From 34bedcf91238b19ab1730d762fdceb1d9c06c8dd Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 26 Apr 2022 13:06:44 -0600 Subject: [PATCH 001/174] Add the CLIP ResNet 50x4 model --- captum/optim/models/__init__.py | 9 + .../models/_image/clip_resnet50x4_image.py | 369 ++++++++++++++++++ .../models/_image/clip_resnet50x4_text.py | 187 +++++++++ .../models/test_clip_resnet50x4_image.py | 146 +++++++ .../optim/models/test_clip_resnet50x4_text.py | 64 +++ 5 files changed, 775 insertions(+) create mode 100644 captum/optim/models/_image/clip_resnet50x4_image.py create mode 100644 captum/optim/models/_image/clip_resnet50x4_text.py create mode 100644 tests/optim/models/test_clip_resnet50x4_image.py create mode 100644 tests/optim/models/test_clip_resnet50x4_text.py diff --git a/captum/optim/models/__init__.py b/captum/optim/models/__init__.py index a970e68ec4..77ffed8e6e 100755 --- a/captum/optim/models/__init__.py +++ b/captum/optim/models/__init__.py @@ -6,9 +6,14 @@ replace_layers, skip_layers, ) +from ._image.clip_resnet50x4_image import CLIP_ResNet50x4Image # noqa: F401 +from ._image.clip_resnet50x4_image import clip_resnet50x4_image # noqa: F401 +from ._image.clip_resnet50x4_text import CLIP_ResNet50x4Text # noqa: F401 +from ._image.clip_resnet50x4_text import clip_resnet50x4_text # noqa: F401 from ._image.inception5h_classes import INCEPTION5H_CLASSES # noqa: F401 from ._image.inception_v1 import InceptionV1, googlenet # noqa: F401 + __all__ = [ "RedirectedReluLayer", "SkipLayer", @@ -19,4 +24,8 @@ "InceptionV1", "googlenet", "INCEPTION5H_CLASSES", + "CLIP_ResNet50x4Image", + "clip_resnet50x4_image", + "CLIP_ResNet50x4Text", + "clip_resnet50x4_text", ] diff --git a/captum/optim/models/_image/clip_resnet50x4_image.py b/captum/optim/models/_image/clip_resnet50x4_image.py new file mode 100644 index 0000000000..b64b9b0699 --- /dev/null +++ b/captum/optim/models/_image/clip_resnet50x4_image.py @@ -0,0 +1,369 @@ +from typing import Optional, Type +from warnings import warn + +import torch +from torch import nn + +from captum.optim.models._common import RedirectedReluLayer, SkipLayer + +GS_SAVED_WEIGHTS_URL = ( + "https://pytorch.s3.amazonaws.com/models/captum/clip_resnet50x4_image.pt" +) + + +def clip_resnet50x4_image( + pretrained: bool = False, + progress: bool = True, + model_path: Optional[str] = None, + **kwargs +) -> "CLIP_ResNet50x4Image": + """ + The visual portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable + Visual Models From Natural Language Supervision': https://arxiv.org/abs/2103.00020 + + This model can be combined with the CLIP ResNet 50x4 Text model to create the full + CLIP ResNet 50x4 model. + + AvgPool2d layers were replaced with AdaptiveAvgPool2d to allow for any input height + and width size, though the best results are obtained by using the model's intended + input height and width of 288x288. + + See here for more details: + https://github.com/openai/CLIP + https://github.com/mlfoundations/open_clip + + Args: + + pretrained (bool, optional): If True, returns a pre-trained model. + Default: False + progress (bool, optional): If True, displays a progress bar of the download to + stderr + Default: True + model_path (str, optional): Optional path for the model file. + Default: None + replace_relus_with_redirectedrelu (bool, optional): If True, return pretrained + model with Redirected ReLU in place of ReLU layers. + Default: *True* when pretrained is True otherwise *False* + use_linear_modules_only (bool, optional): If True, return model + with all nonlinear layers replaced with linear equivalents. + Default: False + transform_input (bool, optional): If True, preprocesses the input according to + the method with which it was trained. + Default: *True* when pretrained is True otherwise *False* + + Returns: + **CLIP_ResNet50x4Image** (CLIP_ResNet50x4Image): A CLIP ResNet 50x4 model's + image portion. + """ + if pretrained: + if "transform_input" not in kwargs: + kwargs["transform_input"] = True + if "replace_relus_with_redirectedrelu" not in kwargs: + kwargs["replace_relus_with_redirectedrelu"] = True + if "use_linear_modules_only" not in kwargs: + kwargs["use_linear_modules_only"] = False + + model = CLIP_ResNet50x4Image(**kwargs) + + if model_path is None: + state_dict = torch.hub.load_state_dict_from_url( + GS_SAVED_WEIGHTS_URL, progress=progress, check_hash=False + ) + else: + state_dict = torch.load(model_path, map_location="cpu") + model.load_state_dict(state_dict) + return model + + return CLIP_ResNet50x4Image(**kwargs) + + +class CLIP_ResNet50x4Image(nn.Module): + """ + The visual portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable + Visual Models From Natural Language Supervision': https://arxiv.org/abs/2103.00020 + """ + __constants__ = ["transform_input"] + + def __init__( + self, + transform_input: bool = False, + replace_relus_with_redirectedrelu: bool = False, + use_linear_modules_only: bool = False, + ) -> None: + """ + Args: + + replace_relus_with_redirectedrelu (bool, optional): If True, return + model with Redirected ReLU in place of ReLU layers. + Default: False + use_linear_modules_only (bool, optional): If True, return model with + all nonlinear layers replaced with linear equivalents. + Default: False + transform_input (bool, optional): If True, preprocesses the input according + to the method with which it was trained on. + Default: False + """ + super().__init__() + if use_linear_modules_only: + activ = SkipLayer + else: + if replace_relus_with_redirectedrelu: + activ = RedirectedReluLayer + else: + activ = nn.ReLU + + self.transform_input = transform_input + + # Stem layers + self.conv1 = nn.Conv2d(3, 40, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(40) + self.relu1 = activ() + self.conv2 = nn.Conv2d(40, 40, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(40) + self.relu2 = activ() + self.conv3 = nn.Conv2d(40, 80, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(80) + self.relu3 = activ() + self.avgpool = nn.AdaptiveAvgPool2d(72) + + # Residual layers + self.layer1 = self._build_layer(80, 80, 4, stride=1, pooling=72, activ=activ) + self.layer2 = self._build_layer(320, 160, 6, stride=2, pooling=36, activ=activ) + self.layer3 = self._build_layer(640, 320, 10, stride=2, pooling=18, activ=activ) + self.layer4 = self._build_layer(1280, 640, 6, stride=2, pooling=9, activ=activ) + + # Attention Pooling + self.attnpool = AttentionPool2d(9, 2560, out_features=640, num_heads=40) + + def _build_layer( + self, + inplanes: int = 80, + planes: int = 80, + blocks: int = 4, + stride: int = 1, + pooling: int = 72, + activ: Type[nn.Module] = nn.ReLU, + ) -> nn.Module: + """ + Residual layer creation helper function. + + Args: + + inplanes (int, optional): The number of input channels / features to use + for the first layer. + Default: 80 + planes (int, optional): The number of output channels / features to use + for the first layer. This variable is then multiplied by 4 to get the + number of input channels / features to use for the subsequent layers. + Default: 80 + blocks (int, optional): The number of Bottleneck layers to create. + Default: 4 + stride (int, optional): The stride value to use for the Bottleneck layers. + Default: 1 + pooling (int, optional): The output size used for nn.AdaptiveAvgPool2d. + Default: 72 + activ (type of nn.Module, optional): The nn.Module class type to use for + activation layers. + Default: nn.ReLU + + Returns: + residual_layer (nn.Sequential): A full residual layer. + """ + layers = [Bottleneck(inplanes, planes, stride, pooling=pooling, activ=activ)] + for _ in range(blocks - 1): + layers += [Bottleneck(planes * 4, planes, pooling=pooling, activ=activ)] + return nn.Sequential(*layers) + + def _transform_input(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): An input tensor to normalize the values of. + + Returns: + x (torch.Tensor): A normalized tensor. + """ + assert x.dim() == 3 or x.dim() == 4 + if self.transform_input: + if x.min() < 0.0 or x.max() > 1.0: + warn("Model input has values outside of the range [0, 1].") + x = x.unsqueeze(0) if x.dim() == 3 else x + x = x - torch.tensor( + [0.48145466, 0.4578275, 0.40821073], device=x.device + ).view(3, 1, 1) + x = x / torch.tensor( + [0.26862954, 0.26130258, 0.27577711], device=x.device + ).view(3, 1, 1) + return x + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): An input tensor to run through the model. + + Returns: + x (torch.Tensor): The model output. + """ + x = self._transform_input(x) + + # Stem layers + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + + # Residual layers + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + # Attention Pooling + x = self.attnpool(x) + return x + + +class Bottleneck(nn.Module): + def __init__( + self, + inplanes: int = 80, + planes: int = 80, + stride: int = 1, + pooling: int = 72, + activ: Type[nn.Module] = nn.ReLU, + ) -> None: + """ + Args: + + inplanes (int, optional): The number of input channels / features to use + for the first layer. + Default: 80 + planes (int, optional): The number of output channels / features to use + for the subsequent layers. + Default: 80 + stride (int, optional): The stride value to use for the Bottleneck layers. + Default: 1 + pooling (int, optional): The output size used for nn.AdaptiveAvgPool2d. + Default: 72 + activ (type of nn.Module, optional): The nn.Module class type to use for + activation layers. + Default: nn.ReLU + """ + super().__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.relu1 = activ() + + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.relu2 = activ() + + self.avgpool = nn.AdaptiveAvgPool2d(pooling) + + self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * 4) + self.relu3 = activ() + + if stride > 1 or inplanes != planes * 4: + self.downsample = nn.Sequential( + nn.AdaptiveAvgPool2d(pooling), + nn.Conv2d(inplanes, planes * 4, kernel_size=1, stride=1, bias=False), + nn.BatchNorm2d(planes * 4), + ) + else: + self.downsample = None + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): An input tensor to run through the module. + + Returns: + x (torch.Tensor): The module output. + """ + assert x.dim() == 4 + if self.downsample is not None: + identity = self.downsample(x) + else: + identity = x.clone() + + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.avgpool(x) + + x = self.bn3(self.conv3(x)) + identity + x = self.relu3(x) + return x + + +class AttentionPool2d(nn.Module): + def __init__( + self, + spacial_size: int = 9, + in_features: int = 2560, + out_features: int = 640, + num_heads: int = 40, + ) -> None: + """ + Args: + + spacial_size (int, optional): The desired size to user for the positional + embedding. + Default: 9 + in_features (int, optional): The desired input size for the nn.Linear + layers. + Default: 2560 + out_features (int, optional): The desired output size for the nn.Linear + layers. + num_heads (int, optional): The number of heads to use. + Default: 40 + """ + super().__init__() + self.positional_embedding = nn.Parameter( + torch.randn(spacial_size**2 + 1, in_features) / in_features**0.5 + ) + self.k_proj = nn.Linear(in_features, in_features) + self.q_proj = nn.Linear(in_features, in_features) + self.v_proj = nn.Linear(in_features, in_features) + self.c_proj = nn.Linear(in_features, out_features) + self.num_heads = num_heads + + @torch.jit.ignore + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): An input tensor to run through the module. + + Returns: + x (torch.Tensor): The module output. + """ + assert x.dim() == 4 + x = x.reshape(*x.shape[:2], -1).permute(2, 0, 1) + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) + x = x + self.positional_embedding[:, None, :] + return torch.nn.functional.multi_head_attention_forward( + query=x, + key=x, + value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat( + [self.q_proj.bias, self.k_proj.bias, self.v_proj.bias] + ), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0.0, + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False, + )[0][0] diff --git a/captum/optim/models/_image/clip_resnet50x4_text.py b/captum/optim/models/_image/clip_resnet50x4_text.py new file mode 100644 index 0000000000..8069b8d74c --- /dev/null +++ b/captum/optim/models/_image/clip_resnet50x4_text.py @@ -0,0 +1,187 @@ +from typing import Optional + +import math +import torch +from torch import nn + + +GS_SAVED_WEIGHTS_URL = ( + "https://pytorch.s3.amazonaws.com/models/captum/clip_resnet50x4_text.pt" +) + + +def clip_resnet50x4_text( + pretrained: bool = False, + progress: bool = True, + model_path: Optional[str] = None, + **kwargs +) -> "CLIP_ResNet50x4Text": + """ + The text portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable + Visual Models From Natural Language Supervision': https://arxiv.org/abs/2103.00020 + + This model can be combined with the CLIP ResNet 50x4 Image model to create the full + CLIP ResNet 50x4 model. + + See here for more details: + https://github.com/openai/CLIP + https://github.com/mlfoundations/open_clip + + Args: + + pretrained (bool, optional): If True, returns a pre-trained model. + Default: False + progress (bool, optional): If True, displays a progress bar of the download to + stderr + Default: True + model_path (str, optional): Optional path for the model file. + Default: None + width (int, optional): The desired width size to use for the model. + Default: 640 + num_heads (int, optional): The number of heads to use for the model. + Default: 10 + num_residual_layers (int, optional): The number of residual layers to use for + each residual attention block in the model. + Default: 12 + content_length (int, optional): The expected size of text inputs to the model. + Default: 77 + vocab_size (int, optional): The size of the vocab used to train the model. + Default: 49408 + + Returns: + **CLIP_ResNet50x4Text** (CLIP_ResNet50x4Text): A CLIP ResNet 50x4 model's text + portion. + """ + if pretrained: + model = CLIP_ResNet50x4Text(**kwargs) + + if model_path is None: + state_dict = torch.hub.load_state_dict_from_url( + GS_SAVED_WEIGHTS_URL, progress=progress, check_hash=False + ) + else: + state_dict = torch.load(model_path, map_location="cpu") + model.load_state_dict(state_dict) + return model + + return CLIP_ResNet50x4Text(**kwargs) + + +class CLIP_ResNet50x4Text(nn.Module): + """ + The text portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable + Visual Models From Natural Language Supervision': https://arxiv.org/abs/2103.00020 + """ + def __init__( + self, + width: int = 640, + num_heads: int = 10, + num_residual_layers: int = 12, + content_length: int = 77, + vocab_size: int = 49408, + ) -> None: + """ + Args: + + width (int, optional): The desired width size to use for the model. + Default: 640 + num_heads (int, optional): The num number of heads to use for the model. + Default: 10 + num_residual_layers (int, optional): The number of residual layers to use + for each residual attention block. + Default: 12 + content_length (int, optional): The expected size of text inputs to the + model. + Default: 77 + vocab_size (int, optional): The size of the vocab used to train the model. + Default: 49408 + """ + super().__init__() + self.transformer = nn.Sequential( + *[ + ResidualAttentionBlock(width, num_heads, content_length) + for _ in range(num_residual_layers) + ] + ) + self.token_embedding = nn.Embedding(vocab_size, width) + self.positional_embedding = nn.Parameter(torch.empty(content_length, width)) + self.ln_final = nn.LayerNorm(width) + self.text_projection = nn.Parameter(torch.empty(width, width)) + + # logit_scale is only used when combining Text & Image models + self.logit_scale = nn.Parameter(torch.ones([]) * math.log(1 / 0.07)) + + def forward(self, text: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): An input tensor to run through the model. + + Returns: + x (torch.Tensor): The model output. + """ + x = self.token_embedding(text) + x = x + self.positional_embedding.to(device=x.device, dtype=x.dtype) + x = self.transformer(x.permute(1, 0, 2)).permute(1, 0, 2) + x = self.ln_final(x) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] + return x @ self.text_projection.to(device=x.device, dtype=x.dtype) + + +class QuickGELU(nn.Module): + """ + OpenAI's models use a slightly different GELU than PyTorch's default GELU. + """ + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): An input tensor to run through the module. + + Returns: + x (torch.Tensor): The module output. + """ + return x * torch.sigmoid(1.702 * x) + + +class ResidualAttentionBlock(nn.Module): + def __init__( + self, width: int = 640, num_heads: int = 10, content_length: int = 77 + ) -> None: + """ + Args: + + width (int, optional): The desired width size to use. + Default: 640 + num_heads (int, optional): The num number of heads to use. + Default: 10 + content_length (int, optional): The desired content_length to use. + Default: 77 + """ + super().__init__() + self.attn = nn.MultiheadAttention(width, num_heads) + self.ln_1 = nn.LayerNorm(width) + self.mlp = nn.Sequential( + nn.Linear(width, width * 4), QuickGELU(), nn.Linear(width * 4, width) + ) + self.ln_2 = nn.LayerNorm(width) + self.attn_mask = ( + torch.empty(content_length, content_length).fill_(float("-inf")).triu_(1) + ) + + def attention(self, x: torch.Tensor) -> torch.Tensor: + attn_mask = self.attn_mask.to(device=x.device, dtype=x.dtype) + return self.attn(x, x, x, need_weights=False, attn_mask=attn_mask)[0] + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): An input tensor to run through the module. + + Returns: + x (torch.Tensor): The module output. + """ + x = x + self.attention(self.ln_1(x)) + return x + self.mlp(self.ln_2(x)) diff --git a/tests/optim/models/test_clip_resnet50x4_image.py b/tests/optim/models/test_clip_resnet50x4_image.py new file mode 100644 index 0000000000..aae050646f --- /dev/null +++ b/tests/optim/models/test_clip_resnet50x4_image.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 +import unittest +from typing import Type + +import torch + +from captum.optim.models import clip_resnet50x4_image +from captum.optim.models._common import RedirectedReluLayer, SkipLayer +from tests.helpers.basic import BaseTest, assertTensorAlmostEqual +from tests.optim.helpers.models import check_layer_in_model + + +class TestCLIPResNet50x4Image(BaseTest): + def test_load_clip_resnet50x4_image_with_redirected_relu(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping load pretrained CLIP ResNet 50x4 Image due to insufficient" + + " Torch version." + ) + model = clip_resnet50x4_image( + pretrained=True, replace_relus_with_redirectedrelu=True + ) + self.assertTrue(check_layer_in_model(model, RedirectedReluLayer)) + + def test_load_clip_resnet50x4_image_no_redirected_relu(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping load pretrained CLIP ResNet 50x4 Image RedirectedRelu test" + + " due to insufficient Torch version." + ) + model = clip_resnet50x4_image( + pretrained=True, replace_relus_with_redirectedrelu=False + ) + self.assertFalse(check_layer_in_model(model, RedirectedReluLayer)) + self.assertTrue(check_layer_in_model(model, torch.nn.ReLU)) + + def test_load_clip_resnet50x4_image_linear(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping load pretrained CLIP ResNet 50x4 Image linear test due to" + + " insufficient Torch version." + ) + model = clip_resnet50x4_image(pretrained=True, use_linear_modules_only=True) + self.assertFalse(check_layer_in_model(model, RedirectedReluLayer)) + self.assertFalse(check_layer_in_model(model, torch.nn.ReLU)) + self.assertTrue(check_layer_in_model(model, SkipLayer)) + + def test_clip_resnet50x4_image_transform(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping CLIP ResNet 50x4 Image internal transform test due to" + + " insufficient Torch version." + ) + x = torch.randn(1, 3, 288, 288).clamp(0, 1) + model = clip_resnet50x4_image(pretrained=True) + output = model._transform_input(x) + expected_output = x.clone() - torch.tensor( + [0.48145466, 0.4578275, 0.40821073] + ).view(3, 1, 1) + expected_output = expected_output / torch.tensor( + [0.26862954, 0.26130258, 0.27577711] + ).view(3, 1, 1) + assertTensorAlmostEqual(self, output, expected_output, 0) + + def test_clip_resnet50x4_image_transform_warning(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping CLIP ResNet 50x4 Image internal transform warning test due" + + " to insufficient Torch version." + ) + x = torch.stack( + [torch.ones(3, 112, 112) * -1, torch.ones(3, 112, 112) * 2], dim=0 + ) + model = clip_resnet50x4_image(pretrained=True) + with self.assertWarns(UserWarning): + model._transform_input(x) + + def test_clip_resnet50x4_image_load_and_forward(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping basic pretrained CLIP ResNet 50x4 Image forward test due to" + + " insufficient Torch version." + ) + x = torch.zeros(1, 3, 288, 288) + model = clip_resnet50x4_image(pretrained=True) + output = model(x) + self.assertEqual(list(output.shape), [1, 640]) + + def test_untrained_clip_resnet50x4_image_load_and_forward(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping basic untrained CLIP ResNet 50x4 Image forward test due to" + + " insufficient Torch version." + ) + x = torch.zeros(1, 3, 288, 288) + model = clip_resnet50x4_image(pretrained=False) + output = model(x) + self.assertEqual(list(output.shape), [1, 640]) + + def test_clip_resnet50x4_image_load_and_forward_diff_sizes(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Image forward with different" + + " sized inputs test due to insufficient Torch version." + ) + x = torch.zeros(1, 3, 512, 512) + x2 = torch.zeros(1, 3, 126, 224) + model = clip_resnet50x4_image(pretrained=True) + + output = model(x) + output2 = model(x2) + + self.assertEqual(list(output.shape), [1, 640]) + self.assertEqual(list(output2.shape), [1, 640]) + + def test_clip_resnet50x4_image_forward_cuda(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Image forward CUDA test due to" + + " insufficient Torch version." + ) + if not torch.cuda.is_available(): + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Image forward CUDA test due to" + + " not supporting CUDA." + ) + x = torch.zeros(1, 3, 224, 224).cuda() + model = clip_resnet50x4_image(pretrained=True).cuda() + output = model(x) + + self.assertTrue(output.is_cuda) + self.assertEqual(list(output.shape), [1, 640]) + + def test_clip_resnet50x4_image_jit_module_no_redirected_relu(self) -> None: + if torch.__version__ <= "1.8.0": + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Image load & JIT module with" + + " no redirected relu test due to insufficient Torch version." + ) + x = torch.zeros(1, 3, 224, 224) + model = clip_resnet50x4_image( + pretrained=True, replace_relus_with_redirectedrelu=False + ) + jit_model = torch.jit.script(model) + output = jit_model(x) + self.assertEqual(list(output.shape), [1, 640]) diff --git a/tests/optim/models/test_clip_resnet50x4_text.py b/tests/optim/models/test_clip_resnet50x4_text.py new file mode 100644 index 0000000000..69352ca277 --- /dev/null +++ b/tests/optim/models/test_clip_resnet50x4_text.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +import unittest + +import torch + +from captum.optim.models import clip_resnet50x4_text +from tests.helpers.basic import BaseTest, assertTensorAlmostEqual + + +class TestCLIPResNet50x4Text(BaseTest): + def test_clip_resnet50x4_text_logit_scale(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping basic pretrained CLIP ResNet 50x4 Text logit scale test due" + + " to insufficient Torch version." + ) + model = clip_resnet50x4_text(pretrained=True) + expected_logit_scale = torch.tensor([4.605170249938965]) + assertTensorAlmostEqual(self, model.logit_scale, expected_logit_scale) + + def test_clip_resnet50x4_text_load_and_forward(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping basic pretrained CLIP ResNet 50x4 Text forward test due to" + + " insufficient Torch version." + ) + # Start & End tokens: 49405, 49406 + x = torch.cat([torch.tensor([49405, 49406]), torch.zeros(77 - 2)]) + x = x.int()[None, :] + model = clip_resnet50x4_text(pretrained=True) + output = model(x) + self.assertEqual(list(output.shape), [1, 640]) + + def test_clip_resnet50x4_text_forward_cuda(self) -> None: + if torch.__version__ <= "1.6.0": + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Text forward CUDA test due to" + + " insufficient Torch version." + ) + if not torch.cuda.is_available(): + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Text forward CUDA test due to" + + " not supporting CUDA." + ) + x = torch.cat([torch.tensor([49405, 49406]), torch.zeros(77 - 2)]).cuda() + x = x.int()[None, :] + model = clip_resnet50x4_text(pretrained=True).cuda() + output = model(x) + + self.assertTrue(output.is_cuda) + self.assertEqual(list(output.shape), [1, 640]) + + def test_clip_resnet50x4_text_jit_module(self) -> None: + if torch.__version__ <= "1.8.0": + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Text load & JIT module" + + " test due to insufficient Torch version." + ) + x = torch.cat([torch.tensor([49405, 49406]), torch.zeros(77 - 2)]) + x = x.int()[None, :] + model = clip_resnet50x4_text(pretrained=True) + jit_model = torch.jit.script(model) + output = jit_model(x) + self.assertEqual(list(output.shape), [1, 640]) From 599d8e1eb668b4c942183eabc053ce11c271c478 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 13 May 2022 15:21:58 -0600 Subject: [PATCH 002/174] Update CLIP model for new testing & linting --- .../models/_image/clip_resnet50x4_image.py | 37 +++++------ .../models/_image/clip_resnet50x4_text.py | 9 +-- .../models/test_clip_resnet50x4_image.py | 62 +++++++++++-------- .../optim/models/test_clip_resnet50x4_text.py | 18 +++--- 4 files changed, 65 insertions(+), 61 deletions(-) diff --git a/captum/optim/models/_image/clip_resnet50x4_image.py b/captum/optim/models/_image/clip_resnet50x4_image.py index b64b9b0699..4fc86a8880 100644 --- a/captum/optim/models/_image/clip_resnet50x4_image.py +++ b/captum/optim/models/_image/clip_resnet50x4_image.py @@ -1,9 +1,8 @@ -from typing import Optional, Type +from typing import Any, Optional, Type from warnings import warn import torch -from torch import nn - +import torch.nn as nn from captum.optim.models._common import RedirectedReluLayer, SkipLayer GS_SAVED_WEIGHTS_URL = ( @@ -15,7 +14,7 @@ def clip_resnet50x4_image( pretrained: bool = False, progress: bool = True, model_path: Optional[str] = None, - **kwargs + **kwargs: Any, ) -> "CLIP_ResNet50x4Image": """ The visual portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable @@ -24,9 +23,8 @@ def clip_resnet50x4_image( This model can be combined with the CLIP ResNet 50x4 Text model to create the full CLIP ResNet 50x4 model. - AvgPool2d layers were replaced with AdaptiveAvgPool2d to allow for any input height - and width size, though the best results are obtained by using the model's intended - input height and width of 288x288. + Note that model inputs are expected to have a shape of: [B, 3, 288, 288] or + [3, 288, 288]. See here for more details: https://github.com/openai/CLIP @@ -82,6 +80,7 @@ class CLIP_ResNet50x4Image(nn.Module): The visual portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable Visual Models From Natural Language Supervision': https://arxiv.org/abs/2103.00020 """ + __constants__ = ["transform_input"] def __init__( @@ -124,13 +123,13 @@ def __init__( self.conv3 = nn.Conv2d(40, 80, kernel_size=3, padding=1, bias=False) self.bn3 = nn.BatchNorm2d(80) self.relu3 = activ() - self.avgpool = nn.AdaptiveAvgPool2d(72) + self.avgpool = nn.AvgPool2d(2) # Residual layers - self.layer1 = self._build_layer(80, 80, 4, stride=1, pooling=72, activ=activ) - self.layer2 = self._build_layer(320, 160, 6, stride=2, pooling=36, activ=activ) - self.layer3 = self._build_layer(640, 320, 10, stride=2, pooling=18, activ=activ) - self.layer4 = self._build_layer(1280, 640, 6, stride=2, pooling=9, activ=activ) + self.layer1 = self._build_layer(80, 80, blocks=4, stride=1, activ=activ) + self.layer2 = self._build_layer(320, 160, blocks=6, stride=2, activ=activ) + self.layer3 = self._build_layer(640, 320, blocks=10, stride=2, activ=activ) + self.layer4 = self._build_layer(1280, 640, blocks=6, stride=2, activ=activ) # Attention Pooling self.attnpool = AttentionPool2d(9, 2560, out_features=640, num_heads=40) @@ -141,7 +140,6 @@ def _build_layer( planes: int = 80, blocks: int = 4, stride: int = 1, - pooling: int = 72, activ: Type[nn.Module] = nn.ReLU, ) -> nn.Module: """ @@ -160,8 +158,6 @@ def _build_layer( Default: 4 stride (int, optional): The stride value to use for the Bottleneck layers. Default: 1 - pooling (int, optional): The output size used for nn.AdaptiveAvgPool2d. - Default: 72 activ (type of nn.Module, optional): The nn.Module class type to use for activation layers. Default: nn.ReLU @@ -169,9 +165,9 @@ def _build_layer( Returns: residual_layer (nn.Sequential): A full residual layer. """ - layers = [Bottleneck(inplanes, planes, stride, pooling=pooling, activ=activ)] + layers = [Bottleneck(inplanes, planes, stride, activ=activ)] for _ in range(blocks - 1): - layers += [Bottleneck(planes * 4, planes, pooling=pooling, activ=activ)] + layers += [Bottleneck(planes * 4, planes, activ=activ)] return nn.Sequential(*layers) def _transform_input(self, x: torch.Tensor) -> torch.Tensor: @@ -230,7 +226,6 @@ def __init__( inplanes: int = 80, planes: int = 80, stride: int = 1, - pooling: int = 72, activ: Type[nn.Module] = nn.ReLU, ) -> None: """ @@ -244,8 +239,6 @@ def __init__( Default: 80 stride (int, optional): The stride value to use for the Bottleneck layers. Default: 1 - pooling (int, optional): The output size used for nn.AdaptiveAvgPool2d. - Default: 72 activ (type of nn.Module, optional): The nn.Module class type to use for activation layers. Default: nn.ReLU @@ -259,7 +252,7 @@ def __init__( self.bn2 = nn.BatchNorm2d(planes) self.relu2 = activ() - self.avgpool = nn.AdaptiveAvgPool2d(pooling) + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) self.bn3 = nn.BatchNorm2d(planes * 4) @@ -267,7 +260,7 @@ def __init__( if stride > 1 or inplanes != planes * 4: self.downsample = nn.Sequential( - nn.AdaptiveAvgPool2d(pooling), + nn.AvgPool2d(stride), nn.Conv2d(inplanes, planes * 4, kernel_size=1, stride=1, bias=False), nn.BatchNorm2d(planes * 4), ) diff --git a/captum/optim/models/_image/clip_resnet50x4_text.py b/captum/optim/models/_image/clip_resnet50x4_text.py index 8069b8d74c..66cb58ce69 100644 --- a/captum/optim/models/_image/clip_resnet50x4_text.py +++ b/captum/optim/models/_image/clip_resnet50x4_text.py @@ -1,8 +1,8 @@ -from typing import Optional - import math +from typing import Any, Optional + import torch -from torch import nn +import torch.nn as nn GS_SAVED_WEIGHTS_URL = ( @@ -14,7 +14,7 @@ def clip_resnet50x4_text( pretrained: bool = False, progress: bool = True, model_path: Optional[str] = None, - **kwargs + **kwargs: Any, ) -> "CLIP_ResNet50x4Text": """ The text portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable @@ -72,6 +72,7 @@ class CLIP_ResNet50x4Text(nn.Module): The text portion of OpenAI's ResNet 50x4 CLIP model from 'Learning Transferable Visual Models From Natural Language Supervision': https://arxiv.org/abs/2103.00020 """ + def __init__( self, width: int = 640, diff --git a/tests/optim/models/test_clip_resnet50x4_image.py b/tests/optim/models/test_clip_resnet50x4_image.py index aae050646f..beb3d33595 100644 --- a/tests/optim/models/test_clip_resnet50x4_image.py +++ b/tests/optim/models/test_clip_resnet50x4_image.py @@ -1,18 +1,17 @@ #!/usr/bin/env python3 import unittest -from typing import Type import torch - from captum.optim.models import clip_resnet50x4_image from captum.optim.models._common import RedirectedReluLayer, SkipLayer +from packaging import version from tests.helpers.basic import BaseTest, assertTensorAlmostEqual from tests.optim.helpers.models import check_layer_in_model class TestCLIPResNet50x4Image(BaseTest): def test_load_clip_resnet50x4_image_with_redirected_relu(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping load pretrained CLIP ResNet 50x4 Image due to insufficient" + " Torch version." @@ -23,7 +22,7 @@ def test_load_clip_resnet50x4_image_with_redirected_relu(self) -> None: self.assertTrue(check_layer_in_model(model, RedirectedReluLayer)) def test_load_clip_resnet50x4_image_no_redirected_relu(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping load pretrained CLIP ResNet 50x4 Image RedirectedRelu test" + " due to insufficient Torch version." @@ -35,7 +34,7 @@ def test_load_clip_resnet50x4_image_no_redirected_relu(self) -> None: self.assertTrue(check_layer_in_model(model, torch.nn.ReLU)) def test_load_clip_resnet50x4_image_linear(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping load pretrained CLIP ResNet 50x4 Image linear test due to" + " insufficient Torch version." @@ -46,7 +45,7 @@ def test_load_clip_resnet50x4_image_linear(self) -> None: self.assertTrue(check_layer_in_model(model, SkipLayer)) def test_clip_resnet50x4_image_transform(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping CLIP ResNet 50x4 Image internal transform test due to" + " insufficient Torch version." @@ -63,20 +62,20 @@ def test_clip_resnet50x4_image_transform(self) -> None: assertTensorAlmostEqual(self, output, expected_output, 0) def test_clip_resnet50x4_image_transform_warning(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping CLIP ResNet 50x4 Image internal transform warning test due" + " to insufficient Torch version." ) x = torch.stack( - [torch.ones(3, 112, 112) * -1, torch.ones(3, 112, 112) * 2], dim=0 + [torch.ones(3, 288, 288) * -1, torch.ones(3, 288, 288) * 2], dim=0 ) model = clip_resnet50x4_image(pretrained=True) with self.assertWarns(UserWarning): model._transform_input(x) def test_clip_resnet50x4_image_load_and_forward(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping basic pretrained CLIP ResNet 50x4 Image forward test due to" + " insufficient Torch version." @@ -87,7 +86,7 @@ def test_clip_resnet50x4_image_load_and_forward(self) -> None: self.assertEqual(list(output.shape), [1, 640]) def test_untrained_clip_resnet50x4_image_load_and_forward(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping basic untrained CLIP ResNet 50x4 Image forward test due to" + " insufficient Torch version." @@ -97,24 +96,21 @@ def test_untrained_clip_resnet50x4_image_load_and_forward(self) -> None: output = model(x) self.assertEqual(list(output.shape), [1, 640]) - def test_clip_resnet50x4_image_load_and_forward_diff_sizes(self) -> None: - if torch.__version__ <= "1.6.0": + def test_clip_resnet50x4_image_warning(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( - "Skipping pretrained CLIP ResNet 50x4 Image forward with different" - + " sized inputs test due to insufficient Torch version." + "Skipping pretrained CLIP ResNet 50x4 Image transform input" + + " warning test due to insufficient Torch version." ) - x = torch.zeros(1, 3, 512, 512) - x2 = torch.zeros(1, 3, 126, 224) + x = torch.stack( + [torch.ones(3, 288, 288) * -1, torch.ones(3, 288, 288) * 2], dim=0 + ) model = clip_resnet50x4_image(pretrained=True) - - output = model(x) - output2 = model(x2) - - self.assertEqual(list(output.shape), [1, 640]) - self.assertEqual(list(output2.shape), [1, 640]) + with self.assertWarns(UserWarning): + _ = model._transform_input(x) def test_clip_resnet50x4_image_forward_cuda(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping pretrained CLIP ResNet 50x4 Image forward CUDA test due to" + " insufficient Torch version." @@ -124,7 +120,7 @@ def test_clip_resnet50x4_image_forward_cuda(self) -> None: "Skipping pretrained CLIP ResNet 50x4 Image forward CUDA test due to" + " not supporting CUDA." ) - x = torch.zeros(1, 3, 224, 224).cuda() + x = torch.zeros(1, 3, 288, 288).cuda() model = clip_resnet50x4_image(pretrained=True).cuda() output = model(x) @@ -132,15 +128,29 @@ def test_clip_resnet50x4_image_forward_cuda(self) -> None: self.assertEqual(list(output.shape), [1, 640]) def test_clip_resnet50x4_image_jit_module_no_redirected_relu(self) -> None: - if torch.__version__ <= "1.8.0": + if version.parse(torch.__version__) <= version.parse("1.8.0"): raise unittest.SkipTest( "Skipping pretrained CLIP ResNet 50x4 Image load & JIT module with" + " no redirected relu test due to insufficient Torch version." ) - x = torch.zeros(1, 3, 224, 224) + x = torch.zeros(1, 3, 288, 288) model = clip_resnet50x4_image( pretrained=True, replace_relus_with_redirectedrelu=False ) jit_model = torch.jit.script(model) output = jit_model(x) self.assertEqual(list(output.shape), [1, 640]) + + def test_clip_resnet50x4_image_jit_module_with_redirected_relu(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.8.0"): + raise unittest.SkipTest( + "Skipping pretrained CLIP ResNet 50x4 Image load & JIT module with" + + " redirected relu test due to insufficient Torch version." + ) + x = torch.zeros(1, 3, 288, 288) + model = clip_resnet50x4_image( + pretrained=True, replace_relus_with_redirectedrelu=True + ) + jit_model = torch.jit.script(model) + output = jit_model(x) + self.assertEqual(list(output.shape), [1, 640]) diff --git a/tests/optim/models/test_clip_resnet50x4_text.py b/tests/optim/models/test_clip_resnet50x4_text.py index 69352ca277..3d7f9d7cd5 100644 --- a/tests/optim/models/test_clip_resnet50x4_text.py +++ b/tests/optim/models/test_clip_resnet50x4_text.py @@ -2,37 +2,37 @@ import unittest import torch - from captum.optim.models import clip_resnet50x4_text +from packaging import version from tests.helpers.basic import BaseTest, assertTensorAlmostEqual class TestCLIPResNet50x4Text(BaseTest): def test_clip_resnet50x4_text_logit_scale(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping basic pretrained CLIP ResNet 50x4 Text logit scale test due" + " to insufficient Torch version." ) model = clip_resnet50x4_text(pretrained=True) - expected_logit_scale = torch.tensor([4.605170249938965]) + expected_logit_scale = torch.tensor(4.605170249938965) assertTensorAlmostEqual(self, model.logit_scale, expected_logit_scale) def test_clip_resnet50x4_text_load_and_forward(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping basic pretrained CLIP ResNet 50x4 Text forward test due to" + " insufficient Torch version." ) # Start & End tokens: 49405, 49406 x = torch.cat([torch.tensor([49405, 49406]), torch.zeros(77 - 2)]) - x = x.int()[None, :] + x = x[None, :].long() model = clip_resnet50x4_text(pretrained=True) output = model(x) self.assertEqual(list(output.shape), [1, 640]) def test_clip_resnet50x4_text_forward_cuda(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping pretrained CLIP ResNet 50x4 Text forward CUDA test due to" + " insufficient Torch version." @@ -43,7 +43,7 @@ def test_clip_resnet50x4_text_forward_cuda(self) -> None: + " not supporting CUDA." ) x = torch.cat([torch.tensor([49405, 49406]), torch.zeros(77 - 2)]).cuda() - x = x.int()[None, :] + x = x[None, :].long() model = clip_resnet50x4_text(pretrained=True).cuda() output = model(x) @@ -51,13 +51,13 @@ def test_clip_resnet50x4_text_forward_cuda(self) -> None: self.assertEqual(list(output.shape), [1, 640]) def test_clip_resnet50x4_text_jit_module(self) -> None: - if torch.__version__ <= "1.8.0": + if version.parse(torch.__version__) <= version.parse("1.8.0"): raise unittest.SkipTest( "Skipping pretrained CLIP ResNet 50x4 Text load & JIT module" + " test due to insufficient Torch version." ) x = torch.cat([torch.tensor([49405, 49406]), torch.zeros(77 - 2)]) - x = x.int()[None, :] + x = x[None, :].long() model = clip_resnet50x4_text(pretrained=True) jit_model = torch.jit.script(model) output = jit_model(x) From f3d3e1d8088c85a79f7da374e987b649a558fba3 Mon Sep 17 00:00:00 2001 From: John Reese Date: Sun, 15 May 2022 12:01:37 -0700 Subject: [PATCH 003/174] deployment of pyfmt with usort 1.0 Summary: This deploys pyfmt with usort 1.0 and the new import merging behavior. Facebook This is part of the final rollout, announced here: https://fb.workplace.com/groups/pyfmt/posts/1011066416197541/ Preemptive SEV: S271899 Hand rolled on devserver and laptops, with binaries hosted on manifold bucket `pyfi_wheels`. Couldn't use MSDK bump due to issue with make_par on sandcastle Macs: https://fb.workplace.com/groups/fbpython/posts/7503431436364825/ pokemon_lift Reviewed By: zertosh Differential Revision: D36394396 fbshipit-source-id: 7cee2a05261e3281fe86360cdb2faa62df1d9a4e --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 48bc6f4057..e03ab29915 100755 --- a/setup.py +++ b/setup.py @@ -73,7 +73,7 @@ def report(*args): "sphinx-autodoc-typehints", "sphinxcontrib-katex", "mypy>=0.760", - "usort==0.6.4", + "usort==1.0.2", "ufmt", "scikit-learn", "annoy", From 33d2b75ffad8413beec8b29836b5873dcf487965 Mon Sep 17 00:00:00 2001 From: John Reese Date: Sun, 15 May 2022 12:53:03 -0700 Subject: [PATCH 004/174] apply import merging for fbcode (8 of 11) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Summary: Applies new import merging and sorting from µsort v1.0. When merging imports, µsort will make a best-effort to move associated comments to match merged elements, but there are known limitations due to the diynamic nature of Python and developer tooling. These changes should not produce any dangerous runtime changes, but may require touch-ups to satisfy linters and other tooling. Note that µsort uses case-insensitive, lexicographical sorting, which results in a different ordering compared to isort. This provides a more consistent sorting order, matching the case-insensitive order used when sorting import statements by module name, and ensures that "frog", "FROG", and "Frog" always sort next to each other. For details on µsort's sorting and merging semantics, see the user guide: https://usort.readthedocs.io/en/stable/guide.html#sorting Reviewed By: lisroach Differential Revision: D36402214 fbshipit-source-id: b641bfa9d46242188524d4ae2c44998922a62b4c --- captum/influence/_core/tracincp.py | 4 ++-- captum/influence/_core/tracincp_fast_rand_proj.py | 14 +++++++------- captum/influence/_utils/common.py | 2 +- tests/influence/_core/test_tracin_show_progress.py | 8 +++----- 4 files changed, 13 insertions(+), 15 deletions(-) diff --git a/captum/influence/_core/tracincp.py b/captum/influence/_core/tracincp.py index d3671767ce..d5acc2dfef 100644 --- a/captum/influence/_core/tracincp.py +++ b/captum/influence/_core/tracincp.py @@ -9,11 +9,11 @@ Callable, Iterator, List, + NamedTuple, Optional, - Union, Tuple, - NamedTuple, Type, + Union, ) import torch diff --git a/captum/influence/_core/tracincp_fast_rand_proj.py b/captum/influence/_core/tracincp_fast_rand_proj.py index 66007d9e50..cfbf7b47d4 100644 --- a/captum/influence/_core/tracincp_fast_rand_proj.py +++ b/captum/influence/_core/tracincp_fast_rand_proj.py @@ -1,26 +1,26 @@ #!/usr/bin/env python3 import warnings -from typing import Any, Callable, Iterator, List, Optional, Union, Tuple +from typing import Any, Callable, Iterator, List, Optional, Tuple, Union import torch -from captum._utils.common import _get_module_from_name, _format_inputs +from captum._utils.common import _format_inputs, _get_module_from_name from captum._utils.progress import progress from captum.influence._core.tracincp import ( - TracInCPBase, - KMostInfluentialResults, _influence_route_to_helpers, + KMostInfluentialResults, + TracInCPBase, ) from captum.influence._utils.common import ( + _DatasetFromList, + _get_k_most_influential_helper, _jacobian_loss_wrt_inputs, _load_flexible_state_dict, _tensor_batch_dot, - _get_k_most_influential_helper, - _DatasetFromList, ) from captum.influence._utils.nearest_neighbors import ( - NearestNeighbors, AnnoyNearestNeighbors, + NearestNeighbors, ) from captum.log import log_usage from torch import Tensor diff --git a/captum/influence/_utils/common.py b/captum/influence/_utils/common.py index 28c76ebbc3..10783eaf4c 100644 --- a/captum/influence/_utils/common.py +++ b/captum/influence/_utils/common.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 -from typing import Callable, Optional, Tuple, Union, Any, List +from typing import Any, Callable, List, Optional, Tuple, Union import torch import torch.nn as nn diff --git a/tests/influence/_core/test_tracin_show_progress.py b/tests/influence/_core/test_tracin_show_progress.py index b4af4d3118..5b35352880 100644 --- a/tests/influence/_core/test_tracin_show_progress.py +++ b/tests/influence/_core/test_tracin_show_progress.py @@ -6,15 +6,13 @@ import torch.nn as nn from captum.influence._core.tracincp import TracInCP -from captum.influence._core.tracincp_fast_rand_proj import ( - TracInCPFast, -) +from captum.influence._core.tracincp_fast_rand_proj import TracInCPFast from parameterized import parameterized from tests.helpers.basic import BaseTest from tests.influence._utils.common import ( - get_random_model_and_data, - DataInfluenceConstructor, build_test_name_func, + DataInfluenceConstructor, + get_random_model_and_data, ) From d27e6c2fbe8df0e0ec6061ec4b4e0884efc70ffa Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 17 May 2022 10:16:18 -0600 Subject: [PATCH 005/174] Add CLIP loss objectives --- captum/optim/_core/loss.py | 216 ++++++++++++++++++++++++- captum/optim/_utils/image/common.py | 53 +++++- tests/optim/core/test_loss.py | 159 ++++++++++++++++++ tests/optim/utils/image/test_common.py | 34 ++++ 4 files changed, 460 insertions(+), 2 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 66bb4c40c2..1dca3c50ad 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -5,7 +5,11 @@ import torch import torch.nn as nn -from captum.optim._utils.image.common import _dot_cossim, get_neuron_pos +from captum.optim._utils.image.common import ( + _create_new_vector, + _dot_cossim, + get_neuron_pos, +) from captum.optim._utils.typing import ModuleOutputMapping @@ -837,6 +841,216 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return activations +@loss_wrapper +class L2Mean(BaseLoss): + """ + Simple L2Loss penalty where the mean is used instead of the square root of the + sum. + + Used for CLIP models in https://distill.pub/2021/multimodal-neurons/ as per the + supplementary code: + https://github.com/openai/CLIP-featurevis/blob/master/example_facets.py + """ + + def __init__( + self, + target: torch.nn.Module, + channel_index: Optional[int] = None, + constant: float = 0.5, + batch_index: Optional[int] = None, + ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance. + channel_index (int, optional): Optionally only target a specific channel. + If set to None, all channels with be used. + Default: None + constant (float, optional): Constant value to deduct from the activations. + Default: 0.5 + batch_index (int, optional): The index of activations to optimize if + optimizing a batch of activations. If set to None, defaults to all + activations in the batch. + Default: None + """ + BaseLoss.__init__(self, target, batch_index) + self.constant = constant + self.channel_index = channel_index + + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + activations = targets_to_values[self.target][ + self.batch_index[0] : self.batch_index[1] + ] + if self.channel_index is not None: + activations = activations[:, self.channel_index : self.channel_index + 1] + return ((activations - self.constant) ** 2).mean() + + +@loss_wrapper +class VectorLoss(BaseLoss): + """ + This objective is useful for optimizing towards channel directions. This can + helpful for visualizing models like OpenAI's CLIP. + + This loss objective is similar to the Direction objective, except it computes the + matrix product of the activations and vector, rather than the cosine similarity. + In addition to optimizing towards channel directions, this objective can also + perform a similar role to the ChannelActivation objective by using one-hot 1D + vectors. + + See here for more details: + https://distill.pub/2021/multimodal-neurons/ + https://github.com/openai/CLIP-featurevis/blob/master/example_facets.py + """ + + def __init__( + self, + target: torch.nn.Module, + vec: torch.Tensor, + activation_fn: Optional[Callable] = torch.nn.functional.relu, + move_channel_dim_to_final_dim: bool = True, + batch_index: Optional[int] = None, + ) -> None: + """ + Args: + + target (nn.Module): A target layer instance. + vec (torch.Tensor): A direction vector to use, with a compatible shape for + computing the matrix product of the activations. See torch.matmul for + See torch.matmul for more details on compatible shapes: + https://pytorch.org/docs/stable/generated/torch.matmul.html + By default, vec is expected to share the same size as the channel + dimension of the activations. + activation_fn (Callable, optional): An optional activation function to + apply to the activations before computing the matrix product. If set + to None, then no activation function will be used. + Default: torch.nn.functional.relu + move_channel_dim_to_final_dim (bool, optional): Whether or not to move the + channel dimension to the last dimension before computing the matrix + product. + Default: True + batch_index (int, optional): The index of activations to optimize if + optimizing a batch of activations. If set to None, defaults to all + activations in the batch. + Default: None + """ + BaseLoss.__init__(self, target, batch_index) + self.vec = vec + self.activation_fn = activation_fn + self.move_channel_dim_to_final_dim = move_channel_dim_to_final_dim + + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + activations = targets_to_values[self.target] + activations = activations[self.batch_index[0] : self.batch_index[1]] + return _create_new_vector( + activations, + vec=self.vec, + activation_fn=self.activation_fn, + move_channel_dim_to_final_dim=self.move_channel_dim_to_final_dim, + ).mean() + + +@loss_wrapper +class FacetLoss(BaseLoss): + """ + The Facet loss objective used for Faceted Feature Visualization as described in: + https://distill.pub/2021/multimodal-neurons/#faceted-feature-visualization + https://github.com/openai/CLIP-featurevis/blob/master/example_facets.py + + The FacetLoss objective allows us to steer feature visualization towards a + particular theme / concept. This is done by using the weights from linear probes + trained on the lower layers of a model to discriminate between a certain theme or + concept and generic natural images. + """ + + def __init__( + self, + vec: torch.Tensor, + ultimate_target: torch.nn.Module, + layer_target: Union[torch.nn.Module, List[torch.nn.Module]], + facet_weights: torch.Tensor, + strength: Optional[Union[float, List[float]]] = None, + batch_index: Optional[Union[int, List[int]]] = None, + ) -> None: + """ + Args: + + vec (torch.Tensor): A 1D channel vector. + ultimate_target (nn.Module): The main target layer that we are + visualizing targets from. This is normally the penultimate layer of + the model. + layer_target (nn.Module): A layer that we have facet_weights for. This + target layer should be below the ultimate_target layer in the model. + strength (float, list of float, optional): A list of floats to use for batch + dimension weighting. Default is set to None for no weighting. + Default: None + facet_weights (torch.Tensor): Weighting that steers the objective + towards a particular theme or concept. These weight values should + come from linear probes trained on layers in target_layers. + batch_index (int, optional): The index of the activations to optimize if + optimizing a batch of activations. If set to None, defaults to all + activations in the batch. + Default: None + """ + BaseLoss.__init__(self, [ultimate_target, layer_target], batch_index) + self.ultimate_target = ultimate_target + self.layer_target = layer_target + self.vec = vec + self.strength = strength + assert facet_weights.dim() == 4 or facet_weights.dim() == 2 + self.facet_weights = facet_weights + + def _get_strength(self, batch: int, device: torch.device) -> torch.Tensor: + """ + Calculate batch weighting. + + Args: + + batch (int): The size of the batch dimension to use. + device (torch.device): The device to use. + + Returns: + strength_t (torch.Tensor): A tensor containing the weights to multiply the + different batch dimensions by. + """ + if isinstance(self.strength, (tuple, list)): + strength_t = torch.linspace( + self.strength[0], + self.strength[1], + steps=batch, + device=device, + ) + else: + strength_t = torch.ones([1], device=device) * self.strength + return strength_t[:, None, None, None] + + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + activations_ultimate = targets_to_values[self.ultimate_target] + activations_ultimate = activations_ultimate + new_vec = _create_new_vector(activations_ultimate, self.vec)[ + self.batch_index[0] : self.batch_index[1] + ] + target_activations = targets_to_values[self.layer_target] + + layer_grad = torch.autograd.grad( + outputs=new_vec, + inputs=target_activations, + grad_outputs=torch.ones_like(new_vec), + retain_graph=True, + )[0] + layer = target_activations[self.batch_index[0] : self.batch_index[1]] + + flat_attr = layer * torch.nn.functional.relu(layer_grad.detach()) + if self.facet_weights.dim() == 2 and flat_attr.dim() == 4: + flat_attr = torch.sum(flat_attr, dim=(2, 3)) + + if self.strength: + strength_t = self._get_strength(new_vec.shape[0], flat_attr.device) + flat_attr = strength_t * flat_attr + return torch.sum(flat_attr * self.facet_weights) + + def sum_loss_list( loss_list: List, to_scalar_fn: Callable[[torch.Tensor], torch.Tensor] = torch.mean, diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index f1cdc5f477..31af3169ef 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -1,5 +1,5 @@ import math -from typing import List, Optional, Tuple, Union +from typing import Callable, List, Optional, Tuple, Union import matplotlib.pyplot as plt import numpy as np @@ -363,3 +363,54 @@ def hex2base10(x: str) -> float: * ((1 - (-x - 0.5) * 2) * color_list[1] + (-x - 0.5) * 2 * color_list[0]) ).permute(2, 0, 1) return color_tensor + + +def _create_new_vector( + x: torch.Tensor, + vec: torch.Tensor, + activation_fn: Optional[ + Callable[[torch.Tensor], torch.Tensor] + ] = torch.nn.functional.relu, + move_channel_dim_to_final_dim: bool = True, +) -> torch.Tensor: + """ + Create a vector using a given set of activations and another vector. + This function is intended for use in CLIP related loss objectives. + + https://distill.pub/2021/multimodal-neurons/ + https://github.com/openai/CLIP-featurevis/blob/master/example_facets.py + The einsum equation: "ijkl,j->ikl", used by the paper's associated code is the + same thing as: "[..., C] @ vec", where vec has a shape of 'C'. + + Args: + + x (torch.Tensor): A set of 2d or 4d activations. + vec (torch.Tensor): A direction vector to use, with a compatible shape for + computing the matrix product of the activations. See torch.matmul for + See torch.matmul for more details on compatible shapes: + https://pytorch.org/docs/stable/generated/torch.matmul.html + By default, vec is expected to share the same size as the channel or + feature dimension of the activations. + activation_fn (Callable, optional): An optional activation function to + apply to the activations before computing the matrix product. If set + to None, then no activation function will be used. + Default: torch.nn.functional.relu + move_channel_dim_to_final_dim (bool, optional): Whether or not to move the + channel dimension to the last dimension before computing the matrix + product. + Default: True + + Returns + x (torch.Tensor): A vector created from the input activations and the + stored vector. + """ + assert x.device == vec.device + assert x.dim() > 1 + if activation_fn: + x = activation_fn(x) + if x.dim() > 2 and move_channel_dim_to_final_dim: + permute_vals = [0] + list(range(x.dim()))[2:] + [1] + x = x.permute(*permute_vals) + return torch.mean(x @ vec, [1, 2]) + else: + return (x @ vec)[:, None] diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 49c35ed9d4..4b516e4fa0 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -197,6 +197,165 @@ def test_activation_weights_1(self) -> None: ) +class TestL2Mean(BaseTest): + def test_l2mean_init(self) -> None: + model = torch.nn.Identity() + loss = opt_loss.L2Mean(model) + self.assertEqual(loss.constant, 0.5) + self.assertIsNone(loss.channel_index) + + def test_l2mean_constant(self) -> None: + model = BasicModel_ConvNet_Optim() + constant = 0.5 + loss = opt_loss.L2Mean(model.layer, constant=constant) + output = get_loss_value(model, loss) + + expected = (CHANNEL_ACTIVATION_0_LOSS - constant) ** 2 + self.assertAlmostEqual(output, expected, places=6) + + def test_l2mean_channel_index(self) -> None: + model = BasicModel_ConvNet_Optim() + constant = 0.0 + loss = opt_loss.L2Mean(model.layer, channel_index=0, constant=constant) + output = get_loss_value(model, loss) + + expected = (CHANNEL_ACTIVATION_0_LOSS - constant) ** 2 + self.assertAlmostEqual(output, expected, places=6) + + +class TestVectorLoss(BaseTest): + def test_vectorloss_init(self) -> None: + model = torch.nn.Identity() + vec = torch.tensor([0, 1]).float() + loss = opt_loss.VectorLoss(model, vec=vec) + assertTensorAlmostEqual(self, loss.vec, vec, delta=0.0) + self.assertTrue(loss.move_channel_dim_to_final_dim) + self.assertEqual(loss.activation_fn, torch.nn.functional.relu) + + def test_vectorloss_single_channel(self) -> None: + model = BasicModel_ConvNet_Optim() + vec = torch.tensor([0, 1]).float() + loss = opt_loss.VectorLoss(model.layer, vec=vec) + output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) + self.assertAlmostEqual(output, CHANNEL_ACTIVATION_1_LOSS, places=6) + + def test_vectorloss_multiple_channels(self) -> None: + model = BasicModel_ConvNet_Optim() + vec = torch.tensor([1, 1]).float() + loss = opt_loss.VectorLoss(model.layer, vec=vec) + output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) + self.assertAlmostEqual(output, CHANNEL_ACTIVATION_1_LOSS * 2, places=6) + + +class TestFacetLoss(BaseTest): + def test_facetloss_init(self) -> None: + model = torch.nn.Sequential(torch.nn.Identity(), torch.nn.Identity()) + vec = torch.tensor([0, 1, 0]).float() + facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0], + vec=vec, + facet_weights=facet_weights, + ) + assertTensorAlmostEqual(self, loss.vec, vec, delta=0.0) + assertTensorAlmostEqual(self, loss.facet_weights, facet_weights, delta=0.0) + + def test_facetloss_single_channel(self) -> None: + layer = torch.nn.Conv2d(2, 3, 1, bias=True) + layer.weight.data.fill_(0.1) + layer.bias.data.fill_(1) + model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) + + vec = torch.tensor([0, 1, 0]).float() + facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0].layer, + vec=vec, + facet_weights=facet_weights, + ) + output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) + expected = (CHANNEL_ACTIVATION_0_LOSS * 2) * 1.5 + self.assertAlmostEqual(output, expected / 10.0, places=6) + + def test_facetloss_multi_channel(self) -> None: + layer = torch.nn.Conv2d(2, 3, 1, bias=True) + layer.weight.data.fill_(0.1) + layer.bias.data.fill_(1) + + model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) + + vec = torch.tensor([1, 1, 1]).float() + facet_weights = torch.ones([1, 2, 1, 1]) * 2.0 + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0].layer, + vec=vec, + facet_weights=facet_weights, + ) + output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) + self.assertAlmostEqual(output, 1.560000, places=6) + + def test_facetloss_strength(self) -> None: + layer = torch.nn.Conv2d(2, 3, 1, bias=True) + layer.weight.data.fill_(0.1) + layer.bias.data.fill_(1) + model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) + + vec = torch.tensor([0, 1, 0]).float() + facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + strength = 0.5 + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0].layer, + vec=vec, + facet_weights=facet_weights, + strength=strength, + ) + self.assertEqual(loss.strength, strength) + output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) + self.assertAlmostEqual(output, 0.1950000, places=6) + + def test_facetloss_strength_batch(self) -> None: + layer = torch.nn.Conv2d(2, 3, 1, bias=True) + layer.weight.data.fill_(0.1) + layer.bias.data.fill_(1) + model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) + + vec = torch.tensor([0, 1, 0]).float() + facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + strength = [0.1, 5.05] + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0].layer, + vec=vec, + facet_weights=facet_weights, + strength=strength, + ) + self.assertEqual(loss.strength, strength) + output = get_loss_value(model, loss, input_shape=[4, 3, 6, 6]) + self.assertAlmostEqual(output, 4.017000198364258, places=6) + + def test_facetloss_2d_weights(self) -> None: + layer = torch.nn.Conv2d(2, 3, 1, bias=True) + layer.weight.data.fill_(0.1) + layer.bias.data.fill_(1) + model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) + + vec = torch.tensor([0, 1, 0]).float() + facet_weights = torch.ones([1, 2]) * 1.5 + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0].layer, + vec=vec, + facet_weights=facet_weights, + ) + output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) + expected = (CHANNEL_ACTIVATION_0_LOSS * 2) * 1.5 + self.assertAlmostEqual(output, expected / 10.0, places=6) + + class TestCompositeLoss(BaseTest): def test_negative(self) -> None: model = BasicModel_ConvNet_Optim() diff --git a/tests/optim/utils/image/test_common.py b/tests/optim/utils/image/test_common.py index ef484c7135..fcece26683 100644 --- a/tests/optim/utils/image/test_common.py +++ b/tests/optim/utils/image/test_common.py @@ -516,3 +516,37 @@ def test_make_grid_image_single_tensor_pad_value_jit_module(self) -> None: ) self.assertEqual(list(expected_output.shape), [1, 1, 7, 7]) assertTensorAlmostEqual(self, test_output, expected_output, 0) + + +class TestCreateNewVector(BaseTest): + def test_create_new_vector_one_hot(self) -> None: + x = torch.arange(0, 1 * 3 * 5 * 5).view(1, 3, 5, 5).float() + vec = torch.tensor([0, 1, 0]).float() + out = common._create_new_vector(x, vec) + self.assertEqual(out.item(), 37.0) + + def test_create_new_vector_one_hot_batch(self) -> None: + x = torch.arange(0, 4 * 3 * 5 * 5).view(4, 3, 5, 5).float() + vec = torch.tensor([0, 1, 0]).float() + out = common._create_new_vector(x, vec) + self.assertEqual(out.tolist(), [37.0, 112.0, 187.0, 262.0]) + + def test_create_new_vector(self) -> None: + x = torch.arange(0, 1 * 3 * 5 * 5).view(1, 3, 5, 5).float() + vec = torch.tensor([1, 1, 1]).float() + out = common._create_new_vector(x, vec) + self.assertEqual(out.item(), 111.0) + + def test_create_new_vector_activation_fn(self) -> None: + x = torch.arange(0, 1 * 3 * 5 * 5).view(1, 3, 5, 5).float() + x = x - x.mean() + vec = torch.tensor([1, 0, 1]).float() + out = common._create_new_vector(x, vec, activation_fn=torch.nn.functional.relu) + self.assertEqual(out.item(), 25.0) + + def test_create_new_vector_no_activation_fn(self) -> None: + x = torch.arange(0, 1 * 3 * 5 * 5).view(1, 3, 5, 5).float() + x = x - x.mean() + vec = torch.tensor([1, 1, 1]).float() + out = common._create_new_vector(x, vec, activation_fn=None) + self.assertEqual(out.item(), 0.0) From 77850c7ed2bb6b6065578a2d3fa38aadbfee4d90 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 17 May 2022 11:06:44 -0600 Subject: [PATCH 006/174] Fix Mypy error --- tests/optim/core/test_loss.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 4b516e4fa0..d2cf248bdc 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -263,8 +263,8 @@ def test_facetloss_init(self) -> None: def test_facetloss_single_channel(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.data.fill_(0.1) - layer.bias.data.fill_(1) + layer.weight.fill_(0.1) + layer.bias.fill_(1) model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() @@ -281,8 +281,8 @@ def test_facetloss_single_channel(self) -> None: def test_facetloss_multi_channel(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.data.fill_(0.1) - layer.bias.data.fill_(1) + layer.weight.fill_(0.1) + layer.bias.fill_(1) model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) @@ -299,8 +299,8 @@ def test_facetloss_multi_channel(self) -> None: def test_facetloss_strength(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.data.fill_(0.1) - layer.bias.data.fill_(1) + layer.weight.fill_(0.1) + layer.bias.fill_(1) model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() @@ -319,8 +319,8 @@ def test_facetloss_strength(self) -> None: def test_facetloss_strength_batch(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.data.fill_(0.1) - layer.bias.data.fill_(1) + layer.weight.fill_(0.1) + layer.bias.fill_(1) model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() @@ -339,8 +339,8 @@ def test_facetloss_strength_batch(self) -> None: def test_facetloss_2d_weights(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.data.fill_(0.1) - layer.bias.data.fill_(1) + layer.weight.fill_(0.1) + layer.bias.fill_(1) model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() From a4eee848254611125954cddbf057d063fc16c5c1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 17 May 2022 11:46:17 -0600 Subject: [PATCH 007/174] Fix Mypy errors --- tests/optim/core/test_loss.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index d2cf248bdc..39d8ef4ee1 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -263,8 +263,8 @@ def test_facetloss_init(self) -> None: def test_facetloss_single_channel(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.fill_(0.1) - layer.bias.fill_(1) + layer.weight.data.fill_(0.1) # type: ignore + layer.bias.data.fill_(1) # type: ignore model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() @@ -281,8 +281,8 @@ def test_facetloss_single_channel(self) -> None: def test_facetloss_multi_channel(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.fill_(0.1) - layer.bias.fill_(1) + layer.weight.data.fill_(0.1) # type: ignore + layer.bias.data.fill_(1) # type: ignore model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) @@ -299,8 +299,8 @@ def test_facetloss_multi_channel(self) -> None: def test_facetloss_strength(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.fill_(0.1) - layer.bias.fill_(1) + layer.weight.data.fill_(0.1) # type: ignore + layer.bias.data.fill_(1) # type: ignore model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() @@ -319,8 +319,8 @@ def test_facetloss_strength(self) -> None: def test_facetloss_strength_batch(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.fill_(0.1) - layer.bias.fill_(1) + layer.weight.data.fill_(0.1) # type: ignore + layer.bias.data.fill_(1) # type: ignore model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() @@ -339,8 +339,8 @@ def test_facetloss_strength_batch(self) -> None: def test_facetloss_2d_weights(self) -> None: layer = torch.nn.Conv2d(2, 3, 1, bias=True) - layer.weight.fill_(0.1) - layer.bias.fill_(1) + layer.weight.data.fill_(0.1) # type: ignore + layer.bias.data.fill_(1) # type: ignore model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() From 452979baabd0b9aa709bb199746058084e48fc32 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 17 May 2022 18:04:07 -0600 Subject: [PATCH 008/174] Add Optimization With Transparency tutorial --- ...ptimizationWithTransparency_OptimViz.ipynb | 4425 +++++++++++++++++ 1 file changed, 4425 insertions(+) create mode 100644 tutorials/optimviz/OptimizationWithTransparency_OptimViz.ipynb diff --git a/tutorials/optimviz/OptimizationWithTransparency_OptimViz.ipynb b/tutorials/optimviz/OptimizationWithTransparency_OptimViz.ipynb new file mode 100644 index 0000000000..5c73dd2ed7 --- /dev/null +++ b/tutorials/optimviz/OptimizationWithTransparency_OptimViz.ipynb @@ -0,0 +1,4425 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "OptimizationWithTransparency_OptimViz.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "370a9f4d87814515a51144d26a9ca8b3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_fbec190edc884c0aa2342d4c278bc7c6", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_11f67942024d4e3098a9e7d88b0b144d", + "IPY_MODEL_58498c78f5a046a8853c954d6bcb264f", + "IPY_MODEL_2db7e08b9242423c85928c537e7f300d" + ] + } + }, + "fbec190edc884c0aa2342d4c278bc7c6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "11f67942024d4e3098a9e7d88b0b144d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_05f2bd3ad5f14f698bef478c33eeb2b1", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": "100%", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_7efa32283f78475c994a3c20011f017d" + } + }, + "58498c78f5a046a8853c954d6bcb264f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_97e90f93bdff4cdb84ed7616f9b2fa08", + "_dom_classes": [], + "description": "", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 512, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 512, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_73adf96fa6c84b608c2a6927a5347414" + } + }, + "2db7e08b9242423c85928c537e7f300d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_4afd2911641f44278eeb8dae71721be8", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 512/512 [00:25<00:00, 20.20 step/s, Objective=-940.6]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_a6fa5361b97d4790a7ed78c928612fd6" + } + }, + "05f2bd3ad5f14f698bef478c33eeb2b1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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" + } + }, + "7efa32283f78475c994a3c20011f017d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "97e90f93bdff4cdb84ed7616f9b2fa08": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "", + "_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" + } + }, + "73adf96fa6c84b608c2a6927a5347414": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "4afd2911641f44278eeb8dae71721be8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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" + } + }, + "a6fa5361b97d4790a7ed78c928612fd6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "a98966a99b5b41bc8559e8046b96969f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "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_3f4c72541ad84ff0b05071d020cd2f0a", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_5de4bf65e4cf4492aa2f35bb7bcd5167", + "IPY_MODEL_c0fcfadc6d1e4596b9b3a88f1e6d0a0f", + "IPY_MODEL_31fe21e26c214532aeb4844f009e92f0" + ] + } + }, + "3f4c72541ad84ff0b05071d020cd2f0a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "5de4bf65e4cf4492aa2f35bb7bcd5167": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_cf4af50e246443a8832eb622bd2b0ddb", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": "100%", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_c615948ca593466fb2602d98da4fb5ef" + } + }, + "c0fcfadc6d1e4596b9b3a88f1e6d0a0f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_911b842b1d374479b06b272674dee5d1", + "_dom_classes": [], + "description": "", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 256, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 256, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_8520b5deb27740d997b4a4a05fe6e493" + } + }, + "31fe21e26c214532aeb4844f009e92f0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_cdd0fd17c90c4a6a9c51036ddf9cde78", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 256/256 [00:09<00:00, 26.77 step/s, Objective=-2799.0]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_9f56ee00c73141fb8294ee315a94f718" + } + }, + "cf4af50e246443a8832eb622bd2b0ddb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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" + } + }, + "c615948ca593466fb2602d98da4fb5ef": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "911b842b1d374479b06b272674dee5d1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "", + "_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" + } + }, + "8520b5deb27740d997b4a4a05fe6e493": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "cdd0fd17c90c4a6a9c51036ddf9cde78": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "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" + } + }, + "9f56ee00c73141fb8294ee315a94f718": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "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 + } + }, + "f7c74f1afcc044d089932873da46fb0c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_550cd2bd52134286b76bccbeef7abcb1", + "IPY_MODEL_8cb148d2cac34c0dacac2470bf1e9425", + "IPY_MODEL_c86de569236942e49689347e283dca4c" + ], + "layout": "IPY_MODEL_c57371c34d724c24beb4349ed2d537c7" + } + }, + "550cd2bd52134286b76bccbeef7abcb1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_969e4090581846f69cd6bf3bf8ad89a4", + "placeholder": "​", + "style": "IPY_MODEL_4bffb6e24fd04f9bb81df1458ef1591c", + "value": "100%" + } + }, + "8cb148d2cac34c0dacac2470bf1e9425": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0de0fbbd2d194cd386a0bd2b018828cb", + "max": 512, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_767f518665f34f4ebf5f9498ff2c9f19", + "value": 512 + } + }, + "c86de569236942e49689347e283dca4c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_46e8522957ac45129b3aee66cdc47f08", + "placeholder": "​", + "style": "IPY_MODEL_f06233ce85924fcb8bba14228f4325ef", + "value": " 512/512 [00:12<00:00, 41.50 step/s, Objective=-292.1]" + } + }, + "c57371c34d724c24beb4349ed2d537c7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "969e4090581846f69cd6bf3bf8ad89a4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4bffb6e24fd04f9bb81df1458ef1591c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0de0fbbd2d194cd386a0bd2b018828cb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "767f518665f34f4ebf5f9498ff2c9f19": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "46e8522957ac45129b3aee66cdc47f08": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f06233ce85924fcb8bba14228f4325ef": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b9b1828c563c4cd184f26fa5590b3f5d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_03a3658f7c2e499f9528d3376ac6b203", + "IPY_MODEL_6717308b8d6148d9a9c8747164b791b6", + "IPY_MODEL_53a11c21782140afa93165abf2f97e76" + ], + "layout": "IPY_MODEL_b91e276e9fb24ebb804eb5605707874b" + } + }, + "03a3658f7c2e499f9528d3376ac6b203": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6dd3c9c30bb246cdbb364456cd1bf5e8", + "placeholder": "​", + "style": "IPY_MODEL_5017968b4ae742d5b8320942b325e707", + "value": "100%" + } + }, + "6717308b8d6148d9a9c8747164b791b6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_92994846e32f4fd4a079444319362f1a", + "max": 512, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_35d3a18dfd08421ba1543031b5fb8cab", + "value": 512 + } + }, + "53a11c21782140afa93165abf2f97e76": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3952b6f664e94cf8ad7edaf249a17d1b", + "placeholder": "​", + "style": "IPY_MODEL_b6e7d16af29a4e43ac54a249e843d973", + "value": " 512/512 [00:12<00:00, 39.40 step/s, Objective=-786.4]" + } + }, + "b91e276e9fb24ebb804eb5605707874b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6dd3c9c30bb246cdbb364456cd1bf5e8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5017968b4ae742d5b8320942b325e707": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "92994846e32f4fd4a079444319362f1a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35d3a18dfd08421ba1543031b5fb8cab": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3952b6f664e94cf8ad7edaf249a17d1b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6e7d16af29a4e43ac54a249e843d973": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cee03ddb22f84eefa613c6446234c6c4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2bb9a8610f0e4d8b91d054cfe9140801", + "IPY_MODEL_f825760c27ee4b80830654f3c02ae65b", + "IPY_MODEL_fafbc35e64814fa4b13e5da2f643dddd" + ], + "layout": "IPY_MODEL_5b9280650f144ff882e0d329ff4cb5bc" + } + }, + "2bb9a8610f0e4d8b91d054cfe9140801": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_084a58aa0af344a2b2a3fcafa838811c", + "placeholder": "​", + "style": "IPY_MODEL_f1f53143baa94a89817ff46acece5054", + "value": "100%" + } + }, + "f825760c27ee4b80830654f3c02ae65b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ddc620d6a2c042789bda344dc94b5017", + "max": 256, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1ed5c534ec334eec8d144f912e6beb23", + "value": 256 + } + }, + "fafbc35e64814fa4b13e5da2f643dddd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_84afeb12ab79493a8aa8e3040323216d", + "placeholder": "​", + "style": "IPY_MODEL_0dbfdbf943244faea948bfafc16c4a2f", + "value": " 256/256 [00:06<00:00, 41.01 step/s, Objective=-2563.6]" + } + }, + "5b9280650f144ff882e0d329ff4cb5bc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "084a58aa0af344a2b2a3fcafa838811c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f1f53143baa94a89817ff46acece5054": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ddc620d6a2c042789bda344dc94b5017": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ed5c534ec334eec8d144f912e6beb23": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "84afeb12ab79493a8aa8e3040323216d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0dbfdbf943244faea948bfafc16c4a2f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "97f8059a1a0f45f795ed677e3b7a653a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0f98ad01cf3d473eadffe691475b39fb", + "IPY_MODEL_f71ac5cdf889431297f604518614ade8", + "IPY_MODEL_022f04c4b4754a90a4910a02d3386106" + ], + "layout": "IPY_MODEL_96c9ebb9cfc047198f97db04c7be8b66" + } + }, + "0f98ad01cf3d473eadffe691475b39fb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb9c56fb447945a3b9c20f52b8bc6748", + "placeholder": "​", + "style": "IPY_MODEL_f90c6c3c80cc49a8846396e11d739b96", + "value": "100%" + } + }, + "f71ac5cdf889431297f604518614ade8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f540a3f6f1dc4f169746510dca7b3691", + "max": 512, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_55af60abb1ca4831bfdaa12185303e79", + "value": 512 + } + }, + "022f04c4b4754a90a4910a02d3386106": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_40cc1ffd1c734f9e800e8a40a234512e", + "placeholder": "​", + "style": "IPY_MODEL_946a6ac6a24d49e39f3248f9936ef592", + "value": " 512/512 [00:13<00:00, 41.13 step/s, Objective=-1352.2]" + } + }, + "96c9ebb9cfc047198f97db04c7be8b66": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb9c56fb447945a3b9c20f52b8bc6748": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f90c6c3c80cc49a8846396e11d739b96": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f540a3f6f1dc4f169746510dca7b3691": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55af60abb1ca4831bfdaa12185303e79": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "40cc1ffd1c734f9e800e8a40a234512e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "946a6ac6a24d49e39f3248f9936ef592": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "95d38ecf0e3f42d285b3b72179601f70": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_323d89c37c62400ca33f194b44ae74d0", + "IPY_MODEL_baf6d0f46126420395bd64ec76a704d6", + "IPY_MODEL_0c99c38f17544da997a575538dd2e5f0" + ], + "layout": "IPY_MODEL_4d3ba63fda70437a9bc0770e6214f1c6" + } + }, + "323d89c37c62400ca33f194b44ae74d0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_99f161d1f27144ec8721c8dd6e841da6", + "placeholder": "​", + "style": "IPY_MODEL_6742449d54ea4997b5b85082b7d12efd", + "value": "100%" + } + }, + "baf6d0f46126420395bd64ec76a704d6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ad0d9e48e7a4a7ba7f66cec35a8eacd", + "max": 512, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d7c6b875af764e0a9aac393bb539acf3", + "value": 512 + } + }, + "0c99c38f17544da997a575538dd2e5f0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_27d1bfac70e64b04925375e57162aaae", + "placeholder": "​", + "style": "IPY_MODEL_cf4d1a9836814fab81ca7688a66d5fab", + "value": " 512/512 [00:12<00:00, 39.01 step/s, Objective=-1222.3]" + } + }, + "4d3ba63fda70437a9bc0770e6214f1c6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "99f161d1f27144ec8721c8dd6e841da6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6742449d54ea4997b5b85082b7d12efd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ad0d9e48e7a4a7ba7f66cec35a8eacd": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7c6b875af764e0a9aac393bb539acf3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "27d1bfac70e64b04925375e57162aaae": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf4d1a9836814fab81ca7688a66d5fab": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3f4b2348efa0443ab3c29300b85f29e8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fe953f251ac24f8b912db5cf4f9864e3", + "IPY_MODEL_5601082b45ce4996acd41e91921243c2", + "IPY_MODEL_82e4a1dbe4944e28bbab6ea2e8ad5661" + ], + "layout": "IPY_MODEL_3137aeea1e504d1f842dd8e65667bc70" + } + }, + "fe953f251ac24f8b912db5cf4f9864e3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e306b531228a441491fbdfccb9522fdc", + "placeholder": "​", + "style": "IPY_MODEL_0317501458264f4e822b3486207f8019", + "value": "100%" + } + }, + "5601082b45ce4996acd41e91921243c2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aeff5916a0e140e3a254d2bf7e2fd60b", + "max": 512, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b3d9810d08b4ce190d7c3a801a345e8", + "value": 512 + } + }, + "82e4a1dbe4944e28bbab6ea2e8ad5661": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f06b61f3847b477487f4359bf855c4d1", + "placeholder": "​", + "style": "IPY_MODEL_55c305b5b8ed407f972fd2b775a5d18c", + "value": " 512/512 [00:12<00:00, 40.96 step/s, Objective=-2751.7]" + } + }, + "3137aeea1e504d1f842dd8e65667bc70": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e306b531228a441491fbdfccb9522fdc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0317501458264f4e822b3486207f8019": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aeff5916a0e140e3a254d2bf7e2fd60b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b3d9810d08b4ce190d7c3a801a345e8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f06b61f3847b477487f4359bf855c4d1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55c305b5b8ed407f972fd2b775a5d18c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Optimizing with Transparency" + ], + "metadata": { + "id": "dnzyC1T_A92P" + } + }, + { + "cell_type": "markdown", + "source": [ + "This tutorial notebook illustrates how to use Captum.optim to render RGBA images when using models trained only on RGB images. This process is known as optimizing with transparency, and more information on it can be found at [the corresponding research paper](https://distill.pub/2018/differentiable-parameterizations/#section-rgba). As we will see below, optimizing with transparency yields important information about the saliency of feature visualizations that regular feature visualizations miss." + ], + "metadata": { + "id": "Vp2ArO9T9wZO" + } + }, + { + "cell_type": "code", + "source": [ + "from typing import Callable, Tuple, List, Optional, Sequence, Union, Dict\n", + "import math\n", + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "import captum.optim as opt\n", + "from captum.optim.models import googlenet\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = googlenet(pretrained=True).to(device)" + ], + "metadata": { + "id": "Tz9CVl-TZ8Ha" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "In addition to a visualization function, we'll define four main helper functions for this tutorial. The first function allows us to create distinct checkerboard backgrounds that let us easily see transparency, and the second function allows for the compositing of RGBA images onto backgrounds. The third function allows us to quickly view RGBA images on multiple distinct backgrounds. The fourth function simply allows us to graph the loss values from our rendering." + ], + "metadata": { + "id": "JsPKNvxKTehk" + } + }, + { + "cell_type": "code", + "source": [ + "ModuleOutputMapping = Dict[torch.nn.Module, Optional[torch.Tensor]]\n", + "\n", + "import matplotlib.pylab as plt\n", + "\n", + "\n", + "def visualize(\n", + " model: torch.nn.Module,\n", + " loss_fn: opt.loss.Loss,\n", + " image: opt.images.ImageParameterization,\n", + " transforms: Optional[Union[torch.nn.Module, List[torch.nn.Module]]] = None,\n", + " n_iter: int = 512,\n", + " lr: float = 0.01,\n", + " return_image_instance: bool = False,\n", + ") -> Tuple[\n", + " Union[opt.images.ImageParameterization, opt.images.ImageTensor], torch.Tensor\n", + "]:\n", + " \"\"\"\n", + " Helper function rendering results.\n", + "\n", + " Args:\n", + " model (nn.Module): A PyTorch model instance.\n", + " loss_function (callable): The loss function to minimize during optimization\n", + " optimization.\n", + " image (ImageParameterization): An image parameterization to render.\n", + " transforms (nn.Module or list of nn.Module, optional): The transforms to use\n", + " for optimization. If set to None then TransformationRobustness() is used.\n", + " Default: None\n", + " n_iter (int, optional): Number of steps to run optimization for.\n", + " Default: 512\n", + " lr: (float, optional): If no optimizer is given, then lr is used as the\n", + " learning rate for the Adam optimizer.\n", + " Default: 0.01\n", + " return_image_instance (bool, optional): Whether or not to return a detached\n", + " tensor or the ImageParameterization instance.\n", + " Default: False\n", + "\n", + " Returns:\n", + " image (torch.Tensor or NaturalImage instance): The results of the rendering.\n", + " history (torch.Tensor): The loss history for the rendering.\n", + " \"\"\"\n", + " assert image().dim() == 4\n", + " if transforms is None:\n", + " transforms = opt.transforms.TransformationRobustness()\n", + " transforms = (\n", + " torch.nn.Sequential(*transforms)\n", + " if isinstance(transforms, (list, tuple))\n", + " else transforms\n", + " )\n", + " obj = opt.InputOptimization(model, loss_fn, image, transforms)\n", + " history = obj.optimize(opt.optimization.n_steps(n_iter, True), lr=lr)\n", + " if return_image_instance:\n", + " return image, history\n", + " else:\n", + " return image().detach(), history\n", + "\n", + "\n", + "def create_checkerboard(\n", + " size: Tuple[int, int],\n", + " channels: int = 3,\n", + " tiles: int = 4,\n", + " colors: List[float] = [1.0, 0.0],\n", + ") -> torch.Tensor:\n", + " \"\"\"\n", + " Create a checkerboard pattern.\n", + "\n", + " Based on Lucid's checkerboard function from here: https://github.com/tensorflow/\n", + " lucid/blob/master/notebooks/differentiable-parameterizations/transparency.ipynb\n", + "\n", + " Args:\n", + "\n", + " size (Tuple[int, int]): The dimensions to use when creating the image, with a\n", + " shape of: [H, W].\n", + " channels (int, optional): The number of image channels to use for the output\n", + " image.\n", + " Default: 3\n", + " tiles (int, optional): The number of tiles to create inside the image.\n", + " Default: 4\n", + " colors (list of float, optional): A list of colors to use for the\n", + " checkerboard.\n", + " Default: [1.0, 0.0]\n", + "\n", + " Returns:\n", + " tensor (torch.Tensor): An NCHW image with a checkerboard pattern.\n", + " \"\"\"\n", + " assert len(size) == 2 and len(colors) == 2\n", + "\n", + " square = torch.ones([math.ceil(float(d / tiles) / 2) for d in size])\n", + " board = torch.tensor([colors * tiles, colors[::-1] * tiles] * tiles)\n", + " scaled = torch.kron(board, square)[: size[0], : size[1]]\n", + " return torch.stack([scaled] * channels)\n", + "\n", + "\n", + "def composite_alpha(\n", + " x: torch.Tensor,\n", + " background: torch.Tensor,\n", + " gamma_to_linear: bool = False,\n", + " linear_to_gamma: bool = True,\n", + ") -> torch.Tensor:\n", + " \"\"\"\n", + " Composite an RGBA NCHW image tensor onto an NCHW image tensor background.\n", + "\n", + " See here for more details:\n", + " https://en.wikipedia.org/wiki/Alpha_compositing\n", + " https://en.wikipedia.org/wiki/Alpha_compositing#Gamma_correction\n", + "\n", + " Args:\n", + "\n", + " x (torch.Tensor): The RGBA image tensor with 4 channels in the format of NCHW.\n", + " background (torch.Tensor): The background NCHW image tensor to use.\n", + " gamma_to_linear (bool, optional): Whether or not to convert the alpha channel\n", + " of the input image from gamma to a linear format.\n", + " Default: False\n", + " linear_to_gamma (bool, optional): Whether or not to convert the output image\n", + " from linear to gamma format.\n", + " Default: True\n", + "\n", + " Returns:\n", + " image (torch.Tensor): The input image composited on top of the background.\n", + " \"\"\"\n", + " assert x.dim() == 4 and x.shape[1] == 4\n", + " assert background.dim() == 4\n", + " assert x.device == background.device\n", + " if gamma_to_linear:\n", + " x[:, :3, ...] = x[:, :3, ...].clone() ** 2.2\n", + " rgb, alpha_channel = x[:, :3, ...], x[:, 3:, ...]\n", + " image = background * (1.0 - alpha_channel) + rgb * alpha_channel\n", + " if linear_to_gamma:\n", + " image = image ** (1.0 / 2.2)\n", + " return image\n", + "\n", + "\n", + "def create_mosaic(\n", + " img: torch.Tensor,\n", + " background: Optional[torch.Tensor] = None,\n", + " num_tiles: int = 4,\n", + " gamma_to_linear: bool = False,\n", + " linear_to_gamma: bool = True,\n", + ") -> torch.Tensor:\n", + " \"\"\"\n", + " Composite an NCHW RGBA image tensor onto 4 distinct backgrounds;\n", + " no background, checkerboard, white, and black backgrounds.\n", + "\n", + " Args:\n", + "\n", + " img (torch.Tensor): An RGBA NCHW image tensor.\n", + " background (torch.Tensor, optional): An NCHW image tensor to use as a\n", + " background for the img input. If set to None, then a checkerboard\n", + " background will be used.\n", + " Default: None\n", + " tiles (int, optional): The number of tiles to use for the checkerboard\n", + " background image. This variable is only used if background is set to None.\n", + " Default: 4\n", + " gamma_to_linear (bool, optional): Whether or not to convert the alpha channel\n", + " of the input image from gamma to a linear format.\n", + " Default: False\n", + " linear_to_gamma (bool, optional): Whether or not to convert the output image\n", + " from linear to gamma format.\n", + " Default: True\n", + "\n", + " Returns:\n", + " mosaic_tensor (torch.Tensor): An NCHW image mosaic showing the img\n", + " input on different backgrounds.\n", + " \"\"\"\n", + " assert img.dim() == 4 and img.shape[1] == 4\n", + " img_list = [img[:, :3]]\n", + "\n", + " # Place visualizations on top of custom or checkerboard image\n", + " if background is None:\n", + " background = (\n", + " create_checkerboard(img.shape[2:], tiles=num_tiles)\n", + " .unsqueeze(0)\n", + " .to(img.device)\n", + " )\n", + "\n", + " img_list.append(\n", + " composite_alpha(\n", + " img,\n", + " background,\n", + " gamma_to_linear=gamma_to_linear,\n", + " linear_to_gamma=linear_to_gamma,\n", + " )\n", + " )\n", + "\n", + " # Place visualization on white background\n", + " img_list.append(\n", + " composite_alpha(\n", + " img,\n", + " torch.ones_like(img[:, :3]),\n", + " gamma_to_linear=gamma_to_linear,\n", + " linear_to_gamma=linear_to_gamma,\n", + " )\n", + " )\n", + "\n", + " # Place visualization on black background\n", + " img_list.append(\n", + " composite_alpha(\n", + " img,\n", + " torch.zeros_like(img[:, :3]),\n", + " gamma_to_linear=gamma_to_linear,\n", + " linear_to_gamma=linear_to_gamma,\n", + " )\n", + " )\n", + " return torch.cat(img_list)\n", + "\n", + "\n", + "def composite_alpha_only(x: torch.Tensor) -> torch.Tensor:\n", + " \"\"\"\n", + " Visualize the alpha channel of an NCHW RGBA image tensor.\n", + "\n", + " Args:\n", + "\n", + " x (torch.Tensor): An RGBA NCHW image tensor.\n", + "\n", + " Returns:\n", + " x (torch.Tensor): An RGB NCHW image tensor for the 4th input image channel.\n", + " \"\"\"\n", + " assert x.dim() == 4 and x.shape[1] == 4\n", + " return torch.ones_like(x[:, :3]) * x[:, 3:]\n", + "\n", + "\n", + "def plot_loss(\n", + " history: Union[torch.Tensor, List[torch.Tensor]],\n", + " figsize: Optional[Union[Tuple[int, int], Tuple[float, float]]] = None,\n", + " title: Optional[str] = None,\n", + " labels: Optional[List[str]] = None,\n", + " axis_names: Optional[List[str]] = [\"Step\", \"Loss\"],\n", + ") -> None:\n", + " \"\"\"\n", + " Helper function for graphing losses.\n", + "\n", + " Args:\n", + "\n", + " history (torch.Tensor or list of torch.Tensor): A set of loss values inside\n", + " the history created from the optimize function.\n", + " figsize (tuple of int or tuple of float, optional): The size of the graph.\n", + " Default: None\n", + " title (str, optional): The title of the graph.\n", + " Default: None\n", + " labels (list of str, optional): A list labels to use if graphing multiple\n", + " history tensors.\n", + " Default: None\n", + " axis_names (list of str): The names to use for the x and y axes, in a format\n", + " of: [x_axis, y_axis].\n", + " Default: [\"Step\", \"Loss\"]\n", + " \"\"\"\n", + " assert len(axis_names) == 2\n", + " if figsize is not None:\n", + " plt.figure(figsize=figsize)\n", + " if not torch.is_tensor(history):\n", + " history = [h.detach().cpu().tolist() for h in history]\n", + " for i, h in enumerate(history):\n", + " label = \"Test \" + str(i + 1) if labels is None else labels[i]\n", + " plt.plot(h, label=label)\n", + " plt.legend()\n", + " else:\n", + " history = history.detach().cpu().tolist()\n", + " plt.plot(history)\n", + " if title is not None:\n", + " plt.title(title)\n", + " if axis_names is not None:\n", + " plt.ylabel(axis_names[1])\n", + " plt.xlabel(axis_names[0])\n", + " plt.show()" + ], + "metadata": { + "id": "GNdef32udfDh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Alpha Compositing\n", + "\n", + "We can verify that our alpha compositing code works by displaying Captum's logo on a custom background. We also show how to load an RGBA image using `ImageTensor`'s `open` function." + ], + "metadata": { + "id": "hJ7H4h6x5O8c" + } + }, + { + "cell_type": "code", + "source": [ + "# Download RGBA & show test image\n", + "img_url = (\n", + " \"https://github.com/pytorch/captum/raw/master/website/static/img/captum_logo.png\"\n", + ")\n", + "captum_logo = opt.images.ImageTensor.open(img_url, mode=\"RGBA\")[None, :].to(device)\n", + "\n", + "print(\"The RGBA image:\")\n", + "opt.images.show(captum_logo, figsize=(6.5, 6.5))\n", + "\n", + "# Show Captum logo with alpha channel only\n", + "print(\n", + " \"\\nThe RGBA image's alpha channel (white represents opaque \\nregions, and black\"\n", + " + \" represents transparent regions):\"\n", + ")\n", + "opt.images.show(composite_alpha_only(captum_logo), figsize=(6.5, 6.5))\n", + "\n", + "# Setup a checkerboard background image with square tiles\n", + "background = create_checkerboard([max(captum_logo.shape[2:])] * 2, tiles=4).to(device)\n", + "background = background[None, :, : captum_logo.shape[2], : captum_logo.shape[3]]\n", + "\n", + "# Make black background tiles blue\n", + "blue_color = torch.tensor([0.0, 0.7071, 0.7071], device=device).view(1, 3, 1, 1)\n", + "background = torch.where(background == 0.0, blue_color, background)\n", + "\n", + "# Show background image\n", + "print(\"\\nOur custom background image:\")\n", + "opt.images.show(background, figsize=(6.5, 6.5))\n", + "\n", + "# Composite logo onto background\n", + "captum_logo_on_background = composite_alpha(\n", + " captum_logo, background, gamma_to_linear=True\n", + ")\n", + "print(\"\\nThe RGBA image on top of the background image:\")\n", + "opt.images.show(captum_logo_on_background, figsize=(6.5, 6.5))" + ], + "metadata": { + "id": "hn_zkqFQ5OZn", + "outputId": "68b4bc28-6e0e-4c1b-bc9d-ac31c899a481", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 592 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The RGBA image:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "The RGBA image's alpha channel (white represents opaque \n", + "regions, and black represents transparent regions):\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Our custom background image:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAABsCAYAAACPb8KhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAD2ElEQVR4nO3aMUtdZxzH8f+5xwQutEIhN5vdlCyWLBccQraSgEPpOyg45F0EHJq3UHDIq9BSKLSbLhIwjoYO4pLYRS4Rot77dGnHqx5I+nj+fD7rWX4envPl4WJTSgkAchrUHgDAlyPyAImJPEBiIg+QmMgDJCbyAIkt3PC8d/9fuXFwEK9PTmrP6OT5aBTb43G0TVN7yq1Nrq7iye5uvJ1Mak/pZHN5OV6urNSe0cmbs7N4urcXH6fT2lNurW2a2BmP49loVHtKJ1vHx/Hi8LD2jM7K+vrceLjJAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYiIPkJjIAyQm8gCJiTxAYgvXPdx+//7/2vHZfHPvXqw/fFh7RiffDofx64cP0dQe0sFFKfF4cTGWhsPaUzop0b9z/ffFRXz/4EFcllJ7yq0NIuKv8/Peveuzy8ve9eMmTbnm4LQ7O/05Vf/aWl2Nn5aWas/o5LfT0/hxfz+mPfqIv15YiD/X1uK7xcXaUzrZPDqKn4+Oas/o5PHiYvyxthZfLVx7J7tTrkqJH/b34/fT09pTOtlYWopfVldrz+isbZq5d8RrT83s82/58pom2vl/7500iIhpKb1639NSYtDDdx3Rv3NdIqLt2bsupUTp2Zn+T5/e8234TR4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARITeYDERB4gMZEHSEzkARJrSilzH756927+wzvq02wWl7NZ7RmdtE0Tw7atPaOz8+k0Ztecn7vo/mAQ9wf9utvMSonz6bT2jM6GbRtt09Se0cnlbBafetaPiIhXjx7NfdHXRj4i+vUFR8TGwUG8PjmpPaOT56NRbI/HvfogJldX8WR3N95OJrWndLK5vBwvV1Zqz+jkzdlZPN3bi489Cn3bNLEzHsez0aj2lE62jo/jxeFh7RmdlfX1ufHo15UGgE5EHiCxm36uAaDH3OQBEhN5gMREHiAxkQdITOQBEhN5gMT+Af1+spSBMgUIAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "The RGBA image on top of the background image:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Basic Optimization Without Transparency\n", + "\n", + "Below we'll start off by performing feature visualization without any sort of transparency." + ], + "metadata": { + "id": "U44pk7xERQ10" + } + }, + { + "cell_type": "code", + "source": [ + "# Set channel optimization target & render visualization\n", + "loss_fn = opt.loss.ChannelActivation(model.mixed4d.conv_3x3_reduce, channel_index=139)\n", + "image = opt.images.NaturalImage((320, 320), channels=3).to(device)\n", + "img_channel, _ = visualize(model, loss_fn, image, n_iter=512, lr=0.02)\n", + "\n", + "# Set neuron optimization target & render visualization\n", + "loss_fn = opt.loss.NeuronActivation(model.mixed4b, channel_index=373)\n", + "image = opt.images.NaturalImage((200, 200), channels=3).to(device)\n", + "img_neuron, _ = visualize(model, loss_fn, image, n_iter=256, lr=0.01)\n", + "\n", + "# Show both visualizations side by side\n", + "img_neuron = F.interpolate(img_neuron, size=(320, 320))\n", + "img_no_alpha = torch.cat([img_channel, img_neuron])\n", + "opt.images.show(img_no_alpha, figsize=(10, 5))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 367, + "referenced_widgets": [ + "370a9f4d87814515a51144d26a9ca8b3", + "fbec190edc884c0aa2342d4c278bc7c6", + "11f67942024d4e3098a9e7d88b0b144d", + "58498c78f5a046a8853c954d6bcb264f", + "2db7e08b9242423c85928c537e7f300d", + "05f2bd3ad5f14f698bef478c33eeb2b1", + "7efa32283f78475c994a3c20011f017d", + "97e90f93bdff4cdb84ed7616f9b2fa08", + "73adf96fa6c84b608c2a6927a5347414", + "4afd2911641f44278eeb8dae71721be8", + "a6fa5361b97d4790a7ed78c928612fd6", + "a98966a99b5b41bc8559e8046b96969f", + "3f4c72541ad84ff0b05071d020cd2f0a", + "5de4bf65e4cf4492aa2f35bb7bcd5167", + "c0fcfadc6d1e4596b9b3a88f1e6d0a0f", + "31fe21e26c214532aeb4844f009e92f0", + "cf4af50e246443a8832eb622bd2b0ddb", + "c615948ca593466fb2602d98da4fb5ef", + "911b842b1d374479b06b272674dee5d1", + "8520b5deb27740d997b4a4a05fe6e493", + "cdd0fd17c90c4a6a9c51036ddf9cde78", + "9f56ee00c73141fb8294ee315a94f718" + ] + }, + "id": "UNnYd0cEtOHN", + "outputId": "76811ff5-48ff-4d42-81d1-0faf56aceaa6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "370a9f4d87814515a51144d26a9ca8b3", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + " 0%| | 0/512 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Looking at the above flower and car tire visualizations, we have no way of determining the importance of each part of the visualization. For example, we cannot easily tell what part of the flower is most important or how important the car body and ground are for tire detection.\n", + "\n", + "This limitation of feature visualization may seem like something unavoidable, however it can be overcome with some clever design!\n", + "\n", + "**Optimizing Additional Degrees of Freedom**\n", + "\n", + "* Feature visualization can yield a ton of information about a target, but by default is unable to work with some of the additional degrees of freedom that targets can have. One such area is the importance or saliency of each part of the visualization. In the case of a model trained on 3 channel RGB images, we can view this additional dimension by adding a 4th channel for alpha transparency to our image parameterization. " + ], + "metadata": { + "id": "NJvEZRQcSCr6" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Alpha Channel / Transparency\n", + "\n", + "**Optimizing With The Additional Alpha Channel**\n", + "\n", + "* Using the 4 channel RGBA image parameterization allows us to see the feature importance based on opacity. The more opaque something is, the more important it is. The more transparent something is, the less important it is.\n", + "\n", + "* The optim module has been designed so that using RGBA images is just as easy as RGB images. For example, `NaturalImage()` handles RGBA images without any changes, other than being initialized with `channels=4`.\n", + "\n", + "* To render a 4 channel visualization using a model that only supports 3 channels, we can use Captum's `BlendAlpha()` on our model input as the final transform. The `BlendAlpha()` transform performs [alpha composing](https://en.wikipedia.org/wiki/Alpha_compositing) which turns the 4 channel RGBA image into a 3 channel RGB image." + ], + "metadata": { + "id": "7GB_ASIOafYx" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Basic optimization with transparency\n", + "\n", + "\n", + "For basic optimization with transparency, we use a simple self balancing equation that avoids producing too much transparency or too much opaqueness:\n", + "\n", + "```\n", + "loss_fn = LossFunction * (1.0 - mean(alpha_channel))\n", + "```\n", + "\n", + "The above equation's alpha channel portion can be performed by using Captum's `opt.loss.ChannelLoss` objective with a channel index of `4` for the alpha channel and `opt.images.NaturalImage` as the target. This is demonstrated below." + ], + "metadata": { + "id": "sSknEhony0hd" + } + }, + { + "cell_type": "code", + "source": [ + "image_size = (320, 320)\n", + "\n", + "# Initialize NaturalImage with 4 channels\n", + "image = opt.images.NaturalImage(image_size, channels=4).to(device)\n", + "\n", + "# Set optimization target\n", + "loss_fn = opt.loss.ChannelActivation(model.mixed4d.conv_3x3_reduce, channel_index=139)\n", + "\n", + "# Use NaturalImage output as target, and collect alpha channel for mean()\n", + "loss_fn = loss_fn * (1.0 - opt.loss.ChannelActivation(image, channel_index=3))\n", + "\n", + "# Blend the alpha channel into the image as our final transform\n", + "transforms = [opt.transforms.TransformationRobustness(), opt.transforms.BlendAlpha()]\n", + "\n", + "# Render the visualization\n", + "img_basic, history_basic = visualize(\n", + " model, loss_fn, image, transforms=transforms, n_iter=512\n", + ")\n", + "\n", + "# Show visualization on multiple backgrounds\n", + "# The backgrounds are as follows: No transparency, checkerboard, white, & black\n", + "opt.images.show(create_mosaic(img_basic), images_per_row=2, figsize=(14, 14))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 824, + "referenced_widgets": [ + "f7c74f1afcc044d089932873da46fb0c", + "550cd2bd52134286b76bccbeef7abcb1", + "8cb148d2cac34c0dacac2470bf1e9425", + "c86de569236942e49689347e283dca4c", + "c57371c34d724c24beb4349ed2d537c7", + "969e4090581846f69cd6bf3bf8ad89a4", + "4bffb6e24fd04f9bb81df1458ef1591c", + "0de0fbbd2d194cd386a0bd2b018828cb", + "767f518665f34f4ebf5f9498ff2c9f19", + "46e8522957ac45129b3aee66cdc47f08", + "f06233ce85924fcb8bba14228f4325ef" + ] + }, + "id": "c6eh8j7Jyz-n", + "outputId": "892702f7-6b67-481c-c2e5-910bfe7b05a2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/512 [00:00" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwcAAAMHCAYAAABsWCtPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZBkV33n+znL3XKvzNqruqo3datb3a2lhRaQECAsCYSMbbCNdxsbDxD2eIlxjN84jO0AG3ue7Tf2jJ8dDOCxWYyxwwNmEUKIAYSE0ILUWlpqdbfU6r32qlzvds55f2RWSbw3Y/TivYiBifxEVERV5a3KzHPPuef7/S03hXOOIUOGDBkyZMiQIUOGDJH/s1/AkCFDhgwZMmTIkCFDvjsYmoMhQ4YMGTJkyJAhQ4YAQ3MwZMiQIUOGDBkyZMiQAUNzMGTIkCFDhgwZMmTIEGBoDoYMGTJkyJAhQ4YMGTJgaA6GDBkyZMiQIUOGDBkCgP6XHhRCDO9zOmTIkCFDhgwZMmTI/2I458R/7/f/ojnY5GdufxeXz+1HJDHtJKU26pEvrCCKAabTxWQOF1YRSlCqxNhMQlWzvLTE2sIKlUqRQMb4VY+zDx1BkGJFTpolTE2W0GEBRqpcXIrJTIQSAtE+w+piRs9YzjRXcVoSBBpPSVIDB2oB0zt3cLYXs7KyjktjKkXN2kYXZTP83OB8HxuGZEKy1uowt61KWTqSboqJU5T28IpFOqsbTDRKqCii0+siRE5U9CmNVDCtnGbeI2llSJMipcELPSZmRhmZqlOduZoLZ84jsyblgsAvFnE2QfoRQXkKKXvYdBGbrqKiGkJonL4EyMBl4FKk6GKzhON/9Vlmrp7Hnw2RZYFU4JyH9K7gk7//Xzh8xQ5mr7+ZMKjTvu9RHv/yCSYmppn/tR+EnqD96GmyjQ71Nx6k9fm7cBhcUsatNSEMENvGMO0XWH7gQURVcabd5UQn5QIaU61w5uIy1iUIYxgNfSajgJKnWMwM1liqUuGHISYskmsPZ3KqRUPdCqJOjx4hxg+wkaIVOLpRle6FReI0pxxphHR004RLapKVbk55XBEKjRD9aah6Pc4tJthahfVOBjLAt4KKy9ixs86zJ5Z5Yd1QKo1SdAIvc+SyxroeZy5OyL0y3dzSiEJ21RqQjnPJ9gIne5rdkSHAkeSWOEsp0qF9cRU9sw0/VYQlD6/kYU4nrC0m1LalpMUNXAaLy3DyYovr9j1D+AYo+K/nQx9+mMneSW6/dhR16MdJ7j7Co08ss78+jZ9moDR6uoF3RY8P/PMf8/O/+j7+9M//mieOHuPAAcUv//IIHzTfx8O/9hFecbvHob2K9VXDN4+mxHM+339VSJB/P1/53DOE8QIz4xLZmONc6xYumy5yvvsYrBYpRaOMbCsTjnWxtsGRB9Y49dij2N4CpaqiNjNLsXiI+FunuCNuUO2dxZlFYumRRFcQRevo8VlONE/SiRfJXAphwNR0idrENPc9+TA2z6j4iiKW3kaTXrlOHGWIrkIkHZrxOotxB6Ui5usVOlmHsZJPKHw8rSlWNCb2yJIMKSIm5rdTrNUxTpG3Y1QoCcplytUqGIfptXGmSTgzBn4ALsALJUIAFpQU2M46IioAEhfnuMyB0KhQkmcgTYpJLdZYsl5Mb3mNLO4SViX+xBTtc8ukGz1kEIAyyE4KyoHy8SslhLO0zlxACijN1sg7MatrGegCYbHM6tI6joQd+3bQPN9ECA/tazAZQoToOKWTbkCphNY+KjfYLEH6BRwCpEDm4AceYS0i7Vp0NSI+nwAOr+rjlX1EanFxDz1dJM81Jk/RvsAPPdKVFBUqzHqCiiRSbV7tJUjonN3A5j0yK6AYEYyW8IsCckd6fh09XkbVIqzJOX/yFO/56z8C4AMf+ABjY2P/33ac/0n86Z/8MQ899CAgkFKw+Tk+AocQEgc4a5FSghBYaxH9AxAIHGCtxTmHFCBEf990CIQQeJ5PmmYI4UC8uKd6WiOkxBqDdRYpBEpJ+k8vUVqRZRlaK7TqHxdgCIoF9uyZ4vtedxnz28YQegQZXY5zkJ49ij+2DbopNs2xpQpesQCbT+vAGQsOhCfBfftr2mLzs4wG73eTOI554BsP8K377uft734nI40Gzrn+e5dy672/HI4fP8573vMecA7rHEoKnAOHA+cwxqA9Ba7/OjafRzgQUmKsRQiBFBIBOCzWOpwTSKVw1uAcSKnx/QJlL2KptYhWPqWwwKEdV7Nv25Xc88SnmJ3ey/ddfi1CaPLc4klJIB1feehr3HbzD+InEq+mETmYVUPaMoSThjzsQaJYPG/J8xZTu5bw9gg8dYiPf/gxXrVnlfm926Gwm+zEMhefbTM93sB1YkQxRE36JNVVvvXEP3Hj7f+a9//un7Gednj9zUWuvGmOB1t7+cqffYg7fmKK+VHNyTNrnIktarTCtZMjePYWvvq1p5ivrFOplcj9edrZbmarHkvJC+hWhWK1RFiR6MgiXEjednzoLz/M6EiVybkpauPThLJB+uwah3sVgvUljG2R+EUWleThlQd4bPlpOnEHa01/vmMxzvTnhzGDqeW+fd7gkEicNQjRXyf9eSKwm+cSkFL2vxCYzbkmBc66rbWolEKqftHK7/3e77Fz166XPc++m/jbv/lb7rzzTqB/TemvF/GSsRP95TgYV629wTGuvzYGYyZEfwylFP1rlLPYwVgZ0x9vsXmRGhyPc/3n4SW/Hzwm6J8v5xwItsZ+cz2LwXUgzdJ/8f29LHNw5aX7uGnv9dhWgvM1JBtQiwkmK9h2h7xlyFUFV/cY0Wv0zq/gxiOWyuOsREuUCz7lCrR6FxibmUXrHp7OUCJnfKqE9EJWXUDDdqAwghd49M7ErGNp99YYCcq0rEP4ijDQyAxe+4oRCo15/HMLlMiRNmC06rPqW8gV1UhipcYUSuTFEsakjI0ElPKM9aU2WS9F+j66XEYUHLvnR8mUohf7KGUplnyiSoHl811GpkboLbVwLiV3OVbCzI4RatNTbL9iHwtL03iuR8lPwTRxeQs/9ClM7kTQxuUVHBZd2oZUDazaBqaNyztAilQWl69wJi/QffxxwthROzBH5YoZTLKM8i5HH7uVsXaHXVdcTmNmN62OYPKRnL3v+HEm33gD57+xTNzeRanmUX/NJdz3z6scvGmU3rGL6CmHv20S5qfZeOIxeq6Cq8UcPX6c8NwKtpNzITN4CByKQEFFaWqeRznQrGUJnpL4SjNSKKHLJTKliZOEycBxmRdQK41z3kh62iOPPC4EGZVGlaBe4vxqh1avQzeNEQqKkUbXBOM7fcy6wxiNVWC6sLdQYiWoUjWSJPMIhc9kqCl4Po3ZGnrKY7YxTaHniFcSFuMCaT7Cjkqdc70F5qNZ9hbHuaRQQQfzZAGMeRFTgaPuZygMzUzQk11qc10KmSSwsCoD1oTP/FSCmChwqnWBxKwzOV9EH67xXCK4ePwIcytfYM90hfyONyDWVtjjOsysW6IrruHSdceOegnP1zgXEVt4YvUe3vHjO7n91mv4zGcf5MyZFYRp0msJfuYHJM/sLbLjxhL75zNOPd6l8LzimluLvOmaW/n0R7r4BZicrHDwsimmL7mJT3/zWsYbj1BVdUYP7YfSOIzA5dOKI19f47F4iciLKM0dZGzXHJXqDPFzjhvKbW52ZRp5ESvKtFWJdX8bYTiPrs0xV59irXuBJGtDICg2FPXJCc69cAZloaokRZEjoxFWpeSCzCiHdWzeZSMeoRR3iXA0KiWcUlS8FM/lhKUiI3MzLJw8i5WaXRM7mN29h2JtBJBoqeh0YirViPFd8wilyHpdjO1S3DWFV4wQ1sdubGBSgwhCio2IbOEiMixgpcL2DC5xSO0RjBdoP7dIOFLEZJa03SPeaBKvbWDyDK9owC+T19vknZjcWJK4TVEpnJTEscMrFdC+IK5O4owlaBRwVtLuCLLcI8skC/kSM7NFxidG6ZZzvKCAFJKk1cWv1nCrHVrdVaK5CaJSEZlkJGtd4m5OoVHBWgkWwmJAZaLcF0IqZH2kTVjwiKoBXqQQWYr0FaIeYqzCWIPU4ClJvpYjCj6dZ9eREXiRwPMV2vcgUHTObOBch7hjsGGIHiviFyU4kK0EV9a4UoA1jlPlZ4G+ObjllluYm5t7OVvDdx2f/Pu/48hj3kDsw4sf8tkXvCBeNAeAMVt6tf+YcyilwDnkYDPti5++iA1DH2stUgq0loON1uB7Hrnt+zLrBL7nMTMzze2338bq6jr33/8Aq6vrhKFPo1Fj28w4hy7dw+c/+Wmunxrj1huuY/eBWZQuIYuvARTJ+X349XFEq0d2fp206SjesA9kXwCAw2WWeCVl7ViHicuLyGqIEOBMXxgIKbZMw6bxAVhfXeNbDz3M5QcO0nvhNN93881Mzc7inMNai+f7W2P6ckzCgw8+iO/pvhGwDjali3M4ZxFCobXCGocYmDZnLVL0TVrfMPSFoxCibyZ0X2whBE4IJAqlA/ygSCEoUpcS4Ry1qMzeqb3ceNlraPbaHN59NVfu3E85koAC6SG0Y3pyjlduP0yAZNX5SAfl7RaXa9ZbLXLdo7GjSBeflVZMr3uGicJTTEzvI/jpPWzzV5jSiqKqImcuZ6VsGRuPcEKACejYDZb0k+x/2/UcvPH1fPGfH+XU2acYLRu2T44wd+MsLzy6m2tv284lpSbZVyF0gv2v2sE149dz9+d77Ng7waG5CbbP7yb39/PshUl2FE+QqgojwW6SyKNUEtQ0LDzf5czFJjvnL2V23w62XbKbYtggP5cyNbPM4fUiDb+INQmdsM5iUGKyWuFk6wzGGZzti1DrTP9n4TCbBtrZLfHaNwYghcIK8aJhdv3z3P+xv1601kgpMXnfzCEHx8oXi1C00ijdP8833XQTVx0+/P9miX/XcP9996Ok7At6YQdT9SXjY6Hv3AVOyG83BwyCELZvCvRgDfSvWXJL3KvBdUpIiZJq6282zfNLn1MgkEIgpcI6u2UerLUDM/HiWja5+Y7v72WZgyjK8cOMNIHqeJGlZ5cIR6qEjRrWi0izGGLItMD0HOniMsYUUS6nLDVeL0UWPVaeP48ulSh4glKQUwo1Qlvy3LJydoleq4M/niFEgXYnxylNMTLMFwpcaMX0gIIWjChBVBes92LiZhNpUrSW5LnFFxmiqCiPhWSdjMSzhCVFo1LB9hJ8K9FIMqlIHeRJwmikKBY0G72YyANPS3wsrtei2+pw4NA4sTSkKqRnMnpxitSWXiejvXaKYmkETxaRWUbSWULTgV6M7YUIeqA9ZHEWFc2BtxPlbD9pgMBYQ4pHEErmf/InefCd72fj0WPgRinsaSCiDJTl1T90Ayf/9n6ypiVvSExWY3JslJm330r3+Abnv/4CUaPK2L7dtE9ZTh2f4vBPXEbzia8Q7hyjePluXKlM++km46+dJxOnKa008S/2yJM1ltaWEVgiIaloicwtrTglMTntTkrgabo+RFpSJMPEXTZaMVE7gKLArzWQMsUgyDOBsY7CxgozYzVcmmNsghGKshTEQpEow2rXsr4QY/GQZZ/USPaPVFiMPSLtg4GiH1EoVXn6aJPxw5exrVpmqlTH6wjWLyR0z6VMZ+BkiXjtCHPFbUxlIdlyl6nxFb55KmP/xBTNTFMIY+peBy+BC5Uao7sr+CdewHVXWWkKTscFZqZgolriniOLpL3zdL0ie665lGuvuYo//oNR1F/fydjeb3LHb72TU4tVnvvoQ4xc+Cq1113JoeJeREPgAoFrSbrnmzz99GP8+O/VcRtPc/mll3Lm1FlOPf8wH/6rdf7sqge45tbtZNJx8vgSF19wlP2A1+6qEW9cz11/9z50ybFjfg/VuSsoVw+g09O0L3yRicmdNHZEbBQc3XiDccZ49JP/zHMnnmdyZpLG/isp7LkKVgWdZ/6BfWkXP8mRrgnCIQixbpGmmSdyCWOT44RJSNxZI8vXeWF1gTYtZBoTeQUwkAJB6GHWL9DqWtRIiA40UbnBZFRDdi7QTXMq5TJpZshFD6scTo2wnJ1CJQI/iHA5JM0e2lc0tk8Rn3aQJNg8wwsVnl9A6AoyrOKHHuSObqtH2s5QVYkbLZDFoHE4YTGZACf6+5DwyBfXseUiwlO4QZTGq5fxAWxG+/wqoa8JSiG9Vpteu4cciZA6oJd3ideaqECiCj4idyTrHWRUplQoEHcd3bU2Lk2ZqE/SO7eILFXwPQeZIU4N0hNkRQ02RHka5YFEov2QbHkVPaFJY4fQAhEq8DVRUdJccmRkFAoKpQ0yM0id4U9VMZlFWIfyVH9jSS3Kk2RWYixkGyku18iqRocCqSXhaBmkRq7GZAZckpNaAb6iOl4jibtk7RSLRHnRy94Uv5sRAoQcZAEGAt8518/WMNAqsu8ctozDQPyzuSF7GjEQO8Y6nB1EwwEh+mJICoGnFUoJjAEhLMYYpOhHT0ulIgcO7OM3f/PXOXLkCTxPsbi4zNraOkGgOXjoUt72Y2/j6FcepNrJWTuXsDYrGR33wLRBVfEacwgFJknJzsekpxYpXL+XfNWiKxKhJKbn6J1OWfrKCmO7fGQlAATkg6htqAcSwfV1CrCytMITjx7hK1+4m7nZaSZ8DzmI+DOIAm9lXAbj950MwuawusH3xm2OeH9slVaDoe4f4QYnSyjZFzmbj21GX53orx2pMCZHCI3vR/heAak8wkIR7YdsC+sEqkxZFPGTHq+cuoHLZ/aTb0hKwuEjSNB0KyGvfOVr8E6vYtMuG2s+2leU64IglCwdaeO6i2SViKnrt+OY5pG7fbzPP0rt8uPc9pO38/zDbVqPPksYnyK4fDtTpQmoDqTehiM5t8FG8zwHrxzFds9y/Q034L54htNHT/NocIY3Tke84tYrWe0GnFxcZXXZoz5WYn91ho32If7bnb/P7J5RgtpVhNXdpHkDkS3QW3+ckfpOClMB3Tzp+52W4ehXHuL4UpM9u+aJ9l1CMD5HvtSjffI4jSQlbwuEMEjpo0RO2VPsHz3ApbP7ePLCk8RJjLMWYyUYMJj+egGMY0vIYgdzR/VFKoAYzA/bd80oKVFSoFR/vhmbYZ1D2E2JKgYecGC4jUXplyU/v+vpxxUE1r2Y/eqbcYexOQKBkHKwF7lvM1fGGhwST3s4LGYQuJAIzCBQ0fdYsh+0ADKT9U2862cNN7M1fZMg+0ENIbcMQX9x9sdcyn5wyIj/n8yB9iNKjRqubPEij5nDu/EnQiSS1skW+apBmybp80ukdRDjNZSvKeSSQsmgnSXrrVEtTuNVBQW3SiAyEIrWyjK9TJB1U5JOi/YLbYTWuCQnRjEzN0IvE4x4TYpZStFXjEeCJ+5fxRuXlLShVAnIraWbdHGBZmZnnUqoWLvYIml3yS72WN/wqfuKUmOEwvYRFpspnW5GURiKBY9MpiAsWmsQFuMcvlbMbSuhKmWKIyUCm1PG4GlHGPgIiiyfepJKY4Y4SXFpi1JNE42OYFfOkq0eQ5c8VDCC8Dog2kAbIRKEr3C6Ri+2rDQ7jFfHCGWZq977Gxx73x/RfPwpCqOO0be+CelHeOZBZg7M4aPYeHCJpa8L/IO7cdZy4i9Po049Q/32PWhPc+YjLV69Zx7tRiB6FXJXHTVfxjUTGnv2oHek9BaWaHYCnluXnIodDo0gZ9L3KUtL1zo24gwSS92TNIWgUQ6oNXxEmtPe6NBrxSwXfE60mrSdIBgp4AtBZhx7tOapYydZuliiUChw4xW72TY3isi7tPM2/3jXMR47vgHC0pjwGC+UGIsatFtQLjpWLq5RUJoRZ9CrKR0kt954I1jFYtOjPF9h5rISk8/CzimPT3z2o1xZq7CzdZ6FzgpPdlN+5myLV/p7KO6bxC0mFFuWMFnBW3+MkX1v4OwLCa3dM7QePkfFbXDL9lGki1h86B/YEx0kc1/l84+c4cjI9fzum/byO++b4tkf/CkK+f2Ibspo1kaP1ahf9tO4O/8Q5W8gb7gZc+TrsLpC48Ah3n75bdzzS7/FdX+ieccdv4BcP8ffnnwQZQR/+sEF3vtvf5Sf/ZVv8IWTCQdeIbntZ2tE8Ri/8akvEJYU0sbs3nkt9W1v4HN3P8fByufZWb2KcPIyHvRmCXTI4eo4FzKPux6/j9HSTq67+bWsbT/M+aRMtPAcB6OLLC3PsjvXGD1PLiJyVSUsbGelNsb4pI9fV0RU6a6HLJzrcGJplWKzQ83TFAslvMgnsT1OL5+llxqEyXhu8Xl2TEwxURkhUYZjS+uEhQpq4wIztRKNyQlsscjKUpurr7oBdfE0Sdqk017Hiyp4qow3UmNmbILuSot2BwoaCrUCUTnCZY6slZBtdFGjFUrjoKzFdbvkuYcOS5BaVCCQWqCUpbfQRoki8cUWsh6Ap/BqRWSkyVdbBH6AiVrQi0FrglqVihNkrVWKYzXqUx7tjR6djS50LI2xIk6k9FaXcX5KoVCjODtKoxQinCLLLPRylEzwlEdUKkCuGdk7QbASsXJmjY1TCxQCSakyQmOqhswMxDl+uUCgfFwO1gVkvRS1ntLLY0TFp1gt4FVL4HsoDHY9Bl8gQ43QGpNa2msxI5eWiM80wdOIoodVAtvL+5tN0yKSHN+BRdDtWlyo6Ugf2QMlDMI3OGm/4z7wPcEgIj1I6m9FLnH99LoVIKVAKYG1/Sj/ppFg828YBG6cGETgQCqJpzUmNyglt/6tlAIpNXmeoyR4nqJaLXHJJfNcfvkuVldXOPXCc7z3vb+B70f8x//0Yf7+k5+ife9jjI3P84af+ynu/8iHOfuJf+K18W3c+sNvhnwBRNh/JXFO/HSX+IxFbx8F41i5a5mRGwp4tZD4NJhTMLeziioX2RTeLhuMh9+P7mJzkJq4l3DPZ7/Elz9/N9WRIsmZc8xEEYHnbRkDOSiDEELAyywvcs5h8xxj+7pECbFVOmKsQSAwxiGkQgqJE30jIpAwEKVKS9RAjyql0EoTBgFZblBKUauMUinVkNKxbWIXjz92H7987Tu5mNY4v3aGsw/dyw3bbyINu8yYBuVYodbOU3IJ1WgHGwst/B11el+/yHQ9IKwUoJfSPXGKyeI2TPdePnPXMteOvolrbn4N429usH7qFmRyFJdk1G2C2DVH4Brw4L0Ifz+84jK45+swVmf8cI1qay9n/vSvmP+diLe+8XaWvxFyupXRbXb55iMLvOv1b+EX/vBrqNUNXv/GCldevo1ms8Y/HH2MbbMN6DWZm30FHTPLxQvn2VU8TiM6gFfbxmOuyDavQEUIzq5d4K4HHmTH5KXc+MM38Iys0EkU1XyDSys54ekp6ipAegGJ8DFBSC+AC2qNP3r7v+fffeJ/48ziGdIkptPrsNbZAGu2zld/DbiBCHX9UpVB6cumMLVbpWAMBCmDUiWBUApfQb45jxB9ATtYOGmWEWnNizVy33tIKdFqIKEFYPrXj83s3IuR+34WxRjzbZF+kw9KEKXsC/3B//Q8Dz2ozHhp9iDP863nemmpUD9j0H8tbpAxcFsm3w5ej+iXc0mJsy/vWv+yzEF+LkVeKggmC4DDK4ZgLKbbIyw4XN3S2WhSFm0KE7tZPNHCpSCkxkpBvL5CknbQRY3L1mg6SZ4rXJ4xUpukIlI2eh1IquTGoKQjqgVcXNzAnjGMT5SZHy/SaWtWWwmrKmB0LKAXt1lqJrhAIwPZHzypSZuGoNogbET0XJN4rUmr2SWaKFO0/RNRkpZ6RTJSL2LSHJdCFHlkGVgjsMKB0wQFjwvPnac4VkdJh+cpkD7NxR4ytFRrY4QaZKARuoFXrqArRbKkhQoydK2IKvaQ+j5I/h7iCs7fCUqBOEApugo/mOWxpuHqoI43WcHJMuvfWsO1n6H+/dcjoxpCCeInniT+yJdxaxpROkjxFT/B2pNN7j36EK8JqjTaDdInN1D3P0eh2CT/TI25d29HTnj9E+lLhKjizh9DtS5hNX6KFXOBNhsYFEJAS0AsvX75lMvBWuLEMlr0mRSGbGGFbi7wvYhX7ZumGEHBgWt2eGF1g4XMkGnL7pGIJRnRdQUOlEJU3MW020TVIs+vtKgEVRpViV/yKfohYkWxkvRoddY5sHeGuBjgqTKVyW3s3L6bWTPFyjfX6NTHueTwHGNTVULpsXtO4JTjrQd+nXEs2Z1HGLvvCRqnT/DF9RP80uQU+Tf+Ft+bJvVGWUOR5WOUn3qS0nHNvc8sct0b97JdNVn65sN84r4v84mV0zzywZ+ndP33c3M9xOSCeNVRGZMc/uqbSO5+Nc9/+uuE+0eZ/ZUbWX9sg6lHAkTvAvYj90D3BeSVDexO2PiL/8hrpgKKl/0k8b//c2782hPsuXyEg7+5l6x6kbf92ic4/0SHvGPYW65xQ6PIT/ziU8hM07GKH/3pSxmdN5w4+ggbDy+zVtvN/XsWKBzehvAmuMQK1LHH+alf+VVSm/KLbznIA+UdLPcMI4sPceDJe7mqejNzbgVvuUbL1snDBq1ijXPlImJHDVPKuXi+hZ+npHGbVrtFwRuhVCoSpYssr59HdgKiyKdeLLDSa6JUTKlYoNU8x+raaZSAUPuMlkPGiz7bZsbw/BBjJdURS2/tNM5axosaHUCpERIWQ57+xlH2vWY/uhQSFIsoCVnPYNpddFlCqMgzRxD4aOewrQTSlNpcDVEqgjG4zOJyg00NuBQ9XcZlOTZ3qNBHF0NcnKKCkDzuUZwYJ222MTbBLyiK45OYbp00cXSWO8S9jDTNsJlgodekVvQRuk6eZuQ00VVHZfsoS88t4RcbaC1BBhgZ4KTC9yStZy+Q9Aw6zrHOw2SaeKNL4HkkWYrwSjjhY6yHTiSdxYRSUZHlDj/18fwyqlFGNnxM2yCEwmkfm1tEBrogUCVJWSiMcUTbKkglcbklbyYIBSQ5MgdRLJHmhriTIjQEQiJsiqp5CBWCAL+3+rI2jO9+xFY5UH8XZfDlsH3ZgrP9CBsOlHxJ5Jr/Z8m+Uoq+xnUotVmzuxn1s5C/mKHwtGZ6eoT3vvf7ufm1Uxx98hi3334r0zPjvOFWn8A/xO5d0/zcL7ydO972w4wIhVKO6449jT3zHNUsxdkuaBB17ngAACAASURBVB+7foT2nU+ijp4mlxOomf3oyj6S1YTTC+cof6mIPjwJp0EebaGLOennQrzbiqAG7zs3uFaMkBlivAbA//lHH+ORbzxCEnexQvKOX383O/fsAQHddrtfIuUHeL7/bWOxWWLy3+1pGIxdZvvju2mvNns2HLJfTjTo2xgUXGOsxfCiKFJKobVGCImyoKRC6ZBrrnsFC4sX2LNrL6+87ia279zFajem+tkihZ2THFgyzFHGdDQzRQVPn0WFCSYoEaceIgXvySUKoeTYeI+Dt+wmXFrlwpFneeTho9x/cZn/8J9/G+Z+k1/xFDZzkAmiCUX0/r2YYztY+twzVK6fQ1QqpC9coHBOQW8dPv40dNYRO8cw+Xnsg59n+84KeuJW8j95D2/cuIj/xkPUbt9O017kT/7LRzDPnCXupuwK5+icy/nYp+5FpD6ZDfj5n3kN+Bkrz56hfapHUJ5gZXqdsH4lZRsx6QxHvvR1PvbxT5E6w4/80B7u1WNkyjJx9hjbFppMNQ7SCFPcuSJdSthqiVZoWQ1iwkrImu3xq7f9O4Tt8PGvfpS7H78HBudGSblV7z6occEN6ugdFmMcanCcGETH+2fb9R8bGG8hBcYMzINS/XKxzWyekmitCfxgyyx8L7LV+uMc1rxoCDbn+db4iH6GZbO8xw5EvVIKjULK/tgwyDo6B0mabvUGbJqwzTIuKSRCCzzhDczBi30EA0s3yHbarUydUgql5KAP5DtnAuFlmoNgzMOrKEAQjkdI4TCrjs5yTrbagZ6jMDJLt5nSenYBz9NI32CNI84V7TxC+IbRMUmvWWB9rYVNMyJtSFo9VlcWWFxq0UwNVjm0hixxFDxFo+ihsGz0LN04RzlHVfgkXkoSOyZna3R7Kb00IypHlIoaCLG5xLZjSBLCUFCvBfg6J806CK1QASghSeOcbs/iaUu3mW1NXM8PUFEJZzIUINsd/FKE9kNkVKLcmMK3g9o8CTKQqEAhPYf0ynjVBnnnOUT3NEKtIYPWYDRXMM8ehVIBWT6CKBzB06/jcGU/zpZARmz7pXfiyiUufOzjpD/251xz538g2P9u5No78FoLhOOHiPYdZOHZNmPNi7y53CNoHceue3hFTTV+gNK2GyjeUoYRiVAQn7Zs3J+QPtBk9A078C+N+Kk/3s/BLy3x2X/6b/zD039IIhSJyegag3KWCEskHUIrWi7nxJrD0zlCS5Q1JIs5Y35ApVxmx47dxKeXMetNQuE413KYFgQyZn3V4JKM8+dW6El4YSnGL1V4w22vQmY5y0sbLC420bkj8wLOxRlqdBKEIAkkXReQFyYpXD3CvkqJo+c0D5+yjISOAyOS2QMhO5uCRQTmjmspXXGA0fuf5zN/90+898LXeLVX4HClRiAFGYZ1s05ImYu2woH1O6msvp7OrmlO7ilz992neejXf5/KHZcgQg9w5O0uSWeJ1smEM//mg1zxmd/iktoMzUdP0btnhekfvInH/u4PuOpHKvCJ98PFNmwEyKMPMRIVELe9lfyfPsDF8ycpz8L4YY/Sdk33kYy1b25weHfIu37xAMvLKb/01mcYcSGjr/5FLhz5GBMH/g1PPHo/5+75M26crnLvxmG2HfphbHWO8W8d5dmvfZ4jD95F7jKunr2Rx655OxcXC/hPfZ0dboPDt/wcX/v7O/kBdZD16jZyFbJRqbDeKKNHDKNFyYmJIkmSU7OQ+Irnm4qzzc/RWzrOqK8w5EzXRynrkIutnGebG6TGMKklCEVqU9Ispuppso6hKSucOpVQr9YoFyNI2xRcl6MrKYQ1tpWKrK8rslaLPVdfRiojSpM+bj1D5BIv0oQjGhX4uDxGyZC8mWKEQAURfqDBGwggqXHCYHODy8Avl+iebqFLAUpbhJL9UGYYYdBIX0O7gxQGyBHGggV/YpR0sYkMYlACKS2F0BGEBdIc2hs9CvUKQTXC8xUyifGxpCuL6IkpMuPIOh1MnFNtlBA6QtsmYTmCMCRHkC2uEAYR5UYFrxSA9rDWYlopXjlEex713aPkJiOcLhDOlrCpJesmeEGOLCiwCqyFNENEqh/t0wqifj0qFmTRwzYzVKRxnkOE/SbYwPUDIVkvRQkf0+tHtfAYRHD/10EItkQ/sCV4NkuCNhsCt1oSxEsb+ga1+oN69xcPGAgoIbeadvvRcYHAUCl5fPivbmbP3jaSJ9i/33Hvl2/Erq3SW7kHT5zmlpv348QVCBlj8hCpI0bf+W6WPvQXrD/wMC6LGf2FdyCr+xCLf4dWZby5cbJGnfhsQiFR7J+T6N4CuBpaxOCt4ZUm0Qc9+rVPkC058rMGupbCayqYpQTnSd583Zup9SIefvrrWOHzkT//G97zn96HFJL7P/1fOfnkEwTlCpXZWd7y0z8LfGdjsDXmm30Qrj/21rqt5tXNqLF8SVO0HAz6VqmKUgipUNojUD5S9eftRtdRG9vNzLZDzM7uYW7HNi7B58DBKyB3iPMdNh66yHP3Pc/6M0+xv1xgbqqB0JLc5BjbQ1hH2wXMrz6IaN9IPBZxzGtzRm7w/t9+B2JPdUvtubRH1k3In+vQ+sjDTP/hHYzrEXpnzyJNDW96nEX/rUxc78MnPgE2go01VG+NoD6BuPZ23Dc/SjPboH61j38wRBVAnOxy8bPPcMfrZnnzW1/LFz/9EI8/dJTpyjy1V/4sZ7/1Uarbfowvf/KvGEsvMDUyzfPxQSZmr8F6RRpPn+LxB+/kwSNPYYXiNYdey/Ed17GxKKgf+xZz9XFK4RTHHzpF6G/Dm5giV5JWPSSrSsoFS8ODTpjw9OlvcWhuB+PTlzB29iSd9BmsAWNzkP35vylordgsFes37+eb50/0m/775XcWBlkEQT9iLQd9PJtlMlIplO6LYYdDbhnJ71VebP5l0/TSH7u+CWZrTgXaI8szcmP6GbOXNAcrpbDYLUOxmWkABuag3yy+WVb0UkP20hKlzeUphMRJi3D9npzNS5wxA6MxKKv8Trwsc2CFw1kQmcT0FNbEpMu9fl1uo4jIAvJexvrCOq7TIZwKyXod8rhHlmRkuUV4ZTprG3RTSe40mdAkxmJbG8RxzEackdjBHQoQ1CJNo6DwUJxZjqmUfOqVCC0lBd/j6FKXrJczW3BoTxFKR+hL6pWIOPfRyiMIA2h16HYNQoFTEMkMkffdlxzcUUGQg/aIAkk3zgCDL0ApTa/XoxL5gwujQ4j+pqCFwIkYrEUHdXQUocMQXaigwgY6rOOVFnHpC5A2sS5B9nP7yIolP9ki7iWI8ZjiQYuUEzjRQJBSnJuktHOKsKapZR3sqbuJT36Mop8jax5C9tCrParP3487W6HQewHvwA0ky5P0Hj+NDRxeaR051YFWSHavYe0bLc4dW2VkxEMEISL3CTLJoSvH2L7nFn4iuorWuZQf+413YbImjoxUCDwkY76iY0HhaCcpeerwrU8QBJgwot6o8UIr52KrjXWOWrlCvewzUfN55uI6QS7otEF2Lb7vEwQVqqUCsfWpqIiJkYiCLrO4dJ6NVpONxSZmI6ZSKWE2ulx8fpHxXZb5A6+kMBEwhs9s6lEyinMrluaTKXvmFKORppVo1qYrJLfv4yev/Vfc/Xv38cmFu7Cdo1xKm1I4Tr0QsNTJodShXPH4zN1fwnRexcG3/hB/c8crqc1sQ4QahKH3tbuwrQWqr70RN96g+H+8mtXf+FdU3/YKSgdysrPLuCdXuewP3sLxd3+IWcYIGnVsexEefwG94y24pS7JRoeNxZToUEj1+jl65jDv+sCjfPSDt9CYfzX1sEmShVx506WgKvzuH/4O/iVv4gsf/s+sLF2ks665kLSYf32PN++f54Mf+jobx+5n7cyTnNgQTFfrXPpv38Wzz7XhzGmuni8xITO++OC9vPIV13HmaIPyeI31tkSOeEzvEtTmAnI/4NiJHLEa8/yFoxxfeZRjzSdIstN4rsOoLDM3PkuK44lzp1jorJNmCUopOt01gigkUA6ZJcg8oUxI0OuxEPfvEpQXFJ1eh6VOgh+GpGGDrNOmpEOq9TojM3USp8llgF/S+J5ABwqpFd5IERdrlLNka4AVKK2wiUUFIaTglMVmFuckMgqRkcYbNbhuAhnYXoqNE9I4xqsXML0EMoMRCqtCHJK8naDyFs6CVy1R0Yq8UkSmGco4WufWQRVAhZjM4NIOqlSlUCmBEiRxjJAO7YeUKiWkEKTtmKzbI2mCX0wJR4qUdozjeRHJSgarHZwMEH6IV/bxyiEqVOioikagqxqhBDLSSD/HdHLwQBZUPwihHChIMosuerhOikkMSIEu+QgnwWbIgkIECptbXCfHZuCHfl8ACIEYNMSprVsdfe+zKfrdi97gJeL2xc100zwIIbYalN1gM3W2v9m+VBRvGgeHwPM0URQSBAEOQRQG/PZv3cDsdIZyLTAJSkIxAic99NkV0tMJ/liMN+KwroTWIVLlhBOj+NtGsEkBXxloncLmG/i1CWSyhAgtOs1wJ07gzhXw3Ary0gMkT+aYhTaSDFmJEdUcYg/zrKVzPIYaVF4RYS5kyLrGxZZtV1X5gb238PrWdTQ3Yj7+D//MxQsL3PWJf2R0osGr3/ojTM7OIrXXv/vSQAj2y0f+x2JO0L+LWG7ct43ni8PXz9aIraNfbKaUQmDp3/Els2m/4TtQBFHE9u3bGZ+c5LWvfB3Tk7vwwirr65KJhqQWato9SzJbY2ysQu3QDCc/dYa7jx3hjcEJRhrb8MMAoxXdngEvIax5fOUf72fijmvZ8+bbuPrNN1EYH0VIAEvy6P3I0RHCiVlcoULw87tpv/+3Kf7smwimFsFohNlB/ZYdrPzlg4zU5xGpw50/CwVQU9fj1jNMs0NvsU3lqln8bZdweqnEp7/6KL/7v/881ckrKYVtbv/Ra7j5hyq0uwlfeeAedu5/C5/76F9wfqHLsxnUsyb7rsm4YqzGf/3CMbaff5SnnlulFRe4dMcEc2+9iRfOdgkWWlyxb5zOxTUurOfMXraL9tkK3XAdbRvokYzKpIdfFqx12hx94jgzhXlOP7NMsqbYUd/NXLWK5xKeWzrJqfUVcmPJ8px8UKYiB+JXKYkcBEXBocXAHEs1yMz1PzxLIHBSYB14qm8ItO/hBz5SasIwwub5luD93sSx2c20aRKkGBhd0c+evPTuYHqwprbKgQbrol/9KF/8j4NMJ7xoqrcanZ3r9/OI/h2gcpsPTFp/1Ddf12b2op9FsFsP9Y/7v10c/we8LHPgVyOCsSIChc0d0ghU0ad7Zh1pDNoT5CZndWGJkm8RK+sILci6hl6z2b/9ldNstLp0RY6vIQh9cifpxW16qSHDYnEY1++ND0JNqRSQJxa/l1LTmkqoyF1Gq5VgU0PRV3hSoKJw0FFvqIUenVxitaBYL1IxCVmeEgV95+Ryg+/7KKlxxtHrZTgpkEoTJxlZ7vqbsgBhDEGgiWpFPNVP5QBIZyFPwSV9R+cH6KCE8guoYAypagilQM7ixElcO8e2UqgNJkQokGMauWJon1/i4tlvseP1I+DHoLajvYT63ozW9SFP3Nthl+ixcddTYK5A+j75epNe+xnCzOL5I9igBXEb2VlCX7yA89bwX1dAxAHx557gS0eOsnJmhcuCUUbf9gN44z7mokVMCIojPuXZMWZGZ4jnU95y87/mzvvvJG4/hXSrOGdYTS25cVgHHRxWCkKZUUhi4m6bc8uCM23DRiehEASY/4u79w6S9LzvOz9PeGPHyTObM3aRiEQEigQBCgRFUxQp2wySrUD7JOvuJB7Lll13J/tM3l3dVZ1d9l3ZPoWSJeooOUiUKFEySVEkAAIkCBCJWIQFdhfYvDM7qafzG55wf7w9A1BO+OOqTvSzaaa7t6vn7bff5/f7fVMQUG/XqCO4sjXAeIGz4IyjnxtUBNIk2P6IoQVbWoZZzrh0EGhUXjLobtFf7WAKgy0cUysdws453n3rJ2mkEeWmYtgDGyqGytM3HrFhMAKSQNGaikimdvP+/+5dPP75hKfOneZyfpWjosf+xiHstKRvzzIcGqZsk+7L51n7+lf5wN/9K4gkAg/DYQntmMCuIk9/DnH8w9Rv2Yu4Yw2pH0YlKaLlsU9eJtl7irmf+EHM7z9UFXlK4dczcOewF87j2oZarIj23MSwdT3nnjrNj/21OW5754cIajO4ssCWCTOuDfT5ub/xIby6g3/yz7/A5uoqPtbUDu/mhnsWefLznyM4l3P+6utsDraI5+q87e5b6BZN6tllpg5IajjyQYqfvYHNcB/h4pi4lRHsa6HrHpsMubwV8NzpFdbPPkxv/TLd/grr4ytsmCuEuuRtszWCKKHWlBSDMaNsC1kOMM7TrtUZZQNckRMKQ4qlpqAWOowzdLIRm1mX1VCQaMEgs7RVRBIFiChBN6epTc9RDkHPBtSaMaGjgqQ9COOrqX8coBXYfsVbVonGjkrc0KASgR04TOEq0VwAKINONKYowDmcL7A+xwsoR+OKDlmUCK2RQlfuDyKEvAAUOgggtJCVWOcpMsO4FOhUI7UkUCC8AhzC58SNhDJzKCnRgSSQE/GeBqk03lmkc0hrCYIAqTQylGA81ilwEi00vnDo6QgVSbyXiKgSa+I94UyI0xXcLCOFjCVCe3COINWgwCmJxeENSOeRiar2AwfOeJyZsPClRgiPMxadBtjSYccl5frgrWwF38dLTFCD7X3xjc3xe+kzvGkCN0EOtsXKrhpECVcJL5XSLC4u8s533sVNN13PPXdDnDyJy8dImSMm2mChJeF0AoOc3uWzmJWc2h5LUrsZwQJKZzRvrNEZx6x3DU0k5fllTHwYIQaQ53g1QrYd0kicHyGHOWKjRPa2kE2LPBZAobB/dpknXnqNxVsOsPvobmQg8dYjI4nPPUEE0/Upphba5OOSD3/8/Qz6JatXV6nVU7a2upTOs7BrF3/wL3+TZHqK2+65i5nZue+Zdv7HjzI7jYGbiFHF9oGdFD4VReINO1MpIdKaZqNBFGic8xjrqAeC9z34AAcO3cBiey9Wp+RSYANNicAMq3K0FmqCmkLUIuK/HKEf1jx34Rq7e8ssihb1xjQucWRulbwvmI9a5E+/ig/2sXDvcZiIPovCIqbqSHMa0buEaN1CeGAKbhyC/QaqnuLWBZw7R1Brk773Hsy3nkXvnkYMBJgRmCv4K1fwbUlcT1GLdzEsWvjBNX7gnfs5eOO7kbqJMzkzaQpoimKA13fj5XX88mc32Np4mXChQXxgHwtLCa8+/hD1TsjJ5ats2jGzR+c5eP31DEVM3XRp7a72TKFbyHZEKerY2YIwCRF1SVgDF3rWe54zZzM2XjnHevk6eX/A2mAZVE6jnjKTxthgDyvjHv3hGIEnEJKSChXY+SXYEfhvf1jchAOvtSTUGmOrgrQSNssKBdIBYRDRaDa5/777ue7oMRbmFrGZqT6b0feXQHlHfCwnjkATje+b6UbVv9u3C+Q20sB24S93BjM7ImPBjtapQtvkjrbgzTanO89PNeiQshpoePcGZOH/3GN3Xt9/vjd4a82BSkJ0PQLn8ZlFKo3YkbSDF2BKi7cWGYaMOx3qu6eJREpRDFG5I8sNpfMQGqJIEUUK4zy2CJFB5Xsrhas2QOFRWpLUEgoxphZIYgmRAqxjNBpRk4paLIkCiY4CLGCLgjgMGI1zsnGGVA4toR4r0sgxzAHj8brq1LyvNnIcIBSlMDDx4PXe4/KcuBEQxCGmNFjjkcYiTIHDobRBSFm5YyiN0A2knkPIOgiJCI4j7EmcuIDPHX7LQ00gQoGc1+jQI4uC4WurnHno6xx5T4SIRgg3or6vZPauY7zyyAvYFzfIXxixEo5oF47YDCiy89R23YG2G7jZKUTRRQ87SL2Jm5PIxSns84KHvvwNTi+/wtxSk4V376d1Ww0CR/ncMrI1A40ILwUq1MTT8MNH3sWTzz7L5vB1IhRSeHqFRXlP7h3FRBFvnGOUZawbx6C0bBYeKSOSUFNPJFE9oGZD5usROZUYMiuhtJY40MRakXU6lFZQWsfIGwg19Wad4UaHoj9koz9klOU451hfXyPavMCxmw5z9/0fQM3NY4UnLSDwgl5uCTOH0pbQgzYC4wU3vWc3SZ7ynWfnWT71DJ2NZTZsTtIImd7VYv2KQBcB8uJpBv5l/Cffi0jm8ZOaINh3EK3OYE//MepADVG/mfR9Ae7aa5CFqKSGk0N6v/9tZn71ToabM4xfv4rKBqT1Nt69Svb6WQZJm+adtxDdcR/j2b2otSEf/9AtqKTA25eRBmzfY/sZOt7gwffciMfxypl7yPMR51dPUk8C7LWCx/7kIWK1wOpwAxtr9h7dy5577uHFS5YZXbA43cQu5+TjlHjPUV67OOCWExFSa4hGbAzGrF/oc3mzy3Mnz0P3ITbLFYS0BJFnZj5h6ehR7tm7yNqKRQWS0fgym1kPU+ZkCHIcOTDOxyTSkgSKdiskqWu2RiXWj9kaZ/QymIojjJVEFpJaSphOEdbmiGozeBESxgFRLSCYnFveejCVeItAIbWsrj/eI1U1jcI5oEIRvHEI4cGCy2wFY2uBtx6PxQIyCUBMPOFDvTPV8UWJ1yH4AszEmcM4XG7IhwXOSoJmg6TRIIoDpCvxTiLR6NCiohiJQwk9aWxsxVl2FhWESGnQgUR6sCODVw4hA1Qa4MrqEmoyRxDbytKuPhHpyWry5o1FpRphq11GxAoRyuq6m5WIcLvBkXilKku96nKGkArbzTHFRCSoZdU0CA+lQwhQWkAgJpPT7/+1jRpsgwQV4Ct2uMDbj9mWI+x8z4QKz7ZIdufOnS8r8aAGIQnDgL179/COd9zNj374g9x443E6nWfwVOcppsDjqkZQKlSrRig9oj9iuHae4aBg/y3xZP/pE+2bIVzeS3mmwF1cwZxaZXO9TituIbIBiE3C+SVkr8QlTRj1UWaErGWI2QRRi/HnPE99/STdjVX23rtEvDuAsUdEAt8ZIVQIpQclEIEkSgJuP3acly9dJg5i8v6AjeVrdDtbbK6s0Nva4uLKVfYdOkgURcRxQpy84Wr155sEz5toWULgRdVQ7SAvby5ItkGcyW1pHDPTbhOHAcaUjPOcVGumA81dt9/MeCjojCrtTRRrSieQxiO1RDmPKBxKSXbf2iJSx3jh2QbLZ19hZAVtXxK1JLVmTH9VEEeS7OUXKWfG+B84XBmgeA9eoBd3w7WT+O4riLqGYA/hO2q4/ilEOIUING40oDg9Jv3ELRTrDYp8FT09oZvl5yhXz1DWFkjvuBu96+3kjGm2So4cnkXoDOwawhX4scXbnCh0XH98L3jL7bfdxSOPbRLGOfVAkV8b8tJ3nidUi1wd9GhOpSxdv5/Z40e40nW0tWG2VSO/NIaohUxqdLoli/sD6kHCSJdsdQ3dawWra30unF3FrK2zmq8SBwLdNsxNN2lOp5ita4hxjSCKccMhaRAQ6oD1YR8vJFJWdKHt92y7d67ezm0+PDsIk5K6yruY2HgGOmBmZpb777uf++67j1vf9jZqjcakmKXK7IDKqvctcOL/Iqw3kK9tWlB1u9+xGZ1M6idr+ys5oQlJpXZQA+erBsNJB76iFymhdlCDSuzMhJYk30A7d4RV7FD6dl7Hzu3fi1b8f6Y5cA689QjnUMKhYk3Zz0nn6ohAYLMctobM7ZoGYRj1FKoZkiQhSRNGGz1W1gZE9YRWYokTBaIkz3PiSJHUE1R/jHQC6SyRhEgrkkihjCfQktwaAgNCK7TwTCWSYNIcWFehAliHEyHDzQ4mKhjnY7AlsfYkCkg13nnGAwORIgoVaRKRj8dYIdBRiA4CAuUQeFxZEogAVxT0u8PKn1cIfFxisKhAoYQAm4EXSNVCBgsIkeBFAeImUM8iapeQNsevjgEF1uOjHNUQtI5oRFPzlX92gfrRx5hbWq0cRGqzTB28k3fOnWHj154j75Sc7z3Okdk6s806UVyQzh5Gbf4p8dw78V2Dl9dQ7RHyxE3wcp2Vf/cK/2bleT48t8j7P/g+kp95ALtWYDobsHEJb1J8EVYdbQHCew5eOcUet4pXBkGE0gHCFhR5QSEqu7IwVESBIi8ty1lGO0xIm3USoVloaBbrAh05yDxz7QSkYmRhUBgS42nP1GmkEWsbPcIgwEqP09CYSom0xPT7kw28ok5YZ+lnhsfPX+X8P/yHfLoxzS1338/UTIP8qiMQgs0cWqkE6xlllvVCEBbVNOP4A00O3nQLD/3pIk98+1WWs5dIswE/cc9d6Jde57snn2NjeJ4DA03x+gvEt92PR1CvKUgXcYPD+KiJ638eVdtALJb4rsAPOqiog76rzubvZtQv/F/Uf/bTdH5lA/PyCukdNyJGG4xeyLk2rnHo4x+ncdON1GVA+/BeVPQ4ZP8KyiHl6gZmY4TPQc5I6H0Tz9v4hZ/+KCq8k9/5fIY58yqPnNxivZtRlOcJ0ya7Dhxi3y23Ipo3U3eCZlJDdwSla5M16gwjgUnWmbv1BEXPc+XUs7z44lVefW2Dje6rSHcRrUOiKKXeVMwt1Nl7Yg/Hf/gHuHFqnoe/+Bqda9e4bC7z2rBDbgw1HTLqd6hrSV6MKbVgqtGgNtUgboaUWR8tC5QoyIxjdWjIfICKDKLWIK5NEagmUtaoLU0RxBpTVAMBIappiaqFk1KuKoSD6Rhf2AqBG1tkK6ycT9QENp1cnLEOvEVKh0Ph0UAlTA5ijR2W6DTCZDkuzxFC4iRIFWFthjMZJssoxgV5WRLVW8y268T1Gn6cU3QNthTIIEHFNXIDQhtw29QKMGUBo6LSJwlR+bV7Qb6RI4IQFStEEqKlwI1LikFJOhMjysmFW6vqyVxlX4oTle2pVpXuIKiEx3bgKkTOTq7PQiBjhQwUrrQI6zGdMUVWNd66HROkIISqMhidRwYKXQ9JZPOtbAXfB2t7o5zQufZSigAAIABJREFUYLalKTuNQfWoNwR+VT/4Zh7w9078xPbvnfuUEsRxxD333M3HPvZRjh8/gXMl6xsp4fw8QdRBlGPIx3gC0BZUF5kKpg80cMBrT73K9IEZWlNDnM0x0TzNpYjm2mlGX/sGxcqQ9dWS1rvvQY9G0FtDNvYgG+uoqf1wpYcPezAVIxan8VcU/Ucv8bWV03zi2I3sak0hfKUpcYMxXBsij8zgUZWrigJfOsYnl7GqSzutEamAdqtFOj3Fy99+gh/5Gz/Nw1/9Knk2Zn11lXqjwVy4uJNF8D2k6glFCOl3Cv9KZPlGJTnp06rPq59QMCbHNo5CgjCoBMpa0oga+FzyzFe+wt33vofGzAIqiimLSlg5tp5mrMALxoXHWUsoqsZw8W0RMwf28fifNlm+usyK2aRpPXe87Qji9TVOP/0Svr+M7ya4zgpq4QAAYSiBNj5cxLsLUD6KCG7HNwR+4KA8j2gmMB+SP75OuPFFwo/8LBu//jmSmUXUrgV8Zw1zesBgdJC5j/4YqtaijceLPQh5DszDYPu43gXcOJtoWyLI9wE38Ym/ci/r2R2sXH6JwStXeHa4xtrWmFF2lnqzzb6jR5k/cBwZLZB4QRpGiJ6nDJrkUUKOQyc5U0dnKIeejTNnOPvqmCuXO/Q6y4hyBZUEpPU6U7MB83vqzB9ZIlmc4YmvfoOLpy+DCkFI2rUGU2mDfpGTW4uSktLYnea6EjBvT8S3rTorXnsUhjgPcZpinEfrkNnZWd7+9rfzqU9+iqIskROnHzER+ntTueqI8K3Z5/7/vSoK4uQz8CZ0YDujQFJpMsQEIcBPnKBEhTwGOtjRNlWPr/ShuOq5jTFVg/0mhMAYg/dVI6wnTW1laeq/R5RcvZgKhXcTGpGUavI63gJsAKhPf/rT/9E7P/OZz3wa4GMf+QjXHbkORgZ3OUNKQd7LIAwQTmA2BhSXVonbAVtXOoRxgTQG0+thywzdbpJvrhBOQ3suAjum3+2y1RkgvKVfGLrdIWNbcf3nmhG7ds1QWEPWHVKWnsI6nJgEz3hPHIfsPbBINhjT644Zj0rwktKrCSfaAhVkqQNJmATUmwmbI8N4OEaLyl1CCLDGEcQhaT2hXoupJyG1WFOLw2qalOcVChFopAqr5N5QoeKUKNIIpVDJIrp2ABnOIFVUwfekCHkAdATBeZAj3Csl7qJDxB6UR+KIY8OJdzX5+//rOrcdukpscvzQIXp91MVLfOXhdZYLwz2zin1zKfHuPcS791N85/do/NQvYs9eQ3S2oMgRSZtgz9tgS/HPvvQhPtX4KHd95ieIf+YOvIT87JjlT/5zmn/rR/CNFKE8KpRVYIcpGf7K36M0jkwaglqd3XN72NdIuNjvY4UACdOthKlmXBUleGygac81aLYkceiw1mB9SXOhho4iFvbOML1riqmZBs0kAhGxlTtyB31TMiwLxlnORrdPZjJaMyk6CWhOJTRaIUHoKUqHKR0jZ3nu0WcQNub6G29i72wIhUAEgjyAfOTxOQRSgIJHv9kj1ZqiFXDgupR7bm1zdLrBqWcv8+grT3HvBw6zq7bI1qDg/KVXOHryW8z+tY8hcDg7xJse1GLkgWOIztehpfF6CREPka0MgPKUo1nzjD7fIXjXHoLWHvSu23FHbkUvtSk7T7P1wE/Rvu3tJK0GQlq8H6Py36yev+iiwpxwDqI9okITXurjxlfBvcydt13PoWPv4/ceElw5/028SlmcWmTmnr/Kkfe8n5tuPMHUYJ6t777OvsOzTIU1us1ZLqgG3a7jb37gELEKefIrT/Hlr/8hp84+TlFcJU1n2Lu4m9nZefbtWeLWd97Ane+7l+vueZBu2eTVK/DH/26V7zz3DS5cPcPIZPRMwcAavC3wdkRNOxZqEbO1iGGZ06g5VntjrnaHbBYlfesZGE83z6mFMfv238DSvnmcTtkyMQdunUdLSRQEGCPATAb8QqClQIbyDXGXdbjM4XsOwgBZDxCRotwYYrqjKlyprIoOL4FII+MQnVaNgUCiIonLx5iyqIJ/cLiiRFIivEHhGG/2KXLD9JE9zB1eIqqluLFCOksQhETNJkErZrTZAULssEqwFc6htSCsx0ivEQ5cKfFGYHNHPnYIlZBMtyj6HjdySEdFodyVoFohPvM4I6pmw3mwDkGlG1CxQgSqQj2sp9wyGONAaYSxSAUyrHJ+i1FJsTystBdCoJsxeioB77C5I0wqcSBe4EvY6nb5tS/8BgCf+tSnaLVab3WP/Au1vvAHv8/Zs2dQ6k0WnH+u0KhEgG9wdLddWr4nvZRqOieE2Cl0KyvAiusbRjEPPPAADzzwXqQKEFLRbE4RhEeR2iJVH1wf1vv4LQPJdtOSU2tJWvvm+KMvXmD/0jXGPYuwgjDrYa9c5NxXXqQ/HnLsQEAcgZ7fXbmYnHme4L4H8Rc3YTAC4RG1NjKawnRHfPtf/z1+/NgnmP4f3o440cYbMJcGjD73DNH7rsc72KEmeyDLKJ/8Or2+IReG2x68jxvuejtzS4scedvNSCnZc2A/SRKTj0cUeU6SpgTBG0XN9nG9euUqv/3b/w/ATvr0G5aK7BzH6u1447Ztf/ZRntPtden0uiA909MtisLQKwxXX7jC4r4DLCzN0kh1VUQKgQ0kLgfhq6FVWXrOXSiIQ4lNJfuPhhw5nNAMA1ZOd3j1ynluvn8PzWia5c0OZu08s+OrxLfeXh0SX4DPoDaPSBMoT1cJ7WoXIlhHJAafeXzPETYc5WPX0G+/AVXbj1w6BrNLyEaKUxcY3/Zxart3o3SFoAjWEfZb1Tlh15FhhmpIVN0hGMHGGpgVEOv8wK13MvaH+M6pktdf+y5C1zi6tJ/Zd3+QozedYKk9TzwMKa72mFusk8qQjUadq7ki1Jq7j7eRSM48dYE//dIjrF46i/c5zZkpdh+YZ2qxzf6Di5y45zCLRw+TzuyGoI0Ip/jqlx+j21lDCUEcJYRxQqvR5FpnDclkIi22i+JKg6CERCuJdRX1eK7d4s6jx7jS6bB/70F0oEiSOh/60If5xV/8O4RhSJHnFLkh0iFSqB2OvBBU3bqa+F79Be4Pvv61r/P0U0+/cX4DsJ0Wvf3zSJTShCrcoQdppSq70iBASTXRP9nvsTOt8iLeaAr8Tt7KxFpZVpqG7TRmT2Wwo96kedh2bbPWvoGSTuhf1tkda9RPf/rTn/kP/Xxvzcp0ZDD9AtstKVbHSO8oTEkoI4QQBAtt6lMhw1OrNFsJzz71beZCIJEMAovRlr3XH6E9H7C5fInuxpheJ2OcZcy1K8eT+fmUYKNDPjIMtjzDaIOBdOReMioKxoUhyEtyEyCFp1kPeOT513Gmilh3E2Qj7g9YaimGY5idS/HO0e9neAkHDjcZd0vKlmJkNMXYMh1AaQxqMKZZD0iUJYgDwiQhDBSlyaqPQRzjVYBKEqJmjSgMcBZKLFJP40WEM0Ns3kMmc0AEIgS5AMH7QR5AyN9E3vgi+dMDRl+yqHmIrxMECxZxtcs//dQU/+f/uMnd9xYcSq9QPjli+ZGMrgj4yb99lGTXAnLhI7B1K/6lLsmv/jzlt3uo7BTqfT+CWW1QPr+OuJyhZjf5qAyY630ZfvUgvjuPfyBi/H9sEogbsY+O0LcpqAtMUWCyAi2GTP3UJ/nxEwt8KJA89s0X+cK/+hL9jTO0JtMgqxWbvYy1bk6gNWmUsDQdUgs8o36J944g0SRK0JaKS37E2W4fVIrJHb3OgI2ew+HoDUZM1xo4JRkYsIWl29viwL5pfDMm1U1mpOW22gz77kz517/2PCuv5cQNxSPPbfL85jlO7N7LRz9UY3MV5pSiHit0rZpCZAPDnfc1WX2kR7Ol6DYNYeyZPrCPX/hfPsDDv3OS//5fvMR99x6hfWCK2XOO9XMXMWc/htr38wgyvB3iXY5wA0RzPxSXkfE9uPoeSOY4f37Mb/3jJ/nxUHHwb7eQzRFJq0d83QyivhfnpvnK3/kHfPhTB6jN18izF7HFi9QaKfnqGip2iE6B8DmoEiKgJmG3R/Yt3q8Dmwj6BK6H0ooHfu6T+I0z3HRklnQqY+XCKhefOsOhd9yCHRpecSmDIOLEPsVfujdmWml+5n86xQtP/guabkisU2TQRDcS4qTBqiwYxpKtLc3T31pns7NK3lmn88pDjLMBxhZICqQSxEKhAUPJ2MDsVI3GfIOpmTrN1NNoC37wekvwyIBTlxwrY0/PWnqZY3htlR+tS+YPL9CYO0TJFGakiLTH9MbEjQiR6ooYbsGXAhFScW+g0qM0JSIMqomksMhQEi01sP0QOxjjtnrI+RaqHuEKUxVEwmMLQ7E1Ip6rgw4IU4EfZhSjkqCeMlzbpNZQBDph9li9YvYohxMWJ8DJ6tyWWKQ3uLGnHBuK4TJ4TRwrVBTh4xSRNnDrI4br6zgkYRQRxzH1dowQEYlUBJFGTyuQnrJvyS+WqGaKNuDGDpoK0VCIstJS2G5JiUemEicqKpKsadIZzfDKkLw7RkeKOA5RiaDYMDghK8SgkSAChe1nEFRahGxQErVDVC3AlR678tamSd8Pawda33EcegPe3/H+tuzQjqoidTLZtt8rFNwRA1Lxiq2rNtzRaMTnPvc7rK9v8kt//5cASRDWMaUF9T5QBxHycbz6LvbSZYqnBwS7JHpWI1ROnYIf++BuvvZ/n+eG9xn81hmyM5C/KijiKW751B2oxjy0HoTlFEoH9wf4lQJ6ryF/4D5cD+jkOCvQRyJuzRXBq9/E/94C4gPzuNzhnoD0r9+OP13AvkqU7JwH7xDSEd1xN9cttbhxboqiNLzyjW/x3T/5Em5hhvMXzmGUo720Fw9Mz87wjnvv4+jx675Hm/HmtaPTYHIM2eZEO7YhhT9P51JKghQ4BBoYDIZc21zmvh+8jssnR5gk5+HvbvHK2oBDSw2OHVYUmaRVKoK4ekZnPUZAcDCgd6ag1pZksSWSAYvH55k/2uD1J1b4p//yLD/8gUM0ZmOSswNGZ5+jsfUryNYPgx+Bq0iwkEOwhHBXQL0dHx0Gruf1l1/i6pef4qZmjdZH94LIiA4IvFKgZ8nXM848t8pNH5hDhIoyexkpC5To4rJVpHIwHgNboArQonIbawrIDfgVYIjyEImcZrvJ+3/yr+O2LnH8QEIpR6xf3WKwGTB/ZB6bW877iALN7fvhYF1SjD2f++N1vvoH/5YTrYgoriFrNXQzRMUBm9JSpJLOumVwdcBgVCXIr7/yLPt3HyGbX0KUm8R+zLjf5aWzZzCuolBvR2cJOXEqUpK5mYTAwEYvwwuFR3GtW3LbgdvJ4jG3v/1djHPHlatX+exnf4tP/MRPk/WGpM1aNfzZtt6tmKKTk4O/0I0BTDDKbfRggj4CO5kDWlchfhVLtELJwjDcERnroMpH0UpjXGXFvy1gfiMY0FVZEVTp04HSOFtdw6wxOwFo2xczKeTEaapCcKx1E/F4xa6RUrHtIPafW2+pORBOYHKP8RAcTPFKITdy/KhE1DS6EaKdZBAMOPfyd8i9wPo+kSsIS0Pez+mc3GTclAyDCGsyApmhdEEUSA7PJkRRg+8802cwyNgYFHSGY6bThMU9KfFUgHUaaw3OZwgBkenzjhN1zp/vcGWzZFR6ggCs0IxGlkYSYbOCmZmIA7un2OhZrG1TuHWSeo3FmRbCCDYub1E4h+n26HQG7N3XZipu44RiNHKEtRQVga4lk2uexY3GZHmJ7WfUl+YZr29QDgri9oBkpkRFLaSKJ0cvAS8R1PHxJxGzJwne+XuEwUXOPpNx/hEHNcdf+gjIdMTP/qOD2Md6ZI/1yE4WlE7w3n1HiH/o1xHFNL5MEalGtoa4586g/UXkf/M3MV+9jH/+GjJM0DftJv/KYyxbxyIvwCuP4v5JG/vLc8i1P6LUdYLZBHc6xydjXFBQbnr0gwvEd94NsedPfuNRvvzFhzi3/Dje5gydRSnLsIQSj/GekTGMrEOvO5p9w+G9c+yfb9CONRtjxwuvLpMqw1Ck2MBirKM/HFEUnnqc0pxfYGq+gdSeoshxpSUbSqQvELU63peYLGP54pinT63y859IaRczXLi2n2smIAs7uHSOr5+OWQjggoQgr+wFQ6U4OqOYFx758RYXXijZXDaMNjKKcMzRRc+D//W7uGXtOp5cN5x5NkNPHWDFbdL7316i+T//BqpeINQk1QdA9aouPX8OoXZhszaLe0P+1ufewf/+wX/EP77rKDQXkfoo5CVu9FWMPcF77p/DrjxFMVcjbB7AiJjV1/6UYB2SfA29UOJzg5AeoSVC6spNxyvEFpT506Rmk1turPHYxZC5dsoN+w7zzBNPc3E5I505wA233svmyjqy3WJx0TPbEhycDqmlil/++hbPPfFZytEKKmgQx3NE8QL9vMvaeIVr/TXcRgPOJTg8jgwZhMSH9xAsv4ALIlwm8ENbJV5ai5aaeiSZ210nqiu65ZB9821OvXyJ6brkhoOCqTji1LLn8ZUS5w2DPOOzn/8Se952C3dd18bkIaYHUgvkSFEUFln3qFiitEJEYPsOGQtQ27ZsHhl7XD+DelRNDSMJpcSOJfnIo7IcoRU2N3gqLZTp5iAkWSev2GqhIGqGqBiyrRHJdIIdOUorKAZDTGHR9SZRbBiurpFd26LbL3DO0mjELB3Zj8nHE8qQpBhbinGGHAriuCQIFfWZBjKpE7VrhHFI3jWosWZ8qktuEsJmSBAIpAF5qIXrasSSIqhLhPLYzFKuG/RUAA7KlSE2lMjpiLAdIEpDfmWMFJ7aUlI5YQgoR56oGeOx5D2BtB4lPDJWOATluKig745DBhoZSFT8X0Zz8D0e614gxQRun7gTCba/r3i9TKaV1r4RKiQn3ut/3oNdAMY4pBSYsqSzucHq6gremQlSLLBWVvoVtQupPwzpHbDvT5D2Ka6eGjEcjElmQvbfDCru8q6fu4vy5EWef/gKwWrA4cY+Dt94Per4z8E4AB/DEjAaw/IWwvaRD74b981VfMcjdjcQMwLz6Gn6JbT7X0N87QT+OfBk+NF5RifrNP6rW3AXCnzD4AuLVwp9JEUt7EJoz/KFDb75h1/g9eeeIRsOyC9eQqicrtZsDoZkxhDENUZFydETx/+9us17j7UOrSrUYFugWlm/ih3/9m0UZhutqULkQGm9I2b1QBIpHnxng9kH9rHeu46hkqg4o1A1zm1q2oFgw4AyHqQk1YJ2zdME5J2a9YuGbGAwrsBGlnZdcvzBgyzeNcvpoWBzah9TC1cY2JeZ+vITRB8OQI0nb7RCCANyBN6CPQlqL34s2HfnD5K0buCxX/tVPrj/A6CboKYRZQ9fDtAaDt2zj7JzBh1dTxAdohxfIR9cRGUebS4gm2PI84mBQgCkQID3GkYCa55nqT3P0b0xL2/ETKUhe6eXeOo7TzFyCdPze1hYmmHYGyGSiIWWpxnDfE0xzOGbp7v88RcfJdvaYCPaw/6ZBUQYspUPQA05v7qMuZSi4zZelFhKUILadUuIsxfpOsnymXXWeltYk5OkEYOhq7RbSk7okwKtFUko+dgPHWVtpct3X+lQ2IQ4alIUhtXhFrccvYEPfuBHabVniMMatVodl8N0OkNpy6rpZWKvqQTeAAqE9Xj17+ta/iItv51dwCSTQ6mqQJ/oCAKlSaMaoQyoRQ1GZsjemT3s37WfqJHw9CtP8w/+7i/x2d/9LU6dfpmtzhZFUV2bjS2RCIzzb2oAJtreiRzcOFuZIwj1hnBZbgub/c7nTQo5CbJjR7+wrXP4T623pjkYOdyoxBU5pQB3uY9rJ4hRiddAQyPaCWJPncbSAnn/GnLQQSch7fYUqRljNi5TFilCQ1qLcJEgGxjKcowuBOHiPLsXB9Q1ZOOSUTdnkGX0txwkIUhBFAgSpclGhjjUaG9QGup1jbYCXxaMewO6YUi9VqOXeVTPoZXHFg5v+5SlQGeerDNGWg/e4AtXBdw4z3hs0IOcBFFlBg9LIhuSD7YIE42KY0QQYJVgUHjyq8toHRHXJ9CNKwjqBxEymAjbQryv4W0M9HD2CNR/geSOb3Ng7/NMLV+kc2HIn/y25UhrwJ4jy7jT0L9qudZTDNM9LNz/SeRgATkV4056/EqGWBog925BbRHMOuqH9sOxDHvmFHbkiX/mXg489VnC0kH+Cmw2Qd6MtldI/Z1wpUCIDCcyfOIJZxOCPRGkjtHzPV5+9glePvcUg3yEZCL4BGqhpGJ/CJTWKCSutLSmE+bqIY1A4RyUhWF94Kkrz7XxEBGVhFoROMlCKyINY+rtlPpSkziNSQPN1EyC84ase43eMCMINbHOCbJrjK8NqF0VNOuSpRlBXMBgbBj0clZXS4K0er8KJH0v6VjBn/U8x2bADAvuOBgSTQmWL0jWLiu+9bWz3HVilcb+BW7Z1eKmD95F56jnmV9/mrdf8oSvniY6VFST6kBWXBc1UZDmHriGlG2iVpvUX+RcKMiTm4hUG2QH2ztHef513O6Ixg0haw89wuLutxHW63Rff42Tv/sQ7/zLOeWTI+SdAr1bIuoSggQf7KIMZrBiA78+wEVrNI3inoPzRO/7BPlGB6enue7m2zl8RxORLtHxLY4cC1lsREzXNI1QUxeCrSs9vvybX6AYfhvvBwRyGuMk3TzHKkEPR2mmqIUFyByvBEGsmF2cJlsYIGYibjoc0R8FvPqq5cILGd6B9obIBnS7A3a14YbDDWamPYeimGWdEc5JUgPp0CM3BH5UUHrLaxuX6PS3KnvRTcH5k7C7BrWGIjyqCG0lLqzG2xPawoT+53ETBa+teNPWV82bLcFXwt14oYFIZDUdLk1VjCiFTgKMqAS4LreT89ki8QSRRqSavBxSDoZ017qMh4b6LIjZZsWxTkLCvEQUjlg6okaIj2N0oPAFeJtX4mFn8YVFhYo8N0hZwqDEZgI/UtAF3xNoAWEgkQMo1jOy1S6N6+rEh1qImkSIKu9FqAjrHOWgslsmqK5TFBYZa2TkkVpNXIkm2gMEshYQCoWua2xWVDkQY4uoBRXn2zjKzKBii64H/JcSc+D9G9C5EK5KQJ4UqVqKnWmfc37iXOTx224gb/rDtlmF2JYxi5102G0UIS8ysvEAU44JogptygtHqDX4EuMdSu5GJh8n2HeY2fZJmr1LDFe7vPrwgOnamHQJ3DWYHUqcb2Nax0lvfy9kNUgUvOpAW0StgOkSggaYAfLuRbjyGkQOMb0LHe5j6rfnELmErVOQRwgZIl2XQMzAugFb4HMLkUTOKkQiQUF5JefLv/VvOf3is4x662jpkbGmOTPFkT1L3P7Od1NvTyOVotFo7KADby7bPOwUJNuBUNVRq1CbnbA5Wd2qtSII9CQcq6JKJHHMe++7gVuOz9AMBjRzTbseMohLQizeOezIMlCeIHRIPAWCIY5BKbClZykFnzmO7VKMC+h0JINLJXaly+EjAfFSk6NzGvuDN7P59DUuPfsCC9cy1PrL6KkhBNFEuG5AFBPBpUFwAfQuAt3A11ZZSUJccAxFhJBd7OA1fCEgnCPcFTH87kO0HzgKwtJ77STja4+zeMJjX7+KPJYgGnH1eZazeLEXK5t4OtDv45I1ZkPPLYdazDTeS9EfgKpz5IYTyLCJDepYHbGwIGlGmlokiZQkdHDu7AZ/9m+eZ7T6OLgRNR0zzB1WWEQpkVbgmKMdjSC0CA1hFBDXA/L6iOHlHoenYkKf0OtKbA7tXsHpM2fBO5SoaJBpHBLHGh0IDt8wz7GjTVqtJt95YYNzVzeIRUogUi4tX6ZRqzE/NUPRDxhchIweMzMtxLSv0IKJeJdJADDy++titG0Zap1DSYXwEGjNTGOa47uOs9Xb4sDcQe664U4Ww3mubazy6PnHqamUEzdczyf/20/yh1/8Ak8+9SSXrlwiy3MoKqrQTgAaEw0mVbNgjKk0CkLs5Ie8WUdVrQm9SSqYCMm3kYXtFOz/1HprzQG+4s1Jj3WgpmOywqNLt4MC2dKimgHNXfvovzaCoIGTFi0ktVpCVsaIdh3pHGGlOEahUQaKrKAsDI16iDIpY5UjR4bCGYaDnJqwqFqEEhoMJM7SbMbI1DOdWXTdM84dWdcRZJYkDcFZhFPkmausTwWMrSVppdRChRmPKXNTTUqtJW6GjEeV/7lFVfBxWZIPS8ZbY3QgQTQIAg1aE4YN+v0NAlkShwWuNNhshMvHpPOXEDpEyrSaNLsI75q4cpNybQUXHiVqv5dmY4na4lM0519gOM7ovpAjz2Q0OwH9EjpOMRtNkd53N8Jo1r6ek+JIzQr++VPIH94Nq9+CtkPsuRk1XycPW6x89Zsc/vj9TCdHUC6galD6CHeZQC6R+Ku4c13kzTWkMQhVoK6fRzYVzsKzX36c86deZDDewHiHxJEGkihVlAiUFERC4oUgUoo4jqg1UsalZa03RghFf2joFIKe9az1xkSJZXaqxky7Rpym9HtDwmZMa2GetFYnFIKwrqjVA1Zlxu75JrIYk5YFrSRAJDHrg4jRuEURHsRnC4giIkgEDZOT9xUi1dSEoB3BnkSwUZNsdS1YxclrnpkwZGF/k/p0SkftYvlij1fWc/b0NdP7Ymp7D7L3fQ9y7dIjmGe2mLEl6UGJnpYQOMTEphJpgAFCDUB0CLTlgz85T+fsJeLGDEr2GF84Tf+bF6HRIawV1A71kNlXGT5RY/zM60yPr6JcHQ4GqNkQOSXwYYh3uyD4IVBnKK6sUF4eI2JHvaW56eAMF0YRrdndCN8inUtoLbRpN6bY7BnWshHF2jrnO00WdMrqhuNb336dy6cfBr9BIkJCEU3ETiO8l2SUaJUg1QgResJmg/pMHZ1sUl/YYk8j49bjji0CBkHA2RfsxF/ZVxvnWkk7sZzYI6jPQxAq1pahs+rp9ASbaY256xt0nriIJ2NoDRcfP8lVsYtm+yj1YUQQxRQ1qlX/AAAgAElEQVTXLGJeoLbFkolANUTlzGO3Nw8PucXntrIKLh3eAraikMhQEcykkw29Cu+DSvAmI48sXTWoc+AKgy1LvHXoJMTHIV6N8b6sHq8qbUI+kKiyJMvGOJMR+hLlBSYboVspblwgZKXbQXrExObYS4EtIK6FiFJg+wbXF/iuxHUDwroiLBVuUJJf6NKhT23fzYi4aka3gV+Re3zh8ZlBNqPJNM3hC4cLJAiPDiW+cHjn8LnDGocMQ4KGwhuBUQE2A1sa3Lic0LZ85aQjPK60E6vT7/+1TXeRcnuz3GYoVH/vyGgn0PqbJ5PbG6ygqlm23ezc5P9v+/SLyX3OWC5fuswf/dEf8Vc/8jFAEWiNdwHGZeAKTD4CvUBUu5cknSVufxedvIYpe+SrA+zKkKBI0FIhdErUmCO47iAYGH7bkEyDHG6AGSP2aPzoVUg0TB1CJHWK1SF26yrpnv0k88dgPQYZgh0gfA2l6wi/ie+WiP+XuzcN0uw67/t+55y7v3vv2+wrMIMdGKwkQYIiaZiQTGqJ5FhVWlhR4tiOXE4lJZflRI5dVkkuW1XZZCVlxaVYMuWKtZIUBZIIwQXgAgwwAAaYfaZ7eu9+9/e+dzvn5MPtHoBOpOCDXSX6fOrqfvut7tt9zz3P8/z/v/+CA8MEEXnISRfhlmnRN194h5vnL9LrtbEiR0Yuc4eXePijH+bNC6+yePAgi4cOo5TzvRODf6epay3v6ViKd2mA+zps+b2SIyFKU6UxmlolwPccji9Nce7sEqEzYDDWZGmLIptGESF9hXLAMZo8VbgehAhCD2oexLkgzcu/1rUONH2XxpSD7yrGVtPbzrjdLZg/IvEnQirHTuDYcwyzNzHXN4kOj0pfjg8IjRD75s4UbBchx1jjU2llnHnmGPHWTapLdUyxQbZ+kWKrD14dVUnwZoaQvED6zgCxepHAWUPSREzWIGwgAomlBuIkcBeIXXR3Hb3bQ9Qkdc9lfqbJWFUIqk2MjqhOOtSrFYR0GGWGJM8pBiM2xiEz0uP2asYr31rj1uXXkbrNtBcROAGFLsgzgzCaxBYETojnjyDUhI0KXqBBtnGbPe65G44uOiyfmOedywNuXx0gtGRisoWyBYPhiNBTHFqqcejwJLu9mNsbQyYrESaoUZmT1HRCvKURwqWdFQwu3KZxMkSoOm7m4PqKvFdgQ4N1yhvMOiCcvSH999FWJNg7cO+57aWUSCFphk3unruLj536ATrdLkcOHObsibP4uw7ehmQmb+LOOtRbdVpTLZJkTBiEfPNbL3Hl2hWyNMVYi5LqTtLx/n31PY2MfTO03J/OlQXEfkNjHxdcFgnvoRS9j2v8vooD6wKewGqFGRv8xSrmag8tBYUAkhyblN2y2uIi4doWuhhhbA+TZniBg1uvIesh9AY4QiNci2MVaJ98mJMPRgi7x48WOUoJWqFiXGicLKdSK9NEx0NNK4Co5iA9RTXSIAtCpSlEQJEKqAQ4UuIUCmE04zhHeIrBSFOpeVQ9GOaGYpyXjUhhkYFLnhik56I8d+9wYNCZZjRMqE42yKyLKRRCgotLNk4RvkSLnMxqdJpgE01Uv0DdCUsk5h2ecx1d1CgGF8n1dYp0HuEsotihMr3NIz+ccUn0GXcDqqMM7Y8pBEyKFOd0E3sDBn+a4jw0oDK3irl0G9aacP2L8MEZhCkQE2ewxw8w+vJ5zLV1vPrj5biziMGmwE2UXMILVsBNkYemEekAqwvUwQAcQbFj+OKLz3NzfRmDxZWShqeQvoMTlpQUQxlao7VFOBAEAVpKdoYZPTIc4ZBmgpF2IZekiUZJje8qFpeaGOEzSGJ06GK8kMR69IYJuhsztxCx0tOcPdnCjy1eb0wgWoi5KZpOyMbtOt3BfYzzRbSokYfQGPfoiQrCNVRdj1lHMtsA1VK8sypQoct3r2TguZxZ8DkSGsJ7TvL6F9dZWx7QuZ2Qj8Z4s5p7nv0kvT98HafXxbmaIgNNFEhklTJJVgBOeQNaOwI9xvcUf+1nF1n/1gXiayPEsEtydYNko4e9dI38eB1xVtK5/CeYtzPcbc3p+z1QguDJaahG4FaxZoLh8ABvvTLBva0+DEYUCYiiwAvGzDbHBP42xw9/AL2haI8NtptRMR2auaW7s8NgFLMuJbuForOmef7SAGO3EEIQyf0O/BhlRlhcrEjxXU3gG1TDJ5z1aMwLsvFNpiYTTk0NWZpVKF2hPmmptmC0XZprszxnlIJLTt3P0DMFqz3Nzq2cnTRgZ+STuhPUFpbwLoUUu29jhMv5r56nvu1x9p4hx6N53OZBhjvgbFp0XOYJ2IpAhhIhLbYo9hCjZWGguzlGGkSgkH4pYxBKIRXl/Rjv+QNc9S5ZQyrQGoxFOgKdaUxRYLTF8VRZZCBQrku15RBEFp0mZPEQX8B4METpotQMm4Sks4NfmyEdDcsxsivKw3mWIVxFFmt0HkEh0akl72jkQKF7AjsuDXyOhLQzIt5a5qa+xYnD5xBRqb8uix6BzcBoiQolNJ2SdJZR6k5Tu0dskiUiVVjQmmKU40QSxy+neM4evtQYTTHO8aoeOgGnUpKcrAGTmT9j9//+WmLvwVhqfMtS4F3l+3soHqLU9ar3HFhL5n5J+GBvelA+mPd8CcYglXr3Pa1lZXmFz/7OZ/nUD34c5dXxPUmaKrT2ENpBJ320tui8jnIWUaJPOCVZaIzYeWObzVWHWcdQOC6+MAQqQUwF0Ib0OznBsxnIAXYwhm2BGJ6HUzNgXERjEdNNyXd72CBBHbofm8WQjkvjqygQfgVZG2B9g5yNQA0QdRC1UgOtE8O3X/g2/f4QIST1yUkWjy1w/KF7OXrPvVy98g7jOGZzbQ2tNZVqlZm5+T/z+u83gff11/uhTtLakpSyVzTsy7z2KjkmplocXpphfmYWP5hChdNUGj6jboM8PYjVLVAu0rH4SUqiPISShAoaShJUBNYV7A4UyhdcXNFUpx0mmjAz6yAO+2y8OWJ9NWG0nZOmY4KJORrnPkjy9iZyuIXaKvd7uZ9pJNkrEAosBdhNQFFvVXjkmcMMV96k2E4xvVsUW6sUO50yYHFhAWYEoxt/iL3SJ4wk7kINXAfn6AnwaiADMFN0dqbobGoOzPYgHWIKkMkY34up+GM8L2Z26iimIxilBkdlhKrAzw3ZeEySZmxLh1xLrq3mXN4akZsOypXMBV65T9pRKb+yFitTokATROUeW5tSuMGYNNug3hpzcsbl8KKHWHbY7iXsbBqyfs7UVBNZZBRFQeBAqx5y6EAT6UrefKPLxJRie+jhT89xuBWxerlPtrVFriq88+Jlkl3N/OI8M81p3EqLtJdTBDlG+pjClpkg+zK+3CCcv/jTg9KaVHbtHaUQlEZjX/kcnTzMY4ce5dzcOfJGwdziDJ50STodaj3J6cph5BMNvMBDWMGpE6dLSZWGza0t8jwjLwq00dhiPw9E3pEEKSnf9Trs/zzvkUjur/3iAPYkYf+v6cKfvd5XceAoUx4cjYMeJZh+QqUq0bgk8RgxzPADhTfTwDk6yYHBHDvXdijGMW5QVvhZIel3e/ijHioqb/RcCBJVwQYGPShIB5o8ztF5jvBgKgzJsoyi0FSBcZrRTwqcuRqalN6mYncjweQZ9arL1GKLUV+yVRhaMxGd3Yw0jskLjc5AmA5uzSOJAjzPwQSaXj+lcBSpkWSUmDoHjcDiVFxU6JAUBqoRSa6RwxjfLxhrTVANcARYR2O9gKIQdFfXEbu7RFUX29rfCHwsLrlYxJl9ALv5AjuvfZlxluGG0GrOER5oceyjXUZbVdR3bxCvbNCwI7RehjEU72QsVDPUxg1slCDvewj9q/8MeXaImANO1RBGUJs+zH3/xU8T/8LncKf/Cnb4+5jiMtgdAIy8gTz0g6gfmoYFD8Y1SCVmO4ZJh95rA17sXOdW3scRkqbnce+kzxWp6I5iWhXJIC0YJgblKMYanMJgOgOaoYexgiTTZEaBE1EXDsIrcBXUKy6LBxqMYoNbmaVbpNxevk2nV9BrD3BVweKwzlZfMr8EJ+eP0lhSmExQNB5GiAlUI6V9XSCHAmesWV1rc3m7y+R8C3fX44br4wqXCeVyaC7gsSdctJUETsbNjuGV2znzIubcAXj6Rzye6oSk2zlby322tncZLTSZOHqK5sO3Gbx1G2czwW1YPK9ErJWFwV61riUUEmEEThEzf1LS/cPvkl9JiQ44LD4XkrcNG3/c4eUvQmQFxx5WHH4mwDtWLdnkziJC1jDyIXAfYH0n52/82I/zp7+4QPXpGZwzPsXYJ2lb0tV1Tk4/waJYY11V6G2k3Lo+5PV8zHjo8plnajj3PI5SIS/e1qzOwaFH6qxcfIz+1hcwQCF6KDvC1Tm+BRnUCNwOS7MLhAcncaYS/OhtmtGIQ8egqi31acO1d0YMtw2nzwVc+nqCsZZsbMm15epOxvXdjD88P+TIQsBa2/Lkjx6mvtti+VKF7mCW5qmz5N9ephpWeSUesfbKN3nk4tv8pzMPUj/1UWx1kkqjQDZ9bOSW0pBOhg7LoDBGY0QAVkjS2zHpygb+XTO4cxVEoMApvSZYQ5Gaku9pxJ3QK2NLlJzJcqQvcTwHoS15Ysn6KRqN1OAHVcKKg9GGuDckHg5QQYjrCqJ6Dd+1yCJGD9p4jTrCy5HSIS8K8nSMTQ1+0GLcSzC5y+DmLkXiYLOQCRsy7kl8nYHJ0J2crHebzvAV3lG7/MjHa4hIlMSitCwCbKBQnkW2GhhtEGmBsWXxYDS4jRoUKcJXZVKmsag0xyQFmRQ4wR4WVZQpp16gcAOFTcoME+E5WOS7vpr/CNa+dKhEsAnEPvmEfdlRGZ51Z1IgxZ3OnL3z/e9OGPYTSJV8TxGxl+yaJQk7m+ts3HqT2QOnsNLde12AFRP4DZdx5zxbl5fxQpcgkPjRQdxqROVoh9W1TSruLoEs8PJuORnIwG5q6vMatbkBUyH0R9gvfB2ODqBpYb6JMJLowCJhuIT+0i3EwXuxa9/AprdLc61VWG8ScfwhxN0e1ASCsMzPiAtQgmw948Xda4xsQaNS4fSDD/DhT30Mt17jj373szzyxJOM4pjvfOtldne2OXvfA3z8kz+4d6X/HU+GkO9mGYh9c3J5QctrbAB558Cyf30dx6febPBTP/MTzE+3MKpCFi6gVYSsOBS+hMGILCsYjUYUo5xqK8DpOaw6DoEV1F3FZMthbqGUTZxZsuwMLaPtnKaTM1eH449IjtzjUPQt3Y2YbKgpJqqE82cIDjUZ34xxBhmea9/VwJfdoPJ3MgqsQlrADKlNCeJvfw7WegR3TxE+PIXupQwvXObWi5LIkcycqxEebeE0mqAirFgA0cKKexDuEm99+0t89bf+KX/nv34A98Q8YiHEpj7ZIEGNe8zVTtGwfXrSZ7CT0tYpWapxpcOjxwPkwkEOCsW3tjX2XIX52lGal++hu7mLdgWJaONrQ6gLPCTKDfHULodnD5HVXbzaLlFlh1qQMTEp8bUgqBRcPL9MPlacPB1yfrtPIB1GOzn1WgW0ZfV2wmiwhhdKLA3aZJikTk0dpjFzjHBScv2Lv0+t0uDrt9us7fZ4cHqe5qG74LDC+gGFHGNVBVtVe+M5XRq0hUR48v/T8P4Xbe2zCzzHw3cDPOmy1FwqC4OFcxQDQYCP0wXRK7DbbZxhj4WZKT70mU8jXYnODFvrW8zPzPPMhz/Kt1//LkkaMxyNyPLsXZ/AnvdAIEpli92nR71bBEgpMSa/c3/tE5DKDU0ilXi/JNP3VxygBSQgrKByvI4a9VH1gHiUEdYU5A7JsMAZZIi4QOSS+kQTbV2ko/GdMbs3L3Fzu0clVJw4uohf9WjvdMm0wjUxW7tDrHAQucaxhkYUELqA6xG5LkIaiixFBALV9Ll2fUQyyLGuy8x8nenpGk5Uw/FT5qqC5a0xK1s7pEnGdNVluiYJq4r1zZgiyvFDifIUzbk6UV7QakRIa7FFTq9jcQKfiYMTGG3Q7ZjRaIxjNK6QePUa9cUWjdmInbU2vbUtRr1tinGBl6eomRmSvIm98jncuXtRzSMkScGNt69w19kFvMVnOHA4wQpJEu/QXXmZ8UsbTD14P84kJKNN5EBSFQ6jxCN/q416ICBZiZBPPAbZd8j+4S8jdy7AqoKvKNTPj+DpBogIe36AN/0M9mYP7S9CMYLCYpwRzH8S/1efg94Ys9OHKthqQHJ1RDF0eOXbPSbEBEO/jlKWil/ljTgmFkPicUp7WLJ3lStxXYVSLp409Acxg35C5AY0wgqTjYhaY5r+8g0ybfCFRzKS3LwxphaNGTghV6/16GebtLtjet0M5TlcvLFMPByT8CTBM/dyaPYwt7qaF9/WbK72WLu4gd/RyGQHna2h0yHNQyd5848/T5LXSEcDirRX6tDlDLmOOdVa4pP3HGA7tby6ep3b2y/SsDv8Z4t1nnruENWTD3D0sUVOT9VIRiBO/GXG7T9g6r6Q3mCT4XKb+XFBtABqUiCccK9bHWGdKnk/p/1L1+itAYuSuR8PaDzWAjWB0inTVcNjX9dceqHgC7+nCW/l/Nw/kPR/5CruqatU/8E0cmYDnJxJcYbPNAR2sQILn8EvYlzVwj2gSBpv88bvXeDilU0+9qEniIIheVhFzdxPx5vndzPJ6XXDA3e7fPxcyKcVRLLKZ7/5q/zSE7PY/r9l3jPlWBoXVw4JggH3332a/ql5pg8O8IIOhZY8eqpCFHXxhce1GDozhvmHBPU3FKtVyYGHa1z95oD+bkGRlyepPNG8dj1GIPnD37y6tynlCGNwBczWJvmVX/inDL/2BjsXXofxkNc31rgreZ7axCGS7ZOIVgN3zsc5ANlbq6gnTiJrHqg+tpditIs8UCdfKQhDF5MUCGGR0sM6EptnkGTgB2WKMBa0QUqDW4/IEoMepbieg6p5CM+gtxMcMvxWlTwRCNfDSIEyAmcY4zo+kzPzmHyM9EB6ISbpMl6+gtUVBrtbKOXgB1X8qI7RksbkHKsXV0g6MaE7R6syg8w8bJ4ThQq3GGL663S6r9NmlY/P/TfIiiipLRqs2aPlCIv0gdRQbBfoNC/3wAm3ZGILi9YKoUFojTKlXyMdFShpEcItk6JTjbEWvxGAAn/Kw2bla3AE0vk+eBK/j7UH+SiVU2a/aybe87U9udb+U509j8Le99/pd9vyPcriQd6RIZVFR2lsdhWEniJPU37iZ/8ev/vP/waNpUeQbkSWxCTxiMmpOuHkQxycuRdjJb3OTXqdW9QGI/zZk3zo6RMkX3qBnDHWSLJhiN1JkEdc8lUf7j+Bffkl7FdeQGy8Ce+48CUX8fMp9sBHEGMB3QIZLmFNDHPzYHJsdgsaNTh7Dvkzx7GJgXYKVYXNLKZdoFPJ1kbBA/ecYqfjM7M4R64lv/Mbn8WEBZury3zra1/FCX2qzTr3PfIIH/rox74HEbt/givxsAqjC+7It/aKAqXK6YwuNAi7h2mUaAvS9ciLgo3dEbe3DNHEAplscnvLodsTrF7foTZU2KxDEfcRwhJMN3n9u2vEeY14u08xGpW6FFkhTXMeOTLFM49NcXMz49LNK3R3rjCnejx7osGxjx9CzZ5i7r4KOB5auzD7MHqcUznyGIPRZfxOlzArcKsSAoUQ9fJ/Rc5gRYjebpN++SXSjRwOVGg8dwjVOgiijpgaUqnC4cmc9eeHvPQvOxz6yxVOnemT/+7ziOMe/k88hrBdBB/mZMVSXVTQaEH1R3DyPrY2gagNsRs7LF9e5vZag/vOnsRxxshqCxM0GciQVwpYHMDBeclTNUUkYbR0gEfv+TT/6y/OUWz+EWermgEhGRmOinG9lKOHD2COLXFgokOmJb7jslAPqIQ9XFnjWi/ngWcXGW5rrr/SpSgSnnjuJN/9omF9eUBaaAZ5znasETj4nsKpHQc9ZuP2S7jF16kqWJpu8Yt//+/Q/cKbFOubOGPJ1rUtJgcZ7uQEtcEsYphhpw1UClApYrGFnAz3sg/+Yu9Jd7r4oswPiJRPxYn4q4//BCdmTpHHhqqsUIkkIs+w2z3inet4gctdJz6ECh2wYLVhcWERLHR6nVK6DuiilPDuTwz2u/7alJkTUPp4jDElnUhrpFRlgvKdiUF5vwHvUo14f0bv9ycr0qXu3PUFQkl0LJFTgtAqTBxjpSGaqaOaLtmWRTUrBN4MxXCTpLvO2vY2b1zfYKLmsLQ0iycdBIqJ2QnaN9cYd4eMuiMcX5XEgsAlqFgcDcYI4rhgkI1xA5huuKyt7nJzI0XGGQeWmjgiLEekxuBPVdACKg04caBJmoyIQsvBhRqjrZhtAb1OylxUpV4PyHNN6CicZEieZlin1JV6uSAdxQwLS4GhWa+QDGOKojTy5t0NGocWSdc3Wb2wTLcTgy3TYOdqs1z8h/+EytkZlocX6Q7GtCYkT/zYQ3z3X3+DQ489gK1IfK9Hxe8wfyhEa0n7179AbzGg9cHPwJwh+d3PsXj1DYov/DreL/89qp9xGfyLCwz++GX8bgeVanzvCBRDzP++i1x9A/GJeTj6acznJEyPKWYexn3844jIxWykhD81SZoJ7PkMKYYkNztkUuOdnkOv3eJ/+pN/wb0PfoSfVHdzfeUC//qdt1hL20ipcVVJ+ZBCEHmKqbqHysB1LL4y1B0HTM5g1MGIghPHFsi6IUHNo1atYD2HiysbiGxAJ87YiQ1Bq16m4PqQDrvkY4nROW9+6Tu88advMR45DPsFphhhjYsnAqCBIyPCwKVak2x/6zJPnZql64R4tQWkI4kHMRuXd+j3NlgZXuC3zl/jx548wd+9f5a1yw8z7F/gq92bXP7tmxx0vs7ilMf8yQrND84z/dQTVCsPI7JVphYbdOM1zt9YY/rVGHfH0HjEpXrPMdpasruyQ321w+01wYmnXaofBH/Ow+ZnscEzmP7voyZHHPjrz7H0czd5xr8fwoNkO/+GP7p2i3M3YP7VbaJfqvKV9LP8yW+P+Ue//lfxTx8nz8Y49Xtp/6s/4ML/9Qd8I5zkyGd+jolLX+aFzzuc+diHOXrsOM2oQtj0+YCFm5sF/+cLIx485vOhu3wcFz4Vgv/f/SQv/94BxOrXGA2XGQiHYOp+Fs5uEWcd+tmIaNNwbFpz18Eqbd3m8zcN15TD6gZk1xK4PCa/kZN0DOkFzXM/O8XtrZyrrydsX85IMoMdW6xQGJOWhny717lH8Guf/s+5e7ZO9NwnKM58hNGFDYZXL7BrFK3hddJul0S2UH5EMOUTPnwQ+80exaCNikY48y3UwhzCywmPzyICr8R8ZpD2E2xa4DY93LqHjMopVtZOyTs5SmYgC5QyqMDDSsgLS54VaCtQWjPY3MWbmMFYTdobk/RikkzgFyme7jEYdCFw8d0IM4zZuX4TFcyUGGUNOhjiTs3gu1Ok3QEVFSBkhEpDsiInKwKk1dhuFzt8hSxeJst6SG+BifmF0qypy4LAdgqKrRzpgFyUpY3CEWXOQUVgXMh3C5Sx6H5COOsjI6+cjmiLKyQmz0g2++UBzpV74Wv7Hg6BkZJ0WGCtxub//wa174e1T9IUQiDsu7p3u9ddE6L0Fpi9j/We4W+fqW50aVR21P4kpcQGWktJI7EWBQhdILSgHgY8dOowP/3YGdK1Nhff/hxCx0RTNSrzs6zcypk6fhLjWFzVp1EvEJU6ZmeT/peep9cM6B/8CK7u07h8BX/Yw7z5EvJTP4D3UUvyf9xAXFpFtgfIsYOqnoaiB791DZ6bg0M1UEfLYvKsxSyFOKfPoncLCAXqjI+xAm4l4GTkWzE0PGTTJ+m0eeniWzz4kQ8yOz5O495jfOvtt/nGb76EJMP3ygJrqjXBM88+y6NPfQjX+XOODHcCz94tyPaxsuwFlEm5X/SWfwddaCpRRLM+wQsvXuJzX1wlHhSQJxjtUndCjGgSej71hsJ1C5JrV3n03im6SlJ76BDWGgbbCbs3+vR2Olza7LH74gb/yScPc+7EIqMtSTy8yWu9G6z/1gVmwj+ldTCicnKC4MQBgsVTSO8Motik1ojoD28y2F0luN5FxprwWIg7/zC90RA72EKubRPvCiYen8Y7JZBBBTiHZRKrz6NqKY0Pf5L6By5xynsc4QwYvPI8N178KksvjeDbL+L+whRf/sovo7IWH/jbfxs1OYvJY2RwjN5nf50bK2u0Z48z89iHiLYv8tpLLqeeOkO9VsHzXJY8yQkD3ZHhC2+kPHHMw69KqljONT0a/+XDXPpaE3/9PN1Rh9SbwpuqU1vqgcpYH92gYQ2HW4pq5DOkzfkdzcVuwWos8bb7sD4k20hYXGiwfrHNT/38PVy80eXK+QHrKwm9YcF4u6BQPqQDhFFgyqmmUAE/+IGnqLoFSz/0OHYlJ7vWJl3bJdOSoL+F3klJ1huoqoOa9nBPNlATIXwfSIqAdzGmAooiJ1M55w6coWIjgjwkdGvIXKB6Oc7uDYpOBxtrnJk5wvna3ptAoXPSdoKLQ1j4TDUny0b/XhCaVO9ODPalRPthgvtTgP3PF7q4g2t+b44IQKE1OisnEfuUpT9vva/ioHNrl9GJAbWFJia3oBTKFWR5KckRnosyOeb2AN/30K6AiRAdNUDEeMM2hycmsFWHoDnDzvqYcdJGqpwCS1gJqY4zxoUmFWXsduQCQjMY2pKg4issmiQpiAQEjmEoFY7RrC73uLbSp1p3mZuO8GYmuXKjS03mzMy3qE3XGHcHdK1PiAYPiHNibSiMQXkQTNZpSo/uqMAajeNJkmxMvTnJ5OIsjuPiDfqItE/g5HhyRLF9gyJuUxQJWZKSjTQ6HTNuv0G9ITATh7n7A+dQtWniIuHqeMCBp2d5+/xXSK5t09ke0uul6GHOhGM52apTvVhw/uoX8VPNlHObNZ0RvPoOC//qReS9x/F9H/feT+Ac/FFUPUe8eJneXdsAACAASURBVBPz9t+FdoL56jJi49tw9Cw8dJz0G28x1JC8WiF4aJGJ546SXk/IVzSOTiiWf5+s4qGPnELVBbXZgJ/7gQf4l//3d/l2+xJZsoGyIxYjHysyhCtQToBXcXF9hcg1gzTHByYjF12AFhbPc8iF4sa1FfzIY2qvYztKM4wrWduIqTUDZGDJ4oSgVqG62GKwLRkmEhnU6a6ukw43KDKNziXWelgMhWwQKImwPWQBjpmnHrV4ZctS8W7TTHaotxrMz87ywRNPIQ9/jEs3Ut559Y95rX2JcNLnh56BynSVB64Ldl+1EI9x1Zgsjem+k7O7NuTUByZQlYigeoSFiYNMTr3J8PBlgmHE8MKQf/v7l/AOHOHEvUe4vrHF51c0v/JDdYIjH4NsjBUV4u4G3/q1VR77m38N1XyOJB8jVITnVQinF/nQb7zA4L/SqAhcO+ZcDDM3Olz4x1/mkc/+GGbnN/m1//63iW8ZJqeOsHj3NAdrOQ/8xC/wuJ5ARTWG1qGTaLzemFYI1Qq8oxOe/4Pr/M7/vMpCr8vPnjxE+J1vcCxP2K5WqU0cY6nqEM808VSBnTrI4mRC2Nlm68YOO4M+l7XDypJi5Ttjxjdz9FqG6mvCUDB5wMUbWF7+XEyaC2qVKkeeqDFOcvIc0k6d3U7OsN9DZ2NmJ2f5H//R32T+eoVL/9ufMp34VMwUtqhRkxEm3SIrfJRbxegcZRIc0yJfFSjPEN07jY0WGLUzsuUhUw/PoKyH1QaUohhbTA7ScdBji2q6yNBFmBKLqpWhGOSoukA5CukoCmswogBP4rZCxjtdCmsQwwFogR5lFL0BZrSL9SLc6Ra+SMiTBD1IsDIET9Hp7RIql0ajCRJuXL9N5Ce4soHZWie1C3huhOvWCJyQcSdFdwc42ZhBnnBDT3C19QQf/Vu1Owf7fLtgfHlI0cupPlzDFgY7MkglEJWyOECAlgUUFhkJbFE+HIQjUZFE6AIjICtyinGKW/cIppu4oUJnmqydokIHJ3BLtn//L3aX7v0uIUqJVNlN2y9MLc4eNvMO0lQKtLF3ign2HvJSKpByH1RUdtv2unB7mXF4QuIowemZJh84OsdHjjRpOEPUZJMjp09ihCKzOVoU1OuGtZWXKNY2GPSGZP0UUo3vCArrkt/YxZ++ScsMcLwOo0Lj3tpBXViB2SbOVAUx/WFk4+kyC+XSEPudfwxWw9ffhrUmdqoF83X09W2yArK4wDtaQwYOul1gehZJjl35OnbpGKLRQASaKBA8fGKaV67d4uVLr+F882s0Fyd57gd/gIsvv8iR+x9gcmaWI6dOMTE1jeOoP1evbPcMB/vTl/1OpbWm9ILsybKkKA3/rutQb03x0DPPsnNzk831XfLxLkXmYnWAlYLMDZkIJDLr4BQRUVjDb7i8tiloBrsoO6LSqnHwcIP77lpA1BWr25or51/ije3r3H/I4ei5AulFHNiRjN+xSN1FeT2KeES8nDDa3mHqxCS4Ea53konJCYpalWLqBk5aJVvd4cXPf5EDDzxN1Jhgd/ca126O+dTPHEM1/wo23cGqkOHtLToX28w/9SlU8ABFcRfKqSOkpXJXwqFf+jzZP4tREwZJn4eSIaML6+z0BLN//b/Fxs/zb37lN5mqThEunaZ1cJ5WxWV26VmW7qniRj6jAjJtCFNDqMD3YF5rfu/LaxRrXY5heWQuRLxxmVlpWPcdpibnka0qWcXBaI3baFLVO3SurVPUY2jmdAKHjZri7eUhydoYfbtHZDXNisPC4Qh3oPna8z3yFI4tHOLMEZ/ROAPrkPYmWN0Ys7O+htSGu08e4Uc/9TSVrqL9Oxdx/AaOaiGNIJAOIh1S5C4i8DFJCpFCVUPkXOXdjvb3g6aIckYmKXGic2GLm+0V1kdtFicNddfDDgRyO4exJh6lrOtZ3KVDHPqwy77fSw8Ktq5uIgOJaCqeevQpXv7utxACgjBgP3V6f9/yPK/0Iuwf8i24ojzK50VRomaV8660D74nU+S9PoQ/b72v4kDtEXryAqwu8KYCCgx5kcNeRYPJURWJTXKEzcm6ffJkiNGWcLLBQniQVBcMdwd02z2KfEzgWXKbkQFZlpHpAm0kVroErkfoO/huhoMhLyxJYUnGhizTzEUu3lyVmYpkdTdjs5Ox0s/Y7mUsFAZVcWk06zSmqoRRSGEETlNxeWeFRsMhDBS6MKRxjtAW32ocV+A7DiiB5wqEtmRJRjTlYtMUJTWOr/D3yH8WiXLKi5yONUkvo5Zbwqpl5if/EurkhwmmjyC8kCAf4Qyv4cavcvREjdFEyOzIUIw9yCao1WeYrOwgd64ht3LscobemmBbHcIde7Q+/zu4bz2OevBR3KeOIyfqCBeK3/tfKJIu0tXIcQ79DmJwkVG3j/9QhN/dxg7b6GttOr0tsBHRaJu0vop77yzh/CF0bQGjBNbNuPueRfSXvsnKICHRGa7IqShQtiDNy7A5B4tMBDorCJSHh0LnFieMUJRmmepEi93tNn4twmu0kK5GJAVamVKfV6nQzAs6nZRRJ8GvQLVSJ1MRqYjw6x5Ii0orCDmDEx6g0RQwcGmGHkW+SjxeJtEG4czR6dwgln267QJn3SMI6iyHV6i84zAX3ccjD97PSn+br926yua1V3l2MWUi6XP8Pgfv8DFU6zjSn8P1E7Jc4DVLTbEdjJAWqpOP41WfQGXn8epDHjs6B56B7DZvv50wq8CbPYOqPYMtLMnVy4xfu8qxZz+NjR5Ei1lsN8cIja47eNXTzH/g75Ms/g94Pwzq7gdorlmOPP4dVuwMV77yVQ6de5SjzYR8skVw8hSjiQnmG4dZ3zT4IqN9Y41Bd5u4s8OrXcn6ztucmZjh8OmHmL5fszsfsb2s+Y0/+eewu8bI83CnpqhPNPEQbK7dhnASN4Pd5Q3saBecIcl6zE48Jrs1ZnQxQe8WuIUh8gRRoNCeRz/N6e/m5AXEvmG4W5AXGimr2DxG6JzQzVmacPnhh2c4FB2kf/UtxM4QkfYwJkHbGYSq46RvEovDRGoAoY+teeh6Rmo0fqEweIw3DMY6hC0Xm4BT9UsTrRQItzw4KwUmKbAWdFJ2w80ox2a6PFgLhc0K8lGMqLg4niyxea6HPz1BJCQ6KUg6AwqdoOouvgxxqy5Z3CHPxhhtsLogHQ5xvBpBmFHkmmE+RuuEbm9IR2VU6VKv1khSh1xYXKGJsgwvHmOSS+wWHZaNoeM2qU0cwD/lYBLIO5r4SkLe18iKpMjL+004pYcRZ68xa0r/AaY071kM0pEIT2GVA5kFVXoOhOOiQhcAUxhMrnEitzRkZxooSUv/Maz9SUGZbmxKJvieMFcI+z1Chf2i4L0Hkn3KkXhPZ27feIgQuI7CV5Inj8xyz0SN0xMhc1M+laceQy4+iBO2MELi6pgi38HJVpicaZCFAdXEoBMHqSMcP8TKmKx9C8dYwh2XzDlAbKuIbYH35S8gF8+hTh9BTNUQoVNiLr/xZcyog/RrkGpIB9hiG+0JxCGFk8To3iZZpwPCRzgKJ4/R4S7qxAGc1hTWDbAYBJqZhQbj8ze4up1QZBsckBl3z5zmyb/0LI3ZeaJajVE8YvW116hUqjx07tE/87rfwS6+h65yJ/VW3BE0YIzZ46wLtBU4fpPmbMh44GB1FamaeGGDek0ihh7TNcVosIzWKYmRWFVjZ2OTsRyxuVIglU/kVml4FWoVyYEjJ7n/3ElutPt87fW3uaVv8MB8QsQutbMhsnUf0ptHuBHCkRirkL6HRWLjPjKs4UWP4gb3IPQa0utyMmhRndCMdm6RbXZp+aBqDyG8B0H0yJevI3oZjVMfBO8IVlRh7GFci/AdVPU+Knf/LYrjv4L86CSieY7GSR9X7hAH87SvXaJ5+AwHF7apHbkLOz2DrNaJvBaDocARhnanSzHqkoxyuoOC3e46xydbHDx8nEgZhvWI3o01Pv+l55G7HcaVEHeuhec0MGnKMB2j3TqBK9lY72HjFJ3mJP2EoY3JK33iq13y3YS6MDQChygIyL0Ko/GYrd0BaSbobxZIISkKQVSZQ9kRgRgzUctYaPicPeihckhvdwhHINJeGWopagjhouI+uZzF9UdQi3BORXh311Cz/h7Rav8G/Q+wQfx7XPv/81obpND0ixjXCt7aeJtWMEmjWSEceNDfIB6PaWuJbtSozFeRkwKbWYqxId/SVKIaYg/CcezgMaYmJtnt7CKl3JNHlv4BaQTIMkfBinf3bCFKIIbaIxaVQWvlBMYY855iYH9/+/c0OfAqPkjFsJuiRxlTky3snoZVlbABhCMQvsLEIxC6pHYYg/IdHByCxgRxu0e8uYWMYxyTgTZYk5NhSIsCYwq0EWRYYkcgHQ8pIfAEw3FJVhiPNYm2zExHTMxXca1FDAyZSemPczxlcNY7NOYn8SoBUilsku51fgTSlVjfITGGNMkZa0PddZHKoovyNY4rCXwX1/XRtsDoHB2PsNkYpQqskuQ5aKsRSlKRgqq2RIHg8Jkasw9/gObTn8SJ7iPBpSi2cfUaFbOCkprW7Bz1xcM4KsTDx6GBGxps8jXyXoVqu0F6q8JO3Ye8yuVL36Fx+VUmb8eElRh/IcarncBcvsz2xteoFkk57q1MYapzxJ11wKE4chx3nODkHnlfkO3uILWHs6DhUAV5z33IiQWc3GW03ue1b7xK3t7ieK3OZlRlZbjDyBTY3OCiSYTACI0qij1TjCWoeniOQ6o1jnJwHZfAUcy1Aka7hiTOyQpwnADP0+gioRmERH4FVcSMMGjhUQ0aTExPUfSqjHJBpXqMyeoEtXAKz5mj3lik1oB4N8eRgjheo9u5xaA9JNN16psddnsCm2uScUxv+zbL+Q0CBMfnepyOThL687SzhG+++QLe9R4//eOfZOqJGsGJY6iJ4wh3BmUG6DSliLuYpItIVzFJD9FJcb0GMqqijuScPXGCeGuFKy+vsrZR8PhZgRt9EKEOYZKSsONWHA48+WHSbojNBTIbMrxykxjLzCc+QNH4UczkP0E+fggxP4dyUyqfOMaceJKVzZusXJli4exDdAdjNkcJW9blniOzPP+5b5AMErZ7Q/LBLk7SZqgDknrKdk9y79RF7qpZ5qOUV1WP2+1XqdSrbHnzNGs1dFBFImnnOSZX2GGbuN1lXAxJ3Zw0UBS5gbUUp1PQCi1OZS/gRSjiVJJqiVUWJfZwwe1RmdjoCBwV4ytN6BgWwgpnah633xmSbPnUwkkcmcPYYrMR1mkhnHlsoTGmjybERD6VWYnOc/QoJe2E6FEpGQrqfonhDByM2DsIWo0QEumWtBoKixmVplw9yqAo9yHhKkxWUAzGuL5ABh4SKJJir7hVIHKyIiPJEqTr4zUqyIok725RZGnZHbU5xbiH8iNkmpEXOYWBJM1pD3ZITJ95p4KqHyG3CXnWoz/MCWOBE28zyq+xbHKuCw/mJ7n3ydnS4L1ZoDdz0uUhwrWoWoBNygOqjATCEdh31S4IY5AuEJbmNKsotbr5npFSCNyahyNchKuwe0nRJs1RvlNiT1ODtRJTFH/2A+D7aL23K2aM3SsO5B1S0b58SEixT7wtP/8ejCmU5m3Ne/GBoKTE9xRPHp/hgwtTHJ2vMnNglsrJ+whPP4p0DpBqjdVtFG2E3UVIS1SfJmzNoIREWB+Ji1A56Mvko2nsuIlZd9EyQlvF9sp1vM0LRGsSJ+qjKscROsJcvUFy+w28QpfmwtYShVfDjHuIIILZCKkLxEihOzkm0QhXIhsW0/QQS0cQTojNLOPeiO72DmHdZzYK8RyPwThnbXMd77Lk6Mlj9LNlpJLsbm6yvbXF/NJBHnzk3J9z8bnTrXyXYmr3HAjiPWe+PR+HLNHZ7c0tKuEE99x/lko4i+83iKoVahVL1tF4rqHXCxn2h6SJpdAunhjS61lsqom7MZ3hGstjTUVKOjspZ548SOTMsNm9zuWVDpXdmEeffpjo+CRq8m6EvwDCRdgMWxTYYozJY9AFNs8RRiJUhHRquJM5h2YeJG2/wM71VZI04f/h7k1jLM3O+77fWd717vfWrerq6q16nemefSFnSA5XUZS4gKIpWRtlS8oCKUaQQFYSw0iQQIKTGLCC0HJsBwjiL1ZiwTJNWRJFihIXiesMOcPpWXqb3rv2qrvf+67nnHy4VT2jOIqZQAkkHaCAKlR9uHXq1nvO/3me/++/eq6C0E+DaM67HHaMX++ij53DZHOggixTkmv38Lpt/BPL2OgHcUv/C/LCsxAsIE8dJ+wcB3uGyWSX4Vadw4+/nVk6Y29coIRHMw65/MobjHtDtscJuhjhYXFak/qSnJDVhTWO+TnTqOCqvUt/dIO4GbMbtlhoNhh7Ebk1zIzBGY9ROibbS5k5S+I06UxT5CWYGVE/41A8p0Zq6WGtzzTTpEaBJ9Bohv2cZJRSZJYw9gkDSdWb0ggNJ1tV6iLj2996mWNZl9W4TWolfp6jRYH0Q9A1XDm/VwUnF/DOVZGLHs4YkPrgTfIXft2ncjmLdI6kSKkGLVTpMKMpRdmDgU+ebLGbWba1T+VMTPtsgDGWbGpwU4fZy6hUY1RVYdQ8YFQphdaKsgSLvQ9GmBO/DnxPB/9r7v6DTEgB7k3U6Z/qErwFAvDn5jnQvqJIc/rbCcUooX44xvNASo0wBqEc+BpTFFgKnCfQFZ9ASwyS9O46EoE2JaFweKGmsJbEFighEMaCVHjSQWmhNNisIJ04pHZEAQjnKHNDmpWYwEPXQ4QSZIXASFDSEomSVk0x6Wc0mjmzWYnILF6WUgKZhbgiyFxJPssoihIVedQ7VULfMckNws3xnaE/DzwzqqDIE8pZCnmCUJbMKoynSTODDGOWqj615SpBN+aBj5/l0Af+Nk4s4YQmyScUyU308CuY3i7e8ruZzBxx/BS+r/HFCC0HCPsiqG9Au4KqnUItn6V9qsVKe8p3spe4+obk0Ogi9c+8RuWl7xA+/hFmf/hZNmaGB/wWarmJPPk4xfID9Ne3WDwtSUyf4HBGePg4kb+E3Ungdop6+0micytkA4tLZ5hhn8nNTb78r79JZgc8dvgxtpMe/XyDQWqYlvMgufv/EHaeGqyknFfotMbk8/ldT4Dva+peQbOuuTuaMe0NiaL6nC+f5tSCiIpfQyeGouLjNdt0jixT6yySbYR4SUncOMk7njzJA6tdKjqgrhVpKtgYO/ZGOUnSJpmcpb+dMBluEC07Xr+bICaOcrrNYHyNwWyHIkl5YeObbH9hjQcefC+nuyvMTj7CZtDj+C//PVQQ4/YjznGGkhLhDVDRLlLtQqWFS66Tb3wZM90gONVFyE0ch0nWtumvjRkIuPC0QgWPzsNQxilq4RT18+/C5RIxHSCCKYo3SK98g2SrpPnsacauTrl4jtI9gNnexpVT1LmztFY+QPmdz/HF3/59xNs+xN72FjdfvsZOtMnJ7hG+/PmvMUjuMclSrNI0mhEPHIt45hMf5ru7D/HtK19mMLhDtLfHlXt9HjlzBnvsKDa+gAyqpFlOkaS47lFY77OzN6CtFynxyF1GYByeLij6Y6ohHF505FawN4ZJJshLB4FERRrfedjEolxGkUlMmYIT5EVJPVD4pcdWv8KkGNOMH6ZabJJNU4wZolyCqkpc/jTh7EWk75EqhwsFqluh3BoCmmKc4zc0uiLAGqSv51kAhcUJsT+y4FCBAAlumuOsw8xKXLlPwIh9RADCzCuX1liktThjsLMp07Ud8sjHCUGa5qRJgpqMCZcXMM7MK+sKnMsRLkfKDBFoinKKJEOrCOtS+pNdksxSq7XARtT8EDubMe0lDJKUIO0xs3tcJmJUX+bcE0d58uMtknsls70Cb5DDZIpsaKT1UbnFefsED+vupyBbY5GeQFcVoqIpJyXOWJx12KwEJJQGr+bP6TTO4YzFFgXYcp4bZ9189MZYbFb8PzoY/6Iux5v4UWPtnFaFu48nPXiKyX2Sjt2XDX+qqo18E6u4/z0p512DKPT5wUePcaxSZemhQ3SefJz4yA/hqOCQ5CZBFPcQ2e35JTM+S5pbomAVJTKkmCEYgLsL7jXCRh0Tn8Y2u8RLIXlrzOb4DXbvOerbLxF89hW8R5+BqEvx3VeYDS2L9WU4tADHH6f0ahSTGZFMKYVG10v0kUV0IXGjAmYOebSJ7tQxyTyDw05Tppt97r6xwdJDhzlzZJlrdxokKQx7O1wcbPLaxecJosocFxpGhHGVlWPH71cj/89rvkfznAMh595E9g2RB/t/4AE/SJOVUoG1bN68zNLKWZ55+hhHlpcJtcYTkrxwDFMYTXPa5iRZYplNM/LpmOCI5vKtnCiFaX+T3u4mg/6AdFbylYsvko/GnHnHU5xaOkbmjdiLpzQ+9h/DvhlaiH0vCWZuhGWGFD5CVHDJJcz0VZzpo5sdEPfArVAM1plOh+SxZPFsHdRxnCuwSYk+cgHhR1A6RJ6BzhFik+y1i7jjR1HLVXIbYttvx5XP4IY3wfNRh08RBWdw65e48u1v4c6/k+Gly2wOBaqbIo3k4vNX2Ni8wvaswIs8ji75PHBmgdWnnuHyeIXLN1+kmPUZre8yHcx44PwJzJFlSn8VFfok05TcWQwOBgnbPUtTVplZgTaSkARlZhR9QWAUp5Y8NgaWSaowuaAQFmIPrxLQtAGpnzERU5JRQpH1sUYxNUMOLdRo+w1sHvDy5VvEqydYjiN2poaWslT9Eqqa3D+CG9/BKE3wUAd9uDoPoh5nqKb/lnfUX+wlmD8mpAAtJUpIamHMA9VjHDExbmeDfAbTfMS6iEgWOhx+qkbnQY+8XzLpz+ad8TwDK5Fosqxga3uLJE3wPR9rU4SdeweQcu57wlGakn0u+T597U9RTedfv6VjcJASf5Ba/v3s7vdHKyoNyXaP/rVtpIyZXRtSf6iGF3nMbg8QtiQ+2iQdDbCZwPg1dCMHOcFlFukLkiQhbEQUm45KLSK0mqI3RnoVhJ2hAwEeFHmBzUqkgd7akM5ixJ3dFD8QaCHRUpEkBa6wTGcZaZLjTE7oC2aFh/R84rBkoRkyGI9Y352hpyWHj3aZeJLagkJNCrorTcJ6SJkZhBMUwx6hkXhK4CuDZ1LKmcU4xzhJ0aWlEnloT2GFIKjUaRw7iu33MHGD6sk2tYcfQdffBWIR43L62Q6Mv4cdvcwsy1lY+RAbrkJn8Ukil+EGz1NMvoRQ30aIEaq7hEhSRt/5LCZdJjjyME/8tZO87W/8Ct/6xH/B9+68TCcZUbv2FXaufJXbrsKzQZN89b3UfvkjyHqE3hhw+F3nGP7BN4nJEHWNDUA2QTYbyHc8gvAUJsnnIJfbt+l953tcv7zDBz/xKTYiwcbExxBRyaYkOz3KMkNSUvflPONASYRS+FrT7USkuZmLu32hl+UFhXF0Di2SyBlBYbFMKRAUFoxXZbG2wEKzRieHwgsgDMmdjxfEhJmlu9CmVatSjXxA8uLrOXevW9ZyR55kDK1jKCzWlbTv9PCWH6f9eEK+/hrTzYBm7XFOV6vcfv03ULMYJeu8evUFLojD/Ne/+Hc49xNPAg7jLEVpsGWGzWdMJmMqyU10rQt0UUxRYRWx+Cyzz/wTpNpBVxTjV3+brBKydK7Je67scmcNlqd/gqc+AI0OEh8BlKZKWt6F0R7uxjfoPtfExiF7X/g7dN75n6F+7FdIv/5fUvbuIvMIsRTj/62IhWMtrr+2xxe/8D/yto98hHPv/SBbv/U5/rv/9tMcax3nZ3/x4wgEqrlE5dRZgmrAnULzs4MNdvzjfPX33uDS6+uES10e+Olf5WViLsSONIfx3hDR38UnYRo/ShFH7IkeNbY4rDcReo3hbkHpWxrNnHvXRqTjHCfmXT0dgt8JmK2nZEmKloqwHtLyu0w3d/BVQWbnYTCuuYx69kfQG+dZ1E3Sfs5k+goq3aOma+h6nXR7B69ygsqJDs2VCqLqke+UlHvX6X7846R7OSJQFDAnQDQB4zDDDNUM8ON5AqTL9s1Y0s1TgDWIaJ6boGoexSQln2S4uEqeGkQ5A8+gEAS6JNnZpfQDCuOQzPCzHWTmkfZHSAqCKgihkU5idM5wvEOlDsmooMzA5jmRNw8bu9rb4tGjZ1hoC7TYZrh7lV62gzUBr9Fi4Ld4//uf5qkPPUbiStIrEwYbGYuLBu94BTMypLdmyFMVZNPH+SAiAdJgk4JilKECC6EPSs47L7kB47BFgd+tYJxD+AKLnXdPZznS98Hz5p0FqdHaYP8KGZLl/sXfsj/bLudV7HnmBfcvrPNxojntVEuBVPPj0hhHWZp9UtF+6JmQ+4ezRnkB/+J7m/zSf/5TLDz1LqLqcWCe7D4rZtjJVZy5h1YxKj7K1PmE0TJKGMzsKrjvouUVEBMIj4EpSN74N4jwHGHrDMfee4xj7/xR1n7NcKd/lYVRH/uNzzCcWqZlkxPdZezjH8b/mSewSYFvLZ4rKTf3ULMRhGqeeeEpZK0GYXWem5GX4AR2e5vxrW2KTHLqbY+ReoLdI5b4xMNEw3WSfICzCcJaWp7BKEVYi3n/Rz/Os8+9H9/339zst1YfD8wbbwk+e2sHwVq7b6qcy4WyLHFJAmIMmxssLR3BFRnCFUxTR38P+nuWvlWUmaGHYCYsKi9pDkpU+wjNc0PKrTWc9Oi2T7KqYevS86i9CsgK3/jaC3zgfWf54Z/9OZpnuxwIFWMcOIMpC0yeos0YGUTgakixiQhXEOmQcv15hLiF9D2ym/8It3iKQ4eWqM/WGPUE1eIKwnsYUa0ipGYuLhXGjiCb4XYv0fr4gxSTDfLbv0+89F7ku3+J/OVfQSQJmCXk8UXkQx5BPWbt4j2++IVP8yM/83N04ynXXr/Cq1fucbS9xE/9xM+TJzleexG/XgclGVvBDzbH9F2Xr/+by2z1tqmcOMHKOz/GTaFZJaNUFWbDCapIuS8g/gAAIABJREFUMNYxCgJm4QXGw+ssVwVRMGU0vMlGfwM/brH2xi43b4yoNyO8aoQILWFsCBYr7F7rM0v6RF5I+2gL3x1meneDyJ8xMSG+9pCLJzn28HN86sEqYmvG7G4PO9hCuRAZV/AiQX+4R6ElK2eOoasVVOTP82o6/z88IP4c1wG9zFpLaUossJtsY/I7KHLKmaJfRGxQZ9io8uSPrVI7FzObpcihJOtlRG0Nix7ZbsJkPGXX7HFz7RadzgJ7gx42Te6bhw8MxsaY+6OSCPemYN/v0jnh7qfEH5Q+DvxTBwnv7k9Jif/r9X2Jg0Fvj+iC4/QjXda+uIH39GH6N0bEVU3cibCTIbNL13BxyXav5NChOlI5nEkwaR+TTCCdYkROIDIU8wpf5ClGkxlBXRFXfRqHapSzhNHWkFEvYWkpIKr6ZEnOei9jXDq053G0FSMmBWML24OUsrA0GxWWT3eoRIKHnjvJbq9g7btrjAcTdF6wtl3QWFHs7Bo8HVDulNTylHY3hDxlJzMEGFqdKmGkkVpQKljfS4jjKmGjjqcdnqfQfkxpBcVwSu3IKtGjH0NHXYSOKIkwNmN7do3+xa/RrveodSqohbeRB+fx8pJasAOzz+HiF5CV2yiZQAakMcXrm1z7rQF7r92k1X6Nhz7+JNnDR3n6X/06z5Tfofzjz5B+7tvk3xMEj38M/ckfJnj4LOWWof/SHcaXttH6Hp0PvY/B5YJ7/+oiQe+fsXBBsfAjH0RmS3DnNuUkoRgLrt64x1ZpOP7jz9FdXuR8M0RUfD71cz/JePijvP7SNf7Rp3+VnfWXafsKHSimFpLSoZ3AKM3hhSoFCu0F5KUjQ9C3IUVZUvV9rHXILKfq+4RxzJ2NbXaDOp1WRL1dY5qV7G0OyXRBq75I41AXM+izeSNiugt7A82lbw65PpE8+f4FfGNoDVPqk4xJv8/1DShefR6/HFKNYoRskmZ7jO6+yKMrj/Dzts7/vvYiN2ebRHGF4w+dvl9BnGSO/iBhZ22P/r1bqPQih7tNtm98CZXcxmdG1fZYEDcJL0D64oTJnqX6rg6iLhheGrO7Axf+ZhvT+xIyfhKCk8AC1gbYEOKlE6SX/hATKLQeo80WlcaI7Pqvk96+xeJP/CzlH/4BZvMK+pyAtTHizC/zd3/nP+LVT/4Uv/Mbv0sU1omjCsOkz/O3N7m9OeAnfvKTtKYVLn3rJku1Ot/b3eNLn/977KUJ6tgqwXv+Gu7Ig3x3t01yb53byy1cUaBR1BZWWD59mCfrIeux4+aORY/HVNO7+LOX2b3V5/e+tMf6tWS/Ig3WmHk1YgyqNEQSCmUpC8ssM0zLKdrTLIaW2djgCkc5rdEaP8nRIy32XnmJTjWn1j1NOTlN1odcenhnTtObORae7aCzGen6Llk2pfHcO+jvGPxIYacFXsMnXI4RNT0POYs9ymEBsUD4++hEM6+aW2FBO6RwIOejcXmSMtgdErerjLeHlLMZcVPTOrOIFDkmSRjnJUGzSvtoG5Eu0H/1JXS1QrjUwLeWrDci2d0j8B2xV2DDKkEck09SrC1YXKizfWuXJSnZ2bzK+p3vMJrtspOM2LGajA73hOLfe+xJoq7HG1euk3+7z+mnV9DHFxj1MkLlCOsazznM5gC50EFgcPn8YECA3wpwtsDlJeUkA8V8/HGYQF5iqwF4Yt4ZsBakREb+vJOCRGqBMODUvPpk878anQPxlg8p38T2uf3ArYP7qzFzcaD1PL9A3O8qsG9cBk8LtNZorfG0wvM9ao0Gf//X/yErR46i/QjrFKUrmGS7TO6+htRD6q1FvHgZI9p41hLKBGmfR0WvIuUmgtk8pyKPKDdusPH5G7jB92g/9j46713CRo6Vv/tzHDG3sBd/n/Lbt3CjNurCc8jHH0AudTD9kvTeLma6i64Y/JXDpNuGwR/cIZx9lcoTR/HPPYRIfdxoBLnBJLCx2Ue2a1Qf7BBGmnqoWVyRPPzo20mnT3H19au8+PzXyCf3OHH8BIdPneHUgw9Tb7bmCcl/RufgYJ+FeHPEgX0KlHN2LtZ4i8HbWCwGV2bk6Yhrr3yXf/kbIZVamyg6SqXyIOuJ47n3nyQbj2mXmkZiGY4yru1aspfvEJUJzVqFWS4oJ7skRZ+zJ0/x8ZN1/vnL3yVNB4TRMWrdOjB/WZmBJMkZ96YUsx207VOJfCZ7G6hiDU1BZG4ShPdQbUNxe4NikhM+8gR5MSXp9UmzgMUnjuJmX8PVHwDVBAKck+A5dKVBuX0FF8Vgh0g1QugdTO/3Mb17RO/+JYqv/q+IqoYmkHjoxQ/w0V99N7//yZ/hN//hv6De7KDDmEHS59ora9zZnPGjP/YeRrcNNhugteL2cMR3v/Qv2c0M/vnT1J98BzSXuZU3SPZG7DYiXGkIdEhzoUanEbES+wy1Y23cJphOMMPbvHHxCq/euM2oKGksnSCsjynLnNnUIMZTrHKoIqPhG9K8IEshGWWQgxcHnGg4gjspRakQ4xotcRS9oNi89gabboOXZq+QjgseV4/w7qV3UB6t8j//4W/yn3zoP6TT9uY5Nf+2Gegv/NJqnq1TlIZIe0xnI7yyYLBzjat+j4mJyehy15O8/4ka10c3aF6s0WpU8Tse6/mA9Rsly4eXiTs+l197jWt3r7N6bpXBoE+aphR5Me8S7Ittuy8M5iJ3XtARcD93RcD9M+JgrG8+JjnfY2PMXDTYPydxEAcSXyiskjRWq/Qvb+G16xitUZUM1fWoLK4wurGOP9tGYBD5HuVok2LURynJsDfFmSmedPhxjBECcstsVjDcmnDyuGK23SeqenSWYmSWcmtsmW71yAVknsZECr8SsLzaJDMpwfYEkzpSHeKCOrX6IifOH6fUEZG/QTe2lJFg5HxKmzPbMZw63MCrB+TFFFNMSbYydjdHbGeOZqtCVTqq9RAVBhTjIVoYGt0K6TghMSFlVKdSaeH5EWGzQdQ9jw6XcdIjNxNGs6vs7F3Gbt8h6p5DRDGpV2Ncdnll5wrvO5QgxSJOb6BUH0kKhYEZ5KMb/PNfHeMZyQM/0OXsc0ewI4m/dRF37AEKUUU8+3Hip36caLKAzCaYhVOk1x39m9tIP6H1aJ3s9SYb3/BZ/tQZWh89xiv/023+6MtfZfLCdY4vf5Zv3hqSF46zy+eJVmtsRwm/9ek/RAcxn/zYv8/hcys0lyrEFY+n3nGWf/zEP+Xa1Q1ef/l3ufTiN0mTKb4SeEXOta2M9mIFoXyMFaQ5JDnsDQs8MnCKbi1CC4lzCpCsdKtszfpYrRiM1hDam1c4RiWTSY/GmeOUac7eep/prmOahfjhjBORz2I+pb1koWIxA4Nux/zwcy3+9Wc2uLuxzriXo9yc/5saxeevfZeX/BY76ZhV/wiPNc/iFrx56Ipz3LmR4aUJS4Fg9bHj+JWz3Nl8gzPLKwi7TmE3keUV/HEf8/Ia0xkUnuDi92ZkR+vUTx/iAz9X8p3f3KH2UwHNhQmen1MKR+Lm1JvtW4blo8/gja/i0hsUeQJujPzKXepdn/E//SzBU6uoB45jsgCrIzylkEFEGL+TUkzpJRukQhOfOkNy8xZ3br/Ir/0PLzGf1TJ4OkIKRU1I3vUf/BLt1XPITgO30GTyzTHuiRobt4egBWEcUtiAb39jwD3dob6qWG47fC1pVw011edbV18n3e1RJsV9VrwUCh34SGFpHFrAm06JTI4xknHmIcc59QXN7lpJ4SQNXccMPL7zJ1f567/8Tr7yuTc4ubfHA6eOs7R8mGTi8/rrmzz26GPE0uCFMNudkRnwT6wgojrtpxaQ0lCOyzmrPzO4oUFGIeW0gP0kYXKHneVQWPIsAwG64oEn5px/W+JXJGE1wNOO5qEYp6rISgi+RFYbyGiAnPUJAk3QrFCMoXJkhSIxjG5vkvQ3EJRE9SqyqhjujWkuBIRNyIOS2WzK3mCHzemAG0WKZpeiyBgWGXvGUoqIY4Hkb//4pzj7yDnsvSnZ5g5ePaHYKCj8Ke0zdZg5VCDxWgG6oZCLITYrMbN9A7IP0hc4KzHOzUcjihJhc5QP6IB8c0jpS3QjmI9Q5DlmlmKLEl2v4xKD8r39k8WB/5fjQP53LWPtPoXoT/8+dj+bAOYju/vxaADcn4oXc2EglcSUFmPmJnelNK12k6eeuMCn/uanOLR8HKk0WTEmKwak6S7FaJuofQJfV8FvsZsrJsUWxyoGKWsI9lByAC7ZT/ousMnLPP/pa9SPNlj58IM0zj6MiBu43RuwfAFHBfHwR/DOBlDMDeUuamJ2HLOdCV4HdCWmHFum9zwqj3U4dK7OnX/2PLe+8ALqO9epLi9z8+om5dRw9MxDcEyzdWvM7osJQbXKY48/S61bJ6xowkDy0GNnOXvhBMk0JU320NojrlTRel4ZB/6tvZ2/sINqJfsYRXlfoCmhKI2djzWU5b4HZA78cCTkpcEa+N6Lz+MHFeKoRRQ9z95ol703FmnVapw78QhFklIWKc+ce5Dbb5TcvLGNGDKni5UlW7nl6uYlLsY1NiYFz3bPcry1jAsOCC3Q2y0IXUmrqtDtZRBLTJIR3UYL7BKlG6CNQUyG2O1tysJitebutW3EoRWq55ZpdKesf2udE++MCKoZQjkMAuPmSeOzIdTaJxHJZVyW4MoRJLuIjSsEtZj0819CP/ocSIdTHZzU86qu8KgtfoLrd77JcHdC41BMfGYFd/ku3/76N/nG81/HljN8pYjDmNjzWYoi3vu3fhYZBqhWFYdPulXAyYitzQQv0kRhwDCRrPVKNrVH1HEsVCAtc3wzgtk2g71dlo8fYzhKADn3XEiJ9HyEr6g2DlGvTqkupIzyiGQCOsmpLXhsXkooRJWV6gmmGz7XL96jcrpgT/T56sU/4kd/6GM0a11mvZI/vv48X7j5Bzx85mH+m3/yq/z9h/4BZztneYtj/S/Nml+y5ySueXXf8f6lVWZW8mqSIP2AIwsen/zrT7Ny+hDJjRFpPmAw2kGlIWVpOHR8AVsYbOB49JlHefi5R0hczqmTJ7mzdncefObEfXP/AbLUWLNvhN73Ibi3dBDEAZhh/mQ7KHzc/1lrvy8B9v15DuIAGQUIX9K5cAhX5Gy/uEatvYyr+POxjGLGLJnRONZmdP0S0s7I0gnZdASzGTu9hFbF0loMUDWPrDS4sWHQG2NsTr43obI4V7qpUKjlRbQcUdOGvDC0A0FQ94nbFYJYUfUisjyjUWQs1hX1Qx6yUbDzxk0ub/R59HwdGwpWHmxzWmnWb/eJWi1meUZcOKJqQJEqbq9NmI0ydieGRiNkODO4cUpQ5uTTGXdvjdjbS+ge7RAtdhFRjVJp4moDKssIHQOC0mRkaQ83XKcpVhHHHqKc3CTwjpGXU/qj5ylKQb3yU1h3FSEShEkgTzGDjGRbsvbZFKcd5z/RYfXJJXS1jq2CeeFl8kpIWW8gZwKzeY9s9CrdH/kY/V/776n/9H9K+12HyLcsZjMlftvDaDTJtTG1J5uc/OkfI6qF7H3mt2hNZ3z8F3+Q/+rTX+OVtUsckVWOrEY8+IDmy39yk9/+rX/Mw8cf4e3vejsr50+guhXa7QZnznjo9g/htWrcefUik/V1PB1w+twSnW6NTqPGYJAzHGfoacZOf4YBvGaLIvTmlbJijhGMRYyxGVuDIfVKgGcdpSmwrk5hAvQ0RwqNKEtMmWDSEuvgUEtSVY5O7FNtaoqGZPONPcq+JTQFnegwXpThsi2y6V2QlokJWU9H1PwzNCqH0fows0GJqJRculRCS9NuN4j9KqXLGWRjWoFHpaKQsosVFawJoJ7gyTH+F8Z8/vmcIx+ssnLkIVz1MN+6/B3OPVNl96ubBJ3PYI8liMq78cQJ8nFCvSPZHkJHBPj5BDfcRqQ5YkXi3DLFUhvdPYpYXqU0HYwMqZsJ1nkk+VWSYp3CZpjUp5GWfPC9H8B2Fnnh619h7eYbuNIhixLJiPL0T/LS3S1qE4Enm/hIHl2MuLfVZrnVIO76WOeTzQRLNcss8rh3F7Kh4fQi6FCwtVNw+XtrpMMZ5b6R3/MVfqyJ6j61hmS8PaVRE3h48/GyKGBiI26PUjzfoy5DZHmInWmdq5tbiJbmgaefQH7jixQq4HbusZcZDp9q0b9zmXi5hVWW+hM1TFYhvzfDljm6PkeP4ksoLC63mH6Bq+y3WZXZD6oC6UmKfD4/r+IA6Xs4LCYx2FlO2k/n10BtkSoEpZFK4qwlSx02DCiVBW3xQ6BwjCXopsb2ZziTzjMQMoUfRywsNJChz3QyoLe+x8bmkGEyI3cZDa2YFCUTYxg5UF7IhcVj/I1f+HkW4+OkicTIkOrSEs2uQEYtwqCGLTR+ZPGqElVXyLpC+CAK0DWFM8wxls4e9LWRvqTs53PhEHo49kdoKHFZDmpe0ZXaYQqDSaa4UuCcACVBK4JW9P/iePyLt5RWKDUvDoi3dArs/l6J/ZEX5+Zdk3nX4MDINzcX2oMJq/1LLAik0oRxjVOnTzKdTgmsR5H3KLIJQdBF1ReQZkia1nB5j1wkCFUh9C/g2AU3AzuFYohJUvKBYPJyH3VIcOSDDxB2V7B6iJl+F7s3wygL9UUYFpTDPiKM8btdsq98juC5jxLX65ihRfgCr6ZRVlDsZITHIhY/9mGCz/8eduMWwULBgx9+jN/4jW9z/dYVjgV1mgsezU7BnZsDbsQv0brWYvWRU8h2BRVp4kqE5wXoqiZUGs/zOaCc/Jlr/+IhndsXWwep1AfproLSmPle3+8jHFQ/CwqdMejvoPWQsTfE87fJsinFdJ070rF57xrtWheJ4pvf/SLTIXi6w9On3oFKpph8TCBLJjLg1c07FEXBbOkomZXkqUEJwc6OQdcUYRAipcW4ElNm85wjXyJooIjAlggvR4gZ8ork4gsjjnx0mWrjaSZJybS8TWe1yeTVO+jGFxDx+0AfR5gIV5YEkWAyE1RlgMhvQz4EckTTx3EY026iK4dwfhPrIqxQ+LbAIdkbvUR/so2THiaqsmgVH/rAM+Rhhd/53Jfo7TjyQpImgnExxVz4IC+sb86NsPdSGp7iaN2nNwo41KgQNjVlrqhosFVHLmFrKLGpI8pnvP7SK1x+7Tq1sEGyOyR3El8ZompAmmU4ZzlycpnJ9ojDhwJkFnCoGuN8n2HPcHeY4tciAheQ2SNs70SIWsKJ84rGsTYrzQVeuX2d3N1hMBjS723hO8GfXPxjMqYYOw/N2591ecv76c/5wfD/0ZL7xgNPS6wBIUIyqak2GqyeO8359z1NpRYy6c1QgabR7OBFEpRHQ3k0qhV6g20KURKGIV6kyJKS3d7efmi9u08mcm7/cw4IRBYn5h0Da+2bUIl9cXAgJA5IRvYgsFDK+1jh/7v1fYkD6QV41QgQWFEgAqguByTrW5R9jYskQhf7XGlHVsxpRRiLQJHljiJ3yKpHEEhUsM9jnc2ourkxOB8BHT1v/+eQoGg3PVwY0BsVOFPi8hKT5hQe6NBnrZeBc8S+oxZahFdy49YWly5tcri1TKMZ027GVDyNywyuVmPtzoRaNyYMQlyZIeSUes2H2BFXfaZZSbI3QXuCIsnZnZV0o5JcKUJP4SQYW+BcSWGmFGVGlm2T5hPSfAQmwJQ5k3xKxeZY65iMhkx3djh/7p0YWYfyOkrOqU6mdBRTyC/n2KbkyZ9Y4sSTbartFibvgLdAfrhgcu9lwpOPobwWTueI0TXKl75M/PYnUK0AVQ+gqJBndXQcYb/2u6TnfwThBzQfPA83rjL5nOV3N0ecGmesPnaKW+tTbo2GJJtTHn3mOD/w4QW+/OU+ey+/wK3RJo/ePMVjZ08SHV4mWu2y2GgxXl1lurtFPh6BlHQWOkQ+pMZgtcCrBITap64iyskUZUosAbkQeIGkGQREpcMbbGNNSaI8nC+RUmMsgEc5muHrCJwhCB21tqa0lqZXEtgUmzmK0pKME/qDAbPNfG6sUt6cyOi3UFKgFSyqgIVmG5G1qZQFgxlcujrkbDMklYLFmmZNgbKWpskph5t07C537/Xolz2iSkjNy/Azha/OYI6sM3l1iKi/Bxc9RCF8Yl+TjV6kkIJkeAe38XW8+gyv/ShB+ADKTiknfcZrI4LhjDBN0KakEAGm26Vy4TmClXOI+iGkq1LmORu3bjC+cYvpeIwVEokkUpp0VHBvY0jFVnjkkad46qm3I7VHaUBrg+w+S8aQiQkxWUxUSvZkhV5RhThCCIXyFGEAHd8StiWPLSi2xyVpJrh0K+XeyzvMJiWmnBudPF8Reh6e1nhCUQkCap2Mheqc1Z7liiITNNoexc0xHV9zfuUEm3uCW5t38AY++csf5fSFFb70lYh001DtFHhVn+pCh+2X1jDJgO7yYeLTXVwiSQtHCdhJiahLpAKQOAsFEkY5wtsHzyu5D7lwuPE8adurh4hA72ch7BsPoxBtFNloStCO8aox0hM4aRBJQdBp0NQlUUPibIotZygtELrEr0ps4VHmEudpXBgS+SXTvV0G29tMeiOyWUpWFFRUSVd4TLISi6DuN1g+tMp7fuCDnDx7np2Lm1A5QrQYEwdVopoEpwnaITKXSN+iKhJVU8jqfCwD6RAeiBJsZjGTjDLNkGEIws7JTYB0FuFJVN3DpWZe1cpKhLM4KzBpiVAeODvH2R2Mrqrv5yT4S7DuBxe8Fd3HPg/c7RO3xP2D94Dm8WaY0Bx+MaeCHHQWHEVRsLG1zd5ej7V7m3QWqlSrAb6nybKU3OXoMkUHMZNRH3xBZ/E4TgZgNhGi2BceDjMz2L0Maj7H3v849dWjONFEuAhBiKxH5P1b+NXWPPRO5DAd4sQU7/gxRCCQnobcB19DPsPdfQ17+ClQmnh1Fbvc5N7dKa/d2GD57EOcefZhtrdGrO30sFGV7uEmpyshd9Z63OxtcXe6w7nVFRYPdfHqNVQ1wJOKMIrujyzMt/fPvlSIfZO3RO7v55suZOfm++8cCLUfzHTgSXCOIkuxZYmnC/I8x00H2LIgS+Z+osl4wFa8DlayvbuBJiIMm7ymHLJIEaZAKM3AwvmHniadFPSKMTc2NmlvLNNZaVA4SzXw2AIqTuCVGWQTtJ0w6M+YmiFxXMF3BmXrSP0gtl0nizeR8Xuw6gRCpngywJibWKUok3vI4nuoyhjpHUHp9ryDJxLSvSlePkOaGcJZrKxh4y7BoYdQtSWcquDQmLJk3N8j29miUD4lklhrIqkZ93JuqykLSzHvf8/b5zUBN38OKlUSnDiPVCMyG6ELjZaSofAZOh8RekgnEYEgDiHS80LCSk0yTS3TQczazoytnSm+9MmyhM3tTaJAEMUhxhqCSJOOMg53IrqtkElSoSg0pXOUwlCOchb9kNULD3Lt9YKt/nWivZJ6+jA9f4/tccFWuUE/GyM0BL5kb2fAtc1rNDv1+ZjL/d7dX64lBXhKEimPs502ITG+FxBFLXSnhluMWVpdYXRngIp9ojgmijVKz8cWVeTjq4B6s0FQ8/CqHk45imHG5tYmZVli9jsSuDcv/I55kVUKue9JPvD3uLe8NvmnvQfuzaTlg3G/f9f6vsSBcAKtJQjLeDRB+Zp4QTG6vUU2FohaiK77OCeZbPchrAAZ2hk87TBFSeQneEqiPYnAIYuCoCxZiAUpAmENttg/xNI5JrV1qMKsFDjpmCUGU1h8B9YWsJNxc2NGt+0jfIEKJUpadrd77PYnDPtDDh9pUe+00E7R7Fr2koJZWmCtJJ9ZbGapVjxUaajECj/2GY4mZPuHelaArAQ0V1rIOMBJB5T7h8WMclrihCSdTelPekzzAufV2Vlboyh3ObWywOTuNv2kR9gwPLu4QuESrHmVWAyxQFFKsqlCZAGtd/osXjiEdD42CXGujpBd5Ioie22DWFp0p4rJhuSvbWDvFtR/4dcxg5KitDgRoMMI4U1h+BJq+ROIUKGjGNls0KuG/G+XRzzwxdc5fnyVzvEGG7cL7m5vU10f8tPvq7OVnOTVS9f44pXnubl+lem983QPHeOpH3+cWIV0qgELS21m0y5JZiidYDpL6Q1GaO0hdQQ6JKiE82TMaUKSBAjlEVRiOp02Mjeo27uEziKcjxQxWkVoFGiPfDKjEgp0EBFXHQttjcUSWYNJJ/TShGKWMe4P2NnZozeYUhYWT/n40gdqZKxQuikVv8axxXMkgwlytMbeMOHK5T2OPr5EdVEhtWAvh6y0ZKVhsShBw2Rk2ZzmhH1DoktC18aERwhPnqL6tgF26UPM1GE8b8Kx5Sa3rnyTbkcxvpPg8ku4cg/cXbxmiZlJ6sGYoQswdMF38/GC4Cjq1FPUVt+NDJaxBFBasqLPq1/8KrdeeZVZWUVXV3CzHULto1zJq1euU7m5ydvf/TaOrT5IpdWl2gyJGjG6kEzzw2wOJZNc4fs+t1OJH4cknkfRL/EChx9BPi45QsLRmmVXWG72DXfeSFl/tY9F4UuFEhB6PlpqKAUudZiZZHGpSlU5JqmkQKIDyaF2DJfv4cmIx8+d5KXra7y+donBdMzdP3qD879whrx6hN7AEXpTOh0J7YhBbrGDbUTrPKpex9oEFUtcLhi/tk10oooMPKSSWOOwGtw4R7QjhBAoJUHPL8ZSO2Tgo2JvPjlWgENCEOA3Yoq9BLM3RTRA+QoCD4tFhgWeNjSqEsGYIumRjHoEnqPI569HFwHkJcJXqFCSj6dM+xskwyE2y1C2QDnDIc9Qt3CXgoqK6LROcObku+icfg9b9ySTnR6tQytUGxGh5yE9UCXEdYXN5nsp6xJRlYgQXFIgpMWVdv85WVCOE2w62xdIc2TlnC9vkdIgPB/p1JzolBVzqpPSIDQq9MEZtDfXVtY5bP5XA2X6pto56AS4/UvoQRVtfvEXYt5NsAcJyhzcY8V9AXFgXHbOkec5Gxub3L79Bjvbm+SmRtt20X7IeLhHWYzDLS7uAAAgAElEQVQ51Gkx2etRuj263UO0ojqWHOduoGQ+F2dGY/IAKUKicw0Wlh6EUlHmIUJUkbqFa3rY6TbCGWQtxvUz3GQTvAz/8Y9gU4u1gPTmoiOfQnIX2Xj73FuiA2hWWZc+X7k5YvWFa5x84CGoNbj7ep/N3QlRK+DciTr9IuLm9DY3Lr9Cngw5X5xm6dhRKlWJxqKk+r7Rh2/1dhyIs3kInZ37XngToyiFfPNvZB2lze+PaAhTUBqDNSVl6SGEIE0z+v0BxhismWeuZMUmr8z25hcfpfH9iDBucfLYQ+xsrDPZvMn29oCN9QH15Rp+Zf47jEsonKNqLLGd86ryxDDKc2yhCRFIOjhvGbl4jPiRHUz0LDkSP8jxIsV45zKVuke63sfvvA6ijwz7KO80OI/QS5nZEC06c7ywALzDiIWT+O0zICKsm9OximnK5sXX2Vm/R7h0Cr+fUpEFtcCjLHIu/h/cvXmQZdd93/c559z17a/3bfYZzGBmMACIjSBBkCZF0RK1UaRlS1EpSlKObSVlyaqKVU5VKmRsqZTFqdgVObKVlB1TLMdaSFESJC7gChHEOhgAgxnM3vv69vfufu85+eN1DyCVRYFWrJJz/uru193v9b39zvl9f7/vcm2DybU+jz95jonZaar1MpWqje3ZqAKiosreEIRQFFLSzgWWq4iUJB9qLB8iDKNI0/BhwsroFJrNUNI3E6RyAvIOwgiGnQ6xrRg6Nr7v4VlVwn5O41gV21aQKLQSqIqhJDViJcKrVThx6gg3b1xkEK4x6hms3QewFwWhsCmlktGgh/BB+2VW25v0gwFW2R4Xvwdvvr/0+OCPjzakAEcJmr7Do/PTWHllbPnqu8S+T1c4hH2FiTPKix4lrzSuo41GFgW2N96HauUaVkmBC63uHs+/+AKdbpcsy+4KiMfPuL+PiYOpubrrADaeno//n4QZfyyFHL/3DhyK5Fug4P87t6IsRochRV4QtvZwKxX0+g6lGR/fVkjfRfkeW8sh4WaHxryFVfaQRYYwOU6phopGSDKE55DFCSbT+DVvDBzKmiLNEFpQZAbbMsw0FMiCTiciiRPiQpNLRZjljAYFe7dGWNKQNiSq4eFNVUiCjNZqjyIrQBnsqodVn4DcBqdP9+oyWazZ2+ph6QLHkvg1j+EwomwJ4nycxiy1pNCSDMH8YoWFI5OE2XgcKoQBZRilA5KhId1aoR0EbPcH7IYB3TjntefucGahzN4pn69+ZRvvSJVP/NfvwnAdS8zSylZxVB90ThwKkkBRec9x6ksSZWn0SKBDm2IoIG4R9Mu409OgbIwl6O11ufnCVWZ+8adA2FiTPqPtmCLxsGMQ5g7OJ+7HPlQed0bTiEGes2zX6KqMb71ykxevbHPfhz5Afa5J58YWL37xVc72J/m7/+CjfOE1j6e+eIlrdzqsXr/IhY0bnH88oXT0HHU7Y3q2SaoP0d7ucuPym2R5zGiYUvZ9fC8FETOKIXc8bG2TjmJKvkejVkW6TaQtEM4KfhpSrk8hZZUiFTiej3ZtssF41FuyE5wsgkix1CxjMljeHNDtJrQ6Q/qDPiILCcMM4piZ6XuZcD3SImVj1GWlFeCKlMs7V6nIlBIhyji0bq6Q9I9SnquxHRqOuoJOatgLLBZLp+h5h7j3/T6HeiGdjRVGww6B9xDrrYzp2hzlJzSxZyErVSbLklFxlWTRIx3ldL4ZYZ7MKUox8dYWtVO3kdZ7sESVuUceRejT6OAOJh3gzXwQ1fggQrhgIE9zRt0ha1ev8/Vf/QwX3Sby+OPURZ3unWtEpsOhZsYQxSgY8IXffwrxxReYWriHx993HP/wBHORYOH4aZZEhdC3GS44OC3FohAMYkM6HGtvtlLNxuYI4UpEe4fUnyD1fdK2JBm5JIlh0bHRtsJ2POJCk2YFjhRE/YJeo0psLILtLjM1eOBdM1QPT/Lbn7tC28DsyUWmwhGWyIizHs9depojyTG+9+EH2Xz5JtmwQ9pJKJYqBOkbWO2QIojId0ekmz2CzQ7eoUNsf+U6kw8s4i3VsZoeuBJtAUqikwIpzZgeYwS6AKtW3rd3KygySIcpRZJjVWzcmkPSyyn5LjIryPoR2s4pJJhUkxRg2YIiiQi7bXobO8zMVkhHAWmWUEiBdMC1I5wiZW9zlSTt43sGExVYJqVh5dSUIAhzqlJTVVWWZs/SmHqIZ79VcLxkePjcMSpTVdyKhbQsjJI4rkLmAtkEuy5QZcAep/zqLAUMRZAghEEnKTrNsHwHk+UUWYZyHVDj8TFCYLIMZVvk4Whs/+o5yLKH5yjcmouQYx2CEZI8BRP//wMcCCn3XTnGiaLA/jiefSs/cTfYTOxbl7L/sXkb7VlrjUHsJ4pqtC7Is5S9ndtMz9fRdsB6b0C7P2T1zhpuWvDudy/xB198g3d9z33MnJ4G2ggcEr2OrSIKDVkMxqrjHDuNV5EIkY+1I7FC6BzEkCxxUM2FcS2iBKPVFYrhLjPnT4NQyJJFOsggU6h8iHBS1LtOIepjDYnJUga47LkTbNJl7Vuvc/HyNk9+/CM0p+vsrC5zeXuVxoUZPvKRH+XySZuvPvMGl8MWJmgy5R9G6hjXdvYpQAcBBt/52uu3dS6FEOOcCaP/2GNSWW8rdsbBTlqPMyQwmjxL3yZ6NvsCSkFRaIwu7ibCBnqIVBLHOGgNOlNk2mayPs+tS9ssb36L+xfOYUcew60+RTCHN1mml2iWXEkrMsTGpeRME6smMycs6nFG0NmlYI7ISEaJoVyp4J/TxLZF2fWwTUJY65LVLfI0IXx1E/EEFIMBarSF3VgHeQYpPGonHoF8D5O1EEIh/TMI9yj7nsjjyflwROvWClc+/zRXSxPMX3iETgTJ3jqpjDk2mTGUiq3dHp/+zFeoTB7mzL2LXDjfxG2WmMglE/NzTKNIS5KRq3AjwaSQjFLIgpwgEGwHOXvDHNsC0Rsx8n3agz0y7zjOTEi08kdM6xHT9RphmiGkRb1aY35mlkZ1kp2eYtC3KNo9jh6ts3RihsTYvPjNDVpYBFaBsjKkDAmHLXZvrnH8sTM89MBZss2IXrjN7b3b9OMBw3A4pkAi3jHF5S/d2t9TXAsmfMnZqRIruzGd1KMVdqg0JpnIFli5NuLUqQmckoPlyXGTRkhsaeEpF2NpjKPJLUMYBLzw0ov8w1/+RZI0vhsqONZDibvOSFJKLMvat5J/69oVRbH/M3IcEXAAxKVEWWpsPGH03STzP2u9M3DAuCOFUriTk4i9PSonZlCORFUd0jhhsNnGL1sU87PEeRcnzhB5ghApjmeYOt7E6IgiGtLvxHT3AuLhkJm6gxGKlaBDPUlRnkLZAhtNECe4vsTNILIUWkM0itnr54xiw6QHuQK3UsHCY2dlB7cMR12HI4tVumubRLtdKiWPdmuIkAo5GBLZYDeqZK6kyCImD9Xp70UwStF+ZZx6nGSIPEcai+H2Lr1RjuV18esVrJJLq9djeXXIRi8lnyyTOZAWCUU8ZOG4x+yRlP/nS9tsvhHx4VmL+z0LVz4GhIgsIQ33iAYRSSwoz5dxFwtE1sbIKah+BFNYmHiT3DvLc2/6HHPaHD9yEqVeZS/6Ci91cx5YE7iPjIUmdklinyyhpnKSb38T970VrOYkSJv0lS/zzNc+xy9f3sZvHCca7ZBZPq998zlKlo0SDkEs+eUvb3HoyN/nw5/4MU7f8yh/8MwyTz31Kld0xK2Lf8TZY0dRKsHKh8gihpJN4UhmG2UsbMJUEg9jbGJ8z0OnNl6thGMLJmpVmjUfV2p8VzBbqdEbgjsKqTUqlGYm0bnFXtSlUfKYaJSwbE0Y7LC8tkyiamhRopsZ+u0ew+GIKAowWUzZm6CbJ3TDPhvtbTqjbfrxHogSju1RpLd5MyvIzIhSe8TlO5Lbz67yS9/82zRqEiQsVh2Sps2LtwM+88WUX/ienGgzxTiz2AvzmCJn/dYuzYbAzW5SEmUqHKHkLTJs3s/5D/xNrn/pHzF1v6H/fMLg5ZSZd/t0bwxpHLqDO38fRg4RziGs6mNgVcb+ssIj11CkhsG1Dd586kt8+l/9Cl8KDIWCX/hbx3n5SpPf290mGLa4stxFTS1x/t4my8u36HS32V0J+NztP0B4R3Bn76XkvoY1eRhZm6NkVzh25iR/1JZMzkmOzEoWlYUjJPrxEs9taQaqRGvbI3plSLIs0EwDHntZzIwtsZVHblsYIbAq7piGY1VJY4FiRMO1WGzO4s2cx5ivMkpCvMNnqe9pSu4riCShPnyWa1/4axxZ8oiLW8TDgEp0D/bWLt/3I+fIWor6ZJ0iyAjbObGsMXFPlensOJ2NXWpNi0pzHMwjTI6qClRJUIxSTFyQJ5DHBcYWKN8aUxdySEeCoK1xKikV22bieIXQ13RudwmeX0VvblCetal98DyVRoUijmhv9dh9c5Vwa52mXMRkOSIpyKMhdgmckkMW9fGrEc1Fj2KYsgX0Ao29n0CcO5Ckkq20xe7aRY7qOice/Tjn7ytz+MMnsY0hDgx5JnAsiawLCqHxSgplAUU+5pDqgjwKx5acOqMoxoWqcA3j8jUlHWksobEqDsoSkBfj8DcMWgpUzUN5DsKykPtuF8IVY3pSlICR2HXvuz0e/wLWW9Sgd7p0MQ7TvGtXevCAkFjWW9aDZl+PIMS+WHX/6aQUd4GEFOMCwJiCKAopdMZXv/kcj33fo+RK09nbIxoOKJUs1tdW+Oy391i/2eZ9TxxlSvoosYAxCeiYIl8mikYI5Y9pO6UMTBdjFtDOhzBqB6RNJhbY7VvUuIW31IT0EnuDZZI2NAcgZ8YUDOlI1KyLaffQw9uoRgPhuAAUaxf5w+df5oU7farTRwl6u8RumWee+gYT5QpJYuj1I66tv8F/M7XMhUd+grmPP8rT336DQdplt7tJsrHM1Ll346jmO5oajO/SAYDYB2V3LWMPJjECCfuTnLfAm7Tk+JrrYv9rb00qpFLoYmxRXBQFhS7276lEYZELCcKhXjvJRP0krdaLJN5xCnUvn33l9zlxY5qHrz5KcCXn+//7R/BcEFJztG4zShTLnYzXNgs+eg9EnQLhT2LZgijKGQwifA9svYcjSrjCRlgV7NopZo7/AO3r/we1M5MMnmnhLbp4SwKt+7i1bVT1OIYQ6RwG/wxIB3Ax+5QrnUO4usfys8/y/Ne/xh/1BJkN/+A/XeBf7I64HrbZGAzpXe/jLS3wPU80+Mo3L5H0t3n52Q2e/9YAq36ExtGjTHrrWHNz2LZPs+wzN1NneSSZmoClGcFMITg55xBaDjdHhoGwGLQl0c4iSQq5WMeoOolj89i5WW7s7rLb7xNk0E8Mk3aJMIJOb8gh1yIJNGns41Vn0GlKp9vhxH2PcOv1NsPWWOQsd17jxS/n+BM+X/jSb9FPQqrVKhP1OsuskJmMRr0+Llr/otbbXLT+/Za4+3sMBlvBTNXl2LTPF1ZuU2if6WqVCzNnqS+epjRXx5qOmH7kFMNOj8Ia2/ErS6AciVYaIceBi2EQ8Bu/9Rt8+jOfIUszijy/Cw7GFsD7jYz9oZxSf9w1rNh/7wghsSy1PxkdA/ODa3yQlHwXIPwZS33yk5/8Ux/81Kc+9UmAH3jPhzm5dBRLgW0LvNlJGO5RhBnFcEQ6GBCNIoTJqC422X7lOSxG+FWD3zDYXo5ygSQlaQ9JhmPXDIVBWQp/0iWybIaZQVkCx4bBMGEnTGDCx604dEaa3U5MNMpZnHB5ZMlh9nCdU/cfImsNaF1ZxdIxJ49K7n98ntmTpwnbQ4KtDkk3xPJt7KbH/IkJFk8ukKQZu7s9dlohu9t9LAntAnJHkBSGNBW4wkXkMe1WgC57DEYRna0Oe+t7rG71yWzJ/FKNTnsEvmTycIW5+TLz84bVakhrI2GwmXH5pQGvvKj4qZ/8WQST1C0F+Q5yFFBSFcpHL2D5j4J7Emn/EEU+wc0Nw1detPjaH6S8Z67NyQ808CYExa1vM3jjVcIs5ejDe9jzj4H0xp1HCQkVBpPvpVR7D3g1hIJf+p/+Of/s07+D9mwuvPc8ndYOFStF1G28mQm82iQi8ciiPb78csp7JgqOzk5iFg6xUZtk/cqbfP12wJ03XyEME8KkoB/ldIYRR5qzY51ByaHkSZQoMLrAUZKtQDI5VaXsVhgliu3WkN31VUbLN/AtD99ysVUJy6pShCndWy/jVg8zCiP2+i3CMCWLEpKgT6u/y24oaHc6KClQogApSJw6QRrgiJwsbjMK7hAnWxRFjCObfPzM+6lPz2L5JxE0IQehu6wMX+Abn5dkZ09RrXrUXEHVExybcfjhd1X5X69JGr4i68fcvrnD1dt3uPeYwO2tM71kY5UX2W2X2VjPafge/XZK7WjMM3fa9GIIBoobr+RcuRRw53du8sy/eYnRpUsMn/0WnUsvM2DI7s0rBFcSfv9Xfp3P/pNf5bP/+tN86bnnuS18HvzxjyKrx3j6C6+xUMn5yPvOoaoPsNbKsbMBo3BAffY09dlprFKEsKewbRuEIg0CsniTPLxN0rnB6vNPs7f2DXb2qty4GbHR0wSWwhXwY4+V+OF7K7zvjMv9760w8Z5FegtnCbaOkra/TYRFjsCq1ZGlMoNWh9mFJoNA0Nkd0e6GrG8OaXcUH/uJ/5Lf/L//LbnOefeJe1D+NANjs7t6lRDBoDdJstejYSzmJ+eYbDRoFCGuqFE+voCqWwSrA9KdgHJD4c9N4B6q4E16eDUHJfYpMkkydkLxHGSaYUYx+ShFFwbiAhNG2BMlhKMQcuw4Y1lQqjuoskscGp7/va/x3B/+LivXv46/c5OFxx/E1Jp0ex2iVgcZxVQ8D6tk09/bQUR9kjxCeRm2F9PutHErBjPqUatkVFRCw8mYbWgmpmEtgI6AnSiiHe9SOwT/xT/8z5k65hEPE4Rt48gUz86QLsQ6o9bMwSqQQpMN2gQba8TrO9hSo8o+ptDkSY7RGlW2sKouRokxDTPNgLGOwGQR0rWQtoUoBKYQ6DjFpAnOVPluUJxm3LU1umDY6/AvfuffAvBzP/dz1Ov17+bU/A+83vlh/ju//VvcvHEdIeR+IJe824l++29RSu6Dg4NCVNwtYsX+rH5MbSnI84IsK8h1waAfcPPNFaI4YdAJGHZGGDIe+Phhet2ArRtdnnt+jTiZ4tGHvgchSjiygSl2kHGE8g6jyg8g1RlQx0G+myKXbO4JVlZters2hxZ9KjM5yjUUm8+QhkPspqAy20eWTyKkg5Lj15xZDbLSMSzn0Jg2Bvzv/90v8uLFVynP1jn76FkMMUdmS6Q1xcKJw7heg3RkiLo7PPtsjyfOVqjVp8gn59gMhjz74rPcbKWcv+d+PL86th/dL/z/NK7yxsYmn/71Xwexn0xtxrxnMVZH7mdOHOg4BBKBEgJl2WPNQZHvhxMWd6cNBnm3QLpb1OwXeEoqtC4w2lB2m5S9KVzboVFKWR5dwaiIhr/ETGkBaTJWt69z8fkRzYePU7EVrgW+LZitKs7MOXxxD2Z9STxI2NrtMYxGzNQ0dtyn0lRgT9LpCdIEbKFIE3CnyryxsY2UPqOWYO92wu6NLp1vX+X2N15F9O8QX79MMmiT5AlhZ498V/PaF77Fxd/+fV760te5fH2VTn2KCx97P87UIX73c5f5yMMNHrrvBG79COtDiZ+M6Ad9jp99kOacwm8ovMoEZd9CC8WgFxFne2ThHr2tDa5fusL69g02gibXNjJGZmzoVncEjy3ZPDJt89C8wwP3udTuaZBNLjHKl+huXCe2PKanpzn10CPUJmdRSKamahhZ4fbNVeLUJmzF+E6T+sxh3nz+NZI45vrKdebOXEAWGaOtDbT08NxT/ObT/5okDSlEQZxG9Ec9+sEI3/cZjAb82I/9debm576r3eDPvf7cVqkatKG7/AL14jbHDvt85coeTsmipGOKbJcTDx/liU98iOmFBlIrbM9BmRSlxjS7JEsQMkFT4Do2n/ofPsXnPvc7dDsd0iwlP7Ap3f/fP9iniqK4qzUAxkGWB2Fn+8J/sR+OJuXYavXAurTQxV2RstaabF/A/MlPfvJT/66/8p1NDuJxF124NkWUUaQBjmcj6g467GF3B1SLEbm02Hn5JiYe0ml30LHP5KEq0knJLZc8iUh0TpanYDKUKwhNxsSRBeaOCLJWh6Q1IhnFGKDs2ei0QCIoa0O1gFCP3Qsn7pnBKgrCVp/dzRHZIGJ6QpBXHBanZ7j52jKD3QCTgWUb7F5GYgKWjs4St7tEvR5pEmOExJ+q04kjXCUhTsdk1EIAOYFO8Xwb5dnESUaY5ogsQaE5ulTjtc0BhTQ0qiV847D++hqXXt5hdzMkGeVkwfgAvnz5Oh/86Pfxu7/ydyjPP4xdljhHE4SYQzhnELgYEzNY/Txf+2qPQafKTK3G4UcCjr5/Adv/Cma0TZbt4s1L6hn86r9c5u8d+W9Rh34eLY4hVA3b8/E9h0GQopyEV/7Hf8TVZ54hQOAUOfHtG0ws1Fg6NsO1V9cJdrexGw2W7pmjtXsf2ytv8I9/Y5W/OXeWhYck7ztjY6JjWFHK2tUW02FEpbDIogK/KAjCnKCQzEzOkpViHC8gGEYQJix5GgePJIxJ0xyhCxyZEkqXerOKnZXIEgiSiGGiie0m3Y01hOUh0biyi6/GU6R+mBKGV7EtH9udI7UMZCF+PkR5JXAriCig4RzDs12a9RoXTp7j+GyDq8lhpgcav7iHUe8CF9/cwIm66LkH+MyvDfm/9r6AiDe47/wC//Qff4zoTo9PRILL167iFSGLky5nTx9mOy1YOnycklJstgp8YeE1bKJ+hOdM0bU+xuN/5V6CnW+ht5fx2z5Rdoy1OGKqt8FzWwU7yxFZ9ibe1++wFkJ7pOgF4dg9RnpU5o/xkZ/462xu2xya2KLvrHHx9TfptPd45Ow5ms2H+eLnf5tR6NMP1nErNZzyPNLvkesGlh6SSYtCLyEyF2l1qBx7ElttEXWfJ+7XWVvL2Xg24aIzxzfm5phqNjj8yAKPn6/zo1Mu73uixjePvJ8vPLVI8vy/IYlvkw2iseNK6jHYHOH6NWZPnSFY2cJrD5lhkvWV13Asm4pOKS5f5OQjHyC67zzLL76IsBu4g2+QmSWGMiaxPDrdaZKJCvPlGtIVZO0u1qRDtdlEpSnoBBNYuDWPIk5ACZSvEFGBKiuQGdoWZGFG1h7THp2Gh3IlOgPhSVTJQgQF4WaMDAdYx2HnxTVay3doBdu4OsP369iHj2BNNshEyqg3IIszZhozVGZKZMNNBoEmNxKTZqggY+KQhwhabNyJKTUtnElDTRpMqjGW5KileOk1Qwco8gxkwuysQAuX9Q2BZQy2JbH2aZm2FBihIRkQ99YJt1pkwxSv3iBOA5ykis40Rppxp1VJhAWyUNh1e+xgJAzkGSYrMDpHOQrp2YhCozOBznOy7hBhCUym9/2wBRSQB8mf88D8y7EOcs4MY5tBIxVirObjoFlmgLzQ+4eoeVutINDsH7JqbAIwps/vp+kWmnZnRJIVlGtVbEcgVE7heDz1a1dJwoQ8H5slfPmZb9BLQv7+T/01nMoxpPP9qAkJcgohJ8AotM6Iei/x4nNDGuUpJio+pfIIryGQ4jom3qAwbbzpiP5uxsVv93jkw59GNv4GmCpIB2VZGCNJc41Qmt2vfpm9JENWq5QtiRP0mVmaYnKqwsbzt+iYVSYnprjngeNsrZe4ffUiv/uFDX7gpx9msWKTHmlQr5xi0m5we/U2jeYsUqp9l6HvIEbGIIwh3/dRF+LACUqO9RH7oOCguDdiDBAwB3Qv7g6KjBkDDMzY5OSgwIHxZGecia4BjTYpSdZiGEbk2qdcckhMishWOXvvEr1OizsDzX3zT+AeOs5vfj6k9cZlbFHwoQ8u8sMfPYIZpDyWC8J0CGHIfN1G+D6JgVpjEltJOgNNybVQEopUo1SNWDzMmfMzRN3nUIMIGddIiykGaUot2OS1LUN/2EVdeQFdXGRnqNnuanpBgidLFG6FQ+fP8PCjD9CPbJYafVbtO3zz21e579QCDx2bY7J+lD/83T8i6lZZ66wyMdPE8hrIUkJmSrh6RC5t0mIBO4vxXUntxDFsNWTYuUrf1HjhRsBLhaJcqjM9VWGhWeL4hToXFlz+6qTkgQdrvLFwjm+e/lmCF79NmG0Qt1KySGIXFdJeRqlcRrouDX+KQ04NRpKrV17F91wmkyHusM83vvxZsr5mWtXRtofTe4NBZxtMSpRn9OIRg3iEVIpzR46xtr32H0ukAXeFSRiMzjF5yunDFtUHqxRI/sponpvrhlZoIBpiyYTmhEeS2jz7rZc5f+9pamUXaSmyIh+7z9keOo/4+Z//e7zwwkt0ux3SPNsH12Z/EsB+I2C8LMt6CwggKCj2JwQCpRRKSrL9qYM2GmnGAFtJdfd9eSBq/rPWOwMHYR8TDMhNhWC7S8nXiJrERDEmShEmxy3n2DWPYtgni1KSIEW1cmyZ41cVqcyw0owsy5EK3IqD8m0sC3obQwrXYbQTM+pE5FlOqabwtSHNxvZyvoCKo5AIHC0RmSZJMgItCIxgJBRhZCgPJWqzRzKIiGKDwELYkiQxBK0RZc8m1hBosCs+Fd+mUbbp6oAsDvA8H2VL8qggSWLwJDESEUckUUJmxknJtijo92JMYShizd5alzQ3bN7uMeyl5MMcNDTPOLhTNtqpsm45/Oz//GkqXpO//bc+xvFDNjJvk46+zBubI6691iK+fZnG/PtonDiOVdbMTya45YvAKlGvxfZmyMBomudt9r464DP/5HXqk/+M47HN4kOPUX38SQYDwW//01+j48P7Hz/OdHQfE89q8vXOOBwssBnohKmqJvIMedGn3c+xJmfwtyqs9RJev/gmpWmX8ycPo0i4+K1rjIRgbWePqhugUkkeaZJEo1rah1AAACAASURBVLWmbM9SqpSo1C2MUQShZmGhSmQpgiDGFGOP9ijLEcai1R1SLTnYvo2bSTJl45Rn0IUkHqVYwiJJArTO8R2LKE+xrII8i/BURslR+AgyYSgsRZF6zE6WKJeqNKsVDk81OHFiljdf2cF4ZY5XK8wvubjVGe5/YJa9SxErszVeubPL5uYqYWSITINf+KUr3Dd6g4V6xsz5U1jlQ/i1MrXpEk1H4jourtE0o5jtfsHyWpfB+uucf/8j+Okk5g5IDhOWDjFgimrzMKfj1/nsRYvp001OKUHY6zC4tcmT997Lt169xvf/0PdxIxL0tE+9PMGdG9ucqDYR8ToT9x7j9bUqdzbbFMWb3P/kx/iZ/+oneenVHW7euM0wCCgY4dqCQiuyQoIJEck6ReoQUxB0XqQxbeGXq1RGa1h2hHE17WCTjZU5tm/mrG4cZ+XiDPPzdSZna9x7bJb6957mqdmfpPfy6+TrL2DCGyjhs9NqUfIjDp+8QEib3TjD2Wtz+emvcaTp0d9LefXWDq38EoXl88jkPEGUsZdtstodsqRg1nGYlEOma/eRuyFhGFFs7+EvTuLPTCILm6wTELQKEpNRnSvhNhxMZijiAqMTrElvnIBcdzGjiLwXYFVsVHWcCyByTTYsiNsh4XYXHIU346DKglLZoeH7+JaNde+70J7NMAhBeVRnlyhNTNCYUOSDLfy5WdLdFJEH5EaT7Asiy1NNZuOQUi1HpjmOY5CuQtcsjsw5+Cs5ejdjYAo6RY4xAcrzsesuaa4peQ6WKzBSooxBCE0aJnQ29kj7fSzl4VoSXJ88DdDZmKcrlYWw5Dj51hRIS4Cw0Pl4gqCjBGGPE32NBlOMp2yWZ0Oek48ihGGcB8AYUwj1l9Gu6LuvHMYd5gOPbziwLX37kkLsu4CMz3t5UPaKu7Lku6DhIIj0gI4ktCbLCnqdPnOLDepTFbTIIc2QEo6+exLll8msOdYcxf/2uc9TExY/+YlP4Dsx5F3idIPWIGR7s0u2dYPK1JPY1UnsiqZUHiHldTDbZNEO/W4EJYFVh96tgEtfvk2p+hTT3V2qj30YOXOUQXvI7ZdeZSBzHn74AvNP3I+6uY6TZwyH67RzB9mTHJpzKIRmFO5iuxWOnD7KcG+Lld0RW3duMn3PcU7OLDFTnmFl+RoLhx5AiLfTF/4Mmpcwdx2L9jEVB+Sit1/Pg8+1ACVgPCjY50scBKft38sDQCEPnKP2nVfEvgsVQiNkjpQJQkiK1AIjePzC4zzxxON0em1ev/wGr915mgvHJGvLrzDas3CqR/jGxYCd9iUeLimm5xXu8QV0uYZdtnHLFlU5LrgsDGU7o58aRv0uJguYPjKHVVQwuwLp3EPsO+DVcdwyk9k2z922WDjRoKpj4labYpgwdWwG6+Y6H7j/AjeDAtur41gurXbAfMnDJHs8+eBxXry2y+s3ewxjxT3nz/FTP/VB3rw94urNNYowQRUCf3+/j3OBJESPtkgQpIWg0AGLSzb1aoVadwOrVhDkhm7SYW2jxuqNjBubi1w7XGFu0mVmwuNMzaPx0BJP156k+9oy4c5rCDEAFGvbLSaqKe991xPcvrbG6iBh3imoOxH1msAOPabkDK9uvoqnPJqTM9i2YXu0xmZ/hyeOnOZOd4d2kYEYA+3ljRWCMKAYWxT+R7LGCLYY3iDvvkqjtIxzrkomHI6FNtL3uHqlw0aQ005ThChwPIdjp0+SGINWcl8obOFZCiEM//JffZpLl16l1++Pp2f7lKUxnWj8rFqPBf0HjkPA3ffAXbBtDhog+/veAYjeBxkHLCTzJzfD77DemVtRNkRkMVI1sEqKtL2JXTjjQyVPEFqjXBvVqNOcLpFFPkFP0G8H6DSmMlnGqiqwBIURqJKHU7JxyzaWzkl2I7JORNiN6Y8KclMgPYEnIU6ysWuCNthyPIoUhWbQipCWJjYS5SkcYRMlOVYqaO8OcYHUGNASkWq6QQLDlG4vIHZcYmOwfUW96aCDBB0lFFKhc4VWFoXUKLcg0RqTGpKdiDjJkbbCKzsI2ybUUC57DAYBna0h7X5Kdy/BcSzmT/lU64rSmTJ52WUYuvSEy9Mv3cEevEH1a/MsVQXOaBWZ7bK8HbI2NBydeZDmVBN3OsX3BjQbu1CsYqRmfVtzpQOq4nD8kItVHUDF5oWtl3nj8oiZ1Q0aq2skiSB49vf4cgSP/fgvMle7wNKwx95uB0zCkaMe0eYQu+5ScgVJnBEFXbRv4dQmKEa7vP7GFlPHj/DwufuZdnaYkBZRrcSoN6KwUzzlUiQWo1GIyAsGngNCYiyFVgrp2FglC9tRuIlLFmnyNCfPc5IoI40KkkwwMTGJci18G4Tr4btN9tZakBUkeUqqU2xVwnNdsmhEnOfEYRff9fClpOLZREZjbMHcxAwTUw3mpqssTVaolGyqDZ/FozWmSyXqDQcpDZW+oKIyknTEEREysiuYI1MsPHIPgRfRs6oszBZMHZ4n9ZoY1wXfxrIlnVGOFSds3+6xsddhO+4RZ4KHSz7xICa5NSRpLqLnjiCqM4z6BYVKmbv3DBPDgkbVIT6accNZQRUBP/hDP8iRoyc45rl0hE9vr+Drv/mHlCq3UUWG1Vzi7L33MjMIWFndYHOrzbkzE3zoA/PMNSW376zT7kcURY62yySpjdbDsQ1NUaDThDS+xSCJ8SbOUjJdSqUCr2yh3Iy8qBIONcHOMm92t1m+XWF6ep6853H8hM+H33OeN906m9c8hpsVstYqSWsXEwT0N7YIB0NGach6J+ClF0YI1ycVI251hki7Rd0rIYqUxdoEfatDq9emX0gaVgXPM/gLk4zQiMGAbG+AsCWW7+CUy+TDgPbVLbQt8ZqHcIxCxxlxN8SfKEFhg60QvsKq2ujYAUsjXEWea4peSNLPKUYpkpwoirHSCfy5KofuP4vjgihivPvuJQxStts9JpoN/FoVaVVwqjZSJFSO3YOxM/rtVeLBiDyOqYag5kpMnXDxqwaRq3HehCdJSjZurjh/1mKlldIPC/Y6HZ79vd/jyb/xn+GVFdtDiaUEjgJBgcgLkjQk6nfJioxcSgyaOBqihMSx7bFwU9lgqfHOrUBY45GxzjV5klEkKRQFmAzLszFpMRb/SYmR1l03HpPlYwoNoDNN/h98cPCdTMy/e23BO3kuuV+oHugJDorWg26l2DdRPHjqA1tA3jI5uvv4WDxrUAiMLrBsgVty8EoeOQmNpkdjusTk2RkKq8TINOkmDpfurOIFfabfPI0z3MXPWqh8xCBIaeUWR5qnaE6UcEoZthvhul0wLcDQ6xZsJDDZLOPWwa5Y2LUzrAxvcufly0wKD2t6mbw/JL1xnSuJ4pGPfpDDD55DpTnR+hrkI6YmJ4h3h1QXp8l0QTaISKOUvFFlcuEQg/VrXHn9Ng9OzzNdnQNb0Sw3mJyYecd6g4NifuyIwt2L/laRv3+Z98PRDjqXet9h6617vw8u3rKPGlMI9+kVBu6+pgM+trQEQo3taV3X4a9+6IO8974nOXzkML1Wn3B3yPXXX+Xmm19nNBIEUY3jDx1n5mgTLboEnmC64uCUfBJjg6cQ9hgyRplG5jmd7YBeGjHKIhxXMm/Z5HFOvh2Qzx8Gv4kxHkmaI5WksTBLNZV4NZtBfcig1cUzhsfff5S5xUNMSNDCY3e1y/Ll2wgVoCyJ35zlwrkaW7sd+nFBqxtxaKHJB+ZmqPsZ260RUZxQYDDCI0CSywBlBCLV5FFCMNpldRBQXzjHtBzQmLCpVwzVPCNKXXpFxnBvj2tRl51qicXpJieWJlmatXnf/Ye4Lnx2VgrC1iZpe4d4p8VwEGAXir3WLsNcIPHJDahKlVBEyNzBZBpHGMhjlvvrjMyAtIiR4w4FSkl8yxuD60EPXRzc+7+g9e89pjhwNDPodBedXkJnl7BKPfxSGVe5LB6WvHFzgOsoeilsbW+xdvkyRx58mLnFWbbbIwrLQkqQxhBHEa+/+gpf/NKXaXe6pGm2r6k5cPWSb6PTmT8GAv4kze7AiU0bjSjG3yd4KzANDqycD67Dd54CHqx3mHMgEJZEuS6VxRq99QFFHKMcGyEscBTKq+FOzbFwPsBkCZ3tXUaDhCzSJEYyW/UwwkXaDspR2CUb24Z8EOEITdgdInIBQpIXgmiUE6MY9BJqtsAUBmkMUo69cvu9iEbTIo0yPF/hlhWjosAqNHmiKVcVsgxjs/SCLA6olRWhHouNEAVlHzzb0BqEBMMUf6qEzlLyIqdQkooPUTchjQzZIMV2FLVJH9ezkFWHKJXY2GBGxEFOMMrJhcSvORy64HPskMvIdtja02StFONvUVrykH3N719+mnh5AOsDpmzBRK3O4fc/zJnv/RGs0VV0/hplO6Rc7FEUMbl2eX1ZcEv7zE/4OGXF9BmLCx9vcPNGm+sRvLH5OvYfvE4pNvzYnOQ5U2dgF/hLs0wdnmNoCxzb5dSZMlciQ27AtsApC2xjGCY7lBaOkyx3uL4RM317xIm9mHRQMFcrkYfQ2R5i4ozCdzAll7jfQ2SaQb9HYgTK8xFSYFc8QgTCAq/qY3SO1ik20O9FGDQ7nQ7Cr1D2JVIJXM/Dq5QY2Q5R1EFm8XhTMZqJao3dsI+QgmjURRYVKqUaFc9BJxl+RVGfmGR2ssH8fIWpWR8zlDzy5GHmz5XJNwzJdk5vOWb0aoS9dptmtcFp28daOM3Eh+d54D85QtNo+tsLVEoOUggyI0ikpBtCb2/Idici2dth5dItUvqUjlRpnHkA15To9EfonRFD7wilxgXmq2Ve+voLbM6d4Md/8CyvfvZFhqlCHp+Fc/fy3Kf/F37mgx/lzhvLnDg5wcnZGlcjm5qq8tIrz2Idu59aOuTxRw5x30PnuHh5h43VFb4xaPPTP/ooNeckU5M1bqx22dpawZE+QVQhzqtkWoJOUKoF0ibu3mHUE5RqFmlmU9cO1aqiWi9I61OMohFRskMSt2mvxDzdEjyxPcOTHznO7IMz3Fx6gpVbc2xcepowb5P397h56ypoCweDySPu7JZJvBp906JUxKRowiLjZm+THzlxD42FBvHV1zBhjBRVal4Fp1xl0BaUe0N0XJB1h6QVB8uxKEzMcGuVyuFZhKUxJkcHAWl/QHmhNO5C6RyBxqo6SKc6bkPKgixOCXf66BSU7eBPlensdvA0uFNVjj/xEDMnjxINe5SPTbGz2qMz6FL2XCxfIbXAFDalmTm8egnhhIRJi6S1QxiMmKkaRCEoLSrsqj3udRYKLSQUFnu9jKOHbE4dsknigry9w1P//P/k/T/+0zi2YCRAZAZ0hp2GiGBIMuqgR1vYvkQohyxMCEYhrsixnKmxVkBZaGHu0iqwDDrLyaOELMrH+6RloXON1AUUOVIK0AU6KpCug3QsiihBOQ5CQhEXhN3ouzgs/5T1pwn+7haHBxX6nwAD/05sYN729Xd+qL+lIdjvYktJUeh9WszByxkLjYUQCPPWgfuWV7jhwJPfiHG3T0jBQcZykRfYjk2WaYajjPJEiYmpCmfvmaJvbDo9TZwPMXZAba4EgeZLt54huHyHZjhixrGpVaYon77AwgPfA6OrWDLClTGWCTEmQeOytlvQdepU3SqeyqgflSy96yzrK3e4eV2ws34Ra+0iNa0535zkWj5DoGOaM7P0yi7akni1Bo1jNZZzQYFAyoxqSZJnBd3eCvWlEwQ7Fpdv7DJ3bkhpMgADJw+dx7KsPwEOvvN9OAAHd+lDBxMXo+92MZWS46LlLoIwd+/H/pxg3NjAvDW1OMii2H8FYzeq8eNKSZRSSCnwfJ/7Lpzl7/7M30ENbOJuih7Bkj7EqfISOxstytU6wtnjoUcFD75nEUfPE/YjrMp+mOn+35lFmjjIGUYZUW/A7s097HqGN9PAmZpGGYswktAZEc3cS602ixmkbC23GE3M8NiFGa596TrSaUBzniTbZfvSC7z3Q+fYvL3HseNNYl+SOg5WCldu3cQ+fZ5GEfDwA8c4fHSG9a0hO3s9epHF97/3JO6Di6xsh2zt9mj3h/jSpR/6DLMSqVEoO8S1xnS5nVtrbO96RIcFmXZp1hQTFYdytSCpV+nHGUHcJxnGrIUFnU7Kg4drPHBhktlzdVYW3sXaygQ7NyWh7pO39rj25jWifg/fVkQjzTY1ZGOGdr7DRBbiei6uVgwHfW7FHVI75f9l7s2DJbvyOr/POedueXN/+77UrpJUVVJraUndUqsXdTc0NIahmcZAG8IzeGxiPBHYnhg7PBF22OOZvyDsGNvjwOAhwBDAgHugaXqjpZZaS2uvUq3vVdXbl8yXe+bd7z3+I9+rKjUGBMYezvvjLXnzvpvnLue3fJexYom238OPQqSSOKYNOkKj8VP/A4Bb/h2PO0F5gk7apN47aHEZWfLQ0iSLBQiLUiFhfXef+dFxHMekv3Ob6y+9wOLDj2BIEPk8icwYdFv02012trb47d/6P9nY3MQPAuIkJknSO6RjdUjzOfIBAd5/L+oj6FF22HA7Sp4P75t7Egoh7knQ/wr50QfrHIzPkVgVov0elpNQeewCycVXSWsH6KyAOTGBPTaLMTVHYXqK0doOpWs50qZN6ocMmj7pnD0kNJccsn5MuDdgEHoErR5RmOBlICybMdckjTX9IGS/FtP1I9wpizhOkaZmdMxian6UXrOHSYr2IsKBQDoS05b0DwKmZwsURguoaRdTSUppyPGGxHAcbhwk7K12GC0o8gWLZKCxlEIVc4xWDYTQBDojSBP8bkzYF+w2PdycxUhBoSxBpiRuPk/Lz2i3ferdiACBUcphlzVULNKxeXb34frz19lbrRGnGakUjB2vMHOywsOfO87m9T223ogZzytO/dDH+OnH/wnh6ldIojfQuR6ZkScwcmThGjUv4d0dj2NLi5yecGgMbnP+sw5fvb3J4+csfvKYQxIndPsxhasJ9X3Fv/jSR7ldNLlxc0CnmxI4Fu78NN/61jZV22BypgI6I05C3CWLopTk3AG3DgQDL+Pm1hpvvPoy5y4cY5BXlMwMs2zQ7YEXgTYlfpxRUNAd+FixxC4kOEUXs1gicas0dw4QQYAReBg6AWVgFR0m7SKbBzHNnk/Hi8mZBkvFKlGzjUxDkqhH3jQoOnkKRYemMKlWRhmVBmQa27BwLQdDGARZysz8FPlqESUUZiYol2xKSxamY6Fj6L8SkK36uM0eEwc1Ym+PmeJxmmMlPvJEher5HIUwZbcdcnCjweVClTFXYgjoBZp3ah7Nt66w6u9w8+Yr5CenOfPERznx5OOcGTN593ZEfr9Hc2+XzvR5lvMjVM2AN7/zJoMHn8H6cYNrN7bYOciYiwssf3iB9WiSf/wf/3dkmeTjIwZPfOajLP7Ij3HfU0+yt3uTHAaIiJdee5PjzWX+7k/9MNHOSf6X5/f4k+9sMjk9RXlhnnMTHnJlEXHwPbYGVcK0Qr/fI0g0sjCDao0yOj7P7q0XCdtd6m1NQ9nkbJd8+SZLpUVOnzhG6tj0Ykmr02Zn/V/xp995mNcufoSf+dEpPnWiwMbocV4aq7LxmqL12tcZpAkls8qIVWZEhVRnzvDGQY9I3yJWGSu9LUgz0jQkPdhl8dkv8u3rK4TRADsIWWr12XnjPcYmT5FFGZllIPMFzGIOIz9spZYXC0w8sYQ96aD7IdnAx7USVN5AVVxo+cNg0xYIy8KolIg2a/TrHaJeQH6qQm6ywqCV0a+nyFgwYpqYE2UmZitYpmBQa/P2y2/z0FML6MSnt9VAqQzzxDKUq5iFAmY4i7V9iSQL6Q08ihWH/KiP7YZImYElSYUkixSSPJdf2+G1TY8LD+U5PWmyfTnENQIGXgcvtRk1BM0g5aDVwNheRe7eJsRjZqZAvpjDMCSyACk2ZqmMKuQhDEgCnzT0iT0TlSuhJGRpTBqHQzU2yxlCjtIMHQUYjoMQCh1E6CTGqLhk7YBw4CGVhbQdUlK8VueDrxp/2Tgqu7//j3e/a3H3ZyHuBgj3aHr/dZsIR7G9lEegoqNkQLzvmI5ce0mzO1VsnR1hco8clUHIIwjL0C05TTPSVHPj6jb2eoOR2RHOPHmGE+cv4PdS3v7at2m1OwRpinAsFo/PMj01wiOP3ce7ZoDu7DExMs782U9xfvJjhPtvorLrCGmSKZdUCLK4xiBOWGsOePDsA7hGl1TWKC52eWvjf+LEdJ4nvlTGI0V3PYxuHuwH+OKpB2mIlHYvpBsl2JMzjC8f55XXX2R2ZIRS0SEYRMiShenaJGgMs0Wt5DBIfbbrW0x0xjm2eD+uUzkkA9+bcP3FQxzimjnquui7wc1Q/UneqYIKMSQsKyER6ggmMTxjR19CKEDfIR4fGTilekhaFhjobMgLsR2bM6dO8i/+m/8BQxr0rvhwEJLtNik1Qz41+yEeu/CD/GnnDWYeX2RpeZq8F+JH0G9F7IQWZXsoc9sKNL2mR2+nyXbU5frKe4wvzvPA3FkmZkYoGZK9doLdC+kd1Bhoi4rtEHQ63Hp7m/j0McxHFCsXa5jNjKlz04wUKhy0cvz6P/tdtFZ8fMlg4XPPMDE1z9zZE7TaHVwEmYj47utXOX/+BM9+5Bhex+eb13u8canO6MQ4k3MCp+zjHrTQ3Q22rSLVrMRes0NatFCFcVyrytLCPK+/8m0ObvY4uGXgunmqFZfRUcWx6jwPnJzDlyb9SHDQ2GZv93t8e+sE76yc4QvP5Zket5jOL3J9JM9u1WX/5RdphDFnTjxBIWxQKdrkJhd4Z7fNIE5InISJsRFMLwIvxk40m36fx4+fI+fFbHXbxFGCI01sY1hMGfgef9uzgyMInE67RN0XEOkLw3vCVDh5FxlBv2uwfX2Xc8enmFrMYx+kpP2EMGriDfqkyiZPxkEv4KVvfIPvfuNPuHr5PdrdLlpnpIeW7FINr+8s404H4UhqGRjKNHMX4niveeOwI/r+e/QI4nekTHQESfozOMs/Z3yg5GDr0iar/nVc12Z+ycGaGKe3tUW2cUA0ENjTM9gTOcxTc2hlkj/2Ie4Li9SuXmP/9irdfp14HcJqicoUGCokiX3CQUBJxIRpzG4oKI6V6A9ithsB640+22lG1VHstjPGJhxyWjOIM/oS2phcvDlgomJQGbOJ0OzuemQJlIo59na6CCugUHCIHYPEzjEwQJJSncxBnNHvJZhRyE4rYGLKwMkZHAwSvCgbVuBQmG7GeGZRmLQplB2QikYnYN9P2ffhYK1Lz0sQpiRvaywyRk+4bL+xw9ZL6zhhzIgaznSQUxQWLJ77zBwv/skObZFgHJ9EuEU++9H/iovXf4nav3mBgwfGOHH+UZ4cPY7ff53Weptf/LceP/Zz/yV6/y1efOHb2L7PT/7CLH/8v97ij14O+Lkv2szcr5BtRTgQrFxMKVNiyjH5/LGAkTmP/y1ICFotPvuP7ued39liZb2BIRUjJZNJJ8K2FHHHwpgqUwl6pH6Tq6+/Q5j16Q0gig3MJMP3PPwwopykHBstEEsYG8nTqPUJgz5ZltHrJUOTqyiiVutiYJC3XXKOJD85Rj43TiFep9lpYJtFLKfM2uV1fCQT1TGqpTJlU1G0HbBMojjCt1zKY1WyVGMmAVkcUYszyrbFyUoeUwksQ5EFGn/Lx/Y10abH7X/dZXN/BSO4yJj0mak+SvmhH8H8qRFGYvCl4LWvrPLKN19lubyFeOQzLJ+zEJGivdGhu7lBNrhMFtwmVDkeeOoLPPvZB1maLRM3NasveIi1W7Trb9McH+HRB6c4M51na7XDd7dv8k8/8wUMaXO93eS1V9/mIbb43Bf/M37rIz9P/fbfIx0E/IEn2Lu6yY8/0eAz/94Frq3cJNp7HZ1YzFYKuEHGN3/vMj/79x/nlx55gBvrbS6v+2hSJvIaqzBCuGHQvbFLmMszgknU7lDb7uOV5yks7rOoz9Ldv04yaEHqEQddDgYZ/YMD3rv5OtPjBabGq8yMjvD4J2Z4+9Ilajuv8C//1cMcO/0ITz11ir/3+BSvPPKf8G+9Fu1LbxDrNsLOYRsO242Y81PH+N7Od9FBH9PWpFKwFvf41fqb/HL5H/L5Z36Yr774h8RRRNkFO42wozY7a7cZf/Ic9oSDlAHh1ha9gz6jF85ilQR4PXQEIm+jSjm0ZZH0A4LdFpgm5BywbCxH0hMu/fpNqrOjFKfzGBWDRCZs1zNGKy65osXNRoJUghPjFoyNc+pzT9O59irp7jaDWh1VLGKPzOJUhxV6tzSJbdnkjIxKSVA5bhH5Hm5Fo0zQpkEaS/o9wd7NkMYgwVSa8dMWx48XOLmR8vXfb/Jf/OfP8diTX+S96yUETdLBCnH9Fj/ysfMsLC5gWh5Rp4lRHaM8PYM0c2SZJE0DlKWIu33ifgCYaDPByoGlHKyJEkJaQ7WGKCHxg6FztH0EwTCQQqM7bZAK4VhkaFLPR8mM8WMjH2jB+OuN71uMvr/DcBRFfl8A/9cZ4rDilmZHleZhUJndU4GT4jB5EAyNg1J9JzhV6v3/f0iOPVyg5ZDcJ5UgjRNCz6ez12Tr0m3GqlWufv1VZhzJkkpJHEkyYjMyX+DJ88u8/OIKkeNijy7gTJ/i5PRT7He+TefNb9I9f4bTufspmIooukHQ3ud3L2V88uP/mO7GH7G/cZNKCWZOjnNlY583rrf57CcmyNmQ2DZhYtOpHWBojStTHpsIaSuf7faAYuLxA1/4GO88f5m17SaOZVLSAbbs4+ZKkFqcefxRCNuk3j57GzcZH1ukmJ9AKe7orH+QcZQYHE4WR12Bu2nh0fzLO2Ct9JDAfJTAHXUclFR3CORHQdHQvE6+75g0miROMISBkRq8+cevY79RxjwQlIJtqoUClcklBg+eoPIDI3zce5pMKi5+fYewfp2x8Qxx8gRjiw540N8eEHfr6GCfLG6TGDYPP/Esj31oCteQ+G1NsxZAeEYF9QAAIABJREFUq82gu01vdoYHZgsUTMnqwYD31ur81JPnyLTkrY0mjddW+LTxEOeeO0ft3IfZufQ26UHM7zcVnzpT5/7ZOc6cm2W/0yepr6DjHPPjLuGBz4bscO6hKb60OEmtFbB+EGPnYKroUiy4RC2H3kabqGAzMVamtdfjoAvh2Ajl6S5PxxfYufUOYtAjiQ/w9mOub6UclLZ55XsxD94/wfjEOKfGK1xYqrB6+wZ762/zy//Hozz56DLnzlb4zJkZbi6P8q0kYPfFlwhlk9lRC0cVCQYWjywt8513UnS7wfJEnmaWUG/5qBQcy2YvbHNt9QpJEqEBrxuQ6Iw0TQ4lN/+WM5IPqw06C0nDHUwLhMzAMElDE7+f0NoP2G8OKLiKM49OU8rl2Vvt8u5bV/jyP/wJvvSz/ylf/sN3uH3zTVr1TQa9LkEQEcUBOtMEQYhS6k7yOxT1ujsvd54/9xRdjp5uhnEXfgSHcKFDON4dDoK4yz84MkOT8i+f9w8kZfr5Rz/O6fnjGLaNZWSYaYPm2/tEviA3PkpubJQMF3O0StruIktFnNkSdi4m7O6zurpNyYg59swiByttdJRhRAlyr4fc6eHVfXJao7sB9abPgRehxFBqbKYs8L0YxzUpFk0KeUVqpPhJhj+IiLIEP0mJNdiuCULQaXu06gN0mhAmKY1+wu39gLeutZGmYqKSw1KaMInohSG+TplcrtDpBux2Y/woxZACM6c4aCdkSmLlLTq9mL09j/1dj07LJ0xi2hG4jsAwIUph0Is5uNmldalJFibEGnAVY6dLPP4PTvHwk+d44eV1anFEc62L7MzzwGP/AXbvN/iV//Gb+DOSE498nvPLTzMnNfvXf5tf+Of7/Pgvfp6zSz/AS89f5sqNd3jwEcXCSU0yk/DySxHFOU3swq4neHsnZXApJbzvAg9OnmKmMk0cJWxsrXD9UpOx3TqPP5EyfyaPWsjTdxVxP8ApqKFergu2m2IZgsTPqK23UYaBEWboFOJUEWmDMINOP8axc8gwRkZDHV/SFH/gM78wR+ZrTMMizaAbxLSCFGmM0PZTms0uyRERMw7oeD28Xp8kCdFJSDTo02i32G130drFICBWkkxo+v0mnWaDNJRUrQLj+QojTg7LS7G8GKOb0r8YEL/dJWh2yZlFqtYk1dJxiksnUUsO3XcHXPzDTd792m/Rv/xllqp9Tv77/xHLT09RQLBydRshdkkrPjecCezzz/LEuU/ysSeOMdq1qL/e4a2vvss3/+BXuL3yCiR7zPzAF1g4+yCkFlcvN/nTb73E45/7FI6w+faffJO9nTVkoYK5/DQPfXSCd/6wT9u7QSoszL6H293hxHMfp+VpZl1JR9nsdfOsbXa4evVbvPjNN/nUhx9B5VymxhwqeRuwKFXyuNVpHlgokPbaJJGB4Y4wMlWExvfw3IeYefIHEeX7CRILr3+A0D4KsHQ2VOEIAvrtNvX6PuvrO5yYSHnmQzGqt0ltd4cr15pcerfLRyZjfuqLnyA8Nk1tf4/drQ06icfiqODh8VPs7V7ES2JSmSNIFV2/y0kBiwOH56+v0PM8jCxDpym54jjP37zBtNtm/Oxx7IJDVN+l+fbrtNZ3KS7NYjhFkiAj8jySzBvC2Wo14l6Hg/0WfscHLbFLBYQCZzQ/7FJKA+XkyITJoDbAKeWZX87TvtrC6aXklElsmZg5hWMoNl+4gjjYxESQq4xRHKsCGsNWZIlPe/8qUtcZqybooIvdj7AnJcIWaJEj6OfYvan5+lfqJDLjyR8us3jKZieJeLPVxzdD3n2xwSvfeJkrb/4pK5dfo9feYn7eYH7OIPU7DDpthEiQKkGLcAjHiyMMwwY97AxIywZhYDkGluOgbBekQiqFVBJ0ik5jrFIeIeRQu3/IXx5aWmWauJ8QDmLitk8W+AzSHr/y1S8D/++kTJMgIAkClGlyb1Kg45jorZfo/eovMXjrDZzzjw7l9eL4Lub8HhlRjr7d+/twT9x98c+O3/+93+P69esMdfGHhkFH8n4603cIf0qpYeB/T0B7RJY9Wpgz7hJghwGrPKx4H1X4hvtLwpjBZo1CzsbLNPZogYVHlrnw6Q9xbPEUb6xu0DY0u6vb5OV9TFdPov23+JNvPo8x77K8/INMFxawkk221l7kd762xrOf+wnGC+f42gv/F1puMzuXUahkiHLIW5eaTM1DLE0avqLWTon2UuyFRxnPFclZBYKwxdbOGu++fpmqt8uJ+wNGpgp4ZQOfmCyJMW1JGPkMpI+SIceXz3PqxGNMjM0dkh/VHY7AX5a0bW9v8+u//uvAMPgfdl/0YbAz1PaXRzChe87pvalHlqXDWEwcdmqyoSeHUuow6BF3trvDEckyDKkwMbFjm/KgxKX1dzk1e4Zifozc7CR6Lkff8SgcFNn41gH7r71Muv02o4sFpj/2GKPHCjhasLXeJlfo0bahXRwlt3iK0wsnObtcxWoJGqseV19Z4dJ336C+eQuDDuNPPcPISJXAF9y80WD1Vp0HPnIKUxi88AevEfS7FOYmqR6fZ3bG5eYbNluNSyhzlGLYpuhC+cQiKYqxnKIhFfvNHLfXdrhx/SqbN/d54PQC0jQZKRiYUqGUgeM6OIUSy5MOcadLmjkUykXK+RQ52MLPLbHw8ENk5RM0Bxm+7yF1iI3ATWPMnCButWnX99jf2aJR22d5SvPIhRj219ne8Vm5FdA6iHlwQvLsh88gTsyycvkK2wd1UhGyMG6xVJ6gu3WFXpBgFcbp+D4MujycLzI/f5Zr21vDIDVLieIILw6JknhoIOY4/PTP/AzTM9N/4bX173ZoUr9G1HgH3X4DVUgQBmhGCPsG+xs9Vi5tUSwrLnxinsnpAptelyZ9hBvi1TtcfvHbNLauYJkxnten3x8QJzFRGBPFyfC5cuf6Fu9LqI+S4aNnoWVZGIZBmqQYhrrbDbiz/aH7+D16REceCfcS+5M0/ZuRMpXGMPA2LBNlJgTthCyIcMdnsAujoCokvSLha03UpEAcn0Y5MYXlGUZax3Ffu8FezeO+tTVGRorYJRtZ7xKvhqTdiFKkwQCjYuHmBfme5EbTJ5YZeUvSCTSmThBaEmaKdJAQtwKCOGXUFcxMWZTLFlGkGYTgDVKCTNMbRHh+AghCBCUFI2WDSKcIW2JoherHjJQFQZgQpBIRa0QGfqppdyNyOYUfaPxWQJhBHGsSBKbOiNohtuni5jW9XsSgGTHoxrT2QzIvBSVwp2yWnzzJyU+cpa822LlyjcZKiz4KWVpk7tgU56ov8erK21gTFtOTy1yoLjBvOdTaA76+rmnFkhOTF7DVCl5/h1o3YzvNyJkZC2MatQBBQaNsGDcEct5CPWVx4cRHWW8HpMDpBx7hJ35ulpdf/a+5upnSuxQyOp8yWQ0ZcU0OnBxmWeK4YOynpB1BFAt8P8MxEsJIUyrbWLaLGTvkfIj9gCRRiNjHizRxFA6JYaYJlmL19gF5J4+0HQrSpFxVmDmbzm6Lei9iZnaOrN/DRmMLhac9WkGPRqeJbTqYhosyTCzTpFQ1UZlgu9EhUyZJrMEqUizPQlqk0YzJpQnS16h8DlnK4VYN5ObQpM1csrFGBYbUxI0BN7/xr2kGHba9Gg3dwP3QQ4z8yN9h5sOj3N4N6W4nuComUwrDGeXMyDhTE3n8RsLa83VuvfM11tdeZ6exTctPmSlVWfeXeaQ8Sc7JU99NuP5ej4L0sedytDp9nHiPXFZDdWcp3hjw4GNFTj73WRq//2X87oBa12Jr18f2PE5dWOTll77CzLH7WXpwkl6vyY3vdbl1Df7Jf//bfOqHnuXs+TlGSjYuCUoKdm2LxJhm/oSF0+jQb3cI+gHl+0/i19eJVrY4tXwfx5Y/yc76Mte+81XS5goaA5UG6DRGJ5p8IrDjiOurMWaS40MLkuOFW1zeqXFz7TK/8ZsP8NjVWZ55aprJTz7E6yVYubLNxZ0tOrzAJ5cvcGXzNptxj6b2EUri6Zj3Vv6YWIyzbBSZKY0wWq0S5yw++dkn4dYl+hvXQXaRtiQu24SDGkHQwMpKJFqTKQ8lI8giwlqXrNtH2RXSzKbbSxjUAkrLU5RPOKhSHtGLGWw36da7tJttph+7gK0g5ypaux5+I0A1XCZP5Yn3ulSzHlFuhOKxGcon57HLeaKBR+DXcaqa0olTxEGN/de2WesOeObv5JGmDaKEtx+z+l6Hl1/uUVQZ1XNlZpZLXNvo8fa6z+1OjCU19lxKdyUkRINWJAYkbp/dzg6luQnc4jQ5R6OkRxYaaLeEaZcgAWkotJJIpTFUitB6qG1v2kjjUM8/PeQi6JRMg1Lcxc8rhbYlOomGakZxhLAEwrDQsfVXWTH/7DgM8KVpkgQ+rRvXqJ48NSzlC4hf/ybxS99E3FpDplsM/uU/x/2Zf0Bw+wqJ4dCPUmqXvsdDf/8Xhwua+P6E4AMSY/Whssc97xDyLp/gDjwFSJK7uvlHMBg0MESz3GnHH1IYhuZzcug0msQJCIHj2oyOV1FCE1oG40ujnH70UUYWRvBEm3DvBo3NOj07R37mUY7PVxjP32atu0ZutMBY6STz9giOgAMvZrUDfe0yXlhCsEmn00eoiK42mTNSqm6KngiJzICC4VB0FfmZWapTP0S+OI2fKnJGxqmzT1Jv5bh65Y+4tNrkwBJMTHvMuC6xlSdKqigrIWfbnHQfZHPtHYrFEsViFSnVEU6BuxPwl837UH5USnm3Q3CkrJLpQ16AhDswibskz7sBkbjnHB66wR5uejdBuQupEEqhpEExX2J2cp7zSxd49uSz6GmonqpiuhIDA1lrkXt9lXp8nbBXwzf7lJ77MOMfPkt+Okd3kBG0EwpWSopBwc1TsHPkcyaxp6lf7bP+1qtsbV6h1h0Qk2OmWmHHn+ZMvogQkkY9pt8IqVgRRsXA80LGsm280EM1+hSaKZUTNic/eT/XLv8GB2nAzrbJsb2YBTQT0yWuvVVj/vQp1LEcB3uKjRXF5RXN//6bb/Lsc2eZni6S1wqdDhlHfVORqRKTcwK3FxIOfGJpUXHHCbt10vUDHjy+xML0R7l5fZqbFy8Sbt8i0SbOoIvWA4oBOIFCBR43Yg8jKfHY/YrtrcvcbGxy6+oEBweLnD9T4qnzUxQ+/RDvvneb2uYB37t1k/qCz9OPPMObr79Nw+sRZAGGLchEn1P+Nv3RY9zQ6+yj0UKTSUlGRpokQxW1v5W4onuKGllKv7ZNd+0iYwsZSBvNKFE7YP3qDnsbdaolAzUzSXVsnHevrXOr7xHoFGUmFJcF+5FPFKUYeYXsJ0gzQ8TDDqTKxB0YHnfge+qOQSBHgf1hd3PognyXnJzd4R3cw5virlTpHWLy0efRR0/GvyFCcn5+jPxUiXS/Q7TVIA2ahInG7PRRXbDHi9j3zSPdQwv40ALhYJQWKC/6LE98l93bHbrvHTD6kMSpKLJOQtKPMMIUOxGkgwTTKGBP5BEVn25vm00/o+0JTFtiWAJfa2r9mMRPEPFQFmtqymXpRIli2cbv+CRCsb8b4rcyBoMUqVNMQ4KUGAhiL8RwLMycQjkGmWEShBG9bkCnExMGKVoIMq0J/AQtTFzXJA5TwjgjiIY3pmUbpFHC2LhDnMYIYpTW6FhDKjBsSfV4gZmH55k7O45Nk7U390n2e/hxghqpcuZYnjOTXbbWr7Ky3SFtKqbnP0IhXyHLEurthNdf61Ium4zYE6zrHfbjPl4EUSwwhaDsaOzjEBcglpATBoW8S7RwgdHyHC+9tYYjC5ycn+fs+WWe+/mf4/lf+zXi2ylelDBaycjlY4r5IX7fdgTSkARKQk4hhcQAEksRKAMhBYkczoFCMjoxQnNzi54Xo7MMaQwdRoVlE4UD4iDFzhXI5wuUChaOTGn0GiQDTez1II5BCpQhcBwT4dvoJCFMNalMcaSFaVkoBCkKI0vRqcaSCpXPkcu5uHEOx7JptHpUpI0suIhMIWOB1gqJJKh7RK1tZLpN1q7R33+b26kgtsZZ+NgFRj75GOVHTxC6kmA/RnodCoWISBoIy8V18xQCuHSlQ3Xva9y89l1qBxsIEopOkYLqkj9+HsMsE/YkB1sh++stpvIx8xOKzRe2EZ5PQaaIQY/NlTWWOuOUCgrHOUbY36ETh2w0DmhcXGPk0bOMzp3B7ys80yM/WuAHPv8sl5Z8vvGdVxHfepVi5WnuP73AWMUmTlOW8ya+PYK0DJTlULNcZLFEOCiiVI1uu03U26Y4WuHcqTGWSp/mlZcmaG9fQkQRSTpcmEU6JNtmWcp7aULkGSyWIp5aijnWj/nOVsarr3QwRY3l5RKTT9/Pe5OSb7x4m43mBvHUWRwzoSRStBIEyiQehKwO6nhGSskY4OaXmCxMMLo0yeS4SadfJon6ZDpE2C6RJZAFRW4yR9Dfo19vkzRrmDIif+wEYXdAVBtQOj8PKofXTOnve0SiizufR7oOSbNHd2uLbr1DcXqS0qgJqcYwIet2GGw0iaOA5IaLTgTSKlBcXqZ8YhJ3uoxWEssxiPotLNfEKk6zpsu8e22AGcTIikOKSdiMufFuj2tv99D9hNHTDu3JPO9u+ly56bPTiUg1BJmmuKg4c1KgpaYzAMfOmJwOkLSRpk1xZAJT+2RhQhSayDDCMAVxEOJYBkIOTaOiTGOYCoHEMtQwKT+UyiNVyNRAqOHyQHaI5NYZOoqGYkZCoAyJtAQ6y4i73l+wTh7CQ+JkKHmqjyA58i6nOM3gSIlmMGDw1usYjR3yDz2CsF2yRgO9V0d2PVSk0Rcvkrz7BsbYKHGjRv/qZRob62RpilQKjfg+3vJf3DG4e7j3BPQcdgtEhrrHgOuIcHx3u8P3Hn7WIwM1fc9+joa8hyNhGgrXtSlVCpgqZer0NDMnlxmZcEi9Jo2DPZLBAJ8EuzjGuZk8484Brd4eW50+umsxOnYBUypSnVE/8Njc6FAuuuRUid1sj2YcY8WaNBsq9TlmijmtiJUmQ2CqIio3i20tYSmL/VaEVc5TKIxy4n7Bwy2fK6+9gHezT5oIym6MU8iw3RStUwylmaxM4VfnKBVHsG1n6Mh6CEX4oJiiI27C0TwecToOZ/tO4I8Q3DU5u3fOxeFrRzCO7I48451E5TAYOjpHUigcy6Holjg7f5ZPPPgJxowJFJKg7pMmNUTsoVsN5MEeB5FEFEeZ/MR9FB8/jTM3QoIg6SfIOMRxM2KpyJkWyjCRgWZjI6Dcep2VlXfIBk0c08B1JXnLJze/gMQkDgStekTcD5iqpJRcQetaG1emVFRC1hnQ3O3iLI4NRSBGztDvZOx3PPb2Gpyq98hPVihNTJN0MzwRMzkzyuRImdXxgFeurOO8dpPnPnmWSsFhSLvTWEBs5MgQSOHTMy1k7KDCHIbRo9/ziLwDJoo5Kg/MM1NxuHJplNr6Kgy6+DEQxRBEJKGCKORiHBIt5ZguRZTyKdudhBu7EW8F0+SsPqfnZinn4HJZcu36LlsHG3xo4TzlfERgp2CZSMMhavcYhH2q5PlQocJlmZFKTSI0SRrfYzb4/+P4YI+QYaKb9oCITr1N/eYKwe424ycdtFYkg4Tt1Rq93Q6m1LgTRfpugdv1LhuNPoFIyQ4v/OK0zcIUhElG15f0m2U2Vw3ee6dJlsk7ngZ3EmR9lFS/n4R8lAjESYLONFIeyZRmd+VL4c7P358oDCVU73YZPsjUf6DkwBkrkRvJ42/t493aJI76RH5I2muQhRZSVrGLk8iKBVlIFmsyLZB2lcKMzbEnP4p367dorfmMLPeQRUXWj9A+GJmBozVRpJFJBcOZoeB4FKx9sn5IHGeEQpCaEIiMlh+T9hMcpTEtyfi0y+hsEcsx0FmMH6ZggTAlWmVIQ2K7iizMCMKUbiekaioMQ6ANAYkiHGiibkivm5ACQkm0FqSpYDDIKBQUmTg0a8mGa6M0FYatyTtw0EjJYo0lJbYhKVYdnIrFzAMFTnxoHsdKqF29Qf9SC981SV3JzNw4c2MpMtnn4sY+7b7BpFVmbvYhTDtPL07ZawtuX/YYmXDIqRF29D6NFPoBNHuCVBu4EkaWFaogiTBJRQnXPY6uPkm3Z1KyJnGsWQw1zvio4gs/81PUr62zcuU92vUeSTekUsqYXErxGxmOMFGJQZZoMBVWziYNYpQNsWGQJQlJmJKGoFKJ6xrUgSBJEFogGbbxrZyNIVL63RDDKaGlItOaNAiIggEFw2XQrGMph9i0iJAgFZaTI4siMi1BaQxL4OZtlDDpeD0UGSIDw1DYlkU+Z+JKsE3otftYFZOcJdFBTHiQEPshmSdp7O0hvbdw4utIGdGX49yiwukPP8rxH32EykNThDlJpxmTDyMELXQxwzYczCzHwJe0+iFp5wZ7a18l6u+RkxLHKqPzY+ToUR5bxkwdvCbUtpp06hucf+AkwXoT3epiZQ55mUOGAdvbt6nX72dE9nHNKfoqwY932es2uf32Tc5+9CwzJ0+ys7pHvTZgkNicfGiCp59x2GjWWNkKefW1VRzD4L5TCyghmHQVUdHElKATgbAczHCE3paL79pUVJ7d9gFBt81MtcyxhXOoj42yuVFg8+pVBgf7pH4XLw1JdUZBpxwcpPi+iZ6DD80rHp8NiOIat1qCt16to9Jl7lu2ePpUlcjzuPzmLa4P9nDtgLmcYlIaNGRCGkQ0M0EYdykkHgOvhEgyZuYmQO8SxSEqk0jTwSjkMcpFDJGhipp4f5/W2grdm2tYSrMwWiIcZAwGmnKpgOEWkGGItzWgttamcraIQBA227TrB4RewszkGFZOkvZjsnoXuVdD377FoL5DZDio8TmqTy1TPLFIfqaIctWwQ1iw8AZrGI5CmgbtSHNlN2TJBFnOE0cRq5c7XHynT7OWMrlg05lyWPdSNtYHNLoJQsGIA64U5EYkT50W5IoZrR5kkWDM0hj9EK16GOYAgyJJKkljTRJGxFZMkt3V5k80JAgsx0GbCi0BKRFKIQxAWyiZDavcydC8S+t0qPYUhaSxPFxgJMo2yMKQpP/nJAeHi6UOI5JLq0hpISbHkZXS0LRNgJYglGYIxAHCkHRrk97uBs7sJMbkImgTtINMDVSckvZS0msbWM+dhlqNpLYDqSbqtpGOi+k4h10HcbdyPDyav7CSPcTUAgyDjyzTpOkhnv2IeHzIPzgKaI9+Hwa1+n0KIcM93d33vYgny1IUCjmq1RKFEYfjZyeZXlgi7u/Q2dtiUO8RODZZ3mBpYorpXBvf32a726EX2IwbJarl42iR4KdQb0XsbQ+YmBjDFC4HaLoJOIGgF0rAwBRQGXNB2aTkMeUMSi2SZAZBoFHCQKoiShrMzszzkY89S9Dts3r7Op1mTNKLmEBQKuZRlkPgN1EoSoUpbLswhKYdYvsPZ/GDhAjDbeVRFfQeAvMdwsFdv4P3XVuHHYQjKMSd3O3w1SPX6iGEWnNv0KSEwjRMbNNmqjjFyepJgv0AOTBo77fIddewdI9MpASyTM0qMP/h00w9N48xniMRgmiQYiYJEh/tgsIkygySQBP6Eam3z/7qy+iwTd7KYxYqyFyenJFSHBlHpoKwD83dNjoJWVweI6574EXYRomKEaMHPs16m6pXpiQjSuUlBn6bZthhr9ags9NidK7KyPw0je0e7QMfNeEwM1bi4UqJDb/PtZ2Aqcs7nDszTbXiohAUDEFiq6H5XALSsRmEOYKuhchZFITNTrND0OwxXqly5thJyuUxbk471K4pBvv7BL0mWeARpxHlBOqDAB2WsU4KFicNRvMSM4ONruTSu10unJ9jvpwjd2oUy4jYvb7OamebwojGshyCTBGpmMzzaGeSNGqzaOTw3Qp9UvppQJrGmEq97x77/3zou/f+UZX98EL6c7aPybImuxvXqG/cJBdHCHuMLIupb7XY2+wBktxokX7BpRZGtDttegIcS+AogW0IcgXB2RmJYac0Ohoduuwsl8gZkpderhFFGVofQhSzu8+gTGeH8LxDydLDw0oPnZMl6n3wo6Ouw5Gj+BEv5y6fR95zT/4NEpKzMEYIjcxJsrhDNNDQbON069iRgSouIzY1pAbMOmBA2M+jpMCanmDsJ/8R7pe/S6t2i2jFx+mbpO2ULLMwVA6lIwxhQTCLHpwiNnr0zBsUjICqpbnYi3EThTAkWZoicoJBCqNVA3c0R2ooukFKvROxfatHP8pI1FAytVA2KZcNqAcctFKIwE0SnASSBPqDFC0F3U5MrAVaCpSUKMSQROzFdLyELM2wDJBIPA2RkBTzJl6tR/8gJk7AkIpKQVIat5l5aI7SaMS4A639ATsrHYTOIK8wlMmpcYdet8a1gxqtYOgFcOGjj7E8Ok3ByrE/aLHeDOkMJKqRwxCTBOwTxQ6NFlxa1/QiG0coTk8JipaNQR4jW6BSfZpKdIraZsanH3kYw7LRCHLK4JmpBfin/4xf+m9/maz/HqbeQ9k+SWxQ3wsgHHoGhIkk0RJpQJxoRmSKMGHQjcDTyFgihcmg38cXmsxQCAyGy8lwcZEFG1fYOK5D6AeEXR8jDpCGYrTostvo4eRtkDZ+apBFETnLJkk0wlIICU7OoFDOY5gu3Y3toayj4SJQmEIxmrdROiIKMko5KJcNbBuSXp9gf4DXCwlDk51og1xaoyQ1sbHIhvoI226FZ3/xLCPHh9UYr5sidkKmiiF+0icslciMClnH5eAgpdPq88D41/jVr20ypzSGW6YjRxAskXEbqwPFKCNMUvZ3t/E6V3jm7/4o73xljZOLULbGyYt9sjRG9DcRjRYLxYi8kSBlnlDkaQcH3Fzd5VkZ4bgJ8w9ME9/ucXV1l99cvcWXfugh/sMv/hD/81cafOvVb9PudVHuKMcnS2ApKrZEh3kMrSnmBbvthF4yy35D4Uzk6YQGt1dvsfrmBgtLk/z8z56mUzrHH/ze19l55zWWazLXAAAgAElEQVT6OzcZ9A9IQw8JFEQGA8mV2xGdruZTD8CPPZBn83adP6gt8vzzq2xeEXzygRy/8MwMv+kd8N339jlftFkwTESYsBt4aMfidiDoxwkDIva7u2w1bnPBfYbMC9m+ssbEzCJaO1j5ItWlebJuCa9fQ9pdus1bbG3ewszlmPF2iH2HTt+m0OmRN2xiZTDAZqPWYvz2PhJN2uzhaRPh5tFSkqUJ0XZC+PYa5o013L11/N4mkjxGeRpzchxVyiFNCUjSTJJGKc1eSDkRWGadQdqikWYs5RVGMU99pc3z3+lQ29eMTOfgdIHvdDJqew2yQCBzkpKlmS6k3L88vKaXqhm2lXFyROK6EseWDLqSWzcD/KCFVZ7BMksk/tDELEk0luOCmSNOFCka01a41QJJlg2hGsoEJQ/jaQtUhkSRJjFpEkGaDRcdUpIogEgcYsoVQplDrsL/8yoJWUa8e0D023+M8G2sT34Uzp0FBNoSYAN5NfwfBkjTwapMMli5TnLtPaSRQ2OAPYpUPkL6SFFAeBNkbUh0Hl2axk72aK9cRJfGGF8+ibLtYSXmkFwn5J93jHfHkfb9URBwNNLDCt0dvXCOqm+Hn/EwKtX6rlLI+zh7RyXwNB12NQ4rcY5lMjpWYvnCSUZGY8ZzirX9AV5vMMxrXAtLWJwqGOy1tqn5XbzEIi/KnHnwEap2HkOltPw+jX5Ks2vgWEWkKBCRJwoUa1HGzYbkw2kOC4elksIyqwhmMDiJJY+RBSmel7EwO4aSFpnWFE3F6clZCj/xJX7n33ydstzClG0KpQqj5WXKpXlu3P4GcRJjWXmkMvj+iuVfZdz7lizLjkBCoCHNUgTykCtwdB713aThcH7vJGAZCOT7VKYEhzTnw02klCA0aRrTabXYWd/E8mzMOE9r0EQnPSJTEtnTtM1FDhyX8z87Qc5VpAjwUpSXUHQSkjQkybkonSPqKoJeRhQMWCi+y+++t8m52TyekSM0xpC6TJZ1MPpgp9AJMhrb20gds/TAg2xfbDM1rinYU8QiwAhD6LeQ3iTjuYS8kSLMIoPA5KAb0tzrsiBSDCtj8niF3q0BN2+22Nlr8sT90/z0cxf4tVf6fPXFN9FSceG+OaoFC9QwCM1sC1nJcIOEvifxtUHv/6btzWMsy+77vs85525vf6/eq33rfbp7eqanh7NwEXdRtkQxMoXYEhkniiI5gO1ESBDADoLACGIhRiJIzmoLSuQltChYtijR1EZR3PchZ+ue7pleq6u7a3/7cvdzTv54XdUzlBRTsnWAKtS99R7q1bn33PP7/b7LL1R4Mx5bIbx25QEFqTn7WIF3vWOZZ59d49OfW2L46ksMtm6R9HbQ0QApLE0h0QcFroRj4pOW82ck73m8TO/BAb+3c4KvfvU2F495nDtR4PilRV6UA7754j1+YKlJ1bok4z5h4pBWK+yOFGkakpGxVmoxQLOVdInjcIpOK/lnSj7/zONobU+RTZvm00NXIRz1aE2LR4+Kw3tYqjLGbrK3d5veoMP6bA3hFpl021y/2kObEpX5CpOq4fokZTjpoBOFqgSUxISFimWu7uA4mkYhxXVyZpcCPLfAhRMljq3UeOG7ByglHhpOPBLma22OtDdamyNBspTy0Wy9aU0cJgOHgv5pd/LpGtMPG6gZa95S3Ph+xveVHKS7bbJTMe7KCo1n30Hym59gUWeUcotK+nDrGlHnazinn8X52RWcBcGdLypMaGidEdQvzZB/5BNs/sp7OXE3puKXkdoBXUTJOTIO0GoJVX0nJigSm/uEhacpOZ9lK05xlWVrJ2YkBAcxICXrqx4X31FG+hn37hywu5dwr5OS7Cc83hD0CoostwgtcR2XciOgcz+joSR7w5wot0hHEKY5NtY82EuoNgLqgUNQ8JBSksiYbt/gJIagJKnWAxwlmYwzoijDWniwFZJmkkqzSLlZQGDRZcu7f+gJQpvzYOcu2+1dUgG2CZ3+mLnnLzHs3WKQh3SkC6nLPEWePf6TzBRauK5D0n+dwa2vo0fQKpWY6ACrmhgTMNnW7HxVcKdX4sxMhac9zchp0fKWmbXrjIcewVydWvMUxvXIjMZqQ5ZrlHJ5crbMf/6f/QRxdpa49yr7m2/w+o0dSmWXe3dzZpYElXoZk1miUYoXBCTCY3y/R9wLcYVLwQ0oyJzdjsNEC1y/hOt5SAzS5hRkzuLyAoMDSCcJg96I8WCA1CHHF6YcatIQ65RBahCCMMowOsFRitxqfMfDdV10ptkddhgMezSrs8w2mtQqdQp+iYIFvxyQCUu9Vicxgs5wSCk0mIqHr2ZoiiLLtgbjs4Rhwj1d4HXmefY/nWVh1acQgE00xVEC+yPCwgTnsTIFu8bGpiUcpJxoJgTBG/yfv/S7mMRQLfoo9zgjeY797qucP7nC2lILLRWjJCdOxhC26W9qPv63n+Lvf/y/op6uMOPPsJ/dpzTYpPNaj/jGZ5mvKLoDjyS1JJlh2HOwXgU9FMwu1rj4g0s8ebLAL3ziFr/8pXv83ffO864fGPD6ynPsbIz57U+/wH/5tz7EtY7liXlJcb7ATMmBroejJvTrJZY2ITSK5mzIwdoSt16/w3e//o/4B//4r/KOM2v8zY9+gJ1L87zy6hWu3txg84WvI2yGtJZKniMtDDrwO69YOsct6yeX+S/q8OJeynfDVT5x/RzvmXyeH710ioVim3g75FYnZBSlPOYFzKgiUTJiRrgk1jLMhvTTDfziAKvneL0fUmqlhA92ESohWG0g5wKymRqd+z0mTkZe0LhOhJNt4uWK+7c63N67wZM/+kFmTz5BsOZSjgVR+z5yrcHyDz7BcmjRu32kSdFxRnS9TXJrD7GzTX2SUhBrjIMm9aeeJcNh61af+rxPZcZnMNLcfvEBz/zwKoIt8sk1sskdtAV/URKPh3zy/+1wtQ315TJiOeDabsyrX+nRWFYsrXuUjKEucuZcg2dz6nVYqECSWapFQakm0NIQJ5Z2L2NhTmGVg3ADhAhQWQHhB0g/QHoBpNOuyOh8mgBYjfAk0pVYY9BpPg1qhYvJExAGE8foVAOCbDwhC1NMqnCdAiKwyJKHv/gnuBUdBm5pSvqbf4QzzhDDHuYPbmGvl5EXF+BsEVkTHLyq8ctQXJSo1iL+e3+cBy/9PWZfvIrs7qFvt7Fti3BOYWQbE6yjGufIdkKiAWT5LNLc5/q/+VUmeca7fu5/pjS79FD4a7BG4xdK02DikGryJ+x0jyqCkB9usha+t9lSnlsQb+q0yyPdwWHAIpV4VIU7CiSmv3McB2Ms/d6Q3Qc7/JWPfRjtWHYObjGIRuQu5I7mYNxl9ex76R+8yJ6jGYsifu6z6NY5MfN2fMfF4pIMrhG3txEjh5lGhcQ4QJlEw97rQzZlwODpOg0/4YSTkqlT1NU6vlnDmgqUivjNBlJ4DwMBOUVxhWG+5PHxj7yfmZoDJuHevdfo9dsEfoHl2XdxYv0iSh52yP7++Mh/0hBwRPux1h514D50RplOoXiUpB0hBBxVPh+maFhhp92TmfK+j6hOD2lJxhpyk6G1S2/Y5/PXPs9Wd4f/5kN/h2pQxi41KUVzJIlgYFx2i1VO/FCRUklNPeRTgxNmMEnInAy16OOaBjs7GZ4wLFQi0vwBX/2tzxJ4EWUcKJ1jNHFJx21OnFmg1SyQWYgzA+kYOxpDLLn0vjk+9bf+KUvzZxkFW6hsiNdpM3kwJtu+xvpaib1+TGegGYeGaKhAephY0Jgr8IG3V/naKzHfuX3A524M+OiZEu+7FHNr7ilu747xnDbPXlpiEsNcSeBXXKwrsDLFUYZCUVHvWnIheG+5QG92njcuX+fKC1fZHryLp481+NkPv437Zyrcvn+GO69dZfeFbyBNiNCa5miE0bCzIQgjzZnjGZWlVf561XB5J+XW8Dj7dyUXZu/w7NnHaBUOSLcnXG8PKWmYLzdQ0mImHWbcCklqqGcxi55hrtkAY+j3BxQc9y/GrehNRQE7dWBAt4dEr9xHBB7Bs8enyYGFaaOTP/5Wi8BkW5QqZbJWC1ntkUVDXvzKbXZ1nfnVWQ68CZt729y+s0Oj5bG0UKagM2pOSs3LCRxBsWipBpDlmlKgkA6k0uD6FteVOK4iiR+hldaKqYvT4fqwh03RDlHRR+vgzc3R5FFRxB7lPIcucIdmDFpr5MOE7PvBDr4/WtGJFbzFOfZevcU3fuv3qeyN+NCJD+DlB9j0HjaNYfBF0iv3Gf+v72Pmlx7nzHsld74dc/dazsULVZ76DxfJPjnHINyj8kBTD5o0qmuY7oBcLhGbbZzZgGT5Kfb6NS63/4hb/Yizc4LjNcEesJcbRkDRsTx70aW85BL1DGE3xhmlnC4JwkWfgzClNSdZqnnEGez2Yrb2DTOBJOrHTCx0pUUqi3Usk8QQ+OBYjUWhdYpQknLNZSbKKRUVUWaZDA1CGEajjN29kO4kQ7mCRkHhmhxpM+qrdSgo9HCbu+0JtzZ32NkYMG7nyKbCFsqUoyHjKKZ/PybpCJqlMj/+wx9nbn2d1HFwiBjH99gevk6SWKqB4G53SFoqIMslRN0lnGi++52Q8z9ykacrHp9PLtDJV2i6LebnlghNhYLnY/TUmSKMNUkqWJypkIxDdnc2GKcdkoFhElYp1Q2FuE86mVCTlqoSqFJAVqmQjDTDfko60VhjyEXOOIwYxVBZclg5VufOq1tkiYPvOLhotrr7DHcGeOUyOnGwqcE3KbnJplaU7RxhIcwiqjMNZusV+n3N3a09FDV0LtEmIo4Stre6jCYJvkpx/DlUyaM0W6VVq1M1gt3tERGCeBjh2RFuBk7q4gqfqoC7/ZiWP21QtStcrltL6Umf5z/osd6Q5Jkh3UmpbE5orAheixxOFR7jbjehXs5pBQYv7nLzxm/w7XbGe4se48qTuLWnKGdFNk2XCe8ma2QYUjgYIva3cBkzVylQ7AV8MHiaL3e+QeausVx7nqrYZ3Jzg1EvoFV1KBdz+mNFZjSX23e4uxFxbL3FzV1D10tYOLPAL/zNH+P/+fQ1fvE7V/mJJ0rMr53ilTjj6msv8Y9/VfC3P/IBkhlF2ZNUy4p+7LO7m/PkzAD9AzP8g085/PXHF2jW77Dd73HuzBybN36Pr26u8PJr7+Tpd65y/u3nuPBcl0+X29z50hu4ecYYzTFjqMY5t7TDluNSbt9juC55qtXk/Pgu326/yJcerJBkz/BM6zKf628zh+LZmo/qTLgTwrtLc1wezXM7G1AgppnNYw6avPjSbXYnAypnV5i5+Bhus4oRKZN2h6QK82sB+qkmWdYh2enT7tzl1tUOv3tnRKUYsBgvM1NbYlTI+dYr/4ZT7/ppFp85TaNSQCWaxFFMrj5AWYfa2+oUNnL0PYc4rGFn51n/Gx+i9M55Hnz+Ft/+xmc5+dxpLn3webyi5u5LX+LkmXO4J19h55tfI375DmdmJYvvCfjilX02OtB6rkWhUWRnI+Sb3+iw8lerPPUgw3M0ay1YawoWZ6DaEAQlKJbBdyWuC1YaxpGh07OsLDcpzy4gnMMKuEuchxRIGeaGguthxLT7uKd8lHJJw5hirQJYTJ5gkpQsF/jlqbWrTjS5zTE2RyoXVfGxUYJTKwAeySRCDFKIJn/qRmuFwm+cRVSq2N59GPaxt18j73YwO8cJPjbL7FlJZzMj7BtKvsLzHZqz64w3ruOkAsfOQkHAYIRxl9F6A7FSJA1qdHe7bGxv0elus7IsmS+nvPDJ/5GTH/wpeqMud699g7/ysz/PIXv9/z+AnXJstbaPXv7w7B9zQnrzoZwmBYJpQ8ZD3ayAo4ZpubVIphux0Zo8F6SZYTKMuf3aFexMkZ3RDu32iDg32HKA8UqUkwGhiRluxOSRx1JzkWfOfohyvUYKeKSMkjsM032M9SgFgl6cgAjw52fgXpHhwLCzp2kee5YVz+eaOUtqqwSqjOMUMcLHEZLcZkgUSZpirMV1JCXPx2sqXNdBAOfPvo9Df/XV5TMopd4yn3/egE3n+s3FWjDmYUsL9ZYK8dTx6aFY2U5RhkO6BEfvt1P6Lg+pFXqqG5FSoqSDkgptDGmecng/3Ni/yS/+4S9wvH6O9dYiURzjynn6NueWc42/e/K/pqIgzSyinRKkGboMPS2pO7O0Rxn1isWxFj3eZ/v+C3z5yogfWS7SnvkBiuVjqPQB4WRCKGYxJQ1WQ3cM4z4uOWXPxUtcLrXO8dIbr1BeuUS55uEbTbzdJx56zLcUxUJK6LlMkpSbewecH+TMtkpsdw2Rl3PpiWVOzNX5zo0uv3F7jw8f92gszfLtbpur9wYYo3nHuRVMUeJK8ANJN1Yk1tAsJuh6iV9/0eFjZyqk9j6za01kFrJz5Zt84+YCr926wLPPrXPhqVMsrS7xSitj8w9fwB8PGauQ02lC2PUZZVXawsPbu83musOlhRZrvVe4cV/z4oMlonPHODaj+Hp7m9PLDrVxSNaJ6KWWY801dpLjtOMdmtZwbs4jqU74zO7nAEhM/hax7F/MsOSbB2S/fZ18bHGeWkI6zlEWoHONctSRJuYQ7cqSl+jdeoNSXsFdDHBqCXf3B3SiAnNPH0NJydVv3+LeYIdjzy9yshPhqZS5uqBVhXJJ4PkSxxU4nqUofRzHok3G5VeH/KNfvk+vn5GmU1TTcRUWyLKcXOe4rkeWZd+DHDxySrNMHaCkmK6JQ+RX2GmF41CzYw61VQ+RTsEUVXD+VKT40fj+kIPehKw3wiQxkyTiC8Me7/NmCZaeAm5jB32sM4O0D3C7X4WtFfLZKvOPu5QWLLe+0OHUeyus/Oj/QOnl/41yVSDzOvq+AS9Htj6AjkNEoUc7/zZbw9tk4zfwBNyfwId/KuDalxKuvJZjBCzNuMwt+jQrPv0oZOwYHEdQrjusLBTo7Ib0tKWzOWESGoYhdENLw1MstnwyIbDKkmSa3jgjdyWzMy4yl0SJJjMG3woik5NkGk8p8kQjwpQ013SjHK0EQlscR2I8SRZIkAYZpxSqda5ut6nMlol2EsY7MRQkky7UnwxY7W+z9SBFx4KZapVz84+xeumvUSl4VHyPLJ+wtQt3bgS0qkUCT7Lfvkdk5vELNUozJbJ7Y1789Jif/kCALH+E9xWOYWwZYX1cp8KMCKbVGzFNgiqBoOJL8jxkb/8egTck1h4T4xEnliRVRMMA5QpGaQE9VBSNg3Q9JoM+OnPQiUFkgkIgKZR9xGwBr1JCqQZK7RNGE3LroHyPtOzTGU5YmlnECgUiRpoUmUh6D3rMV6tUZur0Qs3BcECmLY4VxE4Bmyc0KjPUa3UCz8MmKYNel9nGPGtrx9GUSEPDQdjnQWQJE4GbGzAJNocCgobKKBQMTrOIR0KSCyZFn1EpwE0N+YxkqSqxBtzYIPKU3I9RVcWZlRUmPWjIlGZRk5uc7XHO7//BfWadgJnyBZzl99BNoLv1MtUsZHF2lnpBUVCGne4m4/1NxFjj3c7wnnAwSZmm8cmjO7g2ZsF5kt3LrzOQa4zlJm68Q1mOkO4SM42TZFe+QOXYEicCnzRxSMYlevUi7/phyxc+c4VXrgbkzR7MzXP8B97Hy998mX/+2c/zNxrvw5EBXkGyOOOCLfCFq2MulGP+zg+3+IM/eBHlu/ylD3+M7Ec+yi//L/8TO6+/xnh7m69++Wmu31zl1LriP/nIf8v1lU/wud/6KsPBhBu5YUEa3q0sr3XGPHWmxYONPSLfsFQr8q6lIk8N9vjCzZe5WujyzkaNSSLotDWkLdZcQ2WywyU7oSkb7NlF3jhYYv63Ii7+d+/n3E+eo2xSjCvIzARjhviFIY7IcMixjsvCpQt4l1w6V1+h2cx48jGX1YUia2sC19+F/C5xuI8zO0uhEJDiMN4PiR5MKJYUsmiRhRqy+QwZ+5joDgiH4EwNp+bRW6gyqc3SdQIG5DRKgvNPtLj1ld9kFG2xe3uP3IUTT/uUj5XY/qMJ8WyZdD9m7+YYk2W862mXlU7G6bpBHHeYr2UszBjqjSnlp1KRyDRFJAY8gwHSkSJuW5aOzaMjcGZaoGbJhA8lRRT3KFfmUCbD9RTWCLAaqXK8soN0cnRqkK7A8UpY64LNAAmug/BcjhyLjMDqBJ0WkUxQfoB0p0nE0TAP6R7WYrRGG43zoxcwyRyMq5C54EhEPEBs34ZxA+tIqouSZJwz2c0ptTya/8FPwOf+CU5rFvZ9LCHUFLL1JDY/h8n2GZgu4/5l8u5l7LjHbrvApY8u8eVfv8uX/4+/jx84HDt5AqMjlOM9wv0Pq35vSRLskSPRoTRBiOm/I743GfgeytCbQwNjmNqgCjF1WLHiSCT4x1t1gRaCyM1Zmilx5XKXhIRMTbVsc6sFlsc32diJUHjM1Rc5sXCO+uLj+I7CVw5ZHrO57RBOKizNSFxHMJr0yf0irfosg9oM0Tjj7stjnlgNEN5znKUB1kEKDyldJOrhNTNoq/Fcd2oHaqfakkD5R3MEYO3UEvNQm/HnRQuOZt5atDFvsVY8ciuy9mi+jdEPxcSHlVA1TSKOKqTiIYIz5UlLJY+ci6Z0LzFtmvbwb+RaI0ix1pDphFE0YHuww53ePOM8JUxSMgGtE0vUSw7agEhyTB6BtLhFlxmvSJoISkoglSHXhvsHIde+fsBqtUa59QzF1Sfo3O+S7T+gJiOaM2UKrsARhrC3T94ZERgPuW9QLYkdF2gZl+GDGxTzFYruLMPLB4SqSejsUddb6KJLo7lAvVZH724QNGvMuwqTOESeDzMOZ85Jslf3uH7PJa2OmTu5wkFnxEtbHSDjvc8cRxYkSgnmKg5tYbndzZhTMR+7VOHrX7vJ8toMTz23QPvEAcMvfpXt164w2Nhlkl1iabHI8aUSH3z3X2NveYWv/9qnGe93eSVKOFXIOeUa9rclxy6us3dri3s1l0bd51Ip4dR4l5t3UraLY55tzTJ8sE84LGLzCjUnpt7ZopS/RsVbZWSbBOkSPzjf5G1/79383//8l9na2Z7eI4fwnvi3B6zfe88d3jNH58ybkg0BJtbYexIOeshJCoMSeZwjAoVSktEwRLgSz1O4joOwlu7dK4jyXcKojBV93HKEDAqMNjRycZZJd8KkPWS+rFlpFWlFIQu1HOZK1Pw+1YrC9abmLa4jIR8A6ZTeoxXtvTFXX+sSxwYhFI4zXYfqMGexlixLH9KL3oSCWANCHa0nx3GmSbY4dAqbljeOehsIgTh09nqIuB05kX0f4/u6GmmckyY5mQqIZ85jKDM++Ca21UMsLiGa56G6gvFn0NEdep+6Snqvi3JzZFmTpBlhJ8YGX2PbRoyzaUXBBIrEDYmXZ9kqGczjZZLqTdqdL9LJI/aM4S+/2+XWhuHunqEfG3JrWW1J5s9UcdFUSgF+PUDMuLgNFyOgulKlvlJB+w4Z4DgWaTQTLFqBxhJnlnFiCRNLGhsGQ0NnkDCcZPQGKQedlF6YE2rNaBwzClN6YcoozsgzTRxqXN+lUXWptwoEZR/XdSlWPGZbPoaEN65u0d4bkaUabS2qYKmmmvZ2Sr9vSccOxeIplp/+GHm9TMN1KQiHOJd0dmK6NwYEQvLYhVW+9vuvcmdb4zZWaC6ukeWKly+P6G51IetRRFCURXxVIlAFfOXjKgdHSozOyLKILI+J4wk66iAl+I6kEBSp1Jo06zNY4TE7v4Zwqii/BrJEGj8UZ+cGo3OU52FR5A8tX9NJyt5uF6tKqEIZrRwybSkGRYKSC2mGjiOSJGKcJHSilIPukF4CpUaTQuAhgCjNOOj3kSQIZyq+TPXUjtFzPWZqJaqVBoEjUUnIuN9j56DL/ijCLxbJcs1kOEYBxVIBr1rCOBK3aKidrDEKBKIsqTY9nILLM0sulUCgUovuG6TjUVxr4NYrRKnEaEmj5lOpQRRtcv3KHzIcRpxwS/jHzjC71KTi9THxHXxXEddXKBVLDHtjwhgKskgzFtx88bs4qWHGe5JAPUeBVUQqeTBMOTkRnPK2KXlVZpTPvCOo+XCgJoyzIaqoyCou2cRB7EmKKJaWmixevMBm36GWjFmUGW5Qo7Z4hqsb9/itz23Q6ycoC54DlTKcaCqGnSH1CizPl5lVVfxOESFmeM/Hf4oLb3+KC2dWaQQRUfcee/d26XVDSvWnef+P/xDrxxZwfYcOgsupxosSdndGLPkxQaHPTtzjjb2Ekmf4YGkfT8zTGVbQWlEPcuoyYiWQtI1DCYezRJylQym5zb17f4gyBfzFZb5xZYNrmxuE2TaOvIXr9ZDxDYR+g9acpLk6D/Vldu0qleee5eL7l1j5wRaXD67yL//Vp/jSZ/6IetChuVTCiodOENoCOTKIMGUP0SggWi2MWyLPhiSdK+z+7guECNRKhfrJY1TnWzi+JNUxbmWLhbUh7mgCqaG2XKT1eIPN2z7ffiDxKy7JKEPrjGLJslSGVZuzsgpPzmacaBgaFYEKJLmSjIUi14AUU+jaQpxYrt9IeTAIsdU1nOIyyq0hHR/pBWg7Ih7tkgx3MfEASTZ1KpIKv9RAuh7SUQjHQbgOyhUIqzFZis5TMp2T6Zw0z8h0jpYSZI7OUtIwIhyMGXZHb9lUAfJUM9wfcf/KBtRcxIpArCwg5uehVsd6PmawS/zVPWyqkZ7FKkueG/I4Rae3iFeOYRwP6ylMYMlLCdlKlWFDIdaKJOmLjAav0h136JmUi++scH8zZHt/xIPtXZJ4RLNuyKLvAlN6kbXmT6042iP3j+9NHDgSNx+ZFR2Wud/EN5aCI/6vefg1dQWZUpAO3UGw0825Vi+xtDJDOBlx/e4dBpMJcaYxwuC5hqrO6bQjemNBHgVU6uepLV/CBi6BmjroJRr27/QJdyIalTqrp85w+eW7dCLFwtxp5mfWmEwcXry8RzzqIUyEKySu9FDSRQn1FsGhUg5STs8p+cgn/ZFQ+JAqJd90/PRo6HAAACAASURBVOj3f17kYJoMiCOKEEJgj4TE4ug1R5fh4fybw6Tu8CJ8z2d4JLB8JB7X+rBr8hRZ0EaT5RnjdEw/67Ez3GeQdDHKsDC/wNufuITvCEySk4xShK+QZRej1BRJQFAsKoKSZDzaor11m3yccqw6g3P6ODOtAjLbQuQHuIFLVqkReC7hKCG3ipoqUuhkdF9+gMwFpeIqjneOgqmRDGCyp5kfWRaCHr5XYcGVrJYUhaKlrWIyEyM9Se4rzFgiQ0GgFI1Gidb6Ane6MGsTKkpQKlUolKvc3u7x0uv9h/fm1La44FoqjiaaJJQDS7PhU8w9nCyg2pjn0nveyfnnz3Lh1AJFMSLsdui3xySJojRzjud/8seYOzaPKAXsZJZ7/RCn3WVwt818NYbggP3ekF4/oxpoHi/3UXKW0aCI4wqKQUrVS5kpeUzygKL0WRN95uwexeE9iv0OF05d4Kd/+mdYX1zDczx0OiQdbZEN72Ly6GGiaN/0xVuOrZ3apkfjEZN+b2rveUixOQQVD2sIUoDyMInETPZI799m/No2mbFM0pxUH7IFJXk6pr97BWHvYAb3SEf3cCsRqlhmMJrljf0Mx4dhZ4fM7FMqxMz6hqaIqTcFS+Uh9aKZFnCkg8Yhsc5DFNLFWkGSGiahJgxztJ4G+1IqXM+lUChQLBaQSr4JLRAoJVFKTte0etS3hUOK3sN27uahtsBYc+RkdEQ7eoi6AUdr6N82vi/k4I2rr7EWNHCpEak6EfD5vdf4yJMXaRw7Ba0ydqyxB1XMSJPd3iLfqEJlHlMuMLPqcXB7RJQekFQK6Eodoz10YYT2i4xWStjaDJPCkE5/g710k47WzHvQXHL44osJB11Nri1KClbnoTLrER/kjPcyjIJSw6FYUghtGaaQStAPA1ilBI4E6UussMSpIUwNcW4RCooK0jAneZi0YKeCMzJL2QNyw2SSk+Xm4X0nMBpUYZp9FgMH4wq0wzQ7zFLSJOPBRo9hL8Zog6MNroaVgmCzLxgNJa2FE5w48TzHlh+j6AuqnoMrFFsHQ7Ye9DC9mGrVYen8WX7vtzdYPntA4Fcpzy6hgjt0opRP/s42P/1Tr1FrriOcJo50pi3pEQibkecxUTIhThKslTgWTB7iKUNMhus6FEplHKFxinW8UgM77KO1JE0seZwSKJfIZBRLAZ4X4Co5bXZmp2jCaNjDkSUc10Pn053XUz7SZNMmR/lD+FVJhKPQWpNaibQPOahAqnPG0QTpKYSYNrMzeUqWgJIuBc8DBP3uAHJFnBgm+bSzk80ztMnJjcZXglLRxws8oiQlTAyqLLF1F7fk4AQurbrPmbMevpx+VoOZwm6+B4FAjTVBRaLGOVJY9HhI59p1hHBYrVdpPfMMaVRgHI5Js4RS5STV5QUCzyVujzHRiLLJ8a1PurPD6Otj1s8e441Yc9CeEOdXiKLLNGUDK8uUVBMhXCSWUuBRXj/Gd1+9T+P0OaqtAp1YMuonBL6gsFzk6Utr3N/N0fmYuN/DCVLOnZ/n21/Z4BtXX+apxxtUSg6VmqQcKNbmC7xy+WWiYYn1Y3X2N7bZvfEGftly8Z0forxzl9H9bXqJYJxoRDTk/q1XqM4tsX7yDOlgjO+8zva9HbbijCWj2eqFSN+wXJY4AvaHAbcdj5MBrEoYRCO0zQlcj6pvmfQ1Re95RvkbzDBglpjMTBiNUra+cou1j59k7JZwGJHZMTltHLuHNWOEYynNzjGIDfuDiJvaZ9HNcGqS2ulFdl4f097Y4eD1Lo+tt/BrLlpYRG6QnsCtCHQaol1wPIk5XSCrj4ntHqHxMZklFGADSW2+gR8I0miEpIO2OzRXqkyGEcFCCr5k5Ba4/GqHTGr8CNxEs9wwrC7CQlOy6BhWTrnUC9O+H5mriIRiIixBmCO0gGBqqxrHglEMOrVIm+OXlnG8BjrJsHpMFFvScZcwbDO3tI5yarieh+OVcbzSww7KGbgSjAabTzdXm2KyfNpIylHYZNqgLBsn6DhBlQPSNMGkGSY15G963v/aJ/4F8/PzzJaXKJkydy6/wt6165yvLhOs1pCxh5mAGbiYcU6+2SE5rhCtIlZKhDKM9mLS9j6ZtRS8AMeNMaUMXQ1IWg6mWiC0XYbpDTrhAybZiEZVUpyXvPLdAyaDMUmc4TgB1Uqf8fAy3/ruPu39EVGiH9ruTj+v1g8DeW04e+4cx46feMv+Zf+EPAEO0YO3CvsQU9Tg4SuOguajgPWwKifB811qjRILa3VURfOdzVdJU0vgKTwEgYB5T/FgqBiPPY6vn2dl/izN2iyeEvhqKrjtjGKiXgzDCK9Rpjg7z40v3OHU8WMEXoNiqU7P2ebeIOKPXrjDj7x/BcdvgfCn/GI71U8YnfPJX/+X5Ll5mADZh8mSORJZP5yRt/D9jZ4+/w4n61B7cYg6PJJrT78dBi5vFnFmWc7P/dzPPZrbI17zIe/5UR3SHr2GI9ElvKna+ZZr9CgIOjx+sxOSo5wj5OfwfKlQxhcFhAOuU2SmPseJk+s4ampRazwHJZna+EqJkwLkmDQDNyfe7RA+aCOEw/xcjdL5k8QjSzgcYHIHv7xCoVFBqSlSJtKIqlI4qSK/OyK9ljHzVBNncAp70Cce7yJtn7JfR6gCgaqhDfjC4FQDvFqVmzcGXJxfpFh1GexbbJTjKIFXcjm2XmfjICdPM9LxmLLn482XuH6rz0s3b/HYsadoNVyUAwVfUi8q9vf3yJMyKys1JvsHxHsT/HKBk+vHKCUT0oM+vVyRRhkqGdDfn1CsN1g+fY74HW38Vy/Tvb/LwShCJQmdnTaqamnWPYYRjKMCwnGY8SUzUjGJhgjlUCgUcBJLNnAJ6m8jjm9RVWPqNmUiUgh9iuNLvOc970HnmuvXrzLu36YcxMRhj1CXWFqZ5/72hP2DIaNxAhaqJQfPh0ksSKIEN89pFBwWF2YonbjEwX6bjdt38BwHpQSNep2nLj2N7wTomiXXu6TRDnnkIpIMnaVEcUY8jMi7I8plh0CGhL07lEsxOjXYYor1AzqDjHv3BqR6SDbQ2LDNbCuhURVUA0XV1VRaJQruAKRLLguk0iW3FkenGNHEuC7G+FjZ4tSZCj/zM38JbUApbxr0y0O3IUuaTlGDt2hy3nLvH7oaibfqKzjULTyyNp0+G6ZUoun56WJ5443r/Ovf/Nd/7Jn45vF9JQff+c63qMSKs8ffRm3GQVUL/EbnAae797j4xDLFEw3EPmA8rF3AOhPG9+9gZwWF88eZOV7g2u93COMKhZkGcq5FHiYkgx2y8izZsSKunmd/9BIPBvfZIyfE8u6GYCOE2/s5YaQRFpSw1AKDYzWy6LN7MARjqFYVrrTI3NLvJPSyDD3KkLkhdyTCe2hpiiXONZPYoI3FDwTlQDHopyRIcv0w+9TTh2Cj6ICBOMwJI4OUgoIvcV0HAolxpsIvJQUGw3gYY11Ld5IwaqckY42SBqUNpUzSKimuhgqdFTh24m1cevLtLLuWWQyBF2CE5fYbd9nZ2KWkPOarAU5znvHoNfyd28iWi19rUJqvMO4M+aefafPs2y7zxMUzVOpNlFvAGAeLIc+HhMmIMI4I44Q81/hCYmxGybOEUY7rCoQNEDal0vRAuSgVo3WOyTNMZgiki7ApMzN1rFC4jkIYQTwxoA35JMIJPJQAz5nyV4WVYD0sFkdMhTAIDyGhYAFHEccxSW4wNkcpg1TgKZfMWKS0kCfkJiN1fArSJUljojQjkEWyfHp9HN+QJxOktASBQjkPN3ghGeUGM84pOQn+vI9f9VFln/VSQOu0QhqDdMEGFh0ZrBEo16XmgVcVDNsJNktJD2L6myOUP0NzZZ3ZJy9x/cvX6baH5NanVr3I2TMtpIJBd4CIetREjlZlKplh+/c6rH90jdX2aQbR66SjIYm+yVifw229m4poEnUEI52w5Ls8eeEiL3zyFZ57us2FdywQtxS7g4h8O8NpVnjyZMD1i8ts3d4lH7SpEHHsdIMbx9bZev0bvHBtn2q5wPlTJYpVh1K9QJq3mbQHNFdm2T5os3nwJZ6YNLA7z1Lz5yi2Ulq+IYljxlsTot4GXt3FTgqsnzlHAU1Bx1zbbNPVBpGkDPYM9ZJgseaiiz63exlBtciJSg9Pt+kbg7UeEsUk1CyqC2yyS5kJJRHSQnM/aXP9M5/n1E+ss3r6DFbfJeUekdB4ehPhG4RfRQUJcXbA3ihmY9hl7toBqpGyVn2M08fHDF9P6KfbzMgJws0w2gXN9P0NQT6Y8nGlNYSlHgPvAT3VI6yfZuEdZ8ARDJKEUs3DcXKi8Qil9nBdjdeYY5LnBMd9hhPN/RsRDzZGnF3JyMOcVs3w+DqcOS5ozCtqgUN5NkBaQZ5DhiTVAiMsapKiiwH7RpJPNGHP0G5byj40Sx6+W8PgkeqIcTRk72DAaPMerVKZoHKeQrWG49Zx3DJKBQ83AInjCEweY7IMk6cINFOM1KI8D52k5ElCOAoRUYobZCRxQh7mCKtQwaMmaL/yv/9frC2t844n38Ox2VN84XOf49ZnA+o/+VEWzp/HVw6iD9oqcl0my0dEd1MctYTfKINjGBxMiDspzqRDtrSC9fuYYk5enSFtOVhToNe9Sidp08nHWJlwfC5gbxJz734bk4QIY5F2gs322du5xW/+q09x7coWnX5EGGXk2iIspLklyzVZlvMvfu03+NGP/Nj3s639Ow3LIe0qJ8lDuuM2L9x8A5tJHKMoWkXFKhq+x7UoQJg6Z04+x/GFNRqOoCTAUdPAu73XRWaCslS4NiM2lk7ngDMHDzDC4pQLBM0S41HG73xjk0tnr9KcXZ32lJFFkjjnwf0t4njCL/3iP2QymUyriMZgtEHr/Kgb6qNP/wg9ybIcpR7SpuwjSpkF3tqBdRqk6/xRIyaYBinPP/88X/ziF/7C5/3POt6MEOnYgK9wENjcIpQAV6KkJU5T0n6CECnDe31G2xEiqFNeW6R8bJm9z99k0o8Qok515gTzc9O1N+mHuHlIyVU4ysPtG8Zfj6h/pEZjY54kdEkHe5g4JdFnUPUFiqJIN01xTcpaJWBubo4bX9vh3Pkxc8crDEaaZJhhhoJCUGSl6XJ8vcZee4DIQhqepVYvca9VZePGVW7tnMFzy9SqCt9zKZR8ICYLU2Zmy+zvX0WMD2jZGUx5nrLXwDZy6gVFPAxJ+iHZpEtecSDxWX3qOQJSNqxhb3OPXpbCcEi4IWjOeNSCAn1jaPc0br1MszzCoUNoFIICWNChQ7VwngN5QNWLKYsUxIQ46RBf3+bUe57j4//xf8TP//x/z81Syon1gDS6z0FvyGR8jJcud7h2bYe7m12iScKxxSJ+zSVMa6RJjD8esVbxePzJ05T6mpvXb/O53/8DlpeXqdcqHF9fY3l1jVq5jjEjTL5BzAQqPsFCmTTPaY9CzGjCaNQmDi31YowwEdYJMKqMbEGnb7h3b4/tzU1WZyP0aECzlHGypWm0ChSKPp4jcIt1hJUYI8hFEYSDQKP0GOHNEcsAmTcwcoULFy/wzh94GiFA22yacFsz1TsJ5wjV+540evrTvycB96c+9al/P8lBd9jl9uZtZpuzfODDz2LDZ/lnX9vkt7/9JdyFWS6uL4LnorouijOMnC56/w0KQx9PHadnFYVmwObLI1omI6vmRMWc7q6lK0qcfHyGq5c3SbjHlu7TywUFH+aPSV5oZ+xnllxOYTObWzr3NfH+hNyBMMspOhaMpTuChrYUjMONrZASBtcXJMIiKwqtJOMoR2qLzQ1pbpFCYQsK11UUPUWSW5J8elHqRcUkseg0IYk0OgOURXvgVSWFhkez5GMDRYIhzqZuM2Eecn9vzOQgJZ9MLUDJBNVZn+3dlGji0Jxd5ckzZzm/vEzWjqhPUuRskSzT7H/9CvHrWyw25jh1vMLe/Qe4viK+fxMpahQrisa5VZJvXcdz4Vf+2RY/+zNf4/GLCr+g8VQDKSSTuMc4jki1Q2pyonBEP01xfEVVKMK0iFAOeRDgFgssexnjyCPTCpWG6DQkFJZRHOMoh0ahxijLGYcJSZxCZnC0h05zxukA3y9SLhWQSCZRwky1QdnTxNaQZTnSGhzpUigVyIRFOQKDJk5jXOXQqFdRXpFxlBAnA1AK4Xg4NkcLF2tyqo1jpCNNHE/ILZSLVSoln9xRFCoucQR7wxgvyoiiMYnTwHegsFAgWChQrnsEJZeCyqZ2eUIirEEGAtFwEYHCTyxkGa7r0rvZZ+PVB1wdTSjOPIlz+scQsoh7cIfi4D4EDusnTvDMhQpXro144/K1afIxs05XDrGpYadzQG1/nnccL3HcnOPynU2+G32LF50KP/RjP0g8NDjdz5MfTCirmEtzhterc0y+9S3s2XWas8tMJobxq32SbU162uP59y3xWeVzsFnCyhHbOyP+8juP8cmbbb5yexfXcXHtMo9dqoHnM/PYBzBxxkQrhkEdfew55p75IX71H/4T2lGFD7z/BPX0Dfxwn6BWwV0+xcb9OwyGs2RFn9UT6yzVBN3PvMDuwZDQGtI446XbI55YVzy26jLen6AqBQ5kRmI15SwkisZc6Vf4kdYq3938PLNijqrMKNKlQE5PJ+xufop858eZdRW7JqCdFZkrFIAJnsjRTo6SMTK0qL3J/0fdmwZZep33fb9zzrvf/d7ep2ffBxsBkABIgCBMWRRFLTYtWVJVmJQlOVYsSx8if4pTST4ppXIlsZOUrcSRS5UqJY6UWKIskuJikiIJLiAxWAeDwezTM7133/3d33NOPtyeAURFFboqTMnPh+66t9f7dt9zn//z/BfU7R2+/lbC0k+e5UfrL7B4VLK563Dxi69xUmb41RqVWKRSLqVKKWsWt3uaiXTJ4im3f//TDK7fZNDsIk5f4Mzzx4gUvJNMudBx6UYRUijyseXw6dOYeoKdKDSr3Li8xUtfv8LxKMXuw5HHFe9/yOHwiqDRkrihQ61Zo4oNRgXknkesZ9vEQ26ODAKKxhzfurtPOYBiW7B3V9MxDiUNxmWFZyoGuWZjFLN57QZXXr7Bf/xLn6Tee4QgnEMKDyFnPFWsRaKBAxcKA6YC6fioELJsOPuYVAilkL4/c1Qrc6o8IZlmgKSs8gfn/eHmHH/zmR/l6Q89TSozPvNixkZZ5/pLr+MfXaS3EuEphcg8jJinUBPE/j7u0Q7IOoUUaLdid9Bn2TeYhiaPK7IcKhXSWAq5e3MDr3aPflXMwhu7gtoxlxujhH5RQCBRhSGPK7ZvTdjTG1hdopwD6o8xVJXBkRJHgbWCqhLfJyb44ZeUCt+t0Qgs29t7lHFJ4VpkFBFFIf1xRZZGHFk9xanlFdpBiKw0wcEWWhtLfmOTpg2Qi6s0ey793R2Cus/03i2cpSbt+S55ukyVpXhOxZe+co33P9nAD8/iugvcuL7GP/6tf8p+f5/pNH4w9b8PELAHOQ/2vjD73XAyAwfpxbzn696lZd0XGT8IRfu+ml1u+xfcoP6q1MHiAWtBOrPJLKVBeHKWhSRAaounHPBc4jsDbt3a5sYoZeHoI4ijj2IqjXtvjSgZEC61WD42x6FFj63tkrW373L6SA8nytEMMKlmfDcmHNZ56AM+i+oMa7enbGfb3I3qXPjIObJYE/9ZQqOc0nIKVpuC3Uad9PJVxOFFWl0PlVZUk4pqCqYruXC+ydcuSbzUI9caVRqeO9Xj03eO8/L6kFBKTh6uEbUdhOcTLZ3C5pocQew1qR9eRHttXv7G64yKgKefWsIbXkVaCNtNrBPS728SpF0KX3H88cdxHEWRVwzXd0nzjHJ3xJWLmjNPhvRqFjXSSCKmckZdrJcDBvsuOmlzdLHDxsWXaatjOLbElSlUBfnOLoPvfRn9tx8l1jFlCdPMYITh1KmQM45HYTOee7bHhZNNXru4zvUrm5xcrTOZX+LcseeYX6pz5+Wvs/baa7zyxjvMOd8jiFp0ex0++tdf4OFHHqbeaJGUFdVwgP3WJcqiIF1apX7yBJ0jHYS17BnD4YbL/NIJqCbIao+otoz1Cyj2QR3l9u03GW/dY8UdIEYwfzbg5GGPVsvB9UMcr4bjhJjSYOQypQoptEDZkkjmCLeO9lbYnjrU7SqmqBMaRaM+o0ZO821AkJUFLgGBqiOlg++HWCpm9r/3n3kCa98TZPZDPut+sIRkF+4Otrn4+c/xzz/zB/z6E+f5rz/8Uf7VK6/y0iuvEjo1Dj3zIdwXziPf+C7uVo3BeMzkSkpvfsjKCytMz7S5/C82eOaDD8HT70fHIyb3vsDt0SanTzssugNuf2mH/MaEYGJo9xRvBYKdy/nMEs0XtDzoufD2wDAeDfjma7s4vqIRKfLc0t82NB/pcO/bI1RmSZQgCB3aLZe6EOzvGXYyQeRInAjc0lJUlltrKWHkEvY8msqiACXB8SyjPY1TV+jckmcz0V/QcBGhotFycR2PEklaGiZZRVXkZPuWOClJd0uqWM88wK2ivVRn7XtjtK1xfvURFqJ5qr0J5fUBwakaQtcYbawz2FkDk9KYazPwQvbuWjqn20SNKV4l8RyBmqsx6DXpHJPsO5o39zPK21eoRwMc2aDXPIomIMlSJrEmLxyU9Kj5AQqHUTzG8TxUVZJnFXml8HxD140QWcLecEiWlhjpUVQ5ftRgfW2HREiyokLnBaGE5aNNNjcLtJQ4rkslJaqsqDuCZrtJfzAhGQ1QusCVktD3qDXa9PsxOrc40qUVebiOi3Bq5EWC0BmmSGarODy0DtizNY62WrhkZDrBtQlOBfnUxc4tEISzADdbltiqJMAjWlzAlqDmQ8KGpCwyhtsxLTSTsYt8dInA91ELs62HULOtg6pVpHdSkvU+3/rGy3zn1Xt0Vz7Gw09/lKTjc7KyvDhap18YTh2/wGM/8Ty6tGy8vMNP/9RTbL5xnZ3rt6i5Gb6ucJ3bbL11jJO/EtA7eY6lry3RNT/LZvw1PrfU5OHbn2Gh6jP06pSew9LclJOLNX7npe+w+tP7XDi5SrfX4VZP8J3fvszc0Q/wobM+xWNtXvV8dq6N2Nld59z8hEeeXeG1L7zKNelw8sgCy8OSbiQ4caxD/9/8MZf3z7N85lHOLz/MH33hIj/7kRErZ57hN3//Mk0v4+R8l3YYUZOWlp8TqxK32iAp2vRWn+A/+fUT/M+/+S9pV3C5sIxSDbcnhFPFqQsrjC7vsVmFLDgd8tylyIYc96eYZBNjxsy7j7FuImCNRTZ5SOZ8lYoXf+vbdD42x1a9TyGvE9TfJPQSdvsZrXxCM5C4eYAfCMo8IetIfv4//EXmFhYI1IATKw6PPe2jTUVy/Tew3Y9inPdRmQ6ZCIity2C8y1d/74/oXvoct5MBKx//OD/1n/86kQuvTEoWS2i2/RklJxvT8ErcyKE0GX7N4+U/eIXrr22yonPaLcHCBz1+9KmIKChxfQejBP20YO/ugCuvlnw1EVwaSx5f9vmFMx4dt2C46vE//Mk9HpcCNZE0mj7nP9hCtub54pVtPt4tcRoON966zrc/96cUa3t88tf+Dkcf/lv4QWtGueP+VOmAS64E1s4CHLVUyLB5YL1Z4fqKPM4wjkW161TxLjob43fnKE2JzRLKac7OYO/Bef+xCw+ztzvhf/29z9JyNP/pJz7Gl1+/xJVJRu3VK+B4dI8cxmv3cO6uI3YC9nf2qK8ltGsltV5A0osYbY45/PxjOKdPk4mrJMkNMtWnu+jSUzn9ixvoeyOajiBYjrinFIO3dsED1ZIckZJ2KIm14cPnwFdNPktC/EbGeDprYrWcbZMl/HmK8l9a9r2beODP04v+XWrWYM8I9Hmes3uvTxan1GtLtGqLtJp1+ms5VikeXn2YyAmw0xy0QbUUGAeTF9y6/AZCuATtNoljGY9h8VgTzxsjcwerNVngk871WFiSbFHxT377T9nf/L8YjTKSJKcsNGmSURQFMBNhv/dRGXNfPv3uve/Sp+wBFck+4CvLAzHzAy3AAT3hvoXiu5dLPKDa/lUuIQS4QAGy4bwrTAessthRRTlMef1rlxhN6iycfZql04eJI48zGr6ytUGk5lk6dZbFR1cwhWV0a8pzHz/L+sV1dBHjhQWOFahgwPjtLvO/EFIXx2iurjCupozNJq+1PE7cfZXjzZBRrDG+pN2oWOi4fPpbN/jVF55iruNTOxmxdzdl5/U+tfYSJ3uS4bGA7XXFeJxSTVPmQ3jkoRrrb22x06jRmwvwI0mkoNv2SV+/xL3qBBeOP8RgELO2sc6HHstoLZ7iX375NufmPDqRS+g4eEYTuYYMjar2SPQix97/Agurx3n5Dz5NsLPFa8OK6cYEnw0OnzpC59gS2dUtksU6bXeJZGTwTELgjmBksMWYZuthNktLrVwjEnv0KLizPeLOH92m8eEmK8vLrMyPOXsow7EFu8MRYV0w1wioH2qyu+6wtyFwl2p86lO/woml80jR53P7l7h1w6AnJTp5lR/7qU9x5vQK//bL3+JPP/+nzC0u88HnnqcTNuje+RZ3bMa5n3g/S0/PJvY7lWVeOjRbIaYsUNLg+RLlKLQtcUOfNz/3Z5j9HeZkTK3r0Dxd5/TRDo6ToJwILQRFVqKnY/Y2Kt4sHd6awI+stjjftDieJast8Y1Lb3FGVWSey9zh0zS7R8irAbujuzTrPWr+Av3ta/Q3r0JVsnBslcXlsyjhHQAD8Z5nrjk4+eUDofEPq34gcLDgtOioAFFmbBiHf3bxVf7h3A1OlgVit2A/XuXIiY+QrXvoU4/gNHwWih5rt17nxldus/Jjv0H9pI87KsnWryOdD9LvLHOpW+fcYylVLWYj2eSr10YMdyoiV6IiuJJCaWGSGKK6oNcQNKUgyeDuxSnvO+HROl9DKJds31BzM26+ts9gx9Bs+cTCoj1Frhz6g4L97YwwUtzaqgBL4Cuko+hPKtzU2adS2wAAIABJREFU0hKW+Y47C1uzII3C6wjGuzlO10VnhjI1DOOKtLRs5R5Ro0SnJa4PbigoSsX23eEsVG2qQUpqywHNMzVu3s4Z7RuWznY49+HTNA81sLqgd8QBJyePh/yL/+afsn3jOkuNGovzSyyfPMoXr94DvUOrfZi0chmPRkwGU+YOBQzWJggHLl+foBkz164T+j4yEJTZDpO4IE1dNCFe4FJTHv1iwkg7THTJcJww2h5QxBVKgfEy4slkNoXTCoVmrtugyDP29mOyUlAys8Vr1lzcomRpaRnr1FCuIgxcGqFP4Pmk0xKnyhBVhWBmRaekyzjOaPiC3WlCFEaErocwliTtz5JbsTTCOqYoKTKN9KDth1RlgHE1tcDFqXywiuZ8j/7uLrV2i72koi4ltchDhS6OtOQARcpkL8bxIPAFlWuZFB7eIAWjcXyF4ysEUOUl2faQvTfvcfu7L6EG13h0NYNFTf2kwV/uUI63seWA0POYW1hh9bEGo62CQ6suInKhlAh6mF6HWv8mmrvckNu88ns5K080OPn3F/i53jJf/HaHc3WPV165x2rrEOp0m3FesHt9l/lnH+F83ufFP7hKNQ059/wpTh/rcegf1vjd/3GN9q+t8uxKQP18yKd1xe03mth3xnz8R0+ycW3MtSvfo2GvsnLs5zl5uIVuQZ7s80SZcGtzymfHu/iTlzj9kZ/l3/zhv+XnHxmTTFx2Mp+tQpHt3OJYlCBOHya+NCLf2GG7v0/fl/zcb/4dvvhf/R5Nk1Fqy72sQO8O+ZhjWDq/yo3rOwzwESoi9APauebz+/f4md6HeWP0beqihScirFiiLrZ4AZc/vPp5PnrmaVi0xKHmGosMnA1WOwb2S/S8T1IV7JWGe3WJ5zrMFUNUtclYG5onuvzkrz2MShLW39inFnyaS8MXceaOY5ptvvHONkvxUXYvrlE/cY73/+qzLL3/A+RujfW0xG72Ob8YoXyLk1f4TkHdqRBhAPIUn/69l1i7vk3kZBxakZx5rsXRYxCFAi0UVSGYDDW3rma88Z2Cy0hONT1+qSkY3cz4Z1+a8N17FbkQ/OzTNQ7/tTZyxZA4MPXqHJ87w0/Nf4CdJOF3/tvfYuPNmxxdDvmZX3mSZ57/FKHfRsqZ7uZ+wybuvzWzCbQRCqQLgDUlRZxitKaoMqpqdhY12i7j1CHO0pkLjC/JjSWZvEs76QVzGCOwQjCIDV988TV+5kibjSrB397EU+dwewHVRGBXVggjh9VDNbavvMPEifEbx1nfv4PXryh2b4PzMPtBg3QxZG7BUsmMcbXPd9/eRZUQRh6lX7GdV5RGM9jPmTsSMF/3cCoo8oJsa4MLp1o8/PT7+Ef/5cvkuaHKZ/QWoyHWesab//+1R53Bg0prtne2KKYaPwhZPDbHE489x+Haaf6XV36bH3/+x3j8ofMYLRCU+BKQmqrMGQ1GLPTaeH6ECF1GpmBrkGLtPs2VFbZGKZv7OyT5iFbdY3tthBMqNrfHjPZjsqSiKjXGQFmWWGtngmQOtgB6JlCEdyXas9wI+8Az/T6gmPH2JX/BBf09mo374tf7Ogx50Jz85SF6f7VKeWqmw9CzcCiAgpJf/tVf4hef+wSv3bzIwtIKx073iI6GqLrPdLiLrEZEjQ6tpTb1rksx1XR6EqMcZGqhvohYauIOhmj22JNL3P7jkpX3+6w8U6dja9zdarPgSW68tMX5J89y+24fq0PyuKD90CFOZRPe/NIaZ58/Sn2+xtLhGq1GwMtfGVD/iTaPtR3e0LBrNdv7FeVuyZPnFrh7t+Lqm68SqaOE9eM0IhfjQZVMOKlLbu5ljEY7NMWI9tIjXH7tHT75WMl4VzE2imFWESV95oISlufJ3t6nyvcYTgVO6PPE3/t5Lv2T36WXDzFpwa2NXbQQnPMkzYcW2bu+xVQ1sE6XiDamP+XGnW0eOv8h7t16kbZaBqcLrqKuhpwULhdf/g4fOPE+njxzCu1PSeQ2oRiwNJ9QJFPubZQIF2zT4h5toYOIhRAEE3IEH/6xJ3n2+RY2S4i3+4T2Iklrkb/3y8+zV2j2JiWtwqP/9ibdR5/gsaceo7mwTKUcysoik4KlpodQ4FYGV+nZBlL5IBZ55WvfIJtuUQtz5lZqzJ9s0GwJXFeg8SgzSxrnDHcLtu5p7uqCo80GPxelbL61xWeGTe7GdXZGb/C3PnSCzvkGhd5hEH+eRK7Qqp9joXWWcTFhcPsWV773TRrtihMPn2du8QxKeghm2SPvlUy9K8+2P3RA/gOBgxf+7i/ygdOPcuONy/zhv/5Drozh80OHFT1lL9/GfPvLnJRTFv6z/4LBxZR4sIvnJdSaM0eN/d0hc0sh74iA6OotTg3HzD10nvOPPcLevW/SHF7m6nduIJKEwNdooRlj8AvYMZZ6R+IHMDUwSi1dCUvLcOiCIVguKKaatXc0b3wt5uKm5fyii1SGwvGQro+wkmkqKOxMpOw4gjg2jEYFRQHTSYnnSyLPoCOBRFJoyyiGvDQESpAYy6QwVMbi+JIwUGSFJk8KXDVbb9vCEk8LkmFJPtEzMXQo8WseYRQh0gq74tJpR+zsXoNsSlfWWHB89JURoswonAAd1HCloVIZGxv3OLIoGKUN0jRmPJGkZQnCR6mA9qJAKk2WwP52hs3GSM9Q6x5nNKkITImpQGuXXFtsLUIZTan7BMKh5tcxTYPwE6zrsLuXIoSHcHKENEhdYApJ4PhUwqUyBWHNI4oCkAK31iBfv0dRDglqAaKK0EWE47gM1geYLJm9CDkBxvEonBBfhZAk+FWBTgyxkGhjyIsK43o0owDP88BTKA2OFcSTCfWoi/BrGFNhvYCiFOxOpoR4mGkMIkA4Dm4oqTUUNV+hnZDRqCRQEpvlSK2J5uvUFpo44czWqyjsAf96yv6dO1x5c59i9w47g3vsx32avuCR1pjk9f+NQn+c7+4Jet4qS2cOM3f6HNN9y85NOH10Eew6kesinIphuc6hpdOIssGd5CWuTnzeXzxGuNPhG//q26yeeZp7n70FS8dx5BS7cZ3peIfd0R4Pn+lwr7fKelxy7d4O7tUQrzNP3XP56V9c4SvfKnjmsYILR33aT7X4XMPh61++xdXbE1afP8UdYu5sbPO9L3yX3n/0AmNTYt/3LI3pGt1Rn55uY488x5e/eZvtMuCQc4zKHaCm+8wVY9qnltjZjuFaymL7CKW3zSQesmh7VGtDPvTJQ6x9ZYNL2xn7pWG/LHl9d8qH6wnd0CHPdvGKAFN63MldPtz6EFem79Cgoi5rKKEwomDinuRm9jpPiDprr18iON6icULhtQ1jGzFYH+MvaHRiSLcL9G7Jma7lSN3iZy9hp+8g3ZDIKfHnepSFT72mmMYu5+mwNijY2JtyvnWIl/dcDv3EC0ydPsXqMdygh1NZdjdT5msK4YIkRdgS5Xq4nQWMucrdr32Re7fXacmc7gmHuQseh04aPKsoxwWT3GMjdblzt2L3CjzyfI2//dRpGn6NmuuidcmPZynjJGM8gvU/vcXll6YcfbzJ/FEXPYmZ3L7GMGjyxh99B39zmw88M8fjH32W933gU/h+Cykd4D2WjwfWlWAxViOkg+MGGFliypwimTLdH4IpwZYz4G9LsmJM0AkpxhnefEjpVlTZmGo6fXDeP/wf/DSBcLj95nWuvXmdzZHHG9shi3mftXhM9OWCZjXB//BHyLYqksEAVIz1ZsJg3/E4ffoYfywjWpcvs/LXPkZrrofQ88TFLjJdZ/PKdSK3wKiEUsRUNkflli2r6R4JCeqSnUyjcsORjqDVheZyhWpk/INfPMYXP+Nw4+0R9ZrHn70+oNTmYLJ98CDs943OD+6qqoo8zzBGU683Dj4i/53ZSLNp3uz6x8mU3/nf/ycEhsMrR3n46JNIXF69/RKLqys8977naNQaGAPC2pnrv7DkyZSw3qB96BDYisFoQH+wS3e+jVEtqipnOo4RwsVxQpLRgGSUsdzpUuSaJM7J0mJGmRFqZmEoJdpoDgIGDhyaBJbZ/42xHFi92oMcgu9zBeK9QWbvuXYHF/C9AmGl7ie2/tXeGtyvB1NWCUIo7ps1mjLnyvUr/Hc72xRpxvLWHE8Vu7wg+qQLZ7idB5xYPUW01CNY6pFNLelQ0JurgxniBwFxtYlRFfXDy4jSZXt8jdulT8uepP/OhN2NMd3VZYav9JFnjuL4BeX6LnE6Jstj5pqS7XaP7byisbVH25Z4QYTrKR59tsHLb5Q8cQ7OtBwaXsiVUPHOrTGL/ZxTTy6y/p2Y9XsJzdoOR88vk2Ph+ClCs0uziMALQSxx7daAgfZYEEtoZx8vneK4An++w3icw3pOd+kY+5MNpBZ4VYCwE87/wsN0P/sml27tk5YFe/0h9254HFc1ajVFOb2JVzZJExdRRBxZOczOxhXqCnyvBiLBOg1S12cwvcwJ0+TuxXcIjtcIlg1COZS2jp8MaNQ0zVaL3f2Seb9ErTjM1Q2evYLUd1EiIApKhDuHqSXU6j555nB8fp7diaFJhNOI2Bj6zD1zmKk7pd3s4TgBprLkaUXdn1mTSUoEBun6KE+jyy1Gt15lb2edubAkWoloHfKpdwzSKnSWkpURe5nPaCdAlhXHHlI8tniM0A3xpeRIlfK+siQtDfF0germBv2d08wfX8LYdUj3KeiTqrvce+NlhjtbLBxdZunIo3R6p1HKf1fAb83sufz93ssHtqY/zPqBwEF3ZZ4jj5yhsdQmOlLnD37/m2xeewdjJBOdsb+7Q/21i/zC65+mduFjjGSK2c5mh/F0j3ztdbxDH8TqXV7Z2eexPKHdipgcOszNmw7HRxsMru8STwqENBAYxsIiSqjVQLmCvIRcz2zPSgl+A6LI4tmSwVsF179e8d3rFX0leGrOYeQIZOgwijX92ynb+wVlVqIilyzVxHFFnhmqajYNcY3FdQ4mQZWhKA2lASMETlNiEk1lzUz74Am8QJAkBW4UYiqDObiS+bTEVBbM7PeOmi7KCMrNgmbo47ZdbFmxv76OrRVkQZtpUKOfT5DplExPkaGkkpKp1LgmIbQCESp2+jGplVhXEXgBSpb4QZ3KapQfklYOw0zTVIIiK5gkGZWuCBwHKUCikY4PxZS80pRpQVFoHM/FjZoIbfGcirLUSKnQBuK4RKUWgcHxXXxrqYUu9XqAoxRIg65K0jiZNS5mlgxaFprpJMYBXMfFUe7se5Yak5UYDYEfYQ6AgbEVQrlY6yDw6HQ6mKLAFhWuVYymBnRBPE3wRYDrhSCh0hV+UEPpCY5nQfkkuUbbnGB5nlhrorZLECqEBulYVCPEuB5KSaqymgW7pRnpcEQ5KVFK0VtZJomHOK4kEpZ4UHDzzh1ub/5rXviFX+Z6/wJ6e5tmkSBxCDqSwAcju/jqGoFbkfUOk0cepqyRjVOijs/a1uuk2uXw2eM0/ZTtu32Wz6wS25xBMWU6GdD2mmTTPRp6i9g/hF+rEYUgSJiMImqdJqcuOGzsxhhVsnIq5IVzDTYv99jYzagfl7QOzTPaHHLl9Tf58PoHaBz2WZvrUrz9Jeo4XFh+jEulw+s3v8cHj53irbtjek3JSsfBH28xmMTMNyJGQ8H2NMalQbfeInMKRJwj6ocIVxOWsj7+IEcbw05WsLa5R7vXxLMF2AQXw4oj0XpEZSvqskmJASFB+ewSkymXyoxh4pHtC4pmg6DusdySjGOIdiAfVqztWfZSwenjLd55J8ZztpGiIBASVIkQBUJVKEdSKY0fzFG6HZAtEnGaJ7s+98aCR46epDW3hFdZVJlSkwlO6FOaHMcavNDFlT5WaJLpgDdevYkqczqHXRaOKOZ7kroS2KFFteq8ea1gfzelGTr8yE+usHocVhamqEAjCRDKZcFpYuwSRabZCsfcuznm1Ttjrm76nDsbIMyYzSuvsn1lDXyHo2ce5cJjn6DROokUzsxP3xQzfQww63DkAQf1wBfmoPGz2mC0nWl2FNiqwuoCa0s818z0FHGBdByEq3EjSW2h+eC8l82A3vwiYbdB99gSb75yh50rG4hKsZsk6Ot3kfNvcu78PO7CGWzhwcBFYbHpCJv0qTXbiHKdSzfvcVoXiHaTLOmQ9Peop32Gt9bJshw/KsjdigQ9c4drClzXZZoZMmNwxey8dwKB62qkzVjKE464lmnbx/jOAc1FzMwIAKM1eZEzGg3o9eYfWF8C7OxsceXtN/A9h+ee/7ED8d999w/4d2t0LWVVMZ6M2B/s0Gt3+PhzP875M+fxfIfl5mEuHDZ0Gp3ZZP09eMVaixvWEAZWTx6nKDL2rozZ2N4gygZYB0a1JnFekRUZ49GInY1Nxv0Rk/6EySgly8vZRgiBle/afN63Nnyvs48x5oHI8f7U//799j7lSMr75kJ/jp4lHuCMd1NYtT4IWuK+e8r/uzXiX5W670p1/29trWWSJMRxzFyrwyhJ2NrcY6u1zvaNPR7/G3+D22urhCrH0xVCStzQ4iqBcSIc1nDrHoQ1qsBBFD7luKA+F3DrxiXqjTrdlS6+UzLZTeidmCMucmq9FpEr8KWDKRNCM6TwF/ADD0lFmScYFeHXA5ZWJBs7OQuLisWag5nziPshO5Oc7iFFv9dmtLvDzvouh47M4dcV+/Ua9s3v0pw/hgjm2K4K+nu3OTm3zNWthKVmQFdMsVVCUbrUQ480lvTjFM/pICSU5FBqaB0lPLPL8iAlG6XIPGWws0/b8agdWcaxMcZOCVSE67nYPMYag3LaVKbE8RwqZYhFQRWEWDdGTkfkQ0FZ8/Bdh5qrKEqBn0qELBmOc5QXMjcXsLef4Dn7CKHx5AhhC6woMeo+sNDUojlKPJKihWc7OE2HUSE5NjeP7/qoyiCNxZMa6SgqW+Fai/JcpNJYW5FnEzZu38QXFfVDDRpzLvVI4QG2sMigzY21GJ3EdDs9egtdmm1NLZwg3BxhIwLpgahjrIcuS6bRlDS9y62bmqCW0mpajF5jPNxg7+Y1aEb0Fk/Q7h7HdVsHLkTMhj6Yg9sHoJyDwYS1iL+Q8/L/bf1A4GC8tcvO9g6i7vOhT3yEYV/yTTNlcnvKNE7pFzlf2trixB9/msd/4zz1M4dIXIfprVuk8SZqsgvWkpT73EsSdoZXWSqP0O80GdeX2X7pKtONMamoZlY2IeRWUOWWdkuQllAUUEnwIoETQdWSWAnZWsWV71VcfF0zET5P/vVHieo3eOeeYTgo2N6q2FzLmKYGhEVNoco0ZWkwxuIoQTNSzM25tJoOvicp9cEBKwTKFRgJrjNzNnKEwosURkAQCoJAkiVQlQatDXmsUVLiegLlSWo1j8BK5MTiui6VUpRZRTaeMiocMl8zreVYL0JnI4SXE3U8KgOFsgjXENiKIi8YT1MqKfCEg+c5KD/ACx2UmTXFmXURlSCoLGWeQ1mQlOBJie+CpSIrktnkzGriJMNUBsd1EYGLHqdY4VAVKVpXaANVJTBWY3SBG0RI18WVDo5UREGAqyz1uk9alhgh0GYm5s2mCbYqEV6A7yo858DX3ViqvMBXCuWFMxsvaxC6oioMZTH7t1RK4YUhRpWUaUlRVegiwwpnZtcqHTxXEXoQBD4mGeGIAoMk0RVZVtAyLeKiIghdHKWQrkQFPtp3KQqNrixFPpu0lnFCMojJpyUL802iqE0+HlIVXfI44c71Na4OLaKoeOj8MtfeGmP2PJpeiFAKN5QoDI5soZTEDRWB32NCiiNSat053GbKXjFifRhx6FiAKjOcSNFs1omcOsnqYZwiwZYFNqlYqRe8PRIM+znpYMLSMcUk96myklNnQy5fKrm+bhmbiuPnPR493+GVG7sEQPfwAsm9bW699hpXv7fFE8dOs2EtVS4JjEZM+4wGfXwnZpUh39neQ9geva5DFIZ4wselpFPT7EzAWh/NjAompiXahjjzbZbHJVEJe9Ocwhhuj8YseQGLgYNQGkyObyTDYo3IaSNMi4Ee41mIpMvAGRHUFsjsgLoaUzoRk0Kxu5Eyn+eIZsQkqehPLKPCwa37dGoRV/fHuIGPkhmOzBA2QZscIRRWeDiuoXAUtdYyPblCOp2j3Qzo65JDnWWk5+MYizIVdT+nVAFCF3gKAsfDkRllMuTa27dY34pZXHDoHnOYW3RYiAQqNwgEb+9I9hNohJILJwOe/FAPIQrINrD5GGM9pBshRBMlHcIaHPuAS2/OcrOfcudOgVOXPPVEi423bzGdFBx/5DTHzj5Bt30OcLBYKl1iTYxiNgUWaJANjFUPQqPuC0ONtVjloAIfbImxBZhZE+wHijIvsdJSlAmVSVGRpLHUfnDeT3b7tJsdwrkWR9oRVoVc7O+TbIYk8ZCb4zFcvU7tpRoLH+vhLtQprEV7HkoXkCdY22CabrC1PyRJbkP7DFnUIO4HDK9cYbq1QxZV6MBQeIKskthC02p5xKUgjWeiUTcUqJZEBworoNydcu+dAVVcsbQ0h5lbRX53D6UtnW6DW7ff4RvfCMiLnCSZ0m51D3ILoNFszmw9tcaisHYWQjQDBhZrBT/oBsFyP1TOoKTiqfc9QxDWeOaxZ+i0ukipED2BseZBMukDu1AAa/GCAFFWLKwskWUZ1TtvcXttDUdajIJoYZm8KCjyjPFwyPb6JvF4ys49STpJKUuNua8bOBAb32/24X4zf0BDu+9D+h6tygO70/vg8r5Q4fsa/T+XjfCe+415N9zs3ydw8P9Ula6w2lBiSPOSrUHM9c0RzfYCq6st3hRbtKWaCfHVrC+QgBAhCIPT8DHWJ7MVQlaETgOvk7ETT3DqAd2GgzQV0pdEkY8KHZZWl1A6h0ojlaYXaq7HkmSiiQKLE1qENZhSs7Tscuem5N6Opd219OqKYwsBV3cKQiHorLTY3dtgc73PkXsJSxfa9AGvAC+vKM2QNB7iypyeTHhzf0jLnyNUDo5wcYSDQ0UtMAxi8IRPUZUkeY7INMaGOKvLLG+ljO9sE49T8jRlZ3OHdtSi0wzRNkfqFFkY8nyMF3WxpsU02aLmR5SuJvMz3O4iVTQlkn0yFZCkFXp/SlgvkGGDokgojKZSIb7fRpceG+MJjuchZYKSMdYkGFsihAPSx3EqrHKp1eYxqkFZhdSkS4ahG7UphEAYi8IglJ4lzRuNIwVKKiSGPJmwv73BaDhhbiGkthjQiBxCBeIgcf3OPqQl9ALJ8lJId7mBIIVqCzRYUwOnjlANpLBI39I+Ion6d7m5GTOsGihvnrmgznj3Osl0zJGHHqLRPozrtpht5WbAAKoZdcjOBgAz0cz9jeWB0v6HWD8QOLj+ytvILMI71OPZx4/y1EeOEyTv43vpPuX6mJ005dok5ne/cIm5M3/EkU/9A8ZnlxncXiWZjNGiR6U1G7oktYaNa19h8WaFWHwe1Vjmxd/9P5iUJeawJA6hrMAtJLmyyEgS9w2VskhfEDUFK0cF45ZgkAq2v1nx1UuG1wvBhbNNfvrvfoJvf+6fc2k7Y+1ORTzQVKnGGIHnSUycP5iKKEcSBJLVnsupMzUCYVGBQ1xa9EHanJCQxjNhX72pZiFDvmKvX9JdDGfr1XIWFJcmFWVpZ8l1riCIFKHvUPM9wiCgSCRaHLxYKMiqjEwDSuP5LnEREzU9vFCSpSVprtGAci072xOwBqkrbC6wjo8buOjSzmhQJQglkRJGJmaaTvGEJZPejNZjDHkZs7OXzYADFRaDVALXc0EGJGVCXkGaTsjTBIBGvY6yBdb4ZLnFdUMwCp2D8AWho+j16mQIKiMQwpltwpTEUZYocGlGHtYISgMohyovwZGUxqCUi3Q8HCyuykmLAgMMBkO6vQ54PqP+lCTJScKcbtRC5xkGjRtE+I0Gru9S5gG6tGjHYD0PPJdc53jKkkwKVCGptRuoQJKUBXJiSWo+RVZRZQVVUpFPNZNpzMrxDoWoaCwuMtmP2RlqbpeStHWYT/3Iz9FsLTCdvIjneTQPn0W4UMYWFSj8AlQwj2gOEOmIadFGVLssHjlFnH4D2gtMvGO8+d03OPPoGVorHapxRXPe4cyRFZqOZH3/Du+vN4lOHOXb38p5+aVbyLTBj68+xHJ9yLiqkRNw+GSN1y4WfP3Fgs5Jj0OnIjY2XAITII93mA52uPyNiq9+8QqPfPIko9hwbOVRJjub3Lx9h7ha5/TSUe5efYNDumR/M+H18RzLS8ucXJhn9+5lTjTGdFZX2YrHbO7skA9c0kRQpCnz8xHhXIsqtYxLQ5Fr+saS9EcEy4u0HUlRpdwpCnpa43pLlJVkaHdxZYZ22iQNyfziKr3JmMT0iWoejpsx3NxhPck59lSNioyhDAiciEO5Yu9GTKA0TjSPLG8gxBgpCihLhFRUNgSrSMo+ieuRBR3GG+usxQ1OHj9OXOQ4Us2a58Cii1k+gGsqvMDHcyw2Txjt3OHiN9/GdeHkOZ+oq+g0XDqBQzzJEV7AV14f8oHjDh+4UOfQUoRJKlCzzVgRZwSuh6MybDxB+ZuIeg2bD5BhwZOPg/ZK3rw3QYdH6e9N8Fsuz/7I85x55JGZk5qp0MaQ6phADEEEgMbYFCECjAUlFELMJklCCowQGOUh3BxdVCBnnHAhFdY6VEkGjmQ6npKVMY7r4tXeXVHv39mmMi5hM6DbClg52WLroS5Z3qeeGfbyjKtrW8gvVHyoN0/zgx8lW+4Qt9sYz1JZH1uWbJQZuSnYv/t1oqYAp0eRC6589UXSYoI5EdJXAqkVGMilRIQekzjD+hYvkDRbHt1VlzxQpAXsXxrx0s2CEoejp4/QeegjND7/EnpScOzsIl/92p/w5S99BiEUvbk5iizFVBrpuJw5e4Fnn3uBH/3YT1EWU4p0jB82Z/ZH/ODA4L2llMN8b4Ff/LlfQTkK3/MfTOwtPAAG3/86PgN0AsdxiGoRjuuQpTnXb9xGmIrcWub2RvT39rFYtDZMx1OKopwoCYUKAAAgAElEQVS5HGmDrmY0M2EBKx7oCcT9pv8BBehd//P7Pxsr3hO0JB/w72efcPDe3r9xPxzt/i/OA3Dx7uP594Na9JdVpSuMNuwPB6RejsWlPZfw9//mj+MFEZNBH46v4LRbAOgShCtwtEXUOohyjCkK8tKDKqZ9aJ40vkh35QxlLtla22H+UI+oF1JOKupdxdGjy8TjIdPpiGXXwzu0wDdfSnFeH2Mv1Dh0okHoJhh8KqvoLUreumwYJhWnzjp0ug6dfUGAz+LhgP0bPhvXxlx/p8/i+TZZaakdfojhaMLeaAtNwkKzy+76DZao2Nu0TOsR3WaPlu+RjHaYC2PChUPsT7ZJ45R8DGUOOs9pL7RpnD9PoRXZ2hZ5UjHOC/K1TaJHzuM5BVkSk2ZTokogG8voVDBNbiFVG12rUXZ9/PkFwvFlUr1LI/Ipy4I0GTEpSzrtFpoxqazTqXcoJ5bdvQGe0kh3HqnfRIgEbIIyGis8DDUc5ZCZMaV7nCJXxMmY2IbMd7okeYFwfaw7a6zvZ38oa1COi8Kg85jJYJONO7dwXMnSsToqkNSCAAeoyorSerxya52nT9c5emge3/ewZQGiwlqFTkc4ykPqfZD7COWCE4DeRjgJJ45W3N42ZMVxHP8sZXkHrxVy/MzDhPUmM7RuZs5rtsQVOQgPawsOnCewB650f95i+IdTPxA4WBtuYdbvInZ2Gbz8RbICjj7+YZaOH2Gcjyj3SnSZsZWnfPa//z/5kWPnmXvfc4jeElddGLxT45NPZ5zouYwzy3e/co8qfJFHP7HOxc+9zCTT9B5WVF0o+wI7EgShQK0q7mxmZBKcOoQdmDsu+MQzivXdkisvC/7kK4adocP8uRryuZB/9Jv/mJuXDNPdEl0axIyKinRA+ZLAFThqtppxfEmr5TLXkRxrSzylaC4FZI5gkBkmmaWwFfduVgwHBTry8CMXL3LwS4lX87h7bXIwha6w1hK0fcrYEIQSxxW4rqIygklucJT+v7l70xjL8vs87/kvZ7v7rX3pqq7eu6dn5ZBDUuKuhRK1y6FlQ5CDBDAM54MRBIjhJEY+JIAT5HMSB0FWJIZNwYsoirJkDkkPSVGcGQ5n4fRM9/S+1F637n7W/5IPt7tnKMgIo0BJmAM0bqPq3nOrgLrn/Jb3fV50rU4znDGSk7omjEK8txyMUrLjlOP+hHasCAJJbh3TqkSlJQtrCYcHU5yfsfxMYcBVdJpdchcggghkgDWCrLD0RxMWWi2W5uYIrGfYG7K70yMJNEZpglDQbDeQWISEIA7Qqk4wHVFoT+ktBCFJq003kbjSkA4KglaTonJkacZwkqF0wJ39EcI6SutR2s9SD2WArmmiVoAMYgKhUJVjPMlxhWFYphhTUessENcjGnHAXDtGVMdUlWXqHUlDEcUJUWs2oRpUGeQpi/UmLi/pHw3Y3g948tIl5hbmuHX/EK0E7XZCe74JHjrNiOGxRCagI48oU/JhSrzaYTTKCQKBjmtIp1AdRev0Ek4FmMKS5CFpcUQqR5TxHH/lV/42z/9bp8gKweXl84yLffLpEecXFC0jKA+gcyZkeXOJ49ERO8e7bMYr3L/zgKDTw9st2tOKMOvRS7aoSUmw1EZkhwS1OnHYQIenOD5uMv7hP6L2M7/JpbUhN+4UvL2vaFzp8fG9b7L+xf+QB86ykgg+95SmtyGYHDlcLDm3PMfUGrJAk66d5ujsz3E8eo3Du8+zETXZGw2Qd68xB2x97Jf4B1/9X2j0HvC3Lq9Q37nNu7evcufdiHuqz6/90rMov8XKcsW5WohQ51DBCa7nd7ny3Wt84+Vt4uMJy1LT2Vjg9p1jPu08DV9x62DEciNkKZS4wNKUdW5U95FecTK02LDOnXqLg8VVDuqea7eGDLMxmwc9Lq6GXHi6hX1ylde+eo1f/HhA+8M/zdV9wRvffIvdt3f5qx+NUdEuxeEBUZAj4ofzzyBERRYz9mD3mfhD7qUL3N6+w08/+TF+aCvWooCad7gy57DK8dWUU6HkgaozHyukyznY3eWH33yR+VDiNjWdwNCJIQ48VVUxHSleemfEF3/9PIvxLvNNhShyzOCALIlxkebqYckT53+ZzvEB5e0/IjqTIGsCezhhvGt47VVLKgJ+9fOar/yL19laCXjiUyc5df4U9WgO4QW2KhkVBaHKcPIYJ+OHU6k5KlPhcdRE9HC6NPvnXIkzJbYqcLbCVCnCFmgqrM8wWLRMSWoCkytMXlGm2ePr/f3DXd7dP6BTU5yer2Od5tzTH+aN3V2CapHlSR9XTDk42Ob2//xlLpy5SDy3RtZc4mBaMdj1rKkJp9ZDisLw+jdf58laQBUGvPf2WwyLgqWnE4quxOx5YiuJ4hBRV9w+OmCqIWmCmofVE4qLawGD8Zi9I8kffidj6Fssnllmr2V56/Xf5eyHtzi8NyQfpBA4tJrJDmUATz3xIZRwjEZ9nn72Sc6eP0dVDLj19h8RBDGbFz9LGLce3grFj0zA/00F76NJuxACpRRKKaIo/nNe9/B5H0TjPD7J+wFrYRgRBCHOeQ4Pj1ASkILjo+PH5/OANYayrFBqJjP7EVSp82g9+1m89zhjcdZiLX/md+JHtghCfMDgLmY/62wjIGY90+NwtPdf75iBc+1DstFMrvST3RyUxiCFIC9mUltUyEgXnPjUKYwRnFtbQTsDJqfdkFQCzASSZUVrsc3QZZjK0ZA1hvtDZH0C2RatUc5UJLikTaBANSIox6iwTqNTQ0ch5UiR3/8B8dMf5+LigLs7A35wfcDRFJ5pw9xzn2PkPMXxLk+e6EKYkE0qCDVrrYTYSUQiWVo/jRyFDIf3SUfLLAYRB5MRYu8BS505xt0V/vjaG8i9+/z2s2e4/e51tu8JdqVlpVbwxIcuIDjBfCdnfq6OPL2Mkwn9os/ujXt89/t3eOHy87RUnXF4jcmNHbasJ7YTbt84YmNZozSImkDrGofZXaRTrM3XGTfrDOYXmSx26MUV99/apz9+wIXtu6w9McfSxRXMXJc7L7/OM8/WiLZ+ids3d3lw4weY49t85pk5kHvY8X1EbEBYvFAP/SMhrvBgDkjVlF6mKIqCzYU2u84wp2fqhMoYSl+hsDQljGRES4MzlsH+HYbb79IIFX4pJCInDmK0zLClZDyGB4cjPvP8s4T2+iwXpDzCmTFWt0AvsD855sTqX8Ht/QG4e6hOG6TBTfcphpb33itZXG+ga9d5863v01aCrU9doFbvzMhEHowzGOdQosKLDC8MQkZ49AwsIGCGG/jL/7z9WM3B577wBOsrG1x5ew+XznEYKBi8jQj3WV7xdGWE3isoveEqOc1/8A/55N/3bDx1Gn0pQOiM/+aNK6jPPMvuH3wHl6fcefkeX95+QDm0hEuS1Z+O6b08JSsstASTI4M5KKmvQ3decKoLT6wIntyUrC04vvPH8OWX4RCNPpswqEv+9KUj1GSmKxMaopamuxqwdabOk08vceJEh7WFVQ77d1jpGDbmBO3QEaQVAR4ZJGQmpl/G7E8E9/dHvPfuPgfTWVKkMJbsKGPaN3SXmkwrx/g4w5lZzm8QK+qdkCJx+KlHGI+XkjDSJHGINYrssOBAOrYurlBf6iJEwGB/wv7t+xzvHhNKSWu1S70dkcxrXNRG2zGD0ZiRKvGyIogESa3Oypl1onqXw527uKIkCUKacUI78FhpieoxiRlydDzhwYMeOw+OcWHM3Poy3XoXrKAYF2TTDClTVheatE6tM68ki2uKdJjSOzxiUkGnFTNqJVRKUVV2Jnsae25euw2hZWF5iYZQeFsBhsVmTDoGCk9uUlJrKQtLkRtEZfFKEiZNdCiIA0FNKXxZ0Wm1yAmhcqTDCc4p6oubmCAl339AJ44wZYYMmjQW50iqjG7sUb6iOdeg8BVZlaJTwXKzTjUdM+hNSJoL2AyiANqtOgfX+2w+WyOJatjUIMMA3QixxpI0ErJRDz0XsdJYYXljnp8Flp7fJKiHjHPHvTvXCa2jdfIipXUUB3D6IwozAM8KjShjLSzIRcnKhacxWUTYmJBVOV6HnFxc4nYPnokNeRCALQiFJuq26Pg6//j4c/w7keKFc47zl85zwy3xlTcz4uc+R+3geywuPEkl2iStiGYz4PaOY6eS7BxIFlqSshCE8y0WPrnJ3f/xS3zpP/tPee4/+nvIWo9mXKB7nm995WssHklWTn+BP3jnG7TDDBNWjHZ3OSoUL/9XXyULa1zQhqfbmvNzmmZk2BvD0M3xizqjmCupaU/DS8bNkK/3xpwPEtZJGecB/SpiWacsNCUvHvR4IlI05ze4HzX4QVXy3uE1itGYp78Y8OBFxbd2S/7kbsb6QcbPXe/zuV9K+NI9wfMbYyZ3+jx45ya7qePiszOzutUVlnKGYdTgHpIoyriOcRmBuMlcXbN+boWrI4nQjkLNmnepBcrAQrvFwVHO+uockoJicJOif4VJoLk1nvJrn6qxqiOyquTeg4JdI1g6u8InL53mvW+8yskvfoHG4n18/iZmCm98bcATv7DATz3zAve++zJpErL60Y/ieQs7OSCbWA7uWeIcppXlvddzzrYkxX3PmdMfI9KKcf8uRdmjEouE9RFUN7HhAj5oY0xEZS1eVnR0iPMSyUOcqUmxxRiBRLoxCIvxGaaY4rOMbDwhUAJijarAU5JXJYMyf3y9/1+//L/x17/424yyKf/4xVc4f/FJkpNzFKLH0pmYZDtG7k2o/JT7BuL//p9w7u/8DiuXIUkLRvmUb97N+GfXD7lQMzTHE+784Lv4WGDLiuhkxPJTbR68chNfCygKi+kPscbQWNEsdT2nm7A1H7LQlChfcu+245tvSobdDo3VVaaVYbzfRxagsahY0dxscP7MKpfPXeLMyQs0m3UiLRhO77HafYYkmCDd71NNCzZOjpC6Szb+XSrzYaL4LGHY5S+ENP1AE+H5UXnNj08UmU34rbHYhx4J62ZJBELKx0nF3gFq5ivBzwzOeI/SjwyMHmftTF7mHm4LxCzLAGZ+jA+O/B/5CKSQ7zcbgJQzX8JMrfa+p8UY9/h3lA8bhw9YGH5yj4fbEI9HKsGzzz3Fv/8f/B2klpgSDt7bYeOZFVQjwFYOm0q6mwI7Ba86NMIM7VKcEjQ3V3GZIm6V5JWhniSIJOZ4DOuBo1QBmBIdxDRrMWmxyFujp3jBFcw1j2i/sM7tLObaZELljvjE8DZxbY21pWUcnuP+gMFhgVhYoj/yrMdgI0F9vU46Cjl45R5v/Ks+G7/48xRySKseMB5M2HkwYmGq6W59lm+89g3mOhF2OqK/P2V7Yvnen1xjqBt8pGU5sxQz1xZI5Rlnmkov87kkI7v7NTr1BvFKhD2OeeXmfc60T7BoDjg63kSHgvm4IqrD3uA+W52I+ORT3BGaq/mYnd19bGPME79T450vad49Smm/Mub87V0+dKHFxY92eGlH8uzyhNHtN9i++x4ysixu6NlgXU1m/kQ5aw68M2AnuGAB56docZ9WY4mJbHFQzJQfRjrC2kw9oaUilIo0M7SaCdZVuOk2xoyZAuNqyhObTdoqIS+n7A1ybNSgtnSCU6uLHFx7jac+8ddQ4vtQ9shT6O/kzG0JttZ+icN3XqSxepqoOQ9cxVfb2NIy6RW0ZIA0JxHVPN3wh9i+ZX7+ebw1FGUP6xOcCFGqQDHEqSaIAGsFHosQEMkAhMe58jG97i/r+LGag5v3BjRaOc31NlcOmwyv/JAbuzlnI0e9E1IZze6RZ0tookCx43b4o//uv6Bf0xSrmqc/0+ZEy7H4s5rta4b9W47s2JHEko1PhuxeLbllM/pYRGqpl6AtnPwkbH5E8EIJC06QdBT7VvCf/5cl4XzAUSDY+HCMKiXZgSV3mrxyvHBecPJUg3PPrLG1tcVip4vmgNxnZMPrnD8FrUZMI0mIggjmNVI4PF20qWFTx9CNycsSW0UonaK1IAwVzgvSEo73p/hIE4VglKA0ntJDIARJq4aIDLVOjBaabGLo9QtqWlGMUqIkZP+u42DnGKVDklpEN66zdmKR6VEfk6bYEKQQjKYD2vNNmt2A1tICwzzFeE+33aJdS9i/cReXTnDOM/U5ZTDGLi/w3Poch71D3r3+YDalUiHNxSbDccn+Xo/hYITMSkRh0d6jA8Xtm0dsnFuiZ2YR42VRYIUhCTXZtGAyKWi0OzOMVqzpNDts9w5oBjXGvRRpKnxVIQWITotKRLS0YFpZKiuxSESkkIEjqrUpspzxJGNm4HBUxuKVIg4MPlSYImCae9LekE4U0D1xitxaXDElSQrq9QSv5vj+D19nde0UTkt0qAgjCHVFLMfIJGBxWSG0RQUxOknwOqK2bEhTB4HBlzn5pMAhWNxsgZkS10OElggkwUpAvV2nMR8jpEBknjTdx6saoUxohZ6jCPZ+4Fi+oJi/GJGKDsMfdhEcE6pljFYMK0+7DloZjsd95usdbGBodyqaOiQJY1RQJ6tXZDl85dobhLdvcGLlSc6c/ijuQsK//ParbNSepUqPiJqSubYiEYriuOL5zZhMSm4dKU4taJ5eDsjPbHAtfgpp53jvpat0apa7omIy2GEjCLhnetx/8zbnOlB6x1TkxI2K4TDnQZ5DljPwntd7nuCORwoIHUz8EV3l+GwIpyNJ2lT8zUsRf3o/4Ov3C7Yrydmgz1atjYnW+GfTuzwRWroLES+KI26pkuN6DTfp88JzLf69v/m3SP52yt7ed3n562/w1f9pwIt3Cqa/b3jut1oszj9g8GBKPRJsRiHrn7iAzQaMepak4Ui0AyupJIRoQtlge1hRKENRxtx40GIxytm4fAZZjBBiSiAc0mZk6ZTD2inmtEI4mAx3efDgGvu7fX7+uXXWFkvs7SNefFCi1jv81CfOEkaX+MN//i2ePrNGrfPTyPgl7t/5U179+oTLl2OK9uf5ziuCk/GUubltZHoT70eYqWe4a5gIOJp6Bj3HYmlptEI+9zc+TrNzgTw3jLIBlbV0Wp4g28YT4GREv+hjqgOaEpqdFQIVoaTEI7DW4TEo5bFpH+RDXbyYGf69MOiaJAgTxkf75HmFrCuiKMLb92lFaZbz0p98k1MXnuT8R3+KMCt5491tTi4tkab7jMKKpCbo2jpFFHJz8irTf/QOO8rTONVl6ewcm42SX/6ra+xcnzA6HiP2J3Q3ayxcbnC0O+bVG2NGomB+nBFlljiGlWc1CycDzlaGxGtUM+HmvYrX35ygWy0Gieb8U4uUx5Z8KChkjCXlo+ciVj+7xNqpSywtXKQehUgxwvhjTFHRndfEwQFaSYRIECQI0cb7FsIlSN1CquAvdAN93Bg8evDv36w/2Bg8et6fbR4eP1OAtZaiKH+k2XCAfPgSKQRKCkxRPTQYP5T8PPYV+Jl23r3vMZj5U+TjDcMjs/LsbeWMcMRD7KmfFf7yz1b6j/wJzEhGj4LF8LM1hH/sYv7JPTwOITRBENButVnfXOfs+TMzIlNp6R3fZcMvE+sIrTyF9EweQHNF0DgRkNkaVa9AiJRAN3FakZqCVjKTiJSlIIxCnPQkDUNEiFYBqIBUVRz1B7y+M0Yd3GU+TDhRX0Daipu7I54YSFw1QSpDoxaTZwV5f8j51WVKqdibSDY7kqgdM+nOs59sIUyT7fe2aUYxV7ND9DSjaS2H2ZAHb73HuUXNyOaYMEXqKcN+xnu9Q4TdY8d5IlGh8ASzTwt9Z9kIDZ+f00w6NRqrTT71kSb3Frp8/+V9HowTLnUM9cVTjNUCB6M7bDQK4o0O36nuctxeZhgbQj/giScW+PQn/jqf/8iIXv8bvPEv3+bWq4e8/HaPSTrh0i+fIgrvovWUbj2gMT9H8+TT+OKYfOqJmxkSjxcRTkgkCYoukyxFhp5pFnE0DmkFls5SDV/lIAqUsEhXUXlHGrSpSYHwkE336B/fx5UZFzY3aDZK7MEur/ZKNrY2WFk8TVW2uHXtXZqNJaQ+h+AH7O72mQ6mzC+vYcLPcPd+yEL3kEDfRJg9vDvGlpZ8lFMGdcZpTHbvderNNs3OFovntpCqS1Xl5JVDSkEYlEg3xXsFUjAtpigcodLoIAGCmS1Z/Fil+/+t48d6hyrdJduT2Kln0dUYF9u0JnB/soczUxYTxeWLq1x5r49nTCOG2/0cP/WEueDF3hGnz8Lqz7d48mc15g8loz3DYh26NcOhd0zulrRDR30F1hbhwockK02B9Z6VBcm1A3j3uufermN/QZO0A2pNwWjb0Q0cW3OCE6cUJ1frLDQlS6uLxLHE2AekB/cwNiMUlvm1VRq1gDiICPUSQXwWZJvS7GGM4Sgfc2Onz3u3j9neTZkUjlonJowlxdSQjgx57nChRicBZeVmWnutiBshtVqIKQzaQ6QlSgnCuYR6q8b4cDLLH7AGZXMCHLYoGU0L2qfqeByFmK2ERVkSBQJhBWUeETcijPIzfJUx5JMMN5lyvHeMikJ0GACe0hlGkym727uYyZRIKUqvMf5hOqRQuHxCFMQkcYCKJM55KiRxskyYJLRUSDFMsUWFLHMKU1KmKeXEkwclMowIYo3TjlOXt5ju9cjLCpeDMTOKRVpUEEkm5iGNSCicEHjjZpHjgWQ8nQXOZWWFQyKFwBQFSgcEQUQpFJWpkHmKiVrEypCVFY1WExVE5B6EKzh1egu8ZFoWFKVCBwLlNINMYAY9GvUWgYxwLsB5Rb0TEYQBUZKQT3PSokTGilYzBC0wPsTHgjjWBIEkiELieoKQAlN63vjSNuFwkxNPLTK/vkCMYCFw7O0Y2lsS1ZC0VussDZdxXmEnMbuDjPZih9D0ETYjXk8Y7oxxcZfWyjxhWhBGEfF8Qh4IBofXWV96igdXb2Pv32RNhTSXT7HSWkAsbqCqlFB6vHBMbclUO+xBxakLiuPXLEkKDSGZa9Wplp9m4N/ieGcesTAhcgMa4oj+2OJEwho5WE+ezshMl7qKYEtzZTdivDPhYFzRLwzDalY8qIfm18QKXrOCq4UjSh1vpY5f7AbEJ2u8spdzVFjG+YREHrCSJBRxxY2FkNcODHf2+8wvV/z2b2xysR2y871XePZnf53u5fMszv+QC2e/wfe/8i4HV0uSWyUrlwOiT26RJx3e+VdXkaJL7+42dDSh1FTTaia9aAjSPKBMoUaHUi6TuxZJkNGtrTEoHcG0oFOPiGsxufNs7x2wsJ7QCKFMJ1x57xb3b9zg+S3H1pYnigRv3itYOhGw8uQF5hc+TO/wPW6+eZ9f+JV/myDZp6zuUaUT1NDiY0ExNdT7N6mfLYm7BiFSfGZJC8/NbXj7jmdYSOY3Iy5dSBA6or6wxmHvLqOJwrmEJOngk0Vsdgvb2GA8HYH31JSkFnVIwi5SRgB4W82IRNYgMMhIUBUW84hnLz3GlXjpqGyJV45SVuTOzAYb7v3iriwL9nd32DqxTs3M88dff5H1xWXCtQajSY/DXp/EKM63uuD36bTgnaM+SdNT3D6gfxSyfEJz+fIC9fYcV752j5qGxbqmEaUMyJDKsd52dKRheSFgaTmkWZ9Nx5v1Btd7nvs3c/b7nmG7SVhr0kwU/Xs58zXJ2pKiczKkWW/QjDXd+Q3AIc0NysrgfYaSAc3OR9FqgpIhSrURsolH4fwE5yCMn0CINhDg/Mxc/H82jftzZULvf/Nhsfx/5bWPJvMOa8wsa0DOKnL3sGi35pHkxz2WCT1+dCCEnW0SEA+DzHi/gOcDNkYpHjcVj5qSRwSU2QbAP/YuSKkeok0fSY5m/oRHSNMPxqr9ZLcGs0NKSRAE/MZv/iZf/OJvoZTClJZrX9vhyvYNLoUfIqwFBEIQCc9o7KgvaVQiqHeT2TTbF1AGDMYFjW4DmQ0JQ4gCRTmtcGFMkASQGVSkEFrDyJMd95CdLQ7SW9x/81V2hlN2BiOk1Hz+0y8gipKpyVCyA4FGJgmDUUGtUaKKkMhCLZRE9Tp5d4mhOaQ6rhG2MmKGeDskKzx4xYqssK6iygVdJdg8EXB2M2DrIGF6p8duL+dwVDIuzezvwJUIU1JFipergPC4oraXsTIX89R6nY++MMeVt3rsTqf09B41UdJuNDCNjN2lmFffnTA43ObcxTk++ZGTLNcjBjevsPnkZ6m35mj86kXOPfEGu1evkT6YEu+OaW3EbH34Q/j4OmbUA1qk/TtQb+JsCabCS4HTGmcTbOWJxQKZ7+CFJlKOJIhIDQSloZ5ECB1QFIYyN9QamlBBVeTcunUVVe2xthDQ7oBSgu39MeubcywuXCIKu0yG9zi4e5/zX/h1hDjAmj3I+ojC47XGGU0wfYdg3aHCCbgR3hZUlaHXt9zfm2ClYm6pTqeToEJHkHSYTHbIS4kUMVHUBKFxbogPupRlifQWrTRKRqgPbApmKN7/DxiSG2GGKY442J0QhjFMjxgOPFU2oihzZKFpA/d9wc99LOTSCwF9lSOlwVWe6/dL3nvT8SD0nHguotYSDHc9SQ2evKj43ldKdArPPA9nluHkCmw+KXA5THYFO1bwRgVXUse4DNDnlwiPjsinnosLsLkoWZ0XnOgK1uYkQRQwtQWDqkJTkEQWGcZEskt77jSB7iCcJB1W3L12n+vpEXvTY0TkOT48Zm/3mKOjKVXhqFJD3IzxwpMNDJPMYw1IBaL0RLUAzMzwF2iJrCyiMIgoxBZgpUUIj7OCylgq63AOfJojtUU5iXGa7LhPicVYT+UsIq/wocSKAGtnuFHpZ/In7y229KRZjrUSrWKcFFhnwHsCHId7PbT1BEEDKQOKymKrnFoSoEVIQysCJVFihsFTKqRydTAltTDBqIogjIiaDRgfQVlQpB4vJ0RJRa0eUqtFCB3j05CGbGAyw2QwJZ3mSKWwSCoh0RqUDPFO4bUmCmeaWSX149W0sdVDkxwI5yitweuIKIqIggjrHAJDrRGS1JtUhaFIU+IopLm8THeakg0AACAASURBVDrOMEWJswbnDIV1ZEZA7phfSghCSWorbAGlSUhaMUlDko9KTJYT1SOimkaFCqk00guiSKGlJAjUbG1vPdXQkN7fY2P5BCdPr9HsJoSRoN0UvHdUYkRAlAiCJCJI5oi7mv67febWGySJRhYeZ2NcTeIXY5r1OjXVIIxKolgR1zUtFTDJexxc32d18xTNsqCY9jHbDl3VeGN3xFJoOdkwYEosis5CyPDAcTwWtNcU9ZZEGIiVprm2iRjuUg4Nh1XFQlVRUznbwxSnBd5V9FKBdwYlDD3j0YHk/EKX7lJIv6joDQ2DY8PxOGfXGj4We07OKVwp2BtL7kwEVweGBMvFRsC5RHHXe3p2JnUpK824IdhebLN/OKDSjtUTLT798Us0B3d59bXbfNN/jyde+AQntz5Nt9shDr7CG19+G1VokqhD4/QW43LM9W/f4N5dyVxjg9DfoSoLcBIjBLpQ+KKOH2niegdRKPLxFKk1U7EP0xUILZUoyUpDVlQUdOjUA5T03Lx5ld6tm7SqnK2tRWrdDtPte7w9NTx14tOcOvkpVNhiZP4UmXm6SxeR+h7ltE+eGqpSIBpt0uu3WFz0JM0MdIavHGUK71yx7PfA5YK1lZATJ2MWlhJyWjgP4/GIfOqIoxqRqLDjETJsgBAYs0c9WqRZWyCOF1Aqnn1mbIqzZoYSFrMpaGVznDNIQEoPwmG8wVj3PvjCWJyxWCN4mDEMgPeWaTrl7p1bVOmYctrDNhKysSFPU0JnQTh6aswzzzc58USNhfKIRlyS5paD3oT7NwzCW5Y353lXCgSWRizo1BR/ei8lmTo+9mzAck2yuKhpdgK88ZRjz7FTXLeWvcJRBl3U8jJBekRRGE7PhSzNSeYailaiaSQaqWJKNyV3UxJmKFQhE7TqEMULQAdJQjFNGU77jIxmYX6dRlwHFtjZ3yWOEhbmlh8Wyo9K3b/YzffPMyD/OMeMUjLDRkv/gYRi//5k3nsemxH9QzrVTG8kH/sJ3AfikX9E8vSBRNX3zcV/5rkPyU0f9F+8b2QWj5sCKeVjCdL/HzoDJdVj/8iJExtsnNigd3TE7/3el7n50gGHxREyEYSxRmuBDTyHA4uTGqUEMggJkhpCa4rDnNp8RBwpkDXQAqtnsI4w0IQyQAYVUgpk6NGxoCgL+g9G9LKCdhjRDCRtJSmF4vf+8Ku4fMozzz5HGJxjMJrwYHuXsqiQSZf5RUEcCoyYAUDaCx1UmZJPLBMBbQ25zRiPMoxPcFXO0VAjjSGXFTYGWdecP7FAslTjcJRydFQwGuQMpxnjKuViWLKxmFCliqOhZjL13DuoqMi4sJSwtVRj93hCYVNkMcOSZh3JwcI8u9mQeithfWORc2c20Okh23fu8ZZ/kzPnn2Vx82M0Ol2a3Ro7P3gbioAw7LC0vsCol3KQThkONLVoE+UnOKdneR0+RIgQb5r4XBPEXSapw5UVSEXhJ1A1EHp27cN4KguWiDhQSDx7e/ewg33abWh3O+ioTjXa5m5hubz4URqNi1R2RGknyErQ6pwEHmDNFFOVOBuDrFEd3aHREshgBCLDO0uRWQ72CyZTkNYzvxzTma+RxAlORjjvKIoptnIEkUM4i6s0UkU4PM4NiIMuWicoFc8aAg94A8R/6RCAH6s5SAIPomCcj+jYEZiC3emEtjRUOHbHKZMsRZ/S/MxfW+XSZxxBbYSzGZOh5epVx/+wB999qeDzJwNUDDIR+EBw6qLm4K5DH8LSr0meeQZWQkE68ow1qIbgWgp3ChgHNXSnTUyDVr5P4OAzz4ecWpXUQklNSWxuGFaSw7SHr8NyR7PSaZM0z+LdMpNsnp39kPGg5PDeLlffep3v9uC+0QT1gPJggp/mhBLqTY2pPKuNgCJzpCkUFUgkyitsKajP1QmdwBuLtBabVnjj8KEgG1d4MdORmmLG2TbGgtbk0wohLJGSIDXjvQNsGNNI4hmFghKngFjj85KWcEhj0DjMozWuE+ggQmlNJSxOgFISFSjyvMJbQU15wkghpccbRxSqmTmqynGVAa3QYUQUxRztjsjLgrgR4CuHFIIoUDNMaV5gSwFlAcqgY0NTa7LC02xExPUu+SgDA8IJ4lCRM7twJloiCPGo2ZjLWfJqRipSSqPVrHhIqxKlYpT1eGeIAk891tSSmDxN8d7SrtXw4YwEk6UTJAkTa3AqwM1schhjGOcleE1ETNhqo0ONzEqM8YyGOXGsSCKHkBAqUN5hjSfQCh1rQCLVTMstlUICrnRUg4LV01Brr7NwboEokQSJJOnAeK/AuAQVKsI4REcNdBwSNlM6m3V84XAuwlpLVY4JT3Rohw1CH5DEEXFdEIYCmQT4wHP9W9/j/K//NO2aJD3YJzu4hVVz3N7dJ1pqzlCxtkJqz0I3wmfwzh2LPq2ZBoIg99SFZGmpQ6SfIN29yjB1BEqCdeTTEhEPGBU5eRlSF4aJt+yNwfXguS3N5mbMchIhc4kZekbjjJcPRvxKR3B2SaKE4nYa8OpAsbtf8J1RhhsWnIglc06Q5x6H5fYk42Kk8Z0GLhizmGievbTIifXTbO+8zTERd3/4LtSXCeo/RWvhs1z8nKEYjzh+o08lu3Tqp1icK5CNP+HOTsz8x89QHe1QInBaYYRCpCGiiFG+hR9pTGkwWUFlHX3TY64E6hZDxSRzTKaCuLlAEEJe5Lz51mvE4z3OLzdpznWQ9dO8/dY75HPzzK39LO32hzkav8eN/Qnnzi8ShxHe9ZkOMqYjgU4USjVR4xHts3OoYIrJJ9jUcbDt+eEbnk5TcHJdsnQypLsQIWSNUpwg7fexVYc4MDTikkin+DLHNtcBQy2saDQa1GpLaDWjWzg3MxxbY3mUbWWdocgniIdbHkkB0mKFJ80zZBAiqfC6BAVeShDvJyQLPGVVcvP2bQ72d1nutjHOMDUpXli6iUTHnuik5+lfOMfy+YckJDdmOim4e7vk298cc+XNHp/f7BJ1FC5wyFBRq8XcvpFSO4Jf/ULEqbYkEIKytJQCZBSyWwgOncQkS4RqgdgmNOw22sNHLjdIohk8QiJwpqJwikmxg6gJwnqbRryA0hvglyiNIE0TslRyvL/L9uE9jkzAs0+eoBEJ0sk17uxc5+TaKRbmVt4n8fy/dHywIH9MEHqEIn30qB4V7v7x15xwHzzLw0fxo/9/1Gw8bAwemY5n2wb/I+d89LXZ6R6dW4KYyZt+tDD5ye8O5MO0aCEl9+7d5ZVXvsfR4RH/7T/8r6mmJSc3TiGD2dBEaYEKPelRiRMhgRIorVA6Ai2RYUlnIcIVDsImzs0a5aATEcqQQGpUrBHaoRSEscAHnluvvUtQV7QXF5jrtmk1+1x7cMQ//ae/S5WO8c5RViXOQzYZkzfa4BdoJoISEA5aoWJlvk6UrjDZ2yWVmsgKyrKinEzwMmOUTsiyOh2ZcewcWV8gFZze1LRXG5w/UedCFmDGhv5oxPbwmI91YHFR403IneOY7QPH4eGEK/0edTFgfjGhUQlS7zBVxs5RymatBu02xjlOn2xy7vQy9foco8EtxkTs3r1Bq3uCheUNguZzLF2MZnXmzQFOdEjiVZJ6DxcdMhjH1OfOYYfvYrSeyWp8gvIJmBqSFj71uKrCGUuFxbuUugFf81gqqtJhnCKMaigFlTXcvvMOq4Gn22oRJvN42WH77hVMd5lG8+PooMEgGzDMK5ZXlmeGfzcgTy3GKWQQIgghPyZemgN/iDMpVW4Z9S37O4ZaHLC4mNBeTgjDCEcDK+aoshHetQiVJdAVEof3IU61ETgCVRGECUrVZ8hWANz/Y5eoH6s5GA5LFmsR6/MSZz21+Zj6YEBpDJk3ZM5QzAX81t89xUe+cBbBDbzPcbZCtz1PPan4d/+TiCt/b8rbb+QEkWP+lMAFsGMltgBnoT4v6GwKykN45TuOxfOCjXOa4wcKWwmUWYXpCtH3vk14QfO5zwQ8dVnSCCWiFGgn2CscV0c5F89rNudCGmEXIS5Sul9gMi54+fsv8dU/eJ2r13ocDismSmCdJFjpYg8OcGmFkp6kqcBGVFZwtD3FGEGZOpSd6T51GFKFAaoRUW+EuDynGEypxtWMEDGtKCuDVAJnAetpdyJ8EaBqMeWooCg9lYE4EoyzinrSwEuFcyWTcUVWFNQXoN9PidohtixnpjEv8E7QTFqkkx7CTBFaU481SRRgvSRoNJgMRoiiIKhFhJHEVZJKKJrdNqOdMeUkhyAh1HXCQLL97lskJ5cRlUZMc0wxJS1HTPoZxSAl0g3mOjVqzYAg9FR2ylytjvMNKgGjrMQ6SafeAlfN1t0ypFGvYypHmZe4qiKzMKkEwiuaOiTQIZVzlG5EiGBclrTbMZHKUVUfS05TCPLM4fSYyWjMNLcU1lEOK+TBAe2oTSgcqYMiLwlNRRA3UUEbGzaoL8QkeUExKplmhrQ/wZeapNtkrlmjTA3p2CC7/iHibGbgU4FEB7Mk0Co3+Krk8m88gZIaFSiCWM5M1Q3JYG/CeL9OZ0nRXlD4zZh7dyQrHz/P+N5N4rCFUwHWG1pW4qIGNV1HNQJkBLouiBpgzZR2O+HNG2/w4kstLj+zyGI7pQj2aMeSC6carCQxjVgglcCLWQjM4omQJ1PHV28aiAQnFwWrDei2Awq9wfDmq8w1DVnuyHoVNWXw44yJq6hJiVSCSgiEVGx4eOnGHt+8mnF5IeHceoOLWw0+/XyX+rdyevUao/0R6+c1Gx+OOVvXDN5o8PvXIt698y67oiIIIPACvOE7ecXlnuW8Lnkvtqw2BR9bc1gR891vbfPa07/Ab557noM7O3zt69/m6V/8FM/P/ya1jw/51rd+j61Rjba7iKt3SDa+hWpt0Kj2GachpQ7xGIQPcFWCywVibpPBmwdk9S3kwknye4csJReR2nE0mrIczm4uoyri7KKimpYc9R9w5/57XO7C+hNrhC7EiIv8k3/9L/i7//HnOb2+CRgOj4/5+jen/P3feQohrlFOrrBzo8ekp7h0SWF2xpz+1M9QjF6iTI8gyznes3z/FYOxsLQqWdnQBAGgQky0Suafxt55mWR19vkSVFgfEc6doeAe0iqW5j5OFC4ihce7DITEljlVWVKV+cOC0uCKdHZB9QVVVWB8jqdEKEdZDJCihsmOcMpjrMcag7Wjx9d7Zz14S+U9kzyn7FnK7V2MWWKpHtAXhvVLy3z6b3yEE+e3gOvgE7zIaTQEp87XUHMtrvzve9y4fczS+YAi87hQkQlJNjKY0pM0FEk74Hi3oNcvaM7XaHdjBiZClSDFh9G9Hsn2t0lOtXn+uSYLiwpnQDmJc5JpZTgqp6wtR7STGoE6iecy1p6hyB27eze4cX2fW3f22B4NmBhDo96l1rzN1Xfe4sata5zd3GKhvTzrrAT8RW69Pw7l6N98PA4LeFzse+Ef6vtn+TDvF+Ae7+z77/M4A088biZ+9P0fCYrepx69bzy2hEHAo3yEx+d/tKn4QK6B9w91+QjEQ/PyB/GoP+n9wSMPhxSCr371D/jKV36fyWSCeUghvLt/m7SYzLDAGlQA44OUYlwjmFfU2wrhBelU0tiapxr0CcM6VoD2cmYcVwFahohIzoZS0SyUU2qI65IrP7zNhz71PHeOtqmplMPeHt/+k5fxQhFIwYsv/jGv/eD7fPIzP8Pnv/DLVJXFO8ndQ0c/9izWBU0l6DQ0mWwyHN8kjHIOjsfocUZNVDDuMy7H1FUfryWVCIiFpm4s33v3AeKtMc+fWWJ9o8vqZoclUaN7M2ecNEh3dpm73GLzcsxWFTB+MM87d89w851/zbE0yCaEleU4m3LlaMRJSjaDklbdcHa+4kQLysJx970dbp76eT63fIZbd+4wMrC2sUE3eZ5gy3PnlX/OyTIhYhPRMATzGTJeJDID0rKOk8Vs00Udb+t4A6K2yfTmffzSGZyoYTNLLegipGecF3SDiNQFODRxIDCVYZwN2T28yamzi/wf1L13kKVrXt/3ecIbT+rTcXry3Dvhxr1772Z2YQPLErxbZBCyXSYIJJBLUOU/7CpctkuFbEtllapkqeySbKtAiJJZBAhhL3gvu1uwsPnmHCb1TE/n0ye96Un+4+3puSvh8tqAgOePqemec073vOe8z/ML39/n21mMkCGlMCt86ZmK7//RT5CnPUyo2dqdcn3L8tH3XSL4O7jmKqM7DXGck/UiKCsWLjyGrX4PHbbxzZzRbsHOVkUIgt5CQm+p296JMsfJUzTuFG70OvFCpzWN8xWoITLqYzlAhohOfgEpNAJ3dJ8J8B6pB/9e0MHfUHKwF1LOpF3yvGJj44BIzPnEYznP3ppz86DdYB54YsDf+q4nQDxPCNsQCji64fJOxAP3ZXz0pyxP/s8Vbu5ZuSBZeliy3QhEDKGCM7lmIVdcjx0veMe7vwJyGEhHEu0TxNYdxLWr9N/bJR1avvU9ApEoRCMRWrCP5PmB5T0XM04mEYoM17yd7Z0L/Jvf+rv88r/aopoZTnU0DoFY0uTnuqSP38fsyzuUr9UE4xF5e6PbyhMnMbKi1d8jiDOFijVlaUkUzEceM2tI40CsJSGRRIlksl8xmxjCER86UoIslUCEnRt0HBOlCqUjkjhGNB4qS1ga0um2xhtpHBFkwFWGw4MZOkmQKkYpgdaBwjjW1/rMqylpv4dHUZQNhS0xQtLM5/R6aVtNbzzWBnTk6HQjxiahGY8pqgrGju6pLlsvvMj6wjqmuI10rUGcUYoqaOh2iYVm67Cir2NyFVPtTUmzkljk7G5uE4xGqwjjPNM6cHJxlUgG8kThtWXuG8alR+uEnvJMpjWhEQRrEd4ziBRr66e5M23oxoLEVTSzKePZFoO0g8+HTDOPqWZ0oohBHFFODFmnQ42nEobZfE6epZxYXmGh06GiA7EmSgUqidsNcWbRwxwr2ooCOGTkSbUkGMfUOIZDiY7iY0qIDwEhA+lSBolCa9V2FiKFTATREC5heObXDxEMuO/tCQunNUlPsrMXWDv3IKYyUBpkCIjeEipV2KbtRCVdTTwQoCxu7ti3I2SSsXHzOpXfo78QYQvoJTWr12/QPXOSNMuwMsdEAjev6Q5jeqcU37Mm2NnyXL3u+L0tw4X7c3YHgubmCSbXX0JXIxZDyox9FCUTI1nuCyJrSUwg14L9SPAdmWCjjLi5V3Fjp+ILL44YLqX82KUT/Pas4Jktw/SVKWsy8L6Tku/+UMyH7/N8+PSAJ1+bMCscBMWdWbuR/WLp+fhBl7OnZjx2RnH/ao/5uOGPbhjSCzEsL+BvHeC3rxJufpZo5a9z8fJ/QdL7CnvjNbrjAZ31M3z/j/4sG09+iv3edbpnTzK5ETD7E7qLOZ1GYvPvpHz5ObLuZRLbZ3Z9m11yHuj0uGav8gSHmOYsc5kTZIVSnqQT8S+e/DRLcsTpHOLueTjxQT77j/4+T3znJVYufAyVnmJrtsHO5DrfcuFtrJz/acr5v+TOC9scvjlDqBR/dpV0HmHETeSswNaWrVuOV151bOzB931MsW8EzT7o1VVE/zLz5iy7WxusXvwWBuEmjdnCiASvExJzyNpyDy0VOlLtECka0ARnsM7hvCV4Q11M8LYiTWOyTGObQN1MMdUc0xiCNeSJo8CS5Zr53GGrGqylE9+L7qTWxFqiBCgB3jUo6Xn91ja9R08hMsXi+hLvu3QFeAO4TmD/SLaSkCU91lcz3vn+KV/4nW2GXc/JKxmd9YRCKGQWaMaB5XiI0po9NeF2NeG+mxUh7hLNFabsYq99lkxC/ugFkm7FpbMKJxK0Byc0MxkYdSxnVxboyQjcAOcfZ3e34OWXf4UvP73P/u42Fxd7HIgUO4i4cvkhPvr4f4Cq4Jd/8Z+idcJ3fui7eeJt72g19n+e2J2jH90WgNr3Q6m3+AvQGjm1DxV4dxTkC/5Y7vm/bYJ21yzvriv0PQO1cC8JOBZVtV2EwB/HVL9nxHR8uf6S44qkkjjvUFpjncM0zbGrNrRV5jo0OOGII41OIC/HvP4HCQ9+uEvWU3QWJUlHUBSB7tIqrnFExoMSiLgt5DgHeNC5QsWthM85z8QVJN0Ov/q//yKXHznHcDBgb6diVhq8K9CRRhWaNO/w3LPPsHHzJtPplG//xA/wvvd/C00l2Nj1lDZwYiVmoiLs9pCDW1dZtAoZJJUbI8WMSe1YW5HI6ZSBkNhY0SSCb+1GbM1SXnxjjzdf36OzkLC+3ufxk2d5dj7h6Wtzyi9tc3koeOyBhPsfynjwvOfBUxf5ynOvEWUpVRUz37WUaD55p+J7xj3e+44eV+5boJtlHM4tr23VJOua0O8QagmHmzAEvfw2Fhc/isx/n+l8Ad+PWT39AP3egPnNVyiSm0SrjzC7/TRSK+IoJ4QOXn8Qu/Ua6fBRyjnMbMVc56zGMXt+n4uUVLaPDQEpPUIFhBZ8/voLnO96ujqgOw9QVym3n/0cl97/GGnvEYJIGBebpAoeWHsbef8J6vqrTG7fwY7n6OEa9FZRIcazjWgKnKvZ367Z2WmwLnDlck5pBWZiSIaX8PoSVdOlqOZ0lt6OZAfrdnEstN0lHGmSooQ8RgSHII/vfxUt/D99hP/U1zeUHJTzA4oK0tjRXY5YkBHDRcmS8JQ5XHgk56/85HmgBmqsc3gnCaEl1NReoELDj78j4bUTDa+86Nnf9Jze8XzzguWfZOAcpAbu1IKnDyVvvgzT1wPf+wPwTBQxeqNi83ZDUgUuDhz/4ScU/cWonUsQgS1n2Wws71hTnIkcoUopJymf/8wX+K3/41/zhomxOqKJBbdyzfLjPd73WIdzi5ovf3WPL//BNZzx6FgSaVBSgFSYINifeoIXdBcSsq5u3TSloTqYI/OY+QxKKVoaRhDMqpb9rGNJS5yTuCAZj6DbgcpYlIfOIG4dmWcVrvEkaU5XWDpLXaI4wjUeMy0pgqXvGvysIU4j4ixGRQn9YcrSoMeNjYSmaMBVqOCJVYQIcP78BeI0IkkirAtYImwxZX71FXypKJzBS0McHKGo+c4f+HZGdUIeLzAaTTiczjDOk66uceZkl8mdXfpojINy2uCawPbOLmcvnaVsjkykdEKSdVhYWkUYz7woKBuLq2usaZAioKWkNp6lLKIxFbUHpWNk0qHB0c/bA21eVlhrUVkX0clYW+7RBE1RaUIQeOWxsSFM7lCkA+bzGdZW1LVjPElJe12sVJSjA6bxAniPsw6VZYRIk8Vt9Szq5DjrKOcVumkYrvTRsUYJ2dIqgOADkkA0iJG6pcNI3XYVEG2l78G/cYI7v7FFeRhhS42MJdmq4vQARtcD+aKm6qWUxpNrj7KBbFGjepokF0Q64BuJKzzN5JBuP+HCfRfo9XKCCNiOYLk/YFYrZjYlFI6eLugqQawVaTDMJ56Z04hUsrQa8LXn3FBxekGyfeIC7k7OQVFQmRFLdcONIvDOVXh+p0ZHsJRCKgI7U8FeN+HkucDqocMZSSU0h1bxK9d2+MkHc/76h76NzcM3eGnjBq/eLvmnn6v5thMgluY88fYVDnYN27tzmtzSHMDcC37zcxv8tZ96G4+/DaZyF1de5Z3f+xHGX3uR1eq9DC+tcztsc+ePXmHvCYfD8fAP/iT1pqXZCiwsNXxJDjmMznJxCBMfUbo50h6ibAKnvgm5v4d1S4ytZ84YHRT5/CR785K4mHB4oocPGc1c4KvAQpryqReeonrmBg/d1+H0hRM4k7P7R59hd/UxPvzx7yTpX8Yjub65z1M3HO/91h/m+Zd/k/58gz0L3Xeso1zg9nXDw+9/B+Xseez1gldvGLZuOVTt+KZHBPs3PP0TEcmFR9mb3sf2rR7ztODcWsWQ10nEHVzah7iDjD0ymRHJiLzzONAaBBIUwdfgSgiOZr6POUIIS+Uw1ZjG1jQOpo3DhxgnPLWbMp3PCVEgzzVJoglSYa1lZszxfl8UJY2SZKkmTdpgKdKSIODVm3tcemiVxeUuYIC6JSH5BFA4FA5Pqko+8fga154+4NZGSbJdce50ydllTX8gME1A1LBlIm4cSq5ddRQjww8/Cs8WKQfzHUaThhOdiPsGlieuZERxijCOChiZAictpzoxA1XjbU4zz3j2i7/O7VHGWC5TIajjjJt5hxOPLvGB81e4uPQIoRT843/yj9BC8z/+nX/IibV1tPqzp3/8v623zgsc5wPHHgRtVRvVUqnuBu93B4q9D0fPOY7Wj19XCI6xpncbI0rKlnJ1d55A3kOh3sWfCgRSveX7d19PCsKRO/LxyMJf7twAKSVKKYpijpLq67Cud6VUeSclzWMApvWUn/3kf0JVBH7pwj/j8gOXEFqiu5J+CuUokPYkpWnfJy0C+ECUgMo1USQQBFwDrnYUBwd84au/zcLCgDdefJX5fI6xhk6nw/7+HmVV4ZxHaY13jqqc89DDj/DGq6/y3ve9n6Alg25gwUM/F0QusL24RH3dsVXt0i130dMJ+7Oax8+kPPXKHovLEQupRRjP/ixivLDI2iXP4laFJ6aUOfPC89St23zzxT4f/on/iL29z3Nz6xa39ubsfu2QK2sgFhQPv+cJxrf2Gc8LRsIyv+XZdzGf/K03+emf+wjDwR512EPEa1x8zwcp3nyF/OGHOXPfCtPt15hubtJbfoQgJBc++FeZjzX9BUeda7ZFF6NXWU4llYuw4QViaxDpEqQPIcop3i1ReIMTc2IfEdUJ86pBm4r5MMMFRVUbOnHbDXttexN/Y5uz51fIFs5hJiWzyZhq+CiXHn4I1ACCZ2N3TB0GnDy1xs7eCyT1PoVK6F15mHpaUpQRwxP3YZs3cPtjNvdKyp0JWe7or0SUBxXJYAG98lHG09PMQoSIavrdiozbKLYJ0SqxShDKIbVByw5KrQEVgfzoI6iQMv1jP7t/Vusb2hHXl1IWFxIm45pZqLl0psukaigJLN6fcvaxzaI6DQAAIABJREFUAYtLnVbbGjyBFOPAOE/pYFx6VONQQvKO9ypGu579m57yZU/uPVq0um976JltGKaveqpnIUmht5SgiwSzX+N2HCtriu/6kOL+oSCg2J1YXqmgiiSPrCScyQK2sITdiqc+N+X3n015rl6lPhyRDSQPPbxA9tCQaNnREwXNS3Ne+vUZvnEoyVEFICbrxCRRRJxopoc1nUFMnEZ4L7DW0ThBNMgQjcV6hz1yKE6ziF4H5iNB42i9DwYZaZpQ7BYENFE3wptAOW0oXIVvAnGicc6wKkA5Tz2fMy8alBM0TUDHEbawVFWrzXfBMCsMZlpw5+o2XmviLKKTJ/TT1gSodBphJQRPUzeUszkyWMrJnLy7hgmSECxBBUorGK70GRjFvGyIBhEdEmaHDa6cMR5LjKkpJlOs8SgBaSxZGmrM7JA00QzyDhJBVRtMMSa2goNpQ3AG5RyJCHRihcw7KKXB1OiqQoSA0BqjFIfjQ4aLfarDgsY0WNfgfUPW69IIzbSxNDIm78Ys5IpaWZrqEOsk/cVFvLVkiaLX6zDaP+DcxVVqJ9neGJMMOvSXegwGKUZH7Gzusn4iRUcKrWWrv807JHmMlgrh2hpZSw8JyCxqq0DyiNyhAHl0QAYYXEn55p84SX1o2d9pWDyXEHcEUSYYXgiU80CSCnq5ghBwJtBZUKhYcPdsLuaGZ794hzQ9x5mTPXpdgfcNaaI5f3aFPO9z6uQSmRD0o4hgHePRhGGeY4VCeRATg4pj4kjineAPP1fyPX+1y4fevc6nXoBRUbEYO4YdQUgUz+157htIxiZwUHkSAvcngZFt2HrNM+goeolkMbJcjGu+smP5+1+e8KPNG6w/+CjvffgMD5/8Q3aE5dYdh9u2nF6dcKYH53sZ251lfvu1V7BOMJ7vU9/cIX3beZYfOc14EvHZTz7Jz/yVAf3eHar8HMl4jb03X0GbXcp4QL/XIR0c4JRlt044F63gLryDEOWE2TbW95mVOXs3A287eYqd25tkeh0vuhRWMGlqDg9fZKXzHoLtIuU6ptZkkac/SLhVlNy4+hTpskKJM2BX2J9Inru2z+ADP8yJ/ipKjNi4fZONSY1cejdXFnNG4nE6+Q4ZKZFyRKrLyZWURL7E1iu3efXZglBa+oNAvqZYORmBzIlPfiu3DmBjVKI44PJCzaIO6KVlkuwxrDiNE4tomZFFkiTpI+UQAnivcGaGMzWRjnCmxNkGL1SrdXCO4O2RNl1RNhZTz7FNSV01NEGRhQbrujTBUTsoS8Ph4VtkRd5hgieUrXGQjmRbqUskXgmeeNd9vO999yMwEByEAda1VJvKBhpjUKF1B37bo30ObjXU1yyzfkVfR2RC0Y0DrqipZM3s6oz6dUuyHJHkA/IwpNjcQBYNJ88kPHQhYpgpPBHTsuC213SihJUkpac8zhjCfM7Vr23y6ugsm2ONr/dYHA546MGTpKdXyHoKXd3ky3/wDF/8YsmdrQP+u//y77K2euI4MfiTdA3+NILjEEIbxBNQRxr4cAQ+CiHgCYjQyo1ajbw8/rlC3JsRaGlDR5X/AMG3XglfJ/25Kxm6G+C/RSIkpURKceSJwN0xhOP/Z/D+aOj6bjvi62VVfxlXHMVtn0S0tCchBWmW4l379zzvEEUt7vall1/i53/+59kb7+Fd4Of+87/Fe97zHj76bd/Gt3zog8gIUiEwDSQZSHWEsQ20M2X67nWEp556ln/xS/+Sz3/hiyipGB+OWiqeabDWYpsaddRxCCEwm80oy5LpZIK3jtp6/tO/8WOUQSC9ZDr23LrlOHtBcflsl5tfsOimJlaW3oJE5jEv3vY8dC5na2bYn0ImPetJxbg+YPcpz8JqQh6VrCQlBMX1OzW/uqv4vrDAwtmP0Mmfojz1GnNbM5oY/M6clZM7rA4bVtbXMD1B8/zTzOeCm1tvYrYvkKyfIOl3mGzNef73v8h3fHQFpQ5JlxaY7GiaaYFwJV7FZGlG1hSUBLyPWYj6TIZnQMaE6pAgTzCebZF4wTBeZD45JNJL+JDTeMesnjH1hs7yKXxIEAwwJtBJJUkkGFcle6MN0mGE8KcgLHAwnjAqIrJzb6Mbd4AZ+6NdZmKBTidnMUup5WniaMQiKVqmdIYrCBkQ/nWKnWtsXd9HhYp8RdMZ5OTdLogVVP8jHMwUB8WEXlYx1IZEKWS2gIoexLECIkdJjZYKKROESI8+Mx4pk/Z7/LvdwT/L9Q0lB500Is8kVS1YWsmRWYSMFWv3O5bOpVy61CdCUJkJBIuQGRaFDQ68IxaGce2wpefUCc3qwGG1J7KBL1y1RJng/h6c6EvGm4Hxc55YwHveI9FZzrUvlIyuGpIGTi4pLt8/JNYzJiPL1/YcWVdzua9YiSVRXTN/0/P8i4JPPW356qZm2iiyyHDfuYzBScP5kxUH04obL03Z+ErBbNcArY9Bm9GDdx4nPQLIMkVw7UYbJRqdaOxcUBUGGofQR2YbLlDODYqWTx31U5JEoyPdGqcYh+zFaBnQsTgi7ngCgryfkvdzYumpy4raudZwRsZIpZgdNkjj8MLhlMSpGFE3bOGZHRaILIE4JVU5XsQ084qmidH99MgcqUYFS7AWleQkiSZN2uHYJgTyKKYKislkwnw8R0sFxiJNazJVTed0khwGCeWkBGvJs5RBP2PnoCIR6qgVG6hrBz4iqC5NPUYJCUGCFqRZhJIekcfUtaAqS1QIxEIgnUHQoloFhiwSBBUTvCDtJEjZznvknRwU1M6Tdjs4ZUiSDuRdvKlJI0GUKISUNM0cF8cIG/ClRswiZCRIexGlU8xrgawDkWppElJptNKttla3DHEh2/mI4znwcFQ9Ozq8fQAvAjIRLJ2OqXPRdn0qS9JTiFiQLkqiXmgJFdHR4Gho3dWlaGMs23iKuWduJI9deYz+yR46sTSuIk0Fp08tIVWErwPjYkp/2GfQTVpzotpSTKcIq+lEEqEDxilmhaF2cALon8v5QkcwCRIhUgpdE9mKSIMPgg6tsZER0ISWcLOqoXCBwnhE8Mwby4VOWzP+4qsbDArJ6YsXOXXy+8kO/i+GnT38WcmNkeVcApdPxSysS97/6Dq/+7XbWO/50gu7XHz7ZR740AMgnuPMYM7BvuSiaojSkuVljb3vNG++8Sz3P/QhXD+j2hEoUxE1cxwxNsloqlV6wwvceHOP7du3WetpNCNK1WNcTFCDE0yrDrf2RhQ7G3RiSegEDscNK4saFUXMnedwXjE9rHjn8ion+hHVwYRZI+k9/AGWTqwhxSGNCbwyGWCSlHec6uEaw2SmSRceoaMtsr6KtPvgAle/usPo9RmVCaye0SysabrDDv3eOkaf4Pao5nAq6A8MS4s9Vlcuk8Y9ZGeI0qsolkB0UUTEyqNUiifFh5Y41tQVtjF4pXGmQkYxeI/3lhBafar1gaAA3yrFnQAhPUkWE+Fa6URVEbxHS4+SXxc5HlNprPcIL7HO01jQXrb3aHA0dooUFiH6eBQutPetFA21MbjGYeaSrlQMFPjg2akb8l7ClYGmn6Xsbk6odw2dXHL/lRzkkI1b28zvFCwnghMLHZYW1lBiTFWWvDkzLPcTFpOYTAaEKbD7ntsb8AdvGm7bBmMq+mrCyrKgtxizvHDI3mjCM09v8Przu2zcsSRpj/vO30+ko+Mq+Z9s/emUzu8mKN63/gR3g/dWGtRCIo6TACGPsal3CUP3fpVwPBcgjhIBpdSR30ErH+LoPW719v9WFyAcyYmOguW7v5u8WwwhHD/+62YP/pIuqeTRdZDkeU6eZyilGB2MQAiyLMN7z+c+9zl+9ZO/ygsvPk/TNIQAV2+8QdUUbO3e4eqNN/jxH/trRCnIuN1P73Z3jvJ1oE2wfuM3foNPfep3ee7ZF9gfbRMl+si8zhOCJ+DBcjwz4r3HNA1NCJRFiTEGIRVaBvqRYD4NjAvHrAz0BOihRmJJdBcpBphQopkSxYEgFH0E9XHs4pCiYSlRzCuLQnDo21jmRE9Qh4hnn3uW3sxy4vxF0u4ayfx5VHabcDLi9mHJuV6gvwrn+33e/cRFfvPTzzMzQ7709AYrF+/n3OqAPNtjuT9nNo1ZUY6Emv7igKZuOBxvsbB4Hp9ENARSZxDeEoTE6xhr+yT5Mrevv0wo58RaI0SBERllM0N2Vjicw2h8gBEFiW7P51lhWejGIBS1D5TWUpeWC/1Fsjyi3N3DyR752kk63Q5C1DgbuFn2GHRSFlOFd47aaKL0LLEsEc0tBNvYomCyvUu1t4eT0F/qk/RSkmyFKD6FlyuMC0fdQL/v6HcWydNeS5qLukg5ANFFkrTwEwFC6BbeAkiZI2X05+JC/o35HASBl5q0m5DHGicdaFg93+f0+Q6rixl4qOoGGxRxFFOGBONrrKtpnOfQQDN1aC1ZWJLUJyXdZYkpNEsnDGkZePn5wO6hZ/QmPHBR8K4Pa8ZecfOLFfMNyzCB1VOSQSehmI554arBJpL1zHMmcsS1xx46br4S+PTTga/sd9mtA8Os5J3vWUD2A40oObh5wMb1mtefq7jxssUHUJEgzSRRJNECtAjE0ZG8KFZUlSeipRl4AtYEmsq3rcKjG8y7gKlayZBXLRJTAM60kaB14JzHNQ6dSBQCrWOUFuTdjCxWhKahaSTmaEtwwaKEwBYGbwwBh4gVKlE0Vc2srAkuoIVEBoGzUJtAPSkICnLlsbZGCkeSKAIaW1t8U5N3M6xtkZdxnLJdevb3D2mmJbHUSBfAe4KQNI0nUzFCKpAN3rdYRCESisIQCUvlapxXhBC3kjIlibVC+PaAiuKYJM/aljQeIQJSSYIX7fOsQUWaZj4nmAop2murVISKBFEcEbuAl4HgwXmJyhKsa0krQrSD4kKBk4p4Icb7msY5hJBYp6FuSJwmxSJ1W20NSJBHVCKlQcjjA1WqdlBX0LbS/VEFRxxVg7w7qvZJEAoiKdBLGle3LtKCljqiE0WcCUS4Vw2M5FFi4APOeaqZZX5okFnM+Qvn6K50kbnEiQYtHXmusS5wsLWL8IF6rUYt9ojiiFlTcWfzgLnK6GUZkfHoSqCEIekqMuMY9iTrCx32sw4mWIxOGYiKlYFgOg90AwwjgZUwrgNKBOJIYn3AW5gcURPPJoJhFJhMp0xuv85hmtHLTzEPbyfvPsUwntIQKKvAuGo4ndZ83/d+gCef+zVsgJdvjXj9jsGxSJpHvO0hSblXIMprpIOIXsczHaZMd3aZnjPESY8mXWmrQKWjjDQQsVecoH/2HHX8BgfFNVQ5wYsMFha5urHFyW6M1YvUIWDLTXyIKeuAqGqESxEiovaendGM3CpOLcToJGNawDzqMLhwmeV8SsDw+ihnjwUW+innB4LxeEKeZbx2VeBqR6eeEdfb2KqieL3BBFg+n7B0UjMc9siyZaQ+w0EVcVhMWBieo7cAvYWIuHcC1DJS9ShsjBSSSAaksARf4mSOcQZna4Kt24FUETCuaAMaHbXdtzZKJGiNcQ6cQyuJsRIpNSJJUC4QeUthHHiLCKCVJM3i4/3+rlb9LhM/hIBzgcZ4UgcbN0a8+eYOS0srKKUQIsGJGOcLvC+w3jM3AVc3xFHM8lpKL/IEHbG/C2vrHfKy4o2XKt68XiHKwH3nM05e7HMwE9x84Q52VDO4mLIwjIlUSt3scXt/hopTFqOGrghIE7Bzw2jL8ZWrCa9WK4RmxqlFzflTA/IBWA7Z2djizTcPeOGZAzZvVqRZj4986KPHleA/eWLwp7nuDfjeMyi7Sy8K+OPZ5XDvsW8J1OVbo3zavUWoI0SpbLsC/uvQqPc6DHcxKCG0TBR53FVoX0sctRq+7jnH6y/SNfz/vsIRoSlLU975znfS7/X42lNfA+4lVZ///OfZvLPJZz7ze9R13c5siJYSdGdrk9F4xJ2tTVaWV/j4xz/eFqiCOE4MEEfX3Hs+/elP82v/6td46qmnaRqD9Q3CtuehsYYQjobOETjnjrtJdxM+5xxNU5OkGUIEskjQSQWdDJwPRASiWLDUz7FFF+8rgp+SmylLS4LDkaWvBFmkaYKnrCxKWuJE0niLaRS1bM+zpUSSxzDe26TctpT9BRiewIqHiDNLFo2ZmnYGMjdTVpcXed+3vJt/8wcvY0Xg6Vdv8d7DwDmZkXU0584JmvEY4TaI9TpJR+NxNMWcpufQUYrXPXCS4AKWNm6ZmT5ZtkQtzlDPCtIoZUkkhDRne3eHtW6MlRHWzXG+wgdNbQPS2pYoJAS1d8wrQ+IVi7EmqJTSl4TOItlwkUw3BBzbZUKtcpYzTUc5miagVMTWDlhjyO0e0u3iygI/bnAIeqsD8mGXJF1G6ZN4sUZhBJWZ08lPk3YakrSL1AMQHYRIMF4de5ogPEdaBYSIAXnURfj32zG4u76h5KCwYHRMkvVQUcmsqjC1odNNieMYvKKuA94pjOhSWMncO2rjqauaw3lg1Ehk7RnPIV9TLEcw6EtO1hGnVhtuvez4pV821A0sLcPbH1S4Rc1zmzWjFywcBpYekZy5Aq4quXW74uWtwEefSFjPLWJusHPJ/hvw+dcEv3dHUakuq0sVD50wfNd3rPE7L+4xu2l57qWa7RuW6ci3+E8Jvb6i09OoTLW8+UyT5hqhJLYKR7g/gTWOorSUM9tazitwgCK0swgh4BB466FsaIQixDEqihBRQlM2NGWDiRVxnKB0jE40sY6opyVCCnwUtYZhweOlQzqFFK1ZmFSQoUkJTGtLOanoDjqkaUJMQNQVjfTMK4u0hxTKEGxDksQsdhYQWrG1cRuX1wS1AE5ia4kzksIqitGUYKExNZGANG4RbV5IJpMSawLGtm6b03mJUI5ZUZLJNgmQOkdFGc4pNIZ+r0MzK1BCkicJOu1S1HNE04C3pEmMtQpjBc5ZUAFfV+BqgvCoJCJJYqq6ZmFBIkpHXcxIkpgo6dBYyaQBUU/oJn10nGCVpJYRabdD4hyV95TGoYIljgRJFqEx5KkiyxKSWBGlLX1ISNXOEyiJCG3l567uNoQ2AVDi7tdHB7Zt7yQVtwmETAQq0URHB7I3jqAF4W6lry1Vtk1CHzBNwBlPMTVMRxUqFXSWu/T7XVQ/RWiPsBWhmmEax2Ri6ApBMS6Z9iu6A4mWghsb+zRZzoX1FYR1UDqGHY9VClNphl3B/avL7CwMOBjNSKOMlf6cWlj2C48BUilYkOB02xHZM55lDT5IyiDRkWBj6skzx8Pak6maeO8F5nZM89j3ECWBvP4aj11s2LjWsHnHcGZpzsd+8HHO/i9Pcmu7YFZX7B4esn8wZXF4kksPS+Yv1fjJV1ArCVouU9eHrEQPsTEa03MpRfccOKhngiqTxLrH9ckCa3KB/OSjmPwmLz7/HB8Ob0csRby6+SLRaors9+gOGmxI2J7mlPuKS3mD8L7tqFGzszli0bXdn/0yxQxPwWARGXt0PGFml3lq1GO4kLI+kGA9czrcf6rHk7/7h2zt7bLkCrreY4znsaUO+fmUM5cFschQYhGr1yjDgJuH1+gOznH23BWk8rhwSFWNqJxASsOkboiDohsndGOBVhXECuMU3jQoIqRofTeMaQhKgbMEZ9pjRbWVcGeatggRR6imIgiFiDJCsCgloSlRR93OIAVxdk/PKsTdBEEeV4qd92Al1npefGGTfi9meTkhzaGuK4ZrGc4VON9SjgqjEcaxuJpSNH108BRTz+QNz/owY2PbcPOT20yrwMUrMcMrCYc+YXz7gMNXJkTGsLzWob/oMfWE6eSQO2PLOy92iMQcGoEtFdNdeG1T8kc7ETpfZDXd5JFzORceOM0bO9tM9vd5/eVdbrw25+DQotOMS/df5md+8ueOuf1/YVa4NzDcgkn88e94dyj530GIHlX5jylDR/8u2zcRf0wcesvMAPekSvCWjsFb/gzB444oSHcf4D1H8sd7icWxS/NfpOv4/2N570mShCsPXOGHf+iHcN7xmc9+hsY0xEIwnU75pX/+i1jrjgL09opKIY+D9aKY8/prr/G3//Z/w8WL93Py1Cl63V4roRXgrePWrQ2KouTv/Q9/j2vXrmGNe0vn5e771xaLCKGVGFl7PP8QRdGxtKs2tj1gaM+p1aEmiWH3sEGINkG4sL7CzVszqBPStM8gmmJFze5eQZNG9LQgCoC2BO85aCwrMRRO4GVbbd+ZeNKs4lzSoMU+avMPaczbcacfR+mE2HyB+y847rwyY743Zm2h5MpjFzl3+Sy3b83YOhwxmhxSN+voZMDKSUmzOceVz6H73SN4jSUmYVzV5D6myrK2A9pInJRIkbBnUoYiJl95kO1rh9hGsP7gWcgEN3bepH8iJs0SojhhXnhGdUwzh37q2g+vEJimoZhVdD14AbMmxi1eROUZUnmkMjQu52aRstJX5Hfp6yqhm2peemHCwXSPNVGALYmFZa3fIV4asLAmEb6HkOs4sUTtFJNqlzhdZ7h4GhdKCBXGFrgQAEvjPTooEt0i3ZEJUidImSLQf6731TeUHPTymP5yjtU1zWGDkhpXzJjtGw47ChFJJkXNYl+j40W2ZzuM6zlFVTOZNdwZN0T9iOgApiPQsWRtQSAOA//wF2bc3/GUh4FpLbAhcLAJr/1zx//6fxY8/B0140PfGqZd0Xz4HZqdjQOe/h3LJ/7jDgvCI6bQTBTTPc1vfM7wu5tdJq7hgfg2H3n/AhceXeXXfvsas8mcV696yh1PNWnNyOJE0htozjzUw5ZtoI/WOKWoCofUouWHO0ddmlaqYgLBC+JuRGUtMhKo4JGiHRhSIjA5NGgtCVbSVB7pHNlCDsZRVw0ojRWagCTxHu09RVHilEA4j6fdsFSSEqqGIlZ4CZ2FHt1OhqgdkS/JRESsYiIdkXcjklQxN4Y0gkltODg8QCDoCkVuwFYNVWNwdYNPO0ipaArHaKdmoiXFZE4n6WJMwElPnEuWF1MOCsdoNGVWGvJBl36vQ2zmHBwcAAGRpnSlJIsypNLURSCLoSIipUMcddBZh0pKPBWBiEQHmqLBOYEXMXMXyIzg5OJJxpMtAhaXJFidMRpN6OhbFLWnrkuUz6lwTMoGYz1r+YA8UVTWgEiIswGLS0v4+QhBRnlrj1hIdJTQ72giF0h7GdWkJEk1nSwmy5NWD4ZAa3lcQYW3VOo8IMLRwXm0lytQWrTvGUfVOgJCgjEOpSTGOIRvO1FChPagDWBqTzF1QGBeWSa1xQVYOzGgKAXziUcLSxwM0jbEMrC8vkI1nlFZS20NuRAth14lpFHEUjfGTxumtqQPLGZt9cn6DpdPLjA72eeN6jYiSOTJJUYv7PDBJcVTM8/VeeBcJLi8oplW8MaBJdPQjWEu4IYT6FihnOX3p57e1HMmnnHf8Crrq7+Je+9/xavVjOH8JisX5uQrFZPbBwxf/J/4b3/qbfxn//g59qaCnTvbvPi1L/P+b38XZx7pcBC3ruO+ukUspqTLOdHyKqdcyc1r29j4LHGeY03J4cFN8vXzvHp9zruQJIOHKKM7vLazyZ57gv1uygs3v0hycZnFNMVM59zZuE33tYwPnM05KOacTiSNcrx6e8bs9W2avQJ57mFmItDpKgaLhqhfkOZv57NXZ/SWOpzsCvqRQArFykKf25MJ3/YjP8iSeC9N8xVK+wJCHdKLVpDMyVwN7hTzccT+yHLHL7A8iDlx+gPs3flDpKyJ45TGal4+2GY6n3G6HzE92OdEb8R965D2LzCf30DqAUrkeJXgTY2ppkidgQhIZzC2bCM3IfHOo6UmKIdREeCQvoEjGKVRCU0zpq4LDBCiBKOS4/2+peaJ42JwCK1XSwiBsjJsbh7y6Sdf4fkXNjl1esjm1g4/8uMPtx3KtCFbhChJYeK4cb2mk8d0A8xnFbtX56xlDdNdx+5MYgRsPGP4/VdHLJ2Z89j7crAw6AkunxmwPoDpwS22ro554l1nib0hVArbpIz2JS++1vDV3WUaWfK4fpp3f9OjVCieef455vNdXr/lKG4b5hMLSB566GF+5Ad+4i9mMHv3evu3dgW4l8SIe9V6cRREvrXaD6106zixE+LIzfzec1r35K/vLMC9ROE4QRDtzIi7m6Bwj3Z0d7UUo3Avpv1LuoQQJEnKuXNn+YVf+DtcunSJJ598EqUUVVVRVdXxDEebMEu0Vnh/b5Yg0BaKTDCMJ2N+6Id/iJ/92Z/jYx/7GMvLK4QQOByN+Jm/+Td55eWXMda0Qb+7e/09xjZIqY66P8DRa95L4u7KuySBVn50l6jUDqvDYj9i2NM0dYMpPOdOLBCmEZORRMkuonee6Ytv8k0Xcj5zp2Zex6x3NKcWJVVpubFZkKSSbgwjLzh0Eh2BMoavbdcsTSzr2ZzFuqIzkPjz3822mdKtb3DiikaNxpi9N+n1Pf/1T3+Qn/vvPwvZkIO9LUa7i6ys9xisDygjhwsabW+jdITqLBDlHTLfMNovIV3FC0HdNFTeodIeOweGK1ISdc6xM7vGyFse5CSzWPLSrQGrD3WQ3jEdT9ncm5Kf0Dw4jDisa1YTwaF17I8r6p0ZtmiQK2conaWbCaLUoOMU1Bo3Dg39XsQgEi2xTUdIoLCGR9/9LjriPmrzCo47KGmJZB8RSnRoCP40dWGY14oqxHSyHt3+RSaHz6LjGCkiKis5qA3GNiylCfPZLiv9ik6eIZPTRHqZvwiduG8oORiuKdbXU8aF4JW9PfbuTDm50iMbaLRSOOMprWKjmNHtCK5tV0yKhtJYqgaKuWLnacPCquTVzxq88Qy7kjRIxoXgUCu+6bsTOg9nuKLh1jMFX/qMod6FL/0zh+jAuz+uCTrwO/9gTnFCcukM+IOaORpXwKuvOP717xpem2vmas4HLws+9u51diaG/+1XbnDzekExBt9APxWEWhD3JefenvM933GOzX3NrVtTdu4UlKWD4NGJoNOTHIwsvWGEcwHrPFkk6eY924DeAAAgAElEQVQRbpCDE4jSIJ0DZ/Fzw3i/wRjQzhNcK0WR0iCspTGaXMUooRHekehArxsTCUOqA1XQxCoi+IA1pq2ui0AsAunKMnGkMFXDdFTQzCxRrHGRJh50MRjK8Ywsz9AKGCZkaYRrAkoJalPiJSih6eQxxf420tMmB9tz9Mp9LC0uk3cGiOAwxYymnLK/N6bbTZjmiu5gAfF/U/fmMZZl933f5yx3fWtVvdq7epue6emZ6dm5i5tEURQpw5ElJg4SxXDkyJAcx0AUBA5iIAIEBIEF2ImRxIKcQIBii4kjxrJEmRTkiIuG4jqcHnKmZ3p636qrupa33ffues7JH/e96h4qUphAcEbnj0bjVdWrW/e+e+7v+/t9F+uYTDKGee2O874XH6cRNJkOE6bTlLQoqZzkzp0RyxsbhIGHH9bTh3RSobwIZyxCtQijoI5Ct4YGHrIokJ6k0ehgMOggQHkxYSjQWpCNcySCqsgZFTlpDutLqyx0F0hGfQ4nBdpvEgVNjNNUcY+GM6i1JfADpJSkIwhjCb7GWPDigCAK0J6mqtyRoE/rGe8HwM6LptlDMrMIJZCBRChmUwZwpcNUdSfJOQdS4azFCgGVoZoJ0crCEsWKfr8i8iCflLjK0F3QSHwaSvPy9bvkWtENJNIXTHWLbgCD0T5Rt8nUSLLcUJmSu/sT1rsQN2M8XU+cFjoQLDn237xONd7g1puv0ltvcfr8Iwyn+5Qm4dWi5MPHMy6WJWuUHPcqDpzlcgYrDs50fXamllHhaHvwiHJsG5++3+K5zpib+wU3M4ccFKg/ukQ8/Xme+ZG/ySBa5tq9NzH5PZ7ZErg048Ofeprjn72C1YtsX8v50m9/i/d8+GnuH6xi7IigMSYb38KIE5x49BSvXPsscvxzrJ05y+3Lh8jRlNUTLV48eZzf/l1DttWkJRVvyoBbXozzQ+65irgVcm/7Fm++0eHc0+fQzR6T4iTb3/4cp37qZym+s890mKNSgZ9MKZJDGkFIHmoSYYg6lmAholCn+e3XDmC5w2OeQ1nBtJJkTnJYlSw1W7TUkKk+Tbu9xrL4MJIx1tygHL1GxTLTUUbfRIxaMYvDA5aXVnn90r9gY/VdVMIwzTM82+XFJ95LUha0goBAJwTlW8j0GsMk59LuddaaIb3eOZwWtX2p8miFXapyiq3qhGhjDU4UCAxKlJSmqoub3IAFX2vC1iJFWVHhUaDRcQieJtm7f7TfB6GHlLUrTmksWsmZm0sNPLK8QiY5+/tjnDPs7I35J//9t9k63a75y1VFu+tTVY7YGW5cH/LEmUU8LyQxMcsq5COfXiI+0aPs3+PCt/Z47cKEgzdLfvfVffSqx49/coXtq0NGt4Y01gNWFjUuHVK4GJML3npzzMXrjjtZwFT1+cSjgmfPPs+lOwe8dWObe7sHTIYGSp/lrk8ydGye7PDih85w/qnzf/5P0j+PNWP71OwdMdtT5ExC4I7oiPWX304fmmtE5uto/3nb+1ukqDumMwukB2nL8+61+z5XI6WZ6xfm3ev55PTBIfzF1hsAxFHEZ37zM3QXutTUKUv5kIOXtfbIFtZai+d5Dyg+lUGpmbW1kDjryLKUX/mVv89/99/+w3qCMyvkq6o6oiRZ+8C/Xsy+x9paV1KfVve2a1pVBsiPaCZK1Zba8zW/Hs5asmTK+OZNFraW6Y96OJWTVT53qoxnTq1xqUx5dmlEUeQkVOzmjo6TnFjtsjsqaThH5BlCJeibBsN4nfNP3ODSmyOEcbg7uyyOv4A/vcjm+Z8j8Ze4ff9VWn7FSgMUFaeefIxzx79J4j3Ore9e5VrTsLD8XibpGo49vGBAlpQEwVlcINkbXkAUH6CzvMrunTFxx6PV8vGriDevOKpFnwC4JzwmQUjL5CQ4fF/zxvU7nLyzyYmNHpXXoz+F+zcu8aGnX2R6Y0Q6AecEIssxRUrk+VRakElBM7TIsE1iYnYPMogD1mU9OS+RZBZKHJHv45GRy2Uir40WBTDFuT4m38bSJU9TprKL0Y7Y5IShx87e11jsPE1hEjACT3fZaq9SOYcnFUu9FG3uomUX7Z/4N/Bp/8HWDwQO7u0NuLt3CL5Gao/jZzfZv3OboBlDIbB5XWglqeHOKCXJHUkqKJ2HMYpi4DjcM1x8acp0v8L3JSPtkAa2jjf4mV9Y5djJRVbWnsTTJeVfusHdn7nEL/wnOyQH4BRcvWDZeK/m3PMeN18qeeE9isOxQA0V3/hGxcUrDtmIqHTFx5bh+Xcf5//82i5v3RhipeXUmmanMhQ4xlN48ocb/NBHN3n6xGleuTJm9+ZtGmFAy1OICoxQSC0opWRpNSLNDOm4oMwtWimsUpSpQSuBpwzSV1jhg8xoKEU2KPEDiRMCU4LNLdk4R4SStLAE1uLr2kvftx5JWpEJjZSa4diA0Ph+hHAlWWHqIjadkJU+eW7JCkujpfCaDfxmk2wypZxmmLwgCyb4rYhQaKo0ZXyY1u5KrbrT6AnJQsdnJVVUeUUVCJbWVxhNHDd2Mggb6HaE9WCapySjEUoUHFtboT8VTMYTyjxHW1hf6TEeVZRyiFYaT4e4MscLHCyGBN4UpRs1lUdqYs+SlJY4CPFUg2HWx/d8At9DZAWDZI/dwxG9pocWHtZIDCVL3Q4HyYSGbtabKg4tPZa7DdaXlnCehaIg1IpmHNOOIg76Ft3STO+PaS+16S1FdDo+YewhPIndrznRUtXiZTGzkDjiW8u3o/c6HKoe9epIzYRmAjGjF8GsNytBCoVz9f8PxoZACtKJodHQNGJJVVYgFO2GYHKY0R8W5NMc7Qxr6w2y0YiGXxKGAdZaiiqn09EsLy/hdzRxbMlTiy8c6TDBZmNO9BRSpqisIDUV0of1WFHEKXsXX2ftsTbK9olsQS9YIhu0WGvvc8f6rBhJGUkKX9IpKxYnFUW7Fof3pCSrBIV1NJ3h/KLhlf2Mb5iQkx2FlxS8clhxGEs2XxrT3PsNTn/6hzh29gyXbko+852b/HRe8czpP+BX/9Ff43/4n75Ckk549v3H+e7Xfo/zT57gtcM9iomk0ZXkZp+dWy/z1PEPcvVwyJU/hsVNj8zkXPleQXuly9kzmj++nfPSfoEIHCdPnMKc/XH6+yXjdk5VWoLKsLK2Ql7lHF79PMX9p1kcCURPc6eSuAGMb03ZvjfkxR95hHvNBVaDHB0tcb9YYlyklK1Vno9L8AMcihKH8iqaLc2SqAh1CEIjCChooGybtFpkNFlncPsPqMKASepTpBlqI+Cbu4c82X2Bw72SyGsRhYtMKbnw1pd59xPnacWLRLqFdItk0ROY4Q6N0V2WOj0kJVU1BRnhqwaD4T7SDPF8hbEZZZljnEVoCabAIrHVFCixwpEaxzBJUVLhtdu1WYEER0W39eBRkOfFUdE47wgbaxFWUBYVxtSTqCwv6A8nIATal9y4lqClQCrH4LBi41jM6MAQBQ2Gh4pmM+TsuVXe/8F1lldXWFh8Euf6fODJK7zx5kX+l39+EbWjsRouX0458XybUFoGuynHjreYZgqSgFe+c0haxBDFSC/n/R3LmdPP8oUvfYthPiEMBMd7MYcmp5jC/qDkh//tEzz12HmOLz+LdfX+8c7SGrx91Tais+Ti2Wtuhg5qmqM7KszfNglw7sgoYV60111/cVQ4WjfPPZhxxmYg4WGAMGMlzQ5GzGxPH5qifh8weeeeyf/npZTi8XPn8IPgSGNTFCXJOMFU5m1jkXlmRFVWlGVZa+Zgdo4UUkqyPEcKgbEFZVnwsE5jnk3xIENBHA3ptFQ4arew+QRIzTQicmZhW2tIZq5KtiJPZ5OgGb1MiHq60ew2UayRD+7QbrZw4zWickyvOWTP7LFSRBQNhwg17TxD5AVVW0OZ0FMhWeGwrqShDa2Ox9W9Ia+YVc6cDtm9MeCt7ZKVJGPx4CbhwW/Q+/gn6Gye4/KtS2zf3eV8mdDrfpX/8u/9PJ/5X/8PTp5+jKXjLfq7r7O4uM7uZBeTK/xIMc5uU7mcle5Z+mnK7lvQWVOMxxnpBLwoYHVJ8NbAcDk1tEJYPfkopCXT1GJlhcksgTUsLC1QvH6ZKxe+TrX3JI1PAC3FfSRm5BgcGCZJwcmzPfpeRFcVGNVlXHik1kEQs+FZUDWrwwgLyhEoQYRFC11zi1EYfHABVdUgL7qkg1dwYYd0Ogu/DeFwkrESPcZ4MCUOWqAkWVUxHt1ldaGHrzto4YGOcHhYFIp3xvrB3Ip6a+i4TZb0aTUCROxhjGF/nFJITUf6ND1Fp92lGDv6B2N06SiAwUSwt1NRjhzV2FJkAoXgeM/jA+cXOf6Rp3BrIW8e3uILX70Ig5yNNclj73uBn/mPvsb//s8GLK0rVEsyLgSXbsHTT/vEgWJyaPnC53OGicTEklxU/NjjTTZbmt//8j3uH6YoHzwHu3sW3RRsnPLQTU28GXHlZsob37oEgUY5yXg/ZTwuKCqQvkD7Hq40ZFlF7sBVBipLYRymNIjcYCqBpxxSaZyUGOuwKLTniBoRYcsH48hHOVVSUWmJyQqMUXhxhB/FVA7QijgKME4RqQpnBQhJUSq0p5kUGX5m8LwS5QTNSOMMeFGIEUBhcUWJK3PQknSQMUyyOnOidEilag5/GBK0u6SVIuq1aQAage/HqJ0ht8WQwfgQlQW1e1CZoYUEqahEQbPRohHEpOOUwcEh2g8QVc5wnBF4df5AYUD4mrgboQCtDWU5Ja0gTyumlYaWRyuS+M0OCnDSUTnoLi9wf3eEXlimsIasKKAAW3iUhcD3PFqdkEALIt+jvbCISXPQIQtLiuIwJ6ckl4YwdIisJIhjjK/xmhGdhQZ+oEnTnN1JyqNbHaJGgKfrca7n1VkVtZUgR+2YOgxIYKqZjR9u9rCsH9jOOKwElESpmjJknKAyFk+BMQ4LZNMSl9cP1GxSICxM04JsmmEqix9poqaPDlocO7POKMkYDYfg8trRpsrphBLpLHHgKE3GsJ8zGBxSDiUbm10O7/cZj3KMdaSBo92cErQNzaUIt3uFZrnDWpiSbDXZGS3SkQPCZUuRGsppgVQ5Irbs7qc8GipMU1FQg9rDSYk4KHn3imS3tExKD9nUbAUlt3cLDktH/9I+9z/zEs9+8hQvPLfJ5pZi/7W7/PpvHnD+wxf45I+9wPVbCds3L3NupUQ1jrHW+Q7XEuj6MdYtcLPf5X5D0Sl2aR/vUd4a0o082q0lvnPR8sxzcP/iPdrPK3amsHNosFXAauDxj3/9DdLDPXa+9zW+3VDkYQuRjcnKC6AmPL2xxssXrnPn4h1Uv8/jZ9YZxQuca2pMvMohMdlYI3LBak8hkSRoJOArh/IVsYSuDuk7x6g0JJllOjFkgxHJ7VcQ995kVE1xTY9WI6ETVgz3QjpaMfYjbNjm8rQkKzKWFw2PbjUZ2x26cgMtOwia+EGLhWaE65RYJ1CqhRSavDSMJ0NUlaI8H1PltVuNqgV81lqU9phMD+sUVjzSNK0FjK0WTtQFfFlBWZYURc54Wjy04z9UDFELHMFirUMpiRYSYRxlUXOvpYTDPUN7KSZuekS+IvQ8ZGrJckUr0pw/tcSZs6donngU1Q64M77FF77yNZb8khOPLNLbfJ5PfbLii1++zupWjGr4XL5WsN4UPH5qAS1D8qnlS1/cJWg2KH3QvuPdCyssBJqvfOs1JqYgigSmEAwzCDo+6yciToYxS8unuHUnY3x4mxfOP4Ov41q8fcSbf+esuR7gbSX3fGxwxDiZawxmL85es7NrddTsgLcJGp2ozRXmdElzRGup3ZDmTY65UxG4utEhXG1OATV/++iw3APB7V+gZR+ibvm+zy/+4i8ShuHR16qqoigLrLO1tnCmM6gpXnXB7vkenvaoTFUbVjhHWdXmGPPrV2sHHig+vn+ao1Sdr2CsxZQVdgYghHiQvaCY2csKg7UGY8yskQXioQpuPjkQUqCFwo8jir0DIibI5ZhsqcnBrqWlO3hroIYxLpsgvBQbFwz3h2w2YsqOT8NqptOM8TSjeTjh8Q3NYVEyLTp0joWkgwnbexP6ecX41cuczAu2fvR5Hn/sEZJRg+T+LldfusfJ5y7z8Y9/jLvb95mO+qx0PZS/RDty7KSOrtdkUrQYly08CaEZE/aaFNtjFhZihqVPf9+x1IO9GyPe9egiO5OKcSZpoxGl4/df2sP0D7j76stUvmbn3gFucMBIvA7yE5zstHnj6n3S3RGeydlY6ZD7Eeu+pPKXGFsPW4IQimYoEUgyZJ1rJEBLUesvpSJ1jsw68hLKwlBOxxSje4jRPTJnIbI0ggTPCcpUEwhJrn0IIm7lJZ5f0g4FbV+T2xGhaNfiY+EzawnwTqAUwQ8IDuIgxJOagyTn/jint9rA8xVpBWRAYkHmBMtNQs/HSo+wGVAZB2mB8CpkWOA1KnRhWVrzOPviOi9+5FGCE01u3Njjza/uYW8XeJVlJ2mTtBY4ffwxnvtoxmRwj0F/wsFuhY9gfV3ze79XUg4sV3Zrp5iVps9jJ1qEXY8b1ycM8hQ/sJgMihyihsQYRxgInHEM71YkkwnZoaN3soPKLKNRRVGCUxKpZS0KLkuEtVgnwJq6S2wcZebwFUSBT5FVFFmJRSKVxPM1OvbwQ0mgBGVVjxAlFl9pCk9D5TDWkFdVLRasHKKsIFA45GyTtiilZ+NGQZZWVJXA8zVB6FNlZf2AKwuctTgtAV1vEmVFGCqcF9ViaFELm0zlmAwTGs1FMi/CmgKZpuSpISlKHJbxJEHKFF+ADwRhQNBoUFmv7vIHIQqP0bhExzHZYJfhYIzWCu35KM/Hc4oKgRSSLM0o8qQGWZnBiBgpIGx10GGMK0vKMkNJQdCMsXe2SbImRliMMygdYAJJkRYoIdGlxFMSTypC4RhLwTQtsDZHiDqKPmiB9iqk9sD3EBKMs2SlZZqXHAxyOr0GnZWYMPKORsbCOISW3zc1qPm+Qj7UTnPUD2Y3f0DWwuS545gQIJ1AWPA1VEAQSmxpKa3F9wQmq+p7RDjCUGGcQgUaC6g4IF5sIwOBr3OcUXRaEb6r0KFC+xHlZEKZFaSjETeuXWOlt053LUR4gM1J+2Mm+ZRG26JFQdRQTN7aZnT7PpQZYU+zgcJbfJb93csIkeNHETawyMhnU04ZJCM0BpxB4+gEitHIEIwr2lIgpIZAEzYCPKNIxiU3JwZzeQ/3ZcczcoNH379IVOW4FYk3vkm81eP0Y5uoUPP11/6Q7ol7dJfXSPMBk3HJpKgQrYB791NWeiX58D5Ro8s0aZH2fdZExbe/kfL00212L77GPdmgqWOOP73Od98acvWrX8SWU5LCcnDvgEpYJC1sOebly6/zvqefp+oL+rs5bXI8X9FcXSHwAvbymEkZ4PCIGh5NT3JgBA1Xg79KSqyUtIWjX8LESA5GUwaHQ5L9XYrD61QmJYwkVp5AywJfO7TfJnUhgRmyP3F4jZxG16MTLrDaidlsd8ixaEpwFaAQTuJJn2bUpSpzQCGFRAuLEhYl6y5yUVQIV9V6F6lwGCpT4GxFZSUy8PGlxWa1c41Qmqy0tQMSltxZRnl+9GmvU8EfdIdr+8s6IXy+rHVIWxeghTXIQqCDCmsFRSapCgi9mMppltbanHzyLCceO42LQw4P9rlz8TZ6Z0jua24raB9bYWvzWc6/uEU6vstwNGCSKTpNn8QFXPvGBDc17JeWODf0el0WF7t4vs/u/T65S4gjSZXWrm1BKEE4GnGT0loOtsdoscpyYwHfm4uvHyqs3wlLcNS55qFp5BwQOEDyoFlxxP2Z/zvTSD0oRB/oBBwzXvrRNz/42x8uWOeAYj45snM+PXP6ywPwMn+XI6DyF2TNz4dw4qgIP3ny5Oxvro0xqqo64vs/zPuvl53ho5k246FMCpxFzfxK5zQhNwdV1LqB+VRnriWp7zdmlNPvA3xwpHEwxsycpsCJGnw8TDuCB58fh0D7AUF7E3G3jxQpYTOmMwnQrScY7l9Fex5WxrVuScKCGDGcDvFEBabEVx7Sd6TjHN2f0vIkqCZBMyQOPEIVkI9z7g1TxFs3EU3Bxgun6a0tM5ZgYxCTa3SWexi5weCw4MbdWzzWXCRqbpCVI5JxRuGaWKVIJgXNqKK0CXEckQwCrBN4znDjhuXM8ZCdKzcZex2WF3wi67h+d8yN772OkhWjMifcS6jGAu0iiizhxt4uZzY2GR06iklFOzC1a2KziZaacelRVgo1O8eeFEysIJC1M5gREk+AB6QGCiuZZBnpJKWYDjD5EOcM2lc4tYoWZW2FrmZTAJczLQXSL4ljTeiHNAOfpufXuSWU1GW4RKIQ4gcqyf+NrB/oSPLJlCzxSZKCO3dHCFPW4WClQ5QCnVmEKom7oKWPjhsoP0BnJaE/pbXgEE6RJpbGkse5p3o8/sHzdJ97klv736G6dYPG/oAT7QobaPbjmP6h4bTrcPJ0l+99Z4QpCsrScu++48Jlyxtfr2hqaJ71afoxK+0mm+sx10c5N+9nhE2BSAXTKdhKEHcl+dSSjx15aelPC/JCEwY+ZQlZYilLgdK6Lg6FpMgNylqU55C2Fp3igBIKU9uY+rGmyCqqokb0WksCrfACDRjyianBQ17iO4vAQ/leLbZ1hsJUSE+RjnIkECx6KKGRCpQQeF7d9VOeJi8MhRUEUqICMMLV9BRrsVJiPR8noapyEI4oDnBxTNiIAMd0PCUfZAz6fRqLDeLCUqQ5djhGCc20UhRFRVEatHYorXFaE0YeXquNQYNVKFWPA4NGGycEydQyyQx+4AiVRDqNFNQJx15EkRSk05Q8r8XHMpA4F1MWBUGgEVioCjQGoRRxQzEpSlACTyu8wEMGHtozGOtIpjmKgNiDbFpglGYymZBmBVGrQRgHoAXGVhAEGCuI/HpsnqQFaWrZn1Q8dnKBTieotQUz0IexR2bUNWWovgfmo/nvpxodPbYluPJB2FC9vdd2gFrVzkRSOCrAmXpTFxZMYfADhdCiFjkLUbvMeArpaeJGQCibCFMRBB7KlviRhw4jxkWJ0CVSwPBggPIiNiYRncAj0DDOpiQHh0wSg7Q55XjE4cWbZPt7WL/EeCXHwgbe+gnCfIjJE8qyJC8NUdTkeG+TN7a30S5F5VNkniEtZCbnbr+g5TlUZLFYcq05tqQZSs32pGC3LEle3mVvmmGWHueJs6ucelaw+/otpuoa6+vLRCtP8jufu8zN/Wss+U1665uUkzHDKiVcmpJc38Nu+STju+CtUEwaVNuOzRMZX768z0f/Ssy3v/AtzNIjLGyeJNQ5r711QNvb58kPvsjyRpeFxZNMRz6HJ57h3o0/5sqNbd577mmygxHjgwFxz6IXFmi2F9gfOBJb0zK80EfEPjjByAkazqKlxDhBljoSa7k0GiJySbJ7jelgn2JyAGWf9sYKE22JXZu43EEIzdAskRtBlY2YtidEeo/N3ilW25u0gxVaukkbC6aPsxlVVVJVFltV+H4La8FVOch68hppSWbAo0IJSVnVrkNC1fYarjJo7THNHJ4vEdJDulqHYK0lSQuwOVYISmfJnTn6RM/YdUd86LoLWpswOBzWmVrsOtPl1DodwWRcUuQWpSVpaogaEcvLXU4+8RgrZ19E97oMR9eoDq8TTvY5tV4wEiEDcpKRoyeX2Fhb4Ht7CVWe4YRglEuu3qm4c3VKjGThqQW8ssNCZ5lWq8FBMmF3mNBse7VjXVXfo14osIWgnMI0N/TTPo+fOc+xtbOEQeMhl53/z8/OP/cleGAdCxy5D4k5EDgSDT8ABg8sTWcgQYqjLnb9JjMh6+zvnauX3ff3OeDIJUnMv4/6Z2t7jAfHyJHf0fz8/cWYHczPST00eEAsM8Zw4cIrfOhDH0Zrxc2bt7h69crRz9QUnwfC8LkYvKosWhuYTWLqc1GDKjOjDx2Bg9mE6ui3ircfV20JPH//+aRnpv+YXet5RsXsS1gszv7pNpdSeajWMWR0l/RwG2tKVjaWmRQCb9wHYSjKHBAEQczC4nFubd9ByQli2sc3JcY3DM2Ew70xUWjwWpbShHh+wPJ6k8yP2B1q7k8mTL7+OmMsJ9/3JMtr6yxtCZK7VyjdHdY2nsGoDe7c3WMwuUckQjqLDfbHA0SQI1RKnihcR5GlMdrvMtlVhDjisOTyQcr545rXvn6V8MTjxL5PkRfcPxjTVglb73qcY48ssdRZgpFkuNlnNLjB7uGQsxubJHtjbJnRjCUqDvGDiFFaZ84roZGeAi1xCDIgdDU9y1oobU31OshLqAT5aIcqTzFFgpQWvxmTSUFEhF/tYWiQmwjrDJ4tMGGBp1J68TFiv4svQ7y6gwcuPYL3Qiik/AsGDm7cuUujm1PkBlM6bl/vc+bJRp0KXDmKSqCtxzhXtL02zYZmNLWUuSEQilYnpBVrlFZsnFzmuXe/m0dOv5tU9bjlLtFOK376RwVlw+faxMPIRZ44fpbqK/+a/o0peztTulseVaHYuZxy/2rJk095PHMuothq8ujSFo0y4sLVu5hbGc2lkH4/pRjVG5gXOQ4GlsUYxgcWbzmkmCjSSuM1fPLDAqkUYVh3mPPKMkkqsrSk2VBUkUfgSUwIJrfYqcEkBptbknGOKSooLa60lAUUUuLrWiyaTQuwFn8GGApr8bTCaI3neURhnby8c3tAHGlCJ4haMYHn4wnJLFWBEkmS5FBZyAuErWoq07QgaIS11aqtcCWkaY6nfYZJQTFxdApDGCqUcHihREjLwf09FiIfkVdUBSyuNPBKeGOc4kchfhiitUJKSxBKRNhgsRUyujehKh1S+USRz/hgFyti8Es6XY2S1LkCnsQeDEi0RFuJRONriYxDROCz2GuST/poZ/CkQGmLyXJsKVk/dYy9gaNyHp6naEhwhSTstikmKUVeYmxIRghGIVAUFRjZwgvaWBfRTxyhFKAdxlIailQAACAASURBVBmWmk38IMDiQFqihZhY1haxzDo29UhW1jH1vkTw0AMWQNZjYGPcvGlUd/DkDEQI+9BdM+MHy5qqZISlKgxy9l5VVmcfSC0Quu60KmuRzlAlGdrz0aIiL0GrCCVyzDghWGwRBAGTAghjIs+jK2FrbZPd+3cpVtvYlocuUwKXkZgpk2HNM797/RYHt+9STIYUtuDw0h5nn+yyHvY5+8KLlIcJ+3d3qA4OWawKFte2+Oh6yNQ4TD5iOh5wd69ia2HMdT1gf5gih5bMZEylYGvDZ2mtw3Mjj9f6Cdsl3Lg65dKvXeKXf+l9eNmQzjHNcrcgj7bx1TI//Tf+Y7519R/wyheu8aGf/Ek6vUOq6CbXzAFFJ+N+4SGiVa5c2WVtpDgVNNm7OeaZpwe88rnfY7Df5+TyCYZXbvIHX3qJj/z4OTZ/+if5m5/+IBvNAAVcuzOitbDJF/7ZJVbCdYqsYrL9PYp7r+OtneHM+36cwx3H4U7O+oqi0ZUYH5JpjowCQiVInKTpwE0LDvoZrw9TXt65ihw4WgffpBmn6N4SYuUR2gs+V3emnM13Ea5P4loMqpIiNSzYiq2TE1znkDA+QydYpqGXUULVYmbRoSoT0iyhKAxSB3hhC/IhZdrHCYFSARJFllcEwhAE0azDaxCitqDUXhODQlJQUdbp5nlK5RTTNCWZDPF8S+UcZWkI/AdMV2MtcyKEmBdU85tg5l7jZlO0sqz3WOMceVpijcUPPYQTJJOK93zkFM+8/xMs9M6SmYSRu00kCn7ovYpUtBBpRDc6TiiWKW6/Sv/egOF0zNYjy+zeG3Dn9pADSs493uX0sSZ5b42T8RMkkyn7B7u4QUbUajFK+pTTOj8mN450YukEksF+n3BtA5d3WV4+zfra8SNgUK93FDqoeeZqzv+fvTwr2O2sN/WA7gjzanGuF5jTieYTADejqTB737niWc6KUCPqBsYDCtPbaVZ17T8TQz/cPRdyNqWYH+M76Dz+Gcs9/B9Xd4fLsuQ3f/M3ed9734fWEV/4wuf57Gc/+yc+Ikqptwm4HwiKa/c5pRRKaYoipyxKjDVv+8X1tavzdObXa6498Gfv7axFSnV0pPPfV1Zlfd3mttqzaYa1Dz9zZod7dC0kRVmi104x3Dnk4NY2vU88z+Fb/4rV84+RHQ4Y7t3DpROaEqLFE5xfisgrB8V9JqMpyThnsTPkvrzH4e4B3mTCqBiiWgHLWws0j61wthXxxnbO9Tzk7oV77Bufj37yXag8IewFNKKMUu2xubVFd2OT7cN/TfraZZ74wKdpda8wtAmF6VMGKeNKo/wed7ZHbIoWQSWYTnNObCZc+c4VsiRhUzu++53rTJIhTz2/zubH38uPPHeSePZ5vHY2YXkp5ptfPqDrdSjykvTOJaTviLZOsbixwSRxJKOK3oKP9gUVDlNZ0ApPQIYkBGxe0c8q+lnOrckIMXW0Rm8StiQ0lvDiBZQv2E1KjlcDClISF5KbCqqKhjR0FzMIEgLPI5AxSgY1xHYliAghAoTw+f8rz+BPWz8QOEjGE/YGMUZoGm2P3sYC/XSAlprBOGM0cWz6mtJ55H6b8fYIGTeIQoEvLItrC4jCcO6ZCB20aS4sMxUxSrZ4fO1HcT8VUN3+PHuHllHQowgXGE+3Me8J2eyl/PFXM0YDwZl3rfOxnznHW5duMhAZf/U/+DFa0RpFcch4mND0N/jsy1/h6s0EL7K4QJDnDgpYXYU3rjpCTxLkggyHdRXF1OG3Y5QncZEk6RdMRyVlVuErqJwEofG9AC8QlK5gOk4JwoBG1+cgMTV6dw+SJ60UpCWkgwJXGnCOUlgyC/FCE6kETmhQkrw05GVJ4Ncbd54VtNdCGp0OorLs7+4gtcA3GpEnNa/d89HKQ3uaEkPhDCLPmXdwtHQI5zBaY7OcLBVIr0EQNvFkTrOrKZxkuz+lG4csLHbRgSbstekt7CFCKPOMKknBVVSyjUgHWL2EwJEnCaYwmEmJyABn6TRbaO2hNChhcVVtydr0S+KFNYwNKA01VcgWJIXCVRVm3EcJh8bhS4cOIlInQDlEYaEwaO3TbEZUVQWdFszEvmWRkKSKtFC0ez6rnTZRcxGv1UG1YpSnyIMIqSSVkmRG4GtFs61YlSULXa/OM6DuuAoF4JDUm6+Yu0YcoYPanlSJB+Iw5uCAOj3b2rrTI4WYcXhBzLjg2pMUxlDmpg7QK0u0BFsYlK9QGqppxXBvTDUSBM0IqyS+FlBaxv0BQdMnHVnGhaGsHGGsWOqGPHm6x7kthS8nNFtNfCOY9hVZJRkdjri5vY21jt3+FJPlxLJC4/ji1+6ivm55z6kbPPv8BsfPLGEeafPSl67w5Hd2ePy5nyDcOMV4YZm4pXlW7XLt0n3Oqdu4vTd47btD+ncygmnJ9p7jrfGApxZiPra1QLQWsRvAN24k/N3//Os8shnwwqdWeewJTXMhQYsLLGef5wNn/w4v5Z/nc1fus9oWOH2MSyPNM890+fxnvsSHPvaj2PI2F2+MuXF/ixNpTn76Sb76O7/MX/7Iz7Fzt+L1N75No3Wbj/2lv8sHn1ojUA+6wo8f7/BL/+kH+Ts/+1v8yj+5wFc/f4F7124RrwQce/E43Qq+84U3ee5TZxg0I5ICwryi1Q4JA0GlJJ1kxOGoz2FWsjsteGXnCu9ddOiogffCp1jsLdELA7yi4rXxlL/Vcnz99QN29h1RI2VjYciVoMXGi+/nw2vnuG2mdEhRNsNUU1ANqLcKjJnRQHTtfnJ4eA9BOvvszZoFUtNqR5hshI8hCETtQlSVOAQ5kJdFTV9DMk4rDidjhNAIZemttLh3/z7JNJ1RGx6iDM04z3NV6pxy56DW3My+Ni9hnK01TfMOpxQKrXx8FeEqH2RMLjRCLtDrPIc838aO/gWDQ58iPIXnNanklPJEyGZb89WvHGLJefSxczzyWMBwep8kKHnhhU+i9CJFsU037uEVi7x25RVu7ezhxwYbSaYTnyhwNMKcy9slkR/QLjWPnnmW9dUttPY4yg2Y39vvEIBwVODPzmNd//9Jys4ctD1c6DqA/5viQkqBnYmNy7KacdflEchQch7K6B7Qg8RsAsWD0LS5jWbdzZ4fhXoIaL0zzuGftr7/HAr54DMQRRG/+qu/hhRQFiX9fp9+vw+A1vqoAJ/v+XMtgA49tFJU5kEOwdEEQNaBl0cTGB6+v8yD9GlrKMvqCCToWWK3mwEL5yxF8SChWsi5q1GtO5B/CigTs3s3bne4/vprDO5tc3DzGr/+3/zXVGmfdz/9GqdfeIH1R9oMD1LuXL3I+uBNVs/+JKq3QtZ4FyteyTEzZtgfsfnePRi8yuXvHrDYH2OSguF2wSC6w6nlJT5w7nHkZou704zt+2N++9f/iLWNmNPvP8nyqkR4Y7R9lbazeMt/metPvMo3b++w3mlykLfIpEevJbnw2vd45ql3UWbbXDlcoTUNaGlJ3lng61/6I/7Kh/86b1zss7dzifWtFs8+c45jvUY9r5lNsR7danJq83l+4hPn+MNv7XI5uU06GrL+9AaLm11Uath744CTz/QYaQ9ZWHwlCHyJ1nUNFxUZwywlreBemnKQjXg0dig/QJ58D504IhI1ZXxY5nwkhOvbQ4YJtNoZKhCkjQZLq5ucaC5yaAo8CnAlztahbg6BFN4MHLzz7p8fCBw4L8QqhdYlvVXF2vEuyZ7l2vaIKFD0FiKWFmJ2t3d59c4VmovLNDxwTmAriZpYtk5tsrSwROIcUbxKpHvEeoGwEVO1tvj9/ClWVnucGl+huPVNrrxxl2c//Us8svWHfP3zv8Vbr/e592afqOnRah7nJz50nr/+X/xLTGUokxIKQ6/t8d73LTLcXOb1r95nejcjCKG5INifOhg7zIJg+3KGNYJmOyBYDkE4Rv2cIvEoJhZpII488ARZaVFJxTQx5LnDGTFTlzuGiaOYunqUrTSeBiEVwiqEV/MC665yLXLVgazFx1IjUGS5wSRpXQhIx/JqRKkcVZWQpqCchw5DBvuH+LLuAgSRh6drMOJRYRBUkxzPEwgqnDE4HWKqnNZCi8DrgNSgPKQXEDc6dHs+1+8cMOnn2LSiyAV7/SkNVXLi1DH6wz6ZLLBBgK8la0tdqnRCaS2q9DjY7dMfjPDDgLi5SJFoqjIlqTJ04OMFmtBO6DZaBCsrTEWMqBSxDvA7TRqR4XBnn/2DjCIr8CVEgYeKGoTaQ3mKINYYlZKNx9w83CXyHZtr6ySlBKVpRCFBGGONpHO8w+mTq3hRE4ytNSOxxI8Cdu/2YbFFs9VEOEV/WDDenfKJF9YolEK5mk/4J9hCzN2J7ANqr5tp8ZyrwdHM9lR5EuWruX7vaJSMc3XCHtSaBSVQoaqvX2DIpxVhDM7qWlgmBQKfeDHGk64WvTmDqyqEVnSObRF7gnI6ocpKKiOQUUy71UY9ssWdN6ZMB7s0WgFeoPAakkonjKZjRFlwdzyuU3ax7BamFpNVlspWXH8t4XfeeItjnYAXn1zjE3/7r/LtL97hN775JvHwSzQDR9RuEDVbnDi3iB1uIHiB0z8ksOkBV1+7Qnj1kChL+eM7I+7pCU/2NY8/u8WH/96nGaw9RdFa4199+Vv87me/Spy9ySOPLPOBH/sxxru/z+L9O0TRGkGzgwkqTugDvnmtyVM//td4+XNf4vn3/7s0d3e4dvfzrP7wz/K9z3yWv/3L/yMXf+cbXPreF5lOK154/6f4kafWUEpgLKQlYBxagh8IVhcX+bf+nef4x//VP+D67Ws8/YEnOXv8Ub70mbd44kc2uLJT0m4VBKFDNi2qoXEDR//qRab+mKtOsZ+NaMuMv/G+d/Ot7QlrUclyd4VJ5njj3n2md24jLl7gH936HgO9QRJG+HHCiZX7fPi5RZ7vvIem7rCl2miboqqUIhuC6yNFSZomFFWOlApPh6AFRVF3nepi5IGzTJanTGxBlTuUVkeg1KCp8hznSgR1SFroByz1ljFVQSsEoRRpnuF54GzBsHjQgTwCuKruVCqljlxu/Dg4ErMCFHlxlDRsjEMIizUO5xRKhLz7gy/Saq8QyBitfJTXwIh1XjdbNGRAvPc9sr0bFGGb1Uf/PcTSFTbP/BrXbwzptnZodnpg13jhzFn+/j//l2ghmQ4nRMKxutBg4/girfYGF1+9Sj5KWFqO6HgaUosdVrhezJvf3eGa/j16nQ1On3j0/+0z8t/Ymnfv7VxrMAcAb+vsP7Qe1goAUomjl+f1+1xE645enP2orTVvD9OYHiQnz3hl87DHGZ2lrjfVEb3FWjejMf3FWKVlNiWp14NzVAvtx6Mxv/C3fp6XX375yG503qmfr3m3XojaHMO6B/QhY2pq8RwoSFlTcJ2zRzSj+hFRh6fVFNV6qjzPn5hfrznIOBKKuxp4+J5HZUxts2prm+E/awkhuHvrBt+9dIk72/fYHySMxkO+cX2PrZfucnarw5MvPM6Jj/4Ut64c8DsX3mBp+DnidozfaBO3OyystbGTHlK+m0c/pBjt3eTg5i2C7fsE2ZhX3rrFI3HMiVHM2fe8i/Mf/wnyxirGb/HypStMv/hVOuE9No+fZu34WYrJ6zTH+/jRGoGOWVQJh1XGrekCJ574OBe/9Q3Ov/Aprlx+mVS0kMuPsH3hKv/+f/iLXP+jt3jruy/RXNri0VPPsLUUH13PspzdB7J2fmo3Y158fp3f+p9/m/1kwPnFcwQm4valIeuPtdk+NLTiOstKBgKhBG5imPT7FF7GTavJ8xG9OOSx3ibbk4qONrTDmHFWcZBMqAaH2N1t/nD/Fom3ShKEtMZDtnoDzqwvsxqeQhHQkR6RWkTyzpoO/FnrBwIH3Z7h5KMhcRQhpCMzEwDaiw2G45KDicSFGlsELDQUFy/eY/NMl8VewEKvw6mtUyA90iJl4KDpQLuKxAy56ywrMuDp5eeYOI+w22Nx8Qz62IgLF/fYOP4YP/mf/TD/2z/8Gm9d2CXw+/zoT2/yT//pl9i7ndWOGaXDB9zU8gef36dv4dl3eeweQn+7It03jKxgfVVQBJrMOIpSIH1Vi4cDDzLLSi/gUECWSQpBXWg6wWR3Spo5hFYEsY+KA4rcURQV/xd17x1kWXbf931Ouumlft093T057mzeWQCLBbDEkgAJEBAoEjRUlsWSyJJKVtG0zT+cLZWrzJLLVS6JKpUoFSXLKjGJlsuiC2YmARCRIIBdbM5pcur4+sWbTvAf93VPDwiyYPkPrs8f86Zv377vvRvO+YVvKCcW3W4SDG8dItDg9rccrmx0ok3cEF6nkxnGWvpxQqdtkDKjtoFpUWDLmllhgZIZjrqo0FGGxpFGDeSm22pwcdY6XFlT5YF0cYlOv810d8B0OKWuaqLMcOT0GnEcM5tUBGsJ3oLI8e0UKXqoWhJjyZQiloZiVjPMZ/RWl0FIltcOoSOFq0u8CAzWSyJV46M2IU6IexlBp6xv3SYzXYTT9HsJ7UwQaY9UHS5f2yBb3yReiRvXaF+T+QLnNNOyqYpIRZNQtBK01uxOLGklSTuaopLUEqSRFFXFxZs3OX3mXtKVZdZWFwmV4+vfepPj3YTRtKJrHMrMz89wjPaOk8cXOHJyjYBkVAQ6acRat8/qYooyCiW4Ax+aj/1qjAwQ5hhdH3A+YCuPwoN1uLJJEEzWuFzvATC8840EnvdNC1nLBudKk2xIEYhj2ZA3A8SxQKtmItdKEhZT7CzHBE+UaKxzBO8xKuBrWL9+nYlIOXxshYWOwfgSkcUcWjuE7Gsm+YTpcIgrRxzrKVxfc+m6JRaCEofUTdKSzzwueKwHIQIjD28OSq4+c5s/+rt/wNnjgbPkHDkGmgQRdegeO8PO9QG6VnR7GTdvT9Cmx8q59yMXL7H9+uu0C8ulqeVK7vjSH1+nv/11PvgPf4KPLK7wn3zqHnae+EFubTzL5be/ya//iy/zyR95lP7xo1x78yo9nyA7KwymnrXVgm+N3uD0/Ue4uHOZWf8kxYUWX/k//wum8iE22ou88saLFDubPPGhx/np/+zHkNIDiq2tiu2NJkFrxY6eKuid6XG4EsSDDR44f4b+0n28+mJJyK7w9Esp548t00o0uqUpfeDSxSkPC5iYlDemNZ3OImcWV6Ac8tRT63TWPJOtFs89/Qz54Aqq3MAwo20E9/3wRzl26gKL7Yh+pllIFJFpnLA3prskWlNWk33in/N+XkwIBOmRWqMjiQglRlnQMUE20sgBQQg1uJy01aIupvi6xNsSX5eUtacSAkkNroEqaKlopxnKS4QoGRczhPIkscbVAetmd+5/JTDmTnCyp73eyDPeTW6VQlJbi/KNvKaUEQRJXTrKsuR3P/tVfupv3ke83KUUDicgFZKjyTGqpFFiC4vnGecVr7+zwYlTR/jEf/hpfumf/y5X397g7PmYU6eX+Noz32ZrvcTVEOpAWytcXnF74ya7AT74eJ9LGzHVpmW8pZEq49hRi1k4zvLKKo9f+H7uv+fh74AUvcvGQR7AXoLw3Tobe5X+u/622afp7Ii7tgnEfhDMARnSO0pDc3IsBzqle9wE2E9Q9vknQswTh4MdhXfnaNBDzfyt9tHdB37JQRhOYDadURRFY1AWPCLsJU9iH4J68AAHE4MQDgT9c0jpwX0aE7rQ8HW0QmuNlE2yVRYFZVXivJ138nQD+9pLBPZ5DhIERJFp3uPPSA4OJnwf/pEf49EnP8Krr7zMv/xn/4xy0HAp3765ydWdEd+4YVl6Pufhs4HzeszySfDWYLpL6PYSxXaOtIqknbC+OSUyx+meXkb1rzG99hKtyYR3BlMu78xIdp5leSPl3Gfey6k046MPLjI9fY7h+A02rt/g9p+8zr0PniJbXOH2jcusqIcoQg8bctppwWvlbY6fOMyV7ZvU99zP+OKbXPn6v8O172OcZLz60kuk1vLE+07zvvedQsxJgdOpYzoOaA2R9MQ6oNqGjgO9s8F733s/Ui2xPSgo5ZCLNxVHl1oYI1FGMCsDs2nNIQKFMlwrHAtZh0WTYEvLzVsz4lagKA2vvnMZkW+g3JRIWtLYcOzCBfqLx0gjyIwk1gKtNZFqo2SE5g6n6P8v43tKDhzgpKOqC4a3RtyaWuzUIxRMLRTesDVWrB3vkFc5q0d7LLQSusbQkopiMmYWHEVZEDoRwt1GBUESYjqqRR46rCbLbFioQheZRHT6Ke98/Xdwx36ER07+VRZPb+Lf3GDz1pS33rzOPR+8l4/82M+wXRtwFlMPmG69wR9/9vOoaclrzzgqD7WX+FjiKs/tocdrxywPqDhqGObOMZ2Bs4EidwQp0KlGycb1uLCB2dSiEtHAWZTGK4WIJMoJdBSIY9VMBF4hRGA6rvCla8xinMOVHlTjutvONGks6bQjUIbSCYgVxXBKtxMxzkvqylLXY5Qu6XRTqlkOrsYL2XQGaoeraqRSGGuZjMeUVUUQzHkCitlogo0cWkY43+wfvMPSVA2dcGQLLdrtGKOah8vWJUVR0IoC0uY4p/AhYJUgSiMSpZg6R6ubkS6k5HlgZ6txtY7jDJUmqFSglUNKx+Jyn0leE7sK7wO1d1SVoAoaW1c4YQlKIrREiYB0loV+H+FqZKhQqgm8UQmTQY4UEUoLFjotlI4YFyW61cYWJcVkRll7PJrYRPR6bdqtLv1+l04SU9lA2lNkiaKfacxckUjMq6R7vL6msTNfROYFNO+bRXe/8rOnBmEUOprrkdcWL8S+46VUTSCHhGDn6hahgWzUlUNKQRQ1OGCtmwUDH/C1pcxrVKyQvjGUcsEh8PjQuHQHpUikR+CaqpS1TKc5eVlQbu9SBo/UEXGaUaoBkVEk2rI7mjHKS2xwVD5QzZsbkWxodGUIFDZQTEomV6/z0fMtPvmJD3Ho8KN4schoItgc1ZxWI6Z5xrRIMKIm7Sbofot2cZ3TD9xL78WnWb884Pp2wW60SHzoEb7whznDxyUXjkR0pODEylkW0hV2Zm9xfdTiUFnz8HKbYnaD0c0tVkTKi5OS+8+eZdrr4dYjlmPF4bWIF5VnWhYc0ZpCdxmLNjqOWTnUXMhqVvDO029x+OQKJovIB7dZ33yR1rFPkxlDqXt0tadfDajXL3NxW/D+x9eo45TxpEKWOYmEY85w3Q2YOAdW0goVURWYFhKVwGzUYmfXEqWetd4RDiWH6bdK1ha6dBeP0kk1/bagnXYxpoPzJWVtmc2G1BWI4FDzm09IiZIxJlisd3hXYyuL0YIsa2NdjncG6zxKinkQEjcyiBLKssTZGuc9XvhGwCCvkd5SW48NljBfNIsqZ3c6wXuLEJ4gHP5AsCnVnjnWXKkFmqTEN9TUECRBirvMmrwPzRwYGo14poF0ZpDKocQuWkQYaRAiwhKxEGXsuoBP+kBMsXudK5depXPqhzmx+gP0Tn+Tm+9cZ3N7wPLRBU6cvYcL7/lRhjWY4FBuzGDjMm+99CxmOuHpp6d4CXHSQaQGV1mKXQvFDq7K+dGP/TUWeovfZXF+dy7WB4P/g8pAexj0/Q17L97j51XJ/cq02IfW34G67F+z/YPPIZDhDikZuENInsOcDnoc3LXfXQ2Jd9Wwe3PxPKC/60of/NDzpGyWz6jqqkkM5iTivVcIBDGHoM6DvKqq5rKi8oBPBHsidohAs/Y6ty8DvHfavPdYaxHC7UNYpZQNdBawziHmHeg7/BH2ZUyDb5K8+iCv4TtGCI2RqkeQ9RZ46NH38rP/zX/LZDzm1//5L/DOzdvsFlN2iptUvuCHHz7MI49+iKx7ClsnzCpN7QKHKKnqxsk9FTWmnRGMp3X4OP74SZK159i+us2NQY44dI5hdoZnXqvZPSk41TNEWrPSP4cMK9yKhwyLlLa1nOq3qSeXSENGLjQbReD44iplliF3BYfamrQbYbViVtf0pWRgOuBzTGzIsma+cbVn6/ImS0f6+OCpJpu4UNDOzmKUYqp6nDKCrBwxnBl2rOTMyTa1Mvi8RtSBGIEOMPAFpQ8oL0mxuHp+TZWgLDTjPNDOYKG7QstYWhG0koQk65IaTRqB0VkjTIJAyYZL8O6cZf788T0lB7a0VJMcFzxbGyO2JjDZsRjlsUKQW4VVJdlKl267Q6etaaeaWHl8XrJbbKLapiHHpAFrB+AkqTSkQjDiPmbCokWElIZgx5SDy6zG64RgKORRXNIiRILpzHN1Z8aTP/pBFo5+ikWV0dGOyO5ye/1NKBf4yuc/y813hkgt0G2NSATeV0yHAXD4IGjHAmka7GU+rfEOxqMKLyUmVkSRahQ/lCBuxThPIzkqFbYKBOswRuGDaTTx521bIQRRrJub1s+x6fPg0JgYE0VkiSGNFaVrgkHlPO2WIk0NhQ2N9XlZIqmJtcIHMEZS1x5Xe4JtFm1tDJJAOSuoaouQTSVOKBjvjsgyj44k3jqk90RSohx4YbHC0e20MLHBlhWV9dQO9HhE71AXR6C2Du8FdVkTJSmx0UxHxbz63VTA0ySmFRmE0njVENxcmJPgopgwKSjGI6qgUCYmjiVSRSDBGIMIjXOrUREGgc4ilKBRgMLNJRptIwepYDoeUI3baBGwtaTTbRFsjncVIkRYH4hiTdrOWF7u0coSEtOQ57JE08k0sboz2cJd3fk5+Y87/wjmAbjH1o1MGfOFVuq5epFvIEhuH7PbHNuHQLAePCAkzlrqys8J3Z441WglCN7h5lClclbhnWsMcZzHuxpBQOom8QzSk3YyhBGYCLyvsXXBeDxmNBlSTkYgFbHR+NpTTEtUWdFTgXVbNQ63rjHEairAoGjUleU8ami1NR/9xHE+/pGHeOjDH6JKzzPeLjC3btEOMxb1DJtJorBCWzmEEVRZzOqZBzHyHsTRUyzennB0aHGmR3z4YZ7byXj+Skk9sZw0lr4SKNXm4Qfu5eL1nNlgxEraIh7eJJsOaYseu5e2XEw1mwAAIABJREFUeID72HQd4rpLlCpakaDVPUK2WXLlS38IskXc6hFFCqNhlpfceOV5Ih9oqZThZs7mzZusLQHe8soLr1JNJyQdgcpvMRtP6S4/xkra5uroJt04oKKIIAS5nbFOhdEJqUxQVHgvCSIh6QluDxQibHHPquJ4J+FQZui1BcuthMIVpLGnpSSGhgMkhEZrjfYFwTZGY0IqbKiQsukQIcDoeO6yXaOkxkQtQjGjLmf4YAlSok2MUBHO100HTkqsFNQuUNoKLaGoarwrGh4DDicclTYMRyNKV9CIe3tC8PsVOGi6AlI2sNA9da5w8N4OTUeVfWWcOdFyz0HWWWzdQI6UAucniJAQCYUUiooVagEmSG5v7aLqIcoP6aclRV5j26vIlqEykoGzjD08cPxBFpYfZyoVXRWw9YjN9RMEn/LKa9/k0is3afdiFtYytFGU9ZTxliWEXbQp0dpgtH53V+72zjFNQO59uCswnO/0HcF42C9qsMcXOPAVBQ2ZXMgDCd8eXGn+j5R7pmlz0Eu4Ay1rtu7NgwffNbwbKd37o3ZzD449/saB/vCfSg/n3y2OY+DAvQ77EKG9yn+TlEuU1lhbz7ff3X1gr9AT9roGYT9xuOMv4fa9E0LwKKn2OzvhwPsdTNj2Og/MIX5NoerP79w0ijueWzdvsrsz4PCRo5w8fZrXn/s2t37/8+SjEYcOZXz4w6d44OH7WbvnPZRyDXYHmOkEZUsyWRC8xIQFUlVhlUIkhjjpIjiGWFyldWpId1JhusfwrVNcLzVXBxZZOZZlIJIKE3VZWcnYHVeUsxkdk6Kn6yShRpWK2TDn2KmjDEnJSIgEpHFK2lrETnJuvfAsUW8ZhuMGRi2aWGm8tY4WkkiWbG+MwU5pdxXeWm5euY2oKyJR4iebIBfIusfomoitfEjHCERo4GGFr5kKj5KaSGgINT5IhNJIKRjnAhHGHF/Q9CNNFklSI4mNwnmLURYjG0lSSBDSvOtIxv9vxvfGOSgsfpyD9BTzRuN4kDfqK6qBJVQiZ2djiRPnjxIJS2wkwjqqaUGZW1azJYgVLghm+ZRZrMm0pnYDlDzJuhvRFj3iKqfcusTOlW9x332L7PoxNzdeYHdrm6oI6FaCPnICox7g0pZBtCLiTBFkC7+4wn/00+/j1ckVCn2N6fY2tS0h99gpuFogPYioqRpLIQhCUleNW21VOEws0FKgtGRaepCSOImoao8wGu+gHNX4ukb3UnQVmuqyC/i6qb+prJHHLAsHdQDXBF9aQG0lSmlCAFtUlKMSVzm6S01woKWkDhIc+OCwZY2MItI0UA1n1NaBF2ijybKESAnqGryTBC0QsUZrj502V2pSWYSHTMpmcQyiUVYwBqUkeVEzHZeUFXg0oaoIQiGVRtOQsMqiJkrTRmbLFdiywEmPDYrFXkoWJxR5TVXPkN6BtLgAg0oQec9sMqFGEKUtStfCSA0mIjItEmmJohitE5T3uGBptQwyQJ1bXDGlLnM6sSbSgsFgC6Nh2Tp0q0/bKFwwKAXdfos6RCRpSrefsbjYQgOxaRK21CgieUDJw8E+mQCBUHf9tE8I3GsNh9o1JkJKIyT7LspuPlF7F5rqqmhIY7ayeOcxWoAMVEVNXYXGM0PPq1FVPdfU9lRFTT6rUUYjEQjvm46KUUgF2IBUkHUjdBYRxZpQW4rZhHy8Q1EMCb6A3OOUwBUFVJ64qEisZ9lovA0IHEp4jA3Uc5UmTzPZLnQiHn7PEf6rv/sJHjj5YXZLz5Xbt9m+9BLi1lv0FxXD7S1yvcpyryBSllk+YzY0dNoP4Xvn6Dz8Xtrvb5MJQyoUpQyo2zlX3xyyftODSrhRbxDLWzx+7jDXVYtNtcTNjRGnpxOWfYn3hs6VglujTeozp2gfjgjKUJYJaatLazDkq7/8v6FWfoC1TsRyW2KEZzge887Lz/CeDz6JrXNuvPkmu4Md7nvsSRA1X/3CFyk3LyFWV7DESBG4cP95JjeuU/rLREttMn2IqYOLoxuo1iFaKsYrRQgFRBkm6lOJiqA2OL865N4uHIqmtBDoMgO/gQ8VUXcRKTXB5fiQY8UKAUeqAnVdIRuJIRyeIA1lmRMlKdqkSJHhbIXzoZFQdeDrHLwDpRBCErSmqiq8pyEEB4GtGuPAKDTJfZ5P0Y2hJ5ZAHiTDyYwkBldVCCUb74MDhGQp5yZZAkSQeDdPCIRAinBXECPnibJSBwLPEBqiq/eMB1NGkxGL/YxIBTwOQZ8xJQkxOzeuYPwmi/3APWdX2JnsMkinjHZziiBotXqI7jGUOsr6FHSsyCJJwSLtQ10e//AR3q536e9G5L5gVhtk6SkngbKUHF88wsLKMkmczqEZ3xkafhfYzl/QuKvKL0QzQd0VeB7Y8eCYT1p3mZ19535zgir+QPAb7gTGe5lACDTGX4jvCGz2qiZ7ScG8onrXQd49w7rQ8HO+66UN+8Wfg79eXFzc588IxD4PYK8rsHer7BGSQ/DU9R0yMhyAhe0lBgcSjeb3Yn//fR+FeafnO5WH5Lyb4P3cO2HevQvc+Sx/XrIraBIeay1b6xu8+NxznDh1km63y6l7H2TxW8/S6iY8+ZGH+an/+FP026cpXGAynTDbehnthkTGURQjarlIJ8sRoaSeWULZQoQ1VGuV9Nj3k56KOI5ECUHuPenUsrVdsrMbkMpg6wG91NFvtRmLmJFos7ObcaJqI6RGTEriGxMGkyH+6Aqmr3AogkqIk4RyPOHFz32OpcNPEvclnVQggicvSgbrNzh25jxlXjK4cZPWQkbcO4xzNW+/+gZqeAtkh9oGWm3F6qEe5c4OliFRL0MGzaTKmdoCFWUkQjXS8KFCmhZBaKyvCWrGkW7BkRgyWaCDQThJCDUhOFTaAZr7QqKRovU93q3vzvE9JQcmQBxHhFZDPHX1lElZNtJxkQQt8cKzfXmdt7opS6pgqaPpxZpIJEyLMflUsHAoISjB1vYWdTFg4WhGmgqOizeo/Cqu7nLxtdfZefNFslbFG90nOOVvc/uPfomdF69TDqF3bJX3/9hP8bk3Yg71aqIq54rWTEMgqz0f+r4OP/tf/yN+69qrPP2rv8Ltr32b6tYYnMJkiihRCCXQicIDVeVxKOJEo4wGpQhRjA2Ng23cgumwRMUaHetmcqVqJgbvqccFrUWBzCLKWjHdLRBYogR0ZgiVAOvQImC0xFnH9rDA2kCYdxXKsmZrs8ZoUGmz0GadFG0kcaYpc0sWSeq4cUsUUmOSmDSJGzy6UOhYUuNxShEvLdFf6BLIaEUSKkeYVeSzglnlCNScvP8cW1vbjIdjXOUwKiFLNCuHWsymFY6CSEIkFFmUEKZjvI1ROOJMI6RjXNSknT6lc6iqZLC9wyxY2mlMHgxOK5aPrCJnJdZJpGq4B/VogCJhWJcsHOrSMpDPcm7vTsjQaJmSJgoRKbxQgEbojKXDy6zvDBjVGl1BSzvctCIxGq2ajkxpoZVIuu2UGoWiwUu3YoXWe4oqTUJ3JxEI847B3RPt/qIpG+iQTPQ8EWy6T1LN1SL2WvY+UJce63zjiOzvVGTLvMTbBuspBY3raF0yG+UEIXBeYmuPrQLlrKQVZ0SthJoYcLg8Z7o9ocynpH1BlnRRSUSFb4LPrSssxp7R7pB8mtNeMvRXUo72V3l7MmFneImHF5Z5OQyJ64pIBlxZcrWSlMFTukYn/8MfPsvf+3t/mfOnPk5lX+LW9jPMLl5h2W2zcCTHSsFGMuPE7pvceO0rTKaKgGFSRfzrf/P7nPv+n2Dtwse591yLi04x8YL3rAVOd0rec95zq07ZuLhFqhWHOku8/doup9sJD505yfW8y/CdhFuTkuzIeR5bfi/P/MofsPrE93EiGrMk2qhOm9bKkG9OWqztpJTXXmJhIWI5WsGOXyMuD7Fy8ofYyBWbmyOE2eDo2ha3NyviQ45ub8zIFdyaKtbuv5eHTj/C5vVrfOOrv8Lpz/wdbs0cWVHTigIr+hBWrzDccLT7U1rVmBBp8ihmuFFyIXqRD5w9T379IqkytKIeLrcU5gbdhXMYEXC+IEiP8CmOgFGSTrbELASsHQEVSkBZ7+AD2No1SmTaIDG4aoKtxkxGAyJjUDpqEo5gKCtLUXuMMBTFNs43HYNWmuG8I05iKqsIskkwYimRcUroLuKxqDgB5ah9AeIOPEFriTZqDlcJNKZPYt79EPMnZt4dnKvaON/AnfbiLqmaDuvNyxtcun6Ffs+T9FOM1vTELWq/QF1qFvoFdjxlUCm20zUWZcHGS7/M+jtbzILmnqVzHDvxJC/vavqZIxpW3NSKqvYsRfDg0gIfe+RHefMxzze/+H8zeP0KbjjDKMXa8dP8L//9PyDLMpScK+vsP+fvrmAW5vH7PJoV4Q7ZVxwI3Pf4wnfK4HMjLb4jPg+NXwfcwTp75zlYFW+OLff/br8CfifCnW+fv2G424fBe7fPPXm3nM29zxHpPSGIOxsPzu5NbnAnMdw7x8YYtNYNzh/uTg7mb9AQjC22tiil5lCgeUlJ3PG5+dPnJDRcNA5e03mCIBuvg73CEuHO9dRzfoKdS9JKRGPq6d3+8b5zNN+vuVZxHPPB7/sQDzz4AG+9/jq/8au/yje++FWSdspf/4mP8f0ffZxu5wjWbzDJr5BUPbLOJbCb1DhcNKafT9i5VlGVKVKl3N5JuLi1zJGHfpj+8fs5eijmzULQiWEphrXEcepQYNcZhreHdNspOlSMd2Ysx4Yjy8tsdRPG10HHPTr9Lid7Yy5/+QWWHnmIFTcmkR18FogWCoo8ZmUzobz0OourhlRO8eUOJqS0Fs8zKgWj3YJ2b4co8cxyR9SSZO2CrUnO9lRxz7330Er67G6uc+mt5zj84R9kc1LSiiq0kPRUG0vKdBxIWxWxzanSjNwpbJlzSt/mxNIK5fYtTLuFChJva0I8IY6XkIDHzb2VDzxn7+Zu5Z8zvqfk4PDJFkk/47UbJS9dGvLjH4owu5rL1zy3rtVMdz1K5OxcnlJd3uGx//LTrC32ULXDTkb0k01m2SJ1kEwHO1SVZWt7zHO3r3J+acTh1Wfpy4x/+/sDVpMHuP++93OrvUaxcIq+ucwv/h8T1q9aolMt0oePUo0e4S+fXcG2F/jSS46Zc5zsWc6YKT/zi9d48Ee6fOtfPcXgjTF2EiEDmFiycrRDaykiLywyOBIjSCMNwjPNa2QSo4xiZh31rKbYneJsio5jahdIlMaoxiV1VoHdmZKkUZNsRBKhA9W4gQOYWEHVBP+uahKJmbesncioZzWDsiaKFHErIVnuMh4M6PRjpk5QzSzKg/ICn1t8adkZeESkibIYpQwmi/FCsLsz48iJJarSMakqyqpieOUWtBN2xkM6/Q6dtI3RKU4ppApk3TbXr29Q5BXWNcz+VAWkCAhXUk+HGBVjIoOUDlc4DnViQl2TW0dVezAJWbJAZAKzrS2kBKUVeRHIRxVSlERrR3CtQGZiilJQW4H1NY6ItUWFURmm08UGT7DQ6QbGgy10cpgkbdFfXiFtd5jkTXK3UxtkEpG1WkjnEHXO0WM9RuMZO4MJN9cHJO0WR0+d4MhxzWIngso1zoPztnJg7lws9h5cmPuOclcVcb9F37SSlVLUtWsqa7ZRRPIBpBdNZ4CA8J4oVijXBHneNkmHNo3CUkgbl+eqsLjKEmSg0o3xyWw4xdWeJIlYSgx4i8naDQdhMqMYFxSzCZGJYHsbvdgnjmOMUqi1VRa6MTq27Cy+gq8tYTTEjydUE0cnyvjoyZMYF9ieFMTWAYGB1HRFYFdI0IJWFHN0+R5OHP4Qg+3X+Nwbv8v5rOC+UzUyr5kNR+RVzVJVMp14dAnttmKaehJj+M8fjvjff+O3+faXHuM3z67xfT+ScP/9gm89V+CM533tgm/fKFjt9YjzmvVrN+iIb3HxxgLnpsfp9yRHzyySihEifx55/0cw3+xz4/Up8uMf4MWdhK13Sv7mj/4DfvJ44F/943/Lt2+/QrsbePa1K3zhp/8Jv/hL/5Qju1f5R7/6O/iFm7z/0WOs3n+BUnhSb8ieWuf7P/M3cPowW1e3ufrF38ahufCx99LRhu3hddzGbVy2hHnoI7x98Q3uuWeXSiwxah2nJiDHF/lLXU3v0EM8+9uf432P3cu2X+K1axPE8G3aZ1PWJt8iaXVIooxW+yRpb4FELxD8jNqOyeIWLmphXU5d7SL9jOACUZQggqDKZ9TlGPyMarZF1lpBSo8IgdpLprWlzEdoY3DBUtcOpSRJHGNDRJ4PSZUgtPtEUYScBxNBJXQXYnZ2bzRa3MEyLSpubOX7832WxSAEdQgYDe1YUsxqqjpQ1QEOaqy7QBTH88B1D+ogKIsaE0Vs3t7l1acv0pEV4aRmqTUlTQ2Rz/jac7d4+PCTREcfZUu1UUmXxbDN3//164xzz9L7j7Bw+gwtc5IziwbiiKduCKLMcUQVTDaH/MJzQx794HGe+sLX2bguiKuE1DhOHTvCz/z1v0O73UbOK+DiT4WH75aQdj7CnXi16SLMA87vaG7IBvM1h5YccCg4QDTeg6TMD0vwB3X55wmDlPtnQck7Ccj+3+5VqkPY7yLsH1sA3PHGeLd0X/bGv+/VXVpaotVqkefN82Dm0rcwT9zEHb5A01lrVISYdwCaDpva95RwYe/87X2w5j/WuX3+GjTH8MGTJilVtcd7cPsNHyEEZi6rug8lCuEuCeK7T0DTzRFS7ic8aVbTbbf55H/wGd554y2iNGV16TxpvMJkepuruy+xpMe003fwfoOy2kHYEakdUxUzdC2Q7Ra5XuLIYsaxU4FvP/01Xnj6DOEex0c+IPFV4NLAIWXgWGx5c2A51u9QjmpsuYkOtxlP26wUS3QziE+souwOQha4hSPEZ3psXyngfed49u2KJXOa9z1+L++PHU9/8XleH1yhvRTx1S8/x9JrN/nkpz9Fazrk97/wHOnqNg/dc5aks4gToGtB9OKAj/ztvwZVm1uv3KLavoZKDWcunCFBsDvZxY1G6OXD1L0FNge7rB4qsLTJk2UKW9H2JUdSQRSvcPWFVzl970m2yph6OkSJKXFP0/Wb1BVEuoOK+/PTXwAOoTv/HnfiX/z43kzQRiXVJGdExYqpeX3LcLk2XL82ZbRRUhceECRlTXwm4pWnX2B79RDLq8c4tHSclcV7sXabLzz/PEdPr5FlCZu3Nnjt5ZtsD3Z46EnDaGWHB0/2qfwtrlSvMi0Oc/Vf/Gs+93tfZDCZILoRvQsfZu0Df4PptzV/qAzTI/D4hYxW6pE2R9UFDyy1+PIvfJbJyy/hJ7eRvkZ3OySxpHJghw7hwUQGh6JwkiIvKHMI+Qzn2a/6SunId3OyLKV/qN1AOCYVrrCEIEliQ5SmVNbjZxUEh/c1SS/CCd2Q/XwTZOosRgvwUlAVRUPgS9qYWOGCRaeKyHhmVQWuIRwFASo2qMpT1NDppUil8EFivSKTHiU8uzcHpK2EthS0jMFECSLLONSLoHYYadDKoFTKcpLgRI2e1OhgqEuBJBAlBjceUuYZeIc2JVFqMK02uvTM6gqVxmgivA3UHopijFSKdq9LhaMtBe1eo/evRMHObJerr0xIsx5xp0+UxERSI5M2o+kIWXvKytBqx3SijF3vaGWCt199i9FyH2USTKzpdGJa7ZjxrCJud1BSorTApIp22yBkiyANWM/S4RVWj66RBLj4xjqnTh1CqabSMm8azNvhzQ/7C6+4a5llv6IEDcbUaIIAX3uEsNRzZSohFHuumEJBXezpVTekzaqomA6rfRfkKDEoo6lKhxTNImPrqiHHe08+nKAmijTV0C6JZMBSEmyJQtNZ6jVKFrZm9/omzoOOPEoblPYsHjlJPdxhsDtl8/qUrXd2iHHcd/4Im+sjutvbTKeBOgSWZEQZKQ63YuRai/vPnuLx9x5md/Yiw3yLJ4+VIAbY0ZSyLChw2MKyO4U4DRx/LKJ9eBHdOYoVRynGGf/puVM8t3UP1/oLHD4U08sE6YOaw7rNV7814lSvTZVETNspdWx46tmEH+hs8E//3Zc5+0Of4oGzRzHVNW7dusinz51Efvq/Y/cf/iwPPrLMex59gvYFz9GjbUws+Cs/+zHuecrTXWjTPXKaXK3y+S+8zYu//j/wt3+8R++BJ5jmJ5g8P6P49m/ymW+9QGf4In9LT2g//AGeDVM+v/smrd551geP8Adfe5n3HCsRq2e4mabEb/8u73vi/aQnHuUbtxz3dTXHJpvowRVEdJNr77zNo+/RXHzrs7wlO9S9I9yzGFHe+BLh/AUW1A7RTKGKXUR5E7HSB52BL7CuwoYK5zzWx9ROUU13KScWk7YQUiIFZFEHURfU3lLWNVJGDbCjrhnubNJbXKCqcpzQOBHhiNBa0G53yYsJXuiGN+Q8s7rGhaJx9Yw0Za2xPqDjmCOrC/vzvUkNR86scOa+Jdo9xTN/fIW1s6sUuzk7myPKMqCVIpJw7Z0NnGvmTKM1Sut5NbkhJvvQwpUJ12+U2MEux8QOh84lFJ3AwyeP4cJlJmTMJoorf/I0v/mlz5F7S7TaZ+3cD9KJH2XzzYJbSUq1pHn0rGqI1GWNabU4vxzxe597ge3Xr+Cm25xYXuSHHvsEP/jB72NpcekuvHbzPP+p+vG7cOzxDprIcA/mKOVc5tSHfeZB0/W8I5e8/3IX7GSvEHIH+gV7ULG9oJ+5gRoIvyd9Gu76RAdhY/vE6DvEhHfHOBAriwM/f6ci3Z/1eX/+53+en/u5n+PXfvXX5l4EzXYpJH4uRyoPGM055/YhP945alfvk5j34EdNLhfmClTN9j3/hDAXuQBQUuGcvUOADmE/GautbQpO3iPnML5mHVTf/YvAfnIH8263dRilWej1+B//8c+zfe0SWa+gqNdxfsbJniaEHWw+pvYzrC+xdUFZO3QEi+f6RL2zYE7j/RK2avHxY8tcmy6y2YnotSSRgm5LEQfNxZslx1sxpVboxWV2BprJVpdTesxvfOEp7v/oxziuUsbDAUpaTh9bQ7z3k4z/17/PvQ/8T/zgvV2yWNJqaYwIPPqx+1i+WLGwvMx7nvwQRaV54/WrrH/zN/jEDyyhVx+jGLXxbwy48cYbfPnZd+iOX+CT3YC79wGemV5nZzwli04yGB7mpaev8/7TltHCCWw9I5tc5fSpI+juYV7Z9TzQ1vSGO0T1Lt7uMsq3OXZScfPy57mZHqadLrCgCuzkOjY6Tb91P364jah3IZGQaIR49zge3xnfW9r8vXUOupLDSw7Z9hw/2aNIDer6BHlMIypL2PS4KpBXgWu7lh9Y6eCCZjCWxK02y92jTEXEybOOvKwxXtKLVyj6Jc+/ss1nf2nC6VVYXbbsiAFXZhts7rzE4O1dxlsTQgLmUBsROozfzLhc97j/iTYPHTWs9BrMbOEStmaWt9fXKfMh3g0AjzAxMgqNoofz6LrphCsnqEsovScfW+qykRCLUkkjS9qoMSkjyWcV0ajAyKbdqzWI0mNd42pry5py0uDLAarSga2IpMREuiHviabSPJ05rJBkmcELQVE54jgmjVOGgyk1DbbX+0CZO0JdoeIEIQNGC7xsFG+kd42/go4RRuHxqNBUxX3whCqnt5ARiQitOwQfYStLbAxBaIR1JNIxtDVlZSHETaLQbdHutpA03APvm2r/ZDSivdCndjW1bSAoJlLk0yFxnGHriiyTBNEQrcfTCusjpGk6HME3XZRaOKTIAUk+2kSVM4pZSqQk1Tjn8OICddkGMXdqdb4xKekYROWpS9vIMBpLLSLaC4YqjpFOkqUepXWjDGUEofZMB1PiWOG0mAfzc9zx3qIp7iQBdw2xV32aO1nODc+UUdRF0cAtpIAgmzbz3OxOigZnCqLRiRcBWzdSpOjmnBmlEIlo+CPCkkaaMlgwkqhl8IVjOiuIXUyZ15TTmuAUOs0auUshcXUjbxucJ9SWym6hF1q4vCLfHiOdp5UqClUSVwK1s40bBcpSIINhQUBmDMcXWmyqihtTR9W1lN0B29s7lPkWS6sDBuMRflaDDZhgMKmgrktaHYOULd5+zXL75jW2b97i8sAQJ6/xxN/6K9xzTHDNCt6YCJJIcnNoOXt8ldzVXLtc05KO84ttjt9zD4Mrig8/8X28+tpFPvfUOySrh+le+En+53/jWf/2v+RCMeXi7/0ynWrAsff/EPm31wn3LxP1j/HSV57nvY8d59w9Z7hhFZ//+p/w/Gu3eOyk5bGHznDrtWt85dd+i+vbI17cmnJWFnzxjVfJr71NV3r+KpaousX6s6+SRA+wwQVm+ZA0vcLh8xHnj63x+VlE8voN8nqHSl+nJd9mzDVOH5PYepveScd9foKqL7FU1Zj+DHn1VTh0AvIpTN7EyxYh34RjT+DqHIQjVBMCDmMaeWGNpqgBoRsCrWm6mkoq6qLEe0vQCqRHi4qskzVhpFRIHaF1hBQCbx0oQW0DZWmplQMJLjQVyxiHNBFGZMhQ4KVE9dL9W7+/kPDEx05z74UV0kxz3+Onubq+wcUrE6ZUFJslRS0IxnD6sVNsvr7NdFYhpSGOE7RS1LYmzSIOHzvK4uISNy8N2HIjthcFb72yxSNrluVlz1UruDJ+h/UNGF2dMtgc4vua7rFVhF1gPO4g4x4nj8YsLigyI3BeUYiY3VngSj6jqKbYMEDKiI88/iRPvvc9LPWX0UrPH+93WQD7Z4xmnrmjTiPuAszPKcB3dRXmWgd+DjeZB6xBcKDiL1BzI7O9ysgdCOW8ai3VXTAIDhz/rk7qXZ+1KQiKu/d614w98vyf7cLw3bcXRdEoAkmB8Hf4aXuSoXtJwZ66UFChWW/n/jd78qMNyV/cUY2aV/L9XDzA+b31Yi/JsPv8BOfcAcJxmKsu3SE0S9kkBvt+CN/9BOy/1kWJENDqdDh573m0Mc39cuI4ZfUOVXFJlIAaAAAgAElEQVQd77aJ013yckSoi8ZDQcRI0yUEjYm7CJa5eWXCZONFBgPJIE+J00M88PHHWGvD9QqGlkYe3MJqr00VHOvrliMtOJq2sIuSclfznguP8M5Lb3NxpuieWkMvrvD0HxfsvPw13hcbrn3ldzj3oY9geqvU45qwmKCzLm9/9Sk+8KknaS0eYmdc8txrF3nz+eucPyE5fOIwb3/l81x/4Q0ubUx5dr3kwbjgpaefYevFP2HNCE61YsTkErNXn+NC+hAbnKHON+n1axZXOiy0W7xZKVq3JszWZ/TkJohNnBrR7wic2yVb1Rz3I2I3IaVGxhVieA0bIuRsl1AUkCxB/xyid/b/w138Fzu+p+Sgu7jMoSMLKDfkWGdGiWHpw23ePtvmmS8NuPTUGLvRKFRsrVsOLS9R+ojCaspSUas+uqVoB02Wl6TSU4gh29mE2aFlrj+3Tj2tuHJpxm4d2MoDk9k6oRQEZYjO9OidO0y/s8Ribjh9ocW5kxG0BFrCjcLz9o0Z15+9zvVv/BH19YuEqkRHpoH7SIstK0CiE4nzlto3vgTBBarcUlW2IYK6+SQp9zJ/gQ1QVw4Pja6llEglcLYhmdqyxlYN5CROFASJUI2cnghzXLqUBCVwoZnQrfWEop7HpwLvLUVhKavmcyokQslm0ZcKpQTBeWzl8ChUZKjqQNxKMSqgpMfXFlvWBOdJZYK2JXGSIaTHi4CMNGVZsNBrUZcKO8uhLpEejBJUOkb6QGEFRht0kAhbI2UgoHA2NBwA4UAqhImw+QiqAolH2kAdwHoBKIyJUGhqB1VVEbxA6RilI3Aea2vsnMwdR4bERHgR6LZSprN5siYlSjaYfCMNtnK42qKjBCcNW5OSMgiOLraoZlVDjp1MyCONdk1CJZjzOwIg5B0j0QNYwH397rtGmLfjPd45rPVoIxtJO7Un+SjAO3xlEZG+s5aKZhFWkUTVkrIKSDxKCdBN29kGGmdmAloLZFBzfoNECI0NYK1DmIikF6FwyFAgdIR0JSbUSC0xiaIcVUQiJt/dRJYTNJbUQDcOFOOal28MkaHLmsg4mvbJZJsy5GRxxLn7V5APHKF93xLdlZKqvkQnmxBEThCWMK8m+lpSWUXHaLaHmvGG5Y0rlps3PMOtwBsDSdKaYr/4h/ylH/sMq/21hhQfBCJWKJmR+IrjhzU7W5KXbgYWU4nN+ty4fZGknHJzPXD59pTucJdy4yY/+cj7OL78Xl5+9hvMtnaJhCHIBia4dTtw4YM/zOjaizz1m18lPvcIH3rsGN/6vxzv7CzgvvwyLz7/Ol9/5y1qrfnZH/84q/eepHrht/jK87e5smWZRJJqNqDmNg8u5syWF6lPnOT/oe69gyzL7vu+zznnnhte6tw9PTntzOzMYHeBRVgsFotIAmAmAqNkQjZDySyK5VKpSpJlS1Vk2ZblMs0gli1LJEXSMimCACkSRCAJEIuMzQm7Ozn1zPR0evmGk/zHfd0zs6DKKMs2gfPHTL1+79733nn3nvML3xAdOkS8b5ZcpORfO8v+62dRbot8eoCe2aKxdYFbF5rctD0WZ5vMxzlNclJliWxFoIlbXcWrmljuqaC8ibn5HDZuYJ3DuxEohco0WqXIuFZVI6oV0KR3OFdQVg4RAnHSIghVdx28I0laKBEQcTzpEBicKfDOEpQiH4/q9cYFRPBAHbCYYEEGdBwjCDgR0Pr2tX/o6H6OnDjIoUNt2onl4L6IpRlPEmVU44rhqMt43WKEIJluMjfnSLMKJh4H3nmU1sRZwsL8ImncYkCOjQJ5I2HjuuH8tQHnL17n6tCyOg4MC4GtFD5pMHvPMvOLi0z5lIVIs7ycsWtGI5LalfmqDVy9ablycYML584yunUTUVmq7haL09Mszs0TbTvVbn+pb7Xo9T86Xh2E37VM3V6jdmK/29Xlu2ROxQSOdMcJ6lrGpDhSv6iGW04gMa9e/257QtyJa7qD9LCtegSEb7Ia+f/bCDVHgjtUuO66BsKrH9ev+8hHPsJzzz33DXP6ao7AjqToNryO27C6+u81lEtE2/Kxk+A+yJ3OQp3u1c/Vrui3pVNvnyfsfNRteNE2z8MHj7N/zcxv/y5hIpDRz2u+WzMlm6oLbz4EZBKTqCWUGmHLFQJDgvD1pwoa72peiZYp4zyh2Cy4uDJmtO5Y34TrA006VVHtep6H3/h6ZpVgFAQWgVQKKQQ6CJamJd0h9AM0ZCDEGWsblpavuLSiuDGsSDtDdGl4+NgRDkzv4fwLr+AKg5yedGmkoBgIDt3/Rlafu0yybhHTc+xfbvP1gefWYJri2Zd57tkXuHrmMvHULN///W9keWkGdf0zPPflW4w83EgklZLEUYOjexz50ix+sY2am0G2mxgvMJc2WOqvEkRONVUgZBdG1xkUKX0/YKbTYUpsooUjEh7pIaDx3cu1sIPwBJqIYPnWUyv65u/Tbyo5kM159Nw8TeeZa+Q0lWRvM+XI8ZTcSNY2oVzrEbwg33JcuDzkvtPHSJJlnJzDyAaNdoN+KWmmIDAUISVMj2ifOkXnwoCNnsN6h0NBkhE3m+TXV1FLM8iZDmrmILqxQCP2TO+JsNJxpQftUckrVzd48dkrrH3hBaqXHsdFXaRwiMaEvONDXTaLZO0W7GtZSjdp6QlJrbWfKLxgR3dY6QgVCURUG5W4iSzlNtTEVw6DmajS1MGiUKImviYpphghQ6g7EEpArHCuPr/1BkJtwmWkx1YG6wLV2CCEQmiNiBQqToiVxEtBUVhM5UBGSBnjrKfR0IhQ1dXkQF2Ndq52VB7kYANCWSLdJFIpg9GQmZkGToD1FkGYBCLQyBK8MxgnQURoF1DU8p1KxlhTO5/qRCN0hFOK4MEYT6Icyjs8AiUjkiQhr2ozJ4Kf2MNXeFQ9v8YQx5rKBaqqRARBa7pD7gVx2qQoRsgAKgAIHIHgFN7WGMokSYikYjzM8ZEgjmJ6riDxCa4qqPIxItHoRsTORjZxcCUIggSh5F0QI6DeVHeKZZPEwDissVg3IQmqSRA/6ToHW8+jVBJra08EqK8poSRREjEuK4Kr9eCZtJyFELWZjTW1BvYEyx1FEhlF5LmBINCpJtYaLTxm4LAqQkWSrD3xWkgFkW+SJhHGDoncmFAVJN7QTiTjquTa5pgTM/Msp23abgHFNJvVLXTQzE/tYfGtb2W0q81WcZ2qN6LVuUHhPVoJnI7wQeAJGGfQwVNYzWbh8fEU6VKbqhMzv7rF5pbly3/5FyzsOs3p12UsTrdwISJLFRsjT2Qids1KoiA5kwsuy5h2s82azWhZQZmPWVu7huk6vvddp/jwj7yParaN6HRoT00TN2OCSLj5vIOW455j38Gff+llrp79MqffNubtP/yD/D6O7oZjfb3LjcGAnguc6MzxMx/+UeLXHOXKFyzF/us88dXLnD17lnarQW+jYH7tEp3+K4T2UcqlU6znKe7FLcrPPUaVrNBZTjASNq1heWGO/qZhc+yIq0CcBHQzoFqCaJwg21OY1XWi+SmYmiHoBXyS0V19jmjmINZUSOmROsH6qIYCeo8SDiEiBA5vK6ytKJ0kjhQ6buFxeBz4hEhohC2IdIzxbkKUt3hncN5SVWXNdRFyIqtosd4SZEEcaZSQk2RfouVtpZR7HzjJ/O49NFqOKT0kEopsuUlDZQyEorsu6K13qUpFt+85sGeRXUHTbs+yvt7jxo1V4lgTJTEnTt1Pe6qJarSxFHhdMtUasNIrKMYlpY1BZohYYcOYZHkXanYXsrkPLRKy2NFogxGBtQLS3PD09R7nz66zfvYa48uXqPQA19tgdOsawtodydK7AUTfJtnBDu813AWLuStD+IYqfs2ADWJbSUjskK/vGndAJ+8MPG93Cbb5BHebNW0/DgD+dmJxh0Xat9C4g3ex/XDSbbm7S3xHZ2QyD4PBgE996lOcPXt252w7nYM7eB7bEqV3kZS3505O5iXUpNRtCdntpMJ7X3cNdj5tnSD4HR4Btzsek2s43LFf3E4OJp2jVykc7XyzEPDjAnt5C3d9jCsrXDtCHlhE724hdW3AJvQcUowQIcNNJFW9kgQkPtRxjwoC62JGVYHQc0QzLRIVyKKc3CieefxplncdYXnXNE2tKRCoSDDMBdJJlqYkpYFeKSmkII4T+jaiVcFWb8jo1g32LlU8+MAy73r0JLYRMywkWauNSiNcIRhc9ch2YO/RN/OVx36D5MYWex88zrH9izzrDcO1EjU95NYox7iIY8v7+N4PfSdqcY6tl3tcFT1uPn+BwaiHSDRy7JldOc/0PccQndfj0jm2RoLRYEj1/CtU2RaNpQZjZ0EFmlmDMveMjSPpBpT2yKy+LqSRyHQKP+iiOh28bCLSRWQydfd9+202vqnkoJAN8qhBITVdp1hoaPoeTqSS1z+8zLVek62XzuM2C3zl+M3feYpf/4WHeMsDDzJmhosDS7PRIYshShO6VU4/i4n3aPbtPcCZzz7N2nrB9OkZWrNNQjpHX+9l9ZNfID64G7Oas5bM4ZZj0FdZO7dAdkNxvR8oL23S/+qzDF96llBcQ0Yx+Lod78YVorREqibrSa1wFmKpMK7EVwalJXoqIRKCOFWYwtZSXQKEVnWFTUdU45JQeYStF2IhI4QPE5WIGtMeaYmMJq0+KTEqwjuHnOiYeiGR3uOtR8b1DRSEpygNobJ4ImrXrG28p8BZ0GnCqCwYV2FiWe/woSQSkwSlqvXEA0Cs0UGQJDHd3hjbHZDEKc22JW3AaJQzGJdUziPiFN2QUHpM4WgnEVVe0Go0sT5QVQGhJalXSAeOWrYzbWToRsKwGBN8LdslfKDR1Ig4RhMzzgPr67fI2h1iHSNFrafocdhqhCoL2lmDYHKqquZmCCKcjGk2FFkJZVFb2FsEsXSMcvBW0u5MkeoEVVkInkYrg7JEaGh1NM2mQkWeqCEwMpB6Vzd8ULVkpwehRZ3oyckifpuuzPbG50OtyGKNw5SWMJFnRNbJnhDUHQlfu2dLEQg7MKLblTcVRYhQEMJETzzUXSa8JU0TbAWugmBd7a5sKgrr6fdzOtMNElVzLJRO8KaFERLVaJPM1nhWfE4cWYQYk3USig2DGA2IyjGZAm0se7Tmte0ZWnIRNZrHFzG7rMEVU9jnNlh7TZ881+RRgvPL5GGNPF9lygdEFFOoiJAGmpmle3XMrr0KfWCaE51jmPQEq8Us1eVn+cKnLvD0M1t8+k+/xMY45sQb7sVnDapScqvnMD2Dbwb2TwsO3d/g8S5sjVs88PA7+Ny/+R2u37yIkpIThxf5xV/8IWQmyDy876d+GJ9XuKFhLCIe+4U+7/uFNq98smRzbQabe/KXnqAav5e9fox/5QVe9/M/CfNLmDO3+IHDr6P58NvJbw7Z/7Z/wk88HHjgE5/iqX/3m7z70cN85Avn+avnv847t66wUG5yY+A5/2IP8+zXiV75FDfnEh45eoxESYZbgeUfeA8zw8vE119i4xpctimrTjFlSzre02CKRjKG2SX03FGCPoiRDTZXXqBTNMEakqyBd4HxaAWEJo0zVCzwtkQoDUriiLBRo77efL3WSJmQpAnGCYqiXnONzUGAjFJAUpVjpE7AVgitcEFSGIexQ3RUoLKEyltUVHMFtLq9FZx48DSthYxKblIhyaKIpBPx4HSb/vxeVq9r1m5cwG7k5CNLuHeJh/Yf5sQ9p3npzEW++vhTJEmKjCLe9d3fz43NdYK09PpbXL5wlkTFXMgT9p5eYHpmkYGf5ca6Ye3iBaYOHWRwNaeMd6MyjxtvcnM1Jo4kKzkUq0MufvUig5vXwAxqCFNuWHvlOcr+xgRCcTu4/XZUCtk2ufKvLthPqtm3FYfqAFJuV5+3tfilnFS8a3jqTq1/pzsqdpInt+3OyJ1dgld/nu0qyHbgzQSuNNHd51s0+dqpoDNpm/zHYzXvPU8//TSbm1s7RmRQw4JuN1omAbuoFYWqqiKKIrbVoLbn/U5iuLzDIG3bRXn7OQI7x2wrFNUStreTQyEESki0jlBK0W618MEzHo9rzoh3r2qAhNoHwRjsxRXKPz4H6ymhMvjMkN+zhXjPQVwrBSVw0mGJcCxg3SZJkNhIYJRHaouoYqrRmM6sRsztZW/jNCOxl6IwjNeucOaFFZ55dp3Pf/EMDz50nJmFKYgUhRAMCo/LPcrAkWnJGMmNXJK7lOMnT/JXv/1Jbt06R6c1z71Hlvne958CVQelD37fO+uYyEHeFVz5fMWxD8TceNFQ2FnU2suY6xGNdoddZovquSc58rd+hHPPXCCRPR44/lr07oOYfsXMvT/J9x71vPyHH8d3V1g4MssLT1/hiWde5p2bV/DuNJs9w8b1En/5Jur8k2wsZbzx6FHMMMfH07QP3kNmtoj6Fxisa3LbJrWKhgKNIIuWiNII0ZpH6kVksgzxPN/YovqbHn/9Pf7XjW+uc6Acc0nMgtxFrKYwEcy0FiltxXsPztJ6n+JcMcvmr3ye4AWDqwPWXvwy1aHdLB06wPx0yrpRzByaY80KBv0hbiCIRl0e2hXxr64mhKjD0sNvZWu1z5XHLmAGXbLv+y6KP/lz/MDhL32Wm8nXWJtqIJu/gV/dxA0sMJHci5rIZDcqbRLyLXSS4kuLLR1WWFQCqqpozTSRiUTJCKE9USbRHY0XCp+XFL0SGUXErRhrPflWiY5qLwJvPEoIdBKjlKLRiUmamkGvJDhHpGtISH+jIkoDQtdQIKkkQUrKCjIpkd6idErW0Oi4dkUsi4JGKhFBgXOApbIG6SxEgvGmIWsqQtzACjlRMvC4coArSlwcTWQF66rzsHIMS0sIBlOVWGcZm8CYiK1CEEgwzkGIQDhyY3HlmGA97fklElm7rMZxSr7VJXhozc6x0e2z0S+RY4PAETVn6d68xaGDe2h1UgQehjlbvS5RWdGZEYhEo1Rt7DTOx4y2RpTDAYPGFHO7FplOY3SASKXYvKQ51cG7AmJL1GzSnFukd32VWASy6Tad1hTWRZSlRQnLVJaRZm1CXNJsNpGxpvCOxCu21ns0l2exI1PDeZJ4grGtN06FrzeOOwKK7Y23/k/U+RoBvMAZh3MB4kk3SIIJgkGvIG1HpGmM1ho7UXWyLmCtp9nQuKrWtneuJqNVFlRUm6dZYwCPSiTVpmHkRpS5wrYnFRwXsDiiTpOWFERxjFQBKRwyCIhm8VsjbD9HCYnTDYrCMFgpSUeOh+KEzq1VGm4XynSgBGPGuOomg/GYz//iL7HWarLnLa/l3g+9hT8/O+CNuzW2eIHcNFgbVJTWsbxrHrM4oqEV6fz9hMYebHSQWB5mcPC7+Jk33eA3f/2jfOXxL/LZx0ac61YcP3Wc57cyfviAxB/WfOWL63x5bDi1L+b10lD4PjNLMZ9GYGTCe9/9Bn7tl34R7wATCEHgAdcPmLUAEt77D6d55TFD1BR8/0/8GP3Lh3juM/+KL33+f+BpA6YKvKOUPHr0IK/5qQ9x4EN/F28Dn/qJZzn84Xs5d0HRXHyUv/3b76U9n/EPBHz05BsxVy/w+gt/yil9lk+85Hj5YsLJVs7e1+xmOtlganYG2dnHV75+lt17uuw98UMcvO8WK4Xm/IbkqWubrFy/xeuTMQeX7qdBk8zsJ2scAWlp7tmLHI3xxkIa1w7ZDBnc6qF2H8N2h9Q7ZIZIGnityA0EM6IqusRpE6UlHoPULYRMGA17CElNStcanaY4JGnwYARBJ3XlMY5JrSSKstqBXCoaWUqWKezw9obRascspC2iKEapeYIMNJIFKlfxroV5Nr5nkY10lov//jGMF5x7/ib/3Qffxv7DJ3n00Xfwkz/904yMJ44TBkFgsmm66zdZbAY6Bw/zK188S5QscuyR9/DkUxe4dnYNHzVoP/ouNr7wZcqupTr7V/RmO6QzGhUZzM0e+YYhyIgAqGSOuDELvuLm039O2b8F1t4ht/ptOIRAqNtE320oyV9X8d7+d9ugjDAhK7NtoFYfsR3Ib5c+wgTnfnuEuwL721D1eg2szxV2gtX6zWq+gVSqDkT9t073YPu3j6JosqbyDV2U2+Ga2PnCw8GQn/3Zn2Vra+suiKn3fodvsD289ztE5O1EQSDAizpgDwHv6gJQGcpJ1f82F2G72r+j+vSqy/UuYzMh0HHdKW+1Wvxnf+vHMKbik5/8JGtra/S63duhXgjgHLY/oDx/AT72BfToGPQTyCu83cTfWKH/9JO8onPM/DSHv+vN6CPTXOstsLuVopMmRf8MveEttI5J0gauWdCQkpnWKUI0TUssEjfbNOdfy94jA1TnCT735GMMnvUcPXKU9vQUq1XEI1PgFyVffWbIfFuyvyk4FAzOF2RTmt8tBHHa4EMffJj3fedD+BqRs/NVfA7eBNKW5Mj7EtbOetJpyds//AOsPfN5+sOX2Lj85zw39JiR441W8OjbHkB+zzzte05jR44zv3qTXT+0zOUXHbte/z4Wj0REiWL23SW/96M/zzvOPMOJUzPcVHO8ciWwuhI41ClZOLGPyK+yvLSAixJWNtZotwumF97OzPImL10dseY0hYd8POZkJmk39xC7BlPNfTjVINiCVtz4T7qe/98f3zwAUNxJQvqGJyd6j7/8Ox/ize89RCXGdKIe03qB837EIhpXbrKWZzx1fS//9F9+mupPnyFUAqUE83PTvOvtb+Wf/+I/Y5TO8CUneVOmGfZKPv7R/8C///V/wetPZxz/73+DX/mxv8OwMOisTTCB4dVVxFRKvCigvRd3MxC2hgg/IDQ90hWEIsPHLSAQRRFJZ4Zkapbixk2q8SrCl8hQEYmAylKcN2RJQLfSCcHPkLQUaIFFE1Fhxh5ravNQKkOsIdaSKJI4E/AeRKTQWTbB53vKfo5OFElTE5yndIqy2yduxURxVJuqCYFME0QcUfUrmu0Uresg0eQFLelxPlB5QZzF6FijZYSONLYSEDdoZYE4DVjvGA0cKoBKBLMLbcZOYEJd2fZlztJ0m/5gSFWWZJGk0WyQNDo432BufoEzZ24RBVUrLsURKtQbglm/STw1j9aSWIOQgcFmF2ljXGuK1Vub+Enl3FYFrUxiBn2mWxnTczM0s5QkipBpk7xwrK+vEYKkDDAoDMNxSTOL6TSgXyqq3COtrLkeRcnBQ4eJG5o0ixCRI0iBt4rh6hBLxuxsi2HuUFFCmmQooVG6ZLopmWoK2s0mWauFbrbQ7RkW2opmq0VwAh3FJHEtR4tKUFlEpFRtICVrw5waK1pvfjUCyONszUmJ45jKuJoIXN8gE7fMOkEthiXFuKAx3SBtxATnMNZhSwuVIS9qmJBSChkJghCUZUmcaJS8vVGYPGf1yhp+4JjePUdrKqvVjmQNdRO6dkvWeJSkThKkw/SusPnxP8AOxmxeWKW43iWrPKOVHjMuZa4EVTYQhUfaFkI+gudpBuI6X/eS60mBeehe4h/9AFezJqeX+sw0bnDjzGMkcYpOG1y7+ATL+zr0Lq3RvTqmygPGthmrg3Rn34DLLHNTGUc6MZfP32Jzs+DeE/dwsfUdjIYJtzaHHDvq2Lx0hsf/7HMMzn8Zr0qWlk5TlG/n7/zUw7z/Bw/RRFD0HC+ONdeetYQnCqbxLM7CdBlY+kALc8MT7ZfEUyBDhRkO6PVWePIf/CT9+QN8YWXA2eF+Dt73Ln7xv3k/vS9a/t4//jna6hD7Fx9C6KOk+6b4hT9awgHvvv8vuHHtn/CgPstDUxHpbMK/Lhc5dPgeHjno+eoTZwi9LfZNR3zNxjRn5jm+VLH3PaeYPnQPurNIlLQ4Nn0UlOIrm8/SjBeJ0z1YPY0NJd/hb1Ke/xzjtVvkuSVuNJlbnEfrlGH3Fs3mAlUOIW4TtaYhSfHW4V1Jd3ODwoGXEUJJEqkh0pTVEIRFTHhSOtKUNme1dwNTObJGhtYSj6vNCxnTySIG5Ri0RMaSm9c3+Ln3/Q4AX3n+37B0YBYlCxJliWWbLZ/TRlPZdXp2gc9fdfzW559k8xOPIUYxcWR57fHjfP93vpdH3/ooTje44gVHY0V3WPHHv/8H3Lj4FCdOzjPz9h/l1//n/4k86zDVmGJrtcfGZo9krkFnSSLaBxheqIgGPYgKQmaJ/Zhq0KJsTqGcpakjirXrnP/KZzH5GGdKpJL87r/9Lb7nu75rJwD+dkoUfu3XfpV/9I//ESDuCGBvJwPblWRgp2JfP1lXobehKdvmWQi583rn6g6BnPg91L4HDu8dr+YV3KnPviNhynaHgMkx7ATHBHjDG9/AX/zFX/5/MCv/D8ek+l7fO/V3VPHtWqiAOukKgcFgwBvf9CZGo1FtSHnH3N7ZhbrTLdna2uPAO4919g5lorpLYI3Z+Y3ufK6WKK0TiDuTC+cctSKVvEvpKIpqJSRjDK1mk3379vGB938/D772Af7uz/4c11dWuHR1hU6nM4HOeuzGJoPf/D3SbolYjWBrhLC7IdpN4CpVus5qljHaI5BvPo05cpBCKxaaJa14RH/9HDppkOerFMUNms2YYnOd4VofbwLGL1HoQ+TNA/jY0ckS9qSKV86v0UwTOvO72Yz3U5aK9UHJ8X2Brz9zkUvPvshg5Twhduzbc5Lh+AF+4sMHObA3QwUwZWDdSDZXAvJFQ3sGGhrSGLLjEX4QkPOCSNdddmcK8vUVbv7Bb5AvHuGJl9a4Zk/ypnfcz1vffID+mTH/9r/9Q2bnDrD3+DFGRZu9r894+G+nlFXgH3/4HBuX/z7v3WU5vCdjozPNl9xu9h84xP17PZ/91OMcaFe4RswV0aA5Nc+BuZLFN7yGtL0bGTdIdIPpuIYPnR+vMJMsEFQLJxQNITkRt/iG7O9vdNR38sc++jE++MEP1n8J4a/9gN9U52DVeHo2Z0r1iETB0L7MQbmXwCYbomJgDErc4Md+6uf5PfFHmCcfJ2z26I4qPvEXX+HxZ36c1qEKGpkAACAASURBVMHXo+79Tj7SHVPdfIqNq09CFhN/z/uJZ/dS6gNUN85y8D3fyfTJ4zz9a78M2W5UVtJ+4DtZWpjCb95i/fJ17NQySgwZrHeJjCJupYgqpzx3ker6NeIkRScNBArlYyLh0KnEJxlRKjH5mDhOEDIl4LHOYSqL8wFvJk7HJiADRGlMYy4l3yjwviYlB+cRVYkpJ4oDqta1N32P0BKlJUEI7KTy6QlEUpBlErxHp4rKOpxxqOAQ1tB3gSiKydoZBImpBMYFZMjJUoUrDf2xIUkidBKTCMAZXCUYDlO0loxHFXlpmZnN2NrqY0pL0mwQNxoIISgHY0xVMnAl+3bPEYygMgIvIpIsRuVDqpl5ynGFzQ2FBKFqtYu4kWK1IEljbFUhvSVRAV9YQlUiyVDe1qZjWqE0MPRMtToYERPKnJaWNKdSxr2cRpaSNiO6PU+/V9QKOI0MUsnCwhTCjjDDHnkxJvcCxRStTgc87GrWZlCe2ntAViV+YRoZRRgT4weBFENnWuH7Bp8FZKRq/kgAk3uqap3m/AwIUHGMUBEeiYzkTmbtQ8BZT1U6TOUQOBAB62tPBylrDK83NRI8ThV4RagqKm8QAkxlibOM0lpErDGVpaoqtAWhIgKCwdAg8EgZavJ4VTEej0mSGKnBCYFBkWiNjkFKU7tsOyD4CfFMEbV30XzgdWx89ON0hKc132FwsYeO5lGuoGc9qRPEoXa/xl8n+AGFOkomL1OKjKiZce9+w94kcG6l5MLaWWZm28iyh+2u0GxE3HruFfLKMlqz3FiB1d6QoVlnyjzLhTCDidKa+Ggtylse//JXSGY/z2v3nKS6dp5P/VGPqcxytJHzpO7S60mGg7OkapOonKUTHWL1Vp///Cd+l3cefogTb9iP64FwEbKTkOzyDH7lKZofPonvJjgkQxexcjZh5S87LB7/h5xIz8PWs3zHI6c5+f63oBLFr/6fQ2bFAf7+r/8oB07t4gufLvnUx3KuXg0c2Cc4oo6yHtp8LQ9cCZZTMuHUPri2cZVPXu0y6o9RUmJo8dB997C83/DMmS7rf9nl5PFL3He/4cCJe2jHYzb8Dd49Z1DqCn0Z2JQZISRYv5fe9HE++9mzNGzO3tkB5XCTmfk5sD1s0qS1eByhmpTWkucVVZmDs8Rpih2X5MMhwVj09AzWOJyryLImXtTXa+kiRJQy11nCeFfzm3yBxhBpwXQ2R1X1aTRaeOlBBVrxbS3ung/MmBGNqEQogw1bzLCIp4sVUJlNDs0s8GPv/EE+kh5g9NRXCbfWOb865F//wZ/xh595gvmjr6N58DXMbQy4+vXPMF6/xOLhXTQefAfN2V2sx0exKxd55Cc/wOb6Tb7+zPOEdJYktSyfeIh0+grGOsq4gdEJbrDOxRdeZM/hY6Sp4OqXHuPKM1/BjEeTSmsgOIOA25Xxb6PEALax4pN/xG3oCWwnBRN5y0lX4e6C/W3IEGIC9wluRzEniupANkyUjcIEnlSboN3dbdmBttxBepCvIt9um8oJBMhXuyl/C4wJbl9GNcQ3eIetTN0kVgomHg/bUKGqqnYO3Yb/bEuOCiHuCuq3ZUldbTeNkgqp5F28AAApFbd/F3YckaHO56y1dz23/Ztvv6/WupYsjSKajQZlWXLp8mU++rE/5sLFS3zogx/gl3/1X979vZVEJjGy2aYaChQeJRJCsFB1CSHHxgdJslss/8h3U80r8mAohWRcSgaFx0YKN7iGoEILGK48T+UsVXfM6nXB5niLUJ1DV5or7KJUKUYItKmIokDcbNKa2cOxhX2UK1f4yJ8OOLZHsKuxRTfqsnYrYmP1PFPpFpH7ALHKePH5Df7kD87z0D372XN6ehJLRagFiQwW85lN9KPzhKEktGA8lgxWIsYX52gf+XGW0jWKSwVve9dRFk7vYtAXPPbZwEJzFz/4P76RbDrmc/9HRX9gGQ4hjQX36HlWbYtPXF/nuHccOCA4vDuwunmNz19cJy8qrkQxC3NL3H9wN+1px8WVHt0nexw/LFneu4tO2kDJkpwB9zY9St5kJHZR0SYKkr7N6UTZHT/Qt8+a9M05JKspMr2fOJqmEFdYkClCpJShZCbShEyyHhk2n/gMp97yOob3v47eVs7giScZPPk4gwsXSAc5yeXLXBdNtChxLqKzfJKTj3wQE2X4XOMKybCIWdh7ikd+5r/k87/yv6Fn9lBefp6Fo+9k36k3MzpZ8vhLQ7L9hvHnvsKewwvs37OIziuu4Lh56QJeemYXZ0m1x5UF5XhUVw+UIGBRIqC1REYKY+ubVIr6hpdRhE4ECoH2ARFLdKwwsaQ0Dm9r4pezBhVHNZZwbHC2xp2rKEKlMUk7AQE6lnUlJwi8cUSRRCRRrX5UVQRniCR1MuEdlXVkSY3xL0uLMZYklkTSIrSgLA1FbtBaE2caGQkq4yhNveg3GzHSB3JjSLVCQ008RFBWHptbegFS0SSyDlB1oF1abFGQJjEJgsoqjHe4AKiI9nSbrbJETRZHHUnSRpNet1eThb1HCSA4yiLHlYaq0uAdZVVzE5SsZUbTVpPcB9qNNvTHQEGiI6bbTWSokzVbOSojyKtAXlXEscJXfWQckTamUVGE8QGhA7kRLDQ0MkqRUhNHEWmiEd5QFjnjVUN7ehrVqlWmbAgk7QZBgLMV4BFRDDKqVaImi7RzHjshF8dxzSkAiJMIP+ksEEBJCCbUxitJXLeUfQBZc0TG/SFeSFwIGGMxZYWNJDoKGGMoqroSpbUkzSLy0tGcaaJVhEwUIgI5kdUVWhFFuta39gGcJdgcN9xCtRuoaoWVc1dQ6wOaUQOqDu1dpxldfYY8QEct0IwMkc8xfoOxW2dDtLksJS9WG1TnnmDw8U2GRw8zQ2D//hM02oYwvAixYLa1i4FYINh1khOnOdJvc31zzMrGLcJGj5g2G3nJwCT0u4LBVp/QXSHp9/nq1Ys0qwHF2DGMYnqdDq2lB3jozQ/zZ5/4GIxX+NzH/4KmbnDqnW/kAz/+Ni7+9qc5+Kb3M/fBRbKZhLSh0MEzuJEx+vV/RrX/vyB+3X7GM4ortyI+0Z9hwRxn6pXPcKpa49hiya79QEvwE/91h2uf+F4O3r+H6d0ZD70vYflwhut5zLLi5/7FIu/v/lP++I++wMWvfo2DBy+yeuQI/mIXues1LB3dzcy+OeaWprlv1wJT7ZxjXUe/u87NG6/wzHNf5/KlF9i7GMG9A04uZHSijLZ6DbNimmFY5kVrmWWL6UXI1wu28oJG3qZhBKGAZgeU8ARvoSywo5wgIpK0TXAVIq67bHkYUeZ9Cld3k0Ji6uswOKyrMOWI0hqq4HDBIoUhTRytpFWTkpHIUHMYnLeUdnR7UxAtlJjGM8SGEU2ZgdA4r2jJGKsFG4M+fnPEQydPMNh3kFvdETe/+FVWL11kvddltRzTvniWhp5C2oDt7GH3nmPs2neKSsUUgxg7UPRsyv6TD9DSKV/94hM0pncxuH6W1546SSdtstq3nFsbYskZXb9GtjRH9+sX6Z/7OnbUB2qohhRhO6begeR8243AjoTl9uOa3Fo/3HFP3gns73zdNmmW7UnYOW5HY/8udE3YaRjcDadkgp+vBQhq7hR3ve/2qGkIfjuL+JYcYgILFRPivcAjpPyGxPFOR+Q7E7LtYL0O9LmdIG3Pibw9z9vHOOdu0xwmHfltdaJtfNdt7gdAjbTYPq9SikhHZI2Mmelp5ubn+emf+kl+6X/5ZS5fvszVq9cwVcXRo0fYvTRT/w7eEYwFHxBxQuM9j7LxkS8QNzVRvgnO4qoexm9S6Bni73gt0a45rB8y6K2xmm8xl7TQnRmUWMb5EiUqUjqUNGj6LmrxCNMHNevDEePhAD8uiWnTLQ19l7G15Rj11xBbawy7G/TOvsJsGFF04dy4SdKZZvHgg9x3324+8qdfIxpc5PFPP4N9x/20FqZ46JHdjL9yhvkHXo9+Z4JuKKJYwBjMwFP9u9/FnfwQ+nhK7gLXR4pzeZNOtUjjhac4rLrMzzuSjiBpCB56f4PhPfcxta+BigWv/W6JqSBUAZEK3vf3Wty/9V/x8Y+8TCe6xMLhisHCXrg5Qs7fw/FHpshmG8xOt1nstIhjw/whS1mM2exe4uLFF2lllnbbIecLllsdNE0iFFZoSjJWvaMZYuSEy/g3X6/YtoP9vx/fHOfAm1rxhwzjMxJVYvEoIiKhmNWwv5FzMN3i6nnNvtOPsufEEvmeAwxOHGMw7lN1HWKzTzVSzN1zlNa+Jab2LLO8cIinCoc3QwgOqzRTi7t48+6H+dL/+r+jp1qMzr3MrXOHOLjvMK+57zDd8iaj9Abl7hZx8EzrmNlOm3BoGZuvY0JJaypCK49LJTIOmKLCVIZ8UNamX3Ed1LnJwiZ1jevWSUTWjEliSRiVmMrjK0eSKHxVE1QDgSA8OhboOCb3Na6cieawNxaVROiovukJNZkwUgIVSYKqtfF9VTsqCiVJ4towIziL9xLvZS13aAx5LskSiLMUW5XYyiKVRCdNZCQxQlDaQBwpGplGa0VVWYK3OOcx1oLQWBFhfAFlgemNUNaidUKcCQIe52GmUSccspJQudr1V9fmLGmsaDU0haol2qIkJsgBQkX1+xR15c5JMBYqE6OVwJaeIOrzhsqhAKU0WatDYyTwhUGakkYikcaztb5FcIYAlE5SFgGhoahGaFWTsyOolVhSibMOLT0BX2vAx4IkjRDSESUKZypcVWJNUld5dN1i9s7VmNmqQriAjALBSyauNThfy58KWbtIEzzWBqQUtVnetvKQgmBqwnKka9+N4GqvDGcceVEgk2Rirle7ExvrKMcl3hlkkqKiWrFiPCoZV4GFmSmErxBRLXPrXUB4BTJCKI1QtZwqSuJ9CXZAyDcQw1cYr9/CXhvg4yaNTMG0ZaQzCl2A1JRaImRBXna5GRQ3xTpXGXDRdeldzbn5uS3ayvCWIzMszt6H8EOKdAEXZ6RJSbb3HrrlABcfpbk0w37vmS5GlLnlNZGmKC2DUrLeF6ytDbh15QLXnn6OS9fOMic8lVDkVcrITTPdOMXW5q2JikfJiy++yMLefdz7zjfxjkf20/utVRoYlo5pmnsThBS4kWPUbrPxxc8QnU+h/26Ge4/TdW32vSZGDab4/FMZDVXRfOE5wpf3cPD7Psjr35bC2YOgFM57pqYd++Y3Ofsnj5Ht+W5OvyPjXvcWBtESf6k73LjyUWZ1mz2nDuOOnOToyaPM7Z4nZBlDH3Hj+hrLBySL+9q0ZmBzLUL58/TF83S6I2RnCqHnif0Shqusljd4euUye3ovsLi4TuX7UAiCkAxHQzKV4ompxgXg8TagkIAmThp4E9XXZVRhIkXpKkRQKBkRyQhCBTbHGcc472KEogwWrWuFMa0ThIgJvkQQUbkKP5FfuyMkxRRjgp0hyIQQDDJYnPBIEaGCpqkcM7pgxve5eGnMsfseZu/BJrd0RvfGUYp8TBAR0dBSmYRDJ/ajWk12H9hNK5viUmHwpo8TYJRi79ISu6ucZx5/mqSRcOPsy6wdvIeDyzN0WhKPpjcac+jIHhpKs7m5DuNBLeNKXSEP4baZ1N/4/vufOO6mME46BhNuwI5qEHeQgO9olNwVuovb56vNtm7zCHaOvkPq8y6E8U7iMDnVqxKDWrDh9kHbZlvfimN7zuRkL76TX7Y9qqq6C9Jz57hTEeg2GXxCR5Py7o7CX0c8ftU5trsad55L7hCma96iFIJmo8GJ4yd429vfxrvf/W7W1te5vnKdM6+8zCsvv8TVq5e479gCfjzEJzFhnOOLEoQiTHVQ9+zB2DFWFPheQTUuGHrNKBvQaQmuPvUE3cEWAzlCLMTs2dsmjsBZQYgXkLKGZOtomcKOcdF+2lMp2lWUpsQbx36pKIxhZDRrfehtbtC7ucL65aucuXyO3dohQsz6ViARu5lrLnNrfQsfAqYqefGZl1m6Z5nTe+Y5eaLDy1/so0Ogsz9CJXUX3/UURkvGX3qCaH0KWb6RvDWLkxEzexVqlPLEZxJm58eop59mKolpHT/B/pMRN/NZPCADzC57hpe36D7VRz5yjP0Pava4N3ArX2bjzNfYsleYSTvMHlzG7znE/n0LRI2UoBRjC5ujnLlFgfJdVGww5Q2kuE7FNdJiiMgWQOxCM8CGLYZ2i5vjLgjL/tZJdNQBotsdvm/x8U0lB6Nyk7xaJ5O6XoDUsM4qRYQNAhU8uxuOB0/O8yf/4Wn2NA6y58EDxG95F+V3vIeBH3Pr5S72ylW42mP/G+6hc/oQ6VSbKRt4ZaXEqQ1IoT3TZN9ihxNBsnzqQaqFlO7jj3P2a8+z+8Ax7n/gFG96QPL8+XXU0d2sP36FrrxFZ98ci/NttjoKQ4oPDmMCAkWSpQgtMF1HlXuiWOI8SFcrB2E9aIWMJFEEaaZIs4iiLJG5wxdMNliw3hGcqxMBFUgyjXAe6wPWB8rC4sqKtJ2QNmIINYlVEIgzjRMeRR1wGgleSrxSNFsZsdKMh8UEKuAJwRG8JS9AJQlJolAmggA6jUjSGKTAOY+QtyVT0yylMI58s0sc6uRGRhFexgRKvKuo8gJvPFEESVAkDY1SGqUEKg5EvjaKQwh0osnzMe3pDmqmSb+MqZxHCpAqQkQxzsJgUKKNRcQT4m4o8VFEIAbh8Y46SHeBmU6LOE5otz2RNVAIdAS+rOhuDUiyhLSVIKOEurIPlbE4I9gc9IiNQTcbRDoh1gFnSirvkWkGWVLjQfGkzQRtBEoFrDNIp8gyjTMGY3wdlDuH8tTqT04R1G1S2A7Od1IFssYhtcQh8HgktX61t7Y2o3N129+HgC1rCFFpDHEU7eB+hRDYylAVOVIEdKtBlmiqsqTXKxkbjdAaGSzWeypTUeUGVQ5oqGWC0vUmV/fIwRrctZfJi0vIq2dI8wGjPKcqHdoqNtZfphulyJYhp4u1EZUM9EXB+bLBqthioPr0QsH6qGT1Yo/jV1YZzAtuXXqZuOpjdQObZIxcl3Y0zU2/n41NyJqO2bl5Fnbdi9HTdKoR2tTKNOPKsL7H83JnL8NrJRuDm6yPhkTW44PHlIGt1ZILT/8usWojCCQNiXWGK2fWuXdZoOSQVy5fZPrSHFkrIZpVCATVSsL6yLN87vdRpSQcm6L5miY/8Ga4VTR54bmHOHfmBtWXzlI62PfI69haKyjVHNVYM1zLyTeHrL18mc0nv8SNq+9mqpWSxIID9x9i9sr9fPbLn+LdC0P2vvW9+FN7aC4ugMxY7waeW+2xcmaTNwvFrlbF0v5DHD6xAGiuji4wtxGIbcWV1ZxcrdJXT/PFm1d56YWnOTMuedtszCKORMcQoN9TRI1lynHAjLpI3UAlDZIkpaxAhoCMNM7W2GWla/8TDSgd1WT+qsLmOeNxQX/QI57q4EUgiROyLEZGUFR1sm9CoEZFutrfO+id9d7V5TWk8JOqZI6UBkmECwEtHAvNiP2zDf7yM1/n9N7THDiwwIlHHqVQgWFl6G0W2M0e+Y0Rx+5bJp6bYi5NUA6uDCwyvvV/UffmwZJl+V3f5yx3yz3fXq/2vfeunp7u2ReNZiRmBAYhIYGBAANhhyKQreAPY/4gPCIg5LAtsIVChgApCHsQCBstGCHNKg3Ts/TePd3T3VXVtVe9V2/Ll/vdzuI/br6le0Z4HIED6VRUVWbem+/lvXnvOb/luyBbAe1mzEotQnY7nDx3Ht8MGK5t8uJ3bnB+dZXzR5aIQ829XU/yAx9j99YUTpxmPonJJmPydIqZdeqEgO3tbZ57/jlgL249jM1/58P95XkPcn8oeH73W6unh8m7/ruD9MPjUFX/e47vsb0oCt739NOzqvMB4+Cw7r3Yq0bzTj7FPjTonZnF7LmfEZQrGNE+9KWSTnsXCfmdOPvDx13p8Vvws2D2UKJx/MRxnn322T/gWPckOQ8O+LBfgz/02vfiQP5BvJF3dzz2xl5wfxguVZ3D6hje/b4sy7h06YkKJjrja+zJi0opZ6Zoct/R+N0OyPveBDOYlXWVk7GSs218D9gWvPN9hzgyYRgipWRxYYEPvP8D/Jkf/wmiMOS/+Et/GecMX/vyF/j1f/k58iLngxcCyrdeJussYicZ5STDOI0NQ8o5wbQ+wJaGnIKBn3AvzQmCXdRrL3Pz+hW2Rn3C5QbnnjpH1ponHe8i8j4+7oA0M+GCgBELjCeWJPE0GnM02zU8AYEtEcYwGg5YrHt2223uxQuYacSd7Q3ujIc0XEnpLfmgZDC8z723v0on6SAFEBgG/Yze1pSOTLFizO2bG1xciZELQaUqWArspmKyaekOfhuhVnAXEubONjhzCsZ5yItHH+TO5g3yZ15HtZokq3Okgwwr57CFxuaWYpgxubvJ5OYm4WNnSWKNUnDuqVXWN5a598Z9nugWdB58HI52UXENayW7U8v9ccGwn3JeSpqBY/HISULVovSCabFJLfMIm7E+GUO4wW7ZY23Uo7d7l8vTbd6/+sPEbhFTaIwBY/egZLIyLDy4Ot4xw/j9bujePwewtP0biHfPBfs/6h3TzOFY5vqNa9/znjo8vq/k4G6WspmNmdcRipQiLGmwjvFzFC4it5qhCVnPSh74k4+w9vWrtGsP0LJLdI7Wef98m7fffxT59CM8FcPUezadp7SeTmp59dlNTJgh5+Y53mpxLJCsiSaf/vGf5us3n2FTfYH83h3u313jvhM8dbLFVD9G/mzAUG2zcfUKcjfm5PljjHZ3MU4gI40IK6yl0hFOA2pK3Ikq4m1RYLLK2dBNckqlCEKBSw2lsJAritQgsegwoCgcaAjqEm8EUlSuuZNJRhwIpFD43OLLEpwkjgKCWogpBcIZpHSoWshoa0IttpjMUEzLqppMQJ2QOIqwhcFkDolDhx7nBSKWhN0mOlG0tEYa0FqCCimylCzN0UmAogq+CwQyCEhzj9QOjUR4jXQCLQNsCV57nPJM8gmjdEwyCul059nayWiFYG0lk2qMRYR1wiipZFUbLZKgQOUZgStJvKcQMQ7JIHdo7wkteJfRaTfoT1KSUOMpKa0lMwZvq0l1uNnHoojrCaoW4AtDMRiRZxmthS7tThPnHEGU0lloMdzOKCYZHk9eeArpaEWeleVmJfU6zZC6RpMAU1pyY2h0A0SoiWsJeVEymRRo1cDmFutElXBJVbWdERg80lfOskFY1W2hIvsZ53ESrLE4WXWBtKwUO0QgUQJM6RBK4GYdG4/DGirisvMY5zB5gc0K5uYSnLOk3mC9RwaKoBZTjB27/T6tuTppUVBOJ4j+Jtlgg8WLH4KVZXwUoEOF9BZz5za9X/wf2NjusdSG9jSjJh3WFgynfd6+cw2zPEdtzrA96TERISPZ4I6IuS22iUJDTSlIFVGhKUtD7/ff4JlXrvLV9rc42Y7oJhqkYLsUpEowv3SG8Nx5nJ5nMinwrsnWwHP5xRfZuf86N19/g3DSJxAhQ45y5mgT/YEn6N2+R//egMkAyrTPpPdLGCdI3IRmc44f/8yfYGH5ffyv/+Dr/Fd//RT/6t4z8CvX+ezG3+Ljf+r91J4OKXuerS8FDOwpjrFNlOccW+qz/DHJaFowPVrn5/7+H+d3/vaY2tsNjgRjdr7yK3zll3+bj/ydnyfwD3PvpW1GO2PqnSaf/Nn/htdfGCAvRHgP91833PlGhrFjfv/ulCtvWE4FAW/d6GGw2KzEbNxn4dEuz20HTN+c8NipKefPjAniCQ92YhaaTXaHln/2hbu8Yddxc4q7z28SbDmm9ywvdCUfOhby+HxMNy6IwoLJlR7+tEerOrWlVRrLdQJpKYoJeX+AjBsIJDqsEcqAUGqyNCUIQsqioMwc0xS2t3vsDnZZjQOSeocgqFNYQ54NkdKQtBOmRUkpJUXusWlGfzDan++XFx6l1QD8brVUKUvANo4FnHB4EVF4hah7fuTHf4jbb2zRrR8DH7NSj2jWavSaHeSJFc6+F0Z4hg4S7/Gp5bW7KaqTEXROc66WUJcSukv8yAd+kFd3bvGKEPRv3eX+YMK5E5pzCw3qSYQ0CbJ/mfd84pN84JGLXDh14h3rlBCCP/8X/wI/8zd+ZuY2e6BFv+cYfAilM3vPrOLuqoVYyUqFx1m3XxA4XOGFA/y9P/R79xfnvSBvtu0PEvwQ7CkBHSjX/PRf/2m+8pXf+36W5D9049lnn+UHf/AT3+PkAnsdj0OqR/vV073vBz8LxA8KKHtjT5b1HT9WiH2oj3N2XzFJyiq43lcR2idfV4+dd2it31Htbzab3Lhx4//P0/P/aVTXaQXVtaZSPVK6EqHASz7+8Dk++Jd/FJu0kDe+yPb/8T+x2zeULmQiWwyCeexql023NSsmNunnMVcGfb5x9QV++KkPcet3f5+5SGCkZzpZ5+2tq/Rf+Bq2XaMbKBbaNZwKmDgotabdOYNePcVw0sDN1s3hJGVjbZ3+7l3eevlNlmRK5tr4cIHVlYinf+B9rN24zfpbO2TjOqPtKwx2bpGXkpVyl/bSMj/+E5/mzTsxX/jSPd73Hs/nr34T9dx9fsb/ZRaeaqPaAnPPMf2mJrNnUfkAOclYPmIwxyEvPbYT8dN/+1Ge/bs9OrXrxDJj8MoXWHvxVU79xE9BucLu7apbUT+7wsLjZ+mt5YilKvzduGIZb+QMsxHP3S1ZbXqOhpK7clghd9McV2TUVxLemkDaz7l03NOsp0TaMJ9ExHGbSWr4rZffoJi7w+5kyMadNcKppbde8Nz8K6irE9bfHrN+P2MwLMlTi9IhaVbs84cOzyXG2Hd0DPeu371rxM+SezhI1v1+sj0z8RMzA77Zz9aBRmtJlub/r9fh95UcvPzsfUSYs3Oxw0fe8wG0iMnLr7GdZihp8a5Lns+TZ1us37zNbnaO8ZEGnU5EOYGXvWP+iCZRlVa+U9CRHozjV9cKkvEWKogQy6u0HN0RhgAAIABJREFU5trULQwRFGXEU5/4Qa5/7p+QX1/nyrev0Hj+Np/5wbM8ttRGXnqA8ahg8JZnZHrsTHPqkcdNUzKhETrA6oDCgRlluNEYFUvsOEV7EA6KzFRux8OUoBXhlWC0lYP11FohTinMtITSUmvHBPWIwklGW0OKYUnucopAIsMKsx7GMSYrSHcn6EBWykM1hS8kXihqdUFRGPLCUhYgvEAbz+btPuNGjUBYEu1o1KqANitC0JqFxTmGuz3CQBM2Y5yQaO8orSEfjGjJFloEFIXBpCnLZ45jpilSQKQF3uSY3LO01GFrWJAXGc1OHYGizCxmWiLzMSMU4xSEBVtWeNJ2OKa2OI8vQ5TXRAqE9rjMMtreZfXMKVqJJheG3JbkWcakZwh0SoEi0I5aLaabxKhAMeqljAYDGp0FSlOpAVlfYqTBJJqVlWN0OzVkkOClJGjV8HmBUoJuK8L7gEma4fOMehIwHATc6W1x+sQp2p06SS1AKUVDSmScUEs0KEkSVAQxUxYIoCw9OENUS5BS4URFXPPeE4Yzwhoe7yylceAd3lcSqBKJmPkaSARxPcQWJcJklYJSKBEiwviQoCEYDVM0IJQkrMfU2zWktOSlIR9lbG+l5N7jwohSxdSbDWpJAxUZTBRCXB3DS7/+WyzMH6FeO87KE0eJdobs/ptnePnrdxkKx+KFGLUcsiYcu0MH0rNOzuuDNaYGaidazK8mSAJ2XtvCj3d59EKXFy+XjIlYmQ85nRS8fX9Mb6OkO1TENdiYeoaZ5qHTdVpPHmXxgY+wE1/kwSPnCTcGvPalL/L7X/9d4nREMgcf/vCjFMURZBGxtPoQd8U5smsv8tN/5T/nShbwwkvf5vK//zKT2wXSbFI6y2f/zj/mPR96HBE6HvrYSfLpmOEoJfQ3uHftOm/8b0uonwsod2DTOsLg76PEOvGfOk70I8tsT0b82n/3O/zX/+7Pk/uSzrGMxYc6HPt4DRVf4T0XIPvNv42bf4zEJtS6p6k1P4hNSy7+yWWk8qyPPOdrm3xm5RbjjuAnf/5neebbA177xtdp1UJUYugsa37qr3yaYGGOjoICwYs7G9wYX2VOnmCzdol8+i/47//1a9xJHeMtQ7lb0jol+dgPRCy0PNfXHMNrji++kZJdzunqEReOLiNiy6kTNZTzlKMBKtHEkSTNMgoiwnoLJSLIJmSkZMajqSBtY+PJgpiVMxc5G4ds7O4Q1WImaQaU1OKAerPDOB8wHQ+wUULpPQ5wh3wOZJlwv7dOGDqWO6eR4jjWvsnEmMoszbdxTpNmG7y1dpVhcYLVbkRTKSYFTPDUaoJQVhK0Xgi60jPOPZfHlkYxoR41qR9fpZ2ECA+pBUfIY+fP8VtaMbh2nW9eXWN+dZU/ttJgrhZyYnWB+4OMze1bDNNiH5//zir3HgRewIwA6oz9rur7fhVuDx44G06Iqgu4vyBTRaOOg0DWz5bsveDXH7gU7+3Owe77H+zg8x6oDQlxkCj8p8cj/0cY+zmSOEgAmFUuZ9AZf6jyXh10lbFVicF3dy7gXbAlMeua7j+dwXdnj/eIvmrm0uu9r4KqWRV2TxkIf1C9/8My9oK+YjrBmRKlI/pXbrHwyAV8WeLWB4xevsb2i8+Qjzc5dbGBOtNl93pGkXlSLFsMubPTx3U19QtLFNYz3B0hk5IPHz1Pc37A2o0Rk2SO95xI6AYFGxu79O9M6Q5qmCMNrg8lc+2AlWNtklOr1JceYaSOcLqzyOTufW68/i2u33idKKvm+0/84JNM+gX1qEPYPELPNSm27vFXf+xjvDGCF194hZsvXaaORE3uMC4K/pef/zm6KwlHH3eUuWVnbYP+rTGJfovdazv4yw52JOUupKUn6Pw1hB4Q/tgy4mxA760+N76xwdN/40Gs9zQv5HQfP0L92BA3WWP1fkr58j/FtS4RlRI9fwatjyGUYP6hBO88oxIe7gxI67vMnezw+J//DFfWM1576TLL8wmFyjh1rMN7Lp1ExRGxAMMR3hoN6NmSljhLpM5SlF/nl198hp6I6b15CyFKjiwlXFoNaIaem9uGYjlBuIB8PEaZjDEGZEiWlZXsrqj4JkopmHFb9jgzVReh6typPf4L7M9TwH6C7LzbTwz2W41U/1XKWILv55L/vpKDhy/MEycBv/38HX77TsYnP/AYD9dWOBErJtmIu4OSm/1NMBu08hbZ0hF20pQo3WW55WgGlroP6GrB0HvqrlKNWUegO545+x02FxdwCyvEQUyQlvgk5Mmn5ohrgn9z4nEGm2Oym29y76uf59mP/xQPh4p7K13a77tEb/c+d1++y2h3xPnFDvlGj2x1gfaRBhmOre0Bo8wwnGSoqUFpTYVxqSrwtrA02hovPSrSCDwuq9qBUlRBoAwl6dQwTWe6+Ap0M0QiDtqmzmK9QytwCEa9jCi2BHGECjQunaCAWpLgTU6gq4qA1hqRTSnHI6YSVD0mKypZ0jCOqc21kKpgvlNnMiqYDMYEWlA6Tz4pqScJSjvCSCAI6fUybq+tM9rsU6YlsQpJkhpJo8bEOLbWdlg+vohTuiJLRwKfCobjklrT0p3rMOyNwEOt2cDrFlvrfdr1hCKFqancpSMB9fY8ZWmZqJJ2K0HkhmGeIeOAiYdus06mW0yspBgXaJuT9kcMjaauQyJVwygFOqCmIu4NNjmaVB4GtsxQtSZxvUtajul2FKH2CAddUZmLxXFIXiouLB1nvLHByElqRyT1do3cQjeO8dJjsxyhNDrUqMDhc0OSBHhbLVpCeCQOGWiyvCAzVGRxqGBgwiOVQmmJNQ4ZyMrVGMBbyiylLKqgwRZl5ZQpKkUjKxRJEhHicAV4Y9AxlC4gG2YoGdFshTSFIFASGWnieotJAe1aTL3ZRKp5zNHjrD76EOk4heGUtTef587XvsLb//7LXJ4Y/lrk8dqz8BfO09uM2LlpmFJy/eom8WnJndfHlMdSdroDxqMUsTIiiEKuZSMeeroJ7QU6c03O1gqefPEN0prmi29lvDSO+fCn/zh/6od+iKkrObFwmhtZwpFdyzO/+jo3vvN1jHiZR95f5+IH/gx68eMkqkMt1kzTEW9dvsHp7U0euxjxq7/0S6zdH1HrrPDkqQfpLrf4ty+8wr/+9X/JyHb5vW9tEwl47PEGC8cX+OLXn+Pa3/sF7K01du98Dt8fEBcrnBQP8LnyPL8btPnJlTqt+ymf/+V7fHB1juLOiF///HXEdJvR8AbpF3b44Ec15/7Wj+FrP8FoXEf4EYPRLuv9jKPNBqGD529mLKeWt771O7y89jLLn/kpPvfP3+a/fKJD568+QLywShB32S0V/+yNAduD3+HPPXgJNd+FIueiCjkZrzIefoMf/dHnmBxxtN57nEbLsFTu8tSpGlI4fqLtiRZizIMRxafbGLVCMzhOejkim1jmTi4T1lp4V038hUmZThU5E8wgA1mZLWbecvfqNZJQUTqDDRUyibAupqBEBhEOjfEG6yXTccFbt98maSrm5pqM0wm5N0xNzu37vf35vl1rs533+M72DUxviwvLqywFc3SUJi3G7OYjRnlJIjPev/Qoz1vNTp4hlaauA2Kpib0kETABYg+ph0wJgsiw4DfpLh4l7HaJhUQaRxhKTq/GKA3BufcyHTzP+rUrXDu1xP2Vh5hXgn4jpnXuGHc317ixOWBlbofFTpMgCPahJJWCGPvcnv0Qco8huteZ38PayxlBb58kutdd8DM5/0NQl0PkUzGr7r4bO3xgTjbb7wA9w+GeghB7JOG9V/9o4JD/Q+O7sdTV+awSJ1WdPiGwnv2uzmFSNRyYgiEEzs7MyLzfJ2MzI/Z6e2D+JeR3JxN7sCl3iAuw95nEu/b7wyR3WwWApoKVagVY6meXEUow2tim9+bzrF1+iclmj8d1AQtnGD1Ukp6W9IcZ/WzC0GS0VjQvPX+XpbpgEs6x1tumt3mPufkmC90jfPATpxkUEXktIGl5PvXQHEUY8ty1EYOgy8d/5E8zf+QoQioaSZue0XSn8OzvvM3u7qtE9S3OvWeRpWOfQjbOEsqYMBD0R2MGu0OOpBNOr2j+z3/6a2xuFqyeP8MnHztHvtrkmVdifvEX/ybjUnLvjQndjmZhPmD17FH+x9/4BXZ+7UvI7btM7nwb0RME+RwNFnluuMgr7Tqf6gasv5LSfzPnxHKCGRS89EqPuJ1y58Zt8nzK0qkG3U//KOjHyfKQSEwZTVIKHPVAI63n7sjStZ4rL32ZfL6BnP8Q33yhxydPxXzg00cJal2kDLmfe/79+pRJfoePLq9iazF1b2jIGonM2dx8k7/7C59nehpOPvYgS9FdjoclJzt1Qml5sg5P1hPskYRX45S7jwpayTxL9WX+4T/5v3j1zWsYd8j/gkprpJJXP4DI7btoVy9U98KhQsQeam/P78TNoJZSvVPS2OMx9sCl+w8a31dyMO0XzOsWc0dXWC8CvnFdstldZCUYcVyBdhYzyvm/f+Me4erTrKycQW+NyaNtpq2YRR8wX+ZsqZB5Jdjxnn7uGGSG+TKDyRrdc09TX5pj4i1Xbm/RPbGMrWlWQkH9Ix9F3ryCW99g+/p1fufagA+faXMpVkSnmsSPP8rrvQmDqy/gluZYWG7hmpKtYcYEB06QT6fIJCIOI1xpsVlVvVGBpNasE9YEtnQIAYXw5GWlmhPXFUVaEVrKrKgIqaoKJk3hqM8llNMSZypzGSUceWEJ6xodenToEaqqXJWloYZjOi7RUhI3I1SgMHlJUA9ptWuoosDMTJ+MVAQ6qipOpSMrPaHyNNsRUavGaGooRU4sLUGs8ELijGO5ISgpKbWAIKBWb1CvxYRaEljDhYsnyPOc0vqqzRRqkrqlt5sRJnOkhUVGIUkSoHXCeDwi0iHTIgMESaNFkiRgC4owJvBTmm3JtN8nm6aEAqbGoGsJo7ygyEeESJQEHQo6R1aYbo0grmOKEsoS4TS5sKycWKa1WEc4h7UKY6Cc7OK8ppeHtExRyaUKCIVA6oj5hTZZVtJoLdBu1ajVBEp7kjDApiljFSCyAqkN2mli7SuuhKywf8JZhJvxSHwFBzKlQTiLRc7MWRxBLPBSVouc81hfEbalqIjq1lZVKakUEllByZRCuLKSIPUCVIj3IVI6AilZXJlnOsiY5BWWNwo1YTMiiDSdSCOdB2er7kqZ4tINIhWhOoLo6Ye4nd3jyuWv4dY9pi2Jf6DFP/1XN7lnwbckZWQZnvZEWpGc8UyzlOnVnDRVRG2JDy33C0GGQ6cZa/cj1oOQJ492ePrEJbpnd7nhHOvbN/nNf/EbnHzicS6/8jZvPZ9jNtcZ5VOapzs88NE/x6ULZ6knx7idxujdKTd3e9zpbbG5u8sppcnCPvrBM5w92WGw0ePVN15FlAOOPflhrtzr8+bv/xvuXNvm5PkHufT4T7LYDtEtwRN/8y/x+v/8vzNeexWKKXdMj3l9gk/oiH/kPT/3K9epx1u0zYCP/unHuEfJ3OQVli8dp1VfQvS3eOuFdZ586qPs7ioCXbJrWvjOEscXI1IjiSPPksl4/l//c+rzIT/8U3+R1/Rx/DN9yqMNhqFnEjQrVRwx5ZMXWpTTC7w5CihcwcVOk2K6zS/87vO8/hv/lt2hQDcjpq8OWOgITi9FrJqAF5/p8VxHcnJOsnLxNIunP0Kt+0OEqolZNmS7a5RFjncC7wRlUZKVHh0FTMe7lDM5RithdzzFmIwsywmbMVJVvAFfeoo8ZGJKhPF4oXDOkGUZ4zRnmGaIKGTiqy5oVlYiCHtDCsmDR5+kOznOerrDNNNI3WVspjjzNtLlZGPLrXuSIhEszM2hdidkgSYKBZEXJE4ysZKmEgw9jMqq6lW3JaIYcPzkY8zPdxikBcE4p1GPQEtaSrDw3kuMnv0Wk7V1rt3b5NXhef5EM+SYBt+NcKdO8/qdO0yml/nj73+IVr1OGIbvgPpUC6bAO1sRTQ8RbxGHzMP2luNDKJeDyv874UQ4XyndeL+/n5jtJ/ZIrLMFe68bsLdYC3mwQO8lFdWi7b+vKt4fhVFBF/aeHCgk7XMTRFXw2uvcvANvL2EPYL2n6uP93rmZQSfEnlzowXejlHoXx+LgC9yDUgj4budiVSk7CScOvrs/BMO7yqugUrwrwGZopbHFiLjbgJPHoLdFMB5Ay5D8wJ/lmZ/7bwmORbjEkdUsWaIpp465CwHDYZ9+f0igNSeeWiSQlrt+xNzRmAYWZESexPhWjVNz50mODNgArlx9g8b2gLnlFUy2xp2rBru5wVgali+ucvzM46x0uwS6Q68M0JOCtcmIncmUsiiZl4JCT4geOcsjps21t+9w+e2bCGE4+5H3sj3MefOrz7C5VvD4Bx9lafEstVghY03yZz7C3X/8eeTkNvlYkpZHWYw6PNRUfM56rv/iOokfcOqo4uTTi4y8pZXdZv6B0wRuGTfq0V+DheWzZJlCacvYNohabaTQWCrz0YYzvPnFL7H68Hm6CyuslzV69wtMKySTnkIlCFdSDz2PzCcYM8+tXGC94Uytxp3tLV769su88vWvsDkJqE9q7L6xzvGm4Gi7TiOX3Fvb4nZNESlP+/gFHr/0KJeePEqoY5QQ/NjAc/0f/CPyopx5bMwk1P3MWI+D5PYAImm/m8rkDyCM1Rw1k3eedQsOq2M5cdBl+A+N70/KtN5CRi3MoI/fHTNKhrzluuyKlDywLMQBxs1x78oLxOIeFy4+BRu7dGTKkUQShJ5YVK6BO5kncA5VlsTZFDcdcPHRJ0h6nlpDo71ga2cbluc41VAkAi6efYDdxRV6O33y/pDLX/4yL7f/GOe7DR4IA7YvHGdtq8/127d4+0afB+YDykixNR0zKcZQTjBOEDQibFZgjcPOJiIhPEJ6jAUlxH4LWupK8955SCcFSlZux95Vqj5KV14G1TaFkMxcEWcIL+EJYomOBDqsBHDSoavMrqxFSIUzVdBJ4SBSNNt1zKCCrMgoJoxjoijAlxZHSLMdk01ScuuRViFcQSMGb2dITucQ1lcBtRBorQhDVekFxwFJHCK9xJmMUDqs9WivSUKBagfoaLGSVdWqsmxXAagAQ4ooc5IkQOgQ5wXGOOJAMdduMBlNyEpIjaC0oLynEWrwQdUOVFUVzyqNj2JkWGOh6whmygh5mlEUI0qhaAWwM/C0GwlREqFKKsiXhEJKxrknUIowUOggRtUb5JMxaSmp1UNCrQhmGbf1ntEkw+icWFT3i8kLstwRhg6hHKAQ1uELh/EOFQYEAUgHDlVhDq3FZgXpxNBcqKGVPFj88LgZ1g9vkDhwVWuv+lYcEjBliQg0UmtA4IzDOUMcJZShJLIWoTVJI6HejCk9hFrgTKVAI8oMkee4LEWIXYYuoz5/ggtPX0IFP0b5/G+jb9zjq9+Z8tybE3YDCBcksimwxzTHH2tyrNS89vIUk+c0QkFcD4ikoXNKcHcjZzryRHHEqJHw3Ibndu8aKx2J0Iaaieiljhe++BXMoE9+V9FsKs6//71cePopzl48TxK32FgryHa3KYpNpsbSSAJWomWkhq8+M+Dcg4+wu27Y2rzPaLRBWYyQ6zcZ3enxyIMnaayuIOtH2OlZuo2SceGYvglbU8VQSkoKHD1CWRKKW5zH8Nr6Dv0OLJ85xu/dMcz/yy/Q8JvMrZxibnEF8mOU5cNMnresl4LwSIJ1IdKFyDDENS33bgyp37tJMm+5LSPEJObsI22Ovi9mUwk2Jo703oClpuf8iZiOTwkbHYJmExlqokjw2tsZX/vNZ9l6fQd1NCB0iicixbE6hKXh268MePgYXF4X7Ew6XOxc5Nz8IyStowRJjSD0BGFMNtylLAqsAScyzM4uYRzRCGMKFVYIFwyNxCP1PDYdESYRIqTyl5CS0qSMpwalAwSWopyS24K5uSNMyimjqcOHiqKELIOyVPvzvRBQj1qsyhClYt7cvc04jpkL6uR+l1ALymyHazfeIJtv8OCDRym3eszLBs1AoBRoUVVtR7lD4yvZZFPineHkkWMEqaRdU5iiYJhm6Dhgbia9/NTqKltL82Q6Ynenz5VrN1h74AyLccCxSLFxbIGd/oArm9t8+VtXOLtY44n3PFzhbqtIEDHjHBxU6sUBlnuWCByuPMMsZvd75MBDgfweDElUDrgHMKB3VpylrBrSYhbQvruvcAgIU80Nh6Axf9TzA7H/VxxQtQ8dvHPuIECfJU+Hg3j28NH+0Hv3IRFVkCSkqDqyh8i/ez2ZwwHUOwi+sA+xcIeqs9ZapNwjH/+nH3sSqdaVVVLgLFiDcB6pBdPJBnF9ge7qMoE7SbmQEYbz3L11i1t3t4ikRHcVrlGtsUdPzXFCK1585T4dnaGjgLgR0q5DrFO2hhOUlySxJfWWb9+f8vaO5HgnIlIFdd2mv3WXtTs3seMRbiui0Y0498jjHDtzkm63ixQBk7HFpGNGdoRB0IlDgjjCupJvX5ly8cIZdtZz0nzEzs461uY06zFZ70nOXlhFL1p0u046dWgJpfUU9xVToSiFwJIRiiEqMgRil3NYrt3qUzuTUDYbvHEnp3XnFkltSr27SiCbuM48GEdx1zOyoDsB1ipAo7TEaUe+awgHfaKliFsmoi4jVudjFoKQoYTt3JNvjTk6p5mvCxLlkFGCjkKklggteP3yGl995g22bveIT8c0TMD7Ys1yYslGE9Z3M450BXd7kiRagskp5mtHaTaWieMY8Hzwwx+j9cu/ymAw3L8GnHPMlJn3uwDev2u+2e+6iXckBrNX2Jv59vxH9roI7HF/vo+KxPeVHKBi8jJiPPKQG1wK670tUtPDtAYMFtuUtkPWd0zu3cDUFO3VNssLDZYjzUgJxhIS79ic5MSmQJkpZTamLCxLZx+i3h3ivGWwMyJPh5hpn6I5z1gFvOfYCtdPrNDfuIdLx/SefYavPHqezuMPslQLWV1ssnrhJHevPsq9Z1+hpgqMMeyWGXnax+cjEBDUFFnfzsrFVO0A73C5x5aSSIHJDbZ0eAFeSPLUUEwLgkgRhBKhquq8q/rQ5LkhjmXlkzD7o0IJupK1lFWPG4FHAWZGTtXBnrukQIchUaSI45jxKEVKVSmQBIowkJTTgtJDNwwpc0uaZrh+hnApWjmckgitkQi8N2QlWK8RUlXQFy1RUUBYTzCTnHQ8JEwipA+QfkZ+DgLaYYKzhlIFqLIi3llRScC5PMMLTRBX6irGlDitUVis9UxGOTiNlBFKKOr1GEOAdyVKBXihEFpjZEiRGdqRol6XSKHIMsckT0EospHAlQY8dFWCkgFSabAQhpoiE5Vvw6y7YnH4PKMsFb4W4q3HFAV4gdEOGVVVU8IAW1ictzhFZS4jKj1vjMGaHGEKhKwTaonTAiMEZk99SEqycUGShwRJWEHPDpAHlc+Ft3jcAcZZVkR1ocAVKY4IdHVTVvKyAqUtOpTUhEIGmrgRUk9CcmNnN7NF+AxcihKVMYwvpzhfYsyYpaU5lj76AXa6d/l3//AuLz03ppiDovCMB45QKcKJR87VCcYpylvaDcvCokJEJaG3PHZGElvL2panNI4y9VzdNLw6ucq5ZsJc7GgsLhBEgt21HdLbm7RknXOf+s946oc+xulzDxCqhHtbIybTKbErKbWhU4uJVBPSktvrN4nrp4n9PGnvdSh7LM6HrN8vmWwNiGWNJ54+zykdMshDtIO3Xh9Sb4WMNi3RqQdohpr07m2Ca3dR0YChM7y/22K5IVmLQ6YKXrs55Mz2q5z+SAsnBUGrTdKeI4gipp9/m/5uRqTniHWA9IKRtkR4phtjApFz9ImL3LxbcOfeNjUdETjDKF5mMC2xOz36U8/NsE4znHJsZZX5lTqdUHPXwp0xbFzZwTtBHDgeW5acjhyBh/HMrO5YPWY37qLnL+E4Sd4PyGp9dFaSzHfQUYeoLpA6xxQW7xSq9KgoohYKNILCO4zNaSpNREwWBZVAgTSVCzKKNM/JpyU6sAhpyU1O4SwhIWEckJpRpbJWevJCkJWHq6dV4JUEMfNJl8W0TyRDpBVY10YGCdbkbG71GZt7nL30PuJ2TDcKCGU1ZxRAiGe3MNSwWJNjrMF5mF9cIZnkIDz9wZSyzLBliAliCiF5qtvim6dX6Y8s5WjA2vUbvLU8R2N5nppWLLVjFo4scnNU8vz1HUw64fFLDiEqwyupDhId4+x/MPg73CmAg9a8EIfgQfswJHHQMZCHQtNZC2Ff1Wyf9XxI19wfmJftvxHekRX8kU4QxAwCIQAvvuvw3v0dCFlBi/cTNg6Cnz1lISEOqwtVRmtCVkaiHNq+33rZSw6oOhReVImyFAeEzr3fVyUZ6g8Vz6OCWlnwlSS4kHspV4l3Jc4W1GoR0bFFBnrA62+M2H75SyQnJIMixw8VEkcQBcQLc4TliFAWxElJnHjqNcd8S3JsXnH5dsZgBMoqpnnB3R1LOu3Tq9fpxobGylm8lQy2dijvb9GWbU589Ie58NhFWo0O1sIoLSlMSeAdVlmacR3tNUWWMxhM0OE8oa0x2rxBMymZ6wq2tzJGm2MCGXDmkXO0SoF0Aab0bG8URLEkGzuic6chTJA3t4h2LKIxJbOWJxcSmkqRdRVTHON7U8zuGssfqoMAVa8TRTEUnvLWgHRqCKMa2gkM4LRHBI5yWqCEYeHiSW6uO/LtETI1eOFJowbT3OEmU/pBiHWCJHB06g2a9YCaktx3cHc7Y21tDF4wHzqemNecEAXGOTJniYC5uMUoaBN2HgbbxWaeYbnLjjUcO3GCYydO02532NzcnilUmuoaYK8mcWjOEe+6n/Y6cLPk4YDcz0Eb713X9/6t8h+rczDqF6heSW4Cgu4c00mD4bdfZuR2KU9F9FVEZsYUeYDoTSllwJEHz7GUVK2T0sO6cxwVjrVsyk4xoshHZEVGJ1mGIODC8Tr9qSHPC9xwTLJzi2ul2L/yAAAgAElEQVQ6RCw2eWQl5mtnV7hxu4nbHlDuKL757O9zdn6eS8cW6CrJA8cW2P74h3iz57nSu0pw9zpK9TH5kDIdEySVpGaelQQBCC1AeKyxkNlZm9FjjcfZ6sQVWIq0xBmLaiiieoAEyrQkLz34qmVdlCVKCJQEqSVhHFZKSVJgCk9RVjr1esZbCAJNHFfBv1CKIAxJ1GxylLLChOUFOEcsYqSv+AXltEBaj7SWdDQi0BYTQr3RJohjhJbY0uBchpABmRNI6anVNHEtxEuJKXPKssRqSag0wjtM6TAGAjWlMTeHmzoCWeKdJSsKNBZkiSky4maTKFQoLzEW0umUshBMJwX1SBHohEBrOkvdyiNBpKRWgNIIJSgLy86gT9wRrByZI9AFaaEZlxEagTQVnGc0nKBVRJzUMEpg85KkXsdHAcoUUFrKSUEaGOY6TYpxjtAC4wyTicG5Cc16i3azRekVwgvKPMe4EtXQoKoqgvCVehDWzKoKEmQMvoIEeV/xTYIwwRjIpwVaqYqwvK8oAXluCVSVoZvS4L0nCCXOVneq9yW2rPCklkoSNYwSyqJAh4ooqkjUgQYtIYoDyrKc4acdzhuEllWAphLask1pM/JpSp5bvpOt8veembAQCi59KCacwPYW0FBQaq5eDdhd30blBSdPSE6ekxRThzKOc6ck8w3Jt2/C1ZuO/v2URi2gyDyX7wxoCMfS1DB3LGf1WIP7N6F5YoFLP/nXeODkSbQtWB8M2ehvELcTks4i0tQJhaefGV5a73H/O9/m05/+C/z6r32T3tXLzMcFSw+cpT/OqUePQqNBUGvz4FwDHUZkGfzmN3b40GMR3Q8dof2RZdTgw0y/c53hb/07CHJcWePJB4/ywdVFnt3c4V88+xpzYRelNLbVZlxEmLBL1D0CoxJx7hzu2RsE02VkkiBiDQn4XslSbBmfPc2S9lyo36P33DW++MuvMF7yPPHxT3JGwMoJx/10yrff3qY2H6E6S2w7wWkvGUpwrS6LZx9h6+0t9Ljk4ycFl2+nrE0986cjPvX0PGvXQs6sPsB7Hv0odVOgx3coNyRD0SRqNhFBiNINcBHCF1hREssOytdwhAhfGaRVpHhDqD0yaaCExbhqrvUC0sJDnlXdzkhV0ARvuHnnHkvLXUQcY2xO6QQlmtIF32PmFzSCOu9ZehjrLOu9dSbWA5ZJ4cgzxaQ3ppSKs0ePUpcCQ/UZjPe08RhTMHAFeZkBklgnCCk53gkYFI7hVKFNDumILSGhFnK2FbBw7ij2+j3Ix4x6PV6/fYPlWp2TrZgFBaePzJO5gLsmYCcybO7ssjDXQSqFDgOckZgZEHe/Qj8LXPeCyIPi2ax9z0GH4aBKJw4F+7Ogcm8/DgrchzsUey37inhcPdiDwiD3Kt7VOIyF/6OdHVTY5u+CYsF+BiblHhHyAOJQbd4zCTsc/FRB/h6XZI8cLvwhiNYMgvEOsvne53DuUFLHAQF6FkhJWcGR/jD4M7zDfA6BdZVRm0DirMGUGXHYwNoM72BaKq6s5/zyr3yOpajkkT9bp7wiGRuwKkAWIfe2AnZ2tlBqQqQlcwua+UVJrEpWFhWNKOTN+7B5P6WclsRxTJ4bXr+5zmLgOSoU9blFlucj+uuC2mqbcx/8YRYiTW5KxmXGtEgJYk2Y1MEEaCnYTkvWhmPGm5t84LH38nu/d4X01nVOH2tTa5zEyRrt9sOUSqLCmJN1jVSKfs9w+27GidWY2oMtkgcv4cY5xWu3MN+5DUGBLwNOPzrHyW6Nr79xn1trm3RDhdQKlyTkhSKJGqggqjyM5iR+1EcVraqbGEkQHpFBPYB8fp42juN+h1tvbPLK2hgzF3Dm/DmOC+geEVwfTrjVczQaATKqMUEggVQImgtHWFw9Re/+BrVRykeOC169vMXURhw/0uZMq81oN+LI/HmOrj6CnA7Q5ZidrW1ur22yevQYQmlOnjzJ5sYmZVlWna09rgwz6eFKa3p/3jrMz6mun9m0BvuyqHv31mHFLvaSaQfvvkW/11Cf/exn/8CNP/uzP/tZgOUnz5EstlBRQDS/yI3nXyUzuzROt+ieXqBwcPWVGwxe7iPkcZ7+zKe41G2SSMHYO0IPWjjcaMh00qM/SSnygkQ7ZL3J+1oJw7iJUBEREoqUtY273NqMeOJEm7RMefN6j+2tbSwT9In3kr78Je7rJeZbCUeSkPMNxYMrIbcePEJvmDF55QvkO+sU4wm2LPC+oBxOsc6RNEOCuPILcHmJFB4zKjCFAyXQWiBx5FnlJBrUApL5iCAJZ4RTW0G6hIBZt8H7ykgtjlXFCVABzkGRWfLMUhQem1t8aanFGi0sgaaSywwkRV4grKmSDmvREgItsYUhSeq0Oy3AMp5OmU5TTF6SZSUqTkhUUHkOiEqS0xQ5oyyn9IJ2t8by6hxhIBhsbJKOUgaTnG63Tqg0gQeMJzfgvcR7hStLQimxxjMaphTZtHIpFhqPoJaE1JMAXxpyoenvpqSFx5UO5wNE1KTWbJKEmihqkWUlQRQilWQ6GrJ7fwuigACDDiCuBdTqMYHSRGFEWA+R1u13HIyzuDIniBNq2rO1uUOZDklUSRJEdFePQ1AjCiTOSqwBLQQyrBEpT9Rok8SauBYQxAHWC5JajHeeLEvxvsRTyeE5gioxALRSVWggQOgQHUYMeiV+D+fqHbY0pL0JzguUFnhXeU0EgUbpoDKiM4YgipCBghlUzViDCgOYOdpKLKGWhEGAkrOFUXi0+n+oe/MgyZL7vu+Txzvqrur7mOm5d2bPmT2AXWCxBEAAFAjSFCWREmkxRIcVNOUIBoWwJStshhRyhG1F0LbClkTapmWTCMGCJJIGAQIGcRBYEMdiFzu72Gt2Z+fqmb6P6rrrnZnpP153Tw+AoKCwFQTzj+6KqlfVXe+9zPwd30Nikx7paJe4t0f3W88zcmWi4RqB16Fc8Vlpp/zdf/KbrF7r0s0d4xXDpfeUeMdfa6GON+ntadaeW2HnpSFzlxSP/IjmyUck7z6heHDB0WxYLJaTC5q6FfTfNHzkgTJ9IalXPYajwqejpHK80R7D3YQf//XfJF88i+d5dIYRqzt9TjdbrPX2kB2NCkLeWu3zxps9JtIWv/DTH+FffOaLuPErnLl4Hm/hHOu9CnY8Q7N5jq98/rd47J0PMT0xjzIlnNEcPz+B5wKqc4pyUMC/ZL3M5E88g37fk5z70GME981wcydFIXj/JZ/VL/635OECl37mfZy8+ACNyUlEKojXM1ZKCWLWw6vXkLUQtIdMNY2mT/10haBRxSHZ2ky4+dpVll/+fY4/EXDjSy8xNTWNmpukMlPlxGKdpbMX6HW3EdUmZ3zF/RIuHJ9j8v2Pc/mr/xo2Et5Yzqg+WKMx5eN2cwZ7kps8wn3hEuHtDNfNcXkBw2mdOYaINFJ5CCuwicWMc8gFWScDKYmGKdgcTxu058j3K0rleo1Bf0iS5RihyKwoNgtrkdrHuBytJYHWDPtdJqcmsEYSExCnKcZlOKt47Y9eBuCjH/0ojUbjSHUKojRmbCOuxde53l7hxs01tm4OyOwM737qEZY8RQoYQAtQOFySEGcx/cQgncFThczkycBjrEOUVARAlka0h2P2Is2JRkBqUm5sJ6TRHqpaRlan6d56g35pksVqyISnmAsErYbPaLbCle6IL/+bj3Px/Dm+8idf5fbqHcCSxsk+xv1IZf/gKx3ZHI9Wjw9MqO5WsYt3CCEOuwXfW2y+e+xB+/9ulZr9yvW9sIBD/DB3oS9PPvkkH/zgB/+0/fqHdqyvr/Hxj38cIeT3QiA4eo7FEUjXXcWno9X9u5r/8q7fw3crsLCfVNh7E4sDQrOQEiEFWutDLwJjzH6wdS8UIwh8/vbf/ui/71P0fcehSZoxOFd0uVw2wqRj0n6HeGODHJ883cPTY5QX8vryTf7g2T/i9ZdvsjmOGd3q8uAzsyw9epza/Dy5CVl/4xVWXljl/HubPPFEnYfPljkz5TFfh0opBZmzNFMj30yojx2Xlpo4rZioV9jdHVIqKwKGiOEueWR55y/9V6SVBoEQdMYpWWap+z6DOEbGCulrrm0M6e1ZZktNHjp3mm++fg2dLXPmiUcY+pP0owaBXKBWneRrX/oM7/qRi/iqBFahPUVzMkShCaoCrSTOWLz5JuETZ1AXTzL12AJiuszmesLiYshisMn45S9iKzOceP/9NGan8XwfFxdx19AziIZGBT4i9HBWolAEZUXQ8tBeAZHutFPW33ydwe4VJpY0q6/eYWp6CtGoUqtpZlpVGvUGURIh/JBZJZkHTp9aoHGszJ2NN3C3h9zciDj+jiV862BoGcdltuwFpuUkbn2MJwoBm3qzzqn7ziGMREjF4sICb799jd3dXaw9ck/vLyhKisN5dXTdOPDlOEiU7/Up2U8crDvsQB2dk9ZYsrRwBf+H//Af/tff7978wRySM0m9MU84O0EWhEw/EbP6tSusf2mdFXMLUQ6QsgImwdczPHVikXbZR0cx/ijmTq9HbTak042ZxBBHPVLrmCg3mceyYzUOjQwcs/N16jqnvzMgFOv8yUtjpuebHJ+oMFg8zo3UECpDl9Osvfws//iFZ1GNWapLS0ycmmJ08yrRs58j3tnApmlh6BVCFgnCZoAnQbkMN7aH5Ki4l+CHAptRYPaNONSdF6WAsBkSVgR5JyLuJeSZK8ywrcAkBcZc6AIilI4to2xMrRFikxxPa0ASxbZw30UgA4/MZphhihwZhE5xOMJGlalKgMkVaWbIohwH+FXIB0PwFGleuA8bI6jXqnheoXaUZYUijzGWOM1IE0Ol7BFIQ9TtggXtBKrsM39qnjw2eL5PmsJ4ZBlFRTtzWgjGRiArXkGkJqHbG7J4bJJ6STNIE3Y7PXpdj7RQfCX0AKkxuUMGPn5YJo0dE9MT7O3cwuYZQuQF5MpYSvUyiTXc6YyYsAJPSpwVeGGZ0ThBGYnnByBy8nQAwufkmVnSQcpeO6ZWKyNSVUQiViDSiLpXYTwqIEahr9D1Kir06MdQHwxwXlGhQAqU0GBzrC10zZUTGCNIjcDLcrQEVSuB0AhlUa6QLPUrPq7lg7GYKMOqon2dJjF+tYLSHlLmCFl4AljnGCcgTIpNBgjtg1Y4KRBeUREQQiLimAwHIse5HCnqICEfD7FmQNzdIutvo1xCcP7djGNH2JrBZG3izhZefJXzjT2uqOJ6XDztoW7lvHG9zW4Gv/R3p/jof5hgMkd9JuD8vMelmmMcZ8SxIbhtCMewbhW1YwFP/9UyH/unHbL7Frm4lJB3Cz38znaMSHLe8x/Mc+7Cw8z4JZ5fscgk5IHyBJfbt7nUmMGfrvD81QhXWeKZ95c5X074nS98icreP+dHfvTvcHN7kdHugFb9FfrJ57h+51OQBTz/9S5zczkPPazwpaQ+gnVtqYYw/voaiZOI4w3SYcTzO4bTDct6H06drjK8epv/6/c+xwMnpnj4P7rE1vEQ3Qro3epy+xtvsnPlORYf+jLnPvJRNs0keUlRKXvUtSJLLa8njsWyJldlvvGFL/Lpj/0O9Ybl1ItvMpdGfO0LbzB8cZFTFy5w/5mHuPPcCH8+pLa9x+tzDR6Y1lysW36i6TH96z/L7/36J3CZhhVDZUozP1nD61rU1g2Wtw3OP8mxE6eRlSpuO8b75g6VwFF7IkCEHiKXuLEh6yaEk1O0Nzbp90bIMEWlFrTcNzuMSXtDnAyxUhFlCbv9mGEvYqqh8ctlrKqT25Q0HTDbmqA3MGRCM6SA9tRKIT7qT9sCCL2QWlIlu225s7HLjVtrdPtd5loXOdeqsZFlVDNDkmSMbMG3GiWGBoWXSsX3qEtNHcfA7a+DWjLVLCFMRhyPcHmftzZSmrWQxyarBP0FOkmO05ptM8PbN17jH115jUprhtm5iYKzsLtL8tpldlc3+Jt/7x8wHGxSaTXob++iPY2zBrVvFFnsiu4I7p17NtxC2uNIK/67W+9HSQT7gf8+IvgQTy8Oq+P7H3nweUcwAffggw9x9X/exz7PyxT8MjjSEdjv0hQBfgFaO4BYHTAzpCqq+tYegQlRVFCPnrcDtRW1L717l2x595iDofavSUH0vCs169jXkN9/7geBWPz7G/s4c5PhTA4uJYvHkI+QQqAnj5Mb0KUyJu0j2KIurrFQWsMFCiM83vfuabxhzsbzy5SmyjxzaZp//Okd8jSnOTHBiabPpJ+R5RHGRehegk4lHZdx4tIMq9cTPv+NdfIz9/Po4pjRqsZGKe3BgHKouPjBi0xPzFKTgld3HfNeQCAd28mYuXIVJTVvrWc0J2aZPyFxyYjv3HyLyvAPePiJv8n1zRKh36Pub9HpfJsXl9cQwwrX3oy5+DjUqxLhIM9gpB2ehuSNHnYiQISKLLZsRYbJkqQzhoWzIW+9cJX29TXmH5ph5n0nGFQVc6Gmf6dP79Y62fAa9WPXmbrvL9I3NQgEJa1QQGYdHeNoaEEuPT7/L/+QjbXrzMwqZm/kTKUxz33rGqPJ4zxy+hS10gy9tIyuacrDmNuNgPMVwYy2fODELOd+4cO88MVP4/KQdHlEsxFS8xRyEBN3rtJpnMOJaTqRY2LK0bIBahQjfIk65vHw/Q9z4dx9rK6ssr6xgZGFiZ7Wep+7yKH878GtflCmsHa/y2DtYZEB7nJ3vtsj5F5M458+fqDkIJyco9laJBQBO5HlzJl3s5ecZGReJ776JmZjF2FihFfinf/sI4TNkHNC8/ragLe2hzxxvkE3NkxmQ5b7ORWhOVaCUOTcShTncQTWMBP4ZE6x1WzSPDvDzmc/xfJjP8FinjFgizz0OD77OPWzNW5Nw9Ynv0DW7+FMylA6tn0PWQlxJiPPBBiDyAzGU8iSxjqDSwyZE+SZJUtzXGZwmSNx+5U2v2hJ2tyhSz5hQ6FcTjIwZMOULM4BgV8r4ZTAyw1ZYgh8SVj2UFqjjCBJDJWSzyAy5GnhOJwmOeVqiFQgsgLOo0NNtV5h2BmRGouwDk9rbA5JluKUopxGlFtTlAJISh6jUolkMCIZRSjn6I56KC/AUQSkUkI8zPCRZC7DDBLAIqQCHTLsj4ijDKk8giAkDDxcZun1Y9qjEVb5mLHG8yVKCWamSozjlOE4wliJ5xsC3+JphUxTWvt+CUiJ9AO0Lsyk7mwNUEGLipeR5ClZlqJCn4pw6JLCZgYhNdJTuCwnGw/xhYcXCEq+QmsP3wsJdUB/e5uw1KQ2MU0wYYgHfVyaUas1iKMEYx1q/zpLpTFWkMQptboP1uCHJZTex8QKTZrlZMMuYckjNeCcQkqFyzOSAguEXwqL6yk1CInSEq8kkUiyZH9T8z3CBR+EwPMkOEWeZ+SmqLZXShLlSphMFRJ1AqSnEcovJnaWFd0Bk2JtTpZldIc9GlOTeCWPfCTwghDZrEKWoLdfpNF4iE6vB06S3dolu3GVX33mNF9+8xYfejrgetvw4tWIaD3BA37j1zaozgh6OzCR5pRHgqTvsMOUpO/YCyWJ9tjblNzasGxspJRnPR4Ke9y56chyg6prEifYvJVRv7zL3wpgbxix85qAUPHI0yHvVtO0ky53ZI2T52tMC0Hevc0fX/40/d1v8Bc/+Gt8Zvs8d268SrbzEm54BWNjjteqdLJjTNan8LRPFFuyzOEChROOzeWc6rlJqiWB8gS+0ryz2eONl1b5oxfWad++joqvM398j0d/9idYvXOVWe88t756nZuvv8a4/yrvfWKASgPGV3+X1jmHCZ5EqTm0FKgQToQBn/jvP8FXn32J9niDyvQEw84GX1/Z49TjDRZnTpFTo7t2k6/cvM3Ck/8xc5WQl774ee7cXObL0QbNap+5YwYvXGVuaZpaM8DsdLFZxqgvmO0JPlCSqLBJz43Yeesb2JUmp06/C+VPM8hLBGFKcL+PCkM8z5ClSaHbnkt86e/zZiwiyLE6wmaOfq/L2BhiIPcE1UpANdSU/cLROBMCoXxUucFEc4psMCI1MB5laL+MsIrRqPP9QxdHUSiRkheXb/PlF15hc3ubeGzwmw3e+YsPowQsasWr2xGhhrmaR5RbaibhTmSZ0h5VBRbLrhHM4vBwNLQmsoKgXiFMxvSWbxIvPcCss3REh1LYpFoOCZuKmSmPb37qWYa7XYwZcU06/HJIdbJBPfDoDSFLRqggoNRqkKUxNs/I0xSh1HclBfuVZ4q18gBZci/h7+4eehf+wj4f4e4+e+iHcCihevcjDqreB5r6B9nFgUHX4euHSjp/fpME54p14mhi8N1Jz4GqU6GmUiQL9oAjsB+zHJrVUWi+FwAje7cyKg6UoQ6Cn7vJ2MF1PUwYDjoRFNwwuw+5OPQ2+KFIyg4quqbg9qUO5fvg2YJbFq3j+zOMx6MCFXB1lQmT855HHualvev82KMVXmlH3Pn2bUx7RKMiWb6+xdRSwMaKpZlHqNRiTIxNR2SZY6xDEluisyfZ7cfs9Q3NOZ+T3iYbtx3Cy5DNEjsrjtXlHtXaCu/+AAyinO1lQe245FjLp6IckUnYEz7H5wNqUtDv3GF95wpZusLFh/4G3+xOsrN2DRXfJOrexpcZD85Ost1colYuAYIsLWBhdn+aDPYc4clqgeBQEDiLihK21gZ88/UuyeoqgdrgxH2amQcfZtDfoL44x8aVLVaWr1IP2ywsDgs49s7XKE9rrDyGEhKJwFeCmnB863OXefb/eRsmHX6jzGanQ1tbTj3YZKl1gtiUuHX9dXRlntmTT9BQiiuvXeHNW5t82WwxN5kxNRHhe22m5o8TBB52bxsrJS6BaixZqpfxwhr9NCLYXUezCHYC64XEVqI9gzev+ZW/9SuUwwr/x8d+mzTLClNdZwszxuI2OXK/FJKk4iBxOFxX9hPoI8aKcr9ICf/ut/sPlBxU6jXiXLC53SctNWk7j8F3bmPyRagohNlCVQMaH/wAj5+5RD3QXL09Zr09RtiUdJzSi4bIeMSSD92xYyADvHpATad4gzZJpcJ6pqiEmmbJY2GyQefSg7z17T/mlr5Iqup4lYy4N6IS1DnWmOTUf/afcuOVVdovfp1k+Q1MAswtEJyZx3z12wgjkT5I34BJseMMLwDp+0gF0krytGjROxxeSeIkeFWfcrVoRZlxSh4bomEG1qBUoWpk8gybSwJPQqCxzpGlhYxl6CtEKEkig3DgBxL24UNKOdJBXFSyhMIZSZoa6s0ynq9wUmOlQDiLTBzjOCZKNTXfEsUZQktKoUKZEqMoJxqllEsSJSVaS6QEJzVJXZMmEZkSCAq5Td8r2rTKKbA543GCiaFaVtTLASaOadRnYdQnxpAlOUoIypUyCYLhyCD9AhvvK0EpUFjpI7OcJLPUp1qUyiECSNKccTwktwolcsajIePBkDyJcVLQrE0SloOC+GP34TR+EVCn44h6uQxakePIrEXroCAXKldAhoRgmOds9QZMuIxaY4pSpVJUlFyhjFcphyTjBCMLabBD1Tup8YKAaGzQXtFFMKnB5iC1Jgw9cGUkRSm+IFOCh8DzPZwTeCbfn7jFRpTHMZ7wyFwBHRPOopVASEXRZyqyfmdzzDgjN2O074Eovl9uUrRUOAm72xuU6k2ETotqkRsDKVmeoyrT5GtXkUqT+Snd0NKduI+ppMXf+/njNI9rnpQ7fP7TN/n2zja5dYyBh96hef1rGVsvpXy+n/PaacETD0gyB39wXbDzUooRmjhWDNZASMUOsLmXIQOwqaXfM3RGhteuRjC8ic4WeHypRDuGN28I4qDEwMHEKGXCl6z0l2nvvYWsB/ylj3yUzd5JBpef51S4g3c8oBufxZ84QTaqUe32eP7rH8fe+BbveOIdnPrgO0mkplwVhMfA1xrnHElsaHeGtNxtvvKZr1KKl6kPRlhh8DPJy9+6zJn5Erde+A7xzSF+1GeKlJe/+ja6HKNulGnc/BSL979Nv3qJ13tnyHd3Wfvyb/HVF26xvt1Bl6BUC3D1GvFCi2s3BjSjPWoTEX6lymS9wvz6v+LFK7P85NOzVJ88ydomXF3rc3PjDtGtPY7d1+LWrTZnjoUEnqazmzIc+lTEEsf7KToYUilpmsLHvz0gCNbxF85hXjdkJkUtaqTUeLlHEo0IhEJWa0SJI04NaZqRDcZUpqv4nkfqDhSCipZ64BfCCNLlOJsSZ45RbpHOUK6W6e90mKmXsVqTGUM6/t6d47BNjSDNMr6yErPLPFmtgr9UY/7++zgzMYsn4cZeRpJlhEKSZjDOUkSeMe85+rEj1T6+lITSIJMxue/TNoKyp6h6mqxeZTQzye1rb7B5/2m03yQMR4TSUQs9PFHlx37uJ3nt7W1WL/8J4709rPaxk9OoxSm4ucU7HnyUW+0VVpdHCCAsh5g0PcTCm9wc4tDv8guKjfdAK985hzPu0LCsOBF3k4YDRaSCl+YO4ULF3C4kru/G+He7EEdFVg8qfAf/Q/Hk9wcs/XkaztmCCyMF390dOegYHH7HI/wPxN0uw93ji+De2uKaHe0yFElYoRp1SGHYf11wlzNSwIgEBwpKhVKRO/y8g+Thz3IUf18Wxb08xZoUIUxBThYSoUJsfxMhFM7LGVbrEJ+gSYtf/NElJmc0x8wW//fyHjvjhNwXuIri4fMBaTdm85Uthrs+C/M+CxM+iYXndiS3X+5RazUYtR3JAELfowNs7I4IaopBL2Fte0x7dYRjh59LO0hb5aF5TWZgvQeZ0qRANS1gixuDdZKkTa0xxcLieQbpDNHb1zjbjMhNjX71LJXpU+SxT72f8PwXPkn+1v0cv3SWyolJrJB4HuhGIRhiLaSZwWQJMuvw6leuMaHW6CU5YUVgRjmbt24yMVFi+8YK+Z0BdZXCXpe19TvIUo5YK1OZf5bWsXOsuZN0ozJpe4vdy5/lm5c3WNnsM0MFVS5jJiaJJ6u8fmvETNql1YgIGw0aOj5KdW4AACAASURBVCHc/gZXlpu8+/wkT56cZ3svZ71/m62dDZKdHosnp+jeWOfB05Okw4jtbkonCqA2S2sY4wU5lUYFN86Jx3v4VR/ZmsDcMShlqFYrTDenmGpOFpxF68jze7tiiANJ3n3VrUMYHoewyYJbc1cQ4ID/VBRC7oU//tvGD5QcJIMBo26P0dBgXQPrB6ighuzXCUqK0uIppp46y/yjD3E+nKSfWNY2dxHZgLmGxaZtqnnO0A4oey26Nsc4ge97YIakmWPr1i5qsolp1WiEPtPVChOzx0l3nufmyjaKMqFzVGczhICFY+dJjs/z3sXz7Jyb4daLs6xevowNBdIL8I9P4uIckggX93AU6i9BzQccUjiU77BJocbjnEMGEicFqqQIJ3xkyWcwHJMnKTYtMnvlS7RWOOsI9513RWKxWU6eOVAGbaFUCTDC4falLJUH2lOY1GCyHPx9fHFQMFBVUAS8icnJM4u0Bu0JROrAV2QmJhomBL5GS0UWZ+TGFaUq5eGwCOHwdUHQmZ4K2NpOyW2BWZNSYingO87kKFcEu8oCmQEXoTEkcYTOIkqlgFBpTF7ApjwHgecXevzk+M6HcojQjiTPiUxRCZRKYZIUk+fYJALpY51BGIMvBX4pwEpBq1ot7j7rkJ6P72uMzUkTW/gXSIHEYfKcODN4wuAHmkAYktxghIcKK2TOMB6n1BoGk6f7C38xaaTNwTriJD7chCwO5QeUpQKpCiiUBUzx29NeQe5WCpNT8AqMxbqDDcvdzeadw2Z5scflOSYXZEla8A50oT6ENVhXuLRiwBmDzTNwAuMKedMoycBmGFFIxA7GEe1+l6mqABNh4zZm3CYbWzLTIs1jfLOOGe2iZZNg8SzxboVLiwIZDFDBgOVZn95DNabmy5ybHlE9XmK2atm40uPNl1NubEnaicdo0/HiNnRvWUpeToCDSFKqC3Y7GaPEIoygVbFMlWBTCNoDw//2v/w2F5/8EMdOPEqjPsVy19GXirmJGrNJRhJbrAxoTS4yUTlB4C1x+dVnWawnlHSDXl8RDQxh2RLZMozaLK9cY7S2yeZ2h4d6PaZmTvLAg1PYiQopjm4vprO+i3/7Cp/cfYMLrYTLV1exsaRenaQmq4zeusZOXCY4vc5Gv4vOa5T1MdpJnxnR5vqyYW6lw8r1m2z7Y97Ye5lBe529V7/KnX5MYgwajWlOET6yRLk0SXz1Cr3cku51CfyIcjBC93eJuqtcfXOKhYkS1SDi0dOOs8cajKc0g7Lm9mBIf5BRCyXlhkYGmms3uvSEZq5kqdSbSFEjG3SwfoI3FFizQNbOyGc0cgpETWB3hrggw2t5GBGQi4wkyRmPcpyfYozEUSiVSMDDIqzFYpBKY/McZ2zh1ZIZEAa5j4V3hf0mSvjff/F3jtxavr6+wXYvp1KdZ/rkKepLkywem2NGlxjljr3+iJrOqXggTFHtS1xMWVXYsxlOKLQSWJuQO0dnd4Rfr6Kkhy8EtSCkUm0Q9W5xqzNEp5qKb/G9YkNsNaYoN2t8YGqBm5OK5beusNfrokqaaqnM2YdPo2o1XH+jwG8bQ1gOcLZEmmRoVwhOWO7OXfYhJXIfny4Ak9vvCWyPHL7/Xu4Gtdx97qAzcSSrOPIT9qPge5KCH4ba9f9f4/C8uQPo0N1T8X2D8MOOSwFJchTwzaI7Iw4D+3tTq/0OBOKeZw8e330Pd02l7mn93Pv//DCYoBV/XmEphCvIh9gsxeQCkwcYk+GJXdKkhy7NYfQcKqlxXx3QEVNBj7PHmsxM1phoesxPp9Smq5TsFP3bN1nvp2wPyqxMQ283582xYns7YzoaoyMfbRUukOx1xwzSnGggma5JqiXJupMsb/b53X/9b3jymb/AXOsY/VTQywEpqYc+jdySZg6pfWrBJKH2sbbE28tXWKxLSl6N7Y7FCIFfFcRKQzLm1u1Voh3DmWHEsc3jNKZaTM+VsRUf5Sz9QYbd6zJub/LqzgaLE5K3rm0RUqOiW/hpTrKywzAZ4y22aI/bVEtTWDNNlqeUojFbKzmTW0O2V7dZT4Zs9ROG7XV6y69yZ6vPKM9gr0pt5izl07MEfonR7R5d4zCdNp6XkGrHyMUk0S5Xl1eZb/jM1nMaNc2g3iSq+bhqwLjt2GkPqQSSUt3HItlY79J1jvmGhxIt5EChkwhZ3kGPBEJOYsZAQ/DAxHk++NT7+f3Pf5IkTfYVvQ66j9yTRB+6s8M9cMcD/kHx9JFWp+PQdPGetexPGT+YWtHWDuXpJkJUMHGMl4E/s4A/SBGmydSFM5z/8ffysJcTWsmNXsQ4GzFbMxyflIyiPjIShMIyzHUBwSlpPGkxccR2v8eda3uEe03GCzPYuUlO1Cs0SlWCVp3uTh85GFAvx9SPg9+q0pg7RXec8fDpRaLz81RPzJEkEe31ZVjfITg5i93rkm8OscMEPIdX1qhAko5ScKaoqHuu0AYHnCgWJ7NPNEULTJYVFQhVVKMFBfFUCUl9KmCQFLKeIitaomlWdAtEakBJyPb9EXDIQOFkIT3ql3yE9lCeQvmKzKQ4IEszRGbwtcDzFTUZ4oeKZDxiNEiwvkYLyWiY4ZRHqaSRoYdwOS535M6ipaZaDWkrSZZbtJJIpXFCk1tLEkeEMkD6hZ+B3g/ew0DR2WvjkTNR9gg8j0wIMuOQTlLyVOEymGakOFJbRytJZhw28LBKkRpLNI6JoohkGOOFhfeCsFAqlShXfXLnCEOfUW4oVzRaewghMVYwjjKqQQmcRCER1pFmGbnIqZQkPjDILVZpfC8oqqJJSpJlZNbhyQzP8xCeJkkcAoW1poBHWEeOwxeFyoXn6/2KokA4ifYkQSnAK5Wxdv9a7E9NqRRSFJhXmxYYVuscNjNILEoWrqx5lOKkQiiNdJI8TUCCzS3CuX0ddIHvaXKb4lyR1AiXkecZ4ygmSlPanU2qTuPnXey4gx2OsWNNksVkXouyXSFPRzQqLUrNGXbHgpLp4e1uMk4yzjSPU3//fcydFVT2XmdzGPCOpzy+eHvM7ZWUcd+x2Td0b1oIBMoXhaa2tJRKgkA7xruGSkmTRJaKEDRaiuF8wG475zd+8xP85XbMM++1HDt5kWONKepCcnLCoxQZbuxklGpT1IIWuYn5xuXvMFh9lYX738vOEFa6PTpbHWplg/MkjckScX6cm+u7rL79Mtc3Njh38n6S1eOY6VmkNOzuDRmsrHNy/TKfX9viH/zMwzy300TnNSrlFk4YykNH++Y2i2en8I416I4W2GMWb34R272OEDG3byT0bhi6Zpm9ZIOtzjKZrxAViecEuYGxytGTkorxOHZhimHYQA+7mHjAKB8S1UsszAz4+ivXaJUs9y1UuXCizoOLZVxd8eb6iNKCT7ud4Kyi1vQohxl9u85eXqGW+ERDyTh3+OMhoTdCruXImiK7XYOSjzimkY8pzO6IvO7QVYruY+CjbApOMe7H5Biccjgt8LzCSC/LczAWJ4P9NrNDS0hzS7yvHBRFCUYanJDsS2IcjoNgyzjHII750u01POE4OTNN4/wCE4sN5iVoJ9mMC232yZok0IY0K9ZDTzjGVlH2LcG+yIM1Gb04YmdnTJDEpK06U5USJa2oeAF+tcxed4Q3gIlmTFApI8OAcqVFnhouLbRYnH2aVqvK21deozMc4HUHnLx4jhu3bpObMZ4HpVpI4EkcOcbk4IqKW5EQFHPwILg/4LgehZp89955lFD83VW3Aw3xg6D14Aze8yn7f8MeoIcOguDvPfLP5bgnaIEjkKuDI8QhqfjgCxfnVN6TDBz6BBWHoKQs1Htw7Dul3U3C4Mj5PtLpOoQoHSRidxOH77l4f8aJQTEOEhWJsDEuT3FZhk0lxmiMKuO7HJGOqDQUqW6QWo22Y9RglzjLuf/Eg+iJGrVaihzdpD/2efSJOf74+grtdsLOKOX6qqG9nuFCnyDQuHFGoBSlQOCTE3dSqpUyUT+lNekh50rksWSvnfCvPvH7BNVJ7r8faq1ZWkGIUYJmSaJTx1ZumCg30coxjMYsr60w2ltl7vRjbPYStnsJJhoS+AInK5SrHr35BV6/3WX7tbdY2thlYXGGU4sNTL2BEDmdXkLY2SbbWePVnR5PfOQsL9yp0ahMoStlhB3iDQ0j26a5NIGcLtE1E4jqLL6cx452sNGYzRVB/1ZOP7vDbm+dnc4aWdlHTypKuWRocvBSwqqjITWLJxsMyjV0d0wSd+n6mrjkMVUf8PLNt9ipw9nZCWYnqkxNVzA1xXZvTDBXZn2jT61UpVbXYFOGK1t0jcekrZOPJZVIE2QOqcaozTaiWcJu+biy5PyxM4wvvYfPfeVz9OgXCbM8cr86hznopB3KBu/PF3d4yJF5eHeNg/0ugnD7ZOV/+33/AyUHNo7JRyMyLUjSHmtXLjMoL+LVAsJ6lbBeo5p6XKr6vJJY9voxleOTTFQcZZGyNcx4aXWXp+fnWM7HnJ+tU614bMVDZGR55flvM1YN9l5+mcaJk1x69+OcfWCR1nSZY++cZ+elXbb3OrQ7YwbhFB/50dOsruU8mErubGb4EwELZy9y/ufrfPO/+TVMb5vg1Clcb4CgRx5YdMUjmA5JdgeYfSlABwhP7pOcwCY5whdEA0PcjxCmWI50oElzUzgo5xbPOZrzdco1jwTItcGq4mTn1uEFgtEgIgg9Qg1J6hgMU/yKh+8JAs8rdPY9gdSOLM9IogTnMqqhj9QOLQVh4NOaKDFMxsTDmHwcY3KNFZokE9SaVSYbAb4EnSSMBgndUYoYG2oG0jhDaIVzAukg8CDODVkGE5M+6TjHWoP2FBP1Oir0ydNtbCoZjsakWUYpqOB7JYTnk7mUetXDjA0CQ5blVGoh1jjCcguET5Qm9KMxnd1dZGZwoyGhVlgr8YKAivIo+ZZer49BYESlgD4Zg7QZZhgjKhoTBEgdoANBVTs8T1KuBKhMUpKOKE7J8xQpPYxQjGJJpaxAFeZ1aEGUppg4pVIvpF6lAyUsoe+hhCg6J0qRxAZpRMGhEOAsOJvi7D4nQiogIx0YlA6wWVIYoeAQtjDRU9qR56boRHhFVSvLMpLxmHK9hFMe2GxfbUPjeSFSarI8phJKknGKzSOkTRgPe9SHCePhHr5o4wXHEKWT5K5NXa+TDiQ2PE15fpqS1ozyDOc3mKy9zd6d66y1p3jg8R9n/r7j7Ow8xz/5+pusvLDJ4x8q0+8ZHAoRgbteyKZqI2hkEDY0XkUhM4fOipv//KImGVv2upaxE/zUe6p843LGze2EP/rMF/jWN6/z9I9+mJ/+ub/CwnSA3ROMtwY099vBO8MO3167zjee/xN++a/+l3ziW4bNO19Gj9+irmJCWWHmscd4x7EKz7454O3nvkX3xhu8ma1y9doNnns+ouTPMNLgh4JWRfNWNeCXH32cf/7SMg//2OPMz99He3XAla9+jZZMOVu3fOvmFS7+9K9SLz/I8p5EK8ftKyf4a//5JX7zv/sSo5e+RsXX+AvnGWY7dIVHteXQdZ84M0SDEcPPfht54Sx/+a9/iM3dDrPhJI6UrdQyDJrU5S2mH4mR24aN7Zy3XtzDH21jRl0qUcZ7j9VYnK/QTjL27nQxPctfetcC3Zf36O6UIDKk+YjUzpGpWTzXRiRrKH8KN6piTIAoG1zZQkkS9yOyEHIczhTKPyqw9HpjUgWB1pQ8jVOOLFcop8htAX2zDhIrSVJLpgVxlpHmCc4Jcifp9Qffs+47isR8td1mtxvTbAZcOjFD1KigrWJGCzZzyzDOKE9XKftAntIfW9b7MRdqVdZNzPlWmUQ4xllOMk65tXKHWJbYuXydxfvOEizNMVcvUa35HDvTZPfGkLV+n3ZmOFsNWZpu0BtZzlnJ9rDgaZ04/zCpLNP9yh/TGW7SWqqxGCQMwxSWaoilGuOtNsNOFz9QxNYgnSzW+SPdASkL/L8zB7CWu9jdQ0188b0uugewoIIvuy9KccT74DAB4EgAuw9VcocHHTnXR2A1f16Hsw6hDiJz7lYpi1f3X5eHKk53zeeOuL8eeXxQ+ZeHev9FgGPtvvP8IaxiP6nYl4FEHpFUPaJsJEXhjSOPPHfQyfmzHgJQOsRkHVCTON+iGCCzLjYB6x0nmGjiZAmTgNAeJa9L1L5NpzvLIxffg1fKWd18hedev8H2G1e59KOzpLlHnjvMjkC1IVASlStmcZQWi+KeynNkmpMqyX3Hyoz7kp09y+x0hQtLE7z55phXlwf84ac+zcsvr/LM+9/LuQsnCUNF0oN8nFN24EzG5rjPrd0NVrfW+MBjP85n38oZ7LxBxXSoSUslaDB76iRnmgHfuD0mty/S6XTY7d/mld2rzH8pIawu0PNzGnVJo6qZaZT5Kxfv40tXt3jnTz1GrTzNnWtrtJd3KMuUqUrO2xtXufDuX2QtqhDnApsZBr153vXhOX7/Y6/j3XiV+lQLV3NEWZdO4DM1Z/Aaddr9PuOdVdqdHv79D/D+dz1GZzBgdqnGKE/po8i0psQ2EyfHqI7jRifirc0hKoog2qOcZjww2aR1coZOr8tgrU09U1x8ZAGzHDPelOTROrmZwKMFqgJujM16yKCKG/lY4XBRRugFKKlwxoEqUCoHxOSDm/WwGXYw3Q7XjnuT8+I9B6/9u5UhfqDkYGmmTjn0ub7ZJalktB49RnYtxiyv0nrqaU5fPMnJMljfZ9HlPHMy4PV+xmDUZWU4ZL2rqU+U+fadAU8/uYSaKNOJRuyurvNb/+J17LFt6GxyHFW0gjbWudLMaYZNjjUucaX/ddqrV/BnWrQW3sv5oMyt3hbXa3O4nbgw35mtUpubJxdnYfgy6fVlph8oIeanGLy9y3jXMNxL8TzwSgp7UAWODdIULS/pU2jAGocVAmXAV4LKnEe8Jxi3E5LIIj2JKBemaDLJmJgIiQcw6sVoIRhFOSJzeNKSq8KIx2SWPHHE/ZRaU+BnjtB3SGvoDzNsBq1GiHAZSimk55ED7Z0+Io/otUcF9r5ZwQ9DdMmnWStTr2rsKCWzBWSn4TniQUKuJeF0A41A5AZpLZgc7RxOaHY7Y4QoOiBxljPIc7xxRq1VYvPmBs1qiUpQQvglMkyBe65XCUxKNExwuaVECc8KRrmk5Aw6TyHLcZkljQaAh40dYUNQr1YJSlUkimQ8QOU5kdOEKqfaqlBqlnDxmMlKHT3ZZJhBFOcksSGwIK1FVhqkeVLIOXqaLE9pb24y25pmaamF8DxCX+NjsaMhne01hqJCudnEL/mEZb9QEBrEmKSPVWUQEq9cQmuN72ukJwplJy9A+cWClycxJjH4jQZZEmOkQmqNcBlOmkJXvjcskgojwSv8MLSGoFEhTRLG/RRchqcVQVhCBT7JOCF3OSZLMPGYbNQjjfrIfo92u8uJM47g+BxCh5A4lCwTxxa9+yy98RRh+Qw73Q5bvRd58LEltu0SZnqVpQvPEFQnGG+tUtpb4+//1IN8cvNFvvaliN0Qnn5PjWcerrK1KvmfPrvGu09oUl9ijcOkOWkuiHLB3LzHKDI0JzWypNnddXzlasbS43X+gpfzR2+PuH7zKv/yY2/z8d/5DbQEtGK2OkXYvA9bisjtNn6qOPeuX+XX/9kdNpY/RmVuzPxD9zP3wEd4tH6c0olFvvi7/yd3bl7FpWPCKcjzEj//c/8Jv/2P/gd+vhFwzcUsnF/g3IUzvLCRcH2pwcZrb/Ar73oKr3mMtROO2uwJln/j7/DUU4/xvrGku9fm+MSYRnOWT/3hDX7xl56CmTI///d/kv/1115F2jK/8Mt/nS+//WG+8sYa25/9pwQLknNPTVEXjjd/b43R+k1+43/8JI/8yBP0z7RYnJ/ngckJ/GCK89P34dk7RKMBe1GVO52Yq7dfYe1tw2u/u8Pbtzp8+ILDzyztlZh2nPPKygoX1AIyucCkeIBpv0nZjLDDXeA6GousBVi/gokykje2cQ+HRefSSkyU4DxHKQiwzmBEjicsfq2K9AXOGWzukCiyfW6CEz5QuG1rC6kpZEa1zYmShEFi6Lajexf9/f2klyW80F4jcCn56i6bxxeY9AQTGoSSNCWcbWluxAlxPGKUWIaZIAg0Vzspl063iH1FNh7xndsd/uDKNm6yi+x3eIeUJFFMe9DD1zmh8JkpHefb/Tfprr7EzIVHadVnmRSSnThiJajhOimtmRIqCFFhi8jMUxnfZuvWMj/z9DtR4Yg3r77Nzp0eq9c3wFnCuo/wBck4RSbgPHm3M5IVRnAOd9jCZ58/YA7MMg+q3BSVfyE5ohXuvifQx937e9+//i7G/ZB8vI+PP3jfD0MR+//DOCqzeIjtP0yiiuDGWMMh+8Ddy00oVIWKxwf46OJxUeksHK/3K+z3wIHcIcjoaH51wDUB9h2S921Kj8CV7A9JQuYAbI6qTmKzAgbsRIWcHDG+Qpw28IMFdtp3UL6hPj3ByE3j6ttMHXsUISV5b5d5z/FTjz3Elf6YF7+4y7BZ5qc/coa5ep3ltTF/+OIV3neySux5uCwhzwqVvlwopufKDMcRzdkyRgt2ho7tzHL8iTne8+QEX3x7h5cuf5VnX3wOgaaiQQQ+F2aOU565nyTcxkUd6uE0C/d9iI9/ps1bb36GxQua5v0PszC9xGK5jqiEvPDCc6yt3KFSz4mtYbo5y5MPPcAf/Nan+YVZn++kMRefOIer1diNLFtNj+3hmJ89e5Z+7qFqk/QqHoOXNli68DAPJpJxb4+Tk3VurRp2OhmPP3YMV9J8+G88wv/8X3yN991/josXn+Gt3fdxeXWPW5/732md9HnqmQsMr+9y+40d9m6/wW+tdPmRpx8jC8rMTUxzKqjgewGT4XGkO0mWjrg/a7DZ32Jr7xabK47Ln13h/+XuvYIsy+/7vs///z/55s49PT05bt7ZgLDALqJAggBI0JAt2iQB0TJcsqpcJbpKdskluvzgF72YfCAfKJUtQeWiZImkSBMgiUCAABdpsXF2dmdnJ8907r5980n/4IfT3TML0MV9sEVTv4cO9/Y9fevcc/7/X/iGN4M1Pv1EwOj2gN5Gn7ExdNo5UxwnSk8zHZwkEQqV5dAbABvVWjIdQRTg+gVuK8UTVUPS7fEafwxUB1T3xD7vZr8QuB9aVN0L903hDsQP9p57FyXxuyoOdsegC4W1YO6ukF69SdH3SLdg2C3JR5bASlqeZFPDNRxj44hlhE0UurQcylPeiG6w3DlCO7J886VrfOlLf0ix/hfYr2+CFfj/+AskS7OMVvt898pNfuWLn+LKzBzj2nWycoNmOEVzvs165vFm3uGTyzVWd9eomYC2qjHxYoL5Jyg3vwldTZnN8PDjdR77RB21A697NV7/4VsMrgwpxhqtHZiq0x/VoOjZSgtSWoSnIFAYD4q8BF8Q1Cr1HnxFqi1ld4L0K0k+zxP4AZTOUI5sJWHqCbSzyNijFgWU45Jaw0dIi9MWFfvIxIfSUY5HRMpDWZ9hb0IaBMRTNfyWh+2C51X4YKUg9B2eMOxsbJPveNRbTZzzkT4QQGl8PK9BLFNc6TBKICJFEPp4oxGDbopWmiCuYZwln0xI85y5mTohjiRW4HlYqfA9h18WSKUQRYnLLHnhyLOC7HaPmaUErwSXWnaGfZwrEDbD8wOSxMOfrvwOkiSmMIKd/ojFmYh6lKBMSZrmZMMBgYRma4pifY3Nt9aIp5qYPZ5EEHj4jQCDYzJOwRpEEBHFNRaWfaZlyWDjLk76JJGPspY8zcitZOboHPXYJ/ActijRxuJJRRQGjAdjrBcTxBGBJ5DWUYw1jop47qlqnO2ERCUxnpLgKYQFjEFrjdYaaSpMtTMZtU4LLworHDMOXOWyHEUlQob4gcL3AZEhyh6iKCjGKXm/y2Swi9Y5hw9N88YL14k+/B682cOIUqH1mGwyoQgUYvFnwPQYbaxQrwW05s6y+/or3Nxe50N/+1d54+KPuPXSD7ETjT8/xaRZ59P/8Gm6//QV3kxz1tYcX+2OGKyXPP1YQn0npeEEtibZzCV3d2AhctRbYMaw2XX4UcTiIQ/dzVh9bYB4/ATLh8fUTjtWVgvWXx3jeQ7lC/J4Cm8mx+LhNZ5l6sFfYHPYZOXtz/K3fuXTfOAjn2Vp6RRl4bh5e8jta112dlJiv8W5cx/AhvDGle/QvVXwT/7X3+BP/rffYvH9P8WjzzzJ8cPTTN++y//wj36bhWd/me9FRzne7jDVgNlmRP8Xf42v/MmfceG5B1i/mHNYprTrhvaLE3YubPDYkRNcaid0G20uf/0rXB1f5VP/8/9EPBDIk+9ncvtlbo4nnLkww3/y37+HP//qJS5fSXnpG19j7mXLlUCgM8lmv8bxCx/l8PljtOKIp843+dADbT534SmEGfDqf7PF//4v/4IffPVtnqjN8rPPPcnbt2/yJzf6vDDwaeWrPOzGPKTmOayO4fnHkOFDWD/AyARr/MpROPCIz8wjVB8XFARxQiFz0qKHZIxUHlMzs1glKZRFq8pEcDzsk+UTiCJKKiGBJAiYKIXSBm0kea4ptEN6inbznSZojkoRwzeG487jUneb8UBys18QdRyLsSSUgpGFLVdN2yIVkgUV36FjS26pbaaTGYQ1/M7rN/napZfYXHmJ7IfX8Y1H69f/MXUXs7WyS94d8PhDJ5E1j83oNsVkm5ORIIoDdrTimo75YNtjfTAhJiQSklZUpza9xGTruwQ7kj+/k3PyGMzIFncjePzpj/HHv/M1ZpfqBDM1tm516d7qoXONUoJ8oivumSewe/yDA1lLUZEinXsnXn4fXuSkQFh7QGjG3TMlEj/RzdtraCtxry7Ye9lfhnT5GxvinhLQ/V19pQTOCrS55/xarY8cJOfGGBACeV+Csx/3d0X3PQv2jwMccMAOpjv3cwvug3nt8xHuN7iT/7+qyDQiqCNcis0nFEWBlT6q8TjCjsl27yB0UQAAIABJREFU1+lMT+NMymTlGoNsyMnHf47bNy6S311HBjHUQ2zS4eFPPcvOl/4C4WtW7mrW8nXySc77Hpwn6u0w5fvohsdKX2ILmAktUd1hJorVLWg2WyxFlqyfsf7WLvb8ec4st2ifFVx5ZUBvNSUMQAaKUW2GcHZCmddoHXma+ux5NnoZl1//p/ydv/dZHjjzBEmYkOaW/iBnsJ3SG5Z04jYnzzzA7d1bZKMxyiT8g3/yRb7/B1/m7Ed/mqUTC0SeRFxf51/9/ssce9/HeFvVaAUercgRnDvLqt/k0mvXOXZhmd23MxqRpr5lGV0tyBfGHDrb5lYY0Ot0+L1vf51H8tM88MGPkuQCce7DbL3+A95KRzzywBFOnD7CxSvXeeXWkK9/7Y84u2S54gS9YcDQzHL6wfewcHiWpu/zwNEmjy3PEhx5EPNwyvrHhvzJd17iW3/8Kh986DGOHZPcuXuXb98ZMZ/7dEZdlCqZC+ZIvA4iWYDkKIQKK0KsBi0spbCU8p5CkZCiKhBcdV/Zfd+C+yF8vBPSaO4j9kshq6nDfuG+9/p3w7N5V8XBZKzpKJ/ZmTprk13sKCOYOUPeXaEcjJj0J6S26oDEVjKgRtPP8JCkTjJtS/J0mweOnAU/ouYVNI+04MkHcb/1ZahFBL/4WX7p459m7bWrfOOVHxC0pyHsMHfIYd++g+mPQUQgW4xEyNxwE6/RIZjN6ZEzHhlS5SDYRec5XiZZWKjz6PknefrIQ4wKw4k45n0P/Q5//uqbXPxWn61LBeQWPwR/zgcB5cBhtcOVIHBEiU9eCLxQ7WHnq0mDKzWjsSNpKMwkQ2uNEQ6sxY8kHgKjJCZ3uMJUijiugjEJDHHsI4RD52V1rF6JOQL1IKIoNLnW2DwnigO0MgS+oBZ51Gs+yoNJVuJySz/zME4xNd0gChUORxCHlELSJGJiCtIS0ICyKM8jCiN6eYFvSzQeRVGRd5VX4vkKL64R1mqE9Qjf98jGJXPNOmkpCMJphPTp94bY0rK7M0B5HqNMk0RRpdCDz+zULEU+Ig5j4lpIXIvwrSN3JZOiZDzZZGIEWWoR0mdS+HhxBxFOwWSAzjVBI8L5IQ6fsN6g3O3h+VBajygJiZIYV0r0sE+WG4zOKFyT0A9wKibThu5YU68JslxX0qkO4sgHLQiimDK3mDJDR5Y4CnACyskEPwgwNkMIhxdFRElSjasLvQdDsDhjKvM530MKwXCS45VFJVWrFNZYsvEYFUV4nsPqHKcr7oPQOb6tJGZrPqg4wFc1tPbQkzHv/eAT1GZOIJWPK/r4QZ/pqTF5FmCUTznso6I6XtImaLZJpjrUe7v8X1/5EefO1Dn53ONIKfCER4khmXYsvbeLHHeJ3AS9M+atbkE9lPRSh7YN3E6JLwyttsIJzd2tkn6gkC6iHHlkpUH1DMvS49XnV3C54+RUxHMn5pn9u08wmmkxNfsIF4uQVqSZ8RcoRod45dKYN77xP/JLv/lb/OyDx2kmLYrSY2OQM+gWvPTd71E/NMuJqWl2Bz3Gk5AnH/85Hj59gksrPW6nKYcOLbAdz3Dzypgr371Glq/SvXaDM+YpNgaOgZA8s9DCve9hzhxp8YYVLOPTkAFmt8fpZz1q5zpMkNQ8R3L8PHb6DQabN8nTbT77zCG+OvgAu9d6DFdu8NYrW4zx+dgv/CrPbv+A52+M2LreJ89KFhuKp2uCF25scft7JQtHFvn6lS7fUFtMnWjyy590vGfmIY78Vx/k94/9K7ZeWWXTLfJTX/wYD1y8w8xgnfraLMXNiHKnw65YphPNIdsRfi1EW5BtQXxcoR5YwjRzVOChzQgXWTzhYzNLOjBVQqQLHLZSJioLsrKgKHO0EOjSVKIHrqRIMxAekecRC0NhHVJIIt9DBOYda/4+DXSQjnn51hX85hT5xhp6nGFLczDi9hGkwqeuCqSThMaRuBKjU05ML2AQNKQmOjqDvF3H3OnhLc0x/7mf55MnHuC7332F2zt9Fg8tIr2IZt0yuPQ2stBAgCXEOMlsniLDiKip6WuDUIpcalJGdHcH+M2IQ1N1zi0+jpwWnDid0lmY4kPvnefizhv86EddtG3R7IToPGPjRrXG2D1VzKo5LRBKUpaVeIWrJIj2cs09daH9/HOPMLDPSdqHyBy4I++fR3Hve6Xhfy/ZlbLqbldQmb9kAvE3LOQe/OqeKytUHIF73Urh7sGxDliWVH+3z0G4HyYkqKQYhdgjju8dV97XHYW/pJi4j/uwb5Ym5V4xYu6DFh18+esPp4fgDLgMz0+RwmC0wkmJTseIqIkK60i/hV9vE6YTXn31KsuHOzQebiOlQgiJExY/NMxeWCVgRMP1Wbs14s52n0T6dCclpTiGW9siqUlqNYUWBevdIbtBncC12OxLinFOPNbMiYAX/+IabmR55GiHnzl7Gu+DM5h6gzhZ4JaN6ISGhpyhO0y4du0Oa69/i8//o3/I+5bnUV5EWUJaGvr9jGtXb9Oc73Ck0WZtd5NmPM3JhZPMdVrc7aXczlLOzHbYMAG99QFvX9uin66zfmubJXGcyxPHciSJ2jXU6SWm5hvcFpLFtkQUgrhRMvugwp+JKIFYCeoPnGPzRyv0N/v4Iue5Ey2C8YP0mqtsr2/y0pvrnDhznGfe959x4eEbvLg5YWe1T+jB2aOSRPhc3dll9fUCd3iW52/u4GLF3KLi8aOwFC/yuWc/x/M1ye51QSEbzD+ywNI5mBeGaGcGe80nK9pIv00YJ9Dy8OsexkDZLBg1LKN1h/yhBAXCiIPp2/7ycM8VeX8+t+8h4tirGe4rzqu/uD/2jQTl/1vFQSN0NP2SgUnBTqgvtRnd2MZm2+SDa+jhUTyzzHYeIJFMiQpfvp0OGEzGzDVqbB45yubOLnk6RIcxpw4t8vPveYQv/f5h7GDAEx9+jvNHTjB58yb5eJtJOWAoffpFn7K7i1OO5myLuekZtjc1Mat0/MNsuBHpKCIIYD4psPkLOFviwogzC8c5t3CeqLHMa4NNjnl3mZ3RvOfhgIemG9x8QvO9yym7r6QUuaXoG2zucLo6qcIHo8DzBV4o0Fpg/eoTsIUmnzg8ZdGyUpkRniCqx5jCIY1H6fYIJapKJnEWTwqSQBL4ArW3YCV1n0nNw4sDvFCCryr1o0yTpz7WCLxGQhQrwijEGoHRGbVmTH+gsUKQpSW2KFG+wE8CAiyjYQ4IgigELEVeEoiKlChliBAeprRkmcZog9EWP/KYaU/hR1Glf1IYQhVRqzXwS0MmIpwX4oc10kmOERrrfKyD0mqEqt5jEMWINKZeT5CewwqHUI5aLWGSltg4or81rJQStGU0HDMZjYhMRVjWpSXQEPmS2K8gL1r6OM/bI1pW0B7PC7BlhAgSPGPwvL2bLQfp16nFDSwRpXUI5yp+hiextgQnEc7hJJXrcRAQsDdNijxsbqgUssWeKpEiH4/xpIeQEiUEzlMoVZEtfQ9MkYOzGCVxVlNOBkhhcCZD5xMsBitB2AInDLrQSGtxxQhbTPA8qHcCFk6dwE8O4fI1bNnDDu7C+m0wJ4iXF9BFB4oMPRqQ73Qx0y1Euc1hv4ZLEwqzjtWbTHTArjlFfaPL9Pw05e1d7tyecHstg6iCVYhYMUpLQmMIlaWcOIY4/GbEcMfBRFOUmlwbhAZhSppFwVJ7iqAUbN8ZsTVeJY1Sau2SNZNzVyU0vDlc6rO5vsEjH/8QH37yMaYaCbKwbG+PufLmLS5+7884f8xxe+wjZ4/QWIBE+8wEc0yk49r6d/DqIcfmOhyeTnh7a4srb15FTPmkZgdTlpyKJTe7Bb93e8L7H+yQNwQ7W5pSC/q7fSJVcuQDR7kShjxgLdNAvREik4Dh2oS3vnuRZz/+KMnhWaz/PsKwRrl+lez6Gq/+6bf5+c8tc+T4Oe48aljf1dhCc7adcfSJBmLtMpmyJH4bT0cMB0P+9R+M+bX/4hxHpkM+9dxnuDF3lfTWCn7/Nk9+4FEa4TP4vZiiG6IHCV5aIypjVADeTEiQCKgLZAtER6DLAelgBCbEyrJSu0IS1dvkWQa+QHrgA8IZLEE1dtaVfJ3AVRrffkC5Z/6kPA9fSZRSOCUZFsVPrPtiL1l2kSRd7TIebTAZraGLNtrGpKbaZGpUTrQ74xRroRGFDFWL3UmG1QXWVzwxO033+FF6h09gi4yPX3ichVoT6Up6g01UIsiFJDUF6cYG0VxEq10n8kImqSZiQE012bQZLqvT8AUxQ7L8LQqTUYYRx1uHqYk2PVGSxYYoHrF8NCGYbnGimXBlY8Tbt3bZvNElnAkY3BqxdrlHnmqQVRfZWhB6L9HH7lEH7kFWlBCVog77Cek96Uy3/9geUfCdE4J7RNyDccEBdOYAHfw3NipNdXnQvT9I8J076PRXfI49UjH7/I4fkz3l3vmyUlZn5j7zCCFASlXBhA5I0PK+47PH7RAHhcH+gd8hlSrvFSFC/tWJ0v+X4ZzB6REIVY1qbYYoM0ReIsoAVa/jl3WEdZhRHy0r+XTpJnS8EJ2HSO5S2JzC1sjdDIHKaM/NY9c3uXNni83dES50GF0iajHD8YimsghjSFNBKSWq1qK/BV46YVhqCm3wy4o71ylgce4Icmy4+eYq5c0JQWMOvz6k61KuFj6dYIbJMKd0JY8+/RiPHD9KFHhYbdkZ5dy+vcrK+l2OzCq2Sg/ZnqGZFIQyoe5HpK7gbu8yyVSD+UaM9BVrwxF3N7vIKY+BGWGNZTlU3OkVSBzHOwk2VgzHhsJK0uGIoOmR1CI2lWLWQUNArV01TDd3hqzeWePMiUVqMy0873FC8RYuW2d86ybXM8EzTx1heqbO6qGccW5pKcOcb1nMQ+TgLjYUhNMNTAGDnSHfWhtwerrHg489wenlJ9h266jRGM9M6GrJQ08/RZDGmAcDZB7huRBf+BCAbPlIDwgChB8yfX2BVqfN3Y3VvcT/3jV7f817YC64DxuCd0DkBPdd+/u8nz11sHdLwn9XxYHLU8pRnzxPCSIHM03Mm7dxriAfbTPsrrM7zkjrCbmvmFECrXyE9PGExCpHo12n7HbZ2t4iCGZpt6b5xJljXPvMz/DCv/v3/MyJ0zRqDfzZFslMyPZbt1FKsT3aRacpKmkyPTfHQqPGa69u0Win5OSMbR1Rhoiskkote5dxWMKpBucWz9BMprgxXmd1coVjXAG9w8kZR2vR5/wZhbdg+fJbKfm2oRzYg3Ud5xCeJCstgTA4vxrxyEAgHGRjjfSq7nBRVB+MCj1U7GOcQaAQKDxfIgKB8wUYSxBU3aKyrKQGvUgRRR7tmZh6PcZzErlHbnbaVQUJPlYJjPQohaouB89DBR5hJIgin6IoMVgCq5Bh5U8wzi2e7xH4AmH3Rr6exFiN74V7VagBDE5YsixFEKKRaO1Q1qCkJArCairkK5RQ+O0GURTTH0yYmIwid0hjsc5gBaAC8BXKRFjPw5iU0lUmbM7zcb5Ce5IghtBW0p5SgilLLAIrKnlWgwIk0kGeZRjhIUOBZxwWQV5ovMDhxQnCi3BlgZSSUhsKXRBHDSQKXVTwIA+3ZzgkKrlDWyJVUEnI7d9BzqEChecLDBXUQgqBKTRWW8o0RQUh0vMrMpuzgET4Cj/0yPMCYyyeV02IMAUuB+c0Nh1V/AJpUYHAyaqrhlJ4YaUmpQKPqcUZovYUQoXY8Q7F6jXKnbtIk2P8GqbfRdktpNIIlZNbS5o2aSYtTp9apDfaxg1XMIyw8ijDYUir1mZ1fcyt6wOu3p6wNdLMz3sUpcVKQexpIq86R2Xp6CuJmvgUI4stLb6zzIWKqZka02nKvPM4tHiY65tj7u6OyLa30WVKL7pKs+Ox7i+wm99Gj3qIwPCJT/0KZxsJt41g0LVcv5VyeWVAvWlZOL+E6NY5dOQIuwbGoxyvtGR0Wb/+Gqce+gBHlxaqxXbzNt3dO9igjSlGbKY5S8rREYar/Qkdb4bXMk2nXWeUwU5a0JGW5HCTdW3op5qJcERxStIw9O7AlVcuc+ahBvOHTuH0WQIEsmXRa69x40ff47XFkgcer/HoqSMcM4rt3i6IAadiReNYg83hkFZgaLsa4w3Ft6+nXHnrJY499BSnD52l5k9xN3oJbqwwe2iKoHkcqUPqsoYwIS4TkFF5m7QUNBTCB7DVdToOIK1U1cpck6c5ZVnihSEmdOjCUGpdmTzKCiYUhgGZyXHOVhMz4VckGFFSFinOWXxJta4oRbVDvTMEkEQRJxYOceX6RQpbMhj26E/GjEtDTSmMFNQllFIhhURgcUoQq5BiktIdDaDZ5Ggc8cHjRxk8/TTXXnuVj07PgfSozdTh2pjJ5joOGBQpejQgPnWY2WYbXwi2xhNqsaZwhrENqduKcJimPSaDa2g0jU6b5eZhSuPouz4TNikmA6K4y3LD41zbZ2FJEiYlP+gPiEqFLBLyiWbnzogyraYhB4ZB9+9/3MvpoYJQHZygfbzv/kN77Tt3j5p877mD+uAeTni/0/cfQwgpK2iQlAfJ//2EXyHk3vnZ+/2+LxU5+B5uGu4zkbu/yw/vKMT2i679Ig6xX2a5fT74Xhyc+XfEPrzpry2cA2dwZoJQIa4Y7SEkSqoRRwhliRSDasokcpwLsS7ED2Lm5jv0h5tINrEixLgWhfYI6zHrm9us3djg6t0uMnC0OwHalFjpUVMT4qDiIqZaMlQ+bpyQjy1ZWRKjma4l1IOQRpqySMDi0aNcubbJYLNLoQuisIRoQtjxuDmpMdJ3KLMh80cP89QTn2Am8NixkI4ct7YLdiYlSSKZPtRCjEI6nWlMVqJKh0STlwM2797k5NlHmKpFbA3G7PR32BkP0GEdigmD0jJbE6wZg3aOUARslJZGHDIpwXkeSSgRDZ+Bs2TaUuDo1Er8mk83zbh+Z5X5uYDZziyb+hizRx30NVn3FitXX+NSUHLugYd4aHmB3aykLCf4smBZOaL5hF42ZCapI1LH6nrOazcHvHLnDWYW5phvHWVUT1lfX2Xn1gprIwtRg06jwwPnH6GZtFB4SFsVvaLmIUOJwCfA0R61abQbwI+tK9ybBOy7Ih/A5w5wjPt/+86obpGqAfGTd8D/c7yr4qC/O8Tb7GMCQbtdp4wUMrIVWXWg2V4bcn035cK0picEsx7sWocKEqYSx5Vhj+OR5fT8DC/v3ME1QpJ6neV2zBf+7t9m7flv8d44wSFQi206R2bY+v4l6lj6/S2MLonqh5lqLdCWjrW1G5x8us3N8Zi+WGZOQjEZ8sraGuVOF6Rgeukoy3NHSZ3mYvdVfPEGU2KLsR3RrlsaXslcaGk/orj2kMflH5WV5OQ9eCPGOvKxxowNxoYV5CZQCOkoRpbOUkI5KSjGFSlV+GAsaCGxxuDFAUFQOeoK46GEwzcleWooc4fnQ+SqsX57OqEehthxiYfAlwKhVOXOG4SMx2McAmM0nvRRSY20MES+h+9LskKjLSgrKLXGWIuWPtYKRKHxMfjVHBtfOZyw4CRSCoJIEaAwqSb2fXSeM9YGooBGzQfpSIc94rheJZFxgBfFGOfIRuB0Vr1PY7BYSqORJq00+3MH5QQlBSIIwPfwwpC8KJmdbyOzDJOXVVVrJcI3SE8gw8pt2jpBXlhkWYIfEcc+0kjKXDOZTFDWEccB1gmMEVhsRQB3Ja4Yk40SPF3gKQ/lS5wnKEuLzg3I6nFhLK4oMLmquqq+RGIRvgQUzoLJC9JxQaVFWlSkdVu5ERolCP0aMogphzlCaFwg8JWrcMumrJKB0lCOx1hKgnZSJYN+DRUENOJpnGuAUtTnj1TjYT2iXL9O+vYldJkSP/oIIjhM+sYLiPpNXD3Ba04Tu1nGuw3i1mFKP6C98gpeXCIbp2jXniLYdDz45CL/8t/8c169tMt4omnVBO1EsrJrSceOhXY1ySqNo/AU2vNZWxHUlE+zI1kM4WQ94PxCh3MmZbtfYxwusLm7w6KyNPwS5RlGUcGxpWleD+rcWV+hN75LrT3PR87PMqUEXxs6rt4wbNzReHGLj3/kZ7k1Sblwbo7p0PDylS67/QI/GiPVGmbdceELn2Jm6RAvvfwSf/H971OobmXAOOyzMczYLCwzDcVHj/q8udrn9saIE4sRZRhiOm1SHeNEQezlvLUJvUjj11Lac4rujYSNlbu8frHBe549x2itwWj+NOGyh5ieoNPX+d0vfZsrKz2ee/b9nD7ZYXGmx8XekM3dDbzFRaLGAFXewFOSY0cPceK0z3d++DVqS1MszC1Ra8wzvfwkNX8RIX3MZITzfbxQVBuDlJXs8X59qvbnwwKhqfDwXmXOVeYFeZpR6qpzFiYh+ThnPJ5gKCEEF0mCyMcvNYUucdZQAkiBdRqdj7F5hsLhrEAqnyRu/MS6L4SgEcY8vHCUr0WvQVCnv5Oy3suYn9fMBj5joKlgaB21IMIWBUNdMKUcC80abw+7+ElM5PmcW5gmee8Fvrx+h1OeT+qguTBN4klcv4+PZZiNEFoz01pmKm6CLulPRhxajNgsCiZiihksvTTl1u4uo91NnJIcXjjBdDLNzWIDbXo07Dp+uY0fZdQDiMSE820QyyFbdyOuXe4jAlh4oEM+0fTWJujCYfSewdABNn0vuRX7I31XTYH3Sa17ue4+lvd+qt++2iDsFRT7bXHubfzO/vgm/zc3DiYo+91O9qBZsAfdEvcSe94JBRJCvrNQutci5d7B3EH3VOtqSrz/f/ehRPsmaPdi/wOqao/7Jw5wX4Hx1xSV0pUGXIV40BpZO4QVHiiFlHOYnTsIdxcXNPCm2uBaaFPH96cwAsLRClESIOLjRGKBpJBMzSf84Vde5823NjG2YHkhphYGbA0N6dhyuCOxpaWQgkIEpC5mbU0y5QfUpgXHQ1hutznUqNMxGeNxnYk/SywLTjYcPhYPTRHmtObamDxhsHmVCWNm2oucnE6IcKwWsLlt2RxZZmdmODE/T18bTs3XqHmGrdsltiyRfgZ2RLlpOf+pCwRRwBuvvMmV1VuM5YS8mILBkH5hSGLHiYakKA2bw5ydScFC06f0FF6tRuEZjLAoDBsjmPiW6UZJY6bGxpbm1sY6h9YjHjy1SHczxps/jj9tCesGc+0qX/3T79DXhsceeJT5liT1crr5BJkPUI0OYTBAqT5+ZFiu5dQSx1f+9CZvvvUq73/fMayLuHS9y8vfv0ihS77xre9y7OhxfukXf5kTJ08yPTXN1NQUlQ+u3JtaVj4s0ld4nl9B8KQ4gMC5vWljxT2wGGMOYHzVdbQX+/X1fROG/XXs4Pd3eW2+q+IgatRZXF4kqAXk/S5RXHKzJUjvpOjNMeXqLdJRl/W8xjCNWfQVg3LERlFQGEc7gpNTPmu9gPZUk6NJm1rpWBvepuGGfPa//BBfX1vh47FHc9BDjHO8hQ5b/Ttsrd4CFEk7wq8J8nJMqbs0/GNsXxfUaiX1csh4e5X19YvVCY59jh55hrHVWDdmaSahGdVYkF08bxpf7aJsgbKa2UOCf/ZrM/zCb2xz+3sl5U6FSawMKCqsYmlB5AalJF6sCBseQcdj6tQUN763hskr23gjwEY+cb1JZqoRu9YOX4HnSwIBSI1fVK64QiqEVyW0npRkGztoEyCExI9CJIJIFuSxYLypCWs+2oC1ldZ5kReMs4LhaEIkJVHoYaxHb6Ap0xwXQqMW4gvwnEAJQWEtYRgxHKcI1QBRTRZUECBin+be+yydxFkJhWZ3p0eZZbTnF5k7VMMJiwG8RshgfQWkIpAJXhBhXUmmU/zSZ1I6moGiNBpjwfc84tAjDCOi3AdlCP0amWcZjQtcb8zM0gxlUTAuC7SoeB5SCGphQGYLnFakaY5wDh9DPkwhmcdpS+ALyrJEWwFCMdq8TbvZJs81QSsgbsSVv0Cp0QjISoTK8bwIrCYfjoiSGl7oI6TCU9XeVKaabFQw6me0mzG6tGCLCgcoBBhBPqlkY612FYch05S+pFaP9gh4unJ0tR5ZWeCylLg5Xd3PTiOVIIhrBPUa0g+w5QBXThi+cZlSlciTc5TCIibXaD5zAumOY9wulhgxrhPdusjlF68zCpc5dtJj6tiHCVqHULZH53iLQMEH3tvi+t1NBpMKa72dQc+A52C4a5mOHYUvWbWKIK/RWYqYHQ159j1HOVf3aHcHsLNF4/wp/v3zU1x65RYXbMp7paYjDEtTGZtnl7lUWsbbN9ne3GQ4njCzbJhpRShh2R1pTGp5/HiLB09UutgBmyRexo9WVhgPM850Eo4tLvLHz7/JU5/4DA+c7uB8uH7pEle+8w3aDx1BuJD09puo3OILgR+HZP2Ql3/32/z9//Yz/N7/+RbJYsTskTrJQo1J0OQhX/DvvnqHnzoriZoJcnme4MYqxfYKly/P8MjZt1nuHGbDHWZXHMGeOspS7Tc5/NAG3/+ji7zxwmU+9onz/KeffYpnZ6fIpm6x0/1T5qZjXAv6tmSkN3lgcYqPfLTND278H4TxLPPtp2ksdJCtHMU0Re7hqQAlqBICJxAqQKh7Xc9Ku9piBRgkLlDY0qIiRSAiXGZJxyOc7xjnBcNxhgocYeAhDNiyIFaWKAyxWAonSK0jLTN8aUiLIUktxvkhBZKJLt+56AsqvxZnkS7nUDtm52qf4u5dxseWGOaLDBJFoRVNT9K1OQMNJY6GD1OhZJgrmrWYaS/ClAWlzZhODJ/4+JO82u3y+EwbNRrj1xKIa4yyAbuDXWpxh04zxPMcxuY4VxDINr1taMSWYDJmWPTZGXZxOKJmjZOLF5joFCk0M42IVtBk1kwI/Ba+2kQ6jcRw4UjE4emT/Gb9Gm+9MaLoGlqHInRp6K+lB4o41abKgTypEALlScq83EtQ9zvj+1utPTAZ2ocW3a/z/4581e3r79/jLvxlXe2/SXGQoNt75Ech5Z4zQRX7eGfj9hyo74dJ3Hcc+Eu6n3sJzyKyAAAgAElEQVTfK6326mdjNHC/GZrD7hGb4Z6iS3WO7x3xx/HW+0XGf/hwOJPjdL/61WSozsPgNLbcAS8grM9S+mMwj+PcCCc7MDbo4Rr90ZBRLmm1W6jOeYRSJEpTDwMk8NSFQ7x4eQNfSQoE3Rx2jcR3MNwpmW44toTHjkkI3BSHDifMjbZ4/1OPM2NyvH4XqXuo6ZO8td7g0qUrvD8qmHGGWmiIZiyDpaO8tN7F6T7rO1sEkaOeWCK/EuQYFA6p4emjNTp1AViibEIgS650dwmtY76VgIOru4Innn2GhU5A7hw//PYL3OyuMX16Cb9UdC/fRhpQAlQYkPb6bK90eerJk7z40hathYhGO4AwREvBjHN87/qQDxwSyGadZGmaMBsw3F7jrdUWZxa3ONJpsy1myMIW8vA0h5uOw6c3+eoffoeLly/ymQ+9h3PHj9GpRWi7zji7SLvepBArTExOEEoOH2/yS7/8JH/6nRfQ5XM8/fjDrNy4wbe/+S1Go5SNjU3urq7x2qXXOXHiBJ/8qZ/mC5//An4Y7HGRNMYYnLVMJhO2d3Y4GAxURBwklay+sSBlZUwqhDzghu0LJVRXFXseHz8+/+S+5//qq/Nd3RUfeua9PPHsE6xvb/KdHz7P1UtbfPBvfYTv65fZurZCtnKF67/7O1z7xV/g8VPHeVMb5oI6XTPmpss5owKUrDGSL/DQ3MMMB1t88/I6a/2CTz51lgtPf5LRzg1uDKaYW5zjExfO8y9eXyHbuUWgBEG9xsLZs8jpGW6vbhD31lHEUJaEky36Xp+V9A22X/pjVL2GGGk+/dAio/GAyysrqOlV3hffZtsNWBmnnE4MC76l5luUswSh4KNfqPEvvrlLvmvBgZcogo5CRRIxAT3SGOeqbnkOmdNkr28y6OUITxKGCj+SKGdx/QF5v8SaAbWajww8kAoXhdSUxGsm6Hhv8/cFNvLIx5qtzHFoPsFQUJYaoy2TUWXEFUqABM/38JBI62jMNkkHE0QhQHoMC4MzlpnFNv1iF89zREoS+aCMRZQFtShifRcilZBrUFGADBSYAiU0sRcQCYn1JNoZdgZjemvbCC/GNFISwOQl4+GIfJRWF2eWszaZ4CchrXpE0w+Y9Eesj8aUeUK/NyaOA6amJX5SUpZ9shxUrYHVGbaYEElHfarDyp0tcq8g1xoV1ag16nhJTD8bMtVJ8IQjjhXpaIwuChqtJjXp2LFgvFrlBussUvr404tkwzUaUwsoWWFftbWgFM12nXHPkuc5pfBQQYgvFcbkFKlE1STFqMChSFPDYFAy3ZREjQA9mFDkY5znI6MEoXzAIkpLkoRYIzFFjilzhLV4YR2/ViNIpginm+higCksZrTJZDKhNT+HFyV4YYLyE1w5hhJGr73InUt3aT44w/zyabzGPOVgB33zO3hzxxjqk3THJWm5xcyD5zm+ewO79CG0b3n9tS2seI2HH5kiaZ3D967x8INtGl/2kSIliCWlc/SGcHTecSQ33BCKVSGxTjK0DnWrz9//wBzD13aY1C3JUsSN9hL/y5fW6Peu8vkELuiQGStBlvRNwb/Zuckr1lDOSCa2REpBFFfJQKYLzlDywHlFywehNLdzgRsMubYWMskWOLcQ05J9Xr32IjuTa1x49u/Qrjt++8/e5s9euEY52WZy05IkGRMv5kpZcqYsyZzHC2KKc//g5/jq1ye878JR1lswCgWbUrJt4Iteye/cfZHv9toUiaEW+QTTGXbFMLl2jRdvzTFTbtLsPEhz4TRb4Xm+/+p/xy8/8006R77P9766ze/928t84ytv89xPL/Kr//XTHJOvMMjWqXvgRZK+UxSiQE3VeNQKQp4nLwV+8CiBf5zhYEKa5sTeCFyG0AY90URzC3hJUHWSXOXCbQuDzkvGvQHFKCefFGRpjhOOsB7jR6CjiCiNmRaKST4mm+Qoq0B4WCkYpwV+FCN8hecKEhTj7pC8yEnLEhEatB3TXdv4iXVfCInvhcy2FnnPI48x7r1Kd32T3u2r3PBh7rGHONxpsW4sc17EGybDCWgqDyEkuVjhWH2Z3nCLm7sjAs/n1GyHhYVTZOkOa1mNc4vz7Mwvcnd7gM0GxEoyvzDPkWPHKZWHG0+YtQWe8HDWEhYjdv0xN9Yus7ZxlaQ1RTLWvHepzdZwm1W5xXSyRsetMtS7TGzKUmSoexqPEuFKOo2I5547xA///CXSTYuX+IStELmdI3W1TrgDgvDehuscZb4ntXkgiuO4ryn3k3H/k/Iebtix9z/c/epG/xH4HLh7ifsBIXKfrLHX0Xd70Ih7L6rqqwMTtXsP/wSp+57vgTw47L1ymj3ScdVhrSBMVfIkXUVm1lofTA32iZ3WWsryxwrj/6BRjZSkakAQk22toIIBwq/kWYvBK4gihTCidMsYAy7I8VoJjWKL9pGP0Nu+w423N2l1FFOzbWSQoGSXI8sL6NxRb/l4kUdqLNsDy9lFx+HJmB+KFiNCSueR5yXB3XX+8w+eYPsH1ykPS3Szze1xzAt/cIvB1ojPtSyH+w1CZzF+wW5a8PydPq86g1gKGFnHlHJ4vsVZS+kMh3EkS4JQOQoco9LisoLNoY8t25yc9UmzXe7urjG2O5w4+TiR0vzz17pc3l6j6N4hDkrq4ZidqMYdbZi3jrVSMmp3mJqd4u0bmvMnO+xEMFGCIQIPOOtKnu/e5fW8hgo8koYlSgrynYzdWze5fHyKdjZgpn2Mol5nVZzirWyKnz11hZ///A/48p/t8Nv/+nlOLL3Ks+85yjOPnaQjXiQtrtGMArQvKG2IcRNUFPOxZ5bYWP8u7c4jfOZnf5rTp0/x+c9/sUr8naPX63Hx4kVWV1a5+Prr/Mav/zpWONI05Y++/GVefvllbty4werqKlBJ+8I+t+C+WwnwlNpTIbrHoYH94np/irYX93MTDjxA/urq4F0VB9978RXWx7sgNaKTEOiCt59/AeNPCOZnCJtHmXv4Ed567Rb90YhPPHWWTedoKcFxFfPNuxOulpc4t3yOazrFrxWopQZRIySxHj0Srl0vOfaAZsOOuJpOCBptUt3Ae/NtGlM1ziwvMy9juhvbNJanuJmNWbEjnmjn3Nrtcv3mKsUbq5DnPPHFT7NOxuU7K5w+OcsnFs+SZzdZsVD3Z1kpdtktx8x7huXQIUn5ewsB/7YJQ+VwOdjSIoQlnvLIM0tt1iNu+CgLRa8gKyX9cUHSifEjSRhL4lgRBh6bN0egNfWmR7MhSeoVlKZMFU470nHOJLUICxMs5U5JM1IcnZui25tQ5hphK9fdTMvKm8FTxF71GmNB+g4kdDoJnhVooyjSkqLQDAcFYSMmqdfxncCZHG0cQnhIAjJyhPAJg8qyXac5ntPM1OqE9Wn8yKcwHuVwTJoNkFHIqHSQZ+TXbtJptQh8n0wXxLFENqeRmYfUGZHToAuycsJMPQDfp9aqU+iC3UEPa1NCP2Bqdo7e1gpOSgIR4MmYAEX9+GF2RhvUXAHOkadd1ndyglodacfEoQ8qIoxi6s02RjhW+2OslUzKnFoQEHkeUjpMaQlrDWwpMJnDheApgScl1oKTVZfVpBZR5NhAkSpR6Z5LgdrbaKS0RD6Me2NqnSl0XCeKQ1ASJyXO/N/UvXmQZdld3/k559z97S/XyqysrKyqrurqbvVCI6mlllorQgJhQxgGxhMEy+AZhhliJIiZmLEZRjjG9h8Gw8SER2CzSQZZbBIY7VJLtNTqbnVXb7V27UtW7utb73rOmT9uZlaWQAaHHQM6ERXv1b33LXnfvef8lu+SYWON8F28yMMWAq0MuhAoP0LnBcVGD+UYhApwXYFLj0K5VCZGcJojSKc0q7JFjNVd9PYWyY1VDn/Pd+FMCpRriTc6fPJf/zkvvjbP5Fu2eO65J7l5ZY1Dk/BPfvZBHvr+H+Lsb38Eqxq0D7ex7SaXr1uGF59kbfWLfPgPXmVzO6ZWcxDAympBUHMYE4ZkzCUWIWmqQBeEjuVHD3tMJCnJAcEX1zTnn9qm6G4TuBX+2fRJ5nJDZZhhdU438FhozbCVnqEIJGJukpNTVd54pMV7v/NeNuJ1nrv+HHUeodUYQ1mPfmJRxuCNjPFAFXLlsNa9ypWF59jYOMsTj/19Thw6zOefW+CV3/9ltl7+OgiNUw0Zn23Q7a/w5P/zYR764E/wve97KyOR4NdfMaw5Hk4D/NTiuIKpSHC0KPjZcyljCyvot41z6dXz5P1l7n1wijPzXbavXOf2GZ/6G99PPFzAvbjN8ftezz0/eA+/8SuX+d9++qc4fvICL79yi+e/kfD105LnfuIp/tU/f4yp8EXI17E2o+mJ0hBRWtxI0Ol+nbQQ1NojJHYWzSZFvk6egekFxFua7aUhtfEOtbEWfqsK1mClQGtL0h1S6Jh+PGB7q4M2KUgLhcUPSyNAVQnxqgF+7pPlCbnNCNAMigwvdOlmpkwqTF7ylCoVHCOxVqGEQ8VTyKnRu+Z8sVORVUpRDSIeHpll/dgqp6xPNDZJbWSUa4tbdNOEhw+Os50XTDmK24nhld6QUfpM1SZYNgluYHGaVTzr4qBIjGJlreBgZFnLYgrPo1ZroQsPtZTQmqhztDWCSjTdNCX1Jct5xqpNeSgyvLzZZ/7mCv2ri4SO5T3/4P10ipSVIufI6BGavkNq1uhqSUVNs5Yu0C+GtNyCSFlCct5UDXDqCrNekOUaN3Soj0d0FgdkhbljaGZ3/+0C2/dDYXaq/3sQld3dd2QG93ECy0Va3JEzLWFHYi/J+HZGFe0Sko2987cbY3biFHFH5WlHgUjsI3FYo8vujLxDYt59z/3vL6TYMYT65iRqt366I/UoSmM7Ye7mLOz8CFhr0VrjKLX3nf+2hlARQgVlhmQMXrOBzjfL7oGtkOo2g2RAszZBZ6vP5ddeI/ILTtwzhn/4JBtnPscv/trH+dGfej+V5mGWlzV5sUy//wr/5o/+gkpN0WxIkqSgnxuq9YA2KYOJFgMzTj82KCuYiATvPRIRDIeIGcWf3h6yfKqD7QvafpMfn7uPidzi2RwjC9JalW6tSj+5Su5p/EOzmMVv8MjD9/G2J95BJ+2w2FukKucIoxBtyvOshEVFFaYL0EqyMVxkffs81uTcP/sQo40Gp65u8/zH/yVbN65Ta7WJWhUOjFZZ7Kzxh//uM5z4b9/HsfEWt4dwas3SkZL3hGBTi1ORHHAsvdTwx+sFo5vbFDMtXnjxAhNNwdFDo5zb7HLz/Gkmj/g0T7yTwcY8UTrCydFxDt4zwq89OcI/ff8P8uM/fIkXLnRYWDV84WzBl19+mZ/7h2+jIp8szctkhi9jrDRIvwUWzpz5Io882qLRHqOwmpKGYzFGo3U5mWxubvDUU0/xrne/m0qlgjGaOE7Isow8z4njmDzPy6SCO3PL7vUNJW/1bp+QO4/7L+e/DLGzd/Gn/mNDfehDH/qWO3/pl37pQwDHHpil1goobIZyBcQpSWqRMsMYSOKYuNuj8vCb2FgBRw44ECrGXMOILDgaBbheRL+3yHjol1CRoqCihww3riNDl27eJ4pG6a2uMthcpnFwHKMirl78Gk61TnPqAQI/QupNBiZDjla5v1ZjVVQ598yL3PrqU9hsi9Y7D/PmAw1efu4y7qGTMNlmNbmGTl4j9QySHNckZEVOpg1SgCcsgVQ8e9Bh/TVNulYqDzk1RdB0kKLE5sudCdBxXNzIIwggann4FZfIV/iA6ecEocKrutSnKgRVB89XOFKiE41BIhxJPNTEsSXNyiyv1orI0xTPWnynhKNU6iEZimKQgFI0G1Wi0MdREmsMSkqKQYrNSiKvlArHUSAsUjg4SlBkKcJqXEeW8pzA2nZCxXdRSqGkwnckoVT4ykVJl1BJbJ6hiwIjXVzPQ7oBnu9QCyPCIECq0qlZCEuz2UZikUIjKLBW4zoK8pQo8nD8Eu/veA6e7+K6Dio31FyXIAyRQpFrS2EFTj3CC0Oq9TqOdBgOEza3eyAljXqVIjMo18MLPJSjKGwJ2cqGBcN+D2kNrlK4UmHMjlmUsbhhUC4G2kKel8RiP8APIzzfx/UcpJIUuSaPcxyn1Fh3vPK7u4EiqkWYNC1dkB2FcByEI8Aa8uEA6SgkpSoV1iKxoAtMmmDzDFtohNEIrdFpRj7o4zdGUH6IsKXrtKD0wMiWN/AmDuBOTuLUp5HBNN044F/9m6e5NL/B9OPv4Mb1VVYWliHOGdMeD37PO3DbkiKqcPPaKou3hojWJMsrX+N3P/4i80sDRsZL+TU3Emz1BMcnBTay3LCKbsdAYqm7Do/kBe85UuHpVc3LHct8XEV6Yzw4Pc1//9ATHEsCmlMzuCOT5LNHWL73Pj4/0mL7+CyNBx+gfvQkM8dmOX74IFNeg89/7vc5Vp8nuXKKwvexbkDaS7h6cZnxkYDl1QVuXPoc2eZLRL6gPfMEB6fuoyhifuf//iVuXTpFFnfxQo/msWkKjjNYOkfRWaN67H5ah49xrOlypCYIxyXzjiSqK/KKYFXCSrfL8q//X6yOBNQP11i9contWzcodII6Mk3/2lXSLKNWlXiORCiFtRlzkxO07j3AM587g+dUOTJZ5VAzZ37LgWGbc/NL3He8SbMuUCR4wuJ7glXhEgAVx+C6JRXM6ipZssr1c6/hFwnKCorcEMcpWZajVIEKFPnOIpFrTWY1eTYk1ym5SchsTmpi8qxLGvfpm7IapJTGcw2uZ7E2J0ljrLRkeUZvOCAzOVJZ8nRAmqY4nofnuDtzW8mrefbLLwHwgQ98gEajcRc0xlUON1auMkgzur0OmYVgYppOHzyZMOq7hEJTlzDiOXjSJcm6tDwfXWgca3B1TJ50EI4iNilh0KC/uYqSUG3WKSzcWjlPWGsxOnoEXxogI5cWJ/I55AesGI/nvv4cS1dew480c4/M8fqRJmtLA9T4DB0xpJfNo/NFtAJsgsl6GJGUATgWJTRKOtyeqHDzpQ2K1OKFLsp16K0My5b7Dr59F5Gyp9svdwPOnW3c2SeV2ssG9tbefbCiMjYVd8GV9rD4UvLGN7yRd73r3X/9qv13cCwsLPDRj37kzoZ9wccunGivK7CfOLnDE5B/CTt95w3ukJt3jy8P3O9ovfuSUoVopyOz70vsGkZJWf5Od5I3i+d5fPCDH/zPPgf/6WPnWthjtgtMvlWSkGWEUFWU10K5IUFUpdPpEscxNs2QeU51YhSnWkP5kvVbC2TaR/qC9Y0z/Omnv8ziyjbHjtUYHfPJhCLTiqNjCgLNmSIg3ohxTanoc2+Wct+BJuc2NOe7sJa0aFYnePDQHE8ce5BJExJMTUK7RT53iKXpCc5VPBY8ELUaZ59+nsfe8kZ0Zrhy7jxKrjEWbBIvXYDqGBLFoJ/S6cZUQ0Wn32Fl+UVUvkgQtqg3j9GojFIUKR/+3V9mefUyeTykPd5ibHaWzE6wefs86eYah173IKPNGm1PMhYIKlXBqhBUA0nsCHrW0llfofuNL7PejGiOhVy7fIW0v4HxJKpdY3PlOkmRM96q4kkPhMCRMF6tMDZZ5yvP3mBmbISZhiJyoZ96yLzOlY0VXnfkAErGSAoUIKQixsMFRpsefhDw9adf5WO//2luz98mz7LyPhey5A/YUgGq1+vS7fbY3u7QH/SJk5g0TcmyDG3KxGBXvneXa7B7Y+1BF8VuEcPelVgj7k4MyuRd7O0z2pBnZcfsQx/60C/9VVfn36hzUOQJUmT4vqTQBS3fRTcV9b5AJTE2z0hTRWfpMlHjJNfX+kjpcHgsYqrqMuFrAu1wNfVxhhlZkSCLhKpNcP0tbPoahyKfodkglX08P2YyG9AIjjLaEiSiRbPtUhSbrK3dxG+N045CRiPFM595hlsvfoNse4HaiOTNj0xw5blLbKcOU1GB62Vs65S2P0m/9xqbIiPQGSNOQSYNaz3L8dByoKV53Qm4PAI9F5Cw0/XF8QWB7yCQYCRWCkxm8VyB6+0Yo+UWnRZlazN08PwSrlPkBTotIC9Ih4bceihfoaWzIwOqcYwBAylQ8VykEDi+hxv6hGmMdVwKqzCmrHhjQBiBKQwKi+OWhmWFUFgh8GXp7lnEMTrPEa7CUy5SSbQ2CCUpbFkVdFwHTwr8spRTGvVo0GmCtJZK6GPwCTQoX+FKB7Ejh+gCUgW4GHyZ70CRJDrTmMLgOD5BGECu8XwHRGkIlucFWQaVRg1DWWWVrqawGZqMei3CV4JBYXCdAM/1cZVDYcoEyAhJZiihV7mmUQlxSJHWoqxBmrL9L4wm0yBMTqgteaYReY42Bcopb1bH85CyVA4osgyKZMcMaecuEiClBSVxfY+0N8QIgbECWWjIS4lUYQVFWuCqkmSm8wKTJXieAp1TpCXcyfMkwoUiyUl6CdG4xSQJ6CHStQh8jC7ItjaI7rkPS0ERFxRDyeaaZk2PMDZteN3hAywfG2NteZFA5xw6dgCsoDIi+dSTN9ieX2Nyok2l2mVY3OTmZh9dWIrEkObgVySzh3zaRyy3bhoSJG4kaOUwZTQnPcFzSznp+BGOHTrObF6lkineOFPnsdoE8fyzEEJ25ACvyZDPr3U5u3iZqckaY0GN7USjV7osDjMqdYfb66/xmG4j3VXcwofOArpf52DN58Lp5+kOlmm5m4yOH6Y58Qh+814ynfOJj/4GN84/z7DXQ0YC1XawiWJr+yomGyKVYnvzOi++dIEbYpojD4zy5imX6zkYFzILvVuLnPrjP2X17NNMv+HHmapGXCdjcXsdWxii140hfI9i0GPl2mWcEz7NsZBsc5GrCwf57u+YZPHSURbiLYRXMDYxyfveNMrn/+RLnHv2JucePUy9EjFRq4DuobQlFIa+NWRG4OcrePYynnsM5SiqI22EBW011nFxGztuxzImHXaxyqOQzo5qWIq2OdIDbTOMLEBZhJXoQqKNRZOhrS4TUZ2TZhn9JEV6gkLnaJPvtKQFRZZRaEOl4pJnmmKn0noHO39X6FIuUELiuR7j1SoblR5JnpPkXeLBJuPVCZZ6Q6xMmIxc6krSUobESja0g0xzjC5wrUaRoeQAdMqo75IWfQqV46seFYY4XoWRqkMmm0ShoNfZIskS/GqDmuvQcASfe/olFm5dBNPh0FiDR2bGuXL1KlE0wUF3lls3b+KLTWbGQzAbdPQQVQwZMRnruaanDCMuRIHLQ4dcnq5JsrTsMuZpwR4F4M5J2Lcg7620d5IA8U1VcPbxC8QOBkns37hDqmU31t3lKHybtw72VSz3DJl2Yt7dbfsJx/sVm0p5RbDa3jkX5Yv2vdbsdBd2Aixj0Pbuz91L4BB3GT/tjt3EAMoOxn5i8t/u2E1wBNKpgNz5jiik8FBuKU3caDS4cvE1yLbxJscAiVeNuL24jFcMECLGskU3vsXtXgepNfEgI6p51Koe9bqiMWZZXM3IhUMtMjSNZsrCmLH8xZll7MgcB+65H7WUMFhdJ88Ljhydpti4Su5ZbpiE29LjtaUVrty6wIGjTWYrkyz7VbaWVqi6lnqQ0xneZlY3iNwVAj2GydoEOiAXktsLW6T5NjUnpl6fxa/OIN0mg7jPk1/9NDeuvUqSZoQTHn7bIx1oNjdvorMBvq/p91Y5faVC1a8yNRlwrCJZ1ZQu8tYyf/U2V155ie3588ydmGXEdVF6QK+7SkQVr9FCBgHZcI2F+Us4swHGuhR9B/wqj01XuTU/xmI/ZzIKmRoPCZXlzCtneO3liyy/7hGmRtt4IgXTR0qNKzSJ1dRGJFmyxtbGCrdv3UQIgeu65JRzi6X07zCm7E5qY5D7lAsslLyZnf/dAc3t4/UIyrip3Lgz59i79v9VM8lfajL8NeNv5nMQeow2Q/zQIdFgvYIgNBgnoOgNGZJh8emcfYbordMUMuJqL2fbzdgScFgMaOqUSmWU/qCLTlN8qQkCDzyFHN5gOprj1XQe424z2spx0z6VWpeRmsBphDSiDTbWenQ6HY7OneBQvcX84gWuffXP6Vy7RNSSTN03TnuQ8fVhxH0nG5jhPF63xeRME7f2MMlmh0Lf4vbAoH1LZDWLPU3fh7dWJfcry1dasNgSCF1Cd2wBypP4dRdbKEwKxkCeWRzHoGypfY3WWA0y9MiNAVdSpJp8kKMTDdpicoF1PfIMhOsiPUCCcgS2MIR1H+l5uAakUmgrEIVG+R6udrBCUeSlSZtAIrTFkRD4HsILiK0iNWUby+YZJsvQhcUIsMZBiBKv6biCHPAdhfIclARhBUiJUJI40yQFWCHwVKkc5FiBdF2G/Zg8SUqSjHLw6010EiNNhnI9jJXkqSbLMlQYIV0PihSnjMaJsxRblFKrsb7jBIhjy8q6LQi90kQuU4rA86lENVxPkRe6/K5FicUWjkTZ8jcKHIgCH9+RKAzWaIw1xLkh9CUGyLXGmgJtCyLXL28kKVCug9VlQO/sQIWQLnpHvsrkBlMYpBBkwtlpW1tsXrrRKlfh+SFpnu8RSW2eo7McXHYWpJw8HiCQSOUBGmElNotBGqzVYBRWW7J+lyIfMuh2MLqHzjVJ4bC9rTh4cJLj0+M8eLDBygMHSTdXaQy2efDxaazJuXTuMi+8dBVHF0RNQX/7KkME9zwyibM5pN+P0anFrSump6ts+0OKUBGlAs+TjBUw09dkyufVXsT3vuc7ufeNTyCHLm5nwMlDNcI0IavnbGbb3NQhX+lv8/lL13Bvn+Wd33mShpjiepKytrHMjbV1zEGHsTmX3OkzMtbD5SXS7jVU2qQ+MsnLp88yMjrLfffMUT3wVow/x3BrlVdefoE//8N/R5FmWFEKDajIZ7hlGa6cRkpNe7yG3r7O6a9+mfmFMR5+Ypbve/wtRGOKS6s53a3brJz5Gq/84ccZBAnHmzAShDQrPq7QpOvbhIMeTttHDmM66+tUJhYJmwGBTrlx4waPH6vy2JtPcPnKVZY7Ka4b8gluuVIAACAASURBVKYHD/H8CyGrl3q88LUVJloV2vdX8XSKzgoqUrOtLVkBliGO3QC2EHKaqbkjmM0uRVx2y2Tk4rk7Jox5QqENuXTIjKVI+qAEnrD04wGFKEqTRc/F5kBeoG1OpjU6S0iThDgz9OIE14gyAaFcbKwunWiVUoSeUy4+Ji89RPK/7HMAuzj5Ess9OzrNyuoag9BhS6dka/NMjE+wkrosxAWJUoy6ljY5vjX4XoU4ScDkeEoiHVkWAooNWu44l7M1lBfjuQmuBseLaUUCJwoJ5DZLg000Dm0/pOl6LG4vce7UUwwGKxw8WOXQgSbVVHM6kTx0UBHpIf6gj+tHCKdJxoDMDOjnGl8V5DbBUpB4klnXZU5a6hMOaWHo3s7or5UiErt/911V//3JAHdj4nd27JO6+6b9dv82uxMk7E8s/urF/NtrfHOlfyfw3yUM2zuV+v3ndreLUj7fSbr2VfX3ki1r7nAIpMSwK1X6V0Q64s7nCru/s3BHmcjux2T/rSVle1nN3hbpNbgTDN69u9FoEIQB0vOpj4RgDVlScObcVQ5NhlTW5okJSICZ4zM4az3yYkgSF7RHqlQaFQbOoFS0ywVBxWUq0bQLGBiPVxcSHj00zqMPPsZiOM91rfE8iTdeJQtSuoMtXtha47LxuXH9BoPrr/LA3Bth0+XkfSc5d/p5Dh9pc/y+afxaghZ9Gs0eUp8mS6s4soFUHrd7K1SrLQ5OHkLVTmCMy9bWKq9eeJnPfOkTaBK0sEQjEdKP2N6I2Vy5huMWTE/XiTfnef5qn1RHHD/W5qFjxwhqgmtrmrR7m8svv8i586+SNjJeF0FduTQjl+5yl1imVCoRQauCk2yxvrlMa2ICR4LVhrWtgNmWy5seOMitxSU20gozNZ+j0zB/QzJ/do0zZ25Te0OVVqWBMDlSa1yl6VsDVqBUjOfmuK7cibfcUtlQl1yM3U6YooS/sStpzs41v2MiWJLpdy+VXd6BvTOffFNyu8tLYB+0by/B3pu17rz2rxt/o+Tg5NwUDxw7zFAXWCHZWl1hTAmSGqwu9xBbG4hsSO71WDv7FCfe9T0Ekc9aOmRpeY2NKOeQI6k1mqwZS1P3GfMFYbPCqe1l7s3BGynozK9R01scHXXg6COcXTxPPLjJYw+Oc2vxZYYbDpPjJzg8dZR2YPjwH/weG7cv46qE8XtmOPyO1/GJ33iGsZ/5X5mKLnH+U19BrI7wHTNvo8s0lekWlewTLK3MczUb0s7AJpavbcGxsZzZUNGeFQSLErMtcMOyQ+COuaAcJBJHSoQnKYTFdDTKSlxPIKWDDEGEHvnWEBEPKawgiwtsZlAIHKWoNR22upowdBDKodAQBgLpakZGfBygqsFqTa+vGfYTtBtSr7hUIx+d6TL5QOLusNydwFKrVagqj84wY6vbJ9MWz1ocVRrJCAuuUFgkvjQY4SDVjg8DhuEgIapVyYqcXi8HPwQs2TClXQtKOwSpiNOYfqePKaBSiaiMNInjBOtIwqg0VdKpg+dpdJFRZBpjBPGOF4QpLMJzKYxhPc6oV0rGfp6DQOJIhbSKwggc1yWs+LhpgSsKtM6IhzlubnDCEC+KCKKQNM0JHEW75pZW48aU3QXpkQ1zRsfbuL7Cak2BBkfukETLapJyFBqDdEDVaijAuH4pJ6dNWaEtLLmxDIc54U73QmiDFBrH83C8AHq98hbMMhyhkH6ILTRuJURKQTroUOQWN7S4ocKfHMWmfUTFRwUNpOtgi5h4fRFVr7F08SxKJKT9mMQEFCOzvOuRURrjLSweJ6cPMP2dh6l1b4FMiTtrfPijL9FoHmJrcZtnvnaDa/OLeCeO8iM/VmOyv8Rzp5a5vZZgAh9bq3P71ZTpN/h0zmT4PU1LgQwlT/Ui3vuW1/PetzxOq30IESfYloPbaCCdAH18nNMvLPHHf/E053ubOEmfUSV495GHmJ95hPVhn95aTpb26I8P+e77aqQb13GLBDNcxrErVBRsXZO85fVzPPzg/4xyD3B7WPDa9Quc+tIf8e//9e+SZhbZ3plkRYTo1RgWGVYMcFohx442GK4ucnvxNVaXVrj+bMBX3vdnTL/eZ/Ur2/TO/wGm/wlUXUF9hJXFi/TGZhg7OMroSJtrr9zGDtaoPBgxfLaDFQXDjXmSKGFm5jCDtYTfOl3lJ0+2aR4/yM2FCsnKAlezZV7/3/0kK8+8yje+cJvZiSmOTTbxGwU665GiCYUkchx8PIQVxP0FtBqlFlbR1SZpkZCkpRqP71UoEoP0FP3BgNSANgVFf5siquAon7XhAIeMmnBxXQ9jEjKdUuQCB82g12MwGJIbSZxkUCgcVcrtIhXCCkxRUKmG+I6D6/n0zZBBPyZJBt96ARBl8eDQ1DEuXr1B36ToYcz2MEV3VpgcmaAQloUkZjPLmXI0TaUI/TrbrqWVDal7LokSbKSScWORUUG312HGGVAfqZNKn5XeLYbxLR49fIgrS5fwRJVKdZKRagOPnM8+9xRZZ57AMxw7dj/18TGePjvPgSf+HhPeKl434/7DU4iagw5DlJiilj/FWv8KK6YgzC1ZXrCaQDsaMOb5jB/zyJWht5gwWE/QOy7q1rKnyb8LX9lPQN6V5WQvCDV3KnNiV0+8DFH3qH931nUEoJTce25MqYz37TzELvLH7qQF3yxFxC6ZeIcwubP/jguyuOvw3UDnL30IpRGa2ekQ777H3jOxa7Z292fvVlih7Bwg7sCZ/m6Nb+pU7RtvevNbKdINinQFay2dYcTBmUO8+I0X+fozZzh4zxRves/jPPH6w0yobV49f5FeXGCp08tqLC8lHLininNxgDc0VALBRu5wcdvl8bd8JzMH55iM6kTTo8wdaFOp15GVCsOxgPMvL/DC7ZskWUI9TZg9MMmBaJT/8I2zPPhd76Iy0YCWAw2YGHMw7hoOMXlyE1dCkYMqAk4ePsaBye8HQlaTlNsLlzn1/JN8+rN/wuZAEx4O8PEI9Bh5N6KfDrBqm2i8ziPHRlm8eZOLN59jca3D15+d4Mi7f45jRwUXnhqwdfkTwA28to9bHWVte4HZ+hjHDk2xfPk0vfUNalMNxo9XWX/RYmVGb/MabSehEaak3ZS/WPb43smIcHqcrTWfOBvgNuHBd76Ppedf4ZkvnePYwddTPdRCOKYs4KHxhCBQLoYQYyFN4zvQICmxWu/VD8SOQAGA3pFGZqdDZimVMo21O3C4ctwh9LNnDLjLwdmFPO5JJO8VJHaeGHsXafm/WHLw2u1l/AN12s0mreYY3a2btEZbdAZbTI1bir7l1CvbJMMNsrVVPvv0V3jLz/xPPPzwOE13i2sDwZ8sa35qfI4xM6TmSdLuApvXlnl47gDjEyc5dfGPuG/sLXiqTdw5z/q5J1neeAvH3/J9xGtfxM8DZsYP4bQFi9kSp07/BStffBZTgYd/9DBjD81w4aUC+/APcOtf/gqdqIf0YhbOnefJz32F5qMOJ/7RSWYrPtKJWEozhq7mxJTEvZ3x71/VPHpckjYE7ohAZwLHE/ieoN32SFOF50pUDsYaosM1zKCC6aVQWKSvsEaQ9jKiasjG7W1UAI4LeQFx3+A4kCwNsH6E4yraB5oE7SqepxksrWEdja8Nm90ckwuUUAhfMugleGFEK4jwPTBujtEZJjb0MhgfG8U4LiY32ExTpBmhtMSFphoKqqGLqxSDQUpuHNqtGnFc0G56+K5LnuakMqebWpwsQ7iSLI1LTJrOQGeEQZ1Kw2Ws3aYahgyHKYV20GlGo12nl4BVChEqZG6JC8nUoXF86ZF1BxQ6RylLtRIABXluUUVKkmqyVGM0jI5NELmSdNAn0RKnUkPWHfwkxXVcHF/STwqELglsaEEWw/b2Fq6SHJycQEhNvtMxscIn8jOszRBaQgFCSALPIYkLdFYQag22AFOqQwk3wAlcHM8h1bY0j9OCPLFI1yKtIu3nyMgpNbO1ROcaN/TwHAeTx4jAwa0E5Y2pc3AEUvnUmmNonUKRIx0LrsFmks7Vy7iNEKfigE2QxYAszWg0QQQtBrmhv97HVyvMTNSpeRt8+eOnuLC4RaUF999bxbm+xfozT3F1tYJYuEa9VmNs6iCeCzdemqdftHn3Ac3bvve99NuzXFnZ4sXPfpKf+LHXsdm7xHPPZ3iZRox4JFOjvHvicX70v/oZqkGO51lMb5H41hX66z5jf/8HmK8e52NLr9L1WsyMVmj2rvO2sSbhvY/y0qDHLXuOxtGbHGxvUpU9kn6fukzp5Tl+RdJJLFt9OHiwweyxd4Bq8rlbQz73B/+WFz/1cTZuLUFVAgZRc5CpB94UWrbJlr6GrEZUx8e5tNKlGtTwagKxXUBvFfxf5PpvLJP1NqiOS2r3jZF6Vbrzq1x4+go/8ob3k00WBCMpjrQ4q7cJHpwhb69Ad0AeOGxNuVxyRzgiTnFPb47nlmoklRayVadea6OTFd486/HF2Sbqapeb5zc4d9AQvXMCUzi4OsFzQJoQKds4ok5eJMTpNsPco0gNSWERnkfkegz7fRAOvX7OoN/H6KKEK3oO69t9pKfx6m3qoaHRcJGuYO1mBxlEbGwsMRI6ONIiJGRpggU6MVQqPqnd4b7oBKkz4oGl3a5SmLLzGXku483oW87/gl1XYME73vR2vvT0l7l28xSb3QFfWbrNidnjTL7pcR6tJhhyljO4MCh4T0VRt5bQlQz6iyAKDtZqBGqSW2tPcl/7bVitiYdn6fYH9NOHmD32dnrbp6iqEWojPsaHjWyT9fUrXP7CU7gHQ77/hx9jtHKYja060cEDnP2zP6Yy0yIxW1y6dZo82GT8ngYHjtxLU0u8Zo0FM6RR+IQFZDLlG0sD7hl3cZseQbU0ezSFKav/3xSV7WJ1jb67Nb+nDMLd7qS78AH2mgliD/O7q0wEd4Jprc3fWEHk7/bYwdArsfcc+Kbq5h75gt1Ma1fNZT+cyO4ywdmn877TxTLGIGVZMNC7EIwdTuD+zs4dZ2b2YbfL91S78KJ9z///H//pHQshJW4wiuO3MUYzfdCh218naDdZvNpl8/Q82n6DThLzXd85ja0/gAwjjBrQqA555OSjbHbOcHZri3oIea3Jra2M65e3+emffC+RD2nS53c++hG++tVnmTt6D7/6q7/CiysJ/+Rjv0NqDfXA5b7JUVqHDvKF51/l7T/5Y/zbf/5P+W8+8Fbuub9JTQ7xigGOHTDUCU7gsRUXCOFQa07Qaj4CeLy6lfHFT32El59/mpWNRUTVLRERrQpBpwLhceLOEr3VF/Hb40xMzPDy4ipjlRG8Osh+H607GPlJXvzYMluDFY4frxKOHqSnFZubHV45N8/7jr+JpXpMUFVkmxn+YAk9NU3YvoxZXyGtBKzYgFxKJsVFZtNRzncjEtcnaI7imxoeCWMVTXjPNOmNLqu31qgGTeojLXw3QJoERwDUccQItlglHsYMBzHWQp7nZQdW7bh7G7N37ZYk431dMnavyZ1EWJUKQ0bv+K9wJ9Hdm45sCYXeRUHuv7LEN23Y5Uv9deNvlBw4wuKT45kEbE6jPUqWdokEzN5zlKP3HKE9s8CnPv4Kw+UYna3x2Q98gM/X6ozfN8ubf+hBHnUcPvKlmxz1Fri/CkdHImZmKhg7z4WLZ5ibvYc8u83maofuRg9HHOSxRx6g3vkiZ90BEwddcmfIQG1xtDXOJ//xJ8DXjP7ow3TcMVZ+b535L3wRa12EyUnrICOLVhZdaJY/kdF59TQLP99malIw6Sl0z+GZpZSTo4oFYfm9K5bFZRCuJJqUuIlEBgpVVTjGIjAIAQ6SStUhUZYizrGZJYk1OisQcc7ASahNVEiLAisErigrzMZ1UVGddMsgghDPM9ScIZXQIfOhcaDJ9qVlVjeGYDwa9Rpho07KkIqUiP4GvVyRGgfPEQwzjZGSlc0BtSp0txK2Nob4oUOjYun3B3SLsMSYBwGe45P1UryaS3V8vLRhtwKERAhL0tmmXmvguZLMZFhpcHdMOqrNGqnNSo6FG+C4iqw3pJ9lFLGkNVrFCVy6/ZhiYPHqEf1eglMV+J5G5gXaGuJcYGWGLErOQpIYcguO66BNzuraEl5YRQgfUViU69BsNdmOBwSOoNmukyUp0koCx8FzLENVLrBLG1tUAh/PcZAOiHSDWrvEZkopUaFCKYGVYGyCKCS68In7KdkwJUs0YUviBCFIiTG2dJ5OcxSGwPNQrk9sRAnf0hqRaopOgo016eo8qtLAqfmoUCKckuiJ0WTDIdmwjxl2EEUPo9Idr4ohygUT90l6fbLBOsnWJpFfxYw0Gayu4gpJe6xFZjWri9comrDh5hjdx9qIjtdAp/DMhWs88dbDvO2hY0xNH6TSmsSNamwNL9BdH9IpAkQ0g146z2T3RT7wI6/jjz7zDK+82mO0pWgerTA9Nc19c49y35H34OebeP4ArMfVK/M89+lznD29wd+7fZhf/K2P0c/WOXwo5tihBu2RE7w8bPGxP/o03XyBYGyehx/MaIwIGiLneDOBwZAlBPgOqurgNVzWzDhX1yb47Q/+BDeurtHrb5PnA1TDRU5JKDR2C5QcwaY9Mn0bWXGQ1nLkUMjGcpP15Zv0+8sYDBQFyVee4X/4nV/nz/7Fr9LdvkQ4WoVwkvzpc+haQi/vkFVm8KeP0Dh8Bd+miGyDoWOQI5DpAfGty7SDdVZmjnCw/zLB7Tb33OczrAasppbJ9jTdbJ23/dAbOfX7Q25cW+fPv7DFIgVzMw7jrYDIdQncCpVgitCdxRKA0SSDbZKhxguqCCHpD3vkToDrgM1TwpqDFA7CWLJhTmQzFtbXmBmtouOcraTADyxR6GGjGhUsW2vr9Da2ydIhQTXEdaHpKLrDIcN4SFHEOA6MteskhUuSpkRBiAk9Brpg0O39R9eAXZiG47i87U2PU6tW+MSf/wduXV7h6ksXGX7s9/Gm53j4sRN8x8MzzAnJZzurHHVWOBw4tGsRvq8o9DLr27eYGDlBnt+i191CZ4rQm+FYa5KwuMRNNaTVrNC3fRwvwh32+dznPk805vHAD74dt5jiuU+d4sxLpxkkFqsTxjZH6KkO3WybeDBg4+IWt2dXmXxsisPSY7oasq4z+jbnYDViIyn401XDekewdmlIbyEGbfbiVvY97sJRrDV71f29x/3KOneK13vY+d3jdmkJu/yEXU+E3WriXZX2b9NhsUjkXrVyN+j5lsfvkr53jt2rpu62Z/ZV0OW+82Os3Tlvu+de3knW5G4Css8Ndq/0uq+SKu5IOn5bnnchKXFVlsWFDu985+M8cP/99AY9HnjwMPcen+P6QoeV5R6TzQ6zh+pUoganL7zIa1dX8HzJOgFz1Xv4vu9+iPe9vcrPffDn+dhHf5nf/MjHOPXSGTpbA1579TL/40/9L7SCg0yPTbE5WMNxLRc31ji9ucXYfSd59v/4BQ4/UiMM1nGzAYFXUHdjPPr0RClOIKshxlbpigmWtn0+88lf4/y1NbrxIrEeUDlQw5mQUBRkaxB4xxj2rpEVqzi1AB/DvQciFhYnOXv9BbbzHoVNEb2M/jee4ed/4f/kn/3CP8YPUiqtEdJOyODqeZrVAYlJsOEM7dlRPH+dwPQRxTpbjkWNWfqDNaLVl7Fygq36IUaTa4TdBrNTLuvG4gqHulMjsz0ef/sbeOnP1rl+TdPXq4zNWEZbHrUookggCqs8+8wiL7y4BihK6GYZ2JdqXAZtymtY7nS3doN/9nUmdwsFu/Ai2DVhFHvXt9mBH+2jQO0NswPZ3oXsle/Fne7lf6nOge8prE7obg3JjUav3ER7Hu2RCtXIIwp9Dr1rhPe/4yH+xe88xcUvXyLpZeitNZZPbfHZ1y7gCYutevyjX/1x7p07QhKvsrJ+Cjcc8MDhGmfXbzKqe/hOi+rUAQ6EQ7Zv/S5PjcWMFQlpMYXyBTI9xZ/85idIR+s4Rw6hej7rL5+n+9I8Ni+QvmL0oQkOPVSn9UCT/vY2yy/contxQNox3PzwJp3XK7YedojGJHnd47VhTnPSoVgVqHqO3TaITGCloH0kpLuW47oKz5eIDPKkYPX2FlFUI40z0lijQhc3LNV7orrEqyr8QtLvpMTaYAIXP/LxWhWyZMAwSXC3M5wUMhdCXzB/YQmbWXItIDMM+gXG09jcQFAQZ+C4GqUsmS4vksPTLQ5MjNDDx6/UqTZTuhvbdIYagUQBrueXsBehiFouUkE9UMSpJUsL0rRgmBeEjTphFBKnmkwV2HBHwSfLibM+3cGwNO7wA1Ir6RlB1t3Gqx0g6fcxA8twmFDkKdIP8bIEQ1gqHXk+UkmQsNXZxA8VQb1BsjVEaI0KPDKlEE6EcnywhoACx1pya7BpBm6A7m0hNAjpkBUZqbEcmRlDOYpOJ0VqUyZxykGEJY7bSkWBLZWclGCQJrheiPAEWZ7gum7J60ATDxL8ahXXA3SOpywyclACgtBBD3IST+AKibIK6boIremvb+K2RkhWVhBdi1sNcWpVHF9h4hiRFTiepEgEOocCRby2hhf6Zbs1MCjfIWy2cLB4I210nqEdgS4EWVGAyHng5AHiXswbpjpkrRbu2DjR3CyRl/LQ8ROMTc4RBlVcVyGkg9YZhVQwei+nL65STc5RVVs0gjYLl69zdSNhdc2y3be85/7jvPmNT3Bi6o1IGeKJnHjpOteHVV6aj3ktcxFBzqc/8xv4Yhk3lLzh4RZzJw9wO4bTT19m4blruAd85n64xsmDHicaGsdCIFLmPcGIo4g1DLXE+KNM+0/wm7/9FElYI/e28EYcKqGPtSnbaymkFuk1KLQFhgjRR2jNyIkKXu0dbL36SYbdJVAG5QsKYXBEQjcboh3NcFMztmR51zvrfKwCJtdEOiG0a0TBGrW2JsoUyikQnqIxqghTgxWadUfxzkhya63HsHGGsSyhwiyHageYqzV42UY0Ah93pMVWlrFR5Ny6WcrXToyOUAlapKnLIG4AIVJVUUaQdjcQqobWMSbvUyQZTlAjSzOGicZxA5R0Sg8WkaLzAY6JMd0BxhZkJme7W5AYS3U0Z9BPyYxhmGvifkxhC6JmHRE4RK5Fa0kliGg0KoT1JpHjUXEMaTZkkHbppzHxHgnuW4+yAmXxXI/7T8xSqb2Lr52+ypf+9CsMexnx/EVOrV7m7GchkIZgLOIHf+GD1P0mg/gG/eE8jpMx3qyw1J+nRQ/lTRNEdQJ6xIPPcakiaeTbZPoYgZ+wsfENLl1dY9BuUZs+zHFxgGc/+QVuXb1Orgvmpg/xiz/78zQqIdfjq/zmb/2/3NroUBuv0OsVDJ5fIH+4QjFXQVRDbK64laa4BMS5y8a5DZZe6dBZSrA7+HSj92F2KeUDd5sEu+18sQuP2Vchl0ruLcrstPnVTpGhXI/vxhXtLeC75b5vc+aBlHIn5tit0H+LAGQnkdoPsdqHnbibj/DNSZPYcTnWO3CLPWgSd52+PaT1PuiQtWYPgmGM3oNX7O8wfFsMIbCmoMi7SGn5r//hP6BWD3no4Qpg2Nxc4Y//5KvMPfQdHL+/xWtnFom31xg/ALd7PZ568jbKUTTCFgdG2ty83uWppz7P8Xvm+Omf+d+5cOUWw35K4LgYcm5cv8BqeJPljVWsLMitojBgPAi9IXMPHeCdPzDHA3M+9aDAs9n/R917xViW5/d9n3866caKnXtmemZ2ZuOIy13ukl5KJi0JFA2YEGDDMGE9+8kPftCjE+AnW4ZMw4ABWzL84CAbJgRJkAHCNE2Ku9xEbpzZydM5VLhVN534T344t6qrZ3e1LdoCuH90V7jhnFvn/M/5/8I3kKqGMmiMkzgitVdk5ire3uKr332bMN7CJids7wwxiaBq1xzN1og2kOYvsWpbtD4khhm5lLz06hiT/yK37/x9Kr9GZ5KYejrZkYkllXeoARw9aLm5DS/uZjwYB5z1pNGScMK4WKOGnkwkSOUQieHSvsYsO6z2rJXmBQ3H65J2cJdd5xmZCZkuSLXhNAhGScIbv/wbvH/vTT58eJs33zumXLXkyvC3/tZf5e/9vW9w5/aCxw/n1I3toYPRo/RTB/Dz/2xUtKI8V/M6e1wAUoC/2HWLZ+aYZ53K/iISsoco+guwxLM5f+aBIOXTrtuG8PQzp9nzWQNqSRccVbmiRXJUNbyQRzQaITTKaIa5ZnuU8u//9q9w/8tT5vMnfPNPnvDtP5lRHlVUAvJWcln/kD0549BbOt+iZU29LLmeaox1yO4Rqb2HD47Z9JRPTgquDD/JoycrDt++w+mjY/TY465/ju5773L67kPc8YoQWvRQMbiS8ZV/84s07jFN1yGNYvrKNl3rEI2lfOSYfSPQzgPjTysGtxROKuZrxfGfdbhjSDNDlivCPEId8UEyMAKpwbcR10R8Y+m6Cms9Z+o0oEi0wOQGVzu6LmKEQg0M3mhcmtI0HVt7BavTCu8tXQfOwSgpSExGJRTj7RTtJSrJ0eMhSiqaztJ6gSvbHnIgNXlaoFSvF7ycL/BSkQ0SQpeymK1IRmOKwpAVKcpolNBkWU7tBZ11G6dIgY8b10qd4HWCbyuUlighKczGeXlj6OXrCiUiQiVEKRFFTpQCqQVaKnwq6bzuK+bCoZPeaF0oQEWsd9hoUMMRFkMUG/UnYQhSEo3BmEjXdH1GHBy2bsgkpEbTAaZQvd+Di0QhcW2LUhneWsKmehVibwjRxkAmoAsOHQSJlCjZE7IlkdZ6hDJo3RONfdWC7/CNQCAxiT5/TgpBE1vSzKCQSB+JWFzjSSdDMBCiRLqO0HR4KqhVDwErVwgZwHUEb3FNC10g6KavdrUdiIDMFMXuPirTzJ88RiUJ450xAxTdekE+DJxWR2x94hYqn2DGO5jpLkmSYWIkHY2pyhXrw49YLQ9YEhiMhnztcMhoa0TefsRQHlK2x/yjbzzhvTctrdH84i+/zi9+DrZqvAAAIABJREFU/td46cbnyZNxvyC7ksoK/vAbb/HOO4fo5YpX9iX17ICrA8uNT9zg8s0JK+O48/iE2cFjoi258Vdu8Ff+0id54/Kabf2A1tVUXcTrlFkHVRkQPkJT84+/9S0++GGgbVaooSDTObF1rI9XxCr2UDVziRhOEGEF9DfayfgS67Ckada9T8dQkIwk1VHPOTlyKW0VCZ3HGk012SHblriTmoOuptjfYmd7hwMTme5pjteO6Z4CGxADQ1EodF3xYH7KtSsFtXrI3dPAvpFcv7zDgTG8KAbUtz7LwReXjO8kZKLk0m5B7mFxIMmvDHHeoJ1E2gqlIE/HqDQCBikMPggcNcEuaXzASwFSoRNJdJFZXQEr9sYJiWpBGXwnadcOHyx0NTL0876TCbXoeUmybsnSBGnAZL3gQdPURCWYXNqDKLECRKrJYoJZPH9gqqRmWGxx6/rrDAZX+ezV13l0+M/446++z+2PnrCeLai0Zz8bM9XvkzKlimt87FBUuHbNltGYAMP4Qc/rwdJmay4nIyb6UxwvH1HdOca3NfkkJ5XXaN97n8flj5gkCX/9V/9VXrp5i6tXrvLKzRdRUjFwQ/yJ5qPvHbJ1veCFv3yJ2VHJ3R+taDrPzvWc4VDSiYTGGx7fLTn4wZry0OK7C4GsuAiJOWvZn7cR4ELge7FFf26cJsQzHYgzGMFFSuBTjLzkHPb+850b/IQq5hmHID7FUMWf8DpxobNyllhEzpWJ4NnASPDTYRHnnIINiV6cnQvYkEE3P1/8/xdCseh5RzxPvPoimuW99z7g/r27RCLFICMf5iy94sUXrzHJHnHrRsLDg2O+8c6c+/OWwa0rcGj57Ge+xNFRycMHH/Duex8Sg+PkZMZsXjLIc7QSgMX7hoPZKT5GsjwlSkmIoDON0Z62rPjCS7/AtckJMh4SfYmPG4MwEXCNQ0s4nc344N6bvP+hpmoWDHcTJumE9XxNM6sITcCpHJPcJLY/gjBHC0uejtgeXWMdahbrBc41jIcJxcCzOrGEEDkNBnvS4LYzbGIIwwGjqaKdLZj7juloiywx2FwwyjS+sVzeTnFtYDAdUCSCtFszb1fsTXI6jnlcKnZGGpnk1EqyI1OSvVd4cXvApcuX+IM/+Cf88EcfcDpbEn2kXP0/vP32I5qq95uCiDFmc+/weO/PIT5S9IUWxAb+Ji5cKzzNkT8+N5+5h1zoCvzYFBZP4UR/3s7YcyUHiYmkmSR2CtuU6MIw3c4wmQYZab3DdIJy2fHGi9t84sY1ysYwmQhEEnjvoyVBRX7hNc04fx9bP6RpFEJAkQeOD2uu7qWsQo3QSwaqIeqEvfEeL6QO2QkerZ/QPH5Me+yoXt6ju73C3T7ENx0qEeR7htHlgpuv7bNzTXP3/Y5mXvYKNR6SnZRQRsSRxy5g8Y6nqyLtOpIksDq1lG960kKhtjU6Nbgq0JURLSI6esQGnh5dJLSeqq7IhylC9jKZznpEKolC0VmHiBGlNDJRxEzTGM16HknHglaFHm5i+6pUYhyj7QGiS0hMh5YKoTOsi+SZZLHq8E7grCMGR6I9qUlpnWO2KlkuVyiTYMaCfKhpKkNV9nAbZ11/E5QeHxRCJnTO9eRqqRBSIZVkw79DKw8IjNJkSUIqBIuyInh6VpGWxASEFiTDHoIjjUZpgwwW2QV6iSSHEL2rtPcB5zyNDVgvccJQJCl53tG0/QXeV9MabCfobIdSES379ulgmJOmGmF03xnwESUFHsnpqmIqe8lRSY95jSg8AhcDZdOSJ4LEgI594lB5iQ8wyFKkSVBGI2MgSoUgEOOm4hQ3Fb7YKxQ1XcQkfXIiNxe5FJAMBriuwaQFBNWTGluPawPetYSyQSsLrkbYFukcSiliu0YmEF3Tc76TAmlSQlmDs6jUkBYGkSZ0siIpBPLaDvn+a+hihDQGqRJiVJQHdzg8eYhfzzh9+CFHs8csjGR8/RZG7lKoNcIeMbdPuH0040/fX3M6D1z/1Jhf++Iv8JlXPsd0eAnaGqkUy+WSZetw9YLEnZKpFgoDdUeNQxrLcb3mYO1494Mn2FAz+syIl758ndduvMDV4hTll0R3ymGncSajE+BxxHXkye0Ff/S1IxZHU3woufqJKb4TLJaero5EJ2C0ByIgQoUILVoL8lHC7u4t5s1dXNMQuoAQEpNtKileILWm15T3kEA3GKG0IoSaOjqmoz0moy10Isl3FMWpJwzA1QpSiSpgmnc8qZbc2DVcKiJLcYTrJoTuBZy4wo6UTPdu8ZnPHnJ1WyHtiulYEZo5ggHWFkShaK3E2YZMdGQ7+6ikIDiNkAkSCUYRQkcgEqPD+UhnI6GLrOoSFVum42F/LzNpD5mzEqoZ60VFFzxCJujEgNG9x8Hc4hQEFbHO4jpL1wS0ieg4pLOKGAVKKrzaLFTPNXqyp5I5w3yfYb7HK9deY7bMmA5f5YMPH/Hk+AFH5V1euQFa3MZZhfegZESpQFW3TAYDqm6FljOECHhZMEy2mWiQDnx1n1i2BFnQ5hndakV95z7X/pVP88aXXuPWzZe5efUGo+HofPEbmwl26Tm+v6SuWwZXc6wEO9D42zWtDYx3DBqYrxwPvjtnfqeiKz3RP+tr0P+l8WmQvynUSblRKrtIoP34Ai6eBp0fx/ueqY7AptMQLj79850dXHQePiNxPw38zyBCzwZBz8KHnqoMxRh7FcCzlsAmYXjmSJ8lExeeuPj8RcWWi32MM+jSPy/J+Is5niYG/TWYElF8/evf5vT4IXXbcxNfePlF3vjSrxK6Bev6MaqoWcqOD2cl6zownhZcGezzhc9/gT/+o6/z3e/+gPliwWK+QCmJcxZnFQ0BKyIieFZVi8kMWTFBJJqYGdKtgmQn4cWb17k+vsogkQS3pg1LSpdQtwkA9bqhWax48HjN2/cNs5MxNqx55bV9ujLQNL3nU/ApTG4Q6JB+hooteaLZnU7YHt9g2T2kXjdEYTHKoLWkjBFp+0A52oCWFowkJimpVoSqwhIZZCOyJKNNFdlAU1SOUChsYwiJpsgg1S1zt2ZvaCgMVGFG8BNCGCPJyKRkZ3yNXOdMhiP+6Pf/kEf3FtRVjXOBo6O3cdbDxpwshoD3T7W7zu4ZUpzNcZ5W8zexxlnHq3/HTwflXeTPRDYdzWfuMxvE+GYr5ypsZ9v8/wtWlIiOyUCTqxHlomTnyoTtSxOUVKw6S+cijYrEpkMwI0s7xsmQL/7SJYrLnt/7aiSknn/9ywqRLrhzOmPROIa5ZJwPeSIVVq1YiRKTeyaFJslTrpnLyNVjPrz3Nk9uz1mUHathyodLSffdN4llg1SQbyVMb2Xsvz7mtVd3OTq4w8nRgiQBqoZmXmOyhK7zmImDROCXnvIHnua+R+VgH4MaKkQmCVbSOYG3vXRagcdXEGQgtJIoIt5HbBe4+lLKat5hXYdrAk0ItF3EehgPDCEIkBKlJFILKh+xZYMKoce0uwhBUCnH3g1DrjRBRqIyRKGJqxKjAzKAj72CTxS9RGHVNKybgrU9JVpPBGzXkmcJ+WjMfL4gdg2tlX3wD1hvKQYZUST9IodAKIEyBo1HeIuIHo1ECkWUBi8kVjisdRAVvgt46ZFpQpb2xFwvFT5CGyw2dGgSrA90XUkTFDZ4WgeV08go6TrP5a2MREZYrKmbDhEdou2o0D2utImYxJBmKcUkx/ueiNZVfWKTGEVwkbUPZNaSZ6a/PpQhqowuCCKeVVVDVBgTAYltO8pO0QnFaLiFMClSK5SErJDEpulVAQQ4awkuEl2f8DSdwoWACQGUIJUaY3rdeRklWT7Cu5TgbC9nai2uagjWImSN8BXKW2SqUdLTtRblXS8lqTREj69XdCfr3oNBeZTsUIlCTQzJaMJk/1WC3MXbimDnuLqmKecc3X6bR0FRhI7lfM6qbmi7lPtPDvjSpxo+OrgN9pDbszlff2/BfO4wheRX/tI1fvnWZ7ky2SUSscLhXMtpuaJs17x6I2UsRxwfCh7VDcvouO887sFjBrJibgOP7y/I9zRXf32LK5dyomiofET7nNZLjruEBINowTfw8G7N977T8OggEmPHeHfI7q5i9tDSNg3B9AR/NbkEi9sIXyOJpKli78qArcuf4MkH/xe+rQkEhE7QSU4IHZk0jP0Ko3o/i0RrimICrSAtwChJZjKGg5zxOEGkiuE04BYgMo2TkphE9DSQojhsFZ+5MWAaWoJYUdVL9oPHikChcl6+dJmbY03oKmxXMpspJtv7GKXx1tI4SdspVHS4rkXqAucB3xJ8hxC+v+adJbga33W0ocV34LqKoCIilXSVJERF0AaVRqrFISenHWSKfCAwOqJVpHIdtglYHDIRBClw1qJ8hGmBbdY0LiUGiW8crrO9zOhzj95vBPLN75HdyZf4G3/tS5RfWfFodod3Hv0Jr12d4eMRs+qEEDtSYzB6QCk0QVY0YkaRCow2KJWh5S50JxzOfsDyeElUO5zohNuna07eeYBdlvzVr/xrXLl0FWPMT/xkwXm89ZTHLW/93n2u/sIu+SSlrB1u7ZmP+vvgyUc1R28tqU5afBOIfuO828PW+7/qaZawwQufkZPlM+3/zSHoPWLOGgzxLKeITwFDFxID2ASmG2Ojn6fa9U8bMVw4eJxh/8WGDMx5MH8GbTjnBpw9eRbQCHGOxz57Xfx4OnERcnSGsIjxLM145sScnZNnoBZn7/3/UFn9lz9+0qw4I6WeJTgpznfcemmXo9mKdeMxGi6PDN/71lcZpse4aeDBqqYMEWUk7smaa699DhHgyZMD7j94SIyRzlqEBe8dq7Wj1qpPhjdE2GgtUUZMajCTAfmlIWqs+LXf+iKOhroTEDWtVyyahOU8Ms4Tjg/WfPDujIczOLFDYlwzHhXsDgUfHZ5Se4tPU6JLSacvEE6+T2p7Z/Xtccb1y/tMJtd4+OhrdHWDHIAyOSpIvGsYyoxBaNCbe2CqNanKkJ1gNOwLeEYlDLMcm2XIRFGIgK1hOCloiIhEoHOBRbLwihe3cgpXQqiJviONgSCgMAMEgtFgQlsHjo/XfVwfIEaLdwEf+sQghoDzfSJ37sGxmWpnBYYz8n08T37jM2f//H5yoZP5jHv7eVZ8llBskm+xuavEvjPR37ueqqM9z3iu5KBe1vi2YzjIMWnC7qUhSVoQvCeNjlwKBsMCFQt87HCtxyXQNJFJqvg3/tolJiP44MMDvn/f8v6pZW8Q+M0r0IUZOxNDmhr2soyBioxFxDnPw9l3OX3P8ru/V7M+jhymktujwPr0AeFRAwiSgeTaG2N2Xx9T15F37h2RX95GZYpiKPB5RlQ98dUbjbicUJeOdgFuGfFroOgD92xokFbhjuMmuOurO05EWjbYMQFCKqIODPZyLl8dI1jhYiQIhy0d1arG1ZHJNCdNFd4GXNvrjadlia8Voe1l2FSSkI4KjBZMkgK3LFEmZWUli8Yxmg4Y6pTUQDbOOD054mQ2o7WR1nbM56dsjYcM0hShIHSOFkiyjPGoJLQKISVd6+g6y3BrgvSOIktou0jV1jReINKiNwHzgeXKYYxBKse6LtmZDNCmwOeCGCxd6HAekmKASTW68TRlS+M9dVXRrteEumPdOULs+QcmS5Bpn9gkaYo24G2LQjBIDTpahK0oBkOC61BJStvaXg5MRZwoeHB0ylhlKKNQWoKWJFqwP9hChIiOlsT07rZB9N0Mu1yTakHbWU5PSxLVm581TcCrCdZ5ytpiU0mRGaRzyCjw3iJ0jz92LuCcIHQdUQ7oGocIEZMZvFFgO6TrUFIhVYKSms531EuLnS+ItiVSopMaFVukAJVoXLXEDAuirSFYJGA0PYehrQiuZFQMMaJGSEimKcnOVaQJ+HCbbnVEuzilWy9Ylyumt25yZecWJt1DqJoQW8pV4Edvfod33/o+R03LjZcvM3uv5K2v3UVUgb0rOX/7N36T8fYVQuwIwhGMZ754zHgiaWoIeSDs5DilOXk048QohrsJcylYH65QueT6yylyT/HpF8eM2nv84OAu78lAIToGAnYDHK8ayg8rfvDthrfetNx76IlRsfWpy3zqK29w/60HLA8q4tIitEJPNTpd4LqKRHiUERRbCZc/t09lL3Fw/zFWdYgkYrKUbLSNikt2b+5x8tab2GqOzBPk6BKyeB3tI6bwLBrPDVKu7Ex49eaYozLARLNrOtrSI/ZzQqo4uVfylV/+FG+eeH7YVHx5PGSg9jgVIxrX8LJ0HLQnZEhG+WVC5qnaE7QekWpBKi3LpkPLlNHWLonKsTojdJbTRUl1cki0JUlh0MOU+TIySDVNWeNsSwwKFxzRSeZVTdPUWNnLGPum5PC0ImrNMB9QrpaUZUNwgSwfkiQJ1q7IjMADNhgCkeN5SyUUW9swX7fUixWDTHDj0ug5l4yzIZ75WQiJIDIqprxWvMEnrn8OHywfPvzPePP4Ca9s1eyZFVbMGKRjlNKMigmFrFBRYv2C9fqb1CeOP/6zGbqbcmfUcF/A7KCju99ybfc6uzt7PzUxgKfhVPQRWzoefPMA8+aM61/cQ0wTXCIJNnDn/35CeVj3C3I4j+T7956V1zbVb7Gp9J2pFp2RijnjImwOxdnie6Y+dPaJ4maD58X0M4Lzpvt4VgX8+YK3/Pi4iN8XF4P1uAlqLpC2Lwb1AEoKnmqx92ac0J+bs+MiLyRrZ2TMPvCJF0jjsU/kNrryT1WizlO0zXk4gyj9OYngP/VcieePvn76xn/C72cb3cyl89cE/u7f/Q/xYcE//adf44P373Dj2oTf+a/+PipRTLcKsssanwBRUAjF3XeXfPX4O/yD//3/ZLUqEULgXO+We6YEFSO4sEmafSBNNVXT8eDuE9IiQUiBfFtw69PX6GYf8b35h5joGQ8chXbYRc3de2tu7Gm+/acHPD71VFYhEsX+yy9yefc6B8sFzdEpoelQSUI+yUjTOXUzY5qCSBU7+1P2bl6jskPef/gebFuMlBTFFsppUrPi6kvXmT+6j9QNanAFmV1CqC1MCGSppbKRqUi4Op1i3JS184giZVf3vjCT/Ws0VYlvDZ+8+jr3a8dtV/JGOqZlREATgmN68RQgCAGcC+ddAq0kXWfPUQdCakTwhE0hOMYz476nnTUhBEqpnpDPhc5apBdA4ELAf75vNgpfm3tJfxM5n5NnnbR43vbk6bl9ehn8zPFcycGlS/tMx0OCs1y9coOH9ZplWyOaOfu7U7ZHA6TtqF3JYFSAHxB1zXY2Zmun6OEqsmOUST5Yzbhx2fDSNJDmllQ6XhhDQsS2LbILHC09X3/X8U/+D8/DI1hekcQ9kNckohD4/7EFAaaA65/OcMLz6KBmenlAimd2/whdWeoDi3MOawNdK2lOHa6L2CqitcTsKBCCZCjItjXdEuJaogqFSSR2ZZFbmmxqaBae9VGLrx1Jakgmht2h5OFRjbV9oJhLSQiC7qSFNCEag9ACfO/A2VWWNDFMdoecnlS0dSBGibKB6WgEyZTJ9S3GaUZjPceLivq0IkSLng7B9M7KwmQMC8moUBzdP6HbGZINUqQ3YAWgkNJhpEGNRjhnUUYzGA9pfUKQcPBkTZ7m6DRlYATWO3yIVKFBZj20Jh8mZIMp8/maVEZ2dwcczktc1eJbS1u2NEYzzRVllIS2IZOCfFSwdIHd6QCZa7rGkhjFqNCM0oASEYQnWIlKU0xUBK/BRTCSoHs1poGKtE1Lva5Z5ZrRICPUDUkwKB9RCIaDMT3aKeBdZFU3CBUROrI8PGF3NELIguWqwRgg0+ggSLVhNEpIlCRNDSbRROdZL9bkRYrzII0CYdHCkyUCORzStZpEp6RZ2re9reuLOauGMHc9eVyDtBJlNW7tkRm0jaBpLCauCc2a6nTNYG+EPOiD6241p4sl4aEg290iHh0xujzExBLl2577ctLRrh6CfR8ndtCTMYP9jOGNbbaTl4CMGDwuHLCet8xXC1bdghdefp2jxPPl9D7/0z97i6/9yX2ao17K9n/9L/86g73X8MmE+fqItl2idUITA+HBB9iwjUp2CPIxVXVMeXqIcy15BnkquXEpYe/6AHl5yOPQst067LFjfrIgEY7RWLLaMtxdCobR8U+/2tKWUKcaU2iCSdj5xIR2OGWx+hGrpsZKic41lgTaJbhACGAKQ777AoPi34Hld+geNoixhCb2msHFBMaG4WCNW99BiIZXP3WFVz99g4++c0Q2lbTdmJAmVCEQoiEr9sii5+YVz+2POq6+5lmdVsRlwq1fusmH/iFfeGmFyqdcH11iJXZ47AyH7ZqX0wmNmDLOBySxpapOWJeC7WKM0pJlNWNWKYrMMBQGaz3OlcQQqZsj1tUJRIkYjKlKxzjPwBmWJytCCOSDHJ1qIhJjCmbLBUJ0PQcmgbTIyQYZvm0QncfEiIuOpmlIUw1Vi4vQBoc0hnw0oPaBDz+4x/WXdtjZnWC0JjQN81n1fCvGc41+9VEy4dUb/zFx/DsMxZtoeYISHUnqkVGg/AzhOmZlx0cPPW/9yLBodrk9qpHTDnHZUz12dPcc+1uX+R/+zn//M/ccQyS4QBARHHgr6CrH+7/3oBdEED1MMLjQwySf+cTP/vRxUu3TNv+mAigvJBY8DeEutvyfbuusnd9/OXcGlgoByCieBr8/p0OoZ7tP5wCiC+QCKdU5ORIuxNibmPppQCPOYRfwbHXfu40EpAjPPBdCQOlelvRZinG/X7FRiQqEcw6DiD9+rp57fPxt/9JPXyD6U4I/JIZTYhTE4Pkv/vP/hr3dKT/4wXvcvvuEre0pNsD+JOXTf+M17r7/mNODBZenI37r17/I/r/9C/xH/+l/zenpnKbpi6xKKbLUUFVt30ETfTAbgsf5AG3/xzproYroRJOZhOWTBf/df/KPufzCgMnY8InPXmLv6ojTw4pXb434h3/4gMnukFSArTRBppQnS9JPX2H24B1OXUSkKXmW0ZKi7QJpI14IhtMpw61fJDe/RLf6iMWdEn21QJzUYDLIhqjtAaNigauekGeCL332ZUaTbZ7MGgYTQ20vEbSkDh6hhiTJHoUK7I88T45qrt6A09kJl4ttBuNdZjzh1Z0G1IBhdoU2FsyRrINjW6fPnA1rHU3dIeUG7r3xOjkL9p+R8I1POUdnpH21KSaEM5UinhYOoE884GKn4OyaObsmzjpom1/42DUFF5L1Dc/nLNV4jrn6XMmBEIosHUIGHeDqjk55EttRLhZkIjAdpcgIXdsRJSiRkGiDEIEQLVKl3NzZ4calbQ79jMf2lN+bO17JYDtG7rY13/go8N6bnkd3IydRMr+R070YEU3H4EWwdWD59YA/DIgISSZZlIFsAImD5rSjjrrX+R9kNK0jIBCJRLSB0eWEDkM7txgtUEmf/UUfsLVAGknoIDQCUSi2r6fMH5bUStLOHdGB0AqhJVorlgtPFC2JFHgXAUW+n1E+XOFLeHJnRTaQpAoSDwNd0IhIWUeMFOi0T+OEAkvK/NST7kyYdwFFYKsQJJ2mdIq6DXTrkroDZIESEpMZBvsJKsvoYh+Ed+UKHQXVOuHy5V3W61NMmjMcZxitaSrHaDhEigKvElrvCZ0joPHSUgwMrq6wXaSxARM8SaYYCEFSKMZmhKo01llEJhGuAZVTHa1Ydx0mTykGA3KhWddzwrLnKjhf4yjY2RpvSNQDVFoQkNjOEiSMdrYZFhmL5RwbG1ITGZiMJAisrYhWM5yM2M1zjFS9u7EKrOYlUWi6tkFKSaICmo6t8RQfPRJPMSo22th951t4jWsrateSyAJEwIaIDRJhfV/dVz2PgiSgkKQmIckk7WnZQw6iRNiIkAlhGai/X2EykFt9EKLmntRL7JMluCUq71CjFDJPKA9ZVY7BTiDMZvhyRWgrgvZwq0GGBn/aIWtJOG4RqUVu55hLgrgsSXauIMcJpIASoPdYn77J8t4hs1nDolbUMSUmY9pGUAvP1957j3f+7B6rg5JrNw2/9ZUJRuSsfUriPYnwVM2Ch8eHrOYl+0pzb/aIjz68w/2DGYfzNXW5ZGcEo/2MnVHKlSsF+XZOnSV0csj9R8eM9mBva4skBS0D1BUfPmyQlaNroHQGX2imNzUvbmf89m99mScHlvtHDd1J7wuhU41OEtxpTbplyI1B6SHD4jqvfulVfvfv/LfEbYEIkF8tGGxvod2U9NoQkRnU4gHFMKC2t4jjAdN4jz9984Rf+e3XEOmQVXfE5UHk85/4Fb59WHLn7tf45S/c4q3DA8JOQj6YUiY526tjimyPvd1f4V17CSl3+KVRxkvZkJGwvJgr4rrBdititAyLCYvqMV29pulKimyITjJKF5Ei4OqS9emCeRVYli3BOuqo2bu82xP4nCHEBB8tVWPp2pJLuyNcu8DWDU4K0ixgCHhfcTyP7EwH0LYEbwm2/97OZ1QRRmmClIooJY2ImEwyGg9ZHi4ZGkUxyuhSw6PlyfMsBT9rpdh8j5sAGQSKF4b/LnfL/4Wj9uts6UiKZ+1qfnRYc+9uR93t0Oo9Tq4IZmGNbyouXR/z+KDh6J0V3QO4dSPfrEU/e1ULARB9pT+4zYIZIt4+G+x/DOPTP3RRUejCay6IF52boyEESnEOkwnh6SIvxbNQoWcLdk8rgYK+0/DznhhAj3sOMZ47GZ8RJs+hEVLCM4nTWSDUd1XODuu5x8E5T4Hz7/GCmtH5fjfBVY/SOuOJxGcCrb7TAELIc8hSX9H9F1AqihvYWmVxBw32UYNKQV/Ne9VK70BF0qvbnKeSZx/spx80npJdNviU4Al2AdEhjMEd/y5699/C228BaxADpLqO0C9DhG99802qqqJuLCEKOgcmS6lsyY++8RZWQGwbHr13yu+8eYAPv898vsJ7v0nU6IuoXcD5gNYbLozcJHPEC0o44hw3723k8YM55kjx8KMZl69POX7UcvPVMS+n7BuXAAAgAElEQVR+dso//N/e5vvfn/HGb36OdekoguD1G9v84he+iA2Rb92e0y0d+VZBMRhgkhF2WaGvjJkaiVBX2BrfZLST8Aff+ybJlRRCybXXbjKZXMZZw/jGNsIYZPmQ3f0RcriNSUE2x9x56wm/8Tc/jxcJTThhe7jPQI14WK45Xb7HZ176JO+c3iXZ2UMkY7yAoS9J1BbjwWe5Z4cUKuVFLRkqg5HhmakXI+ddAR88zrqnc04I4qYLc2H6bObx09d4H/DO9RAxIXrepHzquyHOdiSe+hucbeNs7j/l+ogfa1xd3P+Zclf8saz2J4/nSg7mVcfKBkaDFC/g3r2HfPrTL1GMErztqFpLnmmGw22ausbhaLuW0FTE0CKlJ8s9SSJonMU5Se41SRQcNoLf/1bHfReZR1h4QZlEYhvRriXUgVu34OB2ZPZOxH4YetOxRBCzvv3lK0cXW1zlMYVG+kAjO4SIJIUBo9B0DLc1TedZuh4fKk1/MSoBMlfUR46gQKcakxmihMQIgpU4JCKT5KliOErIpjknj1qmA83po5qmsehCM8wTxCAlnUrataU7aRlmkmSYIIWlCxq3rBHWk2lBkvSfpRaOIpEcr9fQdWTCkUTH4qSirAVmOKZF4qVCGYcEqtOOdlXhas9gCEILhNE4B+O9Id52SGnousCqKelcZCQie1d3CDGndZEuWlQiMRqasiMh0ApFwNNUNbZtUdEQs4RF01K6wLpuCXgmE0GxvcVs1WCJJNMClKS0LW3XUNYtg9yQ5ylpYUgzTcBSmIyV69ttJk1Rw4KYK0ZFxjBP8TYlNRkER9O1NF1HDIG2BSNLrNEE2TsJpkKR5gV1s2Y0SvuFFjBaYnSCkgl1ECTaQOx9C6rGcmlnROg6AlDVNW3rkEKRDg1FltBVFdYGotIoNEgIEqQPpMMM0TqEBDPKEMJw+tGC0Ci6NkHbQPSOsFborQnrd/+MMgRc4VGzDnyDCpJib4BzFd3ScXjQ0DWWUSa5otbo3JMIh3KSGFqi6RBpQKf7xNEUOR5AvtNj1MsjgpuzenCIC4LGgdCScZGTjrdQuWLLK96aV9TWko0E126mvPH6Duta44/uAYEQKo6PT7hz5wBFgK0pB8cH1F3dV4xcz+vQmSAfG3Z3C9IiJSJwVcdqvSZPEoxKKStL01gSGdFBYk4jTRnZmaTsFhmj6Zj9nS2ub2/z6pVbfOt3/2faxQKZAplCJorRTsJ6tkbbiG/gxS98ltf/8q9z+84PCWZNbFrEVkJqcnTncOER43HDdA8WzSGxjgzzTzHd/gLt7Ls4G7nzgxlv/Kah1De516Vccqd86caA/WzEh+sVl7cMQWmsjGidkIjr7Gz9EjPnedFE9pLI1Hi2ZST4lkkSaYveyImuBWpmyxWJDqTDKba1xHKFM56A7jkdSuEIODQ+RNZtQ/noCCX3MdRELRgkKYnRrLMBNs0py5ZFEylXp7R1jbOOICKeBt+VdKsFqYJhpimSnlS4e6VgujtlWbWs1g3OBZQybO0m+KbChYh1Ap0mjEfD51ownm+cBXV9+Juqba4Xf5N5u83h+h/x4HDBI++oRGQuHZYTXLem9QITFJ+65HjznRmP3qlZ3e14YXyL/+Df+9vPv/ePr+DQQ3suVtwuVK8vsPTO/vUPn5mWwfliTuzNhuImAer5CPKZct0Z7EjQm6AF37fzz4LmpyU/8S8WnP4FHxeDceA8+1FS9knDT3g9xHOX11626WK1tU8EpFLn2OkefvGTgu3+XHw8r4sxIjbBldpwH86gSPBs8PSzhmu6XoykDtgjRwwSt5LEhxuluRzUrsHXLTJLN8XcnwARihFvLat3fkg4PSDNBIIGs71NqO5CsKAtYpSgtrb7nMF+GxBED0JPkfolEBkIsNazXNX4CFppvHOkMuPJ4zkvXUqYPVxSnzQIC21bUtUe2Hj4eP8MaMk5RwhPOSJPeTL9V+8Dwrr+uDrfFwGEIDjPwzsnzA6W3H3/kO9/s18fVJCs7y74xCdv8dLNq1zfv8Kl8R5vfvv3EWGNmaSIwpDmKbujActFSWKhXlu+8KtfZOfaDY6Wj4h6jqsX6P1tRmKCaEqUaNkfLRlPA/P2CVmTMcpeoUi2kf4BTRP58N0jPvMFw0pcIYSHjJTl1rTgJM25Xy+4NhrhNtAeJQaoMGGSv8bcN1zWkUIFUhXJpCSRGVyYfYKz7srT+XR+XzkjwceI836TtMbzOd8XEiR+0768yCnw4em1cpboXuwanLl//1hnYhP8/8RbysWug7iww3/OeL7OgYx0tmG1aimKEaNRStNWoCUEjwuR01XDblJgfUcrNK3rHTmj7/HUTbQkMqGKLdYFvFd03tBpwaPa8oPvePRLssfNG4FdBEQeGeWwPoL1g4h9FIiL2JOQLxuyKwnpYNMu9J7QRqzv2eJ26UgyRaITjJLkkwytAlEExuME20acDQTAbBl0qqhlRMpNq9FD0AKV6k2puQ+4hJH9SXeB/NKI6qikKS1dbYn08KHtS0P0IGfxeE63rOi6wHrVIYPDpuP+JIUASiOMwgdQbYXxJUGlNI2lqhuUbeg6hwiapm6IJoOuw1Y1jQ3gQcRAwNNWHcL01fTMpFzen/Lk3gFla/EC2i5Q1xaVQbF3jepoBcs1KgQiHhHBW0tbB/I0p4uRGARSarrKIrtI5x11EFRlSSQyHg9I05wQIqt6zSDNkUrSug5tQI9G5JnEJIo0MySJQiiB1IYYJUWR01mHFlAUGYNU0tkW6ztSnSJjQHmPdJa6qlF5AtGyLpcYnaB1smnNGWzbIAEferdTbTTS9Io1REHretJv9I40TchygyPibIdzHpMkZFmB0QrrOzrbbVr+Eqn0phIAWitMopBZ0t9QkgRsPy+01uj9AaIJ+FqjpwazPWD48i2q27dZHB2AW/fqV0mOSSq6ek09azk5bnBtg8kUTjnCIMJIQiKQgwDDiFAet1wSRYHsJL6tqE/mlIdHEC1t5WFrjNIJRTIgGYzRRYHOoTg5plnWGBkZG0EaBbNlxL53RLF9hxg8OumdHIeFJkZYVyVN19BuSLOZEcgkQxUKIQJV56gXkXYBVYh4LWldQK4VUQQS1d/oynlHvRK00TAeZgy2h+xfmnDj0haX9y4x0JbtUYuWAUEkyQzT3W0CCTEcko8M03zI/rUbiK0rVPe/RzVvQHjMpT2itUi1ZLyvKJeOmLTkeUJ0GULsMhpnsPOE6DzHj0p2UGynOzyy8HY44JfdHV6/9Xn046/h8159SxNItaOZfoY8uw5+zjQZs2UKxloi6IhuyXL9iM51dL6kdWtO1yVVkKjOYQYF1jVYb7HNCmcdSM16UdG6M4dWR1V1CONIkjU+erSCzou+cIFiXXfMF0tkbEmVpwuWsmwQBJIsoatbbACTKnSeUGgIwkCiqBuLlpJBntJ0jtpDcC3jQdZzbXxLVkSC/XNCK55jSKEp9DUkX6GzgR/af8Cb75eMXtRELbChoW1rQiIZ65STU8vpgaN63BBXkeF+wSsvvfLc+3tm3TuruG0C+s2DP1Gc6ZmHnkYA5+FAj3HfVHnPCcni3MG3VzXbvEdsqMibjYYQkaKvqvc7u+CI/LEuw8/rEBeCb9gkUBeOndgkV2cJUh8niY005tPHz6BIZ5jqc7LmBYhRjOFCUrZJ0s55DE+r9WcyqucQjo9FTs/LN4gbKVpkL+AhjER6EOMESg9ZRA4kKteEskFmySYAFE/nYIwQA8Fajr/7ZzRv/wDdLhDbOcIEpL0LYgmmA2nAFoTKEuUQnENmnwAVQY4Roug7DUDnekM4KRXa9LCt9XJJ1zXcffeIct5ga08MAu+g7dwFnksf0Colz52qzzoKZ1yb8+bG5vg53+vvCyeQSqJin+DVZUdTdSznMJ8pmnVgvbTc/9EBqlHoRrGVThleUiSmQ4a+S7E9njKd7BG9pu2WTHYKhmbK1u51RDagmtXM56cI0TLcv4VdnpBmhySZw9sWtCBLblBXV/h/qXuzWNuy6zzvm91qd3e629YtVrGKRZXYihJFSRatxJalKIojwSEcILGTwI7SKHnxU5AYhoMY8XNeEiBAYASGkThInECILSNiIMECRYsmKZIiq8gqVXfr9qfd3Wpnl4e19z7nsi1bCmBOoOruc84+a68z11xz/f8Y//iHkDNGeWCcLrFNz5OTiolQjHTJYzGjiS13RMeN2fsR61dQaQ5RYKQfnNvkDbSeMQk1ucrIpMKIwfZcC71ZVlfWzA7V8zRo35KATR3Ozgp50+hPbNYUVzJhcpPZirDrx7GT5X3bBhG3a/dqYIPLLNpWkne1Xide/eX3sOG8J3LgXct6Ncf1jtEkUowL1tWaRmkSDXrDQoWRSGlxwtDaDaNykbZ3JKLHyEAjArWPrK2kjimpTklmluWxR+WRtATaSNdDzCEtBU9eD6wfbYqHPahCUtw2JFOFyTXBAl4gJbjWgVKENoCNCKEw2qBzhe889JAoBQS8HSrC0lTjo0InAWkGb2UtBFpJYpogRSRJBFENRbA+RPq1JTkoObno6JuhQHXbxXEyTkgmBbHtqAi4pqftPHbdM36fITOKbglRSawY2mSPdaA9PUdM94YC5tbhO0+UkiJLCECagrbQ4umspe2hTA0R6Kwj9A6JpJikqODobcu67YhysBKMrqfrJbOjQ+ZVQ7PssF1FDI4YBNoM/RQOp2OkEghhSFTGhZ0TBLhoh+NEh9QSk2mUEeQyZb5SpGmKFAKrWiSKYjQiUyB1QCfD8Y3WiCRFRSjHJf3p2aAVFQkqerq2RcqhiIw+EHuLsBbfW8q9oWNu21bExCOB1nlcELiuB6F29+rA1v1G+6dwzhOiJUkke9OCLEtoA/TOEYInAMoYUjRd3+NCQDqHURop9VBsLAeLTJPogXwoBUhCE9BlgpwpsucL/Elk+ciwiCm3DgLjg0/x+PXXuPv4McLWHGQl02nJxf0FsV3hFmtC3SG9xUiLSTPENYWYeORMI/dTGBvQBa5O6f2I6BXV2RNWTy5olhU6dSSpRmURGSTBS7yLSNvh4pyLt99mfdKSRoEWkrCO3HvQkV8c86woMSYnjRIlAuNcsmg9TVVRtS112xJlICs1FknbR3yhOV11dC7QBHBasXdQsl539L5HpYqQCqL1nD6xBK+IiaHMc0Zpxkhq8ihIJdSrB0ymEqMHW9hinHDt2Qn3XqlJE8HksODw8IjpzUNkoqgWj6gXPWIqkJOczFly02BmEl1FklQRyiN8qDERRllPN2mJPtIsLeen9/jIix+kHN/gbPYyr6/XfCRX/Oi1CW8TcTJlLHNmZsYqf4FEwZGekpl9EjVBC4kPNW0/Z7F6iIsQvKO2DeumwSQJ1B3RBZRK8N7Ttmu69QpPxsX5GpVOiL6n61q6zlJMJEotkQhckFRdoAkeHQJVOuLsYk6R9GgVyApN7g2uaUgkdF2P1qCUGIq2S4VFsuw6XGMpyxytFSIoQt/Tdx3JXkndWkJwODfsD3/y46qQRpHp5zgqc25M32J+8Tu4WSABbB/pnR8KyxPHW29b5scWt/Lc3LvNx1/++KV7zQ/6xKfA2JXTuJol2Hw5RPLkZXZgiAVenvUGeEYRNz/bRqKvHHOr5d0c/uliwO1RL6PYV6VHbAHu1YLDH9axKYwcgpLfBri3BOvKRIkNmN+CHAU7ec12HraFxrvGTcRdRHtbSHzJDcSOQEgxNH7aWslKKVFK7cDvdo1IId5z5iCGONRUCBAmoieaiEdfM/hHkjgSMNKgIdQ99ZvvcrFecfDCc2Tj0QD4+p7mjbeJ6wXzL3wBcXIfPQYxnSImGTFcIEYFosgRSQlqRHAJgRJR3gb1DEJm35E38W6jdRfD/hm8Z7lYIXXk4ZsXu6UawpYkDxdlt+6j3K3Nq/aY2xdPWWZu3sdmbq/+zhbrblw5eXh/RfRQry3L44bFkxq3cmR+sMaXCBKluHYwYzKb8fj+gjSB/WtHHE5uU06mVKFjtT7hYlmh9wXJaEYRHpFOLEZH7NqjjCFm1+m6M3SEJHEIY+m6nvm8Z16d8IHRlDrd4yJYToLnhoE7owlPUGiZkIsUo6Y4dYQScKBHRJGihEIJjRTqexLJAdD7HTkN2w1gU9dy2fRseDYPW5kg8nQ9ALu1DX5TPLw95tXAxs7la1tdLLamB+zW/NVsw+bXdtfyvRLi90QOzuYXPDkZWOdZZ8jHCVPjBlDmAzJ6CIE6rDg4OCAR7SZVqLAoVl5iGo0LLSQprZdUXtHrHE1Cue8xNyzVu46WiCqAQhAraDQ0J9AfR8IyIgWYsSQtFbGJuGSzuSiJSiUhOEwiEElGc9qDdRjpB2IgBCJqXG2HVK+WSCVIhGbRCPLSkBbZsPH4gBYQuzB0Kh1LeuRgSyog1J763TmhDYNTTqrIxilpmUHnSGzHpEzRMtB2mnbtaOuW6bWUVObMHbSdRfSBsjAcXRvx6pcfkF2HvVyTp5Je5dQ20qUZo0lGmWl8Cf1IU9aW4+MeJYcOwghwjYXO0iJ5e72kZ7g+PgwRWaU9wWpGsSZnzbldUHVrsI7Caw6fuc6TkwuE0Rgz1IwUKiHYkjZI2nWLa1qMluSTnKKUCFVDp5nM9kjLyRAlbSqqzjKZgFGDL7uRllQL8iJFpgVpcJhEI7XEtT1NFxFBIqLl2sEMLSTrrsf2Q8Tf6IQiEdRNC1IRg8f2LX1jaayjHI/QiSbRCmIcfOPrNVLnxOgojcJkBUWRMR6NkTLFu0gXI0RBsA7RVExHCVZKTJYjfBgiBkpsznXoX6BSg0r0sClYwAdoJdlzGcm1FBsi53cjr74V2P/4HpOb15g/XPC1+8eMRGR0MCKfTnn7yZy8XVE2C/ZEwJSKw5uC/Z9IMJ+cEOuAnM0gK0CNQB7Q9iOqew31o5Yn3zyj75cU1zJkoQbJynwgosvQIIoFe/slzcryld97i8f3W+gFMij6DuzaYxJHKmA8nqGVo13PmT85596iIks1T07n1HWDThUi1dRLz+p0xXT/On3d0nQ9btPor6k9tvJ06x5ZKLpMQQh0nUAlGh0NidYIG2iXHedyTUDR+BWP7i3xIWBKzfhQcXjT8fbnHnFtL2c0GeMOrzF99oiDPc9nv/i7g/zvmoaw4Oiop8glxy0UdeDa/h6v+uugvsGhOmccLF9YlwQjEF3kNz//j/jY8x/gpz/0aW6UY/7ne/v0F3+XP3N0g9w29PoGOnkfSh1wRx5iwmNu6j1SNQFyvO/wbsWqXRKsJ0RJax1tb4HALJV0jaCp1xid462nrVtWy47OR9p1S5EU1J1lXQ89PoS1eCrGKsFvCWvf41YVdjpltVhz2rVko4RylDHZK3C5QFrLar6iyCV5YshcRMicddXTdC15IhEY+gC9D+Rq6N4tlOFgmoAURK1p2/9f2MFubGFfpvf5yWf+c37j2iuc3ztBaY9MJdEIaCNrGTg76Vje64hL+PGf+BR/5S/+p3wHIvoeQ8hNJP9KBM37DeDfRu22UbQ4BF+vOt3AJe7fecpvHshxWwgbNg22toWCGxmAkmKwMbyCrKQUIOVgbbgDuBvJ0eZ3t1r7H+5xmU25zJ487RL0vYZgyDqEjQPL8D2xURl9dxcnrTQICPGyuBi24DVs6svklXO4cqabaPn3+vnT771CKsUAxBACkWrkRCBTSSjAakHshxpGqTOe/MN/zB+89jV+5tf+HW586EeIEZr7T3j89/53zMUDVGZIR558T5PesahbI6IdI4t9MDOQEyIFwWvcqkUfPEcMQ8Z2QJeX53zZ/dbR94Gu7XDWoYQkbCx6N0mL4f1CboBl3GUK/CY6sG0eJ4XcybS2jjjeh02Wa3hmblDrUOB/JasTIoQ20ncerRXeBVwfeOP1+5weX/CVf/Y1PvNvvoA0kE9z9g8SyrTntJvzws075NN9+vERewcj6oev8/DuV7EGiqMRwZ3w/pvQSMl67Rj3gv3RTV73h5TqFfblGu9HHLsEpxWrRcdvf/P3eGnvNh8b7/FOkvGtqsR1X+GDxT7G9UhzGyn3SUTJSGQYLJkICJEgUCiRkqjiO9ZxiPHyvt4A/Mv6o63USDx1X0TiriZqO19X11oMA0713g/9o9SVAMuVOgNgk42Iu2TZNijy1Lpl27k87oIZ73W8J3KQlUdMDq8hRI+alORac/F4SfBrggGhwBDZF5rQLRGppK1rQuxBBpxXdAkYqYnekWVj0kTTykDva2LM2b+T0b1b4zuPyEDNJHIROX810L4ZCGsAgcoE6XXD+r4l39OoZrD2CzKiDBihkDZirSdT4NaWs7kjmyVM7owojwoevbagr3uECEgpOPYelGB2mKOzjfWoA6EGSdGyNeQpEAIyAgGaTiJ6OHxmRvA9rrFEDHiDPkg4OMpQjedsCaeVwuLIb0vOziuqeY1dDcx3NkuYTQq8HiMSg6sbrEpJyoI8MdiLmn5Vkx2MsV1H0BnptRn7ScLR+wT96SknJ2dYlSPFoGG+mFc01jK6NiZNhxvbeY8PgVEm+Z3/85/y8OKCUSmYTBOyvZKgJIvVkpvPXKefL8mKkul0j8neHoe3Djk7a6m+/gTRt8QY6ectC7fi4Mc/xnyx5Jnnb7MMnrpq8XS4Zk7sJMm1FPqIj+AQoBWJVjjRsmzWZIkieIkMPVoZGhtI04RmOafrVsToSJOEVCf0ocf3FV5mdF0g+KHp2cHREcIo8kINTUcCyKBYVg06lyihScYFSitiYLi+cU1jAypNqPuO2PWoYJBakucTcIFYt0NRcmJQRUpbe3IlUNog5KCDjcFj55bFawsmn7yDIEDlGfWRw6D4+lcNf/YTKf3er5HKE57x7/IcI2R4gfb4HiqckcuOo6ni6CdHHP3KDPVSQmj24fb7YPJRYnJIjCX9Ouf4G49oFytWj79C3RjMZER2NGH/QBF9w/K84+xhxXkTIZfU64pOKOo+kETJso6gJCbNyPOM6wcjsC1heR9HoF43nJ3OeeeNR7ROYI3CGEFTd7RNhdaaw5sTXNWQGDkUt6cZTias255pmRN0ziiNOO+o+g4dIyOZMM4EBocKAiUzQHP/8ZqvPznl+MKjY2SaBEy9ZP2mZe+5jKWTXNyd8yt/4ad58aMf4+433uH0jRPMDU16s2S876kaR+wlz94yvBAVZryHPu25c2vGc5NA+vg1vvnl3yN9KcOvNK/9L1/h3sfv8dM/2vPRvOC/fvF5fqv6j3nc/BMe9w95xtxhIie8Vr/Jz0+e4dn80ygcfZCs+4q6nSO8o+tbvFdUdUPdNKyqNavVGjcK0HiUDzy6eIj1HmE0Nh0RWsHt981ohaYxE8p9SZl6Tu4+Zi+JGNexDgGpJGaU0SvJq3/4FkJLpIJ6FWnTlP3pmHJSoscJuYso24EPBNvTrgfpQp6D8kNRszeGosi5uX8LJTUP53NcTIi2IrYr/Lp5zw+Nf/4xgI0YYaDbkZduv8QrDwIi7YijjlD0iNpx/62ai1ca/EpQpCXT2R7TyfRf6DO3wWo2Rapi96we9oirwPCqe85VKHpJEi6j4kJdfm/78N9Gwtl9+0rGgMuvr6gQLtP+/xwR7H9px5V5uuxwvJU9XAIYIcVQiMEW7GwAZvCErX3Ut5O1TaQ/biRBWg1NO+OmyHiH36VAxK2cYwBpl5mDy94UUgq01psmlz84khr9FflXiPiVo7tbU748Gv6WLmLPApULhEJz+0MJnfgZzPprrH/zd6lqRyj2ePd/+keY6j5arpnsjyh/ep/kR0aISQZuQpx+CFH86GYODb6DtqpRRcrpH36Jw4/9FFKVVyacXaRZxEjwg31rCEOjTuc8MQ5yt61E67Kb94B9tvPiQxgseGGzpLcSOTHYhsNGZiw257c5h2Fi0FIMYJkIQexkdNaHwZ87QrVqqKuO4+M5Dx4c85M/9Rw3JzmqPqOzc6Y3S3pVcu+tB/zb/96vYPIDvnZ8xvHjB0xu5YyPbnA0bjlbOybTlBcPC64XINMD1Krj5Q/c4XrqeefkLR6u3mT2iRlunfA7f+d3+MyP/CL75R4fTFOeSa7xjv1Zlu4tVmHBHfkMTexYhDXPmiml3AM8HkEiS7QwCL7z/gxhaOx6tcHf1mL3226NLSPdEa5hbbIhFJcN0bZSr+EtcXPtLnckscmKEcNT1yDG7Q7F5YGvrO24eY8U28/4wbVO74kcRN8h05S6F3z1//kSt1444qc+9WP083ssq5raDh0mg+uwveD4ZI1INBhFVIosS2lTz7JZUpQZF5UltB6Vpyx7x/rYMRklrJ9zLO92NPcD4SyS7EP3COLgXIpMBKpU4ASqkKhSk40TomNwGaoFzbkllYLJDUPbBLyNRCGJaGI/NDabHKXYStBXbrATbYG6wadyeK0FKElHpGpg9bjGloa47pExko6HjrR7e5pyouiX4KJB5gXFQUHXR07vNxwdjRkXkqaVLFyNUkMK29oOmUqyVJNlCQ7F8XlHeeOQhMjNa3uEPnL6aHD7GU1LVk8eMcpLypHBaIXSKWnbsOx7PJKAp9wfYWYlZ2/fp8wEuq2Ghk5R4jqHCpL3vXCHi4ua3vb0a0mnNZhB99muG955/DrXrx3wwZspmfGcHJ9gveDi8T3avhuKe/OccmTIssCDu48wmebk0TEXiyU600wmJT6vme4V9CJFp9A7ixMCjabrOs5PL/BtYH82IhmNwPW00VItV5x5S7NcAxJMig9AFFwrc2KicGiaPtB2Q2MnnQ2ZhJNHx2iTbLSvmsn+EfePLxhnI1zdkpcpBugWa7I8Z/9wTPSQSUGmCkxi+NbjC569VbKcN4z0kCr1baANjjxLMOWQNQAIHtoTy8lvn3Hz37qGOiqQAeyXF6xfX2HPA5/61w6RCJZHH+Z2csQz1TnZvGE5/11uhgc4NWF0W/PMr7/M/s/dQuZjUC8j9IdpL85Yv3KXV+6d8szjzA0AACAASURBVNqjR6wfnaLnd6nqE946e4sX9zwffP+E8iiwSALRB9brwOK0ZmkhUSmjYLioew6nCTMtqG8KOhfRWpPqMevTnlHu8Q7aasWyqamiZX8/52JV4b0kuIFop6Uk+oDoKpIk5WCkiVKybnoa31NMMqI2OOtwjcU7j5GGwxv7lKVipBxu1eC947xZcO/eilUdkVVN3cK40OTCcyjgxbVlbyoxB1Oe/8gn+fjLn+DVZctn/+gPiR2ENRTPTTk86KieaFIPd8qU4/eN+eZvzfnYr/4X3L/3D2FiUd193vnf3mT8V3+O9nOvE5Ytf+u/+Ru8/car/O2/8beYEfnV8ha+/Ay5GFyFEIE/M/nTECogpffLISspFLmZ0oca1B59YnD9ioZIS09Uhm9+8x10jESjyfKMJC1IdME0F7x78YTWdeRJTgiaaFKCMexPUo6frJhNM04uGrQQZBoW8yVVY7mxV9I3a2Sa0DY97y6PuXZjjz4YFrXj2iRj3nUcr1Zo47j5wh6PzlasL1YU45T9wz1moxEra5nNCtI2xQWDzAR9J1i66r08Cv6YQyCRlHrKr33ir/M/LP4233zjayzudfgsoDPJ4lEk9EMG8K//+t/kFz/9y1fl/z94xG97vZWvbHXrgUsNrwAf/abweANAYyT6Tcr+KXB6eQJb/fD2YRziICkdMgXy8qM3D+nor54UG1kGl8Buxxh+iPMHYvifAMQGcF5KuOIOnHz3SP2WkW3plNhk+TeSro186NszPGyBUvDs6hs253F1LkMc5M3boaTE6GEPtxunmO//t22i7AH6U4s9teQv5ZApRBgspoOL5GNDORuyEf2161zvS4onnuYffIm+aiirR4Rkj/TlZ5h+5mX0Yb7JCF8DcUhoGtxF4O2HK9aLFh0DRRpZnT7m+Z/6JPNHd5lcu006ukKW4wD0E6Mw6VAb17bD3is3MqMoxKa53CCZvkqIQxiI1I4YcKWfxHb+rqzfoeB1R3l3x/Gb8xBCbBrhbQhEjPSdQ6rL42slaSr47d96jb946xleeO5FZuWMM7emFR0/8/Ff4np5yOcuTnljfkZowNea2fUjbpQrHoeU20nGtCh4LAxvf23Bx//UX+KNt/9vRNHx4Iuv8a0vvcuzv/yvYt58wltP/oD/8r/7r/hrf+nX+Vd+/GcZI/mQmRCSj/IS8TKKT4ToiIM/E5kcI78PRFab7JRzfsCnSm5IK7tgQdjsFQOOHwLZV6d3ZzF6RW7HFcnX5RxfWaZP3Stb0n1J8qQUw06rJNu6FLHpoHxVQvmDxnsiByePT3jzdYFKFO9//yFpJmibc8pJQdQg1zWuDTgpaR10JCRRIEPEB8eisiyPa0aFGeoCdIaLCt/CupNUa4X0hsm1dFhQJ5auizRvBWIFUg/RmnQsKa5pkpkhuqErbegh0RIMNGtH6DyxTGjrSDLJkLmg74ZF3S4dQbeICDIIMq3IZgaVJ2S3C+h7XOtwAZwXdF1HO3e4ZU8fAsIGjNFIpTESnJVoqclzQ0jikEXxFpzAOs9yacEITG7YnyTMl9B2gdF+Rlx0aBEJQtD7SDdfko9Tjq7voZXAhcjsaJ/0xnWkCFjfIdISnZQYmSO8wfuKIs1xY8HFvKbplkQNo1nK+eMV0Ql664ambUhMXpLvDfKRdZwNAGSckE1TZCIQSnF6fEFiNK0Tg2563bCuLas2MNofodCk+SBxUnKoK/EhMK8XRCVACbwIjK/NyNJIqy111WJbi5Zq6NKKQPlAu65oFcgiB5VgO4gkrBo/6Bbj8LAdpSn4OPgfo0jSnDQfCqhsY0lEJClHNJUnOodQkmA0T5YVXktq1xC6QC8CZZJSZIZ1sGRCkuU5iU6JfU/b9gjreOPeu9ze30cIiReCfnN3ZlKgjd7dl75x+NaS34i4RJFKQewjFsfKnXJRnzF+6XkC8NbrNZMViGiwrsPbd3kdz7/+l/8zZr+cop+5js0OiH3BxR8Jzn//Cxw3jrZ9zMXyPqY/59bIc/R+TawdP5IGettRCE+ZJigVWNw/ZXnhhrWtoK8tD9/t6LxifdpjkcymKYeZQhmDMoqqddhmcJbqmopV1bGoHR7IUkNbB7QeCvqCVwOptAHfOI7XPShJ1II0V8ySEXo65vjBY4IQhDho2X3dI60hmQwN6vrGUdWWzgYmeYaQGbF3tBND0QuuJYr9Gzk/+8lnUO/7NH7vg7ylNN965Z/S/rPfggKSD6Q885Ml559fc20meOH6lIOwx4NXV8g7N3jOnPALP9awUMd89q2I+cDz+N+9i56fIF6UuPuW/+Pv/wO+9eZb/LX/9m/ykcPnOe4bZsqhaRDCkmhJSjMA8K6japd43yK8o29aWu9wXYcKLbnRhLwg2pbpfs5yKRGFYTzNSYC2XnB8XiERxCB5ND+ltSCEojCaaTrslW/ePR0kJy5SN5ZV07A3SSlygw85UYBSEm1ShE6oOsu6rejrBXmmSRPofc/x43NsbojTlFbB0rbE9RLqhnVVE4LECRAEJIbiT9St6HsNgRAKLQUCxY899ynO68f0c0vVWJb3O3wlyEcZpcwYj4dmbttg/Pbf7ze2kbdtVG1X88slyP8OcLqN2u1A6vf5C8QAAnbgn0swtZWrbL/Y4mMhuLTY3Grlt/Kib/vvh3lsgc3l66ezI4O05ZJw7fC7kEMWH0GMW8nXJhuzYWVCAvHpZnHBD1FbKTdSlk0BsFIDgI1bQLRBRUqpnb1kCJdg9XvN+65GZHgXwXqEDKgi4hkcpPECLz2Ltxeo/YS9F68TAtz7Us/BqcfHFq/O6ew5F3nGB/7Cr5J9XCOm+wSV4TtNf+7pjp+wrns8Fd3ZPYzsyGcF0/KQvckh/dtfRpYz4v41gusJwSJVghCKm4cTnpw6rPdY5wneD825uASOu6zXMN14FxhkRVeAKdsO4JtI87a2QF7Oz9VI9nBcsbtndpx709xvy9GGa+Z3Uq4YI95FlquWX/zTf5VPfPzjg0yzukuFhfwm7zrHxZtfpD95HaaG6fNTnnvfhAdff8CLN0vu5DegyejbHn3tOjfEko98KHLWvM1inLL/7Evw6iPeP844+bGciz845+/8r3+Xt+7f45f/3L/BLC1ZW0upIsQeKYfrKXGEmJDrGQJ1uX6+y9jWW0gpNnamESUFiE39Roi7LNi2w/puX9jMjffbyH/cSbN2tQZc3ivbpOSl1HF3120CGmEwe/m2XiNxl0EbSPuOiLyHreY9kYPRKGFWDAU9wUZqBPPzBWovQytFked0UiNkYN31xODp+qE42AuPyTU0CevKg/JY5bFikB3M5zXtwiFjpNSKODLQC8Tc4SV4AiqTKCPQpUKmCp0pUi0QUhPcZSRGRdCpRCXQ1x5KiZASpQECRIGrOoQC6SNGS7LSIIykLDOcEqy7iK0tfRdxXqCkQLhBTqTKBJNrTJGQJprmosU3FukHW1RjJEIGylHO2cMWqVtINUrCNDN4GzDBorMEFyRCSIxSCOfQRtE3Fts0XLiIjIYiycm14mLeErUm0RHb9rheEYKnvlijvSUVEqM0BE+iBboYsVr1uKqm7ywuWKJOEBksqhNM25PkhmgMIU/wWmNUZDZOWE+mjEcpwghW647zkzmdjQQhmc5KhJckeUlW5Ggl8d0aZRzZqGC5rmlsy7rpKUpNZz0IMAS0iuAdtqrQSUKpPWmpMbkZHKGioO47fBw2+9QUpFlJDIK2rsmIzKsWYTS56FBaDcCqzCmMIUiJSQTODVGSiMOoQFLmVMsFSmdIDcIITJ4TlaJpa1xQ6M2DQ6aaQoKre6rVmmy2h8kG3WHTeiaF2O16266IUTnkrEONZ4MmuQerYZQ84QPyq6j481R/v+HOg6+y71bsi5rGBd5OE37iM/8u01/5WfrkIa4/ojkrePzqmrtfecCDk4aq/gajmWL/hX1uH+5Rto+4UVwMadoP3iaOM8w0w+SKdrXm0etrrFEsL3ouPFQKrI6kWUrXQ5ppbJAor0gSjTGK1nmWiwbrHcIFMiO4PtWQGs6qGhfA9oG+D1g/PBSFl1QLy2SWovJkaDhFxEhJU1uig6btCRFkIkm1H4rydUqSDk48totE6xHa410g2IBJFKOJZjQ1MMlY15bnb32Crz58lVNxzvLsTermAkrIjgScL4l7hpv7I26WY7pGoSLsT2/z7P4xqVLcvSd59a0WEw08fhc1jgO4SwX1RcUfvfkGv/G1z3P//YG+XXF7qpBujY4dd/YL9jLJ2iese4Ht1rhuSd/1BC+JUmIExGgRWCIerzS6mKB7R1poRrlBRwi9Zd17+tpSTqcE5xAIvPUsVytUruh6j/Me4aHvHZ21SK3J04y0SKmanhghSxOKLCXalvGoxPaBWHdoKTCJQKqUqDRprhCJxLYNtu9wSUuWSarFkiRN6H0gRkckUFXte3kU/DHG8NAcpD0DGPzwzZ/goLjOV+5+kT9468u8O7+HE4F8qvnLP/9XeOm5l99btuC7fZqAIYS5TZ9vi/7EU+/ZEYl4+ZDe/rsDjWLrrMPlQzVGNs/+3YN8V8tw5W3Eywf5JjmxC25vwdr2896r//i/jGNHgjavd8A/XoKbqxO4Lfzegv1dlmVzQaLYkIKrmR8ugXzcarrFZVGz2ETHYaPD3/Q0kJv+CmzWRIiRrd+jlPL7dtz+jj9SB0TmEUk6gL8AIRUU7jGmU9Ad4V61HLx5jwMfSJo5lepor+1z6+c/Tfqx92PlHOXGtOeS6qRjdbxmftHQVm+z98we+Z0bZFkgN5E8DxCOIc/Q0z2EPMdWT+hWC5b3zyhvvcif/tBtfutLFU8uqo2UaDhdKcRgtLGz5N1If3ZFyVfm7co1uypx2V3Dzfu3Zk/behv49vduinC3qbbd4t+8jHGQ/vqAkIIin1KUewRfDM5/fs2yrem7E6r6mF7UmIlkPBWI+hwxm3CrOGKkx6y7gEaxXxxxUMwxfsS7Zy3rJmWKgbMHfOSjv8Qr33yFemRYruecnp5wXlecd56XpvtoEYF0IEZCIAgM7VXVbs6+19g6EW3xwHbutlrC7SxIsektIJ6e2+1a3d4H333BXSGvO5K9kcdd2csubVIHQnBVand56Pid1/b7jPdEDoxSyDikXw5vHLKwgccPLzDJHpNxiU5TXOzpXEsqHGWe0PaWrg8Esak1CA4fYd14Oiw+Dgy3WfeEbrNgvUA6SSIUWSpxY4doQGmJ1gKdKXSmEUKhEoWMQ7GL94P0TypBng/qsL4PWOkRchM9ioJgA2pjR2WMGAqSY0AEiQyCJE3JRxofWrzrh0JeCSaTJLlB5QazKUaVSpMkGw27HNJ5WkmyRA7MMUJV9cTOk6aSMhFMcoNf9uh+YJUy0YOtphH03tKte5anIORABIxXdClUXUT4iNaDdETqTTRXQNe2GCVItUIKRWIgyoDKEnAWtWWc0iC0orMV0QuqykGWYZREaEGhJIkUHB1NmI0SINA6xzoKEIq2qSkaRVKOScuUfDxilGREV2DjApkYZNOgbEQIP/xOVOjeIUMYbPyURESBFpE0laSZQko/NP4QCmQcXJDShNQIkiTFu4DE09QrQmIoRzP64BEuMpgFCawHpQ1ppobMz+C1hgg9aZITCsV4mhOR9AQsA/cO3rKqB2/+VMmh8FhJ0mioqh5d97RWIINER03cL3cRL+8Ctrf40BFHAZ8IEAEfQLieiViTqnPia3Oq33yHG8vPUoQneO2w125w9LM/w7O/+Au4gyn93LJ8o6W5e5fu7Uf4sM+tjxwg0zuM90bsPTtlsicwy2uMw7vY+gE2KLLbd8BEFo8f8K2vn/KF19ZM9xLmy55GCFyqEPkgOVNCUiiJaz0uCnoR6PuKlfco71FaoaTCGElqBjJYRo1wgnPXYZ2j7YfNRQWJ6wOlUBst+Qb0KYXtPX3radcelWp0NmwxWTJksTyRdRPoukASAqlzVI1jvejRmcAUmphplh7ePalZPXqHu4v7HB/XXNy/i8UjC0VSKJo6kqQJeaLIlcSLgipMmSjD8/tj7sY97p4/5vjNM5QHoyyBiG2BIIkx4FtL163pcTxpKqajEhNAB+icoA+G1rUIF6gujlks57QuYkxOnuckWgwdV8WwB7V9oLeQZwnjzJBpjXCDS4XvPLZ3NHWD790Akp3Hdi0rK4lSDT7jfcRaBzFQmJQYwAlBlAIRI0ZDmgg6JxnnCWHk6LRC64BKI1IpTCppvd3IDoZMZi1aXFA4N9SR5JtIU5CCJlXfffP/ExyCQeIgYkQKyUF5g738kFSWTM0hDw8eDhbUScrPffLPcm3/+lNg/o/94bB5el+CJbFBRd/+qLwE/VtQs/31S0C6BbKDi43Y/fwKHtpYdF6C3EtCIL4zIhl/eDMHW0y0pUeXZOoyk3A12wKXkeYtaNlZPG6R6tX532Rbhq+H19uGTpfkQ1wyPjZE4Yok7Gp2KDJkgNRGCvLtI4SA90NUOALRhyFqLgMYiGoAZDGCcI48VphWEu/XuM9fsHfxRdK4wqIRz99h9ImXmXziw/giI9SO6kFNOD3B1x7khPHNnFHcY3r9kPwgHYJ80aLCElcfE5RAZuDtCdX5CWf3Tnn0zikfufECN2clR9OSVd0PBiRcMRe4nMZdJmTHiDfTdSnhejrzFrcX9inguZnbOFi6hnD5vUu2fTnflwXp8UrkfIiSy7i9ZBKpUqSeMK9OmPcXNPMVXVcRtSBTGXmSUPeRMhuRKU0iDJGUDs1Eag6LjAf9jMfHb9NcNJTSkWaSi+UTaCUmSXDrnmpd0dmGvXRCJvVT9/jl2nyv9+GA89j8nVLJHTm6usZ38roQd8B9MyNP7Rfbtf3UKVzJ7GyneMcyLpMLuwxOvDLPQzzmaaOFq5/0g8Z7Ige9s7jgSTPDwY0DxKrn9cdPmNVjstKgpKbzjs5LRnlBqsIA2KRH4IlO4DYNpeqmx+EQImzSWAqFJHaRrnH060hsBUYoTAJiNoBzLeXQxEQN3ah8VAgrwQ+FOANDlqQp+FYg4xCN9JsU1pBLiyRKIWXAJBqhhuJU6QNWBZI8IStTQA2FTVVH3wWyaUJSGFRi0Eoh/NAMJCsMKE1UirhZ6VoK1k2H1JK+s/jO46wklppJoohtwLY9wQbSrGA0LhllgsqdDwWhy44sA68EVRuxpQCT0NmOkTOoRGGMIc8TjMu4f3aGShRlmg4WijEwX65Aa0yREnJDmRqUSjA6J8sSumbN6fGcZDJiRCDXJSpNiNEynmSUqWJROVoHMS8QUdBcnLFaR/b2JuRlQjFKmWU5UqScrTvqrif4wds+MYogFD2S0FmUt2ilMdqQaIOWEiNBmQihJVoFWqGNQWZu06NAYH2PdxYhHFW7pszHjHLFvPE4IlFEXNfSucA4yTGpRtiWYB0xKILtSQSMJjlpaWg7T9dZVm1FMDmZkqz6Cis8JYYUSaoCOjNUbcf5uibYGuUlB2WBkAfAoGG1vaNrWzrXIssEJyFEh4sCZTuy4EidJHzuHt0rXyXpP4+loj+4RfnJT/Mj/8G/j54mLB7N8Y3n4R++jrv3R8zSnps/9jwf/anrlLc+gNA9oT3Ft0vs3k3cRYOzD2m9xHeK6smaN77ymP/3s/d55UHLjbWn954sV5Rakmw6SY8yzVhLun6oD3K9Z7GqWAGlyCjLfFMnJIjCUzcOXBwcu0Lc+FsHbBdJTIIxCicU0Q4bo0kTgkkJXU/wEJFDd005gPAsNyxbS9dH1rUn9AGjBpce21ia1nEwMSgt6b2gahxV6/jKl/8x+dGI4wcPWZyeEiSYA4MeJVSV5sAklAbSJKNtn+V8Efngi3vc2XuJ3z9+zP3jFd3jJySHBSYRdK2FZFNM7iKiC1zr4EePDlj7liIdk8sCFXo8iiZIgq9JY0e/WjA/X1AHzbgUaKlxQmHjoLkNPmJbR2wt49GUUkmCB9s4usrSt5YQYH6+BBV3GUwdoW48plD0vYcwABctFIlURKAPA3EOzuKDAxwiTYnBM0oFaIPQA2HWUpCmgrq1G/CU4INnte6JvSTLSzLnKQtNlmvQgq7u38uj4I85NrBOiMEacAOcnz/6ALdmz9J1HUoqkiQhMxlK6SuA+r0D513QehPm3D1Pdz/cgJbvEjx7ylaQK4AhXkawL2sY4kAKwwBUA1vnnK0Yhl3zox0I2rjEsAFpu6j31SjrD+kIW1kFl1FocUU+dQlUr0wql+/fyrJEHPbYnVxr8+6rAHVbaBxCuLR0ZEtSNlHZzbUOmyZrTwGvjV5cqUuLyqvrw4eIc54kGUiz9wHnLJEAm15HEIhRIK1DhohaOuI3L/CvPED3X8UbR7jxDOWf+hTjn/4wIhF0y47Ye+Zv3SNpHqMnYybPHHF4q0SPDkB4op0TgyB4QWg9QoINa+L6IdXZMY/eecy775xzsYL391C3njJLGBUprXVDEy0Rd8Byu163xcrbubyUUw1rb8izPU3ursDS4R4KV74jhkDoJUDdzP9VQBsurzRc2nryHaB8uIYXqzOO3SPsssH2LSo15OmIJC2p2oQbuiRVESNLnN9n3Ujef33ELL/OF44fcH58Smg6ylGOCRlf+vrnCRmIKOkay3K+pF4u+NiNF2mCJVdmqBf6Fw1CXCGiSkqcc1dI73DMsNE2Xma7YGjKOBCFuOWvGyJ7hU9sPuKyIH5nc7DdpMRwgB0BvJIVIl5ez+E4GxIjxHv6c98TOWhVx+Rmzt5ozGvf+iPKBA7v7ON6qCtHEI6L+YKDSUojCtaL+RDRj5IoBV3v8D4MXtZI8jwhyeVgo0dPlQRE1cFKEBYR14ShQdXcIxVoIYabtANfBcxUwUa2ZBs/tPbWAplJotEoA3SQpGYjiXCodNg0+pUlzwWhi3gzZATsyuHd0DsgxoiMniJR4A3SRkI2WFgaP3QFdNahsoxOKFSQmEKiJUQXWCxbOqfpvcAogQyCzgralUepnkQJmi5gsoSDvYL9owkiyZG24axLKJxH2EDftXRC41XK7GjKkycN0QaycYLJNL3r6IOgcZFimjPONaMyo/fw8PEKmee0TYvKUg6uT5jNZqTphGtZwiuP7nGxWrGXDV3/xmboAmg9tI2jtprTxjLvNsXcwiML0JOUbJSQFwmJBu+WaNchQ0RLQ5IInB10owXQND2hbQeSmA1zhIwUI4NwnqyI+M7juwrXOrRMSScFy9UC7yK+t3jXI4JndDjFBklTrVAodJYOm2bXUbcW1QdigEQrZOLoradBIcqCiOP47JjEJGidsWgXKClYe1Ayw+KHJlIoQgRLj8kE0TpEgOCg6yHLFRFPiGKIpMeWzniKfEqiJWFZEfsUJyK9iMh5S//7byDcMXORovNDbv3cn+fmZ34JfVAQlwvOXrng7I3fwNYPaK6/zPGP/gI373Rk+3uQ3gD7JcTJ7xIff4u2Lji59y3GL1wnu3mNJ9/4Gl/87D1+53PnvNFHbiaKdReRRpGmmnGmSBKFmRSMtSDVmj0psEDjI4IUv+7om54sNaTSIIWgayMX68Di8ZrGe+o+4KQgSlg3gcNSUaQJ40mB7z0kmvRwhtdj+jCnPBiRtT1da/FVR54r5muLiB2UKVpAUBIfAseLoWP19DDlaF+TKElQQ0+MxZOKs1ffRN1KSG4W6EbhV57kgyn6Vob7J2tu/rnbfPTGHrPsQ3yu+TD1N/57/vx/8j+SzSZ84w/+Hu+++RCdBLKs4eyNHpxj9FJKsAF3FmgvKl75v36f/+hX/kNO9hqC7XFRApKz9QVnvWAmIkJo9g5vEc2Exbon1RrrAss+0vYB17dE1zFKBUqlqCylalrataNZrGjPl9ig8M7RVI6yGNyiYoxUPfjQY3oBSlDORuSpAR9ZVw6TQ6o0SZ6wWDhcv7EgiJaHpw23JwmEgBIpeZ6SaYlMFHv6/+PuvWNty+77vs9qu5x6+2vzphfOcNhEDkddlESIcmwqVkBJBmLDTmIDhgDnjwBBEAT+LwUJgiCxnMSI7CCBoQQOLCZxYoiyJFJdLGLn9D6v33b6Lqvmj33OvXeoOJoEdkRyAe8B55y9z75n7bJ+5VsUjW1IWlDZhuViAb5hsdQkp7CNZVgktIrMT6qz5/1iMWc2m33bKpDO/j9f1v/5remzgO7sHfEnPj1rca+DaoVGJIFvAyu7YlNdf0cc/6d0w7U2jIajC9XS8/b7O7vzF0ygLsYGSXSBqVwHgBeqovJCxtAt2Btlkc2MdInBGahCiDXuGAQSrdVZ1NUZI3UL/yY5EEIwnU7fMV3iwp+weUNc3ODirF7cUGyqiecJyLdvs6nIn73/jsD9/12u0tQN49HovHp6IWDcYK435/JiQnA2FxfPQzqvuJ51DTaR+1mXR5wZdW2C2LT5HSmhtDoLjsMFEyqlNVqrM7iRUpLxeMxyuez2j2n93ZIsM2edhhgjLliQoFXWceJaTwqamAEhEu7UcPsU3IJK9cm3L7H9yY9TfvB6J3natNR3KlZ3/5jUnjC78iHUpauMxwlZ5CAHEN6A2VeI1uOsxDYT9KiHGoyZvf5lXvzD27z61ozTkLgy3uaLv/5POG2gcoKi6LGnC6rWU9fthTled0IueBIgBEqJs6QM0nkiuz5PGwlUJc87Y3Gt3CSVQml57nkgNufy/BibrsE7hbjOITVSQNM0zOZzIOF8yygNeO7ey+we3I+91RL7ieJyD90vSS+veOjZR3lwIJml97BqGuLd53nmY38VjOFLzz3P6WLK5a0xRa756rduEJolBz9xifkdS3CW6e1j3v7mq3zgkac5air2ydBCnt0rZ/fCuxhKKra3t86eIxvuwcVuQFrPvaB7rpw9F85Og/i2m3ydqF3QN34nTKhLejf8jYudiovPM87P5Dse1WqtILZa1VR/CpT0XSUHW2UPleD4dMJ0MmN8dYuetRzNlxwdrygHffrDnG+9dItRP2d3e4DydH1BhwAAIABJREFUDqlBG4OREekSHsHWoAQVEUlQCEnScCwahMlRpUA3AikCpq+g9GSlwVhPO/XYVURow2C7026f36vwdVhX9jUI1SnIzANqUKAHGtUGZOqCkeQFrvK0ToAT5NKg+pp53SJZIW1OUWQoo4lJ4lvJ6njJaM8QvGS5cAipKPt5l5mHRPKWosgpSoMwhsYL6qZlcTwn2cjl+7YY9zSLecVrtxt2SsPlB/bRZUHZNwgcqg5M2sjjD2xhG8X03oLl4YymrtkJmpVQhFXDZFXjmwUm07gAS2sRvuLk9oq6LHC7Y7b2tvnw9z9N02refPFbxF5OS0bNkK3eLvXbb3A46/P+77+CrRzJC44Ol5z6Yx7cge/72Cf4/WM4nr6G0JY8yzg9mZBCRMlIW61AZ0QpkH3NWy+/Qr5zheViQiBSjAYMdoYIZdleNFBkSKMxSmJUZ3oS2ppAoprOuTwekRc5jRXMsSxJCCNxzrKyDclZRplke3uHybTGKY0KltQ4vNB4YcjzRGMbPIF8MEKSiKua2DhsbUlFoJovWLQOpQ3loM9w9xJWGJL1GJUoskQuIk2deOP4tPOrWDre+voh1WnL4++5wg/88JO0zhI8LCuLjQKhDHbqKUYR0dNw1LJ67g2q1xZ4/Sjan/CF5o+ozZhn/u2/zs4PfAC2+9hF4Na35vze1/4b9pPm6b/wV9n68LMwLrneN7xw2NL+syX3j0tKJ4mnR6jpiksfuo+qaXj+f/89/vC357zylqfykkdKw/b2mF5vyO71IcZYbKxpVeDaOCMvDS6UqH6OqBqa0wUhwGJaY5yiLDLksMQnwdGq4e3XTxFasr3fozmxuNaTSPTKThovLxRGSPKtgmQkKXjcoiFMZ7RtRTWtKIxiMCgwwnSJe0o0jUeFQFt75gtLmSWsTez0Iv0CovPIfIC4epUXv/wF2kJCHug/uIs9EIg7C5pXWuJrlvHlkk89+RjvvfIRvvByyec+9woPXP0oz1yJnPjfYX77Tep7S/JkGSjDpA9hLhDeI4koBa5uee3FFxlIw31mi0U8IdGZME4XSw7GW9RYposFQ6PYHe/SLx2T40Nu375Lf1ASRIvRgiQU3vRYEYizQ7wVxLqBqkYG13VNk0JmBZPTGVXTkmUGESL9Qcb8aEq5s0UxGpDnHRRT0jJdWURpILVsb4+QIXA6WXE4qbl8dczARFSvJGYFQRmmLtAetSgZMIA3AesDIcruXtQJTM7St+i2pcgS9sIK/sM/8gNr7fTzNWCjcR5DFziLtbb6eQD5TujBRv1Ea8mZMdk6+IsXKmGkDjYqVOcRAEDsOlvruBqxPu7Z37FZVL9tpJT4R//z/8Kv/MNfeTfL2nfc+KVf+jtcu3YV4B3B9BkcRKwD4m6Lbs2/MA/hgpPdRsOfGNeQ2wsOwevIWwqQWhMB71xXVbxwHWyUbYRSZ8fdaNpvkprNeOYjz3DjrRv/0ubmX9ZIJFarFT/7l34BYmJ2vOTRxx7np//cJ/i5n/sZou/mvqpt58PgIz4ler0CoSFMWhZfukG4Kyhin7yd8PbJc/jhAff/B38RdXULjKStAvM7c15/9TfoJ8VDH/sZ5M42JtPkUnBcBcIbju2BRjQVLN/oIM17BzTtIXf+8Dd4/rNHHJ14gszYGwxRIWdx5xZ/+5f+p67rLhVi3QnZ4Nm/08cnPvExnn/pBbLCUA4kP/Sp98NewbZMnOYNVVOzfGPOSin2d7b4wGjMKH+Mz79S8/KthuuDBxmwZFHd5Mabb3L82tvU24n+jmIWKlzV0ptJQqhAOI6P7/LCc9/gZz75r9JMl/zCL/4is+mUtmlo6hrbtDhruwKwkutuyzkJewMFSjHyH/9H/wlvvvH2n/EM/n8bn/70p/nUpz71/7jNu0oO7t2YsrffY7DVoxj0mb9+yAPvf4g2eLyBvAdZprl8aYf6cIpnBXkkJkmSiViUqH7Ena64s7Bs7+aMRoYYY2eUtvL4hSMvJNmVHs0qMD+q8V5i5hEfOxiQySUhCeYnDb2RwfRyZLIQBVhJ3tM0s7ZjbfuI9oDRxFJQzxwiCspS4z3Y2jE76kiWelhCG5BFjijzTmmFgCxqskIhyxF+WaNFR6Rp5i1NEoz2cpoU6QvJyVGLbS27l0uu7/eYxMRqsmR5d4LoFexuDVhu52RDQ+/yHt5FGh9YTByr2uMnEXe8ZNDrE5qIkpo8UySpOD09RegSaAlSEo2hSYHGg5WGXpZBaFkdHeOrGnUlQ7QeozJ6xnSLyWzJ8cxyejxHD4Y89r73s7p5G12vMCKwag11PuQbN0/g3g0uIWhTYjGZooRklZfETJIVkl5PYzLBKjSE8Qhbn9IvC5be0tQ16hS2d7e57/I2JEskEYLH2+4BW2yNOJwc45JkWgdy2eJcYNZYqiAoe4YQQWUGISK1dyysJd/uE13d+RYoTYf8siQU+CXLpsXZhnK4RTbeZeJOie2KnXKP0bXHmJ0c01YL+plhoCU2RuaFoc1y5t4xW81Z2Jbx1pj7hj1+4+tv8Pt/8CKmV/D4J5/FJUFMHruoQCkqWlq74IHeiKD6+CDxrsKmI1bihFYqVu0JobjMs3/zZymefpgqCZo7cyanp3z1N/97nnj2Izz98Z+lGOySmoS80xIe1Dw81hx+dMx/+/cv8YGtZ/jxKxVi8euE228jh46vfH7BrbueZUy0Gva3DB//+AdYbO8wv3cTu7AYpzBJM7lbc+2+DJUHbFt1etXFABscuzsB2StokuLu1OJEYtVCVmhmTeDeK1NChF6p6ReamOBw6kBbbk8XXL66w3grw7WWmy+9QYgRTUuhTacQ5iP1siYXgnwgkdYhAVNokup0+O+/klPFyMt3bReEzCYsXj5les+insh54mee5ea9O0xfOsY9v0KWgvL+jE994jLjvZ/gD+zD/M6rb6K+dsi/+fM/SBJjSvU++maLQkvsNHHj6zVCC4rLAvem6+AABaQmUDUVd1cTYpS0QRHxaGW4NLpEhmeAZG/nOsv5IXVVdXyp2JDnmtHAcLKyVJ4z8626WSF8jW0qlscV/Txn61IftZSsFi3zWctoZLBtDd4z3B5zerpAZD1OFxYnWkY7OXmvpEBiosMtZhQmEqIFYxhe3eHKgzm3Xn6DO7FgeDUjJs9qaVmuGtrpHEkkZYZ83FVLDYbqtKK8PODo5i3yrT7FpW1MT6GWt8+e986HtRGSOIN5wJqLfwGffUbE7V50b27gIet92bTs11XcuIF5xITSHU43xEha88bYqMxwUQXoQrX7zIX3QrD7PTi6+D0B8gwq01Xkxdm8wxqoJToPAAEX1JJYr69d1XFTtYQL0KmN7GoIaKXOmzIXgv5EJ+zYAcI27q/dnG803b/bVZa0NvzUT/0k06bglZcaPvgjT/PUjzzdJacpEZzD+haXHPm6wOU385kcSS1JJmBjwiYL+wc8+DefJe0NsC7hqpbF8SGHr36Dy4++h2vv/T6EMNBGVAyInma7lMyvKv7G3/oH/Lt/7Rme2G4R9UuwrDCm5Y0v3qNaWWoEqoD+fo+rjz9Olfd444U/4v7Hvo+iP0J02Kw/6yl918OHhHOWS9f6PP3sdVqdeOJ9P8DNcJf52/doTmfkA8P2lRGfeOIaQTzF16ohL33jmxSTFT/8I0+CKJDxMv0gqbRgcq/m3m2HS4HxfRnNG0t0rsh6ibBqmFUzlrbh5ts3SEmwtb1DvVwSnccLizHmgirT+u7bQIBSWjttcwbR+l4d7yo5OLWRI+swWnFw/XEOHlS8cft5YkoMRzuYfkFjW4yO7Fwdc+/eDBkiwkiwHrGqCQJGo5Jq4VhNG3CB0W6JTxojFMnajvSDIPmOsKZbj8olSii87SRNi16HkQ0Whld6hLrsMFcANpKaBDIilCLUAVMYisxQu7aT+Ipd61DlCpSkWXp6mSM6SUyeetJitMIUiugiQmtSVJ2Ndr4honUP26b2iJRoW09eKrKsxNVgtgvG24LYOpoocVIxJzEYaPa3R9hlReM6WBQ+kCnB9v4Ok9tTqqoiCUneKzGx01u3TaIIK6I0nTxqCzrLUHS8Al9XDHoFEkkTDMxqfL1iMBqQYqRtGggNRikGmUCkwNtv3SZrLcoJcl0w2N9msHvAYjmhVBlLl6itw0WNKTNyO6VpHdVqATqhTcvWsMcqKzg+XmCEJygoyhwjFcY7TOratnVISJWDUTSxQaAYjPapZicoo1DaYDJN0R8wWVYInZGkJAUINhCDRPRzlA8MyhwVBcF7bAhEqbApkKsMZWuqumJeVbS6YLrw7GQFZVtR5Dmm7BQRzKBHkIrj2ZxYDhFa4YTCKmiVIVYT2Bujr1/Gl5LJ8REvvnIX98xTrHykns/o9Udk5HgfmaeM/kiglwF/csiiPuFQNHixRUyKRz75w5QfvsLc1VAvWcwnfPXz32Tw1Ad5/KM/SrQlJ9MKERryOnDjc9DbzdjOE3/5k7uMt56l13+I8IGnmH7zP+R//C9rvva6424luLRd8MyjO2w98jAvHifeOrrN/VsWQcLWEZRioOHe0ZwrDx3gFy3LVWDpukrjoNfHxYaq6ubQi8Sy9nipSLHjbKhMUhiFQtC4QJ5nmMEQJTNambNsQNq4Jid3muJBdmpSuZbowlAazb3pEi01wTlc6/DWg054JUg6Y3vfEJqW2XHL5K7FKdh775g6Tyxfm2DvLRBZAi946IGcB3cfJep9nv/1bzJ/4S5/7i8+w0c//v1oPeoWnaUm1l08qzLV4YWtwPQ7aeToBE5EnHc8f/uP+cC1D2Nb0RUjaElhiW8tbZHj8SRdgK1oZifcPTqisp7GNpSDMcuqYdFUCCXJUmBxdEo5HHSVwdxQ6Jylt7SrTrYzl5peWSClZLGoO9W3gcDNa4K1SB8o6IIx2zaE4GlmNawLJUPXY7S3w+61A2armsVpTe3m+NRBFo+Op2xf3iFFWM5bdCYptCHPc+yqYncnow2W0C5ppcE250F2igmkQEiFVmvMtW0791fVubNuFk4pOudUuW5Xxwtt7ouBo1QdKCekSAq+C3SjIGwgCWdwknTmRSAEZ0ZaG/lQtdk0cpZE/GlQo++ece63sIn/L1YtYS2fyLcF5WuQs1SqC+LTeXU/xfOOjlgnA+eV5Q304AKqQZ4nH5vPNglYSuemTGqTJG7O2buEYnznDYHWih/88R/ln/zWl1n5lnuziqN5w+OXwceIqxuKIscvAzaAygRZKSAk/GJOHVa0UpDIkXnO7ievou8fsqobdJGYHJ4wOZxQXn+Q/QcfIrSSVjhMcMSVxB5CVkoKJfjb/96/xX3XhmRmTlgdUN36NF/8zDFv3my5uzI8/PAe21cOcPker99dMVFz9i9v89JXfoNrj3yIg+uPf1dRV7QW7O6W7F4aIAcF+49cwpeK2Ys3umq/TGRJ8PDegF66wsnE8ruf+yzLwymPXtpHZBIlc0LwLO9ZwiqipUAVmkKJjmM1VkQlqDOBXwXqdsnJ6jbvffxhrl+/j9u3bmLbBu/c+fWtNaREDPYd3bJOLleuDfu+W6/5dzfeVXJw/YEtLl3bIYqcxXKFcy2R2LUxg8O3NYv5iq1MojND4zwiRLzt+Ch5JhBGIsxabjJ0GsW29VStQ2vF1naPug3UtSf5jtQahCc0gRRF1x2QGwxppwMuAGE00XXY9dQEEBJJ7DwWbEBIidRq7dYX1qYpkeAEIgaiErTTBt0vu0ZtjLgmENwaIyYSrq6RISCyzplxo7ahco0IAu8TQia06kxG5scrMp0YjEeUvYgNCS8l41ywOyw4ntUkG4muU9VRQtFWNUaBNh2Rk5SIPmJdpJdl+NWCfDwgyO54KTpkiGgjEJnC+kCHgg242ZzVfEGeFR2vQ0ikSggRcU1NHQRitiKaAnyisonWeOIgEmzAeXA+AR0G3PqAlJJhryQlaFY1KnlMU7OceWyQSBkQMZCUwNmMppU0TReohCRxPuBDRJmM2vq126LGaEXZy5BAs2ophCMmgY8NkdDNR65JMZ51IDJTYF3C+oApSpxzWO9BG5yrWS4WzEODI8eJROUaZKZJRQbkOG1ohMApwcoFRA4IySIplo1gFCwzUyKuD2CUUR87ZqpEy0SFR+QZtY+s6kTTQJYtGWcDkr+FdW/wyuqQUxt4Yjwme0RTPnMFmwna6Dg9njA9PmVrb58HPvwkeT/jjTsLjBZsjw3l/hA5zOj1JZ/+5W/w0//aNbb2x6iipAoLfvUfL/nKix4lM67uD9i5vA17B0zjAW9Op6xEjRt2HYOYAiSBLg1SOeqqpa0dvo0QBKUA33q0gTwDpRJ+XSxxAbSE2oUu6FAaREeyjyqBi0QtaWpHrEG0Fl9FTCbRRUGUEo8kCE2uNCrXFP0evlp1jqM+IVJnYBeUxIVI9InF1DM5ttS1J99VPPSDT3AsK9q3lrg7nfqOQXClyCj6H+V2LahOjrmeWX70A1fRmeHw+IS32ttoaRnkitoLRIoEI3BNwmzJztgnArLrBv3RFz7HU3/+IVIMxOAQKlJkGVXTsFxVCOnIJIAkKY02GTpqmqZBi4bQtNiqwSfJ9o6BQZ+oS7b2BvSMOoOGJEBqhSkLkuh4WLX1HbytzFEIRPD4pqGRiaauqCtLTLErksSIaz1i2ZDJOcJIqjbig+sw0SKQQsT0C0wvRynBYlnjlhZdarb2t4htjTYerTtC+LJ1nE7OOQdSyTXZsAv2z3DeqZOD3gT/5xCXc7zrOab5HMLeVVjT2oiJM/Ium/fhHGdOOhc9Sd05EqIzw9pg59M/LyD9Hlmru2D9AoH2DKsP60k4536k8yB+s/0ZhvwCrvkiaXf96TrJimednbPv51wB6MxTYA1H+naJ183f+93aPdh0ocr9Szzwke/juRd+ixWRRmoEa6dlJWmtp2o8KiVyI1E6J9kpIZzw5mTOMIzZ2e9hdg3miTFeJoKMzE4WNG2gv7PF+L5ddKY5nrbkGWSlIhsYdFRImfj8r93ih/6VKxRjA6LH7O6Ir//GLV57qcWYLa4+cED/8gGMD/Cxz2w2QxYR77rnR/C+uy/ExWvnO3uUvYz9KyMuXR/T3+tx5b6HWRUty9dPaNsWosAYxY4oyfLHmDugmvPU/bsMM82vfebXATiaHvPyl7+FMZ7Rlqa/ZRA9RVNFin1N03YYxaSg9hUvvvlNfuypj/HBj36I5ndXtHWFsxbbtljrzxhWZzCiCzyas27Cn8WE/f843h3nYKukV+ZMJ4HWTWhPTtk7yAipI5QEa6kWLVvjkmVo8XQKQS51KkJCiC7oDBFTqDWZTlA3juW8QSnDcEsQpo666lYJk0ksrpP2c50DoJZ0SisNREfneigi3kVCE6CJKC07g77QKQ4gAjqBKRTe+vM2rItEDyoXhKZbTEkdDtmHiLOxo5alSGpbRNYFOMpoFJ0qjygUqRVdS9x3F5/SEl97hAEz7GEKgWgjuEDfdIoAvg0k16nBrFdg6qoiFxItYievhiAISUqCXGWsfEvZy0BpXAh4H9ZGLgnTK7HLBh8TUiVSsPi6plnUFIO8U1hKiegd0VlWTSBrA16kTk3FelaTJa06YWwiKxtoPaSkEFESmoZev8egyHExEGKkWTmmtcO3gl5ZkmmQriHTqiMFS0HtAqJI2NBJOAIYUxCJtNaSqwwhQSmBEYIgPRkWFx0hWbSUnc29UojYkdOddxRk+BixIdKXIBXUtsUL0anHxO58ZKXCOUebMnAenWuUNjipcEKjewN87XEp4nzgZLliNm2oCsl2SLTjIbFU2GBZtA4pPItoKYucauqZLz3BRfaGLUq1tPE2L81mvNIIZL9H79EB48ck8oGSNjkO2wV3JwtEK3nkifvZvrTP7cmKZSo5MJpellP0eowuS770xzdZLY5JXEIoBTRUyzf53z5nUUmws5Oxf+2A8uo1Ftk2xzcty6gopaGee2KT6BTtEkkbhIzUlaNtEjEIMiEpjWRma7Qx6EziZXefppCwLmGEJMs1SEmIm4CkAxi4uiUVhkiiDYlQd5WAQZkhc8Fs1VK7iPAJHQDr0VJTt51XShcbiq7yo1VnxNZGZjPPso6onuDKB0YcPHiFG1/8Ou2NFWESUKUkM4JesYUu3svkZMZWLrnvyjZXxj1uHh9xspzxwr0X8aklyzTVDJKPJC0h0rmm+4SICakhishrrz1H1dzF+YzGd5yofm4QQlLXFTFV9LMMowS6GNAbOlA1MUastbi2JTZ2fb/m9A72uTtt0b0eiUSzqkBIjFEon0AqGue7DopPeOtISqKEhBCoVyuCaxCxkzxVWYbUElFVeOeo2kCcLdEGFiuIWmByyAuBUonRzqDDqGtFv5eTvCTLJGW/R5KBGB1ZJnExUbcB5847B/JCYBiJZxX6DbkONvAeuX6dNsXr85EuyBWu9+2ENdJasWcNC7q44xl59hyy9A798PVxO632NfnubNcLB/ouHpvfT+TMpflsPjY/+Cw456xr0NW1Nso9F+bmLCcQ7zjGxTnnQhdik3gJdWH7s7ldJ4XfrjTzXQIt+hOXxibxASoEe48/hih/h1XwLH0gEbFEtNFU05rWJgqTkDoiZcDHOXeWLYdeU2zl5A/l5Fc17GhcDExdzXJh6WUZW3tD8kGfWeVwwjBQCqU0WaHwRN5+e45r67VbtySlJadHx3zpDxcYFKP7Ruw/9BCMD6h9TlV7RFaSS8Fq3jAux0jRmbx1cLHNr/3OPS8pJbZ2+5jRkP1rI7avbbO1tc/hyUtUd1dEnSiMocg1MoxI7LOqZvjFFD3qMZlN+exnP8e9w0OOT45xtmYwKhFxRF4MMT0FMdFWAdbFLpGDp+XO8ZtYt2DvYKeTp9edCqTSmmRt1w09UwSSkMJa8er8fvjOndl/MeNdJQeTSUN5b061ClDm2CawtJFe0RkVtc4TkyKSMZvMkb2ctrKdpJYEGwJt5ZnMK/qjnKKU5CJhY6RdeAZbRaeJbjr5UykEMhPE2KINuNZjTKe84oVguQrIKEElXNsSooAAItI9VJXEu7VBhQgoJTH9jLZ2HfteK+LaQVDKdaVs7SooAKFSR9YSYCPoBLrUFKMck2sUiVwm6gQyJZIDnQQySBKSMpd4BM4FpNSQZAfPSILJaUu98pA8MXRSrlIBAXx0CNsi8gKhDQpBmSmkNGSDHTQabXJKqQkh0CxbUFD0+zSxwrWOJCWlUdDWpKrG5AlpNM4nbGM7zsXKEhpPoGOrh5RomgYxmVCMS5ra49BdEhUi0keu7uyhddst+GhESDTW0ctz+sOSZAZIu6CXK0ajISaTzNuGUiisrYkhoqVGJkGZFzjr0ConpoT3jtwYRqUmNIngqs5vIFdoLdduu4lShM5qKlkCHQTNhRahIj40tA6cMIi8oJ9JslLTrirCeMy0tvSkYZCVCJOjsx7j/jZWnCJkYrWqOJ3OWMwsR5WnmE6YDUucVjRty9Hbr7OKH+LIe/aEYblqqZYOnSXy7USULSduwWdeK1mkSzzyuMB/FOxuIhsIjueWl05OEUnywJVdtq73mC5aXr0LTz4+4vJY04sCO7NMbOJ/+Idf5D//G0+y9dAAqRPt6jXuvvGPeLmRfNgIQm+Av3KNsHsf7TQxu/0mw0euUNrE6viYlCyl7DplVR3QItAjp207XxCddYHoYGhImSFpSeM7bxLn6DgfSbG9ranqiLedT0lRCDTQtpayZ8mU7IJbHyh7GVvbJU0I+GlFcBGhO0ffxaJFJs1y7pEyERB4JH6tMBVsoq47sl82kPQvZ3zgp69jm4Z7v3mb+k5N8qA89HKFOXiUUu9gjm7z8M42V/ojZq3n5dO3uHN0zIsvPM981RKFxjuB84ksS8hCUM/SWvZTQAaChLcr5s1tbBx1kD+nKUSfgCQEcLYhQ2DKHJ33yXsgZAINs0VNMw/4pqVUghQ9490tbk1uU7nOIyHUFqE0Umq8D/hli21bgnNnwZ+1jlKXWBdYzlcYBXvbBbGXoQY9WgvKB4gRGzy2caSVo7WKkCKjvZIs75EZRVHkzGeeNgR2dgb0+10i3kaP0ZosZQjTKXIZE+kPirPnfUwJsS4oIy9i/sWaGAsyCULstN8vCH28o9rcSfeJM8fPTfqh1k6dCNFdaGd1Os4C3Y4Q3QW6F+UXN8o2G1WamNI7Atvv9nGWCMjN6/NAfEM+PiMNb7ouYtO1CaxLY+/cr9t4cwS+Paw5eyXWUrPr7jxw5toqLu4tLrgYr2FI3+nJQUqJQDpTnLIx4GNHnK+bhrvVirqfE7OMaV1zMpti0y7LEOijutgh0nkjZZEkPHWyfOVmQbZ7QPZITnwAYr+DHS0bz+35klGW09sqMH1N1UZOF3D1csHAgAgC1wSOVy1f/PJt/vVPXkb1dQclXrzK0dFzvDIteKafmFAy2L2C1Fu0R3Pq6ZTewRg/syxOFmxd30VI9V1Xz7503xYny1MGWyWXruwjRODGV1+mWTl0qSgkDGRByK6ynDRM377Fmy++zO2X36BpLTdu3mQymdC2LSE4QoiU/Zz+dp9UB2SuODmylCNDmUlcSCADMVRUdsJ8dkxdVTR1g/Nuba4qCd6CUmtFK9YQvfgOaN73+nh3UqarhmgDmdQsFoHhAMq+5uDKPsevHTG9s8Bs9di97wrH0yUHOzuciDmnp3PapiEzUJqc8UGfvCggtVjnSBZ6wz6Fyenv7ZDKhmTmmJMVsQ3Uwx7WBXJhIdMIrSgEtHQPT9863NKBVJjckA8Uq6mlGBvaxqHXsk/eB4JSyFLTHFWU4xzV0wjVyZkll1jNG3S/QCuQRoGQiBToZxLbdLr2W0bQ6xtCG4htwJDY3ukzm7fYFhIaAdy8s+TxJ/dJrWXVNmgkhZI0C89p6xFElBCIEDEy0S80ftFyfLSklIm8sGSZplfkbG9vgRGo0ZCTwxbnE72eZjDqY/qaMpPYYOn1CmxAkUI0AAAgAElEQVSTsE6gexnXLu9z58U3mZ+ekg+HCJMhdM7e3j53/CH+5Ii4u0PKM5CCUmmuXN7i9muvMwyBvDcm9jJkr8fu3h77I0EjxpxODnFrMysnBIN8iKsWqEFJE6HIDMWoQIhAqC2LlaStm04nX2d4IZjPj9np5QzLHqiIMYLMRHyw5KUkGkHdehQgZSQpRUmiTJ6iyFi1kZgZdCYIwpFJhzIC2woaJ7EeYrD4UNHb2u+6FlmJRRN1yaX9q9w/GqFNRuwNOJxPiSGxdXmPWFp+8+/8d0z8z/L4UxlZvoXcPcAVC95qPf2YqJSmXkyZNzNsYSlDzf3yYb7yZsObr7e8f++Ep94fKB/IiMUV2iT41ReOeCi7xvseLti9LLlJn/mp4sn3jFHLBpsS+VbBocj4T3/5Nn/3rx9QPniJJDzJHfLqV7/B3/v3v44n57RU/PiPvZfm2iMc3TylfvklHt3SNLScVgs+dF8BsSCERM8E3rxzRK41WlpOppb50uN8QKjEh9+3z6JxVEnghCBThp2hJssM85M5q2XAudAFJkLikyAQCcEhrCf5GjxAwqbIybzChUCuJEIrMiMx0jNZ1BAE3ntUYYhagYrkfdNh2WNChIA0UFzOuf/ZHa49+Bh/8K1vMP/WAj8Nm24u5SjjY0/9NNQVYyrMWOMyy73FK2Qi8rUv/S7zxYKIpTc22CpjduLAJ7JS4JMghoRcdw5IiZuvznnh7g3GgytkaoCIjnuTKcN8F6U1IpW4ILBOkhc5OhM0WiHCEf2hYXGywi9r2miRBz2mkxWZ6mT8pJaETLNsAqfzFl85KhdwPmBbi21ahqOcYb+gGHReBlXjqHwgCoGzDjdpUUKR5wqpM2KwaO+QUmFdoldqok0sppbhIGNrKMhGmsZ7ZGZIOodg8dMZKROMRkNcazvTupBI/zccxpRYs4RZK9mcY9zFWg0nxU3leQ31OUexd9X9TRIgNkFmJ4mr9GbpERfIfnEdbHafSLF2ZN0kAGmdcJyBJs7dQr8XhhAXFILWXA6x+YDzsH4TmGxgapsR1/r2Qsqz/YTYODmf80TEmiTeJW0dzDbSYam74GfDMeCCvOU5bOlMtz2BXPMk5L/wYOniL/uT3/3tkLKLLsoX52uzbSBx6Bq2VY4g8cLslDurmsl0xUtffw537TKPX0lke5eIfWhVw9x7sC2t6RNszSK2eCK57AFjbp5a7t0M/MBjE/bu76O3t0kqw8XE52+teLS8xLU9SIViFjXOSi5dyki1w8eEKTNevxd46c2av/TjQ8RgQIoOERe8+kfP87XPvEqrdjjdVqwGOdtmwOz1V+mtFlzbHlMLT5VJHr5/l/GlqxT9EfK7iIwMsHd1zNEbiqMjR++Ox2Svc/TCBNdElAcRI+MrI56+/mG+9pWXefnrX+H05JSjwyOq1YqmbbvObojEFNYcS4dvPanq6Pym0BASRkSMASUCN26ecvfJIx584gF2vrzNyeERVbXCuQ6topQixk6ZrfunAL++xs65Qd/L410lB3tXdxkdbHF6b4VJFjEYMZ9Y8tKxDAZrSoQUTO7eIZeaV9+asTOQZNowt5bgYP+hkrHMOJlXHcSAjugoehmZgmYxZT6XVFYTTU4pW+5/ao/jmwtmJ+BtwK8csY04lzC5InrWBmsOVweaQpN8oD30ndKNARUDySdiDIgE/VGOlgqVmw4WBCTb+S8URnZ8gxhQKpE0HZvRBUwpsMtV5zpcFJhhTjiZ48SAcneXrA6k1oKM5L7PK1+/w85BHxsTSRqa3oDezg56vmJ5NKNXKjKdSLbm6O05sfYspxUH13fo90zncqo0veSQeZ/J3Tu4WQ+yElloTLFFERYoLNujgqJX4L1mdrri6NbbZHsjxo9eYdgbExLM5ktmsxkNOZ/4yEN8+dUjnPekpCiLIePtLUa9jPr6dbRbEH0kLyLlWND4Ba/dqVC2pfEWXebkgx656hHaJbGN1EyJoUHJGkRD1QSSbxluGxCSot9DZhmByE4+JKczd8m0QadE8i1GKWKh0WT0exqbOlfYXEJYVSyDI5OCKBKmUBhV0LaKo9mSuslYVYHVwnZdoei5vVhx6QHF/uWH2bt6H5mWJCk5JOOBcoRSgjpKWqUZb+/zhM4ZupY/+OBP8vwvf4GbP2VoqwZ9KUdkBW/MBb/5rTf4+Q8+yavLirt3n+dS8PzkB3+emdL8vV9+kUf2X+fSX/jzlI+/D7+YMSXn9WqL+/cjj+/3SYXgZgNBSQY7BUk7BtsFwyzw3K2a337pBn/tI18kf/ovk46+Qpi8QMwcs6M3eX0pGe7fj33Pz3O8Gzn57O8yPzpE72xzYvZZ3lkw7iluTAuSiZAqisWKvUtb5D1DilDaLqnTNkOrhCdxOK/JBgVSC/AeHzxFlnPqAgLIjcaFiEOQ9wsqH4kzy+TunLwwjMcF913KsBJW04Z24VnOGkSuyQeGhUrEpEgCGtddV1JIok2cvl3hhoql7+4xtW0IPcHJpKWa3eDtf3oTP/NnXcHtQvMTH97j2niHG0cvcuf0mJ1hgZCS2fyU596+g9Oak5NTlrNFh8MtMoSuiSRk2XmW4EBkYEqJP0q084bnXn+Nh64JtnpDhlmPsdnmeDpFC8PAFAhniW3NzNXcm62oFgu28h6L+h5buz0KscOdl17jxa+8zsH1ISEf4JqaMlMYCdOTGYvK4VxL03bkxtZGbOOJSiL6fcyixi5rRASda2zy7FzdYXVvycnxnDTqce36iPsv7xObJX0VefHVKUsn0EKynWkuHfSwXlPP53ggTmdUsxnRezKdGI5KmiCYWon1Clcn5vdWZ8/7c4OwtFG9XK+DAu9Dp7GdOljWxUDsnQGbWFf/LzgGC3EhqegkNi9CXOQZn6DjpLH5zjOszfpI6YK5z/fQ+iy4qNDUdWU2RG44T9DOOyXiPHlbO/1ugsO4JiOntNZMP+MjXDAlO5v4jkfXGWet8dXifGo3nYp38A26d9awsPgOs6U/85HSOwK3OiWOo0dKxZedZQeg7HOt7DHKenxpfB/f+Kev88J7jlkNEzvDnJQUd6vE80cLfuz6gM9+9auMDxLvHT7CKH+YeQu/+n/e4umHbjH86CdQeYF3gSppJi7j2iiyv62oRSJ4AVKS9RSISFZqMhP55q2Gujrl+x+co/afhNVtkr9FyDRH0ylHvmT46GMcXn2aH/2xXW7/2m+iSkNlhrx2muitGkYDwaQesD+6hCl7fLfh6n7vM88jr9Q8++xDXL1i+PJXn4fKoWNEWsG1K0Ou9TN+/9d/nx/6+A/y9/+rv8tsOqOpalpr8T6su2edCSVKMJ0sUUbywOiAfqkJRuIlFLsZMghSJVnM57x2521e+cKb3Ltzmxg7yHldr7X/hUBtxBhCtyZuHLxjSudSwd/D410lB/54RT3MsK1jNND4bEDCc/vmgmbVdLj3JLh9t6KQOcNCYL0jRUEvN4hcYpTk7dsLRAr44EEJjFSIWY3NDalWLE467oJdNhzPGga7RWeC5RNtFQlthJhQRmFyhZcSP206vL+CuHIdEdpHZADnEkEJtJHoQmFtZLRbdG6uga5NKATOelQmqOeukwKLneNpZiRqp0d/T5NER04SKVJqKLVnUWjalSXvr51dLdh5hUiRYrtH0wR0odFlBhLmt24yGJRY6QnOUfsALiBTIis0lw4GrOoGpSXDfk4vz1HSkHLB4P7rVC8fs1xOEdozHhmcTxyf1mwtI8NxQuQZ5SjjsZ2HuPfWlLy8hBUSb2uEhTEl169f5cbp2whZgIyYrMRkhqauOKah0JLppEJER4gWJwOUBUV/iyx3HR7PNoR5je4nbOtQJmc0GpBJQ1FKdK7xTYuPAREtIUXqtkF610EKZAKTk2nFsMxJoaGqK4JvSalGa1htqqsRlFKMcjBKcbRcobICYR1x3RaOosBlJad1xWre4Kua4AMUOUsvyY4dd6Z3eOKxB3j4kfuh7NHXGSsiN4XhNGTsSkFhMl7Tmn/nFz/B154Z8seV4M5nXycsWk7K7+e//rv/BT/+b/wVXtQZr85zTuIj1KMRbzHkSydzXn/lC/zQX/k5xk/muPwuC3EfJ4eR41fnPHh/Q7u9j9M9SIFCJESvZEjNeBh4/nbNjcWMJx+o+MiTz8Dkt/D1q0S5z9c+83U+988+z+jgGv/ZL/wt3NaUT//q/wqLOfvDLZLsszy8xzIbca2IWN1QrSpS0yB1IgpF4wKLRYtRgmGhqFLAA2/eqRBZhnUJnRJy/a8NAVVqBpkitJ7aRVofEMp2XJnMIFRncLiY10gCIjP4yjEeZwwyQRCCoDUuwmq2RPYMUSiSXSs/JKiWFqE1ptDMJw1BBGTZ+ZH89v/xOrf/uMJOA8EmtBZEBLdrzz/+7K/QV0N06rFKObOTmqPJCXowJB81FFuCIDPahcc3EaEVdmVJp5FsJEgWvO0K2mrQwQrvvXYLzQC7F5BjTT+D6C21bwjSMDue4X1HsnfR0S4qWu/xK4fIDKq3xei+a7jFnJgylos5pIw2aKQUlIOCfuuY3JlRKIUpDOVWgdLbKAWXd0qmRzOEkfjaEWxktLWFpDMcGoyGjHNF0UbcItHfPmCQtTzynm0W0wrnPdJA4wSVq/8v8t471rbsvu/7rLbbKbe9++q8eZxGzozEEcUmUrItSpYsC04cqzgGZMdOnD+CFNgIEiBAiv6xEcD/JH/EDoLEcOI0xHFiy7JlI6IYmqQkQhI5HHI4hVPe1Nffbafssmr+WOece99QkkdCgJDMAi5uOefsc8/ee631K9/CvLU4EjoGtBKIlPCiwAXJ4nBOs1PRlBVWC9y426z3caM+dKZCtiJUc4YoezYMSe/5PW+iq8dErjrHlCAEYsx6+iGeBqMbiMyq85DgATfWNWboQW7BmiSYNsnLd/NIaVX9l9l/QAb3nmB+LZ+YNkmEVBn7lWLayJjGlU2qXCVjIVuWb+r/Z8nc2QhrDQM7PcdZ5YjNdVh3NEiniaJUYuWAfio/+wf8xL/nb+/nSia+nQ+xHhJACO6EwGwlN+5S4i6JG9ZzzkiUVNjpiD/98Wu8+2t/j9ETf46jL3yJ1lzjtXnL7Le+xCc+/jFuSk199RmWk8RRtcO9qLm+mPPcN77Kj//8z2KmS1xSDKlhuUzMDwfO7waGuiAhkCmihUAaQ4mjKhNvHjikarmyb7iwvQ/ddaK/QxK7vPK5f8aN12/w8BNP86c/8RkOujs898XPsVtrppM9fITWd3RRM409sla8/srzvP1KZP/CZR7/8CcRUr3/E/n/4bC959V/fp13X77H7uVtxnsVy6MBZwNNI7l+/YBXXzpg2T/Hr372sywXc7rlcgUDym7Q60LCuujQdwOHB3P0dc12N+XykzvMTzwCqGpJMVbgLDfffpuvfeUbzO6dMLQDQzegtSKQ55l3buNzEFffgdMO6vf4eF/JQbCBUsJWpbCdJ4gA3tEedXR9DyIQrMEXCnPFMEqR2VE2Bhqfn6BlPrmHdxdsbVV4ZbJMnlYEIv1xR29hPvP4kIgerIv0CwcpoiVELdFCopVEJAiDzz4AOxXORkJIhJRw80DV6Ew2VBKUIEQIi4ztdctA7HvsEAg+YQrNeKIRtWE5syBilgmOZAWgRUddlTkxUIIBSCLr3AqjKEqDihE7OJJzFFJDckSVic9KSFQCKSLVqAAfGBuDlIkoNUkFFJ5xBSedxtvEaFQx2coQrCFK+llgXiRiXaKGgFssObhxk6KeMt3bZdxUtPMZ3ckSIWFSRvqoWSwOSD2wkjPt5y3htVvEWhGNoO9agltCN4AQTHfGTGpNiInpdILQmrbzELNZ2gC0c0upoWgMJiVk1UCKSDzGGMpCo7SkKDSjpiDJhCmzgpUPDiWyS6iRCdZBi9SkUOCNIIWA0olGgLZZQkwZxUgnbNuy1dRYmVV1ohf0QbKQBb7ewytD33mW9+d08wNcipwbGl7/6m/iv/+j7D3yIZ4eT5gqzdsp8bKPXFWCcSlzgisCH1GS3240P/Cxx5jaki899zu8ef8eafEG97/2Zb71b/7bjLXk9mSX6994k4M33+LpJx/n7/+P36Df/knG+59EmiUH7cCtWcQvDZd3PLu7+6RxjVGGIhYMERp7jKoELx1IvnK3Y7cKfOYxgw5z3PAs6aji1Xdf58vfeod2XPOXf/QHefXL/5jfvHeLrZMl1WQLJpCK2+xuDdjRklJUdDGyXMyIJwNFU3BSRByBvg8okbIZnRT4IDiZJyZbgqpUGaJmE0dLy/EwZLdon8naUkOlIPYW20Mx0liX+Tyq1KANyWfVDCUMeqzxUeGSIEVHMSqwIQISZyNxCPgUEBFUkCyOLG3rSCJROokMibt3ZixvOVyfdfCFFLgh8uabc/TeO6C22K5rlJS0g+Wk7am2LHeu36K7P2MYIsPSY7tADECAaBN+kR0/dSmy+6dNoBWzuy17O8d01Zhl4ejKJVpLdMjwncnWGJJEKk3bt3TphBADznl8kBmMISuqqcSLRLcYGI01koQfOoSA6bSiXY4RZC6QrmqKulmZhgWMafA+URYrsmTvWNhjSpmotUKmSLt0uNhzURu6NOdwJpAxInQuXvjO41HosmDR9ogYsyus1hQKvHU4qVksLDIE8P4B86scPJ5Rq1m3DwDW8I2Vl5aSpxXptavnaQchV9jWupwi5QThVJ7z9LXr4PYsf+C0MncatJ6t1p1NDL5XqnhrLL9zWcAhd1jWkJ/3YPvTih+yUnKKYRXQr11ahVhxEPL6tvYlSKwTjm+HoJyFaaVV92dNiuasBBX5+xk6yh/mkz7409kA/+x1fm81fPVrCIF+sKhVghJioCgK/uFnf5v5Qw/z8cf22a4LQHCY4G5MXJKCmQYpEmORUApujEr+1b/wr9BevsQ/+FxEDAvsseP2zeu888k/wlTArekO7zz/Km7hCU+V/OqzBwwPfZp6/BAxHTG3gnaA5BXbTaSpxwQts9Fr0nl+hB6hBbeWidcWjse2JRfGCRGXRP8WqS25c/9dXrpzwN61C+yNL3D7G7/J82/f4CGlKfbPwWhJkgtGWxZnCoZ5IArL7ddeoxSKSheEEDbJwXfyrBACvIvMD3uCzyIwtt+mm1uSB1kJDo8W3L5xgtIGIRTdvM8dgxBy4J7SyhjxjJpQigyt5eD2DNNUvPvSEdsXtil0VoPzXaQfOp6//TLHdw+Yn7QEF4g+5KIiZ+fdCja37niuSexn3aa/R8f7Sg6UyvhERWJcCKwOHM8G8BYZfZb4LCsO73WcvzhC64gxkqiyRbcWgtncorRgPG2wSWBTVjTq+kjoPcvjga4NWbFDK8pxQ7Q9rveYQmFUriblZS7h7UrVR+dAYr0YRp0vZjZ9kSilEBLiENFKgpDYpctkvpgxbWIsMTJRGFYkYbHS1RaYxqCFppt3CKMIMicuaQl1KVbV64C3WVVJs9LkXjlIipT/ZynABkkREmVd4web8fSrFrouC5oEVoAyBUKZrOHvwPZZ9tQPYH0ihYAcHLKMjKZjJBBiwgdPCpGFz9ViHwakMHiRsEowSMXN20dcfHgLL8FLaNs+V0O1RheG2kQmW1PKpiCmhA4ZBtE6sCERBkc5KShNmeFgaGLyRFJO0hS5SiINpqlJ0WaIFgprPX5o0aUGVSONzpteWrunZtnWJByF1tRlRBCRMpGGgUU3zw6/QiKRaKkwSSKFQRTnKcZjoMUPHmcDoRpx87XbHM8in/rpC3zw8h4XTCZ63wgeYmSkYFIajl1Pb5dsNyPQkdHuBT4kDPMf+xRiWnLvzovQHrJdKoKCg9e+yp1nP88wirx0/KM8cm2b9Od/kurKNWbqhJP2PnfvniBaxdUnLpAmispoihhWLXzBVgE3veGVRWBvW/KhSWCbQ+zhTWyA668v+fr116nO7fKRxy8z4S63Tt7g3esH9EKR+oE4dxTlgod24KCViK0RbdLE2CNwJB9RAawHIxWkgDaCstKYJOlnjqoxlLVEKghO4EmkFEgenNS4lChKiTaS5Yknhay2NSo1ptSUtaEsJT5kku5yPiCUBG2IIncXrFst4CExrJRAhMhB4bD0dF1Wfgox4ZYRcZg4mjnscqVuBCCyANPxwcCtN0+QI7BNS4qw7D1t79Bzy2LW0y4s3iVc5/F9VmBShUIrTfICoUWGKlkgCExhsi+H9SjrEM7iug6VJMpbpNIYoxFJkZIgJYlPkq53BKGJMRKcx7uIKBtCXOBDxHYWLfJjISRkkEy2xrihR0iJ1hJFJDqHS5CkRJkCbz1DPxBCR1MZko5URhKjYDkEhO0wIpLoaZ1G65jlnGVEFwrvPEOQEFLupoasTCRiJAmHKbJHh20tyTmCO93oNgHFKihcOxUDG1jLOjB/79h0ENZE1gykX1WuN+XrvLGeQQqtW/ab/+FMYpCJyb/nOz0YMH8nR0P/grGJbdYJ1jovI4HIydX68+XgJK6q53D2g6/PzKmqylnVp9z5WQc9v1v356waS0qnUKfT/FCcXstVV+gPJp15pkv0QHMoklImuMuNo8XpU9ZAqJgSi8Fx67jl+O5dLu1NKQrD4WzJjVuH/M7LN3j6sQ8gpUCvkplupapVCyi1YhYcMUZGUqK04ANPPY0Xhk9+6gd5Z3mf5clNhJ0zNhJP5I0Xv8Y7z7/IWD/O/hPneej8CPHHn0FVE5Y+cdL3dMsOkzQ7uw2pkBiVk/aw6rYUEk6i5M6Q2J8IdktPERd4e0IIcP9uxxs3X2Pv2mOcayJieZ9Ff5fl4QH3JQzDDPQJk7FlMhXMosKYCqkEVz7wOKkfKKrqPdfiTGL/HTdysO1tFqzp55ZF0TO0HiUVh/eXnBwuODlaYgpDQhKsyxzSsDL4O1VE3syZKMC7QLfsObh1hDkscH0kDFPGWzWFMQgkd965x3K2yLFgiBuPgw1Ecr3tnOncrZqoZ5zGv3fH+0oOjDZ5M/SOnS3DMnqOWocmEGVCFtkoa7k8QQ82VxlHFS4GovfYlFguHKNpwWRc0vuE6B3DEBjmAbuwDEctzuVjFZOKalLT3mrxbcCY3JbfZHYia/dbG0khgI/IVSWqrOTKOCshFGgpKEw2rdCFAaPxrUNJgZDZ/dFbT50ipRL4lAmERVOgSp0hBB2QO+L4CISID4kSiVeBEBLeBdJKH9cYkVu5QSJl3mAlgsFDrQ1RGXy0ZM1wgQ8SK2uqwuFswgcYXCKKxDBkz4UCndtcUYDWqLJCFQVFWeLmS5CaoiwIMdD1CVWAFgpVFAQfEEVC1dDPlpQSljGgTA7Ko3O5Y5I8IBlNtonRk6KnNArpHYve0w6B0mhkUSJMidCJftFT1FVOZpwjWE/SEikNUhqUXB1XSaKE3g+UI5lJ1oVeOW56kvBo4akKQQgeoQJCB0iO5B3WtXSLA4qywUoNUiNFDvYq2aDr80zOJ+zRAju/w+COMfvneOPL34Bih08/c4WPPLzHjhIc56YFl0XCIai1pgqCzg0cRskjpcJGz7ZSfPwzn0bvCX7tf/11+uB5pvLcCY6jZ3+V9uUvMvn+D6Ki42f+5cf4qitptObwUHPUWezJW4zHCvHQFOsi0xBIwWGTpxKJwYx57VgijefjOwMPxUMWt9/FLW5x86Tm62+9xZzA9z12kYt15KXf+jx7T0z4RFlxMDtktriP7ROuhzsLwVstDFd7RF1nEnwFhXIUpqBsSnTVIERAGoGqDBKFlS1VbUBB6zxLl0BLdJWwM4+LiYhAaUVVa3yQdK1FScH2yFCNCqSRhBTwId9T7cKStKKoIArBbGbpQ6KpMt7fu0gionTC99lXxIbc9rV9ousDbggsZxlak0JWFUtASDC0nltvLaj3JK42gMBazzA4Qu/xNtJ3kegjvvdEmxdyZRRKKcKq4i1XyYEqJKNRxVZTU6mCRkiqFPH9gPWeMgEyy+KGIPAhsWwtLoIdLKoqEN4RBkvfejo0itz1HJY9Dogx0C8t0oPaGiF0NhMTKScGw6JF1AbrPYWUGYrVOQrnGRUGOwS2JoLWClrrSd4h44BSEBUM3tEPDh+hHJf41pGKmlIqtFCklTJUiFmpqZY5ERlSwvmA82ekTKXcBJ1iFSGu488NvERACmerZ6fEYlaBfw5C1w8/mFCsc4Ost7863spHIY/0wLf18dZB6YO646fv8b0yNgUucQb8vwp0hTg1Rztbuc8f/4yM5SqSWWu1w4OhYk7O1+/4YHKYVslcLtqsOAfrZEyuBI1j3Bzt/XduTqFgaZ2OJEgEQhgIcUCg0KrO95MQSGGIKazup+xsf6/teOVwweLuAYNtqUrDjfvHfP4Lz3JoDb9wZZsLlUEIgVt9jp2U8AhqmQuKLgUckj0lCAImUvGjn/khvvzCl3jhuW8iROBRHTmMgRu/9TlmR3cZ+ikjk/iJZ/Z4K2qElMzcmHZwRDtQNgkxKfEx0cSITVkSXQuBFYb7VqC048nGYuwc2x1npbSu4NbBbaz0PHntA4T5qxycvMHuI2OelA13716nWy6JrUf0kjBX3O4F5y5N8bbjwz/444SuzcXIFVb+O32sA/AMDUqkAN1sILiIrAR37i9YzlqcyyiPkBIinTEGXBccVt2ys4WHFCPBBY5vn9BsjXCdxS0G7IUtpnsTjC5oT9osthPzPFhDiHKsFzJP9dvua/G9tMz8vuN9JQfEmuTrbNgTBd3hQBVjJtsiMj62O2HSaHQKKAqSEBSFQQrFct6iEBgE7XyOiJIiCRCRSgTuvT3LF14rjBZUCUoiSy8ojKYqi7wxOzJUx2QH4/a4IwwuV9+EIPhIWSg6F1HkCraKIEJWcNCFIbhE1RSopBDJ5+zTBSqV5Q6FEGijKMqCctxgW4sdIqqqcTFl7HN0FJXBRhjrBD4w9Ba7HFBCEAuJj5KQLLLIMCidBLuTEmMK5ofzM1LECl0bUtAIHO3SkqKi0CAVKygAACAASURBVAVSaDoXsVZQmIrxtkEWEh9y+3TcNIgkCEITKFFCIvAcDT3jwqC0oF/kCqWJeXLt7DVIrSnTgK4lJlX0WkJy7O5qVKmYzXsUkYQnycRo2tDHnlpKdrcnmEqzFInWeY5OTri6s01hDE0t0SoSZMAohbIZjqFKQ/A9JE9RFuzubhFFhOjwfkDSUxhPU2hiXCLp8ldaYIcl/dLSCE1o7xG3R9lbQzRINcLHLTRbjMZT/LTm/EPbTLbhuS+8i9T3Sd0tYn8bF1sGIZghuANMZcLKiAXejIJpUXPVCF63N/lodYXr/dcx8oM8Vm3DQw0v/mDJi19ccGl5j68cLZkv7yKawOWHtvmz16YcL27zlB/Tiwn3rGCINZNyj6c+tc1SRHZkxHeRearASM6Jgc+faIrljJ9/tKW49zJHt95lPhuwouRzv/UGly8c8RM/8sPcf/V3ePnrX0LvSf7U04HdcxqtSu6+pbhxI/Lq25EvfNFzrhG889bAxT0YVZpRpanGhlYkHr9aM5qOcnAcYPCCWTRcqgtu35nhUmLWD/TBgUy4CEEpXBcxQoAHGWC7qejqyNbOiLqAyTh7HZycdCzvtZSjimKkUKMSpRTt3DI/cVBIrNbUpYLeYnubTRR9BCNwKWurDy7RdxHbR7xNmU8EpCTwNtEvc6Lb9y1uSLRNSdXozB3ykTR4Fndn9HOfPRtc7hoIIfE+t4t1pVBSoQqJKRVlXbC7M2V7PGbc7DCutihlRec8drFENQ3++IjWS4aQsINnMRsoVWDmBNuNYrCO+dyzWA50XcfOOCG1RsmEHxzLecfxnWOi0Mh24ML5KaUk+ywYxckxDN1A9JYgsmSnzhp6nMxbmnGBVpLkE33n6d1AVVd457EnAzacSu11nabQgqLUNE1JMzaoQiBFREVHNBJnE8ElotCEIuKs2yz3We3mQVMzucafp9OKvTwTt+YNev3Q6e4ZQ9xg4cWZR9bB51k1HFL2LFnDYjZx7xpqtHr++gDv3bi/F/bss59ZKXUG1nXmOZvrsk6v2Fyv7Ny6OsaZg54t/gtBJtusYULprJHa6gmr58vNRV53B9J7jp5jgPcLsVinKLnrseoUACHM6e1trF2gZElp9uiHDqELymKbzrYoWaBVRecCh9ZhdhqubT3Omy9+neOTe3TO8s6bL2JJuPQLeMABPVCSCAI8kTtJsK1LYuqZpYELquZevIESl7liDI9dNNzY8bz72j0mw4xvesOyfxe9M+LhcyOeKgKuP+ZiKLGqYREgBcOkGbF3uWIQiTFZMrqloFHZWfftQaDdwCf2HPbwJu1iifeRzgneePsOO9tznvnIp3n3+f+TZf8uo92KRy/UlD9cIdU2s9s1xyeBN1/tef3FjokRvHv9iKtX30b9AJx76LHNtftumQthDQsSkmZUs1jYbOKoFctZT7sYVvddWKEbM4rlbFU/hPBtTcz1tFnPIyKcHCxYzgfKd49pqpKju8f0vcuKWzJjUrz3mw6C95nEnpPxBw0Ac8L83XKW/3DjfSUH9+8eMd6SVI3Ch4r5SUecz/BCM9oqMEJg5xGz1XCiEleCZLkcmPmERWTi2XJgvNMg5h3eK1onmPeeoXeMzo/pZx2jSY0pJKrQqLJg98KY5D19n2+YohCYSuOGQAYmZJxa8HnpckOkHBvq3YZh5jI5ZWFBCMY7Ja5PYATTiUZqRQwKvKMsDC4k6knBcNAxDAMyJIR32CgoZIGTGdPpQsD6iIwePWk4Pp6hpSGliBQJqSWxMNnxd+HphoApE1rA/P6CYlySSJRGI5RCKoWUiugSwwBGSYwWeG/pZpajhafe2ssmbqJEWoFJFoKkax27i5blImzgA8p7tk1ivlgwDJGqAlMUVEYyHhuikSyWJ4zPTTI+uQ70C8lsZukWCyb1DpWyCFUQVIUXkT5pylGJsgEde9KgGLxnaBfEGOlUgUTQ2khKA0pL9rb3mM1mTGpDiANlIShNgfeRk8Wc6fY2xkDyC6LwCCnw0TKtwS/vY/SCMJzQlJ5mpwDv8LHAjSxFp3GxRpoJZfMBMFd58XDGtW3F9OI2H/zpH+HxZxT/4It/l6gssffcsC1tcAgp+aaAjyrFtlC8O7Scl5p9KahITEzBryzv8HFdsi0MJykRzj3OH/0T/y5V/Bv8/X/yi7zwtbss3r7PtT96jSf/7IQXX/vr/Af/1i+TDnZRl/8iP/qX/gQf/+Er7F/ZRyTBBwrNfdtjywFxsqBdSl4uaz4S7/D9F24ye9ODHHNjWfHiS68ii4I/vvs6lz5zjm996W9y7uKcn/xzY6TapUoOM1lgdjV7T1/hQ2LEZ4LkX29H3HhB8Hf+9lfpbKJIkkpp9Ch/DW2HHRxS1YSo6HxingTnzzWgYNl5nAGkJFlHJSWLUuD6gRhgMjU005IUQTUVi+VAlQw9AzFFYhcxqcK6CmESQhU46+haRwhQa0k/a1kgcC7DjLyPSA3JJ8KQITl2WJkaukBw8YECcnQJvwx0Q6KcGgBsaxmWNgeWUqDmAzKEVf1UEMjBppKCYlQhBGip0KWm2m4Y746ZTDU7u7vsjMY0SWGSoioqxlJiRcHB3btAxGxdYFrUhLalO7jL0XEHOnHiMz/D41l0PZ337Ex3KIxHJ5eN07SiLDV3bp7AMOAWLdXuBFUZUnDU5xq6+5bZvUNqEQk+4qOgHtdEDecvjqinY+bxmOFowdF8oBMwMhD7jkJKyrKgqAymEKhxzXRrwqRRCJ3drROO5I9pO4+RmYStRUCVoCg26/0am74hI8e0CTh+N8nItMK/nI0P18kEvDfYP23PCyGID2CJTn88DZJPK9kkVkRZselQiDNv9L3Q6n+QV/EeVaH1X8WZ6nBKp8pEZ5+TH9z8soYSnSV0r3keZ/7Eurewdkg+5YCkTRKxIWSuAyXeT+cgnfkp4WOP8y1CeJQoWLRfoW2fQ8uU5UB7wbITxGKLdigJNEi1izZ7SLXFURd5aDxGmJqnfuCDXL8/8OUXfpOjcEx33HHPO66kxAw4AS5KiUqJoxjYR1LJ7NWxjPCCW/IBYaiF5ITI/t4zfOIjiYn5v/iNb/5vPPf6HYRZ8LFPfZBHnuh44e3/g//qf/8s6e7DlI/8Aj//Lz3KlUmiNAKVFBMtWYaI0g65HFgkhZKSa3Tsj+bM70eE3uLO7JDZ7AQjIx+avMPkQ3u88+xfZ/8xxUPTSwh2MGJAlUeIekRz7sOcFwVPfNrwo33B4Q3H//1P/zl/7Kd+gen2fk7q1yo63yVxa/DZiDX4RNt6vM0+V33n8DYQ/ak879rjJJy2HfP49nz1DFdAMCwHpJEURYF3A928YyYUyWcFy5Diym8FjNYMwa6KxCZzD+JpEWNjAvn/g/bB+yMkB4/1Dm8j3Uzx7q0FFy9VTKqScjyGEswly7Xdy5zcP+B3nr2F1pGtvYbt/Sl6NOauh/nMEmeSqspYWL8MFE1NGBxWOGwXqEYNRVMxO+iQHjSC2aHDKDClQElIRiBdQlpPiomoM0SlLLP3gerEquUkSFJCSoTOoYoETtLPBO3gCArG2wVpCLSHbe5op7yAZkyboBzV1DrhSk0jyFjezhKtpR0s25Mp/dxS1gXFdIwPkWVrCTaTNWOM2GFAy4iLgdRZgoWlSBSFYNQYRnWJHitCp4lpyXhaEZF0bUCWBdWoYuf8lNlBS4xZd771CR8dt9z9VdUu0jlH3/a0bcd0b4olIUc7lKOSkRLoGDjqPWIk2bqwT+qWJOvoCkU3dNy7t8SGwLXdbaxIICKNCojguX5zRjtfsD2pqRtDM6rY29uh0yWCSIgBIRP9wuKGjrKWXLqww/FyTrA9eDCFYTTeQhOodMViOWdS50lbGsl2M2Kr8izlWxwvThjaI0zq0SoxqQRPPlpT1ye4ZLh39x63Dk64c9jzG1/5Etceeorl8CRy8ijNzh6P7fxJ/spTH+M/V7/IO//1s/yzX/mb7E96/swP/hQ/IySfJbKL4NFCcRADr0fYE5Kn9Q4pfZMrxVP8dvsytdnCmH385PvYu/pX+ex/9O+x/VOaSz+v+WOP3eBHzt3ihVmGyYXqPuFb/wVf//zL2N2f5WM/8mmeVJJvzVr2Y+R2u6QUM+oxDHabLV7nZG65OSQOrn+VxewFqvNHXKwmPPQDB9z55ss8+eHAdFKgksGjWZ50lK+B+uQfQe1eRek9hN5DVhe5/Mlj/v0nP8idl5/ntefvcnycmJyb0rvIMHckJZj3kXmXWNpMNj4/3WefQGUt/eBwrcW1itngcEIgKo2SAucD9+61KK2xKELvOHCJ6bTGVBWiqdgxnoMu0oeE7QPdwjE7cfgQkUkgqxphLabQ6ErhYmB+0BF9ItiAHQIx5qAlhrQJCIEsvb7itkot8YNnfneJrrJqUlYZyxr4g40IobIRogeQRKkyT6kqCAKEC6RuQCwlIdVcfPoCtZA0o4LgBpazBdOtbZYuUBcFk6qgnBiE1gxmSrxWcPT8K/i2Q0nBaFIwHRc4uYPqFjSFZGwa7ty8y3y2BAFNY7h4cZtkLcvW0x/OQSWOlj1+5Ro9MjCe1AipKMuSi1d3GFrH7vlLLLv79DFSbI24dGGP9uSE1LWY6BmPGqpRhS5LpJIUZUE9GnP+8g5aeGaHhxwfzpjsT5jPDxhSpO89otAYVeDcacU5xQzJTOvzzmrfXUting0242kCJ1Zl6XVgmeKDmODTA50OpeSmEv5eN2S52tzZVO5WkBYpEOl34T2I3+UNvovGKZRrgxF6T7IjTv90hkOwKfu/Jy8SYk2ijN+GmV4nayqJM0de/x/rRO89BxUP+hlskg3xB0nIctfAhxYX7pLSEd7dYtm/iutuYnRHVSaM1uxMJxizIIzPMzs+og0dJ23LrfuvsTU5z3E4T72/ixlt86HRp9k79yjd6Ff4wn/5a/zSc/+IvY/9KR6bnGcbeIfECLggBEdE5gl2UIyEgXTItr7Ii/YG58wuyVQ0e89w7pLhl/72X+ODf2aXj/3cmJ966Dq7kzd54caA6hZ0o9dpv/gf8+xj/w7pkz/E4zv7BAR3B8c0wYG1jEyPigYZJWU6ph8CJx6W73ydgXeopo5pWTDZv8fi5m/x0FMGYxqgIiaB7R36IFF84CdA7SPECKHHmFHF3qMtP/0Xr7C3fxkhy+/aavZayMD3PicDCu7dOMQ5nxPUdatgldCe7YycnR7rtWZT6feeGFVWAHMC39ss96sUWka8O/UtWAsyhBA2vAMpJUkqBJFIXBGf4f99T4/vzPH+pEwT+MEjXU+sPWrcUE1Khn5gfniCKTTNZMS775xwfOuYZR8pa404CTi3YLwdsR14JNYGlkPGpYumIHY9KiaarSrDYoTAdY7UtcyO+tVCEghC4m1Cy5jxs97j+kBZaNAiu+VEQVkWJBdg5XwsEyQfcS5mN1ItSKUi+IiICdE5+iQz5my12ElWm48LFIUCH6lria41KRrcUtF5hR8cne4pC4NIOr+HD9SmwOExhdxUdNohEUyR1VFSlsgKOuK8p112jJsRThocitYqXILeC8ZVTQEo75jdO8YATVPikWAUg/OMS0FIDhs8Lq7MldqOejTiwt6I7e0JhRC4tic0npNQoosCHyKR3LWgKJls1TSFATPCGIkWKatdJMvDuzUno4LWWaJUoApiWVKohPZLktEUxiBHBYMaEKHj4Nhl1Q2hmG5NmU7HVJWmVBVaBgodmNQVWgWUGKhMQVlXNMVHGY1gNgnMFo7b8wV37jjGzLig7zHev8nFumbvyogn5JwP7WzxjrvBF16ouf3CAeXlyzz5sQ/yc48+xl/9N/4av/hLf4njX/smb3/ft3jjmY+zJ8dUSeIJGHyungqokRwKyU+NnuJLL/0nXDy3zZWdP0mpH0X2B/y9/+l/oD0Z+MwfrXjokuD+ix1/678b8FbxI//ZLtfOJX75Pz1iZ++bXN17mov1Zzi2gTbcxKgpO9riU0CHOfvhTay6yqu3v4m98WtU8h12L0QmzZTz0xHGwuMf/QCmapB6jxQUqb+HvPQpuPYU//B/+W+Id36D3d2KS0+NOf/khPHDH6XSJxjjufhQw/a+IeiKk6M5w9ITfF7sTKNoCknfWd567QY+wGhSkELmF8jCsF1qju8NSFVhVKRQ+T5ezj22s8iU8DLiBCiTg4ZuiGglICrahcP7hKoMBokoDCZEAoKQcrcg+dwpWy4t3kZiWCcFaaPRDmeqoCkbOoWQEDGgpSBal7sdKXf24hpuIRPEtIFJJO8RZUGKgYigGtUU4xInDYUsCINFTneRekQgG/IlF4mdxqh91MSgNXlu2YiRUI4aNAOi0EQg9D06WCrpGHzEyIhSGoXA9pZWSDSCrk+43uOdoyglTVlgk0eWEnSDViZXs7TMUrEHx7SzjmqrZtSM8HbJ8cExSXomE8321hglSlLUKKEYlwX1qKLtO+7d6JhulUCi0AX0gYlWzFcQSK0khMhy1m/W+3z+QcgcYKa0csqNp9laEqzOb9oQlmPMOPacxK1BKqt+wcrzIK4dkc8E/utCZ9wErRvwycqRWWzgRBnr/mCmsf4tKyO9773vO25IkdWzNvFOPDMBVudm06vJmdJ7ugLrZCtxCjsin79NR2IFRVpds7CWrd0MsfKbOO0UrP++7iSczVv+MHGSEKCkQamaRI9W+0h5l06f0NslJ90xwvUUIjERkmJ6nq1qykTssDPa4fx4i3lMPPu25vitE7au7PPExS2e2L7Kz33iZ/jtR77Ga//417n18MfYG08RQmMQBBJKrKTD12dSaD6ot3jp3t9lf3KVXfFJvCy4c/9tvvSbn+ek7fjI4yX7leD5l25x/5ZFyIYf/9krXDmn+G//xitc3HmBi80HqdUluuCxaY6WFSMZQCTKeEKZAo4Rs8UtwuHnqao7TMyIqtylKStUUuxe/TBKNwi5T/RtXuOqT5C2z/G1z/0tirmj2t9hcnmL6YV91PgplGy/jTD7XTUJUkKKLCsbfcoICJm7y+t7c9MlzC9YbwX8vp9zc4/mPUEBPiRESEiVSOp0jxEibZKCNXxISbGBF+W3ynPnQQr/9/Z4X8lBrRSKTKitguTJhye03RK3GIgyk0SG2BE1SC2oJgYlE0UlaUaGqiyoG0nhPfdjix0cujY0lWI5i3QuoYtsbmWdJaaItYFu3lPUCq0yATmEiHeJosjkYFJmKYqYL1wKYF3IN5LO7qRCCoRWhC5DGXRtEDqT4LSUCCEZhkghE8W4wodE8gmSILhEvxjY3a7RhUKvcGmi0EgjCCGrilgEWoKIEm9BlwZpDFIlRHTEJIhCogqJD5lo5l3cLOyeQDsLFE1FXTdEdE5elKKcjjBKcXxvjog+qxClhNQJHyJ9a9FRII0iCY2QkWZcUtUNRV1RaUWKEScFoVQoLdhRBbUp6YZA6wc6H6kmI2KE4Ab66NBBIGLEuYD1UI8qZOgpVUHVVBR1tWoHWqwd2BrV9M4ScCQhaJcDymTeB0oRgsT7hHdZ9rQyiqYeU5cFWiaUrNBKUKhtTHEJU0yomm8ybl5kVrzJ7WS5d+iZvROonh2QzQK1P2N86YSr+1vslIKiepqvHxS8dnyLr3/tFnLxCE8/9TD/2n/4V/iV//5/5vW3nuUbb1zmxx75DDtJk4Dj1DESBaVIaDpaJNuy5I48x3Q4ZOkW2DLRSc8wfYkUAn2bnRaJge7AY/qA29J84qmH+XL5HM9cFHz4ikIoydvJ8UPFwF2/QKTAJMFIGajGnHTvUsVvcP7aBZrxBeqip0kDhR4h3ZxkL3LP9hwfLmkPl4TuhHb+HL56k0e+X1A+c4m6soy2jyjrY0QrIe5QGoGR0PmBYXAsTno6m9CFJvoIKQfxygiS9SyXliQiqlaZG+ACWkqacYWWhqHtaHuLtyF3X0OgrhVKgB0GhBY04wpVG7QNhMWQVbxSQiqYjhV6VOB7C21WLMpzORBdJodHnzZBTYq5in62XbyBN8RE9LkS6mTIZNtVlyHFRIhxo1AmZZYTTjFvENLIHIAJTQyChKQcVezuTamNQsSYTfm0xpgCXdRsjQoKpYmpy1wgIfEyctwtGTeGewuF7wJKRKTIUrFVUTIqDaEfIEQUAimyQVVaVU6FFHS9pbNg6tzlrKoxTWNYLi3t4BF9gOCoCKRkOVlKEAqMQWpF6Bw+epZyYDIp0aWhNCVbowIXAslZ2iFi+y77i6TEbLaEEHAhUlQGUsRHkOrBrWAdWuYqdk7a1tFgDhzXajdpw0XIJmenVbhNIpFWpONVgLvBuae04oOsn/3t8oC5OXBGXvNMxpjD3NMA4XtCWnBdFV21zTbNkbRKllibookzL0in5xgytOQMAZm1WZ14r6P0g0nWOpFeB5vxlK28uUYZciYzl2TdSFrdB+/v4wlAImWBTiNCGpByRFkKlDYU2tPJli4tWXYtw4FFvz6DyRg93aKcbLPdnKNRj/D9D1/jjYXkTnubF989ZL63w6XtHf7yn/8L/JN/9Mu8ev9F9vdrLo+uUIsMNFwkx0gYcjofCUgKoTgS59j2JwzJExA4c4IfvQRhwNlIPQ3gPGnWosuE3n6I77v8KJfTc3zfrmC/kTgBLYmr0nOcBlSKWZJbZeEN7w4x6TrTc9cw1RWMcGihkEIh4gB+n4Xv6U6OsO0xYeiI/hbRSC4+vo/2U1Q9p2jmSOXASUScrK7ce2Ruv4PH2XmaUqKqCuq63NznbvAbgnGKPNCZyuAOsWmzPXDXiTM6TevHUiQJSCtp11ygCPgUSfHBpCqvUXmdCyE9kHuchd6dkvu/B9ab32e8r+SgNJKqqvDW4LvEaOppgye5SEiJ5ByiiBQ7FWZUUqUOKQVlpShLhVqpIqQAzgaSD+igkC7geo+LecHQOiFThJWbcUo5KYiwCijypoSUJCSmXKkoRLHZJLwLKCNJPlcptZawVjoJGVtmktqY/PgosrKRJOPqhSDaSBqyNrrvHKE2FJUm9lkLV5BJmkJqBufw3lGXAiNFDnJENkpK3hJdRCBQJoGGobeIGFEpIlbmGj5JYvDE3iPr7PYqlUIrRTFuoHccn8xQUuJjwg0WFSTSKCKChY0USGLMXQ9TFoybGlEU+L7PnI/SIEuNUlDXBbgs3+V9IkQwZYFQEtdFhMzYumgd3nr6oJFFhuXpoqQejWlGNbjIvLMMSw+FX8G4EgmJGzxCCYpmlLs+PtC1LSkaYvRMygZtqpVRT4LVIplSg5AXKM0eVdphVOwzKveI5rfpy55gIbwb6Y972qOBV653jPbmfPhpxYcfvs7O5ae4cNvw/PUjfv2Vb+AKzRM/9kM89vxXuH30Di999at86PKHafQWx/4QpSRGTREoXErEFDhKS67ufoLXvvFP6R/t2Hpk4B07I6YT1AR2jOH2t3ruvRUYV4LHrkq6QnDzRsB1CdX1jOxAKeH1ODC7tyBuN0Q8zlsGIp0uiPY1Hj43pam3KWSHCPdwyznL24Jmu+K16z0Hh/fxcUDgwTm2J0tkuMvjT9aMzu8idCIFSbIzYn+HYE1OIr2lWwwczRPzpQRdYuqaAo8MkKSkqBRukAy9xzpPKgU+JfoYKKWiKCS6KHDOYheJoY8ooyhKTVkIgg04mxXGIhBN5toQA0opsmR0ojACvyovbyQQV47HKYLScmVIttGj2VQ2v22k04U6hJW8I/k4KWbFiyQSwQekzPM8rqppKQl0VVAVFeWowJQlpiiYTCZsNSMKFE1ZUJYjhCzwTjFpCopC01pHdBHrPMu25WS2IMacOLfLDiEz5rgoEkYrQt/j+oGUEqYskUYTksC7geDcJthLKVe0ogATJYNLLHpP1zpEcKSuQ40KiknJ0Dkckczfk4iYsD4hh8hkKlFSomUuirhugJBwIdH1DqUzl8l6R90YhOqRYt0RECh1qnmvpNwYl4nVOWfzPZ1yEMRq3U25wrZx702n1/mshOaDBmacdgBWcKTNtV1lJuvK9JoIm1i/J6vN/8HS9QMwtO/Csb7v1ycg51BnA6nNaXoA2rB+yZqwLTadGzZB0vp16/FgHJlWkJRVQpJWHYJVnfT0GqymbjzVlV8rTf2Lz/sGCAJCoGQBjFbtJtAyd8wK3aB1hdQv43UkDonYOcL8kPl8Ti8OkPV9Hr4aeGT3As32wzT34MZiwbfuDwziEh/9+Ed5/ZUXuHf7Ju/sXWbr2h5aGLrU5W6Z0DkAJBEIeCK71ZN8881f58nHHLF2HIcFURxQ7QimuuT163do545zE8nOjiZoxauvnGS48jCnChYhErPgs6hIU+BFJIaAW92zIs7ZHjUUxS6KGcnfww8DcdCoquTu3Zb26F1kKYnRIqOjKiwizTh/9QKqvEbiBOIBKbQEdz/zJvk91srvwPFtCXwCpTXaaJzNLsTD4M/AhXLMtwnExZmixPuc62f5NpuOWjq7bqTNmrNOjEMIm1dv/g/BAx3M7+a15v2M95UcSAlNVYIS3Lt9xI1+QbVXoZSmm/UIIuVuCckRkgZrUZMGpMT2LuODjzP7u1v2VBKwgc4NdJ1DVibfJBIUuRoUtKAcVwQtsodA77Lqj9H4KAgpexAkl3AuQxIQAqU1QkHoPckDRUQbkXHJUpD5JHmy+pBIQ0T+P9y9ebBt6Vne9/umNezpzOfO3be7bw9Sd0vdAk0gQCAEQgw2CCe4CEnhxHYqFHYIf+QPO5SxDXY5UElsHNsxKUgcnCKxGAwYMQjQgAarNbRaPd/uO/Wdznz23mv8pvyx9t7n3JacNAVVofVV3br7nLP32nuvb63ve9/3ed7nCRCjRGhD0kvABXxlsZUjEZHx9hSlFKFxM0+Czouh9pHaRqILJLozayN4qGvSTNNaS+M8SkgSFbAu4MuaTM78GXRXyZQC8p6hbGFcN2SZQOgUpVOkUNRtg4sBKVOCsLTOgVcMMkGSG+q6ITQ1KgRUjAgMPX+pWgAAIABJREFUeaoJWUJZFMTGI1yOjJFeP6KSjGr3ANcKZBQoqREioI1Byz6JpAsIQ+x450ZSFhVBSqRIUDolTzPSJGAbCypFS0GapNgYaGzdVUkF9AZD2uAItsK1DisStDTYdtboTcSFgFSSTKfUTiFNghZLaHUCox/FpG/GZBPy07fg4T3KPUv5ouPy5z2f/WzLMzst24+/xAPvKjj5QOCb7nkn950+zc//0RP84bOXeVhoVh9YpfrihK1nCz751pd454kH2Jo+wz2D0xwiiGJAhsH7wE7Y4y3L9/B7X+rRJILTG/s8e/Vp6mcDq48nfO2FPr/6CyVXrjgu3K959F0p5YkeH/zQc7wyblm/WfLAjSlvucez7go+9tIO3/6WM5SywgbLblsTYsVZ1zDYeIzDa0/i9p6hLm5xOG0pL2WcekvKR7+wi7oeOPfABpv3r6Flw7vecxapxoTJ8wi3g0pWQK4RaAitoG1rmrLGWkvdOPYPPF7nDIcp+aCHTAJt40B0KFoxDjRLGTuThrJytDHQ+kiaabAtretofF1VGJTRDPoGQ6CoplhAzO6DykIudKdQhUBJgfcC3waqukGLuQIOM1pJd9zEKLxSBBEWC/idm8iiRNn9uKjcSILvYOG5rKMUHb0IHxGpmnHUJUKAd6DznMGwR29tqRMD8N19NRiM6HvoZwlJnuOcophYVlZTdJqSiyWm9QG7+1O2DsZUrcXFAHhsU3fUy0RCgATH9vaULNEoqUn7ORHB9LDC1S1t1UAErTuBBZVqmrLFlQWToqN7BedRMdB4z8Q4VlKFbFvaKtA2HrxHJoDRZKOMxBh0iMS6pfAW61ukMoQALgRa52lkRCcK1e+jbQUhIlFouh6w+VBaLSpkcz39RfwXWZhxzSH/ELtkZT43gblE5tGmuzDm4vieOscnjsYCGFj8aT7vEUL33oSFCOarX83reseO3bmGOWIjjnGsxZ30nzm9J84LZl3/x5wSJiULtODO4/+Hz8/x5KSbzflsiUVVdnG0Y43SfzLAZpZmCIWSOVIktGGKEBlCPoRUd9NTJ0iTiBptw+YObVnT3phy7aWaq1crbldTqt2CtfsbVk++j7ecvoeVseUzN3f5wvYeD0q4/43nuHTxNjdvjxmu73M2HzF1W5xOVtmPLQaNiqpD8aPl3nSND14MbJyONHGPq9u3KW47Tr9piYc3V/mffusFsjzy5nuGXDi/wjgx/J9/9AmutpqruzucqQuGeWDsWi7uFTzWX6YQNU3wxOBQoWYUI0l2nnL3In76PK07oJmCLzL6ZzQXr2yhrx5y6vFH6I2WyHuCk+dWEbKC+vOQjJByCGqlu8csbG3tsXLyzvP7ehpido1736leSQntTDlNSnFUqZ8vJfIYOnBsMZmvBQuq2xwRkBKpun1m3rck5UzBaDY62dKOAaPmz33VPnScTte93+t4nXmN47U1JB8WyMmEfpZSpIL9sefkKHRwsxAkWpEpyUtPbzNQkAwiIaY0VmJn1X6Jwh7WuDLQSPDOEugmpJcbbO0IVcTSGZZaD0tnlmi9Z7Iz7foIXOjMgaxAoPGzyntXzOrMNLRR2GmLNoroHb6NxKgQCrKRxrsOQfCuW0ATLUBrYhS4Sc0oN4hE00ZQGnqZ4uBGweTW4UwOVWESSWoUZYhUY0+aJzivOiMN12m240tSLUikQaUpQSp2rtwkS3tkvR5VUaFgxtWG4C2ba322DyuKqjs3UtjOOyFJ2NxcpakKGp+QJkPSPKUcW7xvMH6CMqa7cUIkUZGyN2Rzvcf+jqIqGurxHpWr0as59z3QI6Q5RrRo2/FcdRI4nBygW5Da01WGBFIZlkaGg61pp5ARGsr9A2RZMeonmNhy6txprB0Tmqo75wIaJbHjlpOrDhVaEq1IEo1JBAbH4fiQZaXxTTcRKs1ROiCChLbCqB5aDlByGSVPofqPY8OvItwvM9zcYbju2Xg88Mh3WJ77ZOBHf75l/zev8ci3/1u+8Tt2eOtj7+c/+/Zv5ZOTK/z+v/tFbn/qJg8++vWcvOc8F3/9d1j7QMm55gofbRP2e4qHM8ljesATzjOMlufbq1z4/u8n12u8/Mzn+dyv/g/4UvCev3uCk1phEIwe6pG8a8in25x7zENMntlGasXpd34j6i3v4Mlil2S8y/kLHjm+QirXGfVW8HLMzWf3WdtM+eK/+Sc8/9xtru82lK0iqoQmm3L+oOSdb8p4yw//x/TiGOrLJOt9wq0nkZs9ZCKJboqvKhDgm4AtewSv8FFio8IrTdoDIU1Ho1ORWgaiiljr2b5RYOsKX8H+nmUcAjKRjHopq6MeW0Fy++YE17ruPu0nZIOM9fU+xrX44JnsN5QHNWUjKEvHynJGlIa2bjrFB61oC4tJoS0bbG3xs2bS4GfJJSyq2EdLrlj8J6VAzBZtAG8jUgmkjLjgZg20EpNoTCJpq9B5eDDjqyqBNimSznCPJCUIhZAarWUndoBFmh62bQlMUKbH8uoQshyB64xzpCYKSZIYBqt9jIy4qsSWKVXTcWSLuqVtoSw6aeOV5SHgqWvXVf5bSGSkKB2lhb6WbPQVMrTsHgp8osE6RIwoY+gP+9y16ahdySAz2A5AwhlN2htAqMiGGYmICOe7PiLv0T1JqgQNkWbS4GwgTQ1pL8HWNb4VaCHJU0kUkYNjEphdgNoZOM5pQ524Qhd8z1HXDvqPi0B2EasCsxcfzeaCOnRUhZ7/Ps5hgvnPx6p40DUXzoODeeXujq15QSH4atiyjzV0x5nPwDF3VgGdZO1xd+NZ8V4cQ3/mPQNzd9e5yopcIATHUR069AcWz58fNwaOeh2OBV2zQuoRXelP+h0BIRQIRSZWacMYgUaQI9U7kfJRQnwG4q+RDndJ71/hDXdb7jlouHHJ8nO/ecjubz/Bu7/P8ZaHv5mN5Tfyzfffy+Vmn48+/SGuPbXNu9/+XmL0vPLSs/Qu3M2qP+SWWOaSrHmjzjFoDiLo6LlebfPOd383IhnwzMsf5qlnP4KIKd/1gfvp0XktbLxhA7+5ysV2BOUqSxs3SddaTr7hL1Av30PVliS+ZGM9IKo9EjEgyTTleIqfeJLUcePzH+T6pUvc2p0SY49oMkTPcWJ8wP33rnD2vf8FTF9EmhqpLRTPQK8POiW6PZCHxBjwLjI51Pyzf/lJ/tHPevL8TzQB/7+P40H3PCkVUiK0om3srLjfrTFHCOMsAe5+YOG3Mr8W4Y4E+qgXo2OHLKr+c2okM98WuvVNCrlYgKQQuBCOkvNjdLuvCvriaxivKTmohKDykV6UnDl3ijCZ0B9FVG1ZWupBa2nLms2TA4T3rKznOBdp2oAPAa0lblwxHU8xUiIF2CpQN44oYDVXSCHwTTtzNA00LkDbUVPctEZGMD2NyhLauf5dYwlC4mNXATfad5QGEWnLFqW7ZSi0vrt4tAQpZj0HEe8FtfUkvc5kTcRObSdKATKS9TImBxVBS5oQyFTH1U6ANNc0k4beICUERZRJZxTlI7lyiNYjU4PUnTSkrSu0MkQfaV2DixElARE6s40sZXfrFlEnBGLXFCkUtoAlk3PlxhaJivTyBOEExSFkZojQgrqt6eddE7FSkcFgwPkLd1OWNflGStUrsD7FmRG3W8PtvYIza0tUdYP3nf9A0Qiq0rGeK6Q0HYpiOrhPKMPdb1zh9q1t8n5GaD1lVbBfNuS9jCWl8DIj62dI6wlNQxABV5XsHzYsj3pkvZwkESgKbu/vkeU5A5+SatPxw4UmkTlJsoQAnK9pZIonQUlDFMtI+Rc5NPfTD3+ICVdBe7ILPR67Z8wf/sBJfuZ//CS/9/E9/renfo9PP/4i3/PXf5C391NOfu+P8W8fv8X4Sx9j9MpnePubvoWwp/jZ377IT/zwu3g+jnlx/DluyClv67+L0+EpfvbDz/Ofv/uHiLLlk/VllpNd3DfnXHzR8q8uHrD5Ds33PfI23nLP23hmPOHX3cPoNz7P3/yRryWufQO71UmaV57nX//EL/Ff/ff/JaP+LjqZ8vzlwO4rezzCFf7nf/rbnD+5x/l3r/KmjU3WVu8mHZ7iyt6Ys8t9Tg+HqPGXiLpADVPs4SFpP4OmoD1sofJEIbFoDg49TZDkKymTQ8t4AsVUUU09ibZMiw65qoOY9Qgo1tb77OxGXrnVovsSPXbEOmCl4uVLO6isT4ogyTSOAEohUkM1bTg4LJABBr0Mi4IoSL2nLh1SxM6EJnZVGes9Kmq8NEgTZnQk33FLZ+Wf0JV0ELFDAo6ij27xnzOtY8epQCiBmiFv3ncSltEFbIQsV131Z0ZJBIExBoQmMwZfgRWebGXA8tIIX7ZMpw3JcEjdCJSryHKPyXtI6QCHay2ZiSznGld6Dq9f58zdG9x9YpXpfkHQlhg8bWlJRwMmzmOMoJpGfFtRlQ3OO6SMSNlnZVnSOIuSGplkLJ2UxGlkZ69maDTROdq6wWnP8vqIK7cd1bhgut9inaA/TFlaMiT5MoMItmxIkpTBqIfSksNpw7gokQnE0OCtp/KWIAKrSZ9pYTn0LYmM9DJDnh1tBSF0ju7dBixR8s7APc538zh/ztFeIeYsk3hMG5xjlfB5MjEfx9GEed+CODrWHK14NXXly/jV8/jhtWxof87HkbnZvCx6J4Vi3l9zdJ66RDjEcIz+ExdBe/yyeTqiCy3OqZwjA3eeweNJ3RyZmx2CI3O0P90QAhI5wsZ6dixNZAjiMRpOkIrPIsQhIlNkJzT3bjb8zNtW+fV/9zv87h9f5uKzv8Kb3nSJRx/7eu4zhpXH/iN+89we21c+wfn+Jmc3HiRre/zBS9f4vq/J2G13ec49x6rqc05toJsb/OQ/+7/5+//13+KgHbNmr3BidZ+9tSUuXivY2b3Gu997hq89+x3kyUleaSOfb4akk21++v3fyiR9mLLVvPjcS3z2cy/xQ9/39WSmJFUtL9+09OwUM77MR556gs21bU689R7u65+mNziDI6OyLcM0ZZT2iMUzqLS78INtUCYFNybUNdgpQWWUdeSpp3f56X/8FAdj19GGX0fjeHCdpAZjDFJ2nh5GyqNelzBfbBYvPHo8Twr+Azd8t051MdZCgUjMmu1DZAaNzQoeXYFUCNk9l4iUEjPbW2IMM8O/+foiuuLHV8Ni8/8yXlNy0N8Ykp9eIU0NGz3BtUsFDPoYpckGGfhImRSsLg3Y352iGoutLE3lKSqHrxqUTghOYBSdKorrml2djOxslfT7GUFoWu9oGgcI6qklipnBhVZEoxGpJg2CYr9AKglKIgPI2eRHF3EC8qHBNpZgfdcNn3UVk+gi0cyaU7zDTSPReVRmyHoG1zpMLyHpGaTwhLoBBJO9CpdqxLLCDAQqCnxdUxxYokwwQpIkGcYYVN1QFY5MSirrOpoDgURL0jQlEBkMU5IkwzuopCcaSdsK0l6PEA1KpAiVIFqPCi0yCqxzNDagpaAVUEwPuO/8BoNhH9+0CDxKdRJeNy6/TDZYRSSabNSDSjAdFwgZEFHRVAVV7UB0gYGJHt/vEbSiKmuGqSZJMhyCaFuKw8jS+jJ1W0OiyJTBOIHINd47Ki8ZFw3TomBaTklly6g3whhD5QMyeFKhULMwL82XyPJlUpMcax5NaWxJLxlS+BoJaO3I6JMIyS+2Bd9nNmnk+7EiYnBEv8WBvYyWGX/tR9/Evd/2CT78+8/x7Md2+Ff/8Bd54L1fw/u+Juf9Z1e5GB/m5qXnePryE3zTYz/Oib90hn/6zC8wyGomu/vs7+7z4hu/yMGNS+zsneLv/9RfJ1+3FIcVtz9ZsfRXR7z9je/iwy89weqZc3xRZ/zBk5/h5ueusv3Ub/DDP/5t7Kolcp9yT2JZOX8XN/+7v8IXrl/ik3qJ09c/wolQsznIsWstf+PvvZ+09x6mfo8gBgySAWtp4PTpHaTfY+v5D/GllzTrWcnp9DbhcIo5oeDGAVUCIUuYVJHxYWC4nHHy1BLjXbB1Cs6R6YAeGXYOLMW0xfQHyBmCo7VkOikYDDOSRtMPdYe6tQFrIz0B/ZEmmpQKaKXCR4GvatrWYrTCuoAxCi0VIAhOYVKFc568l+ClwAaIJsW6wLRqEUFgm676jxDoRONa1wkOOL9QiDgGHBzRGRYVHBBKkKUaKTsFNGtnr3UeYkBpQZC6a3JMU/KlAXkqSZOE8uCAutL0ZMQMe+jBkDb2sToj1BX9JKHXH5AZSVVMMFrSFmNsUxGdRUuJDIpyv8EJQb+fkurOl2HaKkJlkcGjSEnyHo0vsc0UgN4oRRsFwWGLOHOc9oyDZP3cGsNNS6wtbVlSVQUOy9YUdrYOKceORGlObo5YObNKlA25UlTXdzBakvclWQp12yIziSwsiVCsDlKm0nE4tUgb2D1sSTPdFQcINNbSTN1ivV/w+pkHoMejyCNd/Ds25gVQMKvyz2F54h0B57yPYcEBPv4aju238Sj/OB5MLN4z3vHf8Y/xuh5HzLlj53v+c4yd2t2xcye6J8+C/SPk4Mt0VRY0i9mP87jr2H0WZ0jRkcfFsdd3BIA76Bt+8RmP6FB/gm/6Zd/bkNHGhhAdlsiXfMtjckjLO9BCIESLDxNsPECIhPe976+y9uhHeeJTN3nmqZe4tX3I+Tc+wmNnE751dcR1+yCT8Q43pjc5v/E20gffzIdu/BHCtJwMaxwy5UvxcxxObqO+7h5+7oP/LcO7erz05DX26jGnvv4k4uV1Lg4137j6OJ9vW3ZuPcnWK7c4uFlzb3+Tm81drGrHphEMLtxFurHGC4f7fF5mnNt9gmWdIXLJ4EzOe+7/VrS5QBsLEANSbRhKx2qsEL6g2Pk01273OTG8Tup2IFTIPML4Nq2WRDPkc0/e5FOf2+bJZ/c5OHSUleUo0/vzPb5SxT1Jk46RMFvyvfMsOs+OsdqART/T/FhHiS/H1qnZHiHFgsq4oKHGSJRHal6CWW+BoOt3i3fuPR1K2onfHC9qLPrmXu+Lzf/HeE3JwWBtidWTy7STmude2GZtNUVpQ10XuKqrICIC0dacWE2QbeRmUeMaCz6SpLozQjUJvq4QWiJSjQGUkWxsLrN7+7BrdEwTQhDY1nUGZ3Rz5awnkRn5IMdOK4yEunbE0GWDaqaUJJMuaAkz8wopBVp1vGedKbQWXZOwEjPZN4/RElu1uMbQzzS9VKBEZHJY0wL9viZTfXBdQ6YymmnlukArCwTnCE1FSyDKrnchTSJta5lMLS5Akif0l/tkUVFHj1Sqo1iESJ5rvPWoLMPkeafoIyNZAiZVLA0T2tpgvaQ/WibJcqqqpfWB6WGJNBoQaKE6igkdLas+PGC4OkSqBKcNXmtCbWkIqNEKQVii1hgd0bYgSU1nPuUlNnQ3mRea6FqM7pqKTZoRgkAGyUAqnIDUgEpSSilorEW3BhciReuZVi39ZIAWCi0NQUhcVCxnOVJlVCGiUGSy6zuZNDWoIUYJnKtpg8cZz1CnfItZQpByNeyho2UYEiInGWUP8kTxO9ydnuGhB7+fcX+L/dNP8sqvfYzipee4ub2DHwvOPHiBsxfO8+LeLh+/9QTjrd/kxi98CqUscSPics/Bv7/O8n9ymoOPf4nxtQNW+xok2HGk/EPP0w+8lW99z3fypas3+OyHnqC8dhGVRobffJKPP/ckxbXAucESlw8Trl3NOfOB7+ChzQHnls7w+b11fF+QndtgW7Y8snaBVK0Q9gI3p312JoqDUPDwQwmYk6ydfoR7wkWKgx7Xq00snp0vjlnVgipLGMk+aW5YTiV5olFJjmgkaU+zIgI6cRxMLQNncXXFdLehN+ocmkNiyAcrTHwgigJvG0IbMUrR6yeIssU2DakCg6RpPWXZYquWNMDKckKQCu1mTf0RdJpgCB0H3XRKOCE4lJYURXetL25oOnRBzhplvRd4xyIoXFCd5UzeMcZOlUx19AmTaoSEtnE41/kjzDXwoWuelpqObqcFvrGYYZ+1s0tY79FKkmQCcGgDkyAprt7m3EaOlgl13VC3EWEkSeUQbUtsWmgadGjJ8pS2cZTFmFy0kGusgqawTAqHlAneR2zToBLFaGMJa1uMNijVMp54lDEoJTp/kqYlHRuq2qGyDAZ9fKKwe3tceXGPybSmLQP5mmG4lLCy2ifLcsZ7Y5rWUdceHyP9gUcgqQ4ryoMJcpQTlCQgSDKDUpHQtnjRMBwZtDGExjPeni7W+zDfCGOkA4zETPBGzObtiNozr8b5Gd8d5s/rOPKhawphTjvq/s7C0Gg+Xk0IWgSp8zdavFZ2lbxjycqrE8nX65hTegQd9TUyM3k7Cpe6uZmX72cB+zxYP36y5sDDIpnmSIn2VSDMMbpEmL1HQAp5hEIcj8Jmv5MzXvaxo/yZfH9DggNCbLhPpng0u3FMD00nSLqOUpvcsM+zbta578z7Ofz6Wzz7wvPcuHqJ8e0XuXK4hRh77n3gYVhbZyfAweQlbk+f4PqHnqIdTBmeGtLYhqpuOPGWe7i58wR7u9d54OwGVSwZb7WkTwvOPv4tvPfuTf799pgbVz+NL2/R7xtGbzjNweSAw6c+wUPrF/nklZYm2eShx9/CWpqyki/zzN6Q9dVVYqaplGQ9X0GJnFAKDtqcovIMU1hZMaBG9Eb3seau0TQr1DFimy2q3X16StOYnLy3hJeexh0wmXYLqXNfgYr553wcN9bLsgw9cwIPMVJMZ+vQApgUd1zHc3rcl8Xld16e3UPZiSssEgDEonDhnV8gD1LIRSHDh9ChCzIsPuNxJE/MQYNX9SB8NY7XlBw0zlEVJcXehMu7NSfvWubuPGF8ex9XWZRUqMzgi4rV08uInmJrtyFE21XzpED3E0RddU3iQqBTjc67JufUCFKtFvBpiKKrYDYOdERpNWtWjojW4cpO8Sc6T4gSMdu8ohVgA8GFI+k9KUAKlBAoIemNEprSdYoOSkACiaFbZYPvAv1gEEg8IFNFf5hC4hCx4xsbo/CuO7xKNEZ5JIG2tThlUP2UVAfqadM12giJShNWTiyTe5hWFmsjlbNEEUkSRVN7pDJdYiAkKEEUAZlo+sOMfJoTJk33vULASEk0Eh9cJ5XqPUJLUIogBY0LjMtJp0OfpkStkekA6gn9LMMHhZCGGB0+dpxyHT1F1YDQBK07WlMUaNWpMvkAw14f4TuqVgiCiKKuW0wKOA9BIFVCUJq6tUyLEpMYGqMwEpQW9HtL9LOlGZVII6QiCIEjUnnIYsS5Dt5DghMtiUzZkDn7YQdDDyIUUWGjZMcJMnmeinWWcs3Ddxsqo3je5pjl29TjiptNwZbfIy1TxsUBlz/yQSYXP4O9vUe8G8gUPkiaOhL/aBs5qBm8Ywk98uRR8YbvPcG1Sw1b7QNsLz0Ea7ucv3CG7NQjbPUPuO+hU4jdm2zffJLnn3+F4uWSm7dgGizf8WM/wqke2PvvRed9lpfXsY3n49sGebDDiWRAoZY4kIprey3bH/4ihy++zKMXSpKNHWoVGVvPeGrYKyTWa8JA471geWRYGiYIFFURQA+RQUBsEUKSDHoI0wkFVFaQmBSBxjqJV1CFHO9qcq1RSee8mmYJRmsmpaXykTZG6sZjmwBRYjJDEIpZ+NJxQwGtIDqPlF0hwFmL9xasJ8zkUf1MulJr2QU5UuB9x/E8oorMg8xOu15queCdd/+6qpBtO2OaGI72hDtkNONsgzASoyVZpkAp0kEPoyHtGZQRBBFQicFWDcKkXbPajLqhdYeMIaD1gtpGGheIWhMqSyiKzm8BhZSSfj+jqmuUUrSuQ0H7g4z+sEdVlggnOvlXZegNeuhUUTQ1TWupi4q6dGAVepCitEYpxXjSQOjsXIzpKI1ZP0W7kiwFPzvvVdPg6XTDm6JGyUhsaqxUuBm/O7iu+S5IS6J6ZD1DzAzFcm+x3ocw176f8WsXNCOYB+PzJsFujkS3FszW78iRwOi8UXmuEtJtqnGRaHR/Wzz8MtQo3vHg6H0XSIOIR797vW/Wx5GxKCAu9KIW3y0e++6Liiiz9GH2x7hI5OZzIRbiLHeoHx2dxKMPMA+GjslHLqhh8/lj9jkXyM+xz/mnHFJIRJTEKOgLQxUKEpEToqSNHYXYh4iRa7T0GCaRC6fOooXh9mAZNahwjWU7mbLjC6qo2Sp22bn2GQ5vPoUr9lAbgZ2wT9lGmjJQPR1JBy3rbzwHmeXuB8+yuqo5cEPs0gXG/TPk5T4PnhT4uEvsCU4uDbEHt3jxxiW+8MJlXr4yofVXCXXJX/7272KkI8WJMywNlzGq80B6bj+ifcGqziiioY6a3d0x1158gfLySzz05px0aUyBprZQN4aq1rTO0CaaFy7uc+36lL0DR2sjzoWZse/rIy3+Snx9JTtqaACUFNR1M78M73zuq6h1i2MeHXx2GmaFCCG+rP/gVRkxx39xZ+Px7N4JR74HXxG9/Cofryk5ONw5ZLsXaYqGcYRQWB7cCITWd9VvExFaE+oWTgmQGhtkF7jLTo8/0ZI0iyhtiFGgUkM6SHEBdAzk/ZSmdQTn8SHS1p0ykBQSkQoSLZDO0x6WNJOmCzAUBCE7qDRGbOPxrYfoZwoaRw0kWimkVCSZIbhA9AEpQKUdT990UkPY1lPVDo0gSIFODEmqCCGQpCmJ0cgY0M7P5DolWSKJrnOcdUQcXSO27crvpHnCaKXP8sqQgVSEvYpy2lDbgPCdQpNRIEKkKRtMnoGLtN5hegYXA2k/o6k8BIeIjjxLENKTJAlRRqq60ysPM2tTqSJFY3EHU5SpMHkfnQ3wPpKZBOe6DSj6gMMhYuc+7V1EpZ2jrI2C1ndus01VgtEMfNdc7mOgah1SpRSuohcFvm66hugkRxnF1B3iWkuoaxotUSLQyxWD/ogoEqLzJGk6QxOAoHFofBD4GLu5RRG8pI4GGxTjULEilimi5iAEVHTs2ANOmwfZqQ9ZUjts6oSvO3OB9n2ASeqrAAAgAElEQVSb6Jc+Sv+unEt2ysWdkmsvP0uY7nLwwpdoditWHhWYRzNcLmnHIM8k1J8vSe7R9O8dQFmh0Gy8bYUdO+b82mmuhSVGd23w+INv5O6s4kl7lc1o8Bu77FrF9cOncWv7rIwE21e32Xr5BjvlFv7UKVyyxr7fYIDiozdfZnlqOXlilRNLy+iRphCRGy/Dzaeus/3089z7tRmmrylKyf4UkqzP4e2SfpriCoXVEpsmoDRVDflqZwLSlhFrJenSAJUHnNCo2qOkIipF7SLTpqEShrYFozQy1QghSaUi6yVUhWdvUnfXQYiEAIkxqCShaD2xhSgkkW6+cAF8RCtIpCQKCR6k86RaEISijRAIi1JmiAtlTI78PbvyzHyBF1IiOZKhiyHi2kg49hxg5nAOiJk0p+rUL6QElUjSRGJbR9JLyTJBPsxIc0MgkGrIlnqoLEPqBKMUKI0SEqsFTbSd4o+LtKHbzGKYVe6EwBE6kyWjyVJDtI6oFd53PPAsNQSfUbYNdQNohUkTktwQtaQpbVfBalt8bBBGYHKB7KUYZ/F16NZNE0F5fGxpxxMELTJTdCrNjrqJEDsd+jxLCG3X34TqzoNtu6KJzCWqa9FGJprh6nCx3seFLv5McdYHjDoWQHI8OP0K+urHKtp3BASzGOYOI63FC45efvxox3OSeQX7OKJ/Z2Lx1YL0z+kR8OqsZ/67sJBUnFVE5wnb8XM541eLmQPtHGE4HvjDMcrEsdz8qOfhaL7nsdfRG88n5egz/5mMKAlobIy0OHoMmMaupyJETx0aRuoUY1swVCUnVA918m7S0Rri4BL9NcNlP+Xlwz2auqCY3mDn9rNMd/c4f0GjL4xonCJrNXUhmF49YHCuz+aJTerDLTZOLrO8PkBsazZ7I16JKSfWT/HImdMEWbHjCnqtozHnONAZV3aeI19LUKXnxo1bvHJrCz89JDlzhjE5/ZjResuL4z2WgGLUY5gqSBR1c0i9U7L3/GXayZizb14GoZmWcFhYiiJCASIPfOaJ69zaLrm9U1DXvuvZ/JOyuf6cjSO0rFPDm3P74ejSOrrM4tEF+BW4jQukkXmOIBaJ8vFiREc7mnuBzBcPYFbomB8jvCopmD9dvD5ysT/1eG0NybcPKQcaeglLg8D4+gEHqwJSjXMdjSD6wO4UBvsNoXbs7ZZ4H8mzhNZa2rJh/VQf5wSuDggl0QPFtBIYIlEHlJJo4RCNJyIwSecUrFUncxpah3URbyMmFQyWE9ooCTZ21tuNw1aWNJcEOr1xKSB6CDYiEkVdOCTQOk9wgcR0B89yTVkCHmzlsI3Huki2OaS1jsQIhAoI4cAHqqKhndYkfUPa62g0NnTKya6xHFQ1ddOCMoxGOesnRuQyIe/lMPFE47oM13mk8PQzTTNtaWOAVuK9wEVBTFO2tvYx2agzlMsSBoMeaZowqUDInGBbvO7MPlrvMTEwGPWR4wQfLKHu/Ar8uGRalfRzzXAwwLcW51qC7AKZLE/IhjkxttQ2ImJnNlW1LbFt0E1Low1pf4hUijq0pEYjSLEOAoI0MfTynLSXI4Knry2pUojgic51qISI7E/2GOmc1rcEnSB0QtR9lDLYmGCkosNjDEpk1GTsBIuJJyip2fKBfSc4KRUXsnNcbGtevP0ZRnnCQ6O7WdLLPFNdY/uPt/nOv/A+vm4I09t/wKXLn2cUS5bPCux35tx3NsPqJYLWZAaGpk/5TSnP/5OnKS7vEAeCQ+G5Vm2xdH6J7z8veCLNeEUapBKclYa+eogXmwOu+0PuPvkwJ75nnVpMaDDs7z3IT/7E38VeLhh997ew/Ka3c3rzPh4YDAhuypsffzOfDgNWeoY35JK1s/dw7m0/jvtrP8hf/rbv5f6dPe5ag2RJUw5z7r5rxHSSoAYZS31BnmlcTIkxpWo1phFIS+d9ECRaCIJMkalDtwVSOIKUBCvY3nZM4rRzBHeqk+E0EikltRf4oCimlqg7lGC+KhbTltp6VBDkve4eC7WjbR1GSvpGoYOj8R11JNGSJNc0daBRnrqK+OCx3hF9h+51MX0X6MtZ8L0IOgWdEsusmh8jBAco0ObInNCHjl5kZt4mqG5DCK7FOomzgaStUTqhN+zTX+qTZ71OxtOXLOU9jJQIqVFGg4w00wlBeqpiQmgdRnbBdNG0VAIKZ5DOIXV3/49Lh9YpVTFluLFKU1TE1tIULaAZTw+xViDaiig9qUuRWpFnAxjk2J0pJms6U0WRooYjRmlg95YjEmgJTMpD4lZLnJSoxmHyjLaRSO8xInTJlNZEI3Gi480mRoPU7DUNSkM66qN1Qj2NROGIx7YCpWSHBgCiE4Pr6CyzEv68khZCpHMXDXcmAMeCUylFp3gzg+Tnm/mcwrIY4tXVveMb86yaLo+Ui+7Ym4/RFF7v48tpDK+OQo4i+KNHx2hgs5+Psqljwf/8b/EoKLuzInosEVjMYzh6T3HUbzJ/cKTi8mfx7WeHFgIfFUW0yDikxTGeSU0OhGZFZ+x5y43JdZbzEaeTFBsiF6uS4tKYdzz6GI+lnudf+W3Kw0vksuDkaY39mnXeuDzkQJxAK09PGVL6FA8JPvt7H2NnKxD6kp2bLyMJnF47zzcsea7kim0EWgpW6TPUGdtUTEPL/csXOPeeE1gaKp+zvav42V/5JcbPHXLvX3o/JzfPc3dviQ2jMank/PomT4aUr00FJ5Wgv3ov/Yfupn7fe/mpH/kR3rRdsbIKU6m5MfHcuD0m0YrhUo9Lr0y4fvOQSdF0fVYuHEkGvw5HjBFjDNokM5rhTDJ5jp7NstkFmDjbf+a/n4/FPRLiYs3vkIdZA/JMynq+gi3Qr5m0fYhxIas9v3tiOO7CeewzL47y1T9eU3Lw0F1LPHBhnUIkrLrIZFDiQkQPE9JU0/pIADaXe5Qi42DnNlJJpA/Y2tEfGvbryH4VOLOe43qeomg53Kq4cbsiF5AvZ6S9hNJZmrqGVKIlKBeILXh5lA1muUJISTI0hKIzHWkKi6sdrvG0tSUdGaSCJFGICPXEgrO4YHCVxRgBUjIpHeuDIUtrA8pqAkRU8OgQUDYwMkusGoFMEozRRB+omrprOMwEK+s50QsgYGIkWE8mPWV0CNNdgHgQFQyHCXu3dpHSkKiEXuJxLmKsZ5RptoXvGrZNQPcS+ial30spDksaWjaX886wzTnSnmS3mRBEV6Yb5JJeP8H0UpoWbu9X+OiwbclwOCLLEmzdMhk7ZAK3br2MEhKlBMoYdDai8QlvePwMr7z4MhMX0YmhpwTWtrC0jB0fEItDvPAkgxEnNpfY260IEerYIIxESY8OU6SPrI2GJNKRZQbbTCl9jck0A2U5mDqadJVsqU+qe+Qqp29SGu9QZkgkYIg4oahFypLQpNHySuyzLlKMrBmqmkkMvNxO2aTgPaffzQvjZ/jItT9A2j3+0X0f4Efe+Q7+4Y/+HI98m6NZbiixbF0NnP3BnNVU0dt8gHcvrXDGnMGLDWCf9uRZqp95iN/65T9kyx1ysBW4/awjvK/if33yb/K33/5LfFpt8FwMXLSBc7Hl9t5zPPXs/8XW711HPXwf8RRMXv4s5cf/Be1TE0IT2PkX/5qd+EtcFJKnNtb5uV/+57xpNOAbkpSnGrgcBE5IVpVgpXeKX/793+Bj//vfoxhfQqpAtXNIW2Tcc/8q4/GUsomofEC2tEyMikR4ZLqCSg09UeGLirryTKdjdArFeIpSENMeTUjZHwea2rF5doTsB3AtCYFMSYqJY6dsGZ1cpSmargfIOqY7JTLC8tqIvZ2a6B15L2HUH5AuOZIoSFLNZFp2HP0AIkkwuaGuW5QKXTIQO0dz7zur+naWJAghEaKjscy1qUUIM5pFXGwSSncOxyGA71Z6Ip3E6XyzkEiUB2UjUlleubaPEilrm8sM0yEuT7BZjzNnV4m+xjvNYdEyrVpyAyt9gahKkCmrG+fIlYEoKIqS6vJltPBU4wIpO2QUoVE6Ixn00blgNNBUrsSVTcdxTQTGR4iO0reUt8cYregtDxFacfDKLrUyuBBInWcp1iRSs58OWL4rZ+/qNnvbFfW4YmUkSXqSodYoCeVhgYgwHCSMegrVX4LWUrnIyc0RKMXWbkHqGyZjR60FedugtMYi2R+Xi/Veiq4aLaEzoZ8Fl/OAdZ7IKdVV4PzMyOrOIvLRBnpUgeuSiUXcGbvEgtmc3lGRi0fHWzDFmLfZxiOU6Njoqn5fLRv3nTSGVxdKlVIchTKzZx9PEOIRN3vOqRbMzNOOzc8dyM68MjrDIxaeC3LuScIsITxK5sXsWOJokv5033qGDAU6hbIDDEtoUtEShKeIgR3fMhQtjyw9wpXqMp/b+2PWzYDvXnqAf3PuXv7OP/4/+J7v0hRiwuWiJQAPXBiyqQ3p4E18dzIkESdnCbHDD4Z80w88wO9/6teoh4IXnnZM6ob6Dbt8dO+X+cHhf8NnouDZGMljoO9qtvau8IUXPsLetZqlr3mYib/F3s0XOHz+Cnuf2qY69Fz/2z+NiBKTZLz1rY/zk3/rxziRJpyXkksWDmaoWyo1vf4af+df/jw/9IHvpLUNg1wTnOfW7pTWe8qqRsRIawOtDVjb9Vop9ZpCuD9X43hCqrQkSRVNEyin9QKh6ooRcXF9L2BH5pf40fV7vIchhjCj0cWu5vOq5yBE53sAC/SNGInz3qhj79Ul0HHmCh4X7x1iPGro/yoer+nKur1Xsbw9QeUJQUJPOPL+KsMUimnD/kHL/rhl3O5w6tRJykxz6vQSPQTY0DVA3jrkxP3r3N4+pNwuaKsGJ2G4bmgKTxUj3jUoPEu9hGKgqCYlKkqUUngBUoFWAqEUyUhh64BrPLb0NJXDW7eYcF93CkAy1aAVXnlc46nLBtt60kyRDxRZrpgWNWxHUt25Eqe6M3CaBkHYGrObKYSoSfMMZQwuJrCk6KU9LBKtPE6AI9LvabyzxNSgnOt43MYBJVnaIDKNaC22abFFTWwtMdFMK82o55micbHjFyeJQMmapbUhOh1R102nhpQprK/pJ5LJ+JDVE2uodAQ+4GtLSqT1FaNMErMlKqcoJh4tYHkA9e3bjHcKlpb76F4PFw1FWeNsyU6/x/ZWgzGSpGfwWY5ZX8VWE/IB2AjeBvy0IcSMteUeh7vbRBSp6REEFLbBhIZU5+zsTtHLaUcXIyDkIWath9Q5VfQ4a6H1JCJQBU8lJL5uaEWgDiBMzijJqITmd9uCbzAtLlpEKMhiQysyHlAF+zHjmfoAHwyPDc4yChm/ee0qf+PhC3zwn38nH/6V36G+vs/yScfpt2msDnzg0UfY6J3liribZ33JqvwixAN69gs8E97MX/zA9/LUi5/kE89/iUOvuP0PCvIfeorfevCnuGfpP2WtvYsvTfaod79I3P4NRHMPS++5l5u/+rscfOLzUAZiE1APGLK7RjSfOcBvtQg0ZezxD34j5X/5K4dsrK1wXxBcs4KdKBgtd6pOWbLCuW/6AW698ARu9zKbZyxlscfOfsVweQNcJJg+2ixDDIztPsL3qYqG6CTIBB0866dXqYRn2B+SZwlSa3qFwwZDrQS7hw2iqVntGwySclzi6si5kyMmhSeaTipYC4MWOStLCbZxDIY9mtpSFJ42d7Q+dA23VlHTo2oj5XSKixWDlT7KWqrS4m0nLSdnBjWudd3/zoMUSN2hBELN3HrDLHHoystIpeiUJiIC1VWmxZxy1FWMklQjEjmjFQnSJGM51UwLT5InVE7gDhqcnbDSMwjnMMsK13gG/ZT+IGGQQ9SGqlVoZXBOEVqLnTb4GrxzbNy7jmjbjpZnUtaTjL1xRTu2eANN6dnbK2iBzdPLmFhStJGgDUFDZRva7V1GJ0aMMsFda32EiuQyMPh/uHvTGNnS877v965nqbWXu869c2fnjGaG5AxFURpKIk0t1sbYgKPoQ+zACBLYCCw4/hQg9lfDyRfDQOIgQWBEiJ1ARgzDCqwIlmUt0cJlTHI4nOHs+525W/ft7trO8m758FZ1970cyqPEQDB8ge6uqq5zqurUOe/7PP/n//z/VjCoLUUrWDQrDpcN7bIjOY0uCi6Ma2axo7+xJAYgClbL3L9xcSzQRYlVlqPbXe4b6wLLVmEKQ+wSnVFsTYfUheGgOSnn+5CQ8uT+pux/Ql3JIzNcMkqnlMyL+akoVqmcONzhhMydlKDTdJbTBJrjV9kEnyoHvhvt8w8bJ1SYj+lYN0VuGi3EXUH8MS1iw6U+RSk5TolOZVgbMA0h1gGOXAfxJ9UJIcA7j9n45HBCxVB6nfjB8fNTzJWpTSAVT0mq/vsYt6OjTZEkBK9ExyMi4IhoOgKgENTC0aD5IKzQlDxansfFyI12yZcvnuPM3/xp/vGf/EvOV3MevD9SjjRaK7507kkm+jxXOUedblGIfURq0DHxrniYX/rcX+ZrH/xLDh85YvVWxyu/8QGDLzV8+8KjnJef51avudHNqNqr+MWLlPUFLnzuDF/557/G/P0bpGWupo1+eMyFS2d5/1+8ip9FtB5yK0749e/AX/9sQ11VnIuJA6/okFibEW6jazox4p33b9F3Ldl7Iqs6CrlGwdmg3esG84+ZjOnpkUgYaymrkhACfd+h11RMJWVueD/+4cOj8dOTxuk+glNzQd70pNk/hnjy9ONdfPhJfKfIAsfr1untf1DHRzNBW/TsX52hq5JPPXGZ/ULw4vUlD12aUFYGNT9iNVthhOS9l98moZm1LebciHpasVz1+FIy3hpmOc3tgtJJYgj0wbBQPbODDhEksc8Oj5USRC0pa4WSeaHRRqK0wDloZj1JpWNDJKUlvgNIFIWmmhpMZQgqN0GiJcJFVKEROp9EbRdwIVEUidY3aKVplSHKgmpgkD4wbyJuGbClxbYt1kZMaRE6oqKg3hrgmw7R9UiTkFbQzSJdiEgZGCiF7Hr2399Hu4gvx8QYkDKiqpJUVAgNLBZcunKOl97fR8RI8D2LgwVtUox2AFmCSJRWUNtsUNQrTe8W9CExsgVEcEnS+IjXQ+K6wbjtPEYbylGB9J79m4cMt7YpBgZTVciiopYW10f29mc0boZrPVpOKccVPqwobWJgK7S19M5nqlizoHeGeRup6wLZd2gBBYkYPK5bMapqrIByXCI0JNFios/N1EqRujlNigTv0aYCXeDomUfBfheY1AX3jCw6Rf6cMvQxENNRVpdJO8iomWE5DIHSebCXeZ6a79zs2Xvh37DlBN9+4z366SFpGplVBdNL9/DfPfwLPJtu8p4zDNIrdP4Dbvjb7FjBm21PN7jEH7JDOnuRp+o5T9/zNv/k2Z4bX13y6sO/wfDBb7NTXuG+/S2+8WzL41/6K0yPAjde/oeMH3wdU0raa4YQz3Lvz/1lzH2XmP/FPVbXXuITxvBf/cR/Sje5xP/6h9/kkXsvcnlrTFFVjCNcbQUPlBIpDfddfoIqweFkipYrRqpn2uzRdYFFn+h6x8GhwxqJ0mNu7y9YdgktBaWp0KVi1SRirSgmE5Jr6duWftUROs/ZS+fwYZ/UOUalgRCZeVg1HiPMsSuy0QKdErHP1bgQI6np0VqQJMTgaRL0MSJ8QGvFeGfIcFrQOo8LnsZ1FFaDFkQhiMllSlJMiABSCWIK2R2X9SQs1zr7Yl1VUBKpBdFlTEkamRMI1koWKfdGRASK7GuCkiACvYezVy6iigKpJUVtGI4HdE6yXY0ZjLYQoUVoySpIjItsVyOilix7aLtICpIgSpZRcXBrxplzU/SgxOgchDV9pBYCpxPdYkEXAkJnmlUzO2J1tAQEKklMUaLqAiM7BiNLvbXDtvJ0bY+PkjZocIpaLmlDiy0kwhRU45rx1pC2yd4GvetBSmxpGNWGcV1glc5o3GyBDyGbKsaIiJ5+ERmf2cIaw9H+nAAYThxDlRTHK59cJ2N+reKR+VrpexqHSRxz248X23Ugr7T8npA9+lML9KkGwJN9CjZ9J4j8fCHF8eueZjFtbnzcucCZznC6YnA3Gi/uePKHKTZlZDPeeRjSZl/r0gAnvXgpJcTaJG1TMcivzVrP4xQqu0H1jxuUT+G5/55gVIVEk6XJHxISRyDFhlkyxKQzNx1NkxJFiASzy3O94IP5O6z2n6V0gWevv8fuVscqRW4VUz69/SBfHj/ODRpuBcOEl1mG63gaCiE4CIFgz/McY4rpY/z4EO4Rb/GbN/d545UPePjiP6YcP8sl+QBvHFiuziyXz3+Ws6Xk2s1f4xNPNcwvF6zmA4S9j0ee+CLl7jY3H9tndvsNPr91L1+455MEO+Q3nn2R+85uY4Nj69x55PaUhdKMVf6O/v7f/wf8rf/yb/Kd579DngPX30PKPVspxWOn32z86j4WCPaHUf6CDwihs6+SUOs+UYVMuS9NxkwxgnT8mU/Ag7sngPXtdOLhIQQopU+xHMUdT92M030G+XpY5yMx3ZGb5AK1XG8j+V7K3w/W+EjJwUoYelXiOsELr97g0pMXOVfsEIOn61qCzw2yttRcu75HVRTEoSSkiE+JZRtoVokb147oIrR9oGt6SAljoF85ZIiENqCtwRSa3kdMgsJmDnQEosgyeqEL9IvcaCcSJJ/LPtoqsJKitCij8G0kxHDSqJbI0qpGIXVGG4OP+D7SOQhaoK2AqDHGYmvFjXcXRGXoZw11ZZFKZ0+FmN9baRV9tEgUvvN0y5bFyhNTYjjIaFr0jtbDtWtH6NozHFX0PQitsSprnqdCsXKR2uqM9KRE1wdc42iWc4TXlJXF2hJrJU2bsFXNaBIotSL5jhgFgURQBiE6ktSs2gXeJ6yRaGOyO60uUFVBEwNRSIZVRVlULGcNXbNkcmaEO1oSoyOGBm1L4mLFwXLOYDQihEjbtrjgEGWRzauEgvWilHnbJU1wdEaDVRR1hS0VkYqF6yiswWqDXzdkKwEhOryXRA1JaDySRRDs946zRrElKm4lSRKCSisUBSklhmhupIAqB4y15YF6i2kxpK92+Ob8Bt3rb9O+1KAfEhQXx5TjMyzFAQOmvPruS9x87Q0Eh6hh5Nmrgs98eYRTgRQPODuEcFjywls9P/QfJN56V/Dd3zzgnl+I3PuJkirUzG5e5413XyR032D+zZcR2x3Tp6aMn7nCQ+O/RNp+HFFV1BceonvoYQYSrp8/g1KaTz56hUJEJoVkt1Jg4XoTuWyzX2hhawbjs3i/RHFEiEuCW3G07IlKYAYVJQkRIjGscN0h3cwTlUbVBakyrJYtNtbIsSBETe81rVO4IKHrGZWG3pcINMoIxhPo/YokJD65rGCkFKUSpBIWbUCaLCkplMpeB1ZS14YuabqlI/kOockVulpza2+JrQraVYcUEmsMad1Eu4nsNnQiJFmBaB2caK0zMq3EsQuTixFJyItlSmvwQBOjgBQZbA9yZSFGlBQURtE0AmsLBpVCFJZSl1ihCE1LtT2mVBIhDS5GvEv0OjdeV8bSdIGm6Wk7D8Ez2ZrgXTYV82Jd9SAHWlJFjIRyOCbEFa7zxDa7fwsh6JsWoqIoLGVZIo3BGE2cNyyTx/uILi1VXVAaS7Nc0bnE9k5NkGDLkmFVYEpLJXvKOCCUdUYfZQZHUogYqxiOC+YHS4SPGK0ItaazAReyA7z3ibb3LNvmZMI/teglyMpu6c7AdPM3EdfzazpOCIgbDfJ0jOYdo3TrxvbNTjYo3Innwd0vcnLztGY5pwPjkzd+1/2P39hUCza0nTs/83qcPh6ntskyr2un681+TiOoa6rG3TGN0pIUTvHXBaS0piKt6Xrc8VocJyeZYpQ+NPj7s45ErgxkaRCo0czXFZRCaCK5iVShmMeIMoZaai4rzY6ytNUW7zVHdNfeYv7qIePHRgxHu5R2CsJRpCHvHL7GjQ9eZDB0dD7ROcXjD2/jRUBwxNmy4tq1SJ+WPP1U5J0jwVf/5APOP2MYTs6T+sje0Yw0HEF8ntsvv0p934it3ctMzEPsFp+hqC8itOHBCyOaMztcKMe44RAtLY8+cInQLDk33WI6KCBGjtqeQW2QwOXLlymK8jheiTFTL6VKGCWQa8GR3HvzIdy6j9FIKSG1yC71RlNam5Od9Um2ARvge1H6k2LBCV1oXTz+8Ofe9eAdVCNOJ79rda94Mq/lfWzmsR8c4uK/a3w0wlpVw2CE6zw3FyvGy4ayrlketrgu4r1AIbJ5WUqMxxIztKjCIERW9Ohd5PqNI1KMuLbPxkcACoKPBB+yeZJQ2FKiDXSL3AQklcKF3ECcUu5jCJ0nrDW40/pCkWtpxCgEfRfxbd5GCEBJlEhEKTCFpihUdl/28TjB0Dqj8pZAcj3SGJx3CKWRMssvKpMVmFIEJROxcyix4VwKughRKWQKFEah1yea94nGdVQerJL0bcIUFiE0vu/RStA2LgcJKdOalE2s/JKuWSGjwugBgiFK6Bw4ScFoVKMk2dAtClwQdN6D70naIkRCmYQusmeCkiWmims/iEQUgiTFsTmIIDAZ16w6DwmUSFnUNTpW8xVaFWvTEonvEyk21JNxdr7exAJSIYTGFoogJNqWKFugCotRkuDz51Qmm1hpZdACOiQJSYoRaySTyoIt2PeBF+eeBwvBkTUkEjZFChHQUuFJTLVFxh4lYYxie7jNePJZquYD2h+7yrO/8QeowvHQ+Yt8bvpZroU9jpp3uTV7j7ff2UNWMBidY69+jJ+oai7qexgny1njuGoSh+45turIm14RAhw0CXPYczBbYFjy/td+m8l9r9B3K6SrGA8vc+8nvsAP73yWr79+lflbc+jGXLo4YXhuwFfeuE2yki/u7lK1KwZaU0vQMtHERO8TUpHPa1OiyzEiOGLfopWlbVf45BnUJUU5IPSBIDNvsp8vcUiIkVordFEgnKdb9XiyipHzGikMIiSGSjGXCpEUSkrKumLgNYvFggBoY6hKQ2UEvve46IgIBqWAi1UAACAASURBVJXFhYQygrLUDGpFETRdiCwWDT6BFAalJLGPDIdlFjDoHSnEHMgj15zm3IMg14HoZslTYsP9XFMi1uixlGm9SEYEEqUlprSkJInOZe3smK99JSUKnY0W+x47HCKEwQpFKUBGj29bQlVkdbXeZZUhF4ilxOtEH3RWK3IORaSuKnRV0fuG4MB3AYJDK/C9J/aBUGkQCqUUpdWMhyW+CbTeASCDg2hQ0mKVZnZ9ztI5hBZUwxzktcozO2xpYsSWlnpUYo0FrzAiUyFTBcVklPOm4LNxz9IhFETWlZUYIcBkVDPrPF0P1giUNugAvjuVHBxze9MJjT0dh5icDjY3QWGMKfcgrDdPmwAGTlFlNiX+7x/QHOcTdz6a9xI5WbCP93fCK/hBAPI2/R3iNIXr+8aAH/6Bc7HlpEk4xlNfYNo0GK+Do/U6EsRJIHa6kXmTLJwkeae4GGy+C/F93t9H/Mzrv00ItCmy5/PPWQVLqRAYDAm9TmwSiVoohPAIYKI0u9U2opowcEfsPXid33v/fbarAY8OL3O/vcQsrlj59znoPuDdvdvsmAnOnCOas5RmyrY4R41gS25xnZeIwnOu7HnztiWkxJFPdKuWzkVSf8jVd6+xe/Yt+uBQfcGZMw/ywPanuKAu88Lb7+G9Il1vuOfiCD8KvNQsMaXk8TNn8Iea6XBAbQxBJFIShLju9RESKdU6KQvH10v+yd/daST843LOf5iMKWSxGa3ASIFeo/FpI1t9uiz4PUntn/bBxfG8dXw93UUc+h6n9vxo/n03VUvcfeNEtvkHeXyk5EDbimgqOt9iigE3ry4pdy3Nqid58J3At47DZcNgYNi9p8YPR9hBiSIRYyDKwOGiRSwcxkZyApyyookE57JCEKLHWEk9ymihIs9LkkQMkegC0QfkBmVMJ8XNFLJRkiP3FyQfj+c2qfNrZj5zRhptmfX9fJ+IzjEaGYalQIiIbzp8iCAiKQUG44KytGgNMgVCSPiQWPlEYS2hi4TWZ/WerRLhVgwKjdHQO4ETEaMlWmeDN7/qUNETgsH3PWVlIEak0vR9QilFYQTOZEdalVpEtISuxcuECOFYItb5gJAWhMbHSNu0SO9xQVBVmiShqDWmUCBrbOWygZsWaA0pOFzvUSJTCkqpiEohpKKwls4FrFKkJHE+MahKdFkRUXRujhUCIwBUzvaVwgfJYFTRdS1SaZJURKGQpmJ3WtN2i6zjHk90rdEFUhbIlCglDKoSioqDJPlXt1c8aVpipYn9IXW/ZOx7SiKzdsa5oqL3c65FjSdQaMeVyVkeLgKzh5/k3cdeJl5a8dj0fn5+8jm+s/wqz7/6W+y1ATPR1GfPMX7ss2xv/wq17nlUJUqxhY5LVjuBC/f/Nrf/oCddj9zzRcthVMzem+F7GI4bbn79NaphhX2wQIqLlOHTDPvPsHzzbV567ve4/e0D5I0dvvjUg2w/dT83ZlO6suLwU4qJrHBdZJECYyG5Ugp8SGvqDQhpkKrA91mBqKwGSHFIWDVZQlTVxKRwokCogr73a6M/QzGSTM5uszo8YNV0uATRRYIDqy1SWWyMOKMwJqvUKJkR57ZtUT5RlAV1bSkkLLslVaEJLpKGBU3rQGap4egjtUyUpaJdQOciXexpfaRvc9JZVSV96+nbQO8DUq8R/5DW17UAJUnk8rlIrPtV5NrxPlMopBSQMlVCKYmxiqIqkErjG0XoPAKRGzelhqTZPTOlmS+Ik+2scBACVkYKrZjtz1CFxZYG13u6VUczX+InNUt67HAbVL5+VUx4BJ0LBAy99/he4JtA6Jc5Ae4DzayhW3akBHVdMBkPWLaCWkFoWnwfSKsWUygsBV3r8U2PMhHnOmbzJZ0XLGctw0mBUIq6rCmLgtWsZzXr0JMaKSOVslgNRInznqNVT5CORZsotEEa6HrPtBwjY0/XRhIKY3NJvzAnyUFGLU8kQ2M4MZQ8prDcpTZ0x8J/TEWJJ0nF6Y7aU8HuBqnb+B9sZFQ3scEmQTmVnZxCzje7PBWgfpwX7HTqRhIk4kk1ZoPer4Osu5FP4FgG8hjdPNWgfJpGtAmeTv59yhH5NFK7rgpI5HEl4o6ezePjne4yRPszfNT19+pT4ih4GhI3fOTl1tOrxEJB7JdUvs901ODofMdASUJ0OFGQcNQmG2ueU5Gndx/mpSvf5sJ4hyfKe7nP3Mu17k1eu/lvuR0jo/GIcnI/k52nGRSPUcjABZFQDBBpxc7WCxw2NXtvHxIO4bFPj9lrDKI/oI+GSu5z/erLDMsx9ZUtUrqI7R9EzLfYm7/L89/5Gs6PWLxwxJ97+jKDey5zWCliqXng0oDd4RaL5RxiXku3jFp7j+TjIpXKCVvIx2cjyR59Nj6LcaMU9iEywh+jIYQghQAhf6/OuTzvbKqId1XI7q6U3THSSaP8eu+nfA7W4MH6pD2mx8V4csqnk+1iSusm/s31t6lacnL71Pv5QR0fKTlYLJbofcVqjWzXI4kbLUg9zG7PcW1PYRU7Q4ksK8K4oJiOSCFyeDBjf9UQtYfWrRG/daCfIrFxLBYBU6msNJIS7bylXeYJMkSJiS4bnvkIMaJNoiwNh7c9ghNlk417pga6LhB95o8ZkzXOg49YI9a+aAmrc7Pz4aJhVClGtcFaICWMkMhBiYiJw2V+PUJHP8+NXVJDnwxWJ+hEXuhTYjQtOT8Z4lYCEwWFlXQuUpSJC+dGRGc4WHXItiVFjwiC2gi0SujCUlmD1ZHeB/rG0fURO6worWE0LvD9kv3FIb2DwThTG4QuMVpT6gIpA323wk7H3Pxgn61phdICawyguD2fgy4QpsCIRGkUpRDIlJjsbnHTO4KLCKOR2hKw+H6FTJpOKkLvKZViPBmgK007S4imJYWILiuUsmsTN422hrZdsWw7jF7LIwoYDkaQBFoUBCJdEiShsbaiCdmPwkiFUhqrNDWSL+4qvvHcK6RVw9EH77DYnzO7vcf+1W/i372F0x2SCmGHiKLAji3TB6c8fCHy3h++y+Av7VI89igrO+Vd/yrt8ga/9z/tw6OJH/nph3jmsS/wyPinOZIT3k9DLhL44xi51t9EyxVPntviX19o2Lo3slVL3v/6nO2zQ87+0JDrw+ukK5Gr/3zGQ796hQcf+Q+ZuKc4fPE1/sf/+dfwQ8lgeJbBWc+r+0tW31rwpU98gaerlgEVR41m0UZ6q5ASRir30cj1JFhZSzKa+VELwqKKKecuC27v3UT0PiffqiCYilWQiNEQ5ROpKGmRjApLGm3R7+2Tuh7fefouQFIsgqEMPWfP7iBToHeeJANN79g9v4s4mGOUxChB3znm846jo47CKpZdpKps7iPwCecjw6EkkCiUIAZo+sSsibQxMFsFQu9xLlP9pNSk4KhHVV4UYtYoISZC64DskaKUyvKaOlPKEDJ7FvrsNC6NRBlFUSjMYIgYelrXonSu5mkhsaOKsipxh3PaTqFEwvctfRMwox2a0FA7x9mdMZ3R7LtIO29xMlANB0wGU7RcskqOrnV0KdKniC1KpCywskIKzaJvcV3H1nTI0byhXa0Q3mGk5bAXUFpGxZhbDpazFUVwjMaJ3sPW+S1U29OuFizblrbt8SGynLXURSKGmsNFYBA8Mnqu31hRmJrx1hZdUDjnST7SrVYcHraooSIojR0YkpP4I1gsVxRSsYwSl2RW9BAgrTme73Pz6jrAj2v8ch1IbhC4jGzGYwoAsDYuXM/Fm4X5OK49WZTvwPA+jApwvPjeXdb//iD6CTL5MV6wN6B8OkFJY9oAXN8bBIpTz89VlYwsCyGOfSYQWT/+OPhfJ9bHEqRr/4oT88DTgZA4DrpOkbL/P3/M08lnvp+YuZY+ZfT4vJYkk2hmR+wv5uzdusF86bh1+D57t96ku36TpV5Ryymm2kVYxWBacu5czb3DwDvPvcVjP/8gZnKWlTTM4h6LxQG/+/tXUfdLfvbJz/HY5PMM9RVWomKRDBMi3yHR+CWlGXBheIFb2yvuOeuYSs2LL77How+cQ9Qd/eg6bsfx7T94l2f+wud4YPJLyGXFa9/+Li88+zXEds1QeLbONVzvjni4OcOP1JGzoqXoBFHVvPX6u+ye2ebi+TNMtV7TvXLjv1YKKSR+nZALcpzi+v7ElGudqIWPc0NyShweLdi7PaNdNjSrJldsRTatDXENQJxKcvN2a0DguGJ4ej5JdyD9p0H/0wpeKWajP7WpVqwT8s33cGqHd04pd1Uuf5DHR0oO5vOeuvKUQgA9e75ka+YxgzF9WLFYdiShuPfckOKM5v2FRs72iS7LipquIxmJmgzwTURHR7dqmR/1KCPY3jU0TTYqil3IBmidJwImBPpCURUSI2AZEsEn6rFhHCSuDbRd7m0I5EZFH7NPgioUplSYQqJSxBaZfjCoNClAM+8ZVIIHr9QUQnJ75qnLAqtzf4MqFZPpFvXM06x6ukVH6CIIhXMB6Bic20abhDG5gbJUCtH2WDuisKCSx9SaWhoW8xlHMwf0lMOCJAWdD/SdY2v3DKmsqcYjRNMgVgsEkfF2jXcgNIS4oln1uKVDCYMqCvoQmW6PUIAmIY2iKi3N8pDBqCBaRTIWj2ax8HQxMR6UHNyaU0/HxLVTbT0q8K5n2S1InUaLgPctzVwiDOwKx9mtGh8UMgj6JuL7QLt/GysNB1YwKSt2JyPqsmLv1j4+CKZnawo7yWo0QpCC4XDWs1we0sRb6GKIFxYnHIUzDAdjqnrKTj3g7Sh4/vo+r77xKvIbv8OPPDDlN3/7GxjTEsWEYLa45+mnuPzXtvnuG5GKs0BHMTikSO9z9Xe/zps3JL/yd/8qv/Xq15iuGp6wHTsioez9tI2i/VcLzn02cbkeMJHblNT8FoHbCL7AO9TNb/P83h+xd9DwyU8V+DZxMAisXg5cv32b126sKM4u4IWEqBPUn+bzO4+T9sb8BlP+1v/xz/j6Wy/xuFpye7XHmy9f5a2vvc3B77zAj/3M59ma/iw3r5XUo5JBCeFmyyu+56kvjMiaPAlJRGqDGp2hObrB/s33UEWNtWOk9kilGKgBQiw5FIHxuSmuy6pAnevYu3VAqRRnJwPaox6vQE1KrJS8/s57MJqwXC4otKIPsGoCy+WKqCQ7Y5OrgwGCLrCTCWJ2QOdgOhQMtgf4CM3BkrEtMPWQ0bkBnSkRsyWm7ykqxwe3NbYyFDIhC0OxdCznHQGNkJJ6NMFWgRgC0fV0Iqt1SK0pByW6MDlQ9YEkyZU6Y5Eqc1NTTIS+J4Ql4+kAUw5QwqO1pKwqytGYftUx2p5CoRhOt5iOhwwKA0SMbqiNxDUNWmh2hmNWdkg3n7Pqe+Rywbxr6JzL9LnYI2tJP18gZEFhShiMEVGQ6BkPBEUlmC0WLJcO3/UcrUJWXBlVxHKC9JLglsz2jhiXElWWGFviu4bgoWuy14gXWTVGVVO8HtD1kaGLPHTpEp0oMLomGUHwLVJKtpREuoTTgQZFG0BrTTmVzOYNNkrObA947/oR0XsGtUDIcDzfx+OghDsAug0NZUMW2vhShMgx4sf6f6eROCHIKkPfN7A8ef4xf5505/p7Kis41uffIOgbE7xN9PsxH3c6w67/HlN77gqGjreJd93P+5HiRIEIsWk53lR2TlUSSGzKCTk4WtNt2Thmy+NDe5pOppQ6fnt/ps+43o9PiettQ6EUexHeOTri8NYHmP33uDQtee9bLzOuHU3cpayGPP7U0+ycq3lpH8ZiQqRlXM1pDt/m1juv8O6B5cv/yS/zz979E3503HFROIaiZil3OWgUi9+/xe7jMFYlhShxaN4ksQAeZ5/X3Vf5YPk6PZ4n7tnGecfceq4dLbhx/U1G90hkdYhwATWM2OkzfHZ6ieeWC7Ye/SR//Us/zTuzAy7HFd987pssnOaP/viPeP76nL/6cz/FuPwkB6uex688hu9bmusd4RDO3VsiVS6AHVMoEYSQ+ya7vj8OfOXaVRi4wwX44zaMMSzmK/b2DnF9T0gpC06Qq2Ai3nmufT9gYDNOXN3v+ofg2AzwmLbESSK9qTjE44Q1nWx3PC/9afPXD+b4SMmB0pJircixXDScn15AFIL5wSEja9i59wJ2u8JONEdH+0yaBdJF5gcdh3srjnqH2SqYPrzNuUd28PNDlnu3USPojaTd9xAcMUSCi1njeGAhQa8FtYYgUnYhjYGu97hbEWMNg3GBXDmi8KhCkXrou4gya3dIBMYojFbgIqOBZDpRRJVPCC2h6QOLtsMUFj1QoAS+izRHkXjUZO8Elyk/5Si7iu4fdAxqQ/I9QteodV9C8mRjsyrh2ggy4Zcrmi6CNNy6cRtZKLbMiOmWxViJ6yMyJg6vHRJ8Rv77riOS0EYxri2tjyg7IHiLj9lYLBHZ3t2i8Yqj/SXRzzCFZbg7QdZD5GpJjNkMKRJJncfahC4Nheww3SERzbzXzGaH3L6+T1IWVY8yjSg6IjNsMeXwqGVUlNSVpWkb5k1DWRa4PhCKkqKoMcWYJDSd7wkq4kJi2wyIQOcCgoTWgSWKeedofEc3X4GpKYbbWCJCGFYo3msc333jFs///ld5/4//NY9/espXXxvw87/yS6idJzlQNa1MXBzUbI8K/sYTnq8sDhnM/m8W+z233P38tb/3s9ySE15urvI3nvnzLOJtnEhUqeSm/B3UBUP9I5Zv2Q945PZz/MT5yxzwGT6bDEf9/843rz/Ha7/5Cqu244FfvsLt0PHM6j3+m3/U8+f/wg7yEcmz31nynb/TIh6CM7865q889gkOnGQ2HfEzv/BFllrx6CNP8AAdPylL9j7Rce0nZ9Rv7fPif/97/Ojv/FMunn+S4TMPUzywgxwb7CcrZAB8JPke3/aEPqHQuOWK8fg8e0cthS6xqkWlFqkTi6PbjKZDkBYlMjs1Cs3WeEolJe+/c5VeWGSxltGMnvFYs3e4z2hyD96WdH2gFytKqQiuowsWkRJJqux4rEDUsJo5mnkgmJbCKIRRNFWNCQHft5SlpG8E7crRdT070xLfd8xmDT77HVNUEtcJQhOgUJTWEIPKvQploO0dxaDMwcomAI1ZQMD3AU1+XBkLytBFhVLQLDqsBWXXVUIXkG0HSpNsQUekFoGkEkkJhkZTmAlSVURRUBUV42HBOAb2laLVimUMWGvQyeBCR/SaK2fPcXV5ld4LlssFWsBoNOBovyVWhr39htWipekdrZIo7ylUhXaJkfCMJjVC1hjRM5t3xJVDJUm36gkxYktNPZoijuYMt0qSEEjnSUhaSraHhphKOueYlDVlNSJ5RbsI3PPIFeaHByxcS79KpBAJa1PDJASjYcXWOcts0eB8C83ieL7fGGptlkIp1fHKLGWu3MSUiCGgECixoSClY/GHFHJztjbqOHHYLM6ZLpT3HddI4QbNPhknNJdNAPs9FYb1NnKNfgf/g7F4CyHycVlLL8Kd9Cu4C8AXuS9vI9F4J9B5ElgdN3+vKbqbhmNISCVPUZA42c8aKd0oFOVGzROq0oZOdHc7+Z8+8tnSBM/7ywVRWZoUee+DI179+reIsxtcum/Ea87ypZ98hlTdw/0JjJJMrKE2kp8/H3mtb5k2z3NzITD3Psm5p36SJQXvxyP+i4d/klvhEC2GqNQR1auY3QFnHm94zr/GZXeFC8UAzRkeIrIK3+D12Xf57h99g+m9O+ze/yh9WnF/9wZ/99/M+c+//DTXK89X/vga3/rqPvWDiod/8V6+PLnEG31g+8JZLhuLkJJ7i5LzyfErP3Uft1xP99kl7zz7bf7B//C/8N8+85+xffk+qqfPIAYlYiqR0+zFlELk7/ztv81rr72Wj6+UBOeRUuF9PJbiXJNjCCF8rALWTYB9+jpvVi1t0xJjXJ/zYl0dycySO4uB4kMThGOaz6ad5lRCfWzdmE6Uhzb0vI1TstxQ7tjILuedbCCK42N+il708Tnq/+/HR0oOtkcFZ6YlwSf8yjMYVVy9cRs/X7I9gO2RpZgUXL+1QlfjTDMSHUkkktUMhpadi5bVcsHB2xFEICVBZRU6CLq5QyRQQ4MZK4QXxNbRL3t8kHSdzI2n6+RBW0VMCW0k88bT9/mEMymxbALeRUJImFIjJPQ+nwwpCKLSBCEp14GDjwmh82LXE2lal91ERaY5JSUxSkIX11UDgdCSstRYmxVXZOwy3z+YrAudEjF2dCFiRMRqgTIKmRLVyDLenVBWFlNZhIboO64fLQhRU3iLA5zUeUI3Aj2oSIctCJMrGypkpFTBweEhutrCu9w3EGViJALDUmNlwarL6jI+BoyR1MMpJknG2zXRC3wUxD5hdGT77A7zowVnz1S5kdxlB9vKavZcYtEvmAwvMBpXpJjwfYeb7rLqWwZFdrSOETrXE2MPXiKFJPgOv3YibH3KVRskQRnqakRKMrsnR89eF3jh9evc+urvsth7l50h/MVf/jT3PP1D3BIjbpvzDPSEsVsxmt3i9jtv828PLZfaZ5kNt3ngnrNMzz9EXY/Znu6w6hesDl8Cc53DpuValJTyECGf4jP/0St86x8dcf07B/z601/jGz99gx//oa9zb9T8vX/xDep3bzJsGvQDD/Ba+Ys8YUeYo3/I/T+84K2kOPzjlqsvtOgfVciBoAwjFnHC1mCLkRlTFJZ7gfeAmXO8kiTnixE/em5INdpF/uoY+1//DtXzrxKuHhF/5hMM/+PHcmKbErEP9G1Lt1rRu4ZIoh6NcCFwbqcGIkaN0Bp8ctT9BN8s0Wt6XUwgpaWqhnTeMYugdAEh0rUdyMCtVqCHE7rOs+xbms7TtivoGqZbI5Z9QgbwIZBcC6lnPCoxWrJa9rTLhmg1prTgWjppWRw0tJ3PdJSyIHpBPapYHCwZjCwpZXTHhURjFcuDJYNBbs5PMaGVwquE1BpTF/jOZQfNGFAiUdUFvjQYa7LIgMrKVs4nUu8RRQGCLDxg1g7sTUfSkZgEWEvoOpILyMrQ+khhDSjBqnUkH0lFjzWaelCxVVXEGDg6mOHaDisFxkpmnUdJQ994XNehRCAljyo0V2/czpVPqzBJUZcGNRqz6rIwQqUEzufPpY2i9XBwtKDQESUT5SAHGs1qhU8JZzTSe0gCHyK9C4S2oTLgBqBHFVVZI1SBtgItAmfO7bJ65wO06OmjzxTFuqIwJfNVS13WRCGJ3iDKO0vzJ+vxWrJPCGI8kZll3TQYI8QQTlFVTjNScgCzaY6Va1Tv2LdCsA5KT5Bu1rvPMWtag9nihBd8jPzl+Tsv1jmg+LgXDcSa8hNPU0U+tGnyBPnPx0feldCJU89dJwWnGyjFSfXl5JifUmJJd/YQCHnSayDW+9o4X2+2/TON9fftY2LuAi9dn7H33edpmn0ub9dceuJhhmd3WVBwaMYMZMGWa/DNkv29nleaxK5/m1W1xdb2Rba2C4qyYlQWhNDTLq6j1T6320ijF7iiRNkH+Ikffp0/+L/e4M3XlvyTT/c8+uBbPDF5gGGAf/LCi1zeu87YKg4Gn6AzT3KFDtM4PvWJA95witff2mPPt4yerCkGhkE8Qxsrdm0N2lJJxQCYR0GbFI3S7GhDZSvufeZzPDE5j/7tFfIrHxDebil+/iL6/Bihc4Lmup5vf/t5jg4PiSHk71ZmtUatc4VGqbym5sA54Zz/sx37/5/HaQT+7kRXyDWCH8LxKbypXiY2srrZ6+Q4QD9VcTyWOt6kqvHksRM38LSmLWWAKsYc0x1XItfvM51KEI7fy+Z118Dbx32++XeNj5QcTIcV25MBnQPhLf3hivm8QfWBvoD5vOGocdw+6Ni6f4K2gqNlZBUTqpTUQ8t954ccrAL7ewsWjSdGh1GBhMI7cC7kCkUt0FahJOADbRBZJ9zqrIMeIj4knE/UQ4ULnrAKhC4ijzPDuC4xrSe/kBFCXRmElrguUsqcFbZdpDYapQWDWmTlEidwMTGf9Qy31silkkSRpf9ETBTDgnpQ4luPtApTWJKw9G0gIHA+EIRErSfBECLBJYTSxAhaaZRU+SSWiiAUvetZHM3RZYlW2QW6rixaCKrCMjCKLq1tvbUkioSPkIJDkrBWYQqF6zvA40OkLEr6kAh9QChBURfIXmDUhGbRgQ9oIxjUBoRG+MTZ4YB561i0EREjhUgMDDRNZLHsGMq16lDv6HWBEB1CBvq+IcSelBwxBRrnaYIk9IneZ28E53uG2wq0pS5qUIquc7jgmLuOZHre+OZLXNqpefKBR7j/Qs29959Bnb3ImC3uDWM4PKI9epfV0S1sUdINr3P5/DbzwRWGO2cwo5rlcsGv/2//JzufqZkOew7QVGXJJanxYog0O3zp8Z/jvl96ga9+9WXeeu2Qq/svcXV0k7MR3n1rzvkHDGc++Qmmj/wYqXqaH7YDvtLvcNgXVMsaDvep9uYcXYskIygfrnlz/BrDSc89k8f5od0fYVdCraB1iZcPliRp2a4rzlc15WOXWTxyBf3V1+GDm7jnauYPThj/1D0kk+j7hmVzyMrN8LFBKk+SmuWyxbsl1hpEoRAp0nUNWluE7hFJ5obmGJFCIlVumN/eniLIyZtYQdP0RBcIMnE4a+g9OOeIoUOrRJBQmYSLESWzv0EUGk1uHjVSgMhypgnB8mBOPyiASBQKU2RFKhcF/aKhLAypNOteIJ1VxW4vUaUj+Agx5OZibbJMrRRYq1BC0PeeFAVaG8rRABETqlDoBH1MuJTVdwiBqsgVhKq0jGpDpUV2Cw4QlGBUZ+WgQV1irSY0DUJruqbJUWlSiOQhlRhTZSW1pkP0HtE5+tAjKouMkcIW2KKFmI3iIJGiX+trW8Y7U0TfooJHGUlR1RwdLEkmCxNEIqoss1lc16JQiEIitMBKkEWiS5JFExiqQN95dAKjFVYK/HzFeFJTKE/yLT5kBO3G4YLCAErhQqR1AZ8ynxmZ6FrH/HZHH7LcbHmq5wBOfNc+ewAAIABJREFU03vuHCf89tMKKhvte3EM+CslSSlrmR9bHK8Tg6xGskarOTVPH7/whyiJbIoHp5lDx3Ht2sX0Y0yxAE5VBr632fTk9oZaxJ331w+ePgLptNTlJmtjQyM6uaWUZAOorrfMFYL1PZXUHZWBYwdyJe943kcdm/BNCqiV4tq773Fud8hOUXHxzJDJ1hjKITUl01igmhX9ag8XAtIKEit27IjKbqMHQ4RRXN27xVeuv8eVKzXjIjLDsGUTSlqiqDDW8tnzn2fw1IBn3/w2L7xxnTffXfItXqXwnveaju37Rly6+BTsPMFYX+Fcankz7DLzBcNuRNUcUR4GDo4cohDoccnb+k2Cv8Z9O4+yPbpIKaAQ4Im8t+opjaZWiu3JhN0nH6V/7W3UOzfg/Rn+lRqminYn8Edf+xNeee1l9vb26LougzHH10Smb2UfFwgxEGL82FUONuMOR+O7fo7/f8fpfuzZzYYKlAScajs4Hmpt8rfxRdic5VKKNSh1ckwz3S6dqn6dABGbq+q4crAGJaTceLZsahI/uOOjqRVpRVkUWc88FOwfLfE+5EAjgl90rJolXipK5xB9x2zVE3zAGklZwHhcIbWnO+jpekfnPdFkE6OkNPQR+gRWIE12N41lgCbz0ISUaAVl0jRtLjmhsqRhTNlFUK0RyZRSbrQS6/shkoLAFNl9z6VIn2uk9F2kHudkojKCdhXpk6cPktXKYUpNTBJlFdIqYp8IMTEYVWib0f20NmsSIje5xDX3zWqJ8NnmPIXMHkcK+tYhxonkIkGAUIayErTLI1bLjq2ixBpDVAqjDdH5HAwoQRSRQMjeD7pE20jwCSETVmfFGe8dOjNA0FpgDbgQCM7TrCS1HlGVJbGLBLIHQlVYVssuO0QLS09iFTuc84QgKCtNCJq2DSQajEr0bYOLkqIs6LwjLudIrVBaUFUFTStYdQE89D7Sdj3OO6roKc2AojA0weNSzLr1a1+FM+WCZ378MT597y7TWtHiQNTYWJHmDQc3X2e5/z5OSOy5C9x7ZsGj93yKQ3Wed/ZucvP1N9j/4CqvXn2fJ564hyfO71IUF9mynlr2tBGOTM0l+0Wmv3gfR1tnGL/4Ev8PeW8abHl61/d9nu2/nu0uvffM9EizSTMjabSMEIvAgCAhYMBUCCE2b1SBFE5IpVLlxPGbmEoobF5RIQ5OVcqpwo6LJEAZAwa0BAmBNgaNttmX7um9+25n+2/Plhf/c869PZBkeOchj6pH3eec+/zP/S/P81u+S3v1Fs++cItxUvDYpQc4+9SQ3SeeZuf0hzgrz3JJKP6p2+H2CxWPTh7l/ouC++rLXG8vE03CMHmQK1euI/VVmvwmWyPPnfGEre1tTivFbhOZHS34RhM5ygy705ZTD53DPX8VfzilvvIa00+CfDBDn9HU7ZLKTmlocHTE0LCsK+ZNRWgrGJToqPC+YT6fYhPdK3QJRUD3sp8SGutpm5bxeIiPDtGADZquEQwUVF1LZXt1DO8cPnp8pqjajpEBKwLaaJQ0uNh3/dIQKXpSDc4FlouOum5xwpNlKfkgIU0TQuhJxQe356SjIdJoXBsQslew0qpDmRTb9Vh+JUT/XOkCF0P/HGhBiDVB9F4dKklRMWJyjfAB21pUjCRpD0U0ul/WU60oi4wyU1Avia0ipAllllAWKXmmSJQnGECAa5qVHCq9JHDjSPHU3uOrFukDOgo6D52VKAG5hibpZU+9dbjOsWgaksQQ8CT5AJzBVTWRiFL9s+pEIIreGyHgcd4CHhE1MYo+WdKi50clmjt1wFYdoXN4ICsLilHKsvJkSYJRHkKNtZ62bZguW4Trejf1IAlRIpTCR4itpak7Dvdq0Bqji1X1sh/raj2cgLFwYlMnbNr0myBz041fcRGEANl3H+/VEBGEddnvTZv7qtu/Od4m0zjxgZ6/cPJnT5h5vc1130+ODfyKeNwZ2IQlfWByknvBm5KJDTl7fW5gEyzde/p6RS/vwwo+FE5kCSckVdcB1IosujlO/7G3nJidvDpKCIZaMdEdT77rfi4McoTsYcUBjYma0HUsZrewzYKQlmRFRi4cp4YXqcSQK0f7HN64w/W7d9hvF5zxmkvpCNSEc8oiiFgknUzZkU/xoQ+fY3+QM7xxhZu39nj24CojlfHYxQe5/9I5hmfez9A8wI4YMPCSV8MWN96Y8vDpR9k9lTFeTpjUd5FJxo64wOt7N3HzBXJqcaMlaVYwHgyZKEnuYDptaBEUIZDNWsb3D5CTPWIz5+7zS/bq17gy3Oe3/+B3ePZrz2KdxTmP8/3aEGNAqhWcaHWKQwi9x0oIf/EEv81GDPd6ZMR4fC+Je1aO1R17HNtzkhOwSXVX65YUgXXaKtY3KcdE/w3vhuPkoIcOnRA9XScgJ4Y4nuqv/XhLyUETAj7Sk22ziDYDsraCpq9eRykJmcEMS9oabl2dMtCRzPQbaIyBPdtj/tM8Y7IDjXP4CFJo0jKSZxpDwGQZMk1xbUcjHOAIAprOoWVEKdBpfwPMDlu6OhB9v0uF2HMSbABtevgPK1xkn0k6lkuLHGrmNiJjj+mXEYLUVK1gXvfcBqU1w2FJ13oWjWWypRkOEkQOXespyoym8mSJpqsd83rZL9lSEhKFMRkGaDpLDI4kM2RlynTpESJAdNRLhwuSbFSSlinzo6avnJoErVNsiNSdJbpeWsuhMGnvUeq9QCRDyCLLZY0KHUr6fuFWhmJSksXAUeMR0SFcS7NccnBnyvnzKWWWkhtF53uJtMWy5WBvihCaunNkqWFoNdN2SdsJRDJAlgYdJcHWLOqqr6DGFL01oj46opENOjEUZU4x3CJIi60bTKaQUWBSg8wN1ju2jaHp/KY9qgQMdWTqO374J97DY1vb7JqCLkq6ENkVJfFony9+5XVu3f0zqskW7ty7kGLCJN3mjcUYWR/xmT/+DF/74uc5JSQ/9cv/PUVS8JC8QSFyApYQb7IVX0OIHV7xExrxHTz9nY9w33d/BT/9Ir/y5zd495kH+J53/RDQcTkOScSYD0m4Wu1z4zAnv7HPufHjPP7Ut3H6w3PE/LfJ1Q7PtmM+/9kXiTcPeP7Wi/zR1WfR597Jo08+yX9w4T4eOr3D65eP+OKf3+Q3jireeXnG33n6I+Rb0LX71PY64foU/6cjxt+xSyMsXrV45WmcYzabMju8Sz7QDIqcLE3QIuBbR7uc0XY5rmlQaSTLhiQmJQjH/nRJUx2CHOBDS13XtE2LDDBJU3zdIoyB1GC9p2oa6s6TdZZqRRg2Kyhfa10vf5qAyTKIjnZZIb1FZQYRI1IbxqMBRkvatiNPBONhShcjqTGI4LEWXBdIdIqKFqn7ariWkiTRmFTTdI4sy1gp+hF87CvyAYLqoYZ+E7esoHtKI1wLwdH3MyQhGoTKSHONSDNCVHjbEZolEkOa5cyswwBZDGjZP8e+62iDRCYZQWiib/skPRvQ2ADRU4iWKlS0rqatW+Z1x8x6BmVBkfQiCTLRGFXQLluOjmaUpSJ0lkxFiAFrG5I06SWLlUQ4SUQQpIQouXB6wPLWku6wwrtAFyJUjslwjB6nONGfh0R6VOyoF0tGg4LZNDBfdkihSAtNFJJ5F6C1VHWHTjXZqKQc5ci22qz3a1+J9d9XWJPVu3FTuVsHmj7E3lWZY/lTH3tjQynlqmq3mksCofd+EZv5RQ8bO4HnjWEFmaGHzUjRd5cRctO52CQSmzj4mPvwdqzqxdU+dVzsFye6Cf3ZXgeEx1CfYyiFgE2gFVeckBhjL2yw6aT3M21qo/LEsTbuu7088DopiRvs971BXFz9TwrJX3Rz/v8eApAKvuWDFzib5WTCUMf+6qVREZuaa9cPOJy/ht2+SExGaFJyNYI2ISwP+MTzz3L1G1/n8Qcu8aM/+O+RSM0pMceIBI9FxD08DQtK9klpeIyPvecMp97zHC9NX+SZo0MeHTzME7tPE2LLtTjklEjYjp5btuLmQlPeusrpwX/EhXPfzvvecQPh3kBS8IYv+Nzzr7MVNF957nk+vXiObHSadz34EN8yGnNha8Qb1xZ8Y6/icH/B1s0pH373w5jxkrq+xtdeucZnvvACf3LneRrf9k7nxN7RfI27X5HBY+iTBCV7yGi/5L29SbL3knzXa0T/95PR9zFpnlWcd7wW3TNWHcR7519PFzef3xxXrHsD/Vz3wO7E+vscw+/Eas07dk5++577tzLeUnKwu1WyXSps1cGw4IKAZl9DmtM1FdYG8lFKPjCEZUOZa5IikiSQRomsBa999YByS6MnOchAHhQiTzicWpJRZDzSpDagsgInNIe3Ld3MIrUgm6T41pLEQJkJIoKDO5HQBLrK42x/U7jW47peC1inEpX1rqpKCbJEYXRPKrarqlZmBGluyFJDfm7Csm6R2iPaSHAQhSIpCwpjUQoQkiw3DPNI3XgqLxiMBvhuTowSDwTXIQGTBOKyRiqPGaZkw5x2GRCx42AaabtACKC0YVcaslHO7u4EGyRdG2iqGV0IWK3ZGhSMtwYMJgOkswRjsY3k9uERg0vnSaNADzKMCIgYsVGglcG6Oa1QtCHgEAiR0Ewr7vhbhHpBb/ngcZ2lXToGecL2fffhA/jOE6xDdpZp5xhOtohBEjpHkUjKNGPeCRaHFZP8DLVOcLZFSkizjCgTdk+PWRwekCaG0XBCQFLbDq088+USRyDNE0xZEpUmzTPef/ESF4qSbSUx9JAs7QJ3Fwf87u98kdPnvsZHP/IRvmYe5tllxoPzGR8eDfi7v/8ct3/175GcnfHRH/9J/ubf/vscaMl7qDjiNIar3PCOmzHDyAd4UkgmJuFhLMtYMOOjyK0f5l9/3xmqeIiLU/Zjw0V/DeIVDhc3+MXP/08c/A9f4T/+5fdy4eJ9HAbDM9OO2dElfvLBS3xMbfPev/UUysNRO+OZ177Ov/7vfpVP/atP8Yf1kve9Y5sf/f6n+NZLW3zjf/4jPrEfeOaVP+bjly7gxoGoFafOtHTxCs1eSywNOhMQPd4u6WyFyAqyFJLBgCgNUYLRmomULLqW28uO1AcEFqMVUShuzzrqVtIdHPUGfNazrB3LwwWjPGOSZJDk1F1gUdd0OFKpGG4VxLpDa0EUkbZzCBsQwpOnCbULNI1FBsFwXNCaQIJhnBuM90jlQTisdYy3x1SLDmM03km8jygRMcFjsl6pSWu9WtwjUUlEXjAcpSglCOOMruroWodMU7SUuKZFikhelrgo8c5hjGTn1BZmZXDYeUmiEspyQEnkzuGc6CyNECRSoYD5smNW1WwlHhrFYDImLYa0qu+ondoesZzPuFNZ2kWFJhBUSj7JUXrMrjEEPcMZzdYgRzU1xmiEcORGMMxylIdre/uMVaTMC+42jsb1yTE+4kPgwtlBjzVWGWmeYqQgVjVtB0X0qFQyj1B3HcuqZfryLZ54+BwHt/dJFpE86TtwrhEMMsVtG5kdzhlPEvJBjpQGu98QlOD0VkoxHjPZGiKIXH71mJCslLonUBerzbXnEIQVvEdsHEylFJuAvG/IRqLoBQmi6NWP1lW59diQK+VJ3X7uqdYJ+k16rciilTwh3dibR603bCFX3+ftlxNsxqZAv/mdV0GS4DgYuac7wAl4BGySs5OV/tV8J17iTdP015TVoVYlaiHVZp6TuOs3f+FeOedYPeetjHU3ooueSnjO5Ftkq0PI1T02XS54+bUbbE2u8p5HHufLYUzXRracY6Ilv/z8bZ7/lb/H2W/d5t//wY/z8IMfIkg4h6WmRHHInSBpKMlFyq4QDIRiB0cdMzr5YZ7e+i6+eyvF0RJiw1I4xtxFRsfl5R6/f/lT7H3qT/n4T38/g3SLu87zRmfQ/gxPDSe8RxTc/8GLJAHu2jnPvvgsn/nkJ/nqJz7Hr82n/NiHHuRj3/lhdpu7vPrsi7xwJ/C5L30OUV3mq1deZdFWWAKWiAsO612vLiV6JF4IfWK4hg9FBDH4lZqYPE6o38Zjg/tf3WByVRH4C8H3KvFnte7EcBzMr39mvVjdw7+JgRA8kYjWapMw+OCJIayS4NXzsTrOcQfuJNzpGHq08WF4G681b2W8peRgdnuBPbPNaJLgcZy67xLTgyPm0wqZG2TwdG2HKgUzv2Sx6DBK4pDoQcLpR87hvrHPjZf32Hn0NCYEtIogAt2swh01mMmIBkd95y7N0uIsYC357gDvV7ivCL6OhADpQDFre85BW1ucDf3Ds/rOIgak7M2e3NIjCoWUCdFFMiM4fXrI1naG1oFbt2tuXt5jsp0htSYR4FtHNW1IRiWndnI62xE9dI0lAHkmmU0dSxMIbYfJU0SimR00pC5QJp5xkeKkZG4DR7OaxaFDCN8TZXRBogVZpigGfY3zqHZot6QcZMhE0/le131+cESiI6bsTaSiUNTtgsmkoJrvgymYtYHURHIjaboA8yOCbUnSnJ1RTp1qDuKc8cAQZaDrahACk2YMJ0NOn06Zzzv8vMHFBBdqgm2QEgoZIThoO0ZKMSoyBttDklHBzTeukqpA4iNHrr/mndHMGsvRdM5kPEGlBrRGSShNQuM6hO7dpdFDimJAlqcMxyMu5UNKqYlEjppD7s6WXLszY+/1z/GjP/A32E4f5Y+u99yMx+KU4fQaP/FPf5N4+zrqQsdH/4tf4nu+64d4QGu2cVyPcDs4RLtPQsJAbhOF4Fz8ZVSo+a0bKYfyfnaLjPOl5EX9GN+mvoVfeObn+A8feje2/DBfuNLxiX/zm9z5va9x3/sKHtr9WXbTx7jY3WE0/xK//slP8Y+eeCe/8P5vZUtJXrUGnZzibz/1A3z81z/EZ+78Nv/br32FK5++wz/+53/Mw/cV/Cc/826GdyKf/jfX+GbQPPjYE+TacLPaJ82mpOIUrqsRSqGlQiWK0daAWbVg1tR0IqJVbzmfaMUsJNiu5ezODi2RNvSBbPSBo/1DyrJE6ZRAoOsCbe0RMqfc3iZ1rif7qkia5OyIEq9lb6JV17S2D+S00pw+M+HOUQfFgLA/xTc9LEylgt0zA4bFDtE5YtNircdbyMoBOs3JQsV01tF2kGpNnkoWs8Aw03jbooxBJglCS9JMMiwy8iRyaivlcFazEBKpPPNZhdmZ0FUNxWjYbxLWoYVhZ2vMaGBIjaJp256MFi1JYijKEfWyQuY5MXqibZGlIiOiM/BVy7KFoCD1FmcTmqpGhSWtFwzGOcoopkcN3oMMiuAEzdJSdR1BS8rRiLNkvDE9InqNCoF2YXGtR0pN29Uc3jwCZUhMgm1b5ouWJJU8/K5zLBc9N8loDT6yaC06zbh0UfK15+8iCRSZxGtDkQQ63zIuMqZdR9U6VIwEL7h9c8nhrQOG44JhZlAIrA2c2cpZLgK28ojFnDbWyCzFlOlmvffOI5XsfWfeFFhK2RvzQb8phxMSmpE+6FdKElecF+7xO4gbsq2QJyCf6w34JIRpPWdcKRop2csciripbm/mi30FXGn9VwpS/20b6wQnboKl4y7AMcSn/+wmadu8fxxIrRMLISRCHr++TuhOnlsim2u4TsbW3IV1cCbVcWegr2T31y6EvmsfRezNGP8Kw8dAJLBlEjQ9jru2C+a1Z7Y4wtV7vOfRSxT6NF8/cAxoKILlxt1b/OKzz+L3bjF6+iw/+uP/gMd3zzEUAktgGmFGRLo5miGJzDHcYhj/FBEb/myeY9VFzqSaRBXsyV1OxS1+7+b/yPed/hAL+Rhfvf4azz33eQ5efpaHHjnN6exHSSgZipu4w2/yzdtXuXrmAj9x/hGKCDe9ZiuZ8Lfe+z388BMf4NX5N/mtL3ydZz5zi8/9s9/gvrHmA4+c4WPffoZ/+I9+nY9+4Fu5XB8yvVlR1w1RrlWfeoWvk2ZffXLQO71771eeyatumrzXn+LtOOSqO9VDEfvXhOg7j/dwE1af3zzdYu23cmKyNz/6JztdIeJdOIbJrUYIcaN2tpli3RXbJAbHU4lVseP/D9Cit5QcROeZTiua4Hng4hm62uOtgiLDtZZ22dLVFZ0JLPYbJJFq0cMPtAJfHfHEd5yh+8MZ9et3ibmklYJ5G3ry3qLj2vMHbG0bXO2pDjtsG6DQpKqXdMsyhWgiTRNIB5qw19AtLHi/wa3pXuwfEaEwIHE4DU5BUBHvHbtnS8osIZkM8GWG85ajxYzhqZSDuw3RRbSUKKMxA4Mwgf1bh+Rpz5L3URKUJqVgXEZyERGjhLbtqGc1aarpqpa9vcDwwpDBICNFkGWepelwSuCQlIMcESTVouPKG3fYmmyRJAlSaKx3BCmIWYpGkaWCg/0jkiJFuALbeY7mS2KY0QVQeYFJciKKLkqSrESrlEW1R5EnPZlJeUoj+zm1JMlyfNPifaRrLU3VEjxkPlKOM6IcUteChQ346FHesz3KET7gYiB0HUmbIG1LDH2gMxpm1F2k6yKh7gi2xS6XpMV2r1oEoEAF2JsvSHWOtZE0SopswNliG4ElRsVs+jyH0zm3a0uTCL7nO74f0xzxzMu3+dJNyY03Fsyv3eba3nVCF7DXLaf+q/+ab3n8wzygNbeF4JJQ3LAtZ9xvsWOeJIoSIWqGouLVquDu3ZdQVHxQPc9WXcJswKL6Ej//4v/CRx8veM0V0IyYqIbvfNDAx3eQ7/sphsXD2Fjh7JfZLl/gJ3/wJ7iyvMsnXn2dR84/ylll6ZpXeWl6hRtyi+898+188Gfexx/+4J/wf/2fX+G137/OL/2vX+YD7xhy7sKE1w4XvHH5q2wVJffvbsHejPOnb1PujMA2dB5UosjSXqHHWccKZID3HXWAZZRMG8WZgemDbNnDVZr5jCQxkBjaVXVEFilDMeDwzj4xwKJrUbYDIdBronAQpEmGGG3RNBYlQl+ND4LxSDObLQnekSWaNkQqFzAW8tJgl5GGVeXTQzP3xGWN6zxSGYwJdBFqL8m3t9HGMB7nHBzMadsWgUOFQDbKSQzUzqO1JNeSqAJhXICQlMMCZCTVmjTLkFHiW4caGCyS1vZKY1LlhJBRNxozPEVXtyit8cCyckxGOdEY8qIgyzOUgLbtWFQVmVaEQUaqDFIqYpbRFIK920eIyrK1lXI072hrCASsX7AUglM7O1x9/TZSS1IjkSayuz3CiSGXbx+wXNRUtu8aJInm/PkRw61torCEukFESMuEixdOcbi4Da1hWCiOlhGdpmwPM4TUHDYt2UCTWAtSI7KcVGvu3Dzi7M6Itqlo5yBtL8aAVNCCUZFER1IlEUKTnQDXbgi+Qq5gQRLv7aYBvy5qn9xkxRoPHGOvZCTYwIKADUHw5L9PBrc9PGX1Q+vsY10Zl705ZlgRmeMqIYirz0nZE6DFqvz3doQUweo8hJMJwfp1WOuyA+vS+6ojI9bl/j6puIe0sVZfOQ5wNp+PIN4MqO4n53iC/gKsOQvrSXpn2XXiuFaGeeuRkg+RLni64Ho4mpDU9U2qxjH3nqQwXNx6EOlbru0vePlIIqYt1/YOePlwj9hGllcd7/7Zv8vjo120kHQCygiLaBnFZxiqR3AEtOiQMbBnNcv6MhkHXBIlpj1D9CVHTeAPDhe858wO13yGiBnnEsP4Ukl84BHUmX8HHcdYURHcs1zcVmwPP8KRq/jG3h0uji+wE2tCc4PrGFqZ8ej4MX7uo/fzpXf/OZ/4V3/Gzdfv8tnnX+GFV17j+777KV66fofDak7n3apy3icFRpvNs3cy8gyrCvf6tRB7wniIcUXAffuOkxyXNRtm0x38y5KC1b82kETivbfs5iOyfxRC2HTD1qP3keifgZP3cs+FelMyLe7lRGyEAtaNvb/G460Rkk1BnhQQAlduHLGzqzFGk0SBj4G2FlgPQSqSJKcYByoXkIliWCjObCuGQ8vFSynTA9fLhoZIEgSthWKoWO5ZlhqkAZML6ioQWke3aNFZSkXPRNeDFCciXims8zjfE09WSCGiFCgpUInCrzcdJVBGohNJVqYIqfBEWmsJbQMu4heO2IGtHSQrN18fMQnMFi0liqRQfZWEgNOSMkvIcsViWWG9R4hIogOkfZtVKENW5ugQ8c4yOVewiGoll6pwreuhTdsDrFC0bcMoU70Ea5rgdUJrPa6xeO8IXYNIDSJEgutAKkIUZCKicRD67yxtoA0dg2FOCL2ZnIgCIyQ6enIdMNqjJoPNAxZISLRgqDKSTOJCIMQUyxaVc3gcy84TAyQ+EHxNW/VBjJKaLE/IgibPNRaJEJa2OkRbjaumCJ3ihMQpj5KC0WDEYlGhglsFIIbWOSocB7efR6kKLUrOD8akBgrf8JVXX+K3vnST12anWe7PaabXOQxTZDYkuQD/+VOPc3oy4WYIRCkpsUT/KmflI0iR0MQjWjunaT02Po30r3C/nLLTNnQoDlyGrKY8eukBrk++nQ8U78WFCdfUZczp+3jo/A9x/fA1/vff/TXe+9TTnN+5n05rXq8PuH0Lvved5yniddJ2n/3pkrvzgkff+VE++cwf8T3vfZKPvfODnP3xS3z29HN87l9+mi++fsSlHc1kWNJVCxZSssy2iMKT2ha6GqM8UgtEMPTqI4KiHKCERysQeDrrwQmQCpkVqNDhfSAEQdApSSbQMsN2LZFAZ1uausJ5z92bd6hCROMZjQbkaUIQ/fUwWqC8wLUWEQKEFVE2CvCeatFRDhLyMkUJRVIajAw0ywXzWY3SGq01pUrwaFohycYFVWNpHDitkUYh24rWtbjQYRLIEo0Rga5uKXVKFIYQHFJJijJDhEDTWgbjUU+0B5TSGJUgfW+mE9oWQQ8xbJuOrrZMdjWj0YQlc4QUvTtmhKZu0WVOmuYMyxxcS+i6/ndsLcnFCamJK5McT5b0BOjFoqHQHuUcmQSMocg1ddUQWijThMT0QWt0Fi8ki9b118VHnItIBIlWKCRNHWnbltBZROz7oLEQ7A5TDr0lMZIyWYkzSM343A6/NCyjAAAgAElEQVQuBBSOCKQDTT5M8E5x7tyQZrZgUUNnBYpIqluEERSZ5s5Bxc5uSjbIAINvl5v1fk0o7qvDPc9rYx60ygE2BGTRB+6wkllUYhPk+xPBzMldfgM9WlXD+0189f66rb9pH6xhAGHTdTg2QFtX0Ptd2vu3OcwiHqs/raFWcuVDcAxq+IvmdLDuCqxUh8LxHL0RmlzBLU7ENOKkKsu91dl10AQQRa/Otw621gmMkmrFGVDHELO39kv2AiIh0AaPjp5qeQcpOrTK2dEKo0D6jpsHd/nMq4dcb3cI0wMO2yMWoSPJC8b3CX7qvvuQWjOPkRLQOGI8YiTO989OXNK6XuXMx3cgwhV25HUy11ExxloQwXFu6xz72ZO80zxA5RMqk1BMHmGUf5hpu+R3v/5JPvzI+ynlQ1RU7NmG5VLy7q0xyt8mC1PuVg4nthiVZ3nu5is8ce4dPH3uCdLv2+GLX36WV775HLZpKScpxaJGqNCLpihJ8IG1Bk4IvpcMXiXlSqw6NCcvzrqjs4bivY3HmnMU3xSYr/++vtfXa8Xm59b3WzyGJq4LFptnR644pyeJ25tJjisX645cHwn16l0bbs/Jg66S6zWM6e1ahHir4y0lB1Vtmc9bVBJQo4yAJDWRrvOEpgPnyDODdwpvA4XWWOdIhSRLFEmm6OY1uYwsNXgtSYRkaCNpE4lLz/YkIWhBVJEkE5QTRdAKgse5QIiSdJCSTlJi3dIqT2BtHx5RErQGlIQoCKJvo0d6TWaloBxplOhdVru6ATSSgNEC0QZUAKQgMZI0EfggaBcN0TkypREx0vmAF721t1D9cbquJ03r0pCkAq0lZVDk2iCixDcWKs/o4imq/Tl0nrbxtJ1FCCiKjLoJCB3IBiVag0oThEkIdkkXFUWZEyO9vnmQJCYhCokXkGi90giOPcbOdXSdQKUC1zl87PAu4FqLlJFERRKjSPJ01a502CApEkmWaoQMRA/KS4TSECRd1eBWlWUbPcvQB6VJopAeROgr2XIlcZkahUxAuIaujkTZEZRG54oiK5FRMHMB6T3CO7ztqLreqyKGFqFS8iQnlQrRTPnKS6/x2194gecOxiwO9nDLQ7xYoEaC7to+ky3NR7YHHCaGqy5QE4hJYKxGRM4yC4cEv8R1mroyZErQtQWnspSmhgOR0aYZpwcDbHiA7fxxtvVpbs1eZlF/FZlEzux+KzeWhzz7id/m3O4jnN9+P2l2kWhe5NU/+Sw//OADZGKJ1i3DzHK+82TXPs9OAi++8lW2z53lkXecZ5ztUHaRz33uT7g8XfDItiQYTas6DmOLo2bbSLzsNe+l7FWuhBSYRJMohesiAk+IsSf2A0VqyPMU1wQWTUPnA0k2oLMLXNdRLWq0EbSdp6kdIgru7M3QWW+aluWBTChMkvScABTLxhNdwFlPt/IaEDohMxIxzFGZgUQjlWY8yNBEvHVY63FIVK7Z2hliu4bp1DMoCiI1vm5xvqOLkoJA8B3aSEwiSQwoZ3sZzCjwERwCqSRaCqSNpAbS3KDJcCusbp4laJUhQ4trGrRWfdV7VYjLshQZA4nSKBkwRqOlwQePFhElNcakCCUwbYekxQswQuNWAgrWA0h2d4cc3D0iSSALGcFJguqrUsu6QrlAXMFhpBC4KKjajsWyIypNMRjQ1X3S31ujKuazmugd1jlc52lbi8SyNdAsjhpihDTVGK16icQyx8kEZkfY2BBlL8SgpKIwJfMYODiYE31ApZo8VWSJBJURj5ZEaVaiEJ40OVGBFJsQcgMpWu+RYvP+KmSNx7CXNxt1rTkLb4ZJrJOJ9cSix7Pc07uPa2gLfSIRwrER1/oz64KgULJ/P/zVrLj+bR8x9pCde/ozbwpW4onuzOqHjn92czrFPf9/j5M1J7yoT+RwJ82qYuyThM2R4r3vc/K6/D/9Lm/6txICvY7KokdIQ6IMBk/bLHn94IA/u3KHK3XB/OgQ7eZ4Y5HSEQ9mnNtJeDJPeUMIDkLEicgpCZnIiIxo4oLeE0QTPEgU3pcMRUnVJVQ6QakCLVI8Fxno+yhEyWH7EtbfJDFjhsWjTO3zfP0Lf8x77nsvw+FFlK5o25tcf/kyT33oCbSoULKj1BJnZ5j5lEIqbtx9keHkDE8++A4ykTAqM16//CJ3FzWTnRSd9gIKwkvwYdWniZskTawL4oIVv8DfEzuvjQPf7rCik2tF4AS/5cTzf3x/Hd/HJ1XUTs5z7zlaJxV/8e48KZ18rN+1Pq/qBKTohH/LWiRBnHhm/hqPt3RnVVXN/sGU2aJhsrVFXpQY6VC+xS3m0DYMM01beXSE1CgKKcm1QilN1UaObtZUBx1V1dHESDACYwSDVJEIOHM6pxzoTWVjsK0Z7RqUkSAjQitklqKLjJiaXop0lSkKVipGBpKkD6I61xum4QOaSKphPNCExmJbi6tbXNMRfE9Yxkek9+S5osg1aaLIcsnszhyjIEkkwUZc6xEBsI7OexobcA6kUaTDhHyUUg5SciPBeaq5pTrscAtPiIZmWmHnDYtZTdsFXBQ0ztK0LWmmSHKDkBIFJIBwDikTBuMBaMPSBdrYSxmmWUKaGLQ2KCkxSpAoUMIROk9dddjW0i5r6kVF2ziEMb0krVIriVdH8B7btvi2xdqWtq37ToVzxLbXaA8rScJUBpRwuNBiYwfS4FvHsupYLFqqxZKuXqIIFKOS4D1t29I2FdE2ZEJQJAbhHUZojPfQ1bT1nGU1o+lqssE20oypK8utGzf46jef47c++wx/8MwBlRgSuinRT8H4Pr2tFqSd4ZXnX6A7OiCPEWc9syjYVo8wFbvUlIgwJvGnUH6L0F1B+gwTz7PfnWNqt8j0hJ1T7+V2tcsjwVK7Qw6rF2iXr2CcZCQ06dn30b5QM786wzWKcfEA7zj1NN2rN/naV+8iwllktsP2Tsm7ziqObnyR77z0AHeuvsQLN75MvbzGe+4/w099/Mf4wPc+QZck3O0sDZZOdsxCRSVqdG5QmUEmBpUkKJ2A1Ggj0aqvMDoXsF7gV4pC4zwlURp0gkXhUWRJiRAK6xps2+FsxDtJ8BopE5ZdQIiIj4LWBVofCELifaBrXA836/rkoG0dOI8UkiJLOXNmwnA8IElSMq0YpgZ8AK0waYbQhmhS0u0JJgMle8K8iR5pG9xyhl3OkfTJZDnMycsMk2ikkuSJxoXeMySsZIClCEjhKIsEIQPFIKUsUopck+WaYpQT0UQh0GmKSVJM0nfw8jzDtzUqBhIhKY1hVBbkWUYie0WcCCANSmcYYyiHI4RzLKuWeWWZLiyL2jIcJQxLRTnKSMoBOskRSLrGMp3OqZYVTd0RrcMISWIMXWfxnUPqlHI8Jh8N0GlGLz0rqY6WBN/7CHRdYLm0TJeOg8OO/VtLvAskmWJQJgwyg7cB5zStU7RRU3eSthEoJAJNORiQmZRcwNAIxkVKovqE3yQG20XqZY2zLUV+zDlYb7sCVuZmq81ibVwmV4TZeFxx7tVxIn5Frg4n/qxhQH3VrZ9789/NJv2XQ3jXCj4bFZ8T1T4hj7/Lm6EYb8shxCbwWSsVnVRzuScoWUGs1n/WcJSTWvHiTS2GNQxorYTDqrN+b7flpN48rA3sTnzJe77y5hr/FTo2SggyqSmkQUTQaQEyp2lb9g4OePnqdb708ht89vU5nS4RdkZmHEkqUARMVZE3hpdeew1pO2LokQguanKxQyNyLAYZClQcIIIi+kNEyFA8yMw9gAsjUnOKJHuIuR1yPlqqUFF3rxPcITpGUmnQxX3Mv7lHNasgJAyzM2zpU1Q39njpygwtd4k6Z3uYMUkqQnWZh0a7HBy+zu3lyySi4f0PPcwPfOd38fj7HqOWEjku0KlG6r4LyEodbV1FX8NWTqrk9Jc5rK6/2FTGpZRv++7BCaD/sazouqV44l5cv37vn3snWr92/HL8Sz7H5rmRq2P0h1k/d2y6psfJB5tJI/cmIX9dx1vqHOycKtk5M8ABUmWksu8QKNsxoEMJi3Waelnz5BMXMaZiOrPoRCIMzO4uqfYqjkKgaR0uRBwdwfbE5LNbOV2AqnEsKo/zIB34ypFIQ55qhOmhKnZu6eqa6OuedAx9ZhkiIkh85YkILAItInkqGJaSwVCROsd8CV4qkrzAWsne3hLlLX4ZUBFMrolS4GzvnRBaz2inoOp6kl1mFHmRoIWktoJhYdCDHKl7J2QtBWjNwi04unqX0WCIMTnR5Owd7hOER6hIVmRkowJpFNW8wteWbFJQzxaoJMcHR6gqXFeBSvCyJJq0b+kSUKlBmwTRClT0GK1JEk1iFARQMgMRkaGh61aV9AAhS0hKS9c2LOsZtgu4niNNk4BBoE2KUSl40NZRpIa4VRKFIAkW3zic98hEIdOUZd1Qtb08ZaIlZalZVrC1fY5FfZPGLclSMCbig2WxbIkhcGpUEIMF19I2Nct2Tu3GyLYiiwkvfO0lnv3aa7x4+YDpsiHuPEl9dAMVQaYTXDOlun2T8of+Jjf+2W/yMz/9X/Kzv/Tf8sM/8iNspxkvecuO7P0lLooBJloq5vhkDq3lQxfOcDB9Cjvaowg1Q79Na97Lv/vAAXuzT7M/+iinBh/gHdUTvHZLIqLjdPJOhFS88tLnOfXwKcrJKS6UIz7849/HL//i5/iVf/ITnL2UY7vnQSyYfOjHePXKC3zsPU/y+tVn2b/5Z8yF477iI/z9v/Oz/NzyX7D/zKuM64oyDWRbEjEoyJTC6BSjLIlJUCqhsS22m+Gygtr1mHChUqLUeFuRFhl155BIdsZbdN5Rty1aa4pywqiEplkwm3UgNM5IBltjkkTiYgAlabqONgR0UrA82GeQpSzaCg0kqUYhaLQmNz00ZphkjKWg8x1V02GtRZWGoc4wWUbQGTdnLfM7HdoFuv0pIvSQncQodic5ImqcyhgahxQRsepYeSFY2r7FrnxEyYhWglGSErMSayGXlpgIQpDgLIv9JfOFY5jKnqxtJDKAkIblbE6SlcTFksSUmLREGU0qFTLJiEpRLVokHu8CZTGgGO/ipMc5z7KJHC5q5vMpR7emFNHgJtu0dkrbWZxt8O2Srou4LDIwgmGuGI56SF3T1AitqFpYduBIehilbakWjix4FrVma5yRp+BcoBiPqOdLlkuHMY5RmpBnBus1d27VpM0hQQnMuKSOBipJZwSldETbsHv6NN1ygXINcblgLvpuULtssPMWOUrJ5BBvj9d7IY83XynlvRtxOFHdFKwgKxLv+sqm8wHRCxptVHDWcJR+g+5lWqXqiZZhtdOukUdqHSTFHh6zIR/DZtPfQJFWu3jwx7CBt3WcdE/AITZBk1j/0gChB4Guh9wkDSemiSfnOH7nOIg/rrquIUgn1N2JMdzTFegzu1V1VUAM/bUV64R6DTn7fxknUhSEkGgJ0ksW1uGdQwbBSy+/wYvX9rl6sOSwi7jRfcxmd9hOc4SG5vAuUkke/o6/wRf/j0/yn33pF/nFX/h5PnD+IhHJjEi++r12REqMnlZYhGyRIXJ6tEtVvxuKu2QhouNpZHKGJ8ZLpu03mGfvYzd/GtE5gk0QEYZqG68il699ndF4xOnxOU5vbfPIB97Hr/7Lb/Ar/83HCEriwhVEVmJOf4S9w5s8cf4J7h48w55U5PnD7I7O8iMf+iEO3J+w9/zrmCJHykNO+hj0fhO+X9dX1/w4mVt1zlaXb9O5EfFtHagK0VeoozhOhHsH9RP3zKaj1d9/J9WETna7TkKuEP26sIYc9S8fJ9qI/nwT40oNav2yoLP9YrhJzjg+pg9xQ8r/6z7eUnKQDyecvf8+rK1548WX+MLdI951aYsQIpNRzvm8QOaGu0uDoSFrWoIKRCloFpbrlw+5e6Mi2zGMtxMyo/AeujYSfeSwg3M7ObOFZUEvO5UISSckIQq0ULgoaOcdvmlRroXaYjR0CkRYy+D1drTKBWQqybcNea5IhIQI01nACMHZiwVOSJaLljw0BBcZTiSdhWykUUb1Epq5ZicraLxgtJXh5i3R95CcUztjZi3MIz23IIkkStAuLdWsQRvFeGuCiBof+hV1sQh0tSAdpFS+Y1l3ZDJjtDUmkRYZAnXlYH5ElECiUIlBEPEu0rqaGBRCKFoPJk/YHY1pljWyX7GJUpIZw+l8SOM6bDDILGIKyTBIslwznU9x0mKMoK0q2tpi8ox6XlMHGAwMSe5ItOoN6lyLRCGipjAGz0rKdVZzOLuJykco2WJ9pLN9BWcnTdm7ecBBFdkaDTEaYudY1jMGW4ZMG5bVgqwoMMrgfcdyecCd6ZzXr1zjpWe+wf4dy3I5wMZTpA+cw3CEOjokzBucq2hdRbCKajHETm9CveDO/A6L9pAnBhcokHzKB75XNLjY8PU7n+Z2dZkHzn8Qmn2E+W7udL9BoUtMcR9Wn+GweYPnFp7TxbfxVNwhSsNrzXN0Vz5J8fRPcyTfjdnNOXzpDvuP7dE97imk4vK730/G7/DlT/8e3/29Yx64XyH0ISb+Kb9bPMB07wrndx9E2jkHt19h/9Q2D2x9jH/ws/8p//Dn/zHVzduIUxNO33+aLFF0saZa1jjb4aTEyz5pPb8z5u5hzbzrcO2ccTFgd/sMZjQgKkG0LUIYlosl0/mMpmv6SrUuSLXl4Kj3tOjqGohsT8Z0bUVXd7g6EhYLfNNw8cI5JqWhbi0ISZKX6ERj24ZQ14x2ztB0UFUNtmsIweKdoJyURFczLCKWjv1Zzf61KUZkTK3Eu0iel+QDzVYCruswMlDNp8REURpJqsErybzyJHlKlhrSNCV2Dc1iwcKCzgzCN1TzgNCGNEtJs5RlWDIwU4q0pEzKPpKJjjwxgEQrw4KCVBuEgSgCMRoMmts394jWohKN1AYZDOUQlOu3lSKNyBDJoqFIzzM72mdv7zYxScgGBb7TeB/ZKSt8rpigSP5v7t40VrbsPM971rjHGs45d+zbzaY4NmdSlChKsmRGImIrgRwHSAQrsBEhA+QoA4IEMOzkTxDEQIJAyL8E+iEbCeQ4smA4TuTAGq2RIk1aHJqD2GSP7Nt3OvecU9Oe1pQfu6pO3WZTbFkSos4H3Htq2HtX1dpr7/UN7/e+QuHajiEGMqMRWtN4z/KVh+TZqOCcmwwiNKuW+UxjOwHS4lRg8coZd++f44ZAbiuOr1zl6tVjNoPilS++xEQrmnXHNFNU2ag4HHrP8fU5rzx/RkSNStomJ1nBTA7UpqNZ9FTHk1GPQijc6fLgji/2DnrwYbuQynER3W+x/btL8B1UGFIaqwcHGKAxyy8um1ilECPeeldV2EKLXg0B2AcC7DLf2w/f/xszf4eqqm/UvgNx4PhccsDvSuRsHSMgib2ztCW4ZNdovAvCdnCTR5SnD6FAu/e22Voh097pfC3bOViPwsLjJWxDitc97rvTlmvDzfKI8/WKr33jeZ7+xjkvPhA06hrmRsWElnLTMlORd928zlfY8LmHK+5t4OL+C8SLBWftghSvM1cZOiW+kRJvJ+DxPLv4XbSZUmc1xBbke1iEX6IyNxH2Jk7kOHfOA5+Ymad4S8oYFITN74Nv0Fe/j0bMmTw24cFzr7B+ouFkEnHa8ODqLY7T7/L1P/gM73hHTpkFEg9IwfBVe8RzT3+e977zKRjOcekV+rzgOH+cv/YDP8J//+zPsPKBpDTaamI/kEJiGAa89yPabnstxBDGoG43ckJcvpcSyYdHz/MbzV71tff3lQOozzftsrtfbCMLseuFes3NdwHWZaJi97mBUch3z6C2D5rjPvmxg0nuBAcPyRoe1Wn4/5+9ruDg/Pyc84cTRAqs7txlrjNyk2HyiFEZQgWGYcAMGqsE642jH8JYDWgdq4uRacGWOfVJRaEEw8ax7DpCSFx/fMJy4VguPK4BUxrmJxapDWcbmE5yfISOgabrOb/weMHYXDdVuH7EJUcrGdaBMhdQSmwlMRLSFr6zdoKTueLsrBnL0SFRBMGyDwy5xqvE2aIfJ4OSZJWlKC2qD2xWLa73lJlFFBYvA02fCFIgtcQHh/GJk3nFtWtX6DcbLs5acuvIi4IkFPfvXFDOSlKRoZNFW4tAcH5/zWY9cG1SMMlzTCZJamRgGIKkLATna49SGmVykjT0MRJdpO1bhhgprAYCYegZomW1XrAaHFpEQI2Y8b5HSsX82hEuCAaRKIsCqyx+CAxJIG1B1w9MSktZZUghaBqIEUToWKwDLgWS1ohyzvrOfW7m5VaMKuL8mK2+u+qpbj6BlIG+GZBRjWxSMdI2A/1wwb1lR7SKcl6TVwV937FqL3jp6c9z+vwdekpkXVHOMvIZFMOah3c2dD7g3UD0Hh0N8TP/AhF7UAqDQUXFKkY+HxI/qAx/5+//PR7IT/GB9/ww733rf4ZODeWVK/zKM/+Uuc2oZj9Eb2/QDqe0mw1PzQp69xWknHF3s6RRLW9697v4cv84R4UgVJqXv3Kbd7xwH9s7itLysZNbdD/6FL/4f/4ex0ffzeOP3eRI36cOz/NXbihebN5MExRFcYurIXL7/GVenNzjRM546t/7z/nKr/8yq3vPshp6rE2cnt6huHFMOSmQpiApS5KJi27UhxBKUJQlSkmaZoEUgRZLpgVGJ4yVVPUEMZR063ucrx4yrTOMTFQalAw4D8Nqhc0tR7MpXefwIVHZHN022KMjmq7ByxEOEr2nXW0o64q4WrKJGT5B6yKnD1fcP2t461uu8FilOT3bEGNH8KODbKc1yqy59vgtMiNRcUBERxQ1w8MLitJTTKfYIqMPgfOLNcYKZpkmyURpLbYsCFVJsVkSrcROjhCqoOl6hsFBDJTGML95HR0iwnl8jAQp8FGTS0VqO3LhGTrYKE1VVeRWE7xj8AltcvK6Js9z6BMXi5b7viMZQV0XVNUR+aRmefcu08JQzipWbQcy4ZNj4TpMUVBUFf3DU1YXS7JMMqkt06LifEgcX5lh8hmFVtSZwIqeZtWg5ZTCCJrlktW6JSG5enWGUgWNzZlmE3J7FSlqkuu5JQWza3MeXCzpIsh1T5k5jNXcv/+Ai6SYHc24NcuRybFoG6Qu6fqOqzeOweQ4L3EBgjL7+/0nP/kpnnjiiW+xGry+xfC11swDePFBlvpwg8s/jyT6/gj2H/8nf52f/Mn/YF/6P4hP9rjlw0zjIWZZcJmpldsen72TfdDTGLcMKDvc9+jEjVAdsdcnuPxtB8ig/QDsHo4aEaP9xE/8BK/cvsPlCB2O1KG9msXlj5fFTK8OGnbBxh/BPve5z/H4m57YwzJ2Tcojta0CwPuANpq8KMjLnLIumZ0cc+OtT5CKCbG6AtV1yrqiyBxqfcqnf/PXmb7zg/yLOy9wfvs2mxaqRhL9BmUzdBoTf6uUWCR4U0r85ud+j5X9Au978keYF9dQ9CR1xFfPv0wtpwT7ETyRIbSk6LluNSHdBjHlvF1g6xotTzgLE0ohaGvDl778Nd77/iXqZmQiFe+fzggffxu/8A9+h7/+H/0Ik1vXMNwmV7f58Fxw/oGPgMy5It7G2q9o3ZLWDsyygh/8sZ/kA+/9KB9781O849qtP9a5A/jIR76b9WbNZXQcL+ewuITdhTAy8ygltwrMl7aD0uyc4lebEFsSskPYTUqoHQHBwWtjtl0SU9yLIB5eBCnGPUTu53/+F3j/+99/8EmvcbFcfkP+Zef6oWjiax3j1dfAtz+W4G//7f+Omzdv7CurO7HAlOJBoMElZGwHDTuoZEgpD6BTBxW9lPbn6pBSdVclPLzudwmUELfMbfLRfS6/N/tjdH33bX/n6woOpjXMZhLnBMYqjsuCo9rycGjBWowBukBtetKmZ1g5msHjI0QXMVJCpgnO4ZY9WoxMRGIIyJjAObRNZIUmyIgpFNpIBIpJIei7SL9uaZsWFzzVkaFb97gE3TogFOT5yOnck+iTwAjomghGYoTA+YTwCSkDOJCZRGUKJTWTQhGipKg1ykp8Ap9G+kiUpus83juij3ghGPqBUGb0/cDGOSazAplbVK6wk5oYFRfLc9pBkFlDiBJHZHZ1hoqOXCe6ZOiaHtc7UoKyMqg8I7pIkhnaGqSE5AN9H5jMarKsIkmNi5EQE7k2nC83TEpDkBJQkCSLbkAhybRls7hAyohIAhkkCsnF3dPR+QEyq8m1YtARq2qiKplPDLkMREahkDyT+JToWkAFkg8EF1Amcu3Kydj8HaHrtrzyRhNkousailyzWQ9jpsjA0LScnnbkcmCQBpU00gVMEiSpGIaInR1x9K4pzhu803i3Qq0ucH5FfqtmOFsSLiQ0knh+hr97hkgVk/e9j3ffeIrHVY0Pnltu4BOf+Cwf++iH8Pa9pOomXk6RMfGp5/8Zs+t/lTqPlNqwiSu87rgxEyRzg8xc40JMKNSEG5nmLF7wvEz8eZWjc8MQAq+cdjz9tXMeVy8wu2ZQf/7HWf/SV/gn//cXyeUt/t2/fBPSVyiyFajIpmnwXKEXN5FWULlzhKj56NGc4w+/l/a0ZuYaJspSDoF109I6iRADWifyXNM0njJXICJS5UidobVGK3i46smzgrZrRpx2SPih56iwvHR2QfI9bT8Qk0PnCuUFxNEpCi4xyTKEkYRugzECqRVWwSQzo5igFGRXRpYPKTUGgS010lh8LHjTk1coyppSOoLOWJ63dEOkmk2Zziak2Yx5VVBngr6XXCwifdtwcjLHb1ZENWb3YxzFy0J0RAxITVQStMRKQx1z+t6hjMW7iJUSbTMiamwmRmFzQXQerQwyy5G2InUBLRw6KXSWAZK+G7B1RtdHHrt1Ax8sPkQGF7FGU1WKtBwZtvp1S5taUhJ4IZBZSTSarEv0LkHSzI+mzNya5dBw93xJTIHBa5xPFJWh6SVZnZhYSfI9MSj0ZEqtclLTs7k4J3rIdTZS0uYVsypSqYy6MPjOs76/wLU9wg94vyYrFEJpXCk0vKEAACAASURBVDewXDjq3KAqTaUFsetZW4FOHr9u2fQ9WisSljTIUexKwuD7/f2+rmsmk8nrWRr+P7BHnYdX0wwOg2OxWu0dmD13uhQHzvqjUAyx7VvYiYnthd62xzzE7u/2Hbn/DwKOLaOMkDCyiu0W+1dDGnYPd/0bcp/xTzH9GR73P9yyPGO9Xu+rOzsnRWzxX0KIsfFfawY3MLiefhhou4Gz5ZL5E0+ishXFbEWczRBVRl4q3vYD38lFn+iXEqMm5G5D9+WvYsQVnvxz7+PJ+goWCSEwnJ7yc//PP+Uv/Zs/iNe3UNl1kszohiUPNy9QVt9Lpj1GZfRhhVKBXBtQFTrVbFDUckavJBspaQU8IUfmwHXXc3cxcPJgxUQ7ikIh3vlRHv7DT/Brv/k0f+EHrvOON80g3UPrBiET3m9AlJTmCJsEGZ6UMt5dVtz48PdxrZhQ2fx1O6XfytbrNavVanwitvojjyhpj/MzbmF8UjzaULtz+PdsYN+E09++D3s4ze7a2Imx7aBPuwBjVHVOKK22EMOw/6zDqD3PszfsnI8xsV6t2PeJbKFfe+pfIbaUzWJ/L9hd9zDeS+T2RvNq6uLdMyUP7nPisrpxKQQ3bim3WhmCLXPYq+6Lj+RghMC7R4PD17LXFRw4l+i7gFKKJ564SugD9x6uEdagcsvgHUMfyTJFXmaoFJHLlrYPDFpQlJq0HpiqiPQe70cGFGtgiJIQI64f8cSZHTGs3TqRfIuxdnTKm44YPMIK8kqSKcXpQz8OYCbJphqjwQ0ej4QAfhOJtUBPFCqDo0JRZowUZpnERUE3QH0lJwaNUYlu61TFGImNp35zTe8Szd0eLcEaPdITSo3IAjEFkpYgJSEpWjc2Ya/aiEiShMEHcDGQT2oy3xDiqHQYhgHXD0htKCqLl6AIaCWx1pCkRMjAheuYVVO8G1VBlVJIESEp+s5hxchvHaUZbwDRY4zGoOnUWFURxH3OzC0XpGEgr6doqRAhbSeUQGWW3ObIMOCGflRsJTKtC7quQ2mDEQoZEkJI5lePebg4Iw2O4P1IEanVKGaVemJUGKXQQqNSQiEInadRAalHMZx2M5B0R4otvZcomVGV0DlJlxxxaNBCEjKDXy5JXT/2HViDKnNkHyivvoe/+Jd+mDc/cZ2HD854+YV7PP35ryPqFU+9+8+hyykXsmCNJKwGfvHvfI6/+d/+Le4rwZcevkwuS56cvI0UFyzd13k8fzd31i21mJPkjMXqIe/OpiySoL23IHSJSVGQ+ZZP/dKv8MP/1g/x/ifewTOPvZfnn/ssv/3phre+6wl+8FqJyVqu2gtyH7jwBX0aKMwJJgTusuIJM0VdmXM3XaW7OKW2hiof5ylCQXSI6Elhe56HBmJATwq0NSN17xgXjoxCgPOjiu66GajnlvnxMYvFOT4MY/O+tvgUsIVFhETfBwijg2SsIQRwbUsMfkTmpBEGkpRBWcVZ0+GMwQSNkpbjScbRJENKT/BpO4dHimOhLGWuGdLIFjR4QUwCq0d602IywwvFqnUMfcAlQVHUSN1yPK/HjJSSW8cNYpKUVqMzzXK1wSiJsjlJZKTkya1CkFDGIPQYvBgjiaYgthtEBG0yhDEMUbBYbgguMqlqbGHxEbwLhDBCBWd1SYxbONbg8UHi+khVKrYhOYaRdlIoidYVUfYYkxMIRCFohsiQepLMGDYt0o99QiIpujaShoHSjPeO5DxFUVJMaoTOqKtRadinxKYZlZVFv6a0gugCqQt0qaPtHISEkoKyzjm7dx+lDamdjAFlTAQ/srjpTJEXGX0/VvvMIVvRn2E7RMn8oRsJsV1Y0yPbp232c6favHOexo22jlLaOvuwX+R3AUJKaR8YjJAcuMT88EgMcPn0EIrA3jHaZwgPMoZvWEuXDuNuPA6Dop34WtpC1YZ+IKVEPzjixYK28yibk9evUEwnVNMJ5fEMfTRn/cp9Qhehj2RWkUlDsw6kO8/xmd/6LVbveCchWZ555nm+/MXP82P/zo+CytgIQ58S9++v+OxnnuMv/xsfZ0ni6+uHXLE1E10SU8MQFsz0Dc76jpma0seWGCInytLFxMXtu/hgqbKMzdkpZ+f3eNt738Fbjq7zicffzZeefZmbt65TTybcKi/QqqNUa4YIXWqQYkYmC2SCZeq5rgtu5jOsNN9yOP8odsjes3++zR6P8/yyT2i/zWGZbnfGDq6RV8PHLo8v9hsfMg3tfP6dA7uDCR42VR98+PhHyssnb0DbQZsOaxyHY8LB890YXCYaLhm+9r0Wh8/35+ISKig4PEdpqxFx+Rm793dX4D4Zsv0spdQl49vrGPbXFRzIIIhDRBpJPS25+8opq3XP/LhEGD0uOlJiNAitOJpZ/NCTto0ehZWkXJHLRBjGhmQpGRfsJGlaz3oBMYzRkB8C3kHseuQUQh8YekcQcSyZ+ICEUb/ASrRVYxXACHQBeNBSIJJEWYWdKLIEN67n+CHiBggpEfoxui5nhn7QKO/x3fj9go/EzaiyPD0pGNoBHRNFYSmKHG0yqgo2QyA6T5SaoAR9H0hEnNJYIXBJEP2Oig+EteP2LqBIGDk2uWipCGlkBDIajBIEBFZbPI4hKHzfo7IxMIkx4YgYrUgRRIwkAiEKBAktBRbIMsO6DQxbppnMalI30LlAXk0QUrNjfMIFjAjEfsQ+BhcI3uN8j7EZKA0JFGNDjjKGelaz6VZAIgZLkhJjM1JWoBgwIlFUJUaODb0SQ3QtPkQyMTqJoXV0tES3pg8aGRNqcAgHIni0DGhtxvHrPRmClBtElhPLgtAn3vfdH+Kj3/l2Br/mi39wmxe+8jJPf/7rHD+Z+PrZ9zLVGS+fLbn90ov0L/4B3r+Nx4uSOy7RpoJcFBSmZOM08A0kGSkORClwAqJMvFVX/NLg2Nxdk5pEkVlk7Pj93/w9rp3M+Z4f/zBf/Z4P8Nmzu3z5uY5f/F1463sMb/7eI0qpSGpUE/bJ08eGwUt6lXNdFzgjWSPoXcDmJXmek/uRMcq7ADFAlKNDGTXJu7F8nDzOJ6S0GC1xfkBG6IeRASsmSFJTThS925BSNwZWQuFdh5QJKTSZ0ITBkQIkIel7j9LtyNGf5JjhiAkXB6QpuegjhRF4Lyi0pa4rshhYrxo2TcAlSEqSTSusstjc0DYO5x2Dl0jAKNBaA4agK4RpSckhIhSFxBaKMpOkqFm1LY6RttdkOZWJKCkYtAAlkAqCELh+p1+QUEaD0ggxMqKlLKPtAyqTKJONNKPRs1w3ZEYThx6BRAiFFJIkJaSINoZ23YH3CO9IW5E/WZkR9e0jCrktr48sbS5JpsdX6bqGIQwMPtJ1HqskofOE4LH1BIUm+AQBXOjo/aglUhpLWVagDKkSRNdzvvGsQ0R5h/WeSTU2Oqehxzk/MkHpUUV4GDyrZUudebokoDAYq9DSkEQakwshsMUDotQb0zV9zayruCy1p22W/rX3ZcQsH6yW+2rAPmA4cIa2CZTDBf7VtqN3ZZetS7Drk3ytr3ooMPbGdZMObBvs7AIBAA6EpFJKY3IQ8N6D6Akx4ocBoS0mz8nKgnIywU4mFEdHnN17MCauhEbpHG1LUnOf8y8/yy8/vM3X/uAZECV37p0hTeSTn/4C7/zQh/nGasHFKy+xuP0S3p0w1ZozH+mTQckMNRYcgDUSDWkY6dFJaCGYCc1Xg2P18kNKrlJZw2ZxznNf/AqlznjHd93iXR96L1/+rQu+/A3B0Vwwu26ZPjbBIEnCEdhLe43QHgFzmdBid7/445/1PdXm9jH78X81tORgzr7G9H0UQ5+45MkV+x3SVotv961DCJex8ZbB7BJmk7YVtW+uRHyLBoE3pu3G+1Uv73z8tH0yqow/GjzsEgSvlVxgm859dH8OdmR/rzsMUl7dCyEO37sMHb7tz3pdwcHESiZajo10bc/56YJ8UtGdL4h9R15n5LMS11zQNY6rdUTrNJIppogWgqMrBU3X4Vs/CpLpEYumtGBx5tisBWwXtZDA1oqUIoExU9b2kSQCuYr0bSQMCWUEJh+PE9wIBQpyZEKwViKMxEwNZmLIB48qDRsFOhP41YCMiUktsUayagPCj0GD1OOFEUJkfXrG8WMniO+Y4RcDmTJkRYHNM6YBHg5LXOdRVYGWBk/HYtkhcwN9oHMeA2gBvt0wFNnonKW05SwXNG0kDoGkPFEakJCCwwdIpkLKjNOLlspIjNQIJL1PoB2TaYGKY7AkxEip6vuETZbMWHITWFxsWC1aYkxMKzEqyXqB7zxiyy4cgycOjmg0bd+RXIQUScnTbQZu+xWzo6Mx4BMgtcZUNVIpZpMpWe3I2oIYIUjDOhkyHamtoC6neB/p2xbnFZtNg8gNwowUnNFFBtexbjokDqMCQ98hBtBCYvIMaTL6dcvsaEIIAyRJQuO9QMfIxz7+FoJvePoLz3B675QweN72gRO++szz/O5z97kSNJ/9nd/n0//wHyOe/wJ/41f+EbkymMHzniu3SMJzwYZaga4+zsafc1zU+GYDsuP6rev0IfCZ5oK+icg+srhY8Nztl3nx2Rf43/6Hn+Vf/dd+lO///mtcfP0GX/nCbT71z8/45Vc6/v0PvwNjjsjES1yxFZUoOG/OOHWJK9kRlUzI6FFhoPAOAiidk4sNXRyIscOHQJICazVKzXFR4ILHN2tEFNTRYtLY4OtConcRIQ3TSYFUgmFYMZ9lKFngh0ByY0AY3UBShqKwJJ3oWse6G/H6s1qRzKhzIYREikgaeppBEpWiMBEpochyJlVBuDjl3v01q4sWkVuya9cp5kfkGgQZbnmfIQVIGoVEpXER3qwanFDYskbZgBsGfOiwJmOzOsdkM5rzNdoqJlfnYy9FGkhNT13VhDj2FnjX450kIcfKmc22jI/bDJpPKJ1TZDlCMkIFB4dMkSLXEDyb84fEJDFZQV7NEWnsqTg/WyCSh+iRbkB6x3AhCMbjQ0JbjdFyFARMnpWAk2s3WTy8TzdsMCHSdB2p69Ha0IdA3CY5tLUoazl/6TkeLjdMqhwfBSFAXedAwEuBWA4MXYuIHqkMvVBYExBakklDnWuqTBFDYHWxpC5LjsoMESNu0xN6xcnRhNlJxenFGYuzNcpadKZxG/eHLwJ/RuzbQjAOsp+RtGXUebXIUtpnNndO7B5osXXihZR7p/4yyboVh4vpm0S/dgv4q77GfgmW4rI/Ie3SeuIAYXGZVnxj2tZB2TebPwKf2EK1UtquN9u+jYOqTb9pSaJjaFv6zYbNxYIkBFlmGfp+62CqcV/vmOaW5eB56cUX+cw//zSZzTi5fp33fd/38zM/83f5q//lnM88e4cv/9ovcaPU/NR/81+jt/ect0+OSQQcHUZajHo7Q2yZmhl+aLHZyBTXx8izriOuJHUh2Ww2rM5O+fozz7F4+Zx3feD9/OAHj1l+9SoPVoIvfb3lRiN5340nEKpCc5dKlyOZSmjpYqA2J+RSj1XGP6FwcA+T+6bD7eiI5dZZvKxS7Zz1Q+pQKcCHy34TsXP4t+czhrDHwiMgxbTtY7gUw7sMHEYMfgwBtsc+/L0JDom03rC2nekcOtt753xbrdlDGh8pXwLpgElJXI7rvv+Jw1N6kGzY2o7lKsFeg4Ht40Pb9YTsVOlfqx/htex1BQfLIFh0EcKAFgM3btSURcn5Ys2wXmFER1blPFh3fM/33uDBKytSbtApoofApo/Mr9XQa9TguX9nw7BxTI4sWivqE4tPA0PrESqhhEQpj5hqhAzYPCKHhIuKaA2zmUZcbHh5veWiTWNGRwFZIRkWkdVZhyo00ggmhWR2LePBaYdXGfNJjiwF2ipMLrkIAlNZNveXZBqqiUUZydIIpic5iwenOG9QKFKe4aQi09A0a+pC05z3rJslm2VDWVpiSvSbiLYZnVYEK6hUIrZr7p5tePOtI7SS9FHgUiCKhvPlBVePKvKppW9bVi7hkiLLEzdu3GTdJ0R0KC1RRGp6nEsgoWka2iFxfHzC1StTfO/xHoboR/iG0cynNUJZmnWHrmbkyuKDwW3cCAXKDc1qicgqcpXQivH3SkUvJDIl+r5FSYmLIxyo7xxlN2DKmji0CCFoe0/XewodOJ6XtEtHH1qkyRiSZtEFQoTJtKbpW3IBIm7l4IeAQzO7NkPoDrFo8NGhKo0uCuorE3QYGNYL+t7RDwqdGd75poqHd1/iRZ+xuGhwvsNIR1hv+MiHnuTB4ja/8Y9/i2d/+Te4+MzTqKNjfu6LX+KvPPEuPlhk/MLGcR4TT5mK6+ZJ7qXADXOCNRnPrp6miQ1vPnk3D4eB5cu/Azpya1Zx77O/x1e//AkCgU3y/NTP/jSTlSedLrj5lgp3reR//NUl//bHXuHoX/kRhFii2FDKBlPfYO7O6eQxD5ozFA03r8y5WtScP7hPioauD5xdbAh9gxYJm0NZSe6c3x/x9w60NChhWbfDGCgAAUtRXRmZbLqWi/O7PHZScna+HFW0o6DvW4bNgsnsGhCJfY9MAS3AKEnA0MkKrQXKedzgEcpw9drj3Du9x5EJJBeoJpqqyiDLGYrI5Eiisw3VlWM6ndO6iG87hhBQ0hJjj5YjNtOnse9ndX5OOZmCych0JJPQe0u33rC86Lly3KP0qPBtQsLEiIgCqTVtH0FY8kwxnWpMZlG2pN+MULS2d6ybjpAkRQYn166BgM3gaDYdYdNSWsEkk8gESigyKRExslosuXb9BOFXSCmw0pKCYnAwGIMj0i4Eve8xpqXMJbWxXEhJlmtwLUfzkr5TDE3LbGZ4uFigc0WzHMfUDwNWCoIbUHaKzQWTWUUEzlct2fER+AGtLS6ssXHDqDdtGXygvRjo2sBsVjOblqhM0bQd1sHVkxHP3AVoGkdwnrwq8EnRiZwoWjIzJiiEe2MEB9/OLiER26V113iQLh2XreDv3h5Zhver8Q4rcZn132VAdxlRIR51BA4PIMS4EO/gSzsH67DUL5FslQYeoWx9I9qO1QUux3/no+wUZXejnGLcitzJfUy018ZIo9BicD0xJJySeDds+znUGOwFz9lu7Wfc33tHuh/5yid/m/z4Cj/9X/0tYt/j28jw/vfz66envH9yhceN5jeGwExIrskCLTPaFJmoEiU1Lzf3yE1JYac0fqBdPo+elHz4sZs8+6VPc+/8Iat+Q+sF/8snf5UbbeI7HjN0swmDj3z6duQdL1+Qv+X9CO5BWqLFHKktNiWiKJja4z92n8GhjWxTlzAieeB1p21yZDfxLnsE4gFtcNoHybv3xzP4SM1gT2t8yP4zwpUuFdW3k4FHvNg0+mhbjdlHqkhvZNtXSLj8PYcQRfbzX47toBz85kf/PHJMUrqswrzmJ49n5tV0w7teJ7Y9zrsqZgjxsnrwRxDNe31sRadLzuuKPFdo5Yg+UOSJ3GuadcNLL6544a7i5FrJ6SsDp3fWtCFSTUtuHGUIOzYLr7qSsFkx0XHE4BqLWzuWPpAqw9WpwijBxsO9C08uPCkpmt7hnCdpgU+J+99omFUSU0iyYz027oY0QiFEIjQDV6aS2ZsysuMcVRqWVpPPDEOnGfKcos5oLxru3VlS3dDktWCYKEIzEH1kPs158t0Vy/MNi1yhvSI0gXa1QcRAHGpuvOut9A+WfK35Bm2zRniHkJrjW1PMLJE2ktg7livPfZ/ItWRSKE7PV0QUWghkAu0NWltu32s46SJt68gyw/HJhKISJHeG9ALfODaA0BotYHV6ziJJZJbx9u94jKPZDCkMOoPlww1dt0Bmc6qpIO9aQutoOkcocrJJAVIzuEiIkGE5uXmTdtGjakNVZ3tM6JWjijv3HjLNBcZYZBQItYWPpcDiYkk3uBHeZQS1lYSk2TiNjA1WjHSXru1IoWF2VJIHDybH64wgxuqBjD0ys5R6zibcJ3qHRyDkFGkk123i3sPEQE6yGdNpzs2rR9w60mwuzkiyQttIDIlh1bG6WEFIvPDCfe7f6xiWAaEUeZHzwY/8EFEIWuCtVlGguKnha95T43k5JLy74GH1JFdmBW/PDV9bPcuv/vB/Qf3Bt9PUAb9aMywj9QeeoH/GYX79E5zaK4jJY8A1+mdzNgvLd/3U/8Unf/svMj/+LmJaE1IgyBl90Nx+8AXWTlJkc4wQnHUr3Nrj845MZAiZI7JEFJ5NCEyiwOiOJDRFNSFTBbjIxntO1yuKaoIVkQeLBSEl6lxT5zMuVi39JuI6h80085MjmE9I3qPMEe2q5eLhgmbdEWNPMArTJcpCMMsz1t6zWC1o25ZQzUBuyPMcpQSuX9E1C1bLDSTPdFbQ90smVcV0eszp6SmlgvWm5dwNaK3JjSaThjAElM45X6zInENpBcExrNf050u00TzzzIvM64KJVVz0a5ZnFqO39KY6w1qLkArnQWdmxOA3jjqDHEjKMkSJkBa3WZFPZuS2wNYGaTT4DdVkRkoBWSRE2iru9o7V+QW5FTx26wl8u2HdrNEpYaPj9ssLinlBXlZII+nTQLNaEIVCLGB6dEyR12Qm4FRHE9YUE4UoDHla0/lEe7YiSxtuXr2KUp6iKtB5DioxeM/t51+k8J5XHpxy+6yh1Iar05KjmaRNkc1gePxIUxUFyFEzYlJZ7jSRe4Mkk4mmGZBEJpVm1W1o14njGyWhzvDtQPCevChf96LxZ9kexfWOLGuQLnnJxeUC/E37wiP4nx2nvBBbsbUtD/3O9v0PUo56AXvnSIyO8b7B83KHHV89QCTsX5dSvqFhRY9WTnbOywF9Leyx8DHGbWknIdSukhL3tJ3BhxE+zJhV3TmiSo59j5E0KgbHy8y3d46h62nWDVG/RHZ0jUlVYk3guK546saTI5QJeFIJrggFYmQ5skQu0kAMDV35OMfKMJWB+688x//+H/5N3v6jP4y3Oa+8/DKuUMzf9R2424Hv95ov3HvIYOb05wWLh0ue/to3ePpTn+F/+ukPk9R7GClSNFLOyM1VxhTmn/DYx4j3HrVVY99VCfZu/dZplXtoz44KdZ+PfsSx310f49iPjET7Rldey7lPeOdQSu+vnd1lJLe9YgfT4jLA3jmwb1Dba08I8UhgsBuXHUsXr3W/Sa/65Wl3n9gGaq9Sexf7/y8rPRyMa9xVPIFXD2k6mAMijkxKr6dq9fp6DtYdab1mEBkyK3jqqVt84ZlnyaTBaMitoBOC1SaCi4RmxaAUqQe/jDgS2o7S6G5I1I8dUyJYLxzDDIZ7G3INmdIIKyhS5LoMZN7woA2su8C6HX+gbSMiwZ37nuljhigk5kgjVMLdjwiVKK4rppVC6wRaoApLpQVmkjFcSEyCvosMCcpphhg8vtuQiUCbEiIFku9ZnPWUZcaVqeThg4isM8IQWa17rpzUdPcfbMXeNMfX5mSZJishy8fGwvOzNb0X9C4RvOfq1QmCRFZI+iAx2o6NjJuB9RCQ3ZqFjAhhEM6zXq3BaIQP5EjWbUvvBeQ1xXROPk+ApB88ofM43SLEQNOPN0+d1/R9i/OJmARRJOp5zWZQNDFiU8Rog0Die8dm3TCZTzEykIaBECG4EZd8/cYNVosL1ps1UlmyLGex6LhYL6jKMVipjMLYUe01RMG9h+fY2JCpHi0lWnlM5vF9ovUtSI1JCe/ABUkxrcgLTddukGqUvQ/OkdeOSX5Et36IFIn5PMMYg80zilxw7/49TuqSzWo9qsFmEEzOuZWI4FBdS7x7Ck2PsSWZqXhsI3hmFlARpnG8WS6BtyIIGB7XJUEaTEqUouH89tP85I/9p0Ainj6kSWlk7ClKZGt57AM3KO++xJNPzKnkQF9ueOXqY8THP077j/4ef+1v/Cx/4cc+xgefusatqSG3jsAM19zDRUlyK1KQKCxX5lcoUqQqM9pYMfTjwiliZN2sKepjTheO9TIyyQbmVpIZzfG0phsGFqtznA+YoiRWc9ZtR7dcE6KlntRY5ZBioJ7WFNkRy4sVcVIytwq90qyXa+o6Q/qBUmcoabF2wOaKBkVpIMiCi2VLZ3pESLguMpvW9Hkiq3OuzabU88dIdkI+mXB++2X8vObJayeEKFgvW5rzFdL3lFXNfF6NVLR5TgiejQhcnSgevPKQMlPMZjV1npF8YN102CLHuR4RI56AEgWqmAA5iMBsUpJ8GvVK9Nh/lFSi0ILM5KNo4AQqUdKvc/quYb3pEKpAiIhWMJ1Uo+iUGwiDo+s9wxCRKOp5yawwXKxWzCcVoe9ZnjUsLlaoIiM/nqKHRJEChZGUk5LCGPzDBW3sSUoSu4HUeXwUnN5fMq1y1GzKkBwSyDKLiBue/dornK7XlNWEm9em1GVOHxJ0A/O8QCVBXeUIEoPriAmsyoj0bFbDiEeVib5rSUOiT5ZiqQly25NlJcXw7ant3gimlEIptV8MR+dG7hk89gJujAu6UpfZ0B1d6Q4GkBKkELcsLgmxFVYKIT6qTJsS6iDjuudN32ZJ5e542xclOyjAFmKze/xGzqTugp6ULh3Qveu5NSFI2wBgFHDc7XpQNdlWZfYB1A7kDiOsJYw6SEoIfBjZjxIj01MQCe8dWivKoqYua6TQHFVHTPrAqQ2IBLMEXgo0cJQAJDNhiUpxC4EVLZ/73Kf5n3/276Ksxt+/w21p0MagVYEROdffWfPCs1/nyRs3uHk85a4oePZqjjuWPPhnd/hf/8nv8eP/+o9SZvl2PEbqgj8N5NiOIWc3T/fQrh0sKO0YdAQIiRBh71xeOugHvS8HTu6oTh72rEPbd/afPVZ0xnOtlNpWMOL+HB8W8HbsOpcZ92+VGX+D2DYGO5zj+4TBDqi4raKl9KoNGQkTRj0Y8UhfwHg9jPeGEY54mTjYwWSlPLjOtoFf3FHEPlKdGH3EyyLDdo78SfUcPPbmm7zpLddpQk/vPBfLc0IbcApsVmBtQR8jGym4vxmQVUFhBF2E9XIgiohPjqNcsGoCdSYpjWYyywAAIABJREFUSk1Vj1/An5TE5En9gFASpS0kWN7fMPQO5wI+jNj45AXJjVjnrvEkHWHLfIMbscP1iQAjEBNNyiCIAMqSy4QpoO0Gmn4UDKtOKtabnmKiOG0cnVBEl2DpsFKhc48IgkmZgSkgCVI7jBl413BxNhC0RWpF0gJExLcO13ck2SGMwQqBNRIYCE5SXp2g2g7hO0QSaCOwQqLJQEuGZkCqDKks/XpNWc1IUiCTQCXwfU9z8RDhB+rjGZnUeOfoWocxYw+GLjIE0HUOJSJKa6I06FwTNj2Lh0usENRlQVmWSKtJSqG0IvgRvkQape6LomDtBnwIWCUxVqBkYOgGREjEwRFSwKsBnCQJTbQVvl8hQk/IHT5Jght7LayWDCLHKEtEkSmBQhI1kALWWrwQVPMJsu3QRLIM4pBTEchyidxCnYSQ2GJKM4SxtyHsmngcSa1QtaF77japXaJEJJ/PmT3+BKuvP8uv3K5488mc7ziqUbllKQUtCU1inXquiYHCL/nqM7/Pz/2Dv8+92w8wuSG1HaooMHmGNhLfr3GbDFk9wTdeviCPA295k+Tjb7vBrxt4/uSYRdfwjbsPKGrFal5xtRbkpSQvj5BdS9sNhCDJZIa2AsXYuFcZTSayMbhTkiIrEWjOYkfbN0hnyaucsrQMJJJJbKJHiISVARF7YnJUVcZitUEpO5Y5vUD4gC0SSiQQkTC04AeyTFOUGWk90GwcqTYIpanqiqqo2KxXJKcwGhSXJeaeRJePGgEum/D87TusF1+jyDS3X7jHE28+IdeKKHNIBouknFTIcsLpvXtkCKzcKnTP5xjhkCkx8waVFWRKIvoB3w60mxVHRzUhQd978I5SesCzaR1lPepCpOQQaYTJ2byk7Tr88ABVFKi6IOQjDbCPfnRI/Ej1qXWGMRntukO1jt71bNqB3gVGHmvPZFoyPZlC52hSRBcl0gWm8wqv4WJ5DsqgCousLNNJzqS6woPTU4o850K1+CJS5gXRJQa5xf4mUD5C53CrFWVmmeuaKyc1N65PMEqzWg7IlHNy/Rh6h9jqF7TtgFBjMKAC1PkYAAgkhJHsYNgEXIDMSLQSpMHRrtevZyn4U7f9orVbZP+I3lQiISQjZIVLvG2KB0JpO4d9WxbYuvIIeYn7lVISwmuIhnEJJ5AHmdRLyBFb/PD2+8Mllnh3oF1mVnDgcH0zxOCNaPvm2B2WmsNMcXpkG0gjJv3Adg3aOwjGOK6j879LjaaUcOMGl/Sb++cR3w8MmwvM8RHzazdIRH7t//h5nn3r2yii56Pf9Z3IqqITAkNCCZAiMkkBFVs+/8yn+Y1P/RbnDxfMj6f8uXd9iM8/9zWkUmO1Z9hg6wlen/DcC6e45cDjb7rFZF4jnealx67zAx/+KFYXCKEfbcT9Uxn0b32d7GF0h3A52AcScLDvDnq0c9wlyHR5Ti6ratszJA4m9TZYE1uhxLTtKRl1DrZih9tSnJSSmBJy/w3fwCZ2HQeCGHfN2WLfQyB3jE2vseu+3+ORV9OuHWEMDF7zvO4CjwPs0kFAd9hXsoNG/svY6woOqnlNPa8Iq0DUo9y0zXKadcekzMkKiwgOcIQUwVpc8HTe0/qIj4GYIjrBsgkM5w31YMh1YthOGmMl3oNgjKSkFgQR6f1YDRCKkbfdR8IQ0SLRNRJTSuKgkEJgt9oFWghspZhcr9DVmEWiD1ipyGoxwpAkCCUpM8VyFYheYjJF1JI4RNohoQtoW0cfJbYqULkmRYl3gdWqx+cSVCIrDUlIggv0a4dIA0NSJJFQKoyLSIA+CVRKNO1AcB6GHgNYm6MCGCMwVtK4hNQKrRVSGdo+Maks0kZkdCTXE4YOowTCRZQQW0yfQEiFkSNHvBsiSgJJkqRCYolJorsB340woLE8G9H2/+XuTWJv3dLzrt9qv243/+Z0t69yXZftsiMXWIpIUCzAkQKREjGKyDgzJihTZsyQkgEDpEiMGSIQDIkUESCSiWKcYEhhu8pVt+rWPfc0/27v/XWrZbB2d07d2AdE2bleg/PfZ+9v76//1vu87/M+j6SuDUYroLjxppTIAlJMuGFAUxqLSltYyQDJLPHTjBCRWSS8kqAsGQMItJbM04TzCR81UlcYLZmiJMmitGSMolKaOQZilEglICesNUgB2kiUTFijEHkvd1tqyiVQU4YQCh1EmpokFWRH3QRcdEipqBtLWC9AGRZPn3H7wx+wsS3V+D7dvKZbtAxIPn/o2fUTm+c/5P1VQmx+yvf+xe/wv/7P/wdSapp1XR58SiBFpsqRK+WZ3cAs16Rs8Mmxub/n5kffZ3F5zfK9FYuVYXt3y09/DH63Jj0WXCZNaytinIpDcSy+E23TEbxH5EBra7xMhCgQ1tLWLd7DRddixgmlRJG/zAmlMiFkdKVLnkpC9iPgiMmRcbioCSkjXMCIjDU9/bBj8Bk3zcic6BpDVVucr0gug9LYSlOLCmEN8y6jsycaSWU1BBAaqq5GtUuUkQzDyP39DdubeyaliW6kkpkcE/0w0Q8OZs+yUgQhmRPUZEQMSKGKm7CQtOsVTTQkqUkuEgnUdcuYEtK0eBdxMZBjRo8e/I7RSaStqKxBmyKNLGVG7k36lIxUVJgMMSSyNGgrENoTXECGRPYKEUNxUhYZnSNWZrJIxBwgKmYXAEV0CSEVddvSZFCVpd9tScGDMcRUKpXWQK0FlZJc1S2VaUrzszZsbm/ox5EqSaxS+MExbbaEaUJZy0JILq8WNF3xQiFGpiiYXaQVmpwExlYIKXEx4MYBjaRrG0ylSjU0KpRmr2iVsBK0SswiMPnw/20G+TmPt/W9/6RxMN8Se5J7iWXO5AD3AbxUe3OzwzrYxy77fKZU8phRPRmgFS7wgSpzlh88fl62YR/0C8ERAZzN4edB8zGDe/b9r/M4eTucMptwlsSEUzN3fnOv8/69nDP5vJfjPBu679vIhyrNAUzsPy8u3gJZyEc4N/Lqi5/w5Q//gM9+/w8w0bN5/jlPPv6E7vIKIRQ3r1/xwXvv8ysfXPLTz77H7/7z/4vPfvQSU7dcXK/Y9VuQCSM1tSqiKFVOzMnQNgt2fc/96xfY7HhWK8YPrvjkvfdPVLafcwD8dgApz4L2N2QxD/yTw/8y+0bhs7rBPp0vpEDlop1fkj9v5vlPHPbTeg+9JIfMdLmfBEe4J86uBc4By9d0vLU/h0v0q0DPIUHAcdm3vFaOHxyO9Lk87VtiCftn2xuryPlnrrLj/Sfe2FzOq0R/3HgncFC2pSgNKK0RqsIuYbcLoC3C1OQMyyahjGBKib6fGVMkKoiiXJNDzLgYCQ89figqQRmQVqEqQ1JFXxpfDka1VIQHh+kkNiemPhKmRM4J7xJYhWmLjKGpigKSXWi0jrSd4eJpg7HghpmUInWdqRRU65rLJCBk4hx4nhNu52ltCay92QfdlWAYAuMYaQjUtmRZU0gMvcMnhbKKusr7ACASdiPkiGtWKJURMoKMJCFxUVEJz/1uKtn8lJAqI3VEOtBkGqsRnSHK0v1v6o6HXWKtaqQFGTMqREQqBi7RRVAaWWmkNEipyAii87g5YJUpGulJkbPeux1IpNJIW9bjUkIHjzICJVMJ2kXeA4TMODriGGgbi4+lobhMbAofHCIHrAXnMqgEKpGYSwZ4f/ynfiREiW6KY2ZKhSpTJC1LFjqHiMuSFCLRHagVBluXQE2JTNYSY0omtDSkBWYXMFEwRU+z7NCmIkVJXc1sb3q662swHdViCcqwenrFdP+Cta3YNZLnYceyrklZ8MWLB37/x6/46b/4HS7eE7jXn3H7Rz9ivkkobagW5VoPKULwGJF4bBOvwsyctnSNoatX7PzM//4Hn7P6jmR5VXpc5s2Ge5HQMbI0DUJa3KImj4lh8OSY0NJiFxdALv0otkKIjPOJ3UMgzCPGdqybhs5kEAa0JkRHrSUxKtaLGmJGxEj0AzJ55jAhZMYFR3QJXFF8cmQ2w7iXF81Yq6lrja0twdWkFBBKl+Z9mSAFmqpQVrytaLuq3OADdF2DXLTEENjePyBzxFhFcDOPr2u0yCQ3c38zcv8wYFNi9WTBLCpsZaksECMhBAQBVVeIdonYU3nmAJMwLNYVKkqUMSQ3l2s6U6g/biTJJc5lmtqgtUEahSEyzTM6R5qqpqosSipSKuBcqMw0zQV0hkTynuw9i3pBipZIIktQMjNOJfDY7RJ304iRsjiK18Xd2QWPmxxdVWG7lpwk4xghTTgVCLFk5S4XLVJq/OgYciT4kSVV0VMfMuM8l/tUG5SPIAVziMQ54EJiGyXc7ni8WtL4QN0Z6sawGUZ8LL4L2tTF0I6ESAqpYLkwqOwwIpbytErFZO7PePxxtJq3pfn+VePtbNvBqOlcTvGQlSuc4TdD/IPqxwFIFC32dKQFnZf/z4PgdA4gDhP7MUN+CtLOs+fkvUNyOn3vz8P42fN4Fv4fsppwFhydmUcdAq69ys1hHBPW+zjznMeeD8nRXGhfUpXKz7B7oN8+ELwnh8AXf/gHhBD40ff+T7717W/z9MNPyLrihz/8EX/7b/1HhCdrXr26p78NKN/QNJHlxZLvP/9RodbUirWElc5MYWQOil/45Bmbu+e8vN+wkJqnH73P9OzyT5Uidm62d35r5FzA08nBeA93D0HsGYg4NNaWBvry7EBkxLEyk/f3wpv336ER+VApOACNN+6RA2XusH1fEch+Hcc+77CnIJ7d1/tnxAG0ftWlcP7Wz4CAt5YTb70+nKu3HZWP3zneR2cSt5y5sb/jpflO4GD2npwjlRGMY+T1KBFac/n0MXXV4GNmHDyrZUcQgUoq2PaEOZGQ1I3h9Z3DXBmMDzAH5u3Mbm+WdP24GITMxuIGTw4R0Vq6T1aYO4eRgiw9MWTCnNAm47PA+0wUAoxAWUFTC56+p1lcVmz74oY8bTzu3vHkgxWXaxg3gWffeMx6tSBMnp9+/prmlULOhQ6UO0OzNlilSINnfoB+O3O/ueWRqViu21LmBDabLSEIqvegrixaBpwIkCW91KxqQQwDOSakEkxzQuqEWVhE8tRWoRUMLlI3BhUsprJoIxk9DHORcm1tR041gpmua2nrhjDONCrhVQKhMMKUbOaUCdGBLAGdQoOU5CCIDqwSjNaguxWeQrkQfiZPPdJYlErMLpcqhhZYpRh9RgqD1BVSRiLFnwIy4/aWxTqTdUVhLiRCyKQ40S060DOyqoj9zDBOpCnRpYyoa5RIWCvRGsgJRcJI2IWAkZIsBVmD0oI8OVyyVEZQVyWYi9ERoiuViVmxWHdILZBaopPGucyyWWHaS9wHinmcyCnTrlY0jSH0PdE/8LCZeHjtyc6zblvszY9ptCRtJ4SsadcrLm7ueHE/E8bI8v010+sNhEgymvtgEbOjNq/ZPigunn5I016Tvnwg7wbyHHDtkhQzOQS88zz0O0IUNG5JKxIuZNiDND8PSNWghSmqHqphM038b9/7giub+aVPP6ZWjrbRICQuOlR2aKW5WrVkP+CmmWl2TMER3EjXWqQCsiCJwJRmhkEhp4nOtgitqZTB5IAUidrCLAST94yjImdDMhktE8uuK1W2dolSgugSMWacSyyUwKiKuF4zhIxFcNV2XHRLko8M21vmTU/qPcpabH1N0pILu0J5R/CBME8IP3F5uUZWHcPNDUYomlaT6gpZQT9EdFPjfXEzJiWsSPissFrvMzUaoTNaGCppmKaeIDKYAnKT91R1RVMbSJlQV+Ta4F0gJ4HQFqUU1eWa3dwjVFFTS7KYmkkaNg89rRKsmhpbadSwww8zy25B1Vl0a4iDx/kZ5pmkDarrePVqw8XSUStBf7cjkHBZUSnoWkVNTadWZCMZYuLzHz9w//IWv6zRpkbWHasGVAzcusxySvjUI/E4H7GVQQVHjIngBUoW2VgtJFfLhpR64t4BXUlJ01bvNmP8XEY+Cx+/otSef7Zk/sf9Vsnuc6QSKa2OARSHSnvKOBcRUh4rDSUbXZYLviC4Q+XhwKcv23baHkqq5UiZ2PNbjg3JQrDnax+CrLL+Qjcov1NUU8U77Nu/5iPnIlR6pBCVY1mYQ6fg6ZTATGcZ61MQehrijWD3cHzSqZTzBuXl/HX/8EB/f39AdAixl+tOmXG74cuffk7TNNR1gzYVf/M3/z5SCD7+q3+Ti3qJG3q2P3rAZMP6yYqbzz4H7fG2YecFbnvL5bWGnFg8vUZsRlbLSz6+ekacPDG/pUv/cxw5HZDrmaTpGYDKh4vurGJ1bkx2oNudL3+U4swcqUHnrryH35R7wJDOAlxBRkjFoX/kVCk79ff8eRgZjnS3QxLiQCM6Hf9yQg79ACeTQE7PEyWPx/q8ynj8/GgWlw61zPK8ypDzm8pSb483kxmnn32XM/BO4GD0I9PcYwhcXy35ve+9oM4zjz+8QtUlk97sN3op4Ae3O1arCtsqHgbHPDpkDmzvAtdryThEho1jdBk3RVZXhoVVCCuZvGCePHnjSfeRpsr4kJA5IUVGmExOguZK4vpMeynJCuYAi4VhFpHh+cR7H9fsxp7NTSJ6QSsDVxdLPnhSI2vYzD0PDwNf3j2QH0bUwuI7zbYvGu+VyuRZkFrLeDfSNBV1zuTRczdGHvpEDJ4Pn17y+NmC5ByD96jO8PkXW6gEd3cgUyhzkhIs15GPPn7G3XbLw27CCY0VGo1kJnL5+Io6gR99ubgiRDfS2Yq66lnsA50UBJPNtJUlo6mbFZvdzO7+njkUJaFlpVBVi5KZumporWGUjnnc8WzZIJPAzZrkHX6YmJ1jdanYDQNCQWNbtFbEAFWjGTf3ZC3RyiJSYI4TYxSsnz5BqRlTGbR29H2Pnx2Xy5Zh3LEbZ5adQVYt0gv8mElUzJNkjI7L68XeYXuHEoZx8wKvLKZWGDJGWxZdza6fSLPDNBVJzPhxYB5HlJJ8/Oya17eOZrngYlGTs2CIieXVqphdiZ4Xk2J0DRJBW1WIGNilRLeQ1CJwe//Ay+cPLLuGTz66Zr2MTA9fcvPFjnGzJceEiAm3ndl9cUdlFO2ioWksYYadF1ytNIvZ0W8mtsEyyAr3w+dEqTBas5VLTKPJY+LFD1/xzQ8g3d7wdGlZ1gahFJudY5zvWbYBRQCpcC7QCsVf/43v8HLaYk1F11TM045+2OC8Z9FULNtLglBMkyT7gIkJqWue9xM/+eKOenHBRauxnURKuLndYERF1rBamBLEZE+cdnz5kxcsFxXrpSCmGWMkprb4MXNzc4sHZLAsuyUyKwQRh6CVghlNt9BMEaqm5v0Lgx9B28Crl/csG8M337vmg0cXRGW5nyUqASpSV8UwMU1Fa1wow3pRI3NknCLeC7q2QYqRhKE2NU5C3/fcTxOPP3gPJyT9dsLHTNtaVq2hrg1iIalxeBIqBbxL9PNENdeE2aNkoQhKWUJUYzVCw+QTZtGxu5lBSJrVgttXEbUdWFQtys/MY2KKkWHUPL5+QtVm7u9vkEJw8cgiLwyvbjxUFbsxcXF1SasScz9yu51xdZlkt/0DOXligiwE60qxshXjfct1Z6iWVVH5khXGSuzqEfcvNnjnST6jciAME9llHj3tcCmRfEBpjawsiNKEbxrD/WYipoypDJeXy3eZCn7Oo8yoMUWUVGdBxdtLnVURvoKxL6VA60InTaFQD0tFFYTIJ+WhVHgVch84JSGInFxHD1zpxJ5Wsa9KqAPlMpfs3DHQymcF+0N29qxqcQ5u0oHt8a+a1b+G4wQIflbW9HB2ZM7Es+DzTdrDvlKTDyowvNnXsVc5kkJQclMZcml8PQSpYm9c6PfeCDmlIwWpLCcIOTHPM8MwYIzh6dOnqDOJx4e719y9fA6T5/UXNzTjlg8evYetJFIovBM8zDOL7PmjP/znXH70KQ8e8IkPJ8fN7f0+QfGnOMSBilKOdj67/g7HD1FkNcsy4g1KVt73fhwrOkeefD5mqnM61QROZ7q8lnuWAWdg4ih5Kjge35xP4OTrjhEOlRi1v0ZTOgXjp5ZfgZRqL3JwAlxwXu2KR+B0+O4xqBcnUHxekTmvVBzB1hln8QBEzq/BeLgP3vHKfCdw0N9tmPsFZlHjhp4P65HbXcDt7qhij5YSJeF1L/ngUvLrv/Y+r/uBm7sHzDyz2XriHFBjJDaWVw+R25tIZeH6keH5i4mb0aE6B2Rqm7FrSVYVlZA8/1HPPGamIZFjeXDYTrJ8YtC1xFoBMXLzwy1DJ/jOX+lQ3nFZ1dQfN0xW0bYSIzSrR09obcX9OOOF4D1djIaykTxsZ9aTpr+bmQeHXdfcvxiRQ2L5xNIsFWFy8LDl0SNDrtYonRl1yUCNKvPly3vud561lCgjWVw1mM7gs2B88Ny/fAHGMEwBi6BtLI2Cn3z2wKNHj3h188A0F3dkpTW1ann14gUmL+nWC4YwFl65sjgXSErQ33zJ/dYRs6GqWxpTqgUxC8CghSplvxS5WK95/TChpWImk9DIqqVbLalbw+hGag2JRIoBhUAJCDHRh5HoR4SAQGZKAi01ddfi54Ht3QMpeoSEm5t7FhcL3rta0Pc7EgJbNSg8ft6Csrg5sNkCJKJzCK2JYUaGQFUtEDKRgyeMmadPn6Bf3VDXCiUifpoJmwFdNayfXJCuJ7puxaqpEUgWdUetNa9vXkJzgX/5E+ZRI0RTGpWFRLY1X/74JZ0QRcdfJvphQ9w8Z7u7Z7h5zdTvCCHSTxkRE8sW6kcKmWqUg3g3EqLmw8WCKSWay2fs0EyjQwqFsQvaBmytUMkzb3u0hKvrFTnOXK4qLpcNeu+kLQE3Oybmoj+/p3zotqVdXPF+aJhd4ObuOTEnRDZIEg+39zS6wVYNQhfGrSeitcJIeHTZYmrDalkVWWDvWC06GByPKyBEoptxYSInz3rVsu4qts4V9Rtb3LG3w8Q4jeRqxZWtSZPfK+RkrK2p7JrnP/gj5gwoT90YJrUm6R3z/ZZcWd5bL3l0dUW1XBFcoh53hDiCkigo1MVmjRKBKo+ItmVz84Cuap48WyN8JESNjpkny4bOVsRHVzSLhrpb4XYT97uR7f0dcgoE2fDFdqBSlkykW1RIVfpdgo/c3vQsLxZ4PxG3DqPAWlVMHLs1uxdbZidwQfCwHRnGDToKqsUVOni2ooEA0g97pbaIVpnt/YCfRlJXU0vLvPPMyaC0wdiKzXZLP0VoKrb9iCVRC0tbG+yyIwnBcHODGyakqZlDposCbTKzSLTdJf39luRGgguMwSGToyIi54mpTzxMEZkSTWVJXY3wnlkJzCQw7YJlo4kh8vnz/p0mjJ//EIQY+Af/9d/jO5/+G/zqt7/L5brQNKytOJFSzsdZlLHPcEpVdPTzHigorQpNQoDSpW+sloIYSgNzziBS4qCyqXWR0klxT8Q8y6wWqLA3eUqnyfhsF45B1yEYOGgkHen25MIty4l4VDT9mkdLfBXOeZMqcdRcP8s0H7L7cm+4dVw+n7Kuh6rAGyZeUu5B4PmxLsc7er9X2jmcLYHUIHKRo40h7CtDgn63PW1tzqyv3+P68Ye8evV7XCwy7WPN6EfSEFBZo3XDh4sKkTP/1l/6Lf7ZH/2o9KNpC0j+1n/wN9Ba/+lWgs5A5tHgLIFScn/8DoudV7hOQxzBUT77t7yIKZX7B44B/+GaTofzuVfrkntazaHSdm689ecGBe/HuRP0aeQjwD2KIJS3y5+zio4UJ3nY47cPz4sDOD7AhZ/NkOw34k0gcFKuSvv7SR6Xk3vVorL+P/lcvBM4uLCwqDTS1mipiGrLL3yrZpg92WqoDI3IsHXoBby43xHSzDx5+ikjrcH7gF3XPNwHaiv5xV9oeHRtCdYUhaAUWVy39C6y207kh5kXvcNUifu7yOQzLkIY92WrPpKmIpVadRqjQPrE+pcabG3Azzw8TOgFvPdoxXuXF1xfXTPFkYW0kAI+zVBLnv3CxyhlWA87pq1jupgY+4l+TjzceBbXNVrB9n5gfPDsbkesS1Qf1uiFRfQD4xB52DgmqWhWUK8tMgekCnRNcaC9iRlC4OHVQM7gomCbZlSt+eiDS7Y3W7KLVFqSUQglaC80drXAjYHtlztM3VJZQ5ocu9GxvF6Ts6C2FqWq4rosZ6quYwgZ8JAUCAVGshlmApGUPEhB1pKUi/6zsTWirvDjREiRnAMieKzUXFw2TCmzbAyZhE8JnSVZOgaXiD6xnSPTMJFCQAjBctUwDW7f+ApBSbayxk+BWguCy4x9jzIKa0rTa646jLQEIZHTFpkjMsNUK2IcUanDqsxFU1EDIcLDbouwC1zUTE5AiIz9xN00k5hotOBiscTqiA8BkqBqa5ybiT7z2YsXDLtbaiv45JNP0HnJ7c2XbLYDbiq9GE+vNJ+NCaUkWhmS8wgEtrN01jIqw7PLirubHd4LfBIICYtHF5AmamvpljXGaKyGVS24ai2dVMhsyMEjU0RK8N6TvKT3GmE1slaE4Hlx84JKW5TSTLMGETBGoqxB6YohaXQfwPe0jSW2lu088/TxY7a7LcpUqJiphKRdNsRGodc1YZjZjY5IoePonNmKCbvqMFbgZ8c4TMw+sJ1H6sbQXXbYpmUc5gJSpKFpOsb+llp7GD1ts2R5cYXtOpJt2DjNhU10iwpTNRAlxBkx3pKlASkZXYCYqKuK1XoFArb3E95H6kahbI3QCh12jJseSUapjDHQ1IpKCl7fPKCMLmDUSrTRPGosmAVfPv+SRWsRwhAJxBQwSiKngaaB5B1x9qSsqVYVXZXpdSTuNog8gZ9Iw8hF1/LoymKWl8zOc/fqls3NFpMjpqkR/oEwj6hmhaqa0lScK3a9I+RAUA3OF8pFZQyPrgzD3Q0BScoaNUcMESc1z++3+H6iW2vmWTC5SMwzIlvut5GcFVUeWWoPOdIPEe8Dd7c7ktZIUbKlQgq6qyVhs6HpGrKGefIMU2AK6U+YBX4mOLXmAAAgAElEQVSeQxwDQchopbkdN/y3/+i/4Q8/+z5/7d/+63zw/ofAKdt2zGC+ZbMq9p9JSm+TqoqymVAFMBR6hMSYEkCFUBqxU0p4FyB7BBmtNSEmVOEHlQlbHBySi1lX2mcOD3z4o7rOPoN7oGukmE50pn1WXR242pzN3193WtF+HOk9hwwxp1DkfB9P6lGcnKz30dM51SWfUzKOB7v8Seec+PKiBKcxvmEsl0UuXjpWEkIs/W6yUAS992dUnMzj60uePb3m//6XxVfhcvGIJ4tn3L5+ATnRNAuyqvjFTz7i1Ref47dbvvHRx3znm9/g4/ffp62aN0DMn8IRPwKrw9oOlZdDsHkAVqdAnTeP2/Gzs+09u74PoDy+QRN6U7HruA7O1KmOQPBsuWNV6dDo/DUd+RShHxIFSpWQWori7ZXOj/VBKnl/OE4qZuLY/3EAwoefP1YgDtQwoJgHno7d+edv9iGcYcZ8XoF4t2P+TuAgxtIsW5tEnzNDlvAwYW1R1ZDR015bjAYj4O7lFt0IXBTMWRJzwmrN7BJpyhgpMJVC1gZbGVJMDFNZkUhFKtDFhM4RYw25UiQrS9k3lB3N9wmWgiyKrYgyAlMJYiPJSdE0FVMM6IWlWi5QTc3tMHO1rlnWS0Q25CzZ+khjG4yqycmRXYJFkalcxEicBbezI6ZAHDLRBRCJYetJNz0NidvBM/aB0WUqIxGUakZbmyL7qdKe3zszR8EwOoLW6JDKZGY0qmrxcSTVAoQuuuxk+mkgKs00TAgncSGRa8NCg601RkuQLdkoUirm9FJbpDJ0aaafA0lbbF1jlOZ+90CaE9PkkdZitEVkEHnm5tUty8dXhJiRMSFIyCyYfSgNo1LSLRoCmd5HwhSZtjvWT664mSNRKXRlUdaAiDiRqNoVGo/wgeAiUZSm1/VqRaW2uJQJez+F2c/YShLTRECR3UyloM4zU3/PUiXCdoeuFUKBVgI3OZybkCFDAicaostMw0RLYk6Ai6yrCkNg9ImcTXngSYmoI/3C0A9yD2w8MUXSPDNtd4R5gOjxKSOVJAq1L5tmGiNZdBIMTN7jZ8G42zFHTTaWqjJ0tSBGQ2U0XddiZGmK10oxDzuWy4ZhVzwMFIU+51ykth3ZTeSsCifZSmJMhTqiS1aomAkJpFFoZamsIkwJpQzGGoxSBGGRKhcKlpDFO0KU4CmHRN00jFFiciLNDj85xnnEE6m7hq5bUrWG0M9MgyMEX4A8odDBpEI0mtoopBI452mNZGVXSFuDj8zbHSEo7h9m1tcLqtqStCha/SiqtvQaaakxRiGrCmtb0MXzQHcLpLGYqiYnxTzOiARzKH4EqIwgQBgL7UMUZSBlarJIyOyIniLjahpiFMwPPYhE3ViUUdS5UEyaZYVIHpEjeMe8ucePI+Mw8HDf0/cOZSyXT55QVYacZyqdWHca6Sp2uwIgs6hYLCpytuxGSciZ1sI4zkx9YHCFllLVNVJmdIiMQRBdYBhKQ7NIiSwkKSliksxBYGJR0okovE801mCNwm/7IgOrDCRR+n6YsYAyFdbYEgzHgOksCXBzES0IIWHsu2lT/LxHCTgUv/kbv8V//w//O/7Z7/1Thn7k13/5u/w7f/nfO2Z7j0X7t4IvqSRSySKJbRXLRYPRlhgDSKiairZr6HczShaTR+/iXiEts3ko8tmCQpUQuqzvTTfevbQmh8BJHAOj/BbN/Fxl5+1xVOXZGxO966T9r/MQUkJKp709Zk7Lvh1kMo8f7/85ZDQLmDhbNqdjUAunptsCIvbmcwfOtxDEmEoUJsTxHB2xZ87kFI8OwbD3Tjj6UyRijFxcXvPe+x/SLhckqairlt32jnbvX6SsYLG45JNPPuUf/+Af8Svf/JRPv/kt3n/vGcuu2+vSi6865T+XcXAuPpUOOB7vQz/CEVSf3y+HSst+OSnFm1UdUSpdBYDtA9Ojc684Oy9nP0km5XI9p3TyNDic3wIeTuZhX/fxNs0np9Lz9EYX1Ru+J4fvnR9nTiB5X10sgf2Bunh+rI4LHkHYGyDucEPt3ztQx863lbP3/rjxTjNCSnvZRumZvMDqzHY3sVpURRNfChqpSS3s7gfCOBPR+5KtIMaM1YopxL1yTmb0GeMyRgSm0ZESjLvE6CJujmAUQiachyAlSSlQoex3gDBkpC0PAe0TppbkRhK0ZPQS02jax5ZmvaJdr0AbbG55tHrCk+5jLquZVfXAZurJIiCloUmlsfRmjrgsaKsicTilhN84gkuEORF9Zp484+clA25CxE2BGDLKKGTKNCrTVYpEwk2umInpjHcUlSWjqKyg0VAbjdA1pp7RVUP0kugy0QeGYcILxTQFaiGJLqHQdF2Z8DMSIQxSa0Tcn3RdMc+eRgvqymKbGl1VhNkh4kwYApmMNbIACaFQSbAZxv1DJBH3D3ixv/CNhEWtaWuLF4IoI2MMkHqkUMS85xpagwJSDviU0crgfCrykElgtUTVgsWiozGCbT/QjzPOB2JMxH1gFkOREExWo4JHeDBZkqZIShoqRUiCaQ7k7YbKlkpA9gtENoiYaVQkCVWMzCqNlRqjEnMQSJlANeTc8/jxmoqMu3tA+ExKjhxiQcWpNNtOUWKsJUuFyEUZS+s9fcFKun1gnEQip4ggoY2A4DBKY3XFYrHAEFE5ILLEjyOzhZiKSpaRGRkDIhcDOEgQMtkFlFRoKcnKIKWmrgx+9kTvGcNMbQWxAiEVUmoiEoGith0xjSihkcqQciaybxxEFulba6mIpBQY+8DddgSZiCGQyFTW0mTJ5AO7YYc1IERA60wyNUJILBHvZ4LzWD8jhCAKjUuZKXpS1EzTxKVYgAAfI3724D2V0uQ4IqSmrqtSwRI1KRtc8GWfGw37a2kcJkiB2Sf2tHFyjszzRCM1dS2oGk2tNCFGvItMk8PgqOuGYZiZ+gGtM0YLukVDJU2phCpN3dTI5JjG8RhAT3Ni8omsDHW3wC7WkCPRDYSYsFazXDV4N5HDjFpWXD+6xAdDQiGEpK0l42RwO0/vZow21JVBG0Gce2pbQ5hxo2OglPON0iihEHVDkkUxy1YWicTHRFsr2kYzeIvIpVplas0iSyISmTK6rlBWI3MqlRErSD6WYydlAVg5fuWz/89iSCH5N3/lL/L65ob/5Z/+T/yT3/nHvHz9Alsb/uKv/2WMMRzToW9F40orjNForbDWcnl5wW/+5l/BzQM+OpQpyna77cDm4Z6f/OQ1/TgXR96cmSZX5DBjRmmJtApBmcPmyXOYmOFsIj6jDKUjp+iQvTsHMfls0j5RLcqfrz8wOGY2zwHBIUN69v4b3hFnfItjBpSTws758gdzqBPgSGT2RlvydLxzLk32p584QK9SURD5AOr2wfEenB1G2y159OQ9njz7gB5HipFp7Pnw6VOUEWSp+OTDj3j86Ckff/INPv32L/H06VO6tj0L1HnjN3++4yvWk9+Cmsfr8asWPVBZ9r92PE/lt+Upsi/ceN5sCN+v7gSEc6nUHBpnIXPCacdwmlNU/PUdZR8BikT+4X4+BeSCzMnI7/i98+dC5o0KwzlVKZ/9c6hIwump81Wph9NzibPSwZsVo3cZ7wQOdKVBZaKfsE7zxAZeJ4XICaMyVgjEFJhz4ssvNjQrzTh7CAkrMi5njJEkKXEk3BDILqInj3KZ/mGiXWjGSdIPkSlA3bREnbl9OVP6cyXKKJKNBBdJIeN3ieSKnrupFFwZpNFsssZHweNHNZePL7hcrMFLPn38y7zXfcCj6lNkmnGLG6ZwyzTfkUTA1ZFWSHb9HS/7LVkKbu8Gxikx3TuGB09wCa1K9tjfw/WzyHJd9MPD1jNNM0st6ExCDJEpJCYyVJrFRce4CdTrGtNoGpnplKARiqBLgL68XLMdI/12JvqA8IkwzwhVk/d69jknYgKVwQVFiiBFxBqNNpYkDHO/Q15ccnW1omkLX/lmHInZk+JMveioK1PAgdRFYUqA0MVTIGXBGEpmparEPtMiSDmhpKE2iqbShOWS0Se0NmQpCSETkkCo4gnR328gJEzIGGVo2xpqCQLqtuNh1xP9jMjFdXdwA0JbmLcIqUhBk6fM07bCjTO1LNWbkDIuS0JWhNc3NM+e0PcFmLbNioWpEWGmqtcsKkFrNZVWCBEJaWbV1aSs6ceJx+uOZ01HuFgxTJ4pzkhjqBctbsy4GXTINBHQGjxIpQgZBi9oO8tiYekfPNWiKde3DMjkGfvMYrVEUVHZFi0j2c/kkNEIdrOnNnqvaBJLs73t8C6SbIUIERkiwjsqrcj1Em0tSrZ4ObPd7tgOA9lDEi2LusVnyRSKpF9T1URfsmzIikM3QpYSWxepUk3JrisNUUn6kLhcFqUesgc0y65CC3jY7livI22r6BYWp2omlwiDQ8RAGHrcPOC2d+j1NepijQsORaJtJS5GnEuQIm4YSdMISpBjRhiFthXa1sSgiDHjfZEGNdYgIqQo8D4xuxGfBMmVZ1AWJWuTGknVKJqlBaFxPhEzBRDPkbqRvL4dCT7hY4TNjsX6AtEucLsHYu+LI7Qx+LTDR3AIpqjRVUPTKdq2I+xleIkCN5UKp9AaYyD7nnbxiNY8huDxPpOzotOWoVZMOrOdA+SI1ZJsNC5G2kXLeD8hQiYJwZQEU/BUCOquwSpHVVmapsblzO1uhrpcO3Vb46PGp0gWnoXKhKxJbkbtjREFGZUiQx+o6gpjLbVRTLMj9MP/q4nj/9/xs5PWarHib/y7/yE5Jv6r3/8v+d1/+Tt89uL7XF1c882PPsXaYpSpziY+IUp/gTYGaw0X6wt+9Vd/jb/7d/8TnN8wjvf0wwN9/wAi8we//z1++7d/n5++uqXvR4bNCKL0vIQcsJWh7Wq0Vrg5cPtqR4yhAAlVtluwpwu8FeMcZB1TAuTZZL5HBnmfCX8jI/jnAB+86c56xoY452ef3twveuKuw4GLLfcNsKegNe857FLkvRPvocqQIeRTyPo2CNkHtSkmQghordHiFMQfAjOpTu9dXl7zrU+/zY9ffM64G1m0S64efYStLdooPv3WL9O2C37rr/77xJjQWp+AwZ9yvPsGdeutdR8y9If4/tgX8NYQZ/fRoRpzrBaIg6f3gdcOh9D0BA7213IWheqXT9tz4MHDSUK4/O7XGxgAe9C1FzkQ55z+83Gi131VMH9uknaCTqdqw/lyx/feKEOIr1zvodrGsYp1BrLf4WHzTuBArFr6JBie33OpNHGIPH7coquKzV3PzestP/j8Nfcu8UufXLG86Pji5Q3Je3TOdCpTt4YvP+vp1oJ2r92eRPnsIYEjsVxaRKuRLiKqwPtPFGMvijuyzahOoLJiGBNpzoQ+kVxmrmHRaC5/sUFXIC4kdy9HspUsLzuedR+iU6Zrv8Gz5jvUsiGnESslC1ND8ylRCNz8e6yWmj7/gFf977G965FZYFTC2dLQG/uAz5HFVUP3qMGqMvEqK2kWBttalrWkqgQ/+v4DXguWjxrWF9UxmFxeLpC1wMSAzSV764YtIiVubjcoXaFSwrmAygkhFM8eXTHOJZvdGE23XGDqNVGt6Lc9da2wSkEqWftqvUQuV6zWl2gSYe4RKVF3ay47cHNisegIQTCNHp8jPivSGIs/A5HgA+OcUVaTk+P2dqKZKhYXF4X7TURfX8LseG99xc2d5O7ugRgijx6vSD7x8rPv03YdTtV72lhP5QW7bakS+DEik6aSAqkiVb1iNwXEAprG0lSWWtVUi2eEeovRE6kfGDY7HInrxxfcTTdcr2q0NiRpqazAWtCiw9QLrltDDIHBe+YUUEZR2Yrbhwem2VCritWqQa4ueP7yc0Jfc/nkCqFhe3PHsNmitCLvqWphzsTk0FbRVQZrDEZpsskom7m0FVILhE5IpWkayzjsuHkpqeoKazVVlUhCs2hrrtdr/OQZtzvSHNHrBu9ByQaqsPeNiAzDxMsf37J8+oyuVYVSpyW1Lk63Rknuhw0qVygM2pTHeRwDMU5FAWhvLEcsFcGHcUB6zzj60uguMk+fXXJ9uWYadnRNDShiAm0FH350xc3rHdf2grmPRB1IIUNQPHlyza2SjK5hGzckEVlmx3K5xNY1KkVebwf8JPb0qoxcNLi+p5KwuuyouiVCGpzLbO/vwEiym0k+EJLDh8LXnqKlXlbo7BDzhMpQmxrvZ9qLlmaxQAvNdjMypBGrYA5bcIHluiJjCL5kiTfTTFsFhn6i0Z5tGDGNplou8UGzuf8po3eAoBGShohJI/fbjKkldVczj670X+iGalHRNR1rJN4HPImQEw/bHuEjoxupZEVlJTFHNvcBpQyvX71Gzpq1NlQSEgGfi+naddNiSMQsmEPJrFZSMrjAWmTCYfsqgxGSMHq2964cHyVRulR/p3FCCKgW3b6SOZLGifbPpHJwrliSeftVVVVcLC+5Wj3i+Yvn3O1u+I//s7/Df/Gf/gN+7du/jtb6LBMfS4VFKKRUtN2C7/7Gd/l7f/8/R6OpjGTR1Fyurpnn0mD5/pNr/sJ3/xL/w//4D/ntf/K7bDY3aKNKxSzB1XXL0w+uEULx4osH7m97SIIkOON4C5CF3x1DOuN5Z0ozwV5G86AU8jNzci6KMuLrHyyJMzoDcJS9lFLsqRYcW0sO8Q2c0X84SDTm0rh89tsHBRe5Vyk61msOlYk9BYl8CkBP3hb7c7DvE4F9wHu2giNXXia0Vjx69Ihf/dVfY3A94zhwtXrC9dUTPv74m1xdXiOl3CvwCIw5gZE/i3OYUtpLap69KYpHeEz7+/oYKJ4Aw3mQ/mZD/V55iALYlCr7eTimeY+G3+wfOVy/p9S2UooDvSvt+wsO50R+zSsGwOHiKy+PgffZ/b8fX+XRctz7fF7XOlUNyt/TuTkA4zfoWeLNO+SwSScwfdrMQ/UhH0tIf/LuvRM4eLruePboip0qFI083PHl7YAxMyp4lE6IyvDRymAXFQ+3O7yL5BxRInG5sMg6s15K2pWm1YqcMj4HlheStFAgwRSpflQW+ODRWbJaFpOY7Qy5VqhWUy0k288n5k0mT5nxi8ANGfVY8fFfWJH9hL6oefTBh1xfP6a1FZW+4hvtd/eZpglwKDEiuUeoJyQ0c/VrVGLHdvtDXtw6vv3he0zmJbc/3SCHgN94xk1ESMFsisb8T37i2F5WiATGGB5/Y4WYHQubuPpoiY+JaCX3IaGRvP/+gk2yWJPR1YKMIeaM8wNLVSoVwiQWXcvF+y1hN3BxfUnygo0FHwSVNVTrmnGA3XBHP2YcNVZljMo06wsWXcOFSaipZzNN3I+BOWuqtsIAfRzQcUYKTa4yk88oJCaPoEqw4WbHMEZCGIi2Ro4jeIuPE7KL2ErTzx5By+gcW6cIoqOuQQvNLs1MvWCx0DStJSKYZk+kIQ03jDGRncRIgVSZNERUt+CDRzVjtpi6o2tWGFVxf3fD6nIFEXzcFV1977n54ksa0yFSJqUJaTTGKqxRyJQIbiLVknEaCbPDCkHd1GgmLitoyTRVZppH7h923D/smMPINE80F5f/D3dvGmtbmtb3/d5xDXs6wz13qLmqZ7rpNh0MjcGDIMGOrWBkZEcBMog4svPBkSIlipQoUhIpiiCSZRnFnxLJiZV2SGwLpeVgcBgMNo2hJ5oeqru6qumqunWHM+9hDe+YD2tP91YTipCGLl7p3nvuPnvvc/a71t7r+T/PfyDmQIgtPkiUkhgl8X1Yf/gNlqCh8zRdxJQVxq4DvUqNsQIjFBLJMgnaxqGkYVxqQhBYBVIXLPrEct5AzNTjCZfLFT4IZjpRV5bkE32MKKWZHlouT++ijg/oQ7suCjN909E3LVopsslky5D0vVpiyShRD0Lm5RKZI7W1VLYgqwB2xMS2NF1P6gMqZkLwxKC5mPeU/ZCK3Xcdl6ue49mYuJSIokKrerh4mIzMBdXkANV5ZJIoBitamSQ1isYFpgKKcvhATF6hdUlVjBDeUxQ1WhckYUjKoYsCLQzTQ0N7PSeHHlCsgqE0kulEk/qAYA2GqhJbGqQ1pJhpQ49rlwjfUBhB13aoSmOEH9LFSwnSUk9L+txxfCxpmkiQBWUxYTqZMAX66xVp3hAiyBxoe0fIhhsnN4jOYSuLzAmypdSWFByX985xkzETNFba4SIpegw9NnqS0lhTg5Jk2WN1ydkbDxlpDUpSjwvGVuGcw3tHcTBB9+V2/G8t3Dyc4WOka3pc328dRWJOXLWBcjRiNp3S9y1935FiRBmNINAtV0S1HvmHTBDfHJqDx69Z/+qf/LO88Ozz/Gc/8de5+3rD6uyav/Ff/Bh/48f+U/7Kv/GjAzBgB2wEAmsL3v+t7+cn/vsfX194w+DaEnu0DMhiOgT7Ve9G2mve8eF3skgtxyeHJJ34tX/yabSSnJxM0cD56ZzTexdIKfB516HeLwgGY5B1hzWvvyvEkG3CztJ0X8C565xvBIxv74JpR4XYCYrXqGd3p/UoYNvt3gZrgZRrR5y0cVt5cwk5sDD2HY2G58x7Qs7932VTLaUQEOylCa/taAfh8r4Yf5gyjEZj3v3O9/LC8+/k8vKSWzdvUxTFdrrwCGecP1xg9wgNZb/glwKRdpMpuQVoO9C0LRbftHbPt9FrbKhw+4XpLgX6zZkOA8AYzvmda9Iez+WPwtoOyjY0Ktjv0A+5B7u7yz1QutG6PN7F3z+ecT3peVzf8fUyXzYC8WH68/VnA1uc8BYOwVu6IlyePmQ+ykihCCcT3nj1Ie3CcXizphppsk7oy0CUmeuVx60GsZcSkiAk2q5Ti8uM9o4cBCFBnyPXC4GsJPZGSWg9buHpO0/XJF5vMuVYUedEkpJCgB4JRqMK830Fn//oNc1ZIoVMdz9y9YmeP/ZDB7j5EpkzC9HyYrvkvn2KP3nrO4lyjM9nnLe/QJkfUoqMlGOsKPHpLlJ8mLp4B+99LnB23fG1T3yC+MwMaTTX55HlIuHjYIWXjcD3iawsd+91VEZweCjp20hpNJ3NLJMnZIHRGqXg8v6CkCRGO0YHM0ph0F4gs2R0UBLawGjkWcznrFxHMZlyYzpBjqb4VcNISwKK4OH+6QpkwWLZY21B5wORArSh8CveeDCnOB6zaK5Ydp6kLdPJGJkk9656chMp6wltTDSrFYtVR3FwQKFHeGcpJxNgSWgvqExJUddMDg5xi4bF1QpcQX04ZXnRoGxPUpCEYnI046CQxHbF0dENwlM9CgdBUdgSPZGcPXyDk6OK0oxpGw/RobJnYiKlzoSYEUIhYiZFD0ZhbMXZg3OmFRhl0arH+J7JqOTkyac4ny8JumJkagwK6QOSDN01oZKUowK0QDtPzD3zladvlohs0LWiy4mlWw4Jm11Gkrm4/5DV5SW+6dBkkgRd1JRlwneOnCPJZ8xUo3LC54QsZxwej5mN7eCAEiOm0Ki2JSuNFYEq94zHB/gQSV3iqruAANYYYgQfA4GMcxJ8QKBQ2qBtiTaZaasoREbZEqcMKUcKkZGuwbuOEHrKukJrQ+t7IoqDaUlWEisDSiSMNgQfuXp4wc1nnyAXcgDt9CybiMiSEHpEkIysIgVPjoEb4zG5FxRHE86vHca3FOMRajwCJVA+YVRPpSBHSeozvulYuUTTN+Qw0I+qcU1Rj5GRwQXGzjB20EmInCi1oDg4xAhB7lucXOFzQEqoqkwhBJVKdEpjSokGsnJoKXCNZyUlOXhy6pE64p2DDP3lAjuSFNPpAEaUwijHcu4ZV5Im9TiXaJaKKvaEDMp5alOT4gJrJMV4TEoR4RpcAOMUqQsDjbKUnN5fUo4M9ZFm6RJWSGxhmZkaW1XMhGaZLcs+sFi2uGVLiA0jVVCPS8qxoZ6WaCvxfQJRc3p9iU4KET11ISnLguw8x3Xi4fkpsYnIogCdyEoyGlWojRWuFMQMPkQygmIyJnpH6hxlaRiPS/wfGKXl0QlBZsg12FwoXeiRUmF1sb34PfvkC/zkf/X3+Gv/+V/k7NUev1jyd/+3n+T1B6/wH//V/xKZ5aD1AfS04s/98A/x7/3VHwNpSbll6T5DJXskCqEmQOL09HVu3PkwB5NneP/zjipofst/gn/yf38WbQ3f+seeZbnoWbnMqg8sFu22U4yUDPamYs0GSgPnfUPHyLuiSigJKSPV0OTalLV7zXJSHDraKf2BHYRvzBJrZyby2tlpA3jeTKYYitKM2AgqcyaL9RRFCkSCGOIjItn9QnZTZColtiOEfXCw9fcn7xX/axpRSutG6v65+OjeG6NRakzOMJ3MtpShfT731yvO/nDWppDfcxJSm99xt/t53T3e1xQI5HaPhmJ2l4K8owp9/Z8q98DsFpRs9nhNTxpwxd5EYY9i8wenyfjGLCHYBcMx0KZT3tju7pycpNgJg/NarL3TeOQtmBZid7zy/udDzkj5+Pn1OKh7ZGy0nhY8Ok0aHj40NPc1Dr/Tekvg4PTS8XDWMaoULAyVtVwJTyLS+0DvI0JJemFQMtP0gaqEg0kBVuBipOsSPiRsqUBmCAnhBv94IwS+MbhrR7P0RJfQCPomsJgnRicWYwVFkRgdCSYzy4fed8QPf9ez/OR//WW++sUVOWT8PPDwlQuOnyp5/mRGGp2wKJ/mqnqepb6NRDPvf5WKz2LlAiEKIjNcXLFcvIwcP8OVnPHG6FlOb3yYxrzI8rULrh92LK8jzuVhXKcVwhoyevBaXo9Gm9Zxdd3y7NNj7MwywzC/6pEiURjN4URiVCamxNXFgpG2jHSFLkbU2uAOA6HtEJ0jI4hWMk+BfH6N0prJdIwQGh8TXRHolh6tMzk7rCmwVmBMwhhNWqxoG0OpDIVI+G5JjI48rqjLTB+HgCkZHRoo9WCX6VNgZBSjcUkqDUZJ2vmCalKjygotIDiPF4Kr64bl6TWjA4upD7A+UGTQ0hK85Pr0DKtKinJGcJ7FoqXtW5IfxvYxZbSEsqwpa0C1AV8AACAASURBVIvIDiMgZkGzWuDXsffB+UGk6yLeWAQRozXYGpRh2awwUg5jfe/JEVzKrFLGKoWLjsu7V6QUKEqJHRVMx5alqgltz/XlGd5D7hNX8wXSd/StJ/UOLTJZKZxPZAmjqsBqzTIvCCGgCstoXLHqIyFljss0hGgJTVmXKNeTSkOpC/oQCb0bCtU+AhHhOmLriC6TzeBaJJQmth4vwNgCYxVSZrzrUFYwmx0gTYIU1h03y7gekVrDap7JQuFSJkdPUVl6LyjKghQ9SQ56EKEUuXFkpRHConUxJGpXkkL0A8CYzVBojIYuJEISaF1hZCTkjKkLnI8k11FZyfWqp1teDrSVwuCdwjtQMmFGY1atQyaPigLhM0EkrNRopfDNCmKFkBBJuOSpbKaoKnLWjOuCxne4rkUzpnPXLPMUoxXKGozIqBjo+yUZTVg6pEikFBAyD/vQZ64urtHVBBHSOvF4sLYsRwVN1xGEptCaWidS9JjRhFG7ZJkSQg5uJWSJa1tcVKTY4/qO7EDETGgCowONj5rmYj5oW2JmtQgYIdBEbGVxQSLagBGZw9mIpvMc1SVSJUL2rLoe5YcAvHa5xOV+MHSIgRQUpU6MRpa+S5TjAmUESD18NikQWtN3HTF6EhldWWRVEAFpC2w9ppnPUYWgPqiR4/qtXAp+nytvL4ibv0PwrLoFbbeidx2f+9pn+N4P//lBPCzVtht2cnTMf/If/SA//t/9FIvTFc3lBZdnDwjRoeQmcCrznT/yg8TCUsxOEECfXkKlV4ZIAVEBLUKcUxSvAu9nScW8epJ+ds7BM/f4jj/t+PQ//zxtBz4q7r9+xuXp9ZoOIwcLzE29tKZSiHUCshCZFIcL8kZzsGEap7Tm0q87rHLgE6wBBX8kmqlDQTS8n2KM69rk8SIkbxOpd3OTTbczsYlpepQTsaNq7ATMrIHHo3zroUh93F9/8zx5CPaMw8Rgv8u77xa1oXRsJhlvep17AGFz/z/MtaVI7WOwvAFqrOvIHZdk46Q0bE3i8TpRrk1kxFqrAY/WoTuwBo8+eEez2QC2DfB7nII0UI3eIr/lm3aJ7YQm5Z0DlmDQXQzn0OAutwmZ2z5S7ADY/hZu0pU3N7753NrcWe6Bvv2J2frf7cP2Hah274W3AszeEjiYTWsOb0ywMlKkQKUl01kJKRBaDylhELg+QSExVmJGitHMoq3guunpfaYcGbIUZANCDsnBUQtSn2nvtbiVo196vMtkq9AzRXceCEoQRaI+UZSHBUdPjHn3c+/hu26+h/gffpz/46O/xSd+/QGhiTz45JyPfMdzTCYzFqpAlIdMq6eZCM1ZnhMu/hnj8Rtok8iUIFYQ75HDfVxe0ZHQtsaImjdeOcXYQNcmVEoYCdOnDrn93tuc3r+E1lNUEr8a+KZ9H+k6j08RqQ3HJyUiR3LOjEeWyJAzMK1KsoXSSMa1oRpbzhctympSNshRiRYWVVq6kFhdzZkeHXNYlBAY0lwTlNrQ24QkoUXGyLwOzgJTWZo+UYygtBKFxOWI6zuQBl0PBYWMw8VXCYHSGaWGZFgfIuREXWusU1gS0XeIUlMUBlyguW4odWA6GiOVQkUQWRBcIvWefrGgGB+jzIiUOpABsqOUisoaspU0LoPU2KrCKA0ukFwi+4zQQ8jaqCiojCR2wwkujaaejkk+EqLHKE3jI0baIUwsDo5EXRIcG0mIgm7VkYlIZbBRURaKVCgu2kCznNM1gd5nIo6Y/BDGRqAwAo1BCkVZa2RRkWKimk1AC8rKoGpFDi2HBzWTQoBwNF6TpUJJhUugpAZtCH2iaT1qscJaRVSawf8h4vueED16VEHoMUWBFJnBuHIoPJIDTInzkbDm2Go5uF9JOSJFj0wQckQSMaYAJQaHjhjRQkAWpD7h+8i4rsgpooUlZijUILAOUWCnE/wqYmUiyATC46JHC0WIw4eYtRptFCkEmmZJt2ooq4okFW0AF2E2tmSZmMxm2FCiVRpsZAGhLcYIdB5ctwRDgIzcdBQT2LIijwYb1Sh6hNSoIAhCgLSDQ9O6OIuuJ4gMMZClAKFRVg7J2nj6sBaD5nVypVKQB1MD37dDlz8lpPeIuqCuNWGekHLQGnUuk+NA4/KLwI2xIsuMWhc3fZMIJuFWK6xRJJkQpkJJS200/fWK4DOtTyQX0EIijUZbTfJhoLG5hPcZFxKu9+TQI3Oi6btByC0NfQiobhjmG63ASnIWpBTxIQ2fsyEOrgVGIrVECYGIGSUzpIQ2ZhChx8Rq2b2VS8HvY+1aYXldrOScWK4WPLy4R+dbbhze5Pbhk3zqpU/wgec+iDIKIYbcAyXhw+/7U/zov3nOx/7Pf8G9+xe89sZX+Lnf+Cn+9Y/8CACvuq9w+4U7GDlBI2jyirD6DabmHIkhMwIWCJGoigtCdgQBRpd0Tc/86oqTG1Nuv+MOPJyTC0U1qujagDQOrQTtshuEnRvXHLkp9wVKQ85DbsK+CBQltzzvjZXnNiBJyuFc33T73sZrx++X5PUkB2AjQN7RLnb7k+JeEbTlY+dd4c+uQNpMDvZtQvepTPtc60eKob214cxvarBHuPcIEHnv8b/bC/49bc83dq3R6gYQbcCAXFPddhhpQ/8R633Y7f+GxvU4PWt/Fzf6mB13/fE93k1VpNxRiR7RJOyBvLfQwP7mXlvg9dj5tjkX97QgA6Z8PDSN7Sa86WYeDf57PGxt9/B9ULuXI7F+0o0d6mbtmhb/7+stgYPjkwm37xwQuxZWPQbBdGIRQWCQKJEYSyiFRRqJLyS61Ag9CFKM1WiRGR1UtEtHSIBWaK2JQHvec73wOBfXtKJIrAyTShLbyOosY4+HILFoLG4lefbgJifld/Dv/FtTVMqUdcf5dceDL3W889YB9/tArTpuFYITKxH+JR7wkNH8c0Qb1qFLLYIFKSSkyCxpiURsvERcfZXXP3+X288doCvJpBKMxiW3vuUJnvjO93H+859FiGvqqeV6OXR+tc5oBgQZA6hKMRobCiWZjioufIO7WHLzsGB0WGJNzbiqGI0LzrsGowVZlNgJqKQRxuBzYOU9ZYwEQESILpFcQkvL9KBAZU9OauDAi4GLr4qK5CQuRWqrUUYTfWLVdvR28Hb362h5JYYP4Uoz5CUoTbtqIfTUMlEXhhx7kgM5GiGEAZfIIXJyY8R4NiU6iZQGn+Vg3KUkEY0ycu0rnRFSoYuKOkdkFkgRGQI95DagKGRJ9BGJQUiLNSV1VTGygoVJhDy8ZdRaBCxWCSMt5I7ClCgBKUJAkRAobWkcaKOJWRKSxDsPJJCKEBw5eZJvSQEmsxFX91aoHMAMwVHCWqqJZVwaLleJLBPVdISpLNoIkgwgeuqqABnxKZD7lhgypS1xSaKlBFUgpSWTCDFjsmDzq0AesjT6jC4tMgWskhAjWURAoISELPHdCicESa1FcQIgYsuCGEpoOlSIwJBcbowluWECI2UmxDS8x3ygMApNxspMTyLmiJaDzW1ZKnzMEAW9ECiG4jurApEyOmeK0qKMoXMR7yMxQk4SHzI+JOL6uLvQMx1PqXNBcCt89JACSgoUEVOPEHHoAPsIMYf1lGzQiAjbI6sRMitSyBhboouKLCw5hjVQkqQsGBpmcvdHGqQpqScVHkno50NwnC0HZ6zsUSlis8fqatir4DGFIruGlBxaDRkdPsTBkUtafNOjxpacBUpFRIh0bT9w+JcL1GiE6A0CjTSSHARN4+kjuBgGPnqSQzK2ihiV8QiUZ0hxTYkUHIYh0EmbwZpUKkHIw4RNDN7Q5JB23cEIMQ/UAm0LvBw6SVJmtBBoOWiKlBwKOd975hdXb+VS8Ptaj5A4csIHz+n5fc6uTjHWYnRBoQp+6bd+kXc9+R7auAIyR+UUa5ZU6ln+8g/8APP5FS9+6SWW4Yxf+I2/z5/6499DE1ruhS8x1e+gyIa+u0boOab/IrLQQImgI2dJTkO4VYdDkDHxktXZa9x/9XVO7hxz57kbxHaFFSWTkztcrwJnDx5SyMjqYs7pG+dbGhR5oGQMYtbBLWm/IMg5D/uc94rnDFnsOnopPU4ReHuulHcWpGIdO709J/PQm0fIPb7+rtW96cDCjre9obiwu9fw7562I+dEZlNw7SZScrOvm6JtwCfEmLY0kA0YebPmYPjqTUXcFrx8c6198fX+bcP7bB8YbDjp26b+lnkyiMaHY7alnOQ9O9LNa1+PzbYAJO8mPxvMJteTlW3Hem8ft0ddbIDfN3hz/iBW3gz/xBqk5s0pN5yL6ztlHtuLR/6bH3/K7b/bYUzeC3/kUVH5mx6bd1887g61dQz7XdZbAgceg0uSHDMxlsjCkcOK6fEhs3FBXUS0DdjphNcfXHH50pzQBZYxEQSgh2Ai6pLQBRYrh64k46Maf92yWERImdAPNoc+gG8i7qst0gWi1Zx84IDqiZKz04YHv37Gu35wSSHOkeJd/Ls/8pC/8BdbPv7iG/z4f/MAujPOHrzB+594lnfac0T6Ap88/zgv6FNO6o4gJC4FVB4KlKZNJPs0PQ0+r3jjwaf48osfY7kIrNoVJ89UtHPL7MlDqnfe5lLcIJaHlCNLXSUWDztEDhRCcFBoJpUmtD1nVz2TseVoVjGxipe+FmmaQFSB2digTEGWGpfgaFwiVEDGmlBkQp/oQsaJElE1hH7BfDmjlDVSW3TKdD7yzDO3SM4RfKbvAl3b06xaRGmZHk5wiyu0WodLJY/3kj4P9phdEzA5YEUmaVDZ0wWFE2noTDcBlxKzSjPOPVqOiEmwcJ7VskfExK0bd1gJi9AZaywySyIZNbZEFJWKLNsl7bIZCsKywJYzzs4eIrSiHk0Z1RYjJU0T6Jce0feDMFUpfPAsVytcW9MuA/WkZNF0tCkM2QBCMb90nByUeCkIfvAOLLXGxoSqRty/7rgxmxBConM982VH03eMxwXSeQ4qxVjV+Gwpbtzi7CuvUmkxTHIiSGuppzNUG+gf3Kc+HmMLUCoMxXqUCFFwer5AVjW1FhQiE72ncQk5GZNzQseOUgmqgxmT2YTedbTO0y9alMloLSiM4aCwtCGQkyO5MHT+jRq89MdT5qsVMgqUsehSoe1gQ6vlEK6G6xAxIbNGmoAuRrhlS9M5tIG+D7g2UOtE6xInRYmVEWklSweX1ytK0ZOUZlzV9F2AGDExUmmDjpFCSMzIIvRwvKWQkC1CVviYSDlgtRwmTvMrUn2IpMUai3OB6FqUEgir8aseMy0pzeA2k50muwIlDAlNSJkA+CTxHqJr0bakLCuCz8S2xwc/OBroIXE6hRYlMilFXJvpA9TVEAxXj6dUZYE0hpjtMAkKDboskNrS5EDf9/TzSHNxgcBhoqcoyiFbIwnS5JhcnhO1IvmWQkukzgi/4KAYkxmyLEprSckzfzjn/iIwHZXowzEFcHG+pG8iIitWV6fcfvoWRiuM1wQ/6DNKEVl2Aazg6PgAkyJ4jyIzGdcUItMtG5zzSC0xtaUaF3QpEXKgKCxh1Q/psKXClnJIlTaC1Xw1cN8VGP2NS0jeUUGGr2KKhBhwznH3wauURc3B5AYvv/4S/8vH/hb17dtEEfny1ZfIKfHBoxfQ6vNI9V7gKf6DH/1erpon+cyXvsov/8t7vLz4KK8vH/KOw/cwUyc8uLzL3esv88LNxNh6YpZAj8gNKQZilGT1PFH0xOy4d/5J7p2+yPW8YXRsuX1nTHM2pbATDr/1u+jtlLuvfJWR6XB37/Ir//jXsVoQQ6BtunVOzyDYVFqtC9NECGlbREm5cy5CgERui1UhNnaP37BD8A1fmXWRLcRA4co7Xv+bue5i96DtF2/+3ubWTfd5U6huIEMCSHlL4dpRkNg2pDaoYBjSSHII2yff78p+3SX2v/xmrmJ305ONF/6m/tucX5sXsw8ipJSwl1I8iMDFdiKwLSo32gKxc5bafG+7x8ONA8AQYnvctsArDZqSzdTn0VCvt+cSrKXxj72EDTjYNgOkRCEIYWjyDRPEzeRqfy/2PgP2pg1bh6e1qcFuux8TJW+ecwPetqBgB0x+LxS4twQO2uuW1XU/+Owfzfjgd72Hf/HT/5RVG5BWEaxC6zE3RsfMDhpOKkETejqfcALUuKK2iuAjamJAZNqYuFwmEgoqTb9yqAMzpByvIjlBANqrTC4SD7/Qk36zI4eWb/n3bzMxT5PDR8nyCinvcHPybfzZD387z/zPv8rHP/Y5Tj/jOfnhEc/ceoPzy4bmlz7G6Szw7u+e0WpJ9h1lHmLTr5YZ+5TlieJdfMqd82s/+xv86t/5TXShuHEQuFNHXjqouSpHrOZXxPYLFE/e5MbTN5n/8q9QVhMOJxVVHfDKcDXPpL7Bm5Kz6x7vPCOrOWuAchhwf+3V+yx7EGbE8dERqwf3mNw+wtPh2kxyAqk09ewmdeywwiNFwqjB3rT1nj4EHp5eMK5qcA6iwGpLMfLMYyCHFp8iZ/MWpQq0GXHdtFSjBL5FlxU5S4RSTA8Uy3lLCB2+TqTcs2oX+FXH0fN36Oc9XkVqmzAhIFxH71run19SzG6z6BOHRyWl0vjOE3LPVCmWXWDZJYq64mByQFEZlvdPaZYBWxnyKBKCo1lGri4XrHoYix4hPTkW+Hnk3nKOQVHfuYNvHAVAlvR95KrvIBpmRzdZ+CUWQV0UlGZEjIKuBSUnXLQ9qblCuBVaQOp6XOhQ2vPk7ZsgJGfXS64urxjXluurS3QeaE1+FXmwuuDo5hGptMyXPelyTm0lo1FBVoquTWt6CKAUsiwxRcly7pBNy3RyMIh6tRyE+/NLcJEmePr5krI2mHGJVRrlItVoQkoKpcCnTAigrMQJGB8cDoFva5ETKXJ1fkFfKipbUc0OyT4gSAiVWM7PhryDONhjFhYKrTEic/P4DkYrclhRVzVGCQqVKIoZEUWfFUhNPVaUdY0UFdfnc7peUE+HD5zQNqS257g+4NUHD5jennF61lBUFbNJSRkilQyY6oTgHIUuqMYVZWlYNZ521SFUg5wVCAXUhtlogms9ykqSrNAGFB2hWeJWC9wkk+N9iuqIPkR8iChl8Fmh8JhaUxUVsQ/kNtChuLpckBjcnOqJBSLN/B4+eHqZ8U3P6EiC1VgqJILFKtEuG3onmIwlCUHrHGZ1xdHBCGUMsVVE1+A7j7WS46Mx3nlCOcIXNQrQvUQ0CybHM7ItQGaeLCYkJ4acgYlmEQKl1UzqgtpmYtD0vSAHg8s9OlsODyvGhUamTLNsWaSEdwlTViirQAtCStRlSdMuib0jukACchq61r7vafuWZeuQfsirsJPxW75o/H9aWxZCIkTPw4v7HM1O+PAHPkLbtXzh1d/io//s73J5PaeuC0LIfP4zL/FqfJnrj7ybvzR5Dyn9PFJcIcQ7OKg/wkc++AHe9c7P8dpLv8zDl+f8K3/umJE4ZxleoVr8Ik0M3Hz2Dl4oRLxCikhM0EWDrgqm8jZfjRf80j/6WV764ovMDkfcmnacFBVfOLoB9Yxld0EmMXv6KWzOfPIf/SLf/X3fw52bmi9/8RU+++lX1iAgkcU6oZehuy3UIPeUYigMUh4KraGbOhTSKeU1N/ybu/z83ZZAoNYc/bhOHd4WR7CesIAQ8U2Uhm0vdO2wsilspBqeT641DBu0sE8byrBTd4sdFWmYJgw8721Bu7b1FAwAZm+88zu+prfDklLtiYMfpaDs03mk3FF9NpqMoVDfy3yIw3kpldrpPPL6fN5OIjaAawMyNlOa9U9/fBCWM0prNpa+O/3D22N/f6eVH3udQ7EvUWrnULRLBF+/P8SjT7CZ5rC+z06Lsb5lb5+34vC9Q70PivfXMCF61NJ3+JF5ez78bustgYOri3M6d8j01oxFd8qrnz/j8M4B5xcLLs5WjLuKg1jz2vI1LvwKjmpujCB6j+8CqlRgBXVd8PB6CUIhelh0w+g8I4le0HSQtUQdKrQ0NH1AGUk881z+wn1il/mWb3sff/v7/le0GtH5n4GHr2GK11Hjr6LU89ysP8THP/4ZvuvPaOrjljZdInRCjRy//GnPUx9ecPvg3YjmHBYLVMoUM0tpPkCfW37+//o7fPpXPwExMTlUnLyz5uUXS8Kd2xx86PuI3nP9pV/imQ9PqK/vcn2xwowKukIhK8uTzx3wxLNHLNpLxlqyvOqGMJ3DMU9qT0hjDm4WnF40VEUBpmYlEvWdKeVkTHvRIrRBZYVICUXL5OCQ+197Hc6/RpxNGY0nJGsRWSGwdMsFI6ORElxwRN/QrVq8kYDC6AIrLUZabhzfpLIZ1/bYqmDZdSybiIsSWwh0abi4eIgLieA8MWeakLlx4xDTRdqux4UeoTxZZq7mV9R6TN9GGlNQVwU5eq4XnvHohGAaCnuNUQEtPGnhMWXJ7OQGByND5z3dskeLDL5FeBjfGBHNiFXTEX1AF4arzjOqJ/RXFzTObUOvcht48h3PIWWiNBNUaFktF5yHhoOjm0gXOZkckLFEmchNRmZHP6nQRab0DWm5pG9amotr7j2YA3oohDN0XaD1gZzg8nxFQaRrPLq0OAS+hdG44saJZHE+R+YSZUeoaorUmpSuSC4jBYQY0VVJNa7xbYtIHUXbURyMKWyBrWpUPRocvlSPVhKjND4N9JyQIs53FCUcTEbA4Mnug8fWBUYMPHofAsZYQoxcXl7hnac6qfGhJaaEVoayqBjXYyCihKTxcUgVVRW6FHTtNb5vIcypZ0cUZU3wmfnlEp8VvbIsVqCyQ+bE2Ej6/iFHx4cgC8aHE5IYMgTOV4nbNzXTds5gEh/o3aB/GULNHEV7j1Xs8UmTkZTGYmdTpBkPYuwYqMqS6tZtrpcjrluHiw6RHEIbdJKoBJODA0LsGFuDloMlqsor2uWS6cEB88USWxraZoX3Pc53ZCGY9x5EQgvF7OAAESMXr99Fxsh4csBhNWLZBIiZaa1orq8Z3z5YTzMSos/UxYz68DbX3QXT8YSVS7i2w9YF5cGYkCwIw2KxpG9hUhQUhUYUCalqxGJFIQKd6+n7BFmhiHQ+oZRBZwFOEHNESMfRYU3beUaHFicLktYkkfCuQyrBwfGUxaJlXBjS2jmmMJLVosFjkHikj4g+Q7Zv5VLw+1s544Pj/vldfurn/0eiKvlL3/1XeObWc3z7+z7CU7ee51MvfZKf/qW/z7/9134InwJ//i/8AP/anR8e9CTh50ir11H2LuhnMOIpavVB+vYW3/ah3yCra2K+RNk5Qc750t2Gw6c0Y/vd+O4M6S7IUqKrmyjxDgId//yT/y1v3PsKWmWOTxSTk0NevjtCPfUMR898B9f3vgT5ktt3RsirjqPDCZMbFf3IIKdTZodTUoTVcoXWcm1vLAcxYkykrIg+kNfCz0FrsOYSMxRjb/8yCTZUMSHkMEVca3mHQmQoSLc0iJTY7xxvnHW2Rfzmz4b+wqaAHcCVXIdySSHWjjib8kvsHsSO5rHXOGdjQ7r5fdM3bmD2B7a2Oo8tIJAoBSntWfzuU6XWk5VBMjPMYdKaIvR4ITmcr8N+x7TLntjoNvaBx+645V29uu5ixxh3eR4Dr2iYKryNx2VCSpRSwwQwvJma9ggO2FDZtnu2Oz+399lMy/YmO9vMjs05LsV2Ags7cPLmz48BAAvElgL5GMPrd11vCRw89dQh41HB6f05nW+ojkcUhWJcDBZ51gpUqZBWoe+eU830IEhSFllZhBjsE0XqUb3HiIyxAhUgxiHRtOkV6dLjrgOIjJ4kOCrIy0iaB3IbUaVgcmJ5Th+isRT2r3N5/bcw7WtU04h4SnCkv4P3fqji9d9umT17zuToEqtqUhH5rS8EblUlhzrSnvZcX/SUJ5qDgylCTvnE9f/Epz72Be5/oqc81Nz5ExXT558gLQ6xB8cszr+AjEuObkjGX3uZ1VccvctUd8Y8+f4TnnthwtPjSDO/5PThihdeOOaFOxOk0kQk1STRhuEN8sRNhRGKLAtWqWTeV1xeLelD5HhcUugakUu0rlguPYWpOJgpdFWSjcGogulkTHd1jXQd1FOUGoSiy2XLdDRDRY9ziZwGK1UjI5UVNC5QFoqLq3MgMyoUQmayLtHJo1bN4IVfWPS0JorAwimsLIkerBmQqffQO88sLRkfHiBoSGHQcwiZub64phI9VZlR2qK0RdaGKnUULeicEF7Sd44+B5TWjGygj0N3vKod7XLBfL5iXB5RVWPoG2IOKEDEQOdbvvrK60xrTXk0Q2sIEXxOdG3PxIwhtXTLDpxHCkmPZLlYMEmWyWTG9fkp7bwlC83J0ze5vLhiosacnc/pYyTGiIgB5UApQ6OGECVVWKQ1RKO5XCwRImOSIIVICj1aS25MatokSKLg4MaUWmVy19MuGvxiweygxgM+RZLryVJgK4sh4WOgiZKu60m+Z2Q1orLoPuDcJVU1ApHJsSMFaENG6h7fJzqx/j2cQ6SepOH4+JjgHN4nQpJcLjuaxZKbR7MhoVnb7eg4OENA0C0XLLs5o4nEFgVBCBIJ4RqCKAZbRz2IclPbcTIZMV82wygzeXLuyZVEZwuFwYgIebCpJXiEDxRVTcqeftmArokpMb845aaVHE4nrC4v6JdzJAJbVExuTLh+7XWy7+g7hzFj7Ngi5ZDqLYXF2BqNoO3DkMgcA9fzOUYlmoUnpYAUAWsEejImdQ4hxcD771tIUFQVMjskAmMU46MCYzQImE8Ns+MxDx/MSVmSi+ngnd4sefDaQ544OaIsClRpELogRVBqxatvnKGMweqKRd+wdAOdTFjDdAT4QOo6kktDk6AwmGK4CBmpIQtCGGgqWipKHQkx4XyHdxmhBLYwROG5vOhIKWGswJaDk1G37CFFqnFBbSI6BRKBs2v/1q8av8e15Rmvl1KKuh7zxVe/wv/wD/8m73rqvbz/hQ9xdHjCJ7/6aVb3zuiv5oyfG3N0UjEV5UAlUX+ZiJqoUQAAIABJREFUZvU3KVaXyFFA1oZSfQhV/Qx3775EeXRFYZ5FKE+TWl58bc73f897MMLRX5+DmGPGh5T2BETJq/0/4Jc/+iWuzx1PvPeQJz9wg9GN58jugGJ6zPz6ixRVQx0d5o2XcKeBO+98noM7t3j1y6/wzBM3eO7mjJ/7xx/HuSHlXUo56A4A5yPOBVKIGKPWoWBDo3vn+c66SBO8/XMOYCOBGjr3sCkcdz74OwCw6f3HmFFql/Mg1nXWxhEnr6kvO0H33tm0rXge3bsYwlb/sF+UCTFoTvbpG2/vXd9MCfboPeullRqar1vB69rFiWEvlJK7gnT9mK8nft23kN25FLHe9x0YU5sJwhag7QpaqeT2eOwnJr+dN38zp8ppHfQn1rawewLjxwPRhtvzIyB182z7AG47MdiAg902b8/53SP3JNF7B1NseUa7Tf69aDzeEjhIya/fsYrr68TNiSUVkqg7YoLEoHyX0lDUlsODETF75k1Pv+oGkR6Rk6MCnRl41GSmI4Wtaw7vZMbLjt/+7CUpeIJL9Kc9xmTufPsR95YON49MnlA88W0WKxSZxCtecHzjGcz1ipzmsDhHT36N7//eZ/nbP/FlnnifQ77rnFmtuHOr4OyljodJcZiv6FKDU5mDmabQT9AS+ZV/+iJvvLxAabjzfMX7Pvgc9xfPsbr3OW7emaGuH9JfXAwX9Ksl9y4Fz/zpd3H0/AnvumN5ZhpRuaFKjotp4MmbhrKqIEuaNvLGvGV+lTjtHM/frjEiIVNgWmiWTaS9bCmMQuWIFhEpIjIP/umHoynjSuN0hRMWEQVeCGaTgjJpslAIJQlK07bQtR3NvEWgkdIiSkFVWWqrmXeOxbxnuVhQVgVWW1zboUc1vhk6YCNdIKsKbQsI4DMIkVBSYcxwATyYwmh6TKU1111L4zJBKITSSB/QnaMoSmLbD4Wh1lRa4AN0KSK1RalIURik0gPvOStiTrimBxEJEYQwzMoaJTPaasbCILwjdAFvBElnjNAo5ymNIWqJcBHnWrqQKYSBrifHiBOZLkFRVlgpabqAS5JoSkJMrFyPlAZcixECKwRC60HnoRRN1zKaVshCk4QkpkxyPSIJiqLEGI2MEZxHWIOUoBGD13lWRNfj2xbvEkU1IguFNWLL1SQHpLRYa+h7j5YCqSGFRAzdYNPag1CRLDoECed6nI8UtsJ1PdkNBW1K4GNCWU3IkUppYgy4EAk5IBEcHB6irCWlwa1JSImQBYkCW1YUxwV9MiRl8UljyhopBpFsDgmMJmdFihmZNf2qwawpFTFLhLZYbUhhADAYMTh4eQd9j8iCrOygW1CaYjxC2oLgx9TjEX5xRfPgPpJMzILV0iGmEwqjEbrCjCcIWQwcbjKrZYMRCac1SWmQBaaaIZwgNisqO2RTBBLaKApjMSoiKkPMEJoleI+2Fbo0ZAQyKyaTGTn0iDTQG+qixF0vwXWkDD46ove41YrWw0rXTKoxypbDB7nryVlAVqSsBuu74NBKUYymKBPJvadHoO2gJRHG0DtHVRWQAil6lCqwpUULjU/DCNv5DCKtHZs0SIXA03crhNFoYYgx0HeOxVWDVInKDk5bKUDn8uAk9v/72h+PD/+TQlJXNSd3pnzprmfVXvLqPYXremYnU77tW76VF1/8dYQWPPmOijvPVAOHP2cuomYy+XboPk+ODcK9hlElzz1zi5/+33+Np96lkdN71NZTyBF3v3KfJYZj7tOnFltktB2j5BO4HPjs53+Ny9MVhzcszz1/k1u33sNZc5vF6W/y9K0/QTq9S9M52taR5ktOe837vvtbOLp1zAtPVFTSsVpc0y3fyctffcDd375GKkVVFYSYuLpu8C4MRa2SJLEuzhKw7uhtaEYbH/2398p7RYtYF0zDd3aFz6ZruqFJ5HVDAtYN6i24GO6/68hu9Bp5XYDuBK/Dzx7eX48CB7EujgZdwl45tdFE/BFAB29K5B1ufJTysgVHu+Lz8S7yIwXoGtghNtOG/FiRuRHTp0cev31oWjvS7WvKc95iih1d5u27+QPY2iLZgTq3fxwePy77nP/1NCDtn8d7a+c8tMmTePT7W0oxm33foYLNe2L/PkL+3olcbwkcxLV3sykGO8bzpmdWWTCaGDJ9hrZzrLpA9BHHMDlICEIE5zNdH7h5WFGXCi/i4G8/LhkfHyKmhqNuyfy0IQRHexlxiwD3EtWHAu/5/id45WcekHxLXAbILYGET2fY2bOk64e460tK06LKz/HuF55itRTMLwKxuUJPE25m6C+ALAkscbKHAuqxRskTFt3LfOpnL5mfBeo7isl7akJ5g7v/8ow7Tx2TF2fkh2fYVYfRFSFm5DtqvufP/HFGJ2Nu254brIhxxEJpbkuPqDxdvCYFWLWJiwfXdJ0h9B1XVaIuC4ry/+HuzYJtTc/7rt87feNaa8/79Dl9Wj2qW1JbkzVayLIyOMSOIcVgikoBFYqkKq6i4ILhhsoF14SrVHFBQVI4doBQhHgAz0Z4kGU7liVZLamlHk93n3lPa/iGd+TiXWvvfbqbpEMs4PBWnd671/6Gtd7v+9b7/J/n//z/Kmuqjx06RLRMJBsIwucFW+XMU11XyMJQmBYty6xOMniq1jBta/q+JwSLFJ66LjhZZCqGQaCFw/qe1UpQOI0IjtEO2RgpRKzzWQKxH0jO0W7toOoWlM4ZmBQISEKISAmJrDjRaM3j1w8ZVgNLvyIMI4MdSDExUZLWQHSZfiSFJakEImSX6pizbEZrVMpKKlLGrMASBMNiSSQSSUhdUGiJDBajFDIIkkxoozE7W3ReUEjQdiApl1VaIoRxxShCBghSY6Wg95ExRMrSEEJkuewQQmFFwcKOrFYOHMgAWhdMJwUhSkKUMA5EVTCbVUQRGVwg+pADeERuyBYiq+eMA85IJqZkDAGcJwwWSVb08S4ym7X0Q08pFKpY85OjR0RPkBVJZ8OSLBWqSdFBAuc8WgSWy2795bOWuZQmL5BC5DKxAl1p0BKZwNmBYejoRk8UkmldMZ1NIQnGYVgv3BKERKsM5mRZo6IgxXVDJQXCaHAW6y1JS4RQpCTR1YQ4rlBCIpTM8q0pS2rm3rfcfEvK8rtSC6QpQVZIITFFSznZRpgC5yyFTAzzu7nBWuks5ZoiOlbUZYWWBanUmePsfTZPk2u1jLWyQ1llmheyYBEDJq0oWkOUGrRCFAJnOzQaqTQiZE58iBKpBc4HCqXOjbqSc4gESlV0qwEtFSS3rsgEnCjRk21Su40qKmRKpLFHDAMqJPZ29xgQRGcptKAwCqUlWiaWw0CSJhvYlbnZm2XKvhleoARUJbQTjdYlbsxNzwKDDFkvP0nw3hPGHqVUdmCOATtERuvxcUSp3NQdTH6+ks6f9fs1NsFKXsUCQo48crDL7k6NUo5ufsL3js7QdxRf+MJn+fDnPsiXX1sSh0DsLCRPwhPTEl0/i1t8F+EtSh4j1Svsbz/K2dwxdB2Em6BLrCzpjjygiNwlSIs0oE0NzBjc63ztt14jicjuEy2TqweMccrdt27zyP4OYf4W4vgelSghSpKW6L0JH3v+BzC1Yef6PmlYMD87oa1rHv/AW7z+6j0WZ0uMKTg97gkvZ0AWgs/dsxuefLrM9+aBoOthHnLD+X8HIHi3ZutLgQwbulF+/SILuslYv3uW+SKOveyfse5XWMf8G733y84KG1Wezb/0kFOL3lWNhosM/SauF5f4VZt7cJPdPj8WnGe0H6DFbPZ8Gzfl3QBtxnCCBza/BAxykuDhv+c3tZoH8NT5H9OlFx6czw0ofjc50XcYnXEJOFx6FjbX8oGqxLtM6QP1hUuVyj81KVMfBS4m0InZbs3CLdnTWaZTuYAPgbPlwL3TEa09cmsLrSM+CZTRmKqi7z1CaqZtRLaKqBVtU7P9yCHtXs3+eMrxc2cIPPdspPOO/pZj/tW7fPqvfYKzVztu/F7P7d+fM/oXQbZcVx6dZqz6Fn+mKAoP20uMTGzvw9n9yOndJYdX4X5VkYCd5IlpIOEpZKJUCsUhL9/5VV79wwG7Shy8r6J+ZsKbdxzjm9/lyX/1X+KFL/0W9vYx+9OGw+sN964JfuBz7+eHP/xJnPMId0oRF0jRMxaapjhjEc9wyxV2SCxWkuX9Jarcpi0Ti/kSLwSTpgbXM/Rzmio3B0c0zkucSJjkUAlUZUi6pGkaClPjhgCrY/wgiHWFtY5xWIJMNE3FMgqkAeUjRorcB3B2glESVTWoUmFkQQiR3gUqZXD9iC4Kprt76KrFec+4WjI1ItOVxoAjZQlU65E2UJsaW0JRC4rR4/oeO1i8MexsTTk5yXKZMjr8akVne0zVIFCwNilzLmZzMBnxMWCkJgwjgYgoDLoqSRJwnlIaXBSApqw1VVWR7h7jhyVIj/WAUWhdIJ0BI+mWCw72dojSkELWKHddj4vQrXqKuqRzktNVxI+J6CJF2aA0NKVBSM1q5RlsT11XTKYt4zhgXTbS0UpiYkKtOX4heuzokBJ2dg0ESNHj6ZGFAmkgjYSY6LqBkAzSBYwW1EYQXE/vDVFENOuyrDHEKEBkjm1ynmVnkVJTlRrvoR966rJBmBIhQcoIImIt6CTouzl91zOM66rNtIE1zQGhM7VIZq38sijQQjLaLH1pjEAic4VAKgYC2AEp8vxIBLqeYSroViNSJAotSTHS9yP1tM2LRso8a2001aRGVzUxlSjV0LRThKlxAQiROK4QrqedZJUsEXz28zASLVrKQrIKAz46UgiIBNt1gyNliValUMZQ65JZrTmOHd0isL3XILXBAV0YmB9ZcB3T2Q5l1dJ1nmFpUUbghxFVRpYLh5IGGRIyQtEUOCGojEWkDpEEumiptiZgW6pqgkiRZHuwIzJ4SinZurLPIgrmx6dMSoHR0Fmbkyqjo2k10pToogAJTV0gTELIApECVZVoykjZVCySJzmNqUx2aI6BQMQPI6vFinpni5gC3g447wgkylbj3MDiuKOXkWrWoOoKqf/pi8U/70gpEtKIjcc8unOVJx5/hLs3NTdObnHnzj3czYAubvPJP/cXefXpW5y+eZs7L93H/9BdEIaZjKQk8aNEpohUPaI8RYlrTPcEZycD9vA2zuzRqxKINAyEdIJkQIkCJUpCqri3/C2+8+UFqjVMr+/im4Z7x2e4o1d4/LN/mW9+9VdQZwuuHl6j2JvQFQ2PPPk4z+4/yeAHkl0gqoqinDA53Oba81M+4R7l5qtv0ffwyksnLLol1mZ3bm/DurYVESkhk4BLPPEN3/uhHYJs9pQ2Ac7F51r/cunnuwWGlwP8i+zqA6+ss9ni0jbpktrO+RtZU5A2zQYice5e/YAXw1rn/724xf5/feQCiTgHVedzeZ6qh8uB5kUVYe1ondYzm9bNrG/jx1/OQl8+Z4Lscp0Peg4QuVRVSCllbJw3Oj//wz7r52DpfN4v5I3PN0h5/d7M7wXQvfDweCf1aK1uli6elLdXby78KtLm4l/svblW4lJL/QPneG/A7D2Bg9tnc5p7x5iq4cp2ze7+VUgeuZeb2hbHS954aY6fr0i7LVWhaGqNEIbgDba3CB9ZjQIzKymVIrU1zcE2z7zvKk2puW8Lqh8KXL9e8/Xt26xuOcZl5LXfHnn9K19m7y/vsPVDE9yd27x5/Ld4dPdfZ6bfz9Hxf0vxeGA6fRL/9W9hDzXT2cBnPyr4g68mXr3i+ejHNR9tniaYNzla3Ge/EjRjRFpBSgXwLP/gt/9H5mMiVYJHHtnj+Z0t7r34Lfb/tS/yW3/vN0CPHFSGakcwXvGYDz3OT37qr9MDb7z5FsPxy4zDSxynOzz9wR2+ee81/vy1gqqAux2cxYDb1fh5z/bOFtO6pK5K4ui5d+s+3cpRTDU71x7HUWOHgF8NDEfHPHbwCJOtGRZDXU/QUuPtHBtG3Ogwg6Kznm7MUnrNrGFrCnaQROcoU8iUltLgZcCpCiUUUxTeOWzfsVwtaJsCXTSEmOhXC7Qq2N7ap9GCFHuaYWBuRxZ9YDk4hpMVN2+cIfenJOeopCHpgoinWw7sbO3Q7BRIFwg2MfpAN1p8Z6naht4FTCEJwuSgPmUPAaUSzdaEoHT+4g4JS4GJFfsTwzwmQhjwwXF0umTsNUc3bzDb0dRbLYVRCJ8IXjExiZA8i/mCcrbF7sSgu4Hl8REhGGwwjCkQhETqitV8yZWdmsZU2UVTCaJImDISagUhoWuNi4qIxHqPSp6drYokck9ClLmBGB/oRo8UmhQio5GMY86aT3YmLBer/Gw7T98PrAgMtUbrGWUR6bylVdmgzqy/zGUaqdp9bt+/j5YlVVVSlgYfNd4vWMxPKZot6mlDFC6ra40JXwicjQQfKPAUWiOkwHYLoqnxUq2lYUFLQapriqrB3blJDNl/QyqNko5xHAiioDCZEqVEICZLWVesxvzFNA4rUpK0k5qt3UcYu47Beobe4b2lbmsmk22atiLZhFY1wTuSUEgUhhzU1tWEsp0hlKbrV6y6JVJIZltTtEmkQYKyUCSKJHDdiHceUSjG5QIhbFbyUZGEwylDQJNCdhefVpqxMty5v2T7YEJTlfSxx80HagGqHFA6URuB94KUcmMk3lO02yzu30BQMJlOqGYTytkEf8MRz1Y46TBGoaoGUbaZkO09s6KlVwUxORACY0qOjo7Ymk7zczFYrLW50c06JqWmaRp8cAgcyTv8uEDLQK8EWzst8ViSBgcuEJxlOt1GK48PgS5EohDUpUJqiZSB20enKBLXd7fZ2ZoxX3w/aEV5bJbEhCelnkJars2e59PP3uGNvTeJ48jR3RPmt3q+/Itv8o+/9N/xb/6H/y4v/8ELIG6zGn+NSfUpSnmV1epnKB99DnE3EuevE5sWY0Y+/oGS7357yVOHSw5mT3JoruLK36Wz32SvkGg3IIIESga3yx++eoNVSuhG0/hDZvdOkemMg09+gd/5tS+h6shjkxY5DYRDRXvlST5z+CMsnOXkZEXo36APt6AYmW2XvLl6hY9t1xx+YIs3jy09gcf7q5ydjJwdKwQC7wJ+7S2zoQqkNWd5w89/WMc61GGTuY8hKzjlOPHttIkHtfcv8phvo628bduNgdlmy7Cey832m0bwTcAvlVoHq4mwDo5E3HCXMpUzPdAc/fCOTTP228hFGbStP+v5nIpLewlxOeY8p6M80BJwHvTzQNXgwTMlJJyb1z3AMdpUJ+TGcDW/l/SQd4Nn3JXeWQVZ/7+Ecz+TcKlSsAEFG2nSEC4qXnAJkHEJFHBx2TaKU5ev8bpYfuk9XAZj6VxNKq03fC+JiPcEDioiahghCg4fa/EnJzRPX8GognExp2kCj71fMZxOGZWEssD6Du8GYgioJCiVR1YN3QBtK9luJ+zODrE20tZ7HDRXiPKAZvo0n/7IiuKv3OOn/uovc/clS4qJk18/Q9eSxWOa//3/+Cb/1r/8Bax0qGoPKSqivo+rA+UrK9i5xRc/Lfjybwru3ogMruemvUXchZMiUiAwOxG7EKzunFBf/Wm+/LdXxCHy/L93jY998YDpXPKLv3/Mo9/5Reo+kXZmtM9V7H9yh+sf+QDXqx/jU+1j/PSv/m12i4ahv8Vdd5viqsSrE/7iMy1NkaiEZhkGFsdnfOtrjkf2Z4xuzu7OFlutoS0VVV0zvjLn0Wc+QFlrrE/cOxtZnHVsNzWxKnntzVuEkJhUNU3VkIRExBU+JDrvkE1DrbM5lbMGET3ttCX5iAqOFATRaxg7Eo7l6HArS6Gyi69PJauFo/ELVqfHtE3JZDalFBohKkqlCSQaPyCTA+UYdeTO8pidMlLKglIrIomzwdGdrrhv7tHu7hBtQKaYXY4R3Do+Y2d7Shc9bpUQsqRqZwg1I/mesq1YOMc4drixx/mALgxNayjqmmm0zLvAycpydrRAB8/Oo48wncHe7oy6qPAjLJcB5TqUCVQNpNQxLgKxG9id7bGMCju3iEJCiITRMpysUO0e88WSydYWyUv8OIL1GCNpdypWK8/RnTMGFzF1TTNtQAsOphMGEjFq7NAzjJagE8l76tk2wufSttQFugRZlJzevI+QiaoxeWGLgZOjJbvTHaKLdF6gZaDUgnpSI0wBWHYnhvm8Y3HW05eapDRl2dKPS0a7ovCSQkOZIoqBbj6i6m1KMaM0mqYukbrEzpdUpUaJiBIgkiSkrOhkKEmQfRTIdBWBwAZNXTc4oRFKgwg5e+TGdZVwZBh7rBfoqmbWbLNYdJA8pYCqMLhx5O5bt9jZmlHrGlEpUlmti68SpRvkRIFdgoLF/buMISGqmqqUTCYZnLmTIzQKqSq8C/Tjilndcnq8IMWAUUskJc3uFkWp2NEVs4Ndgvf4ocPbnkZvMSt7bOeQRU1RamZNptrMqm1UTNy9fcZstsNkq0VJQfCJeHqLna0W13U5cLcL0llPY8/o5wGvBGp7C9nWKGMolcIIsF3Hdi3pQ4WLirJSXHu0pDu+TdEYrCywY/aCiC4waombz9cqRVAWihaJKCVaa+ziKIN8F/A+IDXACj8KupiYzirKqkQkwXx+RkJQKkOSnpNuxXiaGzj/9MelTBkghEbJFimnGNkwqR/n6WsHfPBfeT+f/8GX+On/4Vd44Y8d3ib+l5/9WfZ2D3j0Sssbb36NDz79HFFElHkMgSIZSRpXqDMPRcmHnt7mV3/uhMWHe6aPHTNXHXYfOtFzJUEzdZB6XPcy3fArfOUfvkZVJH7k3/k8P/j407z+wku88Ed/wuHrrzF1CWbvo31mwt6Tj7C78xy7+kM8olp+/5Uvc1Dvcs/dwhYdVSNQasUP7E5RWmAoqOueqDpOxoFlN5KAEMkJg3RBcRGb4ICs5hIf4mDpAf41l7OorAMVcR5EXvCpLmgtl03MuAwm0kWAumnillKeU4PeqZd/cb/FEBCXAuPNufLvWc7z3TLiD9t4J1/9cqCY+102I6Z3B0MbpaiLEk16B+Xooi/uIot9edazMlSe63weLqoW6eLfxsAr99n8KUzA/4vjomLwtmtwDrzyc6Bkdknf3LNSXpC3hBSXqG1r0YJLoPe8UHaOzy6elX9SiL/Z4kE60T95n8vjPYEDMzMU2xqfEp1RVLOSP/nGW+xMSwQBmwI9a5dQ67l5+y5tJZjUBUVpGIeBmByltRSNpGhbwOMXx1TbT3I0drhYczh7lno84sbiTd4cNP/Jf/Uvcvb1b/Fzv3KHG98b8USGEPilnznlJ//Mz6KbH2dinkSKFd73pLNIaiT+ZM7hozWfueaZqcB40vNIeh1ZwSd0YktAv4J0muis4/dee5NCwQ//Z88gqo7f+/kXOfveyNXnJfMjS3KKxz4leOIzj/P4U5/nqdmf5QPFAT/1H/0UH/7kIav3afauKH6gvUav50zKSGstu6njj16f86U/7vjGCyP7V0pSKUnAycmK2AXExLMzafnAh/ZoRM/Nm3MWg2E190iv2Lt6yGy6g1EN9+8vGFxktHNSCEzaCVWtKCvDqvfoskApg42CsmippCFKx9l85P69JYu55/qjM9IYqVXJdKeBEPHeM5kq/OoM7xxeVxTTGZOtGU1ZY0ePUzVUAqNLxtUCJSyT6R6dT5TLkf70PslatIS9WY0UiWldYjuHFpIoBFYIhC442N/n7us3ePTxqzjtGUZHcBbTNDT1hL53LDqHjQIlG9paMqsVj9SRWaUY1nKOY4pQN+xvSQ4OtvEJfFKsgiQmaMqRumjoqNg/2GE1RkLn2W53WHY93loKFelHOFs65icjWmlu35kjjGS5uMl02qCVzI7RhchANPaUdYMuI1oLVBjpmHK0XLC7PcHa/D6srFj2gceuXMHolm7pSD7mHo5uZOiXKCNIylCWRXYSdh47dqwWC2ot8cNA7zynKaHNwP5syqo/paom7OzvUVWSEB0rD4u+ZxSBqdbY5IhRosuGiSnWFJ0OHQPeGY69xY736PvAdVOys7+P9w47DkBCacPy7lvUpkDVE5yNeBeoqpZKeoQ0VMqgtMbbkaGzuJTofcDULVsiq+jEKBiGBcF3tJNdCuEwKeYUhjTosmR+NudwtkOMiWFY4gIYIZmUBm2mxDBQT2tMkmBairLGJVjdu4mfH6PLLWRRkFyi8xXbk13S8hYSSdnU6FpzdnRMtxy48uSTDH1H8jFXNaNBzAomeoqeTKDQJNHjncCNlhQlh9slVw4CuipRhSKGiO0X1DqR+jOii2vayEDVGg4PdlH7ipOTM1wYGeaBKA1VWQCRkzt3mO5sM9vaRimTXcu7yGz7EWxyhHFO8g6pQDclSQWiMNTGoBVUlaJqFN04IjVo0TIc34GUmE1LjJQ4t2I+JLYayWQ7Gyf2Y6BoTG5obmt8v8SGiO0i3n8/ivwPHjNEy+BPWPklp/ZFpuUVFuNdjoaI2Huav/43/g0WN7/FL//+i7z00imyXHDr7pyv/d4J77/+80jzo5T6KWBJcApGD4UkjXeYbD/C5x59k5mMSPsGU9FRVolHlUWLhBssIFnaU944eoXGaH7iP/4JorjN//qLv4COjr0nFIvFghRLnnxece2pD3Aw+Tj75RPIbuRnf+m/4ZlnH+Fmusn+4QxlSlAjpQpU3tKy5Nv37/GVF484ngcevV5z88qUk7sr7GjPy/9C5MVfiWxSdd7T+H24Av+Pjk3mehOMSPkALUJKQVwHh2+nQuQdLnjqm+zq5riXfQ4utOE33rP/FzSkd6lYwIXh3CYr+7DTWzaB4+bT57mDTBmNhPB286vNPF8OGnMgK97GTd90FF/OkJ+TUzYULSmJawWoGMMD1KWUUjbm5AKwZK+DtQfAQzz5cl1RyYpQMUuPbnwkUjynZW3mU64pSBvVKLgAX+cUpQfmfz2P8sIL4dx0Ll28h83IuO2doO2cYvfPONfvCRwUesLh3h5RJG4dLWjLSFVGco+mRRrJ/v42bSd5640gF5CZAAAgAElEQVQ7uLHAF5IhOCISpQXV3pQUIWqB0gllArGweDxlstyfv8F2GdjWhnK6z3Y94yx9iG/tVLz/ky/ykUfvMPQrbvWOt77n+J///k1+8q/eZJQTNEv0TqT+6PMc/dw3mU4i4mriiWcFy6PEq7/tGJ5NPPY4zDTIlA3WlklyEkruVgccfHSJevE2r77iuX/sSQq4p3AdfOhzmh/90V2eevwnCPqHeeXGnF/5n/4mX/ixj+J5HaePOXGBVed51CwpnSesRn77xPKbXx/4zkue1VnCLh1XrlvKRrC1U9OUFUKWnCXFXlNye9Exne4RRaAsGmbtFvu7U4ZxICTB/s423o44b7OyConlcsAsHd0YUaakaQSVgiQM4PA+q99szaZMCocmcdKNCBWQUkPIjZxlVdJubzOOK6JXhAR9TEQXmM+XmKrGlIkgE1QFZaEIUbC6u2Q+ZDfQShUoKUBEptsJ0+7gFyNJKpy1xNFTVIK9K1sIAV4I2smEsoTeptzoqjRFpdgpC1ZDprCMdsDGJdODCckN+CSIUWCA7VnDpDIkaRiGiI9Zczisgx3ZNAgh6GPO1s+KyBAScdFjO0tZF3TLSFMqpte2WB4bxv4MbRI6mVwajBHUuvyPRBUVpkwYcr8BdiBhSaphOcTcQxEkSiisjRwfLymKiNGaJBJj32OXpwilUUWJ0IbBJyCbVQWtOTk+JZZybYoCISW8i3R1laViixKKhigTwQVE8hQFLM48qi1QPhI9RKGo2pbTzqFE5t/GKPEyAzUtI+NoicFBylQbKQ3DMFCaTIXxo6Xvs3JUUXikVgQfcGNPUZWYUqPNDOsjhRQYHZCyxseQS/sxUWuDCj0h5Wy3KQ2qWMt8Lh396GDjXhsFUYCoNKYoiUmh6hbrA84nlFJE76gnDVJofJD4BLrUXLl+FZ9GVv1Ao0tEkEgKikoxJo2qS8xafS2IRCQSIshyi9EB3iGBuimQRIR3oCT11j5KG2KIxGEkjFmOVkhNWxu0BB8jUSmEqVnNF6giIY3GpExf0MpC9GzPKoiJOAwI7REhknyiHyJCS6JPeBdIa9MiO3RM6xqlSowBqSVRKkyp0H7k7HSJ8zErRCGoqxqfJKIYKSpJIDLYga739GPEKI3UJWGtiFaVJquSfZ+HkgWlnjH6+8zHWzQ60ipQ5TZDcYDnCXae+Cgf7X6Bj195hXk65fh4zht3O1742st89FM/iI8lilPkzmOkMDK89lXMMyViVvHocyVusWL+Zo+RjmevZadyEiShGGPLUhwwNo9y+IHbyBtf4+svLDnzI/XEYFEQBM/9QMsnn7vCzvSHWdp9Xn7pFY5f/yrPf/g5kLdQZsWJT7QMzGKHDp5oB77ddfz69+bcPnL4ZcTeG5nfXyCIlFV2W/c+EtZ+ABdKJRvn2IceHuTgUlyujlxy7CVdNAOz4Z2/+2c/D0bFJb62uAAO5/ufp0Ivjqku93LAA8HWJXr8O3nZD+vYVF7Oo3ZYX4SLfgAeDFQ3geSGziZEVnva9BysD3sRoF4cBLFpLo4Rzl2WuXgPYkMvyts/0NOxqRSFQPr/w/0uBEpKQgzn83bZ8RgeBP2bOUqXgOqa6Hb+2gYAK6Ue6NtI58e4fKkflEDdnO3SVb989nPQHd/D3L8ncDDd2mZr95DBWxbzJbfPTqhUBK2xzqOFIqWAKhTKgFUqu0GSUBpEAlMasBbdVOhSgfL0fsW9k9eZVYKb9+8RROLKdJuJbtgJie1CIJ/6IH8kZqyal7BvvEox3OXjzyr+6LdG/swXXqC59jhtVWAK0DNLIUDYiHSecpoYFgnmickpPPUEKA/J5lJXmEjOvOS7L5zw2ScEu9Hy6fddQU2f59ZZwz/4jV9iZ9/wF/7sJ/jU+7/Avfs93/nWP+LV797n4NprHIWOsrrDlrIkKShTYtd2jCcDX70f+d3vOb53LzGPAqUldkgE6xETTVNLqlIDmpgk3TAiAa0FdQVIzaQtUEYwrEbGzlGpHLAYlTIViAJsykZM3hEZCS5nop0dMMbgAak0hYGQItIopLIokQMGYqb7VEVugFGFQaEJKPoANgUGH3DLJVNZoFTWu9ckDAnferr5AlNXiCizihOeSVvTzFqcBR8y55MoMv9eaCbTKWUBhQBFAqVQZYUXmuQslVYgFFpE7LJnsRhxSWK7nlXvGVwiJYUWBSHCWedwLhB9IkUFSMaUKI3ByIhPkULqHJj6mKkJPnsiRJ9lPbVSFFLgVUFhoMCj1ipNQihkoTGCnNk2BiFAS4XQhqAUKUHfDbmkKhW1zlkEb3tMsVYyIiDiSLCWojYYo/FCEHwAIkKC1hrvsswqKX8BK6UotaEswXpJUUii9/Qu4WxEykRpNFtNQ1u3SHKQXSiRFwqjCCREymXmWitCSBSzCVVp8hxohdSaFDNtxiFy/0FMmXKkBUhBsD4DpRggRZQSqEKRRkdVNZBG8IJiXW4VIaClpioUPmpCghQC2ku08CijGe0APuSm6ySIUhJJxJRdbZGKJCRJRkKIBOco6hkCh/MR6deUGpkIQiALk5W4fMBEgZAF2mR1KaU0wQ6kECAK/Dii6poYIkIZ5NrYpogeZT1GSYrCZCpfigQB2hgGJTFrYXdtJDJJWBuReQG6bXIg6DwpeGyQKD/QNjP6zhPciEgJnQRSRtwQGGNuTI4xgN7IW+ZG8OA8XmqSi7gUMVpibWAcHMEDMTFaT6Eszjsgi0KkmBcCpSVFVVKUJV0/gKowCgotGbv+vSwF/4zj0iIpQKBQsqJUW1h7gyN5i61iB5NApoBQBt3MmB5+mP2dJ3n5xpeJ48C0TLz6wj2eff8/Rkw+lJ1eTUIWKZs4BY8IA8VWVjSTA0yqyJMHAhESySfQBd95MfHW/Jj6wPH8I5pJ6Nn9wQ8i2vfz3bs3+d7t73B1r+bjz32W61uf4d7Jq9x45Rus5veZbt9nRUepjmmVw0lDy0jlVzjb8VoX+MpbHW8N4KUkuMDiZMRZhxTrDJ+8yLbm6RGwdqrdGKM9zCNLW6Y15Tz/lOu0ttjw/IH0Lhnji8wpnEf8lzKhF4hgQ2G65Na7DpASmY+dRSHWnOzNOdcR1SaBehkYCCl5qMd5L8GDFZT80oONv+c9HpdAUt4lA4SLbPfmbxcZ7pTS+VxdBhrrI70T225A3WXQIrKc8cW+D3Hp4BJlR16irsEGfG3m5EGAlUSOic/9ELgEDNhcI3FB9YLzSsPbzv7AkdPFH9ZmaRcUrgcqCu8RlL0ncCB1sW40FTRbBcerjsW4ADUiiMQE1vbo2jDZbnGjykopJGIMSAJKgiygrCSoyOgdzlpOFif0k4Kbt0456UeO2ikHumQiFdtbig9uP8Hiiad5uTH4omVavcX18CJ/+Jueb/zuKzz3eYW5dkhRWKQ4YfKhknDsoE2oMtEcCJoSTl5NfP4ZEBb8HFwQjIXAusDecMJnP3zAbnvI1Q/sMDv4LC+/8TR35paDxyRPP/cxbt/Y5carv8btb38Ddxeu/KUtvvnmV3n6UYkOgtob9CC4ebvn9sLyB6eCF14P+FKha4EaBUrni5VVFBMi5fKTJNIPI9vThoRHGxAyIYXHhYGQPKvVKV4VlMagTQFKIlDUTYO1EWGz5F8IniBqovMEtTa1IpJEzmI20wkzH7Fjj085WDRaZh354JFSoUxWTfIRfPIIIwl2JDi55g1nAxUtYKs2uN5QTVuEA99bgg8YKdEkQgxEIlqtHf+UZByh0IaqkDlII2GMxpQlwQakyJlULSRS5+zxSee4uxiJJOzg8D4hhMFQMLiBIUaSsyQPUmbDtdEFUkxoHREEEiqrM/UuK+YoyWhzkJuA4BI6eZTQVI3B+IHgItFnYKNUgUqJfrCYdWCvlUJpg0XgF2eE6EEICiNoSkkKYHTOppMCKXhS8kijESpnzqLPIECIiBTrgEcponP4EBAKhCkwTU1TG8QoECJmz4QAzkVK5Sm1YWs2oywLJAKVBJVS4DtEoUkhQYpopdBa4JWmaGZUUiCEyiZ166qAlAYfPVpkTqXRIJQkBI/3MXsVEPK9lXKAo42maYtctQnrBTskXD8ilaJoJugoGK3D+YAbHdIlUoy40Wd53pTfizQFIQasi6SoSCIRpUJIkyVFIyArdF0gvUeOluRHQjdQzEqaaUs/7xh8QNmA1IJSl9jeIkXCOoezARsEw2JFpVtkTGhdIxVIEUFmwFhqjVaSKCROCpASUzWowYH3uBDPv6RTDEQ3gBZZLjUEUhjxdmAMijIGJlsV49gRY84kkxICj0oBPzpiAGQuxVtrUSniCdiUEDIRkZkWJSKj98R1JS2GgBWWngQiIkj4kBBRoZWmrjQKiSoKhtFTlCo3usuEtd17WjD+eUZe8jRKzOj7kePhmNEsaWRFqTVVWZDUffZ3HqNVhkm3pNKednidN759ws2Xv87hsw2mvopggTArzP6M1HWkMiErSakMRI+eJ547MCQvSZ0nyIKzPrE4O+Vwr+Opa09Tl4dsXXs/pvgRvvLdtyiaPa5faTk4+Aw3b1rOzn6H5d3jrOB2WHF78V2mOwoRJBPZEFYjd5ZLju3IS4PghfsDZtKgtcxyxTZkvvd5lvYSWNrw5cVaHSZdCoAf4nFuuLWuCGwC8QeMnbiUub7UZiEu/ee8n/VSxnSjsMM5LeNCFvZibjmvMFymaDwQg66PuZn/h70heWOWtWGxX56vXFR5kKZyIW96UdV5e5D+YGXhQtFJrBu4BQ/OmxAPAobLRl/vaH7dzPmlTPfDOOI6wN/ctxc9GhfzlgXKL8bl65F3W8PVB6o++SqGdOE0/YBp3OVCjLh4vjb9MxfJBxBJnFfdzoH2exzvCRwcHy84OjpF1hrV7rK3u8PtOys656mNQBuBwjNtWwq1z3BniTEB50aG1UhTekxjmLaKWozY0TOEEesdQ/AcLRKn93qOTjpu+RtMo+PKRMDejEevfpt/4bm/xIeubzN+6jFWR4Ff+Lv/BcV1z2/+mqNuX6KUc9RhTa0S6rMN7u8cEbViOoFmXxG6xEtf8vyVvyHRI4yniZURLEWkdpZ//8cq5GPPUhSfI/oXiPE+T7/v4/zd//y/xKXIf3/3RX7m7/ynfGR2iw8/U2M/UPLbL73Jp65GntLwrVPBPFlW9yO/+eWRO61mpYEC6lpQdAIRoKgk0ijqUmEkROtwVmSNcanwSmejHKGQAmIaGUcQKTB0C1TbIoUiaYU0JbazzKbb9MuB4Au8tcQIUTcU0SKiROHpfU9EMp3M2NnaRcnAnfuOnVYjoiDYlKU3iSSpKbWiVAIpQgYvbYEvYfQJ2w8YlSVqvdDEsaMoGup6gqojVgnGpcONnn44ojtbUTSGujBooQkqN+bZKNYyf/khkyLzHb3rMVqw6gd8BCM1bT3DJcmN2ydMtveyIzQKU5RooxnGESk0q25FRFAYjZQJ5wNx9CSZM/8hjSx6x83bC7QdKRrFYuFIMq7pq4lCC1yAdlqQLPizPmehkiR6h+sCdtVT15q6LjFlSaEVS+cIy4CpDVoKSi0pS4FC0tY1/WgJbsS6iEMgqhInwVkLISC0ytKzKptj+cFSJo+LkShVzqSXBUrXtMnT2RGKhCSDMKwjmAI9qbLhmdG0pqSUCjs6CDVCCpTKgWgUYNqWSVvnhnFdopRCa43WiqEOxHFESPC+wxiNUorVapWz62kkikTA46IHL5A6q5cJJVCmRClN9JHoAlEGVNmiSUhj6PqR1WrE2YEiOYzKSlBRZCffJAUxeKyPKNXkSqSQGFOgpELENZiraiQj0uUqZb9colvJZLpFtJlitlpZpE7M9hsWq54kIXkYfWTV9QzLBabaQkSBLEoKaRApCwP4pNBCo4UmqQInJR6LKAtQHWPfE+KGU5tI1mK0RMiCfjFSFWW+95B4mzBFk83xygbvIqPLHgm1EZSNQSvBYogEmfDR083npGhR0ylKgPIWk7MHnJ2dkZTJ947O9C83BryJNNOKMHoIHpxESIUyFQhNFFCVBTH4bMYmJKks3vOi8X93XOQKFYvFEQt/xPHwHfabQ3Znj7GwiiRe4fnDz3OaFnzyE5/l9ps13/nGbdJuwTf/6JhPT7+CuvoRysKjaoO8sov/2k2SmdBMNUVTcvrWiuHOyMc/05K8IPYRWxo+9LzkY6LkcHIFpp9DqQ+TwteI8T6fffYjfO65L+JS4Bur+/yj3/gP+OLTmmee2uEUzxunt3liajmQkldWglp2vPFWx4t3Bu6WJadKICrJzCjwa7AbIlJnaqAQrEHtRSCQuIgT5Dv48Q/fiCnLLEsyHQ5yYiEH7ms6xfpznsejYgMiclAr11SkrOIS3xlYbuhF69/fYTQVE0lcZEsvgqbNcdfbnV+Eh3vOYX3vAJepVefymZcoLJfHgwpSFxUYua4UX8Tsb/Oo2Mzpmm+/ARBSXhzvwebmy9WLB2k2l197KMfm3hOsQe6m3+Jizs7tTcjZ/7hGw1Jc7iO4OOSGJrSZww2IfVDV69JbiIkozpH0OhnMmk724D2fN9n0n/zT7/v3BA7SMCB8IrrE0Xe/xe3b9zl8suDezSVDqdBXJmwXBYuj25STCTt7YFeefmWxq4F+PlLWgu3rO0xmmm5wrLrEqCSPXJ1y4427HFyVCJ0YosxqLzqx3ay4dazYffnv8cx1yf7eNYr3XedH/ubHeGPxJn/rr73Oz//9kT/v7vO5H59RtjXu5i2khSgVByIwP4ms5pFPPi3wjcSdZI7XoRHsB0V0AlEm4vAdbP/HnN7zJCmY7PwO5f5PYfgw//ZBy88/a/jyH3tWleXTf0GxdctSXin5kxuRr9+K3LiZmC/AHRhCJRH3PckIZlpRl4LYJtrDmioKDg+n6CgpixKztUVMNat+JCbDfDHSVhWVyRe2d57F8gRVKXb2GjBTAhVKaGIlqYxh+9oU73c4vX/KcjmglMSOPclIvActCxCK3gXuLVa0SvDU+66yOFvQrSxC5rvn+PgYURZcO2wRImL7Hu9HZFlR7B6wOJ1T681Nm+k0Z4ueotSMJ0f4mGU1dw93ESmwuHPEzpZhcCPWOUzdcHVnh+n2jD95+TWczFn69dOAKVegImerJVJqCqURIhLTyLQu0XVBW1cMIVNRiiJXDUS7heyO8c7i0NjgiFHw2MEUlGKMiqPTBavVCtdbok3EVGLahHNzQlGTEth+RAfFbEujpQQzRe9MqJqBvpvjk+X+7SNms5qTW8ecHS/Y2tvm4OoeRkRq6SmaFlMagh1ZLefUTQPB0ZaSIT/9hBRYdB1GlRRmyhAdOiW00JjCIBvN4vgEn8A0GllmxSLtRkJXocMAIeFjpK0r2lmJpOJkcIjokRGSVniZXZyLekajShaLkeB7Sp3nziVBEokh9AjrMMZgTLF+kxYdHKbMrucpQkiCqipJQ0e7NcW6XC0QKeHHDgaJkRWmNKQIPlhiCBl4RU/wYw6QkkQjKMkmeVEqDh69hgC8B2sD1o2MfqSuGkxdY3uXOWA4ovaUTcOw6hjO5iilkaZCSwN9YFiNTHZ2qFTFaB3LbmB5dMStsKKSsHX9fbgxMHQn+LMFU1WxPS2pp7MMPIwkBsHopySgGwWTekoS4NNIEFDVFUFrTFNQKYU2CqkUIUrm86zUJKMG79BGU062GMclgyw56zzRVLjkCDFimpKr+9sMqzOEjiwWKxbzgW602H6OrDV9XTOmkYkpqbyG6FgtLb0daKctdZEVXDaAZkCzvH8PTIGpImWrMNEQ/IAqNGlxjA2R3iei0rjvi1rR5UUk/8g0g8B0WtCww9LBdPIMbbnFvfmvMwZHe/Sz7G9XlOb9XH284cOPfZGz7gb/23/9Jf7gl2/xqZ9oOLj+SM7KdXcQIYFsmREY5gOt8EwPS6Kukf2AkJKZMkx9AcmAGsH/McH9Kv2iRxW/QVH/OWTx4xj2+Fht+IdPGH7vlVM+MamY7Uoau0S1U944sXz31HPr7sBKCNxWg1cSuRxJSrKnCigcLkaGM8vquCNrkm8kOM9z6Q8GtWtywcM8BIL/k7s3j7Elu+/7Pmet7S69vG3eDIdDDkmRFEU5Wk3bkknKVuLYkoEEUGBbiRNkQYAAUWIYFmAgNhAgu/9I4CjJX1b8hw3LUoBYNrxA5iJRCkXSFiXRpEjODDnLezPztt7uUlVnzR/n3tu331D0QIiAPJ/B9Ou+3bdu1alTVb/luyi1gTPsqp6XQJ7SKcjFoPFKoLN5pqT0u2Ohd/yDyxSzEJPVHuHzcj9SKqiF8ta3BsKZy6ThSR+7JFNcHqsUgphL91NxlRB8qXYj936+5Bo8PnZQlFzkYR93Bd7tx16itnX+3kFbdn8DSLELgp/kzsGWGP94AnvZQbhMDGIq3WW5g2VxZS0refVc7N6419nZdQUe6ybkvTnO27xu2z3bvDfvn7O3Od5WctDNWxKZxek5BzPJ+z74XXz1lZeZzQesFqQQODkdOL4+J6ULxGJNuBjJLlCbTHVoyRXk83u88NCTJg1UxfH17u+c8Nqp582TgdltTaoEPsNdo5i/seK3f37F3zjLuCHz3NN3+NGP/wb/7n/a8NzBLf7a3/pefuFnvspXfn3J+q7joz9mmR5I5H98TPrCKbMjyEvIZ3D8I4p7r2fe+xTIZSFN5RqYGcyRIb12RiBx2EBSkIcvMzz4Keppi6j/F/7mf/LD/PznYXXyCt8nLnj+I5m/+umRa8DdLydWnSI+pVkPEfEocHTT8P4fOMbdEzz47TXnby4ReuDo1oR+FckelOxpWs38wDIzitOHj4jiEGtaJHMyFpFOsU3NtYliDI7RXSDlwMQa2izwI+S0xgdBW1s6Yznvz9EIoltTVzUxJhYXK1aLkZs3rtPXitEtmTY1nW1wg2cYB5a1oZo01JXB9QWTnU1Lnwzjg9NybK1Cdw1V3aCV4ul3Ps+DO28gsqKyBp0lYsx08wmrZk2+OOXZm9fQusJqSafh4uQBfjHw4N5rdMfHXL91xHxm8dERfKBWRU5z2klEhouzNf1iRTWbYcczVN1iqgbInC563HLFevGIbtoxszVSG5Qx9EnTL86YHh8iJaicitNp2yFE5vTinEnXorLHKk3VTUr1FYVVljFrXAzFA0FI3GLN/HiOGxdEIA8BdxIYbeRssaStDKkfcW6NNpKj+QwpBP3aYbspWSQiniShbhQpZrq5oXKZYRwYVgvCkJnOK44OaypTc+36nMpWxKRwXpK1Rreao5Q570eW6zXBeSpjqJRheXrBpNH0OTCGgLItRoxcXKyoTIPp5tQarJHUSqMlpXKcHTpEpCjSsoPLhNWKpyeHZKVx3oHwzA8OOH000DsHWuPdEi01TTshRklIQBC0tSEEz+gc3g3U7SH9ckXyPbZqsbbDHjS01RLbzhB2AiiUTBgcJImIHlV3CClRTUMcBpJfoJMh+gsWZwuEbjBVh5ECmSXBO2SQZDtADuTkkUTqtubey6/znu/6EFrX+MEjVIvqjtBWQBZoZUjjivXFSIyeVnmqg1usvGTtIk2l6NoOKQX9aolfrtHWErIhU6GERkgPcYkkYq3ADQ5jprTTCd4n1kNk8CNCOKSqsXWDGnvuvvAyQg0kJbBNzfVmwnrVc++Nnul8hplPOJx22EqTk2NcL6ntBCWXzI5nrNdrht4RvAM8izsLbDNF5IjWFSEIVufFaVrGAaUyhJ7kEn2QnC7Gt/3Q+D2PnIk54rxnvWw55Wss/JLXVnfQeMziAV/79F0ePuoZloHv/e5P8wc/Muf9H77Jcfdu/sxP/SS//o/+Hi987hWGRyfcfr7DtDXiD/5rxFd+i+awJrwSMdagbxpWy5Gjidk8NgNULcJOkVaTly+RGWnrTGIB7u8S4z9A2Xeg9V/hr37sz/DpF36R2/aU601kbjx//+UzrgnFnRfWhJtzBitZeY9ee27PO977zDtYPcp86esv8NJvvsHJ6ytI4IbAOARy3lQJ97r7GQrcTxRn8id9bCEMsFGl2UhnSlVUvlCXsIdtMLMdSsmdXKmgcKNSygghkUqV5CFfSqZKcTXWKXyHjBSFM7TVkX98D2URoN+rdD+5ErLw2P5vAvS0x6PYdVDYBKebTs5u6rZwrcfGNtFIKe3y1q0a0RWi8t6bt50EtYPJ5cvEBXaV7G1y9iSP7Tzso3WKgZx4S54v94n42/dvOmYgduIEe78EigTqjmOz997t51/pnD12Dnd//1jy93Zn/W0lByoX0qiLgfP759w76+nmifn1A7xzjEOgX47IQ0M1OeBcDlSzhlZntI0oEfDB0xnB2hlEFckG3AhnQ0aTaE3m3j3PeZSsLxLx5Z7wMDB/VvEdHwC7iOR15rOfC/zSP73gJ76r52N/vuL7/5jia4cW98Dz8I1IM28g9sh3S772YsROBDf/iObeaaK9A2IKQkO6l4k5EZ8NjK8lpo3AZEEwCWlA5kRcRKKKaPvfU+kbfP/Ta37pa57/8mc9Cw93T+DVSuAkiKdAaUGjJc9+eM533Z7w6htrzl4OjKeBShlsVgQvGJaeqVZolTCMyLCAlHn2essiaKaNoq4BIoODPkVClFjbIAW4nFm4jGHk0CgePRxRWWO0AgnRRXxuMUlS6wplNMIrwpCI40iWFU1lCWORMfXeo0RgPrMYY1gtV2A02VZEH/DjiqrryKtThDqkjwUaVk0a1sOInh0SsmE9ROLa0whoq8T1rmLV3aatLCp43LrnznLNm4sFCsfBradZ+8ijR0v8MGJNRQgeO53Q1hadPWPf06/XrMbM3NR4l8EEghg2D1vBvdMLTBKoMSDoMXgEiqVfIYRmdAkVRo5mLUq3eA9RK/oAOQa6pkWkwLIfCUkwuky8OKOpKqSyZGEYbUd16Jh2huUiMp5cFGKslrjlilYZoku4WFymszAopWmbmlr0jDHi3YgPoeidK4UwmsEvGNcj0YdiEKfBDoUAACAASURBVGMrKtGQbaSpazKKwaVSgQdkqFmFQvpujUZpSxaaED1++Yi2sWgp8YMnu4SOMKRAdo5xDGSVELUkoclOsO4FaZRoVdR7XLJIIWkbzUUPymqQEPxIjI4QHGiJbqAyksocIJUloSAFcpQkJMI0JfilQOhyXJGzBx9IMuFz6dBp26KFIfVrsmkQukboCqUtnSnE8bQhdtmmRlWmKFZFmB4eErJCKVOgDElwMJmwXJXOgzYKP/Qs7p8QRnjX8+9lcbJgWI+o9pB2esDBvC1EbJkQMdMdH1FHX0jKOeLzSNtO0VKTQiD6VEiWMTKZTMiuqEnlfiRJj1IK23b0Z2eoWiOMIcWM6x3aWDqZivKX1aQQGZZr1henWJ3p2oY0eqQW9BlEU3Hr6RsoGelsoqsl47Aiuh4jEqZV5OYmWgkqmRGtJWRJSJEUK9a9o522BCHQQtBaA8AoLW6oOLrWUbmeRT+QZXybj4y3O976CMpACI6Ti1cZ3APeWAy8Pg4sHzzEvXFCuBi5+c6OD3+ggpMlIkY+9ckHfPIf3uej3/kS7/ujN/iO77/Fna/cI+TAsIooc4DMp4hrHXfvrTm41SGVZFh7zFKCFQglSY9GcteTpYSlxGpV1pboC70jerIfydIj1P+Bkc/xweORX/3cQ37npTVnLnNvAZPasNQC21hMW3Nctzz7jiOem8555f5Dzh5GZtOWmzcPWZ/4YpgWt7ySjXzjPq4obaqIGx7CkzqKuorcVEg31etNYFOCm7K+dsTgXXaUdlAjdnMgNsRXwc4JdkOGlVxqwG/Jlo9j7bdrT24gFilvERdbzgLs4rf85DskZ7isJm++LR3aSy7A44Fk3jUONiFqLlKmSqndOtzOylVuwj7XoGxvv+MghSy5x16gup+ElO5RevJJ4MDW2+Mtawt2vIy8+bv97guwSX433h2ibKeYeJftCCkvpWP3OwQ5785puZAu5Uz3k4f9DgLb60uUa0cILnf024y3lRxE71AiMqkEakyMOtFNGiqV8G5kHD0iZtLSMIrEdDYvlUVGlEpoIanqDiMtrRsZRWQ1eFZLT9OBV4L1o8Sj1wNnjxLjRaLRmZ/4j6b8oQ++k1lrUf6C6C5Yr3ruvz7CG47P/+M1z3/QcHsOd9eSX/21yA/Vnqc+BC/8auQ3fyvxrg8onptIql8KzN4lyK9DakB2gqzAn0fMATxawMGhKQZfvpxwKTLkSM6vIcQFZ28sePBaZLnKnPnSoX7HD1UsjGalLY1RvIuEvu/4wq8+ZD14XFbkXJSJJvOOCkuTQWfQSSGSIIRAJRVJaCyOFNa4IROS4Oz8FOEF1dERLiYyAiU1EkV2iX7o8TEWImxSWFMxbSaM2XCtm6GEKgTRTmF0Q1sZUNC1DeuLCxKZqrIY3aLziO9HXFKF6AqkXNw9jRVUncUL0AnkmPHRMYRyJxBSUckISiAFnPQeFRKNzTw6OcUajRCaXliGEUSS+BRIfiRVgqAzCoEylqqqUUKQhcCTcHnE2Iw1Bj86luc9kQFlDUbXHM4maCRBC4SJGA1GKbRUmLpCVA1H9W38ODL0IyonJJJOCBaLFQ/PipNnlqAQYBskFbLuEFqhU6BDsBhicaE2FVVVkzeQENHUhbQfEsEVIzCjDT4kzhc9jYw4URyKvQ+ElMlK0bUVioSWGVR5GBb4jsE2h7RNCeaKTJrENjW1MixcJkZRoF1SI7QikMmyJsRI9qXSJqWAHFDakpTHrwdCHJGypWosKXhylkhrCg8hFyiQ2txT5rMOacyO97Ct5k26Cqk1VdWgJUiZERJykAzOU08OUFpBiuRkSKnGjQFta4ILiFzkhKWUCK1Zrtc0VqGNIaaRjMIYjTQaEKToEcpsTHhKpVXpBoECl4jOg4hoZZBWMbUVUriNJGmLmxWi73RS4cYl2nY0bVU6XUiQmfPFCtEIIKIrixCSsF6Rg0foAZ+KolTKGbShmR4TWbB6cI4QCW0kRkmkyKRk0EYhUkkkcvbkAFYakpAokcH1OOdIKdBOG2pVJEofPrqHFxCVRShDXbW0NczmNcZI0pjxMRFINJUB0xShg7wkpoxPFLM4KbCVoakbhBKEGBndiKkrQvKcLnrWPtK0itoYLvLvh1rR5dgGv5lIwvNwcZeXX7nDg3sXDP3IzUPFH/83nuX5Z97HpFIId4/oz1ktL1ifX6D8km9+8R633n3I8TXNyYOR9Utrnn2voTsWPPjqildeHGh+oGMaE+HVHn1dwoUq/iTTuiimuRFhK9YjtO0MkR0iBMhFLYwsyLwA4pzlo4cMywHnPUME2Sie+/Ah92LFUM+5aRRPiYx8tOILX3jI6HuCmZCyJAmNH3JRaGMLrtmXHSwP+JRjCYB3UI8nc+y027cQhx3kQmx8BTb32H08+2WMuQvtt19TSjsIBhuY0AalciU43f77uIyj5DIJ20evpE3ysqtqsw/veDLHpYzpJdF6e1wlmNzrInAJpdqfixKUys0yzLtAdrudSzWetyodwaV3x+an3X+ZTfKww7mXe8BlUvZkz/2u+r+Zlyy2gbzYJWXbnOBbOSBvVbe2r+8nyfvnsPz+8nPTlhi+wxBt8gCuftb26+OJ4tsZbys5SDlgVOSglUyzJs1q5OaBI6SgqiQqRKLzjBcDcjpDSEmMAu8TGEHKggWCCLgx0S8860VPM5OMKeFyoj+LhIvI7WPLj378Gv/2n3qKD14/AJbkpMm5IqfM6gLuvph58EKilQmrBIu54HyVefj1kdlTmtPPJ250cGsuaARcvyVpb0v0QU1WHnVdoCuJXAvMgSa4Y2J+gAoleBHkAhOVQBpBnLA88yzPE7ITHLxLcm16Hf3uEXUaacdEswZ/EliNiZe/7NBC0NysqOYKU0uiy8xmmm4TCGVZqqIuFrUeWbfE9QKRHSFJxpBZDx4dFf04EJxHaoO2EqkMPkvG4MkUR8KYikoGKqOFo61agkusxxHnobIVXVOMmHKKpLSxmNeGgKRuKwQLdGNwIcKY8CEixUYSc9oW0yg0ZEmMmRAl0ntyGGiNhEoSEESRuRgGnMslCBUSoRVRSqyt8c4xLJZomYuSTipENqUssJF2VYq008WHfr0iBErF1UdEiBzMO7q6ImZFyAmURuqM1ZK2amhmE7wwWATBRxIOpMANgZwoFeFc1rFRkiwlQ5YYZUjCIFJE5YjV0AtBDlDVmqarkVLQtAZhNNloBAm7uVidD8Sc0drSh0ROnkLMk4gcEDJRV4W8GLi8kWzbkllZUs7Evsf7sXQalKBuDcEXIqlIxWHSKoUVghxLUBxzufY0oHXetNgVyihICik0UmhS9tTWIrTBj6W6KWVGyUwIkUpr0C0iCnS1vflntCn4dql0udELgZIKlEbrXGRWsyf6QIpFmQkPw3pdEo/NcQpZ5HWdG7DKFOKsiihlUMIickLpisH1iFwS4xwD5IxWZQ3muCE85wBWUHcNUjckvyQHT2UrplOIdSADzaRFVwZNILpMTB5jclHsqnTByioJRoECJSyItKnsbAyrRCFt29qw2sAqhamQ2pCCI6dIbRXERBaSJCV5A40QqbR3U8iIFNESqrpG5khOMIaATxlTa+pKYrREmUK+T3Eo120GnwVWlMBe6QxSMvrE4CJJUDpIQhT+B4XnkkLABfAx0I+OcVwjRU3b2kJc/v907D+A8u45EqNDKUtTHdGfObJzvOfpOd/7nbf5yB94huvtNXI+hzwDJClZxr5icaJZvekwaaSxmqo1+CGwflBgl+uv9hwdWmotsVIiZzVqZhD1IcglctYgoiRnhbAtKR6R0puIpCiuN4ly44+QzwBPv1ziQ8TONfOm4uJljb59RPVwpBaBeulwvWPwiZdfXdMqaG60nLy54sHr5wwrB2zhAqLkHru5KcFs3gTO+cluHACPBzIbeMUuDr+Kzc4UpbyrJe8tTv0yMBIIkFcD4N32d3N2NXjaucpuxzaAehx+sRdQP9FjA+HZcQrYzv82UH3suNkLNMVjv9gmGPmtidOlVOdeMvYYpGj/c7ZqVduXdhXvLC+r6f+KjUtVrrf8gv3a/nbZXs7vftB+2TG4Chu6vD72N1uaAvtti8s0bJss7O/b5Sd8+/H2OgcqoW0q5lpYTGc4WTvGMWKMwh5WGO/JOZJcZDhfoqY1CUGMEEmQHcvkSKMneE8cA9kn+kVgNALVCepGcHxU89E/fMRf/PefZ2aeIqc3ies7BNcDGaVgUks+9D2a1Xsy/euBR29mjg4lB09rTj4xsPztxKERfP/HFcfPKySC5scrchRk3RFzQB1Oka3ExgukbqjkbS7uPCIuc5EZNZRnRszksKmIV6AOJXXSVH/0CLs65usvv0581TGNiTjAi69E5HWFPNBooDvUTA41RkrS0nH9PXNmbY0XBp9kkSHMkqCKEktMoGIubXMPSlYIJRnWFzAGVGWLzrfSIE3RrpcCQiSTi+PpYkmrPH2liT5ycV4Ikl03JVVF+3sZHCEJjC2yqOMQaaYTYpMwlaUaHDmuGHpf5j0GrJJIowskJQmy28jVDj2hX8G8QVYNQhgkkeXYs06CA6sJMZHTSAqOpq0K9vDsHKE1QqoixYhCZs3oIot+pKkNSkBrFULBxfkpykwxSjCGvKmol31wMZJSImpFFgprDfPpjGp6wHpY4vuxtLyVxvnIYj3gs6I+OGRmJCIFgg/0wuIWA4qNpGfyaOGxFiZtAzlTGQUdSA2VlbiQyFJAjlgpGIaBEDPKVjRtTQoO4VcopciaAi82onQMciBFgcigtcLokqykEFiFQOoXjONQZDRjLhySMBJlkZ81aLIQGKPIUSFlgw+S0XmST1hhQXqUANtUSC2xWu/azm1lkZVlmTwierQWaK0YncMJTZQVUmdMJQusKA1ICUZEypUtEEKTZYWUAkNGa8HoA94X3oqpDdJo1ssLppMDpFagyhp3LiFSICZN8q5I4GYFwSFERlctORfZ1hQSOQqUNgidISaST+RYWtVBeA4P5kRR4XHklLBKgbEkaXA+03RHCCLJFQhZRKBEYjabILsabTYGbBlMpchRF7Mw8qb9mwnRlaRR5ELGDz1JUCA9IRPjSKU1UQnQliRKEQChkTmD0igJJgRyLhje0QeET0ghUERqI5g0Ggll3ZAZx5EQIojixBlRWCvJMhQDtJjxLlLVimk3JfgRVOkKqQw6JUa/ZnS5dNdkOXZJpNK/fyFSqawVvHKMAa1abl17H/P2t3jqdsMPf/ez/OB3vBsjZuT8AMKLpNgjREaKRFNL2mc6wvUaf7bCLRJHNy1xELjXHuJMT4fhPT94gK4rhJTYWy1kTRK3yKyQ9TWkHIAIYobmHYwXd5Fuc69nc9JzJqcehEJYiZpU1AcTxOyA5T+/4JtvJMSjBdftBctHnnuLBNMaPbdljkXmwTcfcu+lh7g+IPMuUtqDr1w+mreSnClfVl6f1JE2gYwU36IavxfUbIP+3dTs4THe4ua69+OeDRTFNOIy3NqGPJdwjr3K6V5nYluY2GK4n/SEDHhrpLeL28vMXHHh3X1zVY70SpC6C07TLqDcDywvPyfvPmeb4F75tUi7JGALY9q6CO97VDyxY79Uv58IiUs43H4FvwTy+XLR5jIfMcW9xHa7Jje9xsfOz2Wh4eq9YttBeMuMXoE0bX7ebuNfMt5WchAqRa5AxsRqtDx8bYmeNlRCkXUiqwxSY8JIO52x7EciAVFJUAZ3fsbhccPZRcC5QKMzzVwznUlCdjRVwrWabib4k993ix/7gWeYmQnwBjm8RHj0kLj2RA9jgGWGp54VPLyTSUIQa2gD1FJxzwvGf5r43v/KUs8MeZDkAbIEMa2JX+6J3S2y/X6Uiig+TZQz4vpLVHnEn2ZyDeK6QJhMfAgYwEL77pqnO8Vy3fGy/wif+Iv/F0pkJkcCDiTKCsZaINYwf3/FQaNosqI1hkmjaYXgqblicjThG6cRUDTKFFWT6FmentDYihTBDyPJw2E3RU0OaYcF53lFkhmiI7mBqqkJzFAy4v05ITtEyqz7hGLgoahI3uHGBMLig+NslVHrnvpgTtVo2FQ1p9MalTNjSKRK45JjCIkYItYqhvMlLnqqdooyLSFqnIvUVc3ywlF3lkU/0knBpJO8+sYZw9JRdw1nyyWmL0oWkoxQDcoq6oMJikJaG10iadBqpEmCatLRGImMieihHwaq2pCUZFg6lJS0k5ZuMmF5uiwmYgbcOJKUpjtoObh+DZciel0CKqsV4+i4OF2y6gcmRweYuuawrRj7gTdPlpwlTW0bLKBTQEmJVQarMtV8TvAOoUrV2wXPsPLIJGhrSSDTL9f0PiCNpbWWHDzTumGdYoHsSI3WlmwTq+UaG2EYHE1TUWmNJBP6nio6lgJEinghiVkhQ0ZXFVVMSECqCGnEOfBIWg3ICkEmjI7gPGOCed2U80ymqgzIVDD52qBloutqtEiM/YqcIjGOuBRQlcG7FYQRooNUjLWIAggoUborWcnSOckZP4w05ohKWkSMhHEgZU01uUE3T3STCTpHvA+4oUgddwZU0xYfCSDHSIwRW7WE4FC6Iow9xIhRFaiSUEYXyDGihERVGm01IjjIDqMrSAF0kVEN44hONToZhBRoK9Bth+rmjKOnajLNQUUKAyF4pIwoK1mdLRFCkYVGqoo0DPTnPSFLjMm0dYMSlC5aKOZlKSaCrai6FlVP8CEx9gNKCRKlI6QFDOse7wMmRdy4Io2eoXcoRvAKkSrqScNs0hFx9D6gJei6JMDSWgQJnzxaZlorC/eoVnSzlpMTj9J6Ax8ovilSeGIM3LjWUreTAhfUoOTvb5QkBCilqWxDk2p0nfjgHzjkD7/3FrcPjrBCk7kH6QXS6kVyGDYwqUxWgqZTrC8CSVVkHailJKDpR4hf7nn233sakSdkLyAmEArUFO6fkuvvJKrvQ5ovItQdsmjJ8XMoetJqJE8F0hZoT+o9UlpQivr2MU8fGsLiGb72yg0e9D/P8hff4OnbLfrAELNk1BrpJdfeOeNAae78ixPGC0cOmRzSTqNoq2CaN8mAEMUT4zJ4+1chSgXIG+x0uhJMfrujK266YlNJ3czYXoAF7AIcAcXnY69KLdh0IkW5x+WUdt/DpgK73eZ2f/aC0ydfsShv5HIvM6mtfC5cTYCuBIaPcxDYVKG3CjyPv49cDJHzfnB/+f63Fss3cp15O/d753jDSXmyZ36Tku5xOtiACLdrb+uDIKUkxrjrvIgN2oPyY9nOziRx8/LunIi3nLcrr7NNPPZW8mYp7PwpYCfn9XbvNG8rOXjfzZs8PTvm5OED7ERiIkyvzdF5zXK1JiRBNa0ZnWDRr7g+twxuZLVw+NHhhsCbb1wQ+oGDG4amMyiZENlRt4aX7q555wy+7yMdH35HxUQvIb22C0jUgcQcFckyPWbkOnH/NyNcUwShuBcy6WHiPePA8QcE731KYIYMtSKdRNZf7Dn7guKZv/J+vvlPfhP1ykO+8i9+AfMDP8hH/9e/Rl7+z3zikxd85IakfRpku7EE74EHIG4LMHO++9k/y0t3I//bz/5NHv36L6AaOPiA4qlnFXOl0FkyTIru+Dc/P1DPDDfeNeGpWx1TIxnPBhaPPFmOHOh6o9pSAxZJQCZDIyt8ENSDx41FeSScndAdtginGZJAVIama1m6XAIGPMYI7MYkKuYMa8fJ+SP6tUdEQdc01JUiBEc3tVidqCeWkDWrPrJcrqhMxifF6mKJyImqMtRyQsyBh4sRnTP9+QIvR1yWjD4weoUfM/OZ5amnrjGtK/rVQO9HdKWp0kDUiWwUuqmpreHNb9zFSph1NXXT4nxgcLHAOWSNqieo5Itudi5XjU8W03Q0rSWmJTmAMJpoTDG/Ch4pIkfHB8wnE5xQPHjzLtO6ImZZAj4yVhtkpVmdO5rliFCC1arAtQ6OD3GnPblP2LpAiSJq48mQEeMaSSKITN+P5Fw6ClVr0Vmy9p5gDU3TFvy70ighsMKROsvp/SUKaLsGZRrOh8AQRjrbkFJmdJ5KZxpT4pshFmxm3TQcTifMD2b4DF3d4PsVQyycg9ZKuroGIhmJ1aDNlHEcGdYLoEEAMXuwBik1UiqqSoO2LFcDxtQ0nSImR0ieRtXkfmRYPUIRsNqgjC3yeFXNavWo4PFzBOfxo0NrQ4iB9foRdTUFKUGCVsUIDyR5XIMSaDKNjAgZ6CZz6skcU7eE9YLQrwps0Y2EYY2yhslsjtGKnBPL8wskNc3xEYNdMrrykFcmI40kDx5dW6SxKJvQTSCs1qwfLTGHU8gemTWYmiQM5MCw7rHVgJIC6QNhHBnHgeAz4+jofY+p6kKOtop6AwNKwjD0C1xOxJwI44CRIHzCCkW/7kvimzKttKVzAKzWPSkFpMqEFDFC0sw7+uXAejkSAgUmuIalzEgcVUqlmZkSOQeUEfQLh6kN3WxOlho9jFhrObv/oOyfL34USgq0BO9HpgbmnaWbGHwqSmUni+FtPjJ+L2NTBaNILMoseOfBe3n64DMcdxkt70M+hzxCHpCtRchNwBMKX2R17xy6GZmKs6CZrJY00TF5R8vRTEDvoa5I5/dwL18Q18e0H/kezn77F5FvTnj5Ez/HzZ/8z7jxJ34Uv/6HvPra13lu2qKOm6IwlTN4EIOASQXyWd59/B/y2c9+hk/9P7/Emy99knZqePYDM56/NWEWFVHVeFMTo+IbL55jdc3yYSC5DRk2bZVaBFrKAhPk0rgrhPSWWXqSx75D7NVxGWjuY6SvVvq3/YGr0IrdFnZl/quJ1NYfosRcaZcI5JyK0osoHYoY9wj3+VJSMm3w9E/02AsiyzfbF8UGUrqXIHHZiXm8Kn2pu7/HHdgjG19JILawrsSGbL4lkV8agF1CaPYTjcxWleuKOs8TOLadle2sljxoG8BfDcK3vI1t8rs/tr4UV90q9uRfLzdy+R4pdoT7xxO5fSzRFUO0bwUB+zbjbSUHD+69zpuzFePoaY+uc/zMIcaO5Jg5vjElyEzvlswkDH1GGY3xA60SmLZiNLJUWXUDgHfgRHHvvHsRWAt49obi6blialzBZssahCNLiWoMOWxazJXAtjCbCx7dCzw4Meg2cQ/P3/5i4k/+aU33AYv/5Z70zJrYaV7ONX/9k54bX/gN/ov/9ln+wk+/zh9aOn7k85/lGz/8Bb5SB378l/53fu0v/zTv/1MXzKeQTjPmlkB/WKK6a2T1F/j11z/DJ7/wKzz65QuSFLQfEHQzCUJx76Gkv5A0xxLlYS4UB9c6umlF9ImzpcNkhWo7agS3DucIo+ldZLleY+qatmlwHtCiuOLKjK0sTW7RSmNrgxscfhhYBUWO0KWMqWrstCvuhUkwPeg4dUv6R2tsXVG19QZKMmBzjQ+JXElELNDqphaMSbI4XyB0gU5UVYXRABElNdPQ8OAkYpUgOgcIurqiqaC3CiEiq/OH9CeZoc/olFmMA7efmrJYLVA6k/GcrxxRaWoxoLWmqjTSCCIR158QgkOroo5T1YUEO7hASAoxSgYyppmjcsEIu+USYxXKeqxVuOWSB6uepm145vqMN++9yZg2cJpKE4mM48DFyTkTY+ACzsY1VaVpph2NEZwvl2jTUcmMSokYAv16YFwNTDtDDH0h1CJRuQR+D+/dxzSKTpWEAgQSicmJNGYmTYWatbh1jxhHqrbi4KCmP3V4WaREQwz4CC4Ibl4/YHG6IAiQVYMyNf15j9ceFRxKS3TdFfnOwRNEJJsaWVtkTlTaoGtTCnKqRahArSzSGpKAnAMhj7gkUKqmdyOVKSRWnSUhnJXAB0ddG+p2ghCaxfKU5AZqq/D9ipwCRmvqpkMki64shJExOoSUmNYChjD0BN+z6h3dpEUriZSJyfVjlDkgh0DuV6VL002JwReohTT4YYCmKwZuMRTd7sET5TnkAN6TUiYmzdIlwrjmoGmKZ8JGkSurTDOX1G0iS0s/REJ2VFlgK/BqTk6LglaQtsD2hGC9uo/UlsqA79c450k5YqqKgCJLSBsugZEKbTQpgUqZ1ckpQ854FFJVaG2xOVKpREDiUWQRkVKVa7ibYKtVSZaHQDq5wF4/hnGJsRBiYvQOTy6SvKueVLWMY8Q2FmkMOnqUSjRWk4RAG4qxooukGKiMoppOaeoakXzhSyhNMz14O4+C39PYA43gouO103+Gql7h9jyhxAo2UrAZD0Ih9ARSQiqBKfkrVXtAv+y56GfU3Zo795bEPvK+D84wR1Pi1+8ibmd87vjavYqv/tqKo8/9Ij/053+I//E//8f8xPWO+lN/i/u/9n+yvDHj+Z/6G7z8c3+Wd/zoDLF2pbMyqRA3WoR+P4if4itnP8vv/LPPce+Lj2CiOXqu4qCzJCxfvSMQWtNOFCrCkWi4/2rPqy8+5OT+gqHfrN+YEcUKaRMIl+AppUtIxgbN9LaJgv+/HULs1Jj2g8qtdCZ7X0UWBWIBm07DbhNv4V9sq9mbn2DTCRPbBExs37chhVJc5rdV0y1RGop511b6c+sH8KR3bXZkYR73bdgmCGWCdvTufW5H3qrfcEn6fqwyva+8c3WJChJbFa7tJ4orKjv7sK5LaFJRntoq/Typo5C5JbuGTd50tlK6TMTeck2X499XyHq8w7aFaO2WfN5zqBYFTif33iN2X/Y/YT/pk1c7Et9yv9463lZyIBQoWyGxDBGGsaf1A1Y5lNZkKXf/SyLr9UBMCmkNVmb6GFmsImvn0dLgXSRkTyASRCYnUCHTRxhTJGW3yegVSipyLoSxFDypT3gP0gjM1HJ2kXhwN3D/5Ui/hNuHEtUq+C5FmnZkM2N6X/KD/mVujoKGBX/5f7iF/kdz6s+sMA9f5PpC8NX/5n/iA/9WYnKzQuSAniXUkUI1DYj3kOPf4zN/9yV+5ecXRJERrWD+Ryy6l5zeBaiobtYYCSevX3BcG6RSf9mJIQAAIABJREFU1K1lOqmZqIYPPPsO7j94k0pK/MWKdnbA1DT4eIYfDbprGfozhtHjQiyuuDkz05Fx8KxXa6Ify6IMHiVbmnrGmEYqVTGbTNCyZrUcGZoJkwlMJh1a12ghMTkiM0X+MSdG58g6gyik5OnREavFCZ3MhGFN72OR4dMGpQRH0wYjM4PPDCEjs+TwoOHUZzoDZ2/ewy9GtKqZTyZMp4qQPD5lUoionEkRbF0znXWMq5HYe7IQWGloJ4ZkbDFqUpCFImZIQtAeTLj79VehrrBtS10ZjEz0ccBqzVE7pWkMF+c9w+Dxg+f+6cB82nBx6tFSkYYR7x3GSK5fn6FEwA0LVmvHqlfUPiKNRBKoc8AtR1IShBBJQzHwGnqP0oq6FlS2LvAi70hRcnHac+N4ggRiDEhtsJVGKEkkgFZUTYOWEqUNWSa6g5b14AlZk0j4EFgv1ywXAwlLXRlklIQ+IE3p6miVEN6iw7IQY60qHSgxsHi4YtpNaTtbyNlW4QjgHWmITIUBmfEpIKxEDwOqE4TgC2QnK0SK1LbFaFhejERRFG4EA1KEHU5a5BFjy9pIacCYQlAWomDksygJnBIaayS2lthkQWSEltRth64P0arG9wFjakT2BBfIsTgpGy1pbIWyBqEliYZaRwwbV2+paDpLTpIQBW4caabHhJAIWZKVIidREEadJYwRN46Mo0NKjUoBpQXddMr6dIk2YcNFFijdMZ8dExOgFSt6+tUZw3pEX2+xJpFQaFVhZUSpREgRJyVGRuJokN5RSYmxFRJJ31+gNeQcQcQNREKhpWCxGhmCLJwZY2iqGmkEUmecdwQkQcqiTBYCqu5I0dHOpoSc0UKhqwatAlHaDXxKIozEK4vLFVPb4FKktdBOO5KZsxw89x+9trvf/7k/9+9Q1/XuibPVnleyKM9cRgh55+RZCOZXK5FCgFYSIcEYSTvRzI418+sjH/pww+wj12m0RsuEYKPaIzrIRVI0pTU5BFLeODzXByz7nuF0ycXJSC0zk6bIxYqna+ieQeanuFbd4Tv0msN3/utodYf/4L/+GNPPHqG/8Ruki69Tx8jJP/nveOqj70PadTFlUgJRdwh9HfgQ5P+bv/8L/5zfeeEEZ6E5NDz1oZv84OxP8PWXv8rTT0+RCty4ZHm64Lmb7+EnPvZvYn+yhaT2itzbIGC/qsrePF0Gp7/ymV/hR/7Yx4oc5AankXPaVSFLMLJH7M2wrQ5/q+3tnt9iX8byspq7fW1Xfd8nPlICkW1VeBv4CyE2GOktXKTswzvf+U4++YlPPBbV75bJtwkuxJU/3c3Nt3jtW43HsfCPK8LsPn6/7P3Ye/q+5+Mf//iV/WEX2F5ub1dZz6k44l4pfIu3/rN/Krab3UuEdhCgPS7GPjfjcltid072X9+Ov/N3fo6qrn6X+Xr8JHyrmd4d8u7jH08Cfrdx1ezuLb/9NvtTxs/8zF/nzp27j0FixO4a2HYdtvuzlcq9Uvne7HTaSKTuk9p3+7Zd/3vJzlYtKW+y08s1vXff2yaSe2pNW6jQj/34j5c1vz9Z23Xzuxz1v2xGHm8AXL529fxtc9r9V3ff7y2h3TseOz2f+tSn+Et/6ae/xd5cjrfHOfACISvqThGNoh96ejIjkVaLorONIGvF8bwiCVECHh9BZmTOTGYNddIkN+JjwMWEjxEvIroVLE8iX7kzoBVMK4MWCUSRl0tIsqjKUUsHWhAQnC8zfpF47euRO9/MzA8182sNwkTkDc0bv+ZwZ0ukOuJ7/vTHmPzypzHO8d7vfp6++wFW1Qmrv/0iZzHz7PP3mD9X5E2zK86LaM3wgkfffp2oBw6nS67fFJz0EnUkmB5L6pWgvn5M/zCzfuBIHubvmjKZVcSYGdAEWRVyatdwLXScvn7GtJpAVAipaKqGCy+IKSCyhzQiU0KhUEKzOO9hSCipGcdMDB5bSTAakxxkSCHg3UASmRgztRHUMqKFoKssTWVRRBZnCxanJwTRUdVTcogIaVC6JouMURKRIPsNfppCiNSVoZaJoV+SgyOOgSFDOzUoWxGS22AVI25Yl8p1pXd27D56vEvEAG0358btW/Sn5wxDYDWWY7BNjUuRjCKluDmecgeOw5rpvGXtAkZkRIbBl8+aHh2gpMD7otcsUiaPDm8rhtQwElisPLWK1Eoym05Kazn0nK48wmqEUkQpEEqjbKm0DstVIVApiVGJGAM+KbQyG0dcQYqR6BOqahAhMY6ClAJZFrnUoFuMUfTLBSHlIrFqDFkpKimIIWxuhrpc4ErRtAonC6Zcbo4ruHJtJCFAFbOvkCWNrlHG4mIEYwm+J/hATgmtwBqBriymqYiuR8ly89LSgJBIIwkxUFmD2pCj8ua8hxyomposS4XICFHkNL0DkTCNQStNyokxjqRQcKQhK6SyEDMxDPjsUTnSViCzKTKnSHzKiBzJ4xqtbVElSZSkoK4QuoacsKZCKo0PDj+O5S6oFcqCiBKpalKSpGEsCj22wo+umLsJBSIRo0dowfoikhWYukFpVVrhuVTVgs+lI2U2AUHQtNMDxmEkZooow3SCsgqtFaREjmFD7FVoKbFKYZQh+hXaGhAF/y6VIMtEJBO8oLYCKQyITPAS5wMp9GRRvC6UFGQp6EdHrTXOe2LMxCSImwqV94GoMuNySYqpEMLtBi7WGtYXK/wYELFUslRVEfNIdp7zhw8QucNMGmRKiHQJu/jSl750BWpxKYl4+Uy4DJweq4CJy++FAK0L10gb+f+S92axumTned6z5qr6hz2dqfv0wJlskU1RJEVbYmRAcGIJkuEkiK7iAAlyFSRAgMDIZRIguciNfZEgQBAIBmLEgIAgzoUBwRosyVZk2JZkaiJFMmQ32WSf7j7THv6pqtaYi1X/Hk63pBZgGGpmXfTpXX9V7dqr/qr1ft/3fu/LfGm4da/luXXHwfKA737c0DqJlgohE2JSDcpYEMt6buEBSS6ScQyUMfLm6zt2W8n95+bY5ghkQs7nnP7hE5RTtMvnef7zH6HdPEGmgRc/+SN4+xm8f0T4w28y+szybk9z3JHzAMIilKYUQz69QC7+X7IM3L8FR3cd/Twzu2c5nEtG+SZ3XrqFX0nSkNB2jrvXcXL8AvfvfYiTgzsYVaVw63RcX5X/dLj7L//lv+D3fu8rN8D/laY/76Z55PeEBjeA/h4c7UHNddTwbiWa6Zj9vd9n2yeUJacU814rfQ/SKnVF8sUvfOFP/fv+oo6Liwv+1Ve+cgUSp+0352cyVZsC4utZ8f09ucwU1zTy1ecTbYRLYLl/TvYgttwIEq4H3+zPeXkd4l0/v/rqqyyXy3/t8/JvYrz14C3+4Pd//7K6UXn55XJd2c+fUjVRmlO+Vl26mp+9mtyzwZ1gopBN++z3l0JcPg8ppSkbL2/M7w0q2rVnee92/HM/93N84Ytf/Dc0U/96xxtvfO/P3Od9BQelGAQGqQRoMFpTUiIkwTAWbEmIkklK0jhDzKAY8almGSWFtqmmT+ePBpCVg1mEJMXITEHYZv74qwM2Fu50mRcOClImKKkqmWSJLAqhNELAbgfffhJ5/DizGQQbIRG56rCjq9HT6lsjw+PMyWee4+Wf+TLlm/8UdfQcqv0i7tUXePzGmm/+fcDA7S87tPH4sZDDVdJneBoQ5gF+1vLpzzR86UzyoN8SSiG+ngkjzO4JdErgR8IAi5MF3Yc64pNAlJKQMuTKH583DTvncG0HaEpWGDdHjANKCAQZq0DnUvstsmTrIzpLfNT0Q83CFyKZgEsepRtyzPRhRykjCUvJBa2r1KOiVMqIVOxUou+3iB2ULBiwCGVxrSIjMNrQDwNSKZwQ6AJRgDUWH0dCDJTo0aIgjCKmhNKR0Q9IVZAqM/YB4w3d4jZSRTqzw+dCiBlRBPOZpps3uAJnpxeMIdbGPSlprWZIghAhxZEiZG1UzYHj2wtmPqKlwmdJ8qCkQNkKNn3wFQwqRQlVFWvdN/iQGXxGyETbaeZdQ46RYbUlkTGNxbgKQHOW2FajYqLkiBASIw3GSTKCjRfVZKqoCtZCwodEsoamnTOMgZwSUkYUkLRGd44QMlnKKp0qa2ZRpsyuD4RYJqOvGpQKbRilQGaF9wHvPZTIvJG4+eQtACQ1GaaUQkgFkBhj0BJEjjVzLMEYQ+MsQRbE9PKlFHIIqG5JigmjbbVaoJCpDqNagHVVdayqTGRUBiUjUguMsZRSK3oFT+WSZlLKCFmpISkkYuppbId1ipw0UkGOmRQ8yYyUIjFGEtKIkhJlTM0UG4XIBuUsIChjIY8BRA2ulLPIIBDSVlqPiRgsWiv8ICgpI5REK0lW9dUeg8DNGtpFh5KSHANCSNIYUVojJ/UeKEjy5K+QGTdbSipYazGmynJmH0i+0qqMsWhZdeut1uxyVZMqRdUgRRZSqgZ43iecNZP5U0KSCX4gDiNaCYqs818DB8/QJ1JOIAV1bwUkfIoIpRg32wrAnUUJhRQKJs5+TJHsR6q4mcaPkTgG+n5FP26xrQFjpubY/fv+JjC6vp2JujAl2bie37phcCX2QcVkRJULwWf6bWBz4XnwvTXfev0JtzpFc6thZguICCVQioNiEKIBqSgZfCg82u7YrgND0mwz7LJBCI2QGYzlG7/zXZ7/kOLkY5+lO/kI4rf/D4T7GEK/gvpYx+q3FRdJYjvJ7GMnwIqSEqSqGEfJpH4L6lske8KP/vDzvB01/RsrhBAMD7Z8O/weB0cfJw2CPIBWDbdv3+Pecy9dSm5Wesf7zX1fG+LaPMIVCN1ndHk22Li8M+/KCz9rVLX/7EYxY19F2Ad+z1AN9gZX+/fFzQzmVfVhv+8PxCjlOgvqKkW7r75w/XtfLo+53Hfafx8YXJ33Xb/m2vFTA+sN0L//He95idM+f87v11/AcVmRua7uczmtN6sGNwOja5KholJ4L6U/68E3KgX7cfl93VcXrgXi1xWtLoO66xSpa8/RD8DU/5njfQUHxlbush8GCpLlvKPvI0RDP0R2G4+lUBpJsLmWsgFJzZSlXMj9ULlURtJ2CtcURJbsNpmF8IzAw68G/uA8caAS81cth22mqnF44iSUUhCsx8LpWeYPVop+kzj4mCIt4bu/7QkXPe09i8iF2X0wtwztpxxtl4k/Nke/8nnE7GeRq1/i0fbX+F0t+Juf0rhlgZJgU0h9IRZQIhJvK9bngpgLr3zkhFWUfOPNR3znqyse/7onrqCE7zF70dDeNeRV4WJ3zvyuwS6aCpjDgFYFKyQ+G156+R7BK2LQFKFRUmGFZ6Ydg9TMjKIQ8ONIjJ6DwyWtanjtO+eEIaBEZjdGyIHcFpwVyCiJvkoFFgNDsJjFEcJHUgzEsQIw12i6yTRs2OyqwpFuSVmAsMyXDf2qp3MG12pijKzP12jZsBqqnGzTOJauKqnshohPO0a/peQBIQJKR6zJ3L5zzGa34khaxqIYA6RRsuwatv05HY6cEtoqjDGkmLl76xbvnJ5SlCKkCWgrODroGMjcvnubYTuwHTzSamjnZFElSjWGLKtqUMgFHxJiG4i7EWcskkxOHotnZuFsFzCiOv22rUMoy8Xpmu5ghtOR4FyVGJUKrSWIwtkQydsBTaaxikxhRBBD5HA2Z+1DfXkAMUVMCmglUaZm+JXRFFFIPhL8lmEb8EVUPXVdg+vVKBHWILyv/P0wYLTAHsxwjUDmQNfNSEJCrgpBsu0QKWPalsZISIEYM0pkUkoMPuG9wCmNEgERB9KwI88casrSaKnQyoIAVQqN0fWZzdSUfhrJIqJloHEzlBKM3gNDbaSeGZIfCWFEoKeXe0SSsG5JihUsxjAgUkYXi8wB0y4JyZNSpGsXIAT9doVtE84sSSkTYyDGiBAGpEMWjdaOrBQ5JmRJtbTe2skLxBN3tdqirEPLBrygcYJucYCdtYiSIQSMM5w+3tI0HaoIlAyIUshaEX0gJcnuYlezRzKRy4gvHjluEUnQzBtsNwMB426DUZmsFCGE2rCnauVlHCLeJ4Z+xFlTKw8xIFNApQ3jmHBOE2IAIWufkSnsNht0q9HGUkSVh84UhKJ6UaSIaw3WWpRSxADjblWzbTkQ+6HKMhdHCDD6RJaGR6drUgyYxuGVufHOL8+gm+t8ZCVvLpr7cQUwr+gzKWWEUNXZfUyszz2tge8Gz+II7rQSJw547qTB6Uw140tUNksmZcEYE8MYeXN0hHHHvU8d0n9jzcXZmhwMzOZQMl9fBZbLOfeOO3TS8MpLyFs/BuoLiN0v8I7/HtuZ5dWPdCiXoQQYMzVxGOq9bVt8r8l4PnL/s3z2Ysl2+wYP3jjnzX91jj8XlHDK3VdOcNYyk0ec6PvMnztk489Z5kN0Me9Ry38faGJCnkpKYpyC7OscFCEuqwUVh+7vwdUJLqlCkxJMvkYlukkd2v8jrkDUzVt+875O2e5938TNKsQPAFKaqEaX2vB14yWlh/22ApdzcQ1Q7gMDsQ8urnOOhLg6djrmeuhYeC8Quldg2svdTvcvF8rUw6KUvEEf+SCOPWVRMDkNw6XZJdT5SKnOidbm8hjYBxbTHIhrTeYT53//HEgp6/tr/0unSculUopqAHy9QlqbgytXv27PuVxzF55W+B/wCOF9BQf9cMG2d0ghOZ51zFuN7wtjFmjTkGRh23tU0XRYVqsVY0ogCikEzi9GlieWsMkIIxAlYJE0jWF33pOFYD3UReeP/lngra8Gxv/Q8Ve+2OJ0rUjEDE/WkW8+DPzeg8SPHktOjiyvvOJ4/FrgwUXk1X9L0N0BwQhO8uJPa/p3PLvvfJWzb3yNu3/zr5HzCpXfZPP6dzl6/Ii/8ZOGj/+du2Q/Unz1W4hZEsdC6QRFKeSh4fadV9D2kJ/6wj0+97klP//6P+Qf/m8POftVT9wWVl+PXHyz6o1rI3j4x9/n1icsL31iib27YCvgwTuvce/+i6zX5yzmd7HC1OxmTCzuLnny6CHP33qB9fqcPvZI5yhh5NZsjhSG5+9Ezk4Tu91IQhB9Yn3Rk8bCrJ3Rzg+rWVIMLGYabcDkwDjmmlkWBntwn1fuNqwuVqwvdtUBWTsKgtyviXpJYxxFFXY5M4yBi03P04sHLE9mHC0tynQo26Fk4uHjC3abgJHTS845jJ1TzIz1uMLvNjhnq0Sr0ARfkDtPHwdy3uJ3a3ANpp0z1xKbEwemkHyhz4LQR+KwIzeOvIu4LpFkwXQWWRxhHHBCsl5fIBFIWxVohhJRpkGEgDZ28lMAnz2np+dYq2hnxyysQDuHsRo/es6enOK3VXmHEVIBWwTLRlOKIO2eQikMMpKixjSWw9tHqNJwfrEhkdDGoIzBdZbj508470cgo+I4LSiScdiw2gaslGghSSUzjIXdkIjZs9ACnzNd13JrtkS72rQdpcXqwnJxMC3SmVwg5YgsVf42hArqpRQ01jH0AT9smHULpJFYLZFWYhqFyFukm9V+h6IpyCovGwPYDq2YKCcFjMSYAJnqAB16WitQ7RI1NfAmMUfGAAKSyDirmHULRt9jNJRxLzigEcrU6hYRKQrSKEoeSRFEKvjtFtlIyqYg2w7dLtCNJI0ekSNSzJFKEX0ijFURybUS21VKH7Ya6qEMWlvi0y0lZ/IQwQZKLqRdBdbOKrIfMG2BDDFMwCol2s5xfPuQYbdidbHm4mLNED2GzN27t1geHjMGWK/W7DYblu0MiSalakaXoiSXStfS1nIoDbv1ls4KGg1FCpr5beYHnnfeOUOLhHMKaQRj8syPF4zbEWLBOoUGQihkDEZkFvfvk/2mVvOEZBcSfgBtBTGBMA0pZcZN7YmYO0Gi4/5zh2zHgfOLHRdvrS7f90JcVQHgCi9WDCnJBcReOnECpEJymd6+BFaiLro5J0pR9fmJmd02st0F7r7V8lu//Bbrh2s+/8UT7t9ZoFUkC03KhdWw5e31lrM+8ELrWM6WvPjcHd7+3hmfei5wPFfoFgRrUJr/9L96mbDaEJ/8BiH9EN0X/xYl/zpCnTE+/Bov3DpD/ew9Dv7qJyBuKIB0ulYBKAitQLSIdsZs/mWEmPNTn/0Sr37qlN9+9M/4zX/+Gg9+eUXaJr7zW48QRtO0F3xv9oRf/ae/yic+e4//7Gf+O5qj9vqEcTWL7wNMTABca1lpmhPQYT+9U+r/euOnEJNvwPXzTBSW/Awd7F2eAoBS8jIzfnX81EciJknRa8FITrUh+CpT/sEfex75VRC0x/J7szZ4dt72oHTfBlxKIZXabCuu7QdXwPN6j8SeYnQZ6N3IdO/332+fKnrTNVxWdD7gYw+8rwtG7b93SioymZQTKZeaSBESpRRKySkYEIQQ6nFK1mNyJuWMnIKINLkJV1rY1VOopKRMtOf9Pbip+FSrd2lPWbr+wf8PxvsKDoaLLdJHlscLlFScPXyKFp716gKPQTYNbqZZDx7le7IcsSLXRUYLxNJUDddWUVRh3s2oRr2BrnOMu8StA8fZvUIUhfV55uf/3sj//gsjP/Uzii98VJKc4imwcYovfdrwmZlktU4sPWRXWM0zw5mo1YUMQmX0LJH/KPLa3838Yi/4Lz/3jzj+sGXzzm+waxsWf33BfTUS3jmF4zkRQU6F8E4irArqRyyboJgdv8Q//gff4iOfe4GPvvoqLzX/Pv/tZ/4T/ou//X/x+tu/wu/+wVMenXo2p56nX9vx5LuJ17YZHkc284H27pxXXl6wsHPSxdvMpcOlHUo5itREaxl9YumgDOdYAbpdoFyD1Ibt+VNSKSyXc6yybLcDmzGC7ljqRCqGTR8Y/Y7GFaRxJCU5Upat10iR0Lpq5V88Oec0C0pINI3DOoe2BiEl53mgsYXD42P6MDKEkVwqVznuRo4ObhHHDTFLUh/YbDb49Ybt0wvMsiFLCShkkXgfGHePsKpwdNiSc0aqhBXwdDviNiCO5simUHIkb9Z40/L4fEPnBHNjsQcaDiRKS8bkKccdMvbMpaYfBrbjAEIitWWx6PBjRmiJExpEg9OOi+1AaxXbTY/IkUYLrHZIH7i7mLMNlWuepUQbx8nJgn6XCb0nZk3jLE1rUCqyevgQZwVxjLTtvPYDjAG9G7CNpjGGxhyDyBgtmbeuNr8OQFJoXYPlXKBtHKdDpu8ThzNDoeDHkeB7jDEsRKEsDM3xLVSjkMJT0sBmsyUPO3Yx4Q6WiHaOkA0dkTBucNrSWls56bmwjYLo18wah2k12rUUCSEPQK5Oz0qCqP0hSkmUtmitQSp83NG6DkGuzYmiodMNIIlF40xVvCoUQohYsaOZH+DHM2LygCUGD2hK0UhVyFKgtMZqgxAeQUaaDmcsJUnCGMgl0jRLjBQgM65tKbrSs6TUKBJCCcrewbtpELpy10sC51pKqbSmlAoyJpQVLI5bhNaUWJvW+20glID0CdMq0jjJbSqByopxu6XEyG7oST4hpUU7R9qccvzy88i2ISSICRKaVFq2a0/bJmKp2tbD6AmxILUkbEcCGSM07axDaxg2W0qRCK25fe8AVDUVisFThgh+xBiBazoyofJyE5wPG04+/AKiRFIS+BxIJdaG5Zzx24DqJvWsXLPjUlmktUTfc3rak0qs5pBcrc4x5MsFGq5A6bOKj9dL7bVB8xpYuYEb90ECeF84v4i0jeLROyMnP7zg9UeB7/7yW3Sd4Is/0vHh245BODZITLvgwwvNLWMYxhEXEvPGE1UiJjUhtEqJkm5H/J1z3vh6x+lyx+cPf5/msOBX/4g4m7P4Ky9jRE/ZPaC44xqwpEh+uoHGUY5bQm7R7tP88W//Jh969S8zW3yWF5sf4/mXfoqffv6rnP613+Lb339CHzzDWWL3GLZnhrdGySdmn+bJ6UMWzSGL2SHvOyC4nKZJq3+aUykERV6p7kyTvp/ea+efstTPYkVxZXT1XkD1va/h+r9XPO3rXO79OZ7lvn+gxz6oFTc3XKrsyGuErkuK1dUBV1/19yZ+7eVWnw3ALqksz1KF9p/tfR9unP/avfiAz7uY+jhqu8AU8E4Z/TwFRVppCgUl1fUjSSnfrHpRqwb52e/3tE+59v/7oaUikaeqgJiqDFfBwJ5SVx+HD/Zc/3nH+woOZq7DaUtO9WXUNA2lZE6O5qzHSJaJxkqUUGxOB7bDFlLNftm5puk0fhgwwPGBRTtNSFW9yEnJOAr6kLmz1Ny9rTENBDJfe93zO9/KPHoamb9cuPeC5sMnmlutYhRzNsMZr387oGxmfl9hbhe+8isjn/9phV5Uo6r5v6P47McEt34j8U/+TuDf/V+XNK+8Qto8JG/fQvpEGmD77TM2JSMfZYwB3wi+/+uB7i589eQdPvmlhkdPLvg/f/GX2LTf4Mtf+PdYzH+Il08OePHHT4EeUQbScEHyb/PaO2+x+sYZj4KkOc4c2ZGTZSaJBYez24RcGxpzkYzRILXl8cXb2EOLNm01XUJgMeyCrA3SyjEKjxKJIyeYHzSMu8AQIOSElzVi1mOPMS1vrU4JGayaIbIkxcB8PqPf9ShgGAcoAZENKIsfRpqZJYtAobr0lnHEIGgOGnbjBkrGGY2VEpctY2+w62oWlYrEGse807iuwQ8DfgzsxoQtI2XIxCGipaVpJd41nF30lGGg0RmhR8YRNiXSHsynplRVswgi8/jpKWK2hEZULvU4kGLEK8nxnTtQEsoZnJCYIeKHSHewxKREqyJOCBZWs1jOakbINvhtba7NJeB3PSkJSpYYIaoLryyEkiAWirRkMdB0GqV15ccrxcwZfBIoIQg+VpWeIumB7CFqR0mQxpEsFMI2KKmYtYLRr+n7ST5WGxZNy/JwRrugOgOomsLyITNuh5rS1o5oFFoIZClImWm0oTMHDCGSZXXgVSFBrrKnwljCOECKVEJlputqhcMYTcoQ0wgZrGgRCmIZESJRcl/dLolIBdoYgr+gtZrCyBg8KWWULIQQcE2LVAJuCg9PAAAgAElEQVSpLRSHEoWct+SsaLs5fgyUUoMkLSRaWoRpyBlyiOQs0GaBmy1hHCmK6jItFFpblDbE3kNI5MGDqK7J0miUtmThwNQGbyl6ZL8jjwPZe9puSZEFP8Yq7ekk7XLGeLpCag1FIm2LkJC2A2HoSUNAyioJKo3AzSxd6lifXmAORHVpBkQKiOLZpcBqFetCpC1m3qJTwq82HN9a0m9HtBRoAaIkpI7EnAm+IJy6dFCujduFxawFAcNqxTAMZAnaGQ5aV4UIJtpSoWKJMCRUhnE70IiGpCFRexlKKSSpECpVp+0oMEJxtGwu3/c31kBxM0F8neawz27ut5fCpf52rRxMe5WJlpTytPjXZsAn74x8Iwt+5EvHvPyJJU+3PX/4hme1Sdg7hTvLlsPG0qhq9jjG7/HowQo3U7S3W0SIPHr9CXc+0iKbWrlqf3LBh19JnHz7KW/8Yscn/uMPoe/8KLn/F8i0hhyrMeSTx3hAngVUJxm2hf5iQM3honudlz5xh4eP3qacfxs3l7TdDGde5ng254sfXSOEp+SBHDekdM66B//4Tbr2FaToydkhECjVXk3kVQ3gvRfawmWfwfVxxU4RoGowcKk8dD2pXa6OuAKi7/27LrPf77qGcq0CdK2p9tqF3DDOeiZI+IEY5fIvvxzv+hsn4Cqe2QTv9k24BKXXKXhw1cgsbgZ3N03x9h9MPgLXg0PxJ/lKfHCGnAQhUsmVArQPoqbmYmMMWutL80CjDaP3VTFqmiNrzNRUXF9CslRz3JILUklijADvAvjPii5cBQX7asbUB/HMcfv7816eBT9I430FB+2sw1lHDImSFK5pOF1vkcUhMygNbWcZz7YkBAdHLbGftNitopQ0cYQFzjVsdyN9CCijME7jtWEhA1aC6wR6LvA681MvLtmGLc2h4mgJt+dwaAv9znPx9IJxnehd4daR5XghGHcDcRR84xcin/yPLGaukYtC9wl46ail+0sz5DIw9N9h+1sr8uOR/EnB8BCajxn4yoi7JeFQoBy8sKzF2vBHW7afsQjnePGWpZQLXv/1v8/pfMbnXj6kbQJF7DAqc9jNccsZn+meZ1zA6aMeXyStsxzNDyhqiSiZYbfCugOcXVKyZ7N6jFa1aXHwO4Q0WOMIY8+43dK01dG4zGYoqUixYJSlGM2TtWfMGSsLBkGJAvD0vcC42iypkCSZETkyIuhcQ/I9IWVkLBA9WmT67UjbtJUmpAVRSdrGYlqLawS5REoeKSnTaE2UmfmtBv8kUYpF6IZiDFZb3KLl4uwx2+2IUB1GSRABoy1NY/GiYIQn5YEyxuqfoBXrPiGayqUWyqCVQZXAsM5YIrFfIQ00jWXoE2HYkoYdYayeE1BIvWcceqw+ZHmwZKSg/EhjDG03I1nB00cXjF6QSyBmT4iRmTWE7Y4QMwEBsZCypOsUMmX8LiM7yxDBaIESsNuNoGBzcUEIBSS4xqJpGIdMsgKDBi+qa6/fMfYS3Ti0bhAoGtfWsmfOdLpgpSEQGeIAYs/9z6yebDm63bHegMfTYJlJg5KVj9k0LbGUKmMqCzpXUNtawxg8BbBaY4xDa0EREqkcSXgoYjINkgipUWUEZSgEIJKJ5BQYpjKwUUyN1AXJSBi3GD0jxx1CaaxqkLJBCYkYa3NtTH56iWdyjlUlq3hKjpSkgVoaRlRn37BZIZRDmYwokQKoViGRICLC6CpSoDQIhVAWJSw5JoQuKKshN5QiMI1GGQNWIYxCSkhjAB9J256iq85+Vg1CaKS2tMeHDP0O4kBMuQICpXDtjO15z7C+QOqa7Y1DT9jtSCiCUrRKElIkTaBviBnd75gdzEh9VeEBkNLQWJCukKQkx0JOCZFBm4ZhDJi2RSiDc5EkMkWA0Yrt2RppNNZCVcjRaJVIqQcj0UZSRIEiEEZjde1V2O48IQac0bRW4W8sdDedN7lOfeA6nYhLHnvJEx2AK1iTU7lBf6iBhcCHmu0XArT0fP0PVwyD4COfOOH0wRmHn76PzImlsrQyE/yGsV+RfCA6wWF3iJQDxa+Ja3jyu+fc/vJzCNEgu0jzgkMdHtB+4rAqePmv4H/vDdQiIxeKNBTUyTHiOw/Qt1qKE9WjAlmrmG8+pn/5oxg7w5hz4vorPHprxeDmvHTyHEJuKOwwylafFtHSNhAMlPI2unwYwQlCCFJaI+XifSUdb7rOTlnMCVTuQfp+5MkFeK98k/O1Bk2u49CpPXpPaeFqnz8py32dvrLvI9nf2cJVFnz64Qcmo1qg9gE9Qx+Cq/m8ZGU9g92vVwXS/l7sCXbXqgJKSG7cSLh8tjLXA8NpxkX1bJjisGvP0kT3end49wEbk9oVk1IQE91q+vuUVFhjKaWgVP2+p1z76Ko6EZd9BSmly2OVUqDqc7JXmboKqp+per4rwL16i+3vTQ1YyqW0aUF88Kf+zxjvKzhQ2mJdQ4mBi03C7iKidex2AyEnGqFQRSJipGskhwvDYBRIkKZmPW1jmM0kjbGMMiCyoGTBbNGyTAK53SFVomklygkykVsHgv6pYJeg7Qun68zDs8gbb3tOVOH2keRgLmlnojrMnhae9PDgm4Xya4mXPg+LOyBdg/vQ8zx//5x3/rjn6dd2lD+ONBK4W7+U5t4tlh89R6qRUAq6CBb3DWMwvMBP8KZ7m5kZ6WJkt97giucIz3C+xeOR1mM15NMNt583zFzH/LZjpqEfWpIxWN2SKfTDgCgCKU0tI6fq3jtfdnhPlaIUkIvCaIlt52Q1w5gOY2YYE+h7XwFJGpFKIUomp0gaB6ywhCHQ2hlN62htrUJEKfFjRLgOYwtisusqQCoZbSzKOuwELEtMGKk46AzBWrQMSCnoB0+KmbbtkPMOWWAnBOsdxCxBa5quxUiD95uqc64tTgtmC3Btg08SmQNHjSREifeQtWTWOsbsEUISfKzNmRhmjWXuNMZowrhF6ionmbRAWMNu8Oy2ET0GShF47ykCdEnVY8EZpCwkYAhxAoeacewnt+7aIG8bybxTXPQSY6YMrsgkH8lJ0DQdxuqpHAqxQI6JRo5olYijR0mDVQKpFes+oJRAao0UlpJHvPdsY+Kwyxit60vQ2CpVGkaiD4wxEEtgkCNojdYKrRRS7a87IFRAKc8oFH0sGFPQpiGOAV8iUiqkMViraZzEWgeIei6t6j0WclpkRHV0lvVFmKiKYlK1yDIAHjE58+biUTIhtMEIU3mZMpBiRAhPKlWaVev6u6TQKAFSwThOmckbxiyCkgIpliqHWhRGC0rwJB+RxhJ9RupqGEau589kpNWIybIeFEIYhNZ1wU6BEqfmPWsRut6HxFW5mFwo44DWhTBsUa5BRHnZJKedoYySIg0pe0YfGWKttmmbyaVn3G3RqhrZDXHLEDXCNjUzqNyUOc/1d8eA1ZLNMDCsd0ijaGcaKSVG+KpqFQLVQStTUqhKQ8pUkzNRXamLVCjrCNuhBjiTp4WQNTngUwIta7O+KOjJh6BWTUZiCWAM2hm0qr0Al2O/IO4RyTMZ4/1O19fTcj29vA8o9iebAolSBKUIcoFxmIx+ZCR9f4f3QNIIE9gFwYzC6qznyTiw3W1ZmsJi5pg1ZnLBTvhdYjMKeOgRXz/n8EMztBMId4hpXkAfnrN9/Bbb7z5APdlgpEM6UwPI2cu4WwHhdsQMxlpk15HiDFU+x7noaRtByTtSllgZECIR+ofkvEaaSEZTlKXtDEZazEyQxicoVT00KhiJPMPV+RPHdWB/yYGe+guu3weuAZ2adN4Hb9fPts9uXruHN0D/MyKrU2Lisia0B0z7DLmc6EvX6BZ/XsfVv9DjelT7HuNS0ak8s+PNR+Laz1dNx1da/fLyfbc/9AYTbx9oc9PM7Hrg8a7L/qAHZoXLdUBIgURArjSuPejff1e11kghiZPE6N57wJgqxtD3/Q350X2zc31W8mVQd+WfUK6VROtz9Czlbl8NuhzPxhA/wON9BQcpF4TUaCvZnXsuViue/+gBFzkSckJ46NcDhsxsbtBFUDQIVRAyk1AsZprOwhgLSlR5wVAErms5NpItGa0zrgWhCyHC9mLgwXcCF7HQ6QzrxMVbibPzzL/9lwxHL0pkK1jFxHqTKRvYFok/yPzj/zvw2aeJFz8uWBxZlvc1b37jKRd/NLJ6rbBYCPQ9QZKC5V2JXM5Y/lhi/E4mvuMhSuKswzY/Qn7py5Q3fo1heMCu37LZKha3jvjQ8QlPz59AGLAZpM7sNo9Jx8eIWYvVAnO8xI0L+rCkFEuKPTFkhJpTUPhQwaJtZkiZGJ5GSomEDEkInOtoD1p2o0aqZjKFS4TUk4YtPgS6zmKixI+B0G8xOhBzYX7QVdnISZtVlExMCeE0RiWkMZATqWRCzjjXMl/MsBKCECAUSupq3oSiDGEq4QEIGqtZnhzTD4IjaYl5x24ApMQ0BpkE89m8lqdjpuRCN2vp5o43H+9wDMxlITjFThpEN2fezLgYnzLmStcIYyDmhHMzjg8dorHsxAiyPtxaS8zskN0m4IeBIBK5QCyZtutwujD0O5S1YC0+BMKux8rqKDuMZzSNqTK5GaRRNPOGDdB1rur6+5HhYgXKspi1SFWrBplCKhKlClomnDOIGGlbh1u0JKWJudAgq2eyrNr+3kfGmOlzj1h0VaIyF5QCZGYYE5thRIhMLJkiJM2soT2ZszzoaF3LWARWSmROxHFgE0baBI2G4EdiqH4BzbzDNQ4pAvNZRyrTC1AAopp47cujSmm0FEhR8MljjMKaDiU0pezIKVXKkgCtVJX+lKVyWYTGZEua+guoAqgoUb08pJ3M10KkZIEQNchBarRsCT6TfW1G3vc/iKgQaEqSpFgbzqRUlCSQQlGyQRg3gXymqpFEKo0QgrhL5FCqnK9RCGOQAoL3pCGSQwEkImfMXDP2vmLbnBElIESGib4WUaRcvQW89yilcbMWEQspxlrJkIViYAyBVhi2PtPYpgKEnHC2mq6V4Ok3GzabAWktWS6JQaDkwBBSNTgTCokg+QEtLUZKilGAoqRaOXDO0Y+ZONaqj5rK4KlkUswkCyEljK1VklwiIWfCODD6EWF0VVMi14rXs2MCMoJaedi7oV4HlkKKPV7kEvRMwFEq8a7tpYAoghDrAi1lJuVISltCiNy+b/ne62fcWmbeWg1s17U35tMvz2iPDBjJzu/IQ22+HzGk1vIH/88TPt73zJeW5uAW0nnWb71GOD9l+H6hO1HImUJO0sKiOcB+5CXi49cQ20DBku1dZPdD5MMvU05/kzGfEWIPYkG7vM2JO2Kz/S4yDnWu45YoBmhug8woKZDOozQ1YBUSpWY35uBPG3vOc+VSP8tEuTm3+7HHN0rJS3WjK1BUx7NVhfc6V8W9YgJr0/UDpeRL8zOYAK0UyMxEa/lT+hc+UKNWQPeUqv22qx/qM3D9Nr4bl1e1o5sOweWyslCDNXEZfD/TQs4+vi77qGGq2FzNb7m8qus/f5DHs8FqzfoLEBKtFUoppJh61C4rCOryGK01bdvSdV2tNIcwKTpdqXallK95gtQhmGi7l99/QSZf0vouXafLPrEx9Z0Iee2h/MGODt5XcDBudgybHj1z3Dq2vLPq6TcaZwU5azbrkc3ZmhdfWNLNLN///hlSJpwuCFkIWaAOGjabDU/Hnkyu5mhO4bMgC8vR3QWGiEq+glltCNtMs1M8+NbI984y223BSMUXfsjx6k9aPnZH8fBtz+uveYaQ+dHPao4OHK+dDPyP/9zzu38382EHH315xef/+u/z9/524W/8FcXdv2pRH2qRCPQjjwmFcP4O9mSGuWMZFWxGxS6e8KHZf8PvvP7fM3z9Nb56OpJbzcduK955cEpMhU0ufGjpaJwEGVm2FbjI3KP0DOluI9s7CH/IuhcUDLqBcYgMfVUd8rmWtGMSZJUrpaVU6a4iHD5XK+2UCmM/MPpQO+jjiNSSmQNtZ2w3A6vTFf3qjO7oiDCs2W53jENCZUFrDaKz+O1jxHxBPwyklCdVC2g6ixCFsb8gUq+1GMujR0+hnTNsPDpFukXLfOmwInDvZMmDJ5myeYooEi0USihGvyYHzaw4Hp1e1D4HmegPNbfKIbnf4Ic1Z7E6DttuhjuY43A8eGeNaT3GuSl7L9Gdo+0M1kq06NiMIz7GWto/OCb6J4SmQytLpuBzRLgG6yxhyAilQCoSghQ8OUguNhfs+i1ZV/nMHBOHNKxSqIGqBkompqr9r2ezKpkpwWpFEpIsarUhjAO78Snz2YKjwwXKWla7SCMLtnhsVoxhwA89JWbuLg8IfqQfM64tlZqjNFl3aKkwsaCsQA4jKUV0DDQ507SK5XyGOTqcXlwjJXtyzGx8QjYSRGLe1aBljJEcMr0PNJ3DaIUQdR7GnKvMpogUUq1mCY1RkpR7hGxoTAX4MdYqiVELrDHYiQ8f04qcB4T0mKa6NMsSKSFSUiRRJtqNhhKQJSGkgyk4MG6BkQtyWJHSiBUaowxSGKRQKGnxUeFMg2k6BIrUh2rCUKZGWiWpPjeiVtEuqVF79YpCyRLdGEqKyFIN6oSxyFYhZCYMMDtq8UlQECgyMkdi31N2a4biQEuaplYpipW41kLQaAV+GClh5OT4CNsFZl3Hw4crQr+FBEqC7aqk53qz5cIHipIkH3n6xiOs9HRN9W4oZFxjaY1FSke/3uHaAaNBCkseqi9CyYEUIkOSdEojShVUKEUAiVQ0GYnWDlE8YewJEayRPH39lMyKdLzg6HiObK96DvZ0ESl416K6z6TVTJ9EymoEWD+7kjAVE8q5fnSlBWcKUw8VlXqUQqkBH5LvfH3DR+6f86gRjL5wsrS88vGO5z5+yPHMsbpY8/ThhoMZ3Ll/gJYtp3PLP/jVLe98Z83dueL+p/6I5vY3+OoveT734wuWf/kIli1iLMi+ILMiDd9FdofoxRFBbRjUDPgorfoPePP8F0kPH/DtIXO8KMxNJG0uOJztGHLmdtdRZAXkRjukPEKUtxFqgdT3EMLW5+myovV+x5Wiyj7Lf31O9+OqWXI6+57ec3kPrlEmYAKsNyko+0bOqbRwKRdZ86zi8iMp1WUWl1JFNJ+9DrgCeR/csW86vfy//ebLf4u4vuEa/WX6+bpJ3bPqRPKyP+BKKhP2hYhyrY+n3lNxjdq3/+9l0LdPdn/QqwbcLIjVQm6uHkvO0TSOrm3p2hld1xFT5PTsDK00Wmu6ruPk+ITFcoH3ns1mU5WKSFBqpSGEgFJqkje9uscg2Lc3X85jpvbWTdekdaXz7tWP9qO+u8p7BIc/WOP90YrySBx3ZK04Oj5iXHT0Y2K+cMSSCEJiukMiHZvVlvmsZZzK4UokLs42fP/Nc8zC0h4syD6w2/TshsjtE8ntWcOigdXTc8ZRUqTFGRCt5WOf1LzwyTnfW0Xu3Jvz4z98n5cWt8k8xtEj/Xd4aQg0jebF5ztcd59bP/aU/+V/OsONgd1bmUdfyzz6Ffiv/2eHekFgZh1q9p+T5V3G5ue5+B++Bj/kWf/oyO1Xn2f56VuUTcNb31rzt37lZ3n0Nc1PfOkWfmkIsbDaSF6439F/9zF3P/1Jzk8f0s4FZtHx9kbzSnqbk0/+BFK+AOI5RJIQzxBsKWLAlhGlNRGNzxKjI9JD7zNq4sulJBA5UPwOyYyT41s07YzT1TljWuMQnPWCk4MDsJ6UE3ZpWbpjLk53PL244M4L9+l2GUhkBVkLxsdrZgcLsigIpUnRk0rBOkeWhe2w4/z0jEZLZl3HoWsJx3NK0qyGp4TBYxs4MC2LRvH00Zusn/YMg4TsMBJMiaRBcHhwi7EHpbbcOZgxawToyOmTh0TvOVo2rB5e4LOgFY7WF/rNisW8RTeGw1sn2NmCnDWutSwWjtN3HrPzI0NIFKFomw636zFjpnPV/C3GhEoCnQTnT9eUEaQLhFyVcRbtjM1mRS4CbRUx9PgsiFlho6hNnrHgt08JPuOTAe2QKeInucvdLqO0RjtLGDUKQVMkbbdgLIK825HGEU2i3/VgW3LKuNbRKoFRmda2rHvPwcES1Wi2YSTlyEsfeRnz8C2enFUVlTwqtn3Cv7UiOU3WAy8/f8jDp2ekDIv5ApU3HCw1JfRk3ZE1GF04pmAEqIM7WGOxxqG0JpFJfcSkC4Ks1QupLFJZhBS0rjZIG7Uj5x6tCkZXSV1tLDCQyhYjK88/JU8pCavm+LABkWrJvOwq/18ticMK6zpAgNRI3aHMkpwlhfoO0VJN7s0W3yeE1OAjeUgknadG6wCyQVAYz3agG+ysoZlbdGsrqNqNNeNpNbrRCCWIfQQFSIWdtSgFQtZeiLSz+N2AWLRo1yJjJJ6v2Q0DQjvCxYhxCiUF1jS4pmHx3DFnT56iomd2NCewYLsZcSJgbz2PePS1SsOYmuRkKvQXK8as0LMDNuueYRwQRbLxAtE4mpyYdbXnoR8yKoHBcPboEfPjZaVRaYNMEcbEXCbmB4YxBOL/x92bB9uWnuV9v29cw57OOffcqW/P3eoBJLXmCYSkJEJmkI0hDiEDhEqIMYNNgpOYqlSqkvyTqtixKaccKCupJMRxIMSGGEGZopgsIdHdqFtDN+qWerq373zGPa21vjF/rL3P0JJBDHJF+qruPefsvdfae3/fGp73fZ/3eZLsXbHLgoqK1kmilixiiyIj9ZABLVdu7nHXpW12XtmhmzXMqxJ3Cpz03FqxarhPKbKqsZygGPVGdlmtANHRvbOHib0u+Gp/ckUyWjlgp1UWLufeGDFlyLmnpJ07X1OOtnj+pQP+4l96K+9866NM6jGwj6JB+E9wMVqGtmI0PIdSdzCsbvGf/5ShSA2LW5HmakbsS/61Hx8gJhqp70QVf52ULhNe+g3cE0+SLx3g7ttnePHNlOOzxIXg6t4en77xt9i7WvC2R+8kC0kbBbXSDCuB27/M+I7HmB5+gXo0xsstOpdQ6XmKzTeAOAtig0SJzB1C2D/h7fi4yTHTK6ms53oN4nsg01caVxJRq79f2xzZA3x5CsH0kqRHvPWc+x6jVbNnv1ZyFUj0QO2IEpZOgKFVMLLGyl8PlYNTbJET/K7XhMasYHs/lXm9ZT697TpAXv29pgUdVV9SJqt1xryf8xjil4RXJ6dVsHb6Pf6s//8Dp3/yjLpWCm16GLqucCkhGY9GfMt7v4kPfeADvPWxN9O4yP/0kX/I81/8AgeHU0ajId/6wQ/ywz/8w3TO8Z0f/k6CD6eqZjn1srJG9oFxzivp75g46o46sdbrORarAzv1ZiuAODon8urxNRX363l8ZQ7JgxGxHLJsAtOXbjDeHLJRaKrNAXIwg70DZgct1693bI0M5MBwXJBILNsMVUlVVcyDp/ASESOFsWgLXaMhBLQqKSabDIoKUw5QWrBY7uFazz3bG7xlfInx4BuZFA8jRcbKgkqWPH35J3nlxucYV3D4e5n03HOc+74tti9uUcVEddax+ainKjNyaLjuNxjUP8DEfhMh3GKnPsvZH6vxv7hkQ1qUfgfKfDcv35T8jf/hB1m82PET/+WIzz3bsXVhzKVJRbWEy6843nrvCOf3WU49o8GIi+OKC+WSjeEIod4M+iEykpR2EHLBoBJce/kVkIpxPYLYgg/YbPG6hqajUJk0KBnbMWWxQXCJVAx59dpVzp+9k9r2aj27t15F54ASGec0i8UCJRRGGSolKQvLwe09srSYusQUFdbWXDpXExPY2hAydE1H23S4lJnuL9ncGqH1oOeWoxHSYr1jr5kxdRE7sGAlbbekazxu2jDdP8RTYlWBLkq0LlHKIIHJsGC+2yFVRlmLNpJC1aR6A5MjKiZcTIjC9hnsYcmF0UXKjU0Ko2nnLTu3Dli2hjaWXNvZQRcl0Qt82+BmC/aV5czWCD9tmM2W+JBRxhDTHGSiixAOZ9jcUVtNqxU39x1uvk9ZGVIQdD6ilWZjZKirCdevXKHtPLYomdQWvXJAvn5dsOwaBnVJloLGZWoF0S/RkzNMm4juQk8RokSazGy6ZNl02JQxWkNpiUpTWMVmPcYvZ2hhKZWg8Y5Xnn+OzfOXGIzBFhblI8vDKXu7e2xvb+PmC/Zn+3TdnKbpWMwFdWmwxYC61mgyUva9I0YnBsOK0cY2ne+IKaKyxGrFpCgQegzaknPASEFpLKW1xGQxtKTMis5WomWFEBopMhmFzu6odK6AlDqkcJD6SpRgZdLWLSB6inpCpje7i2FJcA0uTCnKMVIYRJwjoiTLEmkU9WQbkkJVETsYYqoSgSTi8cvI7c/eoro4YXRfQblRo/Q6A5QRIZOWEWTvrZL8OmEkMUVBaB1h0SGyByuJCPYv32Bwx1lC5fvG8ZBRgxHCJurlLex4ghcCPz+kjY6NuGRgFHbrAt1iweHelGvTRDML7Dz1+wxLw3LngNGw5vzFs/gkqDYGFCnR5UwpJK4wtD4RYoVvFzRZsrk9QkpF6DyF6LAusLvQzOYdQjZYA6UxuGYOUhIjKCVIK3lWT0RXFRtlT2M63DskJE85rLBVydkLWxR1yWA4YjFraJuO5eH86HrfmxAdU0ZOqXawMgTKq1K9kEhxgo3xGjp2T6nqA4R1hlSbvuIAkLOidznWdJ3i2tXAr/yTa/zt//EnefD+t1AVm33mFYUWihduP0+z6GmMk+khYnaF+vX3MBg/hEqOYa0Z3duhVANmyDJdwtjvwsi76GJDOH839j3Xyc9ex6gJyHej1Dt44sXf5aMf+13Y7/i+732Al68Kzp2fMECRO8+0dVzcHBLDTaIfYfUG1kREXlKYIYh7QZ5HqXOA4U8DHPrelBNZZ6WQUvXStWvO+yqjLHI8VS1YxQxHVJRjLvuXNimfMkPj+LHjz7EOUI5pLGvjraN9vVb3/Ws/PgA45vqv5rKPj06C3i+3rsdUoT9+rEBqPA48jiWD+wrDUbMtxwEBQEzxmNa3ajL5WoenUhxXSeIS+ToAACAASURBVJTpA9PBYMCP/rW/xr/xgQ9wbvss0SfCwZwrL1zhr/9HP86jb/5GhuMhxvT0UVJiPpsfzWOKvTfCOig7UiE60cy9nvwY41FgvZ7bvpKWTvSIHA8BSKX5ujng/4jxFQUHSIUXmi5nBiVsbNbsHhxiOkWhSwaDCa7JeKFYdB4lFHQKUxUUQ4vsWlCa1CUO9lpK04OeopT4DMVgBGZATp6QNKQKIUeY6iyoJYPBGYbV/ZT6fgJb3I4L7pZbZEre+y0/hXj5nzC9+jGG16f801+LvOt1gck73o1uX2b3qSvMrgZe929NuB4fBfsW3PQl5nJKLB7Ej3+QqG5SfdsVFr8fERcDeQIbdz7Ad/zwf8rP/ch/x8/97JTv/96z7HWGVz8X2HBzigckL12PlLHj3vvvwMvI1Wu7PLDpUWlM8JHQvQhSE1OHjx0pJsb1pL9phogP4JwixIwue1nHpvV0PoJfELxEF2OW09sMx2OuvPoilbZYoyFlnItce/UGQgnGowFKCmKImGrAVjUiNgsWXZ+xNBlKpSi1wJSG2XzGwdwRQs/XjlEgpSZjezlULUk50bZLUgoYnbnz3gohwMhMcI7FrEWiycNtUptpO/qmXgRq0bJhambtPtVAQArMmkP84YLaaKrRBZYJvDKEFEgh4ZqGsigQlBzsLSmMQOSEtIKD5YJpu8DYgtL2GdEsoOk6BiSUhmKgKTuJEhlhFVlCaRLSJ8RgQJEKrMhkLSnLGiESplAQAqORYjSqmQxLuiCI58+xWHYQXE+TSZo2QtstIUsKaVBKkGNi3iaGugAf+gZvaXo+IwmFIjQNTRcodY22Gi0kVihiBqECzfQQlwbYUhM6R9t57rxLAwP8MtI2LSFDfWYTbSxNarg9myFjREhBzBKXJLPUz92okAjZczOLqkaXGxwe7pDJFIXFS/rSqwBNQuCJqSOhcSEBHXVhIQWkUKQUEEKSMGihESKiRCYnT8oNWcYV+mv7C6ytiWJKTgGkpJCa4B3SSIQaoaLsqV2dI4uETC2L3euY4TYyFYgYkMFjVW+eVW1uoqu67yPYWTD72GVuPvkKN6TijT/wduyo6MFmgpwiYdESFwt6hQBBDKAqS2+7K8F3hNbhFy0iRUwtcNMpRW2IIRDdWj5X03UtfjZnb2fKREqwluAEqlC8/OxVzly8QDg4ZDFvmE8dYRppdhZs2hJDIFUKWWiCkGglwJZo36FEBlvQdoE8XWB1pBGCemgxSmMLjawKVK6IjabIM7QCbfqmfGsNthyyaBZoa5AyEYj4LEEblAZwzOctrglI3StQeTTogv15Q551vSKSVv11YD1OcMxT6g3O1o19R/17QiLUCuiwpk0cU2DWTJejACH3akZSyV7TXPYUqN7EL5KSIKWeHmat4slPXmNz9BjnLxW8eu06v/p//xr/yd/4MR556Cd5dvefY5eX8Vdu8uIzLfdtBaq73kd0T3P43GXMQDB48A6a/AaEeoi2fQVhR3hxF6l8O/nMHupRcM96xJlEVpJ7738nb1k6fvsXf55f/mc3+b4P38sy3IfqIKfbePkqe7NIpTLb2xdwUSLSPrXpEJxB6YdAlIA51XT6Jx3rxm4hJMH740bhk/N/IlBg9eNYNSqfwi3rxmboQb9AcrLh9bT6zemg4bhSkFcOsz04PiVlKk6+8Gt3CHnSfXo1N+v/VxyrU4+vQKeU6pgWc6L6dlIJ5+g9xNrHIn5JIH28hifAPxz1LCBWpl3HO+NfTeY6k3MgpmuQ5yj1AEIUxx/6zzjSms+/+s5FWfK/fuQj3H3PvYxGQ/J+h3/5gO7FPf7iW76DN77ljYy2xijdA/TrV6/xX/zU32I2myGkxBrbG3QGj/f+yNwuxdPBwvH17TU+Ev1XRq38Dl4rS3uS3vX1UDH7o8ZXFBzszztcSIyGFuGX+OAQuWNxEDBliYqJQvUnUIwRXeqeDxxBCk1ZlGQh0XQgJdr0Nz9TKIpRjalKFl2gNAUKi4sFOZaMqk1MrbB2SKHuQctzJDGglAotqp6LP7qL83e9n4GWiPZjKHtAcagQbPPZJ77I/KWOsxcuoIZ/mVG+hBITcvtZusOXoEiML3yQkL+VMPwlbox22UiesTvEiY7hxQd4/XdfYvrCDp95pmGzNJS6Jm5toDYhH+5RbZ3jIA5w8xm1KLCXHkQNXkdIAh/mSDUgC4UUBUJmyqLuI9UUCDEgFGhlaJ1j4RNKarRSZKH6snB2FEIiyRilEARyTH2DYl3RLhJCJlIIyCwATRsiWRkECS36rKLKvcOg0gOKqmLZLpA590RgBNZYhDQE59BCkGPEdz0X3fslMmW2zo7JQtAtHQvncanvi4jC0EbHfNEiJFSVokiCw3lLNS4IsaSQGhEEc9/SBdBJk3JGVhVCNYS2ZTnr0BTE6MGWYCzKKioliBpCykSfiAjQEl0IVPQko0EpytqSusgiLem6hqJSDKoKFxxGaYwEnTNCGOoCctJE15K6lkpVDIq+jB+9IFEALT60+BAQzhNbR1lZQoAsNcoatM6ERYMLvdSm1QLvBGHl5Ki1ZTgakmQgZ0XIAhF7NSytNapQECuEFLjOETqHNlWvsCRrlmHK0meyMJSVYHYww6lAEgKDQiaJpM/kyQxVWYOEkH3PqtQlWSgympx7r4CEwIeAkpFCWxCiv8kpiVpbxpNArJQzVvQEKRVKWaSskBiyuIEQC8i9sywIoj9ASENmQUoBskFhkCIhxAaCBDkiBUhbI6iJXUKYAiEswtRkoQnOo5sp5fY9mLpGSkP2Ab9zwMHH/4Bsz3DnN99DuVUCmdhFCAkhIm53RgoeNZK9znJegdyciU27+n4KlEHIPmNVDkqEyMybtg/eqpIUBV27oJnPONifk7WlmvRKTyRHzJLZ/hSXAl3o3a3dot++qioK6QgioKxCGqirgsKWyC7SLFsQCiM1WhpCguGkwJoeDEQfSCtzniwkutBoJTC259uiFNpWfclc5h5whAwSjJKUhcEBSjuQirXJq8yCGDyxVzzoZWOlxAtzfME/gehzzpBOKOMcRQf9f2uudOI0N16KdTaVIxB0ssE2hLTiXkty7puaYxQoqRmONnjodW9gNNomRU1dDHnsjY8xX7Ykc4GNjXdT6wGh8qhiH90aENu89MwtjHdsbn8jynwzlotoeY7o54T5p5DlQyh7gaTfSiqWTOvrDGPAxgZrKy7e+Tre9C2PEecdL7x8yNnRAUkbkhEIO4DuEDu6QJDnSF2HtBXKaoTZRoghx1/4TzuOgf1xYJWP5vokq2edNT4KyE687Wsz2Ov2gi99D3HUgHkSMK2fW2d000rpZd2Qvn7/fkGPPtHX9OhdoE8YX3F8GvQvkK+prqwe5jWTf7zDU7Qk8drnWOVTXhOkrftM+gCd43MHTk3zuvFZfAl4/fMcfWCQWa6++5ycvkimBjFByg3Wcsyv3a4ff/y5sD7GpJRsnznDj//Yj/KNb3g9xlhyiDS3Drn+9LP8iy9+nvd/z7czGA8QSJLvMc/04IBnnnmmVylKqcejWqG0Qgi5UmZbB9arpnNWAclJjuRrguPjvpv1de14u6M/v/YP+z9yfGUNyY0nOd+bkwWHbxNu0dB1kcFGoig0hQzMZp5qaChKQ6/LTt+cq3ppwFJrpIS6LlFGkkkUtiQjaVxCGwOigGQRQVHoEcNyE2k2MPoCSm4ghKbOCpdaYo4oIRhUl/CTh1iOnyUPryCkARLPfL4jN4k73nYWyg9yhprLB3/IphoiZKQNrxLcy5TmvTTVF+ExyXL8EK6Z8eqNT/LS49d5w7d9kE//ykd59gsN73ggMT4n2ItwSRoGw4rrnaAIDRtoRpNzyOptZHsfOc1BLHoQElNvopVyT8vQhpw8QnXIlMjCEtp5r7BT1qjQ89+zSIjkMKogh97dV5KQRLLsJby85ogjnGXfTOl9wOTQOwsWPV9OioTKgSR67XUlBVYKshQg+oAtZ4iuQ6+oAjn3+5PaokNApF65yrmMTxmhJB5FFoYkVpKRZLQQKKNZupYyW3yUK219i1GWJmY6HzBKUFYFxmQgEmLAN0tyFoxGQ0xpUUaiMLQp0i0CCUWUfb47EHpwN6gIQiJXGUkpQctMaQRaaYwMFFqik+5fkxUye4ie5BzJeaLXhBDxPuE9OB/w3vXKP64jxw5hPeVw1LshVzXGKESM2ORZLAVEgRGZGDIhr6g3dYkta4ZaEUMkul4+1khBYQuyzgyGNVn05xY5UwxGtMuOpAwuJpYhgoS6rAiLZc//FgqtTW+ElhIQkDlQFIaYMykkEv2NPSJQpkYJhbUFCVYmLwpra+g/ej+XahWcksjC9HKwogdtUhikHKBkAXjIt5HcQMgByDsgl6TQInAIluTU9o2m0pJjJrkBQlfkCGSDVBVKj4GAKQWIXr0IKUkxoG1JMRwilSEnCDszuucu07zyBXjPPVx8853YykLMhIUj3G4gznuH31IjSokQfUMluUdbsXUIaxBCobRFCAVSYEeydwOPfa9EDokQeildH5bk7OkWDXZQUY8HvZlWrIjB4xK41FeyCmtQ0VNaiTYlZXREASFFbGUptMR3Cdc6jFVoY7CFpZk1TOqa6FtSjEQfiMGjRMJajdQKWxYopfvvIyRZKEw9gNzi2rBS1FBo21+DQ+ew1qCMJREROaNiIEaPiCu+eoKYUu/hsBpfIqV41FgJnLihHtMiTjAvVjfVtb+BFOLI4Tevg7QV6BHqRGMmPUCwRck73/VOHnnk9VT1mBgiw2LIY2/6Bm7cus54+wyFuQNR7OKrK1AXCFEgSLzw4pS77tWcGd2D0G+iwDB3CypZk9NL5HgT8gMI9SjB7CLuugcvz+LdLjdvNBwezHj4re/m1ovP88XnX+bMI1MWAXJMnKtKilKw5zOTxlHLAq3PI80ZlN1cI70/t3Ea369AzSrLup77df/BelVOcdRXc7zOlnL0eo5ev2KmHFd7TmTH12MdCKwVYNYUmq+3cdJj4hjafmmw158Cq0oCp/1AXks+WlcYWG/D6TmWK3nYlFZrulbZ4XiK15pGR0pfJ6hEOeev6lL0FQ4HveMPsEfOl4EthLhAzp6cJUKcPQLd//LxL/mkq4RDVVXcd9+9/Jvf8z3Yopd/jgdLlq/e4PDmddLYcOHhi8eN8YvIlcuX+djHP4ZRhkE9wAePlIoHH3iQrc0tPvX0pzg8SKuAC1hRIvvpTz0uWvkj9M++ptLD8bVr7T+3/lt8nZ4HJ8dXFBzYGMjLJQ0SER3JJA5vL/ExosuasjSUKtPNW85dGIMWuABCK7TWq9IxWFuhRIM1hgA0ncO2ARIIaYhowKCyRgQQKSPlkNKcR8sJUlS9mVfOTP0rFBI21QY3smfhE7vLiquN4EBpZn7KS9NALQvkaIPIWaKUPH+4x+s3CuqN83g3ZWf+BTbOvJ6w/Q7OPvBOOmm4fvUTPPWJX+WJn7vBf/BzP8OTZ56ie/ZlYlGwTIndK7fQWxvo+zf43Gd2edPZIWfPXGR783UE+TDBJcpiA4kmhSXRLfDdoo8RAmAHJBxJQCL0SipSUdrIYDAmukDTOjrve+AdAsQMoUHKjJQGJTXB9z4Hioi2JUopcuqdV4vcUtUVHYrgY1950L2D7bJbYvAYkRBGkqQhZwmxOyo6K2V6l9gsMcWEbrlgerig8xmfJVn0WfM2SIxUFEWJmYCVkrIsUFLiF4754ZSl7z0HSpVXFY1eU74YDCitQRQSozXaBtz+DKs1w1ISDAQlyUKziIn96YLxaAK6xodIG3st/3JQsewcwjlc2yGkZDiqKcq+mbKQmcJIRNRkl4kusphNcc28l0ezBQnFogkImckik2OHD7Gf9phYNp6BMoSY2ZjUFIOaFBOhjRS1JaiS5AOGQCATHGSfe537JBmOx5AibtERO9/TVpSh9UuqQmOMoaIgpEQuhiymhySdcMHTOQdWQVUz3oJFN6XQhuGgwGhNComumZFSxIuAEBqlenpVip6Ye5nSurRYo4g5o1LvnVAWEzKRzvfVAiENSpcI4ckohHAoJZGyQMgSIUd9MJovQ/5DBNcQbK5oJiOSNhDnKNERc0NKkYgl+kj0CmkKRDZIMUDIHvgXVY1vBNFFknekKJG2oLpwJ7IoIWZS52ife4XZJz9NQ4M6M+krFlGSM8yvH3Dj4y9SNFM23vgQ5R0DRDKIpJFaorUg+V7Foq+yZJCSLCTeB6Qt0EXHQE5wPuG7QGw7QoQcO4ZlJrg5qSsxdoTWFonGUxI7cLMWqzKT80NmN29TFxInFaVUtCHiXSDkTModi0XLctkyUIqi1NhS0u22xDTAdZ5K9YFk0wW0ShSmd0vW62bulMi5Vyyy44qcHJ1rycEhtEaURe/uPXNYbbDG4Fe+CbgGlTN4j8xATmTvILTHF/y8akheZdNOqtIck857QCPlazJu4jQton9MsIY9+QRYyin3rtO5B1tSCMqy4Fve9z6qekT0mT4hmDiY77C7e5utyYAoPS4oDrqC3U5xURq6OOelQ80ZMQG7QRIDYk7stLe4oyqR9R10OUGcM9B34AdvYrh1D57M3u7jfP7TT3P5puZ93/vv0hRXaZaeTgSm8zkqR1R9BrN1F1devcFgs8MO78WYTaS+gNKbf+ob8JcfJ+BhPgE0BV/ioHwUIOTXbJ+PwWjOp0HpGuCfpHOcHsfw9qj/4QS95UTx4Shg/FpXzkkp9gDyZCAlT4L/Y+WhdYBwaj45URZ7bdS1GusKzrpJ/KjJdbV8a1OvU0HeandHlKc1KM3rxv6vTvo650TGk/GILMjsQX4ZOECIS5ADKe9A1gh15vgLApneKFXK0fF8/BFDa80dd1zkXe96F2Vd91PpA/6l6xxeeRVZGz78/u+itCWkfl/Ta/s89VtP8NFf+mc8cv/DdMmTRSamxLd/6Nu5//77eeHFF/DOIxqBlH7Vu9MHAkqqXmktq+PAMB8HZr1K0apCoyRCqp6adOKc+do+4v/48RUFB4uDObODBVkO0Cj8Luy3iYG1zGYBZObMxhnuu3cDFEw7x3hUUVp1FBEzGHMwv4VOkelsF7/K+DJ3FFXBsLIIL/tMlky0wTGbL9DKk5hDOcLqipXyOT7OMWKPNjk2WDI4mPHE0zd54aZi57riyauB52/BGbPBzuwSD2P4+WaHb77wrZBa5v6LpMIxVuc4nP06L7oFOMM9xQY3XnQ8/fh1UkqE5S2G9z1C+M1XeeKJG9x/f8k33FPy/1xpePuD5/gr73+Y+zfvxuaCEAq6sMfB3jXuufNRuu4Q5xZ474ghI3XBMoNfLDBK0LpACIGqLpmUW3jvqKsBnfTEbHq2hhqwu/cqUhbItETIEqsNWpdUdBTOkJVF6d50zoieQ7y/O8VWGlMOEMpDTgitaBYHzDqYDBUCj5SGgGDeteTFgslowDJAu1ygpaCoKkR2ZO85SBEvDYUpKLQBJJPQg6yQImY4wOqMkRGFYBYNBzt75LLAIdCVpdocwO0DlBKIIHp5USGJqudbb49LUtDszPZwM4vD4oVkMK6YbAQqY0mqL3CLsiblkoNFR7M3pzAZawxF0Wfa2qjROSBzR2oWLDtJ00Ri17Jz9QrVoKTc2sQOB2ij0UJQJE9tBa7UtJ0miyECA35GExNG9X0Q0/19nE9oqSjGBRsjRVy0iLajlAKfI9OlIx422EFNMaxILkIWOCloYsDPO4YbNVIGpBBoLVEisOOWzPYWSLnAF7p3XNYCckSODHhwyyXe9v0h3juUqfHCcnNnn63hgNooSmMwtiD4ls4nhuUGShsK1QfsLi5J2fUBgR3Ts7XUymzG49OMlAOIAUJNkHITiSVzDe9/EclLSBpEvolI10G8Dms38a1D0CFy0zf85iU6JZIuSN0NpNokKQ2xQYQOWwww1SZCe7rDBiUKNi7dhaqGQN9g5q/tsHz6cW5/7uN89tJbeO8776M5BJYOKTJ/8MlP8o/+/s/wr599Jx+6963o+waookAWEmEEEKETqKLALxtS8v09XCk6n3DzBh0zSfceC0qAd57l7X3iYcv8sOFwtmDetYhSUJ4ZY4sNROg4vHWT6dVbDCrN9mP3sl2cxYfM7b1D9KCgVpB0Qbtc9hQjnVG5pVsGfLfAd44iduzc2megM2o4xtYSqSNdGzCy374JEiskhEjXLkjJI4cGowzd0tE0S1RlME5x6ATWe0TWDMuChcs0ywUah7ElwfeeGFompBKMBsdSpidlLk/Lk54MAsQpgCRFD1aOKCxC9JnRnFeqNwDiBFCFeHQrFiSR8D7Qto5/9H/8X9z/4MOcOXMWIyU7t2/zq7/8UX7oh76zX6/FlGu3dnjlygGXb1nu3Ve8vOF58RbcPbuD+9w5bIYXo+eh0WP4NCelAULWCCFp/WX245ycFNvScO3yDrdvHSI4g8qBYvNOxvHzPP7MCzxy54ByOODT08DD2zXveej1jGwNSaOLMcZu8ueXQjwB/FI6QSs/dig+qY2/9h9YA8s1cDlFMzpRFeh58/IIgK4Dud6ZPa/WLx/RKdZZ3aNs+Qmay9HHFce0kK+XsaaOyBMB1fq4X2vjH7vunthu9fPk0fDl5+X0Po8oKyceO9UYDazdkNdVPSFf64Hw5zsSDZAQWQAzUvo9BC8h6CDvI8RN4BKIMdCRs1mB6kgK1/DN0xSjvwCiPKoNfrnzRCnF2bPbfOADH+AnfuIn+lemTNyd4p55ijRtsPc9THnvFr4BJQOkxJO/+bvcfvKLfP+bvof7P/Q2bsdbvOc978FWBc53PPHk43RtR1kUeN9f670QKxW1/noUVz0FvTpkPKp0Hn/U/nxZNzD3HlN9E/OXif2+7sZX1nPgEgdLRz202Lpkb3rAZDikMprxyDIYCIxJDMZjvAvIsmIx3aNLnrJUmMoQ85I77jnD7o3QN6GIhJBgCwMusgwBWxlk2Wt7lxJG9d3Ug7sQaKyoKIWF7OncDmBx4iz7+Tw3k+fpV7/AR3/1Kmc3SvSb38zVgwlLZ5ju7PPxT9/kre9P/Hv2Xn5xCe8uSwq1RWw+h1h8nJl9hDNn3sIlVTAXI17ZsTz3csPhLPJrf/e/59//z36Qz3zXDrdffAGnOl46d5Ef/NAP8K7J29AUKH+F4HbBTxFxj1FdslzexjeOGA0iKzSOEJZoo+m8IOUBtqwxOUDONPNDFgtPKBYoO0ZmjfIdotmD1tG4jmGtKMoaKQrms0Pc4SH1qMZ10DjIqUNpMKOSXGpu3thluBlRpkQqC6GXpaVZsLuUjMoaXSi0FJSFIYkBLgSUc3RtSxM8i/mSYVXBcMCdZy8CAr/sSC4ipWAvZERKjMdjlkCTfW905Racu/cs5y9tceP2Lq5t0C6zOdSEM5uUEgrf4mPHTBQ4LCIviChKa/F7hyy6DnRJVdU0SxiPtnHLJbnrqK0hWcXO1JHLinoyxs52IYMTgoV3tPM5Y5GZzRqqYSQVI2RVM94Ysj2A6zsH+BDRKWKNprYSFyKHc8fBfttzilUmuYh3kUortM0sD29iyyGl1YjkCYuOM6NNPIYm97rvfbNzQpc9L3S+O+9lP42l3KgorKCZzll0gVyViBRwrWPmHYcHc2JKLJNj+8wWUhoWy47nnr3Mmc2Sksj22U2EtSSlQFticMyC5456SEdPNZNSYJRBIRlYQ2GLFTCISCIqB8BT2TFNbImr5lAXPD7tUKiCLMDlDknCSEMm49MhsESIhKBFiEDfjDxHcBFT3EUKu2TdIohkpSmqDfY+f5nhnZt9VjsHEKGvagzuAjclJU+1tYEtDbLuPQlybJle3WPxDz7Cy089z6vn7ufOv/BhLk00RSn4/C99mmd+/aNUnePv/Id/k9F3vKun6d0KCJmQRpJcxu175FARmkBYBkQIyEIiBwaZE8vDFmU00iWE1QShcFFSCUEYbbJ1cYOmcQDUWlDaMV2C+X5DN19QlpnJVoEtSyglsm0YzgPOQdYFuqwQKWPKIcvplJgzi8Ml3jlU6rDDCWZQYUSkXS6pK8nYKlyWGDskpchy4VkGh5KJsigZFkPcouFwuQu2pFIKJTyiCywax/5sST2a0HaeFDusAh8LulnDcGQZ1AWxWeLbwLA4SSOiV7s5ohGtgFFa9x30j6+NtY4yy3DElY8xHSkS9dSII5S6omD0MoMp00tq5r4PoW09zbLDSENlCj732c/w2c/+Ad/zV/4S6CHTUHP1YMrjT1/nyheucvH8BuLSY1y+DgHNS9d2uHj3Hm86L/kGNeYLQXCf2sBrS/YvE9OcpLapqoeYCENLwUs3W6bOcNfZSzxiz1JfmPPqN7+Rg9svECdb1Hc8xDeff4Sz9iwKA2kXay4gZfVnuPV+6eipuKe5/2skf5TdFMfAsV+PvPKbkCuAs97XMfD8Ug79+jl5tDYpn1YjOvk+cAzr0ukGhvU7nAgAvzbHUUb+qJfi+HiFY5rWuqqW1bGC16rGcrSv41Pn5Dzlo8f6tUynqEaviblO0Ij40uNh/U9+NXPXKxlbehd4aOhJxofADFgg2CdznpwahPwOoCD4xwn+U0iRmb76dxjf9VPwR/h9DIcDfuRHf4jv+7e/t8/qp0Q3XdL+41/m+Zv7xNc9zPlHX8eokCideel3n+fl3/xt7r3nfr7pR34A+8B5EJKHFq9DS4NE8oXnvsAnfu/3+54/VRF8oG1bQg7H16+eQXZ03PZ0pV4Raj3PUq6uWycSHII+gdZX07++awdfUXAw1JpJWaCAK9d2GY8L7jk/wkfI0bE8XJJnMJw0+GKT/ds7BDqqojc/arMhLBKuPWRcWUIWLNsOG2BrdAZr4HDu8AEm0rIx2OhdTrXFdXsgBpR6TCSTwy5d+xyyOosS92BSzSd/53/nV/7pP2baKrbveYjK3sPjP/8r7E8PmU0jT37uMgfd77HU38b7ygEvLGFLjdmo3kaoHutdYMm8JvGukgAAIABJREFUuL/D3//p/5annn6cKCT1BXj+4y/zwk8aNt73/XDn41yyHe99/Tvw6jECE4yUeHk3UZZEoUhAPdjChwOSqHDukK45IHSHRBFgcA6XC1ReIrMieY9vDkku9RQRL3tTMG36oCo4RsOOkbDY4Rbz/T3mOzcJXcQYA7Wmcx1SKcq6ojAK5wJnBgOCkUQZkbKD6PAOVD3kwYfvYrlwBJ/ofCTnxKSuKSZDgoCwP2O8OV5xgjNJJERR9mZYTWTpBD7BQCeGkwnXb9xksjGgDAFyRBlFzCW3r9xg8+yE7a0xwVkKmRnXFa4WWCU4uO2Zd4ll7PBJIoUles924ZhsnuVCYQHJrI3E2JFyYPPshIHuD9zW906xzkPbtmhtKDRoI2mdZPfKAWY0YukTsV0ggRKPzIIUBePtMyS/xHcdS6l6LwOryV3HsNZ414NYk3uQ7ZtDFrfg3PaAsQVrJUIVxJCYHnjarnfK9cKjKzhnKlKG3Vu7JDUi6YQGSqMpihqvGwSOrumIMhC8Y9k66kIwEwFiRddGRHKERYvuGu6YnGfhOxbNgvl8n+G45sy5LUajLbQtEQmSBmVAGQ0opBIU1QZIhZa6l2ITmspMGFQTtCoRypPJhNzR+QN8ApEOKY0mJYePhyAKhJDsd3/Atj4L4tbqPhp6CVNmIPYQLAjdLs73KmVlURPzgtnBAV37WYbnH8IONdJKyvF9SDWkqCG4A3RpMYMRQtd9k6r33Piv/2duX75O89Cb2Hr72xmOEru71/ni//azDMf38NZ3fIjJufup7x1BEOQdj9jzRBJpJokp07nQU97OTtB1QZxOSc7h5h3LRaSoKrr5AbbWGFMiyop6fC/7QtBNb4OQ6Ko/PkQ5YL7fsExQFCXnxpYcN9BlyeKwQZYlIkC9dRG5mJGUJpmC5cEhKhxSFjWH4TaQydrQREM52ubCpXvoDm4T/BKUJBtJoQykloSCbokgkaUiAEFG2nmiaxJtaKkGlroqcM6TAkgfcbM9pIWqVGhlCN7jRaJpHXuzObbovT5OghOl1FHPwClKEcd4JLMCSUJy5LAtT2SyTwCsvudjna2WvcoXqwpCXoNQQYyJdrlkZ2cX5xxPPP4JXLfPe7/lGymrEim2sVLxhy/+Dl+4/HnaMOD89qN0ywHPPPFR8qDg6VenTC6/wiOPXkXJ+7hLGa67zJYuUeZBlAAlNQLYbZb8zC/8NLuzHWol6W59jv/m7z3Nh3/8P2b8wPsR47M8sv0QlzbvQwhNTAEhBNbcjUB9Fag064Brpf6EIKe4ko5dcZ9PVAr6v+VRS6hWipjSlwkQVntfN8KeqPism43Xxk4nxxGV6MS2PRXjRI78KMH9tQ+UThVGVggynaIaHc/DSZpPXv0U4hjk55MBxnocq5L2jcQnekdyTgipUOJElWAViJxel3z61z/zMfjl6h2JlBxZBFJucekGldgGrq+yBg0wB24heJVMQ043QN6BkDOkvA3yLMOLP0ryM4QqENLSVw4TmdgLtAjB3/vpv01hC4Qs+uM6Bg7+l19nOZNsvOvdqLsvYm3iYOcme7/3O9Rb9/HGD32Y+swGZrOECDQZMY9c2bnGz/6f/5CnPvcUbdsyHA14/etfz5NPPslsPsN531fk6PtdY4xHoH/tupxyOqqIAUcqbOkEzZIv05vz9Ti+ouBga2ypjSC4yGhSMdoa4mIgxV51J0ZPlxNxLqlUJCJxXW/oZQqB8J4sHG0TmS0bfE4IKQhRc3B4yMb2NiLPscLifMu8axgNJlzdfZHoAqPRBTKJYGpkbBHmHOi72Ek1X3z1U3zm9z/DS5+6jVY1j77v27k5H3KwL4gpEp3n2Scv8zd/5Gf4r/7uy1yo/ip32wmOgmvZcD1Fkk/86i98hC/+xr/gxef+kKVfMDhbsf3ghJALnvp/f5vv++6/yvab/zJjGZiUFTuHc6ZSse8bRlZgBYDBe1CqIZPIYUZOSxABlCSFhF8eInKBV5qQBCEkctc3CmZtcBFkCkflSBcyQpbIYkjnIl2XSFlijWS4McaMSqRQTGcNznmsluQcGIwHGFvgfST5Fccdzfxwjz0VMGqENIpKrhulM6GdInXJvO3AiL7z3xYgIpKEXsmDdT6zdIGucWycH7ExGbBopn0zshS9H1L2gGc5X6LJhBhoc6JtW0YbG7gmkEKkLi0GReMybRsJS0cnBAWCEANdF1i2AVsaXOfQZgWMVs8VZEwhCA6E1kQlVsopgo3xiCws4HAuMKk6JhYMEm8kzkec0Cht8SGzOFygCkNoe1WtrAQaTV1ZROo58kVpVnbuBm0t2moKbWmWAd+06LKidR1t5/BRUhaakHvH3dB6iIkgJIsYmM46hEngOhK+N1ehl2GNPrExKrEiEHMga4GsKw6n+5SVoqqHCKExVhKco20lgwhZacb1kAjErKis6XsLbImSGa0HGF2ipEZJMHpApgcWKWdiyiShiDnS5AYZBc1yB2v2qKsDlOwYictIMSCL8wiWkOaQHcheBlVwDV1mrtxqmHeZh1+nUaKiDY6rL+5wh54w0YpCDhjaXmQgJYGtK0xZIXSNz5KmaXjqH/wyw8uvML/zfppH7yVuOvaufor61oJz47dRje9mY3SBMhn8swsWz32W2d4rqOphRu+5h6QVWWZG791ADXplomgVURmi6A3z3LxDiJayUpjCorRGComSmnpzSDXR+LZhb3ePtvNo4QgJtLTkdokpyx68a01IETpPioK4mCGUQEtJCg6c43AxReSeKmUKRWkLjDJoEs3+TZado6wG2LqgLAXkDtkuWLoEFqzs1YYWBwcsG8GwLjHaErKHnAldJHaO1AaU0qTQEhLEIEgqr+SiQYncH7+mVyQJXTy63p+8763B4FHmOOUjHJHhFAA6+dv69TGmlQjMCozKng+/BlrrPoTewTSCyOzu7vLEk5+gKi0bkxptJpjiDMukefX2c3z6yRe48soBo/E2mU2adJ5r15bkGppZw2/91u+zd+sWP/DvfJCBfi9b2hIRHCBpErRNw5PPPMmnfuOfc+3GZcpxQXXnGQZnR6hKcPDyNd740Nu469Lb2S4nFKqvEKSVgpxAflXAQR8UrOQqRS9hulbHFKxBfR+MrSklOSWSEEfSi/1++sVYu/WmdExvOWq6PV7GU3SWo+1X79mvSw98pZC9aAGiv/evtvtq0lv+VQ2xolYJXiNZeupFfRB70rn4ZC/COkR6TUi2+nla9Ya8Xu/1I2IVeIujYLt/y77ynFay1ac/zp89MOjigpwzVtUn+lcSIU9JaY5ggWUXISrgApkdRJ4DLf2JbREMiPEXWczfgJSvYEzvE3Nw/Rdw3Rm2Lr0bU2zRayInED0QD75hY2OTnAUxQzdvuPGJZzB7uzQPPwSXNnC6odu7zTg2TDa+gWJ4jqocIf4/7t4j1pb8vvP7/GNVnXjze/1S5242SXU3qWaQKGooUVkajSXLHnvGM4IA2xhAMDDwxhuvDK8Mwxt7M4ANwzBkYTTAeBJgCKIlUWJLDM3MZrPZ6b3u1y/fdEKFf/SizrmhSUHcaGTyv3j3nXOq6tT5V/qFb/CK+PqScOsQPztCjC6y8YEplS/5+Z/6eT7+yY+hrWZze5MbN25wcHiAD5EQQi/4kNLK3b2/NtbXnZDyNE3Kp123c1K/QqyS8B/uc/6vGz9QcjAcWYyRdCGzvbMBhaRedqgYMQqEVuSUaZsOZZck5/sKjRa9C6lIdCExWzhUjGgt0dogihJbDbG2wEtF53oYQRdqwjxxsJiznC+opguSLNma7GGERehtHriCO/MFn/13n+GbX3qFpoXtx6Y88uQVvvEnr+OGu4SjOa5Zsrzn+NxnXuF/+18C29sdSk1pxBXmquRY3qV55x4vfe4zHH77uxAj5tIA9fAu6tnnqS7ULI8qhlTsjLfQqWNWz9m/8zZ+extLjUolSSaya2nrOW55HylVj9tuF8TgQEhCkDjXUVlzUk1LMRNDwi9rhInYatBXi6Jfqbr02r/LEHGuQ8hMVRWYlNBSoHNPGCUFYooEYclKs1h6SmPISZKDXz04Asl3dAsFVUFwLVoKjClJGTrXgPc0riN1Ge0jxSBhSoVrl7QJOpfwUSOUQuoBbdeAVmiVUNljZP8Ac9HTdEu6rsXK04eeE4rBVOObDtc4BlYxKDQKSag9ImfEqqMSY6brPL5zGDnElGBkJIZACoGcJYXRdKvzLaaE0gaZMjFmrNJ0MWLKksIKqlKDyDSdY+kySRcoa/tKYogE3xFz28ukyYIc+4eFyr0MpbYaEqhVRSkLgTWa8ajCtXPKonfnJUR8G/BeILPEt56oWpTSxJBoG4+OGpkFg2qAY5UECoESgpwEpVaMhxXRN/jOE3yvJ991LUJaxhsrnHBMOB+RbWQgAlL2+yjFGhsLRvd2nkpZjKmwukJL2+tmy1MJy5RC392SBUlKYMqsvcHR/nWULphM77FVzajMArIliyE561U1KCByBhJCztHW4KWnyYDOiJy4fbfjcN+z9eghUzVGGLGCZsi+YGAkQvcci2a55ItffpMHL36Jh65d5eDClDrfpnjwBttNiS6vMZxHdJeR+zeIbYc/ivgHx5gndoh6gE8SpSV2Q1JsWnrD2pUgo9ZksUqccw9pNKXCVCXK9gT9rutACcxoSCagNbgQaJ1D6AJrNSiNliXLxZyunqMcmMkUITXJN2g0kPpzqgvE2FcHy/GkVy8qCgySbt5wfHiMVxpbjfBJIHzCFppkDDl1DIYVKkbaOrBsEvWsQxeSkD05OVKwhJRJziNj6N2NhUGITIy9+laKjghIBaNxhVQZ366xxafjHFn1TPfgHJw9r03SxHvWO4UX9QFUv2b/EF6BMPLpFtek4941OVI3Sz734l/wsY9/hL0rl2jlgM4JjuojXvzsn/D2O/eo0eztbrOzu8tXvvwGevdR5sdv0M477h0ccnxwQDlwbOy+ixRjGvk4znra5j5HN2/y6vXXufXtb1BozejSlI0rD7N38RqzZeDJzWsMlcVoi1HFyQ9Wq6Dmb2qcJgDnwnbgDHZ9HYiKNTzr9Dik9WdnI38hUCcudX1gI06C0LOcku8TBHGm23CmS7Aea/z7e7H3P7RjDZfj9Nw9Bw96D/Lo7DjnHXHWbfykCv3952n9PfLMMT8fdK7hSJxJQk6//6/jeoTUnXTmzmLGJP19w+dAyo4Q2l5ZMmdi6KjDXaQ8pFQ1Urb0T71Rf5/Ijr57EEF44D7QsOzuYS2YQpFCy4Pb3yDlJxltKRBXkOohlNqGDD625OSQ0oDILJYtt2/coX35DaaPXma5VSDcTYqQKUOFFhPKRqIiiHyXvEzEeSB1Hrk7JFuD94FP/sQnufDoHk9/6H1kkU+gQWvuzNoled2xkVL2cs6CVXJ49sicXmPrSV9DK98LBftRHD9QcmBK3Rs01QElJUFAFzOq8USRQUGSvQzmQgp87bHjXiXDaEU2AtdlZsuOvY2S0hqiUkRjKaoBRvWXQNs1WKUQbc2i6THni8MZh8sWbcc0CUS1gxN7vHo0480vf5E//dcvcu/GbfTeFtsf/TGubo/507sP0Fcus1s4hEvUhw/ousDv/bNXMduvg7Ak+T6EnSD1DepX3+khfFpgdseMn32cjY9/iPLh5xld3Mfe8rz+1g3wNaOhpa1r7h7eQ1UJqRd0ouiftr6m62bgluQoKEuLb1tSCkhdkrMl+oAqDWRFjqGXOc2Z4D0Ej7aa5BUh9DZaSpUYk5kd1fi2wZDRRpBdomkXpAzOF0gRkFogjSKqAfNF128fQew8OXpyznTRUxUVmBbXLInKAAVCib7anRoCmuBCX/WTGakrunpJ3UWEMmAkRVlRVRXL5TEdCisjMnYYIdHGEFPAh6ZXRFnpuUuhYVWxr9tAcpHSObTtIWRSgDWqN2OLEYRCajAhEX2gnFYY1VethBRoIXsjpbZD+IAg9sonMfdBHz3UYbI5YFIZpOorxYGOtmsoTdErZwpPio4QW7zrtfmjUmggx76tq42hLAztzJFEoq47hBAMyl6eN6XYq3D52MvT+oBrEgOrkSmSgseOClIWtF3Axn7dyhaIHMmeHraQ+xt5WUqKomCZIj45fPA9vlhInBcE50ihA617KBSmryAKhQsBY/qKdcwRIRU5e5Qa9NKu2qJlhRS694xAEUl0osOJAqlHCDYoRcV+/TLHR7dxSdG0+4yn90hbI7IawKpDkzM9Vpq8wp10KBVRo4TSfYciuzmvfKvl0sUCaxt0kRCmwuc+aY2pRmpLFr38al0v+PZffIOt+X3uffAp7tkO0dxl3HXsivch6yny7S8jlCTmltgeEXxCP3GJ8S98hOVMISeWYltTXdCoSoLsK/Y5JaTsr3epBOVAYiclOUWklkjTJ3HBNQTXgVE0TUNOgZQ8Lkq0sKAk0hRIEpkFznXQRpJRDEZTlAFJBh+IXSBGgRCWopLY4ZjCGrSQ5M7T0dA1EVn2nYGui+SUUFKhjACXGAwNqcs4J5BaEevIonXgW7L3vZur1kgyWguUkvhkEDmQIzifcM73145RKN1LHPvcnwPr0bfQ5Ulgc2oQta56nq349+ekOkPQzFmcBDMrpjLr4ETIMyZaaa2cH1eJsepFILzjxo3rPPfxD5GGQ/aTZv/BEW+/+m3+/MUvMWs6Jg9f5dL7n+Ha5Qv8xR+/xIWffBr55pzZPY9QLfsHc/7lv32J8eWXgQkdH8FWjrh8m+M3rpOFpCwVo4s7XHzmGR556sNc3XqYedvwxEOP89r+bS5MJyTZB92nwdvf3FjPsGQNy+Kkwny6zGl6draSnFIfyKz9JU712E/3/TTgPbPM91Q/TxOJE7399fusOwwrrkk6uzc/5KFSPvVwWM/bSaK0gletk7c1AGk9dSc0hVNQ0QlfYLWpc8Ep9Mcuk1dKQJwsnM5eZyfb7vflvV4UwPe8fu9IqQMhkShYsQYQPdekzaGXuybjUo0SihwO6Oojlv6AUh1hy5psDchytY9rOJRHEEFE4BghPU7cQ4ltBHvEcMytN29x8dqI6Jd4N0dZA2oLciKmACSE6LuG9WLB3evvUs72mb//EZayoWrvY0RFlSeorkDcvgnWEOOcvGjJWqOvbaCfu4arBcs44+Of/DjVdokqFXmFVJjP533HIPcqb+9V+1of37OfrWVizyYBPVLs9PMf9fEDJQc5JazppSVvv3ub6eVtYhLUhw3dogaRKcYGWxlq6ck+IkNJEgXClkgjiGmJD4nBeIy2hkXrmC9ayv19dC5Y1HPcoiFFQdtljuczgpYI5+maQ+68/Sp3jo+YjR/meLrB9a9e52v/4//A/PiIWJTsvf8DPP8P/jMeHV3gmQ/v8t2k+cinr/DWV77N//MvXsTfXyIyyC7hu4bsv947BkiFLhSyFNhRweTTH+Tip36V3Wsfpbx5n8vDjuvD2/yf//L3+Jmf/CjPP/s8Ulr8aMiklMSuJnbHJC17B1YRGWzscHzvHs38CCRIYSFCORjiYkRmy7LpcG0NOWFtSTEeMV8sqRc1yUSULJGmohgVxDSnNAkXIjE6fHC0bUdIAXusiRj0wK58Inp5R6lKYuyYLxZE31/IOQZm85ZpNUYNO4bDITn16juZRD131DlgqwqVdR/05EwIHVEI6rqmmk4pBwZbKmSOKKXx8wU5HKNFpBgUlBrIHdNNg8w9ITT5iBSCwkiODx5Qd4Gt0qBSIHtPVAoUjMZDchRoYdFFQaEUuvMcHRxR5ILOSaTUGJnAO5rjGdErxGLBcFLgG0/TBFwdUKZgVE3Y3lEY1Sc8wQVyUWKtpku9dKZOHcG3+M5R1wlZTbEmUyoDMuFTxkuDVLbnCLQe3y3wbYsUPcY3eE/yCaEKtLXklOkWDaPL26jNIW2TQSm6KIjO0SzmTC9tsjg8JqnUqw4lQGQGZe8vEDP4JAlCIayitBKhC7SWNEc1QkXsuEQXBeVkROvWnIdMoQRa9YQypRK9N26HwqFEn2QJJEooIroPb3OiEZmRUgx0xQbQDgagWuZHCb/vuFC8y+iFEUI/jgozsszkqMkhkXUGA0I4pIjIsUaWCpkiy+UdvvKXjk/9rmFnK4M2NEHiZjfwaYjyD6jsVWI2NF3m3n3HxhvfxV+0vHnnaxQP73B1eoELYRf/9pDjL/4rKpNR1WOk4SOkjUCa1gz/3odRVwak/Uj5UEmxbTAjidC9sV8OkewCOUaUEciNAtslfOjIXUcQ/QMEKZAiEtsat6w5uLeP6zp8FkQpyLElGIsWjq6NSFVSTneZHx7Q3bqDfLjEmBKlS/ARGXrCc1weU0wGbE4nkCC0jtZFGpcwpiAnB26BKQyFkojGo6aCHCCHROcDXQhIERkOCpo6oHMmhkgKDQpDNTSo3HMVlsvQY2sTpCwJISO1xAqB8x65xt6eqXbGmHsifjoNZOBstTRzvnL2ns/PYCvWmOyUM6xa+aeeCbAOWfvXK633FNnaGRKKyM1mztEsc/fWA17+N3/AYesRwyGPPvsRnvvoJ7gY4YmnLiC2J3xo7xO8NPo6b735Ju3+ISkm0nGHdwdk/2c0qU9yiqKgHBs2toZc/oVP8szTn+QDG5d4XFnMJLO/OOKll7/Gr7zwU2AFISWs+pvtGpzMRs4rWOT5yv06GTvpLkjZm2menUWxrmCv3lvLnq66uSfcj9VnKZ2HxKy/h/y9wU8fOJ0Guet9lesE8occg/1XBXsn/IrcF+tOCvBng0hxesL3uZngXCNuDT1aJ8aCnu8rTpO9s92as5eRWPtn5FWXQIiT5O4HUYhadzrW501GkhF4EksEUmi0GGBkgSUzD99l0bzKoinIqWZQHqN3QcirCHreGQkEnizCaj6OkcJDNejPsVTT1TNe/8pdfuyDBdq+j4zBx0xwc3I2DMsNfGxIWbLsEt1RS3XwgNlm4uD+a1RXtpkUVxnUI+KdQPvdr6F1hsEVGF8k73TICwbzgV3EyJBsZGdzl2KgkKY/TjFErr91naOjY5x3J2R6IQRiBWX8fgnXGta1Pg7nkmvRQyXPyTL/iI4fKDm4d3vO7cr0xmVG0h633H0wZyAsyiaM8IwrzfYTW3SqZHbYUi8dTRsZopkWAwayZXuyi0azmLUsmo6cPXdvLfFuiFjWxCCJtAQXmDUds/tHGCtJxYhXvv0Od7t7zNQNFvdfxL98HRcAa5n+3V/jo7/1m/yTS88wlol/93/8Mc/+6vsYXNmi1NuMNrcRo8SlxwVPPGl45c87cqewlzfwT+7QHC8RRUF55Vk2H/lZ7Fwj/+wLxOM5L77+Erm7x+O/9Ks8/Og1RmFGdDVPXd7GGskyX6Grb4CbI3GE0JB9IvmaXFQoSQ/7ARaHh5R2QuMSi+USLSWFLhAh0TSRJCq0tiAkSpuecOwXRASFVkymGl+7XkNfGtws0GUYVJaMBlmAtLSzJc1yjq/G6NEY5R3ee5yLiELSCYMUBb4LWDtCiILD+/u4mFmg2PAeZQqUliBbDvaXtC4R5kf4ENBSYnNiPmtwXcZKj06u50z4jKw7VAgMlWG6vcXR/UN89ugsKAmo7JHa03UesGRfE3OHKgeMSk2KmW7hSUEgVYEtLJNxxfzwAVkajPCQO7z3LFvF5auX2NoZ4XPm4KgmpITUmnJYce2Rh1ge7ZOcx0pFRvDgeIEelFRa0i3nLNtM12ZSlFTDAfMoKXOg7QJaFZiiojAGEUBWBp0zxlgKJchNYN4dYquKRbMky0jrIkZbJkPB/NCxOZkwm80QKZARKAmykOzvHzGcTlDS0yNdemLobFGjqwp3eMyy9dQhkqQFU5DR7K46SdOdAYNhRWklPkNhLYvmkG07wOoJthpRlSVSGSxzuuYumilG7ILYBjWEvAUkBPAOgpeToEiKv2/HKAS7k1/n/vQVuqM3qL95zF985hY/9c8e5srA4w7eRBQCJS2qAy0SwoIcAxKuFokNkbgzjzx4s+XqGIbPlnRjCVSE+YLX/sXv8t39Lcqf+2/4uWcq8IbP/fkDfv9/+iZPd1/iyqcsMz/gFx//CMObnqPPfYtLRw8R8pT86KeR3hHcEeraJqOfeZ4uaa5/4S7f9RU/fXnAdKKQZnVzj5nkHERPDImcIzl7fOt6x3IviL7GuBZdSKQEay3z+ZzNvR2WywYXIkoblB1St70J4+HBjBB6XkjQluNO4V99g+HWBtNJYlgNKKpNfJGIXUNsAge3j1FGY61GlwVZFijjSLHXLper+0YSGZdgazoipY56uaDtOkwhGU0G3L59G58SKgYKqymtQBlBDi2DsqTxkZzAuUQMknI0ZOkc0SeMS5RWYgqDGZ0+CpQ8GwzK3hTubLC6CnTUmZpxSv1753XhxcqwLZ+05IPPJ0GqsYoUOeUc5Iw0gBS89JVXOB5OSC9+g/tv3eehCw/hg0JWJZd/9Tf5iWef46PDbRbHx3zpy6/xC4/tYWTF5vAK4pph9ETD3gXDeHyXN79p+fAzn2a/dNwNB6SQkNpy6cJzuMFVqnlH197ntej4+mvfYquS/IOf/nWs1ieB778Pwu0ajnX6BqtgPp++fA8EaD1yTqeB5GrFtdzleo01RCavgiKEeE9HRKzgSmtZ1NPvfG/VfP396/35YQ+UzunXr37XufR31Ukj53Oyr2fXPcFdibNYFHEO0fPXJ1H5JIE7e8qdhzmd3+fTJc5852oYPSalGZmOjAHKk128l2GWYUNInpAaQWZUPM+RfgkbFsy//jbN4j6Xf+spxtr36o52ikwKkTxCdAiVyKYPuveMw8fEvLXMZzP2pgFzaRMvhii1jZ8fMb/7CnM3ZOOpT7FVlSwCvPjZOTdeusHF9DIXXhgwi0uef+h56m/ext+YUS0qIhPyw+9DON/fo5/eQF0Z4Vzm6Pqcd9rEhy/u9ImB7JO6g6MDfvs//x2Oj45P4EBSiJ5PuOrMpZXVB+hJAAAgAElEQVSc6Xo+16/X3SB5Uhg5NYFck5d/lOR7v9/4wTgHRjMpLEFElvWSaqrZKDRF8tRdxElJGlZ4ZfBdRzWYkN0MnTLJpZ7suWgRPuPbgFGKycgSAhwuWu5d32djOsDlxPGDQ2ZtxNuKhy7vcjw74N2bD7jxes3+QcIFgZu1/QNsKLn0H/wGv/2Lv8IvP/1+ZlHy3712m0/+pOR3f3mKr7a49dVbHLwaiUEyuxN49Suw97ELdLc7xM3AVLZ4e5HJwz+P+vpXefuP/iVFscv2QzsMd5Yca8XVD36C5/b2GOSOo9khua3Zl4HBeMrhzVfwzRGVdowGGWMy79y9g2qgkgkvepOqFAJRWmQ2FIMBuW6pu5a27VDAUFuSgOg7giqJ2dOlzGi8gTGRZVv3+Dw0PniCB1sNMRGk1Ghboe0AhCabSJcM0YOLUApFoQTCCLwxOA9+f4kZjum6jGtbOmd5MG9pCOztjVC2IMqEJyGHkrFy3D+QON9h9BGGyKgaEIYVrjnC6BEmZ1SOyJgwpmRSaoQwyPEYvdWT+dq6xR0vkaGly4K29QwHlvFoRBKCZbOEBK7xFDGhUyYrRaEl+/OacjzEidg/CE1BJSUqO9quJXQaGSXKlAQFhVW0zRLf1bjFEaYcIHXvEzHfb9l5aJNWtv1x0RqrBVIpxsmxXHiE0pRFoswdhW+JIWELQ9cBMhFRuCBQItO5BT4JcteSvSMjCMriYuLmgxrvPTIJ2iRwKVEWmo3RAKSh7jxJJGLuYVybO1PIgcXxgnrR4QGpFW32tFliosRYhUPTUTFQQ3T0HB8+YGNcMTKWUTFgUm2wNdlF6xLBHKP2Ecz4/J/8X1z/zlf5T/7LT1OO/j6STe5GzdPC8pw1zHPmD13EKMPHxCaPPPJbTLe+zC3/RW79ySuU//fb2P/qd0jbgdk3voaSmcnTj5PufRduAU9lhIVCCJqc2J+33Pxyx8+9AKONAYtDR1p+i1H5gBd+5hl++tI/QY+fQKkK5wU7+ZjUvs61f/hJ/vz2HX794WfZf6tj9sobbB7cYTAu2A8Pc7D/b9m6egHz+LM0u5vcPOj4jmgpP7DDzz82YVRoUuzvcjlkwjIgrEEPK4JbknxESPp2d84IlUltQiiJVD1MMiOw5RhFJutMaRWqLIkxsrx3SKsNXkvqKCAmSinZG1k2R0P09g6xrmnbFmQm1A1FARtbJYt5SwoBn1XvTdY6RO5Qhe6hdUIQoiArQ6UU2S9ZPthHIxgPKmxVUkwH1PV95vOu7wKtTBCX8w4rE044ogsYnSi1gChxKSKMweEplUYh6HLmrxKi7Ktr/UPybBgi6CFZvbvr6uG5ghP1660Dpz4gMlojRK8GklbY3uDjGW+E3uejB1VkBuMB7778GtL0AgCvf+0Gj3/iOZ76yZ/ntz/0IR7e2uGVG+/wz//fP+JXPrXLr71/zDxt8dKX3uHllw/Rquba5Ql7e0+y+2N7fPZbX2VnY5tHrj7OzoXHEMUGb771DT71wae5LzPTwYBL21OeuHSZ6XCElv9+OgVnR17DiM7ChUjn4r73VunzKlhdVzVPo0h5ApU5WXZFJj/hGaySvJNtS9Yr92aQKZ3Z6JmxWkXKU6WqH4WRV3N/KtF7pnNwZpnvIRwA57tnZw/Eaj3Wh0WuFIjOrCnWS5yHJ62RZevEbB2UCnGacBir/9qEI+chKb0O+Q7SvB9yxRzJY1IhUMwzvJYyWiiuUbK79SvUg+sc3twnH11Hv3oH+cKvQTWjvfGn2K2r6GqD3LxE9gm53e+lQdLljuViSXPvkA98UCGLCc3BAcOhoyoN5eUBDw0/0gudIJE54+6/jcsHbH/6I7w8O+anLjzOvbeOsNdvMqgFonqIlDaYP/gC42sX0Fcep60Mx4uO+ymgtiwfuryzgjb2ic9XXvoK//S//qfMZnP8ioS8nsM+4F+bMp5Pss7O5dng/0R96ixs74c8If7rxg8MK+pcwkuoBiVd06KEoiqgXgZcEPisMMUEEQ5pZjNs9ggMTdOy7BzROZZzx9iOmGwVmIGliyXZeQ6bOfP9JdKCjjDQhlyVHM7nLL2mO25J8wbRaaQs0aXATEv2nrrIf/jJ5/no1YsgErVf8oHZG/yd3/xltvY2aeQOo/GbaNMQZjVdUnz0Fy5y/Y0li1sNk9GYcTGlmT1g+dV/BUeHhPIyXdsyO3oHphOyLyiT5uj4LiKUbJQFW2VFOLrNcn6T+vgeUmcaF0jBszEUDGxFIQMuemy5IjiGQOt6HLGIvXQowylKKERwyNhC2zCrPXJgEVKQ6Pkd1B1HxzUKiYwJvTZB0wXOe7y0/WcrYpHraqzN1K5B24Jl2xCFQJZDRIJCdAyqMT57slaU44K2UBy2lm07IaopzXyJMJnhdMTuRPHuzZvYwRCLwxqFtiXDyYjgNMlrROzw3uFTRCuJKQZc2LuGDx5XVoTQ4X1LoWE6qchYvCpYLD1tG7i3f4jWAhkFoetx+1IEcg4g5UpyNdDVDZFAUWqqQYFRkkHsFa6WS0nKmUJKKqOQMTJb3meoFQwsUimk0IzKESI5Du7NcH5JjIGiqhhMJoQUmV+/SzM/ZjQZM54MKauCZrmgnS1ISjKfLxlMKorRkNJarJTksODurEVlge8cwff8nL7NanBCY+hhWIWx2NIymI44nrckoUnZE6InxIRc1oyqIQeHc5omMpwOsVaxmC8oRwNENWG0XRGSwCWNdz30MwrJZDREliOKwSbj4SaVKSnsECULpNglpdf4sY/scOHyNl988Tto8d/y3Cd+g73yaXo1ihEZydOrbledBIHHKIsHXLz6MvOPCf7wD5b8o//ibVBHLO+0CLeg2qlRI0N422PrnvuizITZ25LP/v5dXv9c4h//9yWDaaLQE8TWM5Sjj6H1NXQ5QOQFEoXVFlUcEaev8tzH34/++mvoB39M+/KC4eGAyfaEB8WbNFd3SeppxLVHuD/c4LqvuRtaHnv2UX7ismVUgswRYia0guQSrvaYDUvKEVQii0T0HiUC0hqCimgkOXm6OuJXuvEpZFQlKMYDckzk7EFLTCmYdRFrBEIqolD9OcaYOgnUsqPUGiVWvJ/OIbJccQ8CddcSPEihcSQEAYuhazqEypRaIpMnzOuewyMMOUeMVEitON7fZzLdRbEA03dCYogQEyp6FgcLyvEGWvUFANH1IgWGTKFLOtf1XSwtKa09ud+n9TNQ9AoqPXyl5zCchbL0D9uV4lo+NWhaK+Ks+QiClSGaAEGvppZXGF+p1so/vSqSzOA7jyJRDgeU0wmDjZIsL3Hz66/yO//pP2bLauq2geTYk4l/8/t/zm/8wi8xklPKQQR/n/n9B7ybd/g7n/pxvvCt73Dn3Vu88MQLPPHQU9y4/w4/+czjuLsj3r1/l6u7F5kMhwgk0+EYtQoK/jagMn0hflXVfI9qzRp+8j1rnODZ++7BOdnFszChkzhfnCRqnIGtwFpCtXeaRaxUkM7i73MvxiDOfbf4kdB8P+2UrKFE+QQS1MNRJEKcNwU8u+56lfMbXf8Rp39XMqZwPu1arytPpEz7BbJYJwTiDKysvx61Oh/CpRxJuUOIDEhyuksIrzCf3Wd57ND6DXYvf5ixvABiRBaKAYKd3Kv0dAiiuEBp9hlfKzk69Lz+R2/y3IcfAAvcwQIpa5QG1JQ8O0J4iSgqpL7G4Y1bvP61d5i9E/nYf3wVrTzD4TbaJpTeQIhLCKUR2YEo+vvPeEl1seHqtSnm7pwHNz5D940518oriKllWd4mbFWU9hG6ixe4Ywy3mzmxtFy6tMnVocKo1WymvjDhWkdd1+Sc+w5s6pWK1uTkvDrOp0aNp0cipYS15uTgpLPHas25+b7X4o/W+IGSg1BUUJVYPMJmZk2DSR4zsGxMNB0SYy05evwyEJcNnRRoFAOZkSqzAAoRiD7Qzmpc6/BCEp1Ah8x4XCJEIpjEQAu8jRwcBZb3W2SWiJDIyxqpPZPdCjvRXNjKPDbp2LYOIzwT5XhhN3Jl6wKDcsIsWFrfEes5yfdOzqOxYzxJyDnsjT2PbcwZVZmbd496WUnVIUqB1JpgPeOx4tKgpYyZgdAMjUHjWDQHlEawbI4RCAwOpMcFKK0m2hGqGNNFTY4KJSxJBlKEetkhtUYrjUQQUXgXCSER0IgMRggkinpec3w8p+3ojatIGKUoioqQNFEqhBkgAWskhcjEJIkP7jEYDVFKEHNPRiorhSpGjHcLVNvSzY76yqWtiHaILjQ7OxvIZU0SEFA03uPCoicSu44Y59hKIeQm1hrqDmSGwaBEJEUKPQnaWEXbHFNWG7jOEZ3vj4FQFGVPhC3sACM75nnBYt4QPIyMQktHWWi0FaB7TLzSithqupgh9VhJpS3WKtx8RrOYMyoqpC1BGlKWCKmxFoiZGDLeO7RSWGNBQgyJet6TY5UwveJTFzAGAj32ums8MkMOHV1cInJBURaMBwPGgwotFbGpEUn25FPRc9MNsm9fRo+0BotGikypDcZapDFEIQkRQhb9jUuCKjSNCzT1IfPQqyiEkMhtwEVFcJKiyxgMhe6DtXnTMtyYUE4Nk80ttDEIoZBCYpRAS48QoQ8EBIym78MUjzAYOer9Fzm4/iXU2FFtHKPLPQTb7IkRXW44TIFxNgzMVfTW05RP/im3//cl9d2/YHBxB50q2rsH7L/s2XpW8pnPw89egmqkEVpzcJD40hciP35N8vBTI4bDvwuDMZlNRJ5C/Ta5e4d8+HZ/3Y33eP8jkX/0m5Lf+/0Xee7xyPU7R1ystojiKg+qhygeEzh1kRve8MhY8Q3T0Q0lH780ZHOjQ6REqMGUlhQheYguEbJANB0pRbLIoHJP00sQgicLgdSS5FckVFsic4cPkdzmFedEIZRkMBoglKZwidlRTVi0iOgxErK2vVrX/TnTkaYoLClrTFFC7KhbRxYWqSKx7Vi0LdoaCj3CWIkpVkF30xJczXBUIYkYq+gaR71YQNeAFoToqUaGiCEmT6Am+I66aSFrrFAobUhEmi5RWoMQAZM7FnVDyAljNbk9W808lRqFM0HQyXt5xUVKKNUnEOlM+321hV6mcQU3Wvse9AmDOIFd95XyM8FVSgSfOX5wTFGUdMkzux8YjCsuXRxxoUxk1/CXn/tLvvCFL3Lv7m1Elhg9ps6SdvmAdnafZrFADzRXdq/w9eprTAcBK2pUnlMZR90c8e69N/n45SfYHI8prO27F/LMzvwtjBPzq5PXZ3bnhCBLP2+ryROyn/OY8roe2i++rjyvk4KzUBkBIp9CptYdncT5hCTG3sdaKcVaRpW1gZc4CZM4h4H5IRzrCv33qwaf79asr43TYP5sVfns+6yS5fVx42T589s/y/c5zSZ6JR2xSlSVkieJgZQSqfpOodb6zHoZSPRqQv0vynRItUc12EaKhuRu0h6/AyZjqw2QIxQlQzQxZ5qcqNAYdRG/cQExKji+eQe3/Dxm8BAyQbd/CFJDZXj7zcSTmxlpKxCWWzcDN99pefLykI2di2jzadTQgtjtYbXhHvi70LyDsKDsQ3z4gzO+/UbLH3/uK1zecMR6yd6FC0R5mXY6QGwqkt7kbjJcqASvxI7tLcPVkWFUxF6p0Pf+SinCm2++wVe//jXKsmKxXJy4H5/waVbcpn5eVS+MkM9DxVLsz/HvUe0Sfbf0rAfIj+r4gZKDorQUlSW6iI8dXefJGoSSjMcVKkmWGZZtTXvUkJ1DjAcYq1EKUvA0iwbhPcF1RJGILtJFQfIB4TMiZpASpTIxevwsYl1mECILFyFnZPYQIqWwbBjFxWGmPnqLenOH7Q3JhlIU21tYvcDICsMSlRbk6FbkrITdUFRDQRgIlI4Q5yDKnpw4KdAyYAaJYiCROnNxq+DRHUsIgSGRIjmiW9C5FoEipISrO8rUYpSncQIxqggStDEENCkrfFZEHym16SuHUpCCX+FwE94n2gAeSXK+v/hEQdc5msZTVkPIgRw6Er3IkU+yl9tUBmkUWicEEW0VykpMqckJrNEYIal0r/BTDEY453tVndCbRUUh0N7jlnM26OhCpHbgfSaIjsoqVKXBW6w1KClxLpFzQMseimFsAUmTYoQc6ZqastzEKE2SiiQVMfeyptL0pidaQqUFGNEnVlpQu16G0er+DI1S9NKT0xGqDYSUMaXFSEXyCed7/ffKZrJVdEHgfaAoNDZn6phoO0eMYKwgWUHInqI0LJeKsjAMrEaRSDFQGM10NMKaEkLCtR0xeVzKvXxvYfvvbQP0eUaviy8k3neQU++gaCQpgja9YkjwYaVdntFaEqInxpZu1faUOqFC6r0kuo4oFdbKXnJTSOx4TLIVyyBJ88SkFGQJIWdCNFwYDuiE7U3eUl/9yyRyvEPiHjkJAnMEGmt22Npu0Fwh1jPq/TfI4S7FeBdhLlHpEh8nWGkRnSPRodQOe9c+xOCDn+XOrTe4OrDoSULcE/g7Cf8+wx99PvMTH8uUFx/igYIb7oA0Evz4xyXbkxfQ+pNgFSncI7evkeObCDzCvYbIDaLc5fJDT/HJn3qc//lfv0van1GGAaLaZrb5EIz2GBaOspqylAsOt1uGheXKxPD0BUlmRhvGqJyJeYSSBpkh+ECICVOAUJosJVmuHGJzrzbFCmvaP4UzWQiEkeii9ylwTQ1IdFlisqSoBsiBwrmM6zw+RUQG5wJG9r4ZzXGgGo8YTTepioLoe4I7GUKSPUkvJSqZGY4GaJPRVpB8i+uWJN8gdEWpLTonYnD4tlcfqgaWZtkHdVL1JlYJ1XMMgqAyCtd1ZDIh9vCU0AWk9MTckSNEJLFLzObtyf1+DavoxxnpvlWA2Qcdq2A/rpc5nxy8pyZ60r5fk2rPjpPQclWVyznTNR2LwyOQgrp2zI3m6Q9e5cuf/zyl2eTrX/02r73yKkVl+PSnP44SFmJNDjNiWBKCI8YWYRKlzZQl7M9vsFNPuLJzFQRc3LvExa0tBkVxhuz5tzfOBpviTHV5XT0mZ04OAadwk/XKAvFXBiynROUz/55scw2xOAOdWAW2667B2tX3vTj7dRL5o1JE/V4i9vlz+8xlwRqcsp7d9yYX4j3bOf3/2o/itMu2yrRO/i+l6s+B9TkpJaemFxKpNEpJlD4N4foEryPnOTkvIUOkQVJhTF9Q83K7L+LWtxDsI/UmQg3RQpFyhUJD8CQhMPYKg72nMY/eZjH7DhtmjBpXhNkxcZlxWF5+OfL4kwk5epyj0DEnYjYMV5+cUNkXEOI5snUQ9yHdhLSPyAER30D4JdiHefjqExw1W/zZN29x9NY+D1+4wHK6x0KP0VVJVRhsMcSJjmbgGeeCCyPNbgWIDhctOSd0Lgne8+qr3+WrX/vqChJ5Srw/PQCnnVGgv88Lgcz55B61OlBnkgOJUiuugsiQTpPwH9XxgyUHREyKuBCRucNET7AW76GoKiSShYsUXSa6QHKJodaUViFyZLFYsjiaI5Kg0hJhdG+o3XYo3xIDHO8vMMMSoROt65gtIoNqwO5A8uCep7AwGCpizJS+Za/Q7FaCN777MiNlmNrMoLyIKraR/pgUHWW4QykOeylA+gqV3SiRsiNlwbHLvLUfmMuAwCLGmkJlBsPEaCrYGlqubo+4OB3y4MEMHT3ZBVw7J/mMF56iGNAtGnzj6ERARIMYlNAJcmopyxFCCLrOE+qWamOAEhJB6tVTYiT7hMs9P8D7SIwJuVbKiVAUlvFojMwO34HrXE+i1JrsI5ARRpBCJISmh7QMJ6QIwXWIJNBa0cu8B/A9F0JXQwrfS5wG12C6BfffmTO+uklqj/vfZEvk2JCtZevKDrndYFJVGG2Yz5do0SBUIqRew1zSJz4xJFAakmcwKFEqQAspCERUGFNRN8d473q50WFJ8D3MYDbP+JQRMWJkwGpF1IZST1C2I+aeNClypG09XlfsDQUxR9qYWbaOZd2yQZ9otELR+V46jSBwMeODYzzaIMQxVbk6V0kIlUjaUEw0QllySrjoaAJkUeF9RMjIQT3H2IbxeMDOZIAhIztFXLaQQdkCZSSi0MiU0MmzDA11iGRvGIqIlJ7gj2hcb0ImYuoJ56nXYtZaYWRCG40dVhQbO3RCM593uJkjt5pQWkylWcwdo0Lw9sExFycVw2EiIgg5I8O7RPci5DEe01soe+i6Fp80engJ9m+QZneJ4RaqfJNcOpJ/H1t2yvFC0saGUkSubD/LM//wi7z7oMW671AMAmpPkd/N1AeCWSep34aNH7vC6+GQ18Itnvyg5Mkf1yj5CaS41Lst+5uo+GeIcobQCsEC/AJRtsjhVaaXPspzL2T+6H/953zqZ69xe7KJuFjA0DF45y6XLj3Exe2I2LO8UI3YUyUxBqL0ICe9XG1jMUpQKHrOT86osoSQofUk4Un0XhBrM6KU80qtTxBjQGjJcGKp54HF4TExSsqsEKoFBLkaYq1hUFq6DCFC9AuKUkOM3HtwzKDOGDNhONJ4qYhJE7qWZe0JIVMUGiUFxaDoE0lifw3j0FpiC0M5HJ7IC6MUUUBhJdkPqY9rqpFHClBRIpMhywExdoTFgs4bRO5hSm3doYSnJWOLEqUUjXMc193J/f4UjXJaNUs599+9jmPOBEw5Z6QSKwx6PleJk+dIrPmkhX/SXxCniYM4F5xnDveP+yqpFMz3Z9weGH7vrT/AqJKqHDLd2OCxxx/ht/6jXyIER5jfQskWbTPIhNSZedpH5EwQgnf2b7C7d4Xnn/plUkp8+qO/3Fdn/38DETgfxOR0Plg/xcCLdWaw8hbpAxxOZ5W1os0q/j8Xf65BEkKsnJbfExCfHK33wIliPGuUJ84sffbvD+dYB/bvTXLX0q1rfsYptOR0HuF8s2kNV1l7QJyofnF+Xk8Tg1UnYr0v8rRrsIY0rXklctWRFlIidd+dhT4xiMmTcgPpkBxvAAMigpQkOUZiiiQ0QhXQvktqI5hjpLYrf7ILDFXFshNI0WGZsnHpafwvvsLx4gjdfgU5tci2JLtEh2Y2M/jDiLn0Pm62XyJPHVefqNi8PAU+ihBjUjxEpLcQvIk09SoynyHSfVAerZ9ia+9prl2V/Nkf/CGX/94e/x97bxYrW3qe5z3/tKYa9nT2mfv0Od1NsbvFJilSUjiIVDRQjmzHUAaDsp0oUi4kCHCUGA6CIIYvlMCBb2IgUSDEiJUYGQybVkRrlizR1GCJpKgmm6TY7GZPp0/3GfdU4xr+MRerqvY+FBMwiQOTTP6LvWtXrVpVe/1rrf97v+/93vdBXmJHniwt2OoMO7sjtqtA2Cr5Nln2fgzRI5QkRY1LDmc1bVPzxp3bvPLqqywWCzgLfE8nenOv8vEUqK3lYtdzsAGA67cKcSZB8s0/viZwcOfuku1CMxpHLu4PUDHQtoGj5Zx0UZBtl+wbuJRr7BN73HzhgDhfILGUhcKEwP52yeHdBW7pmYW2zz6riFs0iDyjrT3GeITzZCmwP1JMm47Od1y7aKiyyMkJeAu7lyquXa8I8wl3XzlkVwouDFr29m9QFtfQ4YT58g43D1/g4PhWP5lSYLTA3jwizyRZKXB1YtkKLjy9R33ocSkgnWA0Mly/vssTl66zfOMOB3dfQVdbaN0i0QgMPraU3nN+b0gmO6YHjlmnSPmQIpWIRnDvwQnDqkZISecDg6JkVi/JlKTIDUVR9hn4tmYxWaCkw0+WbF8+Rz4a4YNEq0QnBkznS4ZZr1MsVjKLhQnM555sEPAuYYPDRYFnABIW9SFu2pCQlEOJyHJiNsAtWoiRoEzvntpZYucZbxWk0nC3t2lmONSc2xqS7QzZu3QJZy22duQkpOuw/oh2PiPmIy5cuIhfLgjOooxGl6PegVfUICq8EERpKHJFZnp/BKUSxmhUlqHRhM7jYsf5vS2igjZIUIbBaEAiZz5fMBgXOAuu60gCqvNbZGQo+4B6ZnG+RgtFWeYEaZi1lnJYUIwqZOhQ0RN8pGtaUjlkPFIQPU3T0nWeYBM6KziZLhkM+nJlaz1eaKrRFqHtM7HBN3S1pbOeXAnO7QzRSjEqDBBIOhGk7GVC3RL8EqWgzHOiUnT1gkW7xNmuX+BNTso0ZAWdj7gOpAq0NqHzgtHWLlt7u7z8+hsUqjdoa5Y13kWyYIjLCV84XDDeG9Bd3mO0fYELZohShugzUvMKsvgBTHtAuzyiaSCIDLc45sUXas69dYf9/XejtCa1zxOKjCxN6Bb3cDyNKc6j7X385H/m/d+V84U/XvLP/t4RT75XsbslmNxKqHuW/+pvVRw+19I1NzmZLpm80HDuNugtTQyfQ6kP4ZevI9yLGLNA5FuAQOgTCKHnysohO1tP8Tf/6qP86v/yHOP37fH2t92gPqmZ33uNd33oEml/wf7g3ZRyi+AXTIUjN0MOFw3XsgXDvcsc+QyEolSCIvZALwno6rZPwklF8gllDElohJb4tiYKjVQSnSQ+9RWFkGnEYIAJAp1JrI90C0c3seiBRvf6vUgnqC5fZL5YsLO9B9KAkPimxYaOGsFsNqPuPCJGBplhUOaYXAJ9P4BIEW0G5AMNbkGRFQhdYbsGsgEyRprljEVboIShqyNBNJSF7ntwtCZqzd27vdCDymRvPyE1KVoSsLUzJIQO5ztKBbvbxeZ+n2LqaVewoZ0ocbY5U/TVslWwFPy6eXWdkV4ttGHVcBziwzyZ1ZArWkpaafQLCd57AOaT5YZbvVYPufXaXaTSFHlOWZacP7/D933vt1NlnoPDl/nMFz/FyfExoJBKUhnJOGwzHJZM84yQNM4rlFLk2Uq15esGGJyOs0HKhgjPmTBciFXvR9rQTDYYDB4KXjbYQoozQU6/t3T2ibMZb9FnrlNKfRWY083EhnsvVpWESEpfX8fv/8746v4Bp5WRhxScxNqjAPos/wpQrN57Fuxu6EpnXj+lGPXRZ+LM3Gy+AKf7PIlyhT4AACAASURBVAOc11QipQ3KaFCKSKILFvCnFTh/C6Hfg3L3cJ0lRElMAt8tODnoGF8ek5dPIMME4pQkNZoa350Q5Q0ynZGaZzHpd3jkkYqDuzXP//Jnefx7tokLi5tF9CDw4R99jPrN+xTuZSZHrxHunVAGhcxzSK8Cbyd0b6LFPYTyILd7Opw8gNisQO6AK+ev8gPvG/Abv3Gb4dMjrl96hIP7B5QycWF3hKgcA3MNI3Kcr3uzUAQ+JkbCkw1GLIKkyEfkg4JEpLPdQ7h3k3xYNxpvqEJ/+lw4CwjWI4ZIXM3k+hr4Zh5fEzh49C07XL+2RTOdUjdw+dIW06njeLpgXi9RBGSWMwkzti7ucfGJ8/i6QcVEU0fuH7WkQjJvOvYvbqO1RKiAMYLxIEeNCuJWhRSBWdOXwEcG7t9bMl82DHdzrj1a8MRjJfjI0kaO5h1bdOwUiskbN/lMc8DuIy/x2KU9RsNzvDF7AzOAPFdEIZCqT2Tfvi3QJUgj0DlkJpEtG+YW6oMZu+cqsqSI02NmmaSqDKPtHZJv0MGxnLYcHkwYFgUHUdLVCxKOoiqQo4wsz6ktjISjEBHotb2HhWZna0x7dMhElehWMygjVTnClHsM0dSLCfuPZHSuYTGxJFmCyshwKGmYTma46BApkAtJNTTIzKHsnKIaE0QiWQfKMF+0kCJFrui/RWTZthjfga44uT1l+8IWeVYSyZDa0daWwXBAE2bI8Zg8LylKQ24kultydO+E2rYMc0MpJURBPj7PeGdErg3be/sk1+BdSzka0C6XNI1BtDVCCIw0hBA5ObmLTJFivE2mBdGtGqmNhmDIdiryLGfoLJHQNzWISAoW7QwiBKQWeGHo6g7t59x9cIfxwOBaiXUSmVWU2wUXL+0S2hm10uR5hdaKxWxBt5zSnbyGNgXOJaIqyMoR+Vgxn7Xsn9vn6HCK8xHrPPVyAZOWS7tjxpe2SbGlm8xxswXh5IDjWQ2ZwugKlWuQgtZZTmYTZpMpg60BQWhAIWNCBUc3X6DKASYz5IUmCUETEilleOYwb9B5jg+Jk+M5k6kl+X42b987ohiU5EUGszlKnFBcPsc5bzl34TLl9kWiKoipxag95OBb+sWsvMxo+K2MpKFrP8+9w8jbP6C589wf808/+htU+wXf8+G34NS/xva56zz7sf+Gwd5tyuEtWHyOu1/s+Cd/reGH/hxc+37Br/ymhxcS71Lw60toXvF859+8gH39kA+WlrddEXz29wP2wGMeO09nv4TIrqD1ByEWJPcmQt6CEbC9A3KLxIh7d17mh37gL5N1ksMXf4R7dz/BY49d4a3PfAAnt9hzgmpZc69t2Mo6tFA8cJrLuyXODLk7bRGFYTDQDMu+Uum7vvJnConrLK5rAI9KfZ+Pqxu8bxGiD8xi7IFiV1u6AGZU9iDWCY6PFphyRHCWKiSyskIMJCkKRns7TF9/HTcy7KdzNL5v6q0MzN98QJ7lNM6jtMYMSsywItgl2CVB51hryfDkWhPUHklscfzgiHa2wEVPkAmXNMvJCYOtAdXuHmQZrV3QdDMKFaiUpRpVZOMdpApE62i7xLJZsn9ui2XT0cWO+bwmxog7k/lVWm4yyr3LtiCEM/SSmIgrQz5gQ4EJa+UiANLG/yzBQ3KoXy3JLGUfiIXQN9OaTG7MwJzrAYMUUA0kWvbUqLt3b/Lrv/pRiO/HqRmf/8zLHB/XICVZoSmKnHHxKFUxxuQn3Lj4NI9feRv/cslD/ydDfLUg9eE/5JoCIVWvt76hQpwGP18Zq6+znXLlVN8/lwipBxib3cvTRkspe2qilPIUqGyA1JqCtPna3/DjlJ718Hm6abReZe9PKzCnoG1dXPjK8XC9YLOb/vcKrKV0us3pLlZGn6KnlwkhiUBelCil+/6kIiMblKSuofEdNggyEcmlRMgRQl8DAsKcpyjGpFTj3AHRwMWRYvL6H/LC7/wKV5+6xPnHn0LIp8mzEW++/POUO0uE+n3C/DVOXjrh4JMHPPV+yda/mvMHP3/Mo61DucjdKHj826dc+TfeQ3fni7xn6Dg0guXMEuoOMd7FhzvI7AYiRUi3IN4D8QZkQPE4iAtAyZc+/yn+h//+Zxl3GbMHP87s+BNcvfZ2zOgqSRhyl8DVnKSOLeNxwYDIGBSaqDJqGxFaU5WKH/mRf5enn3qSn/qp/4C2aXDO0bYt3vuNoMJ6vvt728PGaBtPESHP5DTSmlG5AuNff0mFf9HjawIHbTvDR40uJFELTpYWk2dceHQPGyPNsqM9nnBYaLKq7V1qPVjn8NaiVYAkGFYVgUQpI4VICA/z1mPkgqIyLOcNy9rRIXBRM5vWHE89ISaMBDkw2ATHTeTll0/Y35Vc3TcczeHmcYd6o2b+LceUe2/y4p0FzckJf/KZY6KLSC1QlWT3mubgyw1xGkheMLMtIkwIUnN+r2BvxzCQAT+dcegie6MRxW4ABLOTKc2iQUuDKUZss0AnT0OOTAnpAl1bk0xFmynmXQ3OMSpLtgcF7fEBOgjGuWJpA60MCN1r3BdGkAaSZZIYUyF9pKtrmsUUNGztXUJUFVlqe85eUiQBg3HFYJCzXHS0zuG9p10cQ6wYiYx8awCyXwh8DEhZYDuHGlQsGshygdYZjUs4ImExQeUJJT3JtXg8OZo37t3H+ozR9pjd4QAT+2ZKYQyujajM0WqJTBlCgF8sIERm0wdEyYoTLXH0Chl5WbJcLiB4cinJtO750NogZEFre0ygBEjnSVqzNx705VEVkL4jWoewkVznaFNwfDQl5QUmL8hNoBCO5BZMjhtS7F2WTSEwVclgWDBZtkidoxVkRU4xNChdMqgKTo6m7G1vM1+0RFdjVIkP4ILD1oEsetQqaMlNTjVUpGybEBtC6nscls2SFFoQEJIgpX57j8QnQdSawbAgJo9LDr/qYwgobBdRMqMaDxEmY2kdzXJBCpDlBTE55gdT2kxjqpK2tVy9/ji360B2B7IqsVsqhMgJsSamKcaM6BYPIB6hTAFyl6uPfBfR/S6842kuvnXKy5+7w0f+iz/mB//1e9x+/N/jLd/2b/OJn/3v+GfPPs9WGfgL71M89mGBvp8YPF3w779Xkm4GeM7xZCkx2znFaI/w8SVUkb2nMj7w0yVpYSGO0PNPIXKNSAek7jWEbMBEyP8sAkuKc2KyaPE8H3jPu/iPfvrv8masEfVtClOQ5A73D0/YH0pu371HHO/hZIYUFdVoG51rFlozNRkXpaSSoGSfOZe5waeIs5JAQKiIQpBCR5ISWZbQhZ4TLCRKQttYZocdS+sockEbWhoLxd4Ork1UKrCc1XRdjlQa33XYWU3sCo4nBwhhkYMt9HCPKGG0LTk8PGZQSKRMCKXpApRVRXKeRRtJXuE6i8VhxiMOX3kdmRVoNIWSBAVG5gwvDWF7F71o0QREpkm6IsmcfHtMLCboLMOTs4w1liUyz3hwNOHChRK77JvuooTW2s39vg/Q+8cxJWJYK7bwUBAUVypGcJoIPUuNkVIi0qnh2amh18pIe/XXOuBc84Ol7GVO19uH2HsuSCHoWksIAdU6lnVHvVxyMjvmwdGCJx4v6Jq+fycrDPko46h9nfu330C0lktbV7i0++gpqPk6C2vF+kdaZ6e/yjZC9OIMPqwM5U7pX+u9rHtEgE2Qv3qFdZNl4mFq2LrxdRMjx7j5HmsKxtniz2kVQ35T9BsIAXLl0L2m/pyN+tc/+yLMGcCQVspO6XT+zhrX/WnUcAZUrJ9KcRV4CuRKJW4NyNYVOuh7FcphRTEcoEzWVzerAYe1ZZzlaLMCfnQksUDK67juATLWIBRS7TAa7ZDiS2w/8gzfdmnBq5/9EievfYzrb3uT2fb3cuGRP8PzP/+fcHL7gCtXNI/eyLj4wQI5D5hnLvKhn5KIN2akqeWGyVCDbaR5C+Ll5+GqZvdbL7OlWdHdSmT3PCLLILwB8RDEEpQC/QNAA2lJjEu2tyTf+71/jvd8719kLgPaPYrJxlgn6doGETq60CKrMQGN1DlS5wgtsEIyD5F9AWoFbN/97nfxkY/8Y37ix3+cV1979QyIPkvpWs/swz0zMayrdus6wXpLcVqK+/8AtehrAgfTznNQ92gxzwLjcUa7cCAErvW4ZYf0jmJccO/2MVujEpP1Wt1CaXYqQRSJaDQmeEzs+fFt62m7QD4sOZp3ffkskygXcZMG6SK4gIgK3waEVkStyKVgODDYpWVeSRobmS0DSbQ8O5lz7ekxKcGD+zVHhw5CQirItxWT2w3Jxt7RNUh0IfBLx9Zlw/KFY8S5krBVYLZKdkcZsTnCzTvs3CKlYlRo8ALtppitAmP7CzkE27uuxgzXzVmmvD+RrCfogI0gApyrCrzKKI3Fh46uiQgMWZ5orEOagthZ2sZS17Zv3pWSed3S2QaZHLmM5Eowm1m2t3ZpFksWTaRpO5ztSD5x4dw5Jic1vo64BDLTFGVOiArbWZbWYkNNbnOKvMRIzdTO0UawvbtPM1tiW4eIAicSyVpMVpHpjDwrKYwhyRKrK9x8QUwa23pUDCgRkaKXIh2MK6z3dJ0npoDODEGAUhFlXa/xHiI+BOrWMdwZUJQDQt3RLGuibcmVYrxbgTE0bkHrEyn2aiiZou9PyAsy3+K9Q3lJVhaU2mM7izIS1wpIEZEc0SWQEmcjArspD4PGesvWaMi5rRHzqacRYExGEoKurnt348mcxtcYESmKAmVgUJSIAtpYYJ2jcx1d12G7hiozZEqQpCLQf1+vSoSONAGGZYVIvaJQRBM7z3BoiLKgC/255WzELRuEKoi+QxCIPuCEREnN1sUR5y9dYLIMpLJEmECSHqcyMlGg9A5SHKOLsqcZhUgIhsDzGKkZ7r8XwQnPbL3I3mXLr/3WXZ6Rf4LN32Sh7vL4VXj79Zyd914ge/RHSY1A7UWEfpN0fkl6ekAlRojiA6TxIWbwdzj6/Es0L1rG71XsvMsQ6j8EWcCXD0jM4UKCIgf1KCmUhMlLJH/E0Z2X+PynX+Sp7/gQ58+NyNqaQ0a8dqvlwd27nB8mnp20WDXkhh5SCoWRGcIIDpNBa8FbSsNQaTK1supa3cwTEJztAystiNaRokdmBQKPEImQIIZEtIFmNqPuOkyRYb3H24QIQFeTRYntLD56Ytdnb33b4o1aVbA6fGcJixPU3LG1O0bIyO7WiLbVeN/hg6NpHEKW5MIggu25w0IQg6Q5mXN4cMxgawcdba8ak2cELZl1NVup7hWXZCAzBpVlJBXJ88RsPmU+q0nUeNuSYkdrPcG2TKeOqCV5LihEn6Vfj4f41mcW0zUdQp4JgPpgXqyC99V1tHbi/SrAYH2l9e89Q0U6E+L21QlI634EVgFS6hV58BGlJXkuKQo4OT7h4N6cFDPIMoTQjMdj3vLY25hPFqTQEn2gl9zsZSI30pJfV5GtOAUInOU6P5x/9t6vXkubAFRKuaFxrb0L1s3268bKEOOmR+GhTz1zDNb75czxWYMD0sMw5GwT99fTUfx/Os5mi9fmWXAGOHFaNetP9zXgSqf8oc0x/Yq2VXEmED3b/AobgLYGCimtzAVFP6dZXjLY2qEYVhRlwZUbNzh3/QkOYqBMjigyolBI1k6Uc5SuSClA6pWmAveRwpAN34ZIxzz+7siDO6/w4muvc/n66wRziy6LPPbYgP1r2xTXn0QOvht8Qgw1StyHMoHPQA5BXetFOYqPM//cAeJcS/5YRXZ+G9wfI+QA7rwIlScVWW+8Ka5Dyon154Elx7e/zOLwIlduvI/t8YDMz1gy4O79lugihY4sRQRTsi8zZFxTthJ1lCAjF8reUV6tql+vvfYaP/MzP8N8PieE0LvAbwBCn9Q421C/HmkjA9zfJ+KZxuOzfTZrQYZv5vE1gYNu1rKYNCglKbRkYAyHiyXGF2glyYqcGCRaSJouoUeJ5Cy+c3gfyArFYFBR06JtQsiIc57ZtMWGRD3UhBgoC4GWgmUXmMxbMqPY2xYMxjlaSdqFp46ecpSxey7n5Hbb69+HgEoR7yOTuWd4tMQbydGBYz4PIHqwakrJyS1LtWUwA4WMkryQxC7SzSwXHxuymDqaWYtVgnaWYyqBrSNG674BKPUNbMpIbOuYz1vKQhKtpWscMXpS3l/kpYAuRVxnaZaGQkrkjiFFgdEGTQKZUCKAygkhoVKkayy27aUVs2pILiPOKLK8oOskwVlSDBjdL5jT6RyPASKJgLMe285IyfWNrtL06kWmv9nMg6V1lsY5XEoIqRiWOfvnRujBgNH2CG8DzvUBqF00yCTYPneO7e0xwzLr5T1DQPqIzjNiSigkREeKAVlmKFXgYsLkOSHUeB/QSkHyvZJA1xJcIiaJRxJTr/QiZUvwDmctOIfMeufipQ3oPEfHgPcgpKLKC46PlyRTENBAQMoEwVFPJ5i8IlOSpARSJmJwOOfwgM4zpEh4m6iblqbzKFFw3Dmu7O8hY4dMvWOiziQ6aYpc450jRoXWCiVARE/oWqzv8BIWy45l09O6FD1tSjgNSpOSwPlE6xLORZKLdASIPYUqCkUikBUVC9srWSWlQWtMCTIKUtLkGXTLgHUS0UrUsOLozhHTOnDl6hWMLMhVjhIaJXdB7yHEFiqeIHxLjAqBp53fJWRPEOIBcEgx2ObGO3+Id9Zv4tJL3P3jl3lssOTSewZc+9bLZE98J3LnMZJ/CepDwj9/ExqHeOs1xMXHSL/zO/DB70RcqsianOm9wPO/47nWSq5/zy3ciwotLHIbpNgG8wxh+TL+pWdpTt4gVR1HneRQR566Lvgf/9df5OJuzbhIRC/JdIbQA4bFDvnWLqM8p1QGpwwnRiMzzZXKsJuZjZHVmnYRU297z0qtUmmF0BnR9rQ1FwJC9WIB0Xq6ZY21Pbg0WhJUjkASOovC09aWzicynRArMRGhFXXnmC87VHBIH7DOYRtLDI69vS2MMfjoEMKiV5l719UsvKQ0fZCgM00MkcnhlMaBqTuyYY5UiojGJYWQBW7WkOWQcg3KgBIIGVGlwVRDVDPFNjWSSFYUHJ0skEJgrSOhUUqgpECekbCMKaG+StlcrrLZa3BwSh9ah66rQHXVFxVi77y9XmA3e1ttvwm2VryX04z0Soc8ni7Ka/391TuIIdK1jsmkpnOeEAMnJ4lqR1MMBKNBxeXz1/jiC5/l8vm3wo7i3M4lMpPz9RzKPkxX+IrjlthIwq5fBU555mLVAptSTx9aTctpsHl6PMXquU11ZtVbcHbKe1+YUxpSb3R3Jthdv///iFfzDTTW3gJ9q4GAtGr23vQbnDECTNDbBgr+lAnc+nifoV1tMs/r6ySt9rlW0VnTlDhNTG+y2avqjTam18hWBlOOGe2fY+/qDU4Oj7Ghr3ooIRFCIylBDhEUyDRdVf4kpEjwC6K8QEyHCDGl2HqUfXWFZO4TeY3pzc9z+RzsX7hCdeGtyO13ILLHSOkedIekz9+E7V3E/g0Qu6TXPg1v/R7kxfeg02eZHz9g9sWacZOx9dhNwl2PyjxC5CD2QFwi2QPCwR/g6tcRA8HCGWK5zWgY+PgnPsulHUeVSaRXCKlRKseYEl2UZLJXDWqFogNkiuyajCrTiFWK49N/9Ef8wkd/gd/73d+j7Vqcc331McbNvearuhufqXiuzgoS/ky1YT3X8aF5/WYdXxM40C5A67ASvJYIZ3Bth3OSwbCgKHOEKVBKkKmIUeCDx3cdrnUYkWEGFbkCWk8Sfena+0T0idm0oywF0Um8C3gb+mbTgeolAwcGGRPzhWW6cKhcMxhI6lVpHpHIZI+uTSE4Oe5YhMThA0vbJKQGnfcX++IgoHOFlqJXJQmR0CUWhx3Xv2NM2wSSS7gYmc0adkzBzM05vztGyUgMgSQUQWpmhxN844leEa2naRwhOYRTZFXCKIMQK/UOFxCZoO46MCBkryAiiH05M0EKkGLAt5YUIsZkKGPIVKIcFJjSsFzW2MUSEyyZMSxmS1rrkBqU6lWJuuQ4OT6kGuSUpUFkvWmSkgkbIyiHkgFjJMYItI4oGdjf3yEUFSFGTJFThAjeIRxkxYDx9jajcYkRkWhtXyGwDTKpVTkvEumb1JTOiUJhbW+8lGUJpR3CaIJ1fRNW1/UVHGmQOqcos75ZeFkTYyDG3sFWGInMNLGzSJEwos+CBSJCCQKBLkDdBjIlUYD3lug78iwnUwmRC3wMdF3DclEjhKEoDCIGXBdXlQ2HkYloW9pBges6nLV4B0IpRqUkrwzTeUdcZReUSAgSXbukDoFkBMulpbUBqQSZFDQuEG0HOvXUJLdq5Av9Qt85R3C+X19lom48gwqsdQShUFKhsxydGdJiiU8CtEGaHNtEFouO2p0wP57RdZaxGvCO3R3MxX2MACXGeHUVKJDyBKQn0RvNKQra5RRrX0LlghQuUehrvO/738UXPve3eeU3T3jvM5Er79rGPHEeke9B9xzx5NOk1+8R/uCINFFwf0raH6Ne/EUOc8vw8luJytF0rzB51SN+z1FenHLrt1oeff8W+4+ch3CZ9ssZh3fvkX3phLSjme4WPBjuUzz1NFd3JP/o1/45r48UN85lXLg44PL5c5jxNlvFFsNBhkiJmCmczkkqY6fIOV/0wOC02bVfiGP0hOhB9e6+QmuUMXgl8d7hbUDJPjCIMfX+BlKSZb2akNYGYxRBC0TyLIMjREFmJEIrXASfQq/IZfoKRW40SUiaxnN075DBsGJQapB934zShigTk8mCaZNwpSbPFIXpdccXDkxRMhzljM/t4q1lWVuCC+wMR3Sz416SOEms8xAiUgSygaEYb9Mu5oTG9/dGY0gyIYWitR0xRLJCo4zAuzNL3SrYOxu8r7PXrIOndcZ43XTZF+bYkCnOvL5RJGJdkj9brF+9Z5Ml/2o0jP45KdcBWq+c1NQW5z0jH9BFLxkttSQrDINhxXiww7Of+zh/5d/6q5S65OLeNXKTnwZpnKmIfL2NNYBaRfin8oqrX2tqEGxkTh9SkDrz3tN5/MqPWFd/4p86Dn0lSG4qO2fn52Eln4e+1jfuOAukOAVpD0tbsjkXBT3d7UwyeeMr8fCOHiYmsboOThW7Nh+4om6tmp1XWe3+I+WKRqTIBmOK7X30cI8ulbzxyvPcfOkBN8YjZCFRCIQoiOwgMAhxgujFz0kpIpLC2xkh3kaZDNtukxf7PPL4dQ4f/BIHn3qNJ58pyB+5iBxdBZlB+AI0XyYd3iF9+TZsnyceWRD7sPwEtR5TXf4eYryPnU9pDxcQZ6jqHg+eO+Tqe54hM5dI7Q5+3tLObqIOb8J4xEKOsNVViu1rFClw+84rtLVkSzn2Lu5QjvdQZkCmCzLdA7ig5apCIiiEYJiZleoYvPjCi/zSL/8SH/3oR5nP5/0hX1e9vqIUtxZCWIO5h4hG63neXIdnrrmv13vGv+DxNYGD8VbBuDRMpg0nMTLMNLnRHM1bvA3IvSF7O1vIUlLPW0KKGC1RWmFFIHWB5dGUQRFZzhzBCbSRjEc5TRuYHrfkO4bDmaXpHELBaL8kRMd0YpHRkwWQPQeF+f0Foz3Nzk5Grj2zLuF8giKRV5KDuzV3TwInJ5GQIroQqEJi54FYJ2a3LTrrG31SCr2MpYI7NydIlxhUBbJUtM7iOs3htKZIke1hROqSLmjaeeTe3QkXRhWTE9dnwgUEIbCHC4Z7IHIwWlPmiqLsm1ge3HnAzoU9gszwrQUhKHeGveGRB0FEAdnaAMXVRFkwLHJMMaRQmqAFrqlpOs+9O3fZO7+PTxGQvZKB0UyOp+zuVT0okhEpI0oZbIDxIJIBIi8p8hwtFN4JtIR2OWXWWozO2d4aIVNAxDFeZiSg7hpyERAhYZMmyCX14THjvW0QEZTvew6S6ANuVK8vXxQYVWBDJNoOIxImCYRUYDJkmfeqVZ1CuNDfILUkommTYLGc4ZsGbxckD846ll2HEy1FlTO/M2WysIxKhdB9kqUoM1AWIQuyAnzdsZxPOTycsTvaRmeml4sLnmQjwcOsPeZiqTi+e5fWaRYLT91FqtxQ7SgyBY10+M6BzJGmwuhE6DqIAYEizxQJcCGiJQwGObYLSNHLr6XkGQ8KovAkI5G5xLc5wSWCC0wnDq+b3sxOKRAJpQIyTyxDIIga22i0Tihlmc0WNJMJIpbEesndz97i2qjgbW+5xAWjiSLh5bcg06tIfR6RKogzaB2j7aexd34Oaa4wGD+Fn9bc/vLH2H/fj/HEpT0+cyeQflCir2Yg5sTFr+Ae3CK+0MEnIiIUpGhwv/oy7Zu32fpvv5Pnf+6Xedtf+zvcXe7z4Ph1nnxv4OCTno//Twt+9zX44SuO6pFdXLvHzZ/9h7yxVNy4qrnwvn3u5hc44h08celDGCI/9SMdv/RFzYmUjHO4anYp95+h8705X14WzExC5ZIni5zzec6a6NBXC/rMdfSe4C3eW1IKyEwjVe/XkVKvfBGT7Z2MhSRKg8gGZKLBG4WUCUVC5xo51CzuHzEYZ4jJAqUHqFwQnKdbtpTjjJ3dHe7faigHBaUsCdOO26++wcEbd+Bi38gslO77S2xk6QtSauisBaFIQpKiRBnF/niLa0/skJVjDm4fECYThA+cuzTiJCoKLQjJUS8bvLNk0mNMZLC3y/TuqtMnJVKUlHl/UE5mlpAEwxihlDj/sPnVWWqFWFcCQloZ6q6O8KqJOIbe1yNtgvy0MR5itd1a0nTD/d182ObHKmu7/uAz3O5V5Ucp2ZvLxlVVQURUFAjRV4SKkWa8NWSwVWGqXqyATvAtV95BVQ422vHrhX79v349jY007Jrnf5ZPdHa7M7/X2XwlV2p2Z/oDzgKGh1yMV8FoT4kNm2D0bAVgXfk5y2namNltAOMavH1jw4O06ms5paI//P+cAt2z58tpz82qPIMQq8rAmfdv6ELr836zLRv60HofaXMo+/VcbLRvswAAIABJREFUiN7LRmpDnhl2r16j2LtA3Vhu3TrGFJf4lY9+ksev7rI7vEChISKJ7CM4RMhdhGpIqesr4GZImP9ThL5Bnl+jOb5Jm2aU+0+yO9ji1VvHyO+7jqhKUroD7XOE+ZfhaAJfamHnGpwcEj7/R0R7Dv2j7+H+b32Ea3/lZzi8r9GVZvf6gPr1BV/+g7t84dXEn39aMK4eoXnjFpPnPkbTGXbP54ze9hiH7UWy4p2My+uY6Pnz3x159k3Jl1+/ybftCHb0FrLaJwSP9Q0mz6mlodKKsTYUZxyij46O+Xs/93P89m//NvP5fKN8tm4gXs8jq3vW5ryXksSprO+6ryeldLo+rJ4PIWyuna9mmPfNNL4mcGBtpCgN+6XiaNGybALVqCIvA3ZpaU5mPOgcTzy6gx1q2uMlUiaMFpTjnoJC8PgU2N41vbGW8+REjJHITDFSEZQkH5VEJWmayGTmsDYitUOLxEAmfKlofGR2t0GMMzITUaJvuJ0deY6XEtsmTo4CVoC5oMhzQX3f0x0FciMRMaFSr1hErsD0PQ17VwYcvzxnOWvAOWYPPOIdEt/2ZWxUL2H44HDOcacYS0O3jFS57EEBILQhG2mSA2EUyUU8DbWwKFEwHI8xKsO6QAiOEDztUb9Q58WQiOvNsVygMorze2OWdYOfzfHWo0wGosT7jq5p2Tt3jqHujZUSkeATjbAU5RiTEvXxBO8sSUpUVVFVAwxg8QyGCpNlONcDodv3j/C2RuQFSS3JqgGj4R7BC+ZJgTF03uIT6KQQyTAYj2lmJ0wmh5w7f4GiyGnrhhA6siLnZDIhz0cINK4N1G2HzDIWR8eoaMnUkM7Col1AkTMY7rG9e57DZoauZyQfCMIwm8xoJg2D7SG6khRZBlL2ClouskiaqBNmVJINK4SQOKBrPDrNkdqwmDsW04BfOKZ+SlnlCDnA1w31rGVZ942othyyXCxJHkTUDDLNUDsW8zlhZmAwxDvPpOlwrubqpXGvJEHCC3C0ECIiSqrhkKQCk3pOZSTloCRLEKJBJ0tSgSrrnbJnXUvdNAz2RkRbY71GKksKDS4YuqZ3T86rktTVTE7m1IuaEC3VrsbOPCk4wvxNfvGTnyZcu8B/9mffxjjNMEzpuIKJL6BkIKv2iGbJ9M4/YOeRvwRIpge/gcpKHv/gv8mX7v0tdj77aX7sPxdIEsk1CHlI9ydv8urPOEohKO4lxk925MahFZj3eSb/6ON88Kf/U547+gjbT57jxuMf5v7v/wPy1vNffyLxl//jMWGs+NTHv8gXv/Q5PvoFya9+5BEoJDZ/P0+a7yPGHD3/PZifY+/pH+Y/fMc2SRgWPvLK8ZRf/5PX+PbKcHLlBrEouFFmPJIZBkpuSsukvjoZfCB6RwotzgWkEEThEaZXbhH0bt7J9xk7mSmk0AiXsHiis+iqwmiB1n1mLqxAqe06hFDY+YRSDqjKHKkNuquxi0g23MJJCKFG5x03ntxmPm24+dJtdsYluhgRZUkXYDFbYllydWeIlhlFNcIUmsJYtitNezzBxWOMhwt7W2RlSbWTo8SIumswq2qJkoLKSLQK2K6lGFa8caumrqcUhcLPG24fz9gaGBAa2/YVpC6cLnRr+tA6U3pW2WOjzb7OtK4ybyF8Bb2CFc1q9aB3QV5nY9evr+le/d8bbjcgZA8GYJXFVqvFffV4kxfvRdN4x79ymRdfPOJd7/4AovB87vk/4tav/30ePf8YeZafUgXWAdiZz1tXEf5lDwEbNaKzz27YKGcC8A3FZV1Z4Az15xTZbbboH5ytDHxl9Wa1ZVoBCaXOUJVWmdZN4edU0nP1wX+6LPENNs5+/TWG+mqN2xvgximAO9vcKoTsT9I1bhBrczTO0OYewlubCsE6Q92DYUESve8Pqa9Cts5xcnCPUXJIBUEMkaWG5ha//KXXEMOc91weYrBIWjw76HRrRSs2RDelq5+l2P5BUoJ2/kuUO+8m6DGz+f9GefBx3v8TlyG2iDQjNTexN19k/okTDAZ1J1K86wjpE3I/J+y0uM8d8fi/8ze4dfJPuPTOvwCTS9Svfgy7SPzj5zr+4k89TeNmHH3uN/nCC3PuzSp+/CeeAS0J6gNc234G4Q8Q9hUI21Tn3s33ny/g3e+nDoE3JwuODhdcyjWh2gFtuGQM1aq/YHXYiDHykz/5k3zmM59hPp8T170D9PcRpTRnm+qt6wUYziY40hklo+DDKZI4M++n98L/X8oUgJ3McHk8IJWC4RZkvmCyqCmKjK3dDBkjQSSGW73D8H0XSF1LLhOaSNc5OqXJZS8nOJn3ihODQlEMc6bzhG8SVZY4OPAcNYFYKsZjyfReR56gGmrGO4o9IZh1kRffbBilwMmBxa5cZwV9d//ueclk2lM+nI+000hoEsEluiZglCAGkEFQZIKLOznzNvDyJw8RIZFVGSjB4GLBK88dIirNfB4oc0teZJgiQ0dF6w3NbEGTa4ROYASZSGRG8uBeg1YdWa4phzkDJHnmUOMBSSpS1zCocpIoOal7mko9P2YwGDHcLkmdJ7nAdDpH0xFDAmcJWdn/lyExyAzl1jnqyT1cO0MrQ6ELhiYnJkvTZWSDbaRb4lqLWzjm3ZQ6ZMQQmL95jGOGTYoYEpcGhv1HLuO6luWsobEdxi8Ybg+4ONrhwdGSmGVUucToCLHm/usHOCRZZqidR+cVsRhTL+eURpMPK6IyBNLK6TfQNA2kjnL3PE29oBMBZIaShiQVd+7cJChDmUmksvjmAPSIan+AMRW5KVguazrfEZLmsScuMnvuBZZlhlaKtra0taUYCIbZmHK4j1Ee7+b4ylKGwP3DJfMHDVsXBA5FlWfsl7CzN+buomPZepQaELSiaS0H05pHLwzRRUVuNGarItJnaH1qQGRMJnPIDZ3SkEtK0zHYzlgsWka7O3Q+UCApc8PCSbZLj1WS5BwqaYq8QKuM0fkh80XNbNqhs4KEROuMajDk4O59isqQFTtIoZFIOhcZvvVbSFs3GFzqePCpQ+qXXuQLv/krfOy7r/BD1SGk36Ph/Sx5HO3uoewbBN+gd97O4sGM2N2m3HqKcjQjC/+Qd176MY5ufZL6C5HymkRWM+zrsPj7joGH839DI4RGfyrAswG3TMy+1FD98IBU/gnveMuToL4dIZ9g9Nhfwn7or/MLLx3w5d865sJ3lLjHS7JrV/nwf/kTVMUnSOkuJlwki/c4uf0qn/vdX+SXny3563/7nVzafppMGbZV4qntjK13P44sdjinM4yAaQhMQqAQay5pop4tQemVpLUneE/0HoGl38KQSITQ4lqHjwld5kih0CKRG4tOiuNOYKIHC4mcsKJM1o3FFBnedaR8i6gLiixntL0DNvDGzXsU6oQkSoxSVGWONord7cgdd8wgCyAtUWuyssSMzpFmEp0iOgGLOa72qGTxFrLlIcuyorOKYAN66ZDZgCzPsM4S2npVpczJRMTjODo44cG9B9hlg583TGaBVkjyKkcowYVSITW0CebL8NA9X0nZU68EWBs2bKBTF12F0RIRThU9ViFUDwoeqj6cNlZy5vkNueeUOYQAtOpVW8Tp2k+IfR9EjKnvkVC95OpwaHjiyV20gRQCtrbgA7Zx4CR/5rs+jFZmRZERD/Pt/6+ulv8vj3UDrJRrHXV4CLikPgu9DmJO37fqE5Gn4Osslehs2H62wVIJ2ZtfpRUAWIO0r6gwbD588yXWf4qHt/0GHxvQCg+dIxszP3H2vD5VfVoDOLGhq/T7+Wo9O2vAsAYWayWptFL+Om1+PQVfKcXV/cthp1OWCYIEkdXceNeTqOxJ3vjDz/LCSPDI+ae5rmfAq3jeiuMKyh8g4qKnFeXXccuG6B+QD74brd8gkzOK4ftoF7+G+9/Ze+9Y27L7vu+z2m5nn3Lbu/e+OvOm8c1wKofSkBZNUsWRaFmR4JLYshMgiB04RpA/HCFRAAMW8oeBxDICxA6cALGTGDakyBYjyLYUqlGdbTgUOSSnvXnz+nv33XbK7qvkj31ueZQd0EYCDIUs4OKWU/a5a6299698y+0Gs5Hi7S3cO3vYrx0SaUn6w6sIlyO/MYP7NXa/wpYt+mPnQV3jwpnnQDwOgw+TbP4g4+d+gf/6B+7z4LWr5B96EmFi/vhjP8rq2T+GDK8Be8gwQvr7zO5/jpvvfYObB2f44z+0yTDaRKIYSLg4StjIE6SKSEXP8Su8p3GOJPSSvk1dc+XK05RleSpBPuU/cdTt8u4ht2Sl1PGaCSkQ4YikfNQZOH0ePdwNdf5h+dM/iuPbSg6UTpBCEmyDbA1t27K+MSY2Gtm0tEVFV9U0+zs0jccflKSpQnhB0/XVnXwlQhYdkXeoOKJznuChs57gLLPOs9hrKTq3bPEIWq3IRhJhAlXraAtLWVvKDmTd0eLJR4KilrjOM0qgBGaHHpML4ommPHRU+w7X9f9LtqLwSuCbgLQOIVruBUGSKfQgRvnAMI8YDiKasmNtI+ewcpjekrdX3JGwMs4IdULQMVXdAKGHAgnJrO6vDhtbK7Suw+NprIVIcHdnn8lwTKYjhOkhQMPYsDstyAcDEA6pDdZ6qrJGtg2aFl/uY2WMHE2Qce/34HsKcG9sVnVYIRFJxDiJiGLfmyFbSfBHUAtPI2Pwjqq1yCiitY7GerIoJRrkQODOzj3Gac4gMihXEomYUB6Sq44Gj3KiJ2yWDenqgGFXYImWF9OOOJJATFstEE6i46g3SxYS6SO0LdEaksGQZHWTurXUdbPkLQR0ljCdT1nUFq00cTohThO0jth/sEcrRQ/BCgIzWqUjJY8TBB0CSxugER7lQEUB71vuHJbUZUcIBpmk5CsSoQxCC3COZJAw0hFe9thz4z1dt8AicEHgI0XpLGfyBGEbtOyTNdV1dI1iZkuEdrRBQpyglMTbCD0cMY5qynsHOBXQ0mEEjNOILB9z9c4+1aLBeo1SEekgJk8jbNvB6hCU6M8zH6jLOaP1EWuba8y7jstPnGex8Lx3t6PJzrD9wgusb0tWn1G8+6tv8MZXvsY/+C/+Hj/8d/8impcZil3aUFKLhE5fYmjuov0DvP0abatpDu/hG4ea5KjBv2BwUfKP/07H9/9puDixWBuoh1APIXrkDGrwKYJ6ld+9+Q1+8w9a/vOfNPzs/9bw538spRXr3F88wHvH46NL6LWPMeKX2bgdePNqx/2DKekg4tJTX+bXfufTjGzL51/7Pb50U9IoeP7JwMsfrvjpv/HXWU9iqrVLrD72AZ55+iU+8uTHGMUGtSRLpkoQvMf6lrqacuv3f4bhI99PMlzFGA2+pa7m4DqCisEFEB1KgZK9GlTbWnxTIaKEoCSuc1RVA9LQWkgSQzmb4toaQkApzWLRMBgMaWpH21hMkpLoAcHOWN8Ycf9BRyslrm5QtWW0mnPv9jtMJgOkkCgdIUwEScracIwbpnTTByyqFikNiY7AKmyrOZhazm1McElObfsyyMqFdbrpDtiGKB5TzCumewtUDONNg5A1uaqYZYqmNJSHLVbUNCGQTyJmjcc4iVCC6F+DXTmGWz+EAwoQPN73QVGvlnSi2y5FX1mz4YTkelJ9fbhOL4/ecpkgeN8H/cdHEyexqA8BvTRFi2PFaCXm/CMTnn5xk9IFdCR569pr6ETTtZ4synj2g8/3cKLjivxp2cKHJQzfH2MJzQr+GAd9pILTiz70CULPfTshh4twMqunAxp/OoD5FiiEX/ZfjhMuyUmnaHk8vD9e234cp3QPz937byL/jcZJ/+Vkj8plEI9f7mOOfCZO8Q2W035ckz7VDnhY0rR/7AjG0p9CR4n2EnYn5NJr4qjLJgmi74UKAfkgoavmNLZj5cKj/MBf/k/Z3Mwp9IAv/OY6v/0HtxHVl/iPPvUckktETLE0OJEhlUEzQ4YFwV/DWUNXXIVYY+KAkK+jh4Yv/uMHfOjPGuJkjlcNdqjwUYKaPIdUnyJ0P8fnf+dNhPQ8/ckBb3x+ygvPJ7RhxKx+QKpXGag1VPY8Cb/L4OIlrl+dU82nrJ67ijaSg5v/nMTXvPE1w+fe69jcinjs0YQzZ+7zS//0v2WSGIqVZ9jYfowLZy6zPd7GaMWRptpICJqm5p9/5jP87f/ub1MWC2az2XLtwtJVXaKkXMJKPV2weO/665M84XecrL84ycGPoI/htMSvOJa5FXBCJv8jPL6t5ODG/QXbqzGjFU0RDFmmECi0EDjhQFhiETjYWeDwpIkkTgJ1G2idJ041vnU0radeVP3N1UiUUtjWMc4V88LTeY8PPd68bQQDIXCdw0uFt5aycswWjqqDpnIMBgojIU0FxBIbAl4KyiIQGYHoDVLx9AuuTd+OllL0kqmqv6i6su3lAT1EsQYEtvVIDGkWYbVARdAR6JyATmCcZBiBiFeIZwcYGTCRpHUdbdtgDOBKVPBEWpPGEVGaYIOm8w7XeUrvcHWLdR2RsBiRUNsWhMRaS9u2aAldUyBbiPMEbyuC8Ogo6z+nK2idQxmD0gKp+mBYKoVEE3SMVZrKCuZVzTDXjMZDFlX/3pnsPSS0EpRtg6piJvmYlWFKohTeetq2JB0mGHpsXrCBpg10LmAMKNnrDgdlMFr1cw9URU2exBA8Nmi8VGjTYgYZeZQikxSvI2KhkULigqDtOnSiiVqF6AJCR6h0QDxMsEWF8IK66bAu0AWB9VDXHegYYzt6xGVAK48WgbKqiNdW0AnEweCoqZuWECBOFEXRO7E64Sm7Dld3tA6mZdXDIdRyr6NwTlC1HamOyBJJ6AJtUTEvGryASWJQqcYZQIDWMVk+wAnBeFQxL2uCbXCuhSjQVTCSEivAdh3BS3wXMdspmJUlo80hne/xj7H0RCZivLZO6+GgaGhqSzwacW51TEPOwVs36a7N2bl/lcWNQ7r5Hm99bYe/9l/9I/7OT/0F8lggQoN3h9StYM6ECXcww8fRaYptoT68zoOvfY5JdA+5GvjuP62wcWC2cERAYQXXpvBE/p8g4u/m/3z9Hnujt/hTf3MT8/wneCX9ItWbX0Scv8o4+yhSBELxBfTgPNna49jsdRrXMN5OWb2g+fLv/Sa/9fmCcqfl5e/Z5OVHEkq5wZkrj/Hixfe4/ORjDJJL2Pgcu/E6Pl9HEJDe9mIEywAnCE8QAaEFa4+/gpMxXdfiXQvB0nQtwTaoSGE7h5IK5wIhOJRYYqhN301oqoquKGnKGpMk6CRD+RZXFdSLBUJJojhBmQHtomaxP8VEGd4FrA+MhhHVrKStLekkZ1E7Dg8WxGJK5DucGVI56DqFCjDQLbpdYERJ6xuUTug6R2gLRiZCGsGD2nD/TsFoQxPlOU5HHO7P0W1HCDG+doQlbMpEEqkiQnC0dQVdQ1vXTBclaawIwuOdoEPipGSUGrZWT24FxzXiZXDZt+jl0qhsyUEQvRz1UdXt6IYbjqtvLG/OR5VQ8XAARo++OE4MjmFH4fjYx4EyAq0ELoRjdSWtBRtnMp770CZRLGkby2g1pqWkaQQ+OLJByni8svzcpxODhxOE98s4DQ06Ugk6ij+P1uQILsFx4MkxTvp0qPKtmOhjjgXf2q05CaaOkrjwLa+BU4FuOHHrPSIs/1EJkr61R3L003GAyFEV+qgB0CdU/l/x7z8EWQsn73WkwPXQlIWHk+eTODUskz6Fdx7bWaJcsnJmnc0LFykOG+7N5xT1AWLRUM93+PxXW6qq5K/+6CsYBYSG4Kf4YOhIiJij4rNIHSGdwy7exB28QaRvIGN49BND6rZFO4ULjroTFE3MSvTnQFzh17/x80y+6wwXLzxOfPYDnB+8Q3vnNxArG2Tq4xi/AOZIs4HOLuPMq1jnGJ9bQ2Yl16+9xrUbjrOrH2bjmX1eXG+JVs6zuj1mPZ+ytrFOYtbpoi3mZoSIBn3HI/gTSFsIGCV59tmn+fG/8O/zN3/qv1nOXXjoO8uk+QQKJ+nFEcJxJ1MsSR7+lMHdcZuUU/v9VJXi6Pz8/2FFQOMEVkRkWUacDSj3HqDoUCbGZBGJsgg6ag911SEjha09LvQqHkoLuqphsWipDmsiCUZLWiFBQZpJDhe2D9Csp+gcFsGo7OUHF5WnbQJl4alrj/OADXjrcYCTAivAEZAhELpAPBREA0Ezg2D7gFZGAqH6Fe5bt/0mSKKA0mAEpIkkjQVZrIlNAq1lMDDoSOBC396uOvCFA1EzXB3hQqCXtJE471ABlHS0ddFXH0SEtBHBauqurwh1WqNEr6DT1iU+dLiBoWhaTOdRrUUFS7AO6QE8WaZRaYSXBisUXkl8U4E0oOTSSTgQlKCsS1KdoyQIHREjaYNEL9WE0iQiSSJc5zEd6CQiMopgPcM0ZphGaNnzTQKBrm3oWovDE4Kis56q86QKoihaqr9ItNG99COeJDaYSNO1DT4EnJS44ImzEVkmsUJggziGG/QykwKkIcsHtK3FCU1QGi97hRklQepes1n7gDAB28x6AnyisMH2nBINRkdESUbTNQiliOIYFwJdo6GVBOexjSVJ4t4sKDgkjrZzzOsaHTyRNkgdoUQAB3XtEQZQAeEDXfA0TY2OIpzofReQvTusXmLgpbUMs5gQPE3lIHh0bJjNCrqyA0Tf4lQKEaCYNzSdoy4rgo4JzoEKDFKFdZbpwuIbx+F+gXYGRjk0+8y/+Q6zZsqivMPG5oj88lkO/aP82r2af/Tpz/PY4y3PX8oYRr306mE9pwh7FG3FWChiYkT9gOD2qHb3OPyS48wVsFJABLYIFE1P/hXqaRAXyLc+xnBryDPfM8HL7+Xx8ZTpz32WsHed5MkxZqWke/Bl4snjRBsvUadvMZNzVnLP2XNw/14Di8D48VWefHmDcX4Jq55CnXmCC4Mdrly5jDEXgBH3O8V+FwhhwfWDW0xm75BvnEfFmwiZ95AgpRltPUG5KHv5UNtzcTwCqXqiuDIavYRnOLvkIXiHVIYQPF3bUVc1XesxiUe6DoFHC0GSJOg47kvccUZbdIjQQVfSziVt09AealQHRipSbah8TVtYam1B5agoIU+HHM49Vdn1nJKqZZQLgtDgFXK5v7W1iLZBO4EMIJ3DBEek+/2rhcbbBm8tTdPRKRiOE9q6Ye+9W9y6sYOtK+p5TVm3SGFo8CyqDpnEeA8OGGbm5IL/EBRFHOP1lRTL4H9ZyYZlkNhffpw/rXC0fKOTmmr/buKoChcewv5L2Qf93nOcIJz+QEcBvlYCYyRRrMmHEetrMdNpTVO2jEYGLxxtGwg2EGtNFEXfzi3ufTGOg9MA4RgityTWE/5QwN8/92SxxOnJP/W8U7EOCJDLNs2REouU4rhi3b/+OJQ9Pv5pIdnjD/uHEq3v4CH66nGftJ4kUhzVl/vM4BhKdARZEcevOnnFQxAslolCECddnIdINidJ3olPQliq4S0fEwIlA3XdELteWhvXcXjjGjvFlDgPPL65Srd9lv3a89os8JlX3+Cx855H14aI0GFtQ+c6GqY0dkoGKJGAO0DYPdrFDs3OgvGjcnlu9lBMawMyNiAeAyZkKx9j+0LF2tajwEVWB4rmK/8Mqpx46xF6/519VLyBSj9AZ16lChUrQ082ELRdQDSgV1fZupCwfn4VH18kSocMTcHm5hmUXCEQs2+XkCpfc1Dso4tb3D8QKD1gfX2D8+fO8n3f/738zM/+HG988w0623FEkA+hJxwfBfHHSfVDbI+TOT9xDDlaGnH8/USxaMlPWJJH/ihs+/+n8W0lB5PJkI31CeurGdn6Om/f2Uc0BSrVDMYJJhcgayyCw/dKDmcVaRTQeUQySoi0o5lWFPMGW3QYI+h8oGo9ydgglWZRNHgCtQvMqt4cp5h50OA6QdEE2pqeE6BBiUA57yCS1EJQSoHTgdA6lA+sbWjIBdN7AVcHQhsQSR80Bge0AaRHaLGELglGmWaQSPJUMcoi8izh7o0psfG4yCCDxHeBrvW0ZYfynnjcUDQdoS4xCpTucc4mCkjVZ7m2bSlYoCQcFpb1kafLBpgkIjKCtnZUsxJCxLxuSIInFxATsMFhlMErT5wZBpMRXkYsKoczmqos0UlC1TjoHF7o3hOia0hNhhCOOI6Js5QsjSkP79MsPMMsJU5Tms5jO88gTYhiQ1NZ0lRgZECKgJIeTExZFjRVi0OhTIILirppMXFCMBrvO7TSSN0HYTJ48jyCoGgai+ssViicEJgoRUQK5ZplJSXgvMN520MAtCY1OTq2NDZggyd4R5zGxFlfxW+q3tBJJIKumhErT9Catm2R0hG0QaiIOM84vLeLMkO0iHozvFThZYotO3ASg8FIhaBFmw7bVHhr0RKU8Cjp0VqhhSd0gdK2dNajZYcMvblckAmd0kRSEQmBWuIWy3mDKkvSLCIkvTKUl6AGhp39BdNZSRgMUdr0pCl50rKeH87QaQpB0GmJljH3pnuUpGRSUNYdQdRIO8fODzHsMkwEly49xrMvX2Lj6Se5kzzK1a894NO//D/z1KzB2Ud4evsMsYlp2+ssXMPtW9/gTGhIhSTPA2trCisj7r1asUpg/SVFnAQWTWAe4OLTghDehjDm+z75UVr3YSogNedou6cIxa/jyhY23kTmBzT7h6i9z2C2/3uizf+Lg688gAcLBnXCS9/9GPe+eItz37vCIxcmjIaXiZIrmPg8rX2Srq0J3QIj99lWgQ3jOazn3Nh5E3v7Nwjd85jh85jkceJsCyUzBJLICLrG00N5+8TLSIUPEhNFaCmPnTCDs8vqnSJ4v1RwCT3TtXN0zQylI1SckozGpFlKtXfQmzomEdkgRnqBsy3zacG8rLn4xKPkA0+sFZmJGMQpVa3p1JBcG9a3tglywf1ij+lBTaw1Jh1g4gzKvkuTJ4YYQbO7Sw6s5jHGaDQQSUGU5HQLS+drWhtoQ6CJJGIYsbhxj2tffYvbB3N0cJSdp2jplasIOCUZRQbhwFmPQ50XJ7HdAAAgAElEQVRc8E+Vl5UUGCWxzqGV7E3IlmX/3s9gCW2BY4JgCAF7CpMrAI6SAXGEzz5x75WS/lzTAueWhONlx+AoqlUS4lihlCRKNFluiIzAljUqWBaHNflAMZt72oVFEzFOJw9VZIU4DYd5H97axcOB/LFM7PLraL6+tQtw1Dk4rnb2L+5VjEKAZddn+dRlsCtOBUAnH+F0h+L4b94THuoccOrnkyDqO26cmscjI7PT2+LEX2MJJQruVHJ2BH07pdrEUdx/qtp8fJhwvLZHYejRNjzCtx+939FeFUtDr+A9Gmjahs46qqJgvnuflbV10uA5d+4S3/XMecLKJne7hOt3DvidP/hNKuWJ5SOsDQaEUGHdlMbXHEzfZYUGKWLSzBJnEa7JWLx7m0EmGVwaIJZ8TW8Eo3OSEG4jRMIr3/Uj2GBxIkIJ8OIC1HP8XgfrbxBICcUBor6Gzv8aajTmYHGD9almY7JCdn4Te/8G49UbZMl59PASSm0h5ADvBc514OZIscuakFgchSuZLnbQO6/yS7+yi1DrXL78JJubWxwezrl48SLvvP0O1tlTCXXofZX0Cc8onIIF9etxCr64ZKIdLdhpEQZgWbRY7vPwHbjX/y3Gt5UcnF9JWctTOq+xUnBhY8y733zAZAShA58IBusp2IrDacG9OxUXzids5oIhgVgZqqrG24DvHJ3roR/BQ7lwXL/nmM4sK5uGyaDHplfWc0hg+sCzuS5pW2hsQAMm9Hrx9b6FoUKY/u5U2ECz8Jzdlrz4UsRX320pDhxd6Y97s6F1KKkRAZSAyAiClvjSkuUJw0wxGEjiOIDqGK8oqrZjNgsEJMH3fIgoVyATqtJSWI+yHtt0VE2B0YLHnzvLxiRhPi05mDc01jPSCiM7IuHwtgJh+oBaaAwxt67fJs1SzFKZw2nNaGOFg2nNaJIR0iGtSvtgR1uUivFRhQ8NZVVSVT2xIhGezcmQNBvipCZJNFEU06YRi8MHJEqj0rznUeCJI8k4iyiKkq7pGG2tIUWgtW0fzMcKaQVhXtM6gQr9hStRHaOVM72xigooGRDC45f4PhmnJFqB6qiKCuG6JU9ljk9X6EIPV9Cy//LB4WxAJymIgNEarEXbjmFkUDpCbk6w5YzW13hXIjpFVZQEI2hbh6Gv/teNw8lAcVizmBWM84CVBmzPJ9jcWmf33hQ77bC1RVqLpKUoa7QVTCLN+UmCVxKMIc0GFIVFyIbOSYRzSAKj4Yitx85x835BrDxpLAidx3U9BG1+sIvWjiRRxEoTDTWdCBx2lvHaGtNSgYgJXUvX1Tip8DagVY3HUM1qdJwgZMLO3FN7RXZmDHVJMsxJ1tdIViY01RrbH/8Yf+npbR4ZDxhEBiMFOjj8xZQ3P/FfcvPgNT7zuS9za9ryp158hsfPXyI2D3jh0VWqbo+3bk+5czAllA3nLq3w/E9W3PqHDdPYEy5I6kowPSN5+hVwi/8FBrcR+sO08jHmdg0TOu4VVxi8PGE8LDCTGtQ+6YpDXC1ArPDic+f59X9ynTvXD9iZLFj7YMMTP3iGnc/do918mkbP8O2buAHs7+5x6/7nycMd1uI75MMOkxmiTvJ44ZAXVpld+2VC+ArJxkcZXfohjB4QVE7X2SUJXiMAHcB51e8z2yKTDCEVwjq6zqKTBC0lddtBoA/CXYVAEQQc7leQRKSZJpKBZDKkqUpi0dJFCUJEtJWjKBdMdErrOvKBxqSCwaU18smYb3z1Goc7FfFkm9wGoswgY83Bfcf5zRXasmCSR4TI4uqWgCLeOoMtDkjtnG7eIs0IbSJkbRFK0N6eI1dzynKKzhOiNUVrK6rykJsPFuRDza19y868ow2B1GsmI03jOtqqZjJOyBLJzP5hbMRRUVob3XdYY03d2D5BoO/iaSUg+L7yv+QKOB+QBJwUJwnYUQC0DI6kAKNVDxWSAm16eWutZI8RtqGXTkVglCCKJGfWYgISaSTZyBAbQXFQc2ZL83bZkZ/L2Nupqacd66trvHDlY8cBbDiF13j/UZFPj+PMDGuXJHEhOF3BBE6RYU9edfR3xMOuxkc17tOtiRNjryU2+3QywIkb9vK3hzoRy0Mck6ff/yM89O0PDQFa94UB54+62MuHRE9c9d71BZ9l99GHI6ndZXfl6P2Dp+cm9OfCQ7C6ZaIBnCjjHB3kJGvj1AOw5DH64JFAlmfko5xsPGT7qcf4Mx95ge3xCC0lkuV5txGzd+VH2atu8tk33+SVCxMura4zyLZQcsHWyojOH3J3b4p1ByBTBtvbbP3IjMPfvkcV16SjhFYY2jVYv+AIzT+D6AdBPIYNK4QQEWgp7Fmiy9ukmUIkc3AWzAKKPSDj3LnH+M1vfp79wrE2XCO/NGTtyjaLd9/GrXwQ6l2CkSCGVNWcefEuMXfJ9HuoqDdwNV6w6gJsrfDz//QXuHZjRt34Ywij1uYYKiSlQCl53M8Jwffxnla9s/iSkB+OoFxHl4Uj+BGnrg/iYeLxcVfhSKXq33I3fqeMbys5EKplsAbRWHJ4f4dhPOCpZzaIE48zgSYIdpqIw4OCgwctiwbeeKOg3a954pxBC3B7gQyIx5IagdGBM0Zw50HHfulxCuatY2YDCx/IJlDMPc9cllQBFiEQx5BKuH3d0XY9ES6NQHlB0wRmZWByXrOyKZnkioN3LPvv2X5RFchE0llIcoHSfdULCfWDrudFWMei1Hgt6HDUDw5JAhSFQAZLnvRwhNJCsX9IkY6YzkpEqBikgixJGQbH7etTHuzv04YcFRQq1sQ+IIuKrXMriLoh1grfNDSdJY4TBquaVloiqRGto7UOB0RAJxoqG1NNS6JOoaMEAEND3S6YVR2zRYsUgjTRKCSOiLKsyRJNsBKnXM+vICI1Bhc6utYjtSZKIuLE0Daa4XpGlCYsFge0HuJ8DZmMkG4PMxlSzOa0oQI0IpH4QcwAqMs5XfC4usQ2Dbt7BZsbE1SqSeME56HuOoQ0NHXN3r1bTDa3cb5DRIpEJ9jDEodDektL1xPutCTSMXt7+zhv8U1B8A1l00OO8jxDuZpsZZW9eU2xv4+0jijqjZ6kSFhdW0Wh8VbilcQquHPzgIEMGOkp6xovPcNYsZKmdOWC8fgM4/URig7X1LiuY5IPsU2LXptQdX1FjiihrTwDEyF0TFNPEV7086MgHRmKuaCaOjCWqquonUUmI7bWcrAxh2VA+ZbGdtydlly7+g4bj2xTHM6QSYoSmtqXuLoinqyjdU28niPzVbLts8Tnz+MHEx5NBG9ryZ1b11APHjC7fpud967ygZdTvu+7v5fnzlzhUz/2FL//9uv87Bd/l089e5YPXAAR/SWS9B6vjKBtbzIvvoj1Ywz/hLUXHNXcU9wLiAk8+8OSV3/O8ejwXdb+/P9KdvGALPthUCmfefcLDA//d77rhb+MaD9H/cbr+FtXSVYnJD/y0yBqivk73Dic8qU3O/ZGh/zED13lrvl+hpdvgtzg3vXr3L3xWe7OPdXgKcqrbxFWZlx9t2C073gpDXzoSRjEhtGPvQjPXqZzW8wXGTeufoGt7aco2xSZrDNIcpQyWO9p66URmuircW3n8DbQli22bUgHfVIu4gSqCiEcMk9pvceFiMGKoy5bfNHhhcF5B8KRjzMshtZqIinY2o7ItEdGgXh1QjmbUldzqtKSaE8bAm9/8z20b1lfH3NxY8gkUmQo9u8eUPgUnUTE0hN3DXLvDoaC0seMVs6Ch27fYmWMVofkH3yK+fW7/MEXXqWbVGx/YIWtYcTOl1/j6v0ZYqGYdz0XQivBwjmyFtaGhkcuxKTGUFvHncPi5Hq/LFULcSIhqrTszfvog6XekAwiAevjjExLvKQXOGgdzmmmZQdG0lrHETzltCNskiiiWBHHks2thA89v8b5zYRf/JXbzAqL94FBrNhYiTm7mREb+P0v7VJXlq2thLPbCcmKprWwt1NDDL7uvUU2N8/w737qzwFHKJu+EHEsdft+HcsI5Ejm9UQ29OEK/7eO04HKkX+B4ESG9OhJYtm9IUDwJxXu012Kvrty6rdT/IawDIBPOjAnycp33DiK7QMopUGBCv4YqnU0Az2kTeNwEPrE1vujfbx0Vqb3Ngj+qFJ9lIiedAX6hK3/OSy19d2yU6m0OoFziSP+jl8eH4TQ6ChmMB7z1Ce/jw/+iX+HzVjzQEq6wz3ComC2s4ui5fzFFdZXVtnKz/L0h7d47cabvHH/kMfWh0xyCeKPoTjg8rams+9i7QE+tAh2yS/PaduOetqQriv0OOLOF6esZJ8l/eg7RNlfIVEvMGsbbi2ukTS/x9lzPwHd79Dd/BLSHqDGV1CP/w2gxTZf452diuuHC8qVq7x0LmGuP0K8cZfghxzufoXp/LcpXUonztLsvQvDPd69tkPx9iFPbUheuDJARTnJM8/zL//FT/Hj/+Hf59UvX6Usa7yHrrNL2eOjvSyPO2nen/CmTnfkjrtfx3ChP2zud+wNIsRSsapfa386sfsjPL6t5ODB/pSvv36dxnvoJB/75IvEwfdSfTrgTIIThjhyNC9u8OZv3Wdx4LCdI5OBK49EDIMl1ILdhSXTnvWRIFWSO1NLOXXstR5dCiabissXJNsrgUYowlASpZLtGm5fc7zzesvhLLC9Ch98RPOBlyIWi8DVqx3DA/jxvzgkGRp+41cP2X+vxTcBrUDEgigVREKghxJXB2IlmKwapocdqZYUhWWkFLaAzkdMVkfc/cYOdQ2TjaR31A0QO0c2HnE4r1hfTVFySFvW1I0lnqRsnoNRtIQkdB10AYVEDzQGgVMxrQvEMpCnMYN8zO69PWKVk5iIxs+JB5rxJMPoiHoh0HHEwkFXl0SdRStDU89xZYuJEjY28r5yECwGyPKcJOnVh0SAaj5jPp0SGYXQEdkoozrYg65DGEHdCJquobaBu/cr0BJjFDQl1mkEA/IsR/mIbGCIhxl10NRtR6tA6JSumpMoyUqWEgdLrCzGCaTsyAcZkQtU5YJE9a7Rsp3SG4uAd4E40iggYIlNIE4yhNA0TUUSee7d30MFi0okUeZBtL0CUpwws54QGUQSYytPCJrx+hgfDG3dgtUo06s7YRWjLNBMG4aDHG8dCk8kI4rOkSiFwUHZEWcRMpKUzRzXzqjmLbIWrKyfQScGHyzdwRydpuwczsmTAbGGtpwz3d+jqRq00uwC0VAxWR0wyTJ2qsCdW4fs3ptSWoExMTobsLK2yfnnM6qdOwxWBzRWIr1H+h7lsljMkPtDosdW2Ufx7p2G+tYObvE2X7p9ndE2mJtvYO/cRUUZww88w++8Lvj09Vc5v7jOhz/yHGe3L/H0kxf5td0H/Py//D/4Exd+lY2LgcnWMygZ0+4eYg+/gnrkE5gPfYXp791n+qDhwW7gxjvw0iuCwgiSqkUufpe6fZumu8DHz/8ZdnxMufgZzN4UcW9GpIfEH32W4O/gu1/i6vyAl15WvPh8wuXnYnAR3/PCf0z9RMObpWV3eIf48j1e0JZJ8gjj6DkiBbb7MovFr7B78/e49rsLtn6xgZd2mDz9EyTRFjKryCYt+fA81JbWCdogiBBIZejNPTrarkVJgW0acBaNQ5kI13ZU8wJX1QjfIYSg7FqcE4hQ4oOiawpmDwp2XWCyvUYeSRwSHWc0wlO2DUVbMJ23hKlgb3+KdwsEFoUhzxPW1lL2qwMi4Wn2dynLkllVs+MTJsOI7OyEaDSh2duluHmD8vaUWHtEcpb5ogE5xpghg2zEcD0mWRvR3LrKnekucSK5aDZBpHzjxh7TpuWRzQE0nqYNxAqiGLbWMrLUk1hLEhvSSQp5dny979vxfWVfLaudSmvarmN1ZYAQEuc8ITgSI9naHPHh7Zw37hywWzYkKzFnRzGff2sf56FsOA7E+uqe5NLZnGndkgw0L78w4YVnxyS5RuURXQisrsUMIsUgVuSZYphBGguK1vKRl9dZX4nQyjEQko+8cp4716fc3OlQ3jAcxIxHI7TSeOco6wWDNEeIHjr1vnVF5uSziWMI0RGv4CiyX1YxpVjOZx/MKqmW+KNl3TOEkw7AMeTFHwdCx3Hx8nmnE4MjpvhR8qCOTKJCOJbc7Ivap8yl3ofzeYzh/9c/4TjA01IQx0kPb7WWI9Ub5/yxeZ5zDufdUrXGH3NnlJC9Eo4/mV8pll4IyGO+iD9qxYkT/oFYdm6OP8zR9AqOuwwI2QsjDHJGH/thqksv8YXXb+MWC9ZXBVuzB/jDGXK0QphM6N6eMYnmbFf3uPLMFbZXLrFwntf3d+m+/hofWPkC+Rokg2dwtsBVd8HuIkafQl78PPaNr9LUCw5ngVZpNp9IaZRAVwdI81ls8zpaPMHF/DIViq79eeT8AWL+ALX+OPLMCwS/Swhf4kFT8AOfGpFvpKxtjjFqxMWtj+NWLXeto95cJ9sqWJOaWK8Sqz+LEvBdH3qHsvwNip132Hv7kPq3ZiwWX+X5j/5n/A9/92X+1t/6aT796V/s4ysE2ujjoP6EX9Anfc7a4/mWopdJBoFbmqT1TZ5/dXfpOKHg1LknRJ/UfScmxP8G49tKDnYKy5XRiCtPbPUGO3GHOiyIhh3J2io6HxMQrG2toUxJ/et32a0dxsFBAtnEM1qTNEVgvGsxVWCcSgYjSX5F81u/0eElXPpghEphPrOIWeCVH4zoEsVb32h54w3LwV2PbDwrY8Ff/fGUjUc0Jhbces/h9gQbc8/mXk0rPFoFlAGTiB6jmwryiSC4nnSbxhIjBfXUoaXA2YCVgaZxdI2nKx2jTHH2sRF+ryHNNa2zIBQro5iirjFK0lUdg3HeEzYbi8ZwOD/EeEm+HpMYQ1CBICTJOMbXJVhFluVoqRAuIJCsTibMFy1d1xDHhiTRBK+oywaZRFjf45AjpSF4qqoiS2KGJibLRrR1S1nXOC8ZRBKjY7TWSCy2bcF36KWSkVY9TlkOUoySaCUIriISFVVrKb1HR738aSssrisYZBmj8ZjxyhAXPEF4UgJF09DMS4p5QZpGaAO1bYkSg5aSqipxTYMwtsd946lChxSOejHFRwmd701ITGR6rXqjEMYgtYTQImWFxWHiZnlsgetaFkXFg2lHOhzSzGesjnKy1SHCDVDOkiYRNkT4JKHuevKxbTyN0zjnqduKRVGSK8ko1iSxYiA0LVAsWlxTUi9qhAYrJSiNq+cY0dAu5mhGDPIBIo5pWkmmPLhAqxQkMB57Wl3T+9Zl6CjQdA3TBzO81Ejfqyv5pqXxYIXsuQ4C1s9vkwxTDvenlIsGW/dwODtbcH9+lX07wI0kbVfTLm5hEokqZ5giZ/KBj7DykREba0POreecESUrQ4N0zwMZSg5YkS3rruHix/89fm3+BvPb97hy8y2eSms2V8eMz/4gs/tfRwyfoDunQD7AFDWDTHJ4p8ONBH7XYWf3MZsLnL2Pe+vrpOdapr90n8ljgcEVQzQWCPUewe7RVJpoXvL6mx12HljLBOVKw8qlB7yVPs2OFpw1ZzirdhDuJqLd5079Dlv54wyyD5Im55nkf5LzW+/Ad1/n9V/9Omv7v8rkiRcZrD9CNjiDUBHO1iihkTis9XgXcHWHFH2wG0WaID2+Ad968B5rO8pZQWhbbFsjjCBfG7M4qNm5f8D2xTOoaIKMBzRlQ1FamsMFSmmUVHRFy+KwYDEtmESSpumYVoeoTKNNDylLh4KNLU1313P15k3WViLSVPdY2GbOtUZzeK9hVJaMRgO6zQlvvf4G2/km65sJs3nDOPXkWUq6ts7kmTEk8NZXbjGbLnjy8irn1gfU3rBb1hTWs+8CkQShwIqAVDBvW/JEce3GnDPbgkc2xowGg+PrvexLlfjQizxo0ZN784Hh5ZeeJM9TQGCd4+7tWwjbMG0cL54fcWFDcXbLMBjF/NCdNX7us7d4cm2CGGruV45bD2qUkFy6lLP+xIi6bZloyI3gwmMp81rwie9Z5WC/I1k6jA9XDd/zyjr5WsJXrxV86IUxK8FjnMesB/6n//E1Pv7JFfY+d4iMehGC8SSi7Wq0icjSvoP0fgxgHxphGYQslZuOfdvCCd45LCFdEtFLkZ6uUp8iJJ+Gs3AKAnHa50HK8BCh+ShRWD6TAMeV0yOS81HAfVoP/nSQ/f/5BH27zzz9Px3PxdGjJ8CyI/h4YiKUkCSxgaR/nfOetml7CNESy97LalmEPzlQEL3ePkusu1qqOAkEznl8OKk09/O1XMfTkyZ6xS8X+i7bceIle77UpU/8SbLNbWQ8ptg7xAiPbkqSdsD5y8+go95LZRBJMmFJI4n22wiRYVTEwBUEnaAuv8LX2/sUuwc8ufsaa4khy9Yx2SM0izuI5Fn8egfTG2hh8UB9WOITjZjNCBdeg2gL7Nv9vWowpP7aV0gvZJhHxsjUI8Q3lnKpKbqZ8eVvFjxZWPJI4dKSKK/YjTYodGBLZcRMEX4BrmAeNKNonSh+FGPWyNM9utUH7G3d4if/+t9jZestmsZR1S0XL17g1q07PYRZyuPCwxFxXC45Iw4e6gyc8EP8co1O9lXfZejV7I6EGI72kPceueTvHEGa3i/jdOfu/63P9e35HKxF6NUIqRyhnOLbmsHZLeq9PeR8nygKmPGQOB7z6HMv8h/8lXP8w3/wBXbf2+P6vuPWDc+jFxRxJVj1INtAWnjSxhNtJWxENXMbuHDZ4KSnyjwfPCPYWBH4NvC52469Hccoheee1Tx6xfDMM4IiOBaFIBaeswPoIhhm4IaSe7uBouxzb60EiRaMMomUisRC8ALbBVznGUwMg0mEoq/OSiXRicKLwHigYC4YKEEdBLULNLVlUQQGg4g8T2htR1W22Kpj2nU0tSUMYnwDUaRQUX+j9S2IrqRpNcGBMTHeS5ReoJfBsGs91ns6J9BB9SpCvsc/tUulo57w3FfzjEnwdQcOjFLEGpIooi4bkJJIi2ULVGLiGCN1jxPWEisDWkmM0mAlThnySKN6dX80AUVvdjWMY9IkRghF5Rx119C1FcpZIhMhM0+cZSRGYqRHalCupLU1BIXvGjw9mSdJFUoqbNNQNx4bWDq7KuLIEKUD2q4kyA4XenlaLwPjSUZtO+rW0nV9FdJoT7YyZE1KRokGJLYNuLZXN9Ii9E7ZcUo+0igLTemoaHB6nWrnkNS3RAFEJ8liTWagrWucq4gHEbGJqBEcziq6oqYtAl4MiAYaTEZIJ7jdXXxbUzmPygxGObQLmCgmyQydAms75mWgqD2R6bBVi/MBk8bE+QAvNUVrESpCRpp2USKWZOzgIIoHaN1gTUxjDKG1UJZMXMsHLqzyytObDNfHiPEag1HOMIM8Klgznny4wsJvUM6nHM732Wsq8lHEUxfPMam2OZztsdLdZKB2IYVu8CR7813OSEu0KSmSDbpFiXYzdr52m2zheW3Hs7rbMNx2xCsll9Yti1sxK2c7uqon9YqsX/MQFHUV+O1fqBmOJOMzIGygLhy7B6+ysvIcJlIMRCAWOUIOcWyQdEP2ioLdKGMlOs969n9T9+ZBuqV3fd/nWc767r333de5M6NZJM2MhEYbICRhiJyAwWIJMg5JysZUqlJOGYL5I66Ug6lUQdkuhxBSMcQuKwFcDhiCFCFQJLQwGm0z0oxm5t65e9/e3/2sz5I/TvftnoHA/GEbeP7pfk+f9+3zPmd5fst3OUGanMUsjVmbnGQqHZmxRFbiREjtQASNwtN9AIl3KJoWsw5U02o2HlM7XGVBCby3jYlhlKCNOghDAopyitSyMe4TCqEkcSeE2lLkEpWk1GXBbDKjzkv6gw6xtITtELtrmJUl2hlk7CCbgigwdoZqaYpEYWKFiD3dsubuq5uMdqa0WzHdtoRyzm6eUBch3eWA7voynXiJ3vIi/QsDkuWUap6xeWOfblGyIgvadkKea8okpfJD6sISxArRChAScmOp5zUPXmgRJS1aaYSpLfNbu/ef9z/993+GhYWF+wGpFKJRA5OekyeWCNQY3AyLZDIeY+uS5z//TXS2TUsbVnRAvxOxcLKPfzJgNUnQg5h5GrNvA3Z3BRM/4a1PL7E3HNNRcGIhprsY0ZkXrA4qvCk4sxyzvhaxsKo5cyLCSsGHvnONiydPEOxmaGtonV/i29/T4+TZp0m/9vvU9Qhpc/a2rvEvPvrz7O1UuBrq2t03nGoChUZ/57A6fjiEaOA2hxrp9yEGHBlduQMRhcP9D4Pl+xCEA9LwYc1eyCNM+mt+cjxghV63x8/+7M8dw54fJ6rev5ibiFYcfs5RwNN0Ew62HGEojt7pj2BEr08YDnY4Fn43/+A4sdb5o2Ti8Psezk9ZlvzUT/3k/dcNkfO1SkZN9fzQBZr7fz/Eit+XUfX/f8oxTZAulUJridaNeefhPkIKtFJY5xFSkcQxvW6bbqdDqENu3LxFmRcs93p4D8ZahIROkvBf/fjfoTUYgDWoIEBISV3XGGNACHQQNXCf13UBjroz3A9K78tewmsJ5K+BrhydGn94/KJR1eFYwucB6z0vJEtYndAJEhY6IctdzYqM6bZT+v0WQagJlCGUNYkShGFE6dpU5ZxZMcX6mjQJ6bXbRGbALJ3QsQO0rvBBC6O6ZFVBW1h071EKfRLcHLJ9pveuEuYV1/dKBsUOuluSpAGtxFGPE+KBwWRDdApojUfgUZi65Buf3OH0+RbdtscbS1XlUNwgTdaQ0hOLCE0EwuHQaBcxr0p8ENGRq4TxIkF4GhFf5MM/kpGkK1gHaZriPYzHk/vQu0MewfH5bpAJRwaPh/cjHG0/Hko33TR3BE06fl8cO7fee/b29vnJn/zJ46i9ptDzukD9NdLDxzoY970TXneTCxr1wiAMMcbQ6XTo9/vEcczW5hb5dE5tS4QSB8lMc41Ze8ys8thB+YP76/A6kwJeeeUqf9Z4Q8lBaxAStRV1VWInQ3S3wLRWsLnE2RFuOsfbHrGO5wYAACAASURBVCYsWDrzKP/Rmce4t53y2Y89y9aNmzxz1xMq6EuFpiFzmNxjRp7wpKInBAvC05KgB5Kor3hkHTIPt28a7ty2rCwKHrsiecdbNA89qqlHhs1rFuslHQFJCmUKSVdDR7OzC3ne+Jco2RCP01QRaknLCmojKOaO2lgWOpLeUkBeWoxpFsK4pRu1AAeuqlFaEKGonTxIDiANGqnRsq4p85xqVlFnIPEorRodcOfRQmE8jIcVMqgxQFHPCUKHsQInPHEaI4QnUFDVhgIDEpIwBC/RCswhxlM07paH5OjZZIYQmjBSxFGEkJrJdEIQh9TIxsNFKIIoIQpjcBVSC4qqRgJaBoggwIYpoRN4KxDaE2hFoANAk8Qp0juwDkyFqSrqqkZ5DmRf2+g4JgolgWxIntYYnBBQ1XjpQWmEjpvjjCMyKSiMReGJtCIMFXGiCaIAb21DKJUarUOCQKNocJ+VFxCACASpCEjbEStJhLYVeV5SuxoL4CRCN34IKmwTJx06QYI0knlcY3PI3CZ2bwuXZeA8qrD43CBmBYG3JAoiJXA45GSGKitGlUO2LGkJnpCo00cPR5TWALq5YY0DK1FSkcQpdZVjDVinqZEYU+OrJhhNkoS002r8OLKSrIQyqzD5FCsa/G+UBKT9NjbyxINl8k5IJAVr/ZAHeglvfaTHt64uEbQTMlcjpUNQUpkdhFoi9BF3pwJpK8auZlsEPLx0ijCOeXP7JPXKKYy/QGX2mWWbXLu3Qb97mUreIGpfJuyFxKUjzibcOvtpphu3qVIYzx3ZbUM0tfQTSTbM6J+XUHq8N/ha4nVIWVm+8Kkx9zYcl54OWBsIopkiTDrcHX6NB5cylkTEni3Yt5627JNEPWLZYr+cUTnN0Ei8V6yFpwmTC5x5Z4+rt2+g4wWEajpQwll0EGFsyYFoI0pKRKAxtiHRGu8x1jfQGOcQWjdFgVAThI0imaktZVlibI2KAoqsQkpPEEWESQsVBrjKIsM2VV7hHYRBQK/fRWqPEBaHZLq1S1mVaOko6pxQZDhbIETCqAKkphtDK6gJzZR8nrOzaxi7ClULyrzN2IeEOmH57Bla3UU6i106p9roSJJdy9ndG3O6HXOy1yUOIvy4ZFgCUiJrh4s0XgqEAo2kKh2qnbByegVTOEY7E/ZvHiUHP/IjH+HMmTPHVoDDoNDiyuu4/BbgEMk6MMOLiCj4Iree+RR7o03iexAoSZJ0efsDHXxeobsJ4YlVzOIaL3xjwo3tV1leWCTtJAwiWEwDDAorAubzbc6eXeahS23OnFZ0exZb1gx3LU8/cRZtEqrcIb2nv3qCD11+L1/4aooSfawdgcvZ2brN1557hbs3pmSziiK31LW9H9g23jeHzs3cX02lpHkOqIPkwB0akTUUx0My4lGiwUHBRjZEyAPIwZFLLq+rQB7BeZr/dyiG6fnxH/8J/tuf/vtvZEn+Cze++MVn+OAH33+gF+8PHK4P06OjgPgwmD7SiT8iksoD+NKhx0WDkjqQWT1IRpSSBGFEuxUTBBpr7H3cuNKaNE2ojCNJW5w7e4azZ06zvLSMsILPfPpzpCpkrZ2ioQn8nWO1P+C7vvd76S0vo6KAqNdDaE02GVHOpsi0S9LuNkacYYDS6qhjA//e2iaH1eraWn7lq98kL2tOhJKTXc1qL2AlDFCBonS2gX75AudrECnKa+YlaFcztg4dhHSSgDAIOR11sK0ezq9g7JR5OSbLJqTxOlZsodMryEgS2RIV3GPSE+TTq9gwIpvXyHqIrUMUAbYaEy9EiKoGNwMX4WlTFSXXnt9iOvFcebJHVFtC3QaZMC1eZbn1FC3vmboaIxShSFEqQouA3FZYL5k7QSIjYpXQ7i7yIz/6EaJwleMqQ3+e46d+8qf4n3/xF19TXHAHHJLDcRx6dz/xgAPStGzgSdYe46MItNKNDHwcc+7seS4/cJm1tVWqsuL3Pv4Jdu9tUdscrxtivLUO6yx1ZTi8n44LKjnrUEreTw6U4EBU4k8fbyg5CEpL6CBIQwLVolyIubNzlVNnOqT1HLm/SfXqXfK6RzA4S7z4AH/7J36M84ur/Pr/8n/wta19+rfhkSVBt6uoQxrZzT1YHAqCCs4JmN0qObkccnpV4/YqdjLBH3yxYlR4vvOvaN7zds1CX6B8TV5a5hues6cFkYR54pl0Gk6BFYpy7jE1WC/QWtJe0vRXAsjAV6ADRewl2jgWWpJOrHDOkWiBArRrFp+q8piybsycdIAjIBQSX1pmezWTWUlnkBIIRy0MVojGBEyA8zVVIcE3HgPbowIXK7qDoJEPLGucKHGRwswd1lUk0mBpDOMq68mtIBKCVhoRhE0t3zmPqQ2VMwhpyIqSQBgCnSJESGEts3zGqlrGVuZAy10S6oAoCvBOYu0c6qpJDgINSpO2Eqq8xogAHTYKR1oLvLGgNPl0AtaRl3MKYzA6QQLSNY6uoRZEWiDxVDanqEpU1KIoRoRBRNrrE6QdqmJC2OkhkhRRlAjvCbVC6QCpHMaUCG8QQhAIQRDGuDhmOt6lLHOCUFAFDqsa4ytTj7Bxh6oomGYZpTF4oZB1BSamtCFaVeShIGn1WFxZo70cMb4xw21Z8nwHOS1RxlLPK+qsws0m9MIAVTvsPEeHnkVbgrBMVYQrDaKwpGgG3Q5+sIiOAwhjZmUOZU4aBThrSOOAygsEEbGvKYVhWmnSVLGcphCqRmJXgg8V+xtDivEU0Qqoq4owCmn3OnRW28gyJlk/Q1kYzqykvOfCAt92rkcvlQi9hPclbVsipMY4xTRrs1WfxczbfOX2XbopVL0TRL0Vep2IO3aPgppUCopaMat67ExrPvvcr/GRb/thdv0OJ9JLtNUaWrbpCo9bT/j6v/0ET5/cpJjljHYt1diz8ZJhZRnGr3pOvFUSDhp3aVtJpjvb/Oo/m/Bd/0XK6UuajtdEnTYyWWMvv4etbiCDVea2Zs95crHIGUY4HbIc9ElkyO2q5GphWAoSQhkStS4yWG2RqIBYHrquCwId4JFY1wQfUkhkoNEavKmaxUU0ggQq9CAd1UFJ15qCumh0851zhBqKDPRBtVNKjVQhTkAy0OSjGlsZ2u0WTjReGUnSwfiC/mLAeKaZjAx5LlAJ9BJBlBXcuT1kojRRN4ZehLFzWm1NGghefWWX+f6E2EWESZeFtQ4nVtbpnzxBa22BpB2iI4mwjvlzu9Q+54ELZzlz4QHkYAm7c50bN0fEQUAgmgShrhxOOJYXNWOn2J0JohHkw5L5Xs68/rMXC0+FmX4SP9tFBheR4SUcU2TY5oMf+k4+m+3w4rMZ10YTUiU4cTIi6kZUxW3MpEK2FxGdFDd8lYX5Htn+IgunOrTJsXnBvIrYGJ5klM/5rrefZm3FE+g5wuXY2lGNYeXkOdz8Liqc4n2IEoqo8yGee+4fkOVzSiuI4gAtPbOpoa4PfHHkscosR3juw+D+UM3I+6PK4GHOcBgGNoGvOwgMD6uJh3NzEAAfSr0e/ek1VfBjsfL9l+J12/6yDiGa4N07d9DgOCqN3+80HAb9h50Cd6gmdfQZcFgF9vcN9qRq4BxBoElbEYtLPdrtGHMfT95UW+MkxVjB6toaT7/rnVy+fIVOq89wb8JwWPGm9VOo4TbdQCGMp5qXRF6x/cxXmCUxvYvn6J47DQqGN19l9+4d/NJZFk+cZrC8QLvfQSTJseTnP8ScKi73YrxUXO5HLKeq6f6LBDBoVzfPexNQWk3mevgq5PZoRDeS1GmfJE7QGiaupPaWUAoKI6htm935Lrv7V3nLmaeZ+X0G4Vli0UIIDZ059Je599LHuLJ0i9lsj3Ja4YqKuc1JU0WxW9E/30VoifMaV1tmwxt89v++yTt/8CydXkBQRUixgpFLZGYbb/dBpOSuxglNIgRtUeOloqUSQqG4ZyqM90RSIdCooHdwbfzF4Ax5mg6SPDimwwT3Pj/hWHftkBgN/qBz0bxfSdEUsBsST4NsiRIWFvr0lxb5Gz/6N3n66XfQabf5+nPP8Yef/DRCQBAGmIN7SUqPqAVeg7FNguAPix4A4kg1yzetuzckIPCGkoO739xl83Sb1dOnOHlxGROs8JUbz7Ds7iHTnCB0uNhgvjbh+V/9Vzz+w/vopffwvg9/N4+/6Qyf/7n/ns/edZwtDCJVDHSArCrqfYsb93lXus8/3/VU9xznRcTiashsa8g//uU54s0Bf/tvxZxZdRBaKsBknllbEV6A3okAc7MmyBzrqSCqDHl3je3tHeZTh4olnUXFuXekvPepLte+XrN5q2Q+9oRKsLwSMRikKKkYtBzFxGJKR5Vb6swwaCu6awkbuzUdAYu9gMU4JrM500nBoBeRBA60otduIUJBHEjq3TGikzAvFbW36EDSVh6DREpNvw1EMSJKCMOAejKlyA1WVM0JFwrrFTavkK0YFbQpLQ0GUTismbO9OaTbiektrhEJhRISa2usFCy0U6rhDHQT/EvtcKJGRi1CnbB9Z0wYJ42CUVkStTVWAC6kk7QJoxYSiSlyZrMJTu0yy2bk8xrvKipfUXjDw0sJse4jwgjC5rtWxZy6mBPEHSQapUGFEWHaJYlSvM3BOqIwJZSqqfsojdaCIs8ovcJUEEUBSmrKqiKrCuLl0+R7d3BmSlnMsa6ku9hFBQX5fMZs7iiwlBiqwiHLgFsjT5IukYqK/qkubqmDSnosJJ5cDPnqVz5PuHmDVRnQVT3GuxlnY4+tPNaEpEKy0vb0BhXT6ZRnC02gNSdOLnPlgXOcPHECazXhwoDuuQe4c/ced+/ewtSGKA2wtWK0NyXpLTKZFRR5hXSGrla0emtErYDcZGT5jElWMJ7XyKqg3YsQ3SX8eIRSirDdpdMfEAnD0lLA01fO8+jKAsvtHlHYRckIk38NU97D6HM436ISLabJJe56xas7W0zZIWOVx+IlHum1mQjPzLd5abzBGeX54qtf5e7mq5yJI77nu3+aL45v8HDr/cxpk5mcPfsq33DP8/72h5l+zweZvPzf0Uuvsni2RCUgx5ZwSbLUk0TJIWRAYjLIbggefFfAV285FtuexfUOt/IOv/1PXuSv/+g7ePXGr3Lm1PdxPn2AZRdwuxzz1coRmV2utFZB7XFCK06HXaauZkFGBKrF2uAMRTHD1AXaCxySuqrxpsI5gZcapxTSC7wzlFkGQjZtXSmpjWxI8NbhqhKVCHQswcBoz5JXlqKoSNuKsNVFRBFVVWJmOfHiEtnsHmU2RXc7eKWZ7A3RojGtW1xZQQUx0/0R5TxDR4ZeV7G7WzMqAnYKQzKfEsxGvLK1haXNm9cGjCZzNvcy1mLJf3xO8fYPPc3Ke5/GtiJUpAi0bBRTjGM+m/IDb75E98IKcWuZ0W7OvZc2qZwgjAJaHU0gDfuzit1pzTx39NshLz2/yUsvTLGFYakXcP7CAnDtT10HqvxrCL2LTLdxsy2ql17GLX4H6eJLED7MO/76j/DQI5fZ+NKnubeTU1Y0/Kp4FbO/i9mdELUmnKy2+fjOiBVzljTOCakZjxUv3DzFLfdZPvKDA9LWJk6YRhXKSuooQS86wvQ2+X5OiEMHNarapa7u8MJz1xkWE0ToWD7Z4czFLhcvLvMv/9fn0Fph6kZuVQrVVLAPF09xHHN8lCQY71/j29D8PMSNNyvuIfrnEEViDwipr5U+vI93ACEPkoHDzsOxN/+l104X9yu6R0mBP9YhOXQZFq9LhgQcc8U+hFsgmoTA+6bqqbUkjAI6vRYnTi6yuNDhe7//W9nc2afTT0mTlNm45tmv3SDQbc6dPc3C2XOI3hKq1eF0f4EPdZd55eOfIJ0PSZMB1VzgRzX9jmC+PcH0E6pvXKMup6ikRt14EeH7bN+8xcqp07gsw4QBYRwfcA2OssB/18Hq8dDNecebTy8RiwqtAoQMG8aJ3cGaCU6u4L3GyEVyAobOs59n1HLOWA64HCe0Q02Bp3QBO+WURen56uZVZDllpd3nwfPfxZ16zHrwFkofUrqcmbuBFAUnkqepHn2CbPtnafUd3RWDwCBMhUoi0jhq1JZweKewFbhcce7tPV6+V/JUqBDJCW7erri38RKPPfUO9oa/z2L/W1nVfTLnmNmKTevQPmMlaFOLKas6auBJvuFNSUJqVzdIh/9ALJc/bfgDgr67D2U68BMRR11FKUWD8DgGV9Sq8WsxxhIGukEZIEnCiDRJSNttnnr72/mH/+h/JEkThHCYqqbfH4CHbjumcBZXlRwWvwIdIsoCk5vGkNY13YFDdbim2HF8zv7s+XtDyYETOf1oyrIYcfOFEWunNnj/I21idRdhc6g9YeAJ3wdvKVI2fv23yS58nd6lN9NbPs2j/+UP8Bt/7//k2aLiiTonXNbEgUBXgmK0yWa7RXFnjBw7FsMz9MM+V7/xB1zd9/wPfzXhLBULsSdpg1Aw23NoI7mSQ2I82Y5Dbzv0akT4+GV+7edr9rYddQUyFLQ6mkcf67AeCm4Jgao82U6FFpJTF2KWQst+L4Rd8JVD+APSSWHIcfQXNA9e6TKZNq7A1hmiRDOcS9pasLDcohSebFbCuGCWWy6c62DrgFkmmE0KapNhy4KHHr6ECDwFCqk1AY5ynlGbBkspohZKSqKguYBsafEqYXNUEYYKT4mpC0wxR0WCssgwtqLTG6B9ExhpaxojLx0QhCnW1Ggd0x8sE3dS6mxCZ3mFPM9w+RzpDV4JnI9QOiLtLjb4wMk+5XAPfEhZjnEiYF5khIkmTrsEzqNaoiFVhg7EjLKYM5mN0VaxsnyKcVHR6gwIZNNutrWh01qirAqoc6JQkKQpQZhQVjkFIE2JEALjRIMLR7GytIKzc2xnQFF5ElOQuZKN6YiVlQU2RjM0Fq9rOr2E1VaPza2c2cYON1/d4uIjb2dp+RyD9XMsRSlb44KbL/wbru2/yJuoSU2Im5SYoWQvGDI3U7YJqGtFVwu6AXzp1Tl/MBMMTq3zgbc9zYVTFzGTGptXtLRAzEraCk60OnilCIVlPyu5vZPTjSAetGkvxyAcuY+ZOMPONCPqR9RliStydFkRh5qRkywLR+0gSEKkVOzvZZx94CxPXj7HW0+doyOnSDfD1WOcyfDsUuo1dnLJb14f8enNCbkdEVcZevgS3/eut3B6dYFBOGQyusam07yyM2Vj4za/8clf44l3LvO2p55Ct95CqiRvHlwgtjO+MdvE5TdZFvucXrxCqQe8tXOa8PFfQuf/E5H8InHaRooEV3y1Mf/D4wqLGXp2X875B/8058F3RDz08BKuctwZtwjOXOSH/t5f4xd/4Zf40pdLfuBvXuc73vNuTp58mJ6LSYILzG3IFyZbdGXA6VizklgKUVFqQSI0sdaISGFkAsZQlxZHgY40muAAj+mQAqwMidMWZVU1FTnZkO6Lac5CJ6XwFZ6KIEkJow4wwdweNl0oGZKNpoTBhFjC/p0Rk40tFk91mcgWKlDESiM6A7bubbByZg2pFOW8pCospRVsbWbM6HK3CLg3bTprs+mcu7fGzKYlyx3HKyamowc8+vBbeOqpd/P4D7yPOIkJOgFayaa7ZDzl1FJeLxlHPR7+zh/C7O3inWOyd5eXnx2hwzaZnfPs9TGXVwJ6/QDXUdy8XVBHkijzOOFZW+9y5fF1Hr64AnzxT1kFDNL9Dl5OIKxRfVC9IZjfIb/+MOE5hRATWqfWaJdPsfs7n6W9dJLlrZcpBxaV9sA7ir3nGUcR5f4Ms79PElzEj/a4/vwX+MSXPsVP/N330KpeJA5rdADOGExl0U6yZAzCh8idEb6oketncP3HeOFTn+fe1j4ikI24RCXphjFPPr3Ev/noixQCqqJuglZxhH2HA9jQsUjM+wNTtwP8+xG74FDWtQlu/THPpD91uT3A/1rrUKrRYmvW6+PeBYD4i1EN/XcxDhMBOIJSvXa8lsx5mCscqiEppdBaHXQaJFGoSdKQMNFcftMZPvyRD/ClZ77Otdt3OPfAAstLiygREbZzHhQnGO0bls6eZ+nUeZa6AyKpmE5n7Nx9lo3ZDR4PFDof4UcB4b5lPt+htFM297Y4uRwRy+tYKq5vzPnGdJOFS0+QtntoEVLPHHMzJexFRK2kOf5/T+ft8Npz3hGpEOkr8AXYOc6XeAqc7DHMKn5/t2Sj1BgniG2FLvf59ktn6LRiQj8iKyxTC3t5yWg64jNf/r948ulHaa9cJtTLRFJxQi6gfcntckRsNmlpSKJVvGpxUvVQJ/4hqv7f0DpHqRZ4i7dfRshG9cdXJTaruXd9ny98ccSJhxY5ffI8eVFSBF2WL12ifSLhE5/5LZ55fspHfniDB8++Gx0OSIkIVZfKSG5UM1pCsxCAVg7vG2EChWg8C/4CJAZwwH85ULE6HEcV+UNInWw47Hik9xhrqY1BCEkchTjXKCqdXD5BlCYQSk6sr/MLv/CPQTXw47qsmA9n7N3apzA1p85eZLi/x85on7IsMNZSOkteFFjrGp8sedDdvH9oh8+Zpij2J9yUf2y8oeTgkXeeYfHBy2wWfZK4ZP38WarqjyhyT+gaOUAnQUkLAroPC1rxjNn+17i1f412f8DP/fL7+M+//9+ijePRjmTQVri2op878I689KwNFIvtkNuTgP/9m56lNcG3XIjwCMKgRkvwtmnDpDqkdV5R3y7R3tM9q9CDHjr9MT76yf+GvDLoQHL5iYRv/94e7zgdsnd1xo1nZtSFoKMFaSIRBkYZ1KZkulOShIq4pfBCMRo38KPt/YpZ2bSPXA3zsiCQAYNQURvbcBKExOeO/b0Z86nh0pkOEmin6gDf74j7XXpLXaajCQqBtxInmodgYSr6nQQZJuSzOaaygGW0O2Fh4DFeI7OasJsigxBX1pw6mWAOkor5bI4xDQYt1pp0YYFimmEAnMU4ixkrkqzEl1O8l4RBSK1DTO2h8hhfE5oaU0xxtQcn0VGX4d4EWQnycoa2Na1WShwlIC29xTZ1XoMMMbbGe0E7ikmigDj21IeJlnNA4xqNKEkihbPNBVuXBldPKJ0F4RDaEwcJeZHjrSUOQkIZsTV35FVBXUzY2N3i6u4epqMRZ3r019u8+vJNdOywqaeyimE25dqLm5Siz4Orb6LsnGRmJS0c5b1bfO4zf8QHH4govmmY7YZEtkflhtw0AaudNcLpLuvtkpWOYjcXfGwIRAv82N/9zzh77jLFSDLdhdopumHEeDqinFZgNV61mLmScV1g2guMp1OiErxq3Gl95PGtPrN5ia9rirwkm88pZnPquMVCq002y5nmGa7IiMuc/uIC2aRmMjdcHe1jtp5HTq/j7ZTrU8lv3vFsfv42+TBjZlIKC9RD4laLx97+HfzSL/wcs91dnLEIHSKCNt/xwXfwpW/8Fh/50e/hkYtP0koWqFwDLUvtTV6c3qKmYLXf50R8iVCGbNbfxPubDHc/S5jdJdmeku7dZv0timS5j/ATrNOMhzU3nze88KWUD//MB9hNDBfSFt6sMvddqqCFTtb48Z/5eTZ3b/Evf+U3+Z3f/X3e8ugef+vv/BC0QjJzndPRAoEacKvM+Or4KutRTXfl2wgPsMuhipBeUlOhhUF5jTMVAon0HJAWGwNFR4gOQ+qywBQGa0BITZZXqLCFdg1PxAcRrYWYqoa6MuRZhSsybGUpZKN4lpUZrWlIZ3GR4f6M/Y0t8nnBxqTGdD2VytjZ3MSXM6SE4c4OpXXUhUQFGoox1AWB0NSjPbJcsTmf8uTqWR5/29s4/e4n8UJTlaATmOce7cDNLbN7JeW1OVceW0NulNQ3tnFJTieSfMsj59kMbvHlPcV4p+besCZJQh452yMK2oz255xbiRGRQoaweXfC/F71uqe+f93vAlO3UHYCwuCFRWLwUiHjr2D3N8msAtlh8WSLb//Bt/Kvfu5jPLHcZj0tENKgZIQyClfvk41rwvrLKL/OC3uO5/cq1k4J1rojnE1Reo4gANcsZEqlBAseuz0h6GhEWyA7K8zqx/j4x/7JgXOy4q3vXePNjy6w3gnZurlHJ5JkY4cSAuMdxrj7uH9rXVOp5tD06k9YMP0Rf0CqIxdpJSQed0yeUv5xkikHMBt/2OI/qigewpqsdUdk5r/U4zCUPTJgO5QDBYFz9j5Z9FBqsgmuGqWfxtG2cbgNtCIMG3+SQEva7ZCF9TZX3naGB5+6RN2SPP0dj3N34zo2rMhFAd4wyibcur1BqZZ5ePkihU6xXiCrmnx/h5ef/zLvelOX6bMTqjrFVprKTclMTH9pQJTtsTDICRTc3bd8ZRs6py/wbd/3PtqdFGcUQiqkElSzGhXohn9w7Lr4dzufB+GlkOTOMd69C/UuRV1yL4dnR3D1ubsMd2aMZRdTzQkoWRr0eeLhR/kXv/lRdjb3EErjVMygt8DTj57nhduf4nvf9yGWu6dB6oM40aP8mM1yHyVquq1lEpmAkMzcJvg95vNniMwMvX+DSE1JlmN0sopgB+dTsvmEneuOWbbGWz/0PRSBZzFqU5sFShHjVYvOQsr7v/u/5m3v3edff+x3+b3PfJ53P/Ukj77pCl4Jaj9koNtIkXKvmoOfHJjHnjjg59CodPlDE7o/v/HH01t47XlrxBzKqsIfwN7uE6Q9SC+JgoS15UVUEvG+93+QD7z/gwRhiBCS2bymzOZQS6oRrKTr/PN/+sskheaTH/9d/p+vfIpX7l5jOBkhnCWKAqrykMPDAQ/lSByhOTx/QJr+s7/fG0oOtsYzxkbSHSxgd2/x5e1dHlj/NpSb4IscQY1KHK7y4CBaS9jfN8yyfQgy4m4XH034wFtWef75bS7klvWOpOxr6oWAO1fH7DvBciukRcbGfs2tDc87lxW9Xotq5MgqibGeCEcnkMQ+oNhzCKJGvaClkMsLzK/vcGOvxFhoRfDgiZR3PjCAecFnfntGC0kuGvWi5a5meVmxPSoZ7QlmmSNZTJByPwAAIABJREFU1gRaoHEEbUnYCpnOmopTGCuIBYWE2bAmaHeoMOzsFEjvccYSBSFBC4xzzDIw1tHwkiWyGzGfZzgEoVJ4pTFeMMtLKmMYTwRJQgOLsBZvPcLAeDhHh5rSOTqhIk4iojCkrD1JGlKVjnw6wxmQSuNDjUpjRBzisEgBWgsC31ivK+MIk/BA4UIjlMVag3euqYYUc5zVOARONx2OUDfwn3arR5RovLRY4cirGmPBZhOs8ygtaLdSvPdUdYHJxyADpGpagc5apNL0WiFOBxRliYUDF0NJqGIiEaBVQNpyB6TRxsEyLguEl7y6ucfO7i77uyOqMVx+IGBt4QF2F2O++fVt6qnjrU9G3ArH7G+OEW2BbjnODxRroePuzhYvf/PL5Hs5uwrG+5Zg7lgSFaqe4LxjJ5vy0DKcXdBsVvCvb3uGNuG7/sq7WD99Eh23qDBUGFqRY7CumW9MqGyACBQCKKqQqaxY6BiyvMQ4iwwCgiSFVodZJakrz/50jrQgVYRQFh3ElGXNrKyYz0pqaylyi7MKq2+STzZ5tt+jtHOK/RH5cJ95e4lrV0vKqoXpLIMrkd6g5SKtfpsbr3ya4a1r1L5EDq7QP/FmHrwUcu3WF/hrP/BXuXLhcWzcY+I9iS9x9R7PbvwhuvsIy8mATtiiEG2GZcXLu7/Hx/7ZM/zYj/+nuM4X+eK1bV78TM7KbzlMVCAueIJd2NpybOcgVxRPml1OFRbbPY9qn0PUEbvjGZ+49zI/+sQHqFLHh3/w+3jl5pDr13f42X/0K1x59BLf/598J1t2SKpqekFIxIAKwefGE949iIll2FSUlMZ6T1ZUaOFQKuA+61Q0uHMlJWGoqMoaZ8EL2RAQA0k1r5FKowKNrUuK+Zwstwid4OsCoRrOkdAaHUqilqAOe3gD2lk6cYDrtRBasuTmtLVBhF2UDrBGopSg325x4tIFfDIm1xW7xjMrS4oqJwk9/VbI2sIFwt4i6BRnNEUtCQPYGTvcyJN4jxgXiO056bLCvDBH5Yags0QdFVRZQTYu6ZsWcZ0T97sURcZkZrl2bYKvQRhBIiWr3Yi4n2KFYuvu/rEn/qGLqL8PmTAuRwVvgnoPxBAhS7wV4BwqTcjmc2qbEUQGHQUkrZLHH13l6ldeZbUfEfUDfFtRC9i/N2GbgG6UIOyM7Z0poz3PE6c7RGEHk2VUto9yHukdofQorzFZBbKLlCEyakG4ynxnxFdevo2RlrVWysWlRda7XXyWcefFMXEQICgItMTZBot7SMaT4sDV2cPr+XlNtU/gpOTQyMofTc+xIOCAqHyoEnIMUnTcA0AdkHOP6wEdfozzjdvrX0ojsfvjSNrUWvOa7U3CIF4TkBzJQ/omaJIS5Q8N9hrol1aKKNKsrLZ46KlVFs6GSDmmnbZZbZ2nsH1evnqHhy+EdPsxpRiyt7OJ6Ch06FhPFBGG0WzMzvYG5bBkGpXs7nt6OMIiQ+YjnHOMx0NOnwpptSQvb1ueuyOYix5veeph2t0eHkWeNx3IJJEoBba2SKVeo47zZ43jc/An7f7HjLiameWljU2cD9jZgd3csW0Ud7ZrRrLDbHkB7XJCExA4hxcVL17/Mvdu3caElmTlzZxeO8HpfsX2+BXe+7b3stA9QSlClLcoX1PbOffmV9HxWbraI2VK5TVFPWFr/FW+8PHP8v3f/zeYi9/n+f2S2fUd2qOKWm0gLoYEdx03tgqqNGZwvssFP6FvHVaeQ6QrUDnu5hlTV/DEykVcKPnguz/A7tTw8sY2L92+x5Xzp3nswQeYuIxEpbSUxvmECs1WVbMeNQavh9g+x6Ex2Z/POLzTD8m+UqmDYoLHetcIExzsJ6Ui0Jqqqg4IyU1ReHmwgnGG5YVlzpw+z9lzl5BSsLM/Z7S5TyA8qYtJhEL0U3ZubbC+cpYrV97El25+g1vbdwmkRmpBXlcopTDeHPjQHMHefNNMaDoHgjf0rHlDyYEc5uxcvUc2TXjw4gpK5HzzruChhYfRusKaWyhnwXiEtOjQYCqD9D1k0GKSbdHuwFPv6PHcN3fZGRnW+4J2P8BomEwspfV0+l2K/ZK7GyPqmeDSYyFK9PB53lhxeoEoDdpZKCPqeUAQthBm2FzMi4/x0V//NPPKIaRg7VKH85fadK3g65+bs3+9ZmUlJIokEgiUJwjB1I75DKJW0GjdR5JYCmwoKCtLHCiigAYfJiTCWHSsKYwFHEiIAWVBeMHCICHQgnlWU1YHko5CopKAuswRvulIGBy1pTFE02Bqg/f6SEXDeZIopKTxIigrAxbCICQIJQaLlwE6EBhdI70BZ6lzg08UKlIN5t85AtkouTgjsHVN2GpTH5i6CAkKiZGKJO2Ca7Sby6qmyObUzpDEHRIgThVCmMbOXQnG8ylKtkEphNYEUUgUKepyRlnXjaEMBqUNwjf+BKUXJDpBBi2MbRI5jwetiZNO02rTEXEQI0SAtc0NmFtFkGjoXMPFYETNeFZx8/YGD6+us7rQ5huzbSpdksga4yZk05LAzgiyu8T+Ct4F3Nu6zYuf/xLCCapSY6oSbUqsDJkSMPQZV+KSU4OEXav4o1HMN6oFeish7/zWh0iTmM1XRmy9vE+5M0THkrq7ynRaYCtJe9DCKclwmBF0IdIZhbUIp5FJiosSphkoY5AGnEsavogwWF/jvWS8PyYrSrI8o64qCpVTG8e8rthtKdxgmRIoqoCyWMaONVb0aZ0OqHVMpydpKYsfFeQig6gkaV9EBR1k7wq6vY6ZfZVHH27z1sffTqwjSj/Fe01uYXf7K5Sq2wRwOmXqLGV+l72dl/nc//sMUScnab2JLC5R63ssvjmgv1Hx8njOvds5D3YT6jMtdNrjoQvrnFh4hMndF9nI7tA9d4qwvcKiTzntEp555QUGKz1OXn6A3okZg8WbPG9rdodjvvCHX+fUQ8uUfUOkA1oqwruA3ekthkmPpVgjpEIg0apR4/CmbgIMPP6gr2q9JziGY8Y3vB55oGRmC4UtLWiBrRtoijGGIm+qPGEcoIM2SlmEqAlCSaIChHVU0wzhJZ00JmynDXzc5eTjCV5GhOmAQEE0g9mwIqwsA1szzDKK8ZSqzkEIuq2YKFlg+fID9BaWEWNDGRnkSsTevZqOc1jjkNMKWRpkZqjvFES9EFnHmMxSzSTKRrgi5oFBn2t7m8SyMTbb3TNEgI4j0lhBYRltZRRSULj6j618hwpFDRRG4tUqoBFY8PVB4qWQSmLrChUMQETUbo6MDBceHfDiH4wZb7RY6rXQaUCVFeS7BWVlSborZHsTxhsTfKZZWxogxABf7UDUAmsRtkY6hzcptuqigi4ULyPaZ9nLV/ijzz3LcFYQdyIuPXKeE6sD/LRg+9Uhflzy1gs9bt2ZwEH1/pAUax2vqdgLx5E6UQMfbuDw9zHy/jWB/7FaHOJAkeS1mvqvjfyOZDoPA8RjcBt/iF/+y5wccEzF6WgOXj8f4oCoIQ6gW0dykQ1MIwxDBoM+g0Gf3b09klbI409fZv1yRBUWTKp9hjmcGqzTTTrMxyVUFVoIjB0zmU6IbYI2QwKWMMYx3Nvh7svXEV5ia42vSrwoME6Ro8lcxom0oN+LuDdRvDQasCVaLJ9sc+7KOlJI9m9nzLemhNIjFmPSk73XBF+H1BLEG0FzH87Xa169Zh6PbxZAO4q5MyrZqFM2c8kod1iZsrjWxxc1S+0eYWWopjNm0x2cnuPiiNb58yTLV1DCIM0+p060uXjqQYSQeJfhRIAxOVmxgZUJqQpABOTOUFW7DIev8ur150g7giA8j+Mi8dIUUbWIohnTas7+MONCewFUi+7CIuunz9COzpDPNhHlHZKVVXSQ0vUaU5bc2LtHp93i1KlzLFQFUsDu7phplnH11busnBxQR655XqOpvaCspxQ6JFESeZhk+yZu+POC4x0S8I+rEQkhMd7ex/hb2/yuGoUaxMF2KQWB1iRJh7ye8uQjT3Dp5KUDSXnH1194kbPL60QoqrzAOUlMQFrFOOtZTlfASLxt1rHa2ftduT/+rOJ1vJg3poDwhpKDcFhx+8s32UrntNfey7esRXz2pducXzpPEm8hiy2MdShvEcKDrYiEhahLrVvsDZ+ne+4h1p+sSD4qubfpWJjCg1pjXM2o8ITWE8UJWzcdV7+WoWvJ8kICdhEz30FrhSaA3GGLDFenSNfD5wGYOSYecG9+kV/8jd8CAUGoeOztS5y71GJ0Z/b/UfemMZal533f713Oete6tVd1dfW+ztozHI5mSIrDIcUhKYkSKVJRkMWWLUeC5CgfkiCBLQUOYliCgdiBjSCAZcHWYslaIZGxKJKixBnOypnpmZ7e9+rq2uvW3e/Z3zcf7u3uoWJFDBBH1gsUqnHqXnTdU+e853n+z3/hvW90KVmL7OdMLbkYaXFKisJ38EOD08upVDWBKwgdge9pokzS2upjfQdcDUaSG8gKi/YkRScFIXFDNeLBZRm2gFI1JHQc8iQiig2FBUmB6ETI+Qp5kpEJQWYkmR2J1ALfoZemFFZgrBgVyAiUowlcF0dZ0qJAa42jPXA0wo7yEHzHIShLijgmH6bkSY5Jc4QLjnaQwoDNyDNJUUBRpIx+IwNKooUadeRWo70SeVaANBRpSpIlWKXQQYCkwBJRFNl4Y1MMs5iwUsHxqjiOg9YOVhbAgLwoUCrE2gxhBcKOmpCiyIjjAe4YbSospEWGIyWO8shFDlKjdYjjlBDCQyqPTFTp22kmTZN99BkWfZpXB5x/u8UjpzZpONNUHAdrLFFssElMmhRYEyP718jSU7Stw+7WbdYu3sYFgkpA5EaYQUJsHJrKBS9hbkKRCcFbey6vdiZIy/s49bjP8X2CZC/i8subDG7cZZoOebnEXTtgrYD6ZJlSpULmKNxYUCs59HLAG0IhybVPVCja7SENbfGR6NoUWdQh7sdkRmJSQ3tnjwxDkqekUYQ1liQvkJ0+Xr0MQ02WG2xQBb9OtrGLOzNNUKsh4z6VUomak5M0N9hrr1Gf9rH1ZRxvkcKEJDu3WL32Gv/dT/0NKt4sUbGHY0dTit1hwXpvg+UDn8bXCZFJSYab7O1c4MKlb3HxrVX+7n/7gyT02ImrTOx/nIeOL+Gnd6lsb3HhZYeHHithZicR3jwPeQcoyYP87u1t1s+e5Wi4zOLEEgsz+9jX0Pzyt77Ok16ZraCg5MLphxY5duQgb7+zwje+9Qo/VH6eKO9QqpWp+R4+hobtsNLt4mmfmpZoMaInlP2QOI54gH4bjBlpxJQc542YUfCZKAxKjkjm2tHEwyFFYhkF3Dg4GvZ6u3iupFoLEdrDkGOyCC+oQCaRUUTcHSCVgw4DwtChPlsl7rZIuh2CsEIYujgS8rTEtUs7VEVKEGWUjEAbh340RGgXrX2UX2Xu6BEatWkYQNLOMWWHnetdgqokGxTIpMDGBfbaANfXiJqL3Rky2G0TFUMqtQUmZtvI7A7vrsQ4MsPXUHiCNLWUPYtQgq3dlLvNiNwRTM0FDzb8MTiRZglFkeB7ciQGRCFUANZH2hRhMxAZwgzRIgVnisymFGmbsD5B9WAFp8jZvtsj3D9JVSjyAnqdjCDOUG6F3ZUhvdUYJ3EoV+pgJilSgfJ8pFGQxZg8g6KOsDVsAhhFYWe4s+Xx9W++jlSKsFTm0acfZ2qyyc6VbbauNgmw7J/07msIpJLjhPQxnUeOi1QERoIY089G+VTyPkhzH8W956wjuD9N+M4i98Gx+yeScQ81TjR+/3ThHr3mvtPRd/Mw/o922QdUorG24/3OQ/CgMbj37wdBaqP3S6nw/YDDR47w1FMf4MbNm2jf5cOfOE0hV1lr3maz0+L6rYjl2QN4RYVQOQihKExGkQ0YRik276CzNVKzj2iYsLe9ye7qJh4CtxyC2sXkEZn16bsuhAn1GU1qBBc2A1aSKeTsJAceDpiqGpJeytr5Jl6/hS5JMlsl8jXurEaIHCdwkPZ9TST3Pu/7pyV/0V/3wXXz4HoZncc4Sdlr9+hGMVmasnp3l6ZRDAaCtJPhVEPq1ZD27jWqlQauzelELeLBHqUwwK3VCCb2oURMa+c2VbnHox/5KK4sk5guLhlJIeinQ+JsSL16Ei0LEpOSp9vsdC6zunaB7a0tPvXxH2CQdOiZeRb2eZT3t7F5k9pwh9vXOiwf20/Dm6WqZmmoKWwRcrEds7fyJsv1Y5RLFea9KlUn4ez6TQ4pn0wbSi48fPIAUVSwvtniyu2bNKqPkpqIkueipUTZAmxMOx2Fq4r3teZ/lc5FAh44FAlBnhdjUf4oJ0GKkRh5jDNgitHPlZQjOqzjIbXmwOJhHjt9htmJOeJ+SqZz1m5s8Mj8MdxU0BrGpIOMknVZqi1SSCilIV6qcdFo7dBPolFmwtho4Z4jkoDvAB3sSPv8Xe0131VzcG3V4DQz1rN11ld+h9P/8GN8z/IkumiRoZHuFNq0kEUf00sRTkijoWjHLYa9JnqQkQ6ncY776MoVdjdjbrUyymsJk4+UOJ9YJgDdjFjLq9y4W8JJm8zuuGjbQCYKGStwQ9JUUqznBPUaXuFQXLqBPKTYLUn+7PcusTtIUEoxO+vz8TMTHAwN7327z+5uTj2QDHA4tr9M0NDYig+1MmG1hXT7tJoWVE7hwdC69I1Pq7tHaytmYamKF2TkuWXQz0gGBfV6iV7mMMwE3ShDpRmTFQcjXKz0EQyxaoSwOwLIMhwBnWFM3MvRFYEbBriiIBceg+6QuIhRxiALQ2ZHF1TFc7BCUalX0L5HlhdQFOTWYqxE6wKEGKF7VuO4PoNeinBijJug7ltsFfSjjIpTQllBUK6hlIU8Iup3UHlCkWZkCJwgZCLwqFYDUqOpOB5Rt0NmLMZAnqdEvYSwHBB6Lq7rgtDkeUac9imSPtp18fwySgTj6bJCaEVdFMSDHayIqFYmKKwgzQ2eW6IoUpQOsE4JK10sGqVCXKfM9EQDp1jkaNjg0GyJE9UB/bNNXnsj5pWn2nw0VLjaEuOwugc4o0CcoiiI3BsIvYocaDor1xF1n97WHjYs2HFDhjaiWuwRkfD8YoMNPeTKpuXcoEJTKsrTt/jEZ5ewN89y4XKZG+/ucayW8/TD80SVOb762y/TbCxx8AcO4gRlrGOZnrHs7m5xc7dHNXRo9S2D1gBhJbVSiWzYpR5Wqc5NsrlVUHR6WO2QmoK030ZMTZF3IrI8xeaGoiNIhylmrQnZZYRXRoUNpFdCFwPynTWGe0dJdm/R6e9RxD1M0iHLM3b8MgR3qMzOY/rb2GiDpQ8/xv6p72MgXHyRkMsqe91NVrYvcHD/8wTOFIOshT98C7P+bXYuXuDr7+zw0AcDlqZf4NVv/T4rdZg/8ASN8Dlu936V/W7Oof/0p7iZbzMb58wWDq0UhLqIHw5441yf+YM3yZf2seFUMbbHC8/+KOrGJc63+xDGTFZcpr0qDz9xiDxt8+71a5Ramxw7+jAz+08Q5W2masd5cWOLql/GLZUpaTWygxMSrR3iOKXIi5EPurU4SpPnBVlmSKKcIk6QJh01wY6H1BKhXWyaYvMMyHFEAdGQrC9wJyZGFAIJ1qviBQ2y5hCZryP6EUJYomFGr7PL8ccPknUlg56iVK/ieC6FcJhcqnLj+kuUSHEnSjx1+APMbW/wZy99HU+m2LzC0sGDWF2ig0aVPKwr2Fkfsn15hXJUohJZZGIRmaGaxXiL84g1i9mN6K6u0HSalE+e5oWPHuHHf+7n6EcpoWNolB3mJnzudhLcusvdzZy9riVNBa4taG8Pv2PPz7KUdqtFFHWZm6mhZIciT5BqGmEysA6YXUiGoDxKJcuw2MFEe1hSTHkZNaMRZYfdXkS41UPOlEkDn6vtmDkhkJ0+63crdLcUfmIotz0ENUQm0IXG2Cp54sOwj/KqaKMxt7+FPLrIVltw/fxd1lttgtDj0NE5Hj10nMH2Kwx3+qT9AqTgD1/Zwg89XGsZRjk2KSjIITMoOQIsEPdoQ/f89McP0nuIvuV+0fedgWljqPg7KoaxkHn0ZqyV/97XmvGE4q83leg7l7UWrdQ9IP1+gQKjIsqMuc73moQ/HxaltCIIAx559FH+7s/+LEKOuPbDvIXIX+H6pT7xtTWurLS5dKTJiawgCH0io1FZgZWKNM/JREzq3ECJ4/R39mjurCGqLr3tDIKcbafOIBqi0jbSLTi8XGdP9Vm/CyuDBoMgYnnfJicencbs3mbjbomdG00ePuEyc7BBLD3W31pl4kkH15VMLNSR3kihfq/If//UZHRkDErYBwFxjJvMB6+AKI6Jk5Q8z7mztslXX3qDt2+sY+MBiVthanp2RJHLErxeG5PO0zz7DnvnPWwekcV94jxna7WCLYX0bn4Vkm1m9jWYePqDVIOj5Chc4VJQoh2tkxYp9eoJtCyRmiFuepN8711urV7jaqfJyaN1auETXLrydZpTdQ5NPIwSGXH2LhNKMPXUT7BZ7DCTWHShiTBou4V2It693GTxyCqJVyNyJMaBUwuPkG2vsSkN5bKh6jp4XsjiokSIlJWtTYJqiD+zjOt5owbM8bk9HFBzfKSSY5oeD+41/sMJw/+iZax9MBlQ6r7W5t7fX45TlpUU5MYgtcJBIcTIOCHwQhxP85lP/xCRsGz2WkyXQ+JEcXr/Y+Q3UmxUUC5K6MKirUHUHfyeQzQwnKotszfVJO1AYlOSbk4pCEiyZPR7ja8pOb7XzHgfw/w/fqz767tqDsK5OU4/eYoj0uHLv/1lvvDzX+cnfvLDfHhmmylviCgr/IkQ3AI2YoSnMYM2LhlVXaGQE1w69yLf85kv8qFD7/Di5pCdQc72ekRjxtIq4DQwdXKKnVsJ7DZpSM3+akCyd5dBJ0blNVRcUOwVZFMPoXZ6dPrXaRzLSZxHePXdgH/0h19GInE9yf/4NxZYmFO88kqbb/x2G2FgekLzN//BhxGVMs2tbTZWtrn73jYb2xkuknJphCBFscCTOUEpYeFgCDsZYU2BMWSxQRaCStlho53Q6Q2pVXyIMmSS4gofJSTDnQHhRIhbGIbDlDQrmJouEycxrucTdxLSZgeZptSnyxihOHRglpu3thjmlsD3qFdLhIFHp7tLpValUi9joph4r8MwzekPDKVahTjPcUshQjpjr1wDOLhylGrqKIHJCtIko+TUAIUbOBhlSOIBJu7jY9G+AlugYTx6LVA2xrE5Wk8RC4feMMWVI/90RxaE5RrYAonFmCGiSEcjTNdHURCnEZ7vIqU7RpMSfN9Fe1PkeYSQoIUcP0gGo8CucBIrFEp6SBmglIdSLlIoJpXGV9PE6kM0HtMs/33LJ59/jZtvD2j4Owx3DX7dQcUtHjvt8VtSkLUz3rp8myNH32I6vsO5V79Cb7PL80/MsfvGNUrZMnFpntsmwbO32an1ubwKwcwHyXY2aFRWOfPJKT589EN86V+VufLqkOfnJzisJeqaQ+Vgncc/9Gmuz5U5+OwMOTHNVptuP+JOe4fW5iZ34oQkKgjLIbOLMxxcngf/MIdnarQzwb5DC2ysrfDeO+9w4dx7RNbSvXgRU2T3+d8mL7CpuW+EIHUHkiF6co5wYYKi1yZrXUGXHIpMkkVgVAnpu4jlA8hkg+7KeRj2eOQDx/nFf/Tf0xaakuhQ6DLr698kGWzy2NQR5spTvNW9TND6t1y6uc65jTbr0ZBnn67zk5/4e7x99Xf59T98lc//6Gf55PxDyMTnpUtX+b1/8h4/9xs/w5y/wG/96r/l1rtv8UP/9fey79CnOPPUMUrJFn/wKy8ze6XNZ37WI9Yf5Xm3zO836kwOtpkQU6SDhItbZ9FT8zz73Md58Su/SikuWL+zTTMr8/ihCVYTwf7QgXRA5GgcERDIER9VKgchcpSUKNcBDFmakaUJQigwkKSWPM0RJsbmXYQUpL2CwJFokYFNsSanFFYorGR9rUu8sYGwOW6thDERiWjgWI0qQuKWIQf8epnhUJPlCr9apT6/SFipoRwPnAqf++n9aCFQRlAqCa5e2mR7u8bty3/MR5/5KNPPHGYlK1PNXKb6htaLW7QrA5Zv/yal4Rk0k7gyoCRdvDhE74FZ3yMNc/zKKeYP+YTP1vjS5fPE/f5Ia+RpCiSDRGClw+01ixj08HyXU8tT+NLy8uXVBxu+EHieT6MxzXaz4Jtnz/KJZz6JTDex+RQ4McgUyKBnQWlssoajDUaGRKmgufMmC0de4NEzS5x79QbtnQ6VNQF1h1ZsedgV+MuLFO/dxOv0qVdKVAKXfLhOFqdY7UNviLFlrLcM/R5p8h6lgz5Z8TRfe+0iX3npDTQe9ekKP/VjT5Hb67z14mXWLmyjhMCr+xx97DilrS4rt9Yp+ilFno+m3GpUtOdjG1MzbgIcLbHFmB4jRroEO37M2jHt6F4S8Wg/G1ORGAWnyXuTKcR3IMcj4fE9OtKDgK8/n+b613eNAKh7jIVRjfx+VFeMnV3uNQj2/jRn9FJLlmbs7uzS2muNii2hKEuLI2sU+kkefcRFCYc3zv4Zt291aOgbeCkQdQinyixOBRgBw7UW59fOMV06RNzdorP1Dkmrw5OPHWT7xdeZcj7ITn2K2DSpeJsMq0NW70pK+5/Fnj/LgSMRj37gMPO1h7n+pmLt9SFPHZ2gNATuSNwJl8a+ZXqRZt+ijxEjOscoOM8wGEaEvn//Gru3jLFsNlssTE+OPv+98zReaZbxC//0n3Px1gqd7oBomBD3MxAWrRWOXyakYPnQEgeO7WNfvcJ7d7bpbN0kmNyH0C6FV0PXfdTSAmpwl8HuHroY8sTxp/mR558nEQKHGEHATvttAukxHU7iaJetdBM3/lPubG9xsbuD9SM+NHucx/d9nrWdl/itl7/Gf/WFn2HZn6bdv8XKrQtsvPg6n/vpz1MVE/zLX/tnzC1UePKZZ6lVjrJ/3wLOJ67zG7/2ezwAE0LbAAAgAElEQVT7mYgDDz2DlAssBpL3ajWm8wFlOUE/6tA2LZywypGDx7h06Zv46RLrzS61KjTKLr1CMOmMUpcz4SHG9CIY3bt/FeLk0T0reRDKdi+lWN5vdj0vQKmRyYXveziyhM0FWTIgtRlHTx3nm2ff5kde+Dw1Pcve5R5926a2/i6e8xSpEXiOj4eLKPSIVbGbs5d1kKVJqtOz1N0eETmDQcz8TJ3tvT2iKLlPuUqz4n5KspKjPK+8+Ms7hO+qOTi/mnA36SKVy2RY5fDRE/z6P3mTYz//PaTVPk7vDkvdiMlp0I8sI6Im6dUROiO1ZpcGOopwrcfKKYm9Auqm4W7TYtsVanTYAa7dLHNrPcemOR+oOfifWab97i1ub4fM7ttPOZNkO1vk3Vs4EwbrC4x6nN941ee3X94gUJbKhOIjM4p6vc9X/sUOdy7ENIxF+4If/+lDVGYbbLY79AcpaWwgyRDDmHrNpRRIdOgSxxmd3QGdLU0QBiM0vZVhx6nEvj9qQMpxQqs1JCtyPF8TVD3CksJmMYUUdHZShBT4gcNE2aUfxXgdS6nWIAwlwvHRrksyMCgH+naIqywGgeO5aD+gQFAKqigrEJlAWIGWGk9pRDjqCt0gQGgfrTVagLQ5vhOQZSnCdXF0ASoeCWOsAZvSbd6lXJ+hHJQR5QqmyMkG8cgdqFwiS1KMsAi/TNrrkWKoTlYJqiFRMqA/6BOnDlUlcZTAcTXGQmoEwroE2pL0tsjTAWE4iR/6KCkhH4xoPuR4jocx+cgfXHq4jofru2glKdAUMLKhRGAQ3LsFExy0c4Cy1jhzHf6n/+U6//MvNpn+/o+zu3aJE7LN/mmf1251ceqCeKfgWFZwQFTYG5R5/VwHO4iYfMJhbWuKlbu7bPa2kY7iySOG3VJGNHOA3E8QTp8nDhzlJ5/5Ya7/4y/x9fNV/t6zn6ByO8Lu5djQp8g2MLnH4lyVchiQ+w7DLIb1DHerx3tvXCO1OdWZGQ5/4CkeefYphNE4VYeFkqDdyrh26Q5vv3aJd77yB/R7PfI8GfkfW/PANxxGxa10ccIq/tQspZlZ/Ikq5DF5fYZ0uIcMGgTuBOF+Hz1bI27exXoBtpsy3NnCPTnD1OdPU9YzlIRhVzRodX8Z4RSUG/sY+gFnuy/hRRd4b6XPK+/1UC6cXt7Hk7OHuXr3Or/z8iVe+Nw0D506jCenidM91tfa/Of/w0OsOreZEQf45ONTXJYeu+fO8/ihx8mKZS5MVVlNDOVb6ziXzxEcWuSfr7l8YeEo59UkK1urlAw8tu/DbKYOV6OMJ57+YQaRYntjhd76y1yZ+Tj1epWSrNIH0rggMimLgYcjxZgm5JBaC0Ux0irJB0WZdgRuqNGOjzSaNE9I4wg/FDhSEHdikiQCL6C5usrQSDyRw3BIbjMGdkg4Ncn2bhfZ2WJ+eYGiEMSxpchCZDdjqubQvHmHaJhQm1ukPjvPVD3g6PEy1pj7fu61+QqVWc3f+dyv8NWVnL/9fIiTFmy1hsTdnEPONvzp28z4exTd/5MsfQytTmDdBiZPob+KKE/Qzl3S/Q7+Iy7GS3nvpTcBQ+b6VCoGT1vag4K7SUHaL6g6gpoHchgROh6Pzy1wrXkVuFfcwntnv831Kxf57Bf/M85fPM/yckim59BJikcfx+kjZk8i8nXydYtQGbnwiW0VlW2jrMvmSUHpbUO2O2CnUkU5E0wIyU5u2dkos70TUzcFR+caqJP7SNZu0GzPMukeREYdiqiNcG+iAgOOppAf5w++VXDlRpvJwDA5G/DkootbVlz+VorZKKjbgrBR4vjHH+HJ6jKZjfnFf/g7xFEM1pAkFjOeEBTGjhyMCkBwP/kYHozj7ejGQ96j6r4fEbb33IdGDcBftO5PHe5zTu41FQ/Ey3+9m4NRQ6X1+/cqOaYP8b5jAmNHzZMcq7jF2NHIMhJ1CqkYZzUBkAuFo6aR8hRHjgz5iR9f55/92lUWPvfjXL78Wzw3o9BKsdlvUWpomlfaHClyprwab27e5eV3NijZIc999gSbdw6ysnmNnZ5msgGN/Rltx5LOHgc9wPP7nDn4NKf8Jbb/6Nucu17ic8+cwV7sjcKjhmD6Bus6+MGIRpvkGWKc3iwYCalfeuUsjz92Au179FNDLyswCqYqIZfbAzY2WlSKIefPvsXvfenfEQ17JGlGFMUUFqwQCKHQ2qVWb/Df/J3/gqefOjP2vR+dOyklnwT+9f/2C+S3V/AqFbxaBbdawe7c5MgHz5DK6yx89BSzTx7HkyEKiAgYJl/H8+tIVWMgMtLkGipfY6WZ8srKDvONgCP1w8yHS2y0N3jpxkW++MnTTFbmUMIlTiJSMj70g8+za7ep0+D7v+cwrcEm8c4N5qsLFLbG7Uqd1Y020foKztISWcnljURzpjbDrUHEbq9J1a9QCWcZGMFObjh66GkGqUPaWmEw6COD/WjHwzejPIXMgijAlQ/uvb+KNcLoxg2KeTAxEELgeR5PP/00v/Qvfol+v0+lXEEqyfb2Li//yWt8+Te/QrA0j6MLao1FLt9YIakMmEgsgys3OLkP0p2XMclJjD+N1RppCpxOBtWQOHJZPn2Ukq4xu73A699+h5JQuDUf3evgZHJkKGPhvp/p2KlIylG2z1/WIHxXzUF7Z5eomyGUixCG6GvvcfTECX7l/7jAD39hP88+tYyN+9zZ2Ga6vYq37KAnfdJdRb41oNZKGOYRSXKZqScsV15TdG9nVIThpMqZU4ICxVYPqqnlWElRVAMGlzcQSrPbUYS6j6oFZFMV7N46vY7En9nHL7/c57XLd8njJtOORKSGz3xhli/93oC91ZQkKpioaT734TqNo0vERZ8wH9K81ebKuT3a7ZT+MMckhsOHQqwCqwVCCWyUszeIqFcCSrqg18tIM0BL2p0CL/SYbHhUaw5B6OFojRaGcuiye7dLVIBf8fHLHpWqz+ZGF0cKhDE4QQByVNB7jiDPclq9Atdz8ZB4nsbTo80yRSC1SxoNkNIiHY2LpeQWpNbiheURl7qwZNYgbTEOJdFkWY7nhig/hGJAnhQjzqz0EVqNEBrlYJVPFBckcU4RKrTrAQW5MXieS65GFCfXd0GOLEd9P6QcVhBFhMlijFRjeC0HBI4zEh1Lx0MqPfKat4Y8z3AdhRUFBgXKQWsXx/UQ0h1HwCuUdEFICpsRmxwlJEoYAmGRCDRVQu8Yz32oyttrFa68cpbuWpv+tCQ1ER85XObLXps+llNHDrISSV46v8GgnaCA9vQTvNp9kc3dPaYWHB4+U+bopOD8DZ/dqZTuVotHT1Z59HTA2uUL/KsL8NNHniN/5w754Ara209afpqWV2J9a4Un9x8lUPD6r7/GN/7oRS52bzEvE464Dqf+kx9j/6kjTM9P44ZluolF7sT8ws//S/rNd7nb3GC7uU2/1SQfO0e9fxsSWiMdF6lc3Eqd6uw0blhFei6YAqFLiCLHC6dGQTlaoVyDyltIJ2HuuY9w81d/g9p8lU8+/2G++PEfJpQePXKcfJ3O7SbV6gGcepV21qSiKjSbLS5cvYujMxquxvYtF92MJ+tXOf/SLp/64FM4oUvT3KBnrlI4it+95vIzZzwKc53dYJtWySHswuuv/xueefpvsTR9itriHW5t9fndl64yPWzwxTOf59zAUKgyWbBIq99jYjthbsLQKyxvGQddtHEn6hRBjbNn3+SFD3yEHWcSVysmHU1FSXJjUFIhxEjwj3XI7chVxOSWUbp4QVbkGFOABKEdlADG4X6DQZ+knyCEpjwTMH90kdZehIhabA80GQGBVyLNBMPmOu6wzbDtISqzoxTxYYe5YD/CbtApBpRCRXWqysTUBK6rAYE1D2gFnhLMLszz3I/+HA+fmaLVzdjcXuf2O2cp7XbZ/9gnuNsrWOpZPA5g8wYmVZg4J092KCYX6FczXuzA4oKi0Rjyh1+/yMXLr5LJgiOnq4h2H2Es5WqAsx5R8R3KgaQa+AwSCITD8cUJuPCgOfg3//p3KZU8Hnr0SX7pn/6vvPD5L/DiN77Nk08t4gcxadIk7mwSJBvIRgVVq5F3QfZbeImlkAMKs0L9eMjdQOJFOQ2dMaNypn2XXAZ0erDPMwxmK5hqiWx7E4RPv+9Qa7cRjovBRcRdBBpdPcIfvbHL7bVVPLvJjCMom5yHnzvAi79/HdPq0GrtMT9XY9+RaS7dibh593W++LlHqZU0E2UPDeRZgVYj1LowIEVOLg3FmDI5KvIsRTFOFh1TipSUWOx9550HetQH2oL7VcN4lH8P0XwwdRgjjXaUM3FPKCj+XwhZ/2NediwsvqfVGJ2KEeXGmHspsvp+I2TG/HqtR45FQeDjeg6FHU0YpACHkVZNiArlcIZTx6b57Gcb3Hrzjxh2WgwSn8DxOdSoEnp3EVnG0vxjXO0WXF7dY2ejQ5eM//2XzjFVmWDrxgoPfXCRwycqNFzN2m6ZvcmE9nqbp55ZZmrKsLq6xaXbDs8dPEX85jpedAMxcZpMTzIUgn57yMLEBBK49TsXuLGzQebGLEyFLDx6jANHDlA4DrmBXIyup7yZ8OUX36G18ibn19YYDru0O222m02KPB+zPQTC86jX6zx15jH+5o99EcdxmZ2epBQGI+rK+Fzfv17ynGjQIU/6ZIMWes+jMIZ8eYn5xQY/8vCHObN4GoUkswZlBwz2BtRry4wMJlNcHAbDLte3rjNZktQRxDHsqJiq2+WVs+t87NT3YST0zToRO/SN5vVdn0/tc0jsGp0gJ419RL/D6vrXWF74FDPlk1QOvcH17h7JrVtMLwacnDrJndQgpUfmNkjyHNcWVFzJnrXctg4lkaBrcwzihOHONkdm99FB4VooiXGOjmVEL7Ijwwkl/wNTi/5vVlNi3BQqtB6nqwPlcpnPff7z/MTf/glqtSqlUohSo2ve9Tw+8KGPIP0DTM97vHfuTXRtkublm2h/F2oLBGIas7tLbmbwsxLaOAibQxGjJktE5YLNfpXJZcWb597i9bPnCCtV8ryO8hOkAKXVCHzIDY7WI+MZITBj98fvpqP6rpqDTz7+vUCdt2+v0cybtPZW2Lp1lxyXr/3OKrYteeETYByHnBg5LNAShAJpLUEvx1Z8XrzR5NhUg3frXdZUSp4YKmsDEguh6yOyUVFUaVTZ99gyl1e2qO+bIEoM169mzDQE03MO3biMN1Hh1sU+b73XZrs1RJERllyeWdS8dsHQ3SoQmcF1oNbQLB33GfTb2J7inde2uX29S5EaGnWNo3MWZjWy7JD2M/q9gn4sgJFgprAQSU0uDUJaXN+lPu2xerdHtexgE4suCUolTTZMSFNLIQRKGlwNjiMQWuEqSTTIcEqjh4TUAu0IpNKYLMeicfwQm2cUuSFLc2pTAcOkwNcCjEIpUEqAr1B5gbIKVwqQ9zjVBUJoskwyaMeU6j44Idp3CB1NHGfkeY5bro5QszhBaoHVLtYqyvUqbuBj84S8GD32CiQ2L7ASHAS+F6ClJImGpIWlpDVFHmPHPr6OlOjxFEG5/gjttmb8laPGIlEpBY7rY8XofQhBVsQIK0DpESdYKAwCYXJWs4gk6TDhFFQchVQGKRtMTJ7iB75vQOvGO+yuZzQHivWe5YVTS1T3b9K5mPDut3dZMneQfYMtRjCh507T6kV0BwkTrkUsBzQfepQr597Eo80jxxrMlQOaGwXDS3f5+COnmbr8LYrdLsqZpVALpH2B5C5LjQJx6TbDrRZXXr/EOzevcGd4h3Y15NN/67/k9AceozY5ydpmj8svvsPKxXMUm9c5++q3yaINusmAOE/Htobm/mgSJRHaQWgHqTRutYEOyyjXGxXAJsNEKcITiMLghQFhLRidyywjbg6Imm02/uhPSNbXmfueeZaOHmT/xBICS2oKBrtXmK4cJA1qDEUORZ9W6zXObmwxHMRUGwGucrCiYLLc5PJGFy9MaVWWEe4sWnjkEuYmZ7l+paCTbqGEg/Qm8EszFO1d3nt9g0ce2WGuNEelWqJzc4vdK2s0lm7zx1de5vThF0gdj9nGJB0rOb92i7nONv7xM8yLjFw1UKqMzDVlcZdyLnEDQUMrPAHWGPLcIrEoIRF25PUs5ZhiOYJuR4UY3LefK4wlzSxZlBANexRphjQCrQTp3gAT5yB8Yt3ArcfIzGCNxAoX17GEiFGieC0kyRKitEU6KLGbdGgcPsbs/oPUJ6fwfQ8pR9QVk6cIqcYUQEFtIuSzP/Yk59KMV3/zj/GCHrOTZSpOwLmXv8pi7SD93VlscRA3nyTBo5CKgCqm4vPNboepJxrMnNZ0wz4bxYC9fhuv7FMNBHkkiVNBGwephrgmpxGW2T9Xw8YO2dByZ7v94LmHwHOqrG31aUZ36Q1zzn/7dVbv7DDcXuexJ7vsW8rIlcbYNiIdUWaQIAuDTiU28Lmx12a5vsSb1VsUex1oJThem8wKwrABeQZSU19apLo8xc5OF39ykjw3rF+PmJiTaM+jKOrIMKR5q8+Fc6sUZoiSgompOodmPa7eKMg7fUgjMgpUNWBiscx8ohn0Ja+/9B7LMyHaTLG+2aWwBVlucTyHJMoQVo0mA+aeoFiOKUPFfdtTIQWmeJDge8+k8F69IO8fG53BP7/+/JF7k4T7mQD3yUt/fdd3FmajxscKgRx/MjkupO4z7a29FyYLgOd67F9eZt/SPgpr6OcZSTqk4gg8pUZFj5qgXDnBBx+O2b15k7W7ObvDIVGhmarOUJ+/ja8EV86vUDs8g0ha2DTB9Xye/ND38trXvsreXgsb1LCLB2m5c9y8c42QXU4dm6YUKPZuD1CR5fj+acq33sHupMjKLHlawXQzdJZQCS327h7pbsSN2+tcWLvG0PbZ2j/DxJnTTJZL5Eayutlj9fYWu3fuMNy4xbXrK3T37nC3vccwjchMTmEtWmkC3+MLn/shZmbnqVTL7Juf58TRw+9zenogMv2OZQsocmw+AtSqtVnAMtzaxMguVRlQc8tYLLktyIbbVIP9pFJTiAKT79GPrnGnt0WWxkxOTEKh0SrFUTvs9FtUwyE9b5GGDLFEaO1T86dptgRR0aYQ4Hiz5FoQ9XbZG+wyP9Oj4U3j1xyGrR2GW3eJq3UuSo/9jZNkQlEPS6TDIa24h5vG6No0dQyOKmGEO8q3ynMcAzUt8MQ9rP4BSj9qFP49+p//D9d36GPG312tCP2RqDjPM4Iw5NTJk3zsYx/juec+yoEDyxhjaLdalCsVXM/FcTSL+6chKLGeJnReeo/hziUWGlM4XcPgziaLUydI2zluvgh5QJaPnhXa0ZiKw/XukOUzZYI5zdzgAFPNPTrbTcq1CtWqYr3sj4xt8pFNbTGmvCkpMfczRf7yvea7ag6eOfkE87PHWFhZ4VrrLmv9g7SvX4Us4ttvKNJIMlvKOfNQGVvLyOMM5Qi0L/FqmmTT0tuCQd9waOE05VJGrgfsRSmXV6ORY40KmJg+Qq/YItm7DZnCqCnW9hbw99bYXu3gFD6zB+ZpG0E1gnfOtthZ64CWlEKHsjYsVTV/ciHDpjnTZctkVbF/QeKIlJ2Vbe5swPaFFvVgkn1LHrJosm5jKtYi8oKKp7C5ILUWYzQihWE3JQk98mQUS62BwFd4EibKLt1WhsgMOs8R0oxQrsClyDIkliLJyHSKKyAzgk43RvsaP1BoR2GEwCiF71mw9zpQC7bAURbtOiAt2vHRyuKoETpTpBqnkChr0Y6L50CqNFFmybJihJAJjXZ9cBywhlJQJosL/LBMEUekRqDH/5frepTKJYzIGSQJhclRrkZqTVEUOCIHMwpd87RGew5ZniFciaVAIRDKGY2GixQhDK47tnYsciyjxkUIgxUaK0YJg5KRA4gxloKRlacU7n0tAwJyk5CbiJ32ZYTvk7kuriMI3QLlPcPD+1/mqWcX2d4sGAyGNDcVE/4BiuzbSCCgxcHKFvNHysQfnUJLxYmFGcgMRV4wHMJOXEMtf5iV7VfYr1KOPu2SdQTNO4aFYcjDizXStZeAOrl7kIx9JKnFGbSYrTuksWFrpcOtfkSv6jK1b4Hpk6dZ/tj3stXOuH7xba5cvM6ldy+wdeltht0bZNaSmIysyEdImwQn9CjVysSdUcOlfB+hHUxh0J6H0hqbF5gsAWtGXuHag7xAWBfXlRTGkA5SsnZEuhfTvf4GUuccP36Yg8v7kUiGRY8s2kIkm9Tq8+zKnMTukucbbHcucaef4pclnlKEnk85kGTZDleafWphQRA08HWAwCGVU0xOHKXpbrDe2WSmvkzoTFCpdGiXm+y8G7Gzc5fS4kGUpzEmo+h0GGxtcmn9j3nm8MfpKIEIXIJqCdEJub3T5CFlqVpBX1dwdJXQarKJnDRKqYQpvpbYQpBgRvxla5AWHKVGYS/Ye5G3Y3rDiBtujRzfIzmiGCHJhZK4QQBGYtOc/l6fqJORlqaQpSq1Sk4xjMiiDK/koQ/uZ3Blg9r0LH7NI4kTXOGAm7O52+bQE/tozMwQhMFI5GpybB5ji5SicxkZLiKDffiBw0OP1vnT80POnd9httakfuI4kzNTRDdXEFmfnIOYtExhUoyKSFTA0ClT1A1rruCZx1zMvOVGc8Buf5cg1PiVkDRKcbQiyyx73QRpDQdmXOYPVvDQiLBB5Ck2Vx5oDkRmOHHsCM7aNu24x9FHznDlwlV2V1a4akNMmqCfhPl9NfAHmHSA0grpOShPofqGtGXJ5g3z1dPo6nUSUvZ2E3TUAqkovAnKE/vY0xvkqcXGLoU7Rbs7g9ddY+/WHuVqHRnWiI2DigpWLqzTubNJY76G6/tUy4JGxePSSoK0CVN1QVDzmJwQeDpm0lFseJbB2i6PnzzOgYU2F67cIomHlFyXcCLk5kqXOMlJM0OaG0wxojEWlhHAc4/6IyBnJGK2BjBmjPTa+9SC++fvHtVhXLDY+xWF+A708YGbz7gx+OvdG4zF22Mdxfiz3KNM3VtijLjem8ZIKcbNmCAIAx5/4nEefvRhjC0obMYg2sS1ZQo9svPWMkDrEyxOXOHkw0e4dbNNr58RDzwmgxnyxOBIg7YbzIW7PH7UJ+jvpxLW+L6PP8uf/f5vk2UJnR607CwiPM6trXMccYYcfdKjeSfBtiRT1mPR8yjWNhB2AlNfIjclTJygVYRX0+SppTuIWDc5edWlVJnEP7iErdZY2e7TXt3i1s1VNm7eprlyg+7uClFhaKV9BvGQzI7yhhbmpnnkxEOEpYAf/sHvZ2ZqGtd1RlMmKf+CkvfBUTt2vcKOvpT2qdSqmCLm+OGD1ErVUWNgEoq8D0WXUtigRYKxA7Jim25yh900IfA1Go3vltAqI8pabEc9ZksFjq6hhSbFRegGlWCJpNehnexRdmcJ9ARFMGDQ26a90aU/3MWtzGNdiRn0yftNuq11OnstTkyepCcZUcg8l7hQDLOMmhSECEK3ihUa5VlcY9BIlKPQ4ymUZBwyNrqo/v+buo1KNARQqZSZnGyQZCnGupTKNT7z/Z/m05/6FAsLi5giYzDokyZ9ouIOqnEU7VQolRzm3Ao31gTdboWbNy6y/NEXSIoW3bVVjteOYMUsThpii4xcuRhHk5QURRX6QrF01KXrgDe3yPRyC5FGICsMdvZG7JPMYpMMYQ2+UuR2RJ+8p4P5bmyTv6vmoGoMHzqyjzOPH+XSTos/EYJ3/vDfsXX7W7TbNd54F+LN2/yDv+8xOz8k2TTo0OJXQM64xB2P7W9scux7BYX8ALVKQr20y253g681M+bCCtnSEeYf+yHc6ze5fe1LXHhpm8/+4Af51tWQR/au0tlu4Rw9hHfoMXZvfYP4vRUu3e5hhobKhM+EpyjlEStrEZ51aWYZZxYlZ5YVC1OQ3Omw6cJXXx/ysSmHA8eWEKHH1s1ttvs5W2sDFo/mLJ2coleBfCul19e0dmOKTox1DXlm0M7oxAbkHJwvEar/i7o3DbL0Ou/7fuecd3/vfnvvmelZMRgMBgMMNhJcQAHgJoqLSe0UpZCJrUSqKIqWuCquSipl2U4+OKmSFMmKFKmsUlKSbIkSZYqbuIEkNhIAsQ5mxcx09/R6b9/9Xc85+XAbAGVZMqtcsc2nqj901b1dfd577vs+z3me/+8vcbRA5yV6ZKjWPfzYpRCScmApC0MySDGZxpECFfpsb42JGwopHQLfRyiBVIJqaBn2+wjh4Yc+cehi8oxarUaRp7iejxL7YzvGIByBkhJRSpR0cDwf5Rkm/QmWjFY1JPJ9fMcl11OTtwMLMaUQIDwyIdH784uUOXG9ClaTpQNGgyECqDUjvMCjnGgiUaCtwJY5UkrCSpV8PERIi5LT8SSh9g3STI7yII4rFEWOzgYYWyC8EIHE8WIKk1DuM+mVcqendEpiRAE2w5oEhINBMtYFs7JgOLlIMmmxJz1EYFme8Wm5Jwn053jvu89x/uWCl759jeSyoLMV4PY0h+fgJz7kcPubNKmWPHTbCo6niG+JuOV4iHIbFNbn5sUqs9zKcNOyW9M4MYw3hqgs5MTCIa589QZHzQEK9yi5nMNKCb4haDTQzoSd4ys8s7vK9mzIYvM4t95zgCPvfC9JVvDnf/51rj36Wcab57FFF2kLUmtRKgAEjqNQjsSLfCozNRrLs2y8eHNqEBfHCNelmOTYrADlYqUgt/nUPMj1EEIjrEZnBek4oSxysuEEM0mAKSVq9vA8D9/1Zs4uH8fqnH7Rg9HLzFYdJk6OsglKb7GXX2W3ULhKEs8FuH2Xlh9QqRgub+yxlgiCUnCrE1IVE/raZ0SbqHo77RmXzd09Gp4kkB5R3aVrqwSp5ublCyw1WpSexkSCMQWXrm/hbnbZe/d11NwxJiJAxBG3njjC06zjZwOSPCctwPcUkfLp5IbNvI91HdzIUAiJpxTScygRiLIk8Pz9TtW0uERJTGko8wzPccCAyQw21y894nUAACAASURBVMSegEZMGnp4vs94kNLf6TFOS4aDHC+StKKpwFBbH6sz4sBBrSzw3LqP05rBizKIIsTCEUQ1wPQv4agxSo4RTDtnpszQg8sIv6Tc/n1U+z0IfwbkFIVsE4MpZ9nqDLm+Pmbx+BL3PfRevvLrf8y9zQ/icAMtBtighak36YWCq2qTxbcfRi05XCDl69vb3Lh4kYOLAaM4pb+XEktFWWaUg4QwUNx/ZxMzX+fq+QzhVFD1WcKmAp4DoNwdcuLYUY4dXaAQgk6ScvUmdF9+jj17jG882qXc3ePhD/rUWzWKQZcwKHACAbWQvG+YvNRh7rikELcz37rEptdnc2OdYb9gpr3EZPko9SNvIbhYsvvC8+jukKNvP8vWNY/D3efZW9vGefN92GqT/k6fwbU1Vi/vEk4kFb9CxS8JyzG9nQJfOPSylDOHPeZmKrhORtrdZWIN3e0hbzs8S3zoNKPBGk7WZbDT4cRig9mVGl/zHfrDjNFEM5yUZMlUvFeYaYKbZtPCXSDQatqNKkuDKEGbaQfU8oZHwl9DCPKaYJm/kcBM61S73yl8Pe/4no43jM1e0wvsn+zKKTvRWsNrbtHTH4nc58RLqYjikNNnTnPi1ElyWxJTkukd8lQzBHxfUglcfDGLY5/hvrse5IknryFGKemWYOiA7iQcXICH3hYQtwuOLczznrfOIN0QVVcsLccErk+vW2Fns049brGzaqjPlLiBIOn0WAiWqeU19p4Z0DDL6GAZTYSRFhkKROxjpGa42OTq7hZ5K+bIyZMcOLlA88AKk0nG1x+/zJUvPUrWuYzMO5QmY6jB8WtgBFHFI6rUmFma545zt/H3f+zj+K6HsZZJklCUBb7v4ygHx/kOB+Z/R/dA69dmyg1llpIM+9TbTcJ6lU/85MdYbi+gTUmmx4hih9hXZKLEsRmF6TDRPSZG4UiFV4mQiaLZCshMh61hl+3UEJWCJeUhSciMRIsWQSCoRFv0hn3ixgF8JUniABGFOGlKb+cazbCJDiTah34xYby1jj8eMT71XmTYYoLADzwabp0sFUTCgnSYc8PXu3RS/G0F0huhxP8/5cHfRhOz1tJqt1g5skJWFLi+pBJG/MAPPML83AzW5hTZiNHeq9TrPpOtr1LGbaQKQbnTP1IK8jxipzNiOMpJdEo/36O/ukNr/hzCdDAqx8YOo8DSUxlaBczeOYMJNWulYSPXGASHD1TpmpRXXtgD5VCrOrhORiKngu69UU6/n0zHoKSDcgCSv3Pt31VxkHztG9y4Drvtk6SVNnedrHH6lz/EjvNTfOk3fotXvvgYLw6P8IlfeIXf+eUa44sOS2FG86SLf+s80YkzvFx8nif/8Q0+/MsJ9y6eJTg65PL2Ni3Xo710Bz/4m79NJ2vgth7gTd6bufZnn+TXvzJPpf8nLKRblG5IUD1E6S/x9Sde4OLLQxpxhZo7nUGr5ppaWZJ6sDcac6+w3OY7NAJJCgw2HLYngh8/PMsYyxe++DRXbg7RWCo+dCaWhUbJQKdc3DQ8c1Wzl0JeStzIpSjGWKFo1jzmY8HJtktzqUm60SWXJT0MVnk021WUgklaMEo1YehhDYxGCbVGTFHkePWQ5kyFdqNCFIUIpZDJkKw0tGqKUeoQRXVqjSrD4R6hq4iqDSg0yTghT1KUhOZsnUq9jp5kJEnBeFJijCG2Y6QfEUUVnMBD5BOULqlIA5MRunARKiCMqmgMRZ5jCgWFpSIsSvtU3AKBRhWgi4R6NcLzA4x0wE5P1gorcOotPFeS5UNyPZ4KmY0mDj2UF5HlYwLHolWC1lMhMtIjdC1FNpqKZghAuvieT2Ek1iZIpSnNmKE2bOmCtVLwgLNBy69x48pz7CYhYesQBytws/dJWoHHgcoZDp3aYWOtz+a3h/zDf/pH/JP/a4V7nrtO81yEWyupyF3ajR7WaIT8F3zyD1d4tDjL//sHq3zzU+vMDwzGqULQZ3Ylxrvaw+zuUfNbPLfbZSloElTPcT25QcO/zrF2G3HyDK/e6fDr377E+hd+lxNvWeRNb7+fpeatvPzkJT7zz/93xoNdIjPElQlDByZaoYTEjT086dJcDFlcabK4NIsrI558uQNOQOiJKY4113hxTNIdgRdg3GmC4gQOXuDjSkPcblDYgGQwpCwLiiQhG++B1jiexyd+7ie499Rp6tKn1IaaCQnqpyiNZpccT07w9Jhe5nJpK6WRl4wTn3tPHmcv3+XG8Aa3LEj+8pMjjq3ElP4ixgqKckKuPQ6058hPbdG9uU63YfEciRMHkM5y5EybtccvUDk2SzRXQtVh69WUlr/FSFv+4E/+Vz7647/C8sIt3Mgt38pc3nr0zQxvvkC322GjoxFBk9m5BQ5UIwwug94QJzU4YuqgncUhVd/FMYYs+etDGrbUjLeHTJIBjXaNwPMIGzFGT0fr9CQlGXYweUg2GJIM9pgUmsbhWWRRcP3F82QjiR2Da6B9sEW5qbCVQ2zvCebjBtWFWfxAkEmXuSMF1699jqZ/lopzBIyLHt7E7v4qorWDt3QC7ZTkRQ8cRZ4r9KU9pNnh9Pe/k+OnV1B7gmf/ZI3jKiKq1NnLE8IwRM42GS9XGMy5fOYv/4hP/OQnYFayu9Nje2cVNezgLo0pN3pUD8esv9wl7xTUGyGLKxI9b/jUFzb4gfvvZ33V4ZVrI1Ix+/q1yp67xCALmeiAJAM97/PIh+/i7o+8mU/+yq8yGCgeuz7Ljd+6zn/1sRbZqkRWJ3grIap+FNOosjZ6mvwPr3HfT5acve0BmpfWGXc7VCoNqrc9wtlf/hn6I8nywx+mVr2DrRfX+crjLlH3q7Qn1xDBAdxgkd6wx7efepa1p3dpzC0y1+gTW0M1K/CFJnMsw2SHMwJmXQ+pIC8Uk56iPxS88+hxEqt58nN/ynA8Qjnw1hNNhpOC22dz7vzgLBeuJGzsFIxSSDPFlZ0Jsa9oNVtcurHD1l4fx5FkGSRJQpKWZGhsYTGvVQH7u+21pH+KRZ0KbaV6Tbj4HZ0C+524y9c6W9+7qoPXcqipdwM4nrOPz35tTftYxX2M59RAysHzvenrHRelJN969llku82ZN93NshwTuzG7O6+QMEO93sTIhJG5Suj4NLwjHLj9doqLq1x87hpX9tb4pV+4h+Wb3yRoNxFuilvfwdb6+9qOXX7zVz/Ay/oM/89v/QXZ3i6VXFJ4TYh2qM5EVLo7VHwFmaBzY0KlXsVpH2F7d5XZKkQzLfTyLLvzgr9a3eHm5/6Uuz54JwcPHUVSZf2l6zz9yb9iuLvNnNlj5EzoWcGkdHF8j7AZEimPI6cX+f5HPsDi7BL9YZ8kzSiLkk63yzMvvsTSwgLHDx/GVYqZmfZfu9b/9i4xZvoMl8ql1pph5dQd5GmflsmpyxCp7VQvKDw8bw5jLWNKAilJdJ9+BpujlLgoGE4i7lg5xbXRC3iyS+xYzq8POLkwg5YNsFMvHikcGnEVI4eM+htMYoFwBcJEeJU55g7s0bn8MtHCAnOLDTZ3xmSdLnWbM7KSR5/5Ex554L/EcxWb2uA7Iedmmq+v7T9iL+BvjddNDV9rhBm7352e6oyU63Pu3vt4z/u/n0tXL3JsuaQW51jdRxiNo28yF38F6e0SrZxmnKfkxQRpI4pE07+6wZXLf8mJu84gZkKO1O9iRp1joZ/hVHx2+j3qsw2KWcWLg8s8fv0ZVpI7ee8js4jYobvTIxkOsOM9+sUGyha892Pv4Im/eAZfemRZQre3y0wtYO9yj0a9xqA/QTkBwvOAwd+5/u+qOGCyjbt7kcp4iEpznn+qwnNfdZn90IP86M//PMOP/ff8/r++yt7nfo2Zo+9m8f4JT376y4w+vcbSUzG3/4O38NEfv8Dv/P5NikvXGfQNO1Jjj72Nn/ml34G7Y578rW0urCcs5RlzhWL2lh/gn/5vdzBY/Sj/9S9+kV/8+WOcqT3Dt3/tn+G+MqKnLYwGnKgIjoc+1dBhZ2LZmliaY8s73+TQXFRMHIdB16EsQlbXBlx6cZMndksmJVQcWK4Jjh5zeHBFsLpleezpDFJYkJKmC605wd3vqTDZsSyuzNNeqKEw+CU4LZ9rmceCq4gyS5pZdjf7FFIiXQc/kIyyElUKfE8yHCfM1qYW7VqX9CcZaQnSCMa9CdVWlaBSR3kapUAayezMEfb6XTzHRZcZyg3xnen8Mm4F40Wke3tMhjlZMU2IfOXSDBU61+RlzvbaNvl4yMxcxOIdt2KdEOVI0mJqvhTGIfgKR2jC6ixu0yUZdskmA0DjhxFaFORFAdJS5BllUUyT/LkZlE1RFBQmA1PgSIXjN5AkGJuRpX3QIwQl2IQig8lknSD0QDpok1NkE0w5wAvbuO7UkMng05lYLg87nGvVGNgms807WDmySW17k+1rz/HlL2bc84njmO5VVLjMR3/kl3HKv+Dzv/t/8Js/NsNtK78JS59A6B4UA+wgR9/UWA/c40OE2+BB7z14P/73UCur/Muf/jkeed8sVxvn+MoLY+7Y2mNZCVY7OVpmFMc+wHnOc+zQmPn5RUaHbuHKoRb//LOPMRxv8pGf/VH8eIYXXujxG5//V+QXPknNizA6Y6jH5I6DbbWZO1hnpmiytHKAMytzuIHH+k6XFy5dY2Nvl163D1JhcJCeh3L9qXC8AjKIqDXrUyt2pXBUhKccbJaTY6YJb1aiS4tTa+L6LtWlJTpDj8HEUo8KlLQ0nAqb2YBVBE015EZ6nRvdVxisX2duYkA0uX+xZCPtEERjDkcuz62X5Bc0zbvqtAOfsfXJTcCiCHDtFk7D4Wz97ax2U8b5HsJaZpw61wIfVY7Z6K/TvdpDD0riA5LolMPmt4Z84w+e4P2P9Dm0KDgXONzp+CTjITmCvdVtTOngFAbtCmx8cEpbsJJCCjxn2uWghCGGmisxhd4Xv5eYQiO0mTrpNioUykUnCaKcjgDqvARb0GzMUGQ5YeDiL9RxlY9XX2T1xQ2Kbbi+OcD1K1Tr83ztBcVbHphlvqFYfbXLbiaZFQFzCz6zgeSP/vAv+JUfFNTdIaZ8Hpk9j8oehYUE8DD2BlI/i9Ehk/FRNvqK6vCrtOqb7PQz7tSWRd/we1cTKn3FB+f6rIsRpZsz07RU2pLPX9b87G98hKje4Cul4NmLQ8Yv71J1YbuUHJxrsvXyEDN0iX1YDAvOzEW4wuHErfP8q69cxe/lnK4vcGr5Vr62f7tXDYUc9XC2E8TuhI0XA16dgfqbb+Vnf+WXePZqwTcfv0r30nNEs2eoHE659PUv43xhRPvWBrVTRzn7jg7f+uI2enOTJB3RayzTfPebeOCDP4iddXj1yxPWuwGHTIqftjhw/wz3vrtF1n8T/8M/eoV/9o8P4137NOPPfxWe3aWTFrB5nVsPKJars2hKBmnBeKCp9QtOPdzAmakwznLK1MXkDpPdHV66/DKPXuqgpKJVUSwteRw4GtKYDdjdLbj61JiqkMxLwVwsqa54fPBHjpLsFswdPokVilcu3eSbz1yj3qryhS+9wMbWkMIYhBZTx1MBupxii/Tr7Xq7nwArsLyuRxB8Z3EgkfKNU+H/9OnQf2hMCx3B/siHfKPgmXYT9ok++0WD4ygajSo/9CPv5/FvPM3P/sLPkUYxrh8wIyEnIg4P0G5vMBn1GLy6zVBLFs40sckqwmvx4Yd/ln/5yj8h1Bf56L330qz/d1D5R8Au6MvYcQ+bpuC6iMYqQhzlNu8RfvgT/5AvfeUZvvanf8yHvn+Ra/HdPH9xlxV/hKsLhpMcEwn07efY4BrLKwX+7CLJXJsbruSLz99klA14309/mNxEfO1bO1x65usUV56i6cdYk9BJdphUmwS3LLMw12CWJnPL89x2eInCGq5d3uTJJ19hb5yyvdNFKXj3g28hiirMtmdot5pTwt+/76rbqdjbAt2dTXa/9CmUUmw3KgzHE4qywHUdokrEyMBQCqqi5GaxyWC0Sj7aoZ5Z0kmFe+ckN9Nt5mLLsHRZ3S5I1wrqb50hEoqRdXDx8ESJERkqcFkJzrE1HqJtgjSKUEV0XR9lBnTTTfpre7hOSXU2wGsItq7s8sIff4p33P1R6l7EcUd9h5bgP5+wFtZe3CHLDbXlGu2ZAL2PPh6MUx5420Pc++YHKPOEP//zv+Q3/qd34jk5mCtQvowS56GSAiGWa4TeAQweSZoy6KfE5RWE2KFx8M08/82v08gOsyLPsd4dcGdzh44Z0XUMF9e+ydivcN87PsLZByu4gcu3S821K3vozpBq6JI151kQOWsv7+KqClWv4MRyjWq9zdbOhExX2Vgdc7BZp1WtMcwSdrsbf+f6v6vioKRED8e43W2atsu95gZvCx7i8U+9ilE1amcWufeRGn/1+Q6/+3vP8Pf/l39A632nuHzgJpd3HaLtRczmkA9/7CFsu8XFP38WNa7wyJn38OlH15mdO0g32+WMtJCcR9V3ePj930e7GlLeEfGnn/4gSSRZfwJQD/EB+7u8YizCc6msrCAZkfQ7mHHJUUdxes6nmsPkguZGr+ClnuaFYYebpeEW3/KuFcXJY4IjJwXzxwW1gwpVlSRdi3HDqUBWKfxaHa/5fbjRg1jbQqgAQYpOrpOufYVCG+z5HcIYRklJPioIY4egWieZZJRJgU4MpVRQ8WhWqxBEU3W75+A6YMuM0SjHEQ7J9pBymBLHdYLYR5qcIu0ihWVvb4DNE+JaRKNZIwh8xpMxaX+HGzd2qVTaBLUY4SpsIZB6wtbmNrlxsdLit6qIuI4RDkwGWNedOjArByVdjO8TOBbXUST9HkoIwiCiNDnC9ShLw2BnDYHF8318P8DzFcqmmDyhyFIUOUrqKenJZGgBFEOMHmL1BG0STFYSBTWC0MNxmSZ1UmERWJsSuhbpxSAqhATUij6TdI0vnc95+MgZvjHqc8K7Dzm7hWdWmZ3s8Kf/82f5wDsKyge/wF7lAFVxlXtma5x88EEEvwf0sOkYCg2ORa1M97Vey1FLPQi+THrj6/SeuMBg5yYvvzxh6ePvRLxc8FJnxAjNW47dxmPdLr0Tz7J1+QluvetdXKqf4IvDmIuru1j5Kr/439zPi89POP/Y4+xeP89MusqkHjDWLtlkj/qJZQ4dWKbmBWQ7mxzxcr75rW/y2Nfs1GBKGlAumfWxjke8dBwpSqKKj1KGYbeDDXwQgmw0wq/GeFGE64Yo5TDpD6YCZemAkriVAL8aIaseUbPJy+dfohWnlKdu5ejiCo6KaAeHqAjL2sRi0oCKlYRVsKrJhVXDBZOw0qixOxSsbmWwl5GPNCvNA8SqhSvqGGvpGYEXH+AEVYrRDo1KTqWokuUVdvIh9eV5zDM96v0eTpThz1iCScHW8wXzK5J8U/Br/+J/5OM/8Qt8/9s/gJKSbSup11vce+52VldvMszBUYZRklDzGwSBojOakDgejSCgGkCMmI4MiekpZeB4FKKgs7tHYgucXDMpNUVviC0tjhchdUa9HlD0UwrjE0YxccXFCX2GY8Hs0UN0BhEzepe99U0uX3mKV7Xl4z99B/0tw4GDMbVZl2ZTgZnw25/9GjPVLlFc4KhnkeU2onwR3CFWa8zEwwQxxh9ixSoUXczuU7z61CusHLuTQ3dBrWXZuLKH6z/Jln2UPxtOuO2Rd1A9e5CrtmR9o8OpH55lNV5mQUt0kaKKLtAhtQXz3ZSgEZKON2k0XQ4c8Dh+oGSurvjspZidqx6D1OVMOOJkmNDO3nhQ5NfXKJRE7aXUhjusyC5Hirs5/+g25cMHObDksXfEcunlHZ780lXe9mOPEN/f5tKVAYOwzsoohyzn3PsfwgQuVz7zDIuzt9KcO8WFS2NiP2ZSjjmhFHnvMpWVCo2zB/ECBxt5/Or/eQc6lvTX7qIu17hDv8TNzCBqdcJT96FHFyj2dnFTw3IUsXAwxvWOk17tsrPe4cZmj7XehD1TcLRmee99dZaPuzSWFdGsi1f3EK6iHFvue1cMViGcCOUvoYJ7kd4tWBNMyWlmwvzRVe6+9wpCGHY3dhiMMpIsnwpk5VQjNiUPmdfRpK/F63jTfXTqa8ZnrwkpXyOeCL63OwfTMaE3/n9t9keI5HQsRClJEPh4novne0gpqFYr3HPvWT7xiR/nJz/2MaK4xvWkz9ZkxJXuJscac1zJJhzwbofKLsFsn8nNXV74N09y5nSJPfFtUtnmeDShGR6lsXwPgq+D6GLzLtYkCM8gfIm1GtvfRtQMQjxFunGT7pXzrF3boTJ/goPvehPmcsIrW5c5sdwiOrzCgJT08HV6V57hyO3v5mLZ5HIu2EpGuEGXH37bYV69lrJ7+dvYrVXm2WIyEzEqfSb9NRbecpZb55Zxyhw1HtMox7z0xFN8+rMWmffxAxfrReQyxA0Cztx5mgfuu4/Ad3HUlCT4N/Ua/46wYDFonUNuMFpTItjJxvy3P/NztFstPvCB9/OhD38IR4SEWLpZAVriG43rOehqg20063bAQjTDal+TpiP0cMBkVLAYr6AIiPAZGYkWJY5rmSVE5yMqXgmmTlJqctcQ1Waxqx3iZBdRNcS2RI/36Iz7LMx7JPOC//vTv8pPvfunOdBaxAVKo3Hld3de/R8jBDDc3KM3mJCpgiheoMwsQUXBvgPyq9eu89jTT/H2B08SRl2UvIowLyC4DnIEtsQWETgNhJogbBdZ3sSMLzNYu8Zb33GW0w/cQv3hu7nwjfO88sWvMkwGrF27wsM/+mHcgxUa/aPUBcwvVhmGNaQFpTW+nDBUGdaUzE8Kqo0q6egyR47WObRsaNckRenTcZYw1zcJopCHV2Y4NrvAhc1Nnr78/N+5/u/qk5AL78JTS4ib18gKiSj2qGw9z7nsChc/P0CP3so9x2o8Xn0bV689z9ZmgfYrnL3tdqp+mxiXr5n/gtks5fb2EVaq1+jYm0hWOfTAOTavTVg46uOla9QWWrROHCcO6ww+N2Hu9gqdlYCaL4jvOEnlI+9m9cu/y0MCbhjNbEWQjsBL4TbpMgkCDs4XqGHJy7uGC0NDxxhmGnD3LQ5vvUPRbCmqM5KoYfGrFllVlEVAPBvhVQKkXwO3jfJnEe4ZDCmWgmxwmWz7CunmOkV/nU4uGY1zCmXJSwPOtGOwuTmiEYEwU1pKgSXLLYW12KSgcMAVGs/dd8/TmvEgI3YlfuBjs5xxNmSkUkQYoAIP3wkoBOQGxpMEdIYZ90lGfQ4stslUgPJdhFKM0zGrnT6WEq/ewAs8gjAgiiqUuSZLJijVJisSlLH4GIQTkOLiCZ9hmkM+RAmN47u4VFCORbgBgWvwfB/HdRFCUwz3kDbH3W+tK9dFuj6lSVDSIc9zpAqRCpQjcEQOMidLhvj+LI6rkMoH4SIwSDVGEGLxsCZh2evzrnkYN6o4psNhL+f6wJJmHsqp4h3scHTlFJ/515/jA3eWsPMYd9Yv8PYfyhHZE+AXmNEYO9IIZREB4DHFWCIwuoTiOdYvCp756gjQtNuSD916jkeffAadH8UUiu6qIfMrPJ/e5ODJs3yzPMFmvMiwnVJ/8Tne9fdO0nnpBbae1+xcfYlu5yqjNKHQlurSPMdbDTItSDY7JJMUT6c8lUo2Bz0mWmIciR/WiJpz+H6DyPMoS3B8iS5LsFBpzzIWA4rcoOIKKLBWYVGkaUIyHqN8DydwcCsRTuARxD7Cc2G0RSoS0uEMUpfE7nScKTOWTOeEqkHbW2DcXWV1DVxP49YzllqKwnQoZUbuSi4OobbscWb5MIFbQ8k2woWUklA5eGUf4wR4cR2Rp0zSPp3tPRzdpHakxgvnOyR5gVSKLDF4Dc2wq3E9Se+Va1xf3+J6PmHGlOR5Ti/1kOMxzdAjCFyM59EMJK2KQltnipU0iqIwDMscGWjc0EM6an8mfCpIDuKQwliKMsE4Arxguh+UQimH3c0hdd9HGY2vfDwnwGoHx0AQKo6eWEKOPYZr15h0n+Ow9PnUr/02H/jYR1k41MSru+wkJd+6Mmb31fN83+w1IkCUeyBGWDHE2gxRgtEBwo0QqoHJE5LhedaH22xudZk7fop4tonwBeO8D+oit/38xzh5x12cO7jMlUrMq2sjtjYKki9e5RP3n2FtZKhuj3GvrlJcu4qnAtKxpjPao9lymWlZ2nWL9jxupk0uXwwwuzeplBGzrTnm2vNUHPeNh2L7dmRHokc99KgGyQB//AJHJpdYffJBamcOcrAyw1p0ks3VdUZDiyDm5PE2oRNAnrPjPYSbW5Zn2yyGksD08aIxwcFFxnslzWUHLu1Sv32BcK6CMi7FJU28IBk3HSoOuKeOMLx6gOIxwd2OZafIqNYkox1LLXdpux5EMY3ZHLOxxvX1jM3OiMQWzB92ObUScvxwQNT0CRoeblSifMAN0GWMV62hghihmqAaCDmDkIcwGCySYnKVvLeJGe2g+zs8/vwGN7f6eK7EcSR5IcDY130hXtcOfEeF8Log9zscXV97jWF//t4K7Hdie77XQ4ip4FHtI1ol+L5DELhIqahUIh76vvt417seoNGsEccSQYy1GUuRpum6lEYhbcKMMtxMABOg/ASnHVIfHOLbn/8M9x27B7H7Oe68o0u1koL+DMgMW+xgsxzhWKbGP9PiywrATEB8nudfSrlwuY8QgoWmywNzKzz+xMvU/bNcHddxc4EMPNaKPWZPnOb5SZv+XAUz7jI37nLo9Cyj9VW6Vy2dGxfpDTuMkwwjFI3D85yoVsmFR/fqKk6RIE3J1ZFgs7/LRHtYX+I2W1Rbc7Rm5nnnPbextDBHJY72KX1v7Jm/rSh4fS8ZPaU+mSmJb0rjMxih6Ozu8iM/9BEeePObcKSDtYYcTeDE2J5iNIK8NEinxA1zmoFDqm8inZyOkWxYh4X5Gsu1RaTwUUiMgtJqHATKpFjp4HgxVhfkkzGjSYZDg2CuySvXr+N5ElNOkdteWDAe5YShmKw5OQAAIABJREFUQ/el59l9YEC9PkssBMKq/6yKAwCcCXl3nf54h44PlUoTEfv4riDBJRERC+2Iew6soxggbB/YADFgaooB1tYRqoIRMabskhUdRvmQfn/I8m0P0Z5vE8kKc80q5W1LzJx7G/OHlrjt8CFedRX65oTBWg9xccCbD86zl1sqwxR97QZir4eLQzY23Ej2OHCwQaNhqLUtXhjTGzXpDgWRs8PKwaOcOXGcY7OzJN9F6v9dfRJpskNemyGvL7C22+NG8Qre6CY7hebqtyvMVWc5fes7+KmPv4+2OYaggpeXtJpVZtotdCFYuftBAtVBZRlNY5FLVar3HaN92GP4WML69XWOtUPqBxvEKqL42k3YjHFesgxPhmzf75Iu1ugvHWSHBd6kNph3BJk0FFJScTzaUnBkwaHsTHhiWHJ1DGkABxYlp067HD3qc+yOCg4ZwpMQeuA4ZLlEu01KLdGjCIYBppTobIssfZInLozZGQeMh1sU/S28dMKxhsBfrDHRFsdOCUJCQXdYsNUrGUwk42RqaCaVxBWSLNfk2fQ0IxAOceDjhT5+GJOnE4wwU5a21hSlprAlvlDE1RCLg/AiCl2QTFLsJEOUOWVaICsFnlPi+BKLIssm9NOE+XYTPwzwgpAwjgmjmDIbYpm6MZZaY5VE6hLXTnUMJhvhuA7WukjM1G2kzKbeCnETpTTS3cds6hKx39J0vRDLVFTrOC4KMLZAKQdHSYS0+66YcuoWq0YgSiT5VIdAjhJ9rJ5gTZ20XyKkT+goVqQld0OGecyMP0uq++SiwEYeW3aR6l1V7PNfgqtXiHs3aMttFk5qhLiJLQxCW1AgHKZFgRTTB1coSBOLNH0Oz7u8/S6HT10XvO9dD/CmuQWuLSyxMefQ7wu6boPG0ZgNP8c7coo+TSb9baKiw8LZGbyJ5amnu6xduUG/u84kTSgExHNz+IFHkk0oRxlpP8emOUZmrE8EudXMHz+CqtbwGk2CapNeN0PmOXYyxnUcjJmamTjSRfkhxuYIDCAxxqCLElcphGT6eSoHpeS+IZ7BcyyuyWlEDgutJs24hivUPgLOkJYpRZnTH07o9zPyTNLLCpYWFRPpomxJklsmI7AjxcpKQFeXJFbQkCFNx0FLTWYcXNnGeDE1vcVICLxIM1epYmyMQrB9bUKvp3FzQcWXDHRJXoewBskg5/zqVRavXeAtCwtkecJwr4NfWhzHw7MCKAhMjsiGSBkROVMnVasVZVYy7KdQWuLYRwNYixKCOA5BQj6S0++SL6Es0aXBE4KoGoGBOFR4roBSg3WIooCw6lJtSAI/oNq+i0MHUyZPPs3nn30Ue/cK3smH8f0mbgakCaMrz7Fyoo/vuwg7weYpZDmwb8iGBVGZJix5n+H2Bi8+3idzmpw5sUg9crHdDRiuMXPnQd7+vu+jdXCJQrrUhaS5lSILl9PHDnKs4bM2yXnhy3/FpSe+QX9zjaheoz9MKOyEo3d5LM5DsyLRpcsTF8aMe5aKTXj73Se579hZDrdWGPaG8Jnp/T7vbmO8JdKoRn9QsDcukOkum5OCm8k8t7erHDrQxn/kLA0ziyklrvap1mI8zyXPA2qLJ0CPIC1puAVqvkKw0sCtC/IbBbs3eizPBwTzFdTAYi4MYewiGxHZYZfRrYI8jplUlijECif8q9QDAVIjnIDYM9QjB7flojd3eGVQ0p1IZFWzuBwweyimvVShdbCJsGNwQ4TjYIRCaxdNE2tcTBIDAaYs0cUaebrN1dUh2wNBMtxCpwNcm6Os5spqn71hNqXD7I/PWPsGq//fFhb/9ZTOvs5B/85kb/p+g5Diex5l+p3xBmbyNd3BdM1SwqmTS7zpvmXuvisGkYC+SJmOEapGKCWhkmjhkWufyKmRlEMcBzI3IKvOEhxsIq74sH0ef/NFmo0e4UyOoIvdH23dl3uAUAjhYIUCR1AWGslNTizVuHwgYN2E3Hv6To5GMRdbDcwwoK89pB9QaUuMq3GWDzApXExvh6qfE81FOJnh/KURm9dWGe11GRcZuB5xvY4fuiSFoRz2Sbs5rk4obcHqEHI0x04fw0YRzdlZfD+mFle549ZjhL63bwjHvoD9u+skTceKNGWRI7QEYxEYNBZdlBw4cIC5uTlgutdyPRXZ94djxuOCHI3wCqqhICHApSAtIU8EbumxWA8Z6pISgSM8YgmZNRgrUDLG4hGIHpkQ+F5A1SvBKqQQ7NzcpT9SNLXEUYqEnDyCuCLp70y43Nmg3prDC0KszQkc7/X9858qrLXY0mK0pbXYRvYGjFc3uPzYU5y54zZs+yhSSlyl8NGE+S4LjSHK0WDHoPewZoygACsBA7KCsAZTDBh3OmxdG2P8GU4dW8aPQmxnQK3h4997K0ceOE2tWaeUiibg2JTA8VluhLR8h26uefKvvsK1l19BOgYvcEkGE6wYc9+5kEa9JPY9OgOXm1sZOvOZn6nyyLlz3Hb4JI2oRiXt/fsuw3dXHIy6zzGKQ+zKHUwW2/SvP8lmWvLcIKUsXyXYu4Efx/zUx+9DinvovrqHO84Rk4JE94niOmfvWMCKRSYvvoQRTaKDB2jfdRbV6cFmj871Ibc/vERoJ9hnLlJ+dYO4OEn+zR2cw0fZTqv07vfQtkZ6yzvhwh9wxnV41bqU0lBxPXxZsOiXPPFyznPS0ljyOHnM4+itAXecDanWImiH2N6IwkiKIiQ3Ef2dAr/ZIu9lOESYLCcZdhj1t+h1Mr7weMLV/vSUJ4p8Zlo1Ys9lTnjkNkVnJcZYcmPY7pX0Esv2SOAiUELiOw6e60xxnVpTZiWeV1LmOdr18IKIsOEgsxIr980rrAFTIoocV0kSI5GOiygNZabJdYqjHAw+k3FKIBWujSiFwJoC4VqqMzOIQuwTDzykcsnNtAOgyxzP81B+gHRc1H6BUIwzXBUgoylVyNoCdIL0q3hRDa1LSjTWaKQWOJ5CF+B6HpZpwikQOEqR5RmeG+A4MKWAa8DiuBGu7yBtgiAFO0LYDYRYB9PH2piyt4sjWwi3iqMtTukhbZNJeozDSKSTMRKKob+EPThH62iT4VPnmR2MqBwvcOsgfQvaTAsDH/aHYadHWcJBCMgnJVJabj9W4WM/0ubqhma5NY++foE2CTvuhLJRoXH0EIM8wWmd5ttGc7g2Yj7tIPI93JWTXPizV3jxQodk5zKlmRoGhqGi2gwp+z1udrbxjZ0y1Y2l1JrcCKKZCseOH0aHNXQco8IQne4wGveRskACQk29HnRRohwXGUqkzVCOj5XTkyMvDKnUq5SOi3BdpDAoU6K0wDGGZj3g8HKTQ0vL1Cp1tLXkRcq4mDAYdZgUe+zsbTNIRijfp0zHNIKYK5klsprusGTUS6mnDvV2xKvJiHNlQRvJnOMTG8FqKcA9iJIpkZ1gHIWJA7x5wZ7cJZ9kTHJB/3pJM1LEBx062zn+YYnXkXiRYPXmBc5feIq7qm/B5mNE0sE4LjkSdIlTaDKG6HGCE2o8P552sRyJKA2jQYo2EiGn3zcpBZ4rCV1JHBr01CQXKQTaGAqTgzDMLM6QdAdEdQ+pDTYvUW5E0I5Qng9KUVuscOhMi/TcMutOwTP/5s/YfOwrzD54Dn+uQeRAS2R4u1cIK6BCATrDZilkBdIDm0/3paUGRULWGbBxoce1CwWt5mHuOhzS0z02b65i0z2OP/wWji7PM0Twrc2cVq6Z7WecWYp5x9tPMRMplkLJi49/kQsvPI3nQWEGpFozP2eYXQlozVjcXLFzXXDpSp9K1eH2g4d510OnueX4WZxohcm1ndfv98n1CxS3NSgPtckiy8RT7I1znt4e4pkbHBvdyszcIU6eqAErJHspYe5ikxJdgOd5zMxEIGLy9ZvgNQkOrhDOtTH9BNtNGW6khKdnp/f/5ztwWePoWTQD5Kk5er5LsSQpKwexK/fDq2scigO2rUfsVQl8jeeWhCLhxpU+qxLaKw3atzSZPVKlvVDHDSoQVbCTLlr7GFGl1C55ahFeFZPkSBFiixHpZItktM1kmPDUN3fZSizSgPJjJBKTZgxKS1YYslxjjMG8Thuy+64Hb8RriZ14Iy+ecv1fo/fs//7ae//GH/gejNfExnafEPbGkqamcUoKTt5ygAcfPMYttwgkr2DtGEyMSddRziGkUAgDynpIUyXPZ5hVIUqk9IkovTq0BJWVBZIXnyIc3cQ9rZG+RagcbMb0pmn3L75i2iqOEFjKYoQyhvtvWyDPIp6MHepulXLnBjOyYIM+bnsR1aozJkeGy1zKcg7/f9S9aZCl2Vnn9zvLu9795p5VlZVZa1dVt3pvSa1Wo0ZoQ9IIJDOAxQAGzTCAwhOYsMMxxPiDHWF77IgJcISxxx40ggACBhOABJKQ1JJQd6vVUm/q6q6la8vacs+863vvu51z/OFmdwthQzPLB51PmTcjI/O+77nvef7P81/qKVGvg6r42LDK7Ze3uHxtj/H6JUo50YTF9ZBaw6fo73Jza4uaE1ijMLYkNQUZkvpck7fceZK+lcSNGqEf0g6rhIH/hqPVa4Wx+Nt1KK//zO3nvBR2f1K1n7shwJaGy5euUKlU0Z5HgaWQFuEZVjeu4+jhVy2+rwiEz3apqBiPzijBjhWNMkDrkGvb25xYmOQtNYRi7BwjC4gGUpQEboSVUI0kvlUkdod8NGRQKLauDpheauD7Hv1sjN/28CsKvyrZ7m3QHx5kVk1Psgqixn/8jfkm13db8NpyEhY2tThP3Tm284SbL73CoBJROXkYFQhCCRU7wkvW8SOB0ALMAPIBkO4LjCRSWSw1hBmS9/bobQzo7UKzdZCjsyF7aU6/t0vUimjPLzHXbpIhuNy3zJSWtoW5hSonl6rEnqTuWZ786lfJkz0aTU1c1WS2ZGHKMnWgRiUWuGFAt1uysTNkqh1w/MRJ3vEDp6lPHca6GH1t6m+7FMCbBAd5pUk6p4juKTn9wNs49a1zPHmlZOP5PXQQMXcwImuHWD1pn1fnW4RDQ+fKNXYubFBrL+MfalKZibCHTpIc+Qg6T4m2Urb/6iyXrvZ59NEPMFutIL7yF/D4nxHnI6R4HwUbTJl/QP0zR/CHTcTDM1z85K/xqV/+Mz4pDMfkNJuuj7E9Ipvx6mXLE0Jw9wGPh39yjsP3NQmqVaSt4HzHeGePot+ml1n6pWRQCjp7BQtqCzH2iOdKrOrTz3useT67znH3fYKjYYWV+YCVlQM0F46QbHa4ebtPtjZgby8ns5bUSRID41IglaJWCyagUQi0L6k3I5yC3V07KexzRypyZKTRfkTk+ViX4oSZAAsDRVbQTzLwvf2EO/CEIoqqSK0pCjWhlowsBQOc1lQCTaBCavUWo06KE5LSOERusDLC2ElmQa02jY5DECUuTyiLMVlqQRf4vsD3FVpHiDJFaIO1HmUBpQVjJThJLHw8bxJuZq2ZQAAHwhZYFEqC1MEkxdeISRcn7SCCAC8IUCpDuG2wVxFuG0mKtl2aNY0rBzDYRWzvYo3EpT63nv8ii49+GCUGNJI93rn4Tp4bVtmzmhe/knBflDG1ItCzkwmMEJOJgRu5yaGhxcQl2YRQWNTQkjqBayxy6MT9fOJXU37jH3+Kh499ntWrPsNuwsoDD/LWRx/mD377M8w89nHWfvdTLL3tXg7ffwwt6zzz5Sd45ZmU0fYzuCKDoEJYi6lVJePdy4itEc4EoDS5GzGyOUYE+IHP4VMHWCzH3FjdY6dUiGaLerNKisUojSly5D71xVmLVj5BpYIWGpRPaQRlObkfjbl50FCUOc6WaKWIogDnEqampjh1x2nq9SbGGUZ5wqgcszYesbp2DU8l+OTEUczYNViMHVbG9IuU1d2EYughRZUgLkmMJq5NUdgCnCHYtxLVosrlQiHpk4tFYrpoMWQ1StmMLjHvSvqixnhUEoWCpOJTpintXcFYCuKmQCU3GK8+x8bSFAe8KjORx05/gFMK6TRZKekOhlRCn8j4xFaTpgZPeQQqwHmSzEFSQpmXBIFCakVWWISxpOOM2JsEKu1nJuOkxY88vJpCmgKMRUeKaKqC14iYFBgSTwE1TTR1hOqxX+IDLz7DMxf3WF7rMHdkEXAMxmNONkDJGOdJ7GiASDOk2M9byBQy9EHVKft9Ns+v8uITm0THj3FXchCdZqjuLdIkoWjNceb+e1jd6bOb+3zn6QR5PeFtJ2P+yX92hK0gRAnFwwcCFqabXPV9bD5AZAWLi4J73l1nat7D5ZaLNw3fOV+imk2OnWzzMz/2QRZLSWEHjMa79F3++vO+kDF5nOIdlcw3DrGwfoIrtzKuPm6ZWfKpTnuYUOH26Rp+NULnluHtdfJS4FfrqHqAFylse570wHupBDFiZ0RybYudjZwzD5/Bswo+/wTi/GVU6oO8E0ePKm8lCht4DwXkx1dY++j7eP5/+it+SElm5Sw900fbbVzSZatT8Coex46HHP/YGaKpFkJWgAAkFMM9TLbAMCso8MhKKNKMqsgRmYdqlTizxd54wG46sXiWdcnDDx9heS4mrq9w9UbK1x5/nrUraxSFIRnnZHlJUb6Rqsz3cO5f4+C/8dr3Tga+f/UF/1/rNfH1JAVZ4qyb0KYmByBSClrtOp/85Y9w+pSlWtlBsIckBRcQhj7YDiTbuKyHcxpbhPSupkzd+5OU3Qs0vRbV6CTrRcjAetx46jpHZhLEnTEitDg3mkzlpMBlBrSHEBqIwbXBGmQ2ppAaEZ/gnnuOEtc2+fPf/23uPXqSq2c9iv4OZz74QYL5CmcvXKF+/B7WvvBFjjz6IPOn5xj0ulw/f5XVVxLG68/i0hzRiqlPVfD1iNH2ecRmH1fUEb7HoNwidQIjI2r1gDvuWmZRWHZvb7GzN+DO0yd5510nX9ehAK8DhDe7Q6wzWGuQQk6oU84htEIrhXWO3/7076C1RkiJF/q0plscWl4gN2MaCxUOHG+y3GhgCeilJdf2RhSpRKcRoizpjw3dlzfITmUIVUFLSUWAQtBzCuFSSprELsMJQV8ldFwPLxmxy0FG3fOMlgOM9ih7Ca1EMFaCZlsxXXZR4z3KSkRNR/9pNuebWM65iWre2En+kpYTjOYL9LEDzLdj7qHgysU9ph8Z409XyEuDoORgQ02o0FJB2kXYMUgDwoPSm+iZRIUy22H36g12twqqB4+yks9AUaAGO4ytJZyeoTk7TWeUkZSKK5cytrZz7r2rwuxSSKkUUgpWGppGvcF2f5N8kFANFMuHNXc+NE2tGVKOMy7cKrnRVcRzUxxfnuO9D76NuLCU5ZgCTfEmGhFvChzc9d/+LCceOsnXv/FX/Ponf4E/+He/xE81Z3nsiS28Q+9hPP9Wru4VfKYL7z3h0dmStGY1sw/eQfXYYW5f2Eb0S9gdoSs+D7/3XtIi5+bqFuezGh/8xIdZagbc+j+u4J7PaDOD53Yw5s/QZJhRSNR5F4OvLpNciTnz0yH3z/8c14Z/wj2VMe0ipS8cztf0Gh7vbEge+y9XaB+5E0aCfGMdVwzYvXybW0M4P3AMSsuUcpyOFSdm23jlLHMfWsILXkSGKSJaoBTH2OkaNi6/yNId7yaq3olQ0+R5wrj8Bs//wTOY2GfkBCrQOCtIdgtGqSHSjspUjaDqo7XCFxJhFLpSoTRjNjsl7emA6aZPFGrS7pBxqYmCAK8SEfgaqTxKGVIYy3TFZ28IkR/SmKpQb1Qo8hFBOKTT6VNqnyTJGY66CCtptAJkURBUfFzp8KzDd45uJ8NljsbiAWRYR2uBsAl5WWKlptmMGJuUUVoyLixR4BOHMfmogxWTFGYlg4kIFh8pLEJFODLyNANXEEQKL2rgi8mpaa2mLCfjTi0NWmtwKVK2cbYDdgdpd5CuDxQIJ9ChD2UXwhrMr+AGq+gs5967l1n/wlO88kKfvBrwgz8d8I4lzaGD66wqS/yBCPkegZUGmZcTYGDAjQRE+1MDA+QZtiuQQ9ioLSGC98LuXVz+N/8V9w8Lrp5d52q/pLSamfUXib7xL1Hr57n6my/woV/7V/RvbnHrUobqDDn7+Fe4cvsGUkCtWUPJMeVwl821MUVu8cID+HaHXtFHeIpqXKU1vcDBk2cYXn+Zm36HNA/wcrD5CPwqTmu0lpSDfeGjlhRGTmgVCsY2wg0znDFIX6F8n16S02hGeFLhCPH8kErLZ+bIMvcsznBgdhbtBfTzHJenGJOTjBPyUQ+/ClHUpq41CEtbBWyk0LYRw50xB5vTrBxtY3NHYENOLL6TeVES2RSP2iQaXioqfoVUaW4RMMyvkmcdyiKh52rcoZokT63iaYP1fTY3LIMetNZBRY6iosiyIRvXr/DCd76BWLwDKWL6/Q612gxRXMF5knzUZ3pqgXolprM3xPMFSijG2YhkBJWqoihAKo0AyqzAOEs1lrRrPsZoBp2EcpwR+4KppQOTTpv1GG908SJBMBuivBI3TiHTOOMhGgoRTIC/V2vw/v/z1/idH/3vOP+V80zPz6DvqKLbe2ztjGk0WqBq2KKLyOwkHNEXiJYEVyLSi1B67PT6nHu5x73pHj/8ax/l2hOv8u1+g4UTd3Lq+DyX9wZ4vYSLX0746KGCuR+axSzWuJrkHAmjfVqK5Gf+x3+J9+v/K7c+/2/5sbeFHP5hzfrAsHch46WzBdvjmPbiIU7e8Raiq0/w5T/8I95/111cvJTw5NmMy3v115/3B3/5g1Rbmq997ltcPnuTX/hvfogH39rm+JkOwfLDDGSb7tDSHUtWmoJxIqg0FY3jBxn3MsaDHDEyxIlD+5I73rnCOC3YW++R+HXOvPcQjVCx+9tbVHZCNFOIsovL/gopMuxeDa9ziuSpGHXcZ2F+hu6ZT7Dd+QuW4iGBzLFKUUQ1TN3n9Fs0J3/kbvz6Kcp+F5t2sXmPZHeDfga3E0eJZUY72lFIPZ6CskX9ngMI8RTK18zK0xR2lnGac/zMOZqzP4jyDoLwEdEtdjsjnvv2WZK0IM0Nk+iCfS67sxNP9u9y53lNd/CGy+nkNHbwBi3pu8DDdzv7fL+uiSf95OsJBX4ybbfOURYlR48cYmE+JPDWwW4h6AL5hHqkYzC3oHkYXBNX3ECajMWFM/Se/yJr1zs0VuaZOy1ZaS7SnrrKrtHo9yzDksPRQ9hkot0wDgoFOsA5b3IAmB42VcjCpxs/QqweI7l5i/G3n+CO3QHX+xe4uDbAE3WO3n6WKpdxN2+w1nmJ93z8l9i9vkZ307J9bZNLLz7F6q2baOFoL86A2GW8dpm9bkKRKYLaMeLyBrfSAXElZnZqnun5ZWYOHmK8eZlr+RY2E4iiIN0Z0u0PmGk3/xoY+HvtBOuQ+4GiEwH4pCEJgiIv6Obd1/MlvCCg3+9x4+o1ompMa7ZOZ73FzqU63STFr0Vsbm2jM0c1CvF9j6SbITCM3rUOizWk1CgEWkgCBFbF7FqBKbYwZY7BYcMWc/VFNv7wOdqHAsZO0O8a8j40tUWHkMaSW1uXOHXoLuaqi2il/s63+p9kOYcrcyhKQEPJJOkslrwW/e4368w9eg9fefYzLJ/fYvH+A1gxJCu7mEFGGNVwNHDmPNLkCGUmzaDQB3IoriCwbN7eoXN5zPLJBY6++172Lm9yMWty/MgUMvLpJzmMCjYuFvzQvCF6qEEeS8bGUdfidVvVX/mX/4Lf/R/+BQflKg+/vUrtDk1vbElujnjlpRFZPMehpSM0WlMEu+c4+/TjPHDsTl584SyXNyp886VLf+dleVPg4Muf+wse/+xnWN+4wCd/do5/9s/+LYOt+/nVxx7i7sYsM0sJi1XD9l7IN/8Ylo8K1qVF+hATsHLHAToDQ7pbMHy+YOEBRftIFRGEbLysuPmvX6D90Ckq25egSBnZ02RyDk8mWPE0ojJP/ZNHUUFI949e5ev/fMwPTre5WC7Q2+pTLDZIV5oEXp+V+49x9w/9CMYUPPfMN7CDXZpexOrNHb5+c5oH72vywHLIgjcmFJqSNn78KtX7+2QX/hA5laHiSfFqywppp8fVNcPF9ae5/OrnOX+hz9VbJYOkZKEpmJ31UUJhMostDM5JgkhTCzU2khjt8DyHlIL+2OHGhqSXIn1FOlSkWqIig5Yee1mJMJYyz/GiAD8WSK8g9n0IQ6YYMRwadndT0kEXoS2UJa2piOEww3OGuUAhrCDGxwyGbK7vMUxyGs06S8uz1P0hxq+jpGXYHSBlQRCUxHFMFMWkZUHk+XhihHMO3/fxfBgPLc6MqcUVysJSlDnUqoRKE3hjstxSGjdJNHaKwgi8oI0SEluOcUIg/QpB0MCOr2PSAVSW0f4CwjURpUSY74ApoJx8WIWxuOEett9FVUqEszh7kYXHGrTfUeHq+ZJP/atn+OivvMJLlxPeercmbMbYVGC6I8x58E9BsQfKFwgtwUiEFdjbBhN6yIU5GuOHKNe6uLVP8wO+ZfkXj6HescQXvrjKybf9Y46eXGHrhf+Ln7oc8tiv/xbV5jTfqi/x5S89xzcf/yrdtct4JiX2QrbW1lDOIgWUKHzl0R+tU686pqc8wngBz2si3DbPP/Ulfupkkz9an6VoH2Wq7tEsOux0IS88WqHAxZOQNFNa7ChF+R6eEiT9EUqLiWYlCIkijRxbbG7Ii5JaI6bRCKkEhrqA0hgurt6g1Z4mCGK0EERewbWtWxRlwWgnIar51Coe9foiWz2Fy1KOVyrc99AySlqMMdhAcXjmGAtRSJlnZN6YUOUEetJdjxEooTmoPEbBDJmusNy8mx9sv8wv/s9/RCoNNpeMNiy6khMIQYFikAkqgaIcOHau97jAFY415qg2AmbnZynLCvkYTF5SOM2NtQ4zLfYnbCU4h8nBWEUU+jgcYyMYlw4tHFoJPE9Rbc8w6o6Jm4oijiiynM31HuH2Ftn6Kiq1TB+bR7UF5kqP7E+fJ/z4x8izGNHRqLpCNyeaheDY/fzXD58eKQzpAAAgAElEQVTg+dXPc3m1yvLsXSzvXGewFNNYug9z61sIM0YFoOLJweeul1ANYfkebnz7ZV752hpJrc6P/tyH2HjlSR6/2uVHPvI+duszvLA24OjWTTaeH/GTDx1ltFClcaRBc6qKFgrPFuz14WZqsCrikY/+F8hHz3DP1BdZ65/nyE6frz+xx41xzOJ0yHFpuXT5OcrthHPdkts7l/H0As2V47zrvjovn58877/zzDPcvHKZZiPl4XdO8anf/BK9G6f5xEfOUFv0mK0XtLAkieLGKx5Ts9BNJvOVwPdpTPlkmaUcG7KrlvadmmorxOaKYsun94V14jvniEYbkAXk7iQyCBHBGOQlxHSd6D+forw8pHthi/FzGcfmqmxnhxht9slPHgZvGlWBmcMrzCzfh3UlV849S9XTjIeOta2U3XKeIyt1Djc0rWCEpI6ToMMN/Nk+5dafolsFQjSwlBRZycbtbV4+v0ml9mW6u1tcX0tY381Js5K7HjzMq3/8PHlpMWZf7M4EuE/WdwED9sPP2A9Ce43lwmsi5e+tT9z/b+DS98uy9o33/tpy++Fw4MhzR1Q9hQ5mEU5POHYu3f/FEZgUN7wMFtDFPmd7QOPug1ROTXPjfIeXn/wyKw/EbKz1OPr2Ns6bgzLF9XNcohGtEjeyCC9C2AhkCKXEJRl4Nai/hSh/CNm5Sn1wgdPTAbWffQdyZYkXv3WOU2//RTy5Rf/qs0wV0yx95JcIogqXihW+/c1zXD97lsHt84TFgDhqcP7ll2iKEiM1qACtNVvdSywuKo62mwTRaTwtyMfrnPv2FT54ZoHfveoxt3yYd73lICcPtYmC8G9ct7/Xeh1kutczNibgzFKU5f59mPyBwozJ8wwpBUVRME4SNm9uojwJUuBJue+UJIkrIe3pKRbm5nnu6Zf4Rz/2CX7+53+eD7z/AywdXmbSWBcUTtBSHoXfpOo1mHMZY1b59Fd/n6gtyfqKK7c3CALL7KxP5jwGhabmB5ixoMws1lmk9P8DLsJ/wLIG0jF2p4vbSlAnj2AKBaVFBhLhCVCaoDnH++5bZGvnJZppgygfMy1zxjN1rH8S0/k2SmQIXyO0D1bBYAzBQWifYefbn2V9fQ8xe4wTD93PcPMKZzcT3vXoA1zKfVw/odpNGG0YHlppkdV94qmAhtaTJGhrGZfQKx2e9vnwP/1VmuJVmv5FkvE1pssuz3zlClvhQU43I8JiyO76Hlm3z61uzu0tja8PsnRqkZ7bhD/92y/LmwIHX33+PD/24XfxT3/mh0kubXJ5c5Vo8AT/21eu4z1juWelzsff/RDLP/KzLDwqKXGkPUfaAeMESSAZVSWH79B0zvXZehHyTYlVFl7IePy536N3pcHp8A4C1SaRBUM7oG6fJg8f4cSvvAd99wHCXsrUiQh74cs0mkdZWPkYjUfOkTQ26I4zNs0KH3rkp/jy5z9F3flUIp/+Lrx04ybZDHzsA4vMJUMYZrhKQdHIcZUx0r9BeSkhPJiBBmccxc4enWsv8pUnc67sWZ6/CFtbJcOBIStAKMEg8pA7jrga4ClJEPtUIo9kDM7TjLOCfJgyMhbtedSbVZJRD2FzlNWTYCRjcKVhWJa06y1ckdKcmSKMApwzoDWRLCj6O7RmZhC+YNAbk2Q51TAmaDVxVjFd9THjEcWgh0wzTO7oD/tUa01UUKJDjxQ94ZylOTrSiLLADzWVagU/ClBSQJpgkBiTYU1BCXgqJI5jiiTF5IYSPXGAyEeUtkRVPazJiSoBftDC82OycggOtJIk2QjP9/GjCK0Vjgxlawg0QraQrIBMES5C5E9g8wxcONHyxHIi0h52cbsWPIs8NCL0C1YOChrvE4yfzPDnHc8/VXDfIw8yu3wYUd5kcPtzVOPJqewiiYh9yH3cUFE8W6DfU0HaGdreIuee2OHsn7xKY7bCiR/8caL5Ju/+2WNU60uEYUz3Lf+cr332t7nr332W5s/8FF/63f+dJ556kjzdwwjDYJDR0zmhmtBdnRUo4cisA+EIAk2WRySFxdIndGMePTrFFzamSLwGd997lHa1wvalVWSvRzkq6G5nVCJJoEGISQBLUZb0t/eIoypSOjzfUYmh4TkKbemZkrIYEUif2Ff4pqAYSMaeoJuM2esm1OKISuxTBIJ6NSIdZuhA43sWzwmQTdrVkGo4IChKtLF4Tk9Ci8IIrMTYGlJFJGUBaYe6b9EqBhyYEgVU/Rp1JzGja9z6xm+wennI0Ar0jEbWBdoXxE7RuW058v4qGxdK8szRiAR1JUluXWeQSOr1JpIMIUOciiaUNN9nZ29EIwoJfI32JpqaViWgyAuEjiZuT0oRBIrAk/R6Y0IPskJiCwi1h68Fgxu3CdWImXvvQmxeQ2e3KV66gtw1yOk29uo59MEV8k1FueNhFmOCAxHCUxz5yR/mhX/9O+TDEWlvQHd9ndGtHL/xIC67AIMdbC/D9Cxq3oNSI5p3YtPrrF3ZwE+rfOStx7HDjAtJk499/F3sFDHb524wv3qdFa9Dcfo49eMx7akIFyjy0RBMQaFCzq4lJN2C+YMtxkGDZ27O8Xu/6Uj3NgjzjI2+pVQlQ2XYEyVO9Jg+cJQTd7XZuNwnsA18F7C5duv15/3nv3GWj3/0MY7PN7l1fcCFtR1qe0/w6T9bx/5Fn0ceOMC9b72T9tHTNCqTWq4YgynBCIHVUPqKekUyuDZkcEUQtAR2y5G/POTyU18ne6nKQvsIhVcjVw5bdPHsLUzrNLOfOAWtAG/RULm9hX/9JmFzmvqpxwgevEapOnTHFbzqIgfnT3D5/NPERNSjJp2bt+iPe/i1iLsXp2nYMTY3CGFxwRDh9RHyPLa7hjeVgpQ4IylHr3L1lXP8m9+/ydsfmeVzT19h0M0ZpY7SSvxQ4zF5Xr+R7uuASVNk0iV3f423zOTTMHl+7X+zX8JhrZtkIABKyf1Jw/fv5MA5R1mWKDUBSlLK/ckI+wYYhnPnrmBMhJAL+xLlGOyzODMGVwdZnXRaiwzyHRgXoA2y1UVrjwOHDVlTYG7m6CnLtW/2OPrQP8SrRdjus5TdL+GJ/e6ziHF2ClHGuIHAbhnEShPpFqnoKa596RskG+tUl+ZpHXsPulblzne9h0p1BscimzMzXFw9z+xLLxO/7e184Xd+i85wk2K0Q1aM2Vvbpoz3aIUKl1m0m6Qbp6UFZYmjCnk2TT8z2GJMKzTcfWSRJ9bbqGqVe+86QLNVBaknIv5iQgP999oCzvL6pvuuMLrMGJRSqP174YRAOCidRXuadJRS5AqlFVJJpBJkk19GacWgm7C72efaxVv0OgPSccanP/Vpnvj6k3zoQx/iH/74T+y7bVkkEOgQ4TLK4Sq7q3/Ay+c26WlFY6lGrVWl4iy+NextWE68o8mVCyNW2m1qUQ21n/fx7zM9+xvA6u/Qarym9Sn6fehuQDmGJIXUIVQV19lBttqYnsVkEllRyEgjtKR5/yluPfEMZZpj8xQzSEi3crz4GGTncEWAG2YIH0QQ4qhBdBfkV9m50mFp6hD1paOUuWGnqPC2R06wmUnEzU0a4x5VzyIPTBHM+ISRxjmHKVKcm+T6bA0L8tTSmooZ+jWefj7m0otjyt2rhOWQtYFDRBk2stSyMUpntGaPcvx4nduXeviVJuPMMOj97QFo8GatTOt3cm7V5//+vafobo9YCBN++iceoYyX2Bt4aFfhvDvI9rUObzlQp7ProbSHV5OYFPqbDh8YCUFcr1GZ86gc9BCJZa5aJyhr7G2tE/7C+5mZWmb0cob9y02eGb3MW848hDy9gFEedmdE0Fe0Z9ukySsMGifxo2lGgy6BrHD8zvu4/Nw3qFeWCbY22L7VZWTH1FeaHDi+RMMOqEcWMTXEuT4lCc6M8Zt9tMuQgcAagdkruX3F8idPZ/zlEyUmVmzuOdLRRKEfRBIvlBSFpQwlKlA0GhGRp7GZxVpDYQxpmlF1jkhLohBCzzLUGs+bCNnA4ntQiTReZikl6DDa5w2WBFoQVEKkybEElLkhzzNKV06CsSpTBJWYbJAh91N0bVYihGJ3p0/UmCGMfbxQ41XrVGcOgikY9oa0ZgJCI9GqxBQjhnl/39kBrFCkeUlpDMrmWATNxhyZ6pEXGb4MkSpEOIMpxwhdRVMiVIRUGmMKbFngdInUVbywjpR2YtlnDagAaQc4W04AkKwixEGE64NsIYIhzuW4YQFGIfQkqwHPUVxxuFdGiHkP/4DP1OGIa4XHyuKj2NYm9TseRVWPI+wWwd0+Qn8R4Sx4DqcaCLeMYwUXfA0RPIDd1ahCUhsmHIxCDr7/nawNmywPe6RrX4K5u9AH78P3ZnnmQsHU+uPM3LzOM1/9Bmu3biOkQQlD6DmGpSO3+xZ0+xaFUikW65qMCsZqPJcTuTEVT7CZC273OkydPkmrqmjUfezSHOWtFCEjhttDirFBegrlecRxQJJmSGcnPse+j/b8CcfWlOg8pchSRDbGDgwEGZVmlaAscSX4no/nCbQoKIuCsTVUtEczUAgdIpVDCQulZWg9KrJJWQ6Ig4DAm4xYlYoI/RajLJ/wWIUlJaMsd4m9DJwjt4bEFBTjPW5ePMuX/vhPuHbhMt2ewYUKjcCljrxnUMIRasnGszml1YTaJ/J9bA6Xr2wxv9LGZQXVSg3tWZyUaCEpi4y8FCRlgO2M8HWK0RW6hcQrJTNtSeBrlCcpEdhSUI8jdgcO7QdUY59IWZQp0HOz1OQAbzjEC7cQ7iai7CFaAuQK9tVzCO8UUhyjMG2y3SG6UkVPtagcO8GJOx6k3EjZO3uOMM7Z3kxQ/hkKOYdZu4UqR6hZhTMaN9RAQHl7j6yvCMI6i62YTscyc+QUl65WSF96ipa9weJ8SWU+5kgb4pbB8xJM2sGWisxErGcWzw05VOmxefY8vb2IWqo485bHkLXTPP/V/4dWO6B9aBkjYvq7fSqeZm8YknuWnIh0lDMcb2LzNwTJ4fQZvvPiHt9JbzNISlaahne+534Kb5H+sMRv1tkwDSq9lLmqzziRKK1QIZgxlENQlcl0PqgE+LMarypxI001CvBNheGNXYIfexg59kifz+l+Z5v1UY/F+w4jDlWwJYi+wxc+su1RZjdJmwfwwzbZdpdqaw6vMUVv8xZROI/udxkmJcZTNJozVJsNQgoCLaA6ANvBuCGIHVR0G0UPoTWu1NjBiJu3Ul54Ned2N+Hsap/EWPY6I7JCUBpBvm24cWWiM5jU8ZPyw7o3uv6vdWcF4rvEud9VvMjXHHz2HY72XzbG7heF39+TA5i8VykFUr7mhjaxerUW9jo9fuM3fouf/7kPc/zYFDAEMYvQPVw5xmVjhKiAnLjkOelwmxnu+jpioYpfqSOaVfoipNV8ECc20M27J7bA1SZqtgrqm5OJhJLAEnB8QiXVFxH6HtwwQDpDpRwRTM8QH7+HQVGlmY8o966Qq3vx40V6ScxTr6SI609TvfYqrz7/JEk6ROsCLTPi2NHNckYmwCmJEgohFL7vcagVUNpp8lITuh4RBRGKndRyfXeXQ/ccpeYLarFPXAnxtNrfO2944H5vXsbftoTYP1dfK6zlxCVq4pDlXheIv3GTJtMcY/eF9ftgQBSTG+isQ8oSqSRC5FjjMMZSmpLNzS2SZMRwmHD+/AUOHFzkxz/+E6RlAeWQK688y9nnn+Di6lnWdzJsxaNuJYwtZWnIhEMpwfUXBxjnc9fR+1icPfQ6OPj77jXnHMY6uoOCwFd4WqCVQO3rXJxzlGYyOf4bwGM0QpgtyPcQMoPIA1q49evgHUWIKazR2EwhlEb4Ht70LDPzy6TrHQgHKHKy7YQgPITJZnA7Dhf7uMAHE0EW4Aix3S1K26JSa1MJI4pcUpmaZWPLx55/kVYzpdoUeLUKMhZ4oUPKHFOMwGlyo0mMQYmMZpDSvbZGmVaZjRsEdz2AMfNcOf9NFhYjZg4dJUkVaTkmUjndUUiuwXkVdvtjBklCbzD4O6/vmzOVtSWvXrnFi5vXaU8v8fEPHeSHf/TtpPFBdvs1tjoB2z3H6sV1DkjHwLWo1zz8WCIzyIeOdMsSadCVkGBeEy5IvJFk8W119BdjqsFhwuOHqN65QjxXYq7VCNfeTvORZQZ7imKQY17tkd3exQUea+MUcfcsw2YTVdSoBwVxLWL99g1mD51imIYEKiGqFzQOCOaaEXYPytEQIfo4OiAG+P4Y6eUI5yh6UHQdw024fMnx5fNwJXHMRo7mlEDNKPJUkIwEYSRJ+4YSR5Zb0tyg5SQcIzeG0E6ojlZOHH0qVY9Kzcd5Ptu5QzmHJyQeAl9JZBiymaTUQ49slEAhEIEiCj08zwPhk+cZ6SglzwxB4CGFYNxPsBlIW2ByAypERBXSrYRmJcCPPHACP66g/Yhup0/pRaQGQuEo85SyHJKXOUKFBHGEUBOlvjUTsZOgpDAKpzSe5yNliBDepLhXFrSHwkeIiQDKWIMUCluOyVOFlBohzH5MJgjhYdEYU6JsATJEiCkE86CPgLs6GTH7GjcsKLtdEA4RCUQDTGJJruVkHfCWQrzAcv1Gzr3veDf1w3fTv5bQO3+dhVOHEM37KK+cRUY5qlaHsonrGdSBBtbOYHMfu71Fu14Sv/teph94mNV1yWhrDbn+Attra9zezsmW3sm7H7mHKT2Nr1KsyRiPEqxzhN7kueLcBBwoLVBikp4q1cR7epgVeLLAU47QF3iVgJ3McOBwjXsfOkJQ8VCBY+ZQi3K4QWkCRF5BuWxivCEVypMEJSgrCQT4UiCFAiMYFxmhNYiiINQC5coJYFCa0AtIcqjUIyqhQlFSlinCZCQ9R7tRxRmBlAHOOrIsxUlvQvPRJaHy0UpNwgFFhCdjrBOURYbQMU6UjE1KXuTgLJnJ2OrtsnrhPM9+7Sn+8rNPsDUsXh9bq0IgHVAKXKTQStC/De2DEbVKSDUMEMayN8iYm08Y5TkRAh1ppPaRfkiaZagSkqEgzS2hp4jqksIElEZjpabAm3QwtaCfO7RUKOnwI001VkTKQVkQevP4psLes49Tj14l9NaQXoKoa9xegjF9zLU97HSJCQ5TZCFq5FG9V+HXIo6dXGSvm5EmfYrtLUgKKEKkPkHev4hgMPm8DDR4VRyK4ram7Af41TbTK3ei46N0L1xgsLrF/O4LHF7uMnN4FhYOUK3GBOY6MvWRRcA4jegmlk7eZ3aujhruMhyOyKxmZmGKO+96gKwlmG0JFJpwbpFuYri1uoaQPZLdnCy1RNOOPJ2I5lT5RmHqTM5LL69jUsOBpRne83CLBx65i0y3GCQ+g7EkTQ3F9pCaq5ARUglAqkkxbEpHkYBWAh176IZERwI5A9XlACVDgsosaqWBXw1RsiDPFF5HEN7fYtwBjaFcG2EGGSZQDMsSuVIn9QJ0DYJaDJ4mTUoqjUWywkMHgmocEcaCyNOQ9rFFgqCDYxuh9lBqD6kG4AxmDCYxjDpw+brjlTVLMBeQOcfcvCb2Q65dGbG3kZIkBYNOOjkOLeDE99CAJlamEzHpPv9eTiYCrxf/r1d8Yv/779IhOPh+pxV995q4MLnXi08pIU1zvva1p/gHH36M48cXEUyBPIzjBsJqUA1c2oOyD8KCpyF0uCRnfGsADQ9qIUKU9DZGLN/7XlRlgcHZF6HcJV4+A77D7j6PDAsEc7g8wpkcUZvGudkJQB/cpnGohazPow+cpJ9AMewg+5fo9HPc/AOUUYNjRw8QeQKtU/K0w95WB08ZalVBFAisdYxSCKsaEEgMSpa4zLA96lH1BEEgiasBMg4ZOlhYDLn7xBy+cgS+Igy8SWo03ytgf/NL8JrTjtt3wvrrlrnWWYQVb3TUpQQzAQavTazE/ojHWYuzFvb3rxDidfqctRZbWvr9AWdfeolLly6xtHQIP/YpraFR11y78B1e/M5ZVjtjhFYoIxjcTqhHHtZaxkVBHGrybo70HYtTS7TqUwjxxv/999hlE2AwLBhmhlEBlVAilQTh8ADPE+y/nYkpxGsAXoAZZ6h0D2nWJk5XQuPGHVxZwGaBa53BqgokAlKBnq6jQo+pxTbjUpIPhojdDmqcoUSIVcvYRCKDEGwENgTVBARmT2PLKn51nqh9ECsajFavk/fatIertA54+FNTiEpM6CmU3UU4D4wmy2FcluSuII59RJowzkqssBw80OBYpU2hjzA9V0OJgOrsAhtbA5KkjyAlHU5okJVpwSjxkFKgovjvvLpvChx42UXC+gL1Eyd56PQD/KN/soCxAj/sM9sIiWdC4vWcnWf32LgREpyoQOBTKoeoSBpH4dpzsFiTjGqO3k6JLQXNioOjPXbKTR5s/QBsViiPObwlzdQPtHn08nup3l9l7bmcMEuQG7fJdq8wDvfYPHQPR9/7EONxRrNaINUmG5vnaB19B77TmENTHF2qUqlk5IObDG+fJaxpeutbmN0t/NqA6kxGpVbiUkvRd/R3HNurcHMHXuhIeqFm8ZTkQDzxmffrimQk2LjukEDSnWifur2M8aikUQ1otisYHEHgEWkFDkqpEdojCD2mtGSnIwilh5YaWwisFZQ6Ik13iFVBWigKASaQhEoQzU5NPItNMaEhFeCkgXGPTqdLqBsITyF1iBe1UNUasjFA+hLlKYT0EUqRj0Z0BwnN9gL94Qjp5bgyIc8THA6pPIJI4IRCSY0TAuMkCI/dvS6KjEZ7bj9MxSG9GBkFWAqk8ia2ftaB0HieJhvtMM5G+FETrSedFal8nC2wqom1Fm0KnIpAVkDMIeQJhNvDBhLpVTDZENPNkfUMEUv0Axli4Bh907L1isHbHBAHkuce/3PueMf7MKOM3W8/w+pn/5z4Y0eY/sjHSNcuUZIRaUUQ7lBceIbR1CHEzV0i7wzFrW8RRAG1h95GEC9zbNGy+mKXajHHxuVrvLoZI468g//lv/9JCucT6oytrKD/mc+xsb6BLQyZE5h9bq3nHNqBcJMH8O2OoRAJ04GGOGAUxAxDjSLg0R94gNN3LvLqxpAUw0yjSs9XaGFpTbUQZkyeFuSFwRYFoQRhIPIV+y1IXOFIsxwVaQLtJt2oSE0yPKyg4kV0ximt6RBfK2yZY02B5wqGaUYtmgTa+TKgFB5jZ4iVR6wNqhIjbIY1ErwAKWMwgtAPyfMhmBQhHNaUDPMEnCErety8eYmv/9VTfOuJ75BqD7+mEMKiA4XKJVoq/LomjiRy7Kg1FK1qlVocECmPQDiMVngUFGOHG6UIlSFlgaOkyCyBKcnSFJMpbBAQ+QHt2NFzAhdI+iNBTSlqsaJwjr2+oR5LyqFEOAkVSSPSSM+HwqO/M8BzN1HRGl69QDkPsX0TOXMIc/sGZVmlqGVkdopiF6JDVWTDMr1UUj9xgM6NgMufu8aMEJi9dZR/B848iXE7/y91bx5lSXbXd37uvbG+eGvuW2Xtq3pRtdRaepMElrCQhIQwIMCAjcEw4OHMmJk5PozPMYwNAxpjGx/M8bEZPByDAWEQSIBBu9RqLb2puquqq7uWrKzMrNwz3x4vtnvv/BFZVS3sGUnwj4lzsvJlZeR7ETdu3Pgt3wWbBdCWMDeDFQ6DFQVDh/rCHOPnHmO4Dzc+/Fs8Oj3Pift71M5FyIUWBDNI35DvvIwVUxT2MO2uYWN3i6C+R6TvZ2vHUDl0lmZQx/clR2uS65sDnnj8O/GclEGh6WcFx0+dpG/aDDd32FwuEH6HPIUi9Yk7w7vrvem+glOfYuHYEd50/jhveGu1rC66PRr+GG4qGe4XZDsj+l2FM+VhyxwVGYGrBINdS80TpL5luKOhKpC2oKjF9EYdTizej+lIbA3UMUWDJn67hnfMoXtVE5BiNtsU/X0yP2c4e5iJ1y6Sxim12QXSdJssGxK0jiOFRI+FTE5UsHZAPtwiG+3ieIK0uwXD2zjRHn7Qx3FjbF5g0pykn9PZNGz1FUu7Ln3HYfFMyELoYgQsHIvY7+asrQ4ocl2qDVlBUZivKvLfCersq93PKCvopXrPPS5Cucsd+dLSQdiav2CQ8Nd0O2iY3tXdf3U3pUySdPkaCQQgxkAcBtsHZxJUFeKXyw6C7yI8hTgSw7QheTYl7wxQtbILunLxORYf+pvYeJ/u05/CZvs40WMER99O0bmIEUN8XyIGr6A7+xTeMZAdPPcEZvt5/NmTqPGTSG+MltB012MCO8n20kt0xBT1U4/w97//EQwKVxZ88YUXGT3/AqNOm7xfILRHrsvCT2Qsrs3AZCTE3NobMZS7NJtVdGWCfhghwoAwqPK6h84xN1Nnu5+WLu5K3u0myQOJ2288QTiAsr3aPwPLnWaUOXgu3ZmaSpVy6eLuBSs7CdZYsOZu0lCgv4o4bw9cr40u0BqKouDm0k1+6Rf+Oa7ncPzUIo6viGVAddxD5yNcz6F3q4c7UwcMg/0hvnKoT3p0bu0hjcJ1nLsQtG/gjIHSiXuvm+KGLoOkPEejDLkBT1uUFISeJFcWzwFHlOMilShVFQdDRLELfloqnMcGqnOY9irWHccGk+iRRGcGVZUIzxK2LEE0wdbTr5Avb1K1YEZ9lHscrUOwErIQa0KozSGEItuUKOsQtuYJxg4z2Gyz++VnOTW7wPiZHDVbhagGThUhC0y8BbTQjDPsFyR5jBsWuGaCft9SmTkEUlHzBL6wdIeKc6cfwZEFmbGM18dJbU6iR6T9Ie1djfSHpKmCQrG2WvuaY/x1JQfvfddjnHrLu8kmjnK63ibbf5KXLjzFwnyb1sIjhLU3Ek7PMPW2cS59PmM22WNtpaBQEVHN59Ck4tTbHOo+9I3lqV/ZxlxPObmY8OSXf4d1fYn10TEWrnXxa3Uq8w7yYcH4m1r0exbHTRhc36HS3qAy1mZ9KuDUd76HwGkw3hiRmD79dBq/OsPkvMTKgDORQcpdiuEexe5t4qVlXt7bod7bpDI+ZCrMCIsC0dVoa+lcsyPmGYMAACAASURBVFy5Ah9fFjyzBb0xxeu+t8bkZoHu5nz+ckF/TxOFivF5xcq1AmNBehIPiBzwpSVPclwHxqciIqnQ2uBIQW5ha6NLnAi08UiVQQlBIFxy4ZKatJRDcyV5L0MXBsdxsEIickMuDAZBJfSpuCUOX0mPKPQZxQl+dZagWkUJSxz3iQvB5s4+826FaquO4/toq6lHdXrbO3i+Q6EE0nURVCEdgMkx2mCQ5AlY6aMqNayEQW8fncW43oDQc3GUg1QKi4MjcoTjYU2BsDnSGDCSIs+oNFp4nl8qx0gHIyDLNFJFWNul0H2kVgcL47B8ijiHEEph95eQ9SrBEx/AtJ8qpcKyJZxpw+J3Vmi+JLjyC1u8sFLwzW+LuPDJn+NYrDh639uY+cWf5rlf+Bc88f5vxp38t7zyoR4TextMzzu0/yzh8xdeofW44o3f9w56N1yyzWvUNl2mvvURhD+Pt1Hl+rWCuQeOcf7hRUzoYpB4ViJVxD/9xQ9y37lT/OsPfpDl1TYRhsJaUm1ItCG7o2SSWcJQUfUUlSiARoWBG9BtV2jVTlM79h5++/c+TOEFLBw5TGgE+519eu09PDfEZDFpZsgLkFgcCQJDXli8wENbQZolSGPpj3K80MU6EqML0mHBvhVYrzROI/MZWY9CW6xx8ZVDrebTDCOUGxAEdQI/4pBUDEZdhmkPzzrkWYZyJK5UIMERhjwdIi1k6ZA0HZIVmiQzOI5mlPRIi4xousHs2XmcDY84zRBodFqAEbihT60RUHfKKlwvLlCxpMgsRQCVmk+9GRL6FVzHw7EeKpdAQXfYYZS7jCQIGdFJNHvdEe2BxfclAxNSiSqEBOhCkUrB4fGSe/Dv/jCh29NU6pLXn3J4x32Smgeu53L0x76XwZMbxBc28dZ6hDMOasZDJFu4Z49jl5fI1vrklQfpJPPUl27hLOwjJ5qEwRh6v8NYKGlYQX7rJmpuCr0bgF/F2hq2Y+DEYXRbs/KlDcamK0y+bgzb2+Q3fuKf8O53/kNOzD1J9IBBzcxhnQV07yZ2bQ0aD5BtRNzOU2519xkO2zx+9DTrGwMmz55nolqjEIpklLOz2ubTv3mBy90+Na/HQrPGkXOzLJyfY3ZsHhU0aE5JJu0Ww62vcPXKRb5w6dbd9f79730LtZPnCSoBE06ffLjMzvplxsb3CRpPUFXzBOMV0krAzmpBo4jZ3zXgulQCRRQKxo8IPFXCxl/69R4TLYVkj+UXX2A3eZlO9xCt1RShJKoC8rQklKUHgXQLRtf7hEUPMZ5RTEVMPHgOx7hUKpDoBM0UbiAIIwFCMeVZBH3y0RAz2CfZW2Mw3MOLb+E1dggrMU4xhCRBFwXJbsbmmuWLNx2+slXQOjPBW981S9AekfT6PLOaonsp9amII6csS9e6WANZZsgzfQBZuEc0llIiD5R57mzG3IN1lPu9Kkk4aCP8BbTHX+PtIIDEvgoiIkoehrl3ZsPhkNEopsgTXDcvlYrkfFm1HX4FOfZakI9h0xtl4KovIeuCibePM3hui70nb9HZMbzm0UMsvfirzPctM+/8dkZ9zf7VS8wf/1ZUdZKtj28zqV5BdTN6L3bZWtklfNjh8KNvYLg0Qm5eJjhWwT98CEmE6gRs3R6x+MBxjk8vHsCSBMoCwuWnf/5f8Pv/4V/y5Mc+zdbqDnVbkGY5/SynkyU46oBXoqAxXuFQLaDSGqOYbLBfBKTtKgsTxwnHH+Djn/sSXmuMqeYYwtqyUv+XTgzu6WBZSpibPJBFlaJ8T2NLprgUdxKRe50FKUuTuiIv5VA5UDW6Q7gXQhwgF8BxHHJbfNX11EZjs9LE75Wry7SmGozPTzDRiNhaXqPWqlLzqqwtrRP3h7hSkCcZ2ctbFLkmSwuEOJAN/UY6B3dMBy2EjiBNDV4hyVKLH8iyk4/guWuaqbrFOjDfFIxVyktrtcabnSBPK+ilFIcOqqEQlQDyXeTCSfT2dUw8IjOTaFvB7fYQ1QGiEiFdRZynxGlK1QpMZxen0YB2FZoRtggh96G5gB1q9p9fYep1c9Tnq7SvXebqH3+KM2/5AONjL+AcFhDOgAmwow1sPgBvgaLr0SFlr9sj8CTjzRbDQU5t/hBV1y9FudKcnY0BF1/Y4sYgpenFzDdrTB9rUpsMafoewq1QqQladOjtvcz1pRX215//mkMs/v9amUKUnu61Wot3vffb+YG/9wOcPDbB5f/y++zufpRzW1vkaxl94WDPzjLxuvfjTr6Hp3/3dxnu9FmsnWZ69g3cnjpO9fGAxxYUH/+lNk/9+a9T3b3AE815Evc8H7v6PF/Jb3AkmOGNk+eYjMZZSnd4+995J6OOwuysMdHbxO2tk3gFvPvttBcWqCgXYy3d9jaeE3Nisc7+bU1Pwd6zv82Y9zLNqIswKZu3utTnM6bVLrXXu2SdmKwTY/Kc5c9ofu0SrM4r8hmf1IDua2qZYb6ABx922D7kstdTbNwwrF7O6CwXuBWHkyeqFD3NWMWjFrj0Bpb6eAWRGMKKotbwqFQ8/CAgCANGCexu9jBWELgu1dCnFgWkjkOzUaMRhEghUdJFWYGNOxw/skA/hgEWKSyBtFQCF9lYIE1HBK6DNSXeURjN9so629s7RItHKeKcSnWMWrVOFATY5hhLS7dYaCk83+BHAV5QwRSW3ZuXaC6eJhkVSFnqJGMt/WGHvfY+UU0xU5+g4gcoWSp3u7U6jgN53kMqSVrkJGmO54QoYbAix/dclCorFgiHJN0vZVqLGCVjPC/C88dxXR/FFWAV8iUss0ANm+9iey9hvQcpOs+WWMHmMeT4wyBOM1j+CO1f/CTT33YWeeqdUD+N8lt4E/dz/V/+FLsf/2PO/o818i/EtD/So5CCtB6yvC9ZE4ZzFsaVwjt3ipP/7J/w7G9MMLjS5vzfm6dxn0U2RiBz0pHLl3/lNg/9z48TjTsIIXn+uRf5oR/8YdZWrpWd8IN7x/EV1brPXFWRhQsci1qkTQ8jFBNRyBsfmOf0Q9/F3/3gr+JUj3H6/hNMTgfEvW2uP/UccXuNw3MzxIM+mdYURlMkKcKropQHWYoXelhRdniaLZ+wHkI6IjEFwhUo34OwQdBscP7MAkII+sOEPI5xbUa9bnGwLC5MIH2fRtREqCoD7dKqOVAkpMmQTKekRYq1hopbYawS4UiLtpYkTYjzjMJK6pUWlow4HXJ74xYbG9usrW1zc3mDXjfGZkMGnQSjJX49ojndYLLu05KKK8/fpF7zCaI6yg2RQjBeC5kZny7vB7eKFS5WurhRi5yQoF6lvZuytd5lMDQ4boRKUm4u73DmzDfz4INHaMw2cCoeDU/QCiW1OgxTwZ98JuFzXxqwsZ1y6HzEv/8+lyjSiOEFuPEh7Cufwt4eEdRDRBSihYs8f4j+dkb3mRHR6b/B0ucsR77nCSrNXfyZAJlt0//sR3nmV57nkV/83whOHyF58sOY1eu4TRfv9R5xX5B8skNw+By7kWRvf5f8VsrY0e8hfO5Xmf1AA2fhKMbMk217pCurJJUA78gTPP3MDVy9y9zZk8w9/E2k3R5GgA7GcL2Adq/g6rVtnnvmCvUJj6u7itZElesbXW5evUD75vMoUaXhaRaOHcbrPkc322H65DRvevQs/9MP/isA3v6O9/IjP/bDvOGN56m4ht2bl4kHn2Vud4XRek7eqqEWTxHOPooIT7L8hS+TDzTzYyegMcuoVSM4pDhUE1z+oxGXPvZHHPM0M80ZhvkYr1xY5eJwjbNTs5w9eZRMG4oqHPkbRymGEtvpUBt20d19zHQNe99h0noNT0qstQz6PWqRIPQd0qElkRBf/wL16Dael5AOhiTDPkEzocIG4YkK+d4GmD2ybo+dqzFfvF6wPNcib00QpwVultEsCiYMzB2NGMzUuXWzYH8vY28zpbOZ4wUBX/jjl4gHWWmid0BERoAuygDpTtB1r5tQwjHK0OdOclBi8dWBbvmd//vxH/8H/PzP/59ff4D039H2zDPP8M53vgO4R0a+C5WypZiCUoIw9Gk1G/zQD303P/qj34FkF9gFs4rlyEGLYQubb2PVCWzyDGQpovZa8E5jtUu++xXSj/0p1cffgm09gXAbSL+BLQTdL/8J8Zd+g9kfOMPwty6Tr3Ywvk8eTdHdVexJzVEjUJ5P+MhbCB95H9sXArLlhEPva+K0CnALrIV8aNl4esDCO44hVelI/5lPfY7//Du/yfVLX8BNLYEEYwXRzBhTM3WmGhFFdIIj0TjxmIcoFLPjEYuLcwStU/zyn3yWyclj3Hdqitcfn2OuFSGFKL8Oxu0b3eYW5un3+3c7DxZQ4l6yYa05MN8rZbPK53D5twJ5V0b3biwoyjl7p7ugVBlbwAHGX9+Biklcz8V1HbQpSp8LW5oDludh0IUmjCJGcYIxBteRmEITD0ZYa/mzP/s4588/9A0nB8aUxxHHCdeubZFnNWr1CiIoJcADB3wl8HzINdzeNgyGhkFmER48cUzgOAbSVdj4KGzfgFGOCiIIIqzwEcePMrq+i8lbyOppeksFzYePoNwuTqOCad+g88yz7HzhFsd/9O+ipibIX/hjRJagxj3EhEMxsugrPZz5c/ScjGRrC5E1CKpncFc+QfUtDUTtMCYbw3RTiuEA4wXI1gmWr60TukNaR0/hNyfQeY4VAqMCHMehP9SsrbVp7/dwQsXmUFKv+1zZHHDrlcvE7Q6e9Gj6lkNHZ1B7T7OrB5x94CSrN2/zD3/iZ+9c0//mwH9dnYM3/eRPcvLs61h7pcvKlsPjb3qAR5oNiu5nGd26znBpRHsp5/J//BAfW/0wb33wNbS3Y25evsZg9J9p2wr/w4X/g+UfPMHWM/+JfH+D8cffxpkf/XZGmUvjow/xvpUNPvmVP+Bab4mb8T59vcIn/8Mu73jobVx58VOsiC6t155m/IlvYtiaopcp4tsp0yckM4caZEnItRsjNrdy1ofrHB97iFeuTrK8fJM0XuKt8z3mHpgnPOGRfP4WG/sjnl3V/OlzhlUjcCckRVyh4SiOHTW4Bi58TnPZCq58oaB5XCAqlvauYX8jR6eWak0wbGcwggRDzYf5SZ+JUNGTlMZQulRGScgxIwGVCo1GjSjy8T0fbQRJltOsV2n4LuNRgDWlWZhUHsaPoDJBf2uV/W5MVA0IW6WWvc4zwMdYB9cpyJIR6TDDCoWnHOL9lObYGNUoLM2gXIkj4ey5Y6RxF5t1S0hTpil6MWE0y3BvhCMNqlJBG0MyGtGNNbISYSgolMKoA9jRnYqDBaSiPUjJiwJHSjIsRhoCpyjbyQbyZEReDAgqUyBDlOsdKDYJsizG6h6efwQpaljbARQUbWx2C1FpEd96lvD492CzLrcvXyO+tMbZb3kf9ePHear2LJWFKRpTp2lfjLn1e79Bur7JidYaxzwX+fERlUdPEr1vDHo95On/nSO3XYb/y4/wu9c3kDk8sneJG9/xY5z/rh/Cfvffwj3kY659mCL9FOpEFW/uX/Ha136E5d+5xPw730/96BHmG4KffCzkn34InKqkogWpgcxIBkPLi/0MYTd4xa6hrcEKByUkH/3znGb0h/z4930XD37LOzBVlxevX+VzL1/Fd1NkGLG9voFVbkkUtwKFj+c6eD64Yy26+12SUYyQDrnWeHFBNXTxfA8ovSVkOmKMgFG/W5LOrKBWUYRI8v4AFXnsDgbUlULEMdKOMNbQsw3qnkvoBZAWSMdDSUnkuXiOhy5G5EWB1hZlFRLIk5hhOmR/2GWYCIQMaDbrnDghKLRm9coKvhcx7KUYA9mgIJU1ei5UZ48xV1co3yfHQRpo1BsYv4Y1UFgHxwtwvBBtLPMTVTLl0VEp1uYkwz7d/iYbN6+yt7PGyy8/xac/d5hG4wzT4/dx5vAZjr9hgm962GN2UvF3vj3kA98ScHvb8PufS/nA/53xo08onjh2lFrjMfTYENn5EumexrMR2fIOTu4QNCVqdki++odMTLyN9qc+z86kw9RpTT3qoGPBoWpEenue4rkNZNxC1V6DFYr48z3MGYN3aIfOK1+mevQcNVln2LkBN/8fpt9VRbXOYPpzpO2EZHgLPT5g1D3BCx//U2YWEmbOv4vqdFnV6l3eQc6eZr1o84nn19jauo0iwW3McNme4sH7KhxqGCYWe0xPWm7UXTaX1ijSdZLuOuPHZjnaUtTDHutXvnR3vf/uf/RTHBqbYXcrRQaKQ0cWqXjfihk9jb+7RLbjMNje59alj/LSusND5+9jZ63H1qUlOr0UN5rm8be8m86bWvSfewqhPervuI/J84s0Ymi8tMhDm32e+/SnubWxRU4OuyPMH7U5+eAJbj/zAu1aQf3hUzhH58iDgCyHrFPQmBM0xisUScHunmYw1PSyPjOtU6zeaHL79gY1dZvjcym1hUncyYD8wjO09YgXLwy4eCPmNhZvvI4zOkRzRnJiLqO7p1lZSbg1NFy+aplMXYaZYG0zZn8lJt3PWFtaResDyIU29wjIVtwN8g+etne/3TO2uoP/tv+V4VVZcf/r7XNQBo32QLa1VMmRJdAbkHfHKssK2p0+v/7rH+L69Rt88IP/K1IEYPfLN9JbYHugQnT/Ik7rO7DFPnvLVwkafWqzD2GaLbYqTxM0J3Ars3QuXGZ45RKit06jsUarMol+bofw/d9G6OQIatD4m4x1BXO/+Pf51EtDjriCmVsfwX7hCjPv+V7sWx5EVQRm5ZMQriFaizjBNzN96CI7X1xj/OE3oXyfc/MO3/pAyIeWHbyjAfVM0MsNmXFY3ch5ea0NXOXJPCUpcoSo4ZFRc1MOzUzxvX/7ezj84GmCKKDi+/9VOPzqufH1bkLIA7+NO4R47sbZFnsPrnPw3iUn8A7kzQLybjJ7Z7//FiNaa13Cmg+q9sYYiqIgO+ia+IFf3gfWUuiCPMsx1jKK04NbolRD0lqDLT1Jy+P/xs73TtLZ7fa5dPEaf/QHnyLNAx59/Dy+P4krG1QrVSYO+RyZU/gVwalFhS4UW23L1Q3N77xgeGxRcLg1CZWHsZFC5MvoWKJkE722ilIevpujTQe9v0MY3Ed88QamKakvbEPSwRUurXqTotNAX99DFvPIhsTGGrOSwniBnNxhdP0popMPE+gA3d1AsEv0uhrCP46NmxT9Psb2MKEgHU2yf/l5xqdyakcex1EeeXePtJshquP0dMKzV/fJRu0yMas06MkWx+ZdxkODX3cZD06yvrrN/nabIuuQdHeYO36UQ+FtAm+bl/ZufM1x/rqSg7ccWeD4yVMsbSWkkxHNuRZShPjRWZyxPbzjGwT7m9R2Y7z1s1zfrLC6dYXh9jLdfo8b8Sa//9lf4r3B3+bl3S12nKPMe+dIhE/UlMy8dYzP/PIaVVMlKzbZz2L6ap7l9pDbK5sE/jk8v40XHWK/Ms2GqvDoSQez6NK1mqrrMNbwCGshG07K2xfruBWXE48/wMNZjM0H6FGbT/72/4X/4Q2urQxZinM2U8sgs8imQCk4dwQ6GyVJc+qw5HveHfKVEbz0UsHutiEfGtLUIpsKt7BUlED3C8ZrIY3IxXcdJKU6iu+7JKOCvbggNaB8xcxEjchxqFV9KpUQgSTLS1kxdE5BQKILdKKRwsXzHXBD+lqh3QrKNegChsMCcBF5juN7CKmQjkWIAiMlVGs0ojrDbozWoHMBTtmulyZDiAid5TAqHY2FVHh+hSSzuJVx8qRPnhqE64DjkyS7jI3XyNIUKwz6YDEwJsdXNYQ0IAPC0McrdMlklophuourQgxgTQH4eL6P47hIJyg5Crjl8QuLNvsURYzrnUR4ExSjq5jsFkIexgmP482sEO9voYmpH2rSUDP0+rv4mcMbf+IXuPAff4eFs5cYryWMz6/z4rMrPDBhCf/B65HpECMmIL8f79yboXGcMFKsRie5z+0TmD4tk1Pd3yf9xEeI3v4exJhBRq+hWOkw+Ngn0KOfwvv2H2POm8IbnyTONNc3Yn7rk0soRKnM5UjyXFBoBdLBUlAUozKoAKzNsdYSW0M3zvn3v/fHjD15gUff9FpGSFavbyCzDD0s93OUwupyAffCCOUppCplI/2ginIMVoD0PKLIJ6xH+FGA65XcgqTfJ+kOsPMzJLHGC30qUUDkhtjIw0GXcymzJGmKo1wqYYjSkqKwSEfguBGOyZG2tMcuTEKeZ6Q6I8s1FoGjFJKUYtjD5AZrBK5yqVeqVH2fzn6XQ4uztHcGDLwRFkHge1Qcy+TEFOM1QdU9qMRaQagclHCJezHKC0tya2GQIqPAst8eMHIc9nsDBoUmVYpUCIbGkIuQYrRPttmjt7dMZ/159pcXeeHiA/zph48ydvIw735bk4dO+5w86vADkeTcVYVfM+zsBQhxgmixgLDF/p//OZPHPfTWLGZdIrVBTYSAZsy5yrULMHv4m7CbLp2tXeRuj5nvfg8mNthsFeFmiGyA7MRQrZFvNBAT76ZSv4bsaZTRuG+eI7+1hWy9BmJDsf0KedpDC4sezSLsLkebt5g8/y7csQZ2fx29voeunWUpNrx4bY/6zCxjx+YZKlgj5Ey9hrtveerSkNB1mWoucupbptB2wOZOm0YwwA1uY4xHZ/c2V5buSZmemx7HqbRoa4tfUQRRiJAujvduRLiPmujiHI4Jhga/M83WsMJOsESR5tza7dBfu0qo/4SHeAvLoyFJdITMG8O4Dn4TOBNy7WKXMb9Or7/DkIjCrSO3U6Zu9/GbR/AqA2ylSd+tkDuK+ZaEpmUkLBUl8TwFviEJDKdqPo6raBya4lB6HGES8sEW1y58Bvf2Kyzf3GJ5GBNnGUMJVB2iqsupRcHeyh5J7DA/FXD0dRFLfcPybsbW9ohex5ApSyI060tt0mFBkem7wZe1d7DiAmEF+gCrXcZV9gCD/9XQoTvOydwlIP/1TQhevQlxD/J+J3izQiApK9alB0LJ17A2Y7/d5YtfusA//se/zM/93E8j1Bsx2W2srSFkEyEayGiPLN7HiiG12TmEUyfLRkh8Ft764yz/l88y+/pV/HCD1F9lsLfKxJTCfdfjkLaxZgoRHkXWFsAdxwkE7cobOVt7ipoeEeYx7vYq5oufwP3hB8AvYOo+9FaMWXkZSxd13zuoz0elu31heemlFZ789Is4VpL3YCf0GQwsVoRo5WBMSpa0GaU5FkGexxSFZhvLelez8e9+j8NHn+N9730rZ17zGvxm66s4K3+pBPFVSSjiVR0qDqBEdwV0D3Y3Fn0HjHSgJiWEvJvg3vNM4O701IU+UFg8+JDyaXaXcI4AEovjOHe5NiWPwaDvWIgffLbRZdfB/BWmvhCQpBn73ZjGxASSgi994Yu0mmNETh1fNaleX2D/vml2i5A33+fRrEqmxwWVULHbF3ghDGOHwDuEM+VgnHHSW1eohAobHkbvKMS4iwxSIMVnmf1rlubCm8g3EtgboKxL7fFHITVgdhAuiKQNrsB6FUy/iqg/jntyGTFKccdCnPoYdjREVA5BkmE6Sxg7wIgQa1tI0aNV3aR66DGEEtj+PjYRFG6LbmpY2UqYnB1DOk16QjKSLgueixzBhVsZrdBhcXqao7Nj5HnCYDSi6uU4wR5Wa3Z3tljfT77mGH9dycHQOiR+heZEwOEFHzcoEGYabT1ENIcfHsed6NM8olHdOdRaTnVsgs0vTrDy7AXG0w7X91d59umPMIw1XnWePC5YenKNzf6I+UqTq+2nGK82aCjNKN5n3+1y7PQ5hmM+s605vOZh0oUmuh5yvKUwV1P2ghwrBa9cv0iye4vxuTpTY8eYbi3Qo0JzXFGtgJSG/jBhuPf9PPPr/5wvb3XZjS2Ts4LHHvHotxyGic/ILzABxANLulRyBVJX8ND5gGs3c3Y3NXQEnoWoJbAZd1fELDOMpCZ0HLQR+EoQG02SWxINSlD6HRSa2UYNV7lkoxKf7wqBNLZULZCSwhY4AoSrQDkYI3AdF88t29AaxSCxuMIQioJemlCpeijhoBwBWpBnkvpYDbTFFSDtweKsNTbPMYVBuUHpemwlXlhBJQWuFyKkIs27GFNghSIIAjKTkiUd+t2CQrfwwyaBXwPHQ4oCqwJcofGcclEobEakxnCcAmELhFUIWZ4f1sfo0UFpzWCMwIhS3slai3I8hJgFmSG8CKEMRhhk7TBKFEg1i+t7KCciyy1aR3jdl6nbk5ibK2xlN9lf3uTQjME9fx7ngb+FGMWIzitYu4pNJ9D9s1itGP/+72Ni/43wlaeQX/gioTLIyg6ifgubjWG9MeTcm/HyCJ0rZCMgbM6hlCLLUuJhn+XtmBGCwgh0bimhmwYhdVk4Ew5WFCUx/G67XVIYzfXVDdzNNsP+ELdSox3n1GpVtJUEboWgWiNNMoo0x1iF8iKyPCcKKmBShCzAEUgJXhjgBCEq9AgrPjb3yUc5hRbst7OSiCYKCl/h1CpUm016nT2klPT6GYGvsNrQG/WpNj0c5REnBVJYRJGjTIZ1PZBl5b/IDUlSSueqwC05BcbgHGB1BQrHCXBcHyqaPM5x7ZDI85FS4igHR7j4KJr1souWpwXkBmsl0lMIY0nTAhyJg6RAooFe0aedFCSxQSmF6/kIWRC2DjHWWmRzfZ2kf5vRaJ886REPtvF2dsE7zNz6Ah9Zr/L80UUWj57j0QdDDjUdrq+mLM4IVOQBITYaJ3jk/fRuv4iyu3S3Uuho6n1F5VgVhWbqkEuyehOd+ITC4k8ep9hOSZafJIgGmGqGHW4jbYz75inElk/e2SU8CirwYWiwWY53/hiy2kHfHJAlOVZJXG8MJ5wFsUft0KM4zdPEbRjuWtrxFC+lPv3Qo6i7NFqtsqMnYKrqMKGhk1iGxoXU0hEOmYqYmm4yPz6JWX+Oa9e2GI52yYYx8c69J3VsBFXXpREIWpFEOg4Cg7Euwm/ieClOLSPQAmemDu0CJVw66imLMgAAIABJREFURcign2HzLdY2d2hd+DJGS7wxh6yXs3GxQxwbGqHLRucyk9OTRGqHQZZB3WP86DTphEOj1kTWWmQTdbxQETkCu6OJXY2QgpuXXsb1cyoTNWq1cWphjQSXWjXAcSKstYz6dfJRwtrtm7y4/DIjbTh8X43FIyF70sMJawykRVQU3W5BbqHSKH157jve4ubmkJgcP7EoKUlHRWlEaO5UTe1dpZcyTLoXfL2qUIvBHKx5vCq44gDicbAff3mlmv9eNiEEjuMckFnvRZX24B8py+CzKDRFURKTd3Y6fOazT/NvfvW3+JEf/l4cMY6QtfJhBQjPLe921Sj5d1QxWmCNg5OlBN4x9MYV+puXKPZuU5txUEceQi48BnEPM7qFEJvYooK1U2AE0bveTe3Nx+H5TyC311CVHKp7ELSxuQf+OLJ5P6hpLB4i8PDCJgKLLnJ63QHrO316QjHKBNkgJ48lQmUotyTAojyQFuXVEb5FmVIONy40V5fW2O0mWDfgA7UJHmw0/8rX/U7C+WqA+Ku5L6+akQfBvL3Lk4E7Ha6SRM4dGd4D7sGdpKUoCrQxf6HDcKdJZhGURp1wwMcx5WeVnYa7M6FMGF7Fw/nLCHTdgSDVqhFnzhxhenqcQX/AH/zuJ9na3MKVbaKgzZxrWbkeUxQ+X247NCammJmqMzMhaQWSvbam0ZAI5WBNANU51OEaWX8LIXcZbA5x+xZvMkA1qwhjiCYdkpVV3NTB8auIwMe0M4r1i7gtjY1y9O4GcqyKWGhC30EPerizHsL1S7K9UsjWFHg9zM6gVDNTCuVGWFUFGeM3TyP8SbJuTpa49DKPPe2QuQoOCjaZAd8ReI6goiHOLSmSLHfoCocw9Kk1K1RaOaazxis3tkF0yHs5+de2Ofj6koOXb3SYOpFwbr7O/XUXpMKVY5giAxTKaSIcl8KReK7kWJQT1cdp0KKeOdRfaLPU17y09SKHa6cpwpR0f4sXPrvHjY0tzowvEM4MQM/QSCP8RIEZUT86TXRqmvr4JOFMRFIN8KRD08LyxYTdyQTdbrN3a4VB/za7+wNOHGlybVigGzPUKzm1qkvUiKjUXc5/23ewtfEKx1ufw7l8g0bUZ2JeYl1JZgNu6gS3YUgcwfbQsv6KoTUmOH5Uos+4eOMOe7cM+Yqh4UvSNoSyLJmkmUWgKSKDprw5rAR7EBB7notwPYzy8IIQkWagNQoIHIUSsgy2bMEwzvFDF18qsJoiTRGmNN+Rbum+p0UZOOVpzCBLyE1ApRLguR6OckkzQ601QTHoIfMMm2kKxyALByvB5Dkq8NBCgLYo30O5DlIWBNUKcpSQJAOSNAED+ztbmKSNzWKywlBXEdV6DSEMFo3AQ0qNPFDisIXF80K0aYMukNKhfB6WSgfCZuXiZDTWmvLhKj2EsRRFv/Q+UOMoJ0LKFK1vgDuN3wSpFgEJeohvE0ajIemNi8wfOUb/5RfYufwSw/aQs980hvvIu8F5FFHbwuxeRe99BYpVMj2LM/ZGpt/7TqTbI/9cjbhYZvDSJuP3a6hsYwsXs50iZBX/wbdjGw2K/m1MkSNRbC8vs3ThGWqew35qyDSUJhWybPVaiTogWyk3Kk1o7tjc41BQUIw6GAQvL63huAGVahVHOWihCPwQ5fi4vsRahUWSF5CmhmpFYnWBsBolPRxpsUYTxzHaZihrUFKVilKBotPNCKNSftZ3BdWKh+9YkkJRcRXDNMN1ywA8jjPc0CCDAx8iCsgyhM4gcrAOSOmgC4UpCoQETElO08ZidYl5dZWHwcEVliAosMUeQlt84eC4Lq7jIVUFCpCuJc0lRS4ROWipkKFL4EqKzGALjVYGYUApSPOEUTfGFT5SOhhHMXI9ZmePMD82zvTccTb3btHv7JN2+yTdPfL0Jl6xT752ha+shFysn+HUacFEepjaqRYhku7AoZo7jAlFIH2qJ0/QG4C01yjYIGl30cspulrBFoaxhsfqrRuIYYBoTJBXx4i/eBF9ewOxOI9uSugPkTZBHE4ROwLV2kN2FSIS4BgEAv9UhNm9TppMYZpTKByUqCCm60ipUVNvZWvLsr26z05PsZpFfPnmCvXJKWbmaux1c0bGIHzJtA+qa7DKZWLaw0kVg17K6kpKN81pNQrUdp9b1/YZdDtEjqXqT95d72+txdxXt8xUXVqeACkRNgSrESJAiApWSowSOI5gytMEfoUo8QltztgNy27fsrpxg5nWaZJKxmCrS+9WQb+XMN2s4s+M0O4ijQboUYdRJAlP1PFmqgS1Ck7TLbXFhUBlls5mwaCWU2wPaa+2kWFBtYBWErLTKaBRp1AlId8NHMKgytxrH6Y/2GKs3SdeW6Exq6jMuIxiSGyTHT2i2gwYdDN2BhYxyqmHimOLDvZIDVnTLF9oM9pLD9R27gQ09q68I9xxBj6A1PyFToC1HKx79yqxr64UWwBTqhb99U0NAMRdU7c7FfCSMFpyMpQjUUoewLLKAlKe5ezutPm1X/tNTpw4yiNvfg21agNEjLU9hGrgBCDkJNgMYTTYHJ3lFHu3GTtyiOTqU8QvXcGLDI03nEIefQI4AeEeZucZhGoj8jbG+sjwGLUnHgZxH7o5IH/usxRxj+BUBk4fsjp2P0eEMziLh7GOwhRDrNEIodi6fo14d5uwUmFlYOhkFpspUOrAsVzhC4VUiqA2jpYugXugSogkzhOy9iapgS8/f5Vjxy7hOpKxsRbT0xMlx+9V4/f1bge83Hs/iDtdqXuB/53X9+btq5NRe3cOl/K74u4+d47HHgT6Qoh7pmpf9cmiTEgKjTnoPJiDLsHBjXH38O68+qsp9wrq9Qq12iLWWlbXO5y8f51hb0AaJ2Asmg7b6wOaCG5u+NSnLWYIoQ4JxgPQgsGo9ITwESgvRE1OkuUhsl6gBzG2N8KKEo5NYQhrLu21VVxdxTYamJ6guLaCvb2NPL2IrYHdjFGxQnoJItWIqIOIvYO1XiMCiRp3sfEaOm9AfQxZKIRfhzAsPUKik/Tahv5eSl8HrPdhvdMhakSMjwe0B5oUQRgIqghEYkFKWi2Fnwn2hpr9xNDMDKFncPoj1tf6SNOn4fr4Tv1rjrD6mZ/5mf/PX/7sz/7szwBMOvdx/5HjvP51c1jpEroKX4a4boRUHtpI4kRwu12wP4T9jmBz6FCdGGdxbgJ3Y8Ro1CF3A94wM41jq2x2Rqy0V5kIbpLke7zzO99P2xHUJj1OHJpj2pvj8+11nvjm1xBXPKKZkGrLx2rBK5dgxWjMpOXpTz/DkfvPcN873s1GdoKrVy3XP/0MVjisX77K5ss7DDYlqnCozwecfeQx3vLEJP2dDhcu7fD0Us6lFzTXty3uvEOhDcWYxMw55FYwXhUs3co5e9wlbHgY4yD7UPcdQuVQD0vVF9dRKFdhHYUX+uR5QaEkKQ5KudQqIc3xJmEQlsF7r09RGDzPpxGFOI5Lt58z7MV0OglGOLhhiC0y8jShSDMyYxGOixcEBIFPYTXWxJgiJx7FGAVevU5Qm8APQwJPUqQJab9DPuqCyPBCB98xxMMUqUopM3unza1TrMgJKgGeEuhkSGdvi92dNju3bpLmOZ7jo9yIoFKnUWtijUQXyUElwsFisSZHShdtUowusNbgqJK4JCnIsxQvqOJ4DQQOUjhIWXYClBRoE6OFV1Yu5Agh9rAUKPd4ab4mxsG4mNGAYmeJYvki0mkga9fZeP4i4voOJ1oe9fecIXzkH1HsFdjeRfp/9nlGz13DX8zILj2Je+qdEDWQro+cHDGq73LlT64w/y0W5/7HEaGkePYViss3oS7BM6RxhqBG3M34yH/6EL/9q/+G8YrDRgFB1MRSQTkhyqvg+CHCCUFr3Ggei0YJief4BJ4D1TrCaKQKwBqELbBGk4xSCmNxlIPQGs/3qVSrCCnodzrYIsXmGaZIUIJSzcfxiEd99rZ3yAZDksGIPDO4lSr1iQbaWnSegjA40kIWs7OxiqNCQuVSCIXveiU5PGiipCQ2Bsf5f6l702DbzrO+8/cOa9zj2Wce7nyvdAdLlmXJsiwj8CAbsIEwxjhNDHRnoJsiobvTqVCVhFQqTVWAdAgkjC66gDg00HjEdmxj2ZYs2Uajr3SvpDufe+azz573mtf79od9zr0SSQcD6erwfjnD3nvtU+usvd7n/zz/wcGxBops0llSYj8wzSWJc7ScdC4EOUWZEWcpw7hACr2fKyDBQDRKGPV3sIVEKxffCwmrdSrVJtJK4mFGnhaYzKLQVPwKju/iOCAK9qcvGiEdqn6IyXNMmlPRDmQGk5WEjsPS3DzHDq/w4NvuYfquN1FbvofAXUaME3KrGOeGqOxTdwRLckhzfI3N64K3fvtJ3nSvy5PnBd11SR1Fs5nChcdpvOP7EdOnqR9rIhoenZ5h7/kuUVKg1gqCORdHusTrJZ0/2cXu7eCVEVnhw6iGKSsUhUtxfojrWoK33Emx3SRf6yL8gvCNi4jiGvmFjGT5ffgrb0SLJqQpVBJs7XUkaZ0vP/oKT19t88zakKdf3ubS115guD1EWtjoF0RK43oKf5CSjS3unMf0tKRZkZCXjPZiOv0BN69vocsMYUucOKPiVakcPc75r30VgIfu+V7OnlpguuUjxL4zmtAo6cK+vXFawCiFOIMohl4umVqoUw98nFRg84Q88Di7MkOeeOx2xkTRHhVnjzyLecN7HmQ3i5k+FDI718L1KqwmESdOz5Jqhdd0cV1Jlgg6e9DDQk3w3KOXed0776Jy+CT9pMXWmmH3+TWcmkvn+gZxp6RMJFJIvLrLwokz3POWE2xe73NlJ+GV1ZjVaxFrY03lcECRZ5SzIVnNA0fRCgQ32xFnluugA77+uTUufXWbIitfNTmYFFMHRcpBEJpS8jXg4LY70YHQ8yAE7bZr0aRImlge3f+mN/H2t7/jG6+P/htaGxvrfOhDvzMxm9Nq383J3Co4pVKT7r+1r7HHLI0hyzKeeOIp3vWuh5me9veZ6QIppxHSAVGZTF6yMWbcxgy2kaqKCK7ReeJxKv0uzUPTuG94I2rpXZioxMY3SL7weWzeQfhjTOc6cvr1CC9EKIWYV0T9XYZXXqLyJo2cfwC0wZy/gU0icC2IkrIokcInGeZ88oMf5Ob5Z/FDn61MIdwaqFm8cIqwPoVfayLdKmVe0Fg4Q5GOCZyAqu9Rqfm4rSm0sPhhDW1T1m6ucfXqTeIsY2VlkTAIgD//FOnnf/7nydJsQi+Scj8zwN7SGAjBLUAGr06vnjgyWXO7o39LFP2qtxevum4PQPDtB/dzP26PESZOQoA15T5N9FVP3l92H4x84AMfYGlp6c91rU3+pte6fw2igpXTJ7jz7J0sLczjKpd2J6E3ysjsiMWpCkv1HDeNGHcMKycbLC1KXrwMTizwHYkjYuht4B6/G6pH8RdrFNoj6eUka32KpEC2De6Sh0g1yeWE9EIXsdtBx30KqohhBSN9zEBg12JUKHBOH6FsV7CdLdR0BTXrQr6N2S3Ip9+N2ziCyPezoFyw7gJF6nLphQ1udGIu78a8cqXL9Ys7pIMc1xXsRBbrK1xApSVlAbqmaFQEoSvII0MU5fRGMbt7o4m9ugB3mFGbnqebZjz5pS8B8NM//dP/7D93jr+hycF3/vW7aZxb4mMXunzvXdP4aHJbooQGa0lyw/bAsrNhyLYHfO2ZjNpcwLAOsfDYfdd38OArdxJvdri29xlyCaUXIESPI298K+946zniG5ZHHnkzQrmsvhLx3Nomp4oNfuUf/QyDmXto3P9mmscO02qEHDsa8PpWwI29Cv/bv/wBdgaWbmx593e1UPkUs83TrK4lBNlRyo092hd6PP+RHLcSsHyvg1N9mBv6EufL67jVLWYePMFoeI3tqxGNUFLTltkmLJyS7LQNOy9aPr6XMxOAl0tkLLGexpcWIoGRUKlqqlUHJRV5UdJoVnBGKY16iDFgkgKdGeI0ZWAKTD/GR+FWINeK6uwMJxsuRZEQpxHWSrw8JvADkmgSNjZTa5ClJdkoIncmgSdKKLp7I6rNKq4bIJSDwiA8j3HcIR3vkSQxWZyik4zK4iJSKBaPHp0U82WGKVKKMmUsMuIoJQyrZFkMWtKYmqY/zKhML5JEfUpRI6wu0KjPIvfHx/tsesqywJQ5xuY4bojBQTjTCDKEnjyvNA7WSUHUmHhda4wZUhYjLDFeGCJVDSHUpDshJBaJdr8JcAEHW44g24OoQ7FXsPP5z9J6cBG/8RK7ahfhlJxdnCV48O8jlELPNen+2pswvecIls4jLg/xE4G9/LdRrV9FhisMLmzQ+cRTtIyheC5BHfmnWDeElXksmsEH90j8Ko/JYzz0vh/jt379M3z6i1/gcmTIhjmLi01+4H/6F3z6w88ySFOMHJKM10hMhSB3iYYv4oR1bAlFFlPEKTKT1JffQjZepxhtY/MUrMDkBTZTjHo9sjhgzqtSrVbQdoxxJdYafF/SnFtCOQ5RnNAfjklHQzxtaEy1kE6I8gMqjQrzy7PEyZi000Yai44KTGrxpGK+uUAWxUgtGaUSR2pWWg2MELRHQ4ZRjF+OqIcSPwzI0phCSPzS7NPdJiA1iksqjqbuh/SGQ5LhgCwzlLnBphndbo9q4aMCgbGCrIRhP8NxE1oVjc0ljpYoB0LPoTkVkClFw/XIhx3Gg4SsTPGCgqlKi7m6QA6GJNGAvJ+jpM/s3CLN6RrLR+bwleYuD4KapnHmGG97y1nSvYzPPb5Fv32Tbn+b9f5F8s2PM339o7z5Z84w/69P8H3fHTC+WdK+UOXpxz1OsUL667+MXjqN/+YHWPrOdzH/1qt0fuP/RC1W2Xp2nuWpOsKbxssrVP2Y5PLnaLz+A4gyhvn7cE4tgzeg/amnCN4yw95/eJbaO19HeO8DSHke8+LnsdM/irpDUm1UMU98FlFXMF2h/9nnGC2EfOl3P80fxRt0spysMHh+hfe8/h3oc2dpLDYIjyxQ9wNMP2P9eh/VCghGCXdVc3alhZZBVzxKO0PcL/niR75C2u0ypWMajZLOjfat+/23PHKErqPJ+zknmi4KMBPTScCQFZZxDNGopBjmXL5W0pxzaTuG8VSL8i1v4PTJI2S7Eat7X8b6ZyniMV7VZfHcGY4en6FoW97w0ClMAqtXU/a6Haai6zz6q59ksHAHrTeeoFKfaLlas4pF36EbObz/J9/ERs/iaJhf0kgbEnhz9Polvq2Sbo0YbUZsb5YsKEVtQaLcO3mmOMPNckBtvkn90DKjrRe4cWXMQtWnHhpWahBUHPb6gs3VjE9GEcFeTryV7RdFYEt7Ky32wAZSSrHfEJkUKUq8OjX5oJJhnxc+0dNYcUDD2RfqHtRif7lW6v+vy1pu0YW01iglJ+41+x77B1QjpTRW7IfCiYllpuN4LCzMgZi43mgVIOUMoJiM39P9e35O2e0TXf0TguPzaP8p9so2i9UYd+k4evk9CCmR1YDo0yeRc4uo4Cqy20baAXR+Fao/CcIlvvQy5Y1LeNkIc20L0foXIGYQJ49TXh2RfTEidZqsicMcf+u387Ff+2O+dmGN1a0Iqwx33X2Sb33/j/OxP7yIqCvSdIdxMiYpfWq5prP7LLMLh0hGCeNkjIhj3MBh5ey3kEebJDs3KXPL2voeo+g58kzwwz/03lvTlz/PUkrdmjYcaGD2IyUmhfr+96+2MD0Y6kgpEeq2DgC4ZWl6QP+RSuG67uQIUt6aBh1oaoqiuAUAJobr3NI6HISo/ekE6FdfN3+pJQRCwsp8ld2dmCvtlNbCDCeOL7K+FnHh0hhXRuxs9njlxQuQbrLSbLHovJ9D317ngTdq0q5PtB0T7QRUiwC18SVkcwXn1F1MrdxDsX6F7JUXwXeIbs5Sr3uYpIo6ojDhHuW2xnvdexFFCgt3oFY88p0uxXoXfdIj/uwa/jcfRS4ch/GT2N0Igncg5wWe52HPP4k8tEgx7pHeHJK4guuff54vJFtkiSUtSqan57jnnjOolTkqTR93pkaIJO7njOMSGUjctOCQb2gLy/Q0VKccSiNJxpYnH7tE3o9ZrCSYwYh+J/ozT+03BA7WVMHZRc29gU9TT5DphL9esDvKaG+n9K9mXH+5zeb5P+TOh7+PvVqN7ULgKckjRyyfefYG/a0XEStHyUceR04u8N63v4Pq8bMIG6DPKm70JIPYkBypcvr9J1jZWmT2dzvUl2M++fl/w/bKWU59zwc4WlP8wYctf/MdiuJygVNabAzPX5KcOi65sgenl1yGyQxhY4qz5wr2UsFXvxDxzcUOv/mzn+Kx84+CiqjoZYbPrVI753DP2xd4+rO7bN1MqC1J9k5oZjLLHX97iYv/fo/rF2KmHMXCkk9ZwCiBKRc8oKLAs5YyKxCpoTssWFqoMrNQx6Jp7ya0N2NC35LliqifEFvFeFxiuiXqZsTr7zuJU61TlZpyHGNGQ0xZ4qiQcRRTeAKlXRwEhUkokpRMabzAoVJv4nkNTO4xSksUXQIfZNVBmgxHa7CGwcsXaB45hg5nsKbEGokkwHccRJnT0JIyG6GEJgybeJ5hwRgG12NEEuBVp6g3pqiGNayU2CLBioA0GlEai9Qujg6weYaV4JIjpUCKSddRKpBagPL2N9UMrEUKH6k0iBpKelgkUoUo0QCqGNtHUMEWLmW0hshfBLuGnA5o/a334Y5+D7ObcDgrGBjDGtvc2f8F9PLvQS7IKiH+mZ/Aqb2V6GP/ivBEgWydQZQjhI2pLg3h7j3WvmoRFcP4U0PceoR1BxjHJz9V5RmnwXu+911svfx5rnSfZTPrUkgH4U/R/NFf4d/9/D/ElhGuL5COT2mrBAwARX3mCEpKClNQFFVUAWkmiDafJ3AdWvVl8tLSHXYprUUbRVkICDQGRWbEROi8f4N1a3U836csM2w2ompjkjynUp3D5pKcgpKY/m6b6zamGgY0tItbpoh9N6rW/GHc+iyZ2UHLHFcLJDmdTgetLZ5bZarqkpfeJAODgnrVIbGWrb0OpdfAy1OyOGIYpSSuJvQkySjBky5CFqQmx0qPVnMed2qabmd3sjlJQWYEw1jhenWKeoRfFhTRmNwk5L7CDSqk4wTXDxHpxEGsUfGpezAejKlUXBabHtop6EQSaRXSpmxf3kD7VXZXd7hy+Qrr7S1eqtfxGod56J6T3Byc5eK1aZK1Ar8boWWFf/S5H+X3P/g7HP3+RZyGy+zrljh2rsHei4cwr6QkV9dxv/rrOHjok+do/vc/y+hzn4XVzzMchNSOzVA9NE8x7rLTPUPtJNRXHkZNLUBYxdbnOPTgEun/8cfUZiukz0TgzOCdeS9i6XuwaxuIuV3KL38a77u+D2MvIfaeZeZH3k/+6DV++eoXcO7+CSphnblmk1NnTvHeR2a5umXxp10WPcFuZOj4DqfumeWFbsKfXISPPWa5f2qXxZWS+lyVLJV89QtPsXPlOdJ0A//0MQ6fuI+GbfIoHwKgIwtOtxwaWuHJCSSw1mKw9BND2i8Zdwr2dvsMNy5y5HX303Uk3RxmKoK6Z7lyrc1o5ybyyCmytuXEW46yeHIOrz6FQCEWJLtjQS4s4pjP8soClU6d5jgiXIz55Id+h8Pf8k0cvu80nhG8cB7efFqQbhf4wLAHEYJ6U9COYKEhGSUVvCXF9BKkuWZtPeeYyfjsLz7D+qUX8ZZq+LkgurLG8okWJ5arfPSjL+Ksl8wuu8y1NDUrOPbwaV549Aa91SHjborJDUVu9kMOuWX9+CoNKMbCn2723qKHHDCKDmqj/YpokhOz33H9q4sLAPYnx+pW+JkQEted0MImLjeT3J56vUISJ2RZRp5PQJbrevzWb/1bGs1ppMiAbAIIcMAqbLoH5hpWpIiZgGD2YVT+RewwYSGLseRE5hL17LOIyg9PKI6Bi3/uJ2HryxRbT6HnQISnJqGNjiJYWMcub5PtFeCMKZ7dRVabWLWOdaZIFufp+jPcceYeRtvP80r/MntlRurXCZePE77nR/jXP/cbSDejUVcUso6wAXUyhNAsHjmNIwRxq4IopiCHOLF0Lj/PbCPgzLk3kpU5u90+w3HG+mYfYyx/AWzAq4t2i711/qWyyFdbyooD7YfcBwe3aUFSyltWvAcgT4oJ8BBCUuTFaxyQDi7bsiyxZmLjOwlKm6QWo149QfvPg4AD8PCXXQJQUjAzE6BETq8XsbGe0B8Zvuvblvna1/sMrGahdoK8O8Xm2pBf/t1f4x9P/zjhvR7SV9QPtRALFfJOk3JXUOSG/MOfAreOPnUS797vJL98FcUu2fObuIfvQi+4ZE5BbFfwVgTu9J2IsIp1Nd5CiHeqSfnkKu6sS34+xXFbyMZ7QBoYj8COsS89jX7oWzF7T6LrFeTySUYvbfMfnv0i9Xf/GFVZsjzT5NiRJkcPefTG4FQUTQU7icWtOzh1h6244OI2fOkFeGB2gNvSSN9hNMy4dP4GN15+hThbY+ahe5hZPM7c1vjPPK/fEDhI22NkP8V3fbZ6Ob4rkdKwvp5w7ZktLj67zoUbe4hwhdOP/CjPyYBGxWfGpvijPusX10gdh63BDoMX93jkh97HG86+HndQIEqPnTE8d6NkdkoiPQ3e5NrqCMF9P/O3ePnfv8IxXeXlF6/w5fTfcv8/+ynavXU+cnGa3T7csQDHpwS+gS+dV0wFkt1LlrvudqGm2Mok9RY88t0+XtTh8c5HuT66jNsIcSSQD9l6LMfdrrC0BHMrLlFk2X0xwxzxSD83YKnpUrvbp2IEGsE4kbSmNDULZVQgAZlbdGmpiJLUCxjuJYhySLVaYdrzCKcUwzyjSMGvOAirMEqjgoCpepNB4VPzA8KKRlhBOhiSRQluqFhcWgarKQtDPumlo0KPwTCnpCS3OYHIcLWLyUtIU2StjvYqyLqLtSOGex1yUzAtJTZNSHNBkeZIJahNhYQuyLnoAAAgAElEQVRhDWFL+p0dZNDCSofMJEihmKn66LBCozmH51VAaqTUpPmQIKyQpi5xmqONRauCIo8ZDTqkLlQa0yg9oR4h1aQDaTLSbLx/01AIoRHCwRQZhclBgrE5pQQlcqQdY9Jnya//MRQJdjii6I/Ik4Ki0sJpZZjViF5SMgqh5qWU7asgYPz8mObbXZAgzN3U/u5PI6OvIGfuRdRaINtkN7fpP5vQceDOv1lBPBFRXLAk1lCe9NBvPcH9M++jV9YZznr88D/9Ft4vGrQLzeObEb//D36OZLiHsRlxNNGHKDSZdnA9nyJxKYSDIkVbQ04NpTXH6xqv9iBDG1CahFZljFIWU0RYmxD6DiZLSEYdHFfjupJRZEhz2FjbJotGlFkCUuK4PtpxcbSL6/soV6GEQSY52pfU602scSk1GM+nm0jsaERRlPgqx9UunqdxXZc8HtMdjbBC4SgHiabIC8bjHsoPUdrb38wcAscFNycvCnY7EZ7y8LXEuB7KKSe+8K6m39vCDev4njsZ149TdOAjXY/AQjKKKI3EKQ3pOAcBtdYMsiKI8z1sbnGlZXtzG+IRgRDEnoeJM3RcIFH0lcvifBXlJFSDiKlazrA7prN2jbK7xpevfp2lMw/wrntbBO94J9vjd/PVj62z2f5pfuGD/4S/t/w/c/L+U8gQSAWzp2dxXv+D5Be+hk0CyrbEbPZI/uD3cFstjv+9/4H8ehe1u4Msd/FPP8Tx5mH09i+hzt4DscS0C4o4IcpHhI+cZPSrX6H+3WcRCzMUWQVV9RHHj5F/RaHPPUD6xGeRK1Wcux9BTJ1h7lvv5u7f2ObU+86xq6tU3IBTMzU+emHMcN1w+myTr0QlaGhWFBGC+abH6bcrQg1fv+jxlYsdei90qC9GDLYuEjYWuPPQnSyuzNOYapIMu7fu99kwQxcGhGJUliglkFi6vYLdy32uXu/RHhq8Rp2lsw9wRTg0PM20ynCSiGF/QKoE7c4e3c6Ad//QtzHjV1BGY41kmAlu7lmm6wLjTMAHjiTTFQ79jQfZ+lKbO6uWq5+/iI7GvO6db6I7GvPMZsDuCM7MC0IxoTRd3RSEjmS4azh21KEQHgYIQsuRqkCbkg+/+Jv0c1hgEZeScrzNjS/GuK+b5U33VEnLkv4oZWN1YhWtrvZYqQY8cekGnXaEKSeUjNd4vuxXO2ZfVTlxZxGTxNv9oseK21oEYJ/PvX+MWwLSW2ODb2Qr/m96CcGr/PBve+Ef0Fu0loRhiNaaJEnJspyyKPF9l3/+z3+O/+V//R9ZXGghRAEmwRa7mN5jCCuwUReTDimtwDrTyMBg2zuMnQzXBaN2sfFFaFqyjZzwPj3pjB+9D3nkCJgdRLACrgYGFGvbpNt9sorL1APLFNc3Mddycr+EY1P4S69j3r+f1ARkNcX7f+JHyI1kJ4evX23zqQ99km63TWlitrdzHBSecgl8j0qtijPySKRLxY7QwkM4dRqBy6lqQGvlISLlcO/paQ6vNKhUPMLARyn5Xz7B/y/LGHOrmw/s5xMw0b3dSuDe1wCYEiknJg4HoP8gi2JioX77uAfFv5SWojQoKdFa3z6WNRNNAexTlGCiZTgQ7JtX/ZW3J2mvTQz/y133E23y5HhKgesqQl8w6iX0Vtd4otvm2NmTLE/XGZd1VldTOt2bbLRf4JO/9nt8xz/5XvwZj0nanUTN1ZBzd2H2NrFzb8W2c0hTzJWrSEdTu/8c5VofOdhDVBbxjh/Dma4ju19AHD4GEdheSZkVGGHQp5tkH38F/7uOY10faxyELydGMzcV8sgpiuceRx6eQzYWEU6D+p1z3HV6xPG3zbAZWZaqAY7SPL+Vkw7h8JLixagk9AQVZ5Lp0Kpolk5J3DvhlZuCjdUxJRFKDxm2N2jNL3DHkRPML87g+S6FzP/Mc/sNgYNDU1VsJLh4ocexlQqOcPjKs2NefmGNjZfWGOWK1t13s3hiini6xvEGaGWpFgU207yyZbH9G6yPOxw58x6a8ycJZ2ao1Sy4Lr3Y0myAKwUinnCMjQ+50Zz3Zjjx7YrHbj5Hd+0as1cTfuWX/hWP/PW/wwsff5nw+DLbW4qyazmy7FPrRCwfa2ETS3vVstOw+POSWW2pOILkc79I1HuFshxTpiWjUYl/RLO0UxK3M0wB2oGKtYQVhYks3dWcuaaPtIqyANcKKkYyJT2coiBXoBA4UiC0InQFjYZPPDSYJGdUxLgBePU6jXSMI8GrelilKazCKJdWK2TcbVOMXDJPok1BaQUUJRVH4ihJPBpS5iVgUdIgXYegXsWMh5RY0qJAZAmitEgryTKDFBM9Q6WmJpapxqK9gLxIsCVoR+F5Po4OKMuCoiwRwqXIcqwZY8ocUWZUwiqt5gzKq5ClOYPBmHolxHE8bFmipAYmwmOlPUw54ZBbHFSW4wmN2rc4046LsgYhXJByX3MgsRQAFLZA2Zws6ZGnbex4DbVzHbt1heDwNhQFyBLpl8jMUqwmDG5YnFGGKi3dEnp9w9LWALfzD/GP/H10o4W1guxam8FXn2TqEYGoShA3yB7/BJufeZSbV0pa9ckNMa1LrrdLxJxkOy545uO73H3HJoO9r/Hc1S1mD72etLnMwG1xKFjhB956gg8/ucmwM8IWY5QtcMQk+KcoMywFjtNA2QApwHE9HJmiKmfI5BRpNskrqIULeLqgMEOsTWlWNU6gsdpSlCll4SLJSYdjpC3BKoT2cX1FfaqKH1bRvkewb2U6Go2oeD55DmMjEE6A8jRSa8bjnE77GvOtOn4gsEIhtMJ1wCYTD2yT5ijPTqhAaUmZlISqRGOhzMFKtPSpBg5xNIDQwwiFyXPS1BDFBUmcUp8OkXaKtDekiHKsAVd4hJUQAOm4DMuYJFP4UlNT3sQ+LytI4onxgVQWUxaY0uAqn6AyRZwkKEdRrToErkMpcgJV0prxODQ9y+GZmM3FlI3xNN11OH9pj8svfpmdm9N4YYPENkjMNBKH890X+Njv/DbfPnqEc284jul0EcYjz9ZxFpaw0RgtIowose0xIr4XrVvolRpyZgVhG5jcpXzsaYaDPv76H+HXH4AMev1VXso6PPDQOWy8Q/zoH+M/8g7cu+7GZorogiI8O4dsuVi7hVl9hWy3jfPwPGavyoX2BqMP/x5nHngbeuoIj7+0x8am5cR9x7jSHtNqOkxVNa6AZGgR0lJ1DLu5ZOFQSLMuuPlyn89++P8ii0fMHz3DsUVDlnTp3uzhqdubxUzFY9gvyJShUdUII7mxmbN2rUt3tUtRqTB9qk6t5VPUXRb8STMnLCTjsaTXyymHu1wbdDn9xrcT1pt4votGglQkEirhpJOuMhByonvKhWLDrzJ/n+TTTz5HEG2y90KHJ2TCuYceZOPpXWonW2xuGmbqktATBKWl2fIxuaSzZSirkkoFQmlxRUF54fcZjm8gZZ1oIFFTDuGKz2E/Z7wXUQUca2mhqPuCvJR0biZUhyX9dkw8zjCFRTKZdpl9StGtZe0tACAAa8wk1X6f4nHQrZ3UMAe0jsn35hb3Y38y81eYVnSwzL5LjZJqwmMXB/aWkmq1coue4u17/EdRQqUa8PLLl/nZf/mLVKsujiqYq1s+8G11nJmJoQW6QJgCEUMxGJBai0pTlIJOZsmHKcFwFb/1m+ipH0SFClNaius7lNEG7gkP4SqgQ/HCB+mcf468mxJOaww5ZRDQ3hjjnnW4vjVivLPDwswe6WiHV66usXjyTXTcKtJrcEetgfPmQ3zS32Vrc4AsugRAqCcBXGmRYMkJ3Vmcoop2PdzQJXQtyj9BL/UYlxG7ewnLSzMsL83i6EmH/i/WSd+fANyaEEymBUopDOxfmAci4UmYmxDmtije2ltA4UAwz8HP+0DAWkNpmBij/CldzYGd6URnMPkqD6hLxrwGVN/S3Ij9vIP/iksIcB1BreZjygbd6SHtbspXH3sWCCmsQ5T6oD2kdLi48zKHP/IYr/vWu6k0PMgKEAqT9pHNOiQptiUgsdgCRN5ECg8x10I2mlhZw2wmmCdvksUj9KWn0fN3YIcDBr0usVuycNccJF3yR5/Beed9iIqPiSSmo9CLVagoRLqDuXoRO4wQi+fI+iXPre6Sf+LznHzLg/RiS7tXEKeKxaMN1ocZU6Gi6gkowaQgPQikpV/CwrxLI4DLFze48NTzGGFZOXqYw/MF3W4H6znYNP4zz+c3BA6K1Zco5w8jwkVkHvDFJ/o8+uhFdgeKqak6c8emmTp9jKOLmnZmOVG17OykjPZKeuspV1e7DHY3UPVZ/EPnELqFUA7enEOBxpaGWm4xKSS5JStAuQJfK9olVM5OI2d8HAdq+ZC980+y903vZiHsIG2dceISFZbtJOPIVMHO2OVEJSAdCaLCYgQoUdB96cv8/kf+I71OlyktcMOUOFRkQ8PxWckw0wzGBptD6INNCxSCxVLijgVZZhFI6r67777jo7Mxmgk/HjNR7EtX4yhQgUOcWJIspxAKf1oRGofALdCBQykVVjm4QYA1EXGnT+qGiFpI4Cq0MxHlugrS4YDRKEY77r6wy4ApyVDkxuAaQZmXlKog8ILJBzMzKCUndpLaR1WqZGlGWgqELXBcH9cNcPcL/Kg7xEoDxmJJMPnETQgDjcYs1cYUxljS0pIkKQAVd2JDKrB4rovr+CihKQsmNA89CXWbuO1orBVYXKzUIHOkVCjp7vMmU4zJEEiQAkuCtZIsz+luXuXCF1/i3nslzYrB9UH5Eqel0UkBxiBCj/AE1GxOEll2Xshonvsj1KFD2PQYwjmGDrvo4DKoJhR/Qv7SBqOvPEqyfQM5LRADSzKyJFNVbmZjaq5DOxN87csdVq88hWN2uHB5ndpMjyicJnZaHJ8+x7EjR/j+lQbRKGM4jiiyAtcKHJFTFhGlGSOokmWaNCmxZPgulNEh+r2cuuOgvABZqeL5BmtdlMzxXChFQVZkyHJflG7BFgXScUFqhC1xPZcgCGjWHNAO0kLBZGQvpSA3Lt1hihO6hEoRCAumIBtGyFqADlzSLKckRgofpTRBaSHPKITBIjFliREOCI0AXCGQQmGZ6AgcGYAnKKwgyQuyPCdL0/0AvGwiaC0leVaghML1PBzXBSTD1GBUCNJgpaUQ7gRMZgVFUmLtxCygLDMcYYnjgiQfk+9vVq6rcTyB70qEyQg8Q813qYqAqltlOtOMFmcYdJ7k0s4Wq7s9cuNghIeqnuG/+66/RrWWsVw4bF27iOisciTQqDBA5gWIBrJIEVKiF2ewjTrszmIuvIwO5pGzhzB5nezZLeKLj9M1KfMDzU3n66T5Jja5iSczslaGv1wlv/QCRaVEhyX67ofQLYVu+Qwvd3BqOeWgQ7m2h7yrzeArN9nqX2f01Sscaq7gzlrWNyKOHj5L0zdIV3G4KvG1IEssIrP4CpIIehIW6pKVRoCfOHx09Rp5vYETlkRJjywBz5+i3mzcut+XWzewqoKo1kkTyeXNlBcu7DAuHGZaFVorUzTmatRCwdhY5l3o9EtGY0u7nbGxM2LY6+E0WwQrh7E4SHdSOJVWgrAEE+MZsnKf+6xBCUFkBf6hCrYiCcfgJT2StesMO6dpBjHKZIxzS5QKlCuo+5Z+JlnwNMlYUBwU2GXCaPsy//Fjn0ElA+ZnoKx45HgU44Kj8w7DxKfXz6gEEi0LdAmBlhRjw9qlPeJxTpHbfevHCTfitr8LtyqeVxd01rzmgVcBgtscpH26/cT/XfxpF/q/uktwOw361u+EQDsO1WqFWq1KluVkWY6UEiUPzo/gwQfvQ0rB1atXiIa75MuSly64nDih8f0M6UqE9pChiywLKAuE18Q7kuPuRJhhSby2hzf9GLKxgMkOI50lpNvD5rsgKhPzjo1XyK5+EWO7iKqY5GxmkIfzdMY3aflV9jZyrm9usFa/gCf7XHr5EnsDwa6sot1ZFpvzHDu5xHfM+7TbCXkywDMWT0qksGRFihAZvtMiTyaaFO1aAldRpjP0+zELFYeK1mghcfY1Gv/JtfLnOO/AgTXRrWvJWjvhu8Etq91XTwom+UMHnf99cxJew3zbNym9/S7W7FOXJg/emjQcWNhaDjQNk1e+yhzptrD54PH/D6x7HUejtAKhWD40gzU7rK9vsbPbJ04KcKtU61O8810PUNURQVXRuXGTsuFTCVyE50KSIhwBeTEBlF4dUUhs18eu7SCdJqI1hdmSlBfWyV+8QFJk1MaavesvI6INinyAaniUrRS9VKE8fwHTtMj7Xo9sLkKoEKElWx+hG5ay00bqKqIyILk2YmP7JvIrkuMn7qSXaaJMMzMzTdU1WKmY8/YpYKXFWNAC8twSCcFcIJj2XdpXcuKdPcpWneXQMB4PyApFrVrF3xe//5fWNwQO+i89i3P0ELNnmuxdWeeD//eYQecKs3fcy7G3HeP4mQZCC2aBeQTpRkzv5R6Xr22zunqDrdVLtIcZp4+/kaxaJ0ksRWwopiVCgUZg+pYEwUhDqsFzBTUH5iSMtaTZnCOsTVMUfR4+ssjHfv+L/OD33EHejWg6hqFnWO+k3H3M4U82JCtLilYjIPAhSwpsktC7/hT/+6N7yDTncE1RnYLeomb43Ah5WjDVchiOS0orKLFEezmtmuBY4BJllrhUhL5Po+pjpYvVDsrEeM6+yLIwFMYglEMSGwLtTew9jQVhIE+RhcALJsenNHgaqoFmfX2beJCgay5+YAk8hec6OIGPqxNGoxFpJpCeh3XdSbBWVjBMM4qipCYkWkw2WD+sUuwX1o6YfEyt9BBKUxZDOr2IeuASuNX94lGRRxHDvS5eqNHKIDETF6NSIKRHtdJCag/KAldAZmA0jtFm4mOppMRVPo7SUFpMWuA7Hk5QRSiQMkBIDbYEK7GyDnKMUg5KOvvdNQUUaOljhMX1a2hnBiGbRM02zxWWleurEA6RqoRQ4S5J9LxD0NQI41OrRhzyxxTPpuw9X7J1IqY6/Hd44R240w/jzMzgfCvYfJ2y8zV6n3yZvRspRVXQnIX0Wcj1NOXyPKPpa7g1j0q9yVzL56mbm1ScDNGsszPeYdzeYZwGrNoN+g/fxwf+2r14tSoRFeLMxWYGR48Q2RBFjzLN6Y1KuoOYPOoR+g36V1M6Wx3mvDmsU2Ubu++K5SFFRlak9Ppd8jjDsQJFPtlMpEBqhUAgrUYrD1e6NBxLbAuKQiClQ60Z4vqCTLmMowTPGjxhUYFH1VE4YYWGowmUZG84Ymgtwkwx02hQLSc6hiy/7W7huhPgkOfgaokVkjQvSdIMp5TkZkIpmGDXAmFKKp5HNIonYkQm4EJqieO4aOlgtUuRZ+ighrIKVeZkaBwlyAsQyptkd5Qp5BbtWLq9Hr14b6KB8T2EC0JLmk4dsoiot4sRYNIxpsio5gn+4jHuOVHDDwOutS2745RSGY4dS/jH/+DHCRY0eWeLp/7oC1z9+ivMn1rGcbdwnTvIrw+Qnodu1RH1KUQwhd25gnnueezCm4EC09kje/xZsvQKVs4RNu7npe1PMcgvMR9o7nI88u6L+KeWKV/pkT3+SaST4D14L9WHA5Kvdml/5mtM39dGOCF2uoG1JeP1a9zZ0rQjTbs9oCZ2Wax4vPW+Q3QGA+ZmfCpSMBwV5LGlqjWVfaefKV8iSoN0YLoZsrRyhsu710n7a2zLnGp1nqnmHKp2e7OIbr7CoaVl3NJhZ3XMo+cLertt5k6f5PAbGlRrCi0FIdAAsm7BcCNifafLzvYee+09+rHl9J3niFyHIp1sYEZPChAhBTa2ZAhiNfnYu2rC+KgLSKTg8OIc4/EG1apgZbrCC09f45u/aYG0Oynmu5SMcstUVbE3EMxOSWo1NckuyA2FjRjsrvJLH7nCIZWwHDpkC5aeA2YtRt6pmGr57HQhCBVpaihGKY2Ky5LQPL3WpchLDrzYDwoZKeV+ASxAHJROr0qnfU29c9v69EA0Ovmt4ECkeyAOPQAMf3XXPu+9LCf3ciEm+wcTi9MwrOA4Dp1OjzRNb3nt+77HmSOn+cAP/w2aU3U+/8dfYmPtEocWBKvRBku724hwNOlaByGqJlCNEOX5SGoESuO8uEW5ExFdGaNqO3gLv432H0DU7kMvpVAWWLMJ0Rrxs58h6uboeRcbQDnUlGoJ2zhC0hhh/GlqQYAwiovr21RDi2jW2GivMkwchskOq0GHu994lDedO0rwhgqlCDClAlMi5MTyWRNR5oZhbEiTBGyB71QYbqX0dwcstWaoLDSZngonmjz5FwMGr3nNn3I5Mq8CswdThYPr7GBq8Or/3a3pwf4LLK+97g+OdTAlePXzb00g5O20ZsEkAE/YW+9yG4RYMRkZ/lcECAKB1BqJxTPQaFVQNEjijGg0IEpzlM5YXtb84Hc/glOVlKMBV598kfEgxQ/qSJkjvRqmlyC0AxUP4fgIqyDfw15dg+kqOAbzcpfy/DXM4Caoedz5U/Se+ATa69NoKGquwgzW0Estynib4nM3kK0A/c1zyLqkWEuJnr5M7f4IG0xj/Qa2yDH9DsdmBHHusNceYbXDYqvJySM14jSj3nRwsQxjA0bguRJHQVEIqo6gLC2BC61GnbnZBa6NuqTDNjs2pVFfwA0boMM/83x+Q+DgzjffxaGTR7n+/HU+/mufYHXxzXzP3/kWHrprcdJ1tuBjsVHJsJPwiQ9tE28/w9r2k6z2roLfogiWOHLmAVaTiGivT7cRQs1jZV5BKSmEJLbgNAXas0QZDKVlaTOhoySjKc1ay7I+dHn7236QuY9+mhvbSwT1nGmpaNicNI94+WXBO+5dYdhTdHNIkxKzm5JkMUe+8+9S+6kPUnTb9AuLk8OJiqR/MuDq1Qjtx0gUCEEcWbTvs7YJpglHA8nRuSa1VpVqKIkSi0VSeiGuJ5BpilOUOBWfsNZgNEiJc4jSAuU71Bo+jGMy5aL9CkG1jkZQljndTp88LUgsuEVClrkY38VRHvVqDemGTDc1ql8QpwVRnlEoyXicoW2GF/iEoUu1OuEtRuMeympqzSpkKb3+mNykBJUqviu4cW2HwncRwxhmpvGbTbTr4lc8lM1wHY8ySxDG4kiPXDt0+zEzbmUiaNISbQ2+KlFKEXU6ONUQmyaUmYvrupRW4Nen0ZU6BoHS/iRdOe1jigTpCJSuoJWLFGBsgTECKQO008II51a3wwtO8oZvfguvf7ikGP0UNz7zOC98YpebL6Q05zLufq/PkUM1gsNTNI/72JGgc6Mg3Cv5w3+TcGYm5+4fe4WGWsXmU4jqAmXZprhwjavPJGwWljKTNFM4tuTg3fE2lH8M940fIxZw6Oz9/Pj3v4Nf+INneOojj3Pf972V4uZVemttdndytm+0eeJTH+ULH/5tls8d5ZvufxuLc6doJ4Js3qcsGjx44g5m5A200yGcCpB6Hj3ULNT6TD9whnrps7M74Fq7w8rCFG0TstvZJrMeSTxgWMSUGJpViZVVRr0+ZCWuH+B5Aa4WtFpN8ixinEc4bjgJHxOWqbqkwDJ0/P+HujcPsiy76zs/59x77vLu21/uS+17Ve/Vq3pRq7sHgQRCSICGZTwwngAiDMPM2DETMQ6DHEEYxmgcHhxj48AeZDACCyOhBalBSOqW1K3eu6u6a6/KzKrMyqzMfPn2d/dz5o+XWVWtgBC25YngREZk5rv33e2d++5v+S4opbCNja0V9aqPUYb52THSJKO3sYEO+9jKIqhNYhddktxgY9BY5EaiSCDKkLlGWII0H/l1KJ3S63QI8xjHsklTjUkFrrSoF8BzPFqDGOl5eN6Ik2WwsFA0+xmOIzG+wPbL2OToJCHOIDU5tiogbPDcHEfZ+LZN2+7i+ZJ00KWfF0kyHyeFejBEEXL9rcukQ8jyCG1CdKR5/eoSH3z6vdz38HHObfhc6lgEkz6/+vNjWPboQaXK+3j8F/aio5hko0nn9Fn0lkYWp0YP1DwnW+rD5RuYb38BNTGH/eAxWPOQZ76J6n8SK/c5WLwX1RhyT1ZC1j+Et+c9mPYyeef32fzSX5BmIVY+RC8uoL/1GtYPPsyNr51n6+w7BE6N8hMnkXcfBa9A9amMf6Y+yGfPdzkr55DjR3n0+H6SjT77pGHrUhfRsEgzg8htrLEy/U7KvoaDm2guG0MkBFNT0zz6sb/H5V//ScS1jPmTd6Bzh7Wzl3lrdePm9/3siSP4boGrr1zhrTdXWZnex/f/yGGOTJXItMQSI9NGnWjCYcYr3+xjugucWz5NK43RbglZnGB2314WhwPirsvAs8C28F0QWpAjSAC3BBmQakMClLsZfVuQzisuLA2Jqg3mjt1D7a3LbHRquAWNgyEwGWmY000sjs2WGA4E2BANMuJ8gCxoyocfoVAuQ55zowvTqWD/pMfQLnPlYgtV2MTNXJIsJUcTJ4rWpmbPVIGpcpGry23gFkTCsiyyLBspypjtogvbVdabcqXbqjDi9oRB3NxOrkeeLlLcIoaKm+v87U0PdqBSIwLr6Dx2YCNpmtFqtZFS0O8PSJIRhM11FY1Gg9/+7d/Csh2MMPzQhz4KCAwaY3JM8vs0T32epa+skvQ7lOY9Ju4Zp1adRNQn8CdthusJepCRtSLe+fQq01M9Zj7yGogLSHcGYZXQ6Tp69TTNs316gY1lOxSFojwxjj32AaQ1ibyjSeTPcejxBxh/dJxvnb7KOy+e4cEPPsNw4SytrYjVaxGry9f48hcu8x//sMV9Txzj8TsfQlhFQmmRBTbGeBwdnyAQ62DFFMoOEmukTrfP5cjReVQiSG2J54x8A/5LPnuxTTLe+RxG116PKvuW3ElFb843W9lIIRDG3Ex0dwL3fNuIVN/kLewQGUaB/2gf4jbn4+39f2fXw4hbMLl3ofB2ZIB3iPjfw57ZdgvOAEmS0m512XNgL9XaPGPzORvRCHJz72HnVifDaXDoBx7DJBn5YEjW6eUmB5wAACAASURBVEIiwfYRgYMJY8yNIaz34fIlZKGMODYFF2Pk8pvI5pvIuEJ97zHERMie+Tr2XU9g1WqY/g109xXCz3yNPB9gJVuYpauwuoGebDB4Z4Ph2QUK4zOoO05CvYo2ULtrin9QfIqXLw65Jirs2TPFRLUAg5SGgMFGjCgLdGiQSgGCNDHUfImdwXXLUJSC2X27OfaIZPGP/h3iWs6u+48wbGcsvbPExdOL3/Vy/o2Sg7OfepuFP3iH569fYyHYy8f+ySN8+PAYl4earbWQreWEpbfanH7+PBvXP0kvBSG72K6N5fgonfCRH3qM9kCzW9VZC2oMjcfBlkE5GWVPoXwYqwmuh9CLDdMmZ2Uj4+XnzvHUB2YolxympybJlGQRj8He+wn7PcbECptuCbs+xh17DtLsdVl+O2Zut4dlMrxhBElI09JMWy5nz36e87/2y3ziC6d49mpEHLX4uZ85xO9/7gbzT54YOdhtJkRDj8uVOuniKhcunqNc90jCDmFzQF4tkEkHy5N4roUqekRaEMfgqBG+mzxn0B+SZoZMGywrZq5aI6iVKJYqBNWAbmuLzfUu/Uhw/NgBBtMxG1sxlrSwAExOnkRYRqBVlXJpwKDfZhDGePUixVoVaSksk4PWZJlG2j6eZeO6BVLho4IC436OJS1yYbF+Y4PJsTEKJicaJpjWgEw4KFeBKgEDBjE4bhlHQpzliAyE8kkijetZmO0HnzQWWRhiqQDXKaCTAbYwI2Jr1UILG50OQVgjnX2dkid9glIDJQS2NcL+GSQIsG2JbRcY1dZyMh2PlIwYlRcNEW7hF5m8I2Fl7QV6TpvDuySz0x5eYx/e1CPId75JdayL/z/PEjUH7P+TLumZjH/7K13q9T77Z1tUSwtcPJUyBtSrsH9a4t6pcO8q4Kgx+vEhwoUL/NGfp9zoKp542uXn75nnl37c4YXaFN8eHkbNH+SBO5scrCZ4rZR//KkLXD37bbau3uAzS3/A0akaP3TPCcbknUSH9vDaSotJf5ITu45wuOqysdZmqZJQPbBOuJFB3+BOlpgteVy9vkUnSUl7LXIdkUcxQrq4VoYlDXE8gCwmR6AchfJG3he9doQmJ9cOUmssHSMcRb+dUixG1LwClUqAxCaPM/rdLvNTYyRpTjrsU7QdHKcMiSJPcvxqQEMqBp0tBmFEnBkSy8JxXCyGmEyQa0nYG9JrbZGbCK/cQBibbmsTYyAo+EhPIbViSoJwGwyinGgwJA9DsqSHbfmkfcFkuYAtcvIkJkpgo5cQaigEGQ5QUDaB5aGymJlajdW1TYZG0W91wQqpVKosLzXJNBRMRpbk9IYpcZQR2BG7rBaFrS1eXWwzd7TCz/xAjYPHXayhJrvYoXe1hz/l40w5yGDUGRk7MU34xhqDzhDLlWSvfpPoz/4Ut9Cgse8B3L/3w3C9jl7oYq5GqCxlzJ1DVR6E62cIPv4xxBOHQIHp7qH/C2W2Bj9FkQgpMvLzZ4k++W/x7ziEfPtfU60dxNt9HG0aDJ6/ROvrX+Hy2gUmHj7Bj/7UT7DFJO+suLx1JmSyWObEQzAmYXWhQy0QFMYU6+mA9YUWnXgcAhdbGGxL0PXB1HyUmiZKMuLz30ILB52XULeppCx/8RJvrH6TN7YyBnuO8IM/MM/djQKrYU4U5rTXU65fGXLlzCo3rn2b9QRc1cYtBQjLZqxq8d5H9jOMDbuDgGXXI8wtJsIRptm1BZYNRQMbCVi5wcsNnX7GpUtN7j5ZpVjx2D0/S7lUoaV8wundpIOYCm02bI9atUSt4BDFGZ3rmsqYDTrHC0OurS1wxTR55un38KXn/pjVP/w/+PXPXeH0Wze4I5c8+J6D/PHlM5x433/D+dffppi5xOUxepbL1pVFeovLXL7aIo1TPDWq+IdxhjYaR9mjhCDX6B2IxvbYIYKybWh2u2vtLVjSKAiTQm6TIG+Lkf725gbvGjc19LdPLM9zBoMheZ6jt5Vt6rUaTz75Xv7pP/0NdkBVOSk3A1W2lZycD1PavYZ34mUKSZfGmEe50sAKTmCV7kNf+RSFQ7Pkx+eIWy3GTq+SXhzwl795ltk9AbXJS5hM013sE6Dx6w6Tkzb24RpWbQKpDpBkU6TNFf706zbFmuG973M4cmyc95/0Od6Y4J1kmmC2xKFjMXUrZ2sz5E9fus65Uy9x9ewKv3P63/P08T3cd/AAvpgnHqtyrjVk0q2ze6yAbTT9MKFv5xQKA8KBodSoUPFcbEf9FQKf/2lDbycC3CQC76gQjWDQN4cx287cI36LfFdScZuXwfZ7jeGmK/Lo7aOdvGvO39adkDuE6u1jEdpgCXmThwJmO4nY6R5878F00rbAQFAKOHh8LwCXznSZ3lvi2ISN7wGRRndSsjjHDiykLxFobGVh1QrkzYgszZFpQvrsn6MXl7Gr43i7D2I9fRfcsDALGm7E2EjU2DxyfD9cWcT9Jx+EMW/0ga5WST9dIFz9S1xHg4jJv/EqQhQR738EcekrFGZ3I6f2kEcu6SsXGVw6S6+zQnD3MR754Hvpxi5X1i1W1jT1QDGxC4pA60bIZNUmtzX9NCbsJkSVAigLNzcYW5BYAnwPz5kkDHOSiy+QpCWECVDyeyRl+icLTVwb1FSdp37yF3goHPKJ//P30OtXWV65QrvbxsKiNWziScMdB+boWVNkJZ+5vTM8c/9jXHjlbb59MePBOx+lc6rFhXTA2f3jPPNAkUPTCf5Qkg8EJWnQcc71tYgT1ZwF/zpjpQkGV16hUveZeurv8qfPLvD+x48wc/cYS689j19wsIsNXl/S7PbrzBwpcEY6TKmM3XVFxYS0Ll2mX1qjOvkA+07eyfzrN6hcXqK9FvGJf3YeNTtO8z+8htAa5UqEJemFDrWjd/GDf+cHWXzuDfqtTbIsIjeCYsmi5kkqvk2UZBhtkMomy6G7OaCfpji+S1GNvA/yHDZWt3BLZaJ+SJ6lCGMx3pij4RRxpM3q9XU8JUcVftfGaBgMM1IlGQtykgyqlTJeOSdTkqBQot2Lub58lcrEDBPFcYqFGlae0m+1yE2Pcq1BotRITkyn2NJGug3isEOaavQgx1gxdmAoFMrEEUR6gM4EOo0Jh31EUEJKG+HY2I53SwpNlRDZkLDbRGiFrWpIqdE6w1YujlMgzyykVKRao02CkYoYFxuJZRfJ8hQhFEoVtknNAk1GlnVpNd+gP2wRmxrr61vcd+dJ/vU//Ed0xzo89OBj/MiPzSJERKH4MMrSDL/wG+Ct4467yCDAqj/Iyf9tEdNcYenzHS6+lvDS2ZzNgWFcCg7MWsxZkmNPHaZ4Yhbh7SZtPMNrrzzPb/z6O2y0Mhpz07x+rc2v/NYn+dkPPsDcsTv4wYUNlkSN0ys5L19o8t4ndvG7v3aCl1o/yyf/6AssvPYOF9Y7/KsXz1GbX+Pj1mkKB3+cwtgURTsgN4p9d5a5zzFcaU2w5g1pKElVSPrDDHm9xdXzl9CySHO9jWtiagUbyy8AEX2dkLkOnqNwPIVlMlyZEmWGPE9wbI8sHcnZeZ7EcctINEIFVMs1xoo+jpBEJqMohshtaOrY1Cx+sYRQilRaRMOIXntAhsGyFb5tkNLCsSW5KJMm8cg9VLn4lQZOHmPcIp1Wh4rvkCQZJtJok4GQRIOMLBoiLBdvex5ZwqYfgudahL2IVGe4jkWtUqHTaRJZFk6tzkTRpuxY2FoTb23RWrnGdLVMK1LEcYckisHuEKoCuSxQbExiJxHTJU3FiqmqdcZUA1mp8NqFVzFBHzW/Dyo+/dNt9PAatmOIX+nR3WyS9LsYNNKxsfbupjRW4OLnv8TqW0vY8iCHowkEexC7dqF//zzm5W9jWmfBOont/TRkEkQR84//DD58GfGjT8OKxD0yxvTp48ioCbqDNhGDxQs0/8dfpDdsYSYO8sXf/x3KpBRtj6/3rvDlwYD//f6H2Xf9ImO7C9x3sMhsQ9DZ6vOZrxv27VOUvQJJBu3VDF/F7D0xwY3VIYHU1EWOb4Bc8vRBh6Of+DW++Rfforn1NuvXrpD1O5QC9+b3/adf3UTKJhP3HuWBpx9hdhjx2ZfOYDVvcObSpZG0p85oR21KtuSxu/bQZA5ZVRzaPcee2jir1zZ4YVnzxLEj3DjVY6HkMjHjcWJW0QhynESQJ4KiZRiEOXGcM2VnbLo9Aq9C851XmTtxgoE1wZsLIfcemaQ2V2D1wlkq5RpD4xD1JGXbpzhhc11ajFk55SmHw6UZwp5i8/qbTEwfoXbkIXZ9aQ3THbD48nWuXghR++d489NfGwVMZUVveZXl6z0uXluh4kt0Lnn0xD5Wtrpc22gjxK2KapZvEzC/I7a53TzqliPyrcBKCDEynmQEI9H5Tb2imxKUf1vH7UVgS1rbVefR/2mWkaXZDiSeJ594kh/7sR/jqaeeQohRXzI3Awa9K+RGkWQWWZoxVhvnG//xX5Lvktz5wN+hVvSQ0sZWuxAC0lP/CFkR4NURzl5k8ACF2euYxxa4+tI1Lp8d0Hx1SBwaGp7L1JxDQyqmT74PUZoAdw+RnGb56hU++e/P0Oor9s9N8PKVZdaiHvfs3011aoYHN7usWVVevbpBqWhxYr7B/7RvL9c+9CR/9LWXuPr6FV68MuBM5zzzu1b5Ua7gTj2CH3iI3ML2HaYqPkoa2nFAX2VIzyHTYDKDrf7LkoORBOktNaAR2V0jpHVTLUpvh/xS3EYs2OERMCIci9um3+2J7c76I57BLY6CuA1qdFOy9yan4RY5+q+DSv3X4BzswKWkECP5IgGNiQjZAxG4mNCQbYaYfICwDNl6St7vo5NktAFPIWtlVKDYeP4VMivAqRwj2LJgugLVCnxqBXP+LPRyhHcSWb4LEgFCwW9+Az52AvZMwkBg7ylRmr8PEfcx2Tomy4lfeZ3swhJp3MfM7+X1T3yCieouulmHs5sXuRBH/PidJ6m3V6nUd3FwVjEcGoaDlDfPGaamJJ7v0glBkuO6Bm/Cp99P8YShjMYKBTVbcP/BGgd/6aOcf2eBTm+B1YuLBK7BV9l3vZZ/o+RgK7zAsUce5b7v/xATY0W+/G/+He2tVTop+EGJ6WCGga6z/846+6YGLJ/qQqfDeH0/dx14gN1TE/zOS39GO6syvb9IueCQLGS0lzss1ge8fTphryc4sbdCo+5St1KGokn09hZee5ledz/BoQMsnl2k++ZLfOSHH2at22blTIycOUilHFDzFJbwmPIDzm3A1GTGpJVStAYUnQT/yDS/8Q9+Gzf6NMfSPv5yyvtLPrYNz3VToutNcpOhpYTMYsK1eSSwCNYu8ND+DzNfOM6VN87Rvt7EBRpWjhjmFOoNkjDEMhJb2RhtWGpGlGsBY7WAUtEjCjM67RC/XCRJIE4ixIARSavs4hRdlK+olH0y5aGUwCQRURwicejmktzyqJY9vJKLThLCrRYrSxcQxRIVT1LxXZTQpHEPKQ3+2Bjt5Q0uv/gKtV0z1GdncF2foFQlR5MNbaRdwq+WKTbKICR5MkDj4tgp+TAhDBPCFIxJKNLGeD5JnGHyFAzYro/rFLEKI5UPrTOEyHFcgbKKSMsli/poKTBGIFBYtoVtOeRCkRuNtEZuu1IqECODrzAfsra1gE4ktjNDURUwecIXP/UfOPmjP8HYRINatYjlO0gJWpZpf+6X6Fxp4t5hY/sFdOKQ6R6bsWFi5v1830+3iT7co9dzabUnsbe+TT7zOFawF7tRQQcB3e6AP//jT3PqYhnvwe/jxw9Ok0ZNUpHTGJ/ij7/4Ek8/WmDXkSqNNGVqYpIra0Xe/uoC7VqZB49u8PGf/X6ef/wxnnvuVS4//xyrlyN+s3ORJxeepXzkA7iHDzBWdqkLC9eRTFfKVHyfQBp8Ab6fEQ1jnAMzbLkJmU6Qbp/MaCwXBrFD3o8IGmWkUgg5ggx1e0P8UgHf8vGKHgI9UpBRNmNFmzBOGSv7lAoujuvhWja2TOmttXGFPXKcNoLUSLTx6fbCkRyr72FJiyRPMFmMb9mQ29jk2I5DHGaQaSQCxzH0uj1820YLnyyOiQZD0m4Pu+CzvrKKcEvUJ6bxgiJGK7J+TBLl2ER0wgQhRpLAYSYolCu45LhRiiFHVAs4rkdPKtJqnXrgY3e7lKvThKlhOIgp+lVsp0QWZ+SpoFD0mKrXaXhz+G4Bp1jnQ0/XGT8+T2O+OPJ2OLkLE9axCkCU4EcxejhAd7uINCfrdohefIP5apn64X10zqUMug3S86+g/vkUYjHEmBpYx7H0FrLiI4wha15Gmg7iM+cRL/XJjSFtnSK4+250KomWLxBtXCbKBuSJwt31FN+4tsB6Z4s07+DYFtO+4pdOzvCZr36N7BsvcefcIY7suoOpPSeYOrYH15d0TJm+LUda+9Ii8V2c5pCaD5ZK6WWCVs9gOimiYKhLzcMnpljsGBZrDukwpOhW4aWvAnDl+rM881M/weH7H8bXKW996VWGvRbNVDI7PU2YBeAHHJt3mSwlbF6NSft95ht7OTAxQ5plvHBqi6YuMD7jkg4kSz1DdyPiuky4nGbMOoJdkz4lZVFIE7JeRLo+QA1bRNEktROHWF7vUC7b3HfnFGEa0lrNcKfmCHwPZVkoYeNKm80h1MuagtCIPMTxDK2tlM/+iy8yLf6cI77FAR2wb0bQzXPOd0IGFxbISRBeQErGtGUxVZEUWopNpahOVOm2W3T6IXmW49iSNM1vyT7eFgjtVF1HjvPiVhtg+88R/EJjWyPI6g5PAUYB100y59/i5AC4CUXJtWYnbDRGj/gmWiOFYHJyio985CM89thj+L6PMYbMpHSHTSQBlu3i2RDmHc6fepODj/8wQSmg4PkjmVgxEkbIzv0ronaKM94AWcFkNrmIiHKboPZ+7nl8k/TkgOGwRBIarHQZKndgeRNQqYHtst68weWrb3B1o0Tjgcd4ZrpKP2zhF4vY0vDW2csc3XeI0nQJL00JvHHWN3tcPrNFq+ixb1rwc+9/mJcPH+HUt9/kxtU1LgxD/uDGIu89XCTcfRI1bVMT4AuBbUmKrkvRVdgIpDSjavtORf8/c9ysxm+zWYQQIxXAbUiRtCykkbepCt2awztJgoCb5nwIa7vLZXhXhnAb3MjsMJJ3+Dg7r5mdl83NLtHNuW4M+XbHwuSG/2qzfXQRRsIdwK4jk5goxRZ61JGarUBW2CYd59hZholjTJqNZFizFNPqUt87R3SuRdYxpBs2+RuXkPUy9EOMMwm2i1AK0VCja3NlDWll8KmrUNtEE6PDVdRjxzGJIH3nLGlrlTyWGFlC7jvKxbPL9Df7dLbewA4cphs1GrMuz3/+z0hFwN133MPErkMUp6coNso4HkTaJVQjU1lLSjJpsKKMggNC5gxzgR5okAZha0pKcHhPlRv9PSMlTrdAN/8eqRU98NgJ7r97kka6wOLpkA2vzN33HyAeq2CbBBMLElFlcqbMsHuOZHABqcYYm9vHnoP7qFc1m1sLJLqA8FLq82VCo8lXQ8489wLH3AJy1uZbyy0myjX2K4/gxiJfunCDAyf3sLje4eLiOn2t2HXwIEHVpVp3mO5a6HoFyg7GsyhYisVcMjFh2FPWlEQG6zdoby6SlBXveeoZVLzFWKLYIxKwe9hWn7t7Pqf+8kvUds+wtNyiUi5wuBFQXVrlG5fWeeXZ1zl4osJ8w8PpjzwQXA2RMUS9kCxMkUKhlI3WCZ5UI617YyMtB6+gsISFZ6mRHGU6kgVTysVPI+TQ4AVTVBvjxMImT4ZkaYw2IydJ31PEiaGb5Hi2wlYebiFg0GwhBz2CWkBJWVh5TDKIiHXK2GSRcmOc1rUNokFCf7NNqobg+Uip0FkG0kFLOSJR5wlxf0guJZ6yyXRCnhukbeP6PnkWYUiIk2QEJRKgXAchbbLcYMnblDyMJNcSkebkOeg0RUsLbBtb2VjCQhvIDSMN/e3EQGOIdUqz+fbo+niTaBT9NMWIacr7JXsPH0W5HtKSDAX00xhr6S9Y+voFJh8L8HdP4lRnSfoBW+fPULnraUJtkVibyEZAZWI/fno3rXQvdX+Sga7TyQT9fszWjZC3VwRD41Ms1RiOHYR+Eb15mf7Vi1jeLNdbHdpulfmCzb6SR6NSZUobLg8yXl3Y4BE354E949SdB3mtWuK1V19hM+7x0tlL3BE+Tx2NVbiL1YJDxRdUfYeKI0ekda2RGsrFAkQ+eSVgfatAMhgSRfFIgSgeUq9X6UWGOElHHG5LksYpUkQo38cIhe1a+EpQdBVGgy0tfNsiHvSQeY4uBGihCXOFsVxQHlpYpKnA6Iww1ihyvKIkzhJMngGCLDcUHId40EEIRZYbsixHao2RLiYZ4gceqTQ4CrSTk2cax1X4vkuswUbjWSPy2NDWFBwY9EOEMTiWhdCG4SACN2DnAeRIC1tDFsa0uwndUFMoOEinRJKkGKkpFYsIrSm7IGwLGVQouwrf8/FLRWx8XK/M/qMVCvNVbN/BxAahPGRRYYYRVqmAVYgxgYMpFDDNLhKJPHwMhwjPibCvbjFsnidqbeK9toh18CjCMnAlxMgh4v46vN1C31hAZzFyZQWx/m20o8jthERN49/xOGmUsdVcpRm38NKUAz/6GBN/1CeMJukPMkpOyvF9E0w/swfZKnHt9QWaawt8Y7NJsHSRYGGao8cfYmZ6L6HJMLaDsT3iNCfeGlCeLJMbb/TAM5o4zLDCiGCwRmBixl2PuF6mJRL6W+s3v++f+MBD3H0gQIU32Gz7DEplDs5PMV30CaycJHORjk+5bJEMN4j7p1H+LOMT4zTqFTY219lsLjPULtI5SW1KESpob3VZemuTPQUHMW5xJUqpWgGVOCTcanFuY8jc0QlutIdcXmkTlBtUxqsEpZHPRiWS6MDHeHJb3UXS1aNuc801KDT9lXXW16+z0Wlz6K478eIhG60BB77//QSBZpgnTG8M2Vg6ixpvcGOtw/yuScaFIbq2itgasuYGLIRNOoNwdI8BlpTkchToYm7Cm98VkRjYrr6KnZ8RKXQbQqHNttKYGElNj8xE/3YnBH/VGCVQ2wRlzIioK0bypT/38z/P/fc/QKVS2U4MMobhGgIL6QRkesRVEFYFf9yiMTEzqlALQYwgS3vQPEP7nfNU7t6FLO1CWFMk/ZB4sIU7fjepdtH2OnZjinJ9N5kuE+sWjj1GTMAgN0RRwkYPrvcUmXQpFSukY3OILciGTYzOkU6V1jBioIqMOZIZ36Nk27SUopMZLm32OD4D9+4Zoyru5OJ4nWvXVxmkQ944f4078iJaHWGgqiPkhS3wbWsE9dF6xDsR7/YW+M8b4lbAv/OKGM1QrfVfW6HfgQndPpdvdnx2KAE7S8zt7/uOvctbwf9O8ryzrdtuituO6zsJ0d/bsdPFGAUkBsexR3I+mUZrAVoiHBuyDOEpRJ5gbAvSDJJ0dF+WbVTgw7JHIjbQwzXycIh9ZgtxYBKyFNpbmCCF4y4sRpjhClo7iHNvQSHG+ArjWyRuA+euO8iubtHfXCNNhzgGyo8eptTpk97YSxgvMbByvMkS+x85Qqnt0Dy3wuryRdY2m6hKg8LkGLMHD1GtNkj0EOE5aAR5rsmHGW7RRRuFENseFInGihNk3Mclp+K6xPUiaZgQh/3veh3/RsnBvXft4sR4zvrZF+iszzL3vo9RsyfIgx5FL8NzFODgdUK+/OZFOsMBMyceYtfBfZSrAYO4zfiYYWXlOmvLK+zeW2b34RJuAb72ZshuvchGP+bNGyvMuOMkQRniK7xlV7h79m5ePnuZM+fWGdu3l9kjh+mubeIfmWb3uEuUO7Qci8wVaMsgjOZQI6chInoX3ia8dobe5lWu9nIevON+CkEVf2ofdsEj7NygffUSR8YPc6DsMbFvF5eubFCtFNjTKNB95TTPvvEHPP/VN7HTPYy5CQ1XIo3AMZAgSaME+ybbXyKR1HyLVqpHKjzYeL6FXXBGngdhRBIaMi2InIiBZciHEYXSGE5QRmc5WRSTa4kG8ixnrFFgiCITFkZIpBRYysXxfMgzlHRwJQidkWhDqg2WyUfwpHIVYzKiTpdUCGSxgl8uojwPLW1ynRMNB1hZQjSMsHwXXBfL8XGQKMtQLAcM+ikmCwmHGToKcR2FMClZrDFZCkoh0AgkeS6Joxhtb/+dZUhHjpRphEWWGSwlENuymGYbx5johK3eOyTpENubxFJlktTQiwdYssKeew+SSU1iMsJU0I5z1ptb5C99mUKjgnfXDMH0MWwxQRS12dhKmB9/L6ubb3B5YYugPE25VmcYJbSKe5gJSjRX1+j2QmSS0e1GRKaGtIeURZu+sChVZrAHW3SWljh07AhRv83a1gS+KjHte0w1fObuL+CvDzh/VnNpocne3Sl37RujUn+SftxhuHKZxaUO9auvYJRDJMuE4hAV32NvefTAGHFGIJcS3/MYaolrWzieA5YkThPyJMM1CaoSYNKEJMvRaY6lJBYG8gzLhoLv4voOnmNRUDYa8FywpSCNQkID2A4YQ2a79LSFLSQeEmEkaIM0ArVNWsuTCGEMlj0yvrMdm2E3hxSyTGPyUdCTJPZI2lRLtDFYjoMnBVq7eL5FpZExGObYUmDlGZYwWMLgK0nfCAquhaccbCBLYrTJR5Uq18bolLATEoYJG+tdBv2UDSehaCvCJEYaTdn3kTrHNRHlYoDjFFDYWJaLcIroRGGrEv7sJLbnQrZT7RIIaWMygUnEaB7nBqFtdKqwy+Oo8WlYvootOvgyx7BFmg1gaGMKFQgGoCK0PUScLEMxg40A3b6ByRaR+RpGe8jKIdK5SeSB3YheTLK8SCdfx5uYoXj3PNUvGPSe3eSMU65q9p6oomYCPvj4Sa5PT/LK1SaX2iHdYUhr9RpFv8hcvoqwFP7EHJY/gUxihtiE3RRT9BDkmCQmHyYYE7OytEYoB+h8yJTv+k+JQQAAIABJREFUULRKnFu/RUh+z+P3MJY1ubG8TpLPM3bsXop2Ec/qUypILEshtSDr9nnzwlX6SczcwTlqYxUsZYEwjFUzlq532NjsUq9UmfdsdCy5fCmkajbJ2jHraci83aCV92nnPZbdIgdrPm9euc6llSEP7DpAqVYlCROcRoF6URFri4EU5NJg0GiR0yiCT0Z/6QJpe43e+irhIOG+u09iLM1qa8D8gb2IQZdKkjJ7X4H2wi6csQmuL6wxv3eaYpaweeoMzUvrWE4Ra6yKOnyCOBtxuQSQbvMMdrgGt4m9AO+GT9ySeNzmFbCj+GJurrsTIO2ov/iez2c/+1luuS/vBG7mtmBH3OxW3L6vHYWYm3KS28t2DnEHW34TfnK77OROMLe9sXcnPjvHu72GMbd+iVtwllZriw9+4AMjdRrEzSo/mG1issBxHT760Y9SrVbRxpDpmDhtonWGtCujTnOekuYSaReozUyQCYMxObGWDJKMsLuFWXkbt1BHzR7G9g6D9snMIlHcohQcpz9Y4sbGDSr1aaR0SLQkcSYpOj69boskTrE1hClk+EgrpCgUA2yCYoNk0MSkCeO1Imk8oDOsEJQVvrQYrxWpFX3W+gkra5q19S4TkwWOH5ihVC7iBRA111lY7DJ7/Qwlt0CsJclUGbsOZQVKCBYWF6lVqxRLJQbtAa+//hp5lm7Pre3rfntwzm3V+tuGEIKnn3maJEneFbXfhLiZHS7AX+FpcPvnuv1L3jbHRnPpVnLwVwb0ZtT9uL2TdmuLhp2SofnOY9te//Sp06wsL9+ayNuz/vb93n4NdjwSvhPzdPM8tu+FnfvLdVwef/A9o4Kklhi9vW8BJh1BqQQ55HqkjJCAsRWm4BGu9SBVCA0ma5OnKWYgoeiDl2CcGFFTcMwFX8PbDmZrHbJLkA3AlBHl/ZhqETFTh4kZ0htXSDODO1HH2VulUMoQdxwl0+P0yhFyd4Ha/DxzJ/fTnrnMmaV1Wv2MQTYgaUJQDqimm2B7uI1JtLRHKplGkkUa44PQGp3m6CxHZynDrS6pTECHjJcCOjoHnfDdxt8oOZDdFToZrF9fYaaQs+/OXTz/lS7Z1W9w7+MHmbvzEGmU0Lx8hddffZ6xe36IB598jKNzs8TdIW8sN7n/obvY+uKLXHz9FLXyOEeOVxmfqPLWpaf48jf+H8qvXaBiJIkjOeV0eSsYsO/DH+Ra3uXFF16kbc8yWZvByvpkax22/DL6zjJ2X1LOBXEKmTCcLEaUkk3C/hqn/+TfIJMlSrvLXHm5Q/HLz1OY3MXhn/lvKdTmWXt5kzN/cpZHPjDH/b/wD4n7GbMPgXQFQmQUDj/C/n/5KV7tD3nuq+c4OeMxMxNQLReQkUYJF6Vsio4iNRZRClpYBLbBKQdUfA9PKRxHYtuGMM8QzZBwKJAWhD2NzFJkUCDu9lGVCmkUMQwzskRDlhGFKROOh4VDpVhAKUkcx8RhgnA9hO2TJREmMyglsJQi8IsY4RK3W+RiW7qSFJ1pkriAsjTV+VmSMCWNB+gwHDkTZwbX9clQOKUCymRkOsW2JGW/QL/fo99NUBJ8R6KTiDgBJSQ6zdByhDHUOcTpEN9zEQIS4eLYHlpapGmKRFPyStiWhxSjdmeSp/TSdTa3vsr09E/Ty1JSnZPnGikCTLGMsBQX+y2mfcViJ+ONq1tsXjqHuLDJ3//7j9IIxnDt+xi02zS3zjOcPkpizxPJyywswsxkEcfKub7+NdxSHVl6H53OAv3NPkpWMLLAmNvl/PVF9lfmGAv6zM0eQk+WWHIsHLPJnBwQRwNuDCpoaTHhw0SpyKPlKscrHt98Y5HFZpMZR7CrtouH73+UFa/LRqfPctwmuvwSQccghyUKxVncOZvZghwZ6CGxpIWyBWEqyBND0bKoODapkoRpRqlcoh9HSNtCOS5JnKDThIJv4ZUcSiXFbMPHckadAEe5OEKDLbBshS0FQikQBlsIlO/R7IcUUoNvOTjSwbYtpDJ4tkWabssOSoGrHIp+ES00GQKSGJPlyG2fjyzTSOURRqMk1XJtlOcg8hzHEfgVgW3HKGmTxQlxmhKHOUaPzPB838JXCk9KpG+zEcaQWygF3a0bhO0uvX7Kei+n6AUMBxFOwcZXcpQECJvJsSrDZhNlgWeNpN5yY5PmCrKRBwm5jW6DTsE4EhlISMGuFDHrQ4yxETgQRQhVAUciBl3ypRZ6rYklY9zCPui+Bf4s+lwbIYZQkWRZGWYEPDiDvfQM6aXfQ3RCRGyB5+DuniP45b+LiAT+wKG4tklpeYPZe95LfHmd9cXX2f3IHRT334M9XiOYyei8/gr+7oxd33+SXcVdhJmiudXk2pUBX/vcl1m/8gLFsX3UDknKu2wclaLGjrNxvo+7L0dnMaI7RA4z8rLilfUI1+lR7K1y/NgMe2d30+/e1mYerNJqr5F2I8brHpXJEmcvpGQr73DP4ycIKg5pL6S1tcbpN15n8sH3c/fd+6lYNt1+zCCB++7az9bWGa5cuEb5noDxMUUmqiy2DX/5ykuMX1ighkuxlHPGGbI5pdh78gBr0ZAXXz1H3NiD9H2IIpJ2TGhgZq6ODMHLDKnWQEpVDxFG0x9scf5Lf8js8SlmxmqU8BGLi3jj09y57wCWKrJ+dpM8yph5724ajx8hzwxzxwVCGtAZWtWZ+sq3OTfM+fGPfZQjDz5IZXwC23FuBTW3BTHf6/Fbv/V/89M/9ZNY1ggrfhOuoW8ZrbENq7m5HG6q1eRZNoIwvSuIHJWClRo96neSkR1nW8seKTBhuElQHQWBo+V6G799u0TlTvphSYk2I0jUyZP38+yzz/6V53XTTGt7mwZNplPirEUULVAs3keo021IigWWxNijbvJmElJzbJb7KeutLsPNNdxOj/d939N4dhVLHmbQuUSYC9LiAXJZIZUeN25k+L6HEVuEyVUct4pw9hOGa2SDDO3UsGVOQXRZ7W4wF0xScQ8zUZugoyDqbmDrHmUZE8UR7dgj04KiI/E9m32ux4yvOLO4idXvUi0rpmpl2LefLS9mtdXj2nCd2vlTWD3NVnQAIQvkvqHiCl584UWOHj3K9NQM77xzhv/lf/1l+r0uWZ6Ta43W+c2Aesc74t1Qtm30jJQsLS1RLpe/t5Px/6fxvief5NVXXx3xBLZVm24lIeZmcg2j8x+p5MpbHYrtxdKSI5K/ECNBF8tCCsHE2ATPfeU5POOSGwO2QCoLneajWTxMEbYZde5Tg9Yj87y836V97hruqoVIM7SqoOJ1jFfGnO2CiWDMgakCYtqC/RXkhXvR5/4Q+glYFqLsYe2fwvmJJyDMcQ4fwO1ex2ZA8a5j6M0+g2vnmPrgw1gTd6GqHpY1JF2/jjCaxoN38uijdZI0YdiPaK33ufLWWbpXVwimDlGQBdyii1QK6ZQYNFNs16DTDBGlCCGIEFztpNgqpDDYZO+RWYquQ6X63eeL9au/+qt/7cKPf/zjvwpgYXNlK6arDD/ySJVP/r9/zuGn38sz73sPR44eZKpRxReGP/zTz7HeXOWJD/0PPPPQPmpOzMq1FU6dW+DokVnOv36GyXmLQVaj3SvhFVzuf19Ae/dDFPsB++2AnjfLlcZROHYv5fkKn/sXv0enGzL++ENUJiuI1UXm9no8+7tfp741jilKahVBowBxmvGllzZY+tz/xe/+5j/ns6+fpb/V585A8eR//wD2lWtcOqs5/Zmvsfz5s9hnNUe8wwR6F94TU6y8kuI4EqekRnh2A2N/8nk+3e7STzNW+ynrnWQE0xmCcEaqDMJx8AsuSll0eynDQUKlUcezJHYeYwuNbSnSTLC21sUmR1kG1wbXsbG9Ml5QIgh88n5EtzdEI3GLZSjVmWxMEA36OAVFnEbEWYoX+BQDn9wt4RWKmN4AmaUoR4IRhMOQ9rU1UmlTUDa2lMQGrKLDzK79+MVRq9NTAmkMw/YAx/NRxdLIWCtPIc/Ic0OWhbhScWO9hbZGmrpKCox0QPiEGx2kNviewrZtciNIt+/bPMlwvSK5GcmrOUohhcH1Ktj2SAZ3mES0ekt0tr7K3Ox/R4ykZwDhoqUPTsBc2eMr7Q1sk5GZnMWXr3L2z15l+dqrfPgX38PxyffhOA8j5CRnX7rAt569xL0//StUhcXLb/wWUWxz7cp5FtfO4x8/xkSwm89/8wVm95zA230/623D0qk3mfDbXFlLuXy1RTP1mW80ODEzx2R1hpdXrzM7fid7utfJM0XfrdEp1OnlkkqhiPEq7J8dp6BcsijE0j0OH96DygJOnT1LsToFeR/dvMB4t8X51b2sFwpMSo2djbqvwhiyXkg3yuh0QlYvXqDT3CTJQpRK2bV7in6nSzjsgwDHFhSUoGjbuJ4kHAwoVaooxx+Z3Hk+liUIqiUS5P9H3ZsGWZqddX6/c8673z1v7ln73l1VXdXdarVa+4JAAsQOEgabmTEwjHGEJ4wDOyb8gRmPIwgCf7AdxjAxESxj0MAMGgRCC6ClJXW3elNXdXdV116VWVm5Z9793c85/nAzq0oGjBwBhDkfsjKz7n1v3vuee9//8zz/BTcIqASKqm8IghDpeVQrDSqei7vLf7XW4CuL5wkQliIHcHEcH89xMEVKtx/jFCVZDlkpkVIx0W6QlJI8K/FcF89VWF2QDEf4tsT3XVwpUb5LUWq63SEb232yuCROMjzXA11gTYFVDqurm0zVq3Q2Vxn1hwz6KXGc40WK6elpDs+1aUQOPg6BcKj4DqW0pIMUawxZXJD2U5JexqCXIYYJ1UqdsDV21ZGeQoUSUQoQcgyyKgo7AjtQqIk6shpgrl/BvP4WcuTjtGZwFvbjysdRvQRVjrBlhnpyCnnuOFKcQp6bhnsl6qcP4zzzIZSKEN0V5NueQf63P4+YqoPjIkRMma6TrK+SDDXltRcRG9foryzT6d4ic3r4zYOUpkr/M/8OZ/8TiMoETlCn3trH9KFpDj0xRfvch1itnOLS4hI3Fm+jZ86TVyLSHcO2BpGnTE16HHqkTWMyZFCf4sSkT9mxLN+6xrW3XmV5ZYlLt+4CcO7USW73YqoTAQdmfF56/iqHnjjLk+dOMjHRoB769Ps9vnn5LXZGHd7zwY/y6IEaNk9Z3+rQHcbMtGus3LzHwiGPftak1C7NhsORExHq2GGqpsaRIGSpMsPWwn6cwws4vuDTf/B1+pnh5AfOUjEpvkkQZDz3+deYd2agJqgFAl9Bpz/iwqU7DN56jq/+zr/lazeXmMRy8MAs82eP4ZSGzNS59W/+iGLdEJVVaqaB2JGogxHZgPEE01EIpXCGMf5bN/jq3Q2Wr1yis3aP5tQUzZmZB8LKv6PCAODll1/iS1/60n2A/jBIuu8A9NDa88eXQjwEIC1yl1UxBlxje1FHPegDioe6uY5y7t9WiPHxhHzYf378uz2KyV7XV0qJ44wtroSQLCws8JM/+ZN/6TntRWYVOr/fEc7KkiRbRZcdqtXHdhu2Y4ciI1xcx8VzJbfTGGeXIrHy5iZL129S2B5PPPMYU9EjSHkEhM+NVy4yGEXMPPJhPAyLK58GplhZeoFEFvjtg7iyxuWlG0xPH0O2jrCxvkXWX8OXMRu9kptrXWKnyaFWg5laE+kErCQ5zeo8rf46hYzIvIhMemgknuth3YDZiSrCCGyZ4TuWdquOJypcu7XI5OwB8s5dvOE2bmJZi5vEvoPeWef82fNMTk3x+sUL/N7v/S6bm5vkeU5ZFA+0AdaMpzC7ouI94TAPOQRpo/mFX/gFfN//S6/9P4T127/9O6yurrJn5fvAOfWhKYQYvwbqYTekv0KjY7HjhObdKYcUgiiI+PgPfJwgDMbumY4a8zuUHBcQoULEIHARgYdwoFjbQN9ZwZV1aNdQ7Un8ygJO6iGKDKs1vLOFfHw/6sQCouZC1yK+ZwL51NOIfIiYqiHe/STiI88wFgMocDLKtIdOc4phjl27jaM3SZZXSIo1RNXHqc1Sxpr80rM4B54A5eA4IX6lRrVdZfJIm+rR82y40ywu3mRQCGx1Cu046NgyAFxd0pwIqE/4eBUPU6sxV3fJdiyb966xsbrItZvX+MY3LwLwS7/0S//yrzo339bkQFRmOPdDP4Q3NcV///P/jLe1m/zshw+yoyM2OyXlwKJKy0uv3iLvjnjn49PMTIZsLm+jnAEf/cij/MYnl3nb93w31577AkfEl6lVU3rL72B6os6j0yX+z76XpbfmaMuCE80azhB+61d+Effc4xSBS//2Zdx+SH0u5I/f7FB/5zf59U/+e4JPOfihx8TUHI+efYr3fvwkG9GIldshaRZzOxH8+ZUh5reeY6JIeKJl6ScZQbJKq3BpxAK7GVP85iyTaUTnVUXxnojJD0U4zSmOf/U5zp86z0a8RYAlKDTFMCesCFTi4fuahpWUiWaYlcQlFFpikwGd4djByA8UYRSPbSelJKr4uJ6iVgupViOc3Td2llt6w4LSSHJr0Zlleq5FrATKBWNiiixlMEhJMksQVVAuyEBROh69QYIz7NGacNH5Bs3JJjV8SAuG3ZRebJibqRNW6ggUsVUYHIQfEc04SOWgrMINfIpRQZGXCGGRfo3u5gaNiWlcf5yubLQmTWKKuIThmA+fuh5OxcVxxwKdFE2z3kZIgVKS0lpGeUklrKNLQypyeoMeo3iIVB6Tcz+BkS6pTpHC0C/17lgUvra1yoxd4mB4nD/6P36Pr712m7Q1zQe//2OcabdR1MAKlrdeYKt1meZH2syoKn29xhsvbtDTA952UhKQ87nf+UN+4Gd+kcHUCTqZB+kWtYkC73yTC79/hYP7JjkQHuT2ygpfuniLjmjwnQcqvPPcO3nt3i3ed2KB/StrjFa7FNkEC1Ml3XI/qj6H49coGxHQwmRrbA432f/Yab6v916uXLvFYEOQ2ZTXFq/jeANaz0d86XbAtCdpq5KGn+A2hyBy8q0N6kFAHriQJ7hhQH+QEEUhWQmDpKA0GqUsbgBhs4KXhzihjx/4uEGIDAOEDigyS5ZmNGYCXMcFI4hcD8eUFHbsViSUi7B6/AFYanaGmkYzIvQkcV4y7CXkOxl+GJL2EsqoQm5iFAZXBnT6GZ4XUaqESuRTaks8iulv7zB0fB45sZ9BPqLbSyjSElcoIiCLKti4T5YMSB0Xz/VpA/smqqiiS0UJslzjCNg33+LRMydJtU+a+2wtbRL5CieA4ShFxiUiT1je2CB0QyI1Fmm7WU5ZryN8KIcFgnFnUiGQDYFNgMwgSlChh3VdMAY2eyhRQ77v/VD42FgghiVMJpS3n6IoVpD5Fva1JuodB3H/+SHMXYtoGcrPjRD1AnFuHnHyA9i5sxTPa6zpQUNT3Poa8ZWXWe2UXLz7PGfrI971AzMEUxYbHmY0OMzdz94mqd/iyX/+P/PCr/06y/cstQPHOfaORzBzIZVDZ6jOK95ZHfLI6feymfgMVhPkNy/SPjFPdWjZf6SJiHxevdnhpT+8yA999CgvvNHj7FOneWb+HEW8zIvP/Rl/8BfP7X7e7+Md3/UR7r7yAv/pN36f8yeO8+4TTXq5YDjSyECy00l5+cIKRXfAqQNVPE+xkwxotxRevc2LlwY89aGneeuFr3PunEIMT5A509TbLofrFvd7j3P3To3DlXE43MadVb7wyb+g8vgJNgPF1vXrnJj2iAOHt7KE6MRtfusPnqVZreBFHrPzh2hOTZCzwasbF9g62sK+MWSdFh11kGZwGB1cI7jwMnMywX/9KoE3wHHbEA3R9QBVeJTHPdwZEIHAOXyUyX/xL3jsH/13DIpN7N0l9KB/v0splPprrpB/O0sIuZsT8IAW9DCN5H4B8NDPe6DqfiGwCyT3usoP+Ne7aeZmnEAupUQbPZ4a8IB2ZC3I+z/vThCE+Baw9mC6wG639m+qmcagrZSCNE0pyxzltnHDBSwSTYlEEBuDkorMFAySmDp9Ws4UX/nUF3h1K2f64AJPnTzPdBgCHmDpDK5gDxVU/EkC4ZCWQ5ZurJI6mnNHPZZXXuf61honz/04cXWeOBcUaZ/2XEi3kKzd6LEw3WLOneH60iLPVyY5P99mvhqBM8+t7g5n9k0xtb3BqJfgVhyiQJKZOtKrYlWADacQ2YDSpFhT0Jqf4YPvOsfi8hpyZh+dzZR7S6sofYCq8tiuT5D3LRdf+yJff+ELXHzjAqPR8P5EyBg9pp/dHw/sidr30oX3Nsy3bI9/kEvsFaO7Ey2tzUN7b7xPnV3XofEUYY/K9oBsZI3Zpezt2bGOm2x7WSL/5Of/Cf/bL//vHDp8COEIcECUYkyH1RIib8zIKg0itQRBDfHkHDYT42lCbDCNFLN2AJP2sfEO5csh/gebqPkKtmcgAN4ooKHhfcfB0eBNYxYt6BxCjb75OvnKFpt3B3TiZeZmMw5+bBoZFVjnOOmgwvDyKtRiJr/zH5HnhqUvv0lYDwina1APUdUWfh0e8XMO7H8bSSYo+jlio084XceLC6ZnIxJtWbrVp3u3x6kTdW4upRw9f4h69QCDzjK3Nlf+xnPzbRUH165fYfu3P8XMwnE+8vHv51T3K/z6L/4PfP9/84scWlhgqzvgG29eR/dvMnP4GQ4uTFKNfHpBg6Tocu3123zigwv8xaV1tKyxnrnI4RLTcsTti+9joqxhZxKUGJAIw1IXOndizn/snbx5I+cn/otH2bfTYfHV1/nCn75O7MC/+rUz/NFCgyt/sMTGnYSt7i26yy/hXKzwo//qMd7+P72Xndsdekt9bl/p86//5A6fqFT44MJhFuoGqS1OmqGzWyhvi/LzJ1CPHWOi1cDdVXsLTyJ9j5955If49PVPsV528HyHiVpIu+qTI1EqoEhLtDS4UjE14Y+DLOoRaaoRUuIFDmHg4vsOMxMWhAuug7AueSooyozQLcmSkuHONlHNp12tEFQiWk2XQkHPqzHsdekPEgbDlCzLiNNNjp06QZyF1Cs+fmuKUhvWu+tUvSqyuQ8lClzlELUNzX6KcAM2bi/hRQ2kH2BUgMHBd32KJMEUGVnSRfkVvGodKwxSONSOHwcryPKYPB1SJinZIMetTOPVK4TtMUBwXA/hhRjPZeveJsIkBEEwniIIO+bPZzlaa7qjITtZTq3qM92qkUnFvbKgIV186aAdy0BrhqZgOmgQ2DP87q/+Nt+8u4F65DynHzlCOxgQBo+Rij7S9ul07pJbRWPfOSInopflPHe1w9PvbrOd9lm9tcPahktevMZ//raf5bPPf4b23FFqjXniosQcfpPlz73C4R+c4vEZy9X+Jq9fvcWs1+YdRxdouYf4969rnmge4HA9oR3mtGstTLKFrybJyoKwGrJlGmykMK3XmZzIeerdb2dtc50kyfCkRy0ekDibDNdLXrwlGPUHNHzLyQMBp04YpmYElhJTxoQ+WMcjThPidJ3eYEQ3zXHDCImgsIKw3cZB4khw+ztIx8Ot1AiCAJ2ViDLFOIKKX6VarYxFZMqikyH1ikNZSISELE3p9lLyJCYe5dQjRS30QUhGpcETPuUgwRiFNBm+sIgSdFpgQ4EoE6JgbN+bpTGmLKmGdaJ6lY21HmkRk/RjFBLX8SEI8J2UsFXHpkMckeGZApNkRFGItJKg0sQWlu3NbYabI9av7RBOTAAprZpDe6pJsxFBmrJy5Tp3sxG+A/UwILQWV49wlcfU/lncmSo2MIiqRbUETm0XFDlAVUF3vEcZaexqgZhqIVSEXR9hdvrozWX01jI6rrKdXkMkizRbTxE9cxz5HXNYIShvalSlhCIGOUQcOoLhMKPn+8jtIXb1Ms58D+/8UaYfOc2Zz79F+fXfQeY93KPH8J/6ASyzyK7k6DsmsFHJcHuZJ/7pz3FiS3L9jes8+xdfxA9DyvP7aOwf4vgOtYl5Jiot+p6LOqYYFCO2YsvyH3+d3soa650RRXeLL/7uW7z7/Y+z9sZlrr9mmDgwwSPv/k74Xz4JwCuvfZ17XcHBuWne9YmPMZlc4Iv/1yd554/8GJM1xU5/xNraMmK4xKFHn6ZVD3GkxPGrbO/0SIoRT5+ocnl1gJE11jPJZHYP1U/pZAtUjYup5QiR0Etho5uSo3j8Q4/y5orm577zAK31Hb721We5sXKP1v4GP/ajJ3hpusGNP3+L1Y2Y9Y2XmPElxyar/OCPv4vX3tzhVppw7OlH2Yp7XPrM53nfU2+n9swHcTe/CXdSRGeAtRkyGmKfayHPTMKShEhgHQlS4AUhH3zPD3LLv8mj3/vdNPftG4OYv8OJwd66TxO/LzF4QKvYo/nsgXj1kEf9+P8ecqxRCmksDygoAqPH16L7wVU84GY/nOC8B9Ycx0GXeveveKBHsGbcyb9/+4cmDH/dshbyokRKSS/TRIGP9FxyBKk1+OOIMFwJqTVoIam6IVL7PPsnz/F6DAtnTrNv0qfqlChZpRQ5gpTRaBXhtfGjfThCMSpLnr9zj+941zk2Om+xuLZOoQSKFZ6ef5rXbr7K3OwxkC1MvUcRLbL1yjeY/8BHeKxteW2ny1UHgukKs7WIUDT53D3BO1ot6k5G5CkizwGd4siIvExQgUdfR5SFILQJrso4fOww91ZXSD1LGApqCjI35+6NKyw7k2ysrHD5jedYWrpMnhW4rosuS4oi54EV6G4S8S719v4E5yFdifh/ed3/ISxrDHu2SVJKlBzrF7TW4+mAMejd2+5pfZSSD3QOxnxLOJvaLRLGv4DSlnQHXYbFAO2VOOGYrTCOVlKQ6DEFaGggE1CNxsYO3QzdT7DdTfo7HXqrCc0+mM4a0ZEzuM9Mo/aH2NhiNizCtWBzhCoRC0cx/RK9bRAB2EsriOkY9/xpmu1jiFdv4r35EiLvoqaOIReexmYugfbwhAeOJusP8SaazJ0+wca9RXZu3AYnwMyfpToxpsxV/RABxJFCBC5pkTMsYfTKNfr9jCTNEHkCxCw5AAAgAElEQVTOrRccjp5dYOv6IkvCZfZgi9bC4b/x3HxbxcEPf2wOt9Lm0i3Dji54WRzixQu3+FCesRAqBldXePlPv0BpSg6+4314fgDakBYxuCnH9jfpZyl+CgfPPkacl/RKF1d5LDg91JEai0sDZuYalFbT3SoovAJ19Dw//GSV/ssvEB9oUEx65I0B8miV3/yVV/jxnxd8+L+y3F0S3LxesvRmxsVbA9Z/ueSH3jvN3KP7mHjbIaYfrVE7/hSf+9XPcbqfsM9IlKgjiLAayAvsdoHYFDg1gV0tyC+Dd8ZHunDq576Xlf/zCjdWrzJSGb7j4Lkuk1UfJ/RQrkQLgxSGzGhMVqBaNaq1cMzVDse0oyJNaNQbFHrMnXP8AOn7KN+l2qgwGuZMT7URgTu+TzUiCEJsVuK7kmHiko4y9CgmEAJMhmNy0CPyWCLLEi8KmNy/QBonpPGAIHKJ4xwTl6jSIJOY1Ar8oIIpNXGakcVDvHJEFscEXoDjeWiTI/MSpKA0JW7kYbXGFhZhXZRbw6taKvUm5XCI67p4/jitLy9ycmuQjiUrMpKioNsfEqcpfugwMzXJ/PQ01QqIakQUeASeRyEkvh0LvktrMMIiJPgItJb8xr/5E+5c+ibZ3HECIBv2qT95gLryWbYFLVFhM/OI7RRzlUcwVnHlzkW2NxIalRyTZ3R7OdaUDLqvcHXqJ5mIqqwMh0yHbWZbRxETHjvDhIPdDVayeZKyj6M2ubXWpureYEb1+b4zp1g2ikujEtspkdsxH250WYi6VFwXTyps6FM2qmwVlmyzQyWq8J53vYuXX36JxWs3OXB+glH389xY8gn0NEUG/SBkZb0G6YjFIKHhJCg7wpQxZR7j2YLCGESZE2CI3HHqrFRQj8bOQb4jaLcbRK0K+IIiz/FcDyl9qs2QWq2C6zpoUyKMJnLcMRIxBXmWUWZjgX1sLIHnoXSJLgyekDiBh2cNeeEzo0YYpSiNwZYaUWqsEOgkRQJJnoyduzyBNj79YU7F1VgEpQbpuATVKhPKZeveOo1ZH4NLNsjISo32JaN+StuFYdpBG0ulWoVCMOr26I4sKohoBwJGCXgevhPimgZHDtcQw4x6VEfmJSYtcMPa2PZ1GJMLcFsBwhfjNqkBNFA+6EwJX8CsB7GGrR309SV27txkMOpgXUXdV6xJzVqxzkz/OY7oGabLg9idEudtDuYtjelpnAWH3g3DaAWmnpxg8NnXEaFENX1Es41XaRO8fUDnK+us6wGnrhTMHhK47TqiUsUPq8h2gC0aOIHEbUtOzc4xefYIO1eX+P3P/Cbn3vldhEfnubNtWe72GWwOSXaWkekN0v4O/aVbpL0OrqPY125R5gWXvvksk/mIydAnDGboNir3P++//7uPs5PUKY1lR3hs2cO8fGGJd/yIJXAV6zeXWLp0Ha0E+88+yl5iaq5TAh/CwCPJS7xCcPD0cRIDfeMiBTSdFFFz2NhKqHga6YbEWpBGLs7cIb7niEP/whUaR6ZRLQhcKCY1n/mjb/Dhj7qc/2GH1Q2X9eWEwdKIeyt9vvgfnufsIxNMPHWU+aOTuO4UswePjSlgXoD2BIgqaIHNDdaUiG0NXYGogNnUY1vJpkJ6LtPf9yTV8Az1+TmU6347l8i/tbXX+dzLVGB3R447xvaBOPn+HcZfrH2Qu2CNGYP43eApoXaFz3shZOwdYtdWcg/k77kqaYORY2qLsWNXnfswVDygeewdaE938Nc8I6SQhH4ICMIwwHN2QSACZ3fKYcSuDz/jxxqOCr724hXWl6+hDp4myzIMHkG1hqsUQ6sJ8ekXChlN4rltSq3Z7N1jc2tILSzodfvk+RC8DZL0AmX4JK0gYnk0ZH9jmjBqon1JZ9hnftRlI5vAzXqk/YBV30OaLUISnlmYp2sNvVyh+xD0C06ECVUnwZMShUPFl4wIGGpQ+ZBKpcLpU6d44/KbOMqh4UgGwwvc7WpsepfLl17h7vJl+oMeeZYiBLhKgeeS5nb3hRW750Ajxf+zQLUPnf9/+Evc/7o7oRJ774U9at1DxS8P9ipwn3Yl5QMh856VapwkGGNwAxfljnOU7lu0mvHRsBYCAVJicw3DhPzuBsO79xiVCYUU4Lr0ZMHWaI3ZNcOMmIa8Do5FzErsloYShCsZXTII38WbLCnvbSPnAmRUQqWKOlCB1TsMX14hdhLmtj2CaQ+hKkjHRTouBBJ0iHAk/qTPVMWlmS4Q90a8dek1gpOPkrQF211NUVh0VjIaDDBZF52lONmI7e4OCsFks0agNZt3bxEN+viNKnKkyZO/pRC0s6ebtA+E0EzJ1jPuDuqImZCB1GwNBizdXeHGlWuA4PjRSTxh2OkPybSm3qgS+C4XX7rC0f1Nrt4b4I4yXOEgC8XQjzGjVaJIMz1ZY2d7B5NsU6+WzJ96hLp2uPj7N9CVE8hD+5mU51i8eoE3L+8w6IbMTZY06prJWYhmJdsXDK+8sE4lGXJgTTN93DB7KOLt73+cxUt9br20SJ2QltNAuE2gwDKA7Da2cxiGEWbRYssSNatwpiW1Mwc59fjbcPySzeEK2imJogDf8ZDKxQ1dlAclmmFqyAuJKTQog+OA1BryEp1ZZBQgdY4wZpwgKBXSCcaMS8fDr3loKXb9jyVFmlImBRgHU0o86eJ4Hq6QuLZAZgkqcCnzMQ3IVYKgVaPMc0Q5QtoqwpSUeUI+KvEcSY5DliaYTFMUJehynKNoSiQG5XpjpXtR7ka7G3SSI5TYFbIppOviKIVULk4YUBYF0hqkcjBSkRlDkSbkpmSUFXSHCYU21EQF1wtwXJ+qK1DSxd21dzOWcYhcoZHCUghDXGpWtwa89oULvPiVL1BtFLSmPKSf4KkRC9PzDIQksT5uvokWlkowxUS0j74pWd5+HV9lWDHAr6X4NUv/Rsm1N+/xxOFlvPYsozs36amQ9v6TuDPHifNnId0map+k2bdkow1WViJ62zkfOuHw2GFNRUs6bsC29LjS1XxmzePMqMdjBwNCF0JbZabqIfsB/VShQo/GwmEOb96j3FkmT2IW/BFMHqGiBINeSmEKQsZBZvduXcGbdjFOQpwNsaZgouqiAoXneOwMSgwFUhhcR5IOOhjh4UoPqyRRFOL4AcNU4wYenhNRb0SEQYC2BluMNQ5GlxSJQecjcj22nhXSwfU9QuVhdIFULhKF40h8qcbuIZnBaHk/6VUKcByf3s4A644zLBwFSEGix70f5UhsIfG9ACUcdGnxPA9fWEIl0I6HdnwKk2ONoTeKUWZsuVuUBSiHIAqQqRlrD7TC8QNsUpK7GV7VJYwCKjUH65X4ToSyY79r5QYoaSiHQ0zFBbnrLV+ORcs2t5Ca+/8yyrGdLsUbL5EsrnJ9WWONAreN1i6dfo4/HbEzSFnP7hB27zHZ6yPaDWRTwoxENCJwDdIpcRsGUQpUu4mariCnLFQb2LLAFl0yRuwYzdL1Ds7+TRonDuE1A5ASXbp4tWmEHGeITExM0DwwR3dqlrf3t7lw8SZ6uc9msMBmUSfrdSl665h4jWzzEvloi3oYMddeYHpuAn9jg9HmDi1KAu2hOha9Ur3/eX/q1AzdUrG5mZL1Dd2kiTvtkFJiUsu9lQ1WVjdRUrFvrjYWBKclQknC0CcvNDvdDnMTEXfsiGZeQqkpypJEZri5JfChGlTpDgocChoVh8bMJJERfOGPr+PNNakcOkRlI2dja4nuygbWNpicSplolUxMSu61PLbfSrl25RZ1LyGYC+kNBuw7cJjJmQWsdshHCdrzkEGE8MRYhW5KiLegNwlthVkzY+5iIBA+eAsNgnr0LcDr72VywAPHo78abIv7mNAas8vl2RMYcP/vvd/LFw9ErMaaB/e1e3fYnVbsaRt2nV6stehdwfLDB7K7399/JXZ1CHuP8Vc/p7EzjFIKbQye4zBu9I674NqCNhaJxQhIS8Pq+oArby5y6eqrNOqCdsPF6pjArROFVXIrKKzCMQOQLqHbwFUVUp3QjRepuClWbOFXCrTQdHt91tYWOdDs4VbbjDaWyMIG1m8goklGWQz5FlHzEM1ehk16rO5oekPLmbbkQBu8UpArn05qWU9Lel3JwSTh4KQLVuALD1yBMA6pdSisojY5w9zkXeJOB4qYSS/HTLQhV3x55ypZvI0UFsdxKIsMBDiOxDUSIRRGg36IUjSmi+0B4/+Pm+v/t+thAt0DLcX9qRY82HvsTdYebPa/8n25p1vAUhT5uBA1Brur5RD3m0GMm8OlxWYFptsju7tEttFjbc0ihWaIxFiByktSv0vhZCx171Lr9/Hy1tiswnOgJgAXtEEEBumCMALhesjZCkJ4oBywMVYklF5K4nnkooEzsqhQgXTACATjwFmEQQWCSuRjrSGojZjt9lhZ3MbupGSVFpWKhyctuRIEtQDt5jTmpmnP1FEIqqGPoy29lTUiAkpV4KQjiP+Wcg6cQHDkRIauJlx9VrJ9I+Hk6eOsrN6hv73F1Zu32c5zHMflUHPsjtFNC6z0aDTb9OMBva0OJ99zjCtrI6p+Qs11KCX08j7BesrEwhSecrFFiTUJlYmAx4/N8cYb2yyvryCWI46ceYqjCx/gzU9+kUrD8uxLKW8/qTk9Z3j0mCA6otg+4pDGcGW74ObX7tK82uHU4wnf/6Pn+fhPfRfPr32WwZpLZFvj6YELFBHWbmD7W9gdD2tD8F3KtRxVcyApmDl2jNJ0qG25pHmfUkInLlGJxqtGhBVnrHp3C7LQ2fUVz0BBoUvIS8pCgmsRxlJqC0JjlcZgQI+QYRsrxraQpoRslKNHKaWxFEQIDZEfIR0XhcXzJV5ZILTAFGNfRluU6GGMyAp8ZVBlNh7BKctIZxQ6RwtBksTobIiQEt93CQIfW3r44dgjP9N6nPosJFJZdJ4jHGd3pCmR0kVIj6LQOAjSOMFYcHwfGwTj916WUeQpcZKDEfh+QBTVqNaaWKFwlaK0AmsgNYautmznGp1nVJVkO864vb7Fxdfe4rO/9imixmXqj7+bipcjPUWzFbJQbbFuDI6NiAdLuI6iGU3TCGqslgl3N96i3irJsh7NuiZoCXYGmksvJ3zwe24SNx/HDrZJgdGBI1QWzlIKTTza4ci5CLWcsLG+RtmxLJn9XIsEVXmPU7OznJ2osdNycVuCr18x9FYS/KBgwe9Siwrq1QZVkbDoV9HSpycF9X2HmN9a44UvvcbchMdTh+YoCpdh2WE0ysnsOLtg1F+k4weMbEpS5lR8QbVRo1Eb+9bnpWFzMEBngjBw2EmGCDeCaouiHIPhKIpAZKgwJKxEVAKFlQK7qxYXUpIXGbrQ6DLGOgHC8ZBYAqek4vnkgxRfBIDEmF2xo04YZTlGazzPwRFj8oHrSqw2aDl203D2gEZZUKmGY31MYqlGPiYvyQcpInSJQoUjxh1G1w3GvSGtsXnBME5otQNkDlY4SC/E8w2BkISeoloNkVZQZAWll1GtCxQgKxG2cFCuTxAGY7tXo8AUSA+s0Zi0QOQWSjG+QCQGOzKYjRH53XWSm5coL36OThJwwz9Ma/I0zUoboRN6vZscn5EUd0M2c8HtlXu07l5l3/yj2E6KmKmjZqqYG5rogCWqWvTLMeGRE8jjFus45J0R8bUbdC98k9IRzM/P0Y0lr7+Zss8tOXh6LOou+wbpu6jAAUci1bionj5zhB87+tN85ed+jUtff46iuoCYOEiR5zjFFllaYOKEmqeYb08wP7uAGwkcoWnXIxQFmSiQvS6ueNBJkgr2L8SEQcn6zbHL2umzB9hYW0EayUqnR7+0+J7LdKDRumSUFnhugLGGUTYkSRJm5ysUmzEtH4yR5LpglMU0s5JGq0oYNOn2NxCqpFYL2N+qcm895tad20yu7WPy+FFqwwHXb7zExKTl+soQdzZlX0Pj7nepTDhsTEQMhiW3Ngc4ndt4lf3U68doNSNwLMPeELEwhx1KhDKIQYHNcqzpQz+GoQThYHMJhQW1Czz27ETvY4+/nxbtX36UB33++9/tgiZzX5j68IRhF+wLELuWwpYHegW5K2p++Ih74P6BlmBM59i7/f3Hfcj+VGu9q2sQ9x/zr127yK4wehfcCbS1ZAYSbTBa40vBdlpwd2OHNy7c5uI33qTevEPzzDNEZoT1fWqhR+T4xNYi8cizLXy3QsWtIpVDN4/pjK4zNVGSZSv4lZLStWz2Uu4udjh1apMsPACDNfLWDE51Eq86S0lOEm+ycDgiG3Qp8pJkaOiKGi1H4ssu+5oNlO+yHUpuxYarW1B2C0KvoKbGKbWRVPjS0PdCNIpMeUzNzXO3n7C9tsH+qseR2Tq9QUbLyRg5BoIqjltnY3OFWsVnmKbUqg3SNGMUxxRlCaWlKM0DR589p56/h4L173rt2fDu7cOx+H6PaTS20r4/z92jyO1pahhfwx52c3qouhgXUbuhb5evvEW7PclUewphxXhaXFjIDbqbUmzskK0skty5Rn+gWbLTTB04iDYlZToiTjtsO6u0KxHdNGf11jLOTJV6fRpRaKh7iKqLXTUER4HEYHckTnsC0QRESNlJKO6uUnS2ke0arf2zlH6TjR1Ba1rh+3LcqCrGVDLpyDH9V1oEkrBZ4+TT57n56QtsXF5l+vgRZhqTTNQ9dL1KrdYiT6pMticIAh9jDEWWY8uCWj3ExCNGO9v4rjMOPv0b1rdVHOSkNGsZx+ZLbkyPWJjegcLlxX97GVWr07UuTqMFTo5nYCVLaHohShmGSUxZjDhz+iQXV+4xd3SO7c0hO05Ea6KOf/U2x97zfl5elTQSSb02Q/XRJv3SYV+lyr3DI9A9tt98iUfPznPkmbfz2UaNUdzn4p+XfOgxl/lpQyPQzDiadELx1NOTfPU/lKxdNeysJdy5ssrV5Ws8PfsE7/qpTzD89F3SWx38TOGqOWx/mryMId5AbEqcQ9M4p+tgCsr1nPzOGsQdpo7uo35sgsHmGvdu3mWU7jDodVC+g1+pE4QB9YkKjucTD4YMBgarzTjwBkFhDLLM8YIAUVoMijSxxP0BvippTHu4QYAiGAd2lBm2iMfdUZvjSY/culghCSou7VoE+Yh4FOOJgiCs4gcuJumR9AuCuk/W3SSoNImiAGntWOxbljiyRjLqI4xGhQ5F6aDyEU4twmYZZZojxNjRRWAxpSEZ9BG+h1CglEE4gjTPiLe3CDwHHJcyzyiKjNL1CWsBTiJg98NSuR5hFI6TRt2SEtBakJmSYaFZjHMGVqBkTmwtX3hpkWc/+yXuffHTBNURlblZGgdO03/pVartA9TOHERJF2VyXGOJd2I0B5HBQSwlN/Mer7z6FqKh8YYFPQtbicVrQmcl5+b2FabnjmGsRBUDZuQ9RlNVnCmf27e6zJ/r0k+75EXK6egIzoET/OmLX+XC62/wUx98H287oThQdzjenOQHF/bxh1145a11usMuR8suDXKqo5TD9XkK1+WyMXQnjrK+37LlLPLS1Wu8n6+ztdql3Nohsw4dv8lK2sMW2wxjhx0NwpFM1VyqYkAR+/SGY2epYS+nMygIXMXszCSpENTrs9Qakzh+BS09nNChXglxfZcsS8bJpabAQeOFPmWuKMocYyVRGOAGEXlWkMYJrgPJbptKCovAoPOMPO6jygJtFAqJsgJdFGS2g/QkwhTkmSEXGtDgKALPR4rxxE0Z0GVCoVOSocbRJeQZohDoOCUvLZ7vMRGU+NUavgeVSovC+GQ5YFPmp+rUJ1pMTIaMuiPKUU6ZxASupXQ83KhK3svIigIcSSWsENYqWD0GNLqXUOYG6/jQAxGBSVLMYkx84TZbb7zEysrz+O2zlI9/Bx95bI7BjT4ME+ptUNMTrH7hDTYqhzkROly9dJl7YpN/fOqnkZ0Rzv6zCL+KrRrwQFQFTLjIaQeTDyhtwdpX32T5y3/G8spXWHMr/Mx/+QMsv1nltxYPcfhejR98NGTfvI/Z0RgxvmjsOcW4agzkvKrPP/4f/yn/+r/+Ga5eehFv+yC16VP0Vi/i1Pezb/9JDvkdpEhYXL3EcJhydmaGswenCKMqw+46o84yGzce5BxkZsScp0iiFFUdMNkaYjOHi39yk2imxTA1eO0mgSxQVtAvx3uwNIYyL3EVzM1Ostjts//ANFvbI6Jag0AbdK/L5JGjXO/CRCGZbbeJtcZ1XRq+S29CUfTvsnX1VU4eX6CYnOONapud/iavfyPmHT/RoBqNaDiadgX2Nzxq1QOMtlxWr2Wkgz5xL8ZYDbqkPjuN/miDvLkIixlsOtiOjy4KGPQQI4XzeAO1zwUlIC1Qrehh+PLtXCL/Vtaezeh9v/f71i27IEqOYZTZdWvZu88e+pa7YVTGPBAkS/sgk2GPssRuFsEuwYL7VI7dx5RCoM0DMPot4k9rKcoSY+2u85z4lonHX//cxl/EXmGgDcNSMzIAmrwwfPnaBi9+/mts377ExERGY3aO2sRBdl56hcmTjxG4tTFowiCtJY9zjLOAUBUKq9nIulxd+iZuA5x4hZ6QlC7IwNLZ6rEVL1OvzpFqF0cPqTsV6rUQOVVjaWmL+ZMxW9kmLbfFoWiOLGzw7O1FFu+O+Mj5x5lsaOY8j/nA523NBq+nlreWdjgWFjQE+FLiloamU8E4DsMC4uYBOpWYu6N1est3OH0k5cXnX+OJiQi3qCIqdRZmZngh7/H0uRN84/JNTj9yhPWNLa7dvMNwlFCWJdYaxvR8fd/Jaq+I/Ye+dmuCsTvTbjbGXqG652Q61r3vagus3U2FfjA0k0Lcn47dTyy3dtcW1vArv/or2MLwkfd/J57wKWyOLxR2qyC9ukrn5hvE/U2cyUNkpw9wqGUItn1c10Ck6CUJy2td+pXHODLlcfkrL2Ma8Oh0iCgtojoxtgj3LcKTWCuhAkQCUxRYCf1XlhguXqA7Wqbcd4DHPvYeBvccXu1LzlQU8zUX1x1HECjPYg3j9+re+bYC15e8/cNP8Ae//huIRFF1IqbbdQJ/nBdFq4LnjAXcCnXfwrjabJKnKcOtTZSjiBaX/sbz8m0VB2v5JgOtOTRT4z/7kQP8RljyqV+5Qpkpzp04ycTsfqb2V7hzaZmvfukCv/DUI1QrdZIEdGZIwzozVY/R4tdx9p3BAGlS4qYlwdGj/Om1VZ6c24ecrCDxyQcOqhBMhRI9WCHPU+gWiG5BK2xR++j72Pl3nyeZsPzZVwUtV/Kex6BWGYeL3SsL3vWJSfy+4sblkss3Q1a721zRd3nixFN4HwH9YkmxKQiq+8hWGpiRQBRvYdLXcG6FBJOHiA49AkmK3rzNYPE21ASiHRK2mkxMbCCCOre3JFEtIKoFSF8y6A9pWMP2vS1KI6nWxlQO1wEjBdZxSI3E8xwCLyAQDk5ckCYxOAG9zghbZFQrPrXIo4hzjKMImzVUIdnqp2RpQoQGqfC9gGCqjut7pHFC3B8StWc5cNBj/c41UB5RRYGFLC7ACnRoqbSbIA3pTocyTRBhFeEqEAqRFbiA9BRO5KJ8n+HGBnFs8JSLu+uDbfOYpNOnNC7K9/AnJnA8B52MSHa6JJRMTTSpA0kJubEIWxKPhogiJpcu/aSk0xnSHyTknsNmrcq94ZDnPvUfuffaVZKdLpWT0yx84r20xGN8/df/V6pmmw9+/BBnH5tBWQ3GoozDkAFp8xBJrUWn7LLR/zI3Xkl4+kcU1RnBaGQwCrxpwfC64dk/ucAHfvLHqOw/Sjzc5MbyMvvm9hOcmSO42ePqlW9y7MRTFM0pnn9tlf2DV/nAe6bYtKf55c/fY+7Ll/jupyJ+9InzONEUn2hUufH4DPGgxu2Veyxdvs179p9A/af/yP7v+jBPTVVZ8wUHjk/y5D97L//y51/g9T+7g8wyyqIgNobRbvcjkBAFDtpx8UOHe9uSl68bbJ7ju/CB4028QmIzzUbPMIxTHnnkURrNOr1OhwyXaqvFVLtCvR5SloZatYJ0fQwGrTPKMsdXBoskrFWotRogYGe4w2h7A1tpUA8DlBuMR7GiRDsuldYkyyu3QTl4xqJcB61hlIytdE3pUMRDsmSExOBXqngopKMYDDRW/9/UvXmMZdl93/c559z13be/V3v1vsx09yycjdRwhsuYFCWRWmhaghLIQuREQYDYMWAFhoIYQZAgQYw4TowgIJzYguJYlsxQIkXSChfNcBmSwxlyhjM909PT+1pdXeurt979nJM/XlVXk1owCSIr+v3ReP3q1a17H86597d8F1DKw281Ic2Z7MB2NqBIMrLSgBsgVQVVqTGxU87LodkZojCiSHMmvU2iaoRIJwjdwAsUrlPi+R5hQ2EyS+92D1dPvReyOCZUJbYqEY6HGQzJBxLtOCgczHpB0U/Y+eo3mdy9ylpZotvzPPDUr9F5zwn8xYj8Yp/28hg7WKX/zi0uvNBn9thp/s5/8Thf+ucvcWYtYWlH8/pvvUDuHOZ0sEHjZx9DRD5YH9ELUQ8HMAt2JOh9/nW+/dLnOXvtOzjK8oGFRbynfpVTz3X4Bxtw/orm2z9IOXQt48kP1abj78xirCZXljSQ1OoCIWFx1ke5Bl300bFDNqqCoynjHrfTLeJKQdcvmPcl751vYIIh568MODWzwMyMix9GXD5/8979vpetsKRnmOs08YIFzvqr/PG/eA1MhWeqTzDTajEsDVt373L+7Vv87NEFhFRkmUBLB9f1qDtQbG+guodJbIGTaVzfo2i1eWNzzIlGDWrudLQ/sUgNFQUmGzEajYh3xoxXt6DTpPHEM6x/5WsMZuHVd+BDpz1m2iW+B74rOXkyYHxonu+9/EPe88wTHHnwYawVOG44nWBVfdSHj1JeG1FeyTBrCnIgXofJTVzvJML3sWU5JRb+JcU03ZvCbaYJ9z751NopDJBd47F9MvJ9FlF2j5S5n/SDuEdClntd1l2UilLqR5IpdqUyDdzjMOz97p505JyglaEAACAASURBVBQDv8sTsNMptxD2zy2hhJimdYHr3zvPrXRCMo5JXcVmmvHt777EjbfvkJcxy888yIHHH6BmZvn8v/oMR6IJDz/7BDOtcAo/shZhJCkTdHiEQrnkuk9vdJ1LlzZ55kMVvKpBjzRuKHGqlv52zLlzb/HE0x+mMXeQgdaoeES94lE5cRz/xjpXbr/JE8few/U7JedubrIwV/Ls6RY79iD/4wu3eOJAznsPNTjcmQHh8kQQsXW8Qxmn3Oz1EMay7FUQF87ReOgURzzB3SKnfqLLvDrM1z57icvPX8cbj9mYJOS5ZpL22On3WGq0GPTGHDt8FOU6zC3MEEVVttY3efXcBZxpU3m6QnZVeKRSmL/i+KL92vY+SN0ev4Vpwbt3jXvv7ZfD+3C2e9OE+2B500LbkmUpo+GQf/iP/yFvfO9VfvknP8k3X3qRT7UeJblzh20EleUFOo+fIjrQxql5ZLdHDNp38cYp5c0Uhpqn3/cxogfmufgvbvLYoUNUtjPWX76FrLZpVVLc493pSfVc8BVyXkGosLkgefUO77zxNcb5gFqtwnKzjbNwmu7hgOe2NStrhpvXCzotSaOjpt9LARYDWiIcwZ5YWr3qkGYxDzx4iKNHF/E8797+LUp9j68B3CNrA3hhQPvAAay1eJV9jtmfFe+qOCjTgDSxpH4fz3X5Ox+vku58gG/94U2ur28RjROcaot64PGd177Fr2w8x/GqhyNdhALpRbydbXHw4Y/z8iuvsNwWzFQrrK/FVFzF6eUqt3VCtAnNSGJDSeG4hK5k9a0/Is8yRKmpZynHfEVk5ug3D2PCId9+scdjRwKeecrBD2LqyhIaWI9LkC7FyRp+K2IxG9Mqr2PSgwSdCjx2EHcMsqKoz9bILydkV+vY3kWyweuk3/wuyfXHqH/8QcqKRM63iLfuUK70oR7iBD5Sa2YbgtCx2HhE3C/ZWI9JoxHlJMcLKlAYiqQEHzyliCcZjmuQylKmIwpjmRQG36+R7myjC0FYUQgpSQsXP2pSZjFmXFAYSb1bJwgaKKlJ4sm0gLCGnV4PpEtQa+C6Ffx2i3qhcaVClJoinuCUJeNewuITj5H3+/hSob2Q0uZIFdHszjDZGZKPDZNC4RiJG7mI3FBp1cmdgsmoj3YdPOVSTBL6vR1KJ8Ctz1JQYO2UxVGYDC0d4smYKPApMk1aCvwwIEljtta3yVXAzbUdticJg7xgbXvCyuaYlUuXGFx4nXw4QkZ1KJqs/utX0L8QYiiIRYV2rcGDnSoBOXfyIZVkg9JfZD5oEjrQj7dYfet7jMeGA0cC7lzIMBWoHYCDEq5fN6SDW/hmg6K3iR0KlD/PrdDh5MIBzr60xeHqJjvBG3jLj3L4A0+w9p03Oe04zLVexn2yw9WtRf7piz7/57/5Bs88+SCfeuoQ426HkTZE1RZnZiNev17QPvFe1r7S49BxB/9kg1Z3Hneuwqf/p/+E3/zN/43GaIckHbOZa5LSog3EpSWODUJkBLmD5zpoIM81Mja88PbmVJVEOYShRy2EhaNdpAtaW1yhqHoBkVfBsYJ6fSoSgBRY4WCFO72BjgYErRrGcTAIyiJDSGhVHJJswjgZMhplOEgUMEknHDh6mBPHZrl0/gajwiX1g2mXMR8Rzs9SSHACB+3WCFyPWhQyGsXEqUIrFy90UHbqDF5mCc2FOdbvbiKlg/J8HK9CNfAJGlWqKkRPxuS9IXE5RPhVZg+eIt0eUT+4SDZKyRON4zq4rkM+Khhs9DDGJww9KsriSIu1gqQXI+WQMi3xHYUf+EjlkWzH3HnrFqkesOVVOXjqFMffc4bKgQpme4AbNtDxNtmtGySTbTIkhx5+lKVPfAhTaj76d3+aG1+Dyy9fpX+zwTBe5br+1wxf63K8vczsQ+/FO3qK8gsrNMqcNy+8zit3XiUqC5rBPMnSHI/8k/8e6VlWzuaosMLcfEDnoCRqw4V3YjqBZv5UDb/u4CgoDPT7mqghqeUaX4YopzLV8fZzirFm/kAHMyxJzIBcuERBiCgbDLNtrm/v4GwNsXGXxvEmDz5zGl68CMCdW5rF1oBWw1ANmrzveJ3i3/1rfPuPrvH2lWtErS6BdPBFyYtvvMpzH3mIejTFQgspKaXDmk3oLD7Emxcvc2wuJM40aT/DdXwOth02bEk4SAmcgsKReKGHsCXbq2+QiIiil9KSiopfoypm2Jl9BO3v8Ptfv8ZDh+eZny/w3Am+EHiuInAtJ4936Hab+H4FJR2mkiS7GAXHwTnRxDlisXGJHhQ4sw9i4pjszbOYd0qchQP4jx/7yyN5/mnwabE3DTCU2uA400d2qfW9zv5ed1/fk3TknizktAhwgCm/Te/yBOSuIlFRFPsKOPclaXuqkXvHukcJFQIl9omfZVlOYUZ7RcS7uDwLRL5LLVNsrvf45stnuf3D1xgPM2YOL1FNHQZv3MSckljHsiNrNCoRLU+BLUl1jltOsO4sLcdHCsNkskVv8yo7ccHcTI3Vq3cRbejMWMrSsNFPyOKzOGZMNhxQDTqUTpWUhEP1Bd64c5Uz3TW25FtE3dPY6iyDO1sckmPq4Xnihxpc3J7hnVdT5rnGI0dneeSAJQt8RmlGI6iiU8u1rZTMeBz44ZDu4Qb1TpUdCbPzh/kP/6O/we/+1hfpBOuM3Ix0kpGmmrKwbA8MvSQDZ4d2UkM4ilwb/KjCs4+foRVIvnX2CqMkn3pbKEVW/HlE8L8a8SPWIXZ/hewVyIh9KBzsQYvkfTYcAvSenpHY/9fa6doEjJ46IRdFzuef/yJ/9I0vY0vLl6N/w88c/zAf+djHWH7gAEHNh8KgqgG62ERtjZhkKbmQZHMh+XzIy9//Hs/9+nOs/tE6YxXgpRWS1XU2Bi+RvdzlyPsfxZmdx/Qs5q0RapiycXeV+CD4URO6M9QeOkr3fY+BhP7tEuEpOl0H5YNyLIMdjacsUddFOmJPifiefHDVVfz0z3+cWq2OLjUy2MdSeY7zZ9+/7ptIvhsO1bsqDvzAY6BdNq/ssPPqFa4MFc+d0TR+5hRf++o73L52i/n6DnORx5U443/5wwv8xq/MsDSTk6Z9Ntbhwyc6XLx4k0cfPU5/PGEwyQiaAcH8AmQlxxaqaBFgJhm+KXnwsE9eFLz07R9QaEujuYQbdfEpOFYdMGkJUuUjrOLVC5ojb7j89Q82QFo86TMXemjvIFW/zVJFkK7ElLHi5tlXCP2DeKYyVePZuEMjz/DnPJRTIIZd8pt9xrfv0Fs5S3K2QCqHPB9TypRCZ9jEIBpN/CigED2yNMNaDdJS8R3CakStWiFsVads8qJECE2JQgkDRYpgSszypKBR9clw0EWB0iW+UPjSQxqF1oY0K5mMd3AkeO0IEQRTqIeBNDEEVQ8lHZLMoikJG4pkWFDmPo7vUSQj8olBiID6gUWkcDGmxBYFWIlyI6wKSeMMR0rGeYFXq+I1quC5CGkQuEwmfbLxAL/dxPUD0klJtVmhDEIKmzOKJ1M3UV1gTYajpkWUkZpq1aMiJOUuPnmSF5SOS1zGjCYDkjgh0mPM6l2S65cwkwRhNHrUY3xlB5Sl+J2MYnObzvtO0V6ex5M+I+sgS0WhQ4Tpsm6q+KUgnQz44ZVzCCQHtOQtLe4VLndLS9CFnes51+9+A2naeLKFTXv4Yx/VPo5fvUTuCu5ubbMQ3uGxRx7ne3Mf4q1ygwWRcKRM+ImFjLzd4CvnLC9ff4dLr52nM38A58QMtaZiIZ2waCrMuxnbo1Wu//E7RFdPUn/iAcLjNYrWB/mFZ+7i3LnAaP3SVMrSlZzPJQMLq1sjdrKEwlqE0XhKIAKHPMvpZxrHsXiORTiS2EjyQjM73yDTEUGzTaPTQmBxJAhjsWKaMIldRRCEod5eQOuCOBmhk5yyNCBChN/B6gllPsTDUqQJcZZTFJp4sEOz3WB2cRasRlhDURQU0icMI6S1KAnxOCUeJpRpRqMdUVERRWHQBcT9McOtPnlR4NcCFmZmiDOB60X4rofUGeWkYFRYmoFCqohKNaDSrhM1fNAl8bjA7Cp6CKtwHQ+Lh+NonIqDHzh4nkIIi0lTsniEtXZqGOQBvkX54C9F1FcVjfljLJiQeqeFf9BDLdUwxmXw+YvEV7/OeLyB+8CDtH7mo9QeXkBGEZufu8S4ZWg//V66TzxFspHxwv/6z/GdNgPb5JWNm7S+d43KGz7XxiU7WcG8LmhaQxYdInjgUY489TjP/95FjrcqzD7zEF7gUOZTx/VybKg0HYK2YnurpJZbgkgiXEElkOjS8If/+F/RuzMAtwrVJtFch+HmFYreNbrNw1jls1RzWKhE3F0bkHUcPvmRZ7j6+jmubPdYcGOC+X0TpeGwpJ/B3QurrF6+iIpqPHA8wz5zki98/ltU726x0GkwEwVcTlM++/11/uYHKghSkrRE54Kj7ZDtrT4njy4yihO0Ar/u41Yq2NIy3/Qw1iEf51RlTlsJ0szh+2++QVCvU5k7TtToUA/hcCUmacAEH8cq3r5V0G5WODRXQwpwVYW6H/DTP/Uc9ZoDdgB09h+AYhdAIwTWBVFzcSIHq0tkPcR7+DQmLxF7Hbi/NKjGfenz/QzMXUgRu0n8fl603yW1dt/3QOypC91nprbHobjHKbDmnjOyNXaX/LkPYZhKRdop72y3+IDdaQNThaIp9ONHz+nPvLL7zlUI8F2HuUYNB/jq9hbtMKTuejz3+Cm80OXF77/GzZUd2Bmx/Phj1GpVrFAUZkr0tNZDUKVvHQJj2Yo3uda7gsKnawVnjaIhNANr2FEatwY7qwnrk9epqBBlS0QxwVUGp3qAoNYkEZakt8aR+hKd5hI3xk0upn3mKmMeEBlPLMF6TXF9O+b1uytcOHeTVqeFWq7R9CwtDU0sqUwRyQYb310nfOAg4WKEjCSDieZDT38Edfcqd66+yjGRY1yPES79tGRns8/meAerNdIB31fkQUQytox1xnvOHMEiWF3vc21lnfu77X9VQ+yaT3LfVEred00/en0Ca/WuxOt962n3Z2J3smL2OBm7YbEoo7AaSlMyMexOwg3fH7zD+yrPIlsOouJjBiXpyxvo6+dJB1vIMyeonzyI362SlSWPDSRpluE/dZJWs4McliS3VqgcOMJo5PDW179Le6FGYQXbvZjJpKDrS6rUkceOM398GbdWY/XCkMhVhAc7CCvJCyh3RUKkL3FCSCYW35/ylHEsdk/rGDh15iRCStxdNbV9P5P9q/6T3/UeTPHd8VXeVXFQ5CDykNBYhuUGb/1gxO2rtxl6EUUQMrN8kMVIcWvlNmYCq2cvcvt9x4icDtbkCDFBBgHt+Rrnr2yTKFDtCp4tSSfncKsPID1NIHOydJuImINOysqlL7L61i0836NaDRDCkiUJbbdKdPQ0+cZlHLa5favg/CWHn37fAkpMQDi4MkCKCBV0cWshm9E6Oxsp1UaD0FO4ucYUKdlkwrB/C3cCYT1A55KiUqFs1jCOxcQ9tFfZtTYvMWKqJiNSi9+IyLMKg96uUpAjpglJIAgaLQQanRcYBI6QUGYEQYTjeDiOpSwLCg0IRV4IAkcTOgJZWkSRo5RlaocikEU6dfAzGmUFfqWCqwKszkB4mDImSwpsnhMMCyqBJB9l2CSZPl+CCFdKZBjgVmsE0pCmMVIbhFIIW1AWGZ7rk5QlwnhY60EhSbTFo8TmMa4xkGRo5eBWw+nDxOip26AUICxaCozrgy3QhYsKFZ7vgVKYomQSD0i0JktG1FxwWxFFLcDkHhtXVrmlFDqaxQekyNB6RFoY0tsrUKa05ucJWm1KKxDWoPOUYTmhYnOapmQ7H/DG1h02LvSZnZeMpEPRdEi0JR2bqRfAEYG9ATZOscahUCGZkNRHG4xNTvVIm8HWgChNyeprDIY3eOT0HN85H5Jv1ynyAYnZoVFT/Mz7jvP6D2+yWfZJr1+gaWP8xRaEmgkZW9ev0z14mq21ywzPnkcnJUv1RwlrbdpH3sM7l8/RxWPRa1IXiqXQZVUMGIQz9NOckc0pnAJHlUxGhtkHKtydaFb7mrKUNKou7W4FP7B4gU+r0aLbrRJVHEgTlNRYI0FItNYYqzGWqUSeFJRZiSk0Js8pc02uFX5QQUnBelzie/lUpSrP8XyFIzWl1ggyMi3RpYXC4kc1hHRxQge/UCTjFIHGDyqkKeR5AnmJLTQ2zaY3H+kg3YBqVaLH0/MUwuIFDnE/xmaaRFWQpcZIjZtojFswGSQYcvIyx3UcPD/ADz3ycYFVCilK0rREqIAwdLGlRJceUmgsORoX44IIJEKXqLaPq1yiaoegWUW2fAhctKPZfudltgY3aT/1BM1nn6b6yGG8uQp6UuLMFUR+QW8gMNajfcjl4ceP8ebbJe//lV9g9fW3Ke/chmKETVc5rAtEtUPn+NN0Tz9AZfkg/Tzij7/wPC/6m/z6maMsHq1QqQr6O/DyCpxsSToHBGZsiMcluhAENYXjK4qi5PsXV9lJJE77IPUDB5hZ6jK6dRmTjslGK9TCgEy43CoK3EhyZLZNKDSLRxZQOsLzMjYm++oV3/3WFa5fCfFsQT7K6Y1XuX4iZiwzYl2yPDtDFLmsrN1Fxy5bF1boPzRLJYI9GSzlSCpVjxvrE/AdHF8gTEpRjJH+DEIaHJ2Rln0qvqTKmN7aDa6/fo12p0qtGuK4CscKKjIkmjtIMrhNYBU3VlJOLHVZbLcRbg7CQcmQdruNEoDNwJopUPnH0lYhBCiwSiCEAiVRrSbyXXS+/+LD3sNfG2N2OQb7CaAx+74FeyTh+xvH+/wAu9tx3SsQJNZo7jcyu5+EbIy+RwY1xkyTkN3Xe9MCIeS948I+7ElIidiTQn03sTvJUVIiXUGnXuUTH3ovuihRSnDowCLGGkxR8rtf+DpOkrM4N4fn+7vQKoPWmtwUOBgq1rBVxNzq9xhu9VmeCYgJsNWIQZmQFRbXc3BnJWJLQF6AqGOUD1hkPiETltrBWTbWe3QalsloDS9YYHlukXfuBuhhiK1mjPUmUdTk4bDN7dUdNtIdyjsTKv4ybt3FOoJSa5zJmOr8PIOVW0zeWqGSz+EfquI5EbWFQ9w4/yaz9RnqMJ3AK8VWZYdRPaI3aJB7BcovwGrSVFM92WJnUrC2nbK2MaHU5T1uyF/xwcE07lPCsrtTKmAqzoLcHQ5MPTemH7f3rX+zn+v+WM57P2dnf+1Pp17aGLIyZz3epvQsIlAYJShLzeTKZeJhj+jRU/inDqFmauAKqjogaW7i+5qeFtjAodaoYJ88jL/cJCwc1l8ReFJTJiOcPGVGGeonj+PVFqgemcdvNdjeTHnnrRXSvM/Hlj5IULF4jmRrYkkSmK0KQlfc4wsZDUoKhLu754BKVJlyi+6fAvzIFvxz9uO73KvvTq0otZR3Df1Vw8U1Qc9zubBeJ6xqRBhRcSoU+Zg41cxXGpSrN3jp69+iiE9x8OgCMw2XpMxpz7eorWzjmhVUkCP9AD2BYRVmPY3t3aaWbTEbFvjDO3ztG39IsjFmbukw9WqILQviUULk1Oie6DAerCBcl1G/4PZtwa1BxAk57ciXVED4CBGi3DpuNcULE6JGDSfOESZGyAwVagrdp+yneFGbUhQUnkRHHsq3WDMizzVxMibLU3AMKpCQZrgVDyMkeIoiLynzAiksYaEQUlPmGq0tRst73RqBQSmBKUvK0lJoKMsCP6ziOZZqGCJwUAKU1GgkQme4tkAoH4nAwcH3I3KToYUkT0uKVE+TLqtJ4xJlHbCWfDRBuQ6qEqACH+EIiqKYumAKidwl7kmdAxYZ+IhAkWsXm4ApDEmcUKtkCFuClEySnNRKwnqIcFxsNk0ynd2HrkZSCodxb4BOM2ozDYQ7HXelpZ56H+QJRS5pVUNkVZCVmix3abVrNLsLjEYayhzfKfCCFjs7CcP1FaxwmW91CYIqo1zjoBkOxrgRWNchK4b0km3Wti9T3i0I6wrtuqi6Je1ZRqMCo0HMS8QOePGYvEwoPYn2ffQgpugPqR1u0l/pIUYJcXvEsLxLXVxhuXGQXrHA7a2Svi44EJa0KoLDcxWsGWFev4B+p0/cW6ScqROHAZW+ZuxDFAIbW2TnXMYzh2g81cWdOUBZm6PMRgwmQ0ZxQU0VdFVGo96gFUhy1yFzc4b5BM8xHG06zIWCWVfSzyReI+TUyRmWDs1SazdZmu/Qarh4ssR6Aq0NQhikgiLNSdOCoiyxlGhhcIVFFwZbGExeUuYaxyhcKaYQDStQOsMt1BT3WJaM+mPyvKC0HhaF6wg8L0DnFukqlDNdD44rCYKQ/jBj1BviGAvGoJQkqkVoA0Hg4TgKJXLSLMcWOU44dYp1XWf60FAOpRXkaUHpF+i0IM0nGFPiRRWUsFgrSfMS15d40lCUYt9h03OwhUWhka5FOGCVxLpT6IIJPaRUyIaHbPmIyMVYyPtjLmxdxm0ss/z0MzSeeRi36U2fOZlBdGIi32WSw6Q3odATjj16gM1ug4MnHiLftNj2ElHTolYvkv3gZWaefj/9ztNUTx2mO19HbcZE7S4vvP5NTrz4Kh9xnmT+cJda08VsC7bH4EwEC76A0pIbi5MbjBakcUFam6P0G/hRlXZnkYWZFqODDyD624SyZCaqoHTJzmhCs+rQEYa1tS1atYhGZ5HcK7m6unbvfv/aD25w8ZxHp1Wh3gzpZ4aJbwjrI+ozbbx6RJJn5IlmPmyQ3LzFK98xPPTwUaqtiMCD0moqtRBva4gUq8RpDriEYZ3UMUQ2pxxtEBFTk4piPODSxVcZ3+1z4tTDVAMXXeSI3KPiVeks1hnEmyjXY3uzZKOnGKZVWkIjBBgqWJzdxBb+ROfs/gfiXrfRUdP3d6E4f1q37d9+7COq70F5/pQH/Z+WjIvdxFvvGqYJMSVvThN9C5j7kqndScRew3FXAWmvaBBiOlHY1SPYV5W5J+Y0nUAIe++Nd3V1Yu/EdsPzXN77+Jl7+1QIQVGUZHnJ5774ddqdFovNFkI4lMaitabIC6RrsVJSlDGjYoPJuIeYWKJqiFEhTqXOaKJJc4tVFtH0UKnCTYcYW8e4DlaAyTJ0GlNf6rBx/Q5hXpB0h4TtbRx8ZqMmg6LFys4WlUrBnCzoerDQ8ClmBJy/ijE5g0aNcdWn5rnMW580g7AK8Z0diqsBwgmpdqsMaxV02MQvDcXOBJ1pXJnRlhlRvUlUE6iGJRcxcTwiMSXLMz5Z3cHRhsHOGNcRBIFHaXZXx15mvP8N/5UJa6deGrAPW/uxT8AuD8eYaZ7xJz5j95PkPw0yI9jlIFhzj4hvrKHQmuFkxNs3LjF3cIn5zgLD3g4bm6uE3Tk6T54hWGig0RRZjrRgKyl+NJXnJ8+RoaR1ootcnCMcQHokxvcgzMf4G3exGxvMPXaaXtLAaUYoz0HKksJI3ry0wskraxw9OodX9XB9wbiASWawmaAT7rqd30+ylvvXdv/rv4h4d8XBdsnK93u8+MMdXh55HPnEcVrJKeStlHxzh15vjZXVTRphm2d/4hmef/FVvvQHn2Ww82F+9hd+jpkZj7ubKzz4+Gk+8uQCt899la3JZWT3EerHP8nLKylBkpLceImOXzAjfK6/c4fPffE6QggOzCwQBRUoJeN+RjVwODwXsHnRJav7lOOcO2ual64kLJ2u43uWQlQQ0kNisEYThSHe4YiinxNvr6MHGSp38WQdr2qxVqPTHUoshcgoTIYsS7LckJJTmISdwQiLptH2QDoUvSFZuTv+s4ZklJJnJb4CX21AUEMpD20EmdYox0fkOWmpiYcJOB7WcSl1ytysh7GSareDLEpsXk51oa0l1wnsjlOldRA4oCVFnCODgGRnRJkafOngeA6UhqKAqOKTDIeUeYwVGuEqlOMyXl/DC3yUW8GUKSYvEIXBcQOscYmaNfSkRE8yUisY9LfxDnhIzyPFMkotIi5wHIGMHIyVGJMjcSmFS24lWWFYX98hqwlsAJoSjWSQZpR5SpFOcKM29XoDneck2YDMQqXVZumgx+b6Ntlwg2oU0Zmfx/fWcfIMxw85ObNAwwkZJgXSFmxtZZxqtRjLCpf6q2xsnMe99TauESTKp4qLEhJbWrIEBoVBdF28qMTs3AFVw6kt4gQO+bqDv5kgjtYJIo/41oRRL0fKAa+de51PPPM451cFV9/ewHOruMUMX3vzGmcORbhlzlb/OhubF8mvzuJ0j3Jq6RhPHzvCa69c5JGOpVN36K+NuPv8DXQjJIwaPPb+n+LOSylX+28zKgrKrR2OOw52nJA5CX5zujY2hzBxJG/dynkwNDzW8BlLl7xZ4ZnHD9I88xi5N898vYVniinHwKuRZxLPkyhHUmQ5k8GYNE0xNifJM2ZmZ0ALjJ26Too8Ix5l+JGiHYWM06nHhedNu1XJJGUcpxgvmGL3PQ/HdbGlIY8zpAtZkmAxKGfqzyGkQufp9P9S4YUR1XoNITROkUJuEIVB55qizCGDIAyoerWpYoQKkAhcBdaxRFFAPNkhCgJ8qzFxRjzOmWSGVtXFVyFCulM3TVGCuytlqQu8SoDwPFCSUlus64BSyIoLoYUArCcxRUl86w7fjzU/+czPU3/oFMFSNO10FRqbFWgRE9S6LEQh45tr9M6eZfZIg5/75b/B9z/9FitbI5aePc7xn3yY7rXbfPp7r/Abf/3n+PpZuLahUC2f0483+ZvmE3zzhy/we5/5LPXY8MGffS/zj87z0TOS77xiuXlL89xRQbOmEBrKwlJkmtGg4ODpR7iyegNhNV0p6QY+5ZlHcEcFzbCg4eWYnR79mysMRluM1++yXvgwKfCiJVR3jlB49+73m2tDsshDCwfdaNN+oIvXOEZDNPCFYGv1LmaUMTdziDOPPMTXX3iLz//eqzjOL3Lq1DEcZRnqEYtHl3j0SJO7V7/E1bURTuMU7QNHuTWIMcMUs3WB7Nz0IAAAIABJREFUyPcp85LVrTVefu0mrqM4Or+MqxyScUbgSJpVH60Em3c90jAgnSSsbhes9EsqMsJRoJmqoIWhi6v86VTgz0qU/sxE9i8/sRKAFQIpp8TMe4n5bqdY7qq57Cm0WMs9wub+VGA32drVd5e70B+7Z0bLfrIxJW2y63i8yy+w5h4kyVize4z7VVPYLRrsPa6B+X8zedklKvue9yPvKaVo1Ko8fOokc7MdDjeaOCiyQmO0psihEQRkjsudyTbx8CbeeJtAVEiUILA+QjQwZcEkU8RK0gxDPL/ETFaAJtLVWOtQZhZ3mOHM1AkCl531mJlDKVneZ30Ijx1e5uaO5crlLeYOdoljuLCzxXI3pDrnsvX1K2zfXGfoNwjaM5xYXubo4QVunrvDiQUPuZ2QrsVkNqHyZAvfNzz4zAfZ+PZXGCRDsp0BcjJizpfYOEd4I7x6gziVDGNBphxurcQcrGgO1hzMgebULCuoMBjldGdnd4cxey7Z977G+1bU/3/DGLvbAZ8Wn+o+Ai3sr+m94l0g75tegRUKyy7E7V6Rz73Jwt4GMrvqW0JO99B07WqG8ZgvPP9l2jMzPPNIhUsXLrAzKnnyw08TLXem8MNdf454e0RU8xG+Yu5QHdEfU/R2CNoVPE+xemGFiSuonV6k3arg317gna98iwePHODu+ZitPszOSOaXGpx59DA/fP0Sr3znLFH2KPMPzTFb94kcWNuaclC6NWe67+0urHD/i/jxl38h8a6Kgy9/cY3KbER/ucHBT5zgo498is/8s3fY/ObX0YMdJFAJKhw69gC/+uu/zIXX3iAeeVyedPk/Xk6487n/gdHkGt944XeIuiFriU8ljlgKO8x5IcOVP+KLv/8tfvHpkMZCm1fehN9+/hq9WxlSucxi6TY7VP0WSSxpN2sMTY+lpRrreZNxrrlz3fD53x/xzH88w0JHoaVPUaZQbuOUCTL1McYnjQcMhzvkE4GvFK2apNosKaQk3d4hGe0QD2MyXaBdiXVDstKi7VSjO9clxtXkiWBhMaJSCxHWoIyDG3n4kYO1miKGICzQSuL6dZQTMdnp050LKXLLoB/jljmh72ErTeJRQqXVIQxcyrggGyVom+OEks7sDFt3x1jtgPDJU0OZbFObaZHGBcJ18KJo10zNpRwNUMrFKChLjVev4wQhOrMYWxA5HsoLp8TVSGLCklyDU62yszPBFAYvK7FlSV6WFGmCKErmFxYYZwnBKEEIaHUjwEH3B7tmZi7aSMq0xBGKuYWQxGjiNJlifnHIEs0kzoiiiG6jiu8EbA5iNrdHpFZSrdY5cEyi3IR6eJr2TIMwUhxsQm9+nocef4gzZ07SDSq4eUGmBEHQ5FwWcDyq4KUj1l9POP/8CrJapfp4gwvvJKxbw9itkNUKzFZMTUY43RFrwwVajWUasoEPZI5LKF1GcYPZw13SPCG+vcEbn32ND/7ip9isF+i3LzCnN/HiOdKkxbGH5njnzfOIYoA2PpvJiHH/Bt3egCgNWE1vEThnWEs96vktqmKV2aLO2ncbFEerzH7gKOff9IiW5vnA6WO8+KUXeNscZkZNOFVdZ9PEZEg+cqJDGab81subXJZwJIb3L0k+ciikdmiBaOkhrOMRKXdqMigcJN5uM9Kgi5J6c2o/H48E6aTEsT6uo9CixOIg8xIHjetYAtdF5zlOURJIBxFFBK5DnIATJxR5AjoD42NtZVoYCslgfYc8LxDSYpRLb5hTCTw6nTbCaMKggu8H+J6LKy3jUUERj/FMhishdzxK6ZAULq2WT7NdoczB8zw81yHZnhA4gvlug2ojBL07lStimnMdiGPs7nWXaU5ZpECJWwux1sMIjUSis5IyTrHSJ6p6uIFCSosxGm1KtLWMxhM81eXB/+AYzVN1hJoiVqwx6GLAzCNPkW5sk2/cxZNXOfDkGv5yG61G3Dr3j7iYzUH+SxyvVimac7xNi9FkQlBtU2oHnVnwFUc/XOPgzMdZ3fwdPvelf0YeDfmpxX8Hz3XYumvoJNCvSnRdE0oIrCUpYWeQ4tQSlhfmCAtNVSjurG7yk+85TO/OKp3FOQY5uAtznDl9ADnY4tL1WwQTyyCZMLl8iUbRYebwzL37fZ5rejrDnRXMt1rU7AJnv3EOtb3Kwe4Ckesws7DEkVMP8tSzj/H2Cz9gkIdcGEZcev4a6698F1Nu8t99+h/gVhxM7PHgoePUukdBFyTbF/n2C9/hp57u8n/98QXuZg6FCujfGuP5FeaUwqm3ENbFWkXoOdjhJgc6EedueLiF5fL1EuXFdB+p0W74oHzOnbvGqQcfoTLb2YUU/dUNa0Fbs1sAmH1YxDQjgl3Vnj3IxF7s46/FLnZb7EOR9qAou4kSUlIWBY7j3NPPFwiMmc4qPN+jLMoppEOIe1Kq2hiUVPemDD9+Du82fnyKsBdSCmZnO/zm3/v3McYwTlM0U5GlXCpcN2Bdw5zrIguPW29tsL62jalGRIcWub0yoU9AErTI9QhRltREhKptsz1ZJoq6hPioqTsinvQYZQEHTywyKcdsXLpEmcKDTz7HyC+xo1UOyARVzuDXm/i1gpsbm0g9wVLn1voWouzTGFoaXoexvI7vH6CXOIS2RyQ1JD6TSw563qf+wCxvfWHM0SdP4WO4+eplbtkl2m7MgYbhdjqhWvNZXl4ilRO++spVbvmSpXrAY4caPPGeB7ia1njxlav8vb//GyjXUugUgZpi+BFIuVcc/z+AfP0lxf3d/j0Vrr1pAOxzYpRU97a12Z1qCSGnkz/xo/O1vdW4p2Kk7dRBWVo59ZWabg201mzv9FjbWufNK2/z2a99np+e/ynmPtrFiZy9sQPGTF3TZo4+wHB9i3K8Q9RIqdSmxokmH7P+yr9kfeFxopNdPFFngscdHTJc7yOcAEqL1qAais7hiMPLj7K58W2++5VN3t/4SRZPLGFLSEZQ1ZbxWNNoONhyn/vzbzPeVXEw+9wTPP7BB+nUXfTNDf7LX/o0XrmBLif4Fp489RS//Klfo3G0xe/+7U8zM9C0Dz7H+555isqy4D/77S2s8PnEx/42jx5qcrHXZ3UUE6lzHFf/My/vpLSrLm3nOBuTdd660ScrxTThHRn82mHq2kFtbRM3A7qLRzj3xm0i0aIq++hmQB6nTC6P+M6bKc8+Okea9VBa4OgxnoloyBbpuCCTIWXg45ETqAnGMxS6SZFukuip/nJcZgyTCbIMObw4A3hIIYmERMRjUmsonIhYudhRhpQWZVw8Z2q815xvgy0YTTRIH0dJBAVG+RS5QLjQbEWk4wStC2pVDyN84s1NRhQk2zFlmiI9gywcnGqVwSQljCIiofBCH1cKTDLG6gIpBVG9jhU+SaJJ8hRPCLJCIZTCCoFREmsNxU5MNNNka6VHmZS4rsAN5JTQLAsmWxmNTgNbZJR2gu+WLMw6NFpd0jjGDz1EVGLyHJukGMeSpBOU7xAPCxy/Qs11sGZCEjjEgzFxUpBXBZ6nKEvwwohK5NIfx2xvbbC1PWGnPyKd9KkuL/Lwww9wernJ3Nw8lajKcDhga7bO4OzbLFQnrF29zM1LbxM0Q44++hjH6g4bJiMrAjbeeIXVb7/IaG3M6b/1AcyBJs//t3/IE59c4sDROdZ6Gf2LlwmePMj4yk06Dx1gJxF4O2t0GHLBVjh2JOfN6wbPasqOj2V6jW/+8Ct0wzrPfvADfOv3cyY3btBK1wnHixx/8jBmK+TbXz7PMB1j8pg8n1C//kMWZz5JS27w+obP0UqXo02f3s1vcWDpCMKv8dv/zf/OYz//E+TxGl/73B/wsUc6mIHh7N0N3kmr+MZDxTHfz3L0TMLf/WSTL7004s5WyiuTnEZ1np9bfB+uG4HjTTuB0kFaiTUlCA9QOK4LVQ/hBLhhhYpuUKQTlDBkmQtGoaoOYeSTxDmTQW8XZ6AQVmLL6STGKkNqJvhKIXRJQY7wQrrdBtdvrTNJxljrIq1BCI1wJVVcrBfiWYk1BcJqXMejSHImcU5mfUoBwpZ4uIRBnW43QoU+iTbUqhVcYzCTGJGXjDZ3kLIksZLaXBvpSLLRBM9UKPKSYRLjWsBoHFdS7VYZb26hHEVucoJmhBcF4Eiy/hDpe1gnoCgVZhQjkoSilIzkmE994udpLTemqhC7LSmrLf5ChHVL/EaKO3kdW76MjQrU/AcY3f0SV8ebHF1u8/gCdDzJJiH/6Df+K65NWjzxiM+Nm5bJpCBJoFpx+Pf+65/hM//586Q7b/Kdz3+T4WqTT/79j/P+x11efy3h+z8oOHHUZaajMBZcaXAxtJt1lk8ew05SPJPRYIIHzMy2WJifw1sbU5QhTqNFJfLoDEvSjiEtx6z2N7h56yqVa+/cu99LZ6r8NFkfcuHrb3LeXuPo4gKNmQVC6/ChD32cM08+QaFz3vinL7JMiHv0MB893eGtN3q8cndIbkqe/Ymf5T/91V/iq2/fIStKFr1v0DXbfOPmDscPNPnMZ67x4HtO4wQRRZlS63QwA8hlE3+cYCcTnFpI5LUh3mb7ep9DC4cZZBI7GdC7MuTtSsADR+bI8w1+/7Mv8rd+7VlmZ/8CnpT/FsIae08ZyJh9aJG5T7vR6F3S8S7h2BozhfbsEY3vP949ONDecey9hNzuqrlIIXf/rt79e3bX2ExgtEEphVJTCVRrpj+zdtp0ut847f9rSJbcJVFLIWhUKlhrGWYpeVFSVdMzTbWif/ksd8+exUYuR558mrLi8eV/+Qf8tU89hml1ice3Gad93PkF4g1L89A8a5Pi/6buvWMsy+47v88JN79YseN0mOmexCE5DMMRZySREpUhaaVN2EAL3hVs2IBhw7D/cAK88AIG1rAX8ArwrsPacljLlteWqaVWolaUqBWTSI6GHJIzPdNhOlWuevHGc885/uNWdfdQa4CwRZE6QKNR792679a755z7C99ArzygVTELpTm12rDcjYmVJd9cwc5LZstdbt3+HMPHA559+kl++9oBG+YWvapHNB6ytpERuYt8+uhzNJMtRNViFyWZTeivvkAsp9x4O+KptTMEh9uY3TcZb4xAhXzqH/wOH/qbf5kbn/8cbvs2z7x3jF203L2/za18k8TMqKqGt5sKuVryF3/2Ap/9/D22D47oNyWXVh7nh374p/hLf/0SQRih9ImW3MlEEd9CTv/eHVLKh2pEj1bFH5i9dT8/6Io92iA5Vt464Sw87Io9hL2dwLk7UQL1Dt5Nay3ONyyWC/7h//w/ILxgJRnx/r/xfsKeBtmdtG5qqrJAp4qqKVBRQ5RcJwoXyHANkhWa5Rsc4ji/YlhLu3WW9If8yMc+yn4R8Nhpzda2pzVdgpAOI176y5f57N9/lTq/zvUvXMe7mM0rq1w4K5lNHWEgUVKgku9OcvdtJQeX+hlXdMbda0f8l//Fp5GVpScF45VNPv7xv8rLH/wI+V3P1/67f8Zots3Yx7z/uYtkywlf/fRbrIcBm2sJP3h+xK+8dp3t5YLWOXI8E9/g8BSN4De/eKfDgpkWrTQ9pVgbj+jLiuz047g04f5uSVEccPnCcxzd/jLrZ/rsVRE7e4L52xN+49dus/faPTYuDhn3Uwa6oScKlm7JchaBHhIcY5Hb1tLOcsQgos4t+bzqJkwaEkYKCHh7+4go1DhhWT01YJWYoihpdY8oTbGmU5hRIkQpjU4UKhR4MkRZI4Kwc7gzJTEW1wZdBSfJSOMYHWqiNKTKLcpBUbXIWBNHGUoJrPZ4WzNYGeB1iJOKpvG0riRQLSLSpFmK94qqrGiWJeVsSZMXZKtD+kogy7zDj/bGqCxjvqxQQUCVV7imI+45YbGmwAnJ0bxASUvYSwizjrhVlSWmWpLqIVpJvAJX5ezlBbsHS4gismFKX0pcEDGtLVJIzo5WmM0qlssGK0DpgOE4pHGesiwp8zlNMaMtSuoy4FSooW0ZDAa09Yyj5Q7VsqQXpGzNF1x78zqtHTKvDI12vLUz5YWnz/HKH73GRz/6FPnr3+Do+n201Dx+/im+FjzDcu9XaQ8MG7pHMBpw3e/g8qcYlRMOlaA/DNA2Ym9qcYub3EszLo+2uMVlQj9is97DHdXMvp5z+t0ztGxYe26DPN3B3L/H9es1z175AarLTxL1fpNNdQd5vBF9vZqx+OKv8n1Xf5DnVy8jG8t0UTEaP87yjU+zcvqvcCl+hs994k3K8CbDs4pX5xMod6kDw1AqtOjUQeJ6zvY+fPaPai5flQxWFUf7nl/56g3+t7/yb/Df/KO/Q7r2JEJGCLLuAY9F0QIBUikCoY6diCXWBtSBpswLcAVSdeRF4T2BbqjxNF4jrMMaibOaMIxwJqd3/MDWqoMOqSCkqnKGgyFR1KMoauqywDadD0VlWlS9RGUDpHOYIme6WHTk6MYgRYoOY4RrkAh6qaSfaEyV46zD2uMNfVkwO9hHOkeY9ZBJH2cctAaPoJkXzI9q4iSgtQbXClqv0YUlXskIlcUXLUo7vDW4tpungQZna5yvsE7ha2jKmo33XmD16iWivqbr7ApwnTSqjxWivoHqSdpeiG0UIl4g+yvMfu23+N3DCT85HhM0IwIBm5nkC/Ualy8K7tyZkg6GrGQR0/2aZBzzfe9J+T/XfgFR/hq+vsXOG7/PG7/6FM/91HmaW0taV9EmMU5HSC2I+h47OUDNLc1+CfmUXgIrGytUMqM3TDncmpEfLIhCj1KCw8MjxsMBh2XJNw8qTBUzsAVuNnmw3wsAD7ZxmNaQxiU9U3L5iXfxE3/uJzm7eYn2sCV/9Q7Z0SE90eOll97FL/29/5zt+wsujs6zeW6Vsy//OP/Lp/+Iw3yOwLNDjbZLWuc4WITsHM4Z399iZTRAyZCmrHjq7GVMfkD8+BNU3jPdXVCrBcv9nKun13B2wa2DGbk1TKcVr7xyhzdf+SZfevUOd+8c8hf+Qv0vxOj/mRjiEeT4cdX00arvO8mWJ3ht/zAJEB0swx+/IB5JGDpysXgQWJ0EUifKMN8KC3r4+d2FdUGme8BHgHemA12l+k9mvFPZSBzHiJ40CAmFpKwLysmCOK05eust8q0DVi5fYH3wGG/bAbs3D7BLw6lTffbCIYuFQpgLjMyCIyUYpwHORRjTYM2SWZxyLtvmbZ5h0Nxj1C4wy4rFjQXjswVi2DK+OiJZ3Ge5tY/Z8qy++AyMUrLhiM2tFEuJbAxv398i/43f5srLL3Flcx03W2LFgCgNad96k3j8Ps70LvHZX3+DIJ3TG1vuLvfxZY0NDX1VojKBbHPMcs7ceG4Ucx5/d8JwyzLZs9z+yh/Cm/d498sf4+WPfqxTbpInSnTd/XrAHeGRiPl7cjwyn76l+/QwuO9I9ifzQR4nxifD+YfnOiEdP8o/ODntA0ne445a61ukdBRl2bnKa40fjRm+d3RsusaxGSBIpdChQDRTjLaIKEAEHhE4vIDq9hf47etv81fPfx/CaEIJoVYcuJjVNcl0WjFeSxFSYGpH1JOc2Qhohx9mfaWH8EvynR2qQcroXMp821JMPGkiUUp+V27ft5Uc7N0/4rNHr3L75gHPXznNoA14+eqznH3x3ZwZPUbz9fvc/f03WL33Tc5kKxi7xmNrm9zcrfj6Hx7QmIJk0vJzf/vf4hP/wd/FzSukaJFYGucAT9NazCw/3uSg1TDLa9JY8+YCEm9ZCypGlGymNTt7NYl2mCBEzhfoakEsPX5aYQ9DjmSNODOgUYJpUdKTDT1iol5CPm0ovSZNMnqDAW0Q0/Y85aztCJFKIKIQ3zpkqKito98PGZ5aQcWaKC8oCsNsb4YqanzoQLSEoSQdJHjhkTpEBg4RKKxpsGVBNux1ZFgCdCRA6K5y0zqiQDNfHhFmPaIgQGqFiiOiNMU1DrFsqY3A5TlNXaMDiQs9KlSEYUxT1tjW0FpDYSoUGbGxyCRFmpImr6jMkiBM0XGKNznCCUzbYo0jDCOCuKVclrjAoGKJDUOwICVo7xFeUkznHTG5qWmrAhdnGKHQMqLMHXFkSdOQ0XiMMAfQWuZtQ4BHyE6r37clwyyllpYkkoh+RCRgGrSkgSRVFZPJHtYssa3B1JJULNiuWsa6ptdrCBFM5xXf/MM/ZPezv8vNO/d49+h1rnzoObYqzSuf/C2mX/k8z/7UD/BFIzi6dkTygTV6Zx+nv+ER2w6xcYXe6CrSSqJmydhWlO48VT5FrmWcvt1QCDBrCT4ViEPIr03YH90k2tygmKxRvvUNVqYFd7+6z3t//hkuPXaFa3fvMq1qUq/YdoasXrDcusvZ4AI6WUFkY7TNyYoJgxA+fCbm7Wtz7i9L/HiFhT3g/LhmM0mYTAvmvkWFnlHcYxwOeFPdJc8txniOKsfdSU3U7HPvi/+YJ3/83wYZYb3Beg+uwy/L44hPyGMzFS/wDmTHU8Q5MM4hlCTUIVFUY9IU5SSuqahLS1nWWARSCbLhCDw0TUFd1tjlnCgE4zvttTgQxDLEJx7rIoQU1LllPl2ihScQjkCAVhGql5I3ASGetnZI74gDidSeWHqMFyjtkUIiwgAZxPRXOkO3oJfinME7hxKK+dESuyywNsIZhw4iwigAW+OdonUNuBaMQsuOh4GAtjDYzj4ZjiET1rfEWUi4niKOjzupVnkFKggQag1kiVR7eL2NHJ5CSHjjN+9iCsfq08/RO3eJct5SHzk2nl9Bm5rx2ZBECAJncFaymDjSgeTMDz/B658YEm0r3GSX+5/7vzl99eNkg4bttw+48RVwk4zHrg4glASDlFlzxKXLG6RypXOnNg7jNaFSiMjT9i1aOdq24e7tKXW5oLAlp05fIKoUauqYqObBfi+EoG0MaAgTTRwqNk6tUYqK/fs7+Ns1yaFhuJgRD4bYdkivn/L+lQ/x2sEN6sUR8k7NZ6IlrYnQIsM0E0pXoGnxzvD6jdsIPGVRsNABQnnauuL69btsnr3HzwxT7ty7zf7RAckg5dLjl9BYZmXDra9fwzU1o36EnXmu3d/ixu1DFstOavd7HWf9/zY6xZYOe905vvoHsJ0T4yv3DhnCb4ETHVeKhfDvePdB1fWEgfygHNsFP1IpvDshMT9MKk44Ce7R1sUDCEinFNeRJCXfCejKQ6gJCN99hreWelnwqf/jH/OjP7LOlRdf5O1bB1RHR7Tb13jswkcocsfk1jZPXP4wa8MBi3IfsdCE46uk8Wl83RL5kkgqnBhQ1wtcP+PUdk0Vhfi1BJsKmspTby2YJwesnDtHfX0Xme8TNS1HWxe4uN7nwhNPcO3WXWQl6fmQ/aYmWljq6zsM4lO4MEYHFtnUBHlFpOHq6ZBrrx1RtxqbDiiYsrpSM057zPYPKXVLmMBQrdMLE7bVW+R5hbWee/OGg3kD87vs/MYniHtjXnr5B1HSgZcPSezioUke4ns3Xf4XXdkJN+DBlKMj4p5w30/UigQcrxH3EOLGH0+s3zE1T44TPFhfTdPgdYfvRwlkFnQdtONPcc7R2JZQhaATsihENHeRqkHodWxj2Pv8DVxu6V+6gIxT2tqBEyTrMQJLPEgI8eAsWGgbgQ4kmy+u0d4ckA482pWUOztE2TlOXQ6Q2vOnjCR6x/i2koPbN49ohi1jFXH19JhgKXnP+UusjzfIr+9w9JX7yLuHrIUJvWwFuXmFwcZ55rvfYHd/l3WpeFdyhttvS6rGIo4FOqVwHe7RWax1aN09m4WQqECxsj5EZjETU3Bn7zZNDVni0DqhH4fslyVFleNtySB1DM8khA5kOqAuFcv9ltKDKB11DFnf0FYFpjB4H6J1itAxMk5xYQ1JgmkcaE8YK4RpsFWLl5IgCQnTBJXGWBVgyfHMKOsS6zxIj5cdiU9HAU1jaYTEtQaFQ8chMgqQ5njDsxYZaLzUtLXp1DxUgNIBKgzQQUgQpwRJDxE2CGcwc4OtDcqBTjJ0qqiNoSkb2rruWs5So+KYuJcSRQlSazAdudKaGuW7TgDmmODsjrNSIbBYolgiQklR1+S2wjQFpmkYDhOEMXhhUdojvKNuLVXTkqQpTigUAt86TFUTCYPSismyRPmaKNHIJKDygvliSqgFlCVKONIsJghCGnLasmC+e8T+wR5WWoSUKKvwQULRCPqtIo5CRCCo65Jyr2B+9zpPDWtGp58keeoFRjccdVFz66t3+chfTMAr5jOJaoZspptsDgZQBiSjPtom4D1Kp2gUNl+QbT5LefcaOhH0woCyEsyqil4ygvmSxe4uqxfHyPEmO8MLVDe/SnvtNc6ET3H2qdPcfHMFphNSp1hax4H31EXO/GiLZKxJshQRrxCVS0RVsTZKudLPyBvJvCiZtobGKS5ICcrQmJq2AUOILOeopGVDO5JLKdGGpL7nWdkcMDxzFi0NLaZTZvASfEBjPaEE4QWy65V2FSXvwLdoDWGk8U3TERAJCIKEIKjRAvKqBRxCekxdE/X6SC0JtML5gLqsaRuDMC01FmsFKkgIwgCEpylLojDAtRaPoAWEkuhAo46NzzpnL49UXVKOVwg8QnjCSKGUp17mlNMlWkKUxDgREoZB16ptbfd7TpDEGmk9QRASppowsuBbXBMg427NuabtJIaDANsKvHHUbYtrW3QYIoOA1ge0YUTr7QM3WKzDtQ6U7xzFVR+aryGC28i0RgQBNv8qX75ekLiU/niMDmPc0iIbWDsdszyQDIQh8oZAOYR2neKXE7zwoQF3v3iRyd4uk2aP5c4NFq++TTpaYRwZ/OERUxGRJY7YaPRGyHgYs5EopDMcHs05OJiwsTlgbZjCIGS01sPahuXREdYqzHxOUVecv9ijn2aIMEDph48C23ak1EgKQq1w1rKsKwZNA3eOkNYhjUSFimSwQrB2jni4wlq0wmawQykKVqMBp1cvcev2N1DWIpRHqG7+VQ0IPKfOjkhSjdISLwSNbbizt8PMeP7gCynTyT7z+ZQ4jTF1TtMWNK7hcGf4wVofAAAgAElEQVQHb1uaPCLWitt3JsxnFWVtug7TSYfnz9o4jsGlkg+9Bx4JeKSU+GPDJ3HMPej+O8ZfPzjJo0RO8UAN5uE41oQXdEB+HlbpH1zKCRzjkfeO4dcPyZHeP+g4fCfNuB4EeUCd5+y8+Torek40eJ7x6CrJYMzu7S127+xx9YkA14bMFprA91iNLNOgQLSyUzWzAa3wSJXgaoM3ll7/HLO926hIkoohOS2uaUnCBF9WFLMpK2sp28GQyu+iFwf4nV1WXjjD+tVTfOPLI7JWEbSa3DimztDOSqr9Q/R4BdIIoTOU92Ba+qOY81nMxC0oy4qFM5RGc0ZLfFDS2BpjA7Rz+OUCmVQMlSG4sMahb8h3GoRMeNdTz3SKXg9DZR7e9WMZX295YC72Pdk9OL52cQKBe8Ca6Z5FD6BwD6vnXcLsH1EmOz7Tt8zfh2vhZL2ckPePic10CfOJYaBpLbP5nE/8xj/hr/2NX0AoQVmUVFUNeKzzqCBBi+u4cIIIEqDFVFvcuZMzDsdEwwyExBuP9BBnirqESAikt0h1vF5bj9CCx69GXNteoWJJPstRS0s2GLN6YRV3osb8IOX70x3fVnLgSs3ZC6d5YnPEsLaoVhAWnvobh+Sv7yK2ZmxmKelogzDYZPThZ/FBQl7OoN3latLjvU9+kE9/8qssZ0uEb5E4pHToQEHb3TAddNmUUoowDll5bA0velT5lJ39fUzlWR8G4AcMHt9gfmvCfDEBaoYDTRaEUAlqETJOU2RtaWuPawNqoWgzhSkbQOBai6ka2qYhHPQQShGmKbLulIsQdA8z0WKcwgtN64AWhNcEQUwYhzShpGoNis7LwNC51pZ1AUGEcwatA5I4BKW7m219p0YkPChH27QsloZ+f0wQhR3OUwZoEaC8RoXQhiBFS2sdVvkOFxwF5Muc+nhlSR0RZ4qRjlCBJJIRtDVt3eAah9aOQCrsokCGAq01SjiE7KpHBkd/nBCEIc3WgjzPqQvPYlYSsE4UdItYxREyiBAeykVOOFjBuk51wgPLxQyJQYcxh7MlkWhJEkUyCDBecLRfMhMB7WKJCDU6CFFCkiQaUyw5mG6zLHNkv0eSRYShoiYkCjTOabyThNIzSjR6bZ1mcpuf/snnOf++n2U7GqLFl6gby52bOVWTI4Rg2aTYNmGoIy4NEm5PHWvDMWHjiIIAxIhpWxOaN1HxE0R2C7caYPMSacWxQcoUrSrs4ZxkZY7N1picfYbDr3yZZOtrUP0M48c3WNlcRW0dclqG3J4vsDiMbJnmO7ioRxinGDkmTHKavIDNEVfOnWPp7/Pa4S0wBbfKFJPCGdVV+JvGUZqS+XLJE6uKUSCJ05Dk4pALzw1YPz9k/V1P0LgtBEsEuusOWIURY6TsoVB4ZLdJti14g8cQhMea717Q2uOHvQxBdAZq5jhp0FrS1BbrBK3pvDSM9ISBRsYxpixoTUNVeuJ+RBDHIATG5AQqQAhFGHamLUoqpAoRQuJaR6IlrZT4IMJJD3SEOocj1BJflVSTGfnRkkE/Aw8q1GitcaaldQLrBUGSkAURNI4wipEhIBus7fxJpI1wQmPrGtEagliB7wJgY8EahxAGISRWaAyCKi+IGoPoZHE69Rblj9sxGm++BvI+BA5b55SLL/PKvCVVQwKl8K2F2hFFCgLJYRSiaod0LTKCKANhOynZ913QfP7cVQ7evs/h9IBFXTK99jbZy0POjSWL1uAqx+FuiTIO2cRcXOsx0o5yaSm8I2hbYmNIACKFDEKM0TRFTj9LCZYRCMU4SMjSkFpCO58/3O+PpWa10gRSd9+1gceSDQa5YhgHhIMEkQaI3hrJuzeRMsRWc0ai5szqCqsXL7DSX+NzX3qVwFUEkUCHER6JkJ5eqlg51zsWMdDUjafFIpRksTjkc5//LIEWOG8RSCazKbPFgjBWaNVVkOdT0EpzMCloTSdx6d1350H6JzGOHQqAjkB58leceApAF/RI8ajvQFfhfAjBOYFinCQUPIgtHlUaemiO9hCv/a0ykNZ2KjAPMwkeXBFwrGbU8RVOOAvfqSGEQHiPa1tsmfPBF54lO/V+yraDpSyXDVv3cy7ZBikV83qIdxErQcMsCJjWkEYaaSyp0jQ+xtoFytVovU5g9zB9DQUINcCrAGdt57OzKAn7JWFvgyrdp967STzZQvN+Bo+tsLI+ZqQTohqOjnIcYJUlnxzSS1JcnOF0hozBVg2MMh4/v8HN/R12FxMKU3PPZ/gebEQSX3V7blHOqPMDNtcDkjBAxD0uPdlndBaCIOMjL73E0VGDFOa40AMg8SICHAJ5nBd8j68J8Qh8DR6Si4+TgJPJ/2iy7E/e553z9tHXvzVffZRvwDsUvzrVLd8ajqYT/tH//iv89M//OYbDIXVVUZYFQnTxaZRFCHMDoUuQIc7mVGXJjblnrX8KpVWnEkgHB/ISCqlIWgdSIDSo44DfO89jK4qb6SpFWaHKliRoUM6gtOBPDqj3/218W8nBy08/zfe/510oLzh8c8rFXka6XWFaR2QvE58ThEmDzTwieoz0+TPc/q2vk9+5zZqsudRfJfv+J5n82ieR3ne4Z+k7lYSATmedzpwqSjVBGiLCkOkwYD0Z0b59D6U8KN35CgjHra09Dre3qU1N2pPEkSLAMU7h7lv3ef+Pvw9nWsrc0jaaWAgqJNLFBJHCGkNV1CynC3SWEEYpLoJBv6VcLjCLBmTIymjM7rQhbzwULcoYnHEoKYnjgOj0GfYnR+ArokiCdFT5FNNKhmtDRDAAKZCic+krlwUqyTAe6rJG2IZEa/r9HumgTxBqfNVp8XulQQVYH9CYlliHGCyVadFVh49uK0OYDVBhggwiUt1VJXff3scHFl/n1JMZVgbEG2OyQcjebEaaZN1n2RZnHc53BJ1okKClpxeDr1qKuoEWNIY4S6irBhlEhIMBIkqQR4eURcVoOEQlEcbWVGVOazw+Tdg7OmBl0Cf2kApHqhXDLKVsShbFjGE0RFmLrWpGoWDWNFTFgghHGmhWRgPSfsJbb884vZmSLwSLxRwjPDJMeOpdz7IfTnn6F/8WOkxR927gjnYwjSVfNNy9/gpeNFSLgOVSEUUZz5y9yK1XX+XMuY+SNCWrwZCdecNWUfPBJ65y7RuvsnpqBWsr7h7sgVzl4nt/lGs3/lNEMiCY1+zuWjiVMDq7RtUbMFne5Rt7Jf3BWS6tn6Y8vWQlHmBu3+e0qamjhky3xNqghGEx0/T0KjJoUL1NBlcfZ6zvMZh9nb6pqOMec6WIbUQvhCxqEXXFsoLLI8UnDySTX5/zQz92il/4V55j9bRlMv9n5G7MmWxIIFJsC60Fog9i9SkQCTjZVc1b21UoMV1iKQyB6mAHlpayMjS2JbCS2goaS4c9ElAu5gQyQ1iNtIY4ClCDMZO9I1Q9QypJmkQMRn2kjohUSGUsEYIgCNAStANpO0RsMStIQoXUCTpWIAVB1FVYHI6mrGgPZ7iFIZAhTgY0LYwGYSdf50B5gQgjhFTIUNJbj8B2pEtjBa2XeCqq6QwfBrQGlPIoL5BxSLOskJFGZiHeGBpTgbaoZkk9UZjlSueDoFXHzdDgfNv1QfwCV+TY+QyjHVv3zvFGDU/FfXSU0CK7StFKRNtCbCXZMMblFotDRgHUAirI8Fy4cor7tzaYziLu2oZsMufDkcf3NF6dwUcRqhcy29/FT2c8+dIlIt3Qi2Gw0ePCSo+dnX3uvNkQRzWVNUitiIRnnIbMR2dZH4QMUoW1hu2DBV94/d7Dh4LWBFp3AaiTjPoDfvSZD/Chx19m63CK7PfojzNkogmSVdoNTfGFbUR+wGpsWTm9TvTec2x96Q2GQZ+WmigK0FmICDy9SOFkTSIl6WrG4aRmf3/KomwRWlDMFxRL90DHWwjBbLkA77DOEsdBl+Bai3eetmnRUfQnzYn9LowTorB9SB7uXj6u0PuHmOmOdHBsYtZVPjuctO8MC4U4OaTjHFiH1iek1UdgF98SiJ18hSeEVqXkA8z/CZ775Dgh5XEA4/9YIPYd+XaEZLSxyft//KdZ2gqEwk7vUc6mLOcFyWTJ/uE9VFQzO9KUNaytDNhIC+b7h6yOrhC2NX3d5/a8IJAJG/2Aw507DEZDgnLB1s6EdPUqSWLZ2fkdeqd6RKVlXmgG6yOCM0fMdrdZ5ntsFy1pb40rp9bJ1gW+FoS3D1gxhqZXkWmLDru9tqklhBlCWkQ6ILtyhqS9ySC3xKKgjfvMdUBiUqJUk8YVRhY4C5trCZ/ZDih/4x4f/OEX+MCHLzNaDThaXCPqJwi/hTMtngAhh0i1gnO26x+o+HuelPzH1u3JxBXvSI+/Be7W/dKJ74GU8tgo7dHz0HV7j+Fx3alP5HhPzi+OuwctznfH3d+6z9defZWnn32WMAyp64qj6REXLpxHyAjIEabEW4+zY/LiFNcLeO+ZNUQQ4LxAaAFK4pxAewjTgLaqu26HkggvEBZCAaPTPZrDlGjoSdZ7ZE8Mjz0cxTGS5ruT2H1byUHVtOxcewt/uM/a+uOsvfTj6OWAVGU0+wYzKZGJZ+WHzmJ9AJOKt177DHb3dZ5NElbShL4xbM0kxnY3Gi+xQJBAXnYbn2slkRckmSY9nTDKPAOx5MzT56gWS2grCifYqVq0n6H7mjKvyRLLWuLRLcRScWEt4XB3n3xpkGiSIGJaVKgqYHz6DNWiwkhomobJ/SWPVQWnn3ma9dUerh1STZZM7x+yd3uLebDJyuXH2Lu/z2x7hgo8gRIkkWB1o49MAqKBp13OEG1NXcwJ05hAWpTp4BQi7tGgmGzvU5Ytw1WND/u0C4OtKqJhj9PnznK4t4vtnUEpAa3A1gqdhuSTHBUGtK4my0JE2EVXuZXYoHMpDrUGL2nylqaYkbWGZByTrmQM1jZpvaSWAYvDKf0k4OjuHloHpOMMnUY0+YJyYViGYeduujEiHEfE0zlrpxJWNvokwzUOp1PK6SG2mDA4tcr6sE8VaoSucXVJICUqiih8TShzMq+Y7+5hyyW2XGE0XkEiCO2SezdvkT5+FhVlmNLiJXjr6K9vUBlDGoKyS6qioZnfZW04Iu4LYuVojCOINGcur/Lzf/4/xKiYuZf8w//sH/A7/9evIdOI4aVTfPm//RW8UVSzCWFdsNkbwcXnCNbv4+0dwpUhk4khjRuuDOD6co3zzyRMytexR9d5/j0v4+o+b73xq3zsX3qayfZFBjsxZb5klEnkaJ2vy4g/vH+fj4eWu1uO4RNPoUPP4t49HvvgS0yvfxnHaXpBTBM17AY1Ub9POnaIU4paztipQpr+OR67egn7+hRfH7IoPImUOO2Z0VKYhmwz4Jdzwd6sRreeX//1b3Lr+i3+1n+0zt3dkiqB/jlPFGlaEeL1AC33COUPU7sEYQOwXdDnCfDOUi4O8T6kzB2t0wgdk09maB0yK3JGKxltoyiXJXUDWIFZNkxsSbtsUDoiXAkJBzEKqA5zFguDiCv6w4BsECJ29pGDiKP9PbTX+KbzP+gNU0JtQWnqqsbLzpjKVNCUDpZL8qN9ev0xMu6jhCZYWQEk5WRBMux15klJjPdQTBui80NUFqIU6NYiFgX2YIYMJWqkWSxqAhWTJCFh6DFlBUrSmIZARaCDrkMmW6RzSBVSTZd4IMziDg5YW2QkEaJHu5CYQ4vJBfMk4cvXM6wP0HKJyaFdKqIAJJ5sAqN1ydFCMOj3SbDUC0syUkQaciP4wHsy9m8M+OyNIQe+5feOdrm8k6OEwIiALNKs9xWZH3DqTIjMK2rh0FFCspohraPfNEy2drmxs0OZL+inktVxSl3C+bOXMDbn5rXrFJXBuoDL49MP9ntjTGdUB9gwQmc9nvzQR8k2L3B1LtBOoIYKcSYEGTDf3uPeVz7PqC2gFxEmmn4QsX+kcN533UoPMhCEA8vBrEABrpHo2tE0DXVTYvKauii6Z4FzOMcxGU9QluWDABjcsRMyx3AAR2NL2tY+0N3/sziU7Lo17kSBiIfV0u7fIxXSk2j8Efy1EJ3caCDVAzx112noACcn6kNAp1DkXVcg8P6BOkxnFuVxJ/KlQmCtPdaRF8cE1+7L7wIu8YAn+J0eHZfipHIsqDz893/n73Lr5g3SU2skG2O+/rufQetVprvb6LZhkG6yGHnkUQn+CJUlzBeWzb7DeMXUJAzXA3YO3yRmj/c//xEO9+4zNzd58sVL+HqTZBFCWbJyesx+P+N1A2+8vc1HtGd34Vl98d3UW2/jcsvqueco374ObJJEilIbiD1BEhH0W/xYYH3BtI2JT51jnQPMvSm62qZYegKlaENH3hZYUSM3M/7pUnFn55DMtXz2U7+PKd7iwx89hZkvESGY5Vuo6PtBjvFUeBqElyh9mu/pjgHgcV3XSQiUEA8q/8e04m7+01X2xQnz+IRszMPAWcoTTs6x7O/xsUrLRzpgJ2lGd46TmWztQ9NAgPliwS/8zX+ZH/nYj/Dxv/5xHn/8MhsbG/QHAzwKVzrs0iCTs7jwSdpwHRn2ieIaU4JPBVKBcp6ogSQT5BX00gjhOr8RFXbX0Th477MpB3trVIsEFWtE0q217zY88ttKDl67dp3B+Us8OzrLhuqjZw6yiHY7YNlmcHmN8dMh4kxEFlu2/+PPcebubVrfsB9m1KvrtO+6wo75JxR2ifANgRQoL2jnBoGndR7lOsfFWAuGSYCZW/L8gCr1rI17xGkP40qmB0eUiwmVsIxCSBpFUAf0Y8nB7RnagS9qYhtgnaKyjtYq7tzJmW3dxFpPMk4JwghXCfb8Ltk9jV9Z7ao2jSVMFYPTQ5beIdoZy8UeyhkCBSLUZGfW6Y82sKKh7kEjAkwxo8qXSNkiyhrjLXW+QMUZQdInCx1tUSJby2IyJ1KK0ekNsvGQ0lQM+inzfEngAkIVYy2Udw+xCIxtiAcxSsYINErCaG2Aq0ryWUXrYoTwyNaQ6BhWM6qyJPABWEVdNxTVEiME3kwZ9gImiwI7a9GVplwUhP2UO3cnXLqwQTEpOja/Sij2don9FFAc3LiNcS1RL6K2O4zCmoYI5Rx542l9V/ELvcMfHbCaJJAJon6GjlJmhWBRthztVqyfuUKY9ogHA9LNmFi0KNuwtb2NpebwaMn1e7dZTg6QQYbJAkaDISodsJJEjAYZpzYjnBfUVc6v/vv/Djc/8yWEs1gClrWnH52mKa/h25xbd2+zu7vLu09f4Me+/2f5o0nJT4wdon8bXE1rV9irV5jMVhEbTxGyw9H0Gq58k42LL3Dq9Lv5vd/7JC89+QP0B4YV1TCb7XFtco/3rz7DjX++y+oTMYfNDBn2ufCej3L7zdd57sWLhE3GXg2bvYxTo4RaeHb3GnjjJqOfep63Xr3PfTSPv/gSFPcYbeeoyYI78yW5axn2JY+di/h0nHD4xX3UquRf/7GMH/3hNbKrPbbmO8RPtFzMHLYx7OeOogLhDrlyucIXE1pzBZ08g9KreAR1UzPd3ULIEC88tfc0rcE3hkAJzGKCkA5XO6JAoXoBzd4+Zx67jHSeuqjYPpqwmM9IWgtBiGsasJ1akGhzJvsl0/0Fq5lGHB4RCQ1OISINSUDVGLSQpIElCiNs4ynnBflkRhiFTCYVaZAQ9Dp3cNcaVDlDqwCvQ+p80Z1LB7hWUJYL7I054wvrxOMMHQUoHyMKSRRrHBAqS6grggC8USzv71I4RWsN89194l7K4NQK2WqGzzwiKREo9r5xFxlFjC+dIRpndIzsbe7+16/x1jd38Y9f5OyP/RCf/MI2fREg1y9xa+8W6/NNnrr4DFLArHScijRhZcF4lJYMRhKVgZlC2njSMKI/usTa8IDVxau4oGbvsEBKuHhpxHglxree9Timlglp4hBNSdu0+NbgrSFpa6pexuZaRnx+RBQG0EIpHYGE2dYUMytYGQ04feEcJlH8vd/9n4CuatyKDreshWI2n/Gv/u1/k6fPP8tf+6lf5MnnnmDlXJ9stYeWDvfpezxmZhxKhRkOiM6dgbMb3C8qpsUeg9ATC4WqDLZeEnhH0VjC2nDrrS0WeU1RWUxjaY3BuWP3dtkFoW17orUPWkhs25l0ee8xjT0mGMoObvMde1R+50fXAeiqnyfBTudu3r3fwX9cp5f9SBWVY/SFdRaQXUfeg7VdRf/Eedha947qapcoCLRStK05Pr9/QE6GrjvD8eu4roMgJA/ckx/Cnb7jXw8A1rYU5RInBZ//5V+i2rpDFgeIOGbeKvrxmMXBfaqDKfd3dzh3ZoMLo1XshT63i5YXUk8T76KEIm9SChNT2Izhxg9ANWUyuQMa1k+/jyAa8qVX3uA9j10hi0tSbzic77KbT/ngqafZe3NBf0NydGdKtnYOORIsD/Y5/4Fz0MZMa894FBPEmtZ68nlDdveA5MULvPnlXfqn1xn2nkT7Jb39BfJgnzv72zSi5dTpGHV6xB/5mK3PXCN6POYXf/Ixzl29hE8cZbtLLzNkuqVxlmb5T/FulSAYkqV9lH4ZKaM/nZvy/2M8IBJ7jz3ucHQytifvPwq2e8dvwiOBPjyiuOUfJg3ugZSR54GYxHE3QTw4y0nK2XUknHf41vOpT32Kg4N9/vzP/Rw/87M/gxAOU0+ZfOJLvL13xJmXXiA8v8HXX9tic7TK2vPvZl4ckq5GBEGGt1C3nkx3IiC+pYMLBYACV3cddCslbRPh6pIw9vQGMY/8Wd+18W0lB1IH6PE6yTPPsfns+6AY4uoEfTlhYxwghhpSSRRD80bB7vU/4P7ygEMhMOM+vecuMtOe0NxB+opADYiUxvslrWtYiwS7Rdc94FjqabGV0x8NKGzAC0+fZS2T1KbhaA4ynSEbwerZFcxhwcGkZn9rQWQNSVHx3mfXmU0N8WqPOMkIZISQmnk8xU1qjOswwK03CKfYPiio7V02xgX91RFJmiACjXctUguolqTKEIYaIbsApZkdUWcd5j3K4s6KHUVkQ4QvEFFAYTy2rpCFQakagoxEBQjnGa6MiXxLpDXeaSRLRNQjjWJE0xIdq8YUTlJbT1PX+LmhN0oJIoVvaqrdOckowTtJOc/ptOw12TCmyA3Seg53S7RUIAO8yljdTBFihXy2oD+WoBTetiA9VVGjdAy+6pSfvMPYGjQcTUqmbLFoamwrWNQVbtrApRWKwpKlA5Z5Tr6co31FXwv296YkCcRRipARrYPG1RwezKFsCeIArICiRNYlLvI0psB4y929I6aLnDIvaBuLjgSVqdnd3iVUitXVFZQXHLBPomL+11/6ZX7/D17h7sGCUiqkUky39igPZsfkXMe1L3yer51b5SP/2r/LTz6/xv4/v0PuE86oBVG+iylzXjx7irJ0bE2OiJWmXTlHED1GFgx58ytf4ec/9peYV1sc3XyL9ewUm8MEJ2Nem9zhh8SSOj9glETYocTHhuiD5xALwcwaxN4BjZyz8JokCJisB5zWAd9863N84PsuMTqAz376Fc5l7+KOeIVxphk4iWolzsC9HcvguSHr/9VP8O9dfp5nVmOS5BVa8Sku9R39yKG0JW88ifHYCmxuMUcTZvNvkK72keEZIMG6gLrMkdIDlrJqcCIk0CHCeaStmBZHhFGExWGtxiIJg5jZ/S0kirqqEMesqcWyJE0dVWkJVFefaWY5TV4h8hybbtKWFVYkmLqhNRaJotcb4QOPa6BZzrF1izEWJSBWgosX17Feo6MI4S3KW/r9GFvUQMHyaIGOE2TWx6mYXl8xnS3IiiUEFiXBljXtskEIxWA1JY4DbFnRLAuqRYWVAlPsI4UiijVStXhbotUQpWPqecFyd8rkYM6tu/e4/j++zaKY8f3PP8v9L3+aL75xg7z1vHDuFE9uvsj9t/4T4nSNJ/qW6tar7J8dc/HpJ4kHAQKoSs9AC2wraT1EIZ3zc+jxjWdzpHjq0gqHl06x/Xqfjz3xFEFQglTEypEEx6IB+yXTO3usDVYIw5BZ4SimFWFbQGPptRUiiFEeyFukFYzXV8kXS3Jj6Y1OkaQBOIGrHwaED/DqgUZEnQTueLjKiy9+H1c/8Bjrp8eEaYjAUe0UlDdfZ1bVFP8Pd28WbFt+33d9/tMa9niGe8+5Y9++PbfUkmwNloRQZCuJnFQCZcoEPxACFE9AwWMAVx7ggSIvIRRVpJyqVFwQcCXGCQq2Y+O4heRJUtxqtVo9d9/uvn2Hc++5Z9jjGv4jD2vvc063UykVpBWJ/8MZ9rD22v+1/mv9hu+gM+SFETy0TSMcZXMDkZaM+h8hz1pCOCSw4KGx5pXbFciS+bzmeFphbYfTBUlR6FWSEE+IhVJ2fJgoEs5FklzBbuKpVOe6GvjjOtZVeyXViatxF/uvYEArWE+MnYqJgJM5EuLUMdl7j5Qd5nm9XYTo4HDriH6t8hIFyI78GeOp6osQa86CPENCTsTECVka1hKp8GFjuhKJEDzOW0Jw7L97hz/8Z69wY9Kwde0K0hTs3bzFobpLVIroWl557hs8cm6DZ57+NE+ogN1bUCfNWM2hqsmEZzRSeB+ZVjWZynCjC+RZQWw9k/0HfO6ZT9OEKdPbt9jdvE4vNyyD5Ll7N/kJ0WLbhs3BGInE9RN6fA5aQRU98uCYyJKSgDAatynpS8Wd26/zmc9f4ZXXXuXm/RmD4hEeyFcZjXLGLqeJkmbu8SZx7umHuPDf/Cy/sPMIuyON1N8iptcpY0ArjxQWnyI6NiS3QPAQIj2DMo+y7ur8KA+5OsfgbJB++t9Z9Sy56mKdfUl3vp4lxZ9C3E5Nw7p1s+4mrL0R4Iz5WteG6JJo77vnErz80ssc3tvnm1/7On/xZ36acv8GL742Y5k8f/qTA66qHr5ZsPPwdbbKRKyO8G6LSL+DDwHeQSkhulW3oltyyAxEm0gSrj06RKkBmTlVA4N/tQnCD5QcfPLTn+BTn/g0G4MdYn9IVuboRqOHoCPe7GYAACAASURBVPsgepCySHhgOfoH/yeTyes0siCOLqEuPcTgwhXC9D0sHikLYnK4YJFyhWuUoAUd50BChsA78DZAECxmc3TK8N5ja0uJoD/qHH69FhSlwgVFnFv6eU4mFGZQ0i8MuekwmY2zxDxHn+sz3X9Aax0DI+n3C2ztCAEa3xIWCyrnyaRAl4ZB2cc2Df3hEBEjwa3IP0SiCDSzKTF0KkI+JmTRQyVIwaFSixR0km8EpNL4toXFDKQmFhmUOaowxLkghoTzFTJ2EosiNDgXaKuW3rCHUhlKq45kZhTtokbJhKgqopcIXSCkJqWO1B0b1ymBxG5/pZaEKMEYgmo6vJ4SRKGQeYZbVKR6yXKu6OmEFJ4kIqrIWDhLnFVEb6lspAkJo7oOSJQlsamRMUJMWBtYBoH1ka3+GO8E7dzhcNRtoK1rMqnIddfKrpcVqV2S5Ylsc0B0FuESJklEXpBUQvZMV/mqFlRJQUi4ZcXUeN555UWe+84L3DpasEyQpISYiLVFtBWZFoQkuX9nyrtv3ML6fTZ6l/jikzvcmAvu6UfY3jhPv5zThH36uuKRjW3AEWXGsk1MHtQ8df0Z4lDzzp3ARx/+CMP+mLfu3GE2mwGKc5uRF99ccGFrxGjLcXR4F9H2aDY3ENUeW08/Qc8kdC6Iox0eVo6DG3/MQh/jjx5wcXCJr3zli7z75vN8dOtx5OQuO+/dYTZZcrjwHNWJx8vAL3z+53lmY5db7R9zPLvPsK55snTIvFMAKzPASMjAG7ALj0uBkAS+XSDlhOALXNuilO4Chujx1hKDRAaNkWCyAl9VtG2NUAqhNcEllFI0rcO3LSrLyKTELhzTuoWgKIsMGToYg0xQ5JrMSGQxpLURY7qLeEyCbFCQ6UhsWpSSBCUwSjPcHIKjS8hVjjEKEUFE0CRUFkkITE+TCIS2JqSAdQ4RA5PDOUVryXNFpgTlsLdqKxtUbFcEvogPkbppiVIhdY4oDMIIUKbTtyZgq5ajm4fs3XvA3q332Lt5g3uHt7h78wb2cJ/7TeSR69c5f+lxJguYzaZsiB7DQrCcLzm8cczxm1Ouf26LYgz1QaJfdsmP0AlbJcRxhJDIFfTayIZU7I43ENsPYQZj+rojWwsrsLWjHGnGFzPSvQUyCWzlkG2iEBpFjjCe2f4+88p1hP/kMSLQLyRZKMj7I4ajPm5ZMdlfMA/tyfU+ywxaaRLgvCczkaIsuHLtUgcD62mkgnC0pP3Gq9TVbUK+RdzaQu/sIHsFoZlQp0BRnqNtDzv4iw4Irch1IteCTIkuuA+RGNYuwF1wG08qhuuaHqwLiilGfBQrj6IVDAaB/pAkNX9o40QR6ESm5AQffUqkPA34OpJu97eUYsU/6OZwzRlgTUJOnCQG64fWKjZd4NVlG5HTxECsxd67V60+vfshZRdspRVm+4cxOodnhbeBP/jaP+XGpGKRaYRr0AuwzhNjxWY/o6kSb762z92PP+CjT9f08x4Pb/e43wBqh2GvQYQW0oxcerZ7PQSBKDKqJhG9YufcBWKm2JsEnrh0HR/6PDhoOZhM6Jsegz689m7Dtd0xyc5pmxZkhh+UiPaY0fVraOUQeY7KSnrJsjx8G6fmqFnNtUubLMYly+k9ro4eQS1L+jcXLOae6cRCXfNYT/LxJ7/ApXzMXfsSsZ0wiAtGugERQHm0yjrndulIsSFRI2S5nrUfyrH5fzved+ac6fydUTJdPbdOWs98n1UnYA0lglO43UnCseYVnHl+HaCL98GYOsjcevvBe4TS2LplcnDAe0LynMlYHO7z9oNDlrHhqeOWq5hu2y6xsbvF3uv3mOcLcjOm3MjwGfglZEagdbe2ogNs14GTKaFDwvQ1OperpF/8SBy2Hyg5eOjyJa5fewgoEAqkiigcQgWSChAFfn/J8e+9xeG3/y8O2j2WxUPEjR3ynV2KjW1q9rGI7iIUa2IKJCExShJJKCXJlWScSUYGJj5gZxVl3mdyOMcvNN5Hqrol956dgULOLbkAbxStVrRKdwRFIcmNRoaInS+omkCL7gzJdEbZzxFoTJGhc03ZNxSlBgNLW9MER89o+saQFzlSJIyQuLqh9a67pipJiJFYL5G6O6hSd5hPHTUxOQIR7yKRrpUUku86DLYmJoNTCp8EMgS8TbgUsE2D1jkidpwM7wIqeopCI7Oiy3Bj6IS4fKI+npGsJ3mFKg1aCGQSFKWkWVpUZiBphOqUUmzrSSFRVRbJSloLj2tqUgoI66jnCqTH6EQ0kmWINCHQVhX1YoFNCZkZsjKnbVpcW5HqinkrWNjQEVcLhZIC66BtAx5wAZomUmiNMoZBaTpd9qbGVRVt5TASltMFsW6h9aRVW93IQFs1ULdUNlHNlkxFQIaaydGc945mLHwgAIQALahc4puWTEBRSPCBm2/f5mu/+yx//mf/LZ7cHVCnwOHUcZA0TdHDhEghBEb1CaGBKDqn3SyysbPLa8spSmRcv3ad/dv3+b3ffwFnHX/qmYe4desd3nxpyuCzH2Xn/Bb9akqqczIlEDKwNeyhNwp8P5HnhoubY377m69zFKecW064+pjh6mNP4NR56luKW/Njtq4NMH3H/JZncRT4qdrxpfHTvIfkVjVlOTsgLD3HlUceRLYvgSokSglE1klHeq/Jh8OuKuLmxKQIvt8R6ynADJCihRAI1hO9Q+cZRV5SLRf4pgURkVqT0FgKfEi0LqIFEEGESDVr6BX9lTtzZ7okMoNAoUIEqcAAmSQvcpLqJHd1aLHOIXOB0B3ptywLfBURWpAZ2UnfRknykHzEGNkF9CLHudjptROwQZAZjV3WOJEwIkP2crKiwNVNJ0NqPSJFlBZII4kCksoIqkCUHV4UNK512OWUarJkfrxgf++Ao8MJ0Xvy6Ll9+zajwRY9YxmqMbP7lj989gWil/QLxUD3mbvA/L2a6UsH8LGH6PU1zSyRQkLkILOEkIk09YiYEP2E3W8oPFy7vMkl8xhuNgOnGWwXCATeRYSGwYYh1oaDexOc9d11rOhklJ2XLBYBIQ1SZQSfCNET8GRGM9rcplfm1EEQvSC07uR6r1RHuo6x4wMYY/DR871XXyArDf1hn03R4+qypH3puyzsAXb8BGFrhO8VOCAFT40kNzmpfYAVAq0Ehdb4JOj1SvqmS0LXhNi10lDw60rgaofW3YN1NW312Arx/n4Fkx/jscZQrwOYtQPxWZnQs7FRp/+++kusZYnOqA8lOKtm1I20ns7uv5UcqVgF/MT3pQHv378PqBmtt3f214c2Vvu8XC559bXXeP7lV9ivHF4lwvGUvLRkecedGxnFYFPha8u7N97hxsOXefzRj3Cun1GHSN1kzFVHutepg6rlIicmCzEj2UDIFKbssW8bFIbd3Qs8//03ePW190gx8fHHd7m/t8d7b8y5cmmbvPQUPqJiJ7ggRKA/KIlFQTKSzGhKKXnjjbeZxTk7zrF59QmKUR9TjnETxX41Y/v6OeRey8F8iW0sV2zgyfwCRwmmdoJsKlSwGNFA9JQjQVYMESJ0KAA5ALH9zz1+P6pjHZp/8Nw6TYdPX7fmDaQzLzirYvT+DZyuo7OjW2enJO0EEONKGnUVwMdEoIuzrLUcTo557vsvMWla5tWSOjimy3al3JfolwXDc+fYf2dKqiJx6RGjTuEotGv+0Gr9xkRynUy30GBKiTZiRa7+/zCR/5LHD5QctNOaWLUUw6JzGF20gMBWEWEy4rxh+fwN3vyVf8J08Qq3BNAvGWz3KDcVZFBunoeUkAQQcXV4I0YIfBJooym0ZLOUbPYVdpHwsznlxSF+YbELS+six3Ug1I7yPPRVQJeKFAVGGWQpaNoEUmNcxPmG+bxiOmswwzGDrKHFsTnsoYzpMtUY2egbMgMhQeua7iIYMrIEJiR6/RKXAqkFTyJKiELQ1B22WhclOZBaS6pbdLJEIi5BU3lSkpi+J8qKflZ0J4tUnSmYT9hlg6ssVmpiSEQZcSngQ0fQ7RUZIgWk6Eg5KXhi7EykZtMlWihESigRMSqhgkPmgUZ0evcq67wTklTY1hNc6FSahEepREy+C/CjIAVHO5+RlKfIJMkYjiqHpGU6nzE5mtDrGbbOj+j3eyQhmB/ss4iJe42iETllWWLI0UKwfzjtvBuKAoxBJclIGZLJKXWkXswJtsEHT9M2tG3N7LBisZhTu4CLHiE9AzTBS6y1zKYVvq1IrmHRtOwfeQ5twIVEigFSJCmPKkzn0KsFg1KRZ4Kjvbv88t/+R3z6iacYXfwUn9wxvH7U8F5leTAuuT5+miQbbGyQyUGtGY8UOxuR12eWGYZPjTYomiO+951v8PXf/W1M1uPnf+Zz/P3/+3nu3a24dO0cly9/hEvXHqNdtGDnzHUf/+AOTl9EjLbZZY7qnedbL9xibzbjUx+ThOxVlL3P5YefYn7jHt+/6fj4F3ZQvUR70FCFxO6+Z2YTL/tEavqcDxv0XI+9aYM4jvQKRb4lVsmZJEmNzgtGeoPgAskvO4iQTxAVyUeiGaOlxJisq6iLgBIJFGi1wj5711U0JSzbBi1yrO2MtSSqc61Mijwr0EojZadsJJTqTNlaR/KWrDAkBDLrk/XHGKmJ8xYlFahEWXSa+4KEyRWIzkJeqo6oHGIihEhWZOSZxoVISBEhNEpnRBHIUkIGS6bpqslJEG2gXbRkfUlqu31DgikkeciJS4uLElWU3XePgXpWEe2M6miO8yWLuqKyDp31uLR5nkIv2dy6wGI2p37Q8p1vvMqx9xQiJ1eSvh1ShoQ/dBy+fIejlx9h4/Et8lzQLiN+EciKRD6CGD2yjrQhMt2rkNZz7VKf/u5lXvnWPt6VGC0JRhBVAtkRfOUg49Z330Ekxc6VDbQuqRvL0gqcy9m+MCLLVbe2nCamiEEyHm8QXWAwGDMcjhF1//SCv8KdBwLWWXSjmc2n/P3/4x/w2tuvkQvN0+YCP7f5Mdz8DR6IRCwEXi7JvAAv0b2CGD2ahkwmolg5UUtFGyXlYMgwNxgpkHRcM5FArIy+xAresg5k02kkcPorrf9eVQdj/OGB3z/k8X7ZxW6swQZdMC+7c+BMhyH4cBIMrYmcpPcHR2t893qLHa/h1GzpxFF2Je+opFwFNfKE8JxCJK3M0d6P2f5wR4yR/QcPePb3v8HNec1sWQMOkyKMA8oI/LJF9AoubGmUktx5922+/UcFl7Z2KEcXeWiguDOzzJQkFD1GeZ8kQsevSznJSsZDgU+RIxtohOKJssTN9/mj3/99Xnn5HS5e2OanP/MMf/CdN3jwXsXx4RUuXRiyuV3irYfQ0qgcf7SP390lN4JceKLQvPLKOzxYzvjsTw2o1Wvkm+fo9Tep9495665j8K89THAzlrfnhEVieOxoA+z5SB565HGIcDnzdgaNRcgMnW11sGWhEXIXqR7mT4bWP5qjO6dP9/GkU8aZ8/af8xXESRuxgyat3Y+751ZPrdfQugspTj/rgwlFPHndistDp37UyZwGatuyN5kQRceVRchOUTImCInLj1ym6A3ZvHQBsVD4WYPvF+hehjaJYFdEZNPVyJAJESBJyEYaoX70jtMPZoL2/Te4mW1w6dpDFIMG3RuSlUMaJakeVCzfeJujb3yd19rv8U0vGOQ5j++eZ/PaZQZbGeHgNR56/HEULUJovDAY4SlVd/BcSigFedb5G2xuDxlfHnL33RmbWyNs1TLaHMA4h6WnPWxBKCoHVkbG45IrV0rGmeLVNw6ZR83AC4SWFFmB6xuM0OhFw8I2qAhFOVglCBLhBbPGkojUbQMpYjNDGgeUzlEMwEFoPcFZJB5rLf7Akj92HvIIbYtODdokqJdI06OMEnoe2zoIln5eoFQkesFonFPkCq0CKcKyXmJjYmtjSPAJZxu8S6iU0FtDYl1BTCixMrASCSFahFK0i5bBeECWRfBLwnLOYlITQyIEuvmNASMsUmlCEhA0RS9DZAIbPQRBfTRjUVu0luxeHCILiasr+q7B+kCczRnmhsFwQF6U+OCRzZy8l3HnzgMCOdIIXCtY+g76UFUeYSTDHPq5pJclqtqDKjmcHNMulsS2gdDiY0uTeixsy/2jCSIlslyjMsNsDoM8YtsGO5/hbE1rW/YmlsZoQvSk4LquAYCQBNsiRdfhaerA5e2M8caQ/UXif/xv/w7/6X/9BLvnB3zqY7s80XruTFveuLdkMVI8PN6gxCBFZL5csl/P6RUjPhcyntjJ+du/9N/xW//sRbwoyfQOx+VPcvXx29x+cJfv/O7X6NVzfu6vfJkgC6yVHB/NePlbv8HwwZRHw6c59+VPszh+ixff28fJiHjlHV564ya+MHzqT7/JX3h6g999a8zBhWvUc8U8HvJ0GVm0ju/fvc3dVvJU+TDn8y/gW0GYfY/tJy3VosXlip5Q5JkmiZy8HGGiwrcK53skm6PQSDEgWUldz5EoCiPJdCRESWoi3i9xKYJPyKgQK9y3W9b43HQKWXQeICZXnNsYghBkpkDKjhibUkBIhReJYDKSW3UcgkWZCikVwrW4RY3JSwQKIoTgiJ4OoqczZK5WKioeJcB7gc4NaIFWnVmeFIZB2YADvTnGFKaTM54skUJxfHhMf/MCrvW0bUNSCWU0pYqEXOHqDhaXFQodoVlUxOWCMu/ReMlYSWyWYYsSo85xbjgHAYO8x53DQ2xbcaU/5uDIsT+3VAdLrogd7jvL86+9Qvq7A376P/os2dUCmoBfeOIyYqtETI6EZHHoCTHhJ3OaxRy1qfnJL/wE929PqG2gUQLjA9nEoYuMWR0ZFImmdhzeO2Zy1Cmqjbe2KFQPIzRGZxRFick2KTYN9YOalCKDfkZoOxMyhubkeu+972CJMZ1g2qs7FWVZ8v2XXmZscnpbU14kcmhXqk3xiMWR5WK+yfaOocgG6FCjZJ/aBMZ5S2kCMQS8SuhS0+/16FrREqkhWt/twJrzsK6ir6AyCfCrTuKJHOEqJJCCD82p94c1Tqv4K2fiP5EgnIVHxM7wDd73ncVqntZdByneL/EoECRxmiScKBEJtdpWx23o3pNOIE5rXkGKK034dOqlsNqhD21e1m0DISQuRfaWx0ybBb6ZEpqWmGl0IcgahVKa1rYsp4JPfPQCjRpzuL/gm8/+AZ/72X+T4aDg+tURlYtMasekDrhMsJUXGBSkyNK2hCAodMGjybPVF/zDX/6bvHPTEtQIXVykza9y8ZEHvPHuTb77W9+m/7M/wSMfv0pEE4Jgsax578VvsFEnBo9eJ98eMnlwi++/+Tapr3nl5e/T+ERvZ4MnP/4Qj14aEm9vMtm4xqG/zTA7ZqOfqOuK+4sZMxt5OH8YpSwhaVLSZJsty3lFPhwg2ERIDXhS+A6oK/CvXCn/Bx/vU+FKkE7c+dbGZWded0at6ARuJOUK7t09eGICuHJWPjHyk+trymkycRYWJ+gI/KfwvPXvAARCDOQmY5D3MKqD0F68fI6HPvoEyQVGJufW/hHz/ZbdSrJ1fQM17Iq3sY2kAGIgMRcMwvxoS8z+QMnBR7/8BR5+7CPYownlSJKUxEnH8tAxfeMWb7/wPN95/RWqqLg8fILew9dRg8v4tI0pz7Hz6BXSOGOYjTiMtyEFtNZoLVm6Fu89SMF4u8AvFbduNIgNw+b16/TqBfiKMG/YOn+Oc7sDXj/wDHON94r9gyWTo4pqI+PSdkG9DFTRIVNFynPMeMjF7T7Jee68O2Vra5thv08bBU0MSKNoXUA2kdF2RpQKGocJoKIiExGqGfWypm4bWu9RGrYGOWowQEiB8hXJWUIbaIIEn6FdoF04sqKkGPQQojO/kMogM4MxfaQyxNbRTiYorVF1jZ9JUhIYrekNSvKyhzSKWLfUxxOIoYOMaImKgRQ148sX0b0CoTV14zi+ex+FIh8EnG3xRSIbSfLxFkJrYmMZbZbkuSSkSHICep1jpPOSZBJ12+2HxDDoK1zdMLx2laAF9UqHu1dk7FwY89ab7zAc95hVjtrOOynE4QhDj14JWkuyJAnzBrtYcLSYcf6RS8xpiTh8CNi2w5C7YKmXDe1yyXBUMhgUSG1Y2JbJfMZ0anGt5/C44XjRYIk0k4pY+86afHWhEFKR2u5md6nfuQRPFy2XH9riz/75P8f//tVn+Te+8hX+xl//63zyMx9lfG6L8aVtHr14jnnleG0RmKmE1Za8X3JxVLIzKlh+7ft85Rf/Yx5EC2JArjIG9oD00h/yE3/mz/Hdb73Mnfsv8Ow/3ac+qvkP/qu/zPjCJteevEj2pU9ipESnxOLwkP/pP/lrZC6wYQTVccthAisa2t98k03G/Gw/kAZPMvnyJ7i9ozj41Rf5/M9dZ++dt3jUXGDz6hZi9DOYjS9x/clA9M8Sjv8xOh4jK4XzA0S2iTaXUUJj0wDnAq6aE+oWqQw+ZPjag+5TN5FmafFtRWYy+oMRJhkqKbB1TfQBg4FUQ7PE9PsIoYlBEtBkox7VdIFrHL1eRkTig0OJyGhzi8VkgRkMyUKiqmumh3Mu7YzxKqcYaKTSrHXeZRBdQqINbe0wxYqTYz1IRV4KbGuJscMhaynRGlovIe9hp55YdeROlXcY+a1L57CLCmt959EeA8kGdK+gnTVkSqJlWqn1gBkMEK1G6BK7PGLn6nWuPvMUeR6p9h5QtQ133nyLuoELgx2K7Y7j5J1n05ZMQ4HNcsremDL0uXd4h+f+7je4/jOPkY97SG2Y7S/Zvzlh95NXuPhkj0IJxiqRywH1YWD54JA5kdH2kO2RZm4jdROYzyx7hws2Roayn9MbGNqqI0hqqdCi5cL1LXr9DJTE2baDDk4TIcF4Y4QRESsErmlZHB6c3hRMdlKsO1thq+uGNrWgLS+2kTvTORc2LjExnvrO23zpi1/h/MVH6J3bJhUwLDa41bxBP9Nk+ZAoHdPljDSvUT1DU/SpKk9TeQKQRNehgi4clKrT5T/FGqeT+7/oincr641Trf4P06n3hz5WfIq1ektX1+ycb9cuxZ3kazwNlk7wyl1QFIlncRl/8iNWD8a4Jn+ewoe01Cs897qKuzoGH5xjIbrg7IcwXGs5vntAe7QE313ztSkgauw8MswUT2xmzG3k4GjKxz/1Cfrjazz33Mv8k9/5Rf7Lv/ZXOb87ZpCX9POM3QStjxzYSCPAq0RRZIyVpBCJ+p1j/spf/c+ID11Eqi22RGJrfh+5d5NHnvkM3/i1r/Hy/VfxzSHN7It84ssfQxU5m+cHqMf+3c7KMSYO3n6Tb/7K36OfBKMgOLh7zMyBOlzQLieYz2zxxX4gZU/T/+k/xZ4uSPf2ufLZx1gePuCCHGLyIS77SXT+CQpR0zavgf06Ko4gXiChEeocSn+CHxeQ3dnA/yzRfQ0e+mAAf5KmrtbGOgnu3iFXa2TVgVx1t062t3JZXsP2Tj94XVg47ZytixFCppP9XKshOeeZpwoXPbtXLrJ7+SIIgW8toih56toOQil0rskKg9ACgzp1Fv8xqV/8QMmBaz0xZKDGNLVDjypuvX0f99YB87plEiOtMJjxwwzLEY88cY3hxcdp5ZDbx463vlvzxXMjhNBIEi5GattlZDsDTWgT85g4Om7AJba3DKNcYxZLvJAUyiBdYno4w04rpG/RDGmxPHl9szPDIeHQWLvk9rzGonjyYs4gCdqZ487+Ai0HyKg5nrWIIidqRb1oUSGwuVVgY2Q40OT9HJ0SRjtUFrHzFqU1WaZRKiPLOufOuDwENaJJER/WEnyaZeUZ93N0T2MbC03nLkuRyPKAGZ6jXtY08zkKjeqVpGmFCC2N0UTbkoUMkymULFAYWiLBB/AJnwQuBjSefDyinT1AlJeIQWNtoOiXpKVnsYwsq4rUQu41tg7YADp4vAKtDVIJtBakVBDbGU0SyNoiSoM2JUIY6mlFMSooekWXGChL0JEsK+iPLzDamJKyORSOLAgcGh8iy8oSWk/eKzsTKu9o5h2caf/tt5i0DpMMeqWcUQuBdC0pOrwuiSspthhblos5tnYcT6tOfajI6JGIy5Zgu4oyazWC1Y1UBo9RiWQlF7YGPHp5izJavvrV36Bxks888hB/45f+Z/hbks888Th/4ctf4qkvfI6Nczmf7plOAtdp6smcwxvv8Jtf/23++//tV5ksW5TpdYZeOhHail/7+rP84n/+73Gu0OyFlntHN3nhxd/h+Gs7fOI//PeRqsBJBTHwzssv8b/+D3+TP7y3jx7kbFwZMG8bqkmFnTbcuWv5R/9LzU9sa8qjX2f82C7jKNgbZfzay8dc+fQuH995mONGkh0JhgPBK1XNo9k5FssrFJUg1wFZbBKLa4Rsl2L4MN7dxjaW6AQSgfQLdJAYuUlbL8hFjjSGutUdtAaDjxZdjlZQpBaEpCwFShl6ww1ihHppcdYiswqtIm2z6BS4lO4ClODQuuHcuW3MYMB8VpN8orGJvTtThr2MvCyJAYii82FIkA8G+LbFO8ti0l30k0vEWBOtQw0Kin5Bpg3Je9plRT7q0cwXlL2IznKUMaSYsLMFRaFp69BxFYoMrUFFD9FzbvccjQ2kKAhB4FwEaztuT/L0B32aZEm2wVsQpkeqLVmxTektSXek6Sw4PvPwM4yHl3jzxh0qmyBWmEwzGm7y7eO3WDwv6Q8yykIRQqLxgrhsiQvTwbxaR2wtCkGvN+a99w659mSGzqCHQERBnSTKR1jO6fcKpnv72FaAykkukeqG3uaY/nZJsLZTuvFpNcc5yXt88phMkZmSbHnaOSClFf62G2ujLb/iH1SupXWOw2bJ7cWE8xd2SErz3Vdf4GA55eLbFzB5y+FiggkWWweOYktWeHpFZCByGimpJjXBhlP88Lq6d2Y/usdgbXz0PjKuEAgRO81+Op30H28xU06+/9ngJa4jFUCrU7jVGgoBqzeciT26OT1Bc3dBj1itobQOu9bPsyIpcLKRk0rrVwdbbQAAIABJREFUGXLkSTVWrGVUVx+c0ofqkHyWA2GtY3q0wC/rTjZZSJASlQKZrSmIpGbA9StXePT6Reb7h7x144iE5jNPP8zf+ZVfRzv4wic/wlMfeZyNizuUheSykfiYiEFgFzWzu3u8+PKL/PKv/mM8G/RmQ4pCY/KGxfyAP/iDb/OX/uznOZ8a7s8Oef2Fb7JROJ66XrLziY8jhOnkgGPkxgvf47lvfI2Xbt9GbY3YeHSHB9MHpP1D5vMpb756zPTt+zxzuU9Wf5XhtWsUWjHPDS/sTdi6OuLqYJNZHVDJ0STHe5MFL33rBS7uSr7Y30L2zmF6T67U6LIPzN6P7ppQZ7t96yT4RFVo9fDZn/JUgeusYpY8AzdccxLOdt7Wwf8ZjYOT7Zz+s1pbsoMhpVUxIqVwsuY6CJMnxIhfKaStp1cXGYPMvI8PgeA0KeAMhOpH95CcjB8sOWhqUBHdzzk6bqmP9mFyn1de+y6HS4cNge1Rjtnc4tHr1xmNCsqtgvNbfXZty96NKWkx40tf+Ty/9tX7HE+nQMIguJ5rDnXGYl4hQsT5xLKJ5LOWwvS5O23ZMBKXEtJahHb0swITLRe2x51yStUSnCUQ2TKJJRkXdodIZZg3kUBiVAw5Nx4QhEdLg+nlRCVgWbGcV4TgupuuA5nnZGUJSuNChiwkMoZOh9pHohLMjyaoUhOqRJSSosw6584QSCKwWFb0yhJV5gjAaIUuc5AaQUS4FnxEZBJdanJfIkRkuVxQ5IYskwTXcnj/mF5eEFIkiojQspNcROIWDdV8DlJDE5BZJAiJE4Z8YHBNQhQCHwP1ck5wLdKUzOpAvy9plxKVaaSWGAOthMIIVE/jRVdR6fVzth45z3JxjFMKYzIKJ6nrJbN7E1QyHB42IANZlpF8IDWW6ALRCXyd6GcFZZnwMrC0Dm8XmIFmaAwqKmJIJKEp+xn337tNr5ez6T1CJGrbEqOnWTS0rUfICD4gUiIh8T4RfTi5SYqVY6IG+jpxrZ+RDXO2dzc5t7NJ8onZ/j6t2IBen6fHiaPJjDe+/xzvvP4a5a/+Qy4/8QWeuNSnHQzI7B0O3n2Nbz/3OocHM+rKMlIZKTXk0WOkYYLiremCyyaiUcQELrTsHe7xt37lV/m5N7/Hl/+LX2TWKr72O8/yu7/1m+zdegeRCXplgfct2UDw8KUehc556Y8rZsvIK77l0XhEllr6l/t84jObvPTHM37hyg5vqyE+KbaATTxXckemHqfMF2TNtxH1EW6pccbR29mmWloycxWROZxtaF1D1dRoOSK6lgyFdzXCR5SMhKWjisuum9Q2eBcIEZJr0SjquUNQkVCd7KSrmR05EAohJNYGlPJdBwdJUZSIBPV0Sb2ocLbtuA0ykpLvuj1JEpxDpITJclIMuCCRvSGk0LV8hQYLRmcQE8J6vPUE5/Heo8tIlhnAo4qMhCA6h5ES7wRaKuyyJXoNeVfNSW1L3u8RPTRJE7wlNhYlFL1+iTAZy8M5vu4I0jIv8FGjSoUpI7I6RmDQMUNiyLMRg/GQSxcuspg2tE6SyImp4vLmmEy3mEzT2+xjyhIfDdFbJjcXnZt6dAxGhjDOmOzXjKoleZkTK0d1tKB1AZ1rNkIDXtAGj1QFm1t9sl5BpGW0kUEuUUaD8CgrUa1eVdcdvu0CxLzUZBqEOlPBW5F/E3SmYs4BCe8dSoiuuyo7WEv0iXh4n3IwxMwN4Z2W+3vv0hspPvrZp/i9r97GJo/yMNaK3WHGnVmDSIqeSqgVZGUdrsbYdVhPE4E1jCahzgQGMa7gleuKohQfvO//WI50JkFaBzwnwcYqoIix45ycEDPhVHkFVgpG7+cDnA30xcmcroIjIQgxIJCn0KwzAdsJvOss/OKDJNAPG1UEvP3223znO9+hXdbdWleqE07QmqGG3ULw8NYGve0B25d3GG9tMLs1YX5/SdIbiN4mT2/D0YMZL33r27z0xy+Qj7fZffQjXN3JaYuCor3LjZff4J237nE8axCt4GJ/SPRHjGMfKxQTJ1jemzFSiZhyQrTUzQFvvPw9fvPv1Xz+1ed58t/5yyxnjmd//bd5+7VXWMz2kaVi0B/i7IzeZsHu1Qssj5e89+acyTTw+s0pTxDJVMX2xojSjDjcm/HpjT73owGl6SfFu6+9weuvfJcnH32aanmLfPivk+UbCD1EiIxVmwlYyQP/iAeipz2CU/jgyUEX61d0QwrRXZM+UP2PZ5LZdWJ8VgJVnH7YCWRx/b5TboM46UiQOPHyWE+glN32Y4ona/JPwBjlOrn/ABTqx3D8QMnB5GDG9HhB2evR2grXzGn23qFZ7qM87Gxssn3+MRrfYzDsE5GYMtIfQXCKZV+ho+Gn/8yX+J1nv8Zk1iUHIcBB5RmN+gxbjY+RxicyG6H1NLOasSm6KnyC5CwyBjYHfUJKZKoAaVCik55qfaQ/HmKMxkjPbF7jbIvEUOqcNCzQpUJJTXSWtnY4axkOe7jWQeiyQSUlpszoFSV+VT2UeJK3JGeJWpG8pxxt0zaWpAyZyci1QkhPpSK+bmFjhNKmg9VkBrWCEVWLOaGuUYhOMcU7tNK01tHTgqLMyPKMmCQxOEQS5GVJcpGmdgTvkFIRfCS0DaZfYmdLVNlJBerckOUZdjoh+oCQESESKViMViAF7ayhbiLKqM4MSkTwDZnuVJcgEoLDBTAJgtI01qNkxPuAd4mm8uzZexxNG8rcI1TogrTa4bxGBU+hC0RyuNri2gV4S641Qkk2trZRQtBWlrZuUcERbIPp9cmNxPkONiKEQqBo2+XqJtZdSGJMndHP2hp9JednlKBUgs1MEVXGeGvI1QsjQoAHBzUqCc6PO8J0iIJrG4r50nLneML0cM7Nd6e8MSppjUDHGcvpPjfvPiAIRVEocpGTQkSKQFKKbNDnUn9MfPcGs9ZTC4kFprbl+fduE6tDbm/8Ek989EnefvU53n3rVYZl5N/+S0/zwvNvsrdsGG5oNrcVfRI/9fmMxRyOX2+YLizxVuCidzxydUC1EWH+Mhtbm4hiQM+BdFDkkpS2KeTjKF3j21v49hi/WNLq+6jeENO/SqwSsTWQBCEF2iqBjyQRid7jfMC5RLQBUkN0/sRoSgiN0BIRBNa1qNYRYiB4TwyBtnFokyiyAiFWl5YY0cagENhljW072V+Z6B7PDHJlcaIEHckSic4U0XmUURBAJolRGq06jf8sy2iW045rklYJIoLoRNelS6sGdIydTGtwxChwrce1DhkCISqiFCSv6Y01ydXUS4tvHdJ3rs1iq0eMAZmV6GBprWfReJyL6CTpD3eZLiBGgRWKViQ+dvUyzmvaGGlTIklNZgryImdrWJDlWYfrtgGhIrFDigDg6obkHDJTBK0JUlAODViLa20nNuADde2IzYKtKzsoDb3hEJMZpBDYBqLtcOmu8R0YRZnODToIRN4Z5SUpOwhXTJxoYtLdFNNJhXpVvV/DT1KgU7aXpBgQQXQ8LaM4niRs0zDoD9DlJo995DH+6Dd+j9Y1EBPeCppWsjUacjCdM6sjbqVQJFY3ZLG6L5zCV1YhruhcEGJaV7855R6I1U0+Rv7/AitKcBKgi5RI7yNTcjotJ0H8CpYBJwHK2XEKPTqFbSROicsnnYYPkDTfr57U7VkHdVp9KJw5Th/uKMqCQa/f8f6EoOj3KMuMQabZyhTbPYPI+4zOn2P3/AbzmWU5c+RS0RvlKCEgCR7a1jw4ckxnNZPb93iwN+dmkVElS07F/v4+R5M5UUsGo4ye6hFsg8AhcsOwN+TSeIN0+ID7UTMXihAtbjqlevMdlvaIuybnsY9/jHu33mR28B7nzmc8/aknuXf3De7Xc85fHjEuYaOnGA8H1PNE9fYxk6MJDsvu5Zbtfh/dN9DuUeaPgoj4quHowQHv3niH5FsefWgHlV9CmHKlwCM4kxJ+6MfkX8pYndsnJmbvf+p9HYQTgvGZgH793FlPhDW86GQ7qw2lMxs+abqdhTZ1D5xI+554gp9Zf1L8CyB0J8vxx2Tu/wXjB1MrmrdUkwUyJRANuY7MmoperhiXGTsXd9h5/EmOjhwhL9D9jLIn0SsCGqVApoKnnnqCc4Mh96TCRYeNiVtLy5ODgp7piI1eqq59EwWz6ZKLu53kXaYEKJDeszksuVevtIBVQvqATBKUpjfK6fUk7mhCvWyp64hWGSkPzOeKUpVkMlA3LfOmwQrYHGyyrDxCyE6O1EgwojNf8BZvBUpHlAIyiS40ujdkuLlJ3ixIwqCERItOvrEosk5GcZAjTNap9ZgM4QPtsqaqKjI6GToVA8K1KN99XJYb8jJHZ1kHsVhV0EypcaElpYgPARkDQmkkCqMVoWlJKWF6OSbPUVqiY+wcNlfFA5E6KFJKUFUNTdNVII0WhOSRpC7g9YEkFBYHymJ6iRAE1lliCIQQcNbS1pb50YIqdVAHksNbh7NraUmLLgSCDO8C3jYIESjLXmeS1MtRUkAMhDrgqwXaKHz0hBTwISCiREpNClDXligTQnQJSheUdpFld6/qPDNyJRgaxTgvCP2SnXNDzg0y7uxZ9g4cRudsD3IKpZguWzYGkQtbQ4ajHg9uzXnw4AY37yYWtiIIiFIRtKEwXeXY5ANoEz60eJ2xffEqn90Zc+u7L3BcLbGiOxeFlKhC8vxkSf7VX+OhCz/PYNyydU6xZRx/8StbTO/W3N13pEHk/2HvTX4ly/L7vs8Z7xDTm3POqswae2IPZDfJbrs1UBZt0BAkQNBCBmRBgrn2f+CtDW+80MKAF17ICwGGLRg0RVmmJZOmSNFNNrubPdXQ1ZWV8/DeixfDHc7oxY1472WRAnrBNlQNnQQqK+NGnHsj7nB+w3fwUuBc5rU3LWedYicn2iV0i8D8YYP3geuzgnd/9zd59ReOiPYVcioIKpJ1GMzC/BHCfgHSHiL8GNk8ws+PkdHgoh+cr0MGXQwV/r5Houj8IGWaYsLHRPaJHDqij8QskVkgN14A0XXowhATeOc3gTlIpZFCD5AlKckbOVMjJTkmXOcIbYMSargn9NC5SiFtHsgMyYIUKCXIIW2eOYOLqzGDfwdiwHGKnMlh6OjllBBCkSIkJclekLNHKZAM6l85JbpmOF67WRCi0ggzBhTRR3zb4buAyoMu/3rdY4xASAPK4HxkvfTD4pMSupww2b+G92lQy1ICbWsePT9l0fZkIbBaUxhDPakxxSBXkRJ0qx7ZgSyhnhZIk8ldJLhIaANeOKIQSCsGad+UqSuDyAyCAz4xGlUUtQE9HH/oHFpq8vb+UD2qVGhp0KXEryPWJvqNX4tvPYl4Lh8KQ9VrmxjknEhZDH4tQmw8BTbhZN4o2uSMd45lDMSYUFoR/JS278nbwkRONG1EiMDekWXerFl1gc6HzWJ/sUhvpTUvHw+ZcyKtki9XAskb4mD65PcOXvre+eUAZxusDOeBlyBXF92BS2++NM+wqG6Vjbb7ehnAdJkQffm1j/+i+RyuxP+v8efB/gG3bt5ES8moKhlNaqyM7BrNYVWyM6mJ4wn7e7tMS8t7989oWkFZVOxOCoxULJYtO1PBtev77EwE88dLnj/5iAfzzHxxgjAWbxWiNBQ2oozEjGaYRUeXA2oy4trVm3z+cMbxhx/yInhcUSO0JlcFroDvPH7O+Hf/Ga99+jrTfYlbw61rmV/48h7f/P1TPnrekWtBFxKTUnH7qKJ1mpV2tPPMetXRPHpBvdsym+7w7Pu/z/7rM16cJZanc/qmRSvNd779Q3aqMTlrEOrli0dsk4R/x8fHDvG8c3aJ6H65+/XnqXidT3X+uXyJH/9ykiSAvOEVnG/OF8+8866ZGJKATEbki4RreP6o8+P5WR4/UXIwqyxVToT1AjvSMBozObpO92KJHc2YHl2nnu3haokvCq4f1TCukEqQiLiU6NrAzHveODzg8cP7PFmdEXMiRHgwb6hLw539miZl1lGSpWLZ9XByRvSO3XHJpLDUoxGiNtAkPrz3guAdO6OCo/0RB7MaU2libtjfrfCLHpE9KI0qK7pmULhRVhCSJOTBf2D9Yk6hLcWkpDBQT0qq2pJdhx0XhFVAakO5MwGZMLVlPBshMRg7IgUxBNQ+EkNmtHuAMhlRDbKNOQtCymTnWJ4tUVJjdkaoDCIllEiI3HJwc4/+rMFai9SG4CJZGjKSvm2JzlOVmqoqSBEKW4IdQZZ0Kzd0EV0EWoLvONgZ0fUS5x0+OnIaDFnOTteYSiN7R46KWJQkNLYo8e0Jvl0Ox6sVpaiZVTuk9QobHau2J6SI9z3r1ZxVE0lG4URJyoLoM8knjIKQHOu1Y2YEpi7IyhCyISmBd4L58zkiJVzT0a1bXOqpdyY8PD6l8xEfEjF4Qt+wmK9YNp6iFHTOEXzAbzT5t4uUEAIDlEIwNpbxaIe9V0a8eaWiXfQsG/CqRguIncCOC6ruGR8sM3duH/Dm9evEB9/i8/sTfl+seaJK2ujohcCVFbtV4ngVKI4OyYtIagKmmnL7rS/x9uwBv/eN79CuzrBSUNmSo1pzdVrw3Sdn/M0dxVc+e43iTs2j+Xus793j2ZNvc/tq5vtTwYkPrDoYA/kRrKLhs780QuWKh99fMn93xXuPHXKeePTd/wP7eMqTna9Q793k7asj3FqRpUaVY6rdXXR9iLSHePE+rluS25LWOZrjhpjkcG1KSaFqEpLYeJLPCDG4szrXkHw3mBEKgxIK1MY3oemY7sxYrQZ5UmJAKUE9mZCSJIWO5HuUkAMUxAd8ioNzaUqU0xqhFN47UgdoSRYZXWi0MkgYpFNFxq0b6vGIwkpkzqS+H3gIZGxVQk7INFwHKQ5yljEXA26/6Sgqgy0MSVt8hkIlVm0iaouWFlsY9HRKco6cDFoHvGjw3iFkyeqDexzdvYNvHW0jCE5jRUaLjE6RZbPiyrWbeDckM7bU/ME33+Hh2Zwr0x2u702x2RCDxFpN7x3JWkaFJaehRV1oUEoMsrdComqLaz2+G5Kb6BNBGspaolRBjh2zymGnO5RKYe0AzUt9BDd4aBirWS3WhNajhUCPLMJY8uIMxADnCV1L33ZkMmv3ctVu2xq/gJOIjRJOvlioyYOgAYkQAwpF33fMz04JyfNbv/VbLN0ZJg9ymSFH2lXie6sFD88WuBToXE9MlxKR8wBfDFK8DNK1246B3Epqni/M+XwhjznxiQiI/i3j4hsN33kodF9U+3POZDEkyynFDaxhA5OQ8twTYThn6VIisVV+GWAmf7ZiuqnGkgcRCikHmNYWXsG2MjscpZKSy/HZuWHaT+t32QSFMQ5dwslkwjgFxpMR/uyYiTHsTHbZPzpifK3k5kHNet7SRkO2Ci0kqZOYkaFsH/HBQvP2p24yEhF7fMpr16d8X614qqd0vqGpCsSoZFx4XpydUb1yheDOcG3DbOeQW6+9xmFxwg+/9w7SnTGbjDmsDTf3CqYTzTv3nvIrRyU3bu3z2hevo+wDZH5Gu/4+B7uC2Ujzwq8HkcOs6E4zfaq486VriDjh/rc+YPliRXyyQB73nHz3N9C/csA3H2ba9ZJCBV69fpOT5yf83h98k7/9d/8epvip/fw/1fGSStHHXtv846VeCLBRJroAH53D71IazDo3fxKXCh55AznezLUl2g/zbQz9NhAk2LiQC/GSAMJ5AUOKAQ7575MDWHpBD0wKQVGWmL0dnn7/jylEy8237nL0qevEZHj20Zq9V67iVvPBdddYVC64fuMKLx49ZzIN/MP/4m+z/B86fvtff4OY4CxHfOOYRljX4LQmaYGycKWuWLrAer2GLlLsag6nFVmAJHM0MZycRbo+cny8Jq5a6p0xyUSuXre8fmPC8VngtMmI5IirJXpck9ygf66ExveS58szrt7YZ6Ikfe8JocV3JZPKgltijMKUlvUy4roeZMTs15jRCN8LSC1mZLHVFCklfQa/OkHo4ckaQsKniFCGejxCA4UJQ/CEwkpFeWWKmowY3zgaMNFRkh2ks0e4VGH00F42RYUpKpQ0VKMJAUvf9GiKgcwYPH7tGF3ZGyodAYQLGJFRpiJ2CWuHyovJLT52pG4gKAeXWS9bzk7neNdTjGswivvv3mO8e5XF86eczk8Y7Y2pxiX9SJEahdaC1mukAWzeuDYK7j+YU9QFK3eCkQItM8YoXNT064gVHW0fWS0b2r4n1oMBTZMEo6llvfD4LuJ9wnmPyoHcJwzgY8a5dN5KV0AhM3ul5qi27O6U8MqYL9/WvDI64H975xn3Txy2nHDzyjVuTCwvfvRjbFjwRr3DnZ0bTMdv0i7e43Fzn4lQiL1dVn1L61tkFbm6b4hmj7tXa+YURDViMhtxa19x7bNf5L/9n/5rVHDUUvH2TsWv3h7zO0/OaBL84Djy5off5sbbY+58aYd/+ifv8i/+eM5//g/2ef47J3z3eeTEZ9oAj84Sx2eJdBpJz07QhUB+quLJo8jnrkn4k8Dv/ZP/mSW/yRuvf4Grn/oqPzix3Prca9z58mvUezW2OiKbKaib5IcP8M++TS+fE8Qu2Y4QQtEuO4qiGIzx+kQOg2ujFpmVSxhTkrwkdAMQXFtNaBOdz3TPT8mqgqyRQmANlPWI9ckpmYTPkhwiJkcoBO7FAtd6rJZoFzFWYqWhD4MChalHSK0RWZB9IPmIyDAZlwPfQDA4cAeHlmLwvIiAthhtMTYOUr/FICWYUEihSCHTp0jwArJDaqgnI4SSxJTxyw7RwGhnIKC7CEJZpIWQM8V4zPK0GdTGUsagMdpQTgp61yOXifd/+GMylqKoUCJw79lHTHYPUTniU2QyHTOZTDHlCJEcXe8ZH8wQQQ9GdDJCcqiRpT31aA3V1FDsFuQEqRH4PuK6gCZQWcHk5oz1co1REvqArhRMNOhMu2zoV55yViFEJnRuSKZ2KnaPxjTPzyA4ogt415NyJPbd+fM+c6FesyUj55w3XhgGpQ1CCEIY5C575xDeo7XB+4APQ2flwYOAKxLtomemCxok8xiZVTXEBc5H4oZ8uG3bXyiGXIAJtvjeDIhtXLCFQeVtcAw5f7IX6+F3TxcKLvni99huj5sk6bKWy+VkaWgo5HN0yQXz4PJeLiBCL/EWuKi8DrCxbWTENgvZTsplVPX2vP3Fj4tjzTnzjW/8Ef/sN38TJQSua1Aq8urBmGv7e0yuX6W6dsCtsWOvPOCb37rHqhdMdvY43N1hqmHx0QNsPOW1yS0Op1dYHwe64+fk9SkTFPLVI1bHJzgZKGaR8U6JGFXcvVbwdF2wP7Ls7I042C0pp9f5jf/+f+WW0TyIgl++e8itfc33Hp8wd4IHjx2Hx+9x85blo/uGd98/Zf+J4Etfe43n33+fe12iSYmVg6bxzNeavHLEZx9ib5T0Y0tqI9dHCr7X8d1/8j/ywXHmoRc8WTSsO8eNmzeJahMQf1ID1Y8lmS/xbLiAC13my285MNvnktjwZC66nRe8gZcS65Remm+b/F7e/2W80fZeG45nuP6FkKSQ8DkQfook/H8Xxk+UHMQ2s3oaiCeOK9daxFTw1tf+Kh9d/zwcljSyoF0MJjd6Neekj0zKQEqaEASlcFyfaB7//j3sbua10VUe7l7hg/kTZMooIDjPu8/mzEYFu6OCbh5Q44KAZp0zOnsW6wXpcUvTSuaux+YeIzTj3V1me2MqG3h6/4TR0Q7Hc8h2RM+KtJqTQqZdt9waV3Q54t1gTiakGQyypgVZDCRclQTFhteTsiJGgSSiK4G0GiUS8+On7Io1XarROuP7jtR32KkBVRBTi1wHpBmjsiXFgBMC8EQfaFzEkCmqEfZgRtIS33jCukErtUlvI9V0RBU1zme0UkgNWvhBYrWXpN6jUqZfr1CmoByNMMHCao2xFm8UoksE58lZYCZTdqZjRE6sVg3Nak3IiaRrkpBUxrLMhqrIjEYVo2qGrCc0x8c8ePBiSIL6gJIt5WjMnZ2SGAWmrBAy4PoVq8WK1TqwNxrj4ppuDauYqSrF4WQMJvPs8TFn60ylFY2PzDtPXjVkk2gXZ2Qr6F2m7wJd25NlpBAZUsZtqmlKCIwYdLtHRvBqLZHWoncqilf2ePtLn2J37vnt94857jyjwx3K0T6dE9TOc9ycMlaG19+6w+HeAacPzri1fsjCez413eNBL3gA1NemXL014Xvf/pBf+JX/gGq54Oy0pBcVr7/5Nn//b36N/+a/+kcsvaOSklcLeHsc0OWa904dNZl/2kre/oP7/PzVz/K5u3f47ekfM3nccfZkxRfKTHrN8K7SPF8Ljj8KVDcEj184jm4Y+qyJvWI0EXzwxHF7JLjVOa4rz82DiitffJvPfvEzlCOLEZlm1XD6NLJee5q142op0PuvYbuGnMELQR8KXFT0j+cQBX1wpL5HGz1IlMYKnwaVByXVoJVvDDkHjCoIXUvyAakMWUjaPpIX3eBgjMa3a0KMJG0obQFZUViQxg48IWORSrJ8viS3gRzWeBS6KtFWIZXGFEMgnl2P9AnyAOuKXcRYMUhZGgtWIbTESAlCElbN4O7dRWKfkFpRlBa3iriVR48tFAVKSaTMaFPQdpn12ZKucRTjknJnTIiZtPJomXCrjrIeY4xhvfI8f3rKaGdK6FdUuhogUURihFJrrF9x+85bTCcjiIqQE+OZhXXCtw5ah1IZLTM5RdqTFTuvHjC9VhFjZH28opmvkYWhrA3lSOMWbqBQiAxWMru6D0aTlSQbgdQRkwIEiZAjyBGpQY1KkvO4R3NyYYgIUgCkHOCLBFS4WCXlpWBSCjH4EEhJ7wNKCPLGHGjYvtXHF4QwVHaVELi+J3QOZKZvW6T1zMqKqbbUIfPzR9f5Pz94l5zS4Mw7TELc9vnhJWOjc/hQHuBcUsnNIzIh1GB0d14W/ISOj4OixPl3HoJ0eU7IHrZt/70N2LeV0iFZEufvlfICi70lcl4oD11KyuQiS5eUAAAgAElEQVSAWd92jLak8G3SsA1Ah6rsxlF5Awn7aaO5+r7n5Pkznj16QOqWXN2r+PRuibdj9JU9RjcPObp6nWku+NMP7hNI7N6+jpIjYhTo3HPWHDPSI2596g6CEvXiAbtnj+l7zytXrvFknenLKQd3JkgTefrghM9/9QsUqzUPipo8mXLzjde4c32ff/mb/zfz6DFlxS/uBl7daVgm+PBZy5TEb8wVd753j4Nf/AxHh0fMH0nsyQv6dcXrJcTdKU+zZb7OrJaB6hCeLNZcvT5lHQyqVKg28ey052CS2TtbEZbPef/JmuchI43h6Q9eAPklH4tP2ngZ75/PO1Bi2HgexF++9s4vt21XYbtNXAT2HyfMn3e/5BDgayCEeJ7int9Lf+Y63twPKV0kGnyM5PwzOn6i5MAqjZEWYqZvgX5E4zzRS1aPHGkksOOS6VGBmtWU6zWxCcR2iVs2LJdzGE3YndbYWcGX3vw0er5g750VP1o3PA6emKFOEec8Tgmm1jIJmaPdiiwGXsHIBmaFwMTI6bol2RIpFG3Xo1YKPalopYZVzzsLycG+ZFqV6L0pD+4fI+qaM6UwJJSxpJyJISCsxfUtFkNV6o1jZ0fKkqgsxEjoOhIJqSVFVVCNNa7pWC/X7BztU+1PMEYCnuw91XgCRKStSS7D2ZKwXqNyJBhDVYwpjEBJgW9WZF2BKgjNaiA7FhWmrMhGkpTCREdwHSlpYsokNUhoduuGkBNWGozRG8lVQxI1ou+oC01pZ6xXa5bzJTpoyvGUjMK5DpEdpRI0bo0SCqM1u6OCgMV7zfMXDaNJpj875frBLst+hVs7vK8QoxFlCty8eoguNPPTU/o+k0NmvVxxcrLg5hs3WK16tDGDU2voWZy+wLkeJw2L1RppDUVdErqO1bolO2g7R997ehcJ3hO6wfG294m+CwSfyHHgtCgBRgqCVLxxY8T1t15nfP01wr37VIcjFo8ek8KM3WKHWTUlhMj9h+8xHtdcG+8yvvIZdN7Hn37Ee77k67Xh3XbJ/pXbzEYV3Rgaozj4y3+Vtz/zKd7903cZV2vu3hjzlS+9RbFzyIePHiOEoLCaokisUuQ4wK//rUP+0f/yAj17hR886LlxesiNr7zCf/jX/hV/+C+e8ku9YCwFX5Dwc1MJ1wrePQh8f54IWmFGJVhJWCTC+wG1FHwYLL80M1y7vUd1BGeP3sOZCenONXRlCU3L/P6c9aKjGMGj04jtlkxnJT0KjyaTqWKm3Nujb9fIZWDZdjSNpyRiVAUpsFiu8G5Q5IpKkoTElkPSn4JDFZIsBN4HXOM3bVi3walbEIYQBcYOHAStNYLBCyC7SHQtfSMoihGdC5jsENkMFe/GkYuhW0CSA8cgZVJSmNSQyylab6AScSCXu94hpEArg/MJWyhsqfC9w9SWmil9kOSQia4n+R6Rlrh1g4wKJQ05ZLILjKwhj0pyNPRWErIlbTod5ahC5oRbL3DOkVAgFZ13nLRrbl99ldJoCmvQSpOjYH08JzUNZT0hOoesQGpFihJjJMn1iLoAJchakATkPqBGJYSMtZKiKNC1QhYKUEM3p+8RWRFCJgdQQiNyIkVPRiHMAG2MMUPbYa3ES0USfthHYiAln4+hY7AtGCsliZsqWXABrYdK5QDFHRb0lDYchJzpN1wnpSRlWZBk5rRb43zHTlkhRxO6GDet+jRwq8SGa3DpKLYBrkiDJdIGZv8SIXeYBGLMF69/QscAmxLn3+lyYrStqG6H2jhJb0e+/AFxKegSl0Kalwif56wBYKMCHdNFEiBAScE2Pct5c50IUEohctokJFs40l/8D395SikHfpRbrym1YmQsopry6c++xv7dTyGlJS5PkFVk9eQR0uwzLaZoWZBXa+YnzxhNJxyM9zE7r5Cew2oZOQ41d2eRx4sz9u/eZVwr3ASakeHg1pvcuHmNjz54wG69w+0713nl9hUiikePnqGMpB5byhrOXMfOtRH/8a/e5Df++RPs1c/w0b1T6i8d8urd1+mbd3j3/Q95NUClFG+IxFujgm6seT7zPOkiUVpMPcGKTJgH8sKTVvDQVdyeKhbVGaLsKXsIGear5fZUfnKH2PbBPvbyplJ/boYmLjpg8dJzYpsYKKmGZELkIZnOQ7IbL13zYpNE53zpNfHSbXPO29h2IC4UkIZ5xcU7f+bHT5QcCCXISuCSxmeNbYGsEMWE1bNnxKbhys517Kzk+Uf30VWJyCUED7lBFwJtM7HvWD04RrrEweyIVw9v04gHrJYLYk5UWqGkwmdJyIqDUY0pNCvnobB0SI7XGa0MxvSUhaLQhhADzXJB7Fui79DF4JbXnXnsyA6mPtagrWV+tsZqgSotyhh0CUorunWgUBrnHEokKBVWgvABqyXOZ0xVoe3gDaBMifMOpdLA81IQ5SbDlAKhhwss+g5ixFiPiBCEICIoSjUssiRy8CQkhRZgEhFADCRNYw1dmzCFQRd28JxoA14LinpEUWUKIxE+AZHQtvRNBG3JcYVUQ6VRkRnVFqEVbn5K6zzjUiHK8XDRd4GmCZyerjE6Qg70fcPSL1h3O5jcoYTiZL4mZUlRacrcM9qvOV05dLNm0fT0EZLU2EoxPagossPbjKkKMoqzkzXPT5coBNiCmDwpB3CJvu3JQuJTppSaymSMAK8SIyVZ+0h2iRyHxICYkGSUgBsjw9d/5Q1ev3MVa8a0qwVFueIPvrtgVu1R3PoCypbQL1H9KWfrM26ND7j72peYqZJ0Mic1Z4yEJ4g9MDXTeh9xsIM/KsnXBW+NdymXc4rJmNF4wt07r/K5z3yKnDyPjp8SY+TmwZiJ9ijhqPrITttxeGWCC4k/fHjGzadr/kpR8Iufv8t3/vfn/OgF3DSabpnIbWC8B3dKQXmkOZWw6jw2SibTgslXr7D/tbv88AdrfvC73+PFC4+a/5j8gwVv7n3IcucGo6NdDqcVmBJVllhZMPea7tQP6laixNSWsjaDEhCGQmZa35GixMWMXw369xo1eGP0kSDAGoW2BdGDUgZIJDnwCFII5ARtM5il2cKitSJlQY+H7KjHI4w15OjxncP74ZiyUISYBsKxSPiuxwWPIZ1jrEMcMOlSRIyMBB9xqx6ROmxdYqtyiDFDQGpFTB65MQtESYQaPJMQDKR31xOdJzpP13QQPEU5G8j7SiGTJHSeLAz0HbkPQ3AqLdIYTIhoIZnu7VK4Hh8HZ2FJz/XdKVYWxABdGyh0RgsJQZJlRheK2KchGFMapRVZSlwfUbFHWE1RFqhdQezdQMouFHKksWONUoLoAn0fB5yNksTODwpa21hbgpRmYwY0wERUUSDlUHfrQoNUBhUiMQaie7n6OFTZ5FAhEwN+V244AGnzjMtpqNyrDawhX5IfzSEToiBu/EdEGjo/9KCN5up4TF0U+JQ2jruXYpx86a/8MtwION8H+WPmZ59UaMVmbGFc8PFE6SKAOodXbF4954RcglRdrqQOv+sFcWAb6Ih8oUJ0DuT42Dm4YDtsIEwbIvI2EYjxovL604yXUkr8zv/127z7g+8zqktqO+Gzb73K2597hcOjA0y1DyHi6DldRHYmR1R7b6FFRqzXhG5F2yzZH+1x9OrbmJDo1h3SNZQykdQuoiipx1Ps3oi4L9mZarStMF2DGdeMxiNu3rzO3v4uDx8/48MHD0g+8MrNMSafoWWg8h1lbbnyyj4+JP7NDx9wNG/Zu7nPjcNXePb9hzxfC/Z0iV8mbGipS81VO3TsGyFpfUuZJcXulGJ3H/3qDvd+fMY7f/gduqgILuAbN8Bqu/7c0+cTO7YZ//n19fL1K5Gcw8vYdBcuffZccWszx9aP4Dzgv9RdkJvnSIZLibK4dB8Nk77UidjcIS8LlL6cWP+sjp8oORgk4gRZGbKtsKXBN2FQuVEGowf5z37tSUGjtQIlUVpRlwWKkiwy4bmnmS9x3qPrmtn+EdNmzsz3uBgotEIpOVS/Tcm4KgmbKpY0BoTCx4y2ktGoIJMxOpNzpPeBdfQUOlFJT2E0rvOsM8jCIqwm5ojvHT4OC6YtYTraKObkTE4Q+0DMAZUkOkVkjNjaDvJ9G5xr3PgdDF0Ei1QCpCBLQQwJtV3wM/jOE1OHzA6tQFZDxU8q0IVBKUnyA5lSGcBsnfoGcG3oHGSBKSw5S2IXB23xod+MkgzVIQnRe0LrcMsApoLUoYwgqeHhruTglOpWS9o+YcpqUP7IglINeukpeFyG4Dpc1xIjpEKTTWTRemJSSGnIUdCue3RVsejWiDjAk3IOkDzGSkoUOYYB6hED3jmapiPFjLBiQyKNyBSGKkEMaJmpC4MiorQm+kyfAp5MCkNiQMqonNECpFV8/nbJFz9/i1/4+ucpomVx74T+3iPmbs2T44JrV65hytGgY7/qmJ88xiaFRXL14Aqq7+mbFmMMd+sxXSy4qgtmoqI+PCTcOWS9o9mzDScPn7M7m1DdfIXbd17j8Oohz5slq2aFQnJlOqFWa6zzg4t0H3nr7hE/+KDnZB358cMVn3kKr7z6FT7z6R/QP06cXS1Y+Qg+IZcJ0Sb2iowqFLqBKir2RxNmN+9g5KvsxI71owWnHz1n/WJB2y44e3IK9ROuvXoDc+sQXY4J0vJCCnovqHOkWzVI4xnvaKwsEUh8l8i9I7aZjX4lrsu43g/yqHEwnlZ6UI0SQhFcHirsMRBDxIcwuGLnTNc2KDTCZHJMxOSJQpCF2cBABtfuvmnwvUfrElMqyGGjSjXwSMiDyo02Guc3qlsiD7LdIqGKEhmHAGW7uKQk0EaR41D5V3YItIIfgs+QBUIqlFAkoRAigRyq3VprTKEw0hJTIoVEihmlwYewkb0d3Ga11UgpiCGizRCAl+RBHhlLKfcgZZqmJ/pEtHowaouDIZwUGWkGuVZpFGkjEev7QX1JZTmojdWWpIaFKGmJGhXoiUUSiTGjzGAAlfJwvHmj8iP10KVB2sEgctMVUFIhZMb3DlCDdKyyoECp8uJ5n7cLIudQHSHEpmK8gaWki8raNlng4lPnsoQpBsQGqBTzYICZGLwMzvkFm/1KIYdK9JZseKmk92d0eM4Dg5dWKj7ZZdSLwOdCrYVzBZULUMOf+dh5cL4NdF7CoH/sA5f5CttWzHnoM0Rnlz72chCUch7kgTeV1JeO9ac0/uSP/l++980/olvMufPKbd566w3efOMORzdGaFHiVo6uX5KCRJYzrtyZsGJGaFrOmmesl3MKDAbFbHeftBokkOvKokc1MVp2TEEpLOZwF7dfkkuwwtGedUxGNeWV6+weHlKUBb3rOD07xaI52t8l9R0yeIiZWmTu3D3ivR91nK4jz543zK4dcnDwFjdufoCfB9rZjD62ZA8Wj5SJiY5obRGdZiIsdb2PqW+T/B7juODxjx6T3rtPCJGu73B+6KinT/T1zrbv9PJr510vzuGEL3EH8p99f8rxpSRhM/klOBKXigebPYrt/XLxqriU/Mrts+nPwc19ohOyn3D8RMkBKaONwdQldlxha8vqpMe6QLW7Q1kryIqTR0tGh9ew04CTAhU8RRBokXGxIxugLBDOoceGam/GeDHjIHZ4kQYnT6WorR5a+gK8S2g7yBhKoxFSIUVkrGvmyzWIiNaZkIegvTJgcsfIVNAnlm1P5yJSCfp1Q6nBkXCuJ5OIRuGyYFwZRE7oTWXM9REJlFrQu0TSBhUDMg4+Ad51GCOQhR0uFCmQWpOCGnDbSpGSJ2dPCoHgO2SU6NEIJcwmGTAYY0FpYhwyZCkHw7SMJPmEb1qU0UhVErtwbgCmRCb0LWRJbDNFUSDi4OpqRCLlcrg5fEQkNSRnPuBjT8gRgaJvuiGg2OL0vKM2irPW0XaOGD1WCXLscSKzChGrS7QuSVnSNA73YkVWCWKDkgkpI0JGMBB8pE0CJzTRLenbHt+31JUmAl2zhugQcsAdGwFkT1Vb+i4gRUYk6GOmayPJRcxGMrbUirGR7M0sf+ev3OLnfvWXUHmf9//wI55/7xnH95/z7SYjDo7o7AH29CmyS3TzYx6+eMar032q/R1qCa4JxKQZz3aYja9y72TOK+KUQt5gb2+PeHCde9IS5Duwe8A1MaI4uMXNV69hKkt32g7BrKoYjXbYNwK37lkEz9RqPrs34cfPPMZV3L+34E++veA/+Rtf4mv/0e/w7Fvvs5iWeJMoTCCpQPfME2wiT2p0KMmxYNFOWDybsDxeUI/3+bmvfYnl9Ecc3z/mxdLzZO2olWPm55w5DU3L6syzWK4YlWP2r+wR1ivKwoFTZKeQSpEc+PUC5wdon8gCYqYLfhNrSbSEwhqKsiALTbtqUVIM8LY4GBB658g5EWOkrmuUUuQcGfyaMlJkcuhp+4T3PX3TkXzETmu0lRAcXgwNM6UF5UgjXUYXlj46lM5IoVBCkoXE7ozQLhD6gCoMAklMA0yH0HNeAYoM0q1i4CMoI4lRIo1C4YbEvSyxWqOsQpuSru3woUdkSaEkUWmUVMgoyArQgigVXdsRewdKUm7MCZXXVMawXDm6pkWYiEgl0Qpy78EHxH7EViWq0KAlUSiU0fTN5vcSQ1tcaZDWQI4gBErLoROCQNhEVQiQ0K/98F3lFjuuCD6SoiTEhMjbTkAihYxrPVoZhEhkZdGFwRST88d9ZvuBi4B/y/HJ4nKlDqRUIPJFTPmxNv1QxUvkPCR9fUi03nHmOnKKF9CYTaKw1fQ/P47hf86Vcl4qnV8an1hC5uWReQkqJAc8EfBykLP1H3gZD3Hxs+SUh+6RuOiynBMwxVYq8gK6sd13Pp/kcuBzsX37V9zIRw9JiPzzTsdf2Mg586ff+iaVUbz5+mvcuH2br379lyknM1xzgltnnHtGtwqsnGF89YCinBDe+TEheJ4sz5ifLbg63cPujDFkuiYhrGW0s0N11rF4sWJfOJS8zmQ2Zl1PaIQncwqjCXsUmMke49kMIQUxeIgRVe5Qjw4wdkG/7HECDouCO9MpHzw9pmoPePDwjJ0b17h+9Q3e+NyPWD34Hut6SjIGTCCmhtC0JBXIRYlOIzw1y25C6C2u7SirGTfeep1v/+m7ZK3xOdMGPxij/jneAJ+ocYkjsC0U5EvX9znpXg73Q4wXycFLRPx8kWRsyfYXNX9xcR9sd3v5EDZ/to+8wcdDvtQtOD+OzX//fXKwGbauOLi5z/RgRg6R9aMTTj48RRWavVt7VLOSZtWyPk3IcUJMBrhMd7Jg/eIFVSGx0x2y1ey/ckh+IkjCodSU3l9HqkRdS148P6ZzHi0z0rc8nicqo5nWNdYO3gMRgXMCW9XIVYfQmlIJjAk0radtPF0r8K5FxowPmcYJrDWsfWK0U7KXHAkQKqFjQxMVEwPtOiJFQlqJMIooDVFEHrxoMUpzeM1QjEuUNaAgpUgiE5slutSYeoeirChsRhBo5gukgMHHKRJyYGdvnxwNZEPoPLGJGFMgi4J2Pkd6hzT14DDsHOXE0J02OGnBgXQesaka6lIQ2oDyGVmOUFYg60wsAkJrUta4VU9IHpUiOQRIkqODmnbe8vx0zbrpCD6QMsSsqbKkWa6JAlCGTKDvOpbJI6lZ+FOEnWJ0jU2OPrasVWZkMtn5QTmhtLgUcH1i3R2TK0tMErd29E3LtJoh0YzKREyWznt6H8gpE1UC36F7jwuePkW8gB4NSrI7VpS6o1SCO4cjvv7Fq3z+V75GMbrL8e/9G779L7/DvYcnBCP5YBUxO2BkTe5PaY4fMD87pciaR8szfv2v/zrxcYfOE3bLTIgrnuoCn1csY+L6/oza7yBXlp2bgfuNgpufY6e0HIrIweEIoTQ6eaxUWF3id2boUSI9W9E8CaQomKzmHFyfcRws9+5/iP1G4st/+W9x9VM/z/t/fJ+iBUYKXUJdZWRteCYMT8U+K2qeP0m8eL6k675LsR7zd3/t17jzuS+j3/wCBE/y0L77Pv/4/5nzrXvf5Z1HZ7x55y7XD3aoy0RtZzx4foJVgIvERjB/1pEV7Bzuk5zh9GRBEhuvARLTUUmzSjigLi1G6yERRbGcr0jZMZpMUTFC10LfgtJMKsN4NqLvItEnCq2oyxqpNRjFerlCpozVFqHBh0Rqe1IuEdpTVQW2KClKiywSvYsU4xFWyeG7Og9ao+vBIMyYgQcQXSC5yLr11FOLKgpizEg9JAIpaYpq6FyEJqOtHZS9moacJXo8QtLSrc5YLweDRCUFRVFRzia08yVGDwl9EJmu6/FdQ2ULtNHIPKhn9X2kKASH+7v0q0BhK6QthlK5UUj8gJnVghgdiIyZWBBgCknuE8qloZkuhvK6azzFvkGEQFptCLhCEkOPtAajJDHLoZpPhiRQuqBvejAGKSRSRhARfEZri5RxcCNmCMhTuHjenwePmw6mEEMnYCuXebEgA5ttSqkhuE3pvMOqlRpgD+kC1pLy0IlBCkhDMpk2kem2Cnoxf2JLhRggAZsq9zZePScsnkv4f7LH5Sj7HAZ0sek8sDmHUQ1bxHnrYAup2Eb6+fwcbSfdqr1ueQXn7+HlBOuie5TJFz/4+VwpDQms1NsE46eXIvyd/+zvkWLE2AJrFCkM8ru2PGS9OKbPCrN7hb3RmEXTMa5HCCJt8xzhe2QQzJuGv/TLv0Z41qDVGKsyznYslSKkNX2fuHowRbYls7FgVGeWwcDOFUZGMSFSlpZERGeYaEtpxvjZlDpPaNcrfD9A6MrujMNbeyxaw/vvfJ/JoeLgymuMDj7D83sfYH1CGIs2YLKFBCtK5uIaHWOePutYNi8I/ZoqTPjqZz+HvPlppje/R/X0FLluSX3/MxGeXia7SyEunI7PCfQX1yIwQLazeClBgEvB/uaBcP4seekOGrZv5xVySEBE3pqeDe9RYnuPpZeS580OLzqbPxNn4N8+fqLkYHK4h7E1i0dLumWLLKAwFuIK70akRtGvenb3Lf38jKcPHzLdU8S+I7tIubfP2dkL+qfPOXjzGrlraM9WrLsBc3dr94jjsydcn00IKeNzQulEWRfInBBomk6huoSlI/YdT1YQK03NgLFts+BZmzhdekoJz5YtI6OQUiGkRBuYTi1lzqybiKkU45FlPC4ogqQFdkuFHEB8GKmppxUlC/YmQBaI0OKcQI+m6HENAbILlOMxSmvCekXyLdEUVNOKcjImuzUUlnr/Cm4dEOihJKhGCLcmxhWJDiVLJhMFhcZ33XCBe8/6yRnV1RusXzylrGeMruxBkjSnS4SdogQkseL0/lO0LalmM3IqaI6foEjkCASHKkr0ZAe3OGN93GI0hNWC5myJCxGkpqoqOmdYux4KM8CYgmBkNKpb0ISGx8dr1rqFoqYgcGVW8WxxQj2qaM/OBsnEvQmzwyn70ykP2zXtaYv2EekDgsRYJMa7CimmvHhxSo5QVzWMLGfrOd5lom+IPgyk4xBAwqiq2RsZ6r0xt4+mvHX3kFdevcLZjx5x9s1/zdP7icfPWp70GZ8kR7duo63l+voJjxanfLRo6LrIjarijetvYh+vadwMp5eMa8/uSOIeTbjeSd5dG+YvHlN8+tMUt64gDiRfPrrDnz57zs5kTK0Eupb43vPkccIWU4zI3JyN2R87WldSdIrTndeYnTzjK1c+zR/JBfcffci9H77LP//v/jF//7/8Gn/9b9zl3e/e48lxx9OV5Pig5LW7V/jusURUr/PD3/6A5YdLdnbH/NLX3+Af/qf/gC5VxKXlNO/RiggiUL59g7+2E1k3X+X0G/+KtDpj0SgO9q9BD6XqqasJftmwbCJB9tRC0PVnHB3soYTBKj9AVnxAhMzIloi+QfqhA9a2ntOlgz6yt1/Ttp6+awgxgCk5nI0Axbzx9H2PViXCVIOOvcpk12DlwE9Qegjgm7bH2IKD3cnghKwEiEjfusFFuSgphESXBYiKHNNg5mc1ugA/75BGIIikrkMVhhSGz+mxHrgG3hO7HgoNCIp6463RDjr/IUNnoK4KpCoop2NkFejbDkSmGBv6FZsoNCFFQsvMwf4exIRSg+51oTQKRTGtiesOj8cYgZIBEhRFjbCK4DrWKwGbVrjvHbaeoILEtUMyHLNFCDnA8mIiODUYQYq8UQuSJGERcQi+pTUIFNkHfBvwMUGSqDxs9/2QOCgt0FqjxxWSTOwDbt2R8wXn4LxqlzKIRD43zxqCwMtd/W3gn+JWd38rR5jx3qO0vKg6n3cbJGGjeJTyRaA6eBmI88rhUL3byhJeJAbb6mK6BG0amiuf/O7BJcEVMnnozHxMdSWz5SRcBOaXSdpi41Uw8EAuuUZvG0KXJ7s0zgOu7bFsJ8yXzt0lAuhlH4SfRpi0PZ/1aHxxwDkhdYGQmtB2TA7+P/bePMiy677v+5zlLm/vfaanZ5/BDDGDHSAEgBBJ0NwXSaQkUhLJREsky7FULkdeIkVVcVlK5HJKiSMnsUM7UZUtkbKtMkVKJGWSgrhDAEgsBDDAYJm1Z+n1db/1buec/HHue68HoGRGZVIkNb+qQTde97vv9bv3nvNbvsscM0tLOKCztc3mqec5eMdu8v4WyRlBpZcSiZD56QXE5hBnYkzQpxo5ZK4RMxWmc8XqdshwbY36kSVEq05cbVKP59kYDKmEkYfBaUE2zBmmmqg1TywN840aytVhqom2MWllkVq/zU1zx3jSbLJy8TnOP/N1ZsQWN99zkOO338TKxVN0hinrWUSl0SCeWmQ5CRHBYZ7+4lPk2yl79u3m5K1HuOXgnaSFZO1ym2GhsTJCBRFIhVQO78z63RuWEkYq8E7xO+LaAmAyVXiFstCOi2/kgSBeRr6/Zs0a/W75/WhSKcrXmiT/XDPZmNQH/ib9XucdfFPFwebyGu3pDSq1GFUN6A5ypqca2B7oQuKcQjZnmAkVNkx46bFl2EppzbYId9XIBwOunG/Tqkk67XWG3Q2s6YPMyTsbTLeaJEWFPDdUlSAMHITHv6QAACAASURBVMiCjlUo4djq9qnEFWq1CAhYXm5jckmWFOyZm6VZjYgSQ78QJNaSdgYIC1maMl3RzDUjpEiReG3yxmwdqyYSkfUY8gKMgzAO/UXivGKRCCPmWgFOVyiMwZicdDAg0J4wFuiAMHAo4clZQmQIW2DSBCEcQonxiKpSa+CMw6Y52D4qFChdQxoQ1pAXBpOATHOUkNCIqYYRssiot2KMct7UJWxRqcyg4wqF88ovUuReN71fUAwS6vU54tCbhWWZI8tzko01htt94pogl5qhUQRxncAa2r0+m1sd+umAImxh84S0yDA2oyYG0O+gdMwdh2a51E1Z7mxireTq1Ta1SCFTQbM6MsrKidurpAPYPz1Pb8RBEAY57KGNZbuzTV5kZIXBCg9PyTuCYghy2KdvHFZoChTOKhqxZGaqQSuw1APNfL1FU4Tkl1fYXOny9EtdrlzpMsgKpNVspRXyFcFSU/P586fJh13q0tKUgu08J4gEleMnWH3oyzSnFGF9DyaZY27fFGbtGWbDBYbdGZJVTaMtiOfraA1HZw8QB4rtwTb99VWK/gaD3hq6NQVWcjk2LE0H1NM6l672aA7bLBxpcer8OvXAsefgfgb2EF/eGHD+H/0Bf/N9U9x08wLHB13OXk154qrkj/uaNaVoP/ICq6fXuPfwIu9862u543U/gEk3MHKIqMbsm6qhdB1TVOh3cpr1Lhv9kKXuPC+d7XBlU7LZ2WK+0WSg6ySDnCTLUUVGMwiZnV1EV6rgDLXS8TjJJEkKqGKchBqnKYZD8sQXCiGKzlaffmaQzgsEaBfQ7eYkGOLqFK1WDeEKAm2J6xV0XEflA6yQmCDG4Um5yggqMkIUBTr0hPkRPCaqNBAEHgqUgo4VcS2mGN2sxhcZngirCKeVN9tKLUEcIqVPHhVghaUYpggVUGQ5SS8hTTwfApMSyRpZBgQhAaAlBAQMugOGwwKLxKkAaQMUgkgqbJ4R17wXgbPeQT0KFVmvoFJrsFBrlZwIgUIipII8Q8uQaiUmrMeePJ1bkq0+eQEirkAUoOv+7857DiyEWYZuBRgnESogasWEVUWy3sekDonEOo0pHHky9IpnUuKSnDTJscaitcSGChlabwxnPB9D10Jm9kyP13tn3Rg+BOWYvTQXctd0mr2SUZF7zlnZVxlDHby2eKkw5ey1G62bdPWsG/0OjFLNEclZCPxa6CaTitFv7eysfy/s0zu7pzsalR5TMQrr0GXH8+V/s3/IeenS8pFR0eAYJVkvIyGPv0zgF2LUOS1f/xroipt86JNabAJN/S8dL+dOOOR4YmKF910aJW7TMzO8+r67Aeh2uzDokaUJVkJtoUW4a4HOM6epz8egZlGNaSoLCruxTD2aJdmqUdmCaEoS1DRawUy1hZaSYTYg6/TIkgRDTrgwhzWK9SDnaFTBRXVcv6Bie1QWW5y/2maqaglfdZJhDo8ud7j48c/xuvtm2HvwEPlgg8vtnKtbAWcGER0kW5dPs3rmAm+/9y5uuvUepncdwBVDlJI0pjS33nQDG2tX6G1vkWcZvV73ux5W5GGJ/qoUO64t39kfFQGv5BmMGgovN08bPV2W98w1V/tYpUi8opEwItwL5I7HRr89Ofa4eBCvPMb3WnxTxUF9vkF9uopLcswwxQwj9HSMqIUQaIQOiBSY4ZBuMmRm9xyRyBlubbN5aY2oVWXP0V24dIvV5SsU6RAtC3SW0ogVVZ1StAI2tssNSUJWFLhhigkUcQjSGpLMkAMyjJhuxWQCBoMCk3nsXQXLdKSIZusUeYo0EmsKVts9wkgz2wqIGzUKoVGAcgaRWVSlSqwdUOCE9PrjAkKt0YHESEBqxsQU6wuBKIwIlEYGAUJJP+VQGoHFZX2vuR/GCKEAQVCpQzakiANMahGiJHkagXSSYjiASGJ6hiIxCOOIGyFCTDHY6CNzgcwNQuYIoyjWtjGFI9QVZvbUsbktXVobFFtbDAcZWIdUksApbBFQDyq4YZ9MOGpakwtBkkPuLCudbbIiIcgzUuswwhFowdWtAUJIQmU4d2UdKyTzkaIQsD2EoXNEaY+oFhAG3gfC5AYZBHS2u4hIEusQaSzbvZwogrgiCVxI2h6SZQWmcAjrCKxgZjammwX0M0uSWaKKpFGrkqYJCYp6WEGoCnmm6KYx7XbO5S1L4ASFUxQyJNYRUWhpd64iXcaCthhryG3AdHWGu+/4fs6tdokX92KHW2SDIRXt3XiL+fuprbyA0B1E5yLF9hQ2niZXIVPTlvblNa48/jCikqN2TdNOCxqBRqgmgWoSBAFBPUXPOfKFKZ5f7bNo1yjmD9LOZ2inksbUOmdehA/9xxUeOGE5PAdzjYgT+0NObznWXhoyuJBy82Kd177mBDfd8SpfUOoAXAUlbXm9OggVKs6oRCEuzujvP0q6eoneRkatMc3M4f24K1dYf+kiLulREQIXaIZum9augEDH2BTypCDPC79IOq/ulQwG9NMhwmZI67G2WZGz0u1RCE0YBERao1WOCEOkstg0QQ8SpCuoxCG2EmFFwtZ6m2bdS/Za4T0GqrUaoQqQKGxhEVIjpEbipSx1NUJH4djwJs895EY6AIXUyndHC89JERbCSBFUvHyoKTwePwi1hxkOc0xqUMIRRwolKphMoVVAGEZ4OwWfzEpXUJ2qM+ylxIHG6RCpAqSDYVogHJjca15LIREagijEmoxQKWQYIbMcm3slJyFAV6tUalWU0mAETghUEFKbCXEGnNJY6V1thYFKMwYT4RAUmUBVAnQcIJ3FDjLCeoCN6p6PlBsv6CA1UhmvoGatv1aKAldAUKsS1iLveG1yAu3XJtudbLKjxHwEP3FuRM6bdI/HqkVCeOUiSnK4EGNdfeFKRZsdHemR7KVgkgTv5B8CZdfbfz+i6AopsMYix5ACN0lqX5GsfneGoJRvFf5vVWX3f6ztXho+Un6+OzumvvvqEyFZnrNRdi9FWXgJxzcyinvF57fjuNZOzt0rfjj6f/fKR79lIUS5n0IQRdeStYWfaCTDhINHDmPTlKSfo4xiYfdeNnsZ4cIcJu0jgoxAh6haEzN/krC4jAj6uM4mLo9wuoWTijiwDLb7bL10mnihTiI1ubW0ohChmihRRQVNdCOliAx5rU5/K2GONczMIa70qxRRQVzknF11pF9a5tVHHTMNwWy1ztBFXBoY1jeGDFaG3H10D8dPvIqp2RkEFpRCmIAgMpw4eZzzFy+x2d4mSRKvBDYqAL9Lo5x7+Ulg6eo9mgwIJhC6l9fCE5nRUVE8mXft5BeMy+QdnimSHQcT5e+4UWk9KSIm98OEffCtkOz9To1vqjhQQYjUmsLlGCNRwkClAkWCwKFMgZIwwCCNQ4WSZOgohEZXq+hahUo1YHl5C4xFBwIlFdopjIhxGOIgYKrmMM7f7KGmlOUzVKMICwzSlJ4RxNUqtYZmIQpKDJjFGEekBDpSKGtIEVglSTNBUUCkPBlRKkluCsbukwhMmhCGGoVPhpWSCCxWeCUTColwOQLjsa228GN0pdGx9iN55zzJUYQgDEoKVBAhlQKhEEIjA4mszKGMhwy5wivvCCegcChXwQ0HFC7341MVEITKd0qtgVwgrUA5gU1y0q2CsNkkqDTKBMmBAYRkOMjJ+hphvceADvAbq1LkhSAfDhHWkaYZW4MBm/2+dwMuMqIixZQJlRIB3WGGVgH9NGWYOaqVmGqo0MrRmKtzeWubQDsKazCZ72wFUQBakwyGaKtZ6/bJs4yiyIlixb6pGTqDAVnhME7htMBkOfVYI8OIyAlSI4kihZZhKcmYE4ZVojAiSwRreYExks5qStcE1HQDhaBhFbFUdI2j7yzKOqwM0VJSD2fZu+t25vcc5OlnH+P40SMMhl1UFBPPzECvS/PmW+mXDr90ttg6/RRbapvFG2/gmXMvcW75HFG+Trwwgw5n2D3dQNRmwIYcjgJEf0huY+Z2aa5c7KLrLXbvb5AmcH6tR5BGTB9aYNdbfpCLD3+UPz3d44UVyZH9mpn9igOxY8+eKqfahlc1KizNF0hzlq3LF5HVRUxwmHTYwbg6URwSRhGZKQh0SD2qkU4tEjcGSL3Bat/SPX2F26dChI5RkSSwDo0kyCVVEeFSS55Z77TrLNUoAKfod7t0B71S8cZPEoQrMEVCURSoUCEE5NZQmIxQGayVDAcZyhXEgSRUiizNGPQGZKnBxg6pLIEOCKoRcRxjCy8n7CxIFaJCf92H9SoqDgmiEGMctlQyks5Blnp4nh01FARaS5xz6FgjpKBIHVJrlHJY6bCDDCkEWimMkQitvA56FCDLY0lncEIipIYgLNci6Y0JpYdpmMJ3waWSaOmdowUOkxucdNTqMUI4pBYIK8AKnMSrEwEoiTXgMoeSAh1pr0gaekUlJUtjMYknSVcDTAEWMVZKIrcIJTAGj6u0gPHE77geYnOP5xcWsAFG+6ZLFEmCUOHyzHeqpaLIHclgB6xITrpiI9Ipwm+wI6zumAxYwoJsqeR07QZ+7ZjeQ15GiaQrTbSglCUvu9Y7OAX4ZHa02U++foMs9nshRthrGE9qRh+qcDs8EMpMWOz46oRX6ypPCDs/GyEF0roxTGLSEb02qxylQJYJd2GiGCXGmKSJmpSbJFffjtjRGcZ5Z9xroB7le1JaEcUR+44epl6foegZ4kqVleWL7N6zi16/T9CIUDZCZIr4yH7ywn+2ZqtN/1yBznrEMy3aaxusrq1QCwZkcYyqhdSrVWR9GmzIYqhJuqDjJoKUzvoAWW0xtVAhSQqC9gBVCZlZWKS6MEX73Jd49FyHxamQPYuaqKbYHQlarRoXt3MOt1o0qikuWyZNAtDTWDGNyTNa07McOXID7XbXN3EEDPp9vrvHZmVxJ142JSpjDFlz3vFg3MUfrT8ldG7n4ZgsNzuOs4Obs/P+GE0wR2vOzknEeERGeT+88rjfy/HNSZnmXg5PaIVQktClyDhCpDnkniRocoeIFHGhSJOUdJCio4i43sCSk3d69Ne3qE+FfkMTgkqjSjq09JMELRz1iq/KrRMoEWOcZZj6zp/GQVFQZI6puSmCwNGIJUIor3yTQWFyqkqR5TmZFQgn0VKjrKBS8dyDLMswWFSgve22tUAOpVOnlo4g8HhKU+TkUoLTCO8Sgw4kCIs1XvfcuAKtZLlhmrFOelitjC8uoQJkECMwqFrTX2nG4rKSYGkKrLOoagWTp0ilcFoiRIDUEabTIZqaxg0kLjcUJkXKCtF0g7AxRdG1IC2qEiGFIt/qEe/ejTm3jSs2gQihJFpDRYTIWoV+skKRGbq9AevdbTa6HQpTas8rrxhinNeyz0s5ROMc1nnt8iKXhEJRDRSRhEotJjUW53z3MtISO4JK2YJuZ4ApcurVkGEGSM1WJ2NQTlC8EoogrIRYAqQ1BE4glUYHId1+ShBVmZqaReYp3X7BwDiMsay3czouxsqAinY0rCUxjmGhkNSxJmMoW0zVFlhcOMoNh27hyqVNWuQ0bEYqQqSrom0VV1FU52q0Ngqytcsk2SaDKxfJsw1cJ+W5Zy6yVlziyD6NzQMG25rYbCCIuWFxGrXVx6iCeq1Cs2U4+9RFpo4tkBeWXXqL46GCpE7eC2lWqxy95QBnzpyh101JNuFoUxKYnHrhOLZHs6uhSdN1rp4f4Iymo7exQhGHFYY6Ikx7NLQlzwVbSU6kA/pFhVqlzlS0xepWm63thJP79hAaCEWVUElCIajokMDFpIMeotA4qxGiIJCCvDB0t9t4nqojzW1p9pVhiyFOKDApTgqUlN4dOC+wRpJmpeyoiwgCTb/Tx5qCqFKnKCwhBhVCqAPCOCTPvDyoLbw6UVCLCSuhhwYFEh0pXFZCWwTYrADnJwOeNOa5RbpczVQc4PLCcyekRMoAqSV5apAKAmcQVuKcpCQ6UFhLNiwQWiGlnxAorUjTDC3V2LU8N34SoJVEIbEmRymvlkQBTjrCSJE5idJ4zk/gyW5aS2+wKAEjEIFGhLrsFDt0ACoQPhkvpVulFuiKRiTgtG9wCAeusEilyQdewYy88MQ6rZCxl5uVeYHIfSfOOm98J5VXDi9wCKmwmcUU4OQEu+zhJXJM+JXy2jR8BAF4BYF1Z/LoRoXFjue50bHL15nkuZMJwbU7OjvxM2Mn5fJdjv476ix+txMEBaIkRk4mNgCeFF4mv4wSmHJCM95jBCY3GFeUMJvJpMcnUbbs8LvRaRoXbpNPbceUYNRMveZnOzu1vh71tcg4hfv2Rfl5iJ3Tk/INa61JEMwu7KJen6W72qG3vE5FWkJnECJE2hBBiKgEBDOKuOsw65tkSY98dUiWD0jbQ1YvbbOVb9DcH1PkGjewuEGGkjF75usUqx2EgnqzistzuptdKrV58ixjRiccUBHtooZKq9TrAZWDBzh36TRFz6H6UBWOwBjCQqIWQhpVTTJYw2RbGBeRyiHOeviyjKss7dtLe7NNe2OT7fYWyTD99n7u34IYcQp23t/fCEY0nhbsLA7Gz2dH9j7xBGHnPTD6Mbzsmh/dEfDy63hC7ocdNySjFed7Ob45zsHGVa6uLyN0SJE4isGQrBMQuJx8kDLsJGRpzvSeBi5L6GxeJulmxK0akQvorK2TdNbI+9ukKiQZDhESqs2Yfmrpphk2TSlshjEZDoFUMRtJxuZ2Si11VCNJmuZkhSXQdbpDw7DbpxGHiEAzKAzdQUIzEPSygoH1xl8Iv3AmpiDvJPTTFB0oWvWYUCuKooCaYtjuE4eaoXNUqwEKy7A7QMaKSChcGJDnOTqU1KeqqH5OPVPYfMDU3DRSSS/F6grCOCRsNLFZH6EiZFRHh8r7DlQ2/YVqFTiBzXPMcIDLwCkPKbKJxPRzbJGiEk1v+TIzJ/ZjnaPz/CXygaN29DiNA7vJV1M2vn6BaLZOZc80CEHnuXPM3nuCrcGQtLcFaVjinQtEJMkaivXegPV2m6udNld6HTb7PbQ05NaSS0lmDYXrI6SkWYkIQ00lDnC5odtPGSaSaiVitZMgAkkmNNIlSOkIpMUN+mwmQzpIpMnJkpRISYIgZNsaVtpdzl7YBu2IFQTOYZFshwEhEjc05HmBlQVZ4djs9tk9t4iqNFlZv0AxzIilJjIFZ4YFG4WkIQW7XI4wOVu5l1AdmghRQCGaVKdPEO26kda84pMf/Sgf/K/extbls/TyJmK4RfbSkGhpD8PtTbKao7veoVN0yIsM2e/x1BfWEeFBFg/NEbOGSfpsrKzx/MN/gltd42/cvZ9PfeVxbj/Y4rbDVWS3zbwZEKyu8/lHz3DX66Y5vneO/HLGf3r2Mi99/gl++n98L86ssL6esj4s6J3LuXS1z8a5Dd78QJPt1PL4sxlVWWXP7hanNp6m197gtlteT7/Ww+TrVAYJKqvz4plz6NoMleY0artLWHSpDS5SlYovP7FBLC0VXWcqbjJbrTIlBrQ322TpNsYpenlKxpAgKZA41rY2iRtzZBgGyYDBsE/KEFXkOAMJCWFUoVGpUo0Ckm5CYfzEy9oCnSjifkhVR7RaTRqRYGvLEumQcNgnGHapJDWwAUEoscYSVCMCagQ2QnQtQQAiCikSC0IilaAYpkihKAYZlNAWqf0/5S1cwUGRpDhTlKaEknyYkG4Poej74j9JMYMBTnvzt6SfoYIYFVTRcQUZafqdASIviKLQJ2BZSpFm6CCGAtpbXVpz0ygZeNtSa5GZwUUVVKYwqVdGc0ohB5ZKNUQM+mA1QVhBpAqzmeFSgYod4VSEyRyUUr4qryKHGrPtkA1JUAl9XmQMaEneSSgGeSk6ECDjAIelyBwCz7Nwwk9dbG6wThBWwFUCbApZL8Vi2Rb98XpvnfWZX7kZWrtTSchLWTrc2CBt/JwdLTbf5HcgPTRlvDWLUqLTOYpxh9qHc2M/1BIaMzqQ/MYbvXPXmEA5Byurq5w7d+7/xxb4nROb7U0cXtjKiVERaDyGTo0Ixs5fZwqPyS4J4UJJHMZ/1mICx0AIXxdYr74yKtxG52GiBOOu4TqMw9myIPFqUX6+5Cd1uNFrQTJM/so/91ExC84LGiiNQLB9aZMLX3uRG249wKWzLzAommwt9wmCCNWqEnQsxqUkg6skYoiwlqK/Tne4jNDTVJc03fYamYvZ3upx6cWXyC9uc+LoMT7z2ae49869/n7srGE66/Qvak6fP8WNrz/IrtYcmyuap89sEAxf5I3v+wFmai/R6W9zblVirko22z166yl33z7DpeGA8xe3aFSbqChivb9MNrzMgf0n6UgYpENv/IkkTVKEkFy4cIFarfZX+tn/ZWOYDLHWwxGd2Sk4MFlPxiWrc6Wa0cgLyv/MK2ft6PjvmCJRrjHX9hwmE7Hx6+yoDSZeCTuLADH+mSzdyTc2Nv7Kr/m/bKytrf1nf0f8RRgqIcSf/8PrcT2ux/W4HtfjelyP63E9rsd3ZbhvRESCHdTs63E9rsf1uB7X43pcj+txPa7HX+v4pmBFH/rQh3jzm9/8rX4v12MkteVSXHYGlz6PExGq+TbvLnrhaXRjCqVr2PU2xfQ80XRrx0jM4YzzeORYjxiBr2TS2Im5h3UTrfCiKPijP/wjvvKZP+G9H3w/r773Hg+/sBat9TckDH0nhHN4p2c5MU9JO4bLj/Y59EDLO2KuZtjEE9eL3CA6A6o3teiezhDblqCiUFWNvZLTv5JTO1BQVPu4XNBegcvLA268/Qzh3RAFr+bD/8+zLIjzvPH+BuLQ2ym+doFzj22xtDCHzgpQCrXUQB5P+cSnf423vf/X+ae//iGeOHWKm+6I+Qf/cB9/VPwA/+7nf5n3/PRubj4a0273+OrZNt298/zw0TlC82M8+KenqReX2b8gEdNHuNJ7DccXIlaTl2C7Qi1u0dwVEzYzJA2ybcdMFdaurrK60SaVAVG4l/zUOndu16mureLyLYq6xu5/FVM/1EJPR2MnVuCvD+PqeoxjeXmZ+++/H4Bmo+WVcvCKQmmWjEftIz6CUgqtNYyMygSYohgvOQjvc2CNJQ4DrzaFlz4F0DogzTIQ0sNdrN2BDHDj9UmVnBZndxBQ3cQNdcQ5UEJgJvQE/1wlx1KPAg/Dcc7DELTyPBBjvGnbyIzJUcKmnDcEHJF+wasyhWFEmmZcS4z2DuJCKUxRYK1BSoHSHjoKEq0VaZYRBhqt/e9VMcTNOrffdpAf+9G7OXZkkdMvrPI//NrH2Vy+zG/96s9z7LXvZHh5nScf/DP+8BNf5LH2OYLpGt1Oh4aq8oEPvJ8Tt97E3/k7v0izWqU/zNB4GFvhDCZPaUpNLgzdJCXSEYWAHAh0zP6lJarO8uKlc1hjCIMAqSTb/QHOWM8B9GekJPNLisJ413OpKWyBlBKltfczsRbrPNF+fK6cpSgMYajHcrQjmVvw6lTGG16gSsdlhy19LDzvzJoCHEgVEMcNpsIal9rLhDqmWWvwmhvfwKtveC3//qEPcfTQ7fzY978FSUBeWEIlqUjHRz/7Md7/o3+TOFGEs4GHm64UJO2C6n5DUe1CErB81pDnbQ7edJngdkGk7+N//bUv8Y7bVjh+x43QuIXs65c5/8QWh/cu4jp9RLOG2h8xnF3h8w/9S971k7/Jz33g77KedHjve1u87oeO8Zn27Xz0l/4xP/X3DnLjnoCnXljj+X5BsGeWNx+YJyx+gj/4+MMcn15jZn6KLD7OVnYrR2cDLg+fQ23M0JppUpkRyLggTSSff/BZvvKpT7B/9wL7jx9kfu8hKmo36eOrPNCfobJ2mcK0GVZaLCvJg1f/mC9c/iqdQWds4mqdxbgCJwW2MDtUeUYQNIHFyyU7a8b3yeg8W9yYFKyUQsvSpNEY/3Tp70PvYwJaae9kD2ipSkgiKK0n149SJXRRIqUgyzIA8jwfcxS8oIJfT0YSwNYYTAkzkkJ66NEEqzQWPlDSX8cjUvNILnXktBzogCzPRyuMf69K+8/K2rHfB6WamLWmVHEroUjlhe4PLzGlYIgU3mV+JN8sy3XFuzKP+GF2nJcZYyYci/F9WK6ZTLwWHCOjSP/POost+UW2hBQKMfGrMcaQZn8xX+WbKg7m5+fZv3//N/Or1+MvCueAAaCAgLF+tXM4MrB9nKmSr1xG1OfRS1Ws2UDVdoEIKZoVZBggrcPIKt2HLzH1wROgd1h9G0feyXnx969w9B2zBPNVhPabK9Yhgh06vjtkwpJhwn/4nQ/TrNbYNz3F0sI8e5aWkGXREIThKwlAf8Uxwpe68sbP8hytNVJI8k5BfXWILAKClQKXQSRytLQMUfRqBXMqYk5sIuuGjVTRXlXsaxn27apz9vQGhY2ZO15h3xvq7DcBjz96gCOf/UN2HdnkfT/4atLhHbCyztyDp6jcfpyF7cNU6w5RDXFFQLo+4NQnHuTdP3Efu/ctcPOt9zJIClzvAg/9yTY/9MFLPPzW4yzdtMhsc5vNlYx0vcY737GbW3f9OP/y//ocmTW0luosHd7P/OI9bDw9iys+z1Kjysz+XeRRnUTnvKre4PSfXeWlS2uke6Zp7Jpj/95DDIYCVoccOT7Nnk1LkKe4rZyMkCRzhI9K5n9yHyLcMUT8zji91+PbGDv10l2ZEMpyQ9JK70iuR/h+R1F4YrYzxqtNCYljJG8qMRQIpcZY9mucUMsNdrSBjUiEskzGbYkvdk6MuQtSKYwpkFKUz3Ielz/qf5R4YDFycXYONbZOduXjlLKy5aa6o3cyShC0lp7cLQXWuvF7EQiCQJFlfhMPA4WUfqMNAuHNJMuiIYwijh+/gV/6736Rixcv8+EP/3tWVlapVGKWlha46cQRHnjt/fwvf/8fc3tQ4eiuV7F0YBeF09xz9808ah2PPPIcd7zj/bSWItzB4xx4/SzpO27kH/zqr2B0gQWqzQZ3Hfk+/t59/4iDb2nw67/5P5Pagrvv/j4KY/jCl77A0BQgFNO10FxW+gAAIABJREFUGlhJL8uIlebA9BxxLlhqRGxEMb0yWXDGE32FVGghMWVC5BN662V6ERTOIYUaG65pBUiFMXac8I14ADpQCCWweZmklAWkkmqcsFnrEFqUyctIgECW51khpUbrGK0jpA5YnD+ELTKmozp7mvMc23OY+4+9m3uP3EHLLDDbACVDChlShPCBn5jjqGkQTEsubAdIJ1icd6jFmPMvtLFE7L27xZ5bq1xpG86eusTBz/4JS8c2+Vu/8FbY2CY8t86UuUB0w0EWu0eoTTvc4RjR1WxcuMTWmUv80I/cx+LiDLe/+g28+MJDrJztceGJNu94YI2vvfVGlm48wLS6Qn8zZCqocv8th7mx+Tb+z3/+aeKqYmrvPEeP3IQJTvD4SzGu+AoHWnV2Hd3HOpZaDPMWnnv4Et3ldQ4u7mPfXTeydPgouqjQe2aFE2qbZjFkV9TBGeiHmkZlhuqBt/CVK4+jAoW0vpFmnJcItqXkrcfxm5GCgC8MnE+obXl/ejlpf56FEEilUEKiAy+wkGc5xjovc1yuLXJH/jBKioX0Mu5jpS6tKdKUOIy8k7zwxWMUReAmie5IYpeykJCluIwbJe5jtQOJFGLcKBhzcZwnrgsExhq/NiAoTDEuOrTWXiHP+feslETYMjkfF1CTdc3hRROk9PLQI54PQqCV9mtRqcwkncNgx/LMujSzG903owi0LnlIEqU0xhhMYfzxRw2b8v2OZGCVkL5gY8QZs+OvY2lk6/jPxTdVHFyP/xLh8Cy/UTWall0lhT8NwhcLznpPBTkFooGQFkwb9DyqPoXAYdYHJOcNpjvEOUfywoBgVqHqGptCct4gVgquyfKsw2UWEfqL0Fkz/vn6yhp/9rmvcOrJp9m/MMeMs8Sjanr89icb/GjS8J0Qo25jkmZIKRi+uElnM2UgFfNTMb1THZRsYDsOCoNIB+jOgGDXHMP1lCCWmNVtTN8SqRitFKp/CdM22O0znDUpreZejr7m1cxu7UV8fA/GtTn4QyfY7lXZPucQ+QB58QJNtx/mGjDs4TKLiiW1IKLyXBcz8wx3v/oIg/VzPPf4aZ57zHDy+57hnQ/c7QnIz2+SdwWHDs1zuL6Hxy5XuXzxEnHdUTt2F9WZk2wP60zLs1RIaIRz5I0KWRgQW4ck4uEvPsLGUDDTqhAFFUzUJOknNLbPEHYUbj2DQuBkDSfqPtkSmuRMQnQwRkRiLEMyPr/fGaf5enwbwzlLUersa6UJgmBCFNxhambdRAFn1OkaTw5Gibrwm68UYtJt41oSoS8KhJcqLIVDhPWY14nqCFzDj9sxPdhJaB4djx0bt2+AiNKoy78PUSb+/gXKxkp5nLGcqrjW9M2TpC1S+iRAKekVqKR/F875iYFUmtnZaU6ePM4b3vBaHnn0MT7wgR+l0+ny1FPPsrq6SpZbZnft5tY776S/vcLXHz2NiTQzu/bz9rdpXjj9Ek++dIlHHnmMGyr7mNWL7L9tkdabXs+P/Mev8tWnv8wNd53g5kO3Ue00+Ru3vJ7NqQsoGVKrVbn55C3kWc7Djz5KalKWFmbZWt0gKQz1sEGzUmcmrDEVBuyJJE9fQyYvPRaURAFZnuPsyKxO4G0GBHbkqu3KxlPZEeVln6O1/lrwec8OlSspy6nBRFd+3BXGJ0OB1r7pE0oqUZ0oqiGEZHZqnq32Jq87cC+FaFIpGgwuneP7GsfYP7eITiKaKQR5Qo5hOD/Fwu4D2G5C/+oaMosIKyFagOptYjYttvMcT8Vw5E23snDiEFtdEJ9ZpFCr3Phf38XyIxVIC2S+jrq0TJP9sKuBW9sAIoLYUO1qKqc7mPmneOOb7iFfe4rt5RVefHKFpaN1fuCN9/L06Q4XOwlGVTi8d5r5YDePX465evECM4sVpuffAvFhkoFiSl2g6lIa0R56zQqiSKloRdYe8thDj5Ou97n9rpMUhw9hmwvYtS6VzlUaPUWQZcggxqgAEdRQYUQ9XuA9972HT379U3T6HZy1FKZgmA1xzowncaMTsjOZ9vt/mRjbHckxAiUm/ibOTRJlVx5vojDkp3+FKQhkOFHLGnXJpSinDLYk0DPukPsEXQFqnOiPGfEjsrCQCLXjfZfv7xp1ox3TgLEhY5lgK9T4eVIIJurAYpxYI5xvMJREZiG8/LR1dtzJHy1EYwEAwJTEa/80/3f6x0Ahx+9ZKeUnG7mfynn+/6TrPypMvFmlf59KyLJAKF9iTCPYIUAgRoXLyxjaf05cLw6+5eFwbghsg0tBzJYX0Hq5KdVxokVuFYGsIlQBxmDaXdx2jl5q+eLAhdhODv2E/NyA5MUeat8CrrC0H9+keTCksreKSQOSZzJ2z1eQeVAaLYErgBxcWraFpAOp2Fzf5msPPclHf+ejNGZrVOZh7tAhpqamcDhMYcrRlK86kRNZvb+yT3ScLXiEFNYxHOY0G1W6L21x9dQ67UhSP9kgfiFFHxaYLVADh+gPCNpXaIU1ulgGszFIqFYz5mqWYS/n4qlnmdtzC66xxdezFfrrgpvjO7nv9RW2nruPsH4W0ymITYba0yI4Mgtf/APQAYIK7uolhMmIbtzPsakFLn3ieWonj3Db7uNstwSplkzN1zlzfovbb76Lz3zqSdrL29xxi+JNb1hk9VLMJ597jEo9plXLmZ3Zgwr3c/rZTXbLZVr1JYKpg1xQLSpCs2AVp19c48+eOcXtx2+jMjdPGtXo93PY2KQxHJBcjCnWBFrsxlRCbK2KmJ9BnZxmeCaFmkLVBTKUqIocwzqux1+/EFJOun1KjjcUY+0EziO8c7GXgx4l4KNk22/oUvrOuiu78KNu/lhhpOz/y1J9ZLxniVI+dbTBlV+sMddcls56TX4hpYc3lDv52MRorKoDOK+EJHEgS1Ur/GuMhhOjv4vynfkkR4w3VqWU7/SNTdr8k1Q50VBSEMchR48ucPLEAW6+eY7HH3+MZ599ig9+4J1E0RQf+tBH+MNPfJbO0HH+whpvfO97ePRf/9+8+KWHmWlVOHTsnbz+dXv5zCc/SXIlZ/mRx9gzpViYPog4HFMkBe+77X0sGMEb3/8e5vQBhk8lzM1GPHN2jZM33UZtts6JG28iHSbccevtdHtbVGPJ+uUNlGww31hgtlZHkDJdC8iyAWnhYTt65E4eBAglKJylKMRYmUqUbtW21JVy5eftBa6sR6zKMhFR5YTAUHZoRwWjBFcCMHYUXqPz6J+k0EoTRjG1ehPnLHMzu1mY200UBczP7OWxRz7HD974ABtJg5WNZbovPc9rDt5PbnrM2IjqUCO3B0Q2pRJX6V42DBfrYA3zrRSlMnqbPdpnLrBr6RZsc4PnNreY7e7lppOHmLq/Ref8vQSVFynWBzQDgzyyhM4a8PgXEEqDPAZnXoR9c0wdqVNZa7DyydPU7zzO/QeOcz50XK2FtGohly93uevEIv/h984j2x3e+e5ZbrhhgYsXHJ9+8Ummphq0Kpb5+aP0htOsXl5hl1ql2dhHMHWQs67CgSBG9Pqcev4KX33uNLccuZmjd97KGVXH9HJa6YDdjZBGd4aGjnFBTKFCiihiGDu29BYfvO8n2cy2ubp5mbXNq6xtr5NkKaIs9q7tXk8gMiNpYuFBX2PTslFRN7mvfaItgcKUXXnh5d6lv7G9ql051bN2YpRojc8zCmNGCwm4SUGvSzijMYailFj3r+mhOKN705UQo9Gk0ifNkwTfjVS4mJipAaUHjgE7KRDcuOgZLyU7ip1RoStwxo3XpR3zyHGRU9bG4+fYEr4oSkgUMJ5YKKnGBdioMDDGTNbD8j2M1qZRgTJSJButx+PphRPlhEXwsuHEnxvXi4NvaTicy8A9B/Yr4Lqgf6F87BRQQYiDWFehnfVZiKogHZ0v/SnDRx8hnNLM/q33IFpLuN4ZBl88Bc8sQz9ALpxEN28j38xZ21wn2tLEg1lcpY46vY2u5RQPDRD3V6HhpR3JHfZqgoxyxGwT5+ChB5/gYx/5LJ3tnLTY5s5f+G84dtMJwihk2O/T72wTxjFRHBNXKpO/zE3gAN/uGFEmnIUsMaSZxYoYYwVioc7s+oDg/AqP/faT3LN0A+bsMkE8iw3qpIXAZFXC02voWLE8q9j3fTM0w5Tus+d45AuP8uCFFX7jZ95KfPA4eysaZ8CkliB2zP3cHuyVRbafvoCak9Tu3kW6lqPnqohsCF88C90NOFZDNDOyz/wxS4em0dO3U3z09zj54ikO3bLIrp+9myK4zD/5yB8xeGEVNciZNou00ph//W8fQ7kWaQavf+BOZuYbrF0+T3puQK82z3bcI6o3UTJmOivon7nMb/3Tf0Va5DzwwEHOVKYZ9g2t7goH1i6wKzhAc6aHyCpkroaJK2TTFdJdERGK+rSk83yCdDnxbk3txuZ4pDxa43YaxexY965PFr4HQytv2Dg6t95k0m/g1jpGu8tIk9+5UVfKFxUjaUIh/SaslMf6T7qEpevZGC/r2HlxTfZWV3bvy+93bJTOTbrUIz/VUWKwc0Kx81p1rkxnSmnWEaZ5dJwRvKUELPkUVZUmD8Kh1CghwHc6rQPjxn9/GCgOHZrlV375Tbz2+xc4/eyL/Le/+Avs2j3Lj79vlii6hcOHF3jfT/wIb3n3u2mhCQLHiScex5w5TT1JsMk2QTzHL/zMu2g+3qFytk2ydZUiaiH0Cdrn25w7e54fvvktVPUc2fk+4rkuccPy7uPv5Ed/7r0QKFxhKQYZ99x0F19/8iF+7V/8FtXaFPtn70IjSbNNkILnt9Z5avkswllmaxVCJUkLgxaC3OakSYGzbuyaPbaicg5pRel9A2AxJfRqdFbHSaP0pn/j/cJfDOOJAfikSCmF0hohFMpRepdE3HbHXaytrXD86Ku4757XcfDwYbaGKXFDUTm4m2Orhl2uSd7RzIQOdeYKumIwUZ0005A5ghc2iSqKF1eHnHzDPqLNNpceP81jXz3Fk9s9fuNvvwP2/gzvDxU2c7gcoinJ3M8uYS/vYeMrz1O/cw+i1SRfdqiZGPIhfPJF6HcRxxcwxQrumS+zdHAG3bqT/Lf/Ca9NVgkfOEbrrQfoFFf5Z7//B6iLV5HGsaSadC4kfOxTjyFdg04G737vaykY0l4+T3Ixo1OfoR33iZpT1IuQ6TTh8c9/jQ//3idwSvD2dx3jIT2LIWf31jJ7210WmkeYCwzucp2hqGFadXqxoxMNiZsRHTJ+/L6fQpPye1/4XT795J+U96tEsWP6U07VdrBA/BRIeB6QcGKcXDvKtQGBUqIs1ndAjsamfiC156gEgecijaYASinyLB8n72MPDzwEyDjrrxGlxlON3HqPKGssSk/S2dGUYXRcO4LgMML1e7jTGIZUrg/OjgYRblI4iBHUzYynEKPCZpSIWzuarkymHAiQ+DXSOjeeltqyIFAlPM+vacJ7ZAm/VmYlt2L0+Yxei9F7UqJsqkwKH2vNeD3162M5XUGUn9toSvfNIT+uFwffsvCbhk0/DvYrCLWJQEL2d3HbCUQ3IsIaTp1HqZtZCBfxjkma5lvfiosCup/9BMU//3/Z86u/imgeR7Q/hSp6qIUb0EcX6V/JkHbAsV0COdwEEaBQRPoSQXU/+mSIqPjOmOk4sosWezGn/gMNr62uBHcdvhP92og/evDfkFViPvIvfpdf+o3/ntmFOV58/DE+9/v/jqjRpLF3Hz/ykz9NVKlcM3b8duaG4/GjBWMdRe4Ydh0yFsgMVtoG9s4TTE8TL+zm0jnHH5/6OjfqiH1zNXS9jsEytEM0jp6N2dN5kkr3JrJ9M1ydk3zx6vP85j/6h6gTcwhddgtshskHpOs52//b59n9a29n+tVN0gsb5Kd71G8/yhX5wyy+LoBPfMy792Yh4soF4moN7n8X9ulP0u9cJD4iadwYE0wpuJiw8qnneN1r9vCWd72eq8vbfOiXv8Cuyizzb/9Zlr/2b5haeDOnn3mCta//PvccWuCJ3l3sWboXF7eon7/K6uNf5umvfo7tNOHtd7yN84fv4Uo3IHrpBfaKhL033825r77AsXCeotXABpqkGTGcClGRQ3Zhc05Sa0XYNqSZIEgsQaXs7o06LWIEOfhLnPGXt2Wvx3d0jDYXrfW4S5fnOUDJM1BlIeC80ZyYkH8NjImHcoRFKo9qy6Rw9NjodUYJ5dgx2U06ysK5HY7MfpKBc1jhJxzgD2mMJdTqmsmGtTtwt27yuNwBF5ronItxYSBH35SPl++EEVZ+VOz4hLbEESNo1jX/6v94gENHegjWuPFVggc/fT9mY532xoOE4iJvesOtIG7A2JSiEAgqzP3cz7P6od9i6ysPUXRWmP3bv0Rj3xvg438fkr1UDr+KbHaB4fkMt5JxdLbHYOMidiNEtC0q6VI9cgPBbREu8AVS73JG/7k+V59d4wuXn+Rjv/MxjIYzf7rNl7/wWZ544SsMlSSmwaPZC2jpuGG6yaHZKYzSbEnJf/raUxSFJQo11jnyokwOpQAhccKViaM/m5Ly3NlRMjRKHH2iL+SEbwKTIk6UeGuhFEIqlA7QOkQpjVaSTt/Rmj/Knn03s7R0A/sO7eUGEXPzrXdS5Dni0oCtR69y5gsv0T59ipONKgeX5hBakZsh1g4RMqbvJPs3H0H0X0c6V+H5oMey3OZ/+pWfQx5rja8l54bkg4TB5T7d336YpX/2Hub1FIOzy0g7TbhnN2vRe9h9fwC/+2/B1mC7jRq2iaYXEPe8C/vIR+gU28zcERCejJAVgXihz9VPnOadbzvAD//4G/nYRx7iiYfOsjh7hOnv/ykufvW3ae19L5/+8P/OrvwSi7N7eSm9ld17X40Na8y8cJav/9kf8tUnn0GEEQ/c8gZeOnIv2ysw9+zX2D+/QC1e5IWHX6IaHUDvWqRQgu5shbwlaVSbzGroxgmnzr7AbQcPM794A/MXX6SXDrAGbHkPinLiZ6wteQaA8xwAs+P8SSmQo8eE/16U0yRJCTWS0n+vFEor5Oh8A0rqMUlXKYX8/9h78yBJrvu+8/Pey6Oyrq6uvq/p6blnMJgZ3CdB4qBEChRvUVxLJNderVYWN8LWhlYSbSkkr7SHj5VCG7LlDW+YtiTqJmFSskiJJAACBkACg3MGg7mn5+r7qK4zK4/39o/MrK4BKYmhhXVs4CHQ011dXVWZ+fJ3fH/f3/enRDL92ZDsr35qYxyhtcHvdnsxiJISnSLqJmM39K3Mdugo6jUS9yP+mU3q+bneJ9umUfeDDVnwn/RMpaINN6BlpPs87c9KE2RbKsIoIoqj3vtlt45UKqnE9SUhGT9T98AWUMq6EezoC/J7M01IEgxk0ifSP+QwjpNEQ8g+oO8vWN/VnIPHHnuMD3zgA3/5q7290pUiUdGLmODrmPg0QjYSyhBgAtArDjocgOIIzsQcRjwMVMnKd/VvPUHja49RzDkM/IP3o8MK8TOvwZUrCG8cM/0wwfPXkW4eJerIAweJunnCq1uI1gbenlHUO0fAzqPnoXWmS7sZMvrDFfRygBy1MYEBG4ytCf0uYUvzL3713/GDn3ovL37jSeIo4J6H38XeQwcxCGzHuUH9Q6Zo0l/fGU1KdkFk8JuaZk2z3jBYjmFoUGBbkm4saMXQNYZ8N+KFX7vM+de/xbuKITsGh/FKVbSStDYhGrUoVK5y/NIW+ub9HPzwHewsJEPsUAIhDMGplzDdOs7RY6Dz6K1F2r/8q+Q+9ABy3ENvbiDsOeTsXaz+5NepTOSwpIHOMugl2HMPxt0irn+dtddexbm5SOmRW2mXbuef/fNf5Rf+pw/jVY8hogZaO8TWDEa4/OZv/Qsi9SDXrz3Fer1JK5Aop8N933cfj975Qf7wj85Tvvoa64uXOb20SdWyuf8XPsOpCz6sNjg2LSiLNhdOrHDfwcO0T9gM3lRga1EjcpLitEVuQEDeQktB7bUmq5cXubJ6ictb5wk7y5Q9xac+8+MMjg4jVYIjfNv1/m4uf7+NeTtB+Fu55ufn2bVrFwClYqmHjIkUJQyCACGSkjeQDJ9L/9NogjDolcczyhCkDXo9tF/3Ko49LnGPB5w9V+CHURqAp0lGSmXc5i6/OfBP/t62EvpTf3KRrcx5ZgFNcgjbn5F+J5uuXhAhEqqLZWUYaoJk5vMerpsDIch7OX71V76Hm/askcvVkVYXIQ0YgQk1weUQP3RwxnbjDN+G5i6gmjQ9asPy5/4vwteewR3Oo97/Ls689BpH6hPYq8vUrANEZjelmkTjIIJl7AfeQbigiRc2kLpD/tAY7iMTaFy6L0dsvNTg+NmXeE0f50f/4X/H6ZVz3Hr0Fr765FcZnxpl/4H9zJ9d4Bd+/t9ybfk4u6sFdNxmubHB9XoNpKTTDXHSBlMNRFoTpmo2SllEUdRnD5JrldBFMmpQ70SSNalL6OOUpxzxlJuevZZSFm4uT6FYZu/evQxP7OZ9Dz3KyMgcsciRyyumRh3cnEWjY+jIhKMtVrqc+K1rnHn5WT4yCsPDO7ALBWIj6DQhGlYUq/P82WtbTH/8QfbcsYPxgsZxbYSSgMZ/7quoiVGsmV0QW+itJZq/+L9R+ulPoTvLGF8ivN2IgQOs/pMnGN5TQgQRtC5AQcH0QYxTI679GYvPv0jlw7vwbrmX8+t5fvsPHuOn/8f34VbuAP86sRjHWKPU6lt88UufJVIPc+niF9ho5fCjDtUxjzvfdRePHHsvn/3dU+xaOc6Jy9fZ2GozPjnB0R/7Ed646COXt3josM3KpWXaywF7q1PoiwUa3iZONIo7KShN2rhlxcrWFs8/f4oD1m7WrlznjcVTLDcvIdnEMV3OLL7BuY0VwlgThCFBFKYVtrR3SKmEBpTGAUkjrehRdKyM4pdiANqA6zhJFcixcVwXpSy8fB4dJgMqs6okUtBqtQjDkG632wvAHcchn8+jtabjt4mjeLvKJ5JkIqPPZHYrS3AyalKUJhAZPdBA732zZuCsSbcnziC2S+dJ0L6N4L+5eoBJ6FhZNVVm/TTp+6q0STnW8Q0ARlbx7L9djDY9n6n73j99s7RRO02y0+NUGV0vM6a9gCl5fu+8pCcnDEPafif7/N/RKb9dOXirlzGAD8YH4SOUgcBgOl3Ih4BGKAs5lIN2m25jnfrJAYYOngQ5B3IEIUIKs5rwmMeFr9e51SkRnFohMrMgu9DRmPYmas5Gdcpos4ZobCKbHex2HcMm6o5Z8B2iL8zzzROnMXtK3P337oGOQeYV0kszbm2QRqDKeZyc5tM/+Um26j5hF4KOz/WLl5i/cJGbjh3lj3/zc1jlErfffy83HT2G27fh3uokQWvN1tYWaysrNFst9u7bh+u6CUoYCXRswBI4gyJJFmJDpxODlOSsZFqy8Gzu/dEdjH4tzxuvXed6fZ4d0TyTo7sQ05Jme56tNcOO4Wla19ZY+90/Yd+nvw+s5Lj8bowcH8VqrmDmfwMx8yHkQBHvB4YRhWcRlJFuEX3qHFz6MtV//Gmix54hLruonANrAtovoxcuYKYgP1JGjd1GR97E6unj/MSnj1Ievy8xYqaMjhVWFAGbfPQjn8CISf7NfxTUrz6HyG8wfcctHNg/yRNf+BwDnRHO1VZZDxoM7Spw5wN3sbgSMSIaDO51sVsd/JbDwNxhFpp5StNdOkELZ6eHsAy+8Vldlpx6Y5OiPsml+Xn8ZouWX6fWXSefg/e8/3sJfZ84ipBpUNjXov5dXfNM4UT0jPZ3LmnqWGPilG6igVijis7/12309vorLK01UkmUVD0VjCSI1X2IliGMQmylCKKwVyIXIlX5wRDHEVFkSFkAvbUdf6c0g4yqIwSRNmllYluNI/mbpPIg+/4uS1wSZyl7VIPkdzfmpIakaXL78W8HxW5oqCZx8NtPTZKenGsTxUljnxCSHTum+fCH3se9997B1MQCtnoc43fQ0kflBAiDUBb2ZAVR91m7dIHO+S0G99UpDtyFsHYgRZvBO/IsbHosXewy5mvs12uEe78XrV+gfm2NdqAJixUGh/cTxz5qeRW1bpCdTeSwQd7qYRqK8HNn+ZPXXuXVhZeZPDbJj/z3/4DSYJmv/MaXObT/AA+84z5yAx5eOc94GDC/+Qrlys3k7E0sS2IrwUC+SKPdYXi0QFMYFupbNLud5N5XkjCKiXqytf33cl8yR1LdzXjq2Tk0WVRnEupIrGMsaZFzHIYqFTzXJdYxHb9L2YGPf+yj7Nl3BEsXaMUQWRGikCNA0tmKQUkqVqIcxYTHvT86x8ifFnj65Svs2DzPDioMVscxZU2zfYnaChzbuYf1J47T9JdxPnAXqOQ6+36MtXsnsvUCZukkYvRdyEqRwidGIPwi0htDb4G5eAKZsxn6qR8j+Owf4xyYQrRy0K5hGsfRjSuYaYvS6CDW+LvZrAmc9gV+7EeOUhy5H4TG2LtQoY3RLYZKXT76kR/CiCl+/v+s0dh4iuLcINO37mVmsszXP/+bTEbjfGt1Fd/qMHv7JLuP3sLKWsS4bDB0uEBndQvljOJNF9kKbOzxJhWviKkqHBu6GBavR5w66bP1+gX+1H8J3Q3Y6m4QyhalAgwNOOx0dnKlXcNvNBFoXCUJetLnKZ0sq6il9ywk9lsbQ862ydl2otwlEtoZadXAsmxc26VSHeQHPvpR7rrjTrROpj2fPXuW3/vC73Pl2lWCoAvaEIQBhqR5udVqYVkK30+qBrZlIaWVIvlkmULv3u1nJmY2JjMM/fz+uCd9Cm9GFDLYol+ZKFsZTSrb/7GOoa8lgB5I8iZsjAyoSKppSlnbvRcmpRDJ1B+yDVBkdjiThO0dZPoGsdaotF9Ix6mP7asa3AB69H39i9bbycFbtkx6MWLolarHQQwhLAeiCFod8BRYGuF0kEgsA7bZYPHVy0wc6QDTQIgqOxR23sHw6OvEx18lfmON5WVFqZKn6OWIFy9gzd6BZBlRHkV2DMbUEOU2DJcG42q1AAAgAElEQVSh66HPxnzlxVfwNtvsPjiEXbGgpcEFPV+DkpfwUzPpOgVV32OzXcdVNlGkaW1uUhwd4/jjT7DvyM1cvnaNrc0a66ur5PN5BgYHEyf65wR9f9UVBAEvHn+Bk6+9Rrvd5umnSpjIMDVQ5q5HvpdydRwrBuUbckA3AJeEhhCHmtiA0FCqOuy9f4TCpMv1Ey7nr22w0u1SLCrmbt9J/coWjdU67aXLFNohJnwXwh5I0EElEKUhhB7ALC9D+CTCPYzaGaNrm5hgDWF5yHFJ+yvXKNz3EuLhGfzTF6Fdx5sbxkTzhBfm6eYnce56CHv/EeLBIapSMTTdBvk6xC10t47u+JgwQrkRQ4O7wfi875FdGNXk7JXX8bbWuPq8x+nT88TRCrVWm/xAgakDcxR27GV9VVC0JHktMKFNJC0oFbi+0OTIXB6Bwg/brK34LC+0WFlbY3VhiUJui3p3A6Vi8sOS4eokUwfn2HPbUVyvkJT9jaG+tcWlc+c5cvttaQn2TajGDbeDSe2t6f2cPvlNTzNEfpQYQjJjCEiBDhNFrUze8O3117My1CsryUshsSwbHaeoV+rcMmk+JWRvfoFIlX+E1om0qdjeI1mJ26QUlEymMvNT/WpDGasnI7IZEhuVOdZsZahmUk3oU0DK4peM1tIn3Ze9RvaIfhPVSdCHCPat7EelBJ6X49ixozzyyEM88shDTE6NsbjQZLDk4iqFiCNMJ0rmzSiDzPkoE1EYsegu1Ln6zec4+EgRo0OMbiCHpvAm9lO+cpbi2WvQhcUTL1KwGzjSwi4MoIaH6frnkZMjSO1j9BZmMILJQUQnR3wy5vee+iY7pcWDD9/J8AO7GJsaJdQBd47sxWiNwkYKCyEk5VKRT9z/fp5+/QpFlcOWXaQIiWJNpWSz0m5TqJQYkkXygUO747PRaKFUgm4KQRqQZBWjRG1m+z7ugxJEooGRpnop3UImFxUo5j0qlQFsJRPpbNvClQ6rp07y0IMPEwQWdkvT1RLPsQhiQU4ZhJKEUTK7xpaS4ojL/ofGyE06XHvB4o12h2LQpVxSzNy0i9rFTTZXVgmunoY5jYmOIKwSmYStqkyAb2E6ZyFSCGcvardAb6wANWTRJfYiOi9ukb//JXj0MK0TL+LmXeyRAqY1Tzh/Gb8wjffeD2PtOEqeAHdwgIExH8RrEDcxnU10OwQTYeUUQ4OzYAI+/oFj/NaX1jAsI5ZXudKIOXv6MnG8RrPdZGzHKKP79pIbn0VsCgqWxIsFQeRivCIRLhuBz559RXLKot5pML8QsLrSYHVlnbWFRbRfZyvcJF+UjM4UGJgcpzQ6wOKZN6ht1LBdD9NoUvEKFByXy5trcEPzcKYuJZKHTbIPEua8SdDxFJG3lMIgsS0Hx3aZnpnhk5/4JPv3H2D3rjlWV9fIex6jY6MMjQ2xsrrGb37uN1hggXqjThAExOmMC9FnJ7QxCBNjTFLFC6Mo7VVIt1sqcqD7/E6vxpXGKjcoGpnt+11KeYOQQbaU2gYL+um1UiQzVkRfctKjVqazVTIVrixpsaTCtpKKVU+JSKeVWB2jhUhFDtR2hQLTq3bItIrbE4LoHVPWZ2Cg56PTxuY+MZnvxp2+nRy8hSu5SDFJi5wNjCDkboy1As4mtFrQTrj+uAaUjV0A1Br1FcXC9S6jYx2UdECWccoTjE5cpvbE8wQ1H+2DLO3FcseRfguxvoQcs0GVod0B2UGUDGKiCuuSpWefpd1osefQNDtumu5lntEby0jPRXhuMiMhlknWayA8cwkt2hQsi/zICBMzOxie3cHr62scu+9e8qdP47gO7WaDrt+hUCwmfMDMSryFXQhKKvL5AnEc883nnmFtaYO5agWvPMyh2+6gODBCXho0go4m6RGIDVEMsQYRQ3ctZnDEYm6ggvAcrg9WCJrLLNVbVHIu5V2DNIMWwXIX1agRnH4V95ZkGFRSbbQxuREozUH4OrhFjOdBx4FwHUQDMVjBEBCffQp14IcxNQ+zGmN27kR0W+jTBr84Re6mu7EmJ7EQWEUP5KsQvwxxHaJlhG6SoW80r4Nc4tb9t9EIprA8QXPlLC+fOctWK0BiyFVHmdg7w8zenTjWCF43olhwcWJJaNs0LZuOgcqQIDfk0lzrMn/pCtfmN1lZ9mm1G3jWOtrOUykNUqpYVEeLDM8MM7h7Flmu4Dhub4jN2uoa3/jq44Rac+vtt/eCxxvgVkgSgz6jGoYhp199lcO33bZdQUhuGHSsE0WsTAMaMCItCWcBnRYY+bdHPvf/70spldA9skBfsk2vMdtcXCtt+LMsq8dRzmyASOk7yXNlXyqZOlHSa2y2k8Ieyty3RN/zkamvTtHnjJ7U7/R7/GHRX4qnjzaUPJSghtvI3o3bN21GNKmYquhDEU1yPmzb4uabD/Pww48wPTOL1hGxHgJ5EKFCRBRBdxPTDpLAygNpS4rDFnGoqa9sMn/hBLM7m8QRGDGGVx1Fli4SHT+L1YwQ/gnkzAiF8REUNqFoEw7EKLuEaHcxsokYLCCrA+iliOWvP4Efxux/5BAjH9iP2Fkh2vCJL61w7+13Y1sWURgTBzE61LhC8ejOPaxeWUbGNptdQy0IaYUhUlms+m3oOhRLOUrkaDZt2kGIH8WYlBctSK6ZFGCy/dJDcUXPFvRTHjLaRO956Tn3u118DJYtKZTyxG048eJL3PLySWb2HaBSKhFHCmMEvgHpKIiTyrHRhshANzAMjVvsGxgmFA61xVXazQ3afkDJcynvrbJR36RrfLqr1wkvnsE5eCsAljKgXExhBtQyhG+A7WDyJUzLQrAJnosoJ4i/PvME1h0/jp63iCvDWKM52Kqj5w1+aYbSbQ+gvCJ5NIY8iFMQnQC9hQmvgQkRwiCMBc3LIJd4x633cW3zEGfPe2xevcpy7QKNdoBEU57YwczBnYxOzeHIQfLdiFLBxQkk7XyZhnDQCKrDiuJEgcZyh4vnLnF1vs36ehu/U8cWm9hVjxF7lKFJl+p4kcEdozjVATbaPtdeuUSoQUiF53oMFEpUwoDNVhOZBtt9aXbvPksSxAT5tmyHoVKRWrtNuVwhiCKU5bBr924eeffDvPc976XbDdA63QsCRsZGmZqZwve7bG5u8Aef/wM6focwCBOevLWN+Cf3qEbH6a0ttymI2w3B25+r3xdlgFW2N3v+K7VZJgWmEqGCOIO/eq8n0x6D3lkwYDLaXJo09Oa6JH/Za7Y3xiB1krRk/VyJ3aRn+7YlVbfViXoSqYa0eVuDSsEbI25UlzLbnKKMtpT1VfRHZ99eN/329XZy8Jatbe8ihKKHf8mbwNYI0QEToFdXINCYskG4GqFibDdk8pDg2RdtXN2iVBpDCTCdDkLUuH78Ms5EgamZMl4hQOQdVHmC+OQLyDs/gT5zHXQErgO2jdAF0CGXXvp/eO/0f0vpwaOI+4ZBQLwW4z9+kfwP3o4RChEZQGN8AUIjNs6Ts4uMDlaozE2y97ajdGqb3P7gg3RaLcYnxonjiE6nhd/uUBmsMlCpJBMxjeDNzv2vunK5HO966CHe+eCDrK6u0GzXaTdfZKnV5LlvPIdQAxy+s4Jn25gYtBbEmf6wBkskAeXV6xFECrcomTyQY2q2SmfR4uQTl3nt5cvcdv80wwdm8P0mm2eXafznL+EeOYiQRYwJwYSQKyMm7oXmRYxZBTWNKDcgjohbPp3FBrkDNtHzF5A7rpPbM0U8WUSXqyjtoeeeRd58N6I6luSNpougmyQbpgPxFtLqgpNUb0zsw/o8xm6ArvPOm99JtXw7//p3c1y79gdMTMwyNVilfPgOJnZPMjrgIOoWhXaT8lAeFUvaOYdGKNG+4ejBYRp1zZkTV3jtxRPU1tdwnBzF4UnGR3filixyecHwjhJDUyPkSlU22j5nGytMVUs4dtJotnB9gReOv0jD73D01luwZN8U7r7VK8Omj7eaTX7/33+W4YkpRkZHsGwr5UxCHG5r4JttUDqRj4PkfMWpPuKNt9nb67/SykrY2zQbTRxr4jhKAv1elJ98kZl/zcj/6e8yx5z9Pu1px0qduUxpCVkQL7PAkT7p5L69lUmJbicZyRejNVl5IUtKsgShP2HYBhHT/dYXVGQNglr3yQD2b+1eoJEmtLHBdfMUS2WESBopJyd3g6kiZDp40pzDbKxjuhqqMdgWQoRUxvPYxQpfefwiRbOCciZxVYgSm0jVZeGlKzgzFeb2DmGPT2BKe4i3wLp2CW59N9aZZTAWobCwrBLSFGitrnLhG7/Gp+74BdwfPIacyxO1YoLLLTY/f5Lhn3iY2IpxZJL0RM0QfJ9C6yIP7J3hW/M1rm91qHUDHGCh08axbZqBz6idJ+86WJZFM4hYazYTRZ847p2v7LxrLbanrfeQ3hTtTa9RP30r42hvNZs0/Q5SQmWgRLHkIQuChVaLP/rcf+K9n/gkuw7sx3MkUaiJjSCWAhEIbCFAQRAYFpcjZGRhlyQH7ipg6pKNiw7nXrzOay/Nc/fDO5k6sodTmwtsXpmn9dTXcPbNImQJo7tgAqjMIcIu+I9jWANrF7KSSI8HK13CRht3ThI+ew730AL5W24GewTjWVC2iOdOII/dj8iVQQRAjDB1iE4n9j6qodwY8sm9ZcImptYGuwF0+G8efj//yR3mS38qWVv8BmPj08xWhyjd+SDTsyUGLZe4Jil0AsojHjJUrOdd6i3DkC04MFWgWdeceuUizz/zCnHXx8kPUKpWGaoOYCxNqSwZ3TuAKhYwdp5uJBgY30+t+QTtQODmCgjHJVaK6sAg640aStCj+yX/JxfYtiQKgR8mWlbFfJ5DM7O8Mn+ZsZExQh1isLn7rnv46Ec+im3b+G0fv9OlWqkmg9NMQhXOeTk+/Q9/nKf/y9NsbtYIgwhjgt7k4GRDJXsqm7WSxNB9CekNsViaMhh6s1iyFxFSYJFUqhCp9C70BeJpkJ32JJl0incmogAk04719hTjN6sckSYHtrLTnoQEMLGshGaV2bpYRz1wJancql4i0OvzNKIvLdkO+NOftil9OvlcWeLT66HQvZGTverPX7TeTg7ewpUM+HAwJplIKVAgPOAmsIYgN4gceZ7o+jrh+Q6i2MEaEciiD+2Ye496PPf7W+y4uUO14BKfrdN8bp2uLHHwk3dhDw5D6U5oz8JiF/X378UsBIjWAmLfYYw1gFnvYloR4rDNoUDhXX4NnpgAu4w5oIi/3MH70M2wrJPN4iYO2cQa4Wicm29hdqTIrmqZSAiWzl/iyV/7dcz0GFeuXiYgIj80jJMvIjC4XpHywMB3ihH/iivd+n2OfHR0lH/6sz/Pv/vsL/HK02+w89AMNZ3nyeNNxkpFjt1s025CAYFjSaSdOKC4q5nZZdM620XnJNKLURbkh8rc8/f2ceHpJR778jWO3T7KwFie0rmY9oUrxJufRVbel5QedBdMlATzzgzES2CNYewpsMbYWqhx/LH/zG22Q/WHZhH5CKsYYBkDdgGtZ7l0cp2D3zuA7dnE8RI6WsJ2LGJ/DWnF4PtgmgjZxlgGbAtTEuBHGLMOpo6ki4uPa9u886MfRDSXmBkp4uZCapsN1uYF43smibuaVWPjYzE5KDkyCC6S3/jqKk//yVeYsCIq+QIyV0CVbPLlAis6wJWSsKtYvNqm1mjSqNXpXHkdITU5TzE0WEDEPrNzM3zmF35uG5XtC+Ayw2uMIY7CFNGBTqfDeifk//jML/FP/vefY2RsJJ1ImUzUjDpxKkUnQaVIrTYpCtJHKRHbRvnv5DLf6dvvjOHcIB37N7C00ZjY9AKBJPhTaYKQocLJc+MooRpkjitpPhW9JkBBquyRsYhk2sqc7heVJhKxhqjP6fWcYupQFX38dcMNSGIUJs/NlIQyHoIxpNWqLEhIGhfjhAfQh9ZlCHZa8Ui9bU8piWRfR3HS39Bud/jCFx6j0+nwsz/3cwgktl1IVJ3kAyAnEeJZjHiV+OpVghNtrAmJVVUIOyBPyAcenuZr//Yqh95t0BsXiV/ZovNKiyg/wuH/4T5kaQwx8D2YBQ/ZjVDvFHCpgS1OEt12P+vPX8etW9hyk/OLpzniFnCuvID441l41AVf0/p6m2euX+EDl0KsHRZCQtSI8P0WYdik/J73clvV5f/+n79OUyhuHtvNwbLL9fo6LRmj8za1ThdQ5PM5xkdc2uFlwigkTPQ1ehxr4E2Nj9n9mwUoGT0iWZm9sCyFkaKHwLbabda3Vnjw3Qe5fqKNyYd8840681tN5sbL7NutCH3FQCix3fQdYkNOgL3DonkupDAg6boxrlIM7x5iaC7P/LeW+Q9/cIX3vncXhWoO90KbzqWTlGu/ldh70wbTTZvtu2CPgl4GNYNxZoF9XDt/ioWvHOdQwaX68SqIAGdGgJQYa5CuGOfyqQ0Of6iKsCRhdx4pukixhfbXEZm9p45QAcYSSYm6KDF+BHoVaGMZcEVIqVzkwR/4IGbrGnunXAI6bCzVaddshneOEnU1K8YhFIoj04KdBYHfNnzhq2t87bE/5tBADtcrIvN5VNFBORbrKiZ0JbWNiMZSi1argV+rsX7mVaYnZvGHRyBYw9U+nWaNc/OXiHSUTj2nF4RLCcqSjAznsULNWt1gsEAoVhshN00fppvzuePobXS6mtW1Nb7w+cf41A9/km6zTb5cwHatnuJQpxuQK7hIITl27Bitdptr167RbDQIo6inMpYF8dltbkiKc324RB99RvSoRzprfO4LVAykUqsJlVLrpEeuVz3c5jKlQx+z0Hy7ctAjPqYVSimSiciWZaOkSud+JJOaLen2lLuUrUAnE6rDKCCKoiQhwPQSE2PS4XDpa9rKQseZDYuTREIISIfLqZQOmlVx4lj3EoE41mmvlGDbcv756+3k4C1fAojBWOlutdPH8qA+BN6dqLk/xdinWD27wsbLHYwdcuhdCmGvcc8njxCd72KCWRgdIu7+NvuP3oV90z+C2INIJC9ZDOHKKkLXEI/cj35+FXP1GhQ95LEq0Z+epN41FOKn4NkhzMkS2i1C62Var5QpffoWzFIMToi2YnQT7GMlxPgkQhrWlhu8/OTTfPOPHiMOAzpXr2HZIQ1Lsbq1RWiSJuC63+Wmo0f+K8UxmYZwstHf89BOHr2nyNpmnnrUoSs7aJHj9IrFoIJ1IbDSwc9KSsbygiIwfkeO9esx7U1NN4gI7ZDRATj4fbuYe+c4p2sR1/0AOTFHPbrKyOefw/24RLghvWYMBMgOGJ2UhtUMJhikMjHJAz97N1/40U/zg7PvR3rDIMYhDiF4A2Mm2fvO3ejWJeJiDuWNIPBobbyEagus8BKq7EPkY0SMEBbYRcDGGAc6kji8QEkF3HIgx+oZj6rnsGNknJOvnmVxLaAwOMn+QwfZqrUQhRxDZUPZgyFPYinBV9/o8IU/fBzdWMauDlKsVCkXh6j5Taz1FeyywjJDXHxji1qzhZuLmZgYRuwaZ9JuMzk9zdzsHBMjoxhMygm2/xyaj6G5chaDg5Ov0PZjTp18na3NLerrbX7v13+HRz/2KLN7dqFDQxyl/d8hxJZGOAah0oDOAiKSIeJx2sej/g4nB9naZt8kpiIwyVTqgsA0NcKTf6OWuae+gd4OkDMXqLImZYjCiCgMUenU1CAKESQIfzLxx/Q5orQ3IJuv1+edevQeuEH7PgvItU744NsfsPel962tJBqwrCQ5iGOdzHpMt0ts0sZ4tisa2WcQShDH20lQj5Ykb9xrAohjgxQxURiwsbHG8vISRkcImdj7OFYYE2CpKaT1MSjcD3OPIc2zXDvZorGlKQw77LodZG6Th37iXtrPXuCFr15DznfZ542y78i9yJv+MaJtJ3TPaYNstWFxnZzTgo88ivryNSZqNuGUB6MWR64MsO4bKvWvwFcOYJ4VYDqU/Qt8T+UWrEEXPe9jSiEi0IhYE026lGcmyIuIdx79ftZPvQTNVa6tt/G1xsmFLDcDIiL8QBALCyMljWabKAiRMkno4nTIE4CVSrv2VxSsntpUchKzRk4lZW92hLIUtq1wlMIIgZezePTBEpPvn2NhYz91I8HpEliaC+sWVRdWY4MKASkp2IJqwTCAQN1rsXwxxt+KCE1A5MZUy5JDj+5m7p3jvLim2ajuZLC1wIg+weCXniH3gyT2XYjE3gsN0icZcvMSqD3ojmDnfe+hMHYrT/zyr/CRuQ+CNZAAf8EGhFtYtmLPO3YSrp/Gcg7j5PYQtK/hN+ZRHYMdXUJWfPB9jANC5YACBhuwoC2IopeYGhznwM4cJzZyVPMOO4cneeqp52jFeUYnZ5mYHqFRayELOSYqhooHI3lF0zc88cYWX/jDxzGNNVZzO5gbGUe4Npt+AyMbXFq6TmDlsZ0qyAAtAoStKN40hTx7iS1tcf30Kp2tTXQckM/naDTbxCRSwsk9LrAthWdLPvH9+1laqPHi6+sEcR7XKRN0Q5YaG9xx4Bgf/uDHqFZHyLlFvFwe7WuGCiOEcYAyCUgkpcFYmq31OgNDA/zUT/4UP/0zP8PVq1cT0CGV4HRdFykEUZTIK/eGpZE0CMtU5SyKYjJ8JaH5xNtUQ9NnftJvdLw9hyDWyeBXSV+1UX673zF9iYKS2/MXVGojbWVTcAvYwqbkDdAKm8yO7GDX9C5y5TzPnnyWf/nP/jn/+j/+G06eOsHG5gZBN2vCDpPj1FklIbF/YZaRkzRBi1j0fi+FTBqjs2NO77dslktm+6SUSC35y9bbycFbugSgMXGAUDJlvykwLkbbQAejh8D6YayZM4yNvky1+Qat5SVe+mLERPE61V15xGaZztUTNK8ZuoUDjL/zhxLOY8nANQ21GDHqw4QPbhVaa8h7RjCHljFbS1CtYn/4MCO/P4VVn05kNc1LCHsvMqzhOlOwGCFyEboZgwNq2EEUEn3c4EqXr/3253n+W/+FdmsdVxnsgk1pdJTpmSluuf8d7L3pZiBRMennjr7V5zPorNBYfZVw7TXClkaINgMDO8hFOZoNQ6MVURcxyhFYQNMImkZQi2BtC/YMQrgVcfMuC6sEGyuC9QXFt15Z5OjhDYqzVXZPeOx7137qu+C1f/840+sWcukU9oiPyFnJJEzCpERsDMQBInod5DjCHcMEPksVl1AewKKIEFvo9nXi9etQVVgzLo0Xv0L5/jFwc7Svn+LaU7/DvvcMEZ25itxbSNSrXBdEGSMOEofDaLECjTWMtU7RWByZHGLgY38ff6tOlwH2HT7K/lweYxVZCwQzk2UGbYXnCBwhUNqwutDmd//Vs+jNJzBAyRojjgWLdR+RkzjGotWwmYprKKMZKMBApcDOqUHiSsjh0cNUSg627XL6wkl+63O/CYHkX/6rX8ZxnL5AK4t4DZeuPo30a3jeTkpDh7nrvnsZGBzkp//RP+X5l1/g9gduY3p6mrBlsXEVBssCS4I1qhJde02SlIXpNpB/uSH7W78yOkUn5c/6mngxJroeov2Y/LtKaUANxtfgSIQtMrD1r/ejpkGd6g3Z2ebuSjLq4LZTio0mTIf2ZKicpQTSKLJm1f7Jpdlgnswzy9Rpa93Hje1D/tJ2lIRqacBIekOHMmpTj7uut+kDQoBOxx9nE3uNyaQ0zXbPoTY9bXJ6AURGR8ougOhRKrJjCrpd/E6TsNvC8coAdPwI17ZBBxjjY8kRpPtjOHtuZ2b6ecL6OWrza7z8WJ2xwhalHW3ia3lmQ5sgP0o0fTe5+z6CqAtEyaBfjMEKMZUWjPsIdwjRXEF+cI7o3AtcP3uazbUC+x+9mdE/mUHoHLReg9hC4KF0E8+dhIUIE3WhYxB5gTPq4k67WI6ifaZD68IF1ldXMXELW8RIx9A1msGyzfHzS9RanZRakZ6N3pRpAXGqTpUmBHEUb18/kmRApags6aAny1I4jp2qviTgT97z+IEP3ME7bh2nKDaJNyMsJRG0GJQROowJmxFNbOxQY5H0HtSNYaMr8Duwo2SIGzF3HnRoB7C2ptg8F+BfWuemAxbFXSMcm8whP3wn157b4MI3XmFsXaAWT2INtxCOlzIYQxBhQpXTXYQ5hbTngCKhWmF5wCOWh7BwEWKZeOssOgDjTWJN2tSf/RLVDx7EiDqbJ5+hvfAUM3fmic9cRRwuIwcLYLkgxjBmDq0qaJZhawWTX2HE0dy5f4wdEx+jvblFYAa57f57sbwyHePS0pLZaYtBR5G3BbYUyNBw6uQKX/z1b6E3ngQBg06eeickipMeDRHaCGuOqXIN4wKWTc5zKZQdmoUaly5vcWg0T8kps1XPE/sCfyvkxMmToDVKQt5zKOQdcjkby4adN49x6PAgE2NVvvbNBV6/eJ2iVcJRRU7Pn8GxLEq5Ap0NycJyG4sOY5NVGLXSqcKJ0IE0MDBQSpt0gR4JJlEskqh0H20PTktshEQpKx3AuE0dyuwXJulJIasOpri/0Wmfgja96cVZkE1aOVAikeA1qV1IhpTpGxKMzDZGcYyVziKwpc3owCjHZo+wur7Knol9vOfu72FUjHD2yjm+ePKPKYg8s3t28ks//4v89u//Nk8+9SQXLl2g4/sEQbdnq4QQ29OoSYCzMAx7nzWzXd8O1qX9F1KRDZ7sPe+7CNbeTg7e0pVuVuUl5UnsZBMahcGDqEPcXMKoCaz8IaRXxbHHUO5xdj9Up3WmyVZTkA813TiiE8CAXUQdGEYISf3LEe445Mo1zJVF5G1TsPw4ZrgIuRYiVyZSVRonX6T6wIM4M0dgQWFCCyFyYOoobweoy5jmOGIij4zbGBEhp0tJQ682nP3ySyydvETQbCUOVhpmDx/gwY98mGef/BpBt0s+X8Bx3RtKeG9NdpC9SFra67YxjTWECHEKLt3mGNqfpONX6HYtZFEyKkO6XYXxJGUpGLNB5STtcdjYMIhhi1MrhmHPZnzKYnTc0JmcpnWhxcVXQ4ZXBAMTBtkjOC8AACAASURBVOlVOfjxT7E1/0XCM5sUuh3cMQtZskBphNBpJSEAWggRYMw6tmN4/4/dTefaN7HnfKRsECydo3vyPCZ+CntXieLRECG/RPelLvH8MuMjTQhz2PunEYNFRE5ihIfRswj1bpCniVdWidfXwanjDMD46ChXW+tUx/ehQofYkXgFl3IuRzXSLNTaxO0GNZlnWOWI1jTPfnOR1dXnkSJg2s1TtF0EBkt0yec9un4Xy4GW3wZXkquUKY9XCNQauVxAu30JzwppRwMstzusN9bpbob8r7/4v5D3crz30fdx002HwYSE3SWMKjM6fjuvfOtxrFyLKa/DYLGNVC5CeWy2DYvPnmNDD1LasYOKa2FbNnFDE3dA6LQpzBKIHIlBj01WK34rNtjfyDLGYNoa/+V2ckzdNNdcD4k2fVqzMYWdld72N1EanFoCrL/e4+7pz4u+ZjptiFLqEGbbSSmliMOkwtDHhk2C8qyXoIe6bTcLIiUmTqoCRoDInHEqbCD7qEACknOWOXedlfv7KxOg+noXhJK9hCMjt+htb54M40qTBnqBbHrcpPoMqXNOcpAkzJUZCGI0RsecPXOWX/7lX+FnPvMZEDZ5zyUOI8JAIXRI0FoENY1XvRNVGELZI1Sd0zilGu3zNWqbFnkBkaWQKkfBK2PtGwYEG78T4B0N0YvnEetdvDsmYP0pzEgJXI21ewrn2gq51QWsoXtRo4ehVSIruQmpUe4oME/jXInCPRWitTVEKYc1WUJ5NmjDG59/nmC9howjYjRaaSxPcWp9mb2V2QQ59rt0g7A3HTdWKqFBGJNMSY4TPnO8TQvfpqShEZpE9SwNpLIhabatiLWhOlTBsQSjRY/JwTKuq+iEgrY/RLe9G0sMIgsObl5QERHdrkLlJUNCMuUJjC1pa6htadSIzfOXNXODLjNzMDnp4u90ac23OXu8y45dBm8swps7yGzpQ2wtPE7wxjrlPW3ssRzkBEiNECa1912gjRAxRttUxyXv+eQxGpeeZmBfgAmu4s+/Tnh1DaFcrJkCpdsjTOs/0HlpA7exhFdtI4zCPjCDGCgjHDBmADgM6jBwjnh5mWhtA1kOKZUchoeGWYvqDI7txgQOxhUUi3mGLAs/iFnZahG1G6yrEjtVjqvnfZ56dp6N9ZdRMmA2V8RWOWIdoqNkknBXdyl4HsaOIRdRGh7EdgO68RXypTqP3G8zN53jaqvC8Zc3Of3SGkIZJifHsU3E6vomni3Yv6vCwcMTXF2qc/zFBUYHBrnSdinOzrKzELJ6vo3BoilyrP7Z6+SOaNzSEBUvh53PE9QCTE4Tk1QErJyFW3aTAWmapDm94ydIejqh27LsRObU9AEYWSVTpLKp23zk9N++sMRk2j39qD8pup48S6cUnmQSdGoVssqY2B7gt01hSkEUKcAk1B8pJaOlUe6avZ33H/5+GvUWMzummRqbQlyL2apXOOTsZmN8nHwpT0kWed/3fT+VgUEef/zrvPjaS4TdgNjonoR01rid2S6VzmboHYQkbXpOPqsUSR+mTpOCrKrSo4N+F7yit5ODt3gJwAgL010Cqwgim9rpYChghIsJVugGDtq0ESKHrWYpz2hE3MSYfVgbTeTqAqK7ji2uIQo2LBjURoQstKDUBsfGvHoe5DyiMgixDY5ElnI4w1XMqUXUzM2Y5jLUNzHROugaqAHkkIsYU4hhCwIroWykOyHeinn+1CmurK8TIhgcGuKWd9zC7JFD+EHAxMwO3JzH5UsXWF1aYmhklENHjr4l5+4GVQFjCMMGkfZR3hCyOISRLoHjUA/G0VYe4SrasSZq+Gg3R2QU2lKYWFIEBguS4ogEBZfXImIFXVtQzMFwxWPTEbDaJW8bZNvHRDHF2QOY1suYgWW6jevIfBfHjRA5maC4IlHoSIKkDpgQJS3mDk3RWV4jvPosbG6g25tY5Q66FRAt5qmvSRTXcMIId0Biz5QRXh6Rn0KoIkYOAkPUNz2e+ZMneeQdAdI1mIEBjEgal+xonYH8MKNFi+4WNFoR7W5ISzXRAQzkIkTOJcZhK1CsCsnGsAfKQzmSgmMRywBh6rgROEGOWEQo1aHs2eRHSnhDOfLlLWy5RCkXY+JlhAix5EEGSlX2Hhgnr8d57plnibpdOp02L77wLVxLUq1aHLv9Ac6fW6E0tB+3UKHpW1w+tcxWPSJfGERHgjcuLpP3zrGnHTIeF9GjY8SRQpWBWGKEwDgGaYFQJpHatSV/55KDjJZqDLqtia50iZZiiAyykxTCda2Dv7jM5jMB+2ZuTxP0hNVgDJjYINW2o/vrWNvUmn4J2WzPp8cl0m9kH7IutpuB+69VT22IjOOfvWLieHsDk3rJg+ijHm17916gb7a1zQWpeojZ7iHYPu/0Xqt3FMb0/UBPsrXX3Jf9vcikV8325yYDQtKKgoH1tTWee+YZgtYStjeMkhotJEbkQBQQskHoX2PzqsGy2zhWCcveRWlHRByscv5MyIwdgHKx6eCwjPAszKJBroeI5jrSA9kxiNcvYORlxNAQJiwg3TEYyhMtuphTq8i5Y3BxBePXQC9ihIuwishhB2uHTVg2SK2QJYWwE6WTYDPi6ZdfYb3dIRYKy7bQVsxaGJAvVYiMJue4jA0PIaUkimIuXV9Ca7NNXeidOLFdzOkFadn5vHGP9eI4AVJZVIcGuefOm9mzfxdWaQSR93CVh24U0WoE3c0RSYUOY4JmALkcGomxLDCSQkqjLA8nFbfOYkzXkriOoegphgcL1PIKveRTsDXxZgs1kMeb2Y8Jz0F5mc5GE1nsopREOAIUJOPf0n2gG2AUnldgx/5x/JVVgvNPolevQ9jAKnYxfkS46LG1JrG5itsNyQ3nsCZKiHwJ6c2AKmHUMJgRLp/xmT/xDPfcHiA9gaxUEbaLMl1c02AgP8JIycLfgHo9IvS3sAwIbag4MXg5AhwWOpJrnkO94mFkYu+LjkVXdFC6jRNqpBZYtsaWHYYGXKKiTWnQx/W2MLrGwGjAjFLsGJdcPN7EsUNGJxWLrQ7Fspc0sBc8XAU6knRbMRaSq1dCNga7bLXz2MVJpipDOF6HzTOniIXH8y9fZq0WMjc5wc7RaeyxMYKOIXB9cq6DdCTSlkgtINaYwPDkE0+wuLhIHMfo2BBHGik1Ybg9eC8BHbZlhzNEv1dFNNv25IZoOKvipiCIedPj2/ZObNu87DVT4KInZJDaBFvZWNJKqURFDo0d4O6Zu5lyd2DKmjFvGLtj4W+s4tUD5ooT3PWBvdhuQh3M5/LcfOBmom7EletXiaKIbtAliqNe9aBHCRICqfX2Z2P78ISQaB1h+o6xjxvVU4j7btbbycFbtgx9+wqjI0x3AywPpAMGgkhhu0Noc4W4tUkUpRxHewoVC4pTFqgDaH0BizWcTotY1JOhZx2DWwGlAkw3hG6IefopxNxmorKw10VUbKzcNMXde4n/6BKiugPKNUynA/E6qBiTjxDH7kLM2pAHHAsig2lFGE/RWQm5GtRp2oZcYYDR6Un2HbuV3NAAT3z5y0zPTlOrbXL+wjkuX7zAPe94sC85+KtFL/1JQW9wCJoo8gn5f9l77yDLrvvO73POzS+/7vc6THdPThjkAUAKIEgQJCUxLamstWRZ1qrkXVu1VV6ty2VVra1ab63tP7Ysx1oH2auVyrKk5UpWICUSy0wCJAAizQCDyaGnc/fL7+Zzjv+473UPZNnSSizaLPP8MVM9/d6b+274nV/4Bou8coQxM8S5y0CmbIdg5wYrT+n0ElSikfYIcofUgNQQGKhVPObmoeQ5tBxJd2S4sRnjpAOWqhkLDYfZGYnOHaJRQpRmCOERLN6Hu+CjdlLSuIcIMxwJeBIh9QQfCuBSmEYIzN42TqRIb12BUYjbruCeXUDHOePXb9K7AmJs8BddaufqeK0GZjuBKtAKMHIFIU8SDca8/Fv/Cc/e9x7cE6cQsy4m98hjA/2Ysu0ioh6OVcbEOVGYMTQQJzYPH/fwqrO0HIfb4+J+Obu0wNqbj3Pl1Q6aEGlHOFJja4Mdj6i06pRr0Jir0Vxp4FYzcrap+T0apRTXjBFegTWuVko8/PAKx9rv5+bq29y5epsvfOE5VKYIPI9jJ44RZyVe/darPP2BD2FSl9W1DS5e2QWvzPHjR3FlgIpd1tZ3KUcppXSW0hELUa+AHxSKH45ElHRB7A8csC2E+91XG+wTa0NFvpORb2aokcHKNYw0JlHke3uE66v0Ig9+iv1kykzej6J4Tr+D61497CkhjmlSbf6cRFtM3yf2CXFMMP3iz4FFFQnlZDJoOFAhEQJJkeQfZJ0HxzEtTO5VAgFAGzQTg7Rpd9BAgdMSB3hhc3AAZjoFmBQr0/ccdBanhzQteuRBd9EYnMl7dZbR73R46Rtf47EnnkB6tYnSiESZAK+ygNZvM9pbx/YdMsvCcdp4gU/p0CLZZoesexdfpNh6jMk2IdKosSZoGaROkX6A2OuiX34BebgHMsOcKWM8G1MPMPV5zFt95MI59OYeMhti1ABsBxqH4JGH8B8sE5PjtEuFy+04J9Oa0d2Ey6NtxkZT9kp4gUdmhYyjEYdaLeKsj2s7NJoNPN+n0+2jVteLpM2YffnGonEq90nm+/Cs4rJOurF6X6Rgeq6FlAhpYXs+Tz/zXpYW5kjtCmOnTWYCQgfG0sJSI9L+iCgL0ZnB8QaI3CUx4ChD2bFoVF1mWoKyb7PkWGzuarbHY0qMWSgr5uo27fst8tRl3E3IhMZyyniH7sOZ98nXx6ThCNfVBbVJFI2lIs5DIS5iQ2ZBdwcnViRX30LGCd6pOaz5OdQgIby0SvcSWKGhcjagfjTArVQw2wm6YhDzJYw5gZAn2L7+Zd74g0/x7uOP45w8hZh1MFmAGkXIJKdk2Yiwi+NU0YOYQZiT5hIpbc6ueHjVNm3H4mJXMzsfcLZ0mO7dR7lxcYAyY2xriIXBMTkOYDke5SBlbuEIpiawyx1KQZd6oGg0wdcW2lF0uh18X7K84rJ5I2H2UJm9OxFB4GNyzeZ2wjjcxfEthKixqww6tSnrEqXmLLOLgmz1FiePn2J3bPCurFLbjphftKDvYEoBQiichoddsRC2Rg8j8CxW19b59Kf/iI2NdaYmmnlWODXneb4/zRSTKd9Ubah4xKdJ+wGvaD+WcZAw70+15IHK0PRmvdcDQTOdKkybBEVDYl8ydfJvjmUTOAGe5XJu8T6eOPI4J5unILIIpIM1NIhegtrbxU5DlpaW+b4ffG/Bd8o10SiiPdvm4Qcf4U++8Kd0+x2yPJvEnwO4o5RyElcl+35aTA3U1D0qR/d8x3si6VQt6S8DAv9ecfBtWfu7+UGlZs2TdV4ErwFODa0Uo+GARqOM9Jfxy6pwwstj0vEmaus6fus4ebaDGXQRSY4jPPIY9NYIeaiM2XUwC20Y3EQ/9wXErZeRawG8aCF+LME8XEOUjkInRvpLIDJMexZEjgklxh4hTp9H/thxTKhglIJTaOaqYY6RFltbMSeOHaFWUQRVj1prls986rOYsmJ3c51XvvkCwrGoNmscPXWSJ9/3zEF3cdK9+6udweIc7mv7YkiVzyAxbPcSrnWH9PoWva0Qq28QSYjJh1jk1Bfb3L64yigJGHcjsnGIyXJyVWM8jnhoeYbve6hJjODG5jarty/Q0Nv84IkyR59cwFs4SmW2SaPqoHSKaJ4jj8b4Cx5Jsko22qSkQtyyQPgSYZUQloOhhqaKjmPi575K1lFwyKf0eBvvyApYS0g1IpAxh+qCvRfH3H0tweob3nXCIfy157CPO3gfewjRHpBLg69qfOx4BVGfgfIzWFqjcwtpKch32L67w14n5NSxYyzUc4zrIcuzRHaZq7lgPjK0fMGxtsU5C2xhc/ofPct//R95sPl5VjyB7TrEjk2lamgvexw7fpytkoVVG2O7fSwBS606WJtYwqOb19kb32AwuoTvLlKrVnnyg+ewHcWVS3fY2x4wHo7YfeNNvvX6ZZqNWS7d6COlRTweEQ1HtGolfvZv/TTnjj3I6FurjK+uYnbGdOIhMr+FOzdDPmhhqj5W3ULOCIwcYx2bRVZdhP1dODkAUJp0PSG5EeP4LqqT4Vgg4hi9MyDZvks02uPw8scKs7fJplZgcaddWPhLxPJv3zLTXqmBCYbXsu3J+PqdibbRen/zKhLxIolWebGZ29LCwDtG/tO0fhouponi1ClFa1OYa8FkQlHI3k5/L/c39OLN0io8C4zW+9hgWTQhi27i/gZ6z4FzzwRDH5D3pmCD6WheTDDHB1KnxUhHGIMtwHdt0Ir/7L/4n/lf/iuoLDyCtAOSJCZNYtxmBa92lvnmCYwRDPq3CXuryDDEaSzx6COLxF8dkzspRgjysY/eHaHmHXTDwTlxBPPC8+gvfwm5/SbcCeBlG/l3DMn8LBW7gV+t49TnyddGiMYstpNDfhdTq8IDD6M/uYweppS0AyVJnmiSnZCByrh7NeTw/AKDfoRxLIRr4ToZh+sDxsMuSWoIXAfXlQzjMddX1wuTJq1RWk84KNNzJNEqv6dzO7kWhRxVwUUwpsCHI9AGpO2Q5zmdQczdrRS3Uie1a2yMDf1BzObtAZWxDVkfFQ8RwuDPVNle3SbMa0SdMSocY5SFNgFJnPLw4RmeeWKWrb7ixuoNejvXaMsuzx6rcPyZQ9hzp2geLiM8G42E2ftQ8Yhg+VGi6Cr5sIOfZ9iBQHgW0i6BdNCihTYOardD8oVXyLo54nCJ8vsPYTWOg6gh6n0CL2epKtj68oC3v5Sy7FicMBHxb30d+5iD/+NPQCUlUy5LXsr7j1Sh1oLSB7HyEG37SIZkSY/t9W32dkecPX2apUaKXWmi/Tpj6XNNCeZDw3xL8vCSRUlCNDfP2WMf4Nf+cQWx/hlOVGBgPDIsLCfCK41ZWTpEvtRisdlDIfFsh7mqi+sPkJS41s859u424x3Frdd6QM4D72nxFjnrd4aE45wo1XQ7CUJbeF6IPV7A6JjdjTdw1KtULcHhhTZ/7+/+DMMvXCbf2MEaGbrrXUg07myTUthGdFNMK8eUclIRETZtfvv3fpubt28SRyHGaJQpOEI6y97RSCye6YJIbNk2TAsC2Oe2SMtCTwrZ/dg2iUXTIkPew2OYNgMAcqWKmHMPB8lA4X8wCV6FClGxN/mWS92t8dGHPsKp9hl0BCUZUA4kMokxu33i7hqu53H82ONIzyqORynas20Egr3OHo5TpOVa6X0+1L2eDVrpYmoirGKCN4EdpUphWfaBr8GkwWLZ9v6z+GdO3//j+l5x8G1YZrrpTDpiKh6z85nfxFms0w1vEI2H+IHhyLsfZ/vSDWrLy+BILCvEsceUyhF6RpC8/AZJe4bSmfcha0+hxQuUX/0G+o3nsX7sI7hPWiSf2UB99TZ2t48MDVRPQz7AfHYLMbiE+b4WOOcxmYD7DHo5wFo5hbAkqquwnvLQOZg9hTA5eRyhLYO1VEMPhrz09mucOP8AT+kVmofq7FZcPvvLn0OaBM8VKK2pV+o8fP4JPvkT/wau4/wFZ+df4zxOiqskTen1e3zxy6/wzZevs7YeQTxCa4eqU8J2G3hOQLnsMNu2yW91efRwQGj7GKeJAaJhwtbbA7qbe9zs9Nl7eZMPPbXIj76/yWD1PuKxzcXdK2z94ZvMWpKZeZ/ayTrBQ8uUjj2K45xGqD1KtSpRWmOrc4PKnR3kUOEdC3AXzxBph7C/hd/bpL9paD85i3NKYlVKGH0SnKcx8VeRpT7Vpz5G9al1jtlHwZ4j2/0Cl7+RcOSlEPPSS7g/X+at/C4XvrzJT/7y30POHELnOdJbIvrGc6x/48tc9+do/42forz1GlcuWCw/cIb2TAvfsbE9i2MGOmPDN29kHGlZnGlbuBacswX/wd9+lLe/3kCsvUk82iJxXerHTjF7PKQ7vEviBQShpilhvllirO5wY2Sj/PvYHmUMtnYZ3xnRu/kS/+Lu57jv3BP84A+f4OFnF7j85i5XX9thsz8m2kzJpUO/10XlkjTNQSnSFB4/c47AdWk/fhq1fJzs1pD01gZhbPB7O+S7EbldRgYuVt3COdfEbgbw3QgpAoyAPFSoSKFDTbieYRKFCRPE1m10dxcVRghvBn+hUiSnE0sHExdQJGFA1uQE4vCdOgcFbGbKO5g+l/s4W1l0sGxho7Uh0dGkeywmm6+ekIEh1we+BAd4fbOfwGe6wKyL4gX7SaUUHJjsUSTwU5y6nBJhD/p9QFGAFI69k6T+HthLwUueGnZNjIpMEc8K2dji2LUqsMaF6s7kbExwvJZlIZnURzpHaEEt8Hj81GF+4akHiDd6rF76HCIfU5mrUj60yN3bGa2TpzG2wbEG1KoKWaqidrfof+mL9Bs+/eVn8fIhNfsSXncXdfGbqI89g/U+SfTP7iDfXkN2BphIImpnIO3D/36D4BML+EcWyA8fJbyR0i/vUX5gjup7H0D0BQQCeb9NOk6wug7GzUi3RuQlC1WW5J0+f/rl53no2XdzWpzgf/jDf8Grl2/TaszgOBmlkkRlCte36PX77A6G5FkCTJyRkfvQq+Ic3otxEPvFltGGCeVzv8iaXiOVK8rlMo1qk69+/Rp/8rkNwmGGyCK0dqnbJYxs4Lse9aaNa+dsXr/Gk4/M0bcl1fMrGAzD7YjdGwP6u12u7vTZ+/o2P/3JY7zr1CLjLcl4fJMLnets/fbrzPmfZ+ZIifKZWYLTh/GXz2K594HaolL36Y9uMeisEfS6yJHCP1XCPXSe3miAGW4ht/YIO4LWu9s4ZwXSK2N4DJjFqG9hVWJq7/sktfe+zWn3aRB9Bi/9KTe+HrPyzRDxytdx/uMFPv/cf4mdz/LsL/4iojGHSkMs/xjDf/nfcf3OOp3F07Tf8yyl7Yu88aLHfc88SL1axnVtLEdywkB3rPncWwlPn3DxKoKygMcaLvVfOM+lr9Rx179Fd9Qh9WZx2nWqyz2MTOiEt2kaw7EZi0rJZUjGG7s5b3Zz1kKJu9NHbIzIthIWF2psvt3lp3/xft662efKKwPW78T0RznhVk5u+ZCMCjM3LUCBtHw++tSTlJ2clY++C72ak17fI1nbJVGCYLBDvpuQWj6yZGMv+vTbGf/wV/8JF69eJDMpSZZSQP8mcEEhCpW8SQxReUFkFlLiOA6u65IkyQSKpLGsiSKWnCoY5ah79P210iihDjrt+kCtTEqJmDQqCyGG6dTh3iTbFA7wApTKSfKUs4fPUtYBXuYTOFVkJrD7KdbeTfJuBxMqrIUZ/PkK05wx1xlpL8ExNn7u0mrM7sOC8jxHTmRWpxOL6RNWSK5On7gihuYq34dYTeWnp7DIXCmUSveneH/REn+2EnvHL0XxtP/+7/8+n/zkJ//CD/v/65paVifDAd0rF8me++f4h2YwD95PaeksVtAkyVNGyYhmYLFx8wWy9W1GuwNGnZB8kNFoNDn+7g/gWQGbq7tYvQ1qvQ2Gr2/QOvw05fc/jViaQV81mI6FPFRBlDW8uIt5/h+CGCAO1RAnz2KOfQJTWUBdWCNVYI5UsU/UcdsldEeh9zRSpJjN51HNGmb5CHYgkJ7LxsVdnn/rDrcuXyTubzDTLvHgB5/mq3/wO5x64t3MHVpi5fhJZufnkUBQquBMVGumOOB//fNn9v8Oo4j/8VN/zKVXLtHZ2iMapmSJQOdVjOXh2PM0fZ+qHVMtG2bmFhAKdqWk6SnqJYtqo0KjNcORxhxyzmdtU3Hpleex7QFnjji855SFXxsx3Hmd4eUdVDRGopCejzU7T2bXWLh/DuHVsCsLWB5ofYU4fAU7myG5vsFLL23jzz/EykOn6W8/xzf+6SX+rf/2PF7zhzFZBkaSRlVu/cEfcexHfg63eo5MFxrplmUj9C7h3R9m9PeH1E/nuD98nrxrM/yda/SdBkd+9TdQ4z/kD//7b2CSGeZPHSc4MUvz6GmWF+4H4WGERZgbwkxRAXwHhIbXr2a8cL3H6s095vbG/ORD80Rrt+hLjVr0USIlzRLiZol6BfpKUZsLqBiDVCOGeoPLg9vszUXcvTJi9/YO6foIN9K02yVmKhb+EO4MwLbLzM/NsLIyhyUDtvY2CPfq7PVyttY3UUnE/WdO8e/9nR/H3hN0Pn+L0hAcXQEVYOkxadJHag+8GgaN9G28w02897VxjvqFi/c9BLPvlqWTHCME6VZOfDXD3DHEV0PKN/tY4SphssddVWLr0Bk++J8ew25LjBaogSomexisho30BKL856lRfPvWrVu3OH78OAC1Sg3HsZFTp2Qg12q/czbF8067cFESobTGkhJbyn14T6ZVAd9hmuizP2Fl8jnT4kEIsT8ZmBqkSXnAYcjyAyLgvXKjhVqSIc81UoBl20Wev6/xXYQk27KAA0UdIcW+lviUMG0oiH7WRK4RMU2CD8izRms8KXAsyQOLs3zo5BIfPLmAN1dGvue91JYeQkuXKItIVUTZNqxf+wrZ7bv0O2OiToJINL7vov0SqhdRmnuQJWuIfWed9GZEUHmA6ic+ROncCur5DOGXkG0fIRS8uoP54t8vDLROtjDHnkIvPEUuayQv3SbD4ka2y6FnT9E6vgh9AwODJXP07c+wWZrFO7RAfb6BFhZrr23wP/3m10i717HpkDImtlJaTY9hHpMowZ1uhyzLSJOM7b0B/VGI1qrwipimJZOLa8xBwWZNSOXTREVPrp3t2FjSwvN9WovLPPXxH+fupVuEvTF5bNCZi1FltOXiOIu0A5+K7NFolqnUG+hcsCegHShaDZ9qq06rOct8Ywar5XN3U/H6159jtq15/KTDuRWwgj7h7lv039zG5OPiXilXEbUW2q0wf/8cuA3c+grC6pDnl8miq1hZnfjKGl/8yhYn3vNxKrMJ21ef5/KnV/npX30Eq/xvYqJ1cFoMbnXZe+0iKx/+CZzqA6R5VORTSQAAIABJREFUjGW5WFKg4xeJrv8S438wZuaRHPvnP0j06bsMX9ojXTrNoV/+z1Gj3+fXf+VrLC3dR/3kIqUj8zSXT7A4fwbwMEh6aTEhKwnw7CLef+Niyhcu7xDd7HBWGJ5ZLrN74U2GFZs7ostMw8eaqRCXJHncwZ1tsZdtoO+s4lfH6EZON9DsNIdcerNLdndMvtqnLDWzMx7tSoDTzbkdlkEJjh1doFINiOIUIR3iToubq0O27t5G5oZHHjzNz/3MR8hvxcR/ssW8V8P125N9b0wSDrCMjyg10TrDqgd07IgXdy/w6UufZXO8RX84ZK9bQGvk5FnN8kK+Tgq5nwAbY3Bch1KphDGQJilZlmGMfgc8EgqZ5Onkbwq5sSck+TzPwRgc25n4BBRePTCZQIgJP0ozUemaNjEsXMfBsV3ONFbIsPnk+R/nXUefZMGdw9qB+maIHd+iP97hql7CfeokT/zdQ1izEqNgvD7i2otXEIHAbrtcvnaJf/RP/jG7nZ1iaqL1ZFpXELMtaaEmng1KF38XcKOimJj+fFCIH7gwT5/RLM9J03TyPcyfu7F8b3Lw117Fyb71wudZ+/pzBP09lpop1R94Blk7i3AKUrIwKZanIbzAoZV58vlFVC4gdxCqhlNq4nkRJt5i3klQqy5Jb4mR/SCiK3H/+Hex5h5HPvkg1hMLRWTAoP+330T1N5BVD2wb4xiE2CTPbayHSrjxGDXaIX9lhzRyEfUSnhmQl7awzx3Bac6jrRImVyiT01iqoV/XbA5ht5fTYJfm7Zt89Gf+Fm6lguN57O3tcfHC64yHIT/yk38Tx3X/WmdwXw4TcByH+Zl5zDmHrZmUXs8h0w38apv5lkAMBLNVC0yP8Xibfj8Gu0W8e4f1qMvtNCLPQWqPiqzQcDQPnT/P+YfvYzUc89Llt3nt05/jE6cSZrwhzSebOIceQ1ROIewWlsxQucGywSiNiXbQuUFWH6NUfxLUBZyHjvHuUwsYMyIZXGTj+hanmwrbfx/CegQhLbK1a+TX3+bIx38OnCU0LmKsMGi0b7D9Nv7irxE98NPYH20jT70fuyMpf9zC6IfZeOXLzD34NI8+UUYHNcShw4ztMjW/zsZ6D5uAUZiSjXuoYZ83uhbXVt/ikcV5ls4/wCcfs4nvm2Fnw+M3fuOfUckzdLlCOz1CfW4GI2Hj8m1E8xBOKePCm9ewZILxM0IvIolj2AgZ3dijaap41RJeM6Na8hmhGceKwXaHKA5ZvbbLt8xVjJa4/gKeM2Cm4THX1KwsHOJHPvI0gV0j6W/jeQ52bwiDDJ3mYFUQ0XVisYTnjhA1F+tEFe/JmUI5xJIH9eZ3UWEAICYmN07ThiOQ7ETYeylmcJtRNKZrC9JGmdmjdWRdYDJQkSbbysFoZEVArEELrNJ3ziF6OikosK3FBiORE6nAexw7px02JrhcY1BaYyZTASElTDr9026f4aBzv6+9zYR6ZVsIA0meo/adkg+kTafmZO8Y1CqNxmBNoCsGgzCF5KCQxe+llO/A3E57Zvv1pjiYUFiTYkSKAuKokftdS4TAdWx8W/KJ+w/zQKPCkZpLpeVS/aFPYDUeBssrkmAV4mWbiPgKR08eI1k+jlFgUh9BDdstYUyHuHMFGQqsVcloc46RW0anGY3P/C7ZhQ9h/41HkYsVhGtBt4f6rV9H93eRfhMtBEYMCAfX2Fo3rDx1knRznaOhg/XWNtGVMQQ2rhmQ17Zx3v0YLa+JES5Ka5SKCeZ8HCR3dJlcdfFkhqNjLt/cYAykGmr1CmXXZ2xiPDtCMmFzTBKSyeVAq6LoMqaAORh9IGF7wCsvMNZi4keRppokkbQOnSCulzCmie22CCp1ZhoC0YXZmqDTuUEUDRgoAdTprd0mFgNuZglG2zgmoGL5NDx49PHHee+zT/DqnT3+6Ivf4OXBBd5/OKXpjWm9fxZn4VmEfxxhlxAiR0/ivVYKPVhDlurYwfux3feBvozz6DE+cPoIln2HvRtvY9b3ONmQSPdZhP0gBCdI3noZJ9Ic+uDfBGcBjY0YuGjXIAILy38Uf+lXiR/8d7B+YhnR/hje4y9h5nYJ5Rk2X3ue+Ye+n6efcfCPnyGptzBumZJTYWOti0OJ7jCC0Q7jYcpGJ+Xu5g0eOTTPsace42dbDuOH5rlx4Tq/8Ye/ix/GJKUSzaPL2DWPvNNntK3IyzOUyLh5ewdUSpJqwn5ClA4h6JPe7JL3E1plSaPk43s+IyqM+2P6OwOiRLB5azTxBbCoVg/jORGeHdOqRRxrBZxb1qxf3cK+3Kfu+LgiQgx6aOpI6WGFPVK5jBt0MXWfVwdv8M2Ni7y+doWd8Q474R5RGKPyHKUUSoPnehM3ZLVv/jW9//TkXkuzjCxL96eLfxbuPG0sTFscliz0/82U8GtN+FIYzMQv4EBMobh3BfdAEI1BGUWuJIKMzahD4NR5efVblKwS9dl3MdsNYHiLQTRm29iIdpnKUgBl0KkhHynStZzZdhtRFohAcGzpGIsLC+z2dhF6MoEzk4aHMUjnXqNGa78Y0EpNFIvMwfmB/UJi/zsIgSXvUTv6v1nfKw7+ymva7dYMrrxIcu0VArVD69Ea9TMfwmk9iLSapEagdQeR30FEa0iniTYWdnURX3oTLV4HaQ0w2TWMk1Ly51G1Y4imhRtYbLzwIjJeo9bRuMkdrN0z2Mfux7xxif76FhUz8VOor6Bnz5LsjnBXQvJKGVnNsFo+MnLQAwNxhrXYwJptQL0Jro9UgnSYcu3CFWaPzHC8WWO9XiIcagaDPV5/5RW2d9axXB9hSbIkZjQYgvz23j7TMdj5cycZHs7oDhRRLJEElMtlSj7E4wKykOcNolGLXicmVZJ8J2V1rYpJDPl4zLC3x15nk5G26b/6MqdHi9SWV1goH2LH1PnWzdv8yN/+ebyjdWRtDuE2EdIHk2GrHJ2PMfkYtAd6D92/BpZE+gZhDyk3TpAOduju3mBrnPDYk1Wkex5EYfIivCXcE03s5hFUKEAZpBgTvnkDNcqo/+BTJOI0qnYY5t8DXg3RTHEefpyyfBd6b5XNyzeQKycYbm2x8/pFhrXjtB9p8/JXXmJr/S47wxClEqpOztxswMKxFa7ZLXrrdzjqpHhhTHKnx3wlozQ3y2awTNSaBc8rAtusTRYquv0+PoJhmDAapeRB0Q1JV2OCMGOpHVGvzyHsOsPRkHAwYJyOKc/PUDMu8SClvzMkTzKGURdT9ohkxFyzxLzvYfX2cE5XiGsZzgJYQQW2E8xOjvQkOjiOHUdgKezjTbwHZ5BVm2wvwlkqc09m8f/9dS+u3RiM0kTbIeHVAWI3Rnd3iKId9oSg45fwTtY48v4yOgada8xQYwYJwhcI4SAyDZ71Hf3+BQm5IISbCabf7Et68o7poNIFnnd/fA/7r2UC43Emm/C0GICDr1NMCtjf5O0JqdmYolM2haYIigLlHdOHCVxoypGYfqAWU/6S5uBaFFpIZnL4Qh58p3thTwV8agovmB5hAZlyLIuSZ/FTT57g/nKZ5SNV2vcdp3ryfbjtB5H2LGGeQ74G2Soy7SKdGbSReI2j2FIgsYvPlz1MtkGp5mKyo6hWQN5wGZYjtl5+Bbe7Rq3/VWx5E/exJ7DKM+g33mRwd5MKxYQpqR4j103UKKa6WCP0YuRyRilYxIQ2ZlR4hlhzs9BqkQZ13KAMqaF7d5dLL15gbfMmj59YJNIdNvuKNEtRZAhHYhuJbVmUHBshLGLLmhSMEu7RmZ9ei3cUW/KexGyfulmcTUta2JaNZTlgYPPWder1BZ5++nFm6vP4XoVS4OG6hmig0UYRjX3CUUwUKpJUc6SdcXeziZ0K4mGXYbfH9rBHD5ut5Hkei44yu3IMESww2r7GxS3Fx3/2F3CP15CVJXDqCGGByUFl6GyMyEcIY2GynULByALpa4TTp9qaIdp6iV5nnaFUPPCuOsJ5DLAxkYM1cxbLtrGq86hYgK2RcsDwK2/irizhP3yaRJ4irx1GLHwYRIJcnsedPQH6BLq3ydpb1wjuf4ydG5fZudPBaR8nOFLhxS+9xubdO2yNYxwTUy/BzGyF9rElLtst+jff5oyVonbHsLXGXD3HO95m1T+MbjUZWjYpikRrSKA/6OHFmp6CCI/MFpg8Qu2kzGSwdDRgHBeGfmFqE6eQWhZuu0agPMK9mNHeiDgMycNtPNemJAfMVW1WgiZiGPKnn/8qD1bu52w1oJtJSpnCkxnGK6GtFYhCVKZ48eZb3HX6lGfLPFZ+kE99/Q9Ik5Q4icjyDG10wSmadMhtywYbbMvGYEjTFKUUURShdRG3ij6F2IcLCSYTRSmQGvQk294nHU+Kg4JiZfYhb9NYOEXMWVKSG1UckyhikTAgKQQKtNbUgypH/UPMxj5qawfVt4iiHTYyyZYbsPBohflHfbJQkYxT5BhUL8Jr2NiBQ05OGEbEcYxrO2R5VhTasvge0rL+L7Cggoeg9o/1Hjzk/iR2+rr9KcNfYn2vOPg2LAHUF2apLTxA/f4VvMWnMPgoQOkxOt2GdB1hFNpuo7WLY7UQZAizh2QL8jWE2ADbw2Q+olLGO96gWbLI9DLxS7fI0238yxs4e+uY62tEr95AJBDMncU6O484dw7mjkCnDyQYZWEqCqsaIGQJIgUjg1isI6oBKgPimHwwItoYkSYQG4vq3BythQXW+3cZbd9mY/0u25u3KJVKYFm4ns9Ma45TZ++bEIG+DedwsjFLIThyqE2cGkaxIldgCQtySCJB1zHEqULlFtou4bkZ7rCPXVrB1HIYpejxkPGwTKfTZbC5zdreBr6SLKYBs4slHnni+8A7Ten8D0yIxdNugUZphVTjIjhYNlguQuWFqdnOBey5JsguJgEV9jBG43oWwbwDwj3AJZZnsGdXQFmYbISxI0g2EHoPVE7WuQzBCtaRD6OHDipbA2XAWsI9dJgyfa59/gKdxjKW0WTDmN2tW1zwAtbX9shNgrFy8Dzs2RmaywHth86xFTbJt66wtraG7A1ItGT5/Hmidot5fx5tOagkJ09THAfopmzvWMy32hB20MkYJxDMNBRDJO3lUzRqOYiA7hDWxj3iOEP5Als4uLi40iVwfFCCzlYX385QaQKxRKSacSIZ9A3GriIqCmUlmNhgRjl2wwba2PkuwhY4S3WcQ5Wi6x6pyd2xn5Z+V6w/C9RU44hkfRuztosOe4xJ2A3K2MdnaD7conHCIe/nZInGTjXCmuj4Z6bwe3C+8999SnwD9tnD7+iyTbL0Qg9cYklrMv4/4Bjc60b6DvMzMZUNFQed5wlXwVB8jtRTrgP7o/FiSl5od083wimPQU3G5tY9OemB0ZnhXnhBkexTdN6n04s/Q/izpq7okz+FLFx8Xc+jUgponz7M/MPHad73AF773Rh8cq3J0i4iu4vMd8HY5FYLnTv4VqtwsxfbSLZBbyCsTSy7SpYPkDMVPNun6oG2lgm/cZ2we5nK167i7O5iSi2St+9iQkEw/wDW+SXylbPkTgXyHMczZNEAdwbkYhVpHERkEJnEtMpQKyH6MXo8Ju9GjNf26OyFdMYZ588dpjXYpZ/cJssNygg836NsWRjLxnEdBmHCKIpI9zHNE1jHpJs6vZx6Atl6x7WdXMeDAUxR7GtTqNDs3L2JZwecPNpkeamFI21MJohjTdcWjMMMy2vjVDRmHOOPhzj1I6TVGHeUMNqz8Es2ldGIcafL7a27tC+WmNc15httqnNPEzQUwaM/ANKa2ElNjLRUjtARSImwLRAOpGPM6A46vAmtOsg9TPdFVLSLEBqvZBO0A8DDGIXREjm7jHB8TAYmDyELIb2LZICOBXnfBWpYRz+C2gsQncuQ+8jKMdzGEiWGXHnudTqHzlAKM4a9hLh3kzTK2FjbQ4kMZA6VGn7bZ3alTvP0fWyOmyR3X+fa3VV6mzvEuWDukUcYt2eZteexPY9sFKN0VsBO+hl7kaTiZNhunbKrSc2AMBsgU488HKIjQRoJYi3RUqBtjVXzyCNwckm56uEISTrOSccJLgk6iwh0lUq5hd9YRmyPMOUWsfLIw6hIrl2FrFhEozI6HxLUy6x3utyJtrAyl4pVNAHHeTwx1Tso7qdJvO1YhejBhERcxKCpCaN8xxTwwChNILRmOqYURuxzYO4JeEWsmkw+96cM01GlPIgjU3jO9J6f0A4mqmaaBTdgJs/QwzWiWBKqhC2njHdfi9pDFfw5yDo5YTcmEBbGVqgUiGCsxqxvrSOkwHFdsjzfj6XSsibkYo1R74xp9zY59n/ej7nveBz/0ut7xcFfaR2cZYGgevJRKscKmAnOPOChTEaSjRH5DmTbaA1++X7GxiXw57DNGJLb6PwigtdBdBD+CUwaEa9uopNb2I3TzB4/RevMM2yrkJ3OdXRvA6dzlfGtC3T1AodXVuDc44gPnMGUHBjGeLMl1G4PEScUW/UYWdLISgkx1yo25ziFXJB1BsQb24y7MUceOkPiSkbCUBuf5lA+Qss+49EuqDGtaoDlB/j1Gc48fJ4Pf+JHC4LQQcvor31mhRC4joNBobQgUwalBJt7Ob0udBXkiWKsNGMMWivsrQS70aA6n6P8PaiVqC3VOBQvs3XpBYINF9dyuX37Dsad4eM/9SyNc/OTK6nJlUbnCpWn5EmEa4ZgOaAVUoyRaKSYQffW0e46WDZ57wrKqxE0ZjhS7RAlHo3sGsKqIdwaBhuEROOghUbEXcxoDf9kCWNLkvXP4y9/BH3uQ+i9T2F6dyDzEPUq1pLEq8+QDAVfe+FfcfThxziyfILs1ps897ku87U5Hn3vk1QqAXapilVr4jo2OwpOJ1sMLZvrvYxhKJg/exyWH2NDC46XJGFiiMIEmcYIqahWK3RKEnfW0IoHNLMBlSDiyHyJ3qElFluLDAdD1tbvsL1zhc3tHZSIKbeqxNsR0XhA4JaYac8ROBU8Y5BZl3GcEvVzxuNDmNZptm6GzEgXabvgxpiKgFkfU/LBzbFnF5FKYs9UsTwHWbKxyt8+svt3bO13tgEhkLZAiJAsXKW/dpM8E2x4DdylOieeWGThXJM0SdEDQ5YYbN8ga4VzqEkV1Cxw7mmffweWFAfa4XoCy0FMYBcTboGwpkS3wiV96h587/4jJjjd/B5H030FPt4pmbo/ETCFEpAlRWHiwwGJeJpcHhCTp0oh0ynBQfI5hS/Jia63nMBY2N/Yzf7/OeU2ABP1D3MPvGhqBCcR0sZ2PS4ObZ584gkaDz6BW17C4JLrhDAeoMLrRcPHqSLdJWLj4nttLDHGpFeA1xHiOogxuEcwaUp45RrYx8hLSwSH55k5/W76yYjVGy8gB9tw+UuEWYnYWWRxZQH96JPIH7oPtvpYeYohI1rbxnckeiRRgx6yWkXO1sCrFQpCYYKDIFzfYbzRIYsMK+fP0hAn0ZUF2mFGaPVwtzVx2EHoEc3AJjYQGtgbDtnqdEiyvICOTa7xfvIxJYlPtebvSaSmXdwDOdgpmTRFWmMGezuk830G3T36JQ+tPYYDl07HkPoeaZjRN5KYHJKcoKeQ1SbezADNGJW4VErzLMg2g9sjSt0mxlhceP0Nvv9D9/Pej36U2olZimhf8FN0rlBZgs5CHBNiLAehNVIMsYSHUR66exdh3QXbJtt+GzOzTLNex+tGRIlDPbuCEE9AqYwQNmBRWL4pRNLFDO5QfmqFPNxAbT2P234Sc/8PkK//OqK7DbSRh48gZxzcapOoD5/92r/kQ5/8cRwvZe36Ld68tslctc33ff/78WwHWZ/BKVXAtujnhvviTbq2yyurI/bGCcHhI8w9/CyrWnLUSslkAG6IrQoieVz28Go+4/4d5gODaw3oda7S38iQVkBnABsbIZWahxVYCE/hBwK3WWK02ycNczzbpzRTpd7wiLd2qXkhw8TBRiJqSyze/wwfWSmj7g4I13aIh9skyqNd8qn6guFwyK4ec/bwUeSozJ03N7n15h1sCfWFNnuj3sT0rIDIWJaNY9uFIdq0iTeJRXq/gBCTmFI8t3oy/ZzcpWR5Md3cb2qYwv3YYPYH0wL2i957pweTGcJkQjqNV5OGojEF3Ekrcq3pRXuk8Sq5zhhFNuO8xDoN1KzPg+9t4c1JwmGIFUrCvRC7ZmHqFnkvoT/qs53ssNvbo1KpFAWQ0fvNkOk0rkBJ3QN2mhREeiKuYISZKLBNfVomvAl5j5rTX6JS+F5x8Fdc7zDLMCFGlkHUMMZCoQizDunuHXw/x/VLYLfJrVksrXFlBPkFsN8E+w5CjECByQPUzia9V3aI714naG8x//Gj5EFC++c/yZxex9x8AfXaRfJLOScf+H7kux5AtprokSFd75NtD5HOAP/4UZJdxeDVDWT3NYJFQ/DEw8i8iu71MEmOSSXd7pAxhtqDK3iBoFR2mZmXnDpzmvT7T7K9/kG+9K8+S9S7weHDh5lfOcLKyTPMLS5h284+ru3bQ5YUCFHgh31hIRFkOYxDTW87Y2AEQcNBuBCMNJVBxngQc21XkF7fwIrG1KsupaqNlBGmv86JU6d4ZtHiTy+9xV5vGweozjX2E7g0hzhRhMOYaNBD5utUyj7jvU1ktollYlyzQ4m3sech29gkGyU4x89gApdko0M0lMw/egQTv4p2T4M1C5QBG2MZ7KBGvruFsS2MSJAmwvEjVPdLqN5dvPs+jLnydfR4DbFgY0YZYvb7eO8vPsZXfukf8I3PfJMLtetU6nVGyYhbl3fY2In4wIceo94Q9K/tUvd9bo1CLnzp9xjkiuDEYfwzp7lbbzMeOOT9ERszASpTCASBX2a2XWbZtTlyCvYig5uVqFNjxo84PN9ifbPOf/O//lMGg22SeESSJAhtkCqh6rgcmpllJ9kkGvfpKpvdaJvaTINatIsYROjYJukLnLCFX/aJVvdoHg0IFg8hPYt8N2P85S7WfI3yU01MP8OuO8jAZpIRfhvuqf+X1iQ+5FnOxvWrvPHCF+n0NQkz7FUr/NAHD1E/USWMQuI7Q2aO1XFny5hMF5wXabB8iVWVkBoIvpOHPoUFgdCQmgPvkakDqKDozOV5PiEGF2RdBPvKQGbS/ZOTTvI99gf73eN98q8p5Itzbd6BY793EwYxIeFNHt6CtYyUFtJkk+70BOLCPc7MQuw7jE47aEpNHVblvsLRPrzIKmQ2HbsofBzbxrYt/MClOTvDf/grv8KhpSVsJ0AbSa5Txskuo7VLWNaAarONFSyiaGIbg29FCPUSIngTKTYRRBgFOnNJ7t5g+8u3YPQ2YW2B0dIZqocVD/z7P8l8+hj6wp+gXrwNwxbW/c/Ag6ew5lvoboYYRWSdDiLIaNx/jnRXMfjWKtnoM5TPH8Y9+xDCtzD9ASrKMJnFxq0Oqm5TvX+W+ZlZhCNxygGPPT7LaPAIly++zYtf/yJ7a6/jGYWOQy68fZvN3R5xnJJNFFwsyyomMxzAiKZqUFP52INpTGF0N32t0QYjNEIpTJ6SxkNuX77Ap/+PP6BUnaHkL1Mun2U90jz97HHybp+6cqlEmsEgYbWjiXtr+FlEveoTpZpstEeSdzmxtMIPLNf4rddfIUv7+MEpyjOV/f06yQ1xlDHqjcnCXWzTpeS7jPY2sLN1LJER5DfwvFWsuiJb3yYdpXgPPIpSEfFgSJp7BCcW0eFLCOcRkA2KKYLE2Abbr5LvbGB8H8wAKYcIexfd/SKqv0Zw/t8me/43CnPTqsDENvbsU3zgl97Fp370Z/njf/5pqo1ZLC+gM+5yI9lhp5fzQz/yNONbCTpJcWyLO4Mhr3359+gqgXffCWrn342pL7CeVUk7Azq1wpPAdzwqjQqz9YBDgcvANWwMG7jjIbp/m6vdlO6dNUZKU5tbwisNyfOULFKIcQgWOCan7iriVJFlCf1RhkjBKbnMVg3yTkqeOzCqUGMBu2mx+fYu22qLi8k14lHOI57iqYVF4nmX3/niF/l3P3yUb954jSt3rjEIh+RCcae/jVI5EonruIV7suMQ+AFxkpDnU/z8wcQRmMQZKNzbD8QGgAN1o4n78bRozafSpXJKcJ4CD4uYMQlR3GOFiOM4SKX3Y5ZSmkwpfMsmjEaUjGHYuc0Nd/h/svdeQZJl553f75xzbfrMyvKuu6q7p81MD8YPZgAQAAceoF0QlJZLSFxpYzeCL1KEFIplaAWEVtoH6UEMciWSCipiRS4pmqU4BAHCcQzGYbzp6Z72prxPn3n90cO9mdUDcReIBQgQETwT0TWVVZV5zbnnfN/3Nx+9OEcoJli3HT50NmG1u0b5UoFKKY81ZrIVtthZi5ieniZXsbj4zk2urd1g8cQRut10v42iKBVLo9NiSTxci9MiRkrdTK2EjYzFEUfRiI45vEBSSJCCODpE/r7b+Pvk4PsYOglIkh7plmSQaB8/atHrb8CghZWbBSMglBZ+UmKzt8OxQgCiBHIfIRoIupDE6ECggwu8+tvrWAWDqfuWmLj/LLIwS7x6CT1zFqQDS+9DLX0IFeYhGIBdJj6AwV4PaUY4iy7xrqZ7VVF4eIzJO6ts/sV1rrz0Gt5r15i66zwX31ol7MfMLJ7AOVqmbfk8+2cvohyHhx7+MKWJEm7BwrQVc0fG+aX/8pfodQN63W0kUCpXME2Tv51SZgpTSymwLYllgmNLHn44j2UNG+jYtBs+ft+kWCrTbHp89fFLXL/WoL0d0t9Mbb8wE964/Aqnj86x5vscLS9w3/RJdO5QjNNsRqgwpGBCbaaCtCdotnYZL9eAWeKkBcktpHdAcnOLKI5JDIOt1QOi2gzu1CmOfyTk5jcvYn/QwckNkCohAUJAhwndpqZYWUL6KxBuEgcD0G3ExYs41RLBk99CnVhCzp9OLWhlisYIw6RQ/xiDa8+wv7dKVVvU7jsFb13j1Zdf5lvPPUOUDDAIKbglSo7DTKXK+3/lP2F8cRaVswlti8GFrO3sAAAgAElEQVT1PnrR5mBvgJBgWSZBYvDKpQFrMk9lSlAvQM4QVEzBRD5dWX77d36T7e09wijENh3mxmc5cfwYB41dZpfm2Lj2OkfqEi1yBLqANUhwyiGNjTFUtUI5KeIyxcq5fR76T4/w1rV96lNHiQ86RN2EOFJ48zD32DhxJ8KYdbJ+Bn8L0+qHPIZL7wt/9P/yxhPPs769R2SWOTlX5GOf+yDlyQrhvk/iedhjChKJDmOMnEL72YJvSwhiRM5IFaDfG1X0+x5hFGIaKWoTJ/GoAmcYRoogoNFxnFn/wWHFOMkoODIVwSV65BkOafXKUBlfVhzSY4dVO/Rt9J4Mro/ihDjj9Q6rz4aRohZSSqTKPMHThYFY30ZdyUZa3TucVkJzKEoGhkoIIUCpdKONo4Q4Fkh52MH34Qfv5h//k19hZvYIUgm8sI0XHuB5O0StXdzaCWyzBEaVPV/RCbY4WowRooRQeyjRAN2HKEZ7IcngdV78Xy9TO1Fn7jN3crAnuX5xl5+9W5IEEb2+JHf2ZzHuKqB9hYgDhFvF3wwZ7LWxxySGcvB2BXrFpPTeCfL31LnxG9/m+l++QPyNV1HFPBvrA2JfcPTMvYjjFhsbbbZf72Ll8jz8yE9SmRHkixaFgsV9j9zN6XuOc+H8VS5fepHdb3+LINFZ9TLzXVfpRFRKZe4vmXB8qOHQh5QHKVI6VhRnXvVRhBCpi1Ecp0mDEUUkMbz2ygtYVg43V8V1n+OgucP2O+OMVcqcXr6XsO8RxR6PnrqLG5cjrl7bhgaIJLVE3Q4Szq++zauFEhvdgA9OnuRobQbtHCJhB7sRLiG1gsIcm0HLGdq9BhOVMdAzRLqJihNEu02yuU0YJWjTYOXyNnJ2kdKpWaqTPdafv8XSBxzsoo9Qmog0oYz9hH4LSmPHEP3z6KwfD4N9xNp57EoJ78vfwHz4g2iRoEUVIY20yCYMSpOf5cqNp2nutqnMuBTOLNK+cIvnn3mWbzz91xD3MJUk7xYo2TYz5Sof/2/+GcI0UJUcWpv4Gz4cy7G+3sdyDVzHoeUJVvYi1pVBfhwmixovDCBuofs7NPZ2mV86SqM1IG3AJFMLTdNG2IpiZZpy0qM0PqAVugw6AmPgUxo3WTnnEYkC86Ul+hs2V15fJX9HwIFo8cQbX+fzP/s5auVJWjseT7zzAl+++mUeueu9/PPf+O/Z3tqm6/WJSBvkTU9N0uv1aDabRGEqFo/iGCUVru3QG/SJk/hdQuHUTQgsy8oKAQnoeFRcGCYDcZKuSWniOlqVbqPeiKxJ2KFRwjApkOLQIc0wJQpBGMYpysCQZhfykaklepHirf4AZTscGTf53C89xOTSFP1LTfr+Po12D2PgEMUJM0sTxF5EYpvc++i93OfcTzcccOyby9xcvZX2UcjEx2J0bOkaGsfJ6LiyXxgtasNeDoJ0PcuYUSO90PfC8vj75OD7GgJNiMBG64g4GiD8AXk1hxi7g6i/jqEmiJIeg/4FNBLH+iCxXkfgIXQPog6J1yfs5mg9c4A1K5l/9BiVxSW0hKjzDZKdAQIfXZmFXky83yIOAvL33EPvT34P5xOfpXCqTNxRxG0wjxRRMQRrfZzFHBMf/wiFSo7+Xz2O3Yp4/z/7Kf6P33qKtzeuMysLLCwVOHmXxUvPb3H5/PNUzlU4cmqJysI4smChXBPXNcEex1YK27QYVoZ+oFfztgd2ONnTqiRIVx36HQP2pEsUJgRexMJSkX/0T99Dv3uKt55f49b5GwwamwgBg6TGiYeP8pnPP0ZykKAiQdiLQUk2txLMksItuhgq9Sru+33yhsSwNUIUMHDQ2gI7QR7voF9d57VnG0x/eJaxiQeJ1TQX1l7l2IOP0n3jHMr6EmrsAwjrbpSoE3ohuSJ0uhF5aWNEXRisQxwjpgvo8CjJ7DiyPIUuTJJQJNYSJ/FJUOw2XmCndYFBoOlhMdX0+YWffgxdrfLVbz7LxQvXCPsxnrYJwgP0qY/y0naTUjdCRi5WqLn/qMvWXpF6wcUtGUSJJPRgZl7TtyS31qHXSbhjUlKuFRgMfP7V//wvuH7lIp1E8+h7H6ZSLTE2Nsaj732UZ176CtsrW5RMB6WmMIXEwsSXBV5a3WCpVuLM2ZM0bplsXjUJ4wMespaYO32EuDPArOVh0kIA044i7ocYJXNU2R1FjO/iqPxAp9rf3vgO2PZgt0Wz7eEUy9x16jQf+EefxqRI4Am0ZWHYBo4j0MJEJyZhW2PmFMoGaYqUUgQ/tMQAQCkjFfClpH5i3wdSoXAq+MvoQlGUBn9KEob6sGkYYEo1QhzIYH40qOx9/DjGMtMkPkoSwjghSdLKnZJpEhFnTkVKiuxzsiB+FOnrtHPqsDqmUvoPWqfOOdn6keoPyP7RQwkFQomMUsRog9VZQ6H0gyRapM3WpDIw7BzzC/McNBq4OZPQ3yfy++TzR4jqx8Bbo+eX0HKTQPQwzDKu8yBJsgZRH5IuOmgQ9z38A0nn2/s4Jx2Wf/5eVH6OU3MuJ5Y1bF4kUhHbrYgpp0q0cwlyOUonTtD7o9/F+Qe/gjWWJ9juIytFipMTqUPa6gD3eJGF/+Lz1P7sjwgvv44YqzH7mQ/xG7/+DG9dPc9xM8/c0RKLBcUbL9/gy3/4O9x/8lHOPHoWs55H5iwcx+LY8SNYZYM3L7yDllcRQqIMg5iYOEkwMt/1mEPhp1Qqq1ZmxZns3g8DnCiOs4QwbeahswSBICRSPq3mHkpZmO0WytgmjgZc721yPYm4fvUtJmtzKGHyF1/7Q8I+lIqLfOCuj2H0W8RRk7wBA7fEWxvXIYlpTM/TDcHvRqgENjZj8uMmOSf1AA3ikCgcpOu9lSBECYNcSnuzQFoBxpubPPdEgzt++Sjlsfdz0PZoD64xf3aS9stvUy3+ETL/SaR5DJI8cRTiFgWtTkzZyCP8G+A3ESQwVUKHS8QLExjuJNquE+MghMJKfDQGm3vfYK+zTYxDaBc4Oy/5iZ/7KEmtxu/92z9nd3OfJBAMtMSPB+i7PsXXLlyk7NRRgUndUhybctnZzbEwVsStmngDScXWiKqmoyQbW4KgpynFXV559kUuvfUOY4Vx2ht7eELhGAmFco7+oI9ONEsn59lf2WN2sUDsOczk8wjLZn8/4eJ2j1I1j9Wy6YeLrG/liHIDjt9tMn58ipMXFnj67dfphqkQutveo26VePzZx7FyEqfi0Nvv43U8bMdm6ehRVlZX6Pa6KCXTpFOnFp1e4Ke0RqVGxYRRIJx9G0fRyK5UCknCoe5AKSPTTmXVd33YnT2NZUQmSM6oR0ly+L1Il2A/DFFCEGXBt0ohSmxTEUWaQNtEUlEfr3Py7tPc+cn3QmRysHKAaZvU6tNYOZXSlg2LouOw7a8TiCgVtBuSJIhZ21xPkwL0u5ANKdJAf+hApEVa6EyShCizJh3Rj4Yo6lB4PaRJZZqN7zb+Pjn4PoaQCmIDLSCOQqIoJhE2cTTA83ZxTYskCfC9HslAsDh1ByEaoW8iRC/lhqGIAxO93sU45nLs4ZO4tRrKLKPjAkKNw6KFt30Fp1BD5gsIbSP290kufIvcRz8OOQeUQFgmKu8gpEa/+BU4+2kwFYZbwZ6ssl8U/MUra5xaWuPRjz3C2kaTva11rq4ccPKBo/zkTx3n2Rd7vLN9lde3bnJ8for3HD+KNVbHniqi4hjLtkfwFfyg6ER/49W9LVnQGMaoTpD+q1IXFGWYKCVwcya2rbj3fQucumecJPTRicZLNI19Sa9hUioJcq5ktxFQcw3MgiDvSDZjEHFCRccwaCF0m+31Fs2wgeu65K0IK/JR1r3o+Trm8U1k5eME4hiJ1kwWXDqbz2PWcoRRH5pvIZ0WqngMwzmRWgaafbztA9Sgi5WESHxiSuixOk7lHmRuHIwcCWlHx4PtbbyVG0RJAWGN4dJloVLkYC/ka9+6yvREjfeePcsnPvQIQhrECRgqRlZmiZKATiAJQwM3FmwKg4ZhE5oGri8wTXCK4EqYyAtOVyUHfU23H7Pe0MzkTE6cPMnK+iq/9qu/ytzMDMpQGIZBsVjk3jsf5Xz8FNrvglHGCy2SQHHm7Ene+L3/h9rEGJNujoNwm439DXxvE+/cGWrHXKJIkpgGpqMwjdTqU1oinb8MY+rvFJD+mIyhO0SS0N3d5err52jv7rOwvMTCmdOcevgspunSXtnBrNYwijZKmAgjg6zzEnyypEikYmQLRlnSD+mSGCr1oU9GwX36JcrEcfI2KuGweqyTBKEkh2GhTqlGOkMJso04ijWGkpijzSnl/gql0EqPNrQh919rPaIPkf1vMqIA6ZGQWamsaRuHDYqGBy8yTYJAZxoC0gojZIHHYbIxPN2hK8jwXAaDAVeuXuPKlavcvLHC5FSZer1GPpej093Fi3tYaHL5PPv7DQzHZmZsiYgYoa+hZAQxJIlB3BOw18U8WeH0++/CrddJdBlp1Qhlnnang9O4SbG0jCq4JAHQXYc1n8KnfhptSAxlENkmsYoh2Me++RbBqY+RMw2c+gTRdIkbF2PeOLfHwuwedzxwhL1GzLXVdTxbs3x6ivd+dI4XXgx44tLbvLp9lQdPLDE7PYkoFXCmK0xVKrTbXcIwJEGghUwD+4ySoZMUIUUc6jMSnfZyuf0eDHniw+fj0GbxcEL7Xp9IGVhmlGq/4iZJHGJaJkJrvEGf3e1dkkTT6bRxzSID/wpPvtqGOEQJMEyLPvDpj/8ynYbP7uZlzl2/hrs8xtxyHekm5C3B1QDKUpCLAqTfRMddtlabHEQHVIo1XBqY2kKqe0jmJ7DuWEe4P0s/qWKaARWrSGfvNcx6jtBro/wXMIrbSGcZw54liTxyZo/u2h525GPo9KFOZBldGyNXewDh1tAypSJFYUBja4v+reuQmwfVZ8wxqTsu21seX21cYW6qzi985iO4ORct0qDZMEBWZvGCHo3AxIwUlpBsK5MmJpGpyA8kliXIKSgozYwruWdcstmO2dmtsts1aLRDXCUJEsWtGzdwHYXtWCAgl7fZWW1x+lidqZpBa+DQ6oIfBATJAKvbY8K1uOvRh/j28xts7r5Ebv84450PsJrc5O31JmZOceAf4ORtSmMVLr5zgdWdNar1Cp/5zGe4cP4Cr732OlprVlZW2D/YJwiCkVlAkmj8wCeKIwxlpMYoOnUq8vxhUz6ZVdPjEfc+lU4JDKkwsq7DKRKaUuOiJEIphWkaI4qk1hrDMLK1hxGsKTKkMo6jdA5nlXzDUBRMi3smpynKEjnbxi5OkIzl2Cto8sUqjSubuBPT5O08tmMgRaqHULmUEjkxOYlZMDDyiljEeA2PjY0N/MAnSeLRUqYTTSL1aN2TUmV0yCG16JAbKbP18tA84PbeB9/bRvL3ycH3NQRh6OEHPTr9PXpemyCBxl6T8WqVwPG4ubJDqELmjtaZtiIgIkxWsEU35eRGaXIgihPk6jZ2pYpIDJJQQeRAItBKIZxc+omWQRwHDDZvYB5bQM3MoSOIQo2OFSKRCNlFjBsYZSP1iZeSxMnRLVR5q+ez8+zbzC4uU5yaJueX6Oy1ufbOTebPVrnz7B1cW1nl5q1N3t7wUK7ibK1CTsRYSnNI4/3bjVTe/fb/vs8SKCPN8qUUSKGojOepjOch4+T1uwE76y3KFUXQ9Rjsh1iVPFVymLbET9KHIIg0rQjGpAMKnJJF3nchiYmCgJhFAt/CKi7jnOkQV08TqwqWEWIWLfY2fYpWgndjBz0dYao+SXMfo9BFxGMYMobSJNIBmVQQuoeylqB2FiM/D9JFIyFOCH2ftadeYK3dQYxNkJ+N8fe2kIaiVoi41mjTbg3oByHjM1PUJsY5uljALtnYYYIwC/Q8iZdItK3Y8KAmDLQURP2EEE1Tam70Iio5SSkJaaMwTUmj0eXc9k2299o8+vAjnD1zJ/lCIbOL67O7s01zv0W5OkHi23TaAZbQFOoubiWg1xrQ2O5TerCCW9wlCLfp9APW31pj+dgRlLSIexFSC8yqSp0+zNGkerdQ6sciPzgMQtNv00Bo77WXaa9tM7u8QHVmnomjS8jiGK21LlJLpClRVmr/ybAyLkDbIFPjq3RiyttsIX9IIw2mo1HToOFGMxQDj+z9RnQcMQoQh9aiIqu0xRkKKIa/n52KkrcDQ5noWApIIObQ3YYsQJd66Cl2mDu9S3SnNcqQGS6QCfMyykumVrhNMJ11ftZk+gWdcZUZcpJGFUatJVonxFFEu9Vme+sG0KHneySdAXFbsLuzjYgGHD8yzuvn3yY/LjlSXcA1IxJCouQmSnokSKJAkiQ5VGWKXL2AUx2DQBB7BjpSiEhguC5B2MA0FNo2CVo70NpEz4xhzi0Q9AO0D0rmkKqHtEKoKwIr7X4qlCLOl9ixSry63+TWc+/g5CtUjiwR+nvsbe3jWAH33VHj/kdPc+HKVS5fWUHfjKlvr6GEZu7UDNXxSRzTwLQspFKQUcWGrlXprRuxtA+dXbLFe0htiIU+7I2RwjTZXEhRHh0nJAKEFkQiQIhoFOhpnWqkfD8gSTppNTfWKQ2PPr7fzuaDxLJyVMuL4BXoNtbJySJhV9Dc6TCzNIadM+jHGhtBP0jfoyRzYAjckkXBdyFMCEWNQBSJtIFZvoPc2TaBexxDGdhOQJgPaO0FFC3N4J1NnOMa3e8gwz2kewyRVDBVjK4eQcUWIt5PE2l7EapnUIUZwCLRKQd80Oqy8tQLrLa7FI8uk+uFGFEX05YUcyE3GgGd5oAITWVymsmpKtPTOay8hR2GiFKVRge0KfGUZN8X1FHEUhC0I3xLshslRH5MyREUk4CtSLK+36NtTENhCa9zEztOEFGI34+Io4RSMU8pV8RIbGLp0B0Y9FsRrmNSnysR1HOsXG8SihL5WgGhuvhhm24rR3+1x/g9derTU7ihpNXb46C1S6O7z1ZzG88fEIR5VldXOWgcEMcRidasrq4SRGGqD0AgVRbQ6rSjMRkjOE4SojjO9C2Q+v0nt31/uJ4NBb1DA4OYQ4Hv0AVpSIUbFgSkECQie41D5EAqMaJZSiGwFFQdgwenq3h9i1YIXe0hRAknrrC7GuEoE7dkYztWimyiMZIE27GQEgzTRrkSDM3a2hq//we/T6fbyeb/bXTIbF0adqhXSr1rXU0yt0Wh0z1DZO5xw8Rh5B6n9e2X5987/j45+D5HEAbsNtdpdLbohwNiYbO+s8V4bY6ra2/y/AvnKE8VmTv9EAIPCImSXUxxgI77RGGC1ibm9DxGLkEIDToPSRFigySOGQxilFMGw0LLAK+zzd71mxQfOAtIhCXRUYwWCkGM9neRJ6YRRStdf/0ujU6Xy32DfqHOxaubrGz7nH7IJC8hDjVXzt2g0t/igz93hPL4OCofsbLR5EJnhxNmTK67i1ms8K7E80ccvA2PQ+the/UMQgOiKEkbpGkYdDuYtgn9EO/AI9pp4pqKyvEKXgxlBZ6EPopQltgLc0zVFZYX4fXaRJFPpBQHrZCKU8CcCtCmgTIcHCuPn49R9UmizhrhXgdhQqJ9lLGPwAfrTqQs4NRnQI9D3IZkgHRPgDVP5pNG7If0my22Ll/mjWde5YZTZeLs/bS1y80AWtE2M8rDKbiE/Zi3zl0mubDFxMwcjTN5rHqFmuFQrdVAuESGSaQ0Qpo4iSaMQSWpPWwYaXbbMZvdBHoDQsuhljMZ7Pe48uYKcvcWn/nwg2yurzM9O5vaqoUh7Vab1ZVVphemUfkpmjsXsWTAwlSVSAzodnw2NhpY5QqlsRKOI0jiHgcr15kbzOOYBnGs0XEaSEjj3YnmDzsQ/oGNYeCpNbHvE7abFMoFzPIEhfoE0nRpH0ToUFGplzHy1mF1WgqkKSHSCFOkHZEVoHRqsWh+94Y1P8gx3CxTb3FGjkBpH4B4xHsdbjZw2327bTcTCITWmVwio+/A6MEdBvuJTqtfMgvQh3apKaw+LOpr9PDvRMrv1sMgNeMUD4NOPQpOgaGYMKOrDdECdHp8yZBvDKnOgeFp6IxelNEa4gjPG3Br5SpzyxN4osf+/gEHrQ47WzvQGYA5xVNPX+bRT7yHE4VFIEAS4etddNIhjAKiCIRVxKwuo9wUzUiokEQ2cUCqdUhsEjOP4+RB9Ohs3kR3m1TKZTQCbShiP0GYJioJkGYfliZQRkrN0/0Gq60BN0KbplFi98oWbinkzMwcpu3Q2DngcmOPatTlwU8sURyfZSB6bDW6XF9fw+51sPNNLNcAHaeibaUY2sgyuoa3cf/EYZIwvMUpbUOPEjTgtuZLGvRhn4m0621CFCajZFOPusOSJQVxFgDCwO+jDAVY6fqvcpgUkdph48oWt3ZXWCzXaG+12b28TWNyjPqpMfqhZtwUNGNIhIWHohflmJ4wMHohXueARGq8GNoDTcnOYc8GxJaJaeYwiImKZdTYBGFnDWOniaiZGE4Xw2liJD0wTyBlEXdqCeJxiDsgFNI+irBmgNSFJxp4dHZ2WbvwDm88+zo33ConHjrNQSuks3GLftyjpnzcgkPQi3n2uTewS3ssHhnn2HIeq1KiqmzGJsaJYofYNQgcAykN7ATCWCOTBH+g6XsJ+4OI1RYk3T4t5bC76xGqOVS5gdfaoojH7HidVt8jAmwnR6lYJpcrc9CRdJoaozNgbMFgbqZKJBy++fglGmhkKY+TMzGMmHDQoLWywuT9Jzl+fJHdS+tIDf1eh17QI4gHDF3OXnr5ZTqdDr7vIaSk3e1k881AGRl9aFg4yChEURgSRiFRPNSvDJ2xbrMuHQbEZHqDLNkY/qdJ51kcx0TRUGNwKKwf6RAOVwRSsxSZcfk1hgTXlNTzBnlL0+728ckx0AkFo4Qlx9nd6XPqznFUzkBaWWIsBYYyMJWJVgnaTIhkzPr6Ok8+9RR//Gd/mjVzS0aI3PCZG75mGFn3+tsT8ezryEp4iOjJVD9Cht6OaJPfZfyYJQffUaX7kY70GBLtcjDw6SYS251gwq1jCovqxBh//twNrtzY4k4jwen7qMoskCC1JIkOCP0GcaIwC+OogoKkBWIabZ4hiS0iv0NMnWboUpRtnLyLYJWBd5Wdrsd8J8AgQSCRhoCygbA10fomqp5HGiYIQX/jCufefJUvX1yjeuRemnvrJG6OS29fpuS4mFJx0BP86TNrzM//Psce+gzVh47w5rVdzl/dZKOxTX/lKrNnH8V0ytkD+XdzpNXAhG7H5+I72zxw/wI51+OVl9e4695ZyvMGX/6tZ9l+vcUn//nD5G0DJQV5V1GxJRstwUurCe9bBNFNQOXAzaHjmH7UpxwlmLQwpY3SBlK4YE0wNveTHFy7ijsHg1UPsRmSWyoShm2c4ho6t5AGWqqEUEcRTo5E2IhIE4YBkR/h7TbYOX+Rl778OM96Jn7P43MzeZS02N3dx9tt8PbNPu5skTvvKHHpco+d/Ta76zf50vVtVGmB8sIiJXsbq1bFKBTJK4uF6Qo3e5JqzWKyKCgbkgmpOD5vcL2vGSiTg47k5rWQxrokUBX8nsW/+/NvsrG6xgc+8iFmFxZQyqBcrSMtB9stUsqV2FLXMYSkVFkklBoRJ7S7LWJhUKhNUJucYLBzgOnfxGs8ijNl4E64KCsTCUYJWOK2RfiHPFnge4ZZ/+YhssQgJbbHUYDf2mf2Q4/R6XZ5/ekX6L15nfGJ4yzedw+lRRe7lEMJiEJI4pQxgwXaSVtriMw4O00afriJAUAYRRgq3XxifdjXIBkG4hnnf7h5pzB+Su9JK1RyFPgrJSGOUZloMA3UD0WASXbttGbUwCiBFAnI7DGHvUNSD32Zrj9xWiW8XacUZ7SndBzqC7KLmTKTdNaMLRnun/IQUdCZrWmGkKRHokmSCM9LSJKIF158g/uK94INzf19Bt0O+bzB7mCXp863WV3dJWk0sH2JKk6gdYBIJHGyTeC1QeUxnQrSFakGgRkS8wEisUOkYRBVWG+ETBdNClNTBO1v0fE3CHsmc/0QSFLRtALPiVBBCzvaQzh5atVJNIL2lVd54uXXeHWtTXlimebeBoFlc+Hlt6m4eaIgR7fXZ+OZ68zObnDy0X9I4SNnePKVy7ztHRBLwfyETa5os7q6Sr/Xz+75YWV1iCBAZhk7qs6kF1LrYVqmbwtwDtGZkWUkAmmkcyNOotuCOzna7YcNnkaVUSAmhlhkdA+HUn6JanmJ1sFr9BvXiMUs37ryJEsbdbz1Pv4qPPbfPkAhb2HIhJmCoh9I1hpwYTvhfUc0UStGOGWE0sReyCAMKEYJJg1Mo4ChHYRyMXILVGY/QOPaZfKL0H2zgz3pYU0ZBH4TO7+Bzi+iaCDVGJizCMNFCwsdQRj4RH5Ib2WTWy+/wmvffoFX/HS9/+SxMmsrVa4N9mm2BvTWBjhTRe69s8TzL+8x8BtceWeXC2/3MIqzlBYWqdo7GJMTmJZDxXUZrxW5NhCM1SxmSoJxDTM1hW8arHrQE4qgITH2pwjMhMStgz2OnyhOjY9xa3+f/V6PUBj0Iok2HfxAsL/XZd5R9DsxXt/CrUxAGNPqtKjOHKE2s0Zzp4fhdUj2L3HhBQttaV669iztoI+bdynmc/ihhx8H5HIuK6ur9PuDtI/ICLRLg3Aj07AMdQRDWkwYhsQZdWiILEgpSB//w+DeUmaqk4njtC9AnK6thhAkyiCMUrRCDIsSJOgYYsj4/UNUNEMNsuqG4xiIROMYgumyzeK4wzObq6DzjBdKLFfnqE0fpTRbxRmPqZ6aottqo2WaBKusd02sYqRK17nt7R2+9Jdf4o//9E8Jg/CQHnVbkjNqfKYPqZ1D4l6iM82WOEQUhijK8HfjjKL0vboVqS984Qv/3h9+8Ytf/ALAL/7iL3Ly5Mnv+mY/vPGjTg4ymyshsO0c46VZ6uVZxsoTjJUmGatO8tT6b7N/0GT75gHnz23yzqU+n/joLyBwMVUBki9KNe8AACAASURBVBYyHGCIMlblfqRxCqGOgLgXnRRodOHWpsHqVVhazJEfDzEcSA7OETZuoR2H4uwusnAaIazRphYJB99dxLDmEcpECHj83/wBf/X4VwgMuO8nHyKO+8yN56CoqMyOU6lP4nUkQWuDF19scfeRHLVqGVUdp2nneOaZb3JtL+DU8p3k8sVU2DOsHP4dHGEYMuh5AIzViswtj3Pm7ByWZbB2fZ+1K5vcWnsbYc3hV0tYlsKSYBmCak5y57TJE3uCgiXQXsTBXpetgybTNYHhtcmXJNIq0xtYtDsJrmXgDxKsms31vSZ+JIn6JvvXQnZudWm+eImVFy4Q7d4gXL2Ev71GYAj6jT3CXbj49Cu89ZUneOPrT/HW6xdYU0Xu+eyHseqzPPvMCrMlzUffe4TS+Amu7Atcr0N30GFi/iiTCzWccoiZq5NzTBKh6Hd8BkGDyN/Fb+1y5fVLbOxcY7NX4MZOQsPXaFNgAg/PG7xnzOT0uMHpZYvpk0Wi6SkOegvs3XiTZt9jfW2dt69d5+3rN9nZ2GRsrMzmdoPxsTHWNva5eukW+2u73PvIh3jq8a/h+QEf/NRjFCZn6Ycx7Y0baAwCf4K5s2PYeTNd8NRwcb/t5v0o5tR/1Gfq0RdNAokmCQaErS3CvevkZk+QJJqXvvLnXHrpW8S6x32f/jCmI4i8NCNQIsFQCcJI/fxNW4PMKDiGQprWD/Q0/0Oj2Wzy67/+60DK37UsC9M0UUORaYYWKCVHG4tSEo0misK0L8Ft2ogoSxgMKTCkxMjEwnJYYR5V/8mq+IzQv+FrRpZQjIJSIUAq4ihmGHSmL6WuRUkmeE0dPORhMjHUSNxW21aZ484Qbh8iIbfTJuM4rVandoKpELfd7nPz6ip+GNJtDug2ekDI3T+zQOOgy+aVJi+9vEYYjfPQAz+JEC6WLKHjLaTXx7AXkLm7kOoOUIsgHiQOBRt7cO0a3LrURQ9ucseD80gLks0n6B6sI4sRlcUEVTiJkA6WZdDpdAiNCkb1FLZzBGGYIDS/+Wtf5PU33qIwXeP4vcdptrYoyB5M5HHGy1hWGRWaeM0dXnyhw0/cXaRWn2FQGadvGrS7Ld5e7/LcN7/G6tounW6fgefjB0Gqq8uCCyFucxvW4rAfRjLkRGcKFJ2KzOWoqCSQCJQQKMNM+d630dgOA5fU9UpmCVysk1FCr6RK+dhJQs6uknNq2KZNxQ242XkHYfhU3DnquWmkDljbucpbr3jUHlymaCpMJXAtwURRcXzC4us7MG5p/E7A9m6b3qDHeElj+G2KFQNt1Gi0BKGfat0CH+wxl4vrWyjp0NuT7N0M2LvepPnSJW49fx7ZXcG79g5+t4GfBPQP9gl3E859/Xlef/yrvPHkc1y4tk6zXOfOn3o/Zm2WLz9+no/eV+E9Z5YxivOstQWO16HT73D01N1UJiROSWLnK+Rsk0RKOk0PL9oj8vZpbW1w7dxlNravszmocnUzpAdoCWVL8MCswb1jBu+ZNLnztE3uWBm/MkPXn6K5cRnPcKjXx1i+5z4K1XEkgrGxIonMc/PaKn5g4h345Owa5fF5Lr70Fr434NrqVaZOnkWEIZ2tdVAurnOMf/fE7xMEAyKR4IUD2t0W7X6XXM6l0+vQ6/dJkgTbsigWimh01iFd4/keURgNH8i0M3EW+8nMwjiL3bEtO9U0RYdBtWlZmX4gIfJDZBKjsi7sbj5PGMfEUZQWOEZzOp2vcRynxgjGUMek0QIMCWNVm5IrufNIgYdPV1iYdXniwh5WziCvfeJwj6X7j/Loz32YsakyRALTtpA6RClISPAjDyEDEh1jGop/+S//J770l1+i2WwSRuGo+dlwDNe/OInfhRiMej1oMqHxEMFlhBgMUdC0QWUK4yVJMvqML3zhC1/8m/aEHzPk4O/eEEJiWQ7SkERxSKfb5t8+/rs8/a1vE4cBkRcR64TLV6/x+f/6P+d3/8V/hVlaRFmfwrA1UAIxTjrFI/zWS9y8kRD0XYq2wdhCG6dmIfQFtLdCErcxyh5G4vPUV7d47LP/Gln9JWAcpINSBpZhEUYxQsXsPPXXbG1uEZUqVHIuaneLqcVxqvUCjddv0Vhdw5ioceeDR1idKvLOa8/w+De3+ETlDFMnHe6aDjDfd4ZJu8at9RuUyjVM0/mRxHDfyxACHMfCnrQYn6iMXs8XJEoUqf3Eae7/wEneeHKDrbjMX/yVz82338BrHnDyRJVf++/uIzrweH8oaHod4sGAmgVzM2M0gpjK2ASGlrS6IZaQmHlJOAgxVJ6+eIgTZ5bwu6+StNawennC6Aj7kU+5u8rltYDd1Q5h/23sb55jpZWwuhvQjRIcq4hyK5QXjvGpz32MzU3NfLnBXm6DN85f5WBvm5+4/w4mP3WK3/u/vkKHAnJzg2q9RKU+gcy38JMSTtKlLw2iZJIgsMiZLabP3INrNGluX6bTzPPW1YCXOwGONcb4ZJnpSo7ls2Xes5jjkZLBPcdtLs4e4y/P/g+0XniG1d4Kjtch7wxouTmibheESenBCo7MkY/LTKhpIKY8VmV8dxPL91g6c5L5uU9y+cwS1588j9E+j2AZhM2ImD6MCm/3mvyxGjq1Io4D4s4q0dpLSBHT252i3YetwYD9fpcZr0kuB5rUHjCJYnQikEqgTCM79wTiAGG5CPWjW5pd2xl1Ox6KjYcaHkNIbDN1MkpIbQbTy6CxTDVKAIbWogx56MMhUhEzWQVQx3pENxrai0opSOLbNuvbdABk1oGjl4QEMUwYyKrSadVMJwlaKkSWbSSH+RxR5rpEpId/xiEfKq1EqtsS1+H77R908IKIXKGAZUmEGRFaLn/0v7yBjkKiSBMngi8/8XVu7a3zr371V7BLx5DWz2OM2yDGgBIASRzQbzzFs0+3mahOM1ezceZcxubvxpCvQHADrZpUjjusr/V45qvP8eF/0Meo/GOgzPhEnSgEfxDS6oaYSZ/z//v/xq2DJrGbQww6DG5dZuLIGEeXZ3n6q+cQnS5TU1NMnJmhMVXh2tvf5rf+z9f5uX+6yGQ9z11HixQKRxjsNNgYVAjj1dH1kSKlQ2ggSTKKz0j3kYBOE6rDxEFlSdohD3WoQ9BZQiaz6aG1GAX+esgvJ7M/HSV3w94VMv287OdeuA3dFkFsk8/lCYjoBTd4z90LbO9ucbWRcN/yR3FOnOTf/GGXtVdewxARn/7kIv/ws8eImj4fjCRPvvgix2cmmZ+pIPN5+pGmUp/E0JL9VkDeMVKnGj/CMMr0xXs5e+8R2o2nMTp91KBKEE/SiHyqnRVevRFx0DxAvvY8if8c6+2Y9f2QTpRQdGrofIVjD9zDo4/ez+5uwmKlwapzlb968k3uPzXLI8cWmBs/xh//4V/Tk2Wubl1jcnYCO1dD5D3CJIcTd4iURRAvYgV9ijlBbWYeSzZpbr1FIy7z3Lk2cWDguhXG6kXmanlOPVDl4QWXn6kJ3vdAiXPH7uYb9y3TfPoJet4tuhsDYh/spIi/H1Ao5lGuQ70wyRGrguhIzr35Mrmcw6Tfwey1+erj/zdxz2DWnEBbLvb+67QPNhEE9MOIxqBDy+tgmhbHl49zY+0GeTeHUoqc62LZDr7vE+oQAZimNXIMMpVKxcTDJoxDNCpbRzzfQyo1qpJLIYnCzNM/SkZ0Yy1EmlQohZ2Zqwz6/YzKmAbTShwuBVKKrA+KxDTAVoJ6zWayaPCBO0vctZQnSCSfDuc5dz1iuwtJv4MhfKpjDp5v8td//Rz3nr2LatFFGoowjoiCCMNySMI+n//PPs+FC+/Q7nRTq/RsoUqSwwaQw2EYxkjzJUmLM0nWV0TKVMMWRoeJ9pAmpaQaracZVvtd94EfM+Tgtrv2Ix+Hx6KzVuzrm7f42pN/Qn/QpdveRlqS+XvHWHpkltl7lrCP3MuXv/kELzz3FIsLd1LI50iiLQL/PDd33uS115/l+htvUhxbJj81B0VFuRrimO+AWCPsHdDa7uJFCea4xfpFj413fHYurhI+/ZeI7j5ibJJBr8eLf/CnvPbKiyy/9yEGk3li16AgDSL2WNtpk2xuUKvbFMoWXthne3+Tk3fdyWCnzWDQo1yIKZcd6pPzHKktc+XKG7zn1COUCpXRpvnuBOFHd19ujx+GlmQjp5GMtOw1Y6KBRiKwXcXMsTL1usmpo4r1G6vstxVWZYFCQXPta+cw/W3sehmVK6FyRexCnlqpgFAmylAoLRkEsLPfY+vWVUqzU5iJJl7ZJAlcPHWUtjqJqh+lngt5dt9iYnaZ+eVjjE3NYAmbex/5CWzH4ac++9OM3/cepu++kyPHjnPt4hrLBUGlucLCwhSeLnBtvc/NtR3uPHsXH33sFNOT4+goJuh7aN+noARB7DAIEwQDtN8m7nUYtAJWL61QMD1KtQr1aI/FXJuFiZBY7NHoeazdWGFlxeOdWz2ubPTpdEOWiw6npmw2p2cZxBN0Ox6d1h69Ady6cYPG3hbF/BiNTo+t/XaKJJR9FpaOsHd1haijKVQqjE2PI/2Ivcs3sWZyzN99B+2tXYL+ALdUGFV133UzfxQT6D96aOLWO4Tb3yBqPI0wtiC3jnLv4KVnn+LcuXdY32sjyxU+9InHEIaFl0CCxDAVhqlG5VchNMqyEBm/+4d5LW5HDiwz9V3XGdd7dKYaTDNFDYcivyirvImMR5QmFENqSEoVsgyFUgplpBZ6UZR6dAudwfUj6DwLDDPKyqFAUIw2tSHMP8QBkoSsuZpO7btv2/REpkMYHT/DAFOOzmtIcxqew6G4Ov2b7zDVyc5DISSMTRSYmK2AiJFxgLQlxz4wweKDM9TO3EG3OMvXnnqG5575Bvff+xEM6ZOEt+h0z3F943Vee+NZrr/2JnMn348zUceuKorVPq55GVgh6Oyzv9ZBFA1CmbB6fpdbrx+w8dYV1BN/gCpX0G6e7es3ePI3f4dvP/stwqUZouUJpNaYyQDhDNjY7WDv7DC16GJYCX2/Q3vQIbZMjE5MEPlMj4WMTU0x6MWsXb5JOe/wzDdf5uCgRRCGRGEqUk0p3of9K0bXa8jXvu06Cm7TePAda7QGhM7m2SG9b9jQSQ8TiezeK5miDcNgSJIlbjKdr7ZtYpkmKkk1CD/zoZ/nsY9+iKVjMwTJAS+89VXGp3KsXv42kacxi4ustmJefuUixvUd4oNrLNx7hlx5HLNQxC3kKRcKSGViGBKVSFp92N7coXmwQ35iDDPRBNdX0GqMnj7OwDmBWZ2lkot5ctfi+PJJZpaXKJaqlMvj3HXfQ7iuyy/88ucwT53g+P33UChV2V7ZYdHVVJq3OHpiiY2G4tpag2Yv4M67TvKRx05Tr9XodXpEnoeKQhwhCRObQZQgdQ89aBH3BrR3umzdWCdv+lTGa0z2VzlW96mX+8Q0aHb63Lx6i2s3A86t9Li+3SP2YpaKNmdmXdZmF+n16gy6+5AkJIlif++AKOjw4fd/nKurW+w3PaSKGMsN8HttzIFgprTM+ZXruEqyXB+n5ubY9rb5+qWXef/iaXp+j6bfQYs0Ud8+2KHX6xNEIYaZugO1Wi20hiDwuX35G8qYLMsmisJDmkwcE4YhQgiiKMIwTKIoGjUKMwwjpStJmTqikcpkYiWISbt0jzoLD9cgDYaSI0Qs1T8IDFNRKLjkc5J/8rllPv2BKmdOF6gvFCjNlGh4krwzyfrOgN1BxOypk9z94L0Ylk1lYgo/CHFydurKJwWWbSF0whe/+D/yxhtv0O3108RghJrd1rU9QzKGLktwqAsbGjLo257J4fM57Fo+7Gp/O5VI/91GDr4zcxF/w8/+riQC/+EhELRaDVbXbrK9s0N9YoJPf+Kz+HoXVTcZCM1+N6YtEzoti53mAX9y7mlyLwfYrX1Koof2NbnlM4wf/zBJMUcsd8hZAxy1D7oHuOw1JBu+gZl3mCuWcOoRx89+mvNbr3DpxibOSy9R3Dgg9gMWOlu82XfoGTHjR+eZbx+wu7OL9gPuvnuKnZsttAJpRNimT+LFbG1fpDK/QOtGl0uXtrArE9w9cxx/0GJ55gTFYjmt+v2dStL+/2MYqKT0BUg8jQxBBoLYSwi2E8rHDcYnTaIw4ed+5gS3WuC5BYqTAvfho7hlgVUu4SuTREkwFIMIBn6CCGL2bzZo99p4Zogu1smZJv1+hD7wCUtV5NgUeSOHt+PRsee5645lxN4A2zawSoKWXGBl4wbvfexDGMqmnLfxlcXBns/6nsebN15C1evk4oSTJ2Y5ujzL1Rs7vH1pg4U5h3vummKyHHNz9YDtRh9v0AajQM9z+f+oe7MYy6/7zu9zzn+/+721r73vC8luUpRIUdQuK2N5iT0ewzNIECBA4CQveQiQ5CEIAkzmKS95SRAgDxMgsScznniXbEmmNop7k93NZu/dtW+37r7893Py8L+3qkTJkG3EpnwAdrFvVVfd+v//53d+y3cJEj8b3CcKORxgWz3uvnObwvQzzFQUMzVBJWdyYgqOYRJO1Wj0hyS9Adu+TX+vQrdlcWXZ5j9YKvDYWGBtxqC5M0G0u07g79DvDXh8/wEXrpzDTCI+eP1d9pon2aw3aaSwvbNHr9Ojvd/k/vu3uParr2LkDCzHxinmMvWTn7ppn8SD8ndZ44dLk/grqPQ9tPUQWQzArKKIGPbvcun6Z1hb7zHwU3qDHjf+7E954df/GYaEdgKphhwaoTRCKSzLQMh/+MLg40vpjDuSdfkz2VGlFNGoIyXI4DimNDNYUZxkhmcjvwAFBxhhzWjcbY4UglTGExBHwr8UjDpcArRCjbgCIw5iJvl8hDg81v1WOisAkpFj6SE+lxGsRYx8ChgdmKNvoMcExJHdUca6PihAxrhcASh1SG4cvwOdKkrVHG7eBWlgWw7VqTzLxyt4J2bwE5uu8khUSD+U7HaH/G8//mPM7W2KUYe8CkkSGJRrPHvllxEFjek0cKwejmiCHqLJs7MvWdMO824Zp+Qiqg2aiUVzeod7d1Yp/NHvYRZr2P6QmXiFN7cMTv/qKxwzZzHrdYb+PjkTnn9+ksZKn1RF5AoSc5AyDPqEaYw1Mwu7fW7f2adySlOt1pifnGRve4dBLyQKYpIoOYQkwJGkZNz1JyMX6xGsQY8Tez0q4MbeGJm8bXYZs8Q/Ix2nBwXDmBR+uAfEwd/H5lSGNA6eAyklhinHmg7kSx6/+5/9Lmfmz1MuVGjrMo1Ci3v6Nu+/9S2EKNIZWHzxK6c588wZ8kxSIKFckXgTNYaYaFuSSkkcQxApZKjYuVenT4/QEuTKVTzTYjhIoO4TucewSxPoxGTYCujYy1y/dAax2ceb9EidZRq7+9Rbe7z81S9hSpvPXJwmSC3WHzXY31rj5qN7GFNTFEh59eXz7O732GsMuPNgh8V5l8++sMhEzmdtu0+r28ePYqSRxXs/dTCxMaIQIxkQ6Q733r5NYe46C9WAOcem7EEhL1Haol0xaQddgkaHjW6Owd4ErX2D80s2v3m6xG2Os7YEra1VBptPCcN9/GHA1tM1ttefUBQWlsrR9y10fpK+WqcSREgEdgr9bpe3O/uE0seUmtagRZCEmKZJzrYyGdQ4ysjAKsX3/Qy+qDI+ZuaLIQ9gfeOifiw1ekg0zgi2gkw6NwwC0tFzmvmwxJCKEX9qhAlipJwVRhk+X4oR9CjFNEzyeY9Bf5A9ZxwOtk0pyOcsfuOfnOHFz80xkU9QKiUVBrbpsLQs+O7ra+RdmziVbD5+yIff+Q5Xv/4NSqUcPSVRpokpFShFr9vhL7/157zz7rt0uj2CMMoKm5FB5FgE4uh++ziMW42no6NYOt5njHeeOhrH1MfS6p9/vvz9Fgd/HeHvoIIZ33YOgsXBy/Cx939kPP0LhGkZT7sNw6RanuTiuetoS1OeKyNUjt36Pvu7++y2OgzMLUr5Avm5WZTjs1nfIdneYspKmZo6zemFZ6hNTEPwFKlaGFIjCVCqT6oTtpoBvlHEy5fQMqZ8DNRsm0JuQNAy0P0mSr6PmfjUlk9z1l1C2aCVg7RdpG1QmzlFpEOsvIfpWECMdASu5TJM25Rniwx2LfZ6Q9b3mhxrd8h5eZbnMym3n3xAf3Huw89cAnSg0ZGGtkb2FcpXqDQhqUeofQM5Z3FqeYIZQ9ATAiNV+FSJzJH0p4Y0gbCTMGz4NIOAVn2PQSvAK5hUF0qUpyYJYpN4qEmaXXxnAs+pUTINNu5v056t8tkXZnh87wl9KbCXqrgzZXbe/YjdSpdea8DyjEt5cQqdq1CrVbn39C5OcZZARHilmMnJCqXaGeq7LTZbKfPTismpGqabo9gYsr1bp6AULctmkDoM44wca9oaYWjEMEdjex011IQDk27bplKyKZdgojBNLQ9+EuNHCUEgePSwg9mb5Vgww6lJk+mzs2xPeWyVbBr06T55xE59n5n6PJa0mJ+bYDg0aPZhKAyGKqLvD2jt77Ozsc7nf+uXEZbB9uY2qR9QqpQpjDfPQQz4RJ+Wv9kaQx9IUcEaKngLrZ8gnT4aC4REqBLdrRZGRXLh8hmkCmjv7NPb22WskoGAUIFMNTmZ4ebFuPD+hOObgIPOfYa7NUek0NGhI7Kph2VZmKZBKAJUkmKOZCrR6iCxG8NzLGlkV00f+rklo46xMcKgpyNgkTHu9o3gA0pr0iOHXFZ0jPW7R6eIPEwjs5G7PuhEj4nOh9f1J6VTD5+7I+eSHiHdRp4IWeGQ8STiOGHQD6nvdRnGOSaWqkwdn2N2tsTGVodWe0g3aRHZBq7rYZc8BmKfev0JhUGHac+jOnmCxaVrTM0uIIYfYcoIU8YI+ijVJ9Epq3sDqMyCY2OKmImzeXQiyS0prFYenawiokc4MqW0aHNi/gT5iQrDNMb0HLAtEtMj1SnKFjiOjWko7LyB5Sh8I8Gq2bTbBuvNIVt7DaZMSKOUtUcbmFL8FOcCgLH/BCPp2lFL9mAnj5oz40JsfK/GkwT0oYLUeCr0k0e9Ht2jsbOx+glIWDYpSoHsPBq7Zk9OTvArX/8GX/3Sl1CbEDUjhnXJVFDimcoptJunbSVw3OVTVwucu1pGJiW67QFJLkekJSkwCDXdboTf9mkFEc29HQaNkOqcS3mqQqFaJoiyeJ822vTnLzOVr5HuD9l42KM/U+HVT8/y/hu3CbQFU1Vk0aJ+Z5XdYpd2vcvFk0XchQUGRY9CocjTtcfYZZOoH1CdSjl2bJrpWUWz0WWjmXB8XrG4NItbCNjZ79JodykpRWvo0E8c+pFCWhJhgTQUPd9jb/0JwtcEPYtyyaZcdCgWFEvFCvM1wSAK8COB363zcNBAtac4Fc1zdcZitnyM1arDpifoGCHB2gprW9vkrCJFkeBIC2FM0JcGrWSVoQgpFHK4iUEYDNjyW3Skz/LUPIIM6oIG27DQZnYj4zgGzUFH/Cim3jIt0jRgLEGaQRFHj9/YlVuPO+nZ8xWn6UHMktJAKZ09+0phmdaosanRauzurjNY4eg5NAwDx3UZDIaoUTNBjgqDiarDl19d5mtfWWR2wcOUMWGYolODNLXQgY9WCYtLRSZ6YA/rbD28w9Wv/zJCCBzPIdApayurbK08Ye3pU77znW9T398njKMDmJ7S6nDviDEy86chQHoEtxrHwLGzc1ZEjDwOxmQu+JnFxc9b/zCTg4+Nd0cv/uTHIwLZ4wAyXn/DQucTW0IIKqUaxUKFkycucHf9I242PoDGkKc377G9vkE/6BMagisvPMOFs6cpzLtsO5pmLqRkRBx//lWWp06S7N4lTteRbgpGgVRYqGif3UFCK3Go5ScomAb94S7TJxR3t/89M2WXMy+bCKEIQx9rLyZWC7xy6Vl6loVq+RnJxbKYPHOFdz/8MWXTwTJNVKowTIVXcsgJgWkN8CbyqKFgEA/Y3Vrn6pWXKeWnD6rQA3LgL/rSoHopyofwcYhuBEgSnKpBuq0IPpQYZh5VMjGEIp9EBGFE5GtCz8WzBCLVBGFKpx/QX99jPR6wvr1JdXaCEzPHKM/PUbME+80Yu+0zGPRJEeQcFxGFPLy1Qc6pIqVkY61DsxMzlRqcem6WVXOWv/j976NiwaUpg/MvXaD6+c+wdOEYm+ubuFKgSdjarpOkKZ964RKXjlX4weMBO82AfL6AV62wXIwRXgXdeoJhWhTw6A5ChpFEyxKmLrL4Qo27779N0m1Qbye0TJtiIU+5BserS0zNT1IpGiTCYhCk7NVXePy0y+rWgE8/N8HsQo7KZJFC/jwrjsLfr9Me+tx47z5LtTKnTpzA72ryhTmEY5MaKd1OEy1ThsM+g26P0swUu5s76CjGtGxqo3v0E42BX/B1EJt0Sty/gVBvI0QKZhaM08RHp0UGHZfdjRssnpxhqniWxkoJpzRBksb4QYItLVIk6Yh3YNkWwC/EvhJSjrr4o4RbSoRS2IaRJWmGwDQtbNtBWxYSSKIYa5TIaw478aZh4BgGhhQH+HSDLDGP0yxhlGRdulSBVhrDEAeFgQaUFsgRXCn7L0sKss/pEcxgDGHhsBD42MF4WBqMu84j+cPxtACO/MzRF+rDTnbm6JthgjdW97H3ulTnqrgzE5ycP0Vjb8CTNz6k1+sSKgU5h6UziywtTnNycYZ7/SZiABMTM5y4+CXOVa7gb7yNsDeQRgFt2NkzEdXZ7kW0U5eTuQmImyg5ZPF8mbDdZK6sWfxGlSEBujMg3grZ3HL4/NVrxK6FOYhJhWRouwwMj72NHgUtKDkWaRRiuQLXNSkYJo4T0CpahCpgc3eFYdhkY32Pu3efIsi6nGmSHhA94RADPU74R63Og+nA6Bg/pJwcTWAOqrnRvc+qtCMJ0BE0tBj9fSRneqCapTMOjBb6IE+wbYulhQV+59d+G90A/1YAzT6i0aY6EHxm6RmuPf8V3ujeZurqApOFKvZWl0SDGqa0k4SiLVGxph/E9Ft9ertNCFr5CwAAIABJREFUNpMhqxvrzJ9cZGZhnupEiRzQbMZYbZ/esI8yHUzbZtBt8PSjHfJ2BdOUPLrfQDZijj1vUymV2UgqfPP/fg2VSPSiyelffZXq8gkWzi2zv9/AQaOJefh4gwsXTnDxzAL6eI03Voas7/gUKlWqswKzWMPdb6M6G0gDCiJPo90jxkK7Nq5ZYnl5iltvv45fb7K5J2i4HsWCQ6kiOVZZYGZ5hmpVEylJp9+m0ahz78ECa9sBX365xrHJHIWlaQoFm62SzVqvQ7c7ZHHhLOW4QyXvYk0u8aDZJ0xSUhkxVSsj+xGqH2Enmm4a8NzyeURnSKw0cZIgpJHJGo+SWWmIkQrRoU6/YRgHggGM9qplmSAyv4v4iCv6QSJ8RCTBNK2MczAqSFKlMNBYY8+EdMyNSVFj7tGRRsI4rggBhiFwHYPF+QK/85tnOX3ayM4rw8YSoCMTfyDZWe1zerHC0tkyTlsTtWEQ7PP06QMKtVl6zSHNbod3fvBXvPuj7/PowQM6vR5aj/w8GPkXjBoQYwngo7BOISVytO8O/GY4PDMOP8J4Z4736dHPj7/m562/9+JgfJiKj706JiYRR2gkwrJGLpjZ61pnBKcDQtpfmz/8zDHDP8Aaj1iznz2uWD3H49Kxi7x3903e+4sfYQV9aoZi0rPwizb5SZuFBYeb97fRtkdl7gKagNNzL7O9910GH73DcHGGyfJ5TjgzxOE9gladbz+QXL/+H6P791ldfQc76fPMZxb4YGWDO4+7lK9XqE7b6MAkCRyaT/dxlMIRijOlhDgf8WQ4ZKexy6tfe56P3rxPo90HIck74PoN3HwZkRRZPn8WYh8dttjfWqF/8hkqxfkjGOBf/KUhG6sFisEHEc339tHrG3g6onTyONYX5jE/axBqSH3F5qMWax9uUXVbiAvnqc2bkIDfDAhbbZS/i47qKNPlwtVnuXhumlrJIRko6k8CRLPNsLeNX6uxPFthOmex1+xz4+kev/vVPBKDJ3s9PrqxyqlOk+uvHqN99UXq77xF1BjQbkv6U5N8/tqAM+dmeLx6mmT/EUqZFIouOQ33bu7y6c8u8qsvTdDohGy3EjSKnA2G5RHnoLfewXcsalWDsCPY2fHplisUFvo8l1ygvvaAqLWHDgf43Rar9YReaR8+VBxfLjM/P0G1WuXsMxVW19bY3bzDN79zluXjJ7l2dYZrJ3JMTV+n29pn58YNdLRPS/rkohzddJqZxVkcpUi6beorj9nfcXj85Akf3bzNp7/8eZ55/rmRSpEx6vj+Y3iaPr40Wkck4Ta2oxFSZRqkyiKJTAatBOwyabJBKmLKx2zsaoXtpwHddp2d3W08b5ZKuUgu5yKE9Yu1p/RByneAEVcqRWQ5GVpDKgTJiAAoDRPblYhUYWiFqQShSrBGZj2mkSX/phTkHQNfaJASyzJI4hRbCEyRGZ0FOjscxwljqjOjsnFjwrENgig9fG00ocikNnXmWk92uCo1wt6KEQThYGQvDnTTxZj8jGb0tg5OzvHZlUFqssNZqZERUpIQ+Yrefpvte+tMT07w4K/eYdaVzJspOmeSTnrUFgpcvTjPm++tEto2bnkBZ+osy5NX2Wn+iN7d7zG8epmz7llKlib2P6LX2OdP7gz4+lf+B/Yf/z67aw+YrJgsXZjj9soTPrgfsfDlWVxHEEuXYUcyjFKKbpmZoseC12bfVazGCVJEPPvp42zeqvNobZNCrsBUWZLXKUlqEHVNmCxSikKGrQ2igct+K2Bjq4nvh0RRMuKQjBKM0R+mmd07PfYq0BxRI4JsPjSGH40bf9lnDoylRsXWgYPruHgQmfvreFogDWP0LGYythnkaDyJ0KRJgoGBkRjcfu0W1ntFvJZFKdymnM9TmllkcPoYpc+XeaF/HSXhwx9uETebTMwKxOmTTORS9DDF3x4Q9/ZRYR2VdNCmw9XrL3LtmRk8QzJsJTR2A0S7w6C3zWB+jsszefKm5F7T5+FWi3/+hRxKST7aatO48YSvVuDqV5+hc+E56u++TVQf8pddC3W1weXlJU6em2Fz7yTJ/kPS1GOi5uE3hqyLNleeneHXFiaptwLWGgmOC27eJe+6RHmL9nqHMGczVSnQ2h3Q6GmCSp7CfJ8XwitsPbmJ7ndIwzbDZsTKTkq3VOeDWwmXL0wxOTXB0mSFc/M5VtaeUt/4kP/r/73OC9dOcPlClZeOTbK2UMYfdol+9DqRaJMrm1iGRxyYXF1cpPVuiuq1WZwu0IhjGs0ASwtyjkc97HJ/7R5JEqHRDKOQdAT5MS1rNC3UqDQzNWNUNPi+n0mWjpJ108qIuAeJNGKkUiYPJppCClzXA7KphNIay8piqzQMpGFgmgamtgjDCJTEMQ2iOM7c3aUkjjIOg2PbSBJcS1IqWkxOuhTcOFM/MwDDJo0gGGjaewGtrk+xaHHqyhR5N8fO4x6333/Mt/7lf8Xv/Iv/nD/985usPr1Js77BoNclCCPiJESliiiMDjxvEFmzZEwkhkN+1NEmux5V4AdNlCMFwHh/6FGRMVb7OpSD/Zs1of7eCckqjon6fUzHyV4YR5c0Jd1cofM//zf0334T9/JzWfBNUrRKR5XcUeLrYSfoZxcCn/zxOr7eSZzgxC53br9Dc9BD5yymz87wwm98irMnL/D2g8fsq4iNtQ3StsdLz/w2yeAH/NE3v4OeMpldepnF6iVKIqBb/yb/6+9/xBe/8dvMVq/w/u0bPN16j1OnUio1kNWQW3eb5Gsp0jHpxhab3ZTwaYBz/NNUvSJ5p4DWMc3OKq995z2m/G1Onw+YXPDQNZuupYgHAa5nEsZDBsIHETA7s8Tli19gYe4UWquRdNhITOwXoMP585ZW2eTAWjaQvokjCjjlSaylKsYxk+BmyP7tPttv30A3HzJ/3KD64qeoncrhaMHuVhche6SFhE2nhH3iAheXz3LxRJW8b9BbCXlyY4u3/vKH7K4+wqRN7fqL1Obm0VqytTnkzdcfce0rl7CEwXt/dZv65i52yaNy6Tznzha4/4bDVvMhqXBxk5RiUGfm+hUSJJM5g65hsddzWVsfcO/e+9y/vcb1K6cwLItywSTnGIDEy9nY+RInZ13wh6SJxPIKTM14GM279L1TLD37LMbUOfo6R7vbw0gHeFLipTGmrUkGfbp7e9R31tlYW+f0guT5qyneYJP2XpsHKxErKxHPzmi+/PIlcueW2drd4enqCu2gz+l5lzNTSzQe36IfRPiRpt0Zsre/jX7jBudeegXp2YwJjAd27v/Ilk76BPUb6MaPkfk4a7GIEklUZNASrDyW9Fr3mT8XUawM6aqQTX9Iw3/En//bP+S9117ju3/2B7z15vcZhj6XLj97IAP5ScWxo4TkfC6HaZiZezMiMxyKU1zTxnUdNIJEKVKlMA0DwzQpFPI4lsFiMc9SMU+kEmqTZfxBiGkYLBQ9fvP0LP/y+TP8k9kqDwY+Zcem4jh4pjFSLMr0+1OliVJ9mMSjSVU25jekIE31yNk46xRahjjoVI+vX2bipg4mBOMDdDzZMAzj4PAc95fGDs/iSHFwoAkuOBBiGGv2q9GBG4cxvdVdigWPvtK4U0WOfeoU137peU4tn+Wt+yt0LM3Wgw0KxiXmq2dRw7f48798Det4kZMnvsFcYQk7XGV95fv8/rdW+Nqv/ydM5q/yre//IdKus3zcolgDs6p5+9YOc8sQCoO6r9htBsTbCa3CZS4unqGUnyRWHRqtPTYebLOc7PLsi4KFk9PEMyVCqVBRiO1KtNDIkkE+n7K/2+PW+0/54L2H5PI5Br0hUZglaGp0QdRIX54jnctDbFd23eTIo0CNkpnxZOegrXTkORcHH8cKSByc/XrERZBSjoaL2dcqPeIokEk0mtLAxMKObUr9ArfX3uf84kWKuSm8xVn0kkfPHpKvF1j99j47b/wQtfUBEyeKzH/hM9RO5LEVbKy2yBf6tB1JqziFd+zcKN6XsRpQfzDkox8/4NaP3mZv/QmW7DL9ypeoVsv4Q83jB00eP6lz6ZVzWFry2h++RdDrUlicpXp6ieXFPA/f8dho3MSwJikMG5RyUDlzEm0YTOYs9oVkZ9/jydNN7t+7w9qjXa5ePI5hWUyUrJEssImbd/CKZU7NukTtDrFyKVRLVAoJRn+dgXuS4y9cR5XP0OwnDP0BhgpxgFyaYHkQNlu097bZ3VynsbfDqXnBi9di2HnK2obP/UchrXrMs3OSL798Cc4ucffWh6zv7aGMkBNTNsdL0/S37tIZJtjFabq+jxh2eT5fYnnpEnfW1kZIw4QwjvDjkCiJkULguE52z5VCperQR2X0WKmRShoi8zqQQmSFqs6mCZ7rUiqWEALCKMIyzAOFtey5MbBME9OwDgqLZOQfMJY9NgWYloVt25iWiWEY2LY9ejIVli15/uoEv/W1BY5PmlhlC2FK0rREOHDYWx9w/9Y6larFc19ZZnq2wMqgQ0v0kPkIv97l5mt/SWvzLradMBz26fcHxHGSTUGSTDJVHNkXh07uHMqWjro1juNgGJk6m3lEnWkcv8b/Jtuuh/OD8V4dT/2SNP25hOS/v+JgJK8kpERozf6tD8hNTx/8osnddwn/4H9HP9pAbu4S33obY3GZeHeN4Ufv0+0Need/+R859vmvZyS9I2PiwyX+mv//h1/jAqbb6/Df/6v/lte+96e0I5/ayRoXXn2By1/6EkMR0V65w+aTLs1eiFE6zfLx41yornBj+12UdDkxfZazU+epeXk6QZMP1u/xcLXLF17+NSyjz527N9jeX6MyLzg1k0PJLh912kxPSyoFk7xlkXfKnD73XzJZWSZQFqAolqcoT5zn9R++Q6s3pJn0wRpQzflMF03M4jSikFKczXF+4RoqHlDwChxfuozjeIAYdXD+EUCKNJBq9FARfGuA+lDjTJp4Zz2cYx4q9Nn/t9+h9eFNGo9fp99dh+Pz5D77IpVFl1Zb0WnEWNpHGxosj2q5xmLRIu4ltB77fPi9H/L+D/6IOx9+h/1wQDlvMbRmOHPlFKVyjl475cmHbVoPP+K5b1yDMGL7jR/S3V7HtXM8e/oSS6dcum6Fh+++RrcbIWObmlvi7EvnMMoej1+/ycT8PMfOzTGzWACl+Oiexft3NilPFCiVXTzbxEGQNyWpbQIGhpvHcyxcobDikKn5MhO9fdLmGsuLZU5cOEH52HHWWimD1h6hyqEiHxUNkLFPPk6oRCGrjR6m0pxbTlnItRDdDVb2drn5UMNwyJWlKscWCuSrHvvDmEdP1mkbLV49doXZhUW68YD1vQ2S0Ccf9Rn88DW6IodXruAVcgcGNv841vjESgnau6y/9SdUlgYYngNyhrgn2N8YsvIwworXyZ2aoDKZpz2Y4N5mn7s7ayjLJhZ1Wq0WgzQmtWFuYYGrV144TKA+oetxtDgo5PIH5NwxdCRnWhiWhWGYCGFgSANjlCQbpsm50yfpDwYMhwE12+ZrJ5ZYHbRAGpiWyX/63HF+bWECtz6gGMAXTi2zIQX/9NoZLk5UOJ7L88Wzc7yzXSeMFVJmHXpjlNyrMW+AjGRsGgLLNDCNsWnZ+DcZT56zr5Uy6zCO1TrGikdj1aSxUs4hHWFUkGgOJAUPO20aRod1ph6iyOU8lk7NY9sClXOZvTTNs7/0VaYunqcbdehvPOTpw306IZQWPsO1U0UWyqs8bD9C2EXOzFzi0sxFHAO2O5t8uLHC5l7Ml175DbTa5sdv/pDE6jE5a7EwYaNEj9vtNieWPMqui2fYxL7F0xWPZy/9Cm/euctUrcTC8hXitMytD+7RGSb0ZIzrDZktRni2QLku7oSLPampP9mjVvBYe7LPxlqDMIjRUmbFQZLCiCA6nsBoPYZ3qQO89jipE0eIlFJmsrZZk1OMzJmOTJ71+I8xHG388sjUaZRDjCFf4wpwrNQihMQyLKrlGicXT/HSuZf47Su/xYtLn6b2qQresznsBQfZ6aB+eJPO7Zv0d99mGO5R++UvMvPl58lPO3Q6mvZ+iid9EimxvSIT5SLTnkncS2jc93nvW3/GjR/9Wx49/YB+4pP3bIbWDFdeOIPrWGyvx6x9tEPc2ubily6h/YiN7/wZ/U6buck5zi8fY3bJpZ+rcPt7f8wwdPASi5mZaZauLGPkHR587waL589x7Pw0lZpFEEjuPRDcuLPB/GKNSsXFFhJPClxLoiwDjYnp5fFsia1iPEMzOZlnst8grq9y9sICy5dOI8pT7HZTBp0WEXkI+qRRHyuJKMQxuSBgvdnD1oLnLygm1S5+d5On23VuPkiIWh0+d3mB2VmbyDTYbvR5srFFx2zz9TOforPdYj/t0o/7GCqiTMBp1SdXPE0cRSQiJZUZ3NCyLLRWGbxw5JVy4G8xRicIfirxHcOOxoXm+OvGxYDt2KRJ5l2gRjyGbO+Pm5rigL8ghSCJQmzHASNTjEvSNPNWSBKWFufI5V0m8gbnJm2uLuSZu1DFzBdBzOLv93hwc43tp7tM1lyKZxeYmp3m9fce8dFum7ofEsoEM5/QH4b0VIooSPwoJPDDkV/IGPI4nmbK0XTDzMzSxoaPjJoUKotdcZzAKI4ppX5i+gYcKMkBP1UcjK4mSmniJAb+/1QrGm9orVFhPLJqNrJRtHWEYZ2ow7l0EuO/+Tqt1bsUP/sqZnUaogTdjZCDECNQqI1t0jd/hHntOnpims73/ph+vYFKkxFRT36s8zB+M598UZBdEjHCjyV4nkOxVuDE6QonL1xkZnoC3dlk9/4DgtCnIyKc2jKX51yO5bd4sPaE1V6E3oDy5Wcw7DyxSuh2Y+7eWGd2Iocrc2zrFjtpRC/ViFQiMXDMFGfWInUEMQKLPJZxHGVPgJA0uyHlvEcx5zE9W+I3/4vf5c//9f/B6tMOURDTLSiKhZjCZIpSKdKKKE+U0ROnyLtlHNc7EtR/VoH2C7ZGGy7tK4Y3AtIBiH5K+DBED/YQ3R0Ytkjr6+zHLqJwnvmvHyP//Bxy2sPXoDoJbuojvIRESgxpIgyJHigePfSZ6X6Xrc0HDAd9ZvM54qKkanfJXzyNMF2ioaC7H9OtD1maSpnMw/aDNkYiqNoGVhSy8qRO7pk8dupTm75GHO7TCto83d6k/XgP5+ISc+cu0GmE7PhtclMOX/ziM5w6HfGv/+IDvvvDj/iaeZFzp6ZxcyZJqphBEFsutpUFRGU66GKRsNfDXHAxOwOazT3K5S5X5jzO/cbn+N5bCzz58C3M7oAoMEiClNgPCUKJHUe8OwzY3s1xfqnAc+cEZ/web62t8NaNIYP+FpcuTPG5Z05ycs7iO29JtjbWaZ6o4tdXmKnkKM9eZG99hfTxKqu+T+OdN+k+ecqZT7/AyS++zCdqtv23QCSmcRutA7rNNrv379N4tMLy81NoJHF/yObDOo2NPrZVoLBcJSjM8NH6YxqdOsNUUzBtor7P1OIcV05bIDXDKEep0Ga3/jpz059FynE4/oRjmpF1aqXKEmVbGuRtm7MT87QGQ2aWj2HmPNb3NgnDgEE05OzxM8zNzFPfWKXWa/PpapFLEyf4Xupzf7tLLkkxuwGGH2PEArMT8C9efIkf721RzCW84BqstPvkTJPY1SRCECs9UixRmDJTdzJGpkRyPFHWmihOxyDP0S8gDigHKs2Ms4RpjLP8Q0grh0hWGH/Mks5xsvrxEfxYXlAKge1YFEsepVIey0o5cf04cyfPknd9hutb7O3sESUpgSsozx7j5UVFQT1lZXeb1V6CuWUz+cKLKDSx0uxud1l7sMNMLYcj8zzSTepK4SYCkUoMJI6Z4Cy4xEITawOtCmgKGOV5ZueXefNhnU7fJlcocP7Z5/k6Jn/xe/8n8aOANNSU3B65YkSp5GJoB9MwCdsBXSyCKCVOFYMgJO4HhHEy4meIg+RNygyXzU9cM0ZQIHHw2kFhIECMWN8fZxVoDq+5FBI1krk8UEPSCvQIPTDih6gjZGVDmuScHOV8medOPMevPP+r2EMPqQWD9/uYww2spI0etGBQpxG7mBPPcvKfHyd3eQGj5hHEkHZTPD1E5FMismLWQJJ0Ux4/GDLf+RZPNu7jpQnzZQeR19S8AblLZ1GpSdiH1m5IOvRZnEyZzMHmnSa2YTFphyTtHmtrTViexVU+k3Mv09rvsdNtsL6xxZn1Fu6JaRYuXqKzMWSvFzE/W+UrX5vm1PkB/89rd/iLb9/in/6HzzNdy2fmeEqTQxDbLqYp0BhoJwdRSDQcYCx4GM0+u9urzNTyvHJpkkvzn+et94/x9M47mJ02Q98gDSMiGZF3JVYY8OYwYL+R5+rxIq9OmGy3Gry7EvHOzWWk2Ofq5XmmX4ab0wZv3Vxnt75FozhNsdhhwpF4JQ+RSwn32mzFIQ4NPleucsPS3BtALNRIjtRBaIWWEp0c4Q7JDCxmSANGSX/CSIhA/GSxoLUmimKUznhAKlUZNE3IzLDMNPFcD9u0SeMUPYoFOgUtDGzbwcnliOLoALpkOzZJHPOv/qf/DtNKefub/x627xO1E3ALKGURdlo8ubVO0PApF13c+TJN6fH+ky22+gGGCVILUJLynMdz5220TNlra4J2nqd38/z4Bzu0O2PDQI3W46mIwjCMkQqTOJD6He+JMIpAZ1PMsQeEPqJSlCp1AKU86mkwVvY6qvr289bfiXOgNaQDn+RH70Mvxpibw7hyBt1PM6yTAdLJ3sGYOyDDiMG9x3iLC0jDQmOCXUGSx9ARhBZ6N4WBDWWLJE6xbAd/bxujWMHJFzAsa5SNH44iD9hPn+Q6CJRZFTg/P8OEUaQ0p5iZLCLTIdsbT4haHfycjfYkxyeqFIyARm+bre6QKHBYml+iVpzFMlyCNKU5hO3dkFq1iiEKDBgwiCXNgWC1J0i1g6Ul09U8ju2iRQWYx7EvkSYw6KWUvTx5J4dlWOTdlOsXLjH8pV/n7Rs3UKpN4A/xbJtybpF8cYa99keZQYfhYVq5I5X82IjmF706ICsQYkW07aN0ShLAYNBGtDawhnWQBn3vLJsyx9mvL1P+1BTWjEssIO6n5I0UJXy0KzBNmzixGQxg6KdMeU95/O6H2EGXmudgOEXw5pGqgUMOO5Ukvqa116Wzt8vVz1xm98M2jtS4dpmCUUQkikGzQTycY8LTFNwC+3bCMPLZ7XWprzY4dXmBQjWHRtJvR9S3A0SScnKhxJdfOsO9lYQff7CFH0RcubiEJSWeLXGEMZqcgGlJepEiUAaDxMLFZq3dY/9Rjzw+x46f4KsvX2b9bIG7H9yls7JKuL9F0G8g/CETWqD9gEaqWVEmprJYnjV58fiA1c1ddjfKoAyOzwsWiwZfvTbNLbXPo/YmM2bElJMDIyO8J7UyfR921zbQm3uUS0WmL52ntDj9CT0jRzhDSmWkW/jrY4kw0XpIq/GUlccfkdMm0i2RJj6bT1vsbYekmOSmHHYdl3pzk2ZrSJhqbFNQdqBQAtuLWa5ZWFZApGJMuYsp3sIfKvKFL6C1+MTD2Ti5Rmcyq6ZpcGFygX927DyhL+nNzRDPTPDZ6zama9IP+jxdf8ynX3iJ5JlrRE8fUGpsM6EEL83nGPQSjNQgiSxcihhaQeQw7xwn71o4so6TtnFNn2uLFZ40B+xFMf0gIdKjpsSIBzE2wTraQT6a3I8hRKM+/wGU6IDAd3Df9eh7jeApB99HH/osjK/HqAc1dk8dt6Qs06CQd5marlKeK7O4XGRhboJuY5V+fZe45xMVcoi8wdnJCYg22fZ32RtG6DjH3PwytfwMQqYMkpR6V7FbT5meKmKKAj1h4UcGO33JztDI4j0GsxNFDCtHossYLFMqnuD0qQUiX3L94mXeefM9nn/eYPnUKT519TkGjR7v37xN4O8j4i4ICKKIVq/HidOTmKZNf5iQKFBSECcp/jA69CAZXcwDbsDYm0CMpzEc7h19mLiNJWnR2STggHtw5BTJzNP4GGp4fJ2PQg/H/zZbUghMmRFXDSnxcCnEObrNDtK3ae3WKQw2sEVAajp0vbNsOQUu/+ZJqtcmESWbJAWChLyRoPFJPYkpHPzIJOhpIj9k0nvK3ddvU5MhpldAejWkU0LqAFd42CkEoWZ/YxehIk5dOs3unTY5R+BZExRlivBD/HabNKgx4WlybpGWZdL2G+w2erS2WiydniI/kUcR0miHbGwOiScdTi3n+dJnznLnScK3f3Cfl54/weJcDdsQeJbAEQYq1aiywolMBr5JgImfWrgVm4fNNo2NfSaKVWbnpvnqK0U2z5f54M2b9FeekjS3GYZdxDCkogA/ZAeJpwxOLQqWJiSuabFZ3+HJoxoq2eXkTMjVmSLV52d5cLvP7Z0nLM/kqJg2fuzj65A0ZzOIbQK/x5x0OOmW6WlFNx4QxyEmEjWCn439CLQaTYyUIiVBjLk+R0PTyGk7KxRGIgejYiKbJkikkT2DpplBI+MowhGZeZ85UkIKtEZ7TgZ/U3pUfEIUxWiV0mi2eOnl06zNFWk0TOLUQNhFwqDD4zt77O4OyBdzyOkiW6ZNfdCh1x0SOhY5K6ZsCwquiePByWmFZQsWAwOZFrh4vMxU1eX3fv8xQSBQSpKmGlAjOGRWKBgjCWml9AHnSY+mdQdx+si0RUqJHk9MRufZGPo4LqzGMexvsv4OxUH2jZMHqyRv3ETsDuDYGYQxg8h76LIED6IgIyRJE6Rj4Ry/QOuNHxA9fJS5LLb76NTBMGdBdBFGGaHnUD2bWKTE7hyeV2f/w7dQuRLT558hPzV3SEDT6gDm8smsnx7XCJG5+l04d5GB0wKzjSUT2q19Gs19kIpAJDiVCtMuBFGHnX6XbmSRix1On32WilvEMiz8oEun36PXk5SsIuCRkiNKTBrNlAcrMf6LOUyRZ8GzsY0qlpjB4ji2cQydClJlUi0UME17dLhJplzJy698Hj/J4ag6tuxgWwnHDnLnAAAgAElEQVSOVWam9gy9TgfbymNbNp5b+Al3vn80EBABwhIYU5JoGJNYoHIKGVsoo0zsVmilS6iyS/FzVZzJbOIlfIXsJ5hWSkKKcnPEqYNODWSsIBri9G+wtbXNUt7EKlTpyiniMIf0YlxlYCmII82g0yNs7zF34kW6ewlJu06OIjmrSJREGL0maSegkHQoexrHdgiERSdIaO76XBQgpaYynUfbDqvbbW7d2yHvmrxycYmuMWTr8QofrbQpV2ucnC8RIvBMQc41EUJjWuD4KQE2bk9g2Cb9VDNo+OztdImHa7z8yjGevXgF1yuzVy3TXM3R3LGJNleQSUxBJMhuSEv5PIkkjg1L0zlqUnJrr0Jrq8XTgYlYynN6IcE4M8Wte208N4dWKaozoKJT7MkpNnb6BO0+QTqk8fgpe7fuUFqYOkzI/xad/L/TOgI90VGCGgSoYYwxWUDYkiO5y0H8HL81KR2UGhIE+3QHXYrFHMIwaWz2WdsYEiUOXtWlWzC4V+/SD1pYwsawFK6ZUrJSZmsCKQeUHJAipOwpLKuNYawQhZpc/vOjn/fJTkTH/bksQdY40uCLy2f5fG0eK3R46k7TLy4ze3aZ8qkaQ+3zb/7NH3LxxHMIV7PtFei8+wGl7cecm3bpLswyFVoQe0jDBTnM4r1a5HitQBCUSLpr5N0e15crlDzJW7td4jRzQ0aYmKZkGCYoBELpAwfQsZ7++D6JEU9BH7als99lpHR0gGfWP5V2MH5AxkZEY3nUA3W2cSGJyKYrI8iLbUvOXz5HsRLjyoS94YAgDMHQRIYmV5xgSg7YG+yzH0REkU1ZFDl96jkKtochFcNBnU4vYNCzSHOjeK9zRJFkYztmZUsRXshhygLLORvbmMRUU8AxHPsEiwtz+IHGRbOxto5lWFiGxeLSMq9+7ku0+hZ+/V2iJCIIFfEgZm21i2t6NBtD/CCl0xkSx0e7sFkRlnUuD02Xxr4PY3z0wRU8cjnHMIjxlU1VimAUZwVofTjBOaSKHBLhlZRIpY9gsTmYGB29ZRpNGIVs7K1z6/FNjjkncKQkskNSbRNKl6FVo2kvkkznKH1xAseTJFog/AQ5TLCshNRLkU6RMLIgkYg4QYQdrM47rG7ucXU+z9CpMqSGil1k3sJNDQwFvVDTa+wj05CphZP092OS1i5lZ5pQdjEjH9lro7s+hbRLJSfYtTyCoaTdj+k2AhwJhtBMLBSJDYuHW/s0Ol2eOzfL5y4vsceARw/uUVvpYDs55idzRKN4n3ctEArLT3ClJBA2g77ArBjUo4SNzR7r+/vEQ8W1F+aZufwMGDmapRz7Gx693XV0cwcjSSmKFNkK2IokRgKnT0qOTblMWX3ivUm2Hm0jhyVOLhe4Mq/Ih1O8e7NBvlTBjMEZJhRdh7RcZqepCNOQJAmZzXnsuzlWI5cwClBRmpkJCj26v5oUhYFBojVpmiB0NjHKTAuPTPuMTKr0ADKjwLKtEXY/40ilKsPyu5ZLEgcsFqpMuEXQ0AqH7Kc+2jPoD/pIKTN4ERD4XaSEd965wbXreVJCUlOgXRMtDHY36jx80kCaecxKnq5j8bDRJ0wHmFh4OYOyDJkuaCYrBpaVUnYSDCOmOpHDsmyWZvJ4jsO/+4MnmUdHMibmZ7/iUQ+YLMYdUQkbbbIDXtSRKYE4UiRkalCHMXBMSP7bCID87YqD8UbWiuT12xjtEDEYwN0tkvZT5LVlxJUSsiQZrGtUrHFrgtyCg/viVxl8//tED1awhx20n8J+iDCWUXIPZc8gyydQoUO402IYVEAIVn/0J0QqRhr/EYaXw7Bd/EEHL1/C8fIH7+snosjf8/pZurOQJd85L88Lz7zE2uAmvbhEs7dDa9Ah0Apymm7gM7d0gTjcpRm2aSUgI4cZs8pi5SqO5SGlIAnbBK0V0r5BtZonSg208Eix6DYjNm7EtL6RY7Ywy4KR4MslPGORAgvotAiei+OUkKadjXH1oXFI1TH58meepZAzMGVKp73Nk5VbuLbL3PR1FubO4drekev5j6QoGC0hBEbJoPRKhWTYwXYFxYKL7laJOgmRMBmmOU6/4lGsZmoqOlaYUYoIY0Ijwai5CFWgO4A4SKjkEoTe5pvffQMzDXCNMqYzh+A4re37TF9apFxxUFIQRSlp6CODLnEHLrwwyTf/629jUyXnFkjiFl6/zXDHJ95cZaZmsr1n0mlrhrGi19YoTEQicRybM8fzlIqw+UadN1Z6/PKZIldPhFTLS7R2Aj64s83MVA5fm9iWxPRMXFOghETpGMc1qVjQDuBSIeFYJWHtqc+H7/yYbwOXl2pcv7JEMOWydXqW1bV1Hn67ixi0EGlKIRhiKYjQ3EGBMphZqvKyDZvNhKdRnptbE4RRk1Mzi7jCw98P2W38f+S9Z4xsSXqm90TEcXnSZ6Upe6vq+vZ3etrN9DhyrGaWZjmzNKBIaUFJkAgQghwkQQbCAvoluytQEiWCWoiQCAHCUuSQyyVHM8NxPTPtb/fcvt6Ud5mVPs/JYyL0IzPrVjeHRJOaFZfa+FH3VlVWVZ44J76I73vf730HjIOQFdcn65YJj2MycsK7PL69xe43X+LcZz6GUKe5Rf8UnrXT69WAiRPSoz7RnUPi5oDs5x5H2TNe84zg/N4fS9BRE1slFObqWPYW43GPG2/t0kzyZCslRjnBTrPJnXt7LNaLlOY0nhmTkyEFK8YSCX4mIeMotE5wbYXtpGihmYRiw193YgBgWxZJmk4NqSRF2+Gnzj+J1xoigz4XxBpRc47QVzhrLqYi+OInfxlNxOFwk9gvs7/6PNbGPRrNlJ++cgmxF6H2LIQqoGUbbTVIsmdYK9Vpdcs0I4mSD1jOOdSKJbbCkHGSEjmSjGfj+w4bBwPGUXrCsZ01wgpmMHv6rgNqOjMI0pxssCffSye78GkO/KyoNqNPnqAQ4lTD8/QPKCVJtaHfG9Lcb7K2NE/qwN7RXbrBgEhCnDG0gwFnzjxFr32NJinDxMZPsiz4NZZKT2KryRY8HuwQtPfRA0mpnmGsJZgssZAcPRix4/t0X8xS9ec5o2L6rOGrJcI0x2hsyPoWQlp87fe/QWO+wZtX36TX7/NLv/RLeCbi8kqFl3dTgl5EGmlQmihMeOvNfd56c2NSfdaGJE6ZdmUTR/EEPRLmhNoA0yf0PYWi2TzqEzrQw+Ryxh2fpF+zvoUZYjCb9FNmZ6eoQwYm5lhTBOGhEosh1QlJmtAb9nj53it0Bj1+9RO/hpvx8Qo+MjhLFCuOU4tdX7D+hRx+RiIlqDDFBAmMIyIrwZpzQefoHcd4aCp+QDDY4it//C2yFngij/bP0x0IwuERtYUliiWXxEAUpTAewHCIjCWXni7x+7/2B5SLZzj2fCydYHV7jPaGxHv3WVr02ToKCDCMwpRhD7SxIJFkCi5XHs2SMOKNeyNe3RzwqXNZnrkQ8qBwmZ3dLpkHLQoFF6UVji2xsxYZJUjNGITG8yQFldKL4dmzPuuFKjffvsXGzdu0w2d4fKXMjz9zkWbNZvtglQfX32Hn5W/DsItIE/KjIcoIjrcN78Qp0bqmVFvk027C7cOUu8MSV7cFF0Y9zi+fIytzDLb7bI365JBUM3mEyZP22hQsnyCKKSSaBc+i4VSJopjuuIujLJAQxuMTDw3HcbCUIAwnzchKSoSSJ/TCWXI5kTp9aKpoOza2bU+KbEHAaDTCUopqoUIup/ho7QIvLD3OUTTiyxuvEcctxjpmNApwPYdSuYwQgvEoRNqCOA4Y928T9Fto22DXJOOgy4039zgyPvVGmQOlODjssLPfYq5kUWkIsjqhZMcUvJSMDX7GkPMgSQ2+IxG2YRjHBONo2v9gSOKpW/sUvZQnfjEP0brZhZ+sAzHp0xGnGo1ntKHTqCnTZP5k/c7i2/sY7z85OEkMJv+6pXOQ8zHtPQgiOLhF+lIf3bmI96UqxRVB/0AzbKe4FbBtSaW6QrR7kyjSuJk6TvYstI4x9hKp3oY5QVquMThK2TnYZ2d3j5VlSb2QcP87/zvt3gGlsx/ga//nf8m//O//FqfNdiYB7b0b6z/tUuS7x6yJxnUzFMcFjrpHbB7usX1wQK8ToEo2tr9IPg7ojQ7pHg5IBw4Vv8azVz6FXyighUSRMI6P6IQbJKlDzhN0x2NSbOxiAVXME3SG7OyOWLj0FA3H4366xtjMYWQWx82R4mFJRaoTpJgsrjhJcGyF77jYZTVpzJGCbKbEwvxlUp0w31g76TH46z6k/JXGKfRZOFD+VIHRcQyDFGMc0m7CaCviw5/LMUgMeXcC4emBxukmyLxgmEgKdoXOMCHjpmRtg4xGHO6/wkvX+3xqwWecf4K0eBkvlIRJm5APkPoaSGEwhl4XlQ7JehZWqHikeI4fXH8bk61TX3gMX/UY73UIezalgiSbTfBshUgEdw4PeaEbUy5lOOwZAiul1Mjziz/+GH/62j5f3jjikysuj5UL3BxG3Nk84lsvW3zqyjral9gSHFsS2Iqh1ix4EXrZ4atv5vjIQg7XsTka9Ll0ucG9q6/z5tY8dzYucunxCqtnGyyunUV5R9z+vW9h93uMxJilJCbfC9lMcnTyBfz2HaLzj7E8l6XRPeR++wbXDldAnGOtYPGDzgGliqBecBGtIa1+yuVLj3E3lHSDI5xwjDcskg4jVH5StTkRHXhv2f59jndXMf8ssjf9Asl+m+Rr94kfDDALZYRlM9O610k6ga7VKTI6EI9v0N+5Cd2AesXHLqdsHR1yHLjkLy7i+B47W0e8+eYOZz5d40JHoVRIJScp+5J8JsLNaCxHoWyDpSykNCASBHky+X8dIf7ZWHeVuSq9fo9oGGLriQmgnb+ANQ4Q3W0I+8jWA6ywziiUtD4bM3+hzuYbAXPlRS5fuUjSHbL11rfRwz2sA7DVKiJvQTQEZ5E4fcAob1C1dYbdPluH+7QOW6zkLBZrNl/60AL/+AdHaGWxvpTn+zeb5PIuVpAwGo5J0Oipi+qkki9QyiKdIgTpVNXkvZTPk8rb6QueHjjkFDORSjBTDxRMnZqFIJnufVJMzMHSVBInmtFgzIObN6CSYbd3SPN4yDjRmJyLdnLkxj0CPWawHZCEHpXqMk+tfZxssUCMwGFMP9qkE+wTRhrPEbSDECNd7FoJ7mfo91L29hNqZ5+iYdnsBeewTY58xsf3PIIIxv2AZ59/htdefY0XPvQijzzyCM3mEb/+3/0623t77GzfYzTokaYxliXwXEnruE8cTaqWWk8QljSd6L8/TAjShzF1WsU1RiPFVC1lyns+aUWYLRutMdPq/glf3Ez13E8aLUEzkSM9mfCTbdtgzLRhNZ0kCEpK5LQhPtWaKImZqMMPudu8x//wjf+es6XLrFYXCcIQW9bpmIQ7vet8bO3fIacgig3iOMKNEqwcBKmkZFVpDmKKWYNtNEn/iP3dN3j1TsQXzuQ4rjyPn11GBduE6YhQVtHZFEwKnT4Mu9gmxbdt7NDmifJFXrv1OtnlD5Avubg6ZbzfI+i7VCsWGW+MZ1uMopj7zRZP9GOqcz47bU3kpTz+yDxnKgVeudHiDzaO+MKaS7FR4PvNQ27u9AB48ZEl0qzAkQLXFbQCi4iIOS8iLfr8k9ctfu5CjlFiqK6UEdGQ3Ruv8er9Bje3HuO555a59Og69fkqV/NDHvzJ9zG9LkMVcDGKGLVd+mmetnLJNDfYOuPyWL3GQucH3NpNeXtvieTyGmslzXeOEs7OWxQGI+JWQDvSrJSX2QvWaIb7VI3m/JzLqDhkZ+doUuHXCVk/h+NniOOYKAqxHYckkUhhIE2nBogptmQqejpBj2aiAamBTMbHdhx8P4NONeVSmflag0Qn1BpVfvbCC7yYnsMyWcbuHo1H1yjIBTZuPcDSkkhENBp1XMdl0O5QqRX4V/+VDxNt/Anu4IBMwyWzlmHjcJuDnsXc0+soy+POW/fYD7qsP7/AuVaAo2LqJcFcQZDzBY4nsCyJ7Wgy0sGyJgntO9f6/MZvbNLpRsTxxN9FWerEYDFJE2zbOZFyPS0lPEMPJk3c6YmbtJwW2IQRJ+txRqmcrFtxklwrKdHvKsj98PH+koNpxoGYNHglcYz9009g/nAJE29hWgHYPiI6RGzfgN4zmIKHXxXYI2jfDyivOcx96ZcwX//fsJVBhFlMO4ZcjFh6HhNfQcuYwegO7e594sPvIAYt9g59nvjJJa59Y58//Ie/AUpwZnUBo0eAzURB+5+9cf94E2OHtHeO6R51sXIO0SBD9bxNo3+DnYOYJFaU/CLrlTVKK0/j2RrXskh1zOGxYmevwPp8DduWDIYdYkoUs3PUq3WC7j43vtPh2XMuwn2ec3YZYya9HEo6041uxuFLUNLCzWROZOBcx3n4ZsWpjJUZ5/nPVob+Rg0xyZCVL8g6DiY2GAG+FDQ+CCmQiyZVLJUYJCnaScGDmlcgHIKvUoSYzOFxP+Z7X95ivVimWP0g9pkP0BkldLZuUhp1qdXyZB2JLQ2dXovgsIk4SlDbKWpJogceldRBHG0jo5DSucscv7zNwF1gqA7JBvvUvADjrVBbWCHdvkWmXqbu2CSpSzy2GfgOjz8rib6zxV1jkxZGWHNF1kt5Xr16H0nMp184Ty7noGwo+Aop4Ae7MavjlJ9/yuelVzaxXYtnnn4B88xzjDJ/wO3vXqW3uUl79Ah3HjRYW5J87sV/iSsrq3zzt/8Rx1uHXB+F1OyYD9sxN+5arL1wkcNrt+i5dSqlHJcX85zv7/LWtmSTYx5tFBl3enSbMSJp0JjzEdd/wHqQUFB1Wukim5s1ir+9w+ovLuEW3ffcwB9hBf1UjUCHKWZTwl4feXiAthPSIEYIC6kkg0FIajS2q/AcC8tyOLjxfWRug2CoiHWKldnBmcvReStGzq8y6sccbx9j4j4ffzpPpTei7oaYOZ+81yfnp7gZB9DYjotIh5CEoCQGhQZkJvuju97/l6NSKKGThCgVZLQN2ubv/env8J9//j/BC+cgcZCWQekOfjdmnK7T6w9YfCJH2E3pbI4oL7s0n/sMZ9rfwllZRRxmYDCEkgWND6KHj+MXh7Ti+ww6ryB6b2JLw0Ebnv+7Vb7yP23g2w6e72CQrJ4p0R4eE40jLDUpBsUpaARqeqCUYtrgN00MZij8D8V5xZ//qdZMXJWZcPDlVMFollZM2POzZr+J50PgJKxUC1x97SqRFRNZFuOBYXEtw8rgBre2I5TwWKgscWHxCcpLT+JZBk8poiTg/pbNsJdjqRxj24L+sE3i5qmX6vTLFUa9kDvfb/PUagasD/PBQpE4FQyHY6I4pZovEKiQaqXE4nyd3/yff4s/+oPf5+KlS3zzT79Ou9MmihOMThBy5jJsiONkOmczGUkzNYiazcu0GZmZypOYSEOZmUPtQ/M5jH4oyXuyn3AqY5gYmAn9UBJWSAVJzKxJWTBDaaY8cjkxuUqnEpQzudvZPU2SFGEitE4I44DWsMlmYYP5owaDNGIQjkikYOn8WcpZiyQFEcboOASpcbIuNSdLMNRkpUG5mlhr9naHvPmVPdaKJQr1j5Bbu8LB3T2i/QeUVUi1mse3BLbQDFv7xM0eXuqi9lLUnER3MzSMQ3vzGn68Sk7N035tn5HTYGjtUkk3MFmHcm2RSrmC3rmDV6+w6CiSwGbkOug5m0efUiQv73LNOMSlPguX1jg46vHK1hFpEvDpFy4gfYmyBPNFiyOpuXkUMy8DfuW5Ir//R9c5d7HKsy+eoflIk69/5atsvv467TsbtIfPsrToc2k1x+c/+cscXDjP137z/6C72+TlNOTRbMQjQcLWNqx98Bytm1vcL1nUqh7P5SOG/V3eujVCZUd8ZL5Bc2OPYTeLiQuUrIByc5NCckzZPU/L1MlEy3xhvsGP/Rdf4L/9H/8rNjc3sWxreqhPaLUTJkbqikRIjFKgU6ROUA4k6XQdWhaua6OEQmhJqV5jaXmRbreLMgpbKqQwWK7Dv/Vv/ts82l7G+cYrpKNjHr28yNInnsMr+/y7/95/wCPL5/mxz3+cpeU6d25cp7W3yb/2pY/Qb7/J4WaHymqW/HIJyy/Svt4mrDaI9w8JmwPmC/DImSxzoyH1copp5Cg6x+TzEsu2EBIsS0LSBTPGpJo0lRzu9XnraoswnPh5WJYFCJQ1fa61IY6j6Tp8GL2M0SDUSaHDsqyTM5s+1Yisp6pGQohJ38YMPZjK0b/fottfQsr0EmmiGTRH3P/+O9TW64h+D2IbrAJkMhiVkgbbRL0ssppB5CWp1oyHGssWjHe+QShclBFYkcHEgjTeJbl0hbbok/lAlZG+wf6dr7F9f4vNYcBP/uIS+wdj3ny7xdZBH2nBM08tsXLJwfEunAo+/AVVtx/tpvtD53b6tdSkjKIOYdznxsYddvYOCKIIHInKKuaUYXTQ56gPUeRTKlziwuM/Qb6So2xJHKUIkoQbP7jFje++RT2b5fmPvsDL17sMirVJA9Ywor3ZYuNBk0+9WMf15pAyjxCZSWIg1LSBeBKllbJR0mbWsDODzWdwOad4tbM5FCff/xsgXfreId7NFZ49FmJabYgiQzIExxPIFHQwqWZZeQvhWIzGAmHAcwW2axgMDrl/7VV2r22x7Pnkn75CcalK3N2ht/MOylF4Vz7OYiNHEkQMezHpwRBvo4M4NKx8eJXxWx7dnk+aWJhU0A0znLUluUaX0MsjR118PcLNWrRreR4755EpFxlpmySwkGOF44GXkQRentu7Y85kNOWMIhAelu1zsLtPELosVD18b8LnNEKTEZqwG5IvuQhtyAoHK7YJJcytrZDzJctzc7gSkvEIE8fkfQWiyOoH1kmDLuNgxHCccjiMqIwjZKhpzEusQko3iDjaTygVJcvekECuMAwcMCMysocTDCkgaR9HeAOLoh6TYYCJu4yPm9RffJRUTmXqhMDokLi/TTrYQdo5mEkZn77BnA6akCQJ4XDAsHOM7U/ohifpxamwYLTBHBvSO0ckB1vEyS6BKCPPVQmTlChKkErgOBZKGI4efB9H3kcHGwStLXACnFqJXq/Bqzc3yFU8esd7xGkLLzOi7GnmxJjKgqSaC8h5CbbrgJUhFQ5aZpA6RCp7EuhFESMv47gfZiYJ+dcxTkuZ2paNlILl+jpPrnyQc2qeu82r/K3PfhJHVhB+AeM5pCLGjPdgWKWTG2HnHbQWJJFByQi7923u39yllPOxjY9Ox6SiR3L+MfYHhxQ+sUxr/yvs332F3f0WbZHw+Z+v8+BeyKtvdzgexJRLFleerPGRzzzOd1/aoJDzMUCcauJ0codtR5GkhjiZmaPNrmqGHnES705nCuLUh1m8kxKS2eH4PfDCidnQNK5kfJfGUoVHnlwjUxDcb+1zcNgmEYAj8DxB3XYY7vfY7ytMlGNp+SOsXHiRbDFDyRLYStKLxnzvq99j/8Z9Sp7D2sV1rt6NCRZWUGlAsN/laKtF+3jIx56t4WZqSFVmOIgwWpL1c+QyOTzPw7Yt/pv/+u/z/e+9zPb2Drdu3aLb6RCE4dRHYKLxPtFZjxFCkiQPs2czpWC964AhJtrpM+nhh07VD19zYq40IwfNKpxTJHAmaCGFfNczLsSE/nVCLTqhD02/P6Mkneztp+6DAUtNDmEnYIVJsD2HJDEkjPEzRc6tXuaTH/0oTz1zCR0lBO0IlZFYWZtUSoYhJGFCzlccd/c52L3F7s3rtG8fsJLNkX3hWSqNEu0HVwk7O1jFIt6jz7LQyBH1Q/rdGLHZwd0LUAPJ/JUlxm9maA0yKA1h4pBEDmdsyNW6DJwyVveAnIqh6BLWfc6vuviVEv3ExgwslJE4rsDxLMJMgWsbAVcqGmPZxMIDLA72jhgMbM6tZLHUNFnVCSIaEw7GlKo+yTgirz2EthCZDI2zK+SyivV6HXSMHoconeI5FkKWOPv8eQb7m4yjmG6Q0BtGFMcxMjasrLvobMJRMyYYGkp5wZlcxFCu0+uBa3XJmCFZk1K0PY4PY4pplrIeYukBIuniuJozn7jC4x98kjvXbtEf9fn4hy7zi1/8GJ/++FOMgj6dXhcQ5At5XHviq+K4DhnfIpPzQErKvsd6o8IHH7vIJz7/k2SyOTBwsL9Ht9shSWMy2Sw/86UvUtJleGeXdPgArUJUroF7cZ7a8goIm/MXz7Czs0nveJdf+NvPc/G8Iu+MEWFA4UyDyC5xf0Nzv6Up1lzCXodMTlDKC+aclIoVU1mwqOX6+J5BOg5aKhIUiVCoNEAoG4QkGFtceyfkq19rEiegrIlimO04OI6DbVknfgyz9SHlVJJZqmmfxsP1YAwnTcozSdiZadpJn4GYONWf7p1KdUoU/4ikTA0QBwnNjS52McMPvvE9zns1vPUsom5h+inmyMN0MhAHhM0Oxs0jMi65qkV/PyTtTy8qX8DoAN1vwlqNeMHFrVcIdZvueIfjtElrHHJ5TpB6LhtXd+i3+pjxGFmQzFXGSNHF6BAj/cmB9yTgnKYS/dPaaN99OHkoGTWtVgubnFOl14sYDEJ0kuIaCzkYsrJU4vpQ0etanDnzGJfPPct8LoevBI41aSRp9oZ0OyPsSJO3FM5cneT2NsVhn4yTJSg3yFdyjAPF7327zc985g7ZXBmhcu+56hQlbaRQU07nD89q/qad/d/XOHVNExh78n9jwBECY08/kQYcM0HONUhH4VkgHUgH0cT9thcR3+/h5IvUyg7lJy/SOzYcH4eMRpJS/VHm6jmUFCSxRoQ9MjrEc3zc44jhV0PmnsuzO16hffuYUf8uInmA468w1lVc6TBKYBSn+J5F9eJZXv72HT7yhQaFgk9XCwa9GKcL3pzL5WWXw3bKKBkRdYZYXsjl1SIv9Qo0R3vst3wcO0c2J3EtSda3OLq3RVg+Q2XOo324T3P3KjlpWLzyMdz1NQb7h8zVFGGsSfs9WkicilsAACAASURBVJvvUFxaJe9XufChF8nmsmy/fY32Xod2GqMOm4RuzMoFQ8WTtIYWD44lizmXmhMQxn3GZgwyS87VHN8NKHgfo5+8St608MSInBkRDgytV/eof3IRpdwJUpPEpDqaSigGmPAAaZcRMosQ1rTZMUHrGMtyQUh0mhD2OzTvvoFf+wKgppjiZK0ao0niBJCYBYXOHhKzQ6yyqGqOFMMoTAiHEZ4rsWRCqnuMhzv4FZdEF1BzCcZyGIQZXn/jFgV/SHJssKMeC6WAeg0KeZucTMlWi9iqB2hSYRMZlzESZzwglmWMciB10bqBsNaZsblPotgPoUj9f4UsDPt9ZC5PJVdjobbG1sEbnHUaBGmPzPkCVqzQfYVpOui+iwgHuGMPnUrcgoPraILmAEuVKawuoxqLmHaIMSnamyOoW2QrC/T7m3STHZpJh4gx5+YsIsfm/q0m8SDExCme69KoQ62aYXmlwuaDY9J00ltgWxJLGtITA9HTicHD6TqJ1rNm2lksYBq7zdQnYVqRM2Y2/w9fq6eqKJiJcdKJlGI45rjVxt6BgQ/DUUhWWXgxFCyL5azDtb5Fr+Pw1BMvcKZ+jqJlkZFMONfAxkGLwfEAd5xSzniUVtZ58JU7XHn8LLbM4ReKZMo5jvWY/+UfX+ff+Lkqtpwn4+VA2FjKmbxPk/Af/0f/Ka+88grtdmfiEptq4igijuPZLDzkMYupoVyankgjzl4jpq+b0OvkCWpyIjF68rs0sxb2h9gKp+hbE4xFCEE67UF4OOcGMUsMmPKmpz/7MAEwSKHQnPK50BpOaEmaJJ38TiUtBHDcbTG0Rkgl8DMjdCvhB3cVv8BPgBL0R23yIoe0HMZJxKATUCzniYchWS9DpxmR7Iyw/Cy15SLlJy/TvNejczwiSUsUCxep1HIoAVGskUGbvAILB2t/TPCNkNqPFbk3WKe/vUHYv4XSFo6/QGQqeNKhG2mMTimX8xQbi7z6nS0+9pMLzJUd9kNNGqQ4QmIXbS6tuGwdRDRHAXHUoZDzyC+6vNrL8Mb9t3j8/EdYXvCwHUHGtSnkbHZ2N4iGWRaW8xzcv0V6eISfyVI7f4XMuXMM9g8pzXuMhwEi7NDePSLfWKKYr/P4pz9D7nsvsX/7Af3jAU4SIfaPiDIp55+QSM9iEDhsdRR116bhDBhEh0RK4jkFrIFmsCMplz5Nu/89KmmTnBhgogHRgaD/2iWWPrGAthVLyw0a83O4Gc2gd8TSgsOVKy/wxg+abGy1aTYH+EpQrzhks4LOSDDojShKyUrR4emLVebOn2UYjmk2m/jZLLlshpXlRX76i1+iPDdHqiTGuU9sDjHZIvZSBek6rJ87T84pYvSIxfkK55Zcan6ffNkniRTZdUNs5ejuBBwc7FLOh8jemLxIWa2lVCqKfEbg25JspYAjJ9K/kXCIsYhNih32GGmJkykT9kccNVNa7QTXmTRB+9kytmXjuhZpqhmNQjApxqQIoSZrRMz6DCYeDUkyoxtptJ4kEZa0ph4QvGubmKkWMY11M6+H91PwfV/JQTQe091vMWr2cRUUlmp8/Tvfw8l1WDp7Dn+5Cm0DsQJZxbiatNOCAlg5F2FP5LZibWPpPjrnkWqIszGJV0E0POIwYZTepxO16JqE1NKcWXM4CGL2OyOiOEZKjURgiTxSVE8C3Yyq/K7xV+Qtv9/x502uEALHypD35uh1A0aDECESSCx8W6KMYBi4uHaZlflzrM2v4guDrzVKKgwwPOqi+xGVbJn5RpUUJg2Mww5aWvj5PNWVRVq7+zzYi7l5a4MLF1bI5QvTKitY0sYITqEI/xwPcep+GVA2IAxpOPlXCoMRU16CEtjKgJpyl0cx8SAmlg4q38BfXyRTnaP9YIvkuIuFoFRfZWnewySa4/0OVpSQ8zxiy8MaGPpvjij/RJnG2QIiKNPcdumP92nrOvmz8+RElmBTMxiPmFN5zi2UeOMNiPeauIUsbtZhFMSkvZg0l6FYs1hfy7O9JwiCETmT4lmGteUyrc09bh0MUZbFinDxchbSsRCORzo2WEWLsZ3QMwHV7Bz7d3bptg3FXBFfhcRhyNgokkgTBi0yxscvL7B8OcQ1Y66NrtPvD7EHA8JdQ84T1BZtSsUMB/t9xm4Wzx1i6S4miUkjyWDg4ioX3TGIpISQAa4cgEgZjzq0Xn6V+oufIwIsz5pUQaQiTY5gHCBEhBEhRvukqYshw8HWHUrz8xQKcwgJw94RhzsPyOUKE4749NZrnUyaa40mTUEJQdA+IoyOGLkpcalCbbWMFNCOIpwpaSSOE0iGOK4DjouJMkinQb8XsrVxxLj9gHIxxHE19To05iwqFYHnu7i2j3KzCBTaSBIctLGxZYplEqS9QF+7yLQISQ2SIrn8JI6Nk8FJBQgjsJWPAJSymLBupw/0qYf7R43s5ZTDk6uXeP6pJ6kW53n97Q6rdpHDew/wnq/gZzxkRkJioymRWCH2IMJKyyjXRzNpyh8E4JeyiLJHEvVJUkOaL0LdIRwGpNEWHT2kT4LKaBaWLPaDhP32CEOKEBqTJkTDkNZRD9ez0Do9kRqFiRypNubknkvx8Hg7K9YwpanMwIDTsQA4SQiAdyns/HmzetIQqDX9fsDG3QOGyZjMeploFJNxBY4HOWUhNPQGDr7XYH35Eo1iBU+neKk+ee9bb9+FfkIlV6RULJIawTgKSQ+2UZ4mXykxbFTptY64fr/DO9dvcmZtGctZRakCzcMjvvvdVxgOe/zJn3yFMAxPKogT59lJ5cO85xok4lQyNUuiH87LbD6MMTP18JM+jpP5mvAg4BTq9d4y1Onn8+HPzfoZzMn3H94Xg5khDzPUBzlNzh76T0z+8lRelalWPoJxNCZOE6SSJCQk7TGZDdjf22V+YR7HthCKSay3bDJegucq4kGMNYbOXo/DoxGiMI+3uoZTLhAdbKL7fVynRKW+xELdRSeao60WWSmQroeQBtnT9N8OqPyMx9KFEnZcoXW0jTZtuqJG7twieZ2l80aIlwasZCQLlTy33tHEO0fMPVbAyQmC4zFJP8XyXUoVm3PnCmxtg5UOKZoU13NZXSrxztV9ru0NcFxBreKgHIntuSjPJwlS3KJLXwRYliGvHA7uHTDsG+rlElkxIhIQSYHWCeNRi4QsucYq557qokzK5vUH9IcBajBgvAXVkkVuzkM7im47JJybo+QNsHUXoQVJYJOOXTw7AwOFpIa0BmTFGK1jut0mwzfeYv6zn+HjH/04N+9cRUuLMBmTyQ557LECSys1ciWfhds+d243abf6nF3wMaUMq/YKSmrSg13y6Yhhv4PqtCaIXxLz5JUnWJyfZ3FxgceeeIpUa4ZH+2jdYpR1sBaq5FcrCMcm9TIsLNWIogG+WyDnDLFiJoiSCbD9c+xvd+g0j7CjHn48RuYUc3XJmQVBvujgeA6O7WA5OQSS1Fik6WTdWERIY5PKClu9mNGR4Ogg5rgT4zgK2/X4wk9/jmzGJ0oitja3uHf7PpYy+BmPj378EySxJl8o4Ps+YTjmrbfe4vbtO0Tj8cSIEU4MA2dUxxk6IN6z9k7WvXjY8/MXjfeVHLS2drjz2jWCzoiVi0t4uGjP5d71O7j5HEvVMqKoEEMH6ZRIVIQOeqjAQ6RzpJbAKti0d2J8o9G+RWo7hG2LYSqp1VzCoybBcI9e0GWcCvyiwl52uX/Uo5ekaFfiGoVr2wx7WXTiMBoc4HjzCEcx6z04XTn66yiICwS28vCsHJ3jHqNegOsISCXFap5OVzMeeyzPn2G5tkAl45MOY5wkRWCTpppg5xDZG1ObazC30CAYhmBNKtLCccj6HktrawzbXdyMzbW7PeqNEdlczISFa6aGSn8lG4v/X48ZOm0MSAsmybYBJSZylhKEMphYg4bR0ZDucUhcqZCzMqiVS1jSRreOUP0uhaxD/XydWtliZ3vMqDekaFm4XhatOmBSgtYQv5Vn/rxNXi7gW5e514W9bJ78UyvkBiHqNY3WY2wRs5DT3C3maN3epLrSIFvKoAuGYDAmakakVZv1pQzdFLrHFkJH9Poxjy74fH0rz92jARllkXMs6r6FkJJsbQkzCggymsTOYVVXSSvL7HznVUamhFj2ySd9rDRE+hmsssNR85AwNmhHkK/Pk3Ul/V7E1tu30MGQfnfExl2NwGH5XJaiTJBRyFCLic9CFKL7Me1OjsuVRbbvXCenFlAiQRpFRgdkohHdd14l2P4wadHBqWSwPU0SB5hwgzRRWF4OYbpEoSQMs6Rmnltvf49HSp/Az+WRIiEImgx6Lc49+1EUKdqM0TikWpOkCQaBFopBv0f/2jv0O22iSgnv0gXs+oSq0o8T6u5EJztJU0Si8YtljBUiLEE4tDjY6bN37y51p4eVCuoNyULdI5/3sB0Qlo1QGcJRQkiOoXGQwiajDL4cIVSVXpSlEyocU8amirJyGJMQpWPCtINATQ444xiPLLbrkc0WQWgmcpCna7QP5SR/VEnC2bkGz557igtnzpCoMcWqR39gcf+du+QurKBWs3hlBxG5aFkgMUPS42PsoI4xebQlMK7huN0hW3EwJZcoUAShIFGKYt2l96CHTPfpBWOMBL+skPMWe60h/TRBZCYyjSZKae2NiPItCj5kfInqTST+kkRjK4mSU31+8ZAeNIHbJzuknFW83xUIHlb/H6oRGWYy4jPd8xk9ETGRUJycgyeJR5IahoOQcRQTkrJYzhCPUhJPo4oWrudx1AoIQpdL6+ssFMtkpERGMVacAA6Dfp/Dt2/jRILSXAOv4NNud/ELLmFrB7teolDME1TniAZ9PF/z8lv7HPe+h1J7CFFic2OP3/rN3+a4fcxwODpBPmYGSSeKJSfPyezZmZz1pTzVt2dmztCTU3mq05N5kz+EtvvwPG/e/fyd0K8mf+vdKiqnehpmcw8n9wCYyFieRhB4mFAIcQIcnNwjM7vHUxQ/NQkYRZSMYaRpNg/55rf+lJ/92Z+jVCqgLVDu5DzhOS4m0Wgh6Wx02Nnt0Uwt6rV19PxlVKJJ9ndxo5B8I0t9bY65osXudsio26dU9hGOj5YRJkkImkPCZoHVDzjk9Tq2H3IQHnJYLJC/skL+eIiWMSaO8K2ERg72cj6H1+/RuLRGoeigwphxJyE6TkgrDhfO+OyPDGJoEaUxMkp5fDHHxv1F3t5qUXUtMq5F3lYo2yJbXSIdDAl8G+PPoXILJMLn6M3rdOMcbrFILjzAQuLkc6A8jo9bBAmknqB+7gIYQxSmHNy4g45iuu0hd9855OJTObL+tFQRZRkaRWoU7rhPr6tgLKmXi+zcu0HRPoOQAbbokY0DonBAcP8aqvNpfuozn+cf9g4RMsJxDEs1By0EqRzx1OMZzjSWKXuC29cT1pbyyPXLXFr9EOWqw+2X/m/uvP4qdza2qJWuUptfZnV1iYuXzrG2dpZ8qUx7MCAYhag332aUjDFrZyldWset50iNYWQM5ZxDxZtHpH1UkuL5c+CECFsRDG0Oth4QtQ+puQMcFNUFjzMLFvm8jbIthOWAzBAME0bkGRgX2yRkVIQrNbEuMNBl9o82GexqDvZi+gOozOXIlat86Rf+FnFo6A7avP26jYxHJCuLeH6RX/3VXyWKUmq1GsViiW63y+/+o9/lOy+9xOuvvc54PCZJkol0a5KeiAM8JM+IEwGFGVVvJq7wfg7H7+v0eO2Pv05yr02Uq/DOxj2eLvt84fOf5E9+8/c4OGhSaLTwF+aRmTLs7iCGLqnwiXsGtzUid65IVHI4vL/H0oV5mF9DRwHjwy69XotaERzdo7dzSLTXwQ4TcgsZ9hyH9s0WBomVd5jLW9Q8webuBo8f/RGHxxWWLvwUhcpFlLLfVZU4DW3+xeM9UDTvDp5/mTEJfpOP4/GYzkGPbjtkrlIg79VoVOts3+og7TxnG+eo+GXMOMb0Q6yqA9ohHY852t4k7LcpN6qMUKQ9gz/nYbsRFhLPcshX6hzPL+DPQaB8hHcBx15FSut9ZYX/vA8hBMKeNsh56l2PirIgGSUkg5CDrUP29/qofINLz60xVpKiNhx1jxkkFitnVlm8soxOYbA74pGnFunebzIYjLAzKVZkkF6H4WYF67MWTm6OnPdBCuYJmr173Mk7LOzeZt7VRMUCkW3jexHzVYfvXtun/oEBS9USbsOl68LGNztk6x7zDYvLDZctoTg+tBgO+yzmYx69XODW1V2OLcVxxacYWXi2oFRwGW3eoxnXyVdrVHNzvH1zh6cux+Qqc3z59X1yKqWR8/EcB9tofKtIojQy7RAnWbK1c3zkiw2+1f8d7M0NbnRjBscBSjfxkwzlJ84T3mwx0hlydpkkEKRhm7nMiLRzBOmIjHuBrlaQSvJij5rU3O6M2PnqFoUPzZGoCIYdkv6bZK0msVfF6DGWDEkjQzgsMAoFIxFg+QYtQoQZUajYuI9ewIgIHTWJkiOMqGJZRRzbJdGGKIp4+61reJtvchR3KTz5FOs/+RxKwH6kyeoJVcWYFJOMcWWMchSpSTBCsHntGu0HW1T1gFxJUngkx7kzeRx7jFQuRijG0Yhhv8nhbsyd2OZuIDiT93ih6iJVyLiwzCsbDzijEqRl8OaWqNZXSHSPw842Ob9Exi4yGIzY33lA0u8zf34NJ3MJS7on9MCHIWuCJgjknz2g/RXHi+cu0GkP+fIffJO8Svj5Dz/Pd69fZ6MXUnnnLk4+j1xbwcmXsHZ2EYcZep1j4u0RpXyEV8/QK9oMDgeoR55ErV4mihVB/y6R3WNuzqKoQ45e2SfdH5BTArfusSckvTttjGVQeUlNKfKeJEg1z6xphM6SpHm6/YBef0JR0YCSD70ZZpSUyTgpO58cQk9TtE4abKcv1Zh3HVYnVWozTRYm8Hw6k/UREpGmJMJgpEDakt7hCB2neL6YiENom50HPbDmWKucwUIR9wKkBlF1ManLO1evMu4f4/suTiFDaDlEfUNlKYvjjGDs4McJWdtmWC5RqkuORMx3fudbtPb/Cb1uyGg0Jo40YRBO6UMPzwgPEbQZ8XVy7ZNEaPa5mboeT83KzERd6MSpmIfUrJMDvHgPjWg2p8xQmtnveA9t9eQXvfuZe0hcOuXqOt3HUp2eIAaICfd6+haAh+85FWKCvguDmPooGD3psTjYP+Dv//o/4LOf+xyu62I71pRKlTAej0i6CelxyDvfv8Fg5FE79yT18yuMfZu51LDRPCCrKtTWzlK91CCNDYPdgKc/ss7Oa9ukyRjHS7DMGOl2GNyrMfdFi8x4ifx8nX4yoKsPuJ23Wblzl9WST2eQoh1F3k+olh3+9K0dLnw6pFR18VYyHMuQo2s9snMuyw2LR5c99nYV3e6IaBhQ8+GRCz4vffUee8Uc9VoGLytxJRQLDv1b77Cl11murdLtjthrHvKBRxKcXJn/9ds7PNawKWddMpaFoxMyVoHY0lhJizCps/DI0xSKJV5tHZLt9LnaSRgfDMi+vc/KBZfS8jzj+x16eBRVjfEgxTEBnjWYUMiTAD/7JAfxKlm9TUbElK2IfpSw88c7WM8pFup1luZHrNVDbBKagy6ZrCCfdXHrBRo1i4NtiVXz+cJP/R3W5y8jRZv+3utsbtgk/QSV3uTF56+wtPhxvvHNV3npey9RqTZ47oUXKTg55o7eZtsVXPrxp6g+8ygIOI4NFWmRK9joOMKSGscRKEui0aAUt7/7fUz7iDlrRLbiUDif5fyZMkqNkCpDbBLiYUDS73K0P+JaZHM7sPjYfJHzOUMiQzpS8frObR53XeK+ZNhU2HaJ5z9yhvmzS0RhxJf/r6/iezFO3OdDT6zz7Kd/grPnn8G2PKZEO4wxuK7H3/2VX+GXf/mX+Ns/80V2d3YIgnDy/J+4KD9M1E+oqacWoBSTlSbec+b9YeN9JQdzhTqL2QLHyZjjVszvXn2bv3PzBpWRRgw69Esu2csLJF0LU5tHuAo3HdDZ2WCwv0X+4o+TqViY/T5JWSMurTLycuznPObP2Ggrphsd8fb9Y4JWQsaxEZbhwSgkxdDtJGTnFNVyhryy6PcPaN+LKM976LhFkvwslv2x6STOgtAPOSA/jCjvfu0Jf3IW/P7yPPyHG/bkJh0cHhAMIizlUG6UuPT4I3zmkS/xn33zP+THP/Yv8MSlx3BtnzSMyRQEKE0Shwy6fQrZDGqhRmVhnsrKIq8/2EElfdxCHSV9UBaeZ7NQLzLoBByOu4zHhkmI/evAS/7mDsuxJgsrnWwiGIPKOCjHorO5ydITc9QfL3O0cYjIpRQKPiIcIdMBmaxDcbFOccEh7KaUygrhKEQkECoPi3lccYCmSUvW2fhGSumSS/3zPlf8HDfv+cx7ivtvNVlYmMculeh2Q4atIYXHljgXjdi82kYZj/lLNebKHsXP1vjWH/bwP1VgrWxh1y3aqebBloPej3j28RL3N0ZsbW/iRPuUa08zV3DRriANByz6JY56EXfDAX68RXX5aa6+8gM+thoTDiWdsUsnFsTdJnNuhFioMn7QJxn1GIxGBJbhuV/7F3nj7/06peiYaBRxeNxFa3g271J47AzN2/sEeCCzOJ6HN4p559ZdPnj5k+w+uIpnSijLx9iLOLbkorF4+eprPLr4KOkIRs4Qx5fkVJOSPsBKqojCebSIOR4ccO3+Hmka4kRdRCbDmP+HvTeLkS057/x+EXH23DOrsva6+9q8vbHZZDcpcZMoyaa1DeixJC+SZcxgHuwXzxiYefCTB55nGxjYBsbGjMeCx5ZHtgRt5NCkSIpNdrPZe/ftuy91a83KPfOsEeGHzKq63aKtlkXYsMEPuLdQmXnOiTx1IuJb/v//ZynEAcp7g+lkQnxniqsUe3EdWVpB+yWu73ZoZst03jugvXaaM79wicrmJoVyGRUaO05YLDkIB2ShcaTGUwbrOCiWuP7ay/T2tvCcMQtNxdLH2jQa4LlgcDDaI00M3d0Jj25a7ticU5UyPxfmjHb7fPM1yb14g9s7r/Hrn71A/XIV5WbExfd41LlBq/4U7dozDNMhu9uPePDum4z7d7n24mWW164ghYuYy7QcrVOPm7XmxwYfbPkLGCOwQnA4tXztz9/gN8402cpi/P0dXHUFtxlQDAV2ZY0oUqznJbbffoeROyGon2P78AF+T5Me3AfnSQ7DCnE7or1kKGTCSHd55b0OroGo5FH4BXtpQW4KeocZ7dMBC2UPVUCapsS72zxxvsHTn36a/+QfvEwca4pMozUzjX79WMWAk27IUgkKM8s2P95ESIqZ/KkUM4ItwiKtnGW1zYkjeky8nVcMAAwziI4VEolBKI1EkIwLgrJHe7NJpzvh5a/d4cLV89RbDuOiR0FOuRISYMmKGCaK//G/+6ecby5Sq1SISlW057PXS4BDqqvrbA+n7BzsE2dDahWP/YcDVCDZ3R8xOJyQxDlFbrAGsiybqfzMuQzWziRA9RFhcb79mbkKyhH5N8syYLaHSTGH73wAW8QJNOsoo89JZv8DsKEjDVhm1Z0jzfYjuNZRFeMoGDiWWpwHDbNg7AhSZI8DBTtXQpLyZI+zzGCDJ9fTFDqfnV8pHOEgjMVajTYFpmf53Bc/x2d/6qf5rd/8TS6cP8+7777Lf/YP/yGB8Pjbn/9FXr/3Q1ZW1zl7fpFwM0SVfcaDA2QxIKo0qS3XKTcdspGm0VIYRyGnFsptxEoV97CHFocM5Ap3fz9j7YWQ1Rd9mrbEw50GbVdy45U9Lj97kbsPulgdkExyqlfXOB+PePvrD7j8udNU2mWW1yOq1YDv/6sB1V+s82RdYbVl33jsdjTFQcrHL7d56/qUt199mbJzgahykXLkYFyLScZcxvL+yHLYO6CS7xO1LvPea9f51WtTpv0yA+swSAqiySGLQQ5rS8TvHpKOd0hciV+q8MJ//Hd4/R/9V7TiHjrJuLvTQRvDJTKqV88Sv3ufsaogvAXKymIOJ9x+cMDT1z7DvevfouZtItwmQknKssdZXF764ff55NWP84krlyiCCVO5SyQOWV6ckE3GbO1kSBdMxeKcqqGDiKVIIBiRWMFnvvQsn/lsA5tOGG93cM2rTGsr/Af//k/RyQ0Hg4zy1Ofw3R1a157hqReepdxaIpcOWWGRccZy1Ucoiyw0rtQoBdbxQZR4++vfIBnvUQ5TFtZKLJ6rUqsJHAc0LllqmQxjDnd6PLo74ZHjc7Zc5uNVwYN39/jnN4e8+SiGwOPf+vQatedO4ZbGrF7zkMEiebLEy6/02T08YOv2G5yqRlx67ixPfPJ5Ns8+j+cEHEEj7VxeOE1TuoddiiLnl3/5l/jd3/1fuHv33iywn88fIcXJ/D5KJB0F6/PA+2ge/WX2kdSK/tbf+7v8zL/5qyytLTPe2mV3UjA+dPD7u3Q628TbD2j39il9/hMUsSbLJ8hwJj+lSgEsNggDwdf/9HW8g+vUT29S3dgg9Bz6vQ5Oy+XGD14h6+6i5BTrJExtgicdHg5TKk1JVHHJRIl+HOAVAz7xSUF9zRKUNeQjssmUUc/ja//iH3Pxmc/MMz0nm8H/Gd7IGMN4PCaOp3ie9yMyTH9107rg7/+jv0t/0GNtbY1nrz7H+Y1LfPfdryMcn6988W+y2FigEkZUy2WiehXp+KSTMU5YYpKk4Aj8kocbBig3I9UxOksAh9zCJItZaa7yzMVnUK7l7Op5KlHtuIT0/w6o6v+7JqRAOgrpzEvsQhC1m/itGqVmjXqrxPSlP0GWG9zejQknksX1FaqXNvArdXr7sNT2kXaC7ufEnSGT3j7V9XVUpcWD6X1uDA7x2i5Kal76X9+g1awzublH3ihBPWIwHtHr7LN6bpGN5Qo7PcEoMziRxPElqZ6peWxeKvH69QJfFqzUBBsNj6jk89b9jLJvKK1XiBPJuJPjxFNaG02maIxXoyz6iHyExUVFS+ze36ObGCqVIstyVwAAIABJREFUFXIjMcmEUjahstpiEHvE3ZxqfYHCMcRpTMlpYEY9lj/uUR+OGY1jRmmOLQzFJGMxqOH4Fpt18OIYMzb0BnBl5ZPs3n2NEoLAb+MpF6kKstIyu8M3WK2U6YynGKsplSxOKSG1E+g/wHX2EXqbYecuh9sPySZ7nIoyllZSlHqItTsoJniOi3AUUU1h/Brleo1EW4Yjw4Lf5ubQYenqBdJ2gN9cohxU8RGMhgVVfwYtkxRIXaAUuJED9Dm8/nVu3bxBRU5prXlUL5RZWDQoqyBLSGKfzjjg0Z7H4Y7L2adCPvPCi5y7eI6lMxdYv3Kejz23zgufiPjip0/jHuwwSc8QNa9Qqlaw8TbS1JhkmvuvfINH732HUtNy4fnnWFp6ESX9YzjRsdr3j0jH/nWUxR5XK/pP//F/yYVPPUO5HGLGMYe5y3QY0kj2edTdI9x9SMPRhM9doYgNw0GHnCHpaIRq1ahsLrO01OSb33iXWuct2s9/Cq8UYU1GnIwRVcv7338ZRvsoZ0Iux2QkoHO2x5pm2ycsSw7GhvFU0yzB088GNDYUYUXx1KUGkTYEqebamSo3Hk6YpDP8rePM5C+FFLjO7OdsNZzdF89zqNcC6tUAozVB4M5w+fNU+5ETe5ylVnLWcRnAipnimfhged7xHNbOr2KBsBbgSpd6vcqZJzbwvTJ//gcv8c5rb/DSt7/Fn371j/na//41Xnnlh4y7B7x2/TalqEJY80l0wnAypNUOCcsh0hTsHY4pBFgJ496QcW/E0kqNe28/pH84IolTikJjERRFccyFMI858nBEHH6MbG1PvudRhvFo7zjJQH7wEXscwzwLQuRJld2ewH6OuR5HsLf5hT/cc+RI0egYCnbMFhFHH+Ao2Tar9EiElCghUVIBAmM1xs6co+PgQcjZ2ObXNZhjOdaiKLj/4AF/+Ed/xD/77/8Z/9vv/wF7ewf0hz2+9fYPuLl1n+3uDiI54IkgJ8Hl4UjRTj1aV05TObuGcEqMD6G9FEAxJO9oRvv76DwhXF5FlurcG9/h3X6P1Us1du/sc+N796mWIia39imWa1Dx2N3ewZDSXq/TrCj2Rg7DtMAJCnJjyIzEcQWbl8p859WMdq1gra5Yrvk4rsv7j3JCt6BxvkFnt0CPMgI01eUqCRoTNggnd4mnY4RTQroNOjt9BoVgoXGaaZGhpiNKShMu1hmkHtP9hOrCAqNiiLQugYggHbLyfEh9t8fuMCErNKYwkFoaXhWvLCHdJ0os035OUZQ503yC3XuvU3U8wnAdV+Xg+8R+mc7kPTbqVbZHU4JAEpYNTphSkOBNh1RqU1YWWxTTHNKMVgiXWoq10z6u8xDsAZ6c9QKQnkupHmC8JgvLy/SnBmVCQmeRrSxk5doVpgsuleYGZS+EApK4oOKDVQJJjtAFjidxAoHVh3Tf/wbXb9xiOcqony1TPxNSq1ukFpBNiacR28OIe7emTEcFFz++zKc/9dNcuPoxFs5c4syT5/nUT1/kyz9/mS+9eAFnf4tXX+uSqpByqPBMymQwIaw2Gb/1Tc4s+Dz5+We58omfZW39Mzhq1oBW64I8y+j3+8RxjJSSPMv5wz/8I770pZ/j5ZdfZnt7m6LIj9ctM1dn+GAAP/OFhZyvZ0JQFJo4TYG/plqR4yu8sk/r7Co//Rs/h/f1d7nz3bd4FPuMkphH+wOKd2/wxXe+jn/1s2SBxQ4T8vE+6bhP2K9A9Sx+fIM3D7ZYmIwJPEU3KrOjFYtJH3OYMxnnKNcgSjACRJyw2BDgKJIsJM0BRiTKIjw1IyjrlME7b3Lnreu8012gdursSUAgOM4E5UXOo0cPWF3bAMtxl83JZMSf/snvUwpdfv5f+wpBGHGy2c5P8lcwYzTdfheBob2wwJd/+st8/KlPUC6Vubh8lTzXlKPKrNHYh84dVuvkhWbtzCaNdguDIQgDyvUKa8urXL97m8IIan7EZn2FxXqLclhmeWGJSlQ96az3E/sr2Y9yqCwW6SiEEcwg9JKt/ZTb7/weX/j3fp1dc5pit0M4GCCVotSaEZuFX0GxixcY9OYp8kBT5BLTl7TXIjqHt5nEmic+/xSyyDnsZCycq5NaM9PkThPqQY1Bv08l38GNViiXI8qRAmWIY40bwqUrHt39lHzP0F4VXF5QDFZLdCcZtchQaUb0e2O27j3iyhOnKC143PcV4+s3qbs+KysXuRNn3N1/hxfOXOLt3T6LVcVy3UWNO/T7IxbLFSbS4aDfJVAB9XKVWEwQaYG1G5gLfVaHGdXikCzNGPX67L77PvWL53CtwsgUxxOsVqqMp/dwnAAhGmS6QDkgPJ+BPoDKIofeFM8GFCOP7mEZz/NoVwxJDs7BiFRl7I4lh5lLe7nJq+8ccvXFLlIuoFQCdv7PEaAFjguoNRpUcZ0SiVji2ZbDvU7GpeVFvMDH0QZZGEpODo43Uz+yFsd3UQKsmZDFQ+7evk8oNeXVCpUFl0ogcI3ExgWy3Obebk7cO6RZdnnis6cJohxP3JnxD2wJRIRSEa6/hh9pohf7JINbXL97wDgvsb6hQN7jcOcWh/e2kY0G1cULNOtXETI4fj6NKeboajgigdpjKMfsqf1xTP84m7C4vskTP/sca0+e5bVv32TrlfeRqc9BnDB5cED29pt8/HId7/ynkKKC3S1wjIXhAbpfJWgtE6XX+d7WFhdNiq63GE4ajPd3qU26DG9vMRwllGo5qW+YWItIDYutmY55d2DIhcZzLZkC4YEUBbJIcG8d0pykNKs+saPQzIJ790guU0qiyGNhocR+Z4rV+lgdp1rxWV+rUg5dXntzB5h1W7XWomep69kd1XPy67xicASnkWImz23nr4WhR7NdxVMCx/Po3D5g982tGffMcRDCZdAZonNNx/FmcoRS8mh3l1u3b83gaq5gTIITOBihCfs7WEfg1lqk1hInU3qHB+w8eMiw2+fRnV26nTFpWlAUR1JNR43MzJxr8cHqt543EYOZbPOcTTEjNRZ6tleKx56lx3Npx7Csk+BhpnJk5s+mPb43IOaB00mTsyOI7zGf4Oi/OTTpOGj4UbwFPlShsLMqjzHFMc8Ae9Ih1syVlI6UpY4rENaiC42Rs6xqmiTHx87GqsjSlOXFNsYqDg+m3Lqxz6PXH/Ll/+hv82Ynx017+JMJjqeImjMStAjqOMUdgkYZW/cpXEueK2xPsn62zLtvfJfF1SUuPH8amxX0OhkrV1oM44zGSpvIhbIXksYTKukj0tIZ6o0KoW/J0wlxXsYvwZNP+dx9OGVlzaFWE1xZdEn7JfZGMQsVTWOtRf/uPR7eTjl9dpmo4XLbd5i8/xat1Yt45ZCt6YSDw/f41JlL/Nn7j3hys0S7qtFJl/Ggy0Kpysg6bHcOqYcrSE+QMEHkFms3sU8ecHaQMu2M0HnMoNNl//oN6pcv4JiYnCHlsIKfp0wmD2ewGLlAko/xApdMxYwYYKIGO8k+lTRg0guYRgGR8qgHgrQQuD1FLsZsH+YYv0o9qvDegy6f9PpItUAgO2ATrC0QclYBU/kEN7zKUiNkktVJaPBU2+F+L+fp9UsYx0NlBcoapGPAcTAmx7OgAg8lNUanxJMBd28/oOZDdLZJra6oOAJXC2yqUeVl3rx5iDvtcObUIksbZwlCjSfvoZwITBnhRDh+BZ9lonJK6Qt9Wo/u83v/6gFxvsSZMwuUopxs/z690RS70KDVfppa7SJKhsCMZJwXGVhDFLqz+SoVjWadL3zhc5TLpceI/LOu31rP5rFklkQ8SRTP+1jNKwlCzqqmf5l9pOBgcjjgcK8LvsNCu8WTn7xAq+ax9a2U+P6I0XTMW3v7NL76fZ5cPkfQWCd2XeLdiCIeo+Y1zZ1pl+50Qn/wPovJInmwgKxtcPj2e+RTg6yFJJ6mcDQ6U6RGslj3GE41mbAYp8ALDKVySFFyMUJQ7KTcv+9x98DiBYarzz2DEDO1j5df/Q5379xiPBiT5RkCcB1n3oZbUqnWWF1b59qTz85kRI8IHY/nMD7iZntSAAXf9fnKl38Nx/W4euEJ2o02UioqQfWYTX5MdDs63lqU44IQVOs1/MBHG40fBDNsrTVzXVyHclQiCkPKURlHOYR+eHxO5uP+if317PhvI2fFOOkH1K5c5pTfo96ocDubBQVRs4kVoAuBdAVCOwgnQJZiXC2YFgppY6rtFqF/wEAICrfGqN8nqkT4NQ9lJSVfsbKyQCgtk8mQquex0Ix4e8/AgxG+ylk9W0cGikIXlCoeSd2l2zUc3iw4d9Fhfdnn3l5BICTNdpWkN+Dhaz1uv9vn6meXGWjLYnmJotCM+z3640PWalXc8T5qPGZkazgln4rfIvIi0smAyB0hSiG51gyTPqNRjI1zrDWU6os0zuW4xqH3cJ881+z3B0y3DllaaeL4GqNjktzA9ICgcgaKMqPJFo7VBG6ZpDQlaKwTOQdI9wBdVkwdy2ivTzQeEK22yOOMiQaCkLpfQeSKg+FgJm/KCMkEmGJNghQO1oYIHHJicJdxaKJjyzDVNCohjvRmqVgxQx8qDBqLtAWOlCgFEkOejHhw+yZpkrGwWiJsuZTKHiVPQpHjuGXudqsod8DqWpWFekSl4iGExRYxZCOsHSNUBJQQYoSULkF5jKLL4sKE4rDGQW+J5ZVnePD+n5MWBac3ztBa3kQ50bGzpm2BIJ9jUA3WagQBIOc+0EeTp/soNtg6oONVCCoBUavM1U+eY9R5gLgbIZMOO0mCvXEP96se58uL+M11pjRJ70UIRyItaFPwaNqlN54w7r2GrD5FEZXJRZWH3/k2484B+RL0S5ZCSfJMUVhLqxrQn2hyaVGuJPAVwZIijxyMkKT3Brx5fcQw1mye2SQ48yRf/+E/xwWWNxexqUZnGsd1qFZnGThbWBASqQTWajqdMUnkU6/6TJIcbeScwGuO7+GHq+4W5k71CQzmCMaUpwXdnQFIwXB3QB7nc5iTRDqKPJtlWrO0mHX5VYo8T5lORpTKFYLAo5AWjSFOpigMhbDUllcYj8cURcZ0PKGzd0A8iUEKsjglz2edjMV8gCcqVxasOBrksfN9pH9+HGweE3zFsTN9XE84+aofcM4ff8I+XAk4qk58+Fm09oQUbR4LEB7nyHyYL3MEnfvgvjYzbU4CHUc5c7nHkzHNGqjJky8wf/3xyorkpAO64wiKeVfo0XSC1fDAGbJQH/Gxy8/QaFU4HN6gUS/hlstzONMMkoZ2sF6AigyFhqkRSJFQW1kgC3Y49Ksk1mU0GhIGPl7VQxSCaslj8/QqOp0ST0aUKg7thTIvPyqo3RmwvulTaYUzKe2ioFRziRoudx4ZqmPN4rJite0xejjbZxY2a9x9aLl7v8f6e30uvLDIQVpwprZOrB36g33SdMRKtYzsPcJPhnR7q4goIAp8fKlIkgkVfwiiRF7EJKOUJM6wSQHWUl5cZvFCStc+YHw4pjCa/V6f6cMOa6stRDahmE4wWYpILEH1FOQl+qP3qYgy2pfkUUFY3SAotvH8fXS9zCCfMtrt4ZWnREuLZNOURAuieh1BmcnI0o8LlNdC0kOKCdZOZsGBdbAixHUsmgInbCKJyBNDbCytSoTAxc6kGxF2trZrQBmN48wEDYQtmI67PLp3hyzNWd6sEjQ8KpGH79h5G2PFy7eGlMsuy8tt2kstStUSMMXmY0w6ATtE2gpCTRAiQCpJUE1pGcOTTwj2Bl3evZkhTQk/mZDrjMvXPslC+wyeG834A4WhsJoiG+M4PoIMhJgFDkKxtLTEa6+9ThzHKKVmyQ0x50/qx3qOzBcGcZTsPl7JPpp9pOBg1B8y7I9wywEjmxKWBKc/dgrb3SXXfdLtKaMs5p3Xb7N89iUWfvYXoFQhq1WZTnMmWYBvLbkPytH0tq/T267itK+RxgO27nXI3AxblcQastTiKZeiHJI5lpGdkKsMFUJYlWyu+yTS0h/B7g3NvUGbrLXG2uYCoqx4/Z2XGQ3G/Nm3v8rN968z7o/Q2rK0vIyjFMyl8JZX1lhYXODatWcYdh8Qj3YQlTauH8034b/6ZiuFJIoiPvvCz6CknHexOyK8ziO9oxrtY3biiyp830cphTHmGOpkjGFzdQNHOTjOTM9ZOc4HCHbH5/6J/XhsntmSUuGGAatPXWVpqcD1Qxws0vdwKmWUIyiEhQIcV+JGZWQlxqQ5Ii+TZl3ChQVkbKi4EYlTo9uZEpQDgnqI1RpfKVrNCr4jyZI+Xtyn2mrAXkH/cEynZGifquBlHaS/TG4t9aoimQo6XUuWQ6miaPVdPCROTTJaqLArSjy4t8/FFxdnnUlLTZJej3G3h+dpcuVxe/suDc9hMsjZHwYMyz5L5RgpDIErKVV8pnnMeJIjTUisIB4OGGaK+vImkY2YZJbJ/nCWleseMqpUKYcCKQrGOqOCJfdyLBOs26fwNHHkkiyUke0meu8B8ahLOEhQbhlXxiQBiFFBxXOgtIQyFcQgp7u9y2JUIB0Xig7YAUKkYHKQPlYYrFUUuk8uCxIU42mfgjKlagljNEJLrAOFMBg0ymqMnZVdlbAU6ZTx4QMGB3t4oaTecvFKLoHr4CpFFlvGuUNqqizUcxbrilKksNkAIwEC0uQQ32+jMg3xNvg+wi9jiwOsmeK7E0qhIaHFaJpjdUp9pczS+gaVamvuQM0aUmmb44gUK46UZczsewKSI2fsxzP3O9v7jHIoVX2W6iGO47B+ZY3usEuYuGRJTqfX471Xr1NdbLHwr/8SohExrTZIpcFLXMI0JXMLHCdn++b3aVY8rG0w6O2y/fZ18ijFtgPGuUAZiXI8ssAhljDQBhsYVEnRaLksrXnEwtIbFNx7c8LbeyCiCqvrLYKlGq31OqKb0FwoYZOCPJ71s3A9h0YjnOHb52vwcDBl2J9wZr3GmbUqN+736PbjmcMHaDPnKhxDiU7gNTMnmuMqgjGWPNeMhwlpMsO+p9NsVm2YofuRxmAKO4cuzbrTO0YhcNAS9HCIUoI4SUjznMl0grCaAqgMRgwHw9lfWxumkylpNsPUH+GQZ12D/wKdDmvMPD4QJ1CiD9kRIVnIxzgBH7IjWMLjv9vHGMonTr04Jm/PR8DRiE5Ikh+uQHxwXPaoMnBEPp7DuE4qY/PPiyNoFAgljp0fa81xlUKIOX/kMWdIa32CtT52nmZOlTEWjGUwnlVkhPRopzF/89MvoNwApTUiCFChj3vUyVaD6wqcSh3yHibXiCIgz0eEiy3EMKNeaZNmDoNujL/mETQCTJYTlV2WVlpMRh55NsSdTqi3W+h7KQ/uDEAGrLslmv4UWdkgs5YwyNC5YjoV5FpQKiuankJllnrTJ6zXGO2nPLx/wKln65gCdLnNdDAkJ8VxLRMtuLVzj43Apb+3zXZUolL2qfsFjtQELkTVkP50jJQWRwSk0pKMR/RShQwixOICEpe4n2CMJT3oMGwsUFKCjBSrE0pSknsFxk7A7ZH7hrRSJW1VEa06evs+vfE+9YHEiQAvIw3EbL33XWzlFH7mM+2MmXb3WaqAdDzIdhHEYJMZn0R4GGGQ0iEzAzKliI1hGk8xTpWoWqIoChASIw1azKR9ldUzMQNHIa0mnfQZHW4x6nbwI0Vj0cMJHALPQRrIUs0kU4wzl81FWFtt4zkCm48wFBQFFHpKKdrAxF2k6IMfgAgh3wdilhY1sdFsdyyTYcaSW9DcaHD2wtOUq81Z5UsXs2qeLTA6BiWxaLCziuVRYPz2228xmYxPKmryaG6d/PwL5T9OktgfxT5ScFBIiwwUjiPoPHw4y2BHVZafusg0G5IXU7LDA8bTHrd+72vIzTNUL15BViImY8He1MXPNFeunGIn7bJzdwdn8S1W3Jj719/CzeuEawmxmJL0p5gkI/Qcys0anV6XsZvhRRlhzWFxJeLy6YDReMJ2x+HVmy5O1GTt3CbuWpWXX/8Wb755lzs37lMkOUqAFzj4QYVKM+TsmQtIocnSmKX2Chcvr6OLDvsPv4njBCjnKZSzhlQRQpwoIM3u74/efD+AlRTguh6u6/2F447IVieYysdPcpSxmiloKHXkBBy9rqg47gcvLD4caPwkMPix2/yWOp7L4kqbvKXJc2jX6uRyijE51QCcXEACKhSE9QhvGjEcDylVQ4aFwEY5smgR5hqlU8ZBHWklbsmFYoJ0wHFcKqpGMnEZb71M+doSpxcto1iQuS6dkaHVf0jp3AIah8CRnG5LlqqQZTMMZS3wENYihaBWb7Bw+jyD/ZsMOytUnTLTLEEOO0S5prR4nt9/71Xc7pAvnGoiBgdsdxN2rKAvhjzx9HlGxSJ1Z0IzKFgsR6i1Gt18wO69Ce+8N8Jtr9HYLFMpMrYmd9hIMsompb/bRzdKVCKJ8Qr8aoXd8SNcq2jWBEVUZb8a0a21OHQ1B+M+nYNtWntbrK+VWHhiAae2TvfWO1TOB5RWrjDuS7a23uLg9n1eeL6ClD1MvAdyjHROdNylnPUVwPbJxZBxUWMwGXKq3WTXaBqOwsGC0aQmR1hNKHOm0pvpn5uMZNLl8NF1PAnuokfoWHxlESInKwqy3OPRfs7mpYBqaYnATRC6h0m3SW0VFdYYFhNq/hP4eRcx3kI1DNazmLhHOszZ3ynIpcf6mYLr1/9nqsDmtatU6jWUcMAYtNXkWqNkihUZCAcrPBDecWdMecTm/DHZ7e37iF6PSiAZlFykE3D22jMc3LqOnzZYHIKJx4x6+zz8w28RXXsKf/M8Rb1Bb5IR9zQtd0StJjGjgndefZ9LzYjcd7h/+z1GtmDlcsg00OiORRUC5SocT7E7PCQJoBJZyi3J6qridFsxHE54uCf5+ts5Y69Kc2OBgyDn8MY3WL+0jPdwQJHmeAq8qodyPKJqhOeC5xqwUBSGqCJZXvD4tV+8irUOX//+A27e7bK7N2IwiGeBWKFPnNGjOzv3dc1xBhzQBpvrGSFwkiHF3OGeY/2lVMgZqH8OY529Xsyr01IIsmxKkaco5aDtDKqj5EwBqdftz5YgKedQ2IIszXEcZ569NscYYytmfAs5D2AM9uS9x+A5RxCD2RsGIeUH3n+cdCwF8Jia09F6eMQpMPYxfLM4ceCPurKeQIvM8XWV48yf16MA64TAbI8VlU5SXPY4EplBLbBHMLCZHKopzPEafaThroSaBXf2RJXJHqOMTgKZWfDBidMlBFmeU2hDpFOcRkj7qRWKQrBaqyGNBpNTCiWuBpuCWxeU6hX62RiTG0IRMDJDHD9FOKtE0wKkiw0rSCHwIhebjZGOIqwEKMclHQrGO29QfXqFs80JWwcxN3cSRkWPazXN8jMrFMbBTPucX6phlGQ6KjC+RzP0ibN4pu61toEcSgbDbXp7DVpejX48wu3t06i1sF6TP779Ko14yi9sVkh27rO7p9jH0PJTLlw9TT9rsegeslwGt15FC49eKtl7MOG1N7vY3S4bzSpeENHP9ilnGSUbs/uwy0o7wBECFYDrhOxPHuLisrRYpl8q0WvUGFQrGJVxMO5xsL/Nqe4eqxdq1C4uIsMGh7fuULscUl3+JJ0bD3lw7wF6sM3Hn2uB6KLTXYQtENLMEiUSBOmsImUOSRkzyj1ynbNUbbKvNW1HIbEUWlNQoKwmmK/3UoHNcsbdRwwP7uM7s/U+kBrXUWBS8kIxTRV7XcOTZ89S8vZQykEUHYpsQGo8Cukw1SGhehE5/SaGHlJZhJNjki7pIGbnUUyt1qLa8NnbS2jZMqtXr1IqN1BihmjRFrTVSDKQBYhZoGqsJC9ykiTDVYo4npJl2XGCwD4W6H9gjj9WBbRiNsfkY9XE/yv7SMHB2SfO01pu0Ov0OPf88+ztdti6f52FUki97UI7gJEiS2J2rKD0B1/D/YpL5dQqTlvguob3+z1+4e/8A/7r//zvsdu7z869e6jsIdkwRaktPr55mkfXE1KdYyLNpDfGdMeUljWrq5a1EmzWFWtNn3IQcPeh5u17K/T9KU55RD65yfa7HkmvQ5YMUa4lWiyzvFrlwplVrl18lmqtgqcE43iHeqlGLXKQ9jskw4zVtT5C1SiKLtPxBdzwGmGw8lFuzwfsAwHEh/bsx7P6jwcMP+IsJ+f5QADx4Wv9lYf3E/u/YUdYV10YpCMxmaW708FVgsXGAgYoJlBfF9gEEBG+V6fm5hRoKhsrmFThhimFW+AqRasa0Z3Ahm8ppAJrUMLghAGBcXh5eIkXXYezZwWpjNjPA374UPNTF67iJvuE4SLG+LiOwqtKJollkAsmsaAUWKwLbsWnfr7C1vUD3vmz77D2xc+CM8bzDDIV3HnnDo2epbH6PG/f+T4lP0d7OfFOj4OB5a3Xv8ZIlbhcMpxvuiw3HYJAM5xKErXKU3aCPngdP3A5veAzaZd4871dTlXWWNAD0rFHnJep+RlhU9HpPmKt6uGunGMY1rmb59w5uEs+HfLEvxFy7+sBtx8MefXOAZsHh7y4s8PFn2rxw0PFmVZMcrDPwb23eDScsLgxz6yLGMt0Jj8nZxVBWSQYp4mxMVJ0iPyIWqvKQQpCgZYW68wcA2kgdD2mcUG5ohBodNpFJx1S6dDNJjx1pkxF+mRFSn+QMrKC8sIym+0NDm6+Tu3aZ3DCXWy+h8kkhw8yWuemLLc+zfD+PbTnU175NJZXIbuHznKmgwxPK5Rsksdnafl75KOcWu0KSnjk6ZBCJxhRQjkpFH2sU8IKH2NnVUUEBEIcVxdmSdG/fm+T3/3qv+TXvvLrjJKcH7xxgwuXnqB6eotc9mmd9gm3fOTeiMJO2TGC0u/8Puf/w99g4ZzAjWNG6YiXHiX86YMuF0JNZTxh6+0fQCjQRYG/7tO6WOP+K7ewoUdmC/JBitEFlRWHpbrlbAVONT1aFYnQGQfbhm++qRg3apSWl4mzgklngEzBFQY3VJROVzm1UWN9qcVio0m5XGFlcY02TwxEAAAgAElEQVTh9A4qT1mou9QihWM0oScxhLzwxWt8+5Vt/vhP3+Gl775PXmi0MQgzV/WZrQAzJ5rZ5nqSSJ+tC8ZAkebH5OVZQlpirCbPZtw2KcW80jtTAyrmkqNGW9K0QCk9x9CDnhNnZ3HGiUrPcZDCTF0NO8/UW4tyTrL7xpjjZ+IIKnWUbDpSMpmta7PtRUqJFHJ+3Ow9KY8gSRx7/WbujNu5w3HMYRAcBwcncYdFysfKLsdVBANCcSQzenIn507N0e/zMR1rANrZZ6x4LJCBeYO3k2fXyplSkZASO++cLKUFY1DzqvssWDDz6sFsry20nn1fYVFK8MQTV/jtv/VbSEdRpIbOnV02nl5BlRx0bjCxpLIu0BOwTpWSO0HqKUYJyqtL6EThlz3SXFMKfQhDBmNY9QyZ4yCKHNdVeKGPSFq8Mb7E8yalWjrkyto6d+OAO+MxxnaoDh/il1ZptxawWLq9IcN+glxYYjC21CKfGIfySolJ12H/pYf88I8fceXX/waxOyZwLMODLtsPurRHLosbn+CVG9+gWffIxl16nSk7seDl77zLtNTg6SDm4kpEowpCFowmkpFZ5AUvJj4tKDsxsWvJmx5v3tnjdGWdRd2h2z+F6wtaYYFbFnS6O5xqBLinrtEVilvpmO2DPXRpxMe+UuX6/3TIrcMx1bcmnN/e55mLNc4+X+f7+4qnVyeMH77D3qO7yMCwsOqCASunWAqs0LPnyGjQU4y7iDExSuxQjtpAlcNstsYXyuB5EmEMSkg8JUgSPZMxNRkm3iUvxsTAWCdcXS5TlQHTbMJBnKK9iKi1xvriAgc3XuXUZ34JJV7GZIZkmNHZGbF8+TSN8rMcXv8OYXuVoFrC8j42PaTICsa9mJKA3a0RWhU0axGMBOXSVYwuSPIu2oQY4SLkFFl0sYQI4QLOLNgXFqszvLDCb//2b/GDH/yQe/fuY+aJBx6b1/pYsegkgawLixISPUei/GX2EXcSQXupTVStcGNrl+79h2wdDJk6uzTbC0RXL3J3d5sVp0keBNgLTW792T9l6ilYW6B9viAoR/SSL6HWM+I4ITmYEDmSC8+ts31nQK35BSbO75CND6lmFq8QbDxnaJ91OVtAyfiooMJhGvI7/2KH+voqj/SI9Y9FOIUk701JRiPG4wEvXmmy8NkqSxtnaLXOUvIb2GKH1HQpkpRWw8dzezjKQcoQ/AghakAVZQKQCygnOL7RHyHI+on9/90ExyQeUUDQAGkEQit8BVMHxg8slRVBtOxQqIBUl/CYIEwJG8K0sIQBKGkYxzGVMMAoQ1DS+NLBVS5SuWShodwMee/wEe7eDs3GOu3lswRrPrce7HO2VSLPpni+IAwCfDFzctekJUdwMJYshoJqRZEt1rlVOofUVR7d3KccCfZMTjw4YFkItvM+D15/j/PtkAzNlAleacL0fsrre3vIQnNHW5TJkbZAWkldCLr6e6z6ls/VHU7VA2y7whdfWODs4gJ//p19tgY+p8sx6wvLFI3LvNR9i3PllGCjyht2jx2VMq5UMO4un3hmiS987t/lb3wpYzx+mfdf/h7f+R/u8O23u4ynY87/0mlKlR0m+z3KgeRMu0zt3CewxR7JtMD1U1yZg3EwQgABigbTJEfLjEy7POqFNL2C1koZmccImaGERdicokiZuC0iKVFWk8Zd+t17DLr7XDt7hmo5RR/s8NZhjNNY4Mq5i0h5hjde/S4XTj+NHz2BUGP6nT4Pb+yycWYJHfwyDx5JGkFGFN5F5G+APcDkkAwTMhUxyQKmnW3y0b+ktHCN85++jBcskRearIjR1hD6FmmGzHTzJUkeY+yEQApcvww4s+SukDym9v/Xsmmc8LVvfpULH3uGK5/5LGo44dV3HnJxeZnJeJuenxFFgpYuo3yPG+OXGPyTl3mkLPULC6xcaXG2kvOr/84G994b098bInZGtM6UaD9ZZW9ryHff7zMVGYvDKUFsiEqw+qTL4imXS6nGMw6UQ967nfHKD0b4C3X6keLqs8sk+wVJX5DIEM2UT1/22fyFZdbOXqMcbeA7AiWHZHrCdHiT5bZD5C/ieRHK8ecNIi1QQ2kPY0ZkiaDI5xlmcwKDeQwd8wFn3CLQeuaAn/AUZllpY2c9GKQQWFPMHH5zBGtRx3j4o9MWRU6hxbHC0OMyg4/t+bOsuBQUaf4B/oCUJz0JCl3MNc+Pj56Nac5FsMcNzsAijzkAzDkXdj7uIxPiscoJfADffzRAO2M7fiCPZXi8gvAY2MhYtNXH5zr6XkfqguKx4MQcScpiZ+pERxlPY2bQIU703B9D7ZLrjCLJ583dHq+azEzrAkc58ywrFLqY/T2EwPM8arUaG6c3uHT5wuw6ORwc3mXDLhO4Po6yJNIyug+1dUFl0yUxJbJOimSC69QwrmSSW6ql2fmzNCEIfYwyROUCz3q4ygPlMlE5B4ddXnk4xNu5x6IbsFlZxNE5t7YGPHFOobMhQgXUShHxNCU+7HN1dZlMKu4PCi43DX7dZ7iwwMQ/h9IB99/aohqE3Em2iaYJLSHopj3u/+BdPrZeYlAk2DDGCabs72S82+0h9w64nRnc11KkNbhWUBKWrik4HVp+edEjrfrU1sp84eMhW0stvv3tbe7LMk/WU8rLFxk6i2wPbrJZzQhPN/hmdod+fYVBVODbPk9eW+Lzn/sVfvULY7q9P+H7v/c6735njz9/44DhYMCTXzmP793FcSa0yh6VxSqVM89gs32SsSGoTFFYLD5GSCQRDg0O4wnKt4ymPgcDn5qvaS6VsFkMIkEJjTQ5uTVMvAaRAGFhOt6m27mPSadcPX2KSjlF7z7kpYOMc+fPsrZ0njSpcOOd16lXlhHOJeAHbG8dMOoOaK+tkvs/yzvvTTnTbBJ4t5DFDtg+JjWkgwmpcuj2MspKEPgKJUqcefGL+KVNsjQmzgqUMvieROQDpPBxvDLDZEQRT3CVQxjVcEoRgedz4/2bjEajGQn5eKU4maNHr9k5DlIczQF5Uln8y+wjp5mEEEhdIIf7vPBTzzMeDPmTf/rfMNiPOHftKX7+7/8MX/8n/y3KdBkObnL3cAuhxgQjw7tvWS5eKqE/dcAzL26Q9g853B2wWveoyjH7NuX7b/wXlMWY9qqh3XQ4faFMRWrSRBBUKtwdBdx5CHsdAxfPMw1LNBua7v0+NX/KSsNhZT2gvbhK5CnCqA0osvgW/X6fwsR40qW29PNIOUEJgZRVpGphRYgxPbQpcL3LSNnEWoU2eraIPL7y/Kh786NgQidvHpO9PvqxH8y2PH6un9j/86a1ochnG53VsPPKkFMXLxDUHIRxcCyUlaU7sQS5QvmCoOJRWShjhMRMHHrjlFKjhMonoDNa7RLjvQTrzaVs0xxHSZySRz7N6W49ZO3qGfYf7hNKWG+FrNVq6LUqo0mOyhJ8T6KUJdUFEy3IU8nKuoAtS1iAtFAOXOKlDQ71bYr+CsLEhKaPLzv0JwXaRpwNJFZPyTJJWQjWWh7P/UrIU7t1hjf22d6fst2fcDixZNqwr2PcPMURih92NW/2Nf5WTPN6ny8/2+RnP7/M228c0O0n9A73KEnB+uICU5mytxzwyp2Eew92aS+N+c1/+xqLjsPOG99i49qXqNV+hWd++jnOXX6J29/7No9e7SHvDqm1fYJnnkE1N7n97T8DXWXSex9ZLWFljs4mgMB6DnkRkWeGQC4yFcvkNqLspVT9GsNMQ5YTOC6u65JZQa8/otlw8SXkecL9B7fob7/Hpc2AejNHSsvW7pCV1QrV9YsE4ROMhu+z/f4Nnnruc0h3j8LchXwfP5mipQuZJpy+jtcWqCgDO4IsJyty9g41W9tDtDA0Vlusry5iRYL4P9h70yDJsvM87znn3D33rL26q3qd7p59BcABAYIACIkQQC1WmCalMH8wGKR/OGSFI2TR/uMwKTrCYYYUIUoRNk0thgJ2kBQhyiZIipuIZQbLDGbDzPT03lXV1bVlZVZud7/n+MfNzKoeACYJgg5bnhPRS93KvHnuzXvPfb/ve7/3tesMhhvEqULg4DpVUHV0vgfOIklalsddKbGUP1G2mASsQvG9WiDSNKazt8vls4d4w/t89tc/x4WVNey1Fv1Rj/u9Pr5webS9gNKbLM5ZvD7sM9eC/dt9drbucuaiw2OPr1JtL/KN37xF3YPlWoqvhvR0SMXTrDqahtKcWnNZWXEJpCCJNXajziu7mlu3xxwOIVtvYbsNWi3J/TeGrM4pzp6yWKy7tJtNPNum3jhLHI9IRl9jpGNAI1EM4xUCv0aSuih7HdtaBeFQFD3SNOLv/ze/zNb2Pv1+iOM5DEfRhLN+rBde8tz1LFs9Bd5y0ngrBMhJ4qAE4eWaX0y8U4w2SKWQlMC0KMSMtiOlnPQoTORHtSkBj5o2SZdgOpt8u++mA2jDt2Tgp6Zgk9LaZHsJtOUJ+dGS5HpMij1Bx594FJTVhllzMMxEO46lRyemZTOgX85bToOKCdWnPDdlYGJmxzEJXExJ8RNSMZWHPfmasmpiZsGZtMrKWVHa25fVmkk5ZxowaHMcnEhZ9i4URUEe5yhloY1GmvI9eqITr5TCcRx+6qd+mh/7sR8vg62k4LVfvcvLG1d52HsWt+LiCIEWhqOhppKX6311LsByDFon6Nii0wtpLjQQwy5eRaAdm+goQTsVnCCAcYL0Sl8cMzJEnQO85cfYfmeTay/+MRv7He73BnhBjU9+/HlkkjJKx1jKIFwbq15ntxtRaSQ47xTI1Tq+rfCqVdLVUxylN8k7NazWgHnriKLochSBUHUueIIkGxKPLJY9xSMXfMSTVd63P8/g2i53d0K2epphnBIWBbFOsYsMJ7f4g32wDnKCjYjVlsdHn5jnk39plZde3GZjHKH2N6jPzbPUmiOS99lbDnjhlSOONu/wzNPLfPLjj9BSks2X/5CHPvAfMz//k3z8x9/iqQ99nc1XXmX3zSOsWz1aH6lz5WMfxZm7SrR3D5NXGfXeQbbbGF1Q5AlGKoxtU+QBWaKpWKcYmXmEtKm6OVWnwSA1yCSj6nsI2yKKNfE4pdm08BTEccjbV1+nIu5z7lRArZUjhWHj3oCHH11mfvlJLFWlN3yH3Vt3eOpv/RRC3CHPNlBJDycryIwh7veYM9dw6xWUFYEO0XlGkmfsdg13NjJkpcbC6gKtZgOhWjj+ImG4SRhJlHSRbo0CC2UGZFaLwVDjSKgHLo5Tx3brQMky+Pmf/++5dev2A5RApdTs3tdoxOT6Ptn0P00qfM9oRZNPwPV91i9cJEsi3nz9VYwwdPbuEXb32HIdbu9f55N/tcXyJYcLJgAKiixhZy/nta+MeDu6ybPPuwgrJzMgLZeHzp7hN3/jS7jNhI98v8/FZYe5qqJaNySZRqaK3STjZqbZkzam1sRvPYyz/yaDw4jH1wRLLUWtoqi54FsRKI+j0TapzHHtgmpNouwGUqzguHUQ8wjjkYVjugfXuT3MuXD2/bRrbbSusb13n1E44OELT56A6SdTSH+28e0akN8b/98ZgklO1oByJaeerWIHJQ9YZwZlC5zAkA40WipsWyCUwuDh1RXj/pD2SgUhDGRVjM7RGIJFH99zsAqFpSTKFihL4FcUnaMB6uomjzzyGL6Eg+1tnM4h2vFZXltB4qINZIXGCMNcw2U8Ntw/1FgtQaUiwQJPSk4v16nEq4yjnDEKm7Kp7uigS2Yn9MMRUeLgkKNNwvWjgrhjePjUKg9/qEqUxQx7Gf2DlN7hkI14yAdrKavLASZW7B8qNvYV4+GYX3/ziA+eFqwteLiyoBsX6CJm2B2jVyXd9hK9W/cJmjZXnjjD+umLiNEtDu8f8uKLv8fZK+9nfe0czdUa57/fx7X/GCUchN2mVlthft7jbqXKzo6hPf8UsvgGMhcYbLSwUJkDRQuROFhuDZKCPBpgRIMjvY+TVrAcyEWGTjOyTCPsBq6rQGi2790m7+6waEuq7SWkO0+0f5W7WnOx8UEa9WfQaCITUrFqOM4ciH10npKmhiSTSG+R+N4b1OebWO4uxvRBa/LUsHEzJg2h6lpU5qrU2xVs2yI1dXQRkaU25Am2o7GloIiHKG8JhEToLo7TxrYaSOUdc7p1gjD2LBP657/eDVEc88abb7KzfY/FmkvVtyh0jBAF6xUbUaT01A6f+PQqa09UeVzv46iI8Thnayvh6htHRP2cpz+wjpCSRBe4nmKu7vE7b+0RzBl+5Id9TlcVzYbCrUjSTCNTyb3YcNMYjmwBrRUC9zRB7wadnuYHHqvSbiiqnkXgSFyrAOVyOLhLohLqfk7V9pDWHJhF7HQN129zf3sfcX+LVN9hYwzfePMu+5v7fPPaFkunm7i6ILzfpdBmJgYxXfWnvgBTpblpJl1rjTCTrJyUoAuOs/TlwqEnzqXokt9fDoMxopROnYHyY4+A2f+1nv1/go3RpmyixOgJB98c050mVe4ZZeBbsvaaGQdITPjJk/mb6V8zzwAxA9ffokIkQMnyHE3PwQz0n+A4f+vVOA1DzImfJr+Zvr6MgDCU9B4xoSBpXRxXVU7Qn8yE1iWlmdGjpJJIc+wAbQyYQs9CIUEZCEwrNFLKmWGbkBLHcVBSsrW1xS/+4i+yf3UAVo4TWLieQlkC2zVEhxnmEQslAWyECnB8RTgYsbBeQxoDVgMjNIUAf97HdWwcbKSrygSlMri+INE59165xeFoxNn1ddpzi5zq9jlKDf/jP/qH5OGAT3/qR3j4scfoHPa4fu02p1YfQlbWWLpUZWf3LlajgSurzM9VcYZL6EHC1ihjlQKTxYz6KYUHwzQi7HkEJuRwlLJ/ZBAVi0srSzzyEZ9H05j+Xk5/f8xhf0S3iPi+WsHp0xXiI8HGnsN+V3MYj/ncWz2+/7Tg0nqVrb0BoczJszGj/gC9rOjMr3CU9Fg+M8elR85xanUVM9qgs93h9//wN3nuA5+gWX+C+XMtlN8gCL6CFi7KnqNdXaDb7jLudNnflzTnnkUlXyYXCowHxkXiYYpmud6rOsUgpEgccgT9ooOTVrA9SEyKSTRpbhBODddRGDS3b1+lEh4xt+ATNJYRVoXo4Dq3BDw/9yl8/yxxtktKQtWq4/lLwE2KPCdJNbnxsdwl8v3rNFdWEPIOhggKiEaGrc2ENJK0Kj7NU4vUanUsq04h59A6IU1tpElwLYkyPcgscBcQ0sJWR0gxj+00cNwqUtllwJql7O7ukkx8CqbrftmXLNAcU/6m1//kr2NBgD8FIP0zEVQt26baaBGHY9rz85grD/P2yy9y6+bbeC4sPtfm7NOnqS+PEVYVdE6WQnXOoTuUvHhLs3twgFXPqcxbFNJgBxa790a4/QLvEx4Ly4rACAaHCdpXuIHFXqQYZoJUtLDlKnLzLjZ91pqaC+sB7aqFJS0sIcjTjEFqMHaO60DFDQjcJZT9MEbPMQ4Lut0B/aMOh4cH7HRuszvOEdYlbmVd+kddBqMurUaTRy48+R2T+O+N//8MIQTSKoMBKaG65JTl8ViDBmkJLFeQDDKKrCxX247E9W10LvHmNMItoFAYy0IbG1Nk2K6Lp5wZV1nZlA8eS+MGFnev3mJhrs7KYg2lMsbjLu3mhVJBQZa0BlVo8onBj+OUZdJ+BmlkSg1tKVhsOEhrjnhrEygYmRw1ihFZipMmxNGIXDhYUhMLzbiQ2EPFTSKOmhGLTZv5xSqnFi1MljC3scmFpkXDK3ADjwV85ocWva2Et3aabAx3adcUpmZwhMGYhHc6RzznV6j5CsvSNKuKR85U8Pwme7f32fMWUNQYHo3ZcfvU55doLH+Q8JEB+2/cpZFXcNUSjtdA1laJihrKluihQyFtjAJjHGRegVwirQWSYUZBgREueVEglI1nIDUFPlAUgjgX+K6LMJo0TdjevUNVpMwtzGNbPsJZ4+rVr9E8fZFG4zKWtcAgvM+dnZCzD69hqRT0AdEwJI0VlYYDaYFXqSDdIZgOOuuTxym9/ZSjrqZRd6k1fPy6jePbGFGjEGdIBj2EnMN1BJZVIESGEB6FyBFG49getuWhlD0JDHSZcRX297QByRhNlmfsdzqMR0Pa9Sq7hwc0nQqWKc33ggWblWcWuPShKzRXIxA5RveJoxS3bnMUSb5wI+LcMKJxyi6BsK2Qjs3edoI/gsZcwGLLRseGUT/FuAoncNkObcLcYNzz2CMX/2ifqkppLlhcOmfjWAJbKoSRpVpQGmGcjGqgqDgNXHsdIc4Rxx5plnHj5h1u394mjLoMs4j7oebWbsjw/gHCd1BeOb8szUugKcwxqC8XgMmJOfHj5IFrJhQjOePCT8+hmb1GTN57TH855qqWQQCz7Ps08DDCnKD8nHjAT15wHKg8GDxMZnjiefXgA+ykURnaYE28cY4lUN9tnjYNjABKF+5Zt9z0GJgKbUw/5zhAmFEbmFK1SurVSbpuGVyJY8rWbL+UNCqtZ0Bfl18QAvkAnWr2Z0KzKkeBmQYuxsy2C3nS7O0kLawMfr7xjZeJo5But8cf//Efkcc5y0urFKRISyAtgXIMw05CkXsoX+D4Cp07FAjctkZ5BlFYGMdG61JfH9vBkTbKslCWQjkG6YDtCCxPcOuNayystcksiV9TBJHm6t0N3rx1nTwJmWu12Nvfoz2/wMrKPLWGSyFsDnPIRUATi4oy1AOFYI7o3hZuxWKcG2ScI5MIK09IkxCdeqBSRgaySOGEkps6pFsfszLnsXqqztnVNnE0Znv/gPNNm6ZfYK9XaKY+h13o7MTcPBhxp7/DXMtFjMHVmjgbc3M45ik3oF61kbLg/LLFuZUqlhVw0Dlkz1/Gl3X2dzqk5hTV2jrNVUGSxOy9cotlXcW2T2EFfaj0iIsGli3IxxZ6+qArfIT2oVAIe4m0N8KoRTSKvNAIaSMNxDonQBJnUBiLwLHBaJI0ZmP7GhfrPo2GjWVXKcQSb199ieVzj1KpXEIqh243YfcoZf3yKaSI0MUeo6McIWz8ioPUikqtifT6GL2PzsfEw5Tufka/p2k0XOqNgErDwrJ9CrlAYVbJhkdIMYftgKUypHRA2miRoXWK71YRsoKy3In6VkGWJvzzf/EZhsPhg30DkyrjSfOz8haf9Ndw8lr/0ykW/elpRZQsSSHA8wMeeeJJ9hbm2d66zV7nPsHpFu//9HnaaxXgZnmTS7BtRXvO4X0frXMrVNy710dZGfVlC+kX9PWALMnJswLHlnhVm2ykubcf0W56BEsOSRJg4WFl8xQDG7F1FbXu8fhFl/k5hSMVQkvQglBqIp0xX7eouh62WkHr8wxHyxz1CnZ2b9HZPWJ7r8/9/oAjkbHYOE1/NObrX/8yW/c2WFte5Qe+7we+zRn4s40HVSL+LOO9SOT/TUPIkuv7wDYlMJYogwMJyhGQFkTdAicQ2J4gaCiGRwJ3vkY+HiClTalLr5FGgeWgpIW0JNIC6QikbRA5+HWb62932N09pD1fpVHzSHXI0sr8hNtcqpMoJZGFYZzkWLaiXRd0+4Z+Zshs8KShXbMY2xXyTU0eR4RxiBik2DLDGw05Ska4toUyglxIlLBpSovNvR22t2JOz9dZXjQsLlZYWKhyKazRdzz293bx5zLqSxanlmF92cfdbLB965ADEaECgyUs0izl+iDi3H3NUqFZaMBCDc40odCSjdt77F18mudWLjA86LK9dQ9RtalXL+Cd+gEOXzpgKfYJijbCc2icehyp6sisg6ZGUYzQOkFIH134mKIOdpMsHFPYFsYLiPOYmjtPIfLS88S20cYiNZKmLTBas98/ZDjcpVGVVOYXkNInHgg2DhQ/9IFnaVQX0SYnjEM6B4Jn3vcohi5ptM24NyBPHJpLASZKqa4uk8cvUmQH6GTEqB+xt5PgupKgZlGpuSjbA1kjlyskxTwm3sCpFliOAFI0FsqpgRgjhI3jzKOkN+GBF0wcupDS/y7WmO88jCmRm9YFcZbSGQxIkw6WanO65TOQBWfWWjz7qaeYW58HroMpaSqeZ7Ny2ufpSoOX97e5fbuHPy8wWAhfEUlJGhfo3BAEDk7FZn8Q0+kkNBs+/oJDGLqIVEGyiOof4ffu4p2u8OTDLvWGhclBGEmhBWFeEImcpZZLza0gOEeanWEwaHB/55D9g7u8/fqbbO4O6EnJUEiiBLTyCBo+ZA6Dfki/O5oZYxZaM0nal/c6lHz3yaYy4X4Mek+e+pP4fPrD1Jxy9ruSCMxUovqkzCBMOMOTqkMpqTohR1Nm9k/SiGYfJsRs+4OXwvFEjpt49UQZSKNs+1uag2e9CeLb+RqUAcI0eDoJ5IEH+hWO6yDH5+ZkADHNYL7b74ATx68FM171dM/GlDQuYcTke5hWJCYN1LPgaCrpKGbvLhMxckaxKLRGqTLxYyjP90svf52vfu2rjEfH18R+b5coi0CYMjiwIO2GDPcD2ms2XlWChigUOAsWxXiA5ThoAKNKupNlIYVdeoHYAtsBoTQokJ5h71YHf65ClO1QsTMOuru8+dYrFEIiMbzyysvcuXuHDzz/IT70kY+SpiG1WsxWX1P32+XxZhmBayicgOROSs0UpKHBSgtsIvQoZFhkBI6NKAxCWHjKxjc593dTNu4MGay0WFo0LK/UqNfqOCah53js3LtHfd2luZhyZtnm1Oka1e0G2zcP2FUhVl2iMojHKbf6EetSs4RhsQ3n5mGxKkkSzcbGIXsX3scPnr7I7Ru3SaRAeWu0vct4qwX7X9oiSQMwizj1jOpijJBVVNYhp0WepQgJQgQIgnK9d1pkgx6m5ZMLh6wwVN0ahcjIshTl+eRaYURZ2ddFwUG/QzjawT/fwmvUwNQI+5LNA5u/+rHnce2AuBgxGEYMRy5PP3UBXRyQhVsMDxJsu4bv+4hMU11ZJY/+PUL3yKIxvYOI7mGG6yqCmk2l5iAtF6Pa5GKFNJ/DJNtY1Uue3ywAACAASURBVAJLFRgStAwQlgcyBA2uexo1WduNKYjCiNdfe51/+k9/mTAMy3t2cq+U1cNJj89MYcyUFcaJ3PGJO/lkJuE7jj9lcDAL/Y9vailYWlnl3GNPMLd+mieefZTFxbeBqxi2gR6YDCFslOXSrPl85KOX+K3f+DLJOKG1XLCwYjPWIcoXZH2oyRqOVWFfxGzmId5mzkLTwk0rVNVpotER4e6b+JeX8Wsh6ysOQtmlZrkQxErRcyNOtRrUlAemSp6cpj9ocv3G7/Olr+5xeLDHqUaFxPHQVY+l04v8zQ/9GMUg4X+/cR2QPH75aX7w+U9M/AneA+rvjW8/hBIIB5AgHVhsCfpbOXYgaC4r3Gop0RhGBr/aLIFAVqIO6ZSmTMXETEc6AukKhNCYwtCPh7Tm2zzz9GVqTZ/+oI9W9W8TcAqUhIproaTAtARXAkMUaTpHmq2e5tSSxZFtke7V6W1toMKECjZxMUQwJMkL3EAgswSv0Li2Rd8SvD9w6EQu24cDOnsDAs+itlzjw2eXuROPeKdnGLyzQ0umPHra4vH3VTi7VHB2bomrt3dIogKTOxz1wCiL3ztI+fihw/kzddYXLBrVgDTJ2Oob7EggPA8hHER4hOnfRtROUa9/AKf2VeK8SZS4uNUmV578GP3r3yQJDrAb6yS9lCLu4VZaCONg1HNk3TsoZxWpqySDEUPjsWY7dIo+LRFTFB4pFlC6bBoF37x/i6ad0PIU0m5j3EtsvfBbnHvmUYLmJYSqEaZdwnTAhfY53MpzZOkrjDqHpIMQISroyhq29tB0EGlIkSUMewmd/ZRxWPDoIxViLdGJRKoVjHOJtFgkDntYzUtIDih0Hy1cEAGGDN9xUcKaNbyW2VBZAhVV/Z6vUULJsv9FCpQArTOU1GzuHdKaW8GqSloLLZ5YPwvcxJhtMD2M0Qjh4ToVFtseTz13xJd+e4+aX7B6ySdYsMmkRPmQHxlaVh2hLA4x3I8S3GFMu1bDiiyyOCDbfAlfgv/QKYJ6wvqyohA2UkNuFGOhGQWGVb9KVbqYok6SnmNnd8Cbb/0RL359i2gcca4VYFUtKm0PbJe0oxltHGINhuhCsL+5y/BwQBpnEylSc4wnp9lvfQJg6+Ps97v70WYZ+MlmMfGgKCVDOQHCjzP6GnNiPxM330LPts1+N9nfZOuM1lPGBsf84pNrhJxIGxbFieZdUQYbM2+DaUWDMgF4DOknVZF3OcIJMXUiPjYJPcYaZnZoYrqvE43HJ18sJjz/vChKXwam1ZXjOkSWFxhzrNgkJudrOkeBeIAiVBTFzCn2ZFUFAbooykTPhDZWKjmV35llWZPqgiLPC7IseyAzm+tSBlNLjbBA2IZ8sMPbL2Q8+8llKnUHvyGxfUEUSoJGmyIrsDIDCoQtyvW+KM+L5UqkPaFFFZpRHiEcxe/9u/+DC1fWqNerdA9CorQgz0Is28KyIvw45p13rrK3t0cUR3zsL/81Lp2/xGBg2O+6pEZSDwqSqqLRqtDfucai0FhGkFGadMWZTVBXWOOQupRkliSz4QMVh33b4+7OkIOdETdvH7K0VOPJUwvspCFvHmrCq3c4W9M88pDDuUs+51c05xfWeOXqHSzfJo5tYp0TCcXvHqR8uuvx9OMNzq3X8V2bfpRx78jgxCAqPrKwYLiPGSlk8BT1xgewan/AKGxAw6a9dBbP8wg3rxEHB9jty4y3h0ilcNwqmBpaPUN2cBOnfoFxZIjyhFhVcC2LTtFnQSTEeYPcGJQ0CGkopOGVezc4XYHAEkjvLEnssHftRc499xhO9SGMcOhHR1hScG7hCk7wGGnyCv29DjpKMY0FTDCPJXw0B4gkJMtTunsJh52MAsOF8wFxodCxjaxfQMsLpFmFJAmxmg9hsUtedNGigc4TFDbViotS9nEvjZCkWc7Nm7f5+z/73xJF0SxoFUJMzB0NxeS+KlXWZuXGd60Fk+rh965yMFsFObkWCil59gMfwZCi1BGQAKWttdE2xtgYLHIjEGbMxeY3aNb2uLY7ItGwtFLjomuoN2yyzMKjySh32YxyNrY149spT79Ps++cYfvte9zd2cGONWf9jPc/4uL6HiZXpFoyNJphkbBayanLCJMH5InPrbde5+23OoxqDxMLQeL47PgBC5daPHtxnadWnqTlNPm5f/jfkUYp/9Xf+VmeffI5lPrzBwbvxRX/YQ8hS47ftMR/6q/UOWUE2bigyAxCCVRFUPMg7BqcQJI7hqwwOCW2w/HLwMCyS+6xLkTp5ZWn/Bf/5U/g+S5CwPLS0qR58VslyEq1jzLjaMmSFmEkeB6s1qEdCJQxHDRbZFuCcdInTPZojIfsd0MeO+vz1q0jbF/QroEjxuz3FP3WPHNnNe2jlCKVpMpmmNt8ZWOLT1xu8uG/+WkG0TW2965zb6fHl17q8+Qpg2gqzj52kfFhQv+wR+wnRDc0B8bm83+0yY/9xDOcvSxJ6VHkHc4//zHC63eoXLxIsNygL7sM7mwQnv4QBs2p938a3SsohmAHBXv4RNYCix4kxiLTuwh9iNAW1L8PwiG6aBALyAhRRuInLUZJipXFRA0HjEWeQ5EZPMvi2v4O2dYBS8tVmnNzGF0h3LrOqH6FCw8/ieXOAYLDwZjNo4KLF59l//At3KRDqCXu6bMIrRn0EpbOPkmWXkX3jjg4DBl2Rsg84txZl6gb4zZaWK3vYxyfZdgPSO2Udi3FF/dRHGBUE1SAtECoFEtWUGoFyCeLegmELFn5C7muozAiUxLPtfE9i7woNb+1gBv3Drn06BKt+SqQgUkwFBjjYFBoFAUaV8X8lScXuPFyh82NFG8/5vx6zNK8Ta0BeSoQCexnNpsDyd07BXEv46mn4VXXpTs+oDdMKCoOF+o5z13xsB0fkeXECHpZSCFzVisOdZWi8wrp2Oelf/+/8eadIdtpndwNSAuLO4HP2jMrtB3N7vUOu9c2seKcvDBsvLVFHMblA1WbmU9BeX+/awGfpb6Pgf0Ue86SdSfej5hsF8dV5Kk4xcxQjWOqDZwwJpsA3ymlZ6rhjyrphFPwflwNOFYZkpNA5HjS5dAzWlMZAKoJqDBw3A8xBRQn9jXdbqbHL0qAy4nqiZx0IJ+kCk3/PVk5mHCWTsyplF09GURME/9TfrTW8ri6MqNpHSsyFbqYZP1L9SWdZw8kT2ama0yrC2by3chZI+dU9SkKwwcqC5w490HFw/VL/6JRMuTvfe6nScaGzz7yr7hy5TLCltgVieVB1AWvpojy8rsqfVUMjieQvsJxyu+2SKFICqJul6+98ru02y1uXb3BaDykyAsqlQoHB2PiJKHQBsu20VqTRCGPPfEEt65fx/IaLK6uYYQgGo3xZc6ZuXl2mi30vqSTHlFPuzhhyNEw54kzNt94u0N7yablFphc0x9ZDJoeixcNc7sRWjiM8Qkjw2v3d/nYpQY/+BM/TqfzBe7sbLG9P6Lzap8ryyBaioefe4r+Vof+eMwhOeNNzaG2+Tefv8Xf+Xs/SKu+T2oOEa7Nhfd9iPD6NYLHn+D0uXkGu9cY7uxQW3wCIyRnPvSjhD1Bo1WQBBb7okJmLbDgS+LCIjdv4BQJQrbAfwwRDjF6jlDnFGKMox2swmGcpNhZTNjyKIwiSTMqThmy3tjfwWwesHZ+Hr9xhnwYMe4fEbce5eLDj4JsgNFsdwakps7q6goHh2/hpV1C5VJ/6BHiwZgwtmgvnyVNr6O7A+4fRIQHQ4JKQXPRJu7FeI0Wav5jHPVPMzIS4SQ0KxGuuI9iD2HPT+hEBRCTZwrXWceYBCNrALz26qt85jOfpd8fkMQxeV4GwEKeqKhxnHw4aTpY9sRM1dDMtwT732l8F6LYx1PRWqMsRaG7xPnL+HZOKWLWQpsxhc7JtEWSe4h8iJSK9z93mWHnFgcbR0RvVwg++AxV6ypWIBAT2adoKyJ8VRE0C9ygTpr3CfcH6E7GwpzF+x5RtD0DxmYU5ezkObklOVu1qSuBzgxmPGDzm/u8fb/NW/lFspt3WFxp8/STZ/BW53ACC5Ud8vZLn+Fz/+aIo0HCP/of/imnT50+YUD23nhv/MlDCIFwpz+AXZVYBkxhyAsQNgTzgiw2WJbEq5YgQRfguAJ54nITUuDVPX767/5tlJKTh/aJzNt3uDanzUieA66lcCyNJWCs4dr1jIcfs3jkTJXDNw1hmOCojEZToGoer25qHj4d0A8zuoMMG3iomtDNOux8XVNfcKhVFA01Ys3v8ebdiF/ZFvyNZxWLl57loXPrnF3+AgMZ0dlL0PfHzC/sMFcVLDVqzNuP8rmv/D6jkWRr/zbDewuoS5eprD/GeKx54XP/lh/90TX8SpfcWcUaNxjcu4UqRiTKx3NsnCBFq4JRbrOoauwvnMUoD5N00SwQZwMGBxmn6wsMuh1cq44hINUwzhJ6ozvUVy9j8BDUyXOBozS+b9FNUvYPbuO2LaQ4hSnqDBPD9m5K5fEfpOp4SMb0jjr0EqB2mSXfZiwu4LhDPOEj0UhRo1X3gW8y3L3Jzq09VBER1MFp16nUqhi5hKx9mt6woDseY4sOK5UET0oI5rHsxyjEHIYqUjjYEqR0QXiUYFQihEQpn++VdOm7x1Qju9CadKLHLi1F4EmMLfngD1zhox+9jCCd0JtaZHm/bNRODWlW1mSEkDz3bIvDrYzkes6RH1J5TBGgsO2cYhwTETF6Z0hyNcNfdXGrLapyjvHmBmqUcuasxzOXHdq+RGPRH4/ZNDZN12fFEwSyoMhSzHDI9Rdv843OOltpAWGHWsvi8UfmcdZXyOnS0iMyNUKlCUWs2bx+n3AYH/cWTAoGZU6cY1QrHvx3mrE7rhycaDwGpCVnmf3pm6Y9A1OZUTH5AGviT6B1USoPTfahpJwB62lGvVQgKUF+yY+Xs88vFXqOA4Gp0s+0EjKVCj1WKTkx+cnnHnsclKBZF8WMAnUS9Bs9rRoc9w7M+h44WdWcftRxxWDaKDllD53Mzj8AWmaBwXGD9DGt6DgK0bN+CzPzaSh0MUmYqElT85S2VRqowURVafq5QmLb9izJYzAIKQgqAUVeVhsqlSq2XcKlV197lZ/5z36Go2EPY+Bv/eSP8cHnP8hf++t/nU9+8pMIB/wFSCLwAlGatk3m7TjH670x8MKLX+N/+Z/+GS+/9iqO69DrdhBCUhQZeZ6RJhGWJcnS8rsYDAYMhyN63UOiMCROM7765S/wN/72T+K48wz6EuW0WFtL+fATC3zuK2OaVkLgGhrzFk7D42vXI953ucpGN2avW1CxC9aDnF5ywNYXYhbPNam5khV/BFpyfSvmf95U/EQU0LjyKZ6qvURy7m0GepIh3x6zcvoeK+2c1fXT6LbiD974OqOxZGPnOvHmGdz3n8FrVunf6/H1z/8BP/qfrCHVIf5Ci/6eTTocI4sxmXLxXZdKZcTYGIx2mXdaHM1bIHxM1EHLU/SG27i5YM5pM+z1cO0W2gQkOmcQDeibiGDhDMZ4SJpkqabmSxxH0I1CDg7v4C84UJzB6DYHvR69yKP60LNUbRfMEfudPYayTd2vsRBYROo8jjdkUfhIPGrzywhVYIpvEu7cZfvmAZ5MqK3aVJo1Kn4No5aRtU9xcBTSDQ9p+SFtK8NRFqIyh+U8TaYX0MZDIrCkxLI8hPAn94jmV37lX/L5//N32Nq6TxiGM9qhZZVKmkbrScLgJHVvcm/o6T09ueY0FBOq0Z80/kzBwQO8QMqSIMKA8FC6Tl5sl1QiWUPjoSmQFDgyZqxd8gjWlz/B2QUP++h1Aj/mtZ238Rs2z60vsDJnMTrMCLdsKg2PZ55XCGueG2/fY+9uBzvJWG02aTXOgNkhHI+5MVY0fZu1wMITEtKQfE+zsVHwhRtwqx+T0qFm91hZsrAqhrYb0usN+eYbu7z6xR32e2UQUqtWsS37ODPy5x7vlQ7+gx/T6P2BB+KEU2sJbAVFDpZnsNxJM58oy/XGEbOM4zRZJ21RGhp9C2/42zx0OfncnYAVwEiouoI4NNztZQxTQw3wGgrf0UROgOMsMYwjRHhAqwZJVgoBOK4ksSSDVGM5GWfmbPqFIYrLcv3+MObcksVZHN66+gY3OocsP/Q0q2f/U3T33zHnXsM8FLB9P2fBg7XFnOW25j/61Af4J//yD4l0gxde36O9fo6PP7RKRb/DI5cFB7tHNE4VeDKi1rCQ5y+ws3ebU6uPU3gO4TDEzzOsImKMTS4EWVYjqK2wt9tjuLfPfE0g6ZA7FcZhD7tSZ5gG7PRGRL0jKg9LjGsYjhOaVRehyma9QqckseDR2jxtX5H1OySZoHX5OSqBC2ZIXki2kjlwbR6pWyRpwijMqVfP40qFyG4iig10ErF/q0Pc6YIjqa60qdQDHK+NbV9Cq2UOjg5IModmTVOtzhFUVlEyKKsFooLAA2GjJnUpISwMJcCQykcKZ0Ij+YtZX8RE+lGI8gGjNWS5JkwMVcchHGYMByOajRQlUqRsoIWD1jmWSsAkhHFKFud0dwwNJWk1LKQL22lGte3zzGrBXKPK7q0uyWFOa9HmiedqGOZ4++3bjO6HnKorVtsNGtU1oEM4GvHmMOehOY+25+BSQFKu9zdvGz5/22InSRAmZq4V89DFJqo64EzTYvP+Pl99YZ8bbw6IxjkISTSMZi7Cs/tMTO5Jc1w5OJmFN+8C4CVVqGwGVNbUP4EHX6dBCMP0k6ZBRSkrenxvS8BMqD+60KAmAYKZNkjribvpiR3NPkbPqEXTyEYXJXVGTgKNYzrNicrHJMlXgowSdGgtUFKhlMIwCRIoAfrUf2AK8IGZBOuDBqClypEwzAzcjvFDOb9pveQButP0PE9eOA2EjD5RQVEKISRZnk8CDjGZt565Nk+rMie9FpRUM8aY5pgWNQ0GSvdYSa1eYgGpJPt7+yAEQRCQ5wW/9mu/xj//F/+Mg4P9mZO21gO+9tJX2Lx3l6987QV+/ud+AdsFyz3GEWZSspmCNF1o/skv/RK/9Vu/zc79XcKoT5pbCAy5LpiFhdPAjTKAzLPyOOMoJI5jLNshCKq8+dKXOXflw9TmruB5VSpFQXveJfDByn1SaoxEgkx7LLRL08w5aZFWDLkwhFmObWsurvgcJBolDGGaoTBcXLa5KBxeePnr1Do9zj72IWq1hxCDF2h7d+BywI27CZcXYG4h5aH2HJ/8+JP8yq9+ibFu8ztfvkPz4iNcWmrQqG9z+QLs3utx5QwYPaK9MkcSpxx0tlheusyu7zA6ElSKBF3YpIjj9b5xmts3bqCSMYsLNlIclev9+AC38TCdoaDTzTAypmJJjGfoDmIWWx4FgnGmifKCLJY83likGihG2xsQLNE+d4GKb2EYkOeKm/Eyiw2XeReSJGUcGlT1IVxpIHkH8uskRyO6Wz2Sbg/lWzRW67iVCo6zgmWdIZfzdLo7ZJnL0ryhWl3Hd+dLGWrlI0QFy3gIY02qhYbS+EzROTzgH/yDX+S1V9/g8LBHmiRkeT6rbE1vdQ0PJgY4QaljWtWcRPFihib4k8Z3Zaf5IM9SoEQdW50hze5QmDqKKpmJKEyI1iFZnhPqAFOk5Ml1KgsJ87pOY67C+fYPc/7cLnHf4sUvHjEYJ8Q5PH054PTlJok5y+G1LdKDlHrD0FqWWNIijhNu7ZVNbHNOgac1spAUY83+nuRr9322dINMjFl0ejz/vsuMRESe97l2dcS9jQF3bg7ZO4yRwuY//5m/S61anxzRe6D+vXE8plmxb6EZiOmD/tuB9uMHnbLKB+7sVRMgP8tElgIcx0HGd3H5vXsKlhLUK5K1ZQstUqQxBNKw3KyT9WpkeY7rNqhnXXQN+nsZVQQVzyKQcJQIZF4QWxJXaIpckWqFtC0GY4HjZcyLCLvYwul7xLsucfV5PAvq4h6saNKjjMP9Ecu1Hs9/4i/zy//2G6BztvZ2ubffIytspF1l7YyAwQATX0X5V7AtF0SKSg1HcYorPXKvDUhMKsltC4lNP2vgqDqqepZkr8vuzgGnrswjA5/dnX3mXYVyAhzPYPCJtM04NLQxCG3KvIbQ9MOEOhJXQqodMneZPHBwgyqOGmKEYnPooC2buqvwhCEqyp6JW7fuMwrvUSm28PQORTqkkmpErUJroYpf8XHcOSxrBS2X6UUhhbBpttZLAGGXHe2FsJEoojxBCo0SNkIopCiAKkL5CFTZ0Cj+YiubJY1CIuVE0nJSRRC5RBfwztu7rK/VmZ8/g7I9jHYwlocuhhRFTpJJhpmNyQzziz6DCzV8pSmEpL8pWV+rMdwP+YPf6nBvN8KrCh6+HNBab7DVidl57QAGCY0zAfV2+fgbJyNu3B9xer5O0wpxdIzIBOkg4/59zR9vVNi3zmCFO1xYsXjooXPEKiOOD7j61ia3rx9x+9aI7iAlTwp29wYU2rzruDnmp09A5BSYz1Jyx+nr2fuOA4FjMDd9yZT7O6XdTAHpTC3ngRmYGXidgt0H1pYTjKUZveYEcaf0FyhBgDh5PJPJTDPj0+M6BhDmxOGUez3ZyzA99GnCfgrupwZwYnLyplWEWU/BBIkYrTETgP7geTumP0yvu1m1ZPa7dzVFT/Y8fZ+ZZGeEoOz90mIyFzlzeZ6eG2WpEkyZ0il2SvfSWk8M6iTVWo1PfepT1GpVfuM3foNCF9i2QxxHfOZffYZut8utW7fJ8wKtC6aeCsPhgCSJGY1H/MIv/Bw/+7P/NbZjl03T07M6UbTSheYf/9I/5rc//3nu3L1b7ssUgEQohS4ydJHPzuGUXw5gKTULFLI0w/E8dKG58c5bjEJYOdvn7EOPk4Q+7UaLM8tzHO6NyEmwnRqVoI+pK7rbKXOOouFYpFozjgqkKIhsSYWMPLEwlkRIGAwL3CBlRYXY+R3EQZO4uEDqvx/XtmmKLdbWBaODGLfbo7U6x3Mf+TD/6+++jhYp1za3OOzHFMbF9QNOrRkY9jHx69jeFZQqyqRyqjmKMwIVkHsSCgedSwoU4NDLmnh2E1W/xOBugiUd2mvzCN9le+s+a3UHy3Ow7JC4kISFzXhsWJAatEFakBY54yilhsSREBceUWUNUZ3D9RxsNcaguD108XybuiNRaDIM1QBu3NhmFG3R1vcQeQeRxfi5QdaqtJdreEEFx11GqhUy06CfRGhhMbdwHsuOsWyFmaz3wpSmlhYFSthkWYwuMqSq84d/+AJf/OILfPUrX+foaECe57P7YdqgP/VBOels/sBdMl0LJphiZjIoxLfghW83vqvgYDrEbPXxUGoVVTwMZhkpK2TpJnkxIM0GHEV3yRCozCJPx3gNQVvVqbhNkv0W59rneXPjFrduDAnjlEpDUWvZvH5HMJ8NGe8VeMZlacHm1CmPIhnQ248QymLB0wSywKSaPLHo7sDbewHXBhJb5VxYEqy1fZotm+7+AQcHPbZvH3F/I+Swk2P7Hk8+/Cw/9NEfnpVT3xvvjen4vzML+dNcK9PS+5Q7jJlmkSZFt4mxrRDfJvj4LkdJMYLAk6wuWEhlsKzSFG15rk7UrTA46mPLCpW5OQbjAU2vIMkhRFKXLo1qTlEUDJOCtls+2BNhkQubfmwIiFFZghNpzP4NsiRFXflLUHuePPsS9WDIWI8xwwTd77ByPuXDH7zMS6/tEOaa3mjEcNCj0WzSXnFIGUGxiyjmkTQwIsO1K+RZikxBygCDIM8Nic6wLIfDEFrCxq6dJhEdDrZDHuc0ha/Y7NxFNVzsioOSEeMoozuycTJBYZV8TS00YZ4z6oW4sYaaR6JtjB9g+T7KLlCWYpC69LVDzVNUnYlUnBJYjsEID0QdLdvkJBS2jd+qIZo+1QYoUcfoJplpkuRVkiLCq5zCdX2E1BidkaYxUQHGlICAwuBZ4DulopVlt5HCRfD/nEBCeT0e01amZessK7h584CgYmPZgnpDMhonXHy0TZ7HaJFgrIJUlz0FwlK0VivYWjPsFhxtZdRrko0ebGwOCFPD6rpF0DIUt1NkpUN4P8IVBavLLq0WJGGXXqePsGxWA4GlE0ymiEeKgx14a9fn2kDSClJOn7FZX/GoNywG3SM6nTFb1/ts3Y7oDyZROIZ+d/yu450o58wQuJkBVL7zEnAig1c+iE8wXt4FaqcVghIqTikzRsK0cXcGrN9VoZeT78F8OxqZmC4oE6B/ohIhpETMgohvN3n41j6Bac59GuhMvBSmVcnpIsZxQmIaBIjjF8zmYE4GHmYqpygna6CZbDteI5l5Lxwfy8npTvdh9LQt+ThJKQXoaW/BpMIixISOOe07mAQV06qNmdCmpJRUq1U+8Ykf4kd+5NMcHh7y2c9+ljRNMcYQxzFf/OIXJkBsuq5PGkZNGUwlScLOzn3+9b/+dS5fvsxTTz/N2uk1XM8DII0TvvTlL9E97PJrv/ar7NzfmTRjlwAvLybVo6l062SuRVHMqjvHfRiGIs8RSmEpxf7eDmGU0js6JA47rNqXObXyDGdX5imGu5jUxrYr+F6T/nhA2xeMtQENnrRQ1fIeHyQFy77g/2LvvYMty67zvt/e+4Sbw8uhX+fu6e5JPQmDAQYgEUQREJMo0CpSskCbZBVLZcplucoky/6DVpVLIm2KVXIVZYoyadJ0GbSJAkESFGEEIhOYGUye6e7p9Dq8nG4+ce/tP849997XA0qQDMIENKuqwzvvnnNP2nuvb61vfStGEQtFagXtKKEkQ7w0RvYPSO++iEgS1PHHofokSRwyXR5wMDDoMMAJDziybHn3O87xF19fpxMbWu19gsECnldjatEnoouO13D9BYSIEFLgOUXSJEJFYLwqBksSW1JhUMpjrw8L0qXYPM3qa1uEoeUoy6QFyc2tqzSO+ijHwVroDTStvoubCoyTIgSk1jAIY4J2gB8ZqBUItAu1BqpUQDkWoRw6sUfb+MxVFAUJwsqhSIODoQDU0XIapMEpJhTLhRPpNQAAIABJREFUZWStQLUJwjSxtklk6kTGJTExxcoRfM/NhptOCNOAKDVo46F1itCGkguClL29Ps+9sM4nPvEZnn3meZJEj4QHcvA/DhqMgwsjCt6b5odxRGMUyDwU3P/L7T8QHNwbQZVIKvjeU1giwKEfvYDRHZK0QyfogLL42sfqFaqlbcpyH921fO4zn+XEzAomfoPQcYgLhl7fcOvzXSqvD3jwbR1a7ZDm9DTHVxos1h3arW321hJOPlTFFzE2hjhw6R44vHYj4aVWgZSA08UO5040KU1P89Lrl+n3tlndMES7mqiXcQkXlmb40If+3lug4C17k01ykf+/mlQCM9QzF9mcDMO1UH6LQMGkieFiWfAUx+YlURgR92JmGmWi6RIqlJi0QNo4gtm5zrEZyY12RHsABcehOVMgGWiCMERaKDoCVwp2U7COwmrJWt/g9QOm/Ij5fkhtqgTNv0vPP4ef3Maf2ccttUm6Xdj/c37qQ49yZ+NL7AUFBoOEzVvXqDUeoNRsIE0MjsSm+0g0brmI9QR+ktLvJ6TCQTkuGIOOQ6xToxWn2ZV6U/TtAmsH6wRmmshzub5ZoLDgMuMLkjhha7dHfVvz2HKFThiBgNRqWv2YaL+P6aWwUCcRFt8TFAs2UyRhiq0gpVhwKbsCdxitdF2XQZpw7OxZimIRY06gzRrILp6sge3hGI3VTeLYJQgNfVOg5C/hF5eIgjWETJHSxRiHVqyJ05SG7xFHPXD7+EIg5SKO0xg91W+HCRimskZ+MmaonhPFCbu7PZ579ha3b++ztNxgfXOHH/q7ZxBCI/0Yvw5ewYdezMadCNeBguuQ9i0HGwmFVgxGEbglUpVyeS3l1fUe9fmQ+y4WiCNLY8phsVmkTEJ7b4vWxoAzjyzjmBQbSYK+y86O5NLNlJcPKnh+xP3VO5y9cIxuorly9Qb9/j431xKi3Zh4oHE9heNnkp+Oq4bNCMXhC7c2p+mOioPzj4iJdD6Mfdd8W/b5CbWgYbBpknKTZQbsRHhcjIIFudkhbefQMxGZ6MDIkc8Dc0P/2A7BSabAkzc6OiwtOm5o9uasxyGQk21BSpVljCYi+pPOf8bbt6N5bPKmiJw7ZUf/jFyZUQH2sBA5a0Kms4LpCf8mP9974zNZQ7RhlkWOMwyICblYATrVSGTWV0CNm7YpJVFKjWoLjTF4ns/Fixf52Z/9WY4dO86nP/0phBDEcUwcxyP1qFw1yXEUeUnGOPtisdrS7/f5pf/+l/jwh3+Sd73rXTSbU1hr6bTb/Mqv/ArXr10jSZNh9sGMMjmpTscByhwE2TE9JO9+mwOfPGosBIRBQJru0O202N+4wfGpH+aJRy6wNF8n2C3QPVDgFkmqS6SbA84vezyzPkAnFq+saDZcklDT3wpRCGoedIFIS4Tngw5Z7aaUA818MWTaGEo1FxrfT9c/TzFapXZE4bRbJL1NytEz/PSPPcFrVz+FKc6yt73F/tYUi8cbFJt1pImydyLZQDlFnFIDXPATTbcfo6WP8kRWe6EtRpU5SNKMVldYYD+cpmdSAmYIXcnVdZ/l0MGXgv4gYnt3QGXXcHGpzEE/YEFZOqmm04uI9gfYUCOWmsQmpVoQuL5BuR6xrbEZpNTKDmVHDGtXMtAW6pRT589RFAsk+iiWbaRIcGQJTB/HaoyeIwoM/ViS4FD0C/ilJQa960jXQeAQaUU7TghDQ9mBKOhC4QApJFeubPBr//z32N1tYUxO2TOjcWDzwZRLG+djUQ79i28UzMyBRE4r+nZkDkbfPYx8ZCM140s1io8QOj1KbsBM+Z3sHqxTrJZ4/pnPs3Lke/BKCa/e+SQvX3qG6oUHeeL9x3AXXXR0wPq1Pf7iiyG9ux0+dfU23ozP3/qB80zNnGTzSsxeusl8E2zUIrE+OpZsbsS8+GqP20GVnjrgiSOK88dX6AxivvrCZe7e3aJ9kEDs0ih6JBWXarHAg+84yoMPPPituA1v2Vv2bzU5VA0A+Csvec+jA8PJIh6E9NY3KNYK1Bem6fX3SVPFWhpx/sgsd5OAWdtj0Qvompid0FJHsDBdZb+XEsaWsmdYcBL20gq9wizHjq+ztdZmt5/iyAHq+Wcp2E3mHvjPCEs1DtpX0CZicUpgk5Dl00c5e6zOWmeOuBXwxrPPc+r++wjCebTdQrk90mQTi6TWWGC99TIi/F6qU1N09wKESqnUPRaqNV563ZI0XRSCjlC0XA9ZKNC1Fs91WN3YpjZfpVRyEV6FTjLD5o0rNB97imi9RxxrlBbIOCEJBxQ9F+1KYmFwPZC+Syqb3NyPkCWfWZk9s9RKtBUMrKHsubjCkIg6nihRFCcQRFi7j47uom2FJE4IjUfk+hSiHoVild3Wy9TKZzDCkugUZYvMTx1FW4srHZSMUWYHhxTHO/NX/aa8yTzfQUqJ1oZUG5yhNryUEqMtUZzS6wuc/T4Iw9ZOj//rd1/lyMkaQlrSRFNreujUUrIpq6tdzp9q4rpFQlsEr8A73jtD6dgMycEGL399h1df6tK+mfLZSwe48x5/8wPTbN3u0t/oUlrwmJ9S2KBLYkskgeDqtQGXVg13Q5/IafM9JxweOH2eS7c3uHp7ne2tA3ptg4ks01WXTltRP1ZBOg7XX2hRLPpYA0mSjpzPNy+s4yj/qP5ggrtL7jTfE4kbOdijFL4YOfyTNEQxpGwJO47Wjw+dOdCjQtyc3gSjYx6K0pM739mx80hjviX7/DD6PA43joqAR83ORtH9zKdwlJOdlxkXMcohShEjqlQW/YfxtY2uPz/f4X4Tm4bNzMY0J631CFBBlv0cZSomHk1+bxwnp9gMo6pynA0QOX1ryAUbdXMWWWbCcRw8z4MhbadcKvFrv/ZrNBqN4ectSZJMOOP2UHRWKTW6V0abTE51OE6MMYRhwG/+5r/id/63386oIEPqUpqmxHGc1YPkIGcik5SpTuXYcQIkiiyyH8fxSNJYKYXjKJIkQQqJg4NA4CnB0aVlWqu3aSw1ae7PIZyUyARs6ZgLxxa5noZcmFLESUQfzV5kqSNZnq2z3Y4pCSi6Gs+RtE2FnrfImdO3ufZGh10LcmMHBl/AT1aZf+in6LtltnZeoeTGzJUMwqYcObPCuWNV2uIEW1dvcXdGMbv8BGE4i2YDx+sSDe7i+WcxnmC3cxkRPUVtZprt9e6oH4yTOlxZtSQNFxfYkQ6hX8DREQMsjutw7e4mZzZ3OLY0i1YNDvoJu3euM/3YE3RX24RB5jwTxaRxSMl1SV1JpAVV3yK9En1dZKsXI0o+C1JgrCBBoo0lwVJ0s/k+FtMU3TKOiIEAaw7Q8Tra1ojDkL6sYBxLQYf4nsvu/os0qg+QmB4msShVZ74xT5DEFF0Pz02R8SrPPvMCn/7M83S6PdIkRUg1AuWZCEX2fiU2Ho2F/L3O38tJlaLJtoS5UtEoK/lNRDy/JeAgf3uztLccDWjfqeA5JbROaVSW+Y3f/u/YvX2HRx5p4wjBpZdf59x9p3jHD5+mUvEpl1aQMsE8tM4PvucK/9Ovv8bd67sYT3Lp8i3qhYjHTzWJrx6lcGKDQZQiwzpXLrVZ20xxawvYguA9TcnK8TM89+IVbm/dQTgRJ+ZLbCUB8QD2uykPPL3IY0+c4/Tck2iTopSdiJq8ZW/ZPfYd+mrkAcZKo4KjFoha65Q8l6nqIoOdMvdXD9jW2zSSAmkBUk9RSUJqnQFJ08cmPZquRxQJEp1SshEn53yurLd4JZ3m6HwRvdfi9ds92tMps5+5g7v1u8y+9/toLp5lfUfx5Tcu8VQcszD9ef7xP/5x/vRPv0SsJWcffJCN1S+ztLzM5mCLNBb4RYU2Lbqt11lqPMFuELJ9A6pTisSkbK8nFGtFlucFr+9qbgw0jmdZWlzEnPMZDAyhn5KGBi/V1GtlErpce/HTdG9fpPQDFlFWHBiJHUCwG7O11+fMxQXaXpG6q5Fema4uEkUxplBmxTMYpbBINBbhGHwlKGJwhDPkhjloPKT1SXSJKG4StJ/HuD5x4qDjmGLD4Xa3x1LhLP1eiqeKuF6VBM3m/iorswt4ThFHeEAJawVGuN/2dyYM41FUdUQrMgb0UDIzFaRpShBG7B30UI7A8RU3rnVxlMBRsL+XsnK0RHvXUCqUaO0pqlWfc/cv8PT3HmFmZo6p5oMgDnjvo9d4/dLL/OvfewW14WAcuHJlwPG3NShKQ2tzwMrxGoNIYTsFnn12l0iXoVRGehFPNywnTz/MJz7zRTpRl3JJcnyuzJ4JCYVhp2X4/r9/lgfPPMjd6wm/dfVzCLGFkpJkwv+alBkVAoydrBNiRK3J7suYhHPI8iz+OKh/yKRUI2rAvU3CRjsOwYYagocRKyeP0ss8EjjcOsnjz/sFjGP9EzSlMWUlp94M/zMuchz+GWcz875GEjEEAJNyiYfuRe58DI85CV7U0HHP+NK58z8EMnlEMwdiw+PpXEp04p7nQGny+3L6krEglUIKiTYZdVAqcYia4zgOnu9y4sQJKpUKvV6PdrvN+fMX8P3CCAgkSUKv27unYD0zow0p6dCBywOjWcGzlJIwipBCEOusAVeuEpUp1JlRjUP+zHOmhzOUMUq1xpIBGTUq5h5S+6wd7WNMShRkipFCgOs5CCFpd/b5jd/4dX7mp3+CB9x5pAHfNCjpCjPFPXbwWUxdwqpE6IB6GCLCiKTuQ9JlVhUZxAZtUipOTKMZcXWjzdf1AhdOFVi/0WJvLWK+GzC9dRN/57eY/1s/SnPlApduXubOnQ0ejnvMNb/IL/2Tn+N3fvv3OH7mPNNHSuxvvsrs7DKb/S10pPCKim54m9SELDTuZy8I2bxsmVpxaLdD+j3wSj4LM4LLe5orgabuw8LJc5ggpj8wGJmiA0PBaKZmm0SvXubq818m2XqI8geAmmLLKkzX0trV9HsRpy7Mse8UmCootGrSSRSBNuCXWPYMRmbzfSqyvha+FJSERqFAKKCMxgdbINFVomiK4OAZTKlJ2EtRjkAXBTv9gKXiOdrtAWW/hpSCXhSw3X2Do/PLFAsNPAl491NuxPjl64RhkmWFkmQ8M0iZZc11OpoPzPCdnoxpHBqTwyFozOQMkwcu3vRav8m+BeAgjxhMRg9ASSdDXmlEEAZ0Ovt42iMMDas3r3DuaJ0fff8Zph98G33lcKe9AVuWwV4XIVKWzz3J3/txy0f/6BWWjzTxymWmpx7AL5zn+InP4KkKcbfLn39uDat8/IZH27T43qNHKfsuf/bFZ0hMQrmiQDvc3bCU6h5HzpY5X6lQmjrO2obH1Vdf4IPve5zpRvmetOdb9h+TZTzWnA4w+fwnPILvMMvXZyEFSii8YoFkr4WX7tGsCepLx1m9amg6UziLlrgfo/t9cPuIWp2d1W2OV8uYqouuO4ShYf+gg77d5eHTTVpRyEFQQk6XONHos3ppn10Ptl9c5djO73P8PY9x8tGTHFmusH39Cp/+N1ucfuw5nnrnE2xuBWzcusrFCxbhzdMoWbYjS0mWgGl2B1UOXEs9bVFZXCZdG1D2XUqVGm/cNpw+rdi63uL+pQZ7MWy2U+IIGq7iX/3pBv2NLe4+v4PWPTqyjNcL6PS/hlE/wIlGjTdu7rJzdxdnEHD++Aw9t8zRgiJx6/StSxyBSgXNqsCgiKxEiKyPhCszelFJOvStZaANYWqIIk0c9An3bqIOVomkCwWPUnFAxU8JOgWqjiIwDhQarIUJcRAxVbYsTBUJTAtfVBEikykVOV3k2/wCigltXQvooVKO1hklw3EUQgtSbBaNlpY46tGcrVCuuTi+olrykANDGCvqFY+n7p/nwgNnKZ84T18qrmy/xpf/74+z4Gvue+A4s0ffwY//uOQTf3aZleNlrO/z8mt9jtQFjz8wiyt9gl7CH/3xbWaXpkl88DzN++aWKDoOf/ipL6FcTaPuEg4SNvY1lYbLyn1VLlRKJLLEF752jfWbXRAa33eJgmTiOsfe/IhLnzu7YrygjhxjPaYKCXF4wZ10lm3eAdkycjwtgBRIMvUcM1Fwmu03ph/es5Gc6pU58macIRx+JpdUHSshHZbytEIglBg55iMJxCFFZRzaH/cWGAGHIfAYn9JkZmLiPCeBycRnR4oq+elmKQOstTiOix6qD4lh/wHk4a7PI+AwLmIYAYosg6BRUiGkxHHV8HzN8PgOFkHB9/B9j5/5mZ/h6affxdU3rvLPfvmf8su//MsUh7UBxhjSNCFJk5Hak041xgwzOSIDbX7Bx3Ec0jSrFTLWkg4dulGmQWedqEf3gcOWjaesl0iaDJ1CbYbKUNnv8megpUbrrBYsB3bCAZ2mBIMBSRTjOArXVeg0YntvF7miqJg9Iidm4PooMUuVNu4CyG4Zwj7Cj0irCbtre5yqV4ibPlXr0O2FtLp9aptdHjk5xV4wYH/QZOZUheCgx93bHbZ9y87Xr3Nq73/l9Ifez6MPn2PQbbKzeouX/3SD8+/4Kn/7Q/8Jly5dp7OzxfypAtKboVk23O4bZpw6nahGJ27gCE0tbVFZOUpwY5+5+Rr7SYHdLcviAmy8ccDbz8zwWi9lr6uZQiATy0f+zTrp7hY3vvJ5WmnC3ds7qPY+Xb6OdT7Afc0pvv7aXYLNA4oyZe7INH23xLGCJHTn6KQSm4ASinpJYK0iyEYnrgRXCHwBBemN5vsg1kRRQtw7IGndRrbvEioXUTQ0Sm0kgqTnUnEUfaMQxTne6PVx3YhmUbBUrxCLLmWmkbIICBYWjnP61H04ykEnevQO5JmxfPyM6WZmTK8bZfpUBljzzzCJ00VGO7SHcPtfat/azMGQBzXq3CYUjuNTKkoc5fHUO3+QlWO3KRRilhZ95pfLGM/A3iZ3XrzJgteiWqyRliqsr0umig/y1LtPQ5Rwa/Uqq/01hIZyqcuLH9/D9EPSikGYmClT5sKJFQaO5Pb1dcp1idQuUVczGAhmZh2CUONSZbAbcrC7gV88yvGFR6iVp75pHtZb9t1nxtrR4BlTf76J0fMdYJMOiXJ8CtNnCfYjkt0bqLrLUlMi5p5g79ZrWOMgSyWMnUX4PsfOHGN7dxtXB6goRCSa2WqJVhSwfaODX5bUiikUijhOlQsXCnQ3euyEA9jqE3/+WVZaWxx976PMHztGddnB9LcgrTGzcByndIGvvPJx3lVqUKqcYtrs0O0EhEkXv1qj1QmZbsYc7O9TbkzRa/sMbsGRuuGrz4S87bE6G9dv0HbKzFRqNB+Y5rlrXbZf+xrKSYnLNeJEIkKB586TJru8snqLR06fIuhJ2j1FzRFEOmG2WQOhGESSRAukcHBLClcI2kZQEZniikFghKSApZ1YtBUEQUzQD4h6LUywg/Q9nLl5EDVcO8BXIJ0CGgdsh34Myu8xVfXxvAZlt0DZLWT8azLlDnBAKJT0/x1P+FtvcijraIfQRGuTEUflECikegQUpBQkcbaQdTsJUWzpOoJOMUUcqWGEYv5Yk5WLjzJ98hixDYk27nDn69e5oHvY1GPtlsN+tMTRmSd58t0PsXbzVXZX10F6pIUCd3sOn/3YDmJgsVMu24OQ48vLzM3P0jGamzfXqM9I3NShexCjUExPK+JYY2JNZ7NDJ7G09gx3b7S5dWOXYBCT6mEfAjGmodzLwR9F5oer7KRvOkmRuVdlbNSh9NCiYjOdcTHh7JKDiXGeYUzxyVFK5gZbbObU5w74ZD3B8ESUEiPwkCsaWWuxYthELScg2TG4yZujieFfWb1SHr23gBlOh1kdk4ZD+09GK/NciDV2GDHPzs/I8TW+eZm9NyhjQciso3G+5Z4sRfb/vCv0+Hoz58eAHvZUGKoFWQS+7zEzM80v/MIv8va3P8n1a9f4+Mc/jhAC18ldoSwrliTJqFB4vBSMi6szBSEzojJl55I9M9d1MMN9J4tJc3oHwyyCzDMyIqMIpTk4GtX7jJtWKaWGXZvzcZl/JrsHcRyTkOA4CqyPKWg+/7kvcvvFAk8cnaE+16BcgYZbQM2/k803nsUtONhSBascXMflaHHA3d1NSjqEIMBH4RaL9NoR+nqbQlVSL4JbLFL1GzQLJbo7A3aCPnKtQ/rxT3HsXQ8wdf4I7ilJ85jC9G5hKtOcOHucjQ3N85df4jGvQKl2ljm9SWu3Rep6KB+CXshUPaa/u0tjYYbNTQcJ1NyUF15OeceTDa48/xrdyjxnlssoY3np6j67rz2DVxQMyiVqXY0MCjjONEka8tLqKk+cPkN7X5LECqeQoDHUGjUsim4AVksc18H1JUoIWkZQk4ZUCLRQeAIcLJ3hfN/vRwS9PklvB5v2EG4BZ26egqjjmQ6eWwLlZRKjpk+3n1CstFlsFim4VcpegZLjZfO9SLDWQWt45qvP8Cd/9KcjgJsHDXKAcK8qUV5zQg4OZDbeZF7gz0Rfk+Hwk8Ms2zfj33wLwcHYJiMpSiqEI1FSceLkBYq1MtLrU60XkdUy+/1L2PYay/UDGqUE7QYEPpSKs6jBPnWvwnprD79cJklirt68jUh3iRNDtarwjtSoFuaouw1QirgfkMgstWjjFLBIJYi1oeBIgnaAVg69wFL0a5w89gCu65Png98CCP9xWY6888icNVmTGntvleB3uGWROIVVRWRtHrPfYv36HS48+Aj7B+tUjyyhwwFh0CcKBpRdn9LRBUSlgjABImpjwy5xbCmKDr2NfYL9GOVrtBuSOi7T02Xqy1OoVoF2r8XVuy02teWg0uTikycpOimRu0/qt6A0wCnN0wrfyXayjrunmV5eoej3MSIidLpEWBLloU2RTlRDhj7FGNwgxnd62O4+e2t38eeOIIzD7Z0WFODU8WlOPPYeZmbL1CoNuh1B1Ap45ZlPoRPAWMK9XYKdLarzHtX5RcBjt5ulkJXKWtJrQFuBATQCJQTWQBwa9lLD7UEfEVvormPTIOtwKSW1YondVNNAIE1KZFx6kUeqoaANsj4AJ6RSWKDqVfFUBUc6CDSYiEyq1EEIF/lXLFv6DS3nOudR7qEzgxUIazCGkd6+SrOfjbYEvYQkNriexBho91JO33eU848/yuzJJ9AVj07rEqK3yem5gNoS7GtBv1DGK1QQ/QFOHNMLJZVmg16/x8Z2wqCTkGpBo+5QPDFNXSxTK5Ux1hL3Q2KROU8m1CgpSbGkVuA5kqiTkLpFWvuWjfWAzY0urYM+SaKzwPuIN5+Pk4lbkDvLo+DBeKG1uaLAhFOfL8j53yPqTu5525wyNKHgM3Qsx+tOXluQd/IVI+AyPscR0WbESx8H/OUIcOSgxgyzF1Kq0TWMAU3Oyp8498lsxAQ4spOfExxy1MfncI/TMYqz5BSh/H6PP5c58VkBdH4hZqT1n+01VhIUo2OOchR2/MoCo3syou6IrKDUUYp/8A8+zLvf/W4qlQr7ewccWV7mxRdf4GN/+DE+/OGfxPNcnn32Ob70xS+Nr2zI487rbvJtWo+53kLYIS9cYIwe0pj0qD/FcPiMrmUEQo3BCIFynNH2HJiJiedhbEZDG6lq5WBIm4njWYwRxElCrz/gjTeuk9ar+EGP+VYDp1oCx+Whxx+hefwEadQnHPTBGEqeT3lmEVsp4xAggl10GBFFmoLq0ts6INiJcEqGnhzglHxqtSINdwrV8jno7tG6ts22d53TwuPs/UuUnJRAbqP9PUrFRVJ5DFOw7MTbOLua+ZNnKfhbhE5CSIuIJJvvdYWD0KAi8LEkJsZXA2w3Yuv2XabPTdHdDAn7A6zUnD41y6m3rTC3WKNSmma+MoVKU+7ceBETZxnA/sY6Vg9QK1VK000sHtsdjfQsjpIgs/le5vO9zYC2Tg2BtnTTlI0gQMRA6xaWDGQ4rkOx4LOrLVM2c/Z7aZEkcTE6xU1TqPaJ5IC54llKbgNPFXGEQqAxNuKVl1/h+edf4TOf+QJX37hOOilVasYANHvOZoImNKwryIPyowTVPVm7ibH47xPy/BaDA/GmH7MmKACSRn2aVHbRXhHHL5PKErHcwHMdTpzQaMewn8QYEdGoKXTQgajL+tpdSlMOhVKZ/kHK3q7i+IkqD56cQdeaTBUXcdMCa7tb6IM+UCQOYpJwuAA4DmGSYpHEvT6F2Tnc4gyN5gpz8yv3ZA2+u5zCt+zfbvcOFmvHS+CkfSeDxtEiLrI2K8YrEYgy69c2mDnxIBt3X2dhbplisYj0U4TsQbKPI0usHFkmFQptA5Kox6ATUQhbiOIG0d42aT8k6kTEhLgFQbFSYt6tIhzNQVpgP3F4/cXbzC3MUyiEFBsefsFgVRfcGufOnWe9F7O3egua0xS9MpY9OmmCKMXs9tpIf55Wu0chFRRkgbCVMH8Erl95Eak9vESzu7PNlUvXed/338/KiQd57MwCZTcr6Gp3E0rFAkVzi6IoMehFDHY20L1dCsePMDU7S2snQRtBuaJQKlvI9bAY1xFgDAir0alhEKXsDkL2og4yhELUoehrnGIZUWhifQn9GBt1iHREAkQiJUpAeAVmyi7GM7iOhys9HOECEmE1CB8hPMS3oZ/BX2Ymd2YYs1ZGeEFnjqaVIKQl97+MhWQYjFHKRSCJYpg/Ms/x+x6j1DxFZAISVccvVzg379AzBYK4Trkwjy+qxJu3SPot2q0uS6fKaOXRPxiwHwecODHFxVMLJI15Fvwj9PsRO7s7pK0O1rrE/YA0MliRnUuaZG2u4oHBmSvRDS3buyF7e33SJB054JPZ7uxS88jasAjZ5vkTO8GYybML+R0bK8jkWYjxbyZ+ziPrlqETCGKyg+/wC3JnbwxQJpzg0TN5s5OdZxwm6U6TzZDsxAEmuf0ZfvnG2VIxvFA7PGc78ZuxilHm+ebnPOp0PPn7yQPey2kQk0XEYugAjVrGHXLKJ4HQm6RbJ+5jpt5ihs9Gjpz7H/uxH6PRbJLECc1mk1OnT+N6Hpubm0NVGMtzzz3Ll778pUMASEwAlDHYGd+DAAAgAElEQVQoGlOyJgGE1ik6TdHDPghjOdxhfYGUyBE1xI56LIhhdid3AkeP2WaypZBJsOaqSPl35/vlwCuJEzpJShxFNIXg5ppm0BvgFTx2bUh1KuXMmUcQocIqiQ0DRBrgqjLHj66QSAet20SDgLAXUgzbiMom0fYGcT8mCANkHCNdKFSKLLo1tIg5EFXW92LMK+tUq3UKhYhis0ipkJDIA6an5ijVz7LVTdndu4W7uIhbTInTgIFJsYWQ3V4bVTzCzkGLWVnHxlnfh+m5lDdefwFXlXDDlCuXb6HTgMeeOsXpsw/xtvuW8IevyPL8LI2Kwyu1Hp4t0W0HhNu38WsupeoUtUaTzl6CtoKqL0DlYA+UBEdAakAlKUls6IQJB2FAK+ojQiiHHYoVB1mqI/wyVgFBio1ahDoikgmhUaSpoaJcZioukQxxpIsrvWEPG4E1KZ12yKc+9ed84hP/D7dvr42K4PPnn1MTpZRZ3QGZgpOQw+yeGoPVvO8Iw3cmZ0TkUr6HC9z/3Q7NX0nmIDcBuQQzQgh836dqG/RRpMLBCJ+Z0lnMaUnS6RLFDbTXBFEhiPZQiw2K3gat9W32WoLTF87y8OMPcHerQWj3OHLibXhOFaN7xGHEXOUEB/GAg60AgyKRgiRWKKNoNAyXbyaU/AKFULI0Pc/87DKu4x6aJCfjI2/Zd6/dq0ySSwXmv7OHxtB3x/sgpMQrlej3emzeuknU7fLR3/wNkuCA86fqnLhwlubiDG7J5+6NDeTaJnLlvVCdQZcqOAXFEdWnc9Cjee4AulfYXN0n2Oogu13291N2Btu4jTonF+YozFTolxxW90K+8uk3mF8qsfDAPI1pB7/QR8g7+KLLYu19xMfq3OwG1AoSK2fYCAVL8xWuvfIKp48paPTYSxPa/SqzRhEXa9zYv85T597L7lbK2q1ViqV9zp49xcpMaTghAtbSrLo8/cQyTzz8U3z2uS1uXd2kvXeAX1ZMH51GRYbWrRbL56YIPUVswNWGgu+gpEVbcJOIXhTRTzXdJOV2v83pIjhVF2fpLIVigaKSyFSzFUQ8WOxzt6fpDCyul1AqD0icIlPLx1guN+kajU86VGTRCCTGSqRQ/78CA8hlS0UeXkblvFeyDMG4rdOQsmHssGstZG6UwlEurvRxVAmhyiTCRUqPqeoFxJkSSadN98AndZdwRIFUhZjlBguVmMFnV1l3E87cd44jxwp0BgekZcuRY+/EcRpE0RYUikSux1a3xdZWgHRSjA9hz1LyDYVC5hQVPR8VQG8woN/tEfRDrB6Ob0nOkRk5sRZGkoCSrMHV2Bs97NfeG1AaYoOR05cnFibX4bGjOFzMIdNmn6AMjOeckRd8yG3Pvmdi28j3fHOfHikFdijjmSY6U9QZioYIyajoeZQpysFF1iEwozRMOCv5F2bnqkaZjdyhF8NaBTF5T940fY6vbVTrgECKifoMcsc8BwdiSNUZSzJmQEgdAjv581GOgxjKhAqZUX2mZ6ZxXTcrKE4T7q7f5eatmzz22GP84i/+twgsuzu7bG9t0263sdaOJFAhCxbkzruUEs/zcJQi1emI3iGHzpqQAmHF6Bomn6AZ1gyI4bjKJU0BlHKyazPj+5ymevhejHs15M9DDsFUXoNgjB41zNKpZnVnn8XqEj4ClSSoIOErn3iO6KG7zJ89yfTCDKYs2V/fRq3v4Rz/fig1SEunKPuaKTOg3+kzfWEf2q9z68oBzf02STegs6fp9rfxGg0eWFnBWa6wnRq22jF/8dlrzC2UWHpkkaYB5bWR4oCSUiw23kl0vMal7T3ma2X24zKhcGhUHK5fucy5ky622eLOtqGSFKh6LoFf4vreVb7vsb/Dpdd3aO3d5sjxBufvO8niVIkxG9hyZL7E0uw5nn7qOJ9/fpvrl+8S9LrMnD5CfaaG7Ws6d9ssX5ii5zjIxOApge9IlMjmey8JOYhCgtSyG4W04z5HfYvjeThHH6RS8PGBJNZ0o4AHiwE3Oym9gaBaDfEdi/WKVJqLLFYX2I0H9FotBmYTKbOeNWkacun1y3zyk59la2t7VE+S1xIcml5y0DhUuJJ58GJYm6aNQY7eMTvqWp5PKIJxF+VvNtD5VwoOMhsjeykk3XQLrXwcWcMVBRzHxbg1LqcLTFUazKZ9dOcmmzs3WbzwIzQqVzl5X49Ll++wsbrF3Mw855bfRb2q+a1PfAStE+J+CEnKfK3Mk49ehKVFvv61l9jf6eK6MfUmmMhiOylmVnHr2j63rn0VkgJPPvL06Bzfsu9+y9blbJAkw3q+nOp6b0Art+/krMGk5RNOa3+PK1ff4Oatu2zud2h3Wjy7usPssxucmq/xwIVlHvk7P8TNSzv82Rt3KLe+RNm3+NUafrnB3LEmtj+HEA8xc7/AntlnZ/Ua7s01/KDNpdV1Op7PSqvIwrlTnPyRDxLWjqK9Gi9eu0nnxa/jJ9eZn5/i9P1PEw0uUert4nrTOG4J46TMyA7XWyWO3fdebr30OidOPYlj22ztvELjkXdz82uv8CMf+mnufP0GN688Sz80PPjEUxybLeVXS5owjJxkVKGi73PxwXn++CMvsra9xcnzR5irT3P1hX2Wz1fZ6WpKicZ1QXgW4UkIBMH+HokTsWUlnSSkKBK+Z2WF1U5C0TVU/SJhatnuDohbLcT6Hb64fYO+O8fA9/D8kPmozYWVGsuF+1CiQFVZXOHiym/DFPzvaVqDlBaphlSKYW2BNgbP8w715YijGNd1h/tZhDBZEaZRKFHg0bdfpFqdxpOZCpNyS2jmeVUvURE+xZ2XCHdXoVBj7syHkFPXWDp5kxs3O+zVtyk3ZpBmjofP3Mf//Id/giMEg86AorAsTJU5sjxDpbzI6y9dI+r0aEwpREESBgbbSTAzRVYv7aOEmxWMak2q9UixxxpGDtekTri1llSbnGzKKP49jAAj7DCSd+/qcY8k6cQnJhfrnDpiIWuENHGUvAFWfh6Tzna+071ShILcMR1H+bOMyORuh8GGTseFrTDmw4+c9+G12kles5DYoSSoMfaQeIMUEukoRvwFMb7+kU67tRMT7fC+58BDjLMDkDnKo3qCUfaFUZQ9j4QeVjEaBwWUlCjHxfM8Fufn+ef/4l/Q7nbp9wdUa1UefvhhHn30UTzXQwhBu9Xm5/7Rz/HCCy8QR3H2vO7pO2etHWUElFIYO64r0GikkSM6k1IKKRV5Mf+opwEWKeTw3gmMGPcwyJMhSqmJ91JjLZnSkuuitSZJklE6T2tz6L3Na0i0SbHCgKPYiTQH/ZD9QUR/0OO5u10W//waD55d5uK7nuDk0z/I7at7/NErl5lp3aBcL+FVahRrdaYWGtj+DFI8yomnFJ2dW+zdvoW3to0XdnjlxhqD4j7H+yVOvf1tXPi+J4nLC6RelWcvX2Xw5S9RL2yxfPQki8dOEQ8uU+nt4xUX8J0SU6rHXhqxFpRYOfserjz3dR564ge4dvk5AlFFzp5i89Ub/NhP/EOufe51rr32RWqzxzl9/EGWp4qjdz5NGTFVlFJUSkUuPjTP7//mV9jvt3l46n48XWDtWoe5U1U2DzTVkkY6AulnzrYdWAatfRIn4q51iKI2s6UiZ6YXWeunlBxDzSvSCVP2+n30wR5ma50v7t6m5y3S8wpUe21Wpg1Hp2t4UQWTWKqyxH/18/8Nr7786qixXpIkaK1RSpKmeqjOZUcUojEIz8eYJUnT4TPXE1SjIfVw+K6mOh+vGQCV46GT+TLfpEMj7o2gHvpllnPlYx/7GD/8wz/8TR3wsB3mrFoMoR4wMD1im5DgMABqQpAaSYiggKaQxoRRxEEgkMU+St7i47//Wa6/cZuVozN88IN/g09+4cusbW4QxRpSKEpFvaCwJuJACt51scpuP2VvvcdgKyChyNGpCKd+DKEWeOC+t3P/2YeZm5kfcjHfHAl6y777LAsEvhlV/2U24uZ+F1g+IVmjSVPN9uYmP/9f/hyb6+tINKk1WKlwyzUqixd49+OK426f6ZqDNGVwFigunKK9v4c0i5TLhpg+0pUUfZdu/w6da19l9/omB3spaWRxCiVqp85z8b/+J5yrlXGxhOmAdu8WG3df4/qLm7z9nRcRpQG31lcplY4gC3Nsxh38uuZyZDkZlbFxnZhZ+nsDdv/8I6TVt/PYT76bZ37rowR31rn/oXN84Cd+iEo5c076fU2/mz1jzzEUhMaf8unuR3z0X/8feDNNasdO4ZTq6HCNDoscn6/gVwooXxIb6AWW49KypWO24oh6oUTZFZg05OBAU5+ymMTjxuYOcXcbL23jqYRi0WPl2AlmppYpe5KSq/BUxvdWsoBS3uiZ/HV5t1ZXVzl58iQA5YqP62agJXdOpcgLOxlGT8WIHmMY86R936NcKVGqFJmZrXHi/uP87D/8R0zNLZIIRSIEZQRxagmExO23IA5p9wJu7XY4eWYazOv8+q9+lCjscu78MU6dPcmrV++yub1DkoBIDFVXUXIFRiR0hOA9jxe4ujWge6tHv5WAgKOzir4ssrqZcPt6i731Nr2DAdGwGFkwXEgZp+XzfgR5wkCMrl0cKk49RLCZeIbjwlQ7WqAnKTHDT43WGjtxjJELMDE/HeKZH/quSa8/j/JnHOnROU18ic6LG5VETfY2yCk9o4j0MJuhMgpDBl6yyP69IGiUGiGnvwx7IIisjiKPgI6uaYJ+k1/TqKiS8bZD4ECKoQOlRqAov5+jvgtSjqgUSmb9BlzHRSjFwsICH/jAB/jFX/j5TLFoWAOQZzkcxxkpAnXabT78kx/mhRdeIIqiEd0nv4bs2rLzVFLh+d7IUR/dXzGkf9gMOOXyrXqYjctrClzPxXXdYWbCEgYBYRSOvst13ax+JtXEcTTK4Hmel/XHGCpLZUpKGeVIDc81TTPanJKC6VJxVEPnOi4z9Srdfg/fkcQWcBzc+jzTK2d416OKU27A7HSBNKrj1o6iKtP0Oj2UnqdS0/RNl1KxiCCm17lNd/UFdq5tsr+bYlPwGlPMPf40F/7+z3KmWsQFenGPvdar3Ll2jc5myEOPnkOU+ryxepWF2Yt0rKIrAihprseWs2GVKG4QyyXal1+m/drziKlHeeQ/fZrP/tPfRPV6vO9v/00effoRioVsvu/1NN2OxXXAFxrftTg1j+5+yO/86r9k8ZH7Kc0fRyhI4xZ9McvJ+QputYTyoBdbSCzzwrKtEzaikPlyHV/FhEFMEBgqNYtJPS7d2UD1N3FtH98xlMtFlo6sMDtzlLJjKDoOUsDGxgZ/8Acf5Xf/948QDALCMJigzx1+f8c1NZCmyQg/j0GAGAYs9EjBa7LB4Wg2EIyaLubAOh+bxhrUsNg9jlO6nSAfm99wEforDlsNGZwChBVDdBdg7S5C9PGEoiKLDChSdqoYLYi1xAqPgqew+5vslaY5WnySysrrpJs3WF1b59nXvshT734vjcoF2sZBGo3SffqtVb7wZ3/MTBDyqU/u4vkKv1JANiqkUcyl9RC7u0YabXL25GNMNWe+weL812Oxfsu+9ZbqLKriyFFIa/y0J+kC8t49vzvM2kxqLwgCtNZMzc7yq//yfyEcBPzGr/wPPPfSK+z1BhAeEOqXuO/7TvDwUx+k3LgPQ5VBYGl1Q84dPUoQKQahRxWLV3Kh7FPSJ1k+dYHN1Wdo3dnkzk6XgTND4ez7+PxX+6yfLXBm2lCzfSpOk5PH3k3ibLMTWhqR5szUNOFgg8H+BrPOFK90Yy6unGTPFhCDAjMuLNUlcnaJrW7CgoSwOseBDBhoB1fFYAvoRLN1dYvZpRrKd4h6LTqtm8zUn8RxFT1vhhkM1XCPOAm53HJ46uEmkaNIggQRGgoKloXDVtIjMJaCURRtDLElTjSlqmQwcGkNUqbqLs25o9R9RdlPqRWLKKeEQ4LvGhxHIaWLRaNkBgz+uoCCb2RCjvn2efGbFSJTzxACKyTGZjr84+APQ6UcmzlWJsUvKqZmi7jOHq4QFKSHkgUC61P3qhm9w8vm/V5vixvXnqd65kOcrb6f6fNf4OZrfe5u71BfrPD4k0+zsvgO9lPwrIZkn41br/PiVz5Htd3iY3+4Q6mkEOUitlLARDGvrqUYJ6bXTdld79Dd75PGaRbt1YdlOWEiqjYEBGmaRbvNhJ+d3R+yjRzyv7N/zST9Jrc3B+Am44E5nQcpxwBhYp9Jrv+h92acCABr0BPqRpN1dMYy5Cjn8riTJ5w5kTnFabLYOf9ucYjhlIOBN6+bQwZNFgg0+vBvc8d44hrz7VLKEfgcKShpjTYaxUSWQAgEeT1GDp5ytaWs4Fo5WefjQrHIP/uV/5FHLj5MvVbF9/2hw2Wyfgh5SsCOn2G31yWKoqFzbZgENHbC2c8jsmMAoTLgYXOVphEraEjzyagiakS9G4M1yHXos3uTy6KmaTpShRoBFDEEBWbsWKZJirF23CyPiewDYhhVdol1SicYsNPpUlCCB5anuduNCeIUqXcoFSPOzZ7g8ad/FK96Hq09Ov2EMIxYdhLCWNEb+CwqjaqWsJ6lps8izz1M48ZX2V/d5PpOH2/+fqLlJ/n8swPunPI5P2Mopx3mqqdwzyyzNtVmNzA0ooSHFmdpH7xK3VZIKHGnY7m4dIwdU8Dp+qzUNVNTJW43Z+mmKYtS0G0sYTqbpNaiZApWkkaajcvrHD07R6INUWuNRPeplx/EcR06/jwndUx1sMVu4rOVejxyborAkUS9EKEMValwsWybgNBYylZRJCAKsufkFSX9wKXVT1ma85gt3EfVM5R9S9kvopwiyob4DjiOi7WS3d1dPvJ//gEH+/tZJooMvGY9ZHIAnb8Ded2JHGblcioZhzK1SkpSM9GH5B7K4eQ4zUdIlpDIUpnGZlTCb2b9+Q8EB5OnM+bT/WUx2ENFXkJm6S4b4ioQdh/NSdpohHApOz4y6tFvXaPkDLBijoGxBFoTWk2qYM8K5hsnib1lSo5LWYJLjFeb4/0fnOaTX/kYvfUeMpWUPBff8YnDmP39BNKIQrmKQI5Sd2/Zd7/FaY62s5/zSNyhRfpN9t2nXuW6Lmmasr25xde+/BVOnjnF297xDt75N76f7c6AzmuvU5+u8J//F+/nkYuPUJs/ycBWGRwckHR3KIgUE7WJaVKuLeErg7YxaRoyPdMEMYOpLVI5HbEQpQhZRFQWcHtF2oOUW7Fh1lH4hEDISrPKnf2UtWiAH7jUYoGXJgS6Q3J9jXhwlND18f0CWjpoHFRpjkov5oU/+xNcNc3UdJlaRaGUJIpTdlcvU29M48iE9maLfqfLwso8As2lF64gWlv4tRI6NoRRwIljFykYSae1Sa3o/L/svXmwJdd93/c5p9e73/v2bfYVM1gHO4iFBEACBClSosqyLIu0Y1uO5ZRSVqosu2JFLqcSlyMvSiQlKctkpGixFYqSSIq7uIELSOzLYDALZn37/u5+ez0nf/TtvvcNQAmqSoqkiIPCvJnXt/uePn36nO/v9/v+vj9M2yWOYD3YwTMMcpaDlgYKBUIiTRcs2Ak1RbvFdAmqVkTOVNiWgSNCwnATK2djCCORVtQawyj/UKw3UiaSlQlQlrvoNgJNpq8vzOR+VFqdlr5BoUAnHs0wCAnCDugChughaBCLPTRRGNJg/spFrHiHvNHk5L4CcaNJu1DAV5rAFLQtk65VYHr0GMqdomBZjJoQxJMYuTEcZ5yvPPNntJeuEEkHy3HRRASdEH8nRsQR2CZRGKNinfHWh1vKD1dKgxwk9KbeutSNl0q8JuvCEEgW/R1OgRZ9Aowe3iX7FB+ldzslrpsLWU0EUo18dV3NleRa+k3QQBrR0UOXTRkJafRhmKqQRlCHaU8ZJaovXzqcjJsyhYYjJ7vNiPR6Q8ndaUfEsGQru47pDNjKrDJw6hFPP5fe1/C5qTd0OE/D6ANkyzT55//il7n3nruZnBjvVzPuz92sunN6nUGfarXaIEKRgTaV/ZQiydeQ0sCyLMIw9dKnhd2G7ntIynRAqUoiMmmeRVbASg/lNgxHc/pGUxRHmWd52GjZHUUazFWtEyEWaQq8ICAnDEpunlqhiO93Wa7XaXkxhjAx0Rw/Ps1PffhBbr35ZgoTh2nGBbqrCyi/jS0CVNAloEalOodtRPiqgSkdCrUxNBPE5VmKhz1mgxjTrdGzRlnoOdQ7EZf9mCnLBtXCthST5RKrjZBFr4vbtRjpCSwCaPcI15oE7Vl6lkvJcYmQKKOA5VZxGm2e+9ynKFcnkK1t8rlk7el2e+wsXmJ0bBwR99i4soVlxYxOjxJHAa+98DpOZxPbtOg1fAxnnL0ze3EU1OvLjBUckDl6gUcj9gkNA9e0UdIk0hHCsDCERAtNN9KUnSZ7ygZlw8c1JbZlYAmfMOxgOgZCCeIw4rvPvMwf/uGn2NzcIgr7tSlInCxap//rTH40mWMaiLM1SmQMOZ3NmTSamb39Q4Z7Eg1L6YF9h4BMTFU99PLqofX8L2p/BeNg2JPxJr//C/a84RfYkg6RHxPpLpZQaNnDFl2aWmCTI+w2iVpr9DqrqFIVG4/m5hnq6+t0uhq3VGF87ha2/TJBlMhOxqZA4xDEoxw/NsKSt4XpzLG4co1up0WvHhJ5GiUcHrzzHVRHR9g7s59hEbfd9/ODv4G/3f7qLcU7b2zppr3bvP0hwHF/pZbQBQxs28bNuTiORX17m7Mvv0x9u4Fjuxw/foDb7znKY+9+hHJ+gk7YI+w1Uf41ZHgZ2xGEahtTFxD+PIESRJHGC022tiYoTp6A0j4K1RwKA6EFjqmJSiHNHR9C6HqCQMXYRkDFNMhLA5Er4/dCenEEKkSYBcYsj/r5deTRSfKOxpFgmBblvKBnK7bOXKBQOY5jx9SKILVPEEp8X1EesfGCmF5nGxV2EM4xNIrtrVW8+ib+1ARYVcpuGbfgsLVwGVV1iCKBIWI04EcRUrrowMCUGkOFCMtGGA5+HJE3tpgtQEUEFKTGFgYi1mjRwxBGQt8QqQlq8P1MMv6rNEMmMn4IgVAaRKKYoUUCilNQllIk9DCDpQ9QpJSoSLGz3mBzZ4ta1caWEiTYdGgisJRD2N1ABeuYZU1+YgwvbLGzfpX6eoteKKmVxsmPHqUe1VBtjWVrsCRenMOyZjl2rMTr9RW0Mcv61iK9TpewFxP1DLSyaK/XiaUm8MI+73tA2UllTAXJPSTZxGSqH8NKM8Oe4+TkNzoXrlflGYDmbHnpnzA4KzUSshwByGgH2TX+soVIkO1lw5GM1EgZvkYKUgfKRanKksg+n+VM7Pre/vGsMlsCYKRIAE/qwcxAh3jjTir6n8sMg6HfDxsYXPfdu9WcBp5xIRJ5YaBfndhASkGpVOKx97yH0dGR7DuzZ4jI1FtEf9xSoF0oFLAsK3nOiCwPwJC739tdUSQh+wZEmlQ96KtSaqiGzuD+9JBx+gagf92zllIiVeLIHB5f0TcitVZJtEKmhipIJYhUjBAmUZ/HbktB0bbALPajGza5nM3JYzO86/E7efjhd1HKjdHo1VlefJ1cd5Gc6WNaMWHcxtB5tL+IH8cEocaL82xsTJIfP4IuHaQ84hIpiS0FJRSyF9JqBIhA0O6C0CEijnFtSU4aiFyFXsfDi32k4WCZUEGwc24d6+QsBRljCYm2DUo5QdCK2Dp9gVotR74kKLkxQvnEQUTga6rjNu1uSNBdxywXwZpEqYitzRWC+iZ+PEE+X6RWKGFZgu3FK1BzCMMYS6jEkRHHCOH013uFVAGYLpG2iGOfvNFgtgg14VOQGgMLoohYeUjDBG32nZAG165d5uWXT+/CvumzjxlE1aToJ/ULkc0ZEH0J0/56o9P5NHj2aVJ+uqQMR9IGjpz0un1nRmoMv0Vc8xaNg0HuwGBS/8VnXL+wgEYgsaSDik380MfSLRwzomAuEOgKPc+ku10nbjewXYtNZ5JR3WXx7FfYvLZI6FmM7Znk0P53sFa3yTsQtRVbUhALTU5pfMfg7pvfgzG1ROfpL9M6fZruzhamEBw8dJy//3d+nlKxhGmY2UANLU1vbTjebj9UTZMAHsgcc8nfhz4z2PjE7hP/GhkI6aJimiYzMzO874Mf4OzpV3nlued5+utP4kcRd993ir/14Ueo5PfSCxfxvCWsyMGxF6A4T0RMZDYodNo0t0L8wEaTx4sLnL1apHrAxJ3IMzrhEtgCbcCkCzkZM1HRbAUGXlNj6MRD09hpkrdsRssFmo7ERxEEIU5pjAOlOS59/mkK9s1ULI2tBRqL6TGLSBfJNWt0mpuUKhYOPlurC5SrMxSKs2w3AnpeF8toUawGdL0YuwQuPZRj06OAcMaolUbprG2xuXSB8el30PUjQj/AMaFgFvGVQxDG2LkYQ0doLJQEeopZu8mEXUT4AVKbaC1RQYgyOrh2DVSMRqOk6If4U8rJG1VlfpCaZRmYpoHqAyupVCJZGmeu6IRuoxQYA9qHECLDjkII4kizvrjF1YUFRqvgyByOJcnLeTxVptmCctEn7kEHi017nHERc+XFT7O10CBybaqj+5mcPMVa16YsNJ12zKql0VFMRcTkizY3Hr4fY1+HnW9+lsbZSwQthdAWpi3Y3GrRaXRQUYyK44ROpEErjWHIvhpRCtKSe0rrH6RRgVSnfhf2T/k5Q+H7gVd9AF6z7TsFokOLSkoVSc5LDYL+OqWHPPPXAfshJ3W24feDNtl1Uy9l/0PJ84h3F1FKvfkZ2O5fTwqZ9PMNQHTIYIIEmGZGQ/9YNgL9KAWpzZVakLuQ8tCAJs9E91WxhBZZ1GR3j3V2qmGkBpFAGn1KkZRMTE5RyDmD3AoGIBwxyFEYdGMQqXAcB8uyCIIge5iJYpPKztFaE8fRUI0BlY1h2sXrpkv6Tag4e0H6Xv4BRWo4OpDOLehXUbbM5PkplYHCeKhIm2CQy4GUKNFXjtKgVUwQdAlURC1f5PS+yV4AACAASURBVPD4FFqaxHmXx9//AI8+/gAFZ4Kuv0i7e4n26jlGRz0KOUUkYmKzRbHbob4eEkR5hJFns5lncXuM8h7ITZaYmMpRl4KSDWVTUzIUU2XNRmjgbSuKjoNUPTrNJkXLZrycZ9uZJIxCTCtHuVbCKs5x9esvUXJNqkYAsUHetrDHHbTIk2vWaO0sMzZhEXbrNLdWyeXGyBdm2Nju0e12KJTaWK6FFyhcU5MTPSI3RycuMFqexjWLtNbW2Vq7yMTcgzSbXXJ+F8s0yJtFAmUShAo7H2OqGF8kBp4ZxUxZLSbsIrrbA7OAikApj9huYxlloqBHEIQYZo6R2ggnTtxAuVTildOvZu+ZRkOmuDWcj0RS80KpoXdsoAuXGvTDhnKKqrO347ooY+Yw6L97UgoSIYU3fvbN2luPHOiErx2rCFMmIbAwioa4cwLDNHBtt79I6EHnRLKwJOFNg4o9TdjbYm3nHGPuJqXSJVxZ4czFbUrmPqZHTtB2R2iKEiNqm8/9+TLrmwGVgxNMHj9Ez6txrFwksmzO9jQRmvGcZlbEPHfNxx/TPPv0NYJNkzJVDLtLpezyC3/7v6ZSriSF2YZDpkPD+Xb7a9j00JPNDIPrlu4fhUcvEq6s0d9MAXK2zf2PPsLywiKtVovpib0U83P4/jbXts5Rs5oU7QDhbhHSREVN3KhOGHQxYomTyxFaEscs8c7ZPN956gXOnz1OtCfm5E0m+6cEi5sxSDDtiKVmRMVxMMOYdmsHR12m3SsgvCpOwaRUK2HRgXABY/wkan+NrbUuYuwgK55NczPiwRvewy13w7OFKhe358nnYW2nydk/epK//Y8+Qq7d4JmXziDKdfbuGaMyspdIxahejHFum9ve9Q60XaO73mbrxbMoYTJ31z4sLel22+hWm9h2MecOsLVdZ2qiRyAKBHaZWGgIGhx1BG5hhPUL55ieG6erXDrdEOFt4kgTqbcxTIkpc5hWub8m+kCMMIrf33nwhrb7Xcjl7ARgSBCmIGdA4Mf4QUwQ9D2hKTCJY2zX2cVrRQsCP8ayNdubLS69sshITmP4JqOFDvmChalynD69zg1T92FPHmPLKCHNPLl4g098ZoW2D6PHJinP7ceR0+wt2eDavNgSWEbMtOHT3m7yB2canLh9mpe//TqbKxD1BBYCS0Lc9gi7HnEYoYeAsSAJvaeJtgoGx4eqi6bGTuZpV0NAHd7gIRtg8d0b9rAKaAJMRaZck14rOzWzvwbqSCK1NhiAyHQ/Tj3hu3j4feAxiE2kEqDDYyD6akv9a/YTiVEDj2R6rQSUDCUxk/KgU4/6dYtn3yIYGEf95Emt0UK+KSDOxi2NUqGROlH6GdR9SEC8aQyS5XUaoRAC0zCxbYuDBw4m9zOE0GWmdXldhOW6Zzg5OUmxWKTT6QCJQhBZ95K/DCdQJ30y+tdSWZ+ShH1BrFXWifSrEqpQn2aSGQCJ8pFjOwRBkOU9pIBfkBRxi7MBTgxIwzCI+wZVFMVJZIaEWqW0RsUxzW6EZ5qQg8miZKPrMTMzRXl0lLHqPiyjTLO1xPz2S0wXQk7dUiXuXiMIG6B6OLQIgx6mMpClEM+wmByxmJ4TvPj8S7z22k2oQzEP3SVRkWapoTCkZsqOmK9HzJSLBK2AyKtjqFXa3TyiVyVfMnCnx5DhFlIG6PIsYl+VzYUW4q7DnL8cMWLNcdsth7jViXj+ySrntq9SGnV46cULzC82eOSJR3Hadb71/CvkJhscP3gQmaskReg6AuO1Le750OOIqMTG6yv424sYOZvZW/ZixxrVbaBaHfToJGG5wk67ycSYh08R363hRQFF5TPtgmVXWT1/jn2H59j0bcJuA5MOZlER75wjny+hIoN8Kc+jD7+bxx/7IFtbG9x1z0PEUUQSJOgb2n16WCI7m77eyWITxREilRsW9KNPgwjTwKAXA4fB0Hs4XEyQ4bVD9n/9Fn3gb8k40FrjRz6bjQVOX3ySd536GS4tXeDjf/R7nD/3OjvbDWKlOXrwEL/+7/9TotX9PdGWwDJcfD/H/JWY1sYKMycc/NIKc7UJQr3JVnyRILiDle9+gz/69J/S0B6lqQkOnLiP40ffg7lu8UokaJTgxlmLvKWRKkbrGOXAt770KgtnXkd1rzKeh/vvvp8P/9hPUqlUdllqb7e3249aywCEUsRhhGmYVMtl/smv/DKtzRXCcBMvWiGMA/ZXLZSuE/eaRHGPiBAV9uj5MaYN1QNlnNI+pHsAxSyB5/LuD02y1JlgI+dSdg1yFtgTkqq0OHPNZyJnE5oGgWsTWSZnr7rckqvzqa89z/677mXv9BhGqNmuL3H72CjizvfT/q3/kdnxj3D7sZtx9tgUSxZCwC0PH2VyXuHkXNzKGJEsc/HiFvN//ls88PA47syt+P443oJPcO5lfu2rrzHqv8yjok3uxEkuRV1e2r5KrnaQenOWl59Z5sbZGHNslK5tYa6c5dANBzHK05xrKuYcyXjQQXZ2wNhhx1thZq/N5tq3WRdFVH6CybxN1HyeaOwYxdxxRKcNfhMcEEUHhPV9ngHfqw12DCtnMXt4iiMnxyhVDL779SvMHJ3C3/HYWm/g+QrTMHEMuHp+LamQrDRmX31FJhm7hGGE0iZx4LK4FBBt7TCrt5k85uKVNDft30+grtImT7dlcOXFp/j4lz5Hjxh7coTpw49Sdm9h47zPci5PMGZw9yGDKJbgB1jFPEcnbD77hZepX7iK7iXcYq8es3xtkebGJmEQEceptw50v68JEyTxwg7UaMQQEEzekSRPIPW+DQ9XBt93tV2uJjHwqg/C/kO7+dAlhwNJw8A53csFg5yH4aTnjIjUB9bAgMkmBoGJJEowLI+YgNlh0J8k2va/47pby3rfPzCoUTYwcTKqEqKfRzCIvrwZ1WAAtoeqAgvRV0pKkjSTiEeUjb9WiogQIWRm4GidFAkLhSCfz3Po0EFMyxwUDFMawxDfE5MMj/2v/dqv8cu//Mt87KMfS+hE/WNSSFRfjnS4GJqOFUZfvlUpQRgGmZSplDLLdxjOXUEITNPsR6lSI1En4D+O+hHGFBAm/QujiDCI+sZSIqNqGKl0bFL4jIx2AradrDM5aRDFMQXTouoWcd0CJcvjwsYCH3noFGPjkra3QM/bZjrXIec2Cbp1Qt1BaZ847OGHCsuGkSNVnMoRhHmQWI0RBnnevX+CxfYIa0Wbak5iGVAtGLja4vxiwJ6iTc80MUfGqO9YtDYqHDLrfOLLz3Dy0cfZZ+Zo1rcxZMihvdOI22dp/fo/5Yab/i0PH6uQcyX5nIEhTG599DjjlwOqY+Pc/q776Xkm58/Os/Kd/8Ljj01iTN5HZ7tAdH6HpTOv8cVnLjAavMoHypr4xE0801lku9mhYO9nuz7NS08tcN8RRWNkL2HQotC+xoEDcxilGV6pK24sGFQbW1hBnTjaodfdZG6/zdLVL7Kcm6GUH6UiO4j2FSqjx/j217/Lw3e9kzwKEftg5bDtHKZh7qLQ7aKSaYijCNMyM9lRAwMVD2prDN5P+s9eoBkkM2cRuv6/jOHCaH3jOv1uIQSmKf9S5g+8VeOAmNXWK1xufIv8ZJdvrf3vvHZ5kWAqhk3o1T067ZjXrl3l809+hkfvew+uk0vXiV0tiAL80Gdy5AClEx/is584z3/6/TXunoapiTZbwuD11qtcW/ssesWk14mIyybRaIEuLmtXYQWbm445HC5JXCP5kkgabIUWp7ebSBEgjCbSMDl18hZ++t0PU6lUB0oJmafirdz92+2vQ/veKhtp+xGYDKlnwg9QUYSTczl26y1Z2L04Nobv+fR614iCFdxiA8+ro0MPoWJMbWPaNbS2sE0TdI3laz7bKy9RX3mWxYaDmxvhrp88zo3VHKsRzPvgGIJVX7F3rEw3Dllei8gRs79iMTM3wdaq5MF33MuZc4s8+fRVnLFJxm97L//Hl2K2n/kED9omK9/9c4ygzb4Td+Kte5jTRYRb4uxXnubgjXupnaqyEwQ888pZnn92hblxg4OjI6y/cIFXP/VFFrfbPL2uuT0Pzz7zAp3nvkEtp3lstIzhv872809SHrmXJeMIPb9F3mozu6/ARLnMC54gt9AmCNv45jZFex1PbzA5lsMPVihOmuR0iAyXcaMQoyTQO5eJwhgz9BC9Dlqb6LETyInbv9+z4C9toyN5HvngEY7fMoWbM7jz8ZOcvXiNc5damK96xCs+XqCJTJvjDx1l5eU1Wi0faVi4jotpmIRRQK7gsPfgASbGJ1k4v8ZS2GB53ODFZ9a5dyZiasrnUgQXd15kdSWitxzR6/rIMYvi/hm0V6JeL6Dyoxw96DBVMXANQSQlPZFjowPnGh1i3UXJbQwjz9b8Ao3Fedqb20RBogWv4lRfPtlGs0JafA9wDv13hewzw5tvcnh4dx3i6A9dKC2g9qZLTh/4ZaI5aliRKK0wPPydfeNGJF7/lKKmAOI4S14VIsmf0GoAQIx+ITPBkJTokPfckEYSqdhFG856k/X3uhvoHxVvfrh/6mAsEypOamilhpPse0bVrgsMoiQDDR4yeoTuR0vQSY0IKWRCKzKSROFGo0Gz2cQ0zER0hFSNSWcR0+/1HDY2Nuh0Olk+StqkMTAI0uRuIQTa0JkxkOTgSCKVqBMlCkp9hai+gZSCtSiOEmeuSO4ljmIUiSGTyFX2jTDdpyINGYyGHIipGIYkCiMMQyLkEGVFxUhhIpDsK1VRKNbbLeabdSzbBMvk+UtnmF60cCuj2GYLx92h16kjohCJiSnLKNtG0MLK19DxOJfPbtNYWmZzQ7PVyZErjXPP37iFuZLgfA/8OKkwrEPN3rESnShkcSFkX1lzKJ9HTZjUNy0efvAdPPfsaV6tS8ZOHMGcmOVLn2vRfPHzvLtU5eJnfp8b3vUEhdoc3obGGM8jnDIvfvLLvPOn3oNbHmGl0eQ7r5zn7DMrHJ2x2TMzy+U/+ziXXjjN5R2Pl3c0t+bh29/8Duvf/CzHKzluHCmgm6epv/gVKqP3cVXcQNxZYnQ0YnJ6hFqpxCueoHKtSVu3sJwNtFwnNppM1Bz8YInKvgKFoI0V1DFVD221UWuneeedN2CHC6iVcwh3jCt1m3//sT9LVLf6zzxRDRXZc0zrrRj9eZkmsGevnRpWVUvmccqKSxWxht+T5Jzd6mZpJBSS+WKYBiJ6M1W13e0tGQexDsBSFEo2NatDTMD48b10D83wNadIsxOws7nOxk6X3/2TP+Xe2x7Atu1kPguRLT5pZy0z0QfWlo2z/zjF7fMsNBtcXm6y3QrZ7Ck6oUAaNhTKVG+a4aYjJ5jJ7yMnTMb3WYyXJL3+IC2Fitc3fa6e2eTas0/T89dwleaJd7yDB249SbVcyRbOdJh+FLDg22246UGYOUMEw4c1b9zF9VBY7oe4DdENtFKotk9Y7xDlehRmxrJNPNQS0x2jbN+M115Fiy7SBBUboIxE0zsOcaTDTt2hs9FgccWjvh3TaUjOrfs4FYvG177NOx98kJGREVwL2lpg5AzCSGBL2D9lsl6PeHY9ZCQvyOdzXLxwlYoFq4HNtXMBiyvXKBHx8z/+GKWK4PVnnyPsSaRhIgsGlitpbMWcevyDrL34PKc/9S0qN53goXsOcOmTBhvBNN4zp7nw4mucmV/CtPL8q3/2YSp7p+hd/GO+9dUuZ671uLazTkPHVJwCd84qqnkLY/ogxvQkuuLSigWcWWI6WEfjERYjOrZPrjHP2pU8O7rLWKlCyW7hml0MSyC9CKxpdGMBZZkIywCZQ5hmlkD5g9PeiOpuuPkY+w8dYm46T8X2iLXBhJygYhb4jh/R6WzTWfYJlEC2TSbGRygWA5AOUagJg4icbWK7LuOjE1hmnlyhjDRdxKSLU4crO3VOX1phpRlQ9yWeNlDSRJeqTJ3az0xtknFc9uRN9hywqVVMPANywHlfcfFqj/nXFlk5+yrt3hoigO76Eu21NbqNFmEQovvVnFPPdOqJBXa9+xl1Q4jdyaLXxQaGPd3ZRcTg029cQ3bTSZIzBkmraRXTYapPcr1hkM7uXITrHlvmhdSJ53noi5LrDfUp8TwOvIhpgm5aIXmYTjW438G5Oun0IBKgQZMWMBvIjKb9GnS0Tynqf9/A3tD9wnm7wibJ5aToF0ETGQ87yWtIivJl6WEJMywpQhYn1YHr9TpRENFtd8m5DqZtEYcKyzIHHvyU5sSApgXwa//hP/CNb3xjV/QmuT2ZzCWdGAMqVpiWuUs9KBv3Pt0j0ZUfUJiT5yQGxgSpAUA/GtRPOtX0k6LJ+phOASllX+Gmn1wfp4CyP3ZaITTEkcC1DUbdIqdmb6Zgucw3Vnlh4yKxKbFyDnfc+xCLy9t4vUs8/NAIwgiS85WFDhWBUmhtYok8Ozs5Oms7XFro4tVhoy5YbIa4FYvGV57k/Y89ypxl01YCnySyEUYSxxYc36u4uh6y0BGUbXBch4sXLjFdMLk2b7L6TJN8PmLMgZ/90HspVgUvfumrqEhi2BbCEpi2pLkZ8cBPf4QrT34De6pO4cBe7r11L0tfNlkJZtn+6tf5zqtnWFleZ2Jmlv/hH/0YlbkJOmd+hwufljyz0ubZtSYemqpT5K45RW20TGfPLMZ4kaiQo+0pxKsr7AlW8YVPLxejZBOnPc9q3WVH95iu1iga65iGjzBipNBot4xsr4Bro2xJoENWNrZ44cXn+7K+uv8OqH5Eyezn9kQYol84Tw9UiaBf5VtKBhTowTx6g6muB9kHqSGazsVsSRAiKWjZL2r5l7W3ZBx04iY94aEsA4yIsmETGD1GRYv9xytcWJlm4XwDv6e5eHmeP33y87z3vncyOTKO1iLJyO6/BO0wIIgVfhjQVjGHjt3HxprH0vIipZkilo6pYmHnprh87izG3jmUtNmJxiiKIq4d0ZA60baNQLYD5ud3uHx5je1rS/gr2/iGz088cor7bz7O3MQ4pmkOQrzZMP+gbdJvt///WmoYDCXWD3n5hr1zwzPjTXDED2VL7yNutIheWyda6KJaMcoO6R31cG+aQORsTGkn3jhVwLRrhNEaEhMMEy0kGDEy1ESewHJtjJrDRH4fpT0jtD0XZ2Od1bUuCxcu8krtIEeOWZRHCxhILBPqgYYAao5gsmhgSmgLk3bsUBibpnXhChsba2xuC6ZDn8c+dBtHbp5GOQbaFFi2jeVIYiFZ+HZI7aQkjqfYWTVprS3iFCIOPPQe9uk2XJunsOc+7OoIeavIDWP7OHn/XchKke5kwN3jda48c4nN06+y52CNrfkGV3caTLSWKYq9dMwKa5uS+nad9ssvs5jvMbmvggBanZDJ6WP4XR+nu0wvEOgoR+jYuIbAQSHdSZS/g3Ty4JQR5hiyMPNDYWievONmKlNTCLuHaXkUpYRxk3vtMZq5AvXNyzTW1wkjQasVM7l/hoNWkcnxWeYXVnn94mVsx8K0bO596BEwNJXZPfTCDu3eNpX8FksbbYxigdroFA5ldrqa5uYG+YP7CcMSTesgVcOhJ322UfT6673R8Hjl/DqLV1ZoLq4Qbu8QGCG95Ut0N+fx6g1iP0hyCNSAY59V/9U6U6PJQF0qMZrVd+gPxBAVZDgRN2kiA+ApfEvXluujk/19Okty1hlQGDp+3aKj0zVr6NcDas1uaCD61n1a2IshI2BXn8VAoad/B0MUh/6V+qj7elCRcqUHUffUo39dX4Yd7tktpON43dwfohvJlN6U/pdGYoYAkQC0GOJfI3ZRfEBnFWctyyQMAszUU5p6/YEwjjJp0rT2gAbW19Y4c+Y1NjY2s5EdNqZIn2PfYAmCYMjhKHapWYn+vaQFrgZSlLtNzjSKMqgSPfRjCLMY/fscLqgnRD8aFOuMEie0RGqBLQ0eOHyCe0ZOcLBwBCuWbJY2OT5yhKfrr7KTU6yt1bEtGBupoEUBP9rE1AbaSKSbhYog8rP1Xo44zOWP0ItqlNqK8uY2G5s+V8+c44Xpkxw+PInIO0lOm4S6ryHQTBQksxWTRijxtCSKXYrjs2y9ep6NjVWCqM7Eob08cv8NHD4xQeyYHPd9qlOjmDkDvwlrT4fUTkjCaI61qyH5nfMUCprJmQPsjVtEl68y8Z53I3NFxt0aN80d4cR9dyIrRdojP8k7qx2ufv05gsYm7nie+nKLS1tbzLSXUM4BvLjMyqrC3Nyi9fLLzBd7zB4bo+P1kDmXsakj+D0Pu7dMuytQZhHbdrCsGFNLAp3D6K6TK86CUeXcpW2+9tQrtFvNjA4kh+rCJFgkiWiqoXUqswKH3j3YLd2bKXr1Pz+wdQdr1bCIgbhOHU1eZzR8r/aWjANPtQnxkdIhIodh2CjdxBDbHJgpcvTGg1y40MF7ZZFuL+BTX/kyN+6dZrRoI60isZYoBEpBJ9b0Ik0nCAmimLnJQxTyp8H2Gb/hAL6MaHc1RWcPO7EgzpnsrLe5Erbojq7TqXYJ/BZWHLPaiQmbAZuXN2kubyDCLpZtc9fRAzx2721MjJSxTHNX1GAw4G+3H8mWeraSnfF7zoU3+lN/MFsq75dREd7kuI5i4nab+LXLRN/dQi9IZM9As0241EKGLbpFi8g2MEouRlXSDkeRepycqBAKn5CAWESYdp5e0CafNxHVMcac/cTGHjpxkX2tFebPLfLCiw0uXLiMb1jsYw9OzsVDYkSJp3DLjylZMF2U7ASajpCM753h689eZnNnm6Jrc+qmGvfctw9hJmmPsycOoUOF8mNiKeisKypHDTrbGrswRaG4Sry2TKe1jBF02Lh4haM/8RMcPC6w1jrcdugUxugE7Qsd7Ml72H9SUzRfpzE6zoHbpjl3ZpkvfuGbjG0tU2uvILsjrC3GrF2qk1+9RDhdZMJ2sSyTOLIRlWnc0jYjPZNeWxGpHC1p0lQ+IgqpFUawXYnlFrFyExj2FLFdw3gDQeX73fqgb6jtPbKXUrUABsQixjAtnELIaCHHXaU9rCxabGwZNC5vEHgxHTPH3bef4OiRW7m2uM707ByGZWGYFrfedR+r9R2i2KPT3mF5/jJeeI1mlOfw7XMImYNejl5DExQqWMUy7SWPngZR3KEbx1wL2phKsdZRBNsey68t093ZQagAUwp6W+tsX7tI2G6gwh5xGA8MAz3g7A5zvlMvXbYpa6AvCblLPPx7DRkpYBwCeuJNPgRJHzKg1/e4vylYTv4Y8JIHYDtR/ElFPvTgfJH9pk8dUhnQzr6+f2k1tN5lUZD++rG7SOr3uPddxoxAGv38hKE5rcWwc2Vwr5rUk3ndOA1TfIf6lwKhQQJmasipLJiroe+ZHwAipWLa7TZnzpzh8KHD5PIuKo6JVOLpbzWbfVaDBgMMYfQjGDGf/8IX2NjcyApQ9Z/G4DENPe+0ToFlWck99o0uKeUg0gG75tiwgZCOZ6JFL4lV3Ad86dMkUaySSW0Fy7awTJN9+/ai4pjV1VXCMCCKwow6JtA40mDEyTGTL/GBQzdyX+0duL0x4q6Hb4xwsrqXih1xnhbRfAN3poJhjtAKKtiyCZ11cqUKEYlMvBAxYdilkLeQtWmmc0foiVm8ALz6GosXV3ju+QYvvfIakS0ZnxrDsG18wIggjjVr2zEjeXDzkqZv4BkGk/tn+fSXT9Nqr7N/Lsftt45x6q45hJEwvA7efhLlRX1FIEF3Q1ONBJ0NTXHyAGb3VYKNZXrlHIbfZv38JW77+X/MkWOHsWp7uOGW25GVMdoXu7hz7+TYKUUprGAEm4zsLfP6uVU+/7mvs3/9CmPecbZCwfZSiH9tk9zaJep2mb25CoavEGYJWa3gVuqM9iy6Dc2Ol4y3qWJ0FKHjiJJRIqTM1pbgworPasPHtAyMQALG0LNPxQFENpfSOd3XVE6mmroen+gsapA6HLJIVfrS7HqvBu9mamen8+3/s8iBxseV4MgKhrDRUuJYNZSKOFwq4N04wYWwRGvh0/htnyuvr3Lx3LNMFk2q48fIFUt4yiAEpJUj1gZdr4O302aUkB2/gLTLdPJl1nY6XDu/Au0dqvfdSOO5Z4lamtb86zTMBRZGHMyCIl6v094MQFpowLaLVEbmmBit8d9/+GFKxXxisV1nGLzdfvRaws00EilDPVCaYLBdD+zqNLpw3Sb6A9v6AEhL3mgg9AGR8jz8187DV55Hbo8jWjXoRBhhgGpcoXvlHFetgG41R+32Y8w8fAuLzSpzpeMIyyX25+l2N4hUSCFfIM55CMC19qFFFUkB1xyFsT3cdN8JPONVXj57mUvzkq5hcWB2nIuey71lgSoKLi0ExH7EZF4xFXvYYZPiiEszsnDLI9x56x5+9iMPJmHzSKBi0BHgabSnQWj2vdNmZ0lh5STHH7wFf6PC+tlvs7n2HKvKIGjb3LDjMTk+Tu2x+xm/+wFiX3PhPy8z8s4JGk0Lq3CAgx84SnnS4s474A+++jr1xWvMXLWpGA16S5qVFZexUsTE3gKGqmOpHG6hytXFZcoVj0r+MLVqQChK1H2T5foOjVaHG7SN645jixwFOYZr1Qgij1HjBy0h+Y0h6mLBYsTJY5oGplEBKXCtKnEccUe1yvIDVdZUnnNb3yTohixe2uLgjxeZnR7jhpO38mMf/HG6MUjLxtOCwC6wtjhPTkkOjI/zZDCKsGH8yN2cObPA0qUNIulSuvFmms8/T9ASBIsv06vkWaiYSCsk2mjQ24rRho1GYzo1LLtE5LfYPPsUQWsL4pgoClFx3OdeDxSBsiiASO86bcNSoJo4Gt5gh97/FOxlG/lQvDH15L+BUjTkXdf9C6aGgcjwcLZR78pZ0ILMSbwrwql3/ZmBV53WZxjOcRjIlA4HQ3YvaZkYaXYcrq/1kFBkRHZNlXmxFapvf+l0NIciB32ahB4oDWXl568fzzSJ1+hXS9YpAB8A9WGgbfRzANLky77LlVgpzp07x2/+xm/wi7/4i5RLrzBzdQAAIABJREFURbTWtNptYqW4dvUqhw4dwnHdLOoQhRFXr13jV3/1V2k0GplRkoyDQhq719XUMMh44kn1u139TKlDoQ6HJEoHxc8gVYgajF16G9l49sfftEwsy6JYLPLoIw9jmQbffuopLl28RL3uZadKBFXH5daJKd574CgPFMfIeTayC7oHdqQoGD4/VTvOq51telaZa0FAs+2w1ptjwnFZX2ozt3eMQAVYtoXtOKhciARy1mE0FUyKOG4VY+YAN4236YpXePb0WV69VOBADKVqlfXQ5o6yICoJXj3nUXYUk2ZENe6RizsUR3JshQ6jY+M88cTtvOvBW1FxYqTGMRACHY2OwDIFc/dZ7Cwp3Krk9g88xParOVqd19nYfJUVZTLfsrl/p8PhY4dx75ukduwkQSPmwu8tMfHBGVYvS8YO38PEYZNCzaR4e8DHPnua1qXzHDw+imPV6CxJNjckY+WYqX1lgvYKldIosYi5trpCqRhRzR8jV+twaTWgo0wCLeh2OozIBlSnaMUm3z1zEdMpc/e73skLzz2P70cIIBDR4PXWfbqjFCmOzwyH1ERU/XdmOB8opY+pfiQtVT8bXscHwgoiUzpLDci0QrO8rnbHmzVxvZTXroP9MpC/+/F/xaPvv4uYHo5s48gKO9qngImKm3Qii0uNMf71159l44+/iOyYGFJxYHaGh++5jw//9E8TGi7zSPYYkjCIefa7z/KNL/wZ9905xfQTf5eP/vr/xrYfk8uXINAsXV7CL1lM7HExSnP0VhT+ZpMoqKPLirIICNo5wlwJCUyXizxwyw383E88loXkMqCXDdjwIvt2+1FsKo6JwwgQGPZu23iXJ/CHyKjUKobYBzM3mPsw2Jw9n8ZvfAyn7iE2JWInQPRcMG9Bc5nQ3WQz59CZkMQnZ+GuW2haNhMFn4LToVufR6BRBNS3z1Gu5vG21ulstZKChnEJX+yjUzpBbMeU8y5TOYP11SbtTsCemUk23KN4vsVW22NuXFNfX+fVp8+yfe4lIstnz+xJ/PBG3v3uA9xzdxVTQ9BVbEQGjVWNfj0iJzSlCrihpnCrhW5rRFVgOAKBQgUBXq/Byu/8r3hj+zl9uc619hSjh2/lZz98I73Lio/+s/9CuTTN1IEDCGcMii4//isFtIB/+Q+vsHjhf+Hm3BXumHUxp0t8ytvDgUOHOTGlOP3cWUR7i6kxizNxnkJtkr0jHuM3H6UwPofpVpCmw4Q7ikZy1Vshb5QwzDKRdBBobrXLDD+i7/9qlKyRV69e5dDBQwB89/THmNw3giF7uEaMJYvsaJ+SNgmiTZrRON9aVPzOt15g63NPItoWUoacOnqUDzz2GA898BCxXWBeCY7YJjstj099/BOsXX6B4zdOMPrwz/Ab/+5X6TklaqUa22sNtrbq2KM5qlMGonyA9iUfo9VAmB46F2GrLn6riF+oYMYReVPS21ji8ne+RtDroaIgAZb9e1JKoaIIUGSld7XKIGziaUsr16bUlsH7n3rmRUrXGAKLsDt0n2nNX68z3vfo6WEwmB3rj75OvenD6831Rkbmms7e710JvH2aQZbXBxkQT6+Zqp4M03BUHA8lPA4ZM7voCQO6T3rtFLCnSbHD3Ri2PjIuPIM1dfDX3TQtKUSW9JtSpLQehjyJ8yMxSkT2+QF9KvmM69i4rotl2VSrVX76p/4G73vf+7Ash698/avcfuoU+/bvx3VdDMMgiiLm5+d54okn8H2/Ly051K8hetbw/1EU9R1OKqtgnICuhEIUhWH2jIaPpRKlWuts/NJ8iTTykBpSSYK1CUIQBAHFQoG5uVl+8kM/zh23n+If/ze/wNLiYtK/WFGwbcbzeU6OTvA/3/9eSp7A7lSQLQ+hZsGYRetreGKVxVCwXm7gPHEP+tYTdC3JZCHAVBuszT/N5Mxh4riB11umWMzj7azT2WgSB5pQTeLZB/Hye4ltTSXvMJczOX9xnbzrUB6bZsfeh+ebbLZ6HNsDZ1++wpWXztBavIiyY/bMnqTr3cZ/9fcOsG/WRcTge4qtyGBnSSHORJRrkLfAtSF3zER3NGJUYFoicQQEHr3NJdb++LfxJg7x9OlVluIbufvhW3jg3r3Uz3X53X/5CUbH9rPn+FFa3RJzd+R4x0dc/EDzL/7uZdav/iKPT4YcmsuxXa7ylJpl774D3DIb85UvPMu+coDK2yyIAoXKKHtHfCbuuolceRZh5XCsPDWnihaCi515XF3CcGpEGJx/+WV+/b/979jaWEfFMX4QYlkmhpHUrAjDxHBM648IKUmL6mVL1vVUxv4Pfd06dL2gwCAROTG4DZmUGrBsE8s26XU8lhY20rn9ppvQW4octBR4cURO+ggCAn2JEWZQ1OkQ0YsDXKn5hXf/FP/ROUDn+e8Qr66x3gn5k698ly9++0WmTtxP6fDtzPkRB2sR28tX0SImuvleIrvIlWiW7uIF7nzPXcydOIz3uc+AO4Vp+YweuY0HH56k16zzzJUlRGmUExWLU+MjPHlhCWEKbtkzwcOH9+1aVq/PM3i7vd2ElJiOjYoioiBMNlJDJprfb4h5/5A0IRPDQMdwfRVeIZC2jVGqEHQNDBlhCBAYEGyBahHaB7HcDfa+7z7M2/bQ6m4wYpg0uoJWTxEjwVtFhC0K+RKta98l0Aq/7rG5DJuNdTreFWq9r3Be7aMnXTwENgpHxAhHUh7bw61zhwmXF/jcQoORsubotOKZ4g4bSxYbK69TdVcJ734UW97G1qbH//Qr3+G9Nx1l36kaug1SS2TRxKwJgk8uYT8xie5aaA2+EjTWDOovuVSP/BxT9jJy6zx337WPqQePoKXBZz4dMF6Y5QP/5i5GDhY4882AF74YUm9AtQpHrVHWVYWnNiUXw5C7DMlNRyVXN+f5xvlNgm4Pw7KJqHHnzccZmQh47UqDnZc77Jtd4cD+iLGpWQwR0KXOiXyIEBt4IqTLBGiLRtyhYhS+P/PkL2jDs35HaWphm7zpgRES6g1G9Qwx20QCvHCDQyNT/P3H/xa/Xz1O6+lvoFc2eH29zW/87if5vz75dSaO303t8O3U1htcO/05VGuVPTfup3Dv4+RHpll3biBeOM8j/+TDbG2ucPq5F9HuKI4dMnvyHRTGrhAojW8XCUyXqLnBxZdeYO/hE+Tygktf/RJXn/kmYbcLWiGERschMQn014AwBAgjKxyVCn1nnHUpMirLwFZL3Xi7x+fNnGi7gC8DgLorgXA4+vCGc4f+3Y8qZLGGNKwwHJTQWfpv37O4+wqD7+wbDzqRApVCYpoGOq1NIQQ6BediMAaDIUh7IbLrpgndSX2GIa4/w2vmwDDIvO9id9ekYQ7xpnUmDapJ5EgHYGdw4i6Xnu4ncfeBPfSNhT6YTqMHKvDZ3Nzg//yPv8VnPvtZ3vvYY/yDn/uHtNtNTCH4zlNPobTG8zx+6Zd+KTP6gCThuB8ZSKMDURST1THo9yFGgU4qKKeGSmbk9cc9e3awK/lca/r97xtK/byXNInZsqw+kDQwTJNioUCv1+PS5Sv8/n/+Q86ceY2/85Gf5V//m3+LqRWYBn4UsdrqUDBa+AHQg3IkMLWDjEOIttBxj8g+gmme5Tdf+AY/9sAMj4wepxNpLi9usjr/Irec2k/cWyWO2hB1aS2+RqQ0wU6P5QXJZmcL4b+G7Umu6Fm6MkcPQYEI04gxcjlqo7PcOL0ff+EKv/uHTW47bDFXavGq3WB93WRt8Tyj+VWM4Gcw5RQvvbTBx//v8zx84gD77xohaOpEwGFSIgkJPreB/fgkuiXRReh0BY15g96lMcpH/gEz9iJRyeP97z9G9fgs22uCL39RM1We42c++gBOSfKl3+rRaEa0WpBzBDfYY6zGJf50aYMb4pgjByRH92gWNq/x5bNr+H7IVc9hamKGuw7NUawGnL1aZ/M7dU4ehYmpUYoVieN08Glza1Gg2aYlXHxdYvTWm7nt43/ABx59IjH+hMh+OrZJHIX9wmQGQRAhlEaIuP+OyqEpnxqZA9paaj3sZgsMvy+Dd3mwuvXnmb7+U2/e3lLk4Lf+n3/H+z7wIJb0iVimLBSaHCEdpBb4oWSxFfOdsw288VM0Y5vVTsjis8+x8dS3UY1tSnNTFI0Kleo0tUoZpMAs5vmZv/eT9AyLf/5PP0pj8SIn3nM/px57gLHeNn/ysd9j9NgBwjjigTvu4ODMLEFPcWnV54a9DjcXCzQDn6JjU8vnyfcLluxe6NNhebu93ZK2S1Ej1fp+k83xB7lpFe/yDA7Qhs48eDqK0EGItB10r8v6730ZeU1hbbYRjRaxVyAIL9GbOkrub56geGo/5CUbmwuc2bnMvtIIxdo0SI/IW0aEW9i2g9fuIeJ17MIJwiBPo+Ox1dwmbDboijzbPY9W6LLRENQ36+jty9iRj27DnBWx7Bm0yOGUR6ntPcQdR27iN3/781TbS9xx4hj3PHIPJx46wdaKz8Xf/ib3ffBuSgcrmEUjWUwjjffCNtFnP0p08m9inpwmqEhWtjTfuqCp9lq4Zz/JjflFZh66jdwDD6HsMr0O7LzYZOL2InbRIOxpek0FhklpXNCrK9rdOl/6s0vMv/QqD91ykc254/Su7SBrBxnbO055okShnGc6n8e2Qlqhxus1WV65yM7ONRyjwUQlwNzjM1OukTMrCHGIWBzHo8JKrLjBLGEIifiBqZSsuXr1Kgf7kYOvnf4j9s2OIo0WltWibEgUOULVxMSkEQgurnu8NB/gj95MSzss/b/svXesbdl93/dZa/ezTz+39/t6mVemkEMOh21YJEpW40gmDAeJg9hBEESxEyFIIkAxZCCI04wYtoAgSrEcwYokq5gRi0iKReRUvpnhzJt583q7vZ5+9tltrfxx6n2UZDpIJBKYH2Zwzn1n77XX3nuVX/n+vr9myP0vfInG9XcQcZfs9ARZWcDNzeA7JrEQnL10hh//qY/T1JL/+Bf/Z+Ld23zsF/9dzpxaoH3/Fl/9/JeYPLlCpCJ+6iMfY8LPs77f5e31A+Jok2//5r/g8acusvPOO2zdvk11d5coCnt8+FoNXNf9O2L4t4YhQ9AR3HffSy0HxcDGIs06HVfDj8KG/ixa5MH0k8YAosSfgeHRwwrSR9TeIwHLQW0ERtGAvlN/mIz6iNedMeVBK0abXf+8ngI/usfBJjmqSzBoZnRfUoo+m1Kvf0OPeF+hNQ1jeAzQZ17piUr7xtj4jfX7PSjQNKBsHMfnD++bI18wDfOI8i769KA9WIYcQowEYli0bFAszXEcstks0zPTPP3+91MuFXnp5VfY2t4eRgoODg4Iw3AIMUrTXmXzgbffMIy+d1cNYUE9JU8OX28PttE7Pk5ikiQ5kn8weHcqHSQlD4bGaAykSYo0JJZlYds2Wd9ncnKS6elp/sE/+FX+01/6Ja5fv0GaJJSKBY4fX2X9/k2aWwd4pslsvkw2U6CrTXS7wa8+/jzT9jG8Tg3REaSRIIzWabhL/N+Nl/n99Zc59cQsT3z8SeaeuIgfx6ycfAonk5K27mKIEEMaxJ0uqAPc3GW6bYu9Vp1Ws0bcDujgchgE1BOfzT1FsL8JzS3sJEa3YMWJudG2SK0smfIMU4urnJg9xj/9Z19ivrvBc89+mPd/5n1MHZ/j4H6TB7/7Kh/9Gx/BW8r0IsJCoJsx4Zu7JF/6Z8RP/0fYlzK0FNzZ0bzzMCUfNPDe/l3eX9qi8rmfxTpxllRmCBqa2ltN5j6cR1q99T0KwbAMMiVBUFU0Ogf8xq9dZUJd5eTpJtXKIt31OnLiNHPHJ8lUfIrZDBXXwTT6632nyp37VwmDLTJ2i3IhxlqImM+VcY0CSlwm1ou0lMu9ao1/+O//HR7ee0C92iKKYuiPU92frIZhHoGc6bE5JMWgAvegDokcfteM2M6GRAf0xr4UwwGGUqqX+2AYPaioZRAEXbY3Dgbz/v995EDqBFSCFgqNiRABmgQTAzCwpWLKSXhsLsvWYYeC5zE/M8n5T3yCxqULVIMWYUdDtU3Ukswem6Y0W8LK+mQMm4eRJhX7KDNCeCaVgs+FnORLE2WK5QI3rrzGa5kytlvgwsIsoQ447NS5o7vsbNY5OzfNbD53ZB3+4dh035MfRhnS+Akx9LT/KIyXoVEzCCn2E5uAfrVT0GGTuB0hLAehNEm1BlqipMS5sExoHBA4KcqPiapt6mmZpt8g09zh8Ou32a3u01Idshcmyc2tYMoYFXdQIotyMiADsvk56vESraSA5Xh4vmR2apVUgWcYqFQTptAModoM2dt5jNtvXOOdzZdoEPV48KUiaE8gGvN88UtfRcQdtNasb27y4P59HvvIOeYnDepej+LNdMDK9BhBVAxok9b1deydf4He+yjR8jkiP8P7L4AObL708hx2Y4Pun75GuRkx//zPkC2aVF2bNO1Xx9UJqlZl+xtvM/u3PkmuJPFKZZ74tI1RMnj9rTrnJyVz5y6RzEwzOVHCy3hEwuB+DIcPG6zOCDJZl8XFVWamCwi9RkdfxY0OMBKNlhbIgEQdcpDus13bIFBNThefIuvMYhh+3/vzwzP+2s194sjDcQVoA61CtDAwhAHKJCMj5rOaelbz+a99jaef+1mWF2e48PxnqTU+RjMIiNoKXWvTqgrOXJjHKedZmKpgGzZ77QgtdlCOwsjYLJUL0JnkxUoJO+uxceUdXps7zaculzgxP4Fhmuw1EuJPfhBH5agZN7GlwDQkCRql0j4mXoztAb25kqoB1p2hbqxHmtmIRUT3PLsDfU0aIw7ycd+1GHjuGNN7BSPqyf4/CMERRVeP/znwiz/qlxvY+YOvgj6cSB855PupT8ciG+PK9bC9XqXcnr4g+rD/gRHy/ZGPsbvgz+E56OHs1bAEGwp1BOLQL7YwgjmKgdGkhnYDA9jW8FpHKz2PQyOGER0GjEs9kWMKkACU6hkLA8y/iAWtdotkI+FrX/satmOzs7NLt9s9AvGJohjDkEOjYPwZJEmvPsMRBU73+OYHBsC40flo0rHWmlSPJTn3x8rAQBp4fwdsR73aDOD7PpcvX+b5zz7P8vIKv/zLv0ytWuWVV17i63/yNQ72t3n64izNJGGzGTDvWKyUSxi5Co1ml+vBJlZpFs8yEFZI3I6pygz7cpvA7XBydgLVTNl4uId7bJ8wjnjMAR22UfYMyAhDpNhmhkayyn5cwsm6FPMz5DSgBY4hUakmSKAWCA5rTXY2Nrn/9g2ub16hJWMMw6KTGMSdDMm2z723v46tQpSCm7dvsbq3wtLpeeYmJG1PoVOF5YHh9uZtEkl0Kmm9+xCn9uvoxk/RLs/hFWyeuiBI2w6f/8YiE+ED6n/4Vaae61L54AeQRUnVs0hihSkFkpDunU2a93aZfP4Z8hOSjJ7k2c89zs2XY25t3eJ4yWb+/GXiuVkWpyoIyyJAcrub0jxMWZ0W+HmP48fPopMKigdE+gZuVMNMQUkPrdvUw4c8aB7ysHqf5/7mMjtXJK+98oD1zSadYADLM4dr/4DiVIgBrMwYy7cRo3l01Jo/4hR8NHl+HLrXm66D8SuPVG3/8+QHMg6EcJBIhIp6ConoImmDcEm1BVpgGQaFnM1hPaF1WKNsF7DKs6i5BZCK/UaEarSxmhGTMwXschZMAy/V3DyIUE4NWXQp5jJMORa+hovnH6frabqtDg/ubbA4v8xjxxZZKHts1AI2Gm02dqo4SlF0DOanJn8klLz35K9efuTGSX+Sq7TPatHfhAUaHQWke2so24e9twnWmwjhIaRF1OnSTW1UxsWtFAjKMd0oJfYd0hmP7PIS7775Kis27NxZ586dW4Q2nChL1vXbaAtyro2QgiiNSNIOQvjEVonQlBhWip/Jk8uV0Nql3W6SdNsc7O6j4y46kcRti3J+gqnji7QPD0laIVEk6UZdWs3XWb93hWk/hylhdq6M5xd5/co+F8/arDXXqL+c53HjMaZPlZFFATHEtwyCuofTWEN6G1i5ZYrzGYqTUMfi7EdOo7+3T2v/Pvn1TeK9u1TvrWH5l9AqR1BNiDsRURDilVw6+zG5RRshwclkwM2zdiApbNaYq1zCdfI0E5N2SxFECbuNgFYUoZsGNhFTvkuhXEGIJmZqkgkthE65vXNAW5oou81uLWBj+yZRo87eVJ0Li88wVzmBaXqMF776qzYU7j54yPxsAdex0UmEtgIM0e5Fi5VCpwmWIcj5FqboEmxusexPMrl4HOwTxCql1oxIW23MasjMShlyPkXbRMaaW4cRwqtiiiLTWZeybSKKJS6cu0TDjOnUmty8tcYTJ48xUylxUhR6nOLnH+fg7iEzC0s097Y53N/t7Xp9mEcP4TIyBBhLzh142IbMObq35Q5iC+OUnkLIkYY+pjEPKEh7MJDx3fVoftLIEBiDxug+ZmjwfoeIHj00VsT48eNa+Z8X3B+gdoQA1S+WNQ7xGR028lYD4ihqoXf0ANI0VCr654oxmk1G66bWoBjzWCoGqK1xfNU4oqivyyjkmBIzpIIVHFFmxkUfaWV0Vz1IhugXtes7SdIEKa1hlGOQHNztdqlVq8NIx7iS3/s77b/7fu4Doscg1D9WDKJLY89BCnnEOEj7MC6t/4J7GR9PWvcTv3tVjwc5K1L2qFhLhQKnT57i7NmzGFLy9PveR5omVMwYe/NtqtV9njuRp7VXYuvQoehlKPsO+D5RZYJmcMCOsY7luIRKsddtc6O9y+R0kYYKmXCytEgIDpvUb95BOZLb117FTgNsvwCGQqkEIX1is0TXNLHtlHy+hO3mSFKTVqdN0m2xu7mDRULaNSHyKBcne+v9wQGyGRKmktbuAbubdfY23mYqk8OUimMn52g0DN69dshCKeJh4yHN77zNs5kn8JdchCfQHUF026TTyJAJbiMndvCeqGCVbDJTgoayOf/cWZpX1shsbpNsbdDdeJf65gF27gIqMWk3Q+J2L8po+zbBfkx+yUYIyBTyBGTY3Ve4Oy1myhN4bo5qCGk3pdkNOWx16SYJqilxdMR8IY9np2gOcVMLL7JAJby1toPKWOy0I+5tr9GobSGNmMyyxeymRxTHHByGhGGvSruUgiQZjcOB0dxDPA4ib6JHs/x9xgHDNWBkmB8dZ+NkC1r1EpnHk+L/IvmBjAODLFpZxDrshfiwsKiSKIVSDkq7JDpDOw7puBHVjS6eH2HaClfaTHg2/kQGo1Jk0YQYTVv3vDpxrHmwE6C9BNeeYSqfoywFHSweP32Zd1sbaCFp7OyxubXPTpRy0TdRosy9tiYWFg939inYgvmpye9LynhP3pMfdekpEAqdpCilSboRdsbtKRdJSnpwSOe1bxE7OZy9VwjvN4k7JlpkiO0MVVkgLvtkkhkC0SGtgJ70ib0CE08sE+9eJbs4Tb6xQ24/g512SdcP+N67ryPyLidPnMdUXZqNHSJpEDsWhfJJxOQCBhIzsDHTFgf1A/Y2t2h3dthc28XqtrCxactZ5mZynL50geDwkN21Bvu7Ca2DLocb30J1YwzaLJ4+zTMfeYL89Cle+F6VpaUc371/DXn1kClrggJZzEkD1dS034RIn0PoKoaVx5/QuPNQ3wqQJ3x+7Pklrrf3cGomudmAaO9N9r7zdRZ+ykcE83QPI6JQYWezzH3ycQ72E9AWSguiakKyG2IQsKOLhA1BYStG2hFKaFAKN02YnPVoY3DQNkilJrYSTFMzZVfwTM12vcWrDw/ZSfcwMj5RVRE3NulWNc3WS9iGh2t6FLLzWJbTq97ap9H8q1y73nr3HqdOzOC7JWwrRZkGhtonUUXS1CCILFpdg8iQrDy2xMbDXWZnImwrQ15Y+K5DecpHTpVYNaGpoaPBSjXdIOXBXoD0Y+zSDPOugysEqV/gydOXudnaRAG1h+s8PGyysjjDbNamExVJIpN2NmRmaZWde7f7THSjdb7nFR9T0gfRQa1I+0nD49InBezRJfYhNsOKtUoNN+oR/WBfuX3k3Yjexfp/iO9TuvkzchhghOMftDHc+o/sYUeuMkxSHEQKGTtvpMSOEE2jImcjYwQAxZgRoIfGwaOjblzZGOYawJAthYFy34c4jPT4Mc1lrI0eu/uAIakXmRB6kFA5Bs8aRhEGfRZDC2aoL/UZVwawC4BkUC16EOHpGwdpmiKF7GH6DWNkKI5FKnrP6FFDr88qgxoq/cOk4TEWo6NJzAKlxBiCa2SwqaFBMKKwHGDHLcvCkAa5XJ7ZqQmOLS3iSIN2tcH+zh5z8zMQxixJxc8s5djNBjxRtmivFgnzWWJl0ZZQVRFG1qWTk2zLbbTyqWmbu2ad78XX+VjlCbZaAWXXJOvYGEmH1rs3scseb9X3KLgmhWwWadnEpkHqOuRLJ5BTJjo0iNpdolZKtd7lcHeHVnubh3e3KOqAWBfBmaA8keXM1AU6+wes36kRHggae7s0dh+SRgmmbnHs0iWe+7EPcXvL4e69Bo6Z8N3772C8VeexqZOYsURmJPFDRecdg1icR+o60rUpzUGYV7T2YowVj5/+G6t8d/00haKPm40J1l6l+tpV5j6TQbcXaG820NLGmy1SOrlAvZYgsEm1JtyO0fUuiogdlSNoQGkzZsvskqIx0hRXKipTLk1tsNc0MN2UjEzwTJOKPYFrwka1ybfv7tL1d2kELer7++QSResgxvMlE8suYZCgUkG9EdMNUgxpEKVxP0rZMwpGc3g8gjaqhzGcx2NrTY/xTDCAIo4bG0L25pfSCqnF0cjWXyA/GKxIObRaEc24ydzEMohpklTRTeO+78VBqRJJusHa/jrVaI5SxiLrGKgEtrqarAG20Qt+aCFwRQ/P+E5H4UdtMlYGa2aSQsHHVtAFUiU5s7zElz2Pzt09bt1b58pmnadOVig4FjOTJXZbMY2dNQ5aIUnaK1M9eKDvyXvyoy5DdowoIg7a2F6O5oMNSidWEEKhDpp0b6zDVI+MAAAgAElEQVSx/d23iWobLJ/JI6d8uvuabidF2NC2Nbu6Te36GzhTWWaWVikVpmhu1/nm17/I+Q+ukillmb9wAb/sEWxe47DeZX97l1w7g33CoB46HNQsFud9Msfm8KfO0jamqHhFjEaHzVs3uXXjCl7YxitJHr94hiSZhcQkX5zjkDLR7hrPfuAyW08YvHtvnZuvv4MTRujaHZRp8Qv/3r/NiceOIwzN/IkcSRgRN8BOt+hs73P4zQqiKlC7kk4CIvMzpGYL8YE85vt8uvUuN377Ph/61YtEaYozF5E94eGdNTDsLWZXLdTdL5L4ZzCVi+lNYNmrKKUpHXfQQBApJqw2p3NVqnnBs89/hrs7IRs3N8l6JoajcLOSpx4/hXBtsoYkFYL1oE012ienKgRijnbr6/zhu3fZVZJWvUXS2mZ6Lsv7LhYouZLDtkOt+ibX7oacmf80hWIFx3ERw1DzX6YcVQvfufqAk6fyGPYZ5irLOIaHEgGtqIspLTptk3ZXkCQxrahFjQpBzsSV0Ik1XaHJmBJbQgogBDmhacWaO0GKH7ZxnRz+4iRZxwIFkRZYpsOZ5WW0bdFaX+ONu1vMLy1wei7PcsXEMF22mxFh2MHOFfHzedIkxpAxYdSDAvWD6L0bUT1tM03SvnL7CFQFQPWcVAPRYjxRtI8pF2KIvWcYfejvMX1c/cgQ0UMD5dH9V6lBH3q/pVoNC7I96vAfJOwOcMaDBpUa0IKOHdd/xmIMPjUOwRmq4mL851GUYQg9GIt3DMfFeNazGHkihzkc6D5t7FgCshDDZ33EOugnUeohLGcsWqaPMkHB0fc0jNQM7ATB8BmMK/SDpM8h1ejY+xlAewZJ1Y9ecxBlUH3DsMcz38N8p+nRaMAwh0AN4CBieE8DBiIp+nkb/Teg9XjBqwE8qmdsmKZFNpujUqlw/PhxPv7sMxQ8j+988zt89Pzj/Le/9k/5T37pF/H3uwSvv0tya4NpB4xujFgp0SYkCjQd4FB32Gi1iHKS3EqOSGnqBy20GXJ5aonMRJvDuwGJVebyvEvZitjfq9E5qJPrRsTTWbZDn1LRYXouj7c0S2biHE1jmoVsifb6Fg9vv82Dh9dx4wC/LPngM4/TqUd4dgHTn6KW+iQHm3ziI0/x7uPw1lvvsPbWbXwFNNdQhsnf+c/+HvlJj4mTiiRKOdzeI65rDL1O8+Eh4k4KB5KkKghiENnnSa0G7qen0MsWjetV1l7d46m/d4YwSfFXQrKPlXAXmujggKl5RXrrjyB3EScWGKXlXpTWEBSPu6hU0441q5kah34Df7HE+b/2HA/2Ih5ce8Bk2SMyQhZnC1w4uYB0bLJSEstJbjZrtFSI0Iu09TyN1rf5v96+Qd3MUL+7jSFjZqc8LsyaFB14cJAQlTPQtYlbLRwZ0XFSwkQQdMMhdA1DYvTn57DOgRwp/GnaMyjGZvhw7A8qtyutxubEKNqgNai0R3f8AwQOfjDjIOtkAZ+7+x1eOXyDS0urTJklSqZBnAQ0wpDD7g5C1fnA1CWuKIO2SrGTLkUHPGngYuAJ6GqNAyRAHYHpaib0DqWJGUSpgmvbmElKaEpWFzxME7zVi+jdV6nubnD72jUenvgwc4aglnXJLU9TrVd5cNjgwdYu85MlLNMaegeOWu7vyXvyoyVa9/DCCIHh+Sgi/GPTSMcg2K9Su/sO21df5uH2Ph8SXcTEBfynLxK2NGlTo50M29deI6nE5NJV3EmLfSOkrqs88/7302yf4IUX/4ALrkFpcp6ZxacRwQm2XvgNTh07z8t3mrxw6xaPPfURPvKZXyBUKSWvzH4iKbQVt19ZZ2vtXZRxk2PnfWaPfxIjexITB9uShHHI1s4BU80GK7MWf/wvv8DmepP85AwfPLFKbi7H73wl5p/8+q8QKIfbDzoYwOKiQ7bk89/83v/E4b/8BvFaTPfuK+jtNmZQpsg8LzSnCLMuT/k2mf2E619tcWwxQ9qIuPrmIVK3ieobxO9UWTlnUvrMT6GNp4giEwjpdjs0OwkF20Yq2Kwl5BPN5o3vsVldY+rHfoavvnTAz530+MDHprEyeaTp0UoFL+wGVDsP+OjMPDLjIdOEGWFSNgoEwXX+7n/9FcIVwdy580y4CdPJAZcq0yAUjzkJViaLnvARZh47IxC6Rnu3RmbiJIblckQz+kuWvZsb3Lw9QSvnUuhGXJhfYd6uULFMWt0adaAjA1RYJ3wQ4E/m2esEWJZFwaJXE0dLfCFoa8gITUdDV4Jtp0zoXSanF7BKZVwkIlE4tsHqfAbDAPvE++nWXmLrzk3urEyxPfsYk6bEz2conljgzvpDvKkVVs51aG3fY29zm2qzhRCQKkXax5L3/ez9iUS/NCjjuJ9euH4AMxpikHofalwxhjHoCz2Y0J8TpVZj6J4BFEBDn2ZV9P8bEAcw3KN6isCY13AAIxh4zMeupccyj1W/ENmgPoDoRz8GtzJSnPu5AsPzesaJFHJY12AQgTD6Sb/jkY0jz4HR2jSuFI8SnwdnDYwZA4lAC0065t0cKtzDiIEccrf3qGgHzFKPeOnVGLuRPFqrYgCNGhpyY9GBR2fVQMkfj0IM8hUAVJogpOgnc5popUiSZBiNENCL+A2ehxokmfYSr3VKP4G6b4zoQTLzyKgx+kxHUhp85jM/wec+9/PMzMyA1nzqp3+SJIqJRMSt175LbusWnXs3EdUOTxcVtSRD54MXCFZtas2AWtCmkXTIzVhcefkh076gZZfZ3N/jcGeD8mSByaLHMx9fpRradD0LL6/51GMVItvmxZtNanaRT/zELzAxswDCIOsWOIgEpY7m1S/dolr7Hl5unxOPTzK9/CTCP4mNjeMIqo0m1YMas50Wx2ZMfvd/+1329kKWz57mExdOEM3n+ObrDv/413+F/QasvdumXDKZnLCYPz7PP/z9f8z+b36ZdGuDzoM3EYcCKyqTY5qXmlO8UcjwmZLFxpsB9WshS9MuST3ijdcP8PIB6/ceEIUB08fylH78Z9HGE4ShxBEdGs02kVb4lolMNevNlHKiufnGnxCWi8iJZ3j59UN+4liGZ358DssrIQ2HjY7i21stWuFDPjY9j/I9fJWQM308EbK99za/8j98hfiU5Njlc0w66yw7MctFH0MmPJkRPOlnSOc83vS6bFwUFDKTzORm+B9/7bdoBUEfhTMao6nSQ3jbcGwN4X16gNEbltfoTQk9XA9Aj5LhjTFKY6XQqSZRCf86+QFzDmB18gwThQXu1B5Q7aSY+SlacQeSB4h0HxHH3LghCbOKUmkS2YpQsk3HMSggyKqEWmqQk9BQolcpOVbkVYwKDlhZuUQh72EIeHDYoljKkdiCshRMPXWZrbevEmztsHF3jT/Z7/IfVFxWDIFfsvGOLXLzxkP+9y+/yi/+zDOUCoXRYvWevCc/wjLYcFSSotIYkhaG6ZCGDeyCh3V8GcIG/kEV7RfI/Pjf5k+/+AV2GzfQ2RAj69OYilgoXGCzsUkalDFVjla0yz9/8GuU/Txdx+DF9RfQ6wlaSWxtcrZS5tTUZQpLDXZ0woPNbb7ypS+yev4itzt3eHA1JN7ZIXYUpRNTnHj8Z1menMTQGfa6GrfT4aDVYrfVohmEzNs2HbOJ/74zXLqUZ/veHn/87dcJ2nWe+smP8nCvwf2XXmfrXp3ppUWWPvdRfKe3cc987lk2/8+vkt6+Bu2A/fY0S/4kTxYMfjOFK//HHr7XYLHS5ezfPEYNRTF+QOHELG5mFt1osHN9j4WFM3TaPbq9Tmoj3CzlnEk3BteCgk64+Y2vk5sp8tTzn2FN+8hbIWHJIkUjsBCpQqqIp2dcdDLH7bZB3EpY9F06QYs/+u6bfOO3foum55ENPOrv7jFdMlmezlFMBNev7nMrI5mdmCc3vYJbOolpTCKEgTlVAZ0yBHD/FUm92uZPfvt1Vu+0OPMxh4P9PMn6NnNlgw+cy2M6NpsbB7zw1jYzx36SXGEKNg/o2CYZx6SoDfw0pSYMSlJwmEIj6cHismmIiOocO/4+JksZqp0QoxFQyHsoW1KWMPvs+2m/9B3a65tcX9vlpTMhnytYHDcN3IqDOHcOnYJpWpQzNpawSNYf0gqCI7kAWvdyA6SUfTz8wMv+SPLeELh7xKHe23xHrfVfy4AOlb5SSj/fYWyXhr6CytDbP6RK7h8j+n0S41foYYb6hZEGib0M+6mH/en3pX+NAaRgVG9BDvshANM0SAYJukIOFekh7liIIYxndOt6uPYMWHuEGFCkDmBWowJqSuk+U9MQiDQsDifGIgS6D6mhDxcah+mIwTH9+x5AjUBDHxYkpRwmLgPDImgDuNXoWWr0wEgSAjn2+wAS1MsrUP3+qyHUR41FNizbQghBHMfDZ2HZNkr1eOoH1z3CgEcv4iCNXj10PcZC0+uzMXaswDBNSuUSiwuLLM7PY0kTHSdoFaHiNkmi+fu/8ktUpmb5ky//Dltbt5mTilrF4Z/f3Kd09VuULpYROU3oasKsTVhPmb7gUD+scrh/gJvxOPXcAoYKud+tMbXgkxUJUtp0HJ+okGO1cp7ySo0NnfLm66+QKa4zOb9I2A54+E5Esr1BmDNYfuIYq6c+ynS+jNQuu6FGNltsNOvstzuoJGXSFHTMJoVnL3FSVfje69f47tXrGBZc+vSHuLtxyNtf/ha7GxFPPfcUM1PnyPTX+7l/55Pc++9/G6Nzn27LoBUvMOuVeV/R4J8kmjf+q4cU7BrnztisXpynTsJEdJeJS2ew9DGi/QMOHqRMT5+k04mxDKinGbxCCUNIYgWOpSmqhDf+8A849sxl5qbn2OjYHGxGdEsWsVII4SKiLllL84FZH5WY3GpLlE44m8txe3uXb7/yIle+9hWaToZcJ8Pe6w9YmTRYLGXxA7h3d5ebnolrJFSOn+XJp57mGXcF07DQOuVvhR5//1f/O8Io6Y0n3VPg1dgcGMDRxglJvg8UNB7gG87/0Rwe6sIDp8H/V5ED6FGQ5ewcJ0qrfHP9ClVngmm3TCpCDCOHa8DNG39Ie9rm0uUpiAIq0mTKNhAGPW51ramFGkcrXJUik4g4Cjl/8hzFZoprCUSc0uy0EPkM06LHh/Sh8gQHC/PcTyVJnHLj9de5/sxTLPsOE1IyP5lnrz3Frf0av/mFN7gwl+HZZ5/E81yGSV7vRRDekx8xSZKEVMUw/H/glZK02ts4XpF8Kc/Ji8dZLGyTsY5x48p3uPbOm9SSPcyixi1lqZw4iTmxw2quw+07dYh9yvkK5cIC1cPvMlfOcO3+Nt0gwvUyGNkiL93u8NLNGmenithWRMkoIhyD737rq6jGAV4zR3GhzNLlJ5g/fopyoUiqDA6rXZKgTYMGqWkwWcxyvJQnEpo/frHFxXOn2d/r0k6axJ1d2o197n7rOySnTvLkBy+w96QmxKPeSLGEpptqOjfadFoOXTNHLCMso4HppcRs86StuBY3URWbyplZ/vTtLlMvvUl5VeH4WdxCBlHIk1laIrzepiEyyLKDQCJTaEuF8OFgO8Bv7FE6UeFe1ybcDDlzssDMScl6pNjsQnujwWRGcGLWxYy7WIbF6bKLYUhiIfjurTpf+lev0KqHFJeyFLTJh8s+80WIgg6vvrnNB8/l2NjL0j50mHGmmbKnkBJsR4KU6B/Ao/P/uwhJpxlx69WbBO2ET/zteaqGz+aV61iqRC43ycZuRG2/TTN3n2dWjxPHLWZsyFsCaWgMCYbWHHRTPK3x05goiYhUwvmT5yg0U7K2QAUR9W4X03eY1L2Q+ienptlbnqcjfOoHVa699Q43Lp/jWN5jThgsLJTZPpyjetjCjG0+tnSO3/q934AooZ/lh9R9Hnp1dM0fKpBjCbmin9iK6nnnBt73/gn9g3oGxAAuMnRkj23KUvYuL/rnjQcoOPJ9BEEZv8TA4967fo91J0kSBrkQxgA7rAYt67HujdhJhrSH/fvt4e17UQU5lpNhGMZYMTU9Ym0a6/MQ+jM4Tg/YoUYQKUSvEmsfDMTwzsVIYT4SJRB9I2UIZ2IIRRpPnB7irwZwJyn7LFJ92ARHi8GNK0JmHzmg6D87wxhChkCTJH0a1H5uwkD5GhgG49EMNTzvz5bxqtkDSNF4XzQM2zdNc/h7z6trYJkmnuvxX/yX/zkz01MU8g6kXZIwpN2sc/PWdS49cQbTgmc//mmi8wt07rzI269eYTEW3Dto0VyPscom5CyE4XHm8ix5afDNF9bIFBMMq41DxERZks/E3NyoYyiJX6jQibv86Y1dvq13eWy6hGF1mS0tsF3b5sqta+h2A6+ZpbI6yYlnPsrs/AK+5xMngmo9JO20OBR1pOuw7BZwhKAVh3zzu23ed/kx7t49pBvVCDs7xN0O974do86c4SM//jR3mxo/U6TRTEBJwkTTvtaiRZbQ8FGyg2+2MLyEiG0+bCe82akxuVpBT5R44fUGE9+5Q+W4xs3ZWEYGt1zu0V3f6FAXGcwJB5EKukohLcDRtGsRfmOPyccXuVLVVLyExckM867BZqhY70g69w44OesyU5QYSYxl2pyrOJimJACuvHGfP/3GVcJ2RG4xQykx+cnpHFk/4mDvkO2wzWOrHg83TDLeKrROIL0CpiVxnF4y9Ac/9FEKxf+FWr3RMwzSXj0Nofk+w1P2x1Lfiu3r+WJoaI+vM0rrvuPAGK4ZI6fAYA35i+UHNA5G2Djf8jlfPo5vFyAOiWOLVOZRKJqtlEOxQyBhaqJEyXPxpKANNAEXzWEck6gEnUZESYzEwPBzrFoRiVLUWl3iJMYKW7SsLIZlcLbocWV1mv2ojRm3qT14yNXjC+Tn5yg6FkXHYG6ywN7KMnevrVFupyTpqNDKMLR6JNT7nrwnP/wiNGiVIoTGsCx0mqJUgGXY9Jg/EmzPJZpY4Pd/7wXSww2c2TZ2IEhUBi87iyMK7AU1wladIFRM56eYmZmk3rmD47aZLiUkYcrmQUIrbNNpaKphSrvVpX1QpWynFKc6GLlJPDeheb+KsFOOPflJVk6eIZ8vkipBrd1BGJqMZ6F0BtMwAJNGJ2Rr7T7nj5+meSA5vHOfrKpz5swkb1+rgazg5fJUZvLkTYNES8xEsna/S6ViYRVtSk+dQq1MEN3fRX/vIeQaBHHMyYUiU/kKG1qx2ahhZ7KEB22iExmiFDzTwc5kEUiSqkF80MVyHAxToqUkFWB0NGYUk+Q9CuV58vWQ7Wqbe2+sEZsp7sws2Tgh78ToNOXObhfPSZkvl7EtA9+QBBqqyiQIXWJhkklDPr6cxQ+bNJoGsmCzNF9BJi753AqVibPknDwy6pJ2OyiZRZqSHwZa0ziKe59xzObNNV75g2/RaqVk3Zg7Gyl+3qJa03Q6EqqHRLZFeXqCoudiSkEsoA24WtOMEhQRcRz1k3wNLD/PCTskUpq9sA1JFxFatIwMUhg8Ufb58sk51G6bpHHI9kPBlekiJXeZomMy4UqmZytUm8eoRzbbap8olX2F2ujplFKik6SXoApDOJHQYrDrjpTgoRKqxyC6I5gNMGYkjM4RQ6V1hHcfQnEGsBoxan+4D0lgDCEw+Bx4zHv2zSBJuAfTGeUF9I0KPR5JGKAM9NgeN2p3qEyPQY16vRtEN47o4Dx61OA6I+/8KKegZxDoMTYVQI8MhFErPcMkTfvni9GVBtGI8dyKITRIMDx2EFHpGSwDt9/3KzlDIyntsQDpPjVorxptgtaMxsnQ4z96RuOQrJFiJodQKKVUj/1q4JEdHP8IjGlo/PX7OJ4XQb8/tm2TzWaZmppEK4VjmxgCGvUaQdClVMiyvDKP6/okcZdczkdZK9Tr27z24AXKFiw/W2BzJyQIenUS7DZ0ZJlmZwdJB2mkZH2LfElQzMLqlI0tBBuHijhuEUQR9RA67S7t/UOmMorSgoEhMzhGSFDtrfennvk5VlZXcByPbpzS7naRhsbP2CidwbZcogSqjSb7e9ucP3Ga/c2U6s0bzJckcqXI2nqKMHrr/eSch6MkEpO0A1sPuxRLFnbZYfLDF4lPLRDf2MR80EB7dYIk4uJqhSl/modhwkGzgWsahLUO0RmfKNI45Sym40KoiBst4oMA6XsYSLQhUCmIjsaIY+KiR2VimexOQHOvyp3tOqkFztQ0uTimkolptRPuxBrfEcwUC1ieiWsIGgoaiU03dlAYZNOIHzteQNcP2EfiZGwmCy5m6lIozDI1/RS+4SCjLgcbG9xptLjw5GUKhQqlUomdnb1+ob0e61gvTwV6tYzG1h49Gkuj3CbdSw0azNPhOjAyxhmf+48YE3+e/MDGwaB3hpAcKy4SJwn73RaNpEtHhdQbCVHXIFQpUhhUCgWypjH0AnS1Iq80Ko0IkpgkjVAqxbMcXMMg69sEiSKMFaguabvOljJxihlKtmBiaoLC/h5prUWq4Mbdm0y6PqcqeTKmwXLOITo2zfeClG1avH7zNudXFijmsiAExrCC4nvynvxwyygZsQeTTlFolfQw1e0W2ux7DdIAjUEQJVzbqvOFr3yDsh3zgVNnmZ8tkOBjF4sEUcD2/X0OdreZzHrkKhGlSodUbOLZgmKugyU1jmeyvpVysNlgPp9jK4XmQZtuPSSSmooNpYxLnMZMnj1F5dQF/GIZlSY0+8WoMDS2YSMxSBJFK0yodRQGgslymasP7yOTLuVKjuxUka2DhKJ/irXNHeYWfIq+h2GYxDHsKIGlDTJzNs78AgRTJMszxMUc0rLJJB4TiyXKjo1Z7dC6u4NR3wQBZj4PVgbMDMJ00V1FUshBuz5ihDBkT6lJUzKeJCrkcVCUVIPD3W3ufu8hetFnRinKuSyFrKCpNNvdBByLdpwSqh7G3kQwXalw+anHefO1OxjVBn4S09WKbmqQxaFS9DhslqkUVpjIzGFrhQxaKGmhbAeBBYaB0Jpx/vO/bEmiXnKcMATNwxZXv/E6dtbmxBMrpJ5HQ0A1Sui0Day6xpQm0yUf27ZQ9PavUClyWqPSkGYaESchUkhcy8M1JVnHoR2ltBwLqSLCdoNtZeAUXCZdQWVulqBzDxXHBN2Ya3dvspwvca6SJZvEHCtlSI/PcF0LtjcSvMokcdoljUGpBCV6uPAezGYcQgQMEvKO6PsDdXZcIR0pmsNTxYjbX4ue+vto4u24HTFUjsec4CPv+vgmPdaLgce6D8EZKP5D7/vw6PGWBjq1GCmsfU3g+5XVQf/1EUXhSARjXPpNiT9LoegbSWLMOEjTkcd8gI0eKPsjv9zouxhXasae3KDdI/0ZREUG70UdNRDGYUr9lz+MSDzaNnoseXPs/O+LGg36MXwvalhXYZgPMWYUjN7mUYNhRAPbe6+GYeB5HnNzs3zg6acxTRPTMBFolEpAxThCMTc313/PAZIMh92U67td3l0LmM5JLnk5CjMeoWmTWjZa2GyuNdnf3qKYjSl4JpNli3LRxBIxEyWFa0os32DjfoQIUzJ5nz0F9b02USNC+9tkS2WKrgIUU+fPUD51Ec82CaKITpyQ6gQMMVzvozil1U1odTW2MJkol3nt1i1cGVOcm0S5Du24QCF3nPvrGyytnKLiuUgpaaYpdS2xMTAXbdzFFVRzlmSmQnp/F8O0ySQuU8dK5KVJvHaI3tzHbDZAgFUsoA0PYWcQwkKRkuSz0G4gNb213pAgNIbSOBmDqFDA04qJ4IC79x+yvlVFzGaZTlMquSzFssFmO6KVgsSmlShMDVnAEYJjK8tsPXaWuzc2MWstsmnMjo4JupIZP0vWL3LYKlLMrFC2JjDTACPskAQpQauFjlOEaXL50mX29w8Jw6iXP9Sn5tX0IXhjY3h8fRg5uQVC9KFGwxpIA8O7n3zfXxOG5//rbYN/M+NAwIBpjziN0YagGtd5UN9iZ6NN0IoRmSJTpktRCqTWhFojRS9DOogSZBISRgmpSvFMkAbMGgYNw8YSKaUMWCqh2qzTbrss+hYpKUW3yFS+REPHGBNzrN94m1e8SWQ6zULeJ2tZnCkIDi9M8M7bDW59/gt89iMf5NKZU+RzPhnPG+IMh5b8ezCj9+SHTAabSy/03E+MU2mvEFkcE+3uoXNlhNHB9hRCZmgFLb715gtsNpvsScX5rTIXn13CmYa12h71nRoP37hKdb1F+dMVZOEGtrvG8dkQEYGgjUoiVmYyeLHE2AhZzBkIaaCzDlv3Y8JuSNw8xEojHCfizKd+DuXnaSrQkaYTKvKOQz3ooGKNskz2Wl0azYSi4bN87nG++cYbZJxDpi4eo5VarG00mKjYOKbHF//VH7O09Nfx/SwSiSEFK6dy6A7YjkYmGm1IjOkC9l97glhJZqUkjTXN9YBs1uLp8w63/uBbiIUPkJudxJ8oYVgWSSclrnVp203sOae3qBoStEQmAisjMXwD1zJI04SwrWhu7dLYfoOlU6fYurqDdeYMyi7j+DbLvg1unk7QwglTUgQTBnxgaYryX3+OdvgiyZsBL73V4fST05QKGcxQsbcTE7krTMRF4t0AYRoYjgTRxvJ8RATSk2iZIkz6CbR/+WtUOsDpK0jjhLDTxp/NIjyb/MIMbWXQ3avSaWqyfp4Zy6JimSSif25v0BLEMUYaUg9TTKEwTYllCGYMg7phY1sJk1lFvRVx0GiRBhaLvkGgEub8Gdq5bbraxPRLbN+5zculRVxVwdOKSc/FmnFouxVaZovZU2dIwhZh0CCNQ+KuRgdjTDTDSEBvcxwq68C4evmoR06rcU/3SMY36cGXkR48Op8+l/kANjOMEAzaZ9yxJ4bGyaDZXqBjPHJAjx1o2F+GSu6w/2KgAuvhtUYQplE7gqOGz7C44iAS8ujvg089+BwwFMm+7iH6z0ofOXC8tkC/YY6YOFL0IjqPyBAGoXuefa0VWhgjRUn3kzTHox5DI6T3D70IgRhCgwbVsHtF3Abn9XD/A5aqEQ3kGHd8/72Oc8RLKY9gwUgNSf8AACAASURBVMfvWYzhzvSgAcYMi/7ULhaLXHjsMX7+55/n2MoKSRKhwxrlvIeyBcnBISpXwnICMlmBaWfYqe1w5fZbbHUjDmJF5tuHPPHTi5gzFToqQ6OacO97V9m9f8jqvzXHxWMZZjMmGTTEGtMI0anmXLaAuR/QCjSlgsVNw0DnHB5c3yUMAlxjG4KYTM7l7Kc/SygNGil0uik6Ac9yaIZddAyJbbJe7aJDmHArlKcnefHqWxRzVYrHn2CrHkO3SqVcwRQmn//dP+LS5f+QiYKH0JJMRrJ4zEIHYLsa2VVoU2KdmsU+t0CiBXNSkkaKxu02Sws+FfGQ9RdfQS48SX5uBr9cAC2JmzFREBCYAfa83XvHpoSkB1s0PYnhmbiWQZIkBIcx9c0HhPU1phaX2HxrC/fCBVSmSD5nUrJdlOHSiQKcMEVhMi81n37qDOVSyOf1OyTv3uObrze5+OwcRtAmrafsBJoWU+SET+POHtlCBpGLKeZzzMwvkrYjDF/ycz/9s9y9c4/Dg8Negv+gJssY0cBYQPPIXBxGoYQgHRjhjEXPlEYY4sgc+UHl3zByMOqVa7lkwhi1J9h70ODW9jaHtSpzExWW81naloGIE8wopRqlOBmDVpiQRREnIYnW5G2PIpqW7i8qhiTnO9goWs0ulmpyZzehmHVZ8m3icoX7CdgmbDDD/Ye3uHnnJnamQGmywsxkFmpVouuvcrC5yT/6X3+DDz7+GL/wE5/k7MnTo8XsqLPmPXlPfqhEqRSlYnSSgI5Jo4C020YQY5QXSFIwXA+t2qRhCyu5y1JmHRyJNiyM6CoHN+5Sfydlv93hU589zjd/u0rcTbEdi0pWUzEbxGlAQoCsB5ixoK5svMkCx58u8uXfuUd8+hKPTXTo7hkkcUrzoEna6fDER88xUZ4ga5jcrWtEajDvOKwFdeadDEbG4v5egnTyHJ8wqZgxL9+4Tab9VU6d+QV2G2U6zS55r0m1+w5v3boHrSwP7nSYmVX4MxJTgBULWkJjmoJ4vUmKQJRs0jhlrZVSdjWNAIplk6jV4p1XbrF4fILZT8/TKlpIxyCsdqnd26WzcYfC0qtUzn6WlsqgLIFlSZw+1OEglWRVjz75rZfe5MWvfYviZMrS3QeUoi7X3r5Pc22aublFjk8vsN9OsIombrvLWtZmLiNYcDRnXJO/+/Of4kW3ik5dzFqKa9pMVyro+iEyiahu7iJdSXluFtOxidttjG4H0xQ4cybaNEDoI7j4v0yRQmJaPcY3YRpIx6S50+D+6w9oxzGlxSV0YCHSmJxT4lgxy65SZOOEbjehoxS2Z9AJE/IoOlGAb1u40iQLtDF6avD/w957xtqSXXd+v70r18nn3JzevS+/ft39OpLsZrMpJkkUJc1QyRpLgjTSwNKXAQawDYwxMEB5YI9seD7IGowxgA3DQfLYoyxKopo5NMlms+Prfv3yfTenk1Pl2v5w4m1RsmTMUP7QG7j3pKpdVbt2Vf3XWv/1X7pGueCg4hDPS0jjDncOY0p5m0dKLmFhnrofoWuSI+a5u3mD6+8orOIsCwtlcha0DvdpvfUa9WodZ/4MTtKgXz8mOgrQdA2VDvj2SZJOgPUY1J723otRqG406O/i5U5AIozI+SMnnKaJYeLx6QJiiMkDfNzPlHf5L1Fcp5cfGwkTa2EMRMcGzoiqMlokRaUDufBBF4MI0KkNjA/mXYbMu5aaZlud9s5PGQij/2rgsZ8G2O9O1I3jZEANAtQY8AxQy6BmwESqdRRHGYNvxaDK69CjOk7qTdX3HF8BY8XCaY7/CGSNKBxiyCpAgq7rYwMAOJUoPYoUjCITA8UhyWC3p6nLYvxeCIGum2haOqzGPOCTj0ZYKVhZXuLDH36esxtniAOfwO8gEx+dAE2XUF4mjcB0cyRRB9QJebHFaq6GzFj4sc/7n5rD6MUcvLqDM+Py9GOzfOP36sRhTL5YZCVvUjEiorhPkvronQAt1GikMUtXZtg1A772zSOSs1d4bL5H+4FO6kfUu11cS+Pqc5eolGbJCsEbVcWSaWFJRT30mLddtIzBrb2QQmmGhaxEBR2u379Dpv8Frj7yy9w9sLGMJlljj1rrVW4+2INulgd3AwpPguMOPONGBD2pMDQItrqkJQtpa4RhyrGnKFmKeh+WVk1uvbxJffOQxSuzzD2/TMeV6KZGZ7tN68E+cfcO+eW7lC/9OO2kAJbA1gfGQZwqmokipyBKBV/9wy9wuH+XuTmN+QcppSjg1dce0Kus8PDGBjlnjnaUwcjp2F2PB3mLSxmYNxQfWCyz/Pef57u5Fip2iHY9CgWbnC6RvQC/cZ9WQUMwS8vvUU4EJWx0L0AYGtqqyeXzl7h47jxbD7YI/IBYJqhUInU5zIGaRNYm1MXBHEqHhc3U1Pwc04lgeF2NrqbRlf03CBvw/8U4ABI1sGbe2N3lC999g5t3bhIFKcpwefbXHsfOGBQQ3GsFnHRDHp636YQp+SRk10vJSsmcAToJB7FkxVLoKh3wjRHErk12NkPtte9ycO4JZlRKlxapobNaOEthyWJhweIr//YF2kc1Qr9NmgZI3SC3MstcPkuznRJ6Pi+9/ipx2uc//Ue/yky5MvYgvdfea/9/bVJqpImP1ARpBFLTEY4LykO1H2Bay/S9PqCRHNVRR/v88LWn+PxHTX7s6Sxv1QJefP2Q3v0aWaGoHjZYOJtnb6tNLg2wgz6JDioMSYKYnmGhzCX8lsFBNeGw6pNdyXHZ3Gd7G+I0QOYtepHk/s0umcx9nvtBRT+Mqe8ChmT1gsF5kaUd96kJk9l5kxyCqFfj5uar9Dpv8sy1X+HrjSJHe9ukrXvQ2yRJ+zy2OMNhuE4xX0DXNOJYkSag9AEu6tRTrHkX0xhgN03TWHd9dh+0+PY7TeoPDjCiQ5bX+qx95Dmq+3sUF2ep3a1ytLNN6G9z9WIIoU149FWc2edQ2jqIPAKBrgtKuuDFP/0uX/vcLQKrS+FMhdbhNl96cMKVp2ZYKq+RpC612h7f3Nlk7ZFPUTEN3nztBjfvHxD2DilluqytprhOlZnFMxSKReLGMUkU0Wo0KPcky5k6GBv4+DRvv4FjOJSWLyPJESUaukzRZvUByItCRMb6vs8/IQcFmaSmY2VcZlaX2N07oPjsD9JvH9K700RGOqXKAh/9x08iBaxpGt897OMYsFow6McKPQl54KXM6QZZHWJSThLJIgoDKOka/URgFbJYQZ/63Tu0zzzCoko4UVWKmRnm8y5aAfRMxFt/8k261QZx1OK2StFdG3u2gJQCL7QRcZVM1sYtF4mjgDSJicMQoQ0zhYf823GuwNDtPmGPTMWSp0Lv0/z90wM16GsUGZBDA2Hq5ymKyuDf6OGdpum443dTl0YrD4ppqfHz/N0UpHfvx/fcx9F3wz6md2eSJDwB86fyEqaCI+9+Yo7GbkJfUKRxcnqhv4KGNF0jYJDYLMaF0UY1EAYGl8Y0mBkrAU3JmsppY2wEgoYe1DGViUGQYKQYNMgZOJ1gnMQxUtPGkQYBaLpOGIYkaXIqIiEYyL8iBgZFkiSD/tR07YaJAtRkXEdeXsaJ1d9+6SXqjTqPP3aVmcosmpAIwySKA1TcxlANjMwK/V4PIQyit7aoEPGRJ5/gtW6GH386yzf3Aza/fg9V61JyJbff3mPurMXeA0U57qOHCUnsk4Y9okjR0x185VKrSo6bHo1mSnnR4py5z4P7IMwIreRyuOXTvdvAdbd47mOKVj/m6D5kz2icqVjkdEUn9mljcmbFIoegXr3P7vF1omCPJx/7T/j8SZHazg0M/y5efQdTRlxbmuUgWKeQcQFBFCmEglQOqm63qwrnXA59yASySTG9gL2tHl97o05vc5ucc8i5Kw4Ljz5O43iX0vIC+28e8mDrBuVsjdU1D5FIoqMvkVn4BKlcQxMDIQpTFxSE4mt/+BIv/MENMhsKs5hhv1HjQIu5cK3CRuUsfmRy/9YbaNlFls99gJKu8car17l+Z48/Cw9YnA2Zmw3I2C1ml9axHYOkekgiJMqHnCc4V8ygWXkaYR/7pIqu1iCpkBoOXqqh6THmssN//k/+M4q5Ev/q3/yPhFFEOqqvESdjJ8NwWg2vHcVA2W5UYXxKgGCqdseo1sZgpe9xIf81TfvMZz7zV/7467/+658B+Nmf/VkuX7586gYWhCG//eYB92oJsVFALiyz9Okf4yPLqxQ1nc1GSK0bYBKT0QWt0CeJAmb1lCBKCJSG5ViYOmSikFhAJxlwXR1NoAtBnHF48OYbSNci0V1IJXoaMFdwEDE8+rFnMDcuEwtF7HeRTgbnwgUKD1+kt7PDE5cv8OjVy5xbX+fyxlmUUhi6cfogp2+s77X32t9xG4cJNX1AJwr7QADEpHGEki5p/QCVJCjRxdMEbaOMDFyevnqJxcULXF0vEfQ61BptNFMnt2rx8DWL7nGI2Q84rHfZ6fnkCzZ9JfnjPckLX2ly7yTgoB6zvxkT6xLNNdna66AcjV6k2Nvts7nZ5njH58d/4pMoTEqOxNHhuAP7CE5SDdtLsRNFrXXIYWcP27V47OIn2I9yHN69warTZalk4hQruCtnsVauUa647L7+Tbzru1gdib1YxA/AtsDJgmEN6B5Rouh2Q2xqfP7/fJ2Sfx03OcHVU1xTp3N8n7mSzuFxTPvBAW7kk0899q6/QbPVpnZYpN++i66qNPyQNw4F9+/u8dL//Bk+//kvs3P8FikHSD0iLc0Sbyyzfb9HI4qIpY+dzTBbLLPYfY0X3znmx95X5mOPzvHoWYds3me/ucfuq0cYxTzb96pksy6G4RAFNsI5QxTNY/VAhT1sRyeTLeKQR+9GGLkMVMWwei0IQyBM7ftCLWo2m/zmb/4mAJZtDxR/dAN0k64Xotku8x/+j5H6DHpuntLDj3L5Uz/Eh5dWKEmNt05CvCDA1RS6hE7kk0YBC4ai4Segm5imga0p7DggFtCKEyx9EL3RdElk6excfxOjlCPRMnSabVTskbd1Kk6WJ3/4eVi9iN+tkqYJslDCPn+OyqOX6d+9h57NoGctYt8jbDXRNUESx+iGNqb4jAHy8G/ko5aaNiiiptRAtSgZKdAM6TXDcZJyMA/HMp1DED+OSIvROgw/TCg+MA2nGYPXcUdMQPrg/VTl0yH9ZWrV4RbEKeA5ShiWQyrUmEY1XneU1Ds8bqkxYh1M+p5sR9O0UxWhR4BDjfuawPeBl36UJ6FOrzOspzCdwDsyeE7lEMC4wvHYi68mY6iYePTHxsvU5TGd9Dtal+G6gwjC5Dsh5Xhb49oKQ8MhTQf1CEZqUUJMFIdGNC8hxGlZSTGSlp0yfpJkSPkak7IYy8kO50zgB9zb3GRtZYG5Ug6lAqKwj0rBNAuo5tEg8qJqNHUXTxbJyBLvu3qZ+cXzXDtXYGf3AN8PMbMGpTMOVx9xaOz2sfpd7tV6tBVYGYd2YvDH+xp/+hd1qpHF7nZK9ViR6DrYBlvbbbSSQb0VsbXVZXu7R6um+NSPf5wkNZjLSpJYcezBgZLUUh3HS3BS2K7eoxM1KBVnubTxPAdhlv2br/FQJaFUcHAq87gr53FWHqZSsbn9tc+h3+li6TZaPkMYKWwL3BwYxmCe+GGK73tI/4QXfuc1lnkDM26TczT0NMBr7FHJa+wfxnTu7TBjgaofcXTnDs1mj+phEa9zA8doc78leGc/5M5bN/jO//obvPCFr3LYvoGh18DSSGbmCBbm2N7s0kwjMH1yxXkW7ASn8Rav3TvhJ56d4QevLXJuVZKaLQ6P9jl4p4HIuNy8vsXy6gJBP6Jajai1XTSxgdGM0fHIV4okfUlSi7FjiZ7JIKsaQhcg4e79e9y9ewfP84aG80SCdGSQDgzmQRRunCUlOHUNTfKOGBvfiqHU8DDqkCQpcTQQnvjMZz7z63yP9reOHIys+t+/v0mt7VN0SuSXFylfnmeuXGBOGjTDlG6nR0aElDIgVJcSgjY+QuRQDJLtTE0jiH0CAScHLexCDjIWwtDJGgZZM0MUSjbrfZw0JisiMsUET6VUZhZpmCYfezjPk8s5bt9e5eZrrxJpHvkoZu4Dj+AHIXebVaLEQ9d1/MDHNE00qZ0a9HHIdOqG+157r/1dtcHUHKpjkKCiLmnYJwkhivPEWhlL7ZB2qhh6iUxxhbRtUtBAC9uIOGaj7CLff46ZxTJr+SoyV2Txx1Puv36bg/tNdmoJx57k5H7IUarT72tkPI+MijCkjm0I6kceXqzo1BKWywb5RZ29TYuWn/Df/Nf/kh/7iZ9m49xVZnIFNE/RUYJizsRNUjp+gu0WyWVdHEPS6greeP1LbMwtoWSear3LSb2Koae0wy6R36QbBVR3t7nXCnjosMrS+iqr5wqQddCEotsJ6VWbOPv3+Te37/OT15b5+ss+WqBTKblkjQzmcYOj6JDilQJ7okMvzGHqq4RlnYpW5c79kMquzc7NmHp6h8PWK9Tqh3jtFs20jS8jwm6IN5tl9qklKqKA1z1EOSb1VodWs4lumBxZEXnh8cdfvcNCUbJWsTlbNji/sEywXqErdQ6MEE3LIjVBphhhyQ7Hb7aJ5y6Q6SRovSzxsUEQVrG0FG2nD9oMyYFJkpGIGYm2EaMvuxOex/dtDg4eMJqm4RaKPPKz/4AeDnlnhqVLD7F6YYHVcp45YVCLFK1Gg9mcIG+DrgIKKLrCB1EiVQG6pmFISBKfADjZbZCZLdOT4OiSrGmS0V2iUHC32sXqS+ayAs0wEKZNOV+hYVp8+vEMDxY/zfVXX2F7d4uEPnS6FB9aRqSSuLpPPwxJoxjbtREixet6GKZGjCKNp8LuQ7qRpslJwukInIvTnn8xxdkdY73hKqMgwLRa0OB1TLqZfDlNQWEAWqefN++WJB3lMZyiPg3BqRRiUHNs2EMyxek/xUmecoClw6rRavjdmC4zXHYQMRii7jHA/h70KoYgeIryMNgejPj5A2/m6PvJsuNjlQKJHFN1pg0jGEo3Dj2o08bItHLT6MhGoH3amBlECobncpoLNX1epyMlafqX8lAGcqnpoCrtKKox7EuNjImpfkae3LGcqZpU5mZ8LtPhsQyAXBAG3Llzl36/S0qE8mvIMEIpBy/UQCtjqy3i1gnZzDkScx68LHlNDe/3AZdXymysLzA/a7KQ6yIzBeZ/OuLmi99l/3bASUdycy+luhdxrHTaEcj9Dk5sYRkGukxoHPXxFPSPQy4tWqRzJs2qyUG7yz//r/5bfuYX/iErK5fQDQM9hEBI8hmNTJzQ8FOKhXlsfQZNSGrNkDfe+BpXzqzjpzbH+8f0+x2QinYYE/pN2nHE527f5Gynx7nbq8yvLrK8nsfPOugqodrwEcfHdPa3eGF3n0+/b4nPfrnPjFHELeRxVYw82OfYO6TycJm7qknoL4F+AYoFsqrJvXsh87sum+/4HHmvcNJq0Goe4nVatGkTyIi9uqK0sUDxoUVyqYXnHRHbNsdHVaTW4siUZPQUJ+3y7754k7WKzsaMw2PLOteWzuBf9mmlKXaSZXvrgJlShrmVDEkD9m5ucqAtcKHkkokrOF2BEcRozSOMkxRpL5DUEsgLnp1/iuhHPX7rf//XeIE/UMgSp5ku6bBYmhhGria3GTVxNowu32lcqyZFHU8l3f817W9sHEw8H9DsdnnzsA5aytmFIjOLFbT5GS7oCj8VNPyI1IC8qZOzoe/7NPoJWcOgGytcU2KZEkWCoVJO6jXq7YS42SRTyrMwU2Ypa5GxLYpzGTzPp93z8I2QxJQsFJbRDZdKnFLOWOSXl9Fsk0Qp7t+5SXRcZ25jluT4gPZxgz2/xrevv8SV9Uu4jgP6sBLjqGblqdAvgxPynoHwXvs7ayNvpoFI+pCkCGVCGiHS/tAD56LrWaTpYJgWHT2PpdVQnSp9X7BSeoyFlQx2LuZk/0Xq7/RY2MiB0mi3BO12TKvn0aynpGZKxjTIuAaOKbFMhS0i/H7EYilL0I8wE4VraTz3xAxbDzzeeuttipUFjo/7rG1cYnZpCVuX5A3Q0pSEBIREYtDu9njn/j1mczl6okyjPQDZYa+JYQtyxSVKpSV2cnkO7h1xv1GnfzukeLLPxTsZVLZEoivCOEJ4fSpelUKgaOGRWZ8no+dxpEmn38GNYrR+j3Z/F2f5DP1kgX6awTBm6DaPWXwM9m908fe7+GmPKOrQ2t7Ey9i4CzaWcOlHKb7q0zncxS5pXLuyQVtaGIFOEvl4AnByzMge2/UqvVCx17TohS4lx4bII+wFrLgWQteIiSH2UFHI/GwRPe0ivJjE84g80Po6umUikiYib4HuoEwN2ho4CfqS8/01DOSkqqam6xTmF3BXz0MtJen4lAo51mfnOKMr+gnU/QTD1ShmdCwtoeeHdPoJWcOkFcVUXB3LAEECccRJs0mtHXPcblFemGO5lCNr6GRci8J8Fr/do96KCXIe5Zk8lVIOTXcoBQlOTufsxsagKJ1tsbOzRXrcoLA6S3y0jyc9skUTU59FJjHJ0YC7rVSK1CceXZEOnqxyKvl4LLU0vgKHn0cA+3ucgwGOnlapGfnRT/UyjiikY7rSZPmRbOEgODAdAWCcUzD4acpNf2r31Lvx+/DHMcYfry/EVCRBMKDDTEcGGEVThtufoiicAtIIhJQDz/kQCI/3capNfx5TeqcMrZFRdspgmsozkEKQTikFMQTeI+/8KLIzHozpY1eMx3aSb/iugRqe37Hs+eh8j/ubGBHj4lKDkM4gOjFcbhwXmOrvdERheE9/1/kbJUs3mw2+9KUvc3nFQUNDIgdCLngoaSBkFtPyMSybIHHxI7BkA9U+oeuZXD33EYyiDaJG/fBNmjs9li7kiSKDVjOl1o/QnJR2K0GZiqKp4Vo6rqNhS4VOROTFrMzk6LdCRKRYm3VxH7HY2/N54823mP/SV7h0ucfa2QvkS0UwJFkDtCTFJ8aSBnGiqHWabO7uMpcr0FRljuvHtNtNZNjFsk3ypVlKZYu7bpaDG7vcOjmg6nco7W9z9qZDmquQyBg/iMj4bXSvSS5MaeJRuLjKTGaGNEnxujWcMEbrezT72xTOn6cTzqOkjsE8XrvOYgl2XmsT1Tt4wsNv12gd7+O7NtklG4csLT+i5zUwqoe4hQUee+gsTWHjZmK8OCTUdTTboESP7foJXV/woG5T9B1cCanfJ+p7rDmSaqJjyBgtibGkIjuTEnY80qYkanUwAwctMRG6RMgOqpgDzUI5GrNLJc5V1nEMexgpEANJ5qm8nXEkbXwvOK1gNHIkTEfoxnNzRFH8G2Lbv1XkYGQRP2jU6HQDLA3mZxxmKlm6SlLRBEdKIdIEN2ti6ylCJfQTjUMvYB2XWFeUXBNLF9T9gOOGz/bRIUFqEdaalPszWJbJvCNxTMnCcondu03q7SqRnkJulsfKeQ6bMTNKo9NP0RyNQmmWtYef5N6NLXonDXrLWeYyOmbR4KR6xBe/81UurV8gHZY/13QNJGMDYXK1MlBOmHYVvdfea38HTUoDjYhU6mDaCNVFFx2k55NqGaRjDh6CfhfN1NHNkKDeIAjmmF16iEy5QK97l5vNHDuv3ySJPHqewnZdLCnR+hpduhR0naImsRwN3dYRUYKIEhxTY6Gkk+YkzVZCFOs8cilLzsqR2etw994b7B422dg94eFrV8m4GvsI3FigpEVKTD/sctius1Wt8b5LH+Ebd9t0u7s4okUpK8lbLpkzK1S0iL7dpdcPaSQe20mLlt/n4CtHzOUXaOspdsFgpmzTtXSee2id7xzs8vDTV8kX5mg3fA7euUvQilgu2Wx3m8ytP4nlLFH3NGI/Rth5rl6Z5YQt6i+/hiF1Vi6cxxdt9oSObsSYFYe8luJ3+vRv3KR9XpFdeZyMgNJsBk2meECgZ8lqx8ytJohOzEknZa+XcFRrE3ZPSI7aXFlaJj9rItKUXiuCns+55SLJXg0/zKJ3Y2Q3hsAibZukSQsRO0hbgWmjpCI5TqY41d+fpmkjmgUYjs3cxXP0+yGmnoKT4uqSnNQoanCshvliJRfLUKQRdGPBsZ/iCodYS6nkXEKVUO+HnDT67FYPCFKb8KjKitDIWxqZvEPG0VlYLrH9Tp1a84B6apCplKjkM1Q7MeVUcNSOKJVdFtfO0/IF23cOif02ubVFjLSOsAPshQxJZNPeO0INk6MVEwBLolDD274UDChEY8Ng4I0fKYbAEIC+S1Z27GWHsWKOkFOmwdibN1x+GDUQ4hQ2HLfpZMORd3/4w3j9sRToiM4yNDTUKBIw4TMxQQtD/DtVVXhkiYzUm6a/FyPz5hTIH9EXxJiuMzrWURBlBOhHtAc1BDCTYMpEOWUE/Ef7q5RCqEny8QifTyswjfj76anzMqVMpIB0SPfSJ4BqenzlEMyP6xiMoh6j8Wc64jEVIZmmAU2df03KIf1seltqnMcupUClE8NCnAJyg9yJUZTI8zy+9tWv8vOfepRsYQNNs9Bliqn1EWFEbOTRMzZRAsQ+ugm6FhD4dQJ/jfVLT2GYHkfVt6lWHfbfuIsiIExN8jkTKTRiX+HRp2AYlDWBmbXQpETGCUQpumWwVDKIXMFJLaWYt1i8ZFHMxGwddnnjzZe4v9Xk0ScbnNlYxrY0JAI3kqS6RaJ8mv02h+0G9a7HY+c+xBfeqRN5DygYIaWMTj6bw11ZoaJHVLUc3VqLbrNJL23QaLXYeaXKYmmJYy1kds4hlzXIuzZPrc3w8t4e73/+KWy7zN7mMd5mk8SPmSlabLYanHl6DREX6PoQB3n0wgyXL86w3btD96VvUlgrYy06xI7iSAh0M8SaK5BNffonbfzbt+htJOSWHyGDYm7eIVIJnjRJdR1XVllYSxDNlO12TLMekvY6xN0qquZxvphldWWGWr1Ju94mF0vOz5iI0Kd/7CDDAJHayNRAYILqotIW0i2gQovUehV/qQAAIABJREFUSFHdEEs3x3NLCkk6fe8aXaoj+1VM7gGTi3v0MjEgRiv/bZzef3PjYNh/lCZcbxyhpQHpSZd6qURGE1R0BZpORqWs5jQOwoQwDGmHIa1Q4jo6W52Qq2tFDMegFwQc1Nr8T9/aISkco3XhUdelkCZ0Ol2ObEXezlCyF3nFb3F8skm2nCdXeISy1NkKepzYWdJeRFYK9JyB5WQJWML1b9LY3+eRxy+yOKPDzR7KSyjli0hNI4ojwjhA03Qcy5ka8KGk2ti6ei95+b32d9eUihF2FhmFqFghTYuIGNG7Txhl0fQyfc+j59eZWSzTV1lErkJu9iyabhO26+hBhw9fvsTNoyavX6/StjUuP7TAo+sVmjX47W++zpNLLolhkKYxcewRxJIwEVRmXcIwwMk7FAybVlPxzl7IwvkZPn01z0tbdd66dZfPvnCP3/3sZ8nrCmUZnJ9ZJVM5S+KGJKqBHWlsXPs0n/3yMbt736ayklI8v8bM6kXWzTx6IcurL3+Lw709dBGRndPp9gWf/KGP8/t7f8gzFZNDGTNzbpaV80vcq4fsZ3Rq7ZSFxUXsbAkzD7aT4fjPbmCunmc91en3Y/KZEEPP8cq9Nh/60BLCNnj8Yxv837deR0s03veRa2Ted5nudpPNF/433AWNS1eKlIRi81s71BoP+L3PRzx57QrefJaZgkvJcUFmWcyV0OQ8SaXP2dShFUQcte5TO0p483qPg+M93nc2oJIpI/0CXqfDYXWLWXsdIy7jJDO4wsLUIlSrh6CBME3QbbBtiFOS/eD7Pu8EA8AsdciU85z/wKNUuyHRfp1zT1zlzNIsRV0gdUlBpczmNTb9hDDs0wsU/UTDMjU22wFPnJshNjT67Q5vbtf47DsHxLkqtBXP5bOEYUC93caUMa7hULYX+Ea/RvXgOoulpyjmZsgLyX7k07BypP0IhIbtmFhuiVAsErXfxD86oFy2KRXyeA2f4+0mjZM2KSlO3kKzJX43JPJjSMSgcLJSJNEQ3I2Kcw1zYJUQJHEyedYOHwupGoE+NfR4q1PPj8GFOzWYUx7vAegcwc6h82kKxKZquB/DKs1j4Dx+Bk0TaRhHEdT0h9GSU9tVirG3/ZQ0qVIDWtLYFhkZPN/LMTaquCpQaqgslIw4/GM3/dReMjYQRsehGFGfJonCaiqBe1AddvB+upLzqOjZqIm/BNbVNDl4ar0p1ZZpqtbUeZg2NAY0rYmxkaSTGggjj+xYyWhqG2kqpqIDarysFBIlB0nKQkqSsZLToA+VJkMjXJJGEYuzBTyhUzAHOTJBmoJUWMkOUVJGpvM0G4cIMyZfztNPs8j8DIXFi6g0ImrVKUvFhy5f5E6jw3dfOsYruHz4yXnmslm29z3+4votnl5yCQ0dFUeEkSCMBanQKM26eH5AruxSRNLqKpqpYv5ymaceLfLVuye8/ubrvPI7b0Oi4eoKYZlcmF0jM3eJwKpC2CHvzDN/9sP8yZcO2d75CquXbTIbD7FQWWHeyiJck1e/822qe7vkiopACYr5Cu976CE+d/QCH60YKBIevbYG2Swn/ZgDS1BvJ6yvrdGNdVacIm1D0Xt9D3P1DGcTnV6rxdJckQf1hONazIUnZxG2yTM/eoH/4etf4IMrZ7l07RzZzpN4u3Xuf26bwrrOEw+v42832b9dpXF8n9/9vMczTz9CZDjM5bJUDBfDsJnJVDDkAlG5x1pSoNY74aS5zfGe5O23d9k9bPEJ6eIf+HROfII4pnSQUhEWuneRnLlO1jDR/BDaXZANhGmDmQUb0k6IOgmQQkNKDZJ4Qo2bvmbFUEY3HdUwmEQCGVHv4NS1PqbRSTG8+3wvF8Xp9reKHKSpIk1iNtC53qjRbcNBO8LpJ8xnJbaANlATEKVgCB3NkCSpohyHbOo1CnaRrK741maV3/7Gy5wcfwPvt29ipDpP/xe/Sm4xT9D0eeeoysc/+AjS1alZh7TDY4rYFPM27VhwN7L5UNGg2Q+wlIYrDDzdIDu3Tu/wKxh1xRv7XR45N8cvffqjLLqPsNW9y7nSZXYOHvDKze9iWw6ffPZHsS17eAORk6t+7Pn43uHS99p77T94UzFCdwYPm6hP5PdJJMjco5D2iVo1LMvAya/gH92m0T7i3JM/xdHBfXoPbqOCBK1UInBcHvrhZ2n9X9+GuE+3CW++Xad31OUDDy/g1E9wdZ3UMaiHGq0+zFkpdlaR9jWqLTAth9lZm6TV4+BWFfnww6wsFMitw/a+z4M3WtiGQrMEfqaMNROTCh3dfZTKueeo9XRu3fhn/MTPf4qHrz5BKT9DHCmqTZ9q1aPZjnCNLMvLa8Sm4vbODXrVhF/7p7/Mtz/7F8w+eoX1yxvMFByceot/8Vtf4PzzH2LbrDBv2WRMyJgavY//DDe+fYMzj63Q2Y+QIsLRUrLvRHjneiwVS+ybJs1Cnruvv8zxH+7wI7/0y2T6oF38IM3tV7jvdXnoyjwf/5lneeXNt/jOvR7f/NaXWKvElCwIejrbzRxXH/8oi2vz5E2Dsws252YzPLp4FnEp4KPPdfnSt9/k1tdvcyHSeeLKBTphwEEjZPe+h767z2LQYFEU0fU5pFsBZxlMidJMVKoNwKKljXXnv18tjhNMy8ZyHbQkYfelV1HlM5zUFCvCRaGjJQrThL4QnChIUoWrWfjmIHJcikMe6A0qzhwiTXjhxhYvvPUyR/uv0H/xHjLRMX/rn2ELi+O9Bn6tzdPXLqC5BifWFj2vTtYWOI5FM9F5kLh8OGOw0+zi4qAE5K0MbnmR3v4XoZGQu7jBo5UC0U6VXTPlsfd/hD/9P/6C2eUs5lyGk8069a0GkR9jaoKwH6OEQtMFSopBZdJ05NUeRFDGAJfBA3cMWoeUmmnezoTHzru8eUMmiibGOFowpJhwClcPqS2TcyHGfCM1iRSMwftUvYOp/0Ocf5qPPAVspxV0pgH2xOyYWETTib9JMjBaRoB+OmIw2tdTsqFikvysUoUS6QTcTEUhgKE0qBhHJKbbWKVIDHJgxlSn4e9pMqrPMCwW9S4lqEkoR4y3Oxo1ecroEGNt+fFxDb3+pyIsDAy5KIoGVY4tCzVMYE6H82VEZVIokjQZiEsk6fhYxttEjKMpD197mGxpFSebgzghTmLQNVLjcVB9vPoB2UIBEo/+/iYdv8PZJ3+K7c03CHYOkKYLORvlFrn6yQ9ycvR1lBmzvxdz4B8RegHvvzKHXTuhYhhEOYO9piRNoOKkWJmURGocVKFQKLBopQQtj6M7TdKHHuL8So7iZcmt11o09z1MQ6GZOr3MDPasRxRkKKx/gMzsFY7rPW6/8y/4hV/7GR669DSOYdP3E+qtgE6tR6sbUbQLnL98le3GFv1OFy11+NV/+g/52u/+ERd/8BMsbSxi65DeO+R/+XevcP65j3BPuhQdg4KdYl68QGDkeef1O2w8tUbznkchk5A5SXHuhgRLfZYKJvdti1apyB+9+GWuxXs8/AOfwPUV8tLznNz4FreCHo8/ssK5i6tcv3WPVx90+PKX/pzLSwm2kjQ6Bu14lotXn2FxbY6ioXN1Pc8jy7PYa1dJHvY5+liXP/vqy3ztT17lI49eY2NdZ2tnhxe3O8wHJuVOHVOL0M15XKOEcOchcwYsbVAEM4ZEKEKREsuRcsIAzKdJOoxOjubgKAo5mbuDyNfgczLt7BZiLIcKg2t3umDhX9f+dgnJAsI44ms3X0MrrBBWD4l6fVIvGtM1TQV9TFwtRiIIEBTTmCDscHFmGakZmCImu5jDvrxO8uU/wFhfYukXf54feexJmne3+ebt22jFMugOpbyid+MuXqNDumiicPCEzrLfQ7ds7EJMX2j0Q4UnUjzRolprgm3xUD7Lxvx5yoXz+MIgY5fY8n+PN5M3eaWxy+6dHp//5p/x937g03z8mU8idfPU4b47Wey99l77fjYVd0BFkPposo/r+iSRSaIEqddFWi7SyKLZLubG07hen1deucX6mQILD19FaINIWKoUui2YeV8DM6hjJC38apU7Jy1ypsGxHxPk10gPu7haSHnWJhUe+8dtak4Wizx+z6JTD5ENn6uGw0tfuk3SVVxdLPIDl1cp/8qzeNkcudw692JJVk8oaAUCL8vbd+q89tl/xT/+jX/OY6U8upAEkaIdJvS6Edev3yG/UOJMocRJs4vn6bz/yofYmC9w+7DD/V6Pcj5LS3fZ3vPYfOeATnTA3t195j+wQNtXtIXgUs5BnV1gZTHHTpAwL3TcBJK+x+qzEmvJJRTgaJC/cA65v09j7zZh0OGTF4oUokeozbY42r7Ha2/tcRIpPvX8r/Hc0+/wctVjZ7uFH8ScyUk+nIFv3Wuw97pPvDxH9V6bF1WDwmqWH3pcY9VZ4R88f4VXl7+CdxISG+tcvrDC0sEJ+qU9jFqWYEsjObbxogKOmUWraEhbI01AlAXGuoa+Yf6/T5R/700g0hRNCpycS2VlFi+zSOt4m36zR6vdw8toaG4GUyn6mBS0EKEEllBk04Gm+qWZFWIkeRmSvbiIcVAhfbGNfXGd+V/5RX7u0hN87gvf4PZJi5W1VZ7WbUp5RfOVGxCmgE0qbFKhsxh0QLfQMx4ngYuUkkDGpHqPdtvDKVmcmy3yyNoTmMsW7WsBM0tlfupHz/OtvVf4+lcOSSlRnneIQ5+9W03iMCaJGRsDui4QSMJwKMkpxNCLrxh7jcRE/WMMwJkYBuOkPyZdjF7ToeEx5qjLofJOOgDHo+Wm5Qcnmv8jKsygPymntzJ5OzIIxvDzXRSZyXENlh5FFQaAdmJsjKk0mnY6qZYJ6B3OlAGoFhMn2qnkZNRQRXZYeAwxNpxOj9RgPEfqTEqNtNsHYzGidg1q8wlGqc7vdt5975jHwOiTchSdmVCLUhSa0gYgPklO9ze0zKalIcdxnymVokksSJGmCZqmT2+cSYTitLd2ejyzuRy//Mu/iGUaGFqEZgSoJCUONWBQO0BmSmh2DmnOYFWWyPgBL337OpcvzaItLgwiKqP5YaTMP3tMJm2Ti+ts3+uwfdTEVToHfozPBdT2AaWCRi6vEamAk2qbqp0nq0rs1QR+NyDTj1jTbL71wg3SLjxzdoafvvYQ9o8sEmULuJkV7saSkhZR1Oc5qum8/dYtdl/7HP/kv/sNnixlSRT4gaIbpDTrPW7duE9peYZzJcWdvV3ydoUrK1eYLbjcOWqz6fW5MltmN9SpbjW4c+OATrDP7t0D1n/wDK91UzZciVvOolkGc2dK3AtSNuYMRKDIlHwWn9IxF1xCICsh/9ijHLy4T+uoiYnPD18sk4seoz5zxO69XV58bYeLD13koz/wj/iId5tvHPfZvdfAMQRPZAU5KXl9u87uqz5qY4kX3jkidiSLqzrPXJAsucv80id+ia/M2Zy8EdITeZafWuXCkxpz0sc6qeDd1PG8IhhFHDcDRQ0jZ5BEKWExoJ1L6RwqtJc10AQiEWMn9eia/svFDCdUPCkmEa4xBfHUzWASIZP/vo0DwUDaLDtXZP/2Hu3mPkZRw/cKqCRHOx6oPhRQaLpOI/Tp+D4l16VpL7JdrTPnasSuxaV8gV+8sM6/fPwp/OoJf//CJVZzBfqGIIzb1A+qeHyCZtCnXzshsQS5mTxzuSyNVoIh6+RknlbkEyQaGWDGCPG97xClHknGYqWwzEpmFc3Ichj2sZJNUupcKCvO/sAse48X+e5Ojz966Xe427pBWE349Ef/IzZWzw9v2gp9rLX8XnuvfX+aUoo0qiGkAVEfUm/w6vmk/QCjsjJ4cMYhSb9NWD8mzecRyREbxTJpaOPV9kniI/zYpKMuYMsG2UyFuLPL/c1dtg6bGBUJKsYqZuj1GmSMBFdL8FsxJwJyM/N4uzG9fo8gbOMlg+ID19sdNpRg5eIGSukEkUurmuHlz97EKd2jmbRZP3eVjlOmdtzk3p3bfPLnfoHL5SJCl6SJotuPuL91zOtvv8LTl2Z40JSEzjyFgkYRSUZZtMKIrfp3Kc5mWSlmmMvqbLdCNjf3sVaydI0eXppwxhZst2P+eD/gU+ey9A0o9FPCGDo9D0tXVC7Och/JTApZATkHhCU46US8ff0uzzx1Dq1gU9SfwLWKxMe3SQ8e8MU/+rf89Kc/yKeKa9TX4KSfEAQxc07IT15wEa2b9JMDbKOMkTh47ZDr79h87Mk8hgi5tv4svZkuYbtBcHSH2Y1rEC8jA0gf01CBDoGGDAVCB5mRKFMgLAEmg7/vc9OkQJMClURATGm+THNzj9g/pNPdRFc5DK1EJx5wyIsCNNNgv90nVVDIOjQdi61anTMFg9g0+OjcDOnlC/zO5jWiVpufu3CZspPBsgV9/5hqAzyeoR549E+OcdbyzM8VyRg27XaIQZ28nmdPhUQeVCxBUTQI/VdBBFDIcLl8ESt2OOkHVJMO2aCGafV5eiXDUz95jjePu7x2p8rOWydcXF2kfa/L5isn+L0IoQ2kApN44pFLSSdO56HnXnsXEB4B7VEOwjjvYCocMA2sESCUZKRNPup+rFA0hL2n1G9GgFVOceyBUQ7D8O3gddpIGLYxiB1505n2+o9oOhPAIYU8VSVZvJu/z+T4J575yeeRatOYxjPen0Hl8+nvpo2JEdtqMKwCpWmD78Y1CYbefykRQk7RfCZjJYYcoHHC9VQ+xfj4RtKl0+OiRuM5zG0YhnjGicpTyw5sBjGmKkVxNN69MV1pvMbpiIMYUj/UkC4ihGRjY5X//jf+SyqzKwSdXeKwRfPoPlGnR6F0CWehhKRE7PdITvYIpUbqmGiqxdnSDF7HQGveIkr6eGkBTy1ja01KpXmSB5u8fmeHes9DKwggwS5nabePqWQStCSi0wJfM3DL8/S3Ivpek14YEClBLxF4gc85JBtXL9Np9/jGV97Ckw+ws4sYuTfp0uXQcyiZZWKvh523+cRP/RQXS3liTaCilGrT5+adTQ4OH/DYhSIPmhI/s8LCpRRTmRhoNIIe241XmF2ssJazkYbkpN9h/6SGseTS0bv4ScqjWZ1XD32UUrx/yaZvCordlG4Cab+NUbCw8y5bSGYU5AXksrAtBXsnHe7eesCjD6+iFV3KxgfJaG+TtO7j3XmLFw9P+Hs/8jQ/Ud7g6EzCUTfBIWbRSjj/kAHNm3TTHXLnZ0l7gv2TDr//5zUemt3lgx/+EBcqz1B9aBtaVdL2AXc7gos/9CmM2CT3ARMZGshER0t1hKbQCjqaJZEywpI5Vu+0qMzNsHO4dypaNc7fGV/vk0jgyEmRTs8z3kUrGk6+kWTv36T9LY0DgaEbPLl2kZt3vkGiG3T7ESfNHidBQtlQeEKQl+Aj0TSTjJHSTWIcCRuOSa3bJpFZim6Wh8tFfuGHPsHn/+iP+VCuiKUZmJUC+ZLL/st3sKSkE/VJvB6ZwgIzhQXyusZbjRZLOY2WimiRw8JAJQn7fo/2yT0ikVCuzLFcWkJJyWZ3m1DVWTVaePEJBSvGdhJKWYVp6vzB7Q5vvvVtgnZKlAR87AOf5Omrz74XNXivff+bUkDKoPqZgQo7CDHgoKfJIUKvkPbbEG8NtOhtDU03SY0clmthZjOE/UNU1ERZBtI9Q9RzmZnN8PVvfJ3dB9scV5tEKmJjNkunH9APBQU3wVAJQkGMxJMGh7s6aWAhZELOEaw7LrPlOSpem0JqkZ05y85hn6iTkp7UmQ0jkuohy6uz2LZBt3OA39ihnA956vIZirpkL4FWS3FwHFH1BJcvbyBnMqyXHMp5l2o/odMLUfhIq8fJ7QMef/J5KjNlOr0edw/2qYZVPApYHZ+mHzObKooGbDiKQMFu26eQcenqg+rHKpaYliBIY7qhpEVKxg4oFQQPLIfbu4esn3FZLa2zG5XRZlOMfEpa63G8vc+f/P5XefyZJ1haXqdQdugEHfpJRIEaufkyWtgmq4dkhE5ciChEBoEfYDgajumg5V0iM4sVJZhuBqUkIqMGNWwSUKmAEb1dZ6x7PZgP6V85Vf4DTsKhRntM0Otxsr1DQhYsh24n4KgTsBjEFE0TXwpMAX0krmHhxTF+mpCVig3HYrdRZ7ZcomC5fHB9jfj5D/H1z3+R5/MFIqFRXJnFuHUdb3cXQ0An6JP0u+QLV5nLltHSlFqnzWxG0EgiuqLCjNDo+BF7zQad2haxUMzPLbKaX6GtAjpGFSEOSPpNDLdKxRFkMgORDD1xaO1L+s0YK6exdLXEwa0mXjsiSdWQOqO+56iIYfXkNFXjh+14xEYUFDF03w2sgKnfR50M/uTI+z2VYDs2FsQkN2DwkB8hAsYVhmGoYT69D6N/098LJvsz2oZisG8jr+QQsI5AuRRywtFnApgn3byLioMCNdJWnzKORqhl7PWc/H5K/UgIRnKlisn+jzY1So4eHhpCDCItYy/qlHf0tBzr1HGPcg3GxzJFfRqOyyT6M0XhePdcGJ9nxmpNpz2zw22lKXIYdZmmXiml0HV9nEBeKhW4fOkCV69eQQpI+jX+4s+/SKWgc+HcWbrKwN+5RybXROouKiMJYp0osSgWVjFzGbr125iyjWHPINQihFmK5Qxf/vIL7G/uc1jvkM1pzGYtekFIL4CZbIyRppCmREKjLQz293SS0AQZMp81qOQLVJwMRb9DXtkUFs7y1o19stT/H/bePNiyLCvv++195jvf++6bp8yXY2VmzdVVXT3RFE3TTSvUGCwLE1gRDoUibIeN7ZAUmBCgJiRkhyQbQxCEERIgAwappW5wj3R30WMNWZWVWXNlVc6Zb7zv3Xk6497+444vuxrRWGqQXasi6713z7ln3Pucb631rW+RihR2q4nyWywu5QhiEN1rJH6b/NwGDxxfIW8IbsXQrClu7YVEVoqjJ9Yxix4bRY/ZUoYbNR8VxgjZJ9EN9q/s8tjjHyabdrm6s8+tgx1qYQufHHarTy1ImLNg0dUkCnqJZqvlU8ikaUSggxQpW5NYEOiYTiCooyhnfFJ5h2avx9WtbeYXbY6Wj3CtXya7dhLZiQn2r9LYu8UffarHuz/4OAuLR8m7Pr0wpK8CcqJLZnEW4ddImpfJZvNseC6Rinj11YvMLc2xuHSG7e1d3rq2x9bV69T7CTe3DlicX+RDT/wQsytzWNJGMlCpwjORlsRCYmqFl0uRzqbHY3k02waUd43WAynTZDhGxZh3OJkDo9Yo02NyFHR4+9za29t33efAFJK1fJF0SmIYJn6zR6PaohaERCmbvpbM2NDVCi0kpmERhz5lU2OmXDZ7TWKlQCtSJrzv5DqNE6ukGHBVbccklXKQSoEKaffaSC3IpwoUUjlMrWj12pyaS9HqK2I8MloR+z3udBr023WEbbI0u0HWKxAT01ENLLmLJwOEobFNsERESkacK0sq9xa48EqfervBxSvPsjy/yrljD5Dy0n/mC/mOvWP/Pkyj0Yk/+E1FIFMIMwMosGuY7gJJ7SaG1GgjQRgpLJ1D+aATi1CHGLKLmcqCnceyFjA9SaGcIYyb3Ky0aLZCSgUD0zDxVUToa9KmxpaaCElHuCiZpRvZFA3NXDnHgitZtATzGZdZJ83eQZZW7GHFIW7YJ5cEnMtGdFM25fWB2sROc5NO+w7Z8gzLBQdbQC3S7LcV/VhQLKY5uZijFkYUHRdBhOgkWEqTdqAXdslaRdaPHsHLpHjz1Td56dU3UI6PiAuElTp+EBMqyNgSN22wu9PEdiVRJwLTRNomwpEkhiIrBTebIa6rcF1NdsbDLGbYP9jj+m6Oh04u07QsetYsomBiegml8AJ3bt7hwkWDY80Ox1ZnmS25HEQKon0iw8RJdZEyRMkGppewpApEsY2KZnEsE8twMVMlHNMegpEh+DeGAG2EeoBpUHlIVvF7OQb1JPIt4gTdamKWPIQw6R20qTV7NMOYSA3u46ylaSiFJU0QCqVCcgZYKZcbvRplDaiY+azL+06s0bk6j5MotJngpR0cy0QFIToJafXbGEhK2RmyjouKQzpBl6MzHvVejDYyuCpir9tjs1HD77UQtsnK3Akc0yZWXcxUQFr3SOsmjgkpS+CIgNW0Ri87dM4UOf/yAYEvKThp2jWfOFQE3WRKDUdMAechT94YSXfqMchlFDjXI9w8HWWeent8h3fymG0iJqB/7F+M/hjflAllYBxsv8tBmGz38OeHMwmTaKSUYnz8E1UeJlhjGmBzdz3EdGfnaYWiiWPD2HmYyizcfU2mqBPjKP3dKRExtQwxpkJNruFIsnQ0b0ZHfRetAg6BdTGMpo6jsN92XmLcqXp8Z6e2d8jnEwNHbuIITGVP7nIQYFA/ceL4Bh/6ge8DIPTb/MmfPMXTz17kscfOMBfB1Stv8MDGDKlijLAjtJVF9wyibp9OM8bwJJbRwc3MI9xFbFHCSwxyJY++X+XydhtUTCZnIQyTfhITJpqCpTGloi0kHeEQqTTd0KZkKhYWZ1k1FfOuQ9nzyBs5KrUs+01BRlnknRSOTLCsmCBro1IW86bioLOPafgUcoqFrIOFZj+CWkujDYP5+RJLxRnacUzR8UAHyCjBEWAbCX4/IGeXOHr8KNI2efX1a1y/cxNlxxBlCfdr+JEi0pr5lEm/F3Cw38Z2JGE7QlgGRspGWxoMjYfmejPESykyWUF6LktnJ2D3oMKt3QwP37NCxbZJ3GVERiMdgUpeZefObZ59zuWe012OrRQoeQatKETHVSLDxMt06fh7kOpScArca8V0qgk377zM2voZivlZmj3NC2/cIIxizj//EgsLC/TDiGPHjnH06AYnTpxAaGNQbyL08JE/ePYnowZnI+dgWEuD1sMkWjyR851ynCeTbjTsJ2N8tMaApvgdpI/vsj+7czAViDBQLJVyVG936DSa+AcVGq0GrayFEja2JbF0TEslBErjmZB3DJpakfFcsoaFDiPqcR/HSHjfe+5jN+iy4dp4cUTKMEktzNEPO3R/ggyCAAAgAElEQVR7HVw3SyGfwXENoiRE6j6WnCFqgWvHWCqk3W+wV9tBC4mbdlmfO44WglgFpG1BygoxRYu0mcGSPlIrpI7w0pIfe7xEmDKpfaNNd99ne3+Tm1vXOXP83vHpv1N/8I79hzcNOkHHLUCCVgh3YbAkrqGlgeW6UEyBOoLWIUo4EDvI7j79RpVekiGbsxGpZaSdwTICnGwaKRWnT87ywuu3iNs+wjRphtCIJZ6EuBNheYK+bbCPg5uUKJdNVuMWp1fLLKYsUn6HpNuml1rnSi1Nu17lSNRnIfJxOxHpWaivLNOxXfYrW2zu3KHe2CdVkDiWiUATxQoLzXrRZr5ggRAUkwSpE3Y6PXSSMOeZZDzJnZt97nnkAeaKLt044c2rt3jj0kusPbyOcDT7tQOSMB4+lCS+MKhu7/HI/RtcvVLHyim8nIXpmYSGZFHC12/XuHdGYlgW9kyOVNnF39vi5k6ZU0sHFOwCBhk6RpZoJoen2zy8ss35b9xis7JFtX6U99x7hplcCiej6fsv4zkWwhD4JAitSTllZFyl569jyBNYpgQsEDaMJDHFkIIwAjPJWONlEu2dRovfQxNCYBoGpjSwEGRNTSprU0/6JNV9gkaVTr9DO2OjpIVjCkwd0VaaWEDaEuRtSVMrCqkUGQz6vk+iAnKu5j3vPsftdpN7TIkbRWRyWSJP0wvadLptXDdHqZBGGpow6qNiH1vOUG9q0l6MEfZpdvaptqogJXbaYWP2FG2/Q2IF5D2Dom2Tj00My8E1A0ydIIk5uWBSyi1xICOaz9UIqgmZWYewFxP2exx6iQrGFJJRsWwSj4qQR0BxlOIZZhzUxKkQI5oLdwWgh7QVwxjRi6av/fAnw0zFcBujIPZIq3wUMXy7l/wIDEwxfr59DI3A+ng5U0H2karP6LjHI3OqM/QUKBkehFIKCRPgPQI1I5AzpOIkeqo52ORwhk7E2/cjGK83RfFRKmHsXQy3Mjk+OQD1ehBt/dPmkJQSpTVqXHMwOTIpR92kpxukieG+1MSJPqR0O6VcNO1UiEGmaOTYOI7Dffee5WMf/RCVvR1ajRq/83ufZWmtTKZYoNZs8uyFizz40I8hs8sEcZd+3yCOQwgaVDZ3kJl1FlcKJO4GpmXgWArPdZEozp2Z56vP38YxDWIhaYaaRixIGRC2QoysoCkM6omLqbIUCi5HVIsH1heYlRFGt4WK+rTNFd6qeuxcu8GjdkJRJ6ScBDObcDBf5uJBnQhFtdXEcTWeq7CNwfmHkcYFji26ZFODDJGhekgVc7PVISVhxrOJEkm7rzjzyP3MZA2qfsTLl15lu7bDzPFlpKk4qFZIkqH8sGnSDft09lvce3qVy5frpOZsvJyFtk20FJS15ls36zy2IJFeCm8uh906oN844OZukXtWq8x6eRpmDt8+jTYz5O2IpfUdvv7ly9zZv8P3P3Ifp46sMpMysNIxvf4rZNIe3lJCrKokNJhdzPPhjxzn68+/ReDvc+LYKrdPneDCc8+zf/M2lYMDKgcH3Lh1i7XVNZ74/u/nJ37iJ1hcWkIIiJOYTruN3++zs7NDtV6fcnInc8cYjimlxDjzOBxl46zf9Dy9W2J3NDZH8+zfZX9m50CMJ4tBMV3mgVP30G1pdjZ38fs1br/8ChuZd3GkVKSmNBlp0TKhqWMWhAFYBGKTOW+BIOyz2W5R6yc8tDJHefYofr9KM0yTz2Y5t7TA7au7JP02jhDMzJRYWlrGzWRp93qUVYiBSaISrCikL/tsBTvcuv0KXrZA2kg4N5sljn2qnRZGqsaatYevoZXUKJpd0kaMiUISIg3J0dMJn/9sk+pewFdrf4Lfj/n5jV+cNFt5xzF4x74nNpi00siA4RHWK0ATaQcYboqw/Roi6CNcl1iXiBIbpQNkPkuqu0V2+VGisE/1oEaid5lfSGPYcwhxQGkmjyksDGHgehahhmpbc3pRMRcEXJce29KGWNIBFjoGj59ew9/tETox5oxNzVvlqa/XaO7d4IdnPVYDg1So0aYiaCS8cb3J5Sv79DMxzSTAtB2yeW/AzdUxc1phlCSOAQhNI9HoMKQZmsRxmrm0gSP6bNe26ERVTpzcwLY0X756wHN3dul292hvmhQzin3bYSdOOBolxNritnCZffgY127ErCzmaDsQmtARgo6GR3VC0tjlRpAiNDWeJfDyIdHthMbmba5tlJihR8pbJJUtUzfLPN//CP/JkTd44q+keOaFCt94/hYvvniH73//Gh967Bw5t0cQ72MbIE2TQFsooZEOWP1XQTlobQA5kqSLaeYO3+7hQ10LCXEy4iUM+eXyrvDz98Zs28axHYQQ1OstXrxwmZ/8wIfo1q9R2z2gsXWT22mbBfssq8U8lURQMhwqRoASmpww0EhCsceSt0KzW+VmvYttWhyfLbC+dga/u08lyLAxO8NmeZbNSpOo38JEky8WWV1ZJZYm3XYLs9MEvYrWCjvq0LD6bDZvUK3ewk3n8GTCQws59nu7VJ0Gc+Y+eb1HO6nT1z5LMsYyYkwRIYjJpx0ef2yOb3xxk96+wnRN7KyNtAJEpBFSo+NRxFmMX7YqiQfv1GEx8ODd/XYv2iHAnIrYIUcR6cHLfCRbOlllAiAndpjTfzgSONmtHlGCmGxHjMAFDLT2jfEWJ8wiMfme0qNianVof5P+DvowOB7i95HzNFo+Xbw8PrcR4B46HIMjnlyqEYwZFV9PR+OnL8nIaZFSTihGw2s9KjqeHM/AQRCocY1BHMUD5RZADCOvo75HcRyTDD+Tw4yKEJIkSUiGakhy1JcAxo7E6FwHywWGIYgTNXZwpDHJGgj0oNB0mK1YmJ8ll02xs73F008/z7/87d/jidOzfODj38faqdOk01lOnz5CY/cKTStiv5Fhd/8OxUKajeUFvKTOlQNJPpilcnOffMGkOFvAsGyErDI7W0KFYHsmhmPQTzT1jmJuERb6XZ4TedrYxNokjGLcnX3e+94NDl6+g78kIZtns+/xwre26Fa7/GhesdLOYmtFEoTUgogLOx1e0jFixaWrBs9U2xk4igkRCxpSCxLH0IRoOpFChyGt0II4x0rJpN+vUWlV8GmytHYUSyZ86uUK16p7RM0d0tuajBNw4HhsBiHLict+bNDJ5cmXClzfjDm2nqfqgG9AB4Gp4ZiKiBs7vJVkEIYklVa4qQi/GtDYus3VE2VKYZdibp0wk2GXda6GOT66+hYf+VGbL37tgH/9uYscWXqL975rjcfvP0rO6+CH18m6JrFpkGiXRAcYrsf7Hp6nUrlAHD/AD/zgB1heXuJv/I2/RZLEaK1ptVq8+eZl9vf3uXHzJv/0n/wThBD4vs/nv/AFXnzxRW7dusXe3h7AIIMwDBJN1+/AoPZXDSWPR300RnNkTH0bz7EpAYG36UT+ney7phUJKfAclwdm1ukea5Jg08FjYX2N65t12n7AA6uztDVkBWhpcbERMad2WC8ssK9iTDtG5l0c18LCINYmewcJcwuKtg6oK0WpVCbWDsZOn8JMmiPlEiVh0Wx1iNMmO3HIngq4J5Ow2etxbeeAxuu3kGGXH/7JHye0Je2+T9kpcywzRxBv0SXElgu0VY2+qpKWIXlDIWjz3rTHb+ZNtOXT6rXYO9il1qwxNzP33V6id+wd+/ObsJDO/GCCK4WVy5JEbXTiI5IUkVqn7XfIZ2Zpd/rcvHGTxv4Wjz2yhnfyIQ5e+DIzZ3+I+VxCu9mjWusR7F2m2XiG3/rDb5EkEXOzKQQJ27t9CqUcc6YiLuYJKBD4Jir2yTkBH1swyUUB8ZzkYk1y9SUfs7PD0twS//niKTKtADPpo4gIPItGeZmGvo4sl7BnC/zYx+7jkdUF/GCbftzjev0aGdbwvDRCmwSJRmqNkUqz4oKSkkb/gJ36FTrtG9x//IPMFYq8fLPJs3/4z7n18gsIYeHk0qys5dhuVvjcp59k7uPv54l3nSJrwRe2NAdS8iEX3BikAUVLMJco/sVewmK1QXwmy2vXdlBhk/uPLfDsboubr7zI7JpB9vQHkEEds9NhffkoRx8u8z//mxl+7qM/wl//+B0u397n4psB37ym+dLzT/P3/sv3UnKehWQHrTq4pkQLE02CNB0GKeAALZskuvSnPnCFaXyvRtmfar7vkyQx0jQwAp8giviDX/lnzD96DndulcX1Y+TLZa5t16j3ezy+sUQ9jlkxDW73TS52u5RVm7XCItuqj+uBJbLYysJUBn1tsnOQsLqm2el1By9zN0MQGBhbfZZWi5yYmUUECVJosnMFKknEHhEPpyIu1NrcublD5+o2KUvzsb/+cbbbDZ7du8H3nznLEdfDjys0E4OssUIluEPb6FKyEtKGwhMB702nMPMGyUGECgWWZ5KfT9HY6hDGGjno5TWm/Yx57dNUHTGJ6jNcNI7835UxGEXY9YgSpKe6MzMpLD5EWTlEQ5ko7Ax+CN6+M/KQWzw+sKFUJgOwPZAMnVB8RhBcjACImtrmCMhPnbPmcA+Cw/ScocrSiLufTKn8jByqKW32MSVCqXGmZLoAWNx1rUf3QH0HYDOmLzGRRp1kWQ5f10EfggFIT4bSp5ZlDjIOd60/rqUYFTFPybWOXBMxdBaVHnSMvvsYR9d6kIkYzPNmq80n/+1n+fQffZ5s2qPouXhHzzKzvEw65XDl9Wv8wb/8JL1uk6qRY++OjyciHrx/no/+lUd57P0fY/Zrn+Fn/t6v8l/993+NVOEYOzsxYbRFq/UCv/r7XyGdkxQLFv1+TDtSZPMeMwR0Fop04nk6fYWpNQue4K8eS+N2u4h1k09e77K9WUN2BQuZGf7WsXOUQjBVQGIkBLksrWyWjv8msa1wjhxFbT/DIw/dyw988AmaQYPN9h3y8jipdIpYSRKtMYTGTKXJ2aBMSaV9h4P6awiVcO/RR5gpFDj/Vp1nf/cfUr29RX52jnQxw9Jclq1mhf/rNz/D6f/mr3JyscTtLjxd0TSl5KMuCB/MjGDJhGaQ8PuVmPlag/hIiWeffZXVGcHx9Tleqba48cqLzB+xKZ79MJ3922SCMmfn5jlyqsw//myNX/prP87qymWeea3Bja2EL7wc8Plnnudn/+YTZOQXUVENQ8aYho+SCdIogYaXX/oiDz9WpDAzS6hiRsyfgRMagVbUqgc8+eSTPP6e95DJZFAqGdR4qYFiVhAEhGE4UM8aBwSGQQU1Ch5KhL6b1jfJ8N09P4ejkBH97s+SjDY+8YlPfMeFv/ALv/AJgB//8R/n9OnTk1QpAsuy2Dq4Rcfv0m43qVQqlO45x0EdhO4x40hyhiYvE455No6dotOrULJthBIYiSKtfNqtbUzbJBQRtpUhaLfRQZf5lVl6MVzfuUimMEeusIpjOThGn0ApjLTN6XSKncTj+Quv8Obz5zHocOojD/DutMPOnSYUF+h6JrvBJmayR2LECCIsTGLVI9I+IDBJMKRB62SRnasderUYz8uyOLfEsdXj48n9TvbgHfsPa5NInhBioKUe1tEYCLMIRhrTncH20rheil63RxD4CKUJDuoUVxZw5xbxgx6dhk/gO8SGQbNxnn/xO1+g0eqzfiTL0moKM21y0DG4f0kSeQlvJmm6jQgvECzmy3y4uM6xWZdLlYA3GpIec8zNHOXc+go/sHEv6Z7AXpxHLMyRbKzTPLXBGwt5jrzrAU6dPcsT5x4knXFoJzEzTpmnnvpdjuY7xPtvEBkW2nCI/Jid7SaFnMVBs8bW5nlU5ypZ16E4/27ymTJB6PMr/+wT3N5+nSTySaVcjpw7QSfeoH77IlF9h/zKKoWFFRZTBieyglJBcAeB6wliW1AHDvpd4j/6be4szZAv2uzvbFHb3cYPe2RPHuVg6zLtbp+8J/FsG2lZhEnAYjrHvWdn+fRX3sISaU6UUxwtxtR8SU4sc/7GNY6trJJLm0gRYKIxpKQtnEGfF/YQtJEih2utcXen3fGdH1FXpv59L7MGjUaDX/7lXwbA9dwJANWg44QkSbj34RNgGtSrB/iJJrN+nP2GxhQ9VjyblIiZNWHVdbAtl3avwrzjEcUKV8dYUYte/wDDMghFhCkzNPa2cGwolov0wpjNg5fJzaySyq4MGm0mPQIU0jM566W4plJ89Y+fZOfqG2RnDE6/7zQP2oLPffUFTj3yQbpuRL1/AxXuoC3Qqg1BGyWCsZKPRCENk+aZGa49vU8UaJysjeVYNLe7aDVMy4/EQMQE/I6LBMcAe0I9EdIYewOH6DowKhlgULjLpHfF0EkYUHDuutliQh0YSYYeXn54eNwdaR8B0gElQY6BshitPKYuHN7nhAbDOII+7UTI6W1MXYtDsERMLxeT78Dkuk6d46S4+K6TYJhZ0JPn4tBnmXJMBuuN7s/dTdImkXuBNCSGYYyzDyNVIsREBWl0bqNsxCF52rvqFQbO0rfP6ZGazPRxDP4erBvHMYYhsW0b13GIw5BAC37qv/2b5EtraJHjjat7/ObvfoGtSov9ZkAqZSEFFEyX5dwci/ecpqE1Dz54H9cuvUkvsDBTksr+8/yfv/9F2t2As2cKzC44hNIiUgZn5w0CL+a5wCXebeFqg0UtuDfocXKlxLM7EZeq0I7nWJ1d5333nOWHzz5KJrCw11fQC2XC08e4vbbIpbTBtmNi5wqc/6PP85Ef+SjNeo9nvvo1TGOT9WyD9q3n0LkFJAadZp96rUs2bXDQqnH75tdxoi1yuVVK5XvJpAr0/S7/y//+t2l291BhSHlhhrmjR+kESzTuXCSqbzN/9kFKhTxLnuRYTlDKC64pQSEj6BiCmtbUdzeJvvopNpfKlEsON69eoV2rkDgG7vIs9b3rNNod5vMWjp1CCY0gYTGb5b6zM/zzf/sK67MLnCoLip6mFzl4zPPNK5d59J5TWKaPZCDXL6VJFwcLwbEjOaQh+Oz//XV+7Vd/n0a9ThRGw3kuB43xtCZOYoIgwPf79Hp9+r6PH/iEYUgQBozEAAYdx0FrNZECHs3tqfl8uK5lkm2YTKfR82uwCZWowXEBn/jEJ37h2wYwfw61opF6gWmYLOWKtLJNorDHXgS1zSucXr2HA79Lv+6zkHFY9EwyOqZIQmRl0X6M0iFaJVgixs0oVHKbBTNDRzUILR+sDk7jFoUjj3J0doae8ijlJWFYZ6+yQ25mgRnbxbbgwje/xtW3XkaIGiuLDj+8usg3v/USCwurZIw5lp0FivYGEQl1/zxdYWIoTdZIExNyI26wYEUU0gYnvYTzeUktbZLJZDi+cvwdd+Ad+wswMf6/tItTkUABwkQaBlIIisUS25t32LxzlQ88tgGAFAn1VoTfaWGZMem0ScPRhFkLJzKI+i7dDjgZxQOnymQWE25cb2CaBuXZFIXEYC7oUYqrGEf/U04vhRyxbKTwyJhpyrkUqVaN6M4O2rYw1tfYw+RKs88jZ5ZpdnfR3YAeAjvlgIStvWvEzqAhWTp9B0Nokt4WIsyyVs7xxuXzJKLBQj5NLr+Blz6CaeXohn1+/ff+N/Z2btDr9HGKFtmVFP2aZnvnPGHQx8t4EFd56+odLnWLnDuT51hZUjIEXSDWmv5WhW989itsV67ywfc+ypKX4SoRQXcf4oj8TBlhZzB1ne2ta1i2x2zZo98VvH7Q4QMbeXYfPkGnU+NqK2Y+VeYj987whc9/hv2t17l1/BxZJ0UhPYNOqgihSImEnvIJkgBbSFxmEPYDf3FD6ruwQbEbqGRAMxEC2rU6TqeN9MDy8iSqzd6dt8im5tjuePRFjyM5lxlL4JJQFAmRlUH1AxIVgFY4UmF7ISq+zZKZpa6biJzAq9YxwypO+SS9Yg5fpCllFbt7e/TDgFxxnhknhe3AV/7NZ9jZeQPbaXNstshDWYsvPfcC5eUFSqmQG29cpmXUMI8U0eoyYdTFSEKWkoCOH3NgKOZtQS5tcC6V8McFSRAowm5ErxaOI8/A4V9GTCEYhgKnKD6CQeMBPaLHjJIMQw6SYIp6NIrMD6P6U86gFgxYPVMvdc10pG/44h9JWekBIJ+G5WPloPFnUxmPEZAYfqaH/0ltTKgIYtD8bfQ1OXVsAxw9OV6lR+cz7JQ8vGBKq4kzM3aOhrQjNepSICbBRmPw9yTaP614xLCOQI+j94aQKJWMmz1NFw+PgnhqCKaEFuP7JoyJhOmoj4Ia3TOlBjUgo6i/GBRoD8DZoLZh1OBttDspJ9mcaQWkQQHz5A5OH9dkPYiimHarTafdIQwCbNflf/r5f0qxWEAjqFRqtHoBUkQUU5Ldyj5HFmdZO7nCiQc3BoAxbvGZLzzL8aUcuUKCaVbphDv00xKrp6nsdFDSoZD1WJhL45QSdm6EpA0TZ95iNlCsqJgcgt/446usnHmQx9//fjav7rN55Rq3gj5P3H8fwY0t+rHgFb/DlTjHa7dvc+et53nw8WOszh2jd+I0rz/9PAvlFCvHZghkB51ISjO72Pp5onaRHDlMz+Tym3dQosHqTJZM8V5cbxGkw35jn9/5179Os75Lvx+TO5LCKbu09nrsVy4Qhz7pfJaku8VTl2xsu8CpY2mOFA1KJnQAR2tuXHqDF595mmbvFu9776MsOWlM1aPV3EUYWYziHMJOY+kaN2++hXEqS0qb+G2TvtHl8bUcN959D7c6B/QTh1JhkceE4umnvk5l6zWuP5zh2GqRlBGgVRMpYjyZ0FYRpgkyOUCKGlrHSGlgOw5RGI3rAAYO6WCchMNGetOjRQ3ngdaKZDT20YfGjmK68H3yc6RgJobZyOnEwaSOYeqB8afYd08rEmKcklsuL7NfrVGttUiEprq/RX79KMJziIViJ4xp6ZglI6KAwrIcumGITEI8KbBsh46WpMIOGSfNXlAD1aOUUphGHiUOMFSNtZkN0DU6fR8hDEqZHEXH4aWbr3H76kt0q3coz3mcuOcomzd2SVbOkJ9zyQrIxCHptEOTZYQ+jdR3qAcdlAJLWXR8yY3A5IwTsmhoygsWBw2D0lye+fIi37PQ3Tv2jr0N71gYDiN9jwl9YfASdxybhcUlhOqTLligE7o90Ni46SKuIzAdUEaZ7/u+92HUm/T9AG1qUjmHbCHH9dp1UjMlZFeQd3KUtCSXtKgbOcpmhqXZIsKyEQosBF7KRZkxcdmlG2vq3QZXuj5b+3VOLzkUPImZytGIFRYCQ2haqs3S8gyxsU/aaYIKkckeQruYYZqM2yNfOMtcfh6ZWiZIHPb2rvO1p77MxUvnScwIkQYnlcISOeot6LZu4KTh+NoCul/njVee4/qO4q3rOe5/5IcozRtsbcXUd65S27zE9Ruv0847JHQwKFHOZ9i2DGp72+TW2uRXM6hKlX7Qot3dIZc2yFsz+A2Lqw2T07MeFSdHvysI4oBUyWT93Gn2r73Gay/cIu/Okz1RxCBEqT6IeAg0BegQrf0xwPzLbqYhGXHddaLRMkHHMW9eepOlU8cwMoIohLYfkRR8NhbvJ9Kaa35EI1bMGQkZFLbl0Qp9jESRsk20ofEVeHGHrJvlZq9C2uxgF1yEkvhmA4sGpVyBuHebOPRxrSzlTJ6cZXLhxmtsXb1I4Fc5enqRuYUZNjdrRKvnWFv2ePWFp5jPeCwurpPOOQQ4COMNKv0DUgnoKCJWIV1Lco9jsmZKSqsmkdDU3vLp7PcH0rd6lLljTC2ajhYLAHkY/I7R9NvZXdQiYEyjGSWIBgD1sKzptJTh1FfHNvjecJ1DC4eRcCaNwtTUficbYACe79rmIYdGiMPHfVdEcnLS4hDomOQ8Jg7L4PtivPrIGZFCfhuNaHTCI2jEGPQMrpsUchhJfZuLLgbLp05zapfDY1KTOoJRhF8PPbtR0zMth+cx7Hk05nwPT1VpjeSuazqkcsmhQzWShh05G0oPJFgNwyCd8pBS0u/3CMKIMIp57sKLZDMDlcQgjAnDGM8bNDuJwohOt0OoAgxPEgV9nn/+FbrdiCvXd6l1epSX86TnCjzyrvvxmg0OGhUMJbAMD8PJsteoYxVdCk2NnWjKUiFjgzuBh8xkKM0sc2r1JGWRYzmbwnMtzJkc3YLgoNXkQmWbzdhgf2cbq9NgybG4deUqqyeP8/LFp/DLBun5MvliSGI1yDlddHgZkXiYeGjtkHVDCsVzLBYXiL01+j2fOzde5KnnvsGlF59DORHSEHhuFp2kaHYDet1bOFnBPcdKNHZucbOyScuXvH5ljjP3fYCZBcmVKxGd3Yvs3HiJrb3bqBkLpTsYlFmaKdLeeZNuNSSfz5BbTqEr+3T8Ju32HbxciGME+E3JlabJw8sZbh9ExD4kaLIlxfyJo+xcvsT5b12m8INL2DN5LJGgCIFofI+lqZAyAR0jpMA0TZJEkehk6GDCoJxs8IAZdy4fjfnhPzV0YKcd+lFwYdohmJYNHme3Jl75OGAxnl7Tz5k/xb5r5wAms6GYn2WhtES91sLfraA6dWqb10iVF/EyabokNKMAWye0tGAunSZSmpSWOCJBioRIG9iGTUwDrQQePkUnIkm5bHcOQIbMpHxq7QYyMSnl5ki5KeKkxfkLz9JpbVMqCDY2FlhZO8b5Zy5TOLeG43QIWi12ug0qTUWSdfGKazi6SxB3OUhiMtrClmV2ghazvSopx6Qwb1PsGORzWVJuapIa/Y/hrf6O/X/UJin9u21xaZn5+Rmi/iYIi0R7JEkdz8uRyuYRUmFY+zzx+EmM3jbbu1V6kUQbDq24jYwbLG6YHFxpkItNspaBXchjLTyElJD2XKQwEeMHmEaksrA8i+pLunECSUDJiGhVKiycOUaUKeD6AbHo0ddVIrfDUtoi7tZB+ujER9MYbM03ObJ4jvLsuwhUmt1GnVubr/Lm68/xhS99klYnxltzsYSDbZegX6Te3UXJDpmZMuUZl7DXYntvk1t3tnjrdcFm5gyLOwnbl7u0ty5B+CpWwUKkMuzs73KssMjxiuYAACAASURBVMhcKUMh5bLd6kJ/n9JalmpVoBOfoLNPP20yM+uSad3kai3Lu8o5ytkMTWmje23aKuTUQ49w7Wtf5861bbaXUxxZWMDMzqKTKgqFIQQWNqawEfzlqCf4s9iAXsFYo10lCqnhtZeuIGyXfDlCuV16Tod+u0NvcZa55SWaiU9dDyJkdQRzqTRdZVFQAkcmhEKRYGJLm1DUQUFW9khlBb6WNNtNDEtRtJvstXw8s0w6m8VzbIKozjee+SZxuM/ivMPy6hw6XeCVzT1mzh0hUTu89vJ5Cg/fi7DydGIL7R7B0TUi1WVPhaQjQRxpamFM2euR9lIUVmx6kaJ+tUfQDFGxYlRjPAGrQ5CsJwXEo1pxRhE8NYnGDz4dAXvNoU4Vo6geUzUHesRVfxvHQExe8iNgMP0cGIHU0e/j/U7RYMdUA+764hjQT84PxCgJMqYLHeoGLCb9D8YZEDE640HB8SBaP+U4TeGQce2AOPxG1UPevxgBcCZg6e1sQB2aKAiNyFejKP3kvMcnO3aUpo9lRCcarX+37Oig54McyE2OnJPh/Umm5FRHzsC0mtPou1LKcXO8MEoYqYE5ziDw4/sC0zSIoog4jul2u4AkGSobSeHg+wFaKWq1Bm9evc3zl96gNNvli1+5yD333Me1y9d56bVrzK+VefSDj1IuzHBkMc2VWwbtUKNlhki5ECaUlyX7ey28QOGkTQ4ixZtVzQcffw8L88vkbYda3MexJblCAZ3OUvNMvvH8K1zY2yFJQnIo5koFRGhQ8X0K/Q6l1Tz5VRenpCgWNJgN0D4qrqCFRscCU2c4snyW2fJj9BOHO5Udbt54nZdffIpvPfsntHsx3tEUduJgM0/YtWj399FGl8xsmbmSS/2gws7WDpuVOm9eKXHDPsrSbsS159sElW9imBVkzgbHY2d/m9Mza6zM57n+qqTdbmIkTYprWaoV0HGXbmubKGWRs01Uz+dqLc3753PMFou0aiaR6hDZERvn7uf6k0/yxku3uP90lpyTIp0qIHUHxSB4ZgsHbaTRShIE/rDrNpPxNTXtRsNb62TwRLibsjZFTRtnDu6KFGg1cvw10rjbVb1LfvcQVe/fbX8u52D80BFwcuMEaM2N27fxK3uc/9ZXObK4RvnsvczOemSdgLa2eLmj+L5UHkeGOHaMClsEnRYLhTyuyLPTOM9C6h4kNqG/Q691g37/cZZW7yfsvYYtXMrZMriSvu5xfec1bl+4hJx1eOj9pzh1dIPGno07fx9vPfnHpJfyYHSot/ZpB1VKGzaPvufDLGYWMWWNZtJGyxRr6UVcdZnXqvsslQTa8ygU0xTTxSFP8h2n4B37Xtl3P9aEEBiGi0xvoFRCec7k1u1bJEqTKxTxvCzl3DLF9CzKKHLPbIZYmuw3djh4/Uu8/+EzBHGTUGhspcC2sBc2+MC7f4gw6CFEhJQaw/YQhgNCkARd+tkFiqfmmHcdHlCKsN+ju7uLV5zneqPCWiZPNb7BbvAKptskCvvYMiFEY9qSIFb044RsNk8md5Z+P+Fys8Fzz32Ni+ef5Pr1q5gzFoYQiIyHHWSR5gKh8OhUvoZVmGW2PM9m0ydlgXRjpBdCt4pWX2brfJ/9/U1mZmFxvUTXyrF1e4e3rm/zoRMPk05rvKzAdUzs9hZe+ShO3oR2i7Br04rn2cFiRd5kIVhhp5sidlyka+PaDobuMecIskcX6V+t0a51qewG2OmFQcpYdzCkidAeyAKS7Nt7d38JLU6SKa4rg6hXooh6Pjdff4Ol4yHezBy9uI6ZqvGlW7f42E/+F6yXNIbU1GLJFV9SSuVxRYjtJPj9KlIkzGUy2DLHVu1pNnKPoeIefu8K7W6fILyfhaWzJM2n8IxZMh7gxdSCA+7svcqN8xdInyjy3h88Tadjcm07ou8d4fKXv0DL3MdOh3zj0tc4f+1JyhtZFo6eoGhYOIUUVboEsYUbK2Iz5JWDgLWyi8xYmFaM0GJAo1L62+6TEMOi3umIm54G3YMMyzQYHpbUDl/cYkzPEVMUIyEHwHu6t8K37Xuyybe1UbR7tPKIBz+pJRj2MhiCgwm2mEbs059plJpE3eUwws8UaB87RdPZEjHCH4NrNQDp376v6QjoyNNKkkFEdVzwO82dZgS8xTiLMdJ4P9SPQE5dYzgE8DUDhaMRrQc4VOMghwouKlGTbN/wPhmmROshfcgwp+ob5KAXE4edSCWGDqQEy7AY0bDl0CmSUqKShERKup0OSiuCIBwrKgkhiaIEUOPsiu/36fV7BEGEb0mevvAWl6/ukM9meeP6NvMLS2TKJfZbPW7fqpO99BbdOOJ9984Tp45jeh6G3SOX8Tl7fJaD+usctCM8V5BkMtTbmkZVcWTjHItzOVrNGp/6wz/k6aefY239GL/4i/+Al3a7/OqXPkegYrKuyYnZElZ6kW+9+hYP/mc/yh/82i/xE//dezlxJk9G9rGTLqbu4Schhi1o+zFCWqRTeTKZU3R7IS9Xu3zty5/ilUvn2a/vIrM20hg87512Hm0v02/u0qu9hFMsM1de4Mp+i5ybQXoJ0umi4hYq/hJ3vtljf/86J05mSJXnaCcmB5Uql69t86P323iZGC9jEoURdn+fVHGJdkGiWlXCfIZaLICEWXmbhXCRG60MoWth5goYoYWheqxmFO7GIv7VKjs3t8hmlphdyuHaJqYKkAI0eeIwS+gbBH6I3w/QepD1Gdx/Yzw+kyQBRiphkwg/MHz+Hg4QKAbUvVGCblq9aLSdwz7/VKBCjKfx2z1m3tb+fJmDoQkGtQcnNo7zYymX/+O3foNrN7a4+dIVup/6NKIww9q9p/mhD9/DKSn56vUqa2aNNQfmUi75vIvWNQ7qVykV10iSJt1OC7/Xx2SZjcVlvOh1tmSHVFqQyB6+7LBop/nMH38JJyc59oMPUcitc/35Pb72+T+g3Qd0SKleJLZ7+PSJ4oj6DY3TuAQffgjLy1E2OsRhwPV+jZzdpa8X+VajT6Ud8+jRH+CHT/7YfzQv83fs/+c2fBsNXryKhx5+N3HUHdD/DJhfKNFs3ESYRTyRot/ZQvg3eN+5I7x25S129+HoiYcpFedwHBdLCtqNXYrlVaLeLaRZQhjWIMKZKBAeX/3GJR58/BxLqwukUincTAbvxElqnQ4nsiXqfpUwqZORPiYBJStChW062kCYGaQtMBxNT89z0MvwuU/9Fm9e36Pe3acfN0nNprDWTNJxRHQgcOQSSdCnF9/EzHtYKI7Pexwc5Li5c4VKZ5NIJIgooPnMU/zUT/8sv//bv0mY7JLKZ1Fmid61i8T5PoHqkdglUnMLzB+5jKP7iKhKw1QYRU1Ai/7BFcpeg3rpJLPhLZx2liXPJnBMOjEUnTy9pM3D776f1zo1GrUur11u07ehmFOk3QyuOUciTDzzFKb90F/0KPmubCAuI1BDcBMEAVIKms2AUqtFJu3gYNG406XfDfj1v/N3cI8c5+H3nOGxh1ZZlyZfah9wyqpwxLWZyXo4jkGsdjlo3Ga2eJwo2qTTbhAHBo65xJF8CdF+gS1Hs5AXtAkwrT5Wt8PFr3wZd8bg1EffxdaW5Nozl7j11g2UdrFESHlOIQuCmJjeQZ/a1Qbba/ssPL7MhuGwknWpqJAuEStpj6qf8Pl9RbUpqF7t09n10Yka03vGaBfNqMA10RO5TD1S/JyK9I1NTKLS0w2uxTD6PPh8QgtQQ0AqRiAYDoH4QxHvIcgcqeMc3veE+jIJ6ush8Jw0OxuB+8PZBD2Obk8jfo1GGHKYGRmsM6EOfXtgf6iVxMDJmN7WoZWAUTHw1Hb05PowPMfRO3jQnFqMv6fieBiFHRKYRs6aHMZLtR6DopGNehIMuUlDB0IhTXNwf6ekI0f3QwzrGwYSqoO/5RBkJXE8KG425BDsDfY7KngWCJI4QiUJMRMZVtt1CKOIdqfDSA5VjYHe4BorpVHJ4HrEaIIoAa1QStAPYqrNLkGiWJgvUdnr8PEf+QinTzdod9qcu+8Ip09ucH2zwe5Ok/lik/XVLOl0jhdfv8AbV/ZwbUkVl43UMT7yxAN86L1Zfu5nf45/9Xu/xK//q09y6aXXaDZ6XOlc4+/+1M8zk15ncWaBereCYWmu1qu8Wmswd/YM5//RP+LYowU8p4oZ9nDtmKzZx6ZLW5rY0kSmXRRZOsyy23T43Kd+ndeuVWgHuwRJj9RCBnPeGDzvK+DaR+i3bxEkFcysgyM0JxZSbG5muXzrPI24TaIjRCeke+E8f/fv/0P+wc/8NI4TkS7M4rdS9G68Spzv46sA7S1TWCth2RXcpIuIq9iWxihrOt0D0gcvo8x5mvkjzPg3MVSOjVWTSqKISJBCkhgm73rP/bxY2eLNN+v0xQ5H4h7lokM2nSIJBJ6b5ulv7XDxxQP0kJc47m0xCgYMx+KoXmU0fsQoMzDMJowzd3pCgZs45dMF798+xcZKYfLwwtGs/04ZuWn7f+UcjMyQBotzJf6H//rjfOHCZb74ya8Q9hOCgztc++pNfu3Jz+IQUVhM8ZGf/dusLR3FD6o02q9jWl1WyjPcad4iq9tYxiwUlinafboHf8BrOY9S3CZWDyJNAxm+xtfPf4pOuUxm4xQn3HWu/skLvPTMBUIVM1ue57f/8a+Q8Tw2/U1Qmlalxm98+n9lt1pl99NfpnTaprQGqaxAmB1aUZbV/Ab1TpMP3PtBTmbvpZgq//u4NO/YO/Y9Mk0SNxgUQQoQCZAQ9ltoFTA3ex+39yvUq2+Q87IslB9kv/I8NxoVPv6Bn8EybTzXwzRAxxGWmwcVY3mrjEXSBzIuaOAjP/pBvHR6KP83ACp+GPDTf/9/5JH3PErpTMz6nM+8GyHRGLpKyxBkUrOESYKvDIQ1S1bezx89eZEkP4POdigUfBbTgkR1uHm7iugrnOwGvVCDqGKIHcwg5vT/w957B1mW3fd9n3POTS/369w9eXZnNu9igQUWmViAAAkGMVkSSYgmSjZZqDIdVLbJkkPJiVRZ5aJkVdEsWSbtkqhi0SVSlkgABCmUkLEIu5iNs2Fy6On8+uWbzjn+44Z3e2YJwBSE5D1Vuz3d7777zj3vhO/v+/v+fr/HVvAab+Xy1/4JvdEWylfUPMlAJtSdIaN4iq1ZBjcS4qsJP/j2Bq8sWJLE4JmEQI5oenvMdxIaiYvjpAjXY7nr00gSUhuxoXye8AQ3h2Omtas00pi6t0jgt2l6AVesouF6PPSW93Pl+gWMo1lpv521lZMEnsdkeg7PO43nLCOly1/GM/SdaNYYUnJgamyWjs9xMGSoWFnBGx+4myc+8Hb+6Atf4wsf/TKTYcj40jk+c+kpvvB7moZj6B5p8+F/8D9T97r0R6/QH13E9RKOzs9xZXCJBXuA8k5Ra8zhm10GB7/PK3VYD0NG8RmC2ojNW+d45uVrjI8co33PPOErfc59/HMMd3soz8f3XSYbm5y7OOLH/9aPceFr57HhmM5ak4NhzOCz1wgfazK9u4XTrmETh0vhlMDWCFOX3XO7XP9Kj8H1KUUmIVPky8+bMSYH+TZntclZ7mytlWyykuWhjMiDZyVltpvbWf7ZAQ65QL0Ux/xFLdPo51flVOBrxhPcJqU5lI60xMizv5nymhI+zK4t9PbWoirvkUJgcgBTpCGdSSio3KfaM3Hnn6gYOKXHg7KHtxteUmRenjvG6bY/FEaUrHgkDhskud5bZNWKC7OqkAIhBFqnUBoKswBtrbNg06LegZQSJWXZP5V7IwrvRsESW2tJKt6HQr8lgTTVBL6LNpYkSXOmOHsw35UIobAIXEdx4tgaP/9zP8rdd59FKZ963ePxTgcpLDc3rvI7v/sxHnz7O3jgjYuce/IGB1sbrByBq/0hn/joVZSr6NYXWJtf5NWX9vn4n/7fPPLwA/zUz/wyVzd2MBqaQQ0rUi5ffoHN2gW2ej1wLcooEivAszT9EfNvO8kP/exdPHpE0VQJjk0IVMhQO7ipJMEy0Yqaewwdn+GTX3oGFpbRm31W1jt4vsNkMmRjq48ILX77DP1piOtugtmjLhzO3t/Fqb2dVy7+L4TEeDUHEaREw4iaM6QfhagWbF4JOTkHZ5cDbnYtcWwIbIzHNnONAW5L4+PhOCm4PutrDn4/ZOIaBo7HaQc2+iMajat0w5Cmt0Bjrk3L9bmhp9SFYF/UoS545WbIixdu0N+fEkiHX/mVn+Dv/+YnuXG9z+7OiOk0zoP7NY6r8vlWjSnIpYpFteN8jpb2K9U1VBAF2fwtPJLYbP/IUvLOri3rc4ksQ1exhrTWd0iM/qL2LTEOhFB4ToNu625+4m1HeP/DP8Dm3mf53Oef5rOfucDO9haJTHAdqPEsvt4k0Sp7bKUZDy+z7DfBeKj0CmnyLHEiGbRizgbQqD3G/sE+vWsvM9kfsXp0iebwHva/9CSXLuxQR/GTH/wRHn/0rRxZW2eu1UEKwXHnRDYg9WP86od/g3/wif+enesTBs8M2Nl16Z5w6R5xaQqfp0fX2T4/5W0PztEJuoc0m6+319t3byvc5wbXbWJtDMIh07gLrGvQJqYfhhiV4NgQG/fpRw6v3NI899wYwR/zY2//cZqqgZQK6deyYKlKUF8GkHLXvzW0Wi1kKT2xaKMJwyn3njnDB9/9w5jGLTx5GZebJHqfSEdItcIg1cRRimMEJhryqec/w/VrLaKwR3POIXDmiAcxW9d62MQS+i1c7xQ2fRmpN1FW49UVC/W7OUh3GU6nTAdTGl3JwoKDdSK0tuxZn8lOhJ5GJE3JXq3FwrLLaGuP3XjK/OICc815thxDd8FndxRxbMkjmSSYWoNOPcAND7gy2uf0YpOp3WV7YpiTsNyusSsDjuAQrD9I7Uide07fhzEJC91lAjcLNGzU34yUHuJbs81+G1shv8hQlK0wuXGccv3aLb74uacRNmW13mStpfmVX36cP/nYi7zy8iZJFBMLC2ZMzT6Jl3YQJmfFRMR4dIW1oIWOHZrJFzGTKVMs07bhoaBLs/Eebmyfp3fuImES0lxcZjpeZ+Mzn2R7bx8dx1gbMdjoEe6PURZ0EvMv//4fk0QxoOkeq/PwT5/i1rUBl58eMRikrN5VZ67rotyAzdTlyvkeN7/aZ7qXYnUFFFfYuBIc55WJS4lNXnV3xu7NZCmF/MXmqSulEHmWnpmsppTQIHPpDlTRbfGr0eaQdr5g/Y01ZTrOGX4oWPY7kHf5z0MFkG7X5lcdCfkfqsG6FtDGZCC4uFf+U5gilWjF/hGFNzN3V+TGUVXjP+t25e85gFK5Vr+QcFXrGNwRvEzFEMp/VouWFUwr+XtNZQystaRJmv0qb0uDmt9bqrz+gci+Q6mKwmqHx7WoY1BKR6o1D3KjQebGlNYGW/msNI3yQmwiLyZXjKfBcT2kUqyuLnHi+DGOHlnj2rU9VlZCvvKVL3Dp4gWiOKbZrrO8toxtr/DgQ3dTMxd59IE6L1/b45PPbLPZDzn6jrNwNeIH3vo+bm7s8erLX+LKtes8//yLJGlMGMZ0mk08VwAxSmm29g/Acag36hSqMxV4OK5lsLnH4+sfYq15C6s30HpEYiSxrpEKTTqJqamArY2rPPfKBq9e7zKa7tJd8WnIFr3NfXp7fYyG2G/henchwi8g9AAlNPVai27tBL10i+EkRCch820P5WoG+wlpCrvWJ9yY4K/VmNR9Rs0mc/OK8eYu22nM4tw6N90acQCdhsv+OOL4isd0kBLMz7HkSJzJPjccl5NLTUZmk4v9kCNzilpQY6RqrONyrid46dmLrK03sGlCf79Pb6+PTjS/9qv/jN3dITrJjAAps4KSkY0xiSZN09xYFSWjbw3oIt6oMNrFTCJ0O79/yN93qN7InRfOPGe3rfPXfMOd7VtwaomcrXTw3A6e26LbVszPv4du8wEeuX+Xje3rPH/zizxwYkKntUeU7BMlGikgcH1GYcpcEDM1A1BjXFeDqrHq3U1DTNHxJsl4B9IIp9ZmkxoHV15mdOMWj37gbZw9dYbF+UVWFlep12pZr4TAFW72kJ7D0cUT/I13fYQXXnqJT1/7DMPdA6Iwpt8TNDyP4X6PD979M6w1juJK93uF5Hu9/f+6zQwDEAjpIKzK5CBaY61BSIW1CqF71JQhdTyGUY+bB3s8d2UH67jcf/JemoGPFAaQCKkOM43k7KDKdbuVxZGalMlkwvbeNi/fuMgbHn+UfX+bBQd80UaaPpp9BqaOJ5cQMqbuBUjdYa9vePXaVxgc7CBkyn2rJxgMI/bjKZF0SLXCmbsPofdQSQ9lQ2q+w3J3jtWlu9mMbhIOhkRRQkMEeK5PmkrcSNJQ4LoC19F4MsX1fFTqUPMNSgo81yPwaviui1t3aJFgEgiaDVACqyztJuyaEVMCus2AmAnK9kiSeXyvhQE6tQV86VL369kh7rgIMoChRH22SX8PtULZkWmts78VZ4nWmvE45MKF6wwGIxqNOqPRAZ/+8/Psbuzh+5q5NY/lU3Xe9WAHYS8ynlriFJTj4Do+o0gzx5Cx2UY5Q1zPwXW71J2jNJiQRDcIBxdJk31GosUt7dG/cp745i0GG3tEg5BkkpKGKTpK8qw8lvhWnHVSgjaaF//8BvW1Ou58k73rMUlk6XUVSsBg33LzqR7DjZBkojE6k/fMZDelA7/4Jbt1nu6y2qr59m3l/SVwr6hbyjM5l59obe4AuqUsxoryzZkkpshCYksWstq9w5i/EiNgix0iv3d5fX6NPZyP/1A/qQDp8ikK0FoFGFl/VIUwsMVgiAwQZeDHlmC/uE5UBiyTVhXAuPgibvNKMLPTSqMj77Slsl+V951VkoUKq4rIZEi5t0KWUqOZ9ygjQzKDpahuXIAupWTJ8FY9JWWmr1yKVTxDaW4U7LCYXau1yb9nA6jssUTW11arjpQuQeCzuryAkparV69i0ojzL73K3u4OdS9hGiX0Bj7Kd3n/B9/G1tUXCcQVImfAtg7ZilJiKQlSw333PcjDDz7IH//Lj/PCC+eZTKeMhiOkFKRJwmg8JI4clASMZhql+FhqTR8Z+MhmQLDcJFgLeNub38B8o4OnIgx9Uj2gn9SYTFyUChgPxly9ucP1TcGlXZ/BwT6ohOOLR9nenjAxmgiH1Lg43XsR6U1UPMBxE1o1j7WFBZbmT7AVXmPan4KnUaqGg0KnMV4saDqgXIknYzzH4jg+yihqvkEK8L0agesT+i5uXdEUCTqCoNUgFSC9FM+PGZoxU2ost+oM0hGYPjadw/ObJNrwpU8/RW+7RzjoY7QmCiPSJEFry2C4g05NTiiYrJZAms2nwlAtUwNbW67zwntVkDLF2iozaFFOIWZL6nAq02Itl7aAzZ2RZLKk7NKC8P7GhgF8izwHxWYhcjAOlrp/lLtOHuX4sYT+aJ8TGyscWzgA8Ty3RptoM6ZTA0/VQPlZ0mA1xZGaQMkciESYyYAbGzfY3YkZpQE9z+HCfsTg1ZuIRHPfXffy4D0P4vv+1+sdSjq88eTbmPdWcbs1nnn5KW7sXmUwmKKblsfW38njR99Btz7/utfg9fZd2v7iRV0KEgRoPULrCaBQok2ajPFdD6UcjFynN5mwsXWVvf0eJ9ZOcN+J+6n59XwDO2wYZPemIqOAmTCS8hBXyqFZb3Dq9HGu6+cJEhekRVqfVPsY20CKVaLwOlZ36e1Jzl+8wU6vT1APOHH0BM26x/72iHA0wjgesi7wWy3S3RfwzARHWVp1lyPHlvBra+xuPU1kxqA0yvPwvS7G7NNtdVDTIdJJUJ7EcWt4bhuZQKNusAIc4dIKaiy0miBdvDo0QomwEu34KFeQolmsdxmZGnVH0ZIWKSDVlqbRKGnxVA2JRLmzAN4Cvhwexu+h/SQ/gWYFszKAKHPQlGpNfzBmOJwgpaBeU+zvD7BonLrAOB6TvmSw77I/2mU/nFD3La3Aw5F1kB5IDc4I3xF4jpvHtCTo8YCr1y6zt7HNTgzXHJ+r+z1GF25iw5DR5oCwP8Uks7z6GmZ6+XxqhsOEm8/ssThJ8bWl3lHYiWa6IxHWsvX8gP1XRoQHMSY2GG3LOICC0y/1/xUWWQow5eHOzJiwueFQiFNyt7/FlGfJHekDK1OimDdCUGZLuh2SzzBwwTLOAhQLsPDaaoEZJXkHYVjIpG4jA8ouFuA7H1xx22tFlebDOdcrrHvFU5Bh8SIFaXFFsVZm7zm0/9gCMM+Y1NnL4lBnRem2mBlQ1Va9b2l8iMOvG2Mq98z2tZl0SKHUzCvguR5GmbKPWZXb7Pfy3+SenIpxkKVKzQypwouhjc4rNovcwLIIKQkCn1arQZoaHCVIk4iD3oRer5+BPiF597seY30l4MKlDfb7Y+bnAm5dvsz2/hbN+hjmYXMSEUUax1iGV8fEd2mee/YFLl2+Qq93gDaGVGtIM69YGEUkSZLJxXTmMbZJwng8xcPiuAI5kaQh3PPAEnuTTcZihCNTjIbhRLC7E7LQ9rh6ecjly322DgQj2yJoQqvVwlGWeNgnjROs56G8AL/RIt2+gE+CIy3zc3XW1pdx/SV2Np8iFRGOEnheA2UUwobMtTqIcR8ZaJQX4Lh1XFVHJtCsG7TNgsO7zQYmqiOVg1+DBgKsJHFdjJOCtHSCNoPUp+lJFlQmiTLGoKwmTWNeeuElJsMJo4O0WOkZaM+Z/iTVmdGez4k0zfeBYn0UsqAiA1jp6cp2i9kaKkB/MTfzPcHOfrkzHakt10SWNWy2F5UGyjdpGMC3zDiAw4dfcTBaPMdnaW6Nxc6PoU3Kxu7vsRMO8dWQY36MZkAj6OAol7rycQS4NiWKQ3b6zzPZh6cv9EimAQe1gGtBn81bMelOzCN3P8rSwtLXNQyq3RNWcGr9FMdXT7CiFvnK+Sc5CHs0ag3+5hMfIfCC13RXvt5eb9+w/YVuOnHox1/y5q/xe3FDAzbBkmljrdXobcJKiwAAIABJREFUdIBlgpQBiBYmndBoHcVYw8BKBgOH3pamqeq8+czDdBptlPKoVkL9us9SoUOVUjQbTRr1JiePniCxMePhBVKdMNISYeukuklHLGJ0g8FBTDwNOX/hFl997mlS43D3/ffxyIOPce6Fr9HfO8CMI5Tn43V8AmfANB5QlxrPd2h1WiwfO02Suty4dYO0kaASg+f71OrLKHWV5SMLTA52wE6pterUWsukto0rLJ4jiI3FomgHDVbm5ulHGqce0BYhRhtE3cc6HsloxKnOEbbDhAMbMu+08VWLsfAITUpH3um6FaI6Tt+bLUufmOtUcyOhADtSZMGpplREW3Qa53pXg5AWuSG49fIBl7+sWF1zYUnywKqk6SakYkjNb+C4AU3Voq4SMJLJ9ID9wU2GuxFPnt/GTARX5wKuh312bu4Tbx4Qj1KmvQlWz7S7ZQExY1G57l0gsNqSTjXbL/ZwrgxYe2ietO0ydQU6tWx8cY/pXlQC7Wq+0cL2LYFm4TUQle9YiCxfOBUQL7JMPbqQF5WHfcUwEFT6nAfaimrmn0NolSqwFznrXF2GJfssCg9++eZyT8rrgOVjU1gz4tCeVQJlWzDqVSCd96VAMbnxeMhTYWcFvgrAVI5f1QARs8+relmyjEol/J+lea1kiJoZq1TkTofnAVAG9Nr8mlll68JII7fAOHRfWQL//G95jvo0f6fnebiOgyBj+hv1BliDsZAkCUkck5oUhCXNx0GJw0Hmxhq0yYrGSSHzzE7ZMzhK4jgKx3WQUuC6LvVGA89TjMcT0jQlicc0mwHNo12k47G6tsLP/tyPU69bPvFnT3Lh1WvMNQL+8I/+FD9wWFzvIDuWRBiUVCw16mzF8Ozzr3D9459mNBpn099opBToNDcErM0C8FOD1hrfcwhjw/bWHn7NQ+wI1HWJM11j58Ir9HyBJw3zc9AMUqJeyP7elHhsefniPps9zSR2EF5Md7HB+vpJdna3CA+G2CjF8X1U3cd3+pioT8uxyMBhbnGRuZVjRKni2q1riK7FsQY/aKO0h+cfsLQ2z2hnA+XENDpruMEixjbwhMV1INSWORwWWm1sNMcoNbg1TVuM0YnGtFqkcYS0AauNZXZjzZ4Zs+J2GOgakZUkJiXQCQcHfeIozj1+IHLPkzWZRzrLSiTz/TNLt1vsnTMGf2ZEF96Esgp3PsFtblzkVxXLvVw/Zb2EfJ5mBkqxLdhy26iuca3tTML4TRxR/47FsLNdLMvt63J0+RcQjRZx+mmE3MAVKa2GRlpBkkaQJgzChGu7KU99TXEwXeJGY4ppGcRcSIRlemlCt7bI3/nP/ptsgX5TPZkd4koJ3vvY+3nisR+cvcZtjMXr7fX2jZpl5ry3QCUYcbb4bFYw6TAd93Xu+dpGxgyGSLAJCBfQWDPEpnsYsw04GJ3iBPdhmSM7ZD2a7WPZx1r47HN/xtNfe4r4AB576DEef/gsRg+Qcj43Dr5e12aHdOVhSjeoxeLgcKb1TibxCK1DpnqHvcSSiFX6w6fYG6+zuX+T7cktgmYbvzbPBx//IV4abbM33OUgjoiVR70eMJE1nHSI0gZrJU6tRqN7ipr/BHp0gdGtKaLrokKDcBys30bOt2jUx9hoB8/VHFlZ5uyxI9zanlBrSGK7iFEusTVY4eJ7i3hWs9hM2YmndLqZq5hEsnL0NDt6lxNzU4TTpOUvokWDyDiMTMqq+CZIie/VliO3avVOY03G/BqTg+mM/UxTm+Xpz5lrx8mKpO1uxfy933iRX/t7j1Fvekg3whMxygOFRqQRJonZG4ZcuBnyzHMR1/ct++s11LJArviYmzHJ9SHCJNx66loe4EseA5CTUDnQ00XJXGHBCIQ2iATiacKVz24inLx+gzaY1GDS/MEOEcjFQVyerodeyYYlk5OYzJVySO4CM+A7u1vl9cJDkANwkevTC2lUCRpkEbdQWXMVZvyOLaTCmBcfU/anYC5Flm2niAOo5l03OVilAmQzp0HeD2yZXdNiMDpnSw8VgzvMS5byGlto/WUJ1qtxFEWToig8bXND4fCeUzy+TvMUkOJwKlFjDMpRr7GF5nEAuRFpMOV+JWxm0EmlqNVqpGmK0XpWaVYIXMdBKYXv+TQbDeq1GtIKuq25bBylZTQaMx6NmE6nhEmIdV2MTknSlCRNsurPedxCka1GpwnWSoSUuErguQ6Oo6jVXTxXYYwlDEd06h6DNOLokUXe996HeOc7HuKuu09gjKQWNPhv/87vsrjY4bnnL3L12hYX5zukBlZaHmfeeYJrFzYZb/VZnvN535seZumHHuF//I3/jcFgQBiG2fgoReC7jMdhaUya3BuitSGOs+AKnUIcZlJt11EMdwb8/j/8JCvH68y1Pc48uMLSkRaDvSmnjtf42KduMtet4xpwJw5WBcTjkNrSEgeXn2c/0QjXxQt8IuFBfACpxShJvd2h3n4I330EM77A8OYUZ8VH9iNwAwiaqG6NRm1IGu5QCySPnD1OqznHZi8iqCtiu4hVithohGziuosEytCox2xHI+bXDDvbPZbqizQ7K/TtLic7YxxvkYZ/lN2RwyBN0TrlqJAYC1I6pGlMmqYUcSZpkuZZrcBxnHKOVTOJHeIcEGXsTjUBQjHnhIAkMbnXPkeoFU8AFMRASUuV5EB1/pfeq9zzb2/z/n299m2PlBM4rNZ/mK1pjZfHv8eym1DHMNJDXtmLuHIjordfwwSn2F+V7NLHTicsLNWYhIbN5/v0Lk44dvTY18VY31xfKkfC64bB6+0v04xFT1Pim2PSGyHSBWfZQzQUNtVgY/wTy1RW/ze+p9X5P/LtxGhIJ5jkAFlfIt38HdTCT2LsJTCbIFykOoFwH8rCkEWRGefwZ2mjaaRd7j3yBtYeXedtb3obnld7zWv/Mi0zwBVKKFrBPNZqmnaeurvEk5f/gEeP/BRnl+f56NP/gmMnFnn/W+5nNNqg3ZhwjxZ8eWtMtBeBkjRqAfONeZLeGHe5RdNt4ch5Gu5Jjpxc5F/88/8TZ0XhppbFo8usdE/g2znmTi0hXBcx2aTbcQi68xDUaKZ7vPTV6/z0h96K69UIzZCO7zG39AhmHLK79wz3Hb+Hy4MNTKNGzV8gVC7tdB/PWaBVf4A900ZQY80XzDseCsvXN6e+l1sGcI02eXEd8t81SInKAzLjJCmN5ILFTpMMMEsBo33Ln/zT60z+2ioPvcFn3pHUVMK+HvDcVsjlS1O2BpaerTFaXiE6Cl68R/eI5NbGlJ3zE0bXRjixAWvR6WvYz7f9XmQWEkqUS0lbA+kMMh+6R+Gqh5kn4bZ7z5atLVBzdmhLVWYdMtqWMfyVjJ/5aN5pgJRjakzmlbCHWfJqXIEQedG0ch+pdvHwkV+V9pR5/wtm/fZO2QJAZN93IXUpgMjhSwutfGYcaWuQtkIO3M7iy8LbUBgQIvc43G4YZFmEVOU7KOM9xO07k71jqyqMUiFmmaEo+iFnhkN2jSyrJxeMblElOpyGmaOjAFRKYW0mC6sFAe1Wm7c+9jg/+r4f5q33vJnwyhi3Lnl17yL9/gF6OmV3b5Pf+sN/QpREKCUYhyGjicFojSQrMOdJB2MyqrdZ9+l26oAlTDWtZkC7LnngniXm5ltsHYT82kfu5X//51v88i99gLluDUOTS5en/Ppv/Bbj4YjzL29iDFm6U6GIEotfDxjHI174wvNoR2KjiI2X9vjNp26S6o8ThjFa67IGhk5TxpFGG4vjFCA4IwckpuS9qmx3mhg2rh/gbiuuvwprx+bYvjHl+JkOd79xnj/8/Rd57pl93vgTjzIaJTSt4P4TCzz++ONMI8sXL+8zPYipz9epBx6B9Ih2Bsytt+l6DlKuM985TnvB48mnnsRb90j0mCP3nmCuuUYSO7SOLSJcFzm6weJyC9lawKuBuLXDpedu8RM/+xZS4TNJ95hvLtFUHa6P+mzuP8vDJ+/l+b3L+EtHEV6HFEs7GeB7S9Tdhzkf1lhodDjht2gpl2k8RRqL4yjSBLQt5pAl1WlmtApRBrXbShaiMjC+WJP5hNXaoNOUwkMrZSZfu22CVzagbCUW1ZVngfCyXCzV5VEld0RO9tjbN8y/oH2bjIMqCLc41FmtPUHLOcKVwW/w5Qs73DSa1IGJNETBAJu8SDSFmvG5Zz3m5StjLr4YsX8xomYb/K+//lvUgvpfsjd37Divt9fb/+emowQdpQgjSDZTEAo9VdgNg3AScA3uER8zCZH1oDx0Dy/27HedJIwvv8r4/DkabRdhRnhLi9jwOugxVmlEU+IeOYJwA2z6JYRsYW0DjIusPQy4Zd8OBxdmG4pSHkJJTp+4i0fufyPeHTK6f4tFUWKWKgRykELRrq3y3ns+wngyQArFex96PwfTTUbJFp22pF1r8+xnPs50eAvVtIjAR3ge60tter0RQWQZ9xNOPnyGB9/ybq5sXkTW+iTb+6jlLg1nHneaEjuXOdLaZX4x5iAWyLGkLU/RbtxNePAS2iqePXeTU/cIIrnOdtKjq69xb7fGXtDk0niPpUaAlIpUaFzVxYoG8/VH2NUHLKmYlvLwlMETEMjmbU/8/dFMroOlkBZgcV0XY3RWsCoHjg4Ka8g15HnK0xx4aa2xQpBqzde+skVvb8D2B+b5gR+b5+JGnxvaYn3FqOYgrKGdxEi9xXSY8thpl899bcrGC1NGNxLSXszWheGsgzmtnTH5t0ljuM3+LqQ1ZsaqF0DbpBV6v6D1K7ZB4a6f5d7P7pfVOJjl0RdFSsr8NlJQglJtMgMr+0xZuVcOlCvBzUKITCdsZ8z5LI/5a88ym1ORGSDJ3jfzQJSEfvlcZRaq8jM5BEaKrEoyD8QtJDwF6FdqBjYc1ym9D0JmLp3b4wUKT0E5pypN5LKpTDoEWpjX5E6KrGhGmzyLy2uNxZ1neul5sSZPK5t5jnQeQ5B5FAogZ9FW54ZDYeBkr/meh6MUf/u/+FXe/c5346Ye0StjktigqHO6fYah6bFrtjjwDrhvaZWnrlxEOpJASmKp0FLRqAUEnouLZsH3+NEHzvDwyWUaHUXQFExUwtEjc5h0gKoL3MU51PI6yo75T//jNxM0VgjHm3z0Y5/g//i/Ps/mZg8hBam2hFGKseA6Cqs1SgluXN/j7Noq25f3mOyFCC2JY8F4Emdsd5qt52zOZkZbkiRoLWfzHlt6cyBLtwqZrEoqiVSSNLGkacr1S3ts3ujx8rM3+fyfKk7fs0DgOgwu7PHoW+7jzJmTrC+sMe8t8dTTf4SwI4JFF6cZENQCWkFAf2cfPzSMeiFP/Mi76ayd5MbWBVTQJ93q4R5boq3nsJMDlJyw1t5hbiFkNwR/VKNdu5+GN4/UVxmFmqefvsZ9b5AciOOE8WW6dszZOY+VxhyvjHY53W0TWUh0ArZBEJzAhuv03Zh7gwaB0vik7N3c4bd/6x8xnU6I45hUp7m31JRpaiE34CteOWOzsSk9gPnrWd0DhTa62AqyOWtBl8XMKrK5Yn+x5pBhUM51W0joZLYH3M6glO+3M7fgN2jfkRx7QkgUAQ33DCfb/zXPuv8VF87tUTsu8TzQwjIZj9FNxZxjubSRsrWVEvZSxNhSb7i0Gq3vRNdfb683gDxISyBdBRpUx0GMDHLJw44tYJCLCmfORQ9HiMDLtaeidBPajDbExDE7T32F0QvncHqb+OtziEDiiA3wNSJIkL4Et4Ue9bHOAjJpoupnkX4HrKRMl3kH2LclQhDAGx98HEcpPLcwDL55aPv1vGuHD+wZ6LIIpFW4MqBRUyip8FyPVq1NbI6SmiHSbHP0xFHqz17BHSfUgxZH1k8RxR796Q5Law1ONxdZXD/BVNbQjuXWzV2EE9NeuRsdDUBusLbicjDQxGJMp3kXl+MlwnSeWpCy3NklGU/Z64U0ECw7Hpumw6ss4Ic3WJ57GM95monKwJiHxVdTJvWzoHxW1CKOcJHSxRFZ7mpZyrC+v8yDDBQddnFro0v3tbWUVW1n2tci/Z7B5AegchVpqommghvXJvzZv0p49eKIt//sMufPHbD4YB3XkaRGE8YaWZMs1wQvXU7p7WninkZGBs/L6gdIR2aViEtyuCK5yYHsHTi6NCIqByO3yfzyduhP4raf1iKUwqSawqC3OShXUmCsyIwAC1ZUjJZCHmMstvqh1sw6XGUVZZYMw5bvteWz2VJyk5PwxTeSA1xdyhpn1yEEjuvNAHHFq2BzECxzIXKpWqoCidvGufivZOLLe4FQCpmD7+L++WjP2NLcSCjkSNaCFapk/4tvoogpkVKWQb5Vr4QxumKUzTwEhUFic928Ja9BoLLP0FpXjMgCTGXfjeM4uddCHrpGKcUv/MIv8NAjD9PqdkhHCWNPgwKzaHEnAYmSbEx7bPT3+ZEf/Su8+Du/jUgi4lQjTOYVcaygqRyW/SZPHF3kAd9nMY4JEoUNLcsnHVx/jLPkoh2BdTQyGjFJfEwS8t/9T/+YzY0tdnZ7bG/1CcMU5SiiKIuKcB2F57soR7C3vYsxMS88eYMkTNGJxWrQOguarQaAq9wTmKaZzq7wKJRyrYo9aW2WkEBYg9DZ+Kk83W5iDEkMoYQoUrz60gHhRDMd3WSwMWXr/h6Pv0Vz/C0LdOZ9pBGIOKHbaDE3t8ZkoknsBVaX57m/uUats0ykPCKbsnVrD+XFdNbvZ7J9mfn2kEbdMA1TUjFhvnUPz4+zWIN2Y0K33iMdR9zYGtJVDstejfNqiX4cc0bvszz3EILPEnoNGtbgWI0QktQ5Ss22GfZ2ESt1fKeGIwTD0YBnzp1jPBqSJHG5noo5lBEAlRS9JQ9oZl41LNLKMkDdGn3IhVmNjTHWlBi+Gpg8WyGzvaJqKFTTEldJgsJDZCHb++7U3t3RvgPGQUHTCKQIaLj38NDqz/N59c842OvjugahLRECm1iMb9jai9m/FTPdS1moL/Khn/rw99t5/Hr7Hms2B90iz1DitFysTVFtByMsWoMOFMpIrPU4ePIZNvd26N59itX7z2aSgSTh4N98Dvp7TG5cxexv4rhTnJpErnXAjZA1H1FrgFsH1cEKn3Tq4jVPgVwE0ajkTH9tL0D1X3Pt7mte861thz/b5m5Q1/HyVxSOcvGpkeoGWiusfhqlJF7gMddtsL7a4pXnt1ntdFhcWiJoLlKf7xJ4KTu3zjMMQ5xVF1zDfKCZcxOmSiOShGawxMhdQZtNAjMhUJZd5RKnhv5+xIWdiywvzHM8mMPaNa5OLaneZbHewlpDKmq4sklNdvDUAp601FAI4aOEgxIKR9RK4Pn91opCelWZSIF6TQWAlsxvRSWizYzlQmQgI45TVOjQ27fICymdL4VMlcPuZoovLSaFxApECg3P4eZ2SP9WTNLX6IkhGacVVzxUuP0SVJagNk8vCbPzbxY/QOXApQT3JUtaGhhFJqJZ6tBCJpAZ9Hml4NukSOVBXg09yiUYxubZkGTeBzLgAPI2e16Ufc2qGovbWP/i56xScvY+W/GAFG0GsJMkYab9L82K/HMkFbuJAgtmzPudqVZn9xCl1KjoevFa9ToKI6L8og7dqfSqWGNmBkXFyitrRFTeKmWm1S801TODptK/AuDn8phZIbL89cJrUDE6HOVQndMCaDQavOeJJ1heW0UqSZwmbB/scnR+FWfRR+4rbrzaZ3+UcursfTxw9i5++tOf4+b2Fk9tXWNgBQ034Fizyw+fvotuMuZ4q8miK2jWLcFRD7PgUpuzUK+jPYdUBFjqkDQwkcMff+IZnj/3Ktu7fZJU59mFDLooqpX1GqNTotAwHU+RrmC8GxdTIQ/SLgZ3tnYNhjSteohm41c1DI0t0m+S1dgUM9BbdYYXTqcknSCsIA414TAmHqWEg5iDzR2OrSZIJfBcl/mFGs0G9G/1WGgGdObmcedWac+16Ed99rYvMIojnBUPhGZtSePVU0KjUdrQCDoMnBVscoEGIUJ6TIUiTg2DXsxL2y/z9pOPcbo5zy0puBa7rOt9lprzbFqJlC18W0PZFilN9HTEarNN3anjSI9XX3qVj/3JJ9jf6xGFEUmS5kZmMdeLdSRKb0E1kN4aM4ulMQaTky+zuZ57ByveR611WQ+j9Grm1xbrOFtYxVyd7UXluqySJ0Urv6jvUs/B4Sa5e/6DLC5/ius3EyZmigoEti6xqaE/1PQ2Y0ZbMekQFo4u8dM/9Nezt34/nsyvt+/6VrgIyUGT1RaTgGo6SE9gnSxMIB5BElrqcwH953a4cv7LJL0BC905VLfL4LnL7P/rT+MOtxC+pD6vqB9z8Y4L5IqDNYvIYAHcNsgGliZpJDA6IZnUQEmcb5Rg6E7E8HU9AP8uWgEi74DSVuGoOkoeIfBXCDyfVkPTbipq7hjXjlhcXkUqn6C7Snt+AUHIjUvnsDVJfaGF74zp1BPqnmJgJXNC0a4vsZ02adZSFrwpThKyMQ6RXY/QGL787DnuXTrJIyeXqakuzwiXgekz7y9iTYgj53GcBVI82rKBLww+IISDJDMQXBUUT/dtHctvS6uA/pKlzoFvkYKvkObMAHolvWcla4ZSGRrWWgCKNHG4/EJM+90tBrfG+L7BaUiE50Bi6A8tB5sJ0+0EE1qSiWHSS6gi0HLExeyzCtRfauwrRoPJA2mRlAdjcbuisFXJpBbMemE85BAcO4PBxVldSOoL55wQAl119VMA7pwpLK6dkdwlk26L6ypLNWPY5Yzxn5GCh2QDQhQVU7ljOmbfmUanaV58SVbAyKErobJCTellmH1GaZsVf5iZUcWHzXBMBWB+ozVSGGymynQKmeXDqk7C0sITpdSoCLYu5uTtgKgwYu74TCnz1I6zfgohcD03C8JN0yx9r5T84Pt+kDNnz9BoNDCpQUdZZd7gnjpO0yMdW6KpJZAL3HPmLKsnu7zv7vfwbPg5dBhz0R+C8nl84SjvX14jmGyR1hT1NYf6mQD/TAs73wItmIo2RvikuoYxdWziMe4N2bw6xcYGSRbnIoXAUYYkNaUnx2hI8oJaxlrIg8aNma1lyILfS5tSZEZqWuTnt4XhO/vaZHGhztd5vn7KlLsVA4XCG2Q1aWJQedVwkxpu3tih3x9x8eVLvP89R3GloVmXNIOEQA5QZkCj3UJrBzW3QrvdYO/KJTY3Xoa6JFhs48k+3aYldSV2apmTHq36MhtJg/lWSFdNiSPNdpwguh4p8KkvfYE3r97P6c4SvnK5OHEZ2CHz3jokYxznKMYGoB1q2seKmJW5JaTyuXjhMp/815/izz/xSabTKXGclIHIh0mFfP/IjdXC0Cqt7XxdFDuIrayRfOlgKbKc5Z45Kct4mNdsuUeh3BplZaYfWrtitoeU6+i70nMABVuQySEsBsvZ1fuY3IoYhXtYLyJ1Q5TRbF2f0L8UkR5YWrU5jqwfp91ufz8eya+375E20wnnWtWJJtmKcO/JM2fFFn1gCRND7Lo0VxWx8xBO+AL6uYuM/Qb+o49y83f/HGeyg+tG1Jfq1O9rETw6h+zWsLqDVWuI4CQaH60FJnUIJyOkdBnfuE7rmIvyfMQsMzuVU3LW4cpB8J1rr8U+Qhas6HL2vp/gxLlX8Q9uEEhN0ttiYaUGToO9vQMeeNMpFpfWeeXSK2zduEljzaezsMRC05BGKZGWHJ1rsGpcjGjjolhfWWS542FHm1y8/ALdR5ZI+4oXP/MCF448wl3Lx1lsdHhXq8Wl9FHi9BqpHdKWHQIRsJ/2WFYuDVkHNFmKOh9PBpUx//5rWXXsOzXiWV51KqyYpMiQMcu4UQUemeVqrSCOLOHUUIsMSnrUCBiOJlgNoiZRroNINZvXpwwvRZgJgCSNLZNBXAKc4kAtPAUiP3wz59nhiBcgCxDOU46K4qy2eQXTCtqdsfIVoq56mOf3rnovbIGgKq770iIojJjiYBbF+/PPyz+zeE3mEpnSaMmrHxeMenF/a+/8Xoog3EJCc/g7s8RRjLEWR6pZFeLq//Og25nLZUYpiBJM5OMusj1PKnmbFKji0Sg8KWVAch5wrPKKx6aaejQDLUXq0fyDKL7N4pkKQwoyGUwxLoe2OlFIpGxZS0HYinQoH18pBY5Sh2JFijF3HIc0TUnzcfA8n1//9V/PZEmAjjVEgqXaIqrjZHMoNBxrrTNfF9TdNYKOgoX30Ii+wodOPswrOmYrEry3eQz2XkLUNZ21Os23LeHe00Y061jdIdYLbGxYmu150lQSjTVmnHDtyh5PPPooT517DsMYKSWek2ULGk9ioijNk4dl46i1wXUkSaqxVtyR9reY6EJQMtM6z0xUjkZlbhbeNWsK47vIxlUOfC6tyw1oKzDaIoUlNQasAiuYjCOm05heb8jOzj5vfOwYnQ444x1krUl3JWCaOsSDkLccuwvl1djd77G/u019JaAzv8hyK6Y/TJkLAta7NeZ9gRZNXCQnjq8y7xsubF9ho3eFzkPzTHqCL/6rL3HljT/EXK3FKb/GirvA9fSNTKNLxPqABWeVKSGRDVlQAQvLR5BY9g8G/MHv/yGf+uSn6e33mIYRSW4YzKQ+Vfa/kNsdXqHFWs/21cqo5Vi9XL+H7put55mRUTF4paQo7HcY5IvZj3xhFDFOxX3lbXVJvl77LvAcCALV4K/e/xHM+B/z1MufZ3O7T3SQEswpBlsWHSkcKfiRJ36M//xv/u1DLtHX2+vt29XKRVro96xFTwzTqxH1MwGiprIsipMU009RTYeVbsZOJfMLzNkmrV4P/ZXr9P7NZerDa1i/g3d6jeYHThGcnc8KAopVhFxBT6eYoWZzZ8TO3gSihLmW4mDrJsff+AiT8QCLpbG4TpVVu911P4NM321rpki/JnAcj7/xc7/K57/6R9y6/hx3dY6xVR8wYcqbH3gHayvHuBROeWZ/ExtCPJa0FxdYakwY9l2UFSz7NQ7mu7z0bJ+H3/oYm5tfRfuWSX+Tp/960IEFAAAgAElEQVT4Gc78B/8e3qu3uLb/PL/30X/K3nCD/+iv/RKegLNOA+Pei4vN+2Q56h4FG2GRWAyurKGE931tGAClG7yQDMAs64UUAqtEyXgfep+dscsVsqwE40liGA0Tbrza49LFXe7/K2uE4ykHGynULW5NMtgy6EThCOjvTRjvh6+hRKl6DyoMGXdM/ZypFyXqt4YSvFqRBaHO0nHmh6i2ZeBg+f6CSRUU+TbLdWWsLXOVKyUPc3LicGfKYMHciC/qHMBh1ruQ82SSmlziUWHWy+dlZqZgc009Mw9K8flGa3Se0aRqGBRZVFRlTytuXqY2zvsJs9SIhcSqkDTO0jYKRJ7l53bDKxsfcQd4yl0flcESJcM5A7MZKBKV+0EOlIwuQanI+22LYmYiC5i3evYeJSWu62KtJckzxUiVpQ5NkzRLZ2oMvu9z7PixzEuR9zHZT0l7mtaDTWTDBwO6F9G/2oemYnnuKALJuLPAquyyiMeRRhMdaNJoGxss4551aX/oEbzlFtJpg1hB23nEeEi8/TQ7A8l4lDLY2mS8cx3f0fz2pz7KW+9dx5xPubbbx9qsQnPG3Bs8R+H5DlYIwjBBp1lMlBSZQZ9bAmWhteK7LsCn1hWPYDEfoQyQL5zlSsqspomtVPU1Fk1uZAqRpUKtGPBxnCJlfr3NUh1Px/C5T13gAz91L61hSH2qaXbmaB1dZu34mzi9ehef7e1y+aCHmUIaSjpLiyzXB2ymPk3Xp1Wrs4PHxReGvOkd7+TViz1ELeLmM69y/svXWf+R92CefZk42OR/+Ee/zn/57/8K73vsB2ggOKMa2MaDnG2SzzMAg7Up1kpGox7/8Dd/iy9+/kvs7uwTxVEejF3U55ClsZ6mGkGWHU3l86jwKhT/zsY7lxFCyVQUXrzZ2s/mf2HkFq3YW4sxre6y2VebFRe0xuaxC5kBXaRPk/nrxXL6ZgSx32HjIHsIhYeQmgePvZFeuM3IGWDDmIPLU/RIUKsHBA2fTqeF53n5mq9uJq+319u3pxkzA0U2sVitcVtZrVIlgDTLvz3aHTF4dcrih04DcP3LEc1rCdaJSMe76OgGm1Ly4Ic/TPCwD40GWtZBu0x3NNH1mwwnCZox09EmKjmgNufRrh1l4d5V4hvPoIMmxj0FJkWnE6RTo6zvmjM+30trxHEc3vWWn8E+9pMYHTIYvMiImNRdYkM4bFw/R/Tq59AtSftsl9On22yc32G9rTjdXaKVLrG918ddP8KqGvHme1L6dpdzQ8v6W99J+uUr3LfUZPhIja3nhnzsTz/B1Rs3+E9++W+xXO8wTBJq0iBJEGQucYcEYz1qTheB+sYP8X3Q0lSXRagKMCaYGQjFAVNltbK/z+ICSmytc9ZdW+IoxfQtw1FIre3hxD7NBQ9lNeNxyv7lED0SBA2foAHh1oRQAJ7KikrlxHLBWmeZkmZAuwQkcBjoFv0rnul2cFoYQnYGvl+LoS/Go0jtWsouqveryJqsrZB4hfeiNAayF6vBulWNd/EMVYBfADebA3qqFXiZAffSc5EDBAkkOdtuKnEHxXNiITF6ZlAceuDMUNEFEKl6HirPfSfez+9fYa2hyNwkSqCYdVeAzKRExTgdNj4FeYKWQ99RwdJm2ZBmnossBafK0u4W9xcZcLPGIJUqs/RU+yqlIDUaQ1a/48SJk3z0Tz5avh6PY5Ca2rwLjbwiuoZEpgSxwhUe3qLEAHsvKlZDD7dVw4kOiMId9up17v+lX8B7g8A4bWLro4eKcCdi//xzxLiISEH4Ak0npNlKiWspvb0ev/iuY2z2BnTqDnefXGFlqcXVK7fwpQDqDCYxcZpm+fa1zmRCxXyrpNMs5lMWO5THHBSer8qXaMvvbrZuYJat6Pb75Q6gmeMs/3uhZtHGZN+LkmW2r8Ew4mN/8DztVsAbHj7Oz/zV+7j3TT9I6q3yShyy89Knibaeh67L3N3z3HW6xaWnrvPg8RZHa+voccB0EuKurbMm9nnzIwkXBy+w1XRonbyX6KsXcPdfYvHtbQ6e3Ofv/vZv8pm3fYWf/fG/zrHuMiNjaIgUIRJMmiKswXNhb3/IL37oI+zt7WWZifIxVVKi0aVRZvJIbVkW3QMlZ96AohYLCKSqrIdiyKwta7MYUyFiZszHbJzL5XKYHICC0DAIJfKierNm7azit1RyZoh8E7DgO2gcCBA2N6AyV9W9y2/g+NzdvPX4y3zs3P/DCwcvYhWoOZeff+8v8sSb3l/1fH4PwZ7X2/dlkyBci6glCD/INgMNxhXUnB615AqkJ4k+mXDklcvUo5A6Q6KpZqvW4J7/8OfxHjlBFO4jpzWSqcPgVkj/5gE7BzHR+GXmj87TPrFOt3OCmkioezEmvUpwtINqrSC9lGj0LMmoz9azF2mffogwjOmsnqK1dOTQxv7d2YoNMNu0pFQgJVIpWu37iNMDJpMeaTJgGm4zYoTTlnQ7At3bwplvsVzvsuC0mRpwsCzXVlhu9rFRwM2dBjd2YhZtwHD7RR5714e5fv46o5aPTjVhf8RgOmZzmvKmxVU8KSlQqCwlFRJRBo5+t4/nv30rsFvlL0CV3crc41LJWYacyoGTMZJ5YKK1SCtIc6lHkqQgwfUlz/7JVVRNsHjPHK1jTVLfojF4bcnBpT7R1JRyHiklVmapLE2GBGeyh5IZzbubn8llppv8oUTxcJXnLMDLnS6HyrXFZ1QOnUKTX6S7LFjuEnAW98hBbvUaASW7Wna58GbYGQRQjqwA4uyvGeC4DYRxWFww636RyyRnmW+7qtTjF1IDY8t+ldcAlHEPZkZhUmDCw4Cmei6XTohi/Cjys+fPkj+TsTMphi3GovBC5AaRKedeAbLMobEqDazSAMxSoMoitqAsvJbNCStm88p1XVzXy/r3/7L3prGaZOd93++cU8u7333pvn17m+mZ6dlnOMOdQ1KkqMW2LMNxtCSGBSGKkCD55iAGnHx1EgRJ4MA2EEdWEjgLIAGSLMjaOJRIkRKHi0gOOUtPz/Tet+++vWtt55x8qDpV9d4ZSnQiaYZiP0D3vfetems56///rORB9e1Wi/X1dTzPK19mZ28HmWjm2j1EGOSALIPU0yw279IMAxg+QPrHCeevXWNOGRrxPkcyJjp7lod++icInzhLPN5GNDoc3YvZv37A4cYxI+2jJ1fw50JWLp/HZkekxxt0VMz5h05x3O8wvnfMz3zgSdpNDxVNOLiyyO1+RDKO+c2X3mJjr0+aVUX5XME1T4myPY0x1PAiQgg8KQoXFkeMT4BVWx9nFZEqP6sF37p5aV0p3pIAV1WztbE5SZSCREmO+jHfeX2T9ouv8cTHf56vvPx5wtMXOJpsMVYj/B70upp0f5NgdZ615iot1eJYpIRSstJcZrGzzzBp8e07A7Z2oTmKMNvXSOKYuQziuRAGmus3b/AbL32RZx59jn/+j/4xnjUgDFZrJBAEHvt7h2xu7pAmSVnc0Vhbhiy54WmMKZUTdbfEwpxXWvRkUXjQtbmrlOzmQjXy31mmXMFkvZryNJmrCL8px7ojzu4sZzl9z7sV5YtkMUmRNP0WoWrw0IpP8GyDD57fwcaGwA95aP0RFueXawvTX/9N+r68d8QU5lHfk1jyrC0mLfJEBwIjQYncgiCSlCBNkDqF60PSP9qhffh5ZHaXuCGw586y9iMfovHQeVIjsKLH8Z0+encTf3xAa+4Slx6YRfiXaXRa+C0PFQiUsUjdJ+vvkGZ9MD10bJkcbnLvzW3evLrNxx59gduv/jHLWhF05wibLf68ysfvFak0p4VF0Wtyd+81hqbP8cGA+PgApKLZ7tAMmgxp0ELhC4sUBo95Du1pFq1msTnPltDsHO9zfGcDzw84v7rEd978KqOjGGF8dKrpHw8ZxgMuLa3gyaLsPdMa8uLp3o0meVekwsTOncWZxAvf+ALoVprxemXcarN0+48LjoTcXUloGB3HRJMUL1RoLRnta7QQTA4j0DDciUknBptZdJaTjTI7kil336pXjJ2qPOY0n3Wx7jzhiF+VJWQK1DtcU4JayuuawmzvCIUVpgSgUxlCinbMNbSOGMjSIpM/+5RuvPySs1oISg+mkpzkmVDyYEWHVBx4qQDyifmeq/lzmisrQOJSKgrIA6lFBc5zLG9BFUXDpABbzYsSxJcA3YHyE5rNmlY+f8bqAvVsLeV3hNOq1lJDunMc0ylEKVVUdi47rHjfk9etUqNam1dFVipXQCilcpCaJgR+UI7py5cf4xd/8T/J+wPQqUYJifTBBuQGWpm72/ipxm9KAiz2ap/0i9t0By8iOGTst2k8/xyzH32a4MGzpFqCmOXgzQPE1lt0U4t3YY21+YBG+2kIFGHXJ5rMkIxnCOnTYB+tLI+tXkLqYwZbm2xsHHJra8wbm/s8dHqW1fkOozjloD8hdqW/i3mYu6nZouJx1WdlkxUAPteIm2KuVUDX1ty76sBUKlm2azUwaiuBdZlzXL8VfVDTnmudA+yj/oQ3rt3jpatfIWtZNq98heOjXaxSBF6DwMtbooMCIjzaWLtE3zRZEJrF5gLfCfa4c/MKg4MRobSEbYHfCEiGAqMl6SSh7TdY7XV46Xd+l/5ohJmMSeKYJIowWuMpRRRFpEXgsXt0N8fqNQ3cu1DMK6Xk26yp1lKmMLbFu1KoPKw1U/U/poL3a+tORSZE7Tym5kPBvfP1oVwXLaZW86C6z/Sc+27y7rsVlW+X2w2lFHSbMzxy+gkuLMZIqfCVh+/5ZfXGspF+gDbs+/JXL25RK30zTe4zmAMUk1dFtBky8NxKhzVFER1rkOMM8+oR9t4eJtvGSA/v3DkaH3qK3rOPIjxI9iOy8R7jzXtkkxFBt4VaClg500G15kBMINnFJEOMaZCOd0FkWE8RD+8x2O1z7/o9rt06YDyCjVu3SbRAKK/c4Otr93td6vu7EBJSw/7oXu4zbSO0NLRWOgSdDskBrM3OsBAoWsEck/QMR7vbvP/JB+g0l7i7fYet/QOIRyzMNRkeZ1y5+hp2yUcp0EnGKBuxe3uD9609yiCL6KgQX6rvafH8aytiOud2HTw7ba+zLpTZdPKPeVtyjdrftvArt0A8zpCJwEs0R3eHjI9SrBRkcYrNLPEwIYs0OjMYXWzC0w8xJQ7414/Y+sYpqp/WIZMaTioU6DVmdPLiJ8lrlbvIxVTkPsvT7+3aq2rT0j+mbFcXT1Cef4KQTO3qtY8KylGe6K4llZwC0U5r6QBE3cgy5btUAvPKBapsm5IoFQ1VKopt+dNCrcpxdfdqtxZT13RjYXqNmiYKb5da0LaQOLesenPZExYKbWwZu0HhhlQnUrIIuPWDABB0Ox0efvhhnn322fJ+WaYJQj9/Yl/l7htaY63EGo0SII8zzJVD7MYexmyThm28Jx+n8+FnaT12ASst0X5EPNhicu8Oggy5MEdntcvicoPm3BpaH2NGtwlMRKQTbDwAldGY6dAgY/vqLneu3uPmrX36/RSTwfEoxRiLrxSB75GZwl3FulYvxoAxVTEuh6OmJoWtG4bKmh2lG1i9Y+vfr32nBNJmuv9cyY66xQ+cm64gTTUHh8d86+WXOPfkOuNslygdQUPS6LXxWi3GOylnZlrM+iGBt0KctRnsH/PoxVP4ao439/ocHh5goxEyVMSJxuqMoC1AGnSiseOMdia4tLaG/pFP8cqffIXdzS0iPckJgczy+IsyXWjxzMbiYiq0NuVccBbv6tQq8N2hWzf2ygxgJYeqip1Vg54p65u7ZqELKXsTKsVNvf3rypHpBY7CMl8jIH+OvCcCkqv/c1FSIf2QwAurSQyFluOdU5Pdl/vyFyG2NrvcxNPakGUZUhWbuM19KLXN0BiEChESbKZzt6IsQ2sgVshrR6TRPpHXIjyzRONDz9D+wMNIX6EnEYPtfZLD6wg7gsXTTE49Qncmw/ghNmuibB9Gd7Cju+gsJE0GqE4TK3yONm5y55Ut3rpywGaiWZtf5Oar3+L8488wt7yG5wflW32vC8K7L6IGOMBLBNHwEL/XxTQFmZfhz/lYKWE3Yv3UPOvdLtYucZQuIg9e47HzD+MFcGtjk529PVoKFlqKGwd9JoM+yw8uMzk2WJsSj8bc/PZV0g9+kqMkImx4eEXQWLUY/2BJHrRYK+gD5P1CobWuASwpMJmugYoaWHVAtI4IbeXj7DRvRsdMhmlZI8FasJkhS3NiUAJpywlrwDRgsdWvJXmp84hp15X8t/IZS/ZQ07bW9lb3BrLmv+1unbvjVP7ttmqC2r1z9yPpLDGiqiPhpLpX9SyOhNRBQL1IXf5xFedQPmsNzFls7U9XfK3edk5F5zSTRRvIWoam8kWq53X9XXcpKXWWzkpQ6jAt70S463EWU2Sk/oy1BnLtYKwFWVgXRA2UOauLrM5zyh2BQHoKCpLmcIXyPNrtTl4FXFvW1s5yZv0snpf3tSkUQTJQRf/mqUStyUALkijGiy3qMIODQ9L4gEnQofPQBTqf/AiNy6ugBNko4nhzl/H264ShJT71OGphhVbXoFoNsqSNtLuI8TX80QA9SYniPezsHCjB/tWrXP/KLW7cHXJsBHPNJg+027y1vcPRKCYzBs9TBDYPkrU2dwlyxHm64SmtWAX2LOpMVJ1bJC2rAvbtdJdUVq2KgFRz35aAuKwa7LqRIjKumNOqSLGbJgnbN6/TPq3x5jt5xjIB/kyARZJtjzhzep1T7WV20nMcDUeIw5tcWP4IGsuVGzcZjUcEMkYZy14/QiQxq/OG41uaxBoGe4f07+3x937qZ7i0s8HG1bc43j9EeYosk1OFHV2WLFuQBUsekJ2VQf+1tjB5DEfdkiLKY0VK5NIiV7V7HgdQpRqdXkfz+U+t6vlUJrCCfljh+i+/b+7GVKWmlW+bdyfGwneR9wA5qMSZHIUV8A6uEPVGuy/35S9LrM0rwhpjyTJDkqSkOqPbbeWZMQykmUFbQEpMYiEAPIEdZqR3j0j3M/yZVeTemK3BNbLZeVZ+6qM0H1/DNjyyxHC8PWZj++vMBG0WH3me8NQahD69ULI/0mQbCTMNH08L7OgQxoeEa+tkesj+Gze4/qcH3Ls9YhxlLLebzM50mJ9b4Nyly3Tm5/OX+T7VgBtjGEdDXr3+Tbz5WRI/JGkqrC8Ybg3RuyNOLS7w0OwCK90HuLrr89adAx46/QSzgSEyW8T9I7J+QmZT+oO7nDq1zN00oifbDNQIzzPoLOLNN6+gkLSkjy+qjCg/qNYDp0l1pmwhyLO9iCJ7js2Bs6uSC9MkwG1UBptXk6auP6YCCkagtcUajVR52kOBwGqDTo3zACrdIoqvFverA9YKHL9Tj5XuDcX+QlmrQZTPXbpBOU26rTR2pStMdcGaS0WlYRRCoKREyBw4uYDFad9gBwJyIO0yntRJjwPm2uaFkHCWiUJR5jZ7ASAFqgiUdy4PeUB5EQtR+EV7RYXg/F55LIcUID2vcJfIqu+4tnEkxWnbybMe5Z4pZurck+OmzMJUaozzYlvCipr3V+1eLoLd9XFJQipyWu9nKLIfeVUb6qJSr/TyQmbaaJwJxHkdQEFwPZW7FXkeQRiydv4sGDjcHdKbXaQ3t5DXXdC5JjnRucsomYE0w295CF+ijxLMjUMmfR9LQJD02RrcwC6usPiLn0auzmB9STxOOd7qc2fzJboiZPW5TyNnZ/FDj1AKDiea7E5KKC0Na1DjXVpC01hbJkrGbH3ni7z++V32DjS+DFif6dGcXUarJi++dgs8H2SKtRmh75GoLK+BIEUJ+k8a3Oq+7O/kg17vv7IXSkJhq2rhYtrdqIRptXnkrq9UFaPj+tcPA8JmgNfwaMwGbO0P6C2sYnsD9HHE8F4f441ZXZzj+eUH6AQP8OXbI+7upFxYvMS5pRYTvcHh9i6T/QGtWUOrrdhrGLJMYscRvtQEPowGR9y9fZNAefRUk72tbQyWsNnAWkMcxcVcqtVoKOKWBALtsoiV1oSq3bTOgbgjo+DGdU0hQj6262uamzuly1XRWa4Cch5nYMr1rRjSlHTM1sm4a/eCrlmbu+6XY98R+bd199vkPUUOSqPJidr2P4jau/vybkk+qZIsYWP7mC988QrHUcpHPv0ET3VaaCwmThFSkhlDlsbM+ID00EZgdUqWDkgmfdJEkugIM7vE2f/4eeTZORIL2SBhMhxx95Uvsnr5EssPPY7yQ2xiEMMM43nMhoLxmRDDafQgQ4wnEH0B07+OaKTceeWA/a0+41SThCGLyz2eeuGjZO0u2xuvoc1F5pbOFNk53mPT/M+UfO4f9w/4l//6v2Pt8YeZP3+Ob+69wu1bN4iuHSCagpm1Hj/62EV63ce5rRfZ6h9zpi/48OV1EAG+WOHi4nn63UO27t6h/8qYF97/SbyGZu/2FlE8wmuBHmQcDw4ZJhNC1UAIWYcjP5CSZlnusuEsBNZppMjTcRRSDzSt+xU4UiGLtJ5O62htThhyEEcO7JTE6BycGlNsXuX9KiDiOqPMolRo8MuKzVOdVjMZ1DbvEgxJl06wVrituIjTspafCodypkGOLbLuKOUyglUBtliRX6OoB+CeTxdgzT2WcI9XtFd91yuPO0tD0bDVeS4uwdUeKFKeyuKzglCYwl/ZmAyH9cp+c5pRY3Ly4NpJyrIt8ntUvuOmOD/nHdMEQamatcmW5eNAutyCogSaOagx+ThTVeC1A0QVGaxohEtlqq0pO1wU7V4S2Vq1eCFyopbHhFQZijzfR0iFNgabZfTCgM985lMcTBq8eSXm6Rce49GPPlbUDjCYLCPNIhKb0lCSQCkyF9VrM6waYgNNYiyJjbFLy5z7zz+MXeyQZoZknNLf22H3zW9x6uFHWHvieTACG2uU0Yi2x1xD0l/z+MX/6Jf5x7/wER5diGHyOgzH+EHEja9uMx4lTJCoBrSXWqw9/BCjsMU/WAn4N7/zJSZxSppqjgdjRDFXjEsRKypyVcURuYbNwaOug9UaaXZRM/U5VM4FMX2sjKkpRtDU92qKBGPzf1Yb0jRh9UyXJz90lsizPPrEB7mV3KV/e4vooE+jGzC31uNHHjmDEZd5edLhje/coXk44qOffAxooDhFS0tanuBwO2ZrI0GjmV1vEN0c4YUKv2nRo4jjyTGjNGbjzl2sFczOzTEe+ug0I40TPM9DZ7oYe8Xsc4HJZrr2gGtTtwYaW485qAiEa2pZZBB0NSXyGKaq4reUplzTSn4lQCiJNMWxmrXNWcbcGuKkxMxFpTpbvkfeDyeTE7yTfD+hhvtyX/5KRACHyYhGtwXKsnt0xLV7Bzx+eiFXHMURQdjAw8MiiDJFGApUbNGjIVE6ZKASjOqg0w6r/8FZvIs9xlECNiIaD7j12h1mLl1m8cJFskQwTiKEzfASw95Wm7Cr6IQQdDRybhWx8Bls8hCTm/+EP/zfJ9zeihmoOVbXF3nu8jrzD72fYRywdziiKY44euU2s3NnePi5H363m/PfWeJ4ws7BFjuTPVZm1zm0Q/bu3ibqH6BaEpsYHlptcqrzBL6cx9+LuBj4rH76aeY7LRCQIJnxF1hqL+OvQnemw5Wb30T4HjO9DlmaEUUxE2EYTYZsHt/k3Nx5jPFQyjkW/WCKMSC9POBTFbErOo4whrIYlNs4c22azUGpqBVCcji82LBUkePPGJNnOLIWo3OgWcvdB5Bn1KhdM/9ZEA0HfutFs2r7XO62M+2q4kCQ20TrByrtXU3zWRTY+l420MoNIP+jnq5fliTEcZTi/k4he8I65QhL+cMyFQCZ941FkINzjUQ4vxFbuCggpoBMeQ9Rd4mS0/cVVQrYk32R39PgXB4cMFKlZaIC8XmfVV7RtvaudSkruVoHWPOThFI4bWeVStcrtd/GFNp7UYGfnFAUrhnGUHVFZYXISZKeAlSieDirDWmS8okf+2H+n9/8AkdRn1u7h9zdG3BxaZZMW5LRmFa7TXY8Is4sIpQ02gKRWZKjQ0bZkFgotG2gGk1Wf/Yiar3NoD/Cb1r2N7c52D6md+lRVh68QDLQRFITmBQ9kEQbIWFb0fbhl//Ff0Wr66HkiGz4NYbX/hVf+N92uXkvYSsKefzyCgtrpxh7C7x665gDucujZ5v85Gfex+/+4cu89K1rRVVk5x+fW8C1qcC862z3q6m7/FQDoRwbEorYoiKNb9HXpiyFXidyVdB9mmmUElXGMJuXkqzGo8D3JcvLHZZO97DtkDOPniFuwNEb19F2jPChgeSR5R5husb23pjf+60XyYZj1s+uoX2Jkg0yrelvxGQDTeAJgo6P9RRmIugseKBg0hCkI814MmB7cJvnn3yUixcvcPvGDeLxiDSOMYX1SRXWJxMnedB0zW1ICIkxuja2K0VEPabDkQAnltwdudQ71Nrc9ZdzHyqtmdWsmZpMpVKkmD9Ta1XJB8XUvbTOa/h8rxbx9yQ5uG8puC/vlriNbYhiG8GhTUiVJmp2UAIyMlTokxlLmubmR0GMlD0wB2izzd3JMVEqubDQIbgsERfaJEajPUP/aMi4H7G0vsbcuRUQKTtHKQ0l6LR9GnMtwjlFoASf/ZXbPPfxeRbXGgjVJIravPjLd9jozzLTW2ZlZYXOqdNE7VPc3opIsgnD0TZLcx4NEaBUI190lNMxvvclyzKu33qNf/sH/yedBY/1sw9yI93g4MY2/bt9ZKBoiZAzwRrWO8dekjGJhrQ1tFQnDyq0Ak+EfOCZ93Pp7EXu3bvNG9df5fbeNbKxYO5UQDNtEJgJKkgRAbx27WVOPbXIwEDLb9LwA+Rf82Jn3018TyKkKt3rSl/kIpNJrpWtgAKQm87rPstUSnxBAciwIPJCYaZuHXYAs/i/ntM+P15tfsJVYj2RFcRdwFLXkjkteQUUnW+v81XPP69bF6r7VCdQbrjvKFPfrwVoUysS5oCUszA4olJobuufy8LloJ58o/6OFLuosyoAACAASURBVJpfWaA7ByYqwFw9knObqmcwKtvSMlUcrGxD6wopVW3j/LDfRmhqtSOqjwVlhe2axpoi05NUqnzukjSV7VdVNDbG5BlkpDc9rmpkxuYPl1uDpCxrP7iXd8/v4miEVHkBNFGl69TWYtozPPGZz/D6G79K7EvSsIkSlhSN1wgYjCP64wRfGBphXrTRTHbR7PDazhFLcpG1sx2CNR9xoUWSZlgPNu8dYbTH0rkzzJyZx9qUzcOUbkPS7AU02j5toRDW8Bv/y1v8xM+dQ/kBCMHuhuSP//Vtbu/A7MwyS5fO0FheZtJaIM6ajO0+Mw2FEgFSNAiDBs1GiLaGLIpzkFtkIHK+6c6iUBL5og+clt+1cx2sCiGLar6i0oQX47du1ZuyiolCkXDC7a70ry/IQbvb4NT6LKcvztJb7XBm/WEOG2MGbxyS6AQhFL6SzGQtgvYTHMSKuRAeeeASUmt+6Zf+FYPBgK29ba5fv0a76zG/2KC3GCKbAeOhprnqMRmb3OzlCyZmxDdef4nTzy3wkR/6KPHvjsmyBLAcpClRFJdAoGyjqWFaLAg2H+uyILVam6mq2+4968tUOfdxBMLiggZc0Lhb34qZVFvDanNNutTaeRYlqymPu0fMp54s+8BVkS/XwT9H3pPk4L7cl78qmZoiNabe1xmHKI6ylMPRhL3jIQbNyBhCqcgSQ5LkC4TXEgiRktoRbx3CbtamOa8QD3rIRZC9PNBpdzhiEqU0goDecgehFNvHKV4jpBkoAl8hDHhNy5e+ssn6WUGrI4uE8YdE0et89YpmvZOhTi/RXDmDv7BKLLrs392lsdCj2+oxOtpHNptI5eWLjFK1t33vUgRrLaPxgKPBPlYlPPL4JbzAZ+fqbQY7xySjlCbQC33a3QuE3hzJOGKxN8OM1yAMm3naxQKlzHR6NPyQaDJmZ3uPhtcmw9BSMwxtgq8kjabCoukPt0izIb5qMD0qSlXzX3FrvHti6zuaqysApRk8B34C4UzsWEoMUAPceRCozLVV1gXiOv9aU1oSqhsXgF5S+upCRTpyTXUF8u0UQiwvMfWzZChTf76DOrv2fSGK+5vi4pVvxNu14M4C4a7rftZdC2pAvbzJic9sca9p94vKpau8pqB0+xE4kJyDFVMUMsuvU97+Hd+1erz8hesB1u7a1bnVu0A9HWpVt6EiOU77WWlPS1uCyF19pBBl3QFtqoEjCwuRA2X1zhRCuERxbwOyFooQBVseM7WXFELieV4eYxAESERRtLLIVhSGHGcZanEOG3ocTSYcDEdoO8PYGkIpmYwjdCYIQ4UKLFKmxGLE63uScTgHK23EBQ+5JBEdibaae6M+WWqZaTfoLrSwMl/vw06TVijxhEQJQaRT/vTlHR55PCRoqFxLr7c4PLrBt65qVpQgnuvQO3MW2V1hPILB0Yig1UJlY4YHMckwRlibp9quA3njCFeVLSonBmBdalPXfzjiZafml5C5e5qsu425XnMAtKT2FGMxB//WmXpqKmxVpP0VUrK02mPhdJelUz0Wzy/Tbna4eu11xocRBJZOoGjagMTOkcVNRvu77N6+TTieEE0ivvmtl9nd3eX4+Ig0jZmMG3hqhrAdEDQN0hMc7afgSUJfkIVgRMo42iNO+2gdk6YJWZZhAc/3EHFCmqV5henCJc3qrIw3KLMt2do8o3IRqsc+1cepa9/SLFhyjGLc2uqcym2pmqbOPUiVCQmqsV8nXfUMXuU9C5JXpk79HqwH98nBffmBFGstkdH4MjfFj7OUQZqSasPx3gG7AehQgR+QCkl/fExsNam1SCRZkpEkGuEZjJ9hRJN+EvPWlkR5Pp0VYN1gmgo8wU4/pR8ZwiCg3Q4RnYBxYoiMYj7wCEOJJwRJatg+ThkdHfPB51cIOx5CZESDbTZe/wZ3xy3WOx4LDzyCWltB+E3sIMWO+qiFNhIPqy2+F+KHTU7Qn/e8HPb3SHTM5UeeYe2BNbbjY7bf2GR8OEHHBulBu+HT7Z2jKZtIYZntdeiErRKMAOXiGAQBYdjAGkGvMYfX9HONZGbxJLSbAVYL+oNjxukAz2vT8BpgQ75bhpW/7jKtVaq2txy4VccqslAq0Up3GZh2gakrlVFVvYS6q0+JIxzodNrdKfBf0zif0GSf1Ja786cyi7jP62/oNPcnDtQxvvPTdoCnrjEtH/ttLVYnKdXF6nED5fmi2OSpa1ir583PqY/t+sNRuM+Y0u8f984n7oVzTyieaeq5RdmBZXuZWv9U72nLm9atG67+RI5jinaXonzB8nfB9PcKsOU0m47cKCUwwl2xYjsCCgsSuMQljqAomQdei1qBCOUpOr0eH/7Ex7ny+hXiOGbxzBmaM7MkmWEwGnHnqA8zPrTaTIymHw2IjCbSGolHFidkxpIpi/EsGQ0GScIbGx4Ly02aFyScAdOUWA+2+gmDyDLXbtCcCTGhR5xYYqvoNTzCAKQVDMYZm0cRk/6AFz60igokkNDfeouNa1fZnLRY7cKRF9LrLWJTQTwYoJIxQbdHMhAobYiTLAenQhTZdVz/Gax12YZsmYEHa6bGphCUloWyT8putlOfnczGU0qBVK11rm2yNk9c3IkL5s+H9tLaDK2ZEOF5tBod0mzI5qt3SMYZvpH4QFc16XTPc7hzyM6NG2zeusPm9dtMooid3R2ODo9I4ji3cvYnjHpNepFBTjSioRgPNWFHEHoCFViE0IzHIwbRIULlQdWZznIXvmK+WGMxooorMkZibVaO2Rp1Ltcp10bTiglw8TpFU+efOKVCyX/fvk/XrXH1ddK5dNpa1qN6H1RWzzp5cYv0d+m7d5D75OC+fJ/IScDyDmdMaTTE9ISrbYTWWjLgUCc0bYAnYDuecGMwYBxpvv4nX2fpgQc4e9qn15uhvRIjgpR+lpsOU+mhs4RET9B+RmgNSi5xazvhcD/iwvyEpXMK1TMYr01kJW8djln2OyzOeDQ7kgE+SSaYn/WRqcYkmjRQHGWCb1wd8Hee76K6AdZGoCMO723w8ovXoblIvLLA+efez1GWcry3j0iGLPYUmU44PNrn7HKD+aUlmt35XJP+fSTjaIAfBjx56WPIpuGNuy9yfOuIZJiCtnieZLbVZblzCt9aOu0uoRfm1VBr5MCJlJJeb5bHLj/Bnc3rLCwv8satK0RxhBKSmU4Lk8LuzoCDcR8h2zS8Nk2/VWg8f/DIgZPSBF6COUlpIhBOEykqcGFtDci5zDhFHIBz1ym03bKIXZCFBtPdqwSNdcWZIwDu3EoXXSrgak9NyVIAF03plH3lRe3J34stvLYZ14uE5Qig8AUW0yApP+wy6bhncFDoncVxhdJSUQP+7netdfkM7lEdeYBpX3HnAoK1TAfl5nEQ1XpYtJ7IswY5VxxT3htcsTNrKQpWVX3n2sb1r6CKK3FpIJ0lwrWAq+1QAR1KMuAChd0YKntQCJTy8rU6qyXNL9rXxVcIqUpXFyHACwK01lXmIiHo9no8/tRT/Nf/7T/hf/yf/il7e7t86Md/jFMPXGJn75gv/Mmf8vKNXR44bVGzs4iOJJUp/UwTRTFeI2A0GjAUMRZFV/UQ1ufGVkz/MOHRRyJm1xSqC0aFTIzkjf0xF1tzLM2DDRUj45Fpyfych40zjLBkvs/d45TbmyN+5LkuohFg9RghR9z69nWufGWDLFzkaL6BmZ9jnCkGG3cJJ2MWe10Sm2E9ycJck+09SWIqq+nJ7FdTwbVl4a7p9c2IimxXY7vqc+fnXmrOi7ljMeUYKFXZtopPKccilIDWjeNGKyATguHYMDoyDINbHN3ooxODp8FT0As7nO6e59pbm1z5xjc5PDxgb3ef8XhMFMfEcYTRJicH1hBFCckkIWyB8kA1fKyx+MriBQIpDFtbR2wN9phdmqHdbeEHeYxBmqb5vCuqq1frW95W+fvU3KOcRt/W42Rq7e4+KLujRvBzVlGbZ7U1qpyP1ZfrJM25Rzoinq+R8m0rT0XkXIKAE/EJf4bcJwf35T0kb9/mnXyvEO3k4uYWMlH8dMRgU6dI6fF6ltLCIj2fhdk5TmnNFxfX+eof3KL36S5DaUjagpYfchhbruz3ed/KAqoRMop3ScYDzi8/zgTB731+i4vLm8w+8RTeyllMEjGxHntJg8WOYbHjIzzJIAMrBUHTx0pD0FAEyrDZT7m2N+b967eR88/AeBObbWFlRhwNGfpLnH96kQd+6Cd46+CA/W/8KaPjQ5qrKzx6+WluXrtGKCXDpMVcMEfQ7mKsQThNYF019B6VRy4+zVb/Dq9sfpnFlQbDGyP0OENqAxrmG10+8ez7WJs9x539m5yZvYDv+VNWg5MyPzfPxz7ycX7t325jhWV+YYGDaB/Z9Oh1O+zf3SedJBwNB6zPXKLpNf9qX/o9JhU4r4HPYuPLdB50KgUlEASncK6BZaoUk+4MUYBRIQSmyBxTeo8UQM6Y3Dfa6hqwmCIAOao2DoSXgMbdFYc+qzUAZz0QU5pQ99y1F6/evxBZAwfG5KBzSm9YaP9E6XaRj8Mym1LhNiPLe1f3tTb3GKyfU2VoygtWWVVlmIF6cboCaJWuH4JABSWAN+77tq6Rd2TkBOiQslgfC1BnTb2cQelG9E5ibe5yIoqsQyX/Es7HvwJS1TH3L3ePkCrXMLuCetZYkDavK1OCXFEEJOcxKVJ5eL6PNaALrW/enpKw2WIyGufFyTyfD7zwcf6bf/7PUMLyM//lP+I73/oGF8+e5fT8AqdmRnxrM+Zbn7vD9ctHjNuWua6PsZLtseHK/pAXznT5k1dfo7dseHz2QdrBEv0YfvvFezx1YYv2059BBU2yLGNsPA7SgNVuxsKsRyQNOhMgJUFTgTQETQ9fGb6zFRFNDnl2vY9aeAQ7vIfV9zCeZP/4mEPdpHfxIQ5PPcZHPjrH5u++iGyFRF6b24eW5iRmpiPYPvK5vjXgYDDCGIvne3jWFuk4wVpd9nvdEldPS1rGZrg568B/QbTr87s+BvNxBsYR6xq5dYoFN+CttVhtyZtDoJTgq194i/f96CUe+sAcS6uSb7x8AyYZShukEay02yyHHi99/it85FMf4p//91+nf3RMNImIk4Q01Y7yFGBc0D8a44WKxvwKYcND+xItLX4vQGqBHUtGwyG3tje4+pUb7GxvYXSe9jaK4hK4lwX9tEYXLnsCitoNEitESYilkrU5WgTBF9nCyhWysJa6mecse64GgpsYJ3cyWRScMAUJM9ZidN11sCIW5fpXEnaX4Szvi7qF48+T++Tgvvy1kVI3cnLg11wP+tZyR2sWpCTFsickgySlJwQzvqIvFT/70Yc5+8Lj/MubG1z79lt4sSZ98BK//kef42Mf+wj3pOLexphB0mR2eY4zhNwaR9y88QrPfvpTtNaaaHFMJOYZDQyDnZjlxZSs1UZLH6wlEHmu7QbQDC1bxxn9JOLMfMr68gXE5Com3cHKOe6+/DpvvnKFzvIZfuGFv4maNXzty9fwbcpcdxYSxetf/jJmdoXTZ1cwvuXexjXu3XqDbrPJ+z75t5jSpr6HRQjBSm+dxfYq42TMb7z+Jfo7I7KBphl4LM2u8cxzP43E5/zCQyip+PNeTEpJt9Pj4x/8FBvbd7ly9xU8G6Azy87eLn4HPCzZMCGUIYEKy+qrP4hiCs1ZudELB8gLDZUDmrXv2BN/QwWEHSc11oLWGJMDR12kLa2KL02TgSnDX3nNEwqEEzd1gMcdEzUgU2o6Tz5oTbNXZtI5+S712AhsGXhYBj9TD+IURTvlQcMlkaHYs2v3srbasIudPQe/nofUaQXUCnG1ExyJkEogkFPuXbZIs+nqFmidUT3BNBhUqiIY9RzopiBctvjckRtsjaioevCwq61Qs2yYnGTUyYUoCFAeV0LhPiTL9zdWlOlsBZCUBFTk9/PyexoEKB8/UJCkeAH4YYgX+Hh+k9F4gu8H/Nw//If81M//PIGUJNayI6D32NN4vmJfCpLZLr/wiYf5p1/6FdqXf47D3/8cY/8CbxyP2P3S5/jERz/CXenRuvAso45lvzlDz/i81T/iT7/5FT7zH/4Dgs6QxEhi2owGlv5exKllTdz0MUKirMETAun5hKQ0G4ZruylSjVhfCVidWYHxm1i9gxUrvPo7v8bdq1ucf+RJfvrDn2ZneJsvvfjbrLTaBN1FMmMZZWNG2mfGTBhkQ86tzfHgqWfYuLfN7/3xN4nTrMxWVc/cNDWnSoXZic9rlsApgiAoMiFVFdLdGCvnZ63v31FEpR2Po7yGxDc/e5W3vnGXubUZ5k/1GO5HZImh1Za8+eYu3/nWJqPJS/z6r/06o8GA8WhENIlIsyzPwuSCd4usVpNJxMGuRV5VzA1nOPP4Av2DFCw0W5KgqyCN2bh5k69/+ZsMDwYkk4QkSvA8hc7yDE9pmpbZ1UqrGLV0ynkDlBYEU1hVtSPspZKFYs5CfXFRUpIZXc5NQTVXbLGWCKpkADnBEFN4xs23ujWgshKdaHrhXKS+S9+ckPvk4L68R+QdrAbTK1bt2Enwn//QWhPFCdbmqfaiOGam1+WXfvVz7K6c4rGH1nhstUdbSvas5ZaxnBYw9gUaSygMjwjBtzH4DHn/2ixqaZ6NrV30ZIvZwy1eNQFPSMFWu82VN7ZofPsmK/9+j//rs3fZXf0hvNYFIKIfpxxGBmLF8oyl3e5hfB9fKjwLiRUE2QThC+4MJNf6KbOh5dElD5sO0Po6Ytxla/cOV+5tk/RafOrpy7z1tc/y2a++zOMLi7SXlzGdFBHeYWE1xDTu0Oo9yjBJ2LnxFtHhEetnHyRLU/wgLBeg96rkG1K+MSnpI1G88q1XOdg9xmaW9myDdtih2eyWjiUVcPqz30wpxfqZs8Rpwt/95N/ns3/yu7x593U6zS4qU3zy2b/Bk+efotvsVZvde7mx/hLFmgrQO1eV0hzuinYVGTZVTfvoAg2diRxsSTIorjCdJ7wiGWUazCmVGaUFw92jDvSrIN6atr+0MhT/a5tfpwA7gtyKWK4gdeIA5XNNBfdRAKZCi28yQ5l9qFJsk1tHqiJ6+fXIg7rdrZz7TO24Cxgt28Ja0jitgIExBQiTJ7S97j65NcPogqjUUphKpUBU2X9cHzrN/tv6vtY2trD+ULPMnDC1VFrod7C61MURB5fPXSlZFMTKg0CxucugkDnRSZMUozWhzAOJjaFMZWoRNPyQ9twinfYcw+ND0jRGeh7xOOKBD/wNHvjw+/l7zz/AE2dWaPo+W8ayYS0XJRz5INDMCIkv4HVf8Z/+F/8Zx81Z/o/fE5i4jzkYsXfrKlc+9sO8T8CN7gzXvvQy/YuzjJ86z7/54i7m0Z+kGa6RmT36kWIUgcwUK7OWdmuG1Fe0hMRaD20Mnh4jPMmNY8Fr/YSnlhSnuhqTHmKz6zDscefeVb5zcMSZxy+y2lnhld//Vb5+/R7PLa0gl0+jm3sI74jeYoYOPI73LBkKogOEkXhG0/RVTriNKVPh1pX5UJBC3F5aAf5ynp/4XYgiZfGJ+VI/11kA38kuV3LiYjkx2mBFEYrbd4HTEozHuJ+AFsim4HBvyJ1bB4RhgJAe0TAiSVMyo/M6FcYW1rwqDklYiMcJe5vHBO0G1762zcqFJZphEw9Ih5rheMzm1Zfp7x0wOJ7kxc60JkvzuAJbAHIhZNlWZSIFilgot44Jyorn9TYRgrygb4lPTGF1qYoFQlUgra71ryc6cAXVqqr1eUPW56QUslIy1Po5/z3/w2RV0crvRe6Tg/vyHpBaroMa0843QJ37NEqfKrBHnPg27I8m3NodsL+9zVzDY/3UEttHQ77x4ld49fYhH3z8Ehdnm3RFnqkiMpb5YoLNKcVQp4zSmMUgpCstkQiYCwWPPvsY3t1bXL97hf7+LT4e5Lc//M5XOfz2t2m2AzYmT/Djz61w49FVWksthjZklAwZ9IfITLC8vkgqoSkFymR55gcraQeKnUyxlxnOziuW/QTiY7LogMx22dgYsXV4j6Vz55hrewz2v06flFYIb9x7k3jrTYzK6LQNl87PshlZzGVJa+4cDz31flRqyaJxnrWobLX3MkVwqt2iQvJwzO7WPpNhhOf5PPXE+/nbf/NnyzgKUf78Hq4sBEEQcG79HMYY/tYnf5KNnfdxa+M6f/rqVxFS0G318JVfasvfq630ly1uY3JY0JRZe/JNq6z66UhAzYWvCsjLP5N5NaWCAFSfT6VAFAJcZtEpa4HABTi+TUqt/TQgtQUJcKlAKUz/ZUzACXxrcan9RUkg7PTOWloxyiK+9Z292Jin3Bhrr6FkbkkwRYpCp60Vrrhc6SJUPkKu9aewEhT3q8/aErwYpyEUZf9IKXNXj+JImb2nIAYWyuwmU89be+568COFlaKuBHXZkiifubrWlEuWFIULmijTWkop8X2F57l/Ej/Ia2n0Zlr0ei3SNGN355DJOEJ5AVbk1sHcTQOCVodnP/HDLJ95hP7WJjdef5lJEhPOr3JwlJGG8/z9F57m2VNzdAOfyFoSa5mzecOueB7bSUQENJTHjCdozi3TFh4//u/9GK/dvcrOnTdohXA+gBTDmy/+JltX32S+9STrT6/x4x9Y5eaTp6Hd5Diapz8ZEg0H+MJj6fQciRS0BFBYfzwhCD2PnUyxk2qeWlUsexNsdIxOjsl0l9t3+tzYusITz32Etj1guHMVM5PQDgWv3rvKaOcqQoxZnLXML3jsJZK5+Q79geLmjXssNAImk5hxFKGKsaCsoWYQQpo6+asN4xo5dv7zbpiXn1FYBhzwJQ88LgutUTsfW7jDlNOoHLtu7XApi3VmSWNNPMoYHUxII43nKe7dPaR/OGIyjkkTnVuVMk2mdU4unItUoSgox62x6AySKGbrxg5hq0E0Slg8NcPsUpd2p0Wz4bF3fZ9xf4xOs4IcVHUbXF0DJ7lVwrksk7+3dXE3Rda1us7STUnyGKX62nbS+imFLIunGWPzQPypNZViHTQYM60cOFn0UBTP6jqvjDmoKU++V83XfXJwX95lqcCE02LkLgwZWk/I9BhjDI1gjixLQUqUCsvN1lcBqdHsRzF72hApj3Q45PitQ0bG8uWvfY1B5jHX+CCzDR8pBJG1KAGezeMPEpGz+UAKjmzMslJEdkRDNDmzvEAqjtnYPeT21j3WRMamzjjYuMr48AYzs+c40/A4Nddgznq0hWI0gUkWILKI7oxCNyTKgNCW1EqMELSEYc/4HCeW+VCzooY0kz5RNMBkMVsHGcNxn9mFebqhRaWb9NN7rJzt0O41OD5KGfSHTKIMHQsONyeMdJPb1++wejbk9KlLLC2uMxkcVcWY3uNSXzSjKOILX/w8o/6ENM7w2wGrS6d58OIjUwDke8kmVPo8C0Gn3SFNU86dPsfC7CJLs8t0Wz3OnjpLM2yhpKq5E30/tNpfvNTrF1RAP9/tcpBdgNWi+mYuRYYSivNFtWnlGrRKBeCuO6XBhxzs1lScU1uou14BSh0QmOr+ktBNb751t4dSM1f72yKm8H71QCc15W8H1VMUsnjHk5YnIahSs1r3rapK7UlQXb6LcPeriIi7qHMvKvtHON/lWhB0AcTeWZdbHD7hYeCOV1ShitUQ5fvlZ1Y57KsMLyfduMrYA5GTec9ThI2ARiMgDH3C0MP3Fb1eg7Nn55mZaTAaRXRbgjiN8Bsz7O6PmZ2bIUk0UWSYWz7F8x97gcbyeQZ3bpHpEf1RH687xzjeIx5tcXGhRTfwQIAmdxv0ydd7C4RKgc2Y2IRlzyO2Q9qyy1OXzhNxm6PtPtF4xJrIuJMp9q5/gyge0lAPsxYKVheaLFofT0gObIM4jfBESnvGIws9fGOR2hAh8QpwuK8Vx4lltaVZFcfISZ84GZEkCbtHGcPJMadOn2HGH5AMboO/xbmHZ5lfanF8vMPx8YhkkmEiw3DPMkwkOo3Ba7G1s88+uUY+zTKEFHieBBTCFkHpFqw06AI0GjePTsyX2gDCKeko5oicGqc11iHc6VVSgpx4V+mKnauS82pxmZNyS6LA9zyiUYpJDbIpOdwbMupP0KlBZxX4fTuBnya0tiAfRlsmgwipPAb7Q9CWZJTSmU0Ig4DBwZDJJMZVLjTO0mJtEdSuSwXUVGC1mF53HOHOfy/cLh1xngLi9fXPlgSgXNuMBcyUMsS9lqh9z5GFfNK9/dp1HjDdSG5JO2Gh/S5ynxzcl3dV3CZkrUHbFGxu+kqzI+JkkzQ9yvc+u8xkEoEXolSH1FiMFYTBDKkWHMUpfiug21qmv5Ny89ZNJipma/smiTZM0jEZEAN9IBR5doYYS2ShIRUdaTnSQ2ZVG2n7KBHQlB6r3SZn1xc46IQw3OLeRHM0vEfYE5w9v8CFYMS1uzcYxU0G4TI0mijl0Wo2WVgK0AIk+WKQWIFB0hSC/dTQsDFnghQVDZj0DxkPJxgpOdjeYXYxZnlhjqR/ldHoOq25kIUFTaNpEapF1G8yHMD+nubNb6d01DwHowyRGjyh6PTm6MzMlwv39xPUHY9H/NZv/ybxJMVow1xvjpneLJ73F7NkCSHptjt0zj/EA+ceLCwLISerx/4gShW46z7J/WUdDi2cZGoQl+r8EvxSAkaqy9Q2uXyjOnlcyvwzY+ubnYP8VaYV7HQufig2aFEBGTfoy8Jk76Dtr1s7pq4mxPTDFtp7Jaug6RJ4n9AIuoDfKWXdSfclpr9D/W/3fVVP9ToNGEpVfgG4HNEypqqoXBGgaTAjSjWmqAG6acuE+yN3C3NtaWtgpPY85UNRaJ1l1S61eyulCAKfZjNkbr7H/HyXZsvHZDEPP7LCQ5dmabUVo0HM+ukGaRah2stcv3nMqbU14lgwHFnml85w5vwFsrDFQuMCWh+xtX+Xo3Ef89oeabyXF50UEAvBBEsoBdpaRkajhWLW8zFGE5mErmqQ6D6e7DArJetLPTaWO9y+o1HZigAAIABJREFUvYvu3+XO2BKnu3RX5zmzHLBg9rlz+yZR0uGocQrb8PGQtJsN5uabGGGRGLSxxFYWJBqOUktoI84FKdngmOHxMUmSEmeGw50dZhcjTq8uc3D7c2h9QG+xycKCJmxKpOoy3O8xGBru3U65/VZCI4Y7m338hmUymrA1iMhs4fMuiorZxiBMqcjO+zbLrQm26K9a2oHaQBRTLmyun0uOW052N8eKNaMYJi6epj6u6yS47qpkCqWA5/uMRikYg+9rolFCPEnz8VNLz+oIc2UoOKG1r82T0m9fW0bHE+JxwtHukEYYMjgckiZZvj2KvD6EqWW6yi2O7/z8+RojKUKxp5Qa7niVUKFSSNSXlLpF060lOenXU6QaqoQKrt3zLnbk35FwtwgLShLj+qrePlOE5bvLfXJwX95FKakB2mYkaR9IUNJjEr3GZPwq1h4R+A3GI8F4IjH+DFEWkuoGiB7KX0GpWfqRZbHVwQ9C2mdWCGcivnT9Dxn7EYODATuTIROdIkTAAXBKCAIlOdYpbQQtIfAELFvFK9mIB6SHD0QYRHORxx/8IR746WVevf6HvHHzDlm6zZNPX+JjH15h6+gP+Z//798i2lokXP1RPvGJJ3n28gK9mRYCS09KxpkmkxmkGp0KDpTPKTthqTkg7hsSJMeRZXd/D+l5XOjeo73e4+D6r9GaGbP+yALIOZSNUH4f2WrTmFtjRnQ5bT0e+2iL4X7AG6/uc+7yp5ldOgdSlgFj32/sIEkTrr55lTTWSCl45unneejBy/+fr1fPYOV53hSoq4JQv7/a6C9Lyk3L7S5GlgCg3GxK1OcArJ0CA+UeaqmqquZHyuNC5Hnsqy8VXzlxHQds3LXqaQXrQX8uILB61gq41IF7VcRruojYyc6v7pu/n1CyuIco0rO+w8ZbtF8eQyCnruXSe1K0oS18ieuVZWvNkB+rWw5qUvkf11Ih1tsNqu8VZMjd14nT9JcYpvy/slrUwREn+tAdFLXfS2IgqNyRCuuRH3h4vsQPfM6cXeHxxy/QaSs2N27xyU+us7yoaYQeSs5g9ApHx2NMuMSH0hbIHkItYOwM48hnLKCXTJhdnmN14Xlu7rd56cpLmI4m3h2ylY5YNx3GUtBHsCAkgRJsThJW/ICGFSgp8JBc0xEXhY/CMsQyN/sQj19O8M2Qr776m7x+bw+/PeGZZxY4e27Am/d+h3/xK3+A2T1DcObv8nd+4mHWZz38QCFRtJRkkmmklyLHhrFRKCk5RcxSc8joSIMI2RtMGAyPCZThQm+T9tke26/+ryye9wi7pxDM4ok4X+/bPRpzF5kXPmefCnhfFHKwmfBHv/9H/P6XrpNmmlQb4tSQZbkG3GXMmXb3y3vsz0xnKShV4SezwNXngy0ArQuIFeWyUPjUF8G8bvyUbjAlkdSly5POLFGkyRKNkjAZp2SJLrPyCCmK+JvaJLH1h6o9Zm0qCwHJJEV6EhuATg3RMGYkJ9hM5/FANeuJUiqvdCwEysuLiObxBbYA784KUsyNovZLGcRtqvZya175SZlW3Fak3E5nE8pdlCxC2KIAW+6WaC1lAgeo7lf9y3+p1qPienWL5b/j3nafHNyXd1nykWtMTKoPsHaPLL3HOL5BGm0h6SPRhIFkpjuD7w8xLDIeDhhO+gwjuHr3GvMzqwyzRcL5ecJmi+XmI/ztpbPsy1/h8//DZ/mDK59ndink42uP8TiC17F0gHkpGVjDHoaWhVOyAdk2PbnItWyHUDbwZIdIzbMvL7H7yhvIMxtc/KEGlxdus6hucisyiPEY077L4OV/xiuzP46d+2EevXieUwh2kpSuhX6S4IuYwIdUN2hwQJxo+toy2n2TOLqB3z2m53fpru0zvPc1Fs8YgrCJJEAjyaIEu2cJ1j8MzVWE7AAdpJqhszrh6cUtgnANKTsg5NsW9+8HsdaSpRmjwQijDZ70+MQLn+SZp5/5/3XdKXekdyACP+gWAyfWGISSNUtALlPaeKfJcr7sJVeotOZGVxq9SqFWS6Uo8kw1zrXmJMGQThsmqvgGKWUVqFyo72392eo3dM9SXbB8P12zWFT97jR8Ne1gHUaVz1fttFNuRjWwXD9PiOmKve7KJVgotbjV85REwpk07Mn3qzBAqcA9AZKcFWzKragAEK5SqjRTXykuXbgn/b/svXmQJcl93/fJrKp3v9fd7/Xd03Pu7O7M7Ox9EYuDAEECAmmApgzZPGQyaJMWKZGyTAcVokXafzBsMcJUSBFimCFLPkBdgCFQJEGQIEEQxwJYALP3zuzs7tzTPX2f764j039UZVXWmwGBPwRgF+qMmJ7uevWyMrPyl/n9/q7UWbpE825tt5KUdCVAJqXYgjjoOAE3Zg2KogjXLTE+UefkySM89faHWVwYYzi4ghIraH8bpQI8D0pFh3q1huv1iHSNna119gZ9Njq73FjtMzd5BNE8TOBoiqUJ7q19H5PTJ2hX/oDP/++f4Q9f+CRzj3+QuxszjAPX0VSFYM512BeaHjCBQ0W4CL3DmDvDK/4SU14T7ZYoN++jOePyid/9dU5/uMVDP1rjB+evMl69xstLPnLQYVi7Su/p/5kX7v4l5JNPUh6fJkKwMfAZA7Z9n5o7xFEeMhIU2aU/iNgLoXvreXyxRKkeMlYqUJ/aoH3rKyzcU8BzKmiKKC0I+gG6B4Vj70E7LYSoIZw6XrVE61iX9/3EHP/uz36Tne6QgR8RRpogCBOCoBLNekYKTVC7k4DQ3JxMLXT2ZZ3NLYucZ9r7RP50PMeN4kAqMTKnYwuKIRQAURRPPMeJT8UOByE6iufe1uoOQRCkxMBMeONSIxJ5yFknsiNY4hS3RImGfoh0BMHQj+ek4+A4iigIMS5ThmzHKXET2ZASLR0ECkU8nobkAyYlATKJq4nJs+X6SCLnhnZr+7yO/MIqEKmsGOV/OrbSkC0ddyxZ8AzwT62NaX12/ZnyxP74TgqH0XJADg7Kd73EguHiOlUUAzx3Ac/rMij26Q977PV30HttilyhIaBYb1L3JqiNTaDEOvP1KbYCzblrmtXLO3jj4xw/MctTzSb/7ff9NC+eepUbn3uOa+NHODV3jJosUETGeYMJkWiKQAlBB8HDhTleWv1nzNXmmSg/jCtb6MEu//KT/4b1F77Ez/3aaeYmAq5e2eT/+lqPmpriJ//2O6mWbvJ7v3OV6enLHG4cp+neRTdUDNUe47JM3VFEGoTu0wrWCeUMu3s3UDt/QdFdoTFRoFSYpVqqI8J1Jo8+inSqIJpoJZH+OnL8SZha5Lk//y30xir15gwTdy1Sne5TbL4DiQNYi9BbsERRRL8/IPTj3NNTrWmq1SqO43y3m/afRFEJoogTDWXgPQuANT/jzTL19FHELhRJXv2cxj7JcpQG/QmB1kazT0Im4pqz9ATaCnrO2mfnvk+v6exQp0zLrVPX3DSIF9J0i39VMaQkBz6sdth8wjQlpRS2PxE2UbBB2gg51UbTLrL9PJfiNNHAk4GyJBoxtZJonaUFzWuKRwCEdT3O2W43JLGKGFKStlukQM3GNznLQtr3rD3xPTFJcF03Jh1KMxwEDAeKcmWS8bEx/MBhEGr6gxX63R2E36NIRF1CaXySyXqT1tgEh6fHOb04wZa/xTNXKqy9vkXz8CxnDrU4NX6Y/+ap/5rnPnmeN/6/v2Tp8KM06w0kHgUgQlP1JD2tKWEC1j3OuhM8v/JPOTpxNxPiHUSywOrqZT79mT+gPfR58lSVmZLmmXPL3Lo2pFys8Z/9zFGOzzr81j88z5HpF1isnqTmLtALA3z2cWWFhoxQQlNS25R0hC/G2G4vweYfUa1u0yw0KRemKBVLyGiH6RNPgqyBmEYFe0gVICsn0FPzfOUPfpXiXp/ybJOxI+OML0xTaDwMukMQBLE8Je/TBLdqex4kMqx0mJDmdLJaZDibAwleT7lpinHtczZU3rVP2D8SBUJeeDOQn056BI50cKWDCnR60GCcRjR5RyYrGcTQW+em8J1L0o5MDgRRFAN8GSlcV4HKZFOpMGdhMSdNZ3EBRslmWwOy+7XJ/CVA6IwgYMK38sKYa6rh/Tr3WWZlVGnGKZFm84rvMGuUtdDYDGFUuwO3vem/qhyQg4PyXS3Ga1kKD8+tE0R9HDmGlDVcd4JSoYRfGLDj9Ol2+nRvDZA7HURxDadVozw5wfhEi7n6ad556jA3+hUu7+zz6qUVNqdmeHxxjl/7xV/mox/7GLc613l1/RxPTj9MTcQntO7rgLKIXYggIEDgaode8UG6ag1XDZAoOl5A8ch5/K/usrvr06z7FPCZ0IoxAVvBkFPNM5x0tzk13uDEeJWBEKyieNBVrERDpNJU0ZSER1gcZzhYpSrOUz70AF7xYVw5wFF9BB4iXCDqTbOvu3T3lvE7HbTS9DZeQXl9jj28QLH4ANIZ4rjrSOkj/FfQnEAU7Y36rVFsd4fLly/xr/71R2L3FuDnf/5vceLEXf/R+vNWGpfvRhHpnpIdZBZFKdJLNFixRitNI5Ck2zQHX0H2TlNQm2r+iMG70pYLk9FY32HjtMBA+rkwW7VNEDKtptnoI2O2N+A1vjHrq+0aQx4oZY8S+Q0+0RIanyezB9suQDlMkXZE5OaeHT5tW2WyCjJilAZhSge7xSlgyaWZTAC+GS8T6G3GJX1MnmSJ5LtmDJUVrWyqjqIIpERFyiILWZ/s58apHmXS7xg8uY7DoB+wurLNraVtHn6wgetWcdwaRXWRqufQ8wLavSHtrk/nZh/nhQ56Yg2v1aA6MU6t3qRSOUXt7Cne6EleX1vi3JVbLE9Ncd9Mi9/8lV/ld/6P3+X8+jlaUw7Hx45TJQ5+3dE+Y6KIJESjCJF4QtAtPkLXX8UpBERC41f3KS++hvNSn60dn8k5RVVAS/s4UZeuKHK0fB/HBs/wyGSNyWqRNpoOilOOYjnq42nNuADPrRCIgGB4i7q4QPXYO3GL4Oo2jo5AC4g0QWeatt6jvXERv7tPOOgS9b+OKgy5790P4ogZhLOKdHZxnH308BVENEUU6Wy8oyhRLif0Xak0AJhExlAapMR1ZZpxJ70sksDckfmUzux0/lhnXCQyZrIWpbIkjFUvP9ty3EBrypUi1VqFMIiVQcNBgLGI3dH9SVga85Hr6UxMlANogUZmIq9ji2aoFVpllsXYtTRTLETp6cimOp21PYk5Mu48dixCrk3WNiOMzFjtFEk8j9ak5xogYmImhCQIo7TO1I0pWWdG0xBrcx6IsTCQtS0XF2We/S3QhANycFC+iyWd7UgcXFkGMUmkfaQs4cgSrjOJ68yi5WfQZYEuF4h2A8JuQGd3h9euttlni0fuC6gvCI43zjJemuBG2eP87gZfXvY4MVXn7IP3cGt7hauvLbPQvIemU6Ud7VJzCghKBEg08UmhbYYcLx/ja+dvsjA7ZHI+ZHXYobu+T3nBZX7MZfVKyPotl2Ix4uRiiF/qw/A4u92nWd+8xeHdNSYqsK1Crmx0mWg2iWRAEAb0dARS4UUd6hN3I3SEDLeIwg2Gww7BboVSS3P1xnWGqyuUGhWK43VQPjMnj4PYpVb1casa4TRiwVdbqKBPFPVwteatkZ/oDgs8sLm5yblzX4/TuknJ8eMnqFVrI9rJg/LtKq7npCZxG2ikqkSSU5JlltYv809PNGlpVsBkU1UW8E//y3ZsbZOHhEBobbRl8XNjZbmdT11b6DvTAo6WXCYTYbR+wB1lxIAqM9fi+wwfMPXZsQ4iuzFV3uXAlL25J/fYrTSgwNxrarXdtuL7ZNpCYyUx4526C6n4tGJMHI0wmaUsgnGHPoskr6QdeGkUN1nbM1CWEiEL6Ykk+0zuPeg42YQgBkfDwRAELC+tce7ceQqFKj/8Ix/EkXPxei+nke7LuIWvoSv76JJLNB4SdIdsLW1w+eIuvrvOg6d9xhZLnGo+wERhgiu7fW7ubNCNJCdnxnjiybNsLe1xdXydWnWOmiywH+0z5hSJcAh0ookWiqEOOVE+xp9//QJveyhA14asd9v09zpUFz1OTIzz9Wcu0dkeMNfyWJyr0S8JPvm5Z1nvwtradaYW9mk0NL0w4Opmj4lWi0D0GIQBARqhfTztU2/ejYwi5GCFINqk1w2IegUK45or168wXLpG/dAswq3gVYpMLZTRzj6Vch+n4oCYAVVER/uEQR8V9fCHPkEQEoSxO1E8ZYQ1d5M9NueGkk1Sbb1Dk+0qdWkx89xKx5kS/NhslYJNaWux00lLKmZpCl1DJIQVWGvmmhT4/dCySok8SZASKwz4NnG3rVmJ0CQEVqbnEggRu7yZ2HoTUyDQKfAOkxPcU2IdmwQy4J1mBTPKAKN8sAi+GUelSc9FERZZGlkIDDEJtQn81ok11lpbbKsPI98lU7baCpDcb4mS4k6rwGg5IAcH5btcEr9eIZB4eKIBqg9ECFlG0kLKKaQcIrkJjStEk13C3T7O6oCtrk9/o8fXn79Medln7rigOXM/J6en2YtCboV9Lm8tE3o+tWId/AJX15cpTs0TBVvoQosdKXFFgRouA60IdciEW6THNG1VQXd3eG35PJ3ViDPfN8fCeJErr/TZ6XnMLXi4UyXGStO8emOV1X6fKV1lQBGtAqqRz2YwYDaKCDVoJKEKCYdDakDY82lvXiforxEE+wyHPsM9j4mhotPpUBJ1KuU6lUYF6bhMzlUQbhmCN0DtIuQYCBdN/E+6hxCimBvft1LRWtMfDFjf2ADALXiMj4/jeV7uvgOC8O0rWRCcDRaz/UYmfssp+NBgH/+ZBcfqDOgnwDPTrSefj8xPyzBgabcyIGr70N/2bQNo/oq+xYDQ3hzzOjQb25jkHyNeQha4z5NVe6zMx3fahO2xzDUfa5O/DRDke5V3XRIJ0NEZkDKMIL3XgIdvUJKxy41frqEiHbvRirRVR2aMyJ6ZWnGiiOHQR2nF+vo2YajY3+tTKk/wA+95N567gHAnkbKB5xaRlVswdolwsku40cdnwE4vYGu7y1efu0x1JeLwPWVmmqeQbp3hVoeNsMcbWzdxq5KGmqDT9rm5vcrh8QmC4QZbUYVhtcmELOJowVBFaBEw5hTZVbN0IpftnZtcXb7CcBdOPznDkUaNf395QL1VoDhbozI9AarKS1feYFu4dGUdH4eSCilGPjvBgIUooocAIfEDHxH4VNGEXZ+9tcsM9q8RhD38oUD5BcZmNd1um4o7Rq1aw6tKSmVoTpYQbhX8V0HtIJwKCA8tPKJQ8sJLNxkMw8RlxgTXZsQ9PvdCZ/IUI2sipRJwbkmCsbDZc9MmAkbytJmXxq0oI5GYu0YnuPXnKMBVmjRjkRCCwA+sOUQKyK0pnZF7oVM5y83y1OhhHx6WuAxZB5HF16OkubHbTrpGpIc13i6DuYQWIkniQBYHMNpnm/QbWYuv52U9tew42e25sTDtN1YO60Hp6GcMfYQpZffccQEaKQfk4KC8CUqm5RJIik6dIOolU76IlBVc8TdQ+iJafwa3dAt3ZkipFTFxzOfEUsC/+LMuy6/c5OgGnD475K5Dj/PQwiEmgzZfu3SJq2sbHJs+yuxki72lm7QbFUqDfTpyghUZUHMiasKlpz2K2qcTDbj7nvtxRJHVrde4dOVzCEo89a57KCiNkCHjszWaJ1pshGUq7kN8/tL/i9PUNI89gpw6w+qwR2drm/ExiQzbeKIKjkcURQRtHyWHrC19gZ31NXpBkVCViZRHT3Tx1/Y4sthg5vATuGII0QZOqQCDa1Apx0IfdlFqCEKiIolmgUL1bUmQ8lur2C4o5rh4ISXVap2xsTE8z8tcQA6Iwbe1xOcNmH033sgcKTFHa4369httoMDGkjqnZbaUgJnjQYpvMxCa4dFsg1cWOMiZ99MGG9BibcDCAjtJxRZmz7v33AkU5aq3NOlJfcrqlzDt0sbJKSYwKnG1Mm20N3ibOaSe26bfWIBDkHN5EILEmmC5FSR9Fdq6lrNYiMx/e5Se6YzImXGRlv+01jZhwX5pmcXEBjfJQWcpeEtuDqMQRzugNQqNancYDgN2tttcvnSDw4cOc9ddJykW60jnDEIeQ+k30OpP8CqreIuKIzMBs3f7rC0FfOQvetx68Qpn+wXuvzdiZvI0Dy1Mc8vf55lLr3NpZZ0nzzyKIwTby0tUpI/b32RpWEd5JcoFRUFJ2pGiLPpc3lzi0YfejueWWLr6Ba4vP4dTKPLI2xaJhgHVaolDdx+iNNliPajiD5rUppaZPS5pHX8Pg+oc7V6bwd4e42MCGexTEFWkA4PeENUZEug2a7e+xMbaKlu7Q4Soo7wilLoMN9scOzzO7PEfhP41pDtAuj4Mr4MsgXTR/g7a2UcpTb8XcuOG4qMff5HBMLSAc5ZpChILk8oImtFkR5GyvM1G3NBSmcjmVjp/LQaZgtnk5Qtrrtv41FgDzb0yaVfi3QQijj8SQiJdBz8IDIvPAXQE1unrmXLCJrSj8TNmzqsozjpkZ9CCJM4HkcZXmQVICkGUrAvCGpPcmmKeIjJFitCxO56dotm0SekMlOv0h2l8Xi6zy7fvdSLheJFZX622KQv4jyoqhMhI47dSDsjBQXmTlLwQeE6VQPkoQoSOQ4a1uAdfTODpCzh6A7wIt1Fi8lSXXz3V4rOf/xKfe2mVP/v0l7l+coW3vfODHCp61O55L1+YbTO49QrDvcvcu/AILVXjM9ev80OnHRq6y4a/QYchxwvHaagVtL/A/aUK7aBHL1hnytnAfWyOXmecVzY2WThZ4djUKRbHH2Bt2Of5cJzS/Dw//fYnkOUH6Ic1ejtb/Lv/8BV+7iffg+f1cOSQtV1Fb7/HPFt87StfYXpim9Y9s8zXp6lU5nCLTXb7PcaKRWqFIgyuop0B0vOIBnu4hTKEHaLhEBH20Hgo0SBUs9QP/zwgs0XuTV7u5OIQhiGB7xMphZQOhw8t4joHy9R3stiaRiFlosQy1gORO+k426TzWnY0aRpDm0CYmwzgiDe3DNzbWkWDRe60mxlgnmmtR26wEUNyIdWvaWs/tuqz70IbVxsDoBL/bJW1RwgDLvKVZVpamQEpDKjP6EN69x1EVVnuRLarj9n77ZSOtgtQrsfmuRpMZqS4ScnIaYswCKvdVndkGj9ifNKz4U01sukY2vwsDZ1OiAmY/C4xGQzREYR+RKfd5Wd/5hf45//ydzl1+hSu6wFVlDhF4ExQ1M+C2IeSS7EoWWwN+bX7J/jkp/+CT7+wzNLVP+W+s6vc98BTLBY8aqc+wHB6m53rX+FwdZJGZY6ly+s8u73K33nne7io27zef4OWW2HRnUb2lvhn//aP+F/+9q+yF+zSGC7Rqu+yM1Hn+q0+O9tLPPH2OR5ZeC8lb5qbvuaFQY3i/E3+xx98D53CSYaBy6XLN3n2+Sv8+Ie+D7fQw5VDrq2EVMIuXucW5155lqnWDjMPHOFYZY5ybYGIEv1gSL1Qol4sEnVfxS0Sp9j0h0ivAEGbaDCAsEskinR6ipfPb/Nbv/Myu/sh3a5PEKjYBYXkADAVJaA7nuxSxC84ipIZngBvkutpSmGdJ9VpzAqJjAh7jmR594EkEBrDvhkVSuNyY0iEFOB6Hp7rpvELrsxOG08PY0jnoz3B7hSNkAlSSni1JgyjeNbZloiEx0SJnMUpv2WcrQidpgBXIkmhOkL+M5eopGciJgVRkoIpH4MwQiiEyJINYIYpSdkavyzru9lClp58nI5stpDF8VVZmtWcUcFanzNZ/OZF3NkH0fQhThj1+7//+3zoQx/61mo8KAflP1LRWhMSEughDoKvRPs8LEMEIQKBg0LrfQbROgIPz6nw+tYLnHvxNS48t0+jWeGuxx7nscXT7BTq3NrbYmN7GYZDHj37wzwT9Ai3n8aVHVo0qKgK5+VltvZvsL2/SOHSc9TGQvb3+1x5fpX7f/o+/t69v8K/evHfsjjbxKtU2Oz02F5aYfdam7/3Y7/EG/42ShSZcMepiArn2n3ae+vsiQqzuxeZJmSiXGa8qphpVpDufQzDDooiBelRdhQOPXTUprP+JZY3y1TdHSa8FVRvH6fhws4ygedCcQyn8gjFsR+g3jqBEG6yKWeLyB2Rx5uk2GuP+X17e5tP/cmn+N/+0f+KEIK/+ZN/k1/4hV+k0WgcWA6+jeXatWscP34cgHq9ku4pwvJth0yLD9kUi03wlrNPotFSSW5wk4XHAFVpbX4ZCIm3+9sy/ZCfJzb5yH1uqeJymYBG9uR0o7XuyQ76ItFUkgNEcXyFTPtkxsBxklSdaV/IPdceq0wMrRu02fClZZWwQJm532AiHYOWjGDlpVuIkSBFm7SZe6xU66Pjav5Mz0axNKxokiDMEQtROsgax3ERgOM6KTjMNL/xGDqOgxRx5iLP80AQB6ICjbEG/+DX/wEf/NCP4AvNC1GHx2VISIiDg2RIpPYYql0c4eDKOs+tfpYvf/4mGys+49MTHLv/AR4/fIZVt8b1jetsb92i7FY5fPRJngm6bNz4GEda47zw3Mu4ZY+jpxbZ3LvFTuco1QtfYPxYjSsvrrI37LL4/fMcXj7E6vge77n/EXrCZW1zg42bt2gvd7l3/BhzTzzKZO0Qs4Um/cjl1U6PdmebPVnh6PrzTBXLjFccxmuC1lgd6ZxiEO6jqVB2HYoiQNCDsEN7/YtcWxlnrnGDYrgBUR+nAnpvlcBzUIUxvvbsFk9/dY0XX91hvxPRHyTkIAyTuQlBMp4IYceip7IVBFF6wraZY7GsS6SAUOXnYDp3hLDFLJ00ObnFyDJZvIw1laXtfqg1tXqVYqmM6zgYgLyyvJZCf2ONyq35ydy1p2BmNRG3KSLsyWqSJriugyBOr4uIzzcQiDRBgnlQ7A6ncmRdWeNi7rU/z9YYW34yUpYtBVmQcfo8qxZjFXBcJxv75N3IJCNcJp467ac5eTpNBJFTgsR/BkEvO6WmAAAgAElEQVRIv++b59xxQz1QyR2UN20RQuBqFykEQ93hEaeCJmRTreEQUtYFNDWq7jyX/K8zJcaYmXgPZ554kv7867z22c+yv/oq59ev4e0FnDx+itmFRa702nxu9yKb+3/BjU++QVfs4s65OA2XvatbnPmxd3Dt/F8itrc51mggSwKpS9QvzvPJsSFPnvoZvnJrndfPn8PfvMhkq8b0993Lf7j6R6jtiMmCw8XNIRduKh7/wF/j3vEKM+UmLw2nUSUHr9lgV0XMutNIIXACl87AYaevKUU+CwsaIRvUWg8w712h32mwMywQOUvsXd+iUZog0GWqXpO6O4FXdDGqkLcKMRgtRlv13HPP8fTTTxOFEV6xwM/93M9Tq7313KTeysW4zMRaQ3AckSq6TDYTSPbeBBynWU8wG2ZswlapdtL4rCfPUCoHMEf1gAZwiPiPtMSpVZV1v8l0lG3WsWadvFJeZDXHz9dIRyZKOkNosvriFIQZqr4TQdFKEZkUn7dpLRkRPwNWdO4DIZKN3GgOE1/oKFSpBtOMR7rhy2xc0m09rTalaKkW2ACCOEUtmUUmbYMhbxrj1ied7NwCQ0zsTpl0pxlOlNnfUXbyq4FRjpQgZDwfpIw1tkGAkCLNyrK3u8c/+e1/wtWrV/g7f/cXeFhWCIlY00vUcHC0i6SF58xxzX+BWW+S49MfZv9967x04UWWLrzM1soFXl6/SmFrwMOPvQPmDrEaBDzXe43t3c/yzEc/z0uzksJiiWg7YPnzr3HXux/l+vk/p7C/w33uDJHn074ZsPZVwfwP/Cg/fuIw//6Nm9x4/c+R/gqtVo2ptx1jbfMmS1/9FGenJ/mj1zr4xXme+v53c3qsylylxdN703gzLVTJoy0kLdlEAHLosDVw2OmGjJUCJiclyDHqrQdZlK/R68zSFwX8cIXOtQ1qxTJDr0JNNHHKAqfYJYx2EcIhCALCSBOpJHlAIruR0rH7jiUAKnUvyq6lJFmnszADrAmwtt1RtE0cjKXPnvvm352UzomMOTJTnJfLZRzHQUWKSGv29/aze625RdIckwr5ttrNBcutyJD6KIxILR4JsQjDKM3wFZ+1khABpbLzVcgUGIZnmOEazfYjpLRSPefJkmm8sd6k7TWETRgylWWOGl07jDxF2hCVWKGRnjtiEzaytSyrgTSzmB5Ze79ROSAHB+VNXWJfWoHSsTaqr3apihpaCwIEkdZsB22a8ghKlCkIn4WyQC4e59D7xnDddYa9HjebHTaKPut7m2x3t7n+6qfZvfIaZWdA/ahENQp0fZfhlMNzn3qGiRPjzJ44Q8PR1JTHXQstllahIBq8GE1Qb9Z4d22SYvQEG16PE7UxikGfF/QFri9vEe4IilHEn/3eR/iNX/5Vyk7AvfMzCKdE0augQ83L+xH93V0Wqg1ksUxXSDbasP/KFYK1daYbVynORggkUajp9QpoUaXfBa8xSbn2EJXGXXjFFre7Er35icGd/DfDMCAMfKQjGWvUaTQat6VtOyjf3hJFCicxYSutUaHCdZJNh/x7E8Qa9Owk1gxUmw0JDFgwmj0r2w0pLsnuS6Zu6npkaddsbWTcFp1zsclZ7yFNxWoHMmc8wWgWsZ6ZECANwlKo3ZEcWM+xnyqE0ZRngCr1B7a/eQcRNUBMSRv5W89Mxsqc6irMWRFkfs/p2JGcYyBEZkXABofpIObqNq5AmQu55WZmyIbIUtrammCtjHuEzL9HW2GhRaqNFYmVIgZmERvrGywvrbDf7lNvNOiqbcbFBKEWBBpCreirPk3nCIGuUpJ9TtYq1O59gO2ZRRxnm0Gvy+Wxfa4G+wyGsNleZXn1VXauXWJyus3EmQY9J6AzkAw6cOEvnmPyxAQLp44gwx3uf+I0d5+ucH3Lxa/M8Zya5NhslcdaUwzZpecMmfYKRMUtnnPO88XzN1i91WE42ETt7PArP/uLlOSAB48coVRs4AqX3iDky6s9XN/ncG2cvnTplorc2tzBf+ar7D1/jqfeN0dhEYR28Qc+vZ5LoMvsbWsCT3Dua9dYXutxa6XL0Ff4fkh2aG4ie8SugDKx2GWkkpH5kU3/WDZMtqtE/u4INvPA31oRctp8G0zb8zwjoVlJjhNJiLogTOINYrnJn9dzJ8KR08LL9EHW4XvmOfkYiuwkb5vsZMG+YNLAWrEaOmtvCuzJYgnsdU8bdp42L4nlSUm1ysiK3QfTqRHLSDr6IhnupL1RolSQqYzp9DZLfXLbGH4r1vcDcnBQ3vRFI1C49JUixKGIw0AL+goKKDzhEVFkZ7BJxQmpORVmSw2uT7n4Nzc5NH2COkNe3Vrj1uareME2wr+OO+NzaKqImG4Qeh7jgWB+vkT7Zp/BfgftVOkJQSgiat4uxXqV040KK14Bp1hi3mmw4MyxqroUkYSFHpOTXbqqghobUgtheHOKP3/+awSbbWonj1ObnKdRkDSFw3Jvh4lihetuhdlikWpJUvIEVWeBUBZ45rOfZfFYkVrDBbeKqMwzvfggYWeAV6lRadxNsTKHdEvErglv/bK/v8/u3h6e6zExPpEuYgcuRd+5km5QZGAgH9CaabruRPDsioSN2IWlyc4BbG3/kQfvo+3RmXbSusX63XwnD0QM6DHPFYmWXetsQzUNsxSrWVC2trph77yJtjUFQLl2WHM29x2rLzk2kxxklUujmlcj5n2ZIT4tVmSWDmMFMRVYBChtW2q9ECnQsK0HOaKW9tJ+L9kA2eKotEIQEwQl4mDq5Efidha7OShhpXXUOs5+lfQ9UoqhH59zIKsQCYcCHn0Vt81B4QmIKLHZX2OiAGPOGIN6lVUkrO5xeOYklajHuZUbDHpbMNhARssU50JOTLdQ81MMI4WOXLRforPSZ7DbAWeMrg9OYYAowMR4g7P1KluOR2mswN2FcVzhsxP1IQjouk2OOZrVQYXx+QHDoYSgwqef+yrD9T0mHjpLrVaj5bmIEDaDiNlihctulUNFyVhFokWLaHiSUn/IX372C5x6aIJC0WHfF2x1Anb3ejh+iFdzOX9xi1trHTZ3evT7EUM/QkU6tZRlJMC88oysq2Qep5M6hYyj66lGq5FLWMoAS1zMNBdYTMAQSWMtFCPzSMexPCZtqOM4SMdN2qxvlwdNXt7MPmDAsz0Bdf7PLChbpqA9a5dAOCKxQpr1IhsOO4A7NzojzzDPTWOCsqUAc8p4GiRtrxGYOAVrbRwlCskAax2fF5JyLSOrqZzGqV2NFSEjBeT+TtnRt4gUDsjBQXkLFIFCMkShdQVJyEBrhlrjCkFRlGmrgEEwJIg0yh0ihUYRcX1XEwrFoaaHDPbY279Mxd9nYsplbKbJ4fEJHKeFlEWKjqQiygwWylx45qv01vcYlCR7UcBSe4l77j7FrLdOrVBnTUh8EWc0aMk622GPdjCkEJZQk1OEro8IAyYnZvj9j32C7tUukw/eR3PhMFPVCY5Ua8wfnmaxNct1PJTrUHYElUqV8dZJxNFDPP30Fxn4DrXIoVhpUGjezeziaQa9Lo6jKVeauIUKQjrfE6BZa83e3i47uzuUKxXOnDnz3W7Sf5JFyix7iRgBAvFmlfzDmOKtTTQHgo1rkY364w3KbMrYoNtOA4i9MWcbd3oAm91gCzDHQELkNnmjVTVgSOc2cNsFwLRNZ0DjDqA+aV1GKMxzRu9ROokpyH0x5iBSxiefjqKNVPsa3/yN5NomTKOoPaErGCvAaB/NI6Ud/Jl2JTsXIXvplh93elnnv2NYW9qNuBUGF8XEIR771Bca0FFsGZJSxtpjmYBFx2OoQVPBFRHD5MEl4eBJj44KGQQDtoWHjvoEWjKMIlZ2FZFQHJkq4PdX2du9QUH0aM16TEy1ON5soeQUrnAoSpeCKNNfdLjwla/SX91C1yRLm6toFbFw6AiHCmtMFadZAgZSMEGRcSFZp836sEMpqHDo1L0MdY/eEDbXQj7+x39K+3Kb+e19Ws0F5st1Do3VmV+YYnGyyRuqgOMJxhxBrT5L7dA0wYP389I/usbXv3yJWkMzdFw2uhG31vZxHUmpUuD68j5rGx06PR8/iJLYguzdiEQmM3IZv+v0lPFkrowGnack1X5/5uOUVJg5kj3LviakiA9KNH/nrEX5+mPiErfCdV1kksFPRWEsbunki8PsM995gVkLtCElpk2mI3afjELDkJSk07aCwAB4ATmXpFELSzYu+VOh7ZLVm1eYpJbL5GwHQyZ0cl9s9Bfpe0j7kyMqiZ+kWePuoG/Q9pfsa6Z/5htGWfFNygE5OChv6qK0JiI+QkQDXRw0EkcEFGSIrzW7KqAqfBbLi2z66yx3r4Ha471jj/PxI8f52Mf/hPvPDglrPXoE3NxXnD5TZbJQoV6+h3uK40zICTQ1oIMqT3Dfe2d47pUvsq12WN0KuHrVp312iy+vf4IPHvp5PDnBiha8oBTTOmA42CDsrnHp9Rvs18uE5YD+zlVuXLzA/mtrDLuaS5/4A7Qf4TgFpufn+ce//ZvMei4LjsNaBPvJ+lkTkpJT4ad+6ZdxhBsvkSpChQFusUK52iJd4s1C/Ba3G5jFNAgDlAppNsf5Gx/+L3OaUrPofi8QoTdzERaAMIfxZJqqLOVlDAokUaRSH/S4gvQHYGvIszgCDekJyeahuWlskYbMq8zk5Mm7GpliuxLYWrVR0Dqa2SfDMTGC0EpbrmwZSEGaNoyUEQ177rsW+DeaeSEEruMQmbEZrS+tKWufeYxpp3RMDimd3W0hGTPeOumWSg+qy1JApm1SViCCNj2MCVyMyUQaSJpaiwS5unKuZiPXpUh8zJP5ItIhi+832WCklFRqdVrT07Rak3R0SF94ODgURECEZoBiqELKIuR49QRLg+u80XmJplvlqepJPjV/mI989I9517siurrDhh+gpOD4dIVWoUK1ch/3ew0KYpL4hQaoSo0H3jfPl579U9qVIa9vK/Z6Q3rlbc7t/jE/PnE3ShW4qjQrOqIS9NjcvcErl55hbyWgeM9hOv4qO2uX2b+0zN7FbYZdxYv//P+BSOIVyzz8yEP8T3//7zLneiw4kmuBpo3AQVCRDqXyGP/dP/wNfuqv/wiDYZdK0UGHEWs7PYIoojcYIDX4gSIIFUEQEoYRjuPiui5KxadXa8sNJjnXLj+/zHvI2HHebcaRaHOS78gUj+dKRgbsdeKOc1iDMPHzCLTI3yWEwHEd3IKDGkYMesOMlMSzLUdMzCeZuFkByJD1W4MWmshYSKx7hEjOaRFWwoCEVGUpm0T6vXjNUojU/Sjpa2IJy4B23koiyFz/zHeEtYdpHZ/eDqAjkNKQIFvOTfvIiIUZhfQ5IpFRaRF2Ky2tuZZzzb3zijNaDsjBQXlTl56O2I4CStLhdRVwUkTxpqV9PB0S4tISPn1c1tUAjcOhQpOi8nitvcMPTU4y/rNv5+Pn/hK9s8/CRMDxEwV8qXn71Cka7gwbTLGiB9S4hqBNIXqDW9zDk2f+Gle2niEoXGBfVjn30Us4P7LJq1PHmS09RTVqcd3vEfZWcPov4nMMcfQIN7/4aW69+CKqqwl6IeMPjVOca7H1hZsMb/WRFFGlcX7/oscvjvlUS5Kmhl0l6CEpOiIBEKXU5C6EgOI3Ha63TLmjpjVZbF3Po96oc/Lk3em9B4TgO1eiSKNl5lsQ560XCJmlwkuVdOnmI5DkU1s6Thx4ascEkJjSzftPA/+EpcEj1iySgonYBQCjbVN33tzSTdVs0ne6zVhEsj9JN3BrTpozCvLXY39kKUmDO9N+pfWTrE/Jn2nmn9hNwMRMpGleLQ29Tb7ittl+05bG0+zzlvuHfV+qQxSZpheVtF6ak5Cz8QrDCM+T1nkKBrjJNNVj2jatEsQX32PmQxofojVaJK4jJgDSbl/yUKO1Ne3UgON5/Ox//8t86L/46wyE5FIUcK+j6AVDPHwcGecsqoiAPi4rqo9DibtLs/hKsTHo8r7Zacb/1vfzf3/hj5grtzlyWFNpeDieyzunT1N3ZripZ6iwTpFNJD2cCG5yN+975MM8c+sP2Tm5S/cKXPqTVRo/0OeVhT9jWr6DVd9lfbhHub9E1LlAuTJL6dEpvvSxf0F7aR3di7tXe6jO3OIMy594jXBf4bo1tlSDT1yAX3isR7VSYUpptgPwkXhObKkreBUCWePGrVX8wSB+wULHFgIRnzWiiQOLlU4yfUaKMInfUIlQ2pp7KYHUdz5+h7YAZHKQ+ezbLpzpe8WA7+x/M7V0+k7tuJd4HurIflYeSCMEXqFAsVQgCiN838d1nSTmSaa+/MLIoL1nWEqE9HdzAjTW0oGZk06WnlSZlJ92FQn5xTqo0Vqn7P1ndKy0BpUcpJZq/xmxmo7UETfXECudX9MMibD7N6LtN5ZLQ9DirmcdyhN1E2Qu0neVX7TuXA7IwUF5UxeJpCAcpIb7hGSAQukBfe0w1FUkkh4uPa0oRRqcFm9Q5mL3BntLz1DzA84tL1GY6RMUFatehcrYcf7+1Lu5EG6yHknKXCaIVthVe4w5HivhgKAww3OM49aP8UA54uz4K/zTiz4XX15iYeIjlKa/woR3DL/T5NlrisfPvo/NQUC08hEWTt5kfKrM/pZDXx3lwUd+lEJzgt13dGjv3eSohJ+9690EjscbNzYYrykmygUqjoMbanYdQdMVIOJj3J0kBeD3elGRIopVjHhuAdd1D4jBd6G4UiSm/XgDk45DqBQSgZROsrlqbIBhsujkNtMEyDvuaD58QRTaG73ItMl3AC0IUKHK6s8U5NkWJ6zNXmcPE+mmmWnh7ng/+d81OtagmtziRqOePNukiBwtedIhss1dawsoaLRSsUzn+mNiIKy+f6OiczTCvpyeU5G7KMwYGG2qpWlNsgclZ8Nm46YtAGOAfzJIqRXPfGOE7McWg3y7RpqaWp6UUkghUUJSKZSoeCUcrTmNYKgFrgxpUyLSXtxG7THQinKkiAozfGXocmP3MoONlyn6Pl9fXmJ2sU83UqyWmjzeupf/avwhXg+3WYkkLV5kL1whYEhJCvZChSrO8GU9Trn5AO8d87jivsHHNzZ47ZUOx2d/l+LYZznq3M3rW2Wu71Y5fvhdzNU1N2/+Y+5/akh7q0K3XUcUTnL67PsptibYeHKX3a3XeO/kUX5o/n7agebffO7rnJidpBwFTC8sIFtN2o7LmBMPzu/93r/mZ376p3n23DlAIx0z9yQRDugM6EdKo1WYzhOldOrD7kiZWJd0sqbaWuUR1qxH/r/9rd3hwzhtqolfkCIJKpZZ5p9URi1gm/nLa4rlEo5bQMoCQgximZLxXq9QSG0IpE7IuM0J7kDM7ZKIreO4uXUn+SX3NZOOOO2msbjY/8yjzLqYO0wsIWVk7TXuR+n+pUncGTNlSvp8s1aSfW7pI1KSjSXXxkXPkDL7NQmRdEGbfuhYuZLIvND2A75xOSAHB+VNW4ycughCFJ4oMNQOQjiUpaSIg9KaEpJupAkKJarS4S4qHClWicbmuDDc5eXOH7J2YY3qkSIzhyYZK06zGixRocm17fNcu/kqjuxQqbhcXlH88FMLhBIqepeWF9He0zx/bZMPvEdxbq3Il764z8STmxw7vIgnqkTDTV5cfRnCp9m/uIxoCSaPzHH3qWOcKL8XJePA2kZ5jHBsGoXimlbISLEwNY7QEUUpKDoCLQV7oWbMETiQ5oi/8yr4zQX8rVSUUjTqNVqTLbyCx/b2NrOzswfk4DtcdDrfEhciCVIbkJhpxeONM0pAZKYhRxlTukHQ2eaplEZFGVhJU3XqUchyO2LXaWoW+3N7boj8RwC2ZptMo2YD97zG0yIXgiT1p6W1T75tA19lWym08Qm2zi3QMq0jT56SujWonOXE1rbr2y0l6fibuuLvxOlEsxz32dDF7Yhjsk2a0az9ruegktSOSY2IJO2oyZlO7lmmDToBNVn/Td1xEHtGEiFLexm/84xIeoUC0nFwPI9XXn2VIy+/xNkzp5FKIqSLkOPUhINKgJeH5Fay3telw0NugfvLY/SnT3Cxv8OLe3/Ara8tM/NEi9b4DEWvwma4SoVxLm0+zxcvv0yrCT1f0Bs6vP3hOQKhqbPJbNHljas9tga7/MA7NS+tF/jMn+4x9/41xidOEQWCzf0N/K2XcfSXWHv+CmP3TXPk1BFmyvcxX3ycUNfQCE4VJxguPErNK/H60KdcKPODTzzA3tYGi81ZGtUqQx2x3Y2o1go4AkqlElI66UArFae1lY6g4AqEcEAnFhvM2MekICYHyrxBEIrbNN8ChB0oawNc87kFnrP3aBHnZI5LmWm3tdI5wmxc0UwigxwWTfY0KSWuF/8rFDyqpRKhH6DN/DS8XAuEyEdJGznJDGYijbPPZM2619b8m/YZUJ6SGQvUJ+k+LYmw5vCoQsGKQ9AqdeG7LauTIRnJsNvynhpVLEVGbOnLxk4Kmbjo6RzBMe9IpvFNI8RJW6fM64zof7NyQA4OypuyaKAbhXSUYkcpXuqF3F0Q9JwYuBR1SJEQT0q6hIxJF6382DcfRUEoaqUWDxRK6LPv4FP7+5RrirO1BR4uP0CfTTaHL7GnNuiGAyhUiMaOUqmdoeSVWRQNKhSoErFSURTrX8Ld7tNfK3BsoUbfk9xod+gONmh4A2699jlaR7YIawpHjFPWJ1ioP8piaZzdTo/nL93kdGOO+WYDVfS4tNajLSs8POYyhkApgY40joCajLVCMlngxDeV47ceeLYXz8zFRFKv15ibmaJSquC6Tu7+g/KdKtZmLkjT+WXFbHQZKEzdDAAljak9VvdlwbtZnd+I16ZW79s/yZntratpxQYQ3LbxaUtTZz9bJPEMufpIA6OzA5u01a7EpUBlmY4MSMvhZvtZRosqrCGwteoWiDDAKxfUmHUsD3JGQZeRI0M8ksuZbzVYryzVaBqwpMnWmhyAEZklKbWI2OOfcb2sbYkLRwbMRHoAlUnpaOpxHIdSpcIHf+IneOiptxG0pvn8vs8RR0G1hNARZXyKCTjydcS4dFDKJ1QOgoCydBgrtSgVSvDAu/jo2irztQaPVu/iRPEoPb3Jlv8i+2qDXhDiOpPo6bsoy2NU3BJVUadGkRo+a7VrFHsXUNt9hhsFThyrsUuJ3f1dekGRYrjLyusXWDjRRbRKdPplpvTdzFTO0BIFvvDKs/hBkeGlNvffM0Wn2WTJ04iS4IlWmcmJSTw3PjCuJASeK4hUdnq1dGIXGKXik30N4NMq9tFJ4wNMQHnqcmMH7pqTkk3q3wxMCpm4DlqkVpBlzpHSSficTudj9u6z95+9X1JiIrXt0iTRqFR7nX4n+ZJWCkdqCo4miH2HkEIQGBepkZJfF0YXidGFIyPjhpSKjE7llBEpWE6eqZRZU3TaPxvmg8hZAfMHoGV9jOXTJgl2xjdtWk1OKHNjRJoYItdvY40QpHPBttTEfSJTfJC5lBmFw7dSDsjBQXlTFD3ymx9F9KKIIZpIQ0/DZn9AWyuGgw74Q4Q/YDjco7+/T8FVoAXaKaGkxPM002NjNIsBzmaPudlJClMercI0c26dNX+bly+9yk5BUanXaDYOM948C8X7kQJmhGZIgaEeIIstDk20WN7coeTCodkC7W7AMOjgFfah0KbTu4S+KZiYnKNeuptW6TSlYZPttWVW29v0N/cZ6BJ9QnTBoxhVcJ2IQt2JTeUCIgEigoqXCLsQd9p3v6fL4cXDPPbo4xTcApVK9TZScEASvv3F3jiFBhXFmskULItEt23taVpnbjPpVqitv7Ue3QPT72V+sYmW3N4QtSUBo5g/BbKaOA0OGeARtz8s1WqjLdCQB8vpdUmqAc89k1GyPmpVyD7Mz1XTHnHbJbORj3bOEJ/R7TxztRM5PBQfOEdGDAzCx0o5a0hciiFNPUmgsDVudryANH0f6dKoFSMdAU0KYJJRSn2+hZA4rovjuggh8DyPx972Nt7z/vdz+PhxthyPlfaASzvbVMI6fr+NEwQov8tw0GbY6VDw4rkSygrC0dTKBVr1Mg0vwN3sc/jYPM3GFNOFFk2nympvjZffuMB2Caampphq3ktp/CwF7xiugGmh6VGkq/ap1yZpdcZZ2mhT9DSH5wusbAyoVTsIMcAtrNPZusL69SKN+SZF5ww1fZT2ypC1lee4cuMNUHUG1zrMV4c0tUu5XsENBzh1h4pXYXNzg0a9zFi9RqXo5cCd4zjEAaZROl7pYV7E1gTbl90EdOtkzM0hefo2udHpe46JhcrNfUNO8xPyDhYve47bb12TBR0bLkv+gMS4vkxH7g99pFb4wyG+78dzWI8oj8wTRixluaLJ2pkSWUsbYQhWXBGaOGQnTYmadsmAb5PJSxjWjtFDZJp3bf2ezfPM8pKRkfRzY9FT9t9JP3W+b3GGIslohiOlNdJYHaznp+NjtIp6NPGCWbu/tT30gBwclO96sQUWIFAR3TCgr8HXIFTEoaiH6rXZ3tllf3+L/W7ATq/L5u5l1OYWu/QoyQZeoYFT8PBK0Gi6HG9o9pf2GDtbpzzRQjg1enoPHQ559vlN9FTE2+8/ywNz9zJTOMVAFFnFw0Gzp0P2ojaRHjJZbLE6vsHhZkCj5LJxM0RUFZWZgE5hiWG9x8b5Hkd/+CFOzjxCKVqgs7nD/s1VrnY2ONyco1rVbPS2ifYdTk4eZVr6uDh0hxIcidKxBkkpjVuKFxZLEXSH8r0BlO2N4OTJe1hYWERFEZVKJVtMU0B0UL7dRVljnW5+lgot0wbntXVRpFIwmQbNJrfZPuu3b04j7zb1XyA9OMwGFHciy5lrkCUV1s22Rt6uL6ecJ3MXMj6++VYSB3cmm/+d5mMitSnhMc8e7WsuQNdUnl6y/JRR32DMsqHXWien48YKkljTT+ZmYXyWDXFIyVgG3tPr3MFikfxuwEjak5xMjgZpxu/buBBl2s44zsArFCiVy5TKZRaPHPeL80wAACAASURBVOHDP/WTHDpyFMcrUAl95qMuV7dWaO9t0utss9eD7c46e3tLRNs77Mo+ZcagUKdYcqjUHCbGXBarir2be8x/3yy12gyRcBiofYaDPuee30TMKT74xElOjZ2l4h6hJ0psawcXzTYh7XAHRwrGyxNsNPc4PBVScx1evLLO8WNz6JrAr24R1UOuvLLHUx86zamxtxO0Cyxfu8yNVy8i6x5jEvzZiO2oR3l3l2NRgeMTmvJQEooK2xt76FBRdIoUhItbJAHuAkc68YFgltYbBGGoEmtcrNMWIpbVMHb+z8Y3BaCZpjgNGk7elpQCrZLkAOk1eTvQ5HZ5syFvHOCbgXZDKLXWMYtBW1aAhIgmc0U6kna7R08KBr0Bg8EQZU7XFol147ZZb0B0JjB5mTaMNVsv0k5bZEOrOHDecZyMSBlLoBjJ7KNH/4wvqCSWw8iSUmaMLeJ2p7U0aVB6/oH1PlMZS9YjO37IKGAyI8eIRTdewDAvI34HljbAuu1bKd9z5GBU03MAKN4KJTP1RVqzOhjgOQ77SnOz2+fW1jrOrdc52qqy9eplCq4PooZwGhw7fi+L765xYVNToQ74FL0untrg5sUXudVx+aH3/zBf2r5IJQxYlCEVNFqO0w5c2i/tUDgWMHbIpSiKOLgso/C15i69g/DPs9Q7z74/4PjMOEdDn11HM9M8yb6qcWmwSc/bIvCHUPHpupO0ChPQc7mkXJ5417uQu5scc0LG3AI31rYY7PUZK0R4OzsUvBnabZeo5OIUYsHdjxTTi3EKU6FHNZXfOyXnlyniA3Fq1RrVxGJgB2HnANVB+bYWlbi0pSBz5HOzxRq/4SiJBUh97CHxk0+0xSii3LuGTDtm/HWT4FaZbep51wKj9QJHGBeIJCuII4hPeI3blYL8hFwYjWiqiEvmkYpUDkxl00sk6Uwzraky6WEMJ7KCGE2387AkbovJMZ9mZUoBhZMYEoz2P9Mcp4HCdk0iLwO3e12MEJkExCR5pmK8kbpJZc9RSiVgSFukRmKnQrLPa7hdS2kOZzJ+6OZY5ewZxhdaaYUjXRzXwSsWqI+Pceyuu/gffv03mGk2WY40V7d32du4RWl3mfvGKzz98ss0qhFh1KJSaTC/eD+tmQoXtxU1xtD0qJc6DHZvsHXzKut9j/f96If4w6VnuEsHTIuQqqhQEWO0hy6dZ9cZe0xRcTzKokCAwzKaoVacYpNLw+dY7V4nEJqTs02OBz5bTsBOf8Bz28tUPMDdhSDErWvKYw9zpjHLy90uEydO8ba3v5Ob7R0WdZ8XX3yBdujy0vMvcmVlj6l3vZ3xyoP0+i4n544TBQOGGz57Hcn0YhEJDPxhjOUSUhVFMSEY+n4KGqWUKYmN52gGZrXWRJFOUwsLixCiIYyi9F6bLOu0bitOwMzJnNxmMmXi4eL0pxkIFsTn/xrBMFm/bE27QBJF0Gn3UCoi8AMirRGOjLX5CSjWKjsPRaQzbXTy60wmhbRkw0QQZHNYCJPtTKVWlLivIo3XsNc3lfY9IbzGQoIZOyOTOg/2rXHDIlMmS1nmEphfe/LB3CJNFGDkMj2MUiTcK6khl8Z55Kct9Vmcwzcv33Pk4KC8VYsm0orL+3vgFEBFLG92eeOVN1h95SXO3N/k1dUib3vycZzqPB3hEQjNhFeg6ko+MKO5HPQo9V+n1w3Zjeb5z3/sMfZFmauDDT585DEGqkOgFa72iOSzeJMVJk/XuFpd5ujgIidq0/Q5zD1a0om+yo3ORa4/f54gCDjy5L3s6iH3Bq/y23/Z5wOP7TE32+Vrlzb48v+5SvWM5PQHjvH+1iJd5dIrF3j45FEGGhaa04wT0ZQe5UqLzjBg6EfMzU3R/a0v0piaxzs9iTNTQZQc3Dk3zbnsuFlw2vd6GSUE9vWD8p0rOcCgQZrYD22C3uI0gyqKcABHkpzQajbObLOWTgxyVBBvzrkMNjretBVZxg4b9Rrf/5zCR9j/JZtmAtSj0LTf/NBkRySINDc7xEQhywJCCkDihpn0nZl/tA2+U+2o5dpxG1xJNIQGXKjISk84+qWR6S2EiImLzNGD22+0+yYEOlKpxjH7VqYBlgmIVAkp0Kn7hIrfk7Hs2K8heZ9Gg/n/s/feQZZs933f55zuvvlOntnZ3dm8b9++fTkCIPAYAIIAGPBEqEhRIi3ZrjJN2mW5rFCypPIfLlulkkolkVSV5CAWZRZNkaBEUAwiSCIS6eW8723Oszs7eW6+t7vP8R/dJ/TdBYiyXXyBc6p29+693adP7PP9/qJvRuEAk7lQeKAnJx7I3Dwii5IiZCbJjMoljp+6j5/923+bsNZgK065urzD2W++iGqtcOieac4kFT7+/R9BVQ+yhaIkJRNRSC2QfHqv4vSgw+zgVVbaUDr0EPuf+hhtylwarPHfnfh+bow2CEQdqUekwVmihTrzjzR5OTnHofgg+8t1Iha4B01bPceF7Td566svM3NkD3PH72Ooexwfnud/+sM2/8Mzj3OzPORPv7LMy1/boHky4L4fO8Izkwc4M0qZ3bvAoaiMAg5WKuzRCac+fpzVeMjwQ30uP/sy//yf/u/84od/ntnDR6k8sYBoVJDTQfZHg04U/+B//PucO3s2G18pSeMEITNHcyldPCmNJkkSt3yEs3O3q0YpO/9mTgIpSJW295ipM0J3Pza/eZjWeIA1+8FG8YLMPKmwgVwEoCTRIFzeBA2kSZqFYVWKeJTl07A5T+zzlA2je6eou7gPzFo1YXXdviq+x4xjtTEbMmMs7Tr2wyS7iuyYF18DXs4OXbg+H0Fbj3Eah6IZYJqq3NTODGsubElTW4svnVFK2b4Kf6+Z913+rvJzXZi5c07uwpuv71x2ycFueedLvg9SremnmheXd7j9+ivEndvsm6vwzDMP09y3nzYRt9M6VQLK6Yhyr83GTovnWiEL8Vuo2iz75uapTh5goVymFJYJ0gGDuEvMKptxwpYO0PVNIvEwn3r6Mn/82ctcfXaVz96zxleeOMsn9z3Gog743144y8L6BotRQmnvCc6EH+ehsIro/9889dAOy1py840trixvMvfxBqUgYmK0l07aZLJcoynLSCGYF7ChoZtq2koxI0IOViPCsiLpJcikQvTsLZLXWogPL1L+sX3Zy12Tiwbk+5obfLdmQ7sE4c+xeKYGNk4/AqVShPEJsAeuJk1SpJHIO8yQSTGTxILXAJElw1I6A74iI78ZMPBOK02ewMlzzs2/J5f8CTxbaG1U+vn5aA9EYdtqpWeaopmDFdd7rKOw1jJfCCNJdVFJvsP4ebdLS0qMlDEfF6UcQPPqGo+NfufmdyAjzU0wAuPgq30q4BopZQ78DbAwZMID+sbsR+SffUKWORDn9+Z1mUg3Or8eyMJu+oOTrwUZSKu1CMOQQArK5TJhucztdp9Xdlrc+NY3kHqTB4/u5djRx6nOzdOhzK20xoQImRx1GHVbXG8PWO7AfHyWtLlAc/EoU3M1KpUypSBEJn36ozaxvM3tnmC7FLBQrhFV7ueTT1/j9/7tGc5/c4Nf/MAm9518jQ/OHqeRCP7Fi2c4vrrOvokaa1OP0I0e415GyO7v8H1PbvJSW3PulTVuJwPmv7dJFJWo9RfYTKssVRqooERFCiaA7VTT0YJtrVkKyzQmyxz//u/loyceJvrliwRfukbyepvyTx4k2jeFCCQazWg45PU33mB7e5s0TXOpfEDml5GFdQ6ts3JG7uI4yQm4mQaRZ99WBXMfZ+YlPNLt5k9rTRCYHBcugpidWxM1J9cwjEu6syy/vjmOWS9uvZk2asht/Y3WSYDIQyEDKkncMzxObM2GDDnX3lITueAil+5ryCKN5dJ8P8SqECYDfE6S7dZy+9u9IUTx+UW8btf5+J4ReQeE9PaldoQiU7YaEiBsHWqMEGly4Ulerw02UBgTnLZHK/xBcWTJRY36brXw72tysAso3jvFbKv5apmtK+c5eXKJfRNHmK2H1BslVFQmpM48EarXpd9dZTjsUZ1sUqtvMlc7QS+cJipVIBSstHb4tc//AR96coGZyRqdYIrJMGVaBAhZQwcRT0z9KAefuYcvnXmW0ys3Of8HF3mtc4MoGZLUKyw8tMDkoceZnnkEor2ckCHfSOc4t1ll79QEe8VN1Gibl97YZliOOLDnEJvbN9DVmPnaEvOVfZTJIlLEAq50h2wQUCpFLEQBMgIeXIDbN5H9AemFLfrPlah+aJagHmUHsdELv8+Lb2J0t992y59fcdJyB6h9TKy9pEpW4G8uyf8fBBK0YBTHTsKmcETAy39w58PHiKIQ1qRHSjyTBSwRUErZJF7G/CVNM8BjanJAID80lc45gS8lLPoKFM3epH2e4xcWJbnm2sM+IyIBTprr+0UU7fLNoY3tv806XTjM3bgEgQNxRvPi7xSn+cAjIdq00H4KwyB3GsVpf4x00eAxE79dCM+kJUCpNKtW5FoSE25WiGIfka4PUoIUdLpdzrz+Kr1oiac+eIqlZsh0M6JcLaPCCiVRY0FHqM4O7dZNSggqkyFzkx1maifohPNUyyUSCW9evczr59/i0Ydn2DNZZ0PMcrCRImUZIStoGfKB6R/j4F85xude/TKXL7a48MZrfLF/mjCNiWsR8qn9zB78MMHEg0yGe9iv+zyvZjm/UeFkNMOhoMdobZtLN7tE1YRARJzVLzHov8RD+57k0MxxQqAmIEZxptVnvVQiiAKmwhA5O8HokQXE8g2CbpfRK+ukZegsxvyH3/ttXnjpRba3t4njmCRNs7FTGhFmBDBVWbKzNE1J0jTLiKyzqFk+8PUdU82Yyzw/giGUzgdB+1vJZkQHR2h9c0BrWWfXiCPw9r2hTUZul5+nQA6MVNtkGTaA3mu3v4/c68cAaWHfNeNHRpDndlBW4JDdUyQHRtBe9Lnwt4lpQSYQyIiPzkP7+mSgmOQsE+TpXANixj81G8lkWc7/dlq2bCzv0CQKrEmRX7L9LnOCdKdDsiXtpkP52OrcjNK91L9zef+Rg10c8Z4qHvlHCigJwT0HahzbN81Co0oUSEaklCkRKWhvddjZuUY/HZGW64hSjbCsqDZmCWWFt1Zvc/n6ZTrrqxw9dIjJ+gxLlZByEFEWKaEYkuohXVllJGZp7J3mgXCaA3vPsbN5hWeXV9hTWuKBfQ8wf3CC8sxRGuV9LIgKkYZraobtKzc48tBJDu69l8OVExxqnkVEVeYmj3Bju0Vr+ybr8SZnh5dY2n+EqFrhQKXMHhGws9Xn8k7MVSk5oGBuvkayEKLWdtAlSVifQ5YDm7TkLyIw/ovY53dbMfazRhug8eeleLAorW3ELadiFxas25C80kW9MSdYhj+EBQ3mcB4H35nDn0Jr4UnBcyliDjTAAQvTTqXGpNwID8hkQMj83x3UvpTdfOeBbU0uz+Ou/kAanYNprITWjI2FKwWwDhb+2Oe6fhtHU3PIF773wJ0f9tBGsFHaM53InueIQdZBKSU6VWiUNUkQIpdy2v6rMcCR2Z4bYuD7MxTaa2+RVpMjpEQrzWjQp9va5r7HTnDy0Bzz1SpKKBQCKUKiFFqbbba3LjEQElWdRFQqREFEtT5DKKs8d/0Ky1cukKYxhw4cZKo+yVI5pBSUqMgRUg+I0fRkjVjMMbE0w5OizsOb57mydp2Lmy32lha5f9/9LB6ZJJw8yXQ4x7yoIJKUa+kMOxeuMHnoQxw+vJ+DtSs8sv8WhBXKC0e4utUn7LR5de0lLpaWqU3MsH/PAkcqFfbJkJ3lLc6MFHKUMLHZ5dB0A+YCVHuLa+dvcm6lxVviBs+9+gKXrlwiTRPiJM1Il9ZopWx2cEMY0zTJiEEuZXYZf50UGXzSma1df4WaFVcgwkoba1a7H9zazdecTRDmO9q6feKoBU4gTvG9YNZxMVOxW8vGB8bj7IU9Ytl1oXhMdmzv+nvUEBlXgbenyHaHfc8J3D7GkQpnrmMIk3e/R4zNuLqxEYUuFcdQe1dw1/4VpP4e+c765dXjv8zss7Dt/27L+4oc3M233SladwHHu75oiHXKqWMLTJdKVERIAmgVZpmQt1tsb2/QH7XoVJoMypOUVMhUaZYzLUnv+mle2bjM6uYme6MGH37kCRoyYEJ0KQmItSKhixRbVKkwoEwomjywp0ljcT+j0VXmNlY4UjvAsclTKFK2kAQIZvSIS71brCyvsT8asK8xx8LcfZRmTrB/aS8z0QS30xpbgzWC4YB2v8vK2ho321tIWed2WGJpdgIZh3TXBlxa3WEzDnj8nhM0H5hAtiDYW6d0rE5QybflX7Alu0sK3h1FCE/KO0YIrI25kfDjAIR/TUYYzHUOjItAoEUOevBBsHF+zK5TBqCSSckQmd2+s6c1TdPFc9Br7riAzNhjG8ID3hnqS7rdVxbEOxlkfgB7mP5uj/eLAULav8qr2zTYtuUuBIF8tLV2QNCCPuENnGM4eSInTZCPny48IK9besAh9xvRaKTIbJSNqYIuDJb56AiZkWRm/5eedJoc2GLrM1qYRq3KwQP7ePjkXuarVcoipG+6kkB3p8XG1iqjuMtOcy8qalAVEYGs8/aOpHvlZZ7fuEi83ubU4eM8df+j1GXApOgQCcFQJyixTcCIChX6lIlEkw8crDF5cD/Xuzc43+5ysLqPo1OnSPSI2zpiVmhKaZtLnRus3lzjSHXEYnOJ6eos++aOI5NlGkGD26rG4PJNJmSHtdVtLtx6i2Ei2TezxAOVCkf3ziLbAbdvt7m5vEnlVofWoYOE6VW2tq9ztr3Cy9tXeG3rCkM1YhSPACwxULmmIMjt8aVn4icgC3WtjS+HkY5jJfrjc5WNvb5jXfmv3bthy4I2gmJwTvue8DeBLjq9Wjv+8T2Hc05GeOTb/Zzb+Wv/9oyW533S3vdobZ10XbsBoe2+cZca4yO3J5zAQXoO3cK+z0T+jILmsDA+PjHKhRje84xJ0DhM9bWJ5i8xfp22Tcv30Tj+d6TLalBNO/Jn+EEUvpvyPiEHd5KCXTLw3imGjSc6ZSBSpqMmFQkip+c6VXSGHa4urzM1scLSzBLX5Qw7ccjEcEBVxPzKuU0u/vv/k9mjEU9/5Af5gUc/TU/CLAl9qgi9TVsr2oRIMcl+MaQiJHU9ItaahH00y0f56/sbaBJ66QZKCuq6T6JabPbX+cKVP6T1wjf5qZ/6OHNT8/SUYHUUs9mt8uT0JEeqTeaPzYKCfhpzbesW3/jCH9K5JvjS8k2eOLTAUw8eY7bR5ObqFc5sJuw5MsOppw9Tn7mHoFwq2Pfult3yTpRM4liUwBn1tcqdXo0jMNpkStWe8YxAK0h0akGpATP+Mww5cGYM2MPTfJTCOVoGQR4ZCcgOQs8MJ3d+loHMzRUUPtLwTY7cl2BjgZvER1bqVww5aqSf2rvXRWfJDmob4Ql3cGfgW9vqDbwy6n3jEGwkq4a42BCg+WAYzYrfJ2etUIzU5IChAwg+kBirxmoZ7Nzk2gSVv3+tf8c4ItFmjFzCMyMpdWExs+vTNM2z3Wf31ZsNjp04zkd/4PuYiEqUhQAUQkOSJAy6Xa4urzHRvM6+xVO8qiZJh4rKMIZY8e8vbHLh//oXHPreQ/z4D/w0xw4+jBIwQ0yfCkJvsqUDhtSoiJB5MaQmBE0d01eSWNzDyfpDPN6sZe/7ZAMVlKjRIkliLrdu8aeXv0LnxZf5L/7LH6NRnmQjSVgdanTc4IGJKY6XJ5g/OYvUgu24x1uXTvPs1/6U5187yxc3N/nEfft5+gMPU+5u0r10hZtb8PJrL1BOV3n18gV2+h1inZIITaJS4jSx+8LuMSGs+RAIsozkuTZI68w3QboEc9oAZGEi3WC1aVr7GcmL6yCb76Jpi93LFM38ClqtfF8VE4EJuykK+DaPEkSuVZQiM7lReQhes/YK691ba0YoIaRxuvXaY8C02bPm+tycSpOZHBnfiVRlmpcgMETW67rHOJzZjqMSKvdslvkLS2sXcc011xESa3pkI3tl4x4E0v1WGF83hmZfKfubC8DgTJ6K7xx/jshbZRzE78JNvm15n5CDrNyNEOyShHd/0TpTUcc6ZSqMCEXuoJUO6Q5H7HQHdLYucer4CarhLBdaKekwZq8eEgy2+Ydf/BZq7SbV41U+8kM/wwfvfZIpCTWtaSlNmxTSHiEBZVFHC01d/wlS9zjdqdAXe5iI6kyXIjbELAfEAb5w+1f54PRJdOkE53dGvPT211h97nmO3jfPnvoP0ggWmaRNOLzCxUuv8Af7DvLTe++lKiRrWiJlg6cWT/Lhnz7Exd5r/OGLZ7j+/CoXvvISJw8v8XP/2U+wc/5F9j16H7evXEeWQ5rlMrvMYLe800WlKTLIwLZNBpSfnlLmTsWQH+4mNGJ2wFqAnub2uAaY5GBBeeY/WpNlNLeOk+KOiCDanHoSRCCRwsT61taswrTLEgM/xl8BzbuPVlo+liHZB9TC/ypvo7KncGZ/b4CIf+hnvGrMDGAMr5trQHtgIJfUewQIXBQWH5sbSaD5bCWfwmV2NqTOSvgNsLDtMfU78w7pO5XqDMiZdWCuNWZaqYl4pDXay4iczU/qQjta6bImCEPKpTKL+/Zy/J7jTEVlIiFQaAbxgNYgod3eIumv88A9R6gGC7y2GVPTA2pqxPL6Cv/m5Vdh4xYTjy3yI5/+u5ycWaQhM81wW8EOmiDtEtIkkhUitqnrbyB0n1fbVeJgP5NqSCmsE5WW2CPn+KOVX+YTC0/RkSd57dZF3j79LXYuvMGRe+aZr3yKiBoNcZPB9hlOr17n5p4l/uree6hqwU0VMFOa5kfu/wifOvkQF7un+dyzb/DGl2/x7G/8PgcnI544uoeP7dnD//xPPsvTj38PF9vrbN3qMOgP0cKAP23n2JmBCJIkG8vUhOMCTLjZMAyz8zPXMph14y2zjNDb+7K5y91nrEYHnYHigvWRW6iF+33/BisOyOe4kAjRA/hG4GABfV6fITSZyZRbLql2dRa0efnfVqvnLa87iif5z6KiqTwfiNsPSmnrSC8Kt2oKxMDie4+Ie+sagachcTWlqS585YQG2ciZEKQmYlP2rhXkfv92LM39Co1Q3p7FEYjsWi8iXH6/b/b07QfrziK+nRNgVk9mrfW5z32OZ5555ruu9M+/jL95d8t7pWgy56VhmrCT9ImkICBgOLxNfziiHaeMpODY5Bxq2ObWVpvXWoLuTkxrY4cXb99iW3fYefUaJ3/2p/ipe45wpF6jJ2BBa7ZVF6mfpSGOoSmBSKkwZGv0LVrd51FynbkgosYMOpllONL80a01vufQMQbl4xAcJ+0P6a1/HSnOoRf/GvsqxxEiQcWvoeKrKP0h1vpb9IY9lib3U5YpiRrSS2FdNnmsXgadcLr7Ft/65ltceO4GC2GNn//r/xXD9TUqU3uZnt9Do9kkkMHuMt4tf+7lypUrHD16FIBKuYwMMkm9ydY6GsXWnEDYv9wh6sBxdl8GSlIHGnzVOWMHXm5yI3PnRUNGjLlEkKOGND8801TbTKqQHbBBIGy0E+Mo6CT7OXHQXt2eb4IfktQv0gPShQBCVn0vrRTT2BMEhedAkWEUgUn+RQYswCKz8fP7bpoAf7yt6YAyeRuwwMxqF3CSY6Px+c4yRGfC5MfVV8qEWPWSXWGyH2OvN20TUlgzozAIqVSrHDp+hB//yZ/gmc88Q6UUERLS61+nN9DspAmVUpn99QnSQYfLa5u80IpoXVvjxtYO14dd2mmH1hs3ePzv/df8N0t7CaIIKaCpU9ppB8G3mBQPE5NSEgr0Bjujl2j3XkHJNZaCKiKZI0mqbA4SXtzq8uEDx2lV7iMITjLYOseo/TIy3IKFZ1gq30si+qjBF9BplZG6h83BNr1RnyPTh5C6yyhNaOuQYVDngWoJrWK+1Xqe3/vNZ1k7s0K1P2Au0JxcOMJL59Z44+xFtra2GI6G+dqXeW4DF6I0G+/s/34cexeKFgIbuUjdATztTOYLwtn9a6tFE9axVdm97AhinsDsLuTAX8PmZxsStEDujTBAFtaoWSPKMy80WkTnWGs0YeYvDGPCaBe9D3a/+T4FTlDgCICv9VTKhPHFacqELL6bdJEcKOtI7fopA0kSJ7nAwdyscwLtCLvfhSzqlLaEwxAefy6NgMFqYL1+KKWQwkUCM87lviwC7Sehc0EM4jhlMBiaObor4nifaA520dR7t2SLN1YpgzTJiMLOKmEAUVBlrlamJIFhl6u3l/mTc9usDqcZdfsMBhsk4YhyaYK5U5KfW5qhUimxpjUBEJGi9SpNcQKNINEd4rRPJwYpH6QsrlDXG1SSPgMSukoQJC0eO/goy5WHOVnaj1YB63KFpLHE0tQPsb71Nr/52qs8dvwxliaPEjPPtc4Kre2Qp/fvA1YJkm2G/QGtfoV7Fh/maxe/yZOH7udU/QTzHznE63uv8OU/+Qq/8Ov/ihP7D/L0o9/HpJrF2EHuart2yztZZOAcWLOIP9pJtD1caaSOIj98glASBDKXAAoSI5ku6OxzeKLylW5CoJooNzjpIB4pUKoYa98SFIeNs5jqeCBCUzCpsBoQ7iQE5rA3ksxAFu30bdSXXNponXW9gzeTBGbaC6Wz3MYZ0MrBmbrT+Tm7T9g2FJ2hhQVqnitzgZzZOkRGgEz8eD+KSeazITCh6Y0E0ecuvnQ2A2NO+5KmCm0lnBqdusyyQRja/rlOuTHWCEKLhiCMQhb27qU5PcVIpTBKGGzfplwJqERNGpWQSCjiXovLt2/wB2e22UoWiXf6dNIeupQSyjrzpwR/d+8s21LS0poJIGSEZp0pcYqUhETvMIgTdApC3E+FZZrcJoi7tNhDrCEKBA8deIzLlYd5rHyAVpLSjyoEU48wU9vPxvY5fuXii3zy0R9kMnyK7dE2K+01Bt2QDy0uopKrlPQ2260E5Dx7Jqp8/dKzfPDILq2BRQAAIABJREFUA3xg4lGmP3OErzz7HC+/8CKr3QGTVcHsQoXwMshIIlKZja/WhGQmVWnuXxBImUuQfel1DmCt9NyNt92P+Nqm4jxjSLoNMeq+MxOuC2tajO0DD3znQJZUZeE2gywulwG3QgiCMLCZgwFEEGS0UmCzIftr32+nXeYipzPemnfk3tOQCU9YYQiIlCiT+M1UYNtveuiiEmmyXDtKpfmlJoSCznlIdrUP2I0g4A7/C5ERY98RwvXBj1REobgxx2kQzLPzl4clCt6cu9+8+cr/KK0JQ5mHNQYpij4Ydyt3iSX33i5FddBueTcXXx4WyYBGEBFoqJSrhGGNKIgokZD0tzh99QK/8+o11lWdfqcF8Q7lqqLUCBhcvMhStcRCKKlLSVdprseKBGjIWUZimo6OGOkInTZI0wYq2WIwKlNlmt5wkfZoCh1UqdePcWM4z345QxnoDt+mM3iRkB0a0Syivo+VF67RWxsSMEm9dJDJykGuvHCaeAChbCLDCs1anaVmmeGtP+b+uf1cXX6Z652LVMqKJ4+d4Mc/9UOUD5S5vrrCuctv0ups7q7b3fKuKL480Ji8GCBiALB1fjTAPf9jAGGGL7X9A7npjy/VtIcqNh64Be+eVFJpr25Pgijy+mQonamRXzfucNRaeVI9bZ9lcasnzZRjoMkH63aMrERcWpBlxiRNVZb0zDAp7ciN6bOrR1pTH+fj4GssfH2NKAKQMcKjfII1VpeZN3OdUioDLdqZKFh8772Hvp2gQttnZlJrcsGGUgqVKttNYUCisU1PU7bW1zn71lu89tJLbKytUi5XkbJKFASEasDO9m1eunCO33ntBu1wit7OKv3BOrqcEAQJydWrHKyVmQsDKkKwnmhWE4UmpCHnGIhpOlqiVAWVNkjTEmnSYhCXqelptgf76Ks6YWmGqHqUleE8h8JZAp2y3XuO4egtSmJIvTQHtb3c+NoF4p4gkvM0K4cppdNce/ks8VBQCiYhLDE/Mcls0IKNb3ByZg/nrj7LreENDkxP8sNPfZgf/+FPsHBqkbVOi/pchbAkCUKZJRjMAV7BQt8DeFZaPeabEoYBYRjmfmrCRqXKJPPZ3Ot8rrL940xMzJ6y+yafMJOMTCmVSd39fSTG/GlwyQuNJsm0I8OpqgBo3WYSDkyb5axz0x9vr/laMePPk0W9kt769q93Dtt5U/LxkzbbecalnFmi6ZPpkRRZ2FjrzJzXLe0+xf5mCJCUmRm0I/5uD2aS/QCXOyL748zADPHTbuy1CSbgtKPZu0va8Tf+R2ZvW48Cb4KMEEB4/XGO2H92ed+Rg93y3itSCCIhqQYRcapIREhCyFa7x8Ubt3nx3DLPnVvh7FZIJ1EInRAGuRSvP2J+zzzdzYDP/+k3uXXrJlNo5gX0tSCkQUyJgIiSrlCiTECAUB0aYQO4l6E4SirmKTFNVLmHetikmm7QVj0SDZFuINM5QgSVyiLDtT7b62t0+z2CoMpsZZ7Jao2vv7LCcFhHBHXCKKVZ7qKCiOmwRFUKkt4yg/4y5XLKqXtO8KFHnkDOTHNta4PtbsdKK3bLbnlHiznwCwcuxQPWXIonnc/jqKdpikoyX4LUHHYeAMnFYBa4mEN43LrHHZg+KbBYyrZFYDIRezHMPdBh2um6Nw4qikDDSO1yYaQ7gC3uEMVDWzipukpz22HvqYXIMWDHw7VlHOgURqHwHKtBKLCW714o5ttRZ7WPX+/AQ0HQ6g8Obt4MyFIeuLEZkQUF8y105pi8tbHBhTNnefv0abrDAYMUYhWwtrHN21du8fy5ZZ6/uM75nYh+qtDJAKQgGSXEo5io2aCzLvncF77IsNthTmgawFBL+76PKFHSFSIqSA1SdWmEDTT3M5AHEXqaklykVDpCLahTTdbYVAMkklBNIdUkkQiplBfpr7TZ3LzNMEmoRk1mq7PUohJffuEmUkyhZYlKaUi1NIQgYkJIKkIz7FwmTtZYmJvg8VMP88FHnyRYmGdUqxFVo8zWPR8jK+m2e87NlymFXBT5XBQdwr3Pd5BII50vrhdjniSKk+w0BHdZBGbfkgNWIywo7KUcdKucYFgfIbtui/kRxPhecQPgrd1i2/zm3dF2W1eRcPmffTDvOx0rf22P7SetPRv+sWfbMRt7tvTm49vV6cbVeyfaudZ2t7r3TnFfuT2brQPzTPPekmJsfL+L8r4jB3d92e+Wd2UxB3u2mCWhkKRaMEg0nf6IyzfXeO7MTb745gZv3tJQmWfYa1GWUC/XiHTEYKPL0qNPcOXakF/5rd/lzMXzLIiUB0NJCgyBAGiKkJKKIe0SBkMCHTNfW2DEISgtUgrniZgnZZYDtRL9ZJW2GlEOl2gG95MOFhE6oSInEOWA9Y3rrG/fJtGKRlTm8KMP8uVvXmFra4BWIOiAXKE2f4rNXpsDM4eZ0ZpksMLmaBkQfPieD3L4oYfoRhUGSuWJY3bX7W55Z4sPeLPl6CL3OHm+i0oT5FlcMzCgSRJFkqo8aZP2wEEOSHBSeidJczbR9jlaW3Bh24U57NzhXHSoHdNQ2LNQFLQYjJ0RBdxgAEAO3Nzhnv/xpIO5dYWTmucJkAyR0hZs3yUDuAbf1ntsFmwHhWVD5h5t63Xv0GL7XR/d9+NRibT/nXZSVaNRKUyQQZnCzZfRhDiS55NAF0mFfF2oNEWlCb12h5Xlm1y+dJkbt9c5d/0Gl5dv8cq5K3z59WW+dqbFhc0QyrMM2huoVJGmgu5Wj15XUTp6LxeuDPiXv/rrbG6vcVxqjgSCRGfv+xCYIESmA4TuEcohEYr52h66+jCyvIdyMIdkDhlMs78a0o1XaGvFZOkkFX0CNZpG6jR/30uWb55np7cDWjPVmGDx5L380Z9eYtBLM29idZugPKI0dZSN7g4LtT00B13ag+u04g2a1SYfufcjHHv0CbbDGqJUys3mtPU1KKxHIdBCOK3ZHQTbSJ8dUTBrxIBz6RMzx2eLQDWfWZFHx3JAXxZ8F5wJkrfArORcZAEM5JjkgNxp3Vs79rlu+zjibfquXB/Nc7R97p37xCkltF2m4Pa60ZyMj6PvB2HWsybz8bDkSefRlPLnGmLvEwFfeGHlB7h8E5ZkWcnKOOFxQg2KP3vX6aJm0GgDxi4335t3oPS1klYic2f9dyvvE5+D3fKeLvmeCYRkoTrJRgIXV69y4eYWF9ditkZNynumaIo+zUFCXSUcbEyiZJ1rqyFrHUF78ybJdot2r8MoHVKXEQK4ouGgGqF0n/X+RXrJDjONo0AfJU7STb9OGDQJwj0kcpI03WEjTmmGB1mkhpKS9eQ2aetNAj3LQNSpzNVpbeyws7ZNul+D0GzO7mUi/DrLV88wXWsyOyMRoovUF7ge7qWqKtRrxyDZoNffpC82mCrfy8cefJKvDgSlah09/mbdLbvlHSnZEZc5/6b2sClkA7WfdG6y4oCoPcjMAaqd9MpI2AW5M6UFozmyH9sDvuAyk/KJ4glsz11z8Lq2u/tchJGsfWOSSnufa78vZPJNdFxkJVtd3h9RqMc649p73LP95/jhmUR+v9Y+WHL9sWDbYidDELR9bsHeGiflRHi25AYo5mBKaY2QenzoXb/Mpbro6J3lP3DjkwGuwBIIrXPglbd7lMZIKRiNYvrdLlcvXuI//NpvML1/kVgIVG0fQ2YR1RnKs3XKqgNbOwy2+2xtLdMD9Px+1DCivbkMO112Bl20TpiQZQSam1pzOB0y0n1WOq8TRRPUS3VQCUocp5t+gWq0BOEcsSiTJC02E2iGh1nSJYZSkw7ehmSAWJhkIKaoztdZv7JC70gfNalJwpCdmUVmwg4Xzr7GqfsbVCoa2ERR4lpphhsXTnPf8SOk8TaJXmVYrTNTPsCnH3+af3rmAoMgREQRQRSTpiOU1oxGozxsqSN8WUZkG8gyI3w54FNKo5PEzb4u6oEyU5bUriIQluzqHFiaBalzE5e7kkzv/9pb8yoH/u4e4bRHZq3mmg0pzHrNwL9Nhjj2kG97AubbRBT2hwChbZIzQ8PH+2DI7HhlSZJYH6J8dABQ2vgbGMm7tE7DWisbKtbsxUwa6MQm+YvKjhPCmRxZ8yvTOGH6IwpjYT6FQWD3nembHUML/KVdKwhtAzM4LqK9sfkODGSsvA80B3d2ctdu+71ZpMgSjnU7LZ5//RUu3rpOHI1ozkfMTAgenIS/8T1P0BWC3zt9mrO3b/G3PvlxNs9chLhHqVSmJCOkFgyBFeCIkDz3xkv8yenfYmcYsm/qY1TD/UzUPsy5rcuMVIU0eoBhdIIudTbjMnvKk5TFLSCmM+qSSM3c4hFW1SQ1YFALuXD1GrdvrBAkKRGCB6pNHvrew3zhi6/w9pkdtJqhLOo0uM4jjVUIh4yiBvXaSWbKJ+n1t2jpDlURUH/gCb65tca3Lp95Zydgt+wWsiRMaZpmIRBzUKqVAYrZIaY9KZzv/GjArNEoZP9Ke6gbwGklfX7JpYNOSmhAdh6RQ4g8CZCTeJrDWIbOJtjcl4vccwmiziVpWVQYLTJc7gtCHeh1QAPhzCOM46gDSdmNBogDmaNnLkE1JlGuOLMsQS7ZE0Za65EVPAdRkZsSecDMABMjDTRjaX7WGmveZQCI1QrYDmpLYILA+T2YeTAaXQyk8DQtBSFovjZUqiwgsdqNQpuyPsVJwnA0pNPpsLm+yebaGv1eixSBDhXV6YCJuYCpWsI+vc3FZ79BS4CcmSHt9+mevUBy+QZB2qNUqRASgIa21mxrOKg1X331Wf7o7V+jWnmQucaT1EtHqZYf4ezWJZSeIC0/yTBYoqXrdNMqC6UGJZZBaLYG25TrDeozB9hUTWoI+o2IN0+fobO5TZCmNGTAgxMTPPLRI/zWb36NtbUIwRwVIZiR13lsYpPj9z/MdlJm1J6j35a0epu06dMIIx5/5m/w1H/+M0wdPUQ8ihkOh4yGQ5I4dvNv7P69fSBzTYNSijRJ3TXKBEL1CFmaZVmWUlhHVH8N+L4qBa2elaDbGt012RK2Woa0sLZz4KwNYfBIsictNyYveVVuZ3iaSrMMpTVZyiwLXBI4t76KbBuX/0Dk7xwTbldQiJxl1q/yyLQhuP67RXtr2WHNTAuWOY+nlnBl+zbzDRknWpDhG38f2e0Mdg49mYPdWzrXGAivr+adrFI310p7kYm0zjVuRruUvwtt3/5sQeT7RHNQlJyYf3dNNN47xbxMAik5tGeJn/6RzzCME1q9AStbO2z325y9tc5vn2mxqbcpVUKuXt/in7zy66xttimJOe796BOcPHSSGVlBKcW8UhAnPHHfvaTiJCNZIRYRgUq4svEczYlPUA4FJZEwUF2UHDFTESg5SRBM06NCWUrCqEKbHqtCcb+MCMsleknKSmvE5dUes6xRm4pQJ59m5/Nv8tVvnkGK/fzQ9ywi2CIKuiBjkiRGIUnDSebkYWo6RlHmZFRi7tQjzITld3gWdstucZFOwICNuzmxaf+1m31TjBpYCKHnawAy4HyXB+s7PmT3jH3IBHXZwy1gyb/PhXq5xM9TMNj45KZTXv2e+l0rF8Izc5A04Vjd4Q8UkhUWTDu8qjPw7gH9wkPdNUZ66BOOsZ67IfI0IobE3P2U80CgUhYU2Z9ELlkWjlChVAZyAg+8GOKUP8WATL+PtsrCZ0MUNGmS5s7aGZBVSUoSxwz7AzbXNtludZg9cpSwtEN1apPa5AS6XqY2UeGhH/1+bm93GGxH1MuzBJ02g9ffoCQXOf6JD3DPxB4qBKg0YbRym1/4d5/l5//bv4IKHmQUNFAiZDDaYLX1NpOTn6AcKiISBmmLIEypyxJKNAiYoUXIZDjLMKzQEtAWmmMyQlbK7AyGXNuKmVjZYTIcUq5HcP/HWP/1b/Af/+A5nvnBQzx4fApYphR2mZeaatwjKS+QyiZKS9LWOrq+jycqNZ597lVGG9uEpRJyOELp1EHPsYRiVkIss1C/Kk2tNsEStBzUCmFCZLpoUz7QVxpIi5vPSMjNnvTXmGtF/m9OYmUgiXKynaapZ7KTrxYpQEkb1SpVKeBhMq9uZQQF2s/R4dvpe5qCsWIECR5vLiQ8lEIWtF1mJFzf833s1+E9x5khCdv3grOyt//y3W5rMNodci2q2Xi+IEDalxf2HetrFwoCFG/ohNHkam2xbiZEEKSeGZRt7x0Dd8dQ3lHe8+TA05rulvdosZtKgERSiiLmJiZIlWammbBnaoL+aMjRxQVevnCO+4/dSzmIiAcJ25stvvDyGX720x9n6eAi81MTxP0h12+ucf78Cj/6g48wlDWQISkBIw3D9oDf+dXT/J2/9Rk2gbfaW9RkmcO1JrHq00suMh8dZWPYpyIbJDqg1e1xYq7OttasXrzCqAtTtQZNPeDVZ5/l6Y99hIfrdd46/hjLF97khbdjFg5M8OjMJEF9QE3uMJIBAxUQUyEKJpE6YFMNmJRVJqKQchC901OxW3aLk7QZaZ6J5Q8WyAI2gVgWJ9xJFtFZxtQgyHHI+Eva+6/B6ZlGQVsVOaau/DcpBUgDYDKQI4Q59MdU5Vo784kxoGNU+ErlZjpB0TY7CweaRwvBAYVMYyHyMJ7SHuhOeOoxEa/5BpilqXKx6r1hMOZCvqZEj5EuB7p9UiOw9hT+cBlUXhA/5omwPMm/eYDwhs5AE/K5t6jMzpcgEMKGlHWoSNhs9sZ+HrJkecII6QwG0pokSRGDzISm1x+Qak2vNyAoVSjXalSbTepTE9RnpinPzrF54yY6AZFIytUS9alZWstX6b7wJT4X3+bBBx8lVVXefOs8Vy+fR8kayDIxIbFWXL+6wze+dJ6f/7kfY1UpXtte5WhtgulokpFqM0yWmY+OstJvMx3N0o7bKJ1yaLrGVqK4feYC6Dp7Jur0129xc/kaj37wcR5u1PjGyQ9x+uqbLJwTVJpNTkzuIIMB9WAHKgk7wx7xKCBNy0itGVZ61EaC9s0VutttlMoSmaUiyyqenYMOPGax7EF4e0xgTPKUJ6EfI6V5SN40VR6B8NdKEaQbYmGuM4DYEGLncyAKc2/yjVhpv1kPApAi1ybowpqz/+RxOouwfdxfVOSCAHdN3mO7d4RHhhwJ1navG8JgNFp3fU5Bs1J0/LbvEI2Nmma3+xjp8Al4gTDbd6oZAC9RnRFom8/e/tda2DbbKGpgzbeyphsyZvzATHQr05TcjDMIbV3fDV5+z5OD8bKrLXiPFgFCm0NEEAWCMNBEQUAlimiqKlP1BhUZ0KxWiYIQpTSD4YgDS/t54oF7qNfKCAQDKVicmSQ4Irh0Y5mlg/vZ1IIztzc5f/Yc7XOvc+qJp6kFAeupZrpUpyw1SkiEiCkHe0l1SCTKeSp1TblSpoLgzTSltzZAdDWBEgxGQy6evUApkXzsL3+GDz92mOfa66xsdXnhTJ+9+zX7Tu1D0iAUQ8oyJBAhiRoSp5pIVqlKiKykZHf97pZ3thTDIHqJgPDxoHBSyXEAjjtgjZTLFHO9Uo5c2Pq0d2jl7wFfEyzzNtmwp7j94gCALyfNfvh2drY2BYF5oCeJF56pkFF3SCHRFqg46O8X5fXHSt7NOJg9bg/tPP54HqJQ5KTHmGWoPNSiGYtMyqktgDEgyZr7mMdZCa4HbrQBTubK/HdtNCWeqZcFg/n4Cu0IgwCp79ZzByTHzUaszbR2Sb2UVsgk01wordFJCmFEWCpRrlZpr9cIq1UqE03aW1toJZAyQMoSQobIfof1tS5fXr3J6VffRIYV+iPF7L4pfu3f/Tbf/8xf4uzqDjfefBW9vcaJhz5ATQakKSyWm5SDEC0SpChTChZJdEBZVtAqJQgFkSwRIricJrRvdalTIokTVrY3efO5l+mutfnRn/lr/MCH7+Hrv3+LMzdgsjZgekmy5959BDQoiRYlAuI0Jk1GqCCCZECFEp2tHfrdLmmceNJhbc1gitJwsxYMyBR2ss1a8a/FaAIMePYIp7nS7BV/HqWUpGMx+bN7jU9J3jbhnP3TPGBAZkrnoiyZ61WaPcMHtj6wt8TSPNDsBO3ArfPncavKJzoyQ8R3rEi8triiC9+Zte8Dfb9uu/fyW7MtUQw7O24mZJ+ktPceyAQfBTaG7+DsSLlvluU9BShqAAr7zLeUGWuI7+tl26bv3MHj5T1PDnbJwPujCEQhdbtZ9oHUSCkJdUA5KnHywMHCAaeBo0v7nE0lUC2XqC7MsGdmkjcuXqRESIji0rnzfPE//TH9K+f4mz/xl5FCUhOapFxFoRiSUJUhiH0oNaQWVRgOuygR02xMECvNrVGbNJbMhCFpr8vV5SvcXl+nt97j3u99iplGzP75OstobrVSzsQBi0cmkfV5AlayvgjBiIRBOqIuG1SDMoEIPBCzW3bLO1ekMGAVDMjPPrqD1T+HfEm3O8M9CTPFqDnZz/bkz4FvJiUrSszdY80fZ/Lk9r8BQlZal9+UEQlpD1z/0DSHvMjrF2isr7P5S48BBbCHrPDqsfbYd1zrNAu+Y7MDC3gACFuHMIC/iOFzB8GxePg4wGijp2jt9TcHHwURsT+2OgcxpmYv8ooH1vKJ8gCII2G2A+QdykmFP3Z+GEuVpnlkNhcRZzQcoYcjktGIZDhk0O2gEUSliHg0zNooA0Cgkph6OSKJU27dvMWF8+cplUpMz83RnH2cL33xK+jpWc5cX+PyC8+xZ6bJ45/5SwgENSlJKw1SoUjIhDOCCZQe0ohK9ActwlJAOawySFNuDVuokWSqFLC6sszG+iqXr16jtdLikU9+HwvNEbOTZTpKc/Zmn4lWn08dmCBo7CEUPapBCJEkkoo0yMb6+a8/y+b6BvFgRJomhag62b9etuMc7NscH1oX58GbfzMt7idHZEWB1OJInNknRsLua4rM90ZYkJq9lf2l0C7DMdI+2PxtBAuYNS/GTri7kcyC1NwupeIlhfWZt3HsN1N8IqW8cR2vy7TbRjIS4NXqrrUaFOy7y9u99pkFoUZO/gsvNAF+MAJDCCxhEs7x2rwXNBSUhTLX0pl3cFE4UxgF2xbz/rnzmjvLe54c7Jb3Tynw+7EXibWLlNJea18SxhYQF7dDa00QBjx4/BiJ0ixowejsaW68+CxBbZKXWm0+OrePmUByI1YMgUUZEYgmQxQVWUZqyQ4tEqGZL08xVDEbV94kqpc5XJlmuL3Kq69eYyRiNgcDPv/Wy0yOoBKmHDrYpFet8MKlKicvrLL44P0I0QJiJENKskEkBUrUqIVNArm7FXfLu6QIgSfsv4OymgPbnatOhV8AifhRjjJnYkEONoQuHsxCkCUTdZFZjHw8O4yzKCEqVcWkYcZcwGRQFk6mnjVNZ1GQrFYyP4i9Do7lkHUf87PbHtLmcNVjAFoILwuqASzGcdmXirqoSRk4kzlg0UVQkttBZ34S/iFuAMc4ALwTdFnthHm853BsyIffPk3umAkuAd0YCLtDG+G3wCMnto94AJPcH8Tcq8hUEPmXzgFXoVVKmmS24nFfksSjvA9hVpdKafWzzNnmGWmawPoaF159idL0DL/+r/8VxAnpQCEfeojXOx2enhEsBAHn0pRJJGVZRooSI60ok2XGbes1amGVStSgPeqzduVNqlMNjlabXDn/GhudFqoEmyrms89/mXo7phR1mZ1vsNaN+Y8vb/HwkRUOPPYoQi5TKUNYqjEcCba2N9npbPHP/vE/Z2113Tr9Gw2RXQNm4dmlpQqEtEBGhUBpRYC0vxmTObdWHMs1/ggG6BrJvSXJQljtmAGj2Z7SBaddk/XctEW6pWEZhC8QsMS3sDWL7wC73jAher06MaY++SPysTFhV6WXa8OsRwARuLXs9co+0+WUuOMtZ8fKagPNgOYNcLzD7Qnfp8JoPn2hgO1v8R/vscKZ4vmtGtvg1lcif9fqMQmNJQA60+5Ig6ekuMtD7152EclueVcWtymKm9ZXHt5Na2S3VC4VCYOQQGqGSUIQlCiVSlQqESf3HgIgQTMvBaEImBCadS2paE1ba9J0SC+aoiZDpgLB7d4an/vv/xFHPvE0QaPJ5tY2m70W0/cfoX12wGNJyMXNFltUiZMq7W3JyrlN/pfXXuIf/6PHmJg8iGaUH8QNqqV9gLxrP3bLbnmnShDI3JEvj3iTn9QOwGTXCZGprONE2c8+sg6k+WS3o2cbLAgDkQF+e1V2wGXaAXNAOttaIQRBGNhnixw9ZMAl81cyUjTzZJX7KFi/AmHA8ZjU0ENTmS20+cHZ8cogIE1Sc5ntk8iSKxT8MpRpiCetM4e4zVKbZnWlaeawK811Rltzl0Pcl3NakoQH2IRwYRdte8ZMLqR7P2YCTOEqF9IOoNMcuCcbO3R/TpyWxTXaSKGtSQO5eYOxD9c6s5EODHlMbZ6IzD8jczBxzqqaIFCZvweQpAkugawmjQXxcES/P0Av36Q8vUCzXkNGiul6nWMLS2g0sYalQDArBAhJR2tKKFpao1SfQWUvc2FIg4SbK1f57b/5v3L00x9jc2eHzu0NxESVqfuOkFyL6X3pC2zPnKAyc4C0O0F7U7K9GvAPfumP+OX/4yMofZw07ZJqydlz1/jFX/g3nH7zLP3+0EYC0zrrbxiGGYHSmW9KQapsyKMvavcl2DoLOZztW2FDiZoLDEB1pj3ZnGSm82NkLwfcOk+OptDInFi73CR+u7J5TpKEIAhdQsT8e2leAmZpeGjXCRQ8gKs1aepM02w3xjaBdt3L8xB4BLWgssrN2YzWJa8gM/FxbMZJ+x2puSu6MITAEBFLLLTVuhiyYMdrvJpx9YXXJ8hCs5roXxIf54y1URfvNdogu++9yk1UJpGqMa3Ity+75GC3/IUo3W6PQIbMzS4yMTPHnhjWSgqJoKIBLRhImAdSIZiihA5DAq2JRMza2iX+zt/7hwTViGRthVvbW0RRman6FLobcPzRg1y5dJ7FvXtYnGkyKjc4k4SMFj/A6mcv828eR1MmAAAgAElEQVR//1v85Kd+mAN7j/pyi3dsPHbLbvl2JY0TdOAAZUFDZ6W1LpZ2KL1kPAagBu6QFlJYSSO4gynbdgKJS6g2GqXOHjqv1ACI3H8xBz7FQzdrkyYIgqze3N5XKW1DdToJm+kXBKEXZtVENcm3pcodRF2egjHw6lUkhUBLJ7kFi5k9CWP2HwNLjNNz5mfgEiAaCb7C5RUw9v9CAF5yKiN51jrvu5d4KXMkN410Usw70EpBuzEudBHWdMSMeSDHBBo6B0ke+Moul8VHCYE2IXKlJAj8KrSrK02LgNi0I01RSQK5FDtNU6Iowjjupkojk5gwDKjXmjTrTQIRMtOYYbKfshoppIZJDbEURMCMBo1kWoakss5hDRE9nn3hG/yzf/mvKdUrxLeuszUcUalOEFKlLOrseXiC0k3F4uF5eqvLxHMVNg/u49rBGu0/XOXv/9Jv8MIX/oS410FoSOKEnZ02g36fUZLYYdI6i2UfhkHuNG5Ad1oIg+th95wYOL8CY75n1qnv92GjRBnNgwgQIrXzZ52gKZ5GVkOgNEqlBGFAqpUN2VkoIpvrMAyzOdbZPZmAwM97MebcXFwahIEkSVOrbSo8ADA5DbTA7ge/ZNoQQ/6LvjjZ/jSkC2xEMu3IR/aakXbc07GkgU7uke9P8zLyt4K91DNlNIKI4mZwjsN5f+yeNm0jez8WzKYwvFpZYYwhflbD5JN9NJnJl/lKFwjMdyrvCXLgM+ZdKetfvPL/ZsaLEjFNtVKmVq+x99B+Hn3scR4qB2y2+kxUSggJA6CrBEOdRfLrkTBBilB9zl17i9/90u/S7yXMzk3yiSee5uzNa+z0uoQBDIZbhMNJqO7n7Qur3K62OH5wL08fXSIkRh1Z4ic++cPsmZvP2uZJAnbLbnm3FRP/H3CoVuer1fj2CCcMLJz0uTRf5VlOHRbNpWu56C3IJYyBsWfOpXtBIFBotHaHdLF+IzH1a81/CqQF4zLMpP/mOT7w11oTSGe8YO63eD8HCRqdBUkYC7uamUC5eOmFzMOiGF0lP77HhKbCAmof4vgmBzpvp3uFeXbQ3pyYp7ghunsIb+PQKkTg5gc3juP90zau5Z1vKdPfTNPhwlfKQHpaIp3X4cWP98ii0fqoNC0ArHHTLdNvpVIL+rTWpGmCAJLEOOpmfVFKMRoMGGyvMTc7zdz+AyRqxG/+0i9y6L4HqKuYT3z0+5DNJj0hidAEArRKmBEKrdp86ZUv84WvfpXhMGFyus7O1ZvMHT5Co9FAC0Xa32JHKfZMHOPFN64ykQ64v7nOgekytYbgzP55vv75z5MOB/RaHZLRCJWqLEqTlFmkIRtqNAN1o9HIzS3Z+pPSmMkU58hoYwyIRFA0kyvMvwsM4IubMwdxVQDRZi1kSdJyBZMu+tjYB5rN7QHmURwX1kgQmDwFgWcuCDIInK9CAcga7VLGGl1IV134R+Rtzeg6dwB0q+nMiRGCPLCIROMygttLhX+jtx/RhXETYP0H/PkzvyrlreV8r0rpcieMF+MbNEZxMqCPJvDnBh/QG4LjDcpdivEVyfbwnb5Kf1Z5T5ADv2jt3lb//zlwjg/a3erV3+G33fJuLHaT55vsiUce5PChAxw4cIBGICnVypRyM4WqUnTihJ3ugMlqmedef5v7Ds6zdusib775CjcvdanUJ5neO8GZK2fpJiNCIZmQkgNRQiBTuv2UfXsXEaMWqxtr9NWI+cU97FmaolmvERhzhV2Cu1vexUUI59cj85CIvjmRs3hwIf/GHSRNBePSfUMQzGvcWLFYUwUjFdSZ34NNAuTuzPIcSE96mNtsh1FgpbGuL1gNQpa7SeZSdqfyNwDMAMzMfEmiE9MmZfsrA5mBf+H6n/XZ9VDkiEMI4bK3aveb4xEiN+FwtvPORMfMgKvXkKiCdBBnIjXuw6F1Pr7WBt1Ide30uEEil0AbUaphgDkI9KWwBZOiQh3mOz3WRjt82TUGyFrzFG/+zVgZQKV1bmLkNxi7HkXg5g3IzFvCiFI5Ik1jNtdusb6yjBoOuH7uLCJJuPbm6xy69wSzi/vRMuTKlavMzi0St68zEQ65ePkSt651qTQmmJ5v0Ov0EUGKjgfMlDT1EHaSEi2dMlGv0ZQBq5ubiHQEU5PM72tyJh2BzhJljUZxruHRmaYqX482JKbwtDqWvGbrMxXZWBcyc3uEFkEWK99Iia0YPPvHhRHN9ql1bM7nypBTs0J0Ps5ZZC4vUlnuQO6vL5ETYTv+noRbCldZUWB+Z3hh95/M3CcwZnHyTu2l3zf7fQ5+nUmTudaP+uPjN13059EY9pC1XZr3gv8cMmKhsIkLjWar+A7ICY6HTrOhGaMA3vvU75J7dQpvgJy/hTBzc5d3rv+2EKYOr3IrKAFEyp9Z3tXkYNzz/Nv9/v9FmzC+6HZh2/uvCDLV7ZGDBzm0tEStWiWQklIgrH1xKAWB1shyRC0I2DfRpFmpkk7OMT+9j+nKbTaCLrVqnb4aEY/6lIOIMAqoBhH9botISqYnpkhT6Pc6dPox90xM0V6Y3yUEu+U9VcxqVWPvWCHMoagcgIMMJIAFtkX1dvFotl8L3KEnM4dllWNTY5YOHqA2pCQHVDLIjuDUiS8RQvtnKiDyTM3OnMFI7DOQm9vuawomFga4ZVJUgZ9WaFzS6gP+AorN+52ZY5mvcumsdNFIkMKLQiLQ3+YcKhIQAyj9vo5f6xEO79+ClsNePyb88sa5WK+LFuVHVBm/xjhIGuJiK/VIhvYm1Tc5MeTAb68wWMnU55EuQzZB2/BQyWjEzvoqWmc+HaQpKolJk5T15etcunCe2YVFZFTh+o1l6s0pOq1lqjKhVs7CpYZCEoYRM4t1+p0uiBFBEFAKJKVkSBxvEI8GTBycZdAb0NruEPd7CCkplcq02l2SOCZNU+cwr/K2atd2M84+uC1Op9NGOXMajdb+5Ocy6IK2KR8rI932yBjk8fHtOhCOPOBIgyHXQuDyEtxFk5clJszbRS5gyOdR5WZixtcHD8j6S0fn9bl/iuTSg8puDfn3eqRb4PZw4Vn5+Amvz3fKhoVtoyWrdjwzyYT1YRoj/wVzQ3INDY7AFHuQP26MLPudzt4FphOOQBcuG18v3t7JZQ35XDrfp++mvEvJgd9Zo3pxzNZ9vrsK9W71ZWX8Wl38V4vi8N+l6l2I994rQgjCMGSi0Sh+bz5IgdSSsFyiVorQSvPEqWNIIdg/N0dZBFw9f5YraQJDTblZhuGICBAyoK9LdLY7zM1XiUddwlqJMJhAJ5L5xhS3Kw2MLGHXLG63vPtLdrgYQKM1hGGQC5SFA2fCmRyI/HpzmBqw5ta7u04ah1gy9bkARCAyMwStCELJaJBkSc/I7eYF1m9AaGdna3MyKDIzhPw74x8BubmLMakwj9aaJNWuPToDCsZuO83t4g0qtYCVnDAUZErCSR5z5OfjWymkBXcWeHn2z77/qQE5zhnYImIHijxJvh95ZtycxLbPImsDYnTxqoIE1YH2LLyrB9AMGbISySLoRGfhLf3B8deCbYv53mutf48DfQKv6R6r1MX7hP85A6X9bpd+u43piRDGyVMz6vfYXF+jUvl/2HvTYM2O877v133Ou999mXtnXzELBgABggBIihJFbaRoKdqlpMRyKorkyK5UKmWlSs7iKueLKnHZiauyqEqOl5IURZZFS5RFWqJIUyIWASABAiDWwWA23Jm77/ddzznd+dDree+AwoekAMj3qZq5977vOX26n+4+/X/2OrVanSwvyLKcXnePosh44NIZ5udn6XYyBu2M1uQo+fYutYqgEBU6uYSBopbssNvtk7ROUEkb5J1l1u+sUBsbRSHodrrkWage7OdLqbIMFgli5nvLR7unHBANIFeX59HDm4ineohN0XUh+Dbm99CcWYDstN5SSh/D4oU/+zmY+Ji4PeHvt+lDnYAx9OwQJxB64uNsor47WcFbKbB7yWywknA5LPCGNRA46AB32doW8SuSru3rAhOPUKBRKG2L0jkMannhAunD68Ls+DhoOnqIfURISerAPNG9Ihp8/BYxr2HtPx9GFl6wiz+07+53Ix68T4UDR2YIRVGQ5xkgSJMKSRzJRHlhl5eU+WS4PZzE6O/W0ZXhO6GH2H2A6z6wFG/Kux6hQniTurGehqsG/R6b6yvIrGB7bYtB0WVmYopmvWZ8pFWFTlaQ64K1lVvUJw6RVZvkWpP3c7qdPmmSlPxCD+iA3q/kDxSLeQ2AsWDFRAT4kzQR7n0pylo6mwNRWq1i/GaGAIidi5Dzo65UElrjNdq7fYpCkeeKIlchk48OLhZORpFSIFPzvSmuZl2MFBS50flLGRQ/JqtLYoQDl+JTgxIaMC5ELkWiUhrl4KoVSBLpgv8s0HW1F7QTgfAvFud+4Hlrfyqn5NKhcnHpxNIuQHkYRBvgoggpUN2clSHW3cB23IO7U9nlo5yvPTThLALW8hIJKk6YCUIAUW80UgcrQTAH4cFxLDwIoUv8c7UShBCIBO8uJYRLvZtY7bYiHwysS5oLbjbXJYmkSDSDgaLX65GmKc1m0/Abhc5zpNYkgOhnZHsD2qub1NIqY60GqUzJ+oK+kkyMSOYSwdZOl7zSpEPC7tYuOq2xs7lJluUmqNzyXwKFDUb2wpEHdoIiN32N/fM9UI/mTWltgpfj6RRBCIpdXaQ0MSYOhEuXJjcCiFpr798fW25iaO2sCk45EImtFtQGpYGUwe2mKEyCAVeHyM1DyU3R7ue4UnlwHx9yS4rWlOtveX3jhVYj1Ac+Kb+GxT4+x28nPyPCZjXSoVhZGEckjFgLjPJbOd6Bpnifi90gGrcR/pSJpxFRkL+fK+H3henXfsEnHnssePkEBhFbCpdY4F0C2fepcOBERDOIoij4gy//PxR5wSce+UHmZ+cBqFZr9kWKv1YLXWbYXdu/ywsvfBr9HeUcNo1H2pt3bv2A3r/0V82Ye6lAeAHUGmPMHz3HjWu3GW9pGtMJhRrQ3R1QzTUybXF8tA5acd8Dj3F9fYudvTaHJqbYaXf4mc/8CPVazWoQD9bMAb3PyWlgMUdz4pdsOMQ9QBDCBFhq77UctN9a24w/hoxrggsojYC5vU8IkImk2apy+WMn2FzbZXlhm73NPtVGwu5Gn3xQkKYhu5AqjB+3jAR6kTjrgSRJUpJEklQMSJJSkKSCbFDQkII8Uz7TZ1GYWgpobEyCyZAj0CE9uMCCPaMNdMCmFPDntY0GDMSB1cEbQXs1YVEM3Uf8nnInkNP4OaBceMaGas46uicIHHr4WxEHMLsp1x5gxkKHhtLfZQDvX5UhDoFhCtl0EMKARdeGcOe8uVPa9aDCrVYDq0sWKiwIFokkTRN/jdPkag1FllEURnPtBAqZJsaYlJtYAFcgr723a+5XBWki2e3kNLZ7pLpgalTTPFRBDkaQ/QH5ICOhyrHRUdo6ozuoovsKnQ+AhDSt8+LXn6S9vcug1y/xLXY9MQHibk4D39xYjaY+mlcH5j0otaxzmy3yRfPucxqrvAqSgEaXCml5vtrq2R6wuwnWJjNO4oKEIx5rjJBiALJE2ZS8CFv12qZDFV67XV4dpXWFEf7cWjHt2LigSHARaJ8e1QvEWnvlgcvS5NZtzFwnwAchobyvBNKCfyMY+LgQ24SrLeBGEnihA+MsL9E6+Ej6Drn1jF0HAoYV3ZHwUGiXOGFYPMLPpxMe/Lhtf5QyKXG1CAkkEhHm8N1g1/epcFCmNE1p532efP5xvvHqt/iln/zbnD93wWpQgvTo6C6svAvFr813e+cwU98dkw/og0taa8ZGm5w7c5ynH89I0oSpkVnmJg7Ta++xs7PJxNg4Parcf+4M6ytL7G3sMD0+yYfPneGeM2eoV2sHQsEBfWDIr1QhEEkCLuMHwgc4msPbnH3mEA3p95wG3eu7hAHbApehw1AiXdpRRaE1SI0eFGysd5mTkmR6hDGlQe6wtdYNWkfbbpKaugdSmkrq/b7V+muBxADHJDVWApGATKwWT0iqVYmQJsWkEEYwGAwyYIDEuFFluSbREpErlHYZXAQoRe6KlxE0fE6r7zS4Ps955PvsXCES4dwCPAayLDfAXhU2I1ASdH0l5b1rEP9oT0opZJJ4MKVtH9x1sZDgJ4xwjgoL7twjRNzXIStH7P9P9FnQ3JaQ6H4LrpW6hKvzoE1QdGxl1SrKquOer6K1FwFMJ7EolzI16pMaKCpVwaAoTHpOLVHCgDCtCmSSkMiEVkMz1lTsdU39gURX2F5dYmpsgtZEA5FU2JWCphYM9ID23h5rq+us3LnNytIia0urZIOBB6hCGMcRhEC7NLDaBB1rbDpae11h95GJT3ApcyOlJI4PlIRTvx/dGvDWlgA2Y6Hh3ZKZcy922/Se+GcGZbdz0XOpgYNAHFu1SnEy0cJxWZyEHZMDvGpo/cTA2hUwy3PtB66G1pgm6M+NkBQA+7CmXQRNsx1teWd5WcS6MGrfVnBJdF4tUkhIysH7cVB5HDguEFYICFmkwpDjTW8FYwRChCioeJ3F+7M0zxFUfbfz/4EQDqRI+P5HP0PeL/jTr/87fv13/jcee+Dj/MyP/hzVas1e5RhfDgjxUp5nZCy/mhdLoXMSWfGTIny1QYUUTrIrB1eFRRc0Lgf0/qV3mp14+8cmbTAbOy9y6o0WJ07fw8T0DLmoUK3WWV9foi4Fs5MtctHnyPg8p06d5+b1f889J05wz/lLHD08T6NW8wf+wRI5oA8CKa1JCBVRVWFN0sJo0pwPv8BkwPCFwVwDwloNLBKV9r3pc+Y4N5RC2XyJTqunUIWg38u4c22D1kSNpJYyOjdGfazOwhvrVoMpkFHgsUCQpgmFKtDapk9MJUk1ZWJihFqlaoC/hEarzuj4CNubbZJE0+tlDPomN76QsL2xR7fbAw2JNClRlZRGC20FnSy3fuOIqA/WoiICH2It4PDm9xpxIdBF5IPuhCenwVXl+gfCMSsSstxPKQRFobxGXFowXbgKvARFJlbr68Cnc5dwJ6WvqGr7igNP2vDBgfN9AMqUuQ6jlVFwKGXNrn8lhiFZnplz2OXoj4GbAY7W1UjIKM7ECBd5Xhig71GwsNpex/TCADtlXLMKm1cfDdVKSrNRY21zj0LB9NQkA1GhoWFybJSxVkK9AQUFnc1NXr62wMz0LDdvLbG8vMT2xjrdvT2yLENb8K+cZtpr/IXXqDt/8ZiGBb34LHLfORBo/O0NXhGOkb4RHe73jxmK0XRa5ggguz1v5lIg/b3uM2lcDH0/St331Z7N71FMDw6XG4E1gHirRtBGQDf4N7Y8DIPjKCuPVsPsI1pdto4AeOuM3Q8exwlBQrLPauPHEkwzCARFZK1zD/N7xs+Ti0GwfEfb6un7BbNYQPDGRbCpbjUmtkFYoTq6PsKcZateEDyc0KxU/J4M6+ndQJEPhHAghODw7BG+99HvJxEJn//S79Lv9ekVbX70+3+SQ9NzViOiSYbiBIKmyZEmV22UHqB1gdI5SuVGm0MdKVtA4jVASCetaWt2Vn7RVCtVu1kOgN8HmYanzmkUjMtEQrVaY3x8ihOnz7HR22HQHyA1tEYnmZqcYKe3w/l7LjA5Mc0jj36MVmuUqekZmo2G1+iY5xwskgN6/5MXlt2pSnAl8EjDHkr50GFpfogSQPCfeyRowaAqB/SBOdSKTLN+c4vuVo2RyRqN0RpC1jhycZqlNzZAadKqRCaCPNPoAmQlJdUCtEQmkkqaUq/VmZ6a5j/7hb/JoN+mn3UoVB9NRq/XZ+nOHV559Ra7nb45UPOC3VSSpCkqVyQVSVqpIoURDjp7PVxKRyGiHOg6VhVFgElgQxhcUSrHN6fZM21piDMpmnb2vSqMq8Mwu53WEI0p8iSC77bSyhStK90kgnVCKN9/p812vtUOfHp//SiI3JBx13EB5SBCeshYyRIJFgEMxZGBTsOtcHaOWJNqLndrybqpSAuUlUJZFw6tFEq4oHjtx+n6YorKmVSnQshSDnmn3c2znL4NZq/VG8xWawiZkJBQbVTodHvkAGnK+toaS8urrKxusd0ZsLW5Rbu9Sz7IhtxgBMrGsTh3j0g+C1yIJDcn1Hkelaxy2vOoHJ8RLR5/XVlg1zoCr0Pkpq1s9YnmzGXpEa62hQXDOlIExO0R+unXlN8jrmcuNgEPpN1aDcHF5ZVSWvOWKaXxE5IFiLtcHwvaYIUZLxgPC/Qxf+w7UEVry/XTzoWUwb0H3wdRnoeoPdcPU2lZO8xfmp/STIWt5feKHrretL3/M//MIcXCd6L3qXCwv+u1ao1zJ8+TZzmf/+Lvcn3hGqu7S1SrNb7nkU9x8ujpcgtalRaMW3yKvhUMeijdR6kMtKBAAT2UKlC6CjqlmtbsJJpl3u/3WFlbZm1zhXOnLlBJK6WX+gH99SEXaJQICaQ0my3OX7jI69ffQGcZ9UaL8YlDzM0fYVYojh87RaPR5MKFSzanuixpYQ7WyAF94ChSYXvFZHR4Ow2yucClZXSuKQY4yMQdhO5QtpdbrafXgtn9ppQGBd2tHnkvI5HQHK2hNIxMNxg91KS93jUaUymRiQYpSOsVCg1CJSZNca3G/PwcP/TpH+Jv/PBnGWS79Ps7dHu7dDp7IOHWjTcYG5/mjeu3WFleZ2d9F6SpcaC0otmqMjLWIkkTOnsDer0MldvgZi2Dm7cq88Yf4kLYGDgRs9Ke3oHNTmgqvSJE6cu7TQwBegSg4N45QQsf836/4iz+GWFVd2Tu+ywWJgJY3d9N93w/lEjYcEg0uCs5i8DQ2LXTdgYhArRdWLbOtNeQg6acEcZNibOi6KKgKBSVVHofe3OvaSPLC9zk5UVhBAMp0blgkBfs7nTItwqyvGDlziobWzvs7XbQCHq9HoN+37syaW0rXFtAWdLwRhWuHZCLLQslwSDi4bCLlv9eg9bOskNpbQWQPQSqY4osAM6aFRBygPSO/zrmuVa+Xec+5OZKiiAwOhwVq89LAijhMy+g+KeGmBPcGiKsjTCMKJOaGy8Rn/x1Q94l2vXFtRnFz4iAHfcjfM8Ru8Zc3IbeD9CHhLXhXV2aliF++LFEFgLzoMClYauEvy5eECKIZneVgIbofSYcxFKbZvi3JEkYGx3n4pnLvPDq8ywtL/HPfu/X6XY7/MQP/Sxzs/N+Ekx5aVla2IXOKGiTCImmgqAgSQoETeN7WGyQ64LOQKKKOrMjh8lVRioqgGZ5ZZFnn3+CN6+/wS/9p/815Sl+p2k/oA8qSVtRMUkkzWaDixcusdfbpdPpMDk2yfzsEY4dOcXs7BzS+UxG2rXYB/CADuiDSlJgtNKAy6Wu7KHjDqVQmIwS0DC51E3WkPjAFMLUKXD6QCnN30URzry8lzPo5OR9BULT2R0wfXKMIsvJ2jlFYdqv1qtUminZQCFEgpAJY+MTfPS7Psbf+Tu/TEpKmmgatYTR5giDEZBpyszkCKfOPsAff+2r7D31LTZWt2mO1NnNMqSEickms/MTKCVYyrZMIGRhQYR0YMIIAFKYzEgeHNiTxwlM3vfYg2yC8GVBhT/L7U89dKaUAjodkImBmyDy+VYWXIcJ8UBMKVMY0kwSIpEekGjfsJvfMsBxAMNZ1XVhNOHSAa5IK+kEBJcRVodmI9lHeJcjP1Id0szGb8+gxY5GLdwYrUVGhQxHHhZFWt6SBtnPle231hRKk2U5/f6A/mBAvdenXWjaO7vstfdYX99ka2MbXSh22126nR4CE2jt4kQMn5XxNPBxD2WLDIJQtRvjQx5rgcvChAxgToRrlBW0YkEsYhYS6wrj74vnJFRpFjFvLbmUvrGrkXNTIdr7TsATvl/CPy+xE6+ti0wsAEnKz3PT5LNTOTDtNPZertBD94T16N1sggbDCMxRzYX4PmWtVViBSHgGDa236Llu/uLicjHpaD5cfIUeeq7j93C8TjwP0Rb0/XIuQrEwE+4MgoMOw/efBX7cRch5B3ofCAfDQsCwgFCO1j52+Di/9qv/iF/8736Smzc69Lbb/Obv/ga33r7GP/iVf0ilUkHrYh9uVyj67JECWudAhmCAoIsQowgkuRxDqJyb61dY3trkk/d8mk7WYaZ1mCzP+MrX/i1PP/s4x46eYWJsEk28AAD7kjpwH/nrQdHxQqVS5ejR48zNH2Z7e5uJiUmajaYtsBSyJ5RMggeCwQF9AClkvqB0GDkwUljNt7QarJJWUml8Sh77WQl8iFCHIE0FQiQm0FfaoGUBWgiyrAAku+tdVJZz4bF5Ntdysq0+M4dH2FrtsLfZJ61WaIykICWVSg2Vaer1Bvdevpe/99/+qu3/gCQBVfRBFtSqYwiZkNbPQLLNyftOs9XfY3xslEzmPPOnL1JNE6amRkiArY091pe3kQIyrX02Hf+e11ZYsC6orjCD8JYDk4UJK0CZW4IrhDlDrGIhqpbsMrB4/qoyyHB/ycgtAq1N0CgBsMWAxZ2vMWiO0YR/hkUnboyxQlqUI6g9sHZjAW0ArbANxSYBYdaQGloXgiDYGPehcqpO73IkDBT0FhH3IwpMDv0I/XNA2Lt9CJcStPB9lpgYh7wo2N1ts/D2IreXVhgZGWHx7Tv0+z3yPDcCiBD0+gMK66aktCppnrUOmXzKLNaRX7oLLjVj9pp2Fdy7wKQL9tYM21gA6WYwJX95O+9CCoQKvPcaZ7duEpOmc5/Q5GccD2BNbIJbq1HMA4JYdvFLhxBDENICqzBv0aJy69TFv+AsDFG2n+GT1FmDYkuCm+4YfwUB0y56EY8x8CMWboJoHz9w6HzX0T7C7GctnAAS72sRN4HLeOTbsGBdiPAv5mVRKK9gKQXpD1WsdvPrM8mpu7sOCSeZvwto8j4QDsrktP6FyhEIBnkPIRKqadXm7IV6rc5v/eMv8rlf+X4W3lxk0Onw+BN/wt9avcG/+Md/YA4cbSRmhaZHxp1ik/RumT8AACAASURBVHnZpKBDp3iNVG/bIlZNpEiBAsEkiRxlbvI0vUHGk8/+K77vE/85Cs2v//N/yGuvv05zZIZTpy5SrVSHXoj7g3MO6K8PSSkZGRlBaxgfm4g0oPCudtoBHdAHhiL1rhRom2pTQCjWpTRKQmLfe4m3LITbS2U9hMt/boqSOSQlEkFjpEq1XgGtmT48Smevz/LCtgmMTgGhuf7CMuc/MsPGzTZ5t2B2vsHEbJP1t7v0OgOaE010oqg0m/zof/yz/OIv/xdoUUXpNruDb9IQAxKRIpIxBAXLKzc5dPQxJsdO8sDZglGqvJg/yx998XkqtQoPfuQ0Wxtd9vqavV7O7m7HZiIxkowgWEWUKDxOdUwKvvoSrTRJYvlpj+zYR1sXyoLLIeWCjAvL2WtLijP3WaSRjrSz7rsYbMQgdTguZFj5bL6z2mUL8IaVdXGmJgfSQaNtsLMBNCHotASnhsC81ja9rZQIhU2NGTTtcQfdb4nLMTsEEn2mKKJ89jqMyVkLQo8EKEWhTS2C7Syj2+kiKxUkkA0ym4/eAjClyWzqWylCdhnfD69Zjplq9krhrC1SooVJx+snRwW+apvNKNxtmts/TUGEtHIOMpFBcel5bK+NAfewpWJIsz0s3MRUxjuOl6E9x3cTpOyAbJwGGe+SV1akCS9XOu3/XbA60SWRkCH9M+PrkiTx8ShFkdsAdvOdS2Jk9s47ZArC7EdnITPCeRSHgMm+pqxgKAiB2G6Jatt+CCQOvHN2Rtfp+NHGTbks9NgOlvvn73MuZrrEN4dVnMD2V9FffcX/r+Q0GmFx5kVOu7vL8voCC8vX+cLjv0unt0dWZGT5AKULFGaT/trf/xyXLh+mURPIfp/e1iaD3AaN2Se8kW3w5d4CXdECJP3sVWrcoirugFhGsYpSr9HtPoFS2+zqjLV0mtXmaTZlwhee/GfcXHiLa9dvsbK+xenT9/BzP/XzAOGlVR6S/e9uctsBfRApCAKyFEsQTMJlrcKBO9EBfZApqg1kBAMdDkpvzhYBDphjS3hXG/f2829B4ZMSmTskVKoJlapkfLrBiTPTXHzgMBceOsLZR48hEsnUsTEm55qMTzeYnB7h8Nw0v/b3f5rp+SaNVJIOFBWtGDlUpT5So5FUaTSb/NCv/C0+/LmfJUtaCDTd4mUqxVWkeBstVtAsIsQVRkbeBN1hS2uW68fYHj3FxOlTfPqnPsLRM7NsbeX0i4Sbb63w9tUlM0aRmINaRMe0xKZTdZmdXKYdYd3iDRecS4CxEETvkcBCx3E8Wym/Rxy4cC5aIUhSDbm1RO1Ezcuhd5RvDwNsQoyUQVseVBLAnlImG5DtUJh9qwWX0gRxxyA5Xj/GqiBIkoQkTQP4B9u+tRoM+UQ4MKV0GZCFwNwQZwE6tKXitqBSSVFKUeQ5ReGyBlkrgm1XKYx7UZ4z6PUZ9AdkWWbchKzWvrD9Kde1FFZBHUPXMAwRzbHnZ1HuYwzSZZKQJon/TCbSWKoTE3TvlKXBShN1I7YCaaJ1E6QLrQPP47XiKzILEUB9CWQKb7kqWSyGtNJ3OwM9HxwflXG/cv/Q2q9TZ3VMosJj3mJg10tRFL7t/cJhCE7WLm2Rv9YKBX4+DH+klKRR7QEXaJxE7nrOLcvVLXJ1F5SKXfksNhdmrZetLaHd8vsyqq1Qet/GfHRXR/tTu/UUteTnQXirjI+r8O7235neQ+Gg9OpBaVNNr93eZXHlNtcW3mJsZJJPPPADPP3qUyyu3WZQ9Nnpb9IvuuT0mB9/jP/ql/4Tvu/7H6TaqrC+ucr/+nv/jTfxvNV/jY38NtNpgxE0O7pNt/005K8j9AKCJYS+A+oaUt8mZ4ACWmlCvdflyksvsnTnJn/49d+j6CwzUtM0GlWqtQpFUTDIBnbjxZskDjw5EBA+yCQia1C8uYf/ld+c70lXD+iA/j+jJImC6YV7owUSwhyWaWJqDDhAEMQEAiDUxudXWC2yK1CGgLRWYWSsSn28Ql4RrK22efkvrnHkgcPkSjFxeIzjF+c5deEo9z94P2fmP8s/+NVf4MLl4ySVhHor5eTlUWqiSmt0hJ/5uz/Cd330IU6MTlGnYFtt0935CypyAckKkhUEtxHiJvXKNgMyACZkwmBtjcXr16glKUcvHGO2VjDaTJk7MsPciXlGpsYYHW+QVqThTyJL7wCZJKSVxLtGuQNZSqikRkspbFxFDL6kdUs08U0mI14RSq0GDaMDRlaoKIF//5KidI0DVB74RkAugH0DyIxvuh4WCRySK907HAtQ8iVPEiMkDFd8Na14Lb0DKg68hXEFgOrGUAI3rm3p6maokguOe1wQdMovZAdAtVIeEDohwhSWMyBSK4WyFYvzojCgTRiwmVsga8BcYT0dlKmtYLMZOuDuhAn3LyalQ/ZDp3GOB6G1A7QWV2hKmmknZMVSuLBo02upS0os4XmMEL5vjv9pmpraAirmpRPY7DzZda+jNeGAaVhnARQ7a5vTVsthYFrCTnjByP+N625YA/EYfF9ijYb9zldpjupklN2mbBYxzT63NLcO3XqKvwqxCbHgK4jnypn7lMtwabNU3VVpGAm8nqe42IkQ2+DmoaQYuMu+DnzFz01wLWT/WnsHek/dilz33AbJ8gGr68usri3RqI8wyHNefONZXlu+wrG5E6RZykp3kbMj5xDyJlU5ycWzj/DZH9zj6FHBysYab117luX+U+wVHdrs0EoP0RBjqGKPrr5DU90xG1pWgB6wYza6aJLRR1OQZZvsbL/BnbfvkFYP00+2GW1pTp+9xKGTx3hh5SbFdofuYJuzcyeYGZ8lTSoA5sAcqnp3QB9kCgLCvg0Vm2cP6ID+upCzDpQ0vtZEHvkXS5ve0hzo9proRPUg0gFj65dfqaYk1YRas8LIRA2FZmenx6BQjE7WqB9qUB2pc+jCHLVqSrKt+NG/8SDN6gwPXf4efvrHl7h+6w0WtzZY3M147HP30Un2ePSxo8xN1dH9FVb7m0y1utT1IoIKkIPug7bpHJMRcnpoFP3+TbY2rrO6vMaho1PMHx8l39mmJhvMX7yX3YFkZeEOtSSjv7HJmy9dN7nehXF9yXNbBlqYegsGG0R+/kIYtyJs1hwBklCR1ripWI2jDO8U766K9gHEDlx4jak238WZ0YI7iIsHCcAhhkbOzcAJcc4P3s1dee7DNR6cqRDI6YQNYVBgfItFKWYcLvh6aMHZZVd+n7rHDAMgs64sf51L1JBKrnSPAKGx2bDiwNgwfuHAk3Tr3/BCFa6Gh0Zo5f3uS2DMgUTXdwtYEWIozbmdT/e9dlvGaXTDeI2g5vZXuN/7wwvn0iVRKvOA3F/p+xi7VAkLmh3Xo3l1MyFDgLhfF5F5xMV++DVe8o/Tpq6F2/T2s7CWIyHR1kvQvm9RM8P1Dfycx7wU4UY3NoKLnFv9Ukpb/0Q77pcsaHa68Of80DqLLih95gC8vcU/z2n/Iw5Yngub2S36LhKOfWnH8uvW88cpHMKQh/oY808P7XkrCJbTrL5PhQOvibITVuiCwaCPUoosHyCEZHJsmleuv8QfP/6vqc5M0VcDlneWeWHxWzRO1zhdvYmgjyDhw/ef4tIlwe2123zhyy+ztPVFbu9scGLmDLPVOqJYZnXvGlVxnbFKFyUSCq2QugvkpqhNOg1CkDNgafkKV688y067g1JtZqabbE+1OHPhPCPz07xw5006qzskdJlqjkAhQOekScKhmaNeq6HtWylaxoDblAf0gaOSgeBgDg/orycZbbOwB6X/FHOAmhz/OqBLApAhHJZWIHA/jWZYIFNJrVGhMVYz78RU0uvm9ApozjSZO9JgkGiSWpXq5AiVZsL4qOCTH7sHwTICyQ9+8n52e1O8fuMWz770Nh//3uO8uXyNY60eU8kuy7sLrG++QksUjFULcpGS6h6CAqVysiKBdBYhBJnucePGcywsXKHT7aF1m7npUTanxxC1UcYv3MOgOsbIscM00wGbr7zK7kaXZk3QaXfZ3Nih2xkYkKSMZtVpX/PCaVw9bIw0oeZgdy4dDky64l1OMDABhg5F3D1lYYT0o+eBA4MehDkQFM1njEJclij/qQh+59oBfa/FjICZH4vpo3buPG4stmOxyxLEmtrAH8+LCGzH2lTj2oF3x8Bp0R1TCeDIu1nYsSWISBsf889paUFrYbJuWXcnI4SVQZ932YksIw64KbTPxBNHZ8TAzs9CxA7ncy5E4G0ArZGgZse2P+bNjtWC6H2a5KF5dzyMgW8cY+AvjWfG9UOHce0D8Tp+D0QF1jyfowaFsAUShV9D7hkBzIf14K0ifkTlmdTRtY43QgoosNnVHK8lZeFAUBq2Dtp6LzBH18aWFLcnyxTx3FsspK9+7YRBt2398+3eLWNForbK43PkEhcg/HIaEgCi/XQ3y8U70HtnOXBj1Josz1hcX6DVGGP+0FEOzRxmdXuVLz73B+z1c8TuLpubm2wv7PH0689Rm9dcmLwfrb6JYBPEDI30BKfmzvC5n53m2qtPs3d7k9pDI4yMH6XT7bK58AUalT1mTs2QyToUewi6aCSDLCdpNGjKCdYGG7zywjd57itPU2uNMN7cYzJJ2R6fZANNb2eNbq/Ndlrl0vwZ5iaP8vqbr7C4cpXJ8VG+b/onSfBbEHSYuDD0g4xGH0Q6mLMD+g+BpBDBzG410KoojKLD5VOPNGhEB6U7gJxAAFaRbDXKlVpCc6LJ/KkJVhZ3WF/tklQTRg6NMHV6kt3tDnpQ0N4esHBlnQvffZqHP3MvFTmFLv4SxAZCnmG0dokH7jnF0aOvcfWVJ+gvthk9dpY6mzSKG9Taz7BXZMydPkwmqohijYScooBBUSNtNGjJKRZ6d/jGVx/nrStXmZwaYWY0ZyLRrE5OI0em6Q7aaCEYOzxHrVB885U/5cHHHmJuNuHqazf49rfeIsuMS4rC+h0LrGYUZKJs5V5lk68Y8OnQWVEoq32NAQIGxAqJQGLyn1JybwiVhkPswNAh44HHfugdA0htgs619oHnUsgg/DnNuwjPL6xf9HDMnZvvQhW+srN35dDGl98Xj4vILSdf7Mtp9mWCWTbSgPSSQOphY6R+NejIKeacIOAFJpdFCjsHseqWsJ51YfivpakMHgsqMXP9GO39ZpjWguJdxyzfrLAk4v2iw/5x1zuA7udOR3yOQKETHjWhkrQfh3ACgBMyrOBh96Syfv7OvS92tylshiUXLO3cUVxthjgmwk2FlKKsLS+/EgBNkqSG3a5IXZAqrZudaV8mMljFfOC4vdommZG2RoWO58/yPgiJkbDq32OuSyZlbZBR/AzacUWCmLcy3cX3X5eBvFmekiQJ1h4H3I2FsBwb4tIaSxm3GwQuF09TElRiioSs4T3llQrC7aVQg+Fu7nZ3o/dEOIiEJJQuWN9a4Y8e/79pF4qPX/4kj138OKeap/m7P/E/8Mzrz/ClJz7P//y//I90dnucv/cSP3Ls55FUyPM/o+jeIEluICpzSHmWVuUC/e44F85/i8ZITqY2QTSgssLrb28zfQxGaycRqo/uryCRJPWUVJymoODbV36LN68/g8pypqc1U0fnuXWjSjE9T37oAh0Evd1Fpo+NM9h7m9W1cTbaayx3NslqEqVtIRXil3L8djkAmAd0QAf0PiZ/mAjjF12ErCPgUk5qCgIgKFSoAuzdYUKCEoSASkXSGm1w/NwcJ+47xMx9mjeffoutpV3anV06GYyfHKO6PWCikZAtbXOmd5afOvO3kRQUxZfQO9dJGncgPUUijiHyEzzzzCLf/alDiGoHLXZJKnvkcpc377SZPVFlpHqRvLeMGmyipSBtzJHK02S6z1++8I9YXLpORcLUjKQ1M8H1hRbJkZNMn3iUrcXXQW0wPzeC3OwxNTnKyFSdQbOCHB1hbHKMPNe09zpUKglaJ17TLguF0onxXc9d8KtGKLx23mUjckeDtPcaGcP4otspsTjd8jxKteIB3F3cH5wQ4r5R2utX/WfaVR4WIdDUaXo9aEVQwiaiDBhNwLVJyZpIGawQFoiUNNkOKNuGROL6Gn4ErbFrR9o6Gi5jjCZxWlwCmCqtYYaPXQu6nWBh3YRi0nZOUNpUkI4049r7ORmBVxWmXkSlUgm1FfLYChFZWAipW9368FYd7YLV/XR5IOndacDGLVjLx7DVAhkJA9K353ge/+4EfxNcb4Npifz2Y+29MnOqtfFV92tGK+MKZ+dX+nUSnhfPeVEUHtS7SVVuHfjMUnjBRCmFtMHYTuMeTW24HmEKIhI9L0rz6nz3pQjuRDq+1i0Ney06zF0RxQlobbKTFT49rem3tMKEzzhlGMiQ3BwEwXCF/VmSFYNyxf6Tbi7cGrcNO8uKu3NIbDHWEZvh6N3EF9yN3tOYA6MtMGmmRscmuXn9FX7zS7/BH3/93/BdH/peLp97kCdef5KNt2+Tbe3RGEuZPd1kgipCJKTJ5+h0/w9U9jaVWg/GBzSSnyZt/RsWFq6iayNU6i0SeYwi7fDCWxt85hMXacqCwe4G/e4SyViLZv1+EC1u9v8Vj3/+G7z16ibTx0c5/dgszdljqO4U1dYYy1tXSHSbyZZmZnOJtbfW+O2dF5g5NsfHHvg49548x2bnGnOVi7i0b/tJv8PnB3RAB3RA7z0VSpFEh5NMjS1UqehgFSbg0KWbDGSBlw/w06CEB7nVamqCc9MEBgOOXz7C4fMZ/UHObl/THB9jcOVt1F6P8fNjzB5uMipq5jBNfoG99n9PdW+FdLSHbEnGmw/z8EdPsLy4xNjh16lXTyOSAW3V5uUb23z2e+4lFX16GyvoZIfq2CyN2jxQ51r/X/CVf/o6vY7i5IPTnHhojtHJc5BPUB+dYmPjeZqNjJGiT+XmK/RWC45dPMf0sSNc/fYbnD4xx6XTh/ij3/8LsqwPCtLUZOHR2hbTGuT084JKJTXac23yxbvMQlgQYTKX2Dz/MSD1FgGD9lTkj10KBg8KVHcnJVAeWvGgM770rt4GJUDttKiKRKbEKM+DGx0KFyNcKk1hXTHihmNYo20xOxm07R6jOm26AcQCaTWxEdhxiNqBLa8BLyLrivZjFCJBq6JsMHBgc8gVR+vIZYOQttVYAuJUsCGOoQQApSTBZQSyIDVNcFaHMmizbVk1s9aFtTJJ63rjrHLmWu+yY60lAVoGSmRwZXHPUioIKUkicYYM99ndSFPWsvvHOTBt73MWhNj64QG/dbdzfXAUgovLcxfaFT5FqJ9nN+XRfc6Vr+w2ZgUCmfjPTDpSa1WwjQRrSVhDQuhSbIImuEhppcAJBuCFJBdLoqL1M7wmiPsN0VqOYhtLgkCUFvk7wEYvTLu17OptDT36O7UxTO+BcOAGHjbfSGuE+WPj3FhJ6A4K+sUWL337ea4svcRnvvsH+M2N64i1bQ4dq3PpwTE/CcvFHhPjj5L2auj8FqK3ArWvct/5i/z2v3yZ0cmCo4cWaVYrTI/OsfDtG6wXCTXuMBDbqAo0mzUScZYBGc8/9xxrG5uMTkvuuTjF+RMPc33jBBs3/oQT930X49kane01VnsStd3mWhfu/cTDTByaIh3ZZLv7LSBhay+hkkzRqk+CTHCBQVpLEmGClfVBsbQDOqADeh9SnF7SpTLUWnlNlAMosfuAC3ozv2Pv0aSp9IdSIgSJkFRkyulz81x5c4Ek1bQ3MwpyDh9tMjo9wu0jLcTiHmcujXD8bAsARcFitkuz8SgUr4PqIAY3qKWKB+/9KP/0//wtTl5skI6/zVgdWskkt19dYl2nzIubdGWfek1SrY0hxQn6asDTTz9Np9vj8IkGF84f5fChD3FrY5qtm1/h7COfZnzrDpvtAVvtjNpOm8WiykOffpSx6QkeeWAWOdhlc32dH/vxD/H6m7e5+uoaMklpNutkRcH65h691V0DxFKjdZTKHHwKAxClBYCxRlkIQZoGYcIAOCMkpGlKkecRQDOklCaJcg+WAkC1BQ4ebEfgw37nAjl9o0JaQK09+JFSlsByXIfLaYpjIOTdP8qKbpze1Lkb3dUf348jSrNppRuX6tGDQssMUxR6yF/cLj6ZmABY15B2LivuaTGojxCU/1QEy5n73Hvxa13qv+e5l8bMPjKuHu5zYYWAoOEeFu3QGl0oX528hBYcQPbaffbdW9a3BxcVV4SthFl1EKBCI/Z6b7YqC0pCyqFUolF7StnMRqGf8TWxm46vwGzvC5KkFQSccDIkXJjPgtBhhBIjnQZrTLzm3TsrEmq9VcVav2y8qHPVEuFB1oJqZ0qHOg6ub8Pr/25/xxY9DbbScvy+tZWbhX3nCpMdzXXY8aKsQHCjsW3YwgplQTVMa7wuvxO9RwHJ+I2hdM5AbTA/Ncnc/ASF7rK30eXGrdfIb+dMTGZ8/FP38/hmn53VFe68vAkf66PQ1GmTpLPk/Sqq06EyVkFUbtGoX6CQmm6vT9ZfRdVSttKUvFPQIEGzhRZtZKKoJClCTNAdvMiLf36H3l7G9NkJGqdnWO63uP3KE9x73yNsb9+hv7ZEVUsOj0wxoM/s+QkeOneZWr1GUxbUREEiJJ1ijX52DfqSmpwkFU0SUaNVPUKt0kDKBKFD9cwDS8IBHdABvb/IHl6RhpQYDBGClSPFrb0z/GnSfgpbRLDJkSOzPPzwJY5MTrE+s8bWRp+B1vR6GYONPcYP17j8H32CP7zxJyxf22Xjxhbc20eR0xRtGiOXyBdfR6ddKhJEeodW4wy51HTaPVS2QL/aZEdKim5BU0hyVtGyT5JK0rSOpk5n8CLP/+kSSQKT58bRh2ZY3tWsXX2O+x74GGt33oDlFcaaE6QjTfp1mDs0yUfO3o9IBU01A4MOM+M7TE7Nce7B2ywur7O2uIYgZXlxl9deHpD36+xuF6hcIdMEVWgECqkZcgZwHLb6xGEtdASZpZTeEiPAuoaoSLtcQuKgba2p2BXBSgzBCiGDFrMEGsMvQlNOV6XxQMa7QlhAF7tVaIa0p9FaCm5HCheYWtLkx1KQs2SUoLRbi2WwFFdCdm05Dkph3J5cPQXtvo9AWqkjhDb8cyPQb4KTve62VAE56qHXJMvIBciwy6uMI0NAmEsH/gPGdhfGCQOGgLAGXw/DC0yG10F4wvfJrEYbwyAkGmWKWbs+6GBx0EM8G57V4PoSCY2YNeim1FU39tYXrX0Mh+d3xH899AzX/1iWEa6SsAjxNFII4zJVElDjF1c8mfjsV6792CATBPgy33FzPdyujr6Pnu+E4tJeLTXn4o+G3YWCUBMLAP6akmA3zLkwh27u/ip6jyskK5Tuo9QOc2NHOXfsOPVU83axzOKNJXZ3+jzz+FOce/BBDp88RqpTthb26OevkSRzNGUVXSyjZQXEOLQ30fU9UlEwN5fQ2Wmzs7HF+PgoSTqLkgqp1kDvIXQHqQukSBHMcnPzL1i4tkdWaGbmjnL88Hn2tnu0GgKV1djd2CBpd2mNtBgdT9mem+a+M/czNzFP1h+g8zZd1aWgg04HrHavMJJqciYQjKPFFFmeMj16lKovoX0gFBzQAR3Q+4ti9wrj+uJcG9z3EIQDbdNsCo8bA6YT1n0hIa2kTE2Nce6eEzxw+R7WtzY4feQQKxUodgfsrXdpr3RZra8wNbnL2JkJekvbbC0vkRVvIuUULVkHvYioTSEGbXS3B7UOSVpw5HDK+lKH3uwGsl5HJpMooUiKNUSyRaJ6SF1DUCNXo9zc+DoLb/VgtEpzbJpECfL2Os26RGU1dlZXaPUzGuOCylSDpDXG2RMXmW5O0+51yAcdVFEg6gnTxyZIDu1w+nyVtTsVdtqKxnjK5m6bXq+g1+mZigoK7w/tC8ZpwydnhRFoDNQPmlARUJqZAOECimMAFUtnAYkEDGDnawh8+a9FED+8hj4CjkbLKbz70n5sISLN+H4tatQ5AvAePv/cwikLN/7KSFAQrv9qCKjZb9wYPPBWGiW0Bb5uvFbIugvADm05dxllNeglHa3vmNZBqDNdD+41bhAq0vrGgNxlRsLhUqehH+Kfez6CYAUp9TUERe/nfCyMubHuB4nDzToga/i1nzSULDLeNQwRYgXctNrOx7EtblzOzcq4l8n9z/Azbj9xgPydxivCc73QF83FsOA3/DTXiI9DEMHNUpUlBs+b4V441rl7hC5/6d6pOloP4esoDsONL+pH2OJ339duHQnPiLA2w176zvSeFEGLBRxNRipzppsnOH/0LJfOneWee45x/MgUCfDaN9b5d7/951SqVU5eOE1aVWztfQ30OhUxRp7fRo62qI6dRLe7qCxD0ubCyQrt1YzVO20SFFPJEfIGdPMbSLVJRfdIVGYrPlb51hsLtPOC6lSTo/NnOds6w+jmAifPXeCNF55jb7dDrVmlMVlBTElap0/zoblHGeQ5O+0Om1urLG1c48bGq3T0MjvZCq1km1qyQKGvs927xcLmdZTK/djL3DigAzqgA3rvyRUzcucikVY1PmOtlR7nr+vSlcZ+ug78pmmF0fFRjh45xOHZQyxd2+ae+ZNcOHuKM2eOMHdoHHJ47dlNvvgvv0LzcJPGVIt+cYedzpMIvUFFTpJlV6nOnCStTKE7PXQ+IKXN5XMNFt7ssrvdpi5qjFXmyBoFnfw6id6movpIlaEV9AeSb11ZoI+mOTfCZP0QrZ02jd0FDh8/xavffJbeoKA13qAyKUnmmkyeOsd9hx5hp7fH9k6b9c1F7mxdY7l7nb7YYCdbZqre456To8zN15g82mDm9CS1RoJMTWVbAQEECcuvJDG55cExO+K12AdsShV/KYML5/oTMujg5yGm8okT8tALge2XiNoYAqg2eNn52ZcznwTNtSpM9drCFgkrk476HXroSrB58O40qH6sOkojKfZVGPaVq+11TvMq/TOjYmRGxY2DnU7jfDeKrQmRrOX7JEQsGMSaWiD+CEogzrGstF9wMJ/SxhvQ6QAAIABJREFUfitbGkK/yvE+sUAWro/3pRu2sySE7oSG3byUuy329z16kgOkps+y/KVrE7zPvxM6QlXsIFQ5hYJ3tSEUxYutY248pqqw8nsrDrqOLUKl3uu7jOkdtOkas+9MkPiQcHO3e7xVJComSXkpCGEKSYb5228t1JYfw0X+wnocWhND6y0er1JBsC0rFd6Z3uOAZEEiGgjRIhE1GtV55ifrHJ46xmP3nuN//79+n147o5/nfOPJJxmfGufcsUlu3nqR6cuPUKCQyTSSPsg9dDog2VmD5gInjzZ5+s8F67U+udpjVy+RT8Mg6SGR1GoDCgFZZ52k+VVe+PICaSJ44Psucfxyk9Xtl/nGt5/i2OjLNAcaWkdoHhln4vQ00/PnmEofYlo0ePHON2mmNQbZGrtqlWRUUogdzk9MUE1yEi1pZ3us72yytpZz/7GPD5nj7qZBOaADOqADem/Ia4y1A3qaJJE2gNFV6RSlg84BPgEkUlBYv2BlNbuJTOh3M5YWtxgMKuiiQaNynNPzx7l88j4W773B7/z+nzHoKPo6Z/Wl29QbVXbUBrdvv8LEucsUQiPTI0bjmwoUHZKdAupNzp4c5UufX6P9kT59tcWe7JJNQV92SbWg3spAS/LeTTrdr/Pin92h2ZR8/Mce5v5jJ3n71Wtcf+0qM0uLtHKFqJ6keWqEqVNzTE6cZyq9yKRKee7Ot5luTrFbrJFVu9QakiTtcH58hCQFmaZUq3so0WUv69PpZSbFqdZRTIZ1f7BZWTR4MOt8nYOVJvK593A9HOyuijCoENyJnT8HLiPQ7lqKJpqgwsRqYr1eHuf+4NrWkZZXRAAb7cbghMKo+Jbtgy59EM48F8RaAjuRltdpQVWkXZZJAgXevSJWOboT1RVlExbUufXs2lUePAYOO2E47mJRqBDIazN1hXVfBmrSpl8VQpaCzl0FaOej7y0F+yw8RG2HlsuCWJhHETLdRveG6TUCQCg8p6KUtyK+0a5Pt5djAc59H68vp7oO2XScgGCeZapEu3SvXu4twR3jHhdWRUz7Kh5bnriYF595yAsVZq/I2Ld+iCnv5AblrA9uPKa9csYlbx3QQQvvW/LxK3G75f4l0VidsOPZ6AukBdaq2MXKS4zuHht0fZc1E+9xx9kQYxQE8HdD722FZFXQyzboFG02964wWpsEYKOnWC8O8Yu//PN0Fl/iz75xhdffWKOve+zlSzz1ZwUPnPs8svIZqskRoIdSq+jeAKo1VG+J1tgMDx1eo9bKKHqbjOtFKg04mmTUBWSDDN2VZHmPm+tXqScJP/xf/jA62eK5Z77OxtubnLkwyvbGDqqoceKi5MjpU8xOPsRM9TIzssY//9f/hHvvPcFgqs7oaJ3j1SP0xTY1qaiqjKbuc2Nrhxdu7vDWnZyzc5LuoE01rR6IAwd0QAf0vqU4+BIhyPMCKWPtVTk/d1Eo70fsNHdpJSGRApkIQDE3N8VHHr2PtFXhR37uMzTFGO18jfV+D2bu4Zd+eYps7Q2+8NSrXHl9i9qEYGdzj289+SoXT/4hsvJZauk5YAeVJTDIoCZQ/SVGJ47yXcduMy4VcnCLMbFHra44JjNSocl7GVon7PY3ubV2lVY14cf+3k/Q793k337hj6jJnJnTNXa3d9Cqzpn7Eo6cucRs62FmKyeh3eY3/+Q3uHz5BHf0beYOjZFW62jZpSYVjWJAiz2+vbrMU69vsL2nOHq8ye35UTaX9+j3Bgake22nQuI02QwB3LI2OPDcqAh1EfkrC5d6VHgQobSmsOlnk0R6UKl1DEyjFJEWwCoTmFDWohukZ0GM70noodf8B591h3SFF1ywoN4ED2sHbPZp0YX/4bTQ5vkFRV541jiNemJTXXqYth9hD7moBCAaBGAdgS7n2+8E4wCiAz8gOFzEwc9J+Dq6NgbXymbhiQEnCpQNHXbjMprqSIPs+enGadxdtFJhJkQYnV9FImRKKrsTDQFkCxpd35zfvVk2ct99sVLAu9rYDFBKFeX2rYbcsgDAC8RODIlBv+ePcFPjsl0Fq4BpI8RheCFVyQCQtUYmibc2eEFR2FSphXu/2T3opBcZBCmEQPqEMuW1Fdanefd5odUK/M5dLQbsseARBOLQXnkdRvMlg4XIByL7JVS2iDiLRiyyun6+a6nA0ntrOZAJ9eo0/XyV3cEiWdKnLivM18cYr83T0SmjRx/jwd4X+fDRN+h1l7izt8WtN7Z49vErfPSTD5HrPSQdZKtOevyztJ/6PLUHajBecOhche52h9XXVsiPaB48BTWbak2JhL5o0tGH2G2c4+hDb1Nc+Utefq3PWr8gHU+5tagoBoKPfGSMD188yszYJ8j1JRZWVvjyV/4Jn/zBT9EdXCeTa2xlil2VMys3qcgBapDxcrvLEzc63FzNaRRjVAYnaNZG7IvcbuVhc9cBHdABHdB7SAZKBtBRzvih/aGdOLBqDx1fAdRra512FvI859bbSzz1xLeYP9xioFYYP3SByTRlRE3TVjVWdmf54hNX+dB9H+GTx26wpbZYWN7mxkqHZ594mY996mGyokbKFunMWXIl6bzxOLVLdRgvOHZ/nf7WLvm1XSq1nAdOSKq2mnMhUnp6lB1xjMH4cY58aJ3sha/x9PNdujVNc7xGT4HUCR9+ZIyPXj7GeOOHWO+M8dLLL7B89Um++3s+Rqd/hUp1l5WBYrToMpl2SEVGPhjw3F6XL722w9aWQu0p+otd1m9vIFA0W1WKXJNlmgKnTXUuD+XCV4aHQRPv5sHUnIhAI6Yonfs+gFodpd10Ws5Iy+3ASmJAkpvr4H/vQFQUYCydNj4KtvWWjhjkCLQH8ME1yLkyiCig2QAZV127fAr6MWDPSMcXOXxeOlQc2kxE1CetS2DWfSwtoCy54di16oGdTS/rrpA2T6sD7kq7+GwLHkW0GUqCnku+UuZTSTPsZlSF302fI8DrZspmDVOugJ4DfiXwJxhmawxUhV8btjfCxU0EIcTtc/+HvVGAtyCF3LVO2LKPjhQHKgrydetTF5EQ4WMw9/ffAV1nkQH3njHrxlsSNGgRgWdhsqc50SaR0teJKAs5NuZDWf4ThONQ0diOQxsXKJO1KwhNaZKQF3kpFSqlJwTyFlncGtIRa3Tp/jRJUVqFtRPJBX5NxhYmP5/4OiPDigYn1Khhwfwu9B4IB3YlCxBaIkWFejrLYHCblWKJ0do4rXSUJF9hppIiqxNUJy/RGD1H/86L5Jtf43s/NMb1l7a4dOHPqc98mFp1EilAykVq4w0kObroQkWT1LTR5A8E5+YEolCQAaJCbfQRlPhxrj//P/HIjGREVnjs8odJmw/x9lbCbz/+O5w+3OKxS59lfuxhltZvcP2tp9i80+PDj9R5a+PLjLf6jImCVlKlIiSjaodee5eXdzVPv91hNU+hXmVEjHNk+lTEhgOR4IAO6IDefyRiP9kITHjsI6J/ZUXW/raERCvjf76zvc1bV9/i2afrHLtvlrRRR/YEjbRJo97gRLPgb/7wD3A1y3h5MWPQ7nCoWeXSmODmy9vcf/mrpBMfR6Y1ErGBrG5RG6khdY4u2lAXpFpR0zCu4PQhAbmGTCGqNb7xTM711evMnVrg0VnJSFLhkQe/h0rjIzx55XX+8s0nOHN0jI9d/DSzjce4uvBVrr6yglADLlzWXNv4MhMjfSalopXWaYqMer5Lp9vmyp7ia9c7bIsKop6idzO6e5nVKEKhHdArjH7da0R1AJgeqJUtN04zasBd4edgH0wWAZzEQM3Mj/Zz4cF7DFBLbhC69JkLmPUwOwZgUT5TmSRGI2v771Kf4mwKTsscgWTflB8oTq1f1rxH/dTWMhK7UDjtt/OtL4pQLMyBWXRpyZo+O+uLNq5Qji+hV46P5Tu9SBFps52ow9CeMU3EjlXDQkGZF85lxVkx4nkK2nUcfg59dTh9SCMdP8a5DYV6Z7EgoL22O+oVEBUsEy5uYbi4lkAOR7DqaI1G7w0vUMZCkQ4Cpc9cJKW/38UcOMa6+XICjY7+j12OclvvIgjJjisxub5H8RDYVavLLkPxvtK4uQ+xPvFy1doGHcdPdQKxHkpHGj/FXGhc0ER45rBFQUd8C6N3zw97yfEUIYbm9jvTe5ytCAxjm7Tbe+zmK2yxyGhSZ6w+TtEcgWSB4+PH0WKMSvU+KjVFtv41tgY5b71yg1P31UimTiIrEiE6pMcPUawvghiQ1jQirSNFwcb1Nh8+0kCqlKJbkJHQZ5NMf5OLM5rDMw9Rq5ykMdYgrZ1gdu8oA11jeqKCbpzgmy+/RCV/jYbeRo3X2EugXqwwKSHPBegKvb7m5tI2K1rzdp5wu18gqymjSYNJMcl4c9xsMsf1AwHhgA7ogN53FEGOqPKp00YTabuGgZ491/yrzfw0B3mWDdje3uKt67cYO5WwsHKD6iCnDtSSFFmpceToEc4l91Dccy8iP0naf4v+ynNs9QuuvnSNMw+NkI6cRsgdRK0gnZ+mWF9GJw2qIwm1aoOsPSDfzPjQXB2dp6h2xiCpMDotOFVTnDxUZW7qAWqVUzQnayTpWWTtGEdmzzE5XiWvH+fJb36d0corjNcG5GlKJxE01CpTSUJ/IGnoGutbPVY326wpxa1CsJwV1FtVZAfyQYHKCpJK4t0cXH7+wCwXEBq5VVjk4bWI0ggVsabeuQy5e2NtpAOjsQViWKHsfhgcqb2g4doDVxcg3BYAism540Ciz+ZirzFVdCMw679TXtvqA0uj9RL6F4Cdc78IX7lA1v1A2oFlbxmwmZPK4D0AJo/3Iz5ZJHdXACXc1BAAdtTl8HtsibAd0qX7on74jgcW+FbdXotJhxXimefiCby0ELmcxdfGn0Ugc9hP3VkUyo+MsuXYdRvzIR6ftsKJWYsiEolKo9vHw7iv3g2nPOxQ38CtAQvO43gYs/YcULd1CWJrSczHeCwEa9ndxu92TMxD74pkex8Lyp4PkYXBr8dIgx8LrrYjpbEJWV4Z3iVv6FPAp7wVfqC4RR7m1Q3lXdB7G3PgGSnJsw7ZoEtnsMkgqdKsTNDtrFBwk8NTGpWmTLZGOTz5AK99+2XmLihu3VinXn8DeS5jbGaaVCYwWYe32uiWpF6RFLUqRT9jsKG4fHkEkYPKNCQpSt1GZ0tcPjEBo0eQch6VL1DkbzLZavCjj3warVOu9DZ5/uZvcFguc3Z+jJG5hDc2Vjg3BXWds9CBQd6jvVvw+p02K7Uau4BOBBOVhFFVZUw0GWuNl8xAB3RAB3RA7zuKDk2s9sxn58CCmwjA2ZvsYegwiwObDgFqNIo8z9nZ3QH67O6sUKHP5m4bMsXozCTVsU1OHWowej6lUjnP5lqFG+oWM1py7c1VRsZeZu4eaDYlSTWF0Spca8N4SrOektSgv50j2nBqsonONGqQQ73CmeMJFVFlanQKWodJ5DxF9gaFfoVz8/dx4cinybXkze4GT139Eh+ZFRyZn6KT5iy3tzg5rqmrjIU9kEWPxbUeNzYHrFerbKMRFUErTUErsoGiyAorEOAP5xhPxEpep5k338c+6MIH3Tonh1jb74B9KTDTATMhLdSP9JJ2ghzmca5Jwubpd+BCSol2ftm+v8NA3bXh2lbBqOTBabhAa20KsXmQG8cqWA1stAyH/bLDwx2+CVpvsMDc+uPHAoZ3q/KpdnVJpV4CygTsFECl8OPwAsrQ907gKLUbEI57UDwEe70opSUNwnUI9i1NAiJ+RLktQn+ESyvrBjQ0tnjcZQAthgBkAP9uDD7YPeJ9yFIWrfEhQbQ0xmj8JbA7rGwQ4fPy+8YxSvs9gP+3D2uX8bDWpf5EQ4ueEe4If4nQH+wgNUYg0/j3ZIln5QVF7IIWjy1eGULgXdcCD6zr11Cfy/wwD/P/e0E7vmLIxfA70HsnHPgNZEyl9XqKqDbo5BmVdITKyCxbW0+z1+5B9wYTrZSR1jzjjcMcfux+9vJZ/v3vPMO1V3aQ6QK1EUXSHEH31pBJBUWVhlD0ewN0b8CR+RpFUiMZ9JEkNGRKXdfQOoVUQP4aSj/FoNtD/7/svXmQLMl93/fJzKrqu+eeeffbd+yNxWJ3gQVALEiAB0BaIEEfMiVeJk3SsnkoyHDYphUO6x+FZMsKS46QQpZCYoQtkZKsCIECBV4iiJM4uMBiL+wC+3bffb+5u3u6u45M/5GVWVn9ZglQMvXWEfOLfTsz3VVZeVXV9/s7hSJuvkTU/IsIcZgHmy3mjra5djEn2Rnx8LEG/e0hedLjxq7h4lbBzR3YTWHabZEridxLiZMGC3GbBd2gG8WsLK4RRzGzhssDOZADOZC3ihiM1/IaY9NFRpH0LywH/J1PvM1yAs5i4JSeodLL5u23LyulDEkCjSgljwybmzlymnFsIWNre4Mk+y0WuhHtzmkWlrqcWXs7g/EtPvnrX+TVZzdJ+peIj68hI4OZbiKjhIIGXZExGUxoCU1nuYmWCWY6RUhJV0a0aSBEDDKD/BUK8zkmowkyfpak+Qwq+R4iscyDzQbd+/q8dvE27ZUxc31JJx2TJR2u7eRc2Mi4tQUjCWm3SSEl8V6KSmIWVINMjBmkOZOdlPHuBIHEmAKHJ/w8Ow127eOq8mrll1IFeQvhAsFD8GJw7gd23qUHb+5/sgSw2hE1Y32opZABSMRf1waAzrrZOL/7IJ5A1gGbVKVWN9TWlwjVjSHQgXpwBWC0rvtCeyJRAs+aVrsiQB4Uu81G5V9umwkJlQNdpjyyIjl4ImZw1CWYZE86ggUs+yRqx1WdEcymEqq5e5SHWFckXWm8/dgEspy32WKEQtiYB0e4vOHAnScEhdEgyzb8GKgAKvVA4Xpa1PoylAP1Abf19XFDCkiGr91Q7XF/LR/L4tyjHKEo928ZMKyNLoNxbdxHmK3K963sl107WZE/rWvE03Lucs6lLJ9N5Z6qZVazRyupPCl3BCskpD5ORswEFgsb2O9jRMrzCq290oRgz7k95sYYaAv8fnHr5Ul3QCrcKc4a4Xiv72+58KZ0C/vTiNiXmfuB2p39sY99jI9+9KN/qobvlvp1vNnQFOyO7vDi+c+zWbzIsNhgojOQmu7kDq/8wWU2NyaMhxknjije/74u73r/Gs3Ww2ixyPOf+zTD67dYWIi5/4lFGi2DSFbJr34d0RJMtzOmOyntM22G45SlfgRpgREKZAfUPKrfgd3raKaI2GCEveGUilHxIUT818j1G3zt6h+S7r3O2V7BWGb8+jnJIpJbV2Cv2WDcV2ynKWKScXh+jreffhvprmGuOM7DC+/l9LH7iVWMkMqblA7owYEcyIHca7l48SKnT58GoNtt2VSRwcveuayE7ifO9G0zFdl2hBSoSKKUQAn7wo2SiEYzptVSzM0nnHxoiVOPL3Dfo0sUERgVEaOJBxuc++wNNjem7A1z3vl4wnveO8fDjx8maZyhEEt86bd/k2J7xImzPY6c6RI3JCJZIr/4NeRCi8GlESIRRGsJkzRlsRfDNMOoBog+IukjWxFmeAtDikiMLVAkJFK1UMlxRPRXyfULfOrcxzkUbbLcylnPcj5+UbAsFG98c4/80DyjRDLKMqK0YLXf4eyxEwzXNS9+5hxvfO0aW9dHFGPN3m5KOi1KkCec4tB7adig0hK8l9llfHBj6bcfutg49wX3BrHApwJDYdBv5Tbh/rS+zDUXDXeY14i7VkNg7b4rwUz5WVip2f3iLBlhLQQbj1BYd6WgXz4zDhaY+3Owrk3ep1spSx7Kf64PLjjauW4hbPCq04aH8EbMgCoRjMmUcy3c3yas41ARr5pFJNAkuznw0+5IRs3CVn/XV+TNnuiu7wO+y2UI09k6AOldVEy5V2asEu66VfP2HKkcyTeeRFaabuMBfThhbq9YgDmzJ4yZCT62aXiVlH4O3Pau+cub+lqE/a7muyJ04R70ViEHrAOCW+jCBh0Hx1bXrIC4A+muI9qnDCsDnMsxFUXhyYMj5dW62bkLXd+kq1niF2tGQgtNOe+1wOfqRi3HVt1Ls+NxY6pZfdxPt04Iv3+qLWWzz43HE9fGviD0nsccaKNZ3z7PeHqdm4Mh18djNre3GV+4xt6tCacfn+fxxzokoxH5MOX5FwZ8/GN3+M/e9RqPfGiVM29b4VZvienOgNHOmLh5GFmsI5db3Lw5Im7GzK112dmd0tgS0BCgFOwWGDNGL0bkWxMaDYUkQssJQto0c2YyxYgroP42igc5MzfiK5e2+Zv/aoPtFDYH0G7HZK2YaLVPQ3SZixPuP32KB+YW2BrAYGPC9u55snXD8UMniVVyr6f8QA7kQA7kTUUKGbx0wpd0XRxICEGUlNZiYItp4bXLQhiQgqQdc+aBOebmFJfXB+yKFpM7m0yvbZDtTDn5WI+nn+wiNgZMJwW/9zvrfPyf3+D73/Eyj354jUffd5RLL94gMzl7w4Je0kcW64i1HpeuDFk+2kMqwXiQkgwlogFGKcz6BNONMBLYlSRJhKBAizFKGSjApClGpAj1t5A8wtuXx/zup2/z3DeG7E5hewSddsy4LWk0E5qdFqvtDqeOrnK6N8erV6+xdadgYa7D0aPLTLdz1rcGZQEip9WvtIVARRQ8mA3TY1rwknsg77KuuEKa5Rr55kKXF7z2sCgKX4TNtiMRQteAWR261tdcB77MUkryPAeXPUZYVyAPpgIQo1waSWPQ2qYidUQovFZNzek0rqWFojrMeKLkgFKoya+8U0qVLCWwwoJT/HceD1dadEeAa9rVysXKESoHzGetKZVUZEFQVtLdx+2jZl4w7h6ZWbsS0M3gdD9FISi8m3bg94UDuh5QB+4qsyVwvVY+0PjXrr1PNp46iHdWq7qSOuybt4CF2n83n+EYQ8uNJ1zB1BGSO3uQzeZV4NZBOktCeZOpWYsDNojeW95czEA5vx6QS2eNkbX6C45AGreGwdK6v/0e20ecFUYIgjiiwLUvIEpunPXng51cf1w418EWCzalv97+zKUu9z7mwBTICG7tXuH8hfPcvL7J3m5KZy7m53/xFA+sPW7rAugNjF4nS7cZ7mwyur3Oa8/ucPS+grl2zOYk5qWvjXj0yU3mjzW48dwul18fs3Jfj6WzisYXRrQeOoTZ3kHEBtFugFSY0ZSoqxiOod2dR5gtyMdAgVBlbmWuYsQuW3c2GG6N6LVgEkG7rXj6Ox6kaBxhSAtlMk4Uu6S3NvjXv3WORhwjOl3m5g5xqB/RiJu1G+BPa+Y5kAM5kAP5sxb7XHYaMvfSc2++QMtYogCXb96dbdO5G4hkSRYskIxjQbsdETcUmcy5eWXI1o2bZHnBqZMd/vMff5Azq4+RqAShr6P1JtPxNqOdLfbWt3j18xvc93DB6mrE9cs5mxsDzjwimDuUcPVL25w/N6XzXV3m8wL9xoj4pMJsKkhALXXIc2CSIppNhmPo9pYQxS3QKZAjpAOdV0AMuHXlBnoyodsypDF0+oqn3nOEa9MmQ9nnaCQ5qjOmV+7wr792DqUK6M4DkqkWTEaFzchHgQvMrLTXFgBoU6Z0LN/sUopKE+mAr9OSmnoWIwcAHWj32tOy0JZzKZAh0MA1HYJUfB8qLTq140NXFFnmgncaSSOCPpsKtDsLhig18VZRW0N3tXMqnmOBmcskBGX7oq4h9Ud7zXo1RkkQ1B28ZrVPoSnK9ioQ7CwR3jphjLd0eDcqr00vx64ri4LLa+Pdc8o1rUhLSA1CDbO1XFV/VuNxVjr8/Li9UWrQdUUOq/GGoLK0VoXzQX0MzmojhHPL0X5pXMIBl8N/Nkg87GfYXtkqBlOSE+kBeIGt96CNsQSSKn2skgpnSXL7ArdcAYGoxX6UzyKJLONKjDNV2B+IquDafkDdcYKy+KCzhLggZe/KYwIXSr8MLh6lXB/nImfst9W9Uu19b+2irJGA8evs78vyPgyrR99tBQn2h/DTVJFHql3mntmuP9+O/AckBzX+CBhbBC0dIWWLtYWH+ObrN2k0htz3yBwffvosj548SS9JwNzE6JFtpdtirr/AeAGmaxkNMtLc0OlFrJ1qMb5xh1avjX5jyn3Hm8yfbBA1Fb3HF1BzEaJxBiN2EK0IogRVSETcpG1OY9JXbCEN10djoAGYAVBQ5GOyTKObEUffvsSfP/IrfGH6Cfa21okyjRqnXLw1RLckO9OUdm44vrbE2848yVNnn7G5et9UD3cgB3IgB3LvxWmnpLSp+ArvnhC6UYTpFu13oe6q0rw5n1lNoyHo9RU7wzFRDOluSrNneN+DJ3j/Ox7k/uNH6SYJRl8BMwahMJ0OC/OCybJiciijJTJMZlhYa5BNMiY312m2WujXUh55osv8vKJhIpLmAqIbIVqHgE1kt4UwEaAQUQelj1NkLyELUaaALEFIYkAPQGjyLGVaGKLFBgvzLTa+krDZmiff3mFRblLs5Fwd5qSRZDfNaAL9ecGVb97h6jfWGQ+ndp6EA09ufqq5quZoRl8UqrdxvvrV/DqyUdMMlvPutPchYagOqH71WYP8V9VK+mw/Zf+8ZjTQ+lfAtdKQVu43JSDxx1da17pbTwWkfcpU25gdrbFEJczzbudUEVaSDvtTD+T13xK67pTT6nBhCapCFw17jtHGWptwGu6K/DiL2ez73FZTnrm+cHA5WLt9LDd1a44pDQgzJE4GAB8dnFyeV85l1U83wfW5ciSpvkXMPr/hx+racrdLeLIjDc5jpxqPwFDGt0iJKj+3Fqd6PEGhg0J91F3HVFmQLKwy7fa4Nhp0lZo2TKDg+l+bbzeeStVvyayz0pUDqQiCq/psK5h7Ml3bQa5dWSMv/vrBQpnSdFPFFITHh+Suvhb7WROEoL7nHZFy9KC2Fctr8a3lnlgOwr4KIIma9PtLrK7Oc+SI4NHTSzz98Gki0QVzFZ1ewORDMAVaGAw5vT4ksaDYE4iRpiUVrV6L3a+vk53PmTveov8cfB72AAAgAElEQVRgj8Z8E2Ei1MkmmATyFlr2EPEqMjH2RSRXkAiyaQ7T3FbUiCWgMbkGlYJIkC1F61CXlV6X9n1Pc/nCJq9fv4WY7DAXa+Jcs7ueI+faLB5dph+1OHPiQR46/jaOr5yqbZgDo8GBHMiBvCVFVMBES9BF5VZSaZxFeLgHh1ABQ+M0hyJ0MzKk04xYJiwtJ5y97xjf8chZHj1xkkg0MOY6ZvoGppgAxoIfWdDrC+JYUowEIi/ozzXJExhf2iK7kLH4QJfFh+ZRccP2cVGASdBZC6NOIpKTKHEbzBDkItII0mmGmRSIBhYIGMrn/RRkgurF9I7FjFhkSyyxvfM651/YpJnu0WgJdncLxiMDnQbtlTYdBGaasXNjwO7tIfk086/hEu/iAgc96C9/agcQEKX7jAOrDgCI2px7F4gS9DqioI2ufe6B0sxL1/sjo2EGOEF4bXMXaKmLAyCVWxTYoEzh1Jhv8rJzV5wlMDXQKWY+x9FSvPZVEO7NelsVCQgAthQ2RmMGv1djdVYxp4UOyEPJKLzPOnUQ59c1HJcfqI9UqKBbDUDW+xNaAEKtvx+rKYORPYmsD3zWwuKvJGp/VeTBXcFdV+uZ9Xf3tqjW1hOQ2bgISi168LwoiZ67fr3dytJAsGXEzP6d7Y+fJ+PWqg58fZvBfDrrUMhy7f0m8a565VjdIdoRX0+oZEUMXN+C+fMWJhNYljxp9BvK970ar1sP4ee2vnbVGKr5qeah/mTGk3XfSGBV+VZyj9yKSoYpJXHcoJEltBoxZ890OLHU5YG1FWIBhtugr6DTG5CP0Lqg0JAZjdSS6Z5Gk5BLEFrTKGBXKrids/yBFVSrj8kkZpJjRgY5v0Z+6yaaMxQcRnY0jdUJRs8zHX+NqBhishzi6uY34wIRGYgSWguHWVAJO7sNBptn+LV/9XfoJAVrKw2yuRjiCDHXQagmS2vLHOoucfbYQxyaP4rzWYO7H4YHciAHciBvFXHZQgpttXHOF1nU3zIYYzV+SoXOwC4DSQWypCozjmhBNtVIrWk1FA880Oe73/YwR+dXiEWOYRv0FUx2E4oputBk2mbYEQ1JulegZZNcaRJjkEYwNhJxO2fl+w8hRB8zKTDTAmNiZHeF4vpNjHqU6e1DxMuCqN/E5Anp9AUiPcZkBSSULjCFJQuxAdGku3qcuTjl1nqHjYtzDPLnMC9uc+xIi9TEFFGE7iikSujON5lXMVdf3iIbZZjClKlAy/dIOW1GVz7KpmZZqYNcIfD+4eC0pKL03w/8sXFOFRWY96AV52Ns16fC2wHqcX0JtI4YbPXd/TZHAJIqUBkG/pq7QK4nL28iInDDMbU0rqGPOB45iXDOSqIjRQXYTDlmd1VHXGe1/BXchruAWO0VXQK9MjuXa0fAPuOqA9HwAD8vM+5RVXBqHbjZe0daTbkjOCFnKjFFoQtvJXCdCn3Tw2uLEBh6bXb4/cx+IDgvwG3U9lvAAWv7QJZxAkFcgqnGKYWsBa1ba4e9tq+pEsyqc/cKwbcbe0WWwykPAfQ+v5fZiMIxar9s1X6xRdlc8PdMLEzQZhh/4feeqebMz2t5nAvm90TOkfZweQj2kp+Mav9UBLLal85NycyMTci71/VPkntCDrxZjdIcogtWu4dY7jXpNqdEcoQxm2AmGKbIRoRoJUhTIAuDyHLGGwNo9zA02DOGYjwlTtdpHWoyNycRhcYUCjOZkl3bYPSaoPeh9zJ441XyK9fYeO6PiI4/yH2//Cvo9Le4dvM2hxuGZD5CxIDJoRCIiYF+EyGPsdT9fi5vSJ5/9vd48Qv/B42+4fCDbY6vtlmQDWLa5O05hEy48Nomh+Mj9JtLdFp9n93h27LnHMiBHMiB3CMRlKkQa1q0UINnP3cgVargxYugyj1eirFuKpGy/5TR6O0pz3zoJKv9GCU2MGYAZgJMkc0EIUFqjSgK8mnGZGsE7S7aNBkUOe3hHq0ipX2kxVxPwDjDtGKK4RaTCwOywQKdpx9n8MbL5JeucOOzH2P1R36Wle/7DtLpH3D9zm2ONSFebNjUpkZDDiIViH4T5H0cnvsRPvXy5/jyF/6QWxdv0OrHHH2oy6m1Dt08olAN8rhJUSguvrFDQxmGGxlFarV1WgPaZnNRUtp89sL4l3ee61CvWuFCowFZAkPtJ9FQarwD1wcH9lwRNeG1oMaD8rByrS/cpINWQ60tdWBTgZXKuoExvq+lq7hf/5DsVFJpV0MjhItZmQVoTnMaAlbbbad5DfdkpTE1pUuKNgZhLGl18RBVNiPnDiQpE3IFK1DdAU7j6tyrXD9q98HdpoegX4EWvDzZuZZYY4S9QSpga/tRIxWidLdxjZRDF259Z8SfK1wDIbCsnNI8BQpJiR/fDAkKAGh9DStQqnXhyVzdilLOt58bg02MI6rxO3JRUtyQX4TFzVTZjizjm8LYm0IXZafc3qxibIoSiIf1pdy+tm5KVVBxza0stO5QAXcnLtWvm3AhbMpY176fq5lrhpu9Gqed+LqVUdfONeFJwhIbd8/XkxLg57X27JaiItjsv39m5S2QrUhwZeuryMZFDvV2aCi3fVsYpiCsj6jNA5wTKYmMIWnOMR7sMRp3kXHBoEh543zKE+9eIFmZQ5+7jpjPMc0V1rOzfPLzN5h/9v/he3/pB/iHH/sUj00mPHnrZbZ+9ce51Zry6P/6CS78y59k5cmUVtugxymqnyDX2hA9COLnuDT8DH/84u/ztd++Tt6KWT3VYq6TIEWDcXqcUbrAeLwJ6Zh5kfCeh76X46v304jb+NQA/jl0wBIO5EAO5K0opkzJJ9DaZiCJoupF7dwKXDYiY6qaBrWXGBYTZLlGZQV745xJrjn7+CJnz/ZY7DZRYgQkQGKf9yhE1AO9i1QgI4FKoNFZZDzYY2fUp9kZcfXGkGKv4OHH+sRLPYpXLiOOFmSmz2u3mrzy2QGLX/g4H/xvvo+/9g8+zo8fbtP61K9z6zO/xvDQIg/8D7/G6//khzn5A3OIvRQwqF4DudKB+GHgL/PK9t/l1a/8MTe/toWYa7B0X5P5dow2Ca9eFQgV0e0pogIWRYtbl8ZcPrfO1p0B00leAicDukCU/sVOw6/LFJ4IgfS49e6INClEpbksQVCVj944JOEhswOl+1mnw3SIJvjbiLCuRQgqRQUWmQG9DjwFIN9j0hKMVNtJIFyhqPIj63Eyq7UOAVxAJCBoTyB8xhXsvHica3wArXDzZgLwJEIgVdUS2BcnlW2FOfW9gi/sNBVu9387UE0IyQkIAvu+/o3BWpuC5ZVCeuLm4wzCNRJh7Mj+mcU8gQx+dxf0+06YID9/AJBFHViHxMB3MvwkBLmmIj7GkaJwW+jKCmUtY+Vca20teUJ41yYIMhzNYGE/eSJwb5PWMuHuFb/vwMadBB0pgvS4tdkLMny6oGqXati3Fmj6HYn16+Pmm5Ac2F2ha5uuTgyq+y0cXp3shW3Nko5992N5L3vCs8/zYVbuMTkQSKG4b+UZ9rJDGP6ITG8RyxREgTUrdkHkGFNAMaTIJxSFQEYRqrnIKJ0y2Bixe2tENsqZa0WIKEGe7GDiwyCP023nPMkLLD3xM8S8wF/6G99F8ewS5itXkNd+j/lBzI1f/2mOfvgoqjkGPUB2M0SjDWoVeALMx/jDf/NVfv9zV5k0DaofcfSJVZ7p/yecv3iBIhG0+y3iqeTGxk0eWTtDr71IpGI70mADWZnVVhzIgRzIgbwVxICQRFHkNYO2lkGt1q7VbBqDMKCFzaEuAi2XNhBJ66KS54I814wGGc99/jYqzzl7ZIFWkhHJAoFGCAWiBybDyAxdDNFFjjYCISNkc5HBeMj49oCdO2M6saDXihFRgjjTg+ZZZHGIQ83ziPx1snGXyFzhr/xfP4z+xAq8+nnaWy/DrW1u/Iuf5eQPP4IUQ0gkMpLIpAtqDcwTwP/JP/tHX+KFc7tkHUlrWbH69nl2Xku5vZHTaa/RbXUQecqd9TssqQa72xOkkkihkMIgIyiEzZNeFLoEPxIo0NqBjTLFp3HuWLoqNCUo6xcEEx5qHn0tKhGcX/3tvnPt+/OcljQAgU6DGp5jgxzrbj62uFbV35qyWpSFucqL1DTZRnhtaJjG0mnSXR9r/tour34AyA2WiIpgHO4iQkiUrNJC/knaVIfkLFaeyenp5pQQlM0Gz5ZzHaxMZfoJL17NgSVPDkwKP7a7tLjBqdpX3f2TAZ3nWjPcxRjjA72F+7vs6+xl38wiUQFZU6Y5rtKsinB9ZkBoUdzdliWuLojYlBpwWaZQtYOWStmUvcaAq/3g+lK6FTlCVCc6Bhmk7DVU2VorkgGy3GdFWdvAZ7ByhLg8t9Dap7e116y0+AKCPpeT8ea8r9bHEPm5rRBaUFxDhmrd6gRNlATJVPvK3ee4vVvFzbh/Lk3trMvZm8k9IAfmrr+SuEOaL3JtxzDfnnCkD1KkSDIgpyAG5hAiQqih1aagGO2NMCPDzQtj7twqWDq0Qtw5DHKMaHTZ+spNitEO8dwpjvz5Xyb56ieRmaHZPkLxnieZRktM/uW/ZXusOf3uo0RtgxEaUCAUhhbF9evIxU+jVYe3PZRwfTzHly5MaCw1mE8MtyefZ/nUUaa7EePNPSIdcfz+YywuHEEou8HdY1gEAUkHciAHciBvRTGaMkNMoGkOwCQE2l77F8ZAkbuXbPUCs+fboOY8K0inObvbKTevDvnGzTs0GxC3FULmCAogRxODWCyBwRRhFNoIRqMRYqR545URWZHQO7VA3F4BsYds9rj5yXNErQ2aC49w4iOPU3zlXyCylNbKSfIfeDfT7ArjL77MIJYcf/ooUaIptEEQg0zQmaJYv4Ja/BRadXj/031Gseb8TkF3rcFiM+LQqZiFxbdx48IdRju7SKk4cuY4sVbob26hhULGMU2hiKQinU4ZDcc2uBtTVu6FPC/8XNYrHgsKbVOfYqqqre47qerA2q5F8E41oSvI3e/ayr0jADF3qekdoahAtjEGpEZTuZYJXArTQAvv+yRqn1t/5xJUl3UTjABRHleNYYY4aFt12QeEAj7P6qyFxBgPqApjkHfrl+3wHDmZ0YK7Il/207vf0pXrCX4OnebdEmqrna+IiJvOcj2MKZXRorq2W4i6qjfAvME9R508ubbd5/aaNiuQ2ye6CNxTCNo09b0za3EK/egdmAyJZj22RZcB6K5vdY26m7vQQiCltCDdV0u23+V5Xqaxld7KI4RARcp+Hlgl3E8pbVxGzd2o/F4DSikPio3VdlRWClOtqygtoZSAXAiBUMrP3L6uXLhikJXV5a4K5gEhFdTnvNwFaOOUAOG+udtqd/f1q3b935S1aoTx17OF4YJYof1vjZrcQ8uBHaySEbFq0E5W2V3vkjULOmrKUgcQGZDah4oWWK+uBCNgMtVcG0l2d8eIboMojbi5mWGyCbQUIlI0Vj9INjSodkpj/mHMlU8g59+FSN6JTHIGrRtcSCVr89BYbSLEAJMW6JLxyiylkIZ0tEWRZNx3dIXHJx2ujC6zs5Vz+/ltNtIhzeYuzXaHSEWINOZI936Or5wlThJ89HtI6w/kQA7kQN6iUsLH+meBJtLlzbfPtrugBw7taFNmrZECoQ1pqhnupLRbkktvGOZfjlhtKhqHOsy1BFLkYDKfllCIyGpPNYzTgisjyWBnTHutx+3bGRs7KSafIJoKjOSPX9rgwcfmOXJiDbVwGL3eQi48BeqdqPnb3JQ77GjJyrygsdIAs2uDl7XB5AWYlEIUZMNNikbGYw+e4uLwBoPX7jDdyll/fgcxFey0zkNDg84ppoKphrGOiZsNGq2EcTTGZlsU2LoAiqKsdeC0xg5AOE1oBTzsC1xrU8uoMwsW7wKu9f/V3A5qADAArQRAKwR/4ZrbfpoasBTUAXJ1Whi7UL3vQsBZ0/QTBHL6Y+rjqlsmQueLCoA6sOvCv8FpWk2tHWMcMajXFbhrIkMN+gxQr89dsOcDQGnuunvqh7pYhMqtqtK8u/UK/f1ra+5AqABXlwBRZuN1jKs2fxUAxR9T1147YK78fFZA1/3t2xL1NXIxGVUIgKl+ODIR7uPSzUeXFjFlsJnCLIrFB/UKqiBgBEaXwdcUNcLitPfOquMYm6EiDq4YWjnZfndW2ZjK07RBC23JhCczdn0c8XJcrpoD4+Oz3Bz52Jtg7KFVpooJsi24/GLBcpRdDayB1KVaJxD77Tfq62SMtahVJP5byz0gB+4hYF8sUigilSAb8zTNCTZvXkKPbxOdbtBvSRAabVK0FmidkxY5gzRH5oZdHUGimFuJQWXcGe2CGSFEG6ShdWyRaK+gmF5HFDdQjz6N6J+C6Dhm9AWy/BtMlxosPbmATABTgDaYoswkIVN0o0WWJUCPhd4xHjkZsbk3xzdev8DtOwP2rk3QkxGdlTbtxTZR0aCVLXMjuUm2MOXs4Udpxk1AUV/iA6JwIAdyIG9N2c8NxX1uHGAyNt2zEwcenAYXypzv2mrT8kyzN8oY7Qiu5TmLa4pvNhVRniKPtuk0JYIcXWoic50zyTPGWQG5ZlfHqKZiuZMwmeRETMDsgWhZY+9aglxWiGidyThjs7/G2d4ZEMcpdj/FRNyAY20WnlhAxgZMjtCGIhfYopdgGk2yzFqqDy2e4qn7l8Fc4fyVa2zcHjG8nKHTIfP3zRHFCpOCMSMKldCZj9huCKQ0ZEVhXWwcQFGVFt66J4jyd1kWPtM+e5GUNr9+6NrsUZnDXjVNrjvO1FGGJwYVQJzhBZV+3COS+j6Y1VKH+6Pm1lFrkwqoOfBfHhLmod/fXUYE43JaWEoAHO6vcHLq5AXqwaz7SwiPKw2127mmvE5oPwiohv3PAf1gDh1w98e4z+sN3PV3BQirn8ItuakOcvUuLLGqHyzKTtmaENXc+ul1CxM0Gs69mzMXf1ARzXo7jqr4uBTqQe/BFHmLgbM81n/aiVYIhHRAF1+LwrlcWe+LgkjV96KUZXGzMn7HVUDWzoJQEm83Xmeh8Br8oC07jdUzTiCCuTGl9r0qVhbitzqxDb6bsbC4Y0PyVc1neP6sBP2q3TOhxSKY+rIdM7PJ7FoEe+ZbyD0PSBZCIFEIKTl2+G3cvHqOl85/ExVlHF/r0WrmyMialffSjPW9EdcHE061G3SbMSvLfYYbI+K9CUful0RNgJH1UY0+gSw02WbMYHOTxff+MsZ8HvKrZIMLdOJ1Hn5vl94PPQzamn5FLKGwTFNHCkQD0ZxDqQeIxDJnV9c4vPI+vvr4Z/n0l1/lxuYGkzQjvZUyvpMTxQnZ7Zd44dWXOP3AGu33t1nsrtjYg5oaqL5pDuRADuRA3hpiaqbnularfDZqU3up+vzl/qVfmbCN1lifc0GRG/ZGBeNxzvrtjBeeXSefTCn0PIeXO7SbGTKKKAzsTMbcHo0ZTHOONhP6rYSjawvcvLLFyaWcha5CNUAwAhnzkb+wxvT2gNG1T3HnZsS54mHO5LcR6grp9uusrY5QJ5bovu80xkysdSJWkFnCg4owooVo9FHyYRQLPH32SU6eGPL8+rN86WvnuHrrNmmaMbw4tnEWAlQkmTYiTp7toaK8VHzpUmtoUxZKqcjzoqbFL4oCVfpXQ6lBLIGJUkFApp/78hVSAo4KKISpRd0SGg+savg90KjXgEZNq09JXNz3VRpbIUTpqhKgV/tNTdtODWhVe0jaktn+GgIHyvcXD9BMqD4tW/TgJ7AglNd0vuLhMW5eqj7PxDu4th2wFRb8ixnrWI2Uiap1r9F24HaWTLnrhPdN2XfnduSIkwOklkTaiTIlGQktLq4f9vOa45+fK389a3aoaY9n+2nHJ5FSlwHKlVtLwC58n91cSynrQeO+fy6Q2Aby6kIjApDv5iTcei57jyMrLoVpTo6Sylo5lKy+N7bisuuD1IZCCHtPE8YpCAxVTIKtzmyDpt14qliGat18xWy3P0Ipn5Oza12fT/uZUqr2fWVB8kfW22bGvcyRmuD+v8u6cBfBsG0oGbr88W3JPSUHlUlRgTAszh/i9ANPksohX3ruVb6sdnn8sREnFiU6arAnBJlqcXKlw0rSYDqd0Mg1RZQzSQrSEWU58dw+S6IJ5uou25/NeTUteN+JX6W5KChGnySP2iQPH6b3yBC9dxWay2gjodCYwR56qpGHF5nqmDi5n0uvvMLC4dMsHrqPXvQk37X0NO/+8AtsPfNFLt+4w+54wnSUs3dTM1qPuToVnO7dT7aXsTPcYHX+aOkD5nKC17jrvVuEAzmQAzmQQIpcl9k5Qo3Y3ZpMB4asHy/l880dTOUajnM9MGQZ7A5ymg3J+u0pK4f6XF7PuPqZ2zRb8K4nWpxaaTKRDYZI4maHE72IpShhMh0TZwXtRkoaFRRala4HZRafZIx+aZMbL6bcaTb4wA+9hBlfZbL5CfLOKt33HCcWe+jxDWguURiB0Tl6e4hpJtBskpsmUeNBzj33ZU4+9m463cc53HgXq0e/k+869HW2vvOPeP3yOuN0ymB9h+2ru2zcmHBumDK+tMuhYz3SnQxZSASSwe6ISEnSokBJUVoTSq1vCdwLHyxZB31SCIwLzPQzGeIJD+/uWkNTLlgNfLrvvEZzHwm1zAjv/uGDG4NzQ0Dr2q2ArwXns4GUBhNUoa3IhYffDswLyvoZtS/273IIrlwfQm1wCVJdGkw3QV577f72HalIhh+XFNUsu/MEnjhUXaiPuTb28Hr+muVcmOq42ncOnHvScvec+MBY4/pmgj4GhbGC+xbwgcpuLqpb11UerjIYubWVQqKi6h4v8gJqoFfUnhNOs2+Bu9sjbj7wlZwLbarAZGMwhUZTphxVCoMhUlGwbwVFEdZIKC1F2vj4lNo8eetNtV+tK5WkoF4/wRhbhbkec7HPmpYT5iqSOyvJ7P4Rbk+4v3HB/vhMW34dqD9Dg2Wu7R9nMahczmb6J2Y+E1VDxkA9W9L+It7c7AaitEF87GMf46Mf/ei3bOxPJzM3IAajC7TOGE6ucm39s9zaHnN96wU68jWayzGLC01W2zGdqAnMM9y9wO7tISrWRG1DXhTMbe1x7JEOoqEQaLvJBjl730g5/+kuj/z8GWTnneTTc5jp6yhjIJ2SjgZMkcjdAhUbikSxvZPQmG+y0V7hUHeOnZ2YUX6KuP803d4cnaRHbHaRZoRgimCKMSOMvslgLNi7eZWo8wTdhSeZ6x0DNEp29zEfHZCDAzmQA7l3cvHiRU6fPg1Ap93wL8oAvwGl5liHz+4AuAp8/m1E3QQulUApQRwJkkTSaEjaXcXicoN3vXeZM4/2uD3YI24X3LcoaR5ucXiuzUKrQUPZ5/3e7gU2rw9o9cHEBjnNmBtPOfxAB9GIEOSYvCC/NWHnlRFXn9M89kvvRSfPkO19FpHdRukcck06GpGiEZsT4n7CXq7Ym8bEc322Wisc689z7ZbixYs5je4DPPX270aiaMkRygyJogLJFBiQ53e4fO08xcYNvvzKkOdfGDAcSNARz79wmekkJ01zokhRFJosKyi0QRc5WB28zbAzA96c1AMYA9Dr1YVUAM8eWT9P1qFDzWVs9nMHnjyGNpVmdIYcuOtUmuh6ESgRfPdm1xUEYDognrPgJgSv+zRS/6X8XOui5DgzmnEpvb95SA7KwXBX1IBhJhA8mH/vZFMRG6chrjVds+TU16OaW3v92n1VYVnb7wBgls1WWvFyD/jiWlTFt1zzPjOPH2tI/u0voYZbG1dXw3gXONdZp7V247ZWBHddp/0XNSsjxniyYK8VURS6tK5JvxecpjyOY+I4LpUAmiROmEyntl/WZEIcx7ZQnDu3rEFgtLVaFEVREYOZeRdArjW6DGh23Qz7+Gb3oyrntiL3lWvWfueF6+bmtVzykhQFBwWMLkxKUCMp5T0SPAL8I6GyFpXTYiDMMpXnOeNJ6vq5LwC9h+QA8GY94/8Zoyl0RprvMJqeR4g2G/lv0lQNWmqINOcZp7vsDcboTLNXaPrtLp2GpEjXYZSizg1Y/cARomaTUqWFzlbIpyuoliGbXiV9/hpmMCE60yLbymmcPEz62kWipQQ6EYUSSBVjCsHoiiA9doYiXiaSi0jT4taVi2w1e5w9dIYomqLZQ0noJAvEag8MFNOrFOkaceNJWv2nkDKmKHZRap56QNQBOTiQAzmQeyd1ctCs8oMbp2GstGKVJsu9bOxLWkpRuhdZlKcNqNKFQEpLDqJIIpUgjqDZlPT6CYsrDe47O88TTx3h5u07fOg/PYOYpKwtxDSTjMl0wHiUYnLDsChY7S8RiRE63YFBirww5MiHTyBEAmQY3UJnSxRpHx3tUqRXmX7mFmpRIBdi9CQiOrxA9o1LNE70yROBUcpWbM0Ee1cV0zMPk5sFpOmR7eXs7GyzE7c5uXiYZkdQmAHNqE0r6aDUhCKdoqcXOP/NW3zi92/z3Iu7FEXM0+9+lH/6T/8tg8EeULnnGKPJczt/NoOR1wmWP63GtJ6DvVLru4xGTmusC1sVOMBgFcj0oGkm8HhWG2oCwOddaMorB8DL97JEHh58hhYO6ZB+VZdBlzEVofvLbOzBLBypXJVmgNE+Uh1apmCd1SqbCm/UwWKl1Xfjm7W2iBIUC0+Q/Kn7aOSrmha1fomZE2pzgK/L4D8ve+qKXQHe791p8UMC6C7mtMKVBcNpxDV5UXg3tpCAeVIf9CcUVxgNUbmbuQ9MCTyrOglWXG2AosyY5FyBtHEVgk1Vo8HY/goI6ksIGo0GjUYDYwxRZAOFp9MpeZFTlPdMHEUIUWU6cmMAKIqiqufh9/fdYH/2c+1cpYJ5cEkC3GKGpMu5pYUEzvVj1orh1eHGBfSH810WMXyT/t3tAnb3WtWubZesyjxXtpflBZNvQQ7ueZ0D4bP4VFkLlBI0xCKRihhNB+wMFANzFZnusLezzfU7m5yYkywtJMw1I1RUMMi14h4AACAASURBVJ1OmWymjDIQI830y7dZebBNeylGRguI5v3E0TfZunSb0bktotGEpKsQqSbqCVTvDK0HIvT0DjpNUTom6vfJTZf+Ax9hW1wjEUN0PmGSRcwvH2OhsYjItknHQ1RUYCQMB0P6i10i1SaJDVrsoOIRUsaAQsouVbq2A1JwIAdyIG8xEQFQCwpVGaMDgFO9mIxxRb1Cza1AeY210zA6raNgMsnLc3LyAtJ0i8koZ25FcHN9yEIj4/q1jMFgzHA45mg/YnGxxXwzxsiUyXDCeJAzmdjnffH5G6w93iNpS4RaQzaOItR5Ni9eZfjKJq2swJiYyBhULyGae4jo4QQzvYOYaFQnQXb7FGaefvc/YkO8QYcBu4MNxpmk0WyzEvWRekS2O0YlmnS8hxbbdPotpGyQNCJO3HeYPL/D+p0h01TwR59/kTzPAcgLB+jLeTYu8DMEjqJW/bV0DJrRnIeBsqYiCb7ZCuhYbW7dz92vXbjkDtSU4FN74le5W7iOOiBrwYcIAE8gJTFwYMS7bXA3MINQ4+oAU13RW+ttSTzlzJgqemVq/fUNEpCe8junWTXaHidmkVkwHOsKFhCG8FCBX6fwSm78BlCevO3/3q+7sVTHVS4gJUkP9MWOsNtUlSKwIlRZr2wMTDmvwbWlkL6Xbg/lhUa5cc2C6NKK5MI53FQJAUoqCjQGR8TKDEVGB4oGY11wDDZDEbYBgVUqyJLwiPJZYslEWK1aoqQiLy0BUlrLQCNJaDabDIdD6+ZUjqooCu/WFNYTce47xhVb8/NY36t27t08lPMUVMyuB8W7YYm75s65393tyrMfsC/tb+HedveXJ89V6lp7v1QKmNo1gSqzmGu9vO7sZfeRex6QHIpnOqbcFHSJpSHbXWJ9/RyjnXWmwxwhNK2jbXr9JlpodqcZaTal3VB0W00mqznPPrfNkVtTVpdiegua/snzXP7KG3QbE7SUmMNNTDfCxDFRI8LIjGhxAbG7hzaaQigKtUiz8SEGxSLpxhWG6ZgCRSwjBE3mIsloMiExBoVEooEpwqwhzBQpbc5rGUX+YWS1W3BADA7kQA7kLStOI6XB6Z9swCxIB75KIGJT5EFoVbAaW98Y4F687sUmyHNIpwYokDLjVjJkMJJceXWLQc8wHUzJ04x+V9A60qTfb5Ebw+ZoD1XkNFoxKomYLBd87ktbPLSVMd+X9A+1iLsFN75+gV5zDM0Ec1RAM0LEEVGrCTIjWl6h2ByCnpDLBiI6Thx/B4O8x/TOmDvZiDwrQCcoEdOJBGkxoS0FkYiAKbrI2BtJej2BUgnduXma7UsIeYvR3oidnWFZDEqA0RgMWpfaVkINfQgILFB3vtPG1OcwFO8L7tchyOdOaEHYz1BQd/ewILYOeJzW2ZGJwu0N13/fn2oc/tz9SEO1vXAKwf2k9nGt3xVzMMFXri+hlh1RWQRCy4aLw5i99t2a/fD3khiEHKV2nvu6DuzCarkeyHmrhAmsDrNXFJVmP9A2226Y2pQ4wOsDF6gIUWV5EaXWX1bXBmttogKTUswEurpTQ4KIs8g48leSBWehwcUYWYLpr+nnQ3grltecB/tbSIFSEUopoigijmOS0r0oyzLv9iSlotFIaLfbtNttsiwjFWlp5ajIcWWRqiZZWHbhx2VjYep1BaQPWCYI7K+iPnR5t8jgnguJvV8bHO2fDQouCYew61CB/brrmUs/6wi3k1krQrjW4X3hyWMwz98O/nwLkIPaNrebzVFyY2gmPfrqFJuTW6R7EVKOue/wPKsnmvSbEcPdTbKdMVpr5g/1aTaW2G4kfOH5KVxJyW+mzM9vYvKvcvWFjIef6tK5fwE5v4YgQQ63EdsjisYVRK+PbM0hVQudR4yLJSbp/Vxe/wzx8A43JxkmjlnrjMnTMcpk5ErRjCKksi9DpRIwMUJMEHIJIRYRqo8xOUJE+4z5QA7kQL4d8VqUogAhEaUfsNcCViqd4AV8IH9qCbRTePeQ6juLb9yLrVKf1rGW09BVYrMLmrJt62Nri6Np8tymFF2/kbJ5acodUdBqtTiyssDJIx1WjrfptSJ2t+4wGWT0u4rFhT6R6rHbbHDzi3v0z+XsxZp08zLNhRvceFkz91SX3mOL0D2GSqeI3V3MYEIRX0bMLaG6y4goJaNLmq+g82Nc2fgsjcEGb4wL5lsJvUhQFBOSfBsdt+gqAVJZDJanZGmKkm2EXEXJNQ4fuc3yyia3bg9Is8JXinUgxfkQV7jclC/0EoRL7QNdrRZ8ZnkC4C8CIOi+q7tIiGq+uduC4NbKZlWaBc9Wu1yLC9inH6EIB4MEVIXLRAB2HMCpNN+C0J3IITcH6OtaXa9kc1gh1NBCFV/hyRfV/AiB8GCxqnLstbFlIzXoPcMNwh3tyEht7LL6LnQFCQFqDQy7PVCzFlED7K7tqsAXhHWTZtcaUycmswSvCo62/Q8rKNsg8LqLjQPKQtjMW66YlncXK2zxOKWcixH2+eyWs6ysbTCIcs+6IoCeeFCtg5SSRqPB4uICK0tLLM4vkjQa3Fm/w607d0p3RcnKygpnTp+h1Wpx7vVzRFFElmVeyez6rJQqq1obPKsNALRbDy0qci1wZMeg0aCdlQXvwlUFkdvPdGF8AbeKH7vaCOV8ObJezr8j064v3iIXEvdqZbGWvLq1o/6UdVugfG6E+9BvrjrJfTN5C5CDUETwf4hUg0KnHD9+muMnHqIQ1zHyVbpJE2O2iJhC/sd084hIJbSbiyh5itW1Of7ij0WofEg+yBndMEwva977E6uIfoKMjyLj/xjEMpn5bdIv/AGsDcnuG9Fee5R44Rj5tMHOrXW+cu1vMtpo8eCJQ+hmD2Mk01TRb0XkOzdprz3CZHSDpKGIm/NM8wbJ+HWazScRchnEHEbMoc0EReveTe2BHMh/cJnVQv57tGSsGVhnGXpvBDIh6rbtgzTQhNliVtgUlQfy7yQCymA+gZLS5+tXgY+zMZSBitq+LIMiSKVehzx3L9MKODktnFS2im1eWFeEvWHBhspYWWkg4i7rGyl/7pkneeodD9Jv9YAdFGN09lkW8phe1KLVWEHKNdYOz/FTPyto6DGjO1PG13LknuTpH5tD9GKIjqOSX6TQFym2f5/slWcxqwPyM1O6h99Fs7vGeDfj2u0bvHTjbzHe6PDY2WOYhiEtDDpK6LVixGibdmeN4fAy7X6fSa7QuWStOyWKTwIrjEYxR44NOXz4Ks9/7XWyrPAuH86/2vlmV4Hd2Po6sirjZYBIqup7E5AqbHYXG/1pwUXhqvsGINsBL1DeWuNQmNemgw84tWslLbihTBHpjqn4hwfejhiGcQHuAGn9ROwYS6CqZFW0y7EBUWrIfTVm10hNu+72lEPzM9pZd2ZIVMO9HBIb4a5Xa6L2hKpZU0R4cEmIy71swWFt0mt98EC87HsVt2EwqjrHFtGqaBNurKELE9RAvJ8j8AHW4Nz3TBX3oISfY9c/Fdl9Fe7L0BWpKHKvJbfgWqKUwtem8gQomNKSQBS59u5zSskyrasjNqK0BiiUyoPzS5JRWhUjFbGytMT73/8M3/Od7+cdjz7G3jTn7/3Df0Cn3WU4GtHr9fjABz/AT//UTzFNUz7ykY9Q5FWBNMrnkxA2zsmUAcxa65LglOsWrLUlBMIrLkxwf9ltI0rLXxnfQ9VvROnmZlwbZdYjVwGcsm6J3zMhJagylvk9ow2Fd+msb1YhqvSs3n3Iu18Jvw/CZ4mSjqyVJPnbUJy9xcgBVJoOMEiUajLfe4Bh/irSdEjk9yOEQckYheLq9m22dqc0Y8P0ioEbX6Dzzgfpdu8j0gVxV9BcK4iibVA9RuYYUfxhGuoMWu8yaR2n9cETmK9cpil6CPl2hHyGG9sj/v7v/lUml/b4L396hWu3FL1+l7lmAzUt2Noac3yxS1FsoPMGUbNDpxFj1A7NpAXyJMgVpFxGyjb/XwCkAzmQey8BoClFhG+rP4srGoPJc0xRWPAvEopUozRkowkilshY3ZWV5UD+3USUmUbci9YVrgKLV6wPr9PESQ8OjH8pWfG/aksQKAFxHDvXBoExEiFihFSkU8WN6wW//Zs3+Lv/6H/kzKknSaI567JATCQizt95mfEeLG4lzO3sIAaXab/9FN3eWZTJaMYD2kdTkoZCyyY76Sqd5CdJ5DGG0w2yhWU6715FvHyTRPZAvhup3s1zFz/Fxz/zh5iNMf/FTxzmpW8OOHp0lb5qIDLDIMs4ujBHZnYYDgo63QZLHYUShkbSBE6iWeW/++9/lRdeeJnt7R0Krcmy7C4QVP5Ru4msRYESgJV7XilbXbkoqPv+C4QpLIgRpQZbVusjEJWHCZWGt+Z24EC0t1qEGvog6BgQxuDqD3tfZ1Ou9Yx2u3JJKV1KnPXJjTNw2wj/gfAVcb34rEIBgDS6BGCly0doNaGKV3AMwNGg0L3DBIPzLiHBGPyYhCNO1QgrlTAz5wTz55059pPS/aSorqmD86UQ5XpbC6nL+oMDpTNzZ7ABrEVJeqxbkKxdO4zNENIVJIEoiqxlSFZ7BCCOo9qeVZGi3+uQ5SmT8ZSiyL3lSwhr/RNSkCQRJoY8y5lO82AZBVAqFowmz4KgYVPtGxXbmIJOp8Nf+rmf43u/+7tZWlwin+bk2YCr56/yC//1L/C2dz5Gp9+t+qw1w+Gw2iOFptCFt544UuD2bWXFsdmbXCpSD8xNCb5nApLdWksVlevhgvcplSMV4bB8P6hJEWyY0H0vjB1xrlfue2FEad2p7nMnUaSCJAbVvvZ7P/hG1j6zSjYz4/60n7xJDfG3gtQH2FKnaapTaJrs6oiYNQRtHn7gV1h96MeIFh+ktdnia5+csHFpQq7fT5EfZ/f1IXeevUEhltkyH6SQP8hkcovx9BJT06VIvhsz9zaiJ08w/WZBvpOhKVhePcVHf+ivMB0n/JPfuM6JuS6rrVPI8f2o9BCoCbe3J0y2NAvzK6hknuFQE+khwrSIokdQ6jhCtO/ZDB7IgfxZiM0odp6ieAFjNv/Mr1dMJuii1GJOCqbf2GTrd89z88uXKfICoaQ3oaLNgdXg31McSEFYza82NpCw0IEfspQ+b7x7QTqXAm18KnsvDuBJJbFZOwV5bkgzzWSSs7dXsLdnGI8Nuoj51O+d48bVMamOefXSTf7n/+l/Q+uEJ97+12mf/TDN5nHyKwkvfWbKxqWMQnwP+WSBnRfHDC5oJhzm9vQZ9oofYGf7K3z2i/+Mq+stZP8HMEvvIHrHKabP7VFMU3Jd8MBD38Uzz/wM25uSf/x/X+Qdx5pcOTfhpS9e5drrV8nNkFubQzau3ODwkfu4vbHD5sZ1RDFkZyvlF37xr/P009/HJz/5WW7evMVotMd0muEAdQW8vRGg/Ny6Y8gyI5RT+AkpydKUIs89QHakAVMGzrpXpFd+mrLOT7iWtVXABYHOLk4dqFfnuj91oa37yP4bxl/f9ce4wQZ7yh0basedVj2Mi/DX9ADGVKkrw7Zqv5uZnwRa9koD6y0QgiomRlRa+fLPug/DjLbVtRH6tkNpESjnvxYQXhufBeeeoAQg3AFTp4WXSlXzg9X+2uxUbpLqrjG2XQc28d4jxiJwVGS19r6/JekToiIQ4XZJkojFxTmeeuptfPozv87nP/ePefzxs/T7XdrtBnEsS9BdrpGuMkS5LGXOcuKu57IHFXmZxjeYKyEEjWaT3/+d3+FHfuQvsHboEGY7Y/riBuNPXecnnvlR3vH0O0piYLX7ly9d5s/94A+yvb1NmmU0kgbtTptWq2ULDAZFBm0f3L6y19QBMfD7ppxrTyhmRGvtayyE+6VcglrRNCErt60wvkgK6X86kuv358wN6mNKZqSy2Ly5SsySlHA/Bs+gbyFvQcsBeOuBv7U12uQUxgAJbREBKQWQySb9zhO0RAuT/RH9o9dpZw0kbS68fId8uMvy0ZOoxk/SZYFIzFMUE/LRNzDqOu3+02j5ASZmwM7KFVrK0Mz2yJnSai/xoR/9INPbQ77++i5H5q/Q686xl2ji7iLR8BbthROkYgWTFySiT9w6i4jnQTTqWogDOZD/34vBmALDLkI0gU2MeY2iaAALKHUc2A+Yz2rfvs2rGYPOJja2wACFptgZMfnGBRa//0lyNLJRumpkFpFaV/Do2zKbHsj+op21wIEa7VwOQpBXHhu6E3lsaF0PDFZr6LSv2oAoteNZVpR5zV2wItZlQcQsLi3zgQ9+iNVDxzFFxNrcCj/+Yz/K9mBAnkQs976TpuwzXS7ore7QyltI0eXrX7xAp12wsvReksb30aHByy+e4/GH1njwyMvQ2ITsJEZ9J1OmbK69Tr9IaRZD9iYRUafD0z/4GBsX3+Bzz93hSGeO5ollmotdoo4mHq9jeif4xqUxem+KXJin1z1NxhzPfuWfs76+VWn9/T87J6H2PgSpLgDUGRLcXLm5DjWBszC40tKb2nvm7kDF8OvqXrRBzJVmtR5wKmtaz7oPe9lB575Rtun9700VqGmJQvUevCsPfHms17J6f24HiEpf9RpxCYI4tatEHZCCgDi5gNuQhDgNMaXGXiLL78vUss5tyYRPq7pLj3bfv9ljxt0//uzwu6qfbhq11r7YV1ULISAeENxfUMUL2DnwFp3y2t4ly1mFnHWgZKZeAUAQOBz8LaVkfmGe9z/zHn7pL/9XdLvLGL3H//I3fpo0i/jyl1/lN37j33Dlyi3yXJMkpdsaIJVASkWWC5S0/v65KWoE1wfgln2VSnL0yGH+zv/+t1laXrbEKM3Jrq9z4Y+/ym+9/jw/89/+PHEjAm3QWUGeZQy3d9hYXwds7v4kSYjLIGYpJeO9MXl5PSFKUmiEd6kqN6LvRwX47fzYWgTBOrg1rabaHi3rhNAtVMjfrQWguqbW2sYzlNat8NzwHp61yFZf1bUDsxzB1DpanfvtEAN4y5IDqAwlUOjUGjVFjECCKZjqIVIkNIQkUk2mao5xtMCeisiiBMOE6xtTFIq1/hJanqQhYm7t/b/svXmQJcl93/fJzKp6Z3e/vqZ7eqZ77t2Zve9d7HJxH4RACSAFggTAS5YlXwRJk7LNsMJgmKIZMiU5fIRDpGWHZYtBUzQJ8xQIgBC4ABZYYLHAHrPYmZ2ds2em7+vdr6oy039UZVW97lkCsmQLQ/cvYqavelV5Vn6/v3OZUSGQvk9Mn0G0QtU/Slh9hNrC49jaLN0oZHnl63zrxSXuevpprkbPsfb6NlMjA/q6xfpamztLdcojh7iytc1EWdMoNShVJsGbxQumSZwS9wHKvvzlEWsNlj7JQRmBXUktBzWEiJJ0cRaEPEpex6N4PIpdP/+FD0u/cWZwi97uole3kSOSzlaP2mwtARsGTN9guzFqtkL+9k7BiUlN9P738Ovue0kKSKQIQDOgKgS4yrli94FT8HW3xQQTRY2qyJ5jUwhkSfyRq9UqH/zBD3H48BGk8NGRwVcBU7NjXFu8zOyhw1CqEKlxemqUnvKJvQDoc2kl4uSpCrI2A2qBasnij19FeAGVep2mXifs1/HKC5jgIerHn8D4R2l2b3Ll/HVuLrc5cu+72Wq2WV9scWZhnHZkMK0W05UKVla5uLXFuPSplRoE/jyXr0n+xaf/lK2tVlq3oAAQbHH80i7bXYc2xd8Xtd6FuXA/F4iHA3hF4rAHQNhhUFwUkd67OHe5X3y+53YTHeHU0UP3yvd13tfEXz8PvU0+tiedYwq2itaqrNtDWnUXhMktpYC5MgJA+vwiuCuSW5EvwySeyeaF6JJXRwqyHWh0rxSRBjaTE5aicnfoTWeLE5gTQsiJkiGxOOT5+MnBnNsfqc9+MQDaGJNoxdP27CaIGRhNLU2OTPhSEsdxwXphsSKPr3Br5YknHuOjH/sRjiwcwdJCiCWOHh0gxDgjIw8yNVXl8qUL/E//5LN4CrzUXdBoSxhqfJ24DUaRJalRJjJ//CAtXGbSNTU6Msqdd97Jvffei/KSyufx0jY7VxYJ+y0efuRxxmfGk3VgIG5GnH35FX7v07/LWH2UakXTDwdIKXni8Sc4Mj/PH/7xH2GNZRCGCBHl1h4t0rSoMslMqfM0p8atnRSQuwzNMr3WpHlcs/HNV2s27pllClcw0oIVeXYnUsCfzmuuBMjv5dZ7tpaL9y5IbvEb3sdD98quThaWEMP3eDO5LU7LZBG7wiKpGQYLtFF4+FZjYkurLVhtexyNfdpRxI0mVIMRtJrCUmbLGmIriL0RPDGLMTFxoq4h9A8i60eRwmNn8zWuXT3L5VeXeOjd70dXGphQsN3uEIsQwj477QD/0AL0mgSepRwo/KCO8g4gVePf8ojty778m5XEYhBh0QhrMXYRYa8CWwiqgAa7g7U+gsOAn72tLDEmuon0FxJy/x1Jc3qcG534yBqLCWPi5VUGV67RKVfwehGV2GmzLa31bTYuLXNIHqE8OoIsKzLVn7VYbcH/f3GA/lJJwZ98N7AcPoWyw2nYLWTYRUVgsSKZ1aTyaHKhC+wzJDnLsRapEp9jUBgjwAqiMOLylQvUqopAxEgd0u1FrLdgtaM4FCl2Bj2ubitm9ARGjqNFiRYRMqgSyxGsP4e2Bq1jBuEA7c1SGr0LYWF98xmuXzrL5maJu554G7KxgD73Etv9GGtCTGzYaFn8egVrQw6MjxHYMa7f7PPs11/lD//oC4WCZsOuN4I8S40tqn+TXyXkdRgNpmNe1Fkn5CnhZLvcGYR7xrCGE5sHwrrn5/PkNPq7NfKZEjUjgym0GaYyRSAsHGhhT/+L8QzFdTSk4c57npEd1658VAqacNxzLEoVCKxrfDLSGXBz4zKkkigAendfk+XlH2IHBfBv3Yczy0PRkpEyt4zoZKC8sDfc2Gb7Imt3Ol7G5jHIt9xy+dy5+2VrQaZxJCnJcu1LYjPy50qZBBcnQcM5Ecm8NNJfPPjQ/bzrXW/noYceBEKsvYawV5GiiRARhw8dYGbmHpZuTvJ7n3qWKAzxvcQCMDpa4vDBUV58eZ1mK0Rr154k5sFTiiAICMMQjKFcLnPy5Ane+9734pcCsGD6IdGlq/RWVlGNUR5+4nEUPjZOxmHpwjVe/8rLbJ5b4emH30rHdBkdGwUheOKJxxkZqfOZz32WSrmcreUklgPAZMRJZa6Rw++5orukkElchtD5OpOptQDyInDWptr7wpop7lW3Nt2xJIXIrUTFvZntuCLZc18dETDk2yj//PAuKSzPvGdD9/uL5LYgB0oEGBum5r5kAJSoYOwamiolDKIXsbi4xVqrQr9fZa3jsdSS1P06ze4UB5As6ZD5ynGk6RNTx4oQRZkwXqVtDcJ4jKgyO1t9bt7cRCmfsjHUGweJypdZ2VgnxuPIzDjX4hJ1r8GZw3PU/ACFj1R1/KDBHtXKvuzLbS4JMQgRVgIdrD0LXEfQASSCHWABRAPYwtpxBAprI4xeI+o+i18tIf0DCJKArjfbJ4mWTmNMEnRpjEavbxEtXqNz8xprB05ydHYEEwvMIMLGERtXr3PhW69SK5eZPF7Ga6T3lyQZO3YXN9rfom8qGagraIxhWHPlAJADOlLs1gqnpnazB5plVV4T0GIStw5jiCLNYBDy2c98nrc8+VampmqEccTG+jpnX3qFj33sXVil8FshSyubXLu+zepOiV6/wvWdmBtbsNacoDcYo2IFyzqm36yjZxewqkQQSOI4pBctE5dKDGLFmPRYurHN2nqTbq/G+s1FJqZOsGle5sLiEifm6qhalSuhz2FvgrvmDnJw8jDXry7x+S/8OX/wx8+xs7NDom3PQaDrrS38rkigbJrFxGVoESL7Q3p9WjuiAEgTgE++jlMgmGggnXXHFa9zk1mYU5tmOxLDQFXKYd9xCh/NXGmcxWAXkSmC5CFilLbbAWZHgoQUSbIhO7wm8ifnz9+bPnU4n7xwz0gXk8n6WLznXoA2pM23b54qdq97VtrCDHQPw7CivrZIePa6OIq0D45w5D23u/ZQSgtxWaosucXC7UeXstOB1aIfemYxKJAKV2ugWPPAER4LBIHPRz/6YZ5++qm0XW2sfQW4iRA9oIVgC987yIEDdR555Divnr1MFIZMTJR49OHDvP+9d/I//uNv8Nw3bqTZjhKyJqVHpZJkmYu1RkrFkSMLvPOd7+DDP/zhpH2xJr6xSufCa8QDQ+nEGcoHRzGRRXf6RJ0OF7/5MnqlxQ8+9gEWnr6PjXidhx55mKAS0Om2ee7rzxFFEaVSiTCKEEAIWS0QyDP+yEJ8gcs45OYlB+PJOEubxE3YNCWqy1qqHbHcpSxJ+pwT1eLMOutD0WJWXHfWFrMP2SyjVE5IbDqfBozI3g17CMItyPx3I9/j5CBn2FLIJEeuEEgEA70OosyAGj1gaR2e/9YNpscn8ebupR9Pgaiz2VrnjesrHD1hOKNGuRALDqo6SvjYeBWi6wy8acrlE4wIj76RLO/ELG3FjI/PMS9GkFOzLD94J9urASiIJ0/w+PyDzJZmUHgI3cTz6nje+L/d4dqXffnXlr2HdqbJsEnaSW17CAYk+a67QAT0gC6Cg1gTIuTbsUxjzBLh4E+QnqC98k+pz/4HSO/WlrXMBcNE6LiLEGWsDgl3ekRf+jqdVo/w1GlG509QLUmUMGxdWGfr0iX8UPOOx5/CO30IkOh1jaxLZEUVzLb77OC7EWtFIY16ftQ4UO9AmRtXY0yq7U0/T5KaT2YgueA9nWnkEi2iw0fWQqwNg0FMvxfiCQ9febx+8TVeffVbvP8D70b4I7SjCks7W3zr1RWuX1jh4MEJxMxdXF82aDyuLm9yeH2LmYOC0/443zxSolweJQxLeOYSUnWgfIRSMEtVW9qh4spaj+ubXZauL/Htl1/ll/+Hv8e3v+9RuluLrBnLZOUwjxx7ivn6PDoyWLPF3/9Hv8FXv/oC/X5/KDixMIh7Dnzn9+w0NJYDzAAAIABJREFUjW50k7HdG3CbuQ0VNZtFbbYxGOFSURYBfk4Gsu8pglbXVolzu3Ggo+jiUASrDqSYIU7v7lbIvlLMTITN0kkKmxfYypyji/0qaO33WJ5Erskt9kdrk9+z2CwHnFLklsXPkBMI9xybPkCklpnhglNFUpUNSBLjoFzBr7yvRcy1Ow5kCIBbm2h+E/NNbvURIqtvkfeh+BTXy/SfHL6/tWLokQKB7/uZRtmRwiBICrF6noeUSe0CHess3qU+UuPQ4UOMNRqARts+gkHSB9EGukAPQZNyaYZ/8Gs/wUc+8qtcvbrDhz50Jx//2MOU/Dr/xc8/yod+YpkgKOH7EVEElUqVuUOHWV1ZJY41tVqVn/ypj/GRj3w4OV+MYbDTov9Hf8aVtW30ydPMnDxK1RcoZbjy/GWuPvNF5o8c54kf/+v4xw8AkmOdI0jhoWPNhfNv8MLXX0Apj8DzicKIvrFgI8DmGaoK2bFkMeVqQUtvnUUofWclrlkKpWS2P2xhFSSWADW0fjOCfAvSKaTIYryyAn6719GuzziiYvMNkSlmistujwWBIf3Dd5TvcXLgRGDTwA1hIgbREqgKQk4grMe5N77E1156hp2+z4G5u6mVjvG1rz5DH83NLnS+fYXve/oSkbyLBeWzGkFVlKioQwjvEL5USAzr/S6/+Uf/G29cf4NS4DEhlvm5T/40P/bJ/4zq0acQY/McCKrcO/cQWMnA9BEIgtIc4ns58dO+7Mu/lliMjRJSIKBnrlEVU8AqyStoAHTSnxcRnMGaUwhRRYgBUi4BY4zM/cdYPcDqLkIGIFR6SMZIUQbA6D7GxCDL2cHc/u1n6Gy3iI8cQszMUQos/W6b9S9+ntLoLAfmjlMenUKNqaSEa8dAz0AgEHWQFVnsyj4v+A7iKZnlzR52EwHlcpyTgCRTIA9SOh/vYSuCkCI7YIWQSbEkUs1YaqIHgdGGXqfD6uoaYTTgua98Ca2bvOOd91OuVBBM4yvJ2Tc+z7krrxLGdWam72bQqfHKc5/CjJR54do2Iwcvcebu60hxgntHGyyFMKlGqFTvS4Eg9LotNjD82v/6K7TDLrXRErPHx2itRywbxcTdH0Tc/AbnP/1Vvvg7X+SLBy7xcz/3CTwh+LlP/CIXLrxOGMXsSlgzlAkFC0p5CAleWtXVZWtxYNGJFDLx+7bFYFGBMTrNzZ5e58Z3VxCpIMmwoosEYde8FklHpj3NUoOqW3yi+OHkPynFsIUoMyIIRJqhRqZBskVrRLbttEunOSyW1PaSXr9Hu1l4pAukdn9wAe2OuRYtCy5Gwj1TaD3cyzfToqZsIEtlaoe1rlngOFk5wKyfeZt3jWceypG0x+ZuSC5INwkhyAuR7U05aYe/zT6b9yOpSZDMVZKW1M1LUnk4CHwqlSqlUoBUgigKk8DdOELJgKmpMaSn0baHpcfA3KAmphHcTB/aBZrAMnANwV289akxfm9tHeVFVKsR6+tb/O2f/RRPPjJHP65z5doW4xMHec973seHf/hH+MEPfRghJL/+6/89d99zL0IkmZlMHLP9jz9NJ5ZMPPU03vwsfmDYWltm488/x+jcaR76wF+nNDmKN+JBDLZroK25trLIf/M//3d86+y3MMYwNTXJAw8+wHPPPUez1SIKwyHXHVfzwI2Z9CQmcpaFZMxUCsK11vn+UcVYE5uX3RC59ZCUbCZWhWFCilMUQBKn5+5TWDe5ssE9h3RN3GrJFm0FznVT7knTm/xtzyp6U7lNyEGy+YyNia0GNYaVFTpWsrVzjfOvXOTqa9tMjc/x/qc/xGp3mwOTd7HViVheWefb33qd/+g/+Xv8o1/9EUb8H2DaqxKi2LSCbWPRseZPn/1Tnv+jP6DX2qFUC5g5PMHY/BzHyuNsX7jGsbsOMjb3AFXpI0mqY1ZUXtTsuzXV7Mu+fO+KJTJ9BrpD1RtPTdECrEGbNqFZQYoBFVZIshUdwtJC2HWgCUKTOPaXMfq36PTuINYVqtUBUpRYu/xrDPqzjB98gurYMYQsgdWAB8ISR30SpOJhrCCMYq798deotzaJThwjPDqDLvfYWbuOvxXRmHgArzxGyS8hezHx2gB9YZXe+jJqaoHSfVOUVBWUwMYGVNIdGSSAbZ8kvIkUxsWBwUTrCdoMWwiKknuc5MBXx8OaOCMMCJUBLWdlSGxTMfgea2ur/MsvfI7JiVGmJscxto5fOkDLSC5ff5Hnv/QGi9d2mJyawZoGbXuIGzdjvDHDYKfJH/7+5zn/6mv8pz/3VxnxP8BcUKZnJRvW0DaWdqfNnz33Bb70u79FOOhTapQ4emyK6cPTiJrm2c98lh/7wE+xMPMEL7Rf4vIbi1w4f4Uff+5rKKVYX1uj1+sRR3EGQotm/mwYRVKJN4kJSAC+q45cPOUzH/E0r3ky2LJACkTmyyyEyIIYjU6ynQghstSLkOHaLEe+1ibzrU7V32RKafebIpnLAL+zCiXnr0x9r1VK5Eg/lwX92jQji90FkHatp8yfu6DtJF0HuYXFuVMwXD04BW6u6u2QFrbgzpG436RFrGyhEU5DW3ABcb93ZDUDfm4Qim5IDFsq8mD99G/s3hf5KNuCdSQhGyI3omTfC/KCcKRZhmSSsnlXOhrXDt/3sIis0JUlIWi1WpXx8fEkxiCOGQwGGG2oVCr0uj1mZ2f5kY//ENKD3/pn/wfN7R36vT6eb9FmizC+gZQdyqyDqADzWDYQtgV0QFiECIAyP/GTJzhywnDocAUrY8YnpviVv/sAKzcNL74hGUQhjz/xOD/60Y9ireLQoUP8rb/1Uxw/cQohPWJj6e90WPzsN6h1t+k/9AD20AiGbeTqFo24x8zCW/FrE1RKAbYZE11sEV1eI9zZQE4cYeaJGQ5X53js44/ynh94D0io1it84md/hq3tLbQxxFGETmsbSCkwGpRUaUrR4WxaFJQju12DYq2zOcjJhMHaNDubcKShSKQLpCK1UBTdwrJ1YnbRzNRqYd2e3rPustU4tC5s8X2wS76bo++2IAcCkHjEaAbaEIkSO1rQG4R886vf5PU3LkO5zOHTpzAlw2inxmtxzGY/pteKaG10WV/e4Ff+4aeYmP8WUo0RijOY0hhWLrL+yqssra3R2VjFl4LRQ+NMnT7J/J2Pc3Vrh7ecehg/qJJnLyi2bR9h7MvtI7HuYzEIJFmxHCFRKCIbEZkIjWEnvIEUAcpqTNSnr9fQrFD326AMSI2llMQgWE3i0Rkl/8QmQvQJ9QaDuERN1hA2ZG35PBBRHg1R/kWUfxw/OI0QMAg7gEZKD4EkjAZcuLSKuHKN8I7jbFcUUecipUGHCTmLr46gVtaToC7Tw/b7mI7AKkHlsRNoUUWMeokmqBUj6zI1w9vv7s34/2MpmrKllIg3yfdtTRLIqVReLMgF/+GUudLhYJEBnQz0pWwicVcyKJVoyvuDPl/4whd5z/vfxeGTp+iqGtvdkPXtDT77qd/nxuo6ul5j7OhhFo4c5HN/8mXG7nyQlWvfpLXdp7XZ4ZvNNr/8D3+H8cNfQ8gGoXwMqgMG7Susn7/AyuYGzc0tAs+jemgWDh2j3ziM1zB88Z/+Hj/yjo+ihMQrBUhP0e90WF9fT45gY9K6Gy7XUi4uN05RO2+tJY6dJjstvEXBfzy5KhvzzN2FXRrH5Gapptzm+dNtoi3UxmaazkIVtMzfW6QtzttlKIL0oefvcXHam0jAEYIMAAmnkR22LIhUi1msW1AUmcYDOTAuXNcdbne+1sXHkGe+yUlPoQ9Zj5MbuvilIRckMaxzdTd3vxPkc+UsB9nfd22HzDaSuUq5scy1xcOB/YWRsDmOKAaaJs1xyQHyFKPJdclFCUlK9lwWh2HBCIHnefz83/kZZmZmkUIRx4k1pzfo86u//Kt89Cc/zqOPPYhQMQfnJ4kjwysvfplBdw2v0qHbv0TN7yOUBWmwVJJlZSNSD34QMbBJfaTEqbtL1GslpBJYHYLu4Qc+3/++Q7zbPszUgceoVKpoDZ/42Z/m2PHDlCtlLJrtnTaXz13Hu3iZ0iP30qxYxNYr1JViVB6gHBzHv7qNCnx0uI1pReg+iJJH5fETxFTZ7jb54Ac/xMT8ODOHZpK4ACy9Xi+1YpnMWuD2qFIqH9PdwfTkc+kk0coXVpezTCFI+EKB8BbWq0iJm9u7uVvTXmtZFhOiUguca0/+Osgpp7Nopb8VhfWauUIV3lLu2r805MCSlHLvhl02wjaR32CnN+DKy9/g7NnzrG7uMDY3R/3UKQKpkD6YaonjJ04i4oiN1jZshpx7fYny2jqIKqFZBFnDExs0r15HeJJqzadxbIEj99/HHWce4sz0SebH+4zVxnj1xmVmGuPUxiaIjMaX+4WW9uX2E0tabVWKoQNNC8PAGmIhkfhoEaKEZRAv0e+t0x10gDbV8ja2JrCmASIisZVLMBFCRulhkWS00J4kpoqkijHrXDm7zKm7fZQYYIzC6GmwMdikEqxJy9UbIIpiwsVlKmM+m2pAV0EgDRVbxe9XiW+sodZWwA+wSmJjhUGjTk3inZog6gvEiAdlCX7u8pDJPkF4U8kyCjnJENTwwVfM8iHTvOU2+0AKmAqHobC7gvWy65N1aEm020ZHhHEXHUAn8NgZWNbWVrn4/Jd57fxVOlHMwTvu5vgDD3No+gBKRozOz9ModYj7Fi2WiXo9Xjt3jdLKMoYKoV5F+RrTW6W9vIr0JbWqR+PMKebufQAR+axdWKOzsY7ySnz5lRfw2l1iLOMHptnZ2UndC1zl1/yUTqzaKbAQgltlCjSppjK3xuV/y7OauODfHAwkt8zHM9NPi2G1VA48bcGSkYBNV29gSOPNra0dZO1zMQ45eckvdbEmdggcJYTQrZHcOuHWhSgC76w9NkfihZHN3k3pgAgYjmdw7hjZf47E7OrN0M9ZibAUOA6D/HxccmJkC5/N58eND/l16aZwYy8cw0mf4UhgMYbDBbW6MS8CxWKrdrsN5X0tjIe1GVlKfk5SdN53/z0sHD6CUj7WJlbA/iDkb/y7f5OHnniCxmQDKWLGJhsoC2ONHVZuvIyQEe3tFbxyE3+0jrUNIELgpfs2QqBJrMU7KFWmMuFR8gMEEdFgjcVzm5y4a5q5IxVU6RAqmCDUEVFkeOmlF7nzzEmklMTWEnV7hEsrhKZL5A3oeYYx6VEyVVTHx2yuw+oaplxDKA8ziBE1hTo5iXdyEroQSDg+MUV5rIT0k9Sj7WaLZqtJFEdJteSCTt6t/zyFbG7Vc0uyuD7cvBpj873oCJvMA4KH95ZFFUhpcd0U359FcZdKITBCItNqCEPrQmSrMV+d7keTX7OLh+dr6la/3iW3BTmA5OXaDXts9dr4ssHO2haLr77G+voWqt5g8sgJpufmGfGqLMdr1GtlTi2cpuzD9e1lBmM+SlqE7NPraDy1BaJLz4aUD00R1H3GJ8aZeOBB5o/fx8LEUWZVmVAYljeX2dre4kB9DE+oPVqDfdmX20USi4FBpJUxLQqLQGPpAn0rCYRPVY0QCIi0YRDfpN/vQ0fTGayg7vLx1QhCb6YaSg90lGiUVBK0JkSM51fwZBljuoT9NhtXt3jg0Tp+MI4VPtYoeu0lIu1TH5kDLLGVtDuGlcU+rK1gDio2OkvURiepeSOUuiXshk908SKlSgBIrKpBtY5oGOTJA8SBoG+hUpXIaqIsICsANGz525e9krt9JJpLkZmyCxqrIRowDFyKWG8oBsFaRKEiqQNSyS/SQ9m53UjDRq9JdH2Rre4yre0Ob3zlWTqRxZ+Z48TdD3Lv6fuZiDQjo2VGahWO3XE3rX4frSKi5iaeMpTLiq2NNrbzEqpcRXg+/uwIfs2nPjrK3FNvYWriFNvnFlm/dJbuyiILp+b5/Je/SLDRxEOhPA+tNUomOdyty10+rMreBTwL2vBsXHPN3R5P8kyFXADmDBODN8uik34y4xzFOcqAOSLJ3JWBlxyYFH2sHQnYDVhy7XwBkrxJe4YBjxgKnHbjNGTBKA7OrvHINK3OyiLSqt3OpSgjMMUAZmelyElX9hwAW9QQm929ytqd99s1KCVCQ0R5b3xEFlha6IylkNb0FqAtI0qFP2Wa5vSXmb+6e4e5/qaWFylV6iqjsdYShSHnXzvHZGOc8fFJEl9KieeX+PGf+klWdUQHTQmPqgjwsRw5ehIp3sDokO7SFp5cp3TXAQI1CnodowKEEQgbpcQgiSERIiYol1FCo3WLfneHzWttvu/dB5EeRMaj326it1+n3YNnnn2OH/rwh4mMYH0zYm2xhd1YYTCl2e5cZ3JyjpoeJ2hWsCuG8Oo1gmoJGYPxR+FADTlbQh4fJ/YFHU8zNtugVJUILwlEDwchz371K+zsNInjOFtPbrW7Ggd7CvMNqSwYWpdAFrScu8Ul7mi4a4v3KOyjIvFwc564sWVXwK51nFnJ9i6Zofu664pude4execV19d3ktuDHFiQwkOYAD/0OFS2rKwuMTE5TaOzw+T9D/DQw4/yYHUMH8vyjRVG64YyipIaZXLsMOWxEQ4dLjM2usHy1YCDE3dTmphkkXWEBumVmBw/iajP44cSsb7Fdq3Kc2dfYKKqePqhpxmtjeb+ofsIY1++p2VY++TEU2Ws7WFsNz3v6jgg0wXWLEgrOKMCDFDxT9L2z+GJDuFak5vPnyU4egbfBxPeAGGQ+EirgDZIDaXkEBtRmgBNJ9J0t7eZHosJpkfQQRUh6gjt0b7xdXb6IwxOjDJWqRJbyZVrfZ777AZ3VNbwJtuEIzWOjjUorUUMvn2TcnsKK6rYmZMIozE6RExW8E5PEiHZWe3TUgGHxqHsuxR/6Uj46pbgal9ykaJ4SMoUt+eFpbDD+fEtqRZZ5kWaHMFI/N7T/NvGoK3NwIwfKNDOr9yirc5iQc6dv8Jg4mWsOs/G4gYHJqYxVuGPjHDsHe/l4bvu5c7SCButdd64uMh771+gLKuU1ST1+iZ+PWZ2VnJsvsar32zS34bqySOoA+N0e32UX8UrzTPZOI1Yb1NqdZiZnuLwkWl6zRuc+8p5SsbQ3mnS2tkh7PcB0NomLiqpllggIE076jSNmYa8AJAzFy33+xTNu0BZ6ca2IEIKrC5kAsJh1L2gvOhyksHvXXPk5s8FC0Oe8jL7nEgz6di8f27ucxKxi7g4cGJzIpOvhRywFOMzMktGzocyt52EVCVjlAOqBFRLKfPPMnz93gxH7tlJXwU5ISqCsN2fFyKvTZGNjEhd59LPmwIB2kOwhlTOwhkG9szZrSQHd/nt8vnLLUvpxSAEnkqy53h+Ushl0E/SBBgT81/9yn/NL33y7/D0009SrY0C1Yyw7wBNIxgTgrpQWAG10mlGx79OuB3Tv7TGVnOJ2tE6QQBmcBWhygj8NBNZH6TJ3veTKiY0gk6/Rbe1w4EJgTowRm+g6fUjOuvnaC5foxlO8f4f/ihClmhHghe+0ebKN25yyL/G+H0lYhsxP36A3is30YtN/G4NLeqY2eOoWKNNH/9IA3GwRj80NLc6rESW+xZqSE+ChDAMWVy8xif/y1+i2WxmMTJCCqRNi8+lWcaK8+j2UbYmCz7+bv+oNLlAkWC74PvdMQDOlS0Lks/+ltxbidQDJdvTyboVhfu7deNIb0aKHfndZUEaWjSF9SKyxfPd0YPbghxYLJ1eB99IpoNRbty4xuP338cLF77Bfe9+Jw8cO8HCaANjJW0j0FzmyYVDaA9e3hrwxis7xPEGzc0xZmaOMXVyigs3lrErK9x58jSHZs6gKlNcunyWB48phFdiYGOOzcww03gXY7X6UMq0fdmX20X2mqnB2hJWNzHmBZT/MIIqXSRTQjHrSUILF41FIZkXZRpjT1IuX6PZfZFtf4D32nXUkx/ClvsMlr6CkILS9OPYzmewfYucNAglUEik1fQGO+xcX+XOMz6lap2w10XJDtUKeNOCmdFHEX4FgUIbmK5pjizE1OaP8uLmBk9MHKW/ERFeXabW2iKYqNMZTNDvvUZlagRxYI64XqHV1Wz4htJshSONAL9oLbBJIPK+/KuJMQZjKIDIXBMtVVoB1CaWAWVFdhAVTfUuYFaIRFtn0kwzcaRTkJUcfp4nsydU6lWWX7uI9H2kEFw6e4WT3/cgC0+/i79x/30sNCZ55coiv/25z/Cep6b4wJkRWnqCZ750kesXBNr4LC31+cbLTU49doJ2tIXZDKHZZKtTpj4+z4FSjz/+J/+A42fuo7uzzrU3XiWWHuuXrqCMRUcRQti0em0Cml32IMgBc+bjXgCAQgBm+NB2lViTPpIUE9Rpob9EnY+LzcivK5ofXAYUkVnCnO9y+hAcGCXNhkIBZJs0QDL3oy5kDrKpYjn1ULbSZkGTRUmweNJfV2E2b1tysUoDzl2T3NoxpuCKk7U3B0FFtyM3Fu6hRctA0TfcZXlKxsJkk5CDqgRsFR6XtWk3CXBg0M3fXguKi324lcVk+BnF37knJNMi92Qgci5IWfsK7cmsTSkoLZIfBAQlHykko2MjjI6OIoVkZ6fFYNBHCEun0+bv/uIv8hM/+U7+w5/+MTzvXhBlWkiOSR8hFU1juKgtnvI4QoXpiffRrryBmVxGb7QQr11EPPVDqOoWvcufJ5g8hKyMYXvPQ2hg0iTFzYSibwZ0Om16a1ucOSNRwRhmu8MbZ7/ESG2O+x9/hKD+FpBjSC8g1hCuLxKyxfjbHuLc9jZvnTrB2tUmwbWb1LoCUTmIseO0N15gZGEWb+EE/bLPdjtkzcZ4jYD7Dk+gUi25MPDiiy/xiZ/5BM1miyiOk30mRBp8LIhji7RyzxwXCaMLFM5IADYrNJe5kRUsWrvJckYERIEgFyxwMnthuP+GXY5cirKidSqrql1Yh9mnd1n7htcXuUL7u8Syt8VpKRCYWNPptFneXONrrzzPq9fP89M/+jfpiBBPeVgsoYmx/T7ve/LjDPQlBkZRrgh8b4PW9UtcjMZ593se4xuvvs6Naze45+g9vO3ed/HnrzzDX330TtgYZX1rk4NTsyzMzRDFmrFafZ8U7MttLBZtuwhhAIU1a2j9Ot3OZdZXDEq8xtzRp6h7B0GMYgnwkRxMU/NGgLGTKNViZLrC4AGfl3/3NZ54ZAm8bcKdFiJew6+uIYIp7NYaNlJJqmF1mO6G5tvPfo0b3wx518+cxK/G+H4FhI8MPFT5cYRUYAeJVkZK2r1NLiy/woffeoRSqc2oXUIPIoJAUJ5p0Cldx9w5Rj8+iJmcpOUHbJiQjtIcmBxjfkTipUn2rXEvUpDBfpzQdyPGJEBRigSEJqBWoFSSKtNJAlhEUh244PqRa4oTra0UEqlcph2wSZlT4tgglfPHTfN9W4j6IR6ayugIlfExahNVhC85/+wr/PRP/DuM+x6tXgdpBswHgt/89c/woff+AHU5wuiopswa7a1VQkZ42/uO8cobK/Q3Otxc6VOq1pg4Osnzv/15zty7wPTJ45x94VnazRbaWForK0itiQd9PM/LEJp1pKCgUS+KlAJthrMA7RWRHdTOvcDaxNVqSONoHJAYHuvd55AQSXyO4wOOtrlsRoWHZc90qNIRtd3tk0JghcDEcbYfjc0zqhTrMSCcNnuXhSIjBg5Ep8GYKgdKe3ytU1bgQNit3HUgrweRf7Rg0drdm0Jf3WeLYynSGBAT66zdQyDLzX06bi5mxNwChBXJ0K4hTb8U5i8jZMP+705cUHlOFhiaT9d2z1MomQQk97oDPNXjve99N5/8pf88tWxJ4CZR9BKt7U0unX8J+DLHTv8VxtUcRoxg8agJwVyaWnUAxHaWir+OOV5hYyfm3J9c47G3LGPMNv31DoLXkQcEwhvH7myhYoUNqkjvOBsXr3Lu+cs0r1ue/tvHCVRMo3GQp97+IMo7hlINEB7WDhB4eEogGx1qh3scO9ZgZGmLpfO/z+BbbY43TiEmA1qlG+jpCpXgDvozM6xLxWJ7Byolji5McbymSPQKFnSSUS3qx4RhlIynSgppRlGEpVDnwNqkXkGakQtyohoEfjb4xSl1XDJzl8RitUZBVmtkePKdciHNbiQdJcgVKcNS2BuFKukug5Vylkb3rALZyJ6as4Hdd07X4Xe2YMFtQg4A6rU6zeYOMtZ87AMfwVhNGHUJggG+rBLIMqOqBH4FKQWerdAyEe3OJq31RXqdLrFvONg4zNTUReIO1II2ndZlpkcsazvLnFt8hUfveZq5ySmq5RLuZQnc8uWzL/vyvStOB2fAhiQZigRWxEg1T7V+hLmSZtB+le7mIvgxfnUc5Y9iqVMVZWIMLW2oAYGaIqoex58ao710nkHrzyg17sUTVcJWh/a1LrUjdV58RXNf3eAHZYT02Nrs8+LLfd76YI3pxiF8/8MQjGBtkDRtcBFsjGifBz+CykGOHxrjB94Z8H/+4Vd531N3c/n115mKJjHlA/Sro5QXfKKoykokmPFjLnsgKiUeGA9QKiKMYtAlPF8BEotA+vt1SL5rcYGNqXayeNhIIZID0VqiSOMpmVRHzrTDJgOMymW1FBadmvVdtg+BSIiGTbCSc/1KKiUL1m6sM6cUrc4ON871GWnUOHNmljGvT9xr8tlPf4Fn/vyLdDtNJifG8b0aTQ2t7Zt0tlYYdHvYwLC9fINDszViz6MyVadWr0O9zNaZGeaPH+arX/o229ev0Wl3EzeDOE11GGuypODkri3aaLB5BqDEmgCC3NXAkBzsQ24rGWlIYIVI3WPyzD651nEYYBe+p+DP7jT/Igm2F9YSp7EQGeR0GD5zQxjWqDvAKkVCbEzq9uVaI4RIfLUzd5vU58uaYaBaIDZ7demuKaLwO0ckctV45s6Ttju7Y0Hrmv9ssvZnFoYC4EvWUZrNKcfheRudpt5liyGHV5kVptD4YVej4bSWzsqR96P4rFyrnJpcCm3J+zSU3QlX4VomxDkFk8WMU1JJlPKKB2IHAAAgAElEQVRQSuL7PnEcI4SgXC4zUq8SBAIp3Frw8PyHCQLB6FiLQed11q+9SGU8plQdR6hRpKhSFQGhNbStpWYMgTpMNDaPqNfpri4T7nwWf+xhfCEYrG1jrA91j/NnYx5sGGRQAwRXrgxYvBnz2H1jTI8dxpc/hvLBUoM4hMEFsGHyvi/FyOoJ3vmY4MXzPf733/k898z7iNBy5K57ieN5Oo0a3pSPtSNcjWA+CHkxhuNzFU6MlPHUgChSCA1e4GEMvPzKyzzzpWeo1+u0O23iOM7iBIQtBn6n2Z5uQVh1rLM1VXQ3c/NVDG3OLQYMi3DzaZFpKmHnkr5Hy18ky+nalkqmFr/CWrE2d20XIlN8GVx9FOkYbr7CXJ9Mau20tya4u+W2IQdCShqNBqVSmbH6CEopBlEPISt4ykdJPzErWUU/WkEJKImQsuqhvBBtYzyh6YgtIAJp2eyucOHGS9x76l0Efp0n7nuauanDVEqldJD3Iwv25Xtf7C1+SjRcBmMGGLMNdgMgzXugEFYibIj0x5C+JeyvoTsrEFQR3kQK7CaoigATa0LTB1ujMflOxt53he3mdSaDGmIEVDiCGHSJTYWXXow5fUeMP3KGTWAzWOfAySqHT1fxvfcgxDGskAizDPYyQi4DFlG6gRAtEDepVE8zNXMvoWzzja8sUvFKmHqN6vQoslRn0NqhNjKCX+vSHw2YC0rUAo+yl6TWM1TQeoAxAVJ5+H5y0O7LdyfSgRwAY5EiKeTj3EKsy8fPXm0sUKg8uhf4Os1Y7k5EBrBSPW92zdbGNkJKojCmu7VDo6r457/5OwTeKMs31gh7XcbHxvjRj74fiUdgdghUD6UiLBqhLFNHptna7hL7kvJYiW4n5NtfPkezHfHCV86yenWVXruFCSOcX3GWEjJp9VC7EwBb6Fui/s8BZkGJtDcLicgAQzbWUuzSNjo3AllwYRFYkQJXlxoWcg2gzfe802pmQas47FqIISjMirU2LZw27N+cuTNlwDjJ1FR0e8hB01Av0/9dPpdcg18sipZZKRgWR0r2Au3hq5ISDkkqZpO6YNg9b0JH0pKfnOUj9ykvAMLM8pHP61DMSOHu+TqgsM6H40yKY5IF46dXFiuNu/HIA0eTtiglE4tqejObEqHkgxKhZFq4y0NZi+/7PPTwAzz+xAOYeJ3YbuC001IEyW3lAOGNUR6pYfo30PYG0h9HerXkWaZBVQWYQUgoukgOUT/4GP23b7G1fY1pfwwmS4hNDxEKur2AV16OuO+uGDn6MEvRTaKGYeZUhYMnxvHU+0AcRjCA+DLYRYTcBGGgdBMpd0Bu0ph8mKnZY8R0+PoXz3Pf3XewWKphGgrP19R6UG8oSiNdOmOCu6kxWZKUVIyQhsiUsXGHWFcZDPqcP/86L738Er1eL7PA3CpQNyHFt3h/WZeEIScNSYE6R9x0Yt1ze81lIbM2I6WFF9vw0rW7V2m+Wt0GcO+J4vpMpj25p3tf7rau2azc/NBWKXybplA29hbF9fbKbUMOpBDUayPUayMYa/CUn1eHdEUkrMWYAXG0ifA8pInwhEF5AqTF90DrMPF/VZJW2GN5a4V3Nhaw1jI5Op2V0d53JdqX20EyzVX2c6Kt0lZjbIyxEdg+Nr4ETGNJStSbOAEFRhvCUCTWBeWyDq2BF4Mx+NKnH5cxWDwM5SDm0NPTDKIO6+dfpdIA5UviFui1mJnDDeKOxuoq2/E2O+E2BxoeI9M1YBoh6ph4B/QK0l5GeINEbWx7CL0FKgTvKJX6Ye6/S/K5332Wx99yAHmgQViVWDooM0A2NPVKBVWtMKICKlJihCA2Gl9ahCeJDCgsSuzv538lcQdQrnpO/OONA4zkoNDa3BrgzsN0qI3JTfjJ7Wx2qBXgVGJBghT4JtfGUURzK0amtREG/ZCbV1ZYurqO75WpVqrMzM7y0MN38/jjd9Pr7bC+dgEddZBeojEOfPA88JWgKwWxUmy1e1y6sIKOLa2tDlE/Sgq1WZtkBDGpH3G2ZgSiEKSbWE7S67KDPA04tKBSUJGMnnOzAiGsw2rFkU2GtwDYhwMKi1flGnHIynshHK4Vu1HBLtmz/NO0m7tLPKfXOqKRN2X4GlevIte5u3gIhqwExTeTu48Dxq7fw8Wabr1PRWHsEAzFSrgvOYQX5Plk7a26V8RiOTEogC2bLmTX3qIFx13r9kiRiAmRp3jNwFhxHAuttXb36Lh7JFaaotXEfZVCIKRCyIQYCE/hK8HpM6d58qknuevu01jbwcaXQcxgiDEmKcwVxxoTx2itkKIDlEF3sHRACdAxvvXp6QoajTQxI+MS9fgk/UGHlbPfojYbY4QgbFviyHBgrsGgGePbOsvtJkb0mBoPqE/WSd73NXS0jdDXECwivDiZO9MFs4GQCuX5TE+f4J7Tit999iYPPj2BGG0wkDGWGOmXUen7XtaqzBCgSDLsgUWiQQkGWCJr2G7tsLy6QrfbTea/MLqZ774Q2ILbTh7LUfhqGbIYZesrJeyimBhg99YrEIM3O3ty1XP6phDDxCEnn/kvcoVKoU/u2vT67HXgnvD/8Oy7LchB4tvqsXsGlPIKB0/ynzY9pO0TxhZtPYzxwEqkJ6kEghEa1MpVyuUAHYIQdaSUKOllG3ofSOzL97oUSUGmSXDaXCyRiTE2RgmLEB7oLYSaB9PFRBEmTl5IetCitdmnNKqwsoG1Hr6/jRFVPGEY9JfQYi5xH9E30O3PM+YLWv2Q9dduUp8NqAQCvTYgWta8/a3TxJ0OOlxCh+vI7W0qWzHCKwGrWGswuoMwbYQ0oOpAjJDuzaeAMr6qc8dMjX/WFKiZGmOzHjpMwNzBo6OIqqbqT6MoY21IKAwSj4GBktAIv4S1CitlUiHZHeL78h0lPwBzjZoU5KZomxyuiX86idbWGqzNXR/cgWSsC+IrEIRUMoDorAgAJL65vU6/oEFO/q3cXEd5PuVSQL9aYXZ2klMn57Bxh9WdG7x09gW2t3cQSJSSlBSsXb5JbXoSTwn6A02vn7gF7aw3CQcRJk59eUUSFJxlNRG7wa47G8gIDiJ1+3BWlbT3Nu1M7kIw7Iec+dQzDEiKmvvMmlBAxW71JrEbSfVkIZKgXCEKF+ziFw4oWOvaVJwKhzYK801CyIy1abG3QlN2AVebujVkgbxOgzrcjFzbnlkc5BBZzAhJYRwonMVFMuHWTGZlcPMy1HcxtN6KcQNu/B342+265J7nnu9cmXJiU7x3nvHJ5o8bsi4UwVs23+4PpOurSFbyu2XvducyIj0fz/PxfA9V8hFCMDU9zXv+yvt56NFHmJicQrCCpImQpxDRKjq2KUHQoLu0N0Kqk4pBOIHvdfDEACurKGKi3hpGHsMTfaQ5j9IvMuoJOv2I5ZevMR2PoloRuq2xZcNbv2+auN3C9C+h20v4Wy2qoUR4HthVQGDibRSdZK/IOkJEoHS69nwQFUYrdU7MjBJVZggO1Zk/MMLOTpuK8phsVJFlQ9U7gBQltOmle1JijKUqLV65SmgU5aDG1Mw009NTLK8s5WuosO6z91NhbQ3PfYEQFObaGIOLTnBWBLeuXLBy/tk8RWnuRiSGFAQiJfRuX1pyJYyz3u2Ct4Ue7F2v2Ts0ZQfpq6qwb9Mtt2ulvZncFuQglzfrUJ4ZQ4mAiCr9cJtKeRJfjWIQ+IGiVPKplQ5SDi7g+yUa1XHuOvKIe+3/f9eNfdmXfwOSk4I0UI8EtA1MRN/EgKGmLFBG+AdTcDOK9CsESLS+SSxrTM9Lmjdf5urLX0JVyxx/8BTCPkK5PMX60vN4pW2UdwkdvURntcm1f3GTu56SjNzr8epX+3B1wIKIubQj8Npd5v7a4+jmCkf9JjN1j6WBRvf6iPEG2mwkfq7yFFgBehnE1aSCjTgMooEVYzR3VviN//aTlPoVmmunaHUvMj01Qe3AGWJRpm4EQaxpxR1KMgYkfaMYrfjEKmAQaoSnCKRMA9Lywl775P8vlmS8Um26M79TOLCMc71JyUAKgpxvrAN7Sgp0ahVw6VDd9bnY7OASAuI4yTuuXCyDTTSeydqGWk2hpAYiVleu8+ef/wwlv0Uodzj36lV2dnqgJF5ZoZTgyqUed04YpBL02326zS7EcaKFi5OUpFpbLEmxMKUS0JEc2mY4ADc9I5QUaFu0ELjzOAcV2Dz+Ykg/nGmYcxCdiQOe6WVW7DqVRErKZOLioLXJgG4O/PMCX8lzUsBqE0AjRe4vr63JgXE2B+lpKAVC211BlgUg7eayYCVIepjGZug0eLtgSXFznXw+hVlCIJVK/+ZIh0nXks3ce4fiKNK1VMzqNDRImcaWrK/5h0XhCnLQWFiT1uRxH1mWLiEyV5KM+AlnMbq14iEHYcX5yAFiPoy7wV5aNdya1CtCYgC/VEZ5Pn7gUSqXCKplbNjnre99F0++4+3Mzk4jRISghvAPJuPnT+OVRrD0iKN1rCeZqXfZvvp13jj3BWZPTjJ97E6UOERQabB+8yuU6j2UfBbduUrz8jbrX1vl9BOSkccrfOX/2mShr/EiWDZt5E6HuQ++hXD5dR4YCdkIFJ12jB6ECDFGHC8jvTmE7SPsIphlrFhCBD6I4yCmsZS4+PpL/PP/5TeYEFW62w/Tbb3MwYV78epzWHyC2ELUo0nEmK+JtA9SUSt5WFWiFxqk71EOPH7wQx9kYf4wv/ALP0+r2WQwGNDv9/PYA8jmLttHRStOOqfF+gcmBf+QB+e7a925C2Tr3j2jSHidiiG5vwEMSg4neSi2ofjVrdGh+B6ZKG3cdcq5M5ErKzJiaky6X2zB7fMvltuMHLyZOBOnQsoKfnCIsWCBnZ2bbG9uEA1C/LJPpVFlY3CV1aVrhM0W84eOcezgmfyQ2ycI+3I7iU1cg+JYE2tNUPKJjWW9M8AoqPqSxLEmJKlBME8cNiFuIlUAos7o6B1Yc46xuTOMzS6wcukKL3zqC9z35DWakz/I1Nw7uPjpv8/Kay9RLkkeeqzO1PdXYE3jz0zzlh8PYLOPWWwxG/hQaiDLpzCv3YBSSPXQBMc+chDT3QRbQYUXSAIatkFfB9EDZUG+H4jBtsEKAn+DJ594B+/7oX+PLd3HRE0UCkuJVqdHveSxtbOJKdcxQiFFQBCUkb4iBPrSY0QkLzj3AnXuL/vyF4tO0/5BAs517LTYDH11ufKdODtW7q8u07HfRQpEmtd/SPKYBmMMUZQcwu5nSwKW+/0BsdbIbki706fVbLK6ucrKepu776oz6MXoWOOXPSqNEsfPTDLY6aAGsHp5gyvnN+g0O+gozA5xlbV+lwbZmnS9CLS2+UGcgmRjDJhh7eJuP+AEXxT90/dKlru8SJoK2vyiSJnEz+hY59rLXbrAoiZ86PsE1WaAZvd1xXsULSgyzZ5zy52TkooM8EIGPvZeL9hb/i3/217OnsRN7Q1KTr7myvcieSuCvBzED5WtzshXfpfEAqOStZYi90zbm905QQhySOssiLUmi7BwBE+4edmtlh5qRvqNyeZDpLFRWicBsQoyEmSMoV6vUqnXUX6AVAJVq1M/eALtlTEoEAZjk/e9lFXicAkp2gjpIb0JRsoTGP06jYX7eXi+w/mvvsTmxX/J8fuuszPxPg4svJ+zv/nvs3Ftk/mFMifuLDH3jipsxPj3z/H9vyCxV7cxOyEngjK23CA2s3DhRexCmYl75hgPwIQWbBk5OIsIAtCLYDdAdEFKrPwBBF2wTazpMN5QvPs9f423vf/jrIcdRHQC36vTDy2DXhcR9xkYjayOEqOQfgmlAoQnCYWgqeGAIHEhlYJHH32E3//9P+DHPv5x3rj4RmblKlqw8gkZXntZGmb3dfeyTH9xq6Bel+0rexfuusami0+mlko378W9XvzE7vOqSHT3KLkEuHS+zirh+iOFyEjvd6YFidz25CA3byZFP/r9Lp4v8DyfanWakleHSFMtlXjwnrfQ2e5h4j5Gx+mhNzxc+1rFfbldRBtDGEWEsUYpSXMw4PJmi54yTFZ9qkGJWCg8ApDjCFp4fjlJ3WYM1kgiexElJX7tHgQd5u8ZYeKw5LlnL3DqzEVC7w3CWpv5MxPMz9Qo33ESNf5Tib+mNMAaVPr83+y9ebAl133f9znn9Hb3e986b2be7Bu2wUKABEmRFknJFCmKUcmMUqpES8mKS38ksa1KqZKyVY71R5ylKqmsSsouy6bLjiIplEktJZmUCEIEQQAEQQIDYAaDWTDre/PWu9/byzn5o/t0930YkRRFWSQ1P1ThvXenb/c5p8/y+35/m1qpIKiCOoORfVTtCoMLLxFeGFA5W6N2Yh6ip0G0Ye0SiD6mXQPVRIj7MEaRDL8OZofhdsStS1VWz3wC1zG0iRjEirXNkO7ukMW64s3BEONWWFYBHikjKiQMtMBxBcuuxMnih6Awrd6Tby5p3GtxmNq4ATuWSsxaC+wBZtlzqwGVs2yUzdr5c2Z8zWcPUmPIGL30b6lExsYb4iQh8CS1mkOz7dLv9djd7HPu1REq8BGOxPUcnKqit92n1agwjrK0ho7Mze/xJMRIicrnhc6VyTS7SZn5g8SU2mkKFrpg9Yq25/3I+2+Z4j2sfpaL1LapNHz5vXL9IHsPURRh1VWrgEop88q4ufJh25K9x0TropIrd7fkFC4RhfKrskwr5aDl9J2oPZaNtJM22NNk95HSpot8uwJUZuDts4FZ1lbvtQQUbbZpKFNrh9UHmBFhtfZMGcstJdnjTN7fWZBlM8XkmDYHJcVaMKTz39iA6Bz7ZGip3Gsxq4iKjKG2z7RxFCb73WTzXWVVyivVGo25eYJalUq1wtEzZ1g+9QBnnniEasMHKdDCQQkf6CDYwfFaoGOMEegkRuu3UErh1R9DsMmDH5Dcvn6Bl994iyMnLhI7bzBt+Zx9fIGFQ/N4hx5GNn+stN/fQJwWSBMALYQ6ihFdwvqX6T27jlgcUDldJ1hdxERPg+rA1ZegITC1GjhthDwDRhD3X0Qw4s7V59jdPsSB4x/DlZqOE9GLPa681cNECfUAukKDX+OA8lFJljgAwyABoTSrNQ9HqdwL5JWXX+Yf/Tf/iK2tLeI4Jk6SzAqos3cqSxbLYhZboD5LTOwlN6zLjzWLzgIF61qXWAtqZv3K6ZNsrtt9U2ZpZHMrRHYXgwazN/C9JMak1sXSIkySbA+zU7503xk49C0chd/z4MBKagJUBEE1N7ViBEiFdCW1qsvqyjFe+NoXOXn0NEdX6uybO0Kt2uBt6P6e3JPvdsmYOWMgihN2h2Nev7XGmYP7WY8TlHBxpYsjBIoaRjYQognJFpgQYxyEmRBNt0jkcbS+DOzieg3qcz/G4++9Q3fwItvnX+FAdURjdR+VlTPIxpPgBAh9ETNdw7x4AULg1P0w9zD6mX+MeOLnESs/QFDxCG+d59rzW3R2dlh+/CbJtfPIeh1ZayLEPDiPoadfI7n2O0TjHqYqGKkq06UGK+0Bn/zU5zi2bFhqOHiBT6cRINwKC24Ht1LDFQJHKiLpMBQK33FoexI3zyedSjkbxT35xmK0BiVTszWFsmvds6x/ufVXkULkGVnSQ09mB15qgUiV/JSRtex1qoBmzyspnWX+Ov9MykLZlOnBl0QJ/d6EOEqo1j2EEgz6MTXfI/Akngs6MkzHmr6MiCcxw+6YUXdMEqXWBcdzCKPMZalUCbUw6WfKn8h81U3mglTKZmQPXSVn3VWKw5msr3KPYcC6NcwqvwXTLVL2vsR451YCC1LKymyu8FpFwOTvyGQ3L4MBAZk7D1m/krwNVpTjYOMsUkWJ4l0XHSmekSv4hUpcXJoqp2mF48Jfe2ZN2otzHSx719a1S95lDdvnGw06C9YV2RyeUZzETF2H2UxEBRiZ8U/PrtGlYHTr9mUoZ16alRQkmHwSlOexNVlokxE0mXJZBqEWzNhK5UJIXM9FI0i0xAlaNJdXaCyvcu6553j0kUfwhI8rHJQwSGogmwjRRpqbaCPAKIROiJM+iTyKTl4F2ScIDrO0+gBBY43+8GW2zr3M6WVDa/Uo3sIjyOpDoBzQl2ByG/3HX4flZcThBxCOInnlv0U8+Z9yw9RoP7TK8HaXzRdGtLe2WXjkBsmbr6KW2gg/QMijIA4QD19G3/gq0XgX2h4jr45cVgTuFp/81Oc4tV+z2HCpewH4Aa5ToeG1cIMqrhAoJ93rxwZcNPuCAM9RCFIL1+/97mf4l5/8JOfOnSOJE8IwTJX8sntclvln73wogzRhQV921mqTWnOEKSyr1s0STGEBLE9lkaZ+1kkyU8ROa02S6NxFyWRgcha8v21qYeONjDGpepsBmbKbk7V2WnBrO2Zrgub68TeR7wNwYLMJZKZB6ZAkMdok7HZ3GI0HeIFDpVmh5jXY2dzi0JP3s7JwkFqlhed4e5iTuxdfuSf35LtBcqNidhDf2trh5TffYn1rh5vbQ65cuEFPe7zzkaMsn0pLmRnhoFlEESNEABKETk3hrrNMOH2DxExxvAZJ6BEPt2gt3A/yda4+tUbnrEd1uYlo1EHewUTnML0rsLaF2RljxhXMUKNHY5xjFTZf/ANa97+fsbrFUL+K3w4I16ZsXrjNW+d6HHnkJPOt/ZhojvDiV9jZukwl3MLd36GnWgzcVaqNs1S8Fvvnd+nHkqas0XQkgZvg1Fs4MsBTqd97rCCRkqpU1ByJl2ccs6N2Dxj8eaXMnlofdKNnXUVEpjRrU2R0AZtasvDjzZnb7H5WmSxeSYl1K3x3CqtPdh+lbPCnybJsxRijcVwQrkOt6uC4Ei9QOIEkHIV42nD94jbRKGZ7fUi/NyaygMCRyFjfxXf97UAlb3v+e6n9JgUMxrLtOWss2OvjvDf4OHdxoawMlJj7vc82xd97eXgpBZg0PWNhbEizoLxNSu2wcRVlq48lKtPqw8XzcxAAKeAzhYXB2HcmQeaOYyL/sdd1ai9gt/NIIItaAlYRsg+fvcXb1nUeAiwLlt6+D2NKweKldsscYFjlyQI1Ow6zoMr2yro85f0rpfjNB0vYOgzk410oZ8XnFrxZeCcyeteuPeX6uK5Lc2mF2tIKsVdjcydm0IXnnrnIifkOi9UgszJ5aBbS/V5WETKCJK1s6DhzhNPzJGaK6y4wHUyQMqC1cBIhL3L5313n4Q/O4y3MIasKxFVM+AKmfxVzYxMzmsCNEfpWjNGLyIMum8/+W+pHfpLhxh8QeX0c32F8a8RmcINLL3a5/4M1atWTmF3B9NZX6e1coRp3cY8ssmk6RLXT1PxTBKbO/vldtqaSzd0NjhxYoL1QwwlaSOHhiDTT0UQ5SKloSEkgJIHj5O/mc5/9HJ/5zGd46aWXGI1Gd1eCLaOuizldntfCmDT1dcbul/MJWIvi3rvqMsEhJPYKYecchUXL2DZoWzNB5zELJp+z6bwtr830klKbtUELuzeqgpShWCNvs3aJUgO+iXwfgAPYs29ijOaNS68QRZogqLCycoCQETduvQWRZLl9kANLx7IsD0WZ+bK58p7ck+9msezgTm/Axes32d7t0h9ozr9ykTj2qDY8Vg50ONb0kWiMqKNNDymClIFTESQxUrgo2UXIRZSqoJOQKOxDskVNDvG9ENX0EFWFMH306CLR7fOInT5cCZH+AogELr+JvrOJfvhhwlvXmMSaiZ5DeEu0VzcZvr7Dy89tsZsEtIeaoAfj/ogbzz1Ne66NN9fAXTxO7K4Ch2hVDqO05MmHD3Jxy6HRmKMiY0imRKqBMIbIgHQlsVQ4StJUikBlhZog/3lvTf/5RBYnSi5CCHRi0qJSmRJoleo0t7cN4k0VNHtY2sDRcjxXmZnPKXZmlT4o+9sWylnBftkDOV0HtaaL8hVeVeFWFShBOI4JDVw5t04UauLYEIUJSeYKpZQkjhJKZDxCgk6ywmwlFxWrTNizNVf48rakHbLZcIQRZFHY5G5KqVlltpN30V2MMQg7diV3hL0iSv8zxmBVkr2zfS8wKT8nZTCTkvJRSJFp6u0sZu4GNIOSyFnLu625vcBo5hpRrNlCCSqU+dkhKPpplUJj25R/ln5aJgny8bLvWxQgIJ9LM7p9MZoFz/D2fs3EJljLQjnN5Uy/RenhWXNyxYU83qF4XFrLAZkWxfKbTdxajek0ZmNjFxW0+Orzr/H448eZa1VYrljXpAaaXaSoImQIJgRt8/XvgtyPkh5h3CVGowOy/T5CtQXCV5jkBnp4m3jjCmK3D29Mke2DsLOFud1Hm3k4c5rpjavMPf5xxluv47WGuJVtBld6fP3Lm2xFFQ4NpmgXutdusXv+BZrtJv58E2/5NGF4CM87St1dxNWCdz28yusbiju3XZygjXRaRLKGMglJkuC4DlpJqo6iplx8VVS9f/HFr/L//uZv8uUvf5nRaJRbw5RK9bw8DkYwO+8zt55yhjCTbTJCiDykNV/H6cssrEzCoIukXjmwKymkBbDMUXdp7hhSYqGEgEUxqQuAU2Jg7JzF2NS5GqVUWtFcW3d5u8Zm99tvNf3O9wU4AHJzqyEtVf3bv//P+MB7f5z77jvL0PT4/HO/zx9+4VOcPvQgvltBSYXJ/9t7ON1ti70n9+S7R+z52a76PHR4H7X7j3Dt5hbPMebO7W1euXGD2tV59j94kKoIUQyJqWHMGClAqgAtpoTDc3j1JzAGwsmLSEfR3PcYW6OnCbb/hPv/Zg0hNOgBJopJbr9E//NbeIGH2gTvQB8lJmlU50Oa6MKX2P/Bv8udyVtUlleYW/gEw2u/jeuMee6i5gN/axmnYdi8eZ4bNyOe31jgv/ipBzDKoNWjzMkzaC1gfIFo1KC+73EenasAisgYdiYhNze7HHAlcb2NVoqmI2lIiScklBjB8s978q2LjSewv5fIzUJZFpniaJXju2TcyD0rtMn9wcsKd6HcF2wtpN+RqpwissjKYdk8q9kJlVa/PvHAIhcubGdNquYAACAASURBVEFFIKqCeJpW+52MY8aDMCWBhEQqhdQpsex7LtNxlCnuhRqojcGVCoQsCr/tGR8LePaa6E0pDaEQIvfLt4rrzDhZpTHza5d59pHZw7vs326VW+teZT/QlAs22caY/Iry88AqqobZ5ZEptiat6FoGM8W7NzOEd/k5iFLxNIpiX7aP9v0V7hdpZiILMlWpIqywqESk8UR54TDbTFMGaSK7f6E4pc8n/8y+ozT7kc2mlM4tzSwwyHFf3l+Rv0PyZ5Kne807ZkGRII09ELMAwOIce4+yZS23aGTjaQwYCVKk71THMdMopre1iREaqQBZx6n6hDtbfP7CFdrzVdqrbQIxRTIkoQmmn7laVTBxj2j8Fn793RiTMBl+lkrzQRKnwWD4RfzdL3D24/PAFGF6mNE20ZU3GL7YxfV91HqC39pFJiBaHqIdEl3uc/Cjv8TN3WdYPP0h6M4zvvYUhpDnLsZ85KdX0NLlzlsvc+78gPVei1/4yYdAQeI8wUr9fkx0Gz1+kzjuUFt4mHfOVeDMw4yThFu9Idu9Ecueg640mToui45DVQmc3LpkWF9f51d/9Vc5d+4cg34/s0IVLmNKOaV6GoJQh+l8sJXKS+s4JUJ0abJRYu9F8b3SupHCYLLA/fJyshtkGbaXXRdt5esCGFAA7hnrIKUJahX8Uqpck7kGZs8sp53OfwhDXiDlW5DvMXBwdwbFvoDU/0vTG25z9PB9LMwtMQkjpoOQaBIzmUx5/+Mfo1lvFy83e+HlA/Ce3JPvVikf9EpJ5lst5BHJ3FyHs2ckjz35MJ/83HmuvP46F5/7KpdPL/CgOwIuE3MCwxwy6SGTHYwJkcFhotEUHW/jBMdxvAHKPMdS7f1MKv+GaH2C2/Ex3ga6a4i+vIWbQOXDHYRoIC8P4dKQZJQQXolxfvggxrnBYmcVxGEQi7Tb7yU59s/5e++5xcbLV6jV6+j5NkfmVnnPT/w8InkG2ETrNsIMmPTeYu3yH/PSm1X+5k8cp+67KCHxhGHeFwT7WqAqVLNsOFOjCY3BFRpRcme4Bwy+fVFSIlXKYIVhkh9MhQKqkI5MlSxKyr0xWf79jOVPP5pR+OyZazktASl4yJ7tqJQlLbt2xNqgyAI0pUAqUI6gWnM4drKD44JJEsa9cXpkGsF0FLF1e0g4TTAmNQcIkQYgx3FCdzgsDn2ZtiyJ074m2kBWZok9jDKkirzIXAWEmXExnzl8y+4/ReBtoQTkSqJJ3VSQNhd/MZ75ow2ZhSZz2cpYQWOscin3zPn0Xdj3U7jOpI1V2aDbvtgHCVvQzpS7Yvb8TDtauIEVQCAPss0+KNjW1G/bKvpKZW/fWAU86w8Gk1c2Tp+Vsr+lz5IktxbYm++1UJW8ecCI3NJgDHn8gI2BiOMk75sxdvzLfSsU/zxAP5/AorBQCFI3lLtYYqQoxkvIAghh+5HpMLbtssQmJ3GMSSKiXo8RkEiBCKYce+wM7WNnuP3iq1xYDDi88gBHnT5whZjTROxDxZsI3U+BmL9KNBqj4zv4tfegnGu4coBffSfT4NOEtyd4S1V0fIv46ibJK7u4jqT60Q5C1xGvdDFrY+LdMfEkwnlfBeQ19i88AOIE1B4jWP4Azfv+LX/v/bdZ+8pF6o+fQSuHxeMnqMYHcWr7gC1EUkckd+jdeZ7rV17n+u4i7//IIZq+h0BSkYYDDZ/5qo9wfKpCIYGhTggTjcjSKU/GY5544gmm0+mMgq+s4q8NSqbpQ/Mq3cbG1JBh0ALw5+vUVjvO3k8cx/l+FSdpEhCVufLYOW4ze+XkQLrQ8n3GWo+ELOZgnuAgXz8ak6QNm90zZue2nfephU+RZAkJUgvJHpBiZr70LQGE7zFw8I3EkCQRO90NfuN3/xGh8THy3dy6c5kXX3mKcJKgpMvDZx+hUqkBdvHPbCd/RW2/J/fk2xAhaDbr1Os1ptrw29e7BFXJ0R98iF57iVdfvcyv/9+/y//4n30YyUl8+iRMiYVPrBbx2UWYLsa5hE48kvEddGTwKy2k+wxux+PZf73BfR+A+coIYxLipkPcdFCdx5DuRzDqGS5c/BKvvb7Nj/3KHC/8f9s8fp+Ppkl/2seYiPlgAVl5F+78Z6kfOcLt9RG97hpeENGY+1PWLvxLKknIxdcEr65VifwqD512OXP/mN/5179Cy3eZtk/RXLmPowdPcXzpBL7K4TyuSPOkpy4sb0+SeU/+/GIVn71KcX7SGI1O4/PydIuWzZUZqxrHSa74WyuALtU9gCwzRwYCrJ6onNl3aC372hicrGJyECjacxVWj7c5+8599KYJrq8IvFSBmE5Timw4jNAGkkhjKJRUYy0CqSt21vZMGUgy9rCkaORsohUjcqUi7U+WevXPJLBsX94OWlX2fHv8pG5FzAADq9Qr0gE1WcyQvd/dZn0OBGY+KzH4mc08B1yyYOJzK3ymBBW3sZrGHl2jVEPBBtLqLJtLGjAJcaJRjoMsVZfOAyZNmt0lZ/hLHSpCQtJBsvfTWbCo1iXWPbtmb/aYLHNk/nk501LZXSy9g8m/J9OI8VJbsrlg9Iy2YN72SwEu9s6J1I0lfa4FRilZKXKLkLBBpkJmz4RGvUI47jGJpswdOcnH//4vs7RQYUe4PPMn+/ns8xeZbu3yn/+H70RyHJ8dYiZEoolSHi7d1CKg30THAdHgPPgVXD9GqBdxWg5P/7Nd3vvTLr7fw8gpccshCarI1juQ7k9g7vskT3/hHNLRPPqRJl/94x3e9XCViWnRHd+m6szTcOeQ1XfgyadoHjvBpfNdRt0pcwdanDnl88aXf52KnvLyC5qnL2tWD7d54P4W+1fW+NS/+gd0fEV/4RH2HbiPY/tPsTq3ipdlIjJAWzpMxiN+69Of5h/+g19hNOwzDePiHWUKexoPBcakWf105vtj16koKcx73R5zJbtsTSivpez9pbmyNErJPFNQ4ZJE6bua1N1S53ELMgtQjqIoXzt7RYgCcOz5lxlQkgfIl6yxlOYxkLmVpfv03dKw7pXvSXDwNstN+imTaZ9nX/oXxNGEVmuJREcMpj1GyYgomTLXnKNeb5aixi26zyaImL3jPbkn37UiBCJjIxIM3UlI79odpky4fOMio+0x7njE9a1tfuGf/Ba/9l9+At81OMaA7hMlhrFpURFbKP8kynNRWhINrjK49gUq6gKypXnkJztEk4jxZIILTEPBxk7CnPMLIA/x+ZdfQi80+PA/eQjZ+VHO/twLxLf/ADlXpxG8H6GOQPgCyj+DrD5ApJ7FyJj2aof6whyXzz/F1y/6HFn5EQ68d5elMGTKHP7SEQ42rrF6+Aiuu4yRHXYJmAiPNBBSZxuqLjHQBq2nSOnfsxr8BUSbwt9cG5Nn1VCqYF0BklinjLtMi4fpLC2nHXqb3SiVLGGESBVDnTHuZCEiKYtbKK9l9xshwHUksTY4Tvosx5Es76/xzh84QBjFOCKhsxTgBIrEaLTQuL5kZ3OcAgEBJkuNaudLSrbvnSepgqZNoRPKjM2nqG+E9bm3sRVK3j0AvqxoFr7D+VXZFYVqms7tIhVpWWmFNP+9ZbutzAQL28+0nv3bKjmlQS3ek8raX6jXlpXf656XW1ooXCvyd2ZMCiQSawmQM8ep9ccvAyRR9s2n+Lfc1YZMUaZId1oEXJesGaa4h3KcNADXphe1/WU2owzlvumiqcW42edbBbJQHK0VQubAclbKzG4+2exY7b2+pEhakCgsvW00CIckTphOpjQaTRZWV1k+eYKbb9xg8/yIN25cII4qmGGPp1+acHV9g//+F38UXxkck2D0BrH2SUyFQHZRwWmU76ISwXT7BcL1rxA4byHqhid+dp7heIJMJInRjMaSft9nzvtF4CC/+cVf576PrnLyxFnc6sM8tO9lJpd/C7XcoeN+AmV2INpBevtx5QOE8imETFh58BBGRlw4/yyvXRZceqXLf/zzP8An3hVA8zjN+SZLlU2OnzqM666gZZs17eEqD61jtLUEmJQpdz3Fj3z4h1iY7/CzP/PzCJEU68COXX5GZqRDFp+gtc4tmTZg2KYsLcBxsR6FSDO3ZSFEmIwIkHnRviLjmA0gTotHyvw+IHLwW7hXpgH9aQY4UwQlG0Gsk/w5uYWLLAi+tJfYeAohII4tQCpYnbL7mj0jZZb97ZvJdyk4KFKiwds3SHsN2JelSXRCFE3pd9fRkeHEobPUKjXiKCQcRyTjBK+lcBzHEiP3YMA9+d4Wu4kZg9Qxk7XLVGsBOp5y6kiD5vxh7uiAy3cm/NrvfoGzpwRnDy7TCjx0HDIMrzIy2/Q3LlMnwZc+rhrj1GLiUUL3c9tUzyr8hoNTgWQnJgw19XkfqAIOZ+77EeBRgqUaQpym0tllcvEZol2Bu38e2ZwS96/j+BuoznuI/JfoiTvUjKAeNPFWV9i4fJ3FQ2PmF6q46ihGHkQGi1ScwziqiZQ1BC6BFky1BiasD9Zojm9Q6ZxGOU1AFjQwcG+Ff/uSq0IizeTiOqkKm+art+4jJh9eKfLkMPk+rbUpfHwhY7SyTBxZ9V1K+7CS4DiCJAEpS8GzhW6H76aVkz1fEVQcKoEikJrJNKK/O6FZV0ximEwS9FSjKoJoGpeUBdsWSgeKzYQzeyjYlK254qBFfqjrLGe6vV96nqQ3tax5ueCQzRIiZ/xcyBWLWfNMpgQLg8zScuoSS5kqInpWmTTF/dLPZmBBToSVX7ANKM/dY8rKgikpWGT+/GWrxsztyop8yuLrDLibbHSFzaIiiroVd2NC33bK5yCkiFPJx1uXrQwiAzvWf9ukgZnoXDG3c1rJWderMmDLfbj3WIwsjLPpR6HwFbdxJzZWJP2qdewuB5QXVhJDuVCVjVuxMDHNjmOEfT5oElypGI8neJOI0WBIf2OdoPIG691dKnMeD903j2icZCN02dwd839+5inecZ/g8cOHUje6qMckHtBPthlM3qSFxldVHLmBDBKm3Yj+8zvUHlVUOh7SSZhEMRpDbc4F0rivJ975s3TaE/zmIoh5AqfP9PznifrreEdfARTJdBsV3Ea2niAMvsiO2aJJl1ZjCaE79G+tcejHHmV5/yKuOo3wVlFencCJcVUTIWtgHBwNWidEyZDtwQ7O9itcuiVx/TkOHTrC/Nw8J0+e4D3vfQ9feuZLTMMwX2NpIcUIpRxsIHHJc6c01UvgNMeaxf5jrVQ2lkhm6788f8qugmWW39gJm+2dqdtP6bmlmJh8rpl0RljwWd6UhBCoLIFOogurgu2fyECBgLQQWw5aCvRpSDeUu2Zx2iN/SeDgbgv/W/9O2m6T/4RygBxYk2eSISVjNFESMh4PmQ4SfBVxcN9REIZBv8ekF6IncGDxaGG+ye6RHoB/nnbek+9byQ8KMfv794B4SnJwX4fFRpXmUo3lhTqt+Q5dVef09pid1/sMzYg3t/rsb7SZr9XxnBhNA0dtgBkxTgyhian5EqfaRtVuEW9EKE+CK4ljmDiC+SMumJfBaFb27Scxh4iMxJNVwngVAomUMVJsIKiAGWK652D+P6DWWWby6mVMdxM6TToHD7O6WsXXb+Gqk/hBDaUqKOUTxy6j6Q4Ot3FlH1dpHKEIkwg96RFHuwiOI0SW4xpZKAj35NuX0pkkhMB1HeI4xnMkUVzQ58K6opABBCVSHVsDRqOz++TgwKrKJr1eZNYGKdM4A6UyFxklcrcfMoXJcQT1qoNUCjdQVBsuriuYDqZUHc20H1KrO4w2QsJ+hE4MSckSoYRAS9CJPczJGVxZOl/sh/bose2wjFtZh7Axs6VvknW1hD1KtHBJwS5+zjLzs8SYyXLUUyiv+XeZuV6W96z0hhnTnT64jLXyJxlyK8Db+1A+jwsmsnyya633BGZa8LBnz5wBL0UL8v6L8r8VrbQuPNZlI9cHbDyCHVprbcgVbY2UTta24mWkjL/MXeBEdoPUrUrm1haTK2nFfWHWDaVcBm3G4yAHFuV3KvLrZpMBk39Xl+eEKX0Nmf8dJ3Fq1dIJ4WRIJYDjy6ssri5x39FFZHOOXR2wvtWn++aQvhnx6touh9vzVDyJ60Qkso4bbYMZ0Q+7BP6Uiushq01UdZ3o9hTnqAORItIQVyTtgwKjv46QZzl65H4iLYmFixKGyKxCYFBOjBQ3wVQw8TamfwXR+RiNuWV6z19m7G4w32izsLRIeKiBv+BSCTp4Th3lBggZEMcJw8kWjriBK7tUlSQBxtEUPd0hia7y6d85RxjXWd53gHZ7juFwzHg8LixP2Rq15HnB4qcKdBEhZb7hWSFKa3bWWkQRh5DNghxol9ZD7u6W76N2nhbvuBxfYh9miZe0rkvpGjsdcmtXaY5YxmNmzWbttrtuyeJnR+CbyXcUHBT+jLZqIW9TrsTs/5gFBcUCMVozGnUxOiKotpHSya+PopBBb4fJeECrs4jjeAyHXW7dvEw4Mcy3asy1F7h47QK3b19n2g9xnYDHH/obRRXC3My6h1W5J38NxNz11+Kzb2Xp/NWKZcIMEAsYOy4nzj5AxxM8pLKFrRMOJiGPrLj0l56kF25w+dYNTM9Q9as0KzU8d0SnXiPRXXaHQ8LJLpHRePXDdN57h/4La8Q7EUKnBXjMvI9sCuLuZ5GNAdJ5CMNBYgJ0PGE0dakcOIHn9hEqgXgd5SSI0AV8Ou02k42Ena0dllp3qK3uUj96iMm12+iFCrEYEpm3QA6YTA39/hu48g7K3KJaCahWmhDu0gwlqr4KYpquYOn91b2M71Oxeq1SCqM1rqPQ2hSslQBHChyZMqlSpfMxSQxxZIi0wSRZWlPKZ1jKtHquwpDWLwh8Sa3uEviKXi9kGhl0YlASfE9SCRwWOi6jsQElaDQdqoFkOo5YWFCEw4hGxyGexITDlDTqR3F6mJO6ISWJRsdpKlPLB5dz/tijIM9eUwISeaBhhiryANR8nMp5zE2heGe5V01mOcmvMOkXU199UdJhCwU6SbJz1LLXJQX6bbEE9pvZSysr6HkPS6jAWJZRzAZU5veyCnKGOWYAhP08b0cBcGZckQBKbhtWpLQuaKboVxkb2HaLImg4DXwvZZRRIqulUNyjeJ4uWNVSn4zW+TgLTOYWAnFWGRspskD0Wf1cqnR8pJBZilJb26N4VxaYkP0lRREMW+6LBQemNB75WJX1ohKQKFebrtSrtJcWWTh8iP2njvGRR+6j4yk8pSBJQIwxy5Lo4JN0p3d4/epVKp7ggNeiXmngqjGm2SLRO9zpDonjTRIJ7rxD+9079L98nXA7RNR9EtfBzBlEPSTe+UNUa4pQD6PFEolxiJIRk8ijsnoaL5iC6IIeIZ0pInIBj7m5DruXRqxNYlpz28yf6FA/fIjJtTVY7RBONhBhSEKdyTRk0L+MJ9dQ+hoYCDwH31U0QoGYP8Ctm5d5/ivX2e1N0Zn7mlJONi9NNr9kPn+10QjpZMo7+fq163MGLRf0Rf5eCp/+Mqwr/ZYBj3TfsKAwW09Gp/Mk2yuklBl5kgLY1NJdfnJ6A0OaECLWVqEvP9laG3W2z1gwVMwz6+qoSwvX4uo92aG/oXwHwMHep6Tl3aPJCOU4eH5Amqs3zXCR5vG1BjyK/5c6pJOYcDrg1VeeQpkdTt7/UTy/AUISR1Nu37zKi8/9EeGkyw999OeZXzzA+tpVnn7qN2iteBw79m4Cr85LLz3DG+e/hiOgUvX58Ic+jpIqr+aZsw2lgb0n379STrP3Z8nb1o410/1Z1/4VzRm7bhIDm7Hmy8OQthKEWrA73IXBgMlul3G/y6FjcyzNzdPyWhw+3uba9hrn129yZrlFRyY46n6UM2C5LUmSbcLoMlr7SK5QOTgkGo+JBjFUJHMnA+58fUin8gKVR6/jtqYoN8A1kmuD23jjL9Bc+AlE8irJxtegdxlV66CO/ENgShxeYqPf49rNEfryGvvecZmR8xH8+RWQ8wz7t+h3r9KfamL/NOHGVUx1m7U7u+xrPsiZpWOonU/jOS3c+5eJpy8jkCj36L31+x0S6yaTVwYGHEcRxWkEsuNkjK4ETxoW2xXqriJGM40SwkhjtMPOMEK7EEYxdmVpa55XEPgKz1dUqor9+yo8crbD/qUKn/mjG/RHMUZDLVAstD32L1XxPcGXXtggig2tapXlRZ+g6WCEoN+domoCPY1QUjONDBvXh6nlw8vAwVinQcXaZNmQLIMNQhRccKb1pmOR/S919bGFqsisJun1KattlY7SeUIKrJI8kLlkFSiRU3u8ivIm6AxICVHeZt5+3uZMfH7r4hrr0mQ/nwk43qO4Fg2YZcOt244FNBYtFKttFrAUzy+YUq11zuru5V6KbC0lVtSkLiVCCMJQ57EC1m88Ra1A5mJVxCpItJbF39m1EpFmqzKQ6KTg/Y3BURIh06QGUheWMZO++NRyIQQJ5HoLOtMXhCwXscbSy9ZDwYjClSQFmFmfpczesSHRafXcnPwVNqg1NauZrNia43pU2h2OPPle7v/gh1hyJesodrc3kcMxvTubTMY7NDqSd5x9Bx1/nqMPzPPyjTe5sjXgyFyNVsWg1IMoZ5fVBZ8oukIcb2PMFMwtqod6hNMp00GI11LIqsvmawNalReovusmbi3Alz69yGVjeAMvfJbW8s9gwi+R3HgREXdx2vcjD/0CMCKanudWf8rGlTHqwHVqR5tM3PfjL66hdYPB7sv0+19llFSI5X6i7bcwjW2uXt1i+OYmJ+bhoZNVpKzhP/gY/9ev/V1+4Rf/Oc89d55eb4jWmjhOcBw1MwdEBqiMznRKXVoTomxJK637bCqb0nzOEylg44BMPt8La9XsPpEkcR57UF4lNluVkRDHBUApLHPp3pLG/0ikjcfJ25XNoSSr0WCD1w251UuINFZKl/aXfE3Z1lvg8E3kO+xWlD6w193m85/8n9h/9Azv/OhPoZQkHOzgNRcLVsMOdMbM7G5v4AcVlKOYjNZZu/EMnrNOJEY4vkQ6gl53iysXX+OpP/5tTh47xuOP/SDzC0uMR3eIx+ucOnyCD/zIT7Db+z0271xg+/Yd4lFEvVKh2W7jOi46SZhMR3iej+9VvrPdvyffF/ItgOrvCkmM4fmNAb/31jZyOmZnY4tmS9Ps3kHsdsHxUCsH+OKlAe1rA1Yma5w8dpS5ziL7lxZ4Y9RjcO4LPDj3PPU5qNSPIYRPMu5hRpcQcz+KPPgCyeVzTPpbDPoR20gOnawSSnDiHiL8ClGyRqKXOdL4EEPjE0e/jxptQ28NSR116AcxZhf0C2yFOzzyZIVHnwyYP9hCaIfDy+8jmdeshzGD4Cju/FkOyoSKO4//4CdQAjA3mIYv0O9+kV6/yvyt+/FOr6KCEyTGx8QjXLf2V/1Kvi/EHrZSpO44IJCOIowi5jt1hJTEsQad4HuS5aUGTx5o8NqNHTaGEyqBw4GWz7Pnt0gMjCbGlp/A6NQ958iBOrvjkKDm8s53dHjsbAuvqpA1l8gY5uYD6p6k6isaVUWjBoEHg2nM+55cZKHtIlVCVQje+65D3Lyyw9W1EBVDxXdApSxxpeaysK/J+vUuYHA8SRLrjLTLOOSSe4tObIadEpjJxkVmip/9jtb513IdQAqr1JNWIhc2q4hVKAp2/25SBCwWrP1e5RnILBI2Y49GSZUrpqkyYZnIonFlEqxMeBQOX7OEh/WzttmKDCZn1qHE0FKuXUA+bvkTSmCpSN8IWosZi4KyVv2ShQAy64oqrACIog9kn4sSW6yUQEiJ4zj5PTEZo08a1E2mICU6wWTZmjwvINFJ/u82m5IQEteRJDqNNUm0JktplenvIvMnTydE3kcMMi1BWbiZZONbzoRlmW9EQV6JkuUAIXF8H1Vv0PqBjzE+/CjPv3KTaNBncV4grl5gsrZB68Ahqgf2k0wUr3ztKvvHt3nooQdZ6RxikBjObd8hvPkVHph7lvqCoFI/SxINSca3MPEmovWjyMPPEr/2VSbjATu7htBxWDkREEqJO95GeE8xSV7BkadZbZxkPFCE00+hBpuI3gbO0mnk8iMYvYHRl9gMx/zwR1s0liq0F1t4ssWhfe8nnk+4GcaMl5dorIxYkIpAzRG4+5DAux+/yHD8OXrrb7D12g7jL3fpD1/msff9Ev/b//4efvVX/zt+67d+hyiK0zF0VD525bmolEMSx0WWKpFmCQJyt/QUx9kVMHv6F8uo+Dch0irkaE1hDDRZxewii1Zuec0yUZGB5LyacrY3SGURs21jer2kYAXSui8y3XtNmP1eENopiWPBShEPVe6HXZ5pDM83J9K+TXBQDKDRUzBR9pfAoAjDKZujiPXPf5ro4lPcf6KJ9IfI6lmqD/w4yXAIyQR3bg5VX+L6tWu89Ozvc/DUEk7g09/aZHDrHCcflziV07x1+fO89uobbN28DpM+vhrz5DsW8Jt/iFKHGe2+RHTn3zHXHTO6NGDlwf+ap5/+JaLkOq35OhrD/EKV8XSI6/pUq3WUdEoVOO/J96Z862p8ztgYUzoki3/PmaTS/mCyLxYmvyKDiDX/iW9w0H+npRzodP7mBluTiNfWuvRv7VCpOizIBD9WHDv5MLV6lSBwaHqSFlOqvsKYU4SRRAqFT0xHR+w/+xG+PrxJd2eLQxuXOeSNaTdXqMx9jHH3HFQfIplzwbmMM92h6ruM7uySVFySjT7V5VdQ7dto3WZ0+7dxFk4weemrBAeqeAc7qEodYV7B8DpxtIA32eGlcz2YJrwr0VSOVwlau6ypFXqBYF7WaYsh2uyQxLtshZpmsIwn9xH4HyVY/EHmOncw9/eoNJ4A4eQKW5lF/esuM+zxn3N+KiVBSBKTzm9HGALXod30ec+7H6LVrIIQRLHmrSuX0KMR64OIJ4+2OX3A4dABj6Dhs76+wj/9vcs8slJFNF1ujmIu3x6jhOTwkToHzs4xHE0IopiKMRw9VWV3CD/2I0usr03w3NNcCAAAIABJREFUowQlBc15jx/6wDKNxQoXbo15zxMd2nGMG2vcBcM//pU/5ad/bpXNp7cxrkS5ijg2jPsho2HC2rVdwklMEuncFSF120gzLlmGUKr08DVao6RVDO3eUT7wczU6Y+ZL52FpCpqM0QPy+91tx5olnkUJVJSYRcvC6/R3SVq8y7o1zLD/JWZQZB3Iufwymy5ngylNea/LoFNecI6i6nV+n5z1zK4wZSXY5MAoVaIzxUgDQuftyueco/K89BjQIks9a3LMkytHhlTJc103Axcir9VQzlgkpcTzPFzHw2hDOJmQxDGeq/IxMcaQxKklQQlJNfBSdpc0l/10MiHRFghJEpFgSEiSAviYzKJhM89YlyJB6hpmM+HkwapmNsg7H08pSUyS9SftK1IhlOLkx36K2soBpNtgcGsdz4FKOKIVNageP8vSk3Psm2uwGDg0ZEzFUxhzmulU4gqHmukjvQDnwQ/z4ugm3TubPHj7WZZrFRqNA7iNh5j0LkD1MfSyQOxexs9cNkcbQ5JAYe50qR55HoL9EH6dJBrgtFYZf+Ur1E508M4sILwIzAsY8zWSaA5v0uXzz/d44MiUM/dp/NUuXmOXO84B+tJwxKnjsYtOusTxNptRTDvYhyePUK/+HLXDXRb33WHzzFv87Y/9V9Taf8Ik1LRabU6cOM6VK29lGbyyKuEydYE0WqcFD4UgsWC4bA0kqysCmKR4EYnWOdguxw9Y65cUMleubWVimTH4SghirdFZpqEUqMs8pa+1eglSAJvDX0OafMBokiQFn1IqpFS4joOUCuU6eJ6LMYZRL8GopADNAoRJkznERqNEmhkpW+aFG2C2z6ks+1dIkf71bvIXshwYHYORmGSIDq+BdEFK2s0pzcUON+94XLm+Rme6zdJhhdg6R3TrBiIUyMAlXmkh9y2xcSFia/sG++kzjUKEM+K+sxV830GPr3Lx6y9x89YOrbrggYdqLB5sUmusMRqH3L76v5KMHVquIJYjnMqE0c4/pdn6G7jun+LJmwRBwFJzP6NRl/n5lRLjIf596XX35N+D3C0CP88AkV6QmSGnTEdjas02AkEcTrOCJ+nCjycTRt0+1blOnlLOCSpEYZoWUSiF47hpnmJr2pvZ6f9y+xglCS9u7bDeHWMmMWfnXFaXKxzzApzAQ7gOjqtRcowUEyqOwPUaTHSVmAHdUZ+tMKJR81msebSr9zHpjHH1CVz6CBERqQUG/i4tOUU0HiTyjxKHfUS0RXf3earDERc3I2obEdW5KV57h+VFl/6d12ke9dGjAck4QfkxRmkwR4jDLl/+nTUOHazQnlO4CqLI0Bu+zlxjH00kwkgMCiU8tLNKNXEZTqd0lU/NcWnKNo5bxzgJ03gbz11A4vz1xgQ5vfUdGgSRpQvN0pdKNEE1YLGjWLt1i0cfegePPXYK5dZwvY8RR2P+1f/yL9gcRSxtwZIDNWVYkJK//eRBKnGI7DiE7So7wuO1r6+x6Srue2CB7d0eLTdmX1uhHMG+quB1rXEdw4ljFY4fa7B0oE6jmjCe9vmZ/2gfdcdBrcV4nqJ2uMUv//1H+dQfXWbY1wgjcIXBE4LFhQpvdftIk8YvmCRdy6libftaKMCWKc+ww8y6tjuLtEp+zvCnrL6UIj9XElvMwaSWCFGuf7Bnj9prRbDYomyxKOIZBFKq7Hlpdi5LOKauOOm99TeYD4XSknU+JywLRsSQgpnEpG4Zicn8/Uv1BJw8LeSsRcSCISmte0fWFFWAI2nH1qZn1KWaAYbcVzoPCLZ7bPaulOPiuQrf94gz5thmRHJdN02967g06zWWFudZXFig4gZ87eVXGfUHrC4tYDSEcYwUsNBsUJM+r1y+xOED+9geDOiNRlR9nygMGU9ipgjCJGYaRUzCKYIJGEMsdO6mjClcNpIkrfGRYTkkqUKmLQArvxoLsnTh4iKExHFcnMCnOrfAyuOPIUSAHE5YEX0eWGlwdmEf9UadSDpUfBdXjXFVjO84uF6NcVLF17tsDqZokdCo+czXK8zXHmDcGRLo4zj0MdIhpMrAH9IRE2g/yjg4hY776N5turuvUHFGvLoesdjbxW1PqXUCWk3FaOsCzZM1ov4OTkWj3BBYBNMmDHd5+t/c4t3vnaflJEghCacheniBhcZBWiYdF4yDUnW0WKCiXXqTEZFTYc7xCeQiXtBh4cBh/uf/43/g7/ydX2YwnLC1tZsp0DadqMZ13dTak7n5pS59SRE3YLJaGtn8lZm7u7U07LWnla0Js+lA3768LKzOkx3svRhIytmuZDojEp2BRxsPY1JLlVKKSqVCFMW0O22W9+2jXq9x9cpVksEUoyOkSgmCJDZZ+uls77B7SgYMtNYZ4SOKNt6lov1e+Qu6FQn05DzJ8CLEEWrunRizhufXecd73k3NxNx66VleutbnMVGl1YlwnG2S8RDRB20W8JtNBrdv0hxukvQ1wbyi3jLUvIg4jOl2l7h07TX2H6hw6niNA/skzfaUeDRguq1xAxdPCDx3QBhMUSrB8c+wtn6F4XBKGCUEVZdDq6eoVZspIhRF9c2/3lrF97IUizU90EpJyEuiM1Ov1powDomiEGPSPMdxrJl2B0x7u8TDASYMkdJhvNVlPOpTa9Tw2y2C+Tn8Vovendv07qwjm/NUGm2qjTqVehXX85Cl1HZ/2SKEoCoNnQrMN12ONFzmW4qOEyCd1OwoMhN1nETEpkWSBGwOE1xhGCmPcaXGQsUlFFBRFQLXw5gqsZ5jEO5y6/Y5Ds8fZso1fHUQ169Q1YJGMmbzVIX+7eeYO+QgGaFNzLTbpydcpIkJhYNXAeklGBODFkTRJs/90Q1qyxUWj9RoVB2c0CeoHmYnvMIK78bFo28ihsYQyBoVqRC4GCHxpEukYcsY5p0AKRTGjCkt5O9fKU1rbWZdD3IpmZHLbijfzsikDG/qYw0C4UpiHaOFx4fet8xjpwRmcJOL64qP/62PI1WLH/9PFG889fvcWbuBDjVnEkOtUmF5ro4eDVPXGuUhPJ+O61J1QEynzHccOi7UPRiHhssXu6xthTz4YJWTR6qs7AuoNwzRaEq4HbI676ESQ1IDoRVCKq5dHxKFkiSRxEagHInQhv5uSBIluaJtfZBt5bWZ7SJTGkRpHNPxm2XgraW/YNwzdwGTFSIr3bOsXux9keU0nELYegn2Vc4CkrKLgn3RxfXZ39an3z7vm6yLvCWiUGiLj3LoMGNlFZnuJIWcVYIotS/LRV8EbBfpUm1RqtSiUFge/izLlqC4zsZ4KCXxPIdWq46jZKb8pQ1xHCdVlmNNo9XmgfvPcOzoMeY780zGEb1BxP7WPG2p8aXARAk6Tmi4PiacslqpIX3FVbXBoFLh4MIcvqu41Y2Y4DAKp/SnI7b7XTbW15mGU3ScIDAYnQWkZsAt0YmdLmmsSjaeNvjbuh1Z1JO/4www2X5LKfB8j4bUrMz7HFutcbjtcnC+zkqjnVrJdIhUDjoJSYwhMQFxHLA+iAikpudWCFwXN3CIBFRV+rc2VSI9YWewxm7vEgfb+xlzlYpzIrW4GENS2WDHNBmsfYXlYxJhxsThhPFuhIol0iRMhUNQEyCjzPc9ZjRY5/nP3mLheJsDhxt4U4PndlDBIv3wKvtFiAtsJ1OEUPiiQiAlCBdtBJ5UdGNNKCVNp4of1HjiXe8D6aC1yTIU2WJnqTKd1q+S2LAUSONLpJRp+lELnpOEOHftyUBoto7KcUh7Vko6I7PaBbnLXzb3i9igzFpmQaG04II8wUHqsFLsN5giO5EQCs91qVQClOvygQ98iEceeYTFxQU2Nzb5jZv/Dz0BruNg0jAZ0noJqRWDbC6WgY39KwUKBoHOrSbfSP5C4ECbHkn4Onp6DhHV0L0jaM/g+Aknz5zACyc40wHrly6wOfSo1FyE72PUFD0dEe0MCaYe3mAL1d8h7i/gL9do1kN0v8/2oMH1bkKtpTl+3OHIEYHvj0GPSIwgiQ1N30OGI0IxQPoJSo9w/Qd4840/Ynt7EyMU1UaT9lIN1y+Ky5SH755874k19UOWf9rEjEY7ICTaJETxFIHE85oIBNMoZBJNiY3BcVxc6TIYjNi8/BbRxhpiOEBEGoRLdGeL8XTINKhQX5qHwyNENGZ06VW21zYIm/uYP3gYtEGJ9FAypSJCf9kihOBou0qkFfMVxUrNw3UgTXsXZsycQuOSCBgnTaJQsjkeprniKzWafgXflYzMhDiJ8IVhGE4YRxPiKGYYR8SyAaKD6ywgRQ0FKDGhc+yDDIXLfPAyJlojHI/QoSaOplTrLsaAUwuQgZu+j0QSDbe4dmWdE+9botr08Z0aRrTY2lHo1oQwvIHj7svaLZkYB2kmSCSe8nGFYag1EwOJAUdIpKrlG/T3WzDyrAk8/b/WZQWydGjdpe82zaT5NgBC6gJigLQAEEISxTFHj7f5oQ/uZ6VpuHzxNqM7MetXL3H4zDv5gR/+MJVpnzdffIbR5m02ug7KCIK2j/IMhCG6B7Lu0ZGKfhKxu9bnwJkONU8x6Q5563bIpTtj5pc87r+vwvKiR+AbMBM0Gh1Ds+6gphGxn45CrA3Xb0YkEcSxIJESp+pTrUoa2zFrN4ap77Zdn9l5mVsCckU/G9XsUNAlt4/cr9660IgSx1iiCfO/vxFAsE2Y1TnK7uZvfx/ZXlc2MpTdgezfZd4z7yv5F2aBT94ukSs35b7mPbLDYF2XKMARmfKusyAL6/dvsgqwRbsNNkhU2sBvizZMUbU1a0Cag8hkVZJFmto2zYal8H2XRrPK4mKLgwcXGE+mqT+2UqAlYQzaKFb27+fsE49x9OhJmvUWw+6IQS9in/Rwd+/Q8nxMpAn7U6pC0h/scHRlnmEyoiIhFiGHFjugPOpth1AFOIHL+u4WF/5/9t48SLLsOu/73Xvfki/3rL2qq6uru3pfZh9gZjCDwQADEIOVFAkSNG2CJq2wFFIEGLJBk8EI0lZYCksO0bIjGKGQTSm40yAZIkGQHOwDYoDBrD1L93T39FrVXXtV7stb7/UfLzMru0GCEEnJgI0TUV2dlZlvvfe+c873ne8sX6fX7UIbDGFai9B3tgY0LyXTrPWdqNDgM0MndO8G7w2HwbWWaTDhuTbTpssDM/s4PTvGdMHDsS0G671CgLRIpEcUQ1fnCUPJTrdJzrVxcwXybgbLgq4JiJMITxiqfpc4juj2YnqxJlYFoELGmkPhYESCcguUvSxrMsNU7mWC7haRH0Ico5MIJ2thtMEq5ZBKYbBIIk3Q2uXm9S1O/cAcGdfCsYqEYYlWQ0ChRxiuYFnTCAyxUf15EyKQuMrBFpqeiYmMhTZgCYWXm+AH3v8Un3v6czTq9SF9Z9DUVmuDlOY2NAH6Rbwj6IE2BpMkw3uFGBTOjyb3zLCT8cCLH8y50YDAGJMWl5s9Gp0ZdHjsB3fDzw2QtyElj2E/Dkk6hi1l43kes3OznLr7bj704Q9z1+kzZDIu58+d4w9/9/exrRRZD41GYVBSEQuFMRDFEULsqaHRXwKGyEc/iP1L8qjfYn+L4MAQB5dArCEyDWCbcPUP0JX3IYo7yMwh9p+5m8mZcdaf/WMuXavixwpCgWflEYFBN3oktTqTSZ3Xak3KfgnXKuG6VfxqwoUr49Tzr/LYOxzKxQ7IJtrE6NgQW3nsYoLt7aK7ISqMcFyDMgF++xbXr95iZ7vG3P5FDiwsYrI1Or1rZJz7hpNS7P3zN78M37f/F6w/0PuIQRC1wBg2dy9ipCSMe7Q6O0jtUi4fwxhFEPoYJ4PtFchKG4xhe2uL5Tdex9ldp4iF55YJtEO20cbvNAlzkiDYIBM2cMIy5vpZQl2m3t1mbGYemSTEnR46l0+hb6X2Hqh/x87q6FzWRnNwoohNiCUFUtoIITHJFknSRosKgbEIjI1vitQ11DotNAFG5plRDtO2xMcQaUkzaJKLe6x3tukGTSqWy7ED72YnbDClDhEYm1gH+KZKyDoHnQfoLh0mqf06meR1suUG0gIRBsiMwMs4/SZBqWpNEmhaWzEzpwpUe5KxrkAUizT1GG+eW+HEPfdxq/c8U5MPkPPmcKVLKwmpJaB0SNlSGBHiSUlOummAJ0FiDTnHSqi/4sp9D1vfGxyMqSQ2I9moNBMlrJFCzZEVP1WzkH/jlS3lpu7RNZSl+PjHDjI9Z+M5MSdO5dlXEbz83OeYns7S4zDH3vV+5mbzrL74BW6udil0OsicomCX0J0dlBAUi0X2522+vNqjtBZw6K5xXK/H+rUqz3xtk9lHp/jQvTmy2RDLjUBokgQS28WtKMoTBbrXt5FGY7mC2HU4fmyJ5154Fl8I3LxFaSLLwSNFFufHuHqphmUZojC5TXVn0Mxt9BmaOgR7XcfVMIu4t97sOfZi6HsPYw6tMdyuVpRqF/a9ejG4H2l3VhhJKPS9E9NHMG7L4/c3wUggLEd4xcDwXo/SfEbV+Az9jsaDDbGnoz4qlzjk7Q9iiv75SzOittJ/Y5jVF3361FChR9x2PunxjG6/f/WGyMfg+prh/kWfpmWMRimFbUsc16Y8VmRxaZa85/DUh99OrdmkVMnhZbK0miFnX19ByiwHDyxS2bcfq1TByhaYzBd56B0PcfnzXyIftPCQhG1BUI/J5SQ6giCSzFcKTFUE2D2yEq43EirlSWS5zNKhg9y4eZN6s4Xf7bKtBKLVptvtDrvfwmhBrOg/C9g7v/65DRCVoTSu2JM5Te9nWsfgOg6TlRJ3T+R4cH6CcrGCbbkIEnSyi9YdYjFBLxIEJk/P2DRiQ6PXBhUSWGUO2TaeRX+9FzSCFsW4y7XmKioOmMhWWNz3MNWoxbR9lK62CE2HntlAiYiZzF30lk4Q7nbJlgxqMkaQIJIIlYGMY6ddqU0MWhL1NN26Ye50gY0GTOck2ptiq6HZ3Njm0PEJVnrPMj/zTsr2JD1jaMcR7USjRMC4pdCmR0U5ICAyGiVASZv/9V/9S869cY56rTacs8CwMHngoA87CvfvxQCxuU2lR+ytdXuKQQOnf+QeDp15gzZ7nZgHdLI9ZSLZX2P25uAgMNEinWtqcHwi7UBtW4ok1ihl47kuXiZDvljkHY8+yqd+/hfJeC4YTRSE5DI5jDYUC1n8OCL2fTAaqSRSpn5BGIXp+WhIBs3OxN7c+paT/zb2HxEc3BlqJEjzHFosgwqRWY27P4D4i/TWjmFNL6IyPnZWMHb/I9TO/ynF8Vkm6jdQWR/LsVAiR7D9Ki3HIWx0iRt1bD2HYwyrN77Gn37h6/zcL72XctLGtUJsO4VOwjBEGYdKHGFpi6jVQTQ6iHIBNf02zn/tJTY2duj2IiyZYXJiHycWF2k3n6FSOI0QTsp1G82sfN++R8wMgwKNJox6XN36JuPZQ9iZIrudKySmhVdwabYbvHDhadoNw76F00zMHabi5XEsi7YfU988x2r1MgtxjKUdknpId0OA1yDo7dKoblMpO2SMwuom3LrR5LXGDmNL92BncjiZAjo0dLZbuOUMbt5LM2t3NAb6Oztv0lmoMTjSQpgQTIhJemgTok2XmBy9CF6p+VxoB4TGx00iVHeHhxdnKXsOGdGh2/NpIdntRlSbVTbe/BJLS5MsLB5H2fuxhGTWKaNMyEbUhmiXvOhQyswQywzTsoCa/AfI6E9R4jKWlUcID5N8AyH6hU5xhOml1+dLX9lm/tQEc7MHEImm5Rexyge4/93v5ktf/G1efL3FUz+wzqlj91MuLJIRNpYcIzCS9ahLRiiKliSLIRFJHz0QabMjvj094XvBvqVeZpDN7p+SjvrOrEgdWxOD6Rmsysh3ByiBMVh9/u3fxGxLUsg5xImm24uQ0rB0cIb777XwMiEYjVWWjJdd3nvkAG987vf52i2H9z31YfYdOEQ5fh9vXHkaf3eXu6gSzedA2SijUaZKNz9F1NjBizJU8sewg+u0d5s0IviRU2NkTR3PFVi2RMeaOEqwEosJrREmRtVCTBBDqYgunsRtdtlthFiui5WVmERSsDMcuT/P7+UceoQEvajvtKbXKxl4uAZG+w/AgOkhhvNtoOUzpA4KMANVw0H+/Y5rPZpyMqRyp2lB4gABkHv0HwaOxECGcHg7GWYwYdh86c7tj9LHRjOV6HStEPS18kdqJUaf54PurYOgY+BYCcvCGEMcpxQZM3Tq0+/udXwWt615w8ZoI3SZ203c8UoMz1NIUFKlalkqvciOrcjmHNyszaHj+/jRn3wfr7xwnpWNNRaPjjM5XkFJF+n1WDo1Tb0aU5lfoDK7QKVYxpWKZqvN7vprbHVvMaMUqtfEatg49YRet0YcN2iQIWcJpnKKRMRcW2lzpSUZO3qYe97+EFkri5cZJ+eNce7Kef7i+b/AdV22thIwuh+caeI77tco8jSojzBa76nR9LtJD8QtlEqLUS3LplAocOTIYR598BEyVoBJuiSmA0Ro0yPSOep+wFd2fNYCi0QLMkmIE9Z51+F5Clkbqet0egntBGp+SLVZY/XVP+HBR86QmzqCa03iCIsZp4wyATfDBpl4k5wFnjuJkR4zTgE1/SlU9O+wVA+lciASSM5Cf703oU/Sidi6EfDNl5rMnRhjfu4Qvu8jnALji0fITmd49tk/4YU3WvzEx3dZ2vcQtlvBlVkcq0wQK5b9Jp6RjDkaW6WN32zpYCPIulnyuTy27RCGIUmiCYKAUZlb3efxD35G58ydQ9D0aWDpwO0jeCk/boiQDeRQB/fU3Db+U6Wq4T6GdJ00sBBCpEXlGKQxxElCFMcIIcm4DlqnKNPc5CyZXBbhKuZmZ/nlX/6nGJkiAbEf0ql1qK3VSTDMLxyiurNDrHfxfZ8oTAh1Qs8PSLTBViJFSjGY5I751h9/3wl08LdADgRxlENEFoIuRkYIAhAKlTmLaV2n3cgQkSOTneZjn3wX/8c/+T1OVfLMT0d4WR9jxWTjLDraolsPsfw3sJIym+0SX7wWMH/IZq5Uw4gMUiQpBKwdjEmwZA57HJKdJkqCNeMiM3mEeoLPfObnCcMQz7MYn4uZPbyByyZBXCTo9XAzFqhBWdT37XvPNGHos1q/ysu3vsiB2WME3bNs72xhhI/r2dgiohV0uXFjlZYpMH18ktAt4mvBpDE0WjXOPv813rFUIbgUE1RtrKRIHNbYRlGeWCTjV6mUfQo5Q60NX1uJmTh8inf9yPsolisYbWEyCsuxCFs+yrFQlhqqh/ynMAEoIelpQ7O2SdxdJ4mbbPYEX64qLr60THO3TSxyqZMR7lAoFnj8bY/xW2d/l82NTcJIg+2hnAI/9q4HeHX5aT76no8wP76EJV1iHWGQWOyyHlQxIqLo5Slas0gULb0JZpNO50VUVMdubeK0X6Sw38XJLWHYBDL4vYDqqs/G9TyP/fjHaYqECSuD0RUCnSUWFtIu8IEf/EUef3+V3//Tz/GVF1/h2IE2H/2BxzG2ItI7VKwCUng04og1v0ZJRczmDg2bzgwcoP8c9R7/qc0Yg0kGnGRB2IlJu7pC3Oe1m1ATdTV0NVmTYKoRZDSy7KDy7m3O4t/E3KyLm82RMZDLanJ5j243oNMyOKaNbYFREgjQJubo20ocf2yBbryM391lcqHID/3sU/zrf/RvKNLl8JSHKrhEgOwFSKPpNTRHDhTJex6v3YJXdzSLh3Oc2FcmShSW1UWQKo+gE5TKY09miNbXsYoKWVSosYOE8t187un/Dtd2yGRtHn3vPA/cO810xmL58iYFR9CppwoesdHEsR72D0iVZQbyf6ntTdu++230kMM7kEDEpHPQkG4Ls9ci6fZpP5ABTfczDD72/GuSZJDZHDCfB9rqA4xhrzOzGDr4DLe1R4kwI3+6I1AZQST6f9ijroy8D2lgkugY0Q+GJKm6yUBeNOnXNgAEQdhHsgaZ2gHVaK9h3LBIux98pDrwydCZk3Lv83EcI4XA6SuzxIlGWYJCwWViPs/JdxzkxINHCbKCxz9wP9eX3yKxQ7qiB0lEvdPg+vWbhM4Mp6aP0rNzJEYgw5DeziYXzj7Pe+6ZYucbdcIwTxIqQt2knXhUxiuItatMTDhkMoorO5rnNxVOYYqnfvJDKOVy4fVrvPXWNXy/ywN3Pcjq1hrXb1yjVqsThlF6fRMNOlVvHCB8A/Rt0AxQCvpIw8DRNLcNnAHqp7XG9wM2N7b4xtlXmKsYShmfyGhu+pJndwyXz67S2mnjWxV01MLFZ3J8jIfueYB/+/K/Z/3WFigHozwmxsZ5z31HeWPlC3zih36SSmYeQyrBadBYps5qsIsSMaX8DJ7MYjC0knUwW7Taz+LGXayda2RUnexMFjs7j2QTbXJ0Wg02r2o6wTwPfewdtEXMpJUlTCbwjYNRGYrZLB/64bt54gO7/Nvf+TS3bn6WDzz+GO986H5wBTG7TDl5jMlxvb2LTtpMZFzmCgex7LTR5Wf+5DP8wi/8Ar/5G79JGIYM+P4pymSn4/jOwGCY3d9z6gfzK0mSPUTB3D4fBrYX8AJiD+EaoIh3LriDgFwgCKMQQ6qgNZgLGJBGkrE99s1MgWvzgQ9/hI986KN95StotyOCThsiRVCHmdw8f/jrnybTUfz5Z/6Iz770BS6svEW1UUXoBNe1icIUxZP9IHtYjzAy91M1J/5a+w6DAzNcHDAaIRRR0kY5pzBRFZFsI2UnVYPQCSpXoNs2BFEToTpYYowo3uHdjy9x9qvnKbuKcj5HXLCJi5LNl2usCZtMpkJGJqw2dlm+EfL+Q2UcZwzdiwlxSKTBMjEZlaCMRdQIEKqEVNmUWlFaxN9c5aW3bqFtw1yxxMHxMRbLk4TtDV78wus89eM/0s+u9f/5Ni20v2/fnRZFPueuf5mz175AM2owXt5lX/5uGl7M1esNKrksx5YybFmbrN66iizMolTAjCfIK81Os8XKzaskDc3W1Q7dtQS7m1AWXVR7G+Ps8LSEAAAgAElEQVRBdXuNg4s5xiqKtbbmK28mtOIST7zrXrL5PAaLXs8Q+SGFvMZ2QUdJ6kCYPQj5O7GRxO9f8p657TekC8+bt1bThmdNj1vbHbaVy+ZqAKVZ3IksBQIKyjCVPc1d8xM8/8bXWbu1TVclWDPHmN1/Fw/MS66tPcMPv//HmCxMESDp6ZCMiUD3uFx/nVzuBCXbwlE2gbEJ45CN1nP8yb//M37yE/89snCBi9vrXHqtTeUP1vBZQZwq4qwnrG9E1JRi/Mw0Z1rX2acMYeE+LGcMoS3q3TavV6/y4YUHEG6OH/nAR9ht+rx55Rb/4v/6Hd5+5ghPPvIotaSJoxyyliIrc0Qolv2AAxmFhWKQzDQmSfXev0fsTmk9SKU1B85hEhnCEKQ0JAhk0ueVd2JEM0KVLHRXQytOu4Ame4Vw33ZQ/TWmlCCbzZDPZkAnNP2Q/+q//mmWb75G7gC4xQgpYkwMUiS45XFq1ZDY1HAz0zh2jkjU+dAPPsJzn32WpU4XayKPKeVJpMXm16+yKmwq2XF0VGV9o05zS/DE4SyWOw6tgJ7OYMkYSyfYtkTqDGE9QLr7EL0WMlvBuPvobG7wxkoLspKJrGCpNMaUW6Bba3H9lToZx0Hgp92YBzB7kspPYsCy5JBadBvjYFAwKxSIVILzNndh4Gj0HQMxHIO3ow/0f4t+hn1UzHTwCErVSvaCizsdk9F1ZOCQjKIORu/1KUgPzfSz7mJIaRo4R0NExBiEMXtZ7OFzsB9kiD7KoFIO9WDbenhue12jR883FXqIhkezR/UQI0NSDI8z0X3OuJRYiGFRaZKkzce8jM3cfIG7H99HfkYR9Fap7BNM5E7QnRvnxZcvc98xydhklkDtsr29ilUSKDvgYFYgk4idepX19RXihmH9rTY7W5qyCvH8CNXegYyhunOLU6fyFEqCV25qXr2piDMVHvt770xROOkyNbMA2iHwm0zOlpibnuXK1at4GY8wikiCVMY0IyVxEvfVmUYoKOzRXoSdquoMqR+Q0lL76I2ybIRQ+GHApbcu8crGJs9taALfx2Q8kmyF7c0IKnO40wWycR2VjGMlYMdtXrr4F2zd3ECWJLn5t3FsYYGDxTYb9Vf5+If/S4qZSVomwSLBNiFx3GK5eYFc/jQVG6Rw6WlFN6yyVv0GT//2F/jkz/4vNOI/4oVaTPVclfzqLQJ5FXGmiHs14q2NEDOVY+Z0lmOt68woTVB6BJEZgzDmWrvJblzlibmTCDfLf/Oxn2Cl2ua5l8/z6m/9AW87fZQn3v4wO3ENT2aY9nL4oUXD1+wEu9wz5WDLdKx86ud+jsXFg/zyL//SnkRu/1oPAtLRAGFIqxuM8n7TMAz9gFcM1YtGpYNHptlQ2MBSVpqU6t871UcU02e/ThW+dEKcJFj9gFApG8eyCBONJi0oVkowO7WPjt/m4P797JtdYGxiBikF61sNqqs7ZJSkgEfetrHHPd567gKnF45y+PhJKtdexV1fwVE2tlS0Ax/d7+Yd9yWa+6AcJgUThmuREbevMX+ZfYfBwQDPTjlXwoQIkSERBYx0ERrQCUInICOk7mBiD0vOIJwi3aiOV5DMnsxz7ksBjZWYUtahNOelCjLVENMJcfLj9JoJ1evb6IbF+Pw4gnGSsIqw7VSdIgoRJkRHRXTsIZ0SJriGEA49534+/dufJYgSXCfD4XuOsnBsGu132boCotPiyjf+b44+/KN4xQn2ooTv/Yzj/5dtmF3p81Or/k2a8ToBXepJk4vrV5g8Ms1Yboxr4RahaCKMh4lbNJptvLCKaG9g4ll88jSau1x/6c0UunVyOKKKrbugXJpuhQY1jk0JCiXJrYbFuZ0Cm5kZ5hZtDiyNYynJzvUWrVsNRLeLmMxSOjOLcAUDXvAenzY9h+9khH0rs+Rbw/t0vgsWx6e4vLlFLXapWuM0qj6qUGTWk1SyHsW8RVZqXD+imJccPzbPA6dPcbYTUZVFRCK4duEl3veOJSYKMxihkaaDxCLQglrjTTzvAJ6liIRDkETE0SbNxkVeefl5HnznMbzCJKHSTEyHFN4xSf50h5vdKrd2N5m/f5qyNY7vTHBwYoFK5Qibm5cI2hfITmXwcvNMFTwedMd46eYF5idmyDs5JsZs7j6+j6lKjijQfO3Fs5w8tkiSA5RG0ad0xrt0LYecLVEpsQiD6Ler/9bs6feKDYo341ZM0IhIpEIWLJQwmEijA43QBuVK9FpIHGusrMI0DSZnoNTf0N/i/E2c0Gq0KFdKLB6aQ+iQL33lOR79+Q9hec9jxCZGp1KN0jKYpIuIPRzvIEEc0mvdoDRWYv5MCfsPEnau+8xUxnE9l6DZJarGmG6IU5mjcXOX1o0mVuhRmZ0EPUESbqK8AipOEEkI2qCjPDqeQbpj0H4BWTjEzfokn/mjzxMZiSsyHHnoGDP7SnS32qy+uUEuiXnqvkn+zUqdJE6hf9VvHhbrtLlW6hQMdPjTB35a2LjnwGL6EP2obOfIjB50kk6SQc3CaEDQvx0D53gYhNzetXUv+7lHRjKYVJN8xKFPi133ONJ3BjSDLGE/Fhls6jYqwdAZvY320u8o21+6jAHVd5zY28wexal/coPmZOkpmT1ZUrFHX9J6xIGSAt3vLjyQOzX9HUopcV2XmZlpZmZnWF5Zxsu6vPOD95CfjmmaJtWozvVqwnRphrzMI0ONZTQSnzio02p1yUa7OP4GUTJOEifsbm2w/NollErXe5cmduITCZeGXaQnGhyfleTLNhc2JBdaU7RLFRYOeCwdm0ZKxeobVXprVax2A2O63GjuUKs1kEIxMTmJpi/QYjRxFCKNxJgEIdSAeNbPCJu0G3N/nEiREmTTa6n6UpsiDRriiKSnkZbFN7/ydSZPniYzPYuRWZKWIlsep1CwqLU77J/cTyYIaO/ustPoUhxz6SQT5I7fjVtapN3corp2ncceWGIsP0NsYizTRYgsnbBLq3sDL3ugX5vgkiQ+gX+Lna2LvHXpPA89cRJhV9DmLg4uKQ5NHsJqt1nr1rm5s8Gpdy5h63HyhWn2VfaTy8+xtX2F8OYr5BfejesUOFTKMxYEvHLrEvvGp/G8PAsziszbT7Kz2yL0Y5557kXuOXOUwNFYAmzLJkuMHzZp+mNUPA8pBJWxMR597DF++qd/hn/3a782zPYncYwWot8VeQ8tGM6RQf0ADGVOB3M8RVH25IyHiB2DOZH0/z7ocZB2Xh98PtEGIRSxiYfobdo9XaMU6ChOx3mf0m5bNradQSvN+x55kjMHThE1IxI75pvfeIm333MvGa3oNJqErR4Fk+VAcT9aSSqiQthKFT0Fkl4YpkFBfx8pupGeb9Kf1HIU6fiWMoFvte+YVqSThCD0aXcbjJU8MCLVP5YeUpYxaARNSHwwEseKiRHEOiYKV/GKR8nMRShbUN/ukd/tkfE1JmezUQ/JhQlWLGhsGbZvJFhtTYEcwoxBpJDKRsgsJklIenWEKCJNAepNhIDIKbG1bvPNs+ewLEV5rMiJ48eYmSjS2Vln61obV3lk8hPIfuT3ffvescSkUHSkDbGUVEoF9o8XaFxe48ZruyzNbbPPKuIqC20iOkGC1hF+GKHpkOhVtFlEJw466NLpdtNCoJxN6DqEzRgdNumIhMq0h1Xq0ugablQ9lrt5kpLFsftzFESdznaZzbdaqHaHibLBsgS1qzvkDk4RBwlu3sV2U3hz+EBmL+vXf+OvCEu/deIOFrowjLh45QY3dxpEYcBKvUVVC3xh0d1u4BY1nltmThn8RpPdRp2kVeeGCUksTWXM5tDULG6txsqNt7DjKktzj2OrHLHuIIRFGCc0gy5aZim4MyDitI9JsEmtcYU3Vt+go7c4fvxDdHqbVGUPy11kdv88zKywP9zE3byH0niBCa+CLSuUZAlHeNzCYuPKCovuPNn8NNIqMW4ZNlsF7EjSihOklZAvZDmWr7BTa3D1yg3q9Q5OIsjlcuRdD2MSPGWxE/hY0iKjRBo08B+H2Hy32OBum77OeRQmJHHqMiQa4sAQ1H0yPbACg0gMaIPcCcFLm8CZICbJGkwBVNYZ4Tnf7sx9R8eTDDJumqxnMztRYbfmk8lNgj2OxkeYJpIQkgCBjecKIqkwURdjmgjrAN68QNmK3VpIthlTnk4/s9mIKMUaFQvWtgTtDYPTU+RFCcE4hAIr4yKMgwl9dNhDiiKKMma3isxl6MYFlm8EvHL+EpZjUxkvsn9+kowFrZ02jbU2Qhuq9SBFB4QFsUFHaXfbuN84aUDjN31HdihdykDF53b0buBYiGHtwJ5zPTpvjUmvvaTP3zdi+PcBD38ohTqsfUhHw7eo2Qyt35hM7G1rQHEYZvwZODIjNAn2aBB6iCCQ0tVG99P/ypAOM6QrpUjLKN1CDBp97cEVwzVu4JQM0ZLRz41s/06TSuFlsxw/cYL3P/UDbGxugaW4+9FZNG+xvHaB67d2uLHd4cDMLvmkiOdkiLEJY02iI4IgwtBBcBPNIu1Gl+rOBp1ODxkb7IJDV9mooIeJA0I7oTBmIYuSnVrMW9UJNhOP3JzN4TMZCrJJe7PH2oVdxqwOnoqJg4Tecgt8m0ff/hivXXqVerOJ4zhEcbyXsdYpFS0NhBQZ1yVJNEhBHEliE6FNSjEZoD/GGJRto2wHx8uRLU1gF4q0aiHubkBsx0jRAz/BKxqkXSJavUnbL+EHXVq1bWqtKibIEiUW0U6TZPc14mCX6YrFwZljWCJLZJpYwqEd9uhGPVA5PGcaI2JImiTdZVZ3LnFt4zKJaHLixIep1q6yqQRjpTMUxhbR0Roq3MXZuI/cbJGTzgSeLJMXBdCSVaNYu3SVM9P3glskY2UoS4uddhfdiakqhedqpqfHGSuPs7ldZXn5Fjs7DUQ+ZrxQxJI2ltB4yma924Y4oZTLYUnJwsICTz75JL/x679OHKcFyYMiYTPyM1qg3J8dt6F6A0LqqAT04L29Qvq9JnapxC79ZMGIStFIvUG6LsjbAvMUvbBSyo+SZBwPaSkeOPMQUzP7kJZDEMUEiUZFHm7LxgrAalkIP8HSUM6WIRFkfIcpVaKSKREkIb04QMepcpE2CeiRxKTcWx4Ga8ydici/zL7z4MAYwjCk2WhiTJdyPodOIqCAUNOk6EII3Q4ocOwYkzSIohbGrxL0EqzKJNnxHI3dJruNLvmtFoWjFW60QiYAN05o7hrq64KMD7muC4mDifqQjXTRgUT3wLLzyDiCxnWolKmZEq+9dJGtZhsv53Hi+CxL+6dwIp/lqxtUN9pMzu5n/5n34Hj54QL5fdTge8HMsF9BrA0ZZ4J9E4vkzCbdlZs8/fo6V++vU8iuYxEQC2j5PRxHkmhN2+/RjFdIzBGc0KVXWyexfKSToHWPnsriy5BO3CGSLY7N76MeGKJulo1elp6VUJnd5ujpIsFuk62VBr0Nn6kiTE0W0BNldl9fRZdKePkEy7WwHGtINUj0gO5yO6VAa00UJTh2ykVMgYbbs4kbW9vUmy16QUC73eULX32eN5Y3MGFAbGfIlycYG6ugTEjZMgglqOTLXFy+xfnLVwm6DZqBj1Us4+W3edepALlxjfDmRQ4+8SieO0+CwBI2YQJ+1CGImozlDyGERRzXEcFNus3LbG1f4WZtk7sOz+NYM7x5/QXCcpGpySMYptjtrWPXYw4f+hBVfMJ6AxHGtEuanNXG82yanYCdtRWUN4Y3mcFgcXTmKHGjSjMIINEktsCVhmIlz8LCDPVmFTfxkUKRsfJIYbCsApvdgIqTwRZpkdUooeh7IUgQow7XwFkUgjjSJEBiK8KuIYgjujeryI6DiSUiBhEanFij3AxsJxgrIeloZFeiss4QvYrjuM/tliMO2re/LtoIlLIIej1qu7vMzBY4fGiGRm0dt5xFumNpxljXIfDBknieJgmr2KYNQhFHCmtsmtxkgcZWg/xOB3cmR+zZrLQjZoVARgnVTZugqsjGkryfBe1gIoOMbEzsoQMLEzgIu4CMQ6hdggNL3FyNePP8OtVOj2w2w8kTU8wWM/jbVerrLcJOgrAkry33yBfzBGGI7kbESYyRBkj6mbSB478XwA/8iKEjn74avr93//qO+QDUFKPv97Xvh8ole3UJ6bbvqB3o79AwbMMw/Nyd40XAkL8u+s43IxSWwdHuZfQHxydGPARx2zZHVYVud4r2UAFGgoy0lmIU1e07tnKQKWdkTRtkW/WIUzKQjb19v0op9i8s8JGP/iBCSHyt6SYNROKSi5t0l7d46dwOV++uczIJyDgQxhGhBttRRDoh8Hu09HVm9Ek61V0aOysYN0DGCVHYpG0XCYMQYdpYTsDUbImq1gSNHFt+BlPuMLWQsLiUw99psHm9ga4HlPdbWAWLpO1Q2YV940u854MPs17bYHN7m263izGGTLZMq9lAmwClLJRSOI5DqVxh3/w8yzeu0+t16XV76CBIeyL0HTYvX8D2slh2hkyuTGHqAHg5VOjT2eoQ+Vu4jo0rE3r1bYS/j9rFC7QyeUwSEoVdAqNpdiW4Fr1bLyLCbRYP72P/XY+Sceb6632KBneDFhpNMbuAQBHHVUTvGu3aeda2b1ALu5w8tB9HzfDi5S9iLS5S9k4T6h6t7hZWC44f/WE2kl3k5g7CNohCjC0iPM+m1vTZvnmZscU8Vn4So2wOTRyis71GRwYYYTCWwVIW45MljInY2N0gGxbIOXkyjg1GIa081W6XbJiQdV2UbZPP5zl8+Ah33303r7zyyh4qcIfnm6oDDZIlA3QrnbB7gbYZWQv2amUGwXW6NEswSX9sSxIGPTb0cN+jyJqSqt9pOc3ep43XLAQSKQy27ZAr5Dh+8i5iy6Lp+wg/Ty9JWChMYlZ8okDjGRs7cbC0ASmwA4XuxCwU5lgd26CtQno6pBeEFHIuXb+XrnP9eb5XVD2y8v9dBgeWZZHL5un1urxy8VUef/AJhNlG6xJajKGsHogOxBqMhQlrKDSOGCMWk9R2XmV+/EMcPDbDxa0arVaP1to23kRCI4CTjsCbGKe+HcPuDuNWjkIhS9LbJApCJGVkBKYTofNH0N0OoX8Zb9Ii5AgXLyj+4JnPYGMzNl7go0+eoJhvcu38Kpee30JoKJyewnbBEIBxEcLu0zTMYL3ijv98374rLIWfBQJXgRQZYrHI9LThscd8PvvnN7i53KSSTQvb3ZyDFZeYrtgYBb31Fiub1zh84DCm1+WNs09TX1/n0QeP4Z9bIxPO0s2PsZlk8WSbtldnfdvCmTpB0ttgLLvJyQenmc0f4s1zFtXzMYcnMowpAWsKmRjKM/toBRaluQzCEmmXzn5A0O352JaFY9sp95ZBZhF2Gk3GyyXUoKBPa/wgwBhNFMX87h/+B145f4GtagO/F9JtpTrGuayHlytguTZFu8ziwXmWJsq8eWubYwdm8HttNra2aTupygPzsxSTGl9+7qv0WjscOzLPx97zJKEQ2IRoJF1/lSTuMO1NkrMd1oItrN7X2d5dZ7lVpZ60uefABI8e+hmWd17khcuv88i9T3A4O4uJNdu7K6x+/hme+umPk3cKPPf6C2ysXebh9zzA+Ph9TE+Pwduu8dWnX6Oy1eHRD5aJ5GFmpOKa65AhxMUjiWJq0Q4iW2R+3yLX/RdxtaLT6tHTLebHsrQSQcmyMElM3F/8Bwt9YvZkKL+b7FsUieiPgyS9167rpAiso4gC6NQjwu0QnY+pxLewdnJIlUdJGyuSWKGD6BnMWoA5aCFcFyGdvqObFp512m2yWQ/HcYfu4l+XFDFC4Qea3d02xhL4lQw7F1/jwHwI+z2mphV2IYeRCSJRCGmj/U0cCUbl8CNNo3qe+bGnOHJ6hnNfb9OqdyltN6Di0goFd1vgzswQv3wVt+0zViqQz3kk3U0CP8axM9AK0DqLdvYhOm2C8CK5+Rwd/wxfP3uer77yIo50KFVcfvDd+5GTeV57+ipbl3dRSpIt5Dhy1xEK2y3euriMaafQezLsGAqp0IgZNhWzLYnp04MQfSh+lG7TpyMNif/97LpJUp6/EAO60GjB4qDwmL17cMc1H6rYmNTJHw1C7qw7iuOYgdc9cNB1n3KEGEiF9rc7Qm1kkBDr9xwYHPttg3F0HOwdXH9Hg0ZkaviJ4VgSfXTkNhBjVD5R9FWRdN/RMsNC3cGu4yimXqvTbLb6Dp0iKyVK5knUaY4dAx0nPPfiV1i50WAqu4ryQ0TQIyPzTJRdjILuWpNrW2+xUDmF31qntvk6Qb3JPXcvsfsXb1Ky7mW7UCI0imJmi16ux9otm+z8g9B4mf0HYo4dP0BB7OP6DY/q+YB7DxTI+AkoF6+UwTsVkSko9h+f4YG3PcD27hbV2i7Ktjm4dISV5RUatSrKknhelkKxwL6FBT71qf+Bf/7P/xn1WpXqzjaNeh3TS0UVpOUyf+QU0s2QJJooiGltbSPEFsqSWK0mubCHO1lBeoL2zhax6VHfvEF+Yh5hu2jLQ3kecn4aJ9iitVXHkRGnDx/ivW9/iEgILEIMimb7PBmZIeeOYVmK7XATq/tV1jY3uNzZRWYi7p9e4szcR1jZfZFnzr/Azxx9kH3uOLX2VdZWr7D9zbN8+O//FHlR5NNP/yaTMznufdtDlEvHmJmeJHn4HJ/5vS/y2ActFs88jJRjjLuK3WKRStTFw6Pba9KihXLzzM4u4Le/QSbOslVrki/kKWUdfK0oWTGe6xImaWMzW0qmp6f5lf/tX/PeJ99zWwHyKJIFI7KjZoCK3h4YDCV59chr0w8m+kW9qYKUNUzmDKhDQwnf/rYHSILjuoyNjSOlwFIK182gRIaol9BtNUhUzIGlRc5eusRHnzxOVpRpXGvRimuMbZ7Htu8lTGwc28MRDiJWxCKGakw9amHlK5QmZ6g4bbo6ptvuMjleZnNX4/t7FCkdJf3jT8UFtE4L0P86+46Cg0FUtbmxxn/4vV/nH/6TX+T8hXPMzkmkNQ5hhAnauO4WYvo4Il4j2Q4xSQxK0mUcGbWQxmHnkES8rrE2A3Zv+phD44xJSS027Gxn2d6sY7o+p8c8rLsOEqxfoNaskK8s4CYK3dpE967i5A2Wo9DyPr55Psezr1ynoCIqCx7v2O9QLFqsno+pXQzIRz7ShlMPzBIml2i36xSyJ8h6B9O1bC/Z019MB8vid5+D8f9fG6TSIEYhZQlLLiHKPX72k+f5Z796hYn3/zjbt15g/3iTM/fkuFyvkZ9w2blcZy4KmBCK9ZbhmbNrmOo2T/3YaWrVCdaWN9jo3ALL4uDxhE5BEUwvETsx0mlzaGqOxw89RfXP/4LXL+T46MP34t6MMPUEk9WYsInuq6XYyiI2Gp3E2HaqOuBYFs+/fJ7DS/spVUoEWrDbi4gVTOc9brR9NrabiF6b7uYKv/Kr/yfddoMgjIjjGN3PcggpsZRLsTLOP/ypj/OOhx5ganJ8mB2UUvJkP0N4ZGGOH3ryMSKtabTbSCn51c8/TcO2KN21wMF33YOjcthAF49e+CxSSTL2OJFyWPOvYSXL3Kr3eGW1jmPD4YmDHC4ssd3a5OvXL/LI/VMcnJ7FEjn8pEq1uctjH3kfLatBnknuXSqzmbVorV1kYewIRo9xK1vgZsNHJuvI3WW8sTG+0VY8UBhngwz1dh3HwFzxEM1EsB1p9i/cQxBJWo1twtZVqoWTOK5LRjoopUiMJOzzxEcZC/9Z0IOBQ/XX7GfghCVJf1Hu+5Ya8Hshl8+/xfTCAcbH84SRJsZge5DJR2i/g1rfRDe6aHEAKWYgcTFRjAmakM0Qaiul40QaEcX0goBOu0G310NZUziOO3xgQj8h8lccsxE23V7IofkZji7M88I3rrB4dBFZWORWu0qY7KIrPcYnbezpUxDfIm4ZlNIkModvbKxoC4nNxnFB7iVDvNNlp1BGORXKUrKtbbbX82xv+5R0zNLMOPLEPP7qZWqNGSbcg4huncSvIexlZDbBsm1i8S7+6Gshl67WGc8aJmez3D/rEosdvvZr58h0upTRZMsex588wwPFRRLh8z//j5+m2/ExOiEwBiPT009UX6qzf1uSQf8Dw7DGwPTvrxyk0UeoBwNH15BymNPXe07H7Z8Tg40x6Ho2yLIPGzcNIP8hMsCIwz3yHQmYfoHr8ID/queWGe5fKbWHJpi9Z5/oBxamHzwNnPkhGtJ3hAb1FYPgZyDjKETqSFliLygaOFx3FlQPUGDZvzBCqv736TdSk/1Oyul3YqGw1SRSnmBpqctPf+IW/+rX3mL+Y/8tFy/9LnOzEtuSbLZa5CoWOxfqLCURE26JFzZu8o3XN8ibHu/54RO0Vxa5sXaF7bbF5DhUFhPqliGYOYax22TcDqfm7ue4vZ/mM+d482qeH338fvQbLYwUEEhkx2Bp2DdbwXEdPvDhD3H+zXO88cbrCCTXLi9z99vexcqN85y+7y7ue/gRjpw8RbFUIBf1+NS/+BWWb23z+U//FlfOv4FRNn6vTRjFtHd3MPQHp1BI5WBlckhp2F45z87NcygrTTpFYUTQ7SBth0z+JplCEbdcwC0W0NvXOPrIgwTyMvueOMHUfUdxpYcFdPDoBp8j444jVJGOiAiDm1jxKiu1iGdv7jA/nuVw+Qgz2f1sNDb4+rWL/Mh7TzJWmEYJBz/oERDzyAefYFdvUWKcpx5aotpaxd+5hlfeT2LKLBeK3Nqo011bwVlYIMxleCmwebA4ybWOz3Zjk5KTZ8qdom0kNR1zcPHtdCJFs3qDTruJtveTy2aRIZx94zy5bJ7F2VmmxyrYtsWBxQMUCgU6nU4a/CfJHsVtBAVDCIROnXgx0t9q0DBSiDSjP4inBzUJQgps294bs7K/jg/8RW6vxRFCkMlkeOSRR/jN3/hNWq0WhXwBqSQbm9t87fNf549/60/xDsxhWRHTE3Ncur5MWOgwHkL3zSucWhAE22CXz7oAACAASURBVN/EBCcxmSm0ZWFpcJoxlLL4PYeFk0fI2WUmN2f45otnyQmJVXSxmnWsWKH7Cci+nmm6pmjdT0RCnHz7AOE7Cg601nz+z77C66++yT/4x5/klz75j/jEP/4kzz5zliNHSiwuahI2qdXXybdXkJPjyHyRpGWj6w28bosgaZIkV6gcsbk1btO2NfucmP3KZy7jEKosDV8xpgz2tEs8Pk64cg1h52i3LWyaqHyOpFyERpWgY2OXj/G5lxtcvnEB46+xkLXQzS73ffAevvrZa0TVBkhBcXqOt99XIjv1dqRdJux8ER02iWTagtt2Mt+PA76LzQCx0f2MmMFB9yewi6umOXpwgk98YorXnvkCjfUtxvJZ4qTOmekyn88IVJwwP30Xm1GR565tsHmzihdH3Hf3L/I/Pf0LXLl0gYWDOR55Yj/7cpKry7A91qW6JjhzepLjB/Ns3rjI0+cU/8VdD5K8sEocXkcVZkiKp+lmHGobuyy+rYIl4fqfX+b8y2+xanY5OOly5F0PsHTkIE4uS88IIgPSsrCbEb/3R8/SuPECb60ts9Go4fc6NLrdtN17/6GsHJdcocixY0v87//0l1GWhWNbyP5DdSQ1OLxmllJYCmytcYoFbNvGqjV57IF7uOvMEY4eOoSDwkejdJ1utUPWm0F5Ht2kSU7laDabvLV2kYIjKNkuxk+4JgKOTtzgq8+vcP/Ck0g7Q9ts0DO3wM7xuVsWf2/KRbNGzWpQs12yvs2la7/L8aWfYDZ/kvFDl9iqt/jyhSuMLXq8Z/FhrvsGSzgYp4IfhgTtiLKn2MZwLVF4JsDOl9FRkau3lnlw8Sg7WAhhKEiDA3vZU1InL5WH/C4yo5Ej/iGkFBIhLHwxjx9CuxOx22jTrtVw44TZ8TlWXrjFbCPBzh/ANIroDmidQK+BnK0QTCZc2AkYn4CFvEWkE86++gZSRBw7fgTXdYaH8J1cDx0mnDh4H81Gky898xKP3X2CQnmGL//ZBX7oh+9hbr6IZy/Tatwit7GBNT2BNVYhqoFqbpHxExLlkyRXmDyV5xVP4vZixp2IWTtkLpMhsnLU2oalrKa1r0xcKhDdXMHYWVpti2J1G+l5aOUiug3o2tiVU/z+V9e4uXaFgtyhbEmyUcQ9T53kj39nDbcb0Uk0U0sVFo/O8PLFFpeufpG//1MPU8kpJkouTQnVqJd2n1WSRKdFynGSECdpUbKUaYF7kuxlHA0MJT0HyjsjtP709/D1nuMxynTWeqTA2JiUcjTiRN+2sf4Gh70FSH8Ludcp+3Yef78LrBipSRgJJkZtNCE2yHQO6UUMEmT/D3tvGiNZdp7pPefu98Yeue+1r11LV3d1sZpsdpPdXERtpERKomSJoiRLo7FlGWN4+2H/MQx4jAEMGBgDNmwNZHjkRZqhJUoUqSHZ3LrZ7L2qa99zz4zI2Je7n+MfEZGZRUqaBjzSyIY+oFDIjJs3btz4zrnf8r7vJ3bPuz/w+av4AqNkQKnHZy0MtqdBdjMiemv63gyOwWeR6LqBoet4novtWCRq0GHQBFgwmAIscmS9SZ44McWvfnGGN/78f6ff2qETWBwwHU5NlfievYqIYw4uXOZqPeHqowqV9SYtYv6r/+Z15ucmqN56yAdeXOTU6SIF3eTRRo7qhE/tUZ0XP3aU+Wmd1bVtrj1w+fTpp+h+awU3vQ1jF4isCbqmorvT4PCUga7g/u+9w9TmLJ858xnGsynb+Cw89yQLv/LTzMzOYHhZUDppPeYP/uB7iNrbXNlap9FqEAU+QdJBpsnAfzSB7tiYXoYo6LN17zqogfL6CEq23zRNB5EQNOukfoeoY+NbFolMiebnmD8wwRcufJxzCyfR0QlViqHadKs+Y+XyIFFWEY5w6fTa3Fy/wWzeYgxBt5+yKbqUrCovv7bCJ858hlRI2vIRfbboSJNvrJv83IxNTz6iaoeEPQ/ZafFg+UscXfpZ5nJPUjr5JjfbOzTv3mV2weSZmfPcDSWWZtPTSig/pBj6uI4g0HXeixRae5NCdopeELK58pAD+Qn0yXlOnD1HyTIxEXuKY7rB9155lZ/5zKeHUt0RcRwTx/HQ7+S+DtWQhzCs9o9kRXfJ/oZOMhQvkGqvuyUYVN0d0ySWKQg5aDsqhW7oGIZgJCaQLxT41S98gX//d34HyzIplYrDjp5gZmaSyx95EW/8DFPTOq99/3sY+RKb71xHOJuo8hIZY460skXKPG6Sx5AWWppAGqFN5ennU9Z7RWYOWbzyg1f59vdfY3J8CilLaHYfTQyuiVSRDmHLyVA+OE3lY7NU/jp7X8mBJgSTE/PYbpP//p99jcL0Qb73tT+n3UpYvnKT4yf7vPCJGGHnUUkFFdUQWgR6FqHbGIEG2RLvbXWY9Ra4WazQMfskjQTjToVWKinmxrCUJJECY2yahUtPsLq1THZmkiSRbNyPyGUDyrM2/WiSYqHAyvUN7ry7TCcIsS0dqzjGB5/x+O53emhhgGVIclOLzJ44hDe1Q7f+KrZ7gn53km5rA8vpMj1/As0wdiEgQ1TlYDP84Rvx97Cjv3UbNNklqJR6EhHHPlldYhsahiYQIoNuXeCpE112VlfYaUoafsBmP+Hi9BHGDtzHMwXvvP4eJ1KLYqIwUh8tFtzYuEp1bZl2vUG4oIiKNttLz/Pue99kWm3x7BNPkNE9Kg9ijGqVn3juFHzjTzF6BnruCDJZJGmkGP4m01Mmyc0t1B2bRw82uVFbZbu7wWa/yGLuo+Rtm1RprK93uX1ng0dXbtBbfof1SpVOv0G916EXBcQyGQw5syzcjMsXfukXeeL0aQqFAp7rkM1mdu/Nj1bFR0EBuy3RIIy4fuc+/+Irf0Hot/jYMz/OiYWjmJoJKFIlCTqblHIHCHWTgBihfBqdV7jRrCPThGKmhC4slFBMZba5V9/hwExIx5tC6WVMDAItw2R2nrDdo5NUME0Py5wm4yiS3hrLdxoszrfJWzk8z6G7uU68/ABvcpKvrLzFB2YvEQsdSzeINI3tdgO7v4kzdZA5LURYeaQwyUiYdnLoKUxbAlvT0MWoSzDc9JVC7gvQ/kb8cj8W/PFXHvs+RvLP7LseMZBrGRwtwHJ0jp/Mc6efcuuNexw/OsHczCRBo0/l/gPGMh5hYwy5XsBIHaQySFINQ88h8ybvVXtMXchRnIVW4FPtB3T6AaW8Sa9Tx3NsdN3YG271w5HlD9mRAwc5fuQpQjPDZnuDZm8Fa3WZ7NxZvvMvb+D8pMkT53VSWQBZQ4ZVNBKEkUNTJmasoewC7261OZY7yvfLq6S1GnLbR8gdOqmkWJjAlCEtLIqHZigemmKtskVmeoI0TnhwNWBqQcfK2CTJFJlclo0r69x+5z6WpdANm/H5DKfnHb77HZ+8HiONQTBNxqAw63Jm2iJrlfnyH36XY/N58q7O8loDREoQKSzXwu+GCDUKfEff3aBiriVDTLEYqBolcToI7oFh+LD7dWtCDH2OIQzn8Xv6WOy/D/Kg6/qwzT8s5Qse60wIRpAjMYQF7c01GJ1r9H57Af7wmkdwn0HGsM839w9N03YnJ8vRK0MVVIHYxWePJB6lYncOx1/blRtBoRBojOQctcc6F4/prwOO7XD85AmOHD2KlCnNNKQfdBizBI5poAsQYgzHeZKLJ7qs3b5JpSbZ7PY4EFmM5+YZP7CMZ1T47suvc/CcSTatY6Qh+UyOz//OF/k//+n/SLfZJtK79KZP07UPcP32D5iWPi9dehozFqy+2yaTZnnxyTnU9/4Us2uilZ8gDsdQO30ct8fMhEF8bQt5y+VOrcpmXKeddFG5SV767GcpjJewLIeV7YBH379F5c5t/I1brFeq9MImO70OQRKRyIEnmaaJYem0O21amzskSUKaJqRxPIB/Pb6FMMKUSU1i6MNOAwLHLVCeW0IDulvr1GQD6acY2gCymMiEoLvBVOkUHV2gREoab1LvXuFes4kmJaVsgTjWyFshGXOD1XaNg7MRVXuekl4AejhmianMHBU/oplsg3DIOAcQ1gb9+gYb9R7zs23Kdhk7YxLvbCHcLEkxz79KFZfmLtGXOgulAiubm2zVthl3Jfn5YxyQEQ0rTyZbxtF88olG2csS9TqkShJKl3qrxd1bt7l+7T0WFhZ4/vnnMUxzMJsj1XbXVZqme0PKhnwDOcAO7R6zyy9goEI0gB0amJYxnAquDWBBlolKUoTQ0HWwjMH7aIZOGEZkc1kuf+ADfO5zn+Xpp5/GdWySJGFrY4NiqYztOmiaztRsngt5h+v1Huvr0L75Hc4cO4NdDejdWeHI0Yv425JMtIiKLUJDJ9V1TNcmKVq8W21z/qNF9KLNSfk0FQzW7t4nW8gxVjTYKmaotXxknGKgSKME09AHkCJ9sO7iJCH6q1cv8H5hRUHKwvQ4H3n+PPXQR9eO8L1vvMna7bfwZYl6O4sVVLj8sTFwusi4h2YE6KYNWYe0I+g/aFGaX8Qyn8DNdNCsNtXtCldvVvAsG98s4M08Qaht01y7SfWdTRbPLlDbmcKr3yNcrZAuzqAXlgiCDfx6m+Ub6wQbHeyCR95zcEWIChPiboIfBcwWFXNjbSasVZQf0qk8ZHWnQVkluLkxLDMlqL6HMfsM7cYWmi7xCtMYpjdchxojXOagJbxP+3bfGt2zv08a/k2bVJJIRiQqwRKSINwg1F3iREfTFY4Bhn6KgvV9zp89y8Z6QDeo06+CdXia+koXTcYcXQo4udTlwHSJ/BeewRAa43mLNAlIZUK7pbO5VUI7fpSV5a9geZLcGUjbEXFfUPYmMR/FyLaFoojQJklFjgSFLhRGEpGWxqjFkqptoE2VOfZEkcnjxzBKRd59UGfr5n2qy8vUt1bpba2x09gkwaAVdgmiwXVYjsX8oTk++6lP47oO58+dZWJ8HNM0Hxve8qOetq91j9oNNgxdp1zIs75VYWIig+EZ6KYGSPw0II13sPUAw8wRE6NUh1hu00u6+FKSz2fRpUbGdvEsjWp3k+04pEDKmO5gi0GgFJPHcQ6Styu0/DYlkcHRXFzHpZ2ziO50aLc38UqLJDqkRkKs+lQbVbrraxhTF0gNg0gIhGVQzGXodNuYJOhAwXQxdRsUWLY3GM5kDKYjw94U2FGl8m9txOEQmjGI6dSwZT2a2KyhVMx+AigyAZUi/YcIcxzM8QG2OqMT9GFtXXLssIGSghSdsaVJtm4uk0vHEb5Eqi6YFrg5QssgziboeRt7UqNtSTaaXVaWNzH9NnExh5ctoBvWEKc+IMGNsO/i8Whj1z566TkOHDzGWqNFvG5izxzHlTbba3fYzJ8m800f0elz+mIZ3D5p1EW3Agwng8oKkp4kWekwNm9gWBfI5B7Q1SLWql367QTXsumZRQrzT1G71ae1WkeTbSaPLNKoTJDfuc7m/W2YfxIyeYJmFa3W4dH1ddJKH+/AGI6jyOgJ0o8ImoJu1OPIjM7BfJbyFGhhHUPkaTbbHHAF46cu02pXuPLeDaJ+l+lChuxElndv1ukHCWGUEoQpcZxiCEEsIR1i5BkF22owA0LJgWJUKsVAL1zt8YhGeH81CvLZp1A2gv+M1rAQjIYUjTTJ94Lu/et5z69H/4nhVN1Ra+AxYjDsrgqxLycYVDYHP+xNNx7xKvZBmBg984Yuq/aSILl77v2KS/sSEyUek2gVgqFay55/ja5CCIFuCAZD/jQyWY8PfuhZnrl8EUmKTUovXCcSJaIUTAMs3cAwjlGwf8DFi5e4f+frhG1J3HYQzhj1lQ6GSDhzLGB2rov7/BRn5i/hOjnOnTnO/xb7pCphp2JRaU1hTS2yuvxtLE9RLuts3+mSIUNWFNBXksF+L8poxhSxcFAEGEKhkZKW81TDhJpjUT4+z9LMMaaOHGL8yCHu3tth48qb7Kwv09lep1vbotWpkQqDVtgnjiMUCifn4uRsuvUWrVqDftAfQsUkqUwZjrlGClDy8aRskFwppEzRTROUIg5Cgk6X8sw0upPwMx/9SRZnZ5EqJZJ9ZNzA0UJ000Xgk8gmYVqln/YIlCSbs5GhopzJoQmfaq/OThhQImVCdzFI8ZWB1MdxnYisVafRb1ByF3F1lzjjknY1wvUW7fYGbukgsQmOHuFHHaqVdaJkHWP2IkIIIgGFfA6V9NjpbVNWMUjJd778VYqFEt1mi62VFQwxCMKFHDzT/H6faqXC9tYWhUKBN954gyiK0HV9N+gf+aUYwuV++NkppUQ3jEHSvQsP2lMfGqlMjSBzqZR4TgYV+WgqpVwqYjs23V6PXCGD5+X53Oc+w6VLFymVysRRQLtZxzQl/Z2XMSY/gHDKWKZONmeRthOiaIq7d/6EY4tP0A46dCsrHM4fYULMYMYKKTtIQxC5Hn5GEOUTnHkPd1Kwret0nQxuqcziXI1QxNy/+gih63iugxARMYqcYxGmKb4fo+mDZ2b6PloH7ys5SKpNMmHMwclx5lNBx1BMHunQT5qsLEseradYvkemnHLyZI6kmeJYCjMjMJwsejFP8/t38JZ95OEJJssn6JQr9Nar1OoR0/MnMC9cJr90Ft9u0N7U6T5ao7l4gNpWl2xr8HDQ5g9DdobqzdtsPFpmayPAijQczSKnm3hpn04rQUkTKwkZyxiMZbo4aUjcMPDtAr3NVQp2NJBlrVeJww65Spva5hrjkzqlqQNE0qHTjYlSAZjMHz5NFEV0Wg0c12NmfmkQlOxiBAYutx/H9vf2b8IGD81YSdppQk5EWLJLFPaIMNBMEz1nAQqNiEOLp5lZrLD6MMFfl9x5uMHShMuBpy0unPWYW4BUwcGpCYSuMPIVnr08w/LSGG3fYHstZUkWaDV02nqM4eqk2z2MnqA0tkD9jRoTSQlyS0TSRlM+hqNhlLMkxYQ122B15xFhLmF+eo7FA2Uys4us3V7h+pVltq5eo1d5SBJUSVOfQILlOViGhTdmUR4fZ25uiYn5Mj/2Yx/HNkziJKHWaJCmKePlMQwjwbHtvcrvX5Is7OcVxknCZrVOIZ/l7BOnyOezQApKI5UJhgyxDIdADKezqogg7VCPB1Adx8njpS6OKUDvEQZd1lsptmlR0FxMUnwFEQ6uM00un9Lz62QtgSZ0DNtCZfJkLZPW1iP0TAHN01COQScKSerb6O0mWzv3KY4fQegeia5juB6T+iRZwwagYDhY+mC70oT2r11lf1Ncg/0dA7XvoTIKzpRSxGlCmsaotI9pCHTdRKCj0giiZTD6qHR7gBVQRZTQUEqgRSlj5TyWbQ2CS93CdrLEtfcw3DlwaygZgafDhI42bXN3c43ZM3NoeY26jHjUbrO5sc2pSZ1e0KblNwfBmRxUh8fGx4ftchhUyB8P8gCenFikWMhjA652EHN+Bscrs3rD4OFKlpt3BKZU6E7M4SN5klqC7kmMgo6RLUJTo72+jvOojzwxx8LMGTbv1IhqHToxTM8cxLz4QbyZ0+QPJ9SuXKOzGmKVF9jZ6lJsbiFqPoY9QWy6bG3fJV5bZ3szJCMNMoZNVotwo5hOK0XFMXYSMD2WY2LGwjAUQaNHP7HJSJ3DU+OkQqA0xVze4ORMhulihsUjOfIOVGshzU5C108JfEk/HFQaDd2k2e0ThNGgc5AMsERxnAIpioFm/3AE0G5lHx4PzkeB8P6KvRg4zS4Rer9PaUOZ0N3fjUJ3tX/Zj/xucMTINE3bl6gMEhc5hBvtdq7E40H9yPZ3N3b5EqPAir0kRQzFE6QcJSR7MKLRP10fHL1XlYX9c1t21YmMgQixYehYtomXy6C5Dl2ZkBUhjuoRdGNCTFzPQnN1QKKTcPzQBcbmr2NGHeqrPkpWOTTtceQZm7NPeDiFiKmizfmT42i6jZat8PyHl9hqOHQCQWtHZ6Kco9kw6Bg+TkYnrTfI2B5uotO82WI8LaPyh+hGCj3jY2YFWilLnJesOyYPNx5gzZrMTR9mcmECMz/G+u1lbr/9iO233sJvLpNGTWIZEqJhuy62YZEds+j7EZlChuJkgdvdNqHv47o2XqFEkiT0u138nk/Q6w66TT9MGB9iyNM0RdONXf8zTAtd18i6Nh/90IeZKI8hZYKUMbqKsEwHX4CJIlI+/aRPO1ZYKIThkhcFLFORqD7dsMtGJ8EZ7veCkEhpSJHFc6YI84pOt0be0jF1Dc110LwsniFobD7EyI1j5Cyibp9Gv0O/toEZBGxW7lKcOEoodAzPI6hI3nv7OvWHW7TbHV7+8lfIeBn6nQ4bGxskcYJlmozkRgedlRHRVuP69etks1niJBnw9B6Dwmm7BV5NCKTYmxtiahoqHXbuRpCjIddGExqGpg+JyDqulwEJnqeh6VAeG2N6ZppssUCSBhRzFk89fYpiwUVJHxk3UeEtsnkIw4ckySlEmkPoApUq4k5Iu9VA6TahAul4GG4B2exjTpeIOptoDqhiSl1rsB7UMXtlFp5eRHmS7SChFkaoJKZYgI4yMPIeVj/CdjRsP6Df61LO2lQaAXE8gErquolhCKDPX2fvKzlIN6oE97fwrTzdWkI05XLqySUWL5/gnT/9Jg+uPGDVPMof/l9X+Y9/Z5akmkPSwi46mJNl9OJpulaDjZernM0FzI4vIueOUL1/n4mxcTKnP8KRz/08vdRD6PMsXJilFtzi1noRp/4KW1sBVnEaOztN3I9YvnaTOz/YpjQ2Qc5TZExBNk2x45Qokfi9OiddjUnbHOCtlE7UAt/wWNJ7dHx48OAGtVoDKfvkMt+iF6ScOp6ls5KnWktZ3ejT8RMQWT75hd+l3Wiw8vA245MzTEyUMExv2LY1djfcv08M/t/afnk/gUKSKkkkoZakOJqPY3i0OisEkY5mlohFQmwu4+oGGWuG+YOn8VsRzZVNXtdf5vM/9zRT232cqSyaGWKwgV2ookgRos9v/tox1uQZvvnKOu+8/gC13cDJldCKLXTPwosqiFaIbjdpbrYpT0wgCuP0/CaulpAt5UjnpqlOSF5br9O+cZWF0xPMHj2ARYGNmw95949fpteo4cQNNK1P29XxlUdGs8mM5Zm0y0wulDh39hxnTjzFVnWDrcoOpq4TRSGPVtdIpeLieQ9dE4PkYJ/9pV43fKj3fZ/vv3uNU0cO8tMf/Sj28OEqFdiYaGaZREkCkQxgBMqgHyvqvYi80iD1mCxN00+3aEcV8q7Ow2ttToyXwcgNA6QEpQyytksw5hJ2wY/VYCKjYaKZJcqzU7S2HuHNTeN5OsK0aDR9DL9KT0refO+bvHB5ilwhS0tCK4XTxZl9wdS//bWllCKNJUmcopk6mhhWkofB9UjZoh/6xElE3LtNKV/GsLOgUoh2UMG3EE4dzT6A1BZQykcpQZpqOH2fZy6WcDMWQtdBpWzf7OIkGnrWInQEQpnoRQf9kIt22Gbl9zdZyM0RO4J2J6TT7aCHPqXJadZWH3Dt3tvMjx3G0z00Abl8Bl0DTXfQtGFwOISKjCy/2cRSZY6MLXHuxCTdkoY6YnP8pQu8/E9/n0a7xI1GgcafPOS3vjBHvJ1FaA2saQdjbB7yRVqqz+rXt7g0G3F46TR6+S5Ru0dpYobMyec49vnP02hrjJ/+EE6ywM79Le5u2Nj1H7CxGmHNHMCwC7RrFe69e5vl9+qUxscZz6XkhMKLE0xiIl0Sdnuc8WDMHcAKklgjaOp0WpJz5TEafszdd75JEPQxbcGTB3P4YcJiIWLx6TwPVwKqtYR+CFFqsN6NcXSNsbEJHm7W2dppDDkJGo1Gh14/GnAI1KCqPuoa7fcTRlV7xO5k0l3Y3wiPL8TusSPC795J2I8C2ktEhXjs/R7TZh8SlBlBi9QgsRjwJhgOHWPfNQzUmX7kbYdBp9wldI6aIGIgKT46cI9tscejkANu2EDPXdv396NkhF3Ik24YOI5NNpchiSXjE+Osbm5y9d59nijmsLUAz8xRb9/DlyW0NI8tU2JjDUc3yNrzHDx9nsaVG6zdXaUjavzyL1xiajvAznsIvY3hdlF2a/B9aE3+0e9e5J58hj/85y+T9PvQ6uEUioiiwPAsct0GbugiQ4t2xac4Po4ojNNubzJmG1jjJcKZEluFlFc3duhee4sTL51ibHycNDJYu3qXG3/xKt16jXxSQzMjOoZJiklWt/HKOUpGnplDRbY3quiY5EolVh7WKIynjE+W8UrjdDodGjs76HqX0O8Pugbsv+ePV8CTOEY3LNxsltLUNHHYwfIVnjAHwgUoTN1EN0qkShGQYJCSSI1uJGn2I5xIEscuc3NzbPRvoGttDAGPNrucmhhHaVmUCgY8HaHjuC6RcAk6in6skDoI3cXyyhQmyrQ2HpI7sESh4FFdbyJ7HfK2ohcrXn3nz/mplw5TMG02ZcKDjQrf/qOv0KrXqFaqRFEy9Je9dRFH0cAR1V6XFkA3DJSUNJOEJI4f7xqM7tWog7CPXzNK0He7bwzge7qmIRQYmsFEcQrH8RCGRqFQYHltmVw+x/jEGGMTZc6cPcPzL77A21ff5qkTJlk3RskGIg0w0jWK7htoRhNn6hj92CdJ+ggFkZ/Q39hife0VFk+eIHIUk/oik/PH8Jo+ytGoa23ypSL9Qsid3jpX2/c41DzN4eISkWNQb/QIu11E2KUvm1gkXHzhLG987SqObpCkIZ2ORsGzaHQl2YxFr+PjmC6JLqHT+OFH3GP2vpID4QpE2kfb6GKtNdi45/JwXOCdP8QLn/kkT31c4+s/2GH9qylO4SmM+ZjV994ivLZFzrOZ/tghnvjQA17/VxVko0nYU3Qtj+TUx3jq1/4DxILJ6nd6bO8kFKKYXKqTPXSCT/3SFGHrNP/4nzzgZz87xmT5Nhvf+BLmOzs0wxRtZ5PxGYO5TAbXM2n1Ypq9lFwj5tDpAt6kS6wZBB2dNC6ytXKXaOseb6+0CJOUnKszNW4wddSjNG1Rr4fcubmOFhmMmRY5W5ErhutvFgAAIABJREFUx4je18nEGk8/UcLLp/Qq3yM3+QGkDDCcCYQ2YLL/DcOc/39q+x+qg5+lCtCERZQGtOKQVpIypitCHDL2FPnCDmavTbe2zsqdkLlLM6joEcLMcOnMp+hvSV5791X+0587xXj218BbRqkGSm5B2EJ2OmAYiFIVoS2yYF7ghcs/jlbe4kv/0+/zYx+ZZjl/jke1Pkthh6IF7W6KtGLkidPssMHYYkymXCScGKdWdvjyzUf4UYfnPvUsluXxYLXHm2+8Tf/drzDmFkiTPp24SeDYMDHLwsEyU2mRyblpDs9NoemCSqPJV776Mg0/YnPrZQxD8KGLT5LL5RgfL1LalTwd2F9dHR/WLYWgmM/zH/3653ePDRIfqSS6EDiaRTcNaSqBK0IaSYO6v4Hf2aaUSHL2Scr6Bs2kjmGGjBk2D5oh3dU+xaPH8AyLWBlIBVlhYNBGt3Wm7RM0+hFh2kcoRVbzqFgOetqkE1Zp7zRQUUh2QseeNmnc2+HhN1/lyeOfpJyfYlo3mNNGDvGvwTb/LZpS0NzsUl1ukTtQZGo6Q5IMgqF+EBPGCUIb8GGiFAp6E0PYKNlFpA8Q6RsIzwcclNpCyDWUzJDKMn6ooYebOGNLNPsp+YyOpWus7MQwXcAppfR8RZiGFOYz5A7qvPzNNV744hkMy+aRFGw1E0QjImMqbq09oiRS4hokborKpsjUp7Jxk/L4AoYlEIxa6gOJyJE162sseCWyiYbYrtNITVaWbaY/cp5f/U9+i3cfJbzx/fs07hSxS0+QXYq5/crL6K92GDtWoHDyICcubfHm1zeR1R38oEMnP0Pp+Utc+MmfhSmD5Ze7bNZcFmQfK8ozc77MhU+UCFvn+c/+izv8l787g77yNfzvfRdxo0EjTNCq68wsmMxlJpFEtP0Uv5dS7CQcv5iBgkEQWySBSxIa9OtVbj+4ySv36wN4XU5ndtZmdsmhMOGws5Pw8JpPTmhMmgIsndy4w6fOH8WvJUwuHUUKnTt3N3jjnUcUy1m++vUrRIkkSiUiebx5LAT72vWD9adrA7iQHLBNdx1pb9qxvqcYNBxKNpJO/BHbLUDtSwxGfYVRfqAGmuaaYDgBWewGUXvETMXjZ2IX8jSCL42ShNEU48eTiiGMb/f8j097FuypGu0NmxoQunVd200aDEOnWMzzc7/wU7z26jv89n/47xG4HrptU9IgxsVzpimW1rA6HdqrNXqpYOp0ARUtI+w8n3j2l/lf3/mvcdUdPn3uGUq5X4HMXZSso+QDVK+JCkIwTURhC6Ed4qj5ST71ud/kGy+/xet//qe89PwkK7knufmgwZLRx5AxvSBBZgTy+Cm25SrzByTmRJneRIlVU+PlW5v04g6f+sVPEqYOr1+tcO+dd0nuv0HJzSLTPs24QT9bwpmfZWqiyBgFxibGmMjZmLbF+nid9WqD7VaXhYOnmVmM6DXraKZD2KvSqlYJff8xnxnFGD8sdSuHQ9SatQr16ia6rtEoZGm2OgRhgGNb5PJZfCloa4KcSNiIq7T7G8S9GrlIEfQ9zkxqbEc1yp6imxhsdkOCzYT8kTFcodNTBgY2poiRIsZwTOad02x3eyQqQFMaju5St2x02aIVVOhstTDNhEzRxSgI6g/qXP+zr/OJD/0aRcvliG1Qsww0pfD7fZIoHiSnQ5/aVfKSI0nREUlYI5UpmpQkgIrjfT46ujfyR7gtQtPQ93W5RmThAb9AHyThEmzD4+c/9QXyxTlev3mFauMWT5w8x+b2Jh958Sc5/9RZZmfGicIe3/jmt/nZZ1/E1EOQFUhvoolbiEyAwkWpdRyzgsTFD0K6HR83eYSuNyjOPced669S8ReZF+fYrnc4O75DE5+WqXGn8g59O8v5Z3+Msx/OYtomN5KUteUWaaNHxtGJ7HGmtZjVuxVMI0POipmeyJHNl9mu9ulGGTZXe5SKecq5Ap2wz9bO2o/uMfvs/cGKNraJvDVUQyPb3GaRFY5El7ndq8Ili8KhPOfOmFS/UeW7X73D87/4cbwnF9icbLPaAquTg2aHpz/9EpGmsfoX7yL6Nk898yLXrrUoZAv04h6LmkIGm2hel+MfPoll6shpk3/8352mDzTvKYR+mYvyNe6HEvIF3GMXEKJKWHuEaobMZfLML2Xx3MMk6x3q2zVWt5vcrwdsRwHHi4IPP2Eze0hjbFGQmdYxCxaYDqmfctksg7BA2OhOGc15AbSTIDKD26ViVNIgab9CmvokybPYmUl0w3k/t/Lv7a81hSImVTVSZaFhkCqfLb9G1E84WZ7lQeQzZRxFZDoY1MjFTd78P77FU0+BPHKVvj3BhLXD5Ykxxg79FPANYBviCkgftBStpA8ws61tRC4E8w2i+hWad66y/uARV+aOcegnLqOtSpardTpRzMkjB7jT7OIffkTz/hUmjlxiKzfFez2LR7UuQq/w+Y8f4/6jgJVrt2lvPmIm2KQ3naMZ2fRba0xcOM7hhUUKhk24U2FGD3nz1df4v2sJSdDBMcHJ5gj0LFbG4/zpc1y+9AFmJ8r7Km7vHzKjCYFpGo9tjJ7pDYIVJEES4uoFbKFoxqBSC1dYeK5Lak6xVt/Cd7tMuhmagaDS8hH9Diq0mfHmsfUshhjwc3wFmCUmcUmiNhk7xUk9ktSjLX2y5Vnkgzpe0MT0YpwSZMOU/oZkYdZA1VO+/Mo/56X0M1w8+gyGGExgN4T+V3y6v30TgN/sUrm3Ts8IKRSXiAOF7elIBqQ109DohgG3773Gk0uraKIDahPkNdDboFJU5KGMLMoIgDqkHaT/gI2bW1jaixjFGZo9iR4rDp2V3H1jm/BYmSAaQ5Q9HiYJWw8qHHo2S83IklcCGcfIqE2YNEmTiNlmh1hXBBG02lsITcO1+6RJmav3Qw7OHsc2bYKtTWSjRa/R3v2c07kMY20dp9HD1tZxxRYXsh/l2ssV4k+6LMxbtA4rbl7b5pWvObz4xU+R/+A01+91aJpZDrZ7qL7P8ZcukhZd7v7J6yxMnaE4dYobt9pk7Rx+0uO4oeNX75A/UqD05BKGY6IyJv/L75+nqaBRuURR2+LJ9D02Q4nKF8ic+SCy+R7RTgXDT1lwHWYPlPAbCWq1x069wcpOn5VGjyYpx8uCn362xPwJg+K8gTtuDKCIhk7aV3z4p3NIpSOMDIYzj2ZdRmknABeldKTsMX98hQ9++B5KSXa2d/hm9wFBEA8SA22gUiJJ9xf6d20/tlfT9wK8/cPStOEMl2Ep8zF8/mMqK1IxCIMG77IfpLR3uj3ewX4YEoLB3w9x64Pf7WU2j81ZUApd13Yrq49VX4FUjpTj9kGSfqhznu5OYh7AOgxDx3EsbNvCsi00Icjnc3zg8gV++7d/lX/4D/8BYPKw12Cj1+LOzgbHS9PcDXssWechV8GVTXprFd79l69w/jyo42/ia+Mcz/QoeUcoLVwCvgXsQFwDFSBshXA0lEoH+30hBvF9/PUVandvsvKgiTt+jMM/8SHUrYDrW3c5sThGduIgLd3HP/yQ5u03OXTup7gZjXE7FFR6bWynzs++dIT3bvSo3n4bdlaYFVV6U1lasUU/XGHu+ac4MzWHFgSIVoti2uftHzzgX1QT9LBJNusg3AyR5iFsl+z0Im98538mDnrEcUQSxQPoTJLscVL+so1JDbvsSQgM5DcToOJ3+Y0v/gbj5TKf+9zn+Plf/HkMPDwU1TCCRMeWEtsyyBbKbIuENdlk3hvnYSMl8DukrTZ+N2YudxADFw+HrtRIRIJpCSbJEEctsnYCskQ/TglNRSY/iWrskAmqiEJKhoSkW6fbbjA76xBWBP/Dl/5bfusnfpfF8Tlmxsc59+Q5qpVtHNfB9/0BUV8qkjRFH06a3j/LYORbu4ntPqidGsp3jvw5SdPHYG6j5FvXjV0JYokCmWJoBmgapmnSWa2R1i0yZpaXfvHzxL7G8vZ9nnvhOQo5lzv37vDtH7zKSy+exMnU0fV7iPQdBCug+4OOceyBXkaYPYTcQUt9ZPc27eVHvPDSBZ744EnKP/4c1771Dlf+/Bu0+m3uP7jJT/z6L2PMZym3jlMWkpkpl5aTR1Ogpym21qejByiZMN2PyJXy+N07HDlaZGlBUs4Jwshmx1xAPlrH8Tw+eWiSo5Mz3NjY5I27V/4yb9q199c5mDqDnj2GXFsn7E+StLrYrbc4NPE2j+RFkvY5jh7I8PbYh6msvkOzFpC6giPTk2QOZFEJPMx8HqPRZHFhnMXSA7qtCkm0zNzlGXaqMeOLFtyvkzleIDO/iCZs/LdjcksWzTFBxoapg1P0njtF9cs6HzYlG5HPmBsTdhVGz+SA7RFkixSme6jNeyxvpWy2InxSFo66PHPc5fARB8vTMVwDzVYIPQLhIIMJhJPDsGyEUQR9HLQiiAVQLZRMSYItks4mabuBitpYCz+NaZcQaKAk/B0KZP5u2w9XxRRS9kiTFdAkYA2rVwElI+B8XiPOZomTLrNmwmY/Jk4FlrAxx+Hgyad57Uv/jA/8g5OIzrc5Mn2d85+VqOD3EE6IipqoKEFoIEwdpQ8JdFkTiCB9mbsPDF5+NQRdsjTj8tLMQb7z3n00cZwEg8qDiIxtc7+7zeKJp7iVLNLS88ipgLkHDznzoYNU7txh5wHU125Tb6zRCmOSUDJ5bJ5zEzP0+zHNe6tUmy2yVsr1lkGtu4MUFipvo5fHKE7Pky1P8sVPfJDxUgHXsYfQX7HvSf9XJwj7AxQlxA8p0wxeTWVMIhMMoZEqRShTTM1lzJyi5vdYri1jWgrT85nO2ERyC7QIadlcb4TMLNgcKC9hai5CZFA6RKSYwkCXG+iaiWZmQIsI4i6NZgMrLZKdH+fGyhqxkOjKodvrY45tsbMToGsm7du3qBzYonowoiBASYlh/t1aU8IMkek27VcfsekISqVxhONgmxqtAO5s9ulv3+SA9Sam7CKkjhB9EH2QfZASpcoIPQtanjSJCMMH1Po+W9t1xIJgtiSwULRWKzx8+RWWfuZDaDNTHDENNoSGXw9pVxOufmODn/qlc1RChdeNSR+s0bp7B69QptHqstVrcHAmQ9Jr0xOSwNHYaUdcvdPDryVETZ9iLJjUbdJOZ/czpksv4nRMzEafJPAgVGj33uBE/22uf/OTTDx9mIOZaVbzT7G9dpN2I0KlBs8cX8LSbTqNPjf7H2fCkRwtzHG4/BpavIXhTjB5YoLmTszEIZvk+hbly4dxxzLgmwTvxuQWLHYmoGyCe+EwrY0l4lcFz5mKjdinkE1prsFY7FFwbZKCR2GmD7WAqysJtX6IdCVHz2eZPW5z+IiLmbUwPAvNjBGGQuGQ9HPglNEdD8OYAK0EooxiGpXWUeSJurcJamsk3RrtVpOvvbrMnfsVLFPDMDS0eDCBfRSwjKqVcjfgZi+Z3x+lD+GTkpHQxd6q3Y/bZ3DkLvRrQAxW6LqBYi9xkPsCcQWPze0ZBZXwOAl597uWcih9qnZzhV2o0/By96RRh9ez79xCe/xzjT64kgr0AUxD08G2dVzXBgS5bIaf+cyLfPazH8eyTYTwERgo1WfBCZm2LOLUIJE95k3Fw04fXdmYlok5lWE6OM0rf/QHfPQ/fwZt64+4dLlKNusjg99DsyNUONjvMQVC12AIp1JZE2QAfInX3kq5cjPAtEwOz3p8fOYwf/ztt5jMfZCbbRe9l+KZBg+6Oxw4+yG+35jAX/CwuhUOd6ocuTjHxvVb1O5AffU69W6LXpgAOpNHF5ifnKXVCll9+zpGHKALybsdQa1TQ1MOciyDOTWLXRiDMGHlnddYffmPCf0OaRyTpglSpkMlq9HtVez/ahACTWgomaBpxqBKnqYomQ7iEdMgCkP+3d/8dV54/nl0zUBKSUhCxszRqOm0OhCkEt2MMDMx065NN36EaYWs+gaPhM3CosdiYR5Ns9GVQaJLYiQ6OnraRxMmup2DOCToNmm3+1iqRGZ+krdu38WxDOLIRSiFk41o1Fq4rk3z+nW2nm+SLU6gOxYz8/MD7X0lh+ISw0Fe+z7yKEnY3Y/3w/FGcCExlOBVaiAJvvv6cFkMb6K2qwA2WoKD+yk0gWs7WJZFs/6QKWJOGTbv/dnrfOEf/QaXvJNYrkU10AjsEicPTnBp7gqGshFyC9jZ2+8VKDWGMPNIUSBNdgiiCq3Qp9HymX3qBQqTYxjSYbKQ49wzJ5j66DkWlxY4WMxxQwnCtR6NezWC5RovfXqarUBSaAYkt+6hdbqYhkWvo9hob3P06ASlYoJXVOhOHr9TplKDnLnJqcPHOX/iBAcnxuny1ycG8D6Tg3DlFlFxlmS6RKWnsxV1ScIqa+2Q5k6GOaPAwaMX+He+cI6MXMJ2c+gyxRQmlq6DrrFwaAaVlqDTwk4CxGyOzMWTuFlBdiPm4XubHDhSxJl00ZoRybtNjK6LdLMkBy1Wzuv4kxqRViISFznovkYhZ9HTJI5l42SLOJpiclHHv17hZjfFlzrWuMHSYZv54wXy5SyZqTIkLdANhOmhNIc40sCeJo1T0siBVCONW8hohSS8zRtXN1mtxfR7AY7jsjC/yIWzZzGEg9AMBhPy/m5AH/6/aFL2UXId1BVU2gU8ol4NTcuj6zkcTceWJjEZMCaZpIPUUxJdZ4cZnCWXieNzGNW3MXoPMewK7kKMMCQq7QPpgBqiwWA6qIkSFkLTiKIETQs5d8jhFz6W5/frXT727CdYcF2OL05RiVz6bZBOBi3vIIXGyuQ0mrKwm1tY7S65JxZor3V453ZCY+U2/U6dMJYIw2T6yCy6plhe3kbzI2RfQGQQxj6VfkJq6px+6knMQhEvnyeby9FtR8xMlrGMPfnJEU73fdmwivejkpXisf8HeGSJTGMSGdEL+4SxwjMLVIM1lsamaEofUxj4UYd+16cUWCweOsV60KEoJTlDJy80TGHQlxqWVgSRkJF1AiGwHcFcHtIgJQ0Ser0u1Z2YjLCYzGao9puIqQzZWOH3NB41q5R2NnhqbIpu7JMxnd3A59+mpWGKTBWF8hjHzx6n8/oVrvzZV7n87AXc3Cl0y8PUIKsiKmt3cE410E1A+ai4DUkXRDTAhRMC7uABnnQImy0evtUhciZYmrDRhCKuV8GvUTh7iANzE2i2SVVp2JogF0v0SPDMpSVKjs5OmPAXX/4yK7euIWRAcWKHfi/ApItzPMUrCTKmQdAz+cG129TbY1j9DZ45eZzpsTlcK093bXP3sxqVG8iJJ2hTpLEpqfXaqKTBw25Iu3aVZ6YKHDq7wNyvPIXHUYSycKTAFiamoVMoZTn95BFMXZI2mnj4mCdO4h1fwrAg2oi4e2Wd009OYhVMeNgjvR9j+A7SzZActbl9SSN0DSJtHqGd4aB3lULOoqMSJrwsmVQjm9HITGn0r1W51g4JU0Fh0WDiSJapAzly5TyZ6XGI6mB6CMNFYhLHBqlRQoaKJMigUoGM1kmCm/R7knduNHlUjfE7bWQa4pmQsQQ77ZhukAx10NVQsUcOScXqce3wH3HXgZIPDGANI97AfqjIXlLwl63Z/fBLuQv12aUb7OKw944Wo4BfKXanIg9PKYZwPaHth+3tkTIH3QN9dPBj02T3q2ruJ+U/FrRpw3MjQA0I9zJNMUyDS88c4skn84yVVlAEkGQIu9vo5jSGbmOg40iLWGUQxiTTNDEsnY7y6JLBPCCZOD6LWP4u3vY93KkOdjZB6AkqDYAUYTLc7w2EMFDCBE0MFW16/NilCdJehhu3PD566UVmLZNTh+b4f9h77yDZsvu+73POublz9+SZN2/m5X2bd7HAEgCJNUGACARlECTFJKvMAEouynbZpT9s2tYf8p9WlYslV5ku2RKpREKWRFIkQHBBRAK7ALjAhpfzmxw7pxvOOf6ju2fmgbC5ZplkuQqnamrmhem+9/a5v/sL39CkyzDzEGGEyCmMdHkwu4iTgrd2j1xZEC7P0Njo8MbNjPr9Kwz6PeLM4OfylKamEMJy7942ziDD9CXWCPo65aAPme/wzDtfgFyOsJAnzQQb99fZXbtHPOii0/R4Px0Rvjm69qOP7yjLPSpMjTakcUw2mS5jwGh0EuJ7Pq7rYa1B24wkHRJnffbaDfr9IZnIsGRUHcVe5pJ3PTrDBNO11FKPIJ9jfdBk1loCqagKl4E1JEbgqFG8z+t9+m5AMVcmMB7ZoI+OY9qdFtt7sBR6uK6ilRmYdimkisaB5Vub90iFwwyC85fOjWGz8iinEmKk+jZ5jh0V20eX5hgWpPUINqfU8V6Nzej+PJKqtxPFJ4m14ykYo/3tOA5+ELAwv8A/+NV/gEBRwMPbPqR59Q7drTrpjddJL58lKuUoC0lT92gc3KH05BDpKrBDSJsjKKkYFYuCGEsBYYfYpEN7q8n6lS6yvMLz52ukro/e2qVQ9cgtPMn5x8/hRiE7SGYlbAwNshDx9IUaFV+xN7R86jd+k8PNe0Q5iRe6dDtdPNnl+WdKlIqQd0I2d+D27X2UzrG0WOPHP/D9nF48j+/mCOL6dwaoP7PeXnHQbDJMW6ilMrmlJcq3p9ipN9l50MMmbaTtIiKXc4sBUCbpJGSJRg+HDHttvDBPFLoIVSBONUluFRxFmC9gtht0NvvkwpCwlENtHcIb64ibHaS5gGEHr76ELyLEYy5BVKL3gx9m4w++zSk/wBUFEuHiyC4OHWwz5v5eTBrBzOUy1XNVykslKjNlXC/AKoFNA7JUkWUBGT79bkLoG3TfoHyJ1X2ytE1qFZ36BmF+AdG6TT4/oFItUlucJ6iew/Fyj2zc7623uybXy2BMC2vWsPom2LsI2wZClG0jdBmRuYishzAuyhTotyJyxdMIlZImGVqdYigCbLlC/a23qKQ7BCspMlIIMQCS0UPiiPgnAR8oAxabtjDCUCtUeeHpi2w3Y9Zu3cZtCgYPNMOdFk6uQvX8c2zt7zG9tMD9nQ1WZmaoVkY44TgesH6jw87D+wwPt9BSocIc+ZzCVV30fpNma0CEwGpDolOMydAo5s/Mcn5xhr5RpAhynsfli0s4Sh3vq0ce6m/vyj7ye9+xlDzuxvtqFIQdYZFOHhVMIRjS0gc4MqSZaKRW9GJDlmmKIiAflMn7syPnZguBVDjjhCO1BTApkiGeSMDxEKGgT5NQF+mKEs2DPWSkUdN5ZF3jK4P1NVHRQ5kuSWePpJBDGcvEeeSvY1lrx7atoz8LKQgLEd7qApEeUvnCPvW7O0RnzxBGARKL0BlhcjhSD1EWdAt0Z9SxVEAmwVUg8ogsJm7UOVzbp0+OmVyVsi8YJk16nTaZsMw+toKQikFquHuY4Xc1ntY8fTrH3EIOTwlmQsn+5gabGxtEvkHbFiqApTM++ZrBCQ3tjmZzK2WnNaBSNZxanWZqJqJQCpBuhG1HR+dtBl1sKcVdnaF4KYd+uM5er8Pm7S75rIEVMblyQO1UBFSJ2zEi9khbPYxKcP2QUiFCOoLhMCUtPEZUWcZTHslOg+72gEIhT1DKId96AFd2kBsg7TIai986jR8FuOcU6cIKg3e9j+0v3+KUHyBtES3aI/ldMyBtaB7sDTF5y/ILC5TPlCjPFymUCzh+CFJijUcyUGQqItEOySDDdQRmoFGexWZ1Or19Ot0mSX/Iwwf7pEFIpSxxoxr9PqxvHXDYjUkzw3CYkWYjJ2FtxoTfE2sCsRGMws1RT91OfAqOE50jXwKOE/zvhOwcNeQRJ1PFo8Ji8hpHylknDkRKMe6+iqMD+S5shmNiOsdTi5P3gWFSIByTnifY9/HfMrYYOXEujKRex+/oBx4f+KHneP8PrnB2VSO4i2CANSHKNpE6RsQJQidY46NMnn4zpDR1AZkdIsmj1CwDX2JLFQ6++TqVbBdVkyMUgBgC6SjeH1ksu0AAFBBYbNJAS8Pp2SXe+2KNqGBYu3kbtwnJesJg95DS2cdwZqrUuy28uXnurD/g8ZXTFD2B8S39bp+d62121u4RH26h/Rx+oUCUlziiRbbfptnoU5KKWKf0TMZQa4xymD8zy3Ipop4JdKrp1Ovs3rtJPOgxMt7Ljojd1pqRUpQ1R3vkZIQ/gseIkSmiOCG1rqRAyBGx/Iuf/xIPH67jOA5GgfRdciWPrfoGTjCgMGUpRQG+47NtBO1uzGHPRcc+gXaw1uH+2h5PLWoiKYmEQiHpS9C2iJAJ0nTxMeBKTGDoxw30oEOLMvXNXebPRziuIOsPyEmF8CW5ouJw5xaNIKBWniHynSOjQZjIU8tHpgNHpfOJQdVEfnR8VxzdCUcTgvEkQWs9gg6NSTpyTJZXUhEEAefPn+ejH/ko1WqV9730vpFPQpqR7OxzECn2PrvF3tVNZh+/gO86JJnFtwkV2UW5HsKRkLYhHTeChAQtEa4DoohI2vR2d2jutcmcHAulWaZyimZv5HvhV/LkF2ZxPY9hZrm1l1DtZcy7itxKkdmZEN8RzIWSh3fvMejsUxwIoqKDExpOnfYoz3oErqS+J9isG3oGls/keXblAucvLZArVTDkUOX8d4kCj663Z4I2VUMs5IlnYrrK48zyGbz9mNY3Atz8LPOrZTJH0teC0AHhebjKYpOEpD/ApAkKie8rCIuoxadAZzAwdDdaJNqy8vgSfiLgrX3E12+gOl0QCmtb+EoxFc2CjLBnfTofepE/efkCp2SHsirQG8cCxZDmoaFeiFi9XGTpvecpLE4jVYCwPtokJO0Wwzgk1gJtwNqEJNHIXh9JgHJ7oFqgMvDOksVDzq9epLwSkPNSSqUZwtJZXDdCqQjkxDHmbWRu31vfsSzW7GP0LTDXEOwi6IP1RnblpglpCml7JAOZhaR1gaMEOh1A1mduLmIPDylT2rfr5KsxwnMQvsLaGMQoyFhjQCoECnDBhKAtMu2RiBxWrlIuPcN7n93gs7/+uwyX77FxXzFoDVi6eI6l2lluX3+L8sqz6EFCj2LfAAAgAElEQVQTS0RYqSGNZOPKTR7c6jI4uIU0GuVF+L7FVzHd3W1kPUWkLpkSJAyJyRBemZlKkeWlKQpW02/06GWCnAp48h1Lj1ylUTD8/y5FlkIh1Yh34VjwhENmHIpOxMDL4TkOhi6B4xPqHGkGOTcjV4xx3Ix8OMNK8SJSKiQGBUgkBSlo6hAhFKko4tg+2AE9peg5KXMyR7sbEQ8USSDoCgedhgTdIT1pCQuK0HZw+3WwpwjVXx+PZ1QYaMhGRFLBCB6Bo5BuDufpi1xuHfDWN7eoHHQJSjlQAk2Cn7VRKgRlsWkCWQ9BilAOWIdR2BVY3aF7sMP2nV3C+YssRvMwzEiGA7SxOMUS+UqZdi+m3ZP09lLirmFpyuXMSkTqOAgE06FiZfU0B9tr6M4mNVczvepw9ok8oW/ptzN2dgVrdZ9cbYaFOY+V1SkCV9DtNOknCVv7x7Aib+UUzmpEv6TRyuXsY+cIDjL2hU9teY7SXI5ECgZaEDggPR9fWfq9DunAYFIXaQW+70C+glp5FyoXoNsJ/e02qYUzT59GNAx84yHy9j3UQAEx0CHwQ2YrU0jpk85Mc/D97+SNV7/AadFmyinQMh4uGpsOaQ41jWLEuaeLnP7gM/iFPEJ4WKPQJiFuthkOI/pj+VFjDTo1hGKAI0Ks3wSngfYsSVDGqJTq0pDlS5dYrBXw80s8XO/y5S/+KfsPbxEnmkGckY4N0sy4wztJ+k/W4+LEtG9iJDbaXDwKERz/OyelsP/MzX6sfnT0PpMuv5kYn8mjBoIQo8RKypE/w+RtT7RcR4XI8eDi6PiOScSj72ZMcDZjCJFSCq31eDLAuHPLGBN+DJUadbXlkblcrVbmP/4bL3LxfEIU7iOoj6Zo1kP6HpgDMF1Ie6A1IgtI6wI/V2LYuEMQVQnLHgfkaKiUxpUDSmc1InARXoa1CUKM9OxtZkYkZOEA3ijeZxaRtIlVBeU9xunFGeLOPV79P19meOoud68LdK/D0tkcUeSwsXaP4uLj6H4Dq6YozpRoHR6we2ONtdtthoe3UBjwDIFvEFmPbuMA2cqQsUviCga2Q6pcRFBgOpdnebGG2+uSNFN6js/+7jYH6w9QUpJai9UGYzQTFarjadKxM8nJ/WWtHvluHFWho300MdjT2vDyy59DfV4hpMANfErVErPzUxgSSvN5Fs9WCN0ih33NobUcHrbQcYKbSlQMvUFCc3+P+NneiJsjR+Zg0jh0kAgrGVLGs31SDIkUdGVMLrMctnKYRDAULpmVJH1JpSuIpSBXUuj2GntrHnbvkM5eAyWPMD5H/hgnJ1JG6xPTdMZQouOJgrWMIG3i2P174nBsjEHY46mCGBPkA9/j4oXz/OjHPsbf+eW/O54qCIQSELj44QL4cPrebe7c6LKqXVwhyEwCNqbqg5QRVniQdhF6CMqMG5EuQngIwKRNDte3aeyklKZnmAvnMb2YpN3Geh5BpUxQyNPqJXT6gsF2TKtnuXghpLoQYJ0RpGompzh36QJ336gT0mO+4DK96rByOSRwFb1mxtouNLMc1fk8p2ciHn9iBU9Bq3FAL405bA2/M8D8mfW2ioPSS48TvO8CD69d5zP//A/5lf/+Y5w+/SyLSz2c2gWy0jLNRPMwgdWiJOkLgrwgmC3jFPN06wOSxCCHI8v6+XNTaGto1XscmoAzz5+inPNof/oQ8RBcKkirsIO3kKKH6VZQsUeyBnHTofROxcrFn6BT/wxzbornpSSuA36OtJrjfMln5Qcv4pVOQwq638RmPbqHO/RTOIgh0ZpIaqZdSa5YwRFThEt5pHMD4XTBrWBFQKF2mV79dVZXn0c6c2jjE6eGTm+dKFDkC9WjAuHPoDi+t/6cpbG2A7aFsG0ELaAHViFVOKq+ZRGCU9j0Nl42YKp2nt6dGzTW2qTKZWkqx3xBERQ36DgC9/FZuOSA6GMziXDAZhpSCa6HxRs5ymQdTOIiMp++9wRCvoDtTdN5/VM8nmr2N3bYq3cxFJhL9vG2vkzYvEb7Wwe88NGfodca0GposkaHh2++wcONe7hCkKuUcJwuWWeLvYcdkr7GLVwk0Fs0sy7S9ykVa1Snl5hdOYc+vMd22mSQeDh4qH5Gu9Mj9L3jIMhfTt05SViUVCPVFCyO8gicgFpQA+EwrxN0aggcH891yXSCp3xcN2KoW0ym9whQVjClXDIr6FIm0WD1iJQ1tA7DXp3WlR2CQODn8nT7Lo12g5LvoByFDV2a/UM67UOmohlc5fz1TA2sBZ1h4iFCjwK8tRLhy1H3XwiE6zLzridovHqPxsMD8rUCaibA84b0Wm08vwY4WC0QWoMY44C9kc+E0HvoVNJptdi+3+SiP2DlHefZv3fAThZQmC4zXYtoDmJEP6V5J+OpmiV/LsIWPbqZoeKOumTawod/5hO4Xsbet/6Qj7w7R/lpSXegaa51Wbub0c4KVGZmOb14hmDvDW698U3c0xfY24659UBza/s47Zj+iXcjC4K3/vhbPLy5zc/+nfdx5myOpfkO/uqL9JwKnaGhm8ByXjLsC3IlQe7ULMN2zLCXQmIRA410JGeeW2SQZDS2WnTdPGeenaec96h/dgfV8JHUELqNTa4gxQDTmcdNQnpvacRph+pUieXzP0bj8NOc8vsoz2KMTxoWoRxyoeSz+qHLOOEZTLeDHjZJh0169X0GWrDTt6PpoIJK4ONGZbBl8mdqSPl1pKeoytOkZoZeP2Z2KaI0/R6kmsUYl+rMFstnt3n1a9+iH2fEqR5DiCawmXG3Xx37b0wGlRPkwwSrP8L0m3GX98QUYQzBmaCM5DjRnmTuJ4uP48b+iVTxCGIxSt4nhon26DUmeGyB5NhJ+YjjcOLVjqYB45OZqBKNfh7BmYx91GRqwj04qd40slew49tJs7Q4y/RUDs9tj2N+C4gRSIQKgSHkliDKYdMNPD1kevoi7TdfYX+9RW5hiqmiw3x+nrCwQVu5qBdnYM5ibRNhJFYJyMx4QudjrTs6kHG8lzqk671AKJ5juLtGdv3bXIxT9je22W21CLxp6NzB393CO9ig+/oO7/2xn+dgbZvGnmbv3h4Pr77G2vYGrhCEU1WkqNPfbTFs98kSBze/QmA22R92yeUKTJWrVKYXKU/Pog8fsq88IER2NaF2qNbmONjfR8TDowR3wiOZ7A0YjWUmnhOMybnjumHE7Rjj5aU4nvKkWUba7mDtqGhyfY9er8v2+gZhLqK8V6Bz0KL+IE+rH+MXQvb2D3ATyEcBvu8x6GboRLP34B7llRCVK+EoByUknhBoEWBMmSwbGZgJIVF+mbxXof7aG5QXPHqJJetlZD3IWhYZgAkkxvT5+le/wuH9NiSj8xjxbI6LysneO+b2HBPdpVRM1IhGhHpzVDALIfA8DykFSZKOJ2nyaN+LMWejVCzyUz/+CX7up38a3R+AcDFa4OSc0VtLSW5mirN/84O8+j/8Ns07e+SncxjbI9NtsmGG74dYG2F1itTZqEiVcuTcRwZ6G5sNONip036YcTanOf3cefbv7LFliywvVxGBS68XQy+ldV/zrllNtFoijRSJthSd0c2lgZ/7Lz7Jp/6nAxblA975Dp/cOUFnYGjc7XH7eozOz7Ewt0KuXMY/vMH1b79KcOZxrl454OF+ntfeWv9zHoJvszi4e+M6vZ0dDnbv8JM/d5p/+X+8TPPhE/zkD53l9PMlcpWUYmTpDSwb1x2q04KuBBR4OJSn8gyGlmygSTYM+VOKYMoFWaRTULRe3iG8PIPXOoBYk+kltFtCuglWXUfWKvgfqCDzLoNXD3n4WwnnZnPsxovEjTZ6oUx2uoKj2lTOnmPu/LswWrP18Ao27pHzcnQGPlfWU86s5jk1XSYvuygLhhLSvYu7UEfv/wEi6iKFj7ULGFuBrIB1X+SgnrC29mXuPVjn/kaL7YMGT589zS/8wj8kilxODLy+t972kgg5jeAciARhusCoa4QdjAyf4j7EB+AmQIqwXfJn5whXCtS3Ur79R1/lqY9eYXe7wfITedxKFTKFHRzCvoIZje1bhBOAChEmABxsJwbXQ+Qv4qfPYbsa2/wqZ11N5affhTy7zI0r95hZ+SC1uVN01v+YH1j3Ofuzv4Trh6z7mjeurHH19Ws0167iJ01yUZkHd3dwdYorBanyCb2Ig+Yd5ucVi5U8fnQaz5sCs8frr36eTzyzxO+sK9ypeZ67tMR7H5sjDMOjbshf9noEb4zAEQ5KKHwnBKDAcVfRWotRGkOGIxwK7tQIc30ChexgESMAAKmKiAKXMvOcCbb5X//NvyLzEpQJWc0/y2NnLvO5vd/CCEkj6VGJIszAJRtYtNb4rv8dx/j21yPIiD9vqHdS4QVGyUQSY1tNzN1D5BMXMJnCpAbhCqQvQAlUcZqXnppjN35Ap5ujVJqlEHeZXprCLz+D7XwZYfoIR4xGyyho9sFfwvrnaK9dYef2Gi03x2Pf/27a+/e5udfn2WceoxtFbLYTZjstWvcTnj0/RVoUBFWfIHSRCKQxDDJDOwOE4h0f+Bjivc+wGL5Ba3CDaqfBt76+zlZWZXo6YFVaNnduoRtdttqGhDaYMoWFAs8uZUeX48prr3H/1i1qtZgX3zPNP/8nn6e99gSf/MQl8gsOU2FC2XXo9RTr112mZqHVHyWGgedT9DziZATTjB8Ygicc8mUfHVdIdjxan9slenKWoL8LiU9qzyP8EBkMsOIWcqqI/5NV0lttGtcaDF+LWZ3JsTdcYrDbJj53CtwqKg9Tp88yfeZZsjTj/s1XKXgug65lcy/mMJvl3Nkip0oOVb+PoISVFifYxp1tk+38W1TFIEQRgyWJDbube1y5vkdU+CKNgx0ebHXZPkhJUsPlZ09x7e5rJGNI0cRcTJ3wCpjAh+zJbPtoH4oJRPrRCQOP8gUmBObvZlB3zDWwR91SJBhzjBnSWQZj4uYEu35EVrYCpcSYTwBa69HxcpxQTqRUJ4ZsJwuJo2nIibzNMqp74dFjnVwPO8bOp6klyF1EeTUEEswQYQegDZY+6CEM7oIW4GQgUkTcofTkMrlLNR5eaXH9lS9y5p0Ruzstzr2zjHVnIRti2jGipxDVDNuzCC8CEyKkD5nE9hKs6yMKTxAkzyMb9yl0r3Op5lH62e9Dnl3m21+/yuPv/hUUO7TufINqXGPl47+I4wXcjk/z6itXeXjlCp2tG/hZn1xY5Nb1K5SFRksHoXwc5XDQvMPstGFlOo8fPYGjLHFvixsbt/nopWn+xfopKkuLDA7fYn9rncNGE2Mm6lBm/GVPdNDFI/FsNPGZeFWf2DMTzsh4wqC1PobbjD/jzAxJkhgpBVmWMej12NvYQzoj8rYjBK7joBxJGAVMTdeYn5vnm199nU/+J3+PX/rkL/GRD3+UlZVVRqAtgbCCsnJI3RJ5t8iMTRhwn3/y5VsEVUncVexv7uH7mtk5n9h6dFKHoufRr2t67SGtVpu4E9PrDjDajKF6Ynw+J/fe6P5SSuG4Lo7jPuK9ofWYxG01WutR08vaMfl4AlkaNbRc5eC5Lu989mlOz04RP9ygfWMTe/ksJnMplIs4kYPwQDqK8sIKP/IDp7l2/Y9Rqx/CjxQ1mdKfKmC8C2TNV3GIEb4zghgZBZ0B+HkIH+Pw6r9nZ6eBnL7AueeeobN3n2v7fd7/0go3hi623aPQ7DLY0Tx3rsaw4BFWfYqOM2rAGc0ghWZmcV2XD/3C36PMLYrONXr9e1TTJl/90j32o1M8XgkJ0y77u3WSZof1RsrWvkvoLbN0cYGL+phj9n+33lZx8IU/vcnf/pmP88mf+BDNB3Xe2tyl2vwCv/m7t8l+Z8ClMxEf//BzTL34A5QvCTINaX/0ZS3EriDxBZUZwd5Wj85DS9ocYxTfjPnWp/+Ic18LWVq6iOMVid2MOO0SxG+Szb7I7CcvIM5GqH5Kblkhrl7Dm16m/PgHCZ9ZI4l2GQwTGtkqT5/7Aa5+698REZIr5Bl0YH3vAXY64j0vLOF3DtHdJtofqVoQtFDqGmb3Nk7VjqFMGbq3QdIeEi78Gl/+4n/FTnOR69fusr65TpxpgigkfHpuTJz5XmHwF1sKQQ4rZhDSjqYE+mVG04P8aCznK3AEDDahm4KTIcoNlBxSmxIU3+MxuJnhzhgefK3F8qkfolp7HNIHDBu/jq8yUAHWBgi3DKaEjV3MgyHi8SrCLBGpabZf22L9K1cpnK1QvfSjqCjk0vd/HEdFI9L5wk/xzdyfMP21r1N7z3v440/9a27dvop0B2iRsLu2R5zbZyrnIa3FGoUvDL0BoAxRmCdNq7SbDknWJDBdPvDMKi9vVEjDEs89vsjZ5SliI6gFPkma4Sh1RK76q1zfrVsvxrAGqRQCj8l+F0gUo6CbMVaGsAYhLJ7ykUhssk39zq9x40YdExVxZuD+8C7JWo9aVKZ5MOT8CyG764LILTNVmsZV7l/hGY9W2mhAcxebdGA4RHQzhF/DHu4hq1V0T2B6YHIKp+hhgdILT7L9J18n7Q2Iez06hwdkdYXyViC4gh3mMP0OwmbIkg82B9FzkG3QeLhJlBT5oXc/jxnE7MQV3v2+xzkYCHrrh1QPDpnyBpgz8/izLrnARStJliQok5EJh812StbXVCoRmQp4fS3H//aZlHT7BpHp0rQg/Zh9m7BPhkudmdMXuXC5wva9Fp5yyOdc6jvHD4t/8/nX+M9/8eM8Nj/F7esNrm7vUGt9ll/7l/dIfvOAD757mXe/9DxTl5+hVoZUQ9qBNBvlddoVpL6iMifp3O/QuinwqwK9Zxl+u8nVL32W3isRyytPk7glho7GpAd42QOy2Xew8F9fRpQ9vKUcxa09wgf3CaoLlJ/6CMGLt9Hscdgr4OVPcXrhIlde+ww5QiqVGgd3H9AetghrES8uz5CPu6RDsH6GCZpItwHyGmb/Ad6sBCsxmSDrXuXW66/xP//vD/nwjyzzbz9/lU5LkyQCKxVB6OLiHiVcQkikEqAtmdGjLrmw40R4fBuMv6sj1+IRPGfUGbZHCbpU6ohrAOOusdajpMeaUa54Yp+OBgEjLoEdyz3yHaIYxtoTHIHj3/3OKcDJbuyxXOao4DiCRJ0YB1hj0ExgGWI0QbGWEX9sJIEKY1UZOCoe4kTz7ddvoHWAlEsjqIUqgX4Fq3tgyyAthB6kMcS70BvH+6lDHOly+pwlbSn691LcGcOtzzd57J1/G69UIKu/Qlr/fTzrgBJYESLMNGQ5bEtgdjLEhQqYJfLOFLd+9026u5uULy5RvvgxVBjyzAd/HN/xMWKJ3uwpXr//FtVXvsHUSy/xqX/8j+inB9isTZINOFjbJo52mct7ZEONYz20yegmKcKFKApptaoMOwNs2mcqzHjXhVN8eqOKzOd48mKNHbVIs75Nf3ONIFdg2GkipRp5Y4z3gRlDjUaSnZPPb7IbTn43xxcbOxqWZBnp+Dki5LjgtIAdNSv63T7KUTiOg1Sj/SwZQXeUo5Cyw+5GnWviLoPekDhO+Me/9r/wu//+9/jEJz7BL37yk0fvLYDACRB2SNq5yd6tf8obb27T9Twq5wqUZ4rkjcVLUvY3M556/wzX3miT9odkcUw6GDIc9EnSsRRrmo2RGCdMy4RAKQfHUYix14HjuiipqNRqaD027zMZ8XBIq9k4Ko5c10XL0V73HYe5mWk+9Ru/QTCoI7MeTqwR+1vkZ4rEnQYHgGkPyE+VCWoR0h1dn4UP/wDXfv03yXkhUsS0W10GmzFe7hIivoZNQmy7NVLDD0IsRYieh+QaezcbnJs7Q3nlIukgYScr84MfeJr1lkbe36I8bFIILM3VWbwZlyh0yaxFJwMslsQodjoJWd8wPZuno3J87qs+b73aJdu/QWh61BG4gyFDP6PYH+C7MbXFx3jiySp339onDCr0BinNevO7PgNPrrdVHEyvvINbdyX/4xd/h2YqeGZG8LFf+BgmnKbTc0kyl/Uoz95Wj7O1kE5X4fgSlZPYFIZ1i1uEoRYEuRCvKvHLEvqWymyOWv4USWMb7z+dpbA0R3Y9o/W7La5t7XPhfSswG45s6g81qqEIV+dIDq/RKZ/B2Ij0wMWTHisXz7Nx5SvUpp5ANvbo7iakSlA+N0t1ehG6dRw3j1tsYU0drQ8xaQOVW0eGMUgFWmK6KYd7Dt+4J7j1e/+IYmWBB7s3efyZd/CRj/w0YZRnenqWqdoUvh/yvcLgL7oEQpYQVmNNjKCLFQvgNkeM/2EXrINQOZAp+Ba9EWOvbSOmIsRCBVWYIsl8ZqIfQUzvk5t7BpxFhHMa73wZzG+POlTCglwC+ziIFch/BqFewg4saEFeDVk+VaL0vh+m3pJM2V26+3+CU7pIVHsSnXh87pU2OneV6Btf4a03b7C9d4CQmrBgqE0rDjuaTtuC6yAcFwcP1/d5bD6ia6eJE0FoO8yKjNBX3KwnbB6uc/75JQo+hA5UqnkcZySVePKh/pdffp4gfYn/ZxLwI2jpE4MHRziApZN1SYxBpz3Wb7/FH/3Ob/Gnd26z19H88Pvfi87HdNqHrG3fY7ZcY35qjntfW2d2YZlnH3uRx848jVJvKzQ9suz4wZhlloNmgutKfE/iOgJHSZxxoZWkZtQ9lY+eoxgMQBwixR64XURVYNGw/haWswhvHitzmERi+gkyF6FKVeZPP8agM6S3toHr9Nl+4w3E3/p5jJ3DHNxA4CIrIZgABg4YgWmmWFPBzSvCwKXXhamlU9y6bVHXX6OSa1JecVHlAtMheL5GigyZpFgjyUxII82IVEJU6LP74AHtns+civixj7wbmXuab77yH1iwIVOLp4mtz+FBi9DNsXegaA67YD263QGHrQGD9rF6xeKl9/OZ/3CH3z78Ohnw/LziY7/8CRJvlmZLgAp5oCLC3R6nywHtjhrLQwvSrkW3wc3DIIOoFBGdcvAigQNUpotUoiUGB1uE/80yjg6IvxJz8Cd73O4mnHtpFcouemhhV+OaELlQJG7doFM+g7BF+ht7VOcXcApFtm/+KVNTTyAONrn32gP8Gcvs6VWKxQqi38LxCriVOjbZJzMNBAc4uW2USAEXqwW60ePW/T5fu5nSlYqvXu8i8jDY7ZEkgjiD7a2Uq9+OSVI9Qn9LCcaMu+wcd+iZOBFPkppjTXUpxXF3/gTFNMuyRyBGk2W0AXGCiirko5jzyd/JYzOn8a3IsYLeuOM6MT8bcwGMOZZCZTKlPEHqFByTXUf31rFHwmQKIRHjrvZJ0ymOTKpG56DRduSL0G53+ZVf+W/57371l3n2mXmgAmIB4TWxSQM76CFkHoQFmWE9g1lLsW+tI84UkdUaslTCiByz0ccRU5s4tWexKkKVZxHuaTB/AHY4PpWzYJ8CR0LuWwjn3diWQdghU2FC7dIZgmffSaMlmLI7tDc/R7T0EmFhlXrd8PLXDujlbhF940s8eOtP6fb7OL4hDA2VmqLeMTSaYH0XiYuSHvkoYmUmpKGraCS1rEHB0Xiux51WytbhOo9fPk9ISjxoE8dtyAak8XCc2E5Mu8Z7aNzxn5DZx2QTJiWeHkPWrNZH7r9SCgTyhCP2d4ywxrh8rUeFpTUW5SjIGNt+G4TMkEohhURrM+bXGPr9AQ8ePuSf/rN/xssvv8y58+f4+7/69+mnCTZp8eYrn+drX/k8V9c32OtmyDxUUoXuJvRTjXUFgSd5/bN7eKUCO7cP2H14QLPeIRkmJyBVZjzxOt5Lk32slDP67ngEUYHVlfP88n/2X9LrNllbf8j9e3e4f/c2m+sPSJKEv/kzf4tXvvJF1tfXSNOEMBjJlA7396jN9pHpASJKECLAyWLU9haV2gImUPS7GVqEFFQJEYXIYpXVJ16kf2+PaC7DUwnDvTZBuEw6nMdsvYksBdjQBx3CwMOWBPowwbrzBLkqrnSIE4ep+SWuXNP43/4SMyua3LyPLJaZCiyeZ5B2gIwTrPUZapdOlhI5CblSn/Urd0jSCpfnq1z4sQ+RqXfx+jc/y6LIs3DuIrsHMXG/DSphr65oxx2kn2P7oIUjNY1Wmz9vva0ncGf/HuuJJm4knDt3gQ/+aJWli8ukToFq6tMbSro9TbLfoqtA+xGer5Au4IJnBL2mpTQNeHI0mncEKg+FJz2Sf6WZmz2DE5WQ0wGeMOR3BYv3niD/bJ7ejsVVGrvdI9upY8yQulckeGaRrKDxKjUcZ0hsYoQ/gyfLDPIOuYrCCTTSGyJJUYU8WWcN098FeYB0G3hBGxiMiEBD0F0Y9jz6g1lk7nli7zbKVSzO+VSmu0wvOCzPP0UU5XFd90RAf7RD87319pYQCms9RiZzNYS6APomVgWIwMf2W5jmXYRjRso38wpymv5+THK1ibPk49uYm6++zOWXfha3tETnrTfpfvsLzPzwC4jyh8g2PosM+kgnD9pA59uI8gxWS6zNQ3uTsCoJZt6LV13F9i1Jt0OgU5p3X2Nrp0Oy+j5+/iefZ1qdwVMJN7a2uL/+kDROkIlF5V1iY8FA4Ep8IVA2QUjY2W5RNx0qvkOUC6AYoasFMiV4/rklLj91Cs8PkUrgee6RUYv8LgnDX8ln8hcoQ47G2ghCJ8Kzhut37/CN197k5uYhh0MPPxRUSlXOnFul3tphd2eDF578PgQaz61x8cLjnFm+QLlQGb/e/9vjGMlJ7jSGZFbQG1oCbfE8SKzGMxAFJ87OHGc00pGkwxTVayL1DlJ1wJXQPoAgwOzehArYaA6TKtJGgn96GulYClMOXlokGXTo3dsnSDNsliCcFayOABdhcqPCIJwCqdDtAN3zUW6Z/NKTOG6Nq1/6IhGLlMM9CrMZQa0KuRqBFyCTLZAB0oTEqaI37JPZHqVSmaTRx3gFhBtQ8AJWciViFyr5v4FEIqMc3aGm3uhgRI9+K2HY01DWJKmLMB5B61jBqrl5hZ16RujkeOzSMj/0/mCtMycAACAASURBVCoLF04RO0XKQ5/uAPqdlHS/TReLDnIoXyAUuGNhhn7HUqyJ0eTPFQhX4E9LogsO6e9ZSgsjKJGq+vhPO5TSaRbqHrlnc7TvGXwnI1tvoestUpvRCksEzy+SRDG5sxXwM1KhkcEMrijRL0jmnp7HK2hcT6PG8T7trkF3B9Qeym/geK2RpGCWoQeGtAXdluDWQ7i5ZymtBtRqDr4nWJqr8sZrTfbudhkOMrrtZAxdMHAi6R/t1WNzplGCLFBKYgxjScoxn+BkPX3CkMyOYSKT5G6SjMnj/v1ofxuDFPJIIekoWT96rePn0EnpS2vHPAaO4SqTZH8yiTj2MxhBi0Zx6NgYbVQEmaP4NHmjCU5+koRaa4+MpY4cagUkScrm5g6DgQZRQIg5EOex+taIcxDmsK2H2GQP4VhwfcSiA7mM9sMe9tBB1RQyjbnz5md57iN/F+VXOPjDf4fIDim/8yyi8EGy9c+g8gkyqGGH+9i4hyhOYTOJtUXs4U2KF08hS8vIyjKyb4jbLXLE7L3+xwyW34ucPcPP/eQ7mVIX8VTM57/xGr39LqqvkcMRXj7WBgzkAgdXWKRIsFi2t1scZG1mcx4y9NH5gGFeoh14x/NLPH15ge2DOpoUgSZLxsWBNWOOhh15HNiThQLjclIc7YVJzBuj1Y5cshnDisQYZmaM5qT5hTxhdoeUCCOR1oI5nkRZDSIb7w8z+oz1mIQ/HAzY3t6mfnjIzs4O2T9MsRLmF8oc7Kxzd7vJ4dDB8SVSSA5u1KnV8migfdAn8h2csECn2aG+2aTb7JHEyUgi2I7dxO1xAcRka40hRlprHCHwXJe5uQU++vGfYuX8eTq9mKXVM1x6+ll29w5o7x9QzDnMzc3y9BOXR0IPmaZRP+Qzf/D7PHjjOsVLA4qlPioSI1DsYBunEBA279EJHAYmxMYhYZohT9WQjqWy6JI4OWxzA/NwhzDToDXSvYhOv4A1LmQh2BCCmVG8rwfovoe3eIr80uPoLODhl75EUSxRm6pTmA1wqmUIKwjXQyabIEOEyTEcavrJECsTonyBuNHD5qsIETETeORCSSynma1EKKGQ+QL79T69QRdtBgw7CYOegXLGcBDgK5fdg5k/92n6toqD2RKsXpwGt8az509z5jHJcLCHErsE/gyOV8FV0O8buu0Yf9Yj1ZKM0TjLL4CTgBsIkpyltZHR24B8wVDf26Ex2GJl8TlMR6J7FpUX+M/6LCwuIacV3TWN7g6Rhx1M1mQYJnDqLMHyNMZoXLeCpc+wXyeqzuKg8HJFcnmFkkP08JC4uUZMjG3vgdzHjeo4Xhcl+9hUY3qaXlNQr4fs9wo0VYiag6VMUZSWw46iPtim3Ntk1ZkQwyYqFZNgzPcKhL/QEoyYnj6IKRAHCKUAjXU8hCvA6SAchcg1sCWNkhazYRjc3kMPBVl9QLe9gUq6mNZDrM7o3luj9OIPg36F/nobb66PF+2Qrd2mM1xELRySr8yTHd7CWoOzsIoUBfKhorWfQmceMdxE+QMCT/AfvfsMFoUjDe/d3cUqxZ2rV9Cd3kgxL9OkWYIjwRlL0qW6zyBLydwBjlfAei6dwCExPjlT5rnLT6CwtPt9/CAYm79MuoLHD9//P6xJGuM5PtYaIj9PbeoUF554ATYfcHZphSgKybk5ygsXOD1/hstnnyBJEkrlORZnT1HIF3Ec95H76u2so0eltQyHGcJzSJLRA88AqQCr4aBtyHkSx7GEHuS9sdKtMBB4mI6BbhfsITInEZnBBrOIocX0dzFaoEWRrGFwp7sQZLh5cFQOp2VJMoeC42N7baRXwcYhyBBrSiMb6eoSGMlgfYhjFd5MFS+qsH/1Nhz2mZ5ao3RqgDtbQOSKo2lm1sBmPWwmSWxId5DS7ffJFw0kBiuCMRHeQ0gIsOxtdcmYxVcpDAVFT1FcLpDKhLTbp9nQKKdPlgzpd2PW28dqRaemQZxepVaZ5anzM6xekAyGO6hwm1x0GseL8IQmTg3dToKf90kyiTXjKU0eHDOK93HOcnA9oVCQSDukvr9Nc7iFyr2AroPJWeScJHo+z1wnQlYl7XsZpj9ENFtkpk2cAzGzSnhqimwY44UVhkkTkw2JajmkEfj5EsWSg9Vt0u42Se8AbIxpbSPUNn6xiRt0kfSxcUbWz+g2LJublodNxfoworgcsegLqgqaQ4Nf8SjUPPwtxWCYISVYI0bJ1gncvRATiI79jibtRKf9GDNuJ1nc8X85AUU6WWyMoT6PJO0T8vAEg30MJfpOD4PJJOFYwcWMOK0nHGaPDkEc37uTaaAYT0cm0KNjONLxVGTSEJhMS45VYzhRTBy/jzFmLNUJo3gfjuN9HRwHSMFdQpAD1R/F+/whtmSQMcR1TXK4QzoQZM0h7fYm+cYmdtggG3bobzYpPPV92OzLdO52yF3qIjstkp0Gg2wBOV+nUFsm3XkVWV1ChXmULJILBK39FNFeQMXbiCxmuhrwjrlzgEJJzQ9+9Ed45UtfYO/hGno4xBMWqzOyLEYPLQrQUjBMoadTtNPHo4yOfOquS6oDCrbCc5efIBn06MYJw2RkdoY1GJ2RZem4IBjDicZcjZP74SjX+G4BUDwq/Dz56chVeLJFhMBoc+IzBKPt2Dzt2GPBjl9jUgxOphBmPF0YGsPe/h6f/v1P4/kuC6dm8XMexg0oTYcMOm3C0GfY7NM5iDFZyrA7RAFR0dCp92nstxn24iOuwElm/CP3wfhaSDWG09mRBGkURNRqsxjA83LkyyVmFpY4c16Tdgb0U8Xm2gOWVs6zMBWR9yWNwwOM1uSmp4gH18h0A5UKhK8Q2iKCGdxEIXubKDmFSQSx6aMqDipniaZDgrBCfe8u8U6dyILptVDuPNkwAONBGmB1COUFhBb07/cJ8wH56RkwLs079xD1HrMzDymdHcl6E0Sj2JA1MGkfm7nECFrtAdrERAWJSCxGhBSmpnClJFRAktHei/8v9t4z2LLsPM971tr55HBz6tu5p3umB5MwGIDIJAEIBERQLMqkSYsSJRZsyy6VLemHQ3FolatcLlGyiqTFkijSNE2JpCEwAEQgOEQeTMA0ZqbTTOeb48nn7LzX8o9zzr23B6ABUHIV4cLXP/reE9bed++11v7C+74fGdM4Roz0DaYrVdRkhURHJH5Au6Ww7D7hIMTvByD8b9oH3mjfUXBwfHmGt7/3cXJT80x5MbF/k8bWK1RyDRzvJIZ1As+sYM+V2F/XyEEbv20hDBfHc5F5i/y0wLJA92DjUhv2ImbnNCvXbtFP99hpN3DvtVG2xK6aZHaG/WCOOMyAmKw9QAx6GIWYdDpP6dFlDGnjGCmJViSZi+UsYHsCLQxyBMisj4raZIN90uYu3aiJF+1jlQIMImQaoYOYLFS0thX7bZeVwTT3egUGdszSzDeYK+fJW1XWek38Xoqzt0O9eJWcXcOxXeZnjiHN7x4C8X0bm2Donkk0CqElyCnQCpINhFNGFB5Fh6+C9CC9gnAycqcrmBWD1jN36az2WD5fp7/zZQyVozz1MPkHf5bdr3yGYlhBJTn8TRMV7iDcJuHVLju3etgPlRAXT6BWBujBHvbAwixdJIsL6IbA78eUFmaZWSyhDYab+EChizbv+/CPMzNd50//8GNcev46lu5iJkOMZ5gkpKaJaZvIVFGcqFAp5imUKohKmdApEsRFat4JYmOG116/hcy5eF5xhEk+3Pq/VwKDbzbB6ZPnmJtbZG1zlWdfeY53P/EuXrt9jYHf51jtOKdPnAGtkEWDqYmZEdnyqCTkdxMdjBRXlMJEEQUZUg2JmqmUeM6wvcDNfUXJU2gBBRdUYXisopNhlktkYYmsbaA7PsQKWcohkjaUS4igCb2EjCliXSfe62LUEoRhIS2JnbcpzE6Sdwqofg9RKqKDIsgaOqlCotCijm7HhNt9cjUPZzZH2txm5Zk/4+yTP0J15jbWjIR8GSig/CY66aDdY0Q9g34WMkgzMpVRzNUYhBlebQLPcsgQxFFKpzlg4/UWt3oRRSem7FqUai6FSRvLMbFSk0LJJa9iorRJGm8RdQ7VKy48sMzcxacoV0vUzD7R4C77W68wUdrH8p7AMmfJ2yWcqTzNHYXRazGIbEw7h5tz8HIG+WmBbUImNXee2WWqIrFkn/Xrt+mn+2y3GuRudihlBaQDugTmnEscZAgRk+72cLI+oqJQs2WK55cxlIlpZcRxhqaC5UhsV6CEQV4NIO6i4xaqt0/U3CaImjjhNnath6kDZBKg0ogkSOnsJmztCy5t2lzdh/LxPOfPTpDrRGShz1qkiboZxck88yc06e0etm3RbYXD1iniIJk5nO1iCFNTRx24AwdZH+CnR1P10Hm/fwoDI1jFUbze2InTR5z4cVMzcfhFpYbEywNJUsZZ/WHzp2yIQTlcY6MjjDPJapT9H8tgjs9XjtRyDqFSY6Wi4VHG8BclhseW4ojKmuCArAwQBAHr6xs0GnNM1CUCAyGnhus3u4UsnwFsdHwXhA3ZqwhXUH50Gv9al9aLm/T3A06crdFY+wxm4FJ7y/uIfE3/3k3yQRmVeAxWJbZ7F9kK6d8YsL/dwzqfw3zsHNHtHnLrBm5cwTh1iizMofcF/f5pps8vY03OHQRSylcYZZuf+rmPUq94fPlzn+fe6/ew9QAryYjjgEESE9sWhiUxlCRfL1HN5ylUJ0irJVKVI81qWN4pQmOGyy+/SmFqgsEgwPd9hjxHTZpEqEyNaQMH11YfCSCPdgzW922PIz0srUd8kzEM7RDyNdbSOqhFHSGXD6sC2Qi+xAGUSAgxlBUXQx7JIeznsPqUphppSNbWtijVilSmqzg5j16QIj2PfKHE1uoOYd/HlIIkSojvNshSRZJkQwKyOjzeQWO9I4HtkHsBQhqj62KAMIjChNcuv8bk5CzlfInEMHClpGxbpEXJnZsRm/uSnV6HdjtmtuZSLlb523/rb5NlIf3X22Q7DbJ4gCiaiJwLcQtZP4a300AqSapdwjiH2G6Sm5O45RqGm6frGWhT4GoT3eshKmUIhgkhbbigHdA1VDsi2OxTfXCSXFHQXbvNzguXOPHIu6nM3sCcscGuoVMTHe2h0wC8RaKOoCf6BGGM41rknQJ+rMhNTJGzHFKlCQYx+zsBazca3OknlN2ImudSnnbxKtYQopxZFMoW5cyn428S+PvEg1W+nX1HXu2nPvcs+eoCH/xQnYKdZ29VEIQdCttbRDu3iYWNXpzHW3wPlcnzbF66TNgOqbjTONUlNotVcqccliqSxjdCdm6+jNPZYi6aZL60RLv8BM/tb7D2uQEnX1+gVCywN+jxwI+fJQssVLtNjh7CHJAYDvmTZwmw0JkmEQZhAFJqqmWDoK0IpSJcvYpnbODYfVAxYatHsRZR8DT2bIk0iIn7PlmsaN+Ar9y0aR1bxJqeIytp6HfZeqWLkJrimTxnH6hgGSfY24n53c/+Ktu3e9QnJ3n6v/llCkaRI1XW79t3aUIWQJvDkiajRjZ6A+xTCHKQtYAULebQqgFRAPYC1vQFpn56nmrnEsEn/4Cpyhxi+imw5xDCZu4DH6Xz1Y/jf/029ffNoq418J+/izZgorpI++s3eO35V5jIIC9NdEOSe7DL/iVBtBoz/a6TuLMZwonR9FFhwvazLWbevoSVN7n45LsoTZ1gP/plXnn+M5ipwJVDgpaVs6ku1Fiq2MSFB1jMVYnLNkqYlByHU8s1ppcu8suf/jLl2iIna5PUK+Vhh8gjGZ2/Ct2B/zImBAgpyOfynD15jrMnz4HWHFs4RpqmSCmxRkH1fdC88Ze/CztwqjJFFCXsbu0SRwUKxRymZ5NkQCTAErxp2SBVgv2Wot1UbG5mtBW897TAtQxk8RjMrINYQzW7kJoI10aHG8j5OejvwcYaxbk307qUUnr0GKY3wCj4GEYH121Qrs2iYwO0i/ROojt5sh0LY9Ei7fTJrncpnzlN4BoEzRbZ7gYPvv9nsO7+CeYDFYQ7i048skFA1u6QmjbSyLOzv4/BgOr0JMX5k6RhRMERKMNEAGmU0dn3WVttMrXooAYehYLDWjvg2s1V9p65i6ldqnbK/PI0dv86/bRJZbbKE2956OB6/h//9pP83fwkS48/jC0cGvuaIO6Qvb5Jf/P3ScpF5MJpnOmnKNdOsv7iJeJexlzlOGFplna1SG7JJleW7DwXsL36FXJ7mtnqDPPlRfolwZd27rH5xz7nTi2TpBlpUXDsPcuowEQ1mxTtDlkcQaGKu7hEhInWkCmLQT+gVJB4xmi/FynBnZcpuGvYVkTsD0j84X6fczPcpSniZkbY9YnaGbu3Yl64o1iZq5HV65jFhCiOWbu0Tl0JZo/lePDhOqv3EgwjIdEGhpPDsh2e+/Rrw6w6Q+jPgaZ6pg5kJMcPgwPU2nBqj+aqPuiAOyYkH6jRHIHvjOEf8g1wH2kYo8z8IcAEIchGwXGWZaMxh98dxRYIho6lYRhIORpjyKI+cMgO+AlHzzVTQ7LquHKgh0qhwKiiII+c8zgQOmBJHDqmcjhGHMX80i/9K/b3m/y9v/tjOE4ZSEGvINwnhpFEugNotJxHx3sQRpA7g/fgWdzzDhONVwg/+0mm33QMXX0HyAJeuYg7eY7uC5/Gf+Eusz99Fv//vkG03kbaDtVCie6Lr3P5a99gMROYto0h5jEme+xfVcSrMQsfvoBZCcFK0LpP0jXYfrHL7HuWMW3BD/+Nn8WtneDf/+7vcOPyV7FSQdGCTGm8WoGJ6RJTpRxp7gRLuTp+xYTE5JF6jsXFGazSCX7tmefJlxZZKFUJAp9Gs4kfhCRxcrCRDTtbH0kQcRjwjSs/YkRQPmjSKMQBNn/c/CvL1AEC6QAGNrrPQ2dbHwSUh3PgSPJeHN5n2xwKRJimQZaNGo+NOFumaQ47TytJY6vB3ub+6FgZG69v4OXzBEGEVhmWIclShd8Ph+ehDpNh93cMH5/rcN7J0SQezjmNMExM00Vok417u7x2aZNHHskNO2FnCkyBaxv8wAMuwYnTfOKZW/zxZ9fA8Tj/0Cx/49E8+ZxN5fjbEW4T9m6SdX1kJMCx0P49vNPHUTdWYNBAuWfovuJiF85iuT0MI2TxXI3K4Di7z66iYwutXWThIXQjQmsLUTdJWz2y1zpMPPkIXSule/sGIi5y9u0fwFr/AuZDFYQ1hQoNsm6fbDAgsz2kkWdjd4ucEzK3fAqnNEGWJBTc0X6vIQwy9rZ6tFp9phdzCF9SKjm8tt3j+a9dY9BsYwuLsqNYWJ7Ban2dhupz7sGTPHDh1Dc9R99o4o3SY/e9OZqhv/Drv8kP/sC7yfUTQtPmzFxA0WuTRq+Qtm8R7w0INvNsrye8eAcef+JNNFYiuttd+p0+7cDgRz/4c+TeUefOb32VjbUWkw8v8PhPPEKSgv/yAL3d55Uvf5VgYCDsPGG6x0y5yoW3nGf75asoMyB3YZ78Y+eIXY9ISMyWojQlMBxNmmQE3YRuV9GOOkznoLfWZnt9l3iwwcWlTWYfmsSc3CG9dome3+P2esRLLyv06bcyuTjBncYN6ks5ZmYdSAe8+soqJxZ+kOv3vsLUfJl6bRkZV2msBmyurPNP/sd/hmWaRzKeR1bU9+27sPHDJUVntwAfsmuAAzqEbB0tcqTtNcz6R9BZQHfzNkkomTz319Eabnz8v2f+qcfwqm/HX/FpPfdFso17TMytY/ZMzOkUeeEhmJlFhE3E5M+S9Qzif/r3efalVWSgOFewcMo1aj//D2D+cZiQ6M5zkLyCmDKh9FHS21+iuScpnX8TzsQEQWOFG3/26/yLf/PH2NMupVTiJxo/tYiSHI04QegycRwQxwlKeBhIPNVirlbgv/wHf5+li4/iFYvYlo01gtSM+Qbfiqj4vWHfLMP4reyNf9tfNjjQWhMEIVcu3+S3fuMPiRKHRx+/QH1iHoMqeavM1MkcpxYltjPSas+g58Ord1JudBTvOAbLtRg7WEHvv4LYfwkx0MjiAtnmOnK2gihZqCQk7UMUPkWWOWQlg/xMhuMMiLd2iZ5dwXn3TyP3e8h0G5FLICdRYR/mNLp1g2itizV9DikKxLdX0QUoXMgjy6fQWYXMj0jjFtoOiAan2du+R3k6obj4KFZ+GuX3GWz3kKVpOkryyp027U4bU6Y4pSpb+WnOV01qrmaQRmzvtVi7t83G6h74+8zUPWaOGdSK+3hmh93dLj/1k78EwC999nOc92rkpEO+kmd5OqTgtknD50n2bxFtG/S2LLY2Uy6vC97y1OOsXu7gNzo02z5OboZ3v+cj5N5W4/V//jnWWiGP/PibWHp8icTXBNd89FaPr33ms5j2HAkxCJ/pWpVzj51l7blLyHJG+W3nsY7PE9sOMRKrpSgtCITUxEGK303pDVK6UY+5vGbvtV3WN7Ypm2ucWWozebaCObVH+tKzNFXEpZdavHyzz4YJ+ekC9uRxaidhfjKhtd/j7t0B3YHCcU1mjlXxY8nKjR7NVZ+oGbNyo0UapYSD9D4nWCC+RZfkQwhOptR9EI8xxt8w5ME6P7pWxsHBG9e/5sh6ue944mDc4Vt6pFAjDz6fpilKKSzLOiAXjx2ubxputBANKVGZGgUU8iCjnGbZKP45rISMoSvj0zNN48j44uA9wzCwLIt83uVtb32EX/3Vp5FiANkrwARkW6A7aG2Sdncw6z+BTvfZv3UFt3KO0vybSYMetz75P3P8B9+JlXsvrRdfoX/lG4jOOrXJbYyeibmYIB9/NzgJghKi/COkXUh+4af41Kt9TliCuZyDu3SC8t/8WfTcY4gp0FufAG8FUTsBzvtJ7j1PY9dg4i0/gOE6NG9+lUt/9vv8uz/8Ata0QyU2aCeKKMkxSEw6sUboAlEcEEYxwihj6ZCC4XNsdoK/91/8PAsPPsaXnvsKf/CHf8zVy1fxBz7BwCfwBwf3ZlwJPfQpvvV+KkaBwVHXYwjzMo78PgIIje7ZUcL5mDx+/3NmDCsafs4wDGx7qNQ15JLo++aLYQyJ8o5rj+BlQ15AHCcHAaYenazQAjUKYCWgxjAlDfcHlhz4VfdNLASW5eA4OSYmFliafwChHTRF8pUS9dpxji+c5OTxeaaPe5xcMLBcQZokZKlgc1/xjbsxVxoR/8lFjzPTMbJ1HfZfQLRuQqDR3iysr2BeOE4mfLIwJPOLpMmbUSqHqptUllJE1CK8sU54pUHxfX8LdtoYegNZNUBkKB3ARIpu3yK808E991bUdoe02UCUBfkzBUT5NDqpkPTaKDooKYkGC+zvrlCbTykefw9SGCTdPmE7QRQm6CjJ167tkQQtHNdCF6q0c3XOVk3qjqYZB6yv7bCxssf+dgMRt5ite8yfNKh661hGzFe+cp2nf+HfjfeLb/nA/Y6Cg9/6vd/liXe+n41+SlwweWdZIXUHIRy0CsnSFmnUQoUR+50lbu1Itq6vEt7eoLmyzatbm7xncYF3/vCH+Pr1O/SjKZYfWuSJ99dxHUHip1z5PzdJ792g19qjFUt8e46i2eeRC0sI4WI5PuJEifj8PG3L5IFZiVaaXqpxhMaVmiyD9VbGsbpAWyOZOJ2BSgnCgNt/8m8xXvsiKxvrrHT6dFGUpic4+9d+hpsrn+H4cZPmxoDEgNqix+njZbaY5epKi+Z2AzMtkyhwCjn+2w8/TaFQPCBtja7XX3gtv2/fzo4ECGoXiFHJGjrdAZkhzQVUskcaZigiDNNEmnUyljBSA2GY3Py9P6JyfJHSZEKy+QJrn7rG6cdsrHe/Dx0N0HEJnJMY0xfAdFFasve//huSy89g9TbxhBwSg5fO4fyjp6FigQrIGq+T3vo8qiswf+i/RjtFhGmitODmqy/zL//xRwlFQmpaJHmPoCdIIwfh5MlEQDgI8OMUtCRNFXGSkiowDJdKscz8/Cwf+uA7edvbn2Tx+MlDzOj3dHDw7QODsf2H/n1jZ6rX8/nzL32Dq1fuYhCzcncTU1rUS1WstIhXPsWpR5fYS3M8es7h5JyJZUKcwH5bYVgaL4nx6GPTRPgbDC79OYXjE2TbFiiQpQyqCTrwISyzd0VRfvwtgI3eW0X2b2BdeAtZfxrRu4cUIYIOQgzQ+SqZUYDSJLAKnQChJSIvyLa2sM+eR6gE1emQqj6ZNNBqnlTayPg67ul3Iuw6ahChugN8c4k9pVjZCChMlLBzJoGEbSWZcExkW3FjJ6Fop0wVFdUCYKa0eiGuESDkHmm6S6u5zcuXXuef/KNfBeDr166hclM0tMDLGzxezJC6ixAeSnXJ4gZZ1CMNNY3ePK9vCjZevoG6vcmd1U1agwFvXVrkbe99P1966RqZOMPj75vj5MMFLFMQ9xIu/8YGevUKzU6LDmUSq0TFiXno3AJCe1i5DjyywGCuSuIanJwYOtDtRFEyNCbgR5rmQLFQF2hjqMYjdYZSKb3dbVae+QPMG1/i5uo9bvf6KEuR5iW9kkVtscDFh+ZYu76HMWEzf8yjUrd5vau4vhkQ7cd0mimJJdm722flyzuoRBOH6VAyUetRk69DvH02ako1nvXDjKwcZXvHDv6RcoIYqmgdDQ7G1QY5wvMfXR9jaNI4Y3vAVRh/dpTuPWwSJQ4yykmSDKsQI9lUNVLGMcbZ5vvWkz4YdkhI1aPqgTyC/z74kw7sANvO0GEcVz6EFPdBRqSU2LZJuVzgwoXT/PZv/xqCiCy6BbqFkA5C1lBpkyTIUDLAsnIgZ1B6CkMZIA2u/frvsPT2J3GMm3SvvkLn1VWOXfSw3vt+dHcfFc8hqw8gK8fAcFAKtv+Hf4G68ae4iY9rGJi5EnL5/HC/z6WQ9klXnyVdvwa6hPEDP4d2CwhjWHF85vd/mz/5zV8hFhmpaREVPfw90LIApkGqA6JBRD9KkMIgilLiNEMjsUyPYr7I3MwMP/aj7+Djn/oUz734EipNQUciSAAAIABJREFUydKUOA4PHOuxvXFvPJplP7j1R6pLY6jZuNow7A58/x1+I2x1rAh0qAp0CB0aQ8zkKKg4CpVjRJDXelj9klJiWSaGMVQ4SpNkCDvK1CFIbqSSZIwqYAeljdH0zdKMbDSP5JHgdnhew6q6YVg4bo6puVMsn3yc0BcE7T1yto1ne9Tzdar5OXDm2UszTr/1YT7whMncpI1pGviBYnV7QBT1WMp5VHMBRrZDsnud9PbXKZ5cILqtMEwB0ynSS5Ep6KDM7qsZ9ff+EKodIfauYVg+xtJFVDCJ6N7CMBOkboAlUG6JzMgjShPAbdhPkDkLrSN0t4d94hRCxaSNJqkxQFFC6wkyKRDxDXLnP4gih263SSIT35iikWXcXQ+ozdcwHUFDCwZIKqaB6CqubcTMFFKmy5qcp1EkdPwQzwjRcpsk3mZzc4PPf/Z5fvNXPj6eD9/yAfwdwYr2Yk1XCyqexWzBQEiN0HkyDUIUkVYB25pD5qFe8hC1lOmJIo1ija3EQSRdGoHk6sufR2ZVCrUqIgvYeqHB+mbI4lSJrfbz1KfnKeZnSToNOtY2Z568SFq0qZXLGMU6cdFG5wxO5CF8PabjpjiW5M6V1+jvbTB5ukJ9fhmTOkFk4rpyqJokbWzP4cz7foxrcZMbt/YI05iF0y4P/+Ak3nFFrvoYd7p3UHUI+jEr6xo/NSlM5Lm43OM1z6TZCUk7ioLIk88XOFLY/Z514P7q2Ljpj4mQkyjVAjmFsIsIoUAPEFYVUwCyMOoGaSCVSZblSFZeoD53Hjm4TfPuZfprt5k9ayEvvB9ReTcii9HRa5BdQQ/2UPYHEBnUfvLD8KNPol9+Bv3cpzEsgTibgbODDitgusjqWayHJtFaoo14SJQTAq1SdBrix4ptbdJXkrQVkWXDDc+INY4pMOwShooQThFLmrgI0swkikJ6fof17QYf/8yLBBT4zxaPYf7/hMMyJizen+P8j79OxhVoz3N565MP8sjF0zQbXf7g33+B9bUtwmAX2+hydirHzt0+dmbz9VXJy6U6s4uLPPaAjSUEm5uK5ZrAtBSkCUpIvCc+QnjnCka6xmC/DVspXt3FOTuP1jbVMy6Du7cwEwe36GAuXCC+vEF653WsOQ9KGXR2EKmP+ZY50n0D1biOtaiQtTwEGarXxj5zBuGsoTZ7ZMIE08U0K+BNIHUTmX8Hypgi6aREvkU/m2KlpyHn4E05GLZFmEICTOclXqzoJuB4BijY7St2Is10VZIrmSQ727x64w5hso+tAmTrUK1oK4G6aTJvSSbzcpiB1nkyBUJUMZwypqNwigJRcaGaMFPLsWNWMFLY391gr5dw5RvP4KUTMJsQ7/e588WAdidluuKx2fsqC8fOUdkzGYQ9qAw4/tBpkqLFRKWKKFUJSjlKRYknNcHNhI6b4VkGL3/ha5heRP1YncrMPKauMohMcp7Gtk2EcLCtBaz3fYRraYsrr6xiSpsLjxepnS2wk9koXeJOGGHN5mi0Y1o3fZytmNgyePsDE1zdGaB3Y4JOhi2CISY8VQdkyCwbgS+EQB+BfYznI4wrWkMHXOtRV+ERUkIa8sDJHlcEhBBDAv0I9z38/vATR2GGY0n7MZl5rDpkGMYImnQopzqGGr0RpjgOCpQev8YbYCmHAdAQ/nQIEToMUMTBeYIeQU5GzeHGLqkeHsSQEmlIkiRFZRlJAr2ez9Wrt/joR/8x//yf/U841gxCTiFECjpAmFWsnAZZGXXLddDKIgsM0tVLTJ94Er31Clu3XobBPpNny8jz70GU3o1w+ojwBeBF9KCBNp+CTDD58z8JwTtQn/u/EPeuYeQEnE3B2kL7BXDyGHNPIicfRAsTbUQIszpkxKmYLI3oxZp9bdBXgrQZkqUSYQwwLRPbMDDsMkbmY+ZqmEWBqyRpJojjkO6gi9pr8nufepl79xpoLUFIGHf7hSNkZICRctQ3QU3hqO8xhqZpQGjIxp85LD8M77c6VI+S414UozHH80SOmnEc7TGQZkOe0ziYOOSyjAcYQo3SEYdgOJ46qBIcQD/vgxDBOCkoxvi3v8DGCk7DY2fEccT+zir+YIBp2FQqx1G6iB+mRHGDRqePZ2xgOmX0S31+71WL2tJJzp2d5uwxgY4TmvseS4spghRUAvkJ1Jn309u4haVu0dmMsRsae7aAOTeJmfOYOO/Rf/UKTubgTk0gHE366irp6nWcpTyqlKA21pFTZeTpKbImpI1rOCc0YrqC6rQRaMwTi+Cskq11yUwHaeQwnDraLiPpIXPvIqVM1BgQJSWasc1ODHguhRkXaVn0Q41lCyZtgRUpejG4BYNMC1baCifS1EsGuaJJvLPFC1duYJhtrDBG9oy/8FqPzXj66af/wjd/8Rd/8WmAi4+8jxPHTrE46VK2zaFMmzAYk0KEsNE4xMohwUQbBqnhYLs5Sq5N3o/ww4zUCJivTeC4BZIYuvs9BvtbpF2f6ikXlS/ili3KEzZe2SGpFZg5N4Ez4eJOedhlGyklWR8ajYzAyli/votKUtxKkUAUCPoOrVttEiXw9zsErZA0Assw8OplZD5PfjKPJQ0wJUnBYXMzYK+n6TohqUyJbYOBZdFMFAVLooRPuQSmZzFbO8kTx97L0tTJ+yLb7wcH/zFsnCk3GBYds9GmoQEfIatI6SCNGkJ6wydbEqB8H9VtYrqSeP1VklvXMP0B1ccXsc7++DDIECHZ6mWyrWvIXIBq+UjvOOZkBXNqAqMsUUab/soq3lMeYvkpkA5630d3E2S1hijXESoB4SK0werVq1z5wjP4zS3u+YJOBEnqoYSHsD1MJ49heWRK4ZYWQVpYtkfeK1LMFzArRUQaYto5gigliSPiKGQQhExN1O8jBX7vzi9x37//L48jpSCfcymV8qQYKMtlYmaayakJTNMkUxndzgAVtFFJjC0EBdNEhlCedbEM6Pc1qa+wVIptJ0ilEPlppJdHOyZKa5JAkQSaxFeYoSBLQ2ScwUCQ7Gqy1zcQK3fRmOiBRrUjdC+F0IIgw5iyEJmDDmIgRZZdjHKMbm+T6eOI8iLSLCNwkQUPnDwyv0hzN2ZvP2Szq7jT0LxyZRe/l2Gakk6o6KeghSCPQoeazJSYnsCzJFkCnX5GEMf0ByEi7NNq90h6PpYysbwyf/rZzwHwtnf8JMtzE8yUbfLmMKNoHOz1w/0+08P9PhYmQpokhkvey1GQAjdKCWNFKgNOTM4grBzhIKG718Jv7JH2fCbO5YjsIqW6SaFm41Q91ESBmbN1nLqLN53DLFhIJYn7mmYrI7Qy7l7axMsbiHyRQOXxOyat2y1SYTDYbhL3FToRmJaJVy9jFEoUJlx0kELRpq8le42UVpQnqhhoI8O3TbrG0NnLWQLHNZiacMF1Wb/SZv3VBv1mRJoohpzNEeziSKZ+3ADskC56JOM5+n8MoZYj/Pe4ya1WetSHgAMywf0Z029W7rp/PxitLjkGkDBy8oa49HHFQR8d70iW+Ki05TgwOHru4ijs5CBAkAeVkTEvYlwBGfMLxspKAjFqtjVSdDpy/mmSsrm5Q5KknD57kkI+z5BfliBkebTfTyKwQKXoKEAHA1SvhZkzCa5/kfTuCl5OUHz4FNbJHwExiRB9kmtfgXATpI/qRcjcMczpKub0BDIXkIQtgv4+7qM5xLGnAAu11gFhIcpVRKGM0AngITC4/MUvcO/SC/S7bTYCQScSJEkOLT2kncN0ckjDJVPglZfQQuK4eQq5AvliHqOYhyTEdPJ0+wFSK/L5Ak6uQJwM1XwOJwoHDjgw7FTN/bAbxu+L+5MuY+gQB/dumKLR6rDT8Hi/PDicPpS2vU/56gikbcixOQpt4z7CM0fmzzjYyMYKREdn1fh3PSbqH/4+nnMjPjIHpGkO45wxJCrLElQS4bkmf+2vf4T81BSG64IwyFKI4pQ0zTCjFlEvQAQhVpTiCIv8pKSc9+j2BHaqsWWGaQ5FLIzSHDgeMmeSpXq41w80KjKwQkGS+piRRnUl6WZIdmsLsbaCNjx0T6GaA7QvwJcQZ8hpCxHbwz4etsQoW8hcgO7skXJmKKerc0jLReQ8hFtA5hbY2/DZ3Q9Z7wpubEa8drOJ38uwbElzoPD1sD+skyl0rFGWgeUJcqagH2gGQYofxfQGEUbYZ7/RQXV9cm6Jdi/ihedfAODpp5/+Rb6FfUcpSumnGNEwalQILGEABoYYajFnShOn0A8USZrR7WsCJXAqeUrnFkgGIQv2CqFIKJQhzBL2+10Gkc90PcV0TJbPnWW3G2LrFC+rYe6m3Om1CPpdunGevC2xTYnKNANfEBUl2rMIs4yZpRmq8zWarRR/L0C2exi1hDj2ibQg7miyjqZ8ymPxgceYPTHJF3SBS5e+wcrtHoouVs1A2xpLSGTexPYkiR+T6BYr6ymLCwZ1t86x+pt4fP49hw1k+F523P7qmpQembbRWiF0DOQRogRCAfbwQZFlqKBDtruJdHII9zZB7y6636RWK2IuPYwsLZP5GaqdkK510P19jDrQ+DxUj4M+BcKC+gTZ4jyDwRcpW01IboFRRg9idE+T6SIUCgyUjVfN0dpr8spXXuKlLz+PYXuUSi6Ty4s0mxIlJKYtMEzIMNGDLm5xgjgaILXGNg0cSyPzBTzDGGZ6Ip/NjXU+9ek+Zx84TblU5uTxhWE3yO/Pr29r40za+AFjOxYXHj5LEGb4HZ/21g53bu+y3wgJjZCKa+KIHlHzNe7slJheeJS5GZM7gUEYO8QUMUSA0bqHOXMKbZ0mV5si7u0RbO4Qr20giwair7FncmC4ZNsmyWaEbETYuTJZ4kFUQ+Qm0SIkuRVjn7UQVFGRBbqBKA4wiiakCTqso8vnMSQIHaBVHzVoorxj+Pe63L67y/4gphUJGn1BbzfD1oKoZJB4YNkGpoB0kII2sAtQdEClYGQQRpooVvSjCD/UoAs4Ko9jaqKic3AtjV6KzIYymho5VD5BYgpQOiNJIUw0fqRIEuj2NL6WFOcrlNLjZEog1jaJREK+nBKGMfstH2RIvayxXYMTFy6wstOlYudRPU2jFbPb7RH0XNqhopI3kUKSxOBHgrhooF0Ikpjlx06jLYdOK8ZvBBjtHuZkguoOSHqapK1Jqi6lJYelB9/M/Mkqv7OtubPzOn63S6wtfCdmYsohywxk1cEVYEQpjsi4ea/Hg+cmyGeS3prP/mqPLFWjgOAwMDjiI92XVddvcO7GCjMcOPmCMUn0gIB5FOpx5KejS18ccQbHUcB9nAQ9VCUaj6e/Cbf+Rht3NB4OOJTVPISmjI/5zQtt7AAOq70jbMtI4nUIKRJiSIjVWh0ZawRNGsNgNKRZhgpCPvaxP+FDH3o3ExMukgwhju73JqgEncSofoO02UC6HsK7Tm9vlULWo1Q/ibnwILK0RDZIUc2Y5F4Tc6KLaSbgN6E8D5wBYaMX5kiqFcJbfYpWA5IboAvo7gDt2xAWULkcgbLJ1YrsrLV57k+/xMbtWxiWR6WSZ7q2wM4OGLaJaYMwBEoL9KCPW54kHLSwpIljCqQlMZwinmmgUoh7bSy3gmnZxCpFC4O9wEelyWEDOaWAsTjp6N4egk6Hrws94iccCQakQCgOggEFR8tQR+7pQdg6PNbBrR6Nd1BVGgaaWo1fvx+WpNRhQDmcgyN3Xo/hQkca+Y0d/TGn4ch60PpQ6erI6R6sgaNVDkZzDZ1iWwaLC1Vm3Bp7uwPa63sEjT5KubTaGQ3dpm5q0tYdtoMtZP8ET0xeZPaszbXXTIIIbAo4uo85aGJMnyC1yjgLS/g7W4Rrm6hGC1FO0J0UdzkPjTzpJmQ7EUY/xcpVyCIHjAlEvYYKQ/Saxjppg66iIxP0BrKokJ5AJwId1aHyIFJHCKOPUn1U0Cez5wh2Otx4fYNmpGiEklYHwr7AUhBVDAJXkM+ZiFSRxhqQ2HnNnKtJI0EUQCeAMFT044gg1FiyjEi7WHYZI1/+FvvB/fYdBQdnLtQpzBZY6SQ8OGlgMGymIhhGs0mq8UNNv6dI2wO2tiVOySZ2IREmwcXTLFRLxLt9mr3LZIaF9jwsJ6R+/gwnT06StGHpVAUtDdq7CXuNPjNGl8ufeJ7B5BLW8VnyMxUq5TyTFYuKaeAnJm/7wCkGsSZINEvLNsayjWuXGfgZZlZEdQPC3Yjm3RCzZGPNStJwkrVogVvZBgXXYPrsKZZqZV6+9SwuDnmpqHiayXqBMLTx+xGXXgs5P1Ujl5t8Qwn5+47bf5gdbhv3vaoVGgMtTIZyd9OAAdoAFaGzAaQDVJQQbd7AXS5j2FcI9CbCDDBrE8iZHwApkJ5DcGkO5DLGzCqiMcBQArqfgMLfAatG2tojWbmOK0PUZgcx8ZtgVSE/j04d0lebRHaNTesk8w/nePFzr/LCi69xvZMyCAIuPHmed3zgP+VrX10j0CmZ9An8JoPMo5TYdNrXyVcrpAlEwYBBEGFlKRPLD6LiFll3nywMGfgply/foVB4kcWfmcY0v3357/t2xEYO2ETFw2pHbPQSpGnx8KOnqU/McXstRKcBzf0eN/dWCNq3qFmw+JUFznxwhpPLBqlvEzYcOnsehaSGefUysjiFMTODNzeHM9EjMi4hbPBXqziWhcgVMCZcLCckiTtYjzyJrTOoziOnS2BEhK9uYiy7hN9Yw7o4gbGwgDBX0a2r4L4HWQPLlOj12+AKyBkkG9vE+QrXP3mXS8qnnyjSTON6Hu946CIsTJIrOTiVHLZhokJFt5OiXYmOFCWZESlF6oKYMlDaY9CNef7KLmG7S92LqVUEvfbhJXzTk9P4tsHeIKVQtpEIFEMpRKUVcarxfRj0U5JOwMaWQWHCpmkpwnIJ/aazLE7Viff6bHVfQttFcCO8ksP0A8ssLtVIm5rTFxfJQthYiel321SiDq/80dcYzJ7CPTtLsV6mVnapVk0qhoEfm/zwT5xnu6cxpKA24WGednHsGr1eiq08kn0ffyem1QEjZ1KZlcTBLFeDBbayXYoTRQpzUwyar9HcTSgaNkVXMVmCnG3S6UGrnfHlVwPcRkK4HzMkHDNUd8mGcIlDrLY4cH60HkqcjqE6b6TcCKFBD6UpxYhvoJRirPx5kO0f2SHRdxwJHFYFDhL8R4KDMY9AMCJBjyKYYUM246AyMIQCKbIsOzjeMNMv7+MNaM2Ia2DcF4Ac/qzuqwSMv2uaQ9y5YRijQGoMZZFYlnUQRAwDkiFJ+tSpZUzLHTp+0kPIGuP9XqsAsh4kIWowINp+HXephOFcop+1yHkh5uQUxuTjw/0+5+J/eRFjahnp3ER0+hgigt4noPJfgbCJN+6i9u5hZT5qcx8x8a/Rso6YOU62GpDciwitGrv2cRYfK/P5j/05l+/ssLYXISzJuUfP8bb3/U0+9+nXkSWTOG4yiALizKWQSFrNq9QmZ4gGIUnko5MUM4HS0kX87iYOCVmi0cLEsXMsLF5kf/MOkAxhRmJ834fOsdIjUvt9wSejSh6Hc5LDgFGjh3PgYB4evn8wX6VEjJK8Yy5LlmXDcGQUXEopMU0TZehhEf+gWjEcK03TI9WBUe1MDNv3jYOHo0pIR02PA+cj818pNYp59JHA4qDcgNbqULVLZQwGXf74Y7/Dhz/0k0yVprBnY3TdYmH2HNdvDei0Wuy3Yjo7VzH711neucVSaYmFszUeOi/pbUNvRzPoOVR0AXP3G8jqIvL4Ms7yPNJdgfU7WIUcrX2HSbuCztcw50yU0yLb1pgPvQlbZTB9CmPOJm10SDdbGLMmwdfXcd4ygzG/AOEldDsC583I6lBeW9+5iZipoEOfZMcnkA7XP7vC1/FJIk2qNZMTkzz20GnEzAS5soNTL+JoQdhL8MMMbUt0nFExFT2lqJTAK5qkGfQ7Ec+9vEPS7bFQzpBhgt+L+Xb2nXVIlhn5gmDBtHAPyp+CDIUfK/x+RthIae/6tFe+wfT5R+m7kvZQUYozVc2VGy36eyuIuRnSwGZyvsSZN53Drk2CNhBTkk4gCBNNWrOYfrJCpfsg+VYbbyrla88+Q2NyhrkPvIuqLXnxVXjqvEC3FIbWkAh29gUTE9D0YbIkiVMXa9JhYlqTTzSbt1Ic4fPV37nC9auXCe0eExOzhPd2WGebR88v8vXn12nsZ0zM5khmTCYwuPD2B3j2mZf42hefRTYdLpx+8v8NHvd9+0vZuCA+tDRrjja/EmCidQRYoDJ02oZsA6GbCNfBefO7kPGfovs+lSQkUgk9o40TfhKK/xAUKNfEnPsghn2e5NVPYM3ECO8E6AxBglVq4S2skZQyhBeSXruFzBXR5jbaqpDNTrIjy5x6+CL93dus9+6wk/SI7TwiP0XtI/+Q3/jV/x0hffJ5ieHkSHWJku6BMJmcXR5qPOuMNCtgJhCEgva969SLHscXjuO4Ls1eh82dDtu73VHmje/Pte/CxpfKNCSVioMhFa1mj+2NXXYbMT/0zkUu3+gTGibazahWTZorPr/+8d/kv5v6z6k/VkY6Eq+ep1R3CPeLZDspaQp87SVEoJBzS7hv+zDJa69jyB2S2/tY9RzWRAGVlwxax3BmNXZtGZErgG2hnRyF4wWyz9zGrtqk9xKEVcBYuAjFR6HdBdFH37yG8dCjILdR/jreY28lu7nHH117ntxbf4p8ochE0WVhcYIHznk0uhorb1A0oJ+AbxnUZ3JsBil3tzTP3YAHCj71qsYr2SSp4NVr66zdvsMg2MB+YIml+XMUe+nBNWzJjPMVi7JpYI8IjWqEY+5FGWFbMWgmNPa69Davs/DQEzQtSTuBiZygbCtu3m7S31tFLp8gaWhOvXmR2VNTOMUKAhMxJWgMBLHQiGMOs3OT5FsFSp0uuemQP/n4x7Df+XYKb34AWwmu3YC3PiCI9sBB0w1hoAXlsqARaGZKBr0ohzNtUJsRhInB1nqCKyI++7+9xPbt17DnCzipJLi3yczJKqcWC/zBH17F2s6YnLeZqpuUlGDpLae4/OcrdFf6+O0YlSiyZNQngEM8/3Bd6tH1ub/ZGRxxpMfQnvEWdySDO3TaRwTMEZRCKX0Q5B51rt4IvziY86PPDh1yiRo1lDpw3EcKRWMbvz4mDGdKD/HueujUDT8zxp/fHxi8kcx6kN1lqJCj1dFAwBxVELIDEmqplCcMQ+IoIUkzpBTYtsOv/Mr/QrFURYoYiNFquN9rnUHcBHUXLUJELYc78RRG/Hl0L2QyDtGk+OoOVvwFRP7voDPIPAvrwkdh+yukWy9iToH0TkAWICwDd2oLPbNHtJeC7ZNe3kMWKmi5jbZrhDMztN06Jx94kO72Ve7079HWCYlTxls4gfven+Vf/vKvYXkJlb5BJkugPQokCCmZXjiFLSSDsodOyhBDECrad69SK7hUZk6y0+7SHvhobeBIG8NwiPSwU7JW9weXh/DS+6tT/D/svXewZFle3/k55/r09nlT7pXvrq420266xzMzO8KEBgEaFsRKWrFoIXCxKGK1xGrFEhLaXUkIo1ihAbGwDBoCtIBAgwbGtp92VdVd3jxv8+VLn3ndOftHmpc1DMEEM4qN2OgTUfGy8tq893fP/Znv7/sdmFMfJjYmkDeAckmGCfyxey777EKHEeYgSJCHELmhPRoDwpUwCEGOahiMNxBr1Q8shs3rfXsaP/dREeG+FOCoijBWIogG1atRQKA1iiFsrX8+UayIVYwaQJeiKOLypTfYWNminF+kWJ6jNLVAEKzT2L3EsQc/zNW1DpaYwuulCKXHb/+nT3P+oZ8g+aiDlbLJugVEkKSzl8DGZ+/ababevIqVLBHPzxEeexa5W6F26zmyzOIcncKYcAmtmG48gzMDVvEEIpFEWyb2hId9NEP8wgp20Sa6FiCSKWT2g/2JoNME3ULfu4T5zAdRlRcw0wnkzAma17f4D1deIvfRv09KxpTKeY4uZlmcc6i1wUpIcgbs9jRWyiaT1mx3IlZ2BC+8DU+UmphFE+FatLoBd6+usX7nLt1gjckjD1OYOkppo8FfNr6u4CBshdCNMFMmjW6MaQqk0NTqEZV7TVbv1Liz1cLJFjnx5Hu5rTQZxyCnY6xel+pmjdA22a1WONiu8tR3PMvJk0cRjRAdS5oBLO9p8mmBYfWtygBaQrD43z7L9ud2OZpMcvf6Mi/v/D6L/+C7qbfrvLKeYL8rWMjBXBosAdfWJVlbcrCtmJ8zsTxBIxZ4Cc3ZiybK7/CZu5/i7l6F7PQkpogxgj2u/fE21mNLHJszwDLpdjWbt2vMPvQ0b37lZZ448TDv+tgHmJ88OZpA3xn/5YZpFIjjOkp3EcQI7YPaJtr/HGKAPVXdBnHYRbvTyKSDrlTo6i5+Chy3h269DmVNsB7inTMGzXFHcT70d6B3G+EugJ0E0SHe26F3a5eOFJTec4T4zgbxnZBIR6iZFMapMywmPkI3lvhph2//exf4DiNFS0uu7Hf5xZ/6FZqVHaK4g9Y+FhpXWHieSyafwWw4+NLB0T0SKAKrRCrjcSadJDfzJB3TY3o+w3c+OEU+n8RxbJIJ553A4BsYUgosS+I5BilX0Vy7xecr25y6sMTsAxl6KstO/TgvNffZfu1l/uCXfouP/di3Mf3ADMLR6FjhlT3k9EV0dQu9MI+qa/R+i/iNNxAJj8wTF4i2W4hKBREeYC6cppAvw+a/R8x8NwSgawrlhwRBgP3oBP6nbuB+eBoKKVRkIx0DJgqoaxK5eIb41mVEMYWx+Ag4RVLnZ3nkgS7zH5qnajs40mTKs3lpPaB3oDky6/KWr5CmIOsKklqQSxi896zEuSC4tWlxeblD/Xab7IRPfWeZ4sQUjy+cpFzOkEi67HU3RtctaPiYoUIJg2YUYxh9R2G/GrJzrcatu1X2WopEscCRh5/leqwpuiYTpo/ZblOrNfANye7+Hvs7Vf76D3+cvJFARoI4MmgEcLepmcolQjcSAAAgAElEQVQLlN0PPrRt0LMlR/7ee1n7oy3OZyyu/qe30Ac1Ln7ru6k2W7y4nmSrDhdnIWNAx4ebG5K0Jahuao4fE0SmjZKCRFKTzwlEEPOpK79IV3vMMI9DQNza4vaftJEPTvLs42l6gaJS67J+t00i42Fer3Ikk+Dz1+5S2Wmhoj5ee+jkAKMPI6iRBq36mgDDjCmCMUjRENs/cHzGegCGOx7SRwIYg+WH1YT7ncWho/W1pgc56FUaNoaOkq5jzctCDJiL+gvoK20NHUtGSYk+u9Bhs+uQQx8Og58R7EOAaZuDZWqkg8BgH6YpSaWS2LZFr+vjByFxFON5Nj/2Y/8j/+h/+Snm58oIEYLuosNtVPU/Aya6XUf5TZTSKLuETDno3R1aVoDtahLGDqp9BZnThKshqacsYl8jjz+JXDqNCLfBmQHbBmqEy1t0N2oEKZv8M4tEdzZQ1yMCTyGWSiTmHybhPk4nkgQZmx/86cfR0mY3FLxybZPf+j8+TateIap22dj0cbTENWzchEs6m8Kqu7SEQ0Y3MLRDLNO4tuTUlI2ZfYINPyIU1wn9TdqNCu12DaUjpNAD1qtxqM7YfR/LtPdtawx7MwweB7Y66kMZUIX2A8YYKdUITnZfr4m6H8am9bCZXQ0c/n7AN9qXVqh4SGE79IkOm9T1uPrdWEAx3utwn/32H4w/B10a/93xyKb71yce/O4w8KkebFHOlwgaW9R6TbJoZDvL9r1LfPDB4yTf9wyVisvVF7dYvvEpfu+f/Brf9c+/n9SkjTIhNhTmTA7r+OOYUzdA5OAAjIMK6vo1zOkpzvz49xOt1ZDVHWRmDndpCWeqAnv/EbF4DJqguxFRL0LJGOvBIsFvX8P7xAmU5aFiC+lJsCzUHRO5dJ7wpc9inDyKzM8irTTZ8zM8diHmxEfLrLRgNukitcEr6z5hA47Oe7zWisl4grQt8AxBOWVxrCRwHxK8fttg5W6LWLex7TqNyhqlmVkeWDpPsZjDsiWR8U2qHJTTLjoQrKx1mCk72NLg2h2fjXtVDrbqKNvm6BNLlCdtalJyNNm/xU6kiCOTlQOJrq5xq1blwpMfJlOaQTo2bskB06QdQykHhgZ69JVNLVCx5KYvOfb0BF+8eZWD3goLB21+5V/8Gn/zx7+fG3+8yfRSnvaBwUpNMzdjUWj1KJaT6NCgWdEcuOAUBOmB1ceX/w1x4w5GrMA3aXUk6ZMmF5IFant7uF0D2zZwTJMT+SQHW7cJN2FycZGMVxhjknnHa/vGh/6qz6PU2iCrlsEgBSiIfFqX/wX2XAR0EVbUZ7DoCsLqHv5WD6k6GFrRDhUH+wHJeo1k+6exp38SYabRWhBv7dJ94TUST+fB8hF0iK78Ggevf4n6vR75siZuNwhth92tCGPKotLp8dYf3eTcsdP4tWXevrFCaeEB/Nw0HTvN0cwU/8N//S5+/fmY1bU6unNAUvukDRPLcujGEUhFxkli6wKGMLAzHknLJ0ycZbNl0lNNAh2SS3m8/z1lTNO8vznsnfFXGpYhSKdtHK/I0aNzrG02+bPPvEIYOWgclHZQsoRnp7ndW+al3/ssj7QeYeHCHHR6aOEStncxp9IIehjJAAyNDi10axJ6st9Yns2DctE1RfipNwn8EPPLz2HNn0Eo6FS22ezVOPH+s4igSvCHz2G95yLG+ePoQBLeiXBOpcGykdRRm1eJNm8jH/ooUdPhT6/c5Oj+DS6+93H0xBxf2qnSOoAzj0+y1gqYyhhk3D7WuNeFSABasdkRFHMG5QeSbK00+f3f+gOsXJqFE0vMFQKa9T1aFYWI2qNrNptLUt0PsY2IUs7GUIIb9wJWbu1R2zjAnimxdKFIJm/RMCQnU31HNBEZ1Jom1VpEXF3jZu2AJz/4nVh2GithYwmJFgYdBRP5/nwvu6Bk/18YS274klMfmObTLzzPDJtUr2zxR919PvK938bNP95g8eIkaysR5bxBLiUpEFAoJ9GhZm8NVF6QyQhSQmPEIdGbv4Dyd7CMLM0q6KxN7lSGB8uCg1oPQZ8WdcI2mciZtGPB9nIP3Yyp7/fodkLiSPXVZWUfRz90lseHGGb940PnW4xlO8eB04J+g2kcRYNth/Sjw8bTw5lxCMEZNpYO2YBGDr4YkFbqQwpTBpl7wxw0HUsxEJgcHF8Mvhs4d3EcI+RXNbsyqAToPkvT8LwN2YcSD6lJh46eUvq+8zOkMTpPy7IwDINsNo1l2YDEcxMYhqTV7pBMeWxsbPIjP/wPcByBbSjmS/A//cAMzqJGhCHCU0hTo9uCeG+N7maIRYBtwE5H0zkIcRsrGPl/jD33UwjLQFia4OpNdH0N90IOYQXAFuGL/5jdV66iDgKysyZxp0XoeGytNkk86nLt7j6167c4MlXEr69x6e27HDn/HradNF6iyJLl8aOfeJTffEGxtlLHCiqkhSZhWEjDIoj61YhSIosMXAzbwnQkjgxQmYu0VJJuuMdEeRFT+exv3aLTOgAVDyowh7CxYYZ/1FMwNLTB9/f1Cag+qEfKPgzONIw+Ne6wTYShSJ6BEHpQpVLjkeCoj6W/+0GwKIfBHkRRfN87SQ6eCaXiPgxOH1YdNKDieECDOnxOhr0Sw8BjYJSDHywGlcrxZ2AIj0PI0XEOnyUxCj5nZ6dYnMtgmDaG6TBVzlE/aLC32uK5/S1suwlWjm5PYAmPq62bfOFf/i5P/MAzpAsOut1DhRqtm3hzM4QHFUjFKNVDNyWiO4HuCqxyHlGcAJ1A3akR/ee3CYIQ68ufwzr2ILpe5eBgj46jmHt0AaIq/m/8Kfb3vA9ZLqHqgngP7KUUWBZyZoL48gvoiSOIhUfp7io+c+kGD/yrWzzxbR9lc6vHRiUkjgyOXyixXPM5ljdJOIIogLCniQb2sNoSHJ+1WCymufKVZV787AtYuTTHTi4xW+iyvrlKwrHRnRZ/2fj6YEV3rhIvnSBbmkco+MIrHd6+skKczLJwpMzkjIdb8Ci4kgyarNBUa4pKLaZW8VldO2B/r0Z58RiiWCaWNmiB9Ix+yQgwQo2KwNcQ6T4cybMEtgSSNqViDpnNkKTLaavFGy/fY3HBABUQYhIamt1uyJE8LFc6HEnbpFyT0B4+OxGNe1/hF/7d8zS2KxzJJSnMSaKZJAc3Khw/ZpJIp9itxhg4WI5F96BDOhPy2MI5js6cIpnIDnB6X89Ve2f8xUOP/R0hDseWC+K4hdIhQpgILLrtPV66XudMvUk63cNKgHRdZCrdb+AUDsTTOLFNbvWAuObTuNbBm7iNLPwaqnMaYS1hZAX2qQBkFcJdouXX8VfeRDodkks20WZAFJqEqWmarOKZKeLIpXqnzuc2XiWfidje3WK3FdEx79Ihw0riKA9dmODvfudH6XRj2t0eKoxwEJgiJo66KNVBCI8gMAj8GAhIJR261QS1apekl6AwkaNcSGIYBoZxGBi8EyD81YdhGgjpYCrB7NEJ0CGthuTeaoNqNSDQGq8Y8IM/9O14bkhOSuJOk7XX32JqMouR6bNfqGoXlEJYFiKdQlJGK4m+dQdhFKBcRPck0YsVovXX8YMY5/gCe2+tErTXsfUBpaRFtGFgnS4Tv3aN+MufQ3T3MJ59BuuYAULRu7qFWa6j4wDV0Vh+l+71bXr1DVZ6koXjeyQji7gR8tDJE1g6ppSxyNgSYohCjavBNsGPBdoQmFKTsASFtIEbSeqBItIttvaaGNIhky9iivTomtWuvML82XeRLJRptxVvXO9y7a1VdK7EmYfmyEymSGRc0rYghyYnNNtVxWY9YnezzfZ6lVqtzeTR48SFAnFsIEyJtAwi3RcxM0OIQugNHCBLgi0EtgE6ZTNbLJIM9kg5HeKwzuXXljl6XKI6PTwL/DiiEcFEWnBvv82JjEMmYdAzwRQa5beo3PsKv/hvn8NqNzmyIOhNJ2gZ0L3T4viiJJnLsrbdJZMyiCMf3Q3Iui5WHPPq1XX8bjRgJ+pnRoeUkiPBM32YnR0XQRt3sQ8d/yEUZJBZHTSBigFT0OBJP8zE6z48Y7SNHoMa3Wfh/d6/ERuRuF8QDd13rg457MXhOmP9BaOAY7APYwz/3fdSxw/cb0QeceNr+vTmoq/1MDxGn3ZSYtk2uVyOVMqj0Wjh+8HICY5VH2703/3Q95PwXF555StUdpYpTkiev7LFwy1BKhtieAbSS2CkE1jmgDlLzeI+ZFBebSCaMa1bdZz8TWTxV4hb55DuGawpH53rggjR4SbxrZfobdzBmVLErkkYC8LIIkrNUI9v4TgZgm3B2r1tlu+9SS4Vsru3Sf3NF6nqJNooUyrMcupUkb//3R+j2Y5odbsYscZCY+gYFfeIdRspUnS7EAQBWgUYUqC7eSrbDeamM9SDDr0aGAYIHYGOGL4Th9AfpTR6YA/97Pwh41A/mByyQo059cN7Osiwj/oHhrh/pWBgs4dsSMObe3+1YujMj2xD60Mhv7H1+pUERvajBtAmMWBZGvZLjNOuCjnQANEDpW4Ot+/HCmOYtQE0qv+ThqCjfuVEqL49d7td9g8qSMMgl9OUZhK0DvagomlU2+xHDUKjRn5igv/+Jz9OMhGS15LVNy+T8iTpgktsahJuDmu1immYCM/DKqUxshLDd4guX8PJHEHOp4iXFdGr24TrV+hF4J06zvpLbyJ761hGj2wxSbwTYZ+bJvzi60T/sYX1gWcwjp9CeCbogO6VDZyFNnEQof0I0WrQvblPr7HBnZs25zcrNANJwvRYODrXn++zFgVLEoQaI+z7ytZgvscQWEKTTBrkXAM7ErQDRaybrG1VkVaWTGmCVL7IXza+ruDAFCGeEWH2umxc3+aVZRcvJZheTDJ3JE2xYCGlwNPgKthfD6nuNdjc2WOzUqFWa7EfmDx2YonANgn8mMhXRJ6BaYJQfZrZQAtiC5SA0AAXSEUaX0GimGQvZ1PpCB45dYKX72xy5KlpCCOSEgJDU++FRJaBJSyiSGM5YAiIe6ovpGXbPH/1gEwYMVVQZJMSs+jhr0KrFmJlUhhKogNJ7Jh4zgQylCQxSdhu31jEX1TMfWf81cfh9exPYgGaCK3j4VSJloLk/PsxvNcIwnu0VjuEfoxVkLiTGs9LIMwCjtEPPKPOLtFOj61X9khNfYnEXAUzs4e085izATquopt3aF99hXati0pKjLSFcBV455DWAnpGo7IpUqlZjp9L88aWplGvkzt6jKDjo9tt/FbI7fWQ2Ghxcj5DaaZAeW4a00gShBqcCKKYjB0j44BeENL1I3Qc4FoJuumA6aJLxk6RyKbwsk4f0zx0F94JDP7Ko++49TNRg1ctc4slhLQxrDbrmS6h0JxcKvL4e5cwPIn2u1RXtvGrDcgkUEaMtBx0FCFMG6SJjk3wLfTuOuw1ENNlRFegN/bRN95CN2vYiSNY5RJGdRPTNHEnFsk4Bqp3ABWBbu2jt2uolMR810WMyRTB1Q7dt+6ROBUiUyVkJg2miXA1z16YYbeu6EYmViyZL6eZKTiEQYgTK6wY/ADiCGzLxACEhKwcoEYMyKQTHD93jleuXyKuVlAZB9uyUaGg2uyNrpspApJWTLRXY3WtyxubFl7GYO5YitkTKbxEnxXJ0aBj2F0NqO7UWN7apFKtU281accOF4+foCs0UTcmTJkY9tAREn1BMS2IHdASkGDTn+87MWSns1QOBE42ydzsNG/d2+T40zOoTkTGkdR1ROgrYtPA0AZhqHFcAZEiakeEIiCSFl+4vM+sjHAISaTBS5oELU2rHiOTIboniCyBjvrUtKqtyZgOcTscwHL6lgSDrL7oN0ty+PV9mdn7H1c9guMYo9WGvO5fw1qF4JDmA4aO4iF15Fj2eGz50PkaUZKOrTuCmAyCBznAhQ8hH0Mn835BNQYO2uEPHa039myNHWZsX2IEMfnqHoUgCGk22wRBMIAcCVKpJN/6rR/jAx/4AMlUgvLENPt7G5QKEPcqGKm36XXv0Fntoo0AqxDiltK4noe0CrgnJEZPE2018Nc7bLNDavrzJBfrYBwgMxLSXXTcQDfu0bzyAq1OjCwZyKSJCFzwziPtBdRsk9ibZHKhTF163KjE1OsB+VOn6NY70GpSq0bs73XpRg1OzKWZmC8xO3UUpSwipcCMQcVk7RgR9Wj1IvzAR0URUpn4ByF5T1NK5Lm1tcnqWoikDyfqZ84FclAB0FKidDzIjo874wOHXn7td8QhrEfff88GlaZhUDcMDsarXEMzGFGkjhJUcmSzIyE0DqFDQ5seVTbGs/t6GPoOg+XhYjGy31H1gsOqwX2CgcNzGm2nD4+hNXEU0qg3qHgulpQIbVGt7hNR58SxE+y3c9QCjZdxOHt6kqc+tITpSeJOm1iEmCrESBmEfptACURX09URnulimgnMnkJvbSEqLUTJhYaGu+voezfR7RZOcgFzsohx+zXMYo5k1sFLgO5WIRLozj7q0ip6aR5xbAGZtwlutOlcuoPlCUR+EZGfAtPATgre99AsO3WotBRu2iVXSDGVsYjCCCfWGHFM3OnTRJiOMZrv8xJCBZ4FpckSc8eP8fa9m0T7NjrjYBo23XZMo/FNghUlM3lkLNl8e5lLX75H68yDvPvd88wWk0hhoCINkeKgEdJuNnjrzQ5Rc5vdg2W2mxW0myFRnKAwNUUlVPh+RLOr0R7kzIGJSAl94UOE0ReZ6WlwawG+aRDnDOo5gR9bPH7iAVLVGzRaAV4iQsp+v0FaQL0ZMTdhEYaSUGniqP8G0zYkF85z8vxZzP17RALqzZj5wOf48Rz1PQhbNvlUGpRCapPizAm6tS4ra/d4sNfrv2Vh9EC9M/6q42tVC4YPv6bffGwi5CFTj5ss8+iz34sKczTvfIb9O/eo3euRKsdMegJHZDDzU9gpG13yUfUAu9Zi+bUm5XRA+Ph13KlNLK+A4UwSdiqwe43mWpuOAdqxcT2L7FwKkXk3hsjSLu7SFhal4lkee+Ai4bV13vzyW5QvPoCub9Gr1ckdhGzd7XD97Ru89Nw2Jx5Y5IETp5gqTCMtF5X1iGUaaSVIyyae6+MkBpO/L0nMBiTMBI62+o5swhxjLHnHxr6hMSxZ04dQ+D2fucUZLLNIIqs54oPhGTx53h29FYWbpHTqOMQxqucT1mvQBW04CNdCdzqojV1EQyNWV5DFEmKmAHsGYm0bWX8DI0yTLC0hEz6lpQJi8gTGkUVoNom3Xqbz3JfQUQcR1dGbG+jry4jHz9C7uU6wtY9bymNOzPb7ENoBIhPz199/lusVwabMY2ULzEzkCFoxeVfQa8fEYYRQYCGRjsTvKApJA0NJDoQmRpBMJ1l610Vefe059K5JvjQLKqKxtcvq2vbosmWLE/i1LstXVrl2p45/8jTPvmeB+WKCKBboQBEFinYroN1o8uZrXUR7lbt7t2hGIdLLkCpOUJieYqsX0OlFNLs22JqkI5BaDLodwRwkg7TS+LHGPQjo2QZ6ymL3nsLKFji6uETyyjK1VoDrRlhIElIRa02nHTNTMIhigVCaqBvi+w1it0dh8TynHzhDqnqbak9SbMVMFQ1YzLNya49UWWPFoFqaSLp0cTmoKGTeJGlZMIbdVoPse6w1hiEGUI+hgwSH0QGjLCmMvyvECMahYZSZHzrsjO1HwZiTPdaIPDRrMeSxP1ygxaA6Ma4joBmtN2QS0iNNAw6Dhvt9sPs9/tG5DEKbsR6K4T5Hr8IBVelhU3MfjhRFEfV6AyGg2+0SRhGGNEins1y48CA/9mM/jDRNNJonnnxmeBJoHaHC3+fgaoPNl1cJ23Uysz5l28CReURyFjcToya66AjUQYf1V+uUMz7x+6/gZJcxvUmETBB1KrB3k+Zaj07GxAgtEgkbuzSJzDwFIkdz4iYimmTy1OOkz0/BjQ2uv3qDqccu4q/fJNfskdnx2dno8Nblq3z5C9s88K6TPHzyQdKJHDgOKuWhjBSm7ZGWNZLJkEQ6iVYC5WtCt8HkdAHRjnCqIVJ3UVEwuOt9W1BjtjPw/wffjYNt+pUEPawo3Xe/hnAhEMYQpqNHjrsxoMeWcKh3MYQjxfEhnGh8h3pMiwMBqJGgmhwoKN/nE4nDxvf7fHk9Ln6mR8cejvEK3KH9Hi6TQnKYoB1WRRRRFNFutagduDiWjQqrXHr1MtoM+GsXP8icVSZwkywsJHnkVAKhIfQjpJPgxAfehQpC/EYDubNHWPNRdpKDgwpsBySDOrIWEm9u4R6dRyzk4aqP2LqNbNzGVFnc0hLCazH1wAzmudPITBrdqBBvvUHni8+hVQcRVdF3V9DHttCL0/RubhBu76P2ZzFOL0DCIwoC3KLg4x88x1vbkk0vS2GyRD6VQHUUOVvQafVV2o0QhGmCFoQ9RT7Rn+93Bs98cXqSxXOnufrWa7BrUppZpNPosrvVZPPeFn/Z+PoUkl/b5tU7n+fS2ia3Myf4nvfOsJS32e+FtLs+rVrE3rrPzTcrbK9+mWokMYw2dsLE9DxcqfnAo0dodBVl16NlOazFksmOxjQ1rimQHngK6hH4kSalNI2u4t69KudSWVxHMFEuENsW+8ogmJonjnxMv0nHdjGSSSZzabp+QLOiSOVNDDRmHGMJhXBNEDE//6//CbXP/Sqf/rMrvLbSInx1mY992xmi04+zHe4wU5jFDATVRotNJIvlPC+srCGdJEKao878dxy3b+bQY1NeiJA2aNVXIOaw5A4K9BPYxW2cYz4Jd5NiySCVyWEkT2O4S7D3AnbawXj2HFGnSfGNdfSdBpf/cJ1E1qY05WJ7kurNFmkR4+UMciUbczGNMVfGMBYIogk61XWef0PTCSXnepL3zSd48vQ8s1aSm34ZM19garrNhBdiPa34nec3uXqlwcF2jc+uP8fSRJaPXDhNSi4ipvKstHyyVpKZbJG8Z9Jp96hJhZdsE3Q0yYRHwvMwbWtQIv7/6l78/2tIQ46YNI6dXgRga61FMuNw/phDOisgiFEHIZEfYbgG0hUIQyOVwk7ZxIHfV8cNfOJr1wifewUzmcc7dgbjmZOw76K3uuitABnEuPkFZGkRsb2D+TfPwPkywpboXpr4N57G3/8TbNlFiBB1b53oM1/EODYLd5/HyS9Adoo4dIlv79J5+zK727fJP/YgZx97nGMyy1bNYGMvIuM4TJfBldCq+ri2wEoI2nGE3+4R4KEtE0OAITWhCSJhkU5NE8ch4eYNNCYqTmIb3dE1W//cCpWdl3mrrugdO8vHnpnmRMZkuxXQacfU9yK2ljssX99md+MV9iMD22rgpJNIy2IiZfH0Q3M0ujEziSRbhk0vEMRdEELjmCBNQcKBvQAMpbEiTaMdcfdulYvFPF7SYHZmmnQ6S9VwCKbniIMAW9Spmi7ZVJpcwsH3IzoVTaYkkCrG9X3WdzZZ0xXef+Rx/s9f/3m2P/3T/NP/5za3ru9zTpo88uQJblxrc/bhp7h16Spe7OCnitSlTbWzQmttk9WtBsQKzzKJlabrhyitsExj1Hw8bOAdjmGWfsjqAowe5KFvN4RpDCkk4TDLe+gwHQYT/UrA4WQgEH0+/ZEK8ViAoIcO1LCKMObY634VRA2xHwK+mjZ13InsQ4LuP7chpMQYUJVqdZhdvg+HPth+2AwdRTFR1COKIrTWmJbJRLnM+973Xn72Z39mUE1RKB3ACGgMfSHMZ3Enb+OejkiGDQolj3R2EiNxBsM7g965gXekTHxymqBWp/D2Fup2k5d+4x7TcwmypVV0pGiudkgJRaJgU5xwMZfyGPlJpHUcPyzR2V/jT18xSBfgWc/g1Jk07z6/yNF0jmu9Kbwpj2MnuuTNmMZBwGde3eTalTrby/v87q0/4r2nF3j4xHE8OYcuZ1mu95h0s8yXEpha0e4FNI0Iu2AjmjFvXHqZ1c01Wr0GWvR7NdCqfw/UECYkkXJM72BcmZhDSl3GkpXDfhCt1X3Z/uFNFgOuXSU0f16rqW+bw7B3mOEfsmwd2vr9wePQwIdUqIdVNI0h+sJ3fXVwPQiExagMIujP0TBs7j/c5Xhvj0AM9Fbur0gN0W5SafwgYHNnh6SXoOt1aNT3KRbKNPZdJhdjjp82mZiwEb2Y3l6Hyvoe6ckUXs5DSo0pBalimkYnpNvr4tom+ksvEm5VMQsTWMdPId93Gr0pYDWEio+BhVmYRxYWYG0L+8feDVPJPmRlK038exZ+5Y9x7RhETPzaWwg3j/CeQCy/gDNxBJ2ZJG4Kghu3ad65Rr2+Re7RB7j4nvdwInS5t2uwt6/IJywmSuAaUN/pUcgaxJamHfr0WiG+8tC2iYNGm4JIgpF0SSenCKOQYPUSgZ9AkMSUh5Xiv2iIr25Cuv9+92evjz72d5gpF3CnBY//rR/k4bzN51+/idjfZWVlmYNaHds02e1WyNkmS6eO0DCLRAmHqZkCTy6dZuX6Cl9YVTy+dJzWvkE1klizSZ48ZjOZBieEKBCEErqRotOImEso3lhZ4+EHp/nKZz9HD4vimUd5/uVd3vfwJLmFFLv3buM4KVyvSOALCpZJJm2yIwwyhiJvKzzh092vkpvrYbmTqNUX+cPf+VNeePE6vtKQylC8cJpgZwcJ2J5BKp9jdu4BPv7d30Wf+SGmurOFEILS9BzSeId//ps39NiE1P8bqw69zhp+2CXSSVqtNrNTC3z5d3+ZXjHk+ImjHJ+ZQWsfyzoJaMK3fwbhNCCdQzmzxNZDCLEOvbtcenOd7bfrHCz77B9ETLgOs0dtCq7F1LNPkJw/hpRlSD7I2srb/JtffZF6u8fU4hwTc2WyWYNvuXiani6i9hvsYXOz0uSg0+Jd5wqcT7ms+Qn+w3Ovc+v12/QqNVIZg9KRDD/0QJHO9LuxkwUs08G2JIm0xDOg2gtpRSEFy8QT/UayVMob0Bq+EyF8M0afieMQy7Hy9hZ0BOmMQyZvEG90QTX7jcbdkOgVNmMAACAASURBVLjVQXW7/USAayHKeeykxcGbb9PdaWMEadI3Q1IPzmN+7wX49B7q0m303ia6Z2DknoGERoguiBV4poz40Bl0XRBdaxB/6regVYOoihItlGsRZqcIdRfmHmXt9hdwhcDLFbgVrfFn167z/T/6IxTnZnEKs4RmllZX0GnBvT2YnJQk7D72G6WwjQhzIkGjHmJbBgmhsQwNtkAZgmbL5+qVuxzUVthdWSFqd7BMzU//s38EwPd98H/GMHeYedd5Ln74v2IpafCF129gVnZ5+9YNdKSIiagHdXKOxckzx9ijiMxanDm6wJF8mdW7W3x5TfH+82dYuxfSTLlMzro8OGdRSoIVQuQLAhPanRjdi8nbIW+tb/LUo/P8/r/9v5m+cJGmMcHKcpsnzpfIzidZv3aFfHGOULkQCSY8h3TaYlXDhKEoODGq06Db3MNMHzA5cw7/6h/wy//777G8uosvDVQ6S/LsUdTWFlIIElmLZkexvN7g5toGuYSJbnU4u1hkrVJjdbdGq+szZO6Jle5Djg4tbGBngyBgPNU/+DwUBuuPYZb2EPM/ZKjRmgEZweD7YYOzHBNM6+8CPYRriNFXgyzy/cJoCMZYZcTIN5NSEqvDDPChMFW/iRgYMQ4Ng4XhPuT9B71vrrJMc+AoDrxKIQiDQ6rcb/nwh/jEJz7BBz/wgcFlUsS6Tbtxm0hbBJFBGEaUC5N84bf/OfERl0fPPkA+7SGEiWkuAIrw9Z9AFG10skRsH0Mbiwixie7e5aUXV6heabG34eN3NeWExfSiQ9G1mP3Wb8FOTiCdowRiipXl63zy11+m6fucPH+WVMFlYTrNY0tH6ak8eq/Opuny5vIuqbTgwtEMxxMOa70E/9efPM/qq3cw4h7pgsXCYobvPV2iPfMMbjLfF0HzDFxPYAvNfsdnv9ch2Fgnl87w6uuv88lf/ST37twm8n3iOCKMDq+VGgR1403JeiyjLgfV9UNN5MF2cYyQxoBdSA/2owcN7GIQHBqjQGPMjBnqUtwHIRtWxL4qkz80gZG2gtYjOx6HCvUboQ/VwQ+PN77OoHoyaL4/DLH1qLKr6QvnjS3p0+0ObN+1bNIJl6TnIIVEGi4fe/QTfOhD72f2ZI60Y2C3NHFQR9qC3m6dqNaAKAIp0JaBmCzgZR1WP/VHtCqCnCozn5om+dAc5vddQP/LVfTta+jaAVDCyDyESCg0XYS4Cd/3IBybRFcV8fUa0ad+C+E3IdxFWRFxIkGUzBOoHiw8wa2Xf5PJ/CL1uMHb1Vvc8H2+7yd/nMLcLHZpkU7s0OlImi1Yr8L0tCBhGcQxGDrCckHmHJqNEMcySAmNtABLEEF/vr98h2rtLps37pB0LO6t3eZXfvOTg/utv6aj8XUFBw8cOcq3fOd3896/8QmSMs313/1TWmGTirLIl9JYToZmlGHufJa5Qo+1qw0O6jVK5WlOnFyiWLL53/71l2ibaf7Wxx9CNS1WtmIqkebsEUm1EzHvwtEpj3TKRChFVOnQ225zp73O8YtLrFZ3uXNvG7+leebpC6xXWziRiVlwyXgWKdPANCySpsXqgaaU1SSlwhMBrhkjTcmNt26w8dqblA8atPe3COMmhiv5yl6b9NIS9cY+tWYTL+GyOD3FxZOnOfbEe0mWSsRROBCNMbFs+3AyfMeB+4ZHX/DsMCsRKJ9mextUjGnYCMMi9OvcfuMq8w+cI51KYxlDNh+JROK//g/x62uY8ymMfAmtiihZohUckM5fxBAttGoTBDa9bhFarxJknwJnEle6OIZFp13njStf5O72LL3SBI/MFol6B4QqIpXOsXbrMk888BDpdJY4DmmFgp1awJ3rG6STCS4e1WQmjnBtP+bl167z1pe+gq9cyukOHzt1kuSRRzDnJ0mVXWY8g4QFodIIoZEa5GDytixjxKX+zvjGx6h8PTAxFSuUH0AYIZRGGQ6EEdISoBQ6Vn3F4m4PAcTdDvqggdQR4Wqd7ut14uUsOWsV89lHELsatW9A1Uc064gT5yACfesmqBYi40AxiXI1qnsb46FZdGwR3rpHuHKXKGig544hTpzl2us36Wy9TCgOsAoJJhbnyT4yxx/+4Yu0ApNTx09xYukcxSMnsI+VabQEjcgltgfMJGhMS2MIRcLu21CgRF9wKdYIR+Epn167QaXbZLuyReSHKB9+4Ae+E4CnTp/j4z/645x99GloRNz77Iu0giY72mFuNkcnzEAyzfRSkqmMz8qVGtVGleNL5zl2bIZWt8O/+5036BhpfuRvP872zZC71b4y6HwZ6r2YRQ+W5pI4noHuBIT7HTp7Le51tzn7xFku373N3Vt7FPN5Tp8+wk69gx2amBMeRdvElgaWNLGkyWYdyrmIpI6xdRtDxGyub/Dvf/nXmQ5jHi4V2du9i2n2qEUhlytt6lIRWwoSKRKuyaRjYfkRl5e3WDdtSsUUB5vbbGzv02j30EAQRiPGomGz8DhmW8qvdnz6/lE8wNcbA4rRURNzHA/iOTUmPnbIdNRnORqASe6jIQXDMA+ds8ExwzDEHBxjRGeq1H3bjqeS9QAqdahFEDPkyDdNE9MyB0HQ4XqjbVWfcpOxSoMxEKYa/u3D+YZUr/25bW5+np/7uX/K008/jWmaaK0JdY9aax1TS0zTRQtNt3nA6vU7LFx4kIyXGsyH/XMQUYfg0s/Qq63hnCkj7BKaEhFJOlGLTP5hJFVU3KbnFwi7Ct27S5h+DJxpEoaNLU22t+9y9fYN1vYn6ZUmefZIib3KGm4yjY5j6jtrPHz6HOlMhjAIqEUGaxs1djcPyCRdHjoCmaklnl9t8vLnXmbl2gqxMJlI+3z72TNYx5/CWshSzFqUHIlrCfxYcffObSaLBVzH4cXnX+CTn/wkV6++Ta/bodfrje7DULOAQTVJjCBhg56RMTsZ0uAOHXWl+kJhxrBpnL6Dfmhnh3C3ESxp4JDrMfs4TOX3/46gQkPjZqxyJPrwzSEcSMWHwmrjQmhSHPbGDPvrxoMUKfrVXmNQ/VIqHnue9H2N1OMN0/1tBa7jkPQ8PDeBZVrk0zl+6Zf/FYtzsygFsepj9LVUCKUhjtG+j+r16HU69A5q7L70OsXZEtZqjFjxsGpJMt4u1nsfgZUQVbFgv44wDOTcMYhAXXsbYXYRpTSkHZTpE6t1zAszqMAkeP0K4e4qsSlg9gh64ThvvXwVf/3z9Gjgpj1SM3k4luClSxXakcuTDz/K/InzZI4sIKeyNNuCeuSiXBMd637Fw9QYUuNZ/XsQxII40CAU0lK4cX++3+402NhcJmknufLmZX7mf/2Hw2v6NR2NrwtW9Ne+59v54NOnsHde5+5emfjUcR6ZLhJnPYh9VKBQwiWTsNjfW6NVuQGJBVITkxSmsiTMgG77Hu3AIlCnyZRcpg0Ddntc+eLbPFVKkZo2uN3o4uFQjiWJ5g6fvXvAE+87x069yxuXV1GmzZkLZwk0FGayFHoS5diEjiS0JJYQrEYwVYCspTGFQjdb9GotrHKRI0tHmJspYEaSOOyCbiGMgBO+w861V0lOPsDeXhPPMSgnTazNXb70Cz9P4vQ5Hv3oR0hks3+uhPrO+MaGGgQGw5J2qGJarRWkkcCwUkRa4IchQuWYOv84mUym37AOgKAT+8jtL7N3eZPSuxdxJxcw7Vminklj9QUyS3+DIGrTCnbBcJHGFCJ1jFZmlpSw8GOLVqxp9Zq0ai22/FkS2SQCyYZOYkmFaKzR21mmPHGa3bZPRUZMuQaZpEXCTTDhWqy2Ql7dPuBc1GAhkyD32BInpoq8evkyomXz4t1dLgaXKOkzdM1j7BsS25Q4pkAOJuGh0/DO+OaOIf565BjF/Rcn0kBHGiKBsC2U3xcwEjru26RlQ8fHMF30ZAIZ+dBMoVMJguASUauHcbeOePgIYkuhu210XEe+Ow2XWsRqE9oa0a0ialuQclGpPMFVjfPUo8SVLu2VdZrtOk6jzdRHlpilzd5rZ4nUPumzeeY/8m6kt8+3zS1SvbLM2uYur197hfjWNZx0lofe826Kk2WCOALDQhs2QaAIOz7C8lDYmAKQmiBSyHYAnRpon6TSFFybetBmY+tQ5+C/+Ym/y5lZQXvlDTbrOThzksemCgT5BLLbIooNpOHgWnBQ2aBZeRuz8CC56RK5YopguzGY701i8Ri5WYs5T7C9vs/t59d4pJAgNWvyu2/e5MHpo8xLRada4bVKl0efOc1qpckrX7nD3InjTCzMEBuSwlSWYlfiuxaBI/vML1pQVTBVhKyhkSqisbzO2vo9Kt0O3/63vwvRa7G9vMWp73iWdFrjxyEnKx12rr6MMz3Lyq1NTpxapKhCGjeXkfs9Zr0Mr+yu0Gi1CeKBGJhgRBHJCIIzXt0ThxCM/n/7QMhhU6g+dPT6pmgcQm+4H/sPI38QPfbZMOQgCzzY51hjsZQGlmmh4hgkI+pSpfVI72C8GhAPHa4xp0sKOYZS0gMGmsOK7iGX/WHD9DCYkGPz1jDoGEKboihCCIGXSPBz/+znePjiw33FXa0JVUC7vYxlZDBNj14UEwUxmGWmzhXJJLOEWmEKSQgE3Sp6+0Uql7aY+vBpzPxRpJyle7BHr75OZvEj+EGLXrCBYU8hrFm0XaSbO0VS2PQii3oYI/0WOw3YjyZJZJJIDXdVGmlk6W6tYBOTLRxhp+2zI2KOJAwKrkdq0WK2kGazHfDKZo1HdI0Hix4TH3qMG8dnuH7rNrLb4Us3NnjCf5mEeJgGE5h5SckA1xQcmZnGNAyuXLnCzZs3cV0H0xjJZI+0MaSQKPpB3QjKNrQtYQwxX8Oa++HnEcyoLxI2hjy7bwztSowXpAbxbV8bQY8qT18LSXTYizAMANSYfR9C6YbHP0yochgQDKBqw+X3NTQPfvNQ22BYHbj/uevvb0iXKgdK4L0gIIxikl6Sn/2ln2V2YR4/jFEROJaFFhFhM8B0bEyhwTYR2sULNXbBwnjm3ZjKx+gIxNYetO8QdmLMW3XE08fh1Ra6vgkFEx5PwFttdLiK7iYQ3bfAa6OTHiqZpfNWjPfBZwlvbFOPlgm6LdwooPzRJeb8OrvtC5id2zS8HuF0mofe8wgzzxbYffUGdzbXWH5lD3EpTbo8wdknHmViehI/8JEJj0hLgiAm7kaQ9Yjp/x4lFHEUI3s+uldHa5+UhkLSpV2vUat8k3oOZiY8ClaLg5UNZKvGsfd8B40DQbi3TbHkkZ9Ko7VE1ttcfe0yPSfN0rEjzM2WsISg1ok4vVTk8rVdNtf38I56TE4mcVyXlXtFXrt1j8Jmg0hqSmaKnpTsxXt0Z+fRaZPLN1ZYOVBMz2fJZBIElRbCy5LM20RhP3JU9Bvbyq4ibygcQlp3b6C6+yhTs7O1StlL42RSuFPTCLNEd2efxvIm0w8vkXQ93EyW8mLA/8vem8ZYkl13fr97Y494a76Xe1ZmZdbSXVVdVd3sJpukukmKGmkkwaORgZGNkQ35i2cGMOANMgx7AAPUBwM2hPlij/3BHnsAaywJmtFI5Aw3URI5TbK72ftee1Xu+9u3WO/1h7dltTwgJREwYPQBspZ8ETfiRdy48T/n/M//mKbAFRlxsEf6jR/wYa3LwsYGq1eexC8Wp9w7MZWY+8T+8qbUMHKGGDYRSnVCb3AP0yyhpIMW1qTjIoZNLufQUymmhL6CVpTRaTdJHnzI2lNX8eaXsfyLoD1SjuiRo+Sskakdjk+6+LkCuZxHr79L7Di4hSKt7j7RIMLQJpkWmELQC48oeSm+s0SQm0HJhG42oOAK3LRDM8rTNn0wDFzDoFopYOYyjg1BqxeD2SWXD7i0sUQ/7NI9fMj9R02OWtvoTQMntWjFqzjnLGbdoWzgOA2vlSZVCsf5iR7NT+wntbMR00xAyrCEBTnlv0oD0mFDKKHFUFNZmWAbCENAGEGskZbEXAjQD+sgc9AToDJw0yFYWzWgECC2l9Gb76OjLRANCD3kwjzW568gz1eQfRBHJ6CbeNefRPo2WfeImZuLmDMXcFcKOHNFktoJCxfWKRUL5BsD6t1hkW88kBzvbtM7vocdlHBnl7CKJUyRoFyPsKsRwRBAZmGKCjOUqdk+7pCZEVbWo1SwKMxXaZ82JtdnfSWHMzikfRjimOvMXv8yzaYk3t9mZbWC7bkQK8LTBrfefp/QrXDjygZz5TxZpki04NJ6iQ/unLL58Ii1cwusLluoLOC9vRxv3N1hZqdJ/aRJ48iibUXUrIhoeQWdM3njvfschB4bxSKubZG0YsScQ1BxMKIhiFZopFAUzZSyI7BUxPGPvocSHbLOKfFeGyNO0Z7D/BMbZEFA+7hDr9GnYxtc//Kvom2PmaUGS+fmCbSi5rzP4ut3aAxSFjJJL8mQgGXKkYQpRMmU8vEY3/ssDeIsq2i44Yi2oybAZgRxJo7D2AuYfC4mW4yA32gwIUFnw74Co7HFqMZg7F3okUMAw+ukYZK1mJZRT7/D2FEQUowKPqfOzJC7Pv5CehLxHTsAY2CntELq0XmIoerS+DVpGAa24/Df/sP/hmeffRbf98mUIlE9BtEuhllESxctjGFkF4mwbALXpp2l2FJSSwTtQUS/fozafcC5m0/hVs5j2VeGVBwahKJIwVkly7bZ32+wsHQFSAnTQ5Tt4eaL1Ns7JIMY2/DQAiSKMDqi7Cd4zga56gJ91YewTc5SOEmLepSn5XgEUuC5Dp5j4+RSTg3BYXPArJUyWyrChVUEKb2Tbe72Gxyc3qd0L0c7gs7qHGLBZMZU+J7HK6+8AsCNGzdwXY9333ln2ERPjLtmjyk7H+uGfOaPcXZmDIzP4nc9epcIxITSM65BYTLyY6NOaEPTOhOmlLYzjuhkLz1tmPf4SNMRh3N3eqxptgLEeP+RE/EYUw1NpqbF0eMxh06TOHshJjURk8J+RjQ9NXQWnnzyKjYekYqGc9w0yDKNtCxEosGUCAWGMhDSRfqSwPHoPXiEHIyyHEKhkwHazENLg0zQdoLOCcSaRJR9uHMO9t+GZA9EBHYRoziPeOEaYrmAsbaOqO8gdRf3yYsI1yKpbzP3xYuEeolSIcWaM3BMj8r58+RzPl49ot2PCUNNmkiOtjfpH9/Fzlfxl9cRlomBQpsuvWaKWbLQaUo6SNGZYpClHB11UGaElXZZnivSti2CwOHH2U+EQAbNGkdHgnbrhPmyC3GDWlrC6IfYZkC+4JFGCQdbJ2zvbrL22V9kfWOZhaJP2Is4qvd46sp5tjYbtOundKoVgsBnpmKzem2FD/vH9E5OqWroWSl1x2az4LN2cZWPdo/58N4eycwiVqlAEvYws4R+rU80YyKlgSOZTOhAKeLOMfXjPfbeeR3f7DO3MkMyyBM1GqT9BaJaHysoEZ8mRHdi1KKgtH6VNNGUigJpMEzJOEWWbIfXt/f48OVXSOKIlcuXKS8s/iSX7RP7t5gecSDPpipTFROnDVQW4vhlojEPFj2SnrQZaM0gSwmEpNlJ2T5p02jsU5YWMzc/h2sWMeQi/VaN5kkbOfMMWgQMkj7dvkGWhmTZMbFOsSnS7nmkWYTSijTNiOKMotXndHCK62Z48Rr5Qh7HXcKUgiTrMmOZJGlMErv0pEAJg8CSVHMuOcNk76hJoiLSJCbnOFxeO0dNdtk56dDTCfXGAW5k4AiXXWsOOWtScQW2cSb9ejZ1+4n99Gx8WRXoePh/bTAE/oAwDcg0ZHLoFJANBaRVCoM+upMgtMIoO6A30IcthGGiD/sQAOcDSBaG+qGzDvKFS6i5GuzVEd0EXSkjb5xHvnAVkQnMLti1ZezsGGt5kXTniKy5T/DEMtZKBXM2h0aT9SVZ/RhvcYXV9RLLGERRRLeV8OiDWwy6PUIZ0G12sRW4gYdwXcLjBGFrhM4wtMKxBJkjaQkbmwTVi/FtcHyJbU2hQvfkgG73BB1nVItldNyklpawegM8z8HPu/SbHWr1I3b2tll/8W/zxMVFfKDeGtCPMq4+scrOVpP68QHVSpnZGYu5xYC5Jxe5H9bp7h9SST06Tc2hB62FHGvn5vlg64gP7uxibTwBpkkWDsj6MScP+ixeWAEh8Bn6bVmaoPstuvToHm5x5wd/xuqFPHnLI7YSmh+8RV+U2Ph0ns6gi94Oibsx6lxA9Rc+zd7WIYuXVsiXC9iWQaGbsuD6vHbaZ0E4DByPKE5oZ+oMeBlGSoViCJbPgC0e+9cZIH4mOj/pRzDeV4/3eBywPyZnfPbTEbgajzUu/h2CfDUBWmP1G0ZRfcM0ps+AmALKYYHqcKcxPUNKMW2OxRS0qTOUkeG4U8nSyff72OMmhSCfz/PFL32R3/iN30BKY+gYZH2SrIFWEZZXZqDS6bkZEmGZDLSmn6YUbYPjWshBrUbUOaVi+1Ru3sAxS0i5SvP4A7p9E1G6hhYeg6RLt2fRarSQVkQmBbYu0pY2mYpQWjCIEshCAqNLvV/DdVL8pEelXCWQa/RbNdKsR8mU+NGAfuyhhURJA9+UzOVdiqbF5kGDMInI2TEzgcPl1RVq5oBHB03aRoY+eICVSEIlMZkhLQrKZkK71WF9fR3XcTncP5xEzMfgV51xzB6TJFXTyPz45pwFz+P589h9UHoy9l/IeJ29d2eyVx+n7SCmGGs8/thJnDjIZ0wIplk2cXZ2Pz7+0LlhlA0Zn+FZ5/TxLIEQTK7J+EuPCFij76qGXZMRw34qhjlpH2HJobb9uDeH9ARikCKUGv5IibYNVBIjOn10K0FJA1Hyob+EqB+CMNBbbSjBYNYhCQwcO8K/GCC+cAXu7yL26qBtWJhD3FzHfOEKRBprYwHrdAkRdzCrM8Rbh0T798lfK2NU5siVPCxHQ69FfLyHubTCxYtzpFoThQntRp/t2/fp9zr0jBKdkzpO3sP2fLRtM2jEmH6GTBIsrTEtgTJNWtLCETGqE2KULFypsMwfH9A2vvKVr/xbP/yt3/qtrwBcuXQB5eXpmwaXF23eevU+G88+zeWL56hWy3iOjVQpL7/5Lse1Iz77hS9zeXUGR2a0Wh2O611K5QLH24eUKwIlPJLUxXEs1jdMssUl8jJgznHpByXq1Xn8jRWEmfDd77xDM86Yf3KF2bKD02uTL5q09mskR0M9a0Mkw2iZUrQHiu7mO7z27a/zxke3SXo91koFzn3maYxBRBw7HH3jVaKHLeyBQ1GWEMcCcyNH3BkujNIUCNNAaI1/9xEvP9zjdHeLzvERjueydOnyZKZ+QjH6y9n4IY6ziGFjIU2SpURJlyTeJ8hdIxWCIXYz0JhoaeJZku2ohwXEYcjRVp3d+we0+8d8+nNXqHoXMIxlNDYne3vsPzpg+ebfwhawvf9tktSk296l099FFJfIeYvc2d+hVFrCyC/SizJaJ3t4us1JV3HUCukLn2KQZz5foOAG7PZ65LxZKlkfrQSxdEhMhwyNY1pg2pRyPqY0UFmGoWPKM3lM7bN7cIifKyHSAbpzTBDDaTJH6prkjWEkW6shdcC2zcki+In99E2HCjJg/KwzBmJiKEgfa3QqkI4NpoRWE93oQGoifR9RziP1DKIhEHqoay7WA+SNOeTFJUTRhrZGPJNDXruICGwEIeK5G4gvfAYce3isLCQLm8StLmE/Q9e2sWSDtNcgThooF6ziMmmYke19iKxeQAkblMSyfZy8S3G5gL98kZ43y0mnQ7PTwSgsog0DFUMIGCgCzyBXGtZKqcCn5AgIJYN2jWZtl+OTQ77xZy8B8NzN65wqAy9vUXEzbr23w4VPP8OVS2vkCzlyjk2z2eStD27TaDd44ed+gUvLObJwQK3ZoTOIyAc+p3tHVOYEUVZEKZtC3mB5zUMsLxKIgEXH5rgwS3dpAWuxSpaFfO+779FRsPHcZfI6ws5CMiLefvl9ylme1EqwRYTUGc12l9v3t+ncf43Xv/7HvL29T1mllMsBzkKRtHHK6cMY+909xK6gkBRYKqywvngZaz3PnTe2sH2LoJjDch3MKMbaOeTVhweYOmOl4FMbDDjpDkhSRZJmZEpPuhWPOeGPqQmNormM/1LTuoQpAJLTbca87jOUijG/fwqCpnUNfOxY423HXPCx/OVZoCgNA9OYxgEnPQoYgSemoE/KIbddjGRWp07AGaCmh8c1jWH3hrM1F2PYKEc1CI7jcH7jPP/4f/3HOI5HlmVESUycnKJVD9+/TArECNAGSpijJpCwH/WxBYT9ATu3jjnY3UOYETeeeYKKt4GUyygt2PzoQwaxz+yFFzDJ2Nr9BpnO0zx5j1AkGLkFbKvMvYNdZitriNwijVqDuHOMoXrUuhkHrZC+yLNUKlIN8hiGzUmUELgVSoMGSjrEpksqDbQQWIaJNh0qeR+tBDpNsExNIR9gCY/N3T2KM/Mk7UPMXhsZCk6iGRLHRHcaXN64jOd6vPPO23z1j/8lJ6enJElCmiZDKphWQ+eAaVbocTA+nApqHF0f38PxPRdT503KaW+DCUcfJtsyng1ngPgUnJ+Zv/A4BWjUK2GYdZWTuTr+fDwJx71mODPvxqB+PHfG40+PP81IjDNjE3UlPT7f6ZyfrO1KI0bfwxASz/X4+S/9PIV8Ecu1MMxhcb2UBlJKDFtCyJCmZVsIAdlpDXVcxzIKiJkcZmkG253D6BqILB7WQNwsUvMNGo6BLDt4ysX4mRLyySuIpA3VPOK564jnbw4DTEhE2iVuN4i7IVEnQp1sorubpL0m2g0Z6Ix+YmJLm+jBa5yoGaS0sUwP2/VwCy7llRLu0mUaRomDw136mUR7M2ghyWJNTytsnZEv2Tg5E6REBD4lW5L1odPYpdU45sGjh7zyxjsAfOUrX/kt/l/sJ8ocaKfC+Wf/JsIw+N3//r/j2fVVnj0XMDAc+gOFiiGOFW++d0DvqM/anEfON+k1+xhGzJOXq3zntTbXP/80D956nYLU+D4MWmsUci6rgcJ88RzH2asZKgAAIABJREFUhwElqVgLHOgrfv//+JcUPnWFU0fSbdVAtfErNu+fxCzOHfGnf/xVjFRjezalyiwbF67y/ItPQvEyP9x5H91u0DNyHBpLzFtriKCPe/dDqlkbYyfF2U2xvEXQPbKVAkZmk52zYNEcNmfzAor/9X/Flbf/M1rREVb9FNWoP+ZVf2J/eRunPFMy4jgmSROENPFyT6GRZGQINLFW6NHiuBt2ydOkaFR485W3eXuzxiBX5MXPXmfWCxBiCLi6g12ifA3vahlP2ESqw/7WMX3RZ33ewFB93nnzj/jsF36TMFhgkBnQ7+P6YCz4PPrRA+bLZRbcJY7bPe4eNoiMgKfLFhsL59jrNPDLOfKtFnE3RCmfYi4jCktIO48yLJRTQuCg0y79JKS4UOVzz11ld/+QviGIdcT9vX0qlZTOVsLDlqZgwkxRUl0wEc7jkZ9P7KdrRsEkbaXoeBQttRk6ZyOqkbAMhGGAVoheApmJWF6CzIAEdKQQMkV/tELWbyGyPvIggIqBfC6HOlUIR8CDFLwM8cQceuNpyC+h9oE0RrsZ6nCTdH+Xbl2xe+8Wy4shq79cxioqsBaI40V6Hx2TBXXmXvg7JKni8IMd0n5IYbkMJRezUMXOwZqdMD+/QT81CNspHJ3iLxSIBppi0UFYkv3TkIdvHvHsjTIPDiKW1+YoFRdQSYPsnR9NL5C3wNO/+EvsvvEq3/rd3+fpS5d47nyediLp9TIMJI1myDsfHpI1e1xazmFbknrYo1yUmLkyP/qww80XnuHWyz/gxk0b0ddE9hx522Y1r7F+7jzbmy6rOZOrlsPRowO+/bU/xX/mCQaeQfPRI56Yteg7BttxiH9hhz/41z+gGPjYnsXC0jql2RkSccwH9fc5PV+CTodHTc3d799h0Gvy/Lkqn1lfRjyM8HodPF3CirqI7hF6ociz/mW+9c3v4/xtG/fSAubqeSr/5X/BU6/+59SjHRxT4CKwpMASYsiF10MAorRmyrI4E8XUAqVHyiwTgD00MaKMjClK4+JKpfUZgD1WahmPe1YXfhpcgdH+aryNHgF2OaKTMHU4JtkCY0htkqOeDSojHSnjTLMAIEd0J8O0hkBoHL3mTOR4FGUeq8/oUYh43CHZMIZOiB8ELC+tYJomURzR6XbIVIrjFvH8ZTSSlAyJZqAUhjBIdEon7JGjS0lW+N63XuLNWsL8+WWuXrhKxfUYPrSaZvcerKT4Th5HmERJl53NQ2JbcXPNYmf/Ix6dnvLE03+XMFignwiSqEtxzqYZQn2vzUKlxIK7yL3dHd4ozPP0kslS4KGNBbabNa4tVijXavQ7Ebay8F1JrPJIJwemg/YqiLBDloWkRkppfpaf+fQ1tnYOSKtLtE4GHOwfY4g2BdumXigStxTvvvUSP3j123x06yMGgz4qy0ZUreH7bzIRBKPi7ynd7KxprYe0Maag/rGMwmT+nBnjsWj/1Ak4C8LHPQ8QZ6hJ4wj9KJUwcVwmHbanNQHSHNabKKWYHmn8MAzpQFKOaZ1DRyfLMgxpfGxOGyNHaJwzmdLbxt9/XPsyLtgXE2dX8pv/8Df5n//Hf8z6xjrCFAhz2PRQZAKUxPCs4YmlCh1pXCcPNxYgFOhEo/oZmR+idpbJBm20bJG9F2Bey1FcdSmaZYRnkH0YoQsp8vnzCDNDm7MkDxOEBqMA2aNbJCcN6vs9au0d5ud7rP7qOkZOgblB68iludvmNNcid/OX+ee//dtcX32ei596ivzqDFlg4VUWMXMm6yJlpnKFbl+TdvuoWgOz5GIkBjOLAaHSPLzXoLHV4vq1Eg93Qy5dPUcht0K3scvt3U1+nP1EmYNczqBxEtJrmXzhl59nY+4uP3r1lMW1dUrlgCSNuL+5y9vf/RrrT3+JL75wg5znkCTQ7KYcHje5uVFip9OledghdT2ko3BpMuiVCHoGhpEwSNpISxMmggf7PS5cDTg4yfj1L6/y4qxg2cnoDbps3n2dv/GzJaxLNkdH9zg82qR+sklYu0uh06S8csDzz/wsX/jZX+Lac88QZRF/9Af/iieefJr8xhWshoHVMjCaKTTbyLgPzQKi6CASibQEoiAni+tCLYd/eZZP/fq/z6Uv/uwociQ+yRz8lU0QRiFaSVpxCoaB4zooIWlrjcmY+2qQIBlohScNPJnnpa99n3dqPby18zx5ZZ1Zu8dCeQFEihIRnfZDBlmGnb9I1Z0nznr83r/5I9bWljBosr33kO3jkMtPrPLU/Ge4v3cH0/WxvQIxkmZ8zN53X2LmiYssOYKTxOQ4gryrWC3nKJs239l3kM4MOc8jsCV5v4St+viWh6FTbFOQYdGNDXwZkfMNcsUitdMTLNemXCjgtPqo3ALLsyaPtvo02j28ABaWvDOdL/8/vk3/vzaNsAXCFcNArgRhjegiUoACWgryFhgutDN0M0Ifn6Jrh+Cb9D/YItWHyGAR4+lF5LUCINBbGkINKkZ4CWImB7kFkm2JLJqoW/sIdYxxYR57/RKuyGPs3EcYx5RfuIB58WcRM1cw8lWcc+fwl9dJ2k2sQoBXLJOojP2tR7R3jqipRSBCWhau42EZDnEqsfIOURzTjTXNB3vsf7DF8aN9rLTB6e0jLl+o0Do6Yne3RahdSksV/sn/9n8CkC8Idh8MCHJVPvuFyyyVHvHKD4+4dPMm+cCk0ely+6OP2Hz/ddZvvMiXv3gDx5D0IzhpDOj3B1xZybPT6VLfbaJLRWyzh0wjol6A3zUQRkyzX6OXhhw2YjqpZvVyjoPjlP/kVzZ43ot5/fvf5vsv/xkq2uHXfmWd5GLM3qMPODx8xMne2/S3XmWut8Ov/Iefx8gM4iymtJgn0ia1w4zwNKElC1zOXcbtupidFNnvIeMI0czDrMfGuXX8pQDhSqQxVD6bPfTYOn6H37t7l73BAMOQKKAXJxNF3LPg+/FY7JS28fi7YZoRGMfuxw7CmKYx7scxjr9qmFAMJ+BtNKYhJcZjkqHTvgRiVF8wjs5OgD/TJmwfN8MwhseXQ1qPaVmjY09jvmIC0KaBscc47OKMAzT6rqZpMTMzwwsvvsh3/vwlrEKZcrmM5/skSDporPF6Lw1CIEXjGRYOAX/+h3/OO6Fi7cZ11pdLzHqKarE6XO8JadQ/IrFnCIINClaRXtzmd777hzxz/Um6rQc82DmgG0s2zi9zde5TfLD5LsXiHMIOGOiYRnOf41dfo/zkJc6ZGbcHLrFWFF3BcjGgYJp8dcuhUp7FtwxyroPv+rhqgGd5iCzGsUzC1CJRAlfG2KaiVK2ws7VJP0txM0VROhjFOWr7W+wfCV55/S7f/+G3uffgbaKoP5xjWUYSx2R6yrUf/wwlbafUnikpZ1wsLycZn0lDstG9mKx4+qw07XCbscTpuNh8DKjHTsHZl9DQQZjS5IZsIzHZTn5se/RUnnQ0+OQYk3odpqpJUowUunic1gYjhTmtJ521x8/KWUqTlBJDGhMnwTCHuCLTGT//C3+D6nIVyzeHa70Uw/U/G637IcOfnA22C7WE9LSP2tuh8egRRw92MA5aDE4eYlYvYP/iOXLXZgnMHByCjAESYqONrlbI0jKdhxGb9x9QrkcgDzGeeQK7uooTg3n4CDhi9hevY13+VTJnAaO6QHDpEoW1J7CylIufe571p57mcH+Hndu36Rx12Q8rtDtHbO4eYJkOmTKJFAjXQKE57SUcvn6Le6/dY//2Q/rHu/S2mjx1dZ7DzW0ebnfwyjO0oz7/6mtfB/6amYNf+3evs37pKvd2XA57Hbbjp3n5/ROu/FJC2ZR0jk758Hs/YqBg/dkbSMtCK0WUDhBGxNpSgXovxI0EF64/QSdM6CqBaQXMOwPknM3Rccy5+RJJllFrRFRcDXNr/PoTPjuvvYZcLRPpDo9at2hfSvjdf/oGv/4fzPPUr0lqDZe9vYzde3V+8PJ3+NMfZPytv3mPxavP4swssfzEIn9n9e9iGyUM2yZzAOGCtiBR6DSFJoiaRAQC3VRkVoq5bKIlzPx7n6LoPovpOo81DvnE/io2jC0EXgAIMnMYJTClQCFwNIgRY3ZYdCiwEaSZ4ne++iq9vVs4a1dIVUa73sB7ahHXkNR1iq9dOqlLjEPZWkJpwe7pA2onbVyjB6pDGHYxhWDQe4n77uepBEX2woiikWPen2U7sDiNQlbaJ2ypc0RZH0u1OW4XMPUBs3bML51fYi8VPAoh6kJUH/D5XJ+y4WKZJoYQ5CwTAptOXCTudPEcm5vXr3P33m0O9nZYebpK1nmLj94TrK9cYP3yMvNL/mj9PBvxmQKRT+yvaWcvoWSYJdCjCJtiSDXSozewyVCJop9Bs406ajI4PiYWGaKcxwlDOq5BV0Z49beYaWny/RxIE3nZQO+k6HBIT+zfV8SHGYWf8Yje3cW4UEBaEjwf4fhw2aP+tQc0dUhlzyA/ozByBhg20jQRvonhr4BQmIagGgTMXFgl6Q34/te/i3v10+hZl12V0okVdpZSr7VQ4QkkfSyd0Itb9Ho9zq/M45ctdh58RKk/YDHnIPMhp3F/cmn+07//WXZq52h2MzZ7KXfCa7zy7iFfQuOZBnsf3uPBWx+SWjbnn70+AR1h0iMfQMnwafQivEjw5PPXqXciGtpCmBYVL0SXTXZ2ehTcDNPOMxCavikwKxv8R9dcHnzr+2w8u4676jM3V0SVHf6X/+kb/IO/V+Dn/kHA3onJ5oM+R3f6PHxwxKP/4Y/5pS+vsPjFK7j5BVoteLf6iK/9zjdZO+7wwo0FPHsVEduQaOiLyXpv5UySw4xMgJwXKAl7N2x+/59t0owThBBkWpNkahTxV9NnccjlGAGpqdTnhDxxBrhMnIIRgBr3FpgCmyltaBwBngDx0f4TbvXouELrYY2BGEpIjhUJdTbuXTCigIyjxRP1oeEaO4zMGmfOb3jcLM2GlM+RqtEwkjs6T2OokjPusjuWNB1HefWIYjKmn8RxxNbWFv/ot/8RcZrymRc+T+B6GGJ4XGeUkVBoMsAQEomg0e7z1T95m/7hHYIrz9NpNgnzJdzSLLaUNHRGDp9GamM7c9hWlThL2T99ROOkS8HrcVrrkCU9hDyg03+VjvNpFgsz3O+0uFReJufPoFyDWhRxrnXCg/4iHk0S12PHscmSfYrGgF+7vM7dKOVkIInqGkcNeCbXo2i42KZBhkXBlXSlRysWyEGLYiHPZ559ltfe/BGGazHjSNrH3+dBU6D797j17sscHN2n2+uQxAOkAMc0kJ7LIApJsww1kh4dU8Ue4/ozfTmIMe1LqSlIZ5jVMU2TJE0m9+PjkrRSyFH932hKK0U2IZSNHIgxUH/shTT9fGyTmpTxZiN+/2SLyXMz4RtN9p0+OY/LA4/n5HTx1hOHZKrUJUdZjDFyGD4rWZbR6XZJkgQv8DAti6HYxOgZGpW5oABfgCXRvRQaLaKHB7QebdImQTkuVs6lYUYc9g5Z3n6J5aiM1fPBNpFPWKjdlPZuh/xNn95rGpETeBse8y2H7XadteIMhukiVwTpUsZp+wGNXovcOy3ydgNplUA6CEOSmAJRqjDvWKBNri18id1Hm7z3yps0v/mHXPrcz1FeXuGjfUmt0SRs90jCAVZaI2nX2bl9F88wmasWma8U6MV93nnpkDVDYJc8mOnRbZzy4+wncg6KJZ/1S2AVOwyOBduHNhvPXCF1JI1ej/3TBltHNRzLYq1iYOuMdj8hQ5IL8mg0+3v7nF8pc2t3l4KRkLM9DCHpWCn2SZ0Z38ZxDDr1Lr1uC98TLC3OEXcybt/bJi3azF1YomRmvP1nf0hVmtw7rjHrDcj7fTbWNX41T7ha4Yd//DYvv/GQpYbL/Pk+C+fWWV66iFYWg3oDZToI38IIbNAJxF0It6BdgI6B1hIdSlRBIPICaRuYgQ+GZKxV9wnx469mgiH+kkKSZOmoPfxQljAD4lGDIVNoMgGDTLNf7/G9b3zI/vHLzJ0rM1OWSDPG92wqfp6Olmgc4vQEQyoCo0Bg5+nrjHb0kNniACWOsYMBTl6w/3DA3XsHPFet0QlK6MMHRDqhX13HLF5iEP0LRFZjbu4SbkfSi1uc1GDv1OLFVZeCm7FqGcSGTduy2RxovtlKudyKeHIhwzUVhrTJWxZ2pummJhEmwjGZm5vFCNu0ThoseyZX19bJ5VzKBRvPGz6OZzmU45cBfEJj+6nbKB0+bFGqIdHojCGADFN0u4vau0vSiTnoOdhBGbvgIWyDsDOg+OVlWn/+gAMxwIz7BFGILLjDAs+yRJoOOlZYMwqjoNE1jVmqIBcdhPTBMtH9AbrZxMhryBVI8lXiyMSyBNI20TEIRw5roEbNbYQlQDhYrsPTX/o0b795TLzXxChXyFVLlAOBmVnk/QXSsE0h52FZJjpTWFJiZIrG7j5Wv0+WhJBGmINpx8yZao5gKeTkOKN7pDnqu1x8bomejonaCVtHNQ5qbWwpOFeWSJXRGMRYtoNp2fQHIcfHNTbWirz9YJMFW5PFKVlo0vRD3NOYxbKF51bZP2qRJBGlvMvswgxxJ+XdD+5iXZwjf/E67hZsffgWvtHjeKBB9VgoK+xrklzF4aQiuPfyKa+8qfFmBYXFFq2u5MHuMbErcByfyPTI3DyGctBRjCZBDLbQjTJUJHQVaaZQtsYqGKxe3KAjBf0RwFZaE2fZlNc/nUBnptKYCz6KoDN1BhRT8KX0kBM95u2PlYrGfO8xsMvOrAFTm/K4ldbDIsqzjsqYhTLi/istJ9QlxopEI0rJWA51cl5KTfaDM02rRmBywncf/W7cMO3xx2l0fZQmE2rkBGniOKHT7fIf//2/RzGfHzoeDIvKI6XRmcIUkAnoJBn3H5zy+su3OKm9ycJahWoBsiyk6EnyTjBc77VDmB7imBY5u4BtuPTTNp34IQuliDA7pDCTku0pDo+7zDw64OZMjVZuFr39Ln0vALuEzK0wiL4D6oRzK1c5PeqQDE7ZPR5wUDP5/LLDXCHjsivJbI+TCHb6Cd+op1yqD7i+YmGgsQyHgimxlaSrXUJloP0C60tz1A+OGHRazOcNvNwSKIuXXj1AJ11c28QyPKKwR6YUhgTLNIbJSwlZJkiVQilG1J1RhmhUZDy2cZGtOlN/MFY9EqN5My06/ou06LPF5OOkwSgqNQTio4Ld4X7T6L8xcgQnqGiUPBgDekMak//r0eBn5Uofqxf42Jx/rHh/4tSO6h7OZAvG03/iQowcZiEEKktRyiKOI9IkHarQaRAZ6ERDptGxgl5MenxE/96H9I/aPGrkyFVL9FVK1kuh3yd0j7F9zb1OnXy9ibVQwvB8hDCQFUlQKiFjiXeJISU1kgQrSwgvJiu4w2tVb6PaTbQZEinBu+/dYclapbiyTr48g+nY9FREqVLEtAwyDbbhsLh+Htv3aB3W+JOv30Pn8nRKJU5bDXrNUyygXd8iOtqmUd/HsSTtaJ4wm8Po9FifXcSwICcLWHUT0enx4+wncg6EhFJJgRmzPxAUrBaFxVlOH96n47gcHtcITRMvX6BoQ6xS0pGMlBBDColtmSS2wvUNZJwhbRPLMYjDHr6TIxaSQQQCie/bmJbJQt5jNxrQbBzSOPKYX5+lWl0mqoU0cykffKR5/lrATCmlECS4JZNkJibuPkO71qTTbyMPjjGtIudWLBAaw3GQT66j6YKXIhoK3c6DmaE7fUTPhKKLLBpDekGsELYFUowemGka9RP7K9oo3Z2psfoFJFoTKehlCq0yHCE46EY82Dniznt3+ejdj6guNigtPoUchBiOxHd9PNMm1hqJQRr2EMLHsUqY0qCRheydfkCQTyA9HnIaTYhQ7O+2UOkRpn0BFQ/IhMAQMUG+ivYMGs0a588p2r2QLAkpKBdhFrl1NKDbPeDi3CxzgUfJNrCd4WLeH6QchoqyjPEthe1ofJWgTRslTXpoZKGCXQnpHtwn0ZKqr3FyEjVoE3cUWA4HW9usXr5Ap1HDzxcIwwFZllGpzp3pg/DJ/PtrmSGGxaKxGsqaCoac01Ch6iHpaZ24foBu10nzFaz5MobIYdo2hqvJzBRnwaevPYRlUjuqobcfsXTjAjKMwA0gL6EOhisxbNC7KbKUQzgKbVgkxz3inT26W/eJZ0qs3LyElnm2TyR5LZmtmhgmqASkMVwbGb+YpQZpsbCxRvEw5d6H93CzPtUZSbVYoVLI43smWRKQCzxc10EIQRIn6CzFDxzSwYBBq4nOYqKeNbk0SqTMzUYIHZO2EgpWTGlxlq3338ewbE7bLRLLwjUDijaEWUqaaUzTGsoPApZlkNgaPzCQKsOUNqkBab+DHxQJhYEQDr4bIoUgyPvM5Tz2wh4nR9scbd9n7ZlrtBsL3G1GWHnF7bs9qk9pCm6CmzMI8ibVvEMyEOjIoNNu0AtDjluKRjvjiacu0XpY40f1E54LlpgtBbhZMOQRS4VudVANTc1scxo1IBRceHKdb/7pt8nQZGLUDVkpsgnoYgKyh/YXVV7G6i5jG/OwxxmqabMn8TiomdBFHqcj8dj20yjqWc718PMze40cjbHiy1lpzMezGdPPhT4TCT4DIMcAbXx+4zqJoQTzSOZ1dEYTh2e0zzjync/neer6ddRIragfJ3STDGVagMKTkvuNPnfvbnL3vXvsPHhAdbFNeeVT6EYdu1jGdzxswyLVarTetzHMMo4ZoKWgkfQ4qH9EvqhQ4R4YEamp6cYJR/tN9DNHWM4lkn4HlbRxvFnc3AzKFdTrJ1xcNzjYbyGJcWyHUAd8cBjR7+9ydXkZxzHwbYljm2xJQTdM2WolzFoDfFdjSpNAZwjLJZMGDcCZWyGqDTjZ3UZaiurcDNt7u5wPJKpnIpyAIPB4uH2fpfky+6cNVpZn6XZ6nDaaRHGCShSZHjoIUj4uJwojBw7BGKKfLdRVZxrVTWbMJHI/nQdn59WZ5DVnPNdJBms8Y8dTZUzvOUt3mh7nTGH92IEesy+EmBx1nBWbQqwpbUifOcezCl4fL5LWSo8Cj9Ms27i4+5vf+haO5XDh/EXESJ2LVENfkR52GOzvMjjcIWk06CiHtGwjcyV8kaHUgIEbUqsdM+OWsB3No3dvkxUk1UvLiEhgeHmsgovazzAXBAwUqgZWtUgQxGgpGTxqEN6/Q/PRQwaBz+ylC3R1jncfwgU34nxBUbBNzNhGSpPBIEJJsG0LN/BZXl9jZn6eyq0er/35a0TFAq2kS6d9ggp7dPtNRK9Bv3+MEJpB0qbePMJOU9q9JudmK8zLkNO4ycP79//CPPq4/UTOQUqCbaaUc4J2RVGa79JubfPg3jZ+qUjP8PAqRbQcEPcTIpXhmDZSaeJEoVEszs5w0DmlXCrQ7ob0hYXhSNxWH3tmhnYo0VriuQGO4xIqSd4ycQNIB3Xa+wLVXKW8too3v0Tj4D4P72qevhBgmSY5J8aTTTI7ZuFXfpV7t++RtiqopADZqKpepXilAuppnzR3iiq1YU+jjzx0koAKYSAxCybGhge2gH6GKHtnlutPQNlPywQCgyGbI8sUvSihryHVKbVen3e2arz51h2233mb2cWU0so5ksyjt7dJZX6JvFdCIpAMOwzHcYySRbRZJNMZzbTDva1b2AWFpdtEAwi1wikatBs9jlo7VCqraMNBa4Wl2hQ8C2thhlqtw1yvSaIBocljUCn4fHDUoNMdAB7nZhQzeYNLXp413+N+DL1miJmGaGJClRJk4GkNlkEsIHJy6NIiXrXN/sEuaXSfIOpwshNhuC6Z6/PhG2/zmXjA6f425cUlev0uaMX6xSv4uYBCocR0wT/z4v8ks/ATmzSHXUVVmKF7GcKXZPUuuhESH3WIaifE0QlGbh6xtM581SOpRTCIMLMM5WZkcYSYXyZ3PKBzdExmP6RyroLMBGbOQAYOGBrGnXNzEpGTaGKyQUL7/i6tW7fo9x6hy1XOv/g5BjWLetsh7Bl4RUngjKJcMOWAy1FkWhhIQ3L55gb3PnoDmcUU3SVKBQvPtUagzsUw5KSOxfEc0DZeEJDGMWGnRJbGRKfTNHOYdfBMSc7P8Mt90n6bTu0hH37wkJlz86RK4pSLGNmAZJAQZimOZZJmikwlmIZgtlzkqF1jbm6G01oXL5fDUZB1B1hzc9R6AlMKyoUi/STDsk3yloGTg7hzRGPrLlevXaZamsWZWaBT3+HB7ZQXnsphW5qcnVH0MuYCB8su0at73H2rRf24Sb2WkWYeG2trfO/ONl/fuwXLPp9a8VkK5jAHeXScIOIuST3mlrjFZrxP0MwRBA7/+z/9J6RJjEKQMQS+Wg9BR6bUEERLRpztEViZBDpG0Y4xeBqHMvXjwE1MgPtUJWYCws+CLphmBaRAMm7Edna8x5//s9KV4wHGxxidzSRLoCefPz6GOksVGoMvpoBTa42wrGGDPcbgcAhUx3UZ494O4+3v379Pkg37uGA5CD+HzOWQBhz3evzw1hHv/vBNOsePqM5DYWmFKLYZbN5h7eYinpNDDlnqSKWJoghlLoH0iHXCadTg4c4dvBkwkzqdCJSlkY6m2ehw1NyhWtlASR+RDnAJyQcOxmyJ0+M2K4MmqRHhapuCkOQ9m9undfq9CNssslQ2KAYuVwOPDd/jXiI4PWjhi5QsjrBFjKvAUynCydHTgkFQJSu26MtD7m0+IosG3HrrQ1Zcg67voL0c89UKneYB184vk2i4fPEcp7UGoGh3etRbnRGwHtZ8SCFGDevEKFggJ3x8GEfThwXIw19Ncs/D34/ul5j+6jGncdJsjWmGQDyWNRp1z9DizNQeK2Z97F0kGNLdzjioj9HtxntMMhvDcz9b9A7DALVgrFb0MTlVzjjOmkk3cKUVQgmUyviDf/EH5Dwf84uC2XyVZq9J1QhQJwN6m6d0Dx+RJF3suXPI+SWWvBSzKbAlYFq0fIvDXQPOnacy0OzcvoW/4OPmbVRp98tQAAAgAElEQVSi8UoK28uhDYVU5lD1LieRvo3MUtIw5fSN2zRvv06ruUNWrrLwxc/T2be5dzpHM3HpJOBJiecFICAcRCg5XHNsx8QyTZzA57mfv8a/+ervcXwY0RMp3bBJq3aAtBxynkMc91Eqo9vrcHi0j+847NUOaaeXOO35DPptbm1t8ePsJ3IOQj0gZUDec7h8YY4OIS/9X48Ie5LL0qIwX6JSsWmc7nH37i4XLizgmg5JKsiEgWE5eJakVG+DMU+qh2lcGWeY+QJ3GgPWC3mEbyIxIEmxUoFrCNKoRavdwj0VZO0BRb9E8Znnad4/oI/mo0easu9RXLawrSZaK7r6Lc49sULJ/jKmWiHNhguxabogBIZnIa/MoWYLJHe6qKIx1D0PayAaQ/1pw4ckRVicybN9Yj8NGxfx2eYoWqmhn8Uc9/rEpsFBb8Abb77F5p1duq0Os5dnOf+la8wY5/jeP/8jqqLJ8uocy3P+hDsrlCAmJrNtMsshUiHdcJMHD2q8+KUAO1DESYYwNX7JoFdPuHfvNn7xRbzCLGncpdHtUMiVCDbWsTZPOTzeYmnpCtqv8HBvwExywLVlh7aY4bt3O5S2T/nUqslTC4tYbo5LlkVjxiWJTVrtNvV6m/ViFfPeXXKXLjKXc8lJSbHsMXdtkd///vd4t9tF12tE3S7NMKaZarAkP3zpOwQ5F7yAYrVEeabEBx98yMaFyzz/+Z/Bsiwse1oD84mD8Jc3aRngadJaH1nwGbz5iLheYyBA5woUN27gzhYx8haqFuMUMrTVJ9yt0zgKya3OcuPfucLdf71JtRaTizJqb+2ig1lmvD3McAbDsUBYIE1ESYAPWSQYPKyzd+ddjvbvY5U81mdmkNUNCksuN9qak5pi/yClWhKUqgZSDV+UWmiQoLQctmAAAs9ASMXc/AwXLq7gee6E3pKk6YQGAI/PD9OxyTkVtNbUz9CKGuERcZpRKZYw7Crvy5Qf/d93SSOXz86UKeXKNMKYk8Mmd+7s8OST55CGBKVJhYFp2nimplRvgbVCQISMFZZtkRYK3G302SjkIWdCBjpWSAWuAVnYptvrE7b6DE6ayEqR/NVP0f+TBh2hePsOzNxwWKim2Lbm/2HvzWMsy+77vs85d3v37Uvt1VXV3dX7TPdsHG4aDkc0LQkiRVoULcmBk8CQ4SB2EsR/5Y8kMAwngRE7guUISAJbihBDcUAtjEhRG8V9hsOZ6Z6e6Z7prbq6q2vf6+3vrufkj/vue696RImEpCQS5gdUV82bd9dz7rm/5fv9/mxTcOqkQ2tqgu98e4PNuk/Lk3TaPl9feYUgjLjbeUije4g/7vLiyRkKoUD3bOLePrpxxGt3vgozeZ6cvsI7776FJSVBEBBH0QBPPyq7mFZvUv351A1Xg8xniu9J7mdCCk4+GA0GRh06reWQGzBw1kbhGP2ffuZ2oIQ0kq3VSveJqSNOP2LgLCXNrFQ/oSswDDGoggyrCKofBKgBl2QU2pF2TU6rEik8aVg9EIMKhiZR2en1elx94w12dnapN5v4XsBHX/oEL33q0/Q8nxaC7732PVZubRHrgLErJ1l49hxFJvjav/8tTuU7fKD6UWpFB0GSCTY0+AToTI7IMAmiOo3WIx6uHPKxT+QwMjFRJ8B0wcpDc7/LvXu3yH3ok+Srk7Rjhe11yTkW7sI85soea1t3uDD7FI+2NcvbDSbHNM+dzlNXk/z61S0uT0c8O1fkZKUGhs2lbJ79E2XCrsdW/RARa6YsF/HwPuWLF5hxJIaOyM5XqKoTfGP5Lo9ev4nTanHY7RKFirbfoNlqMJ4r0Kh3mJ2aQRiCaq2MbTsc7B3QbC8lIIYoRmuB6MvEDqRE0Qk/YcTpHgQCgyZ2aQA4dOAT1UCVqFuNQowYZuZTgjIMOyAPyO6D4FYNfjOy3WiwK6TE6AcQOq1GkCpxJc/GIDgZPjr9ruTH62l65Hf63ku7Sg+ChvTZ0pogELRbLf7tr/0KK7fv89MvfYqXX3uVz1QuE+/s0bJscnPTVM9fIDdTwSw6eKsNGoUtaHtEWz60FVee+iiZxRorv7HFhdkZjIOA7e+tE+gMBXOLykcWEYaB1cthZh1kSSIcTdBStG9vsvzWtznY3yRXzHDyxAlU7QzK9fncBxbY2pcc7HXxu03mTpcRoSKXydPzfVr1LooI17UplkvoqIsfeuztLNMI23hxSBT56K5GxzVCP0QSo3WiRub7HZpCoqKIW5ZAq4hGq82fZT+QWtHnPvdZLpw/iZQdpNScqLpQPUO9YRIGEWHoIzXYUnFvY5NnLp8l7yaOX6QgFpK1TodKaZoH69sUnZhixsLrgBWZlPIWRyIpn9sGSEvSFZLTZYfbS6/w2nfexY41Z0/OcerMae5uNjncizCKNreWDpmq2pw76WLZEZahcAwTtIElZzGNcWy7iGlYSGkM8G5CCmTexljIY561MGYNnBcnsZ6sEDe38K6+TXwUYZ8/kWyTZv/et78wGzos/Qdfafb26vzRN6+yevUtmuvbZEybyclJvI1DxFSOjaUVlDS5eHaRp88sYAtoxz46ahMCOadIxnToRk1WN1/ju9de40c+UqO31yEQIUYRTEPT2AnJFzrMz32U+mELPEHeHKMjTWgfcO/6EkUbXEdgFvOYtXl2H24zr3uM6UcUpwUHRo43VkzevLFOFEPFMQgMSYjAEiZF6bLfBGeyRuNeDxEaSNvCyDjYmSLPPTnFzbeWmck5ZI2IUPu04oAoiOj0fBodj3r9EN/robUiUopvfu2rfPUrv8P68l3GJiYpV8eGZV8heD84+CFMgDAlRsVFOibOxSnCagG3Oka5NkZm3EV0PUQhg95vErdaRD0PbZtkT81SeGIBWclSPFVCFDRdDLqqyuF6i6O7X2H99gqIGJ0x8cKY9p0twhubrH/nBjt6j7jrYTkF7PNnWfz8Z5GGprUNcSyxMga5kkmmaNBtxsS9GCtrYNgiadomkmaNGrANSb6Qp1qrksk4uNnMgOBqSCNRgiFNYo/UQEfmTKPR4Jf+9b8G4BOfvEy1GGNZioxtMFN2kFNXWHvkUz/cIwpDhFL4XpcHO7u88MHLZCwjWesReAq2PY9KeYbbSyvM1ywIwW8r7NigUsqwL0D7CrRPICVWNsNUFu4svcK3v/4uYxmbZ65cwilVWT8IaDcFsmjz5o09PnJlksmxDI6VkDgzVhbDyHKwE7K23mJ7o8HB9iFbW7u02h3CKCRE8b3l61zduYFckAQlj//6N/85S607fPL0FC/MLtLYbfOLv/G/s3d4SLsP5VP9ikAi8Th0oqGP71ZDRZnhpBpOMZ1+py8vmjpzKZl3IL/Y30im+9fDMUr3o7QachL6GXlEqi7TP15/nONYEUfJ+Vum2VeCGSEWS4llmQMFmmNNr0Q/C9y/FDXSeCsNMlKnUaXnwZBDYRipHGtyVVEc0+t12d7eptFs0Wq3OGw1WdnaZWXzgDtLW6x89yqt7UMyuRwSg8bWAcaUy9a9FZSd4ePPPcXCeBV0TCfy0FGHSEDJqSKloNHZ5OHaNd66fYMXPzrOwcoRFARGFrSK6Rx65PMdFhd/jK2NTXIUMYwSntbQrnP3zftMFCwUPezaJGa2RmvzkHntUYmXEDOa++0Sby0H3F3eR2mDiiPpSkGj55E3HUzlsHngse35iA0Dx8rg5F18BY7j8OFnTnHv9jpTRoRNl06/uhxHEV0vpNELaLeboBRBEBJEEdIwWZiq8czpKXYOW8RKY1kGlmkQxmqYtddJAGoYEsMwMaQcQIWESLkj8hh8Tcdp/+x0WjwW7CqVZN/7y0ZaARqZ3MM/+7+llMcUkpI5NexPkCYq9MhGaSLjmOm0OppC1+Sx/Q0D9REORfosDeZtcr4qTrhDURRy9+ESX/r67/P23Zt8c+kNDLfGEy98iLlnFilOFbCUxqrkUJuH+Hu7+O0uXTR+OUs4U+B7b7/J8z/9QXbXH7G5ozjYtWmvNwk2vsqjN5ZZvXWbZhzTPmjRu71NdGuXB195nd/90q9TNYv4Th7z8iXmf/bTxHGIq6axMi521iBfs7Czkvqeh+7FuFUb2zUxTMnS/ft8+zsvc/r0Kb74G7/BrXceEMQBfuTR9dtEYYCUEARJ4JB2kY7jhEvkBSH1douu56NFwu9sd3rA91cr+oGCg5/9+b/F3GKZRqdJ1HiCpYctzk76TE6fYXuvxd7mHhUR4sqQo9jgYVBlfqJM0VV0vRb1RsDZ8SxH9QPGJyqE0qIbgWlbWGNlzFhQrbg4ro1Q4KI5VXOwJXzhD3+b/a02UzNnOHfxIrOzJRqHy6huCzvr4rcPseyIXN5htjaGEHmEKGLLDBITdITQEmmUh5P0MROmRBZtdBQm7ahrVcz5WYypEoabSWfk971P79uf36QQuI7DeDHLa9/+LkYQUXRtnr98hp964TneuXqNRzc26O3scerpMzz95FnmquP4GEQqRiiBjqFtZPGlQbe3x7eWf5fdB/v8zSfz7LQDIlPhGYrlTkgm0nh7Nvm5KkZs46hkvtky5jCwaW9vk6nm6IRdJJqzk3O0gwXqtkuc8RjH40rO5MmaSz32WG4ecevNLZr7PnthRD3qEncb1IipZjS99Q2at3cI6wpp55B5C+nUGCPHiVKJU6fnee7yeT725Fnmqnmefv45ilJiE2PbCS6319pHODZRrDg82ufmW6/zzvWrNBoNzl64BLxfOfhzmRA4JRfTFAgjRhYclDIIXt/Hv3cDv7EP5SKZS2fJnKyCI+i9c4ivQ5zJMsXT02RLBvuvv0717BwtWWTj9h3qy7do79znzu1bXL9/F1QDpxdiTM1Seu5ppq9cYuPmAdGOT2Y6h2mbRFoQRiBijbQFmaIk8BjRsIcR6C7VWoVSpYTjOO9RJHn8Gv8kqzca/NIv/RIAL/2NS5SnM6wub/PdP7rN8soRTy9oapNX+MbLb9PZ3KYUe5RyJlserKppnjldQ4guzVaH0I85Wc1Qrx8wMzPBkaeJkTj5HHaliAg0tVoWO+MQdX2yhEy4Goni3//Bb9DY9llYvMyVp5+gVBT0Wuv0mgf4UkP3iHzRpFLMUc1XkLKIlCUc6XLu3Ic5d+Ycgae4e2cN308IiAJwHQcVxzSbDe4s3+UPXvsqP/KBZ7i3s8rS7g5vPVrmzQfvsrS1QRTHBGGA0vHQWYYBhnlgfQcmddgHWOr0ViMwzYQUiuhXEIQ8hrlOg7ZBk6r+fkd2MoAUDRJbDKEZaaUhVTcSA8hJshYYxjAhJuUolKmfQdaQCDCNOmLDAEdrko7FfacxlSlFgGkaA6dzOL1G59fwOElFw0h072NFp1lnd+0he48ekpUuQbMDccTGvXfYvHuLXr3FwYM6/v4BT3z8KZ6/cJZitkCg+/0Z/BC0SdMqoFGs1+9ydeVbNDbr/PiVPPcPetg5xU4Us9OLsUNFb1dTPjON0c3iCAtTRGgd0ghNmpubOFWHRqfFdLnKVOkE7WiW9VAgch5nZMgLEyVmCiZ15bF8cMCb31tlf6PNvqXpBV1Mv0uVCDuok2l3qb+9jVZZ3GIB6WbYPQg5N77AbKGIFTa4PFXk2dMznDt9ghMz41QMA0MFCCmwTHAzJqbrEkQRvdDn5PwEZxamMaTJzkEjQeCLkUqCSOaQaZpIwxjMNcuysG0b0zQHVbCk90C/uZiRON9DwrIajF86puk8S8a8f9wRSVTRn/9G/xwS2Fo6gRPJUvRjiQn6863/PMT9qtRgSzncd7KNHFa1GFYO+nWH/tLW5xukAZDWIPo8B6GJVUwYRYRRQGQouk7Icx+8wuSpacyCi/IF/qu7hHfepL62jjy9QOn5S4w/fRKnkOGEV8MzY+RcjdqTMxQLMf7yHSJp0LDHCY62iDdvs3fvHW7fus31t26gOjtM56vslKbxzsyiKjU6KxFu16Z6fgw36xAJE7TEQGJlBKHsEPQktmFgGAbj42OcWTzF7s4Ov/jf/wsebD6g6Xfxwh5R5KPiqF8VjPvPqk44lirhq6TrjOjfvyAM8fwQ+HNKmWbMKaq5H0W5HsoX2PlTLN27gVsa54WPTdE8OOJoc42O52G/vYR6sEF9sUbRLCEA0+rhC4tyrcCdlUPImDhFG0OH+M27mIXTWCImY2i00SNDSFZ1Odx+k/q9Pc6emqeWzyEJicKIamaC2mKR/d0HZHHY323ycN3k6dOL2MYhCIkgh8YkES4P0ToaWcRGJ2n6D+BYyQJpGhiOfXyRft/+ciypnScvMgGObfH3fu7TaJVkoHJZF9d1+Hs//3n+m3/+v2IGAVPlCvlcAUXS/VWFIZ72sPEp4XIYBdxq7XO4csT5eZemkUUVI3qhxOt55A2w5yRsSWxlESqH2MyiTAfp12nHHSpnZtl5uEolE6HdDIftbS4s5HltGXpRlpajOMh71AoOL16c48HyDrEL4mAXdzvArRSwM5o2HYKbS9RmzyMO1/EfbKJbAbUXF7FKJsb4LHeuvcGU4TFpm2QieFJX6WiP2Svn8aILdMMWvmog8IijHIVql712yG5TMH9mkWef/3ByK/+/Hcm/uibSXwJMicyYqChGGxItJZ2tu7RbR5SefAr34mnMspsol/kKc0Yio4CepwiFJjvmcvpTz2LMVqgKi/3rk0T7dVTYpWCscqII7gevIAsz5KerOKUcrVbMtbc22Wus8fmpH6cybuI4gm5XsHSgOV0SuAWB6fSzzwpkrBEZiTGC7ZWPZZtHr+1PnR2PBQxf+u23+M43HIoZgakVW7sbXH2zTpQ7IJCauXOnKNmCO3eXiHsWQW2F/acnKRRNpIiRZoAvJKVqnhv393ErLnbORIctvPYOZmGeSEfIyENFu+Rci6w6Ynf1Jo9eW2Z8YoxSzsSQChGZWBRxTzxBe/cerjJ4uNrj3OwUJ2oTZGwPIQwQLpaVYXa2xuLpI6anl2jU15JGiiqi1WsnGUSl6foerm3zjauv0mm3WQqCPo5bDDvOjmTL07un3nPPjnMG4Di6u5+8wzCMvsxjPzMrQPVdICkSmWaldEI2HakMpByDFMIUx6qflR9+pkeysUYK/xipAkgpQEi0SmUxR5STVKJoo1TU5wkkWVaVXptKnQo5IoQw8qwwbPSW6NArUKBUIqEp+gFRFMXEscKyFCmpVGAS+dDwdliO3qDT6eG16wReGyvjYlkWjsii/YDxcg3DtPtKTzFxFNCKepSNkKoOeRS0ub+/T3enxZkTGQ51FqNS5CBoE4aaQkZgztqobYEVWPRw6GEjo4g4btKMOpTOzLC2vMqJMU39aA3pjLE4u8C1hw6r+y5+yWe5t8ZUcYKPnp7m0co+jzItMgerVAsGubKDcAS9KEQ2WpRPP83R1h3a15bJdWZwLlQpugW6tQzvfPvrnC5MUlKCjLTQpmBP7tG9sEC9OUFoexiOj459eu2AiQ+Os92MWVpr8eDREc12JwnY+muBaZoDxz9tXBZGESpOGthFUTTSSTutNtCfryl34HFi/bAwkDa2Q/SrSCP8g+F++v+kRYK++mkcx/05OAL3SaFofRndNGCRoq/MBIPvpupMUZRcl5DDSkFyHDX4HP0YSfrYyY1wGoQm1oogijjsNIgdgXAMFBCGIc2Vm3R6Tao/8RKZMzPonEmsYnJunkZxnWqhxMGDHooYIxsQXyjx+9+4zj/4J5/l8JUJjG6bbvMAq3HAmWzEqmlSev7jPHN2jKYXsbLU5NU3tgiM2/xHi+NMzdu4lmTtSLDfEIxZMeWKTafVYHurQaVaptWtc/3GNa6//RZre9t0vB5mxkH1n2uAKAoTSJ8QRKOQR5H0RYn64xhEMWFfjexPsx8oOJDSwTLKhCqg0TtA2BayNE03Nmh3OtRbDerNNl7b59TMLFv7e7z8x9/iySunuXBpkXLWRcUKJ+swN+4S+MtYpsTJL9B2S9SFJG8LwvoWjvYoOBC1A964/g4ygtmJSTKmjSEEkR9jCsnYeInDQ0mxUCQOfPYONLtdyXS2lExykQUcBEbSQvrxl+OxyTOC105/RmfV+/aXZqNQh5QANzczCf2XXYrNnT8xS61YoFjIMV+t4ZoOvUhhoPC8CNc1UcLlKOrRiA4RvQ0c30RbWWwjg+Vo2r6i14voKInIuxiugeFtE6ocyi6gTYO4HUOjTbaWR93X1He6ZDNtqottVnYfsFg7Qz2s0WhGWEJSylpstVsUygYtr0f3zn38DYdgcobiyRksYVA0yuyvNcjbCmlEhFstGteaFJ4tYuXy1E6eh51ltnd38Q+7uJYgv9NFj42DKchmwZSCo05AaJgUQs2JjGRmbI7K3Ay2mdD0jjuAo27K+/YDWQqFyDmJo9iNUFHIeqdNYewM1uwJrLECwurzPGKNooeRMXGkSdQJ8HaauCWBOVGmtxkiy1XcWhm3aJI5nGbv1aucvHKevUaGnnCQ2iKXNzl5eoYbv3+LG9eWuHzpFJXpIoWsyVQs6PmK9Q6cKEr6CbCk0VF/4R+sbX9BQ710Z5tCzqZazVMcLxKVi7TyJyhka8yclPR0jH/Yw7GKXJqZZX9tld/5wg4f+/gHmJ6bJO846FjhZDOcmnDxvOvsHnQQVpXqxCnqxJS0T3f/ITVbUxLQOtjn2lvvEHcDTp07Qdax8bselpmhmM0y6xZoNmysTIZm3WenrjnsmUyKAkJAjAvCBAyUFsRx4oTEKoY+eTWFOkdxAjFodFuoWBGGYYLXNwS2aRL3JUslqYpLP0vZ74ycZt9GLW0a9fh7Js3QDvKneugMJQeRx185/aONwjtSR0eO7D/xAY53YE73m56akAKURsh+pljIgRzrQKK0n2E1ZJqVTW5SivXWyUUMnMPBnOtvq1TqyqWchz7MiaEKUpqRjqK0epEIhKm+RGewu47nh4S9NqJfkSDwyNs2gZbM5ApoLeiFEVEY0mh2KRYyBBrqXoNeuAmdXUQ3Js46OGYG0ynSbYZ0fIUnIJO1MF2N0V0j1hamnQdhoLsKo+1RnCqzdfsBhxs+pQmPgAat+gbnxhfY86bY3l1nvJql1YkJu3WKFYNqZOG9fIPDRp3tQgmzmGe8mGcxU2Pn4T7lskQ2faKVDsgC2VN5ooJi8txl2LvP7uYhcbuNQ0jGauOWq0RxjJPL0Yk1R55HpEEEmlMZjSpbeK0MjbZLywuJFCAMTMMgm3Ux+pWZbrdHs9VMgsT+T8o7SeeJELL//xiM1fFgl8GsTd8sadA5wPzrx98x6X6G4578PTK/RUJuTvksPLaHtJHaYI96+F7TWiH0SHDMcMdpxWw0KBjmRfq9GgQIkQSnSmuiOKbRafLV734Lp5jn/PxZ9je22DqoM3HmMoVLp7DHcigUkR8Qd0MsN8LISsamivj1JlJo8pcmuJL5CGHTwMvlqZ2dwtIzqEcrtN9dJjpZo1eooHLjTE4a5PI+Mi7wR199hW986U1+6m99hMJMjlpRAJKwY7EXm6zeu0apUKS306XRPGJvb4+33rpOpBUKTRQGaB2RPvAaje73CVFaDcnrMrl+U0pUP+iP1fH160+yHyg46Bc+0VoQajCFoDYxRX2/ycHuChsrKwSNFraR59lnLnP09eus3FvFyefJj80hO3s0ukc8/7FnmR/LcrR1hAo98pkpctkawVGb4OAQq7dBIZfDxGV9a5uHKx3QULIcstk8juUSR2AZgqprkM+ajM2eZG9bc3DocXutw9jpMUxDoUQGIXIYRhEhCkl26fu9Pb8vFON9x+r/VesvHKZpHv8MyDg2L73wPKVigZmZaUqmDbEmRqNigRIWwjBp9xrUD/fpbW5iSQc/XyMOXKLQJNISX1u0o5C8UUS6PXzPByPCNEAagkhJrG6MyrkUSnl6zRadwxat/W06gebUlE20b9DuKbBtojDDodchb2m6qk2vVae108U4ajMRKiYK4xhZSWu3jVswsawA3egQPazTnbAReYOZSxfYqm/T0RJRKtDc26HbtjADDzPbhpJJ5JoYmCjDZ3Wrx1gGpisWORkSN7eJKkUMM0eson62b4AShkH5Gd6f03+GCYF0zEQRxouQeZOm6TB54Qz2ZBmZ6We7Yo2OI4RhgGlgCRCeRxAeYOQymFLTWLpLI4TC6SlqZ6awmlVuvv4OTxQKxG2N1xMYtmBszOLMk1Nk/3ic+3dWyIWKRRaoLo4zVRCs1DWRgDAHltUv4T8OPeEvbmTrR11CP0RkXGwzR216gp5ysY66FGyb+sEhZiSYnT3FM889xe/99itce2WXyZNnCJSL6jTw4x7Pv/gcp6byrN9boR0F2PkitUKezsER+1t7lPQmjU7IodDsNY94590dbMtkrlzDtB0CXyHDmIJrUyWiUnA4smzCXsz6TsjD7ZDCTAHHkijh0mh0uHd3gzt3HlJvdBLnM06knuIo6mchk+53URT24RV9UqZWoBJIRdzPjkoSx0al8Ji0QqDVIEgYThtBKrY4CDLFSBY/dZaPT7ZhCD8Cz9BCIPTQMRI6DQZGiMMMn+73Om19R7Dv+NHPFj/+mhNCEMcJDMEwEt5Cis+GpFPygIDMSHVkAD953KlMMe5p4yyOTUqlFVIbCRE7iiBOAgXlh0RRBDpGGiaGABF5BO1DnEyWQhyjvRDf8JOu3x2fQimPQnLUa1Df2SQ8OMA0XFQ+R+wlYighml7cpSc1GdNBuj5+p4chFZYpENoAJbEDjS4VKZZzhBs9uod17NIesXBYmLTxd00anRi3UiNSBvuhTyUrMXOaVuOQvY02XTNPoTZJcX4BYz5DfatFeTyDbTUJm230egdRqWLmJPPPPMXKV5aJs1miWNPYa1OwCliGRSbTRMcmQpk4dgYyJqtbHaaympJtcnG2RC6fpzzus7HT4tLlyxTyOXJZF9MwiULF0dERr7/xOhsbmwn3JI4TnkE/2EsldBEjEqMcH6s0CNR65F3Sh8c9vs70H0g5/zYAACAASURBVIljwUAKJxvO2feuTsf4C/25n/IVhopGx6FNA6J+epZSgFJIIY9VMgZb9o+htELH+lhQrLSi6/X43ltXuXDxItVcmWtvv4nZEyw+c4nMWAHDNdBKITX0Wh6FWhkMg0JZYAcBwgpwayU+fGqGw6/d4kgb1ObnKFSm6ToG926scvLiIgEZvMBiPJ9nfNzENFxe/tZdbrx+lwuTFc69dJbcRAHtwuqhJOpAzw/p9LbImDb1+iHrG+vs7++jidFaoaKoD7FSg4tO1o+Re9xfd5TWSMNIEhxCH7/338d+wOCgX7a0LIrlEoYwcYiIZQfZ7qDrLVzDYOLEHIunF7j/2rsYYhKZn+DudsDdL32Do4NlPvbBy0Rxj+Z+RNdv4MUPqOQgerjEvfU9nnuiRsaqsN2SvL3cQvl5fP+ITKyoZfPk7CxRCNmMiyZirlahMD6N8kLWdh9x/Z0Wz86cJp8JiJGYZgUppjCMMfg+fIP37f8/NlpFeNxs2+Lv/tynUXFMLwiJdNLJMQAcy6ERQ0Wa4MPhozqPbm0hqgWKc1XW1/foZlwiu0KcCVDeETlZg8wO3XASV1ZwtI2pFZ40yVoGDT/H2GSVnt/Cb7RZv7nEEx+epW0FmKpFWXsYPYnX0ZRLJQ4OjlChQkmXw9Y+na17dLeOqMxfoTdr4sgp2j0TN+riGm3MYJ/uSg4x6yAmLQLTxJkcZ3p+jM3XA+rRCbKqybgd0w17RBbMTVWIrDqv3u6w2wxomY84q2KKRkA4NYE0XSIVIAal+wSPKpAIYZB0UD2uTPG+/Ukmkj4IrolVzVKYmKD8VAm7aifCBP0XnybELpVRnofymhhWndysj8xkUVGLg3vf4NA9gZwpEEkDH5OuW6V52EXKbNKkOdJoKSnMWJxevMTW+ivcvf4WhhOTGS/juBZxkPCwgp7CdQwMQ6CjVAHnL97iSNPqRmQinTSM7ORYvfMAs7HLicoEtUKB8RPzLCwucmphjgkimuTZi/JsXdtg9eWXUfEBp2aqjI0XOdyGfGmMkpND7u4Qr9zn+utv8uHLBV65vsZeYBFKh/aOj21lKRsmtptDKAnKIGNZ6MYRNdfhULhIbbC+ocm6XWbcAuMVBy0kN28s8+Uvv8nNG484OmoO1ICSLr4xUhpIMXQ2VBwTxXHifIsEWuGHUYKz75fnlU56HKD7fXtgICU6cFBGnSpBH7pAsk3qUKtRJ2y4wYDD0He8Rp2o1ClPIUkpdwE9dJqOk6HTrYcJgXTfaeCRkobTnziO+xCgfrZWCpRK/jYtiyiMBhne9DtKDfsZpPKR6f6Sc9Z9orMYVBLSs0prJum4JCpQEoFCmgamKZFSE3ot1u5f5+SpU+w9eEBeQHViHCOTAS05iAQTlovuHrF5e5u9gw6ZsSns2RIrj3bpZUvEmRpx0EBEATkzj5E9oB1M42TKONpA6ERdyzUlTS/L1Ikx2t0GR+sbaGzOPjNHy/SxwgY17SN8EkneTJa9o0OMOCZQWbb3d5BhnWpXUMiM4TkxrjXFUdskzyGuaEDXprfmIKYc5IxDF5PpCwvYccjuuzYNNUWeFlP5gG2vS6ZgMz6RxTc7vPrOEQeeYsxVnB4vcOHiHE+Ica7e3OAX/pO/z+zkJKZhApI41hzsH/Brv/ZrfOc7L7O6ukav1xvAjdIuyilWf6DEReJxC5nA64QYTtfBrOpvl0LVjpseVNfSWEDo48/G4IkZ2blO51VaAUjnShoc6CGvIOFQMHyeBs/a6FxPjp2euhq5zmM9OPrnGMcx9UadlfVHEGv+8LWv87kzn6P2fBnDNfoxkULFEQhFaXqO9t4+yjtEONsYxYjMxBhTOsvW2tfxxp9B2Ab56hjdqZhucYpL5y+zdpDwCZQSGK6kOp9j8fwT3L++wtU/+CbGmMPclZMoaRF2YwwvYmx8jj/6w99mcmyc+tEh1669SRAEBIGHioORBIAaXpIYVvxSuGH632EUH6v6/Vn2AwcHkLQ2L9g5fD9k7eFDXnv1VZTnc/H8E5w/fwW34nLj//gmZQ8ufOjDTD55kp2Dfb62fUgQZ1Bmjpd/8/f45vW7bBy1KVm3uODU+dK7a1w4M80zz/1Trt9b47U3XqVWnabV62KToTg+T8HNIIMAv93DzZfY2HrIxakLXL35GqGZo1o5Tby9z0Ejh5R54rhHqTCOIcvvKfW+b3+1bHTxkEKQ6z/kXhzS63bJG8kDEimD1uYK+3feobG+x5Mf/gniSoFXfu83+cCLi0yOT6PbXXbbPlZ2js5WQK4yTieSmF6TvPQ51DbjtZDmjsISEFeL+NLA97usrl6jkq1y4eRpHrYV/tEecnMJM6wxNzdNr2Vwz1in16rT29ymIfewGha58Y/jyDZrDQvDLVDNS7yHtynMTiKMDN/58pvMP3+JyNvj7ndf5srFEnQ0q6v77Ph5rI6FbHV44B2gxlt88oUqV69vsLZyi3B/EyeKOHfpI0Rht08W7JMSR5yIoaKI8Vid9317jwmQtom0EjLpyXMLOAU7Qa30TWuddFgXMYYdI/1NdLQCZoTIzhC271FXAeV8xERe4UhoYfKjL71APbSoVUyaDU0c66Qaague/8wCr/7qTfyj+2wvreHmp1n88BxzMwZHhzGWKTGkwLIkwv5LvHzTwLJMevttlr97myW9xuLMNKXaBDlh8+GPfIKLzz5LGPrc/vXXmMHBPLnAR0/leaexzat7bUId8fOf//v8F3/nc3z11iZ+FDJtvUJN7fOt1Tpn5sr81hcfcPHpS1iZHGHskS9V0C0IZQG3F6A7XWQhi2uXoLtHY73JiYk56oFAtxocrbS5V3TRKoPv7/KVr7zGvbtbdDq9pHTex9Um2P1+Z1lUQsAdApETjLNOYTDJx0qDFHroPPX11xl8Z1AnIFVf0SqRXtQj3xuFUxxz4kccd611Ip+t9KCR1bFuzJqBt6Ni1YdQ9B00pRIN+pH9DyEZw+MPsd7D7H8cxRiyn01UQ2hCSgRVscIwDIx+BUErPeAepBhwOSClJsRlrVS/CpCeSJo1Tqo0Caejn8lVCmkYmKaBaQhSTmAcRXTjCKE0WxuP+He/+qtIU/ITn/kMP/nZzzBZyNALPSIrR2PlFju3b0He4dTicwSuw9e/eJNP/syzqNIEzeYqodfAdmbodRWFiXF2OzGFoEEsbNqGZKIS0doFx1B0xsqoZo92Z5+19WuUMwUunTnDH7+7hR2vkQ+PsCtFKrUcjna4Wf82UWMX0YuIuwEuBXLjz5MxGyzvZCiPTWH5m0T7DylNjoHh8Ef/5yt84POf4uFr30XtrrN4qUTciljf2GW9N4YbNvCDgEboIcc8fvJvzvLqa+vs7TUoxz4nx8/woQ+9yKc/t4jtZIiiCCEM4jgmCgMymQz/8B/+I37mc5/nv/zH/5hHKyt4njfgDhyrNImE1zLgEYihbOlo4HAM5z8IngfIpP78H+nYnXihI6vKe53RYSVAHJ+09IMEPZz4qbTugDxP+jg+FiT3A5xhZasvsZoGtgmeCSFEwsvQ0O52+MIXfxOhBdVshcufeBIrZ5KWDoMgwPN6mFmJH3aRdkDWXYHMJiJTBMdAtZZZP9xn8TJMlSwM06JQq/Gpn/kxjvwsZ09bPHoU4vVCwsDALdp8/O+ewl+qEXl3efN3btBpCRY/Mke1rHiwVOdrr36N+3ff5Vt7W7Q7raTLcxQO1gA96EzNCElcQKQG8KzRexqr4Xo4Evl9X/uhggOtNVEYEUchloBTs3OcPHWSyfFpOns+O99eItc4JB9JFqTBeC5Dxq7yoWfmyWUC1r73Cr/76tvcfviIwPdwTMF91SIMPepdnyjWhJ7P4eY2vaMGn/ns3+bOa28yUc1i54pEGjo9hR+FPHfhGTbWbnN+ehzDybG7X+ftazvcvLHGc088yYn5j2I7uT8dTvS+/RW15AVsS5PxbJ5ur033qIXj+rRX7lN/sIb0NCcq8yzJGXYe/hu8yx5zCxm0m+GerkCwSCWs0zQkecvE0Q6dngB/j4NMnvn8NutyAUMXGfP2UJ5Pa6nLxKkuhoipLJToOocEq1vs3fe5MHueqFbF671CzReMYxErzYODQ9pf/DLnX3iRk1MT4Cu8dog7tYB/6x3c2keZcee5/d0NAmed6pzFSn0PvHUiKyZvGBhSoHSM8vbY3zO51VnnxKJNcSzmaK/F16+/zjce7PGf/lf/bX8tNUHYDKTrBphN3g8MflgTguLlMoYjH3t/ieTlETcQtom2E81+YQYIxyW4+Qpfu7fEx4wF5r0MEig4grUow8SYpN32yOQcTNvE92KMjMGJSQPKH6GcrZLJ1OkePKL5oMLUEwUamzG9I4Xr2Elw8Jc4hAJAQ+QrRBiSdXvkI48zJ87z2b/z00zW5vA2urTfeEj+cJ+SLPCjH3+Kf/Yv/gd2tjucmznHzPw4Jz/5Gf7nr1yl5bURaNa1j6HaCGC/5bC936SytkGtUsQwbIJOjycWzhG098icu0BPxRxuN+lJaO23uDg7gYob3N9t0FYB9SOf119f4earb/Hq1Ufs7rTwuj6+H+J5IUEQ9oPkdMwS50EpjdF3ch9/RaoRrXb6ZMhhs6dh1nG0d0BqAwdcD7+rRwZKGmlPkvfec/3YczmUeR797PFtEshPumlKSh5AMgbwiRFISf+aH0eSxLF6rAKSHj/5VgrHGpKdj987mbTwJlKqn52Wg14IgyCtv8+Ea5BsbVpy2MW3r7SSPl8qjKjX66BNpGXyO7/9O7x1/To/8tEP0Wi1+I//w5/i4M5tOmt7jJ1bZLx8ivtBkZ37+0StkJnpIrtWhUZsob2TlPwGB4agkrPwQ0kvaBNELfZsm4X8BstcoRSuUombhC2P1lKL6mwbUYqoXqjgNtdpr+8QrMWMv3ACynnylTIzWzki0cXwI5bX12l+aY+LP/oJzk9Pog5axKKMnfMI793GrX6QueIZvvVbN3ErDYpVxaPWDnQ9YltRNLuIvECGbcJ2g0YAd5t1zj6TpbyhONyKuf/aq8RvL/HMSz/BJ378U3R7Pgd7dRqNJo1Gg17X4+yZs8zPz/NzP/ezfPGL/zf379/H9zyiOErGmmGWPq0sjY79YPzTwE7rY478gMg8GP+UID3sgzGAsWp9nOvy2DMzGsCOOrT68Z/++Rw7d4YQo0FdSo/AkPpljKFCU5o5B3RC5u10BYFhJHDmapXKc1XS4l/ch+RJw8R0QPhHhJZCOA5EEcIKMSyL4NF3+OOtI874YxjawRQxhtQcxFnyus2jlZhcOY9SPu0mlMddTs3lYP7HsddNgv0Ntq/bKBUSFlq01opMGjNs2DmUigl8jzAKE5hkWukRsg8BHETix3gco+M5uLeDSO49X3uP/VDBgRACy0p0V0+dOsWpM4sQxvS2mnTurJPfXadcrhHHZQrFChs3d7nx7gMO9vYZL8H5l16i+Advktts8vwHzvDii1f4V//TvyRo9fjv/sdfpDYxwXdf/TbLD+5TGZvGdFz+9j/4BbQWNI6OMAxJsVxCoXm09hDXtnHsMWrVKRamJJOFMkKFTM9cwrJzSJle3vvO0F8XSxQ4QGIMMyBBzBf+za/wEz82zuKzT3MUOFz7vd/l6PY3ufChX+DLPcHBg03OnXqayclzTI67iIMQe/wyxdw8OlYYcZcSIcqYwu/eJy6Xmdro0CMmHHNReY08jOk8bFC3dolzY/img99rMd5psf+oycmnJzl95ixvP9yg0fSo4rAXBrgqontnnapRxSyXoZRHRB6ODMjYcG7GYO2oxcFhBLKGUIrZ8YixYp7G7hFd7SEzkkJukrI9xkPnDpudiLin2GmGrO7GlNQ+hsggpCAmzfr0scNohDD6L96R0u779qdb31MRthwmQGHwt5ASjALoAMEGiEcIZxq0YuNr95H1iNLCHM7UBKGnCLua4oksRCHZcg5TKWQcoYRB0Esk7GY+XqZxJ48NFAo2vc1l6qULzF3IoIXGcsR7nMS/aJNCEPoB2lRkciZZx2JmfpqGanHv7Xc56K5TPAoZi3vkauOEUQ3LzfCpMz/DteA2hwcrBK0O/86sY8sxXMvG9/cI4x5aKHQccv3WPUwDer0uDctGSPB7Xb735rtMzZ3hP8jZLC/fZXt3k2K5yJPPPAWx4qjpceu16xBHjJWzhKbmnYfrrG/V6fQSNbsoiAijCCnAkIIgjAfOSQpBUJqB05pmuAWJUzOA+gxwziRBhU6y54YUAx3ZJBt5PEM/WtIfDQQGAUr6t05rD8crDKI/BqlTnzg7iVxlrNTIl/UAWy0G5yuTikd6pMecgOM69YnzIw0D9FDFRo4EGIM+BsMIZOBwiT63IZVLVTq5n4ncqdEPQkaJqUmUJkUSWKcwFyFlwgHpn4MUicSlUhoVhBwe7WHaGdqdFl67ib+7y+zEBJ3VDE//5KfZ2PJoba/hPXiD8xc+zRc7sHfnEecWX2KyOkHb20Y0ISqdo+guEHs+FXFETpqY4QRxsIoqlZl/1KDjmKgpl7gkcDqa3qMWR84WYwunad/awehukfd8dlbmuPihPGcvPcnVhxsYPYOSdtBhSEZoeu+uUnUmUFkXgxjD72FEIa4DT8yZvPt6nZZwCHNVLHnI1FRE1XPZ29glMEIyOYuaOUfNyvHAfIfWfge8mIcHHvtNgTZ3Wf3N/wth5rn81NN4gQdSMD0zQ7FQ4Oob1yiWSnz6059m6d4Se7u77AUBUkkU/TFP7TiGqD8HBEql4zecFwNHc3Rypc/IIKBgoLOfficNHgbyp9Lo84FGnNmRqpaQI92REUjD7E9ZPYAZpZWAQZVDD4+VVrVGn5N0zqfwPNX/HQQB2jSTZJpMlItGWT2xivGjANvNgJWnmNXoYAnheMj8AlEQsfXHS+Rih+KlM4hsDq8VEfuK8TNFVEOQr1k4igHPpteNsTIGcz9Z4er/ElP0QtwHKxSkovIjl/j9t7/A/n6Lh6vLtL1Wv3Kn+r1XEmiX6FdStD7+XA94SaPPnhoZc61/kNjghwwOknuLFBLbdUFrOivr+EvbWK0ezvwMsiWQ5RpWsUT95jL7t+4zKeDykx/k7a8us72+hd9psLp0m5fVAZcuXuD6m1f5lX/7vzExM8bm5irlapHp6UlOnJglm8v1F7AqArBsCykEc7NzJOSxGNO0kEKSc7OEoU/GLfQDg9EX6fvO0F8XSxcoAcRBwO2Xv8UHz+WonfwIXvkETm6fGFi6e8jMj5gI7dIOSyiVp2Q6TNkGkW9jmx466GcKZZZYxXTrO5Rmn6C1cZewaOBSRHaPOGi2ydoTyNgj6nQouzlytSmOZi9w8PAVco+WyT9do3yqTGa6ir/fpBQb1JsRBzomjmLau3vYSuBU8pi5MkYpRHUDjFyG02NlrIMjDro7NMI2Rx2DeUeRtQOU36PX1PSUT+Q/wh13mDBNMhdOMnkuz0KrwrlzH0LTQJBDYIzAB2IUAqP/mdb9Lpv68bLv+/b9zMg5/Sws9DERyXJiGAhloqPbYGyDo9FItH+b+7sBVXcc13WT2xwqDCVwc4JuzyQTxgncxQRD6j7pzeDcnMW76zXadYU8bFJq1imUpsicm+kHJGln3r+8sQvDCADbNHFMCz8I2NzbY8qcorjepiJsHEziXB6ZH6OycBK7VsVUS1SFolKsMF09SXFmhi989cuIOMQ1NYZtApqOF1Ep5qjM5sg6NrZtoTEJgohu4LG9u8Hv/t6X8P0OntfFsi2a7QbtTgssTePoCB1HeJ0Wjmmytt2k3QnoeQEqVolCDxLTSBwAQ4ikcdxg+PSgxC5TuJAYfckm3005HaNO/dD67xYxlGhMM/Xfj4DZRw4NHf7HjpE4RWAa5gACMsBbv0fzvb+dANFnLKe1EM0QljQgB5NmgRl8N+mYPHTcR/tjpBn/1NFIISC6D9tITzqOE3LkaECBHumarDRRn5ysGc7bNOjQWmPIpHfBgLcgBFIlTqkk4YbEgY8hoOTYfGB+kosXixQXPkGcmcKwLer1DivLRzzzhInQWY78EhY5JqyApm2hQpNiVqE9lZD5jTKR38HvtZCFk3C4TlDK4ZKl2djCjwKyVgkZe/TqTWoTWbrOGG25j9Hew95eZ8w5ycHFMczXqxSxyQWCrqc41CEqiGlsbuGMTeKUMhi5MlK0UJ0Aq5DlyYkK2/4q9c4BzbjHQcNkPqNwswGR59H0AppRhzhsY+c7TE9qrKfmiasRxloPKfL8jY99EsfNs7u7zcMHK1TKFRzbYHunQ7PV5Jd/+Zf5z/+zf8S5c2e4e/cu+wf7IMAwjZE5NCTnpjh+yZCXkk7ctH/B443QhlWqfrD8/XpJjaxXCQRpVEoz9dPSztv9uarVCIdhWMkYJb+ndmz+Dc5NDeKTZBrrAX8ofZbS9TRWiiAK2dnf41/+63/FP/ln/xTTsmg1mvi+j2FKojjGtl2kuorKtBEig449eq1b3FvrMpWdTfYXKgwMHNPEyVq0dQlHRRgixHAMpNnvXhnHPHXW5p2J0zR7HuXYx2qFhA/2WV59l167i4hCiFUirT3g6DCQfe3H20ncTlLJNA0D1edZ6T7XBIb8J0bWhD/NfqjgYDA4aFS7R7jbQTVCTMNBumDkHTBtMos1wnaMX69jhk1OVLKU509w48YqcTfAUhG9+iFbqz3mTp9k7sQs9269xe5+ATefZfHcGZ595gVKpRKQyKxlMpn+dSWLZCFfBFJsXCJTlXWzxLFCGub7QcFfc0sXAcM0GZ89QbYwTq52Go1ExAG9rsfOxv/D3nsGW5Zd932/vU+8+d6X3+s009PdkxMGOYoABRIqirZISabkKn5RqVyWXeWyPtj+Ypb1ySXKKhflsstBdtEUTVtiMkkVQCIRwGAAEMDknpmezvHld++7+aS9tz+c+N4MAyAApMleA3S/1/fcc/bZ8b/W+q+1JkyDEcJSTOZ1gsilZjmcaDS5eTijs7aIj8S1HLQWHMYRHd/FTEN8u4Hj2swnE5BNWkuPEd26gXBizDQgrsVov4nVWcQ4NsHeTUbBs9QWOqws9WitTVmyfOJbBzSMRrkxcTzFSQLQDZLIxXZaaRaVdp2lk8vM5C6T7SmNeMyOWGDPsViSLpYTI0WMCQPGkz0eXlliOPAYuhGdBxY4/8hjrK01Scw9TNLGsVqZhUQDLkI2MajMDSz4YQLLv2wiAGFbqERVMgQZRG6EEQbYAzMEPcckY6KkydWxodlYwvF8DCLlo7spTUUjsa10VzfCYDkiTaKvDAs1Qb3dIppPiaMpdDy8npNu/laK6n7Yw5daqbNKq8LCtxwe7Kzw1NqT1E2bWq1JvVFH1G1kYxnrXIdkGKPnA3p2RGupR/fhs1ihxMdOq866EtuvYYSLY0ukjOn06rg1jzCSjMYB0yRE2JLpeMCbl8bYFsXJNxyPmc1nWLbEcdK8/Zg0Du5wOEtBv1LkmCNjP6TAXgiMUlnBpVQxVkoVoLtQCky1D8TxTinPPlMClgI8U9Ibcg5+1aJ3xOJ6nPZgckifNjhNQ5gd3hl7o0qvSC3rIuNfg8lAuCVTHnK1zgF5H5DhtwLvZc/PlCZ9LO158SwpKdWOojOy+8mM/pGfw+lVJn/X4/MqV09SLTsFpUql8R4ZHSTnSuffzilHBrC1zTwM2RmP+bsf+1n8zhncKMKohPFwzu7WiGkwxnI0o1mTOLHpepJl12d3ErOwtkrNgGfXmYUKQ0LHS5iFCs9tYWyY9yfY/iroiPnOFl6niZiEqLbG766gevvE+33MeIdpbGitLnJiuUen1sIOob8zom4MsRtCMMEzPYxySLSHbWtUEiM6TdYfXGN25x7zwZQkntOXXXaNZNVyEW6apSuOpsznB5zp+RwOXdTtiPXVk2ycauD5Nc6d7zAcRgwHW6wtWzhuwHh4l739ANeVrK0t8bnPfpaLFy8yGg2LMbEsq+LNoRiL1PCbg29djFr+V56BqDpHiomRrQdZ6NqiYB29Q6HNuPKFtyH3xBZetGqUqCFVEUWlDfknFa9E3u7ypd7Fa3ek+UUbTOZ9iOOY0XjM8y98nZ3tHVZXVzDGMJ/PiZOI3kIH368h1DaCOUYlhOEue9uaS4OEVm0JZForQVoC6UqMFAjbxjWgogRpSywnW6eJYNE3rJ5f53b/NqPRnM3BAdGVMZY0RPGEWEUkSeoJVVqhtCr6UVBZx9l7iHyLqSp3VAyq4vha/uPle1YO0lYI1GhOvDVFWD5ux0dbM6gLTKOOtVTn8PZtGA9YbApWlruIus10fohjLGrSxrYNjmURxlMWeh0O9kYE0zGLKwtceOQRPvCBj+C47lH+W9XtJNIJbttlBHrq4iyn1X0M9JddBI7rcv659zFWc7SQ9K9fYf/ObYIopqYkm3euIW3FbKwIZgbP9ljrLHHzxg2a9R6eUfjCZxwqQhOz2F5ieLBPrVEDHaIl4LVp1Rc5PLiBqDtYQcJskiBssGoestZkc3eTM0GCbTdYW1khDBQ16RAJn/ZkjKoLLE8jHYWRCVHsILwa0tUI18Fa7OLFCzRHHo04IHQSEmMItYVv+1g2GALsuiRxY97aignvBVyIupw+NcExl5jPHBLqtLwulvAxuCAbWNLBKAHCRkofIa0/tWfvSyaVjbj6bymmS2lbRkeYKEBHIcZTRHGPrcji8V4TaTsYk1nDXAGJwJMpR1soQ5oqRyKs1E1sC1hY8ZE0EPMQty6pnWqUfFvxLsD1B/7KqaUw5edDs9XkQ48+x7MPvJ+9/gSvXqPZqyOaNrbfJa4bRi/dxp4fsuBDd7GFf3aZa994i7pdQ5kpjuPg1ATC09giAQk2klrDZxrPGU7HjOcJCAjDOWGgi3cVQjALAjAKbTSe55AW7Eo9LkmksF2nUqApS5GZ9ZrOLIMWacahFMTITDkoraGGHJjkAY3Hp0H1LConRfqzLGgOsnJOGTKroxEz9AAAIABJREFUPxWQnr1TXlsgj3PIAZau1FNIb1TWFMjbmPvx83vl4Dy3kB4//LTWSHF03R/hmedAP31gUb/gaGaTDE5V+6qiBKV59bPgz0pwagrsctUpz/Z0FJiV4DJNqFCAV/L7CpTWTMOIO9OQxcc/gZAO25dfY3RwQKwhiBK2717D8gyTQ0McQ6/TYqE+Y293h3ajh6MS6qLGxEywHJ+258DhAKvmIsIRsZD4zRWUM6N/cBXLlXiRYT4XtHs9rKUl9m7eZO9wj2mkcNw2p0+t4wUxJjBYXp3WbEbSENRcg3CStPgUEun5aFeD52KvLeJP23RmkpoKSZyYWNsEysFxwbLmaW56LaHh8cZdiO/u8uQHV3ny/T3WT/r0R1dwfI9WbUZ7dZnR+JDNwwnzuc2JjbOc3FjjF//ZL3H3zj0m02kxz48qqhXqWjZWulruLxu6amaqfC1kk7yY6/nY5fcq5swxpTufx5VH5Cz6/KLU+5ROzCNz9nj7cy9Wvo4z/1S2BvJaJaVSIauR1IU3TBe1TUwEu3u7fOmLX+CpZ55hdWUVpRWTyZjuQjt9tg4gCoiiKf1RwrXrkjtTydPLHmTpZKXQCM8CBZ4USMtCKytV5HPF21hIo1k943LvDcHgMGIyPORgNMR3PQyGeRIQqSiLFUlTl1bxcF4Es0goYAxJkmQewfzUoKBjFT3+Z9AOvkflIB8+A8LHWfNJDhPUJAHfxTub5h4mSJhs3sQaH7DaqNFeW0BEMTv7CVGSuiD9Wh232WQ022N3d0gSRjRrPt3eOqdOnqXdbhVcxiOTETiqLJhjnx1v6335yypC5LnD04NsFgR89fc+y7e//nVEvU77zAZX/ui7oH0m/QHJdEzNcdHtFbxOH6UnWDWfaK6oOYq6L+gHNToLqyCnzEZ3WV46g459+geXefxDj7O/4+Ae2sRRTN026KbPW8bi4uaQzxjFaG7wT28gaoZ4v8/C0sPMb1wGlrEdB1VXJJ7Ccus4DQVNg7IixqEkaSywcOYU6somar7PdKaxhSCxDYkIifQca73O18aC7cMxLWG4/ObLRPEd/ubfOc10LlCOwWuC4z2CkA+AGYPQCONi2ev3l8X3KdKx04M0y+yilcmC1iz0TKMmoE0L/IcIOIXltfDqoGODigyWnXa9HRq8umQegefYOAK0MlhetolrOHPSpdtoM+obLJ0ga1Z6CB7bB39YkiQJaI0t07ge6fssPPgwam2BjcUTeMLG6TnIdRekzejONrtvvkJbhdDwcGsuTdfnYGihdJoRRxswlsCuacb9AAswkcAKEsIgIgoDkllEFMxTOkB22OUVgcMwSL3CEgQ6s5KngbRxooi1JklUVggpfQ9docwUKf2S1PLm2HYKmIsg4VQTMoBty+LwrFpY8zSciCyjbf5BBshzy2sOaKTUCJPWC8BwJDC35EPnQFgUudqrgZN5G7Q+TpkoPQ25qpAHSOfjllsPLZkpHFqXeeR16qGQ1lE6Rg7ytdLk9IO0ym3GxyZXvnTRbpF7szKgr7XGWFZxfhtMOZ6ydF/I7OeiJoIBLXShDFlSVgJY07N+YXGBD3/0YxgjmExn/L//8pe5eesm9Y0V/KUuV7/zElK0GO3uIKKQprdKp2PwOnOUnlCv+8xGCQs1RWwspqpBe9Fn7/Aavuzz8IUPMtjfYhJv8+BTDxLNenhzHxOH9Oo2Ud1jJzZc3znkM2j2Z4b2E+eIdu7AVNNZWyO8cwNYxnEtQjdB1A225+A0wDRAi5DD2MFZWqend4nvDBDBAbNpVsHWUcRmjrYS9HKDr45g83DIkm248vpFmo1dFrtLqOkUyzU8cMLw9rWXmM4krtPh5IkHeezRdf63f/nb7OxsMxoNiaI4U8IEcRQV89BkcyGbiuWaqFB3RDbZtcmrEcsiq1HOga9asav7ZA7Ryu+VxpZUATaFd6+gvRRKam6ESZX7wp+UKcdVQ0nhPSB9duklkShVrQNQxkfk+FhlQDq9n2IynfIL/+S/4RMf/wR/7+f+Ho88/DCLi4s0Gk0MkmQUEQ8iDkPJjW3FK2/NUKaGtKeQ2OhEYHvZOgyh1hRMA0m97hOHEXGS4HgWjiORWDS9fRJ7ysQ2qCDm+uEm2jkkjFKlIM/slXtzin0ge59qBEFaQ0Rla7X0TuqKt07KSl//CfK9ew6yxnmn2pjEMN2KYapwmgJTk9iWZvrVezRu3iWajpm4dWazBHepy14YchgeYOk5TuQwO4iQcgrxjDCKWXLrPHrhKd7z9AfwXK+iS/5JLyIKkHhf/upImS5QM5tP0FLw6m/9n+y/+QoeCtPqchgZFv0lJv1dTCTZ3t5kNJmw0V7g2bNPcmUWs1bXSO8ATILSNQ6TOrOkjmitIv1lprNNTLxLvXsayznJ27df5onTz+D5ipqlGU6HXD3c5H3rj9C/PqO57jCKp2D7LD70BHu373DquRNYicc0hFbNp9H0UEIzGySIu31q7znJ5v6UEQ7r5x6F2T3qOyPE3h6bh32mKqTVsdl4qM3zfod7n38L74zL3/7ECu996iTOcofh/DZ2V9FxUrA5nQ1Q+i2kXKLd8pDWjyOlwx/HCb0vfwYRArIKxVon6Uarp4y/fYvR0EKeOE+r/RAvvXSH5VaXxccfJbRiZtEIv7uAMBAk4Dlg5bF4ElxPggMmAFsbtJBo7ZCEDp6MaHVqeQN+JN5QrTUqs6rZQjIajfjP/tl/xWOnHufnf/o/4uGnzrN4qkl9sYEtNfoLMaeiMftSEnc6eCfWYGOZzdmcw/keHRd8YSHDCBVOcYxmFia4UcStawPG05BZqIgiTRzFGEMGlFNkkSRJym3HIIWFUgaRAcgkzrjqSheUiPy8EAikAFVYPbP0o4KC86y1zp4jM2t42Q85oE2pXBkfX2Z8eUhTiMJRK5wxGJPl+BdlTAEiBzBZH5vcVmqKNZlb/apBvkqV1YlzWkeSFXSrggJj8lSFEtu2kQaUSs9F25IIxyFJVBmETV5wKuUopwHBmUJRqWuQX58qT9m+m3MXRNlfeWyEkxewFGWmomqmGp1ZbC07S5mZcaIFmVdHp/1n0i8U7XBch3rN5+zZM/ydv/uzzKcTvvWr/yPh1h2kjoiMZhRbtPwe4/1NAjNic2+HM6dWOdXtEZ9qcmMe84G6IaptYwmbaVQnCGoECjpLaxAccji8gbBhae0ZHLfDt198k4UHHqLuz6ibiMF4l93ZIc+tXGD/6pjmqsXB9JDGwgayI5ns7XLy2Q1QPsPAsND1cXwblRhmoxhx94Dah89w9fqA1oklus3z2GpEtDdG7u1y82CPWCSsbdSwVzt81/hsvXwJ/1yNn/+pDU49/CDKV0zDLRqNmKadEEdT1k9GTKcCWyY0mw0uvvp7/Pq/+S1ms4TqNK3aTnUG4vPf87+rsSPaaCyZJrOQJp2PWumMTplfm86DJEkK8J1a69Oq3FXKUK6gpCsu9zqlUbU6V6pLbbP0WOTzPJ/sWWNzpaRKu8vnTPq8itfL5J6o3M5SKir5/XSmNOtE86UvfYl+/4C//bM/w9/6W/8+QiiiYMDgsy9xY69PcvIRRrUHEPacjrXPZHGR25s3ubB4gWbNRxiIE0PdEchQgwLXsTASjDCE8xhbg+u6LCydxh9bDOY73N29iFv3mc7HaJOgC85fZXMSaWwIVJS7TKrF4AqqVd5f2V6G/CHEHKRPTP9SocatC2xPogHLNujthNGl1xkOBsxsC7XawX9knUBqvOAqdS/Gr21Qt31Qe4RqyiMbC7x8eZNarUaj2cTza/dBzH35U0UbRRSFGKPYunyT5795kTfuDbAXuiwtrXDvxm0O7LvEAixibrzxXS6dbHH+J/8+T5wwhLdGRFh0ZIgzH6HjkNZCmzjWHIxHOFJiWstYziqe9Llz5RKffO/HOJxvM7p3lxpdWr6LETUuzrd4xgmIwzEt38cIB+MkeE+uwRhmJoaDQ0Km1HRqNZ4tOLRsi3tbl3jk8XW2+jGvfvdNNjpPco/vsNDx6eLjRYJEKbZuzFh+7wVO/4uf4ecWH2LBdRC8htJfYclVuLYCYmKd4OopJhlhkilC/RR2/TG+3+V+X46KEQKloH/tNre/8lnevL1D98xpHr1whl5tiXB8kfXzF1huCOzwkGReI9E9bCfd0+IIfJneQ2cntgUYD0SY/n7iZIMHzjax3R+9qyfFbxLpOkjfRToOp5bW+fSnf4KnPn6OheUlbN9BGMX8zozJ269yOA+YuB72RgfOLjMnohG8jTQTeq1nce2ARO2SMOOhBYdXb05B1hiNZgwOZ8SxRggLKSWu6xBHUZYTv6QDJMqk4EQbtEyLbZEdjNUMQ/mPhZVSyCwHewkk8pz/SmmMzGk5ujh3jgTsGUDkXgZRBE2WgD3vN1MwFjAGLdMc8tXPq4HCeUaW3DuusyBcy5IF5UZUGAA5lEm/Ywrraw7m8nbFcYKUMlMwsnSMpKlUy/TGeYG4lBuutc7SNpojfWdVALrJ2oipgq9KASZK8FYGqoqszkT6WeoBySkdZBbR9P1UlqYxf57SCo1BGo1f8zl95iQbJ1f49re/zsXnv8ndmze41p8hFts4iWF05Sq+ZaFtCxPPee3rn+OBXoP3PP0RPEcxvLLPxLRYtCaYyRRfxiz26kSJoT8e49s2cfcUvlcjmYccbN3jx973UQ5nm/Rv3GKte46m7zFNbL565zJPyQ8SBXOW2otgDJEL9uIqZiaYmhi5e0BixtRMjOXaxIs2Ddvi1o3X+cSnzvPdF1/l6uaAjv8wO+JVFro+C6pGoGNmw4REKNafPctD/9PP8Q8WL+DboMwfoPVF6nWNLRMgJvQVfkPSa1kcHgS89K2L/JP/9i0GgxBj0jlbBOCKsohfuq5KhTUH11WwTGaJlpZMvUn53D1CZyu9WIbcm1/g+8o6Mke+X6QDFpU00RyVI7RyqhnGSoVZm2qBs6PZlSp3qoDojBZXsQbktRGEkFm60JT29/prr3Pr6nX+7b/+TX7ub/wkja3LfPfmkNBKuNBuYieS7SuXsXurnGrF3Hv5mywvt2j0Ojhu6qVLImjYEhUbbNfCcjRRFLJ1sE3Ta3H6xBJfDv6Ab1z7Gru7d3A9myCcolRcKEbp+j5uEHh3i3iuXJVrVBV9Uuw1P3BaUT7Y2d8CgxAaIQ2WBDNMmP7uNwjGtzF+G7G4jHN6lXpvgXi6z9z2qDVWiWcj5vEhjpsNjoa6Z+O7dmrl4HsNmjw+C+/LXwURQuLYDkni8Lnf+Q3ePhgy8hwsHRHt7mCUTTzvs9J0mVqau5szLl3a4yd+vI9t97iw1uDWyHBgrdBq9qirOdOoj0/AWmsBYxKMFMwDxWA04dyDjzExAbdiw8NnHqXpeLx18xY37m7SrTVpNwxvXg9ZWWrQacWM+nuYSZ1osYUMDuieewDXNiAV1Husy4jh3ZdR9pTh3g695kk++emPcff26zy5+hR6dBd15y2mB/sMBhH9meK8N+Ovrb6PpuNzN7rIdH6LRjzhhBehhYO0wJZZARcpMXaC1juA9Q563n35/sRoQzib8s0XXuDx936UT36yTavbpd5qppZvIYmHczpry/Rv7aNmQ3xrzuJZH6cOyQSkA7YDwgKVAHODtFL7tWUMtidxfCs7A0vr849CfN9Lgxa1IQhDbNvBcW1WTyzhei62J5Boku0Jwe9+l3l8B91cR6wuI9eXkK6Lnu4xwqLePMV4chPPE1hujHQkUtjUPYuaY6WZhEhxQ15oKwyjo9SCnIYisoDJLBOHJv2iMmkQrJ2n1NQpDUFDlrlDFxZLWbHS5+k0RZaTX1hWacnMx7o4Vas9VFpN04/N8Y8KJSHR6sgY5oClpCvpIzcXIrWm5/SfgqZxBFhR/CxTh0j6Dhl9CMoiVoXV1uRtMBUFqnxumY40j10Qx9qaKQVZG/MsL8YcPXsFIs0Ik19XeWbxtBzE5Rfl75n9XvWUiEwLi6OYzXub/FEccO/mdXq2w9U5zJs1PNdCJBqdhFhixkrLYzIzvPnmkGef2eOpJ8b4TotnHljk+tignQ26nRiRTIiTPi4RG50FtI4xwuJwPEfFFg+cPs/EBFyLBB985DnCxOLW3TfY2t9lsdmh2xF8+42Qx871MEGf+WQGskbcrWPN91h8/DEsJhjXw/IadM2c4darGGfK/q0Bj50/y/yBFQ52brB84kn06B5L12eMBkP29wOiyOJBP+HDK+/HsVzeDl5Az7fomTGLzozEVlh2gi0ssAW2EDTakmZHst+fE0WpJ0nkhe6MhoQKzQSkyGJLMsqPUnluzKPgs1Bq81GsfF6leb9jPRTzOldJOUJ5KaZEPrez3wvaXvF5ZvGvflB4AkyhaOTr6Tj1vNRfjqUazuajUWn61HTKWyRxDJaNhUQmCfN+n289/036hwPu9PtM1Jwdp8PK4pDRcMap5hJ7kwMa0RKzOxHhcoh/soZTtwiHGt8HS2qCIEYNY0yY4GmXRs1nsD9ga+s6e4O7BMkUodOAcIMhUUnqtZECKW3iJC7evYwHKuMwqqHc2UImL+CYbSWpQeSHka2oisOlJ8EGqQ1qEnL45TcJ77zKWA2JOl3s5Tb1tTZet5XmZvVcfN/CUSnXTDgWnvSwG13aC4pmrYZrWVTmzJ+9WT8Kf/t9+YsjJgVps9mcr3zly7xxd5vd0ZxAR1hhSDwLaSwtEBxO6DkOnZ4LQtDfvscXvvCH/I1Pf4amU2O9YTgcRkw0zN0ardoSjogQxkGbBLSg4Qm8riGxXfpxyKLtsdiqc/XSDf7wSy8Qx/CZTz7CG69f4c7dkMaz51lY6NBMEtxQYmeBRJ6KEPU6yvfwmOO32rx28waD+SFrGydYdn3cpmBxY43hnV3u7BtWN5bxGzEqnrNzoHjmMKZnNdnRkiBWyCSB2DCOYxgo2ks1pOMjpUopMKKHdJ6mtO3dl39XkZbEbzR46sMfZGVjA8/3sZ00xXIYJgSTiKWVHq3FRaKpwMxsRJCgA51WORYG4gxs2Rl7ItaYEHANbstG+mXl2R/5+2WUIqUVURQROiFBFPBvfvfXubl5k5rvsyE6vIc14tsvcxgNSJZOEDVttK0QSqFth8iAKxMcM0MpEEbi2w6Rsag3WzQdB1dmhB6dcs0FaSaP/OA3hgwglgffEYukKFm3RSrMigW08CjI0mKeIeYC3OTAIne7p7G4lUDcwqyZUxzKBuSBfmUQMoW1v2r1wxRPLkTnHozie2UAcP4+MgtaLqyu2feOZxtKvSMqo0+Zsv2ZUvDOd8lfqVqkjDTFcXaPNIhZlDtHVmk606CKAPCcolHB90eyHOWSX1dkNhLlfKMwXBiO9JQxqcdCKZIoSouwCpvbs4TD0GAcRbw/xG/E1Dst5sMxXUtyermORnH5zTdZXmjz4Q98mLbnc1Ib+v05fVviOQ0aNReHGHAQxoZE0q2D0oLYshnEEWu2R6/T4HNffIGXX3qThl/j0x+4wGuvXOLetRnnzi7SaHZpC5ckId3vMfhJQNRpIm2DZ8XYtse169fpB0POPXQBu9XCrjforq4w2tzj1q7mzLkN/LsRk+GUcJrwzEjRsZpsKoOKE+xYkSSK0SzARCGtRQct04rmIDkYxLz8+jhLmZsFu+ucLpYOumVZhcKpMyUwr7J9PFtRblAS2Roqldo8rWZ1jLO1KHIlMq8iXlH8srmnqwo4ZYG1XBkupmi+oCqT9kjGHZO3OVNqKvcpaEbH5r5AlHS/bF0aY0CV1KQURCsiA2MMdw/2GM1mzOKEIIoIVcLrr11iY3HKmr+GIzUH/Rmxitm9vE2r06PWqeHW6wijUXNDFAdIx+BIiWW7uK5FPA/55V/737ly7U2iZI42CSpOM6lpygDyqvckSVSmLFhUFZ/qNdX+Tr1+Irtnti9KAccylB2X759nIEDYEmmnPopkohnvbrKvBsxbdepnlmk9uEJjrYkQCX7NxxIaW4LJgkdcR2Bjo4SNX6/hyNSFKI5tKvflvry7GOI45rtvvMLWZMpkPiOOQiw0xnfwew1UpFBCUrNtOi0bx4q4+PpVnjx7lbUHn2DRk1ieYBQLQmmhhMPMUrjCINEQSywMtqMZRgZX2Jys1xjfu8Kbr73C21duYjtdHn34Ub792tsMDg7Zulmn03BZXVsgCdOiT1NLMR31kUmCu7hArWmBJbl05RaHwQRlBPMkxOzdY+3Mg9TckL3AorFwCkFE6BzgWQnuMGQSxRxogaua+KximwOiSGEpQxJ2sGUN0EhpMKKTUQMygvv9tfXvJPkG7Po+Dz36aMV6Q5aTW+BYFifOnsDzajTbHWZBwGR/jFuvU1+sYzmgokxBUKkXQdRECsxcsOoS6fz50SrzTDUAERFWYHEw2OfWvVv0R31q0uFxf42V5ceZj7foW2CcmDDu05jHOEri1DzQMTYGYVlYlsKVGktIIk2a8cjzsPKiSEJkBbHsAnDmf1bBcW5oP26vrtJ3ipSzqTsig5rH7iVyjJvSXHK3fZX/n926kNwS/yevoSqwLW+R6hulpTL3jBStKq7NlYzSGlqc/mVDgOP1LkrvQv6MPPPSO6hPhXU3p3aUsRFHg6B1VrQK0mxMJSWhTJla6YtMCSqzKR3ru7yduQKTo8gjfUfZvswjJDKwmiQJsTGIRp29yYAwDCCIESpCSvCbLiZKUI6kYRu6HYfZ6JC33rjCAyvrrJx+lGVfIlzJSAiQNonw0FLjSI1lPIyRuL4m0ZogMXjSZr1ZZ/PKS7z6ykvc2zrgxPoq5x86z3cuXmZwMODetRM8dG6FzmIXFWtMEjORHUYHWwixTqNbx/MtEqW4dPkmg2hOs9FibzrCX1xgYWEZzwnZntssr51l0j9AO0PcSGCP0v1+Pza0dA+HNWQyJIjmyEQzn1hpEBMuYGNw8f2EbrdBFE2JoqTM4mWOj0XFcl+ZF0d56uVVMpu/ueIrzLF5nrmVjq7N8ialjm2OffTO9XQku44pqyiXDSppUgBai2I9FbqmKdf7cUWdyroolAOyEjamXBvGGGYmrYEwmM5Sb6SQWNLm8OAQX9U4cXKVveEBviswrmC0PWLv8h71dpvV8w5SaqKZJp6H+HWHcXDItetX2dvdZTA75PNf/QMOR0OUSjKFIKt8LkoDSUnTI/1cS4Qoi7+9wzhe9cRVui1X9s2f7jj4PpWD6n6ASINTXODhGnvqBN21JZafeIj22ipIxeRgh3q7gY3CJBDE4DuSpmejkUymEwwa17HTEtaFFeI+kLkv7yYV65IQ7I4PU8UgnJDMAowUKKdONJvhSBthEqKZpLVs0VtqMzENvvPCizwre5w4scJi16OtYRopDmYxkbAQrsTOrGSJidGJxvM8TiYQjvZ58YUv8uZbmySiQcPuEJgeq6d7XLl2m2uvXsRPYlZXn6a52EIbizBoMx338aYzmq0lvNYSw63r3Lq7ifIEd27fZmtzk8i2eTjp88ypLrWOQ9w6RTAPMLUdTrcMxob+eESgbVreAnX7UYz2EbqD3wnR2kYlAiEsDDYIH6NvgvUUcD+O5wchR13W6d86C5h1bJuTZ1bZuHAWy7Kpey5zETIaTantz2i0PWTLQkrQMQhtQAqcBRvs75VO+cMRlSkH+cEzD+aEUYjv+1y7dp2249PqzXlFCMYqPRCZbqOFw6kubIgOnuvimBiEQ2j7dL0Y305IEkWMxvIknueRpnlNLXlp3J0pAGbOUzcZSDTGoHQeAClKEAlYohwPLUGqKjDIgXmmgJSPOQqceScoquJfA0c8BPk1VYtdxaGRtsWYjN9byeRSAS2pUvROa2xBhTomOVc4z8pStDVvg6m2IVV4qkHI+XmdOmPy7CWlUpQ20RT8/7SGkCwAWqpv6dIrURj4DRJJnqTSVI18medHFdSUiqKQBYnnY174DvJrjQHS2IggjBjN5oxMzDwOUNEYPY9xPIlRMXEQ4AkLC818EnL+jIdodIlmhpe+9SpP0OHUqVVWV+p0E8MoUAxDReJYNC0HsDBaEccRBqg7Nq0EwsMdvvL532ZzV4Fs4todItlj7UyXixev8sbz36HlPEv3mbP47RZaS+ZBm9H+PdrjAK+7hOW6HNy6xI27W4iGw/VrV5jHUFtqc/7xE1xYbeN3XYLmgwz929SbIzoiRktNfzImSqDubyCtEC0dsBrY9QnBbIAUEq08pOXRark88/QCGxtbjEcxSawxGXUon+95gb2c3pOPny6UtoqSWU6KY56tDPeZQuWuYLacKlgBrZXrqtbu6vwtlYHKtaYEyJCvvxIfFs+RsoJ4y3cSUhSFBwuaHKaotVA8JPd2kMbZ5PE/xqTZjHQ2D7VWuLZDw3axhEAlIYPhNtuDPR5fO4OzKJjO59y5fI95EDOPx5iGIZ4mxLMY25FcvX2F3/3i73Dx8hsMx0OiKEr3XFO2JV9f2qQeVSgpiYWSfqwgXbUviwHJx+TdFIg/RX4gEYoGsOo1TnzqIyy+/1m8ZgPbcQhnMfPxnFpvAeHB8vIqV67fwKDwa3XaS0u0VhZ565UX0XHCE898iFMPXnhXy8N9uS+55EcMpNatw50+4XCGidMUjMJxkJZDNFJ4ruBM2ydUhtksYN31ePrJZ3j+hVf5+i/+9/zDf/QPOX1mg1qjTq/m0an7RMqwH2piYVCWwhI2TdeiYQtmW0P+61/8pwxqLtJaoGV7LAQHqDvXOPns4zi//wJ3r19k3t/G1haf+A8+gt1o0F5oYJ/+VFrORWtmh4d881f/HzxlaBqL4HDGVGlCJEoH9NwVnnAV2KeYX3iYfQcOht9l4/3nmIyGLNhtfLeO8B5EeA/S6v0YgtuY8A2EGSF0C0MTYXlY9gehsjHfX1s/eJGWhTQGq1HjQ3/94yAESRhj1Wr4qz1AYHk2bs1B5EqAqG7kf67NPyK27ZTWpoolOQhCpAmRdsKlSLM7nrHW3WDoJMx3bvNPybD5AAAgAElEQVTxj/44nYUTOO0e2oGG1+ZWuE3DtXGcBkrGTOYjzCRA1h2COsznijBIUAaMkOgkKVR/aeVuc1OkOy9KAogUs2otMkoEpaVZpBxqrRRG5LnAM3BUoUZIkVKIcmivjcGo5B39UXKrqYBoQ/HY/ML82ZQVjVUlreLxg7xqzS1vcXQi5NSerIkZiKoGG2bUgwpgygGBMSk1oaRh5IC7/D3/N11RuvL/29KuxCDwjvcQ5SR5V+BRTXea2XGyf6eyDZnKeJT3SJeHKK6L47TSexhEDLf7RIMZJo4xOsGyGykNdAq2Kzm3UGOSGA5HU548t0qjfZoXX3qTL3/tn/OP/8t/zPJKF8/3WWn5LDYFUaLZjw2RNCSWxpcOTSlwjWKyOeC/+IVfQJ9aR8oeXWnoTPcw23c4/fTTiF/7LFd23kYkM4gFz37qKaxane5SA3nmp7EAlGL36mVe/I3fpmYEXSMZ7I4YRQZrOEOFY2rPLfCcn2CsJ/De9162YoPe2mXlqTPMDvssW21sr0lsP4bVeRSPKcHsLbR8HhkNGAUOWC329gUvfGOIbfn4vsd8HiNUnso2T/r9LnNNlEC7HKjKGEOR0tZkgL0g9FUU5uPQ7Yi3rJgXpeJwXIEogLEo6YLVuVsC/3J+FXOWnFtfUXiK+h95YHauhFcnKkUK5DxuIl+aQhpyZSYH8EmimJgZruMwj0PuDbaJwghjBONE4ooGsVJM354x/dyY2IuQtsV4NmF4eMh0PiUxCmUSoigiylLLSpGmiNVUKo5na9goU6x1y7IKhTrv62rwtZSyUmhOFArfkWX3Tt/OO+QHohwIIbBsC2nX8er1rCECv2UhHIvx2KJT83juY+/n9VdfYqd/SD+OqLfr/OTP/DQ93+G1l7/NwfYuo8GQjVM/iFbdl78KohLFYH9MPJmhwyjdtGSa5MuNZtTQmHmTkyfWOHN6Ddt2ef4Pv0YgfD74+Fl+/Xe/TBIYHn/wFB95/5OsnnsQr25xomGRGNBaEs8jJnt9Xn/jFf67//VXSLRHTbfw6x6ubzDjKV/4/Ff4+Z/4CCu24t5swJ39PnY45X1Pd9j40IcQwkFlFpj9u/d4/nd+hz+6cQNvuU37wWUm4YjJ3h7B/oAb1wZMbu7x1KkG/sFnaZ4+TR2bvYUW37m1x8qZJidbPeYx2HNBzZX0E81q4wKx5aNnb4PlYftnsb1HAcm7nN335YchhRVZYHsOtucU+3ABquRf8MHIQHYuee79JIpwHIdpFDCPQvbmE26ND1hbX0PYLi++8RLbwwHrV9ZwvYC9cR8nCYkSxb4K8GoJdV/TqvvMEcwHM1SoymOqoMKUv+cWa5GB99IoloNYXVj3bEumOc6hAMyQW9urQb0lVrGs9EDOgQRUQXD2/tlDVSXFZ8nMSG9WBbY5uBAi/a6u3CttCZmBsLQAVrPzHVE4qMRNGEjrF6ZegzwgmyPfrHzflIzvnGL0DpiVZ4qpgsK8/46B/sJbUgFfZNZmnWpzlRcsAVaWA7V4amG1rfaJKQvIHX9/A2nRPNtCIgnGMfFkhokSsCRYAksn+NE0rUYfuJw9fZLzD52gv7PPpct7aOnxgUfP8j//yu9ghZq/9r4nefzJR1g4uYpfszjpku73iSQczzjc2uTKay/zv/zab6JEl8aohV9zsL0549EeX/vqN/gPP/MxVkzA9nCft156gbYz57EHaqw+9x7AJhGpIejyiy/z7T/8Ihfv3sVf6tI9t0o03MFs7TMaDxm9ccDB21s8faaJO/4NumfPUbNshr7LS5t9ls90ONPsMZwlWCZGm5ib/QmvvPASpzYE5zc6jMYRv/3Z1/ny87eYTEKazbROlGVJksyrKURaUbwY7soYlUbm4zS0HPCn2p2hjBfIM2TpI9ebYqJImda6SOtmVLxXQnA83Wb2wZFBP6oOZApmJUj+yDw0Je0mnzN57FH+TFG4parz7ujCTOMwdHaZIQ1l0GU6XiGIVVrYTmmdUXYFGsObO1e5tHsdKSw8x8OxPeIkZp7MSHQaSGzyVK5Soo060gZlFEakCRJyxd2yrKLWQRFzlf935H3L9kkpU0+rzu5S8QTJzJv4x2U6qsoPRjmAIuAh/yO3nsi6i+daSFuwvLaYWtTQOI6DZwmi7bt8+K//BG9dfIODe/cY9w+OapP35b4cl2xe7+zu8Lnf/xzBeEacJNi2xHYcXN+lacG6D4+vLmEtNVlYXaOzvEg0i5nu7BKKZeJak/eflBwOJuxdvcivvPQKxq1x+umPce6ET1Kv4SZ77N94m+98623GoUPbatGo+ygzpJFMcJwG94zHizsT/lMStPZItCFKhmxvX+H/+KVf5jPf/kOe/Af/iFA7fP2LX+ObX/kKcTzBa9t0mh3iYIDXsLjwzBo1e5FXvrnLZDfmjVsjLsQRjplQ31jksWfXeOObm3zi32tzFxdjJC2gJQULdRujplhyBbuzjpAuQvpH11GeWP/+0vrhSBXYctTyeTx47y/y/pYH2BpSa2EKtNP4njR3v4WRkljHGGXY3N2i0W5juYLk+pTN25eod10+8OPP8fu/ukmoE+qJYclx2OjUudKfYguLpp/l4IfCSqh0iveKlJeVNlkVYJAe1iXtxrJlCXRID0hV+bxqadc6vZeV5d1/twwnedGgwpoOBWApKC8VU7gQFdBfsZBX3uAdVApIQfVxoFR4HwqLf37f/B1MZomXJYASJVkn7bbccpjXbyi0qoLWk8cOWFKSaIVEFsWkKm6BMkj1mLWxqmRlGhlCyIzKocsPDUX8ApknQWaUljKHexbrkj+fHPAI7Kzy7tLKCovLK4zHQVo9WApc38WTko6tOdVwOL/Uw1ppsXBindZCl/6NA2bbY4yziKo1+fgZi+2tAa987Xm+8YXncdo9TjzyHOdO1AgbdWrzm1x66SKXr2wzCSUdu03LqxElOyyoBnNcdmOLg50p/4lQxLpOomMSfcAbr73I/F/s8WPv/TzP/Mf/OeNRxG/+q/+bG5ffRuspfsul3WwTTPdo9nwePH+KyWDK1dcPGR/EvH59yBM6YianrKwv02p02bw55BMLLa4nDtKxaWmby6+8zsVXvsVHPvQB+gc3+L/+9ee5dmOLW3cHjIcRQjrMZnMevnCeV159izBM0KqMLTmqB2ZjlLFXitS0hSU9U8wrNJzc4l8G8h+V6neBPzkzTqYk53btcs3kCkP6R/6UNKOSqkw5c+Rnma2JqmciVzjz+4m8CJg5qkAcUYxMts7z5xf7gMiAeraXmLRftNbYlg1aADGRirDkDCklcRIWdDul1ZG1LESaZS1/tjHpGOUKmFKqUAQMJvNwlEUCy4EsU7oW3SbFsb1KFOtb6D/9/PkBJT6vKgZFWzEircaGnbp7FpYWePSZJ4kxzEZDJsMJb1y9ifFqfOqn/ia257N8MnMbHLNk3Jf7clzarTZPPP4EKglxpMCrN6n5Dk3XpudYrDZsDkWdBxZWWF/pEUxidjbHeHaN9fUWrgWDmWGl49Crtdk9hNlQcuNbX+OmcZjHM6TUxEnI4SREeBHNBRtf1iHSGKEIHOie6PD+hQsk25vcjQy70mUqbEaRYjIcM3/5Kq/9D7/Eez7+QYLJPaQesdaO+czf/wRvvPIlrg8m9DoNGk0bTyV87JNtZjPJ/qu7jKZTopshS7OQ0ydDHjttMR1eotd5AsvxcbTAIgMSdi09BKwa4kjBs2Jr/XMaqb/CkmOy/x9pZEXGjszqZJTJlILUg6BkZtkyCqEEcZIQhHP2DnZp1lp0Ox26bptzj57HdX3CcIYwhsksZscynF5Z5PbuHttDRRBnwDxDBQKTFu+Co8m4RZpmMKe/5NhBZpWj0/R8GWAVojBWlwClQl/JMgApXVJmcuto1aKWW/5zqkNutcwP+pxBkeHirIp1CdKrfVkg/IoCUwUlZSrC7Ht5AyANyM0edoQ+lL9/7hHIKtUic4pF0Qi0Umlwcfl2kCmsOehPM9ro4rl5VqTcMpzTSUyRn7603KZgESwro2VU+jt9FVEod2W70nfMqS7VGAqTKxuyjEmYjqdY1gBLWFgYhOfSarj0PIeVmstiq8ZINnlweZ2Tqx12Nkcc9iOa9Rrd5SaOZdifah5c92g3PA6HgulYc+2bX+O6cZmGYxwHJrMJ8zhAeNBcdPBFHS8IiaRB12zWl7pcWF4lvHebm9qib3koFTAOIkb7AwYvznn9n/9TPvyZTxHP9/DEkFNnGrz/x5/h0utf4/LBlNMrXVypWV02rH+qw2wGey/vsNcfM4sjTs5CFhdaNNYbTA/fYqn9NBpNMB4x7A/YvLfF5z8/4SPvf4qrN+e8fXXAZDIlTjRKhxjg2rXbBEFIGVeSjaWpBrEew26mHJxqViCTDUoZR1IMYLHGjmTRyjRHrVTuXKoozWWsS3V/fLcYm6oXKZ8jx+dVvm5klulS5xWPq/fJblRpdrkkMyWgoFTl/WXEkRsUp2jmLVCmrAwtZVqJObfKG5l6HdAJiUqwLZtEq0oxR4klrawvMsU5U5oLb0cG5quxBbnXOU91XO2jd9C0sraaihZfrNU/Q0TyD0Y5eLdzT5QaYZqbVlBvNPjQJz7CaDzk8usXmU4nbN3d5H0f/QhnTz+A5bg0O50fSJPuy19+cV2XleUVfM/HlpJao4bUMQ0LerU6vXYPFlusLrWpScEwMExCC9vxcYWFa7lEsyHDWNFqtTl1okk/OqA5i7hzMGE8mpAYReLYiFqdVl0R6xi720NODWE4RTgeGw+d49EFm52bN5nMRgjXpdHp0vYcNlZr7I9GvO/gKl3/OZZPNVnfr+PHO6yvTdjrzbhtxczdKVJJ6sqw0mqQODYnn1ggmVnM9qfMR1PGdzSm2eDe17/IxtM16J5GeA2kJTFJgrRtpFUjLalVtf5lcl/Zvi9/BinBYnYYi+w0xWSWsjR40RhQRmOjSZI4s6hJLNvCH3i8+dYlQjVHCoXWmjA0TIiJpGZzMGQWJQRxnOVgJyuIVVokC4CRKyumQpEpLOHkSLrwAJSciZySkwEYkR+4ogg4zN+z9BKU/SDIwX5Kz5HvcvjmVAeRWfLT+1W40pk1UAiOs2vIbfgllUocqTxboJhiYHKPgSiq2+Z0CZEpb6IYv1wFIas7YBD6qJdCVLWsTBnU5PQjUWlH1j/5T3lnVppXBBMXdRvKOZRd8C72vhKMFZizMii5gpBXiQ6COfbUodVoYwuQto1nNG3bpldr0Wl2sZbarCw0cZRiNIVQOdiWk+730iWYHtJPNJ2FFRoejKI+bSfkTn9CPBgSWoLIc7FqNWp+QqITnMUlzCBglkT47R4nTj/A+a7F5rUbTOMpTr1Bo+7Ta/n0Oi770zEfPrhCp/1p1s62ETgsLM5ZX51ycGfGFREzEWOSxNC2Ldr1Gp7rcubpRaKpw3izz6Q/wgkjTCPi7vN/wMazbe4cGKbDQ3QUs7a8ws1bt7l06Raraw9x6eomUTxFa0OSFQrc2x8QhXFBtaMYmXy2iXdgN3F8ESCOWP6r9JaqYlDM5mwtmWwuvPtceqdU41mOFC/LDAb5HNJH5kxpfS8mm5Dk8UDFDY6oxLmyf+QVK4Cccq5mXhaK6ZnuTbZtH3uvLLtQ5T9Mupa1VllSgncGDx8B6KY0epTekOPUvlLJOxqrcbS+Qe5FFJU1lPfZccrknyQ/kpKp+SbkOC5PPPUE9+7cYTzos3vnNoeHQ4bTgPMLi9QbjUz7exdgc1/uSyb54giCgM3NTep+DW1LGjUfOza0Hclit0NnbYPehsNar8ngIGIyM2irRq1l40gXmWjccMR8btFqrrLYWWSudllvuOhA4dtNZuGcuYS46bLUhs1BRHuhR0KAMDF2rcH6yVMsd8Zc/O5biPmIpuvQ6TY4v1Kj3bT49njAQzXDcssiWWhzMOmwd+Ua/cPLLK/7LLUU/ThhpCC2BHISMIklZ062qSUe2pMEmwn7swhf2oQvv4xv1qifl7Q3TmN7jRRYaYOwnHdX1u/LffkeJAenudXWANKQ5tXPLd2ZsqCMhjjGNoaQgBFg0HzrW99ipqdYWqIExLFmohXzcM7uYEKoY6I4LsE/RwGEFGlV3mr+cVseL5JpSqB97Myo2MTJ7fzpUZS72itAvuKJSM/SEmYftV+mgczVf6sC9ALT571XouP0f5m1vJr55Qi4MalnIk8xmr9b3sQcHOlqdhMEeSG33EthcghYVQCOtOco8C9+N+kLSknlXjloAoFECn0EXBwJKK3+UDXX5m3K6BwFXD1mGq56WfK+VCoFRVKIlIYmBI4A3xZ0bcmi79JuNWkuLrB8qsVKu87u9pxZJJFuA99xcYWNTAxecMhoXmN1o4s0Cm0OWGu46FDhWh2CcMLMk8imR6vmsDNUtJd6BME+JjB0213WTm7Q9Ye89uJb1NQcVatxpudzcsFDOoY3ZkMu1Ay9js3pRxYJIo8guMdwfIOVEzWWWppJEhFhUMYimgjmieCBM1380CPUIdP+FDML8RKY33wRR23w5pZhPJ8hTIyJNCrSXHzzCo12Hd9vYNkTkjDMoJMmCMK0qnFu2dfmHSlr8wEog9rLuVbFYIXymityleVX/lAqAdW5JfMK2Vlmqqq36kiWoneTbM5VZky2L2Rgt9oUUxbNS1d/tZghFeU/NSSUjrt83ZTelGJdVvcKqn0mioJsRudxNAaNrtyHog1H4h/+GGUpN6Zrk3ogtDnqoUtjPFLaXjUD2TuksI2Ue9j3Awl+6MpB0fHZC9YadT708Y/iOg5f/YPPszcc8Fv/6lc589A5Tp45XbpL3mlmuC/3hfzQMMawvbXFv/2930uzjiQhXmxYbnqs9tosra3gPrDKA82Qpt3hrf1tBuMEp9ZicXGJ5brN4PpN7P+vvTN5kiS5zvvPPbbcl8raq7qrt+nuGQxmABLgYBFIUTBKJjOZzCjTUSbTgVcdJF6km/4B6SoddJFOkiiJB5KiSJGCjAsAbgCIZTAzjem9uqprr9wzFncdIjzCI6ux0AgjADK+AbqqMmNx93AP/77n7z1PRgzaa6x2evjOgPjSZzw6piU95GqL0cxjEc9xOtDtOUT1TXbWalzEPrHTorPSY6Pn4ffX+IMv/1dqOqbnutxcafC51/p89ekJ0xieH8dsne7Tuz1gZbvN174y5fHzQz7xmeucPXyKM424SGCRwNk44TyMkdMQMRzh1iXc6HN5mtDruzjnIS/+5Ets+V1WBj0Cv4twXVSs0kw48tXZQypU+MFQEGSZp/VL3WpcN0s3DegknfiiKCKOY5IkIY5j4iRBCsFLlRB6Cj1b4LgBc0cQx9AJanhIRqFa2k3XWC4pmdht8l78qu0/SPd1KlxgTO+XQlh+1Jmv9BXrpM4Ju32uCWS2yVB5XAnzPwspo7VdcfL6ieJgmTEVkX2nsuBBpZVVB2HdxgSDakNN8mm/5OJjBEBu3Nf5uVct+vZ3WORQA7KwGJtC2iscWpsMiyyHEOd1BvLgSiM2dXHvnD7mfeBVRDGznkpJp91htbfCYhHS8DSrNc31QZONlSa1jRa1nRa7qz51t82TFyOmiUu722W136Pnw+WT53jxmM3BgH5zwGS6IL50mEwmtKWH2OoyPIe2pwk6glrLRzU3uLYWcHDp06sHDAYtVns1hCv5vS9+jXXPQSjBx6712Oq7fP35GZMInh3HbJ0+YnPT5+Fjn6eHI3aOHT7+Mzvcee8hjxeSiYbZAuZTxTBMcKYh+vQcd6OGqvswS+jUJPJ8xqP/82vsnyQ8nWsOxzOmi4jNrS0SR/EHf/RFOu02vl9jNg8z9zqTXlngmIB7rdD53gRZ7zFkGF08uFxEm74riwe65I2irWuZfq7NqpLpu7kxgTxIVorUX75kwBeiHGdjdb3yqiH5ODbvJdN3jIHBiEybiBtreiEAlFVHa4xk7WDGWt6nRSrCVZLGGiDM/iplUWREiHlVGHc6IQQiE0hmjObeNYjSSoK9kmLGgJQyc4ksB2PbiRbyspr2lBKhzCuuUHQ/CD/4q1s5sAb92voa73zuM7S7bX7jv/8Pzh894T/923/HP/vlf8mNu69Vhs8K3xWmG0VRxGh4yeHzZ8SzIeu9Gne7ATJo4g96eDsrbG6v06PBtx49ZRIlNFd7BK0VooXAj2KG0zMaTsDg2g7tbp/p4ZTB8AWzacjO5oCTUBDJBrWdLoPrLR589REf+fxPE0wmXPg1IlmntXOdT7xxg1//L/+L83BBL/C501Lc64XgD/nwaEYXzf8buex854g7GwM2B1t0+jX88zMWkza7niIeNJBOjbO55FxG1AdwcjlnddAg1D4qdmk0JEenCzbaLmv1Ntd2dxhsrOP4HgAy+CsZzhX+msN+/0ohQKZByGEU4wqRZj/JBmK6S2c6+cdxglY63ehsMSeaL0BCOJ8i/ZheUKPledQTzdurm/z2ww/QSpHzdCFKQcR2EKThn0prhFLILJA5jbGRRZCu2TPAqochMELY1nS7wiInHemfwjqnyPEjLM5jNIMpnEmraAwXuXXcaB17hSBzj5CYOhUpSTO6X5RNG2Jj5WnPhZtlydRWFhlZJlnCsdydMnZukzkTx2D8ng15ydObLgkQQboBk5SZ9da4L1AmNbnQsARUvjsyNpmxhF7GtUyry0wYtBsN2o06Dd/BUwmDZsBbA5+43kGs9ejc2GJ75wbqbMI3X04ItaKzPcCVLZIIHCIup+e0vAbbd/cQBDhnR3SHLwkXEbsbqxxOYVZrs3azg/QSDp+f8eZn38IfjXjq19GtDtu3bnJzo8/v/NoXuEwi/Fqdn+7FXOtMGWnB89M5bTS/dely/71nrHzqo6wN1jhrONn7vsHNAMJ+m5fK52IC0yCmvqo5upyytdlhFrk4gYMz1xyfzlltKvrnY+LxMY8OxxxFID2Xlx+cABrXdTk8PCQMo9SNRaUiXWtws0B9O6NQ/vwzS3tO3K3OXYjEIsZFADr3iS+T10IQmmde9L9EXU2nm1vqrc6RjrG0r8q8v2Z9ycrwli8uCVswiHycwVWhmXctma2yUQgVc7zZQ8F2bcMWt+bGomz0lkKQQBYMXQgLk3d5WQCZn450SHQacGzH20jxqtjAtAxxlmpZl6569VjzNPJ7Zu+QPOHBD0CyfyRsQkhJf2WFdz77GW6/dod/8y9+mcPTUxZZvtcKFb4fpEwV/OTynLrr0PJ8RKPD7fs32HrtHrXeNsNnHyJ6mumLfQR9WrUe7VqLOI44ev4BrV6XQWuFxuAmjmoTnR/yeNbkpwY1nl5c0L15g063yaIOUw/W/+7nuX5tk6cP9+k059zoN3jtI3s4QZ0nT1/geJJm26fWUMydiEk055/+k9v8x//8mPrmmxwcj1i9qLH2+k3e+ext/vz/fpWbn4VAOtwSmjs1B9FtcdgNeTSNSZxU7OBK4llC/CLCm3mc+itsbm9TWx0gfb9olGq1rcIPBcKydqUpJM2kFIURrusWLj+YTbvSyTNRirlSRFGM6zrU6zWUhLPZiPliQr/eQLS6TJMkswAqUOm1ErNBWYY0o01qVU+35LK6eGbJM4w9saxlkB4oslzhKcG0zGrm3Ly2UNCH4rNlwZAx/pREl4hteaI2rklKLX1uE/bsd7V0vgmARltTvLDrlf5w5CtSSFqwg51zImdSteY20qK+KmVxWflTNw5HCmtTs5TrSJGmfzWXVZTdwVLSlF7ddtnK+CWl2lqioii4qXQaBC+y4+I4Ip7PoeZTE1CXgpkMuH1nhcbuR3DcBvHhEd1OndHTD8G9SS/o4coANRpzerJPu9thvbeK37+FOkwYXiScRG3u9RKeXpyzdv8e/YbLrKmYNH3W73yUa1trPHzwlNXWkJt3drh1c4soETzbP8TxJK12QNAUnIdzVndb/KNfvMF/+9UDajtv8fDhMR/5qQ1u371PHD7gm9/4DjdiQd1xeAPF2+2ARdfj5SLi+VSROD6y0SaQmvAsQl8u0GN4Fja42fO4aAwR9ZCG1MQKzkcjhBD4vsdkMiUMw3Q8iSwcXQiiKM4JYRGTQqEEDNlFgCjIeJLY8SxLIyR/xvYDs63vRuPZIrfsvpd/tbRaV6BYxbJjaNLVtcKib7L3pCsR6ftEZSsCQso8/TCmPJoll6Ll0VsQf3NHY903gc9pX09LEKs4y1TklIg/6FImLsgyFWG3ZxErYJN9szJg0gfksUx5U14d9/ZKQP61Vuk7ekm4C/ti3wN/deLAfhlrDVLieR6r6+v883/9r/iV//Dvkeg0E4IViV2hwjKUUnzp93+P3/nfv0m71aTh9Xjn429w9+3r9Fd6uG4TnUj6Wys8fhmzurpHp38bhUSPh4jZJePpBTudLbZuvklDusSXFzAfseJOWbCN02pRa7YRK21qqwH9VcFrfp3o/JSgWaPebrK+ucH27g5hHPL+ww9RswV7H1mj4S9wVUhzESJPT7h2b4PpeMYff/CM4NYtPvXmDW7vvMEH6tscjCRrXoPZJEJNZtRbMf26g9duMJEwmY/xIodmrUXzrZu0P3mX8zOXsydndCKNv1jgSyfL/PCTlBOnwo8rNIVFLLXIpf8Zl0+tFIlIJ8w4jnGkk6Y3zVL8maC8JImJogVCp5a6SaLQ8xnSdbjR69Gu14knU6Ik2+ugZOpPCWt6PSuVYG5oNJZHcuu1EAJDf80EmBP0fEIvW81yIqBNGkeBI7lCWu3sQia7iT3acsIlRF5/+z5K8QoyL/LUhkDuV58eb9PogmqZWuQ/zWpASewUYijVQpbFM/uvyFpi9mjQryARlhtR1t7KiCMgToxks55d0bC5mitIkCm5LtoM+7HrvF1ssuM6Djc21um1mrgS6tJld1Dj0//gcwxW1zk9mhCNXpAsJvzhuzHXN+7Q3XwbogV6fImeXjCbjtjpbrN15+N48znT0RQvGtNyQkK5jttq0zrKe0QAABr0SURBVGh2iAcd6usO610H3/FILk6pdZrErRa7164zGKzw8MkzvvPoEWoR8drtLsRnBETUJ1OUK9m9t8Z0NOF3//wRaz9/wc7tFa6t3uFAPWd/JNjwmlxehASzMV7DZTVwaXRqjB0YzYY0Q4fm2oD6tR2cZJMHHxzzld/+IvPIIZwtmI0XxIkmmi/QAibjMQiTucohSVLXtNRzp5xVqtgELf03UQqh07EtrN20S+eYBFZa5zuVm/6BTTgt2ILkVQI672vYhNt2dbLEuS6Lyry/mBU1bfzzyQN/C2Gd9jz7XQZ2tp5ixcH0SnN/uTSmlim86dGFIM7Gf9aHjesgmM0MC4OLELK0aiKzWCqNlSJWmJVZ8nfcMoxTjr0yma/05AaIJYEEr7zWMn40fghCpJHUUuL6Prfv3+Mf/9IvsbGzU1p6rVDhVfj9L/wu3/jTP4b5hFt71/m5v/05ru1dp95USO0ST0Im5+ecn89p9XdodzYZjhXRLGK4WHDwcp++30ULaNR81CIijhV+u8n2YIN4Klj3Q3zlEPTaqPUeY9/BdUeEvkPXC2jtXmewuYJfrzEeXTKdjgmcGt3WgG4whMWCuYxZdySvv7bJ1749BLfG+aXi5ZFkbfVjvPnT38A7u2S60iMUEVLERIlCX0xxvJBANFAqwKdGw13BC3aZJnWSmkf/Wp1aq5lZMauxUuGHhzwoVBT/lyLdbMp2ScgziwizE29BRszErWKNFJpYKyKtCZOIMEmYxRFxEmcpOrMJPLOGl0g0lIm4xY7LCwCvGgPGjag4LyXOFOSkMLPlqxJlF4nitposGDL7w2QWKpn4uSosir8Lf+nl7CiltjfEwEpHWrIMovNylGl2IRiUurrakLaBsTSSN6DtdsBSnZfbVZOmjU3bq4jlsMuX/yqK8+3EkqUrCgCZCkvbuJEJMCkl9/Z2ud7v4rsS6Si6PQfV6TDY2OPg0Uvm+4fE0ykzJRhOPA7GCf2LU5xYcHZ0yGJ0xKDWQAlFqx4QnV+gpKTd61IfrZLMBRv+giBxqW92mfaaRJ7CFRMiz6HvBnRu3KK7OkB6LotwwXQ2IXBrDDqr6MUMEUbEUtILfO7f3uDPvnWJ4zU5OFzQ2dxldeOj3P/oE7zTIePVVWI5xREKwhg1H+M4C2qyThLXaDpNat4G0ttioVrU11x6t/fg0XMSpVhEIYsozjbH0lnbGcs5uYU7123ZnhLa9HH7GZRcab57rFrJ1cYi9svH5M8w68PFfhdWEHLp4WtrHAuLXJdhrquUtvYfKO6rMzFUOlVzpT7ma2Vul1epKFsqmKXVZoU0sYWV7ZJ0ZaxZGZNy0p4FMJsHYMRKHkOQtW0pTres2/P7ylxYFO+UUssuGQrLY/Vqu7wKPzonZavw9UaDj3zyk1c+r1BhGVqnPpbX9va4eeMGnV6fj3/ybfxmi2QxYT4OWcQXxJFAB328eot6o8N88owknJDMRszGU2qNFr3713CEREUSR3rUmoKk1eN8eEpbzKkHO9T8BtprIDxBokfI1gpd6eN3Jb1+lkY0SXC1xvOauM0e9YYmHo6ZzxSucFlvShp9n2jR5+x8wuNHh6xtXmf33hucPPgSYStAuT6OGyKdkGg2TTdS8+vEus0i9LmYuyTjBfHkhN3Na/TWV6i32zium1kZqlFT4YeIjLQbwpBRhyu7OwubaWOMxTon0pCmO03dhzSRVizimJmK0SrJs3wA6CLCNfu7oKvl7n21r+dzs87Kmc3DZh+EEpHWRUzBq1D45S6Vp1RLy1pYPtsi3tZWDTYhEFaQNKJEnO1yGZJlCwiBLl3TZD+yW2U5C5G5ZMnia5WlKIe5lF2ncuXT55s9z8x1qwictpRVzmiKuuT0xbJK2wTNvobpb67rELgOURKxCBOChsvuYA2vu84H7z1n/5tPqM9nhFHMcSSJu+sk45CmPIZFzOTsmMV0QlMGdHa3EUmCjiSu7yBbTaJ6i9H4go6YU6/XaXgNXK/BzA1J9AynvUJf+ARdSaPVTNtLJbiA77ZwWn1qtTNmZ3OiRBE4Dut1h3o/QM4HPH1yQG+7z82bW2zfusfZh3/ColtDuwLpRwg1Q4UQS00YNEjocDbzSBYQqynJPGa1t8rGrTvUVr6NUz8hGc1YmBSZVlYrO6bEJtlCm0YWpcdpxknRZ8r9o9wpiz9sl5zSL6ZPy3KMi6URS8i1qj0uTJml1UcwPNl0+FeMUVMuXbyDTF3setrlt0uSj4mrxTRnfde/BVwJpEan6Z7J4qNMwUy7L+lwTCWNcMtjg3RRX6xrF+/moi2Kz00ZMQP/Sm1/EPzIIxgNsXGwGqAiOhW+Bz7xzqdJkhgpJUEQoKIZCHD8Ljgj8Gp4/QGrrS5Hp+estFv4NY+xXqDUnLoTMF9EbN+9T3IRIYQk8BU60Yx8HynnhLGmW3dxRYBMXIKaYpzUwBvQ8FwaKOoNLx1oiaLh16h7dWSrhduJ0FGdeBShRI3aYsLa+gqn8xqnl5e433mX1+51afXvIPx3U19fCQgJjoMXtBnqGiO5xXjhcn4aMZnOEPKIDqvc321Ra/bxak2k6y5tblShwl8O0t4d1fAKpYrdNW0LuUiXzB3HyYLqNEluKcusmSqfFdE6dUcRiYQkSTciy6bUOCf2lmUuc4WQmnyTMZvQGO8bs/luKiRETjKN/7yyzG+ljEaGtVK4Hyxn/zC/yNLxZtI2qU3NJlDZ30Lk7hi2bzH5JQtCXZBji7gY0mSOz+9ok0Bzvu0XbdrNOqtQDfkzK8pz1cJp7mEkgy4aPBdd5v6SsmGiTGLSshiRJijva2fXRZj2s6qPSHePPTw5Y1T3SZSi3W2xrRq0Yp/f+50vEr6c0m76zLTgLHHYaK9zcXLMqob55SnJIsbFIUxg4/ZrREONlDV8RxMFLgvPSd/3kabf9JFxQFM41AKHqaojvBWanksThe/7JDpGKGh6dWpeHdFu4esW8+E42+DKp7aYsrG1yunUZ3//MSuPAzbWb9Ho3uLMfx8RReCCFhLh+jiBw0jXGMothjOHk+M5YTLCAbpywM3VNnL9FvXBBl7nEOdyhJ7P0uciykK35PhiEUvjUFOswOlS/yqL5TJzvdp/zfiQ+XFXyTO5Irc0SSH8RJEuVGDGdTnAuEyMs3eKEIUFHqx3hd3prEDj0ggyZUrLlV9nSWgYcm7iN0o3sFc2yl0dmb+7dC7cAFCqaNGi6Ev1szaQ0+Srkkoplt8dppCFHrCEVN4P7PY2z6voKz++bkXfBT/IUkeFv9mQUlKr19M/sgEsXR8hXeL5glqrQ6O3guO5zGczXh4cs7U5IJlPmCUR7nROtztlvb+FHIXEkYdyFriBwvccom6DzsDh5YXD/HKMJxWy20DUBRutLseTKbXAxxUgPFBJwmQKQWcNXyZ0mwHNRoOw3cSdO8wbt6iNT7jVvUa8O2Vy+JTTowPe/8Mv887n3+DG/dc4ffmA0WzMJJJMGi0G3XUOph64O3znww+ZH0/odTvcf2udT9//HDEBUruATAVFhQo/TGScMt85dCk3ep5Zw1gjFSiSnKwashxFEa7nZPN1OgEaV6Q4Tv3VlZncRNnP3mQPsa2A6ecFOc1TrAqRpm+0LIQiI8VKFXneSwybLHA4rVF+z2LJXeRkv7CapyRJSpkR2fJELIub52RfZhuAphmJErQhQxbsIOTi3PR+Ujoly5+5qzK7IVsWxJSFaYQWxWZJqrz5krFMWhe07quXjjFfWN9lBM6xymVWAMxxhoAI6/irU7tFsMxKk/VNeo5kEca8DIf4E4dWs4EfJbz37Qc8erjPnbUtTi8nHDy8QPgBe3s3ue26/Mbv/hrBxz5DFGrW6nVurA/Y27uNP1UskgDtzqjVwIk86NXphg5HFy6L0wu8u3vIVgO32aJVg9PpnHoQ4AiFcCCaJSxCF7+zQiAVvWYNTzdQnRauCghrmzSml9zp7zG7ds54/wNefPiAVX/Gm5+8xs3XX+N4/9sMpwsuEp+g2SFodziYe+Du8t63voGeJOxc3+L1N27y5vW3WcQOJwfnhNpHOAGO6yOEg+MAjkMSR6XdhYWQ+S6+sPS882PKnxo3wHzVbYk8lsXpq+23pVUk+8Qr98lEZUaiJTJ9hyx1znKwbfEuMAHI2u5DVhnQGrlsLX8FcTZ1ssVLSZSYymK1l1Xx9F0kch6iRclCkZFx+91lCQ3LwGHXo3gO2f1tF6rsp5SO9fxUvlp69aEUsRW2waR0z++BHytxUKHCXxwChAsIlBB4gYd0HBCCRqPJO3/rU2g0k8mEeDJGz2dMEkVrvY2/ucn4vQ+otRycWg8dtmhu11GHD2jVVolGLaJzB38CbstHSsGg2UUKySKaE00mqHBKFE0I1ldBS84DWGt5tBdtzk80tcUFre0ezw8vafqwfWOPqbrF14dTXvzKb/H3Pr/J5vY1NsILTi+nPB06/HkYMBSS8xcPOPzwGR/f2+Nzn/oUO7c/QRgOcYjRIkbjg/aASiBU+OFBqXSiszPqOI6bW8HtyVVKgUpIc6lnxN2QdnMtlO17XEySZkJTWuW7JJup28myf6RzmjQGwWJSzQpQIp6isFCbcpsvimX3IjjxVZk+cqJNYWTMa50xWJvL28LCILfEG5UkspSrtpXVsvgpy3JpLOimEikvssa30riOWxIMeclTkyNOfnhZ3GBSj+bNaK9U2JbbgsQJI7CwjyvaP7/PVZ6WP5g0OD3Jn2fJQG2Oyxin/cyUVqgEXCnRCuIwYnQ5IprOmM4jTk4veHpxziJR6EXM1999l29++12klBy9POb2+gAPzXCxIHJinI0N5l//Fp3tFjjryLZDY91BnT6jVVtldt6kfg5uV+K1XFxHMGgGSCGYLaaEwxGL+ZyEEH99DaUcTryYu7UG+qSFmkQ01IT6dpfHL87oNTT+/TeZhpo/eX7O04Mv8PmfW2f3xi2i6Qn7ZxEvLjxOpj4jJOf773P08Cn/8Gff4a2PfZbe2h5ROMFxBO2ex8c+epfTowNGlxdpKu/RsBCJ+b/Zc7T7TElclomw+TSPpbnC7cuRN5rCsn/1yCV+KkRpZsqt3NmYEojULdcSJnZBjXtSTmjtPi/SO15xlcvKV1qhMsLVXk1YFkfZC0YgKYkDimvaAsGOwSjdyhIEwurshpwXrl5lgl5qz1fx9vxVYr9nTJyOyFff0s3TsnevWZWz3rfpu8aIx++NShxU+MmGNWj9IMg/S3+mP+bTOXu3buJJQRJrPKfN9Rt3OTqfUl/fQE1GxLMFvuvi1wOS3XcInj1E1CaI2Qlq7KN3t1DSJQgSJudjLh4+gBrIQZdJrOgHDsJdIXDauI6P00xw1gTx6oD94yGr6gjRv8FZ1OcohEHb4dnDGv/ztx7yM3cEWwOHVrvJ7nqNZ+OEl/sTZgdzPnlzi4+/9SYb1/eIojFSOiQ6QAiIkwVO7OKVLAkVKvzl4LmeMUhjMnEYYQAmVWeRVUNkFvgkSTKCnk0+WmcbBhWZPUyAn5moTKYgKOiNlBZBN59KgUoUUpnJVy8z1PT6WpeIgU30vx/sEbRMDwz5yFcz8usX1MxxUxKrjDuFdQ0p7Uld56sl0pq4C5GT1tUxblzGampSvQpjIc3OzMSHxmzAlOa2zwWIyFZo0g9KbWG/Nl7VVibb0zJBLLXU0qMwZEq/6mjreaerHFadi5Lk95ZCkChNGMVEccJ4usBzXBaLkMeLs3RFRoPScZZWXnNjc5fT831ajmaju8Pe9Q3uvP4WR2cTWrs7xJMRIpjhOz5uq0uy9QmC5x8iapfoiyN05KO8Pko6BEHC+HTE6XvfoL7dY+4GhEqzEngIr4cn2zhugtON0I2ERafF+fGYTV7C+n2+OmySBBH1RsSH+y5nv/mQn31dsN53WWt3CJs+z0cxLw8XzA5m/J2P3uTNt9+mvdInSeZIx0UkHm4w4+2Pvcnzg5dcDEfMF4ssVaZmMoZkEWbNKLPxk/abInA1bRu19MxN3yseXHkFyVj3lwNeixNMLzckOMualz1XaWXNEnY5dBH0a/qFIhXQhrgW43m5DxZjyNa+dplyDZIfr6zRXDYoCAyJL+/hUGgnkZfFxpVXiu3ek/1pXK+WVxFMmWyXIDtLkzFKpP8Wwkks3cPeN8SRxWqKCUA2WeQMXNfJzqvEQYW/zhBXvfGWJ20AP/CZJQmb16/RW1nn4nBE4Pq8fPfr9Pb2mAEiCPA6PdR8Qv2NXWLhoOchjGZMvvOIZHRC//Y1Pvxwn8PjQ/p9QTDoIz2H9U4T1dtER5LdQCLGCVEc0FtZ4+S9F9S2r9Hb6pBcRrSPThktAlbuDPjoL/wij7/2q/zRi2P655rrGz4bW5I9X3Pz+ioP9CnX6y3ajQnx9D0WCxDBFsLZJormaBnSqAvawstzz1ciocJfFrZLj9I6XxVQWZpDJxOjMiOoQog0n7i4akHPs2Zk1nBhkWbHkQhldm5NJ9NlEm3SmILONkuzrJz28jvlyVpYZdHm/mDxmeLcnLiIq9cxnyy7NpgJ37bC5rewBIOQTnZFZVntRd5WTm7aLwog0TiuW1oeETpdnSF3hSLLQpNeTwqZEQWV7+9QkBSJzPye7c2WvlschMkDb2IYigZNf9iWSXOeLC0JmGYr/pbZcoZaNukKW0iln9krOubZJUnRdkmsCOM0U4/neGn76eIZHZ+f0ljb5r3DfWK3z+1aB+n7TJ88YO3+XS6HiqDdwlEBJCG111vEOBBGxGfnzL85wTnt01gf8OLJAS+OXrC16TG/hFrHY6XTQfXW0ZHkViAYn0b4tS6OnnH26Izaxha97S7zkwmtFzOSdpPNvRus3L3N02/8Ol94fMLWGdy+BkFXcKcuuHNthQ+SU653u/jyiGh0SZT44K+D3CCaTam1Oty79zqT8Rw0PH/+nOHlBY7r4itNGtCfPlXXEahEY6fjJO9vZiXvFWNEF8QzH1evVNZlq7SB0sYCn2U4y8eEfVS6a7NtDc9jCa7cpehLJg2r2dvAjCF7LwO7SwttX8de2bDeGtqMx8x0YQtnSzRpq49ekUjWvPsqdx3znXGFyo0blHeINu3pOA5ap6ttSEpjuSD/rxAx5nNhwrDTwqY2G7MjtFMq7/dCJQ4qpPhuprWfJLJpWSygsFKl+cMlbq1OEDRxRcDzP3vI2vo6QRISywC58OFCIestZMOhtrFGfHRCqCKSaI4eJpy8L5ifJdQDn6YX40iXRQjnBwd444S3769x+uSM1a5k0K/jyyliMaYWJ1w8fUh7NeDuepP6pebo5IyXo/e5ffcu+4cJSTTmUgmcqeRiNiUaRux0HRo1zWR2SXIS43sBl+OYOFZ0O2vEniCZz3GQtJodhOtiXjo/SY+two8hbLJn5khrCbt0KOTkP3fD0ZlJV5Jfx/jGFhZqywafT852/y1Px/aEZhPzsjz43n0/5wYWzAq7IQ+GCBhjaU7frXawL2OIivnQJhVmQzST7922QKaESCIyUmLaN+W4MtMTmYXUyXYv1iaVY+qSUVhoJXEYE6voFaRfWqqssMKa4OtcJtkWWvOPLrdtqez58RZhWbJs2kUp3JMKYobVlgIwCauKd3e5vymtUCrb9C5RSJGQ9Sq0FnhuQBwnhHFA7HhEnsNwPOT5t/ZZ22rizid4bhMxAuFIZL2JG0hqW+tEhy9Z6Dl6EROeKGbDkPlFQqsW0HQVkfRZDOeM9o+pzTRv3Vvl8bcO2d6o0W2BDscEiwl+lHD2+AFr203e3GyzvxBcHozh4pLX7r/O42dfY6FCziOJN9YMZwvi8YK9VQ8/UJyfnVAL6iADRqMFSRTT7a5B4LC+uc713R0O9w84fHGI6/p4nkKSbgpqhpTUab82RDptW513cKFFvqs4kLu5XKUBxdjNmPSriaXRt4VCTrtPWfmRi93SR3asT/H87e4j8jgfc21xZTwW97Fc37LrmN28zRWLIhWflUTDUjmsRgCzCqCLewmZivNX8ajluqXjqHzMsoujEUymva+4VXH1mrmYLl3XiOy0nolKUpHyAyyl/kDi4Mtf/nK+OUaFCj9JMC+1KIwR2YsymoU8/NIH3Li/jRqeEcY+euHiJRKn28R1NGocEp2eE8ZTlJ8gaoLRVCCcLsEgIXCm6FqLmahx9uQhDx6es1Hb4/33nrC11mBzI0CqEdHTA+T+kGcvn7B5t48M+rwcBrx3vCA5e5dP//2f5/xsn8l0iBAOnlfjYjRhdDLn9dc6uK6DjlxcUaPVbHI6CwnnfdbX9oh9Dwk0pEOr2cXx0uFcCYMKf1EcHx/nv8dxjMm6AaCEzHfKFRRuMyJj04Is2DY7Iu9+OhUHJWu1mSh1EbhqSYTcjJ8v9RfmvtI1bN2wHHBbHPddBoIhSIJ8ZWL5SGXUgfVlYY0zZNq6obUCkNNdu666TFYM6U+WJngpRJp5iSzOwrhu5RvQaXSStqtUTioOtEY4DnEc5b79JT9uIbLdkQvyKEQqDsp7SpTtnjorZ6mepiVkdk2r7UqeJ0ZYZSRNJLoIDrcs08vh2aYvFH3G7IhbiMfUOJ1aksncU9KyCoRwQcecDi9x6wGH5wd85dsxLx8+5s4n9qgnc0I6uAuJ6/o4rQBXQjIKiY6OWYg5oq5JpGA6dxBOm9pawvsfjohajxiPp5w832f/cMJ6cI2vfeUD3ry/QbuTwOSC+PgC8fiEp4ePufFTm8zDHo/PHZ6fXuLOn/PJX/gcRy8PmM7GfOA3UFowHM2YXYS8ca+DFJJk7lOvNXA8j8u5Ilp02dy4xURo5sMhB0+fcfTyiMvLS8IoJIqiVBgkSf68Ym1c1kSefSy3Wuv0d3tzLEM+7eBy0yfsY4z4vRrQXB6m6cpitheHrf9hSUBbQtuIGOtehaAVpQuJ5WPLJn/reF2U7RU8394WrtDI5VGQv/myslyNVxIIpTLxe5V0S22Cw3VenZJ41tZddErgBYJEJyWDjNaaRKTfaaWzlRYzPos4KrvZimBnXbwHxFUDz6sgvtdBQojvf4UKFSpUqFChQoUKFSr8REHnG8yUUaU5qVChQoUKFSpUqFChAvB9Vg4qVKhQoUKFChUqVKjwNwfVykGFChUqVKhQoUKFChWAShxUqFChQoUKFSpUqFAhQyUOKlSoUKFChQoVKlSoAFTioEKFChUqVKhQoUKFChkqcVChQoUKFSpUqFChQgWgEgcVKlSoUKFChQoVKlTI8P8BL1g2uZqc4n8AAAAASUVORK5CYII=\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "By placing our rendered image onto different backgrounds, we can clearly see the varying degrees of transparency throughout the image.\n", + "\n", + "While this naive strategy works pretty well, the channel visualization features are positioned all over the rendered image when using the `ChannelActivation` loss objective for model targets. In the next section, we'll demonstrate a potential improvement by using a custom optimization loss objective.\n", + "\n", + "We can also see that the optimization process is working well with our setup, by using the `plot_loss` helper function on the `history` output of `InputOptimization`'s `optimize` function." + ], + "metadata": { + "id": "E4Jr_QUw-xPk" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot loss vs iterations\n", + "plot_loss(history_basic, title=\"Basic Alpha Channel Optimization\", figsize=(8, 5))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 350 + }, + "id": "N4VUvsoQ-wj-", + "outputId": "f444d5c9-6d59-44b6-d10b-6a8fbccbd498" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Advanced optimization with transparency\n" + ], + "metadata": { + "id": "sKN4xD6Cz-xL" + } + }, + { + "cell_type": "markdown", + "source": [ + "While the simple optimization above using `opt.loss.ChannelActivation` works for optimizing the alpha channel, we can do better in a variety of ways. For example, using `NaturalImage` as a target means that we miss out on the random image transforms that can improve visualization quality.\n", + "\n", + "Below we define a special loss objective for optimizing our alpha channel, using transform robustness. We also add a `CenterCrop()` transform to encourage the visualization to avoid the edges of the image." + ], + "metadata": { + "id": "Dmpiqunk_LmO" + } + }, + { + "cell_type": "code", + "source": [ + "@opt.loss.loss_wrapper\n", + "class AlphaChannelLoss(opt.loss.BaseLoss):\n", + " \"\"\"\n", + " Optimize the alpha channel of an image parameterization.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " target: torch.nn.Module,\n", + " crop_size: Tuple[int, int],\n", + " scale_list: List[float],\n", + " batch_index: Optional[int] = None,\n", + " ) -> None:\n", + " \"\"\"\n", + " Args:\n", + "\n", + " crop_size (Tuple[int, int]): The desired random crop size to use.\n", + " scale_list (list of float): A list of scale values to randomly select from\n", + " when rescaling the input.\n", + " batch_index (int, optional): The target batch index to use.\n", + " Default: None\n", + " \"\"\"\n", + " opt.loss.BaseLoss.__init__(self, target, batch_index)\n", + " assert len(crop_size) == 2\n", + " self.random_scale = opt.transforms.RandomScale(scale_list)\n", + " self.random_crop = opt.transforms.RandomCrop(crop_size=crop_size)\n", + "\n", + " def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor:\n", + " activations = targets_to_values[self.target]\n", + " activations = activations[self.batch_index[0] : self.batch_index[1], :, ...]\n", + " assert activations.dim() == 4\n", + " assert activations.shape[1] == 4\n", + "\n", + " alpha_mean = activations[:, 3:, ...].clone().mean()\n", + "\n", + " # Randomly scale the image and then randomly crop it\n", + " scaled_alpha = self.random_scale(activations[:, 3:, ...].clone())\n", + " cropped_alpha_mean = self.random_crop(scaled_alpha).mean()\n", + "\n", + " loss = (1.0 - alpha_mean) * 0.5\n", + " return loss + (1.0 - cropped_alpha_mean)" + ], + "metadata": { + "id": "pc7MGUKM2MqT" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now we can render the results using the `AlphaChannelLoss()` objective!" + ], + "metadata": { + "id": "mAwfOLftBYck" + } + }, + { + "cell_type": "code", + "source": [ + "image_size = (320, 320)\n", + "crop_size = (150, 150)\n", + "scale_list = [0.6, 0.7, 0.8, 0.9, 1.0, 1.1]\n", + "\n", + "# Initialize NaturalImage with 4 channels\n", + "image = opt.images.NaturalImage(image_size, channels=4).to(device)\n", + "\n", + "# Set optimization target\n", + "loss_fn = opt.loss.ChannelActivation(model.mixed4d.conv_3x3_reduce, channel_index=139)\n", + "\n", + "# Use NaturalImage output as target, for alpha channel loss objective\n", + "loss_fn = loss_fn * AlphaChannelLoss(image, crop_size=crop_size, scale_list=scale_list)\n", + "\n", + "# Setup transforms\n", + "transforms = [\n", + " opt.transforms.TransformationRobustness(),\n", + " # Blend the alpha channel into the image using random backgrounds &\n", + " opt.transforms.BlendAlpha(),\n", + " # Center crop the image to encourage visualizations in the image center\n", + " opt.transforms.CenterCrop(crop_size),\n", + "]\n", + "\n", + "# Render visualization\n", + "img_advanced, history_advanced = visualize(\n", + " model, loss_fn, image, transforms=transforms, n_iter=512\n", + ")\n", + "\n", + "# Show visualization on multiple backgrounds\n", + "# The backgrounds are as follows: No transparency, checkerboard, white, & black\n", + "opt.images.show(create_mosaic(img_advanced), images_per_row=2, figsize=(14, 14))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 824, + "referenced_widgets": [ + "b9b1828c563c4cd184f26fa5590b3f5d", + "03a3658f7c2e499f9528d3376ac6b203", + "6717308b8d6148d9a9c8747164b791b6", + "53a11c21782140afa93165abf2f97e76", + "b91e276e9fb24ebb804eb5605707874b", + "6dd3c9c30bb246cdbb364456cd1bf5e8", + "5017968b4ae742d5b8320942b325e707", + "92994846e32f4fd4a079444319362f1a", + "35d3a18dfd08421ba1543031b5fb8cab", + "3952b6f664e94cf8ad7edaf249a17d1b", + "b6e7d16af29a4e43ac54a249e843d973" + ] + }, + "id": "37jeXKau1prg", + "outputId": "b5c05ffc-2eef-40ee-dbf2-c506c12c879b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/512 [00:00" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "The visualization is now nicely centered in the images.\n", + "\n", + "We can also easily visualize the alpha channel as white regions on a black background like this." + ], + "metadata": { + "id": "DNfyVL9K0bHN" + } + }, + { + "cell_type": "code", + "source": [ + "opt.images.show(composite_alpha_only(img_advanced), figsize=(6.5, 6.5))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 384 + }, + "id": "PsCu_Waa0Vwi", + "outputId": "36754300-1af4-4cb6-c416-3ce39454966f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "When we look at the history graph, we can see that the optimization process performed even better with our improved `AlphaChannelLoss()` objective!" + ], + "metadata": { + "id": "Tl9zHwfH-9a-" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot loss vs iterations & previous loss\n", + "plot_loss(\n", + " history=[history_basic, history_advanced],\n", + " title=\"Alpha Channel Optimization\",\n", + " labels=[\"Basic\", \"Advanced\"],\n", + " figsize=(8,5),\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 350 + }, + "id": "tsA90jBb6bLz", + "outputId": "24cfea81-9cd9-4fb7-b865-0150cad4fcb9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Two Stage Optimization with Transparency\n", + "\n", + "In addition to using the `BlendAlpha()` transform for RGBA images, we can also simply cut off and ignore the alpha channel by using the `IgnoreAlpha()` transform. This is useful for example when we want to ignore the alpha channel for the first step of two step optimization, so that the first stage of optimization occurs without the influence of the alpha channel.\n", + "\n", + "We can then perform two stage optimization with transparency like so." + ], + "metadata": { + "id": "WzRHPcVLA0QT" + } + }, + { + "cell_type": "markdown", + "source": [ + "We render stage 1 without the alpha channel using the `IgnoreAlpha()` transform." + ], + "metadata": { + "id": "gg8-vvF7Za9f" + } + }, + { + "cell_type": "code", + "source": [ + "image_size = (112, 112)\n", + "\n", + "# Initialize NaturalImage with 4 channels\n", + "image = opt.images.NaturalImage(image_size, channels=4).to(device)\n", + "\n", + "# Other targets to explore\n", + "# target=model.mixed3a.conv_3x3; channel_index=76\n", + "# target=model.mixed3a.conv_3x3_reduce_relu; channel_index=76 - 64\n", + "# target=model.mixed4d.conv_3x3_reduce; channel_index=139\n", + "\n", + "# Car Tire\n", + "target = model.mixed4b\n", + "channel_index = 373\n", + "\n", + "# Set main optimization target\n", + "loss_fn = opt.loss.NeuronActivation(target, channel_index=channel_index)\n", + "\n", + "# Basic transforms applied to both stages\n", + "basic_transforms = [opt.transforms.TransformationRobustness()]\n", + "\n", + "# Ignore the alpha channel for stage 1\n", + "stage_one_transforms = basic_transforms + [opt.transforms.IgnoreAlpha()]\n", + "\n", + "# Render stage 1 visualization\n", + "image, stage_one_history = visualize(\n", + " model,\n", + " loss_fn,\n", + " image,\n", + " transforms=stage_one_transforms,\n", + " n_iter=256,\n", + " return_image_instance=True,\n", + ")\n", + "# Save a copy of the image parameterization in its current state\n", + "stage_one_img = image().clone().detach()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "cee03ddb22f84eefa613c6446234c6c4", + "2bb9a8610f0e4d8b91d054cfe9140801", + "f825760c27ee4b80830654f3c02ae65b", + "fafbc35e64814fa4b13e5da2f643dddd", + "5b9280650f144ff882e0d329ff4cb5bc", + "084a58aa0af344a2b2a3fcafa838811c", + "f1f53143baa94a89817ff46acece5054", + "ddc620d6a2c042789bda344dc94b5017", + "1ed5c534ec334eec8d144f912e6beb23", + "84afeb12ab79493a8aa8e3040323216d", + "0dbfdbf943244faea948bfafc16c4a2f" + ] + }, + "id": "aFPWICceYzqw", + "outputId": "36f0ceb5-7b23-41f5-9801-bf18f72033f6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/256 [00:00" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Stage 2 Visualization\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "And we can see the loss graph for both stages like so:" + ], + "metadata": { + "id": "nAd9a-flalLt" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot loss vs iterations\n", + "plot_loss([stage_one_history, stage_two_history], labels=[\"Stage 1\", \"Stage 2\"])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "id": "fqEpq0geqPd5", + "outputId": "cbae9836-3900-4ac8-e2d2-b79f394e2ffe" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEGCAYAAACgt3iRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOx9d7gU1f3+e7beSu/SEaQIgiD2gqJgRaOJmsSe2GIsyc/EJBqNCWqM35hoNAnG3onGEhV7QWNBkCIIClLkSi+XW7fO+f1x5sycOXNmdvbevXfvwnmf5z67O3Nm5uzc2c97Pp1QSqGhoaGhodEahIo9AQ0NDQ2N0ocmEw0NDQ2NVkOTiYaGhoZGq6HJRENDQ0Oj1dBkoqGhoaHRakSKPYFioUePHnTw4MHFnoaGhoZGSWHBggXbKKU95e17LJkMHjwY8+fPL/Y0NDQ0NEoKhJB1qu3azKWhoaGh0WpoMtHQ0NDQaDU0mWhoaGhotBp7rM9EQ0Njz0Q6nUZNTQ0SiUSxp9KhUVZWhv79+yMajQYar8lEQ0Njj0JNTQ2qq6sxePBgEEKKPZ0OCUoptm/fjpqaGgwZMiTQMdrMpaGhsUchkUige/fumkh8QAhB9+7d89LeNJloaGjscdBEkhv53iNNJnniuYU1eOxjZZi1hoaGxh4LTSZ54qXFG/HkvG+KPQ0NDY0SxsyZMzFmzBiMGzcO48ePxyeffAIA+Mtf/oKmpqY2v/706dPRpUsXnHTSSQU7pyaTPFEZj6AplS32NDQ0NEoUH330EV566SV89tlnWLJkCd58800MGDAAQPuRybXXXotHH320oOfUZJInKuMRNCQzxZ6GhoZGiWLjxo3o0aMH4vE4AKBHjx7o168f7rrrLmzYsAFTpkzBlClTAACXXXYZJk2ahDFjxuDGG2+0zvHKK69g5MiRmDhxIq688kpLw2hsbMSFF16IyZMnY8KECXjhhReUczjmmGNQXV1d0O+lQ4PzRGUsjEZNJhoauwV+999l+GJDXUHPObpfJ9x48hjP/ccddxxuvvlmjBgxAlOnTsWZZ56JI488EldeeSX+/Oc/45133kGPHj0AMHNYt27dkM1mccwxx2DJkiUYMWIELrnkEsydOxdDhgzB2WefbZ175syZOProo/HAAw+gtrYWkydPxtSpU1FZWVnQ76iC1kzyBDdzGQYt9lQ0NDRKEFVVVViwYAFmzZqFnj174swzz8RDDz2kHDt79mzsv//+mDBhApYtW4YvvvgCK1aswNChQ638D5FMXn/9ddx2220YP348jjrqKCQSCXzzTfv4eHcbzYQQMh3AXwGEAfyLUnpbW1ynMh4GADSls6iK7za3T0Njj4SfBtGWCIfDOOqoo3DUUUdh7NixePjhh3H++ec7xqxZswZ33HEHPv30U3Tt2hXnn39+zrwPSimeffZZ7LPPPm04ezV2C82EEBIGcA+A4wGMBnA2IWR0W1yr0iSQJm3q0tDQaAG+/PJLrFy50vq8aNEiDBo0CABQXV2N+vp6AEBdXR0qKyvRuXNnbN68GXPmzAEA7LPPPli9ejXWrl0LAHj66aetc02bNg133303KGWWk4ULF7bHVwKw+2gmkwGsopSuBgBCyFMAZgD4otAX6p7djv3IKjQkj0SvQp9cQ0Njt0dDQwN++tOfora2FpFIBHvvvTdmzZoFALj44osxffp09OvXD++88w4mTJiAkSNHYsCAATj00EMBAOXl5bj33nsxffp0VFZW4oADDrDOfcMNN+Dqq6/GuHHjYBgGhgwZgpdeesk1h8MPPxwrVqxAQ0MD+vfvj/vvvx/Tpk1r1fcinMFKGYSQMwBMp5T+yPx8DoADKaVXSOMuBnAxAAwcOHDiunX5Jx/W3j0FzdvW4on9n8DPZxzc+slraGi0K5YvX45Ro0YVexqtQkNDA6qqqkApxU9+8hMMHz4c11xzTcGvo7pXhJAFlNJJ8tjdwswVFJTSWZTSSZTSST17urpOBsK6A3+LHtiFGQsuBH3kNKB5Z4FnqaGhoeGP++67D+PHj8eYMWOwa9cuXHLJJcWe0m5j5voWwADhc39zW+HRdwLuzJyOX0RnA6s3AKveAsae0SaX0tDQ0FDhmmuuaRNNpDXYXTSTTwEMJ4QMIYTEAJwF4MW2uFB5LIy/Z0/BPzInsw3r/tcWl9HQ0NAoKewWZEIpzQC4AsBrAJYDmE0pXdYW1+pRFQdFCLdlzkb9wGOAtR8Au4HfSUNDQ6M12C3IBAAopa9QSkdQSodRSme21XW6Vcbw4PksemJHz8nAtq+AW/u31eU0NDQ0SgK7DZm0J7pXxQAAm7qaIXmpBiCbLuKMNDQ0NIoLTSYtQHUZ64n8bfkIYPDhbGOisPV9NDQ0dl8UswT9okWLcPDBB1vXF5MeW4PdJZqrXVFdxm5bfTILTDgHWPs+kKgFKruzAakmgBAgWl7EWWpoaHREiCXo4/E4tm3bhlQqBYCRyQ9/+ENUVFS02fUrKirwyCOPYPjw4diwYQMmTpyIadOmoUuXLq06r9ZMWgCLTBJpNBCzGufd+wP1m9n7W/oCf26Tai4aGholjmKXoB8xYgSGDx8OAOjXrx969eqFrVu3tvp7ac2kBYhHwohHQlhSswvnvfEVno2bO758GZh0IXvfvKNo89PQ0AiIOdcBmz4v7Dn7jAWO964z25FK0M+bNw+pVArDhg1r9dfWmkkL0bk8inlrd2AXhH/S9q/zO8mO1UDNgsJOTENDo0Ojo5Sg37hxI8455xw8+OCDCIVaTwVaM2khulXGsGJTPWIimWxYlF/Oybt/BDZ8BlzxaeEnqKGhkRs+GkRbotgl6Ovq6nDiiSdi5syZOOigg1r7dQBozaTF6FrBwoMdmsmub1iYcFCkG4FUY4FnpqGh0ZFR7BL0qVQKp512Gs4991yccUbhSkFpzaSF6FbJyCSJqL2xbiPQuC34SbIZIOO/0tDQ0Ni9UOwS9LNnz8bcuXOxfft2y7z20EMPYfz48a36XrtFCfqWYNKkSXT+/PktPv765z/HYx8zW+S/xi7H1M7fAvMfAMIxIMvC/HDTLv+TPHY68M3HwK/bpialhoaGG7oEfXDoEvTtgG6mmQsAlveZAQw3G8twIgEAI+t/EkNrJhoaGvlDl6DfjdC10iaTdNYAOvVzD0o3AfFq75NkM4xQshkgLP0r1swF9poExNoueUlDQ6M0oUvQ70boJpKJQYG+44CznwKO/5M9KJWjLIJh1vPKJp3bd6wGHj4ZeKljPSwaGrsL9lTzfj7I9x5pMmkhpo7qjeNG9wYAZLIG27jP8cCBFwOn/oN9TucgE14cMiORScL0tWxdXqDZamhocJSVlWH79u2aUHxAKcX27dtRVlYW+Bht5mohKuMRzDp3Esbe9BrSWemh5DW5cpEJ10xkvwk1yYlortfQKDT69++PmpqagpQQ2Z1RVlaG/v2Dt9fQZNJKRMMhZAzDuTFm5p48/l3g5L8Cw49VH5zNsFcXmXByIgWbp4aGBkM0GrWyxzUKB730bSUiIYKMSzMxneZ13wJPfd/7YMPDzKU1Ew0NjRKDllatRDQc8jZzAUBlL/s9pcDnz9gaSdbDzGWY+zWZaGholAi0tGolImHiNnN1G2q/r6sBnruMvV8yG3j2IuAT00HP81BkzYTnqrSUTCgFnrmQhRdraGhotAM0mbQSTDORyKS8C/DDZ+3Pi58A7j0EWP8x+9y4BWjYYpepX/UmsPUre3xGQSY184H6TcEmlUkCS59lGfYaGhoa7QBNJq1EJETcZi4A2HsqMHqG/XnLMuCzR9j7UAS4Y7gd7TX3T8A9dn0dK+9EJJN/HQPcG7C6JzeTaQe+hoZGO0GTSSsRDYfsPBMZTVKDLC7kQx5BdM/+GNi4xDZ7EYkMmncGm5Tlc9FkoqGh0T7QZNJKMJ+JR/LT9FvV273I5PPZwL/PF3wmJhnIPplc0JqJhoZGO0OTSSsRDSl8Jhx9xgJnPOje7lsAkgqaifnvybcYJI8S05qJhoZGO0GTSSsRCSvyTESMngEcfzvQZ5y9rcmn5wk13NFc+ZIJz1/RmomGhkY7ocORCSHkJkLIt4SQRebfCcK+XxFCVhFCviSETBO2Tze3rSKEXNee842EQ6zQoxdCYeDAS4Cq3va2hs3+J5XJJN2c36S0ZqKhodHO6KjlVO6klN4hbiCEjAZwFoAxAPoBeJMQMsLcfQ+AYwHUAPiUEPIipfSL9phoNES8HfAiyjrZ7xu2eI+jBTBz6aRHDQ2NdkZHJRMVZgB4ilKaBLCGELIKwGRz3ypK6WoAIIQ8ZY5tFzKJhIm3z0REXCQTH82EUmeDLaDlPhNt5tLQ0GgndNSl6xWEkCWEkAcIIV3NbXsBWC+MqTG3eW1vF7DQ4AClrMUmWfV+Zi5BM+EaRrqFmomGhoZGO6EoZEIIeZMQslTxNwPA3wEMAzAewEYA/1fA615MCJlPCJlfqPLT0XAI6SChu8k6+33GxwciaiZW7a48fSaWmSu/wzQ0NDRaiqKYuSilU4OMI4TcB+Al8+O3AAYIu/ub2+CzXb7uLACzAGDSpEkF6YyjrBqsQnk39lrZE2j0I7ICaCbazKWhodHO6HBmLkJIX+HjaQCWmu9fBHAWISROCBkCYDiAeQA+BTCcEDKEEBIDc9K/2F7zjaiqBqtw5C+AH78NDDjQfxyldjkVVVVhv+5w2Qyw9Us7NFhHc2loaLQTOhyZALidEPI5IWQJgCkArgEASukyALPBHOuvAvgJpTRLKc0AuALAawCWA5htjm0XRMME2xqSmL92R46B5cBeE+1eJZ6gdqFHbu4SyUR2zot447fAPZNZD3lAR3NpaGi0GzqctKGUnkMpHUspHUcpPYVSulHYN5NSOoxSug+ldI6w/RVK6Qhz38z2nO/i9bUAgF88uyTYAUf9inVfPPBS9X4xadHIAM9fzsrWc3z9NvC2x1dc+z57tUKPibs+WDGx9gNWGr/Qvbc/mQXUrs89TqN4SCeAxK5iz0KjDdHhyKTUcM7BgwEAYULw+CfrUNuUAvUTln3HARPPByJx9X4xzySbBhY97tz/5FnA3NvV9bq41sPLtTRtA24fCmxYxD437wTqNjiP2fwFcEt/YJfSzeTEluX51wlb9CRwy17MBPfY6aw0fqoxv3P4oWELMOda4Inv+Y8zDHffGI32w/1TgdsGFnsWGm0ITSatxBkT++PsyQOxcksDfvPcUoy/+Q38+rmluQ/0KvYIalcHtsqiKJBqUBxqOF/5+epMovjLOODPo5zHzH8ASNUDK16CL9Z/ykrgz/un/zgZr/2azTWxC4iUec+9peBaXHOt/7iXrgL+0Mt/jEbbYdPnxZ6BRhtDk0kBUBUPOz4/Oe+b3AeRsHo7pUDTdvY+1eR9vMpkYHVulKK/eDkWMTyZg5Na1oe4ANaPBQA25+mO4hpYNglEK8x51Od3Do7PHgF2rHFu4985l3+I95IptIlNQ0MDgCaTguA7+/fHqL6dXNsbkxlkvep29Rmr3m5kbDJp9Cm7oiITagpWuZaXXwZ92CQTPy0IsAkg7v6evgjH7DlFTc0koSC1XDCywIs/Be4/zrmdk2DTNuDBE4Cd63KfR0NDo+DQZFIAjOrbCa9ceZhr+5gbX8MvnvFwzI8+Bbj8YyBS7tyebgrWBKt5B/Dh35yCmZu30pJG41UoMt0M1JpaVDZH1rxFJtX+42RwzSTVaH9XlYaUCzznRiZYTpSZBLDuf8Drv8lxnhykuTuBUuCLF+zoQI3g2LAQ+PjvxZ5FSUGTSYFApJwOrpE8+1mN90G9RrnNM9kUAApXwmF5N6dpbNGTTHC+/Qd7G191ByWTf1/AhA0QXDPh2kVQhE0y+efhwLavnOfKB14lYrKSU3313NznqVmQmzx3B6yZC8w+F/i/fYBtq4o9G4ZSue+zjgJebdcC5C3Dkn8D6z4s9iwAaDJpMwQq/gh42/qr+zo/R8ud27aYdSxFEuD+ANnX4mXmWvWG/T5XPS+uTeTyrciIxIRrmMcWkkzkVXcyR/jpxiXAv44G3r45/zmUGvh9bt4B3DeluHPhyLdoqYY//vMj4MHjiz0LAKVVNbikkApMJh5Z6tW9gXohjDcUYT1R6kxNZ+da9lpu1sFMNtj7XJqJhyNfjPrKRRJNpuktX2EQVoRAi2SyYzXTqHoM9z7H3ZOAcFS9L9/58Mi2jYvZKpkQ1nNmd0RYIPKWmBbbAn5JtxolDa2ZtBHqEwHVeS8y6S4J13AUqBJCWxNmKCwX1g9OF3wmkllLru3FzWEimeTSTJrN5Md8czVEzYRDJJO7JgB/m+R/ju0rbU1MRr7CSSTN/xsB3DHCe2ypQyRgr+jBlmDun4C3WqjZlVquj47+CwxNJm2ETbuYAA/lKo/FzVzTbwOmXG9vH3iQc1w4xopEykibCYBiHL8rmkv6rBLAuTQTLgRao5mETOFWuw64qTPw+TP5nUs5r5a2NAaLmvNroVzqEDUTryTZluDtPwDvt7CYt+zj6ugopeg/Su0E5SJAk0kb4f2VrDJwOBeb9BrDXvc7GzjyWqCiO7Dv6UDnAc5xoYhNJoMOBaKV7L0qmzwtbZPJRUUmuRzwqqKTQaDymXz7GXv9+N78zqVCvpFKXANbP6/11+7oEP1xYYWGWAyUWmRZe/cGevx7LGiiJVj4GDDrSODLVws7p4DQZNIG6FEVx5zPNwFgUV5/f/drnDXrI/Xgsx4DznkOKO/CPl/7NXD6/UDn/s5x4RhQYZax7z0G+PW3jHBSTcz+L0J2wLvIREEcucwPVtHJACvLtR8Aj8xgPgk/n0lLC1FSyv6MrJrc/Eq+8GgiLz+SF1JNrApAKYEKq+qOQiYlp5m0M5msfM2OsMwX3BS84+vCzScPaDJpAwztUYlNdUzIpTIG/vjqCny82qPgYnlXYNjR9mdC2F9noVlkl0HAsTcDMa6NNLExsUpWmuSfRzjPmStpUaWZ5BKu/Jh0MxPiH9zJnP4qPHMhsPpdlhOiKhvDncFByERls551JLD8v8Cfhqkdy34CK59GY5Ta5PPcJay+VENhmqq1C0QTTSHNXK1BLs0kmy58cdLW+D3ag0zuOYgFmbQWRfbvaDIpIF6+8jDc+p2xiEVCaEq18iEs62y+IcDVS4DBhwpkYgrxWGXhzFzpZqBxu3dOCv9RbVnOTERv3gSsepP98B87nVUzfuEK9sd73BsZ5+qYIx/NRKUJbVzMclaad6objflpT14lajZ9zr6biI/vBX7fnX3HmvnmufPselksNO8EPrzL/txRNJNMAqjfBGxbqd7/4pXA7UPyLyjqhfXzgN91Ab752H/cMxcBD5/i3i77TLwWUPliyb+BBQ+x91uXsyCTgqE4fYw0mRQQY/p1xtmTByIaJsEaZuXC9/8NXCGYVqp6s9eK7uw1VqnWKOSeKUHMXCtfB/40FHhgmnounIB2fA08cSZ7n6wHPr2fkcqjpwELH2V/1nUT6pUdDVhPC/DWmDihqn7cfmTidb5/HMYKWYpY9CR73bXennPOfjQdBM/+mP1fODqKZpJNAm//HnjqB+r9n/+bvRaKtFe9xV5Xv2ueN8m0gK/fdo5b+gyw5j338eJiaFcN8MdBhfG3/edHwH+vav15HMghc5pr21R70WTSBohFCnRbRxznzL8YdChw2izguN+zz9HKYCYBlZmrfpN6rOx/EY/h4ImBqQb/+mHpphzRMAFWUF7Cn5OISjPzCxLIx1fCQ2uzaaGIZonY/GskgeeVp9PeyKRYXbkGj+dPrOUWFDtWM8Gsyq7nixkeGr1zHdMCXvlFsHOLi6H6Tezz9uL4JAJDlW6wcy0jwk/yrPqdBzSZtAGiYfVt9e1zEgSEAPudaZu7YpXAti9zH5duAubdZ3/OpliJDS98OQdY/LTTFKHSZpL1/v3suX+lqo96v+jbEAVBYhfw6b/YKspLqHASSSmy6Vti5lKBr+YzSVuolEoGt1wINBwH1v6vTYVJIGST7FlK1KlNWTz6L5+eN8/+iJmMNix07+OaBU9M5Zpl0JbWIpnw56qjJIDK8sRPvvDuq1++0mbT0WTSBvDSTDJeFYRbClGLGHy497h0Anjl/9mfc+WUPHkW8NzFwN8OEI5R+FmS9f4O6Uwz+zFz8nPtF9sRCwTw5Rzg5Z8D21d5CxVOIqr9fg542Z/kB76af/EKO0mUO5DXfchyZVQCTIRhsFXhV6+zz2veB969LfgcCoVIHHjoBGBOgBX5goeA+s2tu56RBd7/s9sMmUnZ9edUpW/y0UwMA/joHvsZUBEEJwOryoH5G/Qzsf51vPt4wH6ugla93vR5sKZzLYWnyVX7THYbxL3IpBB+FBEH/Mh+f+QvgZuEBlQckbJgSYtKmPOlVE1AOc1czezHGC1X7xc1CMd7k2QSdd5CJdlCn4lKM/Fa0XHBxld14txWvMxe15iFJRs9kh//Mhb4637Av89jnx8+CXj31vaPvJEd8PMfAJ5TtI7euZaZjJ65IL/zL/2P0/zzxfPAW7+zM+W58M4mbUJWNTSzyCSABrniJdZ8besKc4OKTLhmYkYVWgLYQ+AaWWDnGudnDj7vXPXfOP5xmHNBlgv5PhNBEyp/38s267U0HD8ANJm0AbzMXIHrdQXFQZcC3fdm72Nm4ylZaFT2dJdTybcUhpGF0rmXbPDv683NXF7OX1EzEQmAE1eyzluTsMxcBfCZeJGPKgKKjxWF1Ad3sjDlO/d1ZyCL9dJEs05790OXv8tL1wCLn3SP46vufOf3zAXAPQfan7lg5IsNLswzSXsxk1CRiakNBtFMAmkvks/EMnN5iD65C6iDTIRFDodIAAseYk56cW75aML5+uOChi1nk3a0WFDzXgugyaQNEPMgkzP/+REe/8S/edO2hiQufXQB6hMBq/Oefj8wdArQazT7LOd1VPZwaybrP/E+37Rb3du8NJlkvf/qKN3EHvhwDMqVoINAhPf8R5Ks9/GZNNhjXOeVyET8wavIx8uUpnJaP346CyG2zCcRFiYNsKivl3+uPhefF///eGkyrUE2zaKWVP8Tr2KWRhZY8LBN4JxseVfMIOAkKVZR4Mfz/5/V0TMF31bLnPT+c7F3xBeHLBhVctKqQ2e+8u/pJVTlZ8Fh5uKaiUkm7/6RhR2vfpd9l/9eBTxyKttXu95/7irk649zhd0H0Ww0mZQUoh5mrhWb6vHcZ/421L+9vQqvLtuEZxb49EER0W88cO7ztinJpZnk2fe8y0D3Nv4jOua3QH9BbU81qPNIONLNbCUYitiCWSw4KP5wxWQ2SzOp93aYc/NWkDwTUSCoNBOvnvReuRn/u0thizfhZdIDmLDg+UN+gQstxXu3s8oDPAxWhEio4vtFjwP/vZL5HgAhhykPMlEJQd73ht9vSzNJ2P9fP82kroaZsXwhCUaVLOXP59fvAE+cZc+1JWSSkXwmPPjlm49tjYdrYrXmolFufueHfIuWemkm4neTTWdaMykteGkmABDKUauL/6892/3mAv/Rct9JZY/8jlcJEW4Lj3dykk1QzYSE7CKPvGwM4BTiu4SVnLgCzJVnospHkMlE/JGqyMmLTLywY7XbfMLht6JPN6vJJJtmRJBPBJMK280GWLw9gQiR9EX/F08wrTPbHXCSjnoETaigIhMuxCzN0nywjYythSo1kzzyYWTBqFrY8P/TmrnAV3NsjZCEGIG+foNzvJ+ZKytHc/Efq/B88Z8tbwQnVvpurvXXSPPVTHiXVOva3Mfp11pCk0lJwS/PJFfdx7D5A2mxf5Y/kBUmieRLJrIw3LKcNZMC2EpdXHmnGvxXU9xnEorYveZ5wqWMx75jv3eYuXKQiYiwEMorQvyssmF7CXEvGzbvwQK4BVi+mkk2A7xzC/DOTPbaGnhFQlX1Br4Siv+J/zMrf4b7A0xfSV6aiXCf+IPL/4euhNlMDp+JT6b+TZ2B14S2zDKZbFtpB0RwcH+hFYllXpOEmAa38nXmKOfIRzPhZr1MUiAdM1iFV1Xm/YYA4I7hzLfmhXx8Jok6dxklDpFA5MhG7YAvLfhpJrmqRHDNxWgpm3Dh23kv9uDIHRtzQRaGYlZ4OOpcsSbqnKspVT97I8NMQVwz6TnS+9r85jgc8B5koiKxeBV75XNa+h+2GhR/XCrNxKvzo1cIdTZlk4gcJsrJuHY9sEKK6U83M+0OsMnk9euBD/7M3jfvtMdu/9odOJELnLDleyYLaPHe8fnL/gCVhrX0P+qKtuIzwJNoLTIx58Lvl5ERzFy7GPm8+Ttb+5X9VEbWGQzw0d+EnRKZvHA58PDJzm0ymVnaEGFzSTc52zc8dKJzvLhYsPJMzOeF50Zl0/b3pZTtb9pu7hPNt4pn9lahOng+mkmzKllZInLAXQtNm7lKC9Gw9z8snYNN+P+6xSkpfOUx6SLggleBTv28x571hHubn5lG1kz4D4ajrJPzc9rMMxF9Jjz6TAW+ijIC+ExU4Pksnz0CLHqCRRg9d4mTLFSl9r2S0LzyVcIx+wcrr675/bnvaOCps537RGHBhafYOjmTYFrPTZ2Bu/cH3pBMMLkQ9kj4k4MyRGHDM9EXPwncNsiujKCKwHvmAnVFW3FFbWlc3KFvCnNDIJOMYObavoqRKQ+dlsnk5m7AbQOBLSvgQhDBKGuinJgIYXPMRdh+Dni+T1xcpOqdWnMughCfvXzK8/tFsqlyYyzsZmRCCPkuIWQZIcQghEyS9v2KELKKEPIlIWSasH26uW0VIeQ6YfsQQsgn5vanCSFFr2gXi3h3tcvVGz5EWqmZTL8N2O/7wN5TgYEHejsAj/09MPJE9/ZohbfAD0edZCObeLgJZ/IlQHU/28xFQrZvwa9GFP+BWCtXM88kVuV9jAi+6t/wGfD8Zez9jjV2eK4XRI2Ao2Er6xev6lBopO05ynZ/K1pLkX+TbraP46thkSwzSWcSpLhiDgKu/ckE56eZiGV1ErW28172hcn2eRGiwOTXljUT/tmhmdQqTIwewq6lZdVloSuaubxaGIhwrPLNsakGdixfmIiaCeCsAKwiCK/ftjgXSv2TI1X5VbKJEWjX8j/F0kyWAvgOAIeBkxAyGsBZACvbHQ8AACAASURBVMYAmA7gXkJImBASBnAPgOMBjAZwtjkWAP4I4E5K6d4AdgK4qH2+gjf8NJNMlmLl5nrc9OIyGAr1g/tUWlx6Zf9zgNP+DlSavolomXqc6AgXES1nGs35rzBSEBGO+dvSuwwyXwcyM9vWL22fCV9FhiKMyFT44E5ngiT3meQiE+4fUo2j2dxZyDsV4dr3Hsi6MPZXJJ1lUoKPQRLcfj6kTMIWQNu+YoJOXMVmU3AI065D/Octg99jWWOUyUQksPqNzn2bl7JXWYNTFTfkWrYosDi5cjLiwtwyc2WdocH8PvJFj2fuhOI35ZUBzq+danSTVbNIJmmnSbDbUPe5xIWGSAzJOvs5zSahdNSHY2qy8npGxLEf3QPcNsD97C75N9NcVbXNRHLzutbuZuailC6nlKqKSs0A8BSlNEkpXQNgFYDJ5t8qSulqSmkKwFMAZhBCCICjAfD+rw8DOLXtv4E//Bzw6ayBK55YiIc+XIuvtza4orZszaRAk/EyW8mZ8uL4qp6s5H282rkvHPV3MB94CXDin9nr8OOAbxcwYSWGz4ajwKFXApMudB//4V3A1285zVzpJv9rAnYHynDUrUkYWaAuB5mIGe6cxLlAVpFnNmkLKVkz8StVk262f9w0C3zzkWQSSTrNHvk28OKCWy7+KZuORAL0KpsiF03kJfhFUMl5D9jC1xJsKbOZmZCLIjrg+Zz5oseLTFSmSK9IwkyC3ctb+tnkyJGQfCbi9coUC6xnLrQTUUWTUaLOaeZSzTtaIbS7Fo718tGJ93H5i+xVjHJMNwOvmHlMPFpMBP+fzb+fmSwpdWsme5ADfi8AYrZPjbnNa3t3ALWU0oy0XQlCyMWEkPmEkPlbt7ZdkyM/B3w6Sy2yOeGu9zHs104nLWmtmUuGF2nI5qZJF7m3u8gk5h8yGqsCDriICa99jgerv1THtBH+fbgphkdehaJAn7H2OdIJ+0fBkxa9antxiBFr8velWZaVHJO+i4gdQvkMmQyUZq6MTQJcOPHaaLk0k2wa2PtYdh+X/1cK40zZNv1eo9XRToueYD4ElSDlwqhBMrHJmom42k43sqCI4/7gzEmShSMPOxYhR4IBbjOXOA4wfRTms9Bc606S9CIIVUa+F3GnE97mK0szIW7CtHoISfjsYfYqCuYvnmeLAT4P1bxjVfY8xEWHyqwK5M7onzXFvg+qCERO4Ild7P8gJoi2A9qMTAghbxJClir+ZrTVNXOBUjqLUjqJUjqpZ8+ebXYdP80kkzVQGWcCStXzJNRaB7wMr1U9NyuccAdw3kvs9fotTjVYRSbyNse1BEHee1+7jz0J20KTr5J5ddhYBTDlevs4QgRHZz370eTSTKrNqsScuEQYBtOOugxwH8chaiayecdTKJkCgQuJI3/JhLJvkckmJnji1az1slzKPJNkK14SYoETKgH6+vVs+y6FH4gLZrnRkqyZyNpURQ/gkJ8CPUbY24LcByPDBLKoXfFzi4LeK2k0UWvb/vkiQBUgATj9B+lmRpheWkwm4SYK6zzcAR9yH+9FJtzEJ5LJG7+133tpJrEK9n3kiDQvMhEJQswZ+et+zLS1VWjeJvtTVPXzMkmFZlKCZi5K6VRK6b6KP78Gx98CEH/1/c1tXtu3A+hCCIlI24sKr9pcAJA2KKriila2JkJWnkk7aSaTfwwMORwIhdzaSlyKzgpF3RFbjnMKQp8QYMBk87iwHcrIk7i4hhOKOq9LDcHMtYsJjlylPYZOYa+qXixGhv3wxPyWYUfbxwBsdc5JSBYKXqYmLjT5SjxazoS2r5krwQRPOMa+szw2m2KEGK9m+QnNtczvtO4jeww36YnFCMXzq+AiE0mY8QWCqAFm06yBFH8OVStcmgX+PJKZgjgSks8EcBIEX33HqpiAtUKRc/hM+HlDUeCJ77GcDa+xa97zXpEnJJ+JCC8y4UTgtVAQWxSI4Pczk3RqmV5koiLsXTXqJFTZL5ZJ2ImnHNnU7h/N5YMXAZxFCIkTQoYAGA5gHoBPAQw3I7diYE76FymTuO8AOMM8/jwAfmTVLsjlM6mI+ZEJey2YmctTM/EgGRFxyaFNjeCaCWCPDYXtHwrPe+HJXNmUc45ixJOlmeQgk4Fih0S5x0OWnaess22yila4NRguSBY+zlaB1nyEH/jgw21zFheCXNBEykyHa47+89k0E+7hqFvgcc2krDP7S9QC90wGHpxuj+FkImpT1vEJtRnSz8wFABXd2KtIJiteYt0zlz5rz02GkXVm8pOQ4ID3yO3hobqdB7DnibdKjnj4TLiNn9/ncNROTPTSGp+/zC5nIkPUylyaicdCif+vMyn1/W3awXqqyOBjM4lgmolo5uIaxFaPfkUymbz0M3dDtGxKkWeym/lMCCGnEUJqABwM4GVCyGsAQCldBmA2gC8AvArgJ5TSrOkTuQLAawCWA5htjgWAXwL4GSFkFZgP5f72/TZu+BFBJkstM5cKpNAOeDHCaYQglLyivESEpBVtJuHWVkTIQt/SPgTBzU1SnEwyCSexLXzUrslEDfajyZWNXdYZ+MGzwKX/c+8zTDKJVwsmNkV4Mic+nkDIIZZrOewaYOx31XOIljM/kG9FADOaKxxVR/pwB3y8M3MGq8xc/P5vWuo0dWxbCax93+l/4pCJU/bFcJ+TyjfFhb1SM5Giqar7Cg54QVCLZjBOLHsfw1553oqlGUq+B/5s8Hshfhe/+mZeVQ04yal8Jl6lXBK7gA//xjRfVUWJLcvUocuiZqIKUpCxcZF725bl7m2Am0y4w15EJqnIgN/NNBNK6XOU0v6U0jiltDeldJqwbyaldBildB9K6Rxh+yuU0hHmvpnC9tWU0smU0r0ppd+llBa9r2pds/MhPXGsnYWezhq+dbdanWciIyKsSo8VSs8H0UxkYVHZ018zEc75n89qUNNkPl7iaoj3sffSTORyGA2b1NqV6BiPVQLDpwJ99lV8h6xtOpLrlong30tOkhRXi5G4d56MZebyc8A322aucFQRCcY1k06MdOX7X/sNy6EBzIgdwfL7iOmKjCjSrOTVqCzMuLajCq3mq/Jsyj/5EWAh4TxkVRTUYvQSv599xrIOnE3bnOeSz8m1KotMwvb/3q8xWy7Hs2G4ryV/PxGv/wao32DfqyDgiyCxuCXg3e1y2XPubZs9co3kKDVVGRqVZrIHmbl2Cxw0tBsGda9Atekbmbav3bY2nTWQyngnLvKFw4MfrMW2hgLzYjgWLHmQo98E9vqDZ4HLPgJ6jcxh5rKF/s9mL8ajC0xBIf6Q+HXFmkV+c6GG07Qw0WzaJJrg/IjRMGzNJOTz3Xm0l5wxLfpMwnHv2lHRctMPkkMzyQqaiVwSI5NkfqJ4J2D8D5iGwkEpa7Ql54XI81Tl1LjIhPsNzPvBBaSKtBOCiUfWXGQtosdwO7nRSzPh8wzHnM+AFWYr+TFUmgn/3/s1ZhM1E1XirpFx+0zCPmTC4eczlCFqJuL9UPm7ZPDFpJgs6mcVUD3TKs3Esztj66HJpA3QpSKG966dgpF9mYASQ4UNCiTSzn+o6GznGkkqa+CapxVqb2sQiQumngClsat6su6Nw6cCvc0cUVFwDz0KGP9D+7Pk6G2CUHhRrsklJk3mmoso5HqPYa9iqK9fyW1eJj9ebV8nUuZW971IspMQaR6JeRNfpJwJyGzaO3Od+0xCUUZMsnM/k2CEEy1nq9puQtKiF0m9dA0jSz5PlbNWLpPPNRP+nbnpRmUCEZ3PsuYiVkAgIZb017zTzMEQBHXSg0zEe2lpJrKZK+6cRyhi/+/lEGgR4r1VaRNG2q2ZBNE6YpUIvLoXfSb5huiqKiB7JRoD3pqJfN2gDbVaAE0mbQgu1+Q2vo0p5z9UDBEWs+LrEwX6x3MhEIoKeR6Kxk9BIAqcc18ATr3HNYR/hyZqEk8mAVwyF/i1sKoWV6W5/DfiipgLxly5Jxb4P6HaXtFG4nAJBBWZnHAH8MP/2J/DMbVdPRSxiTqTdFahFZFuNn0mMfX9z5j5EVyAisTt5QOY/wCrNsyj1UTy4/Ayc/HvXKHwA3BYzuek+54/KlR6DsftCgi71ntrJrzkvSeZSM+8i0yi9v/Rj0xEc6VYBl68nmiKG3E8MOY09bk6C+bEeKdgJmLAJumVb9ga16FXBTtWpUGIvxkZXpqJbOYK2uq3BdBk0obgtCCHCjelnP9QsV6XWLrLryxLXjjzMRaFVN4VmHoj2xa03lULUJ9kP1JbMzEFpOhIF8Mw89FMuF1bjjTLhXgnQTNRXE91vokXAJ2EqsvhmNMnUc6joKoYyeZywPMVOjdzqdC0w94nCojbfUqrrHmfrcRDEeCCV9z7ZW0tUcsEYtfB7LNXSCzAMq0Ng30vmUzEfJZomU0mtd84hda7iu6d8Wrn99uxmpFwvRTeGooAIDaphcL2s+tr5hIITEkmWSdxTfiBd9TgNUuBAWZL4lhVMBMxAAw6lP3uFj5qk4mfmVhEvmTiqZnIZq62I5MARkKNloKbrORQ4cakrJmwB6c5lcVXm21npV++Sl4YNoX9ASyvZPKPC3NejuNvB9Z+YH2sa2Y/nGaRTGRwDaOsc24tSfyRc80qXzKMVdk2cb9oLhGyDT0Sd2om1X2Z34Pbsrlm4gUuEP3IJN0okEnAFfCWZWwuI09UJ2fKgqm5ltn+z3gA+PIVpzlNRuNWYONCUzPxuefhuN04rfYbp+9Dzp7vMYIJZ/H7fbtAfV5i5j9ZHRJD9v3xM9mIZi5O+iLkUiqhqP9zyJ/BeHXw/0s4yjqhrp9nLzLiPsTtmF+ByMSlmbSdmUuTSRuCLwgjYYKXrzwM76/chtvmrPA0c13xxGd4a4W92ioYmRQaM+51ahkHXsL+TNSZ/esTMB9wLwF70RvMLJMrXNFBJuYj6ynYPKLg4tVC8EEZMPYMYOVrwv4AjtVw3KmZVPdhgpzfi0hcXYCPgzuzvcxcHJzsgoRvA4ws6r4F4lO8Bjg/GmmmZVT1Aiaeb2+XNY9IGVvBL3qSrWj9TIuRGDPrRMpNzcRHaA0+jCXJ+jXCsmBqfJxMdnztXdtKhGjmErVLDrFsPJDb+c5NhfEqdcScCqEwq56dTdpaVFDNRHX//MhEVTlA5YDXZFKauOmUMbjxhaUY3bcTyqJhfF7D7L5NSbWZ64NVzpaeBTNzFRoTfuC7m/t6QlHBZ6ICz5AHWCXh9Z+wh/2rV80SLOZ9ilUAVy5itnje9jRfM1dVbyE0OA6M+x5bzT98knkN6Xx7TYILEclnYgkp8/+USzgmhcQ7v7H5aCZlnU2Sot6rXlWYeZ0iKuygy5lfZ+sKVjesc3+g3/7MLwPk6HUTZ4uCLgNZwqCvfb/M+eoHAnbfRZnoZ97i+NI0953zvEeCpyRkucY77RaW+b/qTekAwfcWtLUwCdt5VbVmacGg0WBKB7zPPVX1/cmm3PW+tM+kNDF+QBe8cMVhKIuyFTHXNNyaCSMTObckEirNfw83c4W5ryNIT4VDrwTOepz9mAGnthI1I5uGHGGv6Lnw7zwQOTH+B0DPEe48E6+ilqf9E/jxW+7zhKU8E6uLpfl/y2Wu45pJKOq/urUc8AqhddDldlFOgDnPeU0tz1WvgkxUK9loOXD09fa9jZaz6DmL1P00E3OuXQYyImqudSe9cqh8Qp4g3udRYca97JVnwHcZqCZBWcjy/93BPwFGneIez02FsWpnDTM/hCL2M8Kr/wY1z4qmSf7cqqoac+z4mi0s+o63t2WS7ojBYpMJIaSSEKbnEUJGEEJOIYS0MBxoz0XE1DTk0GBu5pJzGSMF0EwS6SzqEz71otoAdaZmEolzMsmjHSn/sYnquMrMFa8CrlsPXKHosyFjwjnmsVKeiRgyKwpirxV4OObUKPiqky8Ccq1Yk6KZq4WaSVlnOMghFAEGKHquiMg3AZbf42ilk0B8fSbmnLmgXf6iN7mpyNwLhNiZ7n5JhRw8dFycl6qCgvxMioQlh1IDQmhmNesX1H24OT/vahbMzGU+IzvXsWvkKlpqXU+QEfx+uTQTST70Gu1s051NKjST4ocGzwVQRgjZC8DrAM4B8FBbTWp3hZcPhGsmcnFHv1L2QXHqPf/D2Jteb/V58gHXTBrLzR/S4T8PfrBq9auK5opVMZOB/OOUBWe//W1zmpVjU+Y8F+A0m3mVb5GLYVoho9R77o65CZWT/ciEX0M1Rv6+hABjzBBdL21HFRnEo5NU4PcpWu4kVr+yNnzOU35lb5PJhOeH8HkGNRdxLarnKPe5ZMjaYTgWUDMRngUVafF7GC1nhL7fmeZ2n5V+KGKHbDduYXML6rwXhb4XmcjfKxx1+tmyaYVmUnwyIZTSJrDuiPdSSr8L1g1RIw/kIhNZMymEA37FpgDOygIjY0ai0Eg5S3oc//3gB6t++Mo8E49V8nFSF8cLX7OPkYWE+FnMtfDzDfAfdrTCPoYTWFB7eHkXf5MYJxFVUT7V3PY+Bjjvv8wElgsXvgZcvxW4YI73GIuwK50E4keWfM7xatscEzXbC1z6AWtvMPhQtj0fzURcfXcfZr9X1cgC3CYxudW0BenHFvIgk31OMIeb4/n/hL/69fchIec9y9VczjE9YX78fsl+QjloIBy3yxUBppmr4/lMCCHkYAA/APCyuc1Hv9NQwctsta0hiaufWujaHgp1UAd8DnBSJC2pAxQKmfkwN9nbHJqJKSy8HPAHXMQIzBov/OC4SYKvzsRVopjs50cmZZ2Ak+8CfrrAFhR81RokIoxfK+yzOrfIRHH/ohWS9mWOGXKEt6Di8/vOfazCciSmNuVwhETNJKCZS8zlsMyIEeDIa1kdrkjcFmTWdw8QFSXeg66D7PdeZKLSTHIVCgWcJMSJYtjRwPceYe/5QkEm+kkXAD9XdD0E2PcPhe3nKZSHZqIqQSQfK5vYwlHbrAZ0WDPX1QB+BeA5SukyQshQsNLvGnnAy2x199ur8PyiDa7tWcMofH2udkCri1T+ci2r0MshCjRx1RwEYhBDSCITnrQHOPud5Dr3xPNY8ypuUuC5HWLyn0hoh13Dmk9xiGSiEnTWit0UpKLDPVoO9NzH/qwinMs+BE652/5sdbkMuP7j96y6TzDNZMTxwAl/sj9bZOFRGDKoQAWc2pko8L2y9lVkEqR0UFhBJrFKe/vJdzEtyzIPCve9WtAGRMhadDjmJHzxGZchhvT2HcdeK3uyecjz5DCyzpIwb//BXXW4DZMWA5EJpfQ9SukplNI/mo74bZTSK9tsVrspIh6axsJvFO1ZAcyeX4NJf3gTyzYoSpF3YFhcUijFSvwB8vpEVX3UY/0w9Ej22m0oexWFq0g6smZy8BXMuSmj62C22j/jQfZZ1kx4styY02zTD28wxgWuSguSNRPx+0crgMmXOGuiyeg9Btj/XPsz10yCOLABuxpvt6HO+XlpbFN+5bTn8/nL1+OCzCJLadGhJAjCasD1GuOMQBOJ+8zH7fcqM1eQ0kEODda87+KiqKon07JCkpnLb+EkV2sIR5xEOu5M72PFCMgZ9wA/eIaZ+SaeJ5zffH4PvoK9Ghm3X6XJmW5QdM2EEPIEIaQTIaQSwFIAXxBCrm2zWe2mKI+1zDK4sTaPaKgOAKNgzVhMiMK01yhmgx90SP7nmXQRcPVSlpXM8cNngUOvdo6TtYVpM4HLP4IS475nN5eSfSYTTIEfEuz2fKwfmciaiYNMyplA4xUNAjE210wCBmDyMNZuQ4NFc8l+A8vMJV2PZ3Xz7y4LYtGMJeLcF4DLP3SafsR7Muok+71MHIS4t6kKOjrGBLinXJD7VeElOTQTP3IXo81ilcDwY91jeG8dHghiZNTZ/iKKTSYARlNK6wCcCmAOgCFgEV0aeWBoT/vHmE9CYueKYELg49Xbsb0hia31SXxZBMc7h+0zKRBkU06fsS1r8kOIu9zI3lOBY3/n3ObnVPWDrJlM/R3wo7dZxWUewdSpH3u1yERhguF+FP4dRd+CRUZR5xg/5Gvm4gl2co6Gl5lLvqd8bvL1LM3Ew8w16BBg2q3MV8Ehfr9clXc7D1QL6M4DgAMvZcVGT/w/4ACxnJB5fofPJMA9tUxMfpqJ+f2tjqNRSRv2+X8EKRV/7M3MJFxlkqORsat7i+BhzAMO6hAO+KiZV3IqWLvcNHzvooYKYu/3iYN8slklZLK5bzWlFGfN+hhn3/cxjrvzPUz7y9ycx7QVCtbYa0KR1is+CYXvfbUVj3/i0RJW1kxCIaD/RPaeV73lpg3uT1Dl0FirZIW5hedxBCpFwpGn3fH0fwGjTmaFG0UC8SoIKUdlcTKUNQLLZ8LnLj0n8c7AwZc7TZji9UXTj7zCvn4rcOVnapMWIcDxfwT67gcc8COnr4wLelU5Fb/n2DJz+Qh9ufSPfI2gZkfP84eZWYsvfrJp9j+6aZezq+rwY9m2nvt0CDL5J4C1ACoBzCWEDAJQ53uEhhLcbTK8l3+NnrF72T/cjKromwT+3H+1uQE7m9LmtuLwPb9uq68+429Ycen6dk+6lFHblML6HSxe/7wH5uE3zy1VD/SLdpp4Acvu56ti/qNWRapx4axa/UZkQR1EMzGk8+XAwANZpWkxEgnwNkPJ8DRzSZqJ/HxyMuaaQecBrBoBh2jmkoV4xKx3FsSU12Nv+72lNYg+kwBax8CD2Ovw45zbbxT8n5ZmIpi5AEa2ky50XnPcWbnn7QVulhUJ9vtPA4f9zHndUITVjnv4ZGePmQIhEDVSSu8CIIQRYB0hxKuqnIYP3vr5UdhSl8Bryzb7jhPDiINoJlkFcTSn7VUIpdTqL9/W4GauQpDZ9L+8j/0GdMELPzm01efKiQteBTa4Q7SPuuNd1Dalsfa2E/2P97u/Fd1YqQ4OnkwWrWACsNtQoH4Ta6DFf/w8cqi/WSesv1DLzHLS+08JgJAjEWCsDK+SMxwqJ7JV8kbyB3FhF/ZwwPPzcyfy1Jucoa6iA56fS3baBzHlcbOPeM2Qwmfi9/z23Q+4Ybtb2xCfAVkz4de4wawtJvZjOfhyYMlTueeuQlRBJoCdDc+1Yr5/y3LmF+s1CoVEIDIhhHQGcCOAI8xN7wG4GUBphRl1AAzpUYkhPSod1YFViArRRalsbs1E1Ve+tsn+8RkUCOqmWb+jCYtranHSuH45x77z5RZUxyOYNNh2/HEzV6EUo8Xr1dFuBcegg9mfBPE+5sRxM+1QTj9wgdp1EHD9ZgAEuMNcMXMBPnwq8P9WMZv49VucmkVbmrlE+BHkXpOAU//h3s6/m+x7EisA8OMBZrrb9pXtc5ryGxY+PeY7zuNFn4mRAX6zCa7vJM736OvV8xbNkZYJSqXR5HiAc1Yalnwm8jVEzcSviGMucO3W1TnSDHfnEV0bzc6tp9xdcCIBgpu5HgBQD+B75l8dgAcLPps9CKEcWkI4lJ9mIvop+KlFIRjEVMZx9dOLcMUTC1GzU1GJVMIFD36KM/7hjHTivNZa30mxzHStwiFXsATCXBgxDTj5r8AxN7LVdCgkdMEUtAHuXBVbLgPCStrnOTr7KRZSamkmrdBMvaLOVMVIIx45NNzMxbWHUScB13zB7gVgC/lYBVupy+fea6JwroyZVOmTs3KET8Apr7A8YhorBCpqNIXS4GUHvGxmFD+3NOgDsJ+FrLTo4Ym4nLQ4mXMTXYER1AM0jFJ6uvD5d4SQAjco37OQ63kVf0deRDD3q634ZM12XDttpEMzqYpHUJ/IoLbZXsmpNBcvcCJ7aclGXHrksByj3SiUz6QUuSQwCHH2EgEE23YAU42V7+DzIO1zPHv90LRQB/WZyLjsQzuc9pL3mXD6+8HA5IvV473Cnnk0l5i53XkvIR8jRwWBQ64CKnsBL1yuzvvJB4MOAb6aA/QZBxz5C2lnADNXEPD/Da8O0LzDuV/UTHJpOSKuWuK8t/xY+bkZcCCLjuMhxGc+Bmxc3DotyAdBv0EzIeQwSukHAEAIORRAc45jNHzARcAJY/vgj6ePw73vfo2/v/u1tV/sC5/20EzOfYBVzL122khHY7ZOZVHUJzLY5dBMgv8wOpWxx2JDbcv+xVwjaW26Sas0m2uWAenSys+xNI8guQD53JvWZpGKlXi5Ce8mHwu3mEEugn8vV40083vnqm0WCrFeOj1GAHvt7z82F065G3j7ZrUWaRF0gVYzPA+kXvKTOshEYba8/BP1PZEDIboOYblScvQjIUzDs8YNdkayFRhByeRSAI+YvhMA2AngPJ/xGjnAn9cx/TqjuiyK7pXOh0nsC5/JGsgaFItrarF4fS2e+OQbvPGzIx3jRQc8D0GubRZ8JnlIdh4Nlo82I6JQDvhWkVHn/q26dlFw1hPAx/faGfq+yIMgCmHmygdWpJqkmUy+GHj1Onf5EUszCdjSNlfJ/SCo6uksOaNCoVRj/izKTb38yKS8G9BrZLDzE+LOlSoCgkZzLQawHyGkk/m5jhByNYAlbTm5PQFc4HYudzrnRDJJGxR/f3cV7njdo6AcnIK/ytQsaluomexsYuaxlmoGhXLAFyxfpVTQayRwyl25xwHCaj6IAC50fZsc4FFXss/koMvYn4zqPqzcTNCqy22OAmsmYhFREX4JjEGrC3cg5GVEpZTWmZnwAPCzll6UEPJdQsgyQohBCJkkbB9MCGkmhCwy//4h7JtICPmcELKKEHIXMeNcCSHdCCFvEEJWmq9tYxAsMOSKul0rJM0kYz/ImayB5VJGu7zqFwVv1GrCZYcG56Nl7GqlZsKn0noHfKsO373RZyzLsP/OfbnHyuXT2xqWZhLQqTzhh8BVi4PV0GoPcFPepAsLcz4vkvTTFPMphtlB0JqnqzXLnKVgvVFUadpfU0rHm3+XCtv/DuDHAIabfzzF8zoAb1FKhwN4y/xcMuC/8y4V3ppJJktdN1sU9JRSx2fuPxEd90GJgVJqmccCRCQroTWTVJWkVAAAIABJREFUdgAhwGFXe1esFbGvGWLbbUjbzomD+0aClH4HzExun5a07Y3qPswnNDJHXpGI3mP993/vERa84IcjrmUlUgD/NggdFK0hkxb/0imlyymlXwYdTwjpC6ATpfRjypbkj4CVdgGAGQAeNt8/LGzv0LAKk5qfZTIRc0tUeSaiUz5rOMmEk0hGGhMEdYmMNba1Zi7V8Ss31+OAmW9iS11u57h4/M7GHHWZNLxxwI9Ynkqn3HlDBQEPUQ3aSbHQGPvd/Lp7FgI/fgv41bfe+0fPyJ1/dLRQ4t4v5LmDwpdMCCH1hJA6xV89gLZ6MocQQhYSQt4jhBxubtsLQI0wpsbcBgC9KaUbzfebAHgu1QghFxNC5hNC5m/durXgE28JuLzsXun84bk0E0klFgkmY1CHFsA5RCScoD4TsXRJax3wyYyBhqQzMumB/63F1vokXv/CvwKAeB4AmPD7N1o0Fw2wlUugroYFghW1VaT+eaf/Czjmt+17zUjcu2FbLoh+L97Manczc1FKqymlnRR/1ZRSX+c9IeRNQshSxd8Mn8M2AhhIKZ0A5pN5gjv9g8DUWjwlIKV0FqV0EqV0Us+eijLU7QjZbNW1MoaHLrCjVDJZp6YhjxfJJmtQRzRXlmsmLTBzieNUJVqCgPtz1mxrxL43vubYF5I0siDnKQXUNqUw+LqX8dS8b4o9leLD6qjYQXwgHRkXvsZCgDl46fkSdMC3smylNyilU1twTBJA0ny/gBDyNYARAL4FIMZ69je3AcBmQkhfSulG0xzmX6ekg4EKYvWQYXadoVTGJoK7316FyUOcfQrSkmbiMHOZRCSbwoIg4/C9tFAz8WvxYAXKBMnqb9Hli4KanWxF+ejH63DW5IFFnk2RwaO5WlsVd0+AnI3Om6j1yeGD6YBop/COYCCE9CSEpcearYGHA1htmrHqCCEHmVFc5wJ4wTzsRdg5L+cJ2zs2TKkqylSxE6PsJ5m3xpk9K0Z7ZQ2K+Wvt/dzXkHEQTjBvukggLTdz5T4uyJlL0QFfglMuPKbexJLj+gSoUabhxKCDgXOeB476dbFnkjeKsnQghJwG4G4APQG8TAhZRCmdBlZI8mZCSBqAAeBSSimXkpcDeAhAOViDrjnm9tsAzCaEXARgHVjtsA4PVShcSKzHlUOQpwVyeH/lVlz3n89dx4qEFLQ0l2jaarkD3ntfSEGi3ucpvmTeUp9fFn3xZ9wBMOgQFuq7p+LcF4C6DS0/3uqiWVooCplQSp8D8Jxi+7MAnvU4Zj6AfRXbtwM4ptBzbC94CZ8LDx2M+95f43lcMm2zw9ptzoKMXKMQ80yCaibZAmgmfr4OEmCMfZ4WXb6gmDzzrUDj7LbhHWDSGsXF0KOKPYOioEOZufYk5Kps8esTRmH1LSd47hejpFJZZ/c0m0zyd8CLnBOgWLH6HHugmUtOQm0Jnl1Qg8HXveyKgNPQKAVoMik2PAQmIcRh9pJRJ9TdkgtBqjWTgNFcopmrlaHBKpC8zFwtunybQdQ6KKW49ZXluPChTwGImknLz3/PO6sAAJt2lViBSg0NFMnMpdH6lWx90iYTMfILsIkjkRF9Ji0IDc5Tmh9++9sY1acTYhHvNQoXukG0jpaSWVtBnA6lwLrtTVi9tXDtT/k98VlDaGh0WGjNpMhoqbisa7ZNIUmJTLgQTqTy10xEIZ9vnsn6Hc14/YvNvqvzfEi0o1m5DCk4waDU0gr5LtoKFzw/MlfjNA2NjgitmRQJfTuzDNc+nZ2ZrtdO2wej+ip6bUtw+Ew8NBOxB/y5D8zDV3843ldrGHzdyxjakxXnIyS3ZuDlbPbTOmQ5+faKzUimDRw/tm9e5ykGxOkYlP1xIi9EDxdbM9FkolF60GRSJHx3Un90qYhi6ihn9ZefTNk70PHNgtaRlnJSVD4TAKhtTqFXNSMvSike+N9anDSuL3p3sglt9dZGAEA0HFJqJpmsga82N2B0v06eglM2jxkGtfw/XExywXnhQ/MBAGtvcxfV62hkImsmlFKkMuwetzTyzXF+89+ouUSjFKHNXEUCIQTHjenj62T3g59m4kUmYVNK3TpnOe584yv8/qUvcNljC5Tnj4VDSs3kj6+uwAl3vY+vtzZ4ClB5s5gTk4+g7GAuE4dmQikjFJ7Lw4m3EKHBHYxDNTQCQWsmJYqmlE0mnpqJB8n8873V1jZebj4jnSMWUWsmC7+pBQBsb0hhry7q+kGyQBVJJ59oro6Ws+H2mUDwmTh9J605f0fTyDQ0gkBrJiWKRsHMJZde4QmKKl9Ko5zDYMotmXiiYaLsZ8LFHCHeQk/eLjr/bTOX8lDpPLnHtBSUUnyzvSnnGOd83A54Xv6/pb1fVOfXZKJRitBk0sExso/aGS+Sgiuay8eXsUnRR2R7QxLrtjc6tkU9zFxcwBJ4+wnkzWIFZM4mQaKe2lKozpq7Gkf86R2s2FTnOUaOgBM/GoathaQyhnUvWjNjfn5NJhqlCG3m6uB49eoj8NHX23H2fR87tjclbc1E9o14IWNQbJYS4iiAiX940zU25uGA52DRXup9bs1E8JmgY9Tm+sQsnFmzoxkj+6i7HGSkZFCq0EwARiZ2d8lWhAZbZNLiU2hoFA1aMykB9OrkbmzUKPhMmlLByCRrGNgYMLvaSzNxnM9DcMqbRaGcjwO+2Av0tOGt8TnIJCuQSSuuR7WZS6OEocmkBNCr2iaThTccC8BJIM0BySRjUHyyZnugsdEIUZKFuCWozySr8JnkWsFnsgZum7Mi0FxbgiCcJmsmTp+JTS6prGDmypMHdjWn8Z/PahznL0SYsYZGe0OTSQmgKs6skWXRkNUrXvSZfFvbHOg8OxvTeGZBDSYO6mpt8xLq0XBIKdTs4cShucgmIBEOB3zAGlZfbW7AB6u2SdcunJANciY5wk38XtTMMwEkM1eeusnPZy/Gz2YvxsrN9daRWjHRKEVoMikBEEJw37mTMOeqI0AIQTRMcpq2omH32nvt9kYYFDh8eA/FEfLxHg5489Wgcqtg56pdhCiULZ9JjuvL4c7yNVZvbcAtryxvdf0uP7NbWjq3KgMeMMnEcI8BgLXbGn3rd20wFwKprGF9F23m0ihFaAd8ieDY0XamfDQcylmmvCwSRjrrHLPWjNga3L0y5/VyOeCzBpV8CM59Ilqimaj6r2QMikiYvf/pkwuxbEMdvjuxP4b3zl1+RkYQLcdPMxF9JumsISQtOs9x1B3vAlBn+KezhlWwM0SIdsBrlDS0ZlKCqIjlXgPEo+5/Lc+rGNzDJhMvueWVZwLBrm8YTuHKIUeXqXwm8upb1jBSGffMxPPwFsf1bdj7Qy7t73bAs/fJjNEiDem8B+Zh/Q6mmYQI0T4TjZKGJpMSRKfyAGTCl/AAThjbBwCwdnsTyqNhh0NfdjJzxCIhpbmFb7nlleXY2ZSytosCUM57EU1WopnMMcZQJ146t9nHVJp+JFcSZkAQH/tWYzKDRDrrMrU5fURw+EzyrbAMAB9+bQdDhEMQfCaaTDRKD5pMShCdyqI5x5QJmskxI5mJbENtM3p3iiMatvc1e+SoeDngOZZtqMPMl5dbn/e96TXr/RYpMZKf59WlG7HLLN/iMoVl/T/LxwQhk/pEGku/3eXY9urSTfjv4g2+AnvMja/h8NvfUeSZ2O/docF8TMuIgFL7+2nFRKMUoX0mJYhO5bnJRCxjXhZlWkpjMoN+XcoRE8jEy/fiVehRlJX1iYxye13Cec50lmL9jiZc+thn1jZ5JS8LbrlEDODUVqpNMqlPeJPJRQ/Nx7y1O7D6lhOsgpqXmoUtp+zTE4C3A35rfVKRZyKFBpu70xnRee45HV9kKbXuoTZzaZQitGZSguhUlnsNIArj8hj7N2cMingkhIgQ6SXX7+KIhkPKhlpi6KtK4KuQNSiSGcmPIpGHy8xVAM1k3lqW5f7fJRusXA6OYKHBfnkmTs2ktQSQNah1b7WZS6MUoTWTEgTXTMqiISTSaoEukkSZ4D+JR0IOM5cXPJMWhU0yQXhB5f/IpZmoQoPFMZxMckW1AcBVTy0CAPxs9mLXPnlqoiCXo7moNM5Rm0uRZ5IPKRiGWJsr8GEaGh0GWjMpQXCfSXk07DlGjESKC+Pi0bAyB0UGzzPJGtSz9peXViMjk6Wu6CzZhCaTR648Eyuay8fM5Qd+B2TtSyRnd56JZOYSHPCqEvReRK9CVtB0dJ6JRilCk0kJgkdz+UUk7dXF7p4okk48EvI9joPnmVz99CKMvOFVHP/X91GfSDvGBCYThZlLFuLyZzksVx7DBe7OppSSeHLBK6pM/I7uPBP7PcuzEc1czvMCzp4zuZA1BJ+JJhONEoQmkxIE10zSHsL8/EMG49Ijh1mfxciuuE8PeBHRcAiUAv9dvAEAsHxjHT5du0MycwX3mcjE4yq54tGTRT6P9d48fvb8Ggz/zZxA8/CamwgxeMCdZ+IkM6WZSzjEK1JOBblUi4ZGqaEoZEII+RMhZAUhZAkh5DlCSBdh368IIasIIV8SQqYJ26eb21YRQq4Ttg8hhHxibn+aEBJr7+/T3uhp5ol4JeydvF8/lMdsbSQWEcnE2zQmIqIwhWUN58o7KJnc+OJS11hZiMvOfJXWI5rbWltGxToPlclE0EzkaC7hIxXNXFkxadE+X9ACnIBUjqYAjbY0NNobxdJM3gCwL6V0HICvAPwKAAghowGcBWAMgOkA7iWEhAkhYQD3ADgewGgAZ5tjAeCPAO6klO4NYCeAi9r1mxQB+/Xv4rnvnIMGYfyALg4CER3uZYrMeBkhYvskRDBTDHV8DoJtDSmrPbB9rHOMK89Ece4Z9/zP8/iWQr6u6IPJHc3F3jv7mdjjxfppg6972XcehkLr0tAoJRSFTCilr1NK+a/2YwD9zfczADxFKU1SStcAWAVgsvm3ilK6mlKaAvAUgBmEGf+PBvCMefzDAE5tr+9RLPTpXOb4fMkRQ633vz91X4RDxKGBhAViCKKZhEME4ZD70bj9tRVYsane99jeit4rANAs+Q+yOTLevUx4HIVyUsuCu04gPe6LmWRWWXYXeqTWOFWnxXzMXFlt5tIocXSE0OALATxtvt8LjFw4asxtALBe2n4ggO4AagViEsfv1vjDqfsiFg7hewcMAAD8c+5qx37RNyJqGaqaXTJChEAVPbx6a6N7o4SYh0/ml89+7vgs+9dl/4QcSSWjtWRiFVWUriPmrXDt6LT998L8dTt9fSaqTouymcswqJU8KcOv6rKGRimgzciEEPImgD6KXb+hlL5gjvkNgAyAx9tqHtKcLgZwMQAMHDiwPS7ZZvjhQYN894vmLKdmEoxMQvm0RBQQ1CcjC/EgeSYA8OGqbThk7x4FyxKXNRPxujwogFcMkJ3k/HMyYyjNbrJmksoaKAup749MVBoapYY2IxNK6VS//YSQ8wGcBOAYai/nvgUwQBjW39wGj+3bAXQhhERM7UQcr5rTLACzAGDSpEm79S82FraFViTk74CviIURJgT79KnG/HU7QUEdBJQPgkaLucxargx4NZl8/1+f4P1fTCmYwHXnuwhJi+Y+rm3JJfdzte2VCTGZNqzSNjLEobqcikYpoljRXNMB/ALAKZTSJmHXiwDOIoTECSFDAAwHMA/ApwCGm5FbMTAn/YsmCb0D4Azz+PMAvNBe36MjI56HZtKjKo7PfzcNU82eKZSixWTiZeaSkTXkbPPceSYcjamMS+AuXl9rldgHgkd7ufNdbKnOrxFVaCaGITngeW0uj7L8AJDMevtQRB+SVkw0ShHFiub6G4BqAG8QQhYRQv4BAJTSZQBmA/gCwKsAfkIpzZpaxxUAXgOwHMBscywA/BLAzwghq8B8KPe371fpmMjHZ1JhhhHzcZSiFWYu5/m7VqiLUhqUOghB1kT8EhFZ7w/nthn3/A9H/Okd63M+OTDO69qf+Tk4mch+DSo64BUMIH+FOimizWusNnNplCKK4oA3w3i99s0EMFOx/RUAryi2rwaL9tIQIJqzQjmiuTiZcG2kNWaumHT+iEcdsIzUqVF2uPuRSSpAM6pckVReGfAiYfC8Fl5+RtxH5dBgHs0lmsKkOU7981y8d+1RGKTodOnVAllDo1SgM+B3E8ghuV7mJpWZixMHF/yUAuECaSZRD1IyhHIkgDsUWDZ7nTSur/U+5aEJiAhaYsWd72JvsMnErrrMIdfm4rvqkxlc+eRCNKUyyjmu2mL3gxdvjdx4S0Oj1NARQoM1CoBXrzoC2xvtzodemoWKTFaaAo6buQzqHcKaCzKJRT1ILWs4zVx/e2cVBveoxEQzp0PWVCqEjP5k2r/k+wMfrEFlPGBUmavjo6iZMGLh90X0axjUblssk9uLizfg0L27K+cocnQ4RGCYpJn18bVoaJQCNJnsJuhaGUPXytyVZOKKaKLaJmbLFwkoQJV69fkl8lBl0gMmmQhCc822Rpz+9w+x9rYTAbg1FbHvfTKT9RS4lFLc/NIXgefr7vBoX7c5nTUTOIlrrNjMSmV2y0hkyUFg3w/ml6LW+cRza2iUGjSZ7GHgFYQPHtodyzfV4fuTB2KcWZ6F+wYoWuOAd5KVV++UeWt34K43V3qeRw4dFmuNJTOGZ/2qxoD1sLjz3J1nIiQdprMIE2JpE26fiaCZSMRheJCJaCoTyduQTGgaGqUGTSZ7GPp0YqVYnrz4INc+XkKFUicJ3HTyaHywajveXL455/ldPhMfFedfH6zx3JeSNIaKqJNMvFbvOwVTnx+s3iGm5F67rRFH3fEu9upSbo1JpJhmwkv2i9c0hKKXos+EIyP5hKxzCoEBol9KjD7T5VQ0ShHaAb+HoZdH7SzAaZISe6BMHtId/buWqw5xwWXmCtCISwU5VNihmaSzntFc2wOSCddAOEEs+XYXAODb2mZrTCKTRSRkVwOQ/RpOB7w7KkylmYhkIvqlmtugIrKGRntCk8keBq8MbACoFnrLi/ko8WjIIcz94HLAC9n3N5w0Wh7uCTkay+kz8dZManY2Kbd7nf/f82vQnMoqo84SaQPhMLGiruQ8E/4xrTBzZSSfkH1OgUyES4oVhn3yNTU0Oiw0mezGeOvnR+LD644OPH7vXlXWe1EziYVDvi2C3/75kdZ7P82Em9gqfYjp7RWbccPzS10Z8GI0l8qsxLFGKkZ519kTcOXR7rQm3i9lW0MSt81ZrsyHaU4xnwnXTDKSz4QKmolMHFmDKjWMZgeZCJqJUFVZm7k0ShHaZ7IbY1jPqtyDBHBhDzjNSvGoP5lUlUXQrTKGHY0pt2YiCGkr+c9HWF740HwAwJAezsQ+twNefY7V25xk0qU8ijIFeYmaz7bGlDJ6LZHhPhP22UszSWUNFwGIbXhFNKeEci2UYr8BXbB4fa3TzKXJRKMEoTWTPQT3fH9//PvSg33HiL3hy4SorHg4bJm9vrO/u8J/z6q4FfDqjuYiwnuzxlWAfMI1EimUOxzwWc88k9VbGxyfIyGiTMAUNZ+Y2aJYRiLl9JnIPeidVYNVocHuLyqSRjZLMbpvNQDJzKU7LWqUILRmsofgRCGD3A9zrjocmSx1aSY8jDWmWMITIXzWL5rLziTPX1qK5/XzmcgO+HBIXU5fbAscCRFlxnwiY6AiFrYd8Fln0iJ1+Ezc51dpO/9472scO7o3Jg7qiiyl1j0Re59ozUSjFKE1Ew0HRvXthLH9Ozsc9bFwyFrdiyvw3p3iuP7EUeYntl8uJBlRmLlaEqxECMHa205EVTyCZNptVuJISDW5ImGizOYXe85HwiFHKDKPamu2NBO2XdRMxPuQyrjnk0hnPTWMZxast87ByUTUTLTPRKMUoclEQwmxuVYoZAtkUSP45NdT8aPDWctgvviX80rEKCmv0ir5IB4J+Zq55O6G4VAIquhkUTOJhonjMyfSVNZw5JmIGoPY68SgQFJijkSaZemXRUP44JdTHPt4LotIJk6fifKraWh0aGgy0VBCNmdxzcTL8c3ldSTkHc0VVfSVzxeMTAxl+Gw4RFzVgiNCORQAuPyoYQCcDvhIKOT4zMkka1DTTMa2L1i30xrDyYxHpjUlnT3umWZCESYE/btWOPZ1rmBlb5iZy9aC5HNraJQSNJloKEEkP0PY0ky8xrPXWMR5nMNnElGoCIHnw17j0bBnCfryaNi1qg8LWtWEgV0wsBsT7CJ5RCNEIhOxsVjI8pm8tsyuAMA1E57/0ph0kljCLEbJr/38Tw619qXN+fO+MeEQQZMODdYocWgy0QiE7lVsNd23cxlevvIwvPmzIxz7eQFDWTNROeBl8ErBQRCPhLCzKaVcvasSMuVoLi7cxWiuaCjkMHPJjcVUDnyeoc+rE89bu8OxP2EWo+QkPH5AF9x19gQAzirDfH68QjGgzVwapQkdzaURCIft3QN3nz0Bx43prWywFfLymQhmLlUkGMBMT4trduGut1jhx05lEdQlnGYjfpYj9+mJ++auRlXc/eiWx9S9WkQHvCpMOBQiDoe8GMkm5pmI+NvbqwA4M/NFJNJZZAzqKFFz/L59ADDNhJMh80fBoZnoqsEapQitmWgEAiEEJ+/XT0kkfD8A9KiKYWSfakwYyCoRi9FcXnW6QoQ4tIHuVd71w07Yty8MChfZAFAmVkZCIQeBqPq8GAZFOmMLcDHHRiYjDh6CLJLasJ52omUizUxZolYTMYkplbVreYVNzaRJhwZrlDg0mWgUFNFwCK9efQSOGdkLAECkfSqEQk4yqVBkrHOZLNYPk6EkkzBb+cvnEZExqMNnImsmfn3CxLne+p1x1nueyCiSFyEEsXAIqayBtdtYDbGISVbOqsHe19PQ6KjQZi6NgoALab4S5wJRFN5eZBKWNBO/Xioq8xaHl8+En49ArZlksgYMqjbHeflMOCqF+XStiFrvU5ksspS6jo2FmX/mhLveB2A74MXr6arBGqUITSYanrjltLGB7fdcZlKzywc/Suws6OUzCRG7DEvEw0fBUelDJqrKxmKnREDtM8mIhbbgTGgMhwh8puPQTKrLBDLJMjOXTF6xiDMMmZu5OMqiYe0z0ShJaDLR8MT3DxwYeCwXubIcdGom9oeTxvXFS0s2AmBynGfOZwyqFN48Sqw8GgYhalNQEJ+Jyv+RlRpZiTkfYtKiCqKmJBa5TJm5MDKZRMPOyDHRJxMLs7I1mks0ShHaZ6JRENiaifnqkVTIceeZ4zF2r84AWK2ug4d2BwBMHtLN5di4/sRRGNefjQ2FiKProggVmYTDuaO5Mobh0BZEZ3gkp8/EJhORLHkujHws00ycrXv5nOKREEJEO+A1ShOaTDQKAttX4i0IxRV+NBxCDzN3JWtQ9OpUhoU3HIt//HCiSzP50eFDHcd6mbpUZi45z0QktKFm9FUmSx3aQkMyY40LEbfPZD+T2Nhc7GuKPqFUxkDGMBR5NwTPLfzW+hwi9pziUZYgqTPgNUoRmkw0CoKT9+sHAOhWGXNs52KYZ56LsLLqTeHZtTKGbpUxX58J4O2EV2omks9E1FIevehADOhWjqxBkc5SKwigPpG2jomE3WTCvysgayYCmZiVhGWzmhyEkEgbVrRZPPL/27v/IKvK+47j78/dHyyL7C4/FvmpSEQiElmFKDZoQBGJNZrpkBombYixZTLVJk6aWBmpM+0fnf7IxMak+TVt0ziTWie1mTC2TSRE05lWoxgRsUaEVKYiEcSgILKw8vSP85y7Z+/es7DcZe/eu5/XzJ295znn3vs8ejnf+/w439NAoSBftGg1yXMmNiTuuGYu666aUzzRpxPxSGzZsCL3RA/9h3VOlnRlMD2TBuUPc00ZP4bGQoGeE4Fj755gansLuw8c4dDRHsY0FjhGkk5FJT+5sp+fvSgxG7SOvxvoOdE/Df2xkoSQh7t7inVqH9vEgbe7nU7FalJVeiaS/lrSLyRtk/R9SR2xfLakdyRtjY9vZF6zSNJzknZKuk9x3EPSREmbJL0U/556bg4bMoWC+vQYikuDgclnjSkbANIhoJ6Sn+IDTXhD36GlrHJLgwuZOQ+p7zUnTXHCe+Ozr7LjtUO0j21iXHMDf3LD/N6eSZmlwdkVXANV9ejxd/vN0XQf7x9M0mDXPraJguQ5E6tJ1Rrm2gQsCCFcDOwA1mf27QohdMXHpzPlXwd+H5gbH6ti+V3A5hDCXGBz3LYqyzsdfuN3FvHDO64EYMK4ZClt6bxCevr92scvZcuGFf3eY1xOCpO8Wwv3mTMpObmnPYvdB47Q3FDg+T9bxdrfmF0cjiqo/9LgbNBMA82F09r6fe47x0/0G+Yqvd/K4aN9eybJnEnZZpiNaFUZ5gohPJLZfAJYPdDxkqYBbSGEJ+L2/cBHgP8AbgKWxUO/AzwG/PHQ1thOV+kv91UxPxXA+g9dyDkTW1k5/+yyrxnf0sjkMqlVBjPMBb3zFiH0v+4jKzufke2ZlLYhe1yhAM/es7LfTcEgue1v6RX7pcFkwYw2nopJItvGNlIoOGuw1aaRMAH/KZKgkDpP0jOSfirpylg2A3glc8wrsQzg7BDC3vj8V0DfM1OGpHWStkjasn///iGqvpV1CifEcWMaWXfVe/r9ek/7Ankn/o7MleZZuT2TnAl4IDfBYxowGhpEa3Mj3/zdRWVTuRQk2lubikNsD//hUj6/8gIAXnztUP+eSWbV2G9dMoPfXjyr+Fke5rJadsaCiaQfS9pe5nFT5pi7gR7gu7FoL3BOCOES4HPAP0nqP36QIyQ/6XL/JYYQvhVCWBxCWNzZ2Xla7bLBGfj68dwXDWjSuPKJIMvNmQB9rvUoHebqyVzzkV2Jlgag9PjrLprKRxfNAuCNzH3mS+d3FsxoZ8aEsbmfl132O6dzHJKYMj5pT1tLHOZyLLEadMaGuUII/Qe7MyR9ErgBuCYGAUII3UB3fP60pF3ABcAeYGbm5TNjGcBrkqaFEPbG4bB9Q9r7uvP7AAAJ+ElEQVQQOy0XxQsSL5p+yr8Fioon/5yTanpvlVJ5w1xZaZBIJ9F7Mj2TbDBJMxxnezV3rprHxHFNyVDdgyV1zWhu6K3HQKlR0ozKnTGYtI5p9EWLVrOqtZprFXAncGMI4UimvFNSQ3w+h2Si/ZdxGOstSUviKq5PAD+IL9sIrI3P12bKrYquu2gq//mF5ayYnzvqmKuYmiVnfzqPcvHM9uKV8ZA/zJWVTpin14ccy3QDJrRmgklmziTV0tTA7VfPpaWpoZhnrFwSyGxalWw24FJNJcHk4JFjFCTPmVhNqtacyVeB8cCmkiXAVwHbJG0F/gX4dAghvYXdHwB/B+wEdtE7z/IXwLWSXgJWxG0bAc6Z1P9CxVNRTM1ykp5JQ0FsvH1p8YSfF0yy79OvZ3Ki92Q/qc8wV++cSTnphHvZnkk2mJRMuPc5Lr73By9IhlwXzuxI5ky8mstqULVWc52fU/4Q8FDOvi3AgjLlB4BrhrSCVlUT4km9KedEnvYgDh45DiQ9hsPdPX3u3V6OpGLwSIPJ8UzPoT0zsZ9+drlcXulnHjraU/aamOaStCpZ377l/dzy7aeA3mGuxbMnsvWea+lobWbZvM4BU96bjVQjYTWXWR9//pH3seE3L0ySPpaR5vRqi6urZsYJ77MGuHFWKs0IXAwmmQnx7D1VGsoMc2W1NOUPc2WXCZcOcy2fN6U4j5RdYtwRA2RjQ6FsZmOzkc7pVGzEaW9t4veunJO7v6O1mS9/rIvLz0syDd//qcv46Y79TGsfm/uaVDo/kc7lZCfgs3MmaZBoKJT/vZXe2rf8BHw2mPQf5krjT17Py6wWOZhYTbqpa0bx+ZS2Fj66OFm22zl+DPsPdee+7txJ43h8/dVMbWsBeu+Jdff1F7JwVkfxuDQNfd5tgtNlyOV6Jtmy0vQp0LvAIO/Ok2a1yMHE6sq/fWYpT/zyDSa2NnPwnWNljynXg7mpa3qf7be7e4D8CyTTYa5y0xtHM72Rcqu50tfkDaGZ1SIHE6srU8a3cOPCvoEheyfDPC0l16gcPmkwyV+GvGB6OwtmtLF9z1v9sgRD7zWZTY3umVj98LfZ6l7XzA5uW/4e7r25K/eYdA4kdfhoEkzax5a/QDK9Z325nkdzY4Hv3HJZfoV08uBmVmvcM7G6VyiIL1z33gGPKZ0MT3sUE3J6JumKrdLEjanWnMzG0Dtp72Euqyf+aWSjWppCJe8eKh2t5XsmaU+m3AQ7MOA1L+knDZTB2KzWuGdio9q/f+ZKdh94O3d/W+5qrtgzKbP0Fwa+wVe6z0lTrJ44mNioNrW9hantLbn7G3PmNSbk9Fiybl9+PpfP6X/hZTGPpaOJ1REHE7MyvrLmEp783zdy99+2PMkIdPP7Z+Ue8/nr5pUt78095mhi9cPBxKyMDy+czodLlhhnjW1uyA0WJzM2Ts6f7F73ZrXEwcRsmH1x9cXc//huFp87odpVMRsyDiZmw2xKW8tp92rMRiovDTYzs4o5mJiZWcUcTMzMrGIOJmZmVjEHEzMzq5iDiZmZVczBxMzMKuZgYmZmFdNozQ8kaT+w+zRfPhl4fQirM9KNpvaOprbC6GrvaGornLn2nhtC6CwtHLXBpBKStoQQFle7HsNlNLV3NLUVRld7R1NbYfjb62EuMzOrmIOJmZlVzMHk9Hyr2hUYZqOpvaOprTC62jua2grD3F7PmZiZWcXcMzEzs4o5mJiZWcUcTAZJ0ipJL0raKemuatenUpL+QdI+SdszZRMlbZL0Uvw7IZZL0n2x7dskXVq9mg+epFmSHpX0P5Kel/TZWF6v7W2R9KSkZ2N7/zSWnyfpZ7FdD0pqjuVj4vbOuH92Net/OiQ1SHpG0sNxu57b+rKk5yRtlbQlllXtu+xgMgiSGoC/BT4EzAfWSJpf3VpV7B+BVSVldwGbQwhzgc1xG5J2z42PdcDXh6mOQ6UH+KMQwnxgCXBb/P9Xr+3tBq4OISwEuoBVkpYAfwncG0I4H/g1cGs8/lbg17H83nhcrfks8EJmu57bCrA8hNCVuZ6ket/lEIIfp/gArgB+lNleD6yvdr2GoF2zge2Z7ReBafH5NODF+PybwJpyx9XiA/gBcO1oaC/QCvwcuJzkqujGWF78TgM/Aq6Izxvjcap23QfRxpkkJ9CrgYcB1WtbY71fBiaXlFXtu+yeyeDMAP4vs/1KLKs3Z4cQ9sbnvwLOjs/rpv1xWOMS4GfUcXvjsM9WYB+wCdgFHAwh9MRDsm0qtjfufxOYNLw1rsjfAHcCJ+L2JOq3rQABeETS05LWxbKqfZcbh/LNrP6EEIKkulo/Luks4CHgjhDCW5KK++qtvSGEd4EuSR3A94H3VrlKZ4SkG4B9IYSnJS2rdn2GydIQwh5JU4BNkn6R3Tnc32X3TAZnDzArsz0zltWb1yRNA4h/98Xymm+/pCaSQPLdEMK/xuK6bW8qhHAQeJRkqKdDUvpDMtumYnvj/nbgwDBX9XR9ALhR0svAP5MMdX2Z+mwrACGEPfHvPpIfCpdRxe+yg8ngPAXMjStEmoGPARurXKczYSOwNj5fSzK3kJZ/Iq4MWQK8melSj3hKuiB/D7wQQvhSZle9trcz9kiQNJZkfugFkqCyOh5W2t70v8Nq4CchDrCPdCGE9SGEmSGE2ST/Ln8SQvg4ddhWAEnjJI1PnwMrge1U87tc7UmkWnsA1wM7SMae7652fYagPQ8Ae4HjJOOot5KMHW8GXgJ+DEyMx4pkNdsu4DlgcbXrP8i2LiUZZ94GbI2P6+u4vRcDz8T2bgfuieVzgCeBncD3gDGxvCVu74z751S7DafZ7mXAw/Xc1tiuZ+Pj+fRcVM3vstOpmJlZxTzMZWZmFXMwMTOzijmYmJlZxRxMzMysYg4mZmZWMQcTs2Ek6e6YwXdbzPZ6uaQ7JLVWu25mlfDSYLNhIukK4EvAshBCt6TJQDPw3yTr/l+vagXNKuCeidnwmQa8HkLoBojBYzUwHXhU0qMAklZKelzSzyV9L+YSS+9f8VfxHhZPSjq/Wg0xK+VgYjZ8HgFmSdoh6WuSPhhCuA94leS+FMtjb2UDsCKEcCmwBfhc5j3eDCG8D/gqSZZcsxHBWYPNhkkI4bCkRcCVwHLgQfW/W+cSkhuv/VfMZtwMPJ7Z/0Dm771ntsZmp87BxGwYhSQl/GPAY5KeozcpX0rAphDCmry3yHluVlUe5jIbJpLmSZqbKeoCdgOHgPGx7AngA+l8SMwOe0HmNTdn/mZ7LGZV5Z6J2fA5C/hKTAvfQ5Kxdh2wBvihpFfjvMkngQckjYmv20CSqRpggqRtJPd3z+u9mA07Lw02qxHxxk9eQmwjkoe5zMysYu6ZmJlZxdwzMTOzijmYmJlZxRxMzMysYg4mZmZWMQcTMzOr2P8DSISGcUE9J8gAAAAASUVORK5CYII=\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Single Stage vs Two Stage Comparison\n", + "\n", + "We can also see how single stage optimization compares to two stage optimization." + ], + "metadata": { + "id": "bDyY-lhT2HAS" + } + }, + { + "cell_type": "code", + "source": [ + "image_size = (112, 112)\n", + "\n", + "# Initialize NaturalImage with 4 channels\n", + "image = opt.images.NaturalImage(image_size, channels=4).to(device)\n", + "\n", + "# Set optimization target\n", + "target = model.mixed4b\n", + "channel_index = 373\n", + "\n", + "# Set optimization target\n", + "loss_fn = opt.loss.NeuronActivation(target, channel_index=channel_index)\n", + "\n", + "# Setup transforms, & blend the alpha channel into the image using random backgrounds\n", + "transforms = [opt.transforms.TransformationRobustness(), opt.transforms.BlendAlpha()]\n", + "\n", + "# Use transformed output as target\n", + "loss_fn = loss_fn * (1.0 - opt.loss.ChannelActivation(transforms[0], channel_index=3))\n", + "\n", + "\n", + "# Render visualization\n", + "neuron_img, history_advanced = visualize(\n", + " model, loss_fn, image, transforms=transforms, n_iter=512\n", + ")\n", + "\n", + "# Show single stage visualization on multiple backgrounds\n", + "print(\"Single Stage Visualization\")\n", + "opt.images.show(create_mosaic(neuron_img), images_per_row=4, figsize=(15, 10))\n", + "\n", + "# Show two stage visualization on multiple backgrounds\n", + "print(\"Two Stage Visualization\")\n", + "opt.images.show(create_mosaic(stage_two_img), images_per_row=4, figsize=(15, 10))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 537, + "referenced_widgets": [ + "95d38ecf0e3f42d285b3b72179601f70", + "323d89c37c62400ca33f194b44ae74d0", + "baf6d0f46126420395bd64ec76a704d6", + "0c99c38f17544da997a575538dd2e5f0", + "4d3ba63fda70437a9bc0770e6214f1c6", + "99f161d1f27144ec8721c8dd6e841da6", + "6742449d54ea4997b5b85082b7d12efd", + "9ad0d9e48e7a4a7ba7f66cec35a8eacd", + "d7c6b875af764e0a9aac393bb539acf3", + "27d1bfac70e64b04925375e57162aaae", + "cf4d1a9836814fab81ca7688a66d5fab" + ] + }, + "id": "VkQG2GCrS54d", + "outputId": "24623a4b-050f-47e1-a98c-35bc71d5e39f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/512 [00:00" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Two Stage Visualization\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "You can see that using two stage visualization can help reveal important areas of the visualization that the single stage misses, while producing better quality visualizations." + ], + "metadata": { + "id": "ZkupbmiqOFuw" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Optimization with alpha channel blur\n", + "\n", + "In more recent research like [Goh, et al., \"Multimodal Neurons in Artificial Neural Networks\", Distill, 2021.](https://distill.pub/2021/multimodal-neurons/), alpha transparency optimization has been performed by using blurring penalties.\n", + "\n", + "Below we define a blurring penalty objective called `BlurActivations`, and a second penalty objective called `MeanAlphaChannelPenalty`." + ], + "metadata": { + "id": "TNEviEvlLTXj" + } + }, + { + "cell_type": "code", + "source": [ + "@opt.loss.loss_wrapper\n", + "class MeanAlphaChannelPenalty(opt.loss.BaseLoss):\n", + " \"\"\"\n", + " Mean alpha channel loss penalty for optimizing with transparency.\n", + "\n", + " This objective essentially the same thing as taking the square root of the\n", + " DeepDream objective, but only for the alpha channel. The square root of the output\n", + " is then calculated.\n", + "\n", + " Basically the same as this, but for the alpha channel only:\n", + " loss_fn = DeepDream(target) ** (1/2)\n", + "\n", + " Used in the https://distill.pub/2021/multimodal-neurons/ paper for optimizing with\n", + " transparency, in the supplementary code here:\n", + " https://github.com/openai/CLIP-featurevis/blob/master/example_facets.py\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " target: torch.nn.Module,\n", + " batch_index: Optional[int] = None,\n", + " ) -> None:\n", + " \"\"\"\n", + " Args:\n", + "\n", + " target (nn.Module): A target layer instance.\n", + " batch_index (int, optional): The index of activations to optimize if\n", + " optimizing a batch of activations. If set to None, defaults to all\n", + " activations in the batch.\n", + " Default: None\n", + " \"\"\"\n", + " opt.loss.BaseLoss.__init__(self, target, batch_index)\n", + "\n", + " def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor:\n", + " activations = targets_to_values[self.target]\n", + " assert activations.dim() == 4 and activations.shape[1] == 4\n", + " activations = activations[self.batch_index[0] : self.batch_index[1]]\n", + " return torch.sqrt(torch.mean(activations[:, 3:] ** 2))\n", + "\n", + "\n", + "def _conv_blur(x: torch.Tensor, k: int = 3) -> torch.Tensor:\n", + " \"\"\"\n", + " Blur an input tensor, as per the Lucid supplementary code for\n", + " Olah, et al., \"Feature Visualization\", Distill, 2017:\n", + " https://distill.pub/2017/feature-visualization/\n", + "\n", + " See here for more details:\n", + " https://github.com/tensorflow/lucid/blob/master/lucid/optvis/objectives.py#L261\n", + "\n", + " Args:\n", + "\n", + " x (torch.Tensor): A NCHW tensor to blur.\n", + " k (int, optional): The desired filter height / width to use.\n", + "\n", + " Returns:\n", + " x (torch.Tensor): A blurred version of the input tensor.\n", + " \"\"\"\n", + " assert x.dim() == 4\n", + " channels = x.shape[1]\n", + " k = torch.zeros([channels, channels, k, k], device=x.device)\n", + " for ch in range(channels):\n", + " k_ch = k[ch, ch, :, :]\n", + " k_ch[:, :] = 0.5\n", + " k_ch[1:-1, 1:-1] = 1.0\n", + " return F.conv2d(x, k, padding=\"same\") / F.conv2d(\n", + " torch.ones_like(x), k, padding=\"same\"\n", + " )\n", + "\n", + "\n", + "@opt.loss.loss_wrapper\n", + "class BlurActivations(opt.loss.BaseLoss):\n", + " \"\"\"\n", + " This objective was used in early feature visualization research, and more recently\n", + " for alpha channel optimization.\n", + "\n", + " Used in the https://distill.pub/2021/multimodal-neurons/ paper for optimizing with\n", + " transparency, in the supplementary code here:\n", + " https://github.com/openai/CLIP-featurevis/blob/master/example_facets.py\n", + "\n", + " See Nguyen, et al., 2015 for the origins of the idea:\n", + " https://arxiv.org/abs/1412.1897\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " target: torch.nn.Module,\n", + " channel_index: Optional[int] = None,\n", + " blur_fn: Optional[Callable] = None,\n", + " batch_index: Optional[int] = None,\n", + " ) -> None:\n", + " \"\"\"\n", + " Args:\n", + "\n", + " target (nn.Module): A target layer instance.\n", + " channel_index (int, optional): Optionally only blur a specific channel.\n", + " If set to None, all channels will be blurred.\n", + " Default: None\n", + " blur_fn (Callable, optional): A function or class instance that blurs\n", + " input tensors. If set to None, the _conv_blur function is used.\n", + " Default: None\n", + " batch_index (int, optional): The index of activations to optimize if\n", + " optimizing a batch of activations. If set to None, defaults to all\n", + " activations in the batch.\n", + " Default: None\n", + " \"\"\"\n", + " opt.loss.BaseLoss.__init__(self, target, batch_index)\n", + " self.channel_index = channel_index\n", + " self.blur_fn = blur_fn or _conv_blur\n", + "\n", + " def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor:\n", + " activations = targets_to_values[self.target]\n", + " activations = activations[self.batch_index[0] : self.batch_index[1]]\n", + " if self.channel_index is not None:\n", + " activations = activations[:, self.channel_index : self.channel_index + 1]\n", + " activations_blurred = self.blur_fn(activations.detach())\n", + " return 0.5 * torch.sum((activations - activations_blurred) ** 2)" + ], + "metadata": { + "id": "2kzA7TMvLTqb" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We render the results using our custom loss objectives." + ], + "metadata": { + "id": "q7qEk9SLc1RC" + } + }, + { + "cell_type": "code", + "source": [ + "image_size = (112, 112)\n", + "\n", + "# Initialize NaturalImage with 4 channels\n", + "image = opt.images.NaturalImage(image_size, channels=4).to(device)\n", + "\n", + "# Set optimization target\n", + "target = model.mixed4b\n", + "channel_index = 373\n", + "\n", + "# Setup main loss objective\n", + "loss_fn = opt.loss.NeuronActivation(target, channel_index=channel_index)\n", + "\n", + "# Setup transforms, & blend the alpha channel into the image using random backgrounds\n", + "transforms = [opt.transforms.TransformationRobustness(), opt.transforms.BlendAlpha()]\n", + "\n", + "# Use transformed output as target for additional loss objectives\n", + "loss_fn = loss_fn - MeanAlphaChannelPenalty(transforms[0])\n", + "loss_fn = loss_fn - (9 * BlurActivations(transforms[0], channel_index=3))\n", + "\n", + "\n", + "# Render visualization\n", + "neuron_img, history_advanced = visualize(\n", + " model, loss_fn, image, transforms=transforms, n_iter=512\n", + ")\n", + "\n", + "\n", + "# Show results\n", + "opt.images.show(create_mosaic(neuron_img), images_per_row=4, figsize=(15, 10))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 275, + "referenced_widgets": [ + "3f4b2348efa0443ab3c29300b85f29e8", + "fe953f251ac24f8b912db5cf4f9864e3", + "5601082b45ce4996acd41e91921243c2", + "82e4a1dbe4944e28bbab6ea2e8ad5661", + "3137aeea1e504d1f842dd8e65667bc70", + "e306b531228a441491fbdfccb9522fdc", + "0317501458264f4e822b3486207f8019", + "aeff5916a0e140e3a254d2bf7e2fd60b", + "6b3d9810d08b4ce190d7c3a801a345e8", + "f06b61f3847b477487f4359bf855c4d1", + "55c305b5b8ed407f972fd2b775a5d18c" + ] + }, + "id": "sRvMrq0UTIRS", + "outputId": "147ad3b3-19d6-45f3-de65-83e917528716" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/512 [00:00" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We can also see that the alpha channel for this visualization is rather different from what is produced by other alpha channel optimization strategies." + ], + "metadata": { + "id": "ZFFsYCR2PfE2" + } + }, + { + "cell_type": "code", + "source": [ + "opt.images.show(composite_alpha_only(neuron_img), figsize=(4, 4))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 248 + }, + "id": "HLRL4zhETRMP", + "outputId": "5b16abae-c5e8-48d3-c176-14a9bbac2a16" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file From e2e58da0a0561dd5b38944d40509e9d981c20570 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 17 May 2022 18:48:04 -0600 Subject: [PATCH 009/174] Improve loss objective docs + batch_index --- captum/optim/_core/loss.py | 372 ++++++++++++++++++++++++------------- 1 file changed, 238 insertions(+), 134 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 66bb4c40c2..682e5b44eb 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -141,14 +141,18 @@ class BaseLoss(Loss): def __init__( self, target: Union[nn.Module, List[nn.Module]] = [], - batch_index: Optional[int] = None, + batch_index: Optional[Union[int, List[int]]] = None, ) -> None: super(BaseLoss, self).__init__() self._target = target if batch_index is None: self._batch_index = (None, None) + elif isinstance(batch_index, (list, tuple)): + self._batch_index = tuple(batch_index) else: self._batch_index = (batch_index, batch_index + 1) + assert all([isinstance(b, (int, type(None))) for b in self._batch_index]) + assert len(self._batch_index) == 2 @property def target(self) -> Union[nn.Module, List[nn.Module]]: @@ -197,10 +201,14 @@ class LayerActivation(BaseLoss): their original form. Args: - target (nn.Module): The layer to optimize for. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. index ranges should be + in the format of: [start, end]. + Default: None """ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: @@ -215,18 +223,26 @@ class ChannelActivation(BaseLoss): Maximize activations at the target layer and target channel. This loss maximizes the activations of a target channel in a specified target layer, and can be useful to determine what features the channel is excited by. - - Args: - target (nn.Module): The layer to containing the channel to optimize for. - channel_index (int): The index of the channel to optimize for. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. """ def __init__( - self, target: nn.Module, channel_index: int, batch_index: Optional[int] = None + self, + target: nn.Module, + channel_index: int, + batch_index: Optional[Union[int, List[int]]] = None, ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + channel_index (int): The index of the channel to optimize for. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. index ranges should be + in the format of: [start, end]. + Default: None + """ BaseLoss.__init__(self, target, batch_index) self.channel_index = channel_index @@ -250,19 +266,6 @@ class NeuronActivation(BaseLoss): from the specified layer. This loss is useful for determining the type of features that excite a neuron, and thus is often used for circuits and neuron related research. - - Args: - target (nn.Module): The layer to containing the channel to optimize for. - channel_index (int): The index of the channel to optimize for. - x (int, optional): The x coordinate of the neuron to optimize for. If - unspecified, defaults to center, or one unit left of center for even - lengths. - y (int, optional): The y coordinate of the neuron to optimize for. If - unspecified, defaults to center, or one unit up of center for even - heights. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. """ def __init__( @@ -271,8 +274,27 @@ def __init__( channel_index: int, x: Optional[int] = None, y: Optional[int] = None, - batch_index: Optional[int] = None, + batch_index: Optional[Union[int, List[int]]] = None, ) -> None: + """ + Args: + + target (nn.Module): The layer instance containing the channel to optimize for. + channel_index (int): The index of the channel to optimize for. + x (int, optional): The x coordinate of the neuron to optimize for. If + unspecified, defaults to center, or one unit left of center for even + lengths. + Default: None + y (int, optional): The y coordinate of the neuron to optimize for. If + unspecified, defaults to center, or one unit up of center for even + heights. + Default: None + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. index ranges should be + in the format of: [start, end]. + Default: None + """ BaseLoss.__init__(self, target, batch_index) self.channel_index = channel_index self.x = x @@ -305,10 +327,14 @@ class DeepDream(BaseLoss): referred to as 'Deep Dream'. Args: - target (nn.Module): The layer to optimize for. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. index ranges should be + in the format of: [start, end]. + Default: None """ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: @@ -328,10 +354,14 @@ class TotalVariation(BaseLoss): often used to remove unwanted visual artifacts. Args: - target (nn.Module): The layer to optimize for. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. index ranges should be + in the format of: [start, end]. + Default: None """ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: @@ -346,22 +376,26 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: class L1(BaseLoss): """ L1 norm of the target layer, generally used as a penalty. - - Args: - target (nn.Module): The layer to optimize for. - constant (float): Constant threshold to deduct from the activations. - Defaults to 0. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. """ def __init__( self, target: nn.Module, constant: float = 0.0, - batch_index: Optional[int] = None, + batch_index: Optional[Union[int, List[int]]] = None, ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + constant (float): Constant threshold to deduct from the activations. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. index ranges should be + in the format of: [start, end]. + Default: None + """ BaseLoss.__init__(self, target, batch_index) self.constant = constant @@ -375,34 +409,40 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: class L2(BaseLoss): """ L2 norm of the target layer, generally used as a penalty. - - Args: - target (nn.Module): The layer to optimize for. - constant (float): Constant threshold to deduct from the activations. - Defaults to 0. - epsilon (float): Small value to add to L2 prior to sqrt. Defaults to 1e-6. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. """ def __init__( self, target: nn.Module, constant: float = 0.0, - epsilon: float = 1e-6, - batch_index: Optional[int] = None, + eps: float = 1e-6, + batch_index: Optional[Union[int, List[int]]] = None, ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + constant (float): Constant threshold to deduct from the activations. + Default: 0.0 + eps (float): Small value to add to L2 prior to sqrt. + Default: 1e-6 + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. index ranges should be + in the format of: [start, end]. + Default: None + """ BaseLoss.__init__(self, target, batch_index) self.constant = constant - self.epsilon = epsilon + self.eps = eps def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target][ self.batch_index[0] : self.batch_index[1] ] activations = ((activations - self.constant) ** 2).sum() - return torch.sqrt(self.epsilon + activations) + return torch.sqrt(self.eps + activations) @loss_wrapper @@ -416,13 +456,18 @@ class Diversity(BaseLoss): loss. Args: - target (nn.Module): The layer to optimize for. - batch_index (int, optional): Unused here since we are optimizing for diversity - across the batch. + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (list of int, optional): The index range of activations to + optimize. If set to None, defaults to all activations in the batch. index + ranges should be in the format of: [start, end]. + Default: None """ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] + activations = activations[self.batch_index[0] : self.batch_index[1]] batch, channels = activations.shape[:2] flattened = activations.view(batch, channels, -1) grams = torch.matmul(flattened, torch.transpose(flattened, 1, 2)) @@ -446,23 +491,29 @@ class ActivationInterpolation(BaseLoss): https://distill.pub/2017/feature-visualization/#Interaction-between-Neurons This loss helps to interpolate or mix visualizations from two activations (layer or channel) by interpolating a linear sum between the two activations. - - Args: - target1 (nn.Module): The first layer to optimize for. - channel_index1 (int): Index of channel in first layer to optimize. Defaults to - all channels. - target2 (nn.Module): The first layer to optimize for. - channel_index2 (int): Index of channel in first layer to optimize. Defaults to - all channels. """ def __init__( self, target1: nn.Module = None, - channel_index1: int = -1, + channel_index1: Optional[int] = None, target2: nn.Module = None, - channel_index2: int = -1, + channel_index2: Optional[int] = None, ) -> None: + """ + Args: + + target1 (nn.Module): The first layer, transform, or image parameterization + instance to optimize the output for. + channel_index1 (int, optional): Index of channel in first target to + optimize. Default is set to None for all channels. + Default: None + target2 (nn.Module): The second layer, transform, or image parameterization + instance to optimize the output for. + channel_index2 (int, optional): Index of channel in second target to + optimize. Default is set to None for all channels. + Default: None + """ self.target_one = target1 self.channel_index_one = channel_index1 self.target_two = target2 @@ -476,15 +527,16 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: assert activations_one is not None and activations_two is not None # ensure channel indices are valid - assert ( - self.channel_index_one < activations_one.shape[1] - and self.channel_index_two < activations_two.shape[1] - ) + if self.channel_index_one: + assert self.channel_index_one < activations_one.shape[1] + if self.channel_index_two: + assert self.channel_index_two < activations_two.shape[1] + assert activations_one.size(0) == activations_two.size(0) - if self.channel_index_one > -1: + if self.channel_index_one: activations_one = activations_one[:, self.channel_index_one] - if self.channel_index_two > -1: + if self.channel_index_two: activations_two = activations_two[:, self.channel_index_two] B = activations_one.size(0) @@ -508,19 +560,35 @@ class Alignment(BaseLoss): When interpolating between activations, it may be desirable to keep image landmarks in the same position for visual comparison. This loss helps to minimize L2 distance between neighbouring images. - - Args: - target (nn.Module): The layer to optimize for. - decay_ratio (float): How much to decay penalty as images move apart in batch. - Defaults to 2. """ - def __init__(self, target: nn.Module, decay_ratio: float = 2.0) -> None: - BaseLoss.__init__(self, target) + def __init__( + self, + target: nn.Module, + decay_ratio: float = 2.0, + batch_index: Optional[List[int]] = None, + ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + decay_ratio (float): How much to decay penalty as images move apart in + the batch. + Default: 2.0 + batch_index (list of int, optional): The index range of activations to + optimize. If set to None, defaults to all activations in the batch. + index ranges should be in the format of: [start, end]. + Default: None + """ + if batch_index: + assert len(batch_index) == 2 + BaseLoss.__init__(self, target, batch_index) self.decay_ratio = decay_ratio def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] + activations = activations[self.batch_index[0] : self.batch_index[1]] B = activations.size(0) sum_tensor = torch.zeros(1, device=activations.device) @@ -545,14 +613,6 @@ class Direction(BaseLoss): the alignment between the input vector and the layer’s activation vector. The dimensionality of the vector should correspond to the number of channels in the layer. - - Args: - target (nn.Module): The layer to optimize for. - vec (torch.Tensor): Vector representing direction to align to. - cossim_pow (float, optional): The desired cosine similarity power to use. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. """ def __init__( @@ -562,6 +622,19 @@ def __init__( cossim_pow: Optional[float] = 0.0, batch_index: Optional[int] = None, ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + vec (torch.Tensor): Vector representing direction to align to. + cossim_pow (float, optional): The desired cosine similarity power to use. + Default: 0.0 + batch_index (int, optional): The index of activations to optimize if + optimizing a batch of activations. If set to None, defaults to all + activations in the batch. + Default: None + """ BaseLoss.__init__(self, target, batch_index) self.vec = vec.reshape((1, -1, 1, 1)) self.cossim_pow = cossim_pow @@ -581,21 +654,6 @@ class NeuronDirection(BaseLoss): https://distill.pub/2019/activation-atlas/#Aggregating-Multiple-Images Extends Direction loss by focusing on visualizing a single neuron within the kernel. - - Args: - target (nn.Module): The layer to optimize for. - vec (torch.Tensor): Vector representing direction to align to. - x (int, optional): The x coordinate of the neuron to optimize for. If - unspecified, defaults to center, or one unit left of center for even - lengths. - y (int, optional): The y coordinate of the neuron to optimize for. If - unspecified, defaults to center, or one unit up of center for even - heights. - channel_index (int): The index of the channel to optimize for. - cossim_pow (float, optional): The desired cosine similarity power to use. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. """ def __init__( @@ -608,6 +666,30 @@ def __init__( cossim_pow: Optional[float] = 0.0, batch_index: Optional[int] = None, ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + vec (torch.Tensor): Vector representing direction to align to. + x (int, optional): The x coordinate of the neuron to optimize for. If + set to None, defaults to center, or one unit left of center for even + lengths. + Default: None + y (int, optional): The y coordinate of the neuron to optimize for. If + set to None, defaults to center, or one unit up of center for even + heights. + Default: None + channel_index (int): The index of the channel to optimize for. If set to + None, then all channels will be used. + Default: None + cossim_pow (float, optional): The desired cosine similarity power to use. + Default: 0.0 + batch_index (int, optional): The index of activations to optimize if + optimizing a batch of activations. If set to None, defaults to all + activations in the batch. + Default: None + """ BaseLoss.__init__(self, target, batch_index) self.vec = vec.reshape((1, -1, 1, 1)) self.x = x @@ -673,16 +755,25 @@ def __init__( ) -> None: """ Args: - target (nn.Module): A target layer instance. + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. vec (torch.Tensor): A neuron direction vector to use. vec_whitened (torch.Tensor, optional): A whitened neuron direction vector. + If set to None, then no whitened vec will be used. + Default: None cossim_pow (float, optional): The desired cosine similarity power to use. - x (int, optional): Optionally provide a specific x position for the target - neuron. - y (int, optional): Optionally provide a specific y position for the target - neuron. + x (int, optional): The x coordinate of the neuron to optimize for. If + set to None, defaults to center, or one unit left of center for even + lengths. + Default: None + y (int, optional): The y coordinate of the neuron to optimize for. If + set to None, defaults to center, or one unit up of center for even + heights. + Default: None eps (float, optional): If cossim_pow is greater than zero, the desired epsilon value to use for cosine similarity calculations. + Default: 1.0e-4 """ BaseLoss.__init__(self, target, batch_index) self.vec = vec.unsqueeze(0) if vec.dim() == 1 else vec @@ -726,14 +817,6 @@ class TensorDirection(BaseLoss): Carter, et al., "Activation Atlas", Distill, 2019. https://distill.pub/2019/activation-atlas/#Aggregating-Multiple-Images Extends Direction loss by allowing batch-wise direction visualization. - - Args: - target (nn.Module): The layer to optimize for. - vec (torch.Tensor): Vector representing direction to align to. - cossim_pow (float, optional): The desired cosine similarity power to use. - batch_index (int, optional): The index of the image to optimize if we - optimizing a batch of images. If unspecified, defaults to all images - in the batch. """ def __init__( @@ -743,6 +826,19 @@ def __init__( cossim_pow: Optional[float] = 0.0, batch_index: Optional[int] = None, ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + vec (torch.Tensor): Vector representing direction to align to. + cossim_pow (float, optional): The desired cosine similarity power to use. + Default: 0.0 + batch_index (int, optional): The index of activations to optimize if + optimizing a batch of activations. If set to None, defaults to all + activations in the batch. + Default: None + """ BaseLoss.__init__(self, target, batch_index) assert vec.dim() == 4 self.vec = vec @@ -774,21 +870,6 @@ class ActivationWeights(BaseLoss): Apply weights to channels, neurons, or spots in the target. This loss weighs specific channels or neurons in a given layer, via a weight vector. - - Args: - target (nn.Module): The layer to optimize for. - weights (torch.Tensor): Weights to apply to targets. - neuron (bool): Whether target is a neuron. Defaults to False. - x (int, optional): The x coordinate of the neuron to optimize for. If - unspecified, defaults to center, or one unit left of center for even - lengths. - y (int, optional): The y coordinate of the neuron to optimize for. If - unspecified, defaults to center, or one unit up of center for even - heights. - wx (int, optional): Length of neurons to apply the weights to, along the - x-axis. - wy (int, optional): Length of neurons to apply the weights to, along the - y-axis. """ def __init__( @@ -801,6 +882,29 @@ def __init__( wx: Optional[int] = None, wy: Optional[int] = None, ) -> None: + """ + Args: + + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + weights (torch.Tensor): Weights to apply to targets. + neuron (bool): Whether target is a neuron. + Default: False + x (int, optional): The x coordinate of the neuron to optimize for. If + set to None, defaults to center, or one unit left of center for even + lengths. + Default: None + y (int, optional): The y coordinate of the neuron to optimize for. If + set to None, defaults to center, or one unit up of center for even + heights. + Default: None + wx (int, optional): Length of neurons to apply the weights to, along the + x-axis. Set to None for the full length. + Default: None + wy (int, optional): Length of neurons to apply the weights to, along the + y-axis. Set to None for the full length. + Default: None + """ BaseLoss.__init__(self, target) self.x = x self.y = y From c905352ed283524c6c15e24f3218d043716b9e75 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 17 May 2022 18:58:52 -0600 Subject: [PATCH 010/174] Fix NeuronActivation docs --- captum/optim/_core/loss.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 682e5b44eb..194422f3f6 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -279,7 +279,8 @@ def __init__( """ Args: - target (nn.Module): The layer instance containing the channel to optimize for. + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. channel_index (int): The index of the channel to optimize for. x (int, optional): The x coordinate of the neuron to optimize for. If unspecified, defaults to center, or one unit left of center for even From a7027286f9c8eee91a5fade3958e6f85d5eee3e7 Mon Sep 17 00:00:00 2001 From: Vivek Miglani Date: Wed, 18 May 2022 10:00:30 -0700 Subject: [PATCH 011/174] SGD Linear Model Fixes for Lime (#938) Summary: This updates SGD linear models to work appropriately with Lime, addressing https://github.com/pytorch/captum/issues/910 . Particularly, this switches Lime interpretable model inputs / outputs from double to float and enables gradients when necessary. Also adds a unit test to Lime for testing with SGD linear models. Pull Request resolved: https://github.com/pytorch/captum/pull/938 Reviewed By: NarineK Differential Revision: D36331146 Pulled By: vivekmig fbshipit-source-id: 84d7aecf293404f9ba0b14c48e8723e0e489b392 --- captum/_utils/models/linear_model/train.py | 139 ++++++++++----------- captum/attr/_core/lime.py | 6 +- tests/attr/test_lime.py | 31 ++++- 3 files changed, 99 insertions(+), 77 deletions(-) diff --git a/captum/_utils/models/linear_model/train.py b/captum/_utils/models/linear_model/train.py index aaf8a2e4bf..30e5edf112 100644 --- a/captum/_utils/models/linear_model/train.py +++ b/captum/_utils/models/linear_model/train.py @@ -99,7 +99,6 @@ def sgd_train_linear_model( This will return the final training loss (averaged with `running_loss_window`) """ - loss_window: List[torch.Tensor] = [] min_avg_loss = None convergence_counter = 0 @@ -145,77 +144,77 @@ def get_point(datapoint): if model.linear.bias is not None: model.linear.bias.zero_() - optim = torch.optim.SGD(model.parameters(), lr=initial_lr) - if reduce_lr: - scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( - optim, factor=0.5, patience=patience, threshold=threshold - ) - - t1 = time.time() - epoch = 0 - i = 0 - while epoch < max_epoch: - while True: # for x, y, w in dataloader - if running_loss_window is None: - running_loss_window = x.shape[0] * len(dataloader) - - y = y.view(x.shape[0], -1) - if w is not None: - w = w.view(x.shape[0], -1) - - i += 1 - - out = model(x) - - loss = loss_fn(y, out, w) - if reg_term is not None: - reg = torch.norm(model.linear.weight, p=reg_term) - loss += reg.sum() * alpha - - if len(loss_window) >= running_loss_window: - loss_window = loss_window[1:] - loss_window.append(loss.clone().detach()) - assert len(loss_window) <= running_loss_window - - average_loss = torch.mean(torch.stack(loss_window)) - if min_avg_loss is not None: - # if we haven't improved by at least `threshold` - if average_loss > min_avg_loss or torch.isclose( - min_avg_loss, average_loss, atol=threshold - ): - convergence_counter += 1 - if convergence_counter >= patience: - converged = True - break - else: - convergence_counter = 0 - if min_avg_loss is None or min_avg_loss >= average_loss: - min_avg_loss = average_loss.clone() - - if debug: - print( - f"lr={optim.param_groups[0]['lr']}, Loss={loss}," - + "Aloss={average_loss}, min_avg_loss={min_avg_loss}" - ) - - loss.backward() - - optim.step() - model.zero_grad() - if scheduler: - scheduler.step(average_loss) - - temp = next(data_iter, None) - if temp is None: + with torch.enable_grad(): + optim = torch.optim.SGD(model.parameters(), lr=initial_lr) + if reduce_lr: + scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( + optim, factor=0.5, patience=patience, threshold=threshold + ) + + t1 = time.time() + epoch = 0 + i = 0 + while epoch < max_epoch: + while True: # for x, y, w in dataloader + if running_loss_window is None: + running_loss_window = x.shape[0] * len(dataloader) + + y = y.view(x.shape[0], -1) + if w is not None: + w = w.view(x.shape[0], -1) + + i += 1 + + out = model(x) + + loss = loss_fn(y, out, w) + if reg_term is not None: + reg = torch.norm(model.linear.weight, p=reg_term) + loss += reg.sum() * alpha + + if len(loss_window) >= running_loss_window: + loss_window = loss_window[1:] + loss_window.append(loss.clone().detach()) + assert len(loss_window) <= running_loss_window + + average_loss = torch.mean(torch.stack(loss_window)) + if min_avg_loss is not None: + # if we haven't improved by at least `threshold` + if average_loss > min_avg_loss or torch.isclose( + min_avg_loss, average_loss, atol=threshold + ): + convergence_counter += 1 + if convergence_counter >= patience: + converged = True + break + else: + convergence_counter = 0 + if min_avg_loss is None or min_avg_loss >= average_loss: + min_avg_loss = average_loss.clone() + + if debug: + print( + f"lr={optim.param_groups[0]['lr']}, Loss={loss}," + + "Aloss={average_loss}, min_avg_loss={min_avg_loss}" + ) + + loss.backward() + optim.step() + model.zero_grad() + if scheduler: + scheduler.step(average_loss) + + temp = next(data_iter, None) + if temp is None: + break + x, y, w = get_point(temp) + + if converged: break - x, y, w = get_point(temp) - - if converged: - break - epoch += 1 - data_iter = iter(dataloader) - x, y, w = get_point(next(data_iter)) + epoch += 1 + data_iter = iter(dataloader) + x, y, w = get_point(next(data_iter)) t2 = time.time() return { diff --git a/captum/attr/_core/lime.py b/captum/attr/_core/lime.py index 76f3f4ca71..520251ce53 100644 --- a/captum/attr/_core/lime.py +++ b/captum/attr/_core/lime.py @@ -512,17 +512,17 @@ def attribute( if show_progress: attr_progress.close() - combined_interp_inps = torch.cat(interpretable_inps).double() + combined_interp_inps = torch.cat(interpretable_inps).float() combined_outputs = ( torch.cat(outputs) if len(outputs[0].shape) > 0 else torch.stack(outputs) - ).double() + ).float() combined_sim = ( torch.cat(similarities) if len(similarities[0].shape) > 0 else torch.stack(similarities) - ).double() + ).float() dataset = TensorDataset( combined_interp_inps, combined_outputs, combined_sim ) diff --git a/tests/attr/test_lime.py b/tests/attr/test_lime.py index 4287aa05ba..45646c47d7 100644 --- a/tests/attr/test_lime.py +++ b/tests/attr/test_lime.py @@ -3,10 +3,12 @@ import io import unittest import unittest.mock -from typing import Any, Callable, Generator, List, Tuple, Union +from functools import partial +from typing import Any, Callable, Generator, List, Optional, Tuple, Union import torch -from captum._utils.models.linear_model import SkLearnLasso +from captum._utils.models.linear_model import SGDLasso, SkLearnLasso +from captum._utils.models.model import Model from captum._utils.typing import BaselineType, TensorOrTupleOfTensorsGeneric from captum.attr._core.lime import get_exp_kernel_similarity_function, Lime, LimeBase from captum.attr._utils.batching import _batch_example_iterator @@ -120,6 +122,22 @@ def test_simple_lime(self) -> None: test_generator=True, ) + def test_simple_lime_sgd_model(self) -> None: + net = BasicModel_MultiLayer() + inp = torch.tensor([[20.0, 50.0, 30.0]], requires_grad=True) + interpretable_model = SGDLasso() + interpretable_model.fit = partial( # type: ignore + interpretable_model.fit, initial_lr=0.1, max_epoch=500 + ) + self._lime_test_assert( + net, + inp, + [[73.3716, 193.3349, 113.3349]], + n_samples=1000, + expected_coefs_only=[[73.3716, 193.3349, 113.3349]], + interpretable_model=interpretable_model, + ) + def test_simple_lime_with_mask(self) -> None: net = BasicModel_MultiLayer() inp = torch.tensor([[20.0, 50.0, 30.0]], requires_grad=True) @@ -487,12 +505,15 @@ def _lime_test_assert( batch_attr: bool = False, test_generator: bool = False, show_progress: bool = False, + interpretable_model: Optional[Model] = None, ) -> None: for batch_size in perturbations_per_eval: lime = Lime( model, similarity_func=get_exp_kernel_similarity_function("cosine", 10.0), - interpretable_model=SkLearnLasso(alpha=1.0), + interpretable_model=interpretable_model + if interpretable_model + else SkLearnLasso(alpha=1.0), ) attributions = lime.attribute( test_input, @@ -526,7 +547,9 @@ def _lime_test_assert( lime_alt = LimeBase( model, - SkLearnLasso(alpha=1.0), + interpretable_model + if interpretable_model + else SkLearnLasso(alpha=1.0), get_exp_kernel_similarity_function("euclidean", 1000.0), alt_perturb_generator if test_generator else alt_perturb_func, False, From 8c28dad6172ea1965b518882a6e30bea17425140 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 18 May 2022 14:12:39 -0600 Subject: [PATCH 012/174] Fix FacetLoss docs --- captum/optim/_core/loss.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 1dca3c50ad..94bcdbf9f5 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -981,13 +981,16 @@ def __init__( visualizing targets from. This is normally the penultimate layer of the model. layer_target (nn.Module): A layer that we have facet_weights for. This - target layer should be below the ultimate_target layer in the model. - strength (float, list of float, optional): A list of floats to use for batch - dimension weighting. Default is set to None for no weighting. - Default: None + target layer should be below the ultimate_target layer in the model. + strength (float, list of float, optional): A single float or list of floats + to use for batch dimension weighting. If using a single value, then it + will be applied to all batch dimensions equally. Otherwise a list of + floats with a shape of: [start, end] should be used for torch.linspace + to calculate the step values in between. Default is set to None for no + weighting. facet_weights (torch.Tensor): Weighting that steers the objective towards a particular theme or concept. These weight values should - come from linear probes trained on layers in target_layers. + come from linear probes trained on layer_target. batch_index (int, optional): The index of the activations to optimize if optimizing a batch of activations. If set to None, defaults to all activations in the batch. @@ -997,6 +1000,8 @@ def __init__( self.ultimate_target = ultimate_target self.layer_target = layer_target self.vec = vec + if isinstance(strength, (tuple, list)): + assert len(strength) == 2 self.strength = strength assert facet_weights.dim() == 4 or facet_weights.dim() == 2 self.facet_weights = facet_weights From 32fc6936783f839c428c7604fe584666b7fd12bf Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 18 May 2022 14:20:53 -0600 Subject: [PATCH 013/174] Improve VectorLoss docs --- captum/optim/_core/loss.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 94bcdbf9f5..cd52f02951 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -916,12 +916,8 @@ def __init__( Args: target (nn.Module): A target layer instance. - vec (torch.Tensor): A direction vector to use, with a compatible shape for - computing the matrix product of the activations. See torch.matmul for - See torch.matmul for more details on compatible shapes: - https://pytorch.org/docs/stable/generated/torch.matmul.html - By default, vec is expected to share the same size as the channel - dimension of the activations. + vec (torch.Tensor): A 1D channel vector with the same size as the + channel / feature dimension of the target layer instance. activation_fn (Callable, optional): An optional activation function to apply to the activations before computing the matrix product. If set to None, then no activation function will be used. @@ -936,6 +932,7 @@ def __init__( Default: None """ BaseLoss.__init__(self, target, batch_index) + assert vec.dim() == 1 self.vec = vec self.activation_fn = activation_fn self.move_channel_dim_to_final_dim = move_channel_dim_to_final_dim @@ -976,7 +973,8 @@ def __init__( """ Args: - vec (torch.Tensor): A 1D channel vector. + vec (torch.Tensor): A 1D channel vector with the same size as the + channel / feature dimension of ultimate_target. ultimate_target (nn.Module): The main target layer that we are visualizing targets from. This is normally the penultimate layer of the model. @@ -999,6 +997,7 @@ def __init__( BaseLoss.__init__(self, [ultimate_target, layer_target], batch_index) self.ultimate_target = ultimate_target self.layer_target = layer_target + assert vec.dim() == 1 self.vec = vec if isinstance(strength, (tuple, list)): assert len(strength) == 2 From c211032eb6afff03cc7acee3533aed614a024711 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 18 May 2022 18:55:30 -0700 Subject: [PATCH 014/174] Fix version check bug (#940) Summary: By default: `"1.8.0" > "1.10.0"` will be equal to True, despite 1.10 being a later version that 1.8.0. This PR fixes this issue. Pull Request resolved: https://github.com/pytorch/captum/pull/940 Reviewed By: NarineK Differential Revision: D36336547 Pulled By: vivekmig fbshipit-source-id: 84f277eb1e6897a8378ce9eb8c9eab3285ad8494 --- tests/utils/test_sample_gradient.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/utils/test_sample_gradient.py b/tests/utils/test_sample_gradient.py index 8f49235e72..8f8279b678 100644 --- a/tests/utils/test_sample_gradient.py +++ b/tests/utils/test_sample_gradient.py @@ -5,6 +5,7 @@ import torch from captum._utils.sample_gradient import SampleGradientWrapper, SUPPORTED_MODULES +from packaging import version from tests.helpers.basic import assertTensorAlmostEqual, BaseTest from tests.helpers.basic_models import ( BasicModel_ConvNet_One_Conv, @@ -37,7 +38,7 @@ def test_sample_grads_conv_mean_multi_inp(self) -> None: self._compare_sample_grads_per_sample(model, inp, lambda x: torch.mean(x)) def test_sample_grads_modified_conv_mean(self) -> None: - if torch.__version__ < "1.8": + if version.parse(torch.__version__) < version.parse("1.8.0"): raise unittest.SkipTest( "Skipping sample gradient test with 3D linear module" "since torch version < 1.8" @@ -50,7 +51,7 @@ def test_sample_grads_modified_conv_mean(self) -> None: ) def test_sample_grads_modified_conv_sum(self) -> None: - if torch.__version__ < "1.8": + if version.parse(torch.__version__) < version.parse("1.8.0"): raise unittest.SkipTest( "Skipping sample gradient test with 3D linear module" "since torch version < 1.8" From 7b78aaad80e7d5d411f768c1190b2ead8f738cfd Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 21 May 2022 16:04:09 -0600 Subject: [PATCH 015/174] Improve loss objective testing * Ensure testing coverage is as high as possible. * Simplified code with new `rmodule_op` function. * Removed the NumPy import from loss testing. --- captum/optim/_core/loss.py | 59 ++--- tests/optim/core/test_loss.py | 472 ++++++++++++++++++++++++++++++---- 2 files changed, 453 insertions(+), 78 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 66bb4c40c2..1365537c19 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -64,40 +64,10 @@ def __rmul__(self, other: Union[int, float, "Loss"]) -> "CompositeLoss": return self.__mul__(other) def __rtruediv__(self, other: Union[int, float, "Loss"]) -> "CompositeLoss": - if isinstance(other, (int, float)): - - def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: - return operator.truediv(other, torch.mean(self(module))) - - name = self.__name__ - target = self.target - elif isinstance(other, Loss): - # This should never get called because __div__ will be called instead - pass - else: - raise TypeError( - "Can only apply math operations with int, float or Loss. Received type " - + str(type(other)) - ) - return CompositeLoss(loss_fn, name=name, target=target) + return rmodule_op(self, other, operator.truediv) def __rpow__(self, other: Union[int, float, "Loss"]) -> "CompositeLoss": - if isinstance(other, (int, float)): - - def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: - return operator.pow(other, torch.mean(self(module))) - - name = self.__name__ - target = self.target - elif isinstance(other, Loss): - # This should never get called because __pow__ will be called instead - pass - else: - raise TypeError( - "Can only apply math operations with int, float or Loss. Received type " - + str(type(other)) - ) - return CompositeLoss(loss_fn, name=name, target=target) + return rmodule_op(self, other, operator.pow) def module_op( @@ -137,6 +107,31 @@ def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: return CompositeLoss(loss_fn, name=name, target=target) +def rmodule_op( + self: Loss, other: Union[int, float, Loss], math_op: Callable +) -> "CompositeLoss": + """ + This is a general function for applying the "r" versions of math operations to + Losses. + """ + if isinstance(other, (int, float)): + + def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: + return math_op(other, self(module)) + + name = self.__name__ + target = self.target + elif isinstance(other, Loss): + # This should never get called because __math_op__ will be called instead + pass + else: + raise TypeError( + "Can only apply math operations with int, float or Loss. Received type " + + str(type(other)) + ) + return CompositeLoss(loss_fn, name=name, target=target) + + class BaseLoss(Loss): def __init__( self, diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 49c35ed9d4..fa24bd9337 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -1,9 +1,9 @@ #!/usr/bin/env python3 +import operator import unittest -from typing import cast, List, Union +from typing import cast, Any, List, Optional, Type, Union import captum.optim._core.loss as opt_loss -import numpy as np import torch from captum.optim.models import collect_activations from packaging import version @@ -16,7 +16,7 @@ def get_loss_value( model: torch.nn.Module, loss: opt_loss.Loss, input_shape: List[int] = [1, 3, 1, 1] -) -> Union[int, float, np.ndarray]: +) -> Union[int, float]: module_outputs = collect_activations(model, loss.target, torch.ones(*input_shape)) loss_value = loss(module_outputs) try: @@ -36,6 +36,12 @@ def test_channel_deepdream(self) -> None: class TestChannelActivation(BaseTest): + def test_channel_activation_init(self) -> None: + model = torch.nn.Identity() + channel_index = 5 + loss = opt_loss.ChannelActivation(model, channel_index=channel_index) + self.assertEqual(loss.channel_index, channel_index) + def test_channel_activation_0(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) @@ -52,6 +58,14 @@ def test_channel_activation_1(self) -> None: class TestNeuronActivation(BaseTest): + def test_neuron_activation_init(self) -> None: + model = torch.nn.Identity() + channel_index = 5 + loss = opt_loss.NeuronActivation(model, channel_index=channel_index) + self.assertEqual(loss.channel_index, channel_index) + self.assertIsNone(loss.x) + self.assertIsNone(loss.y) + def test_neuron_activation_0(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.NeuronActivation(model.layer, 0) @@ -68,6 +82,11 @@ def test_total_variation(self) -> None: class TestL1(BaseTest): + def test_l1_init(self) -> None: + model = torch.nn.Identity() + loss = opt_loss.L1(model) + self.assertEqual(loss.constant, 0.0) + def test_l1(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.L1(model.layer) @@ -79,6 +98,12 @@ def test_l1(self) -> None: class TestL2(BaseTest): + def test_l2_init(self) -> None: + model = torch.nn.Identity() + loss = opt_loss.L2(model) + self.assertEqual(loss.constant, 0.0) + self.assertEqual(loss.epsilon, 1e-6) + def test_l2(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.L2(model.layer) @@ -129,54 +154,140 @@ def test_alignment(self) -> None: ) +class TestDirection(BaseTest): + def test_direction_init(self) -> None: + model = torch.nn.Identity() + vec = torch.ones(2) * 0.5 + loss = opt_loss.Direction(model, vec=vec) + self.assertEqual(list(loss.vec.shape), [1, 2, 1, 1]) + assertTensorAlmostEqual(self, loss.vec, vec.reshape((1, -1, 1, 1)), delta=0.0) + self.assertEqual(loss.cossim_pow, 0.0) + + def test_direction(self) -> None: + model = BasicModel_ConvNet_Optim() + vec = torch.ones(2) + loss = opt_loss.Direction(model.layer, vec=torch.ones(2)) + b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) + dot = torch.sum(vec.reshape((1, -1, 1, 1)) * b.reshape((1, -1, 1, 1)), 1) + self.assertAlmostEqual(get_loss_value(model, loss), dot.item(), places=6) + + class TestNeuronDirection(BaseTest): + def test_neuron_direction_init(self) -> None: + model = torch.nn.Identity() + vec = torch.ones(2) * 0.5 + loss = opt_loss.NeuronDirection(model, vec=vec) + self.assertIsNone(loss.x) + self.assertIsNone(loss.y) + self.assertIsNone(loss.channel_index) + self.assertEqual(loss.cossim_pow, 0.0) + self.assertEqual(list(loss.vec.shape), [1, 2, 1, 1]) + assertTensorAlmostEqual(self, loss.vec, vec.reshape((1, -1, 1, 1)), delta=0.0) + def test_neuron_direction(self) -> None: model = BasicModel_ConvNet_Optim() - loss = opt_loss.NeuronDirection(model.layer, vec=torch.ones(1, 1, 1, 1)) - a = 1 - b = [CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS] - dot = np.sum(np.inner(a, b)) - self.assertAlmostEqual(get_loss_value(model, loss), dot, places=6) + vec = torch.ones(2) + loss = opt_loss.NeuronDirection(model.layer, vec=vec) + b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) + dot = torch.sum(b * vec) + self.assertAlmostEqual(get_loss_value(model, loss), dot.item(), places=6) + + def test_neuron_direction_channel_index(self) -> None: + model = BasicModel_ConvNet_Optim() + vec = torch.ones(2) + loss = opt_loss.NeuronDirection(model.layer, vec=vec, channel_index=0) + + b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) + dot = torch.sum(b * vec) + self.assertAlmostEqual(get_loss_value(model, loss), dot.item(), places=6) class TestAngledNeuronDirection(BaseTest): - def test_angled_neuron_direction(self) -> None: - model = BasicModel_ConvNet_Optim() + def test_neuron_activation_init(self) -> None: + model = torch.nn.Identity() + vec = torch.ones(1, 2) * 0.5 loss = opt_loss.AngledNeuronDirection( - model.layer, vec=torch.ones(1, 2), cossim_pow=0 + model, + vec=vec, ) - a = 1 - b = [CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS] - dot = torch.sum(torch.as_tensor(np.inner(a, b))).item() + self.assertEqual(loss.eps, 1.0e-4) + self.assertEqual(loss.cossim_pow, 4.0) + self.assertIsNone(loss.x) + self.assertIsNone(loss.y) + self.assertIsNone(loss.vec_whitened) + assertTensorAlmostEqual(self, loss.vec, vec, delta=0.0) + + def test_angled_neuron_direction(self) -> None: + model = BasicModel_ConvNet_Optim() + vec = torch.ones(1, 2) + loss = opt_loss.AngledNeuronDirection(model.layer, vec=vec, cossim_pow=0) + b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS]) + dot = torch.sum(b * vec).item() output = torch.sum(cast(torch.Tensor, get_loss_value(model, loss))) self.assertAlmostEqual(output.item(), dot, places=6) def test_angled_neuron_direction_whitened(self) -> None: model = BasicModel_ConvNet_Optim() + vec = torch.ones(1, 2) loss = opt_loss.AngledNeuronDirection( model.layer, - vec=torch.ones(1, 2), + vec=vec, vec_whitened=torch.ones(2, 2), cossim_pow=0, ) - a = 1 - b = [CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS] - dot = torch.sum(torch.as_tensor(np.inner(a, b))).item() * 2 + b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS]) + dot = torch.sum(vec * b).item() * 2 output = torch.sum(cast(torch.Tensor, get_loss_value(model, loss))) self.assertAlmostEqual(output.item(), dot, places=6) + def test_angled_neuron_direction_cossim_pow_4(self) -> None: + model = BasicModel_ConvNet_Optim() + cossim_pow = 4.0 + vec = torch.ones(1, 2) + loss = opt_loss.AngledNeuronDirection( + model.layer, vec=vec, cossim_pow=cossim_pow + ) + a = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS])[ + None, : + ] + + dot = torch.mean(a * vec) + cossims = dot / (1.0e-4 + torch.sqrt(torch.sum(a**2))) + dot = dot * torch.clamp(cossims, min=0.1) ** cossim_pow + + output = get_loss_value(model, loss) + self.assertAlmostEqual(output, dot.item(), places=6) + class TestTensorDirection(BaseTest): + def test_tensor_init(self) -> None: + model = BasicModel_ConvNet_Optim() + vec = torch.ones(1, 1, 1, 1) + loss = opt_loss.TensorDirection(model.layer, vec=vec) + self.assertEqual(loss.cossim_pow, 0.0) + assertTensorAlmostEqual(self, loss.vec, vec, delta=0.0) + def test_tensor_direction(self) -> None: model = BasicModel_ConvNet_Optim() - loss = opt_loss.TensorDirection(model.layer, vec=torch.ones(1, 1, 1, 1)) - a = 1 - b = [CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS] - dot = np.sum(np.inner(a, b)) + vec = torch.ones(1, 1, 1, 1) + loss = opt_loss.TensorDirection(model.layer, vec=vec) + b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) + dot = torch.sum(b[None, :, None, None] * vec).item() self.assertAlmostEqual(get_loss_value(model, loss), dot, places=6) class TestActivationWeights(BaseTest): + def test_neuron_activation_init(self) -> None: + model = torch.nn.Identity() + weights = torch.zeros(1) + loss = opt_loss.ActivationWeights(model, weights=weights) + self.assertIsNone(loss.x) + self.assertIsNone(loss.y) + self.assertIsNone(loss.wx) + self.assertIsNone(loss.wy) + self.assertFalse(loss.neuron) + assertTensorAlmostEqual(self, loss.weights, weights, delta=0.0) + def test_activation_weights_0(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ActivationWeights(model.layer, weights=torch.zeros(1)) @@ -196,8 +307,89 @@ def test_activation_weights_1(self) -> None: mode="max", ) + def test_activation_weights_neuron_1(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ActivationWeights( + model.layer, weights=torch.ones(1), neuron=True, x=0, y=0, wx=1, wy=1 + ) + assertTensorAlmostEqual( + self, + get_loss_value(model, loss), + torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS])[ + None, :, None, None + ], + mode="max", + ) + + +class _OverrideAbstractFunctions: + """ + Context manager for testing classes with abstract functions. + + Examples:: + >>> # Overriding the abstract methods in BaseLoss + >>> with _OverrideAbstractFunctions(path.to.classtype): + >>> # Do stuff with + """ + + def __init__(self, class_type: Type) -> None: + """ + Args: + + class_type (type): The path to the library class type. + """ + self.class_type = class_type + + def __enter__(self) -> None: + self.abstract_methods = self.class_type.__abstractmethods__ + self.class_type.__abstractmethods__ = frozenset() + + def __exit__(self, *args: Any) -> None: + self.class_type.__abstractmethods__ = self.abstract_methods + + +class TestLoss(BaseTest): + def test_loss_init(self) -> None: + with _OverrideAbstractFunctions(opt_loss.Loss): + loss = opt_loss.Loss() + self.assertIsNone(loss.target) + self.assertEqual(opt_loss.Loss.__name__, "Loss") + + +class TestBaseLoss(BaseTest): + def test_subclass(self) -> None: + self.assertTrue(issubclass(opt_loss.BaseLoss, opt_loss.Loss)) + + def test_base_loss_init(self) -> None: + model = torch.nn.Identity() + with _OverrideAbstractFunctions(opt_loss.BaseLoss): + loss = opt_loss.BaseLoss(model) + self.assertEqual(loss._batch_index, (None, None)) + self.assertEqual(loss.batch_index, (None, None)) + self.assertEqual(loss._target, model) + self.assertEqual(loss.target, model) + + def test_base_loss_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 5 + with _OverrideAbstractFunctions(opt_loss.BaseLoss): + loss = opt_loss.BaseLoss(model, batch_index=batch_index) + self.assertEqual(loss._batch_index, (batch_index, batch_index + 1)) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + + def test_base_loss_target_list(self) -> None: + model = torch.nn.Sequential(torch.nn.Identity(), torch.nn.Identity()) + targets = [model[0], model[1]] + with _OverrideAbstractFunctions(opt_loss.BaseLoss): + loss = opt_loss.BaseLoss(targets) + self.assertEqual(loss._target, targets) + self.assertEqual(loss.target, targets) + class TestCompositeLoss(BaseTest): + def test_subclass(self) -> None: + self.assertTrue(issubclass(opt_loss.CompositeLoss, opt_loss.BaseLoss)) + def test_negative(self) -> None: model = BasicModel_ConvNet_Optim() loss = -opt_loss.ChannelActivation(model.layer, 0) @@ -218,6 +410,15 @@ def test_addition(self) -> None: places=6, ) + def test_radd(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = 1.0 + opt_loss.ChannelActivation(model.layer, 0) + self.assertAlmostEqual( + get_loss_value(model, loss), + CHANNEL_ACTIVATION_0_LOSS + 1.0, + places=6, + ) + def test_subtraction(self) -> None: model = BasicModel_ConvNet_Optim() loss = ( @@ -230,6 +431,25 @@ def test_subtraction(self) -> None: CHANNEL_ACTIVATION_0_LOSS - CHANNEL_ACTIVATION_1_LOSS - 1, ) + def test_rsub(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = 1.0 - opt_loss.ChannelActivation(model.layer, 0) + self.assertAlmostEqual( + get_loss_value(model, loss), + 1.0 - CHANNEL_ACTIVATION_0_LOSS, + ) + + def test_multiplication_loss_type(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) * opt_loss.ChannelActivation( + model.layer, 1 + ) + self.assertAlmostEqual( + get_loss_value(model, loss), + CHANNEL_ACTIVATION_0_LOSS * CHANNEL_ACTIVATION_0_LOSS, + places=5, + ) + def test_multiplication(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) * 10 @@ -237,14 +457,32 @@ def test_multiplication(self) -> None: get_loss_value(model, loss), CHANNEL_ACTIVATION_0_LOSS * 10, places=5 ) - # def test_multiplication_error(self) -> None: - # model = BasicModel_ConvNet_Optim() - # with self.assertRaises(TypeError): - # opt_loss.ChannelActivation(model.layer, 0) * "string" - # with self.assertRaises(TypeError): - # opt_loss.ChannelActivation(model.layer, 0) * opt_loss.ChannelActivation( - # model.layer, 1 - # ) + def test_multiplication_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + opt_loss.ChannelActivation(model.layer, 0) * "string" + + def test_rmul(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = 10 * opt_loss.ChannelActivation(model.layer, 0) + self.assertAlmostEqual( + get_loss_value(model, loss), 10 * CHANNEL_ACTIVATION_0_LOSS, places=5 + ) + + def test_rmul_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + "string" * opt_loss.ChannelActivation(model.layer, 0) + + def test_division_loss_type(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) / opt_loss.ChannelActivation( + model.layer, 1 + ) + self.assertAlmostEqual( + get_loss_value(model, loss), + CHANNEL_ACTIVATION_0_LOSS / CHANNEL_ACTIVATION_0_LOSS, + ) def test_division(self) -> None: model = BasicModel_ConvNet_Optim() @@ -253,14 +491,35 @@ def test_division(self) -> None: get_loss_value(model, loss), CHANNEL_ACTIVATION_0_LOSS / 10 ) - # def test_division_error(self) -> None: - # model = BasicModel_ConvNet_Optim() - # with self.assertRaises(TypeError): - # opt_loss.ChannelActivation(model.layer, 0) / "string" - # with self.assertRaises(TypeError): - # opt_loss.ChannelActivation(model.layer, 0) / opt_loss.ChannelActivation( - # model.layer, 1 - # ) + def test_division_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + opt_loss.ChannelActivation(model.layer, 0) / "string" + + def test_rdiv(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = 10.0 / opt_loss.ChannelActivation(model.layer, 0) + self.assertAlmostEqual( + get_loss_value(model, loss), + 10.0 / CHANNEL_ACTIVATION_0_LOSS, + places=6, + ) + + def test_rdiv_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + "string" / opt_loss.ChannelActivation(model.layer, 0) + + def test_pow_loss_type(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) ** opt_loss.ChannelActivation( + model.layer, 1 + ) + self.assertAlmostEqual( + get_loss_value(model, loss), + CHANNEL_ACTIVATION_0_LOSS**CHANNEL_ACTIVATION_0_LOSS, + places=6, + ) def test_pow(self) -> None: model = BasicModel_ConvNet_Optim() @@ -271,14 +530,24 @@ def test_pow(self) -> None: places=6, ) - # def test_pow_error(self) -> None: - # model = BasicModel_ConvNet_Optim() - # with self.assertRaises(TypeError): - # opt_loss.ChannelActivation(model.layer, 0) ** "string" - # with self.assertRaises(TypeError): - # opt_loss.ChannelActivation(model.layer, 0) ** opt_loss.ChannelActivation( - # model.layer, 1 - # ) + def test_pow_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + opt_loss.ChannelActivation(model.layer, 0) ** "string" + + def test_rpow(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = 2.0 ** opt_loss.ChannelActivation(model.layer, 0) + self.assertAlmostEqual( + get_loss_value(model, loss), + 2.0**CHANNEL_ACTIVATION_0_LOSS, + places=6, + ) + + def test_rpow_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + "string" ** opt_loss.ChannelActivation(model.layer, 0) def test_sum_loss_list(self) -> None: n_batch = 400 @@ -295,3 +564,114 @@ def test_sum_loss_list_compose_add(self) -> None: loss_fn = opt_loss.sum_loss_list(loss_fn_list) + opt_loss.LayerActivation(model) out = get_loss_value(model, loss_fn, [n_batch, 3, 1, 1]) self.assertEqual(out, float(n_batch + 1.0)) + + +class TestModuleOP(BaseTest): + def test_module_op_loss_unary_op(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) + composed_loss = opt_loss.module_op(loss, None, operator.neg) + + expected_name = "ChannelActivation [Conv2d(3, 2, ke..., 0]" + self.assertEqual(composed_loss.__name__, expected_name) + output = get_loss_value(model, composed_loss) + expected = -torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS]).sum().item() + self.assertEqual(output, expected) + + def test_module_op_loss_num_add(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) + composed_loss = opt_loss.module_op(loss, 1.0, operator.add) + + expected_name = "ChannelActivation [Conv2d(3, 2, ke..., 0]" + self.assertEqual(composed_loss.__name__, expected_name) + output = get_loss_value(model, composed_loss) + expected = torch.tensor([CHANNEL_ACTIVATION_0_LOSS]) + 1.0 + self.assertEqual(output, expected.item()) + + def test_module_op_loss_loss_add(self) -> None: + model = BasicModel_ConvNet_Optim() + loss1 = opt_loss.ChannelActivation(model.layer, 0) + loss2 = opt_loss.ChannelActivation(model.layer, 1) + composed_loss = opt_loss.module_op(loss1, loss2, operator.add) + + expected_name = ( + "Compose(ChannelActivation [Conv2d(3, 2, ke..., 0], " + + "ChannelActivation [Conv2d(3, 2, ke..., 1])" + ) + self.assertEqual(composed_loss.__name__, expected_name) + output = get_loss_value(model, composed_loss) + expected = ( + torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS]) + .sum() + .item() + ) + self.assertEqual(output, expected) + + def test_module_op_loss_pow_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + opt_loss.module_op( + opt_loss.ChannelActivation(model.layer, 0), "string", operator.pow + ) + + +class TestRModuleOP(BaseTest): + def test_module_op_loss_num_div(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) + composed_loss = opt_loss.rmodule_op(loss, 1.0, operator.pow) + + output = get_loss_value(model, composed_loss) + self.assertEqual(output, 1.0**CHANNEL_ACTIVATION_0_LOSS) + + def test_rmodule_op_loss_pow_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + opt_loss.rmodule_op( + opt_loss.ChannelActivation(model.layer, 0), "string", operator.pow + ) + + +class TestDefaultLossSummarize(BaseTest): + def test_default_loss_summarize(self) -> None: + x = torch.arange(0, 1 * 3 * 5 * 5).view(1, 3, 5, 5).float() + output = opt_loss.default_loss_summarize(x) + self.assertEqual(output.item(), -37.0) + + +class TestMakeArgStr(BaseTest): + def test_make_arg_str(self) -> None: + args = {"a": 5, "b": None} + output = opt_loss._make_arg_str(args) + self.assertEqual(output, "{'a': 5, 'b': N...") + args = {"c": torch.nn.Identity, "d": "test"} + output = opt_loss._make_arg_str(args) + self.assertEqual(output, "{'c': None: + @opt_loss.loss_wrapper + class TestClass: + def __init__( + self, + target: torch.nn.Module, + test_var: int, + batch_index: Optional[int] = None, + ) -> None: + self.target = target + self.batch_index = batch_index + self.test_var = test_var + + def __call__(self) -> int: + return self.test_var + + test_module = TestClass(torch.nn.Identity(), test_var=5, batch_index=0) + self.assertEqual(test_module.__name__, "TestClass [Identity()]") + + test_module = TestClass(torch.nn.Identity(), 5, 0) + self.assertEqual(test_module.__name__, "TestClass [Identity(), 5, 0]") + + test_module = TestClass(torch.nn.Identity(), 5) + self.assertEqual(test_module.__name__, "TestClass [Identity(), 5]") From 69a73b2f958d57cca357fe9984819d62f8aae9fd Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 21 May 2022 16:23:32 -0600 Subject: [PATCH 016/174] Fix mypy test errors --- tests/optim/core/test_loss.py | 41 ++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index fa24bd9337..47b421d629 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -16,7 +16,7 @@ def get_loss_value( model: torch.nn.Module, loss: opt_loss.Loss, input_shape: List[int] = [1, 3, 1, 1] -) -> Union[int, float]: +) -> Union[int, float, torch.Tensor]: module_outputs = collect_activations(model, loss.target, torch.ones(*input_shape)) loss_value = loss(module_outputs) try: @@ -351,7 +351,7 @@ def __exit__(self, *args: Any) -> None: class TestLoss(BaseTest): def test_loss_init(self) -> None: with _OverrideAbstractFunctions(opt_loss.Loss): - loss = opt_loss.Loss() + loss = opt_loss.Loss() # type: ignore self.assertIsNone(loss.target) self.assertEqual(opt_loss.Loss.__name__, "Loss") @@ -363,7 +363,7 @@ def test_subclass(self) -> None: def test_base_loss_init(self) -> None: model = torch.nn.Identity() with _OverrideAbstractFunctions(opt_loss.BaseLoss): - loss = opt_loss.BaseLoss(model) + loss = opt_loss.BaseLoss(model) # type: ignore self.assertEqual(loss._batch_index, (None, None)) self.assertEqual(loss.batch_index, (None, None)) self.assertEqual(loss._target, model) @@ -373,7 +373,7 @@ def test_base_loss_batch_index(self) -> None: model = torch.nn.Identity() batch_index = 5 with _OverrideAbstractFunctions(opt_loss.BaseLoss): - loss = opt_loss.BaseLoss(model, batch_index=batch_index) + loss = opt_loss.BaseLoss(model, batch_index=batch_index) # type: ignore self.assertEqual(loss._batch_index, (batch_index, batch_index + 1)) self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) @@ -381,7 +381,7 @@ def test_base_loss_target_list(self) -> None: model = torch.nn.Sequential(torch.nn.Identity(), torch.nn.Identity()) targets = [model[0], model[1]] with _OverrideAbstractFunctions(opt_loss.BaseLoss): - loss = opt_loss.BaseLoss(targets) + loss = opt_loss.BaseLoss(targets) # type: ignore self.assertEqual(loss._target, targets) self.assertEqual(loss.target, targets) @@ -460,7 +460,7 @@ def test_multiplication(self) -> None: def test_multiplication_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - opt_loss.ChannelActivation(model.layer, 0) * "string" + opt_loss.ChannelActivation(model.layer, 0) * "string" # type: ignore def test_rmul(self) -> None: model = BasicModel_ConvNet_Optim() @@ -472,7 +472,7 @@ def test_rmul(self) -> None: def test_rmul_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - "string" * opt_loss.ChannelActivation(model.layer, 0) + "string" * opt_loss.ChannelActivation(model.layer, 0) # type: ignore def test_division_loss_type(self) -> None: model = BasicModel_ConvNet_Optim() @@ -494,7 +494,7 @@ def test_division(self) -> None: def test_division_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - opt_loss.ChannelActivation(model.layer, 0) / "string" + opt_loss.ChannelActivation(model.layer, 0) / "string" # type: ignore def test_rdiv(self) -> None: model = BasicModel_ConvNet_Optim() @@ -508,7 +508,7 @@ def test_rdiv(self) -> None: def test_rdiv_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - "string" / opt_loss.ChannelActivation(model.layer, 0) + "string" / opt_loss.ChannelActivation(model.layer, 0) # type: ignore def test_pow_loss_type(self) -> None: model = BasicModel_ConvNet_Optim() @@ -533,7 +533,7 @@ def test_pow(self) -> None: def test_pow_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - opt_loss.ChannelActivation(model.layer, 0) ** "string" + opt_loss.ChannelActivation(model.layer, 0) ** "string" # type: ignore def test_rpow(self) -> None: model = BasicModel_ConvNet_Optim() @@ -547,7 +547,7 @@ def test_rpow(self) -> None: def test_rpow_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - "string" ** opt_loss.ChannelActivation(model.layer, 0) + "string" ** opt_loss.ChannelActivation(model.layer, 0) # type: ignore def test_sum_loss_list(self) -> None: n_batch = 400 @@ -611,9 +611,8 @@ def test_module_op_loss_loss_add(self) -> None: def test_module_op_loss_pow_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - opt_loss.module_op( - opt_loss.ChannelActivation(model.layer, 0), "string", operator.pow - ) + loss = opt_loss.ChannelActivation(model.layer, 0) + opt_loss.module_op(loss, "string", operator.pow) # type: ignore class TestRModuleOP(BaseTest): @@ -628,9 +627,8 @@ def test_module_op_loss_num_div(self) -> None: def test_rmodule_op_loss_pow_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - opt_loss.rmodule_op( - opt_loss.ChannelActivation(model.layer, 0), "string", operator.pow - ) + loss = pt_loss.ChannelActivation(model.layer, 0) + opt_loss.rmodule_op(loss, "string", operator.pow) # type: ignore class TestDefaultLossSummarize(BaseTest): @@ -668,10 +666,13 @@ def __call__(self) -> int: return self.test_var test_module = TestClass(torch.nn.Identity(), test_var=5, batch_index=0) - self.assertEqual(test_module.__name__, "TestClass [Identity()]") + expected = "TestClass [Identity()]" + self.assertEqual(test_module.__name__, expected) # type: ignore test_module = TestClass(torch.nn.Identity(), 5, 0) - self.assertEqual(test_module.__name__, "TestClass [Identity(), 5, 0]") + expected = "TestClass [Identity(), 5, 0]" + self.assertEqual(test_module.__name__, expected) # type: ignore test_module = TestClass(torch.nn.Identity(), 5) - self.assertEqual(test_module.__name__, "TestClass [Identity(), 5]") + expected = "TestClass [Identity(), 5]" + self.assertEqual(test_module.__name__, expected) # type: ignore From caffe7c5b7292e7a5af1a15865f2bd6a1154563a Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 21 May 2022 17:53:37 -0600 Subject: [PATCH 017/174] Fix mypy tests --- tests/optim/core/test_loss.py | 84 +++++++++++++++++++++-------------- 1 file changed, 50 insertions(+), 34 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 47b421d629..222f4cf03b 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 import operator import unittest -from typing import cast, Any, List, Optional, Type, Union +from typing import Any, List, Optional, Type import captum.optim._core.loss as opt_loss import torch @@ -16,13 +16,9 @@ def get_loss_value( model: torch.nn.Module, loss: opt_loss.Loss, input_shape: List[int] = [1, 3, 1, 1] -) -> Union[int, float, torch.Tensor]: +) -> torch.Tensor: module_outputs = collect_activations(model, loss.target, torch.ones(*input_shape)) - loss_value = loss(module_outputs) - try: - return loss_value.item() - except ValueError: - return loss_value.detach() + return loss(module_outputs).detach() class TestDeepDream(BaseTest): @@ -46,14 +42,14 @@ def test_channel_activation_0(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), CHANNEL_ACTIVATION_0_LOSS, places=6 + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS, places=6 ) def test_channel_activation_1(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 1) self.assertAlmostEqual( - get_loss_value(model, loss), CHANNEL_ACTIVATION_1_LOSS, places=6 + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_1_LOSS, places=6 ) @@ -70,7 +66,7 @@ def test_neuron_activation_0(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.NeuronActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), CHANNEL_ACTIVATION_0_LOSS, places=6 + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS, places=6 ) @@ -78,7 +74,7 @@ class TestTotalVariation(BaseTest): def test_total_variation(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.TotalVariation(model.layer) - self.assertAlmostEqual(get_loss_value(model, loss), 0.0) + self.assertAlmostEqual(get_loss_value(model, loss).item(), 0.0) class TestL1(BaseTest): @@ -91,7 +87,7 @@ def test_l1(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.L1(model.layer) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS + CHANNEL_ACTIVATION_1_LOSS, places=6, ) @@ -108,7 +104,7 @@ def test_l2(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.L2(model.layer) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), (CHANNEL_ACTIVATION_0_LOSS**2 + CHANNEL_ACTIVATION_1_LOSS**2) ** 0.5, places=5, ) @@ -119,7 +115,7 @@ def test_diversity(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.Diversity(model.layer) self.assertAlmostEqual( - get_loss_value(model, loss, input_shape=[2, 3, 1, 1]), + get_loss_value(model, loss, input_shape=[2, 3, 1, 1]).item(), -1, ) @@ -139,7 +135,7 @@ def test_activation_interpolation_0_1(self) -> None: channel_index2=1, ) self.assertAlmostEqual( - get_loss_value(model, loss, input_shape=[2, 3, 1, 1]), + get_loss_value(model, loss, input_shape=[2, 3, 1, 1]).item(), CHANNEL_ACTIVATION_0_LOSS + CHANNEL_ACTIVATION_1_LOSS, places=6, ) @@ -150,7 +146,7 @@ def test_alignment(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.Alignment(model.layer) self.assertAlmostEqual( - get_loss_value(model, loss, input_shape=[2, 3, 1, 1]), 0.0 + get_loss_value(model, loss, input_shape=[2, 3, 1, 1]).item(), 0.0 ) @@ -169,7 +165,7 @@ def test_direction(self) -> None: loss = opt_loss.Direction(model.layer, vec=torch.ones(2)) b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) dot = torch.sum(vec.reshape((1, -1, 1, 1)) * b.reshape((1, -1, 1, 1)), 1) - self.assertAlmostEqual(get_loss_value(model, loss), dot.item(), places=6) + self.assertAlmostEqual(get_loss_value(model, loss).item(), dot.item(), places=6) class TestNeuronDirection(BaseTest): @@ -190,7 +186,7 @@ def test_neuron_direction(self) -> None: loss = opt_loss.NeuronDirection(model.layer, vec=vec) b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) dot = torch.sum(b * vec) - self.assertAlmostEqual(get_loss_value(model, loss), dot.item(), places=6) + self.assertAlmostEqual(get_loss_value(model, loss).item(), dot.item(), places=6) def test_neuron_direction_channel_index(self) -> None: model = BasicModel_ConvNet_Optim() @@ -199,7 +195,7 @@ def test_neuron_direction_channel_index(self) -> None: b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) dot = torch.sum(b * vec) - self.assertAlmostEqual(get_loss_value(model, loss), dot.item(), places=6) + self.assertAlmostEqual(get_loss_value(model, loss).item(), dot.item(), places=6) class TestAngledNeuronDirection(BaseTest): @@ -223,7 +219,7 @@ def test_angled_neuron_direction(self) -> None: loss = opt_loss.AngledNeuronDirection(model.layer, vec=vec, cossim_pow=0) b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS]) dot = torch.sum(b * vec).item() - output = torch.sum(cast(torch.Tensor, get_loss_value(model, loss))) + output = torch.sum(get_loss_value(model, loss)) self.assertAlmostEqual(output.item(), dot, places=6) def test_angled_neuron_direction_whitened(self) -> None: @@ -237,7 +233,7 @@ def test_angled_neuron_direction_whitened(self) -> None: ) b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS]) dot = torch.sum(vec * b).item() * 2 - output = torch.sum(cast(torch.Tensor, get_loss_value(model, loss))) + output = torch.sum(get_loss_value(model, loss)) self.assertAlmostEqual(output.item(), dot, places=6) def test_angled_neuron_direction_cossim_pow_4(self) -> None: @@ -255,7 +251,7 @@ def test_angled_neuron_direction_cossim_pow_4(self) -> None: cossims = dot / (1.0e-4 + torch.sqrt(torch.sum(a**2))) dot = dot * torch.clamp(cossims, min=0.1) ** cossim_pow - output = get_loss_value(model, loss) + output = get_loss_value(model, loss).item() self.assertAlmostEqual(output, dot.item(), places=6) @@ -273,7 +269,7 @@ def test_tensor_direction(self) -> None: loss = opt_loss.TensorDirection(model.layer, vec=vec) b = torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS]) dot = torch.sum(b[None, :, None, None] * vec).item() - self.assertAlmostEqual(get_loss_value(model, loss), dot, places=6) + self.assertAlmostEqual(get_loss_value(model, loss).item(), dot, places=6) class TestActivationWeights(BaseTest): @@ -394,7 +390,7 @@ def test_negative(self) -> None: model = BasicModel_ConvNet_Optim() loss = -opt_loss.ChannelActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), -CHANNEL_ACTIVATION_0_LOSS, places=6 + get_loss_value(model, loss).item(), -CHANNEL_ACTIVATION_0_LOSS, places=6 ) def test_addition(self) -> None: @@ -405,7 +401,7 @@ def test_addition(self) -> None: + 1 ) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS + CHANNEL_ACTIVATION_1_LOSS + 1, places=6, ) @@ -414,7 +410,7 @@ def test_radd(self) -> None: model = BasicModel_ConvNet_Optim() loss = 1.0 + opt_loss.ChannelActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS + 1.0, places=6, ) @@ -427,15 +423,20 @@ def test_subtraction(self) -> None: - 1 ) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS - CHANNEL_ACTIVATION_1_LOSS - 1, ) def test_rsub(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping CompositeLoss rsub test due to insufficient Torch" + + " version." + ) model = BasicModel_ConvNet_Optim() loss = 1.0 - opt_loss.ChannelActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), 1.0 - CHANNEL_ACTIVATION_0_LOSS, ) @@ -445,7 +446,7 @@ def test_multiplication_loss_type(self) -> None: model.layer, 1 ) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS * CHANNEL_ACTIVATION_0_LOSS, places=5, ) @@ -454,7 +455,7 @@ def test_multiplication(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) * 10 self.assertAlmostEqual( - get_loss_value(model, loss), CHANNEL_ACTIVATION_0_LOSS * 10, places=5 + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS * 10, places=5 ) def test_multiplication_error(self) -> None: @@ -466,7 +467,7 @@ def test_rmul(self) -> None: model = BasicModel_ConvNet_Optim() loss = 10 * opt_loss.ChannelActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), 10 * CHANNEL_ACTIVATION_0_LOSS, places=5 + get_loss_value(model, loss).item(), 10 * CHANNEL_ACTIVATION_0_LOSS, places=5 ) def test_rmul_error(self) -> None: @@ -480,7 +481,7 @@ def test_division_loss_type(self) -> None: model.layer, 1 ) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS / CHANNEL_ACTIVATION_0_LOSS, ) @@ -488,7 +489,7 @@ def test_division(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) / 10 self.assertAlmostEqual( - get_loss_value(model, loss), CHANNEL_ACTIVATION_0_LOSS / 10 + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS / 10 ) def test_division_error(self) -> None: @@ -568,6 +569,11 @@ def test_sum_loss_list_compose_add(self) -> None: class TestModuleOP(BaseTest): def test_module_op_loss_unary_op(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping ModuleOP unary op test due to insufficient Torch" + + " version." + ) model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) composed_loss = opt_loss.module_op(loss, None, operator.neg) @@ -579,6 +585,11 @@ def test_module_op_loss_unary_op(self) -> None: self.assertEqual(output, expected) def test_module_op_loss_num_add(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping ModuleOP loss add num test due to insufficient Torch" + + " version." + ) model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) composed_loss = opt_loss.module_op(loss, 1.0, operator.add) @@ -590,6 +601,11 @@ def test_module_op_loss_num_add(self) -> None: self.assertEqual(output, expected.item()) def test_module_op_loss_loss_add(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping ModuleOP Loss add Loss test due to insufficient Torch" + + " version." + ) model = BasicModel_ConvNet_Optim() loss1 = opt_loss.ChannelActivation(model.layer, 0) loss2 = opt_loss.ChannelActivation(model.layer, 1) @@ -627,7 +643,7 @@ def test_module_op_loss_num_div(self) -> None: def test_rmodule_op_loss_pow_error(self) -> None: model = BasicModel_ConvNet_Optim() with self.assertRaises(TypeError): - loss = pt_loss.ChannelActivation(model.layer, 0) + loss = opt_loss.ChannelActivation(model.layer, 0) opt_loss.rmodule_op(loss, "string", operator.pow) # type: ignore From 973aacc0373e5427a73085265d0e631a605e2c6f Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 21 May 2022 18:00:07 -0600 Subject: [PATCH 018/174] Update test_loss.py --- tests/optim/core/test_loss.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 222f4cf03b..5ac5660a16 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -501,7 +501,7 @@ def test_rdiv(self) -> None: model = BasicModel_ConvNet_Optim() loss = 10.0 / opt_loss.ChannelActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), 10.0 / CHANNEL_ACTIVATION_0_LOSS, places=6, ) @@ -517,7 +517,7 @@ def test_pow_loss_type(self) -> None: model.layer, 1 ) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS**CHANNEL_ACTIVATION_0_LOSS, places=6, ) @@ -526,7 +526,7 @@ def test_pow(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.ChannelActivation(model.layer, 0) ** 2 self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS**2, places=6, ) @@ -540,7 +540,7 @@ def test_rpow(self) -> None: model = BasicModel_ConvNet_Optim() loss = 2.0 ** opt_loss.ChannelActivation(model.layer, 0) self.assertAlmostEqual( - get_loss_value(model, loss), + get_loss_value(model, loss).item(), 2.0**CHANNEL_ACTIVATION_0_LOSS, places=6, ) From 6e6f4e6fb7a902118ae8a5c8f9a2ca5d9e95506d Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 22 May 2022 13:17:47 -0600 Subject: [PATCH 019/174] Add more tests --- tests/optim/core/test_loss.py | 177 ++++++++++++++++++++++++++++++++-- 1 file changed, 170 insertions(+), 7 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 5ac5660a16..5db47db850 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 import operator import unittest -from typing import Any, List, Optional, Type +from typing import Any, List, Optional, Type, Union import captum.optim._core.loss as opt_loss import torch @@ -15,14 +15,20 @@ def get_loss_value( - model: torch.nn.Module, loss: opt_loss.Loss, input_shape: List[int] = [1, 3, 1, 1] + model: torch.nn.Module, + loss: opt_loss.Loss, + model_input: Union[List[int], torch.Tensor] = [1, 3, 1, 1], ) -> torch.Tensor: - module_outputs = collect_activations(model, loss.target, torch.ones(*input_shape)) + if isinstance(model_input, (list, tuple)): + model_input = torch.ones(*model_input) + else: + assert isinstance(model_input, torch.Tensor) + module_outputs = collect_activations(model, loss.target, model_input) return loss(module_outputs).detach() class TestDeepDream(BaseTest): - def test_channel_deepdream(self) -> None: + def test_deepdream(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.DeepDream(model.layer) expected = torch.as_tensor( @@ -30,6 +36,42 @@ def test_channel_deepdream(self) -> None: )[None, :] assertTensorAlmostEqual(self, get_loss_value(model, loss), expected, mode="max") + def test_deepdream_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + loss = opt_loss.DeepDream(model, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + assertTensorAlmostEqual( + self, output, model_input[batch_index : batch_index + 1] ** 2, delta=0.0 + ) + + +class TestLayerActivation(BaseTest): + def test_layer_activation(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.LayerActivation(model.layer) + output = get_loss_value(model, loss) + expected = torch.as_tensor( + [CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS] + ) + + assertTensorAlmostEqual(self, output, expected[None, :, None, None], delta=0.0) + + def test_layer_activation_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + loss = opt_loss.LayerActivation(model, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + assertTensorAlmostEqual( + self, output, model_input[batch_index : batch_index + 1], delta=0.0 + ) + class TestChannelActivation(BaseTest): def test_channel_activation_init(self) -> None: @@ -52,6 +94,24 @@ def test_channel_activation_1(self) -> None: get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_1_LOSS, places=6 ) + def test_channel_index_activation_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + channel_index = 2 + loss = opt_loss.ChannelActivation( + model, channel_index=channel_index, batch_index=batch_index + ) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + assertTensorAlmostEqual( + self, + output, + model_input[batch_index : batch_index + 1, channel_index], + delta=0.0, + ) + class TestNeuronActivation(BaseTest): def test_neuron_activation_init(self) -> None: @@ -69,6 +129,24 @@ def test_neuron_activation_0(self) -> None: get_loss_value(model, loss).item(), CHANNEL_ACTIVATION_0_LOSS, places=6 ) + def test_neuron_activation_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + channel_index = 2 + loss = opt_loss.NeuronActivation( + model, channel_index=channel_index, batch_index=batch_index + ) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + assertTensorAlmostEqual( + self, + output, + model_input[batch_index : batch_index + 1, channel_index, 2:3, 2:3], + delta=0.0, + ) + class TestTotalVariation(BaseTest): def test_total_variation(self) -> None: @@ -76,6 +154,16 @@ def test_total_variation(self) -> None: loss = opt_loss.TotalVariation(model.layer) self.assertAlmostEqual(get_loss_value(model, loss).item(), 0.0) + def test_total_variation_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + loss = opt_loss.TotalVariation(model, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + self.assertEqual(output.item(), 360.0) + class TestL1(BaseTest): def test_l1_init(self) -> None: @@ -92,6 +180,16 @@ def test_l1(self) -> None: places=6, ) + def test_l1_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + loss = opt_loss.L1(model, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + self.assertEqual(output.item(), 8400.0) + class TestL2(BaseTest): def test_l2_init(self) -> None: @@ -109,13 +207,23 @@ def test_l2(self) -> None: places=5, ) + def test_l2_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + loss = opt_loss.L2(model, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + self.assertEqual(output.item(), 987.9017944335938) + class TestDiversity(BaseTest): def test_diversity(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.Diversity(model.layer) self.assertAlmostEqual( - get_loss_value(model, loss, input_shape=[2, 3, 1, 1]).item(), + get_loss_value(model, loss, model_input=[2, 3, 1, 1]).item(), -1, ) @@ -135,7 +243,7 @@ def test_activation_interpolation_0_1(self) -> None: channel_index2=1, ) self.assertAlmostEqual( - get_loss_value(model, loss, input_shape=[2, 3, 1, 1]).item(), + get_loss_value(model, loss, model_input=[2, 3, 1, 1]).item(), CHANNEL_ACTIVATION_0_LOSS + CHANNEL_ACTIVATION_1_LOSS, places=6, ) @@ -146,7 +254,7 @@ def test_alignment(self) -> None: model = BasicModel_ConvNet_Optim() loss = opt_loss.Alignment(model.layer) self.assertAlmostEqual( - get_loss_value(model, loss, input_shape=[2, 3, 1, 1]).item(), 0.0 + get_loss_value(model, loss, model_input=[2, 3, 1, 1]).item(), 0.0 ) @@ -167,6 +275,29 @@ def test_direction(self) -> None: dot = torch.sum(vec.reshape((1, -1, 1, 1)) * b.reshape((1, -1, 1, 1)), 1) self.assertAlmostEqual(get_loss_value(model, loss).item(), dot.item(), places=6) + def test_direction_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + vec = torch.tensor([0, 1, 0]).float() + loss = opt_loss.Direction(model, vec=vec, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + + expected = torch.tensor( + [ + [ + [100.0, 101.0, 102.0, 103.0, 104.0], + [105.0, 106.0, 107.0, 108.0, 109.0], + [110.0, 111.0, 112.0, 113.0, 114.0], + [115.0, 116.0, 117.0, 118.0, 119.0], + [120.0, 121.0, 122.0, 123.0, 124.0], + ] + ] + ) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + assertTensorAlmostEqual(self, output, expected, delta=0.0) + class TestNeuronDirection(BaseTest): def test_neuron_direction_init(self) -> None: @@ -197,6 +328,17 @@ def test_neuron_direction_channel_index(self) -> None: dot = torch.sum(b * vec) self.assertAlmostEqual(get_loss_value(model, loss).item(), dot.item(), places=6) + def test_neuron_direction_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + vec = torch.tensor([0, 1, 0]).float() + loss = opt_loss.NeuronDirection(model, vec=vec, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + self.assertEqual(output.item(), 112.0) + class TestAngledNeuronDirection(BaseTest): def test_neuron_activation_init(self) -> None: @@ -254,6 +396,17 @@ def test_angled_neuron_direction_cossim_pow_4(self) -> None: output = get_loss_value(model, loss).item() self.assertAlmostEqual(output, dot.item(), places=6) + def test_angled_neuron_direction_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + vec = torch.tensor([1, 0, 1]).float() + loss = opt_loss.AngledNeuronDirection(model, vec=vec, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + self.assertEqual(output.item(), 1.5350958108901978) + class TestTensorDirection(BaseTest): def test_tensor_init(self) -> None: @@ -271,6 +424,16 @@ def test_tensor_direction(self) -> None: dot = torch.sum(b[None, :, None, None] * vec).item() self.assertAlmostEqual(get_loss_value(model, loss).item(), dot, places=6) + def test_tensor_direction_batch_index(self) -> None: + model = torch.nn.Identity() + batch_index = 1 + vec = torch.tensor([1, 0, 1, 0]).float().reshape((1, -1, 1, 1)) + loss = opt_loss.TensorDirection(model, vec=vec, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 1 * 5 * 5).view(5, 1, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(output.item(), 74.0) + class TestActivationWeights(BaseTest): def test_neuron_activation_init(self) -> None: From 221c72b7a2bc9d0032b92148975ed37e4aa8e2db Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 22 May 2022 13:37:27 -0600 Subject: [PATCH 020/174] Fix weird value mismatch --- tests/optim/core/test_loss.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 5db47db850..097a8f7646 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -57,8 +57,13 @@ def test_layer_activation(self) -> None: expected = torch.as_tensor( [CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_1_LOSS] ) + expected = expected[None, :, None, None] - assertTensorAlmostEqual(self, output, expected[None, :, None, None], delta=0.0) + if version.parse(torch.__version__) <= version.parse("1.6.0"): + delta = 1.0e-5 + else: + delta = 0.0 + assertTensorAlmostEqual(self, output, expected, delta=delta) def test_layer_activation_batch_index(self) -> None: model = torch.nn.Identity() From 862ddce625ee419d4e0ca38f5f8791fc4ac517cf Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 22 May 2022 14:00:11 -0600 Subject: [PATCH 021/174] Add batch_index tests to new objectives --- tests/optim/core/test_loss.py | 42 +++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 39d8ef4ee1..6ae0105f55 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -222,6 +222,16 @@ def test_l2mean_channel_index(self) -> None: expected = (CHANNEL_ACTIVATION_0_LOSS - constant) ** 2 self.assertAlmostEqual(output, expected, places=6) + def test_l2mean_batch_index(self) -> None: + raise unittest.SkipTest("Remove after PR merged") + model = torch.nn.Identity() + batch_index = 1 + loss = opt_loss.L2Mean(model, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 4 * 5 * 5).view(5, 4, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(output.item(), 23034.25) + class TestVectorLoss(BaseTest): def test_vectorloss_init(self) -> None: @@ -246,6 +256,17 @@ def test_vectorloss_multiple_channels(self) -> None: output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) self.assertAlmostEqual(output, CHANNEL_ACTIVATION_1_LOSS * 2, places=6) + def test_vectorloss_batch_index(self) -> None: + raise unittest.SkipTest("Remove after PR merged") + model = torch.nn.Identity() + batch_index = 1 + vec = torch.tensor([0, 1, 0, 0]).float() + loss = opt_loss.VectorLoss(model, vec=vec, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 4 * 5 * 5).view(5, 4, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(output.item(), 137.0) + class TestFacetLoss(BaseTest): def test_facetloss_init(self) -> None: @@ -355,6 +376,27 @@ def test_facetloss_2d_weights(self) -> None: expected = (CHANNEL_ACTIVATION_0_LOSS * 2) * 1.5 self.assertAlmostEqual(output, expected / 10.0, places=6) + def test_facetloss_batch_index(self) -> None: + raise unittest.SkipTest("Remove after PR merged") + batch_index = 1 + layer = torch.nn.Conv2d(2, 3, 1, bias=True) + layer.weight.data.fill_(0.1) # type: ignore + layer.bias.data.fill_(1) # type: ignore + model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) + + vec = torch.tensor([0, 1, 0]).float() + facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0].layer, + vec=vec, + facet_weights=facet_weights, + batch_index=batch_index, + ) + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertAlmostEqual(output.item(), 10.38000202178955, places=5) + class TestCompositeLoss(BaseTest): def test_negative(self) -> None: From b196bbe3d0d1814163c490ada9cae1419acc4ada Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 24 May 2022 18:22:08 -0600 Subject: [PATCH 022/174] Miscellaneous Fixes * Wrap all remaining `torch.__version__` calls in `version.parse`. * Remove unused version check in `typing.py`. * Expose `MaxPool2dRelaxed` to users so that tutorials using it work. * Expose `dataset` module to users. * Fixed `show` & `save_tensor_as_image` docs. --- captum/optim/__init__.py | 2 ++ captum/optim/_param/image/images.py | 11 +++++----- captum/optim/_utils/image/common.py | 8 ++++---- captum/optim/_utils/image/dataset.py | 15 ++++++++++---- captum/optim/_utils/typing.py | 20 ++++++++----------- captum/optim/models/__init__.py | 2 ++ .../optim/models/test_googlenet_places365.py | 18 ++++++++--------- tests/optim/param/test_images.py | 2 +- tests/optim/param/test_transforms.py | 2 +- 9 files changed, 44 insertions(+), 36 deletions(-) diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index 9177d5c62c..828ac03dd2 100644 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -7,6 +7,7 @@ from captum.optim._param.image.images import ImageTensor # noqa: F401 from captum.optim._utils import circuits, reducer # noqa: F401 from captum.optim._utils.image import atlas # noqa: F401 +from captum.optim._utils.image import dataset # noqa: F401 from captum.optim._utils.image.common import ( # noqa: F401 hue_to_rgb, make_grid_image, @@ -28,6 +29,7 @@ "reducer", "make_grid_image", "atlas", + "dataset", "hue_to_rgb", "nchannels_to_rgb", "save_tensor_as_image", diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index fa313b38af..3fade94f64 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -117,10 +117,11 @@ def show( grid image. Default is set to None for no grid image creation. Default: None padding (int, optional): The amount of padding between images in the grid - images. This parameter only has an effect if `nrow` is not None. + images. This parameter only has an effect if `images_per_row` is not + None. Default: 2 pad_value (float, optional): The value to use for the padding. This - parameter only has an effect if `nrow` is not None. + parameter only has an effect if `images_per_row` is not None. Default: 0.0 """ show( @@ -158,10 +159,10 @@ def export( grid image. Default is set to None for no grid image creation. Default: None padding (int, optional): The amount of padding between images in the grid - images. This parameter only has an effect if `nrow` is not None. - Default: 2 + images. This parameter only has an effect if `images_per_row` is not + None. pad_value (float, optional): The value to use for the padding. This - parameter only has an effect if `nrow` is not None. + parameter only has an effect if `images_per_row` is not None. Default: 0.0 """ save_tensor_as_image( diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index f1cdc5f477..39a6ada5ea 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -90,10 +90,10 @@ def show( grid image. Default is set to None for no grid image creation. Default: None padding (int, optional): The amount of padding between images in the grid - images. This parameter only has an effect if nrow is not None. + images. This parameter only has an effect if `images_per_row` is not None. Default: 2 pad_value (float, optional): The value to use for the padding. This parameter - only has an effect if nrow is not None. + only has an effect if `images_per_row` is not None. Default: 0.0 """ @@ -140,10 +140,10 @@ def save_tensor_as_image( grid image. Default is set to None for no grid image creation. Default: None padding (int, optional): The amount of padding between images in the grid - images. This parameter only has an effect if `nrow` is not None. + images. This parameter only has an effect if `images_per_row` is not None. Default: 2 pad_value (float, optional): The value to use for the padding. This parameter - only has an effect if `nrow` is not None. + only has an effect if `images_per_row` is not None. Default: 0.0 """ diff --git a/captum/optim/_utils/image/dataset.py b/captum/optim/_utils/image/dataset.py index c894173990..66bf18b53a 100644 --- a/captum/optim/_utils/image/dataset.py +++ b/captum/optim/_utils/image/dataset.py @@ -1,6 +1,7 @@ from typing import cast import torch +from packaging import version try: from tqdm.auto import tqdm @@ -73,6 +74,15 @@ def dataset_cov_matrix( return cov_mtx +# Handle older versions of PyTorch +# Defined outside of function in order to support JIT +_torch_norm = ( + torch.linalg.norm + if version.parse(torch.__version__) >= version.parse("1.7.0") + else torch.norm +) + + def cov_matrix_to_klt( cov_mtx: torch.Tensor, normalize: bool = False, epsilon: float = 1e-10 ) -> torch.Tensor: @@ -90,13 +100,10 @@ def cov_matrix_to_klt( *tensor*: A KLT matrix for the specified covariance matrix. """ - # Handle older versions of PyTorch - torch_norm = torch.linalg.norm if torch.__version__ >= "1.9.0" else torch.norm - U, S, V = torch.svd(cov_mtx) svd_sqrt = U @ torch.diag(torch.sqrt(S + epsilon)) if normalize: - svd_sqrt / torch.max(torch_norm(svd_sqrt, dim=0)) + svd_sqrt / torch.max(_torch_norm(svd_sqrt, dim=0)) return svd_sqrt diff --git a/captum/optim/_utils/typing.py b/captum/optim/_utils/typing.py index a0e3d6f1c0..10d37bd835 100755 --- a/captum/optim/_utils/typing.py +++ b/captum/optim/_utils/typing.py @@ -1,7 +1,8 @@ import sys from typing import Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union -from torch import Tensor, __version__ +from torch import Tensor +from torch import distributions from torch.nn import Module from torch.optim import Optimizer @@ -33,16 +34,11 @@ def cleanup(self) -> None: LossFunction = Callable[[ModuleOutputMapping], Tensor] SingleTargetLossFunction = Callable[[Tensor], Tensor] -if __version__ < "1.4.0": - NumSeqOrTensorOrProbDistType = Union[Sequence[int], Sequence[float], Tensor] -else: - from torch import distributions - - NumSeqOrTensorOrProbDistType = Union[ - Sequence[int], - Sequence[float], - Tensor, - distributions.distribution.Distribution, - ] +NumSeqOrTensorOrProbDistType = Union[ + Sequence[int], + Sequence[float], + Tensor, + distributions.distribution.Distribution, +] IntSeqOrIntType = Union[List[int], Tuple[int], Tuple[int, int], int] TupleOfTensorsOrTensorType = Union[Tuple[Tensor, ...], Tensor] diff --git a/captum/optim/models/__init__.py b/captum/optim/models/__init__.py index 0f809d5ef5..687aab0f85 100755 --- a/captum/optim/models/__init__.py +++ b/captum/optim/models/__init__.py @@ -1,4 +1,5 @@ from ._common import ( # noqa: F401 + MaxPool2dRelaxed, RedirectedReluLayer, SkipLayer, collect_activations, @@ -17,6 +18,7 @@ ) __all__ = [ + "MaxPool2dRelaxed", "RedirectedReluLayer", "SkipLayer", "collect_activations", diff --git a/tests/optim/models/test_googlenet_places365.py b/tests/optim/models/test_googlenet_places365.py index d6e9cf321d..84f9291fb9 100644 --- a/tests/optim/models/test_googlenet_places365.py +++ b/tests/optim/models/test_googlenet_places365.py @@ -11,7 +11,7 @@ class TestInceptionV1Places365(BaseTest): def test_load_inceptionv1_places365_with_redirected_relu(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping load pretrained InceptionV1 Places365 due to insufficient" + " Torch version." @@ -22,7 +22,7 @@ def test_load_inceptionv1_places365_with_redirected_relu(self) -> None: self.assertTrue(check_layer_in_model(model, RedirectedReluLayer)) def test_load_inceptionv1_places365_no_redirected_relu(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping load pretrained InceptionV1 Places365 RedirectedRelu test" + " due to insufficient Torch version." @@ -34,7 +34,7 @@ def test_load_inceptionv1_places365_no_redirected_relu(self) -> None: self.assertTrue(check_layer_in_model(model, torch.nn.ReLU)) def test_load_inceptionv1_places365_linear(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping load pretrained InceptionV1 Places365 linear test due to" + " insufficient Torch version." @@ -47,7 +47,7 @@ def test_load_inceptionv1_places365_linear(self) -> None: self.assertTrue(check_layer_in_model(model, torch.nn.AvgPool2d)) def test_inceptionv1_places365_transform(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping InceptionV1 Places365 internal transform test due to" + " insufficient Torch version." @@ -62,7 +62,7 @@ def test_inceptionv1_places365_transform(self) -> None: assertTensorAlmostEqual(self, output, expected_output, 0) def test_inceptionv1_places365_transform_warning(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping InceptionV1 Places365 internal transform warning test due" + " to insufficient Torch version." @@ -75,7 +75,7 @@ def test_inceptionv1_places365_transform_warning(self) -> None: model._transform_input(x) def test_inceptionv1_places365_load_and_forward(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping basic pretrained InceptionV1 Places365 forward test due to" + " insufficient Torch version." @@ -86,7 +86,7 @@ def test_inceptionv1_places365_load_and_forward(self) -> None: self.assertEqual([list(o.shape) for o in outputs], [[1, 365]] * 3) def test_inceptionv1_places365_load_and_forward_diff_sizes(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping pretrained InceptionV1 Places365 forward with different" + " sized inputs test due to insufficient Torch version." @@ -102,7 +102,7 @@ def test_inceptionv1_places365_load_and_forward_diff_sizes(self) -> None: self.assertEqual([list(o.shape) for o in outputs2], [[1, 365]] * 3) def test_inceptionv1_places365_forward_no_aux(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping pretrained InceptionV1 Places365 with aux logits forward" + " test due to insufficient Torch version." @@ -113,7 +113,7 @@ def test_inceptionv1_places365_forward_no_aux(self) -> None: self.assertEqual(list(outputs.shape), [1, 365]) def test_inceptionv1_places365_forward_cuda(self) -> None: - if torch.__version__ <= "1.6.0": + if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping pretrained InceptionV1 Places365 forward CUDA test due to" + " insufficient Torch version." diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index 617d34a3a3..0ca59c1920 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -443,7 +443,7 @@ def test_simple_tensor_parameterization_with_grad(self) -> None: self.assertTrue(image_param.tensor.requires_grad) def test_simple_tensor_parameterization_jit_module_with_grad(self) -> None: - if torch.__version__ <= "1.8.0": + if version.parse(torch.__version__) <= version.parse("1.8.0"): raise unittest.SkipTest( "Skipping SimpleTensorParameterization JIT module test due to" + " insufficient Torch version." diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index 385006a7ac..362fce9649 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -1335,7 +1335,7 @@ def test_ignore_alpha(self) -> None: assert rgb_tensor.size(1) == 3 def test_ignore_alpha_jit_module(self) -> None: - if torch.__version__ <= "1.8.0": + if version.parse(torch.__version__) <= version.parse("1.8.0"): raise unittest.SkipTest( "Skipping IgnoreAlpha JIT module test due to insufficient" + " Torch version." From c65665865947cbd2326ac44592fd0c54746ced15 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 25 May 2022 13:21:52 -0600 Subject: [PATCH 023/174] Add Model Preparation Tutorial --- ...ingStarted_ModelPreparation_OptimViz.ipynb | 469 ++++++++++++++++++ 1 file changed, 469 insertions(+) create mode 100644 tutorials/optimviz/GettingStarted_ModelPreparation_OptimViz.ipynb diff --git a/tutorials/optimviz/GettingStarted_ModelPreparation_OptimViz.ipynb b/tutorials/optimviz/GettingStarted_ModelPreparation_OptimViz.ipynb new file mode 100644 index 0000000000..ea83ff0146 --- /dev/null +++ b/tutorials/optimviz/GettingStarted_ModelPreparation_OptimViz.ipynb @@ -0,0 +1,469 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "GettingStarted_ModelPreparation_OptimViz.ipynb", + "provenance": [], + "collapsed_sections": [ + "3MSB2RhA4h8E" + ] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Preparing Models For Captum's Optim Module\n", + "\n", + "While most models will work out of the box with the Optim module, some model may require a few minor changes for full compatibility. This tutorial demonstrates how to easily perform the suggested & required changes to models for use with the Optim module." + ], + "metadata": { + "id": "QVpft54KA-P_" + } + }, + { + "cell_type": "code", + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import captum.optim as opt\n", + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + ], + "metadata": { + "id": "KD5InqKt3Hjc" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Model Layer Changes\n", + "\n", + "The Optim module's layer related functions, and optimization systems rely on layers being defined as `nn.Module` classes rather than functional layers. Specifically, Optim's loss optimization and activation collection rely on PyTorch's hook system via [`register_forward_hook`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html?highlight=register_forward_hook#torch.nn.Module.register_forward_hook), and functional layers do not support hooks.\n", + "Other functions like `replace_layers` can only detect `nn.Module` objects inside models.\n", + "\n", + "\n", + "For the purpose of this tutorial, our main toy model does not use any functional layers. Though if you are wishing to use your own model then you should verify that all applicable functional layers have been changed to their `nn.Module` equivalents in your chosen model.\n", + "\n", + "* A list of all PyTorch's `torch.nn.functional` layers can be found [here](https://pytorch.org/docs/stable/nn.functional.html), and each layer has links to their `nn.Module` equivalents.\n", + "\n", + "* The most common change that you will likely encounter, is converting the functional [`F.relu`](https://pytorch.org/docs/stable/generated/torch.nn.functional.relu.html#torch.nn.functional.relu) layers to [`nn.ReLU`](https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html)." + ], + "metadata": { + "id": "3MSB2RhA4h8E" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Tutorial Setup\n", + "\n", + "Below we define a simple toy model and a functional version of the toy model for usage in our examples." + ], + "metadata": { + "id": "QGIfQki3Dn2M" + } + }, + { + "cell_type": "code", + "source": [ + "class ToyModel(torch.nn.Module):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + " self.basic_module = torch.nn.Sequential(\n", + " torch.nn.Conv2d(3, 4, kernel_size=3, stride=2),\n", + " torch.nn.ReLU(),\n", + " torch.nn.MaxPool2d(kernel_size=3, stride=2),\n", + " )\n", + " self.conv = torch.nn.Conv2d(4, 4, kernel_size=3, stride=2)\n", + " self.bn = torch.nn.BatchNorm2d(4)\n", + " self.relu = torch.nn.ReLU()\n", + " self.pooling = torch.nn.AdaptiveAvgPool2d((2, 2))\n", + " self.linear = torch.nn.Linear(16, 4)\n", + "\n", + " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", + " x = self.basic_module(x)\n", + " x = self.conv(x)\n", + " x = self.bn(x)\n", + " x = self.relu(x)\n", + " x = self.pooling(x)\n", + " x = x.flatten()\n", + " x = self.linear(x)\n", + " return x\n", + "\n", + "\n", + "class ToyModelFunctional(torch.nn.Module):\n", + " \"\"\"Functional layer only version of our toy model\"\"\"\n", + "\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + "\n", + " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", + " x = F.conv2d(x, weight=torch.ones([4, 3, 3, 3]), kernel_size=3, stride=2)\n", + " x = F.relu(x)\n", + " x = F.max_pool2d(x, kernel_size=3, stride=2)\n", + "\n", + " x = F.conv2d(x, weight=torch.ones([4, 3, 3, 3]), kernel_size=3, stride=2)\n", + " x = F.batch_norm(x, running_mean=torch.ones([4]), running_var=torch.ones([4]))\n", + " x = F.relu(x)\n", + " x = F.adaptive_avg_pool2d(input, (2, 2))\n", + " x = x.flatten()\n", + " x = F.linear(input, weight=torch.ones([4, 16]))\n", + " return x" + ], + "metadata": { + "id": "X79d0fh_3LuT" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## The Basics: Targetable Layers\n", + "\n", + "The optim module's `opt.models.collect_activations` function and loss objectives (`opt.loss.`) rely on forward hooks using PyTorch's hook system. This means that functional layers cannot be used as optimization targets, and activations cannot be collected for them.\n", + "\n", + "Models can easily be checked for compatible layers via the `opt.models.get_model_layers` function as we'll see below." + ], + "metadata": { + "id": "UjEdNgauOdbZ" + } + }, + { + "cell_type": "code", + "source": [ + "# Functional version of the toy model with no nn.Module layers\n", + "toy_model_functional = ToyModelFunctional().eval().to(device)\n", + "\n", + "# Get hookable layers\n", + "possible_targets = opt.models.get_model_layers(toy_model_functional)\n", + "\n", + "print(\"Possible targets:\", possible_targets)" + ], + "metadata": { + "id": "uEPS3SOqcl47", + "outputId": "fe01c649-97e2-4565-db99-96ced48ce15b", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Possible targets: []\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "As you can see, no layers capable of being hooked were found in our functional layer model.\n", + "\n", + "Below we use the `opt.models.get_model_layers` function to see a list of all the hookable layers in our non-functional model that we can use as targets." + ], + "metadata": { + "id": "46YGHAeRdBmE" + } + }, + { + "cell_type": "code", + "source": [ + "# Toy model with only nn.Module layers\n", + "target_model = ToyModel().eval().to(device)\n", + "\n", + "# Get hookable layers\n", + "possible_targets = opt.models.get_model_layers(target_model)\n", + "\n", + "# Display hookable layers\n", + "print(\"Possible targets:\")\n", + "for t in possible_targets:\n", + " print(\" target_model.\" + t)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TlZ5UwiVPptG", + "outputId": "169fb32f-3648-444c-b89b-db9f5cf9121a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Possible targets:\n", + " target_model.basic_module\n", + " target_model.basic_module[0]\n", + " target_model.basic_module[1]\n", + " target_model.basic_module[2]\n", + " target_model.conv\n", + " target_model.bn\n", + " target_model.relu\n", + " target_model.pooling\n", + " target_model.linear\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We can then easily use any of the targets found above for optimization and activation collection, as we show below." + ], + "metadata": { + "id": "iHTSN71dWh5o" + } + }, + { + "cell_type": "code", + "source": [ + "target_model = ToyModel().eval().to(device)\n", + "\n", + "# Set layer target\n", + "target_layer = target_model.conv\n", + "\n", + "# Collect activations from target\n", + "activations_dict = opt.models.collect_activations(\n", + " model=target_model, targets=target_layer\n", + ")\n", + "\n", + "# Collect target from activations dict\n", + "activations = activations_dict[target_layer]\n", + "\n", + "# Display activation shape\n", + "print(\"Output shape of the {} layer activations:\".format(type(target_layer)))\n", + "print(\" {} \\n\".format(activations.shape))\n", + "\n", + "# We can also use the target for loss objectives\n", + "loss_fn = opt.loss.LayerActivation(target=target_layer)\n", + "\n", + "# Print loss objective\n", + "print(\"Loss objective:\", loss_fn)\n", + "print(\" target:\", loss_fn.target)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tiD7qBzlQ6Zw", + "outputId": "674df320-9fb4-46aa-8bf2-1acd534a7a61" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Output shape of the layer activations:\n", + " torch.Size([1, 4, 27, 27]) \n", + "\n", + "Loss objective: LayerActivation []\n", + " target: Conv2d(4, 4, kernel_size=(3, 3), stride=(2, 2))\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Visualization: Redirected ReLU\n", + "\n", + "In some cases, the target of interest may not be activated at all by the initial random input. If this happens, the zero derivative stops the gradient from flowing backwards and thus we never move towards any meaningful visualization. To solve this problem, we can replace the ReLU layers in a model with a special version of ReLU called `RedirectedReLU`. The `RedirectedReLU` layer allows the gradient to flow temporarily in these zero gradient situations.\n", + "\n", + "Below we use the `opt.models.replace_layers` function to replace all instances of `nn.ReLU` in our toy model with `opt.models.RedirectedReluLayer`." + ], + "metadata": { + "id": "MlGvyhd0AalX" + } + }, + { + "cell_type": "code", + "source": [ + "relu_model = ToyModel().eval().to(device)\n", + "\n", + "# Replace the ReLU with RedirectedReluLayer\n", + "opt.models.replace_layers(\n", + " relu_model, layer1=torch.nn.ReLU, layer2=opt.models.RedirectedReluLayer\n", + ")\n", + "\n", + "# Show modified model\n", + "print(relu_model)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4w34RcZU_DrU", + "outputId": "596aef9f-26d8-4e87-fdaf-71211e29699b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "ToyModel(\n", + " (basic_module): Sequential(\n", + " (0): Conv2d(3, 4, kernel_size=(3, 3), stride=(2, 2))\n", + " (1): RedirectedReluLayer()\n", + " (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv): Conv2d(4, 4, kernel_size=(3, 3), stride=(2, 2))\n", + " (bn): BatchNorm2d(4, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): RedirectedReluLayer()\n", + " (pooling): AdaptiveAvgPool2d(output_size=(2, 2))\n", + " (linear): Linear(in_features=16, out_features=4, bias=True)\n", + ")\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Circuits: Linear Operation Layers\n", + "\n", + "Certain functions like `opt.circuits.extract_expanded_weights` require using modules that only perform linear operations. This can become slightly more complicated when dealing with layers that have multiple preset set variables. Luckily the `opt.models.replace_layers` function can easily handle these variable transfers for layer types like pooling layers if the `transfer_vars` variable is set to `True`.\n", + "\n", + "\n", + "Common linear layer replacements are as follows:\n", + "\n", + "* `nn.ReLU` layers need to be skipped, which can be done by replacing them with either `nn.Identity` or Captum's `SkipLayer` layer.\n", + "\n", + "* `nn.MaxPool2d` layers need to be converted to their linear `nn.AvgPool2d` layer equivalents.\n", + "\n", + "* `nn.AdaptiveMaxPool2d` layers need to be converted to their linear `nn.AdaptiveAvgPool2d` layer equivalents.\n", + "\n", + "Some of the layers which are already linear operations are:\n", + "\n", + "* `nn.BatchNorm2d` is linear when it's in evaluation mode (`.eval()`).\n", + "* `nn.Conv2d` is linear.\n", + "* `nn.Linear` is linear." + ], + "metadata": { + "id": "KJVG3KDC31dy" + } + }, + { + "cell_type": "code", + "source": [ + "linear_only_model = ToyModel().eval().to(device)\n", + "\n", + "# Replace MaxPool2d with AvgPool2d using the same settings\n", + "opt.models.replace_layers(\n", + " linear_only_model,\n", + " layer1=torch.nn.MaxPool2d,\n", + " layer2=torch.nn.AvgPool2d,\n", + " transfer_vars=True, # Use same MaxPool2d parameters for AvgPool2d\n", + ")\n", + "\n", + "# Replace ReLU with Identity\n", + "opt.models.replace_layers(\n", + " linear_only_model, layer1=torch.nn.ReLU, layer2=torch.nn.Identity\n", + ")\n", + "\n", + "# Show modified model\n", + "print(linear_only_model)" + ], + "metadata": { + "id": "hYbm5Cg34She", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a35a33e2-04c3-4563-b139-ab28127b4f90" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "ToyModel(\n", + " (basic_module): Sequential(\n", + " (0): Conv2d(3, 4, kernel_size=(3, 3), stride=(2, 2))\n", + " (1): Identity()\n", + " (2): AvgPool2d(kernel_size=3, stride=2, padding=0)\n", + " )\n", + " (conv): Conv2d(4, 4, kernel_size=(3, 3), stride=(2, 2))\n", + " (bn): BatchNorm2d(4, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): Identity()\n", + " (pooling): AdaptiveAvgPool2d(output_size=(2, 2))\n", + " (linear): Linear(in_features=16, out_features=4, bias=True)\n", + ")\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Other: Relaxed Pooling\n", + "\n", + "Some attribution based operations like those used in activation atlas sample collection, require replacing the `nn.MaxPool2d` layers with a special relaxed version called `MaxPool2dRelaxed`. This is also extremely easy to do with the `replace_layers` function like we did above." + ], + "metadata": { + "id": "MXXUIcEBk7_k" + } + }, + { + "cell_type": "code", + "source": [ + "relaxed_pooling_model = ToyModel().eval().to(device).basic_module\n", + "\n", + "# Replace MaxPool2d with MaxPool2dRelaxed\n", + "opt.models.replace_layers(\n", + " relaxed_pooling_model,\n", + " torch.nn.MaxPool2d,\n", + " opt.models.MaxPool2dRelaxed,\n", + " transfer_vars=True, # Use same MaxPool2d parameters for MaxPool2dRelaxed\n", + ")\n", + "\n", + "# Show modified model\n", + "print(relaxed_pooling_model)" + ], + "metadata": { + "id": "fWjY33RKkFi8", + "outputId": "f0e0a0d9-fd1f-4857-ea60-e8a2127607fd", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Sequential(\n", + " (0): Conv2d(3, 4, kernel_size=(3, 3), stride=(2, 2))\n", + " (1): ReLU()\n", + " (2): MaxPool2dRelaxed(\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (avgpool): AvgPool2d(kernel_size=3, stride=2, padding=0)\n", + " )\n", + ")\n" + ] + } + ] + } + ] +} \ No newline at end of file From 0e7d0f45c2fac21a6a793147f68dfd1a5f9f7eea Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 25 May 2022 14:47:42 -0600 Subject: [PATCH 024/174] Improve vector function --- captum/optim/_utils/image/common.py | 14 ++++++++------ tests/optim/utils/image/test_common.py | 13 +++++++++++++ 2 files changed, 21 insertions(+), 6 deletions(-) diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index 31af3169ef..1f2cced14f 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -385,7 +385,7 @@ def _create_new_vector( Args: x (torch.Tensor): A set of 2d or 4d activations. - vec (torch.Tensor): A direction vector to use, with a compatible shape for + vec (torch.Tensor): A 1D direction vector to use, with a compatible shape for computing the matrix product of the activations. See torch.matmul for See torch.matmul for more details on compatible shapes: https://pytorch.org/docs/stable/generated/torch.matmul.html @@ -405,12 +405,14 @@ def _create_new_vector( stored vector. """ assert x.device == vec.device - assert x.dim() > 1 + assert x.dim() > 1 and vec.dim() == 1 if activation_fn: x = activation_fn(x) - if x.dim() > 2 and move_channel_dim_to_final_dim: - permute_vals = [0] + list(range(x.dim()))[2:] + [1] - x = x.permute(*permute_vals) - return torch.mean(x @ vec, [1, 2]) + if x.dim() > 2: + if move_channel_dim_to_final_dim: + permute_vals = [0] + list(range(x.dim()))[2:] + [1] + x = x.permute(*permute_vals) + mean_vals = list(range(1, x.dim() - 1)) + return torch.mean(x @ vec, mean_vals) else: return (x @ vec)[:, None] diff --git a/tests/optim/utils/image/test_common.py b/tests/optim/utils/image/test_common.py index fcece26683..09e1a7355c 100644 --- a/tests/optim/utils/image/test_common.py +++ b/tests/optim/utils/image/test_common.py @@ -550,3 +550,16 @@ def test_create_new_vector_no_activation_fn(self) -> None: vec = torch.tensor([1, 1, 1]).float() out = common._create_new_vector(x, vec, activation_fn=None) self.assertEqual(out.item(), 0.0) + + def test_create_new_vector_channels_last(self) -> None: + x = torch.arange(0, 4 * 5 * 5 * 3).view(4, 5, 5, 3).float() + vec = torch.tensor([0, 1, 0]).float() + out = common._create_new_vector(x, vec, move_channel_dim_to_final_dim=False) + self.assertEqual(out.tolist(), [37.0, 112.0, 187.0, 262.0]) + + def test_create_new_vector_dim_2(self) -> None: + x = torch.arange(0, 1 * 3).view(1, 3).float() + vec = torch.tensor([0, 1, 0]).float() + out = common._create_new_vector(x, vec) + self.assertEqual(list(out.shape), [1, 1]) + self.assertEqual(out.item(), 1.0) From 3b67bb047723497ae18afaf99bbf9e5dc67d55ba Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 28 May 2022 11:12:48 -0600 Subject: [PATCH 025/174] Improve the `FacetLoss` objective * Improve efficiency of the `FacetLoss` objective. --- captum/optim/_core/loss.py | 42 ++++++++++++-------------------------- 1 file changed, 13 insertions(+), 29 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index cd52f02951..731eeb2346 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -1005,36 +1005,12 @@ def __init__( assert facet_weights.dim() == 4 or facet_weights.dim() == 2 self.facet_weights = facet_weights - def _get_strength(self, batch: int, device: torch.device) -> torch.Tensor: - """ - Calculate batch weighting. - - Args: - - batch (int): The size of the batch dimension to use. - device (torch.device): The device to use. - - Returns: - strength_t (torch.Tensor): A tensor containing the weights to multiply the - different batch dimensions by. - """ - if isinstance(self.strength, (tuple, list)): - strength_t = torch.linspace( - self.strength[0], - self.strength[1], - steps=batch, - device=device, - ) - else: - strength_t = torch.ones([1], device=device) * self.strength - return strength_t[:, None, None, None] - def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations_ultimate = targets_to_values[self.ultimate_target] - activations_ultimate = activations_ultimate - new_vec = _create_new_vector(activations_ultimate, self.vec)[ + activations_ultimate = activations_ultimate[ self.batch_index[0] : self.batch_index[1] ] + new_vec = _create_new_vector(activations_ultimate, self.vec) target_activations = targets_to_values[self.layer_target] layer_grad = torch.autograd.grad( @@ -1042,15 +1018,23 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: inputs=target_activations, grad_outputs=torch.ones_like(new_vec), retain_graph=True, - )[0] + )[0].detach()[self.batch_index[0] : self.batch_index[1]] layer = target_activations[self.batch_index[0] : self.batch_index[1]] - flat_attr = layer * torch.nn.functional.relu(layer_grad.detach()) + flat_attr = layer * torch.nn.functional.relu(layer_grad) if self.facet_weights.dim() == 2 and flat_attr.dim() == 4: flat_attr = torch.sum(flat_attr, dim=(2, 3)) if self.strength: - strength_t = self._get_strength(new_vec.shape[0], flat_attr.device) + if isinstance(self.strength, (tuple, list)): + strength_t = torch.linspace( + self.strength[0], + self.strength[1], + steps=flat_attr.shape[0], + device=flat_attr.device, + ).reshape(flat_attr.shape[0], *[1] * (flat_attr.dim() - 1)) + else: + strength_t = self.strength flat_attr = strength_t * flat_attr return torch.sum(flat_attr * self.facet_weights) From 4c51ef1c1f1ead191b370f589c61e478096d612f Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 28 May 2022 12:21:19 -0600 Subject: [PATCH 026/174] Add CLIP objectives to `__all__` --- captum/optim/_core/loss.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 731eeb2346..01894ae078 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -1110,6 +1110,9 @@ def default_loss_summarize(loss_value: torch.Tensor) -> torch.Tensor: "AngledNeuronDirection", "TensorDirection", "ActivationWeights", + "L2Mean", + "VectorLoss", + "FacetLoss", "sum_loss_list", "default_loss_summarize", ] From 36df47e363ae7d5297b05af6c34d51646d7cb02b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 28 May 2022 12:28:14 -0600 Subject: [PATCH 027/174] Separate some loss tests --- tests/optim/core/test_loss.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 097a8f7646..97f4c78ed1 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -718,6 +718,8 @@ def test_rpow_error(self) -> None: with self.assertRaises(TypeError): "string" ** opt_loss.ChannelActivation(model.layer, 0) # type: ignore + +class TestSumLossList(BaseTest): def test_sum_loss_list(self) -> None: n_batch = 400 model = torch.nn.Identity() From 31cb2a903330cb87e5dfbb76871a0138606d6a7e Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 28 May 2022 15:17:51 -0600 Subject: [PATCH 028/174] Fix mistake in FacetLoss docs --- captum/optim/_core/loss.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 01894ae078..6542e828b7 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -980,15 +980,16 @@ def __init__( the model. layer_target (nn.Module): A layer that we have facet_weights for. This target layer should be below the ultimate_target layer in the model. + facet_weights (torch.Tensor): Weighting that steers the objective + towards a particular theme or concept. These weight values should + come from linear probes trained on layer_target. strength (float, list of float, optional): A single float or list of floats to use for batch dimension weighting. If using a single value, then it will be applied to all batch dimensions equally. Otherwise a list of floats with a shape of: [start, end] should be used for torch.linspace to calculate the step values in between. Default is set to None for no weighting. - facet_weights (torch.Tensor): Weighting that steers the objective - towards a particular theme or concept. These weight values should - come from linear probes trained on layer_target. + Default: None batch_index (int, optional): The index of the activations to optimize if optimizing a batch of activations. If set to None, defaults to all activations in the batch. From cfa9d9f60f2997b007a9ed801b659ffd6fd54271 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 31 May 2022 12:35:19 -0600 Subject: [PATCH 029/174] Update CustomModules tutorial for new changes --- .../optimviz/CustomModules_OptimViz.ipynb | 1459 ++++++++++------- 1 file changed, 897 insertions(+), 562 deletions(-) diff --git a/tutorials/optimviz/CustomModules_OptimViz.ipynb b/tutorials/optimviz/CustomModules_OptimViz.ipynb index 22d88fde12..ae556a1b0b 100644 --- a/tutorials/optimviz/CustomModules_OptimViz.ipynb +++ b/tutorials/optimviz/CustomModules_OptimViz.ipynb @@ -1,579 +1,914 @@ { - "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", - "execution_count": 1, - "metadata": { - "id": "GWrStkUVEbOC" - }, - "outputs": [], - "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 import googlenet\n", - "\n", - "import captum.optim as opt\n", - "\n", - "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "model = googlenet(pretrained=True).to(device)" - ] - }, - { - "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", - "execution_count": 2, - "metadata": { - "id": "hoyneR7FFTXK" - }, - "outputs": [], - "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" - ] - }, - { - "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 `opt.loss.BaseLoss` and also have the `opt.loss.loss_wrapper` decorator.\n", - "\n", - "For now, the `opt.loss.loss_wrapper` decorator primarily serves to update the name and string representations of the loss function, but future work may also add other generic loss attributes via the decorator.\n", - "\n", - "Custom loss functions must contain the following two functions:\n", - "\n", - "\n", - "* The `__init__()` function 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`. An optional variable is `batch_index`, which is an `int`. The `batch_index` is used to target a specific image in a batch of input images.\n", - "\n", - "* The `__call__()` function 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", - "execution_count": 3, - "metadata": { - "id": "LQZECwPoEdET" - }, - "outputs": [], - "source": [ - "@opt.loss.loss_wrapper\n", - "class CustomLoss(opt.loss.BaseLoss):\n", - " def __init__(self, target: Union[torch.nn.Module, List[torch.nn.Module]], batch_index: Optional[int] = None) -> \"CustomLoss\":\n", - " opt.loss.BaseLoss.__init__(self, target, batch_index)\n", - "\n", - " def __call__(\n", - " self, target_activations: Dict[torch.nn.Module, Optional[torch.Tensor]]\n", - " ) -> torch.Tensor:\n", - " # Get activations from target\n", - " # self.batch_index is a tuple of (batch_index, batch_index+1)\n", - " activations = target_activations[self.target][self.batch_index[0]:self.batch_index[1]]\n", - " return activations" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Custom Loss Summarize Functions\n", - "\n", - "In addition to the loss function, there is also the `loss_summarize_fn` that can be supplied to the `optimize` method of `InputOptimization`. This function dictates how the final loss is computed and aggregated before we call the `backward` method on it to compute gradients.\n", - "\n", - "Here we show the default summarize function to give an idea of what this function does. The default summarize function simply computes the mean of the loss tensor and multiplies it by -1 so that the optimization maximizes the activations." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def custom_loss_summarize(loss_value: torch.Tensor) -> torch.Tensor:\n", - " return -1 * loss_value.mean()" - ] - }, - { - "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", - "execution_count": 5, - "metadata": { - "id": "Hm2HLX9VFmAT" - }, - "outputs": [], - "source": [ - "class CustomImage(opt.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" - ] - }, - { - "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", - "execution_count": 6, - "metadata": { - "id": "uQ9sEz8cG2El" - }, - "outputs": [], - "source": [ - "def visualize(model: torch.nn.Module, target: torch.nn.Module):\n", - " # Define our custom image parameterization, then add it to NaturalImage\n", - " image_param = CustomImage\n", - " image = opt.images.NaturalImage(size=(224, 224), parameterization=image_param, batch=2).to(device)\n", - "\n", - " transforms = torch.nn.Sequential(\n", - " CustomTransform(), # Add our custom transform to the list of transforms\n", - "\n", - " # Additional transforms to improve output quality\n", - " opt.transforms.RandomSpatialJitter(16),\n", - " opt.transforms.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\n", - " )\n", - "\n", - " # Define our custom loss function as the loss function\n", - " loss_fn = CustomLoss(target, batch_index=0) # Only optimize 0th image to demonstrate batch_index\n", - "\n", - " obj = opt.InputOptimization(model, loss_fn, image, transforms)\n", - " history = obj.optimize(\n", - " stop_criteria=opt.optimization.n_steps(512),\n", - " loss_summarize_fn=custom_loss_summarize, # Our custom loss_summarize_fn\n", - " )\n", - " image().show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And there you have it! Notice that only the left image (at index 0) is optimized since we specified `batch_index=0` when defining `loss_fn`. The right image is unchanged from its random initialization." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 298, - "referenced_widgets": [ - "5c666868d62e4862a648cd0df15155ec", - "389469a07da6435eb2a1be7ea55f4f86", - "36b86b673b544cc5bdb5652eb31cabc9", - "6d93392ab27048068aa8bb1d7ef01cf1", - "2c759e9a43754fc4963a9631cc7702c5", - "8fa32da11a2a4401a57a50f80af7be32", - "ba6b8e0c07074921a5faa7dbc29f3fe3", - "ea6b900b717c4e8f8051094882aeef1f" - ] + "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!" + ] }, - "id": "3m5iQ2zfqV5F", - "outputId": "40b79b81-363c-49c6-8546-9b8ada61665a" - }, - "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3ee58c51e28e4977b0c45befa0511b4c", - "version_major": 2, - "version_minor": 0 + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GWrStkUVEbOC" }, - "text/plain": [ - " 0%| | 0/512 [00:00" + "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", + "execution_count": null, + "metadata": { + "id": "hoyneR7FFTXK" + }, + "outputs": [], + "source": [ + "class CustomTransform(torch.nn.Module):\n", + " def __init__(self, val: int = 1) -> None:\n", + " super().__init__()\n", + " self.val = val\n", + "\n", + " def forward(self, input: torch.Tensor) -> torch.Tensor:\n", + " return input * self.val" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2kjc9istEzVz" + }, + "source": [ + "## Custom Loss Objectives\n", + "Captum's loss objectives are composed of classes that the optimization function uses. Custom loss classes should inherit the base loss class `opt.loss.BaseLoss` and also have the `opt.loss.loss_wrapper` decorator.\n", + "\n", + "For now, the `opt.loss.loss_wrapper` decorator primarily serves to update the name and string representations of the loss objective, but future work may also add other generic loss attributes via the decorator. This decorator is required for custom loss objectives.\n", + "\n", + "Custom loss objectives must contain the following two functions:\n", + "\n", + "**The init function**\n", + "\n", + "* The `__init__()` function 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", + "* An optional variable is `batch_index`, which is either an `int` or a list of `int`. The `batch_index` is used to target a specific image in a batch of input images.\n", + "\n", + "* The init function should call the `BaseLoss` `__init__` function and provide it with the target `nn.Module` or list of `nn.Module` along with the `batch_index`.\n", + "\n", + "**The call function**\n", + "\n", + "* The `__call__()` function 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", + "execution_count": null, + "metadata": { + "id": "LQZECwPoEdET" + }, + "outputs": [], + "source": [ + "@opt.loss.loss_wrapper\n", + "class CustomLoss(opt.loss.BaseLoss):\n", + " def __init__(\n", + " self,\n", + " target: Union[torch.nn.Module, List[torch.nn.Module]],\n", + " batch_index: Optional[Union[int, List[int]]] = None, # Optional parameter\n", + " ) -> None:\n", + " opt.loss.BaseLoss.__init__(self, target, batch_index)\n", + "\n", + " def __call__(\n", + " self, target_activations: Dict[torch.nn.Module, Optional[torch.Tensor]]\n", + " ) -> torch.Tensor:\n", + "\n", + " # Get activations for target from input dict\n", + " activations = target_activations[self.target]\n", + "\n", + " # self.batch_index is a tuple of (batch_index, batch_index+1)\n", + " activations = activations[self.batch_index[0] : self.batch_index[1]]\n", + "\n", + " # Return activations for loss summarization\n", + " return activations" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JmrUOtGbZW5J" + }, + "source": [ + "## Custom Loss Summarize Functions\n", + "\n", + "In addition to the loss objectives, there is also the loss summarization function that can be supplied to the `optimize` method of `InputOptimization`. This function dictates how the final loss is computed and aggregated before we call the `backward` method on it to compute gradients.\n", + "\n", + "Here we show the default summarize function to give an idea of what this function does. The default summarize function simply computes the mean of the loss tensor and multiplies it by -1 so that the optimization maximizes the activations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zhxtI_LjZW5K" + }, + "outputs": [], + "source": [ + "def custom_loss_summarize(loss_value: torch.Tensor) -> torch.Tensor:\n", + " return -1 * loss_value.mean()" + ] + }, + { + "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", + "Note that the `__init__()` function can contain any number of variable inputs if the image parameterization is passed as an instance to `NaturalImage`. Otherwise the init function requirements are required.\n", + "\n", + "### Forward function\n", + "\n", + "The `forward()` function has zero input variables 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', unless you are using TorchScript / JIT.\n", + "\n", + "* As JIT does not yet support named dimensions, you can use [`torch.jit.is_scripting`](https://pytorch.org/docs/stable/jit_language_reference.html?highlight=is_scripting#torch.jit.is_scripting) to only name the dimensions when not using JIT." ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "visualize(model, model.mixed4a)" - ] - } - ], - "metadata": { - "colab": { - "collapsed_sections": [], - "name": "CustomModules_OptimViz.ipynb", - "provenance": [], - "toc_visible": true - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "2c759e9a43754fc4963a9631cc7702c5": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "initial" - } }, - "36b86b673b544cc5bdb5652eb31cabc9": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "100%", - "description_tooltip": null, - "layout": "IPY_MODEL_8fa32da11a2a4401a57a50f80af7be32", - "max": 128, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_2c759e9a43754fc4963a9631cc7702c5", - "value": 128 - } + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Hm2HLX9VFmAT" + }, + "outputs": [], + "source": [ + "class CustomImage(opt.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", + " if torch.jit.is_scripting():\n", + " return self.image\n", + " return self.image.refine_names(\"B\", \"C\", \"H\", \"W\") # rename dimensions" + ] }, - "389469a07da6435eb2a1be7ea55f4f86": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + { + "cell_type": "markdown", + "source": [ + "## Custom StopCriteria\n", + "\n", + "StopCriteria functions tell the `InputOptimization.optimize` function when to stop optimizing the input param. We provide 4 possible sources of information after each step for the stop criteria function to determine when to stop the optimization process.\n", + "\n", + "The default Captum `opt.optimization.n_steps` function returns a stop criteria function called `continue_while`. The `continue_while` function takes 4 input variables every step during the optimization process:\n", + "\n", + "* `step` (int): The current optimization step.\n", + "\n", + "* `obj`: The current instance of InputOptimization being used.\n", + "\n", + "* `history` (list of torch.Tensor): A list of loss values per iteration. The size of the list is equal to the number of steps that have already been performed. The last value in the list corresponds to the current step.\n", + "\n", + "* `optim` (torch.optim.Optimizer): The current instance of the optimizer being used.\n", + "\n", + "All stop criteria functions or classes using `__call__` functions, should accept the same 4 inputs as `continue_while`. They are also expected to return a boolean value for each step to indicate whether optimization should continue.\n", + "\n", + "Note that these requirements may not exist for custom optimization functions, which can utilize their own custom stopping criteria.\n" + ], + "metadata": { + "id": "FfbTtiC5g83U" + } }, - "5c666868d62e4862a648cd0df15155ec": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_36b86b673b544cc5bdb5652eb31cabc9", - "IPY_MODEL_6d93392ab27048068aa8bb1d7ef01cf1" + { + "cell_type": "code", + "source": [ + "from tqdm.auto import tqdm\n", + "\n", + "\n", + "# Main setup function\n", + "def n_steps_custom(n: int, show_progress: bool = True):\n", + "\n", + " # Setup progress bar so that we can monitor progress\n", + " if show_progress:\n", + " pbar = tqdm(total=n, unit=\" step\")\n", + "\n", + " # The stop Criteria function\n", + " def continue_while(\n", + " step: int,\n", + " obj: opt.InputOptimization,\n", + " history: Iterable[torch.Tensor],\n", + " optim: torch.optim.Optimizer,\n", + " ) -> bool:\n", + " if len(history) > 0:\n", + " if show_progress:\n", + " # Print current optimization step and loss value\n", + " pbar.set_postfix(\n", + " {\"Objective\": f\"{history[-1].mean():.1f}\"}, refresh=False\n", + " )\n", + "\n", + " # Return True if we haven't reached the target num of optimization steps\n", + " if step < n:\n", + " if show_progress:\n", + " pbar.update()\n", + " return True\n", + "\n", + " # Return False if we have reached the target num of optimization steps\n", + " else:\n", + " if show_progress:\n", + " pbar.close()\n", + " return False\n", + "\n", + " # Return StopCriteria function to use for optimization\n", + " return continue_while" ], - "layout": "IPY_MODEL_389469a07da6435eb2a1be7ea55f4f86" - } + "metadata": { + "id": "_AFuQcdqg8Xx" + }, + "execution_count": null, + "outputs": [] }, - "6d93392ab27048068aa8bb1d7ef01cf1": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_ea6b900b717c4e8f8051094882aeef1f", - "placeholder": "​", - "style": "IPY_MODEL_ba6b8e0c07074921a5faa7dbc29f3fe3", - "value": " 128/128 [00:42<00:00, 2.99 step/s, Objective=356.1]" - } + { + "cell_type": "markdown", + "source": [ + "\n", + "## Custom Optimization Functions\n", + "\n", + "While the default `optimize` function from `InputOptimization` usually suffices for most use cases, you may find yourself needing something different. For example if you want to use a [learning rate scheduler](https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate), or if you wish to use an optimizer like LBFGS which requires a `closure` function [passed to their step function](https://pytorch.org/docs/stable/optim.html#taking-an-optimization-step).\n", + "\n", + "To create a custom optimization function, we will recreate the default `optimize` function while replacing `self` with the `InputOptimization` instance. We can then simply pass our `InputOptimization` instance to the function in order to render our results.\n", + "\n", + "Important `InputOptimization` Functions & Attributes:\n", + "\n", + "* The `.parameters()` function returns the list of input parameters requiring grad.\n", + "* The `.loss()` function returns the loss function values.\n", + "* The `.cleanup()` function removes the hooks that were used to collect activations.\n", + "* The model being used can be accessed via `.model` attribute.\n", + "* The transforms being used can be accessed via `.transforms` attribute." + ], + "metadata": { + "id": "uh1HqWb9ajpa" + } }, - "8fa32da11a2a4401a57a50f80af7be32": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + { + "cell_type": "code", + "source": [ + "def custom_optimize(\n", + " obj: opt.InputOptimization,\n", + " stop_criteria: Optional[Callable] = None,\n", + " optimizer: Optional[torch.optim.Optimizer] = None,\n", + " loss_summarize_fn: Optional[Callable] = None,\n", + " lr: float = 0.025,\n", + ") -> torch.Tensor:\n", + "\n", + " # Setup conditions for when to stop optimizing\n", + " stop_criteria = stop_criteria or opt.optimization.n_steps(512)\n", + "\n", + " # Pass the parameters of our optimization task to the optimizer\n", + " optimizer = optimizer or torch.optim.Adam(obj.parameters(), lr=lr)\n", + " assert isinstance(optimizer, torch.optim.Optimizer)\n", + "\n", + " # Set the loss summarization function\n", + " loss_summarize_fn = loss_summarize_fn or opt.loss.default_loss_summarize\n", + "\n", + " history: List[torch.Tensor] = []\n", + " step: int = 0\n", + "\n", + " # Run optimization loop with protection\n", + " try:\n", + "\n", + " # Stop criteria requires 4 variables from the optimization process\n", + " while stop_criteria(step, obj, history, optimizer):\n", + " optimizer.zero_grad()\n", + "\n", + " # Summarize any non scalar loss values\n", + " loss_value = loss_summarize_fn(obj.loss())\n", + "\n", + " # Place loss values from the current step into history list\n", + " history.append(loss_value.clone().detach())\n", + "\n", + " loss_value.backward()\n", + " optimizer.step()\n", + " # scheduler.step() # LR Scheduler step location\n", + " step += 1\n", + "\n", + " # Always run final clean up\n", + " finally:\n", + " obj.cleanup()\n", + "\n", + " # Return optimization loss history for all optimization steps\n", + " return torch.stack(history)" + ], + "metadata": { + "id": "VVfP7PTHafox" + }, + "execution_count": null, + "outputs": [] }, - "ba6b8e0c07074921a5faa7dbc29f3fe3": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } + { + "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." + ] }, - "ea6b900b717c4e8f8051094882aeef1f": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "uQ9sEz8cG2El" + }, + "outputs": [], + "source": [ + "def visualize(model: torch.nn.Module, target: torch.nn.Module):\n", + " # Define our custom image parameterization, then add it to NaturalImage\n", + " image_param = CustomImage\n", + " image = opt.images.NaturalImage(\n", + " size=(224, 224), parameterization=image_param, batch=2\n", + " ).to(device)\n", + "\n", + " transforms = torch.nn.Sequential(\n", + " CustomTransform(), # Add our custom transform to the list of transforms\n", + " # Additional transforms to improve output quality\n", + " opt.transforms.RandomSpatialJitter(16),\n", + " opt.transforms.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\n", + " )\n", + "\n", + " # Define our custom loss function as the loss function\n", + " loss_fn = CustomLoss(\n", + " target, batch_index=0 # Only optimize 0th image to demonstrate batch_index\n", + " )\n", + "\n", + " obj = opt.InputOptimization(model, loss_fn, image, transforms)\n", + " history = custom_optimize( # Our custom optimization function\n", + " obj=obj,\n", + " stop_criteria=n_steps_custom(512), # Our custom stop criteria\n", + " loss_summarize_fn=custom_loss_summarize, # Our custom loss_summarize_fn\n", + " )\n", + " image().show(figsize=(10, 5), images_per_row=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Oi5-40h_ZW5O" + }, + "source": [ + "And there you have it! Notice that only the left image (at index 0) is optimized since we specified `batch_index=0` when defining `loss_fn`. The right image is unchanged from its random initialization." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 335, + "referenced_widgets": [ + "42c156add91d4acaadcdefa7d261363e", + "b6d1bc1fa28140e2839110ea31c62cc3", + "988add1d46364a21be7e3cdd25bfeea6", + "3a0e2b4a4437470ca73d21b47b2e50bf", + "40d83f16100d4d52abdae1bfd57b3737", + "63a94da5642d4e638d34090f1c039ab1", + "be7c4264ae594792a8d5e325ffcd73f9", + "fdf5702bc6a0416284af79696f1bb7f8", + "1c85d25bb99440a0aab08a49200203f5", + "3b7848513468421aac1d1e8547223825", + "5bb9a2c83c5a4dc8ad1acc44ca79d7e8" + ] + }, + "id": "3m5iQ2zfqV5F", + "outputId": "a4e73b97-8181-4a1c-97da-124c74ff4195" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/512 [00:00" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "visualize(model, model.mixed4a)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Other Custom Modules" + ], + "metadata": { + "id": "T2AJzaGTZseI" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Custom NaturalImage Modules\n", + "\n", + "The requirements for creating your own variation of `NaturalImage` are extremely simple. The `forward` function should wrap the output in an `ImageTensor` instance. For JIT support, you can wrap the output in an `ImageTensor` instance inside a separate function that's wrapped with `@torch.jit.ignore`." + ], + "metadata": { + "id": "FIsFUiGPZdRm" + } + }, + { + "cell_type": "code", + "source": [ + "class CustomNaturalImage(opt.images.ImageParameterization):\n", + " def __init__(self, parameterization: opt.images.ImageParameterization) -> None:\n", + " \"\"\"\n", + " Args:\n", + "\n", + " parameterization (ImageParameterization): The image parameterization\n", + " instance you wish to use.\n", + " \"\"\"\n", + " super().__init__()\n", + " self.parameterization = parameterization\n", + "\n", + " @torch.jit.ignore\n", + " def to_image_tensor(self, x: torch.Tensor) -> torch.Tensor:\n", + " return opt.images.ImageTensor(x)\n", + "\n", + " def forward(self) -> torch.Tensor:\n", + " \"\"\"\n", + " Collect the current parameterized tensor and wrap it in ImageTensor.\n", + "\n", + " Returns\n", + " image(torch.Tensor): A PyTorch tensor.\n", + " \"\"\"\n", + " image = self.parameterization()\n", + " return self.to_image_tensor(image) # Wrap output in opt.images.ImageTensor" + ], + "metadata": { + "id": "xAKSiqg1ZccC" + }, + "execution_count": null, + "outputs": [] } - } - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "CustomModules_OptimViz.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "42c156add91d4acaadcdefa7d261363e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b6d1bc1fa28140e2839110ea31c62cc3", + "IPY_MODEL_988add1d46364a21be7e3cdd25bfeea6", + "IPY_MODEL_3a0e2b4a4437470ca73d21b47b2e50bf" + ], + "layout": "IPY_MODEL_40d83f16100d4d52abdae1bfd57b3737" + } + }, + "b6d1bc1fa28140e2839110ea31c62cc3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63a94da5642d4e638d34090f1c039ab1", + "placeholder": "​", + "style": "IPY_MODEL_be7c4264ae594792a8d5e325ffcd73f9", + "value": "100%" + } + }, + "988add1d46364a21be7e3cdd25bfeea6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fdf5702bc6a0416284af79696f1bb7f8", + "max": 512, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1c85d25bb99440a0aab08a49200203f5", + "value": 512 + } + }, + "3a0e2b4a4437470ca73d21b47b2e50bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3b7848513468421aac1d1e8547223825", + "placeholder": "​", + "style": "IPY_MODEL_5bb9a2c83c5a4dc8ad1acc44ca79d7e8", + "value": " 512/512 [00:12<00:00, 41.83 step/s, Objective=-32.6]" + } + }, + "40d83f16100d4d52abdae1bfd57b3737": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63a94da5642d4e638d34090f1c039ab1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be7c4264ae594792a8d5e325ffcd73f9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fdf5702bc6a0416284af79696f1bb7f8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c85d25bb99440a0aab08a49200203f5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3b7848513468421aac1d1e8547223825": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5bb9a2c83c5a4dc8ad1acc44ca79d7e8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 264a8ad563993c0d73dc772ba0f3d763882485d9 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 2 Jun 2022 10:33:25 -0600 Subject: [PATCH 030/174] Support non default input sizes in FacetLoss --- captum/optim/_core/loss.py | 14 +++++++++++++- tests/optim/core/test_loss.py | 28 +++++++++++++++++++++++----- 2 files changed, 36 insertions(+), 6 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 6542e828b7..04457aaa30 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -1037,7 +1037,19 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: else: strength_t = self.strength flat_attr = strength_t * flat_attr - return torch.sum(flat_attr * self.facet_weights) + + if ( + self.facet_weights.dim() == 4 + and layer.dim() == 4 + and self.facet_weights.shape[2:] != layer.shape[2:] + ): + facet_weights = torch.nn.functional.interpolate( + self.facet_weights, size=layer.shape[2:] + ) + else: + facet_weights = self.facet_weights + + return torch.sum(flat_attr * facet_weights) def sum_loss_list( diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 6ae0105f55..ee8e34a033 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -289,7 +289,7 @@ def test_facetloss_single_channel(self) -> None: model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() - facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + facet_weights = torch.ones([1, 2, 6, 6]) * 1.5 loss = opt_loss.FacetLoss( ultimate_target=model[1], layer_target=model[0].layer, @@ -308,7 +308,7 @@ def test_facetloss_multi_channel(self) -> None: model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([1, 1, 1]).float() - facet_weights = torch.ones([1, 2, 1, 1]) * 2.0 + facet_weights = torch.ones([1, 2, 6, 6]) * 2.0 loss = opt_loss.FacetLoss( ultimate_target=model[1], layer_target=model[0].layer, @@ -325,7 +325,7 @@ def test_facetloss_strength(self) -> None: model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() - facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + facet_weights = torch.ones([1, 2, 6, 6]) * 1.5 strength = 0.5 loss = opt_loss.FacetLoss( ultimate_target=model[1], @@ -345,7 +345,7 @@ def test_facetloss_strength_batch(self) -> None: model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() - facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + facet_weights = torch.ones([1, 2, 6, 6]) * 1.5 strength = [0.1, 5.05] loss = opt_loss.FacetLoss( ultimate_target=model[1], @@ -385,7 +385,7 @@ def test_facetloss_batch_index(self) -> None: model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) vec = torch.tensor([0, 1, 0]).float() - facet_weights = torch.ones([1, 2, 1, 1]) * 1.5 + facet_weights = torch.ones([1, 2, 5, 5]) * 1.5 loss = opt_loss.FacetLoss( ultimate_target=model[1], layer_target=model[0].layer, @@ -397,6 +397,24 @@ def test_facetloss_batch_index(self) -> None: output = get_loss_value(model, loss, model_input) self.assertAlmostEqual(output.item(), 10.38000202178955, places=5) + def test_facetloss_resize_4d(self) -> None: + layer = torch.nn.Conv2d(2, 3, 1, bias=True) + layer.weight.data.fill_(0.1) # type: ignore + layer.bias.data.fill_(1) # type: ignore + + model = torch.nn.Sequential(BasicModel_ConvNet_Optim(), layer) + + vec = torch.tensor([1, 1, 1]).float() + facet_weights = torch.ones([1, 2, 12, 12]) * 2.0 + loss = opt_loss.FacetLoss( + ultimate_target=model[1], + layer_target=model[0].layer, + vec=vec, + facet_weights=facet_weights, + ) + output = get_loss_value(model, loss, input_shape=[1, 3, 6, 6]) + self.assertAlmostEqual(output, 1.560000, places=6) + class TestCompositeLoss(BaseTest): def test_negative(self) -> None: From 00927a13ee8c3aa267a95a9f3dc1662c17e47d6f Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 2 Jun 2022 14:10:06 -0600 Subject: [PATCH 031/174] Improve loss docs * Add missing docs. * Fix errors in existing docs. --- captum/optim/_core/loss.py | 153 ++++++++++++++++++++++++++++++++----- 1 file changed, 134 insertions(+), 19 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 194422f3f6..57b63ebc1c 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -10,6 +10,14 @@ def _make_arg_str(arg: Any) -> str: + """ + Args: + + args (Any): A set of arguments to covert to a string. + + Returns: + args (str): The args in str form. + """ arg = str(arg) too_big = len(arg) > 15 or "\n" in arg return arg[:15] + "..." if too_big else arg @@ -23,7 +31,7 @@ class Loss(ABC): """ def __init__(self) -> None: - super(Loss, self).__init__() + super().__init__() @abstractproperty def target(self) -> Union[nn.Module, List[nn.Module]]: @@ -105,10 +113,35 @@ def module_op( ) -> "CompositeLoss": """ This is a general function for applying math operations to Losses + + Args: + + self (Loss): A Loss objective instance. + other (int, float, Loss, or None): The Loss objective instance or number to + use on the self Loss objective as part of a math operation. If math_op + is a unary operation, then other should be set to None. + math_op (Callable): A math operator to use on the Loss instance. + + Returns: + loss (CompositeLoss): A CompositeLoss instance with the math operations + created by the specified arguments. """ if other is None and math_op == operator.neg: def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: + """ + Pass collected activations through loss objective, and then apply a unary + math op. + + Args: + + module (ModuleOutputMapping): A dict of captured activations with + nn.Modules as keys. + + Returns: + loss (torch.Tensor): The target activations after being run + through the loss objective, and the unary math_op. + """ return math_op(self(module)) name = self.__name__ @@ -116,6 +149,19 @@ def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: elif isinstance(other, (int, float)): def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: + """ + Pass collected activations through the loss objective and then apply the + math operations with numbers. + + Args: + + module (ModuleOutputMapping): A dict of captured activations with + nn.Modules as keys. + + Returns: + loss (torch.Tensor): The target activations after being run + through the loss objective, and then the math_op with a number. + """ return math_op(self(module), other) name = self.__name__ @@ -123,6 +169,19 @@ def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: elif isinstance(other, Loss): # We take the mean of the output tensor to resolve shape mismatches def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: + """ + Pass collected activations through the loss objectives and then combine the + outputs with a math operation. + + Args: + + module (ModuleOutputMapping): A dict of captured activations with + nn.Modules as keys. + + Returns: + loss (torch.Tensor): The target activations after being run + through the loss objectives, and then merged with the math_op. + """ return math_op(torch.mean(self(module)), torch.mean(other(module))) name = f"Compose({', '.join([self.__name__, other.__name__])})" @@ -143,7 +202,18 @@ def __init__( target: Union[nn.Module, List[nn.Module]] = [], batch_index: Optional[Union[int, List[int]]] = None, ) -> None: - super(BaseLoss, self).__init__() + """ + Args: + + target (nn.Module or list of nn.module): A target nn.Module or list of + nn.Module. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set to + None, defaults to all activations in the batch. Index ranges should be + in the format of: [start, end]. + Default: None + """ + super().__init__() self._target = target if batch_index is None: self._batch_index = (None, None) @@ -156,10 +226,20 @@ def __init__( @property def target(self) -> Union[nn.Module, List[nn.Module]]: + """ + Returns: + target (nn.Module or list of nn.Module): A target nn.Module or list of + nn.Module. + """ return self._target @property def batch_index(self) -> Tuple: + """ + Returns: + batch_index (tuple of int): A tuple of batch indices with a format + of: (start, end). + """ return self._batch_index @@ -170,11 +250,35 @@ def __init__( name: str = "", target: Union[nn.Module, List[nn.Module]] = [], ) -> None: - super(CompositeLoss, self).__init__(target) + """ + Args: + + loss_fn (Callable): A function that takes a dict of captured activations + with nn.Modules as keys, and then passes those activations through loss + objective(s) & math operations. + name (str, optional): The name of all composable operations in the + instance. + Default: "" + target (nn.Module or list of nn.module): A target nn.Module or list of + nn.Module. + """ + super().__init__(target) self.__name__ = name self.loss_fn = loss_fn def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + """ + Pass collected activations through the loss function. + + Args: + + module (ModuleOutputMapping): A dict of captured activations with + nn.Modules as keys. + + Returns: + loss (torch.Tensor): The target activations after being run through the + loss function. + """ return self.loss_fn(targets_to_values) @@ -206,7 +310,7 @@ class LayerActivation(BaseLoss): instance to optimize the output of. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. index ranges should be + None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -239,7 +343,7 @@ def __init__( channel_index (int): The index of the channel to optimize for. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. index ranges should be + None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -292,7 +396,7 @@ def __init__( Default: None batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. index ranges should be + None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -333,7 +437,7 @@ class DeepDream(BaseLoss): instance to optimize the output of. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. index ranges should be + None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -360,7 +464,7 @@ class TotalVariation(BaseLoss): instance to optimize the output of. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. index ranges should be + None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -393,7 +497,7 @@ def __init__( constant (float): Constant threshold to deduct from the activations. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. index ranges should be + None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -430,7 +534,7 @@ def __init__( Default: 1e-6 batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. index ranges should be + None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -461,7 +565,7 @@ class Diversity(BaseLoss): target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. batch_index (list of int, optional): The index range of activations to - optimize. If set to None, defaults to all activations in the batch. index + optimize. If set to None, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: None """ @@ -579,7 +683,7 @@ def __init__( Default: 2.0 batch_index (list of int, optional): The index range of activations to optimize. If set to None, defaults to all activations in the batch. - index ranges should be in the format of: [start, end]. + Index ranges should be in the format of: [start, end]. Default: None """ if batch_index: @@ -730,7 +834,7 @@ class AngledNeuronDirection(BaseLoss): More information on the algorithm this objective uses can be found here: https://github.com/tensorflow/lucid/issues/116 - This Lucid equivalents of this loss function can be found here: + This Lucid equivalents of this loss objective can be found here: https://github.com/tensorflow/lucid/blob/master/notebooks/ activation-atlas/activation-atlas-simple.ipynb https://github.com/tensorflow/lucid/blob/master/notebooks/ @@ -775,6 +879,10 @@ def __init__( eps (float, optional): If cossim_pow is greater than zero, the desired epsilon value to use for cosine similarity calculations. Default: 1.0e-4 + batch_index (int, optional): The index of activations to optimize if + optimizing a batch of activations. If set to None, defaults to all + activations in the batch. + Default: None """ BaseLoss.__init__(self, target, batch_index) self.vec = vec.unsqueeze(0) if vec.dim() == 1 else vec @@ -948,22 +1056,22 @@ def sum_loss_list( ) -> CompositeLoss: """ Summarize a large number of losses without recursion errors. By default using 300+ - loss functions for a single optimization task will result in exceeding Python's + loss objectives for a single optimization task will result in exceeding Python's default maximum recursion depth limit. This function can be used to avoid the - recursion depth limit for tasks such as summarizing a large list of loss functions + recursion depth limit for tasks such as summarizing a large list of loss objectives with the built-in sum() function. This function works similar to Lucid's optvis.objectives.Objective.sum() function. Args: - loss_list (list): A list of loss function objectives. - to_scalar_fn (Callable): A function for converting loss function outputs to + loss_list (list): A list of loss objectives. + to_scalar_fn (Callable): A function for converting loss objective outputs to scalar values, in order to prevent size mismatches. Default: torch.mean Returns: - loss_fn (CompositeLoss): A composite loss function containing all the loss + loss_fn (CompositeLoss): A CompositeLoss instance containing all the loss functions from `loss_list`. """ @@ -985,11 +1093,18 @@ def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: def default_loss_summarize(loss_value: torch.Tensor) -> torch.Tensor: """ - Helper function to summarize tensor outputs from loss functions. + Helper function to summarize tensor outputs from loss objectives. default_loss_summarize applies `mean` to the loss tensor and negates it so that optimizing it maximizes the activations we are interested in. + + Args: + + loss_value (torch.Tensor): A tensor containing the loss values. + + Returns: + loss_value (torch.Tensor): The loss_value's mean multiplied by -1. """ return -1 * loss_value.mean() From 16f2177fe5f5df08800e6bc96291bb5a3a053b27 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 3 Jun 2022 14:49:14 -0600 Subject: [PATCH 032/174] Add additional tests --- tests/optim/core/test_loss.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 97f4c78ed1..0ba3651175 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -220,7 +220,7 @@ def test_l2_batch_index(self) -> None: model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() output = get_loss_value(model, loss, model_input) self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) - self.assertEqual(output.item(), 987.9017944335938) + self.assertAlmostEqual(output.item(), 987.9017944335938, places=3) class TestDiversity(BaseTest): @@ -736,6 +736,23 @@ def test_sum_loss_list_compose_add(self) -> None: out = get_loss_value(model, loss_fn, [n_batch, 3, 1, 1]) self.assertEqual(out, float(n_batch + 1.0)) + def test_sum_loss_list_sum(self) -> None: + n_batch = 100 + model = torch.nn.Identity() + loss_fn_list = [opt_loss.LayerActivation(model) for i in range(n_batch)] + loss_fn = opt_loss.sum_loss_list(loss_fn_list, torch.sum) + out = get_loss_value(model, loss_fn, [n_batch, 3, 1, 1]) + self.assertEqual(out.item(), 30000.0) + + def test_sum_loss_list_identity(self) -> None: + n_batch = 100 + model = torch.nn.Identity() + loss_fn_list = [opt_loss.LayerActivation(model) for i in range(n_batch)] + loss_fn = opt_loss.sum_loss_list(loss_fn_list, torch.nn.Identity()) + out = get_loss_value(model, loss_fn, [n_batch, 3, 1, 1]) + self.assertEqual(list(out.shape), [n_batch, 3, 1, 1]) + self.assertEqual(out.sum().item(), 30000.0) + class TestModuleOP(BaseTest): def test_module_op_loss_unary_op(self) -> None: From 63843b59edc96c96fa0c844b2bd200c16a559c4c Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 5 Jun 2022 09:23:30 -0600 Subject: [PATCH 033/174] Add packaging library to setup.py --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 48bc6f4057..09fe441950 100755 --- a/setup.py +++ b/setup.py @@ -147,7 +147,7 @@ def get_package_files(root, subdirs): long_description=long_description, long_description_content_type="text/markdown", python_requires=">=3.6", - install_requires=["matplotlib", "numpy", "torch>=1.6"], + install_requires=["matplotlib", "numpy", "packaging", "torch>=1.6"], packages=find_packages(exclude=("tests", "tests.*")), extras_require={ "dev": DEV_REQUIRES, From 9305b109417ca24ee6893075e03f3da241e59252 Mon Sep 17 00:00:00 2001 From: Daniel Krakowczykgit Date: Thu, 9 Jun 2022 16:59:48 -0700 Subject: [PATCH 034/174] Add support for captum toplevel-import. (#912) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Summary: This fixes issue https://github.com/pytorch/captum/issues/680 Strange import issue --> AttributeError: module 'captum' has no attribute 'attr' In most python packages, you can import the toplevel package, like numpy, scipy, torch, etc.. and then access the submodules simply by the dot-operator. Like you can use `import numpy` and after that you can use any submodules à la `numpy.random.uniform`. With this PR, you can just `import captum` and then for example use `captum.attr.DeepLift` or `captum.robust.Perturbation` instead of having to import both. It's just a small convenience, and I think there are more people that expect this kind of import to work but don't bother to create an issue out of this. I hope this PR is considered as helpful. Pull Request resolved: https://github.com/pytorch/captum/pull/912 Reviewed By: NarineK Differential Revision: D37053826 Pulled By: vivekmig fbshipit-source-id: 64fa2be7651ca30571d1eb85b45dd11410676c4b --- captum/__init__.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/captum/__init__.py b/captum/__init__.py index 24b3fae727..fda440d4f5 100644 --- a/captum/__init__.py +++ b/captum/__init__.py @@ -1,3 +1,11 @@ #!/usr/bin/env python3 +import captum.attr as attr # noqa +import captum.concept as concept # noqa +import captum.influence as influence # noqa +import captum.insights as insights # noqa +import captum.log as log # noqa +import captum.metrics as metrics # noqa +import captum.robust as robust # noqa + __version__ = "0.5.0" From 1489f3fd3ab4011626fa23850bf364802426c893 Mon Sep 17 00:00:00 2001 From: Zhiyuan Chen Date: Fri, 10 Jun 2022 08:24:25 -0700 Subject: [PATCH 035/174] Fix comment in saliency (#970) Summary: Pull Request resolved: https://github.com/pytorch/captum/pull/970 Reviewed By: aobo-y Differential Revision: D37010644 Pulled By: vivekmig fbshipit-source-id: 8f90f0d428e48bd156ea743e6983b825194284f4 --- captum/attr/_core/saliency.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/captum/attr/_core/saliency.py b/captum/attr/_core/saliency.py index 7e2aeed5cd..3790bd2068 100644 --- a/captum/attr/_core/saliency.py +++ b/captum/attr/_core/saliency.py @@ -43,9 +43,9 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which integrated - gradients are computed. If forward_func takes a single - tensor as input, a single input tensor should be provided. + inputs (tensor or tuple of tensors): Input for which saliency + is computed. If forward_func takes a single tensor + as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds From 4aa7e48a98ec607cd6f257e11ff9eb60b5dee985 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 12 Jun 2022 14:06:46 -0700 Subject: [PATCH 036/174] Fix `set_all_random_seeds` testing function (#974) Summary: A seed value was being passed to the function, but it was ignored. This PR fixes that. Pull Request resolved: https://github.com/pytorch/captum/pull/974 Reviewed By: NarineK Differential Revision: D37093181 Pulled By: vivekmig fbshipit-source-id: 87daeb3b7b242f42c66f20836a9702a9226819ca --- tests/helpers/basic.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/helpers/basic.py b/tests/helpers/basic.py index 8f5fb0ae9f..7ac9a8b4cd 100644 --- a/tests/helpers/basic.py +++ b/tests/helpers/basic.py @@ -81,11 +81,11 @@ def assert_delta(test, delta): ) -def set_all_random_seeds(seed): - random.seed(1234) - np.random.seed(1234) - torch.manual_seed(1234) - torch.cuda.manual_seed_all(1234) +def set_all_random_seeds(seed: int = 1234) -> None: + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) torch.backends.cudnn.deterministic = True @@ -96,6 +96,6 @@ class BaseTest(unittest.TestCase): initializations are random, this ensures that tests run deterministically. """ - def setUp(self): + def setUp(self) -> None: set_all_random_seeds(1234) patch_methods(self) From 0ece0afeadb923fbaff798e2e3ebb7a1665ccc6d Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 13 Jun 2022 17:12:06 -0700 Subject: [PATCH 037/174] Add missing type hints in accordance with PEP-0484 (#976) Summary: Adding `-> None` to `__init__` functions is specified by [PEP-0484](https://www.python.org/dev/peps/pep-0484/) and is really easy to do with regex, so I went ahead and did it for the `captum/` & `tests/` directories. I used this to do it: https://stackoverflow.com/questions/64948233/how-to-add-none-to-the-end-of-init-functions-with-notepad If this PR seems a bit familiar, it's because I submitted a similar one 2 years ago: https://github.com/pytorch/captum/pull/535 Pull Request resolved: https://github.com/pytorch/captum/pull/976 Reviewed By: vivekmig Differential Revision: D37094723 Pulled By: NarineK fbshipit-source-id: 10b73a325f838ffb8c1301c6132792ef3730197c --- captum/_utils/av.py | 2 +- captum/_utils/progress.py | 4 +-- captum/_utils/sample_gradient.py | 28 +++++++++---------- captum/concept/_core/tcav.py | 2 +- captum/concept/_utils/classifier.py | 6 ++-- .../influence/_core/similarity_influence.py | 2 +- captum/influence/_utils/common.py | 2 +- captum/influence/_utils/nearest_neighbors.py | 2 +- captum/log/__init__.py | 2 +- .../_core/metrics/min_param_perturbation.py | 2 +- tests/attr/test_hook_removal.py | 2 +- tests/concept/test_concept.py | 2 +- tests/helpers/basic_models.py | 10 +++---- .../_core/test_similarity_influence.py | 4 +-- tests/influence/_utils/common.py | 18 ++++++------ tests/robust/test_attack_comparator.py | 2 +- tests/utils/test_av.py | 2 +- 17 files changed, 46 insertions(+), 46 deletions(-) diff --git a/captum/_utils/av.py b/captum/_utils/av.py index f3b235dd8d..ac3c32a204 100644 --- a/captum/_utils/av.py +++ b/captum/_utils/av.py @@ -47,7 +47,7 @@ def __init__( identifier: Optional[str] = None, layer: Optional[str] = None, num_id: Optional[str] = None, - ): + ) -> None: r""" Loads into memory the list of all activation file paths associated with the input `model_id`. diff --git a/captum/_utils/progress.py b/captum/_utils/progress.py index 88cb07e83f..2ece45ad99 100644 --- a/captum/_utils/progress.py +++ b/captum/_utils/progress.py @@ -12,7 +12,7 @@ class DisableErrorIOWrapper(object): - def __init__(self, wrapped: TextIO): + def __init__(self, wrapped: TextIO) -> None: """ The wrapper around a TextIO object to ignore write errors like tqdm https://github.com/tqdm/tqdm/blob/bcce20f771a16cb8e4ac5cc5b2307374a2c0e535/tqdm/utils.py#L131 @@ -48,7 +48,7 @@ def __init__( total: int = None, file: TextIO = None, mininterval: float = 0.5, - ): + ) -> None: """ Simple progress output used when tqdm is unavailable. Same as tqdm, output to stderr channel diff --git a/captum/_utils/sample_gradient.py b/captum/_utils/sample_gradient.py index 694b2c0121..d17e5b9bf1 100644 --- a/captum/_utils/sample_gradient.py +++ b/captum/_utils/sample_gradient.py @@ -1,6 +1,6 @@ from collections import defaultdict from enum import Enum -from typing import cast, Iterable, Tuple, Union +from typing import cast, DefaultDict, Iterable, List, Tuple, Union import torch from captum._utils.common import _format_tensor_into_tuples, _register_backward_hook @@ -8,7 +8,7 @@ from torch.nn import Module -def _reset_sample_grads(module: Module): +def _reset_sample_grads(module: Module) -> None: module.weight.sample_grad = 0 # type: ignore if module.bias is not None: module.bias.sample_grad = 0 # type: ignore @@ -100,19 +100,19 @@ class SampleGradientWrapper: - https://github.com/pytorch/opacus/tree/main/opacus/grad_sample """ - def __init__(self, model): + def __init__(self, model) -> None: self.model = model self.hooks_added = False - self.activation_dict = defaultdict(list) - self.gradient_dict = defaultdict(list) - self.forward_hooks = [] - self.backward_hooks = [] + self.activation_dict: DefaultDict[Module, List[Tensor]] = defaultdict(list) + self.gradient_dict: DefaultDict[Module, List[Tensor]] = defaultdict(list) + self.forward_hooks: List[torch.utils.hooks.RemovableHandle] = [] + self.backward_hooks: List[torch.utils.hooks.RemovableHandle] = [] - def add_hooks(self): + def add_hooks(self) -> None: self.hooks_added = True self.model.apply(self._register_module_hooks) - def _register_module_hooks(self, module: torch.nn.Module): + def _register_module_hooks(self, module: torch.nn.Module) -> None: if isinstance(module, tuple(SUPPORTED_MODULES.keys())): self.forward_hooks.append( module.register_forward_hook(self._forward_hook_fn) @@ -126,7 +126,7 @@ def _forward_hook_fn( module: Module, module_input: Union[Tensor, Tuple[Tensor, ...]], module_output: Union[Tensor, Tuple[Tensor, ...]], - ): + ) -> None: inp_tuple = _format_tensor_into_tuples(module_input) self.activation_dict[module].append(inp_tuple[0].clone().detach()) @@ -135,11 +135,11 @@ def _backward_hook_fn( module: Module, grad_input: Union[Tensor, Tuple[Tensor, ...]], grad_output: Union[Tensor, Tuple[Tensor, ...]], - ): + ) -> None: grad_output_tuple = _format_tensor_into_tuples(grad_output) self.gradient_dict[module].append(grad_output_tuple[0].clone().detach()) - def remove_hooks(self): + def remove_hooks(self) -> None: self.hooks_added = False for hook in self.forward_hooks: @@ -151,11 +151,11 @@ def remove_hooks(self): self.forward_hooks = [] self.backward_hooks = [] - def _reset(self): + def _reset(self) -> None: self.activation_dict = defaultdict(list) self.gradient_dict = defaultdict(list) - def compute_param_sample_gradients(self, loss_blob, loss_mode="mean"): + def compute_param_sample_gradients(self, loss_blob, loss_mode="mean") -> None: assert ( loss_mode.upper() in LossMode.__members__ ), f"Provided loss mode {loss_mode} is not valid" diff --git a/captum/concept/_core/tcav.py b/captum/concept/_core/tcav.py index 6d79ba06ae..8b6c996856 100644 --- a/captum/concept/_core/tcav.py +++ b/captum/concept/_core/tcav.py @@ -27,7 +27,7 @@ class LabelledDataset(Dataset): It is used to train a classifier in train_tcav """ - def __init__(self, datasets: List[AV.AVDataset], labels: List[int]): + def __init__(self, datasets: List[AV.AVDataset], labels: List[int]) -> None: """ Creates the LabelledDataset given a list of K Datasets, and a length K list of integer labels representing K different concepts. diff --git a/captum/concept/_utils/classifier.py b/captum/concept/_utils/classifier.py index b9b21f809d..5bdf605470 100644 --- a/captum/concept/_utils/classifier.py +++ b/captum/concept/_utils/classifier.py @@ -126,7 +126,7 @@ class DefaultClassifier(Classifier): class and handles large concept datasets accordingly. """ - def __init__(self): + def __init__(self) -> None: warnings.warn( "Using default classifier for TCAV which keeps input" " both train and test datasets in the memory. Consider defining" @@ -178,7 +178,7 @@ def train_and_eval( predict = self.lm(x_test) - predict = self.lm.classes()[torch.argmax(predict, dim=1)] + predict = self.lm.classes()[torch.argmax(predict, dim=1)] # type: ignore score = predict.long() == y_test.long().cpu() accs = score.float().mean() @@ -217,7 +217,7 @@ def classes(self) -> List[int]: classes (list): The list of classes used by the classifier to train the model in the `train_and_eval` method. """ - return self.lm.classes().detach().numpy() + return self.lm.classes().detach().numpy() # type: ignore def _train_test_split( diff --git a/captum/influence/_core/similarity_influence.py b/captum/influence/_core/similarity_influence.py index f781079a48..83cb2966fa 100644 --- a/captum/influence/_core/similarity_influence.py +++ b/captum/influence/_core/similarity_influence.py @@ -77,7 +77,7 @@ def __init__( similarity_direction: str = "max", batch_size: int = 1, **kwargs: Any, - ): + ) -> None: r""" Args: module (torch.nn.Module): An instance of pytorch model. This model should diff --git a/captum/influence/_utils/common.py b/captum/influence/_utils/common.py index 10783eaf4c..b86ddf9f93 100644 --- a/captum/influence/_utils/common.py +++ b/captum/influence/_utils/common.py @@ -305,7 +305,7 @@ def _get_k_most_influential_helper( class _DatasetFromList(Dataset): - def __init__(self, _l: List[Any]): + def __init__(self, _l: List[Any]) -> None: self._l = _l def __getitem__(self, i: int) -> Any: diff --git a/captum/influence/_utils/nearest_neighbors.py b/captum/influence/_utils/nearest_neighbors.py index 3c26d1d448..3ecd452de3 100644 --- a/captum/influence/_utils/nearest_neighbors.py +++ b/captum/influence/_utils/nearest_neighbors.py @@ -92,7 +92,7 @@ class AnnoyNearestNeighbors(NearestNeighbors): but arbitrary shape *, and flatten them before storing in the Annoy data structure. """ - def __init__(self, num_trees: int = 10): + def __init__(self, num_trees: int = 10) -> None: """ Args: num_trees (int): The number of trees to use. Increasing this number gives diff --git a/captum/log/__init__.py b/captum/log/__init__.py index 81d61383d0..8c0b7472ad 100644 --- a/captum/log/__init__.py +++ b/captum/log/__init__.py @@ -19,7 +19,7 @@ def log(*args, **kwargs): # bug with mypy: https://github.com/python/mypy/issues/1153 class TimedLog: # type: ignore - def __init__(self, *args, **kwargs): + def __init__(self, *args, **kwargs) -> None: pass def __enter__(self): diff --git a/captum/robust/_core/metrics/min_param_perturbation.py b/captum/robust/_core/metrics/min_param_perturbation.py index 279179ab64..99308727e4 100644 --- a/captum/robust/_core/metrics/min_param_perturbation.py +++ b/captum/robust/_core/metrics/min_param_perturbation.py @@ -51,7 +51,7 @@ def __init__( preproc_fn: Optional[Callable] = None, apply_before_preproc: bool = False, correct_fn: Optional[Callable] = None, - ): + ) -> None: r""" Identifies minimal perturbation based on target variable which causes misclassification (or other incorrect prediction) of target input. diff --git a/tests/attr/test_hook_removal.py b/tests/attr/test_hook_removal.py index b23f80f933..ce0d0b3316 100644 --- a/tests/attr/test_hook_removal.py +++ b/tests/attr/test_hook_removal.py @@ -45,7 +45,7 @@ class HookRemovalMode(Enum): class ErrorModule(Module): def __init__( self, - ): + ) -> None: super().__init__() self.relu = torch.nn.ReLU() diff --git a/tests/concept/test_concept.py b/tests/concept/test_concept.py index ab7e81e42a..2efb336a5a 100644 --- a/tests/concept/test_concept.py +++ b/tests/concept/test_concept.py @@ -14,7 +14,7 @@ class CustomIterableDataset(IterableDataset): An auxiliary class for iterating through an image dataset. """ - def __init__(self, get_tensor_from_filename_func, path): + def __init__(self, get_tensor_from_filename_func, path) -> None: r""" Args: diff --git a/tests/helpers/basic_models.py b/tests/helpers/basic_models.py index 84020bae21..f2e5c02292 100644 --- a/tests/helpers/basic_models.py +++ b/tests/helpers/basic_models.py @@ -16,7 +16,7 @@ class BasicLinearReLULinear(nn.Module): - def __init__(self, in_features, out_features=5, bias=False): + def __init__(self, in_features, out_features=5, bias=False) -> None: super().__init__() self.fc1 = nn.Linear(in_features, out_features, bias=bias) self.relu1 = nn.ReLU() @@ -30,7 +30,7 @@ def forward(self, x): class MixedKwargsAndArgsModule(nn.Module): - def __init__(self): + def __init__(self) -> None: super().__init__() def forward(self, x, y=None): @@ -135,7 +135,7 @@ def forward(self, x1, x2): class BasicLinearModel2(nn.Module): - def __init__(self, in_features, out_features): + def __init__(self, in_features, out_features) -> None: super().__init__() self.linear = nn.Linear(in_features, out_features, bias=False) @@ -144,7 +144,7 @@ def forward(self, input): class BasicLinearModel_Multilayer(nn.Module): - def __init__(self, in_features, hidden_nodes, out_features): + def __init__(self, in_features, hidden_nodes, out_features) -> None: super().__init__() self.linear1 = nn.Linear(in_features, hidden_nodes, bias=False) self.linear2 = nn.Linear(hidden_nodes, out_features, bias=False) @@ -433,7 +433,7 @@ def forward(self, x1: Tensor, x2: Tensor, x3: Tensor, scale: int): class BasicModel_MultiLayer_TrueMultiInput(nn.Module): - def __init__(self): + def __init__(self) -> None: super().__init__() self.m1 = BasicModel_MultiLayer() self.m234 = BasicModel_MultiLayer_MultiInput() diff --git a/tests/influence/_core/test_similarity_influence.py b/tests/influence/_core/test_similarity_influence.py index 4477e57094..ec08bf6cf1 100644 --- a/tests/influence/_core/test_similarity_influence.py +++ b/tests/influence/_core/test_similarity_influence.py @@ -13,7 +13,7 @@ class BasicLinearNet(nn.Module): - def __init__(self, num_features): + def __init__(self, num_features) -> None: super().__init__() self.fc1 = nn.Linear(num_features, 5, bias=False) self.fc1.weight.data.fill_(0.02) @@ -29,7 +29,7 @@ def forward(self, x): class RangeDataset(Dataset): - def __init__(self, low, high, num_features): + def __init__(self, low, high, num_features) -> None: self.samples = ( torch.arange(start=low, end=high, dtype=torch.float) .repeat(num_features, 1) diff --git a/tests/influence/_utils/common.py b/tests/influence/_utils/common.py index 5d7cd3d5a0..90f14353c7 100644 --- a/tests/influence/_utils/common.py +++ b/tests/influence/_utils/common.py @@ -26,7 +26,7 @@ def isSorted(x, key=lambda x: x, descending=True): class ExplicitDataset(Dataset): - def __init__(self, samples, labels): + def __init__(self, samples, labels) -> None: self.samples, self.labels = samples, labels def __len__(self): @@ -37,7 +37,7 @@ def __getitem__(self, idx): class UnpackDataset(Dataset): - def __init__(self, samples, labels): + def __init__(self, samples, labels) -> None: self.samples, self.labels = samples, labels def __len__(self): @@ -52,13 +52,13 @@ def __getitem__(self, idx): class IdentityDataset(ExplicitDataset): - def __init__(self, num_features): + def __init__(self, num_features) -> None: self.samples = torch.diag(torch.ones(num_features)) self.labels = torch.zeros(num_features).unsqueeze(1) class RangeDataset(ExplicitDataset): - def __init__(self, low, high, num_features): + def __init__(self, low, high, num_features) -> None: self.samples = ( torch.arange(start=low, end=high, dtype=torch.float) .repeat(num_features, 1) @@ -68,7 +68,7 @@ def __init__(self, low, high, num_features): class BinaryDataset(ExplicitDataset): - def __init__(self): + def __init__(self) -> None: self.samples = F.normalize( torch.stack( ( @@ -108,7 +108,7 @@ def __init__(self): class CoefficientNet(nn.Module): - def __init__(self, in_features=1): + def __init__(self, in_features=1) -> None: super().__init__() self.fc1 = nn.Linear(in_features, 1, bias=False) self.fc1.weight.data.fill_(0.01) @@ -119,7 +119,7 @@ def forward(self, x): class BasicLinearNet(nn.Module): - def __init__(self, in_features, hidden_nodes, out_features): + def __init__(self, in_features, hidden_nodes, out_features) -> None: super().__init__() self.linear1 = nn.Linear(in_features, hidden_nodes) self.linear2 = nn.Linear(hidden_nodes, out_features) @@ -130,7 +130,7 @@ def forward(self, input): class MultLinearNet(nn.Module): - def __init__(self, in_features, hidden_nodes, out_features, num_inputs): + def __init__(self, in_features, hidden_nodes, out_features, num_inputs) -> None: super().__init__() self.pre = nn.Linear(in_features * num_inputs, in_features) self.linear1 = nn.Linear(in_features, hidden_nodes) @@ -206,7 +206,7 @@ class DataInfluenceConstructor: def __init__( self, data_influence_class: type, name: Optional[str] = None, **kwargs - ): + ) -> None: self.data_influence_class = data_influence_class self.name = name if name else data_influence_class.__name__ self.kwargs = kwargs diff --git a/tests/robust/test_attack_comparator.py b/tests/robust/test_attack_comparator.py index 494fe2f649..2b356455f8 100644 --- a/tests/robust/test_attack_comparator.py +++ b/tests/robust/test_attack_comparator.py @@ -51,7 +51,7 @@ def string_batch_perturb(inp: List[List[str]]) -> List[List[str]]: class SamplePerturb: - def __init__(self): + def __init__(self) -> None: self.count = 0 def perturb(self, inp: Tensor) -> Tensor: diff --git a/tests/utils/test_av.py b/tests/utils/test_av.py index d5d4e2b92c..956bcd34de 100644 --- a/tests/utils/test_av.py +++ b/tests/utils/test_av.py @@ -13,7 +13,7 @@ class RangeDataset(Dataset): - def __init__(self, low, high, num_features): + def __init__(self, low, high, num_features) -> None: self.samples = ( torch.arange(start=low, end=high, dtype=torch.float) .repeat(num_features, 1) From 8b82a37959822d60669f5db9b700b348483a6361 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 16 Jun 2022 12:13:04 -0600 Subject: [PATCH 038/174] Add alias for ImageTensor.open() --- captum/optim/_param/image/images.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 3fade94f64..e4c4c05210 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -69,6 +69,11 @@ def open(cls, path: str, scale: float = 255.0, mode: str = "RGB") -> "ImageTenso img_np = np.array(img.convert(mode)).astype(np.float32) return cls(img_np.transpose(2, 0, 1) / scale) + @classmethod + def load(cls, path: str, scale: float = 255.0, mode: str = "RGB") -> "ImageTensor": + """Alias of ImageTensor.open()""" + return cls.open(path=path, scale=scale, mode=mode) + def __repr__(self) -> str: prefix = "ImageTensor(" indent = len(prefix) From afc4759083b29ace64c5a80481ad5306ad41eab4 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 20 Jun 2022 12:08:05 -0700 Subject: [PATCH 039/174] Update minimum PyTorch version in README (#977) Summary: It should be >= 1.6, not >= 1.2. Pull Request resolved: https://github.com/pytorch/captum/pull/977 Reviewed By: vivekmig Differential Revision: D37270407 Pulled By: NarineK fbshipit-source-id: cd51a5e5f8665143c4171be001675d624b6a60b3 --- README.md | 2 +- environment.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 801fa4d23a..5f415f7e0a 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,7 @@ Captum can also be used by application engineers who are using trained models in **Installation Requirements** - Python >= 3.6 -- PyTorch >= 1.2 +- PyTorch >= 1.6 ##### Installing the latest release diff --git a/environment.yml b/environment.yml index cd9c40927c..61de9e0096 100644 --- a/environment.yml +++ b/environment.yml @@ -3,4 +3,4 @@ channels: - pytorch dependencies: - numpy - - pytorch>=1.2 + - pytorch>=1.6 From 857f26c07eab76344543624b5ce20d2b85ec4ee1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 20 Jun 2022 14:54:10 -0600 Subject: [PATCH 040/174] Add CompositeLoss to __all__ --- captum/optim/_core/loss.py | 1 + 1 file changed, 1 insertion(+) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 57b63ebc1c..fa0808a981 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -1113,6 +1113,7 @@ def default_loss_summarize(loss_value: torch.Tensor) -> torch.Tensor: "Loss", "loss_wrapper", "BaseLoss", + "CompositeLoss", "LayerActivation", "ChannelActivation", "NeuronActivation", From 9e9a6beb0cf7f5a8f4d55225d087e2240f0c1953 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 20 Jun 2022 18:49:17 -0600 Subject: [PATCH 041/174] Add Conv2dSame to __all__ --- captum/optim/models/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/captum/optim/models/__init__.py b/captum/optim/models/__init__.py index 687aab0f85..121fa09257 100755 --- a/captum/optim/models/__init__.py +++ b/captum/optim/models/__init__.py @@ -6,6 +6,7 @@ get_model_layers, replace_layers, skip_layers, + Conv2dSame, ) from ._image.inception5h_classes import INCEPTION5H_CLASSES # noqa: F401 from ._image.inception_v1 import InceptionV1, googlenet # noqa: F401 @@ -18,6 +19,7 @@ ) __all__ = [ + "Conv2dSame", "MaxPool2dRelaxed", "RedirectedReluLayer", "SkipLayer", From 027038381e18c68cd4838039448290de472f1864 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 20 Jun 2022 20:05:05 -0600 Subject: [PATCH 042/174] Fix doc formatting for Sphinx --- captum/optim/_utils/image/atlas.py | 2 ++ captum/optim/_utils/image/common.py | 7 +++++++ captum/optim/_utils/reducer.py | 6 ++++++ captum/optim/models/_common.py | 17 +++++++++++++---- 4 files changed, 28 insertions(+), 4 deletions(-) diff --git a/captum/optim/_utils/image/atlas.py b/captum/optim/_utils/image/atlas.py index 5954a3a471..dd68bccc64 100644 --- a/captum/optim/_utils/image/atlas.py +++ b/captum/optim/_utils/image/atlas.py @@ -78,6 +78,7 @@ def calc_grid_indices( ] Args: + xy_grid (torch.tensor): The xy coordinate grid activation samples, with a shape of: [n_points, 2]. grid_size (Tuple[int, int]): The grid_size of grid cells to use. The grid_size @@ -86,6 +87,7 @@ def calc_grid_indices( Default: (0.0, 1.0) y_extent (Tuple[float, float], optional): The y axis range to use. Default: (0.0, 1.0) + Returns: indices (list of list of torch.Tensors): List of lists of grid indices stored inside tensors to use. Each 1D tensor of indices has a size of: diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index 39a6ada5ea..77da453678 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -208,6 +208,7 @@ def _dot_cossim( a specified dimension. Args: + x (torch.Tensor): The tensor that you wish to compute the cosine similarity for in relation to tensor y. y (torch.Tensor): The tensor that you wish to compute the cosine similarity @@ -216,6 +217,7 @@ def _dot_cossim( dim (int, optional): The target dimension for computing cosine similarity. eps (float, optional): If cossim_pow is greater than zero, the desired epsilon value to use for cosine similarity calculations. + Returns: tensor (torch.Tensor): Dot cosine similarity between x and y, along the specified dim. @@ -241,13 +243,16 @@ def hue_to_rgb( ) -> torch.Tensor: """ Create an RGB unit vector based on a hue of the input angle. + Args: + angle (float): The hue angle to create an RGB color for. device (torch.device, optional): The device to create the angle color tensor on. Default: torch.device("cpu") warp (bool, optional): Whether or not to make colors more distinguishable. Default: True + Returns: color_vec (torch.Tensor): A color vector. """ @@ -293,6 +298,7 @@ def nchannels_to_rgb( Default: True eps (float, optional): An optional epsilon value. Default: 1e-4 + Returns: tensor (torch.Tensor): An NCHW RGB image tensor. """ @@ -326,6 +332,7 @@ def weights_to_heatmap_2d( no excitation or inhibition. Args: + weight (torch.Tensor): A 2d tensor to create the heatmap from. colors (list of str): A list of 5 strings containing hex triplet (six digit), three-byte hexadecimal color values to use for coloring diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index 2696d003d6..585d0157e0 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -22,6 +22,7 @@ class ChannelReducer: See here for more information: https://distill.pub/2018/building-blocks/ Args: + n_components (int, optional): The number of channels to reduce the target dimension to. reduction_alg (str or callable, optional): The desired dimensionality @@ -71,11 +72,14 @@ def fit_transform( ) -> torch.Tensor: """ Perform dimensionality reduction on an input tensor. + Args: + tensor (tensor): A tensor to perform dimensionality reduction on. swap_2nd_and_last_dims (bool, optional): If true, input channels are expected to be in the second dimension unless the input tensor has a shape of CHW. Default is set to True. + Returns: *tensor*: A tensor with one of it's dimensions reduced. """ @@ -131,8 +135,10 @@ def posneg(x: torch.Tensor, dim: int = 0) -> torch.Tensor: NMF with regular NMF. Args: + x (tensor): A tensor to make positive. dim (int, optional): The dimension to concatinate the two tensor halves at. + Returns: tensor (torch.tensor): A positive tensor for one-sided dimensionality reduction. diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index e65e281217..2e4352738b 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -112,13 +112,16 @@ def _transfer_layer_vars( """ Given a layer instance, create a new layer instance of another class with the same initialization variables as the original layer. + Args: + layer1: (nn.Module): A layer instance that you want to transfer initialization variables from. layer2: (nn.Module): The layer class to create with the variables from of layer1. kwargs: (Any, optional): Any additional variables to use when creating the new layer. + Returns: layer2 instance (nn.Module): An instance of layer2 with the initialization variables that it shares with layer1, and any specified additional @@ -273,13 +276,15 @@ class SkipLayer(torch.nn.Module): See nn.Identity for more details: https://pytorch.org/docs/stable/generated/torch.nn.Identity.html - - Args: - args (Any): Any argument. Arguments will be safely ignored. - kwargs (Any) Any keyword argument. Arguments will be safely ignored. """ def __init__(self, *args, **kwargs) -> None: + """ + Args: + + args (Any): Any argument. Arguments will be safely ignored. + kwargs (Any) Any keyword argument. Arguments will be safely ignored. + """ super().__init__() def forward( @@ -287,9 +292,11 @@ def forward( ) -> Union[torch.Tensor, Tuple[torch.Tensor]]: """ Args: + x (torch.Tensor or tuple of torch.Tensor): The input tensor or tensors. args (Any): Any argument. Arguments will be safely ignored. kwargs (Any) Any keyword argument. Arguments will be safely ignored. + Returns: x (torch.Tensor or tuple of torch.Tensor): The unmodified input tensor or tensors. @@ -306,7 +313,9 @@ def skip_layers( with layers that do nothing. This is useful for removing the nonlinear ReLU layers when creating expanded weights. + Args: + model (nn.Module): A PyTorch model instance. layers (nn.Module or list of nn.Module): The layer class type to replace in the model. From 73eedd11468ce8a50d2a5e34c9ce0d9b0da93563 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 23 Jun 2022 08:59:12 -0600 Subject: [PATCH 043/174] Fix docs for Sphinx --- captum/optim/_core/optimization.py | 21 ++++++++++++++++++- captum/optim/models/_common.py | 9 ++++---- .../models/_image/inception_v1_places365.py | 4 ++++ 3 files changed, 28 insertions(+), 6 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index cd11db9e34..ae5a78e652 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -35,6 +35,18 @@ class InputOptimization(Objective, Parameterized): For more details, see the following: https://github.com/tensorflow/lucid https://distill.pub/2017/feature-visualization/ + + Instance variables that be used in the optimize function and StopCriteria: + + :ivar model: initial value (nn.Module): The given model instance given when + initializing InputOptimization. + :ivar input_param: initial value (ImageParameterization): The given image + parameterization instance given when initializing InputOptimization. + :ivar loss_fn: initial value (Loss): The given composable loss instance given + when initializing InputOptimization. + :ivar transform: initial value (nn.Module): The given transform instance given + when initializing InputOptimization. If it was set to None during + initialization, then an instance of torch.nn.Identity will be returned. """ def __init__( @@ -95,7 +107,9 @@ def loss(self) -> torch.Tensor: return loss_value def cleanup(self) -> None: - r"""Garbage collection, mainly removing hooks.""" + r"""Garbage collection, mainly removing hooks. + This should only be run after optimize is finished running. + """ self.hooks.remove_hooks() # Targets are managed by ModuleOutputHooks; we mainly just want a convenient setter @@ -109,6 +123,11 @@ def targets(self, value: Iterable[nn.Module]) -> None: self.hooks = ModuleOutputsHook(value) def parameters(self) -> Iterable[nn.Parameter]: + """ + Returns: + parameters (iterable of nn.Parameter): An iterable of parameters in the + image parameterization. + """ return self.input_param.parameters() def optimize( diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 2e4352738b..c9af0dc73f 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -147,8 +147,7 @@ def _transfer_layer_vars( class Conv2dSame(nn.Conv2d): """ Tensorflow like 'SAME' convolution wrapper for 2D convolutions. - TODO: Replace with torch.nn.Conv2d when support for padding='same' - is in stable version + torch.nn.Conv2d with padding='same' can be used when the stride is equal to 1. """ def __init__( @@ -190,7 +189,7 @@ def __init__( in_channels, out_channels, kernel_size, stride, 0, dilation, groups, bias ) - def calc_same_pad(self, i: int, k: int, s: int, d: int) -> int: + def _calc_same_pad(self, i: int, k: int, s: int, d: int) -> int: """ Calculate the required padding for a dimension. @@ -217,8 +216,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: """ ih, iw = x.size()[-2:] kh, kw = self.weight.size()[-2:] - pad_h = self.calc_same_pad(i=ih, k=kh, s=self.stride[0], d=self.dilation[0]) - pad_w = self.calc_same_pad(i=iw, k=kw, s=self.stride[1], d=self.dilation[1]) + pad_h = self._calc_same_pad(i=ih, k=kh, s=self.stride[0], d=self.dilation[0]) + pad_w = self._calc_same_pad(i=iw, k=kw, s=self.stride[1], d=self.dilation[1]) if pad_h > 0 or pad_w > 0: x = F.pad( diff --git a/captum/optim/models/_image/inception_v1_places365.py b/captum/optim/models/_image/inception_v1_places365.py index 5ebca2a9b5..85afc7b32d 100644 --- a/captum/optim/models/_image/inception_v1_places365.py +++ b/captum/optim/models/_image/inception_v1_places365.py @@ -24,6 +24,7 @@ def googlenet_places365( dataset. See here for more information: https://arxiv.org/abs/1610.02055 Args: + pretrained (bool, optional): If True, returns a model pre-trained on the MIT Places365 Standard dataset. Default: False @@ -47,6 +48,9 @@ def googlenet_places365( transform_input (bool, optional): If True, preprocesses the input according to the method with which it was trained on Places365. Default: True + + Returns: + **model** (InceptionV1Places365): An InceptionV1 Places365 model instance. """ if pretrained: From c45f6944995c33612995793ad612e53045941736 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 23 Jun 2022 11:37:01 -0600 Subject: [PATCH 044/174] Minor fixes --- captum/optim/_core/optimization.py | 4 +-- tests/optim/core/test_optimization.py | 46 +++++++++++++++++++++++++++ 2 files changed, 48 insertions(+), 2 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index ae5a78e652..68310087f6 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -42,8 +42,8 @@ class InputOptimization(Objective, Parameterized): initializing InputOptimization. :ivar input_param: initial value (ImageParameterization): The given image parameterization instance given when initializing InputOptimization. - :ivar loss_fn: initial value (Loss): The given composable loss instance given - when initializing InputOptimization. + :ivar loss_function: initial value (Loss): The given composable loss instance + given when initializing InputOptimization. :ivar transform: initial value (nn.Module): The given transform instance given when initializing InputOptimization. If it was set to None during initialization, then an instance of torch.nn.Identity will be returned. diff --git a/tests/optim/core/test_optimization.py b/tests/optim/core/test_optimization.py index 7f77cf4b4d..c0def7ffef 100644 --- a/tests/optim/core/test_optimization.py +++ b/tests/optim/core/test_optimization.py @@ -9,6 +9,52 @@ class TestInputOptimization(BaseTest): + def test_input_optimization_init(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping InputOptimization init test due to insufficient Torch" + + " version." + ) + model = BasicModel_ConvNet_Optim() + loss_fn = opt.loss.ChannelActivation(model.layer, 1) + transform = torch.nn.Identity() + image_param = opt.images.NaturalImage() + obj = opt.InputOptimization( + model, loss_function=loss_fn, input_param=image_param, transform=transform + ) + + self.assertEqual(model, obj.model) + self.assertEqual(image_param, obj.input_param) + self.assertEqual(transform, obj.transform) + self.assertEqual(loss_fn, obj.loss_function) + self.assertEqual(list(image_param.parameters()), list(obj.parameters())) + + def test_input_optimization_custom_optimize(self) -> torch.Tensor: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping InputOptimization custom optimze test due to insufficient" + + " Torch version." + ) + model = BasicModel_ConvNet_Optim() + loss_fn = opt.loss.ChannelActivation(model.layer, 0) + obj = opt.InputOptimization(model, loss_function=loss_fn) + + stop_criteria = opt.optimization.n_steps(512) + optimizer = torch.optim.Adam(obj.parameters(), lr=0.02) + + history, step = [], 0 + try: + while stop_criteria(step, obj, history, optimizer): + optimizer.zero_grad() + loss_value = -1.0 * obj.loss().mean() + history.append(loss_value.clone().detach()) + loss_value.backward() + optimizer.step() + step += 1 + finally: + obj.cleanup() + self.assertIsInstance(torch.stack(history), torch.Tensor) + def test_input_optimization(self) -> None: if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( From 650927e5543e8285ab9607a6f66d21d7b4b8ed53 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 23 Jun 2022 11:37:35 -0600 Subject: [PATCH 045/174] Add missing input_param attribute to InputOptimization info --- tutorials/optimviz/CustomModules_OptimViz.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/tutorials/optimviz/CustomModules_OptimViz.ipynb b/tutorials/optimviz/CustomModules_OptimViz.ipynb index ae556a1b0b..0bfe58ce15 100644 --- a/tutorials/optimviz/CustomModules_OptimViz.ipynb +++ b/tutorials/optimviz/CustomModules_OptimViz.ipynb @@ -309,6 +309,7 @@ "* The `.parameters()` function returns the list of input parameters requiring grad.\n", "* The `.loss()` function returns the loss function values.\n", "* The `.cleanup()` function removes the hooks that were used to collect activations.\n", + "* The image parameterization being used can be accessed via `.input_param` attribute.\n", "* The model being used can be accessed via `.model` attribute.\n", "* The transforms being used can be accessed via `.transforms` attribute." ], From 4cf8cfc8033951a358d3759d8ab16437143c09d4 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 23 Jun 2022 12:07:00 -0600 Subject: [PATCH 046/174] Fix test errors --- tests/optim/core/test_optimization.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/optim/core/test_optimization.py b/tests/optim/core/test_optimization.py index c0def7ffef..e7b174e480 100644 --- a/tests/optim/core/test_optimization.py +++ b/tests/optim/core/test_optimization.py @@ -29,7 +29,7 @@ def test_input_optimization_init(self) -> None: self.assertEqual(loss_fn, obj.loss_function) self.assertEqual(list(image_param.parameters()), list(obj.parameters())) - def test_input_optimization_custom_optimize(self) -> torch.Tensor: + def test_input_optimization_custom_optimize(self) -> None: if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( "Skipping InputOptimization custom optimze test due to insufficient" @@ -39,7 +39,7 @@ def test_input_optimization_custom_optimize(self) -> torch.Tensor: loss_fn = opt.loss.ChannelActivation(model.layer, 0) obj = opt.InputOptimization(model, loss_function=loss_fn) - stop_criteria = opt.optimization.n_steps(512) + stop_criteria = opt.optimization.n_steps(512, show_progress=False) optimizer = torch.optim.Adam(obj.parameters(), lr=0.02) history, step = [], 0 @@ -53,7 +53,8 @@ def test_input_optimization_custom_optimize(self) -> torch.Tensor: step += 1 finally: obj.cleanup() - self.assertIsInstance(torch.stack(history), torch.Tensor) + history = torch.stack(history) + self.assertIsInstance(history, torch.Tensor) def test_input_optimization(self) -> None: if version.parse(torch.__version__) <= version.parse("1.6.0"): From 90f9592c32a8d18197ee03264f019c5d98c80af7 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 23 Jun 2022 12:22:40 -0600 Subject: [PATCH 047/174] Fix mypy error --- tests/optim/core/test_optimization.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/optim/core/test_optimization.py b/tests/optim/core/test_optimization.py index e7b174e480..1cd3301a98 100644 --- a/tests/optim/core/test_optimization.py +++ b/tests/optim/core/test_optimization.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import unittest +from typing import List import captum.optim as opt import torch @@ -42,7 +43,8 @@ def test_input_optimization_custom_optimize(self) -> None: stop_criteria = opt.optimization.n_steps(512, show_progress=False) optimizer = torch.optim.Adam(obj.parameters(), lr=0.02) - history, step = [], 0 + history: List[torch.Tensor] = [] + step = 0 try: while stop_criteria(step, obj, history, optimizer): optimizer.zero_grad() From 7d77c7220620ad2c416ac30e6d8b24640397c5a8 Mon Sep 17 00:00:00 2001 From: Vivek Miglani Date: Thu, 23 Jun 2022 18:26:59 -0700 Subject: [PATCH 048/174] Add ODS Logging to Captum (#971) Summary: Pull Request resolved: https://github.com/pytorch/captum/pull/971 Reviewed By: NarineK Differential Revision: D37009629 fbshipit-source-id: 161a957ed56abfb734c9004fc8420e66ccde9d20 --- captum/log/__init__.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/captum/log/__init__.py b/captum/log/__init__.py index 8c0b7472ad..93a5e471fb 100644 --- a/captum/log/__init__.py +++ b/captum/log/__init__.py @@ -2,6 +2,7 @@ try: from captum.log.fb.internal_log import ( + disable_detailed_logging, log, log_usage, patch_methods, @@ -9,7 +10,13 @@ TimedLog, ) - __all__ = ["log", "log_usage", "TimedLog", "set_environment"] + __all__ = [ + "log", + "log_usage", + "TimedLog", + "set_environment", + "disable_detailed_logging", + ] except ImportError: from functools import wraps @@ -41,5 +48,8 @@ def wrapper(*args, **kwargs): def set_environment(env): pass + def disable_detailed_logging(): + pass + def patch_methods(tester, patch_log=True): pass From 5e3a80fa76a5d91f015776bcb60f9615494ef946 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 24 Jun 2022 13:30:27 -0600 Subject: [PATCH 049/174] Add docs for loss_fn in sum_loss_list --- captum/optim/_core/loss.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index fa0808a981..f4cb3a6d89 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -1076,6 +1076,20 @@ def sum_loss_list( """ def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: + """ + Pass collected activations through the list of loss objectives based on + specified targets, and then apply a reduction op to reduce them to scalar + before adding them together. + + Args: + + module (ModuleOutputMapping): A dict of captured activations with + nn.Modules as keys. + + Returns: + loss (torch.Tensor): The target activations after being run through the + loss objectives, and then added together. + """ return sum([to_scalar_fn(loss(module)) for loss in loss_list]) name = "Sum(" + ", ".join([loss.__name__ for loss in loss_list]) + ")" From 613baa99a92bb5d3824715ea44bb52a9ec83db0c Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 25 Jun 2022 09:22:42 -0600 Subject: [PATCH 050/174] Add docs for loss testing helper --- tests/optim/core/test_loss.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 0ba3651175..9fc8f67be9 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -19,6 +19,21 @@ def get_loss_value( loss: opt_loss.Loss, model_input: Union[List[int], torch.Tensor] = [1, 3, 1, 1], ) -> torch.Tensor: + """ + Collect target activations and pass them through a composable loss instance. + + Args: + + model (nn.Module): A PyTorch model instance. + loss (Loss): A composable loss instance that uses targets from the provided + model instance. + model_input (list of int or torch.Tensor): A list of integers to use for the + shape of the model input, or a tensor to use as the model input. + Default: [1, 3, 1, 1] + + Returns: + loss (torch.Tensor): The target activations run through the loss objectives. + """ if isinstance(model_input, (list, tuple)): model_input = torch.ones(*model_input) else: From 6f41b207e4bd0f27657b3ecffd3526ba66d96a55 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 25 Jun 2022 17:22:38 -0600 Subject: [PATCH 051/174] Remove loss_wrapper requirement for loss objectives --- captum/optim/_core/loss.py | 1 + tests/optim/core/test_loss.py | 3 +++ 2 files changed, 4 insertions(+) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 1365537c19..2857ff7e7a 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -24,6 +24,7 @@ class Loss(ABC): def __init__(self) -> None: super(Loss, self).__init__() + self.__name__ = self.__class__.__name__ @abstractproperty def target(self) -> Union[nn.Module, List[nn.Module]]: diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 9fc8f67be9..cbf99912d0 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -532,6 +532,7 @@ def test_loss_init(self) -> None: with _OverrideAbstractFunctions(opt_loss.Loss): loss = opt_loss.Loss() # type: ignore self.assertIsNone(loss.target) + self.assertEqual(loss.__name__, "Loss") self.assertEqual(opt_loss.Loss.__name__, "Loss") @@ -547,6 +548,8 @@ def test_base_loss_init(self) -> None: self.assertEqual(loss.batch_index, (None, None)) self.assertEqual(loss._target, model) self.assertEqual(loss.target, model) + self.assertEqual(loss.__name__, "BaseLoss") + self.assertEqual(opt_loss.BaseLoss.__name__, "BaseLoss") def test_base_loss_batch_index(self) -> None: model = torch.nn.Identity() From 5f849aa4d1dd9ba9dd6cc367be0a70b8e759e8f4 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 26 Jun 2022 11:57:56 -0600 Subject: [PATCH 052/174] Fix Sphinx loss doc duplication bug --- captum/optim/_core/loss.py | 102 ++++++++++++++++++++++++------------- 1 file changed, 67 insertions(+), 35 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index f4cb3a6d89..4657b23f8c 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -303,17 +303,25 @@ class LayerActivation(BaseLoss): Maximize activations at the target layer. This is the most basic loss available and it simply returns the activations in their original form. + """ - Args: + def __init__( + self, + target: nn.Module, + batch_index: Optional[Union[int, List[int]]] = None, + ) -> None: + """ + Args: - target (nn.Module): A target layer, transform, or image parameterization - instance to optimize the output of. - batch_index (int or list of int, optional): The index or index range of - activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None - """ + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set + to None, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: None + """ + BaseLoss.__init__(self, target, batch_index) def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] @@ -430,17 +438,25 @@ class DeepDream(BaseLoss): This loss returns the squared layer activations. When combined with a negative mean loss summarization, this loss will create hallucinogenic visuals commonly referred to as 'Deep Dream'. + """ - Args: + def __init__( + self, + target: nn.Module, + batch_index: Optional[Union[int, List[int]]] = None, + ) -> None: + """ + Args: - target (nn.Module): A target layer, transform, or image parameterization - instance to optimize the output of. - batch_index (int or list of int, optional): The index or index range of - activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None - """ + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set + to None, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: None + """ + BaseLoss.__init__(self, target, batch_index) def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] @@ -457,17 +473,25 @@ class TotalVariation(BaseLoss): This loss attempts to smooth / denoise the target by performing total variance denoising. The target is most often the image that’s being optimized. This loss is often used to remove unwanted visual artifacts. + """ - Args: + def __init__( + self, + target: nn.Module, + batch_index: Optional[Union[int, List[int]]] = None, + ) -> None: + """ + Args: - target (nn.Module): A target layer, transform, or image parameterization - instance to optimize the output of. - batch_index (int or list of int, optional): The index or index range of - activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None - """ + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (int or list of int, optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set + to None, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: None + """ + BaseLoss.__init__(self, target, batch_index) def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] @@ -559,16 +583,24 @@ class Diversity(BaseLoss): This loss helps break up polysemantic layers, channels, and neurons by encouraging diversity across the different batches. This loss is to be used along with a main loss. + """ - Args: + def __init__( + self, + target: nn.Module, + batch_index: Optional[List[int]] = None, + ) -> None: + """ + Args: - target (nn.Module): A target layer, transform, or image parameterization - instance to optimize the output of. - batch_index (list of int, optional): The index range of activations to - optimize. If set to None, defaults to all activations in the batch. Index - ranges should be in the format of: [start, end]. - Default: None - """ + target (nn.Module): A target layer, transform, or image parameterization + instance to optimize the output of. + batch_index (list of int, optional): The index range of activations to + optimize. If set to None, defaults to all activations in the batch. + Index ranges should be in the format of: [start, end]. + Default: None + """ + BaseLoss.__init__(self, target, batch_index) def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] From ca3b5f970242de43c5d7569ae599883150c8d69d Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 27 Jun 2022 13:23:40 -0600 Subject: [PATCH 053/174] Update _common.py --- captum/optim/models/_common.py | 36 ++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index c9af0dc73f..d0a1d81208 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -87,10 +87,11 @@ def replace_layers( layer1: (Type[nn.Module]): The layer class that you want to transfer initialization variables from. layer2: (Type[nn.Module]): The layer class to create with the variables - from layer1. - transfer_vars (bool, optional): Wether or not to try and copy - initialization variables from layer1 instances to the replacement - layer2 instances. + from ``layer1``. + transfer_vars (bool, optional): Whether or not to try and copy + initialization variables from ``layer1`` instances to the replacement + ``layer2`` instances. + Default: ``False`` kwargs: (Any, optional): Any additional variables to use when creating the new layer. """ @@ -172,18 +173,19 @@ def __init__( kernel_size (int or tuple of int): The desired kernel size to use. stride (int or tuple of int, optional): The desired stride for the cross-correlation. - Default: 1 + Default: ``1`` padding (int or tuple of int, optional): This value is always set to 0. - Default: 0 + Default: ``0`` dilation (int or tuple of int, optional): The desired spacing between the kernel points. - Default: 1 + Default: ``1`` groups (int, optional): Number of blocked connections from input channels to output channels. Both in_channels and out_channels must be divisable by groups. - Default: 1 + Default: ``1`` bias (bool, optional): Whether or not to apply a learnable bias to the output. + Default: ``True`` """ super().__init__( in_channels, out_channels, kernel_size, stride, 0, dilation, groups, bias @@ -249,7 +251,7 @@ def collect_activations( given model. model_input (torch.Tensor or tuple of torch.Tensor, optional): Optionally provide an input tensor to use when collecting the target activations. - Default: torch.zeros(1, 3, 224, 224) + Default: ``torch.zeros(1, 3, 224, 224)`` Returns: activ_dict (ModuleOutputMapping): A dictionary of collected activations where @@ -269,9 +271,9 @@ class SkipLayer(torch.nn.Module): during the forward pass. Use cases include removing nonlinear activation layers like ReLU for circuits research. - This layer works almost exactly the same way that nn.Indentiy does, except it also - ignores any additional arguments passed to the forward function. Any layer replaced - by SkipLayer must have the same input and output shapes. + This layer works almost exactly the same way that ``nn.Indentiy`` does, except it + also ignores any additional arguments passed to the forward function. Any layer + replaced by ``SkipLayer`` must have the same input and output shapes. See nn.Identity for more details: https://pytorch.org/docs/stable/generated/torch.nn.Identity.html @@ -365,15 +367,15 @@ def __init__( Args: kernel_size (int or tuple of int): The size of the window to perform max & - average pooling with. + average pooling with. stride (int or tuple of int, optional): The stride window size to use. - Default: None + Default: ``None`` padding (int or tuple of int): The amount of zero padding to add to both - sides in the nn.MaxPool2d & nn.AvgPool2d modules. - Default: 0 + sides in the ``nn.MaxPool2d`` & ``nn.AvgPool2d`` modules. + Default: ``0`` ceil_mode (bool, optional): Whether to use ceil or floor for creating the output shape. - Default: False + Default: ``False`` """ super().__init__() self.maxpool = torch.nn.MaxPool2d( From e87c975531532f8e5dd1bf55d10612b3814369c8 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 27 Jun 2022 15:19:09 -0600 Subject: [PATCH 054/174] Improve ImageTensor, Optimization, & submodule docs for Sphinx --- captum/optim/_core/optimization.py | 47 +++++++---- captum/optim/_param/image/images.py | 81 ++++++++++++------- captum/optim/_utils/image/dataset.py | 28 ++++--- .../models/_image/inception_v1_places365.py | 79 +++++++++--------- 4 files changed, 141 insertions(+), 94 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 68310087f6..4072b0f987 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -36,17 +36,29 @@ class InputOptimization(Objective, Parameterized): https://github.com/tensorflow/lucid https://distill.pub/2017/feature-visualization/ - Instance variables that be used in the optimize function and StopCriteria: + Example:: + + >>> model = opt.models.googlenet(pretrained=True) + >>> loss_fn = opt.loss.LayerActivation(model.mixed4c) + >>> image = opt.images.NaturalImage(size=(224, 224)) + >>> transform = opt.transforms.TransformationRobustness() + >>> + >>> obj = opt.InputOptimization(model, loss_fn, image, transform) + >>> history = obj.optimize(opt.optimization.n_steps(512)) + >>> image().show(figsize=(10, 10)) # Display results + + Instance variables that be used in the optimize function and StopCriteria + functions: :ivar model: initial value (nn.Module): The given model instance given when - initializing InputOptimization. + initializing ``InputOptimization``. :ivar input_param: initial value (ImageParameterization): The given image - parameterization instance given when initializing InputOptimization. + parameterization instance given when initializing ``InputOptimization``. :ivar loss_function: initial value (Loss): The given composable loss instance - given when initializing InputOptimization. + given when initializing ``InputOptimization``. :ivar transform: initial value (nn.Module): The given transform instance given - when initializing InputOptimization. If it was set to None during - initialization, then an instance of torch.nn.Identity will be returned. + when initializing ``InputOptimization``. If it was set to ``None`` during + initialization, then an instance of ``torch.nn.Identity`` will be returned. """ def __init__( @@ -142,17 +154,17 @@ def optimize( Args: stop_criteria (StopCriteria, optional): A function that is called - every iteration and returns a bool that determines whether - to stop the optimization. - See captum.optim.typing.StopCriteria for details. - optimizer (Optimizer, optional): An torch.optim.Optimizer used to - optimize the input based on the loss function. + every iteration and returns a bool that determines whether to stop the + optimization. + Default: ``n_steps(512)`` + optimizer (Optimizer, optional): An ``torch.optim.Optimizer`` used to + optimize the input based on the loss function. loss_summarize_fn (Callable, optional): The function to use for summarizing tensor outputs from loss functions. - Default: default_loss_summarize + Default: ``default_loss_summarize`` lr: (float, optional): If no optimizer is given, then lr is used as the learning rate for the Adam optimizer. - Default: 0.025 + Default: ``0.025`` Returns: history (torch.Tensor): A stack of loss values per iteration. The size @@ -182,13 +194,18 @@ def optimize( def n_steps(n: int, show_progress: bool = True) -> StopCriteria: """StopCriteria generator that uses number of steps as a stop criteria. + Example:: + + >>> stop_criteria = opt.optimization.n_steps(512, True) + Args: + n (int): Number of steps to run optimization. show_progress (bool, optional): Whether or not to show progress bar. - Default: True + Default: ``True`` Returns: - *StopCriteria* callable + *StopCriteria* (callable): A stop criteria function. """ if show_progress: diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index e4c4c05210..64400f24ff 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -21,6 +21,27 @@ class ImageTensor(torch.Tensor): + r""" + A subclass of torch.Tensor that provides functions for easy loading, saving, and + displaying image tensors. + + Example using file path or URL:: + + >>> image_tensor = opt.images.ImageTensor.load() + >>> image_tensor.export(filename="image_tensor.jpg") # Save image(s) + >>> image_tensor.show(figsize=(8, 8)) # Displays image(s) via Matplotlib + + Example using ``torch.Tensor``:: + + >>> image_tensor = torch.randn(1, 3, 224, 224) + >>> image_tensor = opt.images.ImageTensor(image_tensor) + + Example using ``np.ndarray``:: + + >>> image_tensor = np.random.rand(1, 3, 224, 224) + >>> image_tensor = opt.images.ImageTensor(image_tensor) + """ + @staticmethod def __new__( cls: Type["ImageTensor"], @@ -32,10 +53,10 @@ def __new__( Args: x (list or np.ndarray or torch.Tensor): A list, NumPy array, or PyTorch - tensor to create an `ImageTensor` from. + tensor to create an ``ImageTensor`` from. Returns: - x (ImageTensor): An `ImageTensor` instance. + x (ImageTensor): An ``ImageTensor`` instance. """ if isinstance(x, torch.Tensor) and x.is_cuda: x.show = MethodType(cls.show, x) @@ -45,17 +66,18 @@ def __new__( return super().__new__(cls, x, *args, **kwargs) @classmethod - def open(cls, path: str, scale: float = 255.0, mode: str = "RGB") -> "ImageTensor": + def load(cls, path: str, scale: float = 255.0, mode: str = "RGB") -> "ImageTensor": """ - Load an image file from a URL or local filepath directly into an `ImageTensor`. + Load an image file from a URL or local filepath directly into an + ``ImageTensor``. Args: path (str): A URL or filepath to an image. scale (float, optional): The image scale to use. - Default: 255.0 + Default: ``255.0`` mode (str, optional): The image loading mode / colorspace to use. - Default: "RGB" + Default: ``"RGB"`` Returns: x (ImageTensor): An `ImageTensor` instance. @@ -70,9 +92,9 @@ def open(cls, path: str, scale: float = 255.0, mode: str = "RGB") -> "ImageTenso return cls(img_np.transpose(2, 0, 1) / scale) @classmethod - def load(cls, path: str, scale: float = 255.0, mode: str = "RGB") -> "ImageTensor": - """Alias of ImageTensor.open()""" - return cls.open(path=path, scale=scale, mode=mode) + def open(cls, path: str, scale: float = 255.0, mode: str = "RGB") -> "ImageTensor": + r"""Alias for :func:`load`.""" + return cls.load(path=path, scale=scale, mode=mode) def __repr__(self) -> str: prefix = "ImageTensor(" @@ -109,25 +131,25 @@ def show( pad_value: float = 0.0, ) -> None: """ - Display an `ImageTensor`. + Display an ``ImageTensor`` instance. Args: figsize (Tuple[int, int], optional): height & width to use - for displaying the `ImageTensor` figure. - scale (float, optional): Value to multiply the `ImageTensor` by so that + for displaying the ``ImageTensor`` figure. + scale (float, optional): Value to multiply the ``ImageTensor`` by so that it's value range is [0-255] for display. - Default: 255.0 + Default: ``255.0`` images_per_row (int, optional): The number of images per row to use for the - grid image. Default is set to None for no grid image creation. - Default: None + grid image. Default is set to ``None`` for no grid image creation. + Default: ``None`` padding (int, optional): The amount of padding between images in the grid - images. This parameter only has an effect if `images_per_row` is not - None. - Default: 2 + images. This parameter only has an effect if ``images_per_row`` is not + ``None``. + Default: ``2`` pad_value (float, optional): The value to use for the padding. This - parameter only has an effect if `images_per_row` is not None. - Default: 0.0 + parameter only has an effect if ``images_per_row`` is not None. + Default: ``0.0`` """ show( self, @@ -152,23 +174,24 @@ def export( Args: - filename (str): The filename to use when saving the `ImageTensor` as an + filename (str): The filename to use when saving the ``ImageTensor`` as an image file. - scale (float, optional): Value to multiply the `ImageTensor` by so that + scale (float, optional): Value to multiply the ``ImageTensor`` by so that it's value range is [0-255] for saving. - Default: 255.0 + Default: ``255.0`` mode (str, optional): A PIL / Pillow supported colorspace. Default is set to None for automatic RGB / RGBA detection and usage. - Default: None + Default: ``None`` images_per_row (int, optional): The number of images per row to use for the grid image. Default is set to None for no grid image creation. - Default: None + Default: ``None`` padding (int, optional): The amount of padding between images in the grid - images. This parameter only has an effect if `images_per_row` is not - None. + images. This parameter only has an effect if ``images_per_row`` is not + ``None``. + Default: ``2`` pad_value (float, optional): The value to use for the padding. This - parameter only has an effect if `images_per_row` is not None. - Default: 0.0 + parameter only has an effect if ``images_per_row`` is not ``None``. + Default: ``0.0`` """ save_tensor_as_image( self, diff --git a/captum/optim/_utils/image/dataset.py b/captum/optim/_utils/image/dataset.py index 66bf18b53a..66eee6dc38 100644 --- a/captum/optim/_utils/image/dataset.py +++ b/captum/optim/_utils/image/dataset.py @@ -19,11 +19,11 @@ def image_cov(x: torch.Tensor) -> torch.Tensor: Args: - x (torch.Tensor): One or more NCHW image tensors stacked across the batch + x (torch.Tensor): One or more NCHW image tensors stacked across the batch dimension. Returns: - *tensor* (torch.Tensor): The average color channel covariance matrix for the + *tensor* (torch.Tensor): The average color channel covariance matrix for the for the input tensor, with a shape of: [n_channels, n_channels]. """ @@ -47,10 +47,10 @@ def dataset_cov_matrix( loader (torch.utils.data.DataLoader): The reference to a PyTorch dataloader instance. show_progress (bool, optional): Whether or not to display a tqdm progress bar. - Default: False + Default: ``False`` device (torch.device, optional): The PyTorch device to use for for calculating the cov matrix. - Default: torch.device("cpu") + Default: ``torch.device("cpu")`` Returns: *tensor*: A covariance matrix for the specified dataset. @@ -91,10 +91,12 @@ def cov_matrix_to_klt( Args: - cov_mtx (tensor): A 3 by 3 covariance matrix generated from a dataset. - normalize (bool): Whether or not to normalize the resulting KLT matrix. - Default: False - epsilon (float): + cov_mtx (tensor): A 3 by 3 covariance matrix generated from a dataset. + normalize (bool): Whether or not to normalize the resulting KLT matrix. + Default: ``False`` + epsilon (float, optional): A small epsilon value to use for numerical + stability. + Default: ``1e-10`` Returns: *tensor*: A KLT matrix for the specified covariance matrix. @@ -121,15 +123,15 @@ def dataset_klt_matrix( Args: - loader (torch.utils.data.DataLoader): The reference to a PyTorch + loader (torch.utils.data.DataLoader): The reference to a PyTorch dataloader instance. - normalize (bool): Whether or not to normalize the resulting KLT matrix. - Default: False + normalize (bool): Whether or not to normalize the resulting KLT matrix. + Default: ``False`` show_progress (bool, optional): Whether or not to display a tqdm progress bar. - Default: False + Default: ``False`` device (torch.device, optional): The PyTorch device to use for for calculating the cov matrix. - Default: torch.device("cpu") + Default: ``torch.device("cpu")`` Returns: *tensor*: A KLT matrix for the specified dataset. diff --git a/captum/optim/models/_image/inception_v1_places365.py b/captum/optim/models/_image/inception_v1_places365.py index 85afc7b32d..acd5f8fe7f 100644 --- a/captum/optim/models/_image/inception_v1_places365.py +++ b/captum/optim/models/_image/inception_v1_places365.py @@ -23,31 +23,36 @@ def googlenet_places365( The pretrained GoogleNet model was trained using the MIT Places365 Standard dataset. See here for more information: https://arxiv.org/abs/1610.02055 + Example:: + + >>> model = opt.models.googlenet_places365(pretrained=True) + >>> output = model(torch.zeros(1, 3, 224, 224)) + Args: - pretrained (bool, optional): If True, returns a model pre-trained on the MIT - Places365 Standard dataset. - Default: False - progress (bool, optional): If True, displays a progress bar of the download to - stderr - Default: True - model_path (str, optional): Optional path for InceptionV1 model file. - Default: None - replace_relus_with_redirectedrelu (bool, optional): If True, return pretrained - model with Redirected ReLU in place of ReLU layers. - Default: *True* when pretrained is True otherwise *False* - use_linear_modules_only (bool, optional): If True, return pretrained + pretrained (bool, optional): If ``True``, returns a model pre-trained on the + MIT Places365 Standard dataset. + Default: ``False`` + progress (bool, optional): If ``True``, displays a progress bar of the + download to stderr. + Default: ``True`` + model_path (str, optional): Optional path for the InceptionV1 model file. + Default: ``None`` + replace_relus_with_redirectedrelu (bool, optional): If ``True``, return + pretrained model with Redirected ReLU in place of ReLU layers. + Default: *``True``* when pretrained is True otherwise *``False``* + use_linear_modules_only (bool, optional): If ``True``, return pretrained model with all nonlinear layers replaced with linear equivalents. - Default: False - aux_logits (bool, optional): If True, adds two auxiliary branches that can + Default: ``False`` + aux_logits (bool, optional): If ``True``, adds two auxiliary branches that can improve training. - Default: True + Default: ``True`` out_features (int, optional): Number of output features in the model used for - training. Default: 365 when pretrained is True. - Default: 365 + training. + Default: ``365`` transform_input (bool, optional): If True, preprocesses the input according to the method with which it was trained on Places365. - Default: True + Default: ``True`` Returns: **model** (InceptionV1Places365): An InceptionV1 Places365 model instance. @@ -99,19 +104,19 @@ def __init__( out_features (int, optional): Number of output features in the model used for training. - Default: 365 - aux_logits (bool, optional): If True, adds two auxiliary branches that can - improve training. - Default: True - transform_input (bool, optional): If True, preprocesses the input according - to the method with which it was trained on Places365. - Default: True - replace_relus_with_redirectedrelu (bool, optional): If True, return + Default: ``365`` + aux_logits (bool, optional): If ``True``, adds two auxiliary branches that + can improve training. + Default: ``True`` + transform_input (bool, optional): If ``True``, preprocesses the input + according to the method with which it was trained on Places365. + Default: ``True`` + replace_relus_with_redirectedrelu (bool, optional): If ``True``, return pretrained model with Redirected ReLU in place of ReLU layers. - Default: False - use_linear_modules_only (bool, optional): If True, return pretrained model - with all nonlinear layers replaced with linear equivalents. - Default: False + Default: ``False`` + use_linear_modules_only (bool, optional): If ``True``, return pretrained + model with all nonlinear layers replaced with linear equivalents. + Default: ``False`` """ super().__init__() self.aux_logits = aux_logits @@ -295,10 +300,10 @@ def __init__( pool_proj (int, optional): activ (type of nn.Module, optional): The nn.Module class type to use for activation layers. - Default: nn.ReLU + Default: ``nn.ReLU`` p_layer (type of nn.Module, optional): The nn.Module class type to use for pooling layers. - Default: nn.MaxPool2d + Default: ``nn.MaxPool2d`` """ super().__init__() self.conv_1x1 = nn.Conv2d( @@ -392,13 +397,13 @@ def __init__( in_channels (int, optional): The number of input channels to use for the auxiliary branch. - Default: 508 + Default: ``508`` out_features (int, optional): The number of output features to use for the auxiliary branch. - Default: 1008 - activ (type of nn.Module, optional): The nn.Module class type to use for - activation layers. - Default: nn.ReLU + Default: ``1008`` + activ (type of nn.Module, optional): The ``nn.Module`` class type to use + for activation layers. + Default: ``nn.ReLU`` """ super().__init__() self.avg_pool = nn.AdaptiveAvgPool2d((4, 4)) From 2b665f2a74c64097dc3e4d8ad6acfc74eeb5e7c0 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 27 Jun 2022 17:51:53 -0600 Subject: [PATCH 055/174] Improve CLIP loss docs for Sphinx --- captum/optim/_core/loss.py | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 04457aaa30..252f569921 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -865,14 +865,14 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance. channel_index (int, optional): Optionally only target a specific channel. - If set to None, all channels with be used. - Default: None + If set to ``None``, all channels with be used. + Default: ``None`` constant (float, optional): Constant value to deduct from the activations. - Default: 0.5 + Default: ``0.5`` batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to None, defaults to all + optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. - Default: None + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.constant = constant @@ -920,16 +920,16 @@ def __init__( channel / feature dimension of the target layer instance. activation_fn (Callable, optional): An optional activation function to apply to the activations before computing the matrix product. If set - to None, then no activation function will be used. - Default: torch.nn.functional.relu + to ``None``, then no activation function will be used. + Default: ``torch.nn.functional.relu`` move_channel_dim_to_final_dim (bool, optional): Whether or not to move the channel dimension to the last dimension before computing the matrix product. - Default: True + Default: ``True`` batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to None, defaults to all + optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. - Default: None + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) assert vec.dim() == 1 @@ -979,21 +979,22 @@ def __init__( visualizing targets from. This is normally the penultimate layer of the model. layer_target (nn.Module): A layer that we have facet_weights for. This - target layer should be below the ultimate_target layer in the model. + target layer should be below the ``ultimate_target`` layer in the + model. facet_weights (torch.Tensor): Weighting that steers the objective towards a particular theme or concept. These weight values should - come from linear probes trained on layer_target. + come from linear probes trained on ``layer_target``. strength (float, list of float, optional): A single float or list of floats to use for batch dimension weighting. If using a single value, then it will be applied to all batch dimensions equally. Otherwise a list of - floats with a shape of: [start, end] should be used for torch.linspace - to calculate the step values in between. Default is set to None for no - weighting. - Default: None + floats with a shape of: [start, end] should be used for + ``torch.linspace`` to calculate the step values in between. Default is + set to ``None`` for no weighting. + Default: ``None`` batch_index (int, optional): The index of the activations to optimize if - optimizing a batch of activations. If set to None, defaults to all + optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. - Default: None + Default: ``None`` """ BaseLoss.__init__(self, [ultimate_target, layer_target], batch_index) self.ultimate_target = ultimate_target From 5837745fae82c98a4267b7124cea535825821179 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 27 Jun 2022 17:56:19 -0600 Subject: [PATCH 056/174] Improve loss docs for Sphinx --- captum/optim/_core/loss.py | 240 ++++++++++++++++++++++++------------- 1 file changed, 160 insertions(+), 80 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 4657b23f8c..8a4a1a65b9 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -197,6 +197,10 @@ def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: class BaseLoss(Loss): + """ + The base class used for all Loss objectives. + """ + def __init__( self, target: Union[nn.Module, List[nn.Module]] = [], @@ -209,9 +213,9 @@ def __init__( nn.Module. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None + ``None``, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: ``None`` """ super().__init__() self._target = target @@ -244,6 +248,82 @@ def batch_index(self) -> Tuple: class CompositeLoss(BaseLoss): + """ + When math operations are performed using one or more loss objectives, this class + is used to store and run those operations. Below we show examples of common + CompositeLoss use cases. + + + Using CompositeLoss with a unary op or with a binary op involving a Loss instance + and a float or integer: + + .. code-block:: python + + def compose_single_loss(loss: opt.loss.Loss) -> opt.loss.CompositeLoss: + def loss_fn( + module: Dict[nn.Module, Optional[torch.Tensor]] + ) -> torch.Tensor: + return loss(module) + + # Name of new composable loss instance + name = loss.__name__ + # All targets being used in the composable loss instance + target = loss.target + return opt.loss.CompositeLoss(loss_fn, name=name, target=target) + + Using CompositeLoss with a binary op using two Loss instances: + + .. code-block:: python + + def compose_binary_loss( + loss1: opt.loss.Loss, loss2: opt.loss.Loss + ) -> opt.loss.CompositeLoss: + def loss_fn( + module: Dict[nn.Module, Optional[torch.Tensor]] + ) -> torch.Tensor: + # Operation using 2 loss instances + return loss1(module) + loss2(module) + + # Name of new composable loss instance + name = "Compose(" + ", ".join([loss1.__name__, loss2.__name__]) + ")" + + # All targets being used in the composable loss instance + target1 = loss1.target if type(loss1.target) is list else [loss1.target] + target2 = loss2.target if type(loss2.target) is list else [loss2.target] + target = target1 + target2 + + # Remove duplicate targets + target = list(dict.fromkeys(target)) + return opt.loss.CompositeLoss(loss_fn, name=name, target=target) + + Using CompositeLoss with a list of Loss instances: + + .. code-block:: python + + def compose_multiple_loss(loss: List[opt.loss.Loss]) -> opt.loss.CompositeLoss: + def loss_fn( + module: Dict[nn.Module, Optional[torch.Tensor]] + ) -> torch.Tensor: + loss_tensors = [loss_obj(module) for loss_obj in loss] + # We can use any operation that combines the list of tensors into a + # single tensor + return sum(loss_tensors) + + # Name of new composable loss instance + name = "Compose(" + ", ".join([obj.__name__ for obj in loss]) + ")" + + # All targets being used in the composable loss instance + # targets will either be List[nn.Module] or nn.Module + targets = [loss_obj.target for loss_obj in loss] + # Flatten list of targets + target = [ + o for l in [t if type(t) is list else [t] for t in targets] for o in l + ] + # Remove duplicate targets + target = list(dict.fromkeys(target)) + return opt.loss.CompositeLoss(loss_fn, name=name, target=target) + """ + def __init__( self, loss_fn: Callable, @@ -258,7 +338,7 @@ def __init__( objective(s) & math operations. name (str, optional): The name of all composable operations in the instance. - Default: "" + Default: ``""`` target (nn.Module or list of nn.module): A target nn.Module or list of nn.Module. """ @@ -317,9 +397,9 @@ def __init__( instance to optimize the output of. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set - to None, defaults to all activations in the batch. Index ranges should - be in the format of: [start, end]. - Default: None + to ``None``, defaults to all activations in the batch. Index ranges + should be in the format of: [start, end]. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) @@ -351,9 +431,9 @@ def __init__( channel_index (int): The index of the channel to optimize for. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None + ``None``, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.channel_index = channel_index @@ -397,16 +477,16 @@ def __init__( x (int, optional): The x coordinate of the neuron to optimize for. If unspecified, defaults to center, or one unit left of center for even lengths. - Default: None + Default: ``None`` y (int, optional): The y coordinate of the neuron to optimize for. If unspecified, defaults to center, or one unit up of center for even heights. - Default: None + Default: ``None`` batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None + ``None``, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.channel_index = channel_index @@ -452,9 +532,9 @@ def __init__( instance to optimize the output of. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set - to None, defaults to all activations in the batch. Index ranges should - be in the format of: [start, end]. - Default: None + to ``None``, defaults to all activations in the batch. Index ranges + should be in the format of: [start, end]. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) @@ -487,9 +567,9 @@ def __init__( instance to optimize the output of. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set - to None, defaults to all activations in the batch. Index ranges should - be in the format of: [start, end]. - Default: None + to ``None``, defaults to all activations in the batch. Index ranges + should be in the format of: [start, end]. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) @@ -521,9 +601,9 @@ def __init__( constant (float): Constant threshold to deduct from the activations. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None + ``None``, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.constant = constant @@ -553,14 +633,14 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. constant (float): Constant threshold to deduct from the activations. - Default: 0.0 + Default: ``0.0`` eps (float): Small value to add to L2 prior to sqrt. - Default: 1e-6 + Default: ``1e-6`` batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to - None, defaults to all activations in the batch. Index ranges should be - in the format of: [start, end]. - Default: None + ``None``, defaults to all activations in the batch. Index ranges should + be in the format of: [start, end]. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.constant = constant @@ -596,9 +676,9 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. batch_index (list of int, optional): The index range of activations to - optimize. If set to None, defaults to all activations in the batch. + optimize. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. - Default: None + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) @@ -643,13 +723,13 @@ def __init__( target1 (nn.Module): The first layer, transform, or image parameterization instance to optimize the output for. channel_index1 (int, optional): Index of channel in first target to - optimize. Default is set to None for all channels. - Default: None + optimize. Default is set to ``None`` for all channels. + Default: ``None`` target2 (nn.Module): The second layer, transform, or image parameterization instance to optimize the output for. channel_index2 (int, optional): Index of channel in second target to - optimize. Default is set to None for all channels. - Default: None + optimize. Default is set to ``None`` for all channels. + Default: ``None`` """ self.target_one = target1 self.channel_index_one = channel_index1 @@ -712,11 +792,11 @@ def __init__( instance to optimize the output of. decay_ratio (float): How much to decay penalty as images move apart in the batch. - Default: 2.0 + Default: ``2.0`` batch_index (list of int, optional): The index range of activations to - optimize. If set to None, defaults to all activations in the batch. + optimize. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. - Default: None + Default: ``None`` """ if batch_index: assert len(batch_index) == 2 @@ -766,11 +846,11 @@ def __init__( instance to optimize the output of. vec (torch.Tensor): Vector representing direction to align to. cossim_pow (float, optional): The desired cosine similarity power to use. - Default: 0.0 + Default: ``0.0`` batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to None, defaults to all - activations in the batch. - Default: None + optimizing a batch of activations. If set to ``None``, defaults to + all activations in the batch. + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.vec = vec.reshape((1, -1, 1, 1)) @@ -810,22 +890,22 @@ def __init__( instance to optimize the output of. vec (torch.Tensor): Vector representing direction to align to. x (int, optional): The x coordinate of the neuron to optimize for. If - set to None, defaults to center, or one unit left of center for even - lengths. - Default: None + set to ``None``, defaults to center, or one unit left of center for + even lengths. + Default: ``None`` y (int, optional): The y coordinate of the neuron to optimize for. If - set to None, defaults to center, or one unit up of center for even - heights. - Default: None + set to ``None``, defaults to center, or one unit up of center for + even heights. + Default: ``None`` channel_index (int): The index of the channel to optimize for. If set to - None, then all channels will be used. - Default: None + ``None``, then all channels will be used. + Default: ``None`` cossim_pow (float, optional): The desired cosine similarity power to use. - Default: 0.0 + Default: ``0.0`` batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to None, defaults to all + optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. - Default: None + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.vec = vec.reshape((1, -1, 1, 1)) @@ -897,24 +977,24 @@ def __init__( instance to optimize the output of. vec (torch.Tensor): A neuron direction vector to use. vec_whitened (torch.Tensor, optional): A whitened neuron direction vector. - If set to None, then no whitened vec will be used. - Default: None + If set to ``None``, then no whitened vec will be used. + Default: ``None`` cossim_pow (float, optional): The desired cosine similarity power to use. x (int, optional): The x coordinate of the neuron to optimize for. If - set to None, defaults to center, or one unit left of center for even - lengths. - Default: None + set to ``None``, defaults to center, or one unit left of center for + even lengths. + Default: ``None`` y (int, optional): The y coordinate of the neuron to optimize for. If - set to None, defaults to center, or one unit up of center for even - heights. - Default: None + set to ``None``, defaults to center, or one unit up of center for + even heights. + Default: ``None`` eps (float, optional): If cossim_pow is greater than zero, the desired epsilon value to use for cosine similarity calculations. - Default: 1.0e-4 + Default: ``1.0e-4`` batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to None, defaults to all + optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. - Default: None + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) self.vec = vec.unsqueeze(0) if vec.dim() == 1 else vec @@ -974,11 +1054,11 @@ def __init__( instance to optimize the output of. vec (torch.Tensor): Vector representing direction to align to. cossim_pow (float, optional): The desired cosine similarity power to use. - Default: 0.0 + Default: ``0.0`` batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to None, defaults to all + optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. - Default: None + Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) assert vec.dim() == 4 @@ -1030,21 +1110,21 @@ def __init__( instance to optimize the output of. weights (torch.Tensor): Weights to apply to targets. neuron (bool): Whether target is a neuron. - Default: False + Default: ``False`` x (int, optional): The x coordinate of the neuron to optimize for. If - set to None, defaults to center, or one unit left of center for even - lengths. - Default: None + set to ``None``, defaults to center, or one unit left of center for + even lengths. + Default: ``None`` y (int, optional): The y coordinate of the neuron to optimize for. If - set to None, defaults to center, or one unit up of center for even - heights. - Default: None + set to ``None``, defaults to center, or one unit up of center for + even heights. + Default: ``None`` wx (int, optional): Length of neurons to apply the weights to, along the - x-axis. Set to None for the full length. - Default: None + x-axis. Set to ``None`` for the full length. + Default: ``None`` wy (int, optional): Length of neurons to apply the weights to, along the - y-axis. Set to None for the full length. - Default: None + y-axis. Set to ``None`` for the full length. + Default: ``None`` """ BaseLoss.__init__(self, target) self.x = x @@ -1100,11 +1180,11 @@ def sum_loss_list( loss_list (list): A list of loss objectives. to_scalar_fn (Callable): A function for converting loss objective outputs to scalar values, in order to prevent size mismatches. - Default: torch.mean + Default: ``torch.mean`` Returns: loss_fn (CompositeLoss): A CompositeLoss instance containing all the loss - functions from `loss_list`. + functions from ``loss_list``. """ def loss_fn(module: ModuleOutputMapping) -> torch.Tensor: From d3a2ccadb7e7dd843f4e703d0ee1ae313fc8b756 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 27 Jun 2022 19:49:48 -0600 Subject: [PATCH 057/174] Improve vector function docs for Sphinx --- captum/optim/_utils/image/common.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index 1f2cced14f..54cdae4b0d 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -394,11 +394,11 @@ def _create_new_vector( activation_fn (Callable, optional): An optional activation function to apply to the activations before computing the matrix product. If set to None, then no activation function will be used. - Default: torch.nn.functional.relu + Default: ``torch.nn.functional.relu`` move_channel_dim_to_final_dim (bool, optional): Whether or not to move the channel dimension to the last dimension before computing the matrix product. - Default: True + Default: ``True`` Returns x (torch.Tensor): A vector created from the input activations and the From 2a592f0512b49ffb8f67e1ceb9d7be14cabc5e6a Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 27 Jun 2022 19:52:10 -0600 Subject: [PATCH 058/174] Adjust spacing in doc variables --- captum/optim/_utils/image/dataset.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/captum/optim/_utils/image/dataset.py b/captum/optim/_utils/image/dataset.py index 66eee6dc38..8b2c5669b5 100644 --- a/captum/optim/_utils/image/dataset.py +++ b/captum/optim/_utils/image/dataset.py @@ -53,7 +53,7 @@ def dataset_cov_matrix( Default: ``torch.device("cpu")`` Returns: - *tensor*: A covariance matrix for the specified dataset. + *tensor*: A covariance matrix for the specified dataset. """ if show_progress: @@ -99,7 +99,7 @@ def cov_matrix_to_klt( Default: ``1e-10`` Returns: - *tensor*: A KLT matrix for the specified covariance matrix. + *tensor*: A KLT matrix for the specified covariance matrix. """ U, S, V = torch.svd(cov_mtx) @@ -134,7 +134,7 @@ def dataset_klt_matrix( Default: ``torch.device("cpu")`` Returns: - *tensor*: A KLT matrix for the specified dataset. + *tensor*: A KLT matrix for the specified dataset. """ cov_mtx = dataset_cov_matrix(loader, show_progress=show_progress, device=device) From e80b42eae878e0ecbbd7921871e3cc8eae825eb2 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 28 Jun 2022 19:34:57 -0600 Subject: [PATCH 059/174] Fix spacing in docs --- captum/optim/_utils/image/common.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index 54cdae4b0d..9e7553b251 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -389,7 +389,7 @@ def _create_new_vector( computing the matrix product of the activations. See torch.matmul for See torch.matmul for more details on compatible shapes: https://pytorch.org/docs/stable/generated/torch.matmul.html - By default, vec is expected to share the same size as the channel or + By default, ``vec`` is expected to share the same size as the channel or feature dimension of the activations. activation_fn (Callable, optional): An optional activation function to apply to the activations before computing the matrix product. If set @@ -401,7 +401,7 @@ def _create_new_vector( Default: ``True`` Returns - x (torch.Tensor): A vector created from the input activations and the + x (torch.Tensor): A vector created from the input activations and the stored vector. """ assert x.device == vec.device From 8ceecafdff3e2bf1feefdef08639f397b851fd22 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 28 Jun 2022 19:40:05 -0600 Subject: [PATCH 060/174] Improve dataset docs --- captum/optim/_utils/image/dataset.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/captum/optim/_utils/image/dataset.py b/captum/optim/_utils/image/dataset.py index 8b2c5669b5..6a36dd2644 100644 --- a/captum/optim/_utils/image/dataset.py +++ b/captum/optim/_utils/image/dataset.py @@ -44,7 +44,7 @@ def dataset_cov_matrix( Args: - loader (torch.utils.data.DataLoader): The reference to a PyTorch + loader (torch.utils.data.DataLoader): The reference to a PyTorch dataloader instance. show_progress (bool, optional): Whether or not to display a tqdm progress bar. Default: ``False`` @@ -53,7 +53,7 @@ def dataset_cov_matrix( Default: ``torch.device("cpu")`` Returns: - *tensor*: A covariance matrix for the specified dataset. + *tensor* (torch.Tensor): A covariance matrix for the specified dataset. """ if show_progress: @@ -99,7 +99,8 @@ def cov_matrix_to_klt( Default: ``1e-10`` Returns: - *tensor*: A KLT matrix for the specified covariance matrix. + *tensor* (torch.Tensor): A KLT matrix for the specified covariance + matrix. """ U, S, V = torch.svd(cov_mtx) @@ -134,7 +135,7 @@ def dataset_klt_matrix( Default: ``torch.device("cpu")`` Returns: - *tensor*: A KLT matrix for the specified dataset. + *tensor* (torch.Tensor): A KLT matrix for the specified dataset. """ cov_mtx = dataset_cov_matrix(loader, show_progress=show_progress, device=device) From 0491cca122bf64d0275464c1362aeab8c4bea756 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 29 Jun 2022 08:41:52 -0600 Subject: [PATCH 061/174] Improve Sphinx docs --- captum/optim/models/_common.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index d0a1d81208..4b460058f8 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -82,7 +82,14 @@ def replace_layers( Replace all target layers with new layers inside the specified model, possibly with the same initialization variables. + Example:: + + >>> model = opt.models.googlenet(pretrained=True) + >>> # Replace MaxPool2d layers with their AvgPool2d equivalents + >>> opt.models.replace_layers(model, nn.MaxPool2d, nn.AvgPool2d, True) + Args: + model: (nn.Module): A PyTorch model instance. layer1: (Type[nn.Module]): The layer class that you want to transfer initialization variables from. From 86f24bac11f4110aa17408701487d792e9afdca1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 29 Jun 2022 16:29:24 -0600 Subject: [PATCH 062/174] Improve ImageTensor docs --- captum/optim/_param/image/images.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 64400f24ff..7853761573 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -131,7 +131,8 @@ def show( pad_value: float = 0.0, ) -> None: """ - Display an ``ImageTensor`` instance. + Display image(s) in the ``ImageTensor`` instance using + :func:`captum.optim.show`. Args: @@ -170,7 +171,8 @@ def export( pad_value: float = 0.0, ) -> None: """ - Save an `ImageTensor` as an image file. + Save image(s) in the `ImageTensor` instance as an image file, using + :func:`captum.optim.save_tensor_as_image`. Args: From 975550e992524eb1ccea749e6ff44d9ad4a7a2c1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 1 Jul 2022 13:14:42 -0600 Subject: [PATCH 063/174] Add 'Feature Visualization' keyword --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index 09fe441950..cd930850f8 100755 --- a/setup.py +++ b/setup.py @@ -133,6 +133,7 @@ def get_package_files(root, subdirs): "Model Understanding", "Feature Importance", "Neuron Importance", + "Feature Visualization", "PyTorch", ], classifiers=[ From 7530ae5c24a4e67ffb88448916419a02efbba849 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 1 Jul 2022 18:50:35 -0600 Subject: [PATCH 064/174] Improve ImageTensor & Dataset docs (#552) * Update images.py * Update dataset.py * Update images.py --- captum/optim/_param/image/images.py | 5 +++-- captum/optim/_utils/image/dataset.py | 10 +++++----- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 7853761573..568b8edecd 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -29,7 +29,7 @@ class ImageTensor(torch.Tensor): >>> image_tensor = opt.images.ImageTensor.load() >>> image_tensor.export(filename="image_tensor.jpg") # Save image(s) - >>> image_tensor.show(figsize=(8, 8)) # Displays image(s) via Matplotlib + >>> image_tensor.show() # Displays image(s) via Matplotlib Example using ``torch.Tensor``:: @@ -124,7 +124,7 @@ def __torch_function__( def show( self, - figsize: Optional[Tuple[int, int]] = None, + figsize: Optional[Tuple[int, int]] = (8, 8), scale: float = 255.0, images_per_row: Optional[int] = None, padding: int = 2, @@ -138,6 +138,7 @@ def show( figsize (Tuple[int, int], optional): height & width to use for displaying the ``ImageTensor`` figure. + Default: ``(8, 8)`` scale (float, optional): Value to multiply the ``ImageTensor`` by so that it's value range is [0-255] for display. Default: ``255.0`` diff --git a/captum/optim/_utils/image/dataset.py b/captum/optim/_utils/image/dataset.py index 6a36dd2644..9d9108f44d 100644 --- a/captum/optim/_utils/image/dataset.py +++ b/captum/optim/_utils/image/dataset.py @@ -23,7 +23,7 @@ def image_cov(x: torch.Tensor) -> torch.Tensor: dimension. Returns: - *tensor* (torch.Tensor): The average color channel covariance matrix for the + tensor (torch.Tensor): The average color channel covariance matrix for the for the input tensor, with a shape of: [n_channels, n_channels]. """ @@ -53,7 +53,7 @@ def dataset_cov_matrix( Default: ``torch.device("cpu")`` Returns: - *tensor* (torch.Tensor): A covariance matrix for the specified dataset. + tensor (torch.Tensor): A covariance matrix for the specified dataset. """ if show_progress: @@ -91,7 +91,7 @@ def cov_matrix_to_klt( Args: - cov_mtx (tensor): A 3 by 3 covariance matrix generated from a dataset. + cov_mtx (torch.Tensor): A 3 by 3 covariance matrix generated from a dataset. normalize (bool): Whether or not to normalize the resulting KLT matrix. Default: ``False`` epsilon (float, optional): A small epsilon value to use for numerical @@ -99,7 +99,7 @@ def cov_matrix_to_klt( Default: ``1e-10`` Returns: - *tensor* (torch.Tensor): A KLT matrix for the specified covariance + tensor (torch.Tensor): A KLT matrix for the specified covariance matrix. """ @@ -135,7 +135,7 @@ def dataset_klt_matrix( Default: ``torch.device("cpu")`` Returns: - *tensor* (torch.Tensor): A KLT matrix for the specified dataset. + tensor (torch.Tensor): A KLT matrix for the specified dataset. """ cov_mtx = dataset_cov_matrix(loader, show_progress=show_progress, device=device) From 4a62c0b542a75ebcd3f3a0f70e306a2ee57383a3 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 4 Jul 2022 18:25:34 -0600 Subject: [PATCH 065/174] Improve docs --- captum/optim/models/_image/inception_v1_places365.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/models/_image/inception_v1_places365.py b/captum/optim/models/_image/inception_v1_places365.py index acd5f8fe7f..c5df0b85b0 100644 --- a/captum/optim/models/_image/inception_v1_places365.py +++ b/captum/optim/models/_image/inception_v1_places365.py @@ -55,7 +55,7 @@ def googlenet_places365( Default: ``True`` Returns: - **model** (InceptionV1Places365): An InceptionV1 Places365 model instance. + model (InceptionV1Places365): An InceptionV1 Places365 model instance. """ if pretrained: From e63cee8f073d9d125a74fe45d0731807f7211183 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 4 Jul 2022 18:40:34 -0600 Subject: [PATCH 066/174] Improve docs --- captum/optim/_param/image/images.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 568b8edecd..5bb8555a17 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -124,7 +124,7 @@ def __torch_function__( def show( self, - figsize: Optional[Tuple[int, int]] = (8, 8), + figsize: Optional[Tuple[int, int]] = None, scale: float = 255.0, images_per_row: Optional[int] = None, padding: int = 2, @@ -138,7 +138,7 @@ def show( figsize (Tuple[int, int], optional): height & width to use for displaying the ``ImageTensor`` figure. - Default: ``(8, 8)`` + Default: ``None`` scale (float, optional): Value to multiply the ``ImageTensor`` by so that it's value range is [0-255] for display. Default: ``255.0`` From 06db64f71cb6473ed9fca91fe041026b1dfc76f8 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 5 Jul 2022 09:07:34 -0600 Subject: [PATCH 067/174] Improve dataset docs --- captum/optim/_utils/image/dataset.py | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/captum/optim/_utils/image/dataset.py b/captum/optim/_utils/image/dataset.py index 9d9108f44d..5319e4b9a6 100644 --- a/captum/optim/_utils/image/dataset.py +++ b/captum/optim/_utils/image/dataset.py @@ -42,6 +42,15 @@ def dataset_cov_matrix( """ Calculate the covariance matrix for an image dataset. + Example:: + + >>> # Load image dataset + >>> dataset = torchvision.datasets.ImageFolder("") + >>> dataset_loader = torch.utils.data.DataLoader(dataset) + >>> # Calculate dataset COV matrix + >>> cov_mtx = opt.dataset.dataset_cov(dataset_loader, True) + >>> print(cov_mtx) + Args: loader (torch.utils.data.DataLoader): The reference to a PyTorch @@ -117,10 +126,19 @@ def dataset_klt_matrix( device: torch.device = torch.device("cpu"), ) -> torch.Tensor: """ - Calculate the color correlation matrix, also known as - a Karhunen-Loève transform (KLT) matrix, for a dataset. - The color correlation matrix can then used in color decorrelation - transforms for models trained on the dataset. + Calculate the color correlation matrix, also known as a Karhunen-Loève transform + (KLT) matrix, for a dataset. The color correlation matrix can then used in color + decorrelation & recorrelation transforms like + :class:`captum.optim.transforms.ToRGB` for models trained on the dataset. + + Example:: + + >>> # Load image dataset + >>> dataset = torchvision.datasets.ImageFolder("") + >>> dataset_loader = torch.utils.data.DataLoader(dataset) + >>> # Calculate dataset KLT matrix + >>> klt_mtx = opt.dataset.dataset_klt_matrix(dataset_loader, True, True) + >>> print(klt_mtx) Args: From b84980a8a7c4722f29b9693234bc255150da224a Mon Sep 17 00:00:00 2001 From: Steffen Maeland Date: Tue, 5 Jul 2022 16:13:10 -0700 Subject: [PATCH 068/174] Add time series visualization function (#980) Summary: Add a convenience function to plot time series data with attributions overlaid (`captum.attr.visualization.visualize_timeseries_attr`). This addresses https://github.com/pytorch/captum/issues/958 . Comes with three styles, shown here for some dummy data: 1) Plot each channel in a separate panel, with separate heatmaps overlaid ![overlaid_individual](https://user-images.githubusercontent.com/30171842/174852816-f3c7d67f-d03f-4d04-91b4-6766052a640d.png) 2) Plot all channels in a single panel, with average heatmap overlaid ![overlaid_combined](https://user-images.githubusercontent.com/30171842/174852821-1ab089b2-9e30-4233-9726-dd3e3d9f03f5.png) 3) Plot each channel in a separate panel and color the graphs by attribution values at each time step ![colored_graph](https://user-images.githubusercontent.com/30171842/174852820-f0be8148-d432-43f3-a301-e783b98dece0.png) The function accepts matplotlib keyword arguments for additional styling. Pull Request resolved: https://github.com/pytorch/captum/pull/980 Reviewed By: vivekmig Differential Revision: D37495470 Pulled By: i-jones fbshipit-source-id: d218dc035d7158af39480a4df63a0bb9500f495c --- captum/attr/_utils/visualization.py | 330 +++++++++++++++++++++++++++- 1 file changed, 324 insertions(+), 6 deletions(-) diff --git a/captum/attr/_utils/visualization.py b/captum/attr/_utils/visualization.py index 2db9026872..0cfada9b7b 100644 --- a/captum/attr/_utils/visualization.py +++ b/captum/attr/_utils/visualization.py @@ -1,10 +1,11 @@ #!/usr/bin/env python3 import warnings from enum import Enum -from typing import Any, Iterable, List, Tuple, Union +from typing import Any, Iterable, List, Optional, Tuple, Union import numpy as np -from matplotlib import pyplot as plt +from matplotlib import cm, colors, pyplot as plt +from matplotlib.collections import LineCollection from matplotlib.colors import LinearSegmentedColormap from matplotlib.figure import Figure from matplotlib.pyplot import axis, figure @@ -27,6 +28,12 @@ class ImageVisualizationMethod(Enum): alpha_scaling = 5 +class TimeseriesVisualizationMethod(Enum): + overlay_individual = 1 + overlay_combined = 2 + colored_graph = 3 + + class VisualizeSign(Enum): positive = 1 absolute_value = 2 @@ -61,10 +68,16 @@ def _cumulative_sum_threshold(values: ndarray, percentile: Union[int, float]): return sorted_vals[threshold_id] -def _normalize_image_attr( - attr: ndarray, sign: str, outlier_perc: Union[int, float] = 2 +def _normalize_attr( + attr: ndarray, + sign: str, + outlier_perc: Union[int, float] = 2, + reduction_axis: Optional[int] = None, ): - attr_combined = np.sum(attr, axis=2) + attr_combined = attr + if reduction_axis is not None: + attr_combined = np.sum(attr, axis=reduction_axis) + # Choose appropriate signed values and rescale, removing given outlier percentage. if VisualizeSign[sign] == VisualizeSign.all: threshold = _cumulative_sum_threshold(np.abs(attr_combined), 100 - outlier_perc) @@ -241,7 +254,7 @@ def visualize_image_attr( plt_axis.imshow(original_image) else: # Choose appropriate signed attributions and normalize. - norm_attr = _normalize_image_attr(attr, sign, outlier_perc) + norm_attr = _normalize_attr(attr, sign, outlier_perc, reduction_axis=2) # Set default colormap and bounds based on sign. if VisualizeSign[sign] == VisualizeSign.all: @@ -422,6 +435,311 @@ def visualize_image_attr_multiple( return plt_fig, plt_axis +def visualize_timeseries_attr( + attr: ndarray, + data: ndarray, + x_values: Optional[ndarray] = None, + method: str = "individual_channels", + sign: str = "absolute_value", + channel_labels: Optional[List[str]] = None, + channels_last: bool = True, + plt_fig_axis: Union[None, Tuple[figure, axis]] = None, + outlier_perc: Union[int, float] = 2, + cmap: Union[None, str] = None, + alpha_overlay: float = 0.7, + show_colorbar: bool = False, + title: Union[None, str] = None, + fig_size: Tuple[int, int] = (6, 6), + use_pyplot: bool = True, + **pyplot_kwargs, +): + r""" + Visualizes attribution for a given timeseries data by normalizing + attribution values of the desired sign (positive, negative, absolute value, + or all) and displaying them using the desired mode in a matplotlib figure. + + Args: + + attr (numpy.array): Numpy array corresponding to attributions to be + visualized. Shape must be in the form (N, C) with channels + as last dimension, unless `channels_last` is set to True. + Shape must also match that of the timeseries data. + data (numpy.array): Numpy array corresponding to the original, + equidistant timeseries data. Shape must be in the form + (N, C) with channels as last dimension, unless + `channels_last` is set to true. + x_values (numpy.array, optional): Numpy array corresponding to the + points on the x-axis. Shape must be in the form (N, ). If + not provided, integers from 0 to N-1 are used. + Default: None + method (string, optional): Chosen method for visualizing attributions + overlaid onto data. Supported options are: + + 1. `overlay_individual` - Plot each channel individually in + a separate panel, and overlay the attributions for each + channel as a heat map. The `alpha_overlay` parameter + controls the alpha of the heat map. + + 2. `overlay_combined` - Plot all channels in the same panel, + and overlay the average attributions as a heat map. + + 3. `colored_graph` - Plot each channel in a separate panel, + and color the graphs according to the attribution + values. Works best with color maps that does not contain + white or very bright colors. + Default: `overlay_individual` + sign (string, optional): Chosen sign of attributions to visualize. + Supported options are: + + 1. `positive` - Displays only positive pixel attributions. + + 2. `absolute_value` - Displays absolute value of + attributions. + + 3. `negative` - Displays only negative pixel attributions. + + 4. `all` - Displays both positive and negative attribution + values. + Default: `absolute_value` + channel_labels (list of strings, optional): List of labels + corresponding to each channel in data. + Default: None + channels_last (bool, optional): If True, data is expected to have + channels as the last dimension, i.e. (N, C). If False, data + is expected to have channels first, i.e. (C, N). + Default: True + plt_fig_axis (tuple, optional): Tuple of matplotlib.pyplot.figure and axis + on which to visualize. If None is provided, then a new figure + and axis are created. + Default: None + outlier_perc (float or int, optional): Top attribution values which + correspond to a total of outlier_perc percentage of the + total attribution are set to 1 and scaling is performed + using the minimum of these values. For sign=`all`, outliers + and scale value are computed using absolute value of + attributions. + Default: 2 + cmap (string, optional): String corresponding to desired colormap for + heatmap visualization. This defaults to "Reds" for negative + sign, "Blues" for absolute value, "Greens" for positive sign, + and a spectrum from red to green for all. Note that this + argument is only used for visualizations displaying heatmaps. + Default: None + alpha_overlay (float, optional): Alpha to set for heatmap when using + `blended_heat_map` visualization mode, which overlays the + heat map over the greyscaled original image. + Default: 0.7 + show_colorbar (boolean): Displays colorbar for heat map below + the visualization. + title (string, optional): Title string for plot. If None, no title is + set. + Default: None + fig_size (tuple, optional): Size of figure created. + Default: (6,6) + use_pyplot (boolean): If true, uses pyplot to create and show + figure and displays the figure after creating. If False, + uses Matplotlib object oriented API and simply returns a + figure object without showing. + Default: True. + pyplot_kwargs: Keyword arguments forwarded to plt.plot, for example + `linewidth=3`, `color='black'`, etc + + Returns: + 2-element tuple of **figure**, **axis**: + - **figure** (*matplotlib.pyplot.figure*): + Figure object on which visualization + is created. If plt_fig_axis argument is given, this is the + same figure provided. + - **axis** (*matplotlib.pyplot.axis*): + Axis object on which visualization + is created. If plt_fig_axis argument is given, this is the + same axis provided. + + Examples:: + + >>> # Classifier takes input of shape (batch, length, channels) + >>> model = Classifier() + >>> dl = DeepLift(model) + >>> attribution = dl.attribute(data, target=0) + >>> # Pick the first sample and plot each channel in data in a separate + >>> # panel, with attributions overlaid + >>> visualize_timeseries_attr(attribution[0], data[0], "overlay_individual") + """ + + # Check input dimensions + assert len(attr.shape) == 2, "Expected attr of shape (N, C), got {}".format( + attr.shape + ) + assert len(data.shape) == 2, "Expected data of shape (N, C), got {}".format( + attr.shape + ) + + # Convert to channels-first + if channels_last: + attr = np.transpose(attr) + data = np.transpose(data) + + num_channels = attr.shape[0] + timeseries_length = attr.shape[1] + + if num_channels > timeseries_length: + warnings.warn( + "Number of channels ({}) greater than time series length ({}), " + "please verify input format".format(num_channels, timeseries_length) + ) + + num_subplots = num_channels + if ( + TimeseriesVisualizationMethod[method] + == TimeseriesVisualizationMethod.overlay_combined + ): + num_subplots = 1 + attr = np.sum(attr, axis=0) # Merge attributions across channels + + if x_values is not None: + assert ( + x_values.shape[0] == timeseries_length + ), "x_values must have same length as data" + else: + x_values = np.arange(timeseries_length) + + # Create plot if figure, axis not provided + if plt_fig_axis is not None: + plt_fig, plt_axis = plt_fig_axis + else: + if use_pyplot: + plt_fig, plt_axis = plt.subplots( + figsize=fig_size, nrows=num_subplots, sharex=True + ) + else: + plt_fig = Figure(figsize=fig_size) + plt_axis = plt_fig.subplots(nrows=num_subplots, sharex=True) + + if not isinstance(plt_axis, ndarray): + plt_axis = np.array([plt_axis]) + + norm_attr = _normalize_attr(attr, sign, outlier_perc, reduction_axis=None) + + # Set default colormap and bounds based on sign. + if VisualizeSign[sign] == VisualizeSign.all: + default_cmap = LinearSegmentedColormap.from_list( + "RdWhGn", ["red", "white", "green"] + ) + vmin, vmax = -1, 1 + elif VisualizeSign[sign] == VisualizeSign.positive: + default_cmap = "Greens" + vmin, vmax = 0, 1 + elif VisualizeSign[sign] == VisualizeSign.negative: + default_cmap = "Reds" + vmin, vmax = 0, 1 + elif VisualizeSign[sign] == VisualizeSign.absolute_value: + default_cmap = "Blues" + vmin, vmax = 0, 1 + else: + raise AssertionError("Visualize Sign type is not valid.") + cmap = cmap if cmap is not None else default_cmap + cmap = cm.get_cmap(cmap) + cm_norm = colors.Normalize(vmin, vmax) + + def _plot_attrs_as_axvspan(attr_vals, x_vals, ax): + + half_col_width = (x_values[1] - x_values[0]) / 2.0 + for icol, col_center in enumerate(x_vals): + left = col_center - half_col_width + right = col_center + half_col_width + ax.axvspan( + xmin=left, + xmax=right, + facecolor=(cmap(cm_norm(attr_vals[icol]))), + edgecolor=None, + alpha=alpha_overlay, + ) + + if ( + TimeseriesVisualizationMethod[method] + == TimeseriesVisualizationMethod.overlay_individual + ): + + for chan in range(num_channels): + + plt_axis[chan].plot(x_values, data[chan, :], **pyplot_kwargs) + if channel_labels is not None: + plt_axis[chan].set_ylabel(channel_labels[chan]) + + _plot_attrs_as_axvspan(norm_attr[chan], x_values, plt_axis[chan]) + + plt.subplots_adjust(hspace=0) + + elif ( + TimeseriesVisualizationMethod[method] + == TimeseriesVisualizationMethod.overlay_combined + ): + + # Dark colors are better in this case + cycler = plt.cycler("color", cm.Dark2.colors) + plt_axis[0].set_prop_cycle(cycler) + + for chan in range(num_channels): + if channel_labels is not None: + label = channel_labels[chan] + else: + label = None + plt_axis[0].plot(x_values, data[chan, :], label=label, **pyplot_kwargs) + + _plot_attrs_as_axvspan(norm_attr, x_values, plt_axis[0]) + + plt_axis[0].legend(loc="best") + + elif ( + TimeseriesVisualizationMethod[method] + == TimeseriesVisualizationMethod.colored_graph + ): + + for chan in range(num_channels): + + points = np.array([x_values, data[chan, :]]).T.reshape(-1, 1, 2) + segments = np.concatenate([points[:-1], points[1:]], axis=1) + + lc = LineCollection(segments, cmap=cmap, norm=cm_norm, **pyplot_kwargs) + lc.set_array(norm_attr[chan, :]) + plt_axis[chan].add_collection(lc) + plt_axis[chan].set_ylim( + 1.2 * np.min(data[chan, :]), 1.2 * np.max(data[chan, :]) + ) + if channel_labels is not None: + plt_axis[chan].set_ylabel(channel_labels[chan]) + + plt.subplots_adjust(hspace=0) + + else: + raise AssertionError("Invalid visualization method: {}".format(method)) + + plt.xlim([x_values[0], x_values[-1]]) + + if show_colorbar: + axis_separator = make_axes_locatable(plt_axis[-1]) + colorbar_axis = axis_separator.append_axes("bottom", size="5%", pad=0.4) + colorbar_alpha = alpha_overlay + if ( + TimeseriesVisualizationMethod[method] + == TimeseriesVisualizationMethod.colored_graph + ): + colorbar_alpha = 1.0 + plt_fig.colorbar( + cm.ScalarMappable(cm_norm, cmap), + orientation="horizontal", + cax=colorbar_axis, + alpha=colorbar_alpha, + ) + if title: + plt_axis[0].set_title(title) + + if use_pyplot: + plt.show() + + return plt_fig, plt_axis + + # These visualization methods are for text and are partially copied from # experiments conducted by Davide Testuggine at Facebook. From 10d2379c105c125ddaafbfe635646219f4457f61 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 6 Jul 2022 14:42:59 -0600 Subject: [PATCH 069/174] Add missing Places365 InceptionModule docs --- .../models/_image/inception_v1_places365.py | 22 ++++++++++++------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/captum/optim/models/_image/inception_v1_places365.py b/captum/optim/models/_image/inception_v1_places365.py index c5df0b85b0..b92bbb6e6e 100644 --- a/captum/optim/models/_image/inception_v1_places365.py +++ b/captum/optim/models/_image/inception_v1_places365.py @@ -290,14 +290,20 @@ def __init__( """ Args: - in_channels (int, optional): The number of input channels to use for the - inception module. - c1x1 (int, optional): - c3x3reduce (int, optional): - c3x3 (int, optional): - c5x5reduce (int, optional): - c5x5 (int, optional): - pool_proj (int, optional): + in_channels (int): The number of input channels to use for the first + layers of the inception module branches. + c1x1 (int): The number of output channels to use for the first layer in + the c1x1 branch. + c3x3reduce (int): The number of output channels to use for the first layer + in the c3x3 branch. + c3x3 (int): The number of output channels to use for the second layer in + the c3x3 branch. + c5x5reduce (int): The number of output channels to use for the first layer + in the c5x5 branch. + c5x5 (int): The number of output channels to use for the second layer in + the c5x5 branch. + pool_proj (int): The number of output channels to use for the second layer + in the pool branch. activ (type of nn.Module, optional): The nn.Module class type to use for activation layers. Default: ``nn.ReLU`` From b376466519d2f70b7de04e2087a1d875781d8816 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 9 Jul 2022 13:47:59 -0600 Subject: [PATCH 070/174] Improve Optimization docs --- captum/optim/_core/optimization.py | 33 +++++++++++++++--------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 4072b0f987..424d643282 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -71,13 +71,13 @@ def __init__( r""" Args: - model (nn.Module, optional): The reference to PyTorch model instance. - input_param (nn.Module, optional): A module that generates an input, - consumed by the model. - transform (nn.Module, optional): A module that transforms or preprocesses - the input before being passed to the model. - loss_function (callable): The loss function to minimize during optimization - optimization. + model (nn.Module, optional): The reference to PyTorch model instance. + input_param (nn.Module, optional): A module that generates an input, + consumed by the model. + transform (nn.Module, optional): A module that transforms or preprocesses + the input before being passed to the model. + loss_function (callable): The loss function to minimize during + optimization. """ self.model = model or nn.Identity() # Grab targets from loss_function @@ -100,9 +100,9 @@ def loss(self) -> torch.Tensor: r"""Compute loss value for current iteration. Returns: - *tensor* representing **loss**: - - **loss** (*tensor*): - Size of the tensor corresponds to the targets passed. + tensor representing **loss**: + - **loss** (torch.Tensor): Size of the tensor corresponds to the targets + passed. """ input_t = self.input_param() @@ -153,12 +153,13 @@ def optimize( Args: - stop_criteria (StopCriteria, optional): A function that is called + stop_criteria (StopCriteria, optional): A function that is called every iteration and returns a bool that determines whether to stop the optimization. Default: ``n_steps(512)`` - optimizer (Optimizer, optional): An ``torch.optim.Optimizer`` used to - optimize the input based on the loss function. + optimizer (torch.optim.Optimizer, optional): A ``torch.optim.Optimizer`` + instance to use for optimizing the input based on the loss function. + Default: ``torch.optim.Adam`` loss_summarize_fn (Callable, optional): The function to use for summarizing tensor outputs from loss functions. Default: ``default_loss_summarize`` @@ -200,12 +201,12 @@ def n_steps(n: int, show_progress: bool = True) -> StopCriteria: Args: - n (int): Number of steps to run optimization. - show_progress (bool, optional): Whether or not to show progress bar. + n (int): Number of steps to run optimization. + show_progress (bool, optional): Whether or not to show progress bar. Default: ``True`` Returns: - *StopCriteria* (callable): A stop criteria function. + StopCriteria (callable): A stop criteria function. """ if show_progress: From 1821a2da25ce6ebb9f4d16a4d99174db6a3f6e5b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 10 Jul 2022 09:56:37 -0600 Subject: [PATCH 071/174] http -> https --- captum/optim/models/_image/inception_v1_places365.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/models/_image/inception_v1_places365.py b/captum/optim/models/_image/inception_v1_places365.py index b92bbb6e6e..81bb7b98c1 100644 --- a/captum/optim/models/_image/inception_v1_places365.py +++ b/captum/optim/models/_image/inception_v1_places365.py @@ -18,7 +18,7 @@ def googlenet_places365( **kwargs: Any, ) -> "InceptionV1Places365": r"""GoogLeNet (also known as Inception v1 & Inception 5h) model architecture from - `"Going Deeper with Convolutions" `_. + `"Going Deeper with Convolutions" `_. The pretrained GoogleNet model was trained using the MIT Places365 Standard dataset. See here for more information: https://arxiv.org/abs/1610.02055 From adaf3674883910b10a3ae53c29cbf6f9dd147261 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 10 Jul 2022 13:04:49 -0600 Subject: [PATCH 072/174] Improve InputOptimization docs --- captum/optim/_core/optimization.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 424d643282..7d26946e87 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -33,8 +33,9 @@ class InputOptimization(Objective, Parameterized): This is similar to gradient-based methods for adversarial examples, such as FGSM. The code for this was based on the implementation by the authors of Lucid. For more details, see the following: - https://github.com/tensorflow/lucid - https://distill.pub/2017/feature-visualization/ + + * https://github.com/tensorflow/lucid + * https://distill.pub/2017/feature-visualization/ Example:: From 509accd805bd864c29abf92546116e010ffbe89a Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 14 Jul 2022 11:38:16 -0600 Subject: [PATCH 073/174] Improve loss docs --- captum/optim/_core/loss.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 252f569921..8c9011e8a2 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -924,7 +924,7 @@ def __init__( Default: ``torch.nn.functional.relu`` move_channel_dim_to_final_dim (bool, optional): Whether or not to move the channel dimension to the last dimension before computing the matrix - product. + product. Set to ``False`` if the using the channels last format. Default: ``True`` batch_index (int, optional): The index of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all @@ -988,8 +988,8 @@ def __init__( to use for batch dimension weighting. If using a single value, then it will be applied to all batch dimensions equally. Otherwise a list of floats with a shape of: [start, end] should be used for - ``torch.linspace`` to calculate the step values in between. Default is - set to ``None`` for no weighting. + :func:`torch.linspace` to calculate the step values in between. Default + is set to ``None`` for no weighting. Default: ``None`` batch_index (int, optional): The index of the activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all From 407f76903ea0ca1ced8161e7359d1a18c11ecedf Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 15 Jul 2022 10:46:17 -0600 Subject: [PATCH 074/174] Improve DeepDream docs --- captum/optim/_core/loss.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 8a4a1a65b9..33c840e037 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -515,9 +515,15 @@ class DeepDream(BaseLoss): Maximize 'interestingness' at the target layer. Mordvintsev et al., 2015. https://github.com/google/deepdream + This loss returns the squared layer activations. When combined with a negative mean loss summarization, this loss will create hallucinogenic visuals commonly referred to as 'Deep Dream'. + + DeepDream tries to increase the values of neurons proportional to the amount + they are presently active. This is equivalent to maximizing the sum of the + squares. If you remove the square, you'd be doing a direciton visualization + of: ``[1,1,1,....]``. """ def __init__( From 6f10b76c5e15639969c339f8dcd2f348595cd6e3 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 15 Jul 2022 11:50:33 -0600 Subject: [PATCH 075/174] Improve doc grammar --- captum/optim/_core/loss.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 33c840e037..5f9e6cf62c 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -522,8 +522,8 @@ class DeepDream(BaseLoss): DeepDream tries to increase the values of neurons proportional to the amount they are presently active. This is equivalent to maximizing the sum of the - squares. If you remove the square, you'd be doing a direciton visualization - of: ``[1,1,1,....]``. + squares. If you remove the square, you'd be visualizing a direction of: + ``[1,1,1,....]`` (which is same as :class:`.LayerActivation`). """ def __init__( From eb5a961481d28720bc84f39b206983bd1d385895 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 15 Jul 2022 14:12:38 -0600 Subject: [PATCH 076/174] Fix nn.Module type hints --- captum/optim/_core/loss.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 5f9e6cf62c..1c4eabc285 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -209,7 +209,7 @@ def __init__( """ Args: - target (nn.Module or list of nn.module): A target nn.Module or list of + target (nn.Module or list of nn.Module): A target nn.Module or list of nn.Module. batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to @@ -339,7 +339,7 @@ def __init__( name (str, optional): The name of all composable operations in the instance. Default: ``""`` - target (nn.Module or list of nn.module): A target nn.Module or list of + target (nn.Module or list of nn.Module): A target nn.Module or list of nn.Module. """ super().__init__(target) @@ -1227,7 +1227,7 @@ def default_loss_summarize(loss_value: torch.Tensor) -> torch.Tensor: """ Helper function to summarize tensor outputs from loss objectives. - default_loss_summarize applies `mean` to the loss tensor + default_loss_summarize applies :func:`torch.mean` to the loss tensor and negates it so that optimizing it maximizes the activations we are interested in. From a66e7f5179a575f928523f8b854c7b54cb2e3874 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 16 Jul 2022 09:15:30 -0600 Subject: [PATCH 077/174] Fix InputOptimization docs --- captum/optim/_core/optimization.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 7d26946e87..0bdfba8b6e 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -53,13 +53,14 @@ class InputOptimization(Objective, Parameterized): :ivar model: initial value (nn.Module): The given model instance given when initializing ``InputOptimization``. - :ivar input_param: initial value (ImageParameterization): The given image + :ivar input_param: initial value (InputParameterization): The given input parameterization instance given when initializing ``InputOptimization``. :ivar loss_function: initial value (Loss): The given composable loss instance given when initializing ``InputOptimization``. :ivar transform: initial value (nn.Module): The given transform instance given when initializing ``InputOptimization``. If it was set to ``None`` during - initialization, then an instance of ``torch.nn.Identity`` will be returned. + initialization, then an instance of :class:`torch.nn.Identity` will be + returned. """ def __init__( @@ -73,12 +74,12 @@ def __init__( Args: model (nn.Module, optional): The reference to PyTorch model instance. + loss_function (callable): The loss function to minimize during + optimization. input_param (nn.Module, optional): A module that generates an input, consumed by the model. transform (nn.Module, optional): A module that transforms or preprocesses the input before being passed to the model. - loss_function (callable): The loss function to minimize during - optimization. """ self.model = model or nn.Identity() # Grab targets from loss_function @@ -139,7 +140,7 @@ def parameters(self) -> Iterable[nn.Parameter]: """ Returns: parameters (iterable of nn.Parameter): An iterable of parameters in the - image parameterization. + input parameterization. """ return self.input_param.parameters() From f7812657a06810f838e4b2aa4ee55bfa942dfe09 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 16 Jul 2022 10:45:12 -0600 Subject: [PATCH 078/174] Fix loss doc type formating --- captum/optim/_core/loss.py | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 1c4eabc285..b3a100b673 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -209,9 +209,9 @@ def __init__( """ Args: - target (nn.Module or list of nn.Module): A target nn.Module or list of + target (nn.Module or List[nn.Module]): A target nn.Module or list of nn.Module. - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -232,7 +232,7 @@ def __init__( def target(self) -> Union[nn.Module, List[nn.Module]]: """ Returns: - target (nn.Module or list of nn.Module): A target nn.Module or list of + target (nn.Module or List[nn.Module]): A target nn.Module or list of nn.Module. """ return self._target @@ -241,7 +241,7 @@ def target(self) -> Union[nn.Module, List[nn.Module]]: def batch_index(self) -> Tuple: """ Returns: - batch_index (tuple of int): A tuple of batch indices with a format + batch_index (Tuple[int]): A tuple of batch indices with a format of: (start, end). """ return self._batch_index @@ -339,7 +339,7 @@ def __init__( name (str, optional): The name of all composable operations in the instance. Default: ``""`` - target (nn.Module or list of nn.Module): A target nn.Module or list of + target (nn.Module or List[nn.Module]): A target nn.Module or list of nn.Module. """ super().__init__(target) @@ -395,7 +395,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -429,7 +429,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. channel_index (int): The index of the channel to optimize for. - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -482,7 +482,7 @@ def __init__( unspecified, defaults to center, or one unit up of center for even heights. Default: ``None`` - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -536,7 +536,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -571,7 +571,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -605,7 +605,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. constant (float): Constant threshold to deduct from the activations. - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -642,7 +642,7 @@ def __init__( Default: ``0.0`` eps (float): Small value to add to L2 prior to sqrt. Default: ``1e-6`` - batch_index (int or list of int, optional): The index or index range of + batch_index (int or List[int], optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -681,11 +681,13 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (list of int, optional): The index range of activations to + batch_index (List[int], optional): The index range of activations to optimize. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: ``None`` """ + if batch_index: + assert len(batch_index) == 2 BaseLoss.__init__(self, target, batch_index) def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: @@ -799,7 +801,7 @@ def __init__( decay_ratio (float): How much to decay penalty as images move apart in the batch. Default: ``2.0`` - batch_index (list of int, optional): The index range of activations to + batch_index (List[int], optional): The index range of activations to optimize. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: ``None`` From 44260036a1649ca86f1eff8f1afe9f12f2764ccb Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 16 Jul 2022 10:52:42 -0600 Subject: [PATCH 079/174] Fix clip objective doc type formatting --- captum/optim/_core/loss.py | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 8c9011e8a2..5f10ddafcb 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -857,7 +857,7 @@ def __init__( target: torch.nn.Module, channel_index: Optional[int] = None, constant: float = 0.5, - batch_index: Optional[int] = None, + batch_index: Optional[Union[int, List[int]]] = None, ) -> None: """ Args: @@ -869,9 +869,10 @@ def __init__( Default: ``None`` constant (float, optional): Constant value to deduct from the activations. Default: ``0.5`` - batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to ``None``, defaults to all - activations in the batch. + batch_index (int or List[int], optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set + to ``None``, defaults to all activations in the batch. Index ranges + should be in the format of: [start, end]. Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) @@ -910,7 +911,7 @@ def __init__( vec: torch.Tensor, activation_fn: Optional[Callable] = torch.nn.functional.relu, move_channel_dim_to_final_dim: bool = True, - batch_index: Optional[int] = None, + batch_index: Optional[Union[int, List[int]]] = None, ) -> None: """ Args: @@ -926,9 +927,10 @@ def __init__( channel dimension to the last dimension before computing the matrix product. Set to ``False`` if the using the channels last format. Default: ``True`` - batch_index (int, optional): The index of activations to optimize if - optimizing a batch of activations. If set to ``None``, defaults to all - activations in the batch. + batch_index (int or List[int], optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set + to ``None``, defaults to all activations in the batch. Index ranges + should be in the format of: [start, end]. Default: ``None`` """ BaseLoss.__init__(self, target, batch_index) @@ -984,16 +986,17 @@ def __init__( facet_weights (torch.Tensor): Weighting that steers the objective towards a particular theme or concept. These weight values should come from linear probes trained on ``layer_target``. - strength (float, list of float, optional): A single float or list of floats + strength (float, List[float], optional): A single float or list of floats to use for batch dimension weighting. If using a single value, then it will be applied to all batch dimensions equally. Otherwise a list of floats with a shape of: [start, end] should be used for :func:`torch.linspace` to calculate the step values in between. Default is set to ``None`` for no weighting. Default: ``None`` - batch_index (int, optional): The index of the activations to optimize if - optimizing a batch of activations. If set to ``None``, defaults to all - activations in the batch. + batch_index (int or List[int], optional): The index or index range of + activations to optimize if optimizing a batch of activations. If set + to ``None``, defaults to all activations in the batch. Index ranges + should be in the format of: [start, end]. Default: ``None`` """ BaseLoss.__init__(self, [ultimate_target, layer_target], batch_index) From 936bc84f2e3fae8f330a77b1d159b0e57900518a Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 16 Jul 2022 14:12:02 -0600 Subject: [PATCH 080/174] Update _common.py --- captum/optim/models/_common.py | 52 ++++++++++++++++++++-------------- 1 file changed, 30 insertions(+), 22 deletions(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 4b460058f8..6ced882ce8 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -16,6 +16,9 @@ def get_model_layers(model: nn.Module) -> List[str]: Args: model (nn.Module): A PyTorch model or module instance to collect layers from. + + Returns: + model_layers (List[str]): A list of hookable layers in the model. """ layers = [] @@ -68,6 +71,14 @@ class RedirectedReluLayer(nn.Module): @torch.jit.ignore def forward(self, input: torch.Tensor) -> torch.Tensor: + """ + Args: + + x (torch.Tensor): A tensor to pass through RedirectedReLU. + + Returns: + x (torch.Tensor): The output of RedirectedReLU. + """ return RedirectedReLU.apply(input) @@ -218,7 +229,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: """ Args: - x (torch.tensor): The input tensor to apply 2D convolution to. + x (torch.Tensor): The input tensor to apply 2D convolution to. Returns x (torch.Tensor): The input tensor after the 2D convolution was applied. @@ -254,7 +265,7 @@ def collect_activations( Args: model (nn.Module): A PyTorch model instance. - targets (nn.Module or list of nn.Module): One or more layer targets for the + targets (nn.Module or List[nn.Module]): One or more layer targets for the given model. model_input (torch.Tensor or tuple of torch.Tensor, optional): Optionally provide an input tensor to use when collecting the target activations. @@ -278,9 +289,9 @@ class SkipLayer(torch.nn.Module): during the forward pass. Use cases include removing nonlinear activation layers like ReLU for circuits research. - This layer works almost exactly the same way that ``nn.Indentiy`` does, except it - also ignores any additional arguments passed to the forward function. Any layer - replaced by ``SkipLayer`` must have the same input and output shapes. + This layer works almost exactly the same way that nn.Indentiy does, except it also + ignores any additional arguments passed to the forward function. Any layer replaced + by SkipLayer must have the same input and output shapes. See nn.Identity for more details: https://pytorch.org/docs/stable/generated/torch.nn.Identity.html @@ -290,24 +301,23 @@ def __init__(self, *args, **kwargs) -> None: """ Args: - args (Any): Any argument. Arguments will be safely ignored. - kwargs (Any) Any keyword argument. Arguments will be safely ignored. + args (Any, optional): Any argument. Arguments will be safely ignored. + kwargs (Any, optional) Any keyword argument. Arguments will be safely + ignored. """ super().__init__() - def forward( - self, x: Union[torch.Tensor, Tuple[torch.Tensor]], *args, **kwargs - ) -> Union[torch.Tensor, Tuple[torch.Tensor]]: + def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor: """ Args: - x (torch.Tensor or tuple of torch.Tensor): The input tensor or tensors. - args (Any): Any argument. Arguments will be safely ignored. - kwargs (Any) Any keyword argument. Arguments will be safely ignored. + x (torch.Tensor): The input tensor. + args (Any, optional): Any argument. Arguments will be safely ignored. + kwargs (Any, optional) Any keyword argument. Arguments will be safely + ignored. Returns: - x (torch.Tensor or tuple of torch.Tensor): The unmodified input tensor or - tensors. + x (torch.Tensor): The unmodified input tensor. """ return x @@ -316,17 +326,15 @@ def skip_layers( model: nn.Module, layers: Union[List[Type[nn.Module]], Type[nn.Module]] ) -> None: """ - This function is a wrapper function for - replace_layers and replaces the target layer - with layers that do nothing. - This is useful for removing the nonlinear ReLU - layers when creating expanded weights. + This function is a wrapper function for :func:`.replace_layers` and replaces the + target layer with layers that do nothing. This is useful for removing the nonlinear + ReLU layers when creating expanded weights. Args: model (nn.Module): A PyTorch model instance. - layers (nn.Module or list of nn.Module): The layer - class type to replace in the model. + layers (nn.Module or List[nn.Module]): The layer class type to replace in the + model. """ if not hasattr(layers, "__iter__"): layers = cast(Type[nn.Module], layers) From 42b18ca47f708cc553b8c047e9ebf180c7103ca5 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 17 Jul 2022 08:54:40 -0600 Subject: [PATCH 081/174] Add more assert checks --- captum/optim/_core/loss.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index b3a100b673..1d6f26c5d0 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -687,6 +687,7 @@ def __init__( Default: ``None`` """ if batch_index: + assert isinstance(batch_index, (list, tuple)) assert len(batch_index) == 2 BaseLoss.__init__(self, target, batch_index) @@ -807,6 +808,7 @@ def __init__( Default: ``None`` """ if batch_index: + assert isinstance(batch_index, (list, tuple)) assert len(batch_index) == 2 BaseLoss.__init__(self, target, batch_index) self.decay_ratio = decay_ratio From 96e2f8d016d619637c07b9c3c4093391d77890de Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 17 Jul 2022 12:17:25 -0600 Subject: [PATCH 082/174] Add aliases to InputOptimization and ImageTensor docs --- captum/optim/_core/optimization.py | 2 ++ captum/optim/_param/image/images.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 0bdfba8b6e..5636b63dbf 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -37,6 +37,8 @@ class InputOptimization(Objective, Parameterized): * https://github.com/tensorflow/lucid * https://distill.pub/2017/feature-visualization/ + Alias: ``captum.optim.InputOptimization`` + Example:: >>> model = opt.models.googlenet(pretrained=True) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 5bb8555a17..ee50396572 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -25,6 +25,8 @@ class ImageTensor(torch.Tensor): A subclass of torch.Tensor that provides functions for easy loading, saving, and displaying image tensors. + Alias: ``captum.optim.ImageTensor`` + Example using file path or URL:: >>> image_tensor = opt.images.ImageTensor.load() From f31b8ca2dbbb28e47b4d23532674f76f726b7cf4 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 17 Jul 2022 14:27:46 -0600 Subject: [PATCH 083/174] Improve MaxPool2dRelaxed docs --- captum/optim/models/_common.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 6ced882ce8..3032bc4cf6 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -289,9 +289,9 @@ class SkipLayer(torch.nn.Module): during the forward pass. Use cases include removing nonlinear activation layers like ReLU for circuits research. - This layer works almost exactly the same way that nn.Indentiy does, except it also - ignores any additional arguments passed to the forward function. Any layer replaced - by SkipLayer must have the same input and output shapes. + This layer works almost exactly the same way that :class:`torch.nn.Identity` does, + except it also ignores any additional arguments passed to the forward function. + Any layer replaced by SkipLayer must have the same input and output shapes. See nn.Identity for more details: https://pytorch.org/docs/stable/generated/torch.nn.Identity.html @@ -355,9 +355,10 @@ class MaxPool2dRelaxed(torch.nn.Module): attributions of spatial posititions can be estimated using the rate at which increasing the neuron affects the output classes. - This layer peforms a MaxPool2d operation on the input, while using an equivalent - AvgPool2d layer to compute the gradient. This means that the forward pass returns - nn.MaxPool2d(input) while the backward pass uses nn.AvgPool2d(input). + This layer peforms a :class:`torch.nn.MaxPool2d` operation on the input, while + using an equivalent :class:`torch.nn.AvgPool2d` layer to compute the gradient. + This means that the forward pass returns ``nn.MaxPool2d(input)`` while the + backward pass uses ``nn.AvgPool2d(input)``. Carter, et al., "Activation Atlas", Distill, 2019. https://distill.pub/2019/activation-atlas/ From 199509ef6d091abb31b854c50c21606ca851064e Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 18 Jul 2022 15:07:50 -0600 Subject: [PATCH 084/174] Improve docstring type formatting --- captum/optim/_core/optimization.py | 44 +++++++++---------- captum/optim/_param/image/images.py | 8 ++-- captum/optim/models/_common.py | 24 +++++----- .../models/_image/inception_v1_places365.py | 10 ++--- 4 files changed, 43 insertions(+), 43 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 5636b63dbf..8b41e757fa 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -1,5 +1,3 @@ -"""captum.optim.optimization.""" - import warnings from typing import Callable, Iterable, Optional @@ -49,20 +47,6 @@ class InputOptimization(Objective, Parameterized): >>> obj = opt.InputOptimization(model, loss_fn, image, transform) >>> history = obj.optimize(opt.optimization.n_steps(512)) >>> image().show(figsize=(10, 10)) # Display results - - Instance variables that be used in the optimize function and StopCriteria - functions: - - :ivar model: initial value (nn.Module): The given model instance given when - initializing ``InputOptimization``. - :ivar input_param: initial value (InputParameterization): The given input - parameterization instance given when initializing ``InputOptimization``. - :ivar loss_function: initial value (Loss): The given composable loss instance - given when initializing ``InputOptimization``. - :ivar transform: initial value (nn.Module): The given transform instance given - when initializing ``InputOptimization``. If it was set to ``None`` during - initialization, then an instance of :class:`torch.nn.Identity` will be - returned. """ def __init__( @@ -76,12 +60,28 @@ def __init__( Args: model (nn.Module, optional): The reference to PyTorch model instance. - loss_function (callable): The loss function to minimize during - optimization. + loss_function (callable): The :mod:`.loss` objective instance to minimize + during optimization. input_param (nn.Module, optional): A module that generates an input, consumed by the model. transform (nn.Module, optional): A module that transforms or preprocesses the input before being passed to the model. + + Instance variables that be used in the :func:`.optimize` function and + StopCriteria functions: + + Attributes: + + model (torch.nn.Module): The given model instance given when initializing + ``InputOptimization``. If ``model`` was set to ``None`` during + initialization, then an instance of :class:`torch.nn.Identity` will be + returned. + input_param (InputParameterization): The given input parameterization + instance given when initializing ``InputOptimization``. + loss_function (Loss): The composable :mod:`.loss` instance given when + initializing ``InputOptimization``. + transform (torch.nn.Module): The given transform instance given when + initializing ``InputOptimization``. """ self.model = model or nn.Identity() # Grab targets from loss_function @@ -141,8 +141,8 @@ def targets(self, value: Iterable[nn.Module]) -> None: def parameters(self) -> Iterable[nn.Parameter]: """ Returns: - parameters (iterable of nn.Parameter): An iterable of parameters in the - input parameterization. + parameters (iterable of torch.nn.Parameter): An iterable of parameters in + the input parameterization. """ return self.input_param.parameters() @@ -164,10 +164,10 @@ def optimize( optimizer (torch.optim.Optimizer, optional): A ``torch.optim.Optimizer`` instance to use for optimizing the input based on the loss function. Default: ``torch.optim.Adam`` - loss_summarize_fn (Callable, optional): The function to use for summarizing + loss_summarize_fn (callable, optional): The function to use for summarizing tensor outputs from loss functions. Default: ``default_loss_summarize`` - lr: (float, optional): If no optimizer is given, then lr is used as the + lr (float, optional): If no optimizer is given, then lr is used as the learning rate for the Adam optimizer. Default: ``0.025`` diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index ee50396572..16e5f625e0 100644 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -22,8 +22,8 @@ class ImageTensor(torch.Tensor): r""" - A subclass of torch.Tensor that provides functions for easy loading, saving, and - displaying image tensors. + A subclass of :class:`torch.Tensor` that provides functions for easy loading, + saving, and displaying image tensors. Alias: ``captum.optim.ImageTensor`` @@ -138,8 +138,8 @@ def show( Args: - figsize (Tuple[int, int], optional): height & width to use - for displaying the ``ImageTensor`` figure. + figsize (tuple of int, optional): The height & width to use for displaying + the ``ImageTensor`` figure, in the format of: (height, width). Default: ``None`` scale (float, optional): Value to multiply the ``ImageTensor`` by so that it's value range is [0-255] for display. diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 3032bc4cf6..8b6695b33b 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -18,7 +18,7 @@ def get_model_layers(model: nn.Module) -> List[str]: model (nn.Module): A PyTorch model or module instance to collect layers from. Returns: - model_layers (List[str]): A list of hookable layers in the model. + model_layers (list of str): A list of hookable layers in the model. """ layers = [] @@ -101,16 +101,16 @@ def replace_layers( Args: - model: (nn.Module): A PyTorch model instance. - layer1: (Type[nn.Module]): The layer class that you want to transfer + model (nn.Module): A PyTorch model instance. + layer1 (Type[nn.Module]): The layer class that you want to transfer initialization variables from. - layer2: (Type[nn.Module]): The layer class to create with the variables + layer2 (Type[nn.Module]): The layer class to create with the variables from ``layer1``. transfer_vars (bool, optional): Whether or not to try and copy initialization variables from ``layer1`` instances to the replacement ``layer2`` instances. Default: ``False`` - kwargs: (Any, optional): Any additional variables to use when creating + kwargs (Any, optional): Any additional variables to use when creating the new layer. """ @@ -134,11 +134,11 @@ def _transfer_layer_vars( Args: - layer1: (nn.Module): A layer instance that you want to transfer + layer1 (nn.Module): A layer instance that you want to transfer initialization variables from. - layer2: (nn.Module): The layer class to create with the variables + layer2 (nn.Module): The layer class to create with the variables from of layer1. - kwargs: (Any, optional): Any additional variables to use when creating + kwargs (Any, optional): Any additional variables to use when creating the new layer. Returns: @@ -265,7 +265,7 @@ def collect_activations( Args: model (nn.Module): A PyTorch model instance. - targets (nn.Module or List[nn.Module]): One or more layer targets for the + targets (nn.Module or list of nn.Module): One or more layer targets for the given model. model_input (torch.Tensor or tuple of torch.Tensor, optional): Optionally provide an input tensor to use when collecting the target activations. @@ -333,7 +333,7 @@ def skip_layers( Args: model (nn.Module): A PyTorch model instance. - layers (nn.Module or List[nn.Module]): The layer class type to replace in the + layers (nn.Module or list of nn.Module): The layer class type to replace in the model. """ if not hasattr(layers, "__iter__"): @@ -382,8 +382,8 @@ def __init__( """ Args: - kernel_size (int or tuple of int): The size of the window to perform max & - average pooling with. + kernel_size (int or tuple of int): The size of the window to perform max + and average pooling with. stride (int or tuple of int, optional): The stride window size to use. Default: ``None`` padding (int or tuple of int): The amount of zero padding to add to both diff --git a/captum/optim/models/_image/inception_v1_places365.py b/captum/optim/models/_image/inception_v1_places365.py index 81bb7b98c1..62a6834e16 100644 --- a/captum/optim/models/_image/inception_v1_places365.py +++ b/captum/optim/models/_image/inception_v1_places365.py @@ -39,7 +39,7 @@ def googlenet_places365( model_path (str, optional): Optional path for the InceptionV1 model file. Default: ``None`` replace_relus_with_redirectedrelu (bool, optional): If ``True``, return - pretrained model with Redirected ReLU in place of ReLU layers. + pretrained model with :class:`.RedirectedReLU` in place of ReLU layers. Default: *``True``* when pretrained is True otherwise *``False``* use_linear_modules_only (bool, optional): If ``True``, return pretrained model with all nonlinear layers replaced with linear equivalents. @@ -112,7 +112,7 @@ def __init__( according to the method with which it was trained on Places365. Default: ``True`` replace_relus_with_redirectedrelu (bool, optional): If ``True``, return - pretrained model with Redirected ReLU in place of ReLU layers. + pretrained model with :class:`.RedirectedReLU` in place of ReLU layers. Default: ``False`` use_linear_modules_only (bool, optional): If ``True``, return pretrained model with all nonlinear layers replaced with linear equivalents. @@ -306,10 +306,10 @@ def __init__( in the pool branch. activ (type of nn.Module, optional): The nn.Module class type to use for activation layers. - Default: ``nn.ReLU`` + Default: :class:`torch.nn.ReLU` p_layer (type of nn.Module, optional): The nn.Module class type to use for pooling layers. - Default: ``nn.MaxPool2d`` + Default: :class:`torch.nn.MaxPool2d` """ super().__init__() self.conv_1x1 = nn.Conv2d( @@ -409,7 +409,7 @@ def __init__( Default: ``1008`` activ (type of nn.Module, optional): The ``nn.Module`` class type to use for activation layers. - Default: ``nn.ReLU`` + Default: :class:`torch.nn.ReLU` """ super().__init__() self.avg_pool = nn.AdaptiveAvgPool2d((4, 4)) From 2480b6925aa3413aec60f1936aceeea67fbe5159 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 18 Jul 2022 15:18:00 -0600 Subject: [PATCH 085/174] Fix loss docstring type hint formatting --- captum/optim/_core/loss.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 5f10ddafcb..0cc6033fd4 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -869,7 +869,7 @@ def __init__( Default: ``None`` constant (float, optional): Constant value to deduct from the activations. Default: ``0.5`` - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -919,7 +919,7 @@ def __init__( target (nn.Module): A target layer instance. vec (torch.Tensor): A 1D channel vector with the same size as the channel / feature dimension of the target layer instance. - activation_fn (Callable, optional): An optional activation function to + activation_fn (callable, optional): An optional activation function to apply to the activations before computing the matrix product. If set to ``None``, then no activation function will be used. Default: ``torch.nn.functional.relu`` @@ -927,7 +927,7 @@ def __init__( channel dimension to the last dimension before computing the matrix product. Set to ``False`` if the using the channels last format. Default: ``True`` - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -986,14 +986,14 @@ def __init__( facet_weights (torch.Tensor): Weighting that steers the objective towards a particular theme or concept. These weight values should come from linear probes trained on ``layer_target``. - strength (float, List[float], optional): A single float or list of floats + strength (float, list of float, optional): A single float or list of floats to use for batch dimension weighting. If using a single value, then it will be applied to all batch dimensions equally. Otherwise a list of floats with a shape of: [start, end] should be used for :func:`torch.linspace` to calculate the step values in between. Default is set to ``None`` for no weighting. Default: ``None`` - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. From a9eabfd446f4e1bdeb29e5e93aecc24fbe1fcc1d Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 18 Jul 2022 15:18:33 -0600 Subject: [PATCH 086/174] Fix loss docstring type hint formatting --- captum/optim/_core/loss.py | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 1d6f26c5d0..5c534613f2 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -209,9 +209,9 @@ def __init__( """ Args: - target (nn.Module or List[nn.Module]): A target nn.Module or list of + target (nn.Module or list of nn.Module): A target nn.Module or list of nn.Module. - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -232,7 +232,7 @@ def __init__( def target(self) -> Union[nn.Module, List[nn.Module]]: """ Returns: - target (nn.Module or List[nn.Module]): A target nn.Module or list of + target (nn.Module or list of nn.Module): A target nn.Module or list of nn.Module. """ return self._target @@ -241,7 +241,7 @@ def target(self) -> Union[nn.Module, List[nn.Module]]: def batch_index(self) -> Tuple: """ Returns: - batch_index (Tuple[int]): A tuple of batch indices with a format + batch_index (tuple of int): A tuple of batch indices with a format of: (start, end). """ return self._batch_index @@ -333,13 +333,13 @@ def __init__( """ Args: - loss_fn (Callable): A function that takes a dict of captured activations + loss_fn (callable): A function that takes a dict of captured activations with nn.Modules as keys, and then passes those activations through loss objective(s) & math operations. name (str, optional): The name of all composable operations in the instance. Default: ``""`` - target (nn.Module or List[nn.Module]): A target nn.Module or list of + target (nn.Module or list of nn.Module): A target nn.Module or list of nn.Module. """ super().__init__(target) @@ -395,7 +395,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -429,7 +429,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. channel_index (int): The index of the channel to optimize for. - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -482,7 +482,7 @@ def __init__( unspecified, defaults to center, or one unit up of center for even heights. Default: ``None`` - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -536,7 +536,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -571,7 +571,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -605,7 +605,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. constant (float): Constant threshold to deduct from the activations. - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -642,7 +642,7 @@ def __init__( Default: ``0.0`` eps (float): Small value to add to L2 prior to sqrt. Default: ``1e-6`` - batch_index (int or List[int], optional): The index or index range of + batch_index (int or list of int, optional): The index or index range of activations to optimize if optimizing a batch of activations. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. @@ -681,7 +681,7 @@ def __init__( target (nn.Module): A target layer, transform, or image parameterization instance to optimize the output of. - batch_index (List[int], optional): The index range of activations to + batch_index (list of int, optional): The index range of activations to optimize. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: ``None`` @@ -802,7 +802,7 @@ def __init__( decay_ratio (float): How much to decay penalty as images move apart in the batch. Default: ``2.0`` - batch_index (List[int], optional): The index range of activations to + batch_index (list of int, optional): The index range of activations to optimize. If set to ``None``, defaults to all activations in the batch. Index ranges should be in the format of: [start, end]. Default: ``None`` @@ -1188,9 +1188,10 @@ def sum_loss_list( Args: loss_list (list): A list of loss objectives. - to_scalar_fn (Callable): A function for converting loss objective outputs to - scalar values, in order to prevent size mismatches. - Default: ``torch.mean`` + to_scalar_fn (callable): A function for converting loss objective outputs to + scalar values, in order to prevent size mismatches. Set to + :class:`torch.nn.Identity` for no reduction op. + Default: :func:`torch.mean` Returns: loss_fn (CompositeLoss): A CompositeLoss instance containing all the loss From f2f1d5d3eccacc2201c8c50448f7570ea9f72773 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 18 Jul 2022 15:28:14 -0600 Subject: [PATCH 087/174] Fix bug in skip_layers --- captum/optim/models/_common.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 8b6695b33b..5f3cb7677a 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -275,7 +275,7 @@ def collect_activations( activ_dict (ModuleOutputMapping): A dictionary of collected activations where the keys are the target layers. """ - if not isinstance(targets, list): + if not isinstance(targets, (list, tuple)): targets = [targets] targets = list(dict.fromkeys(targets)) catch_activ = ActivationFetcher(model, targets) @@ -336,7 +336,7 @@ def skip_layers( layers (nn.Module or list of nn.Module): The layer class type to replace in the model. """ - if not hasattr(layers, "__iter__"): + if not isinstance(layers, (tuple, list)): layers = cast(Type[nn.Module], layers) replace_layers(model, layers, SkipLayer) else: From a61461bb424a012f95329ffaebc3f4cf3791d6a9 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 20 Jul 2022 13:34:59 -0600 Subject: [PATCH 088/174] Improve optimization docs --- captum/optim/_core/optimization.py | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 8b41e757fa..508f235534 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -59,16 +59,19 @@ def __init__( r""" Args: - model (nn.Module, optional): The reference to PyTorch model instance. - loss_function (callable): The :mod:`.loss` objective instance to minimize - during optimization. - input_param (nn.Module, optional): A module that generates an input, - consumed by the model. + model (nn.Module, optional): The reference to PyTorch model instance. Set + to ``None`` for no model instance. + loss_function (callable): The :mod:`Loss <.loss>` objective instance to + minimize during optimization. + input_param (InputParameterization, optional): A module that generates an + input, consumed by the model. Example: An + :mod:`ImageParameterization ` instance. transform (nn.Module, optional): A module that transforms or preprocesses - the input before being passed to the model. + the input before being passed to the model. Set to + :class:`torch.nn.Identity` for no transforms. - Instance variables that be used in the :func:`.optimize` function and - StopCriteria functions: + Instance variables that be used in the :func:`InputOptimization.optimize` + function, custom optimization functions, and StopCriteria functions: Attributes: @@ -78,8 +81,8 @@ def __init__( returned. input_param (InputParameterization): The given input parameterization instance given when initializing ``InputOptimization``. - loss_function (Loss): The composable :mod:`.loss` instance given when - initializing ``InputOptimization``. + loss_function (Loss): The composable :mod:`Loss <.loss>` instance given + when initializing ``InputOptimization``. transform (torch.nn.Module): The given transform instance given when initializing ``InputOptimization``. """ From 0ecff5d546ca27dd5f10e9db3f54ecfc6a3c5938 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 20 Jul 2022 14:01:34 -0600 Subject: [PATCH 089/174] Improve InputOptimization.optimize's docstring --- captum/optim/_core/optimization.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 508f235534..541c1d8078 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -156,20 +156,20 @@ def optimize( loss_summarize_fn: Optional[Callable] = None, lr: float = 0.025, ) -> torch.Tensor: - r"""Optimize input based on loss function and objectives. + r"""Optimize input based on loss function and objectives. Args: stop_criteria (StopCriteria, optional): A function that is called every iteration and returns a bool that determines whether to stop the optimization. - Default: ``n_steps(512)`` + Default: :func:`n_steps(512) <.n_steps>` optimizer (torch.optim.Optimizer, optional): A ``torch.optim.Optimizer`` instance to use for optimizing the input based on the loss function. - Default: ``torch.optim.Adam`` + Default: :class:`torch.optim.Adam` loss_summarize_fn (callable, optional): The function to use for summarizing tensor outputs from loss functions. - Default: ``default_loss_summarize`` + Default: :func:`.default_loss_summarize` lr (float, optional): If no optimizer is given, then lr is used as the learning rate for the Adam optimizer. Default: ``0.025`` From aeb058d291ea089aecb5b047f0266590c0e88419 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 21 Jul 2022 11:12:15 -0600 Subject: [PATCH 090/174] Improve InputOptimization docs --- captum/optim/_core/optimization.py | 4 ++-- captum/optim/models/_common.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 541c1d8078..0aac927116 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -29,8 +29,8 @@ class InputOptimization(Objective, Parameterized): """ Core function that optimizes an input to maximize a target (aka objective). This is similar to gradient-based methods for adversarial examples, such - as FGSM. The code for this was based on the implementation by the authors of Lucid. - For more details, see the following: + as :class:`FGSM `. The code for this was based on the + implementation by the authors of Lucid. For more details, see the following: * https://github.com/tensorflow/lucid * https://distill.pub/2017/feature-visualization/ diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 5f3cb7677a..8fcc2a978a 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -272,8 +272,8 @@ def collect_activations( Default: ``torch.zeros(1, 3, 224, 224)`` Returns: - activ_dict (ModuleOutputMapping): A dictionary of collected activations where - the keys are the target layers. + activ_dict (dict[nn.Module, torch.Tensor]): A dictionary of collected + activations where the keys are the target layers. """ if not isinstance(targets, (list, tuple)): targets = [targets] From 1faadcda863f6f3a532ba8bb4d5ca2ab2dbbe36e Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 21 Jul 2022 11:21:28 -0600 Subject: [PATCH 091/174] Fix doc spacing --- captum/optim/_core/optimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 0aac927116..84b3b10a0f 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -156,7 +156,7 @@ def optimize( loss_summarize_fn: Optional[Callable] = None, lr: float = 0.025, ) -> torch.Tensor: - r"""Optimize input based on loss function and objectives. + r"""Optimize input based on loss function and objectives. Args: From a7fb6d941ce3edb6a5bccb3417c2a413185e8fa5 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 21 Jul 2022 12:45:50 -0600 Subject: [PATCH 092/174] Max line length doesn't apply to urls --- captum/optim/_core/loss.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 5c534613f2..c48539151a 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -957,10 +957,8 @@ class AngledNeuronDirection(BaseLoss): https://github.com/tensorflow/lucid/issues/116 This Lucid equivalents of this loss objective can be found here: - https://github.com/tensorflow/lucid/blob/master/notebooks/ - activation-atlas/activation-atlas-simple.ipynb - https://github.com/tensorflow/lucid/blob/master/notebooks/ - activation-atlas/class-activation-atlas.ipynb + https://github.com/tensorflow/lucid/blob/master/notebooks/activation-atlas/activation-atlas-simple.ipynb + https://github.com/tensorflow/lucid/blob/master/notebooks/activation-atlas/class-activation-atlas.ipynb Like the Lucid equivalents, our implementation differs slightly from the associated research paper. From 2cfa21be999a54e4b47984ea5dfd74c0f7b000cf Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 21 Jul 2022 19:35:16 -0600 Subject: [PATCH 093/174] Add Optim to run_mypy.sh --- scripts/run_mypy.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/run_mypy.sh b/scripts/run_mypy.sh index d2f7c8d076..2497be44bc 100755 --- a/scripts/run_mypy.sh +++ b/scripts/run_mypy.sh @@ -5,6 +5,7 @@ set -e # hints. mypy -p captum.attr --ignore-missing-imports --allow-redefinition +mypy -p captum.optim --ignore-missing-imports --allow-redefinition mypy -p captum.insights --ignore-missing-imports --allow-redefinition mypy -p captum.metrics --ignore-missing-imports --allow-redefinition mypy -p captum.robust --ignore-missing-imports --allow-redefinition From 6a40ca60a248d797bae63cb6be6b961a586f9051 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 25 Jul 2022 15:18:57 -0700 Subject: [PATCH 094/174] Don't link directly to arXiv PDF files in algorithms.md (#995) Summary: arXiv offers multiple options for viewing a paper, so it's best to let the user decide which one they want. Pull Request resolved: https://github.com/pytorch/captum/pull/995 Reviewed By: Reubend Differential Revision: D38026675 Pulled By: NarineK fbshipit-source-id: 5846218c6cce8d985f79f4375306bf44f5be41b4 --- docs/algorithms.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/algorithms.md b/docs/algorithms.md index 80d50550a0..b06a8aa5f1 100644 --- a/docs/algorithms.md +++ b/docs/algorithms.md @@ -37,7 +37,7 @@ To learn more about GradientSHAP, visit the following resources: - [Original Implementation](https://github.com/slundberg/shap/#deep-learning-example-with-gradientexplainer-tensorflowkeraspytorch-models) ### DeepLIFT -DeepLIFT is a back-propagation based approach that attributes a change to inputs based on the differences between the inputs and corresponding references (or baselines) for non-linear activations. As such, DeepLIFT seeks to explain the difference in the output from reference in terms of the difference in inputs from reference. DeepLIFT uses the concept of multipliers to "blame" specific neurons for the difference in output. The definition of a multiplier is as follows (from [original paper](https://arxiv.org/pdf/1704.02685.pdf)): +DeepLIFT is a back-propagation based approach that attributes a change to inputs based on the differences between the inputs and corresponding references (or baselines) for non-linear activations. As such, DeepLIFT seeks to explain the difference in the output from reference in terms of the difference in inputs from reference. DeepLIFT uses the concept of multipliers to "blame" specific neurons for the difference in output. The definition of a multiplier is as follows (from [original paper](https://arxiv.org/abs/1704.02685)): ![deepLIFT_eq1](/img/deepLIFT_multipliers_eq1.png) *x is the input neuron with a difference from reference Δx, and t is the target neuron with a difference from reference Δt. C is then the contribution of Δx to Δt.* @@ -62,7 +62,7 @@ To learn more about DeepLIFT SHAP, visit the following resources: Saliency is a simple approach for computing input attribution, returning the gradient of the output with respect to the input. This approach can be understood as taking a first-order Taylor expansion of the network at the input, and the gradients are simply the coefficients of each feature in the linear representation of the model. The absolute value of these coefficients can be taken to represent feature importance. To learn more about Saliency, visit the following resources: -- [Original paper](https://arxiv.org/pdf/1312.6034.pdf) +- [Original paper](https://arxiv.org/abs/1312.6034) ### Input X Gradient Input X Gradient is an extension of the saliency approach, taking the gradients of the output with respect to the input and multiplying by the input feature values. One intuition for this approach considers a linear model; the gradients are simply the coefficients of each input, and the product of the input with a coefficient corresponds to the total contribution of the feature to the linear model's output. @@ -141,17 +141,17 @@ Conductance combines the neuron activation with the partial derivatives of both Conductance builds on Integrated Gradients (IG) by looking at the flow of IG attribution which occurs through the hidden neuron. The formal definition of total conductance of a hidden neuron *y* (from the [original paper](https://arxiv.org/abs/1805.12233)) is as follows: ![conductance_eq1](/img/conductance_eq_1.png) -For more efficient computation of layer conductance, we use the idea presented in this [paper](https://arxiv.org/pdf/1807.09946.pdf) to avoid computing the gradient of each neuron with respect to the input. +For more efficient computation of layer conductance, we use the idea presented in this [paper](https://arxiv.org/abs/1807.09946) to avoid computing the gradient of each neuron with respect to the input. To learn more about Conductance, visit the following resources: - [Original Paper](https://arxiv.org/abs/1805.12233) -- [Computationally Efficient Measures of Internal Neuron Importance](https://arxiv.org/pdf/1807.09946.pdf) +- [Computationally Efficient Measures of Internal Neuron Importance](https://arxiv.org/abs/1807.09946) ### Internal Influence Internal Influence approximates the integral of gradients with respect to a particular layer along the path from a baseline input to the given input. This method is similar to applying integrated gradients, integrating the gradient with respect to the layer (rather than the input). To learn more about Internal Influence, visit the following resources: -- [Original Paper](https://arxiv.org/pdf/1802.03788.pdf) +- [Original Paper](https://arxiv.org/abs/1802.03788) ### Layer Activation Layer Activation is a simple approach for computing layer attribution, returning the activation of each neuron in the identified layer. @@ -208,7 +208,7 @@ Note that based on this definition, summing the neuron conductance (over all inp To learn more about Conductance, visit the following resources: - [Original Paper](https://arxiv.org/abs/1805.12233) -- [Computationally Efficient Measures of Internal Neuron Importance](https://arxiv.org/pdf/1807.09946.pdf) +- [Computationally Efficient Measures of Internal Neuron Importance](https://arxiv.org/abs/1807.09946) ### Neuron Gradient Neuron gradient is the analog of the saliency method for a particular neuron in a network. It simply computes the gradient of the neuron output with respect to the model input. Like Saliency, this approach can be understood as taking a first-order Taylor expansion of the neuron's output at the given input, and the gradients correspond to the coefficients of each feature in the linear representation of the model. @@ -259,9 +259,9 @@ To learn more about Noise Tunnel methods, visit the following resources: Infidelity measures the mean squared error between model explanations in the magnitudes of input perturbations and predictor function's changes to those input perturbtaions. Infidelity is defined as follows: ![infidelity_eq](/img/infidelity_eq.png) It is derived from the completeness property of well-known attribution algorithms, such as Integrated Gradients, and is a computationally more efficient and generalized notion of Sensitivy-n. The latter measures correlations between the sum of the attributions and the differences of the predictor function at its input and fixed baseline. More details about the Sensitivity-n can be found here: -https://arxiv.org/pdf/1711.06104.pdfs +https://arxiv.org/abs/1711.06104 More details about infidelity measure can be found here: -- [Original paper](https://arxiv.org/pdf/1901.09392.pdf) +- [Original paper](https://arxiv.org/abs/1901.09392) ### Sensitivity Sensitivity measures the degree of explanation changes to subtle input perturbations using Monte Carlo sampling-based approximation and is defined @@ -270,4 +270,4 @@ as follows: In order to approximate sensitivity measure, by default, we sample from a sub-space of an L-Infinity ball with a default radius. The users can modify both the radius of the ball and the sampling function. More details about sensitivity measure can be found here: -- [Original paper](https://arxiv.org/pdf/1901.09392.pdf) +- [Original paper](https://arxiv.org/abs/1901.09392) From 65b4a841ee369d7a9e457925d0cb93a26470422c Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 25 Jul 2022 15:40:33 -0700 Subject: [PATCH 095/174] Remove the `insights` module from the main `__init__.py` file (#992) Summary: Fixes: https://github.com/pytorch/captum/issues/988 According the `setup.py` and the `README`, users wishing to use insights need to use the custom install option provided or install the modules separately. https://github.com/pytorch/captum/blob/master/setup.py#L54, https://github.com/pytorch/captum/blob/master/README.md#installation Therefore the insights module should not be loaded in the `__init__.py` file, and users will have to call it like before the changes proposed in https://github.com/pytorch/captum/pull/912, and added to the master branch in https://github.com/pytorch/captum/commit/9305b109417ca24ee6893075e03f3da241e59252 Pull Request resolved: https://github.com/pytorch/captum/pull/992 Reviewed By: Reubend Differential Revision: D38026733 Pulled By: NarineK fbshipit-source-id: d9bf407f461c2c1381291480654b8fc6923579c0 --- captum/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/captum/__init__.py b/captum/__init__.py index fda440d4f5..c433fc4a4d 100644 --- a/captum/__init__.py +++ b/captum/__init__.py @@ -2,7 +2,6 @@ import captum.attr as attr # noqa import captum.concept as concept # noqa import captum.influence as influence # noqa -import captum.insights as insights # noqa import captum.log as log # noqa import captum.metrics as metrics # noqa import captum.robust as robust # noqa From 9e1538eee473b34072eb8e0c99b86fd5ba712f12 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 26 Jul 2022 11:10:16 -0700 Subject: [PATCH 096/174] Fix some docstrings (#996) Summary: The "optional" part should come last. Pull Request resolved: https://github.com/pytorch/captum/pull/996 Reviewed By: 99warriors, Reubend Differential Revision: D38026646 Pulled By: NarineK fbshipit-source-id: 6648b3a2183dd4c8d29956e356f1ac5cd90d23cd --- captum/attr/_core/lime.py | 6 +++--- captum/robust/_core/metrics/attack_comparator.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/captum/attr/_core/lime.py b/captum/attr/_core/lime.py index 520251ce53..f5ad7877bc 100644 --- a/captum/attr/_core/lime.py +++ b/captum/attr/_core/lime.py @@ -734,7 +734,7 @@ def __init__( forward_func (callable): The forward function of the model or any modification of it - interpretable_model (optional, Model): Model object to train + interpretable_model (Model, optional): Model object to train interpretable model. This argument is optional and defaults to SkLearnLasso(alpha=0.01), @@ -760,7 +760,7 @@ def __init__( Note that calling fit multiple times should retrain the interpretable model, each attribution call reuses the same given interpretable model object. - similarity_func (optional, callable): Function which takes a single sample + similarity_func (callable, optional): Function which takes a single sample along with its corresponding interpretable representation and returns the weight of the interpretable sample for training the interpretable model. @@ -793,7 +793,7 @@ def __init__( kwargs includes baselines, feature_mask, num_interp_features (integer, determined from feature mask). - perturb_func (optional, callable): Function which returns a single + perturb_func (callable, optional): Function which returns a single sampled input, which is a binary vector of length num_interp_features, or a generator of such tensors. diff --git a/captum/robust/_core/metrics/attack_comparator.py b/captum/robust/_core/metrics/attack_comparator.py index 57b03e8f18..b9ebb59ad6 100644 --- a/captum/robust/_core/metrics/attack_comparator.py +++ b/captum/robust/_core/metrics/attack_comparator.py @@ -118,7 +118,7 @@ def add_attack( or any other perturbation or attack function such as a torchvision transform. - name (optional, str): Name or identifier for attack, used as key for + name (str, optional): Name or identifier for attack, used as key for attack results. This defaults to attack.__class__.__name__ if not provided and must be unique for all added attacks. From 1c50b87007178466f2fa81c428e1e2a40fe0a860 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 08:56:38 -0600 Subject: [PATCH 097/174] Fix grammar --- captum/optim/_utils/image/dataset.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/captum/optim/_utils/image/dataset.py b/captum/optim/_utils/image/dataset.py index 5319e4b9a6..7f03129ac7 100644 --- a/captum/optim/_utils/image/dataset.py +++ b/captum/optim/_utils/image/dataset.py @@ -57,8 +57,8 @@ def dataset_cov_matrix( dataloader instance. show_progress (bool, optional): Whether or not to display a tqdm progress bar. Default: ``False`` - device (torch.device, optional): The PyTorch device to use for for calculating - the cov matrix. + device (torch.device, optional): The PyTorch device to use for calculating the + cov matrix. Default: ``torch.device("cpu")`` Returns: @@ -148,8 +148,8 @@ def dataset_klt_matrix( Default: ``False`` show_progress (bool, optional): Whether or not to display a tqdm progress bar. Default: ``False`` - device (torch.device, optional): The PyTorch device to use for for calculating - the cov matrix. + device (torch.device, optional): The PyTorch device to use for calculating the + cov matrix. Default: ``torch.device("cpu")`` Returns: From 27b702ed7bade5c9b6b9d09bd5864d10c0701acf Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 09:30:20 -0600 Subject: [PATCH 098/174] Fix spelling --- captum/optim/models/_common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 8fcc2a978a..2ba15cfa0d 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -198,7 +198,7 @@ def __init__( kernel points. Default: ``1`` groups (int, optional): Number of blocked connections from input channels - to output channels. Both in_channels and out_channels must be divisable + to output channels. Both in_channels and out_channels must be divisible by groups. Default: ``1`` bias (bool, optional): Whether or not to apply a learnable bias to the From 7924b87d3f1ee45d27fc27c32697317a28a57fe1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 09:30:51 -0600 Subject: [PATCH 099/174] Remove Optim from run_mypy.sh for now --- scripts/run_mypy.sh | 1 - 1 file changed, 1 deletion(-) diff --git a/scripts/run_mypy.sh b/scripts/run_mypy.sh index 2497be44bc..d2f7c8d076 100755 --- a/scripts/run_mypy.sh +++ b/scripts/run_mypy.sh @@ -5,7 +5,6 @@ set -e # hints. mypy -p captum.attr --ignore-missing-imports --allow-redefinition -mypy -p captum.optim --ignore-missing-imports --allow-redefinition mypy -p captum.insights --ignore-missing-imports --allow-redefinition mypy -p captum.metrics --ignore-missing-imports --allow-redefinition mypy -p captum.robust --ignore-missing-imports --allow-redefinition From 3a2194fc158c930252dac326dd8f7c13a24a1a44 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 11:28:47 -0600 Subject: [PATCH 100/174] Remove loss_wrapper tests --- tests/optim/core/test_loss.py | 212 +++++++++++++++------------------- 1 file changed, 92 insertions(+), 120 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index cbf99912d0..92f1bd004e 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -42,6 +42,86 @@ def get_loss_value( return loss(module_outputs).detach() +class TestModuleOP(BaseTest): + def test_module_op_loss_unary_op(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping ModuleOP unary op test due to insufficient Torch" + + " version." + ) + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) + composed_loss = opt_loss.module_op(loss, None, operator.neg) + + expected_name = "ChannelActivation [Conv2d(3, 2, ke..., 0]" + self.assertEqual(composed_loss.__name__, expected_name) + output = get_loss_value(model, composed_loss) + expected = -torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS]).sum().item() + self.assertEqual(output, expected) + + def test_module_op_loss_num_add(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping ModuleOP loss add num test due to insufficient Torch" + + " version." + ) + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) + composed_loss = opt_loss.module_op(loss, 1.0, operator.add) + + expected_name = "ChannelActivation [Conv2d(3, 2, ke..., 0]" + self.assertEqual(composed_loss.__name__, expected_name) + output = get_loss_value(model, composed_loss) + expected = torch.tensor([CHANNEL_ACTIVATION_0_LOSS]) + 1.0 + self.assertEqual(output, expected.item()) + + def test_module_op_loss_loss_add(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping ModuleOP Loss add Loss test due to insufficient Torch" + + " version." + ) + model = BasicModel_ConvNet_Optim() + loss1 = opt_loss.ChannelActivation(model.layer, 0) + loss2 = opt_loss.ChannelActivation(model.layer, 1) + composed_loss = opt_loss.module_op(loss1, loss2, operator.add) + + expected_name = ( + "Compose(ChannelActivation [Conv2d(3, 2, ke..., 0], " + + "ChannelActivation [Conv2d(3, 2, ke..., 1])" + ) + self.assertEqual(composed_loss.__name__, expected_name) + output = get_loss_value(model, composed_loss) + expected = ( + torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS]) + .sum() + .item() + ) + self.assertEqual(output, expected) + + def test_module_op_loss_pow_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + loss = opt_loss.ChannelActivation(model.layer, 0) + opt_loss.module_op(loss, "string", operator.pow) # type: ignore + + +class TestRModuleOP(BaseTest): + def test_module_op_loss_num_div(self) -> None: + model = BasicModel_ConvNet_Optim() + loss = opt_loss.ChannelActivation(model.layer, 0) + composed_loss = opt_loss.rmodule_op(loss, 1.0, operator.pow) + + output = get_loss_value(model, composed_loss) + self.assertEqual(output, 1.0**CHANNEL_ACTIVATION_0_LOSS) + + def test_rmodule_op_loss_pow_error(self) -> None: + model = BasicModel_ConvNet_Optim() + with self.assertRaises(TypeError): + loss = opt_loss.ChannelActivation(model.layer, 0) + opt_loss.rmodule_op(loss, "string", operator.pow) # type: ignore + + class TestDeepDream(BaseTest): def test_deepdream(self) -> None: model = BasicModel_ConvNet_Optim() @@ -92,6 +172,18 @@ def test_layer_activation_batch_index(self) -> None: self, output, model_input[batch_index : batch_index + 1], delta=0.0 ) + def test_layer_activation_batch_index_negative(self) -> None: + model = torch.nn.Identity() + batch_index = -2 + loss = opt.loss.LayerActivation(model, batch_index=batch_index) + + model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() + output = get_loss_value(model, loss, model_input) + self.assertEqual(loss.batch_index, (batch_index, batch_index + 1)) + assertTensorAlmostEqual( + self, output, model_input[batch_index : batch_index + 1], delta=0.0 + ) + class TestChannelActivation(BaseTest): def test_channel_activation_init(self) -> None: @@ -772,128 +864,8 @@ def test_sum_loss_list_identity(self) -> None: self.assertEqual(out.sum().item(), 30000.0) -class TestModuleOP(BaseTest): - def test_module_op_loss_unary_op(self) -> None: - if version.parse(torch.__version__) <= version.parse("1.6.0"): - raise unittest.SkipTest( - "Skipping ModuleOP unary op test due to insufficient Torch" - + " version." - ) - model = BasicModel_ConvNet_Optim() - loss = opt_loss.ChannelActivation(model.layer, 0) - composed_loss = opt_loss.module_op(loss, None, operator.neg) - - expected_name = "ChannelActivation [Conv2d(3, 2, ke..., 0]" - self.assertEqual(composed_loss.__name__, expected_name) - output = get_loss_value(model, composed_loss) - expected = -torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS]).sum().item() - self.assertEqual(output, expected) - - def test_module_op_loss_num_add(self) -> None: - if version.parse(torch.__version__) <= version.parse("1.6.0"): - raise unittest.SkipTest( - "Skipping ModuleOP loss add num test due to insufficient Torch" - + " version." - ) - model = BasicModel_ConvNet_Optim() - loss = opt_loss.ChannelActivation(model.layer, 0) - composed_loss = opt_loss.module_op(loss, 1.0, operator.add) - - expected_name = "ChannelActivation [Conv2d(3, 2, ke..., 0]" - self.assertEqual(composed_loss.__name__, expected_name) - output = get_loss_value(model, composed_loss) - expected = torch.tensor([CHANNEL_ACTIVATION_0_LOSS]) + 1.0 - self.assertEqual(output, expected.item()) - - def test_module_op_loss_loss_add(self) -> None: - if version.parse(torch.__version__) <= version.parse("1.6.0"): - raise unittest.SkipTest( - "Skipping ModuleOP Loss add Loss test due to insufficient Torch" - + " version." - ) - model = BasicModel_ConvNet_Optim() - loss1 = opt_loss.ChannelActivation(model.layer, 0) - loss2 = opt_loss.ChannelActivation(model.layer, 1) - composed_loss = opt_loss.module_op(loss1, loss2, operator.add) - - expected_name = ( - "Compose(ChannelActivation [Conv2d(3, 2, ke..., 0], " - + "ChannelActivation [Conv2d(3, 2, ke..., 1])" - ) - self.assertEqual(composed_loss.__name__, expected_name) - output = get_loss_value(model, composed_loss) - expected = ( - torch.as_tensor([CHANNEL_ACTIVATION_0_LOSS, CHANNEL_ACTIVATION_0_LOSS]) - .sum() - .item() - ) - self.assertEqual(output, expected) - - def test_module_op_loss_pow_error(self) -> None: - model = BasicModel_ConvNet_Optim() - with self.assertRaises(TypeError): - loss = opt_loss.ChannelActivation(model.layer, 0) - opt_loss.module_op(loss, "string", operator.pow) # type: ignore - - -class TestRModuleOP(BaseTest): - def test_module_op_loss_num_div(self) -> None: - model = BasicModel_ConvNet_Optim() - loss = opt_loss.ChannelActivation(model.layer, 0) - composed_loss = opt_loss.rmodule_op(loss, 1.0, operator.pow) - - output = get_loss_value(model, composed_loss) - self.assertEqual(output, 1.0**CHANNEL_ACTIVATION_0_LOSS) - - def test_rmodule_op_loss_pow_error(self) -> None: - model = BasicModel_ConvNet_Optim() - with self.assertRaises(TypeError): - loss = opt_loss.ChannelActivation(model.layer, 0) - opt_loss.rmodule_op(loss, "string", operator.pow) # type: ignore - - class TestDefaultLossSummarize(BaseTest): def test_default_loss_summarize(self) -> None: x = torch.arange(0, 1 * 3 * 5 * 5).view(1, 3, 5, 5).float() output = opt_loss.default_loss_summarize(x) self.assertEqual(output.item(), -37.0) - - -class TestMakeArgStr(BaseTest): - def test_make_arg_str(self) -> None: - args = {"a": 5, "b": None} - output = opt_loss._make_arg_str(args) - self.assertEqual(output, "{'a': 5, 'b': N...") - args = {"c": torch.nn.Identity, "d": "test"} - output = opt_loss._make_arg_str(args) - self.assertEqual(output, "{'c': None: - @opt_loss.loss_wrapper - class TestClass: - def __init__( - self, - target: torch.nn.Module, - test_var: int, - batch_index: Optional[int] = None, - ) -> None: - self.target = target - self.batch_index = batch_index - self.test_var = test_var - - def __call__(self) -> int: - return self.test_var - - test_module = TestClass(torch.nn.Identity(), test_var=5, batch_index=0) - expected = "TestClass [Identity()]" - self.assertEqual(test_module.__name__, expected) # type: ignore - - test_module = TestClass(torch.nn.Identity(), 5, 0) - expected = "TestClass [Identity(), 5, 0]" - self.assertEqual(test_module.__name__, expected) # type: ignore - - test_module = TestClass(torch.nn.Identity(), 5) - expected = "TestClass [Identity(), 5]" - self.assertEqual(test_module.__name__, expected) # type: ignore From 819a0a8c4083d19235d82901d3bb6a0783b30443 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 11:29:13 -0600 Subject: [PATCH 101/174] Remove `loss_wrapper` --- captum/optim/_core/loss.py | 45 +------------------------------------- 1 file changed, 1 insertion(+), 44 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index c48539151a..90f7f36a1d 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -9,20 +9,6 @@ from captum.optim._utils.typing import ModuleOutputMapping -def _make_arg_str(arg: Any) -> str: - """ - Args: - - args (Any): A set of arguments to covert to a string. - - Returns: - args (str): The args in str form. - """ - arg = str(arg) - too_big = len(arg) > 15 or "\n" in arg - return arg[:15] + "..." if too_big else arg - - class Loss(ABC): """ Abstract Class to describe loss. @@ -32,6 +18,7 @@ class Loss(ABC): def __init__(self) -> None: super().__init__() + self.__name__ = self.__class__.__name__ @abstractproperty def target(self) -> Union[nn.Module, List[nn.Module]]: @@ -362,22 +349,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return self.loss_fn(targets_to_values) -def loss_wrapper(cls: Any) -> Callable: - """ - Primarily for naming purposes. - """ - - @functools.wraps(cls) - def wrapper(*args, **kwargs) -> object: - obj = cls(*args, **kwargs) - args_str = " [" + ", ".join([_make_arg_str(arg) for arg in args]) + "]" - obj.__name__ = cls.__name__ + args_str - return obj - - return wrapper - - -@loss_wrapper class LayerActivation(BaseLoss): """ Maximize activations at the target layer. @@ -409,7 +380,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return activations -@loss_wrapper class ChannelActivation(BaseLoss): """ Maximize activations at the target layer and target channel. @@ -451,7 +421,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: ] -@loss_wrapper class NeuronActivation(BaseLoss): """ This loss maximizes the activations of a target neuron in the specified channel @@ -509,7 +478,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: ] -@loss_wrapper class DeepDream(BaseLoss): """ Maximize 'interestingness' at the target layer. @@ -550,7 +518,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return activations**2 -@loss_wrapper class TotalVariation(BaseLoss): """ Total variation denoising penalty for activations. @@ -587,7 +554,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return torch.sum(torch.abs(x_diff)) + torch.sum(torch.abs(y_diff)) -@loss_wrapper class L1(BaseLoss): """ L1 norm of the target layer, generally used as a penalty. @@ -620,7 +586,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return torch.abs(activations - self.constant).sum() -@loss_wrapper class L2(BaseLoss): """ L2 norm of the target layer, generally used as a penalty. @@ -660,7 +625,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return torch.sqrt(self.eps + activations) -@loss_wrapper class Diversity(BaseLoss): """ Use a cosine similarity penalty to extract features from a polysemantic neuron. @@ -709,7 +673,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: ) -@loss_wrapper class ActivationInterpolation(BaseLoss): """ Interpolate between two different layers & channels. @@ -776,7 +739,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return sum_tensor -@loss_wrapper class Alignment(BaseLoss): """ Penalize the L2 distance between tensors in the batch to encourage visual @@ -830,7 +792,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return -sum_tensor -@loss_wrapper class Direction(BaseLoss): """ Visualize a general direction vector. @@ -873,7 +834,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return _dot_cossim(self.vec, activations, cossim_pow=self.cossim_pow) -@loss_wrapper class NeuronDirection(BaseLoss): """ Visualize a single (x, y) position for a direction vector. @@ -940,7 +900,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return _dot_cossim(self.vec, activations, cossim_pow=self.cossim_pow) -@loss_wrapper class AngledNeuronDirection(BaseLoss): """ Visualize a direction vector with an optional whitened activation vector to @@ -1039,7 +998,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return dot * torch.clamp(cossims, min=0.1) ** self.cossim_pow -@loss_wrapper class TensorDirection(BaseLoss): """ Visualize a tensor direction vector. @@ -1093,7 +1051,6 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return _dot_cossim(self.vec, activations, cossim_pow=self.cossim_pow) -@loss_wrapper class ActivationWeights(BaseLoss): """ Apply weights to channels, neurons, or spots in the target. From 61a0be93d6279f3aa09e75e8e1a26c53eed9fbff Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 14:15:44 -0600 Subject: [PATCH 102/174] Fix lint errors --- captum/optim/_core/loss.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 90f7f36a1d..ee47ae0ea5 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -1,7 +1,6 @@ -import functools import operator from abc import ABC, abstractmethod, abstractproperty -from typing import Any, Callable, List, Optional, Tuple, Union +from typing import Callable, List, Optional, Tuple, Union import torch import torch.nn as nn @@ -1203,7 +1202,6 @@ def default_loss_summarize(loss_value: torch.Tensor) -> torch.Tensor: __all__ = [ "Loss", - "loss_wrapper", "BaseLoss", "CompositeLoss", "LayerActivation", From 31b5707b251c92552e6fb4cef9be2fc1526c37a9 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 14:16:54 -0600 Subject: [PATCH 103/174] Fix lint errors --- tests/optim/core/test_loss.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/optim/core/test_loss.py b/tests/optim/core/test_loss.py index 92f1bd004e..4818554f2d 100644 --- a/tests/optim/core/test_loss.py +++ b/tests/optim/core/test_loss.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 import operator import unittest -from typing import Any, List, Optional, Type, Union +from typing import Any, List, Type, Union import captum.optim._core.loss as opt_loss import torch @@ -175,7 +175,7 @@ def test_layer_activation_batch_index(self) -> None: def test_layer_activation_batch_index_negative(self) -> None: model = torch.nn.Identity() batch_index = -2 - loss = opt.loss.LayerActivation(model, batch_index=batch_index) + loss = opt_loss.LayerActivation(model, batch_index=batch_index) model_input = torch.arange(0, 5 * 3 * 5 * 5).view(5, 3, 5, 5).float() output = get_loss_value(model, loss, model_input) From 07c759363f03cf3ced3e41c702b97ab17d8efcb8 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 18:38:12 -0600 Subject: [PATCH 104/174] Fix Mypy type hints --- captum/optim/models/_common.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 2ba15cfa0d..30c574d60d 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -49,12 +49,12 @@ class RedirectedReLU(torch.autograd.Function): """ @staticmethod - def forward(self, input_tensor: torch.Tensor) -> torch.Tensor: + def forward(self, input_tensor: torch.Tensor) -> torch.Tensor: # type: ignore self.save_for_backward(input_tensor) return input_tensor.clamp(min=0) @staticmethod - def backward(self, grad_output: torch.Tensor) -> torch.Tensor: + def backward(self, grad_output: torch.Tensor) -> torch.Tensor: # type: ignore (input_tensor,) = self.saved_tensors relu_grad = grad_output.clone() relu_grad[input_tensor < 0] = 0 @@ -374,20 +374,25 @@ class MaxPool2dRelaxed(torch.nn.Module): def __init__( self, - kernel_size: Union[int, Tuple[int, ...]], - stride: Optional[Union[int, Tuple[int, ...]]] = None, - padding: Union[int, Tuple[int, ...]] = 0, + kernel_size: Union[int, Tuple[int, int]], + stride: Optional[Union[int, Tuple[int, int]]] = None, + padding: Union[int, Tuple[int, int]] = 0, ceil_mode: bool = False, ) -> None: """ Args: kernel_size (int or tuple of int): The size of the window to perform max - and average pooling with. + and average pooling with. Either a single int to use for both the + height & width or a tuple of 2 integers in format of: (height, width). stride (int or tuple of int, optional): The stride window size to use. + Either a single int to use for both the height & width or a tuple of 2 + integers in format of: (height, width). Default: ``None`` padding (int or tuple of int): The amount of zero padding to add to both - sides in the ``nn.MaxPool2d`` & ``nn.AvgPool2d`` modules. + sides in the ``nn.MaxPool2d`` & ``nn.AvgPool2d`` modules. Either a + single int to use for both the height & width or a tuple of 2 integers + in format of: (height, width). Default: ``0`` ceil_mode (bool, optional): Whether to use ceil or floor for creating the output shape. From 16dd3cf4871dcba8c3b92efa42366e80fd41cba2 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 18:39:24 -0600 Subject: [PATCH 105/174] Fix formatting --- captum/optim/models/_common.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 30c574d60d..8a2c6f7391 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -384,15 +384,15 @@ def __init__( kernel_size (int or tuple of int): The size of the window to perform max and average pooling with. Either a single int to use for both the - height & width or a tuple of 2 integers in format of: (height, width). + height & width or a tuple of 2 integers in format of: (height, width). stride (int or tuple of int, optional): The stride window size to use. Either a single int to use for both the height & width or a tuple of 2 - integers in format of: (height, width). + integers in format of: (height, width). Default: ``None`` padding (int or tuple of int): The amount of zero padding to add to both sides in the ``nn.MaxPool2d`` & ``nn.AvgPool2d`` modules. Either a - single int to use for both the height & width or a tuple of 2 integers - in format of: (height, width). + single int to use for both the height & width or a tuple of 2 integers + in format of: (height, width). Default: ``0`` ceil_mode (bool, optional): Whether to use ceil or floor for creating the output shape. From f2f7ea553d63879e6c3336c96f7e7ef55fc344a1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 27 Jul 2022 19:43:27 -0600 Subject: [PATCH 106/174] Fix typehint mistake --- captum/optim/_core/loss.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index ee47ae0ea5..6ec08391b1 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -806,7 +806,7 @@ def __init__( self, target: nn.Module, vec: torch.Tensor, - cossim_pow: Optional[float] = 0.0, + cossim_pow: float = 0.0, batch_index: Optional[int] = None, ) -> None: """ @@ -849,7 +849,7 @@ def __init__( x: Optional[int] = None, y: Optional[int] = None, channel_index: Optional[int] = None, - cossim_pow: Optional[float] = 0.0, + cossim_pow: float = 0.0, batch_index: Optional[int] = None, ) -> None: """ @@ -1009,7 +1009,7 @@ def __init__( self, target: nn.Module, vec: torch.Tensor, - cossim_pow: Optional[float] = 0.0, + cossim_pow: float = 0.0, batch_index: Optional[int] = None, ) -> None: """ From 91074968dbd7693af1758785385fb4c759df3fa5 Mon Sep 17 00:00:00 2001 From: Narine Kokhlikyan Date: Wed, 27 Jul 2022 18:53:42 -0700 Subject: [PATCH 107/174] Fix failing conda (#1000) Summary: Fix failing conda Pull Request resolved: https://github.com/pytorch/captum/pull/1000 Reviewed By: 99warriors Differential Revision: D38222553 Pulled By: NarineK fbshipit-source-id: 4e949041297d8caedd0658e6322a4054454ca788 --- scripts/install_via_conda.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/install_via_conda.sh b/scripts/install_via_conda.sh index aad12b91c1..a8e32b8d22 100755 --- a/scripts/install_via_conda.sh +++ b/scripts/install_via_conda.sh @@ -16,6 +16,7 @@ while getopts 'nf' flag; do # update conda # removing due to setuptools error during update #conda update -y -n base -c defaults conda +conda update --all --yes # required to use conda develop conda install -y conda-build From 7e2dbf9e23608fee29896357fb9095a70619a812 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 28 Jul 2022 12:49:01 -0600 Subject: [PATCH 108/174] callable -> Callable --- captum/optim/_core/optimization.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/captum/optim/_core/optimization.py b/captum/optim/_core/optimization.py index 84b3b10a0f..6ce3fb3e13 100644 --- a/captum/optim/_core/optimization.py +++ b/captum/optim/_core/optimization.py @@ -61,7 +61,7 @@ def __init__( model (nn.Module, optional): The reference to PyTorch model instance. Set to ``None`` for no model instance. - loss_function (callable): The :mod:`Loss <.loss>` objective instance to + loss_function (Callable): The :mod:`Loss <.loss>` objective instance to minimize during optimization. input_param (InputParameterization, optional): A module that generates an input, consumed by the model. Example: An @@ -167,7 +167,7 @@ def optimize( optimizer (torch.optim.Optimizer, optional): A ``torch.optim.Optimizer`` instance to use for optimizing the input based on the loss function. Default: :class:`torch.optim.Adam` - loss_summarize_fn (callable, optional): The function to use for summarizing + loss_summarize_fn (Callable, optional): The function to use for summarizing tensor outputs from loss functions. Default: :func:`.default_loss_summarize` lr (float, optional): If no optimizer is given, then lr is used as the @@ -213,7 +213,7 @@ def n_steps(n: int, show_progress: bool = True) -> StopCriteria: Default: ``True`` Returns: - StopCriteria (callable): A stop criteria function. + StopCriteria (Callable): A stop criteria function. """ if show_progress: From ca84f7b6d8d2f1315c63d99f1a071df397ddcb80 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 29 Jul 2022 14:11:50 -0600 Subject: [PATCH 109/174] Docstring Improvements --- captum/optim/models/_common.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/captum/optim/models/_common.py b/captum/optim/models/_common.py index 8a2c6f7391..9fa9cda942 100644 --- a/captum/optim/models/_common.py +++ b/captum/optim/models/_common.py @@ -49,12 +49,12 @@ class RedirectedReLU(torch.autograd.Function): """ @staticmethod - def forward(self, input_tensor: torch.Tensor) -> torch.Tensor: # type: ignore + def forward(self, input_tensor: torch.Tensor) -> torch.Tensor: self.save_for_backward(input_tensor) return input_tensor.clamp(min=0) @staticmethod - def backward(self, grad_output: torch.Tensor) -> torch.Tensor: # type: ignore + def backward(self, grad_output: torch.Tensor) -> torch.Tensor: (input_tensor,) = self.saved_tensors relu_grad = grad_output.clone() relu_grad[input_tensor < 0] = 0 @@ -262,6 +262,13 @@ def collect_activations( """ Collect target activations for a model. + Example:: + + >>> model = opt.models.googlenet(pretrained=True) + >>> target = model.mixed4c # Target layer + >>> activ_dict = opt.models.collect_activations(model, target) + >>> activations = activ_dict[target] # Get activations from dict + Args: model (nn.Module): A PyTorch model instance. From 1a10252f7be31e02fe6be82065f12adde6cd8203 Mon Sep 17 00:00:00 2001 From: Fulton Wang Date: Sun, 31 Jul 2022 23:10:49 -0700 Subject: [PATCH 110/174] modify tracin self influence helpers (#994) Summary: Pull Request resolved: https://github.com/pytorch/captum/pull/994 change `TracInCP._self_influence_batch_tracincp` and `TracInCP._self_influence_batch_tracincp` `TracInCP._self_influence_batches_tracincp_fast` to be named `self_influence`, which is now public, and now accept a DataLoader yielding batches (as well as a single batch, as before). The modified helper function can be called by external functions to compute self influence. The helper itself is also changed to improve efficiency, by reducing the number of times checkpoints are loaded. The modified helper, despite being able to compute self influence scores for a dataloader yielding batches, still only loads each checkpoint once, per call. This is because the modified helper now has an outer iteration over checkpoints, and an inner iteration over batches (the order of iteration is reversed compared to before). This helper is called by `influence` when running it in self influence mode. The reason we cannot just increase the batch size to reduce the number of checkpoint loadings is that for large models (precisely those for which loading checkpoints is expensive), the model takes up too much memory, so that the batch size cannot be too large. Minor change: for `influence_src_dataset` argument of all `__init__`'s, add description of what assumptions we make of the batches yielded by the dataloader. Reviewed By: NarineK Differential Revision: D35603078 fbshipit-source-id: 92915477b98e06efebf84ed6e59bd1f02f25b894 --- captum/influence/_core/tracincp.py | 434 +++++++++++------- .../_core/tracincp_fast_rand_proj.py | 386 ++++++++++------ captum/influence/_utils/common.py | 12 + .../_core/test_tracin_self_influence.py | 70 ++- .../_core/test_tracin_show_progress.py | 217 +++++---- 5 files changed, 739 insertions(+), 380 deletions(-) diff --git a/captum/influence/_core/tracincp.py b/captum/influence/_core/tracincp.py index d5acc2dfef..78fa32738f 100644 --- a/captum/influence/_core/tracincp.py +++ b/captum/influence/_core/tracincp.py @@ -26,6 +26,7 @@ from captum._utils.progress import progress from captum.influence._core.influence import DataInfluence from captum.influence._utils.common import ( + _format_inputs_dataset, _get_k_most_influential_helper, _gradient_dot_product, _load_flexible_state_dict, @@ -95,7 +96,7 @@ class TracInCPBase(DataInfluence): def __init__( self, model: Module, - influence_src_dataset: Union[Dataset, DataLoader], + train_dataset: Union[Dataset, DataLoader], checkpoints: Union[str, List[str], Iterator], checkpoints_load_func: Callable = _load_flexible_state_dict, loss_fn: Optional[Union[Module, Callable]] = None, @@ -105,7 +106,7 @@ def __init__( Args: model (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. - influence_src_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -120,9 +121,15 @@ def __init__( DataLoader used for processing should be as large as possible, but not too large, so that certain intermediate quantities created from a batch still fit in memory. Therefore, if - `influence_src_dataset` is a Dataset, `batch_size` should be large. - If `influence_src_dataset` was already a DataLoader to begin with, - it should have been constructed to have a large batch size. + `train_dataset` is a Dataset, `batch_size` should be large. + If `train_dataset` was already a DataLoader to begin with, + it should have been constructed to have a large batch size. It is + assumed that the Dataloader (regardless of whether it is created + from a Pytorch Dataset or not) yields tuples. For a `batch` that is + yielded, of length `L`, it is assumed that the forward function of + `model` accepts `L-1` arguments, and the last element of `batch` is + the label. In other words, `model(*batch[:-1])` gives the output of + `model`, and `batch[-1]` are the labels for the batch. checkpoints (str or List of str or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which @@ -140,12 +147,12 @@ def __init__( loss_fn (Callable, optional): The loss function applied to model. Default: None batch_size (int or None, optional): Batch size of the DataLoader created to - iterate through `influence_src_dataset`, if it is a Dataset. + iterate through `train_dataset`, if it is a Dataset. `batch_size` should be chosen as large as possible so that certain intermediate quantities created from a batch still fit in memory. Specific implementations of `TracInCPBase` will detail the size of the intermediate quantities. `batch_size` must be an int if - `influence_src_dataset` is a Dataset. If `influence_src_dataset` + `train_dataset` is a Dataset. If `train_dataset` is a DataLoader, then `batch_size` is ignored as an argument. Default: 1 """ @@ -165,44 +172,80 @@ def __init__( self.loss_fn = loss_fn self.batch_size = batch_size - if not isinstance(influence_src_dataset, DataLoader): + if not isinstance(train_dataset, DataLoader): assert isinstance(batch_size, int), ( - "since the `influence_src_dataset` argument was a `Dataset`, " + "since the `train_dataset` argument was a `Dataset`, " "`batch_size` must be an int." ) - self.influence_src_dataloader = DataLoader( - influence_src_dataset, batch_size, shuffle=False - ) + self.train_dataloader = DataLoader(train_dataset, batch_size, shuffle=False) else: - self.influence_src_dataloader = influence_src_dataset + self.train_dataloader = train_dataset - self.influence_src_dataloader_len: Optional[int] = None + self.train_dataloader_len: Optional[int] = None try: # since we will calculate the number of batches in - # `self.influence_src_dataloader` whenever we use progress bar, calculate + # `self.train_dataloader` whenever we use progress bar, calculate # it once in initialization, for re-use. - self.influence_src_dataloader_len = len(self.influence_src_dataloader) - except AttributeError: - pass + self.train_dataloader_len = len(self.train_dataloader) + except TypeError: + warnings.warn( + "Unable to determine the number of batches in training dataset " + "`train_dataset`. Therefore, if showing the progress of computations, " + "only the number of batches processed can be displayed, and not the " + "percentage completion of the computation, nor any time estimates." + ) @abstractmethod - def _self_influence(self, show_progress: bool = False): + def self_influence( + self, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + show_progress: bool = False, + ) -> Tensor: """ - Returns: - self influence scores (tensor): 1D tensor containing self influence - scores for all examples in training dataset - `influence_src_dataset`. - show_progress (bool, optional): To compute the self influence scores for - all examples in training dataset `influence_src_dataset`, we - compute the self influence scores for each batch. If + Computes self influence scores for the examples in `inputs_dataset`, which is + either a single batch or a Pytorch `DataLoader` that yields batches. Therefore, + the computed self influence scores are *not* for the examples in training + dataset `train_dataset` (unlike when computing self influence scores using the + `influence` method). Note that if `inputs_dataset` is a single batch, this + will call `model` on that single batch, and if `inputs_dataset` yields + batches, this will call `model` on each batch that is yielded. Therefore, + please ensure that for both cases, the batch(es) that `model` is called + with are not too large, so that there will not be an out-of-memory error. + + Args: + batches (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, + and `batch[-1]` are the labels, if any. This is the same + assumption made for each batch yielded by training dataset + `train_dataset`. Please see documentation for the + `train_dataset` argument to `TracInCP.__init__` for + more details on the assumed structure of a batch. + show_progress (bool, optional): Computation of self influence scores can + take a long time if `inputs_dataset` represents many examples. If `show_progress`is true, the progress of this computation will be - displayed. In particular, the number of batches for which self - influence scores have been computed will be displayed. It will - try to use tqdm if available for advanced features (e.g. time - estimation). Otherwise, it will fallback to a simple output of - progress. + displayed. In more detail, this computation will iterate over all + checkpoints (provided as the `checkpoints` initialization argument) + in an outer loop, and iterate over all batches that + `inputs_dataset` represents in an inner loop. Therefore, the + total number of (checkpoint, batch) combinations that need to be + iterated over is + (# of checkpoints x # of batches that `inputs_dataset` represents). + If `show_progress` is True, the total progress of both the outer + iteration over checkpoints and the inner iteration over batches is + displayed. It will try to use tqdm if available for advanced + features (e.g. time estimation). Otherwise, it will fallback to a + simple output of progress. Default: False + + Returns: + self_influence_scores (Tensor): This is a 1D tensor containing the self + influence scores of all examples in `inputs_dataset`, regardless of + whether it represents a single batch or a `DataLoader` that yields + batches. """ pass @@ -230,7 +273,7 @@ def _get_k_most_influential( Default: True show_progress (bool, optional): To compute the proponents (or opponents) for the batch of examples, we perform computation for each batch in - training dataset `influence_src_dataset`, If `show_progress`is + training dataset `train_dataset`, If `show_progress`is true, the progress of this computation will be displayed. In particular, the number of batches for which the computation has been performed will be displayed. It will try to use tqdm if @@ -244,13 +287,13 @@ def _get_k_most_influential( test example. Its dimension is `(inputs_batch_size, k)`, where `inputs_batch_size` is the number of examples in `inputs`. For example, if `proponents==True`, `indices[i][j]` is the index of the - example in training dataset `influence_src_dataset` with the + example in training dataset `train_dataset` with the k-th highest influence score for the j-th example in `inputs`. `indices` is a `torch.long` tensor so that it can directly be used to index other tensors. Each row of `influence_scores` contains the influence scores for a different test example, in sorted order. In particular, `influence_scores[i][j]` is the influence score of - example `indices[i][j]` in training dataset `influence_src_dataset` + example `indices[i][j]` in training dataset `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -267,7 +310,7 @@ def _influence( Args: inputs (Tuple of Any): A batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that - `self.model(*inputs)` produces the predictions for the batch. + `model(*inputs)` produces the predictions for the batch. targets (tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. @@ -275,12 +318,12 @@ def _influence( Returns: influence_scores (tensor): Influence scores over the entire - training dataset `influence_src_dataset`. Dimensionality is + training dataset `train_dataset`. Dimensionality is (inputs_batch_size, src_dataset_size). For example: influence_scores[i][j] = the influence score for the j-th training example to the i-th input example. show_progress (bool, optional): To compute the influence of examples in - training dataset `influence_src_dataset`, we compute the influence + training dataset `train_dataset`, we compute the influence of each batch. If `show_progress`is true, the progress of this computation will be displayed. In particular, the number of batches for which influence has been computed will be displayed. It will @@ -307,17 +350,17 @@ def influence( # type: ignore[override] - self influence mode: This mode is used if `inputs` is None. This mode computes the self influence scores for every example in - the training dataset `influence_src_dataset`. + the training dataset `train_dataset`. - influence score mode: This mode is used if `inputs` is not None, and `k` is None. This mode computes the influence score of every example in - training dataset `influence_src_dataset` on every example in the test + training dataset `train_dataset` on every example in the test batch represented by `inputs` and `targets`. - k-most influential mode: This mode is used if `inputs` is not None, and `k` is not None, and an int. This mode computes the proponents or opponents of every example in the test batch represented by `inputs` and `targets`. In particular, for each test example in the test batch, this mode computes its proponents (resp. opponents), which are the - indices in the training dataset `influence_src_dataset` of the training + indices in the training dataset `train_dataset` of the training examples with the `k` highest (resp. lowest) influence scores on the test example. Proponents are computed if `proponents` is True. Otherwise, opponents are computed. For each test example, this method @@ -329,12 +372,12 @@ def influence( # type: ignore[override] will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential mode. If the argument `unpack_inputs` is False, the - assumption is that `self.model(inputs)` produces the predictions + assumption is that `model(inputs)` produces the predictions for a batch, and `inputs` can be of any type. Otherwise if the argument `unpack_inputs` is True, the assumption is that - `self.model(*inputs)` produces the predictions for a batch, and + `model(*inputs)` produces the predictions for a batch, and `inputs` will need to be a tuple. In other words, `inputs` will be - unpacked as an argument when passing to `self.model`. + unpacked as an argument when passing to `model`. Default: None targets (tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. @@ -354,7 +397,7 @@ def influence( # type: ignore[override] Default: True show_progress (bool, optional): For all modes, computation of results requires "training dataset computations": computations for each - batch in the training dataset `influence_src_dataset`, which may + batch in the training dataset `train_dataset`, which may take a long time. If `show_progress`is true, the progress of "training dataset computations" will be displayed. In particular, the number of batches for which computations have been performed @@ -368,29 +411,29 @@ def influence( # type: ignore[override] - self influence mode: if this mode is run (`inputs` is None), returns a 1D tensor of self influence scores over training dataset - `influence_src_dataset`. The length of this tensor is the number of - examples in `influence_src_dataset`, regardless of whether it is a + `train_dataset`. The length of this tensor is the number of + examples in `train_dataset`, regardless of whether it is a Dataset or DataLoader. - influence score mode: if this mode is run (`inputs is not None, `k` is None), returns a 2D tensor `influence_scores` of shape - `(input_size, influence_src_dataset_size)`, where `input_size` is + `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and - `influence_src_dataset_size` is the number of examples in - training dataset `influence_src_dataset`. In other words, + `train_dataset_size` is the number of examples in + training dataset `train_dataset`. In other words, `influence_scores[i][j]` is the influence score of the `j`-th - example in `influence_src_dataset` on the `i`-th example in the + example in `train_dataset` on the `i`-th example in the test batch. - k-most influential mode: if this mode is run (`inputs` is not None, `k` is an int), returns a namedtuple `(indices, influence_scores)`. `indices` is a 2D tensor of shape `(input_size, k)`, where `input_size` is the number of examples in the test batch. If computing proponents (resp. opponents), `indices[i][j]` is the - index in training dataset `influence_src_dataset` of the example + index in training dataset `train_dataset` of the example with the `j`-th highest (resp. lowest) influence score (out of the - examples in `influence_src_dataset`) on the `i`-th example in the + examples in `train_dataset`) on the `i`-th example in the test batch. `influence_scores` contains the corresponding influence scores. In particular, `influence_scores[i][j]` is the influence - score of example `indices[i][j]` in `influence_src_dataset` on + score of example `indices[i][j]` in `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -431,7 +474,9 @@ def _influence_route_to_helpers( _inputs = _format_inputs(inputs, unpack_inputs) if inputs is None: - return influence_instance._self_influence(show_progress) + return influence_instance.self_influence( + influence_instance.train_dataloader, show_progress + ) elif k is None: return influence_instance._influence(_inputs, targets, show_progress) else: @@ -444,7 +489,7 @@ class TracInCP(TracInCPBase): def __init__( self, model: Module, - influence_src_dataset: Union[Dataset, DataLoader], + train_dataset: Union[Dataset, DataLoader], checkpoints: Union[str, List[str], Iterator], checkpoints_load_func: Callable = _load_flexible_state_dict, layers: Optional[List[str]] = None, @@ -456,7 +501,7 @@ def __init__( Args: model (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. - influence_src_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -471,9 +516,15 @@ def __init__( DataLoader used for processing should be as large as possible, but not too large, so that certain intermediate quantities created from a batch still fit in memory. Therefore, if - `influence_src_dataset` is a Dataset, `batch_size` should be large. - If `influence_src_dataset` was already a DataLoader to begin with, - it should have been constructed to have a large batch size. + `train_dataset` is a Dataset, `batch_size` should be large. + If `train_dataset` was already a DataLoader to begin with, + it should have been constructed to have a large batch size. It is + assumed that the Dataloader (regardless of whether it is created + from a Pytorch Dataset or not) yields tuples. For a `batch` that is + yielded, of length `L`, it is assumed that the forward function of + `model` accepts `L-1` arguments, and the last element of `batch` is + the label. In other words, `model(*batch[:-1])` gives the output of + `model`, and `batch[-1]` are the labels for the batch. checkpoints (str or List of str or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which @@ -507,12 +558,12 @@ def __init__( to "mean", i.e. `loss_fn.reduction = "mean"`. Default: None batch_size (int or None, optional): Batch size of the DataLoader created to - iterate through `influence_src_dataset`, if it is a Dataset. + iterate through `train_dataset`, if it is a Dataset. `batch_size` should be chosen as large as possible so that certain intermediate quantities created from a batch still fit in memory. Specific implementations of `TracInCPBase` will detail the size of the intermediate quantities. `batch_size` must be an int if - `influence_src_dataset` is a Dataset. If `influence_src_dataset` + `train_dataset` is a Dataset. If `train_dataset` is a DataLoader, then `batch_size` is ignored as an argument. Default: 1 sample_wise_grads_per_batch (bool, optional): PyTorch's native gradient @@ -539,7 +590,7 @@ def __init__( TracInCPBase.__init__( self, model, - influence_src_dataset, + train_dataset, checkpoints, checkpoints_load_func, loss_fn, @@ -627,17 +678,17 @@ def influence( # type: ignore[override] - self influence mode: This mode is used if `inputs` is None. This mode computes the self influence scores for every example in - the training dataset `influence_src_dataset`. + the training dataset `train_dataset`. - influence score mode: This mode is used if `inputs` is not None, and `k` is None. This mode computes the influence score of every example in - training dataset `influence_src_dataset` on every example in the test + training dataset `train_dataset` on every example in the test batch represented by `inputs` and `targets`. - k-most influential mode: This mode is used if `inputs` is not None, and `k` is not None, and an int. This mode computes the proponents or opponents of every example in the test batch represented by `inputs` and `targets`. In particular, for each test example in the test batch, this mode computes its proponents (resp. opponents), which are the - indices in the training dataset `influence_src_dataset` of the training + indices in the training dataset `train_dataset` of the training examples with the `k` highest (resp. lowest) influence scores on the test example. Proponents are computed if `proponents` is True. Otherwise, opponents are computed. For each test example, this method @@ -649,12 +700,12 @@ def influence( # type: ignore[override] will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential mode. If the argument `unpack_inputs` is False, the - assumption is that `self.model(inputs)` produces the predictions + assumption is that `model(inputs)` produces the predictions for a batch, and `inputs` can be of any type. Otherwise if the argument `unpack_inputs` is True, the assumption is that - `self.model(*inputs)` produces the predictions for a batch, and + `model(*inputs)` produces the predictions for a batch, and `inputs` will need to be a tuple. In other words, `inputs` will be - unpacked as an argument when passing to `self.model`. + unpacked as an argument when passing to `model`. Default: None targets (tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. @@ -674,7 +725,7 @@ def influence( # type: ignore[override] Default: True show_progress (bool, optional): For all modes, computation of results requires "training dataset computations": computations for each - batch in the training dataset `influence_src_dataset`, which may + batch in the training dataset `train_dataset`, which may take a long time. If `show_progress`is true, the progress of "training dataset computations" will be displayed. In particular, the number of batches for which computations have been performed @@ -688,29 +739,29 @@ def influence( # type: ignore[override] - self influence mode: if this mode is run (`inputs` is None), returns a 1D tensor of self influence scores over training dataset - `influence_src_dataset`. The length of this tensor is the number of - examples in `influence_src_dataset`, regardless of whether it is a + `train_dataset`. The length of this tensor is the number of + examples in `train_dataset`, regardless of whether it is a Dataset or DataLoader. - influence score mode: if this mode is run (`inputs is not None, `k` is None), returns a 2D tensor `influence_scores` of shape - `(input_size, influence_src_dataset_size)`, where `input_size` is + `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and - `influence_src_dataset_size` is the number of examples in - training dataset `influence_src_dataset`. In other words, + `train_dataset_size` is the number of examples in + training dataset `train_dataset`. In other words, `influence_scores[i][j]` is the influence score of the `j`-th - example in `influence_src_dataset` on the `i`-th example in the + example in `train_dataset` on the `i`-th example in the test batch. - k-most influential mode: if this mode is run (`inputs` is not None, `k` is an int), returns a namedtuple `(indices, influence_scores)`. `indices` is a 2D tensor of shape `(input_size, k)`, where `input_size` is the number of examples in the test batch. If computing proponents (resp. opponents), `indices[i][j]` is the - index in training dataset `influence_src_dataset` of the example + index in training dataset `train_dataset` of the example with the `j`-th highest (resp. lowest) influence score (out of the - examples in `influence_src_dataset`) on the `i`-th example in the + examples in `train_dataset`) on the `i`-th example in the test batch. `influence_scores` contains the corresponding influence scores. In particular, `influence_scores[i][j]` is the influence - score of example `indices[i][j]` in `influence_src_dataset` on + score of example `indices[i][j]` in `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -769,7 +820,7 @@ def _influence( show_progress: bool = False, ) -> Tensor: r""" - Computes the influence of examples in training dataset `influence_src_dataset` + Computes the influence of examples in training dataset `train_dataset` on the examples in the test batch represented by `inputs` and `targets`. This implementation does not require knowing the number of training examples in advance. Instead, the number of training examples is inferred from the @@ -778,12 +829,12 @@ def _influence( Args: inputs (Tuple of Any): A test batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that - `self.model(*inputs)` produces the predictions for the batch. + `model(*inputs)` produces the predictions for the batch. targets (tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. Default: None show_progress (bool, optional): To compute the influence of examples in - training dataset `influence_src_dataset`, we compute the influence + training dataset `train_dataset`, we compute the influence of each batch. If `show_progress`is true, the progress of this computation will be displayed. In particular, the number of batches for which influence has been computed will be displayed. It will @@ -794,29 +845,29 @@ def _influence( Returns: influence_scores (tensor): Influence scores from the TracInCP method. - Its shape is `(input_size, influence_src_dataset_size)`, where `input_size` + Its shape is `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and - `influence_src_dataset_size` is the number of examples in - training dataset `influence_src_dataset`. For example: + `train_dataset_size` is the number of examples in + training dataset `train_dataset`. For example: `influence_scores[i][j]` is the influence score for the j-th training example to the i-th input example. """ - influence_src_dataloader = self.influence_src_dataloader + train_dataloader = self.train_dataloader if show_progress: - influence_src_dataloader = progress( - influence_src_dataloader, + train_dataloader = progress( + train_dataloader, desc=( f"Using {self.get_name()} to compute " "influence for training batches" ), - total=self.influence_src_dataloader_len, + total=self.train_dataloader_len, ) return torch.cat( [ self._influence_batch_tracincp(inputs, targets, batch) - for batch in influence_src_dataloader + for batch in train_dataloader ], dim=1, ) @@ -844,7 +895,7 @@ def _get_k_most_influential( Default: True show_progress (bool, optional): To compute the proponents (or opponents) for the batch of examples, we perform computation for each batch in - training dataset `influence_src_dataset`, If `show_progress`is + training dataset `train_dataset`, If `show_progress`is true, the progress of this computation will be displayed. In particular, the number of batches for which the computation has been performed will be displayed. It will try to use tqdm if @@ -858,13 +909,13 @@ def _get_k_most_influential( test example. Its dimension is `(inputs_batch_size, k)`, where `inputs_batch_size` is the number of examples in `inputs`. For example, if `proponents==True`, `indices[i][j]` is the index of the - example in training dataset `influence_src_dataset` with the + example in training dataset `train_dataset` with the k-th highest influence score for the j-th example in `inputs`. `indices` is a `torch.long` tensor so that it can directly be used to index other tensors. Each row of `influence_scores` contains the influence scores for a different test example, in sorted order. In particular, `influence_scores[i][j]` is the influence score of - example `indices[i][j]` in training dataset `influence_src_dataset` + example `indices[i][j]` in training dataset `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -881,7 +932,7 @@ def _get_k_most_influential( ) return KMostInfluentialResults( *_get_k_most_influential_helper( - self.influence_src_dataloader, + self.train_dataloader, self._influence_batch_tracincp, inputs, targets, @@ -892,86 +943,159 @@ def _get_k_most_influential( ) ) - def _self_influence_batch_tracincp(self, batch: Tuple[Any, ...]): + def self_influence( + self, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + show_progress: bool = False, + ) -> Tensor: """ - Computes self influence scores for a single batch + Computes self influence scores for the examples in `inputs_dataset`, which is + either a single batch or a Pytorch `DataLoader` that yields batches. Therefore, + the computed self influence scores are *not* for the examples in training + dataset `train_dataset` (unlike when computing self influence scores using the + `influence` method). Note that if `inputs_dataset` is a single batch, this + will call `model` on that single batch, and if `inputs_dataset` yields + batches, this will call `model` on each batch that is yielded. Therefore, + please ensure that for both cases, the batch(es) that `model` is called + with are not too large, so that there will not be an out-of-memory error. + + Args: + batches (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, + and `batch[-1]` are the labels, if any. This is the same + assumption made for each batch yielded by training dataset + `train_dataset`. Please see documentation for the + `train_dataset` argument to `TracInCP.__init__` for + more details on the assumed structure of a batch. + show_progress (bool, optional): Computation of self influence scores can + take a long time if `inputs_dataset` represents many examples. If + `show_progress`is true, the progress of this computation will be + displayed. In more detail, this computation will iterate over all + checkpoints (provided as the `checkpoints` initialization argument) + in an outer loop, and iterate over all batches that + `inputs_dataset` represents in an inner loop. Therefore, the + total number of (checkpoint, batch) combinations that need to be + iterated over is + (# of checkpoints x # of batches that `inputs_dataset` represents). + If `show_progress` is True, the total progress of both the outer + iteration over checkpoints and the inner iteration over batches is + displayed. It will try to use tqdm if available for advanced + features (e.g. time estimation). Otherwise, it will fallback to a + simple output of progress. + Default: False + + Returns: + self_influence_scores (Tensor): This is a 1D tensor containing the self + influence scores of all examples in `inputs_dataset`, regardless of + whether it represents a single batch or a `DataLoader` that yields + batches. """ + # If `inputs_dataset` is not a `DataLoader`, turn it into one. + inputs_dataset = _format_inputs_dataset(inputs_dataset) - def get_checkpoint_contribution(checkpoint): + # If `show_progress` is true, create an outer progress bar that keeps track of + # how many checkpoints have been processed + if show_progress: + checkpoints_progress = progress( + desc=( + f"Using {self.get_name()} to compute self " + "influence. Processing checkpoint" + ), + total=len(self.checkpoints), + ) + # Try to determine length of inner progress bar if possible, with a default + # of `None`. + inputs_dataset_len = None + try: + inputs_dataset_len = len(inputs_dataset) + except TypeError: + warnings.warn( + "Unable to determine the number of batches in `inputs_dataset`. " + "Therefore, if showing the progress of the computation of self " + "influence scores, only the number of batches processed can be " + "displayed, and not the percentage completion of the computation, " + "nor any time estimates." + ) + def get_checkpoint_contribution(checkpoint): + # This function returns a 1D tensor representing the contribution to the + # self influence score for the given checkpoint, for all batches in + # `inputs_dataset`. The length of the 1D tensor is the total number of + # examples in `inputs_dataset`. assert ( checkpoint is not None ), "None returned from `checkpoints`, cannot load." learning_rate = self.checkpoints_load_func(self.model, checkpoint) - layer_jacobians = self._basic_computation_tracincp(batch[0:-1], batch[-1]) + # This will store a list of the contribution of the self influence score + # from each batch. Each element is a 1D tensor of length batch_size - the + # batch size of each batch in `inputs_dataset` (they do not need to be all + # the same) + checkpoint_contribution = [] + + _inputs_dataset = inputs_dataset + # If `show_progress` is true, create an inner progress bar that keeps track + # of how many batches have been processed for the current checkpoint + if show_progress: + _inputs_dataset = progress( + inputs_dataset, + desc=( + f"Using {self.get_name()} to compute self " + "influence. Processing batch" + ), + total=inputs_dataset_len, + ) - # note that all variables in this function are for an entire batch. - # each `layer_jacobian` in `layer_jacobians` corresponds to a different - # layer. `layer_jacobian` is the jacobian w.r.t to a given layer's - # parameters. if the given layer's parameters are of shape *, then - # `layer_jacobian` is of shape (batch_size, *). for each layer, we need - # the squared jacobian for each example. so we square the jacobian and - # sum over all dimensions except the 0-th (the batch dimension). We then - # sum the contribution over all layers. - return ( - torch.sum( - torch.stack( - [ - torch.sum(layer_jacobian.flatten(start_dim=1) ** 2, dim=1) - for layer_jacobian in layer_jacobians - ], + for batch in _inputs_dataset: + + layer_jacobians = self._basic_computation_tracincp( + batch[0:-1], batch[-1] + ) + + # Note that all variables in this function are for an entire batch. + # Each `layer_jacobian` in `layer_jacobians` corresponds to a different + # layer. `layer_jacobian` is the jacobian w.r.t to a given layer's + # parameters. If the given layer's parameters are of shape *, then + # `layer_jacobian` is of shape (batch_size, *). For each layer, we need + # the squared jacobian for each example. So we square the jacobian and + # sum over all dimensions except the 0-th (the batch dimension). We then + # sum the contribution over all layers. + checkpoint_contribution.append( + torch.sum( + torch.stack( + [ + torch.sum( + layer_jacobian.flatten(start_dim=1) ** 2, dim=1 + ) + for layer_jacobian in layer_jacobians + ], + dim=0, + ), dim=0, - ), - dim=0, + ) + * learning_rate ) - * learning_rate - ) - batch_self_tracin_scores = get_checkpoint_contribution(self.checkpoints[0]) + # We concatenate the contributions from each batch into a single 1D tensor, + # which represents the contributions for all batches in `inputs_dataset` - for checkpoint in self.checkpoints[1:]: - batch_self_tracin_scores += get_checkpoint_contribution(checkpoint) + if show_progress: + checkpoints_progress.update() - return batch_self_tracin_scores + return torch.cat(checkpoint_contribution, dim=0) - def _self_influence(self, show_progress: bool = False): - """ - Returns: - self influence scores (tensor): 1D tensor containing self influence - scores for all examples in training dataset - `influence_src_dataset`. - show_progress (bool, optional): To compute the self influence scores for - all examples in training dataset `influence_src_dataset`, we - compute the self influence scores for each batch. If - `show_progress`is true, the progress of this computation will be - displayed. In particular, the number of batches for which self - influence scores have been computed will be displayed. It will - try to use tqdm if available for advanced features (e.g. time - estimation). Otherwise, it will fallback to a simple output of - progress. - Default: False - """ - influence_src_dataloader = self.influence_src_dataloader + batches_self_tracin_scores = get_checkpoint_contribution(self.checkpoints[0]) - if show_progress: - influence_src_dataloader = progress( - influence_src_dataloader, - desc=( - f"Using {self.get_name()} to compute self " - "influence for training batches" - ), - total=self.influence_src_dataloader_len, - ) + # The self influence score for all examples is the sum of contributions from + # each checkpoint + for checkpoint in self.checkpoints[1:]: + batches_self_tracin_scores += get_checkpoint_contribution(checkpoint) - return torch.cat( - [ - self._self_influence_batch_tracincp(batch) - for batch in influence_src_dataloader - ], - dim=0, - ) + return batches_self_tracin_scores def _basic_computation_tracincp( self, @@ -987,7 +1111,7 @@ def _basic_computation_tracincp( inputs (Tuple of Any): A batch of examples, which could be a training batch or test batch, depending which method is the caller. Does not represent labels, which are passed as `targets`. The assumption is - that `self.model(*inputs)` produces the predictions for the batch. + that `model(*inputs)` produces the predictions for the batch. targets (tensor or None): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. """ diff --git a/captum/influence/_core/tracincp_fast_rand_proj.py b/captum/influence/_core/tracincp_fast_rand_proj.py index cfbf7b47d4..71fe3b45a0 100644 --- a/captum/influence/_core/tracincp_fast_rand_proj.py +++ b/captum/influence/_core/tracincp_fast_rand_proj.py @@ -13,6 +13,7 @@ ) from captum.influence._utils.common import ( _DatasetFromList, + _format_inputs_dataset, _get_k_most_influential_helper, _jacobian_loss_wrt_inputs, _load_flexible_state_dict, @@ -77,7 +78,7 @@ def __init__( self, model: Module, final_fc_layer: Union[Module, str], - influence_src_dataset: Union[Dataset, DataLoader], + train_dataset: Union[Dataset, DataLoader], checkpoints: Union[str, List[str], Iterator], checkpoints_load_func: Callable = _load_flexible_state_dict, loss_fn: Optional[Union[Module, Callable]] = None, @@ -93,7 +94,7 @@ def __init__( projection method. Can be either the layer module itself, or the fully qualified name of the layer if it is a defined attribute of the passed `model`. - influence_src_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -108,9 +109,15 @@ def __init__( DataLoader used for processing should be as large as possible, but not too large, so that certain intermediate quantities created from a batch still fit in memory. Therefore, if - `influence_src_dataset` is a Dataset, `batch_size` should be large. - If `influence_src_dataset` was already a DataLoader to begin with, - it should have been constructed to have a large batch size. + `train_dataset` is a Dataset, `batch_size` should be large. + If `train_dataset` was already a DataLoader to begin with, + it should have been constructed to have a large batch size. It is + assumed that the Dataloader (regardless of whether it is created + from a Pytorch Dataset or not) yields tuples. For a `batch` that is + yielded, of length `L`, it is assumed that the forward function of + `model` accepts `L-1` arguments, and the last element of `batch` is + the label. In other words, `model(*batch[:-1])` gives the output of + `model`, and `batch[-1]` are the labels for the batch. checkpoints (str or List of str or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which @@ -132,12 +139,12 @@ def __init__( to "mean", i.e. `loss_fn.reduction = "mean"`. Default: None batch_size (int or None, optional): Batch size of the DataLoader created to - iterate through `influence_src_dataset`, if it is a Dataset. + iterate through `train_dataset`, if it is a Dataset. `batch_size` should be chosen as large as possible so that certain intermediate quantities created from a batch still fit in memory. Specific implementations of `TracInCPBase` will detail the size of the intermediate quantities. `batch_size` must be an int if - `influence_src_dataset` is a Dataset. If `influence_src_dataset` + `train_dataset` is a Dataset. If `train_dataset` is a DataLoader, then `batch_size` is ignored as an argument. Default: 1 vectorize (bool, optional): Flag to use experimental vectorize functionality @@ -147,7 +154,7 @@ def __init__( TracInCPBase.__init__( self, model, - influence_src_dataset, + train_dataset, checkpoints, checkpoints_load_func, loss_fn, @@ -206,17 +213,17 @@ def influence( # type: ignore[override] - self influence mode: This mode is used if `inputs` is None. This mode computes the self influence scores for every example in - the training dataset `influence_src_dataset`. + the training dataset `train_dataset`. - influence score mode: This mode is used if `inputs` is not None, and `k` is None. This mode computes the influence score of every example in - training dataset `influence_src_dataset` on every example in the test + training dataset `train_dataset` on every example in the test batch represented by `inputs` and `targets`. - k-most influential mode: This mode is used if `inputs` is not None, and `k` is not None, and an int. This mode computes the proponents or opponents of every example in the test batch represented by `inputs` and `targets`. In particular, for each test example in the test batch, this mode computes its proponents (resp. opponents), which are the - indices in the training dataset `influence_src_dataset` of the training + indices in the training dataset `train_dataset` of the training examples with the `k` highest (resp. lowest) influence scores on the test example. Proponents are computed if `proponents` is True. Otherwise, opponents are computed. For each test example, this method @@ -228,12 +235,12 @@ def influence( # type: ignore[override] will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential mode. If the argument `unpack_inputs` is False, the - assumption is that `self.model(inputs)` produces the predictions + assumption is that `model(inputs)` produces the predictions for a batch, and `inputs` can be of any type. Otherwise if the argument `unpack_inputs` is True, the assumption is that - `self.model(*inputs)` produces the predictions for a batch, and + `model(*inputs)` produces the predictions for a batch, and `inputs` will need to be a tuple. In other words, `inputs` will be - unpacked as an argument when passing to `self.model`. + unpacked as an argument when passing to `model`. Default: None targets (tensor, optional): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so @@ -254,7 +261,7 @@ def influence( # type: ignore[override] Default: True show_progress (bool, optional): For all modes, computation of results requires "training dataset computations": computations for each - batch in the training dataset `influence_src_dataset`, which may + batch in the training dataset `train_dataset`, which may take a long time. If `show_progress`is true, the progress of "training dataset computations" will be displayed. In particular, the number of batches for which computations have been performed @@ -268,29 +275,29 @@ def influence( # type: ignore[override] - self influence mode: if this mode is run (`inputs` is None), returns a 1D tensor of self influence scores over training dataset - `influence_src_dataset`. The length of this tensor is the number of - examples in `influence_src_dataset`, regardless of whether it is a + `train_dataset`. The length of this tensor is the number of + examples in `train_dataset`, regardless of whether it is a Dataset or DataLoader. - influence score mode: if this mode is run (`inputs is not None, `k` is None), returns a 2D tensor `influence_scores` of shape - `(input_size, influence_src_dataset_size)`, where `input_size` is + `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and - `influence_src_dataset_size` is the number of examples in - training dataset `influence_src_dataset`. In other words, + `train_dataset_size` is the number of examples in + training dataset `train_dataset`. In other words, `influence_scores[i][j]` is the influence score of the `j`-th - example in `influence_src_dataset` on the `i`-th example in the + example in `train_dataset` on the `i`-th example in the test batch. - k-most influential mode: if this mode is run (`inputs` is not None, `k` is an int), returns a namedtuple `(indices, influence_scores)`. `indices` is a 2D tensor of shape `(input_size, k)`, where `input_size` is the number of examples in the test batch. If computing proponents (resp. opponents), `indices[i][j]` is the - index in training dataset `influence_src_dataset` of the example + index in training dataset `train_dataset` of the example with the `j`-th highest (resp. lowest) influence score (out of the - examples in `influence_src_dataset`) on the `i`-th example in the + examples in `train_dataset`) on the `i`-th example in the test batch. `influence_scores` contains the corresponding influence scores. In particular, `influence_scores[i][j]` is the influence - score of example `indices[i][j]` in `influence_src_dataset` on + score of example `indices[i][j]` in `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -351,7 +358,7 @@ def _influence( # type: ignore[override] show_progress: bool = False, ) -> Tensor: r""" - Computes the influence of examples in training dataset `influence_src_dataset` + Computes the influence of examples in training dataset `train_dataset` on the examples in the test batch represented by `inputs` and `targets`. This implementation does not require knowing the number of training examples in advance. Instead, the number of training examples is inferred from the @@ -360,12 +367,12 @@ def _influence( # type: ignore[override] Args: inputs (Tuple of Any): A batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that - `self.model(*inputs)` produces the predictions for the batch. + `model(*inputs)` produces the predictions for the batch. targets (tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so labels are required. show_progress (bool, optional): To compute the influence of examples in - training dataset `influence_src_dataset`, we compute the influence + training dataset `train_dataset`, we compute the influence of each batch. If `show_progress`is true, the progress of this computation will be displayed. In particular, the number of batches for which influence has been computed will be displayed. It will @@ -376,31 +383,31 @@ def _influence( # type: ignore[override] Returns: influence_scores (tensor): Influence scores from the TracInCPFast method. - Its shape is `(input_size, influence_src_dataset_size)`, where `input_size` + Its shape is `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and - `influence_src_dataset_size` is the number of examples in - training dataset `influence_src_dataset`. For example: + `train_dataset_size` is the number of examples in + training dataset `train_dataset`. For example: `influence_scores[i][j]` is the influence score for the j-th training example to the i-th input example. """ assert targets is not None - influence_src_dataloader = self.influence_src_dataloader + train_dataloader = self.train_dataloader if show_progress: - influence_src_dataloader = progress( - influence_src_dataloader, + train_dataloader = progress( + train_dataloader, desc=( f"Using {self.get_name()} to compute " "influence for training batches" ), - total=self.influence_src_dataloader_len, + total=self.train_dataloader_len, ) return torch.cat( [ self._influence_batch_tracincp_fast(inputs, targets, batch) - for batch in influence_src_dataloader + for batch in train_dataloader ], dim=1, ) @@ -428,7 +435,7 @@ def _get_k_most_influential( # type: ignore[override] Default: True show_progress (bool, optional): To compute the proponents (or opponents) for the batch of examples, we perform computation for each batch in - training dataset `influence_src_dataset`, If `show_progress`is + training dataset `train_dataset`, If `show_progress`is true, the progress of this computation will be displayed. In particular, the number of batches for which the computation has been performed will be displayed. It will try to use tqdm if @@ -442,13 +449,13 @@ def _get_k_most_influential( # type: ignore[override] test example. Its dimension is `(inputs_batch_size, k)`, where `inputs_batch_size` is the number of examples in `inputs`. For example, if `proponents==True`, `indices[i][j]` is the index of the - example in training dataset `influence_src_dataset` with the + example in training dataset `train_dataset` with the k-th highest influence score for the j-th example in `inputs`. `indices` is a `torch.long` tensor so that it can directly be used to index other tensors. Each row of `influence_scores` contains the influence scores for a different test example, in sorted order. In particular, `influence_scores[i][j]` is the influence score of - example `indices[i][j]` in training dataset `influence_src_dataset` + example `indices[i][j]` in training dataset `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -465,7 +472,7 @@ def _get_k_most_influential( # type: ignore[override] ) return KMostInfluentialResults( *_get_k_most_influential_helper( - self.influence_src_dataloader, + self.train_dataloader, self._influence_batch_tracincp_fast, inputs, targets, @@ -476,72 +483,141 @@ def _get_k_most_influential( # type: ignore[override] ) ) - def _self_influence_batch_tracincp_fast(self, batch: Tuple[Any, ...]): + def self_influence( + self, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + show_progress: bool = False, + ) -> Tensor: """ - Computes self influence scores for a single batch + Computes self influence scores for the examples in `inputs_dataset`, which is + either a single batch or a Pytorch `DataLoader` that yields batches. Therefore, + the computed self influence scores are *not* for the examples in training + dataset `train_dataset` (unlike when computing self influence scores using the + `influence` method). Note that if `inputs_dataset` is a single batch, this + will call `model` on that single batch, and if `inputs_dataset` yields + batches, this will call `model` on each batch that is yielded. Therefore, + please ensure that for both cases, the batch(es) that `model` is called + with are not too large, so that there will not be an out-of-memory error. + + Args: + batches (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, + and `batch[-1]` are the labels, if any. This is the same + assumption made for each batch yielded by training dataset + `train_dataset`. Please see documentation for the + `train_dataset` argument to `TracInCP.__init__` for + more details on the assumed structure of a batch. + show_progress (bool, optional): Computation of self influence scores can + take a long time if `inputs_dataset` represents many examples. If + `show_progress`is true, the progress of this computation will be + displayed. In more detail, this computation will iterate over all + checkpoints (provided as the `checkpoints` initialization argument) + in an outer loop, and iterate over all batches that + `inputs_dataset` represents in an inner loop. Therefore, the + total number of (checkpoint, batch) combinations that need to be + iterated over is + (# of checkpoints x # of batches that `inputs_dataset` represents). + If `show_progress` is True, the total progress of both the outer + iteration over checkpoints and the inner iteration over batches is + displayed. It will try to use tqdm if available for advanced + features (e.g. time estimation). Otherwise, it will fallback to a + simple output of progress. + Default: False + + Returns: + self_influence_scores (Tensor): This is a 1D tensor containing the self + influence scores of all examples in `inputs_dataset`, regardless of + whether it represents a single batch or a `DataLoader` that yields + batches. """ + # If `inputs_dataset` is not a `DataLoader`, turn it into one. + inputs_dataset = _format_inputs_dataset(inputs_dataset) - def get_checkpoint_contribution(checkpoint): + # If `show_progress` is true, create an outer progress bar that keeps track of + # how many checkpoints have been processed + if show_progress: + checkpoints_progress = progress( + desc=( + f"Using {self.get_name()} to compute self " + "influence. Processing checkpoint" + ), + total=len(self.checkpoints), + ) + # Try to determine length of inner progress bar if possible, with a default + # of `None`. + inputs_dataset_len = None + try: + inputs_dataset_len = len(inputs_dataset) + except TypeError: + warnings.warn( + "Unable to determine the number of batches in `inputs_dataset`. " + "Therefore, if showing the progress of the computation of self " + "influence scores, only the number of batches processed can be " + "displayed, and not the percentage completion of the computation, " + "nor any time estimates." + ) + def get_checkpoint_contribution(checkpoint): + # This function returns a 1D tensor representing the contribution to the + # self influence score for the given checkpoint, for all batches in + # `inputs_dataset`. The length of the 1D tensor is the total number of + # examples in `inputs_dataset`. assert ( checkpoint is not None ), "None returned from `checkpoints`, cannot load." learning_rate = self.checkpoints_load_func(self.model, checkpoint) - batch_jacobian, batch_layer_input = _basic_computation_tracincp_fast( - self, batch[0:-1], batch[-1] - ) + # This will store a list of the contribution of the self influence score + # from each batch. Each element is a 1D tensor of length batch_size - the + # batch size of each batch in `inputs_dataset` (they do not need to be all + # the same) + checkpoint_contribution = [] + + _inputs_dataset = inputs_dataset + # If `show_progress` is true, create an inner progress bar that keeps track + # of how many batches have been processed for the current checkpoint + if show_progress: + _inputs_dataset = progress( + inputs_dataset, + desc=( + f"Using {self.get_name()} to compute self " + "influence. Processing batch" + ), + total=inputs_dataset_len, + ) - return ( - torch.sum(batch_jacobian**2, dim=1) - * torch.sum(batch_layer_input**2, dim=1) - * learning_rate - ) + for batch in _inputs_dataset: - batch_self_tracin_scores = get_checkpoint_contribution(self.checkpoints[0]) + batch_jacobian, batch_layer_input = _basic_computation_tracincp_fast( + self, batch[0:-1], batch[-1] + ) - for checkpoint in self.checkpoints[1:]: - batch_self_tracin_scores += get_checkpoint_contribution(checkpoint) + checkpoint_contribution.append( + torch.sum(batch_jacobian**2, dim=1) + * torch.sum(batch_layer_input**2, dim=1) + * learning_rate + ) - return batch_self_tracin_scores + # We concatenate the contributions from each batch into a single 1D tensor, + # which represents the contributions for all batches in `inputs_dataset` - def _self_influence(self, show_progress: bool = False): - """ - Returns: - self influence scores (tensor): 1D tensor containing self influence - scores for all examples in training dataset - `influence_src_dataset`. - show_progress (bool, optional): To compute the self influence scores for - all examples in training dataset `influence_src_dataset`, we - compute the self influence scores for each batch. If - `show_progress`is true, the progress of this computation will be - displayed. In particular, the number of batches for which self - influence scores have been computed will be displayed. It will - try to use tqdm if available for advanced features (e.g. time - estimation). Otherwise, it will fallback to a simple output of - progress. - Default: False - """ - influence_src_dataloader = self.influence_src_dataloader + if show_progress: + checkpoints_progress.update() - if show_progress: - influence_src_dataloader = progress( - influence_src_dataloader, - desc=( - f"Using {self.get_name()} to compute self " - "influence for training batches" - ), - total=self.influence_src_dataloader_len, - ) + return torch.cat(checkpoint_contribution, dim=0) - return torch.cat( - [ - self._self_influence_batch_tracincp_fast(batch) - for batch in influence_src_dataloader - ], - dim=0, - ) + batches_self_tracin_scores = get_checkpoint_contribution(self.checkpoints[0]) + + # The self influence score for all examples is the sum of contributions from + # each checkpoint + for checkpoint in self.checkpoints[1:]: + batches_self_tracin_scores += get_checkpoint_contribution(checkpoint) + + return batches_self_tracin_scores def _basic_computation_tracincp_fast( @@ -564,7 +640,7 @@ def _basic_computation_tracincp_fast( inputs (Tuple of Any): A batch of examples, which could be a training batch or test batch, depending which method is the caller. Does not represent labels, which are passed as `targets`. The assumption is - that `self.model(*inputs)` produces the predictions for the batch. + that `model(*inputs)` produces the predictions for the batch. targets (tensor): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. """ @@ -599,7 +675,7 @@ def __init__( self, model: Module, final_fc_layer: Union[Module, str], - influence_src_dataset: Union[Dataset, DataLoader], + train_dataset: Union[Dataset, DataLoader], checkpoints: Union[str, List[str], Iterator], checkpoints_load_func: Callable = _load_flexible_state_dict, loss_fn: Optional[Union[Module, Callable]] = None, @@ -620,10 +696,10 @@ def __init__( interactive use cases. It should not be used if `influence` will only be called once, because to enable fast calls to `influence`, time and memory intensive preprocessing is required in `__init__`. Furthermore, it should not - be used to calculate self influencs scores - `TracInCPFast` should be used + be used to calculate self influence scores - `TracInCPFast` should be used instead for that purpose. To enable interactive analysis, this implementation - saves pre-computed vectors for all training examples in - `influence_src_dataset`. Crucially, the influence score of a training + computes and saves "embedding" vectors for all training examples in + `train_dataset`. Crucially, the influence score of a training example on a test example is simply the dot-product of their corresponding vectors, and proponents / opponents can be found by first storing vectors for training examples in a nearest-neighbor data structure, and then finding the @@ -631,7 +707,7 @@ def __init__( of the TracIn paper). This class should only be used if calls to `influence` to obtain proponents / opponents or influence scores will be made in an "interactive" manner, and there is sufficient memory to store vectors for the - entire `influence_src_dataset`. This is because in order to enable interactive + entire `train_dataset`. This is because in order to enable interactive analysis, this implementation incures overhead in ``__init__` to setup the nearest-neighbors data structure, which is both time and memory intensive, as vectors corresponding to all training examples needed to be stored. To reduce @@ -647,7 +723,7 @@ def __init__( projection method. Can be either the layer module itself, or the fully qualified name of the layer if it is a defined attribute of the passed `model`. - influence_src_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -662,9 +738,15 @@ def __init__( DataLoader used for processing should be as large as possible, but not too large, so that certain intermediate quantities created from a batch still fit in memory. Therefore, if - `influence_src_dataset` is a Dataset, `batch_size` should be large. - If `influence_src_dataset` was already a DataLoader to begin with, - it should have been constructed to have a large batch size. + `train_dataset` is a Dataset, `batch_size` should be large. + If `train_dataset` was already a DataLoader to begin with, + it should have been constructed to have a large batch size. It is + assumed that the Dataloader (regardless of whether it is created + from a Pytorch Dataset or not) yields tuples. For a `batch` that is + yielded, of length `L`, it is assumed that the forward function of + `model` accepts `L-1` arguments, and the last element of `batch` is + the label. In other words, `model(*batch[:-1])` gives the output of + `model`, and `batch[-1]` are the labels for the batch. checkpoints (str or List of str or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which @@ -682,12 +764,12 @@ def __init__( `nn.BCELoss(reduction="mean")` is *not* acceptable. Default: None batch_size (int or None, optional): Batch size of the DataLoader created to - iterate through `influence_src_dataset`, if it is a Dataset. + iterate through `train_dataset`, if it is a Dataset. `batch_size` should be chosen as large as possible so that certain intermediate quantities created from a batch still fit in memory. Specific implementations of `TracInCPBase` will detail the size of the intermediate quantities. `batch_size` must be an int if - `influence_src_dataset` is a Dataset. If `influence_src_dataset` + `train_dataset` is a Dataset. If `train_dataset` is a DataLoader, then `batch_size` is ignored as an argument. Default: 1 vectorize (bool): Flag to use experimental vectorize functionality @@ -728,7 +810,7 @@ def __init__( self, model, final_fc_layer, - influence_src_dataset, + train_dataset, checkpoints, checkpoints_load_func, loss_fn, @@ -739,7 +821,7 @@ def __init__( warnings.warn( ( "WARNING: Using this implementation stores quantities related to the " - "entire `influence_src_dataset` in memory, and may results in running " + "entire `train_dataset` in memory, and may results in running " "out of memory. If this happens, consider using %s instead, for which " "each call to `influence` to compute influence scores or proponents " "will be slower, but may avoid running out of memory." @@ -755,12 +837,12 @@ def __init__( torch.manual_seed(seed) # for reproducibility self.projection_quantities = self._set_projections_tracincp_fast_rand_proj( - self.influence_src_dataloader, + self.train_dataloader, ) self.src_intermediate_quantities = ( self._get_intermediate_quantities_tracincp_fast_rand_proj( - self.influence_src_dataloader, + self.train_dataloader, self.projection_quantities, ) ) @@ -778,7 +860,7 @@ def _influence( # type: ignore[override] Args: inputs (tuple of Any): A batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that - `self.model(*inputs)` produces the predictions for the batch. + `model(*inputs)` produces the predictions for the batch. targets (tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so labels are required. @@ -786,9 +868,9 @@ def _influence( # type: ignore[override] Returns: influence_scores (tensor): Influence scores from the TracInCPFastRandProj method. Its shape is - `(input_size, influence_src_dataset_size)`, where `input_size` is the - number of examples in the test batch, and `influence_src_dataset_size` is - the number of examples in training dataset `influence_src_dataset`. For + `(input_size, train_dataset_size)`, where `input_size` is the + number of examples in the test batch, and `train_dataset_size` is + the number of examples in training dataset `train_dataset`. For example, `influence_scores[i][j]` is the influence score for the j-th training example to the i-th input example. """ @@ -831,13 +913,13 @@ def _get_k_most_influential( # type: ignore[override] test example. Its dimension is `(inputs_batch_size, k)`, where `inputs_batch_size` is the number of examples in `inputs`. For example, if `proponents==True`, `indices[i][j]` is the index of the - example in training dataset `influence_src_dataset` with the + example in training dataset `train_dataset` with the k-th highest influence score for the j-th example in `inputs`. `indices` is a `torch.long` tensor so that it can directly be used to index other tensors. Each row of `influence_scores` contains the influence scores for a different test example, in sorted order. In particular, `influence_scores[i][j]` is the influence score of - example `indices[i][j]` in training dataset `influence_src_dataset` + example `indices[i][j]` in training dataset `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -860,17 +942,55 @@ def _get_k_most_influential( # type: ignore[override] return KMostInfluentialResults(indices, distances) - def _self_influence(self): + def self_influence( + self, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + show_progress: bool = False, + ) -> Tensor: """ - NOT IMPLEMENTED - no need to implement `TracInCPFastRandProj._self_influence`, - as `TracInCPFast._self_influence` is sufficient - the latter does not benefit + NOT IMPLEMENTED - no need to implement `TracInCPFastRandProj.self_influence`, + as `TracInCPFast.self_influence` is sufficient - the latter does not benefit from random projections, since no quantities associated with a training example are stored (other than its self influence score) + Computes self influence scores for a single batch or a Pytorch `DataLoader` + that yields batches. Note that if `inputs_dataset` is a single batch, this + will call `model` on that single batch, and if `inputs_dataset` yields + batches, this will call `model` on each batch that is yielded. Therefore, + please ensure that for both cases, the batch(es) that `model` is called + with are not too large, so that there will not be an out-of-memory error. + + Args: + batches (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, + and `batch[-1]` are the labels, if any. This is the same + assumption made for each batch yielded by training dataset + `train_dataset`. Please see documentation for the + `train_dataset` argument to `TracInCP.__init__` for + more details on the assumed structure of a batch. + show_progress (bool, optional): Computation of self influence scores can + take a long time if `inputs_dataset` represents many examples. If + `show_progress`is true, the progress of this computation will be + displayed. In more detail, this computation will iterate over all + checkpoints (provided as the `checkpoints` initialization argument) + and all batches that `inputs_dataset` represents. Therefore, the + total number of (checkpoint, batch) combinations that need to be + iterated over is + (# of checkpoints x # of batches that `inputs_dataset` represents). + If `show_progress` is True, the total number of such combinations + that have been iterated over is displayed. It will try to use tqdm + if available for advanced features (e.g. time estimation). + Otherwise, it will fallback to a simple output of progress. + Default: False + Returns: - self influence scores (Tensor): 1-d Tensor containing self influence - scores for all examples in training dataset - `influence_src_dataset`. + self_influence_scores (Tensor): This is a 1D tensor containing the self + influence scores of all examples in `inputs_dataset`, regardless of + whether it represents a single batch or a `DataLoader` that yields + batches. """ warnings.warn( ( @@ -883,7 +1003,7 @@ def _self_influence(self): "`TracInCPFastRandProj`needed. Further considering the fact that " "random projections results only in approximate self influence " "scores, there is no reason to use `TracInCPFastRandProj` when " - "calculating self-influence scores." + "calculating self influence scores." ) ) raise NotImplementedError @@ -903,7 +1023,7 @@ def influence( # type: ignore[override] - influence score mode: This mode is used if `inputs` is not None, and `k` is None. This mode computes the influence score of every example in - training dataset `influence_src_dataset` on every example in the test + training dataset `train_dataset` on every example in the test batch represented by `inputs` and `targets`. - k-most influential mode: This mode is used if `inputs` is not None, and @@ -911,7 +1031,7 @@ def influence( # type: ignore[override] opponents of every example in the test batch represented by `inputs` and `targets`. In particular, for each test example in the test batch, this mode computes its proponents (resp. opponents), which are the - indices in the training dataset `influence_src_dataset` of the training + indices in the training dataset `train_dataset` of the training examples with the `k` highest (resp. lowest) influence scores on the test example. Proponents are computed if `proponents` is True. Otherwise, opponents are computed. For each test example, this method @@ -927,12 +1047,12 @@ def influence( # type: ignore[override] will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential mode. If the argument `unpack_inputs` is False, the - assumption is that `self.model(inputs)` produces the predictions + assumption is that `model(inputs)` produces the predictions for a batch, and `inputs` can be of any type. Otherwise if the argument `unpack_inputs` is True, the assumption is that - `self.model(*inputs)` produces the predictions for a batch, and + `model(*inputs)` produces the predictions for a batch, and `inputs` will need to be a tuple. In other words, `inputs` will be - unpacked as an argument when passing to `self.model`. + unpacked as an argument when passing to `model`. Default: None targets (tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so `targets` @@ -957,24 +1077,24 @@ def influence( # type: ignore[override] - influence score mode: if this mode is run (`inputs is not None, `k` is None), returns a 2D tensor `influence_scores` of shape - `(input_size, influence_src_dataset_size)`, where `input_size` is + `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and - `influence_src_dataset_size` is the number of examples in - training dataset `influence_src_dataset`. In other words, + `train_dataset_size` is the number of examples in + training dataset `train_dataset`. In other words, `influence_scores[i][j]` is the influence score of the `j`-th - example in `influence_src_dataset` on the `i`-th example in the + example in `train_dataset` on the `i`-th example in the test batch. - k-most influential mode: if this mode is run (`inputs` is not None, `k` is an int), returns a namedtuple `(indices, influence_scores)`. `indices` is a 2D tensor of shape `(input_size, k)`, where `input_size` is the number of examples in the test batch. If computing proponents (resp. opponents), `indices[i][j]` is the - index in training dataset `influence_src_dataset` of the example + index in training dataset `train_dataset` of the example with the `j`-th highest (resp. lowest) influence score (out of the - examples in `influence_src_dataset`) on the `i`-th example in the + examples in `train_dataset`) on the `i`-th example in the test batch. `influence_scores` contains the corresponding influence scores. In particular, `influence_scores[i][j]` is the influence - score of example `indices[i][j]` in `influence_src_dataset` on + score of example `indices[i][j]` in `train_dataset` on example `i` in the test batch represented by `inputs` and `targets`. """ @@ -990,7 +1110,7 @@ def influence( # type: ignore[override] _inputs = _format_inputs(inputs, unpack_inputs) if inputs is None: - return self._self_influence() + return self.self_influence(self.train_dataloader) elif k is None: return self._influence(_inputs, targets) else: @@ -1014,7 +1134,7 @@ def _set_projections_tracincp_fast_rand_proj( dataloader (DataLoader): determining the projection requires knowing the dimensionality of the last layer's parameters (`jacobian_dim` below) and its input (`layer_input_dim` below). These are - determined by passing a batch to `self.model`. `dataloader` + determined by passing a batch to `model`. `dataloader` provides that batch. Returns: @@ -1096,7 +1216,7 @@ def _process_src_intermediate_quantities_tracincp_fast_rand_proj( Args: src_intermediate_quantities (tensor): the output of the `_get_intermediate_quantities_tracin_fast_rand_proj` function when - applied to training dataset `influence_src_dataset`. This + applied to training dataset `train_dataset`. This output is the vector representation of all training examples. The dot product between the representation of a training example and the representation of a test example gives the influence score @@ -1143,6 +1263,8 @@ def _get_intermediate_quantities_tracincp_fast_rand_proj( the variable d in the top of page 15 of the TracIn paper: https://arxiv.org/pdf/2002.08484.pdf. """ + # for each checkpoint, this stores a list of projections for a batch + # each element in this list will be of shape (batch_size, projection_dim) checkpoint_projections: List[Any] = [[] for _ in self.checkpoints] if projection_quantities is None: diff --git a/captum/influence/_utils/common.py b/captum/influence/_utils/common.py index b86ddf9f93..d6f1c99f20 100644 --- a/captum/influence/_utils/common.py +++ b/captum/influence/_utils/common.py @@ -313,3 +313,15 @@ def __getitem__(self, i: int) -> Any: def __len__(self) -> int: return len(self._l) + + +def _format_inputs_dataset(inputs_dataset: Union[Tuple[Any, ...], DataLoader]): + # if `inputs_dataset` is not a `DataLoader`, turn it into one. + # `_DatasetFromList` turns a list into a `Dataset` where `__getitem__` + # returns an element in the list, and using it to construct a `DataLoader` + # with `batch_size=None` gives a `DataLoader` that yields a single batch. + if not isinstance(inputs_dataset, DataLoader): + inputs_dataset = DataLoader( + _DatasetFromList([inputs_dataset]), shuffle=False, batch_size=None + ) + return inputs_dataset diff --git a/tests/influence/_core/test_tracin_self_influence.py b/tests/influence/_core/test_tracin_self_influence.py index 60f0be2678..9448982a58 100644 --- a/tests/influence/_core/test_tracin_self_influence.py +++ b/tests/influence/_core/test_tracin_self_influence.py @@ -12,6 +12,7 @@ DataInfluenceConstructor, get_random_model_and_data, ) +from torch.utils.data import DataLoader class TestTracInSelfInfluence(BaseTest): @@ -33,7 +34,7 @@ class TestTracInSelfInfluence(BaseTest): ("mean", DataInfluenceConstructor(TracInCPFast)), ] ], - name_func=build_test_name_func(args_to_skip=["reduction"]), + name_func=build_test_name_func(), ) def test_tracin_self_influence( self, reduction: str, tracin_constructor: Callable, unpack_inputs: bool @@ -73,3 +74,70 @@ def test_tracin_self_influence( delta=0.01, mode="max", ) + + @parameterized.expand( + [ + (reduction, constructor, unpack_inputs) + for unpack_inputs in [True, False] + for (reduction, constructor) in [ + ("none", DataInfluenceConstructor(TracInCP)), + ( + "sum", + DataInfluenceConstructor( + TracInCP, + sample_wise_grads_per_batch=True, + ), + ), + ("sum", DataInfluenceConstructor(TracInCPFast)), + ("mean", DataInfluenceConstructor(TracInCPFast)), + ] + ], + name_func=build_test_name_func(), + ) + def test_tracin_self_influence_dataloader_vs_single_batch( + self, reduction: str, tracin_constructor: Callable, unpack_inputs: bool + ) -> None: + # tests that the result of calling the public method `self_influence` for a + # DataLoader of batches is the same as when the batches are collated into a + # single batch + with tempfile.TemporaryDirectory() as tmpdir: + ( + net, + train_dataset, + ) = get_random_model_and_data(tmpdir, unpack_inputs, return_test_data=False) + + # create a single batch representing the entire dataset + single_batch = next( + iter(DataLoader(train_dataset, batch_size=len(train_dataset))) + ) + + # create a dataloader that yields batches from the dataset + dataloader = DataLoader(train_dataset, batch_size=5) + + # create tracin instance + criterion = nn.MSELoss(reduction=reduction) + batch_size = 5 + tracin = tracin_constructor( + net, + train_dataset, + tmpdir, + batch_size, + criterion, + ) + + # compute self influence using `self_influence` when passing in a single + # batch + single_batch_self_influence = tracin.self_influence(single_batch) + + # compute self influence using `self_influence` when passing in a + # dataloader with the same examples + dataloader_self_influence = tracin.self_influence(dataloader) + + # the two self influences should be equal + assertTensorAlmostEqual( + self, + single_batch_self_influence, + dataloader_self_influence, + delta=0.01, # due to numerical issues, we can't set this to 0.0 + mode="max", + ) diff --git a/tests/influence/_core/test_tracin_show_progress.py b/tests/influence/_core/test_tracin_show_progress.py index 5b35352880..17b9065458 100644 --- a/tests/influence/_core/test_tracin_show_progress.py +++ b/tests/influence/_core/test_tracin_show_progress.py @@ -49,115 +49,148 @@ class TestTracInShowProgress(BaseTest): ], name_func=build_test_name_func(args_to_skip=["reduction"]), ) - @unittest.mock.patch("sys.stderr", new_callable=io.StringIO) def test_tracin_show_progress( self, reduction: str, tracin_constructor: Callable, mode: str, - mock_stderr, ) -> None: - with tempfile.TemporaryDirectory() as tmpdir: + with unittest.mock.patch("sys.stderr", new_callable=io.StringIO) as mock_stderr: - batch_size = 5 + with tempfile.TemporaryDirectory() as tmpdir: - ( - net, - train_dataset, - test_samples, - test_labels, - ) = get_random_model_and_data( - tmpdir, unpack_inputs=False, return_test_data=True - ) + batch_size = 5 - self.assertTrue(isinstance(reduction, str)) - criterion = nn.MSELoss(reduction=reduction) + ( + net, + train_dataset, + test_samples, + test_labels, + ) = get_random_model_and_data( + tmpdir, unpack_inputs=False, return_test_data=True + ) - self.assertTrue(callable(tracin_constructor)) - tracin = tracin_constructor( - net, - train_dataset, - tmpdir, - batch_size, - criterion, - ) + self.assertTrue(isinstance(reduction, str)) + criterion = nn.MSELoss(reduction=reduction) - if mode == "self influence": - tracin.influence(show_progress=True) - output = mock_stderr.getvalue() - self.assertTrue( - ( - ( - f"Using {tracin.get_name()} to compute self influence " - "for training batches: 100%" - ) - in output - ), - f"Error progress output: {repr(output)}", + self.assertTrue(callable(tracin_constructor)) + tracin = tracin_constructor( + net, + train_dataset, + tmpdir, + batch_size, + criterion, ) - elif mode == "influence": - tracin.influence( - test_samples, - test_labels, - k=None, - show_progress=True, - ) - output = mock_stderr.getvalue() - self.assertTrue( - ( - ( - f"Using {tracin.get_name()} to compute influence " - "for training batches: 100%" + if mode == "self influence": + + # For self influence, displaying progress involves nested progress + # bars, which are not currently supported by the backup + # `SimpleProgress` that is used if `tqdm` is not installed. + # Therefore, we skip the test in this case. + # TODO: support nested progress bars for `SimpleProgress` + try: + import tqdm # noqa + except ModuleNotFoundError: + raise unittest.SkipTest( + ( + "Skipping self influence progress bar tests for " + f"{tracin.get_name()}, because proper displaying " + "requires the tqdm module, which is not installed." + ) ) - in output - ), - f"Error progress output: {repr(output)}", - ) - elif mode == "k-most": - tracin.influence( - test_samples, - test_labels, - k=2, - proponents=True, - show_progress=True, - ) - output = mock_stderr.getvalue() - self.assertTrue( - ( + tracin.influence(show_progress=True) + output = mock_stderr.getvalue() + # We are showing nested progress bars for the `self_influence` + # method, with the outer progress bar over checkpoints, and + # the inner progress bar over batches. First, we check that + # the outer progress bar reaches 100% once + self.assertEqual( + output.count( + ( + f"Using {tracin.get_name()} to compute self influence. " + "Processing checkpoint: 100%" + ) + ), + 1, + f"Error in progress of batches with output: {repr(output)}", + ) + # Second, we check that the inner progress bar reaches 100% + # once for each checkpoint in `tracin.checkpoints` + self.assertEqual( + output.count( + ( + f"Using {tracin.get_name()} to compute self influence. " + "Processing batch: 100%" + ) + ), + len(tracin.checkpoints), + f"Error in progress of checkpoints with output: {repr(output)}", + ) + elif mode == "influence": + + tracin.influence( + test_samples, + test_labels, + k=None, + show_progress=True, + ) + output = mock_stderr.getvalue() + self.assertTrue( ( - f"Using {tracin.get_name()} to perform computation for " - "getting proponents. Processing training batches: 100%" - ) - in output - ), - f"Error progress output: {repr(output)}", - ) - mock_stderr.seek(0) - mock_stderr.truncate(0) + ( + f"Using {tracin.get_name()} to compute influence " + "for training batches: 100%" + ) + in output + ), + f"Error progress output: {repr(output)}", + ) + elif mode == "k-most": - tracin.influence( - test_samples, - test_labels, - k=2, - proponents=False, - show_progress=True, - ) - output = mock_stderr.getvalue() - self.assertTrue( - ( + tracin.influence( + test_samples, + test_labels, + k=2, + proponents=True, + show_progress=True, + ) + output = mock_stderr.getvalue() + self.assertTrue( ( - f"Using {tracin.get_name()} to perform computation for " - "getting opponents. Processing training batches: 100%" - ) - in output - ), - f"Error progress output: {repr(output)}", - ) - else: - raise Exception("unknown test mode") + ( + f"Using {tracin.get_name()} to perform computation for " + "getting proponents. Processing training batches: 100%" + ) + in output + ), + f"Error progress output: {repr(output)}", + ) + mock_stderr.seek(0) + mock_stderr.truncate(0) - mock_stderr.seek(0) - mock_stderr.truncate(0) + tracin.influence( + test_samples, + test_labels, + k=2, + proponents=False, + show_progress=True, + ) + output = mock_stderr.getvalue() + self.assertTrue( + ( + ( + f"Using {tracin.get_name()} to perform computation for " + "getting opponents. Processing training batches: 100%" + ) + in output + ), + f"Error progress output: {repr(output)}", + ) + else: + raise Exception("unknown test mode") + + mock_stderr.seek(0) + mock_stderr.truncate(0) From a08883f1ba3abc96ace06b11883893419b187d09 Mon Sep 17 00:00:00 2001 From: Fulton Wang Date: Mon, 1 Aug 2022 09:30:43 -0700 Subject: [PATCH 111/174] allow self influence iteration options (#1002) Summary: Pull Request resolved: https://github.com/pytorch/captum/pull/1002 - For self influence computation, there needs to be an iteration over both checkpoints as well as batches. This diff adds a `by_checkpoints` option. If true, the outer iteration is over checkpoints. If false, the outer iteration is over checkpoints. Because self influence computation can be called through the `influence` and `self_influence` methods, this option is added to both methods. Because only `TracInCP` and `TracInCPFast` should be used for self influence computation, only those classes are changed. - The implement this option, the old `self_influence` method, which had the outer iteration over checkpoints, is renamed to be a private `_self_influence_by_checkpoints` method. A new `_self_influence_by_batches` method is added, which has an outer iteration over batches, and re-uses the `_self_influence_by_checkpoints` method to compute self influence scores for a single batch (this method can accept both a single batch, as well as a dataloader yielding batches). Because the logic of this method is the same for all classes, a helper method, `_self_influence_by_batches_helper`, is added to `captum.influence._utils.common`. Finally, the new `self_influence` method simply chooses whether to call `_self_influence_by_checkpoints` or `_self_influence_by_batches`. - Documentation describing the two options for `by_checkpoints` is added to the `self_influence` and `influence` methods. - `test_tracin_show_progress` now differentiates between 2 modes: "self influence by checkpoints" (the original test for progress bar when calculating self influence scores, which checks whether the outer progress bar over checkpoints and inner progress bars over batches both reach 100%), and the newly added mode "self influence by batches", which checks whether the progress bar over batches reaches 100%. - `test_tracin_self_influence` now also checks whether computing self influence scores gives the same result regardless of whether `by_checkpoints` is True or False Reviewed By: NarineK Differential Revision: D37743920 fbshipit-source-id: ead1bbc86e8eac477768113b9939556d9b1c0de1 --- captum/influence/_core/tracincp.py | 102 +++++++++++--- .../_core/tracincp_fast_rand_proj.py | 104 ++++++++++++--- captum/influence/_utils/common.py | 94 +++++++++++++ .../_core/test_tracin_self_influence.py | 21 ++- .../_core/test_tracin_show_progress.py | 126 ++++++++++++------ 5 files changed, 372 insertions(+), 75 deletions(-) diff --git a/captum/influence/_core/tracincp.py b/captum/influence/_core/tracincp.py index 78fa32738f..15811e684b 100644 --- a/captum/influence/_core/tracincp.py +++ b/captum/influence/_core/tracincp.py @@ -30,6 +30,7 @@ _get_k_most_influential_helper, _gradient_dot_product, _load_flexible_state_dict, + _self_influence_by_batches_helper, ) from captum.log import log_usage from torch import Tensor @@ -475,7 +476,8 @@ def _influence_route_to_helpers( if inputs is None: return influence_instance.self_influence( - influence_instance.train_dataloader, show_progress + influence_instance.train_dataloader, + show_progress, ) elif k is None: return influence_instance._influence(_inputs, targets, show_progress) @@ -727,11 +729,9 @@ def influence( # type: ignore[override] requires "training dataset computations": computations for each batch in the training dataset `train_dataset`, which may take a long time. If `show_progress`is true, the progress of - "training dataset computations" will be displayed. In particular, - the number of batches for which computations have been performed - will be displayed. It will try to use tqdm if available for - advanced features (e.g. time estimation). Otherwise, it will - fallback to a simple output of progress. + "training dataset computations" will be displayed. It will try to + use tqdm if available for advanced features (e.g. time estimation). + Otherwise, it will fallback to a simple output of progress. Default: False Returns: @@ -926,7 +926,7 @@ def _get_k_most_influential( ( f"Using {self.get_name()} to perform computation for " f'getting {"proponents" if proponents else "opponents"}. ' - "Processing training batches: 100%" + "Processing training batches" ) ) ) @@ -943,7 +943,7 @@ def _get_k_most_influential( ) ) - def self_influence( + def _self_influence_by_checkpoints( self, inputs_dataset: Union[Tuple[Any, ...], DataLoader], show_progress: bool = False, @@ -957,7 +957,11 @@ def self_influence( will call `model` on that single batch, and if `inputs_dataset` yields batches, this will call `model` on each batch that is yielded. Therefore, please ensure that for both cases, the batch(es) that `model` is called - with are not too large, so that there will not be an out-of-memory error. + with are not too large, so that there will not be an out-of-memory error. This + implementation performs an outer iteration over checkpoints, and an inner + iteration over all batches that `inputs_dataset` represents. The pros of this + implementation are that the checkpoints do not need to be loaded too many + times. Args: batches (Tuple, or DataLoader): Either a single tuple of any, or a @@ -976,13 +980,10 @@ def self_influence( displayed. In more detail, this computation will iterate over all checkpoints (provided as the `checkpoints` initialization argument) in an outer loop, and iterate over all batches that - `inputs_dataset` represents in an inner loop. Therefore, the - total number of (checkpoint, batch) combinations that need to be - iterated over is - (# of checkpoints x # of batches that `inputs_dataset` represents). - If `show_progress` is True, the total progress of both the outer - iteration over checkpoints and the inner iteration over batches is - displayed. It will try to use tqdm if available for advanced + `inputs_dataset` represents in an inner loop. Thus if + `show_progress` is True, the progress of both the outer + iteration and the inner iterations will be displayed. To show + progress, it will try to use tqdm if available for advanced features (e.g. time estimation). Otherwise, it will fallback to a simple output of progress. Default: False @@ -1097,6 +1098,75 @@ def get_checkpoint_contribution(checkpoint): return batches_self_tracin_scores + def self_influence( + self, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + show_progress: bool = False, + outer_loop_by_checkpoints: bool = False, + ) -> Tensor: + """ + Computes self influence scores for the examples in `inputs_dataset`, which is + either a single batch or a Pytorch `DataLoader` that yields batches. Therefore, + the computed self influence scores are *not* for the examples in training + dataset `train_dataset` (unlike when computing self influence scores using the + `influence` method). Note that if `inputs_dataset` is a single batch, this + will call `model` on that single batch, and if `inputs_dataset` yields + batches, this will call `model` on each batch that is yielded. Therefore, + please ensure that for both cases, the batch(es) that `model` is called + with are not too large, so that there will not be an out-of-memory error. + Internally, this computation requires iterating both over the batches in + `inputs_dataset`, as well as different model checkpoints. There are two ways + this iteration can be done. If `outer_loop_by_checkpoints` is False, the outer + iteration will be over batches, and the inner iteration will be over + checkpoints. This has the pro that displaying the progress of the computation + is more intuitive, involving displaying the number of batches for which self + influence scores have been computed. If `outer_loop_by_checkpoints` is True, + the outer iteration will be over checkpoints, and the inner iteration will be + over batches. This has the pro that the checkpoints do not need to be loaded + for each batch. For large models, loading checkpoints can be time-intensive. + + Args: + batches (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, + and `batch[-1]` are the labels, if any. This is the same + assumption made for each batch yielded by training dataset + `train_dataset`. Please see documentation for the + `train_dataset` argument to `TracInCP.__init__` for + more details on the assumed structure of a batch. + show_progress (bool, optional): Computation of self influence scores can + take a long time if `inputs_dataset` represents many examples. If + `show_progress`is true, the progress of this computation will be + displayed. In more detail, if `outer_loop_by_checkpoints` is False, + this computation will iterate over all batches in an outer loop. + Thus if `show_progress` is True, the number of batches for which + self influence scores have been computed will be displayed. If + `outer_loop_by_checkpoints` is True, this computation will iterate + over all checkpoints (provided as the `checkpoints` initialization + argument) in an outer loop, and iterate over all batches that + `inputs_dataset` represents in an inner loop. Thus if + `show_progress` is True, the progress of both the outer + iteration and the inner iterations will be displayed. To show + progress, it will try to use tqdm if available for advanced + features (e.g. time estimation). Otherwise, it will fallback to a + simple output of progress. + Default: False + outer_loop_by_checkpoints (bool, optional): If performing an outer + iteration over checkpoints; see method description for more + details. + Default: False + """ + if outer_loop_by_checkpoints: + return self._self_influence_by_checkpoints(inputs_dataset, show_progress) + return _self_influence_by_batches_helper( + self._self_influence_by_checkpoints, + self.get_name(), + inputs_dataset, + show_progress, + ) + def _basic_computation_tracincp( self, inputs: Tuple[Any, ...], diff --git a/captum/influence/_core/tracincp_fast_rand_proj.py b/captum/influence/_core/tracincp_fast_rand_proj.py index 71fe3b45a0..f42dbd1527 100644 --- a/captum/influence/_core/tracincp_fast_rand_proj.py +++ b/captum/influence/_core/tracincp_fast_rand_proj.py @@ -17,6 +17,7 @@ _get_k_most_influential_helper, _jacobian_loss_wrt_inputs, _load_flexible_state_dict, + _self_influence_by_batches_helper, _tensor_batch_dot, ) from captum.influence._utils.nearest_neighbors import ( @@ -263,11 +264,9 @@ def influence( # type: ignore[override] requires "training dataset computations": computations for each batch in the training dataset `train_dataset`, which may take a long time. If `show_progress`is true, the progress of - "training dataset computations" will be displayed. In particular, - the number of batches for which computations have been performed - will be displayed. It will try to use tqdm if available for - advanced features (e.g. time estimation). Otherwise, it will - fallback to a simple output of progress. + "training dataset computations" will be displayed. It will try to + use tqdm if available for advanced features (e.g. time estimation). + Otherwise, it will fallback to a simple output of progress. Default: False Returns: @@ -466,7 +465,7 @@ def _get_k_most_influential( # type: ignore[override] ( f"Using {self.get_name()} to perform computation for " f'getting {"proponents" if proponents else "opponents"}. ' - "Processing training batches: 100%" + "Processing training batches" ) ) ) @@ -483,7 +482,7 @@ def _get_k_most_influential( # type: ignore[override] ) ) - def self_influence( + def _self_influence_by_checkpoints( self, inputs_dataset: Union[Tuple[Any, ...], DataLoader], show_progress: bool = False, @@ -497,7 +496,11 @@ def self_influence( will call `model` on that single batch, and if `inputs_dataset` yields batches, this will call `model` on each batch that is yielded. Therefore, please ensure that for both cases, the batch(es) that `model` is called - with are not too large, so that there will not be an out-of-memory error. + with are not too large, so that there will not be an out-of-memory error. This + implementation performs an outer iteration over checkpoints, and an inner + iteration over all batches that `inputs_dataset` represents. The pros of this + implementation are that the checkpoints do not need to be loaded too many + times. Args: batches (Tuple, or DataLoader): Either a single tuple of any, or a @@ -516,13 +519,10 @@ def self_influence( displayed. In more detail, this computation will iterate over all checkpoints (provided as the `checkpoints` initialization argument) in an outer loop, and iterate over all batches that - `inputs_dataset` represents in an inner loop. Therefore, the - total number of (checkpoint, batch) combinations that need to be - iterated over is - (# of checkpoints x # of batches that `inputs_dataset` represents). - If `show_progress` is True, the total progress of both the outer - iteration over checkpoints and the inner iteration over batches is - displayed. It will try to use tqdm if available for advanced + `inputs_dataset` represents in an inner loop. Thus if + `show_progress` is True, the progress of both the outer + iteration and the inner iterations will be displayed. To show + progress, it will try to use tqdm if available for advanced features (e.g. time estimation). Otherwise, it will fallback to a simple output of progress. Default: False @@ -619,6 +619,75 @@ def get_checkpoint_contribution(checkpoint): return batches_self_tracin_scores + def self_influence( + self, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + show_progress: bool = False, + outer_loop_by_checkpoints: bool = False, + ) -> Tensor: + """ + Computes self influence scores for the examples in `inputs_dataset`, which is + either a single batch or a Pytorch `DataLoader` that yields batches. Therefore, + the computed self influence scores are *not* for the examples in training + dataset `train_dataset` (unlike when computing self influence scores using the + `influence` method). Note that if `inputs_dataset` is a single batch, this + will call `model` on that single batch, and if `inputs_dataset` yields + batches, this will call `model` on each batch that is yielded. Therefore, + please ensure that for both cases, the batch(es) that `model` is called + with are not too large, so that there will not be an out-of-memory error. + Internally, this computation requires iterating both over the batches in + `inputs_dataset`, as well as different model checkpoints. There are two ways + this iteration can be done. If `outer_loop_by_checkpoints` is False, the outer + iteration will be over batches, and the inner iteration will be over + checkpoints. This has the pro that displaying the progress of the computation + is more intuitive, involving displaying the number of batches for which self + influence scores have been computed. If `outer_loop_by_checkpoints` is True, + the outer iteration will be over checkpoints, and the inner iteration will be + over batches. This has the pro that the checkpoints do not need to be loaded + for each batch. For large models, loading checkpoints can be time-intensive. + + Args: + batches (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, + and `batch[-1]` are the labels, if any. This is the same + assumption made for each batch yielded by training dataset + `train_dataset`. Please see documentation for the + `train_dataset` argument to `TracInCP.__init__` for + more details on the assumed structure of a batch. + show_progress (bool, optional): Computation of self influence scores can + take a long time if `inputs_dataset` represents many examples. If + `show_progress`is true, the progress of this computation will be + displayed. In more detail, if `outer_loop_by_checkpoints` is False, + this computation will iterate over all batches in an outer loop. + Thus if `show_progress` is True, the number of batches for which + self influence scores have been computed will be displayed. If + `outer_loop_by_checkpoints` is True, this computation will iterate + over all checkpoints (provided as the `checkpoints` initialization + argument) in an outer loop, and iterate over all batches that + `inputs_dataset` represents in an inner loop. Thus if + `show_progress` is True, the progress of both the outer + iteration and the inner iterations will be displayed. To show + progress, it will try to use tqdm if available for advanced + features (e.g. time estimation). Otherwise, it will fallback to a + simple output of progress. + Default: False + outer_loop_by_checkpoints (bool, optional): If performing an outer + iteration over checkpoints; see method description for more + details. + Default: False + """ + if outer_loop_by_checkpoints: + return self._self_influence_by_checkpoints(inputs_dataset, show_progress) + return _self_influence_by_batches_helper( + self._self_influence_by_checkpoints, + self.get_name(), + inputs_dataset, + show_progress, + ) + def _basic_computation_tracincp_fast( influence_instance: TracInCPFast, @@ -946,6 +1015,7 @@ def self_influence( self, inputs_dataset: Union[Tuple[Any, ...], DataLoader], show_progress: bool = False, + outer_loop_by_checkpoints: bool = False, ) -> Tensor: """ NOT IMPLEMENTED - no need to implement `TracInCPFastRandProj.self_influence`, @@ -985,6 +1055,10 @@ def self_influence( if available for advanced features (e.g. time estimation). Otherwise, it will fallback to a simple output of progress. Default: False + outer_loop_by_checkpoints (bool, optional): If performing an outer + iteration over checkpoints; see method description for more + details. + Default: False Returns: self_influence_scores (Tensor): This is a 1D tensor containing the self diff --git a/captum/influence/_utils/common.py b/captum/influence/_utils/common.py index d6f1c99f20..131f8964b8 100644 --- a/captum/influence/_utils/common.py +++ b/captum/influence/_utils/common.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 +import warnings from typing import Any, Callable, List, Optional, Tuple, Union import torch @@ -325,3 +326,96 @@ def _format_inputs_dataset(inputs_dataset: Union[Tuple[Any, ...], DataLoader]): _DatasetFromList([inputs_dataset]), shuffle=False, batch_size=None ) return inputs_dataset + + +def _self_influence_by_batches_helper( + self_influence_batch_fn: Callable, + instance_name: str, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + show_progress: bool = False, +) -> Tensor: + """ + Computes self influence scores for the examples in `inputs_dataset`, which is + either a single batch or a Pytorch `DataLoader` that yields batches. The self + influence scores for a single batch are computed using the + `self_influence_batch_fn` input. Note that if `inputs_dataset` is a single batch, + this will call `model` on that single batch, where `model` is the model used to + compute self influence scores by `self_influence_batch_fn`, and if `inputs_dataset` + yields batches, this will call `model` on each batch that is yielded. Therefore, + please ensure that for both cases, the batch(es) that `model` is called + with are not too large, so that there will not be an out-of-memory error. This + implementation performs an outer iteration over all batches that + `inputs_dataset` represents, and an inner iteration over checkpoints. The pros + of this implementation are that showing the progress of the computation is + straightforward. + + Args: + self_influence_batch_fn (Callable): This is the function that computes self + influence scores for a single batch. + instance_name (str): This is the name of the implementation class that + `self_influence_batch_fn` is a method of. This is used for displaying + warning messages. + batches (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, + and `batch[-1]` are the labels, if any. This is the same + assumption made for each batch yielded by training dataset + `train_dataset`. Please see documentation for the + `train_dataset` argument to `TracInCP.__init__` for + more details on the assumed structure of a batch. + show_progress (bool, optional): Computation of self influence scores can + take a long time if `inputs_dataset` represents many examples. If + `show_progress`is true, the progress of this computation will be + displayed. In particular, the number of batches for which self + influence scores have been computed will be displayed. It will try + to use tqdm if available for advanced features (e.g. time + estimation). Otherwise, it will fallback to a simple output of + progress. + Default: False + + Returns: + self_influence_scores (Tensor): This is a 1D tensor containing the self + influence scores of all examples in `inputs_dataset`, regardless of + whether it represents a single batch or a `DataLoader` that yields + batches. + """ + # If `inputs_dataset` is not a `DataLoader`, turn it into one. + inputs_dataset = _format_inputs_dataset(inputs_dataset) + + # If `show_progress` is true, create a progress bar that keeps track of how + # many batches have been processed + if show_progress: + # First, try to determine length of progress bar if possible, with a + # default of `None` + inputs_dataset_len = None + try: + inputs_dataset_len = len(inputs_dataset) + except TypeError: + warnings.warn( + "Unable to determine the number of batches in `inputs_dataset`. " + "Therefore, if showing the progress of the computation of self " + "influence scores, only the number of batches processed can be " + "displayed, and not the percentage completion of the computation, " + "nor any time estimates." + ) + # then create the progress bar + inputs_dataset = progress( + inputs_dataset, + desc=f"Using {instance_name} to compute self influence. Processing batch", + total=inputs_dataset_len, + ) + + # To compute self influence scores for each batch, we use + # `_self_influence_by_checkpoints`, which can accept a tuple representing a + # single batch as the `inputs_dataset` argument (as well as a DataLoader). + # Because we are already displaying progress in terms of number of batches + # processed in this method, we will not show progress for the call to + # `_self_influence_by_checkpoints`. + return torch.cat( + [ + self_influence_batch_fn(batch, show_progress=False) + for batch in inputs_dataset + ] + ) diff --git a/tests/influence/_core/test_tracin_self_influence.py b/tests/influence/_core/test_tracin_self_influence.py index 9448982a58..0f327ce3fb 100644 --- a/tests/influence/_core/test_tracin_self_influence.py +++ b/tests/influence/_core/test_tracin_self_influence.py @@ -57,6 +57,7 @@ def test_tracin_self_influence( criterion, ) + # calculate influence scores, using the training data as the test batch train_scores = tracin.influence( train_dataset.samples, train_dataset.labels, @@ -65,8 +66,12 @@ def test_tracin_self_influence( ) # calculate self_tracin_scores - self_tracin_scores = tracin.influence() + self_tracin_scores = tracin.self_influence( + DataLoader(train_dataset, batch_size=batch_size), + outer_loop_by_checkpoints=False, + ) + # check that self_tracin scores equals the diagonal of influence scores assertTensorAlmostEqual( self, torch.diagonal(train_scores), @@ -75,6 +80,20 @@ def test_tracin_self_influence( mode="max", ) + # check that setting `outer_loop_by_checkpoints=False` and + # `outer_loop_by_checkpoints=True` gives the same self influence scores + self_tracin_scores_by_checkpoints = tracin.self_influence( + DataLoader(train_dataset, batch_size=batch_size), + outer_loop_by_checkpoints=True, + ) + assertTensorAlmostEqual( + self, + self_tracin_scores_by_checkpoints, + self_tracin_scores, + delta=0.01, + mode="max", + ) + @parameterized.expand( [ (reduction, constructor, unpack_inputs) diff --git a/tests/influence/_core/test_tracin_show_progress.py b/tests/influence/_core/test_tracin_show_progress.py index 17b9065458..e940e2ed66 100644 --- a/tests/influence/_core/test_tracin_show_progress.py +++ b/tests/influence/_core/test_tracin_show_progress.py @@ -14,6 +14,7 @@ DataInfluenceConstructor, get_random_model_and_data, ) +from torch.utils.data import DataLoader class TestTracInShowProgress(BaseTest): @@ -28,6 +29,18 @@ class TestTracInShowProgress(BaseTest): in `TracInCPFastRandProj.__init__`). """ + def _check_error_msg_multiplicity(self, mock_stderr, msg, msg_multiplicity): + """ + checks that in `mock_stderr`, the error msg `msg` occurs `msg_multiplicity` + times + """ + output = mock_stderr.getvalue() + self.assertEqual( + output.count(msg), + msg_multiplicity, + f"Error in progress of batches with output: {repr(output)}", + ) + @parameterized.expand( [ ( @@ -45,7 +58,12 @@ class TestTracInShowProgress(BaseTest): DataInfluenceConstructor(TracInCPFast), ), ] - for mode in ["self influence", "influence", "k-most"] + for mode in [ + "self influence by checkpoints", + "self influence by batches", + "influence", + "k-most", + ] ], name_func=build_test_name_func(args_to_skip=["reduction"]), ) @@ -83,9 +101,13 @@ def test_tracin_show_progress( criterion, ) - if mode == "self influence": + if mode == "self influence by checkpoints": + # this tests progress for computing self influence scores, when + # `outer_loop_by_checkpoints` is True. In this case, we should see a + # single outer progress bar over checkpoints, and for every + # checkpoints, a separate progress bar over batches - # For self influence, displaying progress involves nested progress + # In this case, displaying progress involves nested progress # bars, which are not currently supported by the backup # `SimpleProgress` that is used if `tqdm` is not installed. # Therefore, we skip the test in this case. @@ -101,33 +123,50 @@ def test_tracin_show_progress( ) ) - tracin.influence(show_progress=True) - output = mock_stderr.getvalue() + tracin.self_influence( + DataLoader(train_dataset, batch_size=batch_size), + show_progress=True, + outer_loop_by_checkpoints=True, + ) + # We are showing nested progress bars for the `self_influence` # method, with the outer progress bar over checkpoints, and # the inner progress bar over batches. First, we check that # the outer progress bar reaches 100% once - self.assertEqual( - output.count( - ( - f"Using {tracin.get_name()} to compute self influence. " - "Processing checkpoint: 100%" - ) + self._check_error_msg_multiplicity( + mock_stderr, + ( + f"Using {tracin.get_name()} to compute self influence. " + "Processing checkpoint: 100%" ), 1, - f"Error in progress of batches with output: {repr(output)}", ) # Second, we check that the inner progress bar reaches 100% # once for each checkpoint in `tracin.checkpoints` - self.assertEqual( - output.count( - ( - f"Using {tracin.get_name()} to compute self influence. " - "Processing batch: 100%" - ) + self._check_error_msg_multiplicity( + mock_stderr, + ( + f"Using {tracin.get_name()} to compute self influence. " + "Processing batch: 100%" ), len(tracin.checkpoints), - f"Error in progress of checkpoints with output: {repr(output)}", + ) + elif mode == "self influence by batches": + # This tests progress for computing self influence scores, when + # `outer_loop_by_checkpoints` is False. In this case, we should see + # a single outer progress bar over batches. + tracin.self_influence( + DataLoader(train_dataset, batch_size=batch_size), + show_progress=True, + outer_loop_by_checkpoints=False, + ) + self._check_error_msg_multiplicity( + mock_stderr, + ( + f"Using {tracin.get_name()} to compute self influence. " + "Processing batch: 100%" + ), + 1, ) elif mode == "influence": @@ -137,16 +176,15 @@ def test_tracin_show_progress( k=None, show_progress=True, ) - output = mock_stderr.getvalue() - self.assertTrue( + # Since the computation iterates once over training batches, we + # check that the progress bar over batches reaches 100% once + self._check_error_msg_multiplicity( + mock_stderr, ( - ( - f"Using {tracin.get_name()} to compute influence " - "for training batches: 100%" - ) - in output + f"Using {tracin.get_name()} to compute influence " + "for training batches: 100%" ), - f"Error progress output: {repr(output)}", + 1, ) elif mode == "k-most": @@ -157,16 +195,17 @@ def test_tracin_show_progress( proponents=True, show_progress=True, ) - output = mock_stderr.getvalue() - self.assertTrue( + + # Since the computation iterates once over training batches, we + # check that the progress bar over batches reaches 100% once, and + # that the message is specific for finding proponents. + self._check_error_msg_multiplicity( + mock_stderr, ( - ( - f"Using {tracin.get_name()} to perform computation for " - "getting proponents. Processing training batches: 100%" - ) - in output + f"Using {tracin.get_name()} to perform computation for " + "getting proponents. Processing training batches: 100%" ), - f"Error progress output: {repr(output)}", + 1, ) mock_stderr.seek(0) mock_stderr.truncate(0) @@ -178,16 +217,17 @@ def test_tracin_show_progress( proponents=False, show_progress=True, ) - output = mock_stderr.getvalue() - self.assertTrue( + + # Since the computation iterates once over training batches, we + # check that the progress bar over batches reaches 100% once, and + # that the message is specific for finding opponents. + self._check_error_msg_multiplicity( + mock_stderr, ( - ( - f"Using {tracin.get_name()} to perform computation for " - "getting opponents. Processing training batches: 100%" - ) - in output + f"Using {tracin.get_name()} to perform computation for " + "getting opponents. Processing training batches: 100%" ), - f"Error progress output: {repr(output)}", + 1, ) else: raise Exception("unknown test mode") From fb6db3bf2380b6a97ba6b7f8dc548578c5b30c6e Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 1 Aug 2022 13:45:24 -0600 Subject: [PATCH 112/174] Fix branch --- .../models/_image/clip_resnet50x4_image.py | 96 +++++++++++-------- .../models/_image/clip_resnet50x4_text.py | 49 ++++++---- .../models/test_clip_resnet50x4_image.py | 39 +++++++- 3 files changed, 120 insertions(+), 64 deletions(-) diff --git a/captum/optim/models/_image/clip_resnet50x4_image.py b/captum/optim/models/_image/clip_resnet50x4_image.py index 4fc86a8880..14c3cc4ed0 100644 --- a/captum/optim/models/_image/clip_resnet50x4_image.py +++ b/captum/optim/models/_image/clip_resnet50x4_image.py @@ -23,8 +23,12 @@ def clip_resnet50x4_image( This model can be combined with the CLIP ResNet 50x4 Text model to create the full CLIP ResNet 50x4 model. - Note that model inputs are expected to have a shape of: [B, 3, 288, 288] or - [3, 288, 288]. + Note that the model was trained on inputs with a shape of: [B, 3, 288, 288]. + + Example:: + + >>> model = opt.models.clip_resnet50x4_image(pretrained=True) + >>> output = model(torch.zeros(1, 3, 288, 288)) See here for more details: https://github.com/openai/CLIP @@ -32,25 +36,30 @@ def clip_resnet50x4_image( Args: - pretrained (bool, optional): If True, returns a pre-trained model. - Default: False - progress (bool, optional): If True, displays a progress bar of the download to - stderr - Default: True + pretrained (bool, optional): If ``True``, returns a pre-trained model. + Default: ``False`` + progress (bool, optional): If ``True``, displays a progress bar of the download + to stderr. + Default: ``True`` model_path (str, optional): Optional path for the model file. - Default: None - replace_relus_with_redirectedrelu (bool, optional): If True, return pretrained - model with Redirected ReLU in place of ReLU layers. - Default: *True* when pretrained is True otherwise *False* - use_linear_modules_only (bool, optional): If True, return model + Default: ``None`` + replace_relus_with_redirectedrelu (bool, optional): If ``True``, return + pretrained model with Redirected ReLU in place of ReLU layers. + Default: *``True``* when ``pretrained`` is ``True`` otherwise *``False``* + use_linear_modules_only (bool, optional): If ``True``, return model with all nonlinear layers replaced with linear equivalents. - Default: False - transform_input (bool, optional): If True, preprocesses the input according to - the method with which it was trained. - Default: *True* when pretrained is True otherwise *False* + Default: ``False`` + transform_input (bool, optional): If ``True``, preprocesses the input according + to the method with which it was trained. + Default: *``True``* when ``pretrained`` is ``True`` otherwise *``False``* + use_attnpool (bool, optional): Whether or not to use the final + ``AttentionPool2d`` layer in the forward function. If set to ``True``, + model inputs are required to have a shape of: [B, 3, 288, 288] or + [3, 288, 288]. + Default: ``False`` Returns: - **CLIP_ResNet50x4Image** (CLIP_ResNet50x4Image): A CLIP ResNet 50x4 model's + model (CLIP_ResNet50x4Image): An instance of a CLIP ResNet 50x4 model's image portion. """ if pretrained: @@ -60,6 +69,8 @@ def clip_resnet50x4_image( kwargs["replace_relus_with_redirectedrelu"] = True if "use_linear_modules_only" not in kwargs: kwargs["use_linear_modules_only"] = False + if "use_attnpool" not in kwargs: + kwargs["use_attnpool"] = False model = CLIP_ResNet50x4Image(**kwargs) @@ -81,26 +92,32 @@ class CLIP_ResNet50x4Image(nn.Module): Visual Models From Natural Language Supervision': https://arxiv.org/abs/2103.00020 """ - __constants__ = ["transform_input"] + __constants__ = ["transform_input", "use_attnpool"] def __init__( self, transform_input: bool = False, replace_relus_with_redirectedrelu: bool = False, use_linear_modules_only: bool = False, + use_attnpool: bool = True, ) -> None: """ Args: - replace_relus_with_redirectedrelu (bool, optional): If True, return + replace_relus_with_redirectedrelu (bool, optional): If ``True``, return model with Redirected ReLU in place of ReLU layers. Default: False - use_linear_modules_only (bool, optional): If True, return model with + use_linear_modules_only (bool, optional): If ``True``, return model with all nonlinear layers replaced with linear equivalents. - Default: False - transform_input (bool, optional): If True, preprocesses the input according - to the method with which it was trained on. - Default: False + Default: ``False`` + transform_input (bool, optional): If ``True``, preprocesses the input + according to the method with which it was trained on. + Default: ``False`` + use_attnpool (bool, optional): Whether or not to use the final + ``AttentionPool2d`` layer in the forward function. If set to ``True``, + model inputs are required to have a shape of: [B, 3, 288, 288] or + [3, 288, 288]. + Default: ``True`` """ super().__init__() if use_linear_modules_only: @@ -112,6 +129,7 @@ def __init__( activ = nn.ReLU self.transform_input = transform_input + self.use_attnpool = use_attnpool # Stem layers self.conv1 = nn.Conv2d(3, 40, kernel_size=3, stride=2, padding=1, bias=False) @@ -149,21 +167,21 @@ def _build_layer( inplanes (int, optional): The number of input channels / features to use for the first layer. - Default: 80 + Default: ``80`` planes (int, optional): The number of output channels / features to use for the first layer. This variable is then multiplied by 4 to get the number of input channels / features to use for the subsequent layers. - Default: 80 + Default: ``80`` blocks (int, optional): The number of Bottleneck layers to create. - Default: 4 + Default: ``4`` stride (int, optional): The stride value to use for the Bottleneck layers. - Default: 1 + Default: ``1`` activ (type of nn.Module, optional): The nn.Module class type to use for activation layers. - Default: nn.ReLU + Default: ``nn.ReLU`` Returns: - residual_layer (nn.Sequential): A full residual layer. + residual_layer (nn.Sequential): A full residual layer instance. """ layers = [Bottleneck(inplanes, planes, stride, activ=activ)] for _ in range(blocks - 1): @@ -216,7 +234,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.layer4(x) # Attention Pooling - x = self.attnpool(x) + if self.use_attnpool: + x = self.attnpool(x) return x @@ -233,15 +252,15 @@ def __init__( inplanes (int, optional): The number of input channels / features to use for the first layer. - Default: 80 + Default: ``80`` planes (int, optional): The number of output channels / features to use for the subsequent layers. - Default: 80 + Default: ``80`` stride (int, optional): The stride value to use for the Bottleneck layers. - Default: 1 + Default: ``1`` activ (type of nn.Module, optional): The nn.Module class type to use for activation layers. - Default: nn.ReLU + Default: ``nn.ReLU`` """ super().__init__() self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) @@ -304,14 +323,15 @@ def __init__( spacial_size (int, optional): The desired size to user for the positional embedding. - Default: 9 + Default: ``9`` in_features (int, optional): The desired input size for the nn.Linear layers. - Default: 2560 + Default: ``2560`` out_features (int, optional): The desired output size for the nn.Linear layers. + Default: ``640`` num_heads (int, optional): The number of heads to use. - Default: 40 + Default: ``40`` """ super().__init__() self.positional_embedding = nn.Parameter( diff --git a/captum/optim/models/_image/clip_resnet50x4_text.py b/captum/optim/models/_image/clip_resnet50x4_text.py index 66cb58ce69..8fdbcc5179 100644 --- a/captum/optim/models/_image/clip_resnet50x4_text.py +++ b/captum/optim/models/_image/clip_resnet50x4_text.py @@ -23,33 +23,40 @@ def clip_resnet50x4_text( This model can be combined with the CLIP ResNet 50x4 Image model to create the full CLIP ResNet 50x4 model. + Example:: + + >>> model = opt.models.clip_resnet50x4_text(pretrained=True) + >>> clip_tokenizer = opt.transforms.CLIPTokenizer(pretrained_merges=True) + >>> tokenized_input = clip_tokenizer("Some example text.") + >>> output = model(tokenized_input) + See here for more details: https://github.com/openai/CLIP https://github.com/mlfoundations/open_clip Args: - pretrained (bool, optional): If True, returns a pre-trained model. - Default: False - progress (bool, optional): If True, displays a progress bar of the download to - stderr - Default: True + pretrained (bool, optional): If ``True``, returns a pre-trained model. + Default: ``False`` + progress (bool, optional): If ``True``, displays a progress bar of the download + to stderr. + Default: ``True`` model_path (str, optional): Optional path for the model file. - Default: None + Default: ``None`` width (int, optional): The desired width size to use for the model. - Default: 640 + Default: ``640`` num_heads (int, optional): The number of heads to use for the model. - Default: 10 + Default: ``10`` num_residual_layers (int, optional): The number of residual layers to use for each residual attention block in the model. - Default: 12 + Default: ``12`` content_length (int, optional): The expected size of text inputs to the model. - Default: 77 + Default: ``77`` vocab_size (int, optional): The size of the vocab used to train the model. - Default: 49408 + Default: ``49408`` Returns: - **CLIP_ResNet50x4Text** (CLIP_ResNet50x4Text): A CLIP ResNet 50x4 model's text + model (CLIP_ResNet50x4Text): An instance of a CLIP ResNet 50x4 model's text portion. """ if pretrained: @@ -85,17 +92,17 @@ def __init__( Args: width (int, optional): The desired width size to use for the model. - Default: 640 + Default: ``640`` num_heads (int, optional): The num number of heads to use for the model. - Default: 10 + Default: ``10`` num_residual_layers (int, optional): The number of residual layers to use for each residual attention block. - Default: 12 + Default: ``12`` content_length (int, optional): The expected size of text inputs to the model. - Default: 77 + Default: ``77`` vocab_size (int, optional): The size of the vocab used to train the model. - Default: 49408 + Default: ``49408`` """ super().__init__() self.transformer = nn.Sequential( @@ -154,11 +161,11 @@ def __init__( Args: width (int, optional): The desired width size to use. - Default: 640 + Default: ``640`` num_heads (int, optional): The num number of heads to use. - Default: 10 - content_length (int, optional): The desired content_length to use. - Default: 77 + Default: ``10`` + content_length (int, optional): The desired ``content_length`` to use. + Default: ``77`` """ super().__init__() self.attn = nn.MultiheadAttention(width, num_heads) diff --git a/tests/optim/models/test_clip_resnet50x4_image.py b/tests/optim/models/test_clip_resnet50x4_image.py index beb3d33595..ab5f22e52c 100644 --- a/tests/optim/models/test_clip_resnet50x4_image.py +++ b/tests/optim/models/test_clip_resnet50x4_image.py @@ -81,9 +81,10 @@ def test_clip_resnet50x4_image_load_and_forward(self) -> None: + " insufficient Torch version." ) x = torch.zeros(1, 3, 288, 288) - model = clip_resnet50x4_image(pretrained=True) + model = clip_resnet50x4_image(pretrained=True, use_attnpool=True) output = model(x) self.assertEqual(list(output.shape), [1, 640]) + self.assertTrue(model.use_attnpool) def test_untrained_clip_resnet50x4_image_load_and_forward(self) -> None: if version.parse(torch.__version__) <= version.parse("1.6.0"): @@ -92,9 +93,10 @@ def test_untrained_clip_resnet50x4_image_load_and_forward(self) -> None: + " insufficient Torch version." ) x = torch.zeros(1, 3, 288, 288) - model = clip_resnet50x4_image(pretrained=False) + model = clip_resnet50x4_image(pretrained=False, use_attnpool=True) output = model(x) self.assertEqual(list(output.shape), [1, 640]) + self.assertTrue(model.use_attnpool) def test_clip_resnet50x4_image_warning(self) -> None: if version.parse(torch.__version__) <= version.parse("1.6.0"): @@ -109,6 +111,30 @@ def test_clip_resnet50x4_image_warning(self) -> None: with self.assertWarns(UserWarning): _ = model._transform_input(x) + def test_clip_resnet50x4_image_use_attnpool_false(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping basic pretrained CLIP ResNet 50x4 Image use_attnpool" + + " forward due to insufficient Torch version." + ) + x = torch.zeros(1, 3, 288, 288) + model = clip_resnet50x4_image(pretrained=True, use_attnpool=False) + output = model(x) + self.assertEqual(list(output.shape), [1, 2560, 9, 9]) + self.assertFalse(model.use_attnpool) + + def test_clip_resnet50x4_image_use_attnpool_false_size_128(self) -> None: + if version.parse(torch.__version__) <= version.parse("1.6.0"): + raise unittest.SkipTest( + "Skipping basic pretrained CLIP ResNet 50x4 Image use_attnpool" + + " forward with 128x128 input due to insufficient Torch version." + ) + x = torch.zeros(1, 3, 128, 128) + model = clip_resnet50x4_image(pretrained=True, use_attnpool=False) + output = model(x) + self.assertEqual(list(output.shape), [1, 2560, 4, 4]) + self.assertFalse(model.use_attnpool) + def test_clip_resnet50x4_image_forward_cuda(self) -> None: if version.parse(torch.__version__) <= version.parse("1.6.0"): raise unittest.SkipTest( @@ -121,11 +147,12 @@ def test_clip_resnet50x4_image_forward_cuda(self) -> None: + " not supporting CUDA." ) x = torch.zeros(1, 3, 288, 288).cuda() - model = clip_resnet50x4_image(pretrained=True).cuda() + model = clip_resnet50x4_image(pretrained=True, use_attnpool=True).cuda() output = model(x) self.assertTrue(output.is_cuda) self.assertEqual(list(output.shape), [1, 640]) + self.assertTrue(model.use_attnpool) def test_clip_resnet50x4_image_jit_module_no_redirected_relu(self) -> None: if version.parse(torch.__version__) <= version.parse("1.8.0"): @@ -135,11 +162,12 @@ def test_clip_resnet50x4_image_jit_module_no_redirected_relu(self) -> None: ) x = torch.zeros(1, 3, 288, 288) model = clip_resnet50x4_image( - pretrained=True, replace_relus_with_redirectedrelu=False + pretrained=True, replace_relus_with_redirectedrelu=False, use_attnpool=True ) jit_model = torch.jit.script(model) output = jit_model(x) self.assertEqual(list(output.shape), [1, 640]) + self.assertTrue(model.use_attnpool) def test_clip_resnet50x4_image_jit_module_with_redirected_relu(self) -> None: if version.parse(torch.__version__) <= version.parse("1.8.0"): @@ -149,8 +177,9 @@ def test_clip_resnet50x4_image_jit_module_with_redirected_relu(self) -> None: ) x = torch.zeros(1, 3, 288, 288) model = clip_resnet50x4_image( - pretrained=True, replace_relus_with_redirectedrelu=True + pretrained=True, replace_relus_with_redirectedrelu=True, use_attnpool=True ) jit_model = torch.jit.script(model) output = jit_model(x) self.assertEqual(list(output.shape), [1, 640]) + self.assertTrue(model.use_attnpool) From a0ee122e35ac5733b8ef0a2417a589253fe43eac Mon Sep 17 00:00:00 2001 From: Meghpal <40922889+Meghpal@users.noreply.github.com> Date: Wed, 10 Aug 2022 13:09:23 -0700 Subject: [PATCH 113/174] Notebook support for tqdm (#1001) Summary: The `tqdm` progress in notebooks breaks in some cases (for me this behavior was persistent after I stopped the cell running this even once), possibly because it is not imported from the **recommmended** `tqdm.auto` ```python from tqdm import tqdm ``` ![image](https://user-images.githubusercontent.com/40922889/181494132-739f7097-1f86-4a3b-9089-d5cf650a84b3.png) However, when imported from `tqdm.auto` it works flawlessly: ```python from tqdm.auto import tqdm ``` ![image](https://user-images.githubusercontent.com/40922889/181494202-349666fd-cc89-42c7-b59c-6e9ad9967f03.png) Pull Request resolved: https://github.com/pytorch/captum/pull/1001 Reviewed By: 99warriors Differential Revision: D38282900 Pulled By: aobo-y fbshipit-source-id: bc4bd9b4e4d5b7ae2538186e0d9bfbaf730ef116 --- captum/_utils/progress.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/_utils/progress.py b/captum/_utils/progress.py index 2ece45ad99..435a08a19f 100644 --- a/captum/_utils/progress.py +++ b/captum/_utils/progress.py @@ -6,7 +6,7 @@ from typing import cast, Iterable, Sized, TextIO try: - from tqdm import tqdm + from tqdm.auto import tqdm except ImportError: tqdm = None From 03cea17d9ce73bf0abd623dc6f92204c84e3340b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 11 Aug 2022 09:32:14 -0600 Subject: [PATCH 114/174] callable -> Callable --- captum/optim/_core/loss.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 6ec08391b1..ffd7c8e43d 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -319,7 +319,7 @@ def __init__( """ Args: - loss_fn (callable): A function that takes a dict of captured activations + loss_fn (Callable): A function that takes a dict of captured activations with nn.Modules as keys, and then passes those activations through loss objective(s) & math operations. name (str, optional): The name of all composable operations in the @@ -1142,7 +1142,7 @@ def sum_loss_list( Args: loss_list (list): A list of loss objectives. - to_scalar_fn (callable): A function for converting loss objective outputs to + to_scalar_fn (Callable): A function for converting loss objective outputs to scalar values, in order to prevent size mismatches. Set to :class:`torch.nn.Identity` for no reduction op. Default: :func:`torch.mean` From a93a5cd5b0bde67107b3c3c02f64b704c727809d Mon Sep 17 00:00:00 2001 From: Narine Kokhlikyan Date: Thu, 11 Aug 2022 20:03:38 -0700 Subject: [PATCH 115/174] Add gpu support to tracincp rand projection (#969) Summary: Adds gpu support to tracincp rand projection. Cleaned up un-passed args to _load_flexible_state_dict Pull Request resolved: https://github.com/pytorch/captum/pull/969 Reviewed By: 99warriors Differential Revision: D38401980 Pulled By: NarineK fbshipit-source-id: 69c9aba4191bc929f150e24ac4e04d7a720d5d6f --- .../_core/tracincp_fast_rand_proj.py | 62 +++++++++---- captum/influence/_utils/common.py | 26 +++--- ...l.py => test_tracin_k_most_influential.py} | 93 ++++++++++++------- .../influence/_core/test_tracin_regression.py | 49 +++++++--- .../_core/test_tracin_self_influence.py | 46 ++++++--- tests/influence/_core/test_tracin_xor.py | 90 ++++++++++++------ tests/influence/_utils/common.py | 67 ++++++++++--- 7 files changed, 298 insertions(+), 135 deletions(-) rename tests/influence/_core/{test_tracin_get_k_most_influential.py => test_tracin_k_most_influential.py} (50%) diff --git a/captum/influence/_core/tracincp_fast_rand_proj.py b/captum/influence/_core/tracincp_fast_rand_proj.py index f42dbd1527..7206812042 100644 --- a/captum/influence/_core/tracincp_fast_rand_proj.py +++ b/captum/influence/_core/tracincp_fast_rand_proj.py @@ -1,11 +1,15 @@ #!/usr/bin/env python3 +import threading import warnings -from typing import Any, Callable, Iterator, List, Optional, Tuple, Union +from collections import defaultdict +from typing import Any, Callable, cast, Dict, Iterator, List, Optional, Tuple, Union import torch -from captum._utils.common import _format_inputs, _get_module_from_name +from captum._utils.common import _format_inputs, _get_module_from_name, _sort_key_list +from captum._utils.gradient import _gather_distributed_tensors from captum._utils.progress import progress + from captum.influence._core.tracincp import ( _influence_route_to_helpers, KMostInfluentialResults, @@ -25,19 +29,10 @@ NearestNeighbors, ) from captum.log import log_usage -from torch import Tensor +from torch import device, Tensor from torch.nn import Module from torch.utils.data import DataLoader, Dataset -layer_inputs = [] - - -def _capture_inputs(layer: Module, input: Tensor, output: Tensor) -> None: - r"""Save activations into layer.activations in forward pass""" - - layer_inputs.append(input[0].detach()) - - r""" Implements abstract DataInfluence class and also provides implementation details for influence computation based on the logic provided in TracIn paper @@ -713,10 +708,26 @@ def _basic_computation_tracincp_fast( targets (tensor): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. """ - global layer_inputs - layer_inputs = [] + layer_inputs: Dict[device, Tuple[Tensor, ...]] = defaultdict() + lock = threading.Lock() + + def hook_wrapper(original_module): + def _capture_inputs(layer, input, output) -> None: + r"""Save activations into layer_inputs in forward pass""" + with lock: + is_eval_tuple = isinstance(input, tuple) + if is_eval_tuple: + layer_inputs_val = tuple(inp.detach() for inp in input) + else: + layer_inputs_val = input.detach() + layer_inputs[layer_inputs_val[0].device] = layer_inputs_val + + return _capture_inputs + assert isinstance(influence_instance.final_fc_layer, Module) - handle = influence_instance.final_fc_layer.register_forward_hook(_capture_inputs) + handle = influence_instance.final_fc_layer.register_forward_hook( + hook_wrapper(influence_instance.final_fc_layer) + ) out = influence_instance.model(*inputs) assert influence_instance.loss_fn is not None, "loss function is required" @@ -732,7 +743,16 @@ def _basic_computation_tracincp_fast( influence_instance.reduction_type, ) handle.remove() - _layer_inputs = layer_inputs[0] + + device_ids = cast( + Union[None, List[int]], + influence_instance.model.device_ids + if hasattr(influence_instance.model, "device_ids") + else None, + ) + key_list = _sort_key_list(list(layer_inputs.keys()), device_ids) + + _layer_inputs = _gather_distributed_tensors(layer_inputs, key_list=key_list)[0] assert len(input_jacobians.shape) == 2 @@ -1242,6 +1262,7 @@ def _set_projections_tracincp_fast_rand_proj( layer_input_dim = batch_layer_inputs.shape[ 1 ] # this is the dimension of the input of the last fully-connected layer + device = batch_jacobians.device # choose projection if needed # without projection, the dimension of the intermediate quantities returned @@ -1270,7 +1291,9 @@ def _set_projections_tracincp_fast_rand_proj( 1.0 / layer_input_projection_dim**0.5, ) - projection_quantities = jacobian_projection, layer_input_projection + projection_quantities = jacobian_projection.to( + device + ), layer_input_projection.to(device) return projection_quantities @@ -1341,9 +1364,8 @@ def _get_intermediate_quantities_tracincp_fast_rand_proj( # each element in this list will be of shape (batch_size, projection_dim) checkpoint_projections: List[Any] = [[] for _ in self.checkpoints] - if projection_quantities is None: - project = False - else: + project = False + if projection_quantities is not None: project = True jacobian_projection, layer_input_projection = projection_quantities diff --git a/captum/influence/_utils/common.py b/captum/influence/_utils/common.py index 131f8964b8..4954944527 100644 --- a/captum/influence/_utils/common.py +++ b/captum/influence/_utils/common.py @@ -6,6 +6,7 @@ import torch import torch.nn as nn from captum._utils.progress import progress + from torch import Tensor from torch.nn import Module from torch.utils.data import DataLoader, Dataset @@ -55,7 +56,6 @@ def _gradient_dot_product( total = _tensor_batch_dot(*next(iterator)) for input_grad, src_grad in iterator: total += _tensor_batch_dot(input_grad, src_grad) - total = torch.Tensor(total) return total @@ -141,9 +141,7 @@ def _jacobian_loss_wrt_inputs( return input_jacobians -def _load_flexible_state_dict( - model: Module, path: str, device_ids: str = "cpu", keyname: Optional[str] = None -) -> int: +def _load_flexible_state_dict(model: Module, path: str) -> float: r""" Helper to load pytorch models. This function attempts to find compatibility for loading models that were trained on different devices / with DataParallel but are @@ -156,21 +154,15 @@ def _load_flexible_state_dict( Args: model: The model for which to load a checkpoint path: The filepath to the checkpoint - keyname: The key under which the model state_dict is stored, if any. The module state_dict is modified in-place, and the learning rate is returned. """ - device = device_ids - - checkpoint = torch.load(path, map_location=device) + checkpoint = torch.load(path) - learning_rate = checkpoint.get("learning_rate", 1) + learning_rate = checkpoint.get("learning_rate", 1.0) # can get learning rate from optimizer state_dict? - if keyname is not None: - checkpoint = checkpoint[keyname] - if "module." in next(iter(checkpoint)): if isinstance(model, nn.DataParallel): model.load_state_dict(checkpoint) @@ -288,9 +280,15 @@ def _get_k_most_influential_helper( num_instances_processed += batch_size # combine the top-k for the batch with those for previously seen batches - topk_indices = torch.cat([topk_indices, batch_topk_indices], dim=1) + topk_indices = torch.cat( + [topk_indices.to(batch_topk_indices.device), batch_topk_indices], dim=1 + ) topk_tracin_scores = torch.cat( - [topk_tracin_scores, batch_topk_tracin_scores], dim=1 + [ + topk_tracin_scores.to(batch_topk_tracin_scores.device), + batch_topk_tracin_scores, + ], + dim=1, ) # retain only the top-k in terms of tracin_scores diff --git a/tests/influence/_core/test_tracin_get_k_most_influential.py b/tests/influence/_core/test_tracin_k_most_influential.py similarity index 50% rename from tests/influence/_core/test_tracin_get_k_most_influential.py rename to tests/influence/_core/test_tracin_k_most_influential.py index 017562d3d6..5512387e06 100644 --- a/tests/influence/_core/test_tracin_get_k_most_influential.py +++ b/tests/influence/_core/test_tracin_k_most_influential.py @@ -18,42 +18,55 @@ class TestTracInGetKMostInfluential(BaseTest): - """ - This test constructs a random BasicLinearNet, and checks that the proponents - obtained by calling `influence` and sorting are equal to the proponents - obtained by calling `_get_k_most_influential`. Those calls are made through - the calls to wrapper method `influence`. - """ + + use_gpu_list = ( + [True, False] + if torch.cuda.is_available() and torch.cuda.device_count() != 0 + else [False] + ) + + param_list = [] + for (batch_size, k) in [(4, 7), (7, 4), (40, 5), (5, 40), (40, 45)]: + for unpack_inputs in [True, False]: + for proponents in [True, False]: + for use_gpu in use_gpu_list: + for reduction, constr in [ + ("none", DataInfluenceConstructor(TracInCP)), + ( + "sum", + DataInfluenceConstructor( + TracInCP, + name="TracInCPFastRandProjTests", + sample_wise_grads_per_batch=True, + ), + ), + ("sum", DataInfluenceConstructor(TracInCPFast)), + ("sum", DataInfluenceConstructor(TracInCPFastRandProj)), + ("mean", DataInfluenceConstructor(TracInCPFast)), + ("mean", DataInfluenceConstructor(TracInCPFastRandProj)), + ]: + if not ( + "sample_wise_grads_per_batch" in constr.kwargs + and constr.kwargs["sample_wise_grads_per_batch"] + and use_gpu + ): + param_list.append( + ( + reduction, + constr, + unpack_inputs, + proponents, + batch_size, + k, + use_gpu, + ) + ) @parameterized.expand( - [ - (reduction, constr, unpack_inputs, proponents, batch_size, k) - # calls test helper method `test_tracin_get_k_most_influential` for several - # combinations of `batch_size` and `k`. This is important because the - # behavior of `_get_k_most_influential` depends on whether `k` is larger - # than `batch_size`. - for (batch_size, k) in [(4, 7), (7, 4), (40, 5), (5, 40), (40, 45)] - for unpack_inputs in [True, False] - for proponents in [True, False] - for reduction, constr in [ - ("none", DataInfluenceConstructor(TracInCP)), - ( - "sum", - DataInfluenceConstructor( - TracInCP, - name="TracInCPFastRandProjTests", - sample_wise_grads_per_batch=True, - ), - ), - ("sum", DataInfluenceConstructor(TracInCPFast)), - ("sum", DataInfluenceConstructor(TracInCPFastRandProj)), - ("mean", DataInfluenceConstructor(TracInCPFast)), - ("mean", DataInfluenceConstructor(TracInCPFastRandProj)), - ] - ], + param_list, name_func=build_test_name_func(), ) - def test_tracin_get_k_most_influential( + def test_tracin_k_most_influential( self, reduction: str, tracin_constructor: Callable, @@ -61,16 +74,26 @@ def test_tracin_get_k_most_influential( proponents: bool, batch_size: int, k: int, + use_gpu: bool, ) -> None: - + """ + This test constructs a random BasicLinearNet, and checks that the proponents + obtained by calling `influence` and sorting are equal to the proponents + obtained by calling `_k_most_influential`. Those calls are made through + the calls to wrapper method `influence`. + """ with tempfile.TemporaryDirectory() as tmpdir: - ( net, train_dataset, test_samples, test_labels, - ) = get_random_model_and_data(tmpdir, unpack_inputs, return_test_data=True) + ) = get_random_model_and_data( + tmpdir, + unpack_inputs, + True, + use_gpu, + ) self.assertTrue(isinstance(reduction, str)) self.assertTrue(callable(tracin_constructor)) diff --git a/tests/influence/_core/test_tracin_regression.py b/tests/influence/_core/test_tracin_regression.py index 7a615d2c9f..262c76d137 100644 --- a/tests/influence/_core/test_tracin_regression.py +++ b/tests/influence/_core/test_tracin_regression.py @@ -12,20 +12,23 @@ from parameterized import parameterized from tests.helpers.basic import assertTensorAlmostEqual, BaseTest from tests.influence._utils.common import ( + _isSorted, + _wrap_model_in_dataparallel, build_test_name_func, CoefficientNet, DataInfluenceConstructor, IdentityDataset, - isSorted, RangeDataset, ) class TestTracInRegression(BaseTest): - def _test_tracin_regression_setup(self, tmpdir: str, features: int): + def _test_tracin_regression_setup( + self, tmpdir: str, features: int, use_gpu: bool = False + ): low = 1 high = 17 - dataset = RangeDataset(low, high, features) + dataset = RangeDataset(low, high, features, use_gpu) net = CoefficientNet(in_features=features) checkpoint_name = "-".join(["checkpoint-reg", "0" + ".pt"]) @@ -35,15 +38,22 @@ def _test_tracin_regression_setup(self, tmpdir: str, features: int): for i, weight in enumerate(weights): net.fc1.weight.data.fill_(weight) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net checkpoint_name = "-".join(["checkpoint-reg", str(i + 1) + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) - return dataset, net + return dataset, net_adjusted - @parameterized.expand( - [ - (reduction, constructor, mode, dim) - for dim in [1, 20] + use_gpu_list = ( + [True, False] + if torch.cuda.is_available() and torch.cuda.device_count() != 0 + else [False] + ) + + param_list = [] + + for use_gpu in use_gpu_list: + for dim in [1, 20]: for (mode, reduction, constructor) in [ ("check_idx", "none", DataInfluenceConstructor(TracInCP)), ("sample_wise_trick", None, DataInfluenceConstructor(TracInCP)), @@ -60,8 +70,12 @@ def _test_tracin_regression_setup(self, tmpdir: str, features: int): projection_dim=1, ), ), - ] - ], + ]: + if not (mode == "sample_wise_trick" and use_gpu): + param_list.append((reduction, constructor, mode, dim, use_gpu)) + + @parameterized.expand( + param_list, name_func=build_test_name_func(args_to_skip=["reduction"]), ) def test_tracin_regression( @@ -70,12 +84,17 @@ def test_tracin_regression( tracin_constructor: Callable, mode: str, features: int, + use_gpu: bool, ) -> None: with tempfile.TemporaryDirectory() as tmpdir: batch_size = 4 - dataset, net = self._test_tracin_regression_setup(tmpdir, features) + dataset, net = self._test_tracin_regression_setup( + tmpdir, + features, + use_gpu, + ) # and not mode == 'sample_wise_trick' # check influence scores of training data @@ -85,6 +104,10 @@ def test_tracin_regression( test_inputs = ( torch.arange(17, 33, dtype=torch.float).unsqueeze(1).repeat(1, features) ) + + if use_gpu: + test_inputs = test_inputs.cuda() + test_labels = test_inputs self.assertTrue(callable(tracin_constructor)) @@ -119,7 +142,7 @@ def test_tracin_regression( # check that top influence is one with maximal value # (and hence gradient) for i in range(len(idx)): - self.assertTrue(isSorted(idx[i])) + self.assertTrue(_isSorted(idx[i])) if mode == "sample_wise_trick": diff --git a/tests/influence/_core/test_tracin_self_influence.py b/tests/influence/_core/test_tracin_self_influence.py index 0f327ce3fb..0ddbe17333 100644 --- a/tests/influence/_core/test_tracin_self_influence.py +++ b/tests/influence/_core/test_tracin_self_influence.py @@ -16,34 +16,54 @@ class TestTracInSelfInfluence(BaseTest): - @parameterized.expand( - [ - (reduction, constructor, unpack_inputs) - for unpack_inputs in [True, False] + + use_gpu_list = ( + [True, False] + if torch.cuda.is_available() and torch.cuda.device_count() != 0 + else [False] + ) + + param_list = [] + for unpack_inputs in [True, False]: + for use_gpu in use_gpu_list: for (reduction, constructor) in [ ("none", DataInfluenceConstructor(TracInCP)), ( "sum", DataInfluenceConstructor( TracInCP, - name="TracInCPFastRandProjTests", + name="TracInCP_sample_wise_grads_per_batch", sample_wise_grads_per_batch=True, ), ), ("sum", DataInfluenceConstructor(TracInCPFast)), ("mean", DataInfluenceConstructor(TracInCPFast)), - ] - ], + ]: + if not ( + "sample_wise_grads_per_batch" in constructor.kwargs + and constructor.kwargs["sample_wise_grads_per_batch"] + and use_gpu + ): + param_list.append((reduction, constructor, unpack_inputs, use_gpu)) + + @parameterized.expand( + param_list, name_func=build_test_name_func(), ) def test_tracin_self_influence( - self, reduction: str, tracin_constructor: Callable, unpack_inputs: bool + self, + reduction: str, + tracin_constructor: Callable, + unpack_inputs: bool, + use_gpu: bool, ) -> None: with tempfile.TemporaryDirectory() as tmpdir: - ( - net, - train_dataset, - ) = get_random_model_and_data(tmpdir, unpack_inputs, return_test_data=False) + (net, train_dataset,) = get_random_model_and_data( + tmpdir, + unpack_inputs, + False, + use_gpu, + ) # compute tracin_scores of training data on training data criterion = nn.MSELoss(reduction=reduction) @@ -56,8 +76,6 @@ def test_tracin_self_influence( batch_size, criterion, ) - - # calculate influence scores, using the training data as the test batch train_scores = tracin.influence( train_dataset.samples, train_dataset.labels, diff --git a/tests/influence/_core/test_tracin_xor.py b/tests/influence/_core/test_tracin_xor.py index 52a71afcf7..d6f205d790 100644 --- a/tests/influence/_core/test_tracin_xor.py +++ b/tests/influence/_core/test_tracin_xor.py @@ -10,6 +10,7 @@ from parameterized import parameterized from tests.helpers.basic import assertTensorAlmostEqual, BaseTest from tests.influence._utils.common import ( + _wrap_model_in_dataparallel, BasicLinearNet, BinaryDataset, build_test_name_func, @@ -18,8 +19,9 @@ class TestTracInXOR(BaseTest): + # TODO: Move test setup to use setUp and tearDown method overrides. - def _test_tracin_xor_setup(self, tmpdir: str): + def _test_tracin_xor_setup(self, tmpdir: str, use_gpu: bool = False): net = BasicLinearNet(2, 2, 1) state = OrderedDict( @@ -34,8 +36,10 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "0" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) state = OrderedDict( [ @@ -49,8 +53,10 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "1" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) state = OrderedDict( [ @@ -64,8 +70,10 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "2" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) state = OrderedDict( [ @@ -79,8 +87,10 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "3" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) state = OrderedDict( [ @@ -94,8 +104,10 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "4" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) state = OrderedDict( [ @@ -109,8 +121,10 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "5" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) state = OrderedDict( [ @@ -124,8 +138,10 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "6" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) state = OrderedDict( [ @@ -139,38 +155,57 @@ def _test_tracin_xor_setup(self, tmpdir: str): ] ) net.load_state_dict(state) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + checkpoint_name = "-".join(["checkpoint", "class", "7" + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) - dataset = BinaryDataset() + dataset = BinaryDataset(use_gpu) - return net, dataset + return net_adjusted, dataset - @parameterized.expand( - [ + parametrized_list = [ + ( + "none", + DataInfluenceConstructor(TracInCP), + "check_idx", + False, + ), + ( + None, + DataInfluenceConstructor(TracInCP), + "sample_wise_trick", + False, + ), + ] + + if torch.cuda.is_available() and torch.cuda.device_count() != 0: + parametrized_list.append( ( "none", DataInfluenceConstructor(TracInCP), "check_idx", - ), - ( - None, - DataInfluenceConstructor(TracInCP), - "sample_wise_trick", - ), - ], + True, + ) + ) + + @parameterized.expand( + parametrized_list, name_func=build_test_name_func(args_to_skip=["reduction"]), ) def test_tracin_xor( - self, reduction: Optional[str], tracin_constructor: Callable, mode: str + self, + reduction: Optional[str], + tracin_constructor: Callable, + mode: str, + use_gpu: bool, ) -> None: with tempfile.TemporaryDirectory() as tmpdir: - dataset = BinaryDataset() - net = BasicLinearNet(2, 2, 1) - + # net = BasicLinearNet(2, 2, 1) + # net = wrap_model_in_dataparallel(net) if use_gpu else net batch_size = 4 - net, dataset = self._test_tracin_xor_setup(tmpdir) + net, dataset = self._test_tracin_xor_setup(tmpdir, use_gpu) testset = F.normalize(torch.empty(100, 2).normal_(mean=0, std=0.5), dim=1) mask = ~torch.logical_xor(testset[:, 0] > 0, testset[:, 1] > 0) @@ -179,6 +214,9 @@ def test_tracin_xor( .unsqueeze(1) .float() ) + if use_gpu: + testset = testset.cuda() + testlabels = testlabels.cuda() self.assertTrue(callable(tracin_constructor)) @@ -196,7 +234,6 @@ def test_tracin_xor( ) test_scores = tracin.influence(testset, testlabels) idx = torch.argsort(test_scores, dim=1, descending=True) - # check that top 5 influences have matching binary classification for i in range(len(idx)): influence_labels = dataset.labels[idx[i][0:5], 0] @@ -225,7 +262,6 @@ def test_tracin_xor( criterion, sample_wise_grads_per_batch=True, ) - test_scores = tracin.influence(testset, testlabels) test_scores_sample_wise_trick = tracin_sample_wise_trick.influence( testset, testlabels diff --git a/tests/influence/_utils/common.py b/tests/influence/_utils/common.py index 90f14353c7..3ab018e5b9 100644 --- a/tests/influence/_utils/common.py +++ b/tests/influence/_utils/common.py @@ -18,16 +18,33 @@ from torch.utils.data import DataLoader, Dataset -def isSorted(x, key=lambda x: x, descending=True): +def _isSorted(x, key=lambda x: x, descending=True): if descending: return all([key(x[i]) >= key(x[i + 1]) for i in range(len(x) - 1)]) else: return all([key(x[i]) <= key(x[i + 1]) for i in range(len(x) - 1)]) +def _wrap_model_in_dataparallel(net): + alt_device_ids = [0] + [x for x in range(torch.cuda.device_count() - 1, 0, -1)] + net = net.cuda() + return torch.nn.DataParallel(net, device_ids=alt_device_ids) + + +def _move_sample_to_cuda(samples): + return [s.cuda() for s in samples] + + class ExplicitDataset(Dataset): - def __init__(self, samples, labels) -> None: + def __init__(self, samples, labels, use_gpu=False) -> None: self.samples, self.labels = samples, labels + if use_gpu: + self.samples = ( + _move_sample_to_cuda(self.samples) + if isinstance(self.samples, list) + else self.samples.cuda() + ) + self.labels = self.labels.cuda() def __len__(self): return len(self.samples) @@ -37,8 +54,15 @@ def __getitem__(self, idx): class UnpackDataset(Dataset): - def __init__(self, samples, labels) -> None: + def __init__(self, samples, labels, use_gpu=False) -> None: self.samples, self.labels = samples, labels + if use_gpu: + self.samples = ( + _move_sample_to_cuda(self.samples) + if isinstance(self.samples, list) + else self.samples.cuda() + ) + self.labels = self.labels.cuda() def __len__(self): return len(self.samples[0]) @@ -52,23 +76,29 @@ def __getitem__(self, idx): class IdentityDataset(ExplicitDataset): - def __init__(self, num_features) -> None: + def __init__(self, num_features, use_gpu=False) -> None: self.samples = torch.diag(torch.ones(num_features)) self.labels = torch.zeros(num_features).unsqueeze(1) + if use_gpu: + self.samples = self.samples.cuda() + self.labels = self.labels.cuda() class RangeDataset(ExplicitDataset): - def __init__(self, low, high, num_features) -> None: + def __init__(self, low, high, num_features, use_gpu=False) -> None: self.samples = ( torch.arange(start=low, end=high, dtype=torch.float) .repeat(num_features, 1) .transpose(1, 0) ) self.labels = torch.arange(start=low, end=high, dtype=torch.float).unsqueeze(1) + if use_gpu: + self.samples = self.samples.cuda() + self.labels = self.labels.cuda() class BinaryDataset(ExplicitDataset): - def __init__(self) -> None: + def __init__(self, use_gpu=False) -> None: self.samples = F.normalize( torch.stack( ( @@ -105,6 +135,7 @@ def __init__(self) -> None: torch.Tensor([-1]).repeat(12, 1), ) ) + super().__init__(self.samples, self.labels, use_gpu) class CoefficientNet(nn.Module): @@ -148,7 +179,9 @@ def forward(self, *inputs): return torch.tanh(self.linear2(x)) -def get_random_model_and_data(tmpdir, unpack_inputs, return_test_data=True): +def get_random_model_and_data( + tmpdir, unpack_inputs, return_test_data=True, use_gpu=False +): in_features, hidden_nodes, out_features = 5, 4, 3 num_inputs = 2 @@ -169,7 +202,8 @@ def get_random_model_and_data(tmpdir, unpack_inputs, return_test_data=True): 3, 4, (in_features, in_features * num_inputs) ) checkpoint_name = "-".join(["checkpoint-reg", str(i + 1) + ".pt"]) - torch.save(net.state_dict(), os.path.join(tmpdir, checkpoint_name)) + net_adjusted = _wrap_model_in_dataparallel(net) if use_gpu else net + torch.save(net_adjusted.state_dict(), os.path.join(tmpdir, checkpoint_name)) num_samples = 50 num_train = 32 @@ -189,15 +223,24 @@ def get_random_model_and_data(tmpdir, unpack_inputs, return_test_data=True): test_samples = all_samples[num_train:] dataset = ( - ExplicitDataset(train_samples, train_labels) + ExplicitDataset(train_samples, train_labels, use_gpu) if not unpack_inputs - else UnpackDataset(train_samples, train_labels) + else UnpackDataset(train_samples, train_labels, use_gpu) ) if return_test_data: - return net, dataset, test_samples, test_labels + return ( + _wrap_model_in_dataparallel(net) if use_gpu else net, + dataset, + _move_sample_to_cuda(test_samples) + if isinstance(test_samples, list) and use_gpu + else test_samples.cuda() + if use_gpu + else test_samples, + test_labels.cuda() if use_gpu else test_labels, + ) else: - return net, dataset + return _wrap_model_in_dataparallel(net) if use_gpu else net, dataset class DataInfluenceConstructor: From 9263ae17a946722d15a1a052e85659d2abdc06aa Mon Sep 17 00:00:00 2001 From: Fulton Wang Date: Tue, 16 Aug 2022 20:09:36 -0700 Subject: [PATCH 116/174] update TracInCP tutorial to use `train_dataset` argument Summary: The API of TracIn was changed so that for all implementations, the initialization argument for the training dataset is now called `train_dataset` instead of `influence_src_dataset`. In this diff, the TracIn tutorial is updated to reflect this change. It just involves changing the named argument in TracIn constructors. Reviewed By: NarineK Differential Revision: D38378555 fbshipit-source-id: dddb4e320b094223964cb8d048821e9aa45281fe --- tutorials/TracInCP_Tutorial.ipynb | 64 ++++++++----------------------- 1 file changed, 16 insertions(+), 48 deletions(-) diff --git a/tutorials/TracInCP_Tutorial.ipynb b/tutorials/TracInCP_Tutorial.ipynb index bcfbe60a77..e8a0e112a7 100644 --- a/tutorials/TracInCP_Tutorial.ipynb +++ b/tutorials/TracInCP_Tutorial.ipynb @@ -691,7 +691,7 @@ "tracin_cp_fast = TracInCPFast(\n", " model=net,\n", " final_fc_layer=list(net.children())[-1],\n", - " influence_src_dataset=correct_dataset,\n", + " train_dataset=correct_dataset,\n", " checkpoints=correct_dataset_checkpoint_paths,\n", " checkpoints_load_func=checkpoints_load_func,\n", " loss_fn=nn.CrossEntropyLoss(reduction=\"sum\"),\n", @@ -718,7 +718,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": { "code_folding": [], "customInput": null, @@ -729,15 +729,7 @@ "requestMsgId": "3d109a69-eb97-45bf-9682-f336b5eeffd3", "showInput": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computed proponents / opponents over a dataset of 50000 examples in 1.22 minutes\n" - ] - } - ], + "outputs": [], "source": [ "k = 10\n", "start_time = datetime.datetime.now()\n", @@ -1160,7 +1152,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": { "code_folding": [], "customInput": null, @@ -1171,22 +1163,14 @@ "requestMsgId": "495ed6b5-183c-475b-b26e-a38270c51779", "showInput": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Performed pre-processing of a dataset of 50000 examples in 5.92 minutes\n" - ] - } - ], + "outputs": [], "source": [ "from captum.influence._utils.nearest_neighbors import AnnoyNearestNeighbors\n", "start_time = datetime.datetime.now()\n", "tracin_cp_fast_rand_proj = TracInCPFastRandProj(\n", " model=net,\n", " final_fc_layer=list(net.children())[-1],\n", - " influence_src_dataset=correct_dataset,\n", + " train_dataset=correct_dataset,\n", " checkpoints=correct_dataset_checkpoint_paths,\n", " checkpoints_load_func=checkpoints_load_func,\n", " loss_fn=nn.CrossEntropyLoss(reduction=\"sum\"),\n", @@ -1217,7 +1201,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { "code_folding": [], "executionStopTime": 1645988498023, @@ -1225,15 +1209,7 @@ "originalKey": "d06f872f-d82c-4369-b0f8-8043551279f7", "requestMsgId": "d06f872f-d82c-4369-b0f8-8043551279f7" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computed proponents / opponents over a dataset of 50000 examples in 0.01 minutes\n" - ] - } - ], + "outputs": [], "source": [ "k = 10\n", "start_time = datetime.datetime.now()\n", @@ -1663,7 +1639,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "code_folding": [], "customInput": null, @@ -1674,15 +1650,7 @@ "requestMsgId": "d7a7e6d1-119f-4703-981a-62b1e1374513", "showInput": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generated incorrect labels in 0.52 minutes\n" - ] - } - ], + "outputs": [], "source": [ "start_time = datetime.datetime.now()\n", "incorrect_labels = []\n", @@ -1919,7 +1887,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": { "code_folding": [], "customInput": null, @@ -1963,7 +1931,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": { "code_folding": [], "executionStartTime": 1646067341246, @@ -1977,7 +1945,7 @@ "tracin_cp_fast = TracInCPFast(\n", " model=net,\n", " final_fc_layer=list(net.children())[-1],\n", - " influence_src_dataset=mislabelled_dataset,\n", + " train_dataset=mislabelled_dataset,\n", " checkpoints=mislabelled_dataset_checkpoint_paths,\n", " checkpoints_load_func=checkpoints_load_func,\n", " loss_fn=nn.CrossEntropyLoss(reduction=\"sum\"),\n", @@ -2000,7 +1968,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "metadata": { "code_folding": [], "executionStartTime": 1646067346865, @@ -2014,7 +1982,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "computed self influence scores for 50000 examples in 0.59 minutes\n" + "computed self influence scores for 50000 examples in 0.48 minutes\n" ] } ], @@ -2042,7 +2010,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 33, "metadata": { "code_folding": [], "executionStartTime": 1646067380564, From 37516c17e20be8c3aec84495d31a3c374e178cc8 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 17 Aug 2022 11:46:26 -0700 Subject: [PATCH 117/174] Improve version checking (#999) Summary: Without the packaging library, statements like: `"1.8.0" > "1.10.0"` will be equal to True, despite v1.10 being a later version that v1.8.0. The `packaging` library will in some cases not be already installed on a user's device, so I've also added it the `setup.py` file. It's one of the core libraries from the Python Packaging Authority, but it's not included with the base Python installation: https://packaging.python.org/en/latest/key_projects/#pypa-projects This wasn't an issue in https://github.com/pytorch/captum/pull/940 as one the libraries in dev install has `packaging` as a dependency. So, there's no error when the tests are using the `packaging` library. Pull Request resolved: https://github.com/pytorch/captum/pull/999 Reviewed By: vivekmig Differential Revision: D38693600 Pulled By: NarineK fbshipit-source-id: a5ea5ef6f2ca175d60f1638072add2fea6d31091 --- captum/_utils/common.py | 23 ++++++++++- .../influence/_core/similarity_influence.py | 2 +- captum/influence/_utils/common.py | 3 +- tests/utils/test_common.py | 40 ++++++++++++++++++- 4 files changed, 64 insertions(+), 4 deletions(-) diff --git a/captum/_utils/common.py b/captum/_utils/common.py index 6db0727024..1bad602896 100644 --- a/captum/_utils/common.py +++ b/captum/_utils/common.py @@ -18,6 +18,27 @@ from torch.nn import Module +def _parse_version(v: str) -> Tuple[int, ...]: + """ + Parse version strings into tuples for comparison. + + Versions should be in the form of "..", ".", + or "". The "dev", "post" and other letter portions of the given version will + be ignored. + + Args: + + v (str): A version string. + + Returns: + version_tuple (tuple of int): A tuple of integer values to use for version + comparison. + """ + v = [n for n in v.split(".") if n.isdigit()] + assert v != [] + return tuple(map(int, v)) + + class ExpansionTypes(Enum): repeat = 1 repeat_interleave = 2 @@ -671,7 +692,7 @@ def _register_backward_hook( ): return module.register_backward_hook(hook) - if torch.__version__ >= "1.9": + if _parse_version(torch.__version__) >= (1, 9, 0): # Only supported for torch >= 1.9 return module.register_full_backward_hook(hook) else: diff --git a/captum/influence/_core/similarity_influence.py b/captum/influence/_core/similarity_influence.py index 83cb2966fa..0fd21eedb7 100644 --- a/captum/influence/_core/similarity_influence.py +++ b/captum/influence/_core/similarity_influence.py @@ -40,7 +40,7 @@ def cosine_similarity(test, train, replace_nan=0) -> Tensor: test = test.view(test.shape[0], -1) train = train.view(train.shape[0], -1) - if torch.__version__ <= "1.6.0": + if common._parse_version(torch.__version__) <= (1, 6, 0): test_norm = torch.norm(test, p=None, dim=1, keepdim=True) train_norm = torch.norm(train, p=None, dim=1, keepdim=True) else: diff --git a/captum/influence/_utils/common.py b/captum/influence/_utils/common.py index 4954944527..cd989098c8 100644 --- a/captum/influence/_utils/common.py +++ b/captum/influence/_utils/common.py @@ -5,6 +5,7 @@ import torch import torch.nn as nn +from captum._utils.common import _parse_version from captum._utils.progress import progress from torch import Tensor @@ -126,7 +127,7 @@ def _jacobian_loss_wrt_inputs( "Must be either 'sum' or 'mean'." ) - if torch.__version__ >= "1.8": + if _parse_version(torch.__version__) >= (1, 8, 0): input_jacobians = torch.autograd.functional.jacobian( lambda out: loss_fn(out, targets), out, vectorize=vectorize ) diff --git a/tests/utils/test_common.py b/tests/utils/test_common.py index 5bea797e97..e19c3c26b9 100644 --- a/tests/utils/test_common.py +++ b/tests/utils/test_common.py @@ -3,7 +3,13 @@ from typing import cast, List, Tuple import torch -from captum._utils.common import _reduce_list, _select_targets, _sort_key_list, safe_div +from captum._utils.common import ( + _parse_version, + _reduce_list, + _select_targets, + _sort_key_list, + safe_div, +) from tests.helpers.basic import assertTensorAlmostEqual, BaseTest @@ -109,3 +115,35 @@ def test_select_target_3d(self) -> None: # Verify error is raised if too many dimensions are provided. with self.assertRaises(AssertionError): _select_targets(output_tensor, (1, 2, 3)) + + +class TestParseVersion(BaseTest): + def test_parse_version_dev(self) -> None: + version_str = "1.12.0.dev20201109" + output = _parse_version(version_str) + self.assertEqual(output, (1, 12, 0)) + + def test_parse_version_post(self) -> None: + version_str = "1.3.0.post2" + output = _parse_version(version_str) + self.assertEqual(output, (1, 3, 0)) + + def test_parse_version_1_12_0(self) -> None: + version_str = "1.12.0" + output = _parse_version(version_str) + self.assertEqual(output, (1, 12, 0)) + + def test_parse_version_1_12_2(self) -> None: + version_str = "1.12.2" + output = _parse_version(version_str) + self.assertEqual(output, (1, 12, 2)) + + def test_parse_version_1_6_0(self) -> None: + version_str = "1.6.0" + output = _parse_version(version_str) + self.assertEqual(output, (1, 6, 0)) + + def test_parse_version_1_12(self) -> None: + version_str = "1.12" + output = _parse_version(version_str) + self.assertEqual(output, (1, 12)) From 312acd85a0fa07c4b00b64c07520b918e04a8ff0 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 19 Aug 2022 09:36:40 -0700 Subject: [PATCH 118/174] Fix failing conda test, & fix a GPU test bug (#1009) Summary: I think that the amount of Conda install timeouts can be lessened by removing unnecessary installs: * Sphinx is not used for the Conda tests, so it doesn't make sense to install it. * NumPy is a dependency of PyTorch, so there is no need to install it after installing PyTorch. The `nodejs` install seems to be what takes up the most time, and I think its where the solver sometimes fails. Using the libmamba solver seems to prevent it from failing, but it still takes vast majority of the install time (around 20 minutes) to install `nodejs`. https://www.anaconda.com/blog/a-faster-conda-for-a-growing-community I also noticed a recurring error in the GPU tests, and implemented a fix for it: ``` Errors were encountered while processing: sane-utils W: --force-yes is deprecated, use one of the options starting with --allow instead. E: Sub-process /usr/bin/dpkg returned an error code (1) ``` This PR along with https://github.com/pytorch/captum/issues/1007 should fix the test failures that Captum is experiencing. vivekmig Pull Request resolved: https://github.com/pytorch/captum/pull/1009 Reviewed By: NarineK Differential Revision: D38786344 Pulled By: vivekmig fbshipit-source-id: 508aba387f62302053945b9eb1c94d51a7c27915 --- .circleci/config.yml | 1 + scripts/install_via_conda.sh | 13 ++++++++++--- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index a3cccbf9b7..1e74e5e328 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -121,6 +121,7 @@ commands: sudo dpkg -i cuda-repo-ubuntu2004-11-4-local_11.4.2-470.57.02-1_amd64.deb sudo apt-key add /var/cuda-repo-ubuntu2004-11-4-local/7fa2af80.pub sudo apt-get update + sudo dpkg --configure -a sudo apt-get --yes --force-yes install cuda jobs: diff --git a/scripts/install_via_conda.sh b/scripts/install_via_conda.sh index a8e32b8d22..88a9603ade 100755 --- a/scripts/install_via_conda.sh +++ b/scripts/install_via_conda.sh @@ -21,6 +21,10 @@ conda update --all --yes # required to use conda develop conda install -y conda-build +# Use faster conda solver +conda install -n base conda-libmamba-solver +conda config --set experimental_solver libmamba + # install other frameworks if asked for and make sure this is before pytorch if [[ $FRAMEWORKS == true ]]; then pip install pytext-nlp @@ -35,10 +39,13 @@ else fi # install other deps -conda install -y numpy sphinx pytest flake8 ipywidgets ipython scikit-learn parameterized -conda install -y -c conda-forge matplotlib pytest-cov sphinx-autodoc-typehints mypy flask flask-compress +# conda install -y numpy sphinx pytest flake8 ipywidgets ipython scikit-learn parameterized +# conda install -y -c conda-forge matplotlib pytest-cov sphinx-autodoc-typehints mypy flask flask-compress +conda install -y pytest flake8 ipywidgets ipython scikit-learn parameterized +conda install -y -c conda-forge matplotlib pytest-cov mypy flask flask-compress + # deps not available in conda -pip install sphinxcontrib-katex +# pip install sphinxcontrib-katex # install node/yarn for insights build conda install -y -c conda-forge yarn From dbb5a31847d6abedc525d94ba007012645b62b00 Mon Sep 17 00:00:00 2001 From: Diamond Bishop Date: Tue, 23 Aug 2022 09:39:12 -0700 Subject: [PATCH 119/174] Fixed bug in House_Prices_Regression_Interpret tutorial (#1014) Summary: Described in issue: [1012](https://github.com/pytorch/captum/issues/1012) **Background** There's a line that must have been edited/added at some point that assumes more then one tensor is being returned from lc.attribute, but there's only one (since only one tensor is passed in): lc_attr_test = lc.attribute(X_test, n_steps=100, attribute_to_layer_input=True) # shape: test_examples x size_hidden lc_attr_test = lc_attr_test[0] The second line here of setting lc_attr_test to the 0th index, then sets it to the tensor index instead of the first tensor, which in turn in the next cell means that "lc_attr_test.shape[1]" throws an exception. **Changes** Fix is to just take out the reassigning of "lc_attr_test = lc_attr_test[0]". **Testing** Tested running the notebook before the change (which showed the error described) and after, which produced the plot which was originally shown in the static tutorial page and matches expectations now (see attachment) Screen Shot 2022-08-18 at 9 59 25 PM . Pull Request resolved: https://github.com/pytorch/captum/pull/1014 Reviewed By: vivekmig Differential Revision: D38927725 Pulled By: dbish fbshipit-source-id: bda2c0a98638ea1b0f5dc15f8c249985fc890cf7 --- .../House_Prices_Regression_Interpret.ipynb | 42 +++++++++---------- 1 file changed, 20 insertions(+), 22 deletions(-) diff --git a/tutorials/House_Prices_Regression_Interpret.ipynb b/tutorials/House_Prices_Regression_Interpret.ipynb index aee3cfc3a0..497ad58987 100644 --- a/tutorials/House_Prices_Regression_Interpret.ipynb +++ b/tutorials/House_Prices_Regression_Interpret.ipynb @@ -128,14 +128,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -430,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -463,14 +461,12 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABYsAAAK7CAYAAACzq9A5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZhldXkv+u8LLRIVJAzBMAgeNYOYwUgkE8ZcJRc4Il41EYNxOBoi52hijIkGE9rmGmOMGjV6OE5R4xAHckS44olDImoUIzgGh4gIAUHFFgRxRN/7x1oVdhdV1VXVtWv38Pk8Tz299xrfvfZvrer67t/+reruAAAAAACwa9tt1gUAAAAAADB7wmIAAAAAAITFAAAAAAAIiwEAAAAAiLAYAAAAAIAIiwEAAAAAiLAYAFhEVZ1cVe+Y0rYvrqr7TGPbK1VVv1xVn6uqb1TVA2ddz0pU1dFV9dlZ18GOpaq6qu6yxPxln59VdVlV3W/Nirt5u++pqseu9XbHbZ9WVS9fYv6jqur909j3elnqNVTV4WMb2LDeda1UVb2qqp4xxe3fcbz2776MZXeY4wYA20JYDABTVlW/VVUXjn+QXl1Vb6+qX5l1XVvT3a/r7l+f0raP6O73TGPbk5YZNJyR5EXdfbvuPnsb9zeV4Gwx3f2+7v7x9drfUqrqPlV15azrYGUWOkfW6/ycle5+Znc/NhEA7uq6+z/Ga//3t3VbVfX0qnrtWtQFALMkLAaAKaqqJyV5fpJnJjkwyR2T/M8kJ86yrq3ZxYKTw5JcPOsikh33uO+oda+FXfm174i8X9Pj2ALAzkFYDABTUlW3z9Br9X909//u7hu7+3vdfW53/9G4zK2r6vlVddX48/yquvU47z5VdWVV/XFVfWXslfzAqjq+qv69qr5WVadN7O/pVXVWVb2xqm6oqo9U1c9MzH9qVX1+nPepqvp/JuY9qqr+par+uqo2J3n6/K8xj73vHjcO2XBdVb24qmqct3tVPbeqvlpVX6iqxy/VW2+yB+5Y95uq6u/G2i6uqiPnLfsnY83XVtUrq2rPibrfP2/bXVV3qapTkpyc5I/HXt3nLlDH55P8lyTnjsvcuqpuX1WvGI/3F6vqGXNfUa6qO1fVP1XV5vG1vq6q9hnnvSbDhwFz2/rjhXrbLvDaz6qq11bV9UkeVVW7TbxXm8djs+8ix3GL7Y/b/qOq+kRV3Ti+jgNr6M1+Q1W9q6p+eFx2rkflKWPbu7qqnjyxreW0zadU1ZeS/H2Styc5aHzt36iqg6rqXlX1wbG9XF1VL6qqPZbTpsb5v1NVn55osz83Tj+oqv6hqq4Z29vvTaxzrxp68l9fVV+uquctcux+uKr+v3Eb146PD5mYv+/Y1q4a55+9yGt/5UStl9RwXp5TVQeN06uG8+orY02frKq7j/OOH1/XDWNbe/ICpc4/P6+rqkur6pfG6VeM237kxPJbDOFQiwxJUIucI4u00QWvK/O2t5K2u+Txn7fskteXsT2cMx77S6rqdybWXegcm+wB+t7x3+vGY/CLE+s+Z6ztC1V13Lzj+4yq+sDccauq/Wq4HlxfVR+uqsPHZRd9/xd4nY+um9v7pVX1uxPz5trdH9bNvw8ePTF/v/EYXF9V/5rkzgvtY5H9ruqaN86/rIZz4RNJbqyqDeO0J9dwHfr62Hb2nFjn/lX1sbEtf6Cqfnpi3j3GNnZDVb0xyZ5ZRFVdXlX3HB+fPLaJI8bnj6mbz9lF22XN61leVXeqqvfWzdfLF9ctewufXFX/MR6Pp43rHZvktCQPHdvEx8fpjxrfyxvGdnTyct8XAJgVYTEATM8vZvhD9y1LLPO0JL+Q5GeT/EySeyX504n5dxi3cXCS05O8LMnDk9wzydFJ/qyq7jSx/IlJ3pxk3ySvT3J2Vd1qnPf5cZ3bJ9mU5LVV9aMT6x6V5NIMPaD/fJF675/k55P8dJLfTPJ/j9N/J8lx4+v4uSQrHfv3AUnekGSfJOckedG8+SeP+7pzkh/LlsdoQd390iSvS/Ls8WvGJyywzJ2T/EeSE8ZlvpPkVUluSnKXJPdI8utJ5oK3SvIXSQ5K8pNJDk3y9HFbvz1vW89e5ms/MclZ42t/XZInZDh+vzru59okL17mtpLkwUmOyXCcTsgQ4p6W5IAM//f7vXnL/1qSu46v8yl18zAay2mb+2bomf2IDO//VeNrv113X5Xk+0n+IMn+Gc6H+yb57/P2v2CbqqrfyHBsH5Fk7wxtZHNV7Zbk3CQfz3Be3DfJE6tqri2+IMkLunvvDO3lTYscp90yBL2HZQj5v5Ut291rktwmyRFJfiTJXy/y2k+pqv8rQ7v4zSQ/muTyDO05GY7rvTO8H7cfl9k8zntFkt/t7r2S3D3JPy1SazKcn59Isl+Gc/sN43G7S4Zrwouq6nZLrH8LyzlHRktdVyatpO1u7fhP2tr15Q1Jrhz3+ZAkzxzfk8n6J8+xSfce/91nPAYfHJ8fleSzGdrus5O8ourmDzKSnJTktzO0wTsn+eD4evZN8ukkG8fllnr/5/tKhvNh7ySPTvLXNX5AMrrDuI2DkzwmyYtr/PAnw3H+dob299/Gn+V6VVZxzZvwsCT/NcMxvGmc9ptJjk1ypwzn9qOSIQxO8rdJfjdDW35JknNq+HBqjyRnZzj39s3Q5h68RN3nJ7nP+PhXM/z+uvfE8/PHxytpl69P8q9jbU/P8B7P9ytJfjzDtef0qvrJ7v4/Gb5B9MaxHf1MVd02yQuTHDee47+U5GNLvB4A2C4IiwFgevZL8tWJP54XcnKSM7r7K919TYYQd/KP0+8l+fPu/l6GQGT/DEHYDd19cZJPZQjy5lzU3WeNyz8vQ9D8C0nS3W/u7qu6+wfd/cYkn8sQAM65qrv/prtv6u5vLVLvs7r7uu7+jyT/nCG8SYZg4AXdfWV3X5vkWVs5NvO9v7vPG8eNfM2815QMYwpf0d1fyxBkP2yF21+WqjowyfFJnjj2BP9KhpDwpCTp7ku6+53d/Z3x/XpehgBiW3ywu88e35dvJXlckqeNx/I7GQKLh9Tyv+L9N9395e7+YpL3JflQd3+0u7+d4YOLe8xbftP4Wj+ZIeyaO7Zba5s/SLJxPBYLtpfuvqi7Lxjb1GUZgqH5x2uxNvXYDCHmh3twSXdfniEgPaC7z+ju73b3pRk+RDlpXO97Se5SVft39ze6+4JFatvc3f/Q3d/s7hsytKtfTZLxQ5Tjkjyuu68dvxFw/sTq81/7yUn+trs/Mr5nf5LkF8fepd9LsleSn0hS3f3p7r56ota7VdXe434+slCtoy909yvHc+SNGUK7M8Ya3pHkuxnCvmlY9Loyz7Lb7lLHfwGLXl+q6tAkv5zkKd397e7+WJKXZ/iQYc78c2w5Lu/ul43H+9UZQtgDJ+a/srs/391fz/CBzOe7+13j9f7Nufk8W+r9n39M3jZus8f29o4MH/BlYltnjO3xvCTfSPLjYy/gByc5fTyX/22seavW6Jr3wvH6/K15064ar9nn5ubz+pQkL+nuD3X397v71Um+k6E9/UKSWyV5/vgaz0ry4SXKP3+ilqMzhNpzzyfD4mW1y6q6Y4bry+njteX9GT68nG9Td3+ruz+e4UOrBXvaj36Q5O5V9UPdfXUPv7cBYLsmLAaA6dmcZP+thHwHZeiFOOfycdp/bqNvvvHO3B/iX56Y/60kk70Jr5h70N0/yM297VJVj5j46u91GXoy7r/Qukv40sTjb07s+6B56y9nW0ttd895x21ye/OP0Vo6LENYcfXEcXpJhp6lqWFIhzeMX9W+Pslrs+UxXI35x+qwJG+Z2P+nM/TQPfAWay5sfvtYqr3M3//ksd1a27xmDKAXVVU/VsPwAl8aj9czc8vjtVibOjRDb/j5Dssw3MV1E8fotNx8fB6ToRfnZ2oYDuD+i9R2m6p6yfhV9uszDEewzxi8HZrka2MwuZD5r32LY9Xd38hw/h/c3f+Uocfsi5N8papeWlV7j4s+OENQd3lVnV8TQyAsYP77mO7e2nu7Vha9rsyz7La7leM/31LXl4MyvFc3TEy7PEPv24WWX67/bJfd/c3x4eTxXdZ5tpX3fwtVdVxVXVDDcBrXZWgbk+fL5t7yw8e58+WAJBtyy3N5OdbimrfQ8V3svD4syR/OO38PzfA+HpTki93dy3wd5yc5evxwZ/cM3yL45fFDmtvn5l68y22Xc23pmxPTVvLattDdNyZ5aIaw+uqqeltV/cQSrwcAtgvCYgCYng9m6DG11JAMV2X4Q3bOHcdpq3Xo3IPx6/qHJLmqqg7L0Pvy8Un26+59kvxbhq8Yz5n8A32lrh73dYs61sjk9iaP0Y0ZhgpIklTVHeatt9LXdEWG92z/7t5n/Nm7u48Y5z9z3OZP9TDMwcOz9DGcX9/uGYKdpWq8IsPXlveZ+Nmzh57C07DYsd1a25xf90LH+swkn0ly1/F4nZYtj9dSrsjC465ekaGX7eTx2au7j0+S7v5cdz8sQ9j1l0nOGr8OPt8fZvgq+VFjbXNfX69xH/vWxNis88x/rVscq3F/+yX54ljTC7v7nknuliHI/qNx+oe7+8Sx1rOz+JAZK7VFu8swfMFilnOOLHhdWWC5lbTdpY7/fEtdX67K8F7tNTHtjhmP/Wip17gt171lWez9n1TDeOD/kOQ5SQ4cr9HnZXnnyzUZhpGYfy4vx7Ze85KVHcMrMnxbZrKN3Ka7/z7D+3zwvOE+Fn0d3X1JhrD2CUne293XZwhyT8nwbZUfTOxzOe3y6gxtafLcWcnvslsch+7+x+4+JkPP9M9k+D0MANs1YTEATMn49eTTM4wr+cCxJ92txt5jc+PZ/n2SP62qA6pq/3H5+TfTWYl7VtWDxl65T8wQAlyQ5LYZ/pC9JhlupJShZ/FaeVOS36+qg8eA7SlruO0k+R9VdUgNNyV6Woav4SfDV4CPqKqfreEGSk+ft96XM9zAblnGr4e/I8lzq2rvGm6MdOeqmvtq814Zvvr99ao6OLcMfebv798z9JL+r+MYr3+a5NZbKeN/JfnzMeDP2DZOXO5rWIU/G9vmERnGSZ07tittm19Osl8NN3acs1eS65N8Y+xRd+oK6np5kidX1T1rcJfxmPxrkhtquKnWD9Vw87O7V9XPJ0lVPbyqDhiDouvGbf1gge3vlaEH6HVju5obY3auHbw9yf+s4UZst6qqey+wjTl/n+TRYzu8dYaA7UPdfVlV/XxVHTW+/zdmGFf2B1W1Rw035bp9D8M7XL9InavxsSQPGt/Xu2Tobb2Y5Zwji11X5ltJ2130+C9g0etLd1+R5ANJ/qKq9qzhZmmPyfKvo9dkOO7Lvk6sxGLv/wKL7pHh2nBNkptquKHery9nH+O3T/53hhuT3qaq7pbkkVtZbW7dbb3mrdTLkjxuPCZVVbcdr497ZfiA9aYkvzeecw/KlkMlLeT8DB+Czg058Z55z5Nltssehrm5MMNx3KOGnv6LjeO9kC8nOXz8QGWuV/aJ44dH38lwHNfqHAeAqREWA8AUdfdzkzwpQ0h4TYYeTo/P0IswSZ6R4Y/TTyT5ZJKPjNNW660ZvvZ6bYbxZR80jv34qSTPzfDH+JeT/FSSf9mG/cz3sgyBwyeSfDRDj7ibMnzVdy28ftz+pRmGJnhGknT3vyc5I8m7MozB/P55670iw5iw11XV2VmeR2QIbj6V4TielaFXWDKM2/tzSb6e5G0ZAppJf5EhYL2uqp48fmDw3zMEn1/MEBZduZX9vyDDOJnvqKobMoRyRy2z9tU4P8klSd6d5Dk9jH+brLBtdvdnMoSml46v/6AkT07yW0luyNBG3rjY+gts780ZxrF9/bj+2Un2HYOx+2cYA/ULSb6a4fjOhdTHJrm4qr6R4Vie1AuPU/v8JD80rn9Bkv8zb/5vZxgj9jMZbjz2xCVqfVeSP8vQM/TqDD2i58ZQ3jvDa782w1fqNyf5q4l9XFbD1/sfl2Hs47Xw1xnGMP5yhrFr59/UbdJyzpEFrysLLLeStru14z9pa9eXhyU5PEMv47dkGE/6XUts7z+NQw78eZJ/GY/BQmMxb4ul3v/JOm7IcPPJN43L/lYWHi93MY/PMBzClzLcsO6VK1h3W655K9LdF2a4YeGLxn1dkvHmd9393SQPGp9/LUOb29r+zs8QaL93kefJytrlyRluxrk5w/XujRmC3uV48/jv5qr6SIa/tZ+UoV1+LcM4yiv5wAwAZqK2HBIKANhRVdXTk9ylux++HdRyXJL/1d2HbXXhrW/rsiSPXW74w/LUMK7nF5Lcqpe+CSO7sO3pujJnLa8vsJSqemOSz3T3Uj3fAWCnomcxALDNxuEAjq+qDeNXlTdm6OEHsE1cX1gv47Ahdx6H4zg2yYm5+ZtAALBLEBYDAGuhMnxd+doMXxP/dIYxbgG2lesL6+UOGcY9/kaSFyY5tbs/OtOKAGCdGYYCAAAAAAA9iwEAAAAASDbMuoC1tv/++/fhhx8+6zIAAAAAALZLF1100Ve7+4D503e6sPjwww/PhRdeOOsyAAAAAAC2S1V1+ULTDUMBAAAAAICwGAAAAAAAYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAAAQYTEAAAAAABEWAwAAAACQZMOsCwAAAACArXnmxZtXvM5pR+w3hUpg5yUsBgAAAGBVrtt45orX2WfTqVOoBFgLhqEAAAAAAEBYDAAAAACAYSgAAAAAWEfvO+GE1a34rFetaR3ALelZDAAAAACAsBgAAAAAAGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAEGExAAAAAAARFgMAAAAAkBmHxVV1bFV9tqouqaqnLrHcg6uqq+rI9awPAAAAAGBXMbOwuKp2T/LiJMcluVuSh1XV3RZYbq8kv5/kQ+tbIQAAAADArmOWPYvvleSS7r60u7+b5A1JTlxguf83yV8m+fZ6FgcAAAAAsCuZZVh8cJIrJp5fOU77T1X1c0kO7e63LbWhqjqlqi6sqguvueaata8UAAAAAGAnt93e4K6qdkvyvCR/uLVlu/ul3X1kdx95wAEHTL84AAAAAICdzCzD4i8mOXTi+SHjtDl7Jbl7kvdU1WVJfiHJOW5yBwAAAACw9mYZFn84yV2r6k5VtUeSk5KcMzezu7/e3ft39+HdfXiSC5I8oLsvnE25AAAAAAA7r5mFxd19U5LHJ/nHJJ9O8qbuvriqzqiqB8yqLgAAAACAXdGGWe68u89Lct68aacvsux91qMmAAAAAIBd0XZ7gzsAAAAAANaPsBgAAAAAAGExAAAAAADCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDJhlkXAAAAAADbk+PfecaK1znvmNOnUAmsLz2LAQAAAAAQFgMAAAAAICwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAMuOwuKqOrarPVtUlVfXUBeY/qao+VVWfqKp3V9Vhs6gTAAAAAGBnN7OwuKp2T/LiJMcluVuSh1XV3eYt9tEkR3b3Tyc5K8mz17dKAAAAAIBdwyx7Ft8rySXdfWl3fzfJG5KcOLlAd/9zd39zfHpBkkPWuUYAAAAAgF3CLMPig5NcMfH8ynHaYh6T5O0LzaiqU6rqwqq68JprrlnDEgEAAAAAdg07xA3uqurhSY5M8lcLze/ul3b3kd195AEHHLC+xQEAAAAA7AQ2zHDfX0xy6MTzQ8ZpW6iq+yV5WpJf7e7vrFNtAAAAAAC7lFn2LP5wkrtW1Z2qao8kJyU5Z3KBqrpHkpckeUB3f2UGNQIAAAAA7BJmFhZ3901JHp/kH5N8Osmbuvviqjqjqh4wLvZXSW6X5M1V9bGqOmeRzQEAAAAAsA1mOQxFuvu8JOfNm3b6xOP7rXtRAAAAAAC7oB3iBncAAAAAAEyXsBgAAAAAAGExAAAAAADCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAIiwGAAAAACDCYgAAAAAAkmyYdQEAAOw8Nm3atKr1Nm7cuMaVAAAAK6VnMQAAAAAAwmIAAAAAAITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQJINsy4A2Pls2rRpxets3LhxCpUAwOLed8IJK17n6HPPnUIlAACwfRAWAwCwQ7tu45nrtq9nXrx5VeuddsR+a1wJAACsPcNQAAAAAAAgLAYAAAAAQFgMAAAAAECExQAAAAAARFgMAAAAAECExQAAAAAARFgMAAAAAECExQAAAAAAJNkw6wIAAGBnd+qmb694nTM37jmFSgAAYHF6FgMAAAAAICwGAAAAAEBYDAAAAABAjFkMAACwZjZt2rTidTZu3DiFSgAAVk7PYgAAAAAAhMUAAAAAAAiLAQAAAACIsBgAAAAAgAiLAQAAAACIsBgAAAAAgAiLAQAAAACIsBgAAAAAgAiLAQAAAACIsBgAAAAAgAiLAQAAAACIsBgAAAAAgCQbZl0AAAAAsOPbtGnTqtbbuHHjGlcCwGrpWQwAAAAAgJ7FAAAs7Ph3nrHidY6aQh0AAMD6EBYDAGyj6zaeueJ1PvmR81a1r/c961UrXue0I/Zb1b4AAIBdi2EoAAAAAAAQFgMAAAAAYBgKAADYLq1mzOgkOe+Y09e4EgAAdhXCYgAAAKbm1E3fXtV6Z27cc40r2X6874QTVrXe0eeeu8aVAMCWhMUAAACwSqu5yelqPfPizStex01OAVgJYxYDAAAAACAsBgAAAABAWAwAAAAAQITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQJINsy4AAABYO5s2bVrxOhs3bpxCJayX6zaeueJ1PvmR81a1r/c961WrWOu2q9rX8e88Y8XrnHfM6avaFwAw0LMYAAAAAABhMQAAAAAAwmIAAAAAACIsBgAAAAAgM77BXVUdm+QFSXZP8vLufta8+bdO8ndJ7plkc5KHdvdl610nLMf2fmOR047Yb1X7AgCAHcVqbvCYuMkjAMyZWVhcVbsneXGSY5JcmeTDVXVOd39qYrHHJLm2u+9SVScl+cskD13/agHY0Z266dsrXufMjXtOoRIAAADYPq0oLK6q3ZLcrruvX4N93yvJJd196bjtNyQ5MclkWHxikqePj89K8qKqqu7uNdg/sAzHv/OMFa9z1BTqYOf0vhNOWPE6R5977hQqWVur6dWkRxMAAACzVlvLXavq9Ukel+T7ST6cZO8kL+juv9qmHVc9JMmx3f3Y8flvJzmqux8/scy/jctcOT7//LjMV+dt65QkpyTJHe94x3tefvnl21LaDmk1Q+9j9SYAACAASURBVCAkqxsGYTVDICTJFWfddsXrXP5Lz17Vvo76wMo/T9jZg5rV9KpMdpyeldv7MCCraf/J6s6B1bT/ZOc/B5it9ezZLay/pZ39dwCz5f+hWzrvmNNXtR5My2p/B6zmHJhF+3cN2pK/hW9pPf8fNIuhcPwtfDN/C69MVV3U3UfOn76cnsV36+7rq+rkJG9P8tQkFyXZprB4LXX3S5O8NEmOPPJIvY4BYDsjdAQAANj+7baMZW5VVbdK8sAk53T395KsRSD7xSSHTjw/ZJy24DJVtSHJ7TPc6A4AAAAAgDW0nLD4JUkuS3LbJO+tqsOSrMWYxR9OctequlNV7ZHkpCTnzFvmnCSPHB8/JMk/Ga8YAAAAAGDtbXUYiu5+YZIXTky6vKp+bVt33N03VdXjk/xjkt2T/G13X1xVZyS5sLvPSfKKJK+pqkuSfC1DoAxwC/tsOnXF6xydla8zrLdyp561unGyAAAAANbLVsPiqrp1kgcnOXze8mds6867+7wk582bdvrE428n+Y1t3c+uYDVBWbK6sGw1QVkiLAMAAFhvq71vwPHvXONCdmGreQ8cf2BWlnODu7cm+XqGm9p9Z7rlwJZWezfdTR9Y3R1IYXuzmnNA+wcAAABWYzlh8SHdfezUKwEAAAAAYGaWc4O7D1TVT029EgAAAAAAZmY5PYt/JcmjquoLGYahqCTd3T891cqANbXascoAAAAA2DUsJyw+bupVAAAAAAAwU1sdhqK7L0+yT5ITxp99xmkAAAAAAOwkthoWV9XvJ3ldkh8Zf15bVU+YdmEAAAAAAKyf5QxD8ZgkR3X3jUlSVX+Z5INJ/maahQEAsDaMW8+ubjXnwPHvnEIhAADbueWExZXk+xPPvz9OAwAAAACSbNy4cdYlwDZbTlj8yiQfqqq3jM8fmOQV0ysJAADYUeyz6dRVrXd0Vr7e0avaEwAAy7XVsLi7n1dV70nyK+OkR3f3R6daFWwjn+axvfEVcAAAAGB7t2hYXFV7d/f1VbVvksvGn7l5+3b316ZfHgAAAAAA62GpnsWvT3L/JBcl6YnpNT7/L1OsCwAAYGbOO+b0WZcAALDuFg2Lu/v+4793Wr9yAAAAAACYhd22tkBVvXs50wAAAAAA2HEtNWbxnkluk2T/qvrhDMNPJMneSQ5eh9oAAFbMTU4BAABWZ6kxi383yROTHJTkIxPTr0/yomkWBQAAAADA+lpqzOIXJHlBVT2hu/9mHWsCAAAAAGCdLdWzeM7Xq+oR8yd2999NoR4AAAAAAGZgOWHxz0883jPJfTMMSyEsBgAAAADYSWw1LO7uJ0w+r6p9krxhahUBAAAAALDudlvFOjcmudNaFwIAAAAAwOxstWdxVZ2bpMenuyf5ySRvmmZRAAAAAACsr+WMWfycicc3Jbm8u6+cUj0AAAAAAMzAVoeh6O7zk3w2ye2T7JshMAYAAAAAYCey1bC4qh6b5F+TPCjJQ5JcUFX/bdqFAQAAAACwfpYzDMUfJblHd29OkqraL8kHkvztNAsDAAAAAGD9bLVncZLNSW6YeH7DOA0AAAAAgJ3Eoj2Lq+pJ48NLknyoqt6apJOcmOQT61AbAAAAAADrZKlhKPYa//38+DPnrdMrBwAAAACAWVg0LO7uTetZCAAAAAAAs7PUMBTP7+4nVtW5GYaf2EJ3P2CqlQEAAAAAsG6WGobiNeO/z1mPQgAAAAAAmJ2lhqG4qKp2T3JKd5+8jjUBAAAAALDOdltqZnd/P8lhVbXHOtUDAAAAAMAMLDUMxZxLk/xLVZ2T5Ma5id39vKlVxU7pzI17zroEAAAAAGARywmLPz/+7JZkr3HaLW54BwAAAADAjms5YfGnuvvNkxOq6jemVA8AAAAAADOw5JjFoz9Z5jQAAAAAAHZQi/Ysrqrjkhyf5OCqeuHErL2T3DTtwgAAAABYvo0bN866BGAHt9QwFFcluTDJA5JcNDH9hiR/MM2iAAAAAABYX4uGxd398SQfr6oDu/vVk/Oq6veTvGDaxQEAAAAAsD6WM2bxSQtMe9Qa1wEAAAAAwAwtNWbxw5L8VpI7VdU5E7P2TrJ52oUBAAAAALB+lhqz+ANJrk6yf5LnTkzvJA+dZlEAAAAAAKyvpcYsvjzJ5Ul+sarukaGX8W8k+UKSf1if8gAAAAAAWA9LDUPxY0keNv58Nckbk1R3/9o61QYAAAAAwDpZahiKzyR5X5L7d/clSVJVf7AuVQEAAAAAsK52W2LegzKMWfzPVfWyqrpvklqfsgAAAAAAWE+LhsXdfXZ3n5TkJ5L8c5InJvmRqjqzqn59vQoEAAAAAGD6lupZnCTp7hu7+/XdfUKSQ5J8NMlTpl4ZAAAAAADrZqkxi2+hu69N8tLxBwAAAGBm9tl06qrWOzorX+/oVe0JYMey1Z7FAAAAAADs/ITFAAAAAAAIiwEAAAAAEBYDAAAAABBhMQAAAAAAERYDAAAAABBhMQAAAAAASTbMugAAAAAAmIYzN+456xJgh6JnMQAAAAAAwmIAAAAAAITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQITFAAAAAABEWAwAAAAAQITFAAAAAAAk2TDrAgAAAAC42XnHnD7rEoBdlJ7FAAAAAAAIiwEAAAAAEBYDAAAAABBhMQAAAAAAcYM7gJ3Oxo0bZ10CAAAAsAPSsxgAAAAAAGExAAAAAADCYgAAAAAAYsxiAAAAYJ7zjjl91iUAMAN6FgMAAAAAICwGAAAAAEBYDAAAAABAhMUAAAAAAERYDAAAAABAhMUAAAAAAERYDAAAAABAhMUAAAAAAERYDAAAAABAhMUAAAAAACTZMOsCAAAAAIDt22lH7LfidU4969tTqIRpEhYDAAAAwA5on02nrnido7Pyddh1GIYCAAAAAABhMQAAAAAAwmIAAAAAACIsBgAAAAAgwmIAAAAAACIsBgAAAAAgwmIAAAAAACIsBgAAAAAgwmIAAAAAACIsBgAAAAAgwmIAAAAAADKjsLiq9q2qd1bV58Z/f3iBZX62qj5YVRdX1Seq6qGzqBUAAAAAYFcwq57FT03y7u6+a5J3j8/n+2aSR3T3EUmOTfL8qtpnHWsEAAAAANhlzCosPjHJq8fHr07ywPkLdPe/d/fnxsdXJflKkgPWrUIAAAAAgF3IrMLiA7v76vHxl5IcuNTCVXWvJHsk+fwi80+pqgur6sJrrrlmbSsFAAAAANgFbJjWhqvqXUnusMCsp00+6e6uql5iOz+a5DVJHtndP1home5+aZKXJsmRRx656LYAAAAAAFjY1MLi7r7fYvOq6stV9aPdffUYBn9lkeX2TvK2JE/r7gumVCoAAAAAwC5vVsNQnJPkkePjRyZ56/wFqmqPJG9J8nfdfdY61gYAAAAAsMuZVVj8rCTHVNXnktxvfJ6qOrKqXj4u85tJ7p3kUVX1sfHnZ2dTLgAAAADAzm1qw1Aspbs3J7nvAtMvTPLY8fFrk7x2nUsDAAAAANglzapnMQAAAAAA2xFhMQAAAAAAwmIAAPj/2bv3+J7r///j9+c2ZifeZowx5lBC2XxbyWFDoU+k9CHCnD7lEyWJfZQQkqJv1EeKj3wvTimHfl/JKR/0GVPR9EGf1QqpsYMxM7Zhx9fvD/P+7uSY7T3b7Xq57OL9er2er+f78Xq+3ntvu+/pOQAAAACExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERYDAAAAAAAAACS5OLoAAAAAAAAAALhsc7fXbvic6d9ML4VKKh9mFgMAAAAAAAAACIsBAAAAAAAAAITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAAAkuTi6AAAAAAAAAAD4I6ZOneroEioEZhYDAAAAAAAAAAiLAQAAAAAAAACExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAEAOCouNMd7GmG3GmMP5/9a8Stvqxpg4Y8z8sqwRAAAAAAAAACoTR80sfkXSDsuy7pC0I3/7SmZI2lUmVQEAAAAAAABAJeWosPhxScvyHy+T1LukRsaYeyX5SvpnGdUFAAAAAAAAAJWSo8JiX8uyEvMfn9ClQLgQY4yTpDmSwq/VmTHmr8aYfcaYfadOnbq1lQIAAAAAAABAJeBSWh0bY7ZLqlvCoUkFNyzLsowxVgntnpO02bKsOGPMVZ/LsqxFkhZJUnBwcEl9AQAAAAAAAACuotTCYsuyul7pmDEmyRhTz7KsRGNMPUknS2jWTlKIMeY5SZ6Sqhpj0i3Lutr6xgAAAAAAAACAm1BqYfE1fCFpqKRZ+f+uL9rAsqxBlx8bY4ZJCiYoBgAAAAAAAIDS4ag1i2dJ6maMOSypa/62jDHBxpjFDqoJAAAAAAAAACoth8wstizrtKSHSti/T9IzJexfKmlpqRcGAAAAAAAAAJWUo2YWAwAAAAAAAADKEUetWewQ586d08mTJ5Wdne3oUoAy4+HhoQYNGsjJid8NAQAAAAAA4MoqTVh87tw5JSUlqX79+nJzc5MxxtElAaUuLy9P8fHxSk5OVp06dRxdDgAAAAAAAMqxSjPV8OTJk6pfv77c3d0JilFpODk5ydfXV2fPnnV0KQAAAAAAACjnKk1YnJ2dLTc3N0eXAZS5KlWqKCcnx9FlAAAAAAAAoJyrNGGxJGYUo1LidQ8AAAAAAIDrUanCYgAAAAAAAABAyQiLcdN+//13GWNY4gAAAAAAAACoAFwcXYAjpU5dUKr926aPuu62AQEBWrx4sbp27XrNtp07d1ZYWJieeeaZK7bJysrSrFmztHLlSsXFxclms6l169Z66aWX1L179+uuCwAAAAAAAEDlUKnD4oqsb9++io+P1/Lly9WmTRtJ0ldffaVNmzaVGBbn5OTIxYWXAwAAAAAAAFBZsQxFObR06VJ17NhR4eHhqlmzpho3bqwtW7ZIkiZNmqTIyEiNHj1anp6eGj16dLHzt2/frm3btmn9+vVq27atqlatqqpVq+pPf/qT/v73v9vbBQQEaPbs2WrdurU8PDyUk5OjWbNmqWnTpvLy8lLLli21bt06e/vc3FyFh4fLx8dHTZo00aZNm4rV3aRJE3l5ealx48ZauXJlKY0QAAAAAAAAgFuNqaTl1N69ezV06FAlJydr0aJFevrppxUfH6+ZM2fq66+/vuoyFNu3b1fbtm3VoEGDaz7Pp59+qk2bNsnHx0cuLi5q2rSpIiMjVbduXa1du1ZhYWE6cuSI6tWrp48++kgbN27U/v375eHhoT59+tj7ycjI0JgxYxQVFaXmzZsrMTFRKSkpt2w8AAAAAAAAAJQuZhaXU40aNdKIESPk7OysoUOHKjExUUlJSdd1bnJysurWrWvfTklJkc1mU40aNVStWrVCbceMGSN/f3+5ublJkp588kn5+fnJyclJ/fv31x133KHvvvtOkrRmzRqNHTtW/v7+8vb21sSJEwv15eTkpOjoaF24cEH16tVTq1at/sgQAAAAAAAAAChDhMXlVMGw193dXZKUnp5+XefWqlVLiYmJ9m1vb2+lpqbq+++/V2ZmZqG2/v7+hbaXL1+uoKAg2Ww22Ww2RUdHKzk5WZKUkJBQqH2jRo3sjz08PLR69WotXLhQ9erVU8+ePfXzzz9f59UCAAAAAAAAcDTC4tuQMeaqxx966CFFRUUpLi7uhvqKjY3ViBEjNH/+fJ0+fVqpqam6++67ZVmWJKlevXo6fvy4vf2xY8cK9fXwww9r27ZtSkxM1F133aURI0bcyGUBAAAAAAAAcCDC4tuQr6+vjh49esXj3bt3V5cuXdS7d2/t3btXWVlZys7O1p49e67ab0ZGhowxql27tiRpyZIlio6Oth/v16+f5s2bp7i4OJ05c0azZs2yH0tKStL69euVkZEhV1dXeXp6ysmJlxcAAAAAAABwu6jUf+DONn2Uo0u4KS+++KKGDh2qBQsWaPDgwZo3b16xNuvWrdObb76psLAwxcfHy9vbW/fcc4+2bt16xX5btmyp8ePHq127dnJyctKQIUPUoUMH+/ERI0bo0KFDCgwMVPXq1RUeHq6vvvpKkpSXl6e5c+dqyJAhMsYoKChICxYsuPUXDwAAAAAAAKBUmMtLDFQUwcHB1r59+4rtj4mJUYsWLRxQEeB4vP4BAAAAAEBZGzX94k2dt2BqtVtcCYoyxnxvWVZw0f2sEwAAAAAAAAAAICwGAAAAAAAAABAWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERYDAAAAAAAAAERYDAAAAAAAAAAQYTH+gN9//13GGOXk5Di6FIcqL+Mwbdo0hYWFObQGAAAAAAAA3L5cHF2AI0X26lWq/Yds2HDdbQMCArR48WJ17dr1mm07d+6ssLAwPfPMM1dsk5WVpVmzZmnlypWKi4uTzWZT69at9dJLL6l79+7XXVd50Lx5c23YsEHu7u568cUXtXPnTmVnZ8vf31/h4eEaNmxYmdZzI/fqssOHD2vKlCnasWOHMjMz5evrqz/96U96+eWX1aBBg1KsFgAAAAAAALg+zCyuoPr27av169dr+fLlOnPmjH777Te9+OKL2rRpU4ntHT0r9kp+/fVX5ebm6s4779TgwYPl7++v2NhYnT59WitWrJCvr6+jS7ymI0eOqG3btvLz89P+/ft17tw5ff3112ratKl2795d4jnl9X4AAAAAAACg4iIsLoeWLl2qjh07Kjw8XDVr1lTjxo21ZcsWSdKkSZMUGRmp0aNHy9PTU6NHjy52/vbt27Vt2zatX79ebdu2VdWqVVW1alX96U9/0t///nd7u4CAAM2ePVutW7eWh4eHcnJyNGvWLDVt2lReXl5q2bKl1q1bZ2+fm5ur8PBw+fj4qEmTJsWC56VLl6pJkyby8vJS48aNtXLlymK1Xbx4UW5ubkpOTpYkzZw5Uy4uLjp37pwkacqUKRo7dqy9/aZNm9SjRw9JUlRUlIYNGyYPDw+5uLioTZs2euSRRyT931IQS5Yskb+/v2rWrKmFCxcqKipKrVu3ls1mKzRWeXl5euONN9SoUSPVqVNHQ4YM0dmzZ+3Hv/jiC7Vq1Uo2m02dO3dWTEyMJGnw4ME6duyYevXqJU9PT7399tv2c1auXKmGDRvKx8dHM2fOtO+fNm2aOnTooLlz59pnEdepU0djx47VU089JUmKiIhQgwYNNHv2bNWtW1fDhw/XmTNn9Oijj6p27dqqWbOmHn30UcXFxdn7/e2339SpUyd5eXmpW7du9jEFAAAAAAAAbgZhcTm1d+9eNW/eXMnJyZowYYKefvppWZalmTNnKiQkRPPnz1d6errmz59f7Nzt27erbdu217W8waeffqpNmzYpNTVVLi4uatq0qSIjI3X27FlNnTpVYWFhSkxMlCR99NFH2rhxo/bv3699+/bps88+s/eTkZGhMWPGaMuWLUpLS9M333yjoKCgYs9XrVo13Xfffdq5c6ckaefOnWrUqJG+/vpr+3anTp3s7Tdv3qyePXtKkh544AE9//zzWrVqlY4dO3bFcTt8+LBWr16tsWPHaubMmdq+fbt+/PFHrVmzxv68S5cu1dKlS/Wvf/1LR48eVXp6uj1MPnTokAYMGKD33ntPp06dUo8ePdSrVy9lZWVpxYoVatiwoTZs2KD09HRNmDDB/ty7d+/WL7/8oh07duj111+3B8zbt29Xnz59rnkvTpw4oZSUFMXGxmrRokXKy8vT8OHDFRsbq2PHjsnNza1Q4D1w4EDde++9Sk5O1pQpU7Rs2bJrPgcAAAAAAABwJYTF5VSjRo00YsQIOTs7a+jQoUpMTFRSUtJ1nZucnKy6devat1NSUmSz2VSjRg1Vq1atUNsxY8bI399fbm5ukqQnn3xSfn5+cnJyUv/+/XXHHXfou+++kyStWbNGY8eOlb+/v7y9vTVx4sRCfTk5OSk6OloXLlxQvXr11KpVqxLr69Spk3bu3KmcnBz98MMPGjNmjHbu3KmLFy8qKipKoaGhkqTz588rKipKnTt3liStXbtWISEhmjFjhho3bqygoCBFRUUV6nvKlCmqVq2aunfvLg8PDw0YMEB16tRR/fr1FRISov3790u6NAt43LhxatKkiTw9PfXWW29p1apVysnJ0erVq9WzZ09169ZNVapUUXh4uC5cuKBvvvnmquM+depUubm5KTAwUIGBgTp48GCJ92P+/Pmy2Wzy9PTUiBEjCo3f9OnT5erqKjc3N9WqVUt9+vSRu7u7vLy8NGnSJHvYfezYMUVFRWnGjBlydXVVaGioepXyGtwAAAAAAACo2AiLy6mC4aK7u7skKT09/brOrVWrln02sCR5e3srNTVV33//vTIzMwu19ff3L7S9fPlyBQUFyWazyWazKTo62r68QUJCQqH2jRo1sj/28PDQ6tWrtXDhQtWrV089e/bUzz//XGJ9nTp1UkREhP7973/rnnvuUbdu3bRz507t2bNHzZo1U61atSRJO3bsUPv27eXq6ipJqlmzpmbNmqUff/xRSUlJCgoKUu/evWVZlr3vgmsYu7m5Fdu+PIYJCQmF6m/UqJFycnKUlJRU7JiTk5P8/f0VHx9f4vVcVvSeXX6uovdj9OjRSk1N1dixY5WdnW3fX7t27UJh/vnz5/Xss8+qUaNGql69ukJDQ5Wamqrc3FwlJCSoZs2a8vDwKHQNAAAAAAAAwM0iLL4NGWOuevyhhx5SVFRUofVtr6ev2NhYjRgxQvPnz9fp06eVmpqqu+++2x7G1qtXT8ePH7e3L7oUxMMPP6xt27YpMTFRd911V6FZswW1b99ev/zyi9atW6dOnTqpZcuWOnbsmDZv3lxsCYrL6xUX5ePjo/DwcCUkJCglJeWa11mUn5+fYmNjC12Li4uLfH19ix2zLEvHjx9X/fr1JV17/It66KGH9L//+7/XbFe03zlz5uiXX37R3r17de7cOe3atcteT7169XTmzBllZGQUugYAAAAAAADgZhEW34Z8fX119OjRKx7v3r27unTpot69e2vv3r3KyspSdna29uzZc9V+MzIyZIxR7dq1JUlLlixRdHS0/Xi/fv00b948xcXF6cyZM5o1a5b9WFJSktavX6+MjAy5urrK09NTTk4lv7zc3d1177336oMPPrCHw+3bt9fChQsLhcVbtmyxr1csSS+//LKio6OVk5OjtLQ0LViwoNBM5BsxYMAAvfvuu/rtt9+Unp6uV199Vf3795eLi4v69eunTZs2aceOHcrOztacOXPk6uqq9u3bS7r2+Bc1bdo0RUZGaty4cfbZycnJyfY1ja8kLS1Nbm5ustlsSklJ0fTp0+3HGjVqpODgYE2dOlVZWVnavXu3NmzYcMPjAAAAAAAAAFzm4ugCHCnkNg3XXnzxRQ0dOlQLFizQ4MGDNW/evGJt1q1bpzfffFNhYWGKj4+Xt7e37rnnHm3duvWK/bZs2VLjx49Xu3bt5OTkpCFDhqhDhw724yNGjNChQ4cUGBio6tWrKzw8XF999ZUkKS8vT3PnztWQIUNkjFFQUJAWLFhwxefq1KmT9u/fr/vvv9++/dlnn9nXK46Ojpanp6caNmxoP+f8+fN64oknlJiYKDc3N7Vt21ZffPHFjQ1evr/85S9KSEhQaGioLl68qIcffljvv/++JKl58+b6+OOP9cILLyg+Pl5BQUHasGGDqlatKkmaOHGiXnjhBU2YMEGTJ09W3759r/pcd955p/bu3aspU6YoMDBQmZmZ8vPzU/fu3Qv9gbyixo4dq4EDB8rHx0d+fn4aP368Pv/8c/vxTz75REOHDpW3JLUZCwAAIABJREFUt7fatWunIUOGKDU19abGAwAAAAAAADAF13utCIKDg619+/YV2x8TE6MWLVo4oCLcjLffflvJycl6++23HV1KhcDrHwAAAAAAlLVR0y/e1HkLpla7diP8IcaY7y3LCi66v1LPLEb5FRAQoF69ejm6DAAAAAAAAKDSICxGudSvXz9HlwAAAAAAAABUKvyBOwAAAAAAAAAAYTEAAAAAAAAAgLAYAAAAAAAAACDCYgAAAAAAAACACIsBAAAAAAAAACIsBgAAAAAAAACIsBhXMXLkSM2YMcO+vWDBAvn6+srT01OnT592YGUAAAAAAAAAbjUXRxfgSG/+WLqB56utal1324CAACUlJcnFxUXOzs5q2bKlhgwZor/+9a9yciq9TD8iIkJhYWGKi4srdmzhwoX2x9nZ2Ro3bpz27NmjwMBASZIxRocPH1azZs1KrT4AAAAAAAAAZYOZxeXIhg0blJaWptjYWL3yyiuaPXu2nn76aUeXJUlKSkrSxYsX1apVK0eXAgAAAAAAAKAUEBaXQzVq1NBjjz2m1atXa9myZYqOjlZmZqbCw8PVsGFD+fr6auTIkbpw4YL9nI0bNyooKEg2m03t27fXDz/8YD8WEBCgt956Sy1btlTNmjU1fPhwXbx48Zp1DBs2TJMnT9ahQ4fUvHlzSZLNZtODDz6o0NBQSVJgYKA8PT21evXqWzwKAAAAAAAAAMoSYXE5dv/996tBgwaKjIzUK6+8okOHDunAgQM6cuSI4uPj9frrr0uS9u/fr7/85S/6xz/+odOnT+vZZ5/VY489pszMTHtfK1eu1NatW/Xrr7/q0KFDeuONN667jjvvvFM//vijJCk1NVVfffWVdu3aJUk6ePCg0tPT1b9//1t45QAAAAAAAADKGmFxOefn56eUlBQtWrRI7777rry9veXl5aVXX31Vq1atkiQtWrRIzz77rNq2bStnZ2cNHTpUrq6u2rNnj72f0aNHy9/fX97e3po0aZI+/fRTR10SAAAAAAAAgHKoUv+Bu9tBfHy8cnJydP78ed177732/ZZlKTc3V5IUGxurZcuW6f3337cfz8rKUkJCgn3b39/f/rhRo0aFjgEAAAAAAAAAM4vLsaioKMXHx6t3795yc3PTjz/+qNTUVKWmpurs2bNKT0+XdCkInjRpkv1Yamqqzp8/rwEDBtj7On78uP3xsWPH5OfnV+bXAwAAAAAAAKD8Iiwuh86dO6eNGzfqqaeeUlhYmAIDAzVixAi99NJLOnnypKRLM463bt0qSRoxYoQWLlyovXv3yrIsZWRkaNOmTUpLS7P3+cEHHyguLk4pKSmaOXNmsTWGL168WOjDsqxr1unr66ujR4/ewisHAAAAAAAA4CiVehmKV1vVcnQJhfTq1UsuLi5ycnJSy5YtNW7cOI0cOVKSNHv2bL3++ut64IEHlJycrPr162vUqFF6+OGHFRwcrI8++kijR4/W4cOH5ebmpo4dOyo0NNTe98CBA9W9e3clJCTo8ccf1+TJk+3H4uPj5ebmVqiWw4cPX7PeadOmaejQobpw4YIWLVqkfv363aKRAAAAAAAAAFDWzPXMIL2dBAcHW/v27Su2PyYmRi1atHBARY4XEBCgxYsXq2vXro4uBQ5SmV//AAAAAADAMUZNv3hT5y2YWu0WV4KijDHfW5YVXHQ/y1AAAAAAAAAAAAiLAQAAAAAAAACVfM3iyuL33393dAkAAAAAAAAAyjlmFgMAAAAAAAAACIsBAAAAAAAAAITFAAAAAAAAAAARFgMAAAAAAAAARFgMAAAAAAAAABBhcaUSEBCg7du3S5LefPNNPfPMMw6uCAAAAAAAAEB54eLoAhxp1PSLpdr/gqnVbqj9qlWr9O677yo6OloeHh5q3Lixhg4dqlGjRskYc0tre/XVV29JP7///rsaN26s7OxsubhcejllZWVp4sSJWr16tVJTU+Xj46PevXvrvffek3QptF68eLG6du1q72fp0qVavHixdu/eXaj/zp076+DBgzpx4oRcXV3t+4cNG6ZPPvlEVatWVdWqVXXvvffq/fff11133XVLrgsAAAAAAACobJhZXE7MmTNHL774ov72t7/pxIkTSkpK0sKFC/X1118rKyurWPvc3FwHVHl93nrrLe3bt0/fffed0tLSFBERof/6r/+64X5+//13RUZGyhijL774otjxCRMmKD09XXFxcapTp46GDRt2C6oHAAAAAAAAKifC4nLg7Nmzeu211/Thhx+qb9++8vLykjFGbdq00cqVK+Xq6qphw4Zp1KhR6tGjhzw8PPSvf/1LmzZtUps2bVS9enX5+/tr2rRphfpdsWKFGjVqpFq1amnmzJmFjk2bNk1hYWH27T179qh9+/ay2WwKDAxURESE/Vjnzp01ZcoUdejQQV5eXurevbuSk5MlSaGhoZIkm80mT09Pffvtt4qKitITTzwhPz8/GWMUEBCgIUOG3PC4LF++XA888ICGDRumZcuWXbGdu7u7Bg4cqOjo6Bt+DgAAAAAAAACXEBaXA99++60yMzP1+OOPX7XdJ598okmTJiktLU0dO3aUh4eHli9frtTUVG3atEkLFizQ559/Lkn66aefNGrUKK1YsUIJCQk6ffq04uLiSuw3Pj5ePXv21OTJk5WSkqJ33nlHffr00alTpwo995IlS3Ty5EllZWXpnXfekSTt2rVLkpSamqr09HS1a9dODzzwgObOnasPP/xQ//nPf2RZ1k2Ny/LlyzVo0CANGjRIW7duVVJSUont0tPTtXLlSrVp0+amngcAAAAAAAAAYXG5kJycLB8fH/uav5Lss3zd3Nzsgezjjz+uDh06yMnJSdWqVVPnzp11zz33yMnJSa1bt9aAAQO0c+dOSdJnn32mRx99VKGhoXJ1ddWMGTPk5FTy7f7444/Vo0cP9ejRQ05OTurWrZuCg4O1efNme5vhw4frzjvvlJubm/r166cDBw5c8XomTpyol19+WStXrlRwcLDq169fbGZw7969ZbPZ7B/PPfdcoeO7d+9WbGys+vXrp3vvvVdNmzbVJ598UqjNO++8I5vNpmbNmik9PV1Lly699mADAAAAAAAAKBFhcTlQq1YtJScnKycnx77vm2++UWpqqmrVqqW8vDxJkr+/f6Hz9u7dqy5duqh27dqqUaOGFi5caF8eIiEhoVB7Dw8P1apVq8Tnj42N1dq1awuFt7t371ZiYqK9Td26de2P3d3dlZ6efsXrcXZ21vPPP6+vv/5aqampmjRpkv7yl78oJibG3ubzzz9Xamqq/ePDDz8s1MeyZcvUvXt3+fj4SJIGDhxYLHAODw9XamqqTpw4oS+++EJNmza9Yk0AAAAAAAAAro6wuBxo166dXF1dtX79+qu2M8YU2h44cKAee+wxHT9+XGfPntXIkSPtSz7Uq1dPx48ft7c9f/68Tp8+XWK//v7+Gjx4cKHwNiMjQ6+88so1ay9aU1Fubm56/vnnVbNmTf3000/X7E+SLly4oDVr1mjnzp2qW7eu6tatq3fffVcHDx7UwYMHr6sPAAAAAAAAADeGsLgcsNlsmjp1qp577jl99tlnSktLU15eng4cOKCMjIwrnpeWliZvb29Vq1ZN3333XaFlGvr27auNGzdq9+7dysrK0muvvWafoVxUWFiYNmzYoK1btyo3N1cXL15URETEFdc4Lqh27dpycnLS0aNH7fvee+89RURE6MKFC8rJydGyZcuUlpZ23WsKf/7553J2dtZPP/2kAwcO6MCBA4qJiVFISIiWL19+XX0AAAAAAAAAuDEu125ScS2YWs3RJdhNmDBB9evX19tvv60hQ4bIw8NDTZo00ezZs9W+ffsS1+P98MMPNX78eI0ePVqdOnVSv379lJqaKklq1aqVPvjgAw0cOFAZGRkaN26cGjRoUOJz+/v7a/369ZowYYIGDBggZ2dn3X///VqwYME163Z3d9ekSZPUoUMHZWdn68svv5S7u7vGjx+vI0eOyBijO++8U//v//0/NWnS5LrGYtmyZRo+fLgaNmxYaP/o0aM1ZswYzZ49+7r6AQAAAAAAAHD9zOVlCyqK4OBga9++fcX2x8TEqEWLFg6oCHA8Xv8AAAAAAKCsjZp+8abOK08TPCsqY8z3lmUFF93PMhQAAAAAAAAAAMJiAAAAAAAAAABhMQAAAAAAAABAhMUAAAAAAAAAABEWAwAAAAAAAABEWAwAAAAAAAAAEGExAAAAAAAAAECExQAAAAAAAAAAERajjC1dulQdO3a84vHOnTtr8eLFN9X3sWPH5Onpqdzc3JstDwAAAAAAAKi0XBxdgCP12PZ6qfa/udtr1902ICBASUlJcnZ2tu87dOiQ/Pz8bvr5IyIiFBYWpri4uJvu42ZNmzZN06dP1549e9S2bdtSeY6AgAAtXrxYXbt2lSQ1bNhQ6enppfJcAAAAAAAAQEXHzOJyZMOGDUpPT7d//JGg+FbIycm5qfMsy9Ly5cvl7e2t5cuX3+KqAAAAAAAAAJQGwuLbwJ49e9S+fXvZbDYFBgYqIiLCfmzJkiVq0aKFvLy81KRJE/3jH/+QJGVkZOiRRx5RQkKCPD095enpqYSEBA0bNkyTJ0+2nx8REaEGDRrYtwMCAjR79my1bt1aHh4eysnJUUJCgvr06aPatWurcePGmjdv3lXrjYyMVGJioubNm6dVq1YpKyur0HHLsjR69GjVqFFDd911l3bs2FFiP7/++qsefPBB1apVSz4+Pho0aJBSU1MlSYMHD9axY8fUq1cveXp66u2339bvv/8uY4w95E5ISNBjjz0mb29vNWvWTB999JG972nTpqlfv34aMmSIvLy81KpVK+3bt+867gYAAAAAAABQMREWl3Px8fHq2bOnJk+erJSUFL3zzjvq06ePTp06JUmqU6eONm7cqHPnzmnJkiV66aWX9O9//1seHh7asmWL/Pz8bnim8qeffqpNmzYpNTVVTk5O6tWrlwIDAxUfH68dO3bovffe09atW694/rJly9SrVy/169dP0qUZ0wXt3btXTZs2VXJysqZPn64///nPSklJKdaPZVmaOHGiEhISFBMTo+PHj2vatGmSpBUrVqhhw4b22dgTJkwodv5TTz2lBg0aKCEhQZ999pleffVVffXVV/bjX3zxhZ566imlpqbqscce0+jRo69rfAAAAAAAAICKiLC4HOndu7dsNptsNpt69+4tSfr444/Vo0cP9ejRQ05OTurWrZuCg4O1efNmSVLPnj3VtGlTGWPUqVMnde/eXZGRkX+ojjFjxsjf319ubm6KiorSqVOn9Nprr6lq1apq0qSJRowYoVWrVpV47vnz57V27VoNHDhQVapUUd++fYstRVGnTh2NHTtWVapUUf/+/dW8eXNt2rSpWF/NmjVTt27d5Orqqtq1a2vcuHHauXPndV3D8ePH9fXXX2v27NmqVq2agoKC9MwzzxSqpWPHjurRo4ecnZ01ePBgHTx48AZGCQAAAAAAAKhYKvUfuCtvPv/8c/sfa7ssNjZWa9euLTQ7Nzs7W126dJEkbdmyRdOnT9ehQ4eUl5en8+fP65577vlDdfj7+xd6/oSEBNlsNvu+3NxchYSElHjuunXr5OLioh49ekiSBg0apK5du+rUqVOqXbu2JKl+/foyxtjPadSokRISEor1lZSUpBdffFGRkZFKS0tTXl6eataseV3XkJCQIG9vb3l5eRV6noJLTdStW9f+2N3dXRcvXlROTo5cXPi0AAAAAAAAQOXDzOJyzt/fX4MHD1Zqaqr9IyMjQ6+88ooyMzPVp08fhYeHKykpSampqerRo4csy5KkQoHsZR4eHjp//rx9+8SJE8XaFDzP399fjRs3LvT8aWlp9pnNRS1btkzp6elq2LCh6tatqyeffFLZ2dn65JNP7G3i4+PtNUrSsWPHSlwi49VXX5UxRv/5z3907tw5ffzxx4XOK+n6LvPz81NKSorS0tIKPU/9+vWveA4AAAAAAABQmREWl3NhYWHasGGDtm7dqtzcXF28eFERERGKi4tTVlaWMjMzVbt2bbm4uGjLli365z//aT/X19dXp0+f1tmzZ+37goKCtHnzZqWkpOjEiRN67733rvr8999/v7y8vDR79mxduHBBubm5io6OVlRUVLG2l9c03rhxow4cOKADBw7o4MGDevnllwst/3Dy5EnNmzdP2dnZWrt2rWJiYuwzkQtKS0uTp6enatSoofj4eP33f/93oeO+vr46evRoiXX7+/urffv2mjhxoi5evKgffvhB//M//6OwsLCrXi8AAAAAAABQWVXq/2+/udtrji7hmvz9/bV+/XpNmDBBAwYMkLOzs+6//34tWLBAXl5emjdvnvr166fMzEz16tVLjz32mP3cu+66SwMGDFCTJk2Um5urn376SYMHD9b27dsVEBCggIAADR8+XHPmzLni8zs7O2vjxo0aP368GjdurMzMTDVv3lxvvPFGsbYrVqxQUFCQunfvXmj/mDFjNGfOHEVHR0uS2rZtq8OHD8vHx0e+vr767LPPVKtWrWL9TZ06VUOGDFGNGjXUrFkzDR48WO+++679+MSJE/XCCy9owoQJmjx5svr27Vvo/E8//VQjR46Un5+fatasqenTpxdb5gMAAAAAAADAJabgf+uvCIKDg62C69JeFhMToxYtWjigIsDxeP0DAAAAAICyNmr6xZs6b8HUare4EhRljPnesqzgovtZhgIAAAAAAAAAULmXoQAAAAAAAABQOpghfPthZjEAAAAAAAAAgLAYAAAAAAAAAEBYDAAAAAAAAAAQYTEAAAAAAAAAQITFAAAAAAAAAAARFgMAAAAAAAAA5KCw2BjjbYzZZow5nP9vzSu0a2iM+acxJsYY85MxJqBsK739jBw5UjNmzLiutsOGDdPkyZNLuSIAAAAAAAAAtwMXBz3vK5J2WJY1yxjzSv72yyW0Wy5ppmVZ24wxnpLybmUR06dPv5XdFTN16tTravfWW29p165d2rJli33fHXfcoWbNmhXbN2PGDD311FNX7GvhwoU3X3ARxhgdPnxYzZo1u2V9AgAAAAAAACifHLUMxeOSluU/Xiapd9EGxpiWklwsy9omSZZlpVuWdb7sSiw7oaGh+uabb5SbmytJSkxMVHZ2tvbv319o35EjRxQaGurIUgEAAAAAAABUUI4Ki30ty0rMf3xCkm8Jbe6UlGqM+V9jzH5jzH8bY5xL6swY81djzD5jzL5Tp06VVs2l5r777lN2drYOHDggSYqMjFSXLl3UvHnzQvuaNm0qPz8//fzzz+rWrZu8vb3VvHlzrVmzxt5X0aUl3n77bdWrV09+fn5avHixjDE6cuSI/fiZM2fUs2dPeXl5qW3btvr1118lyR5KBwYGytPTU6tXr1ZycrIeffRR2Ww2eXt7KyQkRHl5t3SyNwAAAAAAAAAHKbWw2Biz3RgTXcLH4wXbWZZlSbJK6MJFUoikcEn3SWoiaVhJz2VZ1iLLsoItywquXbv2rb2QMlC1alW1bdtWu3btkiTt2rVLISEh6tixY6F9oaGhysjIULdu3TRw4ECdPHlSq1at0nPPPaeffvqpWL9ffvml5s6dq+3bt+vIkSOKiIgo1mbVqlWaOnWqzpw5o2bNmmnSpEn255OkgwcPKj09Xf3799ecOXPUoEEDnTp1SklJSXrzzTdljCmlUQEAAAAAAABQlkotLLYsq6tlWXeX8LFeUpIxpp4k5f97soQu4iQdsCzrqGVZOZI+l/RfpVWvo3Xq1Mke0EZGRiokJEQhISGF9nXq1EkbN25UQECAhg8fLhcXF7Vp00Z9+vTR2rVri/W5Zs0aDR8+XK1atZK7u7umTZtWrM0TTzyh+++/Xy4uLho0aJB9JnNJqlSposTERMXGxqpKlSoKCQkhLAYAAAAAAAAqCEctQ/GFpKH5j4dKWl9CmyhJNmPM5anCD0oqPn22gggNDdXu3buVkpKiU6dO6Y477lD79u31zTffKCUlRdHR0QoNDVVsbKz27t0rm81m/1i5cqVOnDhRrM+EhAT5+/vbtws+vqxu3br2x+7u7kpPT79ijX/729/UrFkzde/eXU2aNNGsWbP+4FUDAAAAAAAAKC9cHPS8syStMcY8LSlWUj9JMsYESxppWdYzlmXlGmPCJe0wl6avfi/pIwfVW+ratWuns2fP6qOPPlKHDh0kSdWrV5efn58++ugj+fn5qXHjxvL391enTp20bdu2a/ZZr149xcXF2bePHz/+h2r08vLSnDlzNGfOHEVHR+vBBx/Ufffdp4ceeugP9QsAAAAAAADA8Rwys9iyrNOWZT1kWdYd+ctVpOTv32dZ1jMF2m2zLKu1ZVn3WJY1zLKsLEfUWxbc3NwUHBysuXPnKiQkxL6/Y8eOmjt3rv0Pzj366KM6dOiQVqxYoezsbGVnZysqKkoxMTHF+uzXr5+WLFmimJgYnT9/XjNmzLihmnx9fXX06FH79saNG3XkyBFZlqUaNWrI2dlZTk6OmpwOAAAAAAAA4FZy1MzicmHq1KmOLqGQTp066dtvv1XHjh3t+0JCQjR//nx7WOzl5aV//vOfGjdunMaNG6e8vDwFBgZq7ty5xfp75JFHNGbMGHXp0kVOTk6aMmWKli9fLldX1+uqZ9q0aRo6dKguXLigRYsWKT4+XqNHj9apU6dUs2ZNPffcc+rSpcutuXgAAAAAAAAADmUsy3J0DbdUcHCwtW/fvmL7Y2Ji1KJFCwdUVH7ExMTo7rvvVmZmplxcKvXvCSodXv8AAAAAAAC4zBjzvWVZwUX3s4ZABbdu3TplZmbqzJkzevnll9WrVy+CYgAAAAAAAADFEBZXcP/4xz9Up04dNW3aVM7OzlqwYIGjSwIAAAAAAABQDjHFtIL78ssvHV0CAAAAAAAAgNtApZpZXNHWZwauB697AAAAAAAAXI9KExZXqVJFFy5ccHQZQJnLzs5mnWoAAAAAAABcU6UJi+vUqaP4+HidP3+emZaoNPLy8pSUlKQaNWo4uhQAAAAAAACUc5VmumH16tUlSQkJCcrOznZwNUDZ8fDwkI+Pj6PLAAAAAAAAQDlXacJi6VJgfDk0BgAAAAAAAAD8n0qzDAUAAAAAAAAA4MoIiwEAAAAAAAAAhMUAAAAAAAAAAMJiAAAAAAAAAIAkY1mWo2u4pYwxpyTFOroO3FI+kpIdXUQlxvg7HvfAsRh/x2L8HY974FiMv2Mx/o7HPXAsxt+xGH/H4x44FuNfuhpZllW76M4KFxaj4jHG7LMsK9jRdVRWjL/jcQ8ci/F3LMbf8bgHjsX4Oxbj73jcA8di/B2L8Xc87oFjMf6OwTIUAAAAAAAAAADCYgAAAAAAAAAAYTFuD4scXUAlx/g7HvfAsRh/x2L8HY974FiMv2Mx/o7HPXAsxt+xGH/H4x44FuPvAKxZDAAAAAAAAABgZjEAAAAAAAAAgLAYAAAAAAAAACDCYjiIMaauMWaVMeZXY8z3xpjNxpg7jTEXjDEHjDE/GWOWG2Oq5LfvbIzZmP94mDHGMsZ0LdBf7/x9fR11Tbc7Y8wT+WNf8CPPGDMqf2xfKNB2vjFmmAPLve0YY9Lz/w242ngaY5YaY34zxhw0xhzK/zxoULSfAtvDjDHz8x83N8ZE5N+7GGMM6zuV4CrvP9FF2k0zxoQX2HYxxpwyxswq0u5RY8z+/Hv2kzHm2bK6lttZ/ufBnALb4caYaQW2/2qM+Tn/4ztjTMf8/c759y20QNt/GmOeLNMLqGCMMbn57x3RxpgNxhhb/v7L71lvFGjrY4zJvvzegz+mwPcwdxXYd4cxZmOB96l/XX7N57/vnyry9bql467g9lfg9f9j/nv5eGOMU/6xgt+D+ubfl8vv95sdW/nt7UrvOwWOjzXGXDTG1Ciwr7Mx5mz+191fjDG7jDGPln31tz9jTK0C7yEnjDHxBbarXuG9KTj/86Rq/nZTY8xRY0x1x11J+VLkdb3WGFP/GuN8Q58HxpiHC5yfnv95cMBc+pnB/n6V37a3MeYHc+nngv8YY3qX9Xjcrgrcl4PGmH8bY9o7uqbbmSnyM2z+vmI/u17t9V3gvPfyP48uf50eXuCcrPzX+gFT5Gc23BjCYpQ5Y4yRtE5ShGVZTS3LulfSREm+kn61LCtI0j2SGkjqd4Vu/iPpqQLbAyQdLL2qKz7LstZZlhV0+UPSh5IiJW2VdFLSi5e/McQfdq3x/JtlWYGSmkvaL+mr6xz7eZLezb+HLSS9f2vKrTiu8f5zLd0kHZL0ZH4/Mpd+obVIUq/8e9ZGUkRp1F4BZUr6szHGp+iB/B/8n5XU0bKsuySNlPSJMaauZVm5kp6TNN8YU8UYM0BSnmVZa8uy+AroQv57x92SUiQ9X+DYb5J6Fth+UtKPZVlcBTdA0u78f2WMqSZpk6RFBd6nXpDUpMA5qwt+zbYs66cyr7piufz6b6VL7/WPSJpaQrvXJW2zLCvQsqyWkl4pyyIroKu970iXPieiJP25yP5Iy7LaWJbVXNIYXfp68FDpl1uxWJZ1usD3/Qv1f99DBlmWlaUi70355+yTtFPS5V+mfyBpkmVZ58q4/PKs4Os6S1L/a4zzDX0eWJa1tUB/+yQNyt8eUvAkY0ygpHckPZ7/c8Fjkt4xxrQuvUuvUC7fl0Bd+lnhLUcXVAEV+9n1Wq/v/ID4CUnHJXWSJMuylhQ4J0FSl/xtvkb/AYTFcIQukrIty1p4eYdlWQd16RP+8naupO8k1b9CH5GS7s8PCjwlNZN0oPRKrlyMMXdKek3SYEl5kk5J2iFpqCPrqkCuazytS96VdEKXfnC9lnqS4gqc/58/UmQFdc33n6sYIOnvko5Jape/z0uSi6TT+X1lWpb1yy2tuOLK0aWg/aUSjr2sS780SZYky7L+LWmZ8n+Asixrr6RvJU2T9Kak0WVQb2W/NxBJAAAHr0lEQVTyrQp//T0vKcYYE5y/3V/SmjKvqgLK/x6mo6Sn9X+/BB8k6VvLsr643M6yrGjLspaWfYWVj2VZJyX9VdLoy78YLKDo19kfyrK2Cq7Q+44xpqkkT0mTVSCsLMqyrAO6FOLzdeAWusJ702WvShphjJkgycWyrE/Lur7bSKQu/Zx6vW7q8+AKwiW9aVnWb5KU/+9bkv52g/1Aqi7pjKOLqIBu5mfXzro0YWGBbvxzAjeAsBiOcLek76/WIH9WTVtJX16hiSVpu6SHJT0u6YsrtMMNyp8p+Ymk8ZZlHStwaLakcGOMs2Mqq3BuZDz/Lemua7aS3tWlWchbjDEvFf1vbJB09fefpgX+C9MBXZrNKsn+ntRV0gZJnyr/mxPLslJ06f0n1hjzqTFm0OX/EoXr8oGkQabAfzHO10rF79O+/P2XTZQ0VtInlmUdKb0SK5f896SHVPzr6ipJTxlj/CXl6tLMDfxxj0v60rKs/9/e/YZaVpVxHP/+SJFxitQxiTGbSYkmIpy6L3UkJGvUsRwKvCesfCEiRoqI/zEmTCnNcQT/4qgxgqilo/WiRJrBP5ij1VQyKmlhUmqiUQx6jdLHF8/asGffe849x/PPe+7v8+bO2XvfwzPn3L32Ws9e69l/Bl6XNEX+nf9+nt87SXuWoVgy9EgXkYj4K/AB4KDGruuAW5RlQS6WtHz00U2eNu3ONNnuPAJ8SlKnFUDd9pOse3O1TQBExL+BH5KJx+YsWCsk7UVO9uhq8sYAzoOmbvpS1t6Scn19FtgMXDrugCbQexm7tsix2Fbg+JK7sCHwgNbebw4rSZp/Ai/PM2PjTvICOk02GDYYlwK7IuKu+sYycNoBfGMsUU2YHj/P5symWW9X3vM24NPAT8m7ro9L2qePMBebvzRKsdxY27cO2B4RM8A9wIlVoj8iTiU790+QszhuHXHcC1ZZtrqFXEbcq6OA/5A3AKx/S8r19xWyLMuDjf2/IpfnTwN3YYPSIvszlJ+zZslI2lpqWd5b29wsQzEzimAXu4h4gCwHcjOZnNwp6SPjjWpB69TutIA7I+Id8rrbqS79fP0k6918bdOx5HjN9dJnq/6uf0uuRruly+P7PQ9ssKoyFKuAtcCWOVabWB96HbuWsozHAfeVMcQOcvKgDYGTxTYOu4CpNvuqmsWHAVOSvtLuTSLiCbK28YHlrrf1SdIXgK/Rfinf5eTycF8oB6Pbz/NzwDPl3zON+sUHAK9VLyLipYi4NSK+Si7zdyJtT53an05awBclvUDO0lgGHF3tjIinSsmQY8hzyLq3iVzmurS27Wlmf09TlDq5kpYCV5DfwUGSjhtBnJNuplx/V5Bt0h6zxUpdxd8B5wA/G314k0fSAeTf8ObStpxLPqthF/D56riIWA+cQrb3NgKSDiVn0L/a3BcR/4qIOyLim2Qd0aOax1jX5mx3JH0W+CTwYDk3pum83LjeT7I+tWubas9rWAd8mEzSXClp33HF+j41U7uR991y/Zz3ePo/D5o69qWsexHxG+BAwDcHB6zHseuXgf2Ap8o5cSQuRTE0ThbbOGwD9pF0WrWhFNo/pHpd6lReQC4z7uQCsm6W9UnS/sBtwLciYvdcx0TEs2TH44RRxjap5vs8lc4k6zlVJVkeAk4u+5eQiYXt5fXaaimOpI+SCc1/DPP/sADN2/40KZ/wvQb4eESsjIiVZEe+JemD5SZLZTXwt2EEPqlKKY+7yYRx5QrgR5KWAUhaTSbLri/7vwfcXc6hM4CrS6kQ61NEvEnO9D6nLKGtuwo4v3xn1r+vA7dHxIrSthxCPkzweeCIxg1zJ2NGpMwUvhG4NiKise/oKjEm6UPk5IYXZ7+L9WKOdqcFbKiuuRGxHFguaUXzd8s1/BKyRIgNRru2aU3pe24EvlPqi94PXDzGWCdGP+dBGz8GLpS0EqD8vIi8llsPJK0iSxO9Pu5YJsl7GLu2gFNr47FPAMf4htVwNAcBZkMXESFpPbBJ0vnAW8ALZO3JuvuADZLWdHivXw4t0MXndLI23w2NFTbNEh+XATtHFdQiMNfneaWkS8jkwOPkE12rWQlnATeVJLKALRHxcNn3JeAaSW+V1+dGxCvDDX9h6aH9qVsPbIuI/9a23U8mNM8GzpN0EzADvEEmNa03V1Fb0RARP5d0MPCYpAB2AydHxMuSPkN+J4eXY3dKeoCcpf/90Yc+ecpn+ieyU/5IbfsuPCNpkFpk/fq6e8jZY+uAjZI2kUu9dwM/qB13kqQja6/PiIjHhhnshKuWge9Nzmy6nUyINU0B10r6PznpZnNEPDm6MCdXo92ZJpca120t23eQScudZD/pVeDMiPj1KOOdcO3apha5HH9rRDxdtm8A/ijpJxHx3OhCnEw9nAfN72eu9/pD6ev+oiTk/gecVx4KafOrrguQY65vR8Tb4wxogdtX0t9rrzcCH6PLsWtJCK+l9kyZiHhD0qPkxCuXSBswNW6Ym5mZmZmZmZmZmdki5DIUZmZmZmZmZmZmZuZksZmZmZmZmZmZmZk5WWxmZmZmZmZmZmZmOFlsZmZmZmZmZmZmZjhZbGZmZmZmZmZmZmY4WWxmZmZmZmZmZmZmOFlsZmZmZmZmZmZmZsC7Oma04nUhbWkAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -562,16 +558,15 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Compute the attributions of the output with respect to the inputs of the fourth linear layer\n", "lc = LayerConductance(model, model.lin4)\n", - "lc_attr_test = lc.attribute(X_test, n_steps=100, attribute_to_layer_input=True)\n", "\n", "# shape: test_examples x size_hidden\n", - "lc_attr_test = lc_attr_test[0]\n", + "lc_attr_test = lc.attribute(X_test, n_steps=100, attribute_to_layer_input=True)\n", "\n", "# weights from forth linear layer\n", "# shape: size_hidden4 x size_hidden3\n", @@ -588,19 +583,17 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABCEAAAIrCAYAAADROYOiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzde5xVZb348c+Xe6jIIJhkInIskeyCYXl3QE9qlmZmkpfEn3nJvJ7zKxMz8XqSMu1XWagFmnY7eU3NFGHI6+lA3lDSLBAtUhAQNeXm8/tjrRn37Nkzs2eYvQbl83695gV7rWc967vWXrf9Xc96VqSUkCRJkiRJqrUe3R2AJEmSJEnaMJiEkCRJkiRJhTAJIUmSJEmSCmESQpIkSZIkFcIkhCRJkiRJKoRJCEmSJEmSVAiTEFIuIq6KiBQRl3V3LN0lIj4SEZMiYlAX1zshX7fDu7Led4p8nb8t35ecf7f/p7vjeKeodl+JiIaIaCgkqG4SEQsiYlo3zr8+/y7qOzHtpHzaXu2U69JjbkRMi4gFXVFXXt/pEfHZCsOrWr51nHen138VdVd93KoUx9t1/3unn4sjYouIuDUilubLeXor5Vrd7/LpLqx9tN2js8eIWu6P2jCZhJCAiHgX8Pn84+G1vLBaz30EOBfo0iSE2nU1sEt3B9FJEwCTEHon+hPZfvmnGs6jq4+5FwAHd1FdAKcDLZIQ7wATWLfj1kn5n9Yv3wT2Ao4l23d/2Uo5r3Wkbrah/tCSyn0GGADcAXwS2A+4reggIqInECmlNUXPW81FRN+U0soi5pVSeh54voh5dZUi14/WDxvad55SWgE81N1xdERK6a/dHcOGIKX0ZHfH0Jq3637aRXFvDzyaUrqpK2KSVDu2hJAyRwPLyO6OvJ5/biEivhARf46INyLi8Yg4sFKzzIjYMSLujYjXI+K5iJgYEeeVN7nPm7ZdFBFfj4j5wCrgg/m4IRHx44j4e0SszOd7fIWY9omIh/OYnomIL1VqbpfP/08RsSIilkTEjIjYuWT8BGBq/vEveWxNzTYjoldEnJXHsTIi/hERl0ZEv7L5jIiI2yPiXxGxOCK+B/Rtc+2/NW1DRNyXL9Of8jrmRkSLO3sR8eG82eWyfD3fHxF7VKivocK0zZp5lzRR3TMi/jsilgP/UzL+yIh4NF/HSyLiZxExtEKd10XE+IiYFxGvRcTsiNi9iuVu8ThGY5PQiPjPiHg2Xxe3R8Tm+d+vI+LlfPs6s2za0uW5OSJejYiXIuKHeauf0rJDI+LafLlWRsRjEXFkG/U1rZ983e4F7FayvTTk0wyJiCkR8XQe+3MR8fOI2LLSskfE+/LlezVf3m9GRI+yskMi4oq8rpX5vz+LiL4lZarZLnaKiLvzdfJ6RPwtIq5o5zvqFxGX5dvjqxHxz4j4bUSMbGVd7RwR10e2v/0jIv5fV+4rrcTY7jGjE9/LDhHx+4h4Ffh1Pq5L99O83GmR7UNvRLbftChTYZqeEbE8Ir5RMuyDedz3lZV9PiK+XfK5f0RcEhHzI2JV/u/ZpdtcVG6G3zOy/XJRvtwzImJkXm5ShTC3aW27jvaPuadFdix5PV9/syut47LlbHbsj4jheZ0nRMT5edzL8233ve3UtQDYGjiiJLZp1S5fST1VncuqERGfiIg7Stb/3MiOkT3Lyh0e2Xnx1XwffDwiTsjHNdDKcasDcTQ7t5RsKwdGxA8iO54uieycMLBs2mrPpedFG+fssvl+NrJHShcDL3RwWcbndS/O19fDEXF0WZnHI6LFD/uS+e9XMqyaY/C0yPbJXSLigYh4HZjcRowREWdExFOR7a+L8vU8IB8/PLJzaD2wR/m+VFbXBNrY70rKnRrZceGViJgVER+oUNdnI+KhfFtcHtn5cVhry1EyXeMxdL+IeCRfTw9HxMfz7ePifBmX5utqo7Lp2z1v5+X2zrehNyLir437QIVy7R4PpS6XUvLPvw36D3gPsAb4Uf7558AbQF1ZuX8H3gRuJmstcTTwN+AfQENJucFkCY0nyB7x+AwwC3g22+Wa1ZmAvwP3AoeQtcB4N1mrjKeAhcBxwD7At4G1wCkl048CVubTfyaf3+P5dAvK5nU1cBQwFvgUWTPFVcAH8/FDyJryJuBzwM75X998/C+B18iaO+4DnAIsB24omUcf4K/5OjkGOAC4FXgur3d4O99FA7AoX3dH5uvj7vz72bak3I55LPflsX4yn89K4KNl9TVUmM8CYFrJ5wl5fM+RXQjtA+yXjzs+H/fLfD5fAl4EngY2LqvzWeB/85g+BTycr6OB7Sz3pFa2jWeB2/P1+H+AFcCdwP3AN/I4p+RlP1lheRYC3wE+kZdfVbbcG+XLsThfzv2B6/Npj29v/ZBtf38CHi3ZXkbl02wHfI9su94TGJ+vmwVAv/JlB+YC/5nX/b182DEl5eqAvwAvAWcAewNfyL+XTardLoCNgaX5evw02UXrBODKdr6jTcn2ofFkP2AOJts2lwFbVFhXfwHOz5fnHLJ997wu3ldKjzvVHjM6+r38FZgIjAPqa7SfHpvPa2pe18lkLYNepmR7bWU93ArMKPl8GvAvsm19o5JlTsD++edeZMfMl8geN9gbOJvsuH9pSV31+XT1JcMuJDsPXEJ2Tvg62T6UgEkd2a5p45gLHJGvz2+SHbM/mc/r2HbWxzRKjv3A8Lz+BWTntv3Jzl1LqHBsLKtrdP4931kS2791cL+tartsZf6V1v+J+fz2z9fLV4FXgG+VlNk9/44uz+f3CeBU4Mz01nmz4nGrA3E00Hz/aywzH/h+Ps9TyG5qXFNWX7vn0rxcm+fssvn+PS+/H/CZNpZlAmXHF7L9+6Q85n3IjlurgRNLypyUD3tPWX2/ILsOig7u89Py7+3ZfPnrgY+3EffFedw/APYlOwe8SrYf9yDbZ3bOv9M/UXb9UlZXe9c6jfvL74ED8zLzgWeAXmXbYgJ+mi/nYcC8vOwmVRy//0l2vTY+/36fJEsgXUV2LNyX7Pi0GphcMm215+3t8/V+P9n1YWN8z9H8GNHp46F//q3LX7cH4J9/3f0HfC0/sO6Sf943/3xiWbkHyC64omTYR/OyDSXDLs4P/O8tGfau/OSSyupMZD9C3lU2/Jz8BPC+suFXkV089so//zw/EfUvKTM0n3ZBG8vcMz/xPAV8r2T4hDymbcvK75EP/2LZ8CPy4R/JPx+Xf965pEwPsh8r1f6wWl263MDmZBesE0uG3ZOfTPuULdM84Oay+hoqzGcBlZMQl1VYTy8AM8uG756XP7WszmWUJK+AMXm5w9tZ7kmtbBtP0/yi57v58G+UDOtFlhSZWmF5flxW59n5unx//vlkKlxUANPzOnu2tX5K1vF9VexnPYGt8noOLl92Sn645MMfB+4q+Xx+HvvoNubR7nZR8p18qL2Yq1ie/mQX0mdUWPfnlZW/DXi65HNX7Culx52qjhmd+F5Oq+V+mi/zc8CdZfM4LJ//tNbWQV7uDLIfeo0/IG4GfkT2Q2jffNiJebwb55+Pyuves8L+sQrYPP9cT8n+QZYIexW4omy6/6D1JER723Xj9lJ+zP0B8KdObJfTqJyEaCgr93/z4e9pp74FwHUVhle7fJ3aLiut/wrjg+z4dzbZsbdHybItrWL/afe41VoctJ6EKE84/CBf/sYf6VWdS1vZTyudsxvne1OVy9K4vVU8vpDtj73y7+fRkuGbkCXBzykZNoTsWufrJcOqPTdPy+M4qIqYB+XzmVY2/Mi8jgNLht1Xvq23sx62rTAukSWRe5cM+1w+fNf888ZkSdKflk27Ddkx5PQqtr/VwIiSYQfm85heVvZGYH7J52rP29eT7WMblZTZKo+v9BjRqeOhf/6t65/NbKTsrtBfUkoP5p+nkyUGjm4skDf1HEN2pyI1Dk8pzSHLepfaGXgoZc/5N5Z7neyOdiV35uNL7Uf2OMD8vGler8g6y/w9sBnZnZzGed2RUvpXybwWkSVMmoms6fTMiHiJ7A7bauD9ZHcJ27Mf2cnoN2Xx3JWP3zP/dxfguZRS03PUKaU3yZtxV+kvKaW/lEz/ItmJdVi+HO8iuxP938CbJbEE2Xe3Z8sqq1be3HQ7sh9X15cOTCndR3YHZ6+y8g+mlJaVfH48/7fd5pmtuDs17x/kz/m/vy+JZQ3ZHZqtKkxfvt5/SXaR+bH8857A31NKDWXlriO7wBxVNrxDz9lGxJcje4zlVbJtbmE+qtI2V75/zKX5evsE8L8ppYdbmVe128VfyO46TonsMZtK66215fl8RPxPZI+jrCH7obtxlcvzeNnydMW+UqraY0ZHv5fWvvOu2k/fm/+VL/cNeWztmQH0A3bNmw7vlS/zfWStN8j/nZ1SejX/vB/Z/vtAheNZb7LjaiUfJLsL+d9lw3/TRnztbdet+V/gIxHx/fzY3b+KadpyR9nndT02NWpv+areLquRN0OfEhHPkp2TVpO1ThlIdqyGbN3VRfYoxKei7HGIGqu03/cla+EI1Z9LO3rO7nQfCJE9CveLiPh7Po/VZC3+muaTUnqF7LzwpZIm+hPI9uef5vV09Ny8mur63tqZrOXYdWXDf0m2XsrPw13h7pTS6pLP5fvLLmStfK4v+x6fIztPV3Md8nRK6W8ln1uc30uGvzciIv9c7Xl7F7Lrw9caC6SUniNrGVGqs8dDaZ2YhNAGLSLGkB2wb4yIgfnFyiZkmeedI+L9edHBZAfjFytUU/785dAqyzVaVGHY5mQnmtVlf40Xv5t1ZF4RsSPZReirZE2fdwZ2Imu62K/F1JXj6UP2o6s0nsZ5l8ZTaTk78ozq0grDVpbEOYjszso5tFw/J5NdfHb22Fb+XQxqZThkTSnLe9ZuFnt6q5OtatZxJcvKPq9qY3ileZSv98bPjc//D6L1ZWscX6pS2Yoi4hTgCrKLz8+SJT4aL2YqxVr+va8sK7cZbXfeWdV2kVJ6max58z/y+BZG9lz5Ie0sz6eBX5Hd0Tsc+DjZPrS4A8tT2t9DV+wrpao6ZnTie2ntO++q/bSxb5Vmy50n115qZd6lHsvLjSV7fGAA2eNvM4Gx+YV7PVmyotHmZH0dlMf1x3z8ZlTWGGv5Mbet76y97bo11wJfJtvOfg8sjYgbo/OvVqwUB1XG0tF6S+us9lzWrnx7uZWs6fqFZMmlnYCL8iL9AFJKs4BDyRKzNwGLI2J6RHyo6qXqvPbWc1Xn0k6cs6s+NpeKiI3JHqX6MNnjPnvk8/kpLfunuYLsR/gn8/3qeLIWGI2xd/TcvDiltLaKMCueh0uOEbV4w0U13yNkx9HyZf0g1W3XHTm/9yJbt1D9ebvac0xnj4fSOvHtGNrQNbZ2ODP/K/dFsmfpl5AdlDevUObdvHUnEbKTQ2vlKkkVhr1EdlFyWivTPNXBeR1Cdsfgs6XZ/YioI7sr3J6XyJqUttZZ3D9K4mnReVOFeNbFcrLnfX9IdqHeQn5HGbKYB1Qo0tpFS/l30XghskWFslsAc9qMtPu9m6x5f+lnyJ4fhmz5Kt1V26JkfKlK22prxgP3pJT+s3FARGzTgenLLeGt5EklVW8XKaVHgEPyuz1jgLOAX0fEh1NKc1upfzzwTEppQuOAiOhN5y+Au3pfqfaY0dHvpSPfeamqvo+IaLyYbrbc+XfT7sVvSilFxCyyH6SvAI+klJZFxAyyH6q7kd0dnFky2UtkLdg+X15fbkErwxtj3ZzK+1WXyVvcTSFrsVNH1hLoUrJE2Me7en41VO12WY1/I9tfj0opNd0VzxOEzaSUfkPW2mBjsiTUJcCdEfHekvNDd6j2XNrRc3Zn99NdyH6A7pG38GucT4vfBymluRFxL3AC2TJsm/+/UUfOzR2JufQ83LTflRwjKiVEa60xQTqB5seCRq/UcN7VnrcXUfnYVD6ss8dDaZ2YhNAGKyL6kHVs9z9kdwDKXQYcFRHnpJTWRsRssh8ukxofyYiIj5I9A1iahHgI+L/5xc7zebl3kXU8V607yTprWlhyl6GSh8juSvRvfCQjsrc27EbzTHl/sue1m076ETGO7K5G6eMkjdn+Zm9QyOM5E9g0pXRPG/E8CBwTETs3NjPP73y0dnLrsJTSa/mF0IfJnplu64LyWbLvrE9KaVUez55krV2q8RTZXYPxwE8aB0bErmQXbpd2YhGK9Hma3wEeT3aR2Pjmj1nAoRGxW0qptInm4WQ/HKp5Dd1KKq/P/mTPEJc6ppqgW3EX8I08UfBo+cgObheN06wBHoqIc8iex92erDl5Jf1p+XjAUbx1d6qjunpfqfaY0dXfS0Ud+D6eJ2vC/HnyZt25Q6j+GmUG2fF6LW9t73PI7jZPIruTWLp935nX/2pK6c9U7/G8zkNpntQ4tAN1lGvtmNskf8TrVxHxcZr/6CvCStqIrQrVbpfVaHwkpfRHeW+y/hQqyh/BuS0iRpB1nLkZWeul1o5btVbtubTac/a6qrRO64CDWil/BVmz/zqyxwmazi+dOQZX6SGyfXg8WZ8TjQ4jO0Y0dKLOdve7djxAlmjYNqV0TSfr6Kxqz9sPkl0fbtT4SEb++OFuvJXsgs4fD6V1YhJCG7IDyC5I/rPCs3VExBSyDs7qyS44zyX7IXRTRFxJ9ojGJLImcKUn2++SNaP9fUScR3ay+4/832oz/5eRnWDvjYjLyH4MbwSMJLtj0XiBcCFZh0m/j4jvkDWfPIfsh3NpTHeS9Xo8LSKmkj1Xeg5v3RFv1Hjy+kpEXEN2YfJYSqkhIn5Bdmfpu2TN9N4k6/Tsk2S9jj8NXEOW0LkxIiaSnRBPpHJrhHXxH8AfyJb7J2QJl8FkPXP3TCk1JpV+SdZk9KeRvVpum3zal6uZSZ58+ibZ3cjryC6+tiRr/vsXmv9oWh99MrLXEt5F1uz+XODakmf5p5HdobwxIs4m+0F4BFmv/ydU2VT2SeCkiDiM7E0Kr6SUniK/2M63gz+S3an+3Dosy2VkF1nTI+JCsh+Eg8kulk/Mn1lud7uIiE+RbRM3k13Mb0TWc/4rZBdtrbkT+Ey+P95Gdke2sVf7zujqfaXaY0ZXfy9taff7yFtDnAdcnR+bfkl2h/XrtEyWtGYm2eNye5Ld8W7cd/9A1nT/D2X97lxPlni5JyIuJWvi3ofsTvuBZG8X+Bdl8hYWlwMTI+IVsqbYO5I1l4fmx9xqVTzmknVo2LhNvkh2zD6Kt/oOKMqTZK88/BTZuW5JSmlBB6avdrusxjyyxPJFEbGWbF2dUV4oIs4nu9s7k+zH1nvJ9vFHUkqLS5ar0nGrpjpwLq32nL2uHiDbz34YEeeSfTeNrT83rVD+BrK3juxG9paSctWem6uWUlqa76dnRcRrZI+pbE92/XMfrfe31ZbWrnVWtTFNaUwrIuKrZOttCPA7suuKLcn6qGhIKf28E3FVYxrVnbcvJEuQ3pVfB/Qhu2YtfxyjU8dDaZ211Wulf/69k//IfoSsoOTNEmXjNyV71du0kmGHk11ErSRrgncw2WsYbyqbdkeyk+MbZBcN55DdhVlWVi4BF7Yy/zqyC7j5ZHcBXiR7jdLpZeX+HXgkj+lvZHfKbgIeLit3Sl7X62Qdd+1DhbdHkP1Q/Ttv3YUZng/vQXbiezRfrpfz/08mu6vTOP0IsouEf5HdcfpeHlOrPXKXTNtAhR7LKXubRT5se7IfLC/my/482fPCnywrdwJZwuB1sguuj5bXRxs9Zefjj8yXdSVZ08WfAUMrxFipF/lESa/5rdQ/icpvx7iwbFjFOMvXW0m5PYFbyJ4rXkrWTLb8TSxD8+VZki/fY8CR1cw3H7dF/n2/Qkkv/GR3mH6UbwOvkP1w36Z8ffBWL/u9yuqdRsvXzG4OXEl2YbuK7A76NZS8hq297YKsGeuvyPaFN/L47qCN18OVbP8Xkv2o+RfZ3ajR1W5LrXzH67qvlO+77R4z1vV7qeF+ehrZD8w3gNlkb6BpUV8b6+OflLwBIx92RvlylYzrly/jn/O4lpIdFyfx1tuH6mn5VoSeZEnIf5IdUxqAXSl7k0hr64/K23WLYy7Zo4INJettfv7dDmhnPTSrn7fejvGlsnItlq2V+kbm29C/KHlbSQeXr6pzWYV5V1r/HyE7t/4r35bOJ+tEsfRcdQBZPxqL8nX3HFlLtveU1FPxuNWBOBqo/HaMfcqmnUDZ/kz159J2z9mtzbeNZakUzziy65jXyRIyp1LheFVSfkpedrNWxre7z+fbyfPVxJyXD7L9+al8G1pEdj4bUFauqrdjtLbf5cMrnXuH58MnlA3/JFmya0W+TTbenGj1la8l2899rcyjfF+dRNm+RhXn7bzcPvl3W3p9OI2W+2injof++bcuf42vDJLUCRHxXrI3E1yUUrqgjXI9yd5dvSSltHeNY9o4j+n2lNKx7ZXXO09ETCB7z/j7UkrPdHM40jtaRHyOrKPFPVNK93Z3PFKt5P0wPAPcm1I6qrvjkfT25eMYUpXyfh2+S9YEdwnZXcyvkWW/ry4rewHZifpZskc+vgR8iCxr3tVxfZ/sDv8/gPeQ3WGpI7urKknqInm/DAeQ9avyBlnLqq+TPbd+XxuTSm9bETEA2IGsNehWrP/9IUlaz5mEkKq3lqwJ5w/IEguvkTUpPTSlVP66pAR8kywpkMiayn0mpfS7GsTVj+w56HeTNVP8I1nTzMdqMC9J2pC9SvaY01fI+u94Efg1cFayaaneuXYke+zgRbLHjh7p5ngkvc35OIYkSZIkSSpEj+4OQJIkSZIkbRjekY9jDB48OA0fPry7w5AkSZIkaYMzZ86cJSmlIZXGvSOTEMOHD2f27NndHYYkSZIkSRuciHi2tXE+jiFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmF6NXdAXS3lStXsnTpUl555RXWrl3b3eFINdGzZ0822WQTBg0aRN++fbs7HEmSJEkbqA06CbFy5UoWLlxIXV0dw4cPp3fv3kREd4cldamUEqtXr2bFihUsXLiQYcOGmYiQJEmS1C026Mcxli5dSl1dHYMHD6ZPnz4mIPSOFBH06dOHwYMHU1dXx9KlS7s7JEmSJEkbqA06CfHKK68wYMCA7g5DKsyAAQN45ZVXujsMSZIkSRuoDToJsXbtWnr37t3dYUiF6d27t32fSJIkSeo2G3QSAvARDG1Q3N4lSZIkdacNPgkhSZIkSZKKYRJCkiRJkiQVwiSEJEmSJEkqRK/uDmC9NmlSd0fQtvU9vk6aNm0axxxzDFOnTmXChAlNw4cPHw7AggULuiUugEmTJnHeeecxc+ZM6uvruy0OSZIkSXo7siWEmrnooouICCKCp556qmKZSZMmERE0NDRUHD9hwgQioluTBZ01bdo0IoJp06Z1dyiSJEmS9I5jEkJNUkpcffXVTW9QuOqqq7oljoMPPph58+Zx8MEHd8v823LyySczb948Pvaxj3V3KJIkSZL0tmMSQk3uuusuFixYwNFHH80WW2zBNddcw6pVqwqPY9NNN2XkyJFsuummhc+7PYMHD2bkyJH079+/u0ORJEmSpLcd+4RQk8aWD8cddxybbbYZl156KTfddBOHHXZYU5nhw4fz7LPPAjB27Nhm06eUmlpRAGyzzTZN/996662bHs+or69n1qxZrFy5km9961tcf/31LFiwgC984QtMmzat1T4hGr388sucffbZ3HTTTbz00kuMGDGCE088kVNOOaXZ/BsaGhg7diznnnsukyr0n1Hex0RjXADHHHMMxxxzTFPZ+fPnM3z48Db7hLjnnnv49re/zR//+Edee+01tt56az772c9y1llntUioNM5r9erVTJ48malTp7Jw4UI233xzDj/8cC644AL69OnTbJp7772XyZMn8/DDD7N48WLq6uoYPnw4+++/P+eee26L5ZO0nqt1vz7v0H6DJEnS25tJCAHwwgsvcOutt/L+97+fXXfdlQEDBnDppZdy5ZVXNktCnH766dx8883MmjWLo48+uumHfKNzzz2Xm2++mUcffZTTTjuNgQMHAjT9W+qQQw7hf//3f9l///35zGc+w+abb95unKtWrWKfffZh+fLljB8/nlWrVnHDDTdw2mmn8dRTT/HDH/6w0+tgwoQJDBw4kFtuuYWDDjqIj3zkI03jKsVfasqUKXz5y19mo4024tBDD2XzzTenoaGBSy65hN/+9rfcf//9Fes4/PDDuffee9l///0ZMGAAd9xxB5MnT+bFF19k6tSpTeXuvPNODjjgAAYMGMCBBx7IlltuydKlS5k3bx5XXHGFSQhJkiRJbwsmIQTA1KlTWb16dVPLgx122IGPfvSjzJw5k2eeeYZtt90WyJIQy5cvZ9asWUyYMKFFa4BJkyaxYMECHn30UU4//fQWSYpSzz77LHPnzmXw4MFVx7lo0SJGjBjB3Llz6du3LwDnnXceO+20E1dccQWHHXYYe+65Z4eWvVHjst9yyy185jOfqdgKo5Jnn32WU089lY033pg//vGPjBw5smncSSedxI9+9CO+9rWvceWVV7aY9q9//StPPPEEgwYNArKOQT/84Q9z7bXX8l//9V9sscUWQNZK5c0336ShoYEPf/jDzepYsmRJJ5ZWkiRJkopnnxBq6pCyR48efPGLX2waPmHCBFJKNeug8oILLuhQAqLRf/3XfzUlIAAGDRrEOeecA9Cs9UBRrrvuOlatWsXJJ5/cLAEBWVJhk0024Wc/+xkrV65sMe0ll1zSlIAA2GijjTjiiCN48803mT17dovy73rXu1oM68w6lCRJkqTuYBJCzJgxg7/+9a/8+7//O1tuuWXT8MMPP5w+ffowbdo0Vq9e3eXz7cwbJnr16sWuu+7aYnhji4yHH354XcPqsD/96U8AjBs3rsW4uro6Ro8ezRtvvMGf//znFuPHjBnTYthWW20FwLJly5qGHXHEEQB8/OMf58QTT+RXv/oVzz//fJfEL0mSJElFMQmhpscEyh8/GDRoEJ/+9Kd58cUXueWWW7p8vo2PGnTE4MGD6dmzZ6t1vfzyy+scV0c1znPo0KEVxzcOX0qi5ssAACAASURBVL58eYtxlfqJ6NUre0pq7dq1TcM++9nPcttttzF69Gh++tOfMn78eLbaaivGjBnD3Xffvc7LIEmSJElFMAmxgVu8eDE333wzAF/4wheIiGZ/N9xwA0DF/gzWVembLKq1ZMmSZj/OG/3zn/8EaPYWih49ss17zZo1FeuqlBTojMZ5NsZQbtGiRS1i64wDDjiAGTNmsGzZMu655x7OOOMMnnjiCT71qU/x5JNPrlPdkiRJklSEmnZMGRFbAZcB/w4EMB04PaW0sIppUyujRqeUHum6KDds11xzDatWreKjH/1os7dBlLr11luZPn068+fPZ5tttmlqiVApGQC0O35drFmzhgceeIA99tij2fCGhgYARo8e3TSsrq4OgOeee65FPc888wwvv/xyi5YInYl99OjR3HjjjTQ0NLD33ns3G7d8+XIeeeQR+vXrx/bbb191nW3ZaKONGDduHOPGjaOuro5vfvOb/O53v2PUqFFdUr8kSZIk1UrNWkJERH9gBjASOBo4CngfMDMiNqqymmnALmV/T3d5sBuwxk4nr7jiCq6++uqKfyeccEJT55UAm222GQALF1bOJbU3fl2dddZZzTp5XLp0KRdeeCEAxxxzTNPwkSNHMmDAAG655RZefPHFpuGvv/46p556asW6OxP7kUceSe/evfn+97/PM88802zcOeecw4oVKzjyyCObdabZUX/4wx8qtuh44YUXAOjfv3+n65YkSZKkotSyJcRxwAhgu5TSMwAR8RjwF+AE4LtV1PH3lNJDtQtxw9bQ0MDTTz/NBz/4wTY7iTz22GO56KKLmDp1Kueddx5jx46lR48enHXWWcydO7epxcE3vvENAPbee2++/e1vc9xxx3HIIYewySabMHDgQE4++eR1jnno0KGsXLmSHXbYgQMPPJDVq1fzm9/8hkWLFnHSSSc1ez1n7969Oe2007jgggsYPXo0Bx98MGvWrOHuu+/mPe95D+95z3ta1L/LLrvQv39/Lr/8cl566aWmviZOOeWUVh+nGD58OJdffjlf+cpX2HHHHfn85z/PkCFDmDVrFg8++CAjR47kkksuWaflPvXUU/n73//ObrvtxvDhw+nTpw9z5sxhxowZbL311owfP36d6pckSZKkItQyCXEg8FBjAgIgpTQ/Iu4HDqK6JET3mjSpuyOoqcZWEF/60pfaLDd8+HD22Wcf7r77bn77299y8MEHc8011/Cd73yHK664gjfeeAN4Kwmx7777cumll3LVVVdx+eWXs2rVKrbeeusuSUL06dOH6dOnM3HiRH75y1+yZMkSRowYwde//nVOOeWUFuXPO+88+vfvz1VXXcWVV17JFltswfjx45k0aVLFxxfq6uq44YYbOO+885g2bRqvvfYakLV2aKtPh5NOOoltt92W73znO9xwww3861//YquttuKrX/0qEydOrNgBZUdMnDiRm266idmzZzN9+nR69OjBsGHDmDhxIqeffnpTIkiSJEmS1meRUmtdL6xjxRH/BG5JKZ1QNvwK4NCU0pB2pk/AUmBjYC3wEHBuSune9uY9ZsyYNHv27HZjnDdvXpc9py+9XbjdS+uJWie63+GJdEmStP6KiDkppTGVxtXy7RiDgGUVhi8Fqrltex1wErAPcDywGTAjIuorFY6I4yNidkTMXrx4ceciliRJkiRJNVPTt2Osi5TSUSUf742IW4C5wIXA7hXKXwlcCVlLiEKClCRJkiRJVatlS4hlVG7x0FoLiTallF4Bbgd2Wse4JEmSJElSN6hlEuIJ4AMVho8CnlyHem3lIEmSJEnS21AtkxC3AjtHxIjGARExHNgtH9chETEA+BTwxy6KT5IkSZIkFaiWSYirgAXALRFxUEQcCNwCPAdMaSwUEVtHxJqI+GbJsP8bEVdFxOERUR8RRwP3A1sAZ9cwZkmSJEmSVCM165gypfRaRIwDLgN+BgRwD3B6SunVkqIB9KR5QuQp4OD8b1NgBVkS4tiUki0hJEmSJEl6G6rp2zFSSguBQ9ops4AsEVE67LfAb2sXmSRJkiRJKlotH8eQJEmSJElqYhJCkiRJkiQVwiSEJEmSJEkqhEkISZIkSZJUCJMQkiRJkiSpEDV9O8bb3aSGSd0dQpsm1U/q7hDW2Zo1a+jduzd7770306dPX6e6dt99dx566CHWrFnTRdFJkiRJkrqSLSE2cHPmzCEi+PjHP15x/C9+8Qsigohg/vz5Lca//vrr9OvXj/79+7Ny5cpah9ul1qxZQ0Swzz77dHcokiRJkrRBMAmxgRs9ejR1dXXMmTOHFStWtBh/zz33EBEAzJgxo8X4+++/n5UrV7L77rvTt2/fDs+/V69ezJs3j6lTp3Y8eEmSJEnS24pJiA1cjx49qK+vZ+3atcyaNavF+BkzZlBfX89mm21WMQnROGzvvffudAwjR45kq6226vT0kiRJkqS3B5MQakoglCcZFixYwPz589l7773Za6+9mDlzZotpW0tCXH/99dTX1zNw4ED69evHqFGjuPjii1m1alWzcm09EvGPf/yDo48+miFDhvCud72L0aNHc9111zF9+nQiggsvvLDi8qxevZoLL7yQbbfdlr59+zJs2DDOOussVq9e3VTm6quvpnfv3sBbrT0a/0rrvfnmmxk3bhxbbLEFffv2Zcstt6S+vp4f//jHra5PSZIkSVJldkwpxo0bB2Q/xks1fh43bhybbropN954I08++SSjRo0CYMWKFcyePZu6ujp23HHHpumOPvporr32WoYNG8bnPvc5Nt10Ux544AHOPvtsZsyYwe9//3t69uzZZkz//Oc/2WWXXVi4cCH19fXsvPPOLFq0iOOPP5599923zWnHjx/Pgw8+yH777ccmm2zC7bffzre+9S2WLFnCVVddBcCOO+7IOeecwwUXXMA222zDF7/4xabp99xzTwCuuOIKvvKVrzB06FAOPPBABg8ezIsvvsijjz7KNddcw4knnljN6pUkSZIk5UxCiO23356hQ4cyd+5cFi9ezJAhQ4CslcPGG2/MTjvtxIABA5qGNSYhZs2axdq1a6mvr6dHj6xRzdVXX821117LoYceyrXXXku/fv2a5nPOOedw4YUX8uMf/5ivfOUrbcZ05plnsnDhQiZOnMhFF13UNPzUU09l5513bnW6tWvX8txzz/HEE09QV1cHwEUXXcSHPvQhpk6dysUXX8yQIUPYcccd+dCHPsQFF1zAiBEjmDRpUou6pkyZQr9+/XjssccYPHhws3FLlixpM35JkiRJUks+jiEge5wipdTskYuZM2eyxx570KtXLz7wgQ+w+eabN3tko9KjGN/73vfo06cPV199dbMEBMC5557LwIEDuf7669uM5Y033uBXv/oVdXV1TJw4sdm4HXfckSOOOKLN6SdPntyUgADYeOON+cIXvsDatWuZM2dOm9OW6927d9NjG6XKkxKSJEmSpPbZEkJA9sjFddddx4wZM/j85z/PvHnzWLRoEWeccUZTmfr6eu6++27efPNNevTo0SIJ8corrzB37lze/e53893vfrfifPr168e8efPajGXevHmsXLmSXXfdlY022qjF+N13351p06a1Ov2YMWNaDGvs+HLZsmVtzrvUEUccwZlnnsmoUaM47LDD2Guvvdhtt91MQEiSJElSJ5mEEPBWIqGxH4jS/iAa1dfX8+tf/5qHH36YYcOG8fjjj7PlllsycuRIAJYuXQrACy+8wHnnndfqvHr1anuze/nllwF497vfXXF8a8MBevbsycYbb9zqPNeuXdvmvEt97WtfY/PNN+dHP/oRl19+OZdddhkRwdixY/n2t7/drB8MSZIkSVL7fBxDAAwbNox/+7d/45lnnuG5555jxowZDBw4kNGjRzeVGTt2LJA9hjFz5kxSSs0exdh0000B2GmnnUgptfpX+paKShr7n3jhhRcqjm9teC1MmDCB//mf/2Hp0qXcdtttHHPMMcycOZN9992Xl156qbA4JEmSJOmdwCSEmjQmFKZPn05DQwN77bVXU4eTACNHjmSLLbZgxowZFfuDGDhwINtttx2PP/44y5cv73Qco0aNom/fvjzyyCO89tprLcbfd999na67VOOyVdM6YuDAgRxwwAH85Cc/4aijjmLJkiVdFockSZIkbShMQqhJ46MXl112GcuWLWtq+VBq7Nix3Hvvvdx1111A8yQEwH/8x3/wxhtvcOyxxzY9VlFq6dKlPPzww23G0a9fPw499FCWLVvGxRdf3Gzcww8/3G7HltXq0aMHdXV1LFy4sOL4xtYepVJKvPjiiwD079+/S+KQJEmSpA2FfUKoybhx44gIHn/88abP5caOHcsvfvEL5s+fz3bbbceWW27ZbPzxxx/PnDlzuPLKK5k1axaf+MQnGDZsGEuXLuVvf/sb9957L8cddxw/+MEP2oxl8uTJNDQ0cPHFF/PAAw+wyy67sGjRIn71q19xwAEHcPPNNzdrpdFZe++9N7/5zW846KCDGD16NL169aK+vp7dd9+dT3/609TV1bHzzjszfPhw1q5dy7333svs2bP52Mc+VjFJI0mSJElqnUmINkyqn9TdIRRqyJAhfPCDH+Sxxx5j8ODB7LDDDi3KlP7wLm8F0WjKlCkccMABTJkyhbvvvpvly5ez2WabsfXWW/O1r32NI488st1Yhg4dyoMPPsjEiRO54447eOihhxg5ciRTpkyhd+/e3HzzzU19R6yL73//+/Tq1Yt77rmH2267jTfffJMLLriA3XffncmTJ3PXXXcxZ84cbr/9dvr168fw4cOZPHkyX/7yl9vtYFOSJEmS1FyUNzd/JxgzZkyaPXt2u+XmzZvH9ttvX0BE6kpnnnkmkydPZvr06a0mQtQ6t3tpPTFp0tu7fkmSpFZExJyU0phK4+wTQuutf/zjHy2GPfroo/zwhz9k8ODB7L777t0QlSRJkiSps2xPrvXWRz7yEbbffnt22GEH+vfvz9NPP80dd9zBm2++yU9+8hP69u3b3SFKkiRJkjrAJITWWyeeeCK33norP//5z3n11VcZOHAg++23H1/96lfZc889uzs8SZIkSVIHmYTQeuv888/n/PPP7+4wJEmSJEldxD4hJEmSJElSIUxCSJIkSZKkQmzwSYh34itKpda4vUuSJEnqTht0EqJnz56sXr26u8OQCrN69Wp69uzZ3WFIkiRJ2kBt0EmITTbZhBUrVnR3GFJhVqxYwSabbNLdYUiSJEnaQG3QSYhBgwaxbNkylixZwqpVq2yqrneklBKrVq1iyZIlLFu2jEGDBnV3SJIkSZI2UBv0Kzr79u3LsGHDWLp0KQsWLGDt2rXdHZJUEz179mSTTTZh2LBh9O3bt7vDkSRJkrSB2qCTEJAlIoYOHcrQoUO7OxRJkiRJkt7RNujHMSRJkiRJUnFMQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqhEkISZIkSZJUCJMQkiRJkiSpECYhJEmSJElSIUxCSJIkSZKkQpiEkCRJkiRJhTAJIUmSJEmSCmESQpIkSZIkFcIkhCRJkiRJKoRJCEmSJEmSVAiTEJIkSZIkqRA1TUJExFYR8ZuIeDkiVkTEjRExrBP1fD0iUkTcV4s4JUmSJElS7dUsCRER/YEZwEjgaOAo4H3AzIjYqAP1jAC+AbxYizglSZIkSVIxetWw7uOAEcB2KaVnACLiMeAvwAnAd6us50fA9cB21DZeSZIkSZJUQ7V8HONA4KHGBARASmk+cD9wUDUVRMThwI7AWTWJUJIkSZIkFaaWSYgPAHMrDH8CGNXexBFRB1wGfC2ltLSLY5MkSZIkSQWrZRJiELCswvClQF0V038beBqYVs3MIuL4iJgdEbMXL15cdZCSJEmSJKkY6+UrOiNiD+CLwJdTSqmaaVJKV6aUxqSUxgwZMqS2AUqSJEmSpA6rZUePy6jc4qG1FhKlpgA/AZ6PiIH5sF5Az/zz6ymllV0WqSRJkiRJqrlaJiGeIOsXotwo4Ml2pt0+/zuxwrhlwBnA5esUnSRJkiRJKlQtkxC3At+JiBEppb8BRMRwYDfg6+1MO7bCsMuBnsApwDMVxkuSJEmSpPVYLZMQVwEnA7dExDeABFwAPEf2uAUAEbE18Ffg/JTS+QAppYbyyiJiOdCr0jhJkiRJkrT+q1nHlCml14BxZG+4+BlwPTAfGJdSerWkaJC1cFgvO8mUJEmSJEldo5YtIUgpLQQOaafMArJERHt11XdNVJIkSZIkqTvY+kCSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqhEkISZIkSZJUCJMQkiRJkiSpECYhJEmSJElSIUxCSJIkSZKkQpiEkCRJkiRJhTAJIUmSJEmSCmESQpIkSZIkFcIkhCRJkiRJKoRJCEmSJEmSVAiTEJIkSZIkqRAmISRJkiRJUiFMQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqhEkISZIkSZJUCJMQkiRJkiSpECYhJEmSJElSIUxCSJIkSZKkQpiEkCRJkiRJhTAJIUmSJEmSCmESQpIkSZIkFcIkhCRJkiRJKoRJCEmSJEmSVAiTEJIkSZIkqRAmISRJkiRJUiFMQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqRE2TEBGxVUT8JiJejogVEXFjRAyrYrqtI+KWiHg2Il6PiCURMSsiPlnLeCVJkiRJUu3ULAkREf2BGcBI4GjgKOB9wMyI2KidyTcGlgDfAD4JHAu8AtweEZ+tVcySJEmSJKl2etWw7uOAEcB2KaVnACLiMeAvwAnAd1ubMKX0BFnioUlE3A7MB44BbqxRzJIkSZIkqUZq+TjGgcBDjQkIgJTSfOB+4KCOVpZSWgO8DKzpsgglSZIkSVJhapmE+AAwt8LwJ4BR1VQQET0ioldEbBER3wTeD/ygC2OUJEmSJEkFqeXjGIOAZRWGLwXqqqxjMvCf+f9fBcanlO6pVDAijgeOBxg2rN2+LyVJkiRJUsHW91d0Xg7sBHwa+B3w84j4VKWCKaUrU0pjUkpjhgwZUmSMkiRJkiSpCrVsCbGMyi0eWmsh0UJK6Xng+fzjbRHRAHwHuK0rApQkSZIkScWpZUuIJ8j6hSg3Cniyk3XOBrbtdESSJEmSJKnb1DIJcSuwc0SMaBwQEcOB3fJxHRIRPYDdgb92UXySJEmSJKlAtXwc4yrgZOCWiPgGkIALgOeAKY2FImJrssTC+Sml8/Nhk8ge27gf+CewBXAs8DHg8BrGLEmSJEmSaqRmSYiU0msRMQ64DPgZEMA9wOkppVdLigbQk+atMv4EnA6MBzYlS0Q8CuyRUrq/VjFLkiRJkqTaqWVLCFJKC4FD2imzgCwRUTrsVjrxyIYkSZIkSVp/re+v6JQkSZIkSe8QJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqhEkISZIkSZJUCJMQkiRJkiSpECYhJEmSJElSIUxCSJIkSZKkQpiEkCRJkiRJhTAJIUmSJEmSCmESQpIkSZIkFcIkhCRJkiRJKoRJCEmSJEmSVAiTEJIkSZIkqRAmISRJkiRJUiFMQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVold3ByCtFyZNenvXL0mSJElvA7aEkCRJkiRJhTAJIUmSJEmSCmESQpIkSZIkFcIkhCRJkiRJKoRJCEmSJEmSVAiTEJIkSZIkqRAmISRJkiRJUiFMQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqhEkISZIkSZJUCJMQkiRJkiSpECYhJEmSJElSIUxCSJIkSZKkQpiEkCRJkiRJhTAJIUmSJEmSClHTJEREbBURv4mIlyNiRUTcGBHDqphuTERcGRF/joh/RcTCiLg+IrapZbySJEmSJKl2apaEiIj+wAxgJHA0cBTwPmBmRGzUzuTjgQ8A/w/YH/g6sCMwOyK2qlXMkiRJkiSpdnrVsO7jgBHAdimlZwAi4jHgL8AJwHfbmPaSlNLi0gERcT8wP6/3mzWJWJIkSZIk1UwtH8c4EHioMQEBkFKaD9wPHNTWhOUJiHzYs8BiYMsujlOSJEmSJBWglkmIDwBzKwx/AhjV0coiYntgc2DeOsYlSZIkSZK6QS2TEIOAZRWGLwXqOlJRRPQCfkzWEuInrZQ5PiJmR8TsxYtbNKSQJEmSJEnd7O3yis4fALsCR6aUKiU2SCldmVIak1IaM2TIkGKjkyRJkiRJ7aplx5TLqNziobUWEhVFxLeA44GjU0p3dVFskiRJkiSpYLVMQjxB1i9EuVHAk9VUEBFnA2cCp6SUftaFsUmSJEmSpILV8nGMW4GdI2JE44CIGA7slo9rU0ScClwInJ1S+kGNYpQkSZIkSQWpZRLiKmABcEtEHBQRBwK3AM8BUxoLRcTWEbEmIr5ZMmw8cDlwJzAjInYu+evwmzUkSZIkSVL3q9njGCml1yJiHHAZ8DMggHuA01NKr5YUDaAnzRMi++XD98v/Ss0C6msUtiRJkiRJqpFa9glBSmkhcEg7ZRaQJRxKh00AJtQqLkmSJEmSVLy3yys6JUmSJEnS25xJCEmSJEmSVAiTEJIkSZIkqRAmISRJkiRJUiFMQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqhEkISZIkSZJUCJMQkiRJkiSpECYhJEmSJElSIUxCSJIkSZKkQpiEkCRJkiRJhTAJIUmSJEmSCmESQpIkSZIkFcIkhCRJkiRJKoRJCEmSJEmSVAiTEJIkSZIkqRAmISRJkiRJUiFMQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhTEJIkiRJkqRCmISQJEmSJEmFMAkhSZIkSZIKYRJCkiRJkiQVwiSEJEmSJEkqRK/uDkCSamlSw6Ta1l9f2/olSZKkdxJbQkiSJEmSpEKYhJAkSZIkSYUwCSFJkiRJkgphnxBSAeyXQJIkSZJsCSFJkiRJkgpiEkKSJEmSJBXCJIQkSZIkSSqESQhJkiRJklQIkxCSJEmSJKkQJiEkSZIkSVIhfEWnJEmSpHXmK8klVcOWEJIkSZIkqRAmISRJkiRJUiF8HEOS9P/bu/toS6v6PuDfHw5qtCqgo6YqCOIykVJdzSQl1erEsCKmEUx8S6P4ttSkNa7YxJhYLblRjElUbFOX70a6QtWIkkCsMSg6KkZT0UbDWCsYBlFRR0EMyKvs/vGcK5fDHebOzH32uczz+ax11uE8b3ufH2fOPed79rMf9kOGRQMAG5GREAAAAEAXQggAAACgi1FDiKq6X1W9p6quqKrvVdUZVXXoGvf9g6o6u6q+U1Wtqp4xZl8BAACAcY0WQlTVnZJ8OMmPJXl6khOTPDDJR6rqzms4xPOT/EiS943VRwAAAKCfMSemfE6SI5I8qLV2YZJU1eeTXJDkV5Ocspv979Zau7GqjkzytBH7CQAAAHQw5ukYxyf51HIAkSSttYuSfCLJCbvbubV244h9AwAAADobcyTEUUnOXGX59iRPHLFdAAAA6MJlsffMmCMhDkly+SrLL0ty8Ho3VlXPrarzquq8nTt3rvfhAQAAgH2031yis7X25tbaltbals2bNy+6OwAAAMCcMUOIy7P6iIddjZAAAAAA9mNjhhDbM8wLMe/BSb4wYrsAAADABjRmCHFWkmOq6ojlBVV1/yQPm60DAAAAJmTMEOItSXYkObOqTqiq4zNcLeOSJG9a3qiqDquqG6rqpJU7V9Ujq+oJSY6bLdpSVU+YLQMAAABuY0a7RGdr7aqqelSS1yb5sySV5JwkL2itXbli00pyu9wyEPn9JI9c8fh5s9vyPgAAAMBtyGghRJK01r6S5PG72WZHVgkVWmtbx+kVAAAAsAj7zSU6AQAAgI1NCAEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF0IIAAAAoAshBAAAANCFEAIAAADoQggBAAAAdCGEAAAAALrYtOgO0MfStqVxj7913OMDAABw22ckBAAAANCFEAIAAADoQggBAAAAdCGEAAAAALoQQgAAAABdCCEAAACAY3eIXgAAFK1JREFULoQQAAAAQBdCCAAAAKALIQQAAADQhRACAAAA6EIIAQAAAHQhhAAAAAC6EEIAAAAAXQghAAAAgC6EEAAAAEAXQggAAACgCyEEAAAA0IUQAgAAAOhCCAEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF0IIAAAAoAshBAAAANCFEAIAAADoQggBAAAAdCGEAAAAALoQQgAAAABdCCEAAACALoQQAAAAQBdCCAAAAKCLTYvuADBxS0vjHn/ruIcHAADWzkgIAAAAoAshBAAAANCF0zE2CkPSAQAA2M8ZCQEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF0IIAAAAoAuX6AQAgKkY87LwW8c7NLD/MBICAAAA6EIIAQAAAHQxaghRVferqvdU1RVV9b2qOqOqDl3jvnesqldV1aVVdXVVfbKqHjFmfwEAAIDxjBZCVNWdknw4yY8leXqSE5M8MMlHqurOazjE25I8J8lJSX4hyaVJ/qaqHjpOjwEAAIAxjTkx5XOSHJHkQa21C5Okqj6f5IIkv5rklF3tWFUPSfIrSZ7VWnv7bNlHk2xP8rIkx4/YbwAAAGAEY56OcXySTy0HEEnSWrsoySeSnLCGfa9P8ucr9r0hybuSPLqq7rD+3QUAAADGNGYIcVSS81dZvj3Jg9ew70Wtte+vsu/tkxy5790DAAAAeqrW2jgHrrouySmttd+dW35ykt9tre3yVJCqOjvJXVtrx8wtPzbJB5M8orX28bl1z03y3CQ59NBDf+Liiy9enycCsD8b83rxSZa2jnnspfEODvtgadvSuMe/rb/2b8PvO8Pxl8ZtgP2X1z4TUlWfaa1tWW3dfnOJztbam1trW1prWzZv3rzo7gAAAABzxgwhLk9y8CrLD5mt29t9k+SyfegXAAAAsABjhhDbM8ztMO/BSb6whn0Pn13mc37f65JceMtdAAAAgI1szBDirCTHVNURywuq6v5JHjZbd2v+KsmBSZ64Yt9NSZ6c5OzW2rXr3VkAAABgXGOGEG9JsiPJmVV1QlUdn+TMJJckedPyRlV1WFXdUFUnLS9rrf2fDJfn/K9V9eyq+tkMl+c8PMnvjdhnAAAAYCS7vELFvmqtXVVVj0ry2iR/lqSSnJPkBa21K1dsWklul1sGIs9M8ookJyc5KMnnkhzXWvvsWH0GAGBkI18hICNfnQSAfTNaCJEkrbWvJHn8brbZkSGImF9+dZLfnN0AAACA27j95hKdAAAAwMYmhAAAAAC6EEIAAAAAXQghAAAAgC6EEAAAAEAXQggAAACgCyEEAAAA0IUQAgAAAOhCCAEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF0IIAAAAoAshBAAAANCFEAIAAADoQggBAAAAdCGEAAAAALoQQgAAAABdCCEAAACALoQQAAAAQBdCCAAAAKALIQQAAADQhRACAAAA6EIIAQAAAHQhhAAAAAC6EEIAAAAAXQghAAAAgC6EEAAAAEAXQggAAACgCyEEAAAA0IUQAgAAAOhi06I7AACwP1naurToLgDAhmUkBAAAANCFEAIAAADowukYAFO2tDTu8beNfHwAAG5TjIQAAAAAuhBCAAAAAF04HQOA0bhKAAAAKxkJAQAAAHQhhAAAAAC6EEIAAAAAXQghAAAAgC6EEAAAAEAXQggAAACgCyEEAAAA0IUQAgAAAOhCCAEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF0IIAAAAoAshBAAAANCFEAIAAADoQggBAAAAdCGEAAAAALrYtOgOAADAelnaurToLgBwK0YbCVFVB1TVi6tqR1VdU1Wfq6rHr3Hfx1bVO6rqS1V1Y1VtG6ufAAAAQB9jno7x8iRLSV6X5DFJPpXk9Kr6+TXs+7gkD53t89WxOggAAAD0M8rpGFV1zyQvTPKHrbVXzxZ/pKqOTPKHSd6/m0M8p7V24+xY547RRwAAAKCvsUZCPDrJ7ZOcNrf8tCRHV9Xht7bzcgABAAAA7D/GCiGOSnJtkgvnlm+f3T94pHYBAACADWqsEOKQJN9trbW55ZetWL+uquq5VXVeVZ23c+fO9T48AAAAsI/WFEJU1bFV1dZw2zZyf3eptfbm1tqW1tqWzZs3L6obAAAAwC6sdWLKv03y42vY7vuz+8uTHFRVNTcaYnkExGUBAAAAJmVNIURr7ftJvrgHx92e5A5JHpCbzwuxPBfEF/bgWAAAAMB+YKw5IT6Q5PokT5lb/tQk57fWLhqpXQAAAGCDWuvpGHuktfatqjolyYur6p+SfDbJk5M8KsnxK7etqnOSHNZaO3LFssOS/OTs4d2T3FhVT5g9/nRr7eIx+g0AAACMZ5QQYuYlSa5M8htJ7p3k/yV5UmvtfXPb3W6VfvxMkrfPLTt9dv/MJKeua08BAACA0Y0WQrTWfpDk5Nnt1rbbusqyUyNoAAAAgP3KmCMhAAAASJKlpXGPv23k48M6GWtiSgAAAICbEUIAAAAAXQghAAAAgC6EEAAAAEAXQggAAACgCyEEAAAA0IUQAgAAAOhCCAEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF5sW3QEAAAD2zdLWpUV3AdbESAgAAACgCyEEAAAA0IUQAgAAAOhCCAEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF0IIAAAAoAshBAAAANCFEAIAAADoQggBAAAAdCGEAAAAALoQQgAAAABdCCEAAACALoQQAAAAQBdCCAAAAKALIQQAAADQhRACAAAA6EIIAQAAAHQhhAAAAAC6EEIAAAAAXVRrbdF9WHdVtTPJxYvux23cPZJ8e9GdmDD1Xxy1Xyz1Xxy1Xxy1Xyz1Xxy1Xyz1X5wp1P6w1trm1VbslyEE+66qzmutbVl0P6ZK/RdH7RdL/RdH7RdH7RdL/RdH7RdL/Rdn6rV3OgYAAADQhRACAAAA6EIIwa68edEdmDj1Xxy1Xyz1Xxy1Xxy1Xyz1Xxy1Xyz1X5xJ196cEAAAAEAXRkIAAAAAXQghAAAAgC6EEBtEVT2jqlpVfbeqDp5bt2m2bmlB3euiqg6uqrdW1ber6qqq+lBVHd2h3UnXvqruUlWvrqptVfW92fPd2rH9qdf/Z6vqtKr6clVdPbt/Q1Xds0PbU6/9T1TVB6rqa1V1TVV9o6reX1U/3an9Sdd/XlW9cfacT+vQ1qRrX1X3nz3H1W4HdWh/0vVfVlXHzN6Dvjv73PMPVfXLI7c56dpX1am38tr/Yof2J13/JKmqo6rqjKr6+ux1v72qXlhVm0ZuV+2rHjp7z7ly9pn/rKo6chF9EUJsPHdL8juL7kRvVVVJ/irJcUmen+TxSQ5M8pGqum+nbkyy9knunuRZSW5I8sEF9mOq9f+1DP8PTs7w+n9lkuOTfKqq/lmnPky19gcluTDJbyV5dIb3noOSfLSqfqpjP6Za/x+qqocleWqS73Vueuq1f2WSn567/VPH9idb/6r6d0k+luQbSX4lyQlJ3pLkjp26MNXavzy3fM3/+9m6szr2Y5L1r6p/nmRbkiOSvCDJY5P8ZZI/TvKKTt2Yau0fmOTjGZ7/U5I8M8n9k3ysxw9f84QQG8/ZSZ5fVfdadEeq6g4dmzs+ycOSnNhae2dr7QOzZQckeVGnPky19he31g5prR2b5A0d25031fr/x9baY1prb2+tfbS19tYMH4gOT/KkTn2YZO1ba+e01n69tfauWe1PzxBGtCQn9upHJlr/FW0emORNGT6AXt65+UnXPsk/ttY+NXf7Qcf2J1n/qrpLkrcneX1r7Rmttfe31j7UWvuT1tqpnboxydq31r48/5pP8sDZ6v/Rqx+ZaP2T/EKSeyR5Umvt3a21D7fWXpLk3Ume1qkPU6397yT5QZLHtNbObK29N8nPJzkkyQs79iOJEGIjOnl2/9LdbVhVh1fV/6yqnVV1bVX9fVX94tw2p1bVjlX23VZV21Y83jobhvRLVfWWqtqZ5Jsr1h9XVZ+sYbj4FVX1l1X1oFWOeW5VHVtVn62q71fV+fN92oXjk3y9tfaR5QWttSsyjI44YQ37r4dJ1r5tnEvkTLX+O1dZ/OnZ/X12t/86mWTtd+GqJNdmGBnUy9Tr/9tJbpfk1Xuwz3qZeu0Xbar1f2KSzUles4ZtxzLV2q/maUk+01rbvpf7742p1v/2s/v5UW/fTb/vpVOt/TFJPtla++7ygtbaV5Ocn6T73w0hxMZzaZLXJXluVR22q42q6n5J/i7JQ5L8pwxf4j+b5L1Vdfw+tP/fk1SGXwGfMWvruCT/K8mVSZ6c5D8k+RdJzq2q+S9JD0jy35KckuSXZs/n9Nr9+UZHZfhHMG97kkOrz7D0qdZ+o1D/mzxydv9/92LfvTHp2lfVAVV1YFUdmqEOyTAsupfJ1n+2zUszjAi6fh+ew96abO1nXllVN8w+8J5VHeZhmjPV+j88yWVJjq5hHogbquqSqvq9qrrdPjyfPTHV2t9MDaeCHZm+oyCS6db/9CTfTvK62Rf8u86+QJ+YfqHcVGv/gyTXrbL82iQPqKpep4INWmtuG+CW4UXYMrwRHpIhEfzT2bpNs3VLK7Z/W5KdSe4+d5wPJvn7FY9PTbJjlfa2Jdm24vHWWRt/scq25yW5IMmmFcsOT3J9klPmjnl9kgeuWHbPDC/6/7yb5/+lJO9aZfmzZ/26n9qPU/u59o6d9WWr137/+s/2u0uSLyb5wsp21X682id5z6wfLcOvEg/32u9T/1nfT1vxeMfKx2o/Tu2T/GiSN2b4APtvkzwnyUUZ5oP4cfUfvf4fSHL17Hn/1qw/J2cYgfVate/6N/dNGb6Y3WPs1736/3DbIzP8yLj8d/fGJCep/ejvO+9O8tUkB65YdpdZHVqSH+3xb2D5ZiTEBtRauyxDGvi0+WE4KxyX5P1JrqhhRtdNNcwq+zdJHlJVd93L5v9i5YOqunOSf5Xkz1trPxye3Fq7KMknctMvtssuaK1dsGK7byX5VpJD97I/Xan9Yk29/rPn8c4Mp2H88sp2xzbx2r8oyU9lmBD3/CTvq6ote/ok9sUU619VT03ykxm+hC3MFGvfWru0tfZrrbUzWmsfb629JckjMnwQfclePpe9MsX6ZxiJfMckL2utvaa1tq219tIMI7CeV1V328vns0cmWvuVbd4xw9xL72utfXuPn8E+mmL9q2pzkjMynPr4hCQ/kyGAe2lVdZsscoq1T/InGT5fvrGq7jMbBfL2JMujzW/ci+ey14QQG9drMwzVe9ku1t8zwzls18/dXjVbf/e9bPfSuccHZxgyNL88GWZ0PmRu2WWrbHdtdj/b8+WztuYdsmJ9L1Or/UYzyfpX1QEZhoMem+RxrbXPr2W/dTbJ2rfW/rG19unW2hlJHpPhj/nJu9ltDJOpfw2n2J2S5I+SXFtVB9VwacgDkhw4e3zgGvu/HiZT+11prV2S5NwMwVBvU6v/d2b381ekOjvDlcGO2s3+62lqtV/p+AxXROp9KsZKU6v/izJckeHRrbX3zgK4kzI8n5dX1T121/F1NKnat9bOTfK8DOHPVzOMPLxbhtf/dbs47mhGvR4re6+1dmVVvTJDSveqVTb5TobLrPzRLg7x9dn9NblpEpiV7p6b/gjerOm5x5fPlt17lW3vnfV7wW5P8nOrLH9wkq+01q5cp3Z2a4K131AmXP83ZjgP8AmttXPW+dhrMuHa39SR1q6rqs8neehYbdxK21Oq/z0yTMz3B7PbSvfL8OvkL2a4dNvoJlb73Znv0/gNTq/+u5sAsdsvkhOs/UpPzzA/wftHOPaaTLD+Rye5sLU2/+Pi/84QwB2Z4f/J6CZY+7TWXl9Vb8tQ5++11i6pqr9O8net87xMRkJsbK9P8rWs/ovcB5L8yyTbW2vnrXK7drbdxUnuNRv+lCSpqgck2dXQo5tprV2V5DNJnrhysqTZEJ5/k+HcpPVwVpL7VNUPhxzNhjk9Nn2v27xsSrXfiCZV/6p6TYb5T57ZWuvypetWTKr286rqTkm2JPnyWG3sxlTq/40Mw3Dnb99M8qHZf5+7Du3sianUflU1TMz68AxfBhZhSvVffp9/9Nzy4zJ8oVltou4xTan2y8e9V4b6v6P3l69VTKn+30hyZFXNj37+17P7r61TO2s1pdovt3dta237LIA4OsMI3DesZxtrYSTEBtZau7aqXpbkzausPinDB4WPVdXrMgypOTjDTKpHtNaeNdvu9CQvT3JaVZ2S4denF2fPUsb/kmHG1vdV1esznDv0+0muyPrNZHtWkk/O+vnbGVLBF2cYnvTH69TGmk2s9qmqxyS5c4aEOkkeORsSd1Vr7a/Xq521mlL9Z+dA/maSP01yQVUds2L1ztZa1y/DE6v9mzL8wnDerG+HJfn1DJP2nbgebeypqdS/tXZNVvlgVVXXJPlma+0W68Y2ldonPww+D8jwd3dnhg/LL87wC/wr1qONPTWl+rfWzq+qU5O8bHYq3mczfBF4dpKX9xz9OevPZGq/wlMyXBp4kadiJJlc/d+YofZnV9WrMowU2JrkhRkmbLxkndpZkynVvqrum+GqG3+b4fSNLbN+ntFae+d6tLFHWsdZMN1udcbSZ2Q2Y+vc8k0ZrhxxsxlbZ+vum+StGRK86zKcS/TBJE+d2+5xGVL1q5N8LsNpD9uy+oytx+6if8dl+LBydYZ/EGcmedDcNtuSnLvKvjuSnLqGGhyS4YvYZUm+n+ScJA9R+y6135GbZileeduh/uPWf7bvarVva/l/p/b7VPtnZfhj/J0Mvz5+Ock7khw99ute/XdZkx3pfHWMKdZ+9tr/dIbA//oMv06+Y74N9R/17+7tM/z6esns+XwpyW+ofZ/3nVn//qHH6139b7HdMRlOgbk0wwSV2zNcqvlH1H7U9/17ZRhp+O0MIcQXMkwMPeqV2HZ1q1mnAAAAAEZlTggAAACgCyEEAAAA0IUQAgAAAOhCCAEAAAB0IYQAAAAAuhBCAAAAAF0IIQAAAIAuhBAAAABAF/8f8AXY2HZUa1sAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -646,7 +639,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.9.13 ('venv')", "language": "python", "name": "python3" }, @@ -660,7 +653,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.9.13" + }, + "vscode": { + "interpreter": { + "hash": "4311c7dda575c081001492aac26d536ae97e4c13a1d6ad5cc980ffae203d70d8" + } } }, "nbformat": 4, From 656528041b60d6daa06f07f77b9621a4055c7142 Mon Sep 17 00:00:00 2001 From: Fulton Wang Date: Tue, 23 Aug 2022 12:45:39 -0700 Subject: [PATCH 120/174] change tracin progress test (#1007) Summary: Pull Request resolved: https://github.com/pytorch/captum/pull/1007 the tests for `test_tracin_show_progress` were failing we check that the progress reaches 100% X times, but sometimes, the progress reaches 100% more than X times. As aobo-y pointed out, this is because tqdm will sometimes correct its estimate of it/s for the total iteration over progress, and print 100% an additional time, with the updated estimate of it/s. The fix is to check that progress reaches 100% at least X times. We don't check that it reaches 100% either X or X+1 times, because all we can reasonably assume of tqdm is that it may re-estimate it/s >= 0 times. Note that this change is to correct a problem with tqdm, *not* `SimpleProgress`. Reviewed By: NarineK Differential Revision: D38443861 fbshipit-source-id: 3d6b8588380014e4e6e4cf8e0dfd5464c50ce7be --- .../_core/test_tracin_show_progress.py | 34 ++++++++++++++----- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/tests/influence/_core/test_tracin_show_progress.py b/tests/influence/_core/test_tracin_show_progress.py index e940e2ed66..429ac88972 100644 --- a/tests/influence/_core/test_tracin_show_progress.py +++ b/tests/influence/_core/test_tracin_show_progress.py @@ -29,17 +29,35 @@ class TestTracInShowProgress(BaseTest): in `TracInCPFastRandProj.__init__`). """ - def _check_error_msg_multiplicity(self, mock_stderr, msg, msg_multiplicity): + def _check_error_msg_multiplicity( + self, + mock_stderr: io.StringIO, + msg: str, + msg_multiplicity: int, + greater_than: bool = True, + ): """ - checks that in `mock_stderr`, the error msg `msg` occurs `msg_multiplicity` - times + Checks that in `mock_stderr`, the error msg `msg` occurs `msg_multiplicity` + times. If 'greater_than' is true, it checks that the `msg` occurs at least + `msg_multiplicity` times. Otherwise, it checks that `msg` occurs exactly + `msg_multiplicity` times. The reason to let `greater_than` as true by default + is that tqdm sometimes displays the "100%" more than once for each progress bar + because it may want to correct its estimation of it/s. In this case, the + tqdm could remove the original "100%" and then re-display "100%" with the + updated estimate of it/s. """ output = mock_stderr.getvalue() - self.assertEqual( - output.count(msg), - msg_multiplicity, - f"Error in progress of batches with output: {repr(output)}", - ) + actual_msg_multiplicity = output.count(msg) + assert isinstance(actual_msg_multiplicity, int) + error_msg = f"Error in progress of batches with output: {repr(output)}" + if greater_than: + self.assertTrue(actual_msg_multiplicity - msg_multiplicity >= 0, error_msg) + else: + self.assertEqual( + actual_msg_multiplicity, + msg_multiplicity, + error_msg, + ) @parameterized.expand( [ From 12a847b942121589a5d7ee832ee168b9ffbcb0a3 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 26 Aug 2022 18:02:56 -0700 Subject: [PATCH 121/174] Added missing `-> None:` type hint to applicable tests (#1006) Summary: I noticed that some of the tests were missing the `-> None:` type hint. This PR adds the missing type hint. Pull Request resolved: https://github.com/pytorch/captum/pull/1006 Reviewed By: NarineK Differential Revision: D39063574 Pulled By: aobo-y fbshipit-source-id: 90478bb5782bc643e87441529100c8bbc0dc71c7 --- tests/attr/layer/test_layer_lrp.py | 16 +++++------ tests/attr/models/test_base.py | 6 ++--- tests/attr/models/test_pytext.py | 6 ++--- tests/attr/test_approximation_methods.py | 27 ++++++++++--------- tests/attr/test_class_summarizer.py | 4 +-- tests/attr/test_stat.py | 6 ++--- tests/attr/test_summarizer.py | 4 +-- tests/attr/test_utils_batching.py | 10 +++---- .../_core/test_similarity_influence.py | 2 +- tests/influence/_utils/common.py | 6 ++--- tests/insights/test_contribution.py | 6 ++--- tests/insights/test_features.py | 12 ++++----- tests/utils/test_av.py | 2 +- tests/utils/test_common.py | 10 +++---- tests/utils/test_linear_model.py | 10 +++---- 15 files changed, 64 insertions(+), 63 deletions(-) diff --git a/tests/attr/layer/test_layer_lrp.py b/tests/attr/layer/test_layer_lrp.py index 3fc8cd80ea..e4ad951ace 100644 --- a/tests/attr/layer/test_layer_lrp.py +++ b/tests/attr/layer/test_layer_lrp.py @@ -39,12 +39,12 @@ def forward(self, input): class Test(BaseTest): - def test_lrp_creator(self): + def test_lrp_creator(self) -> None: model, _ = _get_basic_config() model.conv1.rule = 1 self.assertRaises(TypeError, LayerLRP, model, model.conv1) - def test_lrp_creator_activation(self): + def test_lrp_creator_activation(self) -> None: model, inputs = _get_basic_config() model.add_module("sigmoid", nn.Sigmoid()) lrp = LayerLRP(model, model.conv1) @@ -77,7 +77,7 @@ def test_lrp_simple_attributions(self): assertTensorAlmostEqual(self, relevance_lower[0], relevance_upper[0]) self.assertEqual(delta.item(), 0) - def test_lrp_simple_repeat_attributions(self): + def test_lrp_simple_repeat_attributions(self) -> None: model, inputs = _get_simple_model() model.eval() model.linear.rule = GammaRule() @@ -88,7 +88,7 @@ def test_lrp_simple_repeat_attributions(self): output_after = model(inputs) assertTensorAlmostEqual(self, output, output_after) - def test_lrp_simple_tanh(self): + def test_lrp_simple_tanh(self) -> None: class Model(nn.Module): def __init__(self) -> None: super(Model, self).__init__() @@ -109,7 +109,7 @@ def forward(self, x): self, relevance[0], torch.Tensor([0.0537, 0.0537, 0.0537]) ) # Result if tanh is skipped for propagation - def test_lrp_simple_attributions_GammaRule(self): + def test_lrp_simple_attributions_GammaRule(self) -> None: model, inputs = _get_simple_model() with torch.no_grad(): model.linear.weight.data[0][0] = -2 @@ -120,7 +120,7 @@ def test_lrp_simple_attributions_GammaRule(self): relevance = lrp.attribute(inputs) assertTensorAlmostEqual(self, relevance[0], torch.tensor([24.0, 36.0, 36.0])) - def test_lrp_simple_attributions_AlphaBeta(self): + def test_lrp_simple_attributions_AlphaBeta(self) -> None: model, inputs = _get_simple_model() with torch.no_grad(): model.linear.weight.data[0][0] = -2 @@ -131,7 +131,7 @@ def test_lrp_simple_attributions_AlphaBeta(self): relevance = lrp.attribute(inputs) assertTensorAlmostEqual(self, relevance[0], torch.tensor([24.0, 36.0, 36.0])) - def test_lrp_simple_attributions_all_layers(self): + def test_lrp_simple_attributions_all_layers(self) -> None: model, inputs = _get_simple_model(inplace=False) model.eval() model.linear.rule = EpsilonRule() @@ -142,7 +142,7 @@ def test_lrp_simple_attributions_all_layers(self): self.assertEqual(len(relevance), 2) assertTensorAlmostEqual(self, relevance[0][0], torch.tensor([18.0, 36.0, 54.0])) - def test_lrp_simple_attributions_all_layers_delta(self): + def test_lrp_simple_attributions_all_layers_delta(self) -> None: model, inputs = _get_simple_model(inplace=False) model.eval() model.linear.rule = EpsilonRule() diff --git a/tests/attr/models/test_base.py b/tests/attr/models/test_base.py index 4ebee39ee2..b8ebbc7763 100644 --- a/tests/attr/models/test_base.py +++ b/tests/attr/models/test_base.py @@ -16,7 +16,7 @@ class Test(unittest.TestCase): - def test_interpretable_embedding_base(self): + def test_interpretable_embedding_base(self) -> None: input1 = torch.tensor([2, 5, 0, 1]) input2 = torch.tensor([3, 0, 0, 2]) model = BasicEmbeddingModel() @@ -59,7 +59,7 @@ def test_interpretable_embedding_base(self): remove_interpretable_embedding_layer(model, interpretable_embedding1) self.assertTrue(model.embedding1.__class__ is Embedding) - def test_custom_module(self): + def test_custom_module(self) -> None: input1 = torch.tensor([[3, 2, 0], [1, 2, 4]]) input2 = torch.tensor([[0, 1, 0], [1, 2, 3]]) model = BasicEmbeddingModel() @@ -81,7 +81,7 @@ def test_custom_module(self): self.assertTrue(model.embedding2.__class__ is TextModule) self._assert_embeddings_equal(input2, output, interpretable_embedding) - def test_nested_multi_embeddings(self): + def test_nested_multi_embeddings(self) -> None: input1 = torch.tensor([[3, 2, 0], [1, 2, 4]]) input2 = torch.tensor([[0, 1, 0], [2, 6, 8]]) input3 = torch.tensor([[4, 1, 0], [2, 2, 8]]) diff --git a/tests/attr/models/test_pytext.py b/tests/attr/models/test_pytext.py index 57f7752865..0f6fdf672b 100644 --- a/tests/attr/models/test_pytext.py +++ b/tests/attr/models/test_pytext.py @@ -52,7 +52,7 @@ def setUp(self): self.model = self._create_dummy_model() self.data_handler = self._create_dummy_data_handler() - def tearDown(self): + def tearDown(self) -> None: for f in ( self.embedding_file, self.word_embedding_file, @@ -68,7 +68,7 @@ def tearDown(self): ): os.remove(p) - def test_word_embeddings(self): + def test_word_embeddings(self) -> None: embedding_list = configure_model_integ_grads_embeddings(self.model) integrated_gradients_embedding = embedding_list[0] input = torch.arange(0, 300).unsqueeze(0).unsqueeze(0) @@ -81,7 +81,7 @@ def test_word_embeddings(self): ) ) - def test_baseline_generation(self): + def test_baseline_generation(self) -> None: baseline_generator = BaselineGenerator(self.model, self.data_handler, "cpu") embedding_list = configure_model_integ_grads_embeddings(self.model) integrated_gradients_embedding = embedding_list[0] diff --git a/tests/attr/test_approximation_methods.py b/tests/attr/test_approximation_methods.py index 54a517b596..f068d56304 100644 --- a/tests/attr/test_approximation_methods.py +++ b/tests/attr/test_approximation_methods.py @@ -1,6 +1,7 @@ #!/usr/bin/env python3 import unittest +from typing import List import torch from captum.attr._utils.approximation_methods import Riemann, riemann_builders @@ -8,16 +9,16 @@ class Test(unittest.TestCase): - def __init__(self, methodName="runTest") -> None: + def __init__(self, methodName: str = "runTest") -> None: super().__init__(methodName) - def test_riemann_0(self): + def test_riemann_0(self) -> None: with self.assertRaises(AssertionError): step_sizes, alphas = riemann_builders() step_sizes(0) alphas(0) - def test_riemann_2(self): + def test_riemann_2(self) -> None: expected_step_sizes_lrm = [0.5, 0.5] expected_step_sizes_trapezoid = [0.25, 0.25] expected_left = [0.0, 0.5] @@ -34,7 +35,7 @@ def test_riemann_2(self): expected_trapezoid, ) - def test_riemann_3(self): + def test_riemann_3(self) -> None: expected_step_sizes = [1 / 3] * 3 expected_step_sizes_trapezoid = [1 / 6, 1 / 3, 1 / 6] expected_left = [0.0, 1 / 3, 2 / 3] @@ -51,7 +52,7 @@ def test_riemann_3(self): expected_trapezoid, ) - def test_riemann_4(self): + def test_riemann_4(self) -> None: expected_step_sizes = [1 / 4] * 4 expected_step_sizes_trapezoid = [1 / 8, 1 / 4, 1 / 4, 1 / 8] expected_left = [0.0, 0.25, 0.5, 0.75] @@ -70,14 +71,14 @@ def test_riemann_4(self): def _assert_steps_and_alphas( self, - n, - expected_step_sizes, - expected_step_sizes_trapezoid, - expected_left, - expected_right, - expected_middle, - expected_trapezoid, - ): + n: int, + expected_step_sizes: List[float], + expected_step_sizes_trapezoid: List[float], + expected_left: List[float], + expected_right: List[float], + expected_middle: List[float], + expected_trapezoid: List[float], + ) -> None: step_sizes_left, alphas_left = riemann_builders(Riemann.left) step_sizes_right, alphas_right = riemann_builders(Riemann.right) step_sizes_middle, alphas_middle = riemann_builders(Riemann.middle) diff --git a/tests/attr/test_class_summarizer.py b/tests/attr/test_class_summarizer.py index 7009cca788..0d7517da2d 100644 --- a/tests/attr/test_class_summarizer.py +++ b/tests/attr/test_class_summarizer.py @@ -78,7 +78,7 @@ def create_batch_labels(batch_idx): ): self.class_test(data, classes, sizes) - def test_no_class(self): + def test_no_class(self) -> None: size = (30, 20) summarizer = ClassSummarizer(stats=CommonStats()) for _ in range(10): @@ -95,7 +95,7 @@ def test_no_class(self): self.assertIsInstance(summarizer.class_summaries, dict) self.assertEqual(len(summarizer.class_summaries), 0) - def test_single_label(self): + def test_single_label(self) -> None: size = (4, 3, 2, 1) data = torch.randn((100,) + size) diff --git a/tests/attr/test_stat.py b/tests/attr/test_stat.py index 9559b1b237..0489472972 100644 --- a/tests/attr/test_stat.py +++ b/tests/attr/test_stat.py @@ -15,7 +15,7 @@ def get_values(n=100, lo=None, hi=None, integers=False): class Test(BaseTest): - def test_div0(self): + def test_div0(self) -> None: summarizer = Summarizer([Var(), Mean()]) summ = summarizer.summary self.assertIsNone(summ) @@ -30,7 +30,7 @@ def test_div0(self): assertTensorAlmostEqual(self, summ["mean"], 10) assertTensorAlmostEqual(self, summ["variance"], 0) - def test_var_defin(self): + def test_var_defin(self) -> None: """ Variance is avg squared distance to mean. Thus it should be positive. This test is to ensure this is the case. @@ -63,7 +63,7 @@ def test_var_defin(self): assertTensorAlmostEqual(self, var, actual_var) self.assertTrue((var > 0).all()) - def test_multi_dim(self): + def test_multi_dim(self) -> None: x1 = torch.tensor([1.0, 2.0, 3.0, 4.0]) x2 = torch.tensor([2.0, 1.0, 2.0, 4.0]) x3 = torch.tensor([3.0, 3.0, 1.0, 4.0]) diff --git a/tests/attr/test_summarizer.py b/tests/attr/test_summarizer.py index 1b8d6859a2..67dc2e53e5 100644 --- a/tests/attr/test_summarizer.py +++ b/tests/attr/test_summarizer.py @@ -5,7 +5,7 @@ class Test(BaseTest): - def test_single_input(self): + def test_single_input(self) -> None: size = (2, 3) summarizer = Summarizer(stats=CommonStats()) for _ in range(10): @@ -19,7 +19,7 @@ def test_single_input(self): for k in summ: self.assertTrue(summ[k].size() == size) - def test_multi_input(self): + def test_multi_input(self) -> None: size1 = (10, 5, 5) size2 = (3, 5) diff --git a/tests/attr/test_utils_batching.py b/tests/attr/test_utils_batching.py index 89cd8b0407..30c99e1d8d 100644 --- a/tests/attr/test_utils_batching.py +++ b/tests/attr/test_utils_batching.py @@ -10,7 +10,7 @@ class Test(BaseTest): - def test_tuple_splice_range(self): + def test_tuple_splice_range(self) -> None: test_tuple = ( torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]), "test", @@ -21,7 +21,7 @@ def test_tuple_splice_range(self): self.assertEqual(spliced_tuple[1], "test") assertTensorAlmostEqual(self, spliced_tuple[2], [[0, 1, 2], [3, 4, 5]]) - def test_tuple_splice_range_3d(self): + def test_tuple_splice_range_3d(self) -> None: test_tuple = ( torch.tensor([[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [6, 7, 8]]]), "test", @@ -30,7 +30,7 @@ def test_tuple_splice_range_3d(self): assertTensorAlmostEqual(self, spliced_tuple[0], [[[6, 7, 8], [6, 7, 8]]]) self.assertEqual(spliced_tuple[1], "test") - def test_batched_generator(self): + def test_batched_generator(self) -> None: def sample_operator(inputs, additional_forward_args, target_ind, scale): return ( scale * (sum(inputs)), @@ -55,12 +55,12 @@ def sample_operator(inputs, additional_forward_args, target_ind, scale): self.assertEqual(add[1], 5) self.assertEqual(targ, 7) - def test_batched_operator_0_bsz(self): + def test_batched_operator_0_bsz(self) -> None: inp1 = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) with self.assertRaises(AssertionError): _batched_operator(lambda x: x, inputs=inp1, internal_batch_size=0) - def test_batched_operator(self): + def test_batched_operator(self) -> None: def _sample_operator(inputs, additional_forward_args, target_ind, scale): return ( scale * (sum(inputs)), diff --git a/tests/influence/_core/test_similarity_influence.py b/tests/influence/_core/test_similarity_influence.py index ec08bf6cf1..395762a5b2 100644 --- a/tests/influence/_core/test_similarity_influence.py +++ b/tests/influence/_core/test_similarity_influence.py @@ -36,7 +36,7 @@ def __init__(self, low, high, num_features) -> None: .transpose(1, 0) ) - def __len__(self): + def __len__(self) -> int: return len(self.samples) def __getitem__(self, idx): diff --git a/tests/influence/_utils/common.py b/tests/influence/_utils/common.py index 3ab018e5b9..999dc6404f 100644 --- a/tests/influence/_utils/common.py +++ b/tests/influence/_utils/common.py @@ -46,7 +46,7 @@ def __init__(self, samples, labels, use_gpu=False) -> None: ) self.labels = self.labels.cuda() - def __len__(self): + def __len__(self) -> int: return len(self.samples) def __getitem__(self, idx): @@ -64,7 +64,7 @@ def __init__(self, samples, labels, use_gpu=False) -> None: ) self.labels = self.labels.cuda() - def __len__(self): + def __len__(self) -> int: return len(self.samples[0]) def __getitem__(self, idx): @@ -254,7 +254,7 @@ def __init__( self.name = name if name else data_influence_class.__name__ self.kwargs = kwargs - def __repr__(self): + def __repr__(self) -> str: return self.name def __call__( diff --git a/tests/insights/test_contribution.py b/tests/insights/test_contribution.py index 56b5f26aaa..3b6f517419 100644 --- a/tests/insights/test_contribution.py +++ b/tests/insights/test_contribution.py @@ -26,7 +26,7 @@ def __init__( visualization_transform=None, ) - def visualization_type(self): + def visualization_type(self) -> str: return "real" def visualize(self, attribution, data, contribution_frac) -> FeatureOutput: @@ -135,7 +135,7 @@ def to_iter(data_loader): class Test(BaseTest): - def test_one_feature(self): + def test_one_feature(self) -> None: batch_size = 2 classes = _get_classes() dataset = list( @@ -169,7 +169,7 @@ def test_one_feature(self): total_contrib = sum(abs(f.contribution) for f in output[0].feature_outputs) self.assertAlmostEqual(total_contrib, 1.0, places=6) - def test_multi_features(self): + def test_multi_features(self) -> None: batch_size = 2 classes = _get_classes() img_dataset = list( diff --git a/tests/insights/test_features.py b/tests/insights/test_features.py index b89bab09ea..2f2e07cc06 100644 --- a/tests/insights/test_features.py +++ b/tests/insights/test_features.py @@ -16,11 +16,11 @@ class TestTextFeature(BaseTest): FEATURE_NAME = "question" - def test_text_feature_returns_text_as_visualization_type(self): + def test_text_feature_returns_text_as_visualization_type(self) -> None: feature = TextFeature(self.FEATURE_NAME, None, None, None) self.assertEqual(feature.visualization_type(), "text") - def test_text_feature_uses_visualization_transform_if_provided(self): + def test_text_feature_uses_visualization_transform_if_provided(self) -> None: input_data = torch.rand(2, 2) transformed_data = torch.rand(1, 1) @@ -55,7 +55,7 @@ def mock_transform(data): # has original data self.assertIs(feature_output.base, input_data) - def test_text_feature_generates_correct_visualization_output(self): + def test_text_feature_generates_correct_visualization_output(self) -> None: attribution = torch.tensor([0.1, 0.2, 0.3, 0.4]) input_data = torch.rand(1, 2) expected_modified = [100 * x for x in (attribution / attribution.max())] @@ -81,7 +81,7 @@ def test_text_feature_generates_correct_visualization_output(self): class TestEmptyFeature(BaseTest): - def test_empty_feature_should_generate_fixed_output(self): + def test_empty_feature_should_generate_fixed_output(self) -> None: feature = EmptyFeature() contribution = torch.rand(1).item() expected_output = FeatureOutput( @@ -96,7 +96,7 @@ def test_empty_feature_should_generate_fixed_output(self): class TestImageFeature(BaseTest): - def test_image_feature_generates_correct_ouput(self): + def test_image_feature_generates_correct_ouput(self) -> None: attribution = torch.zeros(1, 3, 4, 4) data = torch.ones(1, 3, 4, 4) contribution = 1.0 @@ -134,7 +134,7 @@ def mock_viz_attr(*args, **kwargs): class TestGeneralFeature(BaseTest): - def test_general_feature_generates_correct_output(self): + def test_general_feature_generates_correct_output(self) -> None: name = "general_feature" categories = ["cat1", "cat2", "cat3", "cat4"] attribution = torch.Tensor(1, 4) diff --git a/tests/utils/test_av.py b/tests/utils/test_av.py index 956bcd34de..301f04ecb9 100644 --- a/tests/utils/test_av.py +++ b/tests/utils/test_av.py @@ -20,7 +20,7 @@ def __init__(self, low, high, num_features) -> None: .transpose(1, 0) ) - def __len__(self): + def __len__(self) -> int: return len(self.samples) def __getitem__(self, idx): diff --git a/tests/utils/test_common.py b/tests/utils/test_common.py index e19c3c26b9..0a86c96e64 100644 --- a/tests/utils/test_common.py +++ b/tests/utils/test_common.py @@ -14,14 +14,14 @@ class Test(BaseTest): - def test_safe_div_number_denom(self): + def test_safe_div_number_denom(self) -> None: num = torch.tensor(4.0) assert safe_div(num, 2) == 2.0 assert safe_div(num, 0, 2) == 2.0 assert safe_div(num, 2.0) == 2.0 assert safe_div(num, 0.0, 2.0) == 2.0 - def test_safe_div_tensor_denom(self): + def test_safe_div_tensor_denom(self) -> None: num = torch.tensor([4.0, 6.0]) exp = torch.tensor([2.0, 3.0]) @@ -41,7 +41,7 @@ def test_safe_div_tensor_denom(self): # float default denom assert (safe_div(num, torch.tensor([0.0, 0.0]), 2.0) == exp).all() - def test_reduce_list_tensors(self): + def test_reduce_list_tensors(self) -> None: tensors = [torch.tensor([[3, 4, 5]]), torch.tensor([[0, 1, 2]])] reduced = _reduce_list(tensors) assertTensorAlmostEqual(self, reduced, [[3, 4, 5], [0, 1, 2]]) @@ -55,7 +55,7 @@ def test_reduce_list_tuples(self): assertTensorAlmostEqual(self, reduced[0], [[3, 4, 5], [3, 4, 5]]) assertTensorAlmostEqual(self, reduced[1], [[0, 1, 2], [0, 1, 2]]) - def test_sort_key_list(self): + def test_sort_key_list(self) -> None: key_list = [ torch.device("cuda:13"), torch.device("cuda:17"), @@ -67,7 +67,7 @@ def test_sort_key_list(self): for i in range(len(key_list)): self.assertEqual(sorted_keys[i].index, device_index_list[i]) - def test_sort_key_list_incomplete(self): + def test_sort_key_list_incomplete(self) -> None: key_list = [torch.device("cuda:10"), torch.device("cuda:0")] device_index_list = [0, 10, 13, 17] sorted_keys = _sort_key_list(key_list, device_index_list) diff --git a/tests/utils/test_linear_model.py b/tests/utils/test_linear_model.py index fcbc5e5272..ac38a77d29 100644 --- a/tests/utils/test_linear_model.py +++ b/tests/utils/test_linear_model.py @@ -121,7 +121,7 @@ def train_and_compare( h /= h.norm(p=2) assertTensorAlmostEqual(self, h, expected_hyperplane, delta=delta) - def test_simple_linear_regression(self): + def test_simple_linear_regression(self) -> None: xs = torch.randn(TestLinearModel.MAX_POINTS, 1) ys = 3 * xs + 1 @@ -152,7 +152,7 @@ def test_simple_linear_regression(self): delta=0.2, ) - def test_simple_multi_output(self): + def test_simple_multi_output(self) -> None: xs = torch.randn(TestLinearModel.MAX_POINTS, 1) y1 = 3 * xs + 1 y2 = -5 * xs @@ -167,7 +167,7 @@ def test_simple_multi_output(self): objective="ols", ) - def test_simple_linear_classification(self): + def test_simple_linear_classification(self) -> None: xs = torch.tensor([[0.5, 0.5], [-0.5, -0.5], [0.5, -0.5], [-0.5, 0.5]]) ys = torch.tensor([1.0, -1.0, 1.0, -1.0]) self.train_and_compare( @@ -201,7 +201,7 @@ def test_simple_linear_classification(self): SGDRidge, xs, ys, expected_loss=0.25, expected_reg=0, objective="ridge" ) - def test_simple_xor_problem(self): + def test_simple_xor_problem(self) -> None: r""" ^ o | x @@ -246,7 +246,7 @@ def test_simple_xor_problem(self): bias=False, ) - def test_weighted_problem(self): + def test_weighted_problem(self) -> None: r""" ^ 0 | x From 81858f3c37e0a09ab183028660485e53b5427255 Mon Sep 17 00:00:00 2001 From: Oliver Aobo Yang Date: Wed, 31 Aug 2022 16:29:55 -0700 Subject: [PATCH 122/174] add docstring style in developer guide (#1016) Summary: Write down the agreed docstring style in the developer guide Pull Request resolved: https://github.com/pytorch/captum/pull/1016 Reviewed By: NarineK Differential Revision: D39077183 Pulled By: aobo-y fbshipit-source-id: e3b5fab665e6697902d309082d8f4a31d8c52c82 --- docs/contribution_guide.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/docs/contribution_guide.md b/docs/contribution_guide.md index 731e12bfc0..f8aacf1c85 100644 --- a/docs/contribution_guide.md +++ b/docs/contribution_guide.md @@ -77,3 +77,20 @@ https://captum.ai/tutorials/House_Prices_Regression_Interpret **Multimodal** - You can use VQA model and dataset described here: https://captum.ai/tutorials/Multimodal_VQA_Captum_Insights + + +## Docstring style + +Docstring is required for all public APIs to provide users the details of the arguments and returns. [Our API documentation](https://captum.ai/api/) is generated from the docstring. Captum adopts a customized docstring format modified on top of [Google style](https://www.sphinx-doc.org/en/master/usage/extensions/example_google.html). Specifically, each argument should be listed as `arg_name (type): description` in the `Args:` section. The argument typing convention: +- primitive types: `int`, `str`, `float`, `bool` +- common collection types: `list`, `tuple`, `dict` + - [PEP 585](https://peps.python.org/pep-0585/#implementation) has deprecated the duplicate types: `List`, `Tuple`, `Dict` + - element types: `list[int]`, `dict[int, str]` +- other foundamental types: `Any`, `Callable`, `Iterable` +- class types: `MyClass`, `external_lib.SomeClass` +- omit `torch` for common Pytorch types: `Tensor`, `nn.Module` +- use `or` and `,` for union types: `type1 or type2`, `type1, tyep2, or type3` + - [PEP 604](https://peps.python.org/pep-0604/) proposes to use `|` to connect types: `type1 | type2`. We may consider migration later. +- append `optional` for argument with default value: `int, optional` + - append default value to the end of the description: `Default: None` + - Notice this is different with python's type hint `Optional[...]`, which indicate if the argument can be `None` From 5a5eb7842259bb3e2e8e64d6589d66a63711c35b Mon Sep 17 00:00:00 2001 From: Yassine EL KHAL Date: Tue, 6 Sep 2022 18:25:59 -0700 Subject: [PATCH 123/174] doc: rectify layerlrp example (#1017) Summary: This PR aims to rectify the LayerLRP example since it's talking about LayerLRP and not LRP. Moreover LRP doesn't require 2 arguments. Pull Request resolved: https://github.com/pytorch/captum/pull/1017 Reviewed By: NarineK Differential Revision: D39220576 Pulled By: aobo-y fbshipit-source-id: d3466f5193cea053049dbf28da4204cea350b4a5 --- captum/attr/_core/layer/layer_lrp.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/attr/_core/layer/layer_lrp.py b/captum/attr/_core/layer/layer_lrp.py index e72bbbaddc..bdc328f47e 100644 --- a/captum/attr/_core/layer/layer_lrp.py +++ b/captum/attr/_core/layer/layer_lrp.py @@ -204,10 +204,10 @@ def attribute( >>> # and returns an Nx10 tensor of class probabilities. It has one >>> # Conv2D and a ReLU layer. >>> net = ImageClassifier() - >>> lrp = LRP(net, net.conv1) + >>> layer_lrp = LayerLRP(net, net.conv1) >>> input = torch.randn(3, 3, 32, 32) >>> # Attribution size matches input size: 3x3x32x32 - >>> attribution = lrp.attribute(input, target=5) + >>> attribution = layer_lrp.attribute(input, target=5) """ self.verbose = verbose From ff2b403965f99f7ff9eb64cdf9370c1044390080 Mon Sep 17 00:00:00 2001 From: Fulton Wang Date: Wed, 14 Sep 2022 17:02:22 -0700 Subject: [PATCH 124/174] expose `intermediate_quantities` in `TracInCPFastRandProj`, new Summary: - adds `intermediate_quantities` method for `TracInCPFastRandProj`, which accepts the same inputs as the public `self_influence` method - `_get_intermediate_quantities_tracincp_fast_rand_proj`, which is called by `intermediate_quantities`, now does outer iteration over checkpoints, instead of batches. - adds a new test file, `test_tracin_intermediate_quantities`, which checks that 1) calling `intermediate_quantities` on a single large batch vs a dataloader yielding the same examples as the large batch gives the same results 2) using the intermediate quantities from `TracInCPFastRandProj.intermediate_quantities` to manually compute influence scores gives the same results as directly using `TracInCPFast`, when the former does not use any random projections. - TODO: adding a `outer_loop_by_checkpoints` option to `intermediate_quantities`, and using `intermediate_quantities` in `TracInCPFastRandProj.__init__` to compute the intermediate quantities for the train dataset, also with a `outer_loop_by_checkpoints` option that defaults to False - TODO: adding progress bar for computation of intermediate quantities (previously implemented that in D34803544, but probably easier to create new diff on in this stack) Reviewed By: NarineK Differential Revision: D37968593 fbshipit-source-id: 0f1f5d48b5cf0d3c09826b8b24f978f819f3eb5d --- .../_core/tracincp_fast_rand_proj.py | 266 ++++++++++++++---- .../test_tracin_intermediate_quantities.py | 201 +++++++++++++ 2 files changed, 416 insertions(+), 51 deletions(-) create mode 100644 tests/influence/_core/test_tracin_intermediate_quantities.py diff --git a/captum/influence/_core/tracincp_fast_rand_proj.py b/captum/influence/_core/tracincp_fast_rand_proj.py index 7206812042..114d4c45bd 100644 --- a/captum/influence/_core/tracincp_fast_rand_proj.py +++ b/captum/influence/_core/tracincp_fast_rand_proj.py @@ -68,6 +68,15 @@ class TracInCPFast(TracInCPBase): computes influence scores for that special case. Note that the computed influence scores are exactly the same as when naive back-propagation is used - there is no loss in accuracy. + + In more detail regarding the influence score computation: let :math`x` + and :math`\nabla_y f(y)` be the input and output-gradient of the last + fully-connected layer, respectively, for a training example. Similarly, let + :math`x'` and :math`\nabla_{y'} f(y')` be the corresponding quantities for + a test example. Then, the influence score of the training example on the test + example is the sum of the contribution from each checkpoint. The contribution from + a given checkpoint is :math`(x^T x')(\nabla_y f(y)^T \nabla_{y'} f(y'))`. + """ def __init__( @@ -312,7 +321,9 @@ def _influence_batch_tracincp_fast( batch: Tuple[Any, ...], ): """ - computes influence scores for a single training batch + computes influence scores for a single training batch, when only considering + gradients in the last fully-connected layer, using the computation trick + described in the `TracInCPFast` class description. """ def get_checkpoint_contribution(checkpoint): @@ -333,8 +344,15 @@ def get_checkpoint_contribution(checkpoint): self, batch[0:-1], batch[-1] ) return ( - _tensor_batch_dot(input_jacobians, src_jacobian) + _tensor_batch_dot( + input_jacobians, src_jacobian + ) # shape is (test batch size, training batch size), containing x^T x' + # for every example x in the training batch and example x' in the test + # batch * _tensor_batch_dot(input_layer_inputs, src_layer_input) + # shape is (test batch size, training batch size), containing + # (\nabla_y f(y)^T \nabla_{y'} f(y')) for every label y in the training + # batch and label y' in the test batch * learning_rate ) @@ -707,6 +725,14 @@ def _basic_computation_tracincp_fast( that `model(*inputs)` produces the predictions for the batch. targets (tensor): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. + + Returns: + (input_jacobians, layer_inputs) (tuple): `input_jacobians` is a 2D tensor, + where each row is the jacobian of the loss, with respect to the + *output* of the last fully-connected layer. `layer_inputs` is a 1D + tensor, where each row is the *input* to the last fully-connected + layer. For both, the length is the number of examples in the batch + represented by `inputs` and `targets`. """ layer_inputs: Dict[device, Tuple[Tensor, ...]] = defaultdict() lock = threading.Lock() @@ -760,6 +786,57 @@ def _capture_inputs(layer, input, output) -> None: class TracInCPFastRandProj(TracInCPFast): + r""" + A version of TracInCPFast which is optimized for "interactive" calls to + `influence` for the purpose of calculating proponents / opponents, or + influence scores. "Interactive" means there will be multiple calls to + `influence`, with each call for a different batch of test examples, and + subsequent calls rely on the results of previous calls. The implementation in + this class has been optimized so that each call to `influence` is fast, so that + it can be used for interactive analysis. This class should only be used for + interactive use cases. It should not be used if `influence` will only be + called once, because to enable fast calls to `influence`, time and memory + intensive preprocessing is required in `__init__`. Furthermore, it should not + be used to calculate self influence scores - `TracInCPFast` should be used + instead for that purpose. To enable interactive analysis, this implementation + computes and saves "embedding" vectors for all training examples in + `train_dataset`. Crucially, the influence score of a training + example on a test example is simply the dot-product of their corresponding + vectors, and proponents / opponents can be found by first storing vectors for + training examples in a nearest-neighbor data structure, and then finding the + nearest-neighbors for a test example in terms of dot-product (see appendix F + of the TracIn paper). This class should only be used if calls to `influence` + to obtain proponents / opponents or influence scores will be made in an + "interactive" manner, and there is sufficient memory to store vectors for the + entire `train_dataset`. This is because in order to enable interactive + analysis, this implementation incures overhead in ``__init__` to setup the + nearest-neighbors data structure, which is both time and memory intensive, as + vectors corresponding to all training examples needed to be stored. To reduce + memory usage, this implementation enables random projections of those vectors. + Note that the influence scores computed with random projections are less + accurate, though correct in expectation. + + In more detail regarding the "embedding" vectors - the influence of a training + example on a test example, when only considering gradients in the last + fully-connected layer, the sum of the contribution from each checkpoint. The + contribution from a given checkpoint is + :math`(x^T x')(\nabla_y f(y)^T \nabla_{y'} f(y'))`, using the notation in the + description of `TracInCPFast`. As is, this is not a dot-product of 2 vectors. + However, we can rewrite that contribution as + :math`(x \nabla_y f(y)^T) \dot (x' f(y')^T)`. Both terms in this + product are 2D matrices, as they are outer products, and the "product" is actually + a dot-product, treating both matrices as vectors. Therefore, for a given + checkpoint, its contribution to the "embedding" of an example is just the + outer-product :math`(x \nabla_y f(y)^T)`, flattened. Furthemore, to reduce the + dimension of this contribution, we can right-multiply and + left-multiply the outer-product with two separate projection matrices. These + transform :math`\nabla_y f(y)` and :math`x` to lower dimensional vectors. While + the dimension of these two lower dimensional vectors do not necessarily need to + be the same, in our implementation, we let them be the same, both equal to the + square root of the desired projection dimension. Finally, the embedding of an + example is the concatenation of the contributions from each checkpoint. + """ + def __init__( self, model: Module, @@ -775,35 +852,6 @@ def __init__( seed: int = 0, ) -> None: r""" - A version of TracInCPFast which is optimized for "interactive" calls to - `influence` for the purpose of calculating proponents / opponents, or - influence scores. "Interactive" means there will be multiple calls to - `influence`, with each call for a different batch of test examples, and - subsequent calls rely on the results of previous calls. The implementation in - this class has been optimized so that each call to `influence` is fast, so that - it can be used for interactive analysis. This class should only be used for - interactive use cases. It should not be used if `influence` will only be - called once, because to enable fast calls to `influence`, time and memory - intensive preprocessing is required in `__init__`. Furthermore, it should not - be used to calculate self influence scores - `TracInCPFast` should be used - instead for that purpose. To enable interactive analysis, this implementation - computes and saves "embedding" vectors for all training examples in - `train_dataset`. Crucially, the influence score of a training - example on a test example is simply the dot-product of their corresponding - vectors, and proponents / opponents can be found by first storing vectors for - training examples in a nearest-neighbor data structure, and then finding the - nearest-neighbors for a test example in terms of dot-product (see appendix F - of the TracIn paper). This class should only be used if calls to `influence` - to obtain proponents / opponents or influence scores will be made in an - "interactive" manner, and there is sufficient memory to store vectors for the - entire `train_dataset`. This is because in order to enable interactive - analysis, this implementation incures overhead in ``__init__` to setup the - nearest-neighbors data structure, which is both time and memory intensive, as - vectors corresponding to all training examples needed to be stored. To reduce - memory usage, this implementation enables random projections of those vectors. - Note that the influence scores computed with random projections are less - accurate, though correct in expectation. - Args: model (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. @@ -963,6 +1011,8 @@ def _influence( # type: ignore[override] example, `influence_scores[i][j]` is the influence score for the j-th training example to the i-th input example. """ + # TODO: after D35721609 lands, use helper function + # `TracInCP._influence_rand_proj` here to avoid duplicated logic inputs_batch = (*inputs, targets) input_projections = self._get_intermediate_quantities_tracincp_fast_rand_proj( DataLoader( @@ -1323,7 +1373,7 @@ def _process_src_intermediate_quantities_tracincp_fast_rand_proj( def _get_intermediate_quantities_tracincp_fast_rand_proj( self, - dataloader: DataLoader, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], projection_quantities: Optional[Tuple[torch.Tensor, torch.Tensor]], ) -> torch.Tensor: r""" @@ -1335,14 +1385,23 @@ def _get_intermediate_quantities_tracincp_fast_rand_proj( specifically, largest dot-product) data structure. Args: - dataloader (DataLoader): DataLoader for which the intermediate quantities - are computed. + inputs_dataset (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, and + and `batch[-1]` are the labels, if any. Here, `model` is model + provided in initialization. This is the same assumption made for + each batch yielded by training dataset `train_dataset`. Please see + documentation for the `train_dataset` argument to + `TracInCPFastRandProj.__init__` for more details on the assumed + structure of a batch. projection_quantities (tuple or None): Is either the two tensors defining the randomized projections to apply, or None, which means no projection is to be applied. Returns: - checkpoint_projections (tensor): A tensor of dimension + intermediate_quantities (tensor): A tensor of dimension (N, D * C), where N is total number of examples in `dataloader`, C is the number of checkpoints passed as the `checkpoints` argument of `TracInCPFastRandProj.__init__`, and each row represents the @@ -1360,16 +1419,32 @@ def _get_intermediate_quantities_tracincp_fast_rand_proj( the variable d in the top of page 15 of the TracIn paper: https://arxiv.org/pdf/2002.08484.pdf. """ - # for each checkpoint, this stores a list of projections for a batch - # each element in this list will be of shape (batch_size, projection_dim) - checkpoint_projections: List[Any] = [[] for _ in self.checkpoints] + # if `inputs_dataset` is not a `DataLoader`, turn it into one. + inputs_dataset = _format_inputs_dataset(inputs_dataset) + # internally, whether `projection_quantities` is None determines whether + # any projection will be applied to reduce the dimension of the "embedding" + # vectors. If projection will be applied, there are actually 2 different + # projection matrices - one to project the `input_jacobians`, and one to + # project the `layer_inputs`. See below for details of those two quantities. + # here, we extract the corresponding projection matrices for those two + # quantities, if doing projection. Note that the same projections are used + # for each checkpoint. project = False if projection_quantities is not None: project = True jacobian_projection, layer_input_projection = projection_quantities + # for each checkpoint, we will populate a list containing the contribution of + # the checkpoint for each batch + checkpoint_contributions: List[Union[List, Tensor]] = [ + [] for _ in self.checkpoints + ] + + # the "embedding" vector is the concatenation of contributions from each + # checkpoint, which we compute one by one for (j, checkpoint) in enumerate(self.checkpoints): + assert ( checkpoint is not None ), "None returned from `checkpoints`, cannot load." @@ -1377,30 +1452,119 @@ def _get_intermediate_quantities_tracincp_fast_rand_proj( learning_rate = self.checkpoints_load_func(self.model, checkpoint) learning_rate_root = learning_rate**0.5 - for batch in dataloader: - - batch_jacobians, batch_layer_inputs = _basic_computation_tracincp_fast( + # after loading a checkpoint, we compute the contribution of that + # checkpoint, for *all* batches (instead of a single batch). this enables + # increased efficiency. + for batch in inputs_dataset: + + # compute `input_jacobians` and `layer_inputs`, for a given checkpoint + # using a helper function. `input_jacobians` is a 2D tensor, + # where each row is the jacobian of the loss, with respect to the + # *output* of the last fully-connected layer. `layer_inputs` is a 2D + # tensor, where each row is the *input* to the last fully-connected + # layer. For both, the length is the number of examples in `batch` + input_jacobians, layer_inputs = _basic_computation_tracincp_fast( self, batch[0:-1], batch[-1], ) + # if doing projection, project those two quantities if project: - batch_jacobians = torch.matmul(batch_jacobians, jacobian_projection) + input_jacobians = torch.matmul(input_jacobians, jacobian_projection) - batch_layer_inputs = torch.matmul( - batch_layer_inputs, layer_input_projection - ) + layer_inputs = torch.matmul(layer_inputs, layer_input_projection) - checkpoint_projections[j].append( + # for an example, the contribution to the "embedding" vector from each + # checkpoint is the outer product of its `input_jacobian` and its + # `layer_input`, flattened to a 1D tensor. here, we perform this + # for the entire batch. we append the contribution to a list containing + # the contribution of all batches, from the checkpoint. + cast(list, checkpoint_contributions[j]).append( torch.matmul( - torch.unsqueeze(batch_jacobians, 2), - torch.unsqueeze(batch_layer_inputs, 1), - ).flatten(start_dim=1) + torch.unsqueeze( + input_jacobians, 2 + ), # size is (batch_size, output_size, 1) + torch.unsqueeze( + layer_inputs, 1 + ), # size is (batch_size, 1, input_size) + ).flatten( + start_dim=1 + ) # matmul does a batched matrix multiplication to return a 3D + # tensor. each element along the batch (0-th) dimension is the + # matrix product of a (output_size, 1) and (1, input_size) tensor + # in other words, each element is an outer product, and the matmul + # is just doing a batched outer product. this is what we want, as + # the contribution to the "embedding" for an example is the outer + # product of the last layer's input and the gradient of its output. + # finally, we flatten the 3rd dimension so that the contribution to + # the embedding for this checkpoint is a 2D tensor, i.e. each + # example's contribution to the embedding is a 1D tensor. * learning_rate_root ) - checkpoint_projections[j] = torch.cat(checkpoint_projections[j], dim=0) + # once we have computed the contribution from each batch, for a given + # checkpoint, we concatenate them along the batch dimension to get a + # single 2D tensor for that checkpoint + checkpoint_contributions[j] = torch.cat( + checkpoint_contributions[j], dim=0 # type: ignore + ) + + # finally, we concatenate along the checkpoint dimension, to get a tensor of + # shape (batch_size, projection_dim * number of checkpoints) + # each row in this result is the "embedding" vector for an example in `batch` + return torch.cat(checkpoint_contributions, dim=1) # type: ignore + + def compute_intermediate_quantities( + self, + inputs_dataset: Union[Tuple[Any, ...], DataLoader], + ) -> Tensor: + """ + Computes "embedding" vectors for all examples in a single batch, or a + `Dataloader` that yields batches. These embedding vectors are constructed so + that the influence score of a training example on a test example is simply the + dot-product of their corresponding vectors. Please see the documentation for + `TracInCPFastRandProj.__init__` for more details. Allowing a `DataLoader` + yielding batches to be passed in (as opposed to a single batch) gives the + potential to improve efficiency, because we load each checkpoint only once in + this method call. Thus if a `DataLoader` yielding batches is passed in, this + reduces the total number of times each checkpoint is loaded for a dataset, + compared to if a single batch is passed in. The reason we do not just increase + the batch size is that for large models, large batches do not fit in memory. + + Args: + inputs_dataset (Tuple, or DataLoader): Either a single tuple of any, or a + `DataLoader`, where each batch yielded is a tuple of any. In + either case, the tuple represents a single batch, where the last + element is assumed to be the labels for the batch. That is, + `model(*batch[0:-1])` produces the output for `model`, and + and `batch[-1]` are the labels, if any. Here, `model` is model + provided in initialization. This is the same assumption made for + each batch yielded by training dataset `train_dataset`. Please see + documentation for the `train_dataset` argument to + `TracInCPFastRandProj.__init__` for more details on the assumed + structure of a batch. - return torch.cat(checkpoint_projections, dim=1) + Returns: + intermediate_quantities (tensor): A tensor of dimension + (N, D * C), where N is total number of examples in + `inputs_dataset`, C is the number of checkpoints passed as the + `checkpoints` argument of `TracInCPFastRandProj.__init__`, and each + row represents the vector for an example. Regarding D: Let I be the + dimension of the output of the last fully-connected layer times the + dimension of the input of the last fully-connected layer. If + `self.projection_dim` is specified in initialization, + D = min(I * C, `self.projection_dim` * C). Otherwise, D = I * C. + In summary, if `self.projection_dim` is None, the dimension of each + vector will be determined by the size of the input and output of + the last fully-connected layer of `model`. Otherwise, + `self.projection_dim` must be an int, and random projection will be + performed to ensure that the vector is of dimension no more than + `self.projection_dim` * C. `self.projection_dim` corresponds to + the variable d in the top of page 15 of the TracIn paper: + https://arxiv.org/pdf/2002.08484.pdf. + """ + return self._get_intermediate_quantities_tracincp_fast_rand_proj( + inputs_dataset, self.projection_quantities + ) diff --git a/tests/influence/_core/test_tracin_intermediate_quantities.py b/tests/influence/_core/test_tracin_intermediate_quantities.py new file mode 100644 index 0000000000..7f3e806c28 --- /dev/null +++ b/tests/influence/_core/test_tracin_intermediate_quantities.py @@ -0,0 +1,201 @@ +import tempfile +from typing import Callable + +import torch + +import torch.nn as nn +from captum.influence._core.tracincp_fast_rand_proj import ( + TracInCPFast, + TracInCPFastRandProj, +) +from parameterized import parameterized +from tests.helpers.basic import assertTensorAlmostEqual, BaseTest +from tests.influence._utils.common import ( + build_test_name_func, + DataInfluenceConstructor, + get_random_model_and_data, +) +from torch.utils.data import DataLoader + + +class TestTracInIntermediateQuantities(BaseTest): + @parameterized.expand( + [ + (reduction, constructor, unpack_inputs) + for unpack_inputs in [True, False] + for (reduction, constructor) in [ + ("sum", DataInfluenceConstructor(TracInCPFastRandProj)), + ] + ], + name_func=build_test_name_func(), + ) + def test_tracin_intermediate_quantities_api( + self, reduction: str, tracin_constructor: Callable, unpack_inputs: bool + ) -> None: + """ + tests that the result of calling the public method + `compute_intermediate_quantities` for a DataLoader of batches is the same as + when the batches are collated into a single batch + """ + with tempfile.TemporaryDirectory() as tmpdir: + (net, train_dataset,) = get_random_model_and_data( + tmpdir, + unpack_inputs, + return_test_data=False, + ) + + # create a single batch representing the entire dataset + single_batch = next( + iter(DataLoader(train_dataset, batch_size=len(train_dataset))) + ) + + # create a dataloader that yields batches from the dataset + dataloader = DataLoader(train_dataset, batch_size=5) + + # create tracin instance + criterion = nn.MSELoss(reduction=reduction) + batch_size = 5 + tracin = tracin_constructor( + net, + train_dataset, + tmpdir, + batch_size, + criterion, + ) + + # compute intermediate quantities using `compute_intermediate_quantities` + # when passing in a single batch + single_batch_intermediate_quantities = ( + tracin.compute_intermediate_quantities(single_batch) + ) + + # compute intermediate quantities using `compute_intermediate_quantities` + # when passing in a dataloader with the same examples + dataloader_intermediate_quantities = tracin.compute_intermediate_quantities( + dataloader, + ) + + # the two self influences should be equal + assertTensorAlmostEqual( + self, + single_batch_intermediate_quantities, + dataloader_intermediate_quantities, + delta=0.01, # due to numerical issues, we can't set this to 0.0 + mode="max", + ) + + @parameterized.expand( + [ + ( + reduction, + constructor, + intermediate_quantities_tracin_constructor, + unpack_inputs, + ) + for unpack_inputs in [True, False] + for ( + reduction, + constructor, + intermediate_quantities_tracin_constructor, + ) in [ + ( + "sum", + DataInfluenceConstructor(TracInCPFast), + DataInfluenceConstructor(TracInCPFastRandProj), + ), + ] + ], + name_func=build_test_name_func(), + ) + def test_tracin_intermediate_quantities_consistent( + self, + reduction: str, + tracin_constructor: Callable, + intermediate_quantities_tracin_constructor: Callable, + unpack_inputs: bool, + ) -> None: + """ + Since the influence score of a test batch on a training data should be the dot + product of their intermediate quantities, checks that this is the case, by + computing the influence score 2 different ways and checking they give the same + results: 1) with the `influence` method, and by using the + `compute_intermediate_quantities` method on the test and training data, and + taking the dot product. No projection should be done. Otherwise, the + projection will cause error. For 1), we use an implementation that does not use + intermediate quantities, i.e. `TracInCPFast`. For 2), we use a method that + does use intermediate quantities, i.e. `TracInCPFastRandProj`. Since the + methods for the 2 cases are different, we need to parametrize the test with 2 + different tracin constructors. `tracin_constructor` is the constructor for the + tracin implementation for case 1. `intermediate_quantities_tracin_constructor` + is the constructor for the tracin implementation for case 2. + """ + with tempfile.TemporaryDirectory() as tmpdir: + ( + net, + train_dataset, + test_features, + test_labels, + ) = get_random_model_and_data(tmpdir, unpack_inputs, return_test_data=True) + + # create a dataloader that yields batches from the dataset + train_dataset = DataLoader(train_dataset, batch_size=5) + + # create tracin instance + criterion = nn.MSELoss(reduction=reduction) + batch_size = 5 + + tracin = tracin_constructor( + net, + train_dataset, + tmpdir, + batch_size, + criterion, + ) + + # create tracin instance which exposes `intermediate_quantities` + intermediate_quantities_tracin = intermediate_quantities_tracin_constructor( + net, + train_dataset, + tmpdir, + batch_size, + criterion, + ) + + # compute influence scores without using `compute_intermediate_quantities` + scores = tracin.influence( + test_features, test_labels, unpack_inputs=unpack_inputs + ) + + # compute influence scores using `compute_intermediate_quantities` + # we combine `test_features` and `test_labels` into a single tuple + # `test_batch` to pass to the model, with the assumption that + # `model(test_batch[0:-1]` produces the predictions, and `test_batch[-1]` + # are the labels. We do this due to the assumptions made by the + # `compute_intermediate_quantities` method. Therefore, how we + # form `test_batch` depends on whether `unpack_inputs` is True or False + if not unpack_inputs: + # `test_features` is a Tensor + test_batch = (test_features, test_labels) + else: + # `test_features` is a tuple, so we unpack it to place in tuple, + # along with `test_labels` + test_batch = (*test_features, test_labels) + + # the influence score is the dot product of intermediate quantities + intermediate_quantities_scores = torch.matmul( + intermediate_quantities_tracin.compute_intermediate_quantities( + test_batch + ), + intermediate_quantities_tracin.compute_intermediate_quantities( + train_dataset + ).T, + ) + + # the scores computed using the two methods should be the same + assertTensorAlmostEqual( + self, + scores, + intermediate_quantities_scores, + delta=0.01, # due to numerical issues, we can't set this to 0.0 + mode="max", + ) From b8eff98aaf0b17ff4d57a339cec5d3fba250e006 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 19 Sep 2022 12:28:30 -0700 Subject: [PATCH 125/174] Fix multiple Sphinx warnings & docstrings (#985) Summary: The warning messages take up a lot of space on the console log, and it was really simple to resolve them. The common.rst file was also incorrectly pointing to the wrong path and some of functions were renamed since it was created, so no docs were being generated for that page. `InputBaselineXGradient` was also removed from the public rst api docs, as it's not supposed to be public. In addition to these easy doc warning fixes, I found a module that was listed on on the API docs site, but there's not public path to use it and no tests were ever written for it. I made an issue post for it here: https://github.com/pytorch/captum/issues/989 I fixed some docstring issues like lack of consistent uppercase for `any` and `callable`, spacing, random type / case mistakes I came across, etc... I also fixed some paths. Issues with upgrading to later versions of Sphinx were also resolved. --- Currently Sphinx gives the following warnings / errors for the master branch: ``` /content/captum/sphinx/source/base_classes.rst:2: WARNING: Title underline too short. Base Classes ========== /content/captum/sphinx/source/base_classes.rst:29: WARNING: Title underline too short. Perturbation Attribution ^^^^^^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/base_classes.rst:29: WARNING: Title underline too short. Perturbation Attribution ^^^^^^^^^^^^^^^^^^^^^ WARNING: autodoc: failed to import function 'validate_input' from module 'captum.attr._utils.common'; the following exception was raised: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 448, in safe_getattr return getattr(obj, name, *defargs) AttributeError: module 'captum.attr._utils.common' has no attribute 'validate_input' The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/importer.py", line 110, in import_object obj = attrgetter(obj, mangled_name) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 332, in get_attr return autodoc_attrgetter(self.env.app, obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 2780, in autodoc_attrgetter return safe_getattr(obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 464, in safe_getattr raise AttributeError(name) from exc AttributeError: validate_input WARNING: autodoc: failed to import function 'validate_noise_tunnel_type' from module 'captum.attr._utils.common'; the following exception was raised: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 448, in safe_getattr return getattr(obj, name, *defargs) AttributeError: module 'captum.attr._utils.common' has no attribute 'validate_noise_tunnel_type' The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/importer.py", line 110, in import_object obj = attrgetter(obj, mangled_name) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 332, in get_attr return autodoc_attrgetter(self.env.app, obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 2780, in autodoc_attrgetter return safe_getattr(obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 464, in safe_getattr raise AttributeError(name) from exc AttributeError: validate_noise_tunnel_type WARNING: autodoc: failed to import function 'format_input' from module 'captum.attr._utils.common'; the following exception was raised: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 448, in safe_getattr return getattr(obj, name, *defargs) AttributeError: module 'captum.attr._utils.common' has no attribute 'format_input' The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/importer.py", line 110, in import_object obj = attrgetter(obj, mangled_name) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 332, in get_attr return autodoc_attrgetter(self.env.app, obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 2780, in autodoc_attrgetter return safe_getattr(obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 464, in safe_getattr raise AttributeError(name) from exc AttributeError: format_input WARNING: autodoc: failed to import function '_format_attributions' from module 'captum.attr._utils.common'; the following exception was raised: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 448, in safe_getattr return getattr(obj, name, *defargs) AttributeError: module 'captum.attr._utils.common' has no attribute '_format_attributions' The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/importer.py", line 110, in import_object obj = attrgetter(obj, mangled_name) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 332, in get_attr return autodoc_attrgetter(self.env.app, obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 2780, in autodoc_attrgetter return safe_getattr(obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 464, in safe_getattr raise AttributeError(name) from exc AttributeError: _format_attributions WARNING: autodoc: failed to import function 'zeros' from module 'captum.attr._utils.common'; the following exception was raised: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 448, in safe_getattr return getattr(obj, name, *defargs) AttributeError: module 'captum.attr._utils.common' has no attribute 'zeros' The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/importer.py", line 110, in import_object obj = attrgetter(obj, mangled_name) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 332, in get_attr return autodoc_attrgetter(self.env.app, obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 2780, in autodoc_attrgetter return safe_getattr(obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 464, in safe_getattr raise AttributeError(name) from exc AttributeError: zeros WARNING: autodoc: failed to import function '_run_forward' from module 'captum.attr._utils.common'; the following exception was raised: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 448, in safe_getattr return getattr(obj, name, *defargs) AttributeError: module 'captum.attr._utils.common' has no attribute '_run_forward' The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/importer.py", line 110, in import_object obj = attrgetter(obj, mangled_name) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 332, in get_attr return autodoc_attrgetter(self.env.app, obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 2780, in autodoc_attrgetter return safe_getattr(obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 464, in safe_getattr raise AttributeError(name) from exc AttributeError: _run_forward /content/captum/sphinx/source/concept.rst:2: WARNING: Title underline too short. Concept-based Interpretability ====== /content/captum/sphinx/source/concept.rst:12: WARNING: Title underline too short. ConceptInterpreter ^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/concept.rst:12: WARNING: Title underline too short. ConceptInterpreter ^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/deconvolution.rst:2: WARNING: Title underline too short. Deconvolution ========= /content/captum/captum/attr/_core/deep_lift.py:docstring of captum.attr._core.deep_lift.DeepLiftShap:12: WARNING: Definition list ends without a blank line; unexpected unindent. /content/captum/sphinx/source/feature_ablation.rst:2: WARNING: Title underline too short. Feature Ablation ========= /content/captum/captum/attr/_core/feature_ablation.py:docstring of captum.attr._core.feature_ablation.FeatureAblation.attribute:36: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/sphinx/source/feature_permutation.rst:2: WARNING: Title underline too short. Feature Permutation ========= WARNING: autodoc: failed to import class 'InputBaselineXGradient' from module 'captum.attr'; the following exception was raised: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 448, in safe_getattr return getattr(obj, name, *defargs) AttributeError: module 'captum.attr' has no attribute 'InputBaselineXGradient' The above exception was the direct cause of the following exception: Traceback (most recent call last): File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/importer.py", line 110, in import_object obj = attrgetter(obj, mangled_name) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 332, in get_attr return autodoc_attrgetter(self.env.app, obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/ext/autodoc/__init__.py", line 2780, in autodoc_attrgetter return safe_getattr(obj, name, *defargs) File "/usr/local/lib/python3.7/dist-packages/sphinx/util/inspect.py", line 464, in safe_getattr raise AttributeError(name) from exc AttributeError: InputBaselineXGradient /content/captum/sphinx/source/guided_backprop.rst:2: WARNING: Title underline too short. Guided Backprop ========= /content/captum/sphinx/source/guided_grad_cam.rst:2: WARNING: Title underline too short. Guided GradCAM ========= /content/captum/sphinx/source/influence.rst:2: WARNING: Title underline too short. Influential Examples ====== /content/captum/sphinx/source/influence.rst:12: WARNING: Title underline too short. SimilarityInfluence ^^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/influence.rst:12: WARNING: Title underline too short. SimilarityInfluence ^^^^^^^^^^^^^^^^^ /content/captum/captum/influence/_core/tracincp.py:docstring of captum.influence._core.tracincp.TracInCPBase.influence:61: WARNING: Inline interpreted text or phrase reference start-string without end-string. /content/captum/captum/influence/_core/tracincp.py:docstring of captum.influence._core.tracincp.TracInCP.influence:61: WARNING: Inline interpreted text or phrase reference start-string without end-string. /content/captum/captum/influence/_core/tracincp_fast_rand_proj.py:docstring of captum.influence._core.tracincp_fast_rand_proj.TracInCPFast.influence:62: WARNING: Inline interpreted text or phrase reference start-string without end-string. /content/captum/sphinx/source/influence.rst:38: WARNING: Title underline too short. TracInCPFastRandProj ^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/influence.rst:38: WARNING: Title underline too short. TracInCPFastRandProj ^^^^^^^^^^^^^^^^ /content/captum/captum/influence/_core/tracincp_fast_rand_proj.py:docstring of captum.influence._core.tracincp_fast_rand_proj.TracInCPFastRandProj:1: WARNING: Inline literal start-string without end-string. /content/captum/sphinx/source/input_x_gradient.rst:2: WARNING: Title underline too short. Input X Gradient =============== WARNING: autodoc: failed to import class 'api.Batch' from module 'captum.insights'; the following exception was raised: No module named 'captum.insights.api' WARNING: autodoc: failed to import class 'api.AttributionVisualizer' from module 'captum.insights'; the following exception was raised: No module named 'captum.insights.api' WARNING: autodoc: failed to import class 'features.BaseFeature' from module 'captum.insights'; the following exception was raised: No module named 'captum.insights.features' WARNING: autodoc: failed to import class 'features.GeneralFeature' from module 'captum.insights'; the following exception was raised: No module named 'captum.insights.features' WARNING: autodoc: failed to import class 'features.TextFeature' from module 'captum.insights'; the following exception was raised: No module named 'captum.insights.features' WARNING: autodoc: failed to import class 'features.ImageFeature' from module 'captum.insights'; the following exception was raised: No module named 'captum.insights.features' /content/captum/captum/attr/_core/integrated_gradients.py:docstring of captum.attr._core.integrated_gradients.IntegratedGradients.attribute:43: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/kernel_shap.py:docstring of captum.attr._core.kernel_shap.KernelShap.attribute:66: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/kernel_shap.py:docstring of captum.attr._core.kernel_shap.KernelShap.kernel_shap_perturb_generator:4: WARNING: Block quote ends without a blank line; unexpected unindent. /content/captum/sphinx/source/layer.rst:2: WARNING: Title underline too short. Layer Attribution ====== /content/captum/captum/attr/_core/layer/layer_conductance.py:docstring of captum.attr._core.layer.layer_conductance.LayerConductance.attribute:35: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/sphinx/source/layer.rst:18: WARNING: Title underline too short. Internal Influence ^^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/layer.rst:18: WARNING: Title underline too short. Internal Influence ^^^^^^^^^^^^^^^^^ /content/captum/captum/attr/_core/layer/internal_influence.py:docstring of captum.attr._core.layer.internal_influence.InternalInfluence.attribute:209: WARNING: Inline interpreted text or phrase reference start-string without end-string. /content/captum/sphinx/source/layer.rst:24: WARNING: Title underline too short. Layer Gradient X Activation ^^^^^^^^^^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/layer.rst:24: WARNING: Title underline too short. Layer Gradient X Activation ^^^^^^^^^^^^^^^^^^^^^^^^^ /content/captum/captum/attr/_core/layer/layer_deep_lift.py:docstring of captum.attr._core.layer.layer_deep_lift.LayerDeepLift.attribute:39: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/layer/layer_deep_lift.py:docstring of captum.attr._core.layer.layer_deep_lift.LayerDeepLiftShap:16: WARNING: Definition list ends without a blank line; unexpected unindent. /content/captum/sphinx/source/layer.rst:54: WARNING: Title underline too short. Layer Integrated Gradients ^^^^^^^^^^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/layer.rst:54: WARNING: Title underline too short. Layer Integrated Gradients ^^^^^^^^^^^^^^^^^^^^^^^^^ /content/captum/captum/attr/_core/layer/layer_integrated_gradients.py:docstring of captum.attr._core.layer.layer_integrated_gradients.LayerIntegratedGradients.attribute:35: WARNING: Unexpected indentation. /content/captum/captum/attr/_core/layer/layer_integrated_gradients.py:docstring of captum.attr._core.layer.layer_integrated_gradients.LayerIntegratedGradients.attribute:140: WARNING: Unexpected indentation. /content/captum/captum/attr/_core/layer/layer_integrated_gradients.py:docstring of captum.attr._core.layer.layer_integrated_gradients.LayerIntegratedGradients.attribute:158: WARNING: Block quote ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/layer/layer_lrp.py:docstring of captum.attr._core.layer.layer_lrp.LayerLRP.attribute:79: WARNING: Definition list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/layer/layer_lrp.py:docstring of captum.attr._core.layer.layer_lrp.LayerLRP.attribute:93: WARNING: Block quote ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/lime.py:docstring of captum.attr._core.lime.LimeBase.attribute:111: WARNING: Inline strong start-string without end-string. /content/captum/captum/attr/_core/lime.py:docstring of captum.attr._core.lime.Lime.attribute:66: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/lrp.py:docstring of captum.attr._core.lrp.LRP.attribute:68: WARNING: Unexpected indentation. /content/captum/captum/attr/_core/lrp.py:docstring of captum.attr._core.lrp.LRP.attribute:80: WARNING: Block quote ends without a blank line; unexpected unindent. /content/captum/sphinx/source/metrics.rst:2: WARNING: Title underline too short. Metrics ====== /content/captum/captum/metrics/_core/infidelity.py:docstring of captum.metrics._core.infidelity.infidelity:83: WARNING: Definition list ends without a blank line; unexpected unindent. /content/captum/captum/metrics/_core/sensitivity.py:docstring of captum.metrics._core.sensitivity.sensitivity_max:112: WARNING: Inline strong start-string without end-string. /content/captum/sphinx/source/neuron.rst:2: WARNING: Title underline too short. Neuron Attribution ======= /content/captum/sphinx/source/neuron.rst:11: WARNING: Title underline too short. Neuron Integrated Gradients ^^^^^^^^^^^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/neuron.rst:11: WARNING: Title underline too short. Neuron Integrated Gradients ^^^^^^^^^^^^^^^^^^^^^^^^^^ /content/captum/captum/attr/_core/neuron/neuron_deep_lift.py:docstring of captum.attr._core.neuron.neuron_deep_lift.NeuronDeepLiftShap:16: WARNING: Definition list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/neuron/neuron_feature_ablation.py:docstring of captum.attr._core.neuron.neuron_feature_ablation.NeuronFeatureAblation.attribute:69: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/noise_tunnel.py:docstring of captum.attr._core.noise_tunnel.NoiseTunnel:18: WARNING: Definition list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/occlusion.py:docstring of captum.attr._core.occlusion.Occlusion.attribute:68: WARNING: Bullet list ends without a blank line; unexpected unindent. WARNING: autodoc: failed to import module 'pytext' from module 'captum.attr._models'; the following exception was raised: No module named 'pytext' WARNING: don't know which module to import for autodocumenting 'PyTextInterpretableEmbedding' (try placing a "module" or "currentmodule" directive in the document, or giving an explicit module name) WARNING: don't know which module to import for autodocumenting 'BaselineGenerator' (try placing a "module" or "currentmodule" directive in the document, or giving an explicit module name) /content/captum/sphinx/source/robust.rst:2: WARNING: Title underline too short. Robustness ====== /content/captum/sphinx/source/robust.rst:26: WARNING: Title underline too short. Min Param Perturbation ^^^^^^^^^^^^^^^^ /content/captum/sphinx/source/robust.rst:26: WARNING: Title underline too short. Min Param Perturbation ^^^^^^^^^^^^^^^^ /content/captum/captum/robust/_core/metrics/min_param_perturbation.py:docstring of captum.robust._core.metrics.min_param_perturbation.MinParamPerturbation:75: WARNING: Inline strong start-string without end-string. /content/captum/sphinx/source/shapley_value_sampling.rst:2: WARNING: Title underline too short. Shapley Value Sampling ========= /content/captum/captum/attr/_core/shapley_value.py:docstring of captum.attr._core.shapley_value.ShapleyValueSampling.attribute:42: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/shapley_value.py:docstring of captum.attr._core.shapley_value.ShapleyValues.attribute:42: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_utils/visualization.py:docstring of captum.attr._utils.visualization.visualize_image_attr:37: WARNING: Enumerated list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_utils/visualization.py:docstring of captum.attr._utils.visualization.visualize_image_attr:54: WARNING: Enumerated list ends without a blank line; unexpected unindent. looking for now-outdated files... none found pickling environment... done checking consistency... /content/captum/sphinx/source/approximation_methods.rst: WARNING: document isn't included in any toctree /content/captum/sphinx/source/common.rst: WARNING: document isn't included in any toctree /content/captum/sphinx/source/pytext.rst: WARNING: document isn't included in any toctree done ``` With the changes in this PR, Sphinx now only gives the following warnings instead of the above multi page list: ``` /content/captum/captum/attr/_core/layer/layer_integrated_gradients.py:docstring of captum.attr._core.layer.layer_integrated_gradients.LayerIntegratedGradients.attribute:147: WARNING: Bullet list ends without a blank line; unexpected unindent. /content/captum/captum/attr/_core/lime.py:docstring of captum.attr._core.lime.LimeBase.attribute:111: WARNING: Inline strong start-string without end-string. /content/captum/captum/metrics/_core/sensitivity.py:docstring of captum.metrics._core.sensitivity.sensitivity_max:112: WARNING: Inline strong start-string without end-string. WARNING: autodoc: failed to import class 'pytext.PyTextInterpretableEmbedding' from module 'captum.attr._models'; the following exception was raised: No module named 'pytext' WARNING: autodoc: failed to import class 'pytext.BaselineGenerator' from module 'captum.attr._models'; the following exception was raised: No module named 'pytext' /content/captum/captum/robust/_core/metrics/min_param_perturbation.py:docstring of captum.robust._core.metrics.min_param_perturbation.MinParamPerturbation:77: WARNING: Inline strong start-string without end-string. looking for now-outdated files... none found pickling environment... done checking consistency... /content/captum/sphinx/source/pytext.rst: WARNING: document isn't included in any toctree done ``` Pull Request resolved: https://github.com/pytorch/captum/pull/985 Reviewed By: vivekmig Differential Revision: D39335917 Pulled By: aobo-y fbshipit-source-id: a5f96cc78cdbc1365ba683df32c7f8b6162197d4 --- README.md | 21 +++-- captum/_utils/av.py | 22 ++--- captum/_utils/gradient.py | 4 +- captum/_utils/models/linear_model/model.py | 8 +- captum/attr/_core/deep_lift.py | 38 +++++---- captum/attr/_core/feature_ablation.py | 23 ++--- captum/attr/_core/feature_permutation.py | 34 ++++---- captum/attr/_core/gradient_shap.py | 24 +++--- .../attr/_core/guided_backprop_deconvnet.py | 26 +++--- captum/attr/_core/guided_grad_cam.py | 16 ++-- captum/attr/_core/input_x_gradient.py | 12 +-- captum/attr/_core/integrated_gradients.py | 19 +++-- captum/attr/_core/kernel_shap.py | 23 ++--- captum/attr/_core/layer/grad_cam.py | 16 ++-- captum/attr/_core/layer/internal_influence.py | 22 ++--- captum/attr/_core/layer/layer_activation.py | 14 +-- captum/attr/_core/layer/layer_conductance.py | 23 ++--- captum/attr/_core/layer/layer_deep_lift.py | 39 +++++---- .../_core/layer/layer_feature_ablation.py | 18 ++-- .../attr/_core/layer/layer_gradient_shap.py | 28 +++--- .../layer/layer_gradient_x_activation.py | 16 ++-- .../_core/layer/layer_integrated_gradients.py | 43 ++++++---- captum/attr/_core/layer/layer_lrp.py | 35 ++++---- captum/attr/_core/lime.py | 47 +++++----- captum/attr/_core/lrp.py | 38 +++++---- .../attr/_core/neuron/neuron_conductance.py | 20 ++--- captum/attr/_core/neuron/neuron_deep_lift.py | 36 ++++---- .../_core/neuron/neuron_feature_ablation.py | 22 ++--- captum/attr/_core/neuron/neuron_gradient.py | 16 ++-- .../attr/_core/neuron/neuron_gradient_shap.py | 26 +++--- .../neuron_guided_backprop_deconvnet.py | 32 +++---- .../neuron/neuron_integrated_gradients.py | 20 ++--- captum/attr/_core/noise_tunnel.py | 24 +++--- captum/attr/_core/occlusion.py | 21 ++--- captum/attr/_core/saliency.py | 16 ++-- captum/attr/_core/shapley_value.py | 36 ++++---- captum/attr/_models/base.py | 29 ++++--- captum/attr/_utils/approximation_methods.py | 17 ++-- captum/attr/_utils/attribution.py | 69 +++++++-------- captum/attr/_utils/class_summarizer.py | 4 +- captum/attr/_utils/summarizer.py | 4 +- captum/attr/_utils/visualization.py | 52 ++++++------ captum/concept/_core/cav.py | 6 +- captum/concept/_core/concept.py | 5 +- captum/concept/_core/tcav.py | 34 +++++--- captum/concept/_utils/classifier.py | 6 +- captum/concept/_utils/data_iterator.py | 2 +- .../influence/_core/similarity_influence.py | 6 +- captum/influence/_core/tracincp.py | 69 ++++++++------- .../_core/tracincp_fast_rand_proj.py | 85 +++++++++++-------- captum/influence/_utils/common.py | 17 ++-- captum/influence/_utils/nearest_neighbors.py | 8 +- captum/insights/__init__.py | 2 +- captum/insights/attr_vis/app.py | 16 ++-- captum/insights/attr_vis/features.py | 18 ++-- captum/metrics/_core/infidelity.py | 29 ++++--- captum/metrics/_core/sensitivity.py | 32 +++---- captum/metrics/_utils/batching.py | 6 +- captum/robust/_core/fgsm.py | 44 ++++++---- .../robust/_core/metrics/attack_comparator.py | 59 +++++++------ .../_core/metrics/min_param_perturbation.py | 32 +++---- captum/robust/_core/perturbation.py | 6 +- captum/robust/_core/pgd.py | 29 ++++--- ...lgorithms.md => attribution_algorithms.md} | 2 +- docs/contribution_guide.md | 4 +- docs/extension/integrated_gradients.md | 10 +-- docs/faq.md | 4 +- scripts/install_via_pip.sh | 4 +- sphinx/source/approximation_methods.rst | 2 +- sphinx/source/base_classes.rst | 12 +-- sphinx/source/common.rst | 12 --- sphinx/source/concept.rst | 10 +-- sphinx/source/conf.py | 50 +++++++++++ sphinx/source/deconvolution.rst | 2 +- sphinx/source/feature_ablation.rst | 3 +- sphinx/source/feature_permutation.rst | 3 +- sphinx/source/gradient_shap.rst | 3 - sphinx/source/guided_backprop.rst | 2 +- sphinx/source/guided_grad_cam.rst | 2 +- sphinx/source/influence.rst | 14 +-- sphinx/source/input_x_gradient.rst | 2 +- sphinx/source/insights.rst | 4 +- sphinx/source/kernel_shap.rst | 1 + sphinx/source/layer.rst | 24 +++--- sphinx/source/lime.rst | 1 + sphinx/source/metrics.rst | 6 +- sphinx/source/neuron.rst | 21 ++--- sphinx/source/noise_tunnel.rst | 1 + sphinx/source/occlusion.rst | 1 + sphinx/source/pytext.rst | 7 +- sphinx/source/robust.rst | 10 +-- sphinx/source/shapley_value_sampling.rst | 4 +- sphinx/source/utilities.rst | 3 + .../test_tracin_intermediate_quantities.py | 2 +- website/sidebars.json | 2 +- 95 files changed, 967 insertions(+), 825 deletions(-) rename docs/{algorithms.md => attribution_algorithms.md} (99%) delete mode 100644 sphinx/source/common.rst diff --git a/README.md b/README.md index 5f415f7e0a..afa2f99d3f 100644 --- a/README.md +++ b/README.md @@ -159,8 +159,7 @@ model.eval() Next, we need to define simple input and baseline tensors. Baselines belong to the input space and often carry no predictive signal. Zero tensor can serve as a baseline for many tasks. -Some interpretability algorithms such as `Integrated -Gradients`, `Deeplift` and `GradientShap` are designed to attribute the change +Some interpretability algorithms such as `IntegratedGradients`, `Deeplift` and `GradientShap` are designed to attribute the change between the input and baseline to a predictive class or a value that the neural network outputs. @@ -472,23 +471,23 @@ You can watch the recorded talk [here](https://www.youtube.com/watch?v=ayhBHZYje * `SmoothGrad`: [SmoothGrad: removing noise by adding noise, Daniel Smilkov et al. 2017](https://arxiv.org/abs/1706.03825) * `NoiseTunnel`: [Sanity Checks for Saliency Maps, Julius Adebayo et al. 2018](https://arxiv.org/abs/1810.03292) * `NeuronConductance`: [How Important is a neuron?, Kedar Dhamdhere et al. 2018](https://arxiv.org/abs/1805.12233) -* `LayerConductance`: [Computationally Efficient Measures of Internal Neuron Importance, Avanti Shrikumar et al. 2018](https://arxiv.org/pdf/1807.09946.pdf) -* `DeepLift`, `NeuronDeepLift`, `LayerDeepLift`: [Learning Important Features Through Propagating Activation Differences, Avanti Shrikumar et al. 2017](https://arxiv.org/pdf/1704.02685.pdf) and [Towards better understanding of gradient-based attribution methods for deep neural networks, Marco Ancona et al. 2018](https://openreview.net/pdf?id=Sy21R9JAW) -* `NeuronIntegratedGradients`: [Computationally Efficient Measures of Internal Neuron Importance, Avanti Shrikumar et al. 2018](https://arxiv.org/pdf/1807.09946.pdf) +* `LayerConductance`: [Computationally Efficient Measures of Internal Neuron Importance, Avanti Shrikumar et al. 2018](https://arxiv.org/abs/1807.09946) +* `DeepLift`, `NeuronDeepLift`, `LayerDeepLift`: [Learning Important Features Through Propagating Activation Differences, Avanti Shrikumar et al. 2017](https://arxiv.org/abs/1704.02685) and [Towards better understanding of gradient-based attribution methods for deep neural networks, Marco Ancona et al. 2018](https://openreview.net/pdf?id=Sy21R9JAW) +* `NeuronIntegratedGradients`: [Computationally Efficient Measures of Internal Neuron Importance, Avanti Shrikumar et al. 2018](https://arxiv.org/abs/1807.09946) * `GradientShap`, `NeuronGradientShap`, `LayerGradientShap`, `DeepLiftShap`, `NeuronDeepLiftShap`, `LayerDeepLiftShap`: [A Unified Approach to Interpreting Model Predictions, Scott M. Lundberg et al. 2017](http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions) -* `InternalInfluence`: [Influence-Directed Explanations for Deep Convolutional Networks, Klas Leino et al. 2018](https://arxiv.org/pdf/1802.03788.pdf) +* `InternalInfluence`: [Influence-Directed Explanations for Deep Convolutional Networks, Klas Leino et al. 2018](https://arxiv.org/abs/1802.03788) * `Saliency`, `NeuronGradient`: [Deep Inside Convolutional Networks: Visualising -Image Classification Models and Saliency Maps, K. Simonyan, et. al. 2014](https://arxiv.org/pdf/1312.6034.pdf) -* `GradCAM`, `Guided GradCAM`: [Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization, Ramprasaath R. Selvaraju et al. 2017](https://arxiv.org/abs/1610.02391.pdf) -* `Deconvolution`, `Neuron Deconvolution`: [Visualizing and Understanding Convolutional Networks, Matthew D Zeiler et al. 2014](https://arxiv.org/pdf/1311.2901.pdf) -* `Guided Backpropagation`, `Neuron Guided Backpropagation`: [Striving for Simplicity: The All Convolutional Net, Jost Tobias Springenberg et al. 2015](https://arxiv.org/pdf/1412.6806.pdf) +Image Classification Models and Saliency Maps, K. Simonyan, et. al. 2014](https://arxiv.org/abs/1312.6034) +* `GradCAM`, `Guided GradCAM`: [Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization, Ramprasaath R. Selvaraju et al. 2017](https://arxiv.org/abs/1610.02391) +* `Deconvolution`, `Neuron Deconvolution`: [Visualizing and Understanding Convolutional Networks, Matthew D Zeiler et al. 2014](https://arxiv.org/abs/1311.2901) +* `Guided Backpropagation`, `Neuron Guided Backpropagation`: [Striving for Simplicity: The All Convolutional Net, Jost Tobias Springenberg et al. 2015](https://arxiv.org/abs/1412.6806) * `Feature Permutation`: [Permutation Feature Importance](https://christophm.github.io/interpretable-ml-book/feature-importance.html) * `Occlusion`: [Visualizing and Understanding Convolutional Networks](https://arxiv.org/abs/1311.2901) * `Shapley Value`: [A value for n-person games. Contributions to the Theory of Games 2.28 (1953): 307-317](https://apps.dtic.mil/dtic/tr/fulltext/u2/604084.pdf) * `Shapley Value Sampling`: [Polynomial calculation of the Shapley value based on sampling](https://www.sciencedirect.com/science/article/pii/S0305054808000804) * `Infidelity and Sensitivity`: [On the (In)fidelity and Sensitivity for Explanations](https://arxiv.org/abs/1901.09392) -More details about the above mentioned [algorithms](https://captum.ai/docs/algorithms) and their pros and cons can be found on our [web-site](https://captum.ai/docs/algorithms_comparison_matrix). +More details about the above mentioned [attribution algorithms](https://captum.ai/docs/attribution_algorithms) and their pros and cons can be found on our [web-site](https://captum.ai/docs/algorithms_comparison_matrix). ## License Captum is BSD licensed, as found in the [LICENSE](LICENSE) file. diff --git a/captum/_utils/av.py b/captum/_utils/av.py index ac3c32a204..1b749162f8 100644 --- a/captum/_utils/av.py +++ b/captum/_utils/av.py @@ -80,7 +80,7 @@ def __getitem__(self, idx: int) -> Union[Tensor, Tuple[Tensor, ...]]: av = torch.load(fl) return av - def __len__(self): + def __len__(self) -> int: return len(self.files) AV_DIR_NAME: str = "av" @@ -211,9 +211,9 @@ def save( AV.generate_dataset_activations from batch index. It assumes identifier is same for all layers if a list of `layers` is provided. - layers (str or List of str): The layer(s) for which the activation vectors + layers (str or list[str]): The layer(s) for which the activation vectors are computed. - act_tensors (Tensor or List of Tensor): A batch of activation vectors. + act_tensors (tensor or list of tensor): A batch of activation vectors. This must match the dimension of `layers`. num_id (str): string representing the batch number for which the activation vectors are computed @@ -299,13 +299,15 @@ def _manage_loading_layers( for the `layer` are stored. model_id (str): The name/version of the model for which layer activations are being computed and stored. - layers (str or List of str): The layer(s) for which the activation vectors + layers (str or list[str]): The layer(s) for which the activation vectors are computed. + load_from_disk (bool, optional): Whether or not to load from disk. + Default: True identifier (str or None): An optional identifier for the layer activations. Can be used to distinguish between activations for different training batches. - num_id (str): An optional string representing the batch number for which the - activation vectors are computed + num_id (str, optional): An optional string representing the batch number + for which the activation vectors are computed. Returns: List of layer names for which activations should be generated @@ -357,9 +359,9 @@ def _compute_and_save_activations( define all of its layers as attributes of the model. model_id (str): The name/version of the model for which layer activations are being computed and stored. - layers (str or List of str): The layer(s) for which the activation vectors + layers (str or list[str]): The layer(s) for which the activation vectors are computed. - inputs (tensor or tuple of tensors): Batch of examples for + inputs (Tensor or tuple of Tensor): Batch of examples for which influential instances are computed. They are passed to the input `model`. The first dimension in `inputs` tensor or tuple of tensors corresponds to the batch size. @@ -368,7 +370,7 @@ def _compute_and_save_activations( different training batches. num_id (str): An required string representing the batch number for which the activation vectors are computed - additional_forward_args (optional): Additional arguments that will be + additional_forward_args (Any, optional): Additional arguments that will be passed to `model` after inputs. Default: None load_from_disk (bool): Forces function to regenerate activations if False. @@ -433,7 +435,7 @@ def generate_dataset_activations( define all of its layers as attributes of the model. model_id (str): The name/version of the model for which layer activations are being computed and stored. - layers (str or List of str): The layer(s) for which the activation vectors + layers (str or list[str]): The layer(s) for which the activation vectors are computed. dataloader (torch.utils.data.DataLoader): DataLoader that yields Dataset for which influential instances are computed. They are passed to diff --git a/captum/_utils/gradient.py b/captum/_utils/gradient.py index a15157d8d7..5b853cd435 100644 --- a/captum/_utils/gradient.py +++ b/captum/_utils/gradient.py @@ -730,7 +730,7 @@ def _compute_jacobian_wrt_params( but must behave as a library loss function would if `reduction='none'`. Returns: - grads (Tuple of Tensor): Returns the Jacobian for the minibatch as a + grads (tuple of Tensor): Returns the Jacobian for the minibatch as a tuple of gradients corresponding to the tuple of trainable parameters returned by `model.parameters()`. Each object grads[i] references to the gradients for the parameters in the i-th trainable layer of the model. @@ -804,7 +804,7 @@ def _compute_jacobian_wrt_params_with_sample_wise_trick( Defaults to 'sum'. Returns: - grads (Tuple of Tensor): Returns the Jacobian for the minibatch as a + grads (tuple of Tensor): Returns the Jacobian for the minibatch as a tuple of gradients corresponding to the tuple of trainable parameters returned by `model.parameters()`. Each object grads[i] references to the gradients for the parameters in the i-th trainable layer of the model. diff --git a/captum/_utils/models/linear_model/model.py b/captum/_utils/models/linear_model/model.py index bfffdbf38a..24302d540c 100644 --- a/captum/_utils/models/linear_model/model.py +++ b/captum/_utils/models/linear_model/model.py @@ -20,7 +20,7 @@ def __init__(self, train_fn: Callable, **kwargs) -> None: Please note that this is an experimental feature. Args: - train_fn (callable) + train_fn (Callable) The function to train with. See `captum._utils.models.linear_model.train.sgd_train_linear_model` and @@ -65,14 +65,14 @@ def _construct_model_params( normalization parameters used. bias (bool): Whether to add a bias term. Not needed if normalized input. - weight_values (tensor, optional): + weight_values (Tensor, optional): The values to initialize the linear model with. This must be a 1D or 2D tensor, and of the form `(num_outputs, num_features)` or `(num_features,)`. Additionally, if this is provided you need not to provide `in_features` or `out_features`. - bias_value (tensor, optional): + bias_value (Tensor, optional): The bias value to initialize the model with. - classes (tensor, optional): + classes (Tensor, optional): The list of prediction classes supported by the model in case it performs classificaton. In case of regression it is set to None. Default: None diff --git a/captum/attr/_core/deep_lift.py b/captum/attr/_core/deep_lift.py index 251e68dc23..ea059d7fcc 100644 --- a/captum/attr/_core/deep_lift.py +++ b/captum/attr/_core/deep_lift.py @@ -112,7 +112,7 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. @@ -185,7 +185,7 @@ def attribute( # type: ignore r""" Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -194,7 +194,7 @@ def attribute( # type: ignore to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference samples that are compared with the inputs. In order to assign attribution scores DeepLift computes the differences between the inputs/outputs and @@ -226,7 +226,7 @@ def attribute( # type: ignore use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -251,7 +251,7 @@ def attribute( # type: ignore target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -267,7 +267,7 @@ def attribute( # type: ignore is set to True convergence delta will be returned in a tuple following attributions. Default: False - custom_attribution_func (callable, optional): A custom function for + custom_attribution_func (Callable, optional): A custom function for computing final attribution scores. This function can take at least one and at most three arguments with the following signature: @@ -288,7 +288,7 @@ def attribute( # type: ignore Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution score computed based on DeepLift rescale rule with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value @@ -296,14 +296,14 @@ def attribute( # type: ignore If a single tensor is provided as inputs, a single tensor is returned. If a tuple is provided for inputs, a tuple of corresponding sized tensors is returned. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must equal the total sum of the attributions computed based on DeepLift's rescale rule. Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of - of examples in input. + examples in input. Note that the logic described for deltas is guaranteed when the default logic for attribution computations is used, meaning that the `custom_attribution_func=None`, otherwise it is not guaranteed and @@ -611,12 +611,14 @@ class DeepLiftShap(DeepLift): each baseline and averages resulting attributions. More details about the algorithm can be found here: - http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf + https://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf Note that the explanation model: + 1. Assumes that input features are independent of one another 2. Is linear, meaning that the explanations are modeled through the additive composition of feature effects. + Although, it assumes a linear model for each explanation, the overall model across multiple explanations can be complex and non-linear. """ @@ -625,7 +627,7 @@ def __init__(self, model: Module, multiply_by_inputs: bool = True) -> None: r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API. multiply_by_inputs (bool, optional): Indicates whether to factor @@ -694,7 +696,7 @@ def attribute( # type: ignore r""" Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -703,7 +705,7 @@ def attribute( # type: ignore to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (tensor, tuple of tensors, callable): + baselines (Tensor, tuple of Tensor, or Callable): Baselines define reference samples that are compared with the inputs. In order to assign attribution scores DeepLift computes the differences between the inputs/outputs and @@ -728,7 +730,7 @@ def attribute( # type: ignore It is recommended that the number of samples in the baselines' tensors is larger than one. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -753,7 +755,7 @@ def attribute( # type: ignore target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -769,7 +771,7 @@ def attribute( # type: ignore is set to True convergence delta will be returned in a tuple following attributions. Default: False - custom_attribution_func (callable, optional): A custom function for + custom_attribution_func (Callable, optional): A custom function for computing final attribution scores. This function can take at least one and at most three arguments with the following signature: @@ -789,7 +791,7 @@ def attribute( # type: ignore Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution score computed based on DeepLift rescale rule with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value @@ -797,7 +799,7 @@ def attribute( # type: ignore If a single tensor is provided as inputs, a single tensor is returned. If a tuple is provided for inputs, a tuple of corresponding sized tensors is returned. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must be very close to the total sum of attributions diff --git a/captum/attr/_core/feature_ablation.py b/captum/attr/_core/feature_ablation.py index fd0007fc75..70de13e81c 100644 --- a/captum/attr/_core/feature_ablation.py +++ b/captum/attr/_core/feature_ablation.py @@ -47,8 +47,8 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable): The forward function of the model or - any modification of it + forward_func (Callable): The forward function of the model or + any modification of it. """ PerturbationAttribution.__init__(self, forward_func) self.use_weights = False @@ -68,7 +68,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which ablation + inputs (Tensor or tuple of Tensor): Input for which ablation attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -77,7 +77,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference value which replaces each feature when ablated. Baselines can be provided as: @@ -101,10 +101,11 @@ def attribute( - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -129,7 +130,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -144,7 +145,7 @@ def attribute( Note that attributions are not computed with respect to these arguments. Default: None - feature_mask (tensor or tuple of tensors, optional): + feature_mask (Tensor or tuple of Tensor, optional): feature_mask defines a mask for the input, grouping features which should be ablated together. feature_mask should contain the same number of tensors as inputs. @@ -193,8 +194,8 @@ def attribute( Default: None Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The attributions with respect to each input feature. If the forward function returns a scalar value per example, attributions will be @@ -414,10 +415,10 @@ def _ith_input_ablation_generator( **kwargs, ): """ - This method return an generator of ablation perturbations of the i-th input + This method returns a generator of ablation perturbations of the i-th input Returns: - ablation_iter (generator): yields each perturbation to be evaluated + ablation_iter (Generator): yields each perturbation to be evaluated as a tuple (inputs, additional_forward_args, targets, mask). """ extra_args = {} diff --git a/captum/attr/_core/feature_permutation.py b/captum/attr/_core/feature_permutation.py index 544ff16ac6..9aac4c11a1 100644 --- a/captum/attr/_core/feature_permutation.py +++ b/captum/attr/_core/feature_permutation.py @@ -75,9 +75,9 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or - any modification of it - perm_func (callable, optional): A function that accepts a batch of + forward_func (Callable): The forward function of the model or + any modification of it. + perm_func (Callable, optional): A function that accepts a batch of inputs and a feature mask, and "permutes" the feature using feature mask across the batch. This defaults to a function which applies a random permutation, this argument only needs @@ -101,14 +101,16 @@ def attribute( # type: ignore **kwargs: Any, ) -> TensorOrTupleOfTensorsGeneric: r""" - This function is almost equivalent to `FeatureAblation.attribute`. The - main difference is the way ablated examples are generated. Specifically - they are generated through the `perm_func`, as we set the baselines for - `FeatureAblation.attribute` to None. + This function is almost equivalent to + :func:`FeatureAblation.attribute `. The + main difference is the way ablated examples are generated. Specifically they + are generated through the ``perm_func``, as we set the baselines for + :func:`FeatureAblation.attribute ` to + ``None``. Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which permutation attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If @@ -118,7 +120,7 @@ def attribute( # type: ignore 0 corresponds to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which difference is computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -143,7 +145,7 @@ def attribute( # type: ignore target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -158,7 +160,7 @@ def attribute( # type: ignore Note that attributions are not computed with respect to these arguments. Default: None - feature_mask (tensor or tuple of tensors, optional): + feature_mask (Tensor or tuple of Tensor, optional): feature_mask defines a mask for the input, grouping features which should be ablated together. feature_mask should contain the same number of tensors as inputs. @@ -196,14 +198,14 @@ def attribute( # type: ignore a simple output of progress. Default: False **kwargs (Any, optional): Any additional arguments used by child - classes of FeatureAblation (such as Occlusion) to construct - ablations. These arguments are ignored when using - FeatureAblation directly. + classes of :class:`.FeatureAblation` (such as + :class:`.Occlusion`) to construct ablations. These + arguments are ignored when using FeatureAblation directly. Default: None Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The attributions with respect to each input feature. If the forward function returns a scalar value per example, attributions will be diff --git a/captum/attr/_core/gradient_shap.py b/captum/attr/_core/gradient_shap.py index 57d5e909af..f6ec8da302 100644 --- a/captum/attr/_core/gradient_shap.py +++ b/captum/attr/_core/gradient_shap.py @@ -50,7 +50,7 @@ class GradientShap(GradientAttribution): In some sense it can be viewed as an approximation of integrated gradients by computing the expectations of gradients for different baselines. - Current implementation uses Smoothgrad from `NoiseTunnel` in order to + Current implementation uses Smoothgrad from :class:`.NoiseTunnel` in order to randomly draw samples from the distribution of baselines, add noise to input samples and compute the expectation (smoothgrad). """ @@ -59,7 +59,7 @@ def __init__(self, forward_func: Callable, multiply_by_inputs: bool = True) -> N r""" Args: - forward_func (function): The forward function of the model or + forward_func (Callable): The forward function of the model or any modification of it. multiply_by_inputs (bool, optional): Indicates whether to factor model inputs' multiplier in the final attribution scores. @@ -127,7 +127,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which SHAP attribution + inputs (Tensor or tuple of Tensor): Input for which SHAP attribution values are computed. If `forward_func` takes a single tensor as input, a single input tensor should be provided. If `forward_func` takes multiple tensors as input, a tuple @@ -135,7 +135,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (tensor, tuple of tensors, callable): + baselines (Tensor, tuple of Tensor, or Callable): Baselines define the starting point from which expectation is computed and can be provided as: @@ -158,11 +158,11 @@ def attribute( It is recommended that the number of samples in the baselines' tensors is larger than one. - n_samples (int, optional): The number of randomly generated examples + n_samples (int, optional): The number of randomly generated examples per sample in the input batch. Random examples are generated by adding gaussian random noise to each sample. Default: `5` if `n_samples` is not provided. - stdevs (float, or a tuple of floats optional): The standard deviation + stdevs (float or tuple of float, optional): The standard deviation of gaussian noise with zero mean that is added to each input in the batch. If `stdevs` is a single float value then that same value is used for all inputs. If it is @@ -171,7 +171,7 @@ def attribute( corresponds to the input with the same index in the inputs tuple. Default: 0.0 - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -196,7 +196,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It can contain a tuple of ND tensors or @@ -215,7 +215,7 @@ def attribute( Default: False Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution score computed based on GradientSHAP with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value @@ -223,7 +223,7 @@ def attribute( If a single tensor is provided as inputs, a single tensor is returned. If a tuple is provided for inputs, a tuple of corresponding sized tensors is returned. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must be very close to the total sum of the attributions @@ -294,8 +294,8 @@ def __init__(self, forward_func: Callable, multiply_by_inputs=True) -> None: r""" Args: - forward_func (function): The forward function of the model or - any modification of it + forward_func (Callable): The forward function of the model or + any modification of it. multiply_by_inputs (bool, optional): Indicates whether to factor model inputs' multiplier in the final attribution scores. In the literature this is also known as local vs global diff --git a/captum/attr/_core/guided_backprop_deconvnet.py b/captum/attr/_core/guided_backprop_deconvnet.py index e1953ed5b9..ba2c2114c5 100644 --- a/captum/attr/_core/guided_backprop_deconvnet.py +++ b/captum/attr/_core/guided_backprop_deconvnet.py @@ -27,7 +27,7 @@ def __init__(self, model: Module, use_relu_grad_output: bool = False) -> None: r""" Args: - model (nn.Module): The reference to PyTorch model instance. + model (nn.Module): The reference to PyTorch model instance. """ GradientAttribution.__init__(self, model) self.model = model @@ -121,7 +121,7 @@ def __init__(self, model: Module) -> None: r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place ReLU submodules; these are not supported by the register_full_backward_hook PyTorch API. """ @@ -139,7 +139,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -148,7 +148,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -173,7 +173,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -186,8 +186,8 @@ def attribute( Default: None Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The guided backprop gradients with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value @@ -234,7 +234,7 @@ def __init__(self, model: Module) -> None: r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place ReLU submodules; these are not supported by the register_full_backward_hook PyTorch API. """ @@ -250,7 +250,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -259,7 +259,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -284,7 +284,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -297,8 +297,8 @@ def attribute( Default: None Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The deconvolution attributions with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value diff --git a/captum/attr/_core/guided_grad_cam.py b/captum/attr/_core/guided_grad_cam.py index f6e29c4b29..3c7478bae8 100644 --- a/captum/attr/_core/guided_grad_cam.py +++ b/captum/attr/_core/guided_grad_cam.py @@ -38,7 +38,7 @@ class GuidedGradCam(GradientAttribution): More details regarding GuidedGradCAM can be found in the original GradCAM paper here: - https://arxiv.org/pdf/1610.02391.pdf + https://arxiv.org/abs/1610.02391 Warning: Ensure that all ReLU operations in the forward function of the given model are performed using a module (nn.module.ReLU). @@ -51,14 +51,14 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place ReLU submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. layer (torch.nn.Module): Layer for which GradCAM attributions are computed. Currently, only layers with a single tensor output are supported. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -80,7 +80,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which attributions + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -88,7 +88,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -113,7 +113,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -151,8 +151,8 @@ def attribute( Default: False Returns: - *tensor* of **attributions**: - - **attributions** (*tensor*): + *Tensor* of **attributions**: + - **attributions** (*Tensor*): Element-wise product of (upsampled) GradCAM and Guided Backprop attributions. If a single tensor is provided as inputs, a single tensor is diff --git a/captum/attr/_core/input_x_gradient.py b/captum/attr/_core/input_x_gradient.py index 7817466013..fcf1d85025 100644 --- a/captum/attr/_core/input_x_gradient.py +++ b/captum/attr/_core/input_x_gradient.py @@ -22,7 +22,7 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it """ GradientAttribution.__init__(self, forward_func) @@ -37,7 +37,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -46,7 +46,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -71,7 +71,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -84,8 +84,8 @@ def attribute( Default: None Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The input x gradient with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value diff --git a/captum/attr/_core/integrated_gradients.py b/captum/attr/_core/integrated_gradients.py index e96a826c32..04896fac61 100644 --- a/captum/attr/_core/integrated_gradients.py +++ b/captum/attr/_core/integrated_gradients.py @@ -53,7 +53,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it multiply_by_inputs (bool, optional): Indicates whether to factor model inputs' multiplier in the final attribution scores. @@ -130,7 +130,7 @@ def attribute( # type: ignore Args: - inputs (tensor or tuple of tensors): Input for which integrated + inputs (Tensor or tuple of Tensor): Input for which integrated gradients are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -138,7 +138,7 @@ def attribute( # type: ignore that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define the starting point from which integral is computed and can be provided as: @@ -162,11 +162,12 @@ def attribute( # type: ignore - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -191,7 +192,7 @@ def attribute( # type: ignore target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -210,7 +211,7 @@ def attribute( # type: ignore Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. - method (string, optional): Method for approximating the integral, + method (str, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. @@ -232,7 +233,7 @@ def attribute( # type: ignore Default: False Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Integrated gradients with respect to each input feature. attributions will always be the same size as the provided inputs, with each value providing the attribution of the @@ -240,7 +241,7 @@ def attribute( # type: ignore If a single tensor is provided as inputs, a single tensor is returned. If a tuple is provided for inputs, a tuple of corresponding sized tensors is returned. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): The difference between the total approximated and true integrated gradients. This is computed using the property that the total sum of forward_func(inputs) - @@ -248,7 +249,7 @@ def attribute( # type: ignore integrated gradient. Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of - of examples in inputs. + examples in inputs. Examples:: diff --git a/captum/attr/_core/kernel_shap.py b/captum/attr/_core/kernel_shap.py index 2826b30dfe..12da6991dc 100644 --- a/captum/attr/_core/kernel_shap.py +++ b/captum/attr/_core/kernel_shap.py @@ -29,8 +29,8 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable): The forward function of the model or - any modification of it + forward_func (Callable): The forward function of the model or + any modification of it. """ Lime.__init__( self, @@ -86,7 +86,7 @@ def attribute( # type: ignore Args: - inputs (tensor or tuple of tensors): Input for which KernelShap + inputs (Tensor or tuple of Tensor): Input for which KernelShap is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -94,7 +94,7 @@ def attribute( # type: ignore that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define the reference value which replaces each feature when the corresponding interpretable feature is set to 0. @@ -120,10 +120,11 @@ def attribute( # type: ignore - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which surrogate model is trained (for classification cases, this is usually the target class). @@ -149,7 +150,7 @@ def attribute( # type: ignore target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -166,7 +167,7 @@ def attribute( # type: ignore Note that attributions are not computed with respect to these arguments. Default: None - feature_mask (tensor or tuple of tensors, optional): + feature_mask (Tensor or tuple of Tensor, optional): feature_mask defines a mask for the input, grouping features which correspond to the same interpretable feature. feature_mask @@ -184,7 +185,7 @@ def attribute( # type: ignore If None, then a feature mask is constructed which assigns each scalar within a tensor as a separate feature. Default: None - n_samples (int, optional): The number of samples of the original + n_samples (int, optional): The number of samples of the original model used to train the surrogate interpretable model. Default: `50` if `n_samples` is not provided. perturbations_per_eval (int, optional): Allows multiple samples @@ -219,8 +220,8 @@ def attribute( # type: ignore Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The attributions with respect to each input feature. If return_input_shape = True, attributions will be the same size as the provided inputs, with each value @@ -316,7 +317,9 @@ def kernel_shap_perturb_generator( Perturbations are sampled by the following process: - Choose k (number of selected features), based on the distribution p(k) = (M - 1) / (k * (M - k)) + where M is the total number of features in the interpretable space + - Randomly select a binary vector with k ones, each sample is equally likely. This is done by generating a random vector of normal values and thresholding based on the top k elements. diff --git a/captum/attr/_core/layer/grad_cam.py b/captum/attr/_core/layer/grad_cam.py index c650409149..bcbcb02af7 100644 --- a/captum/attr/_core/layer/grad_cam.py +++ b/captum/attr/_core/layer/grad_cam.py @@ -47,7 +47,7 @@ class LayerGradCam(LayerAttribution, GradientAttribution): More details regarding the GradCAM method can be found in the original paper here: - https://arxiv.org/pdf/1610.02391.pdf + https://arxiv.org/abs/1610.02391 """ def __init__( @@ -59,13 +59,13 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's output dimensions, except for dimension 2, which will be 1, since GradCAM sums over channels. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -86,7 +86,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which attributions + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -94,7 +94,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -119,7 +119,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -151,8 +151,8 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Attributions based on GradCAM method. Attributions will be the same size as the output of the given layer, except for dimension 2, diff --git a/captum/attr/_core/layer/internal_influence.py b/captum/attr/_core/layer/internal_influence.py index 8976fe7344..46aba1ff61 100644 --- a/captum/attr/_core/layer/internal_influence.py +++ b/captum/attr/_core/layer/internal_influence.py @@ -30,7 +30,7 @@ class InternalInfluence(LayerAttribution, GradientAttribution): given input. If no baseline is provided, the default baseline is the zero tensor. More details on this approach can be found here: - https://arxiv.org/pdf/1802.03788.pdf + https://arxiv.org/abs/1802.03788 Note that this method is similar to applying integrated gradients and taking the layer as input, integrating the gradient of the layer with @@ -46,7 +46,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's input or @@ -54,7 +54,7 @@ def __init__( the inputs or outputs of the layer, corresponding to attribution of each neuron in the input or output of this layer. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -78,7 +78,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which internal + inputs (Tensor or tuple of Tensor): Input for which internal influence is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -86,7 +86,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define a starting point from which integral is computed and can be provided as: @@ -115,7 +115,7 @@ def attribute( use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -140,7 +140,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -159,7 +159,7 @@ def attribute( Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. - method (string, optional): Method for approximating the integral, + method (str, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. @@ -187,13 +187,13 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Internal influence of each neuron in given layer output. Attributions will always be the same size as the output or input of the given layer depending on whether `attribute_to_layer_input` is set to `False` or - `True`respectively. + `True` respectively. Attributions are returned in a tuple if the layer inputs / outputs contain multiple tensors, otherwise a single tensor is returned. diff --git a/captum/attr/_core/layer/layer_activation.py b/captum/attr/_core/layer/layer_activation.py index 86c511706b..c4244e5966 100644 --- a/captum/attr/_core/layer/layer_activation.py +++ b/captum/attr/_core/layer/layer_activation.py @@ -25,9 +25,9 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it - layer (torch.nn.Module or list(torch.nn.Module)): Layer or layers + layer (torch.nn.Module or list of torch.nn.Module): Layer or layers for which attributions are computed. Output size of attribute matches this layer's input or output dimensions, depending on whether we attribute to @@ -36,7 +36,7 @@ def __init__( this layer. If multiple layers are provided, attributions are returned as a list, each element corresponding to the activations of the corresponding layer. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -54,7 +54,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which layer + inputs (Tensor or tuple of Tensor): Input for which layer activation is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -62,7 +62,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -87,8 +87,8 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* or *list* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors* or *list*): + *Tensor* or tuple of *Tensor* or list of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor* or *list*): Activation of each neuron in given layer output. Attributions will always be the same size as the output of the given layer. diff --git a/captum/attr/_core/layer/layer_conductance.py b/captum/attr/_core/layer/layer_conductance.py index 3d76569c10..b8d9bc563f 100644 --- a/captum/attr/_core/layer/layer_conductance.py +++ b/captum/attr/_core/layer/layer_conductance.py @@ -32,7 +32,7 @@ class LayerConductance(LayerAttribution, GradientAttribution): The details of the approach can be found here: https://arxiv.org/abs/1805.12233 - https://arxiv.org/pdf/1807.09946.pdf + https://arxiv.org/abs/1807.09946 Note that this provides the total conductance of each neuron in the layer's output. To obtain the breakdown of a neuron's conductance by input @@ -49,7 +49,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's input or @@ -57,7 +57,7 @@ def __init__( the inputs or outputs of the layer, corresponding to attribution of each neuron in the input or output of this layer. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -120,7 +120,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which layer + inputs (Tensor or tuple of Tensor): Input for which layer conductance is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -128,7 +128,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define the starting point from which integral is computed and can be provided as: @@ -152,11 +152,12 @@ def attribute( - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -181,7 +182,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -200,7 +201,7 @@ def attribute( Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. - method (string, optional): Method for approximating the integral, + method (str, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. @@ -234,7 +235,7 @@ def attribute( Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Conductance of each neuron in given layer input or output. Attributions will always be the same size as the input or output of the given layer, depending on @@ -244,7 +245,7 @@ def attribute( Attributions are returned in a tuple if the layer inputs / outputs contain multiple tensors, otherwise a single tensor is returned. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): The difference between the total approximated and true conductance. This is computed using the property that the total sum of @@ -252,7 +253,7 @@ def attribute( the total sum of the attributions. Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of - of examples in inputs. + examples in inputs. Examples:: diff --git a/captum/attr/_core/layer/layer_deep_lift.py b/captum/attr/_core/layer/layer_deep_lift.py index 71a8e9eb29..362f250170 100644 --- a/captum/attr/_core/layer/layer_deep_lift.py +++ b/captum/attr/_core/layer/layer_deep_lift.py @@ -69,7 +69,7 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. @@ -144,7 +144,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which layer + inputs (Tensor or tuple of Tensor): Input for which layer attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, @@ -153,7 +153,7 @@ def attribute( corresponds to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference samples that are compared with the inputs. In order to assign attribution scores DeepLift computes the differences between the inputs/outputs and @@ -180,11 +180,12 @@ def attribute( - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -209,7 +210,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -236,7 +237,7 @@ def attribute( attribute to the input or output, is a single tensor. Support for multiple tensors will be added later. Default: False - custom_attribution_func (callable, optional): A custom function for + custom_attribution_func (Callable, optional): A custom function for computing final attribution scores. This function can take at least one and at most three arguments with the following signature: @@ -255,7 +256,7 @@ def attribute( Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution score computed based on DeepLift's rescale rule with respect to layer's inputs or outputs. Attributions will always be the same size as the provided layer's inputs or outputs, depending on @@ -264,14 +265,14 @@ def attribute( just a tensor is returned; if the layer input / output has multiple tensors, then a corresponding tuple of tensors is returned. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must equal the total sum of the attributions computed based on DeepLift's rescale rule. Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of - of examples in input. + examples in input. Note that the logic described for deltas is guaranteed when the default logic for attribution computations is used, meaning that the `custom_attribution_func=None`, otherwise @@ -381,12 +382,14 @@ class LayerDeepLiftShap(LayerDeepLift, DeepLiftShap): input flag `attribute_to_layer_input`. More details about the algorithm can be found here: - http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf + https://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf Note that the explanation model: + 1. Assumes that input features are independent of one another 2. Is linear, meaning that the explanations are modeled through the additive composition of feature effects. + Although, it assumes a linear model for each explanation, the overall model across multiple explanations can be complex and non-linear. """ @@ -400,7 +403,7 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. @@ -479,7 +482,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which layer + inputs (Tensor or tuple of Tensor): Input for which layer attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -488,7 +491,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (tensor, tuple of tensors, callable): + baselines (Tensor, tuple of Tensor, or Callable): Baselines define reference samples that are compared with the inputs. In order to assign attribution scores DeepLift computes the differences between the inputs/outputs and @@ -513,7 +516,7 @@ def attribute( It is recommended that the number of samples in the baselines' tensors is larger than one. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -538,7 +541,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -564,7 +567,7 @@ def attribute( outputs of internal layers are single tensors. Support for multiple tensors will be added later. Default: False - custom_attribution_func (callable, optional): A custom function for + custom_attribution_func (Callable, optional): A custom function for computing final attribution scores. This function can take at least one and at most three arguments with the following signature: @@ -584,7 +587,7 @@ def attribute( Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution score computed based on DeepLift's rescale rule with respect to layer's inputs or outputs. Attributions will always be the same size as the provided layer's inputs @@ -595,7 +598,7 @@ def attribute( from a forward hook. For standard modules, inputs of a single tensor are usually wrapped in a tuple, while outputs of a single tensor are not. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must be very close to the total sum of attributions diff --git a/captum/attr/_core/layer/layer_feature_ablation.py b/captum/attr/_core/layer/layer_feature_ablation.py index 75ac885eac..ee7df14ff7 100644 --- a/captum/attr/_core/layer/layer_feature_ablation.py +++ b/captum/attr/_core/layer/layer_feature_ablation.py @@ -42,7 +42,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's input or @@ -50,7 +50,7 @@ def __init__( the inputs or outputs of the layer, corresponding to attribution of each neuron in the input or output of this layer. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself @@ -75,7 +75,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which layer + inputs (Tensor or tuple of Tensor): Input for which layer attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -83,7 +83,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - layer_baselines (scalar, tensor, tuple of scalars or tensors, optional): + layer_baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Layer baselines define reference values which replace each layer input / output value when ablated. Layer baselines should be a single tensor with dimensions @@ -94,7 +94,7 @@ def attribute( In the cases when `baselines` is not provided, we internally use zero as the baseline for each neuron. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -119,7 +119,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -131,7 +131,7 @@ def attribute( Note that attributions are not computed with respect to these arguments. Default: None - layer_mask (tensor or tuple of tensors, optional): + layer_mask (Tensor or tuple of Tensor, optional): layer_mask defines a mask for the layer, grouping elements of the layer input / output which should be ablated together. @@ -171,8 +171,8 @@ def attribute( Default: 1 Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution of each neuron in given layer input or output. Attributions will always be the same size as the input or output of the given layer, depending on diff --git a/captum/attr/_core/layer/layer_gradient_shap.py b/captum/attr/_core/layer/layer_gradient_shap.py index 9473475cdf..b6dfda9106 100644 --- a/captum/attr/_core/layer/layer_gradient_shap.py +++ b/captum/attr/_core/layer/layer_gradient_shap.py @@ -29,7 +29,7 @@ class LayerGradientShap(LayerAttribution, GradientAttribution): #deep-learning-example-with-gradientexplainer-tensorflowkeraspytorch-models A Unified Approach to Interpreting Model Predictions - http://papers.nips.cc/paper\ + https://papers.nips.cc/paper\ 7062-a-unified-approach-to-interpreting-model-predictions GradientShap approximates SHAP values by computing the expectations of @@ -52,7 +52,7 @@ class LayerGradientShap(LayerAttribution, GradientAttribution): In some sense it can be viewed as an approximation of integrated gradients by computing the expectations of gradients for different baselines. - Current implementation uses Smoothgrad from `NoiseTunnel` in order to + Current implementation uses Smoothgrad from :class:`.NoiseTunnel` in order to randomly draw samples from the distribution of baselines, add noise to input samples and compute the expectation (smoothgrad). """ @@ -67,7 +67,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's input or @@ -75,7 +75,7 @@ def __init__( the inputs or outputs of the layer, corresponding to attribution of each neuron in the input or output of this layer. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -146,7 +146,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input which are used to compute + inputs (Tensor or tuple of Tensor): Input which are used to compute SHAP attribution values for a given `layer`. If `forward_func` takes a single tensor as input, a single input tensor should be provided. @@ -155,7 +155,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (tensor, tuple of tensors, callable): + baselines (Tensor, tuple of Tensor, or Callable): Baselines define the starting point from which expectation is computed and can be provided as: @@ -178,11 +178,11 @@ def attribute( It is recommended that the number of samples in the baselines' tensors is larger than one. - n_samples (int, optional): The number of randomly generated examples + n_samples (int, optional): The number of randomly generated examples per sample in the input batch. Random examples are generated by adding gaussian random noise to each sample. Default: `5` if `n_samples` is not provided. - stdevs (float, or a tuple of floats optional): The standard deviation + stdevs (float or tuple of float, optional): The standard deviation of gaussian noise with zero mean that is added to each input in the batch. If `stdevs` is a single float value then that same value is used for all inputs. If it is @@ -191,7 +191,7 @@ def attribute( corresponds to the input with the same index in the inputs tuple. Default: 0.0 - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -216,7 +216,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It can contain a tuple of ND tensors or @@ -246,7 +246,7 @@ def attribute( Default: False Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution score computed based on GradientSHAP with respect to layer's input or output. Attributions will always be the same size as the provided layer's inputs or outputs, @@ -255,7 +255,7 @@ def attribute( Attributions are returned in a tuple if the layer inputs / outputs contain multiple tensors, otherwise a single tensor is returned. - - **delta** (*tensor*, returned if return_convergence_delta=True): + - **delta** (*Tensor*, returned if return_convergence_delta=True): This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must be very close to the total sum of the attributions @@ -335,7 +335,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's input or @@ -343,7 +343,7 @@ def __init__( the inputs or outputs of the layer, corresponding to attribution of each neuron in the input or output of this layer. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, diff --git a/captum/attr/_core/layer/layer_gradient_x_activation.py b/captum/attr/_core/layer/layer_gradient_x_activation.py index a63a5d7abe..385a1491c4 100644 --- a/captum/attr/_core/layer/layer_gradient_x_activation.py +++ b/captum/attr/_core/layer/layer_gradient_x_activation.py @@ -30,9 +30,9 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it - layer (torch.nn.Module or list(torch.nn.Module)): Layer or layers + layer (torch.nn.Module or list of torch.nn.Module): Layer or layers for which attributions are computed. Output size of attribute matches this layer's input or output dimensions, depending on whether we attribute to @@ -41,7 +41,7 @@ def __init__( this layer. If multiple layers are provided, attributions are returned as a list, each element corresponding to the attributions of the corresponding layer. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -80,7 +80,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which attributions + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -88,7 +88,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -113,7 +113,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -134,8 +134,8 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* or *list* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors* or *list*): + *Tensor* or tuple of *Tensor* or list of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor* or *list*): Product of gradient and activation for each neuron in given layer output. Attributions will always be the same size as the diff --git a/captum/attr/_core/layer/layer_integrated_gradients.py b/captum/attr/_core/layer/layer_integrated_gradients.py index 2e769a5658..d67f52cad5 100644 --- a/captum/attr/_core/layer/layer_integrated_gradients.py +++ b/captum/attr/_core/layer/layer_integrated_gradients.py @@ -41,7 +41,6 @@ class LayerIntegratedGradients(LayerAttribution, GradientAttribution): More details regarding the integrated gradients method can be found in the original paper: https://arxiv.org/abs/1703.01365 - """ def __init__( @@ -53,12 +52,12 @@ def __init__( ) -> None: r""" Args: - forward_func (callable): The forward function of the model or any + + forward_func (Callable): The forward function of the model or any modification of it - layer (ModuleOrModuleList): - Layer or list of layers for which attributions are computed. - For each layer the output size of the attribute matches - this layer's input or output dimensions, depending on + layer (ModuleOrModuleList): Layer or list of layers for which attributions + are computed. For each layer the output size of the attribute + matches this layer's input or output dimensions, depending on whether we attribute to the inputs or outputs of the layer, corresponding to the attribution of each neuron in the input or output of this layer. @@ -74,7 +73,7 @@ def __init__( dependence, e.g. if you pass in l2 you cannot pass in l1 or l3. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -101,7 +100,7 @@ def __init__( if isinstance(layer, list) and len(layer) > 1: warnings.warn( "Multiple layers provided. Please ensure that each layer is" - "**not** solely solely dependent on the outputs of" + "**not** solely dependent on the outputs of" "another layer. Please refer to the documentation for more" "detail." ) @@ -192,7 +191,7 @@ def attribute( Args: - inputs (tensor or tuple of tensors): Input for which layer integrated + inputs (Tensor or tuple of Tensor): Input for which layer integrated gradients are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -200,7 +199,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define the starting point from which integral is computed and can be provided as: @@ -214,6 +213,7 @@ def attribute( - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: + - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining @@ -227,7 +227,7 @@ def attribute( use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -252,7 +252,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -261,17 +261,19 @@ def attribute( tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. + For a tensor, the first dimension of the tensor must correspond to the number of examples. It will be repeated for each of `n_steps` along the integrated path. For all other types, the given argument is used for all forward evaluations. + Note that attributions are not computed with respect to these arguments. Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. - method (string, optional): Method for approximating the integral, + method (str, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. @@ -280,6 +282,7 @@ def attribute( which are computed (forward / backward passes) sequentially. internal_batch_size must be at least equal to #examples. + For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain internal_batch_size / num_devices examples. @@ -297,16 +300,19 @@ def attribute( then the attributions will be computed with respect to layer input, otherwise it will be computed with respect to layer output. + Note that currently it is assumed that either the input or the output of internal layer, depending on whether we attribute to the input or output, is a single tensor. Support for multiple tensors will be added later. Default: False + Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor*, tuple of *tensors* or tuple of *tensors*): - Integrated gradients with respect to `layer`'s inputs or - outputs. Attributions will always be the same size and + + - **attributions** (*Tensor*, tuple of *Tensor* or tuple of + *Tensor*): Integrated gradients with respect to `layer`'s inputs + or outputs. Attributions will always be the same size and dimensionality as the input or output of the given layer, depending on whether we attribute to the inputs or outputs of the layer which is decided by the input flag @@ -323,7 +329,8 @@ def attribute( multiple tensors: the corresponding output element will be a tuple of tensors. The ordering of the outputs will be the same order as the layers given in the constructor. - - **delta** (*tensor*, returned if return_convergence_delta=True): + + - **delta** (*Tensor*, returned if return_convergence_delta=True): The difference between the total approximated and true integrated gradients. This is computed using the property that the total sum of forward_func(inputs) - @@ -331,7 +338,7 @@ def attribute( integrated gradient. Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of - of examples in inputs. + examples in inputs. Examples:: diff --git a/captum/attr/_core/layer/layer_lrp.py b/captum/attr/_core/layer/layer_lrp.py index bdc328f47e..1f78d1fdd8 100644 --- a/captum/attr/_core/layer/layer_lrp.py +++ b/captum/attr/_core/layer/layer_lrp.py @@ -42,7 +42,7 @@ def __init__(self, model: Module, layer: ModuleOrModuleList) -> None: """ Args: - model (module): The forward function of the model or + model (Module): The forward function of the model or any modification of it. Custom rules for a given layer need to be defined as attribute `module.rule` and need to be of type PropagationRule. @@ -50,8 +50,7 @@ def __init__(self, model: Module, layer: ModuleOrModuleList) -> None: these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. - - layer (torch.nn.Module or list(torch.nn.Module)): Layer or layers + layer (torch.nn.Module or list of torch.nn.Module): Layer or layers for which attributions are computed. The size and dimensionality of the attributions corresponds to the size and dimensionality of the layer's @@ -110,9 +109,9 @@ def attribute( ], ]: r""" - Args: - inputs (tensor or tuple of tensors): Input for which relevance is + + inputs (Tensor or tuple of Tensor): Input for which relevance is propagated. If forward_func takes a single tensor as input, a single input tensor should be provided. @@ -121,12 +120,12 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for - which gradients are computed (for classification cases, - this is usually the target class). - If the network returns a scalar value per example, - no target index is necessary. - For general 2D outputs, targets can be either: + target (int, tuple, Tensor, or list, optional): Output indices for + which gradients are computed (for classification cases, + this is usually the target class). + If the network returns a scalar value per example, + no target index is necessary. + For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples @@ -176,9 +175,10 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* of **attributions** or 2-element tuple of - **attributions**, **delta** or lists of **attributions** and **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions** or 2-element tuple of + **attributions**, **delta** or list of **attributions** and **delta**: + + - **attributions** (*Tensor* or tuple of *Tensor*): The propagated relevance values with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value @@ -190,14 +190,15 @@ def attribute( implementations. If attributions for all layers are returned (layer=None) a list of tensors or tuples of tensors is returned with entries for each layer. - - **delta** (*tensor* or list of *tensors* - returned if return_convergence_delta=True): + - **delta** (*Tensor* or list of *Tensor* + returned if return_convergence_delta=True): Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of - of examples in input. + examples in input. If attributions for all layers are returned (layer=None) a list of tensors is returned with entries for each layer. + Examples:: >>> # ImageClassifier takes a single input tensor of images Nx3x32x32, diff --git a/captum/attr/_core/lime.py b/captum/attr/_core/lime.py index f5ad7877bc..1f94bb9cb2 100644 --- a/captum/attr/_core/lime.py +++ b/captum/attr/_core/lime.py @@ -82,7 +82,7 @@ def __init__( Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it. If a batch is provided as input for attribution, it is expected that forward_func returns a scalar representing the entire batch. @@ -106,7 +106,7 @@ def __init__( Note that calling fit multiple times should retrain the interpretable model, each attribution call reuses the same given interpretable model object. - similarity_func (callable): Function which takes a single sample + similarity_func (Callable): Function which takes a single sample along with its corresponding interpretable representation and returns the weight of the interpretable sample for training interpretable model. Weight is generally @@ -131,7 +131,7 @@ def __init__( All kwargs passed to the attribute method are provided as keyword arguments (kwargs) to this callable. - perturb_func (callable): Function which returns a single + perturb_func (Callable): Function which returns a single sampled input, generally a perturbation of the original input, which is used to train the interpretable surrogate model. Function can return samples in either @@ -171,7 +171,7 @@ def __init__( input. Once sampled, inputs can be converted to / from the interpretable representation with either to_interp_rep_transform or from_interp_rep_transform. - from_interp_rep_transform (callable): Function which takes a + from_interp_rep_transform (Callable): Function which takes a single sampled interpretable representation (tensor of shape 1 x num_interp_features) and returns the corresponding representation in the input space @@ -194,7 +194,7 @@ def __init__( All kwargs passed to the attribute method are provided as keyword arguments (kwargs) to this callable. - to_interp_rep_transform (callable): Function which takes a + to_interp_rep_transform (Callable): Function which takes a sample in the original input space and converts to its interpretable representation (tensor of shape 1 x num_interp_features). @@ -266,7 +266,7 @@ def attribute( Args: - inputs (tensor or tuple of tensors): Input for which LIME + inputs (Tensor or tuple of Tensor): Input for which LIME is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -274,7 +274,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which surrogate model is trained (for classification cases, this is usually the target class). @@ -300,7 +300,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -315,7 +315,7 @@ def attribute( Note that attributions are not computed with respect to these arguments. Default: None - n_samples (int, optional): The number of samples of the original + n_samples (int, optional): The number of samples of the original model used to train the surrogate interpretable model. Default: `50` if `n_samples` is not provided. perturbations_per_eval (int, optional): Allows multiple samples @@ -569,7 +569,7 @@ def default_from_interp_rep_transform(curr_sample, original_inputs, **kwargs): ), "Must provide feature_mask to use default interpretable representation transform" assert ( "baselines" in kwargs - ), "Must provide baselines to use default interpretable representation transfrom" + ), "Must provide baselines to use default interpretable representation transform" feature_mask = kwargs["feature_mask"] if isinstance(feature_mask, Tensor): binary_mask = curr_sample[0][feature_mask].bool() @@ -603,7 +603,7 @@ def get_exp_kernel_similarity_function( Args: - distance_mode (str, optional): Distance mode can be either "cosine" or + distance_mode (str, optional): Distance mode can be either "cosine" or "euclidean" corresponding to either cosine distance or Euclidean distance respectively. Distance is computed by flattening the original inputs and perturbed inputs @@ -732,7 +732,7 @@ def __init__( Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it interpretable_model (Model, optional): Model object to train interpretable model. @@ -760,14 +760,14 @@ def __init__( Note that calling fit multiple times should retrain the interpretable model, each attribution call reuses the same given interpretable model object. - similarity_func (callable, optional): Function which takes a single sample + similarity_func (Callable, optional): Function which takes a single sample along with its corresponding interpretable representation and returns the weight of the interpretable sample for training the interpretable model. This is often referred to as a similarity kernel. This argument is optional and defaults to a function which - applies an exponential kernel to the consine distance between + applies an exponential kernel to the cosine distance between the original input and perturbed input, with a kernel width of 1.0. @@ -793,7 +793,7 @@ def __init__( kwargs includes baselines, feature_mask, num_interp_features (integer, determined from feature mask). - perturb_func (callable, optional): Function which returns a single + perturb_func (Callable, optional): Function which returns a single sampled input, which is a binary vector of length num_interp_features, or a generator of such tensors. @@ -879,7 +879,7 @@ def attribute( # type: ignore Args: - inputs (tensor or tuple of tensors): Input for which LIME + inputs (Tensor or tuple of Tensor): Input for which LIME is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -887,7 +887,7 @@ def attribute( # type: ignore that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference value which replaces each feature when the corresponding interpretable feature is set to 0. @@ -913,10 +913,11 @@ def attribute( # type: ignore - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which surrogate model is trained (for classification cases, this is usually the target class). @@ -942,7 +943,7 @@ def attribute( # type: ignore target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -959,7 +960,7 @@ def attribute( # type: ignore Note that attributions are not computed with respect to these arguments. Default: None - feature_mask (tensor or tuple of tensors, optional): + feature_mask (Tensor or tuple of Tensor, optional): feature_mask defines a mask for the input, grouping features which correspond to the same interpretable feature. feature_mask @@ -977,7 +978,7 @@ def attribute( # type: ignore If None, then a feature mask is constructed which assigns each scalar within a tensor as a separate feature. Default: None - n_samples (int, optional): The number of samples of the original + n_samples (int, optional): The number of samples of the original model used to train the surrogate interpretable model. Default: `50` if `n_samples` is not provided. perturbations_per_eval (int, optional): Allows multiple samples @@ -1012,8 +1013,8 @@ def attribute( # type: ignore Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The attributions with respect to each input feature. If return_input_shape = True, attributions will be the same size as the provided inputs, with each value diff --git a/captum/attr/_core/lrp.py b/captum/attr/_core/lrp.py index e11d0b8544..d557f0ce20 100644 --- a/captum/attr/_core/lrp.py +++ b/captum/attr/_core/lrp.py @@ -45,7 +45,7 @@ def __init__(self, model: Module) -> None: r""" Args: - model (module): The forward function of the model or any modification of + model (Module): The forward function of the model or any modification of it. Custom rules for a given layer need to be defined as attribute `module.rule` and need to be of type PropagationRule. If no rule is specified for a layer, a pre-defined default rule for the module type @@ -98,7 +98,8 @@ def attribute( ]: r""" Args: - inputs (tensor or tuple of tensors): Input for which relevance is + + inputs (Tensor or tuple of Tensor): Input for which relevance is propagated. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -106,12 +107,13 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for - which gradients are computed (for classification cases, - this is usually the target class). - If the network returns a scalar value per example, - no target index is necessary. - For general 2D outputs, targets can be either: + + target (int, tuple, Tensor, or list, optional): Output indices for + which gradients are computed (for classification cases, + this is usually the target class). + If the network returns a scalar value per example, + no target index is necessary. + For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples @@ -153,9 +155,10 @@ def attribute( of rules is printed during propagation. Returns: - *tensor* or tuple of *tensors* of **attributions** - or 2-element tuple of **attributions**, **delta**:: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions** + or 2-element tuple of **attributions**, **delta**: + + - **attributions** (*Tensor* or tuple of *Tensor*): The propagated relevance values with respect to each input feature. The values are normalized by the output score value (sum(relevance)=1). To obtain values comparable to other @@ -168,10 +171,12 @@ def attribute( corresponding sized tensors is returned. The sum of attributions is one and not corresponding to the prediction score as in other implementations. - - **delta** (*tensor*, returned if return_convergence_delta=True): + + - **delta** (*Tensor*, returned if return_convergence_delta=True): Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of of examples in the inputs. + Examples:: >>> # ImageClassifier takes a single input tensor of images Nx3x32x32, @@ -241,7 +246,7 @@ def compute_convergence_delta( Args: - attributions (tensor or tuple of tensors): Attribution scores that + attributions (Tensor or tuple of Tensor): Attribution scores that are precomputed by an attribution algorithm. Attributions can be provided in form of a single tensor or a tuple of those. It is assumed that attribution @@ -249,12 +254,13 @@ def compute_convergence_delta( examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - output (tensor with single element): The output value with respect to which + output (Tensor): The output value with respect to which the attribution values are computed. This value corresponds to - the target score of a classification model. + the target score of a classification model. The given tensor + should only have a single element. Returns: - *tensor*: + *Tensor*: - **delta** Difference of relevance in output layer and input layer. """ if isinstance(attributions, tuple): diff --git a/captum/attr/_core/neuron/neuron_conductance.py b/captum/attr/_core/neuron/neuron_conductance.py index dec6b39b01..004d941cb9 100644 --- a/captum/attr/_core/neuron/neuron_conductance.py +++ b/captum/attr/_core/neuron/neuron_conductance.py @@ -45,7 +45,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which neuron attributions are computed. Attributions for a particular neuron in the input or output @@ -62,7 +62,7 @@ def __init__( Currently, it is assumed that the inputs or the outputs of the layer, depending on which one is used for attribution, can only be a single tensor. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -103,7 +103,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which neuron + inputs (Tensor or tuple of Tensor): Input for which neuron conductance is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -111,7 +111,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -143,7 +143,7 @@ def attribute( the gradient of output with respect to the intermedite neuron, which cannot be computed for aggregations of multiple intemediate neurons. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define the starting point from which integral is computed and can be provided as: @@ -172,7 +172,7 @@ def attribute( use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -197,7 +197,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -216,7 +216,7 @@ def attribute( Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. - method (string, optional): Method for approximating the integral, + method (str, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. @@ -244,8 +244,8 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Conductance for particular neuron with respect to each input feature. Attributions will always be the same size as the provided diff --git a/captum/attr/_core/neuron/neuron_deep_lift.py b/captum/attr/_core/neuron/neuron_deep_lift.py index aff216d37a..d486bdea51 100644 --- a/captum/attr/_core/neuron/neuron_deep_lift.py +++ b/captum/attr/_core/neuron/neuron_deep_lift.py @@ -46,7 +46,7 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. @@ -90,7 +90,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which layer + inputs (Tensor or tuple of Tensor): Input for which layer attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, @@ -99,7 +99,7 @@ def attribute( corresponds to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -120,7 +120,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -133,7 +133,7 @@ def attribute( or a 1D tensor with length equal to batch_size (one scalar per input example) - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference samples that are compared with the inputs. In order to assign attribution scores DeepLift computes the differences between the inputs/outputs and @@ -165,7 +165,7 @@ def attribute( use zero scalar corresponding to each input tensor. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -187,7 +187,7 @@ def attribute( attribute to the input or output, is a single tensor. Support for multiple tensors will be added later. Default: False - custom_attribution_func (callable, optional): A custom function for + custom_attribution_func (Callable, optional): A custom function for computing final attribution scores. This function can take at least one and at most three arguments with the following signature: @@ -207,7 +207,7 @@ def attribute( Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Computes attributions using Deeplift's rescale rule for particular neuron with respect to each input feature. Attributions will always be the same size as the provided @@ -273,12 +273,13 @@ class NeuronDeepLiftShap(NeuronAttribution, GradientAttribution): by the input flag `attribute_to_layer_input`. More details about the algorithm can be found here: - http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf + https://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf Note that the explanation model: 1. Assumes that input features are independent of one another 2. Is linear, meaning that the explanations are modeled through the additive composition of feature effects. + Although, it assumes a linear model for each explanation, the overall model across multiple explanations can be complex and non-linear. """ @@ -289,7 +290,7 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. @@ -334,7 +335,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which layer + inputs (Tensor or tuple of Tensor): Input for which layer attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, @@ -343,7 +344,7 @@ def attribute( corresponds to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -364,7 +365,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -376,7 +377,8 @@ def attribute( this function returns either a tensor with one element or a 1D tensor with length equal to batch_size (one scalar per input example) - baselines (tensor, tuple of tensors, callable): + + baselines (Tensor, tuple of Tensor, or Callable): Baselines define reference samples that are compared with the inputs. In order to assign attribution scores DeepLift computes the differences between the inputs/outputs and @@ -401,7 +403,7 @@ def attribute( It is recommended that the number of samples in the baselines' tensors is larger than one. - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -423,7 +425,7 @@ def attribute( attribute to the input or output, is a single tensor. Support for multiple tensors will be added later. Default: False - custom_attribution_func (callable, optional): A custom function for + custom_attribution_func (Callable, optional): A custom function for computing final attribution scores. This function can take at least one and at most three arguments with the following signature: @@ -443,7 +445,7 @@ def attribute( Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Computes attributions using Deeplift's rescale rule for particular neuron with respect to each input feature. Attributions will always be the same size as the provided diff --git a/captum/attr/_core/neuron/neuron_feature_ablation.py b/captum/attr/_core/neuron/neuron_feature_ablation.py index d706f71cb4..8ee73197da 100644 --- a/captum/attr/_core/neuron/neuron_feature_ablation.py +++ b/captum/attr/_core/neuron/neuron_feature_ablation.py @@ -35,7 +35,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Attributions for a particular neuron in the input or output @@ -44,7 +44,7 @@ def __init__( Currently, it is assumed that the inputs or the outputs of the layer, depending on which one is used for attribution, can only be a single tensor. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -67,7 +67,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which neuron + inputs (Tensor or tuple of Tensor): Input for which neuron attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -75,7 +75,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -96,7 +96,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -108,7 +108,8 @@ def attribute( this function returns either a tensor with one element or a 1D tensor with length equal to batch_size (one scalar per input example) - baselines (scalar, tensor, tuple of scalars or tensors, optional): + + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference value which replaces each feature when ablated. Baselines can be provided as: @@ -132,10 +133,11 @@ def attribute( - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -147,7 +149,7 @@ def attribute( Note that attributions are not computed with respect to these arguments. Default: None - feature_mask (tensor or tuple of tensors, optional): + feature_mask (Tensor or tuple of Tensor, optional): feature_mask defines a mask for the input, grouping features which should be ablated together. feature_mask should contain the same number of tensors as inputs. @@ -187,8 +189,8 @@ def attribute( Default: 1 Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Attributions of particular neuron with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value providing the attribution diff --git a/captum/attr/_core/neuron/neuron_gradient.py b/captum/attr/_core/neuron/neuron_gradient.py index 5292990bbf..d948dfee1a 100644 --- a/captum/attr/_core/neuron/neuron_gradient.py +++ b/captum/attr/_core/neuron/neuron_gradient.py @@ -33,7 +33,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's input or @@ -44,7 +44,7 @@ def __init__( Currently, it is assumed that the inputs or the outputs of the layer, depending on which one is used for attribution, can only be a single tensor. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -64,7 +64,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which neuron + inputs (Tensor or tuple of Tensor): Input for which neuron gradients are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -72,7 +72,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -93,7 +93,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -105,7 +105,7 @@ def attribute( this function returns either a tensor with one element or a 1D tensor with length equal to batch_size (one scalar per input example) - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -130,8 +130,8 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Gradients of particular neuron with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value providing the attribution diff --git a/captum/attr/_core/neuron/neuron_gradient_shap.py b/captum/attr/_core/neuron/neuron_gradient_shap.py index 42a543b50d..338949352e 100644 --- a/captum/attr/_core/neuron/neuron_gradient_shap.py +++ b/captum/attr/_core/neuron/neuron_gradient_shap.py @@ -18,7 +18,7 @@ class NeuronGradientShap(NeuronAttribution, GradientAttribution): #deep-learning-example-with-gradientexplainer-tensorflowkeraspytorch-models A Unified Approach to Interpreting Model Predictions - http://papers.nips.cc/paper\ + https://papers.nips.cc/paper\ 7062-a-unified-approach-to-interpreting-model-predictions GradientShap approximates SHAP values by computing the expectations of @@ -41,7 +41,7 @@ class NeuronGradientShap(NeuronAttribution, GradientAttribution): In some sense it can be viewed as an approximation of integrated gradients by computing the expectations of gradients for different baselines. - Current implementation uses Smoothgrad from `NoiseTunnel` in order to + Current implementation uses Smoothgrad from :class:`.NoiseTunnel` in order to randomly draw samples from the distribution of baselines, add noise to input samples and compute the expectation (smoothgrad). """ @@ -56,17 +56,17 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which neuron attributions are computed. The output size of the attribute method matches the - dimensions of the inputs or ouputs of the neuron with + dimensions of the inputs or outputs of the neuron with index `neuron_selector` in this layer, depending on whether we attribute to the inputs or outputs of the neuron. Currently, it is assumed that the inputs or the outputs of the neurons in this layer, depending on which one is used for attribution, can only be a single tensor. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -106,7 +106,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which SHAP attribution + inputs (Tensor or tuple of Tensor): Input for which SHAP attribution values are computed. If `forward_func` takes a single tensor as input, a single input tensor should be provided. If `forward_func` takes multiple tensors as input, a tuple @@ -114,7 +114,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -135,7 +135,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -147,7 +147,7 @@ def attribute( this function returns either a tensor with one element or a 1D tensor with length equal to batch_size (one scalar per input example) - baselines (tensor, tuple of tensors, callable): + baselines (Tensor, tuple of Tensor, or Callable): Baselines define the starting point from which expectation is computed and can be provided as: @@ -170,11 +170,11 @@ def attribute( It is recommended that the number of samples in the baselines' tensors is larger than one. - n_samples (int, optional): The number of randomly generated examples + n_samples (int, optional): The number of randomly generated examples per sample in the input batch. Random examples are generated by adding gaussian random noise to each sample. Default: `5` if `n_samples` is not provided. - stdevs (float, or a tuple of floats optional): The standard deviation + stdevs (float or tuple of float, optional): The standard deviation of gaussian noise with zero mean that is added to each input in the batch. If `stdevs` is a single float value then that same value is used for all inputs. If it is @@ -183,7 +183,7 @@ def attribute( corresponds to the input with the same index in the inputs tuple. Default: 0.0 - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It can contain a tuple of ND tensors or @@ -209,7 +209,7 @@ def attribute( Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution score computed based on GradientSHAP with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value diff --git a/captum/attr/_core/neuron/neuron_guided_backprop_deconvnet.py b/captum/attr/_core/neuron/neuron_guided_backprop_deconvnet.py index 7c69aed87a..b9a5e80b7f 100644 --- a/captum/attr/_core/neuron/neuron_guided_backprop_deconvnet.py +++ b/captum/attr/_core/neuron/neuron_guided_backprop_deconvnet.py @@ -35,7 +35,7 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place ReLU submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. @@ -48,7 +48,7 @@ def __init__( Currently, it is assumed that the inputs or the outputs of the layer, depending on which one is used for attribution, can only be a single tensor. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -69,7 +69,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -78,7 +78,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -99,7 +99,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -111,7 +111,7 @@ def attribute( this function returns either a tensor with one element or a 1D tensor with length equal to batch_size (one scalar per input example) - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -134,8 +134,8 @@ def attribute( Support for multiple tensors will be added later. Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Deconvolution attribution of particular neuron with respect to each input feature. Attributions will always be the same size as the provided @@ -207,7 +207,7 @@ def __init__( r""" Args: - model (nn.Module): The reference to PyTorch model instance. Model cannot + model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place ReLU submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. @@ -217,7 +217,7 @@ def __init__( in the attribute method. Currently, only layers with a single tensor output are supported. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -238,7 +238,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -247,7 +247,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -268,7 +268,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -280,7 +280,7 @@ def attribute( this function returns either a tensor with one element or a 1D tensor with length equal to batch_size (one scalar per input example) - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -303,8 +303,8 @@ def attribute( Support for multiple tensors will be added later. Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Guided backprop attribution of particular neuron with respect to each input feature. Attributions will always be the same size as the provided diff --git a/captum/attr/_core/neuron/neuron_integrated_gradients.py b/captum/attr/_core/neuron/neuron_integrated_gradients.py index f67aec7e7e..2afc17180f 100644 --- a/captum/attr/_core/neuron/neuron_integrated_gradients.py +++ b/captum/attr/_core/neuron/neuron_integrated_gradients.py @@ -33,7 +33,7 @@ def __init__( r""" Args: - forward_func (callable): The forward function of the model or any + forward_func (Callable): The forward function of the model or any modification of it layer (torch.nn.Module): Layer for which attributions are computed. Output size of attribute matches this layer's input or @@ -44,7 +44,7 @@ def __init__( Currently, it is assumed that the inputs or the outputs of the layer, depending on which one is used for attribution, can only be a single tensor. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model. This allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -84,7 +84,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which neuron integrated + inputs (Tensor or tuple of Tensor): Input for which neuron integrated gradients are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -92,7 +92,7 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - neuron_selector (int, callable, or tuple of ints or slices): + neuron_selector (int, Callable, tuple of int, or slice): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: @@ -113,7 +113,7 @@ def attribute( indexed output tensor is used for attribution. Note that specifying a slice of a tensor would amount to computing the attribution of the sum of the specified - neurons, and not the individual neurons independantly. + neurons, and not the individual neurons independently. - a callable, which should take the target layer as input (single tensor or tuple @@ -125,7 +125,7 @@ def attribute( this function returns either a tensor with one element or a 1D tensor with length equal to batch_size (one scalar per input example) - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define the starting point from which integral is computed. Baselines can be provided as: @@ -155,7 +155,7 @@ def attribute( use zero scalar corresponding to each input tensor. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -174,7 +174,7 @@ def attribute( Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. - method (string, optional): Method for approximating the integral, + method (str, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. @@ -202,8 +202,8 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Integrated gradients for particular neuron with respect to each input feature. Attributions will always be the same size as the provided diff --git a/captum/attr/_core/noise_tunnel.py b/captum/attr/_core/noise_tunnel.py index 0fbc32115e..eda936a048 100644 --- a/captum/attr/_core/noise_tunnel.py +++ b/captum/attr/_core/noise_tunnel.py @@ -43,10 +43,12 @@ class NoiseTunnel(Attribution): returned. More details about adding noise can be found in the following papers: - https://arxiv.org/abs/1810.03292 - https://arxiv.org/abs/1810.03307 - https://arxiv.org/abs/1706.03825 - https://arxiv.org/pdf/1806.10758 + + * https://arxiv.org/abs/1810.03292 + * https://arxiv.org/abs/1810.03307 + * https://arxiv.org/abs/1706.03825 + * https://arxiv.org/abs/1806.10758 + This method currently also supports batches of multiple examples input, however it can be computationally expensive depending on the model, the dimensionality of the data and execution environment. @@ -93,7 +95,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which integrated + inputs (Tensor or tuple of Tensor): Input for which integrated gradients are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -101,21 +103,21 @@ def attribute( that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - nt_type (string, optional): Smoothing type of the attributions. + nt_type (str, optional): Smoothing type of the attributions. `smoothgrad`, `smoothgrad_sq` or `vargrad` Default: `smoothgrad` if `type` is not provided. - nt_samples (int, optional): The number of randomly generated examples + nt_samples (int, optional): The number of randomly generated examples per sample in the input batch. Random examples are generated by adding gaussian random noise to each sample. Default: `5` if `nt_samples` is not provided. - nt_samples_batch_size (int, optional): The number of the `nt_samples` + nt_samples_batch_size (int, optional): The number of the `nt_samples` that will be processed together. With the help of this parameter we can avoid out of memory situation and reduce the number of randomly generated examples per sample in each batch. Default: None if `nt_samples_batch_size` is not provided. In this case all `nt_samples` will be processed together. - stdevs (float, or a tuple of floats optional): The standard deviation + stdevs (float or tuple of float, optional): The standard deviation of gaussian noise with zero mean that is added to each input in the batch. If `stdevs` is a single float value then that same value is used for all inputs. If it is @@ -137,7 +139,7 @@ def attribute( Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - - **attributions** (*tensor* or tuple of *tensors*): + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution with respect to each input feature. attributions will always be the same size as the provided inputs, with each value @@ -166,7 +168,7 @@ def attribute( >>> nt = NoiseTunnel(ig) >>> # Generates 10 perturbed input tensors per image. >>> # Computes integrated gradients for class 3 for each generated - >>> # input and averages attributions accros all 10 + >>> # input and averages attributions across all 10 >>> # perturbed inputs per image >>> attribution = nt.attribute(input, nt_type='smoothgrad', >>> nt_samples=10, target=3) diff --git a/captum/attr/_core/occlusion.py b/captum/attr/_core/occlusion.py index de148693fa..fedc2dae05 100644 --- a/captum/attr/_core/occlusion.py +++ b/captum/attr/_core/occlusion.py @@ -39,8 +39,8 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable): The forward function of the model or - any modification of it + forward_func (Callable): The forward function of the model or + any modification of it. """ FeatureAblation.__init__(self, forward_func) self.use_weights = True @@ -62,7 +62,7 @@ def attribute( # type: ignore r""" Args: - inputs (tensor or tuple of tensors): Input for which occlusion + inputs (Tensor or tuple of Tensor): Input for which occlusion attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -71,7 +71,7 @@ def attribute( # type: ignore to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - sliding_window_shapes (tuple or tuple of tuples): Shape of patch + sliding_window_shapes (tuple or tuple of tuple): Shape of patch (hyperrectangle) to occlude each input. For a single input tensor, this must be a tuple of length equal to the number of dimensions of the input tensor - 1, defining @@ -80,7 +80,7 @@ def attribute( # type: ignore this must be a tuple containing one tuple for each input tensor defining the dimensions of the patch for that input tensor, as described for the single tensor case. - strides (int or tuple or tuple of ints or tuple of tuples, optional): + strides (int or tuple or tuple of int or tuple of tuple, optional): This defines the step by which the occlusion hyperrectangle should be shifted by in each direction for each iteration. For a single tensor input, this can be either a single @@ -100,7 +100,7 @@ def attribute( # type: ignore If None is provided, a stride of 1 is used for each dimension of each input tensor. Default: None - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference value which replaces each feature when occluded. Baselines can be provided as: @@ -124,10 +124,11 @@ def attribute( # type: ignore - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which difference is computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -152,7 +153,7 @@ def attribute( # type: ignore target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -186,8 +187,8 @@ def attribute( # type: ignore Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The attributions with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value diff --git a/captum/attr/_core/saliency.py b/captum/attr/_core/saliency.py index 3790bd2068..505c35b28e 100644 --- a/captum/attr/_core/saliency.py +++ b/captum/attr/_core/saliency.py @@ -20,15 +20,15 @@ class Saliency(GradientAttribution): the default, the absolute value of the gradients is returned. More details about the approach can be found in the following paper: - https://arxiv.org/pdf/1312.6034.pdf + https://arxiv.org/abs/1312.6034 """ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable): The forward function of the model or - any modification of it + forward_func (Callable): The forward function of the model or + any modification of it. """ GradientAttribution.__init__(self, forward_func) @@ -43,7 +43,7 @@ def attribute( r""" Args: - inputs (tensor or tuple of tensors): Input for which saliency + inputs (Tensor or tuple of Tensor): Input for which saliency is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -52,7 +52,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -81,7 +81,7 @@ def attribute( to True, otherwise returns the (signed) gradients if False. Default: True - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -95,8 +95,8 @@ def attribute( Default: None Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The gradients with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value diff --git a/captum/attr/_core/shapley_value.py b/captum/attr/_core/shapley_value.py index 72af4e7237..4d5f244816 100644 --- a/captum/attr/_core/shapley_value.py +++ b/captum/attr/_core/shapley_value.py @@ -66,7 +66,7 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable): The forward function of the model or + forward_func (Callable): The forward function of the model or any modification of it. The forward function can either return a scalar per example, or a single scalar for the full batch. If a single scalar is returned for the batch, @@ -96,7 +96,7 @@ def attribute( Args: - inputs (tensor or tuple of tensors): Input for which Shapley value + inputs (Tensor or tuple of Tensor): Input for which Shapley value sampling attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. @@ -106,7 +106,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference value which replaces each feature when ablated. Baselines can be provided as: @@ -131,10 +131,11 @@ def attribute( - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which difference is computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -159,7 +160,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -174,7 +175,7 @@ def attribute( Note that attributions are not computed with respect to these arguments. Default: None - feature_mask (tensor or tuple of tensors, optional): + feature_mask (Tensor or tuple of Tensor, optional): feature_mask defines a mask for the input, grouping features which should be added together. feature_mask should contain the same number of tensors as inputs. @@ -196,7 +197,7 @@ def attribute( If None, then a feature mask is constructed which assigns each scalar within a tensor as a separate feature Default: None - n_samples (int, optional): The number of feature permutations + n_samples (int, optional): The number of feature permutations tested. Default: `25` if `n_samples` is not provided. perturbations_per_eval (int, optional): Allows multiple ablations @@ -218,8 +219,8 @@ def attribute( Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The attributions with respect to each input feature. If the forward function returns a scalar value per example, attributions will be @@ -519,7 +520,7 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable): The forward function of the model or + forward_func (Callable): The forward function of the model or any modification of it. The forward function can either return a scalar per example, or a single scalar for the full batch. If a single scalar is returned for the batch, @@ -548,7 +549,7 @@ def attribute( Args: - inputs (tensor or tuple of tensors): Input for which Shapley value + inputs (Tensor or tuple of Tensor): Input for which Shapley value sampling attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. @@ -558,7 +559,7 @@ def attribute( to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference value which replaces each feature when ablated. Baselines can be provided as: @@ -583,10 +584,11 @@ def attribute( - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. + In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which difference is computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -611,7 +613,7 @@ def attribute( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -626,7 +628,7 @@ def attribute( Note that attributions are not computed with respect to these arguments. Default: None - feature_mask (tensor or tuple of tensors, optional): + feature_mask (Tensor or tuple of Tensor, optional): feature_mask defines a mask for the input, grouping features which should be added together. feature_mask should contain the same number of tensors as inputs. @@ -666,8 +668,8 @@ def attribute( a simple output of progress. Default: False Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): The attributions with respect to each input feature. If the forward function returns a scalar value per example, attributions will be diff --git a/captum/attr/_models/base.py b/captum/attr/_models/base.py index d57646c0da..0b9e406d73 100644 --- a/captum/attr/_models/base.py +++ b/captum/attr/_models/base.py @@ -76,7 +76,7 @@ def indices_to_embeddings(self, *input, **kwargs): Args: - *input (Any, Optional): This can be a tensor(s) of input indices or any + *input (Any, optional): This can be a tensor(s) of input indices or any other variable necessary to comput the embeddings. A typical example of input indices are word or token indices. **kwargs (Any, optional): Similar to `input` this can be any sequence @@ -99,10 +99,10 @@ class TokenReferenceBase: `TokenReferenceBase` class. """ - def __init__(self, reference_token_idx=0) -> None: + def __init__(self, reference_token_idx: int = 0) -> None: self.reference_token_idx = reference_token_idx - def generate_reference(self, sequence_length, device): + def generate_reference(self, sequence_length, device: torch.device) -> torch.Tensor: r""" Generated reference tensor of given `sequence_length` using `reference_token_idx`. @@ -137,22 +137,25 @@ def _set_deep_layer_value(obj, layer_names, value): setattr(reduce(getattr, layer_names[:-1], obj), layer_names[-1], value) -def configure_interpretable_embedding_layer(model, embedding_layer_name="embedding"): +def configure_interpretable_embedding_layer( + model: Module, embedding_layer_name: str = "embedding" +) -> InterpretableEmbeddingBase: r""" - This method wraps model's embedding layer with an interpretable embedding + This method wraps a model's embedding layer with an interpretable embedding layer that allows us to access the embeddings through their indices. Args: - model (torch.nn.Model): An instance of PyTorch model that contains embeddings. + model (torch.nn.Module): An instance of PyTorch model that contains embeddings. embedding_layer_name (str, optional): The name of the embedding layer in the `model` that we would like to make interpretable. Returns: - interpretable_emb (tensor): An instance of `InterpretableEmbeddingBase` - embedding layer that wraps model's embedding layer that is being - accessed through `embedding_layer_name`. + interpretable_emb (InterpretableEmbeddingBase): An instance of + `InterpretableEmbeddingBase` embedding layer that wraps model's + embedding layer that is being accessed through + `embedding_layer_name`. Examples:: @@ -202,7 +205,9 @@ def configure_interpretable_embedding_layer(model, embedding_layer_name="embeddi return interpretable_emb -def remove_interpretable_embedding_layer(model, interpretable_emb): +def remove_interpretable_embedding_layer( + model: Module, interpretable_emb: InterpretableEmbeddingBase +) -> None: r""" Removes interpretable embedding layer and sets back original embedding layer in the model. @@ -210,8 +215,8 @@ def remove_interpretable_embedding_layer(model, interpretable_emb): Args: model (torch.nn.Module): An instance of PyTorch model that contains embeddings - interpretable_emb (tensor): An instance of `InterpretableEmbeddingBase` - that was originally created in + interpretable_emb (InterpretableEmbeddingBase): An instance of + `InterpretableEmbeddingBase` that was originally created in `configure_interpretable_embedding_layer` function and has to be removed after interpretation is finished. diff --git a/captum/attr/_utils/approximation_methods.py b/captum/attr/_utils/approximation_methods.py index 9d63e90c1a..755e701d6a 100644 --- a/captum/attr/_utils/approximation_methods.py +++ b/captum/attr/_utils/approximation_methods.py @@ -28,7 +28,7 @@ def approximation_parameters( r"""Retrieves parameters for the input approximation `method` Args: - method: The name of the approximation method. Currently only `riemann` + method (str): The name of the approximation method. Currently only `riemann` and gauss legendre are """ if method in SUPPORTED_RIEMANN_METHODS: @@ -45,17 +45,16 @@ def riemann_builders( Args: - n: The number of integration steps - method: `left`, `right`, `middle` and `trapezoid` riemann + method (Riemann): `left`, `right`, `middle` and `trapezoid` riemann Returns: 2-element tuple of **step_sizes**, **alphas**: - - **step_sizes** (*callable*): + - **step_sizes** (*Callable*): `step_sizes` takes the number of steps as an input argument and returns an array of steps sizes which sum is smaller than or equal to one. - - **alphas** (*callable*): + - **alphas** (*Callable*): `alphas` takes the number of steps as an input argument and returns the multipliers/coefficients for the inputs of integrand in the range of [0, 1] @@ -104,18 +103,14 @@ def gauss_legendre_builders() -> Tuple[ proposed by [Xue Feng and her intern Hauroun Habeeb] (https://research.fb.com/people/feng-xue/). - Args: - - n (int): The number of integration steps - Returns: 2-element tuple of **step_sizes**, **alphas**: - - **step_sizes** (*callable*): + - **step_sizes** (*Callable*): `step_sizes` takes the number of steps as an input argument and returns an array of steps sizes which sum is smaller than or equal to one. - - **alphas** (*callable*): + - **alphas** (*Callable*): `alphas` takes the number of steps as an input argument and returns the multipliers/coefficients for the inputs of integrand in the range of [0, 1] diff --git a/captum/attr/_utils/attribution.py b/captum/attr/_utils/attribution.py index f4b6e9d35c..fed579eb92 100644 --- a/captum/attr/_utils/attribution.py +++ b/captum/attr/_utils/attribution.py @@ -31,7 +31,7 @@ class Attribution: def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of model's forward function. """ @@ -47,17 +47,17 @@ def __init__(self, forward_func: Callable) -> None: Args: - inputs (tensor or tuple of tensors): Input for which attribution + inputs (Tensor or tuple of Tensor): Input for which attribution is computed. It can be provided as a single tensor or a tuple of multiple tensors. If multiple input tensors - are provided, the batch sizes must be aligned accross all + are provided, the batch sizes must be aligned across all tensors. Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution values for each input tensor. The `attributions` have the same shape and dimensionality as the inputs. @@ -97,21 +97,21 @@ def has_convergence_delta(self) -> bool: Args: - attributions (tensor or tuple of tensors): Attribution scores that + attributions (Tensor or tuple of Tensor): Attribution scores that are precomputed by an attribution algorithm. Attributions can be provided in form of a single tensor or a tuple of those. It is assumed that attribution tensor's dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - *args (optional): Additonal arguments that are used by the + *args (Any, optional): Additonal arguments that are used by the sub-classes depending on the specific implementation of `compute_convergence_delta`. Returns: - *tensor* of **deltas**: - - **deltas** (*tensor*): + *Tensor* of **deltas**: + - **deltas** (*Tensor*): Depending on specific implementaion of sub-classes, convergence delta can be returned per sample in form of a tensor or it can be aggregated @@ -150,7 +150,7 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of model's forward function. """ @@ -184,26 +184,26 @@ def compute_convergence_delta( Args: - attributions (tensor or tuple of tensors): Precomputed attribution + attributions (Tensor or tuple of Tensor): Precomputed attribution scores. The user can compute those using any attribution - algorithm. It is assumed the the shape and the + algorithm. It is assumed the shape and the dimensionality of attributions must match the shape and the dimensionality of `start_point` and `end_point`. It also assumes that the attribution tensor's dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. - start_point (tensor or tuple of tensors, optional): `start_point` + start_point (Tensor or tuple of Tensor, optional): `start_point` is passed as an input to model's forward function. It is the starting point of attributions' approximation. It is assumed that both `start_point` and `end_point` have the same shape and dimensionality. - end_point (tensor or tuple of tensors): `end_point` + end_point (Tensor or tuple of Tensor): `end_point` is passed as an input to model's forward function. It is the end point of attributions' approximation. It is assumed that both `start_point` and `end_point` have the same shape and dimensionality. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -228,7 +228,7 @@ def compute_convergence_delta( target for the corresponding example. Default: None - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -245,8 +245,8 @@ def compute_convergence_delta( Returns: - *tensor* of **deltas**: - - **deltas** (*tensor*): + *Tensor* of **deltas**: + - **deltas** (*Tensor*): This implementation returns convergence delta per sample. Deriving sub-classes may do any type of aggregation of those values, if necessary. @@ -306,7 +306,7 @@ def __init__(self, forward_func: Callable) -> None: r""" Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of model's forward function. """ @@ -318,12 +318,13 @@ def multiplies_by_inputs(self): class InternalAttribution(Attribution, Generic[ModuleOrModuleList]): - layer: ModuleOrModuleList r""" Shared base class for LayerAttrubution and NeuronAttribution, attribution types that require a model and a particular layer. """ + layer: ModuleOrModuleList + def __init__( self, forward_func: Callable, @@ -333,12 +334,12 @@ def __init__( r""" Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of model's forward function. layer (torch.nn.Module): Layer for which output attributions are computed. Output size of attribute matches that of layer output. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model, which allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -351,7 +352,7 @@ def __init__( class LayerAttribution(InternalAttribution): r""" - Layer attribution provides attribution values for the given layer, quanitfying + Layer attribution provides attribution values for the given layer, quantifying the importance of each neuron within the given layer's output. The output attribution of calling attribute on a LayerAttribution object always matches the size of the layer output. @@ -366,12 +367,12 @@ def __init__( r""" Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of model's forward function. layer (torch.nn.Module): Layer for which output attributions are computed. Output size of attribute matches that of layer output. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model, which allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -392,13 +393,13 @@ def interpolate( Args: - layer_attribution (torch.Tensor): Tensor of given layer attributions. + layer_attribution (Tensor): Tensor of given layer attributions. interpolate_dims (int or tuple): Upsampled dimensions. The number of elements must be the number of dimensions of layer_attribution - 2, since the first dimension corresponds to number of examples and the second is assumed to correspond to the number of channels. - interpolate_mode (str): Method for interpolation, which + interpolate_mode (str): Method for interpolation, which must be a valid input interpolation mode for torch.nn.functional. These methods are "nearest", "area", "linear" (3D-only), "bilinear" @@ -407,8 +408,8 @@ def interpolate( attribution. Returns: - *tensor* of upsampled **attributions**: - - **attributions** (*tensor*): + *Tensor* of upsampled **attributions**: + - **attributions** (*Tensor*): Upsampled layer attributions with first 2 dimensions matching slayer_attribution and remaining dimensions given by interpolate_dims. @@ -418,7 +419,7 @@ def interpolate( class NeuronAttribution(InternalAttribution): r""" - Neuron attribution provides input attribution for a given neuron, quanitfying + Neuron attribution provides input attribution for a given neuron, quantifying the importance of each input feature in the activation of a particular neuron. Calling attribute on a NeuronAttribution object requires also providing the index of the neuron in the output of the given layer for which attributions @@ -436,12 +437,12 @@ def __init__( r""" Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of model's forward function. layer (torch.nn.Module): Layer for which output attributions are computed. Output size of attribute matches that of layer output. - device_ids (list(int)): Device ID list, necessary only if forward_func + device_ids (list[int]): Device ID list, necessary only if forward_func applies a DataParallel model, which allows reconstruction of intermediate outputs from batched results across devices. If forward_func is given as the DataParallel model itself, @@ -469,8 +470,8 @@ def __init__( Returns: - *tensor* or tuple of *tensors* of **attributions**: - - **attributions** (*tensor* or tuple of *tensors*): + *Tensor* or tuple of *Tensor* of **attributions**: + - **attributions** (*Tensor* or tuple of *Tensor*): Attribution values for each input vector. The `attributions` have the dimensionality of inputs. diff --git a/captum/attr/_utils/class_summarizer.py b/captum/attr/_utils/class_summarizer.py index 2485711866..664088c299 100644 --- a/captum/attr/_utils/class_summarizer.py +++ b/captum/attr/_utils/class_summarizer.py @@ -36,11 +36,11 @@ def update( # type: ignore This accepts either a single tensor to summarise or a tuple of tensors. Args: - x (Tensor or Tuple[Tensor, ...]): + x (Tensor or tuple of Tensor): The input tensor to be summarised. The first dimension of this input must be associated to the batch size of the inputs. - labels (int, tuple, tensor or list, optional): + labels (int, tuple, Tensor, or list, optional): The associated labels for `x`. If Any, we assume `labels` represents the label for all inputs in `x`. diff --git a/captum/attr/_utils/summarizer.py b/captum/attr/_utils/summarizer.py index 874e5d263b..e4c5c860a0 100644 --- a/captum/attr/_utils/summarizer.py +++ b/captum/attr/_utils/summarizer.py @@ -173,10 +173,10 @@ class SummarizerSingleTensor: def __init__(self, stats: List[Stat], summary_stats_indices: List[int]) -> None: r""" Args: - stats (list of Stat): A list of all the Stat objects that + stats (list[Stat]): A list of all the Stat objects that need to be updated. This must be in the appropriate order for updates (see `_reorder_stats`) - summary_stats (list of int): A list of indicies, referencing `stats`, + summary_stats (list[int]): A list of indicies, referencing `stats`, which are the stats you want to show in the .summary property. This does not require any specific order. """ diff --git a/captum/attr/_utils/visualization.py b/captum/attr/_utils/visualization.py index 0cfada9b7b..c4da31b6d6 100644 --- a/captum/attr/_utils/visualization.py +++ b/captum/attr/_utils/visualization.py @@ -118,18 +118,18 @@ def visualize_image_attr( Args: - attr (numpy.array): Numpy array corresponding to attributions to be + attr (numpy.ndarray): Numpy array corresponding to attributions to be visualized. Shape must be in the form (H, W, C), with channels as last dimension. Shape must also match that of the original image if provided. - original_image (numpy.array, optional): Numpy array corresponding to + original_image (numpy.ndarray, optional): Numpy array corresponding to original image. Shape must be in the form (H, W, C), with channels as the last dimension. Image can be provided either with float values in range 0-1 or int values between 0-255. This is a necessary argument for any visualization method which utilizes the original image. Default: None - method (string, optional): Chosen method for visualizing attribution. + method (str, optional): Chosen method for visualizing attribution. Supported options are: 1. `heat_map` - Display heat map of chosen attributions @@ -145,8 +145,9 @@ def visualize_image_attr( 5. `alpha_scaling` - Sets alpha channel of each pixel to be equal to normalized attribution value. + Default: `heat_map` - sign (string, optional): Chosen sign of attributions to visualize. Supported + sign (str, optional): Chosen sign of attributions to visualize. Supported options are: 1. `positive` - Displays only positive pixel attributions. @@ -160,6 +161,7 @@ def visualize_image_attr( values. This is not supported for `masked_image` or `alpha_scaling` modes, since signed information cannot be represented in these modes. + Default: `absolute_value` plt_fig_axis (tuple, optional): Tuple of matplotlib.pyplot.figure and axis on which to visualize. If None is provided, then a new figure @@ -172,7 +174,7 @@ def visualize_image_attr( and scale value are computed using absolute value of attributions. Default: 2 - cmap (string, optional): String corresponding to desired colormap for + cmap (str, optional): String corresponding to desired colormap for heatmap visualization. This defaults to "Reds" for negative sign, "Blues" for absolute value, "Greens" for positive sign, and a spectrum from red to green for all. Note that this @@ -182,18 +184,18 @@ def visualize_image_attr( `blended_heat_map` visualization mode, which overlays the heat map over the greyscaled original image. Default: 0.5 - show_colorbar (boolean, optional): Displays colorbar for heatmap below + show_colorbar (bool, optional): Displays colorbar for heatmap below the visualization. If given method does not use a heatmap, then a colormap axis is created and hidden. This is necessary for appropriate alignment when visualizing multiple plots, some with colorbars and some without. Default: False - title (string, optional): Title string for plot. If None, no title is + title (str, optional): Title string for plot. If None, no title is set. Default: None fig_size (tuple, optional): Size of figure created. Default: (6,6) - use_pyplot (boolean, optional): If true, uses pyplot to create and show + use_pyplot (bool, optional): If true, uses pyplot to create and show figure and displays the figure after creating. If False, uses Matplotlib object oriented API and simply returns a figure object without showing. @@ -347,29 +349,29 @@ def visualize_image_attr_multiple( Args: - attr (numpy.array): Numpy array corresponding to attributions to be + attr (numpy.ndarray): Numpy array corresponding to attributions to be visualized. Shape must be in the form (H, W, C), with channels as last dimension. Shape must also match that of the original image if provided. - original_image (numpy.array, optional): Numpy array corresponding to + original_image (numpy.ndarray, optional): Numpy array corresponding to original image. Shape must be in the form (H, W, C), with channels as the last dimension. Image can be provided either with values in range 0-1 or 0-255. This is a necessary argument for any visualization method which utilizes the original image. - methods (list of strings): List of strings of length k, defining method + methods (list[str]): List of strings of length k, defining method for each visualization. Each method must be a valid string argument for method to visualize_image_attr. - signs (list of strings): List of strings of length k, defining signs for + signs (list[str]): List of strings of length k, defining signs for each visualization. Each sign must be a valid string argument for sign to visualize_image_attr. - titles (list of strings, optional): List of strings of length k, providing + titles (list[str], optional): List of strings of length k, providing a title string for each plot. If None is provided, no titles are added to subplots. Default: None fig_size (tuple, optional): Size of figure created. Default: (8, 6) - use_pyplot (boolean, optional): If true, uses pyplot to create and show + use_pyplot (bool, optional): If true, uses pyplot to create and show figure and displays the figure after creating. If False, uses Matplotlib object oriented API and simply returns a figure object without showing. @@ -460,19 +462,19 @@ def visualize_timeseries_attr( Args: - attr (numpy.array): Numpy array corresponding to attributions to be + attr (numpy.ndarray): Numpy array corresponding to attributions to be visualized. Shape must be in the form (N, C) with channels as last dimension, unless `channels_last` is set to True. Shape must also match that of the timeseries data. - data (numpy.array): Numpy array corresponding to the original, + data (numpy.ndarray): Numpy array corresponding to the original, equidistant timeseries data. Shape must be in the form (N, C) with channels as last dimension, unless `channels_last` is set to true. - x_values (numpy.array, optional): Numpy array corresponding to the + x_values (numpy.ndarray, optional): Numpy array corresponding to the points on the x-axis. Shape must be in the form (N, ). If not provided, integers from 0 to N-1 are used. Default: None - method (string, optional): Chosen method for visualizing attributions + method (str, optional): Chosen method for visualizing attributions overlaid onto data. Supported options are: 1. `overlay_individual` - Plot each channel individually in @@ -487,8 +489,9 @@ def visualize_timeseries_attr( and color the graphs according to the attribution values. Works best with color maps that does not contain white or very bright colors. + Default: `overlay_individual` - sign (string, optional): Chosen sign of attributions to visualize. + sign (str, optional): Chosen sign of attributions to visualize. Supported options are: 1. `positive` - Displays only positive pixel attributions. @@ -500,8 +503,9 @@ def visualize_timeseries_attr( 4. `all` - Displays both positive and negative attribution values. + Default: `absolute_value` - channel_labels (list of strings, optional): List of labels + channel_labels (list[str], optional): List of labels corresponding to each channel in data. Default: None channels_last (bool, optional): If True, data is expected to have @@ -519,7 +523,7 @@ def visualize_timeseries_attr( and scale value are computed using absolute value of attributions. Default: 2 - cmap (string, optional): String corresponding to desired colormap for + cmap (str, optional): String corresponding to desired colormap for heatmap visualization. This defaults to "Reds" for negative sign, "Blues" for absolute value, "Greens" for positive sign, and a spectrum from red to green for all. Note that this @@ -529,14 +533,14 @@ def visualize_timeseries_attr( `blended_heat_map` visualization mode, which overlays the heat map over the greyscaled original image. Default: 0.7 - show_colorbar (boolean): Displays colorbar for heat map below + show_colorbar (bool): Displays colorbar for heat map below the visualization. - title (string, optional): Title string for plot. If None, no title is + title (str, optional): Title string for plot. If None, no title is set. Default: None fig_size (tuple, optional): Size of figure created. Default: (6,6) - use_pyplot (boolean): If true, uses pyplot to create and show + use_pyplot (bool): If true, uses pyplot to create and show figure and displays the figure after creating. If False, uses Matplotlib object oriented API and simply returns a figure object without showing. diff --git a/captum/concept/_core/cav.py b/captum/concept/_core/cav.py index 39aa9fba85..6aedb24fff 100644 --- a/captum/concept/_core/cav.py +++ b/captum/concept/_core/cav.py @@ -14,7 +14,7 @@ class CAV: boundary of a classifier which distinguishes between activation vectors produced by different concepts. More details can be found in the paper: - https://arxiv.org/pdf/1711.11279.pdf + https://arxiv.org/abs/1711.11279 """ def __init__( @@ -65,7 +65,7 @@ def assemble_save_path( layer name. model_id (str): A unique model identifier associated with input `layer` and `concepts` - concepts (list(Concept)): A list of concepts that are concatenated + concepts (list[Concept]): A list of concepts that are concatenated together and used as a concept key using their ids. These concept ids are retrieved from TCAV s`Concept` objects. layer (str): The name of the layer for which the activations are @@ -146,7 +146,7 @@ def load(cavs_path: str, model_id: str, concepts: List[Concept], layer: str): model_id (str): A unique model identifier associated with the CAVs. There exist a folder named `model_id` under `cavs_path` path. The CAVs are loaded from this folder. - concepts (list[Concept]): A List of concepts for which + concepts (list[Concept]): A List of concepts for which we would like to load the cavs. layer (str): The layer name. Ex.: "inception4c". In case of nested layers we use dots to specify the depth / hierarchy. diff --git a/captum/concept/_core/concept.py b/captum/concept/_core/concept.py index a550ab8a9d..b0adbd7f39 100644 --- a/captum/concept/_core/concept.py +++ b/captum/concept/_core/concept.py @@ -25,7 +25,7 @@ def __init__( r""" Args: - id (int): The unique identifier of the concept. + id (int): The unique identifier of the concept. name (str): A unique name of the concept. data_iter (DataLoader): A pytorch DataLoader object that combines a dataset and a sampler, and provides an iterable over a given @@ -35,6 +35,7 @@ def __init__( https://pytorch.org/docs/stable/data.html Example:: + >>> # Creates a Concept object named "striped", with a data_iter >>> # object to iterate over all files in "./concepts/striped" >>> concept_name = "striped" @@ -79,7 +80,7 @@ def __init__(self, model: Module) -> None: Args: - inputs (tensor or tuple of tensors): Inputs for which concept-based + inputs (Tensor or tuple of Tensor): Inputs for which concept-based interpretation scores are computed. It can be provided as a single tensor or a tuple of multiple tensors. If multiple input tensors are provided, the batch size (the first diff --git a/captum/concept/_core/tcav.py b/captum/concept/_core/tcav.py index 8b6c996856..64977901ef 100644 --- a/captum/concept/_core/tcav.py +++ b/captum/concept/_core/tcav.py @@ -37,11 +37,13 @@ def __init__(self, datasets: List[AV.AVDataset], labels: List[int]) -> None: However, __get_item__ not only returns a batch of activation vectors, but also a batch of labels indicating which concept that batch of activation vectors is associated with. + Args: + datasets (list[Dataset]): The k-th element of datasets is a Dataset representing activation vectors associated with the k-th concept - labels (list[Int]): The k-th element of labels is the integer label + labels (list[int]): The k-th element of labels is the integer label associated with the k-th concept """ assert len(datasets) == len( @@ -69,16 +71,17 @@ def _i_to_k(self, i): else: right = mid - def __getitem__(self, i): + def __getitem__(self, i: int): """ Returns a batch of activation vectors, as well as a batch of labels indicating which concept the batch of activation vectors is associated with. - args: + Args: + i (int): which (activation vector, label) batch in the dataset to return - returns: + Returns: inputs (Tensor): i-th batch in Dataset (representing activation vectors) labels (Tensor): labels of i-th batch in Dataset @@ -91,7 +94,7 @@ def __getitem__(self, i): labels = torch.tensor([self.labels[k]] * inputs.size(0), device=inputs.device) return inputs, labels - def __len__(self): + def __len__(self) -> int: """ returns the total number of batches in the labelled_dataset """ @@ -113,6 +116,7 @@ def train_cav( Please see the TCAV class documentation for further information. Args: + model_id (str): A unique identifier for the PyTorch model for which we would like to load the layer activations and train a model in order to compute CAVs. @@ -120,7 +124,7 @@ def train_cav( to train a classifier and learn decision boundaries between those concepts for each layer defined in the `layers` argument. - layers (str, list[str]): A list of layer names or a single layer + layers (str or list[str]): A list of layer names or a single layer name that is used to compute the activations of all concept examples per concept and train a classifier using those activations. @@ -203,7 +207,7 @@ class TCAV(ConceptInterpreter): This class implements ConceptInterpreter abstract class using an approach called Testing with Concept Activation Vectors (TCAVs), as described in the paper: - https://arxiv.org/pdf/1711.11279.pdf + https://arxiv.org/abs/1711.11279 TCAV scores for a given layer, a list of concepts and input example are computed using the dot product between prediction's layer @@ -251,9 +255,10 @@ def __init__( ) -> None: r""" Args: + model (Module): An instance of pytorch model that is used to compute layer activations and attributions. - layers (str, list[str]): A list of layer name(s) that are + layers (str or list[str]): A list of layer name(s) that are used for computing concept activations (cavs) and layer attributions. model_id (str, optional): A unique identifier for the PyTorch `model` @@ -275,7 +280,7 @@ def __init__( attribution algorithm. save_path (str, optional): The path for storing CAVs and Activation Vectors (AVs). - classifier_kwargs (any, optional): Additional arguments such as + classifier_kwargs (Any, optional): Additional arguments such as `test_split_ratio` that are passed to concept `classifier`. Examples:: @@ -342,7 +347,7 @@ def generate_activation(self, layers: Union[str, List], concept: Concept) -> Non the list of layer(s) `layers`. Args: - layers (str, list[str]): A list of layer names or a layer name + layers (str or list[str]): A list of layer names or a layer name that is used to compute layer activations for the specific `concept`. concept (Concept): A single Concept object that provides access @@ -403,6 +408,7 @@ def load_cavs( of concepts and layer. Args: + concepts (list[Concept]): A list of Concept objects for which we want to load the CAV. @@ -458,6 +464,7 @@ def compute_cavs( the argument. Args: + experimental_sets (list[list[Concept]]): A list of lists of concept instances for which the cavs will be computed. force_train (bool, optional): A flag that indicates whether to @@ -469,6 +476,7 @@ def compute_cavs( multi-processing, otherwise it will be performed sequentially in a single process. Default: None + Returns: cavs (dict) : A mapping of concept ids and layers to CAV objects. If CAVs for the concept_ids-layer pairs are present in the @@ -569,7 +577,8 @@ def interpret( scores for specific predictions and CAV vectors. Args: - inputs (tensor or tuple of tensors): Inputs for which predictions + + inputs (Tensor or tuple of Tensor): Inputs for which predictions are performed and attributions are computed. If model takes a single tensor as input, a single input tensor should be provided. @@ -581,7 +590,7 @@ def interpret( provided, the examples must be aligned appropriately. experimental_sets (list[list[Concept]]): A list of list of Concept instances. - target (int, tuple, tensor or list, optional): Output indices for + target (int, tuple, Tensor, or list, optional): Output indices for which attributions are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, @@ -617,6 +626,7 @@ def interpret( attribution algorithm's attribute method. This could be for example `n_steps` in case of integrated gradients. Default: None + Returns: results (dict): A dictionary of sign and magnitude -based tcav scores for each concept set per layer. diff --git a/captum/concept/_utils/classifier.py b/captum/concept/_utils/classifier.py index 5bdf605470..b8ba7d0a59 100644 --- a/captum/concept/_utils/classifier.py +++ b/captum/concept/_utils/classifier.py @@ -95,7 +95,7 @@ def weights(self) -> Tensor: C is the number of classes and F is the number of features. Returns: - weights (tensor): A torch Tensor with the weights resulting from + weights (Tensor): A torch Tensor with the weights resulting from the model training. """ pass @@ -189,10 +189,10 @@ def weights(self) -> Tensor: r""" This function returns a C x F tensor weights, where C is the number of classes and F is the number of features. - In case of binary classification, C = 2 othewise it is > 2. + In case of binary classification, C = 2 otherwise it is > 2. Returns: - weights (tensor): A torch Tensor with the weights resulting from + weights (Tensor): A torch Tensor with the weights resulting from the model training. """ assert self.lm.linear is not None, ( diff --git a/captum/concept/_utils/data_iterator.py b/captum/concept/_utils/data_iterator.py index 6a8a48f197..574bc71ae7 100644 --- a/captum/concept/_utils/data_iterator.py +++ b/captum/concept/_utils/data_iterator.py @@ -16,7 +16,7 @@ class CustomIterableDataset(IterableDataset): def __init__(self, transform_filename_to_tensor: Callable, path: str) -> None: r""" Args: - transform_filename_to_tensor (callable): Function to read a data + transform_filename_to_tensor (Callable): Function to read a data file from path and return a tensor from that file. path (str): Path to dataset files. This can be either a path to a directory or a file where input examples are stored. diff --git a/captum/influence/_core/similarity_influence.py b/captum/influence/_core/similarity_influence.py index 0fd21eedb7..db1484466e 100644 --- a/captum/influence/_core/similarity_influence.py +++ b/captum/influence/_core/similarity_influence.py @@ -82,7 +82,7 @@ def __init__( Args: module (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. - layers (str or List of str): The fully qualified layer(s) for which the + layers (str or list[str]): The fully qualified layer(s) for which the activation vectors are computed. influence_src_dataset (torch.utils.data.Dataset): PyTorch Dataset that is used to create a PyTorch Dataloader to iterate over the dataset and @@ -166,13 +166,13 @@ def influence( # type: ignore[override] ) -> Dict: r""" Args: - inputs (tensor or tuple of tensors): Batch of examples for which influential + inputs (Tensor or tuple of Tensor): Batch of examples for which influential instances are computed. They are passed to the forward_func. The first dimension in `inputs` tensor or tuple of tensors corresponds to the batch size. A tuple of tensors is only passed in if this is the input form that `module` accepts. top_k (int): The number of top-matching activations to return - additional_forward_args (optional): Additional arguments that will be + additional_forward_args (Any, optional): Additional arguments that will be passed to forward_func after inputs. load_src_from_disk (bool): Loads activations for `influence_src_dataset` where possible. Setting to False would force regeneration of diff --git a/captum/influence/_core/tracincp.py b/captum/influence/_core/tracincp.py index 15811e684b..8cb2ac7bfc 100644 --- a/captum/influence/_core/tracincp.py +++ b/captum/influence/_core/tracincp.py @@ -45,7 +45,7 @@ Implements abstract DataInfluence class and provides implementation details for influence computation based on the logic provided in TracIn paper -(https://arxiv.org/pdf/2002.08484.pdf). +(https://arxiv.org/abs/2002.08484). The TracIn paper proposes an idealized notion of influence which can be represented by the total amount a training example reduces loss for a test example via a training @@ -105,9 +105,10 @@ def __init__( ) -> None: r""" Args: + model (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. - train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.data.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -131,7 +132,7 @@ def __init__( `model` accepts `L-1` arguments, and the last element of `batch` is the label. In other words, `model(*batch[:-1])` gives the output of `model`, and `batch[-1]` are the labels for the batch. - checkpoints (str or List of str or Iterator): Either the directory of the + checkpoints (str, list[str], or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which returns objects from which to load checkpoints. @@ -140,7 +141,7 @@ def __init__( learning rate if it is saved. By default uses a utility to load a model saved as a state dict. Default: _load_flexible_state_dict - layers (List of str or None, optional): A list of layer names for which + layers (list[str] or None, optional): A list of layer names for which gradients should be computed. If `layers` is None, gradients will be computed for all layers. Otherwise, they will only be computed for the layers specified in `layers`. @@ -215,7 +216,7 @@ def self_influence( with are not too large, so that there will not be an out-of-memory error. Args: - batches (Tuple, or DataLoader): Either a single tuple of any, or a + batches (tuple or DataLoader): Either a single tuple of any, or a `DataLoader`, where each batch yielded is a tuple of any. In either case, the tuple represents a single batch, where the last element is assumed to be the labels for the batch. That is, @@ -227,7 +228,7 @@ def self_influence( more details on the assumed structure of a batch. show_progress (bool, optional): Computation of self influence scores can take a long time if `inputs_dataset` represents many examples. If - `show_progress`is true, the progress of this computation will be + `show_progress` is true, the progress of this computation will be displayed. In more detail, this computation will iterate over all checkpoints (provided as the `checkpoints` initialization argument) in an outer loop, and iterate over all batches that @@ -261,9 +262,10 @@ def _get_k_most_influential( ) -> KMostInfluentialResults: r""" Args: - inputs (Tuple of Any): A tuple that represents a batch of examples. It does + + inputs (tuple of Any): A tuple that represents a batch of examples. It does not represent labels, which are passed as `targets`. - targets (tensor, optional): If computing influence scores on a loss + targets (Tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. Default: None k (int, optional): The number of proponents or opponents to return per test @@ -274,7 +276,7 @@ def _get_k_most_influential( Default: True show_progress (bool, optional): To compute the proponents (or opponents) for the batch of examples, we perform computation for each batch in - training dataset `train_dataset`, If `show_progress`is + training dataset `train_dataset`, If `show_progress` is true, the progress of this computation will be displayed. In particular, the number of batches for which the computation has been performed will be displayed. It will try to use tqdm if @@ -309,23 +311,24 @@ def _influence( ) -> Tensor: r""" Args: - inputs (Tuple of Any): A batch of examples. Does not represent labels, + + inputs (tuple of Any): A batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that `model(*inputs)` produces the predictions for the batch. - targets (tensor, optional): If computing influence scores on a loss + targets (Tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. Default: None Returns: - influence_scores (tensor): Influence scores over the entire + influence_scores (Tensor): Influence scores over the entire training dataset `train_dataset`. Dimensionality is (inputs_batch_size, src_dataset_size). For example: influence_scores[i][j] = the influence score for the j-th training example to the i-th input example. show_progress (bool, optional): To compute the influence of examples in training dataset `train_dataset`, we compute the influence - of each batch. If `show_progress`is true, the progress of this + of each batch. If `show_progress` is true, the progress of this computation will be displayed. In particular, the number of batches for which influence has been computed will be displayed. It will try to use tqdm if available for advanced features (e.g. time @@ -369,6 +372,7 @@ def influence( # type: ignore[override] opponent) on the test example. Args: + inputs (Any, optional): If not provided or `None`, the self influence mode will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential @@ -380,7 +384,7 @@ def influence( # type: ignore[override] `inputs` will need to be a tuple. In other words, `inputs` will be unpacked as an argument when passing to `model`. Default: None - targets (tensor, optional): If computing influence scores on a loss + targets (Tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. Default: None k (int, optional): If not provided or `None`, the influence score mode will @@ -399,7 +403,7 @@ def influence( # type: ignore[override] show_progress (bool, optional): For all modes, computation of results requires "training dataset computations": computations for each batch in the training dataset `train_dataset`, which may - take a long time. If `show_progress`is true, the progress of + take a long time. If `show_progress` is true, the progress of "training dataset computations" will be displayed. In particular, the number of batches for which computations have been performed will be displayed. It will try to use tqdm if available for @@ -501,9 +505,10 @@ def __init__( ) -> None: r""" Args: + model (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. - train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.data.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -527,7 +532,7 @@ def __init__( `model` accepts `L-1` arguments, and the last element of `batch` is the label. In other words, `model(*batch[:-1])` gives the output of `model`, and `batch[-1]` are the labels for the batch. - checkpoints (str or List of str or Iterator): Either the directory of the + checkpoints (str, list[str], or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which returns objects from which to load checkpoints. @@ -536,7 +541,7 @@ def __init__( learning rate if it is saved. By default uses a utility to load a model saved as a state dict. Default: _load_flexible_state_dict - layers (List of str or None, optional): A list of layer names for which + layers (list[str] or None, optional): A list of layer names for which gradients should be computed. If `layers` is None, gradients will be computed for all layers. Otherwise, they will only be computed for the layers specified in `layers`. @@ -698,6 +703,7 @@ def influence( # type: ignore[override] opponent) on the test example. Args: + inputs (Any, optional): If not provided or `None`, the self influence mode will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential @@ -709,7 +715,7 @@ def influence( # type: ignore[override] `inputs` will need to be a tuple. In other words, `inputs` will be unpacked as an argument when passing to `model`. Default: None - targets (tensor, optional): If computing influence scores on a loss + targets (Tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. Default: None k (int, optional): If not provided or `None`, the influence score mode will @@ -728,7 +734,7 @@ def influence( # type: ignore[override] show_progress (bool, optional): For all modes, computation of results requires "training dataset computations": computations for each batch in the training dataset `train_dataset`, which may - take a long time. If `show_progress`is true, the progress of + take a long time. If `show_progress` is true, the progress of "training dataset computations" will be displayed. It will try to use tqdm if available for advanced features (e.g. time estimation). Otherwise, it will fallback to a simple output of progress. @@ -827,15 +833,16 @@ def _influence( output of `self._basic_computation_tracincp`. Args: - inputs (Tuple of Any): A test batch of examples. Does not represent labels, + + inputs (tuple of Any): A test batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that `model(*inputs)` produces the predictions for the batch. - targets (tensor, optional): If computing influence scores on a loss + targets (Tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. Default: None show_progress (bool, optional): To compute the influence of examples in training dataset `train_dataset`, we compute the influence - of each batch. If `show_progress`is true, the progress of this + of each batch. If `show_progress` is true, the progress of this computation will be displayed. In particular, the number of batches for which influence has been computed will be displayed. It will try to use tqdm if available for advanced features (e.g. time @@ -844,7 +851,7 @@ def _influence( Default: False Returns: - influence_scores (tensor): Influence scores from the TracInCP method. + influence_scores (Tensor): Influence scores from the TracInCP method. Its shape is `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and `train_dataset_size` is the number of examples in @@ -882,7 +889,8 @@ def _get_k_most_influential( ) -> KMostInfluentialResults: r""" Args: - inputs (Tuple of Any): A tuple that represents a batch of examples. It does + + inputs (tuple of Any): A tuple that represents a batch of examples. It does not represent labels, which are passed as `targets`. targets (Tensor, optional): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. @@ -895,7 +903,7 @@ def _get_k_most_influential( Default: True show_progress (bool, optional): To compute the proponents (or opponents) for the batch of examples, we perform computation for each batch in - training dataset `train_dataset`, If `show_progress`is + training dataset `train_dataset`, If `show_progress` is true, the progress of this computation will be displayed. In particular, the number of batches for which the computation has been performed will be displayed. It will try to use tqdm if @@ -964,7 +972,7 @@ def _self_influence_by_checkpoints( times. Args: - batches (Tuple, or DataLoader): Either a single tuple of any, or a + batches (tuple or DataLoader): Either a single tuple of any, or a `DataLoader`, where each batch yielded is a tuple of any. In either case, the tuple represents a single batch, where the last element is assumed to be the labels for the batch. That is, @@ -976,7 +984,7 @@ def _self_influence_by_checkpoints( more details on the assumed structure of a batch. show_progress (bool, optional): Computation of self influence scores can take a long time if `inputs_dataset` represents many examples. If - `show_progress`is true, the progress of this computation will be + `show_progress` is true, the progress of this computation will be displayed. In more detail, this computation will iterate over all checkpoints (provided as the `checkpoints` initialization argument) in an outer loop, and iterate over all batches that @@ -1126,7 +1134,7 @@ def self_influence( for each batch. For large models, loading checkpoints can be time-intensive. Args: - batches (Tuple, or DataLoader): Either a single tuple of any, or a + batches (tuple or DataLoader): Either a single tuple of any, or a `DataLoader`, where each batch yielded is a tuple of any. In either case, the tuple represents a single batch, where the last element is assumed to be the labels for the batch. That is, @@ -1178,7 +1186,8 @@ def _basic_computation_tracincp( and batches. Args: - inputs (Tuple of Any): A batch of examples, which could be a training batch + + inputs (tuple of Any): A batch of examples, which could be a training batch or test batch, depending which method is the caller. Does not represent labels, which are passed as `targets`. The assumption is that `model(*inputs)` produces the predictions for the batch. diff --git a/captum/influence/_core/tracincp_fast_rand_proj.py b/captum/influence/_core/tracincp_fast_rand_proj.py index 114d4c45bd..0a95a52dc1 100644 --- a/captum/influence/_core/tracincp_fast_rand_proj.py +++ b/captum/influence/_core/tracincp_fast_rand_proj.py @@ -36,7 +36,7 @@ r""" Implements abstract DataInfluence class and also provides implementation details for influence computation based on the logic provided in TracIn paper -(https://arxiv.org/pdf/2002.08484.pdf). +(https://arxiv.org/abs/2002.08484). The TracIn paper proposes an idealized notion of influence which can be represented by the total amount a training example reduces loss for a test example via a training @@ -92,6 +92,7 @@ def __init__( ) -> None: r""" Args: + model (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. final_fc_layer (torch.nn.Module or str): The last fully connected layer in @@ -99,7 +100,7 @@ def __init__( projection method. Can be either the layer module itself, or the fully qualified name of the layer if it is a defined attribute of the passed `model`. - train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.data.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -123,7 +124,7 @@ def __init__( `model` accepts `L-1` arguments, and the last element of `batch` is the label. In other words, `model(*batch[:-1])` gives the output of `model`, and `batch[-1]` are the labels for the batch. - checkpoints (str or List of str or Iterator): Either the directory of the + checkpoints (str, list[str], or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which returns objects from which to load checkpoints. @@ -236,6 +237,7 @@ def influence( # type: ignore[override] opponent) on the test example. Args: + inputs (Any, optional): If not provided or `None`, the self influence mode will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential @@ -247,7 +249,7 @@ def influence( # type: ignore[override] `inputs` will need to be a tuple. In other words, `inputs` will be unpacked as an argument when passing to `model`. Default: None - targets (tensor, optional): The labels corresponding to the batch `inputs`. + targets (Tensor, optional): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so `targets` is required, unless running in "self influence" mode. Default: None @@ -267,7 +269,7 @@ def influence( # type: ignore[override] show_progress (bool, optional): For all modes, computation of results requires "training dataset computations": computations for each batch in the training dataset `train_dataset`, which may - take a long time. If `show_progress`is true, the progress of + take a long time. If `show_progress` is true, the progress of "training dataset computations" will be displayed. It will try to use tqdm if available for advanced features (e.g. time estimation). Otherwise, it will fallback to a simple output of progress. @@ -281,7 +283,7 @@ def influence( # type: ignore[override] `train_dataset`. The length of this tensor is the number of examples in `train_dataset`, regardless of whether it is a Dataset or DataLoader. - - influence score mode: if this mode is run (`inputs is not None, `k` is + - influence score mode: if this mode is run (`inputs` is not None, `k` is None), returns a 2D tensor `influence_scores` of shape `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and @@ -377,15 +379,16 @@ def _influence( # type: ignore[override] output of `_basic_computation_tracincp_fast`. Args: - inputs (Tuple of Any): A batch of examples. Does not represent labels, + + inputs (tuple of Any): A batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that `model(*inputs)` produces the predictions for the batch. - targets (tensor): The labels corresponding to the batch `inputs`. This + targets (Tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so labels are required. show_progress (bool, optional): To compute the influence of examples in training dataset `train_dataset`, we compute the influence - of each batch. If `show_progress`is true, the progress of this + of each batch. If `show_progress` is true, the progress of this computation will be displayed. In particular, the number of batches for which influence has been computed will be displayed. It will try to use tqdm if available for advanced features (e.g. time @@ -394,7 +397,7 @@ def _influence( # type: ignore[override] Default: False Returns: - influence_scores (tensor): Influence scores from the TracInCPFast method. + influence_scores (Tensor): Influence scores from the TracInCPFast method. Its shape is `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and `train_dataset_size` is the number of examples in @@ -434,9 +437,10 @@ def _get_k_most_influential( # type: ignore[override] ) -> KMostInfluentialResults: r""" Args: - inputs (Tuple of Any): A tuple that represents a batch of examples. It does + + inputs (tuple of Any): A tuple that represents a batch of examples. It does not represent labels, which are passed as `targets`. - targets (tensor): The labels corresponding to the batch `inputs`. This + targets (Tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so labels are required. k (int, optional): The number of proponents or opponents to return per test @@ -447,7 +451,7 @@ def _get_k_most_influential( # type: ignore[override] Default: True show_progress (bool, optional): To compute the proponents (or opponents) for the batch of examples, we perform computation for each batch in - training dataset `train_dataset`, If `show_progress`is + training dataset `train_dataset`, If `show_progress` is true, the progress of this computation will be displayed. In particular, the number of batches for which the computation has been performed will be displayed. It will try to use tqdm if @@ -516,7 +520,7 @@ def _self_influence_by_checkpoints( times. Args: - batches (Tuple, or DataLoader): Either a single tuple of any, or a + batches (tuple or DataLoader): Either a single tuple of any, or a `DataLoader`, where each batch yielded is a tuple of any. In either case, the tuple represents a single batch, where the last element is assumed to be the labels for the batch. That is, @@ -528,7 +532,7 @@ def _self_influence_by_checkpoints( more details on the assumed structure of a batch. show_progress (bool, optional): Computation of self influence scores can take a long time if `inputs_dataset` represents many examples. If - `show_progress`is true, the progress of this computation will be + `show_progress` is true, the progress of this computation will be displayed. In more detail, this computation will iterate over all checkpoints (provided as the `checkpoints` initialization argument) in an outer loop, and iterate over all batches that @@ -660,7 +664,7 @@ def self_influence( for each batch. For large models, loading checkpoints can be time-intensive. Args: - batches (Tuple, or DataLoader): Either a single tuple of any, or a + batches (tuple or DataLoader): Either a single tuple of any, or a `DataLoader`, where each batch yielded is a tuple of any. In either case, the tuple represents a single batch, where the last element is assumed to be the labels for the batch. That is, @@ -713,17 +717,18 @@ def _basic_computation_tracincp_fast( and batches. Args: + influence_instance (TracInCPFast): A instance of TracInCPFast or its children. We assume `influence_instance` has a `loss_fn` attribute, i.e. the loss function applied to the output of the last fully-connected layer, as well as a `reduction_type` attribute, which indicates whether `loss_fn` reduces the per-example losses by using their mean or sum. The `reduction_type` attribute must either be "mean" or "sum". - inputs (Tuple of Any): A batch of examples, which could be a training batch + inputs (tuple of Any): A batch of examples, which could be a training batch or test batch, depending which method is the caller. Does not represent labels, which are passed as `targets`. The assumption is that `model(*inputs)` produces the predictions for the batch. - targets (tensor): If computing influence scores on a loss function, + targets (Tensor): If computing influence scores on a loss function, these are the labels corresponding to the batch `inputs`. Returns: @@ -809,7 +814,7 @@ class TracInCPFastRandProj(TracInCPFast): to obtain proponents / opponents or influence scores will be made in an "interactive" manner, and there is sufficient memory to store vectors for the entire `train_dataset`. This is because in order to enable interactive - analysis, this implementation incures overhead in ``__init__` to setup the + analysis, this implementation incures overhead in `__init__` to setup the nearest-neighbors data structure, which is both time and memory intensive, as vectors corresponding to all training examples needed to be stored. To reduce memory usage, this implementation enables random projections of those vectors. @@ -853,6 +858,7 @@ def __init__( ) -> None: r""" Args: + model (torch.nn.Module): An instance of pytorch model. This model should define all of its layers as attributes of the model. final_fc_layer (torch.nn.Module or str): The last fully connected layer in @@ -860,7 +866,7 @@ def __init__( projection method. Can be either the layer module itself, or the fully qualified name of the layer if it is a defined attribute of the passed `model`. - train_dataset (torch.utils.data.Dataset or torch.utils.DataLoader): + train_dataset (torch.utils.data.Dataset or torch.utils.data.DataLoader): In the `influence` method, we either compute the influence score of training examples on examples in a test batch, or self influence scores for those training examples, depending on which mode is used. @@ -884,7 +890,7 @@ def __init__( `model` accepts `L-1` arguments, and the last element of `batch` is the label. In other words, `model(*batch[:-1])` gives the output of `model`, and `batch[-1]` are the labels for the batch. - checkpoints (str or List of str or Iterator): Either the directory of the + checkpoints (str, list[str], or Iterator): Either the directory of the path to store and retrieve model checkpoints, a list of filepaths with checkpoints from which to load, or an iterator which returns objects from which to load checkpoints. @@ -935,7 +941,7 @@ def __init__( int, and random projection will be performed to ensure that the vector is of dimension no more than `projection_dim` * C. `projection_dim` corresponds to the variable d in the top of page - 15 of the TracIn paper: https://arxiv.org/pdf/2002.08484.pdf. + 15 of the TracIn paper: https://arxiv.org/abs/2002.08484. Default: None seed (int, optional): Because this implementation chooses a random projection, its output is random. Setting this seed specifies the @@ -995,15 +1001,16 @@ def _influence( # type: ignore[override] ) -> Tensor: r""" Args: + inputs (tuple of Any): A batch of examples. Does not represent labels, which are passed as `targets`. The assumption is that `model(*inputs)` produces the predictions for the batch. - targets (tensor): The labels corresponding to the batch `inputs`. This + targets (Tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so labels are required. Returns: - influence_scores (tensor): Influence scores from the + influence_scores (Tensor): Influence scores from the TracInCPFastRandProj method. Its shape is `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and `train_dataset_size` is @@ -1034,9 +1041,10 @@ def _get_k_most_influential( # type: ignore[override] ) -> KMostInfluentialResults: r""" Args: - inputs (Tuple of Any): A tuple that represents a batch of examples. It does + + inputs (tuple of Any): A tuple that represents a batch of examples. It does not represent labels, which are passed as `targets`. - targets (tensor): The labels corresponding to the batch `inputs`. This + targets (Tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so labels are required. k (int, optional): The number of proponents or opponents to return per test @@ -1101,7 +1109,7 @@ def self_influence( with are not too large, so that there will not be an out-of-memory error. Args: - batches (Tuple, or DataLoader): Either a single tuple of any, or a + batches (tuple or DataLoader): Either a single tuple of any, or a `DataLoader`, where each batch yielded is a tuple of any. In either case, the tuple represents a single batch, where the last element is assumed to be the labels for the batch. That is, @@ -1113,7 +1121,7 @@ def self_influence( more details on the assumed structure of a batch. show_progress (bool, optional): Computation of self influence scores can take a long time if `inputs_dataset` represents many examples. If - `show_progress`is true, the progress of this computation will be + `show_progress` is true, the progress of this computation will be displayed. In more detail, this computation will iterate over all checkpoints (provided as the `checkpoints` initialization argument) and all batches that `inputs_dataset` represents. Therefore, the @@ -1187,6 +1195,7 @@ def influence( # type: ignore[override] gradients in the last fully-connected layer, please use `TracInCPFast` instead. Args: + inputs (Any, optional): If not provided or `None`, the self influence mode will be run. Otherwise, `inputs` is the test batch that will be used when running in either influence score or k-most influential @@ -1198,7 +1207,7 @@ def influence( # type: ignore[override] `inputs` will need to be a tuple. In other words, `inputs` will be unpacked as an argument when passing to `model`. Default: None - targets (tensor): The labels corresponding to the batch `inputs`. This + targets (Tensor): The labels corresponding to the batch `inputs`. This method is designed to be applied for a loss function, so `targets` is required. k (int, optional): If not provided or `None`, the influence score mode will @@ -1219,7 +1228,7 @@ def influence( # type: ignore[override] The return value of this method depends on which mode is run. - - influence score mode: if this mode is run (`inputs is not None, `k` is + - influence score mode: if this mode is run (`inputs` is not None, `k` is None), returns a 2D tensor `influence_scores` of shape `(input_size, train_dataset_size)`, where `input_size` is the number of examples in the test batch, and @@ -1275,6 +1284,7 @@ def _set_projections_tracincp_fast_rand_proj( `TracInCPFastRandProj.__init__`. Args: + dataloader (DataLoader): determining the projection requires knowing the dimensionality of the last layer's parameters (`jacobian_dim` below) and its input (`layer_input_dim` below). These are @@ -1282,10 +1292,10 @@ def _set_projections_tracincp_fast_rand_proj( provides that batch. Returns: - jacobian_projection (tensor or None): Projection matrix to apply to + jacobian_projection (Tensor or None): Projection matrix to apply to Jacobian of last layer to reduce its dimension, if needed. None otherwise. - input_projection (tensor or None): Projection matrix to apply to input of + input_projection (Tensor or None): Projection matrix to apply to input of last layer to reduce its dimension, if needed. None otherwise. """ # figure out projection dimensions, if needed @@ -1326,7 +1336,7 @@ def _set_projections_tracincp_fast_rand_proj( # allowable dimension of the "partial" intermediate quantity. Therefore, # we only project if `jacobian_dim` * `layer_input_dim` > `projection_dim`. # `projection_dim` corresponds to the variable d in the top of page 15 of - # the TracIn paper: https://arxiv.org/pdf/2002.08484.pdf. + # the TracIn paper: https://arxiv.org/abs/2002.08484. if jacobian_dim * layer_input_dim > projection_dim: jacobian_projection_dim = min(int(projection_dim**0.5), jacobian_dim) layer_input_projection_dim = min( @@ -1361,7 +1371,8 @@ def _process_src_intermediate_quantities_tracincp_fast_rand_proj( method creates that data structure. This method has side effects. Args: - src_intermediate_quantities (tensor): the output of the + + src_intermediate_quantities (Tensor): the output of the `_get_intermediate_quantities_tracin_fast_rand_proj` function when applied to training dataset `train_dataset`. This output is the vector representation of all training examples. @@ -1401,7 +1412,7 @@ def _get_intermediate_quantities_tracincp_fast_rand_proj( projection is to be applied. Returns: - intermediate_quantities (tensor): A tensor of dimension + intermediate_quantities (Tensor): A tensor of dimension (N, D * C), where N is total number of examples in `dataloader`, C is the number of checkpoints passed as the `checkpoints` argument of `TracInCPFastRandProj.__init__`, and each row represents the @@ -1417,7 +1428,7 @@ def _get_intermediate_quantities_tracincp_fast_rand_proj( performed to ensure that the vector is of dimension no more than `self.projection_dim` * C. `self.projection_dim` corresponds to the variable d in the top of page 15 of the TracIn paper: - https://arxiv.org/pdf/2002.08484.pdf. + https://arxiv.org/abs/2002.08484. """ # if `inputs_dataset` is not a `DataLoader`, turn it into one. inputs_dataset = _format_inputs_dataset(inputs_dataset) @@ -1547,7 +1558,7 @@ def compute_intermediate_quantities( structure of a batch. Returns: - intermediate_quantities (tensor): A tensor of dimension + intermediate_quantities (Tensor): A tensor of dimension (N, D * C), where N is total number of examples in `inputs_dataset`, C is the number of checkpoints passed as the `checkpoints` argument of `TracInCPFastRandProj.__init__`, and each diff --git a/captum/influence/_utils/common.py b/captum/influence/_utils/common.py index cd989098c8..356f09b8e6 100644 --- a/captum/influence/_utils/common.py +++ b/captum/influence/_utils/common.py @@ -91,12 +91,12 @@ def _jacobian_loss_wrt_inputs( torch.nn.Module. If a custom loss is provided, it can be either type, but must behave as a library loss function would if `reduction='sum'` or `reduction='mean'`. - out (tensor): This is a tensor that represents the batch of inputs to + out (Tensor): This is a tensor that represents the batch of inputs to `loss_fn`. In practice, this will be the output of a model; this is why this argument is named `out`. `out` is a 2D tensor of shape (batch size, model output dimensionality). We will call `loss_fn` via `loss_fn(out, targets)`. - targets (tensor): The labels for the batch of inputs. + targets (Tensor): The labels for the batch of inputs. vectorize (bool): Flag to use experimental vectorize functionality for `torch.autograd.functional.jacobian`. reduction_type (str): The type of reduction used by `loss_fn`. If `loss_fn` @@ -104,7 +104,7 @@ def _jacobian_loss_wrt_inputs( only be "mean" or "sum". Returns: - jacobians (tensor): Returns the jacobian of the per-sample loss (implicitly + jacobians (Tensor): Returns the jacobian of the per-sample loss (implicitly defined by `loss_fn` and `reduction_type`) w.r.t each sample in the batch represented by `out`. This is a 2D tensor, where the first dimension is the batch dimension. @@ -153,8 +153,9 @@ def _load_flexible_state_dict(model: Module, path: str) -> float: state_dict and other information. Args: - model: The model for which to load a checkpoint - path: The filepath to the checkpoint + + model (torch.nn.Module): The model for which to load a checkpoint + path (str): The filepath to the checkpoint The module state_dict is modified in-place, and the learning rate is returned. """ @@ -203,7 +204,7 @@ def _get_k_most_influential_helper( influence_batch_fn (Callable): A callable that will be called via `influence_batch_fn(inputs, targets, batch)`, where `batch` is a batch in the `influence_src_dataloader` argument. - inputs (Tuple of Any): A batch of examples. Does not represent labels, + inputs (tuple of Any): A batch of examples. Does not represent labels, which are passed as `targets`. targets (Tensor, optional): If computing TracIn scores on a loss function, these are the labels corresponding to the batch `inputs`. @@ -216,7 +217,7 @@ def _get_k_most_influential_helper( Default: True show_progress (bool, optional): To compute the proponents (or opponents) for the batch of examples, we perform computation for each batch in - training dataset `influence_src_dataloader`, If `show_progress`is + training dataset `influence_src_dataloader`, If `show_progress` is true, the progress of this computation will be displayed. In particular, the number of batches for which the computation has been performed will be displayed. It will try to use tqdm if @@ -354,7 +355,7 @@ def _self_influence_by_batches_helper( instance_name (str): This is the name of the implementation class that `self_influence_batch_fn` is a method of. This is used for displaying warning messages. - batches (Tuple, or DataLoader): Either a single tuple of any, or a + batches (tuple or DataLoader): Either a single tuple of any, or a `DataLoader`, where each batch yielded is a tuple of any. In either case, the tuple represents a single batch, where the last element is assumed to be the labels for the batch. That is, diff --git a/captum/influence/_utils/nearest_neighbors.py b/captum/influence/_utils/nearest_neighbors.py index 3ecd452de3..fa8d6d7136 100644 --- a/captum/influence/_utils/nearest_neighbors.py +++ b/captum/influence/_utils/nearest_neighbors.py @@ -34,7 +34,7 @@ def get_nearest_neighbors( so that `query` is 2D. Args: - query (tensor): tensor representing the batch of tensors for which k-nearest + query (Tensor): tensor representing the batch of tensors for which k-nearest neighbors are desired. `query` is of shape (N, *), where N is the size of the batch, i.e. the 0-th dimension of `query` indexes the batch. * denotes an arbitrary shape, so that each tensor in the @@ -68,7 +68,7 @@ def setup(self, data: torch.Tensor) -> None: dimension indexes the tensors in the stored tensors. Args: - data (tensor): A tensor of shape (N, *) representing the stored tensors. + data (Tensor): A tensor of shape (N, *) representing the stored tensors. The 0-th dimension indexes the tensors in the stored tensors, so that `data[i]` is the tensor with index `i`. The nearest neighbors of a query will be referred to by their index. @@ -129,7 +129,7 @@ def setup(self, data: torch.Tensor) -> None: tensors. Args: - data (tensor): A tensor of shape (N, *) representing the stored tensors. + data (Tensor): A tensor of shape (N, *) representing the stored tensors. The 0-th dimension indexes the tensors in the stored tensors, so that `data[i]` is the tensor with index `i`. The nearest neighbors of a query will be referred to by their index. @@ -160,7 +160,7 @@ def get_nearest_neighbors( dot-product of the flattened version of tensors. Args: - query (tensor): tensor representing the batch of tensors for which k-nearest + query (Tensor): tensor representing the batch of tensors for which k-nearest neighbors are desired. `query` is of shape (N, *), where N is the size of the batch, i.e. the 0-th dimension of `query` indexes the batch. * denotes an arbitrary shape, so that each tensor in the diff --git a/captum/insights/__init__.py b/captum/insights/__init__.py index 48ba6fdfa0..2ba766cdd2 100644 --- a/captum/insights/__init__.py +++ b/captum/insights/__init__.py @@ -1 +1 @@ -from captum.insights.attr_vis import AttributionVisualizer, Batch # noqa +from captum.insights.attr_vis import AttributionVisualizer, Batch, features # noqa diff --git a/captum/insights/attr_vis/app.py b/captum/insights/attr_vis/app.py index 9a0433090b..fe7e0bbcda 100644 --- a/captum/insights/attr_vis/app.py +++ b/captum/insights/attr_vis/app.py @@ -108,7 +108,7 @@ def __init__( Args: - inputs (tensor or tuple of tensors): Batch of inputs for a model. + inputs (Tensor or tuple of Tensor): Batch of inputs for a model. These may be either a Tensor or tuple of tensors. Each tensor must correspond to a feature for AttributionVisualizer, and the corresponding input transform function of the feature @@ -116,7 +116,7 @@ def __init__( model. It is assumed that the first dimension of each input tensor corresponds to the number of examples (batch size) and is aligned for all input tensors. - labels (tensor): Tensor containing correct labels for input examples. + labels (Tensor): Tensor containing correct labels for input examples. This must be a 1D tensor with length matching the first dimension of each input tensor. additional_args (tuple, optional): If the forward function @@ -149,11 +149,11 @@ def __init__( r""" Args: - models (torch.nn.module): One or more PyTorch modules (models) for + models (torch.nn.Module): One or more PyTorch modules (models) for attribution visualization. - classes (list of string): List of strings corresponding to the names of + classes (list[str]): List of strings corresponding to the names of classes for classification. - features (list of BaseFeature): List of BaseFeatures, which correspond + features (list[BaseFeature]): List of BaseFeatures, which correspond to input arguments to the model. Each feature object defines relevant transformations for converting to model input, constructing baselines, and visualizing. The length of the @@ -163,10 +163,10 @@ def __init__( a single BaseFeature, while a multimodal classifier may provide a list of features, each corresponding to a different tensor input and potentially different modalities. - dataset (iterable of Batch): Defines the dataset to visualize attributions + dataset (Iterable of Batch): Defines the dataset to visualize attributions for. This must be an iterable of batch objects, each of which may contain multiple input examples. - score_func (callable, optional): This function is applied to the model + score_func (Callable, optional): This function is applied to the model output to obtain the score for each class. For instance, this function could be the softmax or final non-linearity of the network, applied to the model output. The indices @@ -175,7 +175,7 @@ def __init__( are taken directly and assumed to correspond to the class scores. Default: None - use_label_for_attr (boolean, optional): If true, the class index is passed + use_label_for_attr (bool, optional): If true, the class index is passed to the relevant attribution method. This is necessary in most cases where there is an output neuron corresponding to each class. When the model output is a scalar and class index diff --git a/captum/insights/attr_vis/features.py b/captum/insights/attr_vis/features.py index 0986170758..9a048e57a6 100644 --- a/captum/insights/attr_vis/features.py +++ b/captum/insights/attr_vis/features.py @@ -43,16 +43,16 @@ def __init__( name (str): The label of the specific feature. For example, an ImageFeature's name can be "Photo". - baseline_transforms (list, callable, optional): Optional list of + baseline_transforms (list, Callable, optional): Optional list of callables (e.g. functions) to be called on the input tensor to construct multiple baselines. Currently only one baseline is supported. See :py:class:`.IntegratedGradients` for more information about baselines. - input_transforms (list, callable, optional): Optional list of callables + input_transforms (list, Callable, optional): Optional list of callables (e.g. functions) called on the input tensor sequentially to convert it into the format expected by the model. - visualization_transform (callable, optional): Optional callable (e.g. + visualization_transform (Callable, optional): Optional callable (e.g. function) applied as a postprocessing step of the original input data (before ``input_transforms``) to convert it to a format to be understood by the frontend visualizer as @@ -89,16 +89,16 @@ def __init__( Args: name (str): The label of the specific feature. For example, an ImageFeature's name can be "Photo". - baseline_transforms (list, callable, optional): Optional list of + baseline_transforms (list, Callable, optional): Optional list of callables (e.g. functions) to be called on the input tensor to construct multiple baselines. Currently only one baseline is supported. See :py:class:`.IntegratedGradients` for more information about baselines. - input_transforms (list, callable, optional): A list of transforms + input_transforms (list, Callable, optional): A list of transforms or transform to be applied to the input. For images, normalization is often applied here. - visualization_transform (callable, optional): Optional callable (e.g. + visualization_transform (Callable, optional): Optional callable (e.g. function) applied as a postprocessing step of the original input data (before input_transforms) to convert it to a format to be visualized. @@ -164,7 +164,7 @@ def __init__( Args: name (str): The label of the specific feature. For example, an ImageFeature's name can be "Photo". - baseline_transforms (list, callable, optional): Optional list of + baseline_transforms (list, Callable, optional): Optional list of callables (e.g. functions) to be called on the input tensor to construct multiple baselines. Currently only one baseline is supported. See @@ -174,7 +174,7 @@ def __init__( corresponding to PAD with the same size as the input tensor. See :py:class:`.TokenReferenceBase` for more information. - input_transforms (list, callable, optional): A list of transforms + input_transforms (list, Callable, optional): A list of transforms or transform to be applied to the input. For text, a common transform is to convert the tokenized input tensor into an interpretable embedding. See @@ -182,7 +182,7 @@ def __init__( and :py:func:`~.configure_interpretable_embedding_layer` for more information. - visualization_transform (callable, optional): Optional callable (e.g. + visualization_transform (Callable, optional): Optional callable (e.g. function) applied as a postprocessing step of the original input data (before ``input_transforms``) to convert it to a suitable format for visualization. For text features, diff --git a/captum/metrics/_core/infidelity.py b/captum/metrics/_core/infidelity.py index 33f485a78e..a10b2e2812 100644 --- a/captum/metrics/_core/infidelity.py +++ b/captum/metrics/_core/infidelity.py @@ -44,12 +44,12 @@ def sub_infidelity_perturb_func_decorator(pertub_func: Callable) -> Callable: r""" Args: - pertub_func(callable): Input perturbation function that takes inputs + pertub_func(Callable): Input perturbation function that takes inputs and optionally baselines and returns perturbed inputs Returns: - default_perturb_func(callable): Internal default perturbation + default_perturb_func(Callable): Internal default perturbation function that computes the perturbations internally and returns perturbations and perturbed inputs. @@ -126,7 +126,7 @@ def infidelity( and the differences between the predictor function at its input and perturbed input. More details about the measure can be found in the following paper: - https://arxiv.org/pdf/1901.09392.pdf + https://arxiv.org/abs/1901.09392 It is derived from the completeness property of well-known attribution algorithms and is a computationally more efficient and generalized @@ -134,7 +134,7 @@ def infidelity( of the attributions and the differences of the predictor function at its input and fixed baseline. More details about the Sensitivity-n can be found here: - https://arxiv.org/pdf/1711.06104.pdfs + https://arxiv.org/abs/1711.06104 The users can perturb the inputs any desired way by providing any perturbation function that takes the inputs (and optionally baselines) @@ -147,10 +147,10 @@ def infidelity( Args: - forward_func (callable): + forward_func (Callable): The forward function of the model or any modification of it. - perturb_func (callable): + perturb_func (Callable): The perturbation function of model inputs. This function takes model inputs and optionally baselines as input arguments and returns either a tuple of perturbations and perturbed inputs or just @@ -205,12 +205,13 @@ def infidelity( Similar to previous case here as well we need to return only perturbed inputs in case `infidelity_perturb_func_decorator` decorates out `perturb_func`. + It is important to note that for performance reasons `perturb_func` isn't called for each example individually but on a batch of input examples that are repeated `max_examples_per_batch / batch_size` times within the batch. - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple @@ -220,7 +221,7 @@ def infidelity( multiple input tensors are provided, the examples must be aligned appropriately. - baselines (scalar, tensor, tuple of scalars or tensors, optional): + baselines (scalar, Tensor, tuple of scalar, or Tensor, optional): Baselines define reference values which sometimes represent ablated values and are used to compare with the actual inputs to compute importance scores in attribution algorithms. They can be represented @@ -249,13 +250,13 @@ def infidelity( Default: None - attributions (tensor or tuple of tensors): + attributions (Tensor or tuple of Tensor): Attribution scores computed based on an attribution algorithm. This attribution scores can be computed using the implementations provided in the `captum.attr` package. Some of those attribution approaches are so called global methods, which means that they factor in model inputs' multiplier, as described in: - https://arxiv.org/pdf/1711.06104.pdf + https://arxiv.org/abs/1711.06104 Many global attribution algorithms can be used in local modes, meaning that the inputs multiplier isn't factored in the attribution scores. @@ -271,7 +272,7 @@ def infidelity( For local attributions we can use real-valued perturbations whereas for global attributions that perturbation is binary. - https://arxiv.org/pdf/1901.09392.pdf + https://arxiv.org/abs/1901.09392 If we want to compute the infidelity of global attributions we can use a binary perturbation matrix that will allow us to select @@ -291,7 +292,7 @@ def infidelity( tensor as well. If inputs is provided as a tuple of tensors then attributions will be tuples of tensors as well. - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional @@ -304,7 +305,7 @@ def infidelity( being passed to `perturb_func` as an input argument. Default: None - target (int, tuple, tensor or list, optional): Indices for selecting + target (int, tuple, Tensor, or list, optional): Indices for selecting predictions from output(for classification cases, this is usually the target class). If the network returns a scalar value per example, no target @@ -365,7 +366,7 @@ def infidelity( Default: False Returns: - infidelities (tensor): A tensor of scalar infidelity scores per + infidelities (Tensor): A tensor of scalar infidelity scores per input example. The first dimension is equal to the number of examples in the input batch and the second dimension is one. diff --git a/captum/metrics/_core/sensitivity.py b/captum/metrics/_core/sensitivity.py index 77d87e6291..f0c841a5a1 100644 --- a/captum/metrics/_core/sensitivity.py +++ b/captum/metrics/_core/sensitivity.py @@ -30,8 +30,8 @@ def default_perturb_func( Args: - inputs (tensor or a tuple of tensors): The input tensors that we'd - like to perturb by adding a random noise sampled unifromly + inputs (Tensor or tuple of Tensor): The input tensors that we'd + like to perturb by adding a random noise sampled uniformly random from an L_infinity ball with a radius `perturb_radius`. radius (float): A radius used for sampling from @@ -39,8 +39,8 @@ def default_perturb_func( Returns: - perturbed_input (tuple(tensor)): A list of perturbed inputs that - are createed by adding noise sampled uniformly random + perturbed_input (tuple of Tensor): A list of perturbed inputs that + are created by adding noise sampled uniformly random from L_infiniy ball with a radius `perturb_radius` to the original inputs. @@ -90,7 +90,7 @@ def sensitivity_max( More about the Lipschitz Continuity Metric can also be found here `On the Robustness of Interpretability Methods` - https://arxiv.org/pdf/1806.08049.pdf + https://arxiv.org/abs/1806.08049 and `Towards Robust Interpretability with Self-Explaining Neural Networks` https://papers.nips.cc/paper\ @@ -99,16 +99,16 @@ def sensitivity_max( More details about sensitivity max can be found here: `On the (In)fidelity and Sensitivity of Explanations` - https://arxiv.org/pdf/1901.09392.pdf + https://arxiv.org/abs/1901.09392 Args: - explanation_func (callable): + explanation_func (Callable): This function can be the `attribute` method of an attribution algorithm or any other explanation method that returns the explanations. - inputs (tensor or tuple of tensors): Input for which + inputs (Tensor or tuple of Tensor): Input for which explanations are computed. If `explanation_func` takes a single tensor as input, a single input tensor should be provided. @@ -119,7 +119,7 @@ def sensitivity_max( multiple input tensors are provided, the examples must be aligned appropriately. - perturb_func (callable): + perturb_func (Callable): The perturbation function of model inputs. This function takes model inputs and optionally `perturb_radius` if the function takes more than one argument and returns @@ -138,7 +138,7 @@ def sensitivity_max( perturb_radius (float, optional): The epsilon radius used for sampling. In the `default_perturb_func` it is used as the radius of the L-Infinity ball. In a general case it can serve as a radius of - any L_p nom. + any L_p norm. This argument is passed to `perturb_func` if it takes more than one argument. @@ -149,10 +149,12 @@ def sensitivity_max( `perturb_func` function. Default: 10 - norm_ord (int, float, inf, -inf, 'fro', 'nuc', optional): The type of norm - that is used to compute the - norm of the sensitivity matrix which is defined as the difference - between the explanation function at its input and perturbed input. + norm_ord (int, float, or str, optional): The type of norm that is used to + compute the norm of the sensitivity matrix which is defined as the + difference between the explanation function at its input and perturbed + input. Acceptable values are either a string of 'fro' or 'nuc', or a + number in the range of [-inf, inf] (including float("-inf") & + float("inf")). Default: 'fro' max_examples_per_batch (int, optional): The number of maximum input @@ -176,7 +178,7 @@ def sensitivity_max( Returns: - sensitivities (tensor): A tensor of scalar sensitivity scores per + sensitivities (Tensor): A tensor of scalar sensitivity scores per input example. The first dimension is equal to the number of examples in the input batch and the second dimension is one. Returned sensitivities are normalized by diff --git a/captum/metrics/_utils/batching.py b/captum/metrics/_utils/batching.py index ee3b38f58e..83a773bda3 100644 --- a/captum/metrics/_utils/batching.py +++ b/captum/metrics/_utils/batching.py @@ -28,9 +28,9 @@ def _divide_and_aggregate_metrics( attributions for. n_perturb_samples (int): The number of samples per example that are used for perturbation purposes for example. - metric_func (callable): This function takes the number of samples per + metric_func (Callable): This function takes the number of samples per input batch and returns an overall metric for each example. - agg_func (callable, optional): This function is used to aggregate the + agg_func (Callable, optional): This function is used to aggregate the metrics across multiple sub-batches and that are generated by `metric_func`. max_examples_per_batch (int, optional): The maximum number of allowed examples @@ -38,7 +38,7 @@ def _divide_and_aggregate_metrics( Returns: - metric (tensor): A metric score estimated by `metric_func` per + metric (Tensor): A metric score estimated by `metric_func` per input example. """ bsz = inputs[0].size(0) diff --git a/captum/robust/_core/fgsm.py b/captum/robust/_core/fgsm.py index f717481ccd..0e42d08c37 100644 --- a/captum/robust/_core/fgsm.py +++ b/captum/robust/_core/fgsm.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -from typing import Any, Callable, Tuple +from typing import Any, Callable, Optional, Tuple import torch from captum._utils.common import ( @@ -21,37 +21,44 @@ class FGSM(Perturbation): r""" - Fast Gradient Sign Method is an one-step method that can generate - adversarial examples. For non-targeted attack, the formulation is - x' = x + epsilon * sign(gradient of L(theta, x, y)). - For targeted attack on t, the formulation is - x' = x - epsilon * sign(gradient of L(theta, x, t)). - L(theta, x, y) is the model's loss function with respect to model + Fast Gradient Sign Method is a one-step method that can generate + adversarial examples. + + For non-targeted attack, the formulation is:: + + x' = x + epsilon * sign(gradient of L(theta, x, y)) + + For targeted attack on t, the formulation is:: + + x' = x - epsilon * sign(gradient of L(theta, x, t)) + + ``L(theta, x, y)`` is the model's loss function with respect to model parameters, inputs and labels. More details on Fast Gradient Sign Method can be found in the original - paper: - https://arxiv.org/pdf/1412.6572.pdf + paper: https://arxiv.org/abs/1412.6572 """ def __init__( self, forward_func: Callable, - loss_func: Callable = None, + loss_func: Optional[Callable] = None, lower_bound: float = float("-inf"), upper_bound: float = float("inf"), ) -> None: r""" Args: - forward_func (callable): The pytorch model for which the attack is + forward_func (Callable): The pytorch model for which the attack is computed. - loss_func (callable, optional): Loss function of which the gradient + loss_func (Callable, optional): Loss function of which the gradient computed. The loss function should take in outputs of the model and labels, and return a loss tensor. The default loss function is negative log. lower_bound (float, optional): Lower bound of input values. + Default: ``float("-inf")`` upper_bound (float, optional): Upper bound of input values. e.g. image pixels must be in the range 0-255 + Default: ``float("inf")`` Attributes: bound (Callable): A function that bounds the input values based on @@ -80,13 +87,13 @@ def perturb( Args: - inputs (tensor or tuple of tensors): Input for which adversarial + inputs (Tensor or tuple of Tensor): Input for which adversarial attack is computed. It can be provided as a single tensor or a tuple of multiple tensors. If multiple input tensors are provided, the batch sizes must be - aligned accross all tensors. + aligned across all tensors. epsilon (float): Step size of perturbation. - target (any): True labels of inputs if non-targeted attack is + target (Any): True labels of inputs if non-targeted attack is desired. Target class of inputs if targeted attack is desired. Target will be passed to the loss function to compute loss, so the type needs to match the @@ -112,7 +119,8 @@ def perturb( examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the label for the corresponding example. - additional_forward_args (any, optional): If the forward function + + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. These arguments are provided to @@ -124,7 +132,7 @@ def perturb( Returns: - - **perturbed inputs** (*tensor* or tuple of *tensors*): + - **perturbed inputs** (*Tensor* or tuple of *Tensor*): Perturbed input for each input tensor. The perturbed inputs have the same shape and dimensionality as the inputs. @@ -167,7 +175,7 @@ def _perturb( r""" A helper function to calculate the perturbed inputs given original inputs, gradient of loss function and epsilon. The calculation is - different for targetd v.s. non-targeted as described above. + different for targeted v.s. non-targeted as described above. """ multiplier = -1 if targeted else 1 inputs = tuple( diff --git a/captum/robust/_core/metrics/attack_comparator.py b/captum/robust/_core/metrics/attack_comparator.py index b9ebb59ad6..7964711883 100644 --- a/captum/robust/_core/metrics/attack_comparator.py +++ b/captum/robust/_core/metrics/attack_comparator.py @@ -60,15 +60,15 @@ def __init__( self, forward_func: Callable, metric: Callable[..., MetricResultType], - preproc_fn: Callable = None, + preproc_fn: Optional[Callable] = None, ) -> None: r""" Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of a model's forward function. - metric (callable): This function is applied to the model output in + metric (Callable): This function is applied to the model output in order to compute the desired performance metric or metrics. This function should have the following signature:: @@ -85,9 +85,10 @@ def __init__( If tensor metrics represent results for the full batch, the size of the first dimension should be 1. - preproc_fn (callable, optional): Optional method applied to inputs. Output + preproc_fn (Callable, optional): Optional method applied to inputs. Output of preproc_fn is then provided as input to model, in addition to additional_forward_args provided to evaluate. + Default: ``None`` """ self.forward_func = forward_func self.metric: Callable = metric @@ -113,7 +114,8 @@ def add_attack( Adds attack to be evaluated when calling evaluate. Args: - attack (perturbation or callable): This can either be an instance + + attack (Perturbation or Callable): This can either be an instance of a Captum Perturbation / Attack or any other perturbation or attack function such as a torchvision transform. @@ -121,23 +123,29 @@ def add_attack( name (str, optional): Name or identifier for attack, used as key for attack results. This defaults to attack.__class__.__name__ if not provided and must be unique for all added attacks. + Default: ``None`` - num_attempts (int): Number of attempts that attack should be + num_attempts (int, optional): Number of attempts that attack should be repeated. This should only be set to > 1 for non-deterministic attacks. The minimum, maximum, and average (best, worst, and average case) are tracked for attack attempts. - - apply_before_preproc (bool): Defines whether attack should be applied - before or after preproc function. - - attack_kwargs (dict): Additional arguments to be provided to given attack. - This should be provided as a dictionary of keyword arguments. - - additional_attack_arg_names (list[str]): Any additional arguments for the - attack which are specific to the particular input example or batch. - An example of this is target, which is necessary for some attacks such - as FGSM or PGD. These arguments are included if provided as a kwarg - to evaluate. + Default: ``1`` + + apply_before_preproc (bool, optional): Defines whether attack should be + applied before or after preproc function. + Default: ``True`` + + attack_kwargs (dict, optional): Additional arguments to be provided to + given attack. This should be provided as a dictionary of keyword + arguments. + Default: ``None`` + + additional_attack_arg_names (list[str], optional): Any additional + arguments for the attack which are specific to the particular input + example or batch. An example of this is target, which is necessary + for some attacks such as FGSM or PGD. These arguments are included + if provided as a kwarg to evaluate. + Default: ``None`` """ if name is None: name = attack.__class__.__name__ @@ -239,7 +247,7 @@ def evaluate( Args: - inputs (any): Input for which attack metrics + inputs (Any): Input for which attack metrics are computed. It can be provided as a tensor, tuple of tensors, or any raw input type (e.g. PIL image or text string). This input is provided directly as input to preproc function as well @@ -247,7 +255,7 @@ def evaluate( function is provided, this input is provided directly to the main model and all attacks. - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the preprocessing outputs (or inputs if preproc_fn is None), this argument can be provided. It must be either a single additional @@ -259,8 +267,8 @@ def evaluate( For a tensor, the first dimension of the tensor must correspond to the number of examples. For all other types, the given argument is used for all forward evaluations. - Default: None - perturbations_per_eval (int, optional): Allows perturbations of multiple + Default: ``None`` + perturbations_per_eval (int, optional): Allows perturbations of multiple attacks to be grouped and evaluated in one call of forward_fn Each forward pass will contain a maximum of perturbations_per_eval * #examples samples. @@ -272,9 +280,10 @@ def evaluate( In order to apply this functionality, the output of preproc_fn (or inputs itself if no preproc_fn is provided) must be a tensor or tuple of tensors. - Default: 1 - kwargs (any, optional): Additional keyword arguments provided to metric function - as well as selected attacks based on chosen additional_args + Default: ``1`` + kwargs (Any, optional): Additional keyword arguments provided to metric + function as well as selected attacks based on chosen additional_args. + Default: ``None`` Returns: diff --git a/captum/robust/_core/metrics/min_param_perturbation.py b/captum/robust/_core/metrics/min_param_perturbation.py index 99308727e4..95b2897a08 100644 --- a/captum/robust/_core/metrics/min_param_perturbation.py +++ b/captum/robust/_core/metrics/min_param_perturbation.py @@ -63,7 +63,7 @@ def __init__( corresponding perturbed input. Args: - forward_func (callable or torch.nn.Module): This can either be an instance + forward_func (Callable or torch.nn.Module): This can either be an instance of pytorch model or any modification of a model's forward function. @@ -85,23 +85,23 @@ def __init__( arg_step (int, float): Minimum interval for increase of target variable. mode (str, optional): Mode for search of minimum attack value; - either 'linear' for linear search on variable, or 'binary' for + either ``linear`` for linear search on variable, or ``binary`` for binary search of variable - Default: 'linear' + Default: ``linear`` num_attempts (int, optional): Number of attempts or trials with given variable. This should only be set to > 1 for non-deterministic perturbation / attack functions - Default: 1 + Default: ``1`` - preproc_fn (callable, optional): Optional method applied to inputs. Output + preproc_fn (Callable, optional): Optional method applied to inputs. Output of preproc_fn is then provided as input to model, in addition to additional_forward_args provided to evaluate. - Default: None + Default: ``None`` apply_before_preproc (bool, optional): Defines whether attack should be applied before or after preproc function. - Default: False + Default: ``False`` correct_fn (Callable, optional): This determines whether the perturbed input leads to a correct or incorrect prediction. By default, this function @@ -114,13 +114,15 @@ def __init__( function must be provided which determines correctness. The first argument to this function must be the model out; - any additional arguments should be provided through correct_fn_kwargs. + any additional arguments should be provided through + ``correct_fn_kwargs``. This function should have the following signature: + def correct_fn(model_out: Tensor, **kwargs: Any) -> bool Method should return a boolean if correct (True) and incorrect (False). - Default: None (applies standard correct_fn for classification) + Default: ``None`` (applies standard correct_fn for classification) """ self.forward_func = forward_func self.attack = attack @@ -363,7 +365,7 @@ def evaluate( pre-processing function is provided, this input is provided directly to the main model and all attacks. - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the preprocessing outputs (or inputs if preproc_fn is None), this argument can be provided. It must be either a single additional @@ -375,9 +377,9 @@ def evaluate( For a tensor, the first dimension of the tensor must correspond to the number of examples. For all other types, the given argument is used for all forward evaluations. - Default: None + Default: ``None`` target (TargetType): Target class for classification. This is required if - using the default correct_fn + using the default ``correct_fn``. perturbations_per_eval (int, optional): Allows perturbations of multiple attacks to be grouped and evaluated in one call of forward_fn @@ -391,10 +393,10 @@ def evaluate( In order to apply this functionality, the output of preproc_fn (or inputs itself if no preproc_fn is provided) must be a tensor or tuple of tensors. - Default: 1 - attack_kwargs (dictionary, optional): Optional dictionary of keyword + Default: ``1`` + attack_kwargs (dict, optional): Optional dictionary of keyword arguments provided to attack function - correct_fn_kwargs (dictionary, optional): Optional dictionary of keyword + correct_fn_kwargs (dict, optional): Optional dictionary of keyword arguments provided to correct function Returns: diff --git a/captum/robust/_core/perturbation.py b/captum/robust/_core/perturbation.py index 9eb6d53481..c47b02dd78 100644 --- a/captum/robust/_core/perturbation.py +++ b/captum/robust/_core/perturbation.py @@ -18,15 +18,15 @@ class Perturbation: Args: - inputs (tensor or tuple of tensors): Input for which adversarial attack + inputs (Tensor or tuple of Tensor): Input for which adversarial attack is computed. It can be provided as a single tensor or a tuple of multiple tensors. If multiple input tensors - are provided, the batch sizes must be aligned accross all + are provided, the batch sizes must be aligned across all tensors. Returns: - - **perturbed inputs** (*tensor* or tuple of *tensors*): + - **perturbed inputs** (*Tensor* or tuple of *Tensor*): Perturbed input for each input tensor. The perturbed inputs have the same shape and dimensionality as the inputs. diff --git a/captum/robust/_core/pgd.py b/captum/robust/_core/pgd.py index b14239c681..733cbcc488 100644 --- a/captum/robust/_core/pgd.py +++ b/captum/robust/_core/pgd.py @@ -31,8 +31,7 @@ class PGD(Perturbation): x_(t+1) = Clip_r(x_t - alpha * sign(gradient of L(theta, x, t))) More details on Projected Gradient Descent can be found in the original - paper: - https://arxiv.org/pdf/1706.06083.pdf + paper: https://arxiv.org/abs/1706.06083 """ def __init__( @@ -44,15 +43,17 @@ def __init__( ) -> None: r""" Args: - forward_func (callable): The pytorch model for which the attack is + forward_func (Callable): The pytorch model for which the attack is computed. - loss_func (callable, optional): Loss function of which the gradient + loss_func (Callable, optional): Loss function of which the gradient computed. The loss function should take in outputs of the model and labels, and return the loss for each input tensor. The default loss function is negative log. lower_bound (float, optional): Lower bound of input values. + Default: ``float("-inf")`` upper_bound (float, optional): Upper bound of input values. e.g. image pixels must be in the range 0-255 + Default: ``float("inf")`` Attributes: bound (Callable): A function that bounds the input values based on @@ -82,17 +83,17 @@ def perturb( Args: - inputs (tensor or tuple of tensors): Input for which adversarial + inputs (Tensor or tuple of Tensor): Input for which adversarial attack is computed. It can be provided as a single tensor or a tuple of multiple tensors. If multiple input tensors are provided, the batch sizes must be - aligned accross all tensors. + aligned across all tensors. radius (float): Radius of the neighbor ball centered around inputs. The perturbation should be within this range. step_size (float): Step size of each gradient step. step_num (int): Step numbers. It usually guarantees that the perturbation can reach the border. - target (any): True labels of inputs if non-targeted attack is + target (Any): True labels of inputs if non-targeted attack is desired. Target class of inputs if targeted attack is desired. Target will be passed to the loss function to compute loss, so the type needs to match the @@ -118,23 +119,23 @@ def perturb( examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the label for the corresponding example. - additional_forward_args (any, optional): If the forward function + additional_forward_args (Any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. These arguments are provided to forward_func in order following the arguments in inputs. - Default: None. + Default: ``None`` targeted (bool, optional): If attack should be targeted. - Default: False. + Default: ``False`` random_start (bool, optional): If a random initialization is added to - inputs. Default: False. + inputs. Default: ``False`` norm (str, optional): Specifies the norm to calculate distance from - original inputs: 'Linf'|'L2'. - Default: 'Linf'. + original inputs: ``Linf`` | ``L2``. + Default: ``Linf`` Returns: - - **perturbed inputs** (*tensor* or tuple of *tensors*): + - **perturbed inputs** (*Tensor* or tuple of *Tensor*): Perturbed input for each input tensor. The perturbed inputs have the same shape and dimensionality as the inputs. diff --git a/docs/algorithms.md b/docs/attribution_algorithms.md similarity index 99% rename from docs/algorithms.md rename to docs/attribution_algorithms.md index b06a8aa5f1..f1d00a8f53 100644 --- a/docs/algorithms.md +++ b/docs/attribution_algorithms.md @@ -1,5 +1,5 @@ --- -id: algorithms +id: attribution_algorithms title: Algorithm Descriptions --- diff --git a/docs/contribution_guide.md b/docs/contribution_guide.md index f8aacf1c85..82e4f158a2 100644 --- a/docs/contribution_guide.md +++ b/docs/contribution_guide.md @@ -4,7 +4,7 @@ title: The Captum Contribution Process --- The Captum development process involves a healthy amount of open discussions between the core development team and the community. -Captum operates similar to most open source projects on GitHub. However, if you've never contributed to an open source project before, here is the basic process. +Captum operates similarly to most open source projects on GitHub. However, if you've never contributed to an open source project before, here is the basic process. 1. **Figure out what you're going to work on.** @@ -59,7 +59,7 @@ https://captum.ai/tutorials/Bert_SQUAD_Interpret https://captum.ai/tutorials/IMDB_TorchText_Interpret **Vision** -- We provide a sample toy model for CIFAR dataset and examples with ResNet model. +- We provide a sample toy model for the CIFAR dataset and examples with a ResNet model. https://captum.ai/tutorials/CIFAR_TorchVision_Interpret https://captum.ai/tutorials/Resnet_TorchVision_Interpret These would be great starting points for benchmarking. diff --git a/docs/extension/integrated_gradients.md b/docs/extension/integrated_gradients.md index 0a00fb0ad1..ebcca190ec 100644 --- a/docs/extension/integrated_gradients.md +++ b/docs/extension/integrated_gradients.md @@ -42,7 +42,7 @@ class ToyModel(nn.Module): Second, let's apply integrated gradients on the toy model's output layer using sample data. The code snippet below computes the attribution of output with respect to the inputs. -`attribute` method of `IntegratedGradients` class returns input attributions which +The `attribute` method of `IntegratedGradients` class returns input attributions which have the same size and dimensionality as the inputs and an approximation error which is computed based on the completeness property of the integrated gradients. Completeness property is one of the axioms that integrated gradients satisfies. @@ -114,7 +114,7 @@ class ToySoftmaxModel(nn.Module): Now, let's apply integrated gradients on the toy classification model defined above using inputs that contain a range of numbers. We also choose an arbitrary target class (target_class_index: 5) which we use to attribute our predictions to. -Similar to previous example the output of attribution is a tensor with the same +Similar to the previous example, the output of attribution is a tensor with the same dimensionality as the inputs and an approximation error computed based on the completeness property of integrated gradients. @@ -157,9 +157,9 @@ Now, let's look at a model that besides input tensors takes input arguments of other types. In practice this can be used to pass the sequence length or the word/token indices in a sequence of a text, for instance. The example below demonstrates how to use `additional_forward_args`. In this particular example -`additional_forward_args` represents single integer value. -Those arguments are passed as `additional_forward_args` to `attribute` method and -they will be passed to model's forward function followed by inputs in the oder +`additional_forward_args` represents a single integer value. +Those arguments are passed as `additional_forward_args` to the `attribute` method and +they will be passed to the model's forward function followed by inputs in the order provided in `additional_forward_args`. In the example below, we also demonstrate how to apply integrated gradients to a batch of samples. The first dimension of the input corresponds to the batch size. diff --git a/docs/faq.md b/docs/faq.md index de4e22ea4c..16bf59b54a 100644 --- a/docs/faq.md +++ b/docs/faq.md @@ -9,7 +9,7 @@ title: FAQ * [Are SmoothGrad or VarGrad supported in Captum?](#are-smoothgrad-or-vargrad-supported-in-captum) * [How do I use Captum with BERT models?](#how-do-i-use-captum-with-bert-models) * [My model inputs or outputs token indices, and when using Captum I see errors relating to gradients, how do I resolve this?](#my-model-inputs-or-outputs-token-indices-and-when-using-captum-i-see-errors-relating-to-gradients-how-do-i-resolve-this) -* [Can my model using functional non-linearities (E.g. nn.functional.ReLU) or reused modules be used with Captum?](#can-my-model-using-functional-non-linearities-eg-nnfunctionalrelu-or-reused-modules-be-used-with-captum) +* [Can my model use functional non-linearities (E.g. nn.functional.ReLU) or can reused modules be used with Captum?](#can-my-model-use-functional-non-linearities-eg-nnfunctionalrelu-or-can-reused-modules-be-used-with-captum) * [Do JIT models, DataParallel models, or DistributedDataParallel models work with Captum?](#do-jit-models-dataparallel-models-or-distributeddataparallel-models-work-with-captum) * [I am working on a new interpretability or attribution method and would like to add it to Captum. How do I proceed?](#i-am-working-on-a-new-interpretability-or-attribution-method-and-would-like-to-add-it-to-captum-how-do-i-proceed) * [I am using a gradient-based attribution algorithm such as integrated gradients for a RNN or LSTM network and I see 'cudnn RNN backward can only be called in training mode'. How can I resolve this issue ?](#how-can-I-resolve-cudnn-RNN-backward-error-for-RNN-or-LSTM-network) @@ -53,7 +53,7 @@ For NLP models that take token indices as inputs, we cannot take gradients with If the output of the model is a token index, such as an image captioning cases, it is necessary to attribute with respect to the token score or probability rather than the index. Make sure that the model returns this and use target to choose the appropriate scalar score to attribute with respect to. -### **Can my model using functional non-linearities (E.g. nn.functional.ReLU) or reused modules be used with Captum?** +### **Can my model use functional non-linearities (E.g. nn.functional.ReLU) or can reused modules be used with Captum?** Most methods will work fine with functional non-linearities and arbitrary operations. Some methods, which require placing hooks during back-propagation, including DeepLift, DeepLiftShap, Guided Backpropagation, and Deconvolution will not work appropriately with functional non-linearities and must use the corresponding module activation (e.g. torch.nn.ReLU) which should be initialized in the module constructor. For DeepLift, it is important to also not reuse modules in the forward function, since this can cause issues in the propagation of multipliers. Computing layer or neuron attribution with layer modules that are used multiple times generally computes attributions for the last execution of the module. For more information regarding these restrictions, refer to the API documentation for the specific method, including DeepLift, DeepLiftShap, Guided Backpropagation, and Deconvolution. diff --git a/scripts/install_via_pip.sh b/scripts/install_via_pip.sh index 7a13dedb9e..de643e0687 100755 --- a/scripts/install_via_pip.sh +++ b/scripts/install_via_pip.sh @@ -37,7 +37,7 @@ export TERM=xterm # NOTE: All of the below installs use sudo, b/c otherwise pip will get # permission errors installing in the docker container. An alternative would be # to use a virtualenv, but that would lead to bifurcation of the CircleCI config -# since we'd need to source the environemnt in each step. +# since we'd need to source the environment in each step. # upgrade pip sudo pip install --upgrade pip @@ -55,7 +55,7 @@ fi if [[ $PYTORCH_NIGHTLY == true ]]; then sudo pip install --upgrade --pre torch -f https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html else - # If no version specified, upgrade to latest release. + # If no version is specified, upgrade to the latest release. if [[ $CHOSEN_TORCH_VERSION == -1 ]]; then sudo pip install --upgrade torch else diff --git a/sphinx/source/approximation_methods.rst b/sphinx/source/approximation_methods.rst index b6b197d92e..4deec709bf 100644 --- a/sphinx/source/approximation_methods.rst +++ b/sphinx/source/approximation_methods.rst @@ -1,4 +1,4 @@ -Captum Approximation +Approximation ==================== .. automodule:: captum.attr._utils.approximation_methods diff --git a/sphinx/source/base_classes.rst b/sphinx/source/base_classes.rst index c337d666fc..a1f3d8117b 100644 --- a/sphinx/source/base_classes.rst +++ b/sphinx/source/base_classes.rst @@ -1,32 +1,32 @@ Base Classes -========== +======================== Attribution -^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.Attribution :members: Layer Attribution -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerAttribution :members: Neuron Attribution -^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronAttribution :members: Gradient Attribution -^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.GradientAttribution :members: Perturbation Attribution -^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.PerturbationAttribution :members: diff --git a/sphinx/source/common.rst b/sphinx/source/common.rst deleted file mode 100644 index 711a7e6fe5..0000000000 --- a/sphinx/source/common.rst +++ /dev/null @@ -1,12 +0,0 @@ -Captum.Utils -============ - -.. automodule:: captum.attr._utils.common - -.. autofunction:: validate_input -.. autofunction:: validate_noise_tunnel_type -.. autofunction:: format_input -.. autofunction:: _format_attributions -.. autofunction:: zeros -.. autofunction:: _reshape_and_sum -.. autofunction:: _run_forward diff --git a/sphinx/source/concept.rst b/sphinx/source/concept.rst index 7aa60aabb9..19157398b7 100644 --- a/sphinx/source/concept.rst +++ b/sphinx/source/concept.rst @@ -1,29 +1,29 @@ Concept-based Interpretability -====== +============================== TCAV -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.concept.TCAV :members: ConceptInterpreter -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.concept.ConceptInterpreter :members: Concept -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.concept.Concept :members: Classifier -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.concept.Classifier :members: diff --git a/sphinx/source/conf.py b/sphinx/source/conf.py index 27bdc763fd..b01d1c8b81 100644 --- a/sphinx/source/conf.py +++ b/sphinx/source/conf.py @@ -10,7 +10,9 @@ # -- Path setup -------------------------------------------------------------- import os +import re import sys +from typing import List base_path = os.path.abspath(os.path.join(__file__, "..", "..", "..")) # read module from src instead of installation @@ -75,6 +77,11 @@ # Inlcude init docstrings into body of autoclass directives autoclass_content = "both" +# Preserve signature defaults +# Prevents entire tensors from being printed, & gives callable functions +# proper names +autodoc_preserve_defaults = True + # Configuration for intersphinx: refer to the Python standard library and PyTorch intersphinx_mapping = { "python": ("https://docs.python.org/3", None), @@ -201,3 +208,46 @@ # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = True + + +# -- Docstring Improvements -------------------------------------------------- + + +# Regex code for typing replacements. +# The "(? None: + """ + Modify docstrings before creating html files. + Sphinx converts the 'Args:' and 'Returns:' sections of docstrings into + reStructuredText (rST) syntax, which can then be found via ':type' & ':rtype'. + + See here for more information: + https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html + """ + for i in range(len(lines)): + # Skip unless line is an parameter doc or a return doc + if not lines[i].startswith(":type"): + continue + if ":py:data:" in lines[i]: + continue + + # Ensure Any, Callable, & Iterator types are hyperlinked with intersphinx. + # The tilde '~' character hides the 'typing.' portion of the string. + lines[i] = re.sub(_rt[0] + r"Any" + _rt[1], "~typing.Any", lines[i]) + lines[i] = re.sub(_rt[0] + r"Callable" + _rt[1], "~typing.Callable", lines[i]) + lines[i] = re.sub(_rt[0] + r"Iterator" + _rt[1], "~typing.Iterator", lines[i]) + lines[i] = re.sub(_rt[0] + r"Iterable" + _rt[1], "~typing.Iterable", lines[i]) + + # Ensure Tensor type is hyperlinked by interpshinx + lines[i] = re.sub(_rt[0] + r"Tensor" + _rt[1], "~torch.Tensor", lines[i]) + + +def setup(app) -> None: + app.connect("autodoc-process-docstring", autodoc_process_docstring) diff --git a/sphinx/source/deconvolution.rst b/sphinx/source/deconvolution.rst index 61e092e768..d5813d3842 100644 --- a/sphinx/source/deconvolution.rst +++ b/sphinx/source/deconvolution.rst @@ -1,5 +1,5 @@ Deconvolution -========= +============= .. autoclass:: captum.attr.Deconvolution :members: diff --git a/sphinx/source/feature_ablation.rst b/sphinx/source/feature_ablation.rst index 35484a0fe6..e337aecf73 100644 --- a/sphinx/source/feature_ablation.rst +++ b/sphinx/source/feature_ablation.rst @@ -1,5 +1,6 @@ Feature Ablation -========= +================ .. autoclass:: captum.attr.FeatureAblation :members: + :exclude-members: compute_convergence_delta diff --git a/sphinx/source/feature_permutation.rst b/sphinx/source/feature_permutation.rst index d58f625aee..609ff1ff39 100644 --- a/sphinx/source/feature_permutation.rst +++ b/sphinx/source/feature_permutation.rst @@ -1,5 +1,6 @@ Feature Permutation -========= +=================== .. autoclass:: captum.attr.FeaturePermutation :members: + :exclude-members: compute_convergence_delta diff --git a/sphinx/source/gradient_shap.rst b/sphinx/source/gradient_shap.rst index 2a676dcb06..8d94c31463 100644 --- a/sphinx/source/gradient_shap.rst +++ b/sphinx/source/gradient_shap.rst @@ -3,6 +3,3 @@ GradientShap .. autoclass:: captum.attr.GradientShap :members: - -.. autoclass:: captum.attr.InputBaselineXGradient - :members: diff --git a/sphinx/source/guided_backprop.rst b/sphinx/source/guided_backprop.rst index 6ef3a947ae..4c0685e8c5 100644 --- a/sphinx/source/guided_backprop.rst +++ b/sphinx/source/guided_backprop.rst @@ -1,5 +1,5 @@ Guided Backprop -========= +=============== .. autoclass:: captum.attr.GuidedBackprop :members: diff --git a/sphinx/source/guided_grad_cam.rst b/sphinx/source/guided_grad_cam.rst index 99f18d2af1..207d8e55fa 100644 --- a/sphinx/source/guided_grad_cam.rst +++ b/sphinx/source/guided_grad_cam.rst @@ -1,5 +1,5 @@ Guided GradCAM -========= +============== .. autoclass:: captum.attr.GuidedGradCam :members: diff --git a/sphinx/source/influence.rst b/sphinx/source/influence.rst index 6366924a70..6b906d8c47 100644 --- a/sphinx/source/influence.rst +++ b/sphinx/source/influence.rst @@ -1,41 +1,41 @@ Influential Examples -====== +==================== DataInfluence -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.influence.DataInfluence :members: SimilarityInfluence -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.influence.SimilarityInfluence :members: TracInCPBase -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.influence.TracInCPBase :members: TracInCP -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.influence.TracInCP :members: TracInCPFast -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.influence.TracInCPFast :members: TracInCPFastRandProj -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.influence.TracInCPFastRandProj :members: diff --git a/sphinx/source/input_x_gradient.rst b/sphinx/source/input_x_gradient.rst index cd5f222e27..5213eab69b 100644 --- a/sphinx/source/input_x_gradient.rst +++ b/sphinx/source/input_x_gradient.rst @@ -1,5 +1,5 @@ Input X Gradient -=============== +================ .. autoclass:: captum.attr.InputXGradient :members: diff --git a/sphinx/source/insights.rst b/sphinx/source/insights.rst index ece9180971..1e0963d483 100644 --- a/sphinx/source/insights.rst +++ b/sphinx/source/insights.rst @@ -4,12 +4,12 @@ Insights Batch ^^^^^ -.. autoclass:: captum.insights.api.Batch +.. autoclass:: captum.insights.Batch :members: AttributionVisualizer ^^^^^^^^^^^^^^^^^^^^^ -.. autoclass:: captum.insights.api.AttributionVisualizer +.. autoclass:: captum.insights.AttributionVisualizer :members: diff --git a/sphinx/source/kernel_shap.rst b/sphinx/source/kernel_shap.rst index 48cfde3535..421ed0ea62 100644 --- a/sphinx/source/kernel_shap.rst +++ b/sphinx/source/kernel_shap.rst @@ -3,3 +3,4 @@ KernelShap .. autoclass:: captum.attr.KernelShap :members: + :exclude-members: compute_convergence_delta diff --git a/sphinx/source/layer.rst b/sphinx/source/layer.rst index 7fbbd5bd85..466fbd97d2 100644 --- a/sphinx/source/layer.rst +++ b/sphinx/source/layer.rst @@ -1,70 +1,70 @@ Layer Attribution -====== +=========================== Layer Conductance -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerConductance :members: Layer Activation -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerActivation :members: Internal Influence -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.InternalInfluence :members: Layer Gradient X Activation -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerGradientXActivation :members: GradCAM -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerGradCam :members: Layer DeepLift -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerDeepLift :members: Layer DeepLiftShap -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerDeepLiftShap :members: Layer GradientShap -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerGradientShap :members: Layer Integrated Gradients -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerIntegratedGradients :members: Layer Feature Ablation -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerFeatureAblation :members: Layer LRP -^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.LayerLRP :members: diff --git a/sphinx/source/lime.rst b/sphinx/source/lime.rst index 4c722304f1..483458572c 100644 --- a/sphinx/source/lime.rst +++ b/sphinx/source/lime.rst @@ -3,6 +3,7 @@ Lime .. autoclass:: captum.attr.LimeBase :members: + :exclude-members: compute_convergence_delta .. autoclass:: captum.attr.Lime :members: diff --git a/sphinx/source/metrics.rst b/sphinx/source/metrics.rst index 47c11e4856..8e71a40b02 100644 --- a/sphinx/source/metrics.rst +++ b/sphinx/source/metrics.rst @@ -1,15 +1,15 @@ Metrics -====== +=========== Infidelity -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^ .. autoclass:: captum.metrics.infidelity :members: Sensitivity -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^ .. autoclass:: captum.metrics.sensitivity_max :members: diff --git a/sphinx/source/neuron.rst b/sphinx/source/neuron.rst index 8ad1514378..897f237baf 100644 --- a/sphinx/source/neuron.rst +++ b/sphinx/source/neuron.rst @@ -1,56 +1,57 @@ Neuron Attribution -======= +=========================== Neuron Gradient -^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronGradient :members: Neuron Integrated Gradients -^^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronIntegratedGradients :members: Neuron Conductance -^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronConductance :members: Neuron DeepLift -^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronDeepLift :members: Neuron DeepLiftShap -^^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronDeepLiftShap :members: Neuron GradientShap -^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronGradientShap :members: Neuron Guided Backprop -^^^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronGuidedBackprop :members: Neuron Deconvolution -^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronDeconvolution :members: Neuron Feature Ablation -^^^^^^^^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.attr.NeuronFeatureAblation :members: + :exclude-members: compute_convergence_delta diff --git a/sphinx/source/noise_tunnel.rst b/sphinx/source/noise_tunnel.rst index e1aff40b18..15b6ec7dbf 100644 --- a/sphinx/source/noise_tunnel.rst +++ b/sphinx/source/noise_tunnel.rst @@ -3,3 +3,4 @@ NoiseTunnel .. autoclass:: captum.attr.NoiseTunnel :members: + :exclude-members: compute_convergence_delta diff --git a/sphinx/source/occlusion.rst b/sphinx/source/occlusion.rst index a05b236e24..5867d739b9 100644 --- a/sphinx/source/occlusion.rst +++ b/sphinx/source/occlusion.rst @@ -3,3 +3,4 @@ Occlusion .. autoclass:: captum.attr.Occlusion :members: + :exclude-members: compute_convergence_delta diff --git a/sphinx/source/pytext.rst b/sphinx/source/pytext.rst index 66c847dcd9..f11a6a2099 100644 --- a/sphinx/source/pytext.rst +++ b/sphinx/source/pytext.rst @@ -1,11 +1,8 @@ Captum.Models ========================== -.. automodule:: captum.attr._models.pytext - -.. autoclass:: PyTextInterpretableEmbedding +.. autoclass:: captum.attr._models.pytext.PyTextInterpretableEmbedding :members: - -.. autoclass:: BaselineGenerator +.. autoclass:: captum.attr._models.pytext.BaselineGenerator :members: diff --git a/sphinx/source/robust.rst b/sphinx/source/robust.rst index 3b90a32ae5..48b360ad80 100644 --- a/sphinx/source/robust.rst +++ b/sphinx/source/robust.rst @@ -1,29 +1,29 @@ Robustness -====== +====================== FGSM -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.robust.FGSM :members: PGD -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.robust.PGD :members: Attack Comparator -^^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.robust.AttackComparator :members: Min Param Perturbation -^^^^^^^^^^^^^^^^ +^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: captum.robust.MinParamPerturbation :members: diff --git a/sphinx/source/shapley_value_sampling.rst b/sphinx/source/shapley_value_sampling.rst index c998125af9..4d40338540 100644 --- a/sphinx/source/shapley_value_sampling.rst +++ b/sphinx/source/shapley_value_sampling.rst @@ -1,7 +1,9 @@ Shapley Value Sampling -========= +====================== .. autoclass:: captum.attr.ShapleyValueSampling :members: + :exclude-members: compute_convergence_delta .. autoclass:: captum.attr.ShapleyValues :members: + :exclude-members: compute_convergence_delta diff --git a/sphinx/source/utilities.rst b/sphinx/source/utilities.rst index f4e3d7ace6..a19e75df9e 100644 --- a/sphinx/source/utilities.rst +++ b/sphinx/source/utilities.rst @@ -8,6 +8,8 @@ Visualization .. autofunction:: captum.attr.visualization.visualize_image_attr_multiple +.. autofunction:: captum.attr.visualization.visualize_timeseries_attr + Interpretable Embeddings ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -16,6 +18,7 @@ Interpretable Embeddings :members: .. autofunction:: captum.attr.configure_interpretable_embedding_layer + .. autofunction:: captum.attr.remove_interpretable_embedding_layer diff --git a/tests/influence/_core/test_tracin_intermediate_quantities.py b/tests/influence/_core/test_tracin_intermediate_quantities.py index 7f3e806c28..9f0daebad3 100644 --- a/tests/influence/_core/test_tracin_intermediate_quantities.py +++ b/tests/influence/_core/test_tracin_intermediate_quantities.py @@ -179,7 +179,7 @@ def test_tracin_intermediate_quantities_consistent( else: # `test_features` is a tuple, so we unpack it to place in tuple, # along with `test_labels` - test_batch = (*test_features, test_labels) + test_batch = (*test_features, test_labels) # type: ignore[assignment] # the influence score is the dot product of intermediate quantities intermediate_quantities_scores = torch.matmul( diff --git a/website/sidebars.json b/website/sidebars.json index 0337e1bbe9..9efb1fddb2 100644 --- a/website/sidebars.json +++ b/website/sidebars.json @@ -1,7 +1,7 @@ { "docs": { "About": ["introduction"], - "General": ["getting_started", "captum_insights", "algorithms", "algorithms_comparison_matrix", "faq", "contribution_guidelines"], + "General": ["getting_started", "captum_insights", "attribution_algorithms", "algorithms_comparison_matrix", "faq", "contribution_guidelines"], "Usage": ["extension/integrated_gradients"] } } From 30a88745ea5055be63b8a5e4d63d1c0ff787773e Mon Sep 17 00:00:00 2001 From: Facebook Community Bot Date: Tue, 20 Sep 2022 17:53:17 -0700 Subject: [PATCH 126/174] Re-sync with internal repository (#1028) Co-authored-by: Facebook Community Bot <6422482+facebook-github-bot@users.noreply.github.com> --- website/pages/en/index.js | 39 ----------------------------------- website/static/css/custom.css | 22 -------------------- 2 files changed, 61 deletions(-) diff --git a/website/pages/en/index.js b/website/pages/en/index.js index d04e321ab7..9dcd0eb1b7 100755 --- a/website/pages/en/index.js +++ b/website/pages/en/index.js @@ -265,10 +265,8 @@ Convergence Delta: tensor([2.3842e-07, -4.7684e-07]) return (
-
-
@@ -277,41 +275,4 @@ Convergence Delta: tensor([2.3842e-07, -4.7684e-07]) } } -function SocialBanner() { - return ( -
-
- Support Ukraine 🇺🇦{' '} - - Help Provide Humanitarian Aid to Ukraine - - . -
-
- ); -} - -function VideoContainer() { - return ( -
-
-
-

Check it out in the intro video

-
-