From 2eebbb9a198b234fbbd683372c746747d49f8c6b Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Fri, 1 Nov 2024 00:03:09 +0100 Subject: [PATCH 1/8] add linear transformation to transformer --- raman_master/models/__init__.py | 2 + raman_master/models/nn_training.py | 4 +- raman_master/models/transformer.py | 38 ++++++++++---- tests/models/test_transformer.py | 84 ++++++++++++++++++++++++++---- 4 files changed, 106 insertions(+), 22 deletions(-) diff --git a/raman_master/models/__init__.py b/raman_master/models/__init__.py index 0d318ba..0c80bba 100644 --- a/raman_master/models/__init__.py +++ b/raman_master/models/__init__.py @@ -3,11 +3,13 @@ from .nn_training import simple_training from .rezero_net import ReZeroNet from .resnext import ResNext from .fc_resnext import FCResNext +from .mae import MAE __all__ = [ "FCResNext", "LearnedMeanSigmaLossIgnoreNans", + "MAE", "ReZeroNet", "ResNext", "simple_training", diff --git a/raman_master/models/nn_training.py b/raman_master/models/nn_training.py index 9b8aae6..5b0a304 100644 --- a/raman_master/models/nn_training.py +++ b/raman_master/models/nn_training.py @@ -12,7 +12,7 @@ from ray import train from raman_master.models.loss import MSEIgnoreNans, MSEIgnoreNans2d from raman_master.models.rezero_net import ResNetEncoder from raman_master.models.transformer import ( - ResNetDecoder, RamanTransformer, TransformerRegressor, PatchEncoder, PatchDecoder + ResNetDecoder, RamanTransformerEncoder, TransformerRegressor, PatchEncoder, PatchDecoder ) @@ -336,7 +336,7 @@ def self_supervised_training( spatial_embedding_dim = encoder.spatial_dims[-1] trans_encoder = torch.jit.script( - RamanTransformer( + RamanTransformerEncoder( d_model=config["t_d_model"], nhead=config["t_nhead"], dim_feedforward=config["t_dim_feedforward"], diff --git a/raman_master/models/transformer.py b/raman_master/models/transformer.py index 7966e88..071925d 100644 --- a/raman_master/models/transformer.py +++ b/raman_master/models/transformer.py @@ -7,7 +7,7 @@ from raman_master.models.rezero_net import ReZeroBlock from raman_master.utils import num_parameter -class RamanTransformer(torch.nn.Module): +class RamanTransformerEncoder(torch.nn.Module): def __init__( self, d_model, @@ -26,10 +26,13 @@ class RamanTransformer(torch.nn.Module): super().__init__() self.num_cls_tokens = num_cls_tokens - self.cls_token = torch.nn.Parameter( - torch.randn((1, num_cls_tokens, d_model)), - requires_grad=True, - ) + self.embedding_dim = d_model + # self.cls_token = torch.nn.Parameter( + # torch.randn((1, num_cls_tokens, d_model)), + # requires_grad=True, + # ) + # cls tokens are learned together with the positional encoding + self.positional_encoding = torch.nn.Parameter( torch.randn((1, num_cls_tokens + spatial_dim, d_model)), requires_grad=True, @@ -57,12 +60,14 @@ class RamanTransformer(torch.nn.Module): def forward(self, x): # encoder and decoder operate on (batch, channel, sequence) - # but transformer works on (batch, sequence, channel) + # and transformer works on (batch, sequence, channel) return torch.transpose( self.trans_encoder( torch.concatenate( [ - torch.tile(self.cls_token, dims=(len(x), 1, 1)), + # add cls token(s) + torch.zeros(len(x), self.num_cls_tokens, self.embedding_dim), + # torch.tile(self.cls_token, dims=(len(x), 1, 1)), torch.transpose(x, 1, 2), ], dim=1, @@ -176,7 +181,7 @@ class TransformerRegressor(torch.nn.Module): self.trans_encoder = trans_encoder self.fc_dims = [ - trans_encoder.cls_token.shape[-1] * trans_encoder.num_cls_tokens + trans_encoder.embedding_dim * trans_encoder.num_cls_tokens ] + fc_dims self.fc_output_channels = fc_output_channels fc_layers = [] @@ -213,18 +218,31 @@ class PatchEncoder(torch.nn.Module): def __init__( self, patch_size, + embedding_dim=None, verbose=False, ): super().__init__() self.patch_size = patch_size + self.embedding_dim = embedding_dim or patch_size + + self.to_patch_embedding = torch.nn.Sequential( + torch.nn.LayerNorm(patch_size), + torch.nn.Linear(patch_size, self.embedding_dim), + torch.nn.LayerNorm(self.embedding_dim), + ) if verbose: print("Patch Encoder with patch_size: %s" % patch_size) + def reshape(self, x): + return x.reshape(len(x), -1, self.patch_size) + + def embed(self, x): + return self.to_patch_embedding(x).permute(0, 2, 1) def forward(self, x): # input is (batch, 1, sequence) - # we want to get (batch, channel, sequence) - return x.reshape(len(x), -1, self.patch_size).permute(0, 2, 1) + # we want to get (batch, channel, reduced_sequence) + return self.embed(self.reshape(x)) class PatchDecoder(torch.nn.Module): diff --git a/tests/models/test_transformer.py b/tests/models/test_transformer.py index e7b4731..3a4c1ec 100644 --- a/tests/models/test_transformer.py +++ b/tests/models/test_transformer.py @@ -3,7 +3,7 @@ from torch.nn import TransformerEncoder, TransformerEncoderLayer from raman_master.models.rezero_net import ResNetEncoder from raman_master.models.transformer import ( - ResNetDecoder, RamanTransformer, TransformerRegressor, PatchEncoder, PatchDecoder + ResNetDecoder, RamanTransformerEncoder, TransformerRegressor, PatchEncoder, PatchDecoder ) from raman_master.utils import num_parameter @@ -57,7 +57,7 @@ def test_basic_raman_transformer(): num_blocks=2, verbose=True, ) - trans_encoder = RamanTransformer( + trans_encoder = RamanTransformerEncoder( d_model=32, nhead=8, dim_feedforward=256, @@ -90,7 +90,7 @@ def test_encoding_and_decoding_with_raman_transformer(): num_blocks=2, verbose=True, ) - trans_encoder = RamanTransformer( + trans_encoder = RamanTransformerEncoder( d_model=32, nhead=8, dim_feedforward=256, @@ -135,7 +135,7 @@ def test_transformer_regressor_2_cls_tokens(): num_blocks=2, verbose=True, ) - trans_encoder = RamanTransformer( + trans_encoder = RamanTransformerEncoder( d_model=32, nhead=8, dim_feedforward=256, @@ -179,16 +179,13 @@ def test_patch_encoder(): def test_patch_encoder_2(): # given - dummy_spectrum = torch.tensor([[[1, 2, 3, 4]], [[11, 12, 13, 14]]]) + dummy_spectrum = torch.tensor([[[1, 2, 3, 4.]], [[11, 12, 13, 14]]]) # when - patched_spec = PatchEncoder(patch_size=2)(dummy_spectrum) + patched_spec = PatchEncoder(patch_size=2, embedding_dim=10)(dummy_spectrum) # then - torch.testing.assert_allclose( - patched_spec, - torch.tensor([[[1, 3], [2, 4]], [[11, 13], [12, 14]]]) - ) + assert patched_spec.shape == (2, 10, 2) def test_patch_decoder(): @@ -214,3 +211,70 @@ def test_patch_decoder_2(): patched_spec, torch.tensor([[[1, 2, 3, 4]], [[11, 12, 13, 14]]]) ) + + +def test_transformer_regressor_patch_en_de_coding(): + # given + dummy_spectra = torch.randn((16, 1, 1024)) + patch_encoder = PatchEncoder(patch_size=32) + trans_encoder = RamanTransformerEncoder( + d_model=32, + nhead=8, + dim_feedforward=256, + dropout=0.1, + activation="gelu", + batch_first=True, + norm_first=False, + bias=True, + num_layers=2, + spatial_dim=32, + num_cls_tokens=2, + ) + regressor = TransformerRegressor( + cnn_encoder=patch_encoder, + trans_encoder=trans_encoder, + fc_dims=[8, 8], + fc_dropout=0.1, + ) + + # when + predictions = regressor(dummy_spectra) + + # then + assert predictions.shape == (16, 8) + + +def test_transformer_regressor_different_patch_embedding_dim(): + # given + dummy_spectra = torch.randn((16, 1, 1024)) + embedding_dim = 32 + patch_size = 16 + patch_encoder = PatchEncoder( + patch_size=patch_size, + embedding_dim=embedding_dim, + ) + trans_encoder = RamanTransformerEncoder( + d_model=embedding_dim, + nhead=8, + dim_feedforward=128, + dropout=0.1, + activation="gelu", + batch_first=True, + norm_first=False, + bias=True, + num_layers=2, + spatial_dim=int(dummy_spectra.shape[-1] / patch_size), + num_cls_tokens=2, + ) + regressor = TransformerRegressor( + cnn_encoder=patch_encoder, + trans_encoder=trans_encoder, + fc_dims=[8, 8], + fc_dropout=0.1, + ) + + # when + predictions = regressor(dummy_spectra) + + # then + assert predictions.shape == (16, 8) -- GitLab From 4615ccb3ea92d918e44da977087c15062edf46bc Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Fri, 1 Nov 2024 19:14:39 +0100 Subject: [PATCH 2/8] first version mae --- raman_master/models/mae.py | 128 +++++++++++++++++++++++++++++++++++++ tests/models/test_mae.py | 39 +++++++++++ 2 files changed, 167 insertions(+) create mode 100644 raman_master/models/mae.py create mode 100644 tests/models/test_mae.py diff --git a/raman_master/models/mae.py b/raman_master/models/mae.py new file mode 100644 index 0000000..1239471 --- /dev/null +++ b/raman_master/models/mae.py @@ -0,0 +1,128 @@ +import torch +from ray.tune.examples.pbt_dcgan_mnist.common import batch_size + + +class MAE(torch.nn.Module): + def __init__( + self, + *, + encoder, + embedding_dim, + n_head, + dim_feedforward, + t_dropout, + t_activation, + encoder_depth, + decoder_depth, + spectra_size, + masking_ratio, + num_cls_tokens=1, + ): + super().__init__() + self.masking_ratio = masking_ratio + self.embedding_dim = embedding_dim + + self.encoder = encoder + num_patches = int(spectra_size / encoder.patch_size) + + self.num_cls_tokens = num_cls_tokens + self.cls_tokens = torch.nn.Parameter( + torch.randn((1, num_cls_tokens, embedding_dim)), + requires_grad=True, + ) + + + # transformer encoder + self.trans_encoder = torch.nn.TransformerEncoder( + encoder_layer=torch.nn.TransformerEncoderLayer( + d_model=embedding_dim, + nhead=n_head, + dim_feedforward=dim_feedforward, + dropout=t_dropout, + activation=t_activation, + ), + num_layers=encoder_depth, + ) + + self.to_patch = encoder.to_patch_embedding[0] + self.patch_to_emb = torch.nn.Sequential(*encoder.to_patch_embedding[1:]) + + # decoder parameters + self.mask_token = torch.nn.Parameter(torch.randn(embedding_dim)) + + self.trans_decoder = torch.nn.TransformerEncoder( + encoder_layer=torch.nn.TransformerEncoderLayer( + d_model=embedding_dim, + nhead=n_head, + dim_feedforward=dim_feedforward, + dropout=t_dropout, + activation=t_activation, + ), + num_layers=decoder_depth, + ) + + self.positional_embedding = torch.nn.Embedding(num_patches, embedding_dim) + self.back_to_spectrum = torch.nn.Linear(embedding_dim, encoder.patch_size) + + def forward(self, x): + # transformer needs shape (batch, sequence, embedding_dim) + embeddings = torch.transpose(self.encoder(x), 1, 2) + batch_size, num_patches, _ = embeddings.shape + + # mask embeddings + num_masked = int(self.masking_ratio * embeddings.shape[1]) + shuffled_indices = torch.rand( + batch_size, + num_patches, + device=x.device, + ).argsort(dim=-1) + batch_range = torch.arange(batch_size, device=x.device)[:, None] + masked_indices = shuffled_indices[:, :num_masked] + unmasked_indices = shuffled_indices[:, num_masked:] + + # get the unmasked tokens to be encoded + un_masked_embeddings = torch.concatenate( + [ + # add cls tokens + torch.tile(self.cls_tokens, (batch_size, 1, 1)), + # add positional encoding to unmasked part + torch.add( + embeddings[batch_range, unmasked_indices], + self.positional_embedding(unmasked_indices), + ) + ], + dim=1, + ) + # transformer encoder + encoded = self.trans_encoder(un_masked_embeddings) + cls_embedding = encoded[:, :self.num_cls_tokens, :] + patch_encoding = encoded[:, self.num_cls_tokens:, :] + + # add positional info for transformer to unmasked tokens + unmasked_encoded_tokens = torch.add( + patch_encoding, + self.positional_embedding(unmasked_indices), + ) + # repeat mask tokens for number of masked, and add the positions using the masked indices derived above + mask_tokens = torch.add( + torch.tile(self.mask_token, (batch_size, num_masked, 1)), + self.positional_embedding(masked_indices), + ) + # join the masked tokens and the embedding in the right order for spectrum reconstruction + decoder_tokens = torch.zeros( + batch_size, self.num_cls_tokens + num_patches, self.embedding_dim, device=x.device + ) + decoder_tokens[:, self.num_cls_tokens:] = torch.add( + cls_embedding, + torch.tile(self.cls_tokens, (batch_size, 1, 1)), + ) + decoder_tokens[:, unmasked_indices + self.num_cls_tokens] = unmasked_encoded_tokens + decoder_tokens[:, masked_indices + self.num_cls_tokens] = mask_tokens + patched_reconstruction = self.back_to_spectrum( + self.trans_decoder(decoder_tokens)[:, self.num_cls_tokens:, :] + ) + + return ( + torch.transpose(patched_reconstruction, 1, 2).reshape(batch_size, 1, -1), + masked_indices, + ) diff --git a/tests/models/test_mae.py b/tests/models/test_mae.py new file mode 100644 index 0000000..5f5103f --- /dev/null +++ b/tests/models/test_mae.py @@ -0,0 +1,39 @@ +import torch + +from raman_master.models import MAE +from raman_master.models.transformer import PatchEncoder, RamanTransformerEncoder + + +def test_masked_auto_encoder_transformer(): + # given + dummy_spectra = torch.randn((12, 1, 1024)) + embedding_dim = 20 + patch_size = 16 + patch_encoder = PatchEncoder( + patch_size=patch_size, + embedding_dim=embedding_dim, + ) + masking_ratio = 0.8 + + mae = MAE( + encoder=patch_encoder, + embedding_dim=embedding_dim, + n_head=5, + dim_feedforward=128, + t_dropout=0.1, + t_activation="gelu", + encoder_depth=2, + decoder_depth=2, + spectra_size=dummy_spectra.shape[2], + masking_ratio=masking_ratio, + ) + + # when + reconstruction, masked_indices = mae(dummy_spectra) + + # then + assert reconstruction.shape == dummy_spectra.shape + assert masked_indices.shape == ( + dummy_spectra.shape[0], + int(masking_ratio * dummy_spectra.shape[-1] / patch_size) + ) -- GitLab From 10385f3d07e809df53aba727a2fba7bdb5450dc4 Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Fri, 1 Nov 2024 19:22:07 +0100 Subject: [PATCH 3/8] linting --- raman_master/models/mae.py | 16 +++++++++------- raman_master/models/nn_training.py | 6 +++++- raman_master/models/transformer.py | 1 + tests/models/test_mae.py | 2 +- tests/models/test_transformer.py | 6 +++++- 5 files changed, 21 insertions(+), 10 deletions(-) diff --git a/raman_master/models/mae.py b/raman_master/models/mae.py index 1239471..1d18098 100644 --- a/raman_master/models/mae.py +++ b/raman_master/models/mae.py @@ -1,5 +1,4 @@ import torch -from ray.tune.examples.pbt_dcgan_mnist.common import batch_size class MAE(torch.nn.Module): @@ -31,7 +30,6 @@ class MAE(torch.nn.Module): requires_grad=True, ) - # transformer encoder self.trans_encoder = torch.nn.TransformerEncoder( encoder_layer=torch.nn.TransformerEncoderLayer( @@ -99,24 +97,28 @@ class MAE(torch.nn.Module): patch_encoding = encoded[:, self.num_cls_tokens:, :] # add positional info for transformer to unmasked tokens - unmasked_encoded_tokens = torch.add( + unmasked_encodings = torch.add( patch_encoding, self.positional_embedding(unmasked_indices), ) - # repeat mask tokens for number of masked, and add the positions using the masked indices derived above + # join mask tokens and positional encodings mask_tokens = torch.add( torch.tile(self.mask_token, (batch_size, num_masked, 1)), self.positional_embedding(masked_indices), ) - # join the masked tokens and the embedding in the right order for spectrum reconstruction + # join the cls embedding, the masked tokens and the embedding + # they are in the right order for spectrum reconstruction decoder_tokens = torch.zeros( - batch_size, self.num_cls_tokens + num_patches, self.embedding_dim, device=x.device + batch_size, + self.num_cls_tokens + num_patches, + self.embedding_dim, + device=x.device ) decoder_tokens[:, self.num_cls_tokens:] = torch.add( cls_embedding, torch.tile(self.cls_tokens, (batch_size, 1, 1)), ) - decoder_tokens[:, unmasked_indices + self.num_cls_tokens] = unmasked_encoded_tokens + decoder_tokens[:, unmasked_indices + self.num_cls_tokens] = unmasked_encodings decoder_tokens[:, masked_indices + self.num_cls_tokens] = mask_tokens patched_reconstruction = self.back_to_spectrum( self.trans_decoder(decoder_tokens)[:, self.num_cls_tokens:, :] diff --git a/raman_master/models/nn_training.py b/raman_master/models/nn_training.py index 5b0a304..9cbcd60 100644 --- a/raman_master/models/nn_training.py +++ b/raman_master/models/nn_training.py @@ -12,7 +12,11 @@ from ray import train from raman_master.models.loss import MSEIgnoreNans, MSEIgnoreNans2d from raman_master.models.rezero_net import ResNetEncoder from raman_master.models.transformer import ( - ResNetDecoder, RamanTransformerEncoder, TransformerRegressor, PatchEncoder, PatchDecoder + ResNetDecoder, + RamanTransformerEncoder, + PatchDecoder, + PatchEncoder, + TransformerRegressor, ) diff --git a/raman_master/models/transformer.py b/raman_master/models/transformer.py index 071925d..cad7960 100644 --- a/raman_master/models/transformer.py +++ b/raman_master/models/transformer.py @@ -233,6 +233,7 @@ class PatchEncoder(torch.nn.Module): if verbose: print("Patch Encoder with patch_size: %s" % patch_size) + def reshape(self, x): return x.reshape(len(x), -1, self.patch_size) diff --git a/tests/models/test_mae.py b/tests/models/test_mae.py index 5f5103f..32cbbf3 100644 --- a/tests/models/test_mae.py +++ b/tests/models/test_mae.py @@ -1,7 +1,7 @@ import torch from raman_master.models import MAE -from raman_master.models.transformer import PatchEncoder, RamanTransformerEncoder +from raman_master.models.transformer import PatchEncoder def test_masked_auto_encoder_transformer(): diff --git a/tests/models/test_transformer.py b/tests/models/test_transformer.py index 3a4c1ec..29c6661 100644 --- a/tests/models/test_transformer.py +++ b/tests/models/test_transformer.py @@ -3,7 +3,11 @@ from torch.nn import TransformerEncoder, TransformerEncoderLayer from raman_master.models.rezero_net import ResNetEncoder from raman_master.models.transformer import ( - ResNetDecoder, RamanTransformerEncoder, TransformerRegressor, PatchEncoder, PatchDecoder + RamanTransformerEncoder, + ResNetDecoder, + PatchDecoder, + PatchEncoder, + TransformerRegressor, ) from raman_master.utils import num_parameter -- GitLab From fc3f2e56861d9dc992a09618c1b621a3f9bbed80 Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Mon, 4 Nov 2024 21:35:35 +0100 Subject: [PATCH 4/8] seperated mae and mae_encoder --- .../train_nn_on_1d_spectra.ipynb | 2 +- raman_master/models/__init__.py | 2 +- raman_master/models/mae.py | 118 +++++++++++++----- tests/models/test_mae.py | 45 ++++++- 4 files changed, 127 insertions(+), 40 deletions(-) diff --git a/notebooks/neural_networks/train_nn_on_1d_spectra.ipynb b/notebooks/neural_networks/train_nn_on_1d_spectra.ipynb index 34e7bd6..98785a4 100644 --- a/notebooks/neural_networks/train_nn_on_1d_spectra.ipynb +++ b/notebooks/neural_networks/train_nn_on_1d_spectra.ipynb @@ -416,7 +416,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/raman_master/models/__init__.py b/raman_master/models/__init__.py index 0c80bba..4fd88dd 100644 --- a/raman_master/models/__init__.py +++ b/raman_master/models/__init__.py @@ -3,7 +3,7 @@ from .nn_training import simple_training from .rezero_net import ReZeroNet from .resnext import ResNext from .fc_resnext import FCResNext -from .mae import MAE +from .mae import MAE, MAEEncoder __all__ = [ diff --git a/raman_master/models/mae.py b/raman_master/models/mae.py index 1d18098..499b14c 100644 --- a/raman_master/models/mae.py +++ b/raman_master/models/mae.py @@ -1,28 +1,30 @@ import torch +from raman_master.models.transformer import PatchEncoder -class MAE(torch.nn.Module): + +class MAEEncoder(torch.nn.Module): def __init__( self, *, - encoder, + patch_size, embedding_dim, n_head, dim_feedforward, t_dropout, t_activation, encoder_depth, - decoder_depth, spectra_size, - masking_ratio, num_cls_tokens=1, ): super().__init__() - self.masking_ratio = masking_ratio self.embedding_dim = embedding_dim - self.encoder = encoder - num_patches = int(spectra_size / encoder.patch_size) + self.patch_encoder = PatchEncoder( + patch_size=patch_size, + embedding_dim=embedding_dim, + ) + num_patches = int(spectra_size / patch_size) self.num_cls_tokens = num_cls_tokens self.cls_tokens = torch.nn.Parameter( @@ -41,9 +43,70 @@ class MAE(torch.nn.Module): ), num_layers=encoder_depth, ) + self.positional_embedding = torch.nn.Embedding( + num_patches, + embedding_dim, + ) + + def forward(self, x, position_idxs): + # input spectrum has shape (batch, 1, spectrum_size / sequence) + # transformer needs shape (batch, sequence, embedding_dim) + embeddings = torch.transpose(self.patch_encoder(x), 1, 2) + batch_size, num_patches, _ = embeddings.shape + batch_range = torch.arange(batch_size, device=x.device)[:, None] + + # transformer encoder + encoded = self.trans_encoder( + torch.concatenate( + [ + # add cls tokens + torch.tile(self.cls_tokens, (batch_size, 1, 1)), + # add positional encoding to unmasked part + torch.add( + embeddings[batch_range, position_idxs], + self.positional_embedding(position_idxs), + ) + ], + dim=1, + ) + ) + + return encoded + + +class MAE(torch.nn.Module): + def __init__( + self, + *, + patch_size, + embedding_dim, + n_head, + dim_feedforward, + t_dropout, + t_activation, + encoder_depth, + decoder_depth, + spectra_size, + masking_ratio, + num_cls_tokens=1, + ): + super().__init__() + self.masking_ratio = masking_ratio + self.embedding_dim = embedding_dim - self.to_patch = encoder.to_patch_embedding[0] - self.patch_to_emb = torch.nn.Sequential(*encoder.to_patch_embedding[1:]) + # transformer encoder + self.num_cls_tokens = num_cls_tokens + self.mae_encoder = MAEEncoder( + patch_size=patch_size, + embedding_dim=embedding_dim, + n_head=n_head, + dim_feedforward=dim_feedforward, + t_dropout=t_dropout, + t_activation=t_activation, + encoder_depth=encoder_depth, + spectra_size=spectra_size, + num_cls_tokens=num_cls_tokens, + ) # decoder parameters self.mask_token = torch.nn.Parameter(torch.randn(embedding_dim)) @@ -59,52 +122,41 @@ class MAE(torch.nn.Module): num_layers=decoder_depth, ) - self.positional_embedding = torch.nn.Embedding(num_patches, embedding_dim) - self.back_to_spectrum = torch.nn.Linear(embedding_dim, encoder.patch_size) + self.back_to_spectrum = torch.nn.Linear( + embedding_dim, + patch_size, + ) def forward(self, x): + # input is (batch, 1, spectrum_size) # transformer needs shape (batch, sequence, embedding_dim) - embeddings = torch.transpose(self.encoder(x), 1, 2) - batch_size, num_patches, _ = embeddings.shape + batch_size = x.shape[0] + num_patches = self.mae_encoder.positional_embedding.num_embeddings # mask embeddings - num_masked = int(self.masking_ratio * embeddings.shape[1]) + num_masked = int(self.masking_ratio * num_patches) shuffled_indices = torch.rand( batch_size, num_patches, device=x.device, ).argsort(dim=-1) - batch_range = torch.arange(batch_size, device=x.device)[:, None] masked_indices = shuffled_indices[:, :num_masked] unmasked_indices = shuffled_indices[:, num_masked:] # get the unmasked tokens to be encoded - un_masked_embeddings = torch.concatenate( - [ - # add cls tokens - torch.tile(self.cls_tokens, (batch_size, 1, 1)), - # add positional encoding to unmasked part - torch.add( - embeddings[batch_range, unmasked_indices], - self.positional_embedding(unmasked_indices), - ) - ], - dim=1, - ) - # transformer encoder - encoded = self.trans_encoder(un_masked_embeddings) + encoded = self.mae_encoder(x, unmasked_indices) cls_embedding = encoded[:, :self.num_cls_tokens, :] patch_encoding = encoded[:, self.num_cls_tokens:, :] # add positional info for transformer to unmasked tokens unmasked_encodings = torch.add( patch_encoding, - self.positional_embedding(unmasked_indices), + self.mae_encoder.positional_embedding(unmasked_indices), ) # join mask tokens and positional encodings mask_tokens = torch.add( torch.tile(self.mask_token, (batch_size, num_masked, 1)), - self.positional_embedding(masked_indices), + self.mae_encoder.positional_embedding(masked_indices), ) # join the cls embedding, the masked tokens and the embedding # they are in the right order for spectrum reconstruction @@ -114,9 +166,9 @@ class MAE(torch.nn.Module): self.embedding_dim, device=x.device ) - decoder_tokens[:, self.num_cls_tokens:] = torch.add( + decoder_tokens[:, :self.num_cls_tokens] = torch.add( cls_embedding, - torch.tile(self.cls_tokens, (batch_size, 1, 1)), + torch.tile(self.mae_encoder.cls_tokens, (batch_size, 1, 1)), ) decoder_tokens[:, unmasked_indices + self.num_cls_tokens] = unmasked_encodings decoder_tokens[:, masked_indices + self.num_cls_tokens] = mask_tokens diff --git a/tests/models/test_mae.py b/tests/models/test_mae.py index 32cbbf3..1ec540e 100644 --- a/tests/models/test_mae.py +++ b/tests/models/test_mae.py @@ -1,22 +1,55 @@ import torch -from raman_master.models import MAE -from raman_master.models.transformer import PatchEncoder +from raman_master.models import MAE, MAEEncoder -def test_masked_auto_encoder_transformer(): +def test_mae_encoder(): # given dummy_spectra = torch.randn((12, 1, 1024)) embedding_dim = 20 patch_size = 16 - patch_encoder = PatchEncoder( + num_patches = int(dummy_spectra.shape[2] / patch_size) + num_cls_tokens = 2 + + mae_encoder = MAEEncoder( patch_size=patch_size, embedding_dim=embedding_dim, + n_head=5, + dim_feedforward=128, + t_dropout=0.1, + t_activation="gelu", + encoder_depth=2, + spectra_size=dummy_spectra.shape[2], + num_cls_tokens=num_cls_tokens, + ) + + # when + mae_encoded_spectrum = mae_encoder( + dummy_spectra, + torch.tile( + torch.arange(num_patches)[None, :], + (dummy_spectra.shape[0], 1), + ) ) + + # then + assert mae_encoded_spectrum.shape == ( + dummy_spectra.shape[0], + num_patches + num_cls_tokens, + embedding_dim, + ) + + +def test_masked_auto_encoder_transformer(): + # given + dummy_spectra = torch.randn((12, 1, 1024)) + embedding_dim = 20 + patch_size = 16 masking_ratio = 0.8 + num_cls_tokens = 3 mae = MAE( - encoder=patch_encoder, + patch_size=patch_size, embedding_dim=embedding_dim, n_head=5, dim_feedforward=128, @@ -26,6 +59,7 @@ def test_masked_auto_encoder_transformer(): decoder_depth=2, spectra_size=dummy_spectra.shape[2], masking_ratio=masking_ratio, + num_cls_tokens=num_cls_tokens, ) # when @@ -37,3 +71,4 @@ def test_masked_auto_encoder_transformer(): dummy_spectra.shape[0], int(masking_ratio * dummy_spectra.shape[-1] / patch_size) ) + assert isinstance(mae.mae_encoder, MAEEncoder) -- GitLab From 10a224911af0dd3877418f4792cd38a62d0fb25d Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Thu, 7 Nov 2024 20:42:56 +0100 Subject: [PATCH 5/8] working version of mae --- notebooks/neural_networks/split_data.ipynb | 102 +++++-- raman_master/models/hp_tuning.py | 12 +- raman_master/models/mae.py | 339 +++++++++++++++++++-- raman_master/models/transformer.py | 5 +- tests/conftest.py | 36 +++ tests/models/test_mae.py | 68 ++++- 6 files changed, 516 insertions(+), 46 deletions(-) diff --git a/notebooks/neural_networks/split_data.ipynb b/notebooks/neural_networks/split_data.ipynb index af1fef8..53a58c0 100644 --- a/notebooks/neural_networks/split_data.ipynb +++ b/notebooks/neural_networks/split_data.ipynb @@ -75,6 +75,11 @@ " \"Phosphate\",\n", " \"Yeast_Extract\",\n", " # \"Dextrin\",\n", + " \"total_phosphate\",\n", + " \"potassium_hydrogen_phosphate\",\n", + " \"sodium_dihydrogen_phosphate\",\n", + " \"total_sulfate\",\n", + " \"Ammonium_Sulfate\",\n", " ]\n", "\n", "load_from_disk = False\n", @@ -108,8 +113,8 @@ " for exp_id, items in exp_data_mock.items()\n", "} \n", "\n", - "names[3] = \"Acetate\"\n", - "label_mock[:, 3] = 0.70930 * label_mock[:, 3]\n", + "# concentrations_of_interest[3] = \"Acetate\"\n", + "# label_mock[:, 3] = 0.70930 * label_mock[:, 3]\n", "\n", "\n", "\n", @@ -153,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "id": "d1f52e45-262f-4339-a883-3bb523d34f06", "metadata": {}, "outputs": [ @@ -212,34 +217,95 @@ " 'EnPump_device': 'Tecan',\n", " 'EnPump_analysis_method': 'offline',\n", " 'EnPump_label': '',\n", + " 'sodium_dihydrogen_phosphate': 0.0,\n", + " 'sodium_dihydrogen_phosphate_device': 'Tecan',\n", + " 'sodium_dihydrogen_phosphate_analysis_method': 'offline',\n", + " 'sodium_dihydrogen_phosphate_label': '',\n", + " 'Phosphate_2': 0.0,\n", + " 'Phosphate_2_device': 'Tecan',\n", + " 'Phosphate_2_analysis_method': 'offline',\n", + " 'Phosphate_2_label': '',\n", + " 'EnPump_2': 0.0,\n", + " 'EnPump_2_device': 'Tecan',\n", + " 'EnPump_2_analysis_method': 'offline',\n", + " 'EnPump_2_label': '',\n", + " 'total_phosphate': 0.0,\n", + " 'total_phosphate_device': 'Tecan',\n", + " 'total_phosphate_analysis_method': 'offline',\n", + " 'total_phosphate_label': '',\n", + " 'raman_low_intensity_2': 0.0,\n", + " 'raman_low_intensity_2_device': 'Tecan',\n", + " 'raman_low_intensity_2_analysis_method': 'offline',\n", + " 'raman_low_intensity_2_label': '',\n", + " 'Nitrate_2': 0.0,\n", + " 'Nitrate_2_device': 'Tecan',\n", + " 'Nitrate_2_analysis_method': 'offline',\n", + " 'Nitrate_2_label': '',\n", + " 'pH_over_13_2': 0.0,\n", + " 'pH_over_13_2_device': 'Tecan',\n", + " 'pH_over_13_2_analysis_method': 'offline',\n", + " 'pH_over_13_2_label': '',\n", + " 'Sodium_Sulfate': 0.0,\n", + " 'Sodium_Sulfate_device': 'Tecan',\n", + " 'Sodium_Sulfate_analysis_method': 'offline',\n", + " 'Sodium_Sulfate_label': '',\n", + " 'Yeast_Extract_2': 0.0,\n", + " 'Yeast_Extract_2_device': 'Tecan',\n", + " 'Yeast_Extract_2_analysis_method': 'offline',\n", + " 'Yeast_Extract_2_label': '',\n", + " 'potassium_hydrogen_phosphate': 0.0,\n", + " 'potassium_hydrogen_phosphate_device': 'Tecan',\n", + " 'potassium_hydrogen_phosphate_analysis_method': 'offline',\n", + " 'potassium_hydrogen_phosphate_label': '',\n", + " 'Antifoam_2': 0.0,\n", + " 'Antifoam_2_device': 'Tecan',\n", + " 'Antifoam_2_analysis_method': 'offline',\n", + " 'Antifoam_2_label': '',\n", + " 'total_sulfate': 3.598139296,\n", + " 'total_sulfate_device': 'Tecan',\n", + " 'total_sulfate_analysis_method': 'offline',\n", + " 'total_sulfate_label': '',\n", + " 'contains_MSM_2': 0.0,\n", + " 'contains_MSM_2_device': 'Tecan',\n", + " 'contains_MSM_2_analysis_method': 'offline',\n", + " 'contains_MSM_2_label': '',\n", + " 'Glycerol_2': 0.0,\n", + " 'Glycerol_2_device': 'Tecan',\n", + " 'Glycerol_2_analysis_method': 'offline',\n", + " 'Glycerol_2_label': '',\n", + " 'Ammonium_Sulfate': 0.0,\n", + " 'Ammonium_Sulfate_device': 'Tecan',\n", + " 'Ammonium_Sulfate_analysis_method': 'offline',\n", + " 'Ammonium_Sulfate_label': '',\n", + " 'raman_measures_air_2': 0.0,\n", + " 'raman_measures_air_2_device': 'Tecan',\n", + " 'raman_measures_air_2_analysis_method': 'offline',\n", + " 'raman_measures_air_2_label': '',\n", " 'Acetate': 0.9948694366223}" ] }, - "execution_count": 9, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "for exp_id, items in exp_data_mock.items():\n", - " for item in items:\n", - " item[\"annotations\"][\n", "exp_data_mock[21592][0][\"annotations\"]" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "fcb68746-b8fd-41e0-aa8d-b205156101d6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(7486, 630)" + "(7486, 629)" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -263,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "id": "bdbe98ec-22b3-4f71-92c0-1173d48cc8ab", "metadata": {}, "outputs": [], @@ -293,7 +359,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "id": "13cbbcfb-e563-42bc-9976-762b14782f0a", "metadata": {}, "outputs": [ @@ -303,7 +369,7 @@ "(5218, 1525, 743)" ] }, - "execution_count": 12, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -335,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "id": "7885834c-12d5-4c6d-a4b8-e5dc360ed638", "metadata": {}, "outputs": [], @@ -369,17 +435,17 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "id": "c4678c97-ce35-4a99-973b-740627144655", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(182, 206, 242)" + "(182, 206, 241)" ] }, - "execution_count": 14, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -426,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "id": "075eec95-9119-448c-a0fb-508deca69fdb", "metadata": {}, "outputs": [], diff --git a/raman_master/models/hp_tuning.py b/raman_master/models/hp_tuning.py index a1912dc..5c54f93 100644 --- a/raman_master/models/hp_tuning.py +++ b/raman_master/models/hp_tuning.py @@ -12,7 +12,7 @@ from raman_master.utils import ( ) -def load_spectra_and_labels_fs(directory): +def load_spectra_and_labels_fs(directory, lower_wn=390, upper_wn=3400): # these dependencies should be configurable in the future: exp_ids = [ 21592, @@ -34,9 +34,6 @@ def load_spectra_and_labels_fs(directory): 21967, ] - lower_wn = 390 - upper_wn = 3400 - concentrations_of_interest = [ 'Glucose', 'Glycerol', @@ -47,7 +44,12 @@ def load_spectra_and_labels_fs(directory): "Phosphate", "Yeast_Extract", # "Dextrin", - ] + "total_phosphate", + "potassium_hydrogen_phosphate", + "sodium_dihydrogen_phosphate", + "total_sulfate", + "Ammonium_Sulfate", + ] exp_data, run_data = read_spectra_from_fs( experiment_ids=exp_ids, diff --git a/raman_master/models/mae.py b/raman_master/models/mae.py index 499b14c..eae83a9 100644 --- a/raman_master/models/mae.py +++ b/raman_master/models/mae.py @@ -1,5 +1,9 @@ +import random + import torch +from torch.optim.lr_scheduler import CosineAnnealingLR +from raman_master.models.loss import MSEIgnoreNans from raman_master.models.transformer import PatchEncoder @@ -16,20 +20,22 @@ class MAEEncoder(torch.nn.Module): encoder_depth, spectra_size, num_cls_tokens=1, + dtype=None ): super().__init__() self.embedding_dim = embedding_dim + dtype = dtype or torch.float32 self.patch_encoder = PatchEncoder( patch_size=patch_size, embedding_dim=embedding_dim, ) - num_patches = int(spectra_size / patch_size) + self.num_patches = int(spectra_size / patch_size) self.num_cls_tokens = num_cls_tokens - self.cls_tokens = torch.nn.Parameter( - torch.randn((1, num_cls_tokens, embedding_dim)), - requires_grad=True, + self.cls_tokens = torch.nn.Embedding( + self.num_cls_tokens, + embedding_dim, ) # transformer encoder @@ -40,11 +46,13 @@ class MAEEncoder(torch.nn.Module): dim_feedforward=dim_feedforward, dropout=t_dropout, activation=t_activation, + dtype=dtype, + batch_first=True, ), num_layers=encoder_depth, ) self.positional_embedding = torch.nn.Embedding( - num_patches, + self.num_patches, embedding_dim, ) @@ -52,15 +60,20 @@ class MAEEncoder(torch.nn.Module): # input spectrum has shape (batch, 1, spectrum_size / sequence) # transformer needs shape (batch, sequence, embedding_dim) embeddings = torch.transpose(self.patch_encoder(x), 1, 2) + embeddings = self.patch_encoder(x) batch_size, num_patches, _ = embeddings.shape batch_range = torch.arange(batch_size, device=x.device)[:, None] + cls_token_idxs = torch.tile( + torch.arange(self.num_cls_tokens, device=x.device)[None, :], + (batch_size, 1), + ) # transformer encoder encoded = self.trans_encoder( torch.concatenate( [ # add cls tokens - torch.tile(self.cls_tokens, (batch_size, 1, 1)), + self.cls_tokens(cls_token_idxs), # add positional encoding to unmasked part torch.add( embeddings[batch_range, position_idxs], @@ -89,10 +102,16 @@ class MAE(torch.nn.Module): spectra_size, masking_ratio, num_cls_tokens=1, + dtype=None, + add_positional_in_decoder=True, + **kwargs, ): super().__init__() self.masking_ratio = masking_ratio self.embedding_dim = embedding_dim + self.patch_size = patch_size + self.add_positional_in_decoder = add_positional_in_decoder + dtype = dtype or torch.float32 # transformer encoder self.num_cls_tokens = num_cls_tokens @@ -106,10 +125,13 @@ class MAE(torch.nn.Module): encoder_depth=encoder_depth, spectra_size=spectra_size, num_cls_tokens=num_cls_tokens, + dtype=dtype, ) # decoder parameters - self.mask_token = torch.nn.Parameter(torch.randn(embedding_dim)) + self.mask_token = torch.nn.Parameter( + torch.randn(embedding_dim, dtype=dtype), + ) self.trans_decoder = torch.nn.TransformerEncoder( encoder_layer=torch.nn.TransformerEncoderLayer( @@ -118,6 +140,8 @@ class MAE(torch.nn.Module): dim_feedforward=dim_feedforward, dropout=t_dropout, activation=t_activation, + dtype=dtype, + batch_first=True, ), num_layers=decoder_depth, ) @@ -125,6 +149,7 @@ class MAE(torch.nn.Module): self.back_to_spectrum = torch.nn.Linear( embedding_dim, patch_size, + dtype=dtype, ) def forward(self, x): @@ -139,20 +164,23 @@ class MAE(torch.nn.Module): batch_size, num_patches, device=x.device, + dtype=x.dtype, ).argsort(dim=-1) masked_indices = shuffled_indices[:, :num_masked] unmasked_indices = shuffled_indices[:, num_masked:] # get the unmasked tokens to be encoded + # (batch, seq, feature) encoded = self.mae_encoder(x, unmasked_indices) cls_embedding = encoded[:, :self.num_cls_tokens, :] patch_encoding = encoded[:, self.num_cls_tokens:, :] - # add positional info for transformer to unmasked tokens - unmasked_encodings = torch.add( - patch_encoding, - self.mae_encoder.positional_embedding(unmasked_indices), - ) + if self.add_positional_in_decoder: + # add positional info for transformer to unmasked tokens + patch_encoding = torch.add( + patch_encoding, + self.mae_encoder.positional_embedding(unmasked_indices), + ) # join mask tokens and positional encodings mask_tokens = torch.add( torch.tile(self.mask_token, (batch_size, num_masked, 1)), @@ -164,19 +192,296 @@ class MAE(torch.nn.Module): batch_size, self.num_cls_tokens + num_patches, self.embedding_dim, - device=x.device + device=x.device, + dtype=x.dtype, ) decoder_tokens[:, :self.num_cls_tokens] = torch.add( cls_embedding, - torch.tile(self.mae_encoder.cls_tokens, (batch_size, 1, 1)), + self.mae_encoder.cls_tokens( + torch.tile( + torch.arange(self.num_cls_tokens, device=x.device)[None, :], + (batch_size, 1), + ) + ), ) - decoder_tokens[:, unmasked_indices + self.num_cls_tokens] = unmasked_encodings + decoder_tokens[:, unmasked_indices + self.num_cls_tokens] = patch_encoding decoder_tokens[:, masked_indices + self.num_cls_tokens] = mask_tokens patched_reconstruction = self.back_to_spectrum( self.trans_decoder(decoder_tokens)[:, self.num_cls_tokens:, :] ) + # get mask for spectra parts that have been masked + masked_spectra_mask = torch.tile( + torch.tensor([[False]], device=x.device), + (batch_size, num_patches), + ) + batch_range = torch.arange(batch_size, device=x.device)[:, None] + masked_spectra_mask[batch_range, masked_indices] = True + return ( - torch.transpose(patched_reconstruction, 1, 2).reshape(batch_size, 1, -1), - masked_indices, + # torch.transpose(patched_reconstruction, 1, 2).reshape(batch_size, 1, -1), + patched_reconstruction.reshape(batch_size, 1, -1), + torch.tile( + masked_spectra_mask[:, :, None], + (1, 1, self.patch_size), + ).reshape(batch_size, 1, -1), + ) + + +class FCNet(torch.nn.Module): + def __init__( + self, + *, + fc_dims, + fc_dropout, + fc_activation, + dtype, + **kwargs, + ): + super().__init__() + dtype = dtype or torch.float32 + layers = [] + + for in_dim, out_dim in zip(fc_dims[:-2], fc_dims[1:-1]): + layers.append(torch.nn.Linear(in_dim, out_dim)) + layers.append(torch.nn.Dropout(fc_dropout)) + layers.append(getattr(torch.nn, fc_activation)()) + layers.append(torch.nn.Linear(fc_dims[-2], fc_dims[-1], dtype=dtype)) + self.fc_net = torch.nn.Sequential(*layers) + + def forward(self, x): + return self.fc_net(x) + + +def self_supervised_training( + config, + training_set, + val_set, + num_epochs=10000, + use_gpu=True, + verbose=False, + use_jit=True, +): + random.seed(0) + torch.manual_seed(0) + + device = ( + torch.device("cuda") + if (torch.cuda.is_available() and use_gpu) + else torch.device("cpu") + ) + print("Using device: %s" % device) + + spectra_size = training_set.dataset.spectra.shape[-1] + config["spectra_size"] = spectra_size + if use_jit: + mae = torch.jit.script(MAE(**config).to(device)) + else: + mae = MAE(**config).to(device) + + # prepare the model + + optimizer = torch.optim.AdamW( + list(mae.parameters()), + lr=config.get("base_lr"), + weight_decay=config["weight_decay"], + betas=config["betas"], + ) + scheduler = CosineAnnealingLR( + optimizer, + T_max=config["T_max"], + ) + + start_epoch = 1 + train_losses = [] + val_losses = [] + + for epoch in range(start_epoch, num_epochs + 1): + # training + epoch_train_losses = [] + mae.train() + for one_batch in training_set: + mae.zero_grad(set_to_none=True) + one_batch = {key: value.to(device) for key, value in one_batch.items()} + reconstruction, masked_indices = mae(one_batch["spectra"]) + mse_loss = torch.nn.functional.mse_loss( + reconstruction[masked_indices], + one_batch["filtered_spectra"][masked_indices], + ) + mse_loss.backward() + optimizer.step() + # save losses for later and cut the graph + epoch_train_losses.append(mse_loss.item()) + + train_losses.append(sum(epoch_train_losses) / len(epoch_train_losses)) + scheduler.step() + + # validation + epoch_val_losses = [] + with torch.no_grad(): + for one_batch in val_set: + one_batch = {key: value.to(device) for key, value in one_batch.items()} + reconstruction, masked_indices = mae(one_batch["spectra"]) + epoch_val_losses.append( + torch.nn.functional.mse_loss( + reconstruction[masked_indices], + one_batch["filtered_spectra"][masked_indices], + ).item() + ) + val_losses.append(sum(epoch_val_losses) / len(epoch_val_losses)) + + print( + "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f" + % ( + epoch, + train_losses[-1], + val_losses[-1], + ) + ) + + return ( + mae, + train_losses, + val_losses, + ) + + +def fine_tuning( + config, + trans_encoder, + training_set, + val_set, + num_epochs=10000, + use_gpu=True, + loss_fn=None, + verbose=False, + train_trans_encoder=False, +): + random.seed(0) + torch.manual_seed(0) + + loss_fn = loss_fn or MSEIgnoreNans() + + device = ( + torch.device("cuda") + if (torch.cuda.is_available() and use_gpu) + else torch.device("cpu") + ) + print("Using device: %s" % device) + config["fc_dims"] = [ + config["embedding_dim"] * trans_encoder.num_cls_tokens, + config["fc_dim"], + int(config["fc_dim"] / 2), + training_set.dataset.concentrations.shape[1], + ] + fc_net = torch.jit.script( + FCNet(**config).to(device) + ) + if train_trans_encoder: + trans_encoder.train() + else: + trans_encoder.eval() + + if train_trans_encoder: + params = ( + list(fc_net.parameters()) + + list(trans_encoder.parameters()) ) + else: + params = fc_net.parameters() + + optimizer = torch.optim.AdamW( + params, + lr=config["fine_lr"], + weight_decay=config["fine_weight_decay"], + betas=config["fine_betas"], + ) + scheduler = CosineAnnealingLR( + optimizer, + T_max=config["T_max"], + ) + + start_epoch = 1 + train_losses = [] + val_losses = [] + + for epoch in range(start_epoch, num_epochs + 1): + # training + epoch_train_losses = [] + + for one_batch in training_set: + if train_trans_encoder: + trans_encoder.zero_grad(set_to_none=True) + fc_net.zero_grad(set_to_none=True) + + one_batch = {key: value.to(device) for key, value in one_batch.items()} + batch_size = one_batch["spectra"].shape[0] + + all_patches = torch.tile( + torch.arange(trans_encoder.num_patches, device=device)[None, :], + (batch_size, 1), + ) + + cls_encoding = trans_encoder(one_batch["spectra"], all_patches)[ + :, + :trans_encoder.num_cls_tokens, + : + ] + predictions = fc_net(cls_encoding.view(batch_size, -1)) + + mse_loss = loss_fn( + predictions, + one_batch["concentrations"], + one_batch["label_weight"], + ) + mse_loss.backward() + optimizer.step() + # save losses for later and cut the graph + epoch_train_losses.append(mse_loss.item()) + + train_losses.append(sum(epoch_train_losses) / len(epoch_train_losses)) + scheduler.step() + + # validation + epoch_val_losses = [] + with torch.no_grad(): + for one_batch in val_set: + one_batch = {key: value.to(device) for key, value in one_batch.items()} + batch_size = one_batch["spectra"].shape[0] + + all_patches = torch.tile( + torch.arange(trans_encoder.num_patches, device=device)[None, :], + (batch_size, 1), + ) + + cls_encoding = trans_encoder(one_batch["spectra"], all_patches)[ + :, + :trans_encoder.num_cls_tokens, + : + ] + predictions = fc_net(cls_encoding.view(batch_size, -1)) + + epoch_val_losses.append( + loss_fn( + predictions, + one_batch["concentrations"], + one_batch["label_weight"], + ).item() + ) + val_losses.append(sum(epoch_val_losses) / len(epoch_val_losses)) + + print( + "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f" + % ( + epoch, + train_losses[-1], + val_losses[-1], + ) + ) + + return ( + trans_encoder, + fc_net, + train_losses, + val_losses, + ) diff --git a/raman_master/models/transformer.py b/raman_master/models/transformer.py index cad7960..3feada1 100644 --- a/raman_master/models/transformer.py +++ b/raman_master/models/transformer.py @@ -238,11 +238,12 @@ class PatchEncoder(torch.nn.Module): return x.reshape(len(x), -1, self.patch_size) def embed(self, x): - return self.to_patch_embedding(x).permute(0, 2, 1) + return self.to_patch_embedding(x) + # return self.to_patch_embedding(x).permute(0, 2, 1) def forward(self, x): # input is (batch, 1, sequence) - # we want to get (batch, channel, reduced_sequence) + # we want to get (batch, reduced_sequence, channel) return self.embed(self.reshape(x)) diff --git a/tests/conftest.py b/tests/conftest.py index 933f5f3..2a6b849 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -5,9 +5,12 @@ from concurrent.futures import ThreadPoolExecutor import grpc import pytest import sqlalchemy +import torch import raman_hive +from raman_master.data.torch_datasets import NormalizedSpectra2D + @pytest.fixture def sqlite_engine() -> None: @@ -567,3 +570,36 @@ def grpc_server( server_wait_for_termination.start() yield local_channel grpc_server.stop(1).wait() + + +@pytest.fixture +def data_for_nn(): + train_data = torch.utils.data.DataLoader( + NormalizedSpectra2D( + spectra=torch.randn((64, 1, 256)), + concentrations=torch.randn((64, 3)), + combine_spectra_range=1., + baseline_factor_bound=0.5, + augment_slope_std=1., + augment_intersept_std=1., + rolling_bound=3, + spectrum_rolling_sigma=0.1, + ), + batch_size=32, + ) + val_data = torch.utils.data.DataLoader( + NormalizedSpectra2D( + spectra=torch.randn((64, 1, 256)), + concentrations=torch.randn((64, 3)), + spectra_mean_std=( + train_data.dataset.s_mean, + train_data.dataset.s_std, + ), + concentration_mean_std=( + train_data.dataset.concentration_means, + train_data.dataset.concentration_stds, + ), + ), + batch_size=32, + ) + return train_data, val_data diff --git a/tests/models/test_mae.py b/tests/models/test_mae.py index 1ec540e..64f5dac 100644 --- a/tests/models/test_mae.py +++ b/tests/models/test_mae.py @@ -1,6 +1,8 @@ +import pytest import torch from raman_master.models import MAE, MAEEncoder +from raman_master.models.mae import self_supervised_training, fine_tuning def test_mae_encoder(): @@ -42,6 +44,7 @@ def test_mae_encoder(): def test_masked_auto_encoder_transformer(): # given + torch.manual_seed(0) dummy_spectra = torch.randn((12, 1, 1024)) embedding_dim = 20 patch_size = 16 @@ -67,8 +70,65 @@ def test_masked_auto_encoder_transformer(): # then assert reconstruction.shape == dummy_spectra.shape - assert masked_indices.shape == ( - dummy_spectra.shape[0], - int(masking_ratio * dummy_spectra.shape[-1] / patch_size) - ) + assert masked_indices.shape == dummy_spectra.shape + assert torch.sum(masked_indices).item() / ( + dummy_spectra.shape[0] + * dummy_spectra.shape[1] + * dummy_spectra.shape[2] + ) == pytest.approx(masking_ratio, rel=1e-2) + assert isinstance(mae.mae_encoder, MAEEncoder) + + +def test_self_supervised_transformer_training(data_for_nn): + # given + train_data, val_data = data_for_nn + + model_config = { + "patch_size": 8, + "embedding_dim": 12, + "n_head": 6, + "dim_feedforward": 70, + "t_dropout": 0.1, + "t_activation": "gelu", + "encoder_depth": 1, + "decoder_depth": 1, + "base_lr": 1e-3, + "betas": [0.9, 0.95], + "T_max": 32, + "masking_ratio": 0.8, + "num_cls_tokens": 2, + "weight_decay": 1e-3, + "dtype": torch.float32, + # data augmentation + "mask_prob": 0.8, + # fine tuning + "fc_dim": 48, + "fc_dropout": 0.2, + "fc_activation": "ELU", + "fine_lr": 1e-4, + "fine_weight_decay": 0.05, + "fine_betas": (0.9, 0.999) + } + + mae_model, train_losses_self, val_losses_self = ( + self_supervised_training( + config=model_config, + training_set=train_data, + val_set=val_data, + num_epochs=1, + use_gpu=False, + ) + ) + trans_encoder, fc_net, train_losses, val_losses = fine_tuning( + config=model_config, + trans_encoder=mae_model.mae_encoder, + training_set=train_data, + val_set=val_data, + num_epochs=1, + use_gpu=False, + ) + + # then + assert len(train_losses_self) == len(val_losses_self) == 1 + assert len(train_losses) == len(val_losses) == 1 -- GitLab From 4a8f4a2ad4fdb1745a8c65f94e26bb9a3e5518a0 Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Fri, 8 Nov 2024 18:02:19 +0100 Subject: [PATCH 6/8] mae works --- raman_master/models/mae.py | 80 +++++++++++++++++------------- raman_master/models/nn_training.py | 14 +++--- raman_master/models/transformer.py | 14 ++++-- tests/models/test_mae.py | 14 ++++-- tests/models/test_transformer.py | 25 ++++++---- 5 files changed, 90 insertions(+), 57 deletions(-) diff --git a/raman_master/models/mae.py b/raman_master/models/mae.py index eae83a9..c0ca717 100644 --- a/raman_master/models/mae.py +++ b/raman_master/models/mae.py @@ -1,10 +1,10 @@ import random import torch -from torch.optim.lr_scheduler import CosineAnnealingLR +from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, LinearLR from raman_master.models.loss import MSEIgnoreNans -from raman_master.models.transformer import PatchEncoder +from raman_master.models.transformer import PatchEncoderBSC class MAEEncoder(torch.nn.Module): @@ -26,7 +26,7 @@ class MAEEncoder(torch.nn.Module): self.embedding_dim = embedding_dim dtype = dtype or torch.float32 - self.patch_encoder = PatchEncoder( + self.patch_encoder = PatchEncoderBSC( patch_size=patch_size, embedding_dim=embedding_dim, ) @@ -287,9 +287,16 @@ def self_supervised_training( weight_decay=config["weight_decay"], betas=config["betas"], ) - scheduler = CosineAnnealingLR( + + cosine_scheduler = CosineAnnealingWarmRestarts( + optimizer, + T_mult=config["T_mult"], + T_0=config["T_0"], + ) + warm_start_scheduler = LinearLR( optimizer, - T_max=config["T_max"], + start_factor=0.001, + total_iters=config["warm_up_duration"], ) start_epoch = 1 @@ -314,7 +321,6 @@ def self_supervised_training( epoch_train_losses.append(mse_loss.item()) train_losses.append(sum(epoch_train_losses) / len(epoch_train_losses)) - scheduler.step() # validation epoch_val_losses = [] @@ -331,13 +337,18 @@ def self_supervised_training( val_losses.append(sum(epoch_val_losses) / len(epoch_val_losses)) print( - "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f" + "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f\t lr %4.2e" % ( epoch, train_losses[-1], val_losses[-1], + optimizer.param_groups[0]["lr"], ) ) + if epoch < config["warm_up_duration"]: + warm_start_scheduler.step() + else: + cosine_scheduler.step() return ( mae, @@ -355,7 +366,6 @@ def fine_tuning( use_gpu=True, loss_fn=None, verbose=False, - train_trans_encoder=False, ): random.seed(0) torch.manual_seed(0) @@ -377,28 +387,26 @@ def fine_tuning( fc_net = torch.jit.script( FCNet(**config).to(device) ) - if train_trans_encoder: - trans_encoder.train() - else: - trans_encoder.eval() - - if train_trans_encoder: - params = ( - list(fc_net.parameters()) - + list(trans_encoder.parameters()) - ) - else: - params = fc_net.parameters() + fc_net.train() + trans_encoder.train() optimizer = torch.optim.AdamW( - params, - lr=config["fine_lr"], + [ + {"params": fc_net.parameters(), "lr": config["fc_lr"]}, + {"params": trans_encoder.parameters(), "lr": config["fine_lr"]}, + ], weight_decay=config["fine_weight_decay"], betas=config["fine_betas"], ) - scheduler = CosineAnnealingLR( + cosine_scheduler = CosineAnnealingWarmRestarts( + optimizer, + T_mult=config["fine_T_mult"], + T_0=config["fine_T_0"], + ) + warm_start_scheduler = LinearLR( optimizer, - T_max=config["T_max"], + start_factor=0.001, + total_iters=config["fine_warm_up_duration"], ) start_epoch = 1 @@ -410,8 +418,7 @@ def fine_tuning( epoch_train_losses = [] for one_batch in training_set: - if train_trans_encoder: - trans_encoder.zero_grad(set_to_none=True) + trans_encoder.zero_grad(set_to_none=True) fc_net.zero_grad(set_to_none=True) one_batch = {key: value.to(device) for key, value in one_batch.items()} @@ -440,7 +447,6 @@ def fine_tuning( epoch_train_losses.append(mse_loss.item()) train_losses.append(sum(epoch_train_losses) / len(epoch_train_losses)) - scheduler.step() # validation epoch_val_losses = [] @@ -470,14 +476,20 @@ def fine_tuning( ) val_losses.append(sum(epoch_val_losses) / len(epoch_val_losses)) - print( - "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f" - % ( - epoch, - train_losses[-1], - val_losses[-1], + if verbose: + print( + "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f\tlr: %4.2e" + % ( + epoch, + train_losses[-1], + val_losses[-1], + optimizer.param_groups[0]["lr"], + ) ) - ) + if epoch < config["fine_warm_up_duration"]: + warm_start_scheduler.step() + else: + cosine_scheduler.step() return ( trans_encoder, diff --git a/raman_master/models/nn_training.py b/raman_master/models/nn_training.py index 9cbcd60..2b1aa53 100644 --- a/raman_master/models/nn_training.py +++ b/raman_master/models/nn_training.py @@ -15,8 +15,8 @@ from raman_master.models.transformer import ( ResNetDecoder, RamanTransformerEncoder, PatchDecoder, - PatchEncoder, - TransformerRegressor, + PatchEncoderBSC, + TransformerRegressor, PatchEncoderBCS, ) @@ -312,7 +312,7 @@ def self_supervised_training( spectra_size = training_set.dataset.spectra.shape[-1] if use_patch_encoding: embedding_dim = config["t_d_model"] - encoder = torch.jit.script(PatchEncoder(embedding_dim)) + encoder = torch.jit.script(PatchEncoderBCS(embedding_dim)) spatial_embedding_dim = int(spectra_size / embedding_dim) if spectra_size % embedding_dim != 0: raise ValueError( @@ -339,7 +339,7 @@ def self_supervised_training( ) spatial_embedding_dim = encoder.spatial_dims[-1] - trans_encoder = torch.jit.script( + trans_encoder = ( RamanTransformerEncoder( d_model=config["t_d_model"], nhead=config["t_nhead"], @@ -412,7 +412,7 @@ def self_supervised_training( mask_nothing_prob=config["mask_nothing_prob"], noise_factor=config["noise_factor"], ) - corrected_embedding = trans_encoder(patched_embedding) + corrected_embedding = trans_encoder(patched_embedding.permute(0, 2, 1)) # ignore the class token reconstruction = decoder( corrected_embedding[:, :, config["num_cls_tokens"]:] @@ -455,7 +455,9 @@ def self_supervised_training( mask_nothing_prob=config["mask_nothing_prob"], noise_factor=config["noise_factor"], ) - corrected_embedding = trans_encoder(changed_embedding) + corrected_embedding = trans_encoder( + changed_embedding.permute(0, 2, 1) + ) # ignore the class token reconstruction = decoder( corrected_embedding[:, :, config["num_cls_tokens"]:] diff --git a/raman_master/models/transformer.py b/raman_master/models/transformer.py index 3feada1..c06acab 100644 --- a/raman_master/models/transformer.py +++ b/raman_master/models/transformer.py @@ -67,8 +67,7 @@ class RamanTransformerEncoder(torch.nn.Module): [ # add cls token(s) torch.zeros(len(x), self.num_cls_tokens, self.embedding_dim), - # torch.tile(self.cls_token, dims=(len(x), 1, 1)), - torch.transpose(x, 1, 2), + x, ], dim=1, ) + self.positional_encoding @@ -206,7 +205,7 @@ class TransformerRegressor(torch.nn.Module): def forward(self, x): forecast = self.fc_net( self.trans_encoder( - self.cnn_encoder(x) + self.cnn_encoder(x).permute(0, 2, 1) )[:, :, :self.trans_encoder.num_cls_tokens].reshape(len(x), -1) ) if self.fc_output_channels > 1: @@ -214,7 +213,7 @@ class TransformerRegressor(torch.nn.Module): return forecast -class PatchEncoder(torch.nn.Module): +class PatchEncoderBSC(torch.nn.Module): def __init__( self, patch_size, @@ -247,6 +246,13 @@ class PatchEncoder(torch.nn.Module): return self.embed(self.reshape(x)) +class PatchEncoderBCS(PatchEncoderBSC): + def forward(self, x): + # input is (batch, 1, sequence) + # we want to get (batch, reduced_sequence, channel) + return self.embed(self.reshape(x)).permute(0, 2, 1) + + class PatchDecoder(torch.nn.Module): def __init__( self, diff --git a/tests/models/test_mae.py b/tests/models/test_mae.py index 64f5dac..6ca1f0a 100644 --- a/tests/models/test_mae.py +++ b/tests/models/test_mae.py @@ -93,22 +93,28 @@ def test_self_supervised_transformer_training(data_for_nn): "t_activation": "gelu", "encoder_depth": 1, "decoder_depth": 1, + # optimizer "base_lr": 1e-3, "betas": [0.9, 0.95], - "T_max": 32, - "masking_ratio": 0.8, + "T_mult": 2, + "T_0": 1, + "warm_up_duration": 1, "num_cls_tokens": 2, "weight_decay": 1e-3, "dtype": torch.float32, # data augmentation - "mask_prob": 0.8, + "masking_ratio": 0.8, # fine tuning "fc_dim": 48, "fc_dropout": 0.2, "fc_activation": "ELU", + "fc_lr": 1e-3, "fine_lr": 1e-4, "fine_weight_decay": 0.05, - "fine_betas": (0.9, 0.999) + "fine_betas": (0.9, 0.999), + "fine_T_mult": 2, + "fine_T_0": 1, + "fine_warm_up_duration": 5, } mae_model, train_losses_self, val_losses_self = ( diff --git a/tests/models/test_transformer.py b/tests/models/test_transformer.py index 29c6661..51d4752 100644 --- a/tests/models/test_transformer.py +++ b/tests/models/test_transformer.py @@ -6,8 +6,8 @@ from raman_master.models.transformer import ( RamanTransformerEncoder, ResNetDecoder, PatchDecoder, - PatchEncoder, - TransformerRegressor, + PatchEncoderBSC, + TransformerRegressor, PatchEncoderBCS, ) from raman_master.utils import num_parameter @@ -75,7 +75,9 @@ def test_basic_raman_transformer(): ) # when - embeddings = trans_encoder(cnn_encoder(dummy_spectra)) + embeddings = trans_encoder( + cnn_encoder(dummy_spectra).permute(0, 2, 1) + ) # then assert embeddings.shape == (16, 32, 1 + 125) @@ -117,7 +119,9 @@ def test_encoding_and_decoding_with_raman_transformer(): ) # when - embeddings = trans_encoder(cnn_encoder(dummy_spectra)) + embeddings = trans_encoder( + cnn_encoder(dummy_spectra).permute(0, 2, 1) + ) # remove the class token restoration = cnn_decoder(embeddings[:, :, 1:]) @@ -175,10 +179,10 @@ def test_patch_encoder(): dummy_spectrum = torch.randn(16, 1, 1024) # when - patched_spec = PatchEncoder(patch_size=8)(dummy_spectrum) + patched_spec = PatchEncoderBSC(patch_size=8)(dummy_spectrum) # then - assert patched_spec.shape == (16, 8, 128) + assert patched_spec.shape == (16, 128, 8) def test_patch_encoder_2(): @@ -186,7 +190,10 @@ def test_patch_encoder_2(): dummy_spectrum = torch.tensor([[[1, 2, 3, 4.]], [[11, 12, 13, 14]]]) # when - patched_spec = PatchEncoder(patch_size=2, embedding_dim=10)(dummy_spectrum) + patched_spec = PatchEncoderBCS( + patch_size=2, + embedding_dim=10, + )(dummy_spectrum) # then assert patched_spec.shape == (2, 10, 2) @@ -220,7 +227,7 @@ def test_patch_decoder_2(): def test_transformer_regressor_patch_en_de_coding(): # given dummy_spectra = torch.randn((16, 1, 1024)) - patch_encoder = PatchEncoder(patch_size=32) + patch_encoder = PatchEncoderBSC(patch_size=32) trans_encoder = RamanTransformerEncoder( d_model=32, nhead=8, @@ -253,7 +260,7 @@ def test_transformer_regressor_different_patch_embedding_dim(): dummy_spectra = torch.randn((16, 1, 1024)) embedding_dim = 32 patch_size = 16 - patch_encoder = PatchEncoder( + patch_encoder = PatchEncoderBCS( patch_size=patch_size, embedding_dim=embedding_dim, ) -- GitLab From 5f52227f92651ad4683dca72f31216ba9d7abd1e Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Mon, 11 Nov 2024 18:05:58 +0100 Subject: [PATCH 7/8] hp tuning for mae --- .../neural_networks/train_mae_encoder.ipynb | 612 ++++++++++++++++++ ...ot_spectra_issues_with_low_intensity.ipynb | 568 ++++++++++++++++ raman_master/cli.py | 314 ++++++++- raman_master/models/mae.py | 196 +++++- raman_master/models/nn_training.py | 4 +- raman_master/models/rezero_net.py | 5 +- scripts/run_local_mae_hp_tuning.sh | 28 + 7 files changed, 1699 insertions(+), 28 deletions(-) create mode 100644 notebooks/neural_networks/train_mae_encoder.ipynb create mode 100644 notebooks/visualisations/plot_spectra_issues_with_low_intensity.ipynb create mode 100644 scripts/run_local_mae_hp_tuning.sh diff --git a/notebooks/neural_networks/train_mae_encoder.ipynb b/notebooks/neural_networks/train_mae_encoder.ipynb new file mode 100644 index 0000000..a5ba5ee --- /dev/null +++ b/notebooks/neural_networks/train_mae_encoder.ipynb @@ -0,0 +1,612 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "33b00d49", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import functools\n", + "import math\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import sklearn\n", + "import torch\n", + "\n", + "import raman_master\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "78f6e5d2", + "metadata": {}, + "source": [ + "# Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0048eb17-5d5f-4410-8648-8c8c8416a668", + "metadata": {}, + "outputs": [], + "source": [ + "from raman_master.data.torch_datasets import NormalizedSpectra2D\n", + "from raman_master.models import simple_training, LearnedMeanSigmaLossIgnoreNans\n", + "from raman_master.models.loss import MSEIgnoreNans2d\n", + "from raman_master.utils import (\n", + " process_spectral_data, read_spectra_from_fs, set_annotations_nan\n", + ")\n", + "from raman_master.models.hp_tuning import load_spectra_and_labels_fs\n", + "from raman_master.models.loss import MSEIgnoreNans2d, LearnedMeanSigmaLossIgnoreNans\n", + "\n", + "\n", + "\n", + "lower_wn = 396\n", + "upper_wn = 2000\n", + "\n", + "data_dir = \"/home/christoph/git_projects/raman-data\"\n", + "\n", + "train_dirs = [\"train\"]\n", + "val_dirs = [\"val\"]\n", + "\n", + "# load training data\n", + "train_specs = []\n", + "train_cs = []\n", + "\n", + "wavenumbers = []\n", + "\n", + "for dir in train_dirs:\n", + " spectra, cons, wns, _, _ = load_spectra_and_labels_fs(\n", + " os.path.join(data_dir, dir),\n", + " lower_wn,\n", + " upper_wn,\n", + " )\n", + " train_specs.append(spectra)\n", + " train_cs.append(cons)\n", + " wavenumbers.append(wns)\n", + "\n", + "train_spectra = np.concatenate(train_specs, axis=0)\n", + "train_cons = np.concatenate(train_cs, axis=0)\n", + "\n", + "# load validation data\n", + "val_specs = []\n", + "val_cs = []\n", + "for dir in val_dirs:\n", + " spectra, cons, _, _, _ = load_spectra_and_labels_fs(\n", + " os.path.join(data_dir, dir),\n", + " lower_wn,\n", + " upper_wn,\n", + " )\n", + " val_specs.append(spectra)\n", + " val_cs.append(cons)\n", + "\n", + "val_spectra = np.concatenate(val_specs, axis=0)\n", + "val_cons = np.concatenate(val_cs, axis=0)\n", + "\n", + "config = {\n", + " \"augment_slope_std\": 0.,\n", + " \"baseline_factor_bound\": 0.,\n", + " \"baseline_period_lower_bound\": 0.5,\n", + " \"baseline_period_span\": 10,\n", + " \"original_datapoint_weight\": 0.1,\n", + " \"batch_size\": 128,\n", + "}\n", + "\n", + "train_data = torch.utils.data.DataLoader(\n", + " NormalizedSpectra2D(\n", + " spectra=train_spectra,\n", + " concentrations=train_cons,\n", + " combine_spectra_range=0.5,\n", + " combine_within_group=0.3,\n", + " augment_slope_std=config[\"augment_slope_std\"],\n", + " augment_intersept_std=0.0,\n", + " rolling_bound=0,\n", + " spectrum_rolling_sigma=0.1,\n", + " baseline_factor_bound=config[\"baseline_factor_bound\"],\n", + " baseline_period_lower_bound=config[\"baseline_period_lower_bound\"],\n", + " baseline_period_upper_bound=(\n", + " config[\"baseline_period_lower_bound\"] + config[\"baseline_period_span\"]\n", + " ),\n", + " dtype=torch.float32,\n", + " original_datapoint_weight=config[\"original_datapoint_weight\"],\n", + " augmentation_weight=0.5,\n", + " ),\n", + " batch_size=config[\"batch_size\"],\n", + ")\n", + "val_data = torch.utils.data.DataLoader(\n", + " NormalizedSpectra2D(\n", + " spectra=val_spectra,\n", + " concentrations=val_cons,\n", + " spectra_mean_std=(\n", + " train_data.dataset.s_mean,\n", + " train_data.dataset.s_std,\n", + " ),\n", + " concentration_mean_std=(\n", + " train_data.dataset.concentration_means,\n", + " train_data.dataset.concentration_stds,\n", + " ),\n", + " dtype=torch.float32,\n", + " ),\n", + " batch_size=config[\"batch_size\"],\n", + ")\n", + "\n", + "wavenumbers = wavenumbers[0]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6336fb7f-1469-4f89-93d1-7aba36791b36", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "c442f595-ad5d-4e94-90fc-178b6a1e9a20", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n", + "epoch: 1 \ttrain_loss 3.25\tval_loss 3.67\t lr 1.00e-07\n", + "epoch: 2 \ttrain_loss 2.06\tval_loss 1.47\t lr 1.01e-05\n", + "epoch: 3 \ttrain_loss 1.00\tval_loss 1.15\t lr 2.01e-05\n", + "epoch: 4 \ttrain_loss 0.85\tval_loss 0.92\t lr 3.01e-05\n", + "epoch: 5 \ttrain_loss 0.52\tval_loss 0.50\t lr 4.01e-05\n", + "epoch: 6 \ttrain_loss 0.24\tval_loss 0.34\t lr 5.01e-05\n", + "epoch: 7 \ttrain_loss 0.18\tval_loss 0.26\t lr 6.00e-05\n", + "epoch: 8 \ttrain_loss 0.15\tval_loss 0.24\t lr 7.00e-05\n", + "epoch: 9 \ttrain_loss 0.13\tval_loss 0.26\t lr 8.00e-05\n", + "epoch: 10 \ttrain_loss 0.11\tval_loss 0.23\t lr 9.00e-05\n", + "epoch: 11 \ttrain_loss 0.11\tval_loss 0.19\t lr 9.05e-05\n", + "epoch: 12 \ttrain_loss 0.11\tval_loss 0.25\t lr 6.55e-05\n", + "epoch: 13 \ttrain_loss 0.10\tval_loss 0.18\t lr 3.45e-05\n", + "epoch: 14 \ttrain_loss 0.09\tval_loss 0.18\t lr 9.55e-06\n", + "epoch: 15 \ttrain_loss 0.11\tval_loss 0.20\t lr 1.00e-04\n", + "epoch: 16 \ttrain_loss 0.11\tval_loss 0.21\t lr 9.76e-05\n", + "epoch: 17 \ttrain_loss 0.10\tval_loss 0.17\t lr 9.05e-05\n", + "epoch: 18 \ttrain_loss 0.09\tval_loss 0.19\t lr 7.94e-05\n", + "epoch: 19 \ttrain_loss 0.09\tval_loss 0.22\t lr 6.55e-05\n", + "epoch: 20 \ttrain_loss 0.09\tval_loss 0.17\t lr 5.00e-05\n", + "epoch: 21 \ttrain_loss 0.07\tval_loss 0.17\t lr 3.45e-05\n", + "epoch: 22 \ttrain_loss 0.07\tval_loss 0.17\t lr 2.06e-05\n", + "epoch: 23 \ttrain_loss 0.08\tval_loss 0.15\t lr 9.55e-06\n", + "epoch: 24 \ttrain_loss 0.07\tval_loss 0.15\t lr 2.45e-06\n", + "epoch: 25 \ttrain_loss 0.09\tval_loss 0.19\t lr 1.00e-04\n", + "epoch: 26 \ttrain_loss 0.08\tval_loss 0.15\t lr 9.94e-05\n", + "epoch: 27 \ttrain_loss 0.08\tval_loss 0.14\t lr 9.76e-05\n", + "epoch: 28 \ttrain_loss 0.08\tval_loss 0.15\t lr 9.46e-05\n", + "epoch: 29 \ttrain_loss 0.07\tval_loss 0.14\t lr 9.05e-05\n", + "epoch: 30 \ttrain_loss 0.07\tval_loss 0.16\t lr 8.54e-05\n", + "epoch: 31 \ttrain_loss 0.08\tval_loss 0.19\t lr 7.94e-05\n", + "epoch: 32 \ttrain_loss 0.07\tval_loss 0.16\t lr 7.27e-05\n", + "epoch: 33 \ttrain_loss 0.06\tval_loss 0.14\t lr 6.55e-05\n", + "epoch: 34 \ttrain_loss 0.06\tval_loss 0.14\t lr 5.78e-05\n", + "epoch: 35 \ttrain_loss 0.06\tval_loss 0.13\t lr 5.00e-05\n", + "epoch: 36 \ttrain_loss 0.06\tval_loss 0.13\t lr 4.22e-05\n", + "epoch: 37 \ttrain_loss 0.06\tval_loss 0.13\t lr 3.45e-05\n", + "epoch: 38 \ttrain_loss 0.06\tval_loss 0.12\t lr 2.73e-05\n", + "epoch: 39 \ttrain_loss 0.05\tval_loss 0.12\t lr 2.06e-05\n", + "epoch: 40 \ttrain_loss 0.05\tval_loss 0.11\t lr 1.46e-05\n", + "epoch: 41 \ttrain_loss 0.05\tval_loss 0.13\t lr 9.55e-06\n", + "epoch: 42 \ttrain_loss 0.05\tval_loss 0.12\t lr 5.45e-06\n", + "epoch: 43 \ttrain_loss 0.05\tval_loss 0.12\t lr 2.45e-06\n", + "epoch: 44 \ttrain_loss 0.06\tval_loss 0.13\t lr 6.16e-07\n", + "epoch: 45 \ttrain_loss 0.06\tval_loss 0.12\t lr 1.00e-04\n", + "epoch: 46 \ttrain_loss 0.06\tval_loss 0.14\t lr 9.98e-05\n", + "epoch: 47 \ttrain_loss 0.06\tval_loss 0.22\t lr 9.94e-05\n", + "epoch: 48 \ttrain_loss 0.07\tval_loss 0.15\t lr 9.86e-05\n", + "epoch: 49 \ttrain_loss 0.06\tval_loss 0.15\t lr 9.76e-05\n", + "epoch: 50 \ttrain_loss 0.06\tval_loss 0.10\t lr 9.62e-05\n", + "epoch: 51 \ttrain_loss 0.06\tval_loss 0.16\t lr 9.46e-05\n", + "epoch: 52 \ttrain_loss 0.06\tval_loss 0.11\t lr 9.26e-05\n", + "epoch: 53 \ttrain_loss 0.05\tval_loss 0.10\t lr 9.05e-05\n", + "epoch: 54 \ttrain_loss 0.06\tval_loss 0.13\t lr 8.80e-05\n", + "epoch: 55 \ttrain_loss 0.06\tval_loss 0.11\t lr 8.54e-05\n", + "epoch: 56 \ttrain_loss 0.05\tval_loss 0.11\t lr 8.25e-05\n", + "epoch: 57 \ttrain_loss 0.05\tval_loss 0.10\t lr 7.94e-05\n", + "epoch: 58 \ttrain_loss 0.05\tval_loss 0.10\t lr 7.61e-05\n", + "epoch: 59 \ttrain_loss 0.05\tval_loss 0.13\t lr 7.27e-05\n", + "epoch: 60 \ttrain_loss 0.05\tval_loss 0.11\t lr 6.91e-05\n", + "epoch: 61 \ttrain_loss 0.05\tval_loss 0.11\t lr 6.55e-05\n", + "epoch: 62 \ttrain_loss 0.04\tval_loss 0.08\t lr 6.17e-05\n", + "epoch: 63 \ttrain_loss 0.04\tval_loss 0.08\t lr 5.78e-05\n", + "epoch: 64 \ttrain_loss 0.04\tval_loss 0.08\t lr 5.39e-05\n", + "epoch: 65 \ttrain_loss 0.04\tval_loss 0.07\t lr 5.00e-05\n", + "epoch: 66 \ttrain_loss 0.04\tval_loss 0.09\t lr 4.61e-05\n", + "epoch: 67 \ttrain_loss 0.04\tval_loss 0.07\t lr 4.22e-05\n", + "epoch: 68 \ttrain_loss 0.04\tval_loss 0.09\t lr 3.83e-05\n", + "epoch: 69 \ttrain_loss 0.04\tval_loss 0.07\t lr 3.45e-05\n", + "epoch: 70 \ttrain_loss 0.04\tval_loss 0.09\t lr 3.09e-05\n", + "epoch: 71 \ttrain_loss 0.04\tval_loss 0.08\t lr 2.73e-05\n", + "epoch: 72 \ttrain_loss 0.04\tval_loss 0.06\t lr 2.39e-05\n", + "epoch: 73 \ttrain_loss 0.04\tval_loss 0.07\t lr 2.06e-05\n", + "epoch: 74 \ttrain_loss 0.04\tval_loss 0.09\t lr 1.75e-05\n", + "epoch: 75 \ttrain_loss 0.04\tval_loss 0.07\t lr 1.46e-05\n", + "epoch: 76 \ttrain_loss 0.04\tval_loss 0.08\t lr 1.20e-05\n", + "epoch: 77 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.55e-06\n", + "epoch: 78 \ttrain_loss 0.03\tval_loss 0.06\t lr 7.37e-06\n", + "epoch: 79 \ttrain_loss 0.03\tval_loss 0.08\t lr 5.45e-06\n", + "epoch: 80 \ttrain_loss 0.04\tval_loss 0.07\t lr 3.81e-06\n", + "epoch: 81 \ttrain_loss 0.04\tval_loss 0.07\t lr 2.45e-06\n", + "epoch: 82 \ttrain_loss 0.03\tval_loss 0.08\t lr 1.38e-06\n", + "epoch: 83 \ttrain_loss 0.04\tval_loss 0.08\t lr 6.16e-07\n", + "epoch: 84 \ttrain_loss 0.03\tval_loss 0.08\t lr 1.54e-07\n", + "epoch: 85 \ttrain_loss 0.06\tval_loss 0.09\t lr 1.00e-04\n", + "epoch: 86 \ttrain_loss 0.04\tval_loss 0.11\t lr 1.00e-04\n", + "epoch: 87 \ttrain_loss 0.04\tval_loss 0.07\t lr 9.98e-05\n", + "epoch: 88 \ttrain_loss 0.04\tval_loss 0.10\t lr 9.97e-05\n", + "epoch: 89 \ttrain_loss 0.04\tval_loss 0.08\t lr 9.94e-05\n", + "epoch: 90 \ttrain_loss 0.04\tval_loss 0.08\t lr 9.90e-05\n", + "epoch: 91 \ttrain_loss 0.05\tval_loss 0.10\t lr 9.86e-05\n", + "epoch: 92 \ttrain_loss 0.04\tval_loss 0.07\t lr 9.81e-05\n", + "epoch: 93 \ttrain_loss 0.04\tval_loss 0.08\t lr 9.76e-05\n", + "epoch: 94 \ttrain_loss 0.04\tval_loss 0.06\t lr 9.69e-05\n", + "epoch: 95 \ttrain_loss 0.04\tval_loss 0.10\t lr 9.62e-05\n", + "epoch: 96 \ttrain_loss 0.04\tval_loss 0.06\t lr 9.54e-05\n", + "epoch: 97 \ttrain_loss 0.04\tval_loss 0.09\t lr 9.46e-05\n", + "epoch: 98 \ttrain_loss 0.04\tval_loss 0.08\t lr 9.36e-05\n", + "epoch: 99 \ttrain_loss 0.04\tval_loss 0.06\t lr 9.26e-05\n", + "epoch: 100 \ttrain_loss 0.04\tval_loss 0.08\t lr 9.16e-05\n", + "epoch: 101 \ttrain_loss 0.04\tval_loss 0.09\t lr 9.05e-05\n", + "epoch: 102 \ttrain_loss 0.04\tval_loss 0.06\t lr 8.93e-05\n", + "epoch: 103 \ttrain_loss 0.04\tval_loss 0.06\t lr 8.80e-05\n", + "epoch: 104 \ttrain_loss 0.04\tval_loss 0.08\t lr 8.67e-05\n", + "epoch: 105 \ttrain_loss 0.04\tval_loss 0.07\t lr 8.54e-05\n", + "epoch: 106 \ttrain_loss 0.04\tval_loss 0.07\t lr 8.39e-05\n", + "epoch: 107 \ttrain_loss 0.04\tval_loss 0.06\t lr 8.25e-05\n", + "epoch: 108 \ttrain_loss 0.04\tval_loss 0.07\t lr 8.10e-05\n", + "epoch: 109 \ttrain_loss 0.04\tval_loss 0.05\t lr 7.94e-05\n", + "epoch: 110 \ttrain_loss 0.04\tval_loss 0.07\t lr 7.78e-05\n", + "epoch: 111 \ttrain_loss 0.04\tval_loss 0.08\t lr 7.61e-05\n", + "epoch: 112 \ttrain_loss 0.03\tval_loss 0.06\t lr 7.44e-05\n", + "epoch: 113 \ttrain_loss 0.04\tval_loss 0.06\t lr 7.27e-05\n", + "epoch: 114 \ttrain_loss 0.03\tval_loss 0.05\t lr 7.09e-05\n", + "epoch: 115 \ttrain_loss 0.03\tval_loss 0.07\t lr 6.91e-05\n", + "epoch: 116 \ttrain_loss 0.03\tval_loss 0.06\t lr 6.73e-05\n", + "epoch: 117 \ttrain_loss 0.04\tval_loss 0.08\t lr 6.55e-05\n", + "epoch: 118 \ttrain_loss 0.03\tval_loss 0.06\t lr 6.36e-05\n", + "epoch: 119 \ttrain_loss 0.03\tval_loss 0.08\t lr 6.17e-05\n", + "epoch: 120 \ttrain_loss 0.03\tval_loss 0.07\t lr 5.98e-05\n", + "epoch: 121 \ttrain_loss 0.03\tval_loss 0.07\t lr 5.78e-05\n", + "epoch: 122 \ttrain_loss 0.03\tval_loss 0.06\t lr 5.59e-05\n", + "epoch: 123 \ttrain_loss 0.03\tval_loss 0.06\t lr 5.39e-05\n", + "epoch: 124 \ttrain_loss 0.03\tval_loss 0.06\t lr 5.20e-05\n", + "epoch: 125 \ttrain_loss 0.03\tval_loss 0.07\t lr 5.00e-05\n", + "epoch: 126 \ttrain_loss 0.03\tval_loss 0.07\t lr 4.80e-05\n", + "epoch: 127 \ttrain_loss 0.03\tval_loss 0.07\t lr 4.61e-05\n", + "epoch: 128 \ttrain_loss 0.03\tval_loss 0.06\t lr 4.41e-05\n", + "epoch: 129 \ttrain_loss 0.03\tval_loss 0.06\t lr 4.22e-05\n", + "epoch: 130 \ttrain_loss 0.03\tval_loss 0.07\t lr 4.02e-05\n", + "epoch: 131 \ttrain_loss 0.03\tval_loss 0.06\t lr 3.83e-05\n", + "epoch: 132 \ttrain_loss 0.03\tval_loss 0.06\t lr 3.64e-05\n", + "epoch: 133 \ttrain_loss 0.03\tval_loss 0.05\t lr 3.45e-05\n", + "epoch: 134 \ttrain_loss 0.03\tval_loss 0.06\t lr 3.27e-05\n", + "epoch: 135 \ttrain_loss 0.03\tval_loss 0.06\t lr 3.09e-05\n", + "epoch: 136 \ttrain_loss 0.03\tval_loss 0.05\t lr 2.91e-05\n", + "epoch: 137 \ttrain_loss 0.03\tval_loss 0.06\t lr 2.73e-05\n", + "epoch: 138 \ttrain_loss 0.03\tval_loss 0.05\t lr 2.56e-05\n", + "epoch: 139 \ttrain_loss 0.03\tval_loss 0.06\t lr 2.39e-05\n", + "epoch: 140 \ttrain_loss 0.03\tval_loss 0.06\t lr 2.22e-05\n", + "epoch: 141 \ttrain_loss 0.03\tval_loss 0.06\t lr 2.06e-05\n", + "epoch: 142 \ttrain_loss 0.03\tval_loss 0.05\t lr 1.90e-05\n", + "epoch: 143 \ttrain_loss 0.03\tval_loss 0.06\t lr 1.75e-05\n", + "epoch: 144 \ttrain_loss 0.03\tval_loss 0.06\t lr 1.61e-05\n", + "epoch: 145 \ttrain_loss 0.03\tval_loss 0.06\t lr 1.46e-05\n", + "epoch: 146 \ttrain_loss 0.03\tval_loss 0.05\t lr 1.33e-05\n", + "epoch: 147 \ttrain_loss 0.03\tval_loss 0.05\t lr 1.20e-05\n", + "epoch: 148 \ttrain_loss 0.03\tval_loss 0.06\t lr 1.07e-05\n", + "epoch: 149 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.55e-06\n", + "epoch: 150 \ttrain_loss 0.03\tval_loss 0.05\t lr 8.43e-06\n", + "epoch: 151 \ttrain_loss 0.03\tval_loss 0.05\t lr 7.37e-06\n", + "epoch: 152 \ttrain_loss 0.02\tval_loss 0.05\t lr 6.38e-06\n", + "epoch: 153 \ttrain_loss 0.03\tval_loss 0.06\t lr 5.45e-06\n", + "epoch: 154 \ttrain_loss 0.03\tval_loss 0.06\t lr 4.59e-06\n", + "epoch: 155 \ttrain_loss 0.03\tval_loss 0.05\t lr 3.81e-06\n", + "epoch: 156 \ttrain_loss 0.03\tval_loss 0.05\t lr 3.09e-06\n", + "epoch: 157 \ttrain_loss 0.03\tval_loss 0.05\t lr 2.45e-06\n", + "epoch: 158 \ttrain_loss 0.03\tval_loss 0.06\t lr 1.88e-06\n", + "epoch: 159 \ttrain_loss 0.02\tval_loss 0.05\t lr 1.38e-06\n", + "epoch: 160 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.61e-07\n", + "epoch: 161 \ttrain_loss 0.03\tval_loss 0.05\t lr 6.16e-07\n", + "epoch: 162 \ttrain_loss 0.03\tval_loss 0.06\t lr 3.47e-07\n", + "epoch: 163 \ttrain_loss 0.03\tval_loss 0.06\t lr 1.54e-07\n", + "epoch: 164 \ttrain_loss 0.03\tval_loss 0.06\t lr 3.85e-08\n", + "epoch: 165 \ttrain_loss 0.03\tval_loss 0.06\t lr 1.00e-04\n", + "epoch: 166 \ttrain_loss 0.03\tval_loss 0.05\t lr 1.00e-04\n", + "epoch: 167 \ttrain_loss 0.03\tval_loss 0.09\t lr 1.00e-04\n", + "epoch: 168 \ttrain_loss 0.04\tval_loss 0.06\t lr 9.99e-05\n", + "epoch: 169 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.98e-05\n", + "epoch: 170 \ttrain_loss 0.04\tval_loss 0.07\t lr 9.98e-05\n", + "epoch: 171 \ttrain_loss 0.03\tval_loss 0.09\t lr 9.97e-05\n", + "epoch: 172 \ttrain_loss 0.04\tval_loss 0.05\t lr 9.95e-05\n", + "epoch: 173 \ttrain_loss 0.04\tval_loss 0.06\t lr 9.94e-05\n", + "epoch: 174 \ttrain_loss 0.04\tval_loss 0.08\t lr 9.92e-05\n", + "epoch: 175 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.90e-05\n", + "epoch: 176 \ttrain_loss 0.04\tval_loss 0.07\t lr 9.88e-05\n", + "epoch: 177 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.86e-05\n", + "epoch: 178 \ttrain_loss 0.03\tval_loss 0.08\t lr 9.84e-05\n", + "epoch: 179 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.81e-05\n", + "epoch: 180 \ttrain_loss 0.04\tval_loss 0.06\t lr 9.78e-05\n", + "epoch: 181 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.76e-05\n", + "epoch: 182 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.72e-05\n", + "epoch: 183 \ttrain_loss 0.03\tval_loss 0.05\t lr 9.69e-05\n", + "epoch: 184 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.66e-05\n", + "epoch: 185 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.62e-05\n", + "epoch: 186 \ttrain_loss 0.03\tval_loss 0.09\t lr 9.58e-05\n", + "epoch: 187 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.54e-05\n", + "epoch: 188 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.50e-05\n", + "epoch: 189 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.46e-05\n", + "epoch: 190 \ttrain_loss 0.03\tval_loss 0.05\t lr 9.41e-05\n", + "epoch: 191 \ttrain_loss 0.03\tval_loss 0.09\t lr 9.36e-05\n", + "epoch: 192 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.31e-05\n", + "epoch: 193 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.26e-05\n", + "epoch: 194 \ttrain_loss 0.03\tval_loss 0.07\t lr 9.21e-05\n", + "epoch: 195 \ttrain_loss 0.03\tval_loss 0.06\t lr 9.16e-05\n", + "epoch: 196 \ttrain_loss 0.03\tval_loss 0.05\t lr 9.10e-05\n", + "epoch: 197 \ttrain_loss 0.03\tval_loss 0.05\t lr 9.05e-05\n", + "epoch: 198 \ttrain_loss 0.03\tval_loss 0.06\t lr 8.99e-05\n", + "epoch: 199 \ttrain_loss 0.03\tval_loss 0.06\t lr 8.93e-05\n", + "epoch: 200 \ttrain_loss 0.03\tval_loss 0.06\t lr 8.87e-05\n" + ] + } + ], + "source": [ + "from raman_master.models.mae import self_supervised_training, fine_tuning\n", + "\n", + "\n", + "model_config = {\n", + " \"spectra_size\": train_spectra.shape[2],\n", + " \"patch_size\": 8,\n", + " \"embedding_dim\": 256,\n", + " \"n_head\": 16,\n", + " \"dim_feedforward\": 1024,\n", + " \"t_dropout\": 0.05,\n", + " \"t_activation\": \"gelu\",\n", + " \"encoder_depth\": 8,\n", + " \"decoder_depth\": 2,\n", + " \"num_cls_tokens\": 1,\n", + " \"weight_decay\": 0.01,\n", + " \"dtype\": torch.float32,\n", + " \"add_positional_in_decoder\": False,\n", + " # optimizer\n", + " \"base_lr\": 1e-4,\n", + " \"betas\": [0.9, 0.95],\n", + " # cosine scheduler\n", + " \"T_mult\": 2,\n", + " \"T_0\": 5,\n", + " \"warm_up_duration\": 10,\n", + " # data augmentation\n", + " \"masking_ratio\": 0.6,\n", + " # fine tuning\n", + " \"fc_dim\": 512,\n", + " \"fc_dropout\": 0.1,\n", + " \"fc_activation\": \"ELU\",\n", + " \"fc_lr\": 1e-3,\n", + " \"fine_warm_up_duration\": 10,\n", + " \"fine_lr\": 1e-5,\n", + " \"fine_weight_decay\": 0.01,\n", + " \"fine_betas\": (0.9, 0.999),\n", + " \"fine_T_mult\": 2,\n", + " \"fine_T_0\": 1,\n", + " \"verbose\": True,\n", + "}\n", + "\n", + "\n", + "mae_model, train_losses_self, val_losses_self = (\n", + " self_supervised_training(\n", + " config=model_config,\n", + " training_set=train_data,\n", + " val_set=val_data,\n", + " num_epochs=200,\n", + " use_gpu=True,\n", + " )\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "4837cfa6-bf3f-4c46-9004-31354b80150a", + "metadata": {}, + "outputs": [], + "source": [ + "device = (\n", + " torch.device(\"cuda\")\n", + " if torch.cuda.is_available()\n", + " else torch.device(\"cpu\")\n", + ")\n", + "\n", + "mae_model = mae_model.to(device)\n", + "mae_model.eval()\n", + "\n", + "predictions = []\n", + "true_spectra = []\n", + "masks = []\n", + "\n", + "for batch in val_data:\n", + " # just take the means of the predictions\n", + " output, masked_mask = mae_model(batch[\"spectra\"].to(device))\n", + "\n", + " preds = output.detach().cpu()[:, 0, :]\n", + " masks.append(masked_mask.detach().cpu()[:, 0, :])\n", + "\n", + " predictions.append(preds * val_data.dataset.s_std + val_data.dataset.s_mean)\n", + " true_spectra.append(\n", + " (batch[\"filtered_spectra\"][:, 0, :].detach().cpu() * val_data.dataset.s_std + val_data.dataset.s_mean).numpy()\n", + " )\n", + "\n", + "predictions = np.concatenate(\n", + " predictions,\n", + " axis=0,\n", + ")\n", + "masks = np.concatenate(masks, axis=0)\n", + "\n", + "true_spectra = np.concatenate(true_spectra, axis=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "fd333b44-a11c-49a3-88fd-0f161001f767", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((1731, 832), (1731, 832), (832,))" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "masks.shape, predictions.shape, wavenumbers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "1fd8f679-e16a-4ade-b563-57242d0598c5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwMAABU5CAYAAABfzUQcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xUVfrH8c+dnt6AhEDovSMo3YpiX+wURYRVd1csq+uq+1PXVVdce11dVwVUsK6yiCuKWJDepHcInRAgpGf6/f0xyUAkQEISEpLv+/Wal5l7zz1zJiTxPnPOcx7DNE0TERERERGpdyw1PQAREREREakZCgZEREREROopBQMiIiIiIvWUggERERERkXpKwYCIiIiISD2lYEBEREREpJ5SMCAiIiIiUk/ZanoANSkYDLJnzx5iYmIwDKOmhyMiIiIiUmmmaZKXl0dqaioWy/E/+6/XwcCePXtIS0ur6WGIiIiIiFS5nTt30rRp0+O2qdfBQExMDBD6RsXGxtbwaEREREREKi83N5e0tLTwve7x1OtgoGRpUGxsrIIBEREREalTyrMMXgnEIiIiIiL1lIIBEREREZF6SsGAiIiIiEg9Va9zBkRERKT+CgaDeL3emh6GSIXZ7XasVmuV9KVgQEREROodr9dLeno6wWCwpociclLi4+NJSUmpdK0sBQMiIiJSr5imyd69e7FaraSlpZ2wKJNIbWKaJoWFhWRmZgLQuHHjSvWnYEBERETqFb/fT2FhIampqURGRtb0cEQqLCIiAoDMzEwaNWpUqSVDCoVFRESkXgkEAgA4HI4aHonIySsJZH0+X6X6UTAgIiIi9VJl11qL1KSq+vlVMCAiIiIiUk8pGBARERGRUlq0aMFLL70Ufm4YBlOnTq1Un1XRh1Q9JRCLiIiIyHHt3buXhISEcrV97LHHmDp1KsuXLz/pPuTUUTAgIiIiUgd5vd4qS5JOSUmpFX1I1dMyIREREZHTwLnnnsu4ceMYN24ccXFxNGjQgEceeQTTNIHQ0p4nnniCUaNGERsby2233QbAnDlzGDRoEBEREaSlpXHXXXdRUFAQ7jczM5MrrriCiIgIWrZsyeTJk4967V8v8dm1axfDhw8nMTGRqKgoevfuzcKFC5k4cSJ/+9vfWLFiBYZhYBgGEydOLLOPVatWcf755xMREUFSUhK33XYb+fn54fOjR49m6NChPPfcczRu3JikpCTuuOOOSu+eI6UpGBAREZF6zzSDNfKoqEmTJmGz2Vi0aBEvv/wyL7zwAm+//Xb4/HPPPUf37t355ZdfeOSRR9iyZQsXX3wx11xzDStXruTjjz9mzpw5jBs3LnzN6NGj2blzJz/88AOfffYZ//znP8MFrcqSn5/POeecw+7du5k2bRorVqzgz3/+M8FgkBtuuIH77ruPzp07s3fvXvbu3csNN9xwVB8FBQUMGTKEhIQEFi9ezKeffsp3331XalwAP/zwA1u2bOGHH35g0qRJTJw4MRxcSNXQMiERERGp10wzyN69v9TIazdu3BPDKP9ns2lpabz44osYhkH79u1ZtWoVL774IrfeeisA559/Pvfdd1+4/W9/+1tGjhzJPffcA0Dbtm155ZVXOOecc3jjjTfYsWMHX3/9NYsWLeLMM88E4J133qFjx47HHMOUKVPYv38/ixcvJjExEYA2bdqEz0dHR2Oz2Y67LGjKlCm43W7ee+89oqKiAHjttde44oor+Mc//kFycjIACQkJvPbaa1itVjp06MBll13GrFmzwu9XKk8zA7WZvxCCvtBDRERE6r2+ffuW2l++X79+bNq0KVxIrXfv3qXar1ixgokTJxIdHR1+DBkyhGAwSHp6OuvWrcNms9GrV6/wNR06dCA+Pv6YY1i+fDk9e/YMBwInY926dXTv3j0cCAAMGDCAYDDIhg0bwsc6d+5cqrpu48aNjztrIRWnmYFayOstIHdqZ8yC7QQAuwHxbUdhHTCppocmIiJS5xiGhcaNe9bYa1elI2+uIbSk5/bbb+euu+46qm2zZs3YuHFjhV8jIiLipMdXUXa7vdRzwzAIBiu+vEqOTcFALRMMBjh0YA2B/O3hYx4TDm16jyTDwOg/seYGJyIiUkdV9U15dVm4cGGp5wsWLKBt27alPj0/0hlnnMHatWtLLeM5UocOHfD7/SxdujS8TGjDhg1kZ2cfcwzdunXj7bffJisrq8zZAYfDEZ6pOJaOHTsyceJECgoKwgHM3LlzsVgstG/f/rjXStU6PX7y6wnTDJKVtZkAVohMI9YGCXawGOANQuHmSVoyJCIiUo/t2LGDe++9lw0bNvDhhx/y6quvcvfddx+z/QMPPMC8efMYN24cy5cvZ9OmTfz3v/8NJ+q2b9+eiy++mNtvv52FCxeydOlSfvvb3x730//hw4eTkpLC0KFDmTt3Llu3buU///kP8+fPB0K7GqWnp7N8+XIOHDiAx+M5qo+RI0ficrm4+eabWb16NT/88AN33nknN910UzhfQE4NBQO1RFFRFgcOrMfrzcdisdLwmvVEjyggYqSXmFbDAMgLgG/emBoeqYiIiNSUUaNGUVRUxFlnncUdd9zB3XffHd5CtCzdunXjp59+YuPGjQwaNIiePXvy6KOPkpqaGm4zYcIEUlNTOeecc7j66qu57bbbaNSo0TH7dDgcfPvttzRq1IhLL72Url278vTTT4dnJ6655houvvhizjvvPBo2bMiHH354VB+RkZF88803ZGVlceaZZ3LttddywQUX8Nprr1XiuyMnwzBLNqeth3Jzc4mLiyMnJ4fY2NgaG0dh4UGys7eFnycktCIi4nCFPjPg5eD7TrxBsBqQ3GE09Jtw6gcqIiJSB7jdbtLT02nZsiUul6umh1Nu5557Lj169OCll16q6aFILXC8n+OK3ONqZqCGBQI+cnN3hp+7XPGlAgEAw+ogsd0oLAYETPBtmajlQiIiIiJSaUogrmH5+XsJBgM4HFEkJbUvtV3YkSz9J+Eoyse9/XM8Ta/HbrGX2U5EREREpLwUDNSgQMBLYeEBAGJimhwzECjh7Psmbr+XovRPiHS4sPQtrjiowEBERKTO+/HHH2t6CFIHaZlQDSooyMQ0TZzOGJzOmBO2dzmisOyZjs+EfevfY/8kB1nvOSj8afgpGK2IiIiI1DUKBmqIaZoUFh4EICqqfFtoWe2RJLW9EYsBJuAzwR2E7C0f4Z49ohpHKyIiIiJ1kYKBGuL15hEM+rFYbDid5d/JyD7wfRq2vZGY4hoE9uJ/QXf6h0oqFhEREZEKUTBQQ9zubCC0e9CJcgV+zTrwfWLajibCCrFxrQDwNL5SuQMiIiIiUiEKBmqIx5MHcNQ2ouXWbwIM8+IYugmjyRUEdk3D+/ONVThCEREREanrtJtQDWnYsBNebx4Ox4kTh4/JYscI+ojI+JJCIHfLZBrY7CpIJiIiIiLlopmBGmIYBk5nbLmWCB23SLTFTkybmzAAbxC8KkgmIiIiVeSxxx6jR48eVdrnxIkTiY+Pr9I+K+PHH3/EMAyys7OBqhlfbXuPx6NgoJa79+PlnPn3WazZk3PMNtYB7xHR4loA8v3Aot+dotGJiIiI1C033HADGzduLHf7Fi1a8NJLL1Wqj5qkYKAWm7VuH5//spsD+R5+O2kJhV7/MdtGD3wXCG01GtzyrmYHREREpN4wTRO//9j3SRURERFBo0aNaryPU0XBQC32xo9bwl/vzXHz9aqMY7a1OWKwpg0FwNf8Ru0sJCIiUsece+653Hnnndxzzz0kJCSQnJzMv//9bwoKCrjllluIiYmhTZs2fP311+FrAoEAY8eOpWXLlkRERNC+fXtefvnlUv3++OOPnHXWWURFRREfH8+AAQPYvn17mWPYsmULrVq1Yty4cZimicfj4U9/+hNNmjQhKiqKPn36HFUpeeLEiTRr1ozIyEiuuuoqDh48eNz3uW3bNgzD4KOPPqJ///64XC66dOnCTz/9VGrMhmHw9ddf06tXL5xOJ3PmzCEYDDJ+/Pjw++3evTufffZZqf7/97//0a5dOyIiIjjvvPPYtm3bUeP99RKfL7/8kjPPPBOXy0WDBg246qqrwv8m27dv549//COGYYSXf5fVxxtvvEHr1q1xOBy0b9+e999/v9R5wzB4++23ueqqq4iMjKRt27ZMmzbtuN+rqqBgoJY6VOBl2Y5DAIzo0wyAz5buOu41jt7Pw5AFeLs/U+3jExERkVNv0qRJNGjQgEWLFnHnnXfy+9//nuuuu47+/fuzbNkyLrroIm666SYKCwsBCAaDNG3alE8//ZS1a9fy6KOP8pe//IVPPvkEAL/fz9ChQznnnHNYuXIl8+fP57bbbiszp3HlypUMHDiQESNG8Nprr2EYBuPGjWP+/Pl89NFHrFy5kuuuu46LL76YTZs2AbBw4ULGjh3LuHHjWL58Oeeddx5PPvlkud7r/fffz3333ccvv/xCv379uOKKK44KJB588EGefvpp1q1bR7du3Rg/fjzvvfceb775JmvWrOGPf/wjN954YziQ2LlzJ1dffTVXXHEFy5cv57e//S0PPvjgccfx1VdfcdVVV3HppZfyyy+/MGvWLM466ywAPv/8c5o2bcrjjz/O3r172bt3b5l9fPHFF9x9993cd999rF69mttvv51bbrmFH374oVS7v/3tb1x//fWsXLmSSy+9lJEjR5KVlVWu79dJM+uxnJwcEzBzcnJqeihH+WLZLrP5A9PNIS/+ZO46VGi2eHC62fyB6ebOrIJjXpOfv8/cvXuJefDgplM4UhERkdNLUVGRuXbtWrOoqKhqOgx4q6afEzjnnHPMgQMHhp/7/X4zKirKvOmmm8LH9u7dawLm/Pnzj9nPHXfcYV5zzTWmaZrmwYMHTcD88ccfy2z717/+1ezevbs5d+5cMyEhwXzuuefC57Zv325arVZz9+7dpa654IILzIceesg0TdMcPny4eemll5Y6f8MNN5hxcXHHHF96eroJmE8//XT4mM/nM5s2bWr+4x//ME3TNH/44QcTMKdOnRpu43a7zcjISHPevHml+hs7dqw5fPhw0zRN86GHHjI7depU6vwDDzxgAuahQ4dM0zTNCRMmlBpfv379zJEjRx5zvM2bNzdffPHFUsd+3Uf//v3NW2+9tVSb6667rtT3BjAffvjh8PP8/HwTML/++usyX/d4P8cVucfVzEAtNXPtPgDO69CIJvER9G+dBMDny3Yf8xq7PQoAr7eg+gcoIiIisGAsfOQI/fcU6NatW/hrq9VKUlISXbt2DR9LTk4GIDMzM3zs9ddfp1evXjRs2JDo6GjeeustduzYAUBiYiKjR49myJAhXHHFFbz88stHfbq9Y8cOLrzwQh599FHuu+++8PFVq1YRCARo164d0dHR4cdPP/3Eli2hpc7r1q2jT58+pfrr169fud7rke1sNhu9e/dm3bp1pdr07t07/PXmzZspLCzkwgsvLDWe9957r1LjWb58ORdccEG5xnws69atY8CAAaWODRgw4Kj3c+S/b1RUFLGxsaX+LauD6gzUQvkeP9+tCwUDl3ZpDMC1vZoyd/NBvvhlN3dd0LbM6+z2CAzDIBj04/d7sNmcp2zMIiIi9U7QB1tDG3iw9V04681qz9mz20v3bxhGqWMly3uCwSAAH330EX/60594/vnn6devHzExMTz77LMsXLgwfM2ECRO46667mDFjBh9//DEPP/wwM2fOpG/fvgA0bNiQ1NRUPvzwQ8aMGUNsbCwA+fn5WK1Wli5ditVqLTWu6Ojoqn/zZYiKigp/nZ+fD4SW9TRp0qRUO6fz5O+JIiIiTvraiirr37fk37K6aGagFpq5NgOPP0irBlF0aRL6hbugYyjSTz9QQK677J2CDMOC3R4JgM+n2QEREZFqZbFDqzGhr1uNqZWbd8ydO5f+/fvzhz/8gZ49e9KmTZvwp+RH6tmzJw899BDz5s2jS5cuTJkyJXwuIiKC6dOn43K5GDJkCHl5eeFrAoEAmZmZtGnTptQjJSUFgI4dO5YKPAAWLFhQrrEf2c7v97N06VI6dux4zPadOnXC6XSyY8eOo8aTlpYWHs+iRYsqNJ5u3boxa9asY553OBwEAoHj9tGxY0fmzp1b6tjcuXPp1KnTca87FRQM1EILtoQSRYZ0SQlH+LEuOymxLgA2Z+aXar9w60HeX7Ad0zS1VEhERORU6vsODPOG/lsLtW3bliVLlvDNN9+wceNGHnnkERYvXhw+n56ezkMPPcT8+fPZvn073377LZs2bTrqpjsqKoqvvvoKm83GJZdcQn5+Pu3atWPkyJGMGjWKzz//nPT0dBYtWsT48eP56quvAMIzDs899xybNm3itddeY8aMGeUa++uvv84XX3zB+vXrueOOOzh06BBjxow5ZvuYmBj+9Kc/8cc//pFJkyaxZcsWli1bxquvvsqkSZMA+N3vfsemTZu4//772bBhA1OmTGHixInHHcdf//pXPvzwQ/7617+ybt06Vq1axT/+8Y/w+RYtWjB79mx2797NgQMHyuzj/vvvZ+LEibzxxhts2rSJF154gc8//5w//elP5fpeVCcFA7XQ2r25AHRvGlfqeNvk0JTb5n2Hg4HtBwu44a0FPDJ1NfO2HMThKAkGSgcMIiIiUk1q4YxAidtvv52rr76aG264gT59+nDw4EH+8Ic/hM9HRkayfv16rrnmGtq1a8dtt93GHXfcwe23335UX9HR0Xz99deYpslll11GQUEBEyZMYNSoUdx33320b9+eoUOHsnjxYpo1C+2E2LdvX/7973/z8ssv0717d7799lsefvjhco396aef5umnn6Z79+7MmTOHadOm0aBBg+Ne88QTT/DII48wfvx4OnbsyMUXX8xXX31Fy5YtAWjWrBn/+c9/mDp1Kt27d+fNN9/kqaeeOm6f5557Lp9++inTpk2jR48enH/++aVmFx5//HG2bdtG69atadiwYZl9DB06lJdffpnnnnuOzp07869//YsJEyZw7rnnlut7UZ2M4uzleik3N5e4uDhycnLC699qmi8QpPNfv8HrDzL7/vNolhQZPvfYtDVMnLeNWwe15P8uC00r3freknCy8diBLfm/S9uxb99KTNOkUaMuyhsQERH5FbfbTXp6Oi1btsTlctX0cORXtm3bRsuWLfnll1/o0aNHTQ+n1jrez3FF7nE1M1DLbN1fgNcfJMZpo2lC6YSVkpmBTcXLhPbnefh+/eEM8x83ZGKx2HA4YgAoKqrmfWlFRERE5LSmYKCWWbMnB4COjWOxWEoX/GifHLrJX7Urh2DQ5L/LdxMImrRqEIXVYrBlfwEZOW4iIhIA8HhyTu3gRUREROS0UuFgYPbs2VxxxRWkpqZiGAZTp04Nn/P5fDzwwAN07dqVqKgoUlNTGTVqFHv27CnVR1ZWFiNHjiQ2Npb4+HjGjh0b3g6qxMqVKxk0aBAul4u0tDSeeeboqrqffvopHTp0wOVy0bVrV/73v/9V9O3UOit2ZgPQpUncUee6NY0n2mnjYIGXN37awnPfbgDgloEtad0wlCuwbm8uTmdoOsjnK8Q0q3c7KhEREZGq1KJFC0zT1BKhU6TCwUBBQQHdu3fn9ddfP+pcYWEhy5Yt45FHHmHZsmV8/vnnbNiwgSuvvLJUu5EjR7JmzRpmzpzJ9OnTmT17Nrfddlv4fG5uLhdddBHNmzdn6dKlPPvsszz22GO89dZb4Tbz5s1j+PDhjB07ll9++YWhQ4cydOhQVq9eXdG3VKss25ENwBnN448657BZGNgmlDjz7DcbcPuCnNe+IcPPTKNDSigAWJeRi9XqwGp1YJqmEolFRERE5JgqXHTskksu4ZJLLinzXFxcHDNnzix17LXXXuOss85ix44dNGvWjHXr1jFjxgwWL14crhr36quvcumll/Lcc8+RmprK5MmT8Xq9vPvuuzgcDjp37szy5ct54YUXwkHDyy+/zMUXX8z9998PhLLHZ86cyWuvvcabb75Z5vg8Hg8ejyf8PDc3t6Jvv1oVeQOsK95JqGezhDLbXNCxETPWZGAYMGZAS+4f0h6b1UKHxjFMWwHr94b2/nU4oikqysLjOTxTICIiIiJypGrPGcjJycEwDOLj4wGYP38+8fHxpcpHDx48GIvFEi5KMX/+fM4++2wcDke4zZAhQ9iwYQOHDh0Ktxk8eHCp1xoyZAjz588/5ljGjx9PXFxc+FFSgKK2WLErG3/QJDnWSWpc2bsbDO3ZhEcv78QXfxjAI5d3wmUPVfzrWDwzsD4jFEy4XPEAFBYeIBg8fiEMEREREamfqjUYcLvdPPDAAwwfPjy8rVFGRgaNGjUq1c5ms5GYmEhGRka4TXJycqk2Jc9P1KbkfFkeeughcnJywo+dO3dW7g1WkZ1Zhdz49kKGvRWqgNevVVK42Niv2a0WxgxsSY+0+FLHOzYOfX+37C+gwOMnIiIBuz2CYDBAYeH+ah2/iIiIiJyeqi0Y8Pl8XH/99ZimyRtvvFFdL1MhTqeT2NjYUo+a5vYFGPbWAuZsPlyx7ppeTSvcT0qci2aJkQSCJgvTDwIQFRUKurTFqIiIiIiUpVqCgZJAYPv27cycObPUTXdKSgqZmZml2vv9frKyskhJSQm32bdvX6k2Jc9P1Kbk/Oni06W72J1dFH7eJD6C/q2PX13vWAa2DV03e2MosHC54jEMA5+vCJ+vsPKDFREREZE6pcqDgZJAYNOmTXz33XckJSWVOt+vXz+ys7NZunRp+Nj3339PMBikT58+4TazZ8/G5/OF28ycOZP27duTkJAQbjNr1qxSfc+cOZN+/fpV9VuqVhPmpgPw1ys68e9RvZk05iyslrKXCJ3IoOKdhkpmGSwWG05naIvSrKzNBIP+KhixiIiI1IRzzz2Xe+65p1xtf/zxRwzDIDs7u1Kv2aJFC1566aVK9SG1W4WDgfz8fJYvX87y5csBSE9PZ/ny5ezYsQOfz8e1117LkiVLmDx5MoFAgIyMDDIyMvB6vQB07NiRiy++mFtvvZVFixYxd+5cxo0bx7Bhw0hNTQVgxIgROBwOxo4dy5o1a/j44495+eWXuffee8PjuPvuu5kxYwbPP/8869ev57HHHmPJkiWMGzeuCr4tp8bOrEK27i/AZjG4rncaF3ZKpk2j6JPur2+rUOC1OTOf7MLQ9zsurhk2m5NAwEdR0aEqGbeIiIiI1A0VDgaWLFlCz5496dmzJwD33nsvPXv25NFHH2X37t1MmzaNXbt20aNHDxo3bhx+zJs3L9zH5MmT6dChAxdccAGXXnopAwcOLFVDIC4ujm+//Zb09HR69erFfffdx6OPPlqqFkH//v2ZMmUKb731Ft27d+ezzz5j6tSpdOnSpTLfj1NqwdbQ2v5uTeOIdlZ4l9ejJEQ5aNUgVHzsl+J6BVarncjI0IyB250NQV/oISIiIiL1XoWDgXPPPRfTNI96TJw4MVwxrqzHueeeG+4jMTGRKVOmkJeXR05ODu+++y7R0aU/Ee/WrRs///wzbrebXbt28cADDxw1luuuu44NGzbg8XhYvXo1l156acW/AzVofnEw0K910glall9JfYJlOw7PApRsM+pZ8if2TXKQ/4ED5t9SZa8pIiIip9b7779P7969iYmJISUlhREjRhyVkwkwd+5cunXrhsvlom/fvkcVZ50zZw6DBg0iIiKCtLQ07rrrLgoKCk7V25BaoNrrDMixLd0eumHv07LqgoGSysVLth0OBmw2Fw6bE3ZPI2BCrh9yNk5UQCAiIgKYpkmh118jD9M0T2rMPp+PJ554ghUrVjB16lS2bdvG6NGjj2p3//338/zzz7N48WIaNmzIFVdcEc7J3LJlCxdffDHXXHMNK1eu5OOPP2bOnDmn1ZJrqbzKr02Rk1Lo9bMjK7TDT+fUqtvitGQnosXbssgu9BIfGSrcltSwM8EON+PePIkcPxQEIGrLRGx93gKLHb/fTdDvxlE8iyAiIlJfFPkCdHr0mxp57bWPDyHSUfHbsTFjxoS/btWqFa+88gpnnnkm+fn5pVZb/PWvf+XCCy8EYNKkSTRt2pQvvviC66+/nvHjxzNy5MhwUnLbtm155ZVXOOecc3jjjTdwucougCp1i2YGasjmzHxME5KiHCRFO6us35YNouiQEoM/aDJz7eGtVw3DwNp/IlE3enE1vxoIBQQs+h0AB38YzsEpCfjnja6ysYiIiEj1WLp0KVdccQXNmjUjJiaGc845B4AdO3aUanfkLouJiYm0b9+edevWAbBixQomTpxIdHR0+DFkyBCCwSDp6emn7s1IjdLMQA3ZuC8fgHbJMVXe98VdUlifkccPGzK5rnda6ZMWO1H9/417++cUBSF2y7sEez5PYOdUADybJ2Hr+2+w2Kt8XCIiIrVRhN3K2seH1NhrV1RBQQFDhgxhyJAhTJ48mYYNG7Jjxw6GDBkS3r2xPPLz87n99tu56667jjrXrFmzCo9LTk8KBmrIxn15ALRPqfpgoEdaPBCafSiLMyIRW9pV+Hd+QVEQLIvGQZMrYfc0PE2uJkqBgIiI1COGYZzUUp2asn79eg4ePMjTTz9NWlroQ78lS5aU2XbBggXhG/tDhw6xceNGOnbsCMAZZ5zB2rVradOmzakZuNRKWiZUQzZkhIKB6pgZaFm8vei2g4UEg2UnJkX2eRmAbB9kb54Mnf4MTS7Hs/1zzPljyrxGREREal6zZs1wOBy8+uqrbN26lWnTpvHEE0+U2fbxxx9n1qxZrF69mtGjR9OgQQOGDh0KwAMPPMC8efMYN24cy5cvZ9OmTfz3v/9VAnE9o2CghqQlRtCqYVS1zAw0iY/AbjXw+oPsySkqs01UTBOsUaFPCoImMHMg7J6OCXi3TFAtAhERkVqqYcOGTJw4kU8//ZROnTrx9NNP89xzz5XZ9umnn+buu++mV69eZGRk8OWXX+JwhDYX6datGz/99BMbN25k0KBB4bpRJUVgpX4wzJPd06oOyM3NJS4ujpycHGJjq25Hn9rg/Od/ZOv+Aj4Y24eBbRsc3SDowzfFQZ4f3MHQIbsBPhOiW15H7HmfnNoBi4iInCJut5v09HRatmypHXPktHW8n+OK3ONqZqCOKqlEnH6g7LwBLHbsbcaQ6IBkJzRwQHTrkaGlQts+hQVjT+FoRURERKQmnD7ZMlIhJXkDW/Yfp4pg33fgrDexAlYgEPDB+1H4gOCWd7Gc9aZ2FRIRERGpwzQzUEeVJCav25t7/IYWe/hhtUdiS7sKAG+zGxUIiIiIiNRxmhmoo7o0iQNg7Z5cgkETi8Uo13WOM1/A3+kBvFHJaBWliIiISN2mmYE6qk2jaBw2C3kePzuyCst9ncMRDaufwju1pfIGRESkTqvHe6hIHVBVP78KBuoou9VCh+JtS9fsOcFSoSM4bC7YPQ1fMJQ3oC1GRUSkrrFaQ1V/K1KtV6S2KSwMfdhrt1duWbeWCdVhnVPjWLkrh9V7crisW+NyXWNzRIerE3vTRuBS3oCIiNQxNpuNyMhI9u/fj91ux2LRZ6Ny+jBNk8LCQjIzM4mPjw8HtydLwUAd1qVJaF/Z1btzKnSd86yX8Ad9eNKn4HK4QrsOiYiI1BGGYdC4cWPS09PZvn17TQ9H5KTEx8eTkpJS6X4UDNRhnVMPJxGbpolhlDOJ2OaiYPd0vBZg67ugLUZFRKSOcTgctG3bVkuF5LRkt9srPSNQQsFAHdYhJQarxeBggZeMXDeN4yLKdZ3DlQBNrsS3expmy1swFAiIiEgdZLFYVIFY6j0tkqvDXHYrbRpGA7B6d/mTiK1WO9YeT8KQBXh7PFddwxMRERGRGqZgoI7rXJw3sGZPxfIGHI4oWP0Uvk+TtMWoiIiISB2lYKCO61KcN1CRmQEAu9UBu6fhDRLKG9AWoyIiIiJ1joKBOq5z6knODBTnDXhNoNUYJRCLiIiI1EFKIK7jOhUHA3tz3BzM95AU7SzXdXZ7BEa3vxLs9Gf8jXvrB0VERESkDtLMQB0X47LTIikSgHV788p9nWFYsK/5O8wciG+ecgZERERE6iIFA/VAq+IdhbYdLCj/RUEf9t2fA+BLn6ycAREREZE6SMFAPdC8eGZge0WCAYsdW8vhAPibXqucAREREZE6SEvB64EWSVEAbDtYWKHrbH3+Ba3vxm+Pqo5hiYiIiEgN08xAPXBSMwOEkogxbPj9HkwzWB1DExEREZEapGCgHmjZIPTJ/vaDhQSDZrmvs1hsWCw2MP34/e7qGp6IiIiI1BAFA/VAk/gIbBYDjz/IvryK3dTb1jwB3/TFox2FREREROocBQP1gM1qoWlCBADbDlQgbyDoI3LPfwDI3/oRQc0OiIiIiNQpCgbqieZJJUuFKrajUESbW7AZEEy9Erc3v5pGJyIiIiI1QcFAPVFSeKyiOwoZ/d4l4urt0PVR3O7sahiZiIiIiNQUBQP1xEnNDBSLiGoEgMeTS2HhQXy+oiodm4iIiIjUDAUD9USLBic3MwBgs7mw2yMxTZPs7G0cPLhRW42KiIiI1AEKBuqJkpmBdXtz+ftXa1m241CFro+JaRz+Ohj0U1h4oErHJyIiIiKnnoKBeqJZYiRpiaEdhf79czrjJi87qubAzqxCdmaVPXPgcsUTHZ2C1WoHUDAgIiIiUgcoGKgn7FYLH97al+t6NQVgT46bX3Yenh3Ym1PEJS//zEUvzmbFzuwy+4iNbUKDBh0B8PmKCAb91T5uEREREak+CgbqkaYJkTx7XXeu7tkEgOkr94bPPTtjA/keP0W+APd8vPyYfVitdmw2FwBebTUqIiIiclpTMFAPnd8xtDvQsu2hmYED+R7+u2JP+Hz6gQJ2Zx97xyCnMwZQMCAiIiJyulMwUA91bBwLwMZ9+QSDJtNX7CEQNOneNI7uTeMAWLIt65jXOxzRAHg8edU/WBERERGpNgoG6qHmiZE4rBaKfAG2ZxXy0eKdAPymRxN6NU8EYOn2Y+825HCEZgZ8vkKCwUD1D1hEREREqoWCgXrIZrXQulHo0/0np69lfUYeMS4bQ3s24cwWCQB8vmw3i48xO6C8AREREZG6QcFAPdU+ORQMzFqfCcAfB7cjMcrBBR2T6dcqiXyPn4c+X4VpmmVef3ipUM6pGbCIiIiIVDkFA/XUWS2Twl+3bRTNTf2aA+CwWfjXqF5EO21szsznx437y7w+IiI0g1BUlKVqxCIiIiKnKQUD9dQNZ6Zx34Xt6JEWz7PXdcduPfyjEOuyc21xPYLpK/aWeb3TGYvV6iAYDOB2a3ZARERE5HSkYKCesloM7rygLVPvGECPtPijzp/drgEAK3ZlH7MPlyt0nfIGRERERE5PCgakTN2axgOwZX8+uW5fmW0cjiggtKuQiIiIiJx+FAxImRpEO2maEIFpwupdZS8DstsjgVAwcKxEYxERERGpvRQMyDF1L14+tPwYS4VsNheGYcE0g/j97lM3MBERERGpEgoG5Jh6FC8VWrEz+5htSpYKeTy5p2BEIiIiIlKVFAzIMZXMDKzYeezdglyu0BajbvexKxaLiIiISO2kYECOqUuTWCwGZOS6ycgpexnQ4R2FCvD7PadwdCIiIiJSWQoG5JgiHTbaJccAsGxH6JP/YNDkk8U72ZwZ2k7UarXjdIbaaHZARERE5PSiYECOa0CbUL2BWesyAZi8cDt//s9KRr69gJyi0JajERGJABQVKRgQEREROZ0oGJDjurBTMgCz1u+j0Ovnle83A7Av18OrszYBh5cK+XyFBAJl1yQQERERkdpHwYAcV+/mCSRE2sku9PHE9LXszzucF/Djxv0AWCw27PYIAHy+ghoZp4iIiIhUnIIBOS6b1cKlXRsD8OGinQCM6NMMgM2Z+WQVeAGw21WNWEREROR0o2BATujqM5qWej52YEvaNooGYPG2LOBwNWKvVzMDIiIiIqcLBQNyQmc0i2dAmyRinDbuH9Ke1g2j6d0ilDT8y45s4HDxMZ+vANM0a2qoIiIiIlIBtpoegNR+hmEw+bd9MU0TwzAAwjMDO7JCMwE2WwQWi41g0I/PV4DDEV1j4xURERGR8tHMgJRbSSAA0CwxtCxoR1Zh+JzTGQuA233sisUiIiIiUntUOBiYPXs2V1xxBampqRiGwdSpU0udN02TRx99lMaNGxMREcHgwYPZtGlTqTZZWVmMHDmS2NhY4uPjGTt2LPn5+aXarFy5kkGDBuFyuUhLS+OZZ545aiyffvopHTp0wOVy0bVrV/73v/9V9O3ISUorDgZ2ZhWFj7lccQC43dk1MSQRERERqaAKBwMFBQV0796d119/vczzzzzzDK+88gpvvvkmCxcuJCoqiiFDhuB2u8NtRo4cyZo1a5g5cybTp09n9uzZ3HbbbeHzubm5XHTRRTRv3pylS5fy7LPP8thjj/HWW2+F28ybN4/hw4czduxYfvnlF4YOHcrQoUNZvXp1Rd+SnIS0xNBWojlFPnIKQ7UFnM44DMOC3+9WIrGIiIjIacAwK5HtaRgGX3zxBUOHDgVCswKpqancd999/OlPfwIgJyeH5ORkJk6cyLBhw1i3bh2dOnVi8eLF9O7dG4AZM2Zw6aWXsmvXLlJTU3njjTf4v//7PzIyMnA4HAA8+OCDTJ06lfXr1wNwww03UFBQwPTp08Pj6du3Lz169ODNN98s1/hzc3OJi4sjJyeH2NjYk/021Fu9n/yOA/kept85kC5NQrMChw6lU1SUhWEYJCW1DycWi4iIiMipUZF73CrNGUhPTycjI4PBgweHj8XFxdGnTx/mz58PwPz584mPjw8HAgCDBw/GYrGwcOHCcJuzzz47HAgADBkyhA0bNnDo0KFwmyNfp6RNyeuUxePxkJubW+ohJ69Z8exASd4AQHR0qGKxaZrk5e2pkXGJiIiISPlUaTCQkZEBQHJycqnjycnJ4XMZGRk0atSo1HmbzUZiYmKpNmX1ceRrHKtNyfmyjB8/nri4uPAjLS2tom9RjnA4b+BwMGC3R9KgQQcAvN48gsFAjYxNRERERE6sXu0m9NBDD5GTkxN+7Ny5s6aHdFr79Y5CJRyOKOz2CEzTxOPRzkIiIiIitVWVBgMpKSkA7Nu3r9Txffv2hc+lpKSQmZlZ6rzf7ycrK6tUm7L6OPI1jtWm5HxZnE4nsbGxpR5y8tKOEQwA4ToDPl/RUedEREREpHao0mCgZcuWpKSkMGvWrPCx3NxcFi5cSL9+/QDo168f2dnZLF26NNzm+++/JxgM0qdPn3Cb2bNn4/P5wm1mzpxJ+/btSUhICLc58nVK2pS8jlS/tIRQMLDr0NE3/BaLHYBg0H9KxyQiIiIi5VfhYCA/P5/ly5ezfPlyIJQ0vHz5cnbs2IFhGNxzzz08+eSTTJs2jVWrVjFq1ChSU1PDOw517NiRiy++mFtvvZVFixYxd+5cxo0bx7Bhw0hNTQVgxIgROBwOxo4dy5o1a/j44495+eWXuffee8PjuPvuu5kxYwbPP/8869ev57HHHmPJkiWMGzeu8t8VKZdmSSXBQCGBYOlNqazWkmDAd9R1IiIiIlI72Cp6wZIlSzjvvPPCz0tu0G+++WYmTpzIn//8ZwoKCrjtttvIzs5m4MCBzJgxA5fLFb5m8uTJjBs3jgsuuACLxcI111zDK6+8Ej4fFxfHt99+yx133EGvXr1o0KABjz76aKlaBP3792fKlCk8/PDD/OUvf6Ft27ZMnTqVLl26nNQ3QiouJdaF3WrgC5hk5LppEh8RPlcyMxAIKBgQERERqa0qVWfgdKc6A5V33nM/kn6ggA9v7Uu/1knh4z5fIfv3r8NqtZOc3K0GRygiIiJSv9RYnQGpf5omhGYDdh4qnUR85MxAPY43RURERGo1BQNSKc3KqDUAYLEcXoGmJGIRERGR2knBgFTKsWoNGIYRDggUDIiIiIjUTgoGpFKONTMA2lFIREREpLZTMCCVcrjw2NG1Bmy20A5SXm/+KR2TiIiIiJSPggGplJJg4EC+h0Jv6eVALlc8AEVFh071sERERESkHBQMSKXERdiJiwgtB9q6v6DUOaczDsMw8PvdeL0FZV0uIiIiIjVIwYBU2hnN4gGYu/lAqeMWi5WIiEQA8vP3nuphiYiIiMgJKBiQSjunXUMAftq4/6hz0dGNAXC7c/D7Pad0XCIiIiJyfAoGpNLOLg4Glmw7hNsXKHXOZnPicEQD4PHknvKxiYiIiMixKRiQSmvZIIqkKAfeQJCN+/KOOu9yxQHg8eSc6qGJiIiIyHEoGJBKMwyD9ikxAKzfe3Qw4HSWBAN5mGbwlI5NRERERI5NwYBUiQ4psQCszzg6GLDbI7Ba7ZhmUDUHRERERGoRBQNSJTqUzAxklJ0XcHh2IHTeNE0CvqOrFouIiIjIqaNgQKpEh8ahYGDd3lxM0zzqvNMZmjlwu0N5A7k/DiPz/Sg8c246dYMUERERkVIUDEiVaJ8Sg8tu4VChj02ZRy8FcjpDwYLf7ybgK6Qg/RNM4ODGD8CvGQIRERGRmqBgQKqE02blzBahAmPzflV8DMBisWG3RwJQ6M6BJleGz2VPjoIFY0/NQEVEREQkTMGAVJl+rZMAmLvlYJnnS5YKFRTsgy5/AcAACgPg2/wuBH2nZJwiIiIiEqJgQKrMoDah4mMz1+7j4amr2JlVevlPREQihmEhGAyAYSOq5fU4i38Ci5pcBxb7qR6yiIiISL2mYECqTJcmsTRNiADggwU7eHrG+lLn7fYIGjXqTExMY5zOWKIGvUfEdfugyeW4t32qpUIiIiIip5iCAakyhmFwQ++08POvVu7F4w+UamO1OoiJSSUpqS02mxOXKw5j93T8Jni0VEhERETklFIwIFVqzMCW3DqoZfj5vGPkD5QwrE4iWl4PhHIHWPS76hyeiIiIiBxBwYBUqSinjf+7rBOj+jUH4LOlu054TWS/fwHgDoC5RbMDIiIiIqeKggGpFsPObAbAN6sz2JfrPm5bhyseW9pVmEBu6nV4irLKLFwmIiIiIlVLwYBUi06psfRqnoA/aPK/VXtP2N7V51VocjkF6Z9y8OMUCj9vfQpGKSIiIlK/KRiQanNRp2QAftq4/4RtoyLiceydHn7uzktXZWIRERGRaqZgQKrNue0bAbBg60HcvsBx21rtUTToMIZGjtBzr7MpQYuzuocoIiIiUq8pGJBq0y45mibxEbh9QT5ctOPEF/R9B9sIL7amV2AW7cIz5+bqH6SIiIhIPaZgQKqNYRj84bzQ2v8XZm6kyHv82YESERlfApC/ZbJ2FhIRERGpRgoGpFoNO7MZiVEO8tx+Nmfmn/gCi52otqOxGOAzwTNPVYlFREREqouCAalWVotB64ZRAGw9UI5gALD0eQtX8U+mZ8v7mh0QERERqSYKBqTatWoQDcCW/QXlu8Bix9lqJADuIKpKLCIiIlJNFAxItWvdqHhmYH/5ZgYAnP3exgD8JhRuelfbjIqIiIhUAwUDUu0qPDMAWGwuolsPAyDHB0UfRuGdMwrTV/6AQkRERESOT8GAVLtWxTkD6QfyCQbNcl8XPXASEVYwgUM+OLDxfTLej2H/x80JBLzVNFoRERGR+kPBgFS7tMRIbBYDty/I3lx3ua8zrA4S2o/BYhw+ZgK+gh3kZ6dX/UBFRERE6hkFA1Lt7FYLzZIigYrlDQDQ9x2ir9oa6seAOBsQ2ZRCbwHBoL+KRyoiIiJSvygYkFOiJG9gawXyBkpExbUgvs0IEh0Q1WYU9gu+xTRN3O6cqh6miIiISL2iYEBOiXCtgYrODBCqZBx59mSsw73QfxIuVxwAHo+CAREREZHKUDAgp0SrcOGxis8MhFnsADidJcFALqYZrPTYREREROorBQNySrRuGFomtGlfaGYgq8DLrHX7cPsCFe7L4YjCZnMSDAbIz8+o0nGKiIiI1CcKBuSUaJ8SA0BGrpusAi9/mLyUsZOWcOkrP5NT6Ktwf9HRKQDk5e0lO3tbVQ5VREREpN5QMCCnRIzLTvPiHYU+X7aLBVuzgFBC8bSVeyrcX0REEpGRDQAoLDxIQUFm1Q1WREREpJ5QMCCnTOfUWACe/GpdqeNfnUQwYBgG8fHNiYtLAyA3dxc+X2HlBykiIiJSjygYkFOmU+PYUs+fvbYbAIvSs9if5zmpPqOiGuFyxWOaJvn5+yo9RhEREZH6RMGAnDLntm8U/rpFUiTX9mpK97R4gibMWHPyicAl+QNud7Z2FxIRERGpAAUDcsp0aRLHv0f1pnNqLA9f1gnDMLisa+hG/mSWCpUo2V3INIMqRCYiIiJSAQoG5JS6sFMyX901iMGdkgG4pEtjoHJLhQAcjtBuRX5/UeUHKSIiIlJPKBiQGpWWGFklS4VsNicAfv/JBxQiIiIi9Y2CAalxJUuFvlx+8kuFbDYXAIGAggERERGR8lIwIDXu8m6pWC0Gi7ZlsWrXya35t1o1MyAiIiJSUQoGpMalxkdwRbdQ7sAj/11NTlHFKxKXLBMKBtwEg/4qHZ+IiIhIXaVgQGqFOy9oS4zLxvKd2Tzw2coKX28YFqxrnoRv+uKfN6YaRigiIiJS9ygYkFqhdcNoJv+2DzaLwYw1GTz99XoCQbP8HQR9OPZMBaBoy/sQrPjsgoiIiEh9o2BAao1uTeP5w7mtAXjzpy28NXtr+S+22IlsfRMARUEILrytOoYoIiIiUqcoGJBa5Y8XtuOhSzoA8Or3mziYX/6EYGf/d7AZEDShcNNEzQ6IiIiInICCAalVDMPg1kGt6JASQ6E3wKx1meW/2GInuvUIAPIDYC68vZpGKSIiIlI3KBiQWsdiMRjSOVR74MeNFQgGgIgBE8KzAwWbJmh2QEREROQ4FAxIrXReh0YA/LzxAB5/oNzXGVZHeHagQLMDIiIiIsdlmKZZgS1b6pbc3Fzi4uLIyckhNja2pocjRwgGTQb843v25ri5oEMjLBYDq2HQNCGCcee3IT7SccxrzYCXfe85CZqQaAfXSC9Y7Kdw9CIiIiI1pyL3uJoZkFrJYjHCOwvNWp/JzLX7mLEmg7fnpPPizI3HvdawOohocT0Q2lmIRb+r7uGKiIiInJYUDEitdf2ZaQzu2IgG0Q5iXbbw8f8s202B5/hVhiP7/xsAdwCCW949OndAuQQiIiIiVR8MBAIBHnnkEVq2bElERAStW7fmiSee4MjVSKZp8uijj9K4cWMiIiIYPHgwmzZtKtVPVlYWI0eOJDY2lvj4eMaOHUt+fn6pNitXrmTQoEG4XC7S0tJ45plnqvrtSA1y2qy8ffOZLHn4QlY+NoStT11Ki6RI8j1+/rt8z3GvtTtjsTe7GhPI8ID7i/YQ9OH35nPwu2sonOyA+becmjciIiIiUktVeTDwj3/8gzfeeIPXXnuNdevW8Y9//INnnnmGV199NdzmmWee4ZVXXuHNN99k4cKFREVFMWTIENxud7jNyJEjWbNmDTNnzmT69OnMnj2b2247XEgqNzeXiy66iObNm7N06VKeffZZHnvsMd56662qfktSS1gsBiP7NAfggwXbOVG6S9RZL4W/zspJZ98kB/s/iMGz43OyfeDdMlEBgYiIiNRrVZ5AfPnll5OcnMw777wTPnbNNdcQERHBBx98gGmapKamct999/GnP/0JgJycHJKTk5k4cSLDhg1j3bp1dOrUicWLF9O7d28AZsyYwaWXXsquXbtITU3ljTfe4P/+7//IyMjA4Qglkz744INMnTqV9evXl2usSiA+/Rwq8NJn/Cy8/iDf3HM27VNijts+8EUbDuVswRs8+lyEFRLswDAlGIuIiEjdUaMJxP3792fWrFls3BhK8lyxYgVz5szhkksuASA9PZ2MjAwGDx4cviYuLo4+ffowf/58AObPn098fHw4EAAYPHgwFouFhQsXhtucffbZ4UAAYMiQIWzYsIFDhw6VOTaPx0Nubm6ph5xeEqIc9EyLB2DFruwTtrdetZmkdjfRyBHaWSih+EFkU3xBoNUYBQIiIiJSb9lO3KRiHnzwQXJzc+nQoQNWq5VAIMDf//53Ro4cCUBGRgYAycnJpa5LTk4On8vIyKBRo0alB2qzkZiYWKpNy5Ytj+qj5FxCQsJRYxs/fjx/+9vfquBdSk3q2iSOhelZrNmdA73TTtje6P8etr7vhH/Yg0E/ZK7Fb/oxU8/EqN7hioiIiNRaVT4z8MknnzB58mSmTJnCsmXLmDRpEs899xyTJk2q6peqsIceeoicnJzwY+fOnTU9JDkJXZrEAbB6TwVmdiz28MNii8BqDc0G+HxFmKZJXt5eCgsPVMdwRURERGqtKp8ZuP/++3nwwQcZNmwYAF27dmX79u2MHz+em2++mZSUFAD27dtH48aNw9ft27ePHj16AJCSkkJmZmapfv1+P1lZWeHrU1JS2LdvX6k2Jc9L2vya0+nE6XRW/k1KjerSJLT2be2eXHyBIHZrxWNa++onCGz/DF+b4fh7v0Je3uHdiSIjG1TZWEVERERqsyqfGSgsLMRiKd2t1WolGAxlcLZs2ZKUlBRmzZoVPp+bm8vChQvp168fAP369SM7O5ulS5eG23z//fcEg0H69OkTbjN79mx8vsP7xc+cOZP27duXuURI6o6WDaJpEO2kyBfgh/WZJ77g14I+7Ls/A8C99UNys7eFT+Xk7MDjyauikYqIiIjUblUeDFxxxRX8/e9/56uvvmLbtm188cUXvPDCC1x11VUAGIbBPffcw5NPPsm0adNYtWoVo0aNIjU1laFDhwLQsWNHLr74Ym699VYWLVrE3LlzGTduHMOGDSM1NRWAESNG4HA4GDt2LGvWrOHjjz/m5Zdf5t57763qtyS1jNVicM0ZTQC47f2lLErPqlgHFjuu1qMA8DS+nKAZwGp1EBGRgGma5OdnVPWQRURERGqlKt9aNC8vj0ceeYQvvviCzMxMUlNTGT58OI8++mh45x/TNPnrX//KW2+9RXZ2NgMHDuSf//wn7dq1C/eTlZXFuHHj+PLLL7FYLFxzzTW88sorREdHh9usXLmSO+64g8WLF9OgQQPuvPNOHnjggXKPVVuLnr627s/nwhdnEwiaRDqs/O+uQbRoEFWhPvZ9+xsCu6YBENt6GM7+77J//1oMw0JycldMM4jV6jhBLyIiIiK1S0Xucas8GDidKBg4va3alcN9ny5n4758LumSwhs39ir/xUEfBR84yAuEpscaOMAy3EtG5trQbkOEZrGSktrjcFQsyBARERGpSTVaZ0DkVOnaNI6XbugJwKx1meQU+k5wxREsdqLajSHFCY2cYGkdqjfgdB4uYhbaZWh3VQ9bREREpNZQMCCntU6psXRIicEbCPKfZbsqdnHfd0LVh4d5Q18DMTGp2GyHd5zyePLw+z1VOWSp5T5ftosBT3/P6t05NT0UERGRaqdgQE57I/s0A+CFmRtZvjO7YheX1B8oZrO5aNiwMykpPXA4QvkpXq92F6pP7v1kBbuzi3hi+tqaHoqIiEi1UzAgp70RfZrTq3kC+R4/1/9rPukHCirVn2EYWCzW8JIhT1EFdyuSOsFh059HERGp+/R/OzntWS0Gb4/qTauGUXj9QWasrpqtQR2OGFj1OJ5p7THnj6mSPqV2CwYP76eQEuuqwZGIiIicGgoGpE5IiHIwqm9zAOZs3l8lfTpsTix7phE0wbN5AgQrkKAsp6XMvMP5IQ1iVK1cRETqPgUDUmcMbNsQgMXphyjw+Cvdn2F1ENnyBgDyA8CC31a6T6nddh4qDH8drL+7LouISD2iYEDqjNYNo2iRFIk3EOTLFXuqpM+oAe9gAN4g7F3/Hp7PW1VJv1I77cw6HAz4/AoGRESk7lMwIHWGYRiMKN5ZaOK8baXWf58sqz2KmJbXAWACh3LSCcy9sdL9Su105DIhXyBYgyMRERE5NRQMSJ1yfe80ohxW1mfk8cmSnVXSZ/R5n5AU3xKrAUETCrdMVv5AHeXzHw4AFAyIiEh9oGBA6pT4SAd/vLAdAE/PWM/B/KopGOa8eisxra4HwN14aKnaBFJ3+I6YTfIqGBARkXpAwYDUOaP7t6Bj41iyC32M/3p9lfXrGjQFo8kV+HZOxTf35irrV2oPf+DImQHlDIiISN2nYEDqHJvVwt+v6oJhwGdLd7Fw68Eq6ddCEFfGlwBkb3qPgCenSvqV2sN/xMzAkUuGRERE6ioFA1InndEsgeFnhZKJ75jyC2/N3sK/ftpCoDJJxRY70W1GAeALwsEp8bBgbBWMVmoLX0A5AyIiUr8oGJA664EhHUiKcnAg38NT/1vP+K/X89HiHZXq097vbeKL0wX8JgS3vKtk4jrEH1DOgIiI1C8KBqTOiou089x13emcGhs+9uw3G8h1V+Lm3WInsu0YrEboqb/5TUomrkM0MyAiIvWNraYHIFKdzuvQiPM6NMIfCHLxyz+zOTOfbo99yzPXduP63mkn12nfd7C1vpeANx9/QhscVTtkqUFHJg0rgVhEROoDzQxIvWCzWri3eMtRgD9/tpL/Lt998v05YsCw4ffmVcXwpJbwBzUzICIi9YuCAak3LumSwpNDu9CqYRQAHy46+fwBq9UJqx4n8N+WSiKuQ0rlDGg3IRERqQcUDEi9YRgGN/Ztzls39QLglx3ZePyBk+rLbrXB7ml4g2AqibjOUM6AiIjUNwoGpN5p3TCaxCgHHn+Q1btPrlaAw5WIpelvCJjgSRuhJOI6olSdAeUMiIhIPaBgQOodwzA4s0UCAAu2ZgHg9gXILvRWqI/Ivq9Bk8sp3DpFS4XqCM0MiIhIfaNgQOqlgW0aAPDjhkx2ZxfR/+nv6fH4TP7vi1Xl7iPSFQe7p+MOQkBLheoEf6ndhBQMiIhI3adgQOql8zo0AmDxtkOM+PcCsgpCswIfL97JwXxPufqwOWJwRDcHYL8X/AturZ7Byilz5G5CSiAWEZH6QMGA1EtNEyLpkBIDwPaDhThsFiIdVvxBk6nL95Svk6CPWO92LAYETcjfNKnU7IBp6mbydKM6AyIiUt8oGJB66+HLOtGlSSwtkiJ5b8xZ3D+kPRBaOlQuFjuONmNILM4dLgpAoHh2IC9vD3v3/kJRUVZ1DF2qieoMiIhIfaMKxFJvDWzbgOltB4WfRzlCvw4rd+VgmiaGYZy4k77v4Oj9Ko4PovAGoWjzJBxnvERe3l4AsrO343LFYxiKu08HR+YM+IMmwaCJxVKOnwMREZHTlO5QRIq1T4nBYbWQU+Rj+8HC8l9oiySi1XAAioJQNP/28CnTDGp24DTy69kAX1CzAyIiUrcpGBAp5rBZ6JgaC8DS7YfI9/jLfW1E/3cwAF8QCtI/AdOP3R4JgNudXQ2jlepwZJ0BUN6AiIjUfQoGRI7QMy0egPs+XcFZf/+OnVnlmyGw2CKIanXD4QOrnyQuLg0AjyeXYPDkKh3LqeX/1c2/TzsKiYhIHadgQOQI1/ZqGv660Btg2opy7iwExAyahLV4ebl9z3QcS+/EZnNhmqZmB04T3l8vE1ISsYiI1HEKBkSO0KVJHAPaJIWf/7Rhf7mvNaxOGrYfRYwN4uxA+kQinNEAuN2HqnqoUg38v7r5/3VwICIiUtcoGBD5lVeG9eSJ33QGYMn2LHIKy19Z2NJ/EjFtR+OwAK3G4IoMFTdzu3PIzd2F31++gmZSM45aJqScARERqeMUDIj8SlK0k5v6taB1wyiCJixMP1ixDvpNgGFe6PsOdnsEkZENAMjP38f+/WvxevOrYdRSFX69e5CWCYmISF2nYEDkGPq2Ci0Xmr+1gsEAgMUe/jI+vjkJCa2w2ZyYZpCCgvIvPZJT69czA14lEIuISB2nYEDkGMLBwJaTCAZ+JSIigdjY0O5CPl8FahjIKWOaZnhr0UiHFdDMgIiI1H0KBkSOoV/rJCwGrM/IY9hb81m+M7tS/ZXUHfD73ZgB5Q7UNkfWGCgJBjQzICIidZ2CAZFjaBDt5Nz2oQTgBVuzePA/KyvVn9Vqx2KxwarHOPS+C3Pe6CoYpVSVI5cIueyhYCAQVAKxiIjUbQoGRI5j+FnNwl+vz8hj9e6cSvVnX/047J6OOwiHNk4iMOemyg5RqsiRycMlwcCvKxKLiIjUNQoGRI5jcMdGvDHyDLo1jQPg95OXsi/XfXKdBX1E7/08XJjMHYQDmz5QQFBLlJ4ZCP1p9Ae1TEhEROo2BQMix2EYBpd0bcw/R55Bs8RIdmYV8c8fNp9cZxY7zrZjSHZCg/iWWA0ImJC75QOYf0vVDlwqrKTgmMUAu7U4GFCdARERqeMUDIiUQ9OESMZf3RWAT5bs4lCB9+Q66vsODPPiuHoriW1GAOAOQHDrRAiWv7iZVD1f8ZIgm9WC3VIyM6BgQERE6jYFAyLl1L91Ep0ax1LkCzB54faT76i4BoF90GTsaUMxgVw/sOh3VTJOOTklMwN2i4HVElrLpWBARETqOgUDIuVkGAa3nd0KgInztlPkDVS6z8i+rwNQGID8je9qdqAG+QKHZwZsxYkdAeUMiIhIHadgQKQCLuvWmKYJERzI9/DGjyeZO3CEqKiGRIY2rqEgEKpBsH//Wg4c2IDff5KJynJSSpKF7VYDW/HMgE85AyIiUscpGBCpALvVwl8u7QjA6z9u4Zs1GZXr0GInrt0tGISSiTN/uBGfrwivN5/s7G2VHq+Un89fPDNgsWAtzhlQnQEREanrFAyIVNAlXVK4tldTAkGTP326gu0HCyrVn9HnX+HZAXZPA9MPgNdbgNdbgMeTh9/vJiNjRfGMgaoXV4eSOgM2q4G9eJlQSR6BiIhIXaVgQKSCDMPg6au70j0tnjy3nwtfnM3MtftOvkOLndh2t5DshOQOo0lp3AuHIxqAAwfWc/DgRjIz1xAM+vF68zl0aCumaWKaQQoKMvF48gDwePIoKsoCQsuNTFM3shVRso2o3WpRArGIiNQbtpoegMjpyGa18NINPRg7aTFb9xdw3yfL+e7ec2gU6zqp/ox+72Lt86/wTkMREQl4vflltvX5CikoyKSo6CA+X9FR57Ozt2GaJhaLjbiYFFyRjTAM46TGVZ+UzALYLIbqDIiISL2hmQGRk9SyQRTf3HM2nRrHkuv2M33l3sp1WBwIAERGNiQpqS2Jia2JjW1CREQiSUltiYtrBkBu7q4yAwEA0wzdwAZXPMqhj1PI+/GGyo2rnjiyzoBmBkREpL7QzIBIJditFi7pksLavbks35ldZf0ahoHTGXvUcacTPJ4c3O4cAGJjm2K3R2Kx2LDZXHg8uWRnpxMMeEL5B0B++qc4rSNwnj2lysZXF5XMDDiO2E1IW4uKiEhdp2BApJJ6NksAYPrKPRwq9NI0IYK/XtEZl916gitPTkJCK/Ly9hAI+IiKaohhHJ7gc7niSE7uBhgYHUeTvXEihQE4tOVDGlqsWAe+Xy1jqgvKqjOgrUVFRKSuUzAgUknd0uIACJrw86YDAHy4aCcJkXaeHNqVy7o1rtLXMwwLsbFNj3segH4TiAsG8G16H18Q8rZ8QLzVBv0mVOl46oqSOgM2i4FNW4uKiEg9oZwBkUqKddk5q2XiUccPFfq4Y8oytu4vOxH4VDAGvEdcq+FAqMqxb8tEVTk+hiN3EwoXHdMyIRERqeMUDIhUgbdv7s2s+84hffylDOmcXOrcjMoWJqskx9lTiGh+DQA5fmDhbTU6ntrKFzhcZ8BavEwooGVCIiJSxykYEKkCsS47rRtGYxgGf7+qK6P7t2D4WaGdfxZuzarh0UHs2ZMwAG8Q8jZNJDDnxpoeUq1TsnOQzXJ4ZkC7CYmISF2nYECkijWIdvLYlZ25sW8oGFiyLavGK9la7VFEt7oegDw/7Ns4Gf+cm2p0TLVNyb+R3Xo4Z8CvZUIiIlLHKRgQqSYdU2KJi7BT4A2wdPuhmh4O0YPeJ+aILQO86R8of+AIpXYTCm8tqpkBERGp2xQMiFQTi8Xgwk6h/IH/rthTw6MBw+ogpt0Yoop3PPWn3VCq0Fl9VzILYLcY2IorEGtrURERqesUDIhUo6E9mgDw5fI9fLliD/kef80OqO87WK/aCUMWEOj+VM2OpZY5PDNgYDNCgYFmBkREpK5TMCBSjfq1TqJrkzjyPH7u/PAX+j01iyenryXXXXPLc2yOGDBs+P2eGhtDbVSymxD7fqBo6X2lj4mIiNRRCgZEqpHVYvDB2D5c16spTeIjyPP4eXtOOte9MZ/lO7NrZEw2mxOAgC9fOQNHKKkzEMxbj0EAgEAgUJNDEhERqXbVEgzs3r2bG2+8kaSkJCIiIujatStLliwJnzdNk0cffZTGjRsTERHB4MGD2bRpU6k+srKyGDlyJLGxscTHxzN27Fjy80sXb1q5ciWDBg3C5XKRlpbGM888Ux1vR6RS4iLtPHtdd37+83m8c3NvGsY42bAvj2vfmMfsjftP+XisVgesepzgjLPI/8ABC8ae8jHURiUFxqz2CKzFwYDfNGpySCIiItWuyoOBQ4cOMWDAAOx2O19//TVr167l+eefJyEhIdzmmWee4ZVXXuHNN99k4cKFREVFMWTIENxud7jNyJEjWbNmDTNnzmT69OnMnj2b2247XCwpNzeXiy66iObNm7N06VKeffZZHnvsMd56662qfksiVcJiMbigYzJf3TmQwR0b4Q+a3DFlGfty3Se+uAoZZoDojGlAaJvRwJZ3wV94SsdQG5XMDNj82diM4mBAMwMiIlLHVXkw8I9//IO0tDQmTJjAWWedRcuWLbnoooto3bo1EJoVeOmll3j44Yf5zW9+Q7du3XjvvffYs2cPU6dOBWDdunXMmDGDt99+mz59+jBw4EBeffVVPvroI/bsCe3KMnnyZLxeL++++y6dO3dm2LBh3HXXXbzwwgtV/ZZEqlSjWBf/HNmL7k3jyHP7uf+zlac2UdViJ7b9GBwWMIF9HiiYEhWaIQj6ME2zXi4fCtcZiG2FtSQYUMqAiIjUcVUeDEybNo3evXtz3XXX0ahRI3r27Mm///3v8Pn09HQyMjIYPHhw+FhcXBx9+vRh/vz5AMyfP5/4+Hh69+4dbjN48GAsFgsLFy4Mtzn77LNxOBzhNkOGDGHDhg0cOlT2nu4ej4fc3NxSD5Ga4LBZePa67jhtFmZv3M9L3208tQPo+w7R1+4OP83xw75175L1noOMj5tz6H0HzL+l3N253dkUFdV8peXK8JVUIE45G1v3x4DDswUiIiJ1VZUHA1u3buWNN96gbdu2fPPNN/z+97/nrrvuYtKkSQBkZGQAkJycXOq65OTk8LmMjAwaNWpU6rzNZiMxMbFUm7L6OPI1fm38+PHExcWFH2lpaZV8tyInr11yDM9c2w2A13/YzLIdp7YwmSs6laS2I3AV/xUImOAOglm4k6IAFGyaeNyAwDSDEPQRCPjIytrCoUPp5OTsODWDrwYlMwM2C1gtoWIM2lpURETquioPBoLBIGeccQZPPfUUPXv25LbbbuPWW2/lzTffrOqXqrCHHnqInJyc8GPnzp01PSSp537TowlX9WxC0IQXZ57i2QHAOWgyie1GlapMXKIgAObWiWXmExQWHiTj26HkvO/APedmMEP1EwoK9hMInJ5LjPxH1BkorjkWTioWERGpq6o8GGjcuDGdOnUqdaxjx47s2BH6xDAlJQWAffv2lWqzb9++8LmUlBQyMzNLnff7/WRlZZVqU1YfR77GrzmdTmJjY0s9RGravRe2w2LAz5sO0OLBr/jNa3NYsyfn1A2g/yRi2o6msROibRBrAwPwm7D3yHwCgKCPwvy9ZM++GXP3lxQEIG/rh/BNX1j1OABu96md4agqJcuErJbQ7ABoZkBEROq+Kg8GBgwYwIYNG0od27hxI82bNwegZcuWpKSkMGvWrPD53NxcFi5cSL9+/QDo168f2dnZLF26NNzm+++/JxgM0qdPn3Cb2bNn4/Md/hRy5syZtG/fvtTORSK1XVpiJL8prlQMsGJXDjf8a8GpDQj6TcAY7iW23RiibeCyHj6V4wf/5nfx/DySzEkOsj9JhT1fUbLpZtAMBQ8x+6aB6aegIBPTNHG7c9i/fx35+WUv26ttDi8TMrBajOJjCgZERKRuq/Jg4I9//CMLFizgqaeeYvPmzUyZMoW33nqLO+64AwDDMLjnnnt48sknmTZtGqtWrWLUqFGkpqYydOhQIDSTcPHFF3PrrbeyaNEi5s6dy7hx4xg2bBipqakAjBgxAofDwdixY1mzZg0ff/wxL7/8Mvfee29VvyWRajf+6q7ccV5r+rVKIi0xgnyPn//7YjX788pfJTgQNCn0+k9+EBY79H0HhnmJazeaBDvYiu/43U2uI2/LFPzF98YxNkhygLX4fLwdotvchNUWgd/vITd3F1lZm/H5CikoyCz79WoZX8kyoSNmBvxaJiQiInVclQcDZ555Jl988QUffvghXbp04YknnuCll15i5MiR4TZ//vOfufPOO7nttts488wzyc/PZ8aMGbhcrnCbyZMn06FDBy644AIuvfRSBg4cWKqGQFxcHN9++y3p6en06tWL++67j0cffbRULQKR04XLbuX+IR348La+fP77AVgtBst3ZnPm379j0rxtJ7w+p8jH1W/M48wnv2NnViVrBljsWPpNIGKkl6hrd0OTy8nf9ileV1MAGjhCwYCj9WgaJbYhxQkRsW0w+r9HTEwoWD8yAAgEircrreVKbvxDCcTFMwNaJiQiInWcYZ4O/5euJrm5ucTFxZGTk6P8AalVrn9zPou2Hd6q84ruqTx3XTecNutRbU3T5LeTljBrfegG/M7z23DfRe2rZBwBXyGZ70dR8kfCaHwJjYf8N/TEYg/9118ItsjwNVlZm3G7Sy9xSk7uGqp8XIvd+PZC5mw+wF8viiM1zsrtn2bRLDGC2X8+v6aHJiIiUiEVucet8pkBEam8Pw1pT5P4iPDzL1fsof3DM7j3k+W4faWr4n61am84EAB4d046q3dXTb6B1R5Jg3Y3hp+7Mr+GhbcdDgSgVCAAkJDQmvj45sTFpWGzOQHw+8u/3Kmm+AKaGRARkfpHwYBILXRWy0TmPng+6eMv5W9Xdg4f/3zZbu77ZAU5hT6ueHUOZ/39O8ZN+QWA289uRWqciwJvgGvfnMf36/cdq/sKsQ98n0btRhJlhRgrkD7xuBWKDcMgMrIBUVGNsFpDwUDAV1DrqxqX3PjbrEY4F6IkqVhERKSuUjAgUosZhsGofs159PJOXNIltGXuV6v20uOJb1m1O4fMIxKMf3dOa/7zh/4MatsAty/ImIlLypVvUB62gR8Q1250KLG21ZjSMwPHYbU6YNXjZH/SmIPvOQjMHVUl46kOR84M2Lf+CwC/R1XKRUSkblMwIFLLGYbBmIEteePGXvz1ilAND9MEp83CVT2bYLca3DqoJQlRDhrHRfDvUb0ZflaouvZfp63hjR+3EKyK5S79JsAwb2jHoXKyWSywexoAniBkbXqfwJybKj+WalASDFiNII7M74BQ8nNtn9EQERGpjDLqjopIbXXLgJYM7pjM5sx8uqfFkxjlYPzVXXHaDsf1LruVp67qypb9BSxKz+IfM9aTlhjB5d1SKz+Acs4IlIiISMJnDW1RWhAAXxAObvqAhhYrRv+JlR9PFQrXGbBasadeANvAh6vC71lEROR0opkBkdNMWmIk53VoRGJUaHcel92KYRil2hiGwbujz6RX81ABvvfmbT/l44RQAnJC+zHE2KBBfEssRqiysWfLpFr3iXtJnQG71YK9y58BCBi1ewckERGRylIwIFJHRTtt/HPkGVgtBou2ZVW+/sDJKi5kZrtqK5EtrgMgLwDmgltrZjzHUDIzYLdasFktxce0m5CIiNRtCgZE6rDkWBc90uIBmL/lYM0NpHipTdTAiViM0HKhoi2TYP4tNTemX/EVFx2zW0wcttAKyoDJaVEwTURE5GQpGBCp4/q1SgJg/tYaDAaKWe2RRLe8AQjlEJxom9JTqWQWwDH/Bmyr/3b4uGoNiIhIHaZgQKSO6986FAz8vOlAeMecmhR59gcYkU3xBSHHByz6XU0PCThimZARwLb7P0ccVzAgIiJ1l4IBkTquV4sEEqMcHMj30Pb/vubZb9bXXP4AYMHE5dkFhGYHija9WytmB3wlRccMP44WVx1xvOYDKBERkeqiYECkjnParFzXq2n4+es/bGHQMz+wKD2rZgZksRPXbjTO4r8+BQFqxexAyQyAffC3OM58Pnzc51cwICIidZeCAZF6YMzAlvRsFl/q2LPfrK+x5FhLvwkkjMjBALxB8G+u+dmBktwAu92B1WKleEMhvLVgaZWIiEh1UTAgUg8kx7r44g8D2Pb0Zfzwp3Nx2iws3naIr1dn1NiYLI5Y7M2vAcCbNqxGi3sFgyYlecJ2qw2LxYrDGqrd4PMrZ0BEROouBQMi9UzLBlH87pzWAPz9q3U1unWm86xXocnleLZ9BAvG1tg4jswLsFutGIYFW3hmIFBDoxIREal+CgZE6qHfn9uaSIeV3dlFrNmTW2PjcNpdsHs6niCYW2puqdCROwbZbaFgoGRmwKuZARERqcMUDIjUQy67lUFtGwAwa11mjY3D4UrAmjaUoAnutOE1tlSoVDBgtWIYVmzW0HPlDIiISF2mYECknrqgQzIAkxduJzPPXWPjiOz7OjS5nIKtH9bYUiFP8VIgiwF2q6XUzEBtqM0gIiJSXRQMiNRTl3dvTJtG0WTmeRj1ziKyCrw1Mo5IVzzG7ul4g+D5dc2BoO+ULB3y+IoLjlnBWpxAbLOULBNSMCAiInWXggGReirSYePfo3rTKMbJ+ow8HvjPyhpJJrZa7UQWL8nJOyJX1z/3ZnLed5D7gQNz/phqHUPJUiCH1cAwimcGvHtD51Y/f7xLRURETmsKBkTqsZYNophwy5nYrQYz1+5j6vLdp34QFjvRbUeHaw4U/jyKoN9Nzqb3KAhAvh88mydU6wxBycxAOBgwg9j8B0Pn9vxY4zUQREREqouCAZF6rnNqHHdf0BaAv3y+mo8W7WDL/vxTOgZr37eItoW+zt7yERmftcVzxOocXzXXISiZGbBbCQUDVgcOV2zoXMMLarQGgoiISHVSMCAi/O6c1nRPi6fIF+DBz1dxwfM/8cT0tfhPVfKsxU5M29E4S/4iFe46fO7COXg7P1KtL+/xhdYnOWyhmQEAe2zL0LkW1btESUREpCYpGBARbFYLrwzrQYNoR/jYO3PSuXnCIgo8/qPa53v8vP7DZlbtyqm6QfSbgKvlsNLjMoC5w/FN71ytOw39OmcAwFFcdczjO/r9i4iI1BUKBkQEgOZJUcx54Hy2PHUpb954BpEOK3M3H+RPn64olVgcDJrc/eEvPPvNBoa9NZ8NGXlVNoaIAe9iMcBqQKwNkhxgFO4kaEJgy7vgL6yy1zpS6ZyBUDaz3VocDPgVDIiISN2lYEBEwlx2K1aLwcVdGvP+2LOwWw2+Xp3B/1ZlhNt8tnQXs9aHCpUVeAPc8/HyKtuL32KLoGH70TR0QHR8W6wGWKOaAZDnaMH+96PwzhlVJa91pMM5A2Z4ZsBZXHXM5w8c8zoREZHTnYIBESlTr+aJ/OHcNgA88t/VfL1qL1N/2c0TX60FQnkGCZF21u3NrdJtSa39J2AZ7oUrN8IwL7YLv4cL51CYtw2fCYVb3q/y3X3cxUuBHNmLMBbdBhw5M6BgQERE6i4FAyJyTL8/tzVdm8SRVeDl95OXcc/Hy8lz+zmzRQL3XdSOZ6/tjtVi8Pmy3czbcrDqXrhk9x6LHZvNBRZb+JS/GkoheLyhgmsOw4+xdSIEfTiLcwa8CgZERKQOUzAgIsfksluZcmsfhp+VRlyEnU6NY7nt7FZMGnMWdquFwZ2Sub53UwC+WrW3WsZgtTpg9VPh577U34DFTiDgxe/Nq5JZAndxhOEwvBitx4DFjr14mZBmBkREpC6znbiJiNRnMS4746/uxviru5V5/tKujflw0U5mrM7gL5d2JNpZtX9WHDYn7J4GgAGYHe+nqCiLQ7Nvgd3TiLVBdLsx0Pedk34Nb3GSsLPJYOh7Qejr4pkB5QyIiEhdppkBEamUvq2SaBIfQVaBl9+9v5Rdh6p2xx+7M5YG7W4i2Qn26OYwcyCHfhoVDhCKAsDWdys1Q+AurjNgtx0OZBzFX3t8qj4sIiJ1l4IBEakUu9XC89eHcgfmbD7AJS//zOrdVVh/AHAMfA/rDQVEe7aHDuz5KnzOZ0KBo0WlqgSXLAVy2Q//SXSU7CaU/nG11jgQERGpSQoGRKTS+rZK4r93DKBNo2jy3H4mzttW9S9ii8TVZjSxxR/eWw3CFYtzcrfh/fnGk+7aW1KB2Hr4T6LTagDgCdorPfMgIiJSWykYEJEq0aVJHA9f1hGAhelVuLPQkfpNILrtaBo5oIED4uJaU3zPTsHWySd9w+4unhlw2q3hYy5nBABe00awxehKzTyIiIjUVgoGRKTK9G6RCMDOrCI6PjKDGaszTnDFSeg3AdsIL9bhXmxXbSaxbWhGwB0Ac+HtJ9VlyfahJUuDjvzalzwEf+9XKzloERGR2knBgIhUmWinjR5p8QAU+QLcMWUZu7OLqv6FLPbwJ/X2/u9iMcAE/FsmnNTswOGcgSODgeLdhAJGaAtTERGROkjBgIhUqceu7Mzo/i1IjHIQCJpMmJNevS9osWNrdg0A/mYjT2o5j8cfBErPDJRUIPbnbML/n1QlEYuISJ2kYEBEqlSPtHgeu7Izz14bqkswbcUeTLMaygYfwd77BRiyAF+3J0/qem9xMFDWzIC36BBek9qRRFzTry8iInWOggERqRYD2jTAYbOQmedhy/6Can0tm80Fq5/CP7XlSX2CX9bMgKM4M9nvSMYbpOaSiIM+TNMk76fhFE12wPxbTv0YRESkzlIwICLVwmW30qtZAgDzt1bT7kLFbBYb7J6G/yQ/wT88M3Bk0bHinAEzFCC4/d6qGewRypox8fs9eDyhHIXCn4aTOcnBoVlXk7flIw75wLtlogICERGpMgoGRKTa9G+dBMBnS3cRDFbfUiG7Mw6aXInfhMBJfILvzQnlNTi3vXu4z+KcgYAnP9QmfUqVLtPx+YrYt3cJmZmr8flCVZvd7mwyM1dz8OBG9sy4nOwtH+E3wb1javi6XD+QPlFLhkREpEooGBCRanPDmWlEOays2JnN7ycvxRcIVsvrWCxW7GeMD+UN9HimYhcHfXjcoU/iXQe+C99klxQg89pCAY2vyVVVukwob/YogjPOwv/L/5Gbuzt0LG9P6OSqx0pVWT6SNwj+Fjer7oGIiFQJBQMiUm0axbr4S3Ehsm/W7GPa8j3V9lp2exSsfgrvp40qlDdgGrbwDb8r9fzwTXakI7RkyG1tGAoyOj5AMBiokrH6vXm4t38WerJ7Gh53FgcObMDnKwLTj7F7OgBJDkh1QbITGjnA2fwaGLKAgs6PV8k4REREFAyISLUa2ac5N/drDsDsTfvLfd2Og4W8MmsTOw4Wlqu90+4K3VhXMG8gGPThtTUEwNX9gfDxKGcoV6DAE8C69mn4pi++eaPLPf7jKXTnQpPLcVnA1uwqMGx4vaHlSLFxzWnUYTQNHeBsPRqGFRdYG+EleuAEMGwUFOwPLy0SERGpDAUDIlLtLu3aGICfNx04Zu5AMGjyx4+Xc/2/5lPo9fPg5yt5YeZGznnuB/bmFB3VdvzX6+g3fhaz1u0DwBmRBE2uxBesWN5AIODD4w+NyXXEbkLRztDMQIHXj2P3VAA8Wz6o9Fp90zQpWjgOdk8notVwYge+i8MRRXR0Mo0adSE6OgVr/wnYR3ih34TDBdYsdpzOGCIiQknZhYXVm5QtUq8d+Xuu/Byp4xQMiEi1O6N5AjFOG1kFXhamZ5XZ5tOlO/nil90sSs/i3TnpzNsSutk1TZixOgOvP8iyHYcwTZNv1+7jXz9tZW+Om7d/DiX/Wiw27NbipT0+d4VmBgp9oWCgZDYg9HWor6AJweajAPCkDq30Wn2vO4vAzqlYDHDt/BCXI4oGDToQG9sUm815uOExXiciIrSkye0+VO31G0TqG7/fQ/YP1+Od4oAFY8n9cRjZ7zswq2hWUKQ2UjAgItXObrVwWbfQ7MCbP23hHzPW89/lu8M3sxk5bp763/pw++e+3Vjq+p827ueVWZu4+p/zePrr9Sw4YqvSpdsPUej1Q9BHxJ7PAcjZ8tHh/4GfICjw+70UFQcDJbMBAJEOK4ZR3OaMf0KTy/HtnEpgXuW29Syc/3sAIixgtB5T4eDC6YzFYrERCPjwevNOagymabJ1f76CCZFfyc1OpzD9Uw54wbP5XfK3fkxhALI3TdKWvlJnKRgQkVPiut5NgdCN/Rs/buHuj5bz4syNPDZtDUNemk1OkY+mCREkRIZuji0G3DO4LQALth7ktR82A/Cv2VuZsmhHuF9vIBiabbDYiWpzM47iv2qFATiwcRK+4k/4jqXA46Fk5VLUEcGAYRhEFScRF3p8OPaGkno9Wyae9LKBoN+Ne9unAERYgbPerHAfhmGElwoVFZU9y3I8gaDJuA9/4fznf+LJr9ZV+HqRuioQ8OJeen/4eY4PSL0EgKIAuDdP1JIhqZMUDIjIKXFGswQu6pRc6tgr329m4rxt5BT5aNUwigmjz2Tug+fzn9/3Y8FDF3D3BW1JjnXi9pXekrSkSNjANg0A+HnjAQCM/hNJancz8XYwAF8QsnwQ2HLshOK8xQ+HrsUk0mEtda7keYHPwNliGACeILDodxX/BgR9uL35mJFp2AxwxLY96SVHERGJQCgY8Ps95Xrtkvf/1uytfLVyLwDvzEln5a7skxqDSF3jdWdD8U5eAP6IprDna4onCMn1gzm/4hXORWo7BQMickoYhsGz13VndP8WTBpzFoM7NgLAajF47rrufHvP2bRNjiHSYaNX80QaxbowDINBbRuG+0hLjAgv3emQEsPws5oB8PMRuxQZ/ScSOdJLo3Y3YjcgYELBsXYEDfrI3fEdAJGWIgzTX+p0OInY48fZ959AaJ//4+5WVMZx7883UvCBg/w5Y6BwJ5FWIH/TSX/K6HBE43TGYpom+fkZx22b/9MI9k1ykP2+g0M/3c6LMzeUOj9jdfVt9ypyOvEHA9DkytDNf+plULgLgAaO0IcLfhMObnofc86NNTlMkSqnYEBETpm4CDuPXdmZc9o15K2bejP5t334/Pf9ubZXU2zWsv8cDWrbIPz1Szf05B9Xd+P2s1vx3pizGNAmCYsBmzLzS+84ZLFjHfg+Ua1Cn+b7mlxT5qfwpmEjN+liAKIdHNUm6ogdhWyOGGhyJQETzJa3lNlfwU8jcE92lFpb7J49ggObJpPjB/+uL7EYhIKBVhXPFzhSdHRolsXjyTlmm6DfTe6WDwmYoWVT36zciDdg0sqxjf9LfhGAn9YrGBAB8Pvd0OUvRAzdRMmnDk4L2C2Q2OZ6LEbow4CszZMx/9umhkcrUnVsJ24iIlL1LBaDAW0anLDdkM4pXNa1Md2axtGreQK9mieUOt+lSRwrd+WwKD2L3/RoUuqcvf+70OYevBiYpolRMq1QzO8voiDtt7A4i6iYhvxaye5C+Z4AFosNS/fHCXb5C/5GXfn1bbyn6CA5Wz4EIHbTRKIB+rxFwdYPw20MIN4Wyoc4mXyBIzkcMRiGhUDAR27ubmJjmxzVJmCa0ORK2D0NgO9zewEwIGox/aN/gX2wNsPDnqwsUhMTKzUekdOZaZp4F98Du6bhajMcR+Z0/DaItAAtR+PsN4FELBzc/BGeILhztxDhLwRbZE0PXaTSNDMgIrWay27l9ZFncPs5rcs8f2aL0E3s4m1HJ9PabC4sa8ZjftMH/9xRR533evMp3DQFgGjfrqPOH7lMqKQ/DFuZ6/SLPPmhpQVAfgDMrRMJBv14G18BQGJ8Sxo6wFUFswIQWnbldMaGXi8/o8zlQoGAB7o+iu2SxViwsKjwDAAuiV9C56gsOscewAQ+X7KlUmMROd3l/ngDgV3TMAD7zg+JbDOaWBvYWo8O1fsAHGd/SFRsCwAO2dPwBKqmIrlITVMwICKntTNbhGYKlmw7dNQ5w/Tj2PNfAHI3f0Bw7s0U5O2mMHcHRQWZFOZnULB/FQDR/h1HreGPOioYCNUB8LuPDjzci+6GPV+BNZKgCXmOFmTMuh5zd2hpkCv1PGwjvDDMC33fqZL3HheXFt5ZKC9vD/5fbTXq8+QCYHclsif5HrIDccRY8jmzy1kwzMs1g/oD8L81h/D5Shd2E6kvAr4CCtNDu3zF2cHaanQoABjmDQcCJSJ+swYunANnf0Fu7tEfIIicjhQMiMhprVfz0MzAhn154Zv2MIud2DY3YhDaBShjw3vkfNqU7M+ac+jjZHw/XEZhMAKAqOiGx8wZyD9yZmD2VRRMbUNgattw8BDwFRLcFQo6oo3C0DV528I7kzgthJKOi8dUVaxWBwkJrXC54jFX/o1DU2IJzrkJgIIfh5H3n+aw6jGsVgc/OW4HYFCn1tgHvAsWOxd1CS0t2rDfR3bu3iobl8jpxOPJwwQcluJ8nj5vhU6U8btqt0cSl9gOAJ+vkOzs7arXIac9BQMiclprGOMkMcqBaUL6gYKjztsGvk90q+tLHQtnDhTuwk8oGIhO6XXUtVHFW4sWekPLASLsEViKdhI0YV/WZrLec2DOH0PADEKTK7EaEBPbGvsRqQnRVoi1USVLg44lNjoZy55p+IKwf9MHHHwvipytH4dO7p6OueR+/rMs9Cnm+R1Twtc1iY8gxmUlEIT1uw9gmsGyuhep00p2EbIblOv3NCqqYXiJXmHhAfLylIQvpzcFAyJy2mvTMBqALfvzyzwfPeg9nBZwWSDZCY1doRv0OBvhYCDKdfQNwK9nBqzOOBLjD+cuuINQtHkCAV9BaG3+5asxhm6mQfubSbBDQwfEthuNdXjVLQ0qi80RTVKbEViLt1L1+AtLnf9ydRa7DhWREGnn8uJK0BDKO+iYEgfApgNe3O5j70wkUlf5/e7Q7+/Vu8r9e5qQ0JLIyNAGCIWFBzQ7IKc1BQMictpr3SgKgM2ZZQcDhtVJUocxJDqK1wNfX0B029FE2aAgpjdQuvpwiZIE4jz34eVHjt+sw37EX858P/iX3AOA1R4ah9F/IhEjvdhHFK85LueMgD8Q5McNmeS5K15/wD5oMg3iWxF1RN00lwXyzWQez7gDgFvPboXLXrqwWofGMQBsOeDH6y37+ydSl/m9eWD6sdqjy32NxWIjLq4ZFosttFHAr/J1RE4nCgZE5LTX+gQzA0DoE7+ShEBbZDhBsCDxAgCiHUcHA8mxLgAyflXDILHdaJIcoS1C/SYUbv0IAm6sVmepdhVdFvSXL1YxesJihrw4m4VbD+ILVGzZjvWqLcS1G0WqC1KSWpPogK+t9+INWjmzRQK/O/voHZnaJoeCgW1Zfny+wqPOi9Rl7p9vxP+/nvBNX2zL7q7QtYZh4HLFh/pxZ1f94EROEQUDInLaa90oFAwca2Yg7Nc35xZ7eAlQWTMDTRJCS4h2Hyq90461/wScI7xEtAjlIgRMYOZAbL/cfxKjD/llxyE+WRJa178nx80Nby2g/cNfM/7rdRVbgtBvEgzzYvnNZhjmZXpWHwCu752GxWIc1bxZYmif9Iy8gIIBqV+CPnI3TwZCSf62bZMqXBW8ZDevoqJDWiokpy0FAyJy2ivJGdh2oBB/BT9NP1ToBSA+8uhP8ZvEh4KBjFz30f1a7EQNeIcjb6/tOyZX+GaixKx1mQCc274hF3RoBEDQhH/9tJWpy3dXrLPioGfHIR+bMvOxWQwu6pxSZtOmxQHP3twAwWBAW4xKveEL+PGnXokBJNg5qSR/hyMGi8VavFRIy+zk9KRgQEROe03iI3DaLHgDQXYdqtjN7L7cUAGxlOIlQUdqGO3EYbUQNEMBwa/ZbE4S7KEtCZPsxQWKTnLHoDmbDwBwebdU3hl9JlueupRx57UB4MOFO0+qz5837wfgjGYJxEWUPa6SgKfQZ5LrNjl4cIMCAqkX3O5QbRKnBSytRp9Ukr+WCkldoGBARE57FotBq4blXCr0K/uKb/IblREMWCwGjeNDx3+9VCjUwI6r7RgaOMDZZvRRBYrKK6fIx8pd2QAMaJMEgNViMKJPMwAWb88iI+foYOREftwQCgYGtW1wzDYuu5VGMaFch715odmBnJwdFX4tkdONu3A/7J4WqgqePvGkZ/VKggGPR7txyemp2oOBp59+GsMwuOeee8LH3G43d9xxB0lJSURHR3PNNdewb9++Utft2LGDyy67jMjISBo1asT999+P31+6oNCPP/7IGWecgdPppE2bNkycOLG6346I1FKtG4Z28jluEvGvFHr94Z2CkmOdZbYp+eR8T84xPi0/MjH5JC3YepCgGXoPjeMiwsdT4yPo3TwB04T35m+rUJ/r9uby3brQ39XBnZKP27ZkqdAhTyigCgQ8FXotkdON252Db/nDGIR23apMHRB78S5ifr+namt1nGRwIlJR1RoMLF68mH/9619069at1PE//vGPfPnll3z66af89NNP7Nmzh6uvvjp8PhAIcNlll+H1epk3bx6TJk1i4sSJPProo+E26enpXHbZZZx33nksX76ce+65h9/+9rd888031fmWRKSWalOcRLxxX/mDgcziJUKRDmt4G9FfS0sIJdim7z+6oFlYJYuJzS1eIjSwzdGf4N9+TmgHoAlzt7E5s/zbF772/WZMEy7r2piOjWOP27Zp8XvcXxQKiAIBn5IhpU7LnT0Kdk8nyhraFYyz3jzpvqxWOxZL6O+H31/xGbyy5P00HM9kBywYWyX9iRxPtQUD+fn5jBw5kn//+98kJCSEj+fk5PDOO+/wwgsvcP7559OrVy8mTJjAvHnzWLBgAQDffvsta9eu5YMPPqBHjx5ccsklPPHEE7z++ut4vaFkvzfffJOWLVvy/PPP07FjR8aNG8e1117Liy++eMwxeTwecnNzSz1EpG7o2iRUPOuXHYfKfU1mXigYSI51YRhH77QD0Ck1dCO9anf1LAFw+wJ8tzb0Cf6AMoKBwR0b0bdVIkW+AL/7YFm5thv9cNEOvlq1F4A7ivMOjqdkZmB3tif8fQgG/ce7ROS0ZJpBDn53Nf5d0zCAaBvQcvQxA/r/Lt/N41+uZfUJfv/t9ggw/Xjd5f/7cyzuwv3kbfmIgz5g67uaIZBqV23BwB133MFll13G4MGDSx1funQpPp+v1PEOHTrQrFkz5s+fD8D8+fPp2rUrycmHp7aHDBlCbm4ua9asCbf5dd9DhgwJ91GW8ePHExcXF36kpaVV+n2KSO3Qu3kiAFsPFHAwv3zLXEryBRrGlL1ECKBr01CQsWp37nE/LS/yBvjrf1fz6ZLyJ/uapsnfv1rHnhw3KbEuBrVteFQbwzB4fcQZJEU52JyZz4eLjr+ef+n2LB76fBUAZ7ZICAczx5NWvL3o7uwiLMU3RYGAt9zvQ+R0UVSwD8+OL4DixOHo1kct8Zu2Yg9/+3IN2w4UcM/Hy3l3bjq/+2DpcQNx+6pH4Zu+5H7alMDcUZUaoz8YhCZXhp5UYvmSSHlVSzDw0UcfsWzZMsaPH3/UuYyMDBwOB/Hx8aWOJycnk5GREW5zZCBQcr7k3PHa5ObmUlRU9trehx56iJycnPBj586T26FDRGqfuEg77YsLaC3eVr5P50qCgeQykodLdGoci9VicCDfE955qCx/+WIVk+Zv5/7PVrJmz/E/RXT7Anzxyy5uemcR7y/YDsDfftOZCIe1zPZJ0U7uuqAtAE/9bx3r9h57VvONH7cA0KphFC/e0OO44yhRMjOw61AhVmvoxiOoTyOljgkEvOTN/0P4eawNKNhS6pP3iXPTuevDX5gwdxs3T1hESfy/61ARQ1+fy5cr9hzdcdBH9O6PsRlgAvmb34f5t1RusF0fhSELTmqHI5GKqvJgYOfOndx9991MnjwZl+vY/4OtCU6nk9jY2FIPEak7+rUO7cQzbUX59uVfvjMbOJx8XBaX3UqHlJjj9rsv180Xvxw+9+w3G8ps5wsEeXjqKjo8MoM/frwivJ3oXy7twJBj1AEocWPf5pzdriFuX5Db3l9S5q5JS7cf4rt1mRgG/HtU73AuwImUtNuZdXhmIDt7G0VFWdpmVOqM3OxtBHZOxWJAihNsv0ocXr4zm7//b124/faDoSJ8vZqHljqv2ZPLg/9ZSaH3V0voLHYsrccQV/wBfmEAAlsnVn55j2FT7o6cElUeDCxdupTMzEzOOOMMbDYbNpuNn376iVdeeQWbzUZycjJer5fs7OxS1+3bt4+UlND/DFNSUo7aXajk+YnaxMbGEhERgYjUP8PPCm3F+b9VGbz989bjbsdpmibztxwEoH/rY2+9CXBz/xYAvDV7K25f4KjzJQnAsa5QEuFPG/ez61DoRuLrVXu58IWfePab9YyesIgPFpRe5tM8KZJbBrQ84XuzWgxeGdaDpgkR7Mwq4po35nHgiOVQpmnyVPGNzPW90mhdvNVqeaQWb59a5AuQ6wnNTgSDAQ4dSufAgXV4PMqvktOf1++BJlcSbwNL6zGhXcCO+OT9z5+twBcw6d08odR1E285k//eMQCAAm+Ar1buJRj81U1633dwjvDiaDYUk1BAwKLfVXrMVbo7kcgxVHkwcMEFF7Bq1SqWL18efvTu3ZuRI0eGv7bb7cyaNSt8zYYNG9ixYwf9+vUDoF+/fqxatYrMzMxwm5kzZxIbG0unTp3CbY7so6RNSR8iUv+0T4nh/OLqvU9+tY6r/jmXPHfZn86t3ZvLwQIvEXYrPdLij9vvVT2b0DjOxYF8b3i7zl2HCrn3k+VMWbgj/An/iD7NGdAmCbO4crDbF+DRaWvYlJnP6z9sYe7mg7jsFl4fcQab/n4J747uzQdj+2C3lu9PcXykg09u70erhlHkFPnCS4K8/iAP/GclS7cfIsJu5d6L2pWrvxJOmzW8tep+dyQOx+GZEtM0OXhwE4cOpWuWQE47waCfnJwd5OfvC+XBdH0U5wh3KAg4Yi3+joOFbNwXqtb9zs1n8tAlHQC4vndTYlx2uqfFc/+Q9gDc/9lKWv3lf7w7J730i1nsRPUL7UrkDlCJ5N/DgYaCATkVqjwYiImJoUuXLqUeUVFRJCUl0aVLF+Li4hg7diz33nsvP/zwA0uXLuWWW26hX79+9O3bF4CLLrqITp06cdNNN7FixQq++eYbHn74Ye644w6cztD/sH73u9+xdetW/vznP7N+/Xr++c9/8sknn/DHP/6xqt+SiJxGXhrWg3PahRJx9+a4ueej5eR7jt4Z518/bQXg7HYNcNiO/6fQbrVwzRlNAfhs6S78gSDXvzmfz5ft5i9frOLzZaElQgPbNAjv3vP+gu2c99yP7C/esWhAmySu6J7K578fwGXdGmO3Wji/Q3I4ebe8UuMjeOyKzuHX2JNdxNtztvLJkl0A3HlBm+PmQBxL+5TQssmNmUU0aNCBRo26kJR0OKgoKsriwIH1eIoOhm5wlFMgp4H8/H0UFOwnNzf0+2G3R2JYD28YYJom/kCQuVtCAX3PZvHERdq5/ZzWTL9zII//pku47S0DWpCWeHjlwePT1x61jMcZkQSRafhMCES1Oank32Dw8OyjaR49EylS1WqkAvGLL77I5ZdfzjXXXMPZZ59NSkoKn3/+efi81Wpl+vTpWK1W+vXrx4033sioUaN4/PHHw21atmzJV199xcyZM+nevTvPP/88b7/9NkOGDKmJtyQitUSsy86kMWcx+bd9sFoMZq3P5HfvLyWnMHTzuj/Pw2PT1jCtOBGwJDH3RK7pFQoGZm/cz9erM9jzqyVIMS4bfVol0r91A4afFdqpbG+Omwi7lbdH9Wbyb/vy6vCe5drd50QGtW1An5aJeP1B/vblGt74ITRD8OAlHfh9cV2CiupSPK7Vu0NLgmw2J05nDDExqeE25srHOPhhAzImOcj7wIE5b3TohAIDqaW83tK1OVyuuFLPn/rfOro89g1PTl8LlN7et0uTOFz2w0n9kQ4b79x8ZrhiN8AVr80ptXTQgondHdqcxJO7+aR+N46cDdDMgJwKhlmPs1Nyc3OJi4sjJydHycQiddDCrQe56d1FeP1BGsU4eW/sWfzu/aVsK04MHHdeG/5UPPVfHte9Oa/UTkWtGkSx9UCoGNl1vZry7HXdgeJ8hK0H2X2oiIFtG5SqKlxVlmzL4to3D2+l3Dk1li/HDcRiKbtewon8b9Ve/jB5Gd2axjFt3MBS50wziBnwkjM5gqIjPqiMtIIZ0Yxg4Q4S29+C0e/dk3ptkeoQDAbYt29FqU/vGzXqjM0WmjnbfrCAc579sdQ13917TriA4bGYpskdU5bxv1Wh3Q1H92/BY1d2Dp/P/XEY+Vs/JqL5NSRc8FmFx52dvY3CwlA+U4MG7XE4yp//I1KiIve4NTIzICJyKvRplcRrw3sSYbeSmefh4pd+ZtvBQpKiHLx0Qw/uq+Da+pIE5RJ3XtCGSWPO4oIOjUoV9zIMg/6tG3Bd77RqCQQAerdIZHDHRuHnf7m040kHAnC4aNvaPbms3VM6YdgwLFhsLhLajSbqiN1PCwNQlL8DTxC8WyZohkBqFZ+vANM0sdmcxMc3Jz6+eTgQgNCSvyP1aZl4wkAAQr/fz1zbnXHFv/MfL95Zaimis9+/ocnleHb8h+C8mys87iNnA45cMiRSXWw1PQARkep0UecU3h19JsP/Hapw3rZRNK+NOIP2xduFVsRVPZuwOTOfd+akc1m3xlzWNRWHzRLOUTjVXrihBz+sz6RRjCu8rerJSkuMZHDHZL5bt4+HPl/J1DsGHF2Vud8E4oC49Im4nc0pyNuOp/i+xZ92PU4VR5JaxOMJLRFyOGKIjDx6x7AfNoQ2KXniN51pnhRF5wos4Yt22rjvonb8b/Vetu4v4OtVe7mud2h5oMPmxLZnOn4T8je9R6xhOaqw2fGUzhnQMiGpflompGVCIvXCrHX7CARNzu/QCFs5d+85FtM0j75RrgP253kY+I/v8fiDTLm1z7G3XA36QomR09qSe2gz+Y6mRF06j7g4VXWX2mP//nX4fIXEx7cgMrJ0sJyZ6+asp0I7Ei7+v8HHrUJ+PC98u4FXvt/Mld1TeWV4z/Bxz88jObhpCgaQ7ATLcG+5k4kPHNiA1xuqI1LW2EXKQ8uERER+5YKOyVzUOaXSgQBQJwMBgIYxTq4tTpT+cNFxKrSX3NRcuQnbVdvhnKn4/ceo6aClQ1IDfL4ifL5CDMPA6Tz6RujHDfsB6N407qQDAYD+xQnH87YcLJWb4BwwEYcltEloUQVX+phmAEz/4a9FqpmCARERCStZ6vDd2n3M3ri/zErHR7K5EgGOCgZ8viKyf7ienPcdBOb+at10cYBgBjyYAW/pgKGCwUMw6KeoIDN0I6bAQ4oVFYUScF2ueKzWoz+R/359aInQue0bHXWuIno2iyfCbuVAvodlOw5vLoDFjqvlcADcTa6p0Baj5vKH4Zu+sOpxzIDnxBeIVJJyBkREJKx70ziaJUayI6uQUe8uwmLA01d34/ozy14CZLO5MAyDQMBLQUEmUVGNCAS8HNy/hmD6pwB4N75HQ4sF3xkvc/DHG3FmfEkgohne/FA15kgrRLW+kUKfB9/2T4ltPRL7wPfxeXKwWu34/Z7QPvEWG3FxzSkqysLrzQvtcrTiEQI7p0JkU6I8u4hpOwpL/0mn6tsltZTXG9rly+mMO/qcPxguFHheh8oFA06blcu6NeazpbuYvGAHvZonhs+5BrxLbpu78VrsBAJerFbHiTsM+jB3fRH6evc0glOnQbsxpSoli1Q1zQyIiEiYYRiltlsNmvDn/6xkysIdBINHp5hZLDZiY0NLi3JydpKVtZmDBzcSxMDS9EoAfCbkbpzIgclxBHd/SVGAcCAAoV2J9m/8gIL0T/EG4eCmyWR/1pIDUxLY9340Bz9MwvdVd3zLHuLAgfUUFGTi8xXh9xWEAgGAwl0UBCB303sw72YVRqvn/P5QtWy7vXRRP38gyG3vLyHf4ycpykG3JkcHCxV1Y9/mAExftZdDBd7wcZvNhcMZh2ma4aJnJ2SxYzb5TfipaVKJSsYi5fP/7N13eFRV4sbx79RMei+EUAKhSi/SRVcU7KirgigiKLsrrJ1Vd1fW36prd9fuuquACrZVsaNIVaogvZfQCQmk9yn398ckAyMBKSETMu/nefJI7j1z59xDMPed0xQGRETEz5WdU3nlxm789bJ2hNm9a4n++dM1vDR7a43lw8ISfZ96lpcX4HJVYDZbSfjNh4Q3/y0AxW7v+OlqZhMk2CHe7v0zgL3qN5IBlBXtPPqN9n4OhguTyeTbPMoERFnBUfXaUjfs3/g2OW/bqZxmh8VjTqcpjqmyspjS0oNa+rEeKi8vwONxYzKZ/ZYSBXht7jbffIGBbRJPazneap3TounQOIpKl4ePlvvPtYmK8vaoVa9sdEI6PQKDF0Njb5imxehT2slY5EQpDIiIyFEu69SI2wa04K4jdmh+ec4WSitdR5U1mUzExDTzOxYbm47VGkJEv/9grXreCrV4H/4T7JBsB3vLUYS0HEWS3bviSoId4o545rGboVHV8ZQQiMm4kbDwFOLj2xAXl0F8QjsS2owkwgpxdsDi3dPBAJweyHOCZ1vtf6rqdJZy8OAm8vN3UlS0F6ezjKKifZSWHiSIF+gLOJergpycDeTmekNrSEik32T/dfsKeGHWFgDaN4ri3otObp+RYzGZTNzUy/vz/4+vN/LX6WtwV/Wi2WxhmEwmPB4XLteJjf83DANMVug4Ea7cqiFCcsZpzoCIiBzT7wa25Ja+zbng2bnsLyhn5e78GpccDQmJIjW1e9VYbcO3a6olJIak+FZ4irZgjsiAK9YfflHVp53mXm/4Djk8TiKmhWMYEGEFU/pI7L3/C0CY2caRgz5CQqKg3xTo81/wOImYGk4x3jkIFR5wG1DqSCei+lPV6iVRT4LH46Ki7BAORwwmi3fVmSM/5S0pyaGkJMf3vdNZSnR006OuI2deaWkOTqd3d/Hw8EQiI1P9zr86dxsuj8Hgc5J5/abutboq2JVdUnn86w0Ulbt4d/EumsSG8buBLTGZTFitoTidpTidpVitJ7Jy0eFAaZj0mCZnnnoGRETkuBw2C92bxQKwfEfeccva7eG+IOBz5WbMN5TAVVu8D+PVX9WOPGYNI6r1aKJtYGkxCvpOObr8L1W9LrL1rSTaIabVSCKqdkouK8oEj5OKH26k6F07xqLRJ3zfbreT7O9/S94HKeS/64DFYzDcFZQW7fYt/eirgtn70FZSkoP7lyskSZ0oLy8AICamGdHRTX1/J+D9tH3Jdu8KQ7cNaFHrywOH2a28cXMP3zKlX63Z7ztX/e+hoqLghK7l37ukniY58xQGRETkV/WoCgOLMw+d2gWsYb9eplrvN2FY5Unt2gpg6vMWthsroe8UQjNGAd7hQvveiebQlvcockHZ1knHfVB3Ost8K9GUlWTh2fOZ989u2Lf+LfZPceD6pid825uwTU9jMpkwmcwkJrbzPfQdmn09Re/aKZk7DFfV5lGlpQfZv38F+fk7T3i4iJy4oqL9uFzlVfNJYn3HK10ePl6+h5935XGwuBK71UyntNOfNFyTPi3j+WJ8fwDW7C0gv9Q7mTg01Fuf8vL8k95RWMPOpC4oDIiIyK8aWLUe+6Jth9ibX3bm3/BUJ0xWDz3q/YZvUjHuw/UtdEHxvBG4q4aTAL7VXrKyVpGTs56DBzdSXp5PWUUxNL68xrexmiB634ckJbQhKekcLBa7d1Lzmkdw7f6MIhcUbP+AQ1MjcS8cRUHBbgzDQ2npQbKz11JQsKvG68rJKyraT1HRPgAiIxtjNlt8516YtZn7PlrFta8tAqBb0xhCrJYar1MbUqIdZCRFYBiwNDMX8PYMWCx2PB43xcVZx329Hv4lEBQGRETkV6UnhNOnRTweAyZOX0u5s56vomO2EdNqJDYzWEwQWTVixGNAYeZHHHo3HM+iWwEoL8+juPgAHs/hoT+5udu8O9h2+j+SWo3AUjWqJNwCSXZItIOp5WgstnDfSkqhIZGY932JzeSdtwDeeQsHNk7BcHnDR3XZkpIcior2U1FR5BvnLifHG+L2+oJAVFQaERHJvvOllS7emL/d7zWXdmx0xuvVOS0GgPX7C33Hqpff9f6cHe/fzi/DgMKBnHkKAyIickLuHtQKu9XMrI3ZjJnyk2/FlPrK3G8KiW1GkRwCkRkjiW15g++cy4CyLZPBVUpZWV7VkqVmwsLisdlCfeUiIhphHfAuSW1uISUEoluPwjqsBNPwyqNWebHYwklpN5rEEIix+a+MxMz+xGx9nuTkjoSERAJQVLSPQ4c2k5OzgdLS4wy/0vyDGhUV7fV90h4Z2cgvCAAsyczF6T78M2q3mrmsDsJA+9QoANbvOxwGQkNjsdlCq3qHco710qN6BtRTIHVBYUBERE5IrxbxvD36XEJtFhZsPcTyncefTFwv9JnknX/QdwqhA98nOa6lr5egwJ5G0bRwKr47H77tTcL2fxET05z4+DZERzchLq4lkZHeh0dT38mYh1fNY7CGHXsYU/V8h2GVOFqOJNrq3QvBbALH7mngcRIT05zQ0Di/Say/nFxqGAYVZbkc+v5aCt6xYywcVfttcxYzDMMXoKKi0o5aOQhgyXbvMJ3re6Tx8R/68MHY3sRHnMhqPqenfSNvGFh3RBgACA/3hpWiov1+vVD+1DMgdU9hQERETljvFvFc0jEFgA9+2v0rpeuJIx7cLUO3Enp9LqReBqV7KHKBUboHhxlsO98GjxOz2UJ4eBIOR8wxr/Or72e2Qd8phLcaRVKId1iRuaV38yiLxU5sbDopKV0JD08E8E1arpY3+3oOvRdPxa5PqnZWngJVw5qCmctVQW7uVnJy1uPxuHx/VzVZWjXZ/dz0eLo3i6Nr09gay9W2cxpHYbOY2Jtfxrp9h0NeWFg8VqsDw/AccxMy9QxIICgMiIjISRlyjjcMfPzzHq546Ue+W3f8SZH1jdUeQXT2V77vLSaItgHpI2t/p9c+k7AMr8RSw7Aik8lEVFQaJpMJt7vSN3egvDSH8p3/8ytb4oaKbZMPDxmq+q9heDDclbVXX4+zXg9LKiraV7XLdTkA4eFJNS4TWlbpZvUe74N4r/S4Oq1jlMPGxVX/Rv722Tq/+TXVQ8Qqq1aZOpoe/qXuKQyIiMhJubBdMjf28m6stWZvAWPfWc7CrQcDXKuTYLYR3nq0dw6AI5wEO1giMqDPlDP2fscKGSaTmZAQ71KX+fk7MAyD8vJ8wDtZuVEI2Kp+U+dWQsWPIymccz2F79px/XgzB2ZezaF3Qry9BqfxEG8YBnmzryPnbTsl79pxL7ildkNGLfB4XJSXe4emRUWlkZDQtsbhQQArduXh8hg0inaQFhtaY5kz6ffntcRuMbNsZx7vLt7pO169/KzTWXKsl/6CwoGceQoDIiJyUixmE/+4uiN/vayd79g7Rzzw1LX80kp2557kijy938Q8vJLwG4uxVG+IFiAxMc0wm604nWXeT74rS6DxlTjMYGoxirhWIwkxex8LD219n+LMjyh2Qfbmd/Hs+ZxKDxzYOJmSd+2weMzhC59gOHC5KjiwfxllO/6H0wMFLjiw6W1y3g7B/ePNZ+amT0FZWS6GYWCzhRIRkYzdHn7MsourlvU8Nz2u1jcYOxEd06KZMLgN4L8Bmc3m3W/D6ax5eV4NE5JAUBgQEZFTctuAFnx793kAfLf+AFkF5b5zOUUVrNydf8br4HR7uObVhQx4eg49H/+e6Sv24jnRVY6qP60/mQ3RTtAnP+/h3/O2UVh++IF8wdaD3DZlGX2emMUb87cdrobZSkSEd1hJcXGWd+nJjhOxDS/zDjPqN4WYjBHHfT+34X2Iz934FiV5W8mf/VvKp/4iHBxDUdFePJih8eVYTN4Jz+BdcenQlnfxfJZx8g1wBpSWenufwsISjlnm+/UHGDP5J6Yt8YbTfi2PXfZMu6pLKiYTrNiVz5686qVlvROYDcOD211TWNMEYql7CgMiInLK2qREcm7zONwegwc/Wc3CrQeZuf4AfZ+cxdBXFvCPrzfwn/nb2XGwhHKnm+e+28S367IwDINX5mxlwNOz+WKVd5343bmlvPVjJnklxx6e4vEYvL1oB3e+t4L9BWV8sWof2w96h1zkFFVw9wcrafvwDF6Zs7XOlj7NL61k9sYDVLi8Y8PX7yvk3g9X8cQ3G/n9O8sB+GLVPm55aynfbzjA/oJy/jlzi2+HWoCIiGRiYpphtToACA2Nw1z1ZwBL/3f9NkCz2moOMOUeKPi0FaU7PibfBZ5tbx23h8AwDCoqvKvehPR4jqQ2t5Boh1ibdy6Fy4Cygm3gCuxeCCUl2TjL8zCZzISGxtdYprDcyW1vL2PWxmwOFldiNsGF7WqeXFwXkqIcvvkKX1f1DphMJt9eE2730TtRq2dAAsEa6AqIiMjZbVS/5izdkcvcTTnM3eS/hnr1pk+TFmQytGtjXp3r/UT8gjaJzKkq+/Bna2nXKIqRby5hX0E5kxfuYNKtPZmxNovSShdDuzSmRWIEJmDKoh383xfrAdiZW+oLDt2axvDzrnwAKt0envl2EwVlTv58aTtOR1mlG5vFhNViJq+kkkkLd3B9jzTSYr0P4yt25THyzaUUVbj4bfc0/u/Kc/jH1xt8r1+47RDPz9zMi7O8w5AubJvE7rxSNh8o5rIXfyTEaubKLqncdWErwsISCAtLwDCMGoe2mE0WPICl8RXE5nxBiaVqM7XmIzHteJs8p/dzZBPeh3i3AWWO5oQfY76C211JXl4mHo8bs9lKXFwrTH0nY+39H6yA+9PWFBbsoNwD4cv+eNQE6LpgGB6KCnZRPGMAlO7BEdkc83WZNZb9bMVev+/7t0qsk6VEj+eyTqks3p7LV2uyGHteSwCs1hDc7kpclcW+OQSH6eFf6p7JCOLYWVhYSHR0NAUFBURFRQW6OiIiZyXDMHh70U7+9vk637Hm8WE0jQ9n/uZjb7B0MkwmcFgtlNWw83FCRAhzJ5zPvE05vDhrC8nRDuZvziEpMoQlf77wlMeMbzlQxNWvLqR3i3j+e0sP7v9oFf9bvofGMaHcPagVH/+8h8VVa9n/kt1iJj0hnE0HDi8heUOPJjx+dQcWbjvErZP9N2177rrOXNs97diV8TipnGan0AXRVrC1HAWZk6HFaO9DuscJS38P298CoMjl/QqzQMzNlf4TmD1OMNvIydngW8EoIiLZt0tuNbezhAPveB9WG4Xg3Wittldb+hWHZv2Wip0fA969GhJsYB1WUuPQrvHTfubL1d5P4K/u2pi/XtYu4GEgu6icXv+YhWHAwgd/Q2pMKPn5OyldcieRBz4nsvVov5BVWVnCwYMbfd/bbKEkJrYPRNXlLHcyz7gaJiQiIqfFZDJxS9/mzJtwvu/Yo0M78Pboc9n+j0uZdd9AEqoeykJtFtokR/rK3X9xa9+f48Pt/Pvm7jiqls+JDbPRKS0au9WMYeALAgkRdu44v6XvdQ9d0paIECuXdWrEt/ecxxs3d8duNZNdVOEbQnQqnvtuM8UVLr7fcIDPV+3jf8v3ALA3v4wJ/1vtCwIJEXYu6ZDie11CRAjvje3Fqzd18x1rFh/G/111DlaLmfNaJ/LB2N6MvyCDFoneSbAf/7zn+JUx27BnjCbBDraM0Yc3U6t+kDTbDm94dn0J1ubDAXClXet7gPd43BTMuYHCd+3kzr4Op7MUk8lEQkLbo4IAeHdUNqdd5b1O8zOw7OqvKCva4wsCNjMk28EalVFjEDAMgyVVk4bfH9ubf97QJeBBACAp0kHPZt6hQtNXensubBYb7P2cEjeUb3nrF0OwNExI6p6GCYmISK1oFh/Oyzd2pcLpYUAr72ZaZrOJlokRzLh7APM25dAmJZLmCeF88NNuYsNsXN21MTsPlZJ5sIQnr+1IRlIks+47nzV78jk3PZ64cDtuj8HB4gpW7Mpj/f4iLmiTSMukCFbuzqdNSiTXdGvsVw+HzUK3pjEs3u4dutQyMYJypxuHzXLC91JS4WLmhgO+7+98bwXg/cS/S9MYlmYe7hEYd0EGo/o2J7ekku0HS2iZGEFcuHdc+P9deQ6zNmbzj6s7+L1/j+Zx9Ggexw09mzDg6Tks3n6InKIKEiOP8wDb+0049/XDD+U1PZxXLWNq6f0faHkXTrMdZ0UBVmsoJcVZlGR+6C2343/Q5n7Cwhsdd1Uea7cnqTznIVxxranLKFA2/0byt74HQJQVIqxAs5ug3zs1lv/3/O3kFFVgt5rpnBZTdxU9Adf1SGPpjlze+nEHo/ulExYWT6kZnB7IdUL8e+GEtBp9jGFYCgNy5mmYkIYJiYg0OJMXZPLIF+sJtVnomBbNTzty+ftVHUiODOGBj1fTpUkMLwzvSpSj5kfcRdsOMfw/i7FbzYTZLeSXeifhvn5TN4Z0aITHY7Atp5jF2w8x/NymWC2n3tF+1SsLWLU7n0HtvBto/e2K9r45CafK43GRlbUK1jwCe7/EYQYj7Roqdn0CgN0Mtqu2EhWTjsl07Lrn5++gtPQQkaExRMa2PGa52mIYHkrnj6Bg2/sA2EyQYAdT+kjoW/M+EGv3FjD0lQW4PAZ/vawdtw1occbreTKcbg/9n5rNgcIK3ri5Oxefk4Jn4S0UbHmbMrf37yLBDgyrpMJZzqFDm1mQWU6TGCvpCWEkJ3cM9C3IWUjDhEREJKgN79WUxjGhlDndLM3MxTDg71+s44/vrSCv1MmcTTm+VYxqsmK3d3Ori9ol89+RPRjQKoHruqdxUXvvcCCz2USr5Ehu7tP8tIIAwBWdGgHw/YZsZq4/wLhpK057eIjZbPUFAfCuMlQdBBLtkNB2NNGxLY8bBKBqKcz5V1P0aQblH5/Zh2zDMMjOWukLAmEWiLd791o4VhDILirnpjeX4PIYXNw+ud4FAQCbxcylHb1/x9+s9e7Wbe47haiMkZiASg+4wlpW9fQYrNpXyYQv8hn2zkHUMyB1QWFAREQanBCrhWd+2wmzyTu0x24143QbVLg8vjJzNh6e3Dxz/QFu+u8Sfv/Ocp74ZgPzqlY66tIkhh7N43hnTC+eua4zFnPtb2B1RWf/XXRX7c5n5voDxyjtb1tOMdmF5Uef8DgJ2e8NApYjqmw2gdWEd7jRCbCZgNLdABQUZmIsHPmrrzHclRjuSjweF67KIu+E5arlTcvL8yku9t6bYXj/Lioqiigpyaaysgi3YUDjKwm1QHSrWzAPr/TOjziG6Sv2kl/qpEViOM/8tvMJ3VMgXFYVBr5es5+cIu+SopY+/yWk6imstHAbeJwYhsHPe+rXzs/S8GnOgIiINEh9MxL44o/9cdgsLNx6kIc/8652dG7zOJbuyGXB1oN8ty6LL1bvr7GXwGo21ck69clRDj7+Qx9enbONg8UVrNpTwNh3lhNmt5CRFMFtA1pwZVVgcLk93PXBSiqcbga2TuSRL9aTEuVg9v0DCbEeMSfCbCOm9Sjc2ydji2hBdt523IZ3/L2pxagTngzsiGhEbHQ6eQWZ3qVKt71DWNXY9oqKQipdlYSHJ2E2e9+74sebydvyLoYBhDXBKN2N3QwxVnA2HUFexj0AFBZ6J0ybzVY8Hpf/e/Z8ntiY//1qHUsrXby/1BtURvdLJzqsbic4n4zuzWLp0iSGlbvzefPHTB68pC2YbYS2HEH5lqmUuSFq6e+hy3M43Yd7A8oqj149S6S2qWdAREQarHNSo2mZGMGF7ZJ9x576bSc6p0VT5nQz9p3lfLFqHyYTDGiVQL+Mwxtajf9NBi0Sf7kO/JnRvVkcb47qybTbexMd6n2oLa10s3pPAQ9+vNq3k/GCbYf4avV+vt+QzcOfrcPtMdibX8ZXVUtqHsnSdxL2GysxDd1GQuubSbRDWMaooz5pNwzDbwO0Xwq9djvRLa4DoNAFh/6XQfYUO4feS6Bo4e/Jzd2C01lKceFucje/i8fwDm4xqnoUKj2QUwl5W6eC4f/g/8sgAOBwRJ9QWPnT/1az/WAJUQ6r75P3+spkMjH+Au9Ozu8s2kFB1RwUR983MZu8e0JUbH0Lw11JYfnhMJBbqjAgZ57CgIiINHipMaH8++bu/HdkD9ITwnn95u50TosGvBuBfTauH++M6cXU23qzauLF/PCnC7jrwlZ1Xs/wECvPVg1HCrd7P20vrXTz0TLvJ+mfr6x5nsNbCzJrnmdQ9VBt6fc2thtrHnLzxvztdPn7TP5TtUFcTcIGvIPVBB4DKop34ap+q72fU1lRQE7OBgqLszEaX+l7ja1qYqyJqpHvYU2wh8Rgt0dgsdh9qxiZzRYSEtoSF5dBREQKoaFxx22jz1bupf3EGXy5ej8Ws4m3RvUktmr1pvrswnZJZCRFUFLpZvYm71ApkyWE0ObXA1DmBpbfS1bR4QBwqERhQM48hQEREQkKg89JYVB7bw9Bo+hQpo/rx8qJF/HmqJ50OmI5yugwG03iwk55s7LTdVH7ZLY+fgnr/j6Ex6/uAHg/TXa5Pcza6H2IrO7BeOSK9oRYzazdW8jw/yxm4daDx75wDZ+2G4bB8zM3A/D41xvYnlNc40tNlhDiW40g1AIOM8TYvA/6kS2Ggck74jgkJJKofv+m0S3lNIpvSaId7BEtCa8ekFy6m/DQGBIS2pCc3NEXABIS2mG3h+NwRBMV1fi4k5q35RRz1/srKa0aPnPbgHR6ND9+eKgvTCYTF1X9/M07Yqfu0D7e+RtlbvDsmEpW0eHeEvUMSF1QGBARkaBkMpmICaufnyhXB5GruzYmymFlx6FSrn19EfmlTiJDrEy+9VxWPHwRo/qlM7p/OgCLt+dy6+Sf2J1berxL+1m5O99vUvXcTcfeMdrS/11iYzOIs0NYVAb2GyuJGDiN6OimJCS0JT6+NRERKZgsIZiu2grXl8DQrYRn3OK9QOMrCQmN97umwxGN1Xrim4Md2XuREuVgXNXQm7PF+a29+2/M33IQT9UO1HZHLNbwphhAuaMZuaVHDhPy1HQZkVqlMCAiIlJPhdmt3D+4DeBdZQigb0Y8NovZNzTmT4Pb8MHY3jSOCaXC5eHl2VtP+Ppf/mKuwQ9bctiXX3bsF1y5xfuQf9UWMNswmUyEhyfWvHFZ1U7Blr6TSbgxj4QLpnmXPD0Fuw6VcqCw3DfR+983d+e7e8875j4R9VW3ZrFEhljJLalkzd4C70GPE0fFLgAqinf6hTMNE5K6oDAgIiJSj43s05xXbuzGuc3jSI12cEuf5n7nTSYTvVrE8/z13qU1P1i222+H5GNxewzfxOPq+RFzNuXQ98nZfLpiz7FfaD35DdHsjpjj7nR8PG8v2sF5z8yh1z9mUVLppnl8GBe3Tz7rggB49xzol5EAwJxN2d6DZhshLW4CwEi9nIoj5lQXVnhOe88JkV+jMCAiIlLPXdapER/+vg8LH7qQvlUPk7/Us3kcjWNCAbj+34t44psNx32Q/HZdFlmF5cSE2bjjgpZ+K/L83xfrKapawSiQJi3IZGLVkrDVfts9LWDzOWpD9XK1n6/c5/v7sfebAo0vx7V3Bp4j/sq8y4wqDMiZpTAgIiLSAJjNJh67ugPdm8UC8O9523n0yw3M35xDYbl3Q6vPV+3jz5+uIaeogn/P2wZ4ex5CrBaeu74zz13XmYgQK/mlTj5cdpzegTrgdHt4qWrI08g+zeicFk10qI3rejQJaL1O1yUdGxFqs7D9YIlvczmT4SbiwJdUePznsGibAakL2nRMRESkgbigTRIXtEnirR8z+fuX63lrQSZvLcikbUokjWNCmbXROzRl2hLvGPUQq5lb+jQDwGGzcG33NMpdbv7y6Vr+PW8b1/VIq/PhOIZhkFVYzpjJy8gtqSQhIoSJl7fHY3iHNoXaLb9+kXosIsTKTb2b8p8fMrn/o1V8kRJJs/hwwlqOpGLd535lK10GhmFwFneEyFlAPQMiIiINzC19m9OuUZTv+41ZRb4gcKQbezUlPsJ/NZ9ru6WRnhBOdlHFSU1GPl1uj8H1ry8i/aGv6fPEbNbvLwRgWM8mWC1m7FbzWR8Eqk0Y3JauTWMoLHdx5/srcbk9mPu8SUX/r/zKaZiQ1AX1DIiIiDQwFrOJ927vxa7cUvbmlfGHqT8DcMf5LRnSIYXtOSXER9jp3SL+qNc6bBb+elk7xkxZxntLd3HXha0IDzlzjwuTFmQyb3MOh4qPWGGn6h6evrYTV3dtfMbeO1DsVjOv3NiNwf+az6rd+XywbDc3ntuUCrd/2KlwownEcsYpDIiIiDRAMWF2YsLsdGwcTf+MBDbsL2Rkn+akRDv8NlmryQVtkmgeH8aOQ6V8smIvN/duVit1qnC5Ka1wExtup6DMyaQFmfzr+y1HlXtsaAeGdEghIeLE9yA426TGhHLvRa35vy/W89rcbQzv2ZRKt/+Df3XPgMfjxmxuGL0iUv8oDIiIiDRgJpOJKaPPxTAMrJYTGx1sNpu4pW9z/u+L9Tw8fS1frd7HH3/Tyrcs5rEUlTu598NVRIfaeOa3nfxW/Skoc3LtawvZeaiEKzqlMmtjNgVl3hWLOjSOomlcGDlFFbw4vCuNokNP/YbPIsPPbcqz325iT14Zmw4UUeHyDwOVLoO8Q5txup3ExWUQEhIZoJpKQ6YwICIi0sBZzCbg5GahXtejCS/N3kpuSSWLt+eyePsSHr68PWP6p1Na6eLrNVkYhsG13dIwmcBjwAMfr/atkNOjWSyHSirp1jSWPi3j+efMzWzNLgbgkxV7AUiLDSU9IZyJl7enVXLwPeg6bBa6N49j/uYclmw/RKzlF2GgeC+VXw6GxleS2+kRkpM7qYdAap3CgIiIiBwlIsTKayO6Mf69FeQUVQDwxNcb6NEslj9/uoZ1+7wTfGdvzCarsJzVewpwH7FI/oOfrAG8KxZ9/Ie+fPKzd6nSQe2SSYwMoWfzWK7snHrCvRUNVa90bxhYuiOX85v9YphQRYn3D3s/x+jwZ4qLs4iKanhzKCSwFAZERESkRr1axLP0zxdiMpkY8d/FLNh6iKteWeBX5pu1WX7fx4fbcXkM3xCgCpeHy1/6EYDUaAf/vrl7VU+FAJybHgfA0sxceru/BgZhMXlwG2YqLd49IyJa3ECxyUpJyQHCwhKwWhvuXAqpe8Edx0VEROS4qsf9P3x5e9ITwgGIDrXx3T3nMfa8Fn5lU6Md/POGLsy85zxevrEr3987EJvl8IP/td3TFAR+oVNaNCFWMweLK9lxIBeASHMRAJXWOGyXrSTq/PcJCYnCMAyys9dSXJx1vEuKnBT1DIiIiMivapsSxZz7zyenqAK7xUx0mI0Jg9twTmoUPZvHkRrjP+n38k6pAPx+YEvfTsLXdkur83rXdyFWC12bxrB4ey5vHboegBiHhfwS7wRii80bwKKi0sjJWQ9AYeFebLYwQkKijnldkROlMCAiIiInLDHy8BAVm8XMVV2OP4b93otakxoTSojVTPOqngXxN7RLYxZvz/V9HxXbGEoKcFYUYVn1F7jgA2y2UBIS2pCbuw2Px0V5eYHCgNQKDRMSERGRM8ZkMjH83KZco16BY7q2exp26+FHsiiHd8WgSsNOyJ4PweOdf2G3RxAd3QQAZ0W+77jI6VAYEBEREQkgm8XMyokX+b4vrfQAVWEgYzSYbYfL2sJhzd9xftmJonftGItG13l9pWFRGBAREREJsDD74ZHbBworfH+u7PmGXzmr2Yx9/+cYQJELCjZPAldpXVVTGiCFAREREZF6JMR2+PGs0uXxP2m2Ed/6FmKqOgtK3VD+XjgsHlOHNZSGRGFAREREpB5485YetEwM59nrOvuOVfwyDACmvpMJazmSiKrOhHwXuLe9pR4COSVaTUhERESkHriwXTIXtksGwG4xU+n2kF/q5EBhOa2SIv0mGdN3CpGYqNg8BacHDlRA6NRwYtuMht5vBugO5GykngERERGReiak6sF/2BuLuOzFH7nu34uOGjJk6v0fYo/4WLfMDZ5tb2mVITkpCgMiIiIi9UxRhQuAg8WVAKzanc+Hy3b7FzLbsGaMJsF++FB5kxv9Vh/y0RAiOQYNExIRERE5C7y9aAcjejXFZDIdPtj7Teznvk5k0X6KivdTZA3D7irH5arA4YjG7a4k7+PWeEp2EhfbEuvQrYG7AamX1DMgIiIiUo+9eUsPQqxmNh8o5uXZWzEMw7+A2UZEVBoWaxhudyXZ2evIzd1KYeEeCvO2Ulm8E5cBpYXbcFfk46os1lAi8VEYEBEREalnnvltJ67u2pj1fx/Mhe2SGdbTu/PwczM388b87UeVN5nMxMQ08ztWXHyAsuUP+b4vd0POp53IeTeS8ql273KkCgVBz2QcFS+DR2FhIdHR0RQUFBAVFRXo6oiIiIjUyO0xeH3eNp75dhN2q5kZdw2gRWLEUeUqKopwucopLt6P21UG3/bGbALDgCMf+EyA1QQOC0S21gpEDc3JPOOqZ0BERESknrOYTdxxfksGtEqg0uVh7DvLKSw/+lP9kJBIwsMTSU7uhD0kGhpfSbQVwiOb+5UzAKfh3cW4cqtWIApmtR4GnnjiCXr27ElkZCRJSUkMHTqUTZs2+ZUpLy9n3LhxxMfHExERwbXXXsuBAwf8yuzatYvLLruMsLAwkpKSmDBhAi6Xy6/M3Llz6datGyEhIWRkZDB58uTavh0RERGResFkMvHsdZ1Jjgpha3Yxd7z7M0U1BIJqsbEtiT//XUJHVBJ5zUbsx3jqK3GfoQrLWaHWw8C8efMYN24cixcvZubMmTidTi6++GJKSkp8Ze655x6++OILPvroI+bNm8e+ffu45pprfOfdbjeXXXYZlZWVLFy4kClTpjB58mQmTpzoK5OZmclll13GBRdcwMqVK7n77ru57bbb+Pbbb2v7lkRERETqheQoB/8d2ROHzcyPWw9y/jNzWb4zr8ayFouNkJBIMNswWUKIb3MriXYIs3jPV4eDcjd4Fo5W70CQOuNzBnJyckhKSmLevHmcd955FBQUkJiYyLRp0/jtb38LwMaNG2nXrh2LFi2id+/efPPNN1x++eXs27eP5GTvTnyvv/46DzzwADk5Odjtdh544AG++uor1q5d63uvYcOGkZ+fz4wZM06obpozICIiImejOZuyefDj1RworMBkgpeHd+OyTo1+/YUeJ54lY6ncOhlHy5HkbHobp+GdQ2A3Q3jLEYT0f8d/+VI569SrOQMFBQUAxMXFAbB8+XKcTieDBg3ylWnbti1NmzZl0aJFACxatIiOHTv6ggDA4MGDKSwsZN26db4yR16jukz1NWpSUVFBYWGh35eIiIjI2eaCNknMuu98zm+TiGHAY1+tJ6+k8tdfaLZh7jMJx4hK6DuF6IzhmPDOIajwQO6WqWRnrcDp1CZlweKMhgGPx8Pdd99Nv3796NChAwBZWVnY7XZiYmL8yiYnJ5OVleUrc2QQqD5ffe54ZQoLCykrK6uxPk888QTR0dG+ryZNmpz2PYqIiIgEQkSIlddGdCc5KoT9BeVc9coCsgrKT+zFVbsU2wdMIymuJaFVQ4dofCVuw+DgwY0UF2fh8biOfY0qhmHg8fhPPHC7K+vNsCOPx11v6lIfndEwMG7cONauXcv7779/Jt/mhD300EMUFBT4vnbv3v3rLxIRERGpp0LtFqaMPpf4cDu7ckvp8+Qs3l+6i+KKX3+Ir2YZupXYESXEDz+EtevjgPcBv7BwLwcPbvLb5Ky8PJ/Cwj0UFOwiJ2c9hYV7OHBgFVlZKykpyQGgrCyPA99fR9G7VXsZBFBR0X6yZg71r4uCgZ8zFgbGjx/Pl19+yZw5c0hLS/MdT0lJobKykvz8fL/yBw4cICUlxVfml6sLVX//a2WioqIIDQ2tsU4hISFERUX5fYmIiIiczdqmRPHqiG7EhNkwDHjwkzX0/scsftxy8MQvYg0jJDSOxMRzaNSoKzExzTCbrbhc5ZSUHKCyspiysjxyc7dRXHyAkpIcnM4yiosP+HoFSktzMNwVFBxcC3s/p8gFxra3cDtLcB857OgYD+OG4aG09OAJ9UYAuFwVFBXto6zsiAnUHqf3y1WKy1VO0YLbYe+XFFfVpXjuMEretWMsHOV/serXHfcNax46ZRgenM5ScnO3kpOz4awbYmWt7QsahsEf//hHPv30U+bOnUt6errf+e7du2Oz2Zg1axbXXnstAJs2bWLXrl306dMHgD59+vD444+TnZ1NUlISADNnziQqKor27dv7ynz99dd+1545c6bvGiIiIiLBoleLeBY/dCGPf7WB7zccYH9BObe9/ROTbz2XXYdK+XlXHn8a0pa4cPtxr+OdOGwiLCwBMJGfv4PCwr3HfY3V6sDlKsf580Ps3/u537kDleD5uC2Wsj1EtRxBubOc8P0fY2lxC2UdHsNuD8fuiMXlKqe0OIvi0kNYrQeIj29NcfF+bLawqrr4Ky09REHBTl+vhcXSFs+S31O2/V0MA9yAi1DweIeOG8BBSxrO7R94v986hQiTCaP3W+TN/i2Vuz4h0gLhNWzAVl6eT/70ztjKdxES3oywqzdisnjb0eWqIDd3C2734SCRl7eduLhWlJUdIiIiBZOpfm/rVeurCd1xxx1MmzaNzz77jDZt2viOR0dH+z6x/8Mf/sDXX3/N5MmTiYqK4o9//CMACxcuBLxLi3bp0oXU1FSefvppsrKyuPnmm7ntttv4xz/+AXiXFu3QoQPjxo1j9OjRzJ49mzvvvJOvvvqKwYMHn1BdtZqQiIiINDQVLje/e2c5czfl+B2/pmtjnr+hy0ld6+DBTVRWFmM2W7FaQzCbrZhMFhyOaByOGMrLC3A4ojmUs57KLzv6XlfTrsdHngPwVJ00N74cD8DeL6HxldBxol/5lJTOmM2HP792u51kZ6/xG76E4YJve9d4DxYTuH9REbsZEuxQ1OgaijI/8R2Pt4HpujycbidgEBaWwMH9P+Gc8Ytr11BPv3s0W/B43ISFJRAT0+yY5c6Uk3nGrfUwcKylqCZNmsSoUaMA76Zj9913H++99x4VFRUMHjyYV1991TcECGDnzp384Q9/YO7cuYSHh3PLLbfw5JNPYrUe/mGYO3cu99xzD+vXryctLY2HH37Y9x4nQmFAREREGqJyp5ux7yxn/mb/QDDt9l6kRofSPCGcwnInkSHW4y4jahgGbnclFov9uOXcbieuRaOx7HgXAKvZuzpRodO70/FJGbwYTP6DV8LCEggLS6C4eD/l5QW+43FxLcnL247hccK3vbGbIcQMZW5v6Ag1Q6gF8pzeQGAxeet1TL98yF/zd6jq7bCbofLI1x5RT7s9nJCQKJzOMsrL8wEwmcwkJrbHag05yQY4fQENA2cThQERERFpqAzDYNOBIpIiHdz/0Spmb8z2nYtyWCmtdNO9WSyTbu1JmL2WRo5Xj72vWq2IL9vjKtxKvsv7MG01QX7ViJpQi/cB3YT3Ad0ERFnBet1BMNvweNzk5W0/5ltFRzchPDwJp7MMp7OEkJUTsOyYDOmjAA9kvu0t2GI0GB7InAzAgQr/noJIq7eXouQ3P4LFcfjEEb0N0VYIt3rDQJ4TrE2vxej8OFarg/DwJGw27+iX8vJ8cnO3ARARkUJUVOPTas5TpTBwghQGREREJBgs25HLDW8sxu05+rHvdwNb8NAl7c7cm7tK4esuULwFI7QFeQXbMZu8D9gmWyS4iqh+GjW19B+zX15eQG7u1hovm5R0Dlarw//gkUGkekLwkd97nFQuGkv59qmAN6A4LGCk30p+27/6JiMnJ3fCVVlI0QcJhFu8wYX0UdDzFe/1qq/5C4ZhcPDgBtzuShIT22OxHH+OxpmiMHCCFAZEREQkWKzZU8Di7YfYcaiED37azTmpUazaU4DDZub9sX1oHh9GTJidPXmlxITZiQip5XVmXKVgDfMu8bn9Le/DdZ9J3uPVD9c1PGS7XOVkZ3s3nbXbw6msLAEgNbX7qddl0a3enoL0UdDrDTDbcLud5OfvICwsgdDQWG+5X9b1BHhXVzL85jnUNYWBE6QwICIiIsGo3OkmxGpm+H8Ws3h7ru94qM1CmdNN25RIpo/rh8NmOc5VTsORn+CfgKKi/TidpcTENKe4eD92eyQOR3Td1OEk61ofnMwzbv1e60hEREREap3DZsFkMvHvm3qQEnV4qE2Z07tnwMasIu79cCX5pZW/eq2ahh79qpN8uI6MbERcXEvMZgtRUWmnHwROpg5nWRA4WQoDIiIiIkEqOszGf2/pwfBzmzDp1p5c3qkR1YsGfb0mi0tf+IHMgyW+8lkF5SzcdtC3rGdeSSUXPjeXS174gd25hzfb8pxKQDjLZRWUs3xnHoZhUFDmpKzSHegqnRANE9IwIRERERE/i7Yd4s+friHzYAkdG0fzyJXtcboNfvfOcgrKvBNzuzaNISMxgo+W7wHgso6NeGVENxZuO8itk34iOcrBB7/rTaPoUN91DxSWkxgRgtl87GVK69rOQyUs2Z5L34x40mLDjjqfXVTOO4t2YjGbOLd5HOekRhMddri3oNzp5i+fruWLVfuodHsYfm5TEiPsvPljJvde3IYx/dOPuuaZpjkDJ0hhQERERKRm+wvKuOj5+RRXuE74NX+5tB3Ld+YxY10WAN2axtC2URQDWyeyO7eUx77acOZXLzpCXkklW7KL6dwkmhCrhXKnG5vFjKUqjMzZlM3v31lOhctD45hQvr93IKF2/3kSD368mvd/2u37PtJhZdptvckrreTDZbtZuTufPXllvvMmE9gsZipdHl4Y1oWrutT98qIKAydIYUBERETk2Gas3c8dU3/27RZ8cftk7rgggykLd/Dpir0AdGgcxcGiSrIKy0/4uvMmnM+CrYdoHBtKu0aRhNmtRIRY2ZdfRkJECBaziSWZh9ieU0JZpZvR/dMxDIO1+wrp2Dja9zB/pIPFFfxx2gpW78mneUI4FS4Pu3JLqXR5uKRDCr1bxPOPrzeQGhNK7xZxzNuUw74C/zqbTDB2QAs2HShiV24pLRLC+X5D9lHv9Us2i4m/XXEO01fsZdlO7/KkoTYLy/46iPDaXpXpBCgMnCCFAREREZHj25NXitlkosLlIT0h3He8qNzJt+sOcGHbJHYcKuF/y/fw+cp9FFW4iAu30yQ2lFV7Co5z5cPiwu1c3qkRby/aWeP5CYPbsHj7IX7YcpCL2iczsk8znpqxkYIyJ5d0aMTIPs340/9Ws3DboZO+v17pcfRuEc8Ls7Ycs0ykw8q8CRew5UARt7+9jMLyw70lt/Zrzuh+6TSJC2PupmxunfwThgFjz2vBny+tmx6QX1IYOEEKAyIiIiK1Z09eKYu353Ju8zgSIu3M2ZjDoZIKJn62jrhwO9f1SOPf8469q/DpCrGaeWFYV4rKnazak0//jASyi7zvD9A4JpQhHVJYs7eAJrFhXNIhhfNaJ2K3mvngp1088PEaIkKs/KZtEj2bx/KfHzLZnVfKC8O6cmXnVMA7Odpkgs0HiklPCMdu9V+PZ8HWg+zLL+PabmkBmxuhMHCCFAZEREREzrxtOcUkVy1hes2rC8gvdTL2vBas2VtA8/hw3l60g7xS78TkSzumkJEYwdiBLdmdW8r7S3cxpYYeg7TYUP74mwyenrGJQyWVWMwm/n7VOYzo1eyosjPWZvHe0l3ceWErujeLPWY9l+3IpWViBLHh3p2DyyrdHCyuoEnc0ROL6zOFgROkMCAiIiISeDsPlfDRsj2cmx7Hea0T/c4ZhsE/v9/C1uwiburVjBv/uwSTCV4e3o3LOjViX34ZX6/Zz8DWibRKjgzQHdQvCgMnSGFARERE5OyyZk8BoXYzGUl68D+Wk3nGrfvpzSIiIiIip6hjWi3sPiw+2oFYRERERCRIKQyIiIiIiAQphQERERERkSClMCAiIiIiEqQUBkREREREgpTCgIiIiIhIkFIYEBEREREJUgoDIiIiIiJBSmFARERERCRIKQyIiIiIiAQphQERERERkSClMCAiIiIiEqQUBkREREREgpTCgIiIiIhIkFIYEBEREREJUgoDIiIiIiJBSmFARERERCRIWQNdgUAyDAOAwsLCANdERERERKR2VD/bVj/rHk9Qh4GioiIAmjRpEuCaiIiIiIjUrqKiIqKjo49bxmScSGRooDweD/v27SMyMhKTyVTn719YWEiTJk3YvXs3UVFRdf7+ZzO13elR+506td2pU9udOrXdqVPbnTq13akLdNsZhkFRURGpqamYzcefFRDUPQNms5m0tLRAV4OoqCj9IztFarvTo/Y7dWq7U6e2O3Vqu1Ontjt1artTF8i2+7UegWqaQCwiIiIiEqQUBkREREREgpTCQACFhITwt7/9jZCQkEBX5ayjtjs9ar9Tp7Y7dWq7U6e2O3Vqu1Ontjt1Z1PbBfUEYhERERGRYKaeARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgNn2JNPPonJZOLuu+/2HSsvL2fcuHHEx8cTERHBtddey4EDB/xet2vXLi677DLCwsJISkpiwoQJuFyuOq593du7dy833XQT8fHxhIaG0rFjR5YtW+Y7bxgGEydOpFGjRoSGhjJo0CC2bNnid43c3FxGjBhBVFQUMTExjBkzhuLi4rq+lTrldrt5+OGHSU9PJzQ0lJYtW/Loo49y5GJharvD5s+fzxVXXEFqaiomk4np06f7na+ttlq9ejUDBgzA4XDQpEkTnn766TN9a2fc8drO6XTywAMP0LFjR8LDw0lNTWXkyJHs27fP7xpqu5p/7o70+9//HpPJxL/+9S+/42q7Y7fdhg0buPLKK4mOjiY8PJyePXuya9cu3/lg/d37a21XXFzM+PHjSUtLIzQ0lPbt2/P666/7lQnWtnviiSfo2bMnkZGRJCUlMXToUDZt2uRXprbaZu7cuXTr1o2QkBAyMjKYPHnymb69www5Y5YuXWo0b97c6NSpk3HXXXf5jv/+9783mjRpYsyaNctYtmyZ0bt3b6Nv376+8y6Xy+jQoYMxaNAgY8WKFcbXX39tJCQkGA899FAA7qLu5ObmGs2aNTNGjRplLFmyxNi+fbvx7bffGlu3bvWVefLJJ43o6Ghj+vTpxqpVq4wrr7zSSE9PN8rKynxlhgwZYnTu3NlYvHix8cMPPxgZGRnG8OHDA3FLdebxxx834uPjjS+//NLIzMw0PvroIyMiIsJ44YUXfGXUdod9/fXXxl/+8hfjk08+MQDj008/9TtfG21VUFBgJCcnGyNGjDDWrl1rvPfee0ZoaKjx73//u65u84w4Xtvl5+cbgwYNMj744ANj48aNxqJFi4xzzz3X6N69u9811HY1/9xV++STT4zOnTsbqampxj//+U+/c2q7mttu69atRlxcnDFhwgTj559/NrZu3Wp89tlnxoEDB3xlgvV376+13e233260bNnSmDNnjpGZmWn8+9//NiwWi/HZZ5/5ygRr2w0ePNiYNGmSsXbtWmPlypXGpZdeajRt2tQoLi72lamNttm+fbsRFhZm3Hvvvcb69euNl156ybBYLMaMGTPq5D4VBs6QoqIio1WrVsbMmTONgQMH+sJAfn6+YbPZjI8++shXdsOGDQZgLFq0yDAM7z9cs9lsZGVl+cq89tprRlRUlFFRUVGn91GXHnjgAaN///7HPO/xeIyUlBTjmWee8R3Lz883QkJCjPfee88wDMNYv369ARg//fSTr8w333xjmEwmY+/evWeu8gF22WWXGaNHj/Y7ds011xgjRowwDENtdzy//OVYW2316quvGrGxsX7/Zh944AGjTZs2Z/iO6s7xHmirLV261ACMnTt3Goahtqt2rLbbs2eP0bhxY2Pt2rVGs2bN/MKA2s6rpra74YYbjJtuuumYr9HvXq+a2u6cc84x/v73v/sd69atm/GXv/zFMAy13ZGys7MNwJg3b55hGLXXNn/605+Mc845x++9brjhBmPw4MFn+pYMwzAMDRM6Q8aNG8dll13GoEGD/I4vX74cp9Ppd7xt27Y0bdqURYsWAbBo0SI6duxIcnKyr8zgwYMpLCxk3bp1dXMDAfD555/To0cPrrvuOpKSkujatSv/+c9/fOczMzPJysrya7vo6Gh69erl13YxMTH06NHDV2bQoEGYzWaWLFlSdzdTx/r27cusWbPYvHkzAKtWreLHH3/kkksuAdR2J6O22mrRokWcd9552O12X5nBgwezadMm8vLy6uhuAq+goACTyURMTAygtjsej8fDzTffzIQJEzjnnHOOOq+2q5nH4+Grr76idevWDB48mKSkJHr16uU3HEa/e4+tb9++fP755+zduxfDMJgzZw6bN2/m4osvBtR2RyooKAAgLi4OqL22WbRo0VHPi4MHD/Zd40xTGDgD3n//fX7++WeeeOKJo85lZWVht9t9vxirJScnk5WV5Stz5A9N9fnqcw3V9u3bee2112jVqhXffvstf/jDH7jzzjuZMmUKcPjea2qbI9suKSnJ77zVaiUuLq5Bt92DDz7IsGHDaNu2LTabja5du3L33XczYsQIQG13MmqrrYL13/GRysvLeeCBBxg+fDhRUVGA2u54nnrqKaxWK3feeWeN59V2NcvOzqa4uJgnn3ySIUOG8N1333H11VdzzTXXMG/ePEC/e4/npZdeon379qSlpWG32xkyZAivvPIK5513HqC2q+bxeLj77rvp168fHTp0AGqvbY5VprCwkLKysjNxO36sZ/wdgszu3bu56667mDlzJg6HI9DVOat4PB569OjBP/7xDwC6du3K2rVref3117nlllsCXLv67cMPP2Tq1KlMmzaNc845h5UrV3L33XeTmpqqtpOAcDqdXH/99RiGwWuvvRbo6tR7y5cv54UXXuDnn3/GZDIFujpnFY/HA8BVV13FPffcA0CXLl1YuHAhr7/+OgMHDgxk9eq9l156icWLF/P555/TrFkz5s+fz7hx40hNTT3q0+pgNm7cONauXcuPP/4Y6KrUOvUM1LLly5eTnZ1Nt27dsFqtWK1W5s2bx4svvojVaiU5OZnKykry8/P9XnfgwAFSUlIASElJOWomevX31WUaokaNGtG+fXu/Y+3atfOtBlF97zW1zZFtl52d7Xfe5XKRm5vboNtuwoQJvt6Bjh07cvPNN3PPPff4eqfUdieuttoqWP8dw+EgsHPnTmbOnOnrFQC13bH88MMPZGdn07RpU9/vjp07d3LffffRvHlzQG13LAkJCVit1l/9/aHfvUcrKyvjz3/+M88//zxXXHEFnTp1Yvz48dxwww08++yzgNoOYPz48Xz55ZfMmTOHtLQ03/HaaptjlYmKiiI0NLS2b+coCgO17MILL2TNmjWsXLnS99WjRw9GjBjh+7PNZmPWrFm+12zatIldu3bRp08fAPr06cOaNWv8/qdf/Qv1l/+za0j69et31JJdmzdvplmzZgCkp6eTkpLi13aFhYUsWbLEr+3y8/NZvny5r8zs2bPxeDz06tWrDu4iMEpLSzGb/f85WywW3ydmarsTV1tt1adPH+bPn4/T6fSVmTlzJm3atCE2NraO7qbuVQeBLVu28P333xMfH+93Xm1Xs5tvvpnVq1f7/e5ITU1lwoQJfPvtt4Da7ljsdjs9e/Y87u+P7t2763dvDZxOJ06n87i/P4K57QzDYPz48Xz66afMnj2b9PR0v/O11TZ9+vTxu0Z1meprnHF1Mk05yB25mpBheJehatq0qTF79mxj2bJlRp8+fYw+ffr4zlcvQ3XxxRcbK1euNGbMmGEkJiae9Ut0/ZqlS5caVqvVePzxx40tW7YYU6dONcLCwox3333XV+bJJ580YmJijM8++8xYvXq1cdVVV9W45GPXrl2NJUuWGD/++KPRqlWrBrk85pFuueUWo3Hjxr6lRT/55BMjISHB+NOf/uQro7Y7rKioyFixYoWxYsUKAzCef/55Y8WKFb4Vb2qjrfLz843k5GTj5ptvNtauXWu8//77RlhY2Fm/xOPx2q6ystK48sorjbS0NGPlypXG/v37fV9Hriiitqv55+6XfrmakGGo7Y7Vdp988olhs9mMN954w9iyZYtvacYffvjBd41g/d37a203cOBA45xzzjHmzJljbN++3Zg0aZLhcDiMV1991XeNYG27P/zhD0Z0dLQxd+5cv/+flZaW+srURttULy06YcIEY8OGDcYrr7yipUUbml+GgbKyMuOOO+4wYmNjjbCwMOPqq6829u/f7/eaHTt2GJdccokRGhpqJCQkGPfdd5/hdDrruOZ174svvjA6dOhghISEGG3btjXeeOMNv/Mej8d4+OGHjeTkZCMkJMS48MILjU2bNvmVOXTokDF8+HAjIiLCiIqKMm699VajqKioLm+jzhUWFhp33XWX0bRpU8PhcBgtWrQw/vKXv/g9gKntDpszZ44BHPV1yy23GIZRe221atUqo3///kZISIjRuHFj48knn6yrWzxjjtd2mZmZNZ4DjDlz5viuobar+eful2oKA2q7Y7fdm2++aWRkZBgOh8Po3LmzMX36dL9rBOvv3l9ru/379xujRo0yUlNTDYfDYbRp08Z47rnnDI/H47tGsLbdsf5/NmnSJF+Z2mqbOXPmGF26dDHsdrvRokULv/c400yGccQWpSIiIiIiEjQ0Z0BEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIKUwICIiIiISpBQGRERERESClMKAiIiIiEiQUhgQEREREQlSCgMiIiIiIkFKYUBEREREJEgpDIiIiIiIBCmFARERERGRIGUNdAUCyePxsG/fPiIjIzGZTIGujoiIiIjIaTMMg6KiIlJTUzGbj//Zf1CHgX379tGkSZNAV0NEREREpNbt3r2btLS045YJ6jAQGRkJeBsqKioqwLURERERETl9hYWFNGnSxPesezxBHQaqhwZFRUUpDIiIiIhIg3Iiw+A1gVhEREREJEgpDIiIiIiIBCmFARERERGRIBXUcwZEREQkeHk8HiorKwNdDZGTZrPZsFgstXIthQEREREJOpWVlWRmZuLxeAJdFZFTEhMTQ0pKymnvlaUwICIiIkHFMAz279+PxWKhSZMmv7opk0h9YhgGpaWlZGdnA9CoUaPTup7CgIiIiAQVl8tFaWkpqamphIWFBbo6IictNDQUgOzsbJKSkk5ryJCisIiIiAQVt9sNgN1uD3BNRE5ddZB1Op2ndR2FAREREQlKpzvWWiSQauvnV2FARERERCRIKQyIiIiIiAQphQERERER8dO8eXP+9a9/+b43mUxMnz79tK5ZG9eQ2qfVhERERETkuPbv309sbOwJlX3kkUeYPn06K1euPOVrSN1RGBARERFpgCorK2ttxaSUlJR6cQ2pfRomJCIiIkHPMDwB+ToZ559/PuPHj2f8+PFER0eTkJDAww8/jGEYgHdoz6OPPsrIkSOJiopi7NixAPz4448MGDCA0NBQmjRpwp133klJSYnvutnZ2VxxxRWEhoaSnp7O1KlTj3rvXw7x2bNnD8OHDycuLo7w8HB69OjBkiVLmDx5Mv/3f//HqlWrMJlMmEwmJk+eXOM11qxZw29+8xtCQ0OJj49n7NixFBcX+86PGjWKoUOH8uyzz9KoUSPi4+MZN27caS+lKf7UMyAiIiJBzTA87N+/IiDv3ahRV0ymE/9sdsqUKYwZM4alS5eybNkyxo4dS9OmTbn99tsBePbZZ5k4cSJ/+9vfANi2bRtDhgzhscce46233iInJ8cXKCZNmgR4H7r37dvHnDlzsNls3Hnnnb7dbWtSXFzMwIEDady4MZ9//jkpKSn8/PPPeDwebrjhBtauXcuMGTP4/vvvAYiOjj7qGiUlJQwePJg+ffrw008/kZ2dzW233cb48eN94QFgzpw5NGrUiDlz5rB161ZuuOEGunTp4rtfOX0KAyIiIiJniSZNmvDPf/4Tk8lEmzZtWLNmDf/85z99D8e/+c1vuO+++3zlb7vtNkaMGMHdd98NQKtWrXjxxRcZOHAgr732Grt27eKbb75h6dKl9OzZE4A333yTdu3aHbMO06ZNIycnh59++om4uDgAMjIyfOcjIiKwWq3HHRY0bdo0ysvLefvttwkPDwfg5Zdf5oorruCpp54iOTkZgNjYWF5++WUsFgtt27blsssuY9asWQoDtUhhoB4rKHXyzHcb2ZdfzvPXdyYmTDslioiI1DaTyUyjRl0D9t4no3fv3n6bTfXp04fnnnvOt6tyjx49/MqvWrWK1atX+w39MQwDj8dDZmYmmzdvxmq10r17d9/5tm3bEhMTc8w6rFy5kq5du/qCwKnYsGEDnTt39gUBgH79+uHxeNi0aZMvDJxzzjlYLBZfmUaNGrFmzZpTfl85msJAPeXxGNz29k/8tCMPgP/+kMn9g9sEuFYiIiIN08k+lNdXRz5cg3dIz+9+9zvuvPPOo8o2bdqUzZs3n/R7hIaGnnL9TpbNZvP73mQy4fGc3FwLOb6G8ZPfAH2yYq8vCABMWbSD4gpXAGskIiIigbZkyRK/7xcvXkyrVq38Pj0/Urdu3Vi/fj0ZGRlHfdntdtq2bYvL5WL58uW+12zatIn8/Pxj1qFTp06sXLmS3NzcGs/b7XZfT8WxtGvXjlWrVvlNZF6wYAFms5k2bfThZ11SGKinvlq9D4B7BrWmaVwYReUufticE+BaiYiISCDt2rWLe++9l02bNvHee+/x0ksvcddddx2z/AMPPMDChQsZP348K1euZMuWLXz22WeMHz8egDZt2jBkyBB+97vfsWTJEpYvX85tt9123E//hw8fTkpKCkOHDmXBggVs376djz/+mEWLFgHeVY0yMzNZuXIlBw8epKKi4qhrjBgxAofDwS233MLatWuZM2cOf/zjH7n55pt9Q4SkbigM1FPr9hUC0L9VPBe39/6j+H7DsWf2i4iISMM3cuRIysrKOPfccxk3bhx33XWXbwnRmnTq1Il58+axefNmBgwYQNeuXZk4cSKpqam+MpMmTSI1NZWBAwdyzTXXMHbsWJKSko55TbvdznfffUdSUhKXXnopHTt25Mknn/T1Tlx77bUMGTKECy64gMTERN57772jrhEWFsa3335Lbm4uPXv25Le//S0XXnghL7/88mm0jpwKk1G9OG0QKiwsJDo6moKCAqKiogJdHZ+cogp6Pv49JhOsfWQwq/cUMPw/i4kLt7PsL4Mwm02/fhERERGpUXl5OZmZmaSnp+NwOAJdnRN2/vnn06VLF/71r38FuipSDxzv5/hknnHVM1APrd/v7RVIjw8nPMRKj+axhNos5JZUsv1gya+8WkRERETkxCgM1EPrq4YItU+NwnBXYjEqaZ/qTXVr9ub7lZ214QD3fbiKwnLtxiciIiIiJ0dLi9ZD6/YVAJBR/iXZb3fHY8A5pudYThvW7Cnk6iOWQh4zZRkAkQ4rj1x5TiCqKyIiInVg7ty5ga6CNEDqGaiH1u7xLinatOQz3AYYQHr5V4B/z8C+/DLfn2dv1ORiERERETk5CgP1TEmFi5255QC0DtlOhBXMJmgdsgXwrjLk9njnfC/adsj3ul25pWzPKa77CouIiIjIWUthoJ7ZmFWIASRY82kZmk9UdAZRLYbR1L6XUFMZpZVu30P/nE3+vQFzN2kfAhERERE5cQoD9Uz15OFWaclYrs2Gq7YQ2n8KIWYPrR3bAVizJ5esgnJmrM0C4Kou3rWC52lTMhERERE5CQoD9cza6jCQYMUSEgOAyWInKmMEbUK2ArB6+XSmLNqBy2PQKz2OO87PAGDx9kOUO4+//beIiIiISDWFgXpmfdVKQm2S7FgsNt9xR79JtHN4w8Dk7Rm8NncbAGP6p9M6OYKEiBAqXB7W7C2o+0qLiIiIyFlJYaAecbo9bDpQBEDb5DD/k2Yb/dqkEWM5/LDfLD6MC9slYzKZ6NY0BoCfd+bVVXVFRESkgXvkkUfo0qVLrV5z8uTJxMTE1Oo1T8fcuXMxmUzk5+cDtVO/+naPx3PSYWD+/PlcccUVpKamYjKZmD59uu+c0+nkgQceoGPHjoSHh5OamsrIkSPZt2+f3zVyc3MZMWIEUVFRxMTEMGbMGIqL/VfCWb16NQMGDMDhcNCkSROefvrpo+ry0Ucf0bZtWxwOBx07duTrr78+2dupV7ZlF1HpMgizmWiWEH7U+cbnPccn/T7iLykv0Ss+h8eGdsBiNgHQrVksACt25ddllUVEREQalBtuuIHNmzefcPnmzZvzr3/967SuEUgnHQZKSkro3Lkzr7zyylHnSktL+fnnn3n44Yf5+eef+eSTT9i0aRNXXnmlX7kRI0awbt06Zs6cyZdffsn8+fMZO3as73xhYSEXX3wxzZo1Y/ny5TzzzDM88sgjvPHGG74yCxcuZPjw4YwZM4YVK1YwdOhQhg4dytq1a0/2luqFkpIcpi1cDUCbJBsR4YlHlQmxOXBkTefyqG95P/VWBrSM8Z3r1tQbBpbtzKWkwlUndRYRERGpDwzDwOWqneef0NBQkpKSAn6NunLSYeCSSy7hscce4+qrrz7qXHR0NDNnzuT666+nTZs29O7dm5dffpnly5eza9cuADZs2MCMGTP473//S69evejfvz8vvfQS77//vq8HYerUqVRWVvLWW29xzjnnMGzYMO68806ef/5533u98MILDBkyhAkTJtCuXTseffRRunXrxssvv3zMuldUVFBYWOj3VR8UFe1nyo8beXeZtz63D0jH4Yg5qpzVHomlyVAMoLLpCDDbwOMEoFNaNAkRIRwsruS+D1fVYe1FRESkLpx//vn88Y9/5O677yY2Npbk5GT+85//UFJSwq233kpkZCQZGRl88803vte43W7GjBlDeno6oaGhtGnThhdeeMHvunPnzuXcc88lPDycmJgY+vXrx86dO2usw7Zt22jRogXjx4/HMAwqKiq4//77ady4MeHh4fTq1euonZInT55M06ZNCQsL4+qrr+bQoUM1Xrvajh07MJlMvP/++/Tt2xeHw0GHDh2YN2+eX51NJhPffPMN3bt3JyQkhB9//BGPx8MTTzzhu9/OnTvzv//9z+/6X3/9Na1btyY0NJQLLriAHTt2HFXfXw7x+eKLL+jZsycOh4OEhATfc/D555/Pzp07ueeeezCZTJhMpmNe47XXXqNly5bY7XbatGnDO++843feZDLx3//+l6uvvpqwsDBatWrF559/fty2qg1nfM5AQUEBJpPJ1yCLFi0iJiaGHj16+MoMGjQIs9nMkiVLfGXOO+887Ha7r8zgwYPZtGkTeXl5vjKDBg3ye6/BgwezaNGiY9bliSeeIDo62vfVpEmT2rrNU+Z2O/nrZxt4ek4hHgMGZkRwSeeWxyxv7/E8NL6cisypOKe3pPAdOxU/jMBhs/DGyO6YTTBjXRabq+YeiIiIyBlW9cFcXZgyZQoJCQksXbqUP/7xj/zhD3/guuuuo2/fvvz8889cfPHF3HzzzZSWlnqr5vGQlpbGRx99xPr165k4cSJ//vOf+fDDDwFwuVwMHTqUgQMHsnr1ahYtWsTYsWN9D7VHWr16Nf379+fGG2/k5ZdfxmQyMX78eBYtWsT777/P6tWrue666xgyZAhbtng3S12yZAljxoxh/PjxrFy5kgsuuIDHHnvshO51woQJ3HfffaxYsYI+ffpwxRVXHBUkHnzwQZ588kk2bNhAp06deOKJJ3j77bd5/fXXWbduHffccw833XSTL0js3r2ba665hiuuuIKVK1dy22238eCDDx63Hl999RVXX301l156KStWrGDWrFmce+65AHzyySekpaXx97//nf3797N///4ar/Hpp59y1113cd9997F27Vp+97vfceuttzJnzhy/cv/3f//H9ddfz+rVq7n00ksZMWIEubm5J9Rep8w4DYDx6aefHvN8WVmZ0a1bN+PGG2/0HXv88ceN1q1bH1U2MTHRePXVVw3DMIyLLrrIGDt2rN/5devWGYCxfv16wzAMw2azGdOmTfMr88orrxhJSUnHrE95eblRUFDg+9q9e7cBGAUFBb96r2fKup07jGYPfGmkP/il8ca8bYbT5T5u+ZKi/cbeNznqq3y+t41/9/Yyo9kDXxp/+XR1XVRfRETkrFNWVmasX7/eKCsrO/2LLRptGFPx/vcMGzhwoNG/f3/f9y6XywgPDzduvvlm37H9+/cbgLFo0aJjXmfcuHHGtddeaxiGYRw6dMgAjLlz59ZY9m9/+5vRuXNnY8GCBUZsbKzx7LPP+s7t3LnTsFgsxt69e/1ec+GFFxoPPfSQYRiGMXz4cOPSSy/1O3/DDTcY0dHRx6xfZmamARhPPvmk75jT6TTS0tKMp556yjAMw5gzZ44BGNOnT/eVKS8vN8LCwoyFCxf6XW/MmDHG8OHDDcMwjIceesho37693/kHHnjAAIy8vDzDMAxj0qRJfvXr06ePMWLEiGPWt1mzZsY///lPv2O/vEbfvn2N22+/3a/Mdddd59c2gPHXv/7V931xcbEBGN98802N73u8n+OCgoITfsY9Yz0DTqeT66+/HsMweO21187U25yUkJAQoqKi/L4CbfYG79CoHs0iuf28Flgtx/8rCQ1PxtH06CFa5dungcfJDT29vR0/bjlY+5UVERGRwzxO2P6W98/b36qTHoJOnTr5/myxWIiPj6djx46+Y8nJyQBkZ2f7jr3yyit0796dxMREIiIieOONN3zDt+Pi4hg1ahSDBw/miiuu4IUXXjjq0+1du3Zx0UUXMXHiRO677z7f8TVr1uB2u2ndujURERG+r3nz5rFtm3cJ9A0bNtCrVy+/6/Xp0+eE7vXIclarlR49erBhwwa/MkeONNm6dSulpaVcdNFFfvV5++23T6s+K1eu5MILLzyhOh/Lhg0b6Nevn9+xfv36HXU/R/79hoeHExUV5fd3eSZYz8RFq4PAzp07mT17tt9Dd0pKylE35XK5yM3NJSUlxVfmwIEDfmWqv/+1MtXnzwbl5fks2O5dRemCto1O6DUmk4nYCz+mcnoG7uLtYIkgv7yYitSrwGyjbaNIAHbnleF0e7D9SrgQERGRU2S2QYvR3iDQYrT3+zPMZvN/D5PJ5HeseniPx+MB4P333+f+++/nueeeo0+fPkRGRvLMM8/4hmYDTJo0iTvvvJMZM2bwwQcf8Ne//pWZM2fSu3dvABITE0lNTeW9995j9OjRvue64uJiLBYLy5cvx2Kx+NUrIiKi9m++BuHhh1dfrF6Z8quvvqJx48Z+5UJCQk75PUJDQ0/5tSerpr/f6r/LM6XWnxSrg8CWLVv4/vvviY+P9zvfp08f8vPzWb58ue/Y7Nmz8Xg8vqTWp08f5s+fj9N5OGHPnDmTNm3aEBsb6ysza9Ysv2vPnDnzhNNmfZBXsI8Ve733eH6b5BN+nclkIuTqbYQNL8ExLB9T4ytw7f4M18JRpEQ5CLVZcHsMdueWnqmqi4iICEDvN2FYpfe/9dCCBQvo27cvd9xxB127diUjI8P3KfmRunbtykMPPcTChQvp0KED06ZN850LDQ3lyy+/xOFwMHjwYIqKinyvcbvdZGdnk5GR4fdV/eFsu3bt/IIHwOLFi0+o7keWc7lcLF++nHbt2h2zfPv27QkJCWHXrl1H1ad6nmi7du1YunTpSdWnU6dORz1zHslut+N2u497jXbt2rFgwQK/YwsWLKB9+/bHfV1dOOkwUFxczMqVK1m5ciUAmZmZrFy5kl27duF0Ovntb3/LsmXLmDp1Km63m6ysLLKysqisrAS8jTFkyBBuv/12li5dyoIFCxg/fjzDhg0jNTUVgBtvvBG73c6YMWNYt24dH3zwAS+88AL33nuvrx533XUXM2bM4LnnnmPjxo088sgjLFu2jPHjx9dCs5x5LlcFm7MKKXcZRIRYaZMcefIXsYZhxoN9/xcAlG6dgslwkV61R0HmwZLarLKIiIjUpA56BE5Vq1atWLZsGd9++y2bN2/m4Ycf5qeffvKdz8zM5KGHHmLRokXs3LmT7777ji1bthz10B0eHs5XX32F1Wrlkksuobi4mNatWzNixAhGjhzJJ598QmZmJkuXLuWJJ57gq6++AvD1ODz77LNs2bKFl19+mRkzZpxQ3V955RU+/fRTNm7cyLhx48jLy2P06NHHLB8ZGcn999/PPffcw5QpU9i2bRs///wzL730ElOmTAHg97//PVu2bGHChAls2rSJadOmMXny5OPW429/+xvvvfcef/vb39iwYQNr1qzhqaee8p1v3rw58+fPZ+/evRw8WPMw7QkTJjB58mRee+01tmzZwvPPP88nn3zC/ffff0JtcUb96qyCX6iesPHLr1tuucU34aOmrzlz5viucejQIWP48OFGRESEERUVZdx6661GUVGR3/usWrXK6N+/vxESEmI0btzYbxJJtQ8//NBo3bq1YbfbjXPOOcf46quvTupeTmZyRW0rKtpvvPrtfKPZA18aN/7n2JN8TkTZ/BHG3jcx9r+F4Vl4q3HH1OVGswe+NP4zf1st1VZERKThqNUJxHVo4MCBxl133eV3rKbJqxyxwEt5ebkxatQoIzo62oiJiTH+8Ic/GA8++KDRuXNnwzAMIysryxg6dKjRqFEjw263G82aNTMmTpxouN3eBU2qJxBXKyoqMvr27Wucd955RnFxsVFZWWlMnDjRaN68uWGz2YxGjRoZV199tbF69eGFTN58800jLS3NCA0NNa644grj2WefPaEJxNOmTTPOPfdcw263G+3btzdmz57tK1P9PFo96beax+Mx/vWvfxlt2rQxbDabkZiYaAwePNiYN2+er8wXX3xhZGRkGCEhIcaAAQOMt95667gTiA3DMD7++GOjS5cuht1uNxISEoxrrrnGd27RokVGp06djJCQEKP60bqma7z66qtGixYtDJvNZrRu3dp4++23j/n3Vi06OtqYNGlSje1UWxOITVVvHpQKCwuJjo6moKCgzicT5+Rs4O/f7OeL9WXccX5L/jSk7Slfy3BXkvN2CC4DYmzwWtJ6XpqznRt7NeUfV3f89QuIiIgEkfLycjIzM0lPT8fhcAS6OvILO3bsID09nRUrVtClS5dAV6feOt7P8ck842p2aYBERqay6aA3h3VuEnNa1zJZ7IS1GA5AiQua5H8EoDkDIiIiInJcCgMBYrNHsSO3ah5Fyun3SoT18y5t5jQgIc+7W93B4srTvq6IiIiINFwKAwGyO7eUSpeHEKuZxrGnv2SV2erA2sS7/0BME+86tgeLK077uiIiIiJ1qXnz5hiGoSFCdURhIEC2ZnvXwm2RGIHFfPSW36fC2v0ZGLyYmG4TAMgtqcTjCdopISIiIiLyKxQGAmRrjjcMZCTV3qYcVqsDTFaiQrxr3bo9BnmlGiokIiIiIjVTGAiQbVU9Ay0Tw3+l5Imz2aqGG3nKiQnzrnmseQMiIiIiciwKAwFyZnoGvGHA5SojIcK77bbmDYiIiIjIsVgDXYFgdf/FbVi/r5CuTWNr7ZpWqwOTyYTH4yY+3MZWFAZERERE5NgUBgKkX0YC/TISavWaJpMJmy2MysoS4sK8nT45RQoDIiIiIlIzDRNqYGy2MABiQ70rFGnOgIiISMNw/vnnc/fdd59Q2blz52IymcjPzz+t92zevDn/+te/TusaUr8pDDQw1WEgIcy7pOi+/LJAVkdERERE6jGFgQbGbo8EoHGUB4DtB4sDWR0RERERqccUBhoYqzUEmy2UJjEWADJzSjAMbTwmIiJyLIZhUFrpCsjXqf6Ofuedd+jRoweRkZGkpKRw4403kp2dfVS5BQsW0KlTJxwOB71792bt2rV+53/88UcGDBhAaGgoTZo04c4776SkpOSU6iRnJ00gboAcjlhSo0oxm6Ck0k12UQXJUY5AV0tERKReKnO6aT/x24C89/q/DybMfvKPY06nk0cffZQ2bdqQnZ3Nvffey6hRo/j666/9yk2YMIEXXniBlJQU/vznP3PFFVewefNmbDYb27ZtY8iQITz22GO89dZb5OTkMH78eMaPH8+kSZNq6xalnlMYaIAcjmjs1n2kRlnYU+Bme06JwoCIiEgDMnr0aN+fW7RowYsvvkjPnj0pLi4mIuLwHkZ/+9vfuOiiiwCYMmUKaWlpfPrpp1x//fU88cQTjBgxwjcpuVWrVrz44osMHDiQ1157DYdDzw7BQGGgAbJaQzGbLTSJqQoDB4vp0zI+0NUSERGpl0JtFtb/fXDA3vtULF++nEceeYRVq1aRl5eHx+OdK7hr1y7at2/vK9enTx/fn+Pi4mjTpg0bNmwAYNWqVaxevZqpU6f6yhiGgcfjITMzk3bt2p1S3eTsojDQAJlMJuz2SFok5LNoZyWrdxcwolegayUiIlI/mUymUxqqEyglJSUMHjyYwYMHM3XqVBITE9m1axeDBw+msvLElxQvLi7md7/7HXfeeedR55o2bVqbVZZ67Oz5yZeT4nBE07XxAaYuL2Hx9kOBro6IiIjUko0bN3Lo0CGefPJJmjRpAsCyZctqLLt48WLfg31eXh6bN2/2feLfrVs31q9fT0ZGRt1UXOolrSbUQIWGxtG1cShmE+zMLdV+AyIiIg1E06ZNsdvtvPTSS2zfvp3PP/+cRx99tMayf//735k1axZr165l1KhRJCQkMHToUAAeeOABFi5cyPjx41m5ciVbtmzhs88+Y/z48XV4NxJoCgMNlMlkJjE2iTZJNgCWZKp3QEREpCFITExk8uTJfPTRR7Rv354nn3ySZ599tsayTz75JHfddRfdu3cnKyuLL774ArvdDkCnTp2YN28emzdvZsCAAXTt2pWJEyeSmppal7cjAWYygngR+sLCQqKjoykoKCAqKirQ1al1Tmcpj3y6lKk/l3BDzzSeurZzoKskIiIScOXl5WRmZpKenq4Vc+Ssdbyf45N5xlXPQANms4XRvWkYAIu2Hr0RiYiIiIgEN4WBBq5/m6aYTbArr5Kd2TmBro6IiIiI1CMKAw1cUmwKrRK9XUcrdx0IcG1EREREpD5RGAgCLZO8OxFuzy4McE1EREREpD5RGAgCLROjAdiRW47bfeKbkYiIiDRkQbyGijQA1btOny5tOhYEWlT1DOzOd+NyVWCx2ANcIxERkcCx2WyYTCZycnJITEzEZDIFukoiJ8wwDCorK8nJycFsNvuWij1VCgNBoHl8OAC781y43RVAZGArJCIiEkAWi4W0tDT27NnDjh07Al0dkVMSFhZG06ZNMZtPb6CPwkAQSE/whoGcEg9FZWWEhQW4QiIiIgEWERFBq1atcDqdga6KyEmzWCxYrdZa6dVSGAgCMWF24sKt5Ja42LC/kOT4o8t4PC4MdwUWW3jdV1BERCQALBYLFosl0NUQCShNIA4S3Zt6d59btrOoxvOHZt/AgXcicC0cVYe1EhEREZFAUhgIEr3S4wBYurOQyvJ8v3OGuxLnrk8AKN06BTzqMhUREREJBgoDQaJvRhIAq3cXsf/dRJw/3uw75wFofCUAlR5g6e/rvoIiIiIiUucUBoJE26RwEq2HKDccLC/rRO6Wd3H/eBOAd++BDn8GvGHAve0t9Q6IiIiIBAGFgSBhttq5OK0AgB+K++A2oGDrVFh0K263E0zWw70DTUaA2RbI6oqIiIhIHVAYCCIX/2YYAN+XXMieyhTKPeDePhmPq9RboONEGLyYig6PBK6SIiIiIlJnFAaCSL+W8XRuEkORy86jeY9jGFDmBvfy+wCwWkMoW/U0ZdPbwOIxAa6tiIiIiJxpCgNBxGox8++buhNiNbOmIJkVZR0pdkPljg/AXc7mgxaG/ng9N+54iQObPta8AREREZEGTmEgyKREO7i+RxMAPim+Ho/hnTRc8e0F3P3+Ooo8EWRWNuPu7Gc1b0BERESkgVMYCELXdk8DYFlhK+xmMyZgRVlHDlaG+sosOtSI5V9PCFANRURERKQuKAwEoQ6pUUSGWCn0RLDflU5yCKwo7wnADd2SuDzqOwAmrzJpqJCIiIhIA6YwEISsFjO9WsQDsDDja0zDKpjjuQ6AC89J44pWZQD8UNobD9aA1VNEREREziyFgSDVt2VVGNiez5r9pezJKyfUZqF/q0Q6D7yXMEsl+c4Q1n93f4BrKiIiIiJnisJAkOqb4Q0DP+3I5dMVewH4TbskwuxWwkNC6eZYAcCPG3dqqJCIiIhIA6UwEKRaJ0USH26ntNLNpAU7ALisYyMA7I44uqR4AFhpulirComIiIg0UAoDQcpsNtGnaqgQQPP4MC5qnwyA3R5B606XA7C+omVA6iciIiIiZ57CQBC796LWtEgIx2yCP1/aDpvF++NgMplonxoNwK7ccop/+F0gqykiIiIiZ4iWigliLRIj+Pae88grrSQp0uF3LjkqnATLIQ6649m0cT7d+zk1XEhERESkgVHPQJCzWcxHBQEAW0gUraJLAFgffpOCgIiIiEgDpDAgNbJaHbRq0Q6A9Y4rA1wbERERETkTFAakRhZLCK0Svb0B6/fl+45v2F/I7tzSANVKRERERGqTwoDUyGQy0Tb/vwBs3p+L22OwLaeYK1/+kYHPzOH9pbsCXEMREREROV0KA1Izj5P0vLcJMZVT5ray82ABczfl4HQbeAx49rtNuD1GoGspIiIiIqdBYUBqZrYRkn49LezeHoANWWUs3n7Id/pgcSXLd+YFqnYiIiIiUgsUBuSYrOe+SquMjgCs3VfAkqow0CIxHIBv12UFrG4iIiIicvoUBuSYbLZQWiXYAfjk5z0UlruICLFyx/kZAKzekx/A2omIiIjI6VIYkGPyrijkDQMHCisA6Nk8lnaNIgHYfKAYw9C8AREREZGzlcKAHJPJZKL1wX/6HevdIp6WiRGYTVBQ5iSnqCJAtRMRERGR06UwIMfmcZKY/SFNbXt8h3qnR+OweGgW7503sPlAcaBqJyIiIiKnSWFAjs1sI7L1aJ5K+xdDImczMu4jmi3pSelUO61sWwDYfKAowJUUERERkVNlDXQFpJ7r/Sa9u5eQ/m4EHgNKi6AUaO2ay3fcyJq9BYGuoYiIiIicIvUMyK8y2cKJaDHc79g5jvUALM3MDUSVRERERKQWKAzICQnvP4kQM5hN3u/bODZiwc3e/DL25JUGtnIiIiIickoUBuSEmCwhxLcdTbIdTGFNcJjKOSc6H4BlO7QTsYiIiMjZ6KTDwPz587niiitITU3FZDIxffp0v/OGYTBx4kQaNWpEaGgogwYNYsuWLX5lcnNzGTFiBFFRUcTExDBmzBiKi/1XpVm9ejUDBgzA4XDQpEkTnn766aPq8tFHH9G2bVscDgcdO3bk66+/PtnbkZPR+01MwyuxX/Q9NL6c9uZFAGzSJGIRERGRs9JJh4GSkhI6d+7MK6+8UuP5p59+mhdffJHXX3+dJUuWEB4ezuDBgykvL/eVGTFiBOvWrWPmzJl8+eWXzJ8/n7Fjx/rOFxYWcvHFF9OsWTOWL1/OM888wyOPPMIbb7zhK7Nw4UKGDx/OmDFjWLFiBUOHDmXo0KGsXbv2ZG9JTobZht0aAnu/pIl9LwDbshUGRERERM5GJuM0tpA1mUx8+umnDB06FPD2CqSmpnLfffdx//33A1BQUEBycjKTJ09m2LBhbNiwgfbt2/PTTz/Ro0cPAGbMmMGll17Knj17SE1N5bXXXuMvf/kLWVlZ2O3eHXAffPBBpk+fzsaNGwG44YYbKCkp4csvv/TVp3fv3nTp0oXXX3/9hOpfWFhIdHQ0BQUFREVFnWozBJ2KiiIOzb2Jn7bs5q49j5KRFMH39w4MdLVEREREhJN7xq3VOQOZmZlkZWUxaNAg37Ho6Gh69erFokXeISWLFi0iJibGFwQABg0ahNlsZsmSJb4y5513ni8IAAwePJhNmzaRl5fnK3Pk+1SXqX6fmlRUVFBYWOj3JSfPbg/H1OlvpF3wAgA7D5XgcnsCXCsREREROVm1GgaysrIASE5O9juenJzsO5eVlUVSUpLfeavVSlxcnF+Zmq5x5Hscq0z1+Zo88cQTREdH+76aNGlysrcogMlkxrbucZIXD8RhduF0G+zOKwt0tURERETkJAXVakIPPfQQBQUFvq/du3cHukpnJ48T+75PMJsMmtp2AbA9p/hXXiQiIiIi9U2thoGUlBQADhw44Hf8wIEDvnMpKSlkZ2f7nXe5XOTm5vqVqekaR77HscpUn69JSEgIUVFRfl9yCsw2QluOBCAl0rvxwL589QyIiIiInG1qNQykp6eTkpLCrFmzfMcKCwtZsmQJffr0AaBPnz7k5+ezfPlyX5nZs2fj8Xjo1auXr8z8+fNxOp2+MjNnzqRNmzbExsb6yhz5PtVlqt9HzixbvynYmgwlybUGgH0F5b/yChERERGpb046DBQXF7Ny5UpWrlwJeCcNr1y5kl27dmEymbj77rt57LHH+Pzzz1mzZg0jR44kNTXVt+JQu3btGDJkCLfffjtLly5lwYIFjB8/nmHDhpGamgrAjTfeiN1uZ8yYMaxbt44PPviAF154gXvvvddXj7vuuosZM2bw3HPPsXHjRh555BGWLVvG+PHjT79V5Nd5nNj2TSfZehCAfXklAa6QiIiIiJws68m+YNmyZVxwwQW+76sf0G+55RYmT57Mn/70J0pKShg7diz5+fn079+fGTNm4HA4fK+ZOnUq48eP58ILL8RsNnPttdfy4osv+s5HR0fz3XffMW7cOLp3705CQgITJ07024ugb9++TJs2jb/+9a/8+c9/plWrVkyfPp0OHTqcUkPISTLbsDQfRnK+d6+B/QWVAa6QiIiIiJys09pn4GynfQZOT2npQX5Yv5Hf/a+AxjGhLHjwN4GukoiIiEjQC9g+AxJczGYbyZHevSAOFJbj9gRtrhQRERE5KykMyCmzWOzEh5uxmMDlMThYXBHoKomIiIjISVAYkFNmsdiwmE0kRHh/jPZqeVERERGRs4rCgJwys9mKyWQiOcICwP58LS8qIiIicjZRGJDTYrHYSYr0hgFtPCYiIiJydlEYkNNisYSQXB0GChQGRERERM4mCgNyWhyOGJKr5gyoZ0BERETk7KIwIKclNDT2cM+AwoCIiIjIWUVhQE6L2WwlLS4SgH35pQGujYiIiIicDIUBOW3NEuIBOFTiotzpDnBtREREROREKQzIaUuOjSPCbgJgx8HiANdGRERERE6UwoCcNpstlGZxNgA27j8Y4NqIiIiIyIlSGJBakZEYBsDm/fmBrYiIiIiInDCFAakVGclRAGzN0TAhERERkbOFwoDUiraN4gDIPFiOx6NJxCIiIiJnA4UBqRXtUmMB2J7rYu+h3ADXRkREREROhMKA1Iq02DA6pYbi9sBHy3cFujoiIiIicgIUBqTWDOuZCsD/VhzE4zECXBsRERER+TUKA1Jrruraggi7iX0FLlr8+WuWbD8U6CqJiIiIyHEoDEitCXfYubxjrO/7Bz9ZhVs9BCIiIiL1lsKA1Ko7L2zLuU3tAGQeLOPjn/cEuEYiIiIiciwKA1KrUuNiefe2vtzRLwKAR79cT3ZheYBrJSIiIiI1URiQWme3hzOiRwwZCVaKyl3M3pgd6CqJiIiISA0UBuSMCHNE0aVx1XChQyUBro2IiIiI1ERhQM4Iq9VB0xgLAJk5CgMiIiIi9ZHCgJwRFoudtBgrAJkHFQZERERE6iOFATkjrNYQX8/AztxSLTEqIiIiUg8pDMgZYbHYSY60YLNApcvDvvyyQFdJRERERH5BYUDOCLPZhtVipnmst3dgzd6CANdIRERERH5JYUDOCJPJhGXtY3R2fQrAom2HAlwjEREREfklhQE5MzxOLHs/pXvoGgAWbz8Y4AqJiIiIyC8pDMiZYbYR2uJGuoStBWBLdgmHiisCXCkREREROZLCgJwxoQPeIbbp+TSx7QVg3b7CANdIRERERI6kMCBnjMlwE5b1Ba1DtgGwbvGbAa6RiIiIiBxJYUDOHLON8IyRtHZsB2Dt3jzwOANcKRERERGppjAgZ5Sl3xTOadIIgHXOzmC2BbhGIiIiIlJNYUDOuK4XPoQJgx2l0eydPT7Q1RERERGRKgoDcsY1iomhS6h3VaEvVu/TUCERERGRekJhQM44szWUIc2KAPiq7CoNFRIRERGpJxQGpE5cPOQPAKwriKXwh995D6qHQERERCSgrIGugASHJnExpNn2sceZyrK1P1O2/14+32Lmsb4FJF7wn0BXT0RERCQoKQxInbDaI+iaUMSe/TAx+3727IwAIOmn//HoQKeGDomIiIgEgIYJSZ3p3/M3AOwpi/Ad+7LgQkp+GB2oKomIiIgENYUBqTOXdWrE7ek/0dy+i99E/ABAnjuWz1Zux73glgDXTkRERCT4KAxInQlzRPH7kP9jWvM7eCz1KUbHfwjApwVDKNv2tiYUi4iIiNQxhQGpM2ZrKPFtRhFnA4cZbo7/FhMGP5V2Y2lxa1j6+0BXUURERCSoKAxI3eozCUfGKOLskN7+MoZ2aQTAo1l3kb3xQ/UOiIiIiNQhk2EYRqArESiFhYVER0dTUFBAVFRUoKsTXDzeFYQOFldw8dNfkFsZSu/wFbx/USb0fjPQtRMRERE5a53MM656BiQwqpYSTYgIYcqYXphxs7ikK5nrv1HvgIiIiEgdURiQgOvYrAm94vcB8KH7jwoDIiIiInVEYUDqhaED+gPwv52p7Hs7Cuf0jADXSERERKThUxiQeuHKLunEWfLIcSXQd/NnLNxvB1dpoKslIiIi0qApDEi9EOoIZ2Sr/b7vX869DaxhAayRiIiISMOnMCD1xvib7+MvQ5oD8FNRG7ZmFwe2QiIiIiINnMKA1BtWi5nRA1rTp3kIAF+v2f8rrxARERGR06EwIPWKxWJjYMtQAOZsPBDg2oiIiIg0bAoDUu/0r/g3ACt355NbUhng2oiIiIg0XAoDUr94nDTPfYeW9kwMTMz/6tFA10hERESkwVIYkPrFbCM84xb6RSwDYNa2Mm1CJiIiInKGKAxIvWPqO5nzW0YC8ENpHw6Weqh0eQJcKxEREZGGR2FA6qVelz5OnL2UfKeDHo99zx/f+znQVRIRERFpcBQGpF4Kszv4W9ITvu+/XXeAz1buZfn2/RiGEcCaiYiIiDQcCgNSL5ksdi7tcg7vNBtPmLkUgLveX8m1b/zMuGf+D5dbw4ZERERETpfCgNRbtv7v0LdjP26Ne9/v+Ne5PfnspzUBqpWIiIhIw6EwIPWapf+73NQ5hBGx/+PfTe7nxthPAZi9OU/DhUREREROU62HAbfbzcMPP0x6ejqhoaG0bNmSRx991O/BzTAMJk6cSKNGjQgNDWXQoEFs2bLF7zq5ubmMGDGCqKgoYmJiGDNmDMXFxX5lVq9ezYABA3A4HDRp0oSnn366tm9H6oHkC97iTymTuSB6I5fGeJccXbyjjIqKwgDXTEREROTsVuth4KmnnuK1117j5ZdfZsOGDTz11FM8/fTTvPTSS74yTz/9NC+++CKvv/46S5YsITw8nMGDB1NeXu4rM2LECNatW8fMmTP58ssvmT9/PmPHjvWdLyws5OKLL6ZZs2YsX76cZ555hkceeYQ33nijtm9JAsxsdRDdZjR2M/Ts0BOHzcShUg+rd2UFumoiIiIiZzWTUctjLS6//HKSk5N58803fceuvfZaQkNDeffddzEMg9TUVO677z7uv/9+AAoKCkhOTmby5MkMGzaMDRs20L59e3766Sd69OgBwIwZM7j00kvZs2cPqampvPbaa/zlL38hKysLu90OwIMPPsj06dPZuHHjCdW1sLCQ6OhoCgoKiIqKqs1mkDPB4wSzjVveXMi8LXmM6x/DhMv7BbpWIiIiIvXKyTzj1nrPQN++fZk1axabN28GYNWqVfz4449ccsklAGRmZpKVlcWgQYN8r4mOjqZXr14sWrQIgEWLFhETE+MLAgCDBg3CbDazZMkSX5nzzjvPFwQABg8ezKZNm8jLy6uxbhUVFRQWFvp9yVnEbAPggraNAFi0o5Ty8vwAVkhERETk7FbrYeDBBx9k2LBhtG3bFpvNRteuXbn77rsZMWIEAFlZ3qEdycnJfq9LTk72ncvKyiIpKcnvvNVqJS4uzq9MTdc48j1+6YknniA6Otr31aRJk9O8WwmE89t4fzZW7a3kw8VrKS4+EOAaiYiIiJydaj0MfPjhh0ydOpVp06bx888/M2XKFJ599lmmTJlS22910h566CEKCgp8X7t37w50leQUNE8IZ2iXRrgNeGxmARt276C09GCgqyUiIiJy1qn1MDBhwgRf70DHjh25+eabueeee3jiCe9usikpKQAcOOD/ae6BAwd851JSUsjOzvY773K5yM3N9StT0zWOfI9fCgkJISoqyu9Lzk7PX9+Vfi3jqXTD378rYF/ODpzOskBXS0REROSsUuthoLS0FLPZ/7IWiwWPx7tjbHp6OikpKcyaNct3vrCwkCVLltCnTx8A+vTpQ35+PsuXL/eVmT17Nh6Ph169evnKzJ8/H6fT6Sszc+ZM2rRpQ2xsbG3fltQzZrOJvw/tQGSIlTX7nbz8QyElJRouJCIiInIyaj0MXHHFFTz++ON89dVX7Nixg08//ZTnn3+eq6++GgCTycTdd9/NY489xueff86aNWsYOXIkqampDB06FIB27doxZMgQbr/9dpYuXcqCBQsYP348w4YNIzU1FYAbb7wRu93OmDFjWLduHR988AEvvPAC9957b23fktRTLRMjeHF4VwBmby2nuFQbkYmIiIicDGttX/Cll17i4Ycf5o477iA7O5vU1FR+97vfMXHiRF+ZP/3pT5SUlDB27Fjy8/Pp378/M2bMwOFw+MpMnTqV8ePHc+GFF2I2m7n22mt58cUXfeejo6P57rvvGDduHN27dychIYGJEyf67UUgDd+AVgnEhtnIK3Xy8+4yEuOLCQmJDHS1RERERM4Ktb7PwNlE+ww0DH/63yo+XLaHS9o6eOqatkRFNQ50leQsVlzhYvXufHq1iMdiNgW6OiIiIictoPsMiNS1Eb2aAfDd5nJ2ZmvegJye0ZN/4sb/LmHakp2BroqIiMgZpzAgZ73OTWLolR6L2wPv/u81PItuDXSV5Cy2NDMXgM9X7QtwTURERM48hQFpEP4wMB2AzwsGk73pI/A4f+UVIkfzeA6PmmwWHx7AmoiIiNQNhQFpEAa2SaFlRD5lRihfmf4IZlugqyRnob35h/eqaBTtOE5JERGRhkFhQBoEk8nElb28y4zO3OnAs+CWANdIzkZbsot8f/YE79oKIiISRBQGpMG4rKN3D4plpZ1ZtnYuaO6AnKTtOSW+P7vcCgMiItLwKQxIg5GREkPv+AO4sPHH3Y+Qt/kDzR2Qk1Lh8vj+XOn2HKekiIhIw6AwIA3K6+NuonFoEQdcSbxwYBgs/X2gqyRnEecRAcCpMCAiIkFAYUAalJgwOw9f1R2AaXlXcGDjJ+odkBN25NAgp0vDhEREpOFTGJAGZ3DnDDpEZ1Np2Hk1+1r1DsgJc3rUMyAiIsFFYUAaHJPJxLhL+gLwTu6VLF+zUL0DckLcR/YMeNQzICIiDZ/CgDRIQzq34uLkrXiwMHb3o+wrVBiQX+fyHDlMSD0DIiLS8CkMSINkMpmZeOPlZDj2cKgylFfemgjArkOlXPvaQp6asRG3PvmVX9AEYhERCTYKA9JgNYqJZ3z8fwH46lA3yn+8hQc/Wc3ynXm8Nncbr8/bFuAaSn1z5ARiLS0qIiLBQGFAGixLSAyXpRUQb8kl3x1N/xmDWLjtkO/8wuXzA1g7qY+OHCakTcdERCQYKAxIg2a7ejN/aLMFgIOuOAAGhC8CYHuBSbsUix+XVhMSEZEgozAgDd6YEX/l1vgPSbLm0D98MX9KfgWA/c4kyra9Bx4n5eUFVJbnadWhIOe3z4DCgIiIBAFroCsgcqaZLHYm9rfw4LZbsQBuIMpSTKE7gszEO2jpLCN33k2w90uirRDeejT0fjPQ1ZYAODIAVGqYkIiIBAH1DEhQMPV5i5AbK7HeWIltWBlNEmMB2J5yH0U/3AJ7vwSg0AWVW99SD0GQcvvNGVDPgIiINHwKAxI8zDYw2zBbHTSLtQOwYW82lbumAxBiBgModqFdi4PUkRuNaZiQiIgEA4UBCUqdjO8B+GntMmh8JRYTRLW8EYAKDzi3vkVZ0d5AVlECwOW3z4CGCYmISMOnMCDBx+Okj/NtAFblxbEw4n7+5JrNA/snkJM4AgPIsaaR91Ea5fNvDGxdpU5pnwEREQk2mkAswcdso327C4jZkU++O4b7vyisOlHKztgLeClxKpTuAaB4+3s4bCHQZ1Lg6it15silRTVnQEREgoF6BiQo2fpPYUjqbt/3LSIKAFiRl4iHUMwm7/FKD7i3T9aE4iDh8pszoGFCIiLS8CkMSHDyOPlr5F94KPkFbo9/ly+a3kLTuFA8WNjqbEdKCFjDmwDganaTd/KxNHhODRMSEZEgo2FCEpzMNiJaj+LWrW/hMiCs1WjODY1nV+4eljR9h/MHt8KavwtX2UFcMemEBLq+Uif8JxArDIiISMP3/+zdd3wUZeLH8c/2Ta8kIfQmvYMSESuKir0jIpzt9MB6P/XU0/O8oufp2cvpKaCCvSFWRASUpvSi9B5SSNuU7Tu/PzZZEgk9BZLv+/XKy+zMs7PPjCGZ7zxNYUCaryGvYT/+ZewAZhsn2nfwweIdfLEql5OPS8fwh2gfbyUQ8DR2TaWBVF9nwDDCry1VfcZERESaIIUBad6qdf85s0c6ZhNsLahg1KsLMAGvX5VCn1aljVc/aVD+UM3WAH8whMVsaaTaiIiI1D+NGRCpFOe0MbJPZuS1AXw7byb+6b0w5l/XeBWTBhP4zaBhjRsQEZGmTmFApJo/ndONCad1ZYoQPAABAABJREFU5t6zuwEwe1cawRB4NkzUjELNwG9nEPIHFAZERKRpUxgQqaZVYhT/N6IrY7LaYbeY2eHPZKu/Na4AuOeOwTA03WRTFvxNN6HqU42KiIg0RQoDIrWIdVgZ1D4JgMUV/QgaULTxXUo+aN+4FZN6tVc3IbUMiIhIE6cwILIPw7q0AGAp52Gv/JdSUboN79xRjVgrqU+1DSAWERFpyhQGRPZhWJdUABYWtyMhoQsxlZPKVGx6R+MHmqjftgxoFWIREWnqFAZE9qFHy3iSY+yU+4Is7beAqI7hFgFvCIyFv2/k2kldMwwjMkbAWrm2gFoGRESkqVMYENkHs9nE0M7h1oEf1udjHzoZiwlCRuXsQoGKRq6h1KXqC45F2cPNQAoDIiLS1CkMiOxHVVehOet3g9lGdMerACjyQ/nUGFhwfWNWT+pQ9ZmDoiNhQN2ERESkaVMYENmPqjCwYkcxJRV+YoZOxFS5zxUAY+PrGj/QRFRvBXDawmEgEFLLgIiING0KAyL70TIhik4tYggZ8NHSHeSVQ4tuY4HwCsXBDmPBbGvcSkqdqD542GE177VNRESkKVIYEDmAqilG//rZGoY8OpNPHH/HNnIZjFhAYMAzjVs5qTPVuwk5rOGWgaAWHRMRkSZOYUDkAK4Y1IaWCc7I6/s/Wkm+xwkmK4GApxFrJnWpqkuQzWyCkKdym8KAiIg0bQoDIgfQIzOe+fedwaZ/nkuf1gn4giF+3u4DIOArbeTaSV2p6hJkMYPZFA4GQY0ZEBGRJk5hQOQgmc0msjqmALB6lxdWPkJgWhfNKNREVA0gtpjBYqpaZ0AtAyIi0rQpDIgcgv5tEwH4YvVufNu/wBcC/wbNKNQUBCMLjoUDQfVtIiIiTZXCgMgh6NcmCYBST5Drd00kYJgpDwKLbm7ciskRq2oFsJpNVE4mpDEDIiLS5CkMiByCjAQnF/TNBGBjeRKzSk+iIgg+tQ4c86oGEIdbBsLdhAJagVhERJo4hQGRQ/TsqP7cOfw4AJ4vuIkdvgx2+8A777oa5UKaaeiY4o8MIDZFugmpZUBERJo6hQGRw/C7k9rTJS2GfH8iz+eHBxCXbXgr0jpQ+v0oct6IomL2qMasphyC6mMGrJUtAxozICIiTZ3CgMhhiHfaeHbUAADmlGdx146HyfXH459/A35vCaWb3gGgeOM7hOaNbcyqykEKRGYT2tMy4Fc3IRERaeIUBkQOU7eMODLiw4uRLagYxLSSs3BvfAN3eV6Ncu4Nb2g8wTHAX302oXDDgFoGRESkyVMYEDlMJpOJ605qH3k9v3wQ7iD4l94HrS7AVnlD6c68GMy2xqmkHLSqlgGrxbRnALHCgIiINHEKAyJH4MZhHfng5iwAVrm7UxSIxbv1Q+hxD3FX5kOr8/Bt+5jgvHGNW1E5oKobf4uJyNSiahkQEZGmTmFA5AiYTCYGtU+mW0YcQSw8mXczhgHMOAnHsv/DsWs6AO4Nk9VV6CgXCFZfdExTi4qISPOgMCBSB/5xcS8sZhMzSk/lM9dZ2M1g2jIZZ4erACgPQmjBDY1cS9mfyDoDFk0tKiIizYfCgEgdGNgumf87qysAT+T+gW9cZzLV/AhFPV/EBAQNyF/7Bv65o9VCcJTyB6tPLRrepm5CIiLS1CkMiNSR35/ckYv6ZRLAyv3Zt3P/sgGc9exCilvejNUUDgS710/FN9UOC65v7OrKbwQrWwYsJhMWU7ibUFVAEBERaaoUBkTqiNls4skr+tG9ZXxkW4UvyDe2u0g97hocZjAIdxli0+tqITjKRFoGLES6CVUFBBERkaZKYUCkDlnMJl64uj9n9khnZO+WACzaUoB56JvEdLwagEAI6Hidphs9ykSmFjVralEREWk+rI1dAZGmpmOLWF69dhBrc0r5fOUulmwtxh8MYRs6ETrdRgATRkY/TI1dUakhMrVotTEDAXUTEhGRJk4tAyL1pEtaLEnRNtz+ID9tKcRisWO2ONiw4AU+e+kkjPnXNXYVpZpA9RWINZuQiIg0E2oZEKknZrOJET0zeOen7Vz96kIu6peJJf9bPtp5GQZmLKaHOGegC7M9/sAHk3pX1U3IYt4zgFhjBkREpKlTy4BIPbqof6vI958sy+bDnT0wKv/ZfePKIn9KAqF5YxurelKNP6iWARERaX4UBkTq0fHtkzm/b2bkdd+kQia0eAeAT0vO4em863CtewPm/66xqiiVIouOmU1YIysQKwyIiEjTpm5CIvXIbDbx3Kj+PDeqP6GQgdlswuO9nMl/+4rSgI23iy6hvX07N26ahPmEVzTDUCOqahmwqGVARESaEbUMiDQQc+XTZqfDyRs3nUK3jFgAXto9lnyfHRbd3JjVa/YCwSBQNbVoeJvGDIiISFNXL2Fg586dXHPNNaSkpBAVFUXv3r35+eefI/sNw+Chhx6iZcuWREVFMXz4cNavX1/jGIWFhYwePZr4+HgSExO5/vrrKSsrq1FmxYoVDBs2DKfTSZs2bXj88cfr43RE6lz/tkl8duswMhNsFAcT+bDodMrXHcRCZFqorN4Eqo0ZsGqdARERaSbqPAwUFRUxdOhQbDYbX375JWvWrOHJJ58kKSkpUubxxx/n2Wef5eWXX2bhwoXExMQwYsQIPB5PpMzo0aNZvXo1M2bMYPr06cyZM4ebbropst/lcnHWWWfRrl07Fi9ezL///W8efvhhXnnllbo+JZF6YbOYuX5oBwA+KzmLimA4KJeV5VJenodh7HkqHQoFKfruclxv2THmjWukGjdt/lpaBjRmQEREmro6HzPwr3/9izZt2jBx4sTItg4dOkS+NwyDp59+mj//+c9ceOGFALzxxhukp6fzySefcNVVV/HLL7/w1Vdf8dNPPzFo0CAAnnvuOc4991yeeOIJMjMzmTJlCj6fj9dffx273U7Pnj1ZtmwZ//nPf2qEhuq8Xi9erzfy2uVy1fXpixySC/q35R9frOUX73G8uvsKcl94ljOHnMiA1g683lKSkzsBUF66A/eWDwAIrp9MkskEWRMJ+Eoxm62YrVGNeRpNQo0xA6aqlgF1ExIRkaatzlsGpk2bxqBBg7j88stJS0ujf//+vPrqq5H9mzdvJicnh+HDh0e2JSQkcMIJJzB//nwA5s+fT2JiYiQIAAwfPhyz2czChQsjZU4++WTsdnukzIgRI1i7di1FRUW11u3RRx8lISEh8tWmTZs6PXeRQ9UizsHxHZIBeKXgWj7N7s5tHxexNs+Px1OM212E211E+cLbI+9xB8G3cRKFMy8l7614Ct+KhgXXN9YpNBlV4wOsFrNaBkREpNmo8zCwadMmXnrpJbp06cLXX3/NLbfcwm233cbkyZMByMnJASA9Pb3G+9LT0yP7cnJySEtLq7HfarWSnJxco0xtx6j+Gb913333UVJSEvnavn37EZ6tyJEbf3oXHOZg5HXIgOd+qACgqGgTRYXrCO34FKsJoizhMrt94Nn6EQC+EIQ27j3eIBj0UV6aXaO7keybv3LRMZvFjDUym5CunYiING113k0oFAoxaNAg/vnPfwLQv39/Vq1axcsvv8zYsY27uJLD4cDhcDRqHUR+a1iXFnx3z5mszS6ia2YSpzw+iyU73GwpjKV9sgVMVmh1ATG504iK74SvaCO/fWDtazsaayhI0O/B4YjD7S6i7Mfr8W/7GE/bS0g+7W1MFnvtFRBgz42/zWLGYg5f4KAGEIuISBNX5y0DLVu2pEePHjW2de/enW3btgGQkZEBQG5ubo0yubm5kX0ZGRnk5eXV2B8IBCgsLKxRprZjVP8MkWNFq8QoTu+RSavEKE7rFm4Vm7kllpYtBxAdnYJj0BNEj/aQe9pKEjqNxmYGiwmcZuDMHyjsdCd5easpKFhHTs5yigrX4d/2MQDebR9R+KYDY/51jXiGR789KxCbNJuQiIg0G3UeBoYOHcratWtrbFu3bh3t2rUDwoOJMzIymDlzZmS/y+Vi4cKFZGVlAZCVlUVxcTGLFy+OlPnuu+8IhUKccMIJkTJz5szB79/TNWLGjBl07dq1xsxFIseaUceHx7K89sNmXvx+I47oNqSkdGHi/GyyHv2OJ1z3k3zcOO7LfogzN33A/36q2T0oFApUtiacB4AJ8IbAvWGipibdj6pWAKvZhK1y0EAgqG5CIiLStNV5GLjzzjtZsGAB//znP9mwYQNTp07llVdeYfz48QCYTCbuuOMO/v73vzNt2jRWrlzJtddeS2ZmJhdddBEQbkk4++yzufHGG1m0aBE//vgjEyZM4KqrriIzMxOAq6++GrvdzvXXX8/q1at59913eeaZZ7jrrrvq+pREGtRpXdM4tWsLAP799VoufWkec9fn88j0NQD874fN/JD6ON+VHk+Bz8lbiyuwONJo0aI7CQltMVXOhGPu+zeSOo8ivrIzYGkAjAU3Nso5HQuqxgyEBxCrZUBERJqHOh8zMHjwYD7++GPuu+8+HnnkETp06MDTTz/N6NGjI2XuueceysvLuemmmyguLuakk07iq6++wul0RspMmTKFCRMmcMYZZ2A2m7n00kt59tlnI/sTEhL45ptvGD9+PAMHDiQ1NZWHHnpon9OKihwrTCYTT1/Zj5dmb+Tdn7azZpeLMa8tqlHmxjf2LOLnCxqsyXdwWko0Nls0UVHJmEwmTCYzZEzFyHqV8rdiCRhQtmEycZXTkkpNgeoDiC3h7zVmQEREmjqTYRjN9q+dy+UiISGBkpIS4uPjG7s6InvZvLucy1+ex+4yHwDjTmzPpHlbIvtj7BbKfUEGtE3kupM60Dopmmi7hTnr8jm9WxodW8QC4J5zNUUb3sYEJNvBcbUPzLZGOKOj1yUvzGHJ9lIev6Al6bEGY6fmkBZnZ9EDZzZ21URERA7Jodzj1nnLgIjUnQ6pMXx260m8OGsj7VKi+d3QDizZVsSKHSV0SYvl/nO787tJP7FkWzFLpi6t8d7Plmfz6YSTAIg6eSpuvxfP1o8o8EHMh11IuHxLI5zR0SsyZsBixqaWARERaSYUBkSOci0TovjbRb0ir9+47nhW7ChhSMcU7FYzr40dxP/mbqbCH2T59uJIueU7Sti8u5wOqTEAJA6bSMmOj3AHobx0K865o3AMe7uhT+eoFai26Ji1cj0HhQEREWnqFAZEjjGJ0XZOPq5F5PUZ3dM5o3t4wb2vVu3CGwjx4ZKdzFmXz5QFW+maEYfHH2RMVnuSEjtjFG3AEwL/5ndwDH1D3YUqVU0taqsWBvxagVhERJo4hQGRJuTsXi0BiLZbmbMun//9sDmyb2C7ZHpcuB7b95fj2fQBgTaXKwhUE6gxtWg4DahlQEREmro6n1pURBrfmT3SuTarXY1tX6zcBYBtyKswYgH+Xn9tjKodtfaMGbBgrVpnQGFARESaOIUBkSbqrxf05LWxgxjYLrwI3+crd2EYBlZrFJisBAJumvFkYnvZ003IhNUcbhkIhAxdIxERadIUBkSaKJPJxBnd05l83fE4rGY27y5nzS4XVqsDs9mKYRiUlmY3djWPGlWtALZqLQMAahwQEZGmTGFApImLdVg5rWsaAJ+vCHcVSkhoA0BZWQ4+X/kRf4ZhGBDyH/FxGlOg2grEVWMGYM8sQyIiIk2RwoBIM3Be3/DA4qquQlFRyTidiQDs3v0rLtcODMMgGPRRVLQZt7vo4A4c8hMKBcn/9mLyJtsJ/DCmns6g/lVmgcqpRff8atSMQiIi0pRpNiGRZuD0bmk4bWa2FlSwOttFr1YJxMe3wucrIxQKUFaWS1lZbqS8212Iw9EPs9lS6/H8fjdF348ietenBJxtCZRtA6Bo/Vu0sFgha2KDnFdd2tNNyIzDVq1lIKiWARERabrUMiDSDETbrZzRLbwWweUvz+eOd5aypTBARkZfEhLa1vqe8vLcWrcbRoiiWVcS2P4prgBUVAYBAL8B/o2TjskuQzXGDJjNmCq3+wIKAyIi0nQpDIg0E1efEL7pd/uDfLIsm4tf/JG8Ug8xMS1ISuqI05mIybTnV0Jp6S6Ki7cQCgX3HCTkp+S7ywns+CyyyQQk2sAZFz6+JwQsujlS/lgJBoFqi46ZzRaqGgd8ahkQEZEmTGFApJkY2jmVSwa0irwu9QSY9OMWAKKikkhO7kTLlv3JzByI1eoEoKKigKKijRiGgf/Hsex+w07F1o8ASLZBojOGFnaIju9M1LmLACgPQnDj6xR/dzm737DjnmKHBdc37MkeIsMwqBoaYLWYMZnM2CzhtgGNGRARkaZMYUCkGXny8r7MvvtUXhkzEIApC7fV2ic+KakDDkccAF5vKV53Aa71b+CrLJpoA2ena4m+ugzrVeVw4XqcziTs5vBUnHleqNjyAb4QlAaATa8f1S0E1RcXs1ks4TBQ+dtR3YRERKQpUxgQaUZMJhPtUmI4o3s6CVE2Stx+lu8o2auczRZNSspxxMaGxxmUlGbjbXkBEG4RiO48Dk6cHC5sjQ4f22Inocu1mIDqz9KDBtDxOjDb6u/EjlAgWEsYiLQMKAyIiEjTpTAg0gxZzCZO6pwKwOs/bCa0j5W1oqNbYDKZCQb90PshTCMW4hzt2+dsQbas/xH3mznKjDN/IHT8K3Va/7rmr7aWgO033YS8ahkQEZEmTGFApJka1iUcBj5fuYuzn5lDdrF7rzJWq4PU1K5YLHYAomLS9/+E32wj9rjrSHdAmh3MrS8Ei5PQUdxFCH7bMlAVBsKv1TIgIiJNmcKASDN1ft9MLuyXidVsYl1uGS99v7HWcjZbNC1a9CAhoQ1xcZkHPvCQ17CM8mG92oe53z8Awi0LR7GqcQEWM1jUTUhERJoRhQGRZirGYeWZq/rz4ugBAHyxctc+F9gymy3ExKRhsRxkv3+zDcy2SPmjvWWgKgzYLSbAhMlkxqoBxCIi0gwoDIg0c6d1SyMp2kZBuY9T/v09/5mxrs6ehpsruxQd9S0DwfBaCjYLmEzhbkJ2tQyIiEgzoDAg0szZLGbuO6c7ZhPsLHbz7Mz1PPTpqjo5dlXLgK8iD7/XVSfHrA/eai0DJlNly4AGEIuISDOgMCAiXDG4DV/cPoxxJ7YH4NNl2XgDwX2WNwyDxVsLKXHv/4m/xWKHORfjmd6H/CkJlM8edVSuN1DVFchmMVVrGajat+/rICIicqxTGBARALplxPOX83uQHu+gwhdk4abCfZZ9efYmLn1pPre8tXi/x4yyRRHr3Y698jdNycZ3KH/r6FuRuCr4hGcQMtUYQKwwICIiTZnCgIhEmEwmTuuaBsC1ry9i1CsL2PmbKUc35pfxr69+BWDexgIWbirY5/HM9jjik7qQaoeYyiftrgAYG4+uFYm9/vANv72yZSD8ffi/3kCg0eolIiJS3xQGRKSGa4a0w145lc78TQXcMPnnGoNo3164rUb5V+du3v8BL1gHV5STcNw4LKbw6sTeNlcfVSsS+yItA+ExA1XfA/j8ahkQEZGmS2FARGro1SqBV8YMpGdmPAC/7HLx1aocANy+IB8u2QHAA+d2B+C7X3PZlF+2/4NaoyFrIs6LNkKr83Bvngrzf1d/J3GIqp7+V80gBOGB1aBuQiIi0rQpDIjIXk7tmsbntw3jjuFdAHjim7Xc+e4yuj/0FUUVflonRfG7oe0Z2jmFkAEXvziPb9fkHvC4UVFJsHM67iBUbJh01ASC6t2EqlS1jigMiIhIU6YwICL7dM2QdiRG29haUMHHS3dGtt90ckesFjOPX9aXvq0TKHH7+f1bi1m1s2S/x7M7k4jtcDkA7iCwedJRMXag6oa/KgBU/75qDQIREZGmSGFARPYpNdbBR7ecyIie6fRvm8hpXVtw+xlduGpwWwBaJUbx/s0nMrx7OsGQwT0frDjgIl1RJ02CVufhN8Do8LujYuyAt9qYgSp2i6XGPhERkabI2tgVEJGjW8cWsfx3zKB97rdbzTx6SW9+fqqQNbtcvDp3E384tfM+y1utUZj6PEKox5/wpfXBUR+VPkT7axnwa9ExERFpwtQyICJHrEWcgwdH9gDgpVkbKSr37bOsyWTCvuYfMOMkCmePIRjcd9mGsmfMQPUwoJYBERFp+hQGRKROXNy/Fd1bxlPqDTBp3pZ9Fwz5Sdj1YXia0R2fUlqytcHquC/eWlsGwmHgQN2eREREjmUKAyJSJ8xmE7ec2gmADxbvIBQy9lHQhrXzdSTZgFYXUOFxEQw27iBiX2VXoOphwFY5ZsCnbkIiItKEKQyISJ05q0c68U4rO4vdfFm5NkGthryG/WoftgGPAeDxFDdMBfehasag6t2EHDa1DIiISNOnMCAidcZpszAmqx0AD3yykuxi974Lm23hdQc4CsJA5dN/R/VuQlUtAwoDIiLShCkMiEiduv2M4+jdKoHiCj/jpy6h1LPvLkBOZzgM+HylhEKBhqriXryRbkKWyDaHLTzZmroJiYhIU6YwICJ1ym4189yo/sQ5rCzdVswf31u+z7JWqwObLQrDMPB4ai5Y5vdXUFi4kaKizRhG/d6Q19Yy4LCF1z9QNyEREWnKFAZEpM61T41h0nWDAZj5ax4l7gO3DlRU7K6x3eXaicdTjNtduFdQqGtVXYGqDyB2VoYBX8A4KqY/FRERqQ8KAyJSLwa2S6ZzWizBkMGcdfn7LBcdnYLJZMbnK8PjKSYY9JObuxKv1xUp4/eX12tdfbV0E6r6PhBSGBARkaZLYUBE6s0Z3dIA+HTZzn2WsVjsxMSEyxUWbiQvb+VeN98+Xz2HgWBVN6E9YcBWObOQPwiBgLdeP19ERKSxKAyISL25fFAbzCb49pc8lmwr2me52NgMzObwgF3D2LM+gcVS2W/fX15je13zB8LHrtkyEP716AsaBIMKAyIi0jQpDIhIvemcFstlA1sD8PL3G/dZzmy2kJTUscY2q9VBSspxmM0WDMOgvDyP3bt/xe+v2FMo5A9/HSFvVcuAbU8YiLaHv3f7DbUMiIhIk6UwICL16qaTw6sSz/gll60F++7u43DEkZzcOfI6NbU7X60p5Lm5ZfiDBi7XDny+cooLN2AYIdZ88Tvu+/cfWD+xDSy4/ojqWNUyUL2bUIwj3FLh9hv1PmZBRESksSgMiEi96pwWyynHtcAw4IPFO/ZZLhgyuPODDfzunWLyPEms2VXGhKlLmbK4hK/XVi5etvIR/J/3ZftXl3PR3PN5u+ginsodDZteP6IWgsiYgcoZhABiqrUM+P0egsEjb4EQERE52igMiEi9q+oq9NGSnYRCtff9/9/cTXy5Koe1eR5ufHsTj375S2TftFVuMAJ4dnwDwPRfKvAZDgBmlp6Iz9kRzLZaj3sghmHgC4br5KxcaAz2tAyEDPAG6n9GIxERkcagMCAi9e7MHunEOa3sLHYzu5ZpRtfnlvLkjHWR1/mlXn7cUBB5vSrHzxPfV3D6+g/4e87/8aXr9Mg+r+FkTb6L4I/XHlbdDCOILzKAeE+giKo2fqDCH6o5VuEYFgwZfLFyFzuL3Y1dFREROQooDIhIvXPaLFw1uA0A//56LQVlewbkBoIh/u/95fgCIU7t2oIpN5xQ473dW8YB8NHK8M34F65TWenpAUCSJbwY2TJ3Tyo2vnlYXYVCoQBufzgMxDn3tAyYzabIIOIKX9MZRPy36Wv4w5QlnP/cD2zKL2vs6oiISCNTGBCRBjFuaAeibBbW7HKR9eh3jJ+yhO/X5jFp3haW7ygh3mnlsUv6cGKnlBrvO61rWuT7KJsFq9kEwEWJs7i0fR4Ay9y9cAeBRTcfcr1CoSDlvnAYqOoaVKX6IOKmsPBYdrGbSfO2AFBY7uOpb9c3boVERKTRKQyISINolRjFe7/Pok/rBHzBEJ+v3MW4iT/x98/DYwPuPacbGQlOTCYTz1/dH4C/XtCTk7qkAuEg8O0fT+Htm4bwwtUD+M///ZPjT7wKgOXuHgQMCG089IHEHp+PygWI9w4D1QYRHxVrDRzhNKrLtxfXeP316hxKKjQwWkSkObMeuIiISN3o3TqBaRNOYnV2Ce//vIOPl+6kxO2nW0YcVw5qEyl3Xp9MTu2aFrkZ/9uFPTkuPY5WiVG0SoyKlBvcPhmAzb52FAXiadH1IsyHOJC4zLvniX/sb8JAtD38usJnEAz6MYwQJlPDPUMxgl783hJsUamUzr4a6/Z3ie5yHQx57bCOt3JnuFvVVYPbsGx7Mb/mlPLV6l1cObhtXVZbRESOIQoDItLgemYm0POCBO4/tzvr80ppnRSN1VLzJrv6jfmYrPa1Hicpxk7HFjFsyi9nXe/pdOrfm0OdU8jlDj/xd9pMWCq7IP22Dp5geHsg4MVmi6IhlM2+mvJNbxM0wBLVmqA7PC2rY+PrWI5/+bBmT6oKA71aJZCZGMWvOaXMWJOrMCAi0oypm5CINBq71UzPzAQSog5vWlCALmmxAGwpOrx+/WWecDeZWLtlr33RjvA2TyD834aYUcjvr2B33kpcG8NBAIgEAYCyAIc1NsIwDFZVhoHerRI4s0c6AHPX78btCx5xvUVE5NikMCAix7TOlWFga2HgsMJAaWUYiHHsHQaqxhD4Qvbwf32lh1vNvYRCAQoK1lFcvIVQKHwz7vW62L37V3xL/wxArAVS7VC9wcIb4rAWWdtZ7Kaowo/VbKJrRhzdMuJIj3fgDYQiLQYiItL8KAyIyDGtKgxsPswwUObdTxiobC3whcItF15v3YWB8vJ8vN5SKioKcLm2V27Lwwj5sWRPI84KcVawd7yGNDuk2YHoNuGB0h3GHXI3oZU7wjf8x6XH4bRZMJlM9G+TBMDSbUV1dl4iInJs0ZgBETmmdUkLr0OwtTBwWGsB7LebkL1qzED4uUkw6CMY9GOxHH63pipu955F1SoqCvB4SgiFAmCyknLctVi3vgEdw4OFzUNexwxYd68l4C/Hn9odxyF+3spqXYSq9G+byFerc1i6rfiIz0dERI5NahkQkWNaxxYxABR7DApKKzAM45DeX+oJtybEOve+wa8aQFzhC2G1hm+/A4EjX7nX6y0lEPBiNluwWMJdkEKhAAA2WzTWoZPhKt+eWYPMNjDbsNliwGSlvHzvVZwPZPHW8NP/3q2rh4Fwy8CSbUWHfN1ERKRpUBgQkWNatN1KWlz4Rn1HsY9AwHNI76/qJhTr2DsMVA0gLvcGsFrDswgd6vFrU1GxG4CoqGQSEtpit8fidCaSkNCG5ORO4UK1dAOKjU3HZDLh8RQfUpelcm+AJZVdgU7qnBrZ3rtVAhazibxSL7tKjvy8RETk2KMwICLHvPYp4daBHSVB/P7yg36fYYQo84QH78ZF2ffaH1/ZWlBU4Y9MKer3H1nLQCgUxOMpBiAqKgWnM4HU1K4kJ3ciJiaNzQVe/jd3E/5gaK/32mzRREeHb+ardzM6kLnrd+MPGrRJjqJdSnRke5TdQreMcDcrdRUSEWmeFAZE5JhXdYO7sySIz3fwYSAY9FHhD3ePqa2bUMsEJwC5Lg9Wa/j7I20ZcLsLMYwQNlsUdntMjX25Lg8jn/2Bv3/+C28t2Frr+6OiUiqPU4Rh7B0YfivX5eEv01YBMLx7OqGQn/z8NZSV5QLhcQNApOVARESaF4UBETnmtU+tbBkoDuD1Hvw0mcGgnwpfZRiw7z2fQkZlGNhVsicMBIOHPki5uqouQlVP+Kv77+xNeAPhG/z3ft6x134Auz0Gq9WBYYRwu/d/A28YBjdOnkeuy0unVCd3Du9CaWk2fr8bl2sHwaCfPq0SAfg1x3UEZyXSNIRCQcrKcghWrikSCgUj43lEmiqFARE55rVNDrcM7CgJEQz6D7p1IBj0UV4VBpx7h4GWCeGuQbvLvARClsr3+A97sK3fX4HfX4HJZCIqKrnGPsMwmPFLTuT1L7tcfL06h9XZJXt9XlXrQFWw2JeFm3azYqebKJuJR8+NpaxoJRUVe7oXlZfn0jk9PDXrhryywzonkabE5dqO68cbKZoSgzH/OvLz15CTs5yyspwDv1nkGKUwICLHvKowkFsafqpeWLgen+/AN7eBgIcid/g9SdF7jxlIirZht4Z/Te4u3/N08HCfFFbNAuR0JmI21wwf63LL2F7oxm41c/nA1gD8/s3FjHz2B57+dn2NstHRKZhMJny+MjyefbeEvPfzNgCGd3HSOnHvsFNenk/HlKquUF5cnkNbyEykKQkG/VQsvBV2TscXAte6iQQD4RaC0tLsOpk8QORopDAgIse8zMTwE/z88gCBoEEoFGT37rVUVBTst1+9x1PE7rLwAOKqLkHVmUymyLiBHJc3sr5A6BBW/zWMEMXFW8nOXhx5kh8Tk7ZXuWXbw11+BrVL4pELe3Fq1xaRfa/O3cTusj3dkywWe+QYFRW1TzNa5g3w1eo8AC7sk0hcXEvMZgvx8a1p2XIANls0hhHCEiqiReVsTJvyD368hUhT4/cWw87pkdflwT37DMOgpGR7w1dKpAEoDIjIMS811o7dasYwoIKUyPbi4i0UF2+p9T3hLjse8srCYSEjfu8wUH37rhIP5srpPoPBgw8DpaW7anTnsdtjsdtj9yq3PjfcktE1I44ou4VJvzueJQ+eSfeW8VT4grwyZ1ON8lXdjLze0lrr88WKXVT4QrRNtNCvdSxxcZlkZPSLTE8aG5sBhFc97ly5VoO6CklzFggFodUFeza0Og+AxMT2mEwmvF4X+fm/HPGMYiJHm3oPA4899hgmk4k77rgjss3j8TB+/HhSUlKIjY3l0ksvJTc3t8b7tm3bxsiRI4mOjiYtLY27776bQKBm0/z333/PgAEDcDgcdO7cmUmTJtX36YjIUchkMtGqsnWgxB9PenpvTKbwrze3u6jWLkN+v5syn4EnEO6PX1vLAOyZUSi72L3flgHDCFFUtImSkm2EQnseKVYf0BwVlbRnHYHfWFd5I161ojJAcoyde87uCsDkeVtqDPK1WqMwmUwYRojc3BV7neOny3cCcG73KKzWvbtAOZ2JWK1OQqEgbZPC4yE25isMSPMVCHig1/1EXfgrtDoPY8d07p/4KTe//CkxcW0xmcz4/RUUFm7A6y09qNm8RI4F9RoGfvrpJ/773//Sp0+fGtvvvPNOPvvsM95//31mz55NdnY2l1xySWR/MBhk5MiR+Hw+5s2bx+TJk5k0aRIPPfRQpMzmzZsZOXIkp512GsuWLeOOO+7ghhtu4Ouvv67PUxKRo1RmYuVNe4kbi8VOy5b9iY6umoazcK/ywaCP/MouQonRNpw2S63HrZqpaFN+2Z6WgcqZRqpzuwtxu4soL8+npCQ8LWhFxe7IU8SMjL4kJXXca6xAlQ254UXEjkuv2Wpw6nEtGNYlFW8gxB/eWhJZf8BkMuFw7FlNuLBwIz5PMYT8zF2fz48bwgOFhxuvRlY5rq5660CruHC4UcuANGe+RXfA10Nwrv4rsTnT2eJry/dlQ5mTl87ynQHS0npitToIBn0UFKzD5ap9xi+RY029hYGysjJGjx7Nq6++SlJSUmR7SUkJr732Gv/5z384/fTTGThwIBMnTmTevHksWLAAgG+++YY1a9bw1ltv0a9fP8455xz+9re/8cILL+Dz+QB4+eWX6dChA08++STdu3dnwoQJXHbZZTz11FP1dUoichTLrJz5J7t4zyA/pzMRoNaWgWDQd8AuQgCd0/bMtmOx2GDlI4Q+aQcLrq9RrnrgCIeCPIqLw6HAYrHvMwQA5JV6yK5cAbh6ywCEb9qfG9Wf1Fg7m3aX89SMdZHZhRIS2hAf3wqr1UFo+UMUTE1i7evtGPPaIgC6OdaTWThln7/oo6KSsVjstE00AbBRYUCaqdLvrySw41PmlQ1i6NcjuT53Ej95hkb2f7E6D4vFTmJi+8i26jNziRzL6i0MjB8/npEjRzJ8+PAa2xcvXozf76+xvVu3brRt25b58+cDMH/+fHr37k16enqkzIgRI3C5XKxevTpS5rfHHjFiROQYtfF6vbhcrhpfItI0VA0i3l6456l9Vd98v9+91wxAwaAvMng4fT9hoFOLamHAZIad06gIgnf964R84af5hhEK990PGZgt4cG41QcbVrVQ7MuLszYC4QXAEqL3XvwsMdrObWd0CZf9fiNvLwof22KxExubQWpyZxy7pmEAUwvPiLzvj2kvAWBeek+tn1vVOtA+KRxUthZW4Auo64M0L6GAh7JN7+ELWXkq/2YKg4n8VJjK07mjI2U+WrKTXJcHuz2W1NRw1z3DCJGXt+qQxhCJHI3qJQy88847LFmyhEcffXSvfTk5OdjtdhITE2tsT09PJycnJ1KmehCo2l+1b39lXC4Xbnftg3seffRREhISIl9t2rQ5rPMTkaNPj8x4AH7cuDvy5NxstkYWCwvPLGTg9Zbi97vxel1ku8JhoOU+xgsAdEiNwWwClydAWSAGpxkMoMAPeVPiCf04lkDAwy5XgPNfy+euT114q81Ckpralbi4zFqPvXRbEZ3v/4JJ87YAcNeZx+2zHmOGtOOqweHfWe8vrjmridnqJPm4sdjMFr50hcPA31o+Rs+odTjN4Nw+BfYxA1JUVBItYs1E20wEQwZbCzSjkDQvXm8JBrDYPYCd/oy99qfG2vEGQlz72iLyS73Y7bGRgB8IePc5SYHIsaLOw8D27du5/fbbmTJlCk7nvv/ANob77ruPkpKSyNf27ZomTKSpOLlLC5w2M9sL3fyyqzSyvWoKTpdrB7m5yykoWEd+/hoA1uSGb5B7VgaJ2jhtFtpUrmPwa56H+OPGRvaFDCjd8AaB+Tfw3/llFLtDzNtUxAvzQriNBLyWVny5poShj33HLW8tprDcx8xfcrnz3WXc//FKLn5xHoFQOLhc1C+TYV1a1FoHCD/Fv+vM4zCZYOm24hotIACmEycxL+Z+8gItSLEUcXbCQlrYIdkOpo7jwLx3iwOEA5PTGU+75HDrgMYNSHPjDwag1QUsKB8EQLeMPV31hnRM5rlRAwBYm1vKmNcWYhgGCQntSErqCIDX69IaBHJMq/MwsHjxYvLy8hgwYABWqxWr1crs2bN59tlnsVqtpKen4/P5KC4urvG+3NxcMjLCiTwjI2Ov2YWqXh+oTHx8PFFRUbXWzeFwEB8fX+NLRJqGKLslcjM9duIiPl0Wnk0nJqZFZOxA9Vl+QobBL5VhoF+bJPZnYNvw/oWbC7AOeZXYamONK4Kwfd0MZqzdczPwwdI8znhuLcOfWcKfPlzJzmI3X67KYcDfZnD95J/5eOlOpi7cFik/7sT2/OPi3gc8x7R4Jyd2Cj+RnFLt/RCeB/3l7DMB+N3pg2nRdTQ2M9BhHGRN3O9x7fZYOiSHT2q9woA0M4GAB6PXg/xoXAjAH8/qyiUDWjGiZzr/vqwvWZ1SuHJQuFXu15xSPlyykxvfWMziHUGczvAg/tomKRA5VtR5GDjjjDNYuXIly5Yti3wNGjSI0aNHR7632WzMnDkz8p61a9eybds2srKyAMjKymLlypXk5eVFysyYMYP4+Hh69OgRKVP9GFVlqo4hIs3P2Kz2AOSXern9nWW8/3O49S8xsT0ORxwORzypqd1o0aIHOeVRlHoNHFYz3VrG7eeokFV5Az5vYwGYbcR3vY5MJ1hj2mAA7xedgQEMahvL2Kx2kfcFQwZufziAxDn3DCB2WM2kxzuIsVsYm9WOhy/oSYxj3wOMazvHqQu34vHvCTcTf9zCL7tcRNstXJPVIRwArvIdMAhAeJrSdklqGZDmx++vwOMpZkthkOwSP3armZM6p/KfK/rx3zGDIq2C/7qsDxf3bwXA/72/nG9/yeWOd5dhtYfDgNerMYhy7Dq4vz6HIC4ujl69etXYFhMTQ0pKSmT79ddfz1133UVycjLx8fHceuutZGVlMWTIEADOOussevTowZgxY3j88cfJycnhz3/+M+PHj8fhCA/Ou/nmm3n++ee55557uO666/juu+947733+Pzzz+v6lETkGDG0cwqndW3BrLXhVXn//MkqOqXFMqBtEikpe/rj55V6eHpO+KZ3QNskbJb9PxepCgMrdpTg8viJH/IaM+IeYcGGnfTLv4EvKvvpX5Y4g8vP/xuD2iezq8RNr1YJfL5iF6OOb0uU3cLD01YzuH0yt57eGZPJdFjneEb3dFolRrGz2M3Xq3O4sF8r3lm0jUemh7s+jRnSjsToyqlE99E16Ldstig6qJuQNEMlJeEWtvlbwyt8D+mYQpS99mmGbz6lE9NXZOMPhrv27S7zMnOdmxMywOcrJxQK7HfWMJGjVaP81D711FOYzWYuvfRSvF4vI0aM4MUXX4zst1gsTJ8+nVtuuYWsrCxiYmIYO3YsjzzySKRMhw4d+Pzzz7nzzjt55plnaN26Nf/73/8YMWJEY5ySiBwFTCYTr147iHJfkNvfWcr3a/O59KV5XDqgNf+4uBdLthbzp49WsK2wAsMAkwnuPafbAY/bOimazmmxbMgr4/u1+ZzQIZmbpywnGDKA8EQJMeYKzg8+gYW/cH7fPQOGT+yUGvn+zetPOOJztJhNXNy/Fc/P2sDt7yxjyoJt/Lw13EVh3Int+eNZXQ/9mBYHHVLCwWF9Xin5pV5axDmOuK4iR7NQKIDPFx4w/1PlkgGnHrfvcTtdM+J49qr+/LhxNyZMvLlgK/+ds4WhV6cQCHjwel2RlcFFjiUmo2rajWbI5XKRkJBASUmJxg+INDElbj/3f7SSz1fuAuAv5/fg3Z+282tOeHBx71YJ/OHUTpzTu+VBHe+xL3/l5dkbGdm7JXFOK+/8VHMCgiuTvuZfJ5ceVLecI7W9sIIRT8+hwrenm9CpXVvw+tjBmM2H1+KQn/8rY97cyq95AUYd35ZHLznwGAaRY5nbXURR0Sa8ITtnvbQdf9Bg1v+dSofKhQb3p6TCz4mPzaTcF+SFKzrSP6OCqKhkkpI6NEDNRQ7sUO5xFQYUBkSatP/N3cTfP/+lxrZJvxvMKce1OKSuOsu2F3PRCz/W2PbPi3vTKuclvl1XzG2DDFqc9nKd1PlguH1BPluezaR5W4h1Wnlp9ABSYg//ab7bXciMFb9y28dFJDitLHnoLCyHGSxEjgVzV6/i/z7ZTm5peG2NdinRzL77tIN+/z8+X8OrczczqF08z14YjdXqIC2t14HfKNIADuUeV53bRKRJu3xgG/799Vq8lYtp3X5GF07tmnbIx+nXJpGrT2jL1IXbiLZbGNEzg4v7tyLK/iinhPwH3T+/rkTZLVwxuA1XDK6b9VKcziQGtYsj1l5MiSfA8h3FDGi7/1mWRI5VFRWFPP5tdiQImE1w94hD62J3w7COTJ63lZ+3uliRbaVvKxOGYRz2eKAqoVCQ3bt/weFIICFB6yFJ/au3FYhFRI4GCdE2nri8Lw6rmePSY7nl1E6Hfay/XdiLieMGM/vu03jqyn57Bho2cBCoDyaTiRYpnRnUJjz4eOYvuQd4h8ixyTAMFm/cyMpdfuwWE89f3Z9Pxg/lvD61Lw64L+nxzsgMQx+uqMAwDEL7WNzvULjdBQQCXsrL8w5cWKQOKAyISJN3ft9MFj94Jp+OPwmnrfaZQg6GxWzitG5pTXZwrdXq4Iwu4cUipy7cRoUv0Mg1EqlbhmFQULCWHzeHF+07qUsLzuuTSZ/WiYd1vGuGhKcS/n6jhxJ3iEDAWyd1FGlICgMi0izEOqz7nDJQwkwmM6d3jScz3kJRhZ/3ftIq7dJ0GEaI4sJ1+HzlLNrqA+C0rvuePehg9G6dQPeW8fiDMHtjBUG/puaVY4/CgIiIRDjtTq4eEJ5N5eHP1nDDpEX4g6FGrpXIkXN9Pwr3p90ILP8bqytXH69aQ+RInNcnPCPZzAVzqfggE2PeuCM+ZhW1EkhDUBgQEZEIi8XByMJxpFvD/ZW//TWfF954AuqgL7RIown58Wx5D4AtW1bgDRjEOa10TI094kOf1yvcurC4og85vgRKN0yG+b87giPuCQCGEdxPOZG6oTAgIiIRTqsNh2cTk9rdzjVJ7wPw9sYWlL1pr9MnniINJRQKEPSXE8y8gKBh5p9FfwOgb+vEw16Xo7p2LRLonVhECAuzy06kPADBTZMOO0BXbw0wDLXKSf1TGBARkQhnbCYZyZ1It5VyQ+rbRJnc5AbSGLvlH6xZ/dURPvEUaVgeTzE573Ukd0oS5MxkTvlJ/OpKBOqmi1CV87KyAHg6/2ay/S2oCAKLbj6sY1VvDVAYkIagMCAiIjWYL9pActdraR/l47S4BQAsdvdl3NZ/Ub7+LXUZkmOGuywbKioHwgfL+azkTADO6pHGzacc/jTDvzWyctyA37Bw07YnqQiaYdPrh/VvpXoACIXUTUjqn8KAiIjsLWsyXOXj70PL+EvLFzATIj+QyneuvhgLblQgkGOCLxiA6NYAzC07ngXl/TFj8OeRPet0he3WSdGM6JkOQEEwmSUV3QjFdD6sNUiqBwC1DEhDUBgQEZHamW0kn/Iyv7v1U64clAHAN64T2fXrZFxvVRtDoGAgR6FAwEtw2YOYKnYQb4VPS84D4IZh7WmbEl3nn/fS6IFc3C/cQvB96Yl4XRuOuGVAA4ilISgMiIjI/pltjOzbAYC55ScQNMyUBaBo3WRKP2hP6Vt2WHB9I1dSpCafp5DlGzYwcuObPJc/jsUVPQG4bFC7evk8s9nE2b3DqxjPLsvCk3nZYR1HYwakoSkMiIjIAZ3QMZmEKCvFwUSWu8M3VZ4QlLq2UhoA34bD6x8tUl+8fg/T/ddRGEziv/mX4TUctIhz0CXtyKcT3ZeTu7QgymYmJ5DOsrVL8U099KBcs2VAYUDqn8KAiIgckM1iZnj3cFehR3Pv5KfgRdir/QUJtLnisPpHi9QHwzDw/nQHKwriamy/pH8rTKa6GyvwW1F2Cyd2SgbC6w6UBDjkgcTVxwxoALE0BIUBERE5KLee3pmWCU52+tO4feMNzA6Mwmk2Q1RrAv2f3Ku8YYQIhQKNUFNp7rxzryFvy1y2+1thIsSdZ3TizyO7c8/Z3er9s4/vkArAcncP/CEIRHc6pKCslgFpaAoDIiJyUNqnxvDFbcPo3zYRgD9uGM3N7pm4T/yIgK90r/K7d68lJ2c5LtcOILz4U2HhRioqCiILQRlBHwQq9rzpULoaqVuS1Cbkx7N5Kms9nQHoHFfK7Wd244ZhHet0BqF9Gdwh3DKwwt0TT8iB27XxkH5WNYBYGprCgIiIHLSkGDtPXN6XaLsFgEVby3l9+gwCn/WosSCZ11uK31MIQFlZLqWl2eTkLMfjKaa4eAs5My4m981Ydk12sPutGCo+7Ejp91cS2Ecf60DAg7c8l1AoSFlZDiXfXYqrclVkI+gN32wpHAiA2YYv82LWeTsC0LNT9wb9+N6tEmiVGEVJKJ63iy7CHSQ8He9Bq74CsbGfciJ1Q2FAREQOSacWscz/0xk8f3V/AN7f0Z0cfxLl6yfB/N8RDPoo+aQXzDgJ5lwMQGnprj0HWPkw7JweeekLQXHJZko3vUehH0IbX69xc+8uzyPvg+MoeDeDnHfb4/psMOVbPqIsCLt+ncyuyU7yJttxT7E32ArJgYCnsoVDT26PNgFPEYGQnw3e8AxYPTLjG/TzbRYz95zdFYAPis+nImildMPkg/7ZrBkAFAak/ikMiIjIIUuItjGyd0v6tknEZ9iZWTqMkgCUrp9EUc5iAuXbMJsgyb8dU8i7531xLYnKmY7NBC3skGYHS7WeGwEDivzg/qQbuZPt5L3blqJ30/esIuveEf76jar3la2fBPPG1um5/vbpbCDgIT9/DcXFW3C5duD1uigoWE9ZWS6GYWAEvRhVXaDUWtFg/H43ue+2I29qMkVb57DE3RuAHhkxDV6Xkb1bkhHvpCiYyJzyLNxBYPOkQ/55UMuANASFAREROSwmk4mL+4XnVf+2/EyA8DSjX5+ICUi1QVRCF1pkDCQxsR0tW/YnJi6TpK7X0cIBtk7jsF7tI63rGDIckGoHswm8ISgq3kTQgED59sjnRVvCwSHGAplOiLNHYyL8OibcawlXAArXvUHF91cSCniO+BxLSraRk7OU8vK8yDaPpyRyk1ZRsZuCgvV4vS5crh3kzriYXZOd7Hozltw3HFRM2dPtaXthBd+szmFrQTmz1+UTDOlGry5VlG4nWL4NgLeLLqUkmMBxcSUc3zGtwetitZi5bGB45eOZ/ssJGhBsP+4gBxLr50IalsKAiIgctnP7tMRiNrG6ogPb/OFuGRhgMsWGn/iftxqr1UF0dComk5nthRV4Br4CV/kgayKYbZhOfAPzKB/2TuOItdQ8vt0cDgixVki0QboDEmxA+2uJu6acjG5jSbDBqsT/45GSJ1la0QtPCIo3vUfhW1EY86879JOqfHrr8ZRQXp6PYRiUlGynoGAdBQXrIgOiqzObLWAECO34dM9hDCjxQ3Dj6xQW7+KSF+dw05uLOeXf3zP29UX8/fM1h1432SevrwKiWxNjgWXuvgBMOO9U7NbGudU5t3d4NeL5hW0pDcbgDx5cq4C6CUlDUxgQEZHDlhbnjNz0PJN3A9mB47hm60sMWfsOZ2x+m40Fe7oIfb5iFyf/exZjX19EECsAJW4/CzcVEMKKMeR1AhcVYjWBCcAUw2sFY3m88C88m3c9OzPGw1U+8kaWsqP7SxSUeXmk4G7usS1l9PxT+Sq3K/dn38fiit54QzZ8IShfP3FP14wDdNEI+iuomH0l5W+Fxx74fKVg7Jka1estxevdM2tSQkJbLBY7szcFGf5SDt9sScbabgzflp3NhyWX84XrTLL9aUwvGsBdr31AflnN8QUTf9zC3PX56gpSB0pnjyLwRX+o2IGp/TjWeMMzCQ1un9RodereMo6u6bH4Qla+cp2Ge9OUA/4M/vZnQT8b0hBMRjP+SXO5XCQkJFBSUkJ8fMMOMBIRaSrWZLu46MUf8QX2nhO9e8t4Jo4bzO4yL1f8dz4VvvAN8QkdksnqlMI7i7aT4/Jwds8MSr1+5m8s4G99ltKz7A1u3Pog+YHkyLHapUQztHMqUxeGu4KkxtrZXeartU4trAU80+oBujh3kHqtl9I5V+Pf+iEJXa7F1/8/OJ0JmM3hQGIYBsWzrsC95YPI+2Ms4HO2wV++nbiOV1HW9e7IjZnZbMFLEiWBBFomRHHiYzPxB8P7BrRNZMm24lrrZMLghiFxnN7FyZs/l/HFL+FuTKOOb8ujl/Q+lEsu1bjL8yh6Nx3DgG2BLqzzduUv2TfTKjGKH/90eqPWbfK8Lfxl2mqOc2xgUrs7SOs6BuvQN/ZZ3jBC7Nq1NPI6KiqJpKSODVFVaWIO5R5XYUBhQETkiP20pZCHPl3NL7tcZCY4eeKKvtz0xmLKvOEn6xaz6aD7yFvNJgKVZdtXBoC3F21jX28/Lj2Wa7PaM6T0P/x1YSpzywYA0Me5mpfb3guWKAi697xhxAIs1ihSU7tjsdhwl+dS9G5Grcf2haxs8Pej1Xmf8viMrQxol0pGgpMHPl6FL7jvBaGi7RacVFDss9LWns1xjk2MSfmak25cRN7udeSUuBn15m4q/OGTevP64xnWpcVBXR/Zw+cpouD7MRjZnzOvfCj/t/O+yL7bTu/MXWd1bcTaQWG5j8H/+JZgyOD99tfTJSqXxOPGhbvI1SIUCpKTsyzy2ulMJDm5U8NUVpqUQ7nHtTZQnUREpAkb3D6ZL28fhsvjx2m1YLeamXrjCfz5k1Ws2FFCMGQwtHMKL10zkFJPgMnztrCz2M2Atkl0TI3hTx+tICMhipQYO9/9Gh6s67Caef/mE2kR5+DarPY8+916Pl+xi56Z8TxzVX/eXrSNPq0TuLBfq8paPMObZ/jJKQ0y9F/fscLTk83eNnRwbK9Z2VX/JNj7IdzuQmJj03F7y6DVBTh2TSPKAn4jivKAm4Bh5v5dDzKvfCC8EH5aO2tdYa3n/+yo/vzpwxVU+IJ0y4jjy9uHYTKZMII+TIt+j7FpEqZO14HFQVJSByyWnXxynYknv3fx9VoPE3/Y2OhhwDBC+L0ubBYbJlvDz8BzqCrmjKZ4w1QAnGaYWTossi893sF1J3VorKpFJMfYGdIxmR83FDC77ERa2z8mduMkrCe8ckirEovUJ7UMqGVARKTe+AIhZq/LJ8ZuYUjHFMz7WAE2FDIwm02UewPc8e4yFm4q4MZhHbn1jC41ym0vrCA5xk6MY//Psm5642e+WZPLOfGz+EfmkyTawjMNhQywmqBs+AIwWXE44iLjAFqkdMZmsYE1GvdHHfkyO5O7dtxX6/GvGdKW8ad15qtVObRNjuaM7umszy1ldbaLIR1TyEhw/uYE/Xvd/LlcO1m1bQdXv7Ubiwk++sNQ+rZJrOXi7P3euhYKBcmfeRnB7Z9gM0NCfEdsF/6CyWKv1889bCE/+ZPt+Cv/f2JO4NR1k6gI2ph64wkMaJuE02Y54GEawus/bOaR6Ws4Ie4Xnmp5N1Gx7Ui6YkutZUOhADk5yyOvnc4EkpM7N1BNpSlRN6GDpDAgItI0rdhRzIUv/IhhwJQODzC0d18wW2HT6wTbjyW3/a01ypvtKczZYuGcXhnEOcM33jdNXsg3v+zmxmEduGxgG1Jj7RS7/azPLeXMHhlY9hFsDlYoFCA3dwX/92khP27xYrOY+NelfbhkQGsMw8DnKaT0xxux7PyYhM7XYh46udqbwwEhFApgMoKYLI4jqounIp/Cd2pOwWkzQ0qX33zuUcAwQnjKdlE072bYOZ0fKs7gL7tuxR200jopijl3n7bP0NkYNuSVMfw/s7GbfHzVaRROs3efYweCQT/Zu5bz0rxSemXYGdEzjZSULrUcVWT/DuUeV7MJiYhIk9OndSKjT2gLwPU7HuXE2ddy1vxr2X5WMQW9XiYhoV2kbFRUEk997+KeD1bQ++FveO/n7VT4Any/Ptwl6JIBremaEUdKrINOLWI5u1fLIw4CAGazlbS03jw8IoFBbez4gwYPT1tNcYWPku+vpODtVHzbPsYdhJINb8C8sQSDfgpnXkrRm3b8P4whb8Yl7H7TGVnL4HAYhkFZWS60Og+HOdzlBsAfgqL1bzTYqs4Hw++vIPfdDhS93xp2TmeTryP37LgTd9BK+5RoXh83+KgKAgCdWsTQKjEKn2FnpacXAL5Nb+5jZiGDWRs8TF1Swf1fFKOpRaUhKAyIiEiTdP+53RnULgmPP0R2iYd1uWUMe+IHjv/nTG5+ZyMJKX1ITu5Mgb8F7/68Z1zBPR+s4I53luELhGidFEW3jLh6q6PFYiMhJpqnLkyiSwsnLk+AKfPXU7H5/Rrl3EHIW/sGRR90wrP1I9xByF/3FqGdn+EPgX/D6xCoOKw6lM4ehW96b9g5neiOo0juei0t7OHpXb0h8G6YdNSspOwq2kCoYhsmwqHlK9dZAJzeNZXv/ngqx6XX3/+rw2UymTj5uPB4kPmmUQD4Wl1Wa9cvwzDYXrxnCtpQaN+D1EXqisKAiIg0SdF2K+/fnMX7N2dxVo/0Gvvmrt/N24u243Qm8OGSnXu995s1uQAM69ICk6l+nzQnJLTBYjZxUa9w//zPVuzix7JBfFZyLsl2G1ZrFAABA3zVVmR2hxxs8LbHG7JT5AfXlBiMeePCoSDkP7gb+JAfz+Z3Iy8d29+GE/6H7apyoiu73FccJfejgYAH79IHAWhhB6fVwbSSUwH43Ukdj7oWgepOqQwD727vxs9Rv8e/9YN9tOYYkWlqAcp9ahmQ+qcwICIiTZbJZGJw+2T+O2Ygfx7ZnXvO7sqfR3YH4O+f/8JlL83jpe83AvDi6AHM+9PptE2Ojrx/ePe0Wo9blxyOeOLjW3FKJwdmE/ya6+Xu7Id5NPcPdFv1MR8Vnh3pumMY8GbhZbxVdCW3bP8X1259nhu2PYk3ZKYsCLlrJ5P/Zgw5k+2UvGk/YPehoGHwo/9Mxm59hm/KRmLudF34ibU1mqhOYwDwBMFY+Pv6vgwHVOHaDjun4TSD1Qzvt1+BKxhLu5RoTuyU2tjV26/h3dMY1iUVA3jx1274Q2BsfH2vwGYYBiWePemrqCKASH3T1KIiItLkmUwmbhgWXrypwhfg1bmbyHV5+XlrERBewOz0bmk4bRbm3HMaeS4Pa3a5Ik9061tsbAYdWlq4/gQ3X691s61oT1eRx3OuY3j8T8RZC5mcdw4v7R5X470bfR1Y7D6B46PnEzKg6layPAgxG17HevzLtXZJCY8/uJz/ZY9gvbcTD2ffwuDWQ+hZud+W9T9M697EAEKbJmI54b+NMh2mEfRRNncsZZveIWiYea3gKj4uu4jsFesBuP6kDnUyhqM+WS1mnrmqP1mPzuRXbxfWejuS1u0krHtdT4O80j1hoKBcYUDqn1oGRESkWYm2W/nmzlN4/+YsOqSG59N/8LweNaaiTIt3cmrXtHrvIlRdTEwL7hk5mM9u7smvDw/lretPACCEif/YPiTO5OfNwstrvCcxOnwz+XjpI4Ta3kCiDVJsYKmstjuqQ40beMOo9tR51pXs2jKX1Z5ukW2Ltroi35ssdsxtLgIg2G5MowQB7w9j2DXZQemmdwB4r/gSXsi/mmx3uPVmULskrj6+bYPX63Akx9g5vkN4Re1fOr1OYOAztZbLK9sTBAvVMiANQGFARESanYQoG4PbJ/P5bSfx1R3Dqi1c1rhstmgSEtrgdCZyUpdUvrpjGCYTfLE6n6t2vk5pKJbMqArW/f0cfrj3NGbffRodW8SQXeLlptXXUnZBKY4ri4mtzDX+0s2Rrihebym7di0lL28VpUUb8W37mAXlg2p8/tJtxTVeW/o/BiMWENzHjWt9CgU8FK1/K/I6YETxVuHFkddZHVN45dpBWC3Hzq1Mj8zwFI/rdwcj61tUZxgGBdUGaRRWBPcqI1LXjp1/QSIiInUs2m6lW8bRu85Mt4x4rh0SngZ1RXESAJef2Be71UzrpGgSomxMGnc8KTF21uxyccZTP3LF62t4xvs4npADT8sL8Po9GIaBxxPuEhVY+gClH4cXslrq7gtAvzYJAPy0pRBvYM8NqMViB5OVYNDXYOcMYAS9lJRsJeRsDYRvVl4pGEtRMIEOqTFs+Mc5vH3TEJJjjtJF0fahZ2b4Oq/LC1BenldLIDDwBvYMGtaYAWkIGjMgIiJyFHv4gp6c2DmVLbvLaZsczem/GdTcNiWa92/O4g9TlvBrTimLthSyiB4sazuNp3olU1CwDocjjlAoAEYAdk4DwGIy83NFHwBuPb0L93ywgl0lHh6etpoJp3ehVWIUFku4a1DQVwLUnJGpvgR+HEvBujeomlQn2QYv54/ircLzAHjo/B7HVGtAdX1aVYaB3QE8foOioo0kJXXE4QgHUsMw8FULA9UHE4vUl2PzX5OIiEgzYTKZGNEzg9+f0olzerfEYbXsVaZji1g+nTCUHi33tHIs2ubnq189QLiLkN/vBpOV9G7jyHDARyUXkx9IJs5pZWjnVP52UXhBrLcXbWfoY98xed6WcMvAnIsp/6Qr3o861f/JhvyUbggHAbMJVngGcMu2v/B03mgA/jyyO6d1rf8ZnupLu5RoMhOc+IMGq/PMhEJBiou3RMZyGEYIf7X7f39AU4tK/VMYEBERaQIcVgtTbjiBt28cwj1ndwXg37NczN5ixzAMlu30cdmk3Tyc90fWnLybp/KvA+DBkeHB0+f2bsklA/aMnfjH57+wu9QPFeG1DUpKNmHMu/bIKll9/YNa1kEo/2Es7speSl4jlbt33Mus0sEAXDGodWRGqGOVyWTipC7haVC/WmdgNtsIBv243eHVrr3+mi0BvqDCgNQ/hQEREZEmIinGTlanFG4c1pEeLePxBAzum7aN/8wN8M+ZpWS7Ary5YCvnvbAAX9DgjG5pXD6odeT9T1zWl58eGM7xHZLxBUNMXeIiLakjJsKLnlVseJOQpwCvuxAj6D1whard8Ad+HEvRm3aK3rTj/qgjRW/a8c29JlIu6C2hZMPbALhDUdyW9ySloRjsVjOvjBnIvy7tU5eXqtFcObgtZhN8vjKHR78rrxzPUQxQY7wGKAxIw1AYEBERaWJsFjNv3zSE287oAsCHywrYUVzzSXxitI1HL+1dY/pUs9lEizgH12aFBy1/92se1os3ktDpCgBKApAzNZWCt1PYNdlJyawrCYV+M+NNyI8R9FE6exRFb9ox5o0j6C2hYN0buIPgDkJR8WbcQShYP4XC99uTO9lO7pREns67kcs2/48LNk1meXEKCVFWZtx5Mmf1zGjQaV7r08B2STx6SW+sZhOfrijkzcXleL0uQqEAnt+GgYDGDEj90wBiERGRJighysZdZx7HjqIKPlqyE4AXrh7AloJyNuaVccOwjqTFOWt977DOLTCbYH1eGTuKKmh10pt4Nr/Hb8ezlm9+j0CvvxAdmxEek7Dkj7g3v0v1B9qBtZOxr59MbQ+5DaDMtYOA4SA3kMp7xRdG9rWMquCV68+iXUrMkV6Ko86Vg9sSDMH9H6/klfllDGrjIDY2H99vJg/yaWZRaQAKAyIiIk3Y45f24dSuadgtZs7ulXFQ70mItjGofTKLNhfy4eKd3D68C0ldf4dnw0Qg3GWoNAC0ugCv3423aHN4pqJN7+51LL8B/sqb2ngrRMV3wuPaiN8AV8DMrTv+wSp3N4KVtyStbTk8e9259GqTjt3adDswjDq+DT9syOeLlTl8trqC3pm78fiTapTxq5uQNACFARERkSbMajFzQd/MQ37f6BPasmhzIU99u45AKMStp/+PqBP+Gx4HYLYRHfRTVrGb8vL88OfYYnF0uILQtvfwhsBugmgLFFbrneToeA2Wk94kWFHB/2b9wreL5vKrt0uNz72pew4DOrQ8onM+FphMJkaf0I4vVuYwa4OHP57qpcxdVqOMxgxIQ2i6kVtEREQO27m9W3J8h2QAnvtuA/d8sBxP0MzGohCYbVhs0cTFZRIdnUpiYnvS0nqScNq7JI3xkZHSmWQ7OOM7k2gDE2A3g3XrW+x2lXHJyz/x/NycSBDoHh3uxjSkQxKXX/anxjrlBjekYwrxTisuj8GG3QHKKlw19mtqUWkIahkQERGRvdgsZt69aQjTlmdz13vL+WRZNp8sywbgL+f34KyeGWwtKOfETu0i79lWUMHEeZvxBj9iQOdoBnbMoMOG24je9DoAoQ7X8fD0dWzIKyMj3smNJ3fk5I6xdMlsQV6phxaxjiYzUPhgWMwmBrZLYtbafJZn+zgu1VZjv1oGpCEoDIiIiEitTCYTF/ZrxbaCCp6csS6y/a+freGvn60B4PHL+tAlLZa2ydGMenUBO4vdAEwF4Ffap1zDPWc9TLkvyL+/2UBe6S4AnrmqHyd0TIkcc1+DmZu6Qe2Tw2Fgp492STVvy/xBA8MwmlVAkoanMCAiIiL79ftTOvHz1iJmrwuPDzCZwKh8aH3PBytqlDWb4HdDO7BgUwGrs11sKajgD2/XLHN+38waQaA5O6lzKv/+ei0Lt/k4vUvNQBSeTcgg3NFKpH4oDIiIiMh+2a1mXhs7iFXZLnplxrM+r4x3f9rOnPX5bMovj5QzmeCpK/txYb/wSsardpbw8LTV/Ly1CIAbTurA3Wd3xWG1NMp5HI36tE4gM8FJdomHHzaHF3KLtZsp84WqtQw0ciWlSTMZhtFsO6S5XC4SEhIoKSkhPj6+sasjIiJyTDEMg/V5ZbROiuLr1Tl0TI2lb5vEGmW8gSCPfvErJhP8eWQPLGbd2f7WXz9bzcQft0Ret4y3scvlJ8FpYulDZ2E269mtHJpDucfVT5eIiIgcFpPJxHHpcQBc3L91rWUcVgsPX9CzIat1zDm7Z0aNMBDrCE/26NeiY9IANLWoiIiISCMa1D6Zlgl7xgvEVIYBX2U3IZH6pDAgIiIi0ogsZhO3nr5n8bVYe7grVSAEwWCQUMATXuxNpB4oDIiIiIg0smFdUiPfO617xlXs/PZqct6IouwtOyy4vjGqJk2cwoCIiIhII2uVGBX53uXZM1jAv/Pr8LYABDa8rhYCqXMKAyIiIiKNzFxtlqXc0kDke5+xZ1XisiCw6GYFAqlTCgMiIiIiR5G0eAe2yjs0f/q5pFTmgYog5P3yOhVT1GVI6o7CgIiIiMhR4JM/ZHFm92T+ddlAbJZwS0F+u3twnV9E5QRDBAwo9kNoo7oMSd1QGBARERE5CvRrm8yrY7Po2CKOCn94StGb3tnJ4Md+5BvHgzXKup0dwGyr7TAih0RhQEREROQod9/yE/gp5h7slXdu3tLNEKho3EpJk6AwICIiInIMeHzzCKI6XAOAJwTut2M0dkCOmMKAiIiIyFHmuqEdaJ0UxUujB7Dy4bNIjXWws9jNKXOuZW5ZFgBFfihd97paCOSImIxmvM61y+UiISGBkpIS4uPjG7s6IiIiIrV6YdYG/v312sjr/0v/H5ckfAJAnBXijrsOhrzWSLWTo82h3OOqZUBERETkKHfNkHakxjoir5/Ouw6PkQRAWaBydiG1EMhhUBgQEREROcolRNn49q6TWfbQmfRrk0jAMPOJ6T7sZjCAXC+UT9UYAjl0dR4GHn30UQYPHkxcXBxpaWlcdNFFrF27tkYZj8fD+PHjSUlJITY2lksvvZTc3NwaZbZt28bIkSOJjo4mLS2Nu+++m0AgUKPM999/z4ABA3A4HHTu3JlJkybV9emIiIiIHBUSo+0kRtu5oG8mAM+u68EP5UOBcCBwBSCo9QfkENV5GJg9ezbjx49nwYIFzJgxA7/fz1lnnUV5eXmkzJ133slnn33G+++/z+zZs8nOzuaSSy6J7A8Gg4wcORKfz8e8efOYPHkykyZN4qGHHoqU2bx5MyNHjuS0005j2bJl3HHHHdxwww18/fXXdX1KIiIiIkeNUce35cROKQDcsf0+bt7+JGs9nTCA8lZXgtlG9SGhHk8JHk9JI9VWjnb1PoA4Pz+ftLQ0Zs+ezcknn0xJSQktWrRg6tSpXHbZZQD8+uuvdO/enfnz5zNkyBC+/PJLzjvvPLKzs0lPTwfg5Zdf5t577yU/Px+73c69997L559/zqpVqyKfddVVV1FcXMxXX311UHXTAGIRERE5FnkDQS547kfW5pYCcGKHeJ44zw4mK1arg1AoQGpqd3y+UoqLtwKQlNSRqKikxqy2NJCjagBxSUk4iSYnJwOwePFi/H4/w4cPj5Tp1q0bbdu2Zf78+QDMnz+f3r17R4IAwIgRI3C5XKxevTpSpvoxqspUHaM2Xq8Xl8tV40tERETkWOOwWvjwDyfyxzOPA2DeZhfZ5XEABAJeQqEgeXmrKC3NjrzH4ynC63Xh8RQ3RpXlKFWvYSAUCnHHHXcwdOhQevXqBUBOTg52u53ExMQaZdPT08nJyYmUqR4EqvZX7dtfGZfLhdvtrrU+jz76KAkJCZGvNm3aHPE5ioiIiDSGWIeVW8/owlk9wvdDz/3gYl1+zQ4fweCe8QNudxEFBespLNxIaWk2JSXb1H1I6jcMjB8/nlWrVvHOO+/U58cctPvuu4+SkpLI1/bt2xu7SiIiIiJH5LqTOgAwe10B497O5XfvlvHuihDBUDgY2GzR2GzRNd5TWrqL8vJ8Cgs31AgM0vzUWxiYMGEC06dPZ9asWbRu3TqyPSMjA5/PR3FxcY3yubm5ZGRkRMr8dnahqtcHKhMfH09UVFStdXI4HMTHx9f4EhERETmWDemYwsTfDWZkn5YArM0t45nv8/huYzgMmO3pbHIl7vP9ZWW7GqKacpSq8zBgGAYTJkzg448/5rvvvqNDhw419g8cOBCbzcbMmTMj29auXcu2bdvIygovr52VlcXKlSvJy8uLlJkxYwbx8fH06NEjUqb6MarKVB1DREREpLk4rWsaL1w9gL+c3yOy7S9f5rGupAXj3ljDla8uYUV+PFarE5Op5u1fRcVutQ40Y3U+m9Af/vAHpk6dyqeffkrXrl0j2xMSEiJP7G+55Ra++OILJk2aRHx8PLfeeisA8+bNA8JTi/br14/MzEwef/xxcnJyGDNmDDfccAP//Oc/gfDUor169WL8+PFcd911fPfdd9x22218/vnnjBgx4qDqqtmEREREpKnZkFfG8P/M3mv76BPa8o+Le+P3V1BRsZvY2JYUFW3C5ysDICGhDVGOOMzW2ntYyLHjUO5x6zwMmEymWrdPnDiRcePGAeFFx/74xz/y9ttv4/V6GTFiBC+++GKkCxDA1q1bueWWW/j++++JiYlh7NixPPbYY1it1kiZ77//njvvvJM1a9bQunVrHnzwwchnHAyFAREREWmKVu0s4bznfqixrXerBF64egC+YIjdZV7+O3sj5/RM5qTWlYOIVz4CO6cR3/EKYk+aCGZbeHvVf6uE/LVvq63s0aK2OjdhjRoGjiUKAyIiItJUPTdzPR8u2cFtZ3ThrveW11om1mFlzv9lgXcnnml7uhhZTeAwg9MMji7XwZDXACibPQrP5ndI7HwNoUHPYbNFUTb3WoJb3yPWAtbO4bKBgAeLyYzJYm+Qc90Xn68M15wxxO76BGe189hLEwsLCgMHSWFAREREmoPLXprHz1uLat33yIU9uWZwOkVvReMN1dxnAtIcELhoF36vC9cnXWs9BkCUBZJs4L4wh6IfbiI2dxrxx+3nBvw3QqEAZWW5REenYrU6DvbUfnMQP8GgD6+7EGdsJjkzLoKd07GawufBVb49ZStv/stnjyK49R1iO12Leejkw/tcwsHDMEI4HI1/T3ko97jW/e4VERERkWPebWd04drXFwHQNT2O7UUVDOuSyterc5m2LJtrTmiHv90faJn9IgbgCUGxHwwg1wu82/KAn+ENAR3GUVK8GXZOowyI2/g6puNfDheo7cl7tSfyZWU5lJXlUlaWQ0JCW8rKcnA44khMbF/r5xmGgdfrwmKxYbNF455zDRWbpuALheuNszV4dgAQMMAX1ZGSmZdh3jmNRBtYOl2H2+emZGN4CvzghjdIMpsha2KNz/H5ynG5tmOzxRAVlYTV6sRsttaof3nJFkrKCwBISupAVFTyAa/X0UItA2oZEBERkWYgp8RDmTdA57RYDMMg1+Ul67GZGAbEOa2UegL0yoxj8riBxDsMSssK8X7ajqobRYcZgka465BB+AbbG4JoC7iD4W0WU7hMlWgLmGPaY3VvwdphDN7efyfaGY9hiaJszjXYdnxATJdxGENeIy9naY33VklL67VXS4HPV0ZR0WaCQR8mk4n42HRK3m+995v3wWYGuwnKg3u2mU2QUdV6UC24FBZuqLE4m8lkIikuA9PSuyndOBW/ORojUAHRbeDkj7FYbKSl9cbnK220VgJ1EzpICgMiIiLSnP3j8zW8Ondzrfti7BY+6/EwGf6F2E1grT4jaWxnjNIN+KI7YivfRGmw5o31/lhNEDJHEwpW7NkY3RoqdkCrC6D3Q5hMJqpuUW22aJKTO2Gx2HG7CwkEvJSV5WAY1fo0GQH4eggWE0SZw3UxmcBmCndfKt7PzKk2M/grD5XY+WpMg58jEPBitTrxekuoqAg/8Xc44vF6XTDnYqjYe+FaqwlCZ84jZLZjsdgIBv3Ex7cmNjb94C5MHVIYOEgKAyIiItKcGYbB/E0F5Jd6yYh3MurVBYSq3Rme16clz17WFcNsg5Afi7VyQLDZRjDgo9QHFzz/A4ZnN89n3k9n+0b8BsRZwROEksCh1cduhpQxHjDb8XpdFBZuAMBisWG3x+F2F9YoHx2dErlZt635J6m5H2HqOA4IweY3woViOlPh2oCJcKuGj2g8gQp8IQgBqXbISz0fo9cDYKq9B73DEUdKynH4KvIoeCed6jfPJiDFDv7obuwcPJ1YS3F4u8lEUlJHnM7EQ7sIdUBh4CApDIiIiIjs8emynbz703Y27y5nV4kHgDiHlaBh4LCaaZsSQ5nHT4zDysqdJVS/ixzWOYU3e/4X38a3+NJxH6ee+yfiv+2D17WRQn/4Kf0Gb2daWrdgNweItoTHJhgGkZvrZBs4R+/pplNQsA6vt7TWulY9dXe7CzEMg6ioJExGcE8Xn5AfQn5KAzZil96MafPr0P5aOHEyTOsCZeGgQYdxlPT4K+Xl+bV+TlxcJrGx4envfcEQts+7QdkGyoLhrkZmk5n3TA/y/NZh5JZ6GDc4hhuHxBEbm0F8fKsj+x9ymBQGDpLCgIiIiEjtJv24mYc/W3NI7/nzyO7sKq7gtR+3cnz7ZN65aQjmkBvj8778a8NQXs6/nMsTp3FPxiskW01Y4jtB2QYCofAYhN9O/2kYBmVlOZSWZu/1WbWNJaguGDK4671lfLosm3vO7sofTm5XcxBzoALMNgyTlZ+2FJDuLMBmhBdgM5xdSHIGsFisbCs2ced7y1i104XZBH85vyddUmyUr36BxZuzeTn/8r0++5Fzkvm1IJqHzu+F02Y5pGtYFxQGDpLCgIiIiEjtDMPgvo9WMnf9bq4Y1IYYh4UdRW6W7yhmdbYLm9lEuS/IsC6p5Lm8rM3d+wn+0M4pxDttJEbbeHvRnn72s467kWu2P03blm15eXQfFm4u4uQuKWws8LJqZwmXDmiN1RIepBAKBcnJWUaFL8TC7Gh6pZbTMjGGtLSeNT4rEAzx+zcXk+PykNUxhc27y5n5ax4ALeIcfDp+KOtySzmhQwpRdgvBkEF+qZd/ffUrHy/dSd/WCbx2dSsemJ7H12t2M2ZIOx65sCej/7eQeRsLDni9bju9M5t2lzN9xa7ItqsGt+GxS/sc1vU/EgoDB0lhQEREROTQGYaBYcDibUX0bZ1IdrGb/87ZyDs/bedg7iztFhO+30wdNKBtImtzSin3BenXJpFxJ7bnvD4t2VpYQYI9wCOfr2Xait2kxNi45dSOvPfzTnyBEGnxTh4c2YNlO4p58JNVB/zsaLuFMVnt+GpVDlsLKmrsy0xwkl3ZPQog3mnF5QkPfDj5uBa4fQF+2lJUY/9fzu/JsONSSYtzUlzhY/h/5rC7zEurxCje/f0QWidFH/iC1DGFgYOkMCAiIiJSd35Yv5sl24oYM6Qdt72zlK0FFWwr3HPD3Tktlg15ZfVah46pMQxol4TNYmZguyR+2eXitR9qnzGpSruU6L2CgckUHs8QY7dw11lduf6kDmzIK+XK/y5gWJdUzundkn5tEkmPd9Z4X3axm1U7SxjSKdwq0hgUBg6SwoCIiIhI/XJ5/Ez6cQu9WydgGAbXTfoZgL6tE0iKsbM2pxSzycTOYjcAfzm/Bz+s3x3p4rMvvVslMP60zvxl2ipyXV4g3C3pjetOwGI2RcqVuP1c+d/5/JpTyu1ndKFjixge/2ot3VvG889LeuH1h2iTHM3fpq/htR820yY5iq/vOBl/0GDz7nK6pscRZd/T798wDEwm0171OZooDBwkhQERERGRhuP2Bbng+R+Idlh59qp+tEuJiSyAdvX/FtAtI44XRw8EYM66fJ6ftYGL+rXi0S9+odQb4J6zu/L4V2tJibHz7u+z6JwWy4odxby9aBvDu6dzate0GkGgSihksLPYTavEKMy17AfwBoJMWbCNU7u2oGOL2Hq9DvVNYeAgKQyIiIiINKzDebK+OruE7GIPZ/ZIZ/HWItomR9Mibt8zCTV3h3KPW/vKCiIiIiIi9eBwutj0zEygZ2YCAAPbJdV1lZo184GLiIiIiIhIU6QwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlMKAiIiIiEgzpTAgIiIiItJMKQyIiIiIiDRTCgMiIiIiIs2UwoCIiIiISDOlMCAiIiIi0kwpDIiIiIiINFMKAyIiIiIizZTCgIiIiIhIM6UwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlMKAiIiIiEgzZW3sCjQmwzAAcLlcjVwTEREREZG6UXVvW3Wvuz/NOgyUlpYC0KZNm0auiYiIiIhI3SotLSUhIWG/ZUzGwUSGJioUCpGdnU1cXBwmk6nBP9/lctGmTRu2b99OfHx8g3/+sUzX7sjo+h0+XbvDp2t3+HTtDp+u3eHTtTt8jX3tDMOgtLSUzMxMzOb9jwpo1i0DZrOZ1q1bN3Y1iI+P1z+yw6Rrd2R0/Q6frt3h07U7fLp2h0/X7vDp2h2+xrx2B2oRqKIBxCIiIiIizZTCgIiIiIhIM6Uw0IgcDgd/+ctfcDgcjV2VY46u3ZHR9Tt8unaHT9fu8OnaHT5du8Ona3f4jqVr16wHEIuIiIiINGdqGRARERERaaYUBkREREREmimFARERERGRZkphQERERESkmVIYEBERERFpphQG6tljjz2GyWTijjvuiGzzeDyMHz+elJQUYmNjufTSS8nNza3xvm3btjFy5Eiio6NJS0vj7rvvJhAINHDtG97OnTu55pprSElJISoqit69e/Pzzz9H9huGwUMPPUTLli2Jiopi+PDhrF+/vsYxCgsLGT16NPHx8SQmJnL99ddTVlbW0KfSoILBIA8++CAdOnQgKiqKTp068be//Y3qk4Xp2u0xZ84czj//fDIzMzGZTHzyySc19tfVtVqxYgXDhg3D6XTSpk0bHn/88fo+tXq3v2vn9/u599576d27NzExMWRmZnLttdeSnZ1d4xi6drX/3FV38803YzKZePrpp2ts17Xb97X75ZdfuOCCC0hISCAmJobBgwezbdu2yP7m+rf3QNeurKyMCRMm0Lp1a6KioujRowcvv/xyjTLN9do9+uijDB48mLi4ONLS0rjoootYu3ZtjTJ1dW2+//57BgwYgMPhoHPnzkyaNKm+T28PQ+rNokWLjPbt2xt9+vQxbr/99sj2m2++2WjTpo0xc+ZM4+effzaGDBlinHjiiZH9gUDA6NWrlzF8+HBj6dKlxhdffGGkpqYa9913XyOcRcMpLCw02rVrZ4wbN85YuHChsWnTJuPrr782NmzYECnz2GOPGQkJCcYnn3xiLF++3LjggguMDh06GG63O1Lm7LPPNvr27WssWLDAmDt3rtG5c2dj1KhRjXFKDeYf//iHkZKSYkyfPt3YvHmz8f777xuxsbHGM888Eymja7fHF198YTzwwAPGRx99ZADGxx9/XGN/XVyrkpISIz093Rg9erSxatUq4+233zaioqKM//73vw11mvVif9euuLjYGD58uPHuu+8av/76qzF//nzj+OOPNwYOHFjjGLp2tf/cVfnoo4+Mvn37GpmZmcZTTz1VY5+uXe3XbsOGDUZycrJx9913G0uWLDE2bNhgfPrpp0Zubm6kTHP923uga3fjjTcanTp1MmbNmmVs3rzZ+O9//2tYLBbj008/jZRprtduxIgRxsSJE41Vq1YZy5YtM84991yjbdu2RllZWaRMXVybTZs2GdHR0cZdd91lrFmzxnjuuecMi8VifPXVVw1yngoD9aS0tNTo0qWLMWPGDOOUU06JhIHi4mLDZrMZ77//fqTsL7/8YgDG/PnzDcMI/8M1m81GTk5OpMxLL71kxMfHG16vt0HPoyHde++9xkknnbTP/aFQyMjIyDD+/e9/R7YVFxcbDofDePvttw3DMIw1a9YYgPHTTz9Fynz55ZeGyWQydu7cWX+Vb2QjR440rrvuuhrbLrnkEmP06NGGYeja7c9v/zjW1bV68cUXjaSkpBr/Zu+9916ja9eu9XxGDWd/N7RVFi1aZADG1q1bDcPQtauyr2u3Y8cOo1WrVsaqVauMdu3a1QgDunZhtV27K6+80rjmmmv2+R797Q2r7dr17NnTeOSRR2psGzBggPHAAw8YhqFrV11eXp4BGLNnzzYMo+6uzT333GP07NmzxmddeeWVxogRI+r7lAzDMAx1E6on48ePZ+TIkQwfPrzG9sWLF+P3+2ts79atG23btmX+/PkAzJ8/n969e5Oenh4pM2LECFwuF6tXr26YE2gE06ZNY9CgQVx++eWkpaXRv39/Xn311cj+zZs3k5OTU+PaJSQkcMIJJ9S4domJiQwaNChSZvjw4ZjNZhYuXNhwJ9PATjzxRGbOnMm6desAWL58OT/88APnnHMOoGt3KOrqWs2fP5+TTz4Zu90eKTNixAjWrl1LUVFRA51N4yspKcFkMpGYmAjo2u1PKBRizJgx3H333fTs2XOv/bp2tQuFQnz++eccd9xxjBgxgrS0NE444YQa3WH0t3ffTjzxRKZNm8bOnTsxDINZs2axbt06zjrrLEDXrrqSkhIAkpOTgbq7NvPnz9/rfnHEiBGRY9Q3hYF68M4777BkyRIeffTRvfbl5ORgt9sjfxirpKenk5OTEylT/Yeman/VvqZq06ZNvPTSS3Tp0oWvv/6aW265hdtuu43JkycDe869tmtT/dqlpaXV2G+1WklOTm7S1+5Pf/oTV111Fd26dcNms9G/f3/uuOMORo8eDejaHYq6ulbN9d9xdR6Ph3vvvZdRo0YRHx8P6Nrtz7/+9S+sViu33XZbrft17WqXl5dHWVkZjz32GGeffTbffPMNF198MZdccgmzZ88G9Ld3f5577jl69OhB69atsdvtnH322bzwwgucfPLJgK5dlVAoxB133MHQoUPp1asXUHfXZl9lXC4Xbre7Pk6nBmu9f0Izs337dm6//XZmzJiB0+ls7OocU0KhEIMGDeKf//wnAP3792fVqlW8/PLLjB07tpFrd3R77733mDJlClOnTqVnz54sW7aMO+64g8zMTF07aRR+v58rrrgCwzB46aWXGrs6R73FixfzzDPPsGTJEkwmU2NX55gSCoUAuPDCC7nzzjsB6NevH/PmzePll1/mlFNOaczqHfWee+45FixYwLRp02jXrh1z5sxh/PjxZGZm7vW0ujkbP348q1at4ocffmjsqtQ5tQzUscWLF5OXl8eAAQOwWq1YrVZmz57Ns88+i9VqJT09HZ/PR3FxcY335ebmkpGRAUBGRsZeI9GrXleVaYpatmxJjx49amzr3r17ZDaIqnOv7dpUv3Z5eXk19gcCAQoLC5v0tbv77rsjrQO9e/dmzJgx3HnnnZHWKV27g1dX16q5/juGPUFg69atzJgxI9IqALp2+zJ37lzy8vJo27Zt5G/H1q1b+eMf/0j79u0BXbt9SU1NxWq1HvDvh/727s3tdnP//ffzn//8h/PPP58+ffowYcIErrzySp544glA1w5gwoQJTJ8+nVmzZtG6devI9rq6NvsqEx8fT1RUVF2fzl4UBurYGWecwcqVK1m2bFnka9CgQYwePTryvc1mY+bMmZH3rF27lm3btpGVlQVAVlYWK1eurPFLv+oP6m9/2TUlQ4cO3WvKrnXr1tGuXTsAOnToQEZGRo1r53K5WLhwYY1rV1xczOLFiyNlvvvuO0KhECeccEIDnEXjqKiowGyu+c/ZYrFEnpjp2h28urpWWVlZzJkzB7/fHykzY8YMunbtSlJSUgOdTcOrCgLr16/n22+/JSUlpcZ+XbvajRkzhhUrVtT425GZmcndd9/N119/Deja7Yvdbmfw4MH7/fsxcOBA/e2thd/vx+/37/fvR3O+doZhMGHCBD7++GO+++47OnToUGN/XV2brKysGseoKlN1jHrXIMOUm7nqswkZRngaqrZt2xrfffed8fPPPxtZWVlGVlZWZH/VNFRnnXWWsWzZMuOrr74yWrRoccxP0XUgixYtMqxWq/GPf/zDWL9+vTFlyhQjOjraeOuttyJlHnvsMSMxMdH49NNPjRUrVhgXXnhhrVM+9u/f31i4cKHxww8/GF26dGmS02NWN3bsWKNVq1aRqUU/+ugjIzU11bjnnnsiZXTt9igtLTWWLl1qLF261ACM//znP8bSpUsjM97UxbUqLi420tPTjTFjxhirVq0y3nnnHSM6OvqYn+Jxf9fO5/MZF1xwgdG6dWtj2bJlxq5duyJf1WcU0bWr/efut347m5Bh6Nrt69p99NFHhs1mM1555RVj/fr1kakZ586dGzlGc/3be6Brd8oppxg9e/Y0Zs2aZWzatMmYOHGi4XQ6jRdffDFyjOZ67W655RYjISHB+P7772v8PquoqIiUqYtrUzW16N1332388ssvxgsvvKCpRZua34YBt9tt/OEPfzCSkpKM6Oho4+KLLzZ27dpV4z1btmwxzjnnHCMqKspITU01/vjHPxp+v7+Ba97wPvvsM6NXr16Gw+EwunXrZrzyyis19odCIePBBx800tPTDYfDYZxxxhnG2rVra5QpKCgwRo0aZcTGxhrx8fHG7373O6O0tLQhT6PBuVwu4/bbbzfatm1rOJ1Oo2PHjsYDDzxQ4wZM126PWbNmGcBeX2PHjjUMo+6u1fLly42TTjrJcDgcRqtWrYzHHnusoU6x3uzv2m3evLnWfYAxa9asyDF07Wr/ufut2sKArt2+r91rr71mdO7c2XA6nUbfvn2NTz75pMYxmuvf3gNdu127dhnjxo0zMjMzDafTaXTt2tV48sknjVAoFDlGc712+/p9NnHixEiZuro2s2bNMvr162fY7XajY8eONT6jvpkMo9oSpSIiIiIi0mxozICIiIiISDOlMCAiIiIi0kwpDIiIiIiINFMKAyIiIiIizZTCgIiIiIhIM6UwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlMKAiIiIiEgzpTAgIiIiItJMKQyIiIiIiDRTCgMiIiIiIs2UwoCIiIiISDOlMCAiIiIi0kwpDIiIiIiINFMKAyIiIiIizZTCgIiIiIhIM6UwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlMKAiIiIiEgzpTAgIiIiItJMKQyIiIiIiDRTCgMiIiIiIs2UwoCIiIiISDOlMCAiIiIi0kwpDIiIiIiINFMKAyIiIiIizZTCgIiIiIhIM6UwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlMKAiIiIiEgzpTAgIiIiItJMKQyIiIiIiDRTCgMiIiIiIs2UwoCIiIiISDOlMCAiIiIi0kwpDIiIiIiINFMKAyIiIiIizZTCgIiIiIhIM6UwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlMKAiIiIiEgzpTAgIiIiItJMKQyIiIiIiDRTCgMiIiIiIs2UwoCIiIiISDOlMCAiIiIi0kwpDIiIiIiINFMKAyIiIiIizZTCgIiIiIhIM6UwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlMKAiIiIiEgzpTAgIiIiItJMKQyIiIiIiDRTCgMiIiIiIs2UwoCIiIiISDOlMCAiIiIi0kwpDIiIiIiINFMKAyIiIiIizZTCgIiIiIhIM6UwICIiIiLSTCkMiIiIiIg0UwoDIiIiIiLNlLWxK9CYQqEQ2dnZxMXFYTKZGrs6IiIiIiJHzDAMSktLyczMxGze/7P/Zh0GsrOzadOmTWNXQ0RERESkzm3fvp3WrVvvt0yzDgNxcXFA+ELFx8c3cm1ERERERI6cy+WiTZs2kXvd/WnWYaCqa1B8fLzCgIiIiIg0KQfTDV4DiEVEREREmimFARERERGRZqpZdxMSERGR5isUCuHz+Rq7GiKHzGazYbFY6uRYCgMiIiLS7Ph8PjZv3kwoFGrsqogclsTERDIyMo54enyFAREREWlWDMNg165dWCwW2rRpc8B52EWOJoZhUFFRQV5eHgAtW7Y8ouMpDIiIiEizEggEqKioIDMzk+jo6Maujsghi4qKAiAvL4+0tLQj6jKkKCwiIiLNSjAYBMButzdyTUQOX1WQ9fv9R3ScQw4Dc+bM4fzzzyczMxOTycQnn3wS2ef3+7n33nvp3bs3MTExZGZmcu2115KdnV3jGIWFhYwePZr4+HgSExO5/vrrKSsrq1FmxYoVDBs2DKfTSZs2bXj88cf3qsv7779Pt27dcDqd9O7dmy+++OJQT0dERESaqSPtay3SmOrq5/eQw0B5eTl9+/blhRde2GtfRUUFS5Ys4cEHH2TJkiV89NFHrF27lgsuuKBGudGjR7N69WpmzJjB9OnTmTNnDjfddFNkv8vl4qyzzqJdu3YsXryYf//73zz88MO88sorkTLz5s1j1KhRXH/99SxdupSLLrqIiy66iFWrVh3qKYmIiIiINEsmwzCMw36zycTHH3/MRRddtM8yP/30E8cffzxbt26lbdu2/PLLL/To0YOffvqJQYMGAfDVV19x7rnnsmPHDjIzM3nppZd44IEHyMnJiTTh/elPf+KTTz7h119/BeDKK6+kvLyc6dOnRz5ryJAh9OvXj5dffvmg6u9yuUhISKCkpEQrEIuIiDQTHo+HzZs306FDB5xOZ2NXR+Sw7O/n+FDucet9zEBJSQkmk4nExEQA5s+fT2JiYiQIAAwfPhyz2czChQsjZU4++eQafflGjBjB2rVrKSoqipQZPnx4jc8aMWIE8+fP32ddvF4vLperxpeIiIiI1NS+fXuefvrpyOvfdg0/HHVxDKl79RoGPB4P9957L6NGjYqkkpycHNLS0mqUs1qtJCcnk5OTEymTnp5eo0zV6wOVqdpfm0cffZSEhITIV5s2bY7sBEVERESagV27dnHOOeccVNmHH36Yfv36HdExpOHUWxjw+/1cccUVGIbBSy+9VF8fc0juu+8+SkpKIl/bt29v7CqJiIiI1Iu6XF05IyMDh8PR6MeQulcvYaAqCGzdupUZM2bU6KuUkZERWSShSiAQoLCwkIyMjEiZ3NzcGmWqXh+oTNX+2jgcDuLj42t8iYiIiBhGqFG+DsWpp57KhAkTmDBhAgkJCaSmpvLggw9SNfyzffv2/O1vf+Paa68lPj4+MjnLDz/8wLBhw4iKiqJNmzbcdtttlJeXR46bl5fH+eefT1RUFB06dGDKlCl7ffZvu/js2LGDUaNGkZycTExMDIMGDWLhwoVMmjSJv/71ryxfvhyTyYTJZGLSpEm1HmPlypWcfvrpREVFkZKSwk033VRjdslx48Zx0UUX8cQTT9CyZUtSUlIYP378EU+lKTXV+aJjVUFg/fr1zJo1i5SUlBr7s7KyKC4uZvHixQwcOBCA7777jlAoxAknnBAp88ADD+D3+7HZbADMmDGDrl27kpSUFCkzc+ZM7rjjjsixZ8yYQVZWVl2fkoiIiDRhhhFi166ljfLZLVv2x2Q6+GezkydP5vrrr2fRokX8/PPP3HTTTbRt25Ybb7wRgCeeeIKHHnqIv/zlLwBs3LiRs88+m7///e+8/vrr5OfnRwLFxIkTgfBNd3Z2NrNmzcJms3Hbbbft9eC2urKyMk455RRatWrFtGnTyMjIYMmSJYRCIa688kpWrVrFV199xbfffgtAQkLCXscoLy9nxIgRZGVl8dNPP5GXl8cNN9zAhAkTIuEBYNasWbRs2ZJZs2axYcMGrrzySvr16xc5XzlyhxwGysrK2LBhQ+T15s2bWbZsGcnJybRs2ZLLLruMJUuWMH36dILBYKQPf3JyMna7ne7du3P22Wdz44038vLLL+P3+5kwYQJXXXUVmZmZAFx99dX89a9/5frrr+fee+9l1apVPPPMMzz11FORz7399ts55ZRTePLJJxk5ciTvvPMOP//8c43pR0VERESakjZt2vDUU09hMpno2rUrK1eu5KmnnorcHJ9++un88Y9/jJS/4YYbGD16dOThaZcuXXj22Wc55ZRTeOmll9i2bRtffvklixYtYvDgwQC89tprdO/efZ91mDp1Kvn5+fz0008kJycD0Llz58j+2NhYrFbrfntrTJ06FY/HwxtvvEFMTAwAzz//POeffz7/+te/IuNCk5KSeP7557FYLHTr1o2RI0cyc+ZMhYE6dMhh4Oeff+a0006LvL7rrrsAGDt2LA8//DDTpk0D2GvgyKxZszj11FMBmDJlChMmTOCMM87AbDZz6aWX8uyzz0bKJiQk8M033zB+/HgGDhxIamoqDz30UI21CE488USmTp3Kn//8Z+6//366dOnCJ598Qq9evQ71lI5q01dks2hzIfef2x2n7fCXmhYREZHamUxmWrbs32iffSiGDBlSY7GprKwsnnzyyciqytVnawRYvnw5K1asqNH1xzAMQqEQmzdvZt26dVit1khvDYBu3bpFZoGszbJly+jfv38kCByOX375hb59+0aCAMDQoUMJhUKsXbs2EgZ69uyJxbLn/qdly5asXLnysD9X9nbIYeDUU09lf0sTHMyyBcnJyUydOnW/Zfr06cPcuXP3W+byyy/n8ssvP+DnHatcHj8TpoabLdPiHEw4vUsj10hERKRpOtSb8qNV9ZtrCPfo+P3vf89tt922V9m2bduybt26Q/6MqKiow67foarqLl7FZDIRCh3aWAvZv6bxk99Efbh4R+T7N+ZvxRfQD7+IiEhzVrUmU5UFCxbQpUuXGk/PqxswYABr1qyhc+fOe33Z7Xa6detGIBBg8eLFkfesXbuW4uLifdahT58+LFu2jMLCwlr32+32SEvFvnTv3p3ly5fXGMj8448/Yjab6dq1637fK3VLYeAo9tny7Mj3eaVeftpS+z86ERERaR62bdvGXXfdxdq1a3n77bd57rnnuP322/dZ/t5772XevHlMmDCBZcuWsX79ej799FMmTJgAQNeuXTn77LP5/e9/z8KFC1m8eDE33HDDfp/+jxo1ioyMDC666CJ+/PFHNm3axIcffhhZ+LV9+/aRMaW7d+/G6/XudYzRo0fjdDoZO3Ysq1atYtasWdx6662MGTNmr3WkpH4pDBylPP4gq3aGV0ge2C48g9IPG3Y3ZpVERESkkV177bW43W6OP/54xo8fz+23315jTOVv9enTh9mzZ7Nu3TqGDRtG//79eeihhyKTtgBMnDiRzMxMTjnlFC655BJuuummvRaIrc5ut/PNN9+QlpbGueeeS+/evXnssccirROXXnopZ599NqeddhotWrTg7bff3usY0dHRfP311xQWFjJ48GAuu+wyzjjjDJ5//vkjuDpyOEzGwXTyb6JcLhcJCQmUlJQcdWsO/LylkMtenk9qrJ37z+3OXe8tp3erBD679aTGrpqIiMgxzePxsHnzZjp06IDT6Wzs6hy0U089lX79+vH00083dlXkKLC/n+NDucdVy8BRavHWIiDcKnBS51QAVmWXUFRed6sJioiIiEjzpjBwlKrqEjS4fTJp8U6OS4/FMODHjeoqJCIiIiJ1o85XIJYjV1TuY97GAgCGdw8PojmpcwvW5Zbx44bdnNcnc39vFxERkSbo+++/b+wqSBOkloGj0DdrcgiGDHq0jKd9ani+4GFdwl2FNIhYREREROqKwsBR6JOl4SlFR/ZpGdk2qH14RqHthW4Kq40b8PiD/D979x0eVZm3cfx7pk96QiAhIUDoIB0UQlFUFLuoa0HUVVnbir2sriu66iuube24NkDslUVU1EUR6U167xBIgfQ29bx/DAxEQCkJE8L9ua5cZM555sxvQjv3PG1rYcXRLVBERERE6gWFgTpma2EFM9fvxDBgcLf08PFYl51mDaIAWLG9JHz8b58vpv/TP1XboExERERE5GAoDNQx43/NBiCrRQPSE6pv+NGhcWhpqGXbivEHggSCJv9duA3ThHs+XUReSdVRr1dEREREjl0KA3WIaZp8viAUBi7u3mSf8yekhcLAk9+spMMj33H/Z4urnV+4pajWaxQRERGR+kOrCdUB/kCQr5dsZ86GAjbsKMdtt3J2x9R92p2QFh/+3usP8vmC6kODNuwor/VaRURERKT+UM9AhN324a+0euhb7vhoIe/P3gzA5SdmEO3cN6f1bZXMFSdm0DUjYb/XUhgQERGRmvToo4/StWvXGr3mmDFjSEhIqNFrHokpU6ZgGAZFRUVAzdRX197j71EYiKDckiq+WrQt/NgwYEDbhjx4Trv9tnfYLDx1SWfG39qX6/o2ByAzOZp/nNsegPUKAyIiIiJH5PLLL2f16tUH3b558+a88MILR3SNSNIwoQj6ZU1oz4D0BDc/3TsAm8XAMMAwjD987j1ntqVrRgKntmvEhvxQCFDPgIiIiByPTNMkEAhgsx35ra3b7cbtdv9xw1q+xtGinoEImro6H4CLu6fjsFmwWAwMwyAYDFBenoe3Ih+/txSfp2Sf58Y4bVzYNZ04lz28MVl+qYfSKt9RfQ8iIiJydAwYMIDbbruNO++8k8TERFJSUnjzzTcpLy/nuuuuIzY2llatWvHtt9+GnxMIBBg2bBiZmZm43W7atm3Liy++WO26U6ZM4aSTTiI6OpqEhAT69u3Lpk2b9lvDunXraNGiBcOHD8c0TTweD/feey/p6elER0fTq1evfXZKHjNmDE2bNiUqKoqLLrqInTt3/u773LhxI4Zh8NFHH9GnTx9cLhcdO3bk559/rlazYRh8++239OjRA6fTybRp0wgGg4wcOTL8frt06cJnn31W7frffPMNbdq0we12c+qpp7Jx48Z96v3tEJ+vvvqKE088EZfLRXJyMhdddFH492TTpk3cddddGIYR/kB3f9cYNWoULVu2xOFw0LZtW8aNG1ftvGEYvPXWW1x00UVERUXRunVrJkyY8Ls/q5qgMBBBCzYXApDVskG14+XluRR/1ZMdHzUi77048t+Pp+LnIQe8TrzbTuN4FwDLt+0bHERERKQWBY/eB3Fjx44lOTmZOXPmcNttt3HLLbdw6aWX0qdPHxYsWMCZZ57J1VdfTUVFaEPSYDBIkyZN+PTTT1m+fDkjRozg73//O5988gkAfr+fwYMHc8opp7B48WJmzpzJjTfeuN9RCosXL6Zfv35ceeWVvPLKKxiGwfDhw5k5cyYfffQRixcv5tJLL+Wss85izZo1AMyePZthw4YxfPhwFi5cyKmnnsoTTzxxUO/1vvvu45577uHXX38lKyuL888/f58g8cADD/DUU0+xYsUKOnfuzMiRI3n33Xd5/fXXWbZsGXfddRdXXXVVOEhs2bKFiy++mPPPP5+FCxfyl7/8hQceeOB36/j666+56KKLOOecc/j111+ZPHkyJ510EgBffPEFTZo04bHHHmP79u1s3759v9f48ssvueOOO7jnnntYunQpN910E9dddx0//fRTtXb//Oc/ueyyy1i8eDHnnHMOQ4cOpaCg4KB+XofNPI4VFxebgFlcXHzUX7vC4zebPzDRbPa3iebOMk+1cztzF5vZb1Pta9vbmP5pVx/weje9O89s9reJ5qgpa2u7dBERkWNaZWWluXz5crOysvLILzbzetN8n9CvteyUU04x+/XrF37s9/vN6Oho8+qr99wfbN++3QTMmTNnHvA6t956q3nJJZeYpmmaO3fuNAFzypQp+237yCOPmF26dDGnT59uJiYmms8++2z43KZNm0yr1WpmZ2dXe87pp59uPvjgg6ZpmuaQIUPMc845p9r5yy+/3IyPjz9gfRs2bDAB86mnngof8/l8ZpMmTcx//etfpmma5k8//WQC5vjx48NtqqqqzKioKHPGjBnVrjds2DBzyJAhpmma5oMPPmh26NCh2vm//e1vJmAWFhaapmmao0ePrlZfVlaWOXTo0APW26xZM/Pf//53tWO/vUafPn3MG264oVqbSy+9tNrPBjD/8Y9/hB+XlZWZgPntt9/u93V/78/xodzjqmcgQjbsKMc0ISHKTlK0o9o5PwZEZdDAAY2d4LCACZSvG3fATx+6Nk0AYOHmototXEREREKCPlj/Tuj79e8clR6Czp07h7+3Wq00aNCATp06hY+lpKQAkJeXFz726quv0qNHDxo2bEhMTAxvvPEGmzeHVjBMSkri2muvZdCgQZx//vm8+OKL+3y6vXnzZs444wxGjBjBPffcEz6+ZMkSAoEAbdq0ISYmJvz1888/s27dOgBWrFhBr169ql0vKyvroN7r3u1sNhs9e/ZkxYoV1dr07Nkz/P3atWupqKjgjDPOqFbPu+++e0T1LFy4kNNPP/2gaj6QFStW0Ldv32rH+vbtu8/72fv3Nzo6mri4uGq/l7VBE4gjZF1+GQAtG8ZUO26aJn6/B07+EluDVhj2KGKm/ZmCtR9SEYCYmX/B0nfsPtfrtmu50fmbC/H4Azht1lp/DyIiIsc1ix1aXB8KAi2uDz2uZXZ79dcwDKPasd3De4LBIAAfffQR9957L8899xxZWVnExsbyzDPPMHv27PBzRo8eze23386kSZP4+OOP+cc//sEPP/xA7969AWjYsCFpaWl8+OGHXH/99cTFhTZBLSsrw2q1Mn/+fKzW6vcdMTHV729qS3R0dPj7srLQvdXXX39Nenp6tXZOp/OwX+NoTgTe3+/v7t/L2qKegQhZv2sFoJYNo6sd9/urALBYrFid8WCx4+w7BpsBQRNK1r4LM6/b53qdmySQEGUnv9TDY18tr/03ICIiItD7bbjCG/q1Dpo+fTp9+vThr3/9K926daNVq1bhT8n31q1bNx588EFmzJhBx44d+eCDD8Ln3G43EydOxOVyMWjQIEpLS8PPCQQC5OXl0apVq2pfqamhzVPbt29fLXgAzJo166Bq37ud3+9n/vz5tG/f/oDtO3TogNPpZPPmzfvUk5GREa5nzpw5h1RP586dmTx58gHPOxwOAoHA716jffv2TJ8+vdqx6dOn06FDh9993tGgMBAhu3sGWvymZ8DnC034sdlc4WOG1UFCq6EAVAYguH7MPl2RboeVf1/eFYBP522lyvf7fyhFRESkhhyFHoHD1bp1a+bNm8d3333H6tWrefjhh5k7d274/IYNG3jwwQeZOXMmmzZt4vvvv2fNmjX73HRHR0fz9ddfY7PZOPvssykrK6NNmzYMHTqUa665hi+++IINGzYwZ84cRo4cyddffw0Q7nF49tlnWbNmDa+88gqTJk06qNpfffVVvvzyS1auXMmtt95KYWEh119//QHbx8bGcu+993LXXXcxduxY1q1bx4IFC3j55ZcZOzY0quLmm29mzZo13HfffaxatYoPPviAMWPG/G4djzzyCB9++CGPPPIIK1asYMmSJfzrX/8Kn2/evDlTp04lOzubHTt27Pca9913H2PGjGHUqFGsWbOG559/ni+++IJ77733oH4WtUlhIEJ+O0woNDyoiuLi0Bg+h6N6SHD0fw97xmBMwJMxZL//8Axo05DG8S68gSDzNxXW7hsQERGROu+mm27i4osv5vLLL6dXr17s3LmTv/71r+HzUVFRrFy5kksuuYQ2bdpw4403cuutt3LTTTftc62YmBi+/fZbTNPk3HPPpby8nNGjR3PNNddwzz330LZtWwYPHszcuXNp2rQpAL179+bNN9/kxRdfpEuXLnz//ff84x//OKjan3rqKZ566im6dOnCtGnTmDBhAsnJyb/7nMcff5yHH36YkSNH0r59e8466yy+/vprMjMzAWjatCmff/4548ePp0uXLrz++us8+eSTv3vNAQMG8OmnnzJhwgS6du3KaaedVq134bHHHmPjxo20bNmShg0b7vcagwcP5sUXX+TZZ5/lhBNO4D//+Q+jR49mwIABB/WzqE3GrtnLx6WSkhLi4+MpLi4Oj387WrYXV7I2r4yOafHEuWDHjlUEAl4gFAQaNGiNYVTPaqWl2yidcROu7RNJanf9frsk7/5kIV8syObWU1ty36D972QsIiJyPKuqqmLDhg1kZmbicrn++AlyVG3cuJHMzEx+/fVXunbtGuly6qzf+3N8KPe46hmIkMbxbvq3bkhitIOSkq3hIAAQH990nyAA4HJEQ/ZEPEHwr30HvMWYAQ9+b1m4TVaL0J4FXy/ejsevoUIiIiIicmAKAxHm8ZRQWRka0mMYBjExqdjt+5+1bnfG42r+J0wg3wt57yeQM9ZF3nuxeKddA8CZJ6SSHONk484K3py6/mi9DRERERE5BikMRFhx8RYAoqMb0bhxd+Li0n+3fVy/0ViN0L4DfjP0K0DV+tAeBPFuO/cNagPAd8tya7FyERERkZrXvHlzTNPUEKGjRGEggrzecvz+KgzDQmxs2kE9x+aIoVG760iyQ5IdXLt+B71pF4UnFfdpGZpcszKnREOFREREROSAFAYiqLKyAACXKwGL5eA3CTOy3sE11ItrSDlxV5ZC+nn4Nn+JOTO03FaTRDdJ0Q58AZMV20trpXYREREROfYpDESIaZrhMOB2Jx36BSx2sEVhszmxbpuICVSuHQ1BH4Zh0LlJPACLthTVXNEiIiIiUq8oDERIVVUhwaAfq9WB03kEy5pa7ES3GAJAqR/M2aF1gbs3TQTg8wVbCQaP29VjRUREROR3KAxESHl5HgBRUckYhnFE14reNak4YEL5mlDvwJCTmhLtsLJ4azHfL8+piZJFREREpJ5RGIgQt7sBdnsU0dH736nuUBhWJ7EtrwSgLBDqHWgY6+SKk0K7/01ds/+tsUVERETk+KYwECHR0Q1p2LA9FoutRq7n7hvqHQia4N01d6Bb0wQAlmYX18hriIiISOQMGDCAO++886DaTpkyBcMwKCoqOqLXbN68OS+88MIRXUPqNoWBesKwOnA1vwyAqvQ/gcVOp/TQJOKV20vx+oORLE9ERERE6iCFgXrEmfUGpJ9H1abPYNYwmiZFEeey4Q0EWZ2rJUZFREREpDqFgXrEaXdB9kQCJgTWvYNh+uncJAGAhVpiVEREZL9M06TC64/Il2ke3op/48aNo2fPnsTGxpKamsqVV15JXl7ePu2mT59O586dcblc9O7dm6VLl1Y7P23aNPr374/b7SYjI4Pbb7+d8vLyw6pJjk01M2Bd6gTD6sTW9CL8m7/E1/QqrBY7PZolMm3tDuZuLOCq3s0iXaKIiEidU+kL0GHEdxF57eWPDSLKcei3Yz6fj8cff5y2bduSl5fH3XffzbXXXss333xTrd19993Hiy++SGpqKn//+985//zzWb16NXa7nXXr1nHWWWfxxBNP8M4775Cfn8/w4cMZPnw4o0ePrqm3KHWcwkA9Y+/xHP72f8MX0xgX0CsztKHZ7PUFmKZ5xMuYioiISORdf/314e9btGjBSy+9xIknnkhZWRkxMTHhc4888ghnnHEGAGPHjqVJkyZ8+eWXXHbZZYwcOZKhQ4eGJyW3bt2al156iVNOOYVRo0bhcrmO6nuSyFAYqGfs9igqlz6Jb/sEaHc93bq/gc1ikFNSxdbCSjKSoiJdooiISJ3itltZ/tigiL324Zg/fz6PPvooixYtorCwkGAwtFDI5s2b6dChQ7hdVlZW+PukpCTatm3LihUrAFi0aBGLFy/m/fffD7cxTZNgMMiGDRto3779YdUmxxaFgXrGYXNC9gS8Bpjr3sF90uu0axzL0uwSlm8vURgQERH5DcMwDmuoTqSUl5czaNAgBg0axPvvv0/Dhg3ZvHkzgwYNwuv1HvR1ysrKuOmmm7j99tv3Ode0adOaLFnqsGPnT74cFIcrAWvGYAJbxuPJuBKXxU7zBtEszS5h886KSJcnIiIiR2jlypXs3LmTp556ioyMDADmzZu337azZs0K39gXFhayevXq8Cf+3bt3Z/ny5bRq1eroFC51klYTqodcJ70UWmJ0wwcwaxjNGoR6Azbu1OoAIiIix7qmTZvicDh4+eWXWb9+PRMmTODxxx/fb9vHHnuMyZMns3TpUq699lqSk5MZPHgwAH/729+YMWMGw4cPZ+HChaxZs4b//ve/DB8+/Ci+G4k0hYF6yOWIguyJeIPA+ndolhiaALS5QD0DIiIix7qGDRsyZswYPv30Uzp06MBTTz3Fs88+u9+2Tz31FHfccQc9evQgJyeHr776CofDAUDnzp35+eefWb16Nf3796dbt26MGDGCtLS0o/l2JMIM83AXuK0HSkpKiI+Pp7i4mLi4uEiXU2OCwQA5P1wM2RNIaXctc1Of5Yo3ZtE0KYqp958a6fJEREQiqqqqig0bNpCZmakVc+SY9Xt/jg/lHldzBuohi8WKvftIfB3/jjchk2b+0DCh7KJKfIEgdqs6hEREREREw4TqLYcjBpY+ieezFFKWD8dpsxAImmzSvAERERER2UVhoJ5yO+MgewKVAQiue4ceTRMA+GXNjsgWJiIiIiJ1hsJAPeVwROOygAlUBGBA22QAflqVH9nCRERERKTOUBioryx23C2HAlCVdiED2qUCMGv9TgrLD35DEhERkfrqOF5DReqB3btOHylNIK7HnH3HYlSU4N/yXzLdwzkh7S8s21bCmBkbueuMNpEuT0REJCLsdjuGYZCfn0/Dhg0xDCPSJYkcNNM08Xq95OfnY7FYwkvFHi4tLVoPlxYNC/ooeNdBVRCcFpjVbTO3friYeLed6Q+cRoxTWVBERI5PZWVlbN26Vb0DcsyKioqicePG+w0DWlpUQix24lpfg2fVu3iCMKD477RIHsb6HeV8MHsTN57cMtIVioiIRERMTAytW7fG5/NFuhSRQ2a1WrHZbDXSq6WegfrcMwAQ9FEyzkFZAFwW+N8JG7j/82U0jHXyy/2n4rJbI12hiIiIiNSgQ7nH1QTi+s5ix93qGgA8QbjA8xhp8S7ySz18Om9LhIsTERERkUhSGDgO2LPewr5rmdHA+tHc2L85AGNnbtJYSREREZHjmMLA8cBiJypzCADFKRdwVvsoXHYLa/PKWLC5KLK1iYiIiEjEaALxccLd/11KWt2JaVgJerYxqEMD/rson5HfrODWU1thYvL6z+uJdlgZdVUPzSUQEREROQ5oAnF9n0C8F6+3nJKSrXi9ZWwtDnL9RwWUefz7tPvrgJbcf1a7CFQoIiIiIkdKE4hlvxyOaBo0aIPDEU2TeAsvXtKY/q2T6ZgeR3LMnjVqx83SXAIRERGR44GGCR1nDMMgIaE5eXnLaJ/s451rOmO3u6n65Wqq1n9Ej5VfUFrlJ6/UQ0qcK9LlioiIiEgtUs/Acchmc+FyJQBQXp5HwFdBwZr3qAj4aWLPAWBdflkEKxQRERGRo0Fh4DgVE5MKQEXFDnLzV0D6BQA0iw8AsD6/PGK1iYiIiMjRoWFCxymHIxqHIwavd1cPQKcRQJAm+fOADIUBERERkeOAwsBxLD6+KeXledjtbgwzSHH2RJrYBwGwPr80wtWJiIiISG1TGDiO2e1uEhKahR9XNruElpXLAFiSXYJpmhiGEanyRERERKSWac6AhLl6v0bbFm1wGlXsLPeyJk+TiEVERETqM4UBCXPao3Bsn0Bn9woAZq3Ni3BFIiIiIlKbDjkMTJ06lfPPP5+0tDQMw2D8+PHVzpumyYgRI2jcuDFut5uBAweyZs2aam0KCgoYOnQocXFxJCQkMGzYMMrKqn8KvXjxYvr374/L5SIjI4Onn356n1o+/fRT2rVrh8vlolOnTnzzzTeH+nZkLzZHDJYmF9LNvQSAD+ZmU1Lli3BVIiIiIlJbDjkMlJeX06VLF1599dX9nn/66ad56aWXeP3115k9ezbR0dEMGjSIqqqqcJuhQ4eybNkyfvjhByZOnMjUqVO58cYbw+dLSko488wzadasGfPnz+eZZ57h0Ucf5Y033gi3mTFjBkOGDGHYsGH8+uuvDB48mMGDB7N06dJDfUuyF0fPZznngjtoEG1jZU4pL09e88dPEhEREZFjkmGapnnYTzYMvvzySwYPHgyEegXS0tK45557uPfeewEoLi4mJSWFMWPGcMUVV7BixQo6dOjA3Llz6dmzJwCTJk3inHPOYevWraSlpTFq1CgeeughcnJycDgcADzwwAOMHz+elStXAnD55ZdTXl7OxIkTw/X07t2brl278vrrrx9U/SUlJcTHx1NcXExcXNzh/hjqldLSbZSWbmfmZoN7xm8nPcHNtL+dqonEIiIiIseIQ7nHrdE5Axs2bCAnJ4eBAweGj8XHx9OrVy9mzpwJwMyZM0lISAgHAYCBAwdisViYPXt2uM3JJ58cDgIAgwYNYtWqVRQWFobb7P06u9vsfp398Xg8lJSUVPuS6uz2KFjyGCcu64PL6ie7qJIV27XMqIiIiEh9VKNhICcnB4CUlJRqx1NSUsLncnJyaNSoUbXzNpuNpKSkam32d429X+NAbXaf35+RI0cSHx8f/srIyDjUt1jvOe1ujOwJ2AwPfaPmAfDz6vwIVyUiIiIiteG4Wk3owQcfpLi4OPy1ZcuWSJdU5xhWJ+7MSwHo6AqtKrRsW3EkSxIRERGRWlKjYSA1NRWA3Nzcasdzc3PD51JTU8nLq75kpd/vp6CgoFqb/V1j79c4UJvd5/fH6XQSFxdX7Uv25er1GgAtnBsAWLFdw6lERERE6qMaDQOZmZmkpqYyefLk8LGSkhJmz55NVlYWAFlZWRQVFTF//vxwmx9//JFgMEivXr3CbaZOnYrPt2dZyx9++IG2bduSmJgYbrP36+xus/t15PDZnfGQfgGZjlAY2LCjnCpfIMJViYiIiEhNO+QwUFZWxsKFC1m4cCEQmjS8cOFCNm/ejGEY3HnnnTzxxBNMmDCBJUuWcM0115CWlhZecah9+/acddZZ3HDDDcyZM4fp06czfPhwrrjiCtLS0gC48sorcTgcDBs2jGXLlvHxxx/z4osvcvfdd4fruOOOO5g0aRLPPfccK1eu5NFHH2XevHkMHz78yH8qxzmr1Y616xM0OOcbkqJsBE1YlaNJxCIiIiL1zSGHgXnz5tGtWze6desGwN133023bt0YMWIEAPfffz+33XYbN954IyeeeCJlZWVMmjQJl8sVvsb7779Pu3btOP300znnnHPo169ftT0E4uPj+f7779mwYQM9evTgnnvuYcSIEdX2IujTpw8ffPABb7zxBl26dOGzzz5j/PjxdOzY8bB/GLKH3R6FsWwkbYy5gIYKiYiIiNRHR7TPwLFO+wwcWGnxZko/b8aoHdczruBi/tw7g38O7hzpskRERETkD0RsnwGpP3bPG2i1a97AipzyCFckIiIiIjXNFukCpG6y293QaQQtUj3wYSErckowTVM7EYuIiIjUIwoDsl9WqwOLxUrTRAt2q0FplZ+thZUs21ZMk8QoOqbHR7pEERERETlCGiYkB2Rb9gT2/2XRMS60L8TfPl/Mze8t4LyXp/Hlr1sJBo/b6SYiIiIi9YLCgOxf0Id96+cA3Bj7MgAz1u0Mn77r40U88/2qiJQmIiIiIjVDYUD2z2LHljkEgF5tW9C/dfI+TX5ckbfPMRERERE5digMyAHZe78Bg2bh6ziCh85tj9ViEOO0MeXeAQCsziulpMr3+xcRERERkTpLE4jlgGw2Nxg2Av4K2jSO5vNb+uCwWmieHE2TRDdbCytZtKWI/q0bRrpUERERETkM6hmQA7JYrFiXPQHf9cY/4zq6ZiTQIS20cUX3pokAzNxrHoGIiIiIHFsUBuTAgj7s2eMB8KwfB8E9Q4LO6JACwMdzt1DlC0SiOhERERE5QgoDcmAWO64WVwJQ1XgwWOzhU2d3TCU9wc3Oci+TluZEqEARERERORIKA/K7nH3HQPp5+LaMJzDjuvBxm9XCae0aAbAmrzRC1YmIiIjIkVAYkN9lNcCxfSIAVWvHVBsqlJ7oBiC7sDISpYmIiIjIEVIYkN9nsePKvAIAT/rFoaFCuwJBk91hoEhhQERERORYpKVF5Q+5+o6mpKqMqk1fsPOTZjirNhPT5nrS054FYKt6BkRERESOSeoZkD9ks1jDQ4U8ZZsp8YNv7Tukx4cmFOeWVOELBCNZooiIiIgcBoUB+WMWOwmtrsJi7DlU6ofk5XfgsFkImpBTXBW5+kRERETksCgMyEGx9RtHozbX0MAReuwJgrH+HZokuADYUlgRwepERERE5HAoDMhBs/Qdi/NKL5YmF2ICvqZDadogGoCNOxQGRERERI41CgNyaCx2HD2fhfTz8G54n1b+GQCszSuLcGEiIiIicqgUBuSQOWwuyJ6INwgtqyYBsDZfYUBERETkWKMwIIfM4UqE9AvwmtCqRWcA1qlnQEREROSYozAgh8xuj8Lo/CjBgdNo1u8fQGjjsXKPP8KViYiIiMihUBiQQ2YYBo7l/wc/9CN64c00iA4tMbRhR3mEKxMRERGRQ6EwIIcu6MOZ/TkAFes/pGXD0IpCmkQsIiIicmxRGJBDZ7ET1epaDMBnQmZwHqAwICIiInKsURiQw2Lp/QYua+j75p7JgMKAiIiIyLFGYUAOj8WOrfkVADRr0gLQ8qIiIiIixxpbpAuQY5f1xFeg1Z009cbC/A1s3FGOLxDEblXGFBERETkW6K5NDpvV6gDDRsOoAEnRDvxBkwWbCiNdloiIiIgcJIUBOWw2mxOAYNDHya2TAZiyOj+SJYmIiIjIIVAYkMNmsdgxDAMz6OPk1g0A+GllXoSrEhEREZGDpTAgh80wDCxLH4fvetOn6HEAVuaUUlDujXBlIiIiInIwFAbk8AV92LPHAxCT/RZtGoU2H5uzoSCCRYmIiIjIwVIYkMNnseNsMQSAqrSLOKlFaKiQwoCIiIjIsUFhQI6Iq+8YSD8P7+YvOcn3CQBfL9nGloKKyBYmIiIiIn9IYUCOiNUwsG+fCECfimfIbBBFbomHU5+dwsTF2yJcnYiIiIj8HoUBOTIWO65dOxFbmpzLO9edRIvkaPxBk0cnLKfC649wgSIiIiJyIAoDcsRcfd+G9PPwbPqC5mtuY9KdJ5OR5GZHmYeXJq+NdHkiIiIicgAKA3LE7FY7lm0TMQHfutE4LAH+cW4HAP4zdR1Ls4sjW6CIiIiI7JfCgBw5ix1Hsz8B4M0YAhY7g05I5awTUjFN+PLX7AgXKCIiIiL7ozAgNcJx0iswaBbeE0aEjw3ulgbA98tzME0zUqWJiIiIyAEoDEiNcDhiYOmTeL9qjznzegBObtMQp83CloJKVuaURrhCEREREfkthQGpEaF5AxMImqF5AwR9RDls9G/dEIDvluVEuEIRERER+S2FAakRhtWBq/mlAFSmXwoWOwBnnpACwPfLciNWm4iIiIjsn8KA1BhX1huQfh5VGz+FWcMAGNg+BYsBy7eXkFtSFeEKRURERGRvCgNSY5x2N0b2RAIm+Na+A/4KkqIdtGoUA8CSrVpiVERERKQuURiQGmNYnbiah5YY3eEF30fRMGsYHdPjAVii/QZERERE6hSFAalR7t6vAWACpX5g/Tt0Sgv1DGjzMREREZG6RWFAapQrqiEJra4EwBOEYPNr6dQkCYBFW4vwB4KRLE9ERERE9qIwIDUu6uT3sWcMxgSq/F46pseTEGVnR5mXLxZoN2IRERGRukJhQGpe0Idz+3gAfBs+wGUNcuuAVgC8OmWtdiMWERERqSMUBqTmWezYmoeGCvmbXAIWO0N7NyXKYWXTzgoWbimKbH0iIiIiAigMSC2x9X4DBs3C33EEAFEOG2d0CG1A9uWvGiokIiIiUhcoDEitsNlcYNgI+CsJBgMAXNK9CQAfzdnCpp3lkSxPRERERFAYkFpisVixLnsCvuuNf8Z1APRvnUy/Vsl4A0FOeWYK/f71IytzSiJcqYiIiMjxS2FAakfQhy17PADe9eMg6MMwDB4f3BGXPfTHbmthJU99uzKCRYqIiIgc3xQGpHZY7LgyhwBQlTYYLHYAMpOjGTW0B43jXQBMWZWvCcUiIiIiEaIwILXG3f9djPTz8W4ej3/6n8PHT23XiJkPnh6eQ/Di/1ZHqkQRERGR45rCgNQaCybO7V8BULb2XQj6qp2/7bRWWAz4aVW+JhSLiIiIRIDCgNQei52YVlcDUBmA4Kwbq51unhxNr8wGAExekXfUyxMRERE53ikMSK1y9HkbuwEm4Fk3Zp/egdPaNQLgp1UKAyIiIiJHm8KA1C6LHUfzywDwpP8pPJF4t9Pah8LAjHU7WZ9fdtTLExERETmeKQxIrXNmvQHp5+Hd9BnMGrbnRNBHy4YxnNauEYGgyXPfayKxiIiIyNGkMCC1zml3YWRPxG+Cd+07EPRRMXUoO9514J9xLfcNagvApGU55Jd6IlytiIiIyPFDYUBqnWF14mp+KRCaSMzsGyla+wHeIBSsGkv7FDddMxIIBE1O/L//8c60DZEtWEREROQ4oTAgR4W792sAVAWBDWMg/TwA/Cb4ZlzPZT0zwm0fm7icLxZsjUCVIiIiIscXhQE5KpzuJEi/gIAJvmbXQMd/hM8VrHmPy/0jePbSLpzYPBGA//y8HtM0I1WuiIiIyHFBYUCOCsOwYO8+EgbNoqLjE2DYsDS5AKtBKCCsH8ufuqXw1p9PxG23siq3lNkbCiJdtoiIiEi9VuNhIBAI8PDDD5OZmYnb7aZly5Y8/vjj1T7lNU2TESNG0LhxY9xuNwMHDmTNmjXVrlNQUMDQoUOJi4sjISGBYcOGUVZWfenJxYsX079/f1wuFxkZGTz99NM1/XakBtnt0WDYqCzPhUAVjp7P4d49lyDtErDYiXfbubBrGgDjf82OZLkiIiIi9V6Nh4F//etfjBo1ildeeYUVK1bwr3/9i6effpqXX3453Obpp5/mpZde4vXXX2f27NlER0czaNAgqqqqwm2GDh3KsmXL+OGHH5g4cSJTp07lxhv37GBbUlLCmWeeSbNmzZg/fz7PPPMMjz76KG+88UZNvyWpIQ5HDCx5jOCkE+GHfth+PAN3vzGQfh5Vmz4nOPM6AC7oEgoD3y7NwesPRrBiERERkfrNMGt4YPZ5551HSkoKb7/9dvjYJZdcgtvt5r333sM0TdLS0rjnnnu49957ASguLiYlJYUxY8ZwxRVXsGLFCjp06MDcuXPp2bMnAJMmTeKcc85h69atpKWlMWrUKB566CFycnJwOBwAPPDAA4wfP56VK1ceVK0lJSXEx8dTXFxMXFxcTf4YZD/MgIey9114g6GhQYl2sF9WRN77Cfh3PXYP9RLARtbIyeSVenjxiq5c2DU90qWLiIiIHDMO5R63xnsG+vTpw+TJk1m9OrSB1KJFi5g2bRpnn302ABs2bCAnJ4eBAweGnxMfH0+vXr2YOXMmADNnziQhISEcBAAGDhyIxWJh9uzZ4TYnn3xyOAgADBo0iFWrVlFYWLjf2jweDyUlJdW+5OgxrE5i21xPAwc0coI9rjU44nFnXgHsWnZ0zs1YLQZX9W4GwOMTV7Auv4xKb4BP5m5h/qb9/96KiIiIyKGr8TDwwAMPcMUVV9CuXTvsdjvdunXjzjvvZOjQoQDk5OQAkJKSUu15KSkp4XM5OTk0atSo2nmbzUZSUlK1Nvu7xt6v8VsjR44kPj4+/JWRkbHfdlKLer8NV3jhsnK4IBQY3X1CQ7s8QQiuewf8FVzduxkxThs7yjxc+vpM7v1sEfd/vphLRs1gwqJtkXwHIiIiIvVGjYeBTz75hPfff58PPviABQsWMHbsWJ599lnGjh1b0y91yB588EGKi4vDX1u2bIl0Sccnix1sUeGHNkcs9qYXYQL5tgwK348mbtGNfHJTFlEOKwXlXr5evD3cfsrKvAgULSIiIlL/1HgYuO+++8K9A506deLqq6/mrrvuYuTIkQCkpqYCkJubW+15ubm54XOpqank5VW/4fP7/RQUFFRrs79r7P0av+V0OomLi6v2JXWDu/drkHYugfItVAagbM1YOqS6ufuMNuE26QluAOZu0pKjIiIiIjWhxsNARUUFFkv1y1qtVoLB0KowmZmZpKamMnny5PD5kpISZs+eTVZWFgBZWVkUFRUxf/78cJsff/yRYDBIr169wm2mTp2Kz+cLt/nhhx9o27YtiYmJNf22pJZFuRKIyv0aqxF6XLVrEaErezXl0h5NuG9QW765vT8WA7YUVJJTXHXgi4mIiIjIQanxMHD++efzf//3f3z99dds3LiRL7/8kueff56LLroIAMMwuPPOO3niiSeYMGECS5Ys4ZprriEtLY3BgwcD0L59e8466yxuuOEG5syZw/Tp0xk+fDhXXHEFaWmhZSevvPJKHA4Hw4YNY9myZXz88ce8+OKL3H333TX9luQosNhcJLS9nkYOMNi1EdnMvxDlsPHMpV249dRWxEfZOSEtHoDJK3N//4IiIiIi8odqfGnR0tJSHn74Yb788kvy8vJIS0tjyJAhjBgxIrzyj2maPPLII7zxxhsUFRXRr18/XnvtNdq02TMkpKCggOHDh/PVV19hsVi45JJLeOmll4iJiQm3Wbx4Mbfeeitz584lOTmZ2267jb/97W8HXauWFq2D/BUUvh9NZQDcVki82huaY7DLW7+s54mvV9A2JZZJd/bHMIwIFisiIiJS9xzKPW6Nh4FjicJA3eSb/mfyV70LQKN2f8bWZ0z4XHGlj6yRk6nwBvjir33o3lRDwkRERET2FtF9BkSOlD3rLZy7/mRWrR0LwT3zQuLddk5vH1pC9rtl+19CVkREREQOjsKA1D0WO67MIQB40i6qNkwI4KwTQqtFfbc0h+O4Y0tERETkiCkMSJ3k6jcG0s/Du/lLAtOvqXZuQNuGuO1WNu6s4OnvVlFc4dv/RURERETkdykMSJ1kNQyc2ydiAjtXj8Mz9UoqKnZQUbKZKIeVa/o0A2DUlHVc/c5sgkH1EIiIiIgcKoUBqZssduJaXQWA34Sdaz+k6NNmFH3WjIovWnLTyS1p1iC0i/HircWMX5gdyWpFREREjkkKA1Jn2fuNI7n1kD0HAhUAeEo3kOT08/N9p3LPrh2KP1+wNRIlioiIiBzTFAakTnP0/4DozEurHfO5MsAW6hU444TQykILNhXhCwSPen0iIiIixzKFAanzYvu/S4wVknfvTlyxBf+MawFo0yiWeLedSl+AZdtKIlqniIiIyLFGYUDqPIvNRVzb63FYwL7rT6xn1/4DFovBic1DG4/NXr8zglWKiIiIHHsUBuTY0PttuMKLu0VoDkF5AJhzMwD9WiUD8M1SbUImIiIicigUBuTYYbET1Xc0FiO0wpBn7TsQ9HFu5zSsFoNFW4pYlVMa6SpFREREjhkKA3JMMaxOXM1DE4qr0i8Fi52GsU4GtGkIwFVvzya/1BPJEkVERESOGQoDcsxxZb0B6edRtfFTmDUMgCcu6khmcjT5pR4+m69lRkVEREQOhsKAHHOcdjeWbRMJmFC15h3wV9A43s1NJ7cA4OO5mwloR2IRERGRP6QwIMccw+okKvNyAAp8UPx+NMy8jrM7NcZhs7BxZwU3jZuPaSoQiIiIiPwehQE5JkX3fRtj1/flAfCuG0P8wht59tIuAPxvRS4rtmsysYiIiMjvURiQY5LVHk1K+2tx7foTXOiDwPoxXNCpIWedkArAhEXbIlihiIiISN2nMCDHLEvWaBKuLMFuQMCEUn/o+AVd0wD478Js/IFgBCsUERERqdsUBuSYZnHEEt/6agAqU88niIXT2jUiMcrO9uIqflqVH+EKRUREROouhQE55jn6vYs9YzBm9ldUTrsal93KZSdmAPDUtyvYUaZ9B0RERET2R2FAjn1BH1HbxwNQse5DCPoY1jeT1DgX6/LLOfelX1ifXxbZGkVERETqIIUBOfZZ7LhbXYsB+EzwzfwLjeJcvH9DL5omRZFb4uH5H1aHm3v8AYLah0BEREREYUDqB0vvN3BZQ99XrnsXgj5aNoxh1FXdAfh2aQ6bdpazcEsRXf75Pfd9tjiC1YqIiIjUDQoDUj9Y7LgyhwLgaTw4fPiEtHj6tUomEDQ55ZkpDH51OlW+IJ8v2MqMdTsiVKyIiIhI3aAwIPWGs99YjPTz8W0ZT/l7Dpg1DICnLulEUrRjn/bvz9p8tEsUERERqVNskS5ApKZYCBKT+xWlQIkf3OvewXLS6zRJjOKr2/qxYlsJ24orKa7w8dwPq/l1c2GkSxYRERGJKIUBqT8sdmLbXE/linfwm+DJGILbYgcgPcFNeoIbgDKPn+f/t5ptxVXklVTRKM4VyapFREREIkbDhKR+6f02rovWQ/p5eDZ8GB4qtLcYp402jWIB+HVL0VEuUERERKTuUBiQesfpjIfsiVQFwVz3DgR9+7TpmpEAwAINFRIREZHjmMKA1DtOdxK2jIsImlARAObcvE+bkzKTAJi9vuAoVyciIiJSdygMSL0U3ftlAMoDwPp9ewd6tQiFgYVbinhv1iZKq/btPRARERGp7xQGpF5yR6diNLkQvwk7vBD8qkO1800So8ITiv8xfimdHv2e9g9P4uXJayJRroiIiEhEKAxIvWSxWInq+TQA3iAUFq7F9JVXa/OX/pmkxDmJcoS2Lq70BXjjl/X4AsGjXq+IiIhIJCgMSL0Vm9CSmLhMADxBqJhxAwA+XyWmGeS6vpnM/vtAlv1zEItGnElStIPSKj/zN2lSsYiIiBwfFAak3rJYrMRdvIr4XbtplKz7kB15S8nPX05+/goCgdA8AcMwiI+yc0qbhgD8tCovUiWLiIiIHFUKA1K/WexEtb4OuwXM9Avw+j0A+P1VlJZuq9b01HaNAPhppcKAiIiIHB+0A7HUe0bWOzQ48TVKy/MIBgNYrQ7KynLw+SrCbSorC+mRDhYDVueW8fSkleSWeHjswhOIduqviYiIiNRPusuR44LF5iI+vikAfr+HsrIc/P5KTNOkqqqQwsINGEDnNBcLs6t4bco6ABKi7Dx8XoffubKIiIjIsUvDhOS4Y7M5MQwLpmni91dRXLw5fO7iTs5qbcfM2EheadXRLlFERETkqFAYkOOS3R7aY6CqqpBgMIDFYsXtTmJgGzcfXduSZ/7UmXapsQSCJj+vyo9wtSIiIiK1Q2FAjks2WygMlJfnhx9HRTUAIDPRxyXd0xjYPhnQ6kIiIiJSfykMyHHJ6YwDIBj0A2C3R+FwxGAYBoGAl9zcxXRtVALA1NU7qPQGIlariIiISG1RGJDjktMZh2EY4cd2exSGYcHhiAHANIO0a2QjLc5KmcfPN0u2R6pUERERkVqjMCDHJYvFisMRG368OwRERTXc08YwOO+E0HCij+ZuRkRERKS+URiQ41ZCQnMSEprTsGEHbLbQKkJudyKNGp1AUlJLUlO7cH7HWCwGzN1YyN+/XEJxhS/CVYuIiIjUHIUBOW5ZrXaiohqEVxbazWZz4XIlYLHYaNYwhd7NQkHhg9mbeeCLxZEoVURERKRWKAyI/I7o6IZc0zMm/PjbpTnM31QYwYpEREREao7CgMjvsFod9GmTwfTbUjivQ6gH4T8/r41wVSIiIiI1Q2FA5A/ExqaRmJjJld1DPQQ/LM9ja2FFhKsSEREROXIKAyJ/wDAMoqIa0LVFCzo3tmMCn8/PZtb6nZR5/JEuT0REROSw2SJdgMixwumMo2u6g8Xbffz7f6sBOLlNQ969/qQIVyYiIiJyeNQzIHKQrFYH3ZvGVjs2bU0+RRXeCFUkIiIicmQUBkQOQe9W6dUeB034eXV+hKoREREROTIKAyKHICWxEf88qwF3nRLLVT1CE4qnrFIYEBERkWOTwoDIITAMC1ef3JNLu0ST1dwBwJRVeQSCZoQrExERETl0CgMih8hisWG12umUaifWZaOwwseirUWRLktqUJUvEOkSREREjgqFAZHDYLU6sFkN+raIB+DeTxaxbFtxhKuSmvDalLV0fOQ7Zq7bGelSREREap3CgMhhsFpDQ4Ru6d+Y1DgX63eUc8moGazNK4twZXKknp60Cn/Q5KlvV0S6FBERkVqnMCByGCwWOwCZDax8c0d/TmyeSJUvyLPfrYpwZVJTkqIdkS5BRESk1ikMiByG3T0DAV85SdEO/u+iTlgMmLQshxf+t5rckip+WpmHPxCMcKVyKPaeK5Aa745gJSIiIkeHwoDIYbBaHbDkMfwT2sGsYbRJieXv57QH4IX/raHXk5O5bsxcHvpyaYQrlUOxtbAi/H2sSxu0i4hI/acwIHIYHDYnRvYEfCZ4174DQR9/6d+Cq3s3q9bu43lbmLVeE1GPFZt27gkDXr96dUREpP5TGBA5DFZ7FO7MywAoDwBzbgbgoXPbc9+gtoy+7kQGd00DYNqaHZEqUw7R5oI9YcDj1/KiIiJS/ykMiBym6D5vAFAVgOC6UO+Ay27l1lNbcWrbRpyU2QCABZsLI1mmHIIK754A4PGpZ0BEROo/hQGRw2R3xmOPaYYJFPrAnH1TtfM9miUCsHBLkSYSHyM8ew0N8miYkIiIHAcUBkQOV9BHrGcTBuAJQtma0RD0AWCaJk3jvMS6bFR4A7R66Fvu+3SRhp7Ucb6AwoCIiBxfFAZEDpfFjqv19cSHthygIrCnd6Dop8so/CiZK9Pmh5t/On+rVheq47zVegYU3EREpP5TGBA5Er3fxn1FGVYDAiZ41o6mqmw7lRs/A2CI5REGpmzFYQv9Vfts/laWbC2OZMXyO7waJiQiIscZhQGRI2TYo3FnXg5AZdolVHnLw+ccFj//bnAzqx8byEXd0gH42+eL9alzHaVhQiIicrzRrjoiNcDV523KPOVUbfoc/F5IvwDX9glUBcGTNphYi50Hz2nHz6vzWb69hOe/X02PZomUefyc1TGVKIf+KtYF1XoGfApsIiJS/9VKz0B2djZXXXUVDRo0wO1206lTJ+bNmxc+b5omI0aMoHHjxrjdbgYOHMiaNWuqXaOgoIChQ4cSFxdHQkICw4YNo6ysrFqbxYsX079/f1wuFxkZGTz99NO18XZE/pDD5sC+fSImYGZ/BWaA2CHFkH4e3s3jCc64jkaxLp66uBMA/5m6nhvHzefuTxZxy3sLIlu8hHn26hnwagUoERE5DtR4GCgsLKRv377Y7Xa+/fZbli9fznPPPUdiYmK4zdNPP81LL73E66+/zuzZs4mOjmbQoEFUVVWF2wwdOpRly5bxww8/MHHiRKZOncqNN94YPl9SUsKZZ55Js2bNmD9/Ps888wyPPvoob7zxRk2/JZE/ZrGT2PpqjF0P7TlfY59/G47tEwGoXDsGgj7OPCGVISdlVHvqrPU7qw1PkcjxVesZ0O+JiIjUf4ZpmmZNXvCBBx5g+vTp/PLLL/s9b5omaWlp3HPPPdx7770AFBcXk5KSwpgxY7jiiitYsWIFHTp0YO7cufTs2ROASZMmcc4557B161bS0tIYNWoUDz30EDk5OTgcjvBrjx8/npUrV+73tT0eDx6PJ/y4pKSEjIwMiouLiYuLq8kfgxyngtOupnz9ezgt4LBAedrlFK//GLsByW3/jNFnDBVePxe/NoMdZR52lHkB+Ob2/nRI05/BSLt29BymrMoHIDnGybx/DIxwRSIiIoeupKSE+Pj4g7rHrfGegQkTJtCzZ08uvfRSGjVqRLdu3XjzzTfD5zds2EBOTg4DB+75TzY+Pp5evXoxc+ZMAGbOnElCQkI4CAAMHDgQi8XC7Nmzw21OPvnkcBAAGDRoEKtWraKwcP87vo4cOZL4+PjwV0ZGxn7biRwuS79xxLa+FocFaHE97n6jMQCfCQWrx+KZOgS3NciE4f2Y9rfTyGoR2qV4SXZRJMuWXapPINacARERqf9qPAysX7+eUaNG0bp1a7777jtuueUWbr/9dsaOHQtATk4OACkpKdWel5KSEj6Xk5NDo0aNqp232WwkJSVVa7O/a+z9Gr/14IMPUlxcHP7asmXLEb5bkf3IGg1XeKH321hsbhJbDQlvTLZz7UeUve/EMe8GXHYrnZvEA7Bwi5YbrQv2nkDs1WpCIiJyHKjxMBAMBunevTtPPvkk3bp148Ybb+SGG27g9ddfr+mXOmROp5O4uLhqXyK1wmIPf+s6+QOSW18Znk/gCQLr34Ggj5MykwD4cWUugWCNjtiTw/DbfQZqeBSliIhInVPjYaBx48Z06NCh2rH27duzefNmAFJTUwHIzc2t1iY3Nzd8LjU1lby8vGrn/X4/BQUF1drs7xp7v4ZIXWHv/z4N214NgC8IZvM/g8VOv9bJxLls5JZ4mL1hZ4SrFG/A/M1j9Q6IiEj9VuNhoG/fvqxatarasdWrV9OsWTMAMjMzSU1NZfLkyeHzJSUlzJ49m6ysLACysrIoKipi/vz54TY//vgjwWCQXr16hdtMnToVn88XbvPDDz/Qtm3baisXidQVtr7vYjlrLmb6ueSuGktg+jU4bVbO7tgYgM/nZ+PxB/hozmbmbCiIcLXHJ+9v5glo4zEREanvajwM3HXXXcyaNYsnn3yStWvX8sEHH/DGG29w6623AmAYBnfeeSdPPPEEEyZMYMmSJVxzzTWkpaUxePBgINSTcNZZZ3HDDTcwZ84cpk+fzvDhw7niiitIS0sD4Morr8ThcDBs2DCWLVvGxx9/zIsvvsjdd99d029JpMY4VoyE7K8JmlCwehy+X4Zy+a6lRr/8dSsDn/+ZB75YwpVvzuK/C7P5flkO/r0+nV6bV6qx7LXotz0BWl5URETquxrf9vTEE0/kyy+/5MEHH+Sxxx4jMzOTF154gaFDh4bb3H///ZSXl3PjjTdSVFREv379mDRpEi6XK9zm/fffZ/jw4Zx++ulYLBYuueQSXnrppfD5+Ph4vv/+e2699VZ69OhBcnIyI0aMqLYXgUidEvQRt/0LsEBVMLTC0I41H9DRhPaNb2bF9hK2FFQC4A+a3PHRQgAu69mEf13SmQ/nbOHvXy7h2j7NefSCEyL4Ruovn1/DhERE5PhS4/sMHEsOZQ1WkRoxaxisfwe/uwVFxevxBsFugQ3J93LVzNPwBoI8PrgjD49fWu1pL17RNRwOAFY+fhYA42ZuolOTeHrvWqJUjkz3x3+goNwbfvzjPafQomFMBCsSERE5dIdyj1vjPQMi8jt6vw0nvY7NYidp2tXkrn4PXxC6Fz3Lu9fdy/qdHq44MYN1eWWMmbEx/LS9gwDAD8tz+WjuZqav3Um0w8r0B04jIcqBHBnfb4Zgac6AiIjUdzU+Z0BE/sCuZUct/cbhbHYxACV+6JX/IFf2aorFYnD/mS345wUn8L+7T8Zl3/PX1Ni1PumI/y5l+trQ6kPl3gCjp288qm+hvvLsGha0++esMCAiIvWdwoBIBEVl/QcIzSEoWzMaM+ChbMrlWD6N4s/GP2nVKJabTm4Zbv/m1aFduQsrQqtoue1WAEZP30BpVejY0uxinv9+Fcu2aSOzQ2GaZnhydqwz1Gnq8WkXYhERqd80TEgkglyueOJsoZ6BigBUTv4T/q0TAUhcOwY3cMuAt1idW0rjeDcDO6TQKT2eJdmhG/3XrurOExOXsy6/nIHP/0zLhjHMWBfqMfhhRR7f3tE/Um/tmOPfa9O3GKeNkip/tWMiIiL1kcKASCRZ7ES3vo7SFaMJmMCuIAChgOBaPwbXia8y6qoe4ePPX9aFj+ZuITnGyYA2Dak6sy23vL+A3BIPuSWecLsV20vYuKOc5snRR/MdHbP2XrI1alfPgFYTEhGR+k7DhEQizOj1H6JDo32IskKKEyxRGQRM2O6BnHHRVPw8hPLyPDyeUlqnxPLweR24ZUBLDMPg7E6Nua5vc1x2C1f1bsrHN/amX6tkAL5esj2C7+zYsncYiHaEfkN+O6FYRESkvlHPgEikWezEtb2emHXvYDGAzGtxtX2IivGtAQiaULTuI6gqg06PEh+fQXR0o2qXeOT8E/j7Oe2xW0P5ftPOCqat3cEHszfTKzMJX8Akq6WWH/09vl29AFaLgXPXXAxfQMOERESkflPPgEhd0PttLEO8cIUXskYTF5dOjA2S7ODe1WtA9kQw/ZSWbiMY9BMM+ikp2UplZSFAOAgAXNA1jcQoO9lFlfzp9ZkMfWsW6/LLIvDGjh27Vw6yWw0cu36W/qB6BkREpH5TGBCpKyz2PcuO2tzEtbkelxXiE1risIC7+Z+wO2IJBgMUF29mx46VlJXlUlS0gaqqYioqdlJenodpBrGYVdzYbGb40kET3t1r3wLZ1+6eAYfVgt0aWlvUq2FCIiJSz2mYkEhdtWuDMovFTnLQBxY7Xm8ZO3euDvcGQGhJzIKCteHHxcVbwPRzYeBR3Kkn82HhxazytOLzBdk8cHZ73A7r/l7tuLd7srDDZsG2q2dAw4RERKS+U8+ASF22q6dg968ORwxxcU3Cp2Nj03C5EgCwWu17nmfYIP08zoybyjtN7yTNnkOZx8//VuQercqPObt7ARxWS3iYkE+rCYmISD2nMCByjImObkRMTCouVwIxMSkkJbWkceNupKR0plGjjjgc0bjdiST0H03D1lditcAZsVMA+Gz+5sgWX4f59uoZ2D1MSGFARETqOw0TEjkGxcWlV3tsGKFcb7M5SU5ut+dE//eJ9vs5x/Mj7xZcxs+rd7Iqp5TkGAcNYpxHs+Q6b88EYkt4MraGCYmISH2nngGRei6q32iaOrbRJ3oeAINemErWyB9ZumsXYwkJDxOqNmdAPQMiIlK/KQyI1HNWexSJrYZwXdJH4WPeQJCXf1wTwarqnt29AHarBYeGCYmIyHFCYUDkOOA6+QO6tj2Ba5I+Dh/7flkOOcVVEayqbtm7Z2D3MCGvwoCIiNRzCgMix4m4Pq/z1+RxTG51CSe4VmJi8NPK7ZEuq87Y3QvgtFmw23YNE/JrzoCIiNRvCgMixwlHVCNSk1uT4vCE5w/8tGpnhKuqO7z7nUCsngEREanfFAZEjicXrMbxp1yyBg4HYNraHXj8gQgXVTd49t6B2BKaM+APKgyIiEj9pjAgcpyxu5Npm/cMDawFVHgDzPnmH5EuqU7w7T1nYNcwIa+GCYmISD2nMCBynDHMAEl5/yVr11Chq2f0462fV1LlO757CHZPFtYwIREROZ4oDIgcbyx23K2vZ2DcrPChJ75dx00vj8Hj9USwsMjaezUhLS0qIiLHC4UBkeNR77c55/qJ/F/jkdzY4F1cRhU/56Vy/b+eYuv/bol0dRHhC88ZMNQzICIixw2FAZHjlCOqIUN6tuT2lE94Ov1xHIaX6eU9OfvHAcyfeHekyzvq9rcDsTegOQMiIlK/KQyIHMcsfccS0+oa+sUsYlTG/XRwraI0GMPD85rBzOsiXd5RtXvOQGjTsV2rCalnQERE6jmFAZHjXZ+xJLW9ltPi1/JKmzEArKhqQfGaTyHoi2xtR9He+ww4NExIRESOEwoDIgJZozGGeMkcsogMdxEmFmaUtYc5N0e6sqNm72FCdg0TEhGR44TCgIiEWOwYhsGJbTIB+LGkJ6x/Z7+9A8FggPLSbPzeMkzTJOivPNrV1jjf3puO7dpnYPfeAyIiIvWVwoCIVHN+t1AY+LToPEZsvZqZE6pPJg74ysn/3yUUf9qEvPdiyfukGbnvRuGfcW0Eqq051eYMWLS0qIiIHB8UBkSkmlPbJHNa7EwA3i24nCGzzuKjDx/BNIMs/fom3n/tXLxbvgq3D5RvwQQq1449pucYhIcJ7d0zoDAgIiL1nC3SBYhIHWOx89qAXD6e/xpfFJ7CosoTeGDRSSwseI5vsgdQEryAyxPb8Gjam5T5IQAETahIPZ9ojGP2E4bd8wOq70CsOQMiIlK/Hav/b4tILXL1fZM/Dx/PuJPnc1XipwB8tKUDJcE4AD4uvJB1yXfSsEErGjnA4s4g0PERCgrWRbLsI+L1B4DqS4uqZ0BEROo7hQER2T+LHXefN7kleSztnGvCh1u7twPwzPYheM9ZheXycpIuWQ6A11tGIOCNSLlHyrdXz4CWFhURkeOFwoCIHJDdGUdS6yE8kPoKHVyr+HeTx3mhyZNYDPh5dT4PfL4YbFE4HDE4HDEAVFUVR7jqw7N7zoBzrx2INUxIRETqO4UBEfld7pM/4OQuffms5T1cmDibE044lZeGdAPgi1+zWZVTCoDLFQ9AZeVOAEzTJBA4diYUV99nIDRMyKueARERqecUBkTkD1n6jCVqqBfLEC/0fpvzOqdxTqdUAF76MTSEyO1ugGFY8HrLqajYQV7eUnJzF1NUtCmSpR+03UOCNExIRESOJwoDInJwLPbQ1y63n94agK8Xb+fcl37h8wU5REc3AqCoaFN47oDXW3r0az0Mnv3sQGyaEAhqqJCIiNRfCgMicljapcZxfpc0AJZtK+H+zxczbn4FTmdctXameWx8uu7dzw7EsGf4kIiISH2kMCAih+2ZP3Xmk5uyuOmUFgA8+/1q1hQnERubFp5DEAwGIlniQfOFdyA2wsOEADz+Y6N+ERGRw6EwICKHzWW3clJmEg+e3Z5LezTBNOHvXyzB4W5EQkJzINQzYJp1f6jNnh2IrditBpbQHOLw8CEREZH6SGFARGrEw+d3IDnGyfod5bw9bQOGseefl2NhqFB4ArHNwDAMXHYrAFU+9QyIiEj9pTAgIjUizmXnwbPbAfDy5LVkF1VhGKGP102zbt9QB4NmeE+B3UOE9oSBuh9kREREDpfCgIjUmIu7p3Ni80QqfQFueW8BOaWhG+m63jOw934CDpsFM+DBuWsSsXoGRESkPlMYEJEaYxgGz13alVinjSXZxVzzfh6r8311fhLx3vsJeGdcy/axLpz+fEBzBkREpH5TGBCRGtW0QRQf35RFx/Q4Sj0mD0wspKyqbu9EvPdQoMoNHwJg9+/Yda5uBxkREZEjoTAgIjWuQ1ocH9zQm8ZxNnJKg7zxS93ehXj3Db/bbsES3QQAl636ORERkfpIYUBEakWcy85tJycD8PXS/Dq9vGiFN3TD77IZULEFAIdZBkCVhgmJiEg9pjAgIrXmlNbx2C2wpdDDuvyySJdzQJW7ewYcFki/AACnOxEAj3oGRESkHlMYEJFaE+200b2JA4Dxv26LcDUHVuH1A+CyW6DTCBg0C0diG0A9AyIiUr8pDIhIrTEMKxd0jAJg9PQN7CzzhM9VVRVTWrqtTgwf2j0vwGXbte2wYcNhDdWlngEREanPFAZEpNYYhoUBLZ20T3VR7g3w8o9rw+cKCtZSWrqdsrKcCFYYsmfOwJ5jztCeY5pALCIi9ZrCgIjUGovFimEY3NDLDcCYGRt55L9Lq7WpC2GgcncYsBvhY+GeAQ0TEhGRekxhQERqjcMRC0Cvpg4u6hQKBGNnbmLJ1oJwG9MM4vNVRqS+3Sp9v+kZWPIYzq3vA+oZEBGR+k1hQERqjcMRTVpaD6KiGnDfqfGc1soFwFu/rK/WzuMp2ee5oZBQcVTmFOzuGXDaANOPkT0Bp+EFoGrX5GIREZH6SGFARGpdXFwTLBYrV/aIBuCrxbls2LnnJtvjKd7nOfPXreP292dy/8dT8fq8tVpftTkDhg1r04twWnaFAX/kJziLiIjUFoUBEal1Vqud5OR2dEix07+Fk6AJb84qxWZzAuD1lvHjiu1cMmoGw8bOJb9gKy9M3sS3K6v4dGEZ/1u2uVbr++1qQtZu/8LR7q+A5gyIiEj9pjAgIkeFzeYiPr4pN2XFYABT1nlYvdOKabiYt7mKOz5axPxNhUxekcdHs9ezPNcXfu6vm3fWam27ewbcdgMLJhaLFac9tJyQ5gyIiEh9ZvvjJiIiNSMqKpkO6SWc1a6cb1dWcdXY9RjAbwfivDC1lMBeBxdn1+7uxbsnEDt3/Ijlu8cxml+G03YboE3HRESkflPPgIgcNYZhkJjYgut7xWDd9a/P3kFgWN8MGsXaqgUBgOU5Hnw+b2hCcWDP/IGArwKCPo7U7gnE7tJfsRhgbP4EpzUUAtQzICIi9Zl6BkTkqDIMgy4tT2DEWWtYmmtwfb8WRJHH/I15nJjhpWlsNI9MCk0ovqxnE75YsJVSj8nyjUtpuP6fuLZPIK7VVRRWlePb/CXxNohucz30fvuwawovLdqgPQYTsTS7AqctNExIcwZERKQ+UxgQkaPO4Yjhzyd3Cz8OBFw4jXKCQT9ntHGT6LawtSKJP/Vszpz1eWws8DJ1bQnrFzbh5Jhu9Fr9Xvi55QGIXv8OnPQ6WOyHVU/FruVDXc0vwNLpLxjOeBxL1wHgUc+AiIjUYxomJCIRZ7U6aNCgDVarA4CeGU5uGdCGRrEuMpNDexM893M5Xxafw13ZjzOvonP4uX4TSh3NDzsIAFT6Qp/+u2wGFpsLw7Dg3rUbcbn2GRARkXpMYUBE6gS73U2jRh1xuRKIiUnBMEL/PGU2iN6n7RdF52I3wLXrX7DSko14fhl62K9dubtnwG5gsdiwWKzEOkMXL6448jkJIiIidZXCgIjUGYZhkJTUkri4JuFjrVLiw9+nxIX2JZhS1pfbtj7JYs7FvutfsfJ1Hxz2ZOI9m44ZGIYVw7AS5wr1DJRU+QkEtfGYiIjUTwoDIlKndc5IDn///l960b916PGs8s7ctvE2zKbXA+AJgjn7psN6jaJdn/7HuSzhnoE4555/Hksq1TsgIiL1k8KAiNRpHdPjefGKrky8rR+tGsXyr0s6k57gBqC0ys+73nvCexUE1o0+5N6BKl+AMk9omFBilAWLxYphWLBZDaIcod6BIoUBERGppxQGRKTOu7BrOh3TQ8OF0hLcTL3/VF65MrQa0ZcLc7A0uQiAQPOrD3kicUF5aN8CmwViHHuGCQHEOXeFgQrvAZ8vIiJyLFMYEJFjjtViMLB9CtEOK9lFlSxJeQQGzSLY44VDvtbuMJDotmAYeyYQs+Qx4ryrAfUMiIhI/aUwICLHJJfdyjmdGgMwenYRGDYCgUP/BH9HmQeABLcFTH9omJAZhOwJxFnLACgur6qxukVEROqSWg8DTz31FIZhcOedd4aPVVVVceutt9KgQQNiYmK45JJLyM3Nrfa8zZs3c+655xIVFUWjRo2477778Purr/c9ZcoUunfvjtPppFWrVowZM6a2346I1CG3ntoKm8Vg+voyFmz1HFYY2N0zkBDYCN/1xjLnZgyrA0uTC4m3lABQVKmNx0SORytzSli8tSjSZYjUqloNA3PnzuU///kPnTt3rnb8rrvu4quvvuLTTz/l559/Ztu2bVx88cXh84FAgHPPPRev18uMGTMYO3YsY8aMYcSIEeE2GzZs4Nxzz+XUU09l4cKF3HnnnfzlL3/hu+++q823JCJ1SPPkaIac1BSAUTPKCPjKD/kaO8t2DRPyr8UAjA2hSciWrk8Q1/xMQMOERI4nwWAo/Hv8AS59fSYXvDKdz+dvjXBVIrWn1sJAWVkZQ4cO5c033yQxMTF8vLi4mLfffpvnn3+e0047jR49ejB69GhmzJjBrFmzAPj+++9Zvnw57733Hl27duXss8/m8ccf59VXX8XrDf3H/frrr5OZmclzzz1H+/btGT58OH/605/497//XVtvSUTqoNtOD/UOLMvxsenz02DWsEN6/s7dPQPxDbAYQIvrwWLHYrER6wpNJC46ihuP+XyVlJZuxzS1t4HI0VZRsZM5K+YxZdkaNuwop7QqNCLh5R9XR7gykdpTa2Hg1ltv5dxzz2XgwIHVjs+fPx+fz1fteLt27WjatCkzZ84EYObMmXTq1ImUlJRwm0GDBlFSUsKyZcvCbX577UGDBoWvsT8ej4eSkpJqXyJybGsU66JbRhwAM8q7Ya5755CWF925a85AYkYWlnMWQe+3AbBYbMTt2uK48CitJhQMBsjPX05p6TYqK3celdcUkT2+/nU1V4zbwbXjVvPu9LXh4xt3VpJXorlDUj/VShj46KOPWLBgASNHjtznXE5ODg6Hg4SEhGrHU1JSyMnJCbfZOwjsPr/73O+1KSkpobKycr91jRw5kvj4+PBXRkbGYb0/Ealb+rcJ/Vswt6Ir3qZDD2l50dzSUBhIirJgsbnDxy0WG8nRoX8ic4pr/iagqqqIvJxfyc9fjs9XAUBZWU74vMdTSiDgVQ+ByFHi9Zbzxsw9HxJ+MHd7tfPTVm08yhWJHB01Hga2bNnCHXfcwfvvv4/L5arpyx+RBx98kOLi4vDXli1bIl2SiNSAfrt2JZ5f1YPK9R8e0lChLQWhG/G0OCsWiy183GKxkxIbGia0rXj/HzAcrkDAS+HP1+D/pju+BQ9SXLwF0zSpqNgRblNZWUBu7hJycxdTWVnAzp2rKSraiGkGj/j1txZW4Asc+XVE6pPFW3awZod/n+OW0HYj3P35OuZuyN3nvMixrsbDwPz588nLy6N79+7YbDZsNhs///wzL730EjabjZSUFLxeL0VFRdWel5ubS2pqKgCpqan7rC60+/EftYmLi8PtdrM/TqeTuLi4al8icuzrnB5PrNNKqd/FoopWsP7ghgoFgiZbC0NhID3BhtW6p0fBYrGFw0BOcRXBYM19Ql829SrM7K9CNxnZE/B6iigsXE8wuO+NSDDop7BwAx5PKRUVOykpyT6i156zoYB+//qJC16ZHn7vIgIz14eG5nVs7Kh2/OlLOoa/v/rt+azLyaPSqxXGpP6o8TBw+umns2TJEhYuXBj+6tmzJ0OHDg1/b7fbmTx5cvg5q1atYvPmzWRlZQGQlZXFkiVLyMvLC7f54YcfiIuLo0OHDuE2e19jd5vd1xCR44fNaiGrZRIAM8q6Esy89qCGCm0rqsQXMLFZDBpGW37TMxAaJmQxwBcww/sRHCkz4KVy46cAJNrA1exiMGxUVRWFjiW2wG6PwjAsJCe3JSqqQbXn7253uD6YvQmAFdtLOPuFX9i449BXYBKpj+ZtCg0RGtQhmZHnJpASY+H+0xtyUfempMY5Aajym5z+wly6PvYdkxZvjmS5IjWmxsNAbGwsHTt2rPYVHR1NgwYN6NixI/Hx8QwbNoy7776bn376ifnz53PdddeRlZVF7969ATjzzDPp0KEDV199NYsWLeK7777jH//4B7feeitOZ+gv5M0338z69eu5//77WblyJa+99hqffPIJd911V02/JRE5BgxoG+o1/K50AB7fvp+w78/uIULp8TasFmOfMGBb9jjJ1nwAsotqZqiQ119FMO08rAY4Wv6ZuFM+CPdIxMU1we1OpEGDNjRq1BGHI4aEhOYkJbUkIaE5hmEQCHgPaz8Fgj5mr9/JV4v3jIMu9fj5cK5uaES2FxQwZ1Po34PeLVMZ3LMD39/WiRtP7YzVYvDpzX0Y1i8T664hQx6/yVOffYM589BWLxOpiyKyA/G///1vzjvvPC655BJOPvlkUlNT+eKLL8LnrVYrEydOxGq1kpWVxVVXXcU111zDY489Fm6TmZnJ119/zQ8//ECXLl147rnneOuttxg0aFAk3pKIRNh5nZJxG5Vs9Dbll6WLwP/HQ2A27Q4DCfZduw/vCQNWw4DsCaTYQmFge2FZjdRZOeMGyJ6Iq9mfMPqMwWZz0rDhCTRqdAIxMaGJ0BaLtdqQJZcrgaioBtjtUUD1icZ/JBDwUvTjpewcF8vNY34mEDTpkZjHyxlPAvCfn9fz7x+0bKIcnyq8fsZM38CfR8+n0mfSPsVJj+apuN2JxMc3wWYLzX3MSIri4fM6sOThk/mm5ZXY8LHRm8GkX1cc0uplInWR7Y+bHLkpU6ZUe+xyuXj11Vd59dVXD/icZs2a8c033/zudQcMGMCvv/5aEyWKyDEuLiqK8zO288nmFnxX3Jfu70XjbHYZ7qxR2FxJ+33OmtzQDX5T/xz47gEsba6Gfu8CYHPEQPoFpGzPZ0kVbCw88mFCQX8llRs+AcC97bPQTYTFjsVixWLZNVm5qJKdZV46psdhGEa157tcCXi95ZSX5+N0xuFyJfzha+6cfBkfL/XxXN7nQKgX5OkGt2DBxGF48ZoORv28jlsGtMRltx7xexQ5lvz1/QVMWRUK/E6bweMXdcViMQ7YPioqlvYdL+HsHT/yVfEg7thyH82/u5v2Z798tEoWqXER6RkQEakNA08O7WQ+p6Ib3iDkrfsv+R80wD++1X7bL95aBEAbX2jncuumceFP+QzDgq3b/9GhyzkAzFpfcGTFBX1UVJVgRmVgt4AjrvU+8xo+m7+Vfv/6kfNfmcbQt2ZTVFF9adHo6BSiokIrJ5WWVl/2cH8Cvgqmr9rMc3l/DR/7s+tZ3BYPTouX95rdCoDXH2TB5sIje38ix5jFW4vCQeBPXaIYe1UzejZP/sPnGb3+w4jUUfSKmo/XdPDYvIYw87raLlek1igMiEi9kdWqETYjyBZfOq/v+DNnrv2Yyze8zvQcxz7DhvyBIMu2hSYMtmvaBAOwtLiu2g26zebixKahYQLT1+6gynfgFURM0+Tz+Zv4bO4GKrzV5yyUT7mCwnEOSqcNg4otRFuBsjXVhhdsLazgkf8uZfeiRTPW7aTrYz9wy3sLwq9rGAZxcekYhoHPV4Hf//v7HwRMk7dKhwPQN3oOb2Xczblx/yPGCjE2aJLZgzPbhlZfm7VOm5zJ8WXirvkzZ7WP4+5T4jghPfHgnmix07D9NTyS9iYA8yo6U7b2Qw0XkmOWwoCI1BuxLjt9W4fG3b9bcCkBbGz2NeGmzU+wNDf0H/X8TYX8a9JK/rtwG5W+ANFOK0173Y71nAUYWe9Uu57N5qbFtpEkWwsIBE0GvzqdogPsRvztkq3c8+lS7v18Of944/Xw8bIpl1O8/mMqA2Bu+xqLAW4L0OL6cPAwTZOHvlxKuTfAic0T+eSmLBzW0D/Pk5bl8NS3K8PXs1hsOJ2hZZH/aGWhxVuLWFaSgsMKT6a/RKeo1TRwQJwd4lpfi73703RPD9Wwe1lFkePFL2tC+3pkNTXB9GOz7X9Z8v3q/Tbtr1tHY8dOfKadX3xnHNJmhyJ1icKAiNQrTwzuSFK0A4sBl3VvxIlNbFQFnfxl7Dz+7+vlDHljFqOmrOOeTxcBcGLTWCyGgdUes8+1HDYHxrYJ3JMyilhLOStzSrnlvfn77ApsmiYv/7hnEu432Y0p/+UvBHzllO2aIwChzYsSbWAYwEl7AsPS7BJ+Xp2Pw2rhqUs6c1JmEpPvOYXHLjwBgHdnbmTF9j07ozqd8QBUVh54aM+K7SX86Y2FAJzaOpZmHS4mxQmuVtfCFV7IGk1cXBO6Nwmtqb5wS5HWTpfjxvbiyvDfqZ5rzofvemNfcOchXcMwDPpFzwHg5/w09QzIMUthQETqlYykKP539ynMfPB0nry4M/88O4nkaAs5JVW8+csGvLt23jUMSI5x8vdB6RCowmp17HMtpzsZa3RTTomZyXsdXsRltzBzfQHvT1/I8m3FLNxSBMCU1fmsyKnCZVQRaymlynTx/vx8fhp/G5UBO56gg9SoGFIc4LRCXtpfeXD8Cp76diWmafLlr6GNxM48IYWWDWPC7+OarOac0ymVoAkj/rs0HELc7kQMw4LPV3HAQPDohGXh7y/plgy93w6HgN2fYDqdsTRPjiUlxoIvYDJv0xHOixA5Rnw6bysA3dxLSLSVYDPAtundQ7uht9g5tWUsANPLehCcfWNtlCpS647KakIiIkdTUnToxt40TRKjrPz7wjge+KYKt8PGbae14vzOaeSXebAZATxft4eKLdjiM+GS9dWuY5h+ojybKQWaBmZw9YkNeHNGPv+YuA3YBsC1fZqzYNdN9MUJX5NoLeHVHdfxZM6NkANwCQCXJX5P34F3snhbOZ9Myaa0agsAPyzPYV1+aOOvwV3T93kvD53bgZ9W5jN3YyH/XbiNwd3SsVhsxMSkUFq6nYqKfNzuRLzeMmw2F8u3l/PVom3M3hCq6eEz4slqsWss9H6GMcTEpNA1fTvfrapiwaYi+rdueCQ/epFjwu4Afn7DeVgMaOig2tC9g9X/nBFY533PFl86a5ZPom0vn4YLyTFHYUBE6i3DMLAue4KWm7/kh6whRJ3yQehE0EdKjJXiwk14KrZgAM7KDaFJxraoPRew2HG2uJrS1ePwNL6Av3RrwPaiMiYu37MB2ZgZGwGIsnq5KulLUh2VfFZ0Lrn+RtVq+aTwTD75dHn4cWKUncIKXzgIdG4Sz4C2+96Ipye4GX5aK575bhV3fryQn1blMXdDAfFuGy9eGAWUUllZQGHhBv67zMvTPxawexTT2e1cnN3eXW3/hN9yuRJo3dDBd6uqWJmjFYWk/tu0s5wNO8qxWaC//Rscxr5D9w5WbJSbbok7mFeYypSS7rSdc3OoF07kGKIwICL1V9CHK/tLyoDS9R9iNUwq/T6qNn2OFfClnQdRTUjwbcUe17p6ENjF3ncsRnkRwa0TMIC/DxzBkG7R5JYF2FTo56WppZjADX0bkHLiNJLWPssY7wMsrmxJ16jVTCg5h4Tuf2fJ9kq2F1fSIjmGAW0bcnKbhjz3/WpyS6ooqvTy+IUdsVn3P3LzL/0z+XTeFjburOC/C0M9EtuK4ZXp8MBpMRQWbsAXMPnP9EJME7qkuzi9lZ0LTgi9H5vNecAfkcVipV3jeKCE1TmlR/bzFqnjAkGTkd+EJuR3ittGtLWSKCuH1Suw2yndT2Le5M1MKTuJm9Y/GgoVR9g74PdXYdm1B4lIbVMYEJH6y2InpvU1VK56l4AJO9d+FD4VBMieiAG42l4Nfd/d7yUM048r5ysqAXPrBDjh77RJjSPTV0HvZk5ObuHGtCXQ2F0cmoScNZr2XEf7DWMAuK+jHXq32++1R5zf4aDehtNm5cmLO3HTuPmc2DyJzORo3p62gQlLy4iyB1myzceyXaslJUdbePmieGy7Nk6Ki0sPrz50IO3TkoAtbCqowuMP4LTpBkTqp0/nbWHSstAO3ue5PsJmgNPCYfUK7HZmx3Sen7yJmeU9mRt3LyceYRDw+SrJz1+OxWIlNbXrEV1L5GAoDIhIvWbpM5YEvzccBHZvLrp7Pf8oKxibxkHW2/v/NM9iJ7rl1VSuHhd6vPQJGpzxJRaLjby8pTSO8wAlgIHNFtqTgKzR0OuN8PNrQp+WySwacWZ4d9SCci9f/prNR79W3z/h0u7JxMUkYxhWoqIaYLfv29vxW02S4olxGJR5TVbllNK5SUKN1CxSl6zJLWXkrmV6/9LgPc6J+5EkOxgtrj2iv6dtUhM574QovlpWyQOrzuXjAR6SYw7cG/dHPJ7QKkfBoFb3kqNDqwmJSL3nPPlDklsPpaEDUp2hr7TkVjR2QrydPxwi4OjzNtZdIYLsiVhm3wCA251UrV04DEDoejU8kXB3EAB49IITuKp3U07KTOL8Lml0b5rA3We04Z6zepCQ0Jz4+IyDCgIAdnsUPTNCk66/WLClRmsWqSte+N8aiit9tHWu5arEz3BZwRbbMhTej4BhGNzaL4lYp8G6/HKGvjmbYND84yeK1BHqGRCR44Kj/3vQd6//9C12jN3LCP7RTbvFTlLrq9i55j0cBrBhDPR6g+joRlRWFuD3e3A4ov9wOE5NinfbeWJwpxq5lsVi5aLO8UxZl8cXC7K5/6z2RDn034PUH6ZphlfYur3hWzgtfuJsQPm60HKiRxjck2NdPHt+HDd9Vsyq3FLmbiygV4sGNVC5SO1Tz4CIHD92f1q/+z/+Q/j03t5vHI3aXkPSXksQWiw2GjRoS0JCM5KSWmMYxh9ep64a0D6DJvFWSqoCfDBrXaTLEakRvkCQ//t6Ob1HTmZHmQe74aODaxUpTkK9fUcwcXhv1sUP02lxfwanrQJgwqJtR3xNANMM1sh1RH6PwoCIyEGy9Bkb2rhrr6UDrVY7UVHJx/yqH7ExDRnaI7SB0lu/bMQX0E2IHPvenbmJN3/ZQG6JB4B2sTuJsfqwtLx+n7/Lhy3ow7b1MwD68DEA09buOIIL7hlipDAgR4PCgIjIoainGwpZLFau7NOBRLeFnFI/ExfXzCebIpH034XZ1R5f6P4AR/NLQyGgpv4uW+zEtPozbmtoR2MrATbtrGBrYcUfP3c/9g4AmkQsR4PCgIiIABAbFculXUOTjkdP38iUVXl8u2Q724oq2bCjPMLViRyabUWVLN5aDEDn9Fj6Rs/lzLgpOLd+GponUIOMPmOIb3UVMdZK2rtWAzBjTd5hXWvvMKCeATkaNENMREQAsFhsXHhCNO/MLmPx1mKuHT03fM4wYMx1J3FKm313SRapi+ZvCu2o3SFuB+/Hn0dpwwyoCOJodW2t9PBZ+o7DVVXJiTsWsrSqPdPmTOKyk24+5Ovs3RugMCBHg3oGREQkrGGcO7xzcWZyNG57aC6EacIDny/WXAI5ZizaUgRAO2MWpX6gYgt2C1iM2rv1cfV+jZ5RiwCYkRND0O895GtU7xnQMCGpfQoDIiISZrU6uGdALNPvasNP9w5g2t9O5dlLuxDtsLK9uOoIJ0aKHD2/7goDJ7hXh4+5LcD6d2p8mNBurqhkOiWVEWspY4c/kdmbSg/5GnsHAPUMyNGgMCAiImE2mxPDMDACJezcuZpYh48/9WjCpT0zAPhs/tYIVyjyx1bllDJ/UyEGQbq4l4WPu61A5rW1thCAYQaI8W5kQMx0AP7766Fv4qc5A3K0KQyIiEiYy5UY/t7jKWXHjlXk5CzijFZ+AL5Zsp3VuYf+aafI0fTJvNBN+CkNN9LCmUtyYguSHWBtce0R7zj8uyx2HJlDODNuCgDfLM3F4z+0oT57zxnQakJyNCgMiIhImNMZS1paD5KSWoV3VA4G/WQm+Dm1dRSmCc9+tyrCVYr8vt2BtY/lKxzNL8dx0TocV3prNwjs4uzzFt1aNaOhbQclVX5+/uqRQ3q+egbkaFMYEBGRfbhc8TRo0BqHIzp87C8nRWEx4PvluVzzzpyD+8SzlsZmi/ye9fllAGQ4snFu/Tj05/Ao7RFit9qJypnIgJgZAPy4uviQ/h5ozoAcbQoDIiJyQImJLYmPzyA2tjGZDWxc0zMUDqauzuetXzbw6bwtPPH1crz+fW9aPNOupvw9B+aMa6ufUECQWlTlC7CtqBKAls6t2Ftdf3Q3C7TYSWx7HX1i5gEwpbwXgUNYyd00996BWMOEpPZpnwERETkgq9VOdHQjTDNIIODlxiyId1l48ZdSntlruFDzJDdXZWXueWLQR+Ga9wiaULl6LMmGgdn7bcp+Hopjy0c4W18f2gVWpAb5fBWs2pqPiUGspYwmjhI46fWjXofR6z/0WRlDlKWCHG8ib/y8hltObXOQz947DJi/006kZqhnQERE/pBhWEhIaE58fAaXd09gaPdo7Hv9D/LqlLUEgntuXJZkl/BJ8G94gg68QahYO4btW+fx2jwfv5S0oWpNDS7vqJ4GAUrKCrjv41lc+J+lALR0biKqzVHuFdjNYieu1aXc2fBNAF75aT1FFQe350D1AKAwILVPYUBERA5adHQj0hp35uELuvLZdak8dlY8UXaD7cVexs7YyOQVuUxekctFo2bz/Jr+PF/+f5gmFPngnY/+zagd13H71idYWN4cM+AN3cgHfXj9wVCYOMQbe++0ayga58Dzy1CFguPcB7M3MH5pZfjx4NMvimjvk7PvGM5t76S1cz3l3gCfffHcQT5TAUCOLg0TEhGRQ+ZyJdCldQ9ap+9gzubFTFxeyWMTl+/T7qvt7ZluHUcT+zYWV50AQIUZxe3Zj/HK221o495Gvj+Nyze9DAR5OOUlLureErJG89CXS/jfilzeufZE2qW4CXiKcEQ1IhgMEPSWYJoBCtaMI2hCxZoPiFn/AbGt/4zRZ8zR/WFInTBtbVH4+6RoB4O7N4tcMYAFk5jciQyMdbLG04IFW0oOeSKzhgnJ0aAwICIih81uj2JwpygmrazEMAx8gdDNS7sUJwNbO3h9RhkFgUQKAqH9C/rFLGCzL43NnlSGbX6eq5I+ZVLJaRR4nQDcu+UeGlrvJ6HoLt6fPRCAa96exSsZD9EsOJ9FwTO4f8Nf6BM1m5uT32VqxUUU+9wUBhLoEz2HM9aMJTYYwNP1aZzOOKz26P0XfoQqKwuoqiomJiYVu91dK68hB8c0TQqLs1mw1QPAB385iQ5p8SREOSJbmMVObOtr6Vgamkj8q6f7QQUBDROSo80wj+PYWVJSQnx8PMXFxcTFxUW6HBGRY45pmuzcuYrCslJMI4pLx2Tj9Qd467IkMhvYMJ3N2T7rKTZvnE9qRk+yzn6Ede824c4tD7G0qn34OrGWMtLt21npaU1n1zKaO7czoXhg+LwNH3c3+g8/lJ7Cr5WdDljP31Ne4Lz4/wFgNaBhu2ux1PDa8l5vOTt2rATA6YzD4YimsrIAlyuR2NjGGIZG4B4tpmlSULCW0TO388q0UhrF2pn14BlYLEakSwvb9O2fOPXnawhiZeaDp9E4/sDh0TRNtm9fwNR1VTRNtNE+vRGJiZkHbC9yIIdyj6swoDAgInJEAgEfeXlLQp/QemPwestJiTGJiUkhLq5JqNFewyPMmddTtXYco/xPMiU3lTbM5ZaGHxBlNRmw6k08pjN87cca/4uvis9gbkX38DGDIJnObNZ7MgDo4FpHUkw003akAjA4/lsyHZs4JWYmLd07ib3KG3rtw1xr3u/3YLNYws8tK8ulpGTrAds7HNFERTUkKqrBIb+WHJrsnTu4/I15bC0OLcH5r0s6cfmJTSNc1V6CPorGObh0/Yus8bRk1JVdOLtzkwM2N80gk+bP5pbPCgD49W/tSUxscbSqlXrkUO5x9fGFiIgcEavVTlRUQwASHWWkxJhYLDZiY9P2NNrrJtzIegf30Aruvu4+JjxwNc+eUkpL904at72Aq7P2jPOOtpRzQcIMxjYfwV8bfoTNCN3wXZTwI98MnM3jnRfwcYu/8c2gXxl9x1Wk2vIAGF98Nv/Ov5mHtj9IZSB0g1U4+WJyxzoI/HbPg72YpknQX0XQv2cSanHxFvIm/4mS9xyU/nITS7OLqagoAtNf7bl2exQWS2jkrddbTlHRRrZtm09x8WYAgsEAFWXb8XmKQ0/QZOca8da0jeEgMOiEFC7tkRHhin7DYsfV4io6ukLL8C6Y/cnvNjdNk0XbvNUei9Q2zRkQEZEjFheXjs3mCn9inpiY+fvDZfb+hD5rNPR6Ayx2bi0t5as5i8n1N+LChB9JsAfgsnLut9i5odKkwlNFWvwZGFYHVwMEHwCLHTvwWPe1PLHQz2ZvKIQsq2rH0sqWtHsvEQKhG/yyNWOJ7/3mPj0EpaXbKZ1xI2RPxGJAcuur8PV4kfKZt8C2r1npTeWWSf3ZGZhGa+d6nk37J63anUlVx0cBSEpqRVVVMYWF66tdt7w8H4cjlqqZN1G58VMAbNEZxPu24GylvRaOxPJtJXwwNxQA/9w7hX+c371ODQ/azdnnbTrNP5svi8/h560OHphxHdY+Bxq6ZrL3xt6VPu1ALLVPPQMiInLEDMNCdHRDUlI60ahRR5zOQxx6uevmPDE2ll/Onsacdlfxf+n/gRbXgy0qtKtrtIP0pDgMq2Of5wGcefH/MfXRa9n41LkM7toYgHd2DgkHAYBVlY2577UXWLolJ3zM6y0PBwGAoAk717xH0Zed2bhhEY9sv5drNr3Czl2ToNd4WnBn9mNsXjuDBomZlNOERyYsZ1muSYMGrUlJ6UTjxt2Ijg71lhQWrKZy46ds86XwXckAlu+0UegFc9074K9QL8FheuF/q/D4TbKaOXjwrDbYrXXzlsawOhjYoRluo5LVnkxemOX93d/zMu+eAFBY4T9gO5GaojkDmjMgIlL37L5ZOswNo9bllzHo+Z/wmxYa23MpC0TjtlRSFXRSEowjxmEw+Z7+pMTHUlK0kc/HXMevlR1xGF4SrCVcm/QxpcEYrt30Irn+RuHrjkh9llfzh7EzkEic3ctr1/Tnia+XszKnFIsBN5/Sku+X57J5ZwX9WjWgX3Po0zRA9JR+XLnxdbb4Qr0WF8RP4oGUV/CYTgoDqXTtdGqNT3SurwJBk53lHk595ifKvUHGXJnCKZ261/mJ2+Ne/xMPb7wOgyA/3XsazZP3XekqEPBx45ipTF5TBcDYqzI4pWPno12q1AOHco+rYUIiIlL3HOGusS0bxnBVVgvGzNjIdl8KAKXBmPD5Mq/J5/PWc8tpnfl6aT7/zLm32vNzfCmUBGLCQeD02Jn0jFrCVQ2mcE7CYm7Ne575Bclc9fbs8HOCJrw2ZV348Y+r8vlxVWhVo4A5AQCn4cVjOphQfBYLKjqzdVc4eKTyZa7rdXgTnI8nZR4/142ew9yNhQAkuAx6tW5d54MAQR+XxXzOx67eLK1qz/zJT9H88sf309Akv2zPOKGCcvUMSO2r4397REREDs8dp7cmI8lNeoKLm07esyJLm0ahpR2f/mErrR/6lgcn5u3z3IklZzC1PAuAL//ah7dP384tKRNwtLqW1GtyGHP7lVzYNXQjH+u08dnNWZzfJfQ4McrOuGEncfcZbWjfOI7AXv3vfz29I10SQivF7A4CAKPyh+Dxa3z4H3nz5zXhIABwZrto3O74CFZ0kCx2nC2vpa0rNKdkxZYt+x0qZJomeXuFgZ0KA3IUqGdARETqpcRoBz/cdQqOXWPJS6r8WAy4oV9TBjw3DQB/MHSn7rIZdM5IZO7GAq7t05xP520NfQrdtzndmiZC07fhpNfDn9zHuuDFK7rxj3M7YLUYJEU76NwkgT4tG9CjWSJtUmLp37oht5/emi0FFRSUeyn3+umV2YCT2yTz5NfLWZdfTlv3ZpYVRpPnT+azX3MY2iuyu+bWdZOWhiaoX9UjmjPbxdCjRfPIFnQoskbTbvXDUASr6H2AXiCTCt+e9FhQEdhPG5GapTAgIiL1lstuDX8/8uI9m5WNHNyKNdu2886ccgAGd2vCI+efQG5JFc2To7mwazo/r8rnplP2WuN9PzdvDWP37IngsFkYctK+a9xnJEWRkRQVftytaSKf3tIXCH0S/OLbD/HC2r68NmkWf+rRBKdtV81BH35/FYZhxWq1H3gI0WHunxB+ejBAVVUhPl8lgYCH6OhGhz4BvJZt3FHO898vY1WeFwMYPrAbqYnHQI/Ab7Tr9RdYsZRVRS6YNWyf1aRM08S7V2dAUaXCgNQ+hQERETnuDOndFq83nZaNVvPzeh/3n9UOt8MantTZNSOBrhkJtV6HYfq5zPo871nbkV3ZgAFPfM6nd5xH/KJhlK7/KNQGSLSDq3VoKdJg0A9BP4bVScmUK7Bu+YSYNoe/TGlpaTbl5fnhxx5PKTExqbjdidhsrpp4m0ckr7SKK9+cxbbi0KTaPi1ij8kgANC5SQJWAuT5G7Jt5X9J26u3CUJ7Ynj3Glfm9R+3a7zIUaQ5AyIiclxyOGIY2q87b1zTi6Roxx8/oTZY7KS2uZybG44DYHtVNPe8NorCdaE9CaqCToImFPkhuO4dPJUF5P5wMXnj3JT+dCnlGz6hZNe5w12i1OMp3VOOxYZpBikt3UZ+/nLKy/edT3E0VfkC3DRufjgIJLgMHh/c6Q+eVXfFx8TTKjY0Z2Ru9M379Oj4gybBve7/fQHNI5HapzAgIiISQZa+Y/lz94aMSH0egNml7bhx87N8VHgR5657n2s3v8RWbwo5Htg5vgtm9lcETSjb+DnrPM3I8zWgqskVhzVUKBj04/eHbrRTU7uQktKJmJhUbDYnpmlSXLyFqqriGn2/h+Kxr5by6+YiYq3lfNz8Rn7ocBstGiVGrJ6a0LVVSwCeWX8q09fuqHbO46s+LGjvXgKR2qIwICIiEmH2kz/guuYbuavROwCs9LTmpfxhVJou1nhacF/2CCqCLjzledyw+Vlu3TKSt3cO4epNr3LTlmcoWPcJlVOvxAx4Qhc8iF4Cv7+KgoLQUqg2mwuLxYZhWIiLS6dRo45ERSUDUFGx4/cuU2uWbyvhozmbAXgs9SkyndtI8q0PbdR2DLukawPcdoOthVVc9fZsvl68PXzutytKKQzI0aAwICIiUgcYg9dxR1YMj6W9CkDz6FJuOqUFDZ1VbPA2Y2Tu7YwvPotlVe34tbITb+8cCkCuvxHzyztRuPZDct91UfxZc0rGOQhMv2af1wgG/QS9JZimSUHBWrzeMhZs9TL8iwI+mL25WtuYmND+DB5PMaZ5dIerLNiQx3WjZxLEwoCY6fSK/pUGDrDGtgrtSH0Ma9c4nlGZT9AjahGmCY9MWEaZJzRr+Lc9Az6FATkKNIFYRESkrsgayzW9fJxaUEFqYix2q4UzO6Rw+X9mMbn0ZCaXnrzfp40rvIIEWymVQSfbi1NIt7vosnocDTGwZL0FgMdXya8fnkZ64FccMU0I9P+CoGnwzJRKNhVUMmfjEjKTo8lq2QDY01sQDPrx+SpxOPbdMbemFZR7Gf3xC7y2uh0BrDR3bObh1Fdp5ABr86ug77har6G2RTmiaGfM5Pn0uVy18TW2lKUxYeE2ruzVFI//N8OENIFYjgKFARERkbrEYicjec9qOT2aJTG0V1PGztwEQJq7nJPatmb8wm1c3jODT+ZtZl5FJ/686aXwc6wEeKvpXWSs+IT/zipnUPw85jmu4NGV/+Tk6Jk8mfYklkAVYxe62FRQGX7eFwu20qNZIoGgidthxW6PwuMpwe8tqbUwUOH1sz6/nI/mbua9WZuBEwA4PXYqD6W8Qqa7AiPzGugztlZe/2izuRJJim/BjqL1nBU3mTd3Xs3PsyZxZa8b9w0D6hmQo0BhQEREpI67Y2Ab1uSVMW9TIQ9d1J8zOqRwVe9m9GiWSKzLxlvTNhDrshFv5kLQx1ZfKk/m3oGVACs9bfim+FTy/UkATC3PYnrgEso2JPLm9A0A/KlHEz6bv5VPd30B3NA/k9v6x+GZdy9F2ROwtBqC6+QPavR9rcwp4eq355Bf6ql2/Ly473ku4yUcFjBaXAtZo2v0dSPNcfE6Yn+6hN5V83lz59VMz03E5/PsM2dAw4TkaFAYEBERqeOSoh18cEPvasd6Ng/d3D90bnvuOqMN0c7Qf+l5hYWc9tzPrPG0DLdd521e7bljK29nww+hOQL3ntmGW09thS8Q5L8Lt4XbvPnLBvo1b4O5bglNHC6s6z7EaXNg9Blz2O8ju6iSGWt3sDS7mFYpsTw8fuk+bUaem8Cg9jfjTHo2dOAINlSry2JO/pCOG1zEWUooCcaxbFspXk0glghQGBARETmGGYYRDgIAjRITefyibtz36UKCGATZswtzF/dyFlV2YPn2EiC0udqtp7bCMAyev6wrF3ZNIyMxirenbeCjuVv487jVwMt0cS/l1SYPUrVuLO7eb4LFTsBXQRCw2/czoXfXrshFFV5cdisuu5UqX4BLR80I7xmwt4s6uRnY2k2sy6BdagyJDdqCUb/XODGsDqJbXkHn7OVMK+/N3E0ltGxgVGujngE5GhQGRERE6pmLejTjlLKnKN/wBdutXbls2e0A3JP6Pv8quJdlxYl0aBzHs5d2xjBCN6BWi8Fp7UIrCP393Pb8smYH2UWh+QSLKjvyxs6ruL3ROCzT/szaEivPL0xjm9GOUX85l6YNG/L/7N13nBTl4cfxz2y93ihX4Oi9SBcOsUUiiA07iB3FGFCxxZhENGrEHmsk+lNABWsEERVFpEgvSu9wdI4Drtdt8/tjuYWVIgfXuP2+X699yc48M/vMcHjz3ad5vSUUFh3kv5+NozgnHU/0WXyyoyVhdguP9mvJku25xwwCE2+qS5OEw48jERH1MGp5ECgTds5YOm98mrlbYO6SGaT+8Q9B+zWAWKqCYZpmyP6k5eXlERsbS25uLjExMdVdHRERkYp16Bv66V/+jfSd67mrRyzenu+RV+IhPsIeCALHsv1gIa/+uIkf1+0jv8Q/9WWyLYO9nqSjyobbLVx7Vjg5e5by9d62J6zSP5NeoHmch6n72tLGuZl+7WKJShuD1+vC4ykhPr4ZVmvt7Bp0FJ+bZe8245r0MVjx8mjbX3h2XQ8cVgOX1yQxysKif1xS3bWUM1B5nnEVBhQGREQkFBwKBqfi/37eyjPfrAvaFm4UU2yGH7N8tCWfDuHribXkYzfcfJ3XD4D7673DDfFTAuUcFoizge1GV60dG/B7PHNv5poZHVhR3IFmjh1sdTUiIcJKVpGX+HALvz6hMCDlV55nXHUTEhERCQWn8bB957nNaJ8Sy+JpT/Dqzn4k2Q8y5Q8L2df8H0xatgWvz+SnzW52ZLt4JHEcN8R/gQFEWuGAy85udxJWw8ctdb/BMKHEBxFWiLMDTW8L2SAAYOvzIdesuo4V2zuw1dUIgCinhawir8YMSJVQy4BaBkRERE6aq6QA02LH6XAC4HYXAQZ2ezhurw+74YWp7aFgE0S2oCS+B1mbPwagbsvBOGxOPFvGYbPgDwK1bNrQcvO5yfkwinM3jCffFw1A20Qn6/aV4rDChmcGnLA7l8ixqGVAREREKoUjLCro/ZGzCdmtFsACV2wETxHYInB6XTi3+sOAfcfHMNiFrec7/gNCuEUgwGInrvVNXJbxEx9nXwlApNM/A5TbC6bpwzCsJzqDyGkJjeH6IiIiUrVs/pBgWB3UaXMHdRxgNL/DHwDKXuLX6z2uvPrxwNtop//xzATcXt9xDhKpGGoZEBERkcrV6z04e4wCwAm0Sk4I/NlqOfxdrdvrxWnXfZPKo5YBERERqXwKAicUH3l4ZqaDhe7An3+7KrFIRVMYEBEREalmRy60ti/fg+XQmOFSt8KAVC6FAREREZEaoFGcf6Bwt9Qw7IfGDLu83mqskYQChQERERGRGuCNqxMY0Seakecn4LD6mwaWpO+v5lpJbacBxCIiIiI1QL0oKzd2jcRmg/xS/zJQD/9vAwcLfbRKjuPC1vWruYZSG6llQERERKQG8fmCuwaNnraJO8ctYvXu3GqqkdRmCgMiIiIiNYDF4h8oYLeHH7XPa1p464tPqrpKEgIUBkRERERqgLp12xAZWZ+4uCa8ckU8ZyXbseKlX/RPACzMjMb0uqq5llLbaMyAiIiISA1gs4URG5sKQK8mTno1tmJO64cHGzMLziHbG8uzY9+i/0U30a1pvWqurdQWahkQERERqYkMG9HNbyDJ6aFD2HoA3t3cimv+u5iZX/2tmisntYXCgIiIiEgNExYWC0BEn/E4BxUyMG5G0P7xqx3gcx/rUJFyURgQERERqWHi45uTlNQJm80Jtgiu7tyQ1s7NRFiKAPg5vys7D2ZTWOqp5prKma7Cw8Do0aPp0aMH0dHR1K9fn4EDB7Jhw4agMiUlJQwfPpw6deoQFRXFNddcw759+4LK7Nixg0svvZSIiAjq16/PI488gscT/AM/a9YsunbtitPppEWLFowbN66iL0dERESkyhmGgcVyeGhn1Pnj+brvEpa2vZ52YRvwYuXcl5dwwYszOVhQWo01lTNdhYeB2bNnM3z4cBYuXMj06dNxu91cfPHFFBYWBso88MADfP3113z++efMnj2bPXv2cPXVVwf2e71eLr30UlwuF/Pnz2f8+PGMGzeOUaNGBcqkp6dz6aWXcuGFF7J8+XJGjhzJnXfeyffff1/RlyQiIiJS7RznfkTEEBfXXHhxYNv+Ahdfr9hdjbWSM51hmqZZmR+wf/9+6tevz+zZsznvvPPIzc2lXr16TJw4kWuvvRaA9evX07ZtWxYsWECvXr347rvvuOyyy9izZw+JiYkAjBkzhkcffZT9+/fjcDh49NFH+eabb1i9enXgswYNGkROTg7Tpk07qbrl5eURGxtLbm4uMTExFX/xIiIiIhWs1OPlzZ82MeXX7WzP9tC0joOp911IpFOTRIpfeZ5xK33MQG6uf7W8hIQEAJYtW4bb7aZv376BMm3atKFRo0YsWLAAgAULFtCxY8dAEADo168feXl5rFmzJlDmyHOUlSk7x7GUlpaSl5cX9BIRERE5kzhtVh66uA2fDjubOhEW0g+6GPLOTDbv3lbdVZMzUKWGAZ/Px8iRIznnnHPo0KEDABkZGTgcDuLi4oLKJiYmkpGREShzZBAo21+270Rl8vLyKC4uPmZ9Ro8eTWxsbOCVmpp62tcoIiIiUh2S4uN5/DrURgQAAQAASURBVJJGACzf7WLI2HUUu7QomZRPpYaB4cOHs3r1aj75pGYsn/3YY4+Rm5sbeO3cubO6qyQiIiJyyq7o1o42iZEA7Cvw8eHcNUeVKS3Nx1uaW9VVkzNEpXUuGzFiBFOnTmXOnDk0bNgwsD0pKQmXy0VOTk5Q68C+fftISkoKlFm8eHHQ+cpmGzqyzG9nINq3bx8xMTGEh4cfs05OpxOn03na1yYiIiJSE1gsBl/8uQ//mbGK/8zZw1tz9rL9YAHrM12MubknkbZScqZ0wSjaSd2E5tgHbq7uKksNU+EtA6ZpMmLECCZNmsRPP/1E06ZNg/Z369YNu93OjBmHF8/YsGEDO3bsIC0tDYC0tDRWrVpFZmZmoMz06dOJiYmhXbt2gTJHnqOsTNk5REREREJBlNPGg/060aKek9wSkwnL8li2s4Q3pi/nq6XrGbb+Pu7Y/gqbD+ThKsqktPigFiyTgAqfTejPf/4zEydO5KuvvqJ169aB7bGxsYFv7O+55x6+/fZbxo0bR0xMDPfeey8A8+fPB/xTi3bu3JmUlBReeOEFMjIyuPnmm7nzzjt59tlnAf/Uoh06dGD48OHccccd/PTTT9x3331888039OvX76TqqtmEREREpLaYu3EvN73/y3H335LwGRfV24C7OIteUZuwNRmMPe3/sNojqrCWUhXK84xb4WHAMIxjbh87diy33XYb4F907KGHHuLjjz+mtLSUfv368Z///CfQBQhg+/bt3HPPPcyaNYvIyEhuvfVWnnvuOWy2wz2bZs2axQMPPMDatWtp2LAhjz/+eOAzTobCgIiIiNQmv2w7QLjDwri56/nsl2xMIMJSRJEvggijCA9WPKaNVxs+TveIlVgNqNfmNixpY6u76lKBqjUMnEkUBkRERKS2WpG+nfULXqe/5236bBhPvvdwC0Aj+07uqPMJ7cPW0yZiH9E3ucBir8baSkVSGDhJCgMiIiJS6/nc/HdOOqOnbTpqV5w1h3GNH6Rz+4sh7X08nlJsjqhqqKRUpBq16JiIiIiIVCOLnbvOa8mYsxcypcX9XB33Y2BXjjeOf2Xcy+71H7FnnIPMj6IpnDWoGisrVU1hQERERKSWs1gM+l/9NGfdsY5n+hTySbO/MvWCGTgsHpYUdWFa/oXkeGPYUNKcnC2fUjp7EB5XPj5PSdB5Cgv3k529FZ/PWyn19Pk8mumoiqmbkLoJiYiISKjxucFi582fNvHSDxuDdt0QN5n76v0fhgFWA2KbD8bs8SYuVwGFhfsBiIioS0xUIhaLFdM08fk8WK324HEHhz7jZBUXZ5E953ai9k0hptUd+Lq/hWEYGNbKXSPKNE0M0+N/U0vGTWjMwElSGBAREZFQ5vb6uOLNeazbm3fUvgb2PTybMpqWznRocBl0fPLwzlVPwe4pWAzYWNKESEsRrcMziWp1B66ur5E9+2aiMyYT3uJ2ctuOwmp1EB2dcsK67N+3Evc3nQAIt0KJF+wWqNv6NjjF2Y5crkLy8nYSFZVEWFjcUftN0+TgjKvx7JxMvB2cLe6AXu8d+2SeIrAdPQ2r212M1+ui0OPEYliIj3ScUl0rksLASVIYEBERkVC342ARExZvp01SNJm5RUEDjRNt+/m86TDCLG7M/st4d1ERszYVcI31Va6I/Z51Ja24e+eLRFoK+aTpCNpFZpF5/nw83/cGIMYGeRctBMNGZGR93O5CoqKScTqj8Xrd2Gz+b/1N00fGDwMxd399VP0S7BDW4rajAoHbXUxh4T4sFjsxMQ3wel0UFGTgchXidEYTEVGXzMw1ANhsTurVa09+/h4sFn9dDG8xRfOGcnDzZxiYOC0m9ZzAoOCZlTyeEvIntcUo2oYzsgn2K1bh8pRiGBa8Xhd5ebv4fn0x//whF6fN4LNh3ejUKLGC/5bKR2HgJCkMiIiIiAQb+cmvTF6+J/D+r0ljSW7QntSeI7n27fn4Dj05/jF6Fvvc9VhZ0h6Aq2K/4ZHEtyn1Ofg692JM4Oq4b7E2HBDUqmCxWLFaHbjdxcTFNcHpjCbrwHrc33TCYoDz0IhWjwluH0RYIc5O0EN6dvZWiouzA+eMjk6msDDzmGMZfKaJxTCIjKxPYWEmAMacqzCLdlLkC+PPO59jtzuZfyT9m6u7NMOa9h6m14XNYsWwOli/dSXj/vc218V9TbLdfzwNroCOowDw+kxumnCA7dn+z+7UwMnfB7Rj/ILtPHFFZ+rHhJ/uX0m5KQycJIUBERERkWAFpR6+XbmXnGIXz367/phlbIYPjxk8D00D+x4+bzqMdw8MYWzWYAD+lvgarcM240jqzX8P3IZhwMjzYqgXZT36pKueIiJjCrFxLTAKN1PihSx7Q4yiXSS2vgXLOeMxvaW43UUcyNr6u9dhmiYfLCvmgyX53H52JDd1i2JHtoe4rS8Qs/9LAN7afxsTsq8FoKF9D581HcY2S3ccpTtpYN+HYcDTe+/nm7w/AnBB1Dzirbk8UH8Mln7zeGlWEZNXFx/12eF2g2K3yXVdEnjxhrTfrWtFUxg4SQoDIiIiIsdWUOqh579+pNB1+Nv2etFOPhx6NtsPFnH3h8sAiLXmU+CNwIuVy2Nn8nXuhSc8b5+mTl64PJ6cYh8OK3x16GH60nbhjJ5ZytqMEqb8uSf1o6zs278OVj2Bdc83RMc2IycnHTChwRU4ur1AbGwqBw6sxzRNsl0RLN5lpUvj+ixJz+SblRks35Uf+Nx7ekcxZn4BcdZcnkl5mTbONdy6/Q12uQ+PZWgftp41JW0ASLFncF3cFF7bP+yoa3iyw2LWOy/hk2UHATCA565qyefL9rB0RyEAMWEG0x/oQ2Js1T9jKgycJIUBERERkeObtjqDb1ftpW+7RLqkxpEYE4bD5m8R+GTxDv759VqeuKw1X63Yx4KtBwPHxdpdxETFsjP76G/NAc5vGceczTkc7yn0T+c35+7zmlEy9zrydszAYbiYnn8+r2YOY1D8ZO6sO5Hwq/fgCK/Hql1ZxEXYuXXsMvbllZb7Gm2Gj4YRhWwrjD5huUfbreL5tR2P2v7wxa24snMDUhMi+HHNTv765WoiHQZ/uziFfl3OKnd9KoLCwElSGBARERE5dT6ficVikFXoYvraDBZtzWJvbhH/uuosUuLCWZ+Rj8Pi4/35O7m2W0NemLaeX3bklOszDHzYDC9u8/Cg3ofrv8VbB++m2Gs75jF1oxzcfV5z0prXAeCyN+YCYDHgum6pTFq+G5fHB8BFbepzRecU/vblKgpdXi6PncV9iZ8yp9k0XvhhM6U+K/e2WsdDdzzM5swCLn9jLsVuf2tJ37aJvHtLNwzDCHx2dvZWPJ4SEhJa+qdbrQYKAydJYUBERESk6izfmcO1b8/HYbPwl36tWbU7j4vbJ/L3Sas5UOD/Vr9NUjTrM/J/50zH9sEdZ5Nb7ObspgkkxoQFtk9ctIMxs7fw10vaMKBjMj6fyagpq0k/UMirN3ShXrR/VqPMWX+m7u4xWJrfDr3eY/XuXNbvzeaqro2xWvwP/NsOFLIo/SDdGsfTtG5UYHtNojBwkhQGRERERKrW1v0FRDlt1D/iYX3+5gP8uC6Tyzol07VRPEUuD89/t57xC7ZzXssE5mzKAqCRYy87XMkARNtcfHX/H1m1O5f/zNzCVV0bcPd5zYK+pT8l5VwsrSZSGDhJCgMiIiIiNVOpx8uMdZn8oU195kx9gs3bN9CleTMGzzsPgFvSGvPUlR2quZY1k8LASVIYEBERETlD+NyYho0pK/awbm8+d5/XrEas9lsTlecZ99ijLkREREREahKLHQO4snMDruxc3ZWpPSy/X0RERERERGojhQERERERkRClMCAiIiIiEqIUBkREREREQpTCgIiIiIhIiFIYEBEREREJUQoDIiIiIiIhSmFARERERCREKQyIiIiIiIQohQERERERkRClMCAiIiIiEqIUBkREREREQpTCgIiIiIhIiFIYEBEREREJUQoDIiIiIiIhSmFARERERCREKQyIiIiIiIQoW3VXoDqZpglAXl5eNddERERERKRilD3blj3rnkhIh4H8/HwAUlNTq7kmIiIiIiIVKz8/n9jY2BOWMcyTiQy1lM/nY8+ePURHR2MYRpV/fl5eHqmpqezcuZOYmJgq//wzme7d6dH9O3W6d6dO9+7U6d6dOt27U6d7d+qq+96Zpkl+fj4pKSlYLCceFRDSLQMWi4WGDRtWdzWIiYnRP7JTpHt3enT/Tp3u3anTvTt1unenTvfu1OnenbrqvHe/1yJQRgOIRURERERClMKAiIiIiEiIUhioRk6nkyeeeAKn01ndVTnj6N6dHt2/U6d7d+p0706d7t2p0707dbp3p+5MunchPYBYRERERCSUqWVARERERCREKQyIiIiIiIQohQERERERkRClMCAiIiIiEqIUBkREREREQpTCQCV77rnnMAyDkSNHBraVlJQwfPhw6tSpQ1RUFNdccw379u0LOm7Hjh1ceumlREREUL9+fR555BE8Hk8V177q7d69m5tuuok6deoQHh5Ox44dWbp0aWC/aZqMGjWK5ORkwsPD6du3L5s2bQo6R1ZWFkOGDCEmJoa4uDiGDh1KQUFBVV9KlfJ6vTz++OM0bdqU8PBwmjdvztNPP82Rk4Xp3h02Z84cLr/8clJSUjAMg8mTJwftr6h7tXLlSs4991zCwsJITU3lhRdeqOxLq3Qnundut5tHH32Ujh07EhkZSUpKCrfccgt79uwJOofu3bF/7o70pz/9CcMwePXVV4O2694d/96tW7eOK664gtjYWCIjI+nRowc7duwI7A/V372/d+8KCgoYMWIEDRs2JDw8nHbt2jFmzJigMqF670aPHk2PHj2Ijo6mfv36DBw4kA0bNgSVqah7M2vWLLp27YrT6aRFixaMGzeusi/vMFMqzeLFi80mTZqYZ511lnn//fcHtv/pT38yU1NTzRkzZphLly41e/XqZfbu3Tuw3+PxmB06dDD79u1r/vrrr+a3335r1q1b13zssceq4SqqTlZWltm4cWPztttuMxctWmRu3brV/P77783NmzcHyjz33HNmbGysOXnyZHPFihXmFVdcYTZt2tQsLi4OlOnfv7/ZqVMnc+HChebPP/9stmjRwhw8eHB1XFKV+de//mXWqVPHnDp1qpmenm5+/vnnZlRUlPnaa68FyujeHfbtt9+af//7380vv/zSBMxJkyYF7a+Ie5Wbm2smJiaaQ4YMMVevXm1+/PHHZnh4uPnf//63qi6zUpzo3uXk5Jh9+/Y1P/30U3P9+vXmggULzLPPPtvs1q1b0Dl07479c1fmyy+/NDt16mSmpKSY//73v4P26d4d+95t3rzZTEhIMB955BHzl19+MTdv3mx+9dVX5r59+wJlQvV37+/du7vuusts3ry5OXPmTDM9Pd3873//a1qtVvOrr74KlAnVe9evXz9z7Nix5urVq83ly5ebAwYMMBs1amQWFBQEylTEvdm6dasZERFhPvjgg+batWvNN954w7Rarea0adOq5DoVBipJfn6+2bJlS3P69Onm+eefHwgDOTk5pt1uNz///PNA2XXr1pmAuWDBAtM0/f9wLRaLmZGRESjz9ttvmzExMWZpaWmVXkdVevTRR80+ffocd7/P5zOTkpLMF198MbAtJyfHdDqd5scff2yapmmuXbvWBMwlS5YEynz33XemYRjm7t27K6/y1ezSSy8177jjjqBtV199tTlkyBDTNHXvTuS3vxwr6l795z//MePj44P+zT766KNm69atK/mKqs6JHmjLLF682ATM7du3m6ape1fmePdu165dZoMGDczVq1ebjRs3DgoDund+x7p3N9xwg3nTTTcd9xj97vU71r1r3769+dRTTwVt69q1q/n3v//dNE3duyNlZmaagDl79mzTNCvu3vzlL38x27dvH/RZN9xwg9mvX7/KviTTNE1T3YQqyfDhw7n00kvp27dv0PZly5bhdruDtrdp04ZGjRqxYMECABYsWEDHjh1JTEwMlOnXrx95eXmsWbOmai6gGkyZMoXu3btz3XXXUb9+fbp06cK7774b2J+enk5GRkbQvYuNjaVnz55B9y4uLo7u3bsHyvTt2xeLxcKiRYuq7mKqWO/evZkxYwYbN24EYMWKFcydO5dLLrkE0L0rj4q6VwsWLOC8887D4XAEyvTr148NGzaQnZ1dRVdT/XJzczEMg7i4OED37kR8Ph8333wzjzzyCO3btz9qv+7dsfl8Pr755htatWpFv379qF+/Pj179gzqDqPfvcfXu3dvpkyZwu7duzFNk5kzZ7Jx40YuvvhiQPfuSLm5uQAkJCQAFXdvFixYcNTzYr9+/QLnqGwKA5Xgk08+4ZdffmH06NFH7cvIyMDhcAR+MZZJTEwkIyMjUObIH5qy/WX7aqutW7fy9ttv07JlS77//nvuuece7rvvPsaPHw8cvvZj3Zsj7139+vWD9ttsNhISEmr1vfvrX//KoEGDaNOmDXa7nS5dujBy5EiGDBkC6N6VR0Xdq1D9d3ykkpISHn30UQYPHkxMTAyge3cizz//PDabjfvuu++Y+3Xvji0zM5OCggKee+45+vfvzw8//MBVV13F1VdfzezZswH97j2RN954g3bt2tGwYUMcDgf9+/fnrbfe4rzzzgN078r4fD5GjhzJOeecQ4cOHYCKuzfHK5OXl0dxcXFlXE4QW6V/QojZuXMn999/P9OnTycsLKy6q3NG8fl8dO/enWeffRaALl26sHr1asaMGcOtt95azbWr2T777DMmTJjAxIkTad++PcuXL2fkyJGkpKTo3km1cLvdXH/99Zimydtvv13d1anxli1bxmuvvcYvv/yCYRjVXZ0zis/nA+DKK6/kgQceAKBz587Mnz+fMWPGcP7551dn9Wq8N954g4ULFzJlyhQaN27MnDlzGD58OCkpKUd9Wx3Khg8fzurVq5k7d251V6XCqWWggi1btozMzEy6du2KzWbDZrMxe/ZsXn/9dWw2G4mJibhcLnJycoKO27dvH0lJSQAkJSUdNRK97H1ZmdooOTmZdu3aBW1r27ZtYDaIsms/1r058t5lZmYG7fd4PGRlZdXqe/fII48EWgc6duzIzTffzAMPPBBondK9O3kVda9C9d8xHA4C27dvZ/r06YFWAdC9O56ff/6ZzMxMGjVqFPjdsX37dh566CGaNGkC6N4dT926dbHZbL/7+0O/e49WXFzM3/72N1555RUuv/xyzjrrLEaMGMENN9zASy+9BOjeAYwYMYKpU6cyc+ZMGjZsGNheUffmeGViYmIIDw+v6Ms5isJABbvoootYtWoVy5cvD7y6d+/OkCFDAn+22+3MmDEjcMyGDRvYsWMHaWlpAKSlpbFq1aqg/+mX/UL97f/sapNzzjnnqCm7Nm7cSOPGjQFo2rQpSUlJQfcuLy+PRYsWBd27nJwcli1bFijz008/4fP56NmzZxVcRfUoKirCYgn+52y1WgPfmOnenbyKuldpaWnMmTMHt9sdKDN9+nRat25NfHx8FV1N1SsLAps2beLHH3+kTp06Qft1747t5ptvZuXKlUG/O1JSUnjkkUf4/vvvAd2743E4HPTo0eOEvz+6deum373H4Ha7cbvdJ/z9Ecr3zjRNRowYwaRJk/jpp59o2rRp0P6KujdpaWlB5ygrU3aOSlclw5RD3JGzCZmmfxqqRo0amT/99JO5dOlSMy0tzUxLSwvsL5uG6uKLLzaXL19uTps2zaxXr94ZP0XX71m8eLFps9nMf/3rX+amTZvMCRMmmBEREeZHH30UKPPcc8+ZcXFx5ldffWWuXLnSvPLKK4855WOXLl3MRYsWmXPnzjVbtmxZK6fHPNKtt95qNmjQIDC16JdffmnWrVvX/Mtf/hIoo3t3WH5+vvnrr7+av/76qwmYr7zyivnrr78GZrypiHuVk5NjJiYmmjfffLO5evVq85NPPjEjIiLO+CkeT3TvXC6XecUVV5gNGzY0ly9fbu7duzfwOnJGEd27Y//c/dZvZxMyTd274927L7/80rTb7eY777xjbtq0KTA1488//xw4R6j+7v29e3f++eeb7du3N2fOnGlu3brVHDt2rBkWFmb+5z//CZwjVO/dPffcY8bGxpqzZs0K+v9ZUVFRoExF3JuyqUUfeeQRc926deZbb72lqUVrm9+GgeLiYvPPf/6zGR8fb0ZERJhXXXWVuXfv3qBjtm3bZl5yySVmeHi4WbduXfOhhx4y3W53Fde86n399ddmhw4dTKfTabZp08Z85513gvb7fD7z8ccfNxMTE02n02ledNFF5oYNG4LKHDx40Bw8eLAZFRVlxsTEmLfffruZn59flZdR5fLy8sz777/fbNSokRkWFmY2a9bM/Pvf/x70AKZ7d9jMmTNN4KjXrbfeappmxd2rFStWmH369DGdTqfZoEED87nnnquqS6w0J7p36enpx9wHmDNnzgycQ/fu2D93v3WsMKB7d/x7995775ktWrQww8LCzE6dOpmTJ08OOkeo/u79vXu3d+9e87bbbjNTUlLMsLAws3Xr1ubLL79s+ny+wDlC9d4d7/9nY8eODZSpqHszc+ZMs3PnzqbD4TCbNWsW9BmVzTDNI5YoFRERERGRkKExAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQZavuClQnn8/Hnj17iI6OxjCM6q6OiIiIiMhpM02T/Px8UlJSsFhO/N1/SIeBPXv2kJqaWt3VEBERERGpcDt37qRhw4YnLBPSYSA6Ohrw36iYmJhqro2IiIiIyOnLy8sjNTU18Kx7IiEdBsq6BsXExCgMiIiIiEitcjLd4DWAWEREREQkRCkMiIiIiIiEKIUBEREREZEQFdJjBkRERCR0eb1e3G53dVdDpNysVis2m61CpsZXGBAREZGQU1BQwK5duzBNs7qrInJKIiIiSE5OxuFwnNZ5FAZEREQkpHi9Xnbt2kVERAT16tXTwqNyRjFNE5fLxf79+0lPT6dly5a/u7DYiSgMiIiISEhxu92Ypkm9evUIDw+v7uqIlFt4eDh2u53t27fjcrkICws75XNpALGIiIiEJLUIyJnsdFoDgs5TIWcREREREZEzjsKAiIiIiEiIUhgQERERkSBNmjTh1VdfDbw3DIPJkyef1jkr4hxS8TSAWEREREROaO/evcTHx59U2SeffJLJkyezfPnyUz6HVB2FAREREZFayOVynfYc9GWSkpJqxDmk4qmbkIiIiIQ80/RVy6s8LrjgAkaMGMGIESOIjY2lbt26PP7444GF05o0acLTTz/NLbfcQkxMDMOGDQNg7ty5nHvuuYSHh5Oamsp9991HYWFh4LyZmZlcfvnlhIeH07RpUyZMmHDUZ/+2i8+uXbsYPHgwCQkJREZG0r17dxYtWsS4ceP45z//yYoVKzAMA8MwGDdu3DHPsWrVKv7whz8QHh5OnTp1GDZsGAUFBYH9t912GwMHDuSll14iOTmZOnXqMHz4cK0aXcHUMiAiIiIhzTR97N37a7V8dnJyFwzj5L+bHT9+PEOHDmXx4sUsXbqUYcOG0ahRI+666y4AXnrpJUaNGsUTTzwBwJYtW+jfvz/PPPMM77//Pvv37w8EirFjxwL+h+49e/Ywc+ZM7HY79913H5mZmcetQ0FBAeeffz4NGjRgypQpJCUl8csvv+Dz+bjhhhtYvXo106ZN48cffwQgNjb2qHMUFhbSr18/0tLSWLJkCZmZmdx5552MGDEiEB4AZs6cSXJyMjNnzmTz5s3ccMMNdO7cOXC9cvoUBs4EPjdY7NVdCxEREalmqamp/Pvf/8YwDFq3bs2qVav497//HXg4/sMf/sBDDz0UKH/nnXcyZMgQRo4cCUDLli15/fXXOf/883n77bfZsWMH3333HYsXL6ZHjx4AvPfee7Rt2/a4dZg4cSL79+9nyZIlJCQkANCiRYvA/qioKGw22wm7BU2cOJGSkhI++OADIiMjAXjzzTe5/PLLef7550lMTAQgPj6eN998E6vVSps2bbj00kuZMWOGwkAFUhiowXyufIoXDMPc/gmRLW/HSHu/uqskIiJS6xiGheTkLtX22eXRq1evoMXS0tLSePnll/F6vQB07949qPyKFStYuXJlUNcf0zTx+Xykp6ezceNGbDYb3bp1C+xv06YNcXFxx63D8uXL6dKlSyAInIp169bRqVOnQBAAOOecc/D5fGzYsCEQBtq3b4/Vag2USU5OZtWqVaf8uXI0hYEayOt1kfdla0ryt2Ee2ubZOJa4nv9VC4GIiEglKO9DeU115MM1+Lv03H333dx3331HlW3UqBEbN24s92eEh4efcv3Ky24Pfu4xDAOfr3xjLeTEasdPfi1TkLuN4kNBwHYo/Bd5wTXv9mqtl4iIiFSvRYsWBb1fuHAhLVu2DPr2/Ehdu3Zl7dq1tGjR4qiXw+GgTZs2eDweli1bFjhmw4YN5OTkHLcOZ511FsuXLycrK+uY+x0OR6Cl4njatm3LihUrggYyz5s3D4vFQuvWrU94rFQshYEayOX1QEQqcXao74SIQ/++87dMwJx3S/VWTkRERKrNjh07ePDBB9mwYQMff/wxb7zxBvfff/9xyz/66KPMnz+fESNGsHz5cjZt2sRXX33FiBEjAGjdujX9+/fn7rvvZtGiRSxbtow777zzhN/+Dx48mKSkJAYOHMi8efPYunUr//vf/1iwYAHgn9UoPT2d5cuXc+DAAUpLS486x5AhQwgLC+PWW29l9erVzJw5k3vvvZebb7450EVIqobCQA3j83lwu4vh3M8JuyEXBrmIanEzBlDqg5zNH8ICtRCIiIiEoltuuYXi4mLOPvtshg8fzv333x+YQvRYzjrrLGbPns3GjRs599xz6dKlC6NGjSIlJSVQZuzYsaSkpHD++edz9dVXM2zYMOrXr3/cczocDn744Qfq16/PgAED6NixI88991ygdeKaa66hf//+XHjhhdSrV4+PP/74qHNERETw/fffk5WVRY8ePbj22mu56KKLePPNN0/j7sipMMyyyWlDUF5eHrGxseTm5hITE1Pd1QGgsHA/uXPvwL5nKvXa3gG93gOgePYgsrd8CkCiE6yDXRo/ICIicgpKSkpIT0+nadOmhIWFVXd1TtoFF1xA586defXVV6u7KlIDnOjnuDzPuGoZqCFM08RVkk3u3Dtg91TCrMDW9/3TigLh53+Co9FVAJQ0HKQgICIiIiKnTbMJ1QBer5sDM67Fu2sKAGEWiLICTW8LeugP6/UfXF43pemfEOmMCLQaiIiIiIicCoWBGiBv1uBAEACItoHR7DZIGxtUzmkPh91TcRn4Ww3OHqMWAhERkRAxa9as6q6C1ELqJlTN3KV5FG//X+B9mAXsFqDnO0eVtTliMBpegc8Eb5NbFQRERERE5LSoZaCaFc73L6cdboW4uOYYhVug2R3HfNA3DANbl9G42/8Nd502HHtGYRERERGRk6MwUI18nmKK0z8DINIKxuXr/DtO8I2/zRaO212Mx1MMxGKa/lX4asvKiSIiIiJSdRQGqlFhcQ5mg8uw752Ko8WxWwN+y24Pp7gY8vJ2U1i4H6/XhWEY1K3bFru96pYHFxEREZEzn75OrkbFC4fD7qlENRt80jMDOZ0xGIYBgNfrAvzTkpaU5FRWNUVERESkllIYqCYeVwGenZMwgLCdHwfWE/g9dnsE9et3JCGhOXXrtiEmpgEALldBJdZWRERERGojhYFqUuouhgaX4bCA0fzkugiVsVrthIXF4XBE4nTGAv4wEMKLSYuIiEglePLJJ+ncuXOFnnPcuHHExcVV6DlPx6xZszAMg5ycHKBi6lfTrvFEFAaqSemiP8PuqTiaXH9ai4fZ7eFYLFZM00dR0YEKrKGIiIhI6LnhhhvYuHHjSZdv0qQJr7766mmdozopDFQHnxtj5xcYgHPXZyfdReh4oqKSAMjL24nHU1oBFRQRERE5c5imicfjqZBzhYeHU79+/Wo/R1VRGKgOFjvxre8gyclJzyJ0IlFRSTidMZimSUFBxmmHCxEREal5LrjgAu69915GjhxJfHw8iYmJvPvuuxQWFnL77bcTHR1NixYt+O677wLHeL1ehg4dStOmTQkPD6d169a89tprQeedNWsWZ599NpGRkcTFxXHOOeewffv2Y9Zhy5YtNGvWjBEjRmCaJqWlpTz88MM0aNCAyMhIevbsedRKyePGjaNRo0ZERERw1VVXcfDgwRNe57Zt2zAMg08++YTevXsTFhZGhw4dmD17dlCdDcPgu+++o1u3bjidTubOnYvP52P06NGB6+3UqRNffPFF0Pm//fZbWrVqRXh4OBdeeCHbtm07qr6/7eLz9ddf06NHD8LCwqhbty5XXXVV4O9k+/btPPDAAxiGEZjk5VjnePvtt2nevDkOh4PWrVvz4YcfBu03DIP/+7//46qrriIiIoKWLVsyZcqUE96riqAwUF16vYcx2HVaXYSOFB2dDEDRovsomuCAhUMr5LwiIiLyO6rwS7jx48dTt25dFi9ezL333ss999zDddddR+/evfnll1+4+OKLufnmmykqKvJXzeejYcOGfP7556xdu5ZRo0bxt7/9jc8+869z5PF4GDhwIOeffz4rV65kwYIFDBs2LPBQe6SVK1fSp08fbrzxRt58800Mw2DEiBEsWLCATz75hJUrV3LdddfRv39/Nm3aBMCiRYsYOnQoI0aMYPny5Vx44YU888wzJ3WtjzzyCA899BC//voraWlpXH755UcFib/+9a8899xzrFu3jrPOOovRo0fzwQcfMGbMGNasWcMDDzzATTfdFAgSO3fu5Oqrr+byyy9n+fLl3Hnnnfz1r389YT2++eYbrrrqKgYMGMCvv/7KjBkzOPvsswH48ssvadiwIU899RR79+5l7969xzzHpEmTuP/++3nooYdYvXo1d999N7fffjszZ84MKvfPf/6T66+/npUrVzJgwACGDBlCVlbWSd2vU2aGsNzcXBMwc3Nzq7sqFSIna4u5+z3Mve9j+j7CNL2u6q6SiIhIjVNcXGyuXbvWLC4uPv2TLbjDNCfg/28lO//8880+ffoE3ns8HjMyMtK8+eabA9v27t1rAuaCBQuOe57hw4eb11xzjWmapnnw4EETMGfNmnXMsk888YTZqVMnc968eWZ8fLz50ksvBfZt377dtFqt5u7du4OOueiii8zHHnvMNE3THDx4sDlgwICg/TfccIMZGxt73Pqlp6ebgPncc88FtrndbrNhw4bm888/b5qmac6cOdMEzMmTJwfKlJSUmBEREeb8+fODzjd06FBz8ODBpmma5mOPPWa2a9cuaP+jjz5qAmZ2drZpmqY5duzYoPqlpaWZQ4YMOW59GzdubP773/8O2vbbc/Tu3du86667gspcd911QfcGMP/xj38E3hcUFJiA+d133x3zc0/0c1yeZ1y1DNQiMXFNsTS8Ep8Jnia3nHb3IxERETkBnxu2vu//89b3q6SF4Kyzzgr82Wq1UqdOHTp27BjYlpiYCEBmZmZg21tvvUW3bt2oV68eUVFRvPPOO+zYsQOAhIQEbrvtNvr168fll1/Oa6+9dtS32zt27OCPf/wjo0aN4qGHHgpsX7VqFV6vl1atWhEVFRV4zZ49my1btgCwbt06evbsGXS+tLS0k7rWI8vZbDa6d+/OunXrgsp079498OfNmzdTVFTEH//4x6D6fPDBB6dVn+XLl3PRRRedVJ2PZ926dZxzzjlB284555yjrufIv9/IyEhiYmKC/i4rg1YgruEmLtrB4vSDjL76LMId1hOWNQwDR/eXKGn/GKXRDVAUEBERqUQWOzS7wx8Emp3+GMCTYbcHf4ZhGEHbyrr3+Hw+AD755BMefvhhXn75ZdLS0oiOjubFF19k0aJFgWPGjh3Lfffdx7Rp0/j000/5xz/+wfTp0+nVqxcA9erVIyUlhY8//pg77riDmJgYAAoKCrBarSxbtgyrNfgZJSoqquIv/hgiIyMDfy4o8K+59M0339CgQYOgck6n85Q/Izw8/JSPLa9j/f2W/V1WFrUM1GAz1u3jb5NWMXn5Hr5eueekjnE4omD1s7i+TNW4ARERkcrW6z0YVHFjACvavHnz6N27N3/+85/p0qULLVq0CHxLfqQuXbrw2GOPMX/+fDp06MDEiRMD+8LDw5k6dSphYWH069eP/Pz8wDFer5fMzExatGgR9EpK8s902LZt26DgAbBw4cKTqvuR5TweD8uWLaNt27bHLd+uXTucTic7duw4qj6pqamB+ixevLhc9TnrrLOYMWPGcfc7HA68Xu8Jz9G2bVvmzZsXtG3evHm0a9fuhMdVBYWBGso0Tf717eGmox/WZJzUcU57OOyeQqkPzC1V02QpIiIS0mpwt9yWLVuydOlSvv/+ezZu3Mjjjz/OkiVLAvvT09N57LHHWLBgAdu3b+eHH35g06ZNRz10R0ZG8s0332Cz2bjkkksoKCigVatWDBkyhFtuuYUvv/yS9PR0Fi9ezOjRo/nmm28AAi0OL730Eps2beLNN99k2rRpJ1X3t956i0mTJrF+/XqGDx9OdnY2d9xxx3HLR0dH8/DDD/PAAw8wfvx4tmzZwi+//MIbb7zB+PHjAfjTn/7Epk2beOSRR9iwYQMTJ05k3LhxJ6zHE088wccff8wTTzzBunXrWLVqFc8//3xgf5MmTZgzZw67d+/mwIFjr/n0yCOPMG7cON5++202bdrEK6+8wpdffsnDDz98UveiMikM1FBLtmWzdX9h4P2cTQfILT76wX5vbjHT1+4LrD5sd8ZiTR2ICZSmDq7R/4MSERGRynX33Xdz9dVXc8MNN9CzZ08OHjzIn//858D+iIgI1q9fzzXXXEOrVq0YNmwYw4cP5+677z7qXFFRUXz33XeYpsmll15KYWEhY8eO5ZZbbuGhhx6idevWDBw4kCVLltCoUSMAevXqxbvvvstrr71Gp06d+OGHH/jHP/5xUnV/7rnneO655+jUqRNz585lypQp1K1b94THPP300zz++OOMHj2atm3b0r9/f7755huaNm0KQKNGjfjf//7H5MmT6dSpE2PGjOHZZ5894TkvuOACPv/8c6ZMmULnzp35wx/+ENS68NRTT7Ft2zaaN29OvXr1jnmOgQMH8tprr/HSSy/Rvn17/vvf/zJ27FguuOCCk7oXlep3hxj/xuzZs83LLrvMTE5ONgFz0qRJgX0ul8v8y1/+Ynbo0MGMiIgwk5OTzZtvvvmoUeYHDx40b7zxRjM6OtqMjY0177jjDjM/Pz+ozIoVK8w+ffqYTqczaPT4kT777DOzdevWptPpNDt06GB+88035bqWmjyb0D0fLTUbPzrV/MvnK8yLX5ltNn50qvncd+uOKjfwrblm40enml8s3RnYlpOzw9w97TIze1zVzG4gIiJyJqnQ2YSkwpXNJvTrr79Wd1VqtGqbTaiwsJBOnTrx1ltvHbWvqKiIX375hccff5xffvmFL7/8kg0bNnDFFVcElRsyZAhr1qxh+vTpTJ06lTlz5jBs2LDA/ry8PC6++GIaN27MsmXLePHFF3nyySd55513AmXmz5/P4MGDGTp0KL/++isDBw5k4MCBrF69uryXVOOs3p3Lt6syMAy4vU8THunXGoD35qazK7soUC4zv4Rfd+QA8J9ZmwPbwxyRsHsqpT6qbHYDERERETnzlHs2oUsuuYRLLrnkmPtiY2OZPn160LY333yTs88+mx07dtCoUSPWrVvHtGnTWLJkSWA6qDfeeIMBAwbw0ksvkZKSwoQJE3C5XLz//vs4HA7at2/P8uXLeeWVVwKh4bXXXqN///488sgjgL9ZaPr06bz55puMGTOmvJdVo3yxbBcAl52VQpukGFonRtOrWQILt2bx0vcbeHVQFwBmrj881dSW/YXszCoiNSECR1gcRsMr8O6agqfRTdjUVUhEREREjqHSxwzk5uZiGEZgSeYFCxYQFxcXNC9s3759sVgsgdHmCxYs4LzzzsPhcATK9OvXjw0bNpCdnR0o07dv36DP6tevHwsWLDhuXUpLS8nLywt61URLt/tXmuvX3j9XsGEY/ONS/2jzycv3sGJnDgBzNgYPUvl21d5D5S04ur0IDS6jdOtHmlVIREREzhhNmjTBNE06d+5c3VUJCZUaBkpKSnj00UcZPHhwYE7ajIwM6tevH1TOZrORkJBARkZGoEzZohllyt7/Xpmy/ccyevRoYmNjA6+yaaZqksJSD+v2+qfs6tY4PrC9Q4NYru7inzP3pR82ALBmTy4Al3TwT99VFgYAnPYI2D2VAi/4NKuQiIiIiBxDpYUBt9vN9ddfj2mavP3225X1MeXy2GOPkZubG3jt3Lmzuqt0lBU7c/D6TBrEhZMcG7zIxYg/tABg4daDHCgoZdtB//iBB//YCosBK3blsjPLvy0yOgVbZCO8JhSFNdWsQiIiIiJylEoJA2VBYPv27UyfPj3QKgCQlJR01LLKHo+HrKyswAIVSUlJ7Nu3L6hM2fvfK1O2/1icTicxMTFBr5pm8vLdAHRvEn/UvqZ1I6kf7cTtNflksX8Z8eTYMFomRtOzaR3giK5CppfIUn+Zkvx0tQyIiIiIyFEqPAyUBYFNmzbx448/UqdOnaD9aWlp5OTksGzZssC2n376CZ/PR8+ePQNl5syZg9t9+AF2+vTptG7dmvj4+ECZ364GN336dNLS0ir6kqrEyl05fL1iD1/+4g8Dt6Q1OaqMYRj0aJoAwLj52wFol+wPNAPOSgaO6CpkseNscSsA7uTLMc3KXcpaRERERM485Q4DBQUFLF++nOXLlwP+leuWL1/Ojh07cLvdXHvttSxdupQJEybg9XrJyMggIyMDl8sFEFgA4q677mLx4sXMmzePESNGMGjQIFJSUgC48cYbcTgcDB06lDVr1vDpp5/y2muv8eCDDwbqcf/99zNt2jRefvll1q9fz5NPPsnSpUsZMWJEBdyWqrXtQCHXvD2fez/+FY/P5MLW9YLGCxzp7Cb+MHCgoBSALo3iAOjf3t8ismJXLgcP7bP1Hoe14ZWYu78m+8MwzAXHX7VPREREREJPucPA0qVL6dKlC126+Ke3fPDBB+nSpQujRo1i9+7dTJkyhV27dtG5c2eSk5MDr/nz5wfOMWHCBNq0acNFF13EgAED6NOnT9AaArGxsfzwww+kp6fTrVs3HnroIUaNGhW0FkHv3r2ZOHEi77zzDp06deKLL75g8uTJdOjQ4XTuR7WYsmIPbq9/BeFm9SJ5+frOxy172VnJRDisADhtFm4+1IJQL9pJy/pRgH/1YgB8bqIyvgKgxAfFm8equ5CIiIiIBJR7nYELLrgA0zSPu/9E+8okJCQwceLEE5Y566yz+Pnnn09Y5rrrruO666773c+ryVweH18dGifw0B9bcdd5zQizW49bvk6Uk0+HpfH0N2u5+7xmxIYfHhjco2kCmzILWLIti/4dksBiJ7LVHXg3vk+BB4qTryJCA4lFRETOSBdccAGdO3fm1Vdf/d2ys2bN4sILLyQ7OzswvfupaNKkCSNHjmTkyJGnfA6p2Sp9nQE5sYc+X8GW/YVEOKzc0rvJCYNAmY4NY/ns7jQuahs8tWpZF6Il27IOb+z1HpGDC/xrDuyYROncmyu0/iIiIiJy5lIYqEbLtmfz9Yo92CwG/xnSNehb/lNRNs5g/d583N7DA4atVgeRGVMByNr4EYX5u0/rc0RERESkdlAYqEZvz9oMwNVdG3BB6/q/U/r3NYwPJ8ppw+X1kX6g8PAOi52YVrfjtIDZ4Apy8zPIy9t12p8nIiJSG5imSZHLUy2vk+lefSwffvgh3bt3Jzo6mqSkJG688cajpm4HmDdvHmeddRZhYWH06tWL1atXB+2fO3cu5557LuHh4aSmpnLfffdRWFh41Hmk9ir3mAGpGJl5Jfy03v+P9u7zm1fIOQ3DoE1SNEu3Z7Nubx6tEqMP70t7nzo9/0tBURZ5ebsoKNiH3R5JePixZy0SEREJFcVuL+1GfV8tn732qX5EOMr/OOZ2u3n66adp3bo1mZmZPPjgg9x22218++23QeUeeeQRXnvtNZKSkvjb3/7G5ZdfzsaNG7Hb7WzZsoX+/fvzzDPP8P7777N//35GjBjBiBEjGDt2bEVdotRwCgPV5Kvle/CZ0LVRHM3rRVXYedsk+8PA+ox8rvztToudqKhEfD4PBQUZ5OfvJiwsDsMwKuzzRUREpPLdccfh6cKbNWvG66+/To8ePSgoKCAq6vBzxRNPPMEf//hHAMaPH0/Dhg2ZNGkS119/PaNHj2bIkCGBwcEtW7bk9ddf5/zzz+ftt98mLCysSq9JqofCQDX53y/+bjpXd21Yoedtk+RfhGz93rzjlomOTqao6AAeTyklJTlqHRARkZAWbrey9ql+1fbZp2LZsmU8+eSTrFixguzsbHw+/1jBHTt20K5du0C5IxdjTUhIoHXr1qxbtw6AFStWsHLlSiZMmBAoY5omPp+P9PR02rZte0p1kzOLwkA1ME2Thy9uzaTlu7ns0MrBFaVtsr9r0PqM/OOWMQwLkZH1yM/fS0FBBhaLFbe7GJ/PTUxMxYYTERGRms4wjFPqqlNdCgsL6devH/369WPChAnUq1ePHTt20K9fv8AiryejoKCAu+++m/vuu++ofY0aNarIKksNdub85NcihmHQt10ifdsl/n7hciobJ7A3t4ScIhdxEY5jlouIqEt+/l7c7iIOHtwU2O50xuJ0Rh/zGBEREal+69ev5+DBgzz33HOkpqYC/kVhj2XhwoWBB/vs7Gw2btwY+Ma/a9eurF27lhYtWlRNxaVG0mxCtUx0mJ3UhHDgxK0DVqsDuz3iqO2lpbmVVjcRERE5fY0aNcLhcPDGG2+wdetWpkyZwtNPP33Msk899RQzZsxg9erV3HbbbdStW5eBAwcC8OijjzJ//nxGjBjB8uXL2bRpE1999RUjRoyowquR6qYwUAudzLgBgNjYVMLCYklIaEFUlL+VoqREYUBERKQmq1evHuPGjePzzz+nXbt2PPfcc7z00kvHLPvcc89x//33061bNzIyMvj6669xOPy9Bs466yxmz57Nxo0bOffcc+nSpQujRo0iJSWlKi9HqplhnuoEt7VAXl4esbGx5ObmEhMTU93VqTCv/LCB13/azA3dU3n+2rNO6hifz8u+fSswTZP69TtgszkruZYiIiLVo6SkhPT0dJo2baoZc+SMdaKf4/I846ploBZqm+z/S1+z9+S/5bdYrDgc/qnI1FVIREREJDQoDNRCHRrEArAhIx+Xx3fSxzmd/uPUVUhEREQkNCgM1EIN48OJDbfj9pps3Hf8QcS/FRbmDwMuVz6mefIhQkRERETOTAoDtZBhGHRo4O8qtGr3yX/Lb7OFYbXaMU0Tl6uwsqonIiIiIjWEwkAtVdZVaOWunHId53D41xhwuU6+RUFERORMFMJzqEgtUFE/vwoDtVT3xgkALE7PKtdxhwcRKwyIiEjtZLVaAcq1Wq9ITVNUVASA3W4/rfNoBeJaqnvjeAC27C/kQEEpdaNObqrQsLBYcnPB5SrA63VjtZ7eD5iIiEhNY7PZiIiIYP/+/djtdiwWfTcqZw7TNCkqKiIzM5O4uLhAuD1VCgO1VHykg9aJ0WzYl8/SbVn075B8UsdZrQ4cjkhcrkJKSnKIjKxXyTUVERGpWoZhkJycTHp6Otu3b6/u6oickri4OJKSkk77PAoDtViPpvFs2JfP4vTskw4DAGFh8bhchZSW5ioMiIhIreRwOGjZsqW6CskZyW63n3aLQBmFgVqsR5MEPlq4gyXbTm3cgNtdVBnVEhERqREsFotWIJaQp05ytdjZTf2DiNfsySW/xH3Sx9nt4QB4vW683pM/TkRERETOLAoDtVhybDipCeH4TPhlR85JH2cYFmw2/zclHk9xJdVORERERKqbwkAtd3aTOgAsTj9YruPs9ghAXYVEREREajOFgVru7Kb+KUaXpGeX67iyMKCViEVERERqL4WBWq5HE/+4geW7cihxe0/6uLJBxC5XQaXUS0RERESqn8JALde0biR1o5y4PD5W78496ePs9ggMw4LP58HjKanEGoqIiIhIdVEYqOUMw6BDgxgANuzLL9dxDkckAKWlJ3+ciIiIiJw5FAZCQMv6/i4/m/aVr8uP3e4PAxpELCIiIlI7KQyEgJaJ0QBsyizfN/yaUUhERESkdlMYCAGtDoWBjeVuGfCHAY+nGNM0K7xeIiIiIlK9FAZCQItD3YT255eSU+Q66eNsNicWixXTNDWIWERERKQWUhgIAVFOGw3jwwFYuzevXMfabP7j1FVIREREpPZRGAgRHRvEApRrelEAu90fBtQyICIiIlL7KAyEiA6HwsCq3eVtGQgDFAZEREREaiOFgRBRFga+XrGHoeOWUFDqOanjFAZEREREai+FgRDRsUEsVosBwIz1mTz02fKTOq4sDHjdhZpRSERERKSWURgIEQmRDv4zpCvXdWsIwPS1+9ifX/q7x1mtDozVT2N+3xPv/NsquZYiIiIiUpUUBkJIv/ZJvHhdJzqlxuEz4bvVe3//IJ8b+56vACjZ8gH43P6XiIiIiJzxFAZC0OVnJQPw47rM3y9ssRPR7EYACr2QP6k1JRMcsHBoZVZRRERERKqAwkAI6to4HoB1R6w58NL3Gxg+8RdcHt9R5cPPeR+LAV4T8nPTyXKDb8v7aiEQEREROcMpDISg1onRGIZ/ReIDBaXszS3mzZmb+WblXmas23dUecPqJKrZoKBtBV5g8Z+qqMYiIiIiUhkUBkJQpNNG44QIADZk5PPtqozAvh/WHh0GACL7jMNuHH5f4gW2qnVARERE5EymMBCi2iTFAP6uQt+uOjyQeNKvu/nv7C1HlTesTuq1vYMkJxCRiscEb5NbwWKvqiqLiIiISAVTGAhR7VL8YeDLX3azbHs2AB0a+Lc9P209O7OKjj6o13tYBruwX/Q99FuIq9PzVVZfEREREal4CgMhakDHJADWHhpEfHaTBL4e0YceTeLxmfDRwu3HPtBix+mMhtXP4voiSbMKiYiIiJzBFAZCVIv60XQ/NKsQwGWdkjEMg2HnNQfgw4XbycwrOeaxDpsTdk+h1IfGDYiIiIicwRQGQtjjl7Xjj+0SeaBvK67vngpA37b16dIojiKXlzdnbj7mcY6weGhwBR4TfE1u07gBERERkTOUwkAI65Qax7u3dOf+vi0Js1sBMAyD4Re0AODnTQeOeZzFYsNu9Zcv9apVQERERORMpTAgR+nRJAGA9AOFZBW6ji7gc+PYPQmA4i0T1E1IRERE5AylMCBHiY2w07xeJAC/HJppKIjFTmSLWwAo8YFrvgYRi4iIiJyJFAbkmLo28g8u/mXHMcIAYEv7P8L9PYUo3fqhWgdEREREzkAKA3JM3RqfOAxgsWNvMggAT8NrNYhYRERE5Axkq+4KSM3U9VAYWLEzF4/Xh816dG609RwDLUbicURXdfVEREREpAKoZUCOqUW9KKLDbBS7vazPyD9mGZstDAwbHk8JpmlWcQ1FRERE5HQpDMgxWSwGnVPjAFh2rEHEgNXqwDAMTNPE6z3GrEMiIiIiUqMpDMhx9W5eF4Af1+075n7DMLDZwgFwuwurrF4iIiIiUjEUBuS4+rVPBGDBloPkFvtnC/ptd6CwsDgACgv3V2ndREREROT0KQzIcTWrF0XL+lF4fCazN+4nr8TNhS/N4o5xS8gv8YeDiIi6GIaBy1WAx1NSzTUWERERkfJQGJAT6tPS31Vo2bYsFm3NYtvBIn5an8lfvlgJgNVqx+mMAaC4OKva6ikiIiIi5acwICdUtt7Ash3ZrNmTG9j+w9p9HCwoBSA8PAFQGBARERE50ygMyAmVhYHVu/P4Yc3hgcRen8m3qzMA/7gBwzDweErxeEqrpZ4iIiIiUn4KA3JCybHhNIz3zxi0dm8eABe0rgfAvE0HADAMC3Z7BAAuV0E11FJERERETkW5w8CcOXO4/PLLSUlJwTAMJk+eHLTfNE1GjRpFcnIy4eHh9O3bl02bNgWVycrKYsiQIcTExBAXF8fQoUMpKAh+iFy5ciXnnnsuYWFhpKam8sILLxxVl88//5w2bdoQFhZGx44d+fbbb8t7OXISXrj2LFolRgXeX9k5BYBdOUWBbQ6Hf7+mGBURERE5c5Q7DBQWFtKpUyfeeuutY+5/4YUXeP311xkzZgyLFi0iMjKSfv36UVJyeKaZIUOGsGbNGqZPn87UqVOZM2cOw4YNC+zPy8vj4osvpnHjxixbtowXX3yRJ598knfeeSdQZv78+QwePJihQ4fy66+/MnDgQAYOHMjq1avLe0nyO3o3r8vX9/bhvota8tSV7Wmb7B8wvCu7OFDGbo8E1DIgIiIiciYxzN9OHF+egw2DSZMmMXDgQMDfKpCSksJDDz3Eww8/DEBubi6JiYmMGzeOQYMGsW7dOtq1a8eSJUvo3r07ANOmTWPAgAHs2rWLlJQU3n77bf7+97+TkZGBw+EA4K9//SuTJ09m/fr1ANxwww0UFhYyderUQH169epF586dGTNmzEnVPy8vj9jYWHJzc4mJiTnV2xBy8kvcdHzyBwBW/7MfUU4bXq+bffv8MwwlJp6F1WqvziqKiIiIhKzyPONW6JiB9PR0MjIy6Nu3b2BbbGwsPXv2ZMGCBQAsWLCAuLi4QBAA6Nu3LxaLhUWLFgXKnHfeeYEgANCvXz82bNhAdnZ2oMyRn1NWpuxzjqW0tJS8vLygl5RfdJiduAj/w/7uQ60DVqsdh8PfOlBSklNdVRMRERGRcqjQMJCR4Z9dJjExMWh7YmJiYF9GRgb169cP2m+z2UhISAgqc6xzHPkZxytTtv9YRo8eTWxsbOCVmppa3kuUQxrE+QcV78o+PG4gLMw/81BJSXa11ElEREREyiekZhN67LHHyM3NDbx27txZ3VU6Y5XNMLQ75/C4gbCwOMA/bsDn81RHtURERESkHCo0DCQlJQGwb9++oO379u0L7EtKSiIzMzNov8fjISsrK6jMsc5x5Gccr0zZ/mNxOp3ExMQEveTUpMb7pxLdkJEf2GazObHbwzFNk4yMFbhcmllIREREpCar0DDQtGlTkpKSmDFjRmBbXl4eixYtIi0tDYC0tDRycnJYtmxZoMxPP/2Ez+ejZ8+egTJz5szB7XYHykyfPp3WrVsTHx8fKHPk55SVKfscqVzntKgLwIx1mRw5Br2sqxBAfv7uKq+XiIiIiJy8coeBgoICli9fzvLlywH/oOHly5ezY8cODMNg5MiRPPPMM0yZMoVVq1Zxyy23kJKSEphxqG3btvTv35+77rqLxYsXM2/ePEaMGMGgQYNISfHPX3/jjTficDgYOnQoa9as4dNPP+W1117jwQcfDNTj/vvvZ9q0abz88susX7+eJ598kqVLlzJixIjTvyvyu9Ka1yHCYSUjr4RVu3MD2yMj6xMWFgtAaWm+ViQWERERqcHKHQaWLl1Kly5d6NKlCwAPPvggXbp0YdSoUQD85S9/4d5772XYsGH06NGDgoICpk2bRlhYWOAcEyZMoE2bNlx00UUMGDCAPn36BK0hEBsbyw8//EB6ejrdunXjoYceYtSoUUFrEfTu3ZuJEyfyzjvv0KlTJ7744gsmT55Mhw4dTvlmyMkLs1s5t6W/dWDu5gOB7RaLlYSEFjid/i5YpaW5xzxeRERERKrfaa0zcKbTOgOn5+1ZW3h+2nouPSuZt27sGrQvL28XBQX7iIpKJCamYTXVUERERCT0VNs6AxJaOjTw/3Ct3XP0eg1Wq3+NCK/XVaV1EhEREZGTpzAgp6x9in9sQPqBQvJL3EH7LBb/omRer/uo40RERESkZlAYkFOWEOkgOdY/FmTd3vygfVarPwz4fAoDIiIiIjWVwoCclvYp/q5Ca/YEDxRWy4CIiIhIzacwIKelrKvQ6t3B4wbKWgZM04fP563yeomIiIjI71MYkNNyvJYBw7BgsVjB9KirkIiIiEgNpTAgp6V9A3/LwObMAko9wS0AltVPwfe98C4cdqxDRURERKSaKQzIaUmJDSM+wo7HZ7Ixo+DwDp8b665JAHi2fghqHRARERGpcRQG5LQYhnF43MCRXYUsdsKaDgagOGUgHBpQLCIiIiI1h8KAnLbjjRsI6zMeGlyGa8dkPPNurY6qiYiIiMgJKAzIaWsXCAO/mVHIgLC9UwHI3/yBugqJiIiI1DAKA3LaOhwaRLxubx5en3l4h8VOdMtbACj2gmfhXdVRPRERERE5DoUBOW1N60QS4bBS4vaxdX9B0D572v/hPPRTVrp5vFoHRERERGoQhQE5bRaLQdvkY3cVwmLHeWggcYkPWPynKq6diIiIiByPwoBUiA7HGUQMEJb2XwBcPvBtef9w64BaCURERESqlcKAVIjA9KK7847aZ3NEY2t0FSZQmjoYLHaK5gzhwAcOPPNvq9qKioiIiEiArborILVDuyNaBkzTxDCMoP1hZ79OgddNSfrHhNud5GyeCMDBDeNJ7PWu1iEQERERqQZqGZAK0SoxGrvVIK/Ew67s4qP2O+0RsHsqpT4wt46DBpcB4DWhZK7WIBARERGpDgoDUiEcNgutEqOBY48bcITFYzS8Ap8JpY1ugg7/COzL2fIxvvkKBCIiIiJVTWFAKkz74yw+BmAYBvauL0C/hRS1/Rv4PNhTB2IzwGdCsRYlExEREalyCgNSYQ4PIj66ZQDA4YiC1c9SMqUdTO+DPWc5kc0GAVDkRdOOioiIiFQxhQGpMN0axwMwd/MBth8sPGp/mCMSdk8JvHeUbCO851sYgNsE1+b31TogIiIiUoUUBqTCdGgQy3mt6uH2mjzyxUpyi4If7B1hcSS1uY36DqjrgIjYlljCEghvej0AhWodEBEREalShmmaZnVXorrk5eURGxtLbm4uMTEx1V2dWmHjvnyu/s98Cko9RIfZ+HRYWmDa0QCf2/+yRQDgKsnhwMR4LAYkOsC4oTCwT0RERETKpzzPuGoZkArVKjGaD4eeTYTDSn6Jh/Hztx1dyGIPeth3hMVhaXglPhMKw5qQNzES3/zbq67SIiIiIiFKYUAqXJdG8bw1pCvgHz9wMo1Pzh7/hpRLycvdRoEHCjeP0/gBERERkUqmMCCVolfTOjisFnbnFLP1wNGDiX8rzBEBe74JvHf5KrN2IiIiIgIKA1JJwh1Wzm6aAMCPa/f9fvnIROJbDCHe7n/vTr7c351IRERERCqNwoBUmv4dkgCYunLvSZUPP+8jwm4sxWhwOb7dX+OZp1WJRURERCqTwoBUmks6JGG1GKzancuOg0UndYxhGDj2fg1A0RatSiwiIiJSmRQGpNLUiXLSrZF/IbIFWw+c3EEWO5HNbwKg0APehXdVVvVEREREQp7CgFSqsnEDi9KzTvqYsHPex2EBEyjePF6tAyIiIiKVRGFAKlVZGFhcjjCAxU5408EAlKRcpYHEIiIiIpVEYUAqVdfG8VgtBruyi9mTU3zSx4X1GQcNLsO1YxKun29S64CIiIhIJVAYkEoV5bTRPsW/DPaSbSffOmA1DMIzpgKQtXkCxRMcFM65kYKcdExTixCIiIiIVASFAal0Zzcp/7gBLHZiW96C3QI+E7LdkLv5Y/K+bEbhly0qqaYiIiIioUVhQCpdYBDx1oPlOs7Sezx1W92K8Zvtrvx08JzcVKUiIiIicnwKA1LpejRJwDBgy/5Cdpdj3ACA0XsckVenQ4PLAttczlRMa3hFV1NEREQk5CgMSKWLj3TQ9dB6Az+tzyz38dHRyUTvm0o9BxiAr3gnnvm3VWwlRUREREKQwoBUiYva1gfghzUZ5T7WsDqJbnUHdgs4D/3EFmzW6sQiIiIip0thQKpE//ZJGAb8vOkArf/xHV8t312+E/R6Dwa5iG55CwDFXvBodWIRERGR06IwIFWiWb0oBvVoBECpx8f9nyxn3Lz08p3EYsee9n+B1oFSrU4sIiIicloUBqTKPDagDUP7NKVjg1gAnvlmHRsy8st3Eosd56HViUsbXK3ViUVEREROg8KAVJmYMDuPX9aOKSPO4bxW9fD4TL5dtbfc53H2fg8aXEbp9i/xzbtVrQMiIiIip0hhQKqcYRj0b58EwIJyrj0AYLfasO+digns3/gBpRMdsHBoBddSREREpPZTGJBqkda8DgDLd+RQ7PKW72CLndjmQzAArwlZLvBueV8tBCIiIiLlpDAg1aJJnQgaxIXj8vr426RVmKZZruMd535EvVY3YTXABLLd4Fs0rHIqKyIiIlJLKQxItTAMg6eubI/NYjDp1918umRnuc9h6/MhdQYfxGKAywcFG8epdUBERESkHBQGpNpc1DaRh/u1BuCvX67iP7M2l/scNkc0cTb/n4t9lLuFQURERCSUKQxItbqzT1Mu6eAfTPzaj5soLPWU7wQWO84Wt2Mx/OMHSudrILGIiIjIyVIYkGpls1r4z5CupCaEU+rxMXvj/nKfw+j5X8LLFiLb+pG6ComIiIicJIUBqXaGYTCgQzIA/1u2q/wnsNhxNrsJgJLkK7UQmYiIiMhJUhiQGuGabg2xWgxmrM9k8q+7y328s894jAaX4931Fe55t1ZCDUVERERqH4UBqRFaJUbz5wuaA/Dw5yuYtrp8KxMbppewjK8BKNr8gboKiYiIiJwEhQGpMUb2bcXAzil4fCYjJv7K2j15J3+wxU5E85sB/6xCWnNARERE5PcpDEiNYbUYvHx9Z85pUQePz+T7NRnlOt7Z+z1sBvhMKNw0Tq0DIiIiIr9DYUBqFKvFoP+hwcRLt2eV72CLnegWQwAo9IJvwZ0VXT0RERGRWkVhQGqcs5skAPDL9hzcXl+5jg0/Zyz2Q60DBVs+gAW3V0YVRURERGoFhQGpcVrWjyIuwk6x28uq3bnlO9hiJ7r5YACKvGBuHafuQiIiIiLHoTAgNY7FYpDWrA4A36/O4LEvVzLp15NffyDsvIlYG16Jz4SS1MFad0BERETkOBQGpEY6r1U9AP47ZysfL97JA5+u4A8vzWLJtpMbRxCR9jY0uIyirR/DwqGVWVURERGRM5bCgNRIZWHgSFsPFHLPR7+w/WDh7x4f7oyC3VMp9YFr8/vqKiQiIiJyDAoDUiM1iAvn7vOa0b1xPHf2aUrrxGgADhSUcuFLs1i168RjCWyOaGyNrvIf44K8/7UCwOfzkJOzjeLi7Mq9ABEREZEzQIWHAa/Xy+OPP07Tpk0JDw+nefPmPP3005imGShjmiajRo0iOTmZ8PBw+vbty6ZNm4LOk5WVxZAhQ4iJiSEuLo6hQ4dSUFAQVGblypWce+65hIWFkZqaygsvvFDRlyPV6LEBbfnint7847J2fP/AeXw1/BzsVgOfCZ8v2/m7x4d3ezHw54L8bRz88SoOHNhAUdFBsrO34nYXVWb1RURERGq8Cg8Dzz//PG+//TZvvvkm69at4/nnn+eFF17gjTfeCJR54YUXeP311xkzZgyLFi0iMjKSfv36UVJSEigzZMgQ1qxZw/Tp05k6dSpz5sxh2LDDq8rm5eVx8cUX07hxY5YtW8aLL77Ik08+yTvvvFPRlyQ1RKfUON69pTsA367a+7vTjkbFNSU+tinRNjCA0h2T8bgPB8qCgn2VWV0RERGRGs8wj/zKvgJcdtllJCYm8t577wW2XXPNNYSHh/PRRx9hmiYpKSk89NBDPPzwwwDk5uaSmJjIuHHjGDRoEOvWraNdu3YsWbKE7t39D3/Tpk1jwIAB7Nq1i5SUFN5++23+/ve/k5GRgcPhAOCvf/0rkydPZv369SdV17y8PGJjY8nNzSUmJqYib4NUErfXR69nZ3Cw0MVNvRrxzMCOv3/Qglvxbv2AgpTr8Xb6FxaLnaKiA9jt4dSr1w7wt1YZpkczD4mIiMgZrzzPuBXeMtC7d29mzJjBxo0bAVixYgVz587lkksuASA9PZ2MjAz69u0bOCY2NpaePXuyYMECABYsWEBcXFwgCAD07dsXi8XCokWLAmXOO++8QBAA6NevHxs2bCA7+9j9wUtLS8nLywt6yZnFbrXw7NUdMQz4aOEOLn39Z/637HemHU0bj3Wwi9gLPyUhoQXR0f4Vjj2eEkzTxOt1kzl9IPs/cOCbf2sVXIWIiIhIzVDhYeCvf/0rgwYNok2bNtjtdrp06cLIkSMZMmQIABkZGQAkJiYGHZeYmBjYl5GRQf369YP222w2EhISgsoc6xxHfsZvjR49mtjY2MArNTX1NK9WqkO/9kn8obX/52PNnjwe+nwFy3fmnPigI77xt1odGIblUBAoJX/2jXh3TcHtg6yNH2DOu6USay8iIiJSc1R4GPjss8+YMGECEydO5JdffmH8+PG89NJLjB8/vqI/qtwee+wxcnNzA6+dO39/EKrUTFd3bRj0/s2fNpfreLs9HABXSTbF274IbHf5IG/zh7Dg9tOvpIiIiEgNV+Fh4JFHHgm0DnTs2JGbb76ZBx54gNGjRwOQlJQEwL59wYM39+3bF9iXlJREZmZm0H6Px0NWVlZQmWOd48jP+C2n00lMTEzQS85Mf2yXyLXdGtKvvb81aOHWg787oPhINps/DBQUHcRscAU2A+JjmwBQ4gPSx4FHsw2JiIhI7VbhYaCoqAiLJfi0VqsVn8//oNa0aVOSkpKYMWNGYH9eXh6LFi0iLS0NgLS0NHJycli2bFmgzE8//YTP56Nnz56BMnPmzMHtPryY1PTp02ndujXx8fEVfVlSwzhsFl66rhNvD+lGfISdglIPK36vq9ARwsJiAfB4SqHjKJwDtxB29RaMBpfjNSHf2ZScCZGYC+6opCsQERERqX4VHgYuv/xy/vWvf/HNN9+wbds2Jk2axCuvvMJVV/kXgDIMg5EjR/LMM88wZcoUVq1axS233EJKSgoDBw4EoG3btvTv35+77rqLxYsXM2/ePEaMGMGgQYNISUkB4MYbb8ThcDB06FDWrFnDp59+ymuvvcaDDz5Y0ZckNZjFYtC7RV0A5m4+cNLHOZ2xWCzWw+/DEzAMC3abf0B6fm46RV7I3zhWqxeLiIhIrVXhYeCNN97g2muv5c9//jNt27bl4Ycf5u677+bpp58OlPnLX/7Cvffey7Bhw+jRowcFBQVMmzaNsLCwQJkJEybQpk0bLrroIgYMGECfPn2C1hCIjY3lhx9+ID09nW7duvHQQw8xatSooLUIJDT0KQsDm04+DBiGQWRkIhaLlfDwBJzOWPC5Cd/9v6ByhV7wLdTPlIiIiNROFb7OwJlE6wzUDjuzijj3hZlYLQbLR/2R6LDTWCtgwe0UbBpHqc8/mNgE6tjBOcSlNQhERETkjFCt6wyIVLXUhAga14nA6zNZuDXr9E6WNpaolrdRxwFh0U0AcDUapCAgIiIitZLCgNQKF7SqB8A3K/ec/snSxsIgF44Bi6DfQtztR53+OUVERERqIIUBqRWu7NIAgB/W7qPI5Tn9E1rs2O0RsPpZXF+306xCIiIiUispDEit0CU1jkYJERS5vMzZuL9Czmm3OrDumYLPhJLNmlVIREREah+FAakVDMPgD23qAzCnHLMKnfCcVgcRzQYBUOAB33y1DoiIiEjtojAgtcZ5rfxTjM7ZuJ+KmiQr8pz3sRjgNiFj40cUfNGkQs4rIiIiUhMoDEit0atZHRxWC7uyi9mcWVAh57TYwolpen3gfV7edtxzh1TIuUVERESqm8KA1BoRDht9WvpbB75ZtbfiznvBpyTGNyPs0L+Woi0TNX6gFlu7J48np6zhYEFpdVdFRESk0ikMSK1y2VnJAHy1fA8uj6/Czmu9aktg/EBp8pVad6AWG/D6z4ybv42Xp2+s7qqIiIhUOoUBqVX+2C6R6DAb6QcKee679ZS4vRV2bkefjzAaXI5n11e4595cYeeVmml3dnF1V0FERKTSKQxIrRIdZueV6zsD8P68dNo8Po3/+3lrhZzbgo+wjK8ByN70EZ6fb6qQ80rNUew6HB6b1o2sxpqIiIhUDYUBqXX+2C4x0F0I4Jlv1pGRW3L6J7bYiW7hbxHwmHBw8wRYcPvpn1dqjCMHnseEqyuYiIjUfgoDUis9cXl7ru7aIPB+/IJtgT+XuL34fKc29ajtnA9IaO4fO+A1wbd1nAYT1yIb9uUH/uz2VtyYExERkZpKYUBqpXrRTl65vjNv3dgVgK9+3Y3PZ7J6dy6dn/qBv09efcrnDjv/YywNrwDA2+QWDSauRfbnH55ByF2BA9BFRERqKoUBqdUualuf6DAbe3JLWJh+kKenrqXE7ePjxTvIKnSd8nltXZ+HfgvxdnutAmsr1c1zRGuAWgZERCQUKAxIrRZmt3JpR//4gbdmbmbJtqzAvq9X7Dnl81qtTjBseDyai742cR/RfczlrZhVrEVERGoyhQGp9a7u2hCAeZsPcuRQgdkb95/yOa1WBwBed8WsdCw1g1oGREQk1CgMSK3XvXE8zesdnibyT+c3B2DNntxTPqfN5oRVT+H5qgUsHHradZSawa0wICIiIUZhQGo9i8Vg3O1n07dtIld2TmH4hc0xDNiXV0pm/qlNOWqz2GD3FFw+8G55XzMK1RLuI7oGKQyIiEgoUBiQkJCaEMH/3dqd1wZ1ITrMTrNDC0pNXbH3lLoLOcLicDa+BhMo8ACL/1SxFZZq4fEdDgAuj8YMiIhI7acwICGpQ4NYAJ6aupZb31/Mgi0Hy32OqN7vAFDsA1OtA7WCRy0DIiISYhQGJCTd1Ktx0PvB7y7k86U7y3UOR1g81shG+EzIdzTRegO1gLoJiYhIqFEYkJDUo0kCfxvQBotxeNuj/1vJzqyikz6HYXqIKN0BQEH+Nopm3VDR1ZQqdmQ3IYUBEREJBQoDErKGndecraMv5ekr2wPgM+G1GZswzZPsK26xE9XiViKt/rf56Z9hzr+tciorVeLIAODSCsQiIhICFAYk5N2c1oSP7+oFwBfLdjF+/raTPtboPY6YFjdjNcBrQumW8Ro7cAY7spuQFh0TEZFQoDAgAqQ1r8Mj/VoD8NGiHeU61jjnA8KbXAdAcco1YLHj83kpLtx38q0MUiNo0TEREQk1CgMih9zUqzE2i8HmzAK2HSgs17HhfcZBg8so2f4/vPNuJWfmILI/TSJf4wjOKB6fBhCLiEhoURgQOSQ23E6PJgkATFxcvtYBu9WOfe9UTCBzwweUbP8CgIL0z/HOu7WiqyqVJGgFYo0ZEBGREKAwIHKEIb0aAfDOnK38vKkci5FZ7MS1uAkD+G3HoKItH2gcwRnCozEDIiISYhQGRI5w2VkpDOnpDwQv/bCxXH3+7X0+pG7LG4mxQYId4g4tO1CcdKXWIDhDuNVNSEREQozCgMhv3N+3JQ6bhRU7c7jrg2VBg0p/j/3cCUS1vI0wK4Q3vxVLg8vx7PoK19xbKrHGUlGO7BqkMCAiIqFAYUDkN+pHh/HPK9pjsxj8uG4f4xdsL98J0sbCIBdGr3cJy/gagOItH6qr0BlAi46JiEioURgQOYbBZzfi6YEdAHhh2npW7cot3wksdrDYCWt2EwAlPjAX3uUPBAoFNdaRYwbcXlNTw4qISK2nMCByHDd0T+XC1vUo9fj4++RVp3QOZ+//CyxItnf9eDLGOyiZ4ICFQyu4tlIR3L7g1gC3BhGLiEgtpzAgchwWi8EL13bCMGDlrlz25BSX+xyG1Ul8iyEYh977TMj1gHfL+2ohqIE8v3n4V1chERGp7RQGRE6gXrSTbo3iAfhx3b5TOofj3I9IbH0L9Rz+914T9pVCydxbFQhqmN+2BCgMiIhIbacwIPI7Lm6fCMBbMzeTmV9ySuewnDMe+6BCYmyHt2Vt/picD9VlqCb57cO/S2FARERqOYUBkd9xY8/GtKgfxb68Us7+1wwen7z61L4xtkUQ1eoOkp0QbvVvKvJC0SZ1GaopfjuNrMYMiIhIbacwIPI7opw23ryxS+D9hwu3M3tDOVYnPlKv9zAGu4hvdVuglSDfAyz+0+lXVE7bkYuOQfC6AyIiIrWRwoDISWiTFMPfB7QNvF+yPevUT2axQ9pYIgfnYzk001CxWgdqhKNbBhQGRESkdlMYEDlJd53XjJeu6wTAkvTTCAOHGPYowppcB0C2G4omtzntc8qp8/lMyhoG7Fb//E8aMyAiIrWdwoBIOfRo4p9ZaNXuXHKKXKd9vshe/wn8uTBvK3iKjlvWNPVgWpmOXGMgwuHvw6UxAyIiUtspDIiUQ6OECFonRuP2mrz8w8bTPp89vC5JdVpgAG4fFM2/i4MHN3Lw4CZcroJAudLSfDIyVrB//1o8nlOb0UhO7Mg1BiIc/hHe6iYkIiK1ncKASDkYhsETl7cD4NMlOylxe0/7nJbL1+I89C8xZ/NESkuyKS3NIydnO+BvEcjJScc0fbjdxWRnb8U0TUzTR37+XkpL8067DhL84B+uMCAiIiFCYUCknNKa1yExxonL6+OXHdmnf0KLnbhWtxFhBaPhlRgWOwAeTwm5uTvYu/dXvF43hmHBMCy43cUUFOzlwIH15OfvITs7/fTrIEFdghxW//8af7sisYiISG2jMCBSToZh0KtZHQC+XrGnQs5p6T2WuJtdJP1xEklJXQgLiwWgsPDwFKYxMQ2Ji2sMQH7+XtzuYgB8Pg9ud5F/NqIjZyTS7ETl4jk0ZsBuNbAfCgNen8KAiIjUbrbfLyIiv9WrWR2+Wr6HjxfvJKvQxVkN47jz3KY4bdZTP6nFjnHoj5GR9SktzQ/scjiiiIiog2FYKC3No6joYNChebNvxrfrS3wmxLW4kWKPm7BdnxPW4jZIG3vqdQohZa0ANosF26HZhNRNSEREajuFAZFTcEmHJD5auJ01e/L4fs0+vl+zj3C7lTv6NK2Q8zudMSQndznmvpiYVNzuIjyeUiIj61Gw4B5Kd08N7D+4aSIARUDdLeNwgALBSSh78LdZDeyWQ92E1DIgIiK1nLoJiZyCuAgH39x3Lld1aRDYNnVlxXQZ+j0Wi5W6dduQmNiR6Mh6RO2bSpQVom1gM4LLFniA9HHqMnQSyh78HVYLVosRtE1ERKS2UhgQOQ0vXdeJ/wzpCsAvO3LYnJn/O0dUDMOwYLHYMKxOYlrdQYzdHwbqxjcj0gqRh3orlfrA1/Q2/6rHckIuz+GWgbJuQr9dkVhERKS2URgQOQ1Wi8GAjsn8oU19AO77eHnVDzrt9R4McsEgF5aBW4htdRuxdrBFNsIESlxal+BklLUC2CyWwABizSYkIiK1ncKASAUYfXVHYsPtrN2bx3er97Izq4iPFm4nv6SKuudY7Ie//U8bC9cXElG6A4C8rZ/gnXtz1dTjDFbWCmC3GuomJCIiIUNhQKQCJMaEcfs5TQAYMfFXLnxpFv+YvJo/T/ileqantEUQ2eJWbAb4TMja9BHmvFuqvh5nkLJ1BmxWC/aybkI+dRMSEZHaTWFApILcmtaEZvUigcPfKP+86QDfr8molvoYvceR0HIIVgPcJhRs+RAW3F4tdTkTlD342ywGtkOzCbnVTUhERGo5hQGRChIf6eD7kecx6c+9+Wr4Odxxjn+a0RnrMqutTrY+HxHT7AbAP7OQZ8s4zSx0HGXjA+xWCzaLBhCLiEhoUBgQqUB2q4UujeLplBpH33b+QcWzN2biq8a+5+Hnf4Kz0dWYQJ4HWPynaqtLTeY+YsxAYDYhjRkQEZFaTmFApJJ0b5xAlNPGgQIXS7dnA1Dk8jB30wEKSz1VWpfY88YBUOKD/I3vU5y/u0o//0xw5JgBm2YTEhGREKEwIFJJHDYLAzomAfDJEv/MPv+YtJqb3lvEhS/NIiO36qb8tDmiCW9yLQD5Hsj+vCHFP99UZZ9/JigbM2C3Goe7CWkAsYiI1HIKAyKVaNDZjQCYunIvP67dx5QV/lWKM/NL+Wp51X47H3POuziP+BdftGWCxg8cIdAyYLEEBhCrm5CIiNR2CgMilahLahwXtq6Hy+Pjzg+WBj1cztxQtQOLrc446iS0JNHpf1+afAX5hfurtA412ZHrDNi1ArGIiIQIhQGRSmQYBv++oTPdGscDUDfKwas3dAZg6bZscouq+Jv5KzZivaGQmGt3QMdR5OfvxePRCsUA7iNWIC5bdExTi4qISG1nq+4KiNR2cREOvvhTGusz8mmUEEGk08aY2VtYn5HP5OW7ubV3k6qtkC2CqJgISt3FlJbmk5m5hrCwOOLimmCxWHG7i7BanVgs1qqtVzULtAzYDg8grpYF40RERKpQpbQM7N69m5tuuok6deoQHh5Ox44dWbp0aWC/aZqMGjWK5ORkwsPD6du3L5s2bQo6R1ZWFkOGDCEmJoa4uDiGDh1KQUFBUJmVK1dy7rnnEhYWRmpqKi+88EJlXI7IaTMMg7bJMUQ6/fl78KGxBOMXbMPlqZ6uKBERdQN/LinJISNjOfv2rWL//nUcPLgR0zz+g7BpmhQXZuJ1F1ZFVatEYGpRi4FdA4hFRCREVHgYyM7O5pxzzsFut/Pdd9+xdu1aXn75ZeLj4wNlXnjhBV5//XXGjBnDokWLiIyMpF+/fpSUHO6uMGTIENasWcP06dOZOnUqc+bMYdiwYYH9eXl5XHzxxTRu3Jhly5bx4osv8uSTT/LOO+9U9CWJVLirujYgLsLO1v2F/PV/Kylxe6u8DuHhCcTHNyM2thGG4X/49XpdALjdRRQVHTjusTk/XUf2p4lkT4jCPe9Wigv3VUmdK9PhqUUNrFZ1ExIRkdBQ4d2Enn/+eVJTUxk7dmxgW9OmTQN/Nk2TV199lX/84x9ceeWVAHzwwQckJiYyefJkBg0axLp165g2bRpLliyhe/fuALzxxhsMGDCAl156iZSUFCZMmIDL5eL999/H4XDQvn17li9fziuvvBIUGkRqopgwOy9d24m7PlzKl7/uZtXuXO48tynXdG0Y6KJSFcLD/SHdYrGSk7MtqDWgqOgAkZH1Au99Pi+ukiyKF9xN8fZJALh8sH/DB7DhAyytbsbZ54Mqq3tF8xyxzoC9bDYhDSAWEZFarsKfOqZMmUL37t257rrrqF+/Pl26dOHdd98N7E9PTycjI4O+ffsGtsXGxtKzZ08WLFgAwIIFC4iLiwsEAYC+fftisVhYtGhRoMx5552Hw+EIlOnXrx8bNmwgOzv7mHUrLS0lLy8v6CVSXfq2S2TsbT2oG+VgU2YBj/5vFU9NXVstdQkPTyA5uStxcU2Ij28G+FsH9uxZRkFBBgD5s28k65P6gSBgM4LPUbLlwzN6qtLAOgMWrUAsIiKho8LDwNatW3n77bdp2bIl33//Pffccw/33Xcf48ePByAjw/9gkZiYGHRcYmJiYF9GRgb169cP2m+z2UhISAgqc6xzHPkZvzV69GhiY2MDr9TU1NO8WpHTc0Hr+nx3/3kM7eNvPftgwXY+Wri92uoTEVGH8PB4wsJiA9vy8nbjceXj2v5ZYFsdO8Q3uz5o3YLCpEtxe6t2ZeWKpBWIRUQkFFV4GPD5fHTt2pVnn32WLl26MGzYMO666y7GjBlT0R9Vbo899hi5ubmB186dO6u7SiLUi3by+GXteOiPrQD4x+TV9PjXj1z55lzu/+RXdmYVVXmdYmMbExubisXi70lY6i7Gk+Lv1lffAc4Wt2E//1PqJLQk2QmWiFTo+E+ysjadcOBxTVbWJcimFYhFRCSEVPiYgeTkZNq1axe0rW3btvzvf/8DICkpCYB9+/aRnJwcKLNv3z46d+4cKJOZGbwgk8fjISsrK3B8UlIS+/YFD1ose19W5recTidOp/MUr0ykco34Qwtyi92Mm7+N/fml7M8vZcWuXA4UlPLR0J6BQb5VwWq1ExlZH5/PS37+HgoL92N2eByj/d+wJnUG66HueVdsxPAUURcL+/evw+t1U1KSTXh4QpXVtaKUdQlyWC1HhIEzM9iIiIicrApvGTjnnHPYsGFD0LaNGzfSuHFjwD+YOCkpiRkzZgT25+XlsWjRItLS0gBIS0sjJyeHZcuWBcr89NNP+Hw+evbsGSgzZ84c3O7DfZSnT59O69atg2YuEjlTGIbBPy5rx6K/XcSDh1oJAOZtPsgPa6tnth6nMxogsDCZ1R6JYXUEF7JFYLOFERXlD+H5+XsxTROv101W1uYTzkpUk7jKWgYsFuzqJiQiIiGiwsPAAw88wMKFC3n22WfZvHkzEydO5J133mH48OGA/4Fn5MiRPPPMM0yZMoVVq1Zxyy23kJKSwsCBAwF/S0L//v256667WLx4MfPmzWPEiBEMGjSIlJQUAG688UYcDgdDhw5lzZo1fPrpp7z22ms8+OCDFX1JIlWqTpST+y5qSfroAYy4sAUAz3yzlqkr97DjYNV2GXI4ooiMPDx+x24PP27ZyMh6WCw2PJ4SCgr2kpm5mpKSXHJzz4zueEd2Ezq8ArG6CYmISO1W4WGgR48eTJo0iY8//pgOHTrw9NNP8+qrrzJkyJBAmb/85S/ce++9DBs2jB49elBQUMC0adMICwsLlJkwYQJt2rThoosuYsCAAfTp0ydoDYHY2Fh++OEH0tPT6datGw899BCjRo3StKJSaxiGwT0XNCcxxsnOrGJGTPyVwe8upLC0agfpxsamUqdOS5zO6KBg8FsWi43YWP9iav7WAf+DdNl/a7qyVgC71cB+aDYhrUAsIiK1nWGeqaP9KkBeXh6xsbHk5uYSExNT3dUROabJv+5m5KfLA+9b1I+iU8M4osNs+EyTSzok06tZAt+v2cf+/BJu7Nk48M12dcjK2kJJSU7gvWEYJCd3rbb6nKx7P/6Vr1fsYdRl7WiUEMGdHyylU2ocXw0/p7qrJiIiUi7lecat8AHEIlKxruycwq7sIlbtzuWn9Zlszixgc2ZBYP+HC7cTFOkNg5t7NcbnM7FUQyiIj2/qn47UU0JpaR6maWKaPgyj6hZTOxVl3YTsR6xArEXHRESktlMYEKnhDMNgxB9aArA5s4Dv12SwaV8+ucVuit1eFm7NCir/5JQ1LNuWxY/rMhnZtyV3ntusiutrITbWv4bH3r2/YJomPp8XaxWurHwq3MdcgThkG05FRCREKAyInEFa1I+iRf0Wgfc+n8n789L5fOkuhv+hBf/381ZW7spl8vI9ADzzzTraJcfQu0XdaqmvYVgxTQ+m6QXs1VKHk+UOtAxYjliBWC0DIiJSu9Xsr+pE5IQsFoM7z23G9w+cxxWdUvjPkK40qxtJy/pRRDqsAPzz67XV1t3FYvHXweer+SsTlz3424MWHVPLgIiI1G5qGRCpRRrGR/DTwxcAkFPk4vwXZ7FhXz4D/zOPERe2oH+H5BOfoIIZRlkY8Fbp556KQDchiwWb1hkQEZEQoZYBkVoqLsLBK9d3wm41WL07j/s+Xs7e3OIqrYPF4v++wd9NqGY7cp2Bwy0D6iYkIiK1m8KASC12UdtEvr63D/ERdlxeH2NmbanSzz9RNyGPp5TS4oNVWp8TKesSZLcah8cMqGVARERqOYUBkVquTVIMbw3xz/P/8ZKd7MsrqbLPPlE3oexZN3Lw47oUzR5cZfU5kaBuQodmE9IKxCIiUtspDIiEgLRmdejRJB6Xx8fYeduq7HPLWgYKCvYGLUSGz417x5cA5Gz5BBbcXmV1Op4juwlpBWIREQkVCgMiIcAwDG4/pykA36/JqLLPPTxmwCQraws5OdsB8GGBBpcFyrm3jAOfu8rqdSxlrQAOqyWwgrNbYUBERGo5hQGREHFeq3o4rBbSDxSyYmdOlXymwxGFYViw2cIAKCo6QG7uDrxeF3R8MhAIXI0Gg6V61yEIWnQsMJuQugmJiEjtpjAgEiKinDZ6Na8DwE3vLWJ3TuXPLORwRJGc3IX69dsTH+9vmSgs3I/LVeAv0PFJ6LcQV/snK70uv6ds5iCb5fBsQj7Tv7CbiIhIbaUwIBJCRl3WljqRDvJLPExctL1KPzs8PAGnMwaA3NwdgL/7EqufpXRKa8wFd1RpfX6rbOYgu/XwAGLQwmMiIlK7KQyIhJAW9aP555XtAZj0y25K3FU7/39kZL2g9+HOaCx7puAzoXTz2GodN+A+cp2BQwOIj9wuIiJSGykMiISYvm0TSYh0sCe3hDvHL+WzpTs5UFBaJZ8dFhZHTEzDwxssDsKbXA9AsQ9Y/KcqqcexBNYZsFhw2A7/r1FhQEREajOFAZEQE2a38taNXXHYLMzdfIC/fLGSP74ymzd/2lQlD75RUYn+7kGAwxFJRO93ACjxgm/L+9XWOuAJDCA+PGYAwKUwICIitZjCgEgISmteh79d0ibwPrvIzUs/bGRcFa1BUL9+R2JjGxEeXge7MxZ7ZCNMoNjZpFpmFTJNM/DQb7daMAwj0Drg8igMiIhI7aUwIBKibu3dhC/+lMa3953LuS3rAvDajE0s3Hqw0j/barUTGVnP30LgcxNR6h9QnJ+/De/cm4MLV0FLwZGLi5UtOOa0KgyIiEjtpzAgEqIMw6B7kwTapcQw/vaz6dk0gYJSD8M+WEpucRV21bHYiWhxK3bDP5XnwU0fYc6/Da/XRf6sGyj8yAELh1ZqFY6cMch2KATYD7UMlK0/ICIiUhspDIgIFovB+DvOplViFHklHt6fm16ln2/0Hkd8yyFYDfCYULxlPLkzryd/62fkeqB0c+WOJThyrETZeAGHWgZERCQEKAyICOAfWDyybysA3p+XXrWtA4Ctz0dENPXPLJTjhpIdXwX2uRteX6ljCY789r9s9eHAmAFv1U6/KiIiUpUUBkQkoH/7JFonRpNf4mH8/G1V/vkR54zF+O3GlEtxdfhnpX5uqcf/wG+3GlgPtQyUjR1wedRNSEREai+FAREJsFgM/nRBMwC+WLYL06zaB2GrPYL6bW4N3pizEvfXbSt13ECp298VyGmz+jf43DgO/VlTi4qISG2mMCAiQfq1TyLCYWVHVhHPfrsOz3EehvfkFFdKf3pr73EkDskmwgr1HEDRTrwmeLe8D56iCv88gNJD1xFmt+Cedys5HzpwFG8DwK0xAyIiUospDIhIkAiHjSs7pwDw7s/p3PXBUgpKPQAUlnpwe31MXbmHc57/iUe+WFEpdbA644hrfQd2C9giGwGQ52hCxoeRlP526tEKUNZNyGmzsH/DBxR5wVK6F1DLgIiI1G626q6AiNQ8T17RnsZ1Inn1x43M3LCfW99fTPN6kXy+bBdH9hz6avkeHr64NakJERVfiV7vwdljsOVsx1O4j+LpfQDI3/wRzt7v+wcUl80wdJqDi0vcZQuOGRCRCkU7sZd1E1LLgIiI1GJqGRCRozhtVv50fnM+GZZGtNPGsu3ZfLY0OAiUea8ypyG12LHZwsBy+HsLtw98Pi+5M28g90MHnomnvw5BWcuAw2pC0U4A7L58QC0DIiJSuykMiMhxdU6NY/gfWgD+/vTPDOxATJiNcLuVJy5vB8C4+dsYM3vLcccWnC6r1QmGDRpcBoAJZM8cTGH6ZxR6Id8LbD29dQjKBhA7rAY0uML/ueH+VZnVMiAiIrWZugmJyAnddW4z6kQ66JQaR6vEaPq2TcTj89EgLpyf1mfy86YDPPfdehZuPcjY23pgGEdNDnpa7PZwWPUU7J5KpBUKvVC6czJENISiXZT6wGxyK8ZpdBUqG0DstBnQcRR0+Bv2aQVwoERhQEREajW1DIjICVktBtd1T6VVYjQASbFhNIyPwDAM/ntzNx7t3waAWRv2s2p3boV/vsPmJC5zCnUdEG0Da1nWKNoFEQ3xmXBw43jMBXec8mcc7iZ0aINhC/zZrW5CIiJSiykMiMgpi3DYuOeC5gzomATA92syKv5DLHYiWt6Bw8L/s3ff4VFV6QPHv3f6pPeEQIBA6L0IBFAsKCpiLyCCCK5lQUVd13XX9tNdxV37rnWVDqKuiIgiIlIEAkjvEGogkF4myWT6/f0xyZAhCYSQAuT9PM88Jveee+65x4Sc956Gpu14otqNxqTxBgYB9uMAODxgTZ1W66FC5ROIDRX6SnW+TcckGBBCCHHpkmBACHHehnXxBgPfbzuJ21MPG5UN+BxGOmDA52gHzyaiwziCdRAalkRA2Rv8Yjew4ZFaZX96z4BGo/POH0AmEAshhLi0STAghDhvQzvFEhagJy3PyvfbTtTPTSrOCUieBiMdKLekEnpvMcCpjclq0TtQPmdAX/YvolZrQF8WGEgwIIQQ4lImwYAQ4rwFGnU8ODgRgCmL91Jorf3KPjVWFhwo+kC0CbcC4G41plZ7DpxaTcjbq6HTGdFrZJiQEEKIS5+sJiSEqBMTBrfhm83pHM4p4fJ//kqryED6tArn5Zu71Pu9tb2m4O78F9wR7Wt1/akdiL0BgF/PgAQDQgghLmHSMyCEqBNmg5Z/j+pFWIAei83FjvRCpq89wt4MS73fW6s1gKLD7XbU6npbhX0GNHj85gzIakJCCCEuZRIMCCHqTNfmofzw+OW8fns3+iVGAPDtlvR6v69WawCodTDgm0CcuxLNkn4om59CL6sJCSGEaAIkGBBC1KnmYWZG9WvJ+EGtAfhh+0lUtR5WGKrAFww4S2p1ffkEYkPxDjQKaI5+gV7jPVZfE4idTitOu6XShGdV9eAsza2XewohhBCnk2BACFEvrmgfjUGr4Xh+KYdzatdIrymt1gA7XsH9fSdYN+Gcr/cFA2Ed0ABK6/vQ67yTBhyuug9kPB4XOcvvJXtOKIWzDLjX3A+A2+0k+6tEsr+Iwv5tUp3fVwghhDidBANCiHoRYND5hgqt2Jddr/fSa3WQvhCXCmotlhe1O8smELe8Hu0tB9D0/6he9xmwWXNQj38HQIkbLAdmQsoDFOUfwFWSBoCz6CC4rHV+byGEEKIiCQaEEPVmSPtooJ52Jq5AW7a8qAo4a7G8qK2sZ8CoVdDozCiKBp1vNSF3HZcWbBseA0Ap+77UDdYD07FuesaXxhXQGnQBdX5vIYQQoiIJBoQQ9WZ492YArD+cR3pBab3eS9/nTRi2Dkf318752vKeAYMWNBo9iqKtsJpQ3Q4T8rhs2I/8D4AoA2gDEwAocALpP/jSuYcsAsDlsuF2O8nM3E5ubmq9z78QQgjRtEgwIISoN/FhZga08Q4VmrJ4Lx5P/TVkDYZA2PkajvkJ5zxvwDdnQKeg0ejQaLQVVhOq256B0jXjUQG9Avq24wh2HEOjgE6BIC1E6IHmN2F32sjO3k1W1i4yM7fjdjux2y1YrfU75EoIQa12MhfiYiXBgBCiXj05tD06jcL3207w9Nfb6u3NtlFvhvSF2D3nPm/AFwxoFbRab8+AvuxfxzpdWtTjxHroCwACtED/TwloN544I8QYIUQP+jZjodvLADidlXtTrFZZaUiI+uJwFJP9y+1Y5xhqtRiBEBcjCQaEEPWqf5tI3rq7BzqNwrdb0lm5v37ebOuNoWgDW6ICjoA25zRvwLfPgNZTNkxIwWTwXm9z1l3PgMNlx2lOQAHMoUneMg74HEY6fB/toBmnnkkfQEREEjqdyXfM6bDg8dT9PAYhBFgKDuNM+5YCJzgPTMXlKMblKJaeAnFJk2BACFHvbunZnHEDWwPwycpD1abbeCSPpbszfd/nlzg4mF1cs5t4nBht3pV4SgoPndNKPDZH2WpCG8ej+f0RAAKN3mDA6nDVOJ8zUd0OrMUnwXoMsxY0JQdONTA0+lMfIDw8keDgZkRFdcRkCiU6ujPNmvVGt+sfsGQAjtVj66RMQohTXC4bji1/9X1v90DOitFkzw7GLj0F4hImwYAQokGMH5yITqOQciiXbccKKp3/euMx7vokhT/M3Miq/dmkHMzlin8t57p3VrHpaD4ej0pqZlH1w4w0eoKSvI1kmwdyZgfiXD2mRm/0iu3eBn+Qxorm8HTwOAk26cvOnd9beI/HTe4vd3ByhhHrz1cDZUOE2oyvtvfCbI4gODgeRfHOW1AUBUV1YTjxLQCWg3NR1447r3IJIfw57YWQvsj3fXHMcDzHF6IC+S5w12LZYiEuBhIMCCEaRHyYmZt7xgPw7i/7OZpbgtujcjC7mC9/T+Mv83dQ3s5/eeEu/vT1NopsLtwelX//msqfv9nOte+sYmbKUYrtLv7xw26+25ruFxzokj8jROddstPhgez9s8mbaUBNGV9tuVRV9QUDIVqrr5EebDYCUOr04D6Pic/FK0dhT5vv/cZ6HIMGDBqg38fnlpFGT3DSGLQKuFSwHpghDRMh6pDL44bmN6NRgIAWeE6cWt3Lo0Jx3XQSCnHB0TV2AYQQTcejQ9ry3dYTLN+XzfJ/rUCnUXBVaGhf0T6a3ScKOXTajsUVNy17f1kqB7OLmZlyFIDCUidjk1t7T2r0BLUfj/HAVO+YX9XbS2BNnUZg/0+qfBNvdbgpL0LwjcuheQ/v1yajL02Jw0WI6dz2LgDA48R59Gvft3oNhOuBxHHnvBcCgHbQTAKdDiyHvqTUA4EbHvHOOTgL1W0HFBStAQCbrQBFdeN2OzAHxvl6IIRoylwuG3T9KwGXvUnJgvaU/8sUrIMiF1jdEJTyINrkz2r1+yvEhUp6BoQQDaZdbLBv7gDgFwjc2jOez8b2Zf6jg3zHjDoNl7UO98sjt8ThCwQAvtmc7n+TAZ+jv9dBdIexhJS97nCc4cV+ea+AVoEAU6DvuNlgQFf2L2SJvZavBDV63C1uAyAyvA3RBtC2GQfJ02qXH2AeNBXw9ny4Dpx92ELRylFkzDCRN8sIKQ9gLc4gb+UYcr+IouCreEpWjqx1WYS4VKiqB/vvT8KSARh2vUJk+zGE6yHWCMGhSeg1oAK5+2finCvzB8SlRXoGhBAN6q83duLqjjF0bhZCYamT8EADZr0WQ1nLu2VkAO+P6sXTX23lpRFdyC228/uRfADu7tuCrzYeB+DqjjH8ujeL7ccLyCtxEBFoOHUTjR4GzkDvdkHqXJzxt1X7Jq/I5m3oBxgUdLpTeWi1BgIMChabSrHNBaE1fECP0+9e7i4vQKdn0cb2BI3mvN8oavUBmFrdie3o/yhtfjfBZ8jP47JRdHAe4J0Mmb9/OqV7pvulKTr0FQF6E5oKqxgJ0dRYlt+D5/hCFMCQNhvNKAcM/Nz7+6wLIHzNWHL3z8KlQo4Dog9MRdfvY+khEJcECQaEEA1Kq1EYlBQFQHjFBnwFN/eIZ3i3Zmg1CicLS/ls9WEuax3OP+/sweXtoskptjM2uTXD3/+NvRlF/JaazS09m1fKRz9oBrR5HBfeibwajbZSmiKb9816oMG74ZivnFo9gQYNFpvb13twJh6Pm/zl96A5/g2hSWPRDJqBx+NGVT2g6NBq9aDUTWeseeAn2Fw2So58ReBaE5qBVTfk3aoKzW+G9IUAlFaYCx2g9Q6h8qhgPTiTIBn6IJoot7MEa9mu4OF60LQZd+p3oey/ukEziVZVcg/MxumBXCdEe1xo5HdGXAJkmJAQ4oKk1XjHsTcLNbPhb9fw8X19ABjRI54HBiWi1SgM6RANUO3eBRqNDu3uKbBkAM4191eZpryhH2jQ+P1h1+lMBOi9ZbCUOs5a3tKSTOxHv6HUDQWpMyHlAdxuh68cSh0FAgAmQxC6E4u8kxoPeO9VFbfbAd1eRHfD75Q9CgYNxBggTA8hoYkAlLhBXfeHOiufEBcTh6PYuyu4BkxlmwFWRTN4FkFtRgHgjr+ZwqKTDVdIIeqRBANCiAueUadFp638z9WQ9t5gYNX+bDxVrfjjcWI8sQCAwgNz8Ky9H5s1B4c1C3tpHoB3CBAQZPD2BpTTaHQEGrz3tFhP7VngdjtRnf4TnAFsGx73fW33gPvQdIotx0B1oa3jCbqK1kBwW2+jxO4GypZDPV15MKIzhhHe4X5CdBDZ/n5093o3ODPfshetAm4VbAdnVBtUCHEpc6tA85vRKZxxyV8A0+Wz0d6wCbq9SGlpPi6XvcHKKUR9kWBACHHR6tsqgkCDlpxiB3sziion0OgJSRrrW44zY+9M8uZFkzMvltwvIrGuHEVRWc9AgCUFzcbH/S4PKltByFJaCoDNVkjm123Jmh2Ea0GSrwGuuu3Yj34DeCciq0CuNoHSjU/DkgFoF/eo8wmHhkEzoPlNOFXwtB5bqQHjctkpLPRuwqbVGtENnE7QfQ6UgdN9G5wpWgMBre8GvL0D1QUVQlzKPB4ndHsR7S2Hzro6l6JoiG3WG53Ou9pYVtZO7ypEQlzEJBgQQly0DDoNPVuGAbD9eEGVaTSDZhCUeE+V5yyH5lG0xzvePlBjRXt0ll9juDwYKCzrGXCW5oD1GG4VsvIOUjzbu6qIy+PxrU8eWjbtwGU95tvAKFALHKrbDYu0Wj26sp6MjL0zObFkBLm5qbjd3nsUFh6tkLZsbkZZwLBo+wmGvr2SH3ecJOCK2SgBLXB4wGFuK/MGRJNT/juj0QXU+JqQkATfHKTCwmP1Ui4hGooEA0KIi1q35mEAbE8vrDZNwOUzMWu9k2ZjDN4PeCfPFmTtAry7D2vb+g8RCA0wA1BYYsXtduJWtBCQ4DtvcYHjwFTczmLvm8Ubt2FKGufdYRjQKBBnBONZdhyuFY8TU9mOxACkL8K+8Smys3eTl3cAu/1UT0nFidG7ThQyae4WDmQV88c5mzmcXYzJ7l2hyV50UHoGRJPjKfuZrzhM8GxMplCiojoBYLdbfAGFEBcjCQaEEBe17i28a35W1zMA3jH24R3GE6YHXdtx6EaWoG1xCwCFgb0ACG53d6UhAsEmEwBWhwerNcc7Bv/yr/3SlLjB9fsTAOgMQZA8jbD244gxQLShbGWSkY4abQ52TjR6QtqPJ9rg7Xkwa0F/YhEetw2b7VRgpNMZMZm8daSqKv+3cLdfNrPWp2No7Z1/4Gxxp/QMiCbH7bSCeu4rA+l0RgwG794kNltBPZRMiIYhwYAQ4qLWrbm3obsvowib0119wgGfexvlydNAF4C29xswbB2W4AEAhJjNlS4JMnnfqJc4VKzWbO9kQUVHWNK9BJW9/be5wXnkC3Db0GrLdi1OnobuXgfaUWX3q68GdtkGa6HtxxGuh6iODxAR2YHg4GYYjSFERLQlJqarr2dg67ECNhzJw6jT8M87ugPw7ZZ0XH0+hGHrcHV9qX7KKcQFyrnmflw/9vLO7dk46ZyvN5m8myKWli1IIMTFSIIBIcRFrUW4mfAAPU63yr6qJhFX5Ld0qBEUHUXHlgMQdOTDSsmDjN4Wv9XpHVdcvjqPcdA0QsY4MLS8HZWy9fuXDka39c/+92qIt+wavTfgGOlASZ6KyRRGcHA8kZHtMJnC/JJ+t/UEANd3jePOPi1oHmbGYnOxbJ8FFB0uZwkezxkCKiEuJR4nltSZACiA9sjMcx4mZzZ7gwGHo1iGComLlgQDQoiLmqIodG8RBpx53sDptFoDuG0U2L0N9hj1MLisfmligr3DhHJL/Tcr05Q19AOTP/I7rk+b23hj7s8SeGw9VsC8372rC93aszkajcI9l3nnP3y1KR3trr/DkgGUrLoX1X32fRWEuNipihZH/M2Ad7Mxpe25z+vRag0YDEEA2Gz5dV5GIRqCBANCiIte+byBHWeYN3A6RdHC7n+S5w4DIC4kEE5bTaRVpPf74wVO9HrvMCKdzohStm+A2RyOuSxOCNKCvu24C3LMfbHdxaS5m7E5PVzZIdq3P8OtZbs2bzySjyb9RwCKDn1FwWxjnS+FKsSFxuEoQVW9ywGbksbVel5Pee+AzBsQFysJBoQQF73yeQPbj9e8Z8CoN0P6QvJc3j/k0dfOrpSmdaR3cuDJQhtBoe0JDU0gLCzxVAKNnvAO44kxQEj7cd7hOucpy2Jj0fYTVW+iVkszU45wPL+U5mFm/j2qF5qy3Z0TIsxEBxtxeVQORT7mS+/0UOdLoQpxobFZsyB9IUYN57XHRnnPgNNZWneFE6IB1XswMGXKFBRFYfLkyb5jNpuNiRMnEhkZSVBQEHfccQeZmZl+16WlpTF8+HACAgKIiYnhmWeeweVy+aVZsWIFvXv3xmg0kpSUxPTp0+v7cYQQF6BOzUIAOJRdgtPtqdE1emMI4e3HUejxXhsdElgpTViAnuCyScTH8ksJDIzxrR7iM+Bz746+dRAIHMuzMuI/q5k0dwvzt6Sfd37lFpbNFXjs6iSCTad6LhRFoU9LbzC0JeRRYjuMAcp2ZK3rpVCFuIB4PC6sG54EvCtxVfx5L7a7OJLj3WX8iw1pfLzy4BmD8/J9PDweF6pas39/hLiQ1Gsw8Pvvv/PJJ5/QvXt3v+NPPvkk33//PV9//TUrV67kxIkT3H777b7zbreb4cOH43A4WLt2LTNmzGD69Om8+OKLvjSHDx9m+PDhXHXVVWzdupXJkyfz4IMPsmTJkvp8JCHEBah5mJlAgxaH28PR3JIaX1fQzTtpWKdRCDVXbvgqiuLrHTiaa6103qcOGs2qqvLn/20n02IHYEEdBQP7M4vYm1GEXqtwQ9dmlc73bhUGwNa0AjQDZ8CwdajD1uHp90md3F+IC5FlxSjU9O/RK3h7Bvp9DHh/D8dN3cBVb61gzvqjPDd/B1MW7+WNn/ZWm5dGo0NRvM0pt8y3ERehegsGiouLGT16NP/9738JDw/3HS8sLOTzzz/n7bff5uqrr6ZPnz5MmzaNtWvXsm7dOgB+/vlndu/ezezZs+nZsyc33HADr776Kh988AEOh/cX7eOPPyYxMZG33nqLTp06MWnSJO68807eeeed+nokIcQFSqNRaB8XDMC+jOIaX5dT5P33JCrI6Bs6c7ryeQP7M8+yUtF5SjmUS8qhXN/3qw/k8J9fU897uND327y9AkPaxxAaUDlo6RLvHWK1J8OCoihodWZQdNKoEZcs1W2n9Mj/AAjRA4njfAH9iv3ZbDyaj6rC377d6btm7vq0My5drNN5lxWuq98bl8smK3uJBlNvwcDEiRMZPnw4Q4cO9Tu+adMmnE6n3/GOHTvSsmVLUlJSAEhJSaFbt27Exsb60gwbNgyLxcKuXbt8aU7Pe9iwYb48qmK327FYLH4fIcSloUNseTBQ89/r7GIbANHBxmrTXNY6AoDfUrPPo3Rnt+6Qd53y23o1Z0SPeADe/Hk/17y9km3HCmqVp8vtYWFZMDCiR+VeAYCOZUHU0VwrxfZTGy/JMoniUuR2Wjn5y92oeCcOG4OT/Ib4lQfPpyuyu/h01SFyiu1VntdqDaC6cDlq/jKiOk5nKVlZu8jK2nHeeQlRE/USDMybN4/Nmzfz+uuvVzqXkZGBwWAgLCzM73hsbCwZGRm+NBUDgfLz5efOlMZisVBaWvUkntdff53Q0FDfJyEhoVbPJ4S48HSJ9479/2VPFqpas7fpp3oGDNWmubKDd+WdjUfyKbLVXwN581HvsoR9WoXz/sievHFHNwAO55Twn+UHzjm/3GI7j32xhaO5VkJMOoZ2iq0yXWSQkZiyYGhfhsU3/rmwME3eTopLin31GDJnBUL6QgDMGqDkgG/isNPt8Q3PG9DG+xJAq1G4omz1rbeX7mfUp+twV9Fbp932N1gygKL/Ncez9oHzK6fd+0JDfvdEQ6nzYODYsWM88cQTzJkzB5PJVNfZn5fnnnuOwsJC3+fYsWONXSQhRB25qXs8Jr2G3SctfsNtziTDcvaegVaRgbSJDsTlUflpZ0a16VRVZc76o8xdn4bV4ao2XTmPR/UFLU63hy1pp4IBRVG457KWfPNoMgBLd2fyxLwtPDRzI7d9uIbdJ87e+/Hmz/tZXFbel0Z0IdCoqzZt+QTsPSeLfMGA2+0gK2sXOTl78HjO/jxCXNA8TooOnFoxzKSBYB2+icOqqjLi36vxqGDQafjs/sv4x21dWfzE5bxxRzfKVhMmNauYn3dlVMo7MP0rtAp4VChOnS4rcYmLSp0HA5s2bSIrK4vevXuj0+nQ6XSsXLmS999/H51OR2xsLA6Hg4KCAr/rMjMziYuLAyAuLq7S6kLl358tTUhICGazucqyGY1GQkJC/D5CiEtDeKCBu/p4e/s+++1wja7Zc9LbqG4XE3zGdHf2aQHAnPVp1ab5aWcGf/t2J3/9dgcvfrer2nSqqpJRaOO6d1dx4/urcbg8fLrqECUON5GBBtrHnipLn1YRvob6d1tP8PPuTLakFfD20v1nfbbVB7zDmiZe1ZY7yspfnQ5lQ4VSM4swm8N9kyEBXC47OTl7KS7OlKFD4qLmbDYCAI1StsnYPSW+vQW2Hy9kb9kO5uMHJRJk1DG6fyvaxwbTLNTMh/f2Rls2r+jl73dxIKvCHCKNHl3SeMLK4u0SN7hTHmy4BxPiPNV5MHDNNdewY8cOtm7d6vv07duX0aNH+77W6/UsW7bMd82+fftIS0sjOdn7Fiw5OZkdO3aQlZXlS7N06VJCQkLo3LmzL03FPMrTlOchhGh6xg9ORFHg171Z7Khmz4EPlh+gz6tL2XA4j50nvGm6ND/zi4G7+yag0yhsPVbgW3LwdJ+tPhWA/Lwro9olTt/8eR8DXl/Ggaxi9py00P75xfxryT4Anr+pk6/BUe7fo3oypH00vVuGMSgpEoDl+7LIKuvVqMr+zCKO5ZWi0yg8emXSGZ8NoF2Md5301KxiDIYgmjXrRXR0Z0JCvJuSuVx2LJbj5OTslaEL4qLi8bixrBhJ8WwDav5WFCDWULbbcIVNBst/f0f0iOcvN3SslM8N3Zqx4+XraBsdSKbFztC3VzFr3dFTQxIHfI5xVAkGDahAyYGZkFLb4UKnhiHJUqWiIdR5MBAcHEzXrl39PoGBgURGRtK1a1dCQ0OZMGECTz31FMuXL2fTpk088MADJCcnM2DAAACuu+46OnfuzJgxY9i2bRtLlizh+eefZ+LEiRiN3u78Rx55hEOHDvHnP/+ZvXv38uGHH/LVV1/x5JNP1vUjCSEuEolRgdzU3Tv59ol5W1i84yQvfbeTv327gwKrA4fLw7+W7CO3xMHdn6RwLM87v6hLs9Az5hsVZKR/2RjiX/ZkVjq/JS2fTUfzfQ15i83F74fzfOctNif7M4vIstj4YPnBKu/RMyHMtyNwRUkxwcwY34/5fxzEnAcH0LdVOG6PyvS1RyqlXb43i7s/TuG6d1YB0CMhjKAzDA8q166sNyI169TkR73eTFBQnN++Cm63g/z8gzJsSFw0ii3HKD70JRYXYD2GQYN3yE/ZUqJrD+TQ7aUlfL/tBBoFJgxOrDavAIOOuX8YQI+yHc9fWLCTNn/9kRnlv4u6AALbjALA5uG8NjIrJ8GAaAiNsgPxO++8w0033cQdd9zBFVdcQVxcHPPnz/ed12q1LFq0CK1WS3JyMvfddx9jx47llVde8aVJTEzkhx9+YOnSpfTo0YO33nqLzz77jGHDhjXGIwkhLhCv3NyFuBATh3JKeHTOZmakHGXO+jQenLGRlfsrrwjUItxc5ZKbp7u6o3cC7tLdlYOB//52CIBbesZzT1/vUKU5G7xDio7lWbnu7VVc984q+r3m7c3UaRTevKsHYwa0Ij7URLNQE/93cxcUperlTSv6wxVtAJiVchRLhQnNHo/K8wt2suGINwhJiDDz0ojOZ80PIKmsZyC7yE6B1X9pxLCw1gQFxRIa6n0uu72IjIxt5ObuR1U9uN1OnM4z7MEgRCNyOPyXBDZq8Ntg7NUf9lBk9wa3j17Zlp4JYWfMLzbExPw/DqJNlDdIVlV4f1kqrrKeQOPgWSgBLXCp4ApoW6s9SCoGANITJxqCotZ02Y1LkMViITQ0lMLCQpk/IMQlJOVgLmM+X49Bp2FI+2h+3p2J26Ni0GpwuD0M7RRDWp6VfKuTp69tz8h+Lc+a57E8K0P+tRyPCoufuJy//7CbtQdzaRFu5lheKYoCPz5+OYoC17/7G+CdiOhw+b/ZCwvQM++hAXSMq92/OR6PynXvruJAVjG9W4bx37F9Kba7GPKvFb40D1/RhslD22M2aGuc78DXl3Gi0Mb/Hkmmb9lyqqcrLc2joOCIb2iEXm/G5bKhqioxMV19a60LcSHweNxk/nI76vGFvmMxHcagGzQTgBMFpQyc8isAQ9pH89+xfTHoavaO9EBWMUt2ZfiG+M0c38+76pDHSc5MAw4PhOkhYLTjnAMCi+U4xcXelw7R0Z3R66ueBynEmZxLG/fs/cdCCHGRSW4byfI/XUmQUUd4oIE3ftrLRysO4ih7e/fkte19m23VVEJEADd0bcYPO04yduoGsou8642XDzW6q08L32Tfe/u3ZO76NL9A4Jae8QQYtDx8RVtaRwVWvkENaTQKjwxpy5++3sbmtAJeWbSbvJJTb/Pv6tOC527sdM75JsUGc6LQRmpWcbXBgNkcgUajK1t21I7TeWoZZ6ezRIIBcUFx2PJRjy9Ep0CAFhRAd3QWJH8OGr2vl69Pq3BmjO93TnknxQSRFJPEycJSZq9LY+G2E95gQKPH0PoeHIe+xNH8DgJq0TNQsTdAhgmJhtAow4SEEKK+JUQEEB7oXSZzdP+Wvjd+PRPCzjkQKPdQ2RCd8kBgePdmfH5/X164qTMvjejiS/ePW7sy/48DeXJoe3q3DOOj0b15b2QvXr+9+3kFAuVu69WcW3p650Z8t/UEv6XmAHB/ciuev6lmQ4NO1758EnHmmTdNMhpDiInpSlRUB4KC4nzHXa7qJzQL0RgcLhs0vwmDBoLC2hF42lKiX5QN5RvereoN+WpiRNkcpSU7M7C7vI14w4BPoPlNOI5+U6tJxBUDAFWVYUKi/knPgBDiktciPIAlk6/g9yN5DEqKqnU+PRLCGNAmgnWH8jDoNPzpug4kVtG4VxSF3i3D6d0ynCeGtjufoldJq1F4956erDmQ69sRdcrt3Wo03Kk67WLLVxQqOktKL4MhCIMhCI1Gh8VyXIIBccGxb3gC0hdhTBoFV8z1TuYte1O/64SFvRlFGHQabu9deeJ+TV3WOoLoYCPZRXa2pBUwoE0kBp0RJX0RLqAodTrB4LfL8dlUDACkZ0A0BOkZEEI0CYlRgdzdN4HmYec3/vade3ry1LXt+XnyFVUGAg1FURSeGNqOqCAj/7it63kFAuBdtQjO3jNwOp3Ou7nk6cGA02mlsPAYJSVZ5zYJsorVV1TVQ0lJtm+isqqqOJ1WHI7isnvbz6nM4tLntBfiTJuPAhiPfeEXCAB8v/0EAEM7xRAWUP0O5Gej0Sj0T/QOq9tQtoKYRmcitO1IwLvngOfQ9HNaVUiGCYmGJj0DQghxDpqFmnn8mrp/218bYwa0YsyAVnWSV/vYIPRahQyLjd0nLHSOr9kE5/LJjU5nKQ5HCQZDIKrqIS/vIG63dy5DaWkeUVEdy5YmPYzJFIbZHIHbWYxGo/fONdDosa4aTcnBuQS1HYW5/E0uYClMo8SaA4qOgIBIrNZTO0wrigZV9aDR6AgJaU5AQO17fsSlw7r2IQBMWtC0He8XCKiqyqJtJ4FTw3zOR//ECBZtP8nagzm+fxsChnxBScZanCVplJgSCT6HuQOympBoaBIMCCGEINik57oucfyw/SRzNxzl77d2q9F1Wq0BszmC0tI8cnL2EhLSAo/H5QsEAByOEux2CxZLuu+NvmXNg5C+CACzFsytR1JwcB4A+Qe+wJ61llLLURQFPOVr3jW/GWu3F/3uX95w8nhcFBQcxe12EBx8/g08cRHzOHEc/QoAkwbfngLlZq9PI72glECDlqs6xpz37Ya0j0FRdrHuUB77Moq8O3p7nAQ50sgHSiyHMTuK0RmCapSfDBMSDU2GCQkhhABg1GXeoUbfbztZaUnUMwkNTUBRvH9OvMsiZgAQHt4Gs9k7hCI3N/XUfgQ7Xob0RWgU7wovpW7IKwsEylktR1E5FQhoFdCcWAiqC53OSHR0Z3Q6EzqdEaMxGK3WO9SjqOgkubmpFBWdqF0l1IDH4yYnZx9ZWbuw2y31dh9RO6qixRV/MwCGtvf79QrM33ycFxbsBODazrGY9DVffrc6LSMDuL6LdzL9sHdXsXxfFmj0mJIeQK8BT/zNWMp+J2pUfplALBqY9AwIIYQAvEuylk+GvO/z9TQPMzO0UyzDu595tZXyITqFhcd8x0ymUMzmcHQ6IzZbAarqQavVYzIEQcYiHAqE68EN5Du9jf5ArXdYR25Zp4KCd612FTAooLS5H2dkRwyGQDQaHTExp1ZwUlUPJ09uAcBut2C3WzAZAtEba7dy1JnY7RbffIWiopO43U4cjmIMhkDM5sgabR4n6ofH46aw8Chq1xfRdnsRbbM+vnPpBaX87VtvIDAoKZKnr+tQZ/d99Mq2LN7pbfD/cfZmtr50LcbkqYT2epucvIO+n5eaqLj9k/QMiIYgwYAQQgjAu0rRLT3i+Wz1Yd9kyB92nKRfonfFlDMJDIwhICCKoqITqKqHkJAWAOj1AcTGdsPpLMVgCPI2lDuMh0NTIXEcOiD60HRUFXQaoPVYwg7OxF0WHGgSx8KAz7w30eip7j2uomgwmUKx2Qq9B3a8QnHGQsI7jIcBn59Xvahuh7fcZW+YXa5T+ys4HMW+hp7VmoPNVkBERNJ53U/UjsNRQm7uPl9jOijEf1L9xysOUup00691BLPG90ejqbugrXuLMEb1S+CLDccodbpZfyiPK9pHozeGoigaPB43Lpe9hntxVAwGmuy+sKIBSTAghBDC50/DOmDQaTiaZ+WH7d7hQqM/W8edfVowbmDiGXdoVRSNLwioSKPRYTQGnzow4HPvOO6yxrW2/6cVEusJ0Oh8wcK5LMkYEpKAXh+AQWciL30hpYA5dSqmCvc6F6qqYlkxEuvhrwjRQWB7b2DhtFtAdYFy6k+oTmfC5bJhsxXidFrRayvcrxb3FueutDTX13iOiEjCZPLvFdqclg/AA4Na12kgUO7127ujqjDv92P8ujeLK9pHoygKer0Zh6Okxhvz+QcAEgyI+idzBoQQQviY9Fr+fH1HPri3N9MeuAyA/ZnFvPbjXh7/YkvdvanUnNZYLv+AN1gY6TinQABApzMSHByP0RhMQFkXQmn5KAuPE9V9liVIPU7czhJcZW/6bdZsSg5/hQpYXOA6MBX7b6OwLewESwYQduBttFo9Wq2eqKgOvsZn7q8jyZtpIHemAescA6ybcE7PIWqnvFeoYiBgsTl595f9pGYWsT/Tu4dG1+Z1P3Ss3MCyfUy2lAUe4N2TAziH+SXSMyAalgQDQgghqnRVhxju6nPqTf9PuzL4ZU9Ww9z8fN6ma/QEJI0FvJOTLfPbc2K6gYwZJpxr7sfptFZqZFlWjOTEdAOZs4LInh2MbdVobI5iiB8OeJtnWQ7ITfVOdFYA07G5REe2Jzq6S1nvRyjseBlP+vfYPGD3eIMI9eBU7zKp5R9Rp1RVJT//MG63A0XR+PVC/XtZKu/+ksq176zC6VYJMeloEX5+e42cSa+EMAB2n7Rgc3on/5pM3mPeuTNnb9xLACAamgQDQgghqvXPO7uT8tzVPHplWwBeX7wHp/vCn9SoT/4MbdlIkGLLEcDboM/eN5PsrB3k5x/yNbpKS7IoPvSl71oVyDswl9KfhsCJHwgNbe2Xt1EDkQbQtBmHRmdCo/F2Q5iNQRhOLkKveOc7gHdidKG+FSWrxpAxw0D+LAPO1WMkKKgjquohL2c3paV5KIpCWFgr38pWTreHeb8f80vfvUVYvU7wbhFuJiLQgNOtsvuktydArw9Eq9Xj8bixWrPPMUcJDET9k2BACCFEtRRFoVmomUevbEtEoIFD2SXMWHuksYt1dho9oW3vrfrcztew2Qqw273DSmyOEmh+E+Dd86A8iKD0OEYNBNqPEKaHEB3EGLyBgKHtuErDmDQ6M1EdxxNthFC9dyUkAGvxUQoPfYlH9fZUZO+fTcEs7/Ah1e3wzkEQ58zjcZO37C7s33dF2fkqERFJvqVsAbYfL6TI5gLgnr4J3NG7Ba/e2rVey6QoCj3Lege2HSvwHSvf+6Ko6OQZ3/yffk56CURDkGBACCHEWYWY9Dx9XXsA3vhpLzvTCxu5RGdnumIOUe1GE22AeBME67yNfX3ZfgXly4La7YXQ7WWi2o0mXA9RoYmYtd4egDA9kDiWgHbjCdKBru24M89nKJ/vMNJBQNI4IvSgr/AiujzQsLohZ+9UTs4wkj0nlNJV99V3dVxyLCtGYk+bjwJEZn2HUe8//GfH8QIArukYwxt3duetu3uQGBVY7+UqDwa2lgUDAGZzZFnvgIvS0rwzXH1641+CAVH/JBgQQghRI/f2a8mwLrE43SpPf7UNu+vC3xDJcPls9Pd6G+fB7ccTroeQdmNA0eF0WsnM3I7H40anM2G4fDaMdKC9/RDh4UlEGkAblATJM/wnNZ9tPkP5ZOjkaZiSxhFl8O6pEGuE2MgkjGV/eR0VRluVHppT/dAhGVJUmaMQ+9H/Ad6AzdB2XKX/LzvSvT0u9TlhuCrlwcDmtHzfm31FUQgM9O52XFxcfe+A9AyIxiDBgBBCiBpRFIXXbutGZKCBfZlFvPdLamMXqWbKG+dlDXrDoBmVlngsH8bha1DenAp3l8Atqf75nKvkaSijHJhHO9COcsBNuwnXQ4AWDBX+AjuraPOpbgclK0dhn2OAlAfO/d7nqLg4E4vlOC7XWVZdakRut4P8rxPJmRuGWy2byB3ctsqemi3HvCv6dG/RwMFAyzCMOg3H8kqZvT7NdzwgIBqNRofLZT/DJmTS+BcNT4IBIYQQNRYZZPSNu/5wxUGW722g1YXqikaPoihER3chLKw1Go2W4OB4zObwyml1AXV2z4ofTdvxhOkhygBxkd6J2W4VXCmnliAtWXUvJ2cYKTw4j1wnlKRO9w8IynoLnM5S3M6S8y6i02nFYjlOcXEmWVk7yc7ejdWae9751jVL/gFKi474elWMGlCsByv1nqRmFnEouwS9VqFvq4gqcqo/ISY9f76+IwD/+GE3R3O9/380Gi1GYwhAtcFA5Z4ACQ5E/ZNgQAghxDm5sVsz7hvg3d31pYW7OJhdjOsiWGGoIkVRCAiIJC6uJ8HBzRr25hXmFWhG7PENG7KkzoKUB3DYCig88IXfJcVuUA9NR3XbKfj1TgpmGXD8dh85v95Dzuwg1JTx51Ukh8M/oHA6SykoOHKW8e0Ny+12Ytv8HABBOu/QqzA90GZ8pV6bRdtPAnBFu2hCAxp+07cHBramf2IENqeHuRV6B8r3HKi+Z8CfDBMSDUGCASGEEOfsrzd2IirISFqelWveWsktH6y56AKCRlWhpyC03RgUwOYBx8HpWC3exqNO8fYeaHQBuFXIdkD+N+2xHvnGOwE5dQ5q+ve4VbAfmFbruQVut5PCQu89g4JifWPbAfLzD2O3F53349aFkqJ01OMLMWi8KzuZR5WgGeXwBlcVeDwq/9t0HIDh3Rs40Cuj0SiMG9gagO+3ncDj8Tbqy4MBZ7W9OdIzIBqeBANCCCHOWYBBx2u3daV9bBB6rcKuExa+3ZIOwM70Qt5eup89J2XJzJrQDZqJufUdAOQ4wLqoB1A2MbbNWEIVKwrgUsFWnFZlHqUeYMMjtbq/xXLc97XBEERoaALNmvX2DWmxWnNqlW9dUlUV64bJAARp8fYG6AIq9Qgs25NJhxcWk15QikGn4drOsQ1f2DJXdYwhwKDlRKHNt+dA+VwVj8eN2105eJMJxKIxSDAghBCiVq7rEsfPTw7hT9d1AOC/vx1iz0kLt3+4lveXpTLi36tZf+jCG3d+IQoe9LnfhGKdUjbBeMBnmNuNJ8rgn16v985nKF+11OYGT/lOx+fIXmGfA4PBu3tvxbXxa7pzbn0qKUrHc/w7tIp3ngD9Pq6Uxun28Ldvd+J0e8t6b7+WBJsafohQOZNey6CkKABW7PPOrVEUjS8gcLurmqgtPQOi4UkwIIQQ4ryM7NcSk17D/sxinpi3BUfZcCGXR+WeT9cx+I1f+XjlQQ5kFTF26gZmrzvK9DWH+cs323l54S62Hy8g02Ljma+3seFw1WPUKzZGj+aWkGWxAd7lGz9ccYDCUicFVkejN1prS2sMJSqiHTEGiNB7NzbzjYUf8Ll3edSAFgDoAhIIV6wEaiHGCLrABO+uyU5wrh1/KiA4S2DgctkpLDyGx+NCUTQ0a9bbt5syeAMORVFQVQ8ej6uenvzMVFWlpOgElh+TATBpQGlbeY4AwLI9WWRYbASbdGx/+TpevrlLQxe3kis7RAOwKvVU74pW6w0GXC5bpfQX68+vuLjpGrsAQgghLm6hZj3Du8Xzzebj7M/0Tox87bZuvPbjHortLo7nlzJl8V6mLN4LwKr92X7Xz0w5QtmQahZtP8kvTw9h89F8Xl20mzbRgdhdHnYcLyTAoMVStqOsXqtwc4/mfLPZO8Tlnz/tA2BEj3jGJreibXQQEYGnvU5vZO/+sp9f92YxYXAiI7rHo9Eo/glu3o/OZUVX3tA9rcEb5TqORQOhrmPo2o4j9PB0SBxHyIHp5OPdtyB7/2zMB2ejBLbCVHoUU7vxlcbUl8vPP4jTWQqAyRSKoviXR1EUNBo9brcDt9uBVtuwb9lVVSX317twHP0G8PaWBOmAvv+uMv3PuzMA727DIY3YI1BR/8RIALYfL8Dp9qDXatDpTNjtFmy2QgICok67QoYJiYYnwYAQQojz9tcbO5JdbGfV/mxahJu5vXdzurcI5XBOCdlFdt74aS9216kJxpGBBu7t35JD2SX8sOOk73ip081L3+1k49F8CqxOsopODaUoDwQAnG7VFwhU9P22E3y/7QSBBi1v39OTYV3i6vQ5PR61UiPe7nKz9kAufVqH+xqhWRYb+VYn7WKC0GgUNqfl827ZvgxPzNvKhsN5/OO2bpVvUN1ypho9hqTxRB2a6u0xGPA59P8UNHpMioaYg1OxuKDU7f1gOUopEHlgKoZ+H4NGj6qqlJbm4XLZ8HicOJ2lKIqGsLBWmExhVd5Wq/UGA55G2PisuOCQLxDQlE+mDk6qso6cbg8r9nmDzKGNOE/gdG2iAgk26SiyudiXUUTX5qGYTKGUlGRhsxWQl3eA8PC2vkCsvPG/N8tJdKCGuDAJBkT9U9QmHHZaLBZCQ0MpLCwkJCSksYsjhBAXvcJSJ2a9FoPOfxTqkZwSDuUU0z8xkt9Ss0luE+Vb8nHdoVw2p+UTaNDx0sJdftdpFNBpNXw2ti9RQUaW7MqgW/NQPl55kI1H8zHpNfw8eQjH860czClhzrqjnCy0UVjqJDLQwKo/X0WgsW7eey3ecZK/zN/BhMGJTLwqCUupk8JSJy98t5PfUnOIDTHy+u3duKx1BFf+awW5JQ46xgXz+u3dePrrbRzKLqFr8xB2pltQFPh58hWY9FoWbjvBuIGta1ZOj7Pqzc88Tlj3II5DM70BgQc8KugVCLzrBEZzJHa7hYKCo36XBQREEhbWutrb5ecforQ0n9DQBL9VhuqbZfndFB/+GihbOUgL2tb3waBZldL+tPMkb/28n9SsYiIDDaz76zXotRfOKOgxn6/nt9Qc/nJDRx4Z4t1XwmrNobAwDVVVCQ1tSWCgdziRw1HCur07GDs3l0CDwvJJrYiJafzhTuLicy5tXAkGJBgQQogLxoTpv7OsbCOzd+/pSYe4YDSKQoe4YL90NqebmSlH6NQshMvbRfudc7g8XPfOSo7kWnn0yrY8W7YB1Lmyu9y8vHAXv+7NYtJVSbz7Syq5JY7aPRgQbNTx65+u5PkFO1iyK5Ph3Zqx4Uge2UV2Hr6iDc/d2KnWefukPACHp2P3QK4DaH4zdHsRvd6MTmeitDQfjUaLwRCEVmsgOLi53zyB0xUWHqOkJIsgUwghEe3Ov3w1ULJyFIUH5wHenZrD9EDrsTBwRqW0aw/mcO9/1wPewPHD0X24vmvd9gadry82pPHc/B0APD+8Ew8MSkSrUSgpyaKw8Bg6nZGYGO9Gfg5HMe8t2cwHa7zLuW54qpXvnBDn4lzauBdO6CyEEKLJe/6mzgQYtDQPM3NDtzg6NQupFAiAd6WWh65oWykQADDoNL6G9ScrD/LUl1vp8+pSXv9xzzmNwf5q43G+2HCMTIudF77bRW6Jg+DT3t4rCrSKDGDOg/25uqP/m/N7+7f0fR1i0vH+vb2IDjby0BVtAPhhx0myy4ZBTVt7hFKHu8Zlq1byNBjpwDDKBsPWQbcXAe8mYqWl+QCEh7clIiKJ0NCWZwwEALRaA6y6jeIF7bF90+b8y3cWRYVpvkAgRFcWCCSOqzIQAJi6+ggAA9tG8vOTQy64QADgzj4t6NTM2xj7+w97+Hz1IQACAqJQFA0ul923CZmqqngq/IzanLJ3h6h/MmdACCHEBSMxKpDlf7oSg1aDUXfmhuqZDOsSx4ge8Xy/7QTzy/Y/+GTVIXq1DOdgdjHrDuXy3shelSYZ/2/TcTItNu4f2JqZa49Uyvej+/pwPN9KYamTscmtMeg0aBTvZNvWUYGcmP47WUV2hnaK4W83dqJ9TBDL9mbxzzu70yzUDEDvluH0aRXOpqP5vnwdLg9//2F31fMIzpVGjwKYzFHY7YUYjaHYbAWAt5wGQ2CNs9LhAesxAAosh4lZOwbNwMpDdSqy24tQFA16vRmPx33WiccORzEulw2jMYSikmxofjP6EwsJTLofBvy36mFRwLE8K8v2ZgLwyi1dSYoJqvFzNSS9VsM3jybz0ne7+HrTcX7amcFDV7RFUTSYzRFYrTlYrTllG5KpWJ2ngoGcYjctq89aiDohw4RkmJAQQlyS8koc3Pyf1ZwstOH2VP5TN+mqJP40rAOrU3NYvPMkLcIDeOMn74pHJr0Gm9ODSa9h5TNXsXR3JsEmHbf0bF4nZcsttvPqot00CzMzsG0kYz7fAMCyp4fQNrpuGrXeJUHdKIpCZuYOVNVDYGA0oaE1b16qqkrp/LYUFB4GIFQHgfd5h0q53U7cquoXXBQVnaSo6IRfHuUbmen1AbidVjweJ3pjKHiceDxusnL24vH494rERndCq69mMnWZ5xfsYPa6NC5vF8WsCf1r/EyN5Xi+lcFvLEerUdjy4rWEmPQ4HMXk5OxDUTTExnbH4SjmqS838eMe7ypP/70nhmt7XdbIJRcXo3Np40rPgBBCiEtSRKCBlc9chdujsu14AXd9nOJ3fs76o1yWGMED0zZweqxQPjzjmk6xxIaYuG9AqzotW2SQkXdH9vJ9f1WHaJbvy+a6d1ax6LHBvmEl50NRNGjLJtKGh7fB5SolMPDcVtpRFIWAOw6hrryHwoNfUeQG1/x22IqO4laB5jcTdvnnBARE4XY7KS4+WSkPh6OY/PxDhO3/J3mps/CoEBTSmtKiI748yoczAQQFxZ0xEFi5P5vnF+zgWJ63wVw+KfdC1yI8gJYRAaTlWdmSVsCQ9tEYDEHodCZcLhs2Wz4ajY6cklOBUXZx4+zvIJoWmTMghBDikqXVKBh0Gnq3DOfydt413Uf0iKdDbDD5Vif3Tz0VCGgUb/oRPeJ919/Zp0WDlPPZGzqi1Si4PSo3vPcbC7edYMfxwjNek1NsZ8S/V/PUV1vPmr/JFEpQUFylvQRqKmDwTLSKd4WiEktZIACQvpCC/IMUFqaRk+Odk6HVGjCZwggMjCYysj0ajQ6Xs4Sc/bN8dV1sOeKXR6A5zLercnXLnAKkZhbx0MyNvkBgwuBE3y6/F4MeCWEA7Ew/9f+2fK8BqzUHVVXJLj41TyDPWgfzSIQ4C+kZEEIIccnTahRmTeiP3eXGoNWQlmfl3v+uJ72glOZhZr56JJkggw6Xx0NkkJFHh7Sl1OmmT6vwBilfx7gQlky+gqFvrwTg8S+2APDOPT3o1jwUnUZD6yjvcByn24MCPPP1NnakF7IjvZAnh7YnIeLMw2rOh6I1EpF0L5aDc1HxbgDmVsHe7GZQdJSUeNf412h0hIcnlo1/9zKbIygp9g4dUji1rZZeA0YNGBPvxRjufbvv8bjQaKpvmrz58z7ffhV/uDyRv9xQByswNaBuzUP4/rRAz2yOoKgoHYejBKOxlILSU8FATolMIBb1T4IBIYQQTUb5pORWkYEsfeoK1h3KpV9iJEGnrRLUOb7h55ElxQTx4k2dWb4vi99ScwB48sttgHfVoq8fTqZDXDA3vv+b7814uaW7Mxk/OLHW956+5jB7M4p45ZaulfaIKKe/fA6R+Rug+AAEJsGI3dgcVvLyDqDV6gkOjsdkCq+0QpHBEEiJooPmNxGSuQhjSFtcRQcxakBpM867AlKZ6gKBg9nF/LQzgyW7vBOGlz55Be1iK68ydaHr2jwU8O5IrKoqiqKg1eoxGkOw2Qqx2Qqwu06NWbM6JBgQ9U+CASGEEE1SgEHH1R0vnN1qAcYPTmT84ERsTjc3vvcbh3JKAFBVmPf7MbrEh1QKBAC+3nScO/u2INCgQ6s5t6FA3245zsvf7wbg8nbRDO/erPrEN6eCy+rbBdhkCiU2tjsaja7aIUh6fSDseAXSF2Fsfx+6wbPQle9oXM1KQRWt2p/N+Om/4yobY3Rjt7iLMhAA6JkQhkGr4UShjcM5JbQpmyyu1wdgsxXidJbicJ8KBhyuJrvGi2hAMmdACCGEuMCY9Fp+fOJyfn7yCmaM7wfATzszmJXi3UE4wKBFr1V4956emPVa9py00P3ln7n9o7XYnDUfZ+7xqLz3S6rv+8U7K08ArkTnPxxJq9WfcS6CTqMhKHMhQTrQpc0+tYtyDQKBpbszGTt1gy8QCA/Q13oTuQtBgEFH39beoWer9mf7jut0JgDcHhVXhc6AioGBEPVFegaEEEKIC5BJr6V9bDBJ0UE0DzOTXlBKsd27uszKZ64iPECPTqthf2YRH644CMC2YwW89uMeXrnl7LvWFttdvP3zfo7kWn3Hft2bhc3pxqSv/R4PlWj0hLQfD4emQpvxNQoCwDs06LEvNgMQF2Lixycux6TXEGC4uJsuV3WIYe3BXF7+fjfNwwO4tnOsLxg4PY5zulXfcCIh6ov0DAghhBAXMI1G4Zaep1Y4ah5mJjrYiK5s2dCnr+vA49e0o1mot0E5M+Uo9322niKb0y8fVVX56vdjvLpoN0U2J3+cs5mpa7z7B/z1xo7Eh5qwOtys2p9NlsXG/zYdx+qoo6UtB3wOIx3e/9ZAsd3FI7M2YXN66N4ilCWTryAi0HDRBwIAI/slEB7gDYj+MHMjaw7k+IKB03sCnNIzIBrAxf9bJYQQQlziRl7W0vf2f1BSpN85rUbhqWvb89S17Xl/WSpvL93P6gM5PDxrE71bhrNkVwYj+7UkyKjl2W92AHCioNQ3TOW127pxb/+WZBTambrmMA/N2kSAQYvV4SblYC5v3d2jbh6iBj0Cdpebz1cfZsGWdFKziokNMfLZ/X0JDahZb8LFINik58PRffjT19tILyjlX0v2sWDiIAyGIOzF/svJOtzgXX9JegZE/ZEdiGUHYiGEEBeBjUfymLrmME9d256kmOon0G5Jy2f0Z+uxOk6NOVEU7yTk0w3tFMtn9/cF4FB2MTe+/5tvwzUAnUZh9bNXE1fW61AfHv9iC6tSs5l8TTuO5FqZvvYI4N0Feu4fBtC7ZcMs79rQsopsDHhtGR4Vfn16CC3DdWxJ3cZdM3J8aS5LMPDlo1dXWqFJiLM5lzauDBMSQgghLgJ9W0fw4eg+ZwwEAHq1DOfTMX0JrrBcalWBgEaBx65O8n3fJjqID+7tTc+EMO7s04KOccG4PCo/786os2c43dHcEhZuO0GB1cnL3+/2BQIPDk5k+Z+uvGQDAYCYYBOXt4sGYMGWdBRFy+mjsrzDhprsO1vRQGSYkBBCCHGJGdwuil+eHsLx/FKig4xc8a/lgLcn4K83duS9ZakMbBvp2xG33DWdYrmmk3e51Y9WHGTvT3tZuS+bscmta1WOQquTAKMWvVZDlsXGN5vTubxdFAezi5mzPo3dJyyVy54UxfM3da7V/S42t/duzsr92czfks4T17SrYs6Ad66HEPVJggEhhBDiEhQbYiI2xDu85+lr27PteCFv3dWD0AA9743sddbrh7SP5o2f9rJsbxb9X/uF127r5gsUzmTBlnQ0GoWFW0/wy55MerUM48uHknn66238lprDGz/5p1cU+L+bu/DxioOcKLRx34BWtXrei9F1neMINGg5nl/KprQCmUAsGoUEA0IIIcQl7rFr2p3zNZ2aBdOrZRhb0grItNiZMGMjSyZfQWSQgZlrj+BRoWVEAHf2aYGmbKOzJbsymPzlVr98tqQVcMN7qziYXeJ3vG10IHf2SaBfYgR9WoVzS8/mpGYW0bd1RK2f82JjNmi5oVsz/rfpON9uOU5yc//GvwwTEg1BggEhhBBCVKIoCv+8ozuT5m5hX2YRAMPeXVUpXYbFxiND2rJkVwZ/+Wa737kxA1oxe/1RXyBwc494FAWigow8fV17v6VCQ836JhUIlLu9d3P+t+k4i7afpFtUkN85pxsKCo6i15sJCopDo5Fmm6h7spqQrCYkhBBCnNHeDAvXv/tbjdJ2jAumTXQgt/RszrAucSzecZI//287QSYdPzx+ORGBhnou7cXF41EZ/MavnCi0cV0HEz/vs2HSKdhcKlGBGhZOiAG8uxTHxHRp5NKKi8W5tHElxBRCCCHEGXWMC2HK7d34+w97uLVXPI9emUTzMDNTFu/l45UHfekeuzqJiVcl+e1gfEO3ZlzVMQaXRyXIKM2O02k0Ctd3bcbUNYdZfcgOQJDRGwxUnEPgctmw2QoxmUIbq6jiEiW/lUIIIYQ4q5H9WnJnnxa+nY8Bnr2+A1lFNr7dks6H9/bmhm7Nqry2YnAgKhvQJoKpaw5jdXob/8EmPTkldpxu/3RWa7YEA6LOyT4DQgghhKiRioEAeOcVvHVXD7a8cG21gYA4u36JESgVNhkODfCuAuVwq+j1ZmJiugJgsxWSl3cQu72oMYopLlESDAghhBCi1hRFISxA5gGcj7AAA7f1au77PtikB8DtAa3OjE5n9PUI2GwF5Obux+EobpSyikuPBANCCCGEEI3sj1e29X0dUhYMAKiK2XsspAVKhe4Da3EGuKwNV0BxyZI5A0IIIYQQjSwhIsD3ta3CZAGdwbvcqk5nIiqqI3Z7EZY1D2FNX4hHA6FhSWhvTW3w8opLh/QMCCGEEEI0MqPu1CTr7GK77+uKKwrp9QEEmsPRnlgIgM0DhQUHpIdAnBcJBoQQQgghLiAnCmwYyiZrO9wev3OK1kB0h3GElY0ksnnAkfJQQxdRXEIkGBBCCCGEuACM6pcAwMSr2mLQeZto+SUODmb7TxbWDJxGwKgSAso6EywH5+BeMxbVbUeIcyU7EMsOxEIIIYS4ADjdHlIzi+nULJg+f/+FvBIHBp0Gh8vDW3f14I4+LfzSu9fcT/b+mXjKWnIGDUR1HA8DPm+E0osLybm0caVnQAghhBDiAqDXaugcH4KiKOSVOABwuLzDhJ7+ehulDv9dyLTJnxFcYT83hwdcB6aCx9lgZRYXPwkGhBBCCCEuAiv2Zfkf0OgJbDeO8FMrkWJrcTdo9FQik4xFNSQYEEIIIYS4wDwwqDUAEYEG2sUEATB/S3rlhMnTMCeVTShufhNFHf6C3W7B6fQ2/j0eN3lftyZjViDOBUkNVHpxMZE5AzJnQAghhBAXIFVVURSFA1lFDH17FQAv3NSZO3u3IDTgtLf/Hie5+Yex24t8h0JCWuBxFFG8oB0AwToIvrfE23NQVe+BuGTInAEhhBBCiItc+Y7DSTHB3NA1DoBXF+3mtg/XkJZ72rAfjZ6wsNbodCbfIYvlOMW/P+373m5sScFvD5A304B7zdj6fwBxUZBgQAghhBDiAvfiiM5EBBoAOJRTwm0frqGw1H+isFZrIDq6M7Gx3VAUDaguSF/oO+8oScN6+CvvZmWps2Q5UgFIMCCEEEIIccFrFmpm+dNXsuixwUQGGsgtcTB73VFcp29KpihotQbi4noSGBSPpsUtRBlAf1qLz+aBzH2zyJtlgnUTGvBJxIWmzoOB119/ncsuu4zg4GBiYmK49dZb2bdvn18am83GxIkTiYyMJCgoiDvuuIPMzEy/NGlpaQwfPpyAgABiYmJ45plncLlcfmlWrFhB7969MRqNJCUlMX369Lp+HCGEEEKIC0JogJ6uzUN58PI2APxryT4GvfErm47mV0qrKAqhoQnEXbcAw70OAhNHVpmn3QO2VFmOtCmr82Bg5cqVTJw4kXXr1rF06VKcTifXXXcdJSUlvjRPPvkk33//PV9//TUrV67kxIkT3H777b7zbreb4cOH43A4WLt2LTNmzGD69Om8+OKLvjSHDx9m+PDhXHXVVWzdupXJkyfz4IMPsmTJkrp+JCGEEEKIC8boAS0Z0j4agEyLnbs/SeGX3ZnVX6DRE3D5TAK1oFEqny71VD4mmo56X00oOzubmJgYVq5cyRVXXEFhYSHR0dHMnTuXO++8E4C9e/fSqVMnUlJSGDBgAIsXL+amm27ixIkTxMbGAvDxxx/z7LPPkp2djcFg4Nlnn+WHH35g586dvnuNHDmSgoICfvrppyrLYrfbsdtPjY2zWCwkJCTIakJCCCGEuOgU2Zw8/sUWlu/LBmDuH/ozsG1U9ResmwCHplLigiI3BGih2OUNEGLbj8F92QfYHCUEBESj0Wirz0dc8C6o1YQKCwsBiIiIAGDTpk04nU6GDh3qS9OxY0datmxJSkoKACkpKXTr1s0XCAAMGzYMi8XCrl27fGkq5lGepjyPqrz++uuEhob6PgkJCXXzkEIIIYQQDSzYpOf9Ub0IMekAuH/qBjYeyav+ggGfw0gHge3HE2eE4LZj0CjgUeHkvllkzQ7BsuZhcnL24HbLsKGmol6DAY/Hw+TJkxk0aBBdu3YFICMjA4PBQFhYmF/a2NhYMjIyfGkqBgLl58vPnSmNxWKhtLS0yvI899xzFBYW+j7Hjh0772cUQgghhGgswSY9Myf0p31sEE63yiOzN7M/s4h9GUVVX6DR+4ICZdBMghPv9j+fvhCXs4Ts7F1YrTl4PO76fwjRqOo1GJg4cSI7d+5k3rx59XmbGjMajYSEhPh9hBBCCCEuZj0TwlgwcRAd44LJKbZz3TurGPbuKqauPlz9RWWbjgVe+SXhYYmE6yFMD4ZWd4Ciw+NxU1BwlOzs3X4Bgctlo7QkC5fLhtWai6p6cLlsuN2OOnkWVVUbZzKzx9lkJ1Hr6ivjSZMmsWjRIlatWkWLFi18x+Pi4nA4HBQUFPj1DmRmZhIXF+dLs2HDBr/8ylcbqpjm9BWIMjMzCQkJwWw218cjCSGEEEJckAIMOj4d05e7PllLpsU7P/KVRbuJDDIQaNDRpXkIzUKrbh+Zbz8ELqt3orFGj9vtoKjoJHZ7IW63g2LLMQICIlHddvJ+exD38e+g+U3Q7WUKCo748gkJaUFQUIVRGx7nqZ2OK35dDZutgPxV9xOUsZDg9uNx9X4PjUaLRlcH7boz3N/2233YD80hQAv6pPHenpN6uM+Fqs57BlRVZdKkSXz77bf8+uuvJCYm+p3v06cPer2eZcuW+Y7t27ePtLQ0kpOTAUhOTmbHjh1kZWX50ixdupSQkBA6d+7sS1Mxj/I05XkIIYQQQjQlLSMDWPGnq5j7h/6M7t8SgCfmbeXBmRu5+s2V1Q8dAtAF+BqxWq2BsLBWhIQkwI5XKJ6fSNbsELK/iPYGAgDpi2DHy35ZWK3eicx2exEZP9+KdY4BNWU8+cvuxDLL4J3AXPYG3uWyU1qSicd1amh3ceER1OMLKXJB9t6pZM0OJndWAKQ8UOs6sduLyCwri28/hQq9AG6nlbzUOZS4odAFHKq8zKrDUUJu7n4KC49RXJxZaT6F1ZpDUdFJileOomCWAc/a+2td3sZQ56sJ/fGPf2Tu3Ll89913dOjQwXc8NDTU98b+0Ucf5ccff2T69OmEhITw2GOPAbB27VrAu7Roz549iY+P55///CcZGRmMGTOGBx98kNdeew3wLi3atWtXJk6cyPjx4/n11195/PHH+eGHHxg2bFiNynouM62FEEIIIS4WNqebK/65nKyiU6soPjCoNS0jAjiUXcKIHvF8+fsx+idGcPdlVS+oorodZM004lahfEXS8kajSePdyKzomnUEBTenpCQLVVWJCGtFQe5ePEsvByBI512xCMCsBacHArVQYmyJqyQNnQKhbUdSYLPiPr6wUhkAIvVgTBoHydP8jns8bpylOeiNIWh0ZtxuJ8XFGYCK0RiCXh9I9rI78RxfiEaBaAPkxdyK69gCQvWgaTmSooy1OEvSAO8zNuvs3zOgqio5OXtwOk8FLVqtnoCAKMprpajohHe35yUDAO/zBbS9D3fvtzGao1CUKtZzrWfn0sat82CgugeeNm0a48aNA7ybjj399NN88cUX2O12hg0bxocffugbAgRw9OhRHn30UVasWEFgYCD3338/U6ZMQac7NbJpxYoVPPnkk+zevZsWLVrwwgsv+O5RExIMCCGEEOJSteloHkt2ZaLVKHy04mC16T64tzfDuzer8pxzzf04D83EpPE2fVUq7FXQZjyefp+g0ejIzz9M6YbJkF51g76m9ApoFfDgDRxUvEughumBkQ5f74XDUUL+t51wlxxDq0Bkh/vJTXwcd8VmbYUGOpwqf7WuWUFoVGeMxhBARVVVLJbj2O2Wsxd8x8ve3pKy+5i0UOqGwMS7Cb3qy3OogbrRqMHAxUSCASGEEEJc6qwOF71fXYrNWfXuYv0SI/jq4TMMsy4fNnP6ePgKX7udJWTPDsKjgk4BRQGXx7/xreANJNxlBw2aUw3+clEGMIQkQfEB7G7I1bcA63HMre8iZMgc71t4VGzrJuI58WPlsja/GW3PV31DeXS7/oH55LcUuap+NAWINECurgXqFQuqTqNoiIhoi8EQ5B0OVJzhn6As6NAq3mfxVHigKAMY7nU0+DyCc2nj1tsEYiGEEEII0fgCDDpG9WvJtDVHAOgYF8zejCJu7RnPd9tOsOFwHr+lZhNi0lNkc5HcNhJtxa2KyxuyZ2jQavWBxHZ8APXQNF/PgUcFuweMGnBrg9G6i1A1gWTbStDgHf6j6oJwO4t9DWltm3He4UAeJwbVA5k7QXVRqugozdzuzXjHy3DiR3SKd+hReUNfo0BY1kJM0f/D4bKjqh4MQ79BcZeizA2k1ONt/Efovfcq7ynQJo7F3PkVrNacSs+l0WgJD29T1lsAAQFRlJbmYjKFlR1T0OlMqB3GohyeSbEbrGWLL+kVb8BzoZOeAekZEEIIIcQlLr/EwT9+3MMtPePp3jyM34/kcVXHGF74bidz16eh1Si4y15pt4sJ4sPRvWkXG3zuNyqfnHt64KDRe1cs0gXgWXs/yuGZKOUN/7KVjHzpKigpyaKwsMK+UBWG/oTpwdzqHooOf4mieMfqa9qMheQZlctVtvsyAEHt4KZdp8qp0ePxuCkqOkFJSRZ6fQDBwc3Q6UxoNPqa78bsceJYO4Gc/bMACNVBYPvzXJ2olmSYUA1JMCCEEEKIpszmdHPnx2vZmV55XPwfLk/kgUGJxIfVw5Lt57AEp9vtIDNzBwBGYwj2jX+C9IU063g/ysDpsLA9FKdCYBLcknrme3qc3pWTquF0lqLTmWo/6dfjJHemAbfqHSKkGdXwQ4RAgoEak2BACCGEEE1dXomDn3dlcHWnGH7cfpKXv9/tOxcdbOTHxy+nyOZkf2YRnZqFUGRz0bV5aIOWsaQkG6fTSmhoAlZrLnqtHoMp7FSCsl6HxlTepFbWP+jthWjTOL0CIMFAjUkwIIQQQgjh70BWER8uP8hvB3LILrKTFBPE0dwSnO5TTcYHByfSt3UEA9pE+FYqmnR1EsEm71vwrCIbRp2WULP3e1VVG2WJzbq0JS2f5uFmYoJNlc6tPZDDE19uRVXhtdu6cl2nSEpdGsyGGg4xqmMSDNSQBANCCCGEEFVbtT+bsVM31Dj9kPbRTBicSGpWMa8u2o1Bq+HRK9vy1cZjtI4M5N7+LZmVcpSJVycxpH10lXl4PKp3Uq+mbgKHX/dm8vy3O/nTsA7c3rtFpfOlDjdLdmWwI72QPSctDO0Uy9jkVmgUBU1ZGVIO5jLqv+t81/RLjGD6A5dh1mspcbix2l1c/95v5JU4fGkmD23HrJSjzHtoQO3mXpwnCQZqSIIBIYQQQoiquT0qff++lHyrd5nOBRMHkWWxcSinhDUHcvgttfLqOzURF2JixTNXsmj7SYw6DYOToiiyucizOnhwxkYcLjffPzaYVpGBla61OlwEGLyLYaqqytZjBSiKQs+EMF+ajEIbM1OOEBlk5NVF3iFPzUJNpDx3DYdzSvhh+wkMOg0aRWH+5nR2n6w8XyI8QM/o/q3QaBTeX1Z5HsIdvVuQXWznt9RsNIp38nXb6EDsLg/H809tUHbfgJb8/dZutaqn8yHBQA1JMCCEEEIIUb3l+7L4w4yNdGwWzPeTBvsN9Vm+N4sn5m3hiaHtmbv+KAezS3zneiSEkVloI8NiqzJfo06D3VX1vgcA7WODcLpVDueU0D8xgsevacf+zCL+7/vdDO0Uw4ej+/DxyoO8vXQ/AK/e2pUBiRHsSC/kufk7qsz7yaHt+WD5ARzu6u97Jq/c0oWd6YV8tfF4pXPhAXq+fmQgBVYHr/6wB5fbw229mvPAoMQ66+U4FxIM1JAEA0IIIYQQZ5ZeUEqwSUeIqfpVcQ5kFbP1WAE394in2O4iPEBPqdPNxiP59EuMYMW+LNILbBi0Ci98t+u8y3RLz3i+23qiVtd2ahaCx6OyL7OIyEADL9/chRE94pmx9ggvLfSW7fJ2Uew+YaFNdCBto4MY1jWOqzrEoKoqs9cdZfa6NMIC9NzWqzkajcIV7aKJC608l6CxSDBQQxIMCCGEEEI0HJfbw/MLdnIop4S7+yZwbedYMgpteFSVmSlH6N4ijIhAA99tTSen2IHbo3KyoJQThVX3MAxOimLtwRzfrr9JMUF0bxHKnX1asP5QHrkldi5vF83DszYBcFWHaKaOuwxFUVBVFVXFNzfA7nLz+erDXN0xho5xF3e7UIKBGpJgQAghhBDiwqaqKv/3/W62HS/g3n4teeZ/3p2IeyaEMe+hAXyz+Tjv/ZLKG3d056qOMVXmsfVYATuOF3BT93jCAw0NWfxGIcFADUkwIIQQQghxcfl+2wmW7cnkqWs70DKycfcWuFCdSxtX10BlEkIIIYQQ4ryN6BHPiB7xjV2MS4amsQsghBBCCCGEaBwSDAghhBBCCNFESTAghBBCCCFEEyXBgBBCCCGEEE2UBANCCCGEEEI0URIMCCGEEEII0URJMCCEEEIIIUQTJcGAEEIIIYQQTZQEA0IIIYQQQjRREgwIIYQQQgjRREkwIIQQQgghRBMlwYAQQgghhBBNlAQDQgghhBBCNFESDAghhBBCCNFESTAghBBCCCFEEyXBgBBCCCGEEE2UBANCCCGEEEI0UbrGLkBjUlUVAIvF0sglEUIIIYQQom6Ut23L27pn0qSDgaKiIgASEhIauSRCCCGEEELUraKiIkJDQ8+YRlFrEjJcojweDydOnCA4OBhFURr8/haLhYSEBI4dO0ZISEiD3/9iJnV3fqT+ak/qrvak7mpP6q72pO5qT+qu9hq77lRVpaioiPj4eDSaM88KaNI9AxqNhhYtWjR2MQgJCZFfslqSujs/Un+1J3VXe1J3tSd1V3tSd7UndVd7jVl3Z+sRKCcTiIUQQgghhGiiJBgQQgghhBCiiZJgoBEZjUZeeukljEZjYxfloiN1d36k/mpP6q72pO5qT+qu9qTuak/qrvYuprpr0hOIhRBCCCGEaMqkZ0AIIYQQQogmSoIBIYQQQgghmigJBoQQQgghhGiiJBgQQgghhBCiiZJgQAghhBBCiCZKgoF6NmXKFBRFYfLkyb5jNpuNiRMnEhkZSVBQEHfccQeZmZl+16WlpTF8+HACAgKIiYnhmWeeweVyNXDpG156ejr33XcfkZGRmM1munXrxsaNG33nVVXlxRdfpFmzZpjNZoYOHUpqaqpfHnl5eYwePZqQkBDCwsKYMGECxcXFDf0oDcrtdvPCCy+QmJiI2Wymbdu2vPrqq1RcLEzq7pRVq1YxYsQI4uPjURSFBQsW+J2vq7ravn07l19+OSaTiYSEBP75z3/W96PVuzPVndPp5Nlnn6Vbt24EBgYSHx/P2LFjOXHihF8eUndV/9xV9Mgjj6AoCu+++67fcam76utuz5493HzzzYSGhhIYGMhll11GWlqa73xT/dt7trorLi5m0qRJtGjRArPZTOfOnfn444/90jTVunv99de57LLLCA4OJiYmhltvvZV9+/b5pamrulmxYgW9e/fGaDSSlJTE9OnT6/vxTlFFvdmwYYPaunVrtXv37uoTTzzhO/7II4+oCQkJ6rJly9SNGzeqAwYMUAcOHOg773K51K5du6pDhw5Vt2zZov74449qVFSU+txzzzXCUzScvLw8tVWrVuq4cePU9evXq4cOHVKXLFmiHjhwwJdmypQpamhoqLpgwQJ127Zt6s0336wmJiaqpaWlvjTXX3+92qNHD3XdunXqb7/9piYlJamjRo1qjEdqMP/4xz/UyMhIddGiRerhw4fVr7/+Wg0KClLfe+89Xxqpu1N+/PFH9W9/+5s6f/58FVC//fZbv/N1UVeFhYVqbGysOnr0aHXnzp3qF198oZrNZvWTTz5pqMesF2equ4KCAnXo0KHql19+qe7du1dNSUlR+/Xrp/bp08cvD6m7qn/uys2fP1/t0aOHGh8fr77zzjt+56Tuqq67AwcOqBEREeozzzyjbt68WT1w4ID63XffqZmZmb40TfVv79nq7g9/+IPatm1bdfny5erhw4fVTz75RNVqtep3333nS9NU627YsGHqtGnT1J07d6pbt25Vb7zxRrVly5ZqcXGxL01d1M2hQ4fUgIAA9amnnlJ3796t/vvf/1a1Wq36008/NchzSjBQT4qKitR27dqpS5cuVYcMGeILBgoKClS9Xq9+/fXXvrR79uxRATUlJUVVVe8vrkajUTMyMnxpPvroIzUkJES12+0N+hwN6dlnn1UHDx5c7XmPx6PGxcWp//rXv3zHCgoKVKPRqH7xxReqqqrq7t27VUD9/ffffWkWL16sKoqipqen11/hG9nw4cPV8ePH+x27/fbb1dGjR6uqKnV3Jqf/cayruvrwww/V8PBwv9/ZZ599Vu3QoUM9P1HDOVODttyGDRtUQD169KiqqlJ35aqru+PHj6vNmzdXd+7cqbZq1covGJC686qq7u655x71vvvuq/Ya+dvrVVXddenSRX3llVf8jvXu3Vv929/+pqqq1F1FWVlZKqCuXLlSVdW6q5s///nPapcuXfzudc8996jDhg2r70dSVVVVZZhQPZk4cSLDhw9n6NChfsc3bdqE0+n0O96xY0datmxJSkoKACkpKXTr1o3Y2FhfmmHDhmGxWNi1a1fDPEAjWLhwIX379uWuu+4iJiaGXr168d///td3/vDhw2RkZPjVXWhoKP379/eru7CwMPr27etLM3ToUDQaDevXr2+4h2lgAwcOZNmyZezfvx+Abdu2sXr1am644QZA6u5c1FVdpaSkcMUVV2AwGHxphg0bxr59+8jPz2+gp2l8hYWFKIpCWFgYIHV3Jh6PhzFjxvDMM8/QpUuXSuel7qrm8Xj44YcfaN++PcOGDSMmJob+/fv7DYeRv73VGzhwIAsXLiQ9PR1VVVm+fDn79+/nuuuuA6TuKiosLAQgIiICqLu6SUlJqdReHDZsmC+P+ibBQD2YN28emzdv5vXXX690LiMjA4PB4PvDWC42NpaMjAxfmoo/NOXny89dqg4dOsRHH31Eu3btWLJkCY8++iiPP/44M2bMAE49e1V1U7HuYmJi/M7rdDoiIiIu6br7y1/+wsiRI+nYsSN6vZ5evXoxefJkRo8eDUjdnYu6qqum+ntckc1m49lnn2XUqFGEhIQAUndn8sYbb6DT6Xj88cerPC91V7WsrCyKi4uZMmUK119/PT///DO33XYbt99+OytXrgTkb++Z/Pvf/6Zz5860aNECg8HA9ddfzwcffMAVV1wBSN2V83g8TJ48mUGDBtG1a1eg7uqmujQWi4XS0tL6eBw/unq/QxNz7NgxnnjiCZYuXYrJZGrs4lxUPB4Pffv25bXXXgOgV69e7Ny5k48//pj777+/kUt3Yfvqq6+YM2cOc+fOpUuXLmzdupXJkycTHx8vdScahdPp5O6770ZVVT766KPGLs4Fb9OmTbz33nts3rwZRVEauzgXFY/HA8Att9zCk08+CUDPnj1Zu3YtH3/8MUOGDGnM4l3w/v3vf7Nu3ToWLlxIq1atWLVqFRMnTiQ+Pr7S2+qmbOLEiezcuZPVq1c3dlHqnPQM1LFNmzaRlZVF79690el06HQ6Vq5cyfvvv49OpyM2NhaHw0FBQYHfdZmZmcTFxQEQFxdXaSZ6+fflaS5FzZo1o3Pnzn7HOnXq5FsNovzZq6qbinWXlZXld97lcpGXl3dJ190zzzzj6x3o1q0bY8aM4cknn/T1Tknd1Vxd1VVT/T2GU4HA0aNHWbp0qa9XAKTuqvPbb7+RlZVFy5YtfX87jh49ytNPP03r1q0BqbvqREVFodPpzvr3Q/72VlZaWspf//pX3n77bUaMGEH37t2ZNGkS99xzD2+++SYgdQcwadIkFi1axPLly2nRooXveF3VTXVpQkJCMJvNdf04lUgwUMeuueYaduzYwdatW32fvn37Mnr0aN/Xer2eZcuW+a7Zt28faWlpJCcnA5CcnMyOHTv8/tEv/4N6+j92l5JBgwZVWrJr//79tGrVCoDExETi4uL86s5isbB+/Xq/uisoKGDTpk2+NL/++isej4f+/fs3wFM0DqvVikbj/+us1Wp9b8yk7mquruoqOTmZVatW4XQ6fWmWLl1Khw4dCA8Pb6CnaXjlgUBqaiq//PILkZGRfuel7qo2ZswYtm/f7ve3Iz4+nmeeeYYlS5YAUnfVMRgMXHbZZWf8+9GnTx/521sFp9OJ0+k849+Pplx3qqoyadIkvv32W3799VcSExP9ztdV3SQnJ/vlUZ6mPI961yDTlJu4iqsJqap3GaqWLVuqv/76q7px40Y1OTlZTU5O9p0vX4bquuuuU7du3ar+9NNPanR09EW/RNfZbNiwQdXpdOo//vEPNTU1VZ0zZ44aEBCgzp4925dmypQpalhYmPrdd9+p27dvV2+55ZYql3zs1auXun79enX16tVqu3btLsnlMSu6//771ebNm/uWFp0/f74aFRWl/vnPf/alkbo7paioSN2yZYu6ZcsWFVDffvttdcuWLb4Vb+qirgoKCtTY2Fh1zJgx6s6dO9V58+apAQEBF/0Sj2eqO4fDod58881qixYt1K1bt6onT570fSquKCJ1V/XP3elOX01IVaXuqqu7+fPnq3q9Xv3000/V1NRU39KMv/32my+Ppvq392x1N2TIELVLly7q8uXL1UOHDqnTpk1TTSaT+uGHH/ryaKp19+ijj6qhoaHqihUr/P49s1qtvjR1UTflS4s+88wz6p49e9QPPvhAlha91JweDJSWlqp//OMf1fDwcDUgIEC97bbb1JMnT/pdc+TIEfWGG25QzWazGhUVpT799NOq0+ls4JI3vO+//17t2rWrajQa1Y4dO6qffvqp33mPx6O+8MILamxsrGo0GtVrrrlG3bdvn1+a3NxcddSoUWpQUJAaEhKiPvDAA2pRUVFDPkaDs1gs6hNPPKG2bNlSNZlMaps2bdS//e1vfg0wqbtTli9frgKVPvfff7+qqnVXV9u2bVMHDx6sGo1GtXnz5uqUKVMa6hHrzZnq7vDhw1WeA9Tly5f78pC6q/rn7nRVBQNSd9XX3eeff64mJSWpJpNJ7dGjh7pgwQK/PJrq396z1d3JkyfVcePGqfHx8arJZFI7dOigvvXWW6rH4/Hl0VTrrrp/z6ZNm+ZLU1d1s3z5crVnz56qwWBQ27Rp43eP+qaoaoUtSoUQQgghhBBNhswZEEIIIYQQoomSYEAIIYQQQogmSoIBIYQQQgghmigJBoQQQgghhGiiJBgQQgghhBCiiZJgQAghhBBCiCZKggEhhBBCCCGaKAkGhBBCCCGEaKIkGBBCCCGEEKKJkmBACCGEEEKIJkqCASGEEEIIIZooCQaEEEIIIYRooiQYEEIIIYQQoomSYEAIIYQQQogmSoIBIYQQQgghmigJBoQQQgghhGiiJBgQQgghhBCiiZJgQAghhBBCiCZKggEhhBBCCCGaKAkGhBBCCCGEaKIkGBBCCCGEEKKJkmBACCGEEEKIJkqCASGEEEIIIZooCQaEEEIIIYRooiQYEEIIIYQQoomSYEAIIYQQQogmSoIBIYQQQgghmigJBoQQQgghhGiiJBgQQgghhBCiiZJgQAghhBBCiCZKggEhhBBCCCGaKAkGhBBCCCGEaKIkGBBCCCGEEKKJkmBACCGEEEKIJkqCASGEEEIIIZooCQaEEEIIIYRooiQYEEIIIYQQoomSYEAIIYQQQogmSoIBIYQQQgghmigJBoQQQgghhGiiJBgQQgghhBCiiZJgQAghhBBCiCZKggEhhBBCCCGaKAkGhBBCCCGEaKIkGBBCCCGEEKKJkmBACCGEEEKIJkqCASGEEEIIIZooCQaEEEIIIYRooiQYEEIIIYQQoomSYEAIIYQQQogmSoIBIYQQQgghmigJBoQQQgghhGiiJBgQQgghhBCiiZJgQAghhBBCiCZKggEhhBBCCCGaKAkGhBBCCCGEaKIkGBBCCCGEEKKJkmBACCGEEEKIJkqCASGEEEIIIZooCQaEEEIIIYRooiQYEEIIIYQQoomSYEAIIYQQQogmSoIBIYQQQgghmigJBoQQQgghhGiiJBgQQgghhBCiiZJgQAghhBBCiCZKggEhhBBCCCGaKAkGhBBCCCGEaKJ0jV2AxuTxeDhx4gTBwcEoitLYxRFCCCGEEOK8qapKUVER8fHxaDRnfvffpIOBEydOkJCQ0NjFEEIIIYQQos4dO3aMFi1anDFNkw4GgoODAW9FhYSENHJphBBCCCGEOH8Wi4WEhARfW/dMmnQwUD40KCQkRIIBIYQQQghxSanJMHiZQCyEEEIIIUQTJcGAEEIIIYQQTZQEA0IIIYQQQjRRTXrOgBBCCCGaLo/Hg8PhaOxiCHHO9Ho9Wq22TvKSYEAIIYQQTY7D4eDw4cN4PJ7GLooQtRIWFkZcXNx575UlwYAQQgghmhRVVTl58iRarZaEhISzbsokxIVEVVWsVitZWVkANGvW7Lzyk2BACCGEEE2Ky+XCarUSHx9PQEBAYxdHiHNmNpsByMrKIiYm5ryGDEkoLIQQQogmxe12A2AwGBq5JELUXnkg63Q6zysfCQaEEEII0SSd71hrIRpTXf38SjAghBBCCCFEEyXBgBBCCCGE8NO6dWveffdd3/eKorBgwYLzyrMu8hB1TyYQCyGEEEKIMzp58iTh4eE1Svvyyy+zYMECtm7dWus8RMORYEAIIYQQ4hLkcDjqbJJ0XFzcBZGHqHsyTEgIIYQQTZ6qehrlcy6uvPJKJk2axKRJkwgNDSUqKooXXngBVVUB79CeV199lbFjxxISEsJDDz0EwOrVq7n88ssxm80kJCTw+OOPU1JS4ss3KyuLESNGYDabSUxMZM6cOZXuffoQn+PHjzNq1CgiIiIIDAykb9++rF+/nunTp/N///d/bNu2DUVRUBSF6dOnV5nHjh07uPrqqzGbzURGRvLQQw9RXFzsOz9u3DhuvfVW3nzzTZo1a0ZkZCQTJ04879VzhD/pGRBCCCFEk6aqHk6e3NIo927WrBeKUvN3szNmzGDChAls2LCBjRs38tBDD9GyZUv+8Ic/APDmm2/y4osv8tJLLwFw8OBBrr/+ev7+978zdepUsrOzfQHFtGnTAG+j+8SJEyxfvhy9Xs/jjz/u29CqKsXFxQwZMoTmzZuzcOFC4uLi2Lx5Mx6Ph3vuuYedO3fy008/8csvvwAQGhpaKY+SkhKGDRtGcnIyv//+O1lZWTz44INMmjTJFzwALF++nGbNmrF8+XIOHDjAPffcQ8+ePX3PK86fBANCCCGEEBeJhIQE3nnnHRRFoUOHDuzYsYN33nnH1zi++uqrefrpp33pH3zwQUaPHs3kyZMBaNeuHe+//z5Dhgzho48+Ii0tjcWLF7NhwwYuu+wyAD7//HM6depUbRnmzp1LdnY2v//+OxEREQAkJSX5zgcFBaHT6c44LGju3LnYbDZmzpxJYGAgAP/5z38YMWIEb7zxBrGxsQCEh4fzn//8B61WS8eOHRk+fDjLli2TYKAOSTBwAbOX5uF22wEFszkcRWts7CIJIYQQlxxF0dCsWa9Gu/e5GDBggN/68snJybz11lu+jdT69u3rl37btm1s377db+iPqqp4PB4OHz7M/v370el09OnTx3e+Y8eOhIWFVVuGrVu30qtXL18gUBt79uyhR48evkAAYNCgQXg8Hvbt2+cLBrp06eK3u26zZs3YsWNHre8rKpNg4ALkcJRQ/NtYbEfn+44VKxDVYRyagdMasWRCCCHEpelcG+UXqoqNa/AO6Xn44Yd5/PHHK6Vt2bIl+/fvP+d7mM3mWpfvXOn1er/vFUXB4zm3uRbizC6Nn/xLiMVynJxf78F2dD4KYNSAArhUKD4wHVzWRi6hEEIIIRrL+vXr/b5ft24d7dq183t7XlHv3r3ZvXs3SUlJlT4Gg4GOHTvicrnYtGmT75p9+/ZRUFBQbRm6d+/O1q1bycvLq/K8wWDw9VRUp1OnTmzbts1vIvOaNWvQaDR06NDhjNeKuiXBwAXCbi+i2HKM4pRH4cQPAATpINIA4WVBcbELLHMDYd2ERiypEEIIIRpLWloaTz31FPv27eOLL77g3//+N0888US16Z999lnWrl3LpEmT2Lp1K6mpqXz33XdMmjQJgA4dOnD99dfz8MMPs379ejZt2sSDDz54xrf/o0aNIi4ujltvvZU1a9Zw6NAhvvnmG1JSUgDvqkaHDx9m69at5OTkYLfbK+UxevRoTCYT999/Pzt37mT58uU89thjjBkzxjdESDQMCQYuAE5nKbkr7sPyv5aQvohALcQaIVgHJI7DNKoEc1nAX+wC98Gp4JFltYQQQoimZuzYsZSWltKvXz8mTpzIE0884VtCtCrdu3dn5cqV7N+/n8svv5xevXrx4osvEh8f70szbdo04uPjGTJkCLfffjsPPfQQMTEx1eZpMBj4+eefiYmJ4cYbb6Rbt25MmTLF1ztxxx13cP3113PVVVcRHR3NF198USmPgIAAlixZQl5eHpdddhl33nkn11xzDf/5z3/Oo3ZEbShq+eK0TZDFYiE0NJTCwkJCQkIarRyF+Qcp+fbULPwYA+jajoP+n4KmrFtg3QSy907F6YHQtiMJHFL5F0sIIYQQZ2ez2Th8+DCJiYmYTKbGLk6NXXnllfTs2ZN33323sYsiLgBn+jk+lzau9Aw0Mo/HjfX3U0uABWpBp8E/EAAY8Dnm29Og+U3YDs+ToUJCCCGEEOK8STDQyEqK0lGPf4degXgThOqBNuP9A4EyRmMopC/C4QFVhgoJIYQQQojzJEuLNiJV9VCy3rvUV5AObxDQ7+MqAwEAnSEYTYtb8Bz/DlfrsejL03mc1V4jhBBCiEvDihUrGrsI4hIkPQONyFp8Es/x79ApYNJwxkAAvGvr6vv8E4ato7jjXyktSif3lzvImGHAtXZcg5VbCCGEEEJcGqRnoBGVrH8M8PYKKG2rHhp0Or0+EPvGZyhNX0hpheO2AzMIGvBf6SEQQgghhBA1Jj0DjcTjKsWV9i1QoVegBox6E6QvRAH0Ff7vOZvfIYGAEEIIIYQ4JxIMNBKHywHNb0angKaGvQIARnMkke3HEGuEaIN3UzKa34Sj81/rt8BCCCGEEOKSI8FAI3E4iqHrXzHcsh8GfH5O1xoHz0QzygF3l6AfWQpocC/ug3vN/fVTWCGEEEIIcUk652Bg1apVjBgxgvj4eBRFYcGCBb5zTqeTZ599lm7duhEYGEh8fDxjx47lxIkTfnnk5eUxevRoQkJCCAsLY8KECRQXF/ul2b59O5dffjkmk4mEhAT++c9/VirL119/TceOHTGZTHTr1o0ff/zxXB+n0Th/fwKWDMCw8+XaZaDRgy4AjUaL/uRCAPJTZ6LKRGIhhBBCCFFD5xwMlJSU0KNHDz744INK56xWK5s3b+aFF15g8+bNzJ8/n3379nHzzTf7pRs9ejS7du1i6dKlLFq0iFWrVvltpW2xWLjuuuto1aoVmzZt4l//+hcvv/wyn376qS/N2rVrGTVqFBMmTGDLli3ceuut3HrrrezcufNcH6nheZwY07/BqAFD2tzz2y9Aoycs6T40Cjg8YDs4Q/YfEEIIIUSdePnll+nZs2ed5jl9+nTCwsLqNM/zsWLFChRFoaCgAKib8l1oz3hG6nkA1G+//faMaTZs2KAC6tGjR1VVVdXdu3ergPr777/70ixevFhVFEVNT09XVVVVP/zwQzU8PFy12+2+NM8++6zaoUMH3/d33323Onz4cL979e/fX3344YerLYvNZlMLCwt9n2PHjqmAWlhYWONnrjMp41V1Dt7/1gHLr3er6Z+jZk9DVdeOq5M8hRBCiEtRaWmpunv3brW0tLSxi3LBe+mll9QePXrUaZ7Tpk1TQ0ND6zTP87F8+XIVUPPz81VVVVWr1apmZmbW+PpWrVqp77zzjt+xc82jNs70c1xYWFjjNm69zxkoLCxEURRfdJSSkkJYWBh9+/b1pRk6dCgajYb169f70lxxxRUYDAZfmmHDhrFv3z7y8/N9aYYOHep3r2HDhpGSklJtWV5//XVCQ0N9n4SEhLp6zHM34HMY6Tjn+QLVCRg8FQVv70BJ6nRIeaBO8hVCCCGEuNCpqorL5aqTvMxmMzExMY2eR0Op12DAZrPx7LPPMmrUKEJCQgDIyMioVDk6nY6IiAgyMjJ8aWJjY/3SlH9/tjTl56vy3HPPUVhY6PscO3bs/B7wfNXhUqBafSAhbe4BoMgN6qHpMlxICCGEuIRceeWVPPbYY0yePJnw8HBiY2P573//S0lJCQ888ADBwcEkJSWxePFi3zVut5sJEyaQmJiI2WymQ4cOvPfee375rlixgn79+hEYGEhYWBiDBg3i6NGjVZbh4MGDtGnThkmTJqGqKna7nT/96U80b96cwMBA+vfvX2mn5OnTp9OyZUsCAgK47bbbyM3NPeNzHjlyBEVRmDdvHgMHDsRkMtG1a1dWrlzpV2ZFUVi8eDF9+vTBaDSyevVqPB4Pr7/+uu95e/Towf/+9z+//H/88Ufat2+P2Wzmqquu4siRI5XKe/oQn++//57LLrsMk8lEVFQUt912m+//ydGjR3nyySdRFAVFUarN46OPPqJt27YYDAY6dOjArFmz/M4risJnn33GbbfdRkBAAO3atWPhwoVnrKu6UG/BgNPp5O6770ZVVT766KP6us05MRqNhISE+H0uJYFXzkPb4hY8KtgT7pV9B4QQQohLzIwZM4iKimLDhg089thjPProo9x1110MHDiQzZs3c9111zFmzBisVisAHo+HFi1a8PXXX7N7925efPFF/vrXv/LVV18B4HK5uPXWWxkyZAjbt28nJSWFhx56yNeorWj79u0MHjyYe++9l//85z8oisKkSZNISUlh3rx5bN++nbvuuovrr7+e1NRUANavX8+ECROYNGkSW7du5aqrruLvf/97jZ71mWee4emnn2bLli0kJyczYsSISoHEX/7yF6ZMmcKePXvo3r07r7/+OjNnzuTjjz9m165dPPnkk9x3332+QOLYsWPcfvvtjBgxgq1bt/Lggw/yl7/85Yzl+OGHH7jtttu48cYb2bJlC8uWLaNfv34AzJ8/nxYtWvDKK69w8uRJTp48WWUe3377LU888QRPP/00O3fu5OGHH+aBBx5g+fLlfun+7//+j7vvvpvt27dz4403Mnr0aPLy8mpUX7V2PmOVqGbOgMPhUG+99Va1e/fuak5Ojt+5zz//XA0LC/M75nQ6Va1Wq86fP19VVVUdM2aMesstt/il+fXXX1VAzcvLU1VVVRMSEiqNz3rxxRfV7t2717j85zKe6mJRUJCmpv90k5o/ve7mIwghhBCXkjqfM+B21E0+ZzFkyBB18ODBvu9dLpcaGBiojhkzxnfs5MmTKqCmpKRUm8/EiRPVO+64Q1VVVc3NzVUBdcWKFVWmLZ8zsGbNGjU8PFx98803feeOHj2qarVa35zPctdcc4363HPPqaqqqqNGjVJvvPFGv/P33HPPGecMHD58WAXUKVOm+I45nU61RYsW6htvvKGq6qlx/gsWLPClsdlsakBAgLp27Vq//CZMmKCOGjVKVVVVfe6559TOnTv7nX/22Wf95gycPqchOTlZHT16dLXlrWrOwOl5DBw4UP3DH/7gl+auu+7yqxtAff75533fFxcXq4C6ePHiKu97wc4ZKO8RSE1N5ZdffiEyMtLvfHJyMgUFBWzatMl37Ndff8Xj8dC/f39fmlWrVuF0nhrmsnTpUjp06EB4eLgvzbJly/zyXrp0KcnJyXX9SBcVszEI0hdh84B6cKoMFRJCCCHq07oJMM/g/W8D6N69u+9rrVZLZGQk3bp18x0rH0KdlZXlO/bBBx/Qp08foqOjCQoK4tNPPyUtLQ2AiIgIxo0bx7BhwxgxYgTvvfdepbfbaWlpXHvttbz44os8/fTTvuM7duzA7XbTvn17goKCfJ+VK1dy8OBBAPbs2eNr35WraVutYjqdTkffvn3Zs2ePX5qKc1APHDiA1Wrl2muv9SvPzJkzz6s8W7du5ZprrqlRmauzZ88eBg0a5Hds0KBBlZ6n4v/fwMBAQkJC/P5f1gfduV5QXFzMgQMHfN8fPnyYrVu3EhERQbNmzbjzzjvZvHkzixYtwu12+8bwR0REYDAY6NSpE9dffz1/+MMf+Pjjj3E6nUyaNImRI0cSHx8PwL333sv//d//MWHCBJ599ll27tzJe++9xzvvvOO77xNPPMGQIUN46623GD58OPPmzWPjxo1+y482RQZTONqEW3EfW4A94V5MMlRICCGEqB8eJxya6v360FTo93G9D9HV6/3zVxTF71j58B6PxwPAvHnz+NOf/sRbb71FcnIywcHB/Otf//It2gIwbdo0Hn/8cX766Se+/PJLnn/+eZYuXcqAAQMAiI6OJj4+ni+++ILx48f7hlkXFxej1WrZtGkTWq3Wr1xBQUF1//BVCAwM9H1dvmfVDz/8QPPmzf3SGY3GWt/DbDbX+tpzVdX/3/L/l/XlnHsGNm7cSK9evejVqxcATz31FL169eLFF18kPT2dhQsXcvz4cXr27EmzZs18n7Vr1/rymDNnDh07duSaa67hxhtvZPDgwX6N+NDQUH7++WcOHz5Mnz59ePrpp3nxxRf99iIYOHAgc+fO5dNPP/VNDlmwYAFdu3Y9n/q4JJj6vQfNb8J2eG6DvakQQgghmhyNHtqM937dZvwFOVdvzZo1DBw4kD/+8Y/06tWLpKQk31vyinr16sVzzz3H2rVr6dq1K3PnzvWdM5vNLFq0CJPJxLBhwygqKvJd43a7ycrKIikpye8TFxcHQKdOnfwCD4B169bVqOwV07lcLjZt2kSnTp2qTd+5c2eMRiNpaWmVylO+gmSnTp3YsGHDOZWne/fulUajVGQwGHC73WfMo1OnTqxZs8bv2Jo1a+jcufMZr2sI59wzcOWVV+Id1lS1M50rFxER4fdDVpXu3bvz22+/nTHNXXfdxV133XXW+zU1Rn0AJemLcCg02JsKIYQQokka8PkF/Xe2Xbt2zJw5kyVLlpCYmMisWbP4/fffSUxMBLwjPD799FNuvvlm4uPj2bdvH6mpqYwdO9Yvn8DAQH744QduuOEGbrjhBn766Sfat2/P6NGjGTt2LG+99Ra9evUiOzubZcuW0b17d4YPH87jjz/OoEGDePPNN7nllltYsmQJP/30U43K/sEHH9CuXTs6derEO++8Q35+PuPHj682fXBwMH/605948skn8Xg8DB48mMLCQtasWUNISAj3338/jzzyCG+99RbPPPMMDz74IJs2bWL69OlnLMdLL73ENddcQ9u2bRk5ciQul4sff/yRZ599FoDWrVuzatUqRo4cidFoJCoqqlIezzzzDHfffTe9evVi6NChfP/998yfP59ffvmlRnVRn+p9nwHR8AymcGh+My4VPK3HXbD/QAkhhBCXhAv47+zDDz/M7bffzj333EP//v3Jzc3lj3/8o+98QEAAe/fu5Y477qB9+/Y89NBDTJw4kYcffrhSXkFBQSxevBhVVRk+fDglJSVMmzaNsWPH8vTTT9OhQwduvfVWfv/9d1q2bAnAgAED+O9//8t7771Hjx49+Pnnn3n++edrVPYpU6YwZcoUevTowerVq1m4cGGVDe2KXn31VV544QVef/1139D0H374wRf8tGzZkm+++YYFCxbQo0cPPv74Y1577bUz5nnllVfy9ddfs3DhQnr27MnVV1/t17vwyiuvcOTIEdq2bUt0dHSVedx666289957vPnmm3Tp0oVPPvmEadOmceWVV9aoLuqTotbkVf4lymKxEBoaSmFh4SW3zGhW1i5czmIiwttiCjjzL44QQgjRlNhsNg4fPkxiYiImk6mxiyNOc+TIERITE9myZQs9e/Zs7OJcsM70c3wubVzpGbhEGQyBsPM1Sr+OlnkDQgghhBCiShIMXKLMxhBIX0ipG6ypssSoEEIIIYSo7JwnEIuLg9EYTLAOilxQ6oaAxi6QEEIIIUQNtG7dukYL0oi6IT0DlyqNHnNb70oAjmYj8HjOvOSVEEIIIYRoeiQYuITpBs1A1+IW1PTvscwxo6ZUvxyXEEIIIYRoeiQYuJR5nARnfgeA1Q22A9Nk7oAQQgghhPCRYOBSptFjbjeeoLKZIaXxt1/QayELIYQQQoiGJcHApW7A5wSMtEDzm7AfnY9n7QONXSIhhBBCCHGBkGCgCdDpTOhPLEIFHAeny1AhIYQQQggBSDDQNGj06FvfDYAj4R4ZKiSEEEJchK688komT55co7QrVqxAURQKCgrO656tW7fm3XffPa88xIVN9hloIgz9P8Da/imKgQBHETpDcGMXSQghhBBCNDLpGWgiDIYg2PkaLBlA9uwQnKvHNHaRhBBCCCFEI5NgoInQabSYMxYCoAK5qbNxrb6vcQslhBBCXABUVcXqcDXKp7Y77c6aNYu+ffsSHBxMXFwc9957L1lZWZXSrVmzhu7du2MymRgwYAA7d+70O7969Wouv/xyzGYzCQkJPP7445SUlNSqTOLiJMOEmgqNnvAO4wk9OJVcJzg9UHhgDpFaPSRPa+zSCSGEEI2m1Omm84tLGuXeu18ZRoDh3JtjTqeTV199lQ4dOpCVlcVTTz3FuHHj+PHHH/3SPfPMM7z33nvExcXx17/+lREjRrB//370ej0HDx7k+uuv5+9//ztTp04lOzubSZMmMWnSJKZNk7ZBUyE9A03JgM/RjHIQkTQaBbB7wCmrCwkhhBAXnfHjx3PDDTfQpk0bBgwYwPvvv8/ixYspLi72S/fSSy9x7bXX0q1bN2bMmEFmZibffvstAK+//jqjR49m8uTJtGvXjoEDB/L+++8zc+ZMbDZbYzyWaATSM9DUaPRoB8/GZLdRevQbit0QvHY8uoFTZZUhIYQQTZJZr2X3K8Ma7d61sWnTJl5++WW2bdtGfn4+Ho8HgLS0NDp37uxLl5yc7Ps6IiKCDh06sGfPHgC2bdvG9u3bmTNnji+Nqqp4PB4OHz5Mp06dalU2cXGRYKCJChr8OaVHv6HUDaX7Z2M8MJvwDv/P3n3HV1ne/x9/3feZ2ZuEsPcQVBBkidWK4qpaV1GUolRrv9rWapffttaftbW1tf2qtVoHgnsPxImioshQFNkjEDZJyDxJTs6+f3+c5EAkjMBJQpL38/HIw5x7XPd1YnK4P/d1XZ/PdExNGRIRkU7GMIwjmqrTVmpra5k8eTKTJ0/mmWeeIScnh23btjF58mQCgcBht1NTU8OPf/xjfvazn+23r2fPnvHsshzD2s9vvsSVw5WGK6kn/tptQHTKUO3GWaSMeUQjBCIiIsewdevWUVZWxl//+ld69OgBwJdfftnksYsXL47d2FdUVLBhw4bYE/+RI0eyZs0a+vfv3zodl2OS1gx0VpEgacFtJNkgpT4krAlBZPH1bdsvEREROaiePXvidDp54IEH2Lx5M3PmzOFPf/pTk8feeeedfPjhh6xatYrp06eTnZ3NRRddBMBvfvMbPv/8c2666SaWL1/Oxo0beeONN7jpppta8d1IW1MwcAyq9gV5d1URvmAYgGA4wtWPL2HqY4sJhCLxuYjpwN7/WtIckNJ/Gg4jmnLUWzBLC4pFRESOYTk5OcyaNYuXXnqJoUOH8te//pV//OMfTR7717/+lZ///OecdNJJFBUV8eabb+J0OgE4/vjj+eSTT9iwYQMTJ05kxIgR3H777eTn57fm25E2ZlhHmuC2A/B4PKSlpVFVVUVqampbdweAoiofUx5ZxJYyL2cfl8cFJ+bzP898Fdt/10XDuGpsr/hdMBIE04F3wVQqC57FbkCXIdfC2Mfjdw0REZFjiM/no7CwkD59+uB2u9u6OyJH5GC/x825x9XIwDHm0U83s6XMC8C7q4saBQIAD8zfGBsxiIv69QEJE2ZiACELQgUzNTogIiIi0gkoGDiGhCMWb36zC4ATeqQ32nfpSd3pkuKi2OPnqUVb435tw+bC2esSAPw9r9AiYhEREZFOQNmEjiFLCssoqfaT6rbz4o/H8sn6PSzbVsH/nNaftAQHL365nV+/vIKHP9nE1eN64T7C3MQH4jz5fvyDf0XAnUFSXFsWERERkWORRgaOIQ2jAucM64rLbuOs4/K47ZwhpCVEn9J/f0Q38tPclNUG+O8nm/EFw3h8QZZtrYjL9Z3OFFj1FwJzBsHiGXFpU0RERESOXQoGjgElHh/3vr+e55ZuB+CCE5texe+wmVwzoQ8A//pgA4P/8C7H3/E+lzz0OQsLSo+6H067E2PnHMJaNyAiIp1AJ86hIh1AvH5/FQy0sbpAmIseXMgD8wsA6JLiYmzfrAMe/8PxvZk+vjdOW+P/dR+sLT7qvhg2F46eFwMQ6DFF6wZERKRDstmi02ybU61X5Fjj9UYTzjgcR3e/pjUDbez9NUXsqvLhtJlcd2ofzhqah800Dni8025yxwXHcfv5Q5nzzS5ufmE5AEs2l8elP86T7ycQDhDY8jyJrkSlGBURkQ7HbreTmJjInj17cDgcmKaejUr7YVkWXq+XkpIS0tPTY8HtkVIw0IYsy+LFL6NTg35yWj9+cebAwz7XNA0uGtGN8f2zOPnPH7K2yEOJx0ey247bbsM8SEBxMC6Hm5qdc/EZENk0E/PkhzVCICIiHYphGHTt2pXCwkK2bo1/hj6R1pCenk5eXt5Rt6NgoA29+OV2FhaUYRpwycjuR9RGlxQ3w7ulsXJnFWf93wICoQgn9crgqRljjqg9pzsTR8/vE9z2GrVhSFl6g0YHRESkw3E6nQwYMEBThaRdcjgcRz0i0EDBQBtZtbOKP7yxGoBbzxpEz6zEI27rXz84gUsfXkSlN7rg99ONpVR6A6QnOpvdlmEYJI39D5XbXsMfgZTNM0GjAyIi0gGZpqkKxNLpaZJcG/CHwtz47FcEQhG+O7gLP/lOv6Nqr3+XFO6bMqLRtqNJN+p0p0O3CwhGwOpzjQIBERERkQ5KwUAbcNlt/PbswQzOS+Gfl59wxPP79/WdgTk8d91YBuYmA/DlUQQDNpsL4/g7sCYvJjz6oaPum4iIiIgcmxQMtJFzhnfl7Z9NPKKpPAcyrl8WPzqlLwCLNpUdcTuGYWC3u8GwE/RXxat7IiIiInKMUTDQhuIxIvBt3xmUg2nA8u2VFJbWHnE7DkcirLyT0Cu5qkYsIiIi0kEpGOhgclPdTByQA8DLy7YfcTsOmx12ziEYATarGrGIiIhIR6RgoAO6bFQ0Tekry3YSjhxZqWqHKx26XUDAAvpeq0XEIiIiIh2QgoEOaNKQXNISHBR5fCwsKD2iNhyORIzj/0hk0meERv0nzj0UERERkWOBgoEOyO2wceGJ+QC8tGzHEbVhGAaO1X+GeacQ/FxrBkREREQ6IgUDHdRlJ/UA4L3VRVR5j2C+fySIY+erAAQKn9GaAREREZEOSMFABzWsWyqDclMIhCK8s2p38xswHTj6XAlAqPslWjMgIiIi0gEpGOigDMPgjCFdAFix88hqBTjGPQqTFxM87g/x7JqIiIiIHCMUDHRgA3NTACgorjmi8+12N4bpIBL2EQ4H4tk1ERERETkGKBjowAbkJgOwoaQay2p+ilHDMLGvvgveG6tFxCIiIiIdkIKBDqxfTjKmAZXeIKU1R/BkPxLEvvM1AEKFT2sRsYiIiEgHo2CgA3M7bPTMTARgQ3F18xswHdh7TwEg1OMyLSIWERER6WAUDHRwJ/RIB+CxTzcf0VQh+8n/gcmLCQ2/M849ExEREZG2pmCgg/vZGQNw2Aw+Wr+HJYXlzT7f4UgAw04ocAQjCyIiIiJyTFMw0MH1y0nm0pO6A/DiF9s799iAAAEAAElEQVSbfb7N5sJYdSeRd08m/Pn0OPdORERERNqSgoFO4LJR0WrEb6/ajcfXvEXAhhXCvnMOAL6C2VpELCIiItKBKBjoBEb0SKd/l2R8wQhzv2lmNWLTQWK/KwCoCYO15McKCEREREQ6CAUDnYBhGFw+qn6q0JfNnyqUOGEWNgPCFuxe+wTlTzphseoOiIiIiLR3CgY6ie+P6I7NNFi+vZKCkuZVJDZsThL7Tom99kXAt3GmRghERERE2jkFA51EToqLUwdkAzBn+c5mn584/jGMfV7XhIGlN8SncyIiIiLSJhQMdCIXjegGwJOLt7J4c1mzzrU5ksgeNI2s+rpjgQhENml0QERERKQ9UzDQiUw+Lo/j8lOp9Ab54cylzQ4IHBNm45oawN7j+wAEelypqsQiIiIi7ZiCgU7E7bDx8g3jmTQkF38owp/mrml+I6YD5+h/QbfzCRQ+q4XEIiIiIu2YgoFOJsFp455Lj8duGqze5WFjcfMrC7scCbBzLv4IsFlThURERETaKwUDnVBmkpPTBuUA8NKyHc0+3+nOgG4XELQg0nu6pgqJiIiItFMKBjqpKaN7AvD04q2U1fibda7N5sBhswHgD2tUQERERKS9UjDQSZ0xpAvDuqXiDYS57OFFvP71TizLOryTI0GcO18DoHbTM1jhQAv2VERERERaioKBTsowDO68cBhOm8nm0lpufmE5z39xmNWJTQfJA36IaURTjNYtvKZlOysiIiIiLULBQCc2smcGD04dSYrbDsBf31lHjT90WOfaxj5KcnSmELWbntUiYhEREZF2qNnBwIIFC/je975Hfn4+hmHw+uuvN9pvWRa33347Xbt2JSEhgUmTJrFx48ZGx5SXlzN16lRSU1NJT09nxowZ1NTUNDpmxYoVTJw4EbfbTY8ePbjnnnv268tLL73E4MGDcbvdDB8+nLfffru5b6fTO3NoLl//4Uy6pSdQVRfkq60Vh3ei6SBxwHQMIJh/AYFQ89YdiIiIiEjba3YwUFtbywknnMCDDz7Y5P577rmH+++/n4cffpglS5aQlJTE5MmT8fl8sWOmTp3K6tWrmTdvHnPnzmXBggVcf/31sf0ej4ezzjqLXr16sWzZMv7+979zxx138Mgjj8SO+fzzz7niiiuYMWMGX3/9NRdddBEXXXQRq1atau5b6vTsNpPRvTMA+Hpb5WGfZ457goSLNsLw26mt3dNCvRMRERGRlmJYh71qtImTDYPXXnuNiy66CIiOCuTn53Prrbfyy1/+EoCqqipyc3OZNWsWU6ZMYe3atQwdOpQvvviCUaNGAfDuu+9y7rnnsmPHDvLz83nooYf43e9+R1FREU6nE4Df/va3vP7666xbtw6AH/zgB9TW1jJ37txYf8aOHcuJJ57Iww8/3GR//X4/fv/eJ9gej4cePXpQVVVFamrqkf4YOoRZCwu54801nD4ohyeuOfmwzwsGvezZsxbDMMjNPR7TtLdgL0VERETkUDweD2lpaYd1jxvXNQOFhYUUFRUxadKk2La0tDTGjBnDokWLAFi0aBHp6emxQABg0qRJmKbJkiVLYseceuqpsUAAYPLkyaxfv56KiorYMftep+GYhus05e677yYtLS321aNHj6N/0x3EiJ71IwPbKw8/qxDgcCTidCZhWRZeb2lLdU9EREREWkBcg4GioiIAcnNzG23Pzc2N7SsqKqJLly6N9tvtdjIzMxsd01Qb+17jQMc07G/KbbfdRlVVVexr+/bDzJ7TCQzpmkqi00alN8jqXZ5mnZuYGC1gpqlCIiIiIu1Lp8om5HK5SE1NbfQlUU67ySn9swH4YG1xs85NSMjAMEzC4QDBYF1LdE9EREREWkBcg4G8vDwAiosb30wWFxfH9uXl5VFSUtJofygUory8vNExTbWx7zUOdEzDfmm+SUOiIy3NDQYMw8TpTAIgGKyNe79EREREpGXENRjo06cPeXl5fPjhh7FtHo+HJUuWMG7cOADGjRtHZWUly5Ytix0zf/58IpEIY8aMiR2zYMECgsG9uevnzZvHoEGDyMjIiB2z73Uajmm4jjTfd4d0wW4arNrpYe3u5k0VcjiiwUAgoGBAREREpL1odjBQU1PD8uXLWb58ORBdNLx8+XK2bduGYRjcfPPN3HXXXcyZM4eVK1cybdo08vPzYxmHhgwZwtlnn811113H0qVLWbhwITfddBNTpkwhPz8fgCuvvBKn08mMGTNYvXo1L7zwAvfddx+33HJLrB8///nPeffdd7n33ntZt24dd9xxB19++SU33XTT0f9UOqnsZBeTj4uOrJxz36d82IwRAqczGYBAoOYQR4qIiIjIsaLZwcCXX37JiBEjGDFiBAC33HILI0aM4Pbbbwfg17/+NT/96U+5/vrrGT16NDU1Nbz77ru43e5YG8888wyDBw/mjDPO4Nxzz+WUU05pVEMgLS2N999/n8LCQk466SRuvfVWbr/99ka1CMaPH8+zzz7LI488wgknnMDLL7/M66+/zrBhw474hyHww/G9Y9//d8Hmwz7P6UzCMAxCIZ9GB0RERETaiaOqM9DeNScHa2fywhfb+M0rK8lMcvLVH8487PMqK7fg9ZaRkJBJRkafFuyhiIiIiBxIm9UZkI7hghO6YRhQXhugrMZ/6BPqNaQY9fmaV6tARERERNqGggHZT4LTRveMBAA2lhz+GgCnMwmbzYFlRfB6VXNARERE5FinYECaNKBLCtC8YADA5YoORVVVbae6elfc+yUiIiIi8aNgQJo0oEs0O9CmZgYDCQmZse9ra/doupCIiIjIMUzBgDSpd3a0bsCWsuZlBnK5UunS5ThM00YkEsLnq2yB3omIiIhIPCgYkCb1ykwEYFu5t9nn2u3u2AhBMNj880VERESkdSgYkCb1zIoGAzvK6whHmj/Vx2ZzAhCJBA9xpIiIiIi0FQUD0qSuaQk4bAaBcIQij6/Z5zcEA+FwIN5dExEREZE4UTAgTbKZBt0zoqMDW5u5bgAUDIiIiIi0BwoG5IB6NqwbKGv+vH/TdAAQDmuakIiIiMixSsGAHFDfnGhGoebWGoC9IwOWFSESCcW1XyIiIiISHwoG5ICOy08DYNXOqmafaxgGpmkHNFVIRERE5FilYEAOaFi3aDXhNbs8RI4io5CCAREREZFjk4IBOaB+Ock47SbV/tAR1RtwOqPTjHy+5o8siIiIiEjLUzAgB+SwmQzJSwFg4abSZp/vdmcA4PNVYFnNH1kQERERkZalYEAO6vzj8wH47yebCYUjzTrX6UzGZnMQiYTxepsfTIiIiIhIy1IwIAc1dWxPMpOcbCv3smhzWbPONQyD5OQ8AKqrd2FZzQsmRERERKRlKRiQg0p02jltUA4ASwvLm39+Yk796ECIQKD5KUpFREREpOUoGJBDGtMnE4AlRxAMGIaByxXNSuT3e+LaLxERERE5OgoG5JBG944GA8u3V+ILhpt9vssVrVegrEIiIiIixxYFA3JIfbKTyEt1EwhFuOfd9RQ0syKxy5WKYRiEQj6CwboW6qWIiIiINJeCATkkwzA467hcAGYuLOTShz+ntMZ/2Oebpg23Ox1AWYVEREREjiEKBuSwnH1cXuz7Sm+QP81d06zzExKygGjNAQDLihAK+eLXQRERERFpNgUDclhO7pPJGYO70DXNDcAby3fx8fqSwz7f5UrBMAzC4SDhcIDKyq2UlKymvHyTUo6KiIiItBEFA3JY7DaTx6ePZtFtZzB9fG8Anl689bDPNwwTuz0BiGYVqquLZiby+Sqprt4d9/6KiIiIyKEpGJBmO3d4VwBW72peqlCnMwmAysrGQURNTRHhcCA+nRMRERGRw6ZgQJptSNcUAHZX+SivPfybeKczudHrtLSesW0+X2Xc+iciIiIih0fBgDRbittBr6xEANbuPvzRgYSETNLTe5OZ2Y/s7EEkJeXEsgwpGBARERFpfQoG5Igclx+tKrxqZ/MKiSUmZuF2p8dGBBISMgDw+6tVg0BERESklSkYkCNyYo90AJYUlh9VOzabMxYQ1NRoIbGIiIhIa1IwIEdk4oAcABZtKsMfCh9VW8nJ0RoGPl+l0oyKiIiItCIFA3JEBuel0CXFRV0wzJdbKo6qLYcjEZvNiWVZ7N79NUVFy/H7q+PUUxERERE5EAUDckQMw2BC/2wAvthydFOFAFyu1Nj3kUgYr7f0qNsUERERkYNTMCBH7PjuaQCs2tm8egNNaVg30MDvP/o2RUREROTgFAzIERvWLRoMLNtaTmmN/6jacrlS6dLlOLp2HYFp2ohEQgQCtfHopoiIiIgcgIIBOWJDukan9lR4g4y66wPeWnF02YDsdjeGYcamDCm7kIiIiEjLUjAgRyzZZY8VHwP4xYvLj3qEACAlJR/DMPD5qjQ6ICIiItKCFAzIUfn9eUO5eGQ3uqS4CIQivL3y6J/m2+1u3O7oGoK6uqNfnCwiIiIiTVMwIEflzKG5/PPyE7n+1L4AzFm+Ky7tJiZmAdFgwLKsuLQpIiIiIo0pGJC4OHd4VwC+2lZBjT901O05nSnYbA4ikRC1tcVH3Z6IiIiI7E/BgMRFfnoC3dITiFjwzfbKo27PMAxSUvIB8Hh2Ula2geLilRQXryQY9B51+yIiIiKiYEDi6KRe0Xn+y7YeXUXiBgkJWbH6A35/NeFwgHA4QHW1sgyJiIiIxIOCAYmbkT3TgfgFA4ZhkJHRF5vN2Wi7z1dJOByIyzVEREREOjMFAxI3Y/pGF/0u2lxGtS8Yt3bT0noAkJCQicuVAkBt7Z64tS8iIiLSWSkYkLgZnJdCv5wkAqHIURcg25fbnU5OzlDS03uRlNQFAK+3VFmGRERERI6SggGJG8MwuPDEbgDcPmc1CwtK49a2w5FQX504LZZlyO/3xK19ERERkc5IwYDE1fQJvTmhexqBUIQ/zV0T96f3hmHECpL5fJVxbVtERESks1EwIHGV6nYw+9qTSXDYWFdUzfx1JXG/htudDkSDAcuKxL19ERERkc5CwYDEXXqik6ljegJw60vfsLuqLq7tO53JsalCu3d/jcezM67ti4iIiHQWCgakRfxy8iCOy0+l0hvklWU74tq2YRikpnaPva6pKSIcjl/2IhEREZHOQsGAtAi3w8bVY3sB8P6a4ri3n5CQSVpaz9jrmpqiuF9DREREpKNTMCAt5owhuRgGrNhRxRvL4z+VJykph4yMvgDU1pao9oCIiIhIMykYkBaTk+LinGF5APziheUUlFTH/RoJCRmkpOQD0YBARERERA6fggFpUfdNGcGE/llELPjPx5ta5BpJSV0wDJNQyIffH/+AQ0RERKSjUjAgLcphM/nN2YMBeGP5LraVeeN+DdO0xdKNBgIKBkREREQOl4IBaXHHd09n4oBswhGLhz5pmdEBpzMZgGAw/sGGiIiISEelYEBaxU2n9wfghS+2sWpnVdzbdzgSAQioKrGIiIjIYVMwIK1iTN8szj++KxELfvrc15TXBuLavsORgLHqTiLvjib8+fS4ti0iIiLSUSkYkFbzx+8dR7f0BApLa7lr7pq4tm1YYRy75gBQWzAbIipCJiIiInIoCgak1eSkuPj3lSMAeOObXeyoiOP8ftNBcr+pANSGILxoRvzaFhEREemgFAxIqxrRM4NT+kcXEz+3dFtc23ZPeAKnCRbgKXgKFl0T1/ZFREREOhoFA9LqLhvVHYB3VxVhWVb8GjYdpPW/CoC6MIQ3z9J0IREREZGDUDAgre70wV1w2Aw27amlz21v86PZXxIKR+LStuOUp3D2/D4A3m6Xg+mIS7siIiIiHZGCAWl1qW4HZwzOjb3+YG0xX22rjFv7ieMfhW7n4y18EUuZhUREREQOSMGAtIl7Ljue564by6heGQB8sqEkbm0nuJKx7ZpL2IK6TbO1dkBERETkAOIeDITDYf7whz/Qp08fEhIS6NevH3/6058azQ23LIvbb7+drl27kpCQwKRJk9i4cWOjdsrLy5k6dSqpqamkp6czY8YMampqGh2zYsUKJk6ciNvtpkePHtxzzz3xfjvSQlLdDsb1y+KKk3sC8MmGPXFr27C5SO7zAyCaWYjCWVo7ICIiItKEuAcDf/vb33jooYf497//zdq1a/nb3/7GPffcwwMPPBA75p577uH+++/n4YcfZsmSJSQlJTF58mR8Pl/smKlTp7J69WrmzZvH3LlzWbBgAddff31sv8fj4ayzzqJXr14sW7aMv//979xxxx088sgj8X5L0oJOHZgDwKqdHvZU++PWbsKpT2N0+x5BC/b4IfT5tXFrW0RERKSjMKy4pnOB888/n9zcXB5//PHYtksuuYSEhASefvppLMsiPz+fW2+9lV/+8pcAVFVVkZuby6xZs5gyZQpr165l6NChfPHFF4waNQqAd999l3PPPZcdO3aQn5/PQw89xO9+9zuKiopwOp0A/Pa3v+X1119n3bp1TfbN7/fj9++94fR4PPTo0YOqqipSU1Pj+WOQZjj/gU9ZtdPDPy8/gYtHdo9bu+Wla/HNGQqAzYCcgdMwJ8yO7owEtbhYREREOiSPx0NaWtph3ePGfWRg/PjxfPjhh2zYsAGAb775hs8++4xzzjkHgMLCQoqKipg0aVLsnLS0NMaMGcOiRYsAWLRoEenp6bFAAGDSpEmYpsmSJUtix5x66qmxQABg8uTJrF+/noqKiib7dvfdd5OWlhb76tGjR3zfvByR79SPDsxfF103UFbj56ttFUeddjQpKRej/vuwBbWbniTo91Dy/kVUPuXU4mIRERHp9OzxbvC3v/0tHo+HwYMHY7PZCIfD/PnPf2bq1Gh12KKiIgByc3MbnZebmxvbV1RURJcuXRp31G4nMzOz0TF9+vTZr42GfRkZGfv17bbbbuOWW26JvW4YGZC29d3BuTz40SbmrtjNjoqFrN5VRTBscd7xXbl/yghspnHoRprgSsik69Br8W2cSXkQqkNQ++pxROp2EALsBbNJNgwY90R835CIiIhIOxH3kYEXX3yRZ555hmeffZavvvqK2bNn849//IPZs2fH+1LN5nK5SE1NbfQlbe+kXhlcOyEa2C3fXkkwHB0ReGvF7qPPMjT2cVxTanDUxxORuh2xXf4IWlwsIiIinVrcRwZ+9atf8dvf/pYpU6YAMHz4cLZu3crdd9/ND3/4Q/Ly8gAoLi6ma9eusfOKi4s58cQTAcjLy6OkpPFNYCgUory8PHZ+Xl4excXFjY5peN1wjLQffzh/CN8ZlMOGomrG9cvi6cVbef6L7Xy0bg/fHZx76AYOwnAkkTVwGt5NTxIB7AZUOroTqtsBfa/V2gERERHptOI+MuD1ejHNxs3abDYikWiF2T59+pCXl8eHH34Y2+/xeFiyZAnjxo0DYNy4cVRWVrJs2bLYMfPnzycSiTBmzJjYMQsWLCAY3PtUd968eQwaNKjJKUJybDMMg+8MzOG6U/syrFsaZw6NBgAfrS856rUDAOaE2SQPmE6qHdz9psGprxM+azGRk6PZpywrPhWQRURERNqTuAcD3/ve9/jzn//MW2+9xZYtW3jttdf45z//yfe//30getN38803c9dddzFnzhxWrlzJtGnTyM/P56KLLgJgyJAhnH322Vx33XUsXbqUhQsXctNNNzFlyhTy8/MBuPLKK3E6ncyYMYPVq1fzwgsvcN999zVaEyDt17h+WbgdJjsq6vh0Y2mcGn0CpgQwx8/GNKODYuGwn3A4QEnJKoqLVxII1ByiEREREZGOI+6pRaurq/nDH/7Aa6+9RklJCfn5+VxxxRXcfvvtscw/lmXxxz/+kUceeYTKykpOOeUU/vOf/zBw4MBYO+Xl5dx00028+eabmKbJJZdcwv33309ycnLsmBUrVnDjjTfyxRdfkJ2dzU9/+lN+85vfHHZfm5N2SVrfnW+uYebCQnpnJXLWcXl8uLaYi07sxv+c3v+IFxU3KP3wUgJbXyGj/1T8x/8ZrzcacJimnZycodhsmjokIiIi7VNz7nHjHgy0JwoGjm2lNX7O+tcCymsDjbb/+Dt9ue2cIUfecCRI1VNOasPgNsF/5hIswxbbnZiYTXp6ryNvX0RERKQNtWmdAZF4yU528eZPT+GCE/JJS3DgdkR/XR9ZsJlVO6uOvGHTgavvVQD4up6PhYXTmUxW1gAA/P4qLCtCJBI66vcgIiIicizTyIBGBtqVG5/5irdW7uaKk3ty98XDj7gdy7IonncRkR1zAMjoPxX3xCcpKvoGy4pgmnYsK0J29iAcjsR4dV9ERESkxWlkQDqsq8ZGp++8+c0uquqOvD6AYYVIKZqD3YBkO7i3P4NhhXG5UgCIREJYVgSPZ8chWhIRERFpvxQMSLsypk8mfbOTqPGHOP0fH/Pdez/m4U82Nb8h00HSwGvp4oJUOxj9ovUGkpIaV772+6sJBr1x6r2IiIjIsUXThDRNqN1ZtbOKy/+7CG8gHNu27PeTyEp2Nb+xhurD+xQe8/mq8PkqCIeD+P0eLSgWERGRdkXThKRDG9YtjTk3ncIVJ/eMbXvhy+1H1pjp2K8CsdudRnp6b1JSohWy6+rKiUTCTZ0tIiIi0q4pGJB2qX+XZO6+eHhsEfEHa4rjfg2nMxmHIwHLisTqEIiIiIh0JAoGpF07pX82ACt2VOENxD8VaMMagpqa3Xi9ZXTiWXUiIiLSASkYkHatR2Yi3dITCEUslm2tiHv7CQmZOByJRCJhKiu3UFm5Je7XEBEREWkrCgak3RvTJxOA299Yzf0fbsQXjN/8fsMwyczsT0JCBhBdP+DzHUXBMxEREZFjiIIBafcuOak7AIWltfxz3gbu+3BjXNu32RxkZPQlKSkHAJ+vMq7ti4iIiLQVBQPS7o3vl8WoXhmx148s2ExRlS/u13G70wHw+z1xb1tERESkLSgYkHbPMAz+M3Uk9005keO7pxGOWLy3uiju13E6kzEMk3A4QCBQG/f2RURERFqbggHpELqkurnwxG5ccEI+AO+s2h33axiGGVs7UFm5hVAo/qMPIiIiIq1JwYB0KJOPywNgaWE5ZTX+uLefktINwzAJhXyUlcV3bYKIiIhIa1MwIB1Kj8xEhnVLJWLBB2vjX4jMZnOQlTUQgHA4gGVF4n4NERERkdaiYEA6nLPrRwceWbCZVTvjnwbU6UzCMKJ/OuFwMO7ti4iIiLQWBQPS4Vx4YjfcDpNNe2o5/4HPeHTB5rhfw2ZzAtHRAREREZH2SsGAdDg9MhN59ScTGNYtFYD752+k2hffJ/g2mwOASEQjAyIiItJ+KRiQDmlofipzbjyFAV2SqfaFeG7ptri2r5EBERER6QgUDEiHZZoGM07pA8CzS7YRiVgArCvyUFV3dE/0TTM6MqA1AyIiItKeKRiQDu17J+ST4rKzpczLa1/v5O2Vuzn7/z7ljHs/ZvWuI19cHBsZCKr4mIiIiLRfCgakQ0ty2ZkxMTo68MuXv+F/nvkKgNKaAA9+VHDE7dpsDlh5J8E3h2B9Pj0eXRURERFpdQoGpMP76XcHcObQXCyr8fbVuzxH3KbT7sa2aw5hC2oLZsOia46ylyIiIiKtT8GAdHg20+C/V53En78/jN+cPZj3f3EqAFvLvNT4Q0fUpml3k9J3CgC1YbA2zwJlFhIREZF2xt7WHRBpDaZpMHVMr9jrvFQ3RR4f63Z7GNU784jaTDj1WaqLFhKu3Y7X3Yek+kXFIiIiIu2FRgakUxrSNQWANbuPfKqQYYVI8m8HoKqqEN8nV8SlbyIiIiKtRcGAdErDu6cDsGxrxZE3YjpIHjCdRFv0pWfz840XE2vakIiIiBzjFAxIpzS2T3Rq0JLN5VjfXlncHOOeIK3/1dgMCFng2zQbIkF8n17NniedBD6bFqcei4iIiMSfggHplEb0zMBpMyny+Hh26Tb+PX8j760uOqK2jAlPktD7MgDq8i/GsizKNz5NMALlG5/CUpViEREROUYpGJBOKcFp46ReGQD87rVV/OP9Dfz4qWU8uWjLkbV3yizodj7+ra/iWXAVJHYHIGKB7/Nr49RrERERkfhSMCCd1p8uGsag3BScdpO8VDcA939YQCTS/GlDDpsD1+65WEBt4Uvg3YFRv8+3+RmtHxAREZFjkoIB6bT6d0nmnZ9PZMUfz2LBr08nyWmjtMZ/ZMXITAcZA6Zhr48A7AZkOaPf+yNgLflx/DouIiIiEicKBqRTM00Dt8OG025yyoBsAOavKzmytibMJmfQD8l0RAMBZ99p2Iz6qUIFT2h0QERERI45CgZE6p0xJBeAN77ZecQZhozxs3BPDWC7IgDjZ5PQ5wcAeMPA0huiAYGCAhERETlGKBgQqXfu8K4kOm1s3lPLOfd9yk+eXobHdwQ37qYj+gUkTXgciE4Vqlw/E8/TTsLPOWHxjHh2XUREROSIKBgQqZfssnPhid0AWFdUzTurinjkk81H1abNkURKvylAdHSgJgTVIWDzTI0QiIiISJtTMCCyjz9+byi/mDSQjMTok/3HPtvM0sLyo2ozZeKTpDsgob5ScSAC9L02NnogIiIi0lYUDIjsw+2w8fNJA/jqD2fynYE5+IIRfvzUl9T4Q0feqOkgccC1pNmBbucTOmsxkZP/G7c+i4iIiBwpBQMiTTAMg/9efRJ9s5Oo8AaPuBhZzNjHMa8IYB/xVzDsFBV9Q3X1bsKqTiwiIiJtSMGAyAG4HTb+5/T+ANzz7nqufnwJBSXVR96g6cDtTo+9rK7exZ49awmHtXZARERE2oaCAZGDuHhENy44IR+ATzeW8ofXVx9Veykp+eTkDCUtrSemaScSCVFdvTMeXRURERFpNgUDIgdhmgb/+sGJ3HPJ8QAs2lzGks1lR9yeYRg4HAkkJeWQmdkPgLq6CiwrEpf+ioiIiDSHggGRQ7CZBpeP7sEVJ/cA4Nml2+LSrtOZjM3mxLIieL1HHmCIiIiIHCkFAyKHacrongC8s6qIKm985vk3rCGoqtqG11salzZFREREDpeCAZHDdHz3NPrlJBEIRfh8U3xu3JOScmLfKxgQERGR1qZgQOQwGYbB+H7ZAHyxpSIubdrtbnJzo+sRAoFaQiE/VVXbqakpwrKs/U+IBFW5WEREROJGwYBIM4zqnQHAxxtKmr5ZPwI2mwOnMxmAkpJV1NaW4PHspKpqa+yYUMhH8fsXUjLbif9ZJyyeEZdri4iISOemYECkGUb3zgRg855aps1cSiAUnyxAaWk9MIzGf451deV4vaXU1BRT+fEVhHfMIWRBZRCsTTOxwgF83j2EAkdR+0BEREQ6NQUDIs2Qn57Aecd3BaJ1B37/+sq4BAQORyI5OUNITe1GZmZ/nM4kLMuisnIrnqotBLa9Hjs2bEGtqzdlH19J+fNdKH8mVSMFIiIickQUDIg004NXjuShqSMBePHLHfxxzqq4tGu3u0lOzsPtTiM5OQ+ITiHCsGN0v5BMB6TZo8d6PFsIbH0FgJAFkU0ztZZAREREmk3BgMgROGd4V+6/YgQAL3yxnYKSmri273an07XrCHJzj4/+d9LLuKcGSBownQTb/scHe10NpiOufRAREZGOT8GAyBG64IR8zhyaS8SCRxZsinv7DWsIDMPENO3Rm/1xT5De/2qcJpgGOE3gzM+oG3YnFRWb2bNnLXV15ZSUrKa6enfc+yQiIiIdi4IBkaNww3f6AvDG8l1U1AZa5ZrGhCfJHjSdXCe4+kwBmxuvt4y6ugqCQS8VFYWEQj6qq3fh81W2Sp9ERESkfVIwIHIURvbMYGjXVPyhCG+tbMUn8eOewLgiQMKEJ7DZHBiGgcuVEl1jsA+PZ2fcUqCKiIhIx6NgQOQoGIbBOcOii30/3bgntn1XZR33fbCRqroWXNRrOmJFy7p2HUlW1kByco7D7U4nOTkX07THRghEREREmqJgQOQoTRyYA8DH6/fgD4UBuPHZr/jXBxv4/evxyTR0uEzTRmZmP1JTu5Oa2g2Ampoiqqq2t2o/REREpH2wt3UHRNq74d3SSE90UOkNMuj37zba9+Y3u/j15EH0yExs9X4lJmZjWRZVVduorS3B7U7H5Upp9X6IiIjIsUsjAyJHyWYa/PXi40lxNx1bt+pagm9JSsohKSk6cqHpQiIiIvJtCgZE4uDsYXks/d9JPDR1JH2zk7j0pO785uzBAMxfW9KmfUtOzsMwTAKBGmpr27YvIiIicmzRNCGROElw2jhneFfOGd4VgO3lXv727jqWbaugrMZPVrKrTfplszlJTe1OVdU2qqt3k5iYg2EYbdIXERERObZoZECkhfTITOT47mmEIxaXPryIZVsr2qwviYnZ2GwOIpEQpaVrqararpSjIiIiomBApCX99pzoVKHC0loueehzbnlxecumGz0AwzBITMwGIBiso7a2hLq68lbvh4iIiBxbFAyItKDx/bK5++LhnDG4C4YBr361k1++9E2b9CU5OY/09F6x135/VZv0Q0RERI4dCgZEWtgVJ/fk8emjef66sdhNg3lripk2cykeX+uOEBiGSWJiNtnZgwDw+SoJhwOt2gcRERE5trRIMLBz506uuuoqsrKySEhIYPjw4Xz55Zex/ZZlcfvtt9O1a1cSEhKYNGkSGzdubNRGeXk5U6dOJTU1lfT0dGbMmEFNTU2jY1asWMHEiRNxu9306NGDe+65pyXejkhcjOmbxS1nDQRgwYY9PPLJ5jbph8ORhM3mxLIsyso2HvoEERER6bDiHgxUVFQwYcIEHA4H77zzDmvWrOHee+8lIyMjdsw999zD/fffz8MPP8ySJUtISkpi8uTJ+Hy+2DFTp05l9erVzJs3j7lz57JgwQKuv/762H6Px8NZZ51Fr169WLZsGX//+9+54447eOSRR+L9lkTi5n9O68/fLhkOwBMLC6mobf0n84ZhkJU1EMMwCYV8VFfvwrIird4PERERaXuGFeeUIr/97W9ZuHAhn376aZP7LcsiPz+fW2+9lV/+8pcAVFVVkZuby6xZs5gyZQpr165l6NChfPHFF4waNQqAd999l3PPPZcdO3aQn5/PQw89xO9+9zuKiopwOp2xa7/++uusW7euyWv7/X78fn/stcfjoUePHlRVVZGamhrPH4PIAVmWxXn3f8aa3R5uPL0fv5o8uE36UVm5Ba+3DAC73UVm5gDs9rZJfyoiIiLx4/F4SEtLO6x73LiPDMyZM4dRo0Zx2WWX0aVLF0aMGMGjjz4a219YWEhRURGTJk2KbUtLS2PMmDEsWrQIgEWLFpGenh4LBAAmTZqEaZosWbIkdsypp54aCwQAJk+ezPr166moaDqF4913301aWlrsq0ePHnF97yKHwzAMfj5pAABPLNzC7qq6NunHvvUGQiE/JSWrVKVYRESkk4l7MLB582YeeughBgwYwHvvvcdPfvITfvaznzF79mwAioqKAMjNzW10Xm5ubmxfUVERXbp0abTfbreTmZnZ6Jim2tj3Gt922223UVVVFfvavn37Ub5bkSNz1tBcTuqVgTcQ5rZXVxIKt/40HacziS5dhpGTMxTDiH4UVFfvprZ2T6v3RURERNpG3IOBSCTCyJEj+ctf/sKIESO4/vrrue6663j44Yfjfalmc7lcpKamNvoSaQuGYfCnC4fhtJl8vH4P97y3vk36YbM5cTgSyMjos09AoNGBWn+orbsgIiLSKuIeDHTt2pWhQ4c22jZkyBC2bdsGQF5eHgDFxcWNjikuLo7ty8vLo6SkpNH+UChEeXl5o2OaamPfa4gcy4bmp/J/U04E4PHPClm0qazN+uJ2p5OXdyKGYRKJhAiFfIc+qYO674ONDL/jPRYWlLZ1V0RERFpc3IOBCRMmsH5946ecGzZsoFevaLGjPn36kJeXx4cffhjb7/F4WLJkCePGjQNg3LhxVFZWsmzZstgx8+fPJxKJMGbMmNgxCxYsIBjcm6t93rx5DBo0qFHmIpFj2bnDuzJpSC7hiMXUxxbzyYY9/PP99Zx3/6c8t3Rbq/bFMAwcjkQAAr7KVr32seRfH2wgYsH9HyrtqoiIdHxxDwZ+8YtfsHjxYv7yl79QUFDAs88+yyOPPMKNN94IRG84br75Zu666y7mzJnDypUrmTZtGvn5+Vx00UVAdCTh7LPP5rrrrmPp0qUsXLiQm266iSlTppCfnw/AlVdeidPpZMaMGaxevZoXXniB++67j1tuuSXeb0mkRf390uMZ3y+LiAU/nLmU++cXsHqXh//7YANxTvZ1SE5nEqy8k+ArXWHxjFa99rHAHwrHvu+ekdiGPREREWkdcQ8GRo8ezWuvvcZzzz3HsGHD+NOf/sT//d//MXXq1Ngxv/71r/npT3/K9ddfz+jRo6mpqeHdd9/F7XbHjnnmmWcYPHgwZ5xxBueeey6nnHJKoxoCaWlpvP/++xQWFnLSSSdx6623cvvttzeqRSDSHmQkOXngihEkOm2Nthd7/PS57W1O/8fHbC/3tkpfnHYX7JxDXQRCBTMh0rpVktva2t3Vse+zU5wHOVJERKRjiHudgfakOTlYRVrapxv38OWWCs47vit/mruGTzfunbN+wQn53H/FiBbvg2VZlH14KYFtr5Jgg4xB18LYx1v8useKpxdv5fevrwJg+vje3HHBcW3cIxERkeZr0zoDInJkJg7I4RdnDmRgbgpTx/TCNOCEHukAzPlmF9vKvNQcIsvN0cb2hmGQNnEmAHVh8G6cSdhfeVRttieV3r0VoesC4YMcKSIi0jEoGBA5Bp09LI81d57NGzdOYEL/LABO/ftHDPvje/z0ua8JhBrXJfhySzmn/G0+J931Absqj66ImcOVhj2pJwCVQdjzbAaRRdccVZvthS+49+daF1QwICIiHZ+CAZFjlNsRXUNw9rCujba/+c0u7p23nqWF5fzqpW947esd/P71VeyoqKO8NsDLy3Yc3YUjQVID23DUfzpELAgUzNpv/UAwWIdltX6xtJa07wJiBQMiItIZKBgQOcadfVweiU4bKS4708ZFU/T+95PNXP7fRby0bAe/eOEb1hXtXfj6wPyN/Hv+Rtbs8hzZBU0H7gHXkuOExPo1zYHul4HpAMDv91Bevok9e9ZQWbnlaN7aMWffkQGfggEREekE7G3dARE5uJwUF+/dfCouh0mXFDd7qv28s6pov+NO6Z/Nmt0eymsD/OP9DfzfBxu5ZkJvfjV5ME57M+P+sY/DyQ/j9JbhXXgd/i0v4f/0KqqH/IFAoCZ2WF1dBQkJVdTVlWGzuUhJ6RqrZNweNRoZ0JoBERHpBBQMiLQDPTL35rz/+2UnUOMPsa3cy10XDePPb60lNcHB/547hASnjeeXbuOLLeV8ta2SRz8tJC3BwU3fHdD8i5oOXK5UjJ1zCQJlG5+B2ko4/v/hdqfh81UBUF5eEDslEKghO3vQUb7btqM1AyIi0tkoGBBpZ5Jddp6aMYZIxMI0Dd69OafR/tvOHYJlWTz0ySbueXc9D3+yme+dkE+vrKRmX8vmSCRzwJVUFDxLxALb7rfISErHOfFpPJ6d1NRERygMwwCiwUB0tKB9VgHfd2qQpgmJiEhn0H7H80U6OdM0DrjPMAx+dEpfclNd1PhDnH//Z2wrO7LCZa6Jz5AzYCqpdsh2gnP7MxAJkpLSlcTEbByOBLKzh5CcHF3oXF29E8uysKwI1dW78PurD3GFY4c/tO+agY61OFpERKQpCgZEOiin3eTxH46mT3YS1f4QP3/ha8prA4c+sQm2U54mecB0bAbQ91owHRiGSXp6L3JyhuJwJJCcnIvN5iAU8lNTU8SePWuort6Nx7M9vm+sBe07GqBpQiIi0hkoGBDpwIZ1S+OJ6aNJdNr4elslv31lxZE3Nu4JmBI4YEViwzBJSckHoLp6F6GQH4imIG0v9h0Z0AJiERHpDBQMiHRwvbOT+M/UkQB8urGUYPgopr/Upxc9kMTEbBITs/fb3l7qEXx7ZOBoKzqLiIgc6xQMiHQCpw7IIS3BQV0wzKqdVS16rbS0nvXrCbJi28Lh4EHOOHZ8u7KzP9Q+ghgREZEjpWBApBMwTYPRvTMB+GJLeYteyzAMUlLySU/vjd3uAiASaR/BwLczCGmqkIiIdHQKBkQ6ifH9ok/q31i+q9Wmv5j104ray8iA71sjAVpELCIiHZ2CAZFO4vsjuuGym6ze5eFf8zZQWuNv8WvabNFgoL2MDPi/dfOvWgMiItLRKRgQ6SQykpxcOaYnAPfPL+C0v3/Mu6uKWvSaDSMDQV85tIOAQCMDIiLS2SgYEOlEfnfuEP5x2Qkcl59KjT/Ez57/mi2ltS12PZvNAQu+j/eNIVQ85SS0cNoxGxSEwhHCkej0qbSEaBCjNQMiItLRKRgQ6UTsNpNLT+rOGzdOYHy/LAKhCP/vzdUttobAbXfiqIsWHasLw571T1H3jBMWzwCOrZSj+44KNAQD384uJCIi0tEoGBDphOw2kz9dNAyHzeCj9XtabLqQ3Z1JTtYAcpzgNMECKoNgbZpJRdl6iotXxIqTtbV91wukuO3RbUdTk0FERKQdUDAg0kn1y0nmuol9Abj1pW9YsaOyZS50wQYcU2rJGvhDbEY0IPB2n0Kdr5JIJIzHs6NlrttMDSMDTruJyx79aNTIgIiIdHQKBkQ6sZsnDeSU/tl4A2Eu+PdCLnv4c/yhFpgnb0/EGD+LxIu3QLfzqdr0PLw3Flbeid/vOSamCzVkDnLbTZz1wYCKjomISEenYECkE3PaTR6++iRO6JEOwBdbKli0qazFrpeYmI25a+7eDTvnYEUCBAItt4j5cPmD0Rt/l8OG024DNDIgIiIdn4IBkU4u2WXntZ+MZ0yfaIXij9aVtNi1bI4kcgdfs3dDYg8w7AQC1S12zcPlqx8RcTtMnDZNExIRkc5BwYCIYJoGP6pfP/DB2hIikZarUGyM+S/pDrAbkOzfDlaIQKCmxa53uGIjA3bbPmsGlFpUREQ6NgUDIgLAKf2zSXbZ2VlZx+LClpsqhOkgccC1dHFB4oAfgmHH768mHA603DUPQ6ORgYZgQNmERESkg1MwICIAJDhtfO+EfABe/GJ7y15s7OMwJYB9/CxcrhQAamv3tOw1D6EhtajLbtM0IRER6TQUDIhIzJTRPQB4Z1URVXUtXCnYjBb2SkzMAaCurrxlr3cIDZmD3A4Tl0PBgIiIdA4KBkQk5vjuaQzOS8EfinDZw5+zsbjlF/a63WkYhkk43LZZhfamFt07MqCiYyIi0tEpGBCRGMMwuHpcLwA2FNdw/gOfsWaXp4WvaeJ2pwNQU/OtSsiRYPSrFTSMDLj2XTOgkQEREengFAyISCNXntyTF388jpE90/GHItzx5mosq+WyCwEkJ+dhGAY+XyXV1bsBCH0+naqnnHiedmIturZFrw/fGhlQMCAiIp2EggERacQwDE7uk8kDV47E7TBZWljOO6uKDn3iUXA4EkhJiS5erq7eRdBfhWfDbGrDUBOCQMETLT5CsLfomEYGRESk81AwICJN6paewI9P7QfAX95ey0Mfb2Lo7e9yy4vL8QZCcb9ecnIeCQkZAOz5eBq+fe7DAz2nxBYct5SG1KI2Avi90eBHqUVFRKSjs7d1B0Tk2HXDd/rx3NJt7Kio42/vrgPg1a92UlYTYMYpfRjdO5MEpy1u10tIyKLOuwd2ztm78czPCCZkxu0aB+KrHxmwwjXYzeh70siAiIh0dBoZEJEDSnDa+Ol3+zfaZhrwyYY9TJu5lF++/E1cr+dypZKc0g26XbB348IrCLw5FBbPiOu1vs1fPzLgskFDfKNgQEREOjqNDIjIQV01thc202RpYRk//k4/ymsD3PPuOr7ZUcW8NcXU+EMku+LzUWIYBqmp3Uk47UmqnksnxQZl3u1EgPCmmdhOfrjFpgs1jAy47AYOmwFAXbB1MhmJiIi0FY0MiMhBGYbBlWN68n9TRjCkayoT+mfz+o0T6J2VSCAU4ZP18a8c7HClkT34Wlw2sCf1BCDYcyq1tXuIRMJxvx7sTS3qtBs464OBQKhlriUiInKsUDAgIs1mGAZnD+sKwI3PfsUry3ZQWBrngmFjH4cpAWyTPoDJiyn3VlP1Uje8n14V3+vUa0gtGh0ZiG7TNCEREenoFAyIyBG5ZkJvEurvmm996Rsm/fMTZn5WGN+LmA7sdnf0+/pFxf7C51skzWgsGLDtnSbkVzAgIiIdnIIBETkiualubv/eUPrmJDG0ayrhiMWf317LuqL4Viy2212NXrfU7XmsArHdwO2IrkvQyICIiHR0CgZE5IhdcXJP5t96Gm//fCJnDc0lHLH46zvr4noNm80Jq/4Sex3Ov7BFFhH760cGnDZIcDoB1RkQEZGOT8GAiMTF784bgmnAx+v3sGZX/EYHXI5EEormkFqfsChy3G2EQn7KywvYvftr6uoq4nId3z4jAwnO6GiERgZERKSjUzAgInHRKyuJ847PB+CpxVvi1q5hc5Ix6FqS7WDrcREYdqqqtuHzVWFZEbze+GQz8gWjVZVdDpMEVzQYCIatuLQtIiJyrFIwICJxc8XJPQCYu2J3bEFuXNRnFnKOuhcAv3/vyEMgUItlHf0TfH99nQG3w47THh2GCIQUDIiISMemYEBE4mZsnyy6prmp9oX43WurWLy5jLIaf3waNx2kpORjGNFMP6ZpwzRtWFaE6updR918Q/CS4HTgdtYHA1ozINLpxOPhgkh7omBAROLGNA1+ffYgTANe+WoHUx5ZzDWzvsCy4vOE3W53k5k5gNTUbmRlDSQxMRuAmppiamv3HNU/4g3ZhNwOOy57dIFyKAKRiEYHRDqLurpydu/+murq3W3dFZFWo2BAROLq+yO6M3P66Fiu/hU7qvhmR1Xc2ne5UkhOzsPhSCQlpRsJCRkAVFVto7x80xG1aVlWLBhIdDlx2W2xfRodEOk8PJ6dAFRX7yIU8uHx7KSycmvcHmiIHIsUDIhI3J02qAtf/eFMJh+XC8Ary3a0yHUMwyA1tXvstd/vOaJ/tINhi4YBgASHgwTX3tSlDWsJRKRjC4X8hMOB2Guvt5SamiK83lI8npb5DBM5FigYEJEWkeJ2cPmo6ILiTzbEJ+NPU2w2Jzk5Q2OvQ6G6ZrfhD+1d7JzgcuG0O7DVfzrWxXMhtIgcs4JBb6PXNTXFse9ra0sIBGpau0sirULBgIi0mDF9s7CbBtvKvWwr8x76hCPkcCTgcqUC0exCzVUXiN7wmwa4HQ5M04bbHp3m5A2E4tdRETlmhUI+IJqcoClaRyAdlYIBEWkxyS47I3qmA/DR+pIWvZbTmQRAMNj8YKC2PhhIcBjY7U4MY28wUBcIxq+TInLMahhVTEjIim2z213k5AwBotMQa2tbbpRTpK0oGBCRFnX2sK4APLGwkHALZuZxOlOAxjUIDletP/r0P8FhYJoODMPAVR8M1PrjlBpVRI5pDSMDLlcqmZn9SUvrQXb2YByORJKTo+ufqqq2UVFR2JbdFIk7BQMi0qKmjO5BeqKDLWVefvnSNwRbKDuP05mMYZiEw8H95v4eSk19MJDoNDDNaI0BtyP68ej1Bw54noh0DF5vGcFgHYZh4HAk4nankZTUJfZ5kJraPVbnpK6uHJ8vfhnSRNqaggERaVFJLjt/vmg4NtPgta93cuuL37TIdQzDiK0b8HrLmnVuTV306X+iY28wkKBgQKRTiETCsWxBycldsdkcTR6XktI1VtvEU7kZK6xRQ+kYFAyISIs77/iuPDrtJADmfLOL8tqWucFOSuoCRDN/eDw7iEQOLxNQTf0Nf6LTFqtw7HZEFxF6AwoGRDoyv99DJBLCbneRnJx30GPd7nRYeSeht0dS9bQbFs9onU6KtCAFAyLSKr47OJeBuckAzF9X0iKVfV2ulOg/1kTTAhYVLaeiYvMhaw/U+BqCgb0fiQnOaDBQp2xCIh1aJBJNEuBwJMYeBhyI0+7GsXsOAN4wBAtmQkRJBqR9UzAgIq1mfL/oEPsvX/qGIbe/y9THFrOnOr5D7RkZfUlP741hRD/e6uoqqKkpOug5Nf7oP+ZJzr0pBRMc0elCXr/+oRfpyMLh6N+4aTY9PWhfhs1JzuBrqS+wzp4AhD6/tiW7J9LiFAyISKs5q74iMYA/FGFhQRk3PL0sluc/HgzDIDExi9zc4aSl9QSgtrb4oFOGautHBpJc9ti2hpGBlqozEAr5CIU051ikrTWMDBxorcB+Tn6Y1L0fFXgKnoZF17RAz0Rah4IBEWk14/tlM/enp/Dpr0/n9RsnkOKys2xrBT997uu4X8s07SQmZmO3u+sXCG4HwLIiWFakUXBQG2jIJrRvMBC9MWiJOgPhcJA9e9ZSWrq26SBF0w5EWk1zRgaiBzpIGHAtXZzRl/4IRDbP0t+ttFsKBkSkVQ3rlkaPzERO7JHOrGtPxmkz+WBtMS99uZ2/vbuO+z/cSCRiYVkWSzaXMX9d8QHb2l1Vd9D1AIZhkJ7eC4hmGCoqWs7u3V+ze/fXlJSsjD2Zb5gmlOzeezOQ6Ir+S+8NhA57IfLhqq0tiQUkPu+eRjcRno+nUDzbSWjhD/c/UTcbInHX7JEBgLGPY78ygCOpJxbgS+gLhxtMiBxjFAyISJs5qVcGV42N3qz/6uUVPPTxJv45bwPz1hbz2KeF/OCRxVw760u+2lax37mzP9/CuLvn8+inmw96DaczOZYOcN+b+n1HC7z+6PZ9pwk1jBL4QtYRVTU+EMuy8HpLoy9W3knli12pe8YJi2dQXbWNms0vELagbtOTEAlihQNYVoSyDy/F85RT0xFE4iwYqAYrdPgjA/tw+7cB4PNsVrAu7ZaCARFpUz8/Y0CjhbsAD3+yieeWbou9/rygtNF+jy/IH+esBuAvb687ZLag5ORcDMPANG0kJeXEngD6fFVYlhUrOpZcPxoAkFCfWtQfsggEmhEMHOKGIBCoIRIJgRWCndGsJNUh8G6cSfWiG2LH1YSg8uMpFM12UfbBxfi3vkJNGGo2zoLPmxg1EJFm83w8Bd4bC++Nxfbl/zTvZNOBu980IDpVyFry4xbooUjLUzAgIm0qLdHBE9eczMQB2cycPgq3w+TrbZVsLt17A750S+ORgde/3tno9YodB68Gare7yc4eQk7OUNLSepKbe3wshWAkEsJbv4A5xb03GHA3CgaqY8dWVm7F769u8jq1C66MPuU/yNN7ny/6XhKT8sgbMh0DCFlQGQR2vUNDdlML8G55FQsIbH8jdr4nBJUbn8RaOO2g71lEDiESpK7wBQCSbWAWzmr2033HuMewG9G/V1/BExodkHZJwYCItLmT+2Ty1IwxfHdwLjdPGrjf/q+2VhDepy7Bm9/sarT/mSVbD3kNhyMBm23vzX5DpeFQqA5vIAJASkJCbH9DNiFf0MLvryYcDuD1luH1llJWtgGvt5RgsC52vM9bSlXBc1QEwbNxVpMBQTgcjE0RSkjIxBzzSKOsJMk2yHIQS1voMiHJBgbRr4bvvWGoLHhKU4ZEjkLYsgjnX4ABpNiBvtc2f96/6cDd5wcA+CLA0hsOfrzIMUjBgIgcU66b2JcrTu4BwK8mDyLZZafGH2Ltbg8FJTVsLK7miy0VGAY8eOVIAF5f3vyqxg3zg/1+D95gNNBIcu29EWiYJhSIRD8mvd5SQqG9N/+VlVspLV0Xy0RS56+G/POix4bB2jwrOt8/HIg9LaypKcKyLJzOZFyuFDAdJA28lhxnNAhIdYDRdzpZA6eR5YAsJ6Q5oIsLcpyQljGADEc0IKgLQ3DTLD2JFDlC0RG+CHYz+nfH2MePqB3XmP8AEIgAm1WETNof+6EPERFpPTbT4O6Lj+eWMweRnexkSWE5Czbs4fwHPmt03FlDczl3eB5DuqaydreHD9cWc9moHod/HZuDYDAaDNTWjwwkufYtOhb9PhiJfkzW1BTvl23EsiLU1ZWTlNQF3xe/gF1vgS2RSNiL19Wb6g8vh51vRKcRdL+Y4ND/BSAlJX9vI2Mfx3Hyw3tfmw7sgH3cY3v7us8+dySI66Mp+La+iq/b5TiUwUSk2SwrQvVn18LOubjtQOEsGPPIEWUEsjtToNsFhHfOwepzDYb+JqWdafGRgb/+9a8YhsHNN98c2+bz+bjxxhvJysoiOTmZSy65hOLixukDt23bxnnnnUdiYiJdunThV7/6FaFQ4+I/H3/8MSNHjsTlctG/f39mzZrV0m9HRFpJTooLwzAY3Stjv30JDhv/e+4QDMPgzCFdAPh4/Z5mtd8wMhAIeKnwRoOB7GRXbL+7fpqQP2zgcCRiWZFYKtKkpJzYcV5vKUF/JdaONzANSMILQJVnC5EdbxCxok8Mg9teBSuEy5UaHRVo1BnH3q+mtu27z3TgHvcIdDsf75YXiWgxsUizeWt2E94xB7sRnZ5Hn+lHnBrUZnNgHH8HTF5MePRD8eymSKto0WDgiy++4L///S/HH398o+2/+MUvePPNN3nppZf45JNP2LVrFxdffHFsfzgc5rzzziMQCPD5558ze/ZsZs2axe233x47prCwkPPOO4/TTz+d5cuXc/PNN/OjH/2I9957ryXfkoi0sjF9s2LfD85L4eKR3XjtxvH0ykoC4PTB0WBgwYY9BMORw263Yc1Atd+ioQByl9S9wUDDyIA3ECY1tVujc1NTe5CXdyKGYRIK+ajxlkO3C3AakJrWD9c+n6wOIzqth24X4E7IJiOj72H38UASXMnYds0lbEHNxie1dkCkmWoX3wjUr8PpOx3GPXFU7dntLjDshMOqKi7tT4tNE6qpqWHq1Kk8+uij3HXXXbHtVVVVPP744zz77LN897vfBeCJJ55gyJAhLF68mLFjx/L++++zZs0aPvjgA3JzcznxxBP505/+xG9+8xvuuOMOnE4nDz/8MH369OHee+8FYMiQIXz22Wf861//YvLkyU32ye/34/fv/UP1eDwt9fZFJE5G987gTxceR8+sJL4zMGe//cd3TyczyUl5bYBlWysYu0/wcDANU3721EYjgYxEBy773mlC6YnR/ZXeIC5XKomJWXi9ZTgcCRiGgWHYcLvTqasrx+erhOG34xr/H4yUbmQunEZlwVMYQLoDuLwW7IlH9XPYl2FzkdrvCioKnsMXgdTDmeIQCTbe/+3XIp2AZVlUzL+U0PY3MIAEG9G/nQMc+/rynQRDFpeN6h7LQNYUm81FMFhHMFiHy5Uan87qb1RaSYuNDNx4442cd955TJo0qdH2ZcuWEQwGG20fPHgwPXv2ZNGiRQAsWrSI4cOHk5ubGztm8uTJeDweVq9eHTvm221Pnjw51kZT7r77btLS0mJfPXoc/vxiEWkbhmFw9bjeTQYCEF1jcFr9vo/WlTSj3eiNf2lNdDQhN9XdaH9WUnSUoMIbIBSOkJ7em6ysAWRk9IsdE61fYNa3Z+JKiBY3MyY8ScbA6dFAoO+1cQ0EGrhOeQqj2/cIWRDqdXX0pqGJhYuBQA3lH15C7dPRlKeWFaH6kytihc5EOpO62mJ8W18Fotm6zJT+jW641+zycNa/PmHkn+Zx+xur+cUL3/DrV1bw+GeFB23Xbo9+ftTUFEXriBwFy7J49tnf8dXjQ/Q3Kq2iRYKB559/nq+++oq77757v31FRUU4nU7S09Mbbc/NzaWoqCh2zL6BQMP+hn0HO8bj8VBXV0dTbrvtNqqqqmJf27dvP6L3JyLHltMapgptLD3EkXu53Wk4HInURqJP8bp8KxjISHRgGGBZUOGN3mS7XKnR6QD1HI5EcnKGkJKST07OkEb7GPcETAkccYaSQzFNGw57NFVq1canqH6lD4Fn99Y4CIeDVFdtpfSjK/BtfZWqEHgLZlH+wfep3vR8NAXq+pkQ8rZI/0SORd7FewuLJdmBmoJYEF3lDTL9iaVsKK6hvDbAU4v3piz+89tr+ef764lEmi5wmJyci93uJhIJUVNTdFR9/Gj1Zv53xXgu3nSfshNJq4j7NKHt27fz85//nHnz5uF2uw99QityuVy4XK5DHygi7cpJ9YuMNxZXEwhFcNoP/ZzDNO3k5AyhalUBALkpjT8b7DaTjMTo9KOyWj85KU1/dtjtblJSuh7gIi04xB8JkrL7FcqJVj/1V22h1oDUglmYAR++cBDvllcanVIZBLbPib2uCYP1TBKpA36IMfZRTUmQDs37yRUEtr2GQTRdr82gUW2BOSt2UVLdeM5/t/QETh+cw9OLt3H//ALClsWvJg/er23TtJOa2p3y8gJqa/eQnJwXW5fUXGuLava+OJLaByLNFPeRgWXLllFSUsLIkSOx2+3Y7XY++eQT7r//fux2O7m5uQQCASorKxudV1xcTF5eHgB5eXn7ZRdqeH2oY1JTU0nYp3CQiHR8+WluUt12QhGLgpKaQ5+wj6IqH7D/NCGArKTok/eymubVMGgVpgNX/2vJdNYvUAYi9ZWMyzc93ygQSLETq2xsM6KvU+rvU2rDsGf9bILPatqQdGCRIHWFzwOQbAdb3+n7jdzNWR6tbH7Dd/qRluDAYTP49dmD+NOFw7jromEAPPzJZgpKmq5A7nan4XQmYVkRamsPf8ritzVamtBCI4si+4p7MHDGGWewcuVKli9fHvsaNWoUU6dOjX3vcDj48MMPY+esX7+ebdu2MW7cOADGjRvHypUrKSnZ+8c0b948UlNTGTp0aOyYfdtoOKahDRHpPAzDYHDX6HSftbublxhgV2V0WmFu6v5P/rOSo8FAac0xmiFk7OO4rgyQO3gaXZx7b/j31VDFOGvgD8lyQhdnfTCQ3j9W7ThkQVUITUmQDsnnqyIcrCWQfyEA7r5XRafx7fPEfUeFN1bMcPr43rz/i1NZdNsZXHhiNwzD4KqxvZg0JJdwxGLa40u5+fmvWbGjcr9rJSV1qb/m/vuOhGU1PS1JJJ7iPk0oJSWFYcOGNdqWlJREVlZWbPuMGTO45ZZbyMzMJDU1lZ/+9KeMGzeOsWPHAnDWWWcxdOhQrr76au655x6Kior4/e9/z4033hib5nPDDTfw73//m1//+tdce+21zJ8/nxdffJG33nor3m9JRNqBoV1TWVpYzrw1xVx4Yj522+E961hTHzwMzE3Zb19Wfd2BY3JkoIHpwBw/G3PsY2QvvYHIppn4IlAVjAYBqQ6iOdTHPYFr7KONznNFgmQtmkHJ+qcIRCDU+4fYNSVBOpDa2j1UvXkSeLeDLQnTAPs+xQN9wTAFJTW8+c0uAMb2ySIvrekpzv/vwuNYsaOSXVU+Xl++i7LaAE/NGNPomIZMQsFgHeFwcL9ChYdj34GBQCiMy6H6sNKyWrzoWFP+9a9/cf7553PJJZdw6qmnkpeXx6uvvhrbb7PZmDt3LjabjXHjxnHVVVcxbdo07rzzztgxffr04a233mLevHmccMIJ3HvvvTz22GMHTCsqIh3bd+sXEb+7uoipjy2hovbQN/DltQF2108TGpq/fzrAnIZgoPYYHRnYl+mAsY9jXhEgcWp0tGDfQCB2zLcKmNknPImrZ7TOiy94DAc9IkfAV7s7GggAhGujdT8Kn4iNgP3vqys5/4HP+O+CzQBcNqr7Advqlp7AGzdN4IITohXEP91YyoMfFbC+aO+0IdO043BEs4cFAk1PJ2oOr19/k9LyWiXc/Pjjjxu9drvdPPjggzz44IMHPKdXr168/fbbB233tNNO4+uvv45HF0WknTt1YA7/mTqSX7+8giWF5Vz52BJe+5/xuB22A56zZld0VKBXViIp7v2f4DWsGSitbkf/INff6JvjZ8PYxw69+DASxLXrVfxAcMtzMHG2FixKh2BZFoHltzfalmAjtii3vDbAmyt2xfaN7JnOhSd242C6piVw35QT+ayglPLaAH9/bz3vrynmjRsnxI5xOpMJBr0EArUkJGQ2u9+hyN7iid5AiP1rsIvEV5uMDIiItIRzh3fl1f8ZT3ayk7W7PfzjvfUHnXP7Tf2c3+OaGBUAyE+PJiMoLKuNe19bxeHc1JsOHH2vBiDQ9cK99QoaUo5qDYG0U0F/JdaONxptc5vAyQ8D8M6q3QTDFsflpzL3p6fw1Iwx2MwDFxZrYBgG5w7Pi73+ZnslJdW+2GunM1odPRg8ss+NuoaS6IA3oL8/aXkKBkSkQxmYm8KfLoyuT3rss0L63PY2Vz22hFU7qwAoqfbx2KebeWvFbt5fE81INu4AVYuHdUsDoiMIB8ov3hE4xj8B3c4nvOMNKl/qTeVTTiqfSaLsqWRqnt5bu0CkPfEHfdDtfBJskJ3Rj2wnmP32pupcvLkcgLOG5jGsWxpJrsOfLHHnBcN46YZxsTTGH6/fE9vncESDgUCgFr+/eQkNILqOoYE3cHQFzEQOh4IBEelwzhneld+fNyT2lO+zglIuffhzFmzYw8X/+Zy73lrLjc9+xTfbKzEMmHxcXpPt9MtJwmU3qfGH2NJeRwcOg0kE5+65AHirt+INgzcM/mAtnhD4CmbB5z9s206KNFNg6U9h51ycvafg/H4Bziv3phK1LIslm8sAOLlP86fymKbB6N6Z/OQ70Yrk+1Y/t9tdselBVVXNL25at08wUKeRAWkFCgZEpEP60cS+PHL1SYzsmQ6ALxhh2syl7KhoXKF8XN+s/aoPN7DbTIbUpyxdWT+y0CGZDtIHXI3NALsRzcNu32e2RHkQ9mx4kqL3vkd5+Sbq6srx+49+caRISwn6Pfi3RmttuLY/H53uts+0ucLSWkqq/ThtJiPqPyOOREPigk83lhII7Z3rn5bWE9O0EQr58Pma99nhC+5tp04jA9IKlK9KRDqsM4bkcsaQXMprA5x//6fsqvJhMw3eu/lU9lT7Kan2cdrALgdtY3TvDJZvr2Tuit2HXFzYntknPEkXw8TYMhv6TCeVCJHNT1IUSoBwHcEIsHMuPsA3/A4AsrIGYllhIpEQiYnZbdl9kUa8n18HRBcM2/vvX8W3YVrPqN4ZB00ycCjDu6WRneyitMbPF1vKmdA/+ndgmjYSE7OpqSnG6y3F7U477DZ9jUYGFAxIy9PIgIh0eJlJTl748Ti+d0I+D145kv5dkhnXL4sLT+xGWuLBF9n+YHQPAD5YW8xnG0tbo7ttxhg/K1qVddwTMG425g9qSSQ6kmIQrVvg3D0XrOgNSlnZBsrLN1FZuZVg0Nt2HRfZVyRIYMuLQOMFw/v6cF10vdBpg3KO6lKmaXB6fRvz1zWuOtwQIPv9VYRCvv3OPZC6fUYGav0KBqTlKRgQkU6hR2YiD1wxgrOHNb0+4ED6d0lh0pBcLAuunf1FbCFyh7XvE1R7ImkDryHbCV2z+5PmgOzB15LX9SQcjoRGpykYkGNFBJNg/vkAOPtNb/Q77fEFOee+T1lYUIZpRBcPH62GqUJzvtnV6ObdbnfjdqdhWRbV1bsOdPp+Gk0T2meUQKSlKBgQETmEB64YwWmDcgiEIlw76wuWb69s6y61GmPczOjCyws2RkcNxj6OadrJyhpEamr32PSHAwYDSk0qrSgY9FL6wfdh51xsBtjMxrc5sxduYW191fGrx/aid3bSUV/zu0O60CsrkT3VfmZ9vqXRvuTkrgDNWmPjryqMfV/nbwcFD6XdUzAgInIICU4b9/1gBINyUyip9vP9/yzk8ocXcf+HGw9ax6DD2KdicWyTaSM5OTeWNSX4rRSKkUiIyvmXUvakk+BnV++zPYwVbkdF3KTd8Pmq2PPyIEI73sQA0uzA5pmxgNQXDMdu1i87qTu/P39oXK7rstu48fT+APz9vfVsKd2beczhSMQwTCKR0OFNFYoE8fn2Bg513/wFFs+ISz9FDkTBgIjIYUhLdPDij8dx0Yn5WBYs3VLOP+dt4MutFQCEIxYfrS+hsLTjpiBtit2eACvvJDh3OJGF0fSjlhWh7MPL8G55BX8EyjY+TWTh1QR8lRR/cDGVT7t0gyNx56vZBXU7AMh2gnufasMALy3bQVltgG7pCdx98XActvjdAp0zLC9Wc+Ci/yzEH4pO7zEMA4cjEYjWHTgk04HPtncdQ13E1SigEWkJCgZERA5TWqKD/5sygpduGBfbNvOzQj7bWMp37/2Ya574gsn/t4D3Vxe1YS9bl9204dg1BwuoLngSa+E0ajzbCW5/nYbspBEL9mx4mtJnM7B2zKEuDJ4NM6mu2kZ5eUGsMFOnGGWRFuP/+n8ByHKCI6V/bFobRIP1RxdsBuC6iX2wxzEQAEhxO/j9eUMAqPQGeXfV3s8ApzM52j//4a038tn2ZubyRVyNAhqRlqBgQESkmUb3zuS9m08F4J1VRVz1+BK2lkXnzAdCEW5/Y3XsyWC1L8iCDXsa5SDvSAybk9T+UwGoDcPu9U9R/fYpAKQ7IKP+Hib8rfv8mhBU1+zG56uivLyA8vJNFBV9TUVF4X5Bgd/vobh4JZWVW/D5KtmzZw2lpeuprNyiAEIA8NbsJrz9dUwDnAbwvTWxG2jLsvjPRwVsK/eSkejg8voMYfE2bVxvfnbGAADmrtgd2+52pwPR32PLOvTnQCC093c61OdHsYBGpKUoGBAROQKD8lI4b3jX2Os+2Ul8/YczyUt1U+Tx8epXO1m2tYLz7v+MaTOXcsWji/EeJGd4JGLx3NJtrC9qf8W8XBOeIGHfVO11O7AZ0bSOCf2mkeGIfp9oi87jthtAt/NxOFMxTRuWZeHzVWJZFnV15Xg8OwgEaigr24jHs5Oyso2EwwG83jLKyzcRDNYRCNTUv95IRcVmKio2U1tbouCgE6qu3k3l3JOBaPpbo1/jJ+m/fnkF987bAMAvzhxIorPlSiw1pCpdWlhOJBL9XXQ6k7DZnEQiYWpqDj1quG/gHLaMAx8oEicKBkREjtDvzhvC8d3TMA34zdmDyUhy8qOJfQD46zvruPThz9lWHh0xWLa1gicXbcWyLJZtrWD251t47NPNbNpTA8AzS7dx26srufThz3ln5e4DXjMeguEI64uq43fjbDpIH3gNGQ4wjehXhgOMPtNg/GwSBlxLphPSM/qTZIfsgdPIOu0ZcnKGkJt7AsnJubjd6SQnR9M81taWUFq6Hr/f0+jmyTT3Rhx2e7RqtN9fTV1dBXV1FVRVbcfj2RGf9yTtgt9fTfXC68C7g0QbJNuAUQ/E9n+yYQ8vLYv+Tvxi0kCuHturRfszvFsaSU4bVXVBVu/au6g+LS06GlFTU0wkcvDaAeHI3r/LsIJbaQWG1Ykfo3g8HtLS0qiqqiI1NbWtuyMi7ZBlWQTDVmzxYEVtgDF/+ZBAODod4JKR3RnSNYW73lpLisvOqN4ZfFRf/RQg0Wnj4atO4lcvf0OxZ28awR6ZCZw5JI++OUmcNiiH/3y8iYFdkpk+oc8B+2EYh36KuL3cy5RHFrOzso7vj+jGvZedgGnG6eljJIi1+DoonI3Rd3q0eNk++zAde/97AFVV26mtbVy8yWZzkJSUS1JSDoFALXa7G9O04/Fsx+stw+WKjjB4vWUAJCXl4HQmxzIdScdVsWc1dW8OI9EWnZZGcv9oGtx6Nzy1jHdXFzF9fG/uuOC4VunTT55exjurivjBqB787dLjY9v37FlLMOglJSWflJSuTZ5rWRbH3f4O3mD01uziE9L55xUTWqXf0rE05x635cbKREQ6AcMwcNr33kxnJDn59dmDeH9NMTed3p9TB+YQDEd4ctFWtpV7+Wj9HuymwWmDcthYUsPWMi/TZi4FwO0wGdI1la+3VbK9vI6ZCwv3u16NP8TV43rz5ZZytpR5OS4/la1ltfz9vQ0MzE3m3OFdOW1QDpYFTy3eSiAUoX+XZC4Z2Z0Ep437P9zIzspoVeHXvt7J68t38qvJg/if0/of/Q/DdESrGI99dP8b/ibSkzYlNbUbkUiQcDhAUlIubncahrF3ENvlSol9n5bWk7S0nkA0g1FDMFBbu4fa2j3YTTsOV5we9BwoiDlEcCMtx7tgKnUFzwLRKWj0jo5ENajxh5i/PhpYXj6qZdYJNOVHE/vyzqoiXv5qB5eO6s7o3tGgNDk5l4qKQmprS0hOzm30e72X1Wg0YN9RApGWomBARCTOfjSxLz+a2Df22mEzuf38ofzoyS9Jddt5ZNooxvbNwhcMc9nDi1hZX9X4D+cP5aITuzHxno8or206F/8/3t/AP97f0OS+0ho/n28qa3LfM0u28Yfzh/D68p0ATB/fm1mfb8GyornRzxicy6C8lCbPbbajuDk2DJOMjL6HPrCJ82w2J+GGGgYr76R69xwyB1/brAWYlmVBJIhhcwJE1yp8ejWJO1/E1m9vW7W1e/AvvoGU3a/i6F+/XYFB64kEqd0cDQSSbOA0gbGPNTpkaWEZgVCEXlmJDOkap9/tw3BSrwwuOjGf15fv4h/vreeFH0ezj7ndGdhsOwiHg/j91bGCffuyLIvIPmuMFQtIa1AwICLSCiYNzWXOTRPIS3PTJSU6393tsPHUjJOZuXALwXCEy0f1wGEzefHHY9lTHWBcvyy2ltWyZHM5Zw7N5Y3lO7njzTUAdE1zk53sYmNJNfnpCeSmuMlKdrK1zMvqXVVELOiZmcjZw/J4edkO1u72cOWjSwA4c2gud1xwHJOG5HLV40uwLPjvJ5v45w9ObKsfT1ykp/eipqaIpIQMynfOwQeECmZiP/nhRpllwv4K7O7GU4hCIR/+unJqFt0AO98ka8BVGOMep/SDSwnvfJM6A3I2zYST7qOqajveL38Fu97CMiGtYCZ1dR7Y/jJJ/adh7vN0WuIvFPIRCVQT7Ho+7JxLsp0m028uLYzWABnbJ+uwptDF0y8nD+L15btYuqWckmofXVLcGIaBy5WG11tKINB0MACNAwCNDEhrUDAgItJKju+evt+29EQnt5w5sNG2/l1S6N8l+n2vrCR6ZSUBMH1CH1LcDj7fVMZt5w4mO9nV5FqBal+Q+etKGNcviy4pbi48MZ8f/HcxNf4QA7ok84/LTgDglAHZvHzDOC59eBHz1hYTCEViax/aI5crFZcrFSJB3Cb4IlAThnSIrmewIpS/Mgh/zVYSk3uRfvkWIFoMqvSjK2HnnFhbZRufxtjxMWFvdPFpyILdfuCpxk+Y/REoCSVA4csA+NY/STZGdLqUxJ3XW0rlnJHg3Q6AwwBb3+n7jf5EIhYLNkTX5ozu0/prR7pnJHJCj3S+2V7J/LUlTDk5Op3N5UrB6y3F7286a5hlRRpnE1IwIK2g/X7qi4h0Qpec1J17Lz+B7GQXQJNPPFPcDi48sVtsBOK4/DSevW4MN3ynH89cN4a0hL1PUEf2zCA72UW1L8SizU1PMWp3TAfJ/a8GwBuGylcGUDTbye7Zbvw1W6Pba7biW3BF/fe7YoGAo/7HGbYg5I2mSE391mMzg+gcdXfDv6CROhz13wctCG2eDSFvS77DTqvWs21vIGBCih0onLVfhd7nvtjGmt0e3A6TUwdk799QK5jYP3rdL7ZUxLY5HNHAPhTyNXnOt2/+lU1IWoOCARGRTuD47un89pzBsQChgWkanDMsmtLzqUVbWbvbQ1Vd9MaqPSebc45/PDqPHPBWb21y7nVFwfP4a4up++JWALKdkOOCNEcisDdFanK/K0mon5ee4YA8VzRzTXp6X9xmNCjIdoCr/nqVzl54nkkitHAaVvhbaz++ddMqhy8Y9BL85o8YRP8f5DjBbaPJKUKv1KcTvXnSQLqkuvdvrBWM6p0BwBdbymPbbLaG6WoRIpHwfueEIo2LkkU6Zq1COcZompCISCc3fUJvnl6ylQ/WFvPB2mKyk51cclJ35izfRXqik79ePJwTeqS3dTebx3SQ3v8q9mx4mm/HAenpfaisLMQCyl6IBkIus34R6qWVJDnTcL/RH7NmE0Zyf5jwDBk2N2yeCX2mw+gHwXRgmg4yF10TfTLdZzqOIbfjr95FcN4pBIGa9U/h3vgUmYOvxRrzGHULriS89XmS+k3DGPsohs1JOBzE56skMTHrANllpEHNgmmwcy5uWzRQ4/LaaBCwTyDw5KItPPZpYay+x0Undmuj3kYXEhsGbCv3sqfaT06KC8MwMU0bkUiYSCTYqHYGQDjc+O5fIwPSGhQMiIh0cv1ykrny5J48s2QbAKU1Af77yWYAdlf5uPDBhVxxcg8uH9WDET0z2rKrzWI/5Sm6GCbGlicxDagJ1U/x8RXiq19T0CDVTvRG3xld1Gm7sCA61cceHSVg7OOwz0LkmHFPwJhHwHTgqKuAJT9rtNsXAc+GmYRry6nb+joA1eufJKngSVIGTmdPn5uJREJYVoTk5Nym34iyFGGF/fi2vgLUFxbrM33v/5t6CwtKuf2N1bHXI3qmk5fWNqMCEJ2u1y8nmYKSGlbtquL0QdGFQKbpIBIJEw4HY8XzGoStb48MKBiQlqfHECIiwp8uHMY9lx7PfVNO5Cen9eO4/FTOO74rKe7oM6Pnlm7n8v8u4pvtleyp9rO9/snr+qJqPlhT3JZdPyjbhNmYVwRgSoDkgdeSVJ95JnPwtaTVPw5LsUfnnzPmkcYnf+tm84A35PXb3c5EEovmkl4/lSih/qFvTYhYINDAGwbPhllEgtEK1D5f5X7NRkI+PB9dTu3TTqzPpx/2e+6IAqEAVrcLsBng6De9cUG7eh+u3VusLtVt5y/fH96KPWzacfnROher69MHw96pQpEmpoztv2agBTsnUk8jAyIigmkascJMFwK/OXswEJ3v/PinhWwurWFDcQ0XPrgQ04jWTnj9xglMm7mUPdV+Zk4fxXcHH+DJdltruIn/1tP9pJMfJmHRjzC3PtnkvPPmMmwu0gddG5tOlB4J49z0FNVhsKzo6IPbBnsC0fSRXhJh3inQ7QKCx9/RKDNU7YIrqd70XGytQ6RgNimGsfcmuH60IBIJYVhhDJvrqPp+rLKsCMGgl/LyjTD8dpyj/g5ZA5s89qtt0YW6f714eH0g2/ajKcPy03hj+a5YLRGIjgwAhMP7BwOhb08T0siAtAKNDIiIyAGN7p3Jw1efxEs3jCc3NXrDGbHAH4pwzn2fsqfaD8AD8wvaspuHb98bftOBOWE2TAk0qzDZQY19PNreuCcwJjxJ0oDp5DqjIwVJ9mgazFh2orCXJBuYu+ZgRQKx0QF/XRlVBc81WvTsDRPLmlPz8RRqn3YSXjiNkg8upfQpNyyeEZ/+H2PKyzdRWro+tpg9IanpgNMXDLNmlweA8f2yj4lAAIittVm2tTL2HhpGBsJh/37HRyxlE5LWp2BAREQOKS3Bwb8uP5Hj8lO5ZGR3nLbG/3x8va2SpYV7s6asL6rmsU83UxfYP2PKMSfe8/H3bW/cExhXBDDqpyox7gkS+08nywlp9uhoQVLvy8GwU129E8uKUFcX/Tkm2KJBhGFPJGxBrbM33gVX4dn8AlUhKF7/FJEdbxCMQLBgZofLVFRXV47f74m9zszsd8BCXUsLywmEI3RJcdEjM6G1unhIx3dPw2k3Ka3xs2lPLbA3vWhT9QaCYWUTktanYEBERA7L+P7ZvPWzidx7+Qnc/r2hACQ5bQzpGp0Xffl/F3HJQ5/zyIJNXPLQ59z11louenAhW8tqY22U1vhjUx98wTBvLN9JSXU053pJtY9lWyvadUrTJjVkvGkIEsY9gavfdJLsYPSdTtJ3nsVmcxAK+ams3ILX54FuF5BggtlnGolWdH1GlWcLlZtfbPIStWFg6Q1H3EUr7D+mgolwOEhVVbSegGEYpKTk43anH/D4+eui6wW+O7hLq1cbPhi3w8bInukAfFJfBC0hIQO3Ox3LsigvLyAQ2Pv3EYkom5C0PsPqcJ+6h8/j8ZCWlkZVVRWpqalt3R0RkXalsLSWvFQ3ZbV+Tvv7x4QOML850WnjhevHEbYsLv7PQgbnpfKbcwbz2Keb+XRjKZlJTqaM7sHjnxXiD0X41eRBnNwnk7+/t56+2UncccFxuB22Jttu1/bJEuTzVVFRsSkWCBmGQW7OUEy7G+vz6VRvnE3NPoMspi2BSLiuUXMuE5J/UIYroXkVd2s/uZKqTc/hMCFzwNXYxjwcXTzdRlmMQiE/5eUFhEI+HI4EsrOHHPQG/5vtlfzgkUX4ghEenTaKM4ceW2tXnly0JZblaEL/LO6bMoKsJAfl5Zvw+z04nclkZw8CoGB3CZPu+yJ27vCuLt78+aQ26be0b825x1UwoGBAROSovbViNzc++1Xs9bRxveiZmci/Pyqg0hskJ8XFoNwUPisoPWRbDpuB226j2h8C4M4Lj+OU/tlsLfNy2qCcY+rJbzwFAjV4PDsJBmtJSMgkPb13bJ/1+XR2r5sdfeHuTnZkBzWh6DQjf0Jvqqq2QLcLYPjtuFyp2O0u3O4MXK6Ug1805GXP00kE6x9ImwY4DbBsSSRQS2K/aTB+dou836b4fFWUl60DwGZPICtrEHb7gRdH76n2c+790bUrpw3K4fEfjsZmHlu/H75gmLP+tSBW+2DauF7ceeEwwuEgxcUrAOjSZRh2u4v1u4qZfP+XsXOH5jp5+xdntkm/pX1TMHCYFAyIiMSPZVn864ON+IJhfnv2YEzTwOMLcvnDi1hXtHdudHayi4hl0S8niZu+O4Bnl2zlvdXR9KQ9MhPYXl63X9umEV24/PMzBlDhDbBqZxXnH5/PNRN6A7Bmt4fsZBe5bVRttsVFglQ/7aQ6FF1rkDRgeqzYGeOeIOCroKp6N8Hg3p+dadrIyTkutmA1pr5+gv+zaVRsfCq2ULnhZ/xtXTL7Yb+o5RaIW5YFkSCWFaHowx/AzjkA5AyahmPCwQORG5/9irdW7GZgbjKv/GT8MbNw+NsqvQEe+7SQf39UQI/MBBb86nQMw6CsbCN+v4eUlHxSUrqyZkcR5/57Wey8QV0cvHfLWW3Yc2mvmnOPq9SiIiISF4ZhcMuZjdM+prod3H/FCM761wIAhnVLZc6Np2Du8/R2RM90guHlHJefyvh+2Vzx6GIAfnJaP179agfFHn/sJvW+DzfGzvtqWyX56Qm8v7qIV7/eSX6am49+dRouewecUmQ6SBl4Le6CmTj6XxvNWlRf7AzA6c4g25WO3+8hGKyluno3kUiY2tpiUpJyMAyTCCbVr/YnXLOFlNQ+VFYVxn6uDgOyM/vh92yiKtQ4v32dZxMpgapYQbajEQ4HiITqcLj2tlU+/zICW1/BZkBDuehEGzi2PgnjHjvgVKX3Vhfx1ord2EyDf15+4jEbCACkJzr5yWn9+O+CTWwvr2NrmZfe2UkkJmbh93uoqysjJaXrfqlFlVlUWoOCARERaVEDc1P4x2UnsLSwjN/UjxjsK9XtYOb00UD96MIPTiDBYePsYV25ZkJvPlpXQv8uyfz3k828v6aY/l2SyUx0snRLOTc8vfcp6q4qH3O/2c0lJ3Vv1ffXasY+jmPfKsjfukk2DAO3Ow23Ow273U1FRSE1i35Czc65JNrA3vMyaj1bAPBVFoItMZbeNMEGRu0m3FfU4lp6A5HCp6iIJBEI1lIdgsCz6aT2vwrHKU817lNT6woaFiKbDqywP1YDIRTyUzr/UiI75pLebwrhE/9KKFiLv76ycKj+xjfBBukODlr7ocob5A+vrwLg+lP7Mqzb0QcqLS3JZWdYtzS+3lbJip1V9M5Owu1OxzBMQiE/gUDNfqlFVYFYWoOmCWmakIhIu+HxBUlx2akLhrni0SV8s72y0f7j8lN548YJfFpQyvHd0shK7pjFuA4lHA5S/MHFsHNu4x0J3aFuR+xlmj1a/wCI3nw31Fuon7ZT8qQ7NkpgM6JTd8z6NQSejy4nsPUlMgZMwzZhNpZl4fn4B3gLX8JmQCShB9RtJ73flTjHP07pywMJebc32V+XCf76h+LpDki8onb/CtD1lm2t4H9fXcn64mr6ZCfxzs8ntpsF5v/72kqeXbKNn5zWL1bYr7JyC15vGUlJOWwsNbj00RWx43tn2vn415PbqrvSjmmakIiIdEip9VNBEp12Xrh+LM8u2cbGkhp+NLEP593/Kat3eej/u3cAyE118cL14+idndSWXW4TNgMcu+eyX7LQuh3kZPSh1lOI04xOx6HP9EZTjgAwHRhA9sCrqS54Cm84OnWoruBJksY+hu+z6dQUvgRAdcGTJIUDVPhqCe14E6h/yl9/419e8CzmpmebnPLiMMFuRIOSsBUNCBJMDjgiEIlY/Pz5r9lRUYfLbvLAFSPaTSAAxNLwrt29t35CQkIWXm8ZdXXlhCIZjY7XyIC0BtUZEBGRdsntsHHtKX24++Lh9MtJ5rKTejTaX+zx8/f31wPRp8nPL93W5M1VeW2A+euK+WhdCf7Q3vydNf4Qv31lBZc9/HmjgmrtgukgY8A0MhyQl9mXhplZLhMcdYWkD5y2NxAY98QBb75tE54kfeB00uofHdaEo6lIKzc9GzvGG4Y9Bc8T2vEmphHNcJRgi65DsNVft+HHnmqHbHcSSTbIcUa/MhxgpgzA0f9aku1g9Nt/epAvGGb+umL+97WV7KiILpJ+46YJ7WJ60L6Gdo1md1q1syr2u+h0JmOzOYlEwtT5GhchCysWkFagaUKaJiQi0iF4AyFmzPqSDcXV3HrWIP73tZWYBvxoYl8e+3Tz3htSt51zh3fl/114HJYFp97zESXVfgCyk53c8J1+ZCQ6+XBdMW+vLAJgaNdU3vrZKRiGwa7KOl77eiejemUwpm9WW73dw1M/pz/42dWECp/GbdbfbI99vFl1BKxgDXueTonN64foE32nGQ0GIBpoZDiiWYmwp0CoGsxkKvw11NUf02XAFdgnPguLrtmbDWn0g3unBB2gT3fMWc2sz7fEXv/olD78/vyhzf5xtLVAKMJJd82j2hfi5RvGMap3tCZEVdU2amv3sGJ3mBte2hM7Pi/FxuLfnd1W3ZV2TNOERESk00l02nn2ujGEIhYOm8k7q3bz6cZSHlmwudFxHl+I57/YzoDcFLqkuGKBAEBpTYC73lq7X9trdnu46vElnNA9nf98vAmI1kP42XcH8GlBKaluO6N7ZzKsWxoT+me37Bttjvoba8cpT+EYP7PRtuYUFDMcyWT0v5LKgmcJWZBki641sPWdjrvoE6yawmig0Xf63ilH9SlM0xdOw7HpKUwD7Nufg8js6GjEt6cmNdGnUDjCnho/ryzbu87hohPz+eXkQc3+URwLnHaTSUNyee3rnbyzqigWDNjtCQCEwqFGx397QbFIS1AwICIiHYZhGDjq56b85uzBfFbwGZYFP/1uf16uv6Gc0D+bl5ft4C9vr6Uhr9FPv9ufL7dUsGhzWaP2rp3QhySXjQfmF7CwoIyFBXv3B8MW987bEHv9wdoSTAPeu/lUbKaBw2bSI7PpRbBt4iirCTsmPkNOxVKs6gIMg9gUIzdEb/xNR+Nr1D/tNyY8SbJpi44E7Jsh6DD68/Pnl/PWyt0AdM+I5uf/djaq9uacYXnRYGDlbn5/XrS6ssMRDQbC4XCjYyNWNMNWRy20J8cGBQMiItIhDeuWxgvXj8NmGpzUK4P/Oa0/FhamYfDV1go2l9YCkJXkZOqYXlx3al+2lNbiC0ao9YfYUFzND8f3xmEz8QbCbCmtpcjjY0tpLY/9cDTPLNnKvDXFXDOhD06bwf3zC4hYcGZ9TQWn3eQ/V45k0tBcAApKqlmzu5qRPdPpmpZwzFXKPSwXbMQ4yI3/AR1oJOAg5q0pjgUCANdN7NvuAwGAUwfmkOS0savKx78+2MgtZw6MjgysvJPwhh3AndiMCGHL5FtlB0RahNYMaM2AiEinU+MPMWf5LtYVeZg2rjf9uyQf9rmBUASnPZp/IxSOYLdFv99QXM2F/15IXXDv012baXDvZSfQJcXFjNlfxvad3CeTWdeMxm6arNnt4YTuac1++mtZFv5QpF1l0zkctf4QSwvLue3VlRR5fABMHJDNzOmjcdg6Rt6Tf76/nvvnR6s6P/ujMYzvm0bpk04+9ozil7vuwG348FluUt0G3/zxbAyjY7xvaT3NucdVMKBgQERE4sQbCFHjC+G0m9z55hpe/XrnAY+98fR+bCuv481vdvGH84cy45Q+h3WNl77cji8Y5vXlu9hQXM1DU0/ilAHH0DqFo/Dogs08+unm2DqObukJzLvlVBKdHW8iw22vruS5pdvolZUYnVq29FpeXbaO3+y6nVS7H0/IRbLTYMUdkzHNjhXwScvTAmIREZE2kOi0x25c/3HZCaS47cxetBWAM4fm8v8uOI6P1pfwu9dW8eBHm2LnPTB/I5eN6h6ro9Bg2dYKPl5fwg9G96B7RiIvfbmdX728otEx1z35JfN/+R26piW08LtrOe+uKsIfCvPntxsv3r79e0M7ZCAA8L/nDuajdSVsLfMyd8Vuvj/2MSLhRbCrGocrCUKh+gxYnfaZrbSSjvkXJiIi0sZM0+COC45jWLfoFKCLR3TDNA2mjO7JY58WUli/ZsEwoNIb5NEFm7n1rL1Zct5dVcRPnlmGZcE7q4p4/cYJ/N8HG/e7Tl0wzLi753Ny70x+NLEPEwfkELEsklzt45/4zzeVcsPTy2Kvu6a5eeKa0VTUBhnX7xhP3XoUUtwOLhrRjYc/2cSXW8q5ZGQ+YSs6AtAw8ytsWXTiCRzSStrHJ4WIiEg7ZBgGl41qXAzNZhr88/ITmPLIYjISndxy5kB+/coKHphfwI6KOm48vT///WQTL+2TTrOgpIZLH/qcnZV1OO0mb/30FD5cV8LYvllc9+SX7Kn2s3RLOUu3RIujZSY5eeUn41laWMbf39vANRN6c9XYXjyxsJCemYlceGK3Fl3A7A+FWbmjikF5KaS4D75o+ImFWxq9vuLkngzO6xxTd0/qFa04vGxrBYZhEq6/8XfWZ8SKaAGxtAIFAyIiIq1sRM8MPvnV6TjtJhmJDj7eUMLbK4t47eudvLbPOoOT+2Ry0+n9uXbWF6wrilanHdMnkwG5KQzIjVaz/eAX3+GzglI+XFvMa8t3YlnRqsqn/+PjWDt/f289izeX8enG0ti2i0d2B2Dljioe+2wzPzmtX1xuwstq/Pz+9VW8s6qIVLedB6eOZOKAHIo9Pm598Ru2lXv568XDGd8/m1p/iE/WR4tsXXpSdzbtqeHybwVPHdnInukAbCypodIbiN382+sDNU0TktagBcRaQCwiIm3MHwrz0pc7+Mf766n0Bumdlcht5w5h8nF5AMxaWMgdb64BomsRLj2pe5PtfLaxlOe+2MZ7q4oIRQ78z7vbYZKb6mZ8v2w27alhaWF0ROHL308iO9kVO64uEGbFjkr6ZCfRJdXdqI1IxCIQbpzN6MO1xcyY/WWj42ymwZ8vGsa8NcV8uK6kyf50S0/gs9+c3inz6Z/+j48pLK3liemj2bRzA3fNq2JwFyfrSgIArP3DySQk5bRxL6W90QJiERGRdsRlt3HV2F5ccGI+nrog3TMa5+2fPqEPQ7qmkpnkjI0INOWUAdmcMiCblTuquH3OKuoCYSYfl8d9H0bXGgzrlsqqnR58wQhby7xsLdvW6PwXvtjOVWN68eSiLby7uojVuzwAOG0mD04dyZn1NRMiEYsZs79g8eZy/nLxML4/ojuBUITfvLIy1tbYvpl0TUvgta938ttX927PS3XHUoY2OG1QTqcMBCA6VaiwtJZlWytINaMBnH2f5EGlz+fh6nUhqafMxO1Ob5tOSoemYEBEROQYkep27JdRqMGYvoe/mHZ49zRe+58JQPTGfc1uD2t3e3h02ii+/+Dn+92MN/j7e+v5+3vr99seCEe45YXl3H/lCMprAmzaU8NH9dN7bnnxG3JT3JRU+ymt8ZOT4uL+KSM4vnsaiU4b2clOHv20EIBLRnbnz98fxp1z17BkcxlnDs2jsLTmsNOqdkQn9crg5WU7mLemmAvT3gYm4qjbAuQDEMEktO01yst+Q27eSGy2o6skLfJtmiakaUIiItKJ7Kqso7w2QFayk4l/+4hQxOLpGWO4+521sZGAtAQH3zuhK1NG92RQXgpTHlnMsq0VB2wzI9FBhTcIwK1nDuSnZwyI7QtHLP781loilsVvzxnc4YqkHa0qb5AJf5tPjT/ECQmr+abuOMYlfcWi2pEAfNT/Ylw9zobht5OcnEdqarc27rG0Byo6dpgUDIiISGe2tLAcw4DRvTOpqgvy0pfbGdU7k+Hd0hplG9pVWcdVjy1hc306VNOAOy44jstH9eCShz5vNJ3o89u+22jdgRzaAx9u5N55G2Kvv5u7i/nF0ZGBD36cRdcufamq2o5p2snI6IvDkahCZHJQCgYOk4IBERGRwxOJWHh8QSq9QQLhCAPr1y6UVPu47ZWVrCuq5poJvfnRxL5t3NP2JxSOMOWRxXxZP/pyzrA83llVBMCCnw+iR14/SkpWEg5HR1+cziSysgZ12nUWcmhaQCwiIiJxZZoG6YlO0hOdjbZ3SXHz+PTRbdSrjsFuM/nFmQOZ+tgSABw2c+/OlXdidH2SxMRsqqt3AxAI1OLzVZKQkNEW3ZUOxjz0ISIiIiLSktIT9y4M3ndZhWv3HIgESUrq0mhqUCBQ05rdkw5MwYCIiIhIG9s3i5TdtGHWFxszek0F04Fp2snJGcr/Z+++w6Mq8zaOf8+09AokIdRQpHeQpmJBQVkVO4gFQXEVVNS17Srr6r4L9q7orgIqqOuuIjaUBQTpvXcInRBKep1y3j+GDBkJSEmYMHN/riuXyZxnzvzmGJJz52mxsd49JpzOgoDUKcFHYUBEREQkwMqHAbdpYj0yVMjd4WXf41arw7fXQGlpAbm5u/F4XGe1Tgk+CgMiIiIiARYdfnQaZ1GpG8uRycHu3+wkbbOFYbN5V2vKz99PVlb62StSgpLCgIiIiEiAlV/KtaDUhe3I15l5Jce0jY8/uklbSUkuhYUHq75ACVoKAyIiIiLVSGGJm4JSNwDXvzvvmN4BhyOK1NROvg3I8vL2EsIrxcsZUhgQERERqUYKnf7zABr/+QemrNx7TLuoqGSsVjtut5OMjOXk52ecrRIliCgMiIiIiFQjhSXuYx57+IsVLN+Z5feYYRhER6cAYJomeXl78biKzkqNEjwUBkRERESqkYJS/56BOvERuD0mD3+xgsLfHIuKSiIhwbvrs7nqbxROioQFQ489qcdZZfXKuU1hQERERKQaKd8zcH7DRH548EJqx4Wz/VAhLUf9xIR52/3mCEREJBAfmwp7ppDvhpLNH1GQvdV3PGfmLeyf4MA1986z+j7k3KAwICIiIlINXNi0JgA3dq7re6xGtIO4SDsv39TO99hfp6zl8f+s+k0gqIHNAI8Jh5yQ81UT8v6TRkHODgrS/43bhIItH3t7CMr3EqjHIOQpDIiIiIhUA+/d1okPbu/EE32b+x6rEe0AoGeTmowb3IV+bWpjtRh8uXQ3a/fm+toZVgeJTW/DenSFUvJyt5Pz34a+r4s9kPvVeWR94sA553ZyZt5C8URHxcOKJGRUehgYPXo0Xbp0ISYmhqSkJPr378/GjRv92hQXFzN8+HBq1KhBdHQ0N9xwA/v37/drs3PnTvr160dkZCRJSUk89thjuFz+4+R++eUXOnbsSFhYGE2aNGH8+PGV/XZEREREzoroMBtXtEoh3G71PdawRpTv80uaJ/HOoI5c1jwJgOnrM/2eb7vgE5Ka3Ukth/95jSMfbhPyc7dT5IYDmz6lIP3fHHaCZ+tH6iEIYZUeBmbNmsXw4cNZsGAB06ZNw+l0csUVV1BQUOBr8/DDD/Ptt9/y5ZdfMmvWLPbu3cv111/vO+52u+nXrx+lpaXMmzePCRMmMH78eEaNGuVrk56eTr9+/bjkkktYsWIFI0eO5O677+ann36q7LckIiIicla9cEMb+rWtze3dGxxzrHfLZABe+98m+rw2m6yCUt8xo8d47LeWktr8NuxH7vLi7BARe+x5yhSEp4HFXrlvQM4ZhlnFu1QcOHCApKQkZs2axUUXXUROTg61atVi0qRJ3HjjjQBs2LCBFi1aMH/+fLp168aPP/7IH/7wB/bu3UtysvcbfuzYsTzxxBMcOHAAh8PBE088wffff8+aNWt8rzVgwACys7OZOnXqSdWWm5tLXFwcOTk5xMbGVv6bFxEREalkxU43N7w3z2+Y0Pu3d6JPqxS/du65d+Dc9gnhTQbj6vQmmZ9WfK/jsEDNO0oVCILIqdzjVvmcgZycHAASExMBWLp0KU6nk969e/vaNG/enPr16zN//nwA5s+fT5s2bXxBAKBPnz7k5uaydu1aX5vy5yhrU3aOipSUlJCbm+v3ISIiInIuCbdbmXRPN+7t1cj32L2fLOXhL1b4tbP2/JjwQaXQfRw2WziJdoiwQg0HRNug5pHhRE4PuOcNwXSXarhQCKrSMODxeBg5ciQ9e/akdevWAGRkZOBwOIiPj/drm5ycTEZGhq9N+SBQdrzs2Ina5ObmUlRU8YYbo0ePJi4uzvdRr169M36PIiIiImdbXISdp65swbJnLqdnkxoAfL18D9sPFvg3LPtrv8VOeNMhJNghLLYpsTZwNLoDuwVMYP+mT9k3IYwDExw4596pUBBCqjQMDB8+nDVr1vD5559X5cuctKeeeoqcnBzfx65duwJdkoiIiMhpS4xyMPHubvRo7A0E//x12/Ebd/sQBpTCNZu8/+0xgei0W/yaOE04sPFjsj45ssqQQkHQq7IwMGLECL777jtmzpxJ3bpH18tNSUmhtLSU7Oxsv/b79+8nJSXF1+a3qwuVff17bWJjY4mIiKiwprCwMGJjY/0+RERERM51D1zaFIBJi3by0OfLefTfK9m8P+/YhuV6CgAien1OYnwaNRwQXu6usMgNe9d9RP6nJ1h6VPsVBIVKDwOmaTJixAi+/vprZsyYQVpamt/xTp06YbfbmT59uu+xjRs3snPnTrp37w5A9+7dWb16NZmZR5fMmjZtGrGxsbRs2dLXpvw5ytqUnUNEREQkVHRvXIObOtXFNOGbFXv577Ld3Pz+fLIKSvlkwQ4e/fdKsgtLK3xu+PXbCBtQQOJ5dxD/mznEuS5wbTm69GhxcTa5ubsp+vU2cj5xUDx7ENkzbiT3UwfmvMH+T64uYeG3G60dr02IqvTVhO6//34mTZrEN998Q7NmzXyPx8XF+f5if9999/HDDz8wfvx4YmNjeeCBBwCYN28e4F1atH379qSmpvLiiy+SkZHB7bffzt13380//vEPwLu0aOvWrRk+fDhDhgxhxowZPPjgg3z//ff06dPnpGrVakIiIiISLLILSxn2yVJW7Mqm1OUBIDk2jP25JQDcd3Fjvw3N1u7NoV5iJLHh5RLA/LsgfTx5Lsg7sr2TAdjqX4/Z9m+4XCVguuCnbse8fpQV4s4bTEnHNzg863ZiM6YQ2fQusgpzsO7+isjGt2Gc/y42W/iJVy5yFYIt8rSuQXFxNqZpEhYWi8ViJX/WQIq2fU6MDcKbDvEOlSq78T9SQ8HsW3Glf0Z0k9ux9vz4xHVZ7H61m6ZJcXEWhmElPDzutGquCqdyj1vpYcAwjAofHzduHIMHDwa8m449+uijfPbZZ5SUlNCnTx/effdd3xAggB07dnDffffxyy+/EBUVxZ133smYMWOw2Wy+Nr/88gsPP/ww69ato27dujzzzDO+1zgZCgMiIiISbEzTZObGTIaMX+L3eI0oB7MevwSLAct3ZjPoXwvp1iiRz4f9ZlSFxwkLh+HaOp4Dpd4JxgD0WQCG7bhhwGpAchjs77UA95Hj0VbIdx9tYwCxNog678iNeTkuVwm5XzfDVrSDmLgmGNdu9tZyouBQ7sa+pCSPQ4c2+Q5FhsdROLmpr7aaDjhY61qMPd+QaAdbkyG4O73F/k+8G7vZDKh13u14un2IYbqwWGy+8+ZMbgWFu7BbIKbJ7RjdPsQ03eTn76ew8KD3+bZw73Wu0RSr9Tc7v51lAQ0D5xKFAREREQlGHo/JxS//ws7DhcccqxkdRmy4jW1HVh76zx+707lhYgUncVIybyh5Wz7BWv8mrJ1fpbg4B4vFSvjav2Hf+TnZLoixQY7TGxoioxtQGNca9nx/wvqibWBevYXI6NpYrWEUFR2iKH8vpd93AMBigDW1H2EZ3xPbbAicP/aYUFAw61aK0j/DYUBEkzs42HA4pmH1f6HVz8GeKce8foQVEuyQnXIjhdv/85uDdaFoNzYDEpreRlZhLq7dR89hNcCscw2e1qOoSFhYLAkJjQDTGygCQGHgJCkMiIiISLBauSubv327loY1onCbJt+s2Fthu7t6NuSvV7c6/omO99f5Iz0IpI8nxwkF7mOblHFYIMwCLtM7ORmAPgswLHbAwDQ9x71xj7J6JzdbGt2Bu91o7GFxFBdnk/Pl0QVqLAZ4THDUv56onv+ksPAQJSW52CxWIn7u4BvyVKnKekoqEBlZk6Kiw8TEpBIdnVxhm6qkMHCSFAZEREQkFMzYsP+YYUNlmqfEMHXkRad/co8Tc8E9FGyZgNP0DreJtnrDQa7LOywo+sg9c2lEIw5mHVn+tM410ObIX9ePDD0qW9HIA5R6TvCaR/56/1u1HGC/1bubsml6MAwLLBhK4eaPvGHF9AaS8je/0dYjvRsuKHR7g0W4xft5mVgbRMc3IS97izdY1LmG2J7vY7dH4naXkp29AwDDsHiDzREJCY2IiEg4latZKarVDsQiIiIiEliXNk/mx4cuZPkzl9Omjnei66Cu9QHYkJHH8p1ZHMgrYcehAk7578QWO0aP8UQ3HUyC3XtjbUQ3Ifq2Umo3v9MbBBoNgQGlOK7dQPyRNkkHphATVQuHI4rwiBrENRlIgh0SE5tS0+Ed4+843p1q0W7sxtFdlA0gzgb2xnf4ejEM48iTu31I5KBSaiU2oVYY1IqMIcHu7XGIPBIEjEaDib+9lIT4NGo5ID48htgjAcZh8bblqpVE3VpI+DXriLvgn0RHpxAWFktkZE3i4xuQmNiEmJjavhKtVgfh4fGndi0DQD0D6hkQERGRELIvp4hp6/YzoEt9Rn6xnB9WZ/gdb1wriqEXNOLWI2HhlJQt41l+NaDfDjNaMBS2feQNCL+ZROxrW3aeH9pj5m3mQCm4TQi3Hh1mlGCHiMZ34Mqci6VgK5boJnDt5hPXV7ZSkccJC++G9I8hbTB0H3dMG9NdSumUFjgKt2HENPVu1vY7XK4SMjPXABAbWzcgQ4RAw4ROmsKAiIiIhLLcYif3f7qMOVsOHnPs/osbc/8lTYgOs/m1P5RfSlrNqDN74d9bJag8VyHuhffhSf8YS4OBHNjyGWEWbxhggHdI0GkvR3qkjpwiJzFhNiyWClbFPMlzvz1jMwvTDzPigjga1/D2cFgs1t99XlVQGDhJCgMiIiIS6kzT5GB+KbERNg7klTBk/GI27c8HoFGtKD67pxsH8kqoXyOS2z9cxOrd2Yy4pAmlbpMrWiWTkVOM1WJwRctkDMPgQF4Jr/1vE7d1bUDL1Eq8vyoLECfqWfgNp9vDmj05tEyNJcxW8Y35lJV7efTfK7iuQx1evLHdMcd3ZxXy7i9bSYoJo1+b2jRNjjmmzZLth7lx7HwA6idG8vqA9kxZsZcHL2tKYtTZX2ZUYeAkKQyIiIiI+Ctxufli8S7enbmVjNzik37ek1c254+9GvPnr1czaeFOAD4a3JkF2w5zX6/GOD0eMCEpNvzMizyJnoUSl5ub31/Ayl3Z3H1BGk//oeUxbRZsO8SADxb4vt709ytZtTubOVsOcn2HutSvEclTX63ms0Xe92O3GtzWrQHP9Gvp60WYuSGTh/+9guzCY3cxHtS1Pv93XZszeaenRWHgJCkMiIiIiFQs/WABV74xm2LniZb18bfwz5fR9/XZZP3mxjjcbsHlNnGbJi9c35ZujWrwzYo9tK4TxyXNk3ztDuaXcCCvhBa1T+2+rNTlYVdWIW9O38y2AwWMuLQJpmnyx0+XAd6/1k9/tBffrdpL/cQoOjXwrvBz50eLmLXpgO88hgFld8bt68Xz9f09uOTlX9h+yH+/BqvF4N1BHXHYLAz7eAlOt0m7evHEhNl8Q67C7RZ++dMlpMRVQvg5RQoDJ0lhQEREROT4/rduP/dPWkaTWtF8OLgzGTnFtKgdy9q9OUxfn8m7v2w9rfNGOawUlHpnAjeuFcV5yTGcn5bIqz9vIr/UxaS7u9G9cQ2/5zjdHjbtz6N5SixWi8F/l+7m1WmbaFs3jtV7ctidVeRra7UYuD3+t7jNkmPYuD8PgA7142maFM2/l3iXJ+2alsjC9MPH1Nm4VhRbDxRgMWDFX6/g/VlbeWfmse+5X9vavHpzO3YdLuL+iUs5XFDKn69qwfUd6x7T9mxQGDhJCgMiIiIiJ3a4oJRIh5Vwu/+Y+xKXmykr9tK6ThzT1u3n1WlHV9u5q2dDGiRGkl/iIiUugif/u4owm8UXAE5GWs0o6iVG0rZOHCt3ZzN/6yFcHpNODRK496JGPPDZckpcJ+61cFgtRDis5BQdO4SnTO24cH557GJueG8ea/bkAnBbt/p8umCnr80lzWox7q7zcbo9TFywg88X72JDhjdYXNo8ibG3dcJhqz4r9isMnCSFAREREZHKUVTq5s0Zm9l+sIB/XNeGhHITZ0tcbqyGwfh52/n79+sB+HxYNw7ll2IY8O3Kvfy4JoNwu4VSlwfPKdydlvUCXN+hDhc3T+LiZrW4/V8L2ZKZz2N9mnFeSgy3f7gIgBdvaEuH+vGs3pPD/9ZnkpFTxB97NeayFslk5hbz1FerualzPXq3SOLv369n6Y4sXB6Tf97RiboJR1cUyily8tq0TaTEhTO4R8NjglKgKQycJIUBERERkbMnv8TFoH8tpG5CBG8P7IBhHF3Kc39uMVFhNvZlF/Hpgh18tmgXpW4PKbHhvonM9RIj2HXYOxyoR+MajLurCzsPFTJv6yEGnF/vuCsGbcnMI8xmpV7iaSw/eg5SGDhJCgMiIiIi1VN2YSmfL97FDR3r8s2KPazbl8uTfZvzp/+sIjHSzjN/aEmN6LBAl1ktKQycJIUBEREREQk2p3KPW31mOoiIiIiIyFmlMCAiIiIiEqIUBkREREREQpTCgIiIiIhIiFIYEBEREREJUQoDIiIiIiIhSmFARERERCREKQyIiIiIiIQohQERERERkRClMCAiIiIiEqIUBkREREREQpTCgIiIiIhIiFIYEBEREREJUQoDIiIiIiIhSmFARERERCREKQyIiIiIiIQohQERERERkRClMCAiIiIiEqJsgS4gkEzTBCA3NzfAlYiIiIiIVI6ye9uye90TCekwkJeXB0C9evUCXImIiIiISOXKy8sjLi7uhG0M82QiQ5DyeDzs3buXmJgYDMM466+fm5tLvXr12LVrF7GxsWf99c9lunZnRtfv9OnanT5du9Ona3f6dO1On67d6Qv0tTNNk7y8PFJTU7FYTjwrIKR7BiwWC3Xr1g10GcTGxuof2WnStTszun6nT9fu9OnanT5du9Ona3f6dO1OXyCv3e/1CJTRBGIRERERkRClMCAiIiIiEqIUBgIoLCyMv/71r4SFhQW6lHOOrt2Z0fU7fbp2p0/X7vTp2p0+XbvTp2t3+s6laxfSE4hFREREREKZegZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphoIqNGTMGwzAYOXKk77Hi4mKGDx9OjRo1iI6O5oYbbmD//v1+z9u5cyf9+vUjMjKSpKQkHnvsMVwu11mu/uzbs2cPt912GzVq1CAiIoI2bdqwZMkS33HTNBk1ahS1a9cmIiKC3r17s3nzZr9zHD58mEGDBhEbG0t8fDxDhw4lPz//bL+Vs8rtdvPMM8+QlpZGREQEjRs35vnnn6f8+gC6dkfNnj2bq6++mtTUVAzDYPLkyX7HK+tarVq1igsvvJDw8HDq1avHiy++WNVvrcqd6No5nU6eeOIJ2rRpQ1RUFKmpqdxxxx3s3bvX7xy6dhV/35X3xz/+EcMweP311/0e17U7/rVbv34911xzDXFxcURFRdGlSxd27tzpOx6qv3t/79rl5+czYsQI6tatS0REBC1btmTs2LF+bUL12o0ePZouXboQExNDUlIS/fv3Z+PGjX5tKuva/PLLL3Ts2JGwsDCaNGnC+PHjq/rtHWVKlVm0aJHZsGFDs23btuZDDz3ke/yPf/yjWa9ePXP69OnmkiVLzG7dupk9evTwHXe5XGbr1q3N3r17m8uXLzd/+OEHs2bNmuZTTz0VgHdx9hw+fNhs0KCBOXjwYHPhwoXmtm3bzJ9++sncsmWLr82YMWPMuLg4c/LkyebKlSvNa665xkxLSzOLiop8bfr27Wu2a9fOXLBggfnrr7+aTZo0MQcOHBiIt3TW/N///Z9Zo0YN87vvvjPT09PNL7/80oyOjjbfeOMNXxtdu6N++OEH8y9/+Yv51VdfmYD59ddf+x2vjGuVk5NjJicnm4MGDTLXrFljfvbZZ2ZERIT5/vvvn623WSVOdO2ys7PN3r17m1988YW5YcMGc/78+eb5559vdurUye8cunYVf9+V+eqrr8x27dqZqamp5muvveZ3TNeu4mu3ZcsWMzEx0XzsscfMZcuWmVu2bDG/+eYbc//+/b42ofq79/eu3T333GM2btzYnDlzppmenm6+//77ptVqNb/55htfm1C9dn369DHHjRtnrlmzxlyxYoV51VVXmfXr1zfz8/N9bSrj2mzbts2MjIw0H3nkEXPdunXmW2+9ZVqtVnPq1Kln5X0qDFSRvLw8s2nTpua0adPMXr16+cJAdna2abfbzS+//NLXdv369SZgzp8/3zRN7z9ci8ViZmRk+Nq89957ZmxsrFlSUnJW38fZ9MQTT5gXXHDBcY97PB4zJSXFfOmll3yPZWdnm2FhYeZnn31mmqZprlu3zgTMxYsX+9r8+OOPpmEY5p49e6qu+ADr16+fOWTIEL/Hrr/+enPQoEGmaeranchvfzlW1rV69913zYSEBL9/s0888YTZrFmzKn5HZ8+JbmjLLFq0yATMHTt2mKapa1fmeNdu9+7dZp06dcw1a9aYDRo08AsDunZeFV27W265xbztttuO+xz97vWq6Nq1atXKfO655/we69ixo/mXv/zFNE1du/IyMzNNwJw1a5ZpmpV3bR5//HGzVatWfq91yy23mH369Knqt2SapmlqmFAVGT58OP369aN3795+jy9duhSn0+n3ePPmzalfvz7z588HYP78+bRp04bk5GRfmz59+pCbm8vatWvPzhsIgClTptC5c2duuukmkpKS6NChA//85z99x9PT08nIyPC7dnFxcXTt2tXv2sXHx9O5c2dfm969e2OxWFi4cOHZezNnWY8ePZg+fTqbNm0CYOXKlcyZM4crr7wS0LU7FZV1rebPn89FF12Ew+HwtenTpw8bN24kKyvrLL2bwMvJycEwDOLj4wFduxPxeDzcfvvtPPbYY7Rq1eqY47p2FfN4PHz//fecd9559OnTh6SkJLp27eo3HEa/e4+vR48eTJkyhT179mCaJjNnzmTTpk1cccUVgK5deTk5OQAkJiYClXdt5s+ff8z9Yp8+fXznqGoKA1Xg888/Z9myZYwePfqYYxkZGTgcDt8vxjLJyclkZGT42pT/pik7XnYsWG3bto333nuPpk2b8tNPP3Hffffx4IMPMmHCBODoe6/o2pS/dklJSX7HbTYbiYmJQX3tnnzySQYMGEDz5s2x2+106NCBkSNHMmjQIEDX7lRU1rUK1X/H5RUXF/PEE08wcOBAYmNjAV27E3nhhRew2Ww8+OCDFR7XtatYZmYm+fn5jBkzhr59+/Lzzz9z3XXXcf311zNr1ixAv3tP5K233qJly5bUrVsXh8NB3759eeedd7jooosAXbsyHo+HkSNH0rNnT1q3bg1U3rU5Xpvc3FyKioqq4u34sVX5K4SYXbt28dBDDzFt2jTCw8MDXc45xePx0LlzZ/7xj38A0KFDB9asWcPYsWO58847A1xd9fbvf/+biRMnMmnSJFq1asWKFSsYOXIkqampunYSEE6nk5tvvhnTNHnvvfcCXU61t3TpUt544w2WLVuGYRiBLuec4vF4ALj22mt5+OGHAWjfvj3z5s1j7Nix9OrVK5DlVXtvvfUWCxYsYMqUKTRo0IDZs2czfPhwUlNTj/lrdSgbPnw4a9asYc6cOYEupdKpZ6CSLV26lMzMTDp27IjNZsNmszFr1izefPNNbDYbycnJlJaWkp2d7fe8/fv3k5KSAkBKSsoxM9HLvi5rE4xq165Ny5Yt/R5r0aKFbzWIsvde0bUpf+0yMzP9jrtcLg4fPhzU1+6xxx7z9Q60adOG22+/nYcfftjXO6Vrd/Iq61qF6r9jOBoEduzYwbRp03y9AqBrdzy//vormZmZ1K9f3/e7Y8eOHTz66KM0bNgQ0LU7npo1a2Kz2X7394d+9x6rqKiIP//5z7z66qtcffXVtG3blhEjRnDLLbfw8ssvA7p2ACNGjOC7775j5syZ1K1b1/d4ZV2b47WJjY0lIiKist/OMRQGKtlll13G6tWrWbFihe+jc+fODBo0yPe53W5n+vTpvuds3LiRnTt30r17dwC6d+/O6tWr/X7ol/1C/e0Pu2DSs2fPY5bs2rRpEw0aNAAgLS2NlJQUv2uXm5vLwoUL/a5ddnY2S5cu9bWZMWMGHo+Hrl27noV3ERiFhYVYLP7/nK1Wq+8vZrp2J6+yrlX37t2ZPXs2TqfT12batGk0a9aMhISEs/Ruzr6yILB582b+97//UaNGDb/junYVu/3221m1apXf747U1FQee+wxfvrpJ0DX7ngcDgddunQ54e+PTp066XdvBZxOJ06n84S/P0L52pmmyYgRI/j666+ZMWMGaWlpfscr69p0797d7xxlbcrOUeXOyjTlEFd+NSHT9C5DVb9+fXPGjBnmkiVLzO7du5vdu3f3HS9bhuqKK64wV6xYYU6dOtWsVavWOb9E1+9ZtGiRabPZzP/7v/8zN2/ebE6cONGMjIw0P/30U1+bMWPGmPHx8eY333xjrlq1yrz22msrXPKxQ4cO5sKFC805c+aYTZs2DcrlMcu78847zTp16viWFv3qq6/MmjVrmo8//rivja7dUXl5eeby5cvN5cuXm4D56quvmsuXL/eteFMZ1yo7O9tMTk42b7/9dnPNmjXm559/bkZGRp7zSzye6NqVlpaa11xzjVm3bl1zxYoV5r59+3wf5VcU0bWr+Pvut367mpBp6tod79p99dVXpt1uNz/44ANz8+bNvqUZf/31V985QvV37+9du169epmtWrUyZ86caW7bts0cN26cGR4ebr777ru+c4TqtbvvvvvMuLg485dffvH7eVZYWOhrUxnXpmxp0ccee8xcv369+c4772hp0WDz2zBQVFRk3n///WZCQoIZGRlpXnfddea+ffv8nrN9+3bzyiuvNCMiIsyaNWuajz76qOl0Os9y5Wfft99+a7Zu3doMCwszmzdvbn7wwQd+xz0ej/nMM8+YycnJZlhYmHnZZZeZGzdu9Gtz6NAhc+DAgWZ0dLQZGxtr3nXXXWZeXt7ZfBtnXW5urvnQQw+Z9evXN8PDw81GjRqZf/nLX/xuwHTtjpo5c6YJHPNx5513mqZZeddq5cqV5gUXXGCGhYWZderUMceMGXO23mKVOdG1S09Pr/AYYM6cOdN3Dl27ir/vfquiMKBrd/xr9+GHH5pNmjQxw8PDzXbt2pmTJ0/2O0eo/u79vWu3b98+c/DgwWZqaqoZHh5uNmvWzHzllVdMj8fjO0eoXrvj/TwbN26cr01lXZuZM2ea7du3Nx0Oh9moUSO/16hqhmmW26JURERERERChuYMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKUwoCIiIiISIhSGBARERERCVEKAyIiIiIiIUphQEREREQkRCkMiIiIiIiEKIUBEREREZEQpTAgIiIiIhKiFAZEREREREKULdAFBJLH42Hv3r3ExMRgGEagyxEREREROWOmaZKXl0dqaioWy4n/9h/SYWDv3r3Uq1cv0GWIiIiIiFS6Xbt2Ubdu3RO2OeUwMHv2bF566SWWLl3Kvn37+Prrr+nfvz8ATqeTp59+mh9++IFt27YRFxdH7969GTNmDKmpqb5zHD58mAceeIBvv/0Wi8XCDTfcwBtvvEF0dLSvzapVqxg+fDiLFy+mVq1aPPDAAzz++ON+tXz55Zc888wzbN++naZNm/LCCy9w1VVXnfR7iYmJAbwXKjY29lQvhYiIiIhItZObm0u9evV897oncsphoKCggHbt2jFkyBCuv/56v2OFhYUsW7aMZ555hnbt2pGVlcVDDz3ENddcw5IlS3ztBg0axL59+5g2bRpOp5O77rqLYcOGMWnSJN8buOKKK+jduzdjx45l9erVDBkyhPj4eIYNGwbAvHnzGDhwIKNHj+YPf/gDkyZNon///ixbtozWrVuf1HspGxoUGxurMCAiIiIiQeVkhsEbpmmaZ/IC5XsGKrJ48WLOP/98duzYQf369Vm/fj0tW7Zk8eLFdO7cGYCpU6dy1VVXsXv3blJTU3nvvff4y1/+QkZGBg6HA4Ann3ySyZMns2HDBgBuueUWCgoK+O6773yv1a1bN9q3b8/YsWNPqv7c3Fzi4uLIyclRGBARERGRoHAq97hVvppQTk4OhmEQHx8PwPz584mPj/cFAYDevXtjsVhYuHChr81FF13kCwIAffr0YePGjWRlZfna9O7d2++1+vTpw/z5849bS0lJCbm5uX4fIiIiIiKhqkrDQHFxMU888QQDBw70pZKMjAySkpL82tlsNhITE8nIyPC1SU5O9mtT9vXvtSk7XpHRo0cTFxfn+9DkYREREREJZVW2mpDT6eTmm2/GNE3ee++9qnqZU/LUU0/xyCOP+L4um1whIiIiocfj8VBaWhroMkROmd1ux2q1Vsq5qiQMlAWBHTt2MGPGDL+xSikpKWRmZvq1d7lcHD58mJSUFF+b/fv3+7Up+/r32pQdr0hYWBhhYWGn/8ZEREQkKJSWlpKeno7H4wl0KSKnJT4+npSUlDPeK6vSw0BZENi8eTMzZ86kRo0afse7d+9OdnY2S5cupVOnTgDMmDEDj8dD165dfW3+8pe/4HQ6sdvtAEybNo1mzZqRkJDgazN9+nRGjhzpO/e0adPo3r17Zb8lERERCSKmabJv3z6sViv16tX73U2ZRKoT0zQpLCz0/XG9du3aZ3S+Uw4D+fn5bNmyxfd1eno6K1asIDExkdq1a3PjjTeybNkyvvvuO9xut28Mf2JiIg6HgxYtWtC3b1/uuecexo4di9PpZMSIEQwYMMC3F8Gtt97K3/72N4YOHcoTTzzBmjVreOONN3jttdd8r/vQQw/Rq1cvXnnlFfr168fnn3/OkiVL+OCDD87ogoiIiEhwc7lcFBYWkpqaSmRkZKDLETllERERAGRmZpKUlHRGQ4ZOeWnRX375hUsuueSYx++8806effZZ0tLSKnzezJkzufjiiwHvpmMjRozw23TszTffPO6mYzVr1uSBBx7giSee8Dvnl19+ydNPP+3bdOzFF188pU3HtLSoiIhI6CkuLiY9PZ2GDRv6bqpEzjVFRUVs376dtLQ0wsPD/Y6dyj3uGe0zcK5TGBAREQk9ZWGgopsokXPFib6Pq9U+AyIiIiIiUj0pDIiIiIiIn4YNG/L666/7vjYMg8mTJ5/ROSvjHFL5qmyfAREREREJDvv27fOt6Ph7nn32WSZPnsyKFStO+xxy9igMiIiIiASh0tJSHA5HpZzrRPs4nc1zSOXTMCERERGRc8DFF1/MiBEjGDFiBHFxcdSsWZNnnnmGsrVgGjZsyPPPP88dd9xBbGwsw4YNA2DOnDlceOGFREREUK9ePR588EEKCgp8583MzOTqq68mIiKCtLQ0Jk6ceMxr/3aIz+7duxk4cCCJiYlERUXRuXNnFi5cyPjx4/nb3/7GypUrMQwDwzAYP358hedYvXo1l156KREREdSoUYNhw4aRn5/vOz548GD69+/Pyy+/TO3atalRowbDhw/H6XRW4lUVhQEREREJeabpCcjHqZowYQI2m41Fixbxxhtv8Oqrr/Kvf/3Ld/zll1+mXbt2LF++nGeeeYatW7fSt29fbrjhBlatWsUXX3zBnDlzGDFihO85gwcPZteuXcycOZP//Oc/vPvuu74NrSqSn59Pr1692LNnD1OmTGHlypU8/vjjeDwebrnlFh599FFatWrFvn372LdvH7fccssx5ygoKKBPnz4kJCSwePFivvzyS/73v//51QXepem3bt3KzJkzmTBhAuPHj/eFC6kcGiYkIiIiIc00Pezbtzwgr127dgcM4+T/NluvXj1ee+01DMOgWbNmrF69mtdee4177rkHgEsvvZRHH33U1/7uu+9m0KBBjBw5EoCmTZvy5ptv0qtXL9577z127tzJjz/+yKJFi+jSpQsAH374IS1atDhuDZMmTeLAgQMsXryYxMREAJo0aeI7Hh0djc1mO+GwoEmTJlFcXMzHH39MVFQUAG+//TZXX301L7zwAsnJyQAkJCTw9ttvY7Vaad68Of369WP69Om+9ytnTj0D1ZzHY7J6dw7r9uYGuhQREREJsG7dumEYhu/r7t27s3nzZtxuNwCdO3f2a79y5UrGjx9PdHS076NPnz54PB7S09NZv349NpuNTp06+Z7TvHlz4uPjj1vDihUr6NChgy8InI7169fTrl07XxAA6NmzJx6Ph40bN/oea9Wqld/uurVr1z5hr4WcOvUMVGceJw9+vprvVu3DMOCF69tyc5d6ga5KREQkqBiGhdq1OwTstStT+Ztr8A7puffee3nwwQePaVu/fn02bdp0yq9xNndtttvtfl8bhoHHc+rDq+T41DNQTRXMvpUtHyXw46rdAJgmPD15DTlFmjQjIiJS2QzDEpCPU7Vw4UK/rxcsWEDTpk39/npeXseOHVm3bh1NmjQ55sPhcNC8eXNcLhdLly71PWfjxo1kZ2cft4a2bduyYsUKDh8+XOFxh8Ph66k4nhYtWrBy5Uq/icxz587FYrHQrFmzEz5XKpfCQDVUUnSYnC2f8Wt+F9xYSXPsoJ59L6VuD8t2Zvm1nbXpAH/6ciVzNh8MULUiIiJytuzcuZNHHnmEjRs38tlnn/HWW2/x0EMPHbf9E088wbx58xgxYgQrVqxg8+bNfPPNN76Jus2aNaNv377ce++9LFy4kKVLl3L33Xef8K//AwcOJCUlhf79+zN37ly2bdvGf//7X+bPnw94VzVKT09nxYoVHDx4kJKSkmPOMWjQIMLDw7nzzjtZs2YNM2fO5IEHHuD222/3zReQs0NhoBoqLvbe8M/O7wbAhdELaB2xHoBl2w/52rncHh7/z0r+s3Q3t324kC2ZeWe/WBERETlr7rjjDoqKijj//PMZPnw4Dz30kG8J0Yq0bduWWbNmsWnTJi688EI6dOjAqFGjSE1N9bUZN24cqamp9OrVi+uvv55hw4aRlJR03HM6HA5+/vlnkpKSuOqqq2jTpg1jxozx9U7ccMMN9O3bl0suuYRatWrx2WefHXOOyMhIfvrpJw4fPkyXLl248cYbueyyy3j77bfP4OrI6TDMssVpQ1Bubi5xcXHk5OQQGxsb6HJ8Dh7cSPqc57l14Y04TTtftBzD0oNRvJj5AD1qZjLx0cHsPFzIlsx8hk5Y4nvemwM7cE271BOcWURERIqLi0lPTyctLY3w8PBAl3PSLr74Ytq3b8/rr78e6FKkGjjR9/Gp3ONqAnE1NHnlIf6+YCAAberE0nngT7j/1RyApYfi+Gzhdv48ed0xz9t+sOCYx0REREREjkfDhKoZl8vJuEVHlxG9+8JGWO2RtG7Rk6Zh2ygxw44JAgPPrw8oDIiIiIjIqVHPQDWxdm8OMWF21u89wJ4cN2E2g+8fvJAmSTEAxFw4gRuWX8OY/Q/4Pe+5a1tRIyqMzxbtJP2QwoCIiEiw+uWXXwJdggQhhYFqYENGLte+PZf4SBsN4r3/S26O/S9Ntv0Xkj4EwLA66N8mkRf2ezCPdOisfvYKYsLtvg3J1DMgIiIiIqdCw4SqgTf/txGXx+RgvpOlu4sw8HBHje9h20fgObqvQELPtxhb73FiLbk8kPQ5MQ7v4w1rRgKQVejkcEFpIN6CiIiIiJyDFAYCLLfYydQ1GX6PXR47j6YR+yFtMFiO7rznCE+gTZPz+LHxrYzsZvMdi3TYaJoUDcDcLdpvQEREREROjsJAgC1P34sHC3bDSQ1rFj2jlvFqvTe8QaD7OL+2hmHB3nE0Rt8FODu+5nfskube9YBnbsg8W6WLiIiIyDlOYSDAFs+dAMAlMfNZ3G86n/75CaIH5RwTBMrY7VFg2MjO3k5RURZ5eXvJytrGJefVBGDyij3M26reARERERH5fQoDAeR2FrA6w7tFd8fIzVi6fYBhdfgNDfothyMKAI/HTVbWNvLy9lFUlEXLZJN2dePwmDB84jJKXZ6z8h5ERERE5NylMBBA+XOGsraoGQAdmzQ5YQgoExGRSGRkTSIiEnzBAMDjymfSPd2Ij7STVejk180HqqxuERERCQ3PPvss7du3r9Rzjh8/nvj4+Eo955n45ZdfMAyD7OxsoHLqq27v8UQUBgLF42TlhkUcdNcgwiim7eXPndTTDMNCfHwDEhIaUbNmc2rW9IaJkpI8osJs9G9fB4BvVuytstJFREREgtUtt9zCpk2bTrp9w4YNef3118/oHIGkMBAgpa5SZhl3AHBh8iHCw8JP6zx2exSGYcHjceF0FtKvbW0AZm8+gMdjVlq9IiIiItWVaZq4XK5KOVdERARJSUkBP8fZojAQICXz72b2vkQAel9w5WmfxzAMwsPjACgoOED7evFEOqxkFzrZuD+vUmoVERGRwLv44ot54IEHGDlyJAkJCSQnJ/PPf/6TgoIC7rrrLmJiYmjSpAk//vij7zlut5uhQ4eSlpZGREQEzZo144033vA77y+//ML5559PVFQU8fHx9OzZkx07dlRYw9atW2nUqBEjRozANE1KSkr405/+RJ06dYiKiqJr167H7JQ8fvx46tevT2RkJNdddx2HDh064fvcvn07hmHw+eef06NHD8LDw2ndujWzZs3yq9kwDH788Uc6depEWFgYc+bMwePxMHr0aN/7bdeuHf/5z3/8zv/DDz9w3nnnERERwSWXXML27duPqfe3Q3y+/fZbunTpQnh4ODVr1uS6667z/T/ZsWMHDz/8MIZhYBjGcc/x3nvv0bhxYxwOB82aNeOTTz7xO24YBv/617+47rrriIyMpGnTpkyZMuWE16oyKAwEgsfJhg1z2FzSGBsuejdLPKPTRUV5k2dR0SGshofODb3nm7/1xP/YRERE5NwyYcIEatasyaJFi3jggQe47777uOmmm+jRowfLli3jiiuu4Pbbb6ewsBAAj8dD3bp1+fLLL1m3bh2jRo3iz3/+M//+978BcLlc9O/fn169erFq1Srmz5/PsGHDfDe15a1atYoLLriAW2+9lbfffhvDMBgxYgTz58/n888/Z9WqVdx000307duXzZs3A7Bw4UKGDh3KiBEjWLFiBZdccgl///vfT+q9PvbYYzz66KMsX76c7t27c/XVVx8TJJ588knGjBnD+vXradu2LaNHj+bjjz9m7NixrF27locffpjbbrvNFyR27drF9ddfz9VXX82KFSu4++67efLJJ09Yx/fff891113HVVddxfLly5k+fTrnn38+AF999RV169blueeeY9++fezbt6/Cc3z99dc89NBDPProo6xZs4Z7772Xu+66i5kzZ/q1+9vf/sbNN9/MqlWruOqqqxg0aBCHDx8+qet12swQlpOTYwJmTk7OWX/tMf8cYzZ44jtz8Kv/rJTzZWauM/fsWWLm5u413525xWzwxHfmkHGLKuXcIiIiwaSoqMhct26dWVRUVDkndJdWznl+R69evcwLLrjA97XL5TKjoqLM22+/3ffYvn37TMCcP3/+cc8zfPhw84YbbjBN0zQPHTpkAuYvv/xSYdu//vWvZrt27cy5c+eaCQkJ5ssvv+w7tmPHDtNqtZp79uzxe85ll11mPvXUU6ZpmubAgQPNq666yu/4LbfcYsbFxR23vvT0dBMwx4wZ43vM6XSadevWNV944QXTNE1z5syZJmBOnjzZ16a4uNiMjIw0582b53e+oUOHmgMHDjRN0zSfeuops2XLln7Hn3jiCRMws7KyTNM0zXHjxvnV1717d3PQoEHHrbdBgwbma6+95vfYb8/Ro0cP85577vFrc9NNN/ldG8B8+umnfV/n5+ebgPnjjz9W+Lon+j4+lXtc9QwEgGma/JDlTZT9Lzn9IULlRUcnA1BYeIBe59UCYO7WgxQ73ZVyfhEREanAgqHwucP737Ogbdu2vs+tVis1atSgTZs2vseSk733A5mZRzchfeedd+jUqRO1atUiOjqaDz74gJ07dwKQmJjI4MGD6dOnD1dffTVvvPHGMX/d3rlzJ5dffjmjRo3i0Ucf9T2+evVq3G435513HtHR0b6PWbNmsXXrVgDWr19P165d/c7XvXv3k3qv5dvZbDY6d+7M+vXr/dp07tzZ9/mWLVsoLCzk8ssv96vn448/PqN6VqxYwWWXXXZSNR/P+vXr6dmzp99jPXv2POb9lP//GxUVRWxsrN//y6pgq9KzS4UMw+Cfd3Tm25V7ubxlcqWcMzw8AcPYjtvtpGktB6lx4ezNKWbuloNc1qJyXkNERETK8Thh20fez7d9BOePPallws+E3e5/fsMw/B4rG97j8Xj3G/r888/505/+xCuvvEL37t2JiYnhpZdeYuHChb7njBs3jgcffJCpU6fyxRdf8PTTTzNt2jS6desGQK1atUhNTeWzzz5jyJAhxMbGApCfn4/VamXp0qVYrVa/uqKjoyv/zVcgKuroMuv5+fmAd1hPnTp1/NqFhYWd9mtERESc9nNPVUX/f8v+X1YV9QwEyHnJMTx6RTMiHZWTx7w/DCIBcLmKfAHgu1UVj10TERGRM2SxQ6Mh3s8bDanyIHA65s6dS48ePbj//vvp0KEDTZo08f2VvLwOHTrw1FNPMW/ePFq3bs2kSZN8xyIiIvjuu+8IDw+nT58+5OXl+Z7jdrvJzMykSZMmfh8pKSkAtGjRwi94ACxYsOCkai/fzuVysXTpUlq0aHHc9i1btiQsLIydO3ceU0+9evV89SxatOiU6mnbti3Tp08/7nGHw4HbfeKRGC1atGDu3Ll+j82dO5eWLVue8Hlng8JAECkLA05nITd0qgvA96v2cSCvJJBliYiIBK9uH8KAUu9/q6GmTZuyZMkSfvrpJzZt2sQzzzzD4sWLfcfT09N56qmnmD9/Pjt27ODnn39m8+bNx9x0R0VF8f3332Oz2bjyyivJz8/nvPPOY9CgQdxxxx189dVXpKens2jRIkaPHs33338P4OtxePnll9m8eTNvv/02U6dOPana33nnHb7++ms2bNjA8OHDycrKYsiQIcdtHxMTw5/+9CcefvhhJkyYwNatW1m2bBlvvfUWEyZMAOCPf/wjmzdv5rHHHmPjxo1MmjSJ8ePHn7COv/71r3z22Wf89a9/Zf369axevZoXXnjBd7xhw4bMnj2bPXv2cPDgwQrP8dhjjzF+/Hjee+89Nm/ezKuvvspXX33Fn/70p5O6FlVJYSCIlA8D7evF06F+PKVuD/9ZujvAlYmIiASxatgjUObee+/l+uuv55ZbbqFr164cOnSI+++/33c8MjKSDRs2cMMNN3DeeecxbNgwhg8fzr333nvMuaKjo/nxxx8xTZN+/fpRUFDAuHHjuOOOO3j00Udp1qwZ/fv3Z/HixdSvXx+Abt268c9//pM33niDdu3a8fPPP/P000+fVO1jxoxhzJgxtGvXjjlz5jBlyhRq1qx5wuc8//zzPPPMM4wePZoWLVrQt29fvv/+e9LS0gCoX78+//3vf5k8eTLt2rVj7Nix/OMf/zjhOS+++GK+/PJLpkyZQvv27bn00kv9eheee+45tm/fTuPGjalVq1aF5+jfvz9vvPEGL7/8Mq1ateL9999n3LhxXHzxxSd1LaqScWT2ckjKzc0lLi6OnJwc3/i3c5nTWciBA+sxDAspKe2YuHAXT09eQ8f68Xx1f8/fP4GIiEgIKC4uJj09nbS0NMLDT2/TT6k627dvJy0tjeXLl9O+fftAl1Ntnej7+FTucdUzEETs9kisVgem6aG4OIfLWnj3H1i+K1tDhURERETkGAoDQSYiwrvhWFHRYWrHRdCmThymCb9uPhDgykRERESkulEYCDIREQkAlJbmYZomXdO84WDFruwAViUiIiJycho2bIhpmhoidJYoDAQZmy0Ci8WKx+PG5SqiXb14QGFARERERI6lMBBkvPsNeDfgKC3Np/2RMLB+X652IxYRERERPwoDQSgsLAbwhoG6CRHUiHLgdJus25cb4MpEREREpDpRGAhCDod3C/CSkjwMw/ANFVqpoUIiIiIiUo7CQBCy2yMxDAOPx4XLVUy7uvGAwoCIiIiI+FMYCEKGYfGfN1A/HtAkYhERERHxpzAQpMrmDRQVZdGubhwA2w8Vkl1YGsiyRERE5DRdfPHFjBw58qTa/vLLLxiGQXZ29hm9ZsOGDXn99dfP6BxSvSkMBKmIiBoYhkFJSS5RdhdpNb09BSt35wS4MhERERGpLhQGgpTNFkZ4uHcDsoKCTF/vwIqd2QGsSkRERESqE4WBIBYVlQR4hwq1rRsLwMrd2QGsSEREpPoxTZPCUldAPkzTPK2aP/nkEzp37kxMTAwpKSnceuutZGZmHtNu7ty5tG3blvDwcLp168aaNWv8js+ZM4cLL7yQiIgI6tWrx4MPPkhBQcFp1STnJlugC5Cq43BEYbdH4HQW0aymB/BOIjZNE8MwAlydiIhI9VDkdNNy1E8Bee11z/Uh0nHqt2NOp5Pnn3+eZs2akZmZySOPPMLgwYP54Ycf/No99thjvPHGG6SkpPDnP/+Zq6++mk2bNmG329m6dSt9+/bl73//Ox999BEHDhxgxIgRjBgxgnHjxlXWW5RqTmEgyEVH1yYraxt1o/KIclg5XFDKr5sPctF5tQJdmoiIiJymIUOG+D5v1KgRb775Jl26dCE/P5/o6Gjfsb/+9a9cfvnlAEyYMIG6devy9ddfc/PNNzN69GgGDRrkm5TctGlT3nzzTXr16sV7771HeHj4WX1PEhgKA0EuIiKBgoIoKC2gf7saTFycyYdz0hUGREREjoiwW1n3XJ+AvfbpWLp0Kc8++ywrV64kKysLj8c7AmDnzp20bNnS16579+6+zxMTE2nWrBnr168HYOXKlaxatYqJEyf62pimicfjIT09nRYtWpxWbXJuURgIARERNSgtLeDGtg4mLYFZmw6weX8eTZNjAl2aiIhIwBmGcVpDdQKloKCAPn360KdPHyZOnEitWrXYuXMnffr0obT05JcQz8/P59577+XBBx885lj9+vUrs2Spxs6d73w5bRERCeTm7iI5ykXv5rWYtv4A783ayqs3tw90aSIiInKKNmzYwKFDhxgzZgz16tUDYMmSJRW2XbBgge/GPisri02bNvn+4t+xY0fWrVtHkyZNzk7hUi1pNaEQYLHYsNsjARjcLRmAr5bt4evluwNZloiIiJyG+vXr43A4eOutt9i2bRtTpkzh+eefr7Dtc889x/Tp01mzZg2DBw+mZs2a9O/fH4AnnniCefPmMWLECFasWMHmzZv55ptvGDFixFl8NxJoCgMhwmaLAKBNbRvDL2kMwL9+TQ9kSSIiInIaatWqxfjx4/nyyy9p2bIlY8aM4eWXX66w7ZgxY3jooYfo1KkTGRkZfPvttzgcDgDatm3LrFmz2LRpExdeeCEdOnRg1KhRpKamns23IwFmmKe7wG0QyM3NJS4ujpycHGJjYwNdTpUqKDhATs5ObLYwzLA0uo7+BYBlz1xOYpQjsMWJiIicRcXFxaSnp5OWlqYVc+ScdaLv41O5x1XPQIgoGybkcpVglKTTLNm77Nj8rYcCWZaIiIiIBJDCQIiw2yMwDO//bperhPMbeMPBjA3H7lYoIiIiIqFBYSBEGIaFWrVaEBGRAED3ei4Apq7ZR2GpK5CliYiIiEiAKAyEEJstnNjYelgsVtql2qkTZ6Wg1M3Pa/cHujQRERERCQCFgRBjtdpJTm6H1Wqj93neySbTN2Ti8bhxOwsDXJ2IiMjZE8JrqEgQqKzvX4WBEGQYBmFhcXRrEAbAnM0HWDzlbr4ZexEFvw4JcHUiIiJVy2q1ApzSbr0i1U1hofePuHa7/YzOox2IQ1RUVC1aJR8i0m6QVejklgU3AjfS6MBOpnUvxWrTcqMiIhKcbDYbkZGRHDhwALvdjsWiv43KucM0TQoLC8nMzCQ+Pt4Xbk+XwkCIcjiiSYivwwWNcvh5Y7Hv8W2l9Vn/v8dp3ff1wBUnIiJShQzDoHbt2qSnp7Njx45AlyNyWuLj40lJSTnj8ygMhLCYmNqMuSkOxzdr2ZJZQMHhTexy1mHhhq20vsIJljPrdhIREamuHA4HTZs21VAhOSfZ7fYz7hEoozAQ4hKjI3l7UBcAXvrXr7yzpQ6Ljb4MVRAQEZEgZ7FYtAOxhDwNkhOfLj0GArAwuxHFTneAqxERERGRqqYwID6dGyaTHJZPVpGHL78cE+hyRERERKSKKQyIT1RYGLfHfQzAO+vqUFJaEuCKRERERKQqKQyIj2F1cH3rSGrZDpLhqsWXyzICXZKIiIiIVCGFAfET3e01BnZrAMD3q/YFuBoRERERqUoKA+LHbo+iQ7F3qND6XXu1VbuIiIhIEDvlMDB79myuvvpqUlNTMQyDyZMn+x03TZNRo0ZRu3ZtIiIi6N27N5s3b/Zrc/jwYQYNGkRsbCzx8fEMHTqU/Px8vzarVq3iwgsvJDw8nHr16vHiiy8eU8uXX35J8+bNCQ8Pp02bNvzwww+n+nbkN8LsETTK+RQrbrKdYWRk5//+k0RERETknHTKYaCgoIB27drxzjvvVHj8xRdf5M0332Ts2LEsXLiQqKgo+vTpQ3Hx0V1uBw0axNq1a5k2bRrfffcds2fPZtiwYb7jubm5XHHFFTRo0IClS5fy0ksv8eyzz/LBBx/42sybN4+BAwcydOhQli9fTv/+/enfvz9r1qw51bck5Vhs4cQ3uo76jt0AbJg1OsAViYiIiEhVMcwzGAdiGAZff/01/fv3B7y9AqmpqTz66KP86U9/AiAnJ4fk5GTGjx/PgAEDWL9+PS1btmTx4sV07twZgKlTp3LVVVexe/duUlNTee+99/jLX/5CRkYGDocDgCeffJLJkyezYcMGAG655RYKCgr47rvvfPV069aN9u3bM3bs2JOqPzc3l7i4OHJycoiNjT3dyxB0SouzGf7K/zEt72IeS5nA8AcnajdiERERkXPEqdzjVuqcgfT0dDIyMujdu7fvsbi4OLp27cr8+fMBmD9/PvHx8b4gANC7d28sFgsLFy70tbnooot8QQCgT58+bNy4kaysLF+b8q9T1qbsdSpSUlJCbm6u34ccyx4WR8Oa0QCk2y9UEBAREREJUpUaBjIyvEtRJicn+z2enJzsO5aRkUFSUpLfcZvNRmJiol+bis5R/jWO16bseEVGjx5NXFyc76NevXqn+hZDgmEYJJ93FQCZWYdgwdAAVyQiIiIiVSGkVhN66qmnyMnJ8X3s2rUr0CVVW8kx4QAcdMXDto/A4wxsQSIiIiJS6So1DKSkpACwf/9+v8f379/vO5aSkkJmZqbfcZfLxeHDh/3aVHSO8q9xvDZlxysSFhZGbGys34dULCUhDoCDrgRoNERDhURERESCUKWGgbS0NFJSUpg+fbrvsdzcXBYuXEj37t0B6N69O9nZ2SxdutTXZsaMGXg8Hrp27eprM3v2bJzOo3+NnjZtGs2aNSMhIcHXpvzrlLUpex05M8lx3jkDhzw18Zz/rwBXIyIiIiJV4ZTDQH5+PitWrGDFihWAd9LwihUr2LlzJ4ZhMHLkSP7+978zZcoUVq9ezR133EFqaqpvxaEWLVrQt29f7rnnHhYtWsTcuXMZMWIEAwYMIDU1FYBbb70Vh8PB0KFDWbt2LV988QVvvPEGjzzyiK+Ohx56iKlTp/LKK6+wYcMGnn32WZYsWcKIESPO/KoIyXHeXhO3B7IKiwJcjYiIiIhUBdupPmHJkiVccsklvq/LbtDvvPNOxo8fz+OPP05BQQHDhg0jOzubCy64gKlTpxIeHu57zsSJExkxYgSXXXYZFouFG264gTfffNN3PC4ujp9//pnhw4fTqVMnatasyahRo/z2IujRoweTJk3i6aef5s9//jNNmzZl8uTJtG7d+rQuhPgLs9uIDbeQW+whIzufGtGRgS5JRERERCrZGe0zcK7TPgMndunzn7KtIIEPz5/OZde/GuhyREREROQkBGyfAQkiHic1zZ0AZO5ZrtWERERERIKQwoBUzGKnVrw3Se6P6qXVhERERESCkMKAHFf9Jr0A2B52ye+0FBEREZFzkcKAHFez2t69BrYdLMF0lwa4GhERERGpbAoDclzNUuIBSD+QT/YnYZjzhwS2IBERERGpVAoDclxpNaOw4CHPFcau0gSKtozTRGIRERGRIKIwIMcVbvVQ37EXgG0lDShwA4v+qEAgIiIiEiQUBuT4LHY6JrsBmJp7KU4P7F33EdmfOGDB0AAXJyIiIiJnSmFATuiuawcB8L/8i9nrTAag0A3OLR+ph0BERETkHKcwICfUpm4cFzaticu08F7BU77HfUOGREREROScpTAgv+vPV7XAMGB6ZhMynLUAKPYA29Q7ICIiInIuUxiQ39Widiwtax/ZjdjdBCOyHh4TXA3u0M7EIiIiIucwW6ALkHNDq9RY1u7NZW2jf3F+FxslxVmUxNbTN5CIiIjIOUw9A3JSWtfx7kb8vw0HefC/+/nsh28p/aqOVhUSEREROYcpDMhJaZXqDQMbMvKYuy2Xt7Z25z9Zl2vegIiIiMg5TGFATkqr1FjqxEf4PfZTbi9cDe/UvAERERGRc5TCgJyUcLuV/97Xg/subsy9vRoBkF5Sn1KXegVEREREzlUKA3LSUuLCeaJvcx68uCEAh9yJ7N30nYYJiYiIiJyjFAbklEVFRFAvMh+AjcX1cc6/O8AViYiIiMjpUBiQ09KsfhoA20obULL1Y/UOiIiIiJyDFAbktLQ4srrQ6qLmOOveqEnEIiIiIucghQE5LT2b1ARgketSSlr9NcDViIiIiMjpUBiQ09KpQQLRYVayi0zW7snGND2BLklERERETpHCgJwWu9XChU1rATB56r9xzbsrwBWJiIiIyKlSGJDTdnfP+gD8kNubzeunaRKxiIiIyDlGYUBOW6e0WvSsuRc3Vr5wDtckYhEREZFzjMKAnJFbL78SgB/21KV07uDAFiMiIiIip0RhQM5I7xa1iLHkc8BVk6Wr52uokIiIiMg5RGFAzkiYI4yONbIBWBp2s4YKiYiIiJxDFAbkjHVsexEAK/eWYM4fEuBqRERERORkKQzIGevUIAGAtcXNKN0yTkOFRERERM4RCgNyxtrWrwHAXmcKGUm3aaiQiIiIyDlCYUDOWGy4ndS4MAA2blkGC4YGuCIRERERORkKA1IpmiRFAbC1pB6uLR9pqJCIiIjIOUBhQCpFk6Q4ALaX1qOk7i0aKiQiIiJyDlAYkErRJCkagB2WjhRv/0JDhURERETOAQoDUinKwkB6bjglHnBv1VAhERERkepOYUAqRfPaMditBvtdSWwrqU+eC1g4LNBliYiIiMgJKAxIpYgNt9PrvFoAfHL4RhbktyB30wSYf1eAKxMRERGR41EYkEpzdbtUAH7Ku5Q/7nqJdw/cDOnjNVxIREREpJpSGJBKc1Wb2gy7qBFt68YCMD2vJ+6Gd2plIREREZFqSmFAKo3dauHPV7Vg/F1dMTDZXNKInfnWQJclIiIiIsehMCCVLjHCoFX4ZgBmr9+hYUIiIiIi1ZTCgFQ+i50L6pYCMNdzrYYJiYiIiFRTCgNSJS6++A4AFuQ0xu0xA1yNiIiIiFREYUCqRKeGSUQ7DHKLTZbvOBDockRERESkAgoDUiXsNivd4rcC8NP/JgS4GhERERGpiMKAVA2Pk8vtXwIwdWc8prs0wAWJiIiIyG8pDEjVsNi5vE0THEYJu5yprJv2RKArEhEREZHfUBiQKpN40ft0j1oGwHdrD2iJUREREZFqRmFAqo7FTt9GbgCmFvbVEqMiIiIi1YzCgFSpvtc8jd1wk16QwPqpDwW6HBEREREpR2FAqlRCpINukUsB+HbNQQ0Vkmpv3d5cnp2ylkP5JYEuRUREpMopDEjVsti5srELgB9zL8Bc+McAFyRyYle9+Svj521n9I8bAl2KiIhIlVMYkCp31dVP4DBKSC+tz9LVc9Q7IOeEHYcKAl2CiIhIlVMYkCoXHxNL75TdAEwquU8TieWckBQbHugSREREqpzCgJwVA/pcA8CPe+uS/+u9lJbmk5OzC7dbvQRSfRQ73b7Pk2LCAliJiIjI2aEwIGdFz8ZJ1LfvosiM4IbpbVi8aRM5efvZv3+VAoFUGxk5xb7PY8JsAaxERETk7FAYkLPCao/kugZ7AdhYnMagT/fR9/1MNh1wkp+fEeDqRLz2Zhf5Pnd5zABWIiIicnYoDMhZM/DaOxlyfgQ9GkYAUOg0+WRJAYWFB/B4XAGuTgT2KAyIiEiIURiQsyYmMpa7o97gZcdlfFh/JAC/bClm/f5SiouzA1qbCMChglLf5y63woCIiAQ/hQE5ayLDYwnbNwWAFuFb6BW9ELcJj36TRVbu4QBXJwLucr0BLo8ngJWIiIicHQoDctYY1jBqNBtMrA2sBrxW72WSYhxkFXlYtvOQhgpJwJXvDdAwIRERCQUKA3J2dR9HdNPBJIdBYrOBnJ9WA4DV+0opKDgQ4OIk1LnL9Qa43OoZEBGR4KcwIGdf93EwoBS6fUjH+gkArNnnpLDwYIALk1DnNtUzICIioUVhQALjyC7EHRt4w8DqfaXkFhWTn78f09RNmARG+QCgCcQiIhIKFAYkoFqnxtKgRiR5JSZj53l3JT54cD2u0vxAlyYhyFMuDLjVMyAiIiFAYUACyma18OzVrQD476pCbhh/gPnT3+LwxBg88+8KcHUSasr3DDg1Z0BEREKAwoAE3CXNk3i+f2sAMvI8PLjiD1y8+d/8Z8kW8DgDXJ2EErd6BkREJMQoDEi1cHu3Biz+S2+SY8MAKPRE8uSex1j386MBrkxCSfkA4FQYEBGREKAwINVGrZgwPryzC9e1r02UpQAPVr5dc0i9A3LW+PcMaJiQiIgEv0oPA263m2eeeYa0tDQiIiJo3Lgxzz//vN8KMaZpMmrUKGrXrk1ERAS9e/dm8+bNfuc5fPgwgwYNIjY2lvj4eIYOHUp+vv+k0lWrVnHhhRcSHh5OvXr1ePHFFyv77chZ1rpOHK8N6MifW60EYHpxH9/KQyJVzX/OgHoGREQk+FV6GHjhhRd47733ePvtt1m/fj0vvPACL774Im+99ZavzYsvvsibb77J2LFjWbhwIVFRUfTp04fi4mJfm0GDBrF27VqmTZvGd999x+zZsxk2bJjveG5uLldccQUNGjRg6dKlvPTSSzz77LN88MEHlf2WJAAu/8MTWPCwKb8GK398mBembuCRL1awJVOrDEnV0WpCIiISamyVfcJ58+Zx7bXX0q9fPwAaNmzIZ599xqJFiwBvr8Drr7/O008/zbXXXgvAxx9/THJyMpMnT2bAgAGsX7+eqVOnsnjxYjp37gzAW2+9xVVXXcXLL79MamoqEydOpLS0lI8++giHw0GrVq1YsWIFr776ql9okHNTUkwEzcO3sK74PK6d1RvYCkBRqZP3bu8S2OIkaPnvM6BhQiIiEvwqvWegR48eTJ8+nU2bNgGwcuVK5syZw5VXXglAeno6GRkZ9O7d2/ecuLg4unbtyvz58wGYP38+8fHxviAA0Lt3bywWCwsXLvS1ueiii3A4HL42ffr0YePGjWRlZVVYW0lJCbm5uX4fUk1Z7PRIdR/z8Kz12ymZe08ACpJQUL43QDsQi4hIKKj0MPDkk08yYMAAmjdvjt1up0OHDowcOZJBgwYBkJGRAUBycrLf85KTk33HMjIySEpK8jtus9lITEz0a1PROcq/xm+NHj2auLg430e9evXO8N1KVep54a2+z19K/Rs1rYco9EQyY8UyTSqWKuHWDsQiIhJiKj0M/Pvf/2bixIlMmjSJZcuWMWHCBF5++WUmTJhQ2S91yp566ilycnJ8H7t27Qp0SXICXRsn0TQml86RK+ketYSe0d6hZtNyz6dkrjYkk8rnN0xIqwmJiEgIqPQw8Nhjj/l6B9q0acPtt9/Oww8/zOjRowFISUkBYP/+/X7P279/v+9YSkoKmZmZfsddLheHDx/2a1PROcq/xm+FhYURGxvr9yHVV6TDxrS/DGTSn4bhsJj0ifUOEZtT0JXCrRPVOyCVrvxyohomJCIioaDSw0BhYSEWi/9prVYrniO/ZNPS0khJSWH69Om+47m5uSxcuJDu3bsD0L17d7Kzs1m6dKmvzYwZM/B4PHTt2tXXZvbs2TidR28Ip02bRrNmzUhISKjstyUB5IisSVKLIVwat4oISwmZrlp8dOg6nnz/ff69RL07UnnKjwzSMCEREQkFlR4Grr76av7v//6P77//nu3bt/P111/z6quvct111wFgGAYjR47k73//O1OmTGH16tXccccdpKam0r9/fwBatGhB3759ueeee1i0aBFz585lxIgRDBgwgNTUVABuvfVWHA4HQ4cOZe3atXzxxRe88cYbPPLII5X9lqQ66PYh4bfm07t1fQDeOjCUz3ek8cR/V7Fk++EAFyfBwr9nQMOEREQk+FX60qJvvfUWzzzzDPfffz+ZmZmkpqZy7733MmrUKF+bxx9/nIKCAoYNG0Z2djYXXHABU6dOJTw83Ndm4sSJjBgxgssuuwyLxcINN9zAm2++6TseFxfHzz//zPDhw+nUqRM1a9Zk1KhRWlY0mFns3H/JeXy76ujwMNOE579fzzfDewawMAkWbu0zICIiIcYwy28NHGJyc3OJi4sjJydH8wfOIS/9uIqVa2fzUMxoBmwfi9u0MOPRXjSqFR3o0uQcd9PYeSze7l2aOC7Czsq/XhHgikRERE7dqdzjVvowIZGq9qcrmvNyjQeoY9/L+RHLAPjvt+8HuCoJBi71DIiISIhRGJBzjmF1EN1oIAD94qYBMH5LfQ7m5geyLAkCnnIBwKkdiEVEJAQoDMg5KeqCcURY4eLoeTQP20yBJ5LXPxsX6LLkHOfSDsQiIhJiFAbknGRYw0hoNoSkMJMHan0IwKfpjbj1g/nkl7gCXJ2cq347gTiEp1SJiEiIUBiQc1e3D3HcWsr5SXlcHD0XgHnbDjN5+Z4AFybnqt/OE1DvgIiIBDuFATnnRZXs4K8pr3Bh9AIAvl25N8AVybnqt2FAk4hFRCTYKQzIuc1iJ6LJXURYS3m4lndFoUXbD7MlU5OJ5dT9tidAk4hFRCTYKQzIOc/o+j7hFkixH6BX9ELvRmTfrdN4bzll6hkQEZFQozAg5z6LHXuad6nRh9vuxm41mLXpADM2ZAa4MDnX/Pbm3+lWGBARkeCmMCBBwd7tA+izgNpdRzLkgjQA/u/79frLrpyS3w4T0vePiIgEO4UBCQo2WwQYNtxuJ8MvTiM+0s62gwWaTCynxGNqzoCIiIQWhQEJChaLFZstDAA7RdxzYSMAPl2wI5BlyTnG9Zubf/UMiIhIsFMYkKAREZEIQH5+Bte2TwVg+a5scoudgSxLziHH7jOgngEREQluCgMSNKKikjAMC05nIbUi3TSqFYXbYzJvy8FAlybnCLepTcdERCS0KAxI0LBYbERG1gC8vQMXNa0FwOTlmjcgJ+eYngGtJiQiIkFOYUCCSlRUMgAlJbnc3CkFw4CpazNYuSs7sIXJOaEsDDhs3h+N6hkQEZFgpzAgQcVmCyM8PA6AujHFXN+hLgC3fbiQmRszGTJ+MXd+tIjlO7MCWaZUQx6PSdm9f1hZGNBqQiIiEuQUBiToREbWBKCw8CAjezfFYbWQV+zirnGLmbEhk1mbDnDPx0soKHEFuFKpTsrPFwizWQH1DIiISPBTGJCgExYWh9Vqx+NxUTOihKeuak5azSgsxtE2B/NLmTB/e8BqlOqn/HyBsp4Bj8KAiIgEOVugCxCpbIZhEBFRg/z8DAoKMrmrZzPu6pnGofwSDMPg+9X7eGbyGuZtOcT9FzcJdLlSTZQPA3arNzn+dnUhERGRYKOeAQlKUVG1MAyD0tJ8CgoyAagRHUZilIN2db1zCtbvy8XUzZ4c4fJomJCIiIQehQEJSlarg6ioJABycnaRn58BHiemaZIaXYzFgEMFpRzILwlwpVJdlB8S5NAwIRERCREKAxK0YmLqEB3tXWo0d+695H7qIHvGTZQuvIe6tl0AbJj5t0CWKNVI+V4AW9kwIYUBEREJcgoDErQMwyA2ti6R4XGwZwr5Lija8V/Y8x1NwrYDsH7bJvA4A1uoVAtlN/5Wi4HV8IYBj4aRiYhIkFMYkKAXn9iEhCYDsRpgNSDKCk3C0gHYYOsNFnuAK5TqoGyysNViYD2y9JTmDIiISLBTGJCQEHHRJJKa3UmSA6Jt0CS1FgDrXa18bQ7k5FPq0iZTocrt9t7428qFAQ0TEhGRYKcwICHD6DEeY2Ap1oGlNO0yGICtB/IpcbqY/PkjdB89nYfe+SCwRUrAuDzeIGg1joYBDRMSEZFgpzAgocViB4uduglRRDsMnG6TuRu2MXLFZbiw8eO+euTPHhroKiUAym78rVYDi1HWMxDIikRERKqewoCEJPuav9LYuhqAv361xO/YL6vXwfy7AlGWBFDZ/ACbxcDmGyakNCAiIsFNYUBCj8eJY/eXdIzwhoFdRd5NyKIt+QD8kNMD0sdrlaEQ4zoyZ8BiGFgs6hkQEZHQoDAgocdiJ7zxYLpGLfM9lGjN4oNuiwD4KbcXW2reT15BnvegQkFIKBsmZCu3tKhbcwZERCTIKQxISLJ0+4D2kRt9X9/ROJ0e17xC94bhuLHSe8ZVdB09nY0T21M80QELNI8g2JUNE7JaDaxlm46pa0BERIKcwoCEJoudmucN4qU6/8fgxH/zR/tz4HHyeJ3PcBglABR6IpmZmUyWE9xbP1IPQZDzlIUBo3zPQCArEhERqXoKAxKybD0/5qbOzXi27seEN70DgLa5H/JCnTG+NquKWmAChW5g4bDAFCpnhctz7KZjHu0zICIiQU5hQEJb93EwoBS6fQgWO9bGQ7gucTEfNXwWgDVFLQDIc0HOpvF45t4ZwGKlKrl9qwlZji4tqjkDIiIS5BQGRCz2o593+xAGlNLp9lkA7HTWpSjcGwgK3JC1+WMNFwpSZWHA4re0qMKAiIgEN4UBkd+y2ImLiqRhjUgA9nb6H9E276ESDxTPUe9AMHKX22fAojAgIiIhQmFA5DhapsYCsC6jiNimg4m2eh8vTv9MvQNByH/OgPcxhQEREQl2CgMix9Eq1bsZ2bp9udB9HGGNBgFQXPsaTMMWyNKkCrjLhwFDPQMiIhIaFAZEjqNlbW/PwJo9OQA4LvgES52r8eyeQqkmEgcdvzBg8f5o1ARiEREJdgoDIsfRtm4cNovB1gMFfL18N/O3ZGLf9z0ABVs+AVdhgCuUyuTyeDcYs5UbJqSlRUVEJNgpDIgcR43oMG7qXA+Ah79Yya0fLmEi/wdAsQeyJkZpZ+Ig4jGP9gxoArGIiIQKhQGRE3i4d1Pa14v3fT35YFcij/yrKXYD27QzcbBwuY+dM+BSGBARkSCnMCByAkmx4Uwe3pPlz1yOw2Zh28FC9qY8BIAJuBsO9t+nQM5Z5ZcWLdtnwKM5AyIiEuQUBkROQkKUg0ua1QLgk8KhWK9cAn0W4OnyToArk8pSNlnYYmiYkIiIhA6FAZGTdPeFjQD479LdHC5xgGHD7dYQoWDh6xmwamlREREJHQoDIiepS8NEWteJpdTt4bu1hRwudOPRfIGgcXTOgEU9AyIiEjIUBkROQZeGiQC88+tBhn5+iLyi4gBXJJXFt5qQgW/OgPYZEBGRYKcwIHIKOtRP8H2+P9/DxEUZAaxGKpPLc7RnwFo2gVg9AyIiEuQUBkROQYdyy4wCTF51ODCFSKUrv5qQRUuLiohIiFAYEDkFdRMiuOi8WtRLCAdgZ5aTQ/kaKhQMysKAxWJgs2ppURERCQ0KAyKnwDAMPh5yPrMfv4SGiTYAFmzeEeCqpDK4KugZ0ARiEREJdgoDIqfBMCy0r+edP7B0+4EAVyOVweMptwOxbzWhQFYkIiJS9RQGRE5Tl7QkAFbvLaK0ND/A1ciZcpUPA76eAaUBEREJbgoDIqepYwPvMqNrM5wcPLQVt7vUd8zjcVGQtxfT1M3kuaLsxt9WvmdAo4RERCTIKQyInKbzkmOIdFgpdJr0eGM3L/+4EvPIhNPsmQPJ+bIOuTNvCXCVcrLKhgSVHyakpUVFRCTYKQyInCarxaBOfITv6/fmZPL9qt24nYUU7/gPAAXb/4Nn3p2BKlFOQVnPgNVi+HYgdmmYkIiIBDmFAZEzMPD8+n5f/+vXrRSX5kNEXd9jxVs/Bo/zbJcmp6iiOQPKAiIiEuxsgS5A5Fx2V8+G/KFdbYoKD3PZG8tZsbuApdv20KRoNwZgAsW1ryPSYg90qfI7yvYUsBrl5wxomJCIiAQ39QyInAHDMEiKCaderWQub+YdMvTx4sPkJt3EnIKLKAlvSMnOrzHnDwlwpfJ7XEdmC1ut5ZcWVRgQEZHgpjAgUgksFivDerUA4H+biuk7504e2/M4/97bxds7sGWchgpVc+5ym45ZLf6PiYiIBCuFAZFK0qFhbfq1SvR77H/F1wBQ4AYWDgtAVXKyyoYEWQztQCwiIqFDYUCkEj3bvyOXNqvBNe1SANicn8A+ZzKlHsjaNB5z7h3qIaimXOV6BmwW749Gj+YMiIhIkFMYEKlEtWLC+Oiubrw5sBPdGnl7CRaF3Y8BFLnh4KZPcE1ywIKhgS1UjuH2zRmwcCQL+AKCiIhIsFIYEKkifVp5ewdmFPcmofEAAJwm5LuBbR+ph6CacZdfTcjQpmMiIhIaFAZEqkhZGFiyI4u8juNJaDIQAKcHaDQEtNxotVJ+ArHNqqVFRUQkNCgMiFSR1PgI2taNwzThs0U7cXX5EPoswHXFQsyu/wx0efIb7nKbjmkCsYiIhAqFAZEqVNY78Oq0Tdz6r6VgCcM0rBw6tAmPxxXg6qS88mFA+wyIiEioUBgQqUJlYQBg9Z4c3p1byLhF+Xy6KJPtu1eRl7c3gNVJeS6PB1DPgIiIhBZboAsQCWZNkqJ5om9zXpi6AYBPl2T5jv17RSEfDXBTz2IjKiopUCXKEUeygN+cAS0tKiIiwU49AyJV7L6LG7Ni1OVc36EOV7VJ4YaOdUmMsrM3103fDzJ5a/pGTN10BlxZz4DFcnQ1IS0tKiIiwa5KwsCePXu47bbbqFGjBhEREbRp04YlS5b4jpumyahRo6hduzYRERH07t2bzZs3+53j8OHDDBo0iNjYWOLj4xk6dCj5+fl+bVatWsWFF15IeHg49erV48UXX6yKtyNyxuIjHbx6S3veHdSJV25ux9u3dvQdG7col5z8nABWJ+C/mpBFcwZERCREVHoYyMrKomfPntjtdn788UfWrVvHK6+8QkJCgq/Niy++yJtvvsnYsWNZuHAhUVFR9OnTh+LiYl+bQYMGsXbtWqZNm8Z3333H7NmzGTZsmO94bm4uV1xxBQ0aNGDp0qW89NJLPPvss3zwwQeV/ZZEKl2PxjX5aHBnAEpc8L+129U7EGC+fQYs2mdARERCR6XPGXjhhReoV68e48aN8z2Wlpbm+9w0TV5//XWefvpprr32WgA+/vhjkpOTmTx5MgMGDGD9+vVMnTqVxYsX07mz94bprbfe4qqrruLll18mNTWViRMnUlpaykcffYTD4aBVq1asWLGCV1991S80iFRXlzZP5q4edRk3bzfjF2RyafMMEuNrB7qskOVyV7CakAKaiIgEuUrvGZgyZQqdO3fmpptuIikpiQ4dOvDPfx5dUz09PZ2MjAx69+7teywuLo6uXbsyf/58AObPn098fLwvCAD07t0bi8XCwoULfW0uuugiHA6Hr02fPn3YuHEjWVlHJ2mWV1JSQm5urt+HSCDd2aMJ0WFW1mQ4GT9v+wnbOp2FuJ0F2rm4imhpURERCUWVHga2bdvGe++9R9OmTfnpp5+47777ePDBB5kwYQIAGRkZACQnJ/s9Lzk52XcsIyODpCT/1VVsNhuJiYl+bSo6R/nX+K3Ro0cTFxfn+6hXr94ZvluRM9OwZhQP924CwPz0fNxuJyUlebhcJX7tSkryODBjIJmfRFM00QELhgai3KBW1gtgs1gUBkREJGRUehjweDx07NiRf/zjH3To0IFhw4Zxzz33MHbs2Mp+qVP21FNPkZOT4/vYtWtXoEsS4YKm3hC7ep+TPXtXcujQJg4cWEtR0WFfm4K8PbBnCiaQ6wJz60fgceJxFWO6SwNUeXA52jOAb58Bj4nmcoiISFCr9DBQu3ZtWrZs6fdYixYt2LlzJwApKd5NmPbv3+/XZv/+/b5jKSkpZGZm+h13uVwcPnzYr01F5yj/Gr8VFhZGbGys34dIoDVNiiYuwkaxy2RDppONmU5W7CkhO2cXHo8bt9tJ8dInfO3dJhSFp5E96zYyPo4g65Mw9RRUgqNzBizYjvQMgDcQiIiIBKtKDwM9e/Zk48aNfo9t2rSJBg0aAN7JxCkpKUyfPt13PDc3l4ULF9K9e3cAunfvTnZ2NkuXLvW1mTFjBh6Ph65du/razJ49G6fz6PjpadOm0axZM7+Vi0SqO4vFoGeTmgAM+/Iwd31+iPv+c5jbPsngzalz2bpjCeyZgsMCsUem/GfnpFOY/m8Aij1Hewrk9HnMY5cWhaP7D4iIiASjSg8DDz/8MAsWLOAf//gHW7ZsYdKkSXzwwQcMHz4cAMMwGDlyJH//+9+ZMmUKq1ev5o477iA1NZX+/fsD3p6Evn37cs8997Bo0SLmzp3LiBEjGDBgAKmpqQDceuutOBwOhg4dytq1a/niiy944403eOSRRyr7LYlUuSf6NifKYfV7bOshF6/PzuPBybkUJl9PuAWiYhsTYT32+a6Gd4DFfpaqDU5lG4xZjKMTiOHozsQiIiLBqNLDQJcuXfj666/57LPPaN26Nc8//zyvv/46gwYN8rV5/PHHeeCBBxg2bBhdunQhPz+fqVOnEh4e7mszceJEmjdvzmWXXcZVV13FBRdc4LeHQFxcHD///DPp6el06tSJRx99lFGjRmlZUTknNagRxbi7zqd5Sgzt6sbx4KWNfMc2ZLr4sOABIgbmY/TfQnyT24mxQaQV7Bbg8jk4O7yKy1VMSUkeAE5nEaapu9hT4dt0zGr4DRNyKg2IiEgQM8wQnh2Xm5tLXFwcOTk5mj8g1c7e7CI2ZuRx1/jFAFzYtCZ14iO4/+Im1N80HNLHk1P7ZgqaPX7cc1gsNsLD44iLq49hVMmG40Gj3d9+JqfIyfRHe9EgMZImf/kRgOXPXE5ClON3ni0iIlJ9nMo9bqVvOiYilSM1PoLU+AjOT0tkUfphft18EIBF6Yf54aF/Ed71A+zFuSxfs4moMIOmNW0YhuF3Do/HRWHhIcAgPr5BAN7FucO3mtBvhgmpZ0BERIKZ/lQoUs3d2LGu39fbDhZ4Nyiz2Pl8WQ7DvzrM4M8O8d2mSGrVaolhiTh6Y2v1ziMoLDyIy1V8tks/p5TfdMwwDOxWbyAoW2VIREQkGCkMiFRzV7WtTVrNKDo3SGD09W0AeHP6Zl7+aSN//369r91/lh9g1uZc+ozdxeM/uKhZqzXJyW0JD48HoKDgQCDKP2eUnzMA3s3HQGFARESCm8KASDUXHWZj5p8u5ss/dufa9qnEhNkoLHXz9swteEzo0jABh9XC5sx87v54CbnFLuZvO8QXS707cUdF1QKgsPAAJSW5gXwr1VrZEqLWI0OtykKBhgmJiEgwUxgQOUcYhkGkw8aDlzUlymGlbkIEb9/agS+Gdad3y6Rj2o/9ZStuj0lYWCwREQmYpkl29g7tqFsB0zR9m4uVzRewW9UzICIiwU9hQOQcc89FjVj7XF/mPHEpf2ibisVi8MjlzXzHn7u2FXERdvZkF3HVG79yML+E+PiGWK123O5ScnJ24PG4A/gOqh93uW2Gy4YHlS0v6nSrZ0BERIKXwoBIEGiSFM3rt7RnSM80BnSpzw1HJh1v3J9H57//j3s/WUZYZAoAhYWHOHhwg/YhKMdVLgwcyQK+noHyQUFERCTYKAyIBIn+Heow6uqWOGwWHrniPAb3aOg79vO6/fy8oYTExCYARzYo0/yBMh7z2J6BsuFCLs0ZEBGRIKYwIBKEosNsPHtNK165qZ3vsbGztvrmDwC43aWBKq/aKd8zUBYCfBOINWdARESCmMKASBC7oVNd1vytD1EOK9sOFjB/2yGsVu9uugoDR7ndx4YBu5YWFRGREKAwIBLkosNsXNuhDgBfLN6lMFCBsknCFqOCngENExIRkSCmMCASAq47EgbmbD6IxeLdlVhh4CjnkWFCZZOGAWxaWlREREKAwoBICGhbN44wm4VDBaXsyHIB4HYWBLiq6sPp8v71v3wYsJdNINbSoiIiEsQUBkRCQJjNSvt68QAs25UPq5/D/WNnzHmDA1pXdVE2TMh+ZGgQHB0m5NLSoiIiEsQUBkRCRNe0RADGzd3Bos27MU3I2TwB5t8V4MoCr2zFIFv5noGyYUKaMyAiIkFMYUAkRFx3ZCOyzZkFjNz9HC9kjiCjNJriLePBVRjY4gKsrGfAUX7OgEVLi4qISPBTGBAJEWk1o+jTKtn39ZScvtyz8xUOlhoc/jQKc/6QAFYXWGV//S8/TMiqpUVFRCQEKAyIhJAx17fl7Vs78Ie2tQHY5azDhpImFHvg4MZxlBZmBrjCwCh1VTRMSDsQi4hI8FMYEAkhCVEO/tA2lbdv7chVbVIAeCnzAXLdUZS4DQ5+nkzpr7cFuMqz72jPwLFLi2qYkIiIBDOFAZEQdXlL75ChjcWN6Lv1C/ps/Zxdpakc3DyR7Bk3Bri6s6ui1YS0tKiIiIQChQGREPWHtqk8eFlTUuPCASjwRDE550oACrf/F1dpXiDLO6vKhgn59wxoaVEREQl+CgMiIcputfDI5efx8yO9GNyjIQDTCvtiMaxQ5xryCw8HtsCzqGyYUNkKQqAdiEVEJDQoDIiEuOgwG3/p14Ka0WEcLIlgbqt10GYUhYUHyc3djcfjCnSJVc63tKitgh2INYFYRESCmMKAiGC3WrizewMA3p+7DyyRAOTn7+fAgfWYZnDfEJdNEtYEYhERCTUKAyICwO3dGxAfaWfT/nzGL3UTFVULALe7lJKS3ABXV7XKegb8hglpArGIiIQAhQERASA+0sHo69oA8MWSvURG1/UFgpMKAx5nVZZXpcrmBdhtmkAsIiKhRWFARHyuaJVCjSgHOUVOFm47TFhYHACFhYdwOgt97VyuEg4d2kRh4SFM08PB/93AgY8duOfeEajSz4hvaVG/ngGL3zEREZFgpDAgIj5Wi8EVrbz7D3y1fDdhYbHY7ZGYpodDhzbjdjvxeFwcPryZkpI8srO3k5u9ndKdX+H0wOHNn8D8uwL8Lk5dqfvYTcd8OxBrzoCIiAQxhQER8XNLl/oAfLNiL7sOF1GjxnnY7RF4PC6ysraSmbkWl6vE176gKAvq/AEApwecW8efc0OGym74bRVMINYwIRERCWYKAyLip329eC46rxZuj8mt/1rAnC2HiY9PA6C0tACPx4XdHkFMTCqG4f3reWTXt4locAMABW5g0R+9JztHQoFvaVFrBROItbSoiIgEMYUBETnGc9e0IibMxu6sIu74aBHz0/OJjvYOH4qKqkXNms2JialNrVqtSExsTFxcfaJ6/hOAQjcUbf6I/F8GkPvpuTGPoKKlRe3adExEREKAwoCIHKNhzSi+vK87zVNiAHj0y5UcLIknJaU9cXH1MQzvjw6bLYzw8HgMw8DhiCba5n1+lhNyt31BvguyzoF5BL6lRa3HriakCcQiIhLMFAZEpELNU2L57309aJYcw4G8Eu75eAmlbu8xj8dk2c4sCkrK7U5ssRPT5E4cv/mp4vSAuW18tR4y5KpgmJDdojkDIiIS/BQGROS4osJsTLynK7Viwth6oIBB/1rIrsOF3PvpUq5/dx73TVzm197oMZ7EprcRZYUIq/cxE3A1vAMs9rP/Bk5SaQUTiK0W9QyIiEjwUxgQkROqGR3Gize0xWGzsHRHFle+8SvT1u0HYPamA6zdm+PX3tLzE+LOG0yCHRz1r4c+C3C1fzEQpZ80ZwVLi9q0tKiIiIQAhQER+V2XNE9i2sMXUTchgvzyQ4OAD+ekH/uE7uNgQCm2zq/Cmn9Q8p8UWDD0LFV76ly+MFBumNCRYODWMCEREQliCgMiclIa1Ijis3u6US8xgtpx4Xw6tCsAU1bsPaZ3AACLnTB7OOyZQqEbcjd9BK7CY9tVAxWtJlS2tKhTS4uKiEgQUxgQkZNWLzGS/z3Si18eu5gLmtakS8MEXB6T69+dx09rM45pHxGRSMyRFYbyXZA9MQrPvDvPctW/r6JhQlpaVEREQoHCgIickjCblTCbd3bwa7e0p3ujGpS4PDwwaTnbDuT7N7bYiWk6mPgjc4cL3XB408fVbqnRo0uLHhkm5HFqaVEREQkJCgMictrqJkTyydDzubBpTUrdHv727TpM8zd/Se8+jsgmg6lxJBCUesC5dXy1Wmq0bPlQh9VC6Zw7yPrEgWX9S37HREREgpHCgIicEZvVwnPXtsZhtTBr0wHfSkN+uo8jbFAp4Q2uB6DYA+4Fwygtzj67xR5HqetIz4Dh4eCmTyhyg2vPt4B6BkREJLgpDIjIGUurGcXQC9MAeHPG5oobWexEdHsXgAI3HNo4noOTEij59bazVeZxld3wG4YbIusBYI+sAUCx0x2wukRERKqawoCIVIp7LmyEw2phzZ5c1uypYHUhIDwyCVv96/CY4Doy+iZv68SAzyHwDQVyF0DhLgAcxTsAKCpVGBARkeClMCAilSIxysEVrZIBeOXnjcfOHQAMwyCm+1i/x0o94N42PqBzCHzDhKwWqHMNANaUXgAUuzRMSEREgpfCgIhUmpG9m+KwWZi58QAfzN5WYZuwiBq+oThYIwEorT8ILPazVeYxynoGrIYJbUZBnwXYWw731uby4NEkYhERCVIKAyJSaZokxfDUlc0BGP3jBr5evvuYNhY82Iq8Q3FwF8Llcyht/bezWeYxyuYMWI0jQ4LW/IOwWZf5jpeod0BERIKUwoCIVKq7eqZx9wXeycRP/nc1+3KK/BtY7NRo5t17IKHpIFj3IiWTm8CCoQGo1qvEeWTTMYsJpgv2TCHMKPEd1yRiEREJVgoDIlLp/nxVC7o0TKDE5eHN6VuOOW7tMY7IQaWEdf8Xxp4puEwo2fJRwOYNFJa6AAizesCwQZ1rsBke7Ed6CopdCgMiIhKcFAZEpNJZLAaP9fEOF/pq2W5yCiu4ybfYsdjCiUi7GfDuTsyiP57FKo8qOvKX/zDbkbkD7Z+HPgsIczgAKHZqmJCIiAQnhQERqRJdGibQPCWGEpeHySv2HLddVI8PACh2g2fr2e8dKHV5cLq9ISDMemTugNUBho0wm+GtTcOEREQkSCkMiEiVMAyDAV28qwZ9tmhnhUuNAtjD4rBHN8AECsIa+h3zeNzHfV5lKb+PQHhZz4DVceRr74/IIoUBEREJUgoDIlJlrutQlzCbhQ0ZeSzZkVVxI4+T6BLvBl95udsp+NQBC4aSn7+fjIwV7N+/Cre76noLCp3e+QI2i4Hd6u0JsBxZ5lQ9AyIiEuwUBkSkysRF2vlD21QA7vt0Gftzi49tZLET0WQwYUd+GuW4oHDzRxTkeYcWeTwuSkoq3tG4MhQe6RmIdFi95eDBYrEBEGb3hoESzRkQEZEgpTAgIlXq6X4taJYcw8H8Et6asbniRt3HkXjendiP/ETKTvoD7nLDg0pL8495Sk6Rk3Fz09mdVXhG9RWWeMNAhMMCq5/D+Ol8jGWPAhBmVc+AiIgEN4UBEalSCVEO/nZtKwC+WLzruDfvRo/xRN+UAXX+AHu+g9XP+Y5VFAb+9es2/vbtOi54YSZbMvNOu76yZUUj7BbYMwWLAZadn4HpOjpMSEuLiohIkFIYEJEq161RDXo2qYHTbfLOzGP3HSgTHh6Pbe933i/2TCHMHg6Ay1WCx+Pya7tg2yHf5+PnbT/t2gqP/NU/wm6FOtdgAYwGg36zmpCGCYmISHBSGBCRs+Lh3ucB8N9le8gvcVXYxrCGkdRiCClhENN4APGJ5/lW9nG5inG5vHMOSl0eVu0+Oo/gh9UZON2nd8Ne5JszYIE2o7BcvQHj/HcACPNOHdAwIRERCVoKAyJyVnRqkEDDGpGUujzM3nTg+A27fYhlYClGt0+Ytv4gGw545w4cOrSJzMy1FBYeYu3eHEpcHmLCbcRH2jlcUMqaPac3ybjgSDAJP9ILYFjDsVi8k4nVMyAiIsFOYUBEzgrDMLiiVQrgHe//6s8bef67dRX/1d1iZ/QP6/njp8u489NdbDvk9O03UFyczdIjy5R2TUukRUosAOkHC06rriLfMKGyZUWtGIb3R2OY1fRrIyIiEmwUBkTkrLmmXSqGAct2ZvPmjC18OCed16ZtotTlYe6Wg/y8NoO8Yu+eAuWHAa3ad3SfAdN0+8JAxwYJNKwZCcD2Q6e3qlDZ0qLh3q0FsFhsGIa3Z8Bh8fYIlCgMiIhIkLIFugARCR2t68TxwCVNeHPG0UnE78/exvuzt/m+rhHlYMafLmb7oaN/6d9y4OgcA6ez2LeBWecGiVjx3rBvP82egcKSstWEjgwTMo70DKx+DsfOWGCA5gyIiEjQUs+AiJxVj1zRjNmPXcLWf1zFHd0b+B6vGe2dKHyooJSvlu0mr/hoANh62ENERCIAS3cVcCCvBLvVoOHW4dRfdyeAX3g4Fb6egSN/GrFYbFjweFczMkoBKHZWPOFZRETkXKeeARE56+rX8A7tGfWHljSoEUVCpJ1+bWvz+v82894vWxk3d7tf+60HXcTFNSQ3P4sXZ3iHD12ZtBbXzs+pafUGivSDBZimiWEYp1SLb2lRXxiwYljDMOpeS1iWNwwUOc3jPV1EROScpp4BEQkYm9XC0AvSuL5jXcJsVi5plgTAzsPe8f/nN0zEYbWQX+Ji7taDjPh0JTuy3CTaC7k/8m8A1LLtAyCv2EVWobPiFzqBsqVFw8r1DABY2j1PTNuRAGQXnfp5RUREzgUKAyJSbXRqkEDTpGjf1y1TY2ma7P168LjFrM7xhoVHa75OrNU7LMhhlFI73Pv56awolO9bWtQE0+WbPGyx2EiI9AaDrILS03xHIiIi1ZvCgIhUG1aLwV+vboXdatAsOYb7L2lMi9repUPdHu9Qnb+nvsplsfMIs0Ck976dVMM7IXn97l2n/JplN/pxmf+Bn7phWfRHwBsG4iO8PyIPKwyIhITS0nwyM9dQXHx6+5aInIsUBkSkWrmgaU3mPnkpPzx0IUkx4b4wANCoZhSDOtcnJQxqOCAurjF2C9R17AVgS8bBU369shv9hJzpABjp48Hj9AsDhwpKzvBdici5IDt7By5XCYcPb/HtbYJHwwQluCkMiEi1kxQTjtXinQjcOvVoGHjwsqYYPcbBgFIYUIrRfwtRaQOoZ/eGgd07VuNyFZ/Sax0uPNIzkNoJiwFG4yFgsfuFgWKnh8JSrSgkEsw8Hpffz4+SklyyZtzMoY8duOfeGcDKRKqWVhMSkWrt/LREHr38PJqlxPh2MMZi9x0P7zmO+isvBmB3jklpcTa26JSTOrfL7SH7yKTj+Lb3Y4keCSntvS9hsRFpN3BYDUrdJofyS4lM1I9MkWDldPpvXFhUsJ+i7V8CkLX5Y2paLNB9XCBKE6lS6hkQkWrNMAweuKzp0SDwGxZbOC2adgNgv6cOTvfJd+mXrT5kAHHhFiy2iKPntdgwDIOEIxMTNG9AJLj9tlexqCQPUvsBUOqBoi3jNWRIgpLCgIic81IvfAGALGck+YUnP/Evq2yIUIQNq8XwLSsK3v0GgKOTiAsVBkSCWVkYcDiivA+sfg72fs+REYvkucAzf0iAqhOpOgoDInLOS4xy4LB6f2Nn5BTicp3chN9D+d4b/PjIo8uJlrFYbLD6OeLzFwBwOF9hQCSYlYWBiIgavl3I7QbUcoDVAJcJhzZ/ijn3Dlyl+Zhu/UyQ4FDlYWDMmDEYhsHIkSN9jxUXFzN8+HBq1KhBdHQ0N9xwA/v37/d73s6dO+nXrx+RkZEkJSXx2GOP4XL5T+D75Zdf6NixI2FhYTRp0oTx48dX9dsRkWrIMAySYsMBOFjgprg466SeV9YzkBBxbBiwGhbYM4V4q7en4WBe4bEnEJGgUFpaQElJHuDtGaiV3J6EJoOo4QBr4yEkNrkViwFOD+zf9AmZn8aQNzEMFgwNcOUiZ65Kw8DixYt5//33adu2rd/jDz/8MN9++y1ffvkls2bNYu/evVx//fW+4263m379+lFaWsq8efOYMGEC48ePZ9SoUb426enp9OvXj0suuYQVK1YwcuRI7r77bn766aeqfEsiUk2lHAkDB/I95ObuIS9v3+8+51DZsqIV9AzYHNEYda+lls27XOm+XI0VFglWubnePUrCwmKx2yOxWu1EXPQpy3rsZ3biGOwXTiSh8UAM4MiWJxS5gW0faR6BnPOqLAzk5+czaNAg/vnPf5KQkOB7PCcnhw8//JBXX32VSy+9lE6dOjFu3DjmzZvHggXe7viff/6ZdevW8emnn9K+fXuuvPJKnn/+ed555x1KS72/vMeOHUtaWhqvvPIKLVq0YMSIEdx444289tprx62ppKSE3Nxcvw8RCQ7JcUd6Bo78AT8vby979y6loCDzuM85mOcdThQf7v1RWD4MANg7jiG57WAA9uUUVXLFIlIdlJYWUFpagGFYSEhI8z2+O6uQAf9cwh0fLaL9cz+zpt4bJNj5f/buOz6qKv//+Gt6ekICSQgkEHqVKhDAjgY7VkQEEdvugm0t6Lr2709Zy9pWRdeCBdcuIlZEivTeOwRCC4G0STLJ1Pv7Y2BgpENIgLyfj8c8mLn33HPPPUmY+7mnEb17sUO/Abs8EJh1Ww2VXKRqnLBgYNiwYVx66aX06dMnbPv8+fPxer1h21u1akVGRgYzZ84EYObMmbRv356UlJRQmuzsbJxOJ8uXLw+l+XPe2dnZoTwO5LnnniM+Pj70Sk9PP+7rFJGTw56WAac3hoiI+NB2p3PLQccQbCmq2H2sGQzf/sGALYqUwq8B2LZ11YkotojUMI+nDAi2CqzYXs6Ad2YxZvYmPpyxEd/uZoBil5fHv1+FuemtxNtgd89CPAEoWfsRzLylSsvk8vgI7GmCEDnBTkgw8Nlnn7FgwQKee+65/fbl5eVht9tJSEgI256SkkJeXl4ozb6BwJ79e/YdKo3T6aSi4sBP8B555BFKSkpCr82bNx/T9YnIySctITgt6OZiL4mJzahbtxVmsxXDMHC5dh7wmM1FwWaE1KKv4ZcemOfdFbbfZrGR4vwBgG2lpurrDqBuByLVZs/6AlZrJI9+u5SZGwp49Ntl/PePHAD+fmELAJZvc3LFnMGsv6CIhBa3EL/72UGlHwIbRlfZ322+s5I2j//CLaPnVkl+IodT5cHA5s2bueeeexgzZgwRERFVnf1xcTgcxMXFhb1E5PTQMT3YGjB/UxGGYWC3RxMfH2z92zMw8M+27m4ZSHH+CIBl08dhX+gRUfVIibUDUOBPoNJfdf9l+v1eAr6K4Pn2OWfZlAHs+siOf8aQKjuXiByYx1NGRUUhADM3ulm8JXxq4mi7hTvPacLbg7qQFG1nVV4pV745m9wWrxN9kwdrdDoG4I5sErYY4vEYtzi4ovqUNQd+iCFS1ao8GJg/fz75+fl07twZq9WK1WplypQpvPbaa1itVlJSUvB4PBQXF4cdt2PHDlJTg4sKpaam7je70J7Ph0sTFxdHZGQkIlK7tG+QgMNqprDcw+odpVR6/djtMQB4PU4CAX9Yeq8/EBoHkJbeARPBWUP2/UI3Y1DPu5pIUzDd9qIDBxVHy+/3snPitez4KIqij+34PrXDrFspL92Kc/1nuxc4+lAtBCInWElJbuj9qD+2ApCeuPceok+bFBxWC9ltU/npnrM4o2E8ZW4f//l9HQARlcEeBu7SDVX292qod5BUsyoPBi644AKWLl3KokWLQq+uXbsycODA0HubzcbEiRNDx6xevZrc3FyysrIAyMrKYunSpeTn7x34N2HCBOLi4mjTpk0ozb557EmzJw8RqV3sVjOdMhIA6PvKH5z1/CTW7qzEuvz/wS89cE0dCIDPUwY+F9uLSgkY4LCaSezyANZLF0GP98IzNduIajqQVFvw/6J1u45s/YLDKZ86kMCWcRgEZyQp8UFg/fuUzrgzlMYTAJerAJerAL/fS2HhekpLt1XJ+UUkGJR7vcFAv8CTyMLNJVjMJj4a2p2UOAdN6kbz6KWtQ+mT4yJ48oq2AHy1YAtT1xXjaHoTAO76V1RZy0BA0YBUM+vhkxyd2NhY2rVrF7YtOjqapKSk0PZbb72Vv//97yQmJhIXF8ddd91FVlYWPXr0AOCiiy6iTZs2DBo0iOeff568vDz++c9/MmzYMBwOBwB/+ctf+M9//sNDDz3E0KFD+f333/niiy/44YcfqvqSROQUMaBbBrM2BJv8d5a6GfL+HD5LnYQdcG74nLK8GQRcwSd5c8vPBJ4gLd6OCT8WW50D5uno/SEdF71EzjaYNOUzLmxzT/AJ4DF+8Rt+N66NXwJgNwdv+t0ByPNGwta9/39V1r+MSmfwSaXJZMYwAlRWFmM1W4iMTKyyGw+R2srtDnYJstuj+XVZcKbCnk2TyKwbzdSHzsOECbs1/Jlp54w63Ng9g09n5/L21PWcdeuHmMpL8G8Zh3f6zdh6fXjc5VIoINWtRlYgfvnll7nsssu45pprOPvss0lNTeWbb74J7bdYLIwfPx6LxUJWVhY33XQTgwcP5umnnw6lyczM5IcffmDChAl06NCBl156iXfffZfs7OyauCQROQlc2bEBr97Qkcs7pFEnykae002ftR8xtaw3AAHXZqaXdeWGnFHcv/UJALqZf4FfemBd8ugB8zQT4GzzVwBM2hpH0cTr8Ozu1vNnfr+HgK/ykN0FKj0uAmmXYTFB3RaD2b3EAQQqsJogyQ6kXQrtnwTAYrFhGIFgmqVPU/R5Kvkf2vFNH3z0FSQiIeXl+Szd7qHfu5t5fXe3n2u7NATAYbXsFwjsMbRXYwDmbizC7fFg3/49AO71H1VJV6F9Gwa8/sBx5ydyOCbDqL3tUU6nk/j4eEpKSjSYWOQ0s2Kbk1tGz2GH043d7Oethg+QZtvB9TnvUBoIjiUwEeCLzDtpYNtOgg2iBnoO+MS9YNJgev56JW4jgrfTH6B95Crq2cHavxSTLZiXz1fJzt9vwLT1OxJtYG82dP9uR0DBxGtxb/qamMzriDvvC4wZQyhZ+yF+AxJsYMkcTEHLR/F6K0hKaoHV6qCsLI+ArxJjXFNcu4c+2MxQr+UQyPrghNWhyOmqoqKQnQUbuOGjXWxzBv+ozm1Zjw+GnInJZDrksYZhkPXc7+Q5KwG4puE67om8n2iLn6RWB/67PxpvTl7H8z+vBmDpkxcRG6FWQDl6R3OPWyMtAyIiJ1qbtDhmPHwB57dKxhOwcGvuy1y+/iNKAzGkxNq5PXMeT6a+SIMIJxYTRMY1O2jXmzrnvM8FKRsB+K6kLwA7PZD/SSyB3fOLu8q2Y2z5joARHAPAhvcx/O6wJ4VetxP3puC6BVFbv4SAF1PP0SS0GEKSHSxNhkDPD0lKakFKSntstkhMJjOxsWnE12lCQsuhpDjABHgD4F0/WoOMRY5Baek2Jq+rZJvTT0KUjfF39eadQV0PGwgAmEwmBmU1Cn3+ekszfnKej8+gSlYk3vcRrdunlgE58RQMiMhpy2I28eoNHWmVGguADysNEiJ5b0g3/nrdQC685lnwlxNjAVP5uoN+iZsxuMYefNo3ubQnnkBwuJXfANfa0RDwUjH376H03gBUODLZMfH6YJeeaYMg4A2thhxhhrAeCFkfwA2esKf8JtMB/nvu8R6WAR4cja4GwN3weo0dEDlKJSWb8fncfL88OHh4cFZj2jWIP2i3oAP527lNeX1AJ5Kig1MPLzb1xW+AkXnLcf9NVnr9B3wvcqJU+QBiEZGTSWyEjS//ksVrE9eSEGVnaK9MIu0WSkqcYImABpfh2Dkemgw9+Je42Ubv9l2ou7WAXf4kllZ2oEvUfADK/eCYMRT/5rGYAIcZKgNQVJIDJTkEgPw1n2Bf9wmeiGB/5Bgr+5/vSG8gzDYcPd6i0uehcuMXxMyMUlchkSNUWVlCeXk+eaV+5m0ODhq+bvc4gaNhMpm4vEMaETYLt380j9XetpA9C39Kx+O+sSrbZ+HUynmPwIWvHmeOIoemlgEROe3FRth49NI2DDuvGZH24Ihdmy0Slj4NW8djbTrksP18HWd9zEUNiwCY5ulLPbsZZg6nCgABAABJREFUP1b8BpSv/wQaXIrdDHHxTbEcoKeBJwC4tmA3B2cRotuoY76eCHs0pq3jg9OPrhsNu7sq7Wd3S0ctHhomEqaiogCAn1ZWYAA9miSSnhh1zPm1bxBc7HBjoY9KnwW/33PcZXS5K0Pv3bnfqyugnHAKBkSkVop0xBG7Yxx17UDO6CP6wr0iOzin+HdFvThz/U8M3PIhlQFHcFDv1h+wN7oe61XrqNtiMPFWSLIFX47dAUCkBRJtQOaQ4+pKYLFFE9ukPxBsmSBnNJWunfi95aE0nmmDKfzITvGk68nLW0RBwRoMI4DP56awcF2oy5JIbREI+KmsLAbgj5xggHxtl/TjyjMlzkFyrAO/ASt3eKskGKj07fO+/jXqCignnIIBEamVTBY7sS2GBp/SH6qL0D66ZybSIiWGSm+A4govua54ZpR3De2fv3oVk1Zuw5Q1muibPDgGenA0H0qSHeomNqOODcxNhlRJt56osz+BBpfhDUB5wwEU/nEbOz+JwT9tEL7KQorXfkxlAFw5X2IEPLjdpeTlLWJL3kre+WMrT32/nHXbtx53OUROFRUVhRiGgWGKYO1OFxBcV+B4mEwmzsxMBGDhVg8ez/GvUl7p3Tto2N1ixHHnJ3I4CgZEpPbq8V5w4O4RTgVoMpl46op29GyaFLqJmFR2LhYTrHa3Y8jGZ7nlw4U89PWSYHBhtu09xxVr9xsk/GclLi8jvlrCoPdms6XIxbr8Mlwe3wHTms1W7NbgIoxOlxO2jiNgwI41n5D/aVJwZpPdLCtGAsHuQs9OKGDUzDK+WOTins9X4tM85lJL7FlkbHt5JP6AQXykjfrxEcedb4/dwcDEtZUUOXeFWh+OVcU+wUCF98B//yJVScGAiNRuR9kEn9U0iU9v78ETl7cFYGJpFhes/YJbNo0Mpflq/haWbinZ/xyHOdf//bCCz+dt5o+1u+j9r0n0+fcUznlhMsu2luyfOOAldvvXmABj2w8Q0WC/JJ6AlUJfMjdOy+YfP5YxJ9fNr6v39kdenudm7PzVR37xIqegQMCHYRh4POWUVAS49t2VALRMjT2iqUQPp0+bFKLtFnIKfXw8r4ySktzjGqez73SilQoGpBooGBAROQYtU2O5sE0KAGWB4ABEi9lEx/QEAJ4ev5xAwKDY5eG7RVsPO0VgYbmH7xZv22/7zlI3//p5Vdi2Sq8fl8+Eo+kQ4nZPXeJ27aRuZCxJdqgklafyHuK8dd9w2Yb3We9OZ/K6Mu4dGxwAfUWHNG7pkQzAT0u3MXnFRsrcuumQ009lZTF5eYvJy1tEIODjh5V7g+Ezdg/+PV714yN5pl87AL5fXonb66GysuiY86vQ1KJSzTS1qIjIMXr8sjYYhkGnjDo0rBNJalwEaQmRnP/SZOZuLOKCf08hMdrO/E1F9Gmdwn9u7ESEzXLAvMYu3IrHF6BdgzjuPr85MzcU0KReDE98t4w/1u7i3s8Wklk3hvm5RczbWEhchI3vhr9FihFg5bLp3JTzLy6Kn8X9Q+4n+/UFeP0HfzJ5bZeGRDssfDArn4lrK5m4djlXdijg1QFdTlRVidSIiopCAAwjwOJtHt6a7gSgSb1o/npu0yo7z6Vn1Of/fljJznIPv6yq4JrOhURGJh5TXvuOGajwaCYhOfEUDIiIHKP0xCjevfnM/bY/eUVbRv60ipxd5eTsCs7w89vKHfR9ZSrXn5nOeS2TeXLcckoqvNzSqzHXd03nu0XBwbzXdm7IRW1TuahtKgBzcgr5fvE2xi4KbzVwefx0f3Yi/7nxOT4q+ZVKI4Jxxecy7pX5+5Xn5qxG+A2DT2blMjirEWc1r0vAgMZJUWwsCA6k/G5xHk9d6SEhyl6ldSRSkzyestD7MfPL8RsQF2Fl7LBexEVU3Sw9DquFO89uwnM/reKDOeVc1rYUwzCOqRvSvmMG1DIg1cFk1OIJqJ1OJ/Hx8ZSUlBAXF1fTxRGR00hJhZcnvlvG2EXbaJ4cg7PSyw6n+4Bpm9SLZsPOcixmE7P/cQF1YxyhfS6Pj/u/WMzPy/MwjOC85ld2TOO1iWtxVh68a887g7pgMpmYvm4XD2a3JMpuYWeZm+TYvQMmSyu9TFq1nfs+X4rfgGf7tebGHk2qrhJEapDPV0l+/nIgOOD+yve2s6PUz4dDu3FOi3pVfr4Kj59Oz/xKpTfAxzcm0b1Ve+z26KPOp9v//UJ+WfBv+4ELMxl+QZuqLqrUAkdzj6uWARGREyA+0sYrN3Ti0UvbUDfGTqnbxwfTNjJpdT6LNhcT67Bybqtkfly6nQ07g60HV3VqEBYIAETZrbx1U7D7Tr6zkroxDsxmEzf1aMS1o2awbKuTCJuZJy9vS0pcBNPX7cJiMXFB6xQsZlNoXAMQFghAcDG2KzpmMG/9Fj6aW8SyrQWAggE5PXg8Zfj8BpM2GLRv3JAdpVsA6JyRcELOF2m30LNpXX5flc/0HDedmpQeUzDgDex9RquWAakOCgZERE6gerHBm/u4CBv39GnOPX2aU1TuISbCis1i5soOaTz+3TI8/gD3XND8kHklx+29mY+wWRhzaw+mrt1JVtOkUBBxXqvkoy5js5Q4oIj1+eWHTStyqnC7S/l0QTmjZpYBwUX2GiVFEVuF3YP+rE/rFH5flc+vayq5rZeTmJjUo84jsE8w4NZsQlINFAyIiFSzOtF7++X3aZPCBa2T8QUMbJajm+AtPsrG5R3Sjrs8LVITgE3kFFQeLqnIKcEwDNxuJ7+tDf+dvmiflrIT4dIz6vPk98vZUOBj2dYiesW7sNmijiqPfcf+7zvNqMiJomBARKSGmUwmbJbjn+/8WLWsH1xALb/MT1FZKSZfAYYRwGJx4HDE4XDE1ljZRI5FZWUxW4vdrNvlw2I2MeqmLsRGWOmeeWwz/Byp+EgbZzevy28r85m32U37hltJSjp0i9+f+fdpGfAHFAzIiad1BkREark60ZEkRgW/DmasWIbLVUBFRRFlZXkUFKzB5dpFIKC+y3LqqKwsZkNBcFrOFinBNUF6NEmqkkXGDqdzozoALNvuweMpJRA4uq4+Af/e6UT9fv3dyYmnYEBEROjZJLgA07BvCnlhUgl2ezRmc3BNhOLiTeTlLaK8fCeG3w0BzX0uJzevt5xNRcEb6WbJMdV67s4Zu4OBPB+BQIDKyuIjPzjgDW8ZyPkEZt1axSUUCadgQEREuLbr3lmEvl1awbbKVFJSOmC17h20XDLtNnZ8FEHJx3Yqpw5UUCAnHbfbSUVFET6fm42FwSfyTesd/Yw+x6NDwwQibRZ2lftZlufFczSrEZttBNi7MKHfMMOG9/W3JieUggEREaF382T6tt07uPLtKRswmUwkJDTGaq+D22/Hsm0cAQPK/VC47lPKPrETmD4Iv9dVgyUXCaqoKKSgYC1FRRsAyC0O9rdvWq96WwYi7RYubhecRejn6dNwf9cCZt5yRMcahkFgn1szv2GGJkPBfOJmQBJRMCAiIlgtZkYN6sqPd58FwM/L8+jw1K/c+vEybvp4M+e/mctbnpeJ3PvQEqcP8lZ/Qv7H0XinDdovz5KSzezcuRKXqyC0zeMp1/gDOSEqK0uA4AJjPhyszg8+TW+VWv0D4K/p0hCA3/IyqPBbKV87+ogCgn27CAEE0q+BHu+diCKKhCgYEBGRkDZpcXTOSMAfMCip8PLH2l2s2VGGYcDonObkpdxDfQfE7DMXnQGUrPsEZtwc2uZ2Oyl35uL1uigp2YTX68Lp3MquXasoKFiDYRj7n1zkOHg8pQDUqdOEVUV1cfsCNEiIrPYxAwA9miRRPz6C0kAM/y24iXI/kDP6sN19/H/6u/AbNTfLmNQeCgZERCTMmwO78HL/Drw5sPN++7723YFpgIe4mzwkJzYlyQ4mwBMA1/qPYOYteDxlFH7bDib0hqlXYRgGO3eupKwsDwCv10VR0QbKy/NxuQrUUiDHzeMpw+/3YjKZsNujmbp2JwB9WidXywxCf2Yxm0KLCI4pupbNnnoEMocctrvPn2cSDQQUNMuJp2BARETCpMZHcFWnhlzSvj5v3NiZdg3ieDC7JQBjF22lpBLKvSas/dbhuKGc2MzrACj2Qtna0ZTkL8ZwbcZmhkTvZvDvv5hZZWUxJSWbKS7eSH7+MpzOLTidW/G6S/Ym0qBJOQIeT3lonEBUVF1MJjPLtjoB6NL4xK4rcCg3dMugQ3oCAHNdnfD6Dz/F6P4tAyeiZCLhFAyIiMhBXXpGfcbfdRZ3nN2EujF2dpV56PjMr5zzwiR2lrrBGkX0uZ9ji84AguMIvL/2xmyCJBtExDcnKbk9kZGJJCe3pX79zlgswaejNlskFoudQMBHWdkOymb+jV1jEnBNGUBgxi2UfWLH/cdAfJ4yvG4nFaVbCfgqKCvLo6w4B5+nbG9BFTjUSn6/l4KCNfj9XqxWB9HRqUxYsYNFm4sBaJsWV6PlO69FcEG/OeWdcG/45PDdhPzhTQNqGZDqoBWIRUTksGwWM9d2SWfUlPUYBuwq8/DgV4t59YZORFoCJHhzKTEHuwsBxFnBbAIuW47DbMPh2HtTVqdOE9xuJzExqRiGQVHRBvzeMtg2Dh9QvP4zLKbdT0XXfhp87csSBX4XpUBS84G4/V6M3C+IajoIa9Z7mnmlFvF4Snevlm0nKq45t328iMmrd4b2ZyZV77Sif9ajaT2YuJ7llS2p8EPc7Dsg64ODpvf9qZ9QQGNrpBooGBARkSNy34XN6ZSRQKXXz72fB2+6Ojz1K3ERVl7u+A8ucD0bCgZsJnA3ug3HAW7M7fYY7PbgoE6TCZKSgn2raTWEojWjqfAfpnuE34WJ4MDlXWvHhDaXr/6YOhs+JqL5UM3AUkv4fMEuaA5HHGNmbwkLBPq0TsFsrtkBuHtaJnb4kinwxRG9djQxcNCAwPenloE/fRQ5IdRNSEREjojDaiG7bSpXdmzAfwd1DW13Vvq4fXZPvm6xEdsANz+33US/oqm0/L4ffV+ZyhfzNh/ZCbI+IKbJjaGPdjPUdwS7GyXbIckODnOw1SHZsbvlgeC/NlMwOCj1gbH+ffz7jj2Q05bXWwGGD5stkilrgoHA45e14Y+HzuM/N3aq4dJBbISNxklRAKypbEKpD/wbRh+0u1DAUMuAVD+1DIiIyFHr0yaFRy9pzasT1xIbYWV7SSX3f7WM+79aFpZuVV4pI75eQnqdKEoqPExatZMrOqbRLi0ev2GQGG3HMIzQjC+2s8aQhAlfzhgiLGBqMgRH93cAsAa8OOYOC07R2Hgw9QIBKjZ8QoQ5GBDkucFrwHY3MCaByMbXUuf8L6vmggNedT86yfj9Xtxz74Ot37M57a/MzrkMgHNb1iM9MaqGS7dXuwbxbCxwsTLQnW4soszeiPiD/C79eZ2BPw8oFjkRFAyIiMgxuf3sJtx+dhP8AYOLX53Kmh17B/TGOqw8dWVbpq3dxTcLtzLgv7NC+z6ft5lImwWzCTqkJzB3YyHntUzm6SvbsWhzEVldPiC+1wc8/M1ypk4uYExzD5l1o4M341kfQPd3wGzDAsRYrMHgoMlQbM5deLeMC52nYuNXRJTnExmdfMzXWFlZTPGUwcTlf0/Un7of+f0eLCaTgoQa4pw8AGPr91hM8I85wd/DjukJwd+Vk0jvZnUZv2Q7s4qbc3MsuEo3ETvjZsw9P9wv7X6LjqmbkFQDBQMiInJcLGYTL1zbgX/9vIrCcg/nt0rmgYtaYjab6NMmhQkrdlDqDp9WscIbXFtgxvrg6sS/rtjBryt2AFAnysaw85rx2bytANz+0TzeHNiZFim7V5Ld9+Z7T3AAxH1qp8wc7ErkCUBl/SsorygiMjoZt9uJ3+8hIqIObncJDkc8ZvPe5ZQNw8DjKcPp3AIYJCW1BAwKpwyCreMpBhzr38fc5TVMJhMlpdspn3MvcTvGE938FnydX8FiArM1UsFBNQhUFlK56WsAKox6LHC1xmSC/9zYqUbWFTiU81oFg9ElFS3Z4U0hxbYDz/qPiOjx7n6/K38eQKyWAakOJqMWLwPpdDqJj4+npKSEuLianX5MROR0NWl1PqMmr+fuC5rzz7HLyNlVDkC3xonM2ViI3WIGE3h8B38MajGbyG6bQoOESBbmFuP1B3jkktb0aJK0N9GsW2HD+5A5BH/XN9ixc+X++Vhs+P1e7PYYkpJahG4cCwvXU1lZHEoXGVkHAj4qvmsZdvyegcv7fraYwGfsfR9ocCWR3V/D4YjHbo8JCzrk+AQCPoq/boa7dBNOfzTLKtuQZ+nCC7mX0a1xIl/8Jaumi3hAg96bzR9rd9E3dQOPx91NTOZ1xJ33xX7p1mwv5KJXZ4Y+d24YyTfDz6/Oospp4mjucdUyICIiJ9R5LZM5r2Xw6ei/rjmDJ8Yt54nL29AxPYGpa3ZyVvN67CpzM3NDAY0So+j/TrBLUXykjfeHnMmzP65k/qYiflyaF5bvwHdnc0vPxuTsKufqzg3p0/UdHN1GhboQRUYmUlFRGHaM3x8cuOnxlFFZWURkZCIu166wQACgoqIo+KbBFcTuGEfp7oaNPwcCBsFAgH3fb/mO8raPUF6+E5stirp1W2EymTD8HgwjgNkaoTEIx8hZuJbK0k0APJ8/nImlZ4X2XdW5QU0V67AevrgVf6ydxi95Tbi50UCabxoTDF7/NOuV31DLgFQ/tQyoZUBE5KSydEsJo6as5+rODbigdQqVXj+TV+ezKq+UeRuLaFovmrkbi1ix3Rl2XIuUGMbc1oNil4eb3pvNdV0acms3ByaTmejoZHbuXAGAzRaF1+vCYrGTmNiUgoI1BAJ+YmJScTji8HrLcTqDXZRiYlKIi0qkZEw0ASDWEpz21GSCygCU7Q4S6tqDXZOcPqDBFTi6vojbHSxfbGx9IpY8QuGaj4JTpkY1JMG7JTQGIeCrCHYvkkMKBPzs+O0ajC3f4TKS6bP2/dC+Fikx/HD3WdgsJ+8kibd9OJffVubTP2Es96W8S6oDuMETFhQu37KLS/8zO/S5fX0H39/TpwZKK6c6tQyIiMgpq33DeN4Y2Dn0OcJmoW+7+vRtVz+0LbfAxdVvTQdMpCdGsj6/jDU7ynjgy8UkRdvZ4XTzn0nr6dGkO72b1wX2rmdgNtvYuXMFfr+Hnbu7Etnt0cTGpmEymXA4YrFaI/H5KoiOTgaTmfiWQ0NdkKxnvgFmG/bZd+BYNzp4fNMh2M98A5u3Eqs9FovFRkVFIUVFOZQ6N1O6+qO9F+jagtMEkevfp8TlxLXxKxKb30TEWR+f2Io9xVWU5GBs+Q6bCX4v7QVA46QoHrmkNd0aJ57UgQDAtV0a8tvKfGa4z+Ue410CjYdgPuyYgeosodRWCgZEROSUk5EUxex/9MEEmM0m1uWX0feVqaG55vf439zcUDBgscZg3X3DGB2dTHl5PgAmk4nExOZhA08jIuKB+L0Z9XgPuo3CMFn3psv6IDTt6Z6nuw7r3iktIyMT8fnclDpzg0lMwcHNFX4IGFBsTadi41cAwSlSe71/4K5Dh+hSZBgGJsN3Wnc58nvLcY5tR2XpRgCiLDAjcCkAN/VoRHbb1Bos3ZHr3bweNouJzRUJbO4+nbrNO2D/Uxr/n1cgDigakBPv5A6jRUREDsJiNoVWmG2WHMON3TP2SzN5VT4rtjnJfnkqnZ+ZwIu/rObiV//gvNdWUW5qiNUaQZ06TQ86yLfc7aPCE5z56LdVhfR4biKvT1y7dwpIsw3MNjy+AOMWb+PV39by7I8r2VZcAQS7CCXVbU1skxtIskGdhKZE7T5VRfnexdi8Bxg7bfjdlE8ZgGuMHWPGkNB2T2Uxnsoi/F4X+ROuouAje7D/+fE4yCJYNa14Un92fBxDRelGDMCPna+KL2XyjmAA0LNp3Zot4FGIcVjplF4HgCXb/fj97v3S+P1/XmegWoomtZxaBkRE5LTwz0vbEO2wsj6/jP+7qh2Xvz6NHU43l7z2RyjNfyatC73/dnERD/Vty8Zd5SxetZVumYmM/GkVG3eV07p+HG5fgO8Xb8NsNpHdNpVfluXh8Qd4acIaPpq1iS4Zdbj97CZ8t2grn83ZjMe/945+5XYng7Mas6XIxTVdGhJ37v944/cnmZVTzKuZozBvGk3AgAhzcOyBzwD/zFux9Ap2J6r84yZK1o0J3Qz61n5InMlEhc9L0doxYdftB3zr3se6e/D00fLPGIJr3YdENLkJW++Tp6uSz1OGK2fvjDuxVng1/ybe3XU1AO0axNEqNbamindMOmYkMGdjIcvzvPh8lfvt//MAYrUMSHVQMCAiIqcFu9XMiL6tQp8vapPKx7M2haWxmE2c3yqZCSt2MH7Jdu48pylX/GcazkofETYzlbsf0S/eUrL3oIDB94u3hT5G2S3sLHXz8/I8fl6+d4aj+EgbaQmRrNzu5I+1u/hj7S4ANhW46JaZyAu/BgORr5r/k6Et/Pg2fEyEBXZ5goOPi9d+TCIQ6PYWRWvHhM1cVBGAuJzRON2wsrIZZgxaONbzc+l51LMWckGTlliPpatQwItz7YdU+KF0zSekmEyhgKQm+b3lFBdvhMiGULGFOjb4vqRPKBDo1zGNZ/q1C7UMnSo6pScAsDzPS1nZDiIjk7BaHaH9+y06plhAqoGCAREROS1lt90bDFzXpSF/PbcpZpOJerEOuj87kdxCF1e9MR1nZXBKoMoD9NW5tktDVm53snybk2s6N+Sfl7bGYTPz2ZzNvDl5HbvKPAA8fWVbbureCLPZxL9+XsVbk9eH8vhh6XbmbyoKff5s7mZuu+9DIrLeo6TCy4bf/0HD/FdxB6Bw7cfYKsswAJsZkmywwx+F3+ei0ANr6MYduY/ix0K3qAXMcXXGbvLypf0OWlluwpb13+DMREc4dalhsuJOvQy2jg/WwfqPic56r0bHIHin30zBmo8IGOA3zDgssfzq7MxDW+4F4NyW9Xi5f8eTbnGxI9ExIwGA9QU+XB4fxcU5JCY2w2wO3o79ORjQ1KJSHRQMiIjIaal7k0R6NUvCYjbz1JVtibLv/cobcXErHhu7jA27F0Ab0bcVS7YUM3XNTr75Wy8KytxMWLmDv18YXJhs5XYnXRvVCd2ADu2dyY3dM3j3jw2YTCYG9WgU2vdQdku6ZNTBbxg8+OVidpa62Vm6t3/4hp3l/LhsO40So7nxv7ModV/IE23j6Ot9BncA3Ju+haiGRHu3YM4cTPS6jygj2J3ovW0X4Cc46GCOKzjjksew8cbOwTxpfQnWjiEythFm1yZimw/G3PPDg9aP3++laFJ/ArsDAYCSlCuIMKDGlkkLeClbFwwErCZ4Mf8uvim+MLT75qxGPHZZm1MyEACoHx9JalwEec5KVu/009EWbAFJTGwGHGgAcU2UUmobBQMiInJaslnMjLmtxwH33dgtg3/9tIoyd7BVYHBWI6IdTfEHDCxmExBLz2Z7B6ee2ThxvzwibBaGn998v+0mk4k+bVIA+GPtTj6ZFZxN6JL2qbRMiePl39bwxqT1RNktlO4+/4d55zEg9f8o8hrB7kGuLTha3MTctJd59o8LGBb3Eq3tS1jgan/A6/m19DwG1PmWlhEbqNi9KJd3zUfUNZkh6wMgOPNQRUUhFosdhyOWokn98eR+CwRnOXIHgHb/YMeOJcHri0igTp1MTKbqm2tkV+F6PKlXwNZxWM2RYYHApe3r88TlbU+5rkF/1jE9gZ+X57G+OI6OaRVUVpbg81VitUbgU8uA1ADNJiQiIrWOxWzi7UFdaJwUxftDuhLtsIa2V6XBWY1D7+86vzk392yE3Wpm5XZnWNehjQUuXvO+SJJ97xSkZTnfct2omSwsSuKJkn/ji+6AMxCHmQB3ntMEgOeubs/lDYKzEr2y8284/XE4dn+zewLgWjeaivJ8/H4vLtdOios3UlCwhpKC1aFAoK4dkuwQnXk9Zsve/uuVlcXs2rWKQMBfpXVyMF6vC4+nHNo/DtmzmNR2RWjfdV0a8tL1HU75QACCLVYAH87axubSCABcrgIAAn9uGVAsINVAwYCIiNRKvZrVZfKD53F+q5QTdo4WKbG8cWNnRt3Umdb140iIsnP5GWmh/U9d0ZaX+3cA4M01LWmxbDwFqXeTaIOxlkdC6bYWVzI+JbgmQeN6sTyU3YoZD5/PgG4ZDLj4WgAWV7Tipty3+bm0L+s9LQEo9kJRcQ5FReuprCwOZrb0acq/Cw60jjCDPbYZ3OAh/rzPSUk5g+joelgswRnwvd4KysrycLkKMIzj67MSCPgoKcmlqCiHQMCPsfupd2npNnbuXBlaAA4gIiqFd/4Itqj8/cIWvHBdByJsNdZ5qUoN6JZB46QodpW5uWVMLusLvFRWBgPDPWMGrLvvzjSbkFQHdRMSERE5gS49o37Y58cva0PH9HhiIqz069gAk8nErPWFfD4v+IT/qdwbGJH9T14cvQDwhY574ZfVALRMicViNpGWEAlA9yZJtEqNZVVeKbu8sTy6dTgAf6n7IYPbu8FkDT5xBzB8WLaNww9YTBBnBcr3TrdqMpmJj88gPh7KynbgdG6hrCw4Y5LHU0pCQuPwizvSgcqGQWHhejyeMgAqKgoBsNki8XorQumKXAGiY5KZvMbE6h2lxDqs3LxP68rpIMJmYcztPbjr0wUsyC3m1amlvHaVDa/XFeomZLOY8AUMrTMg1ULBgIiISDWKj7Ix6E83uE9d2ZaEKBtvT93AnJxCrhk1B4C4CCsPZLfk8e+Wh9J2zqgTdqzFbOLLv2SxvaSS96flMGN9AbmFLj4ovpnLmtajrtkS6upjd8RTt/VQvOvex2IKdknKSb6Lz35ex009GpGeuHcF5YiIBJzOLaHPLlcBUVH1sNujAfBMG4x3w8dEtxgaXKEZCPgqKSvbjskSgd/vxut1ERmZiMlkCQUC+9oTCExZX8lXS9zM31wB5If239OnOfFRp9/qyg0SInn1hk6c/cIk5m32sLHQR0xMEQFjbzBQ4TXUTUiqhboJiYiI1LAIm4VHLmnNC9eegcNqxmI2cW2Xhowb3purOzckYfcN8ZUd0xjcs9F+x8dG2GiREsvIa85gyoPn7l40DS57dyd9387n/35z4XRb+H2Dg+sX3Ub+JSWYB3jgBg8v5g/h7akbOOv5SZS49q5EbLU6SEhoRHx8BpGRwX7uLtdOILgKcsGajynxQcXa9zH8bsom92fXx5GUfdOE0hl/weUqwOutwOncSklJsMtPTEwKCQmNsFhs2GzBlo15WwI88kPx7kBgr4vbpTKkZ+Mqr+uTRXpiFBe0SgbgX7+XUFFRGJpNyGYJjo3481SjIieCWgZEREROEtd1TefyDmn4A0ZoUDPA98N74/L4aXkEK+6aTCYeuKgFf/9iMSUVXoorvPy4wsuPK5zAVgDen7GFxy5rQyBgMHHljtCxf6zbyWX7jGmIigrOqGSzRVJRURi6wfcueDiUpsQHzi+b4XftbUVg6zho9w8whd9mOBxxOBxxoXy93gre+WoeAJl1o+mUkUBmUjRtG8Rxbovk02LA8KE8cXlbpq7dxeJtXtbvdOHx7m4Z2H3digWkOigYEBEROYkcaKDsvt13jsQFrVNY9PiFlLp9LNlcwl8/mR+axhTgt5U7aJQUxdtTNoQttjZ/U1FYMLCH3R5DTEwqZWV5eD1O2DoOuzk4Y1HAAFxbsJgg2gJRFvA3HkygbmscjjgKCtZQWelk7hY/C+fmUur2cXG7+kxds5PSSi/LtjmxmE18/deeJEbbj+o6T3XpiVF0yajDzA0FLNjiIdoR7M61p2VAwYBUBwUDIiIipyGTyURchI3ezevy9d96smxrCWkJkdz8/hw2FbjCxiHsMXdjIcUuD1/O24Lb56dVahxnt6jHliIXmXXTiIiIx+1xEdlyMNZNH+GNyKSsNAeAWAsEGg9mW+vXsVrtxGLFXemlTp0m/LQkl3u/XQnsAuCbBVvDztslo06tCwT2yGqaFAoGejQK3pbt203IMIxTdpE1OTUoGBARETnNtUiJpUVKsIvRkJ6NeXvqhtA+u9XMR0O7MfDd2Szb6qTj0xMOmMeQno2JcVj5z6R1xDhuJDZiEBe3S+MfCVdhKVvDNxUDePGPwWwf/0fomEibheeubs/XC3aG5RUXYaVvu1TmbiwiZ1c5/To1OAFXfWrIapoEE2DBpiLOdL4L3IXdsx1I2t0yYAAKBuTEUTAgIiJSiww7vxm5hS46pieQ1TQJi9lE27R4RvRtybM/rgKgVWosTepF89OyPPYsgjt6xsZQHmVuH2VuH+9Pz6HVtb9R4CzjX79uACrDzlXh9XPv54tCn6c8eC7JsRFYzCbsVjOVXj85u8ppdQRjIU5XHRomEGkzU+yNZL0nODjc5t3J3mBA5MRSMCAiIlKLxEXYeOumLvttv+PsppzXMhlnpZdO6XUwm01s2FnGpgIXs3IKeHvK3taEPq2TARO/rdzBQ18tCW2/6/xm/O3cZgBsLXbx/eLtvD11PZXeAMPPa0ajpOiwc0bYLLSuH3diLvQUYbea6do4kT/W7mJ2efDnYo2oA5XBMQOBQACLRZM/yomjYEBEREQAaJ4S/oS+Sb0YmtSLoXfzulhMJuZtLGL4+c04u0U9Siq8nPWv33FWBgcm33l2E+6/qGXo2GbJsdx3YSw3ds8gZ1c53TMTq/VaTiXntkzmj7W72OwNdpeyxzeB4uBCcQHD4PRYe1lOVgo1RURE5JBsFjMP9W3FF3/J4uwW9QCIj7Txcv+OxDqs3Ng9gxF9Wx3w2JS4CHo0SdIg2EO4qE1K2GerZW9d+fyBPycXqVJqGRAREZFjckHrFBY8fiE2dWM5LumJUZzfKpnfVwVXX7bv0xSwZ1VikRNFf70iIiJyzBQIVI07zm4Sem/dp0r3rEoscqKoZUBERESkhiXts86C1by3NaCkJBd3uUFCQiNstqNbfE7kSCicFxEREalhcZG20Pt9WwbKx5+Jd8HD7Nq1CsNQK4FUPQUDIiIiIjUsNmJvZw3fPgsM+A0zbB2HEfBSUVFYE0WT05yCAREREZEaFmnbO2rYXbAi9D6AGUt6PzBZKS/Pr4GSyelOwYCIiIhIDTMZvtB7r6uQPbOLmi+YSL0LvsJkMuP1VrBt23zKy3fWUCnldKRgQERERKSmmfeOGSi3N8K8Oxgo8diZlVNEZFTd0P6SklyNH5Aqo9mERERERE4i5bbGmM2lEIAbP9wEbKJv22Se6GMNBQGVlSVERtap2YLKaUEtAyIiIiInkXKPD7cvfNvPy/NxWTKJiEgAwOMprf6CyWlJwYCIiIjIScT150hgtylrioiMTATAU1kEPld1FktOUwoGRERERE4iiTGOsM+PXdYGgE9mb+Kz+YVsnv0K3h86UjwmmsDYZjVRRDmNKBgQEREROQl8cWcWWU2SeOPGzqFtDetEck3nBkTbLWzYWc5T41fx+KIzMQxw+aGgaD3G9JtqsNRyqlMwICIiInIS6JaZyP/u6EHL1NjQtoQoGwlRdh7IbhnattrdlCXubphN4DXAuW4MzLylJoospwEFAyIiIiInqYRIOwC39Mpk/F296dUsCYCHdz6NLSPYIlDuB9/60RpDIMdEwYCIiIjISSo+au/6A+0axPPezWeSkRhFSYWPj/z/IGL3nVy+B4rGRBOYNqiGSiqnqioPBp577jnOPPNMYmNjSU5Opl+/fqxevTosTWVlJcOGDSMpKYmYmBiuueYaduzYEZYmNzeXSy+9lKioKJKTk3nwwQfx+cJH10+ePJnOnTvjcDho1qwZo0ePrurLEREREakxCZG2sM8RNgv9OjUA4NXfN/CD7Ulsuxcoq/BDwdpP8I1tSqVrV3UXVU5RVR4MTJkyhWHDhjFr1iwmTJiA1+vloosuory8PJTmvvvu4/vvv+fLL79kypQpbNu2jauvvjq03+/3c+mll+LxeJgxYwYffvgho0eP5vHHHw+lycnJ4dJLL+W8885j0aJF3Hvvvdx222388ssvVX1JIiIiIjUiIcq237YB3dKJtlsAGLm6O8vrPESSndAYgvzCDRR+Vo/KqQOru7hyCjIZhmGcyBPs3LmT5ORkpkyZwtlnn01JSQn16tXj008/5dprrwVg1apVtG7dmpkzZ9KjRw9++uknLrvsMrZt20ZKSgoAo0aNYsSIEezcuRO73c6IESP44YcfWLZsWehcN9xwA8XFxfz8889HVDan00l8fDwlJSXExcVV/cWLiIiIHIPbPpzLbyvz+eOh80hPjNpvvz9gcP3bM5m/qQiAW3s14n7vFRQX54TSmE2Q2GwApW2eAgwSEjKxWPYPLuT0czT3uCd8zEBJSQkAiYnBRTLmz5+P1+ulT58+oTStWrUiIyODmTNnAjBz5kzat28fCgQAsrOzcTqdLF++PJRm3zz2pNmTx4G43W6cTmfYS0RERORk886grix7KvuAgQCAxWzirZs6c1bzugC8N30Tnyf/SrQFLLu7DQUM2LX2f7jn/R23u5Ty8h0YhkHYc+CA90RfipzkTmgwEAgEuPfee+nVqxft2rUDIC8vD7vdTkJCQljalJQU8vLyQmn2DQT27N+z71BpnE4nFRUVByzPc889R3x8fOiVnp5+3NcoIiIiUtXMZhMxDush0yTHRvDxrd15+OJWADz/yzoCmX8hxQHx+x66dTwYPlyuXezcuZz8/GX4fG5KJvWncowdZt16Aq9ETnYnNBgYNmwYy5Yt47PPPjuRpzlijzzyCCUlJaHX5s2ba7pIIiIiIsflzrOb0KZ+HBVePy8XDYMbPETf5MEWnQGAJToDizWSQMCPz+fG7/eQv2MR5TlfUOiFwPr31UJQi52wYGD48OGMHz+eSZMm0bBhw9D21NRUPB4PxcXFYel37NhBampqKM2fZxfa8/lwaeLi4oiMjDxgmRwOB3FxcWEvERERkVOZyWTigewWAHw0cxPnvDSNoR8uoLy8kngr1PPlEhWREH7Qsv8LvS13NAazxhLUVlUeDBiGwfDhw/n222/5/fffyczMDNvfpUsXbDYbEydODG1bvXo1ubm5ZGVlAZCVlcXSpUvJz88PpZkwYQJxcXG0adMmlGbfPPak2ZOHiIiISG1xfqsUHty9SvGmAhe/r97FtZveZI2nBeamQ4mObYDNtvth6dIng12HdnOVbty7grFaCGqdKp9N6G9/+xuffvop3333HS1b7l06Oz4+PvTE/q9//Ss//vgjo0ePJi4ujrvuuguAGTNmAMGpRTt27EhaWhrPP/88eXl5DBo0iNtuu41nn30WCE4t2q5dO4YNG8bQoUP5/fffufvuu/nhhx/Izs4+orJqNiERERE5XRiGwcsT1vDa7+tC2xokRJASF8HGAhef39GdRvF+jC8TKfdDnBV2eYMDjaMtENHkBio2fEZM85ux9vivWgtOYUdzj1vlwYDJZDrg9g8++IAhQ4YAwUXH7r//fv73v//hdrvJzs7mzTffDHUBAti0aRN//etfmTx5MtHR0dx8882MHDkSq3XviJjJkydz3333sWLFCho2bMhjjz0WOseRUDAgIiIipxt/wGBrUQVnvzApbPtd5zfjqk4N8C/8J813vcq8uPtJseVh2TpmvzwSbBDVbAh0f0dBwSmoRoOBU4mCARERETld3fDOTGZtKAx9bpsWR26hiwqPn6G9Mnjnj020TInio4SLMOHDd4A7wigLJLQcCj3eq8aSy/FSMHCEFAyIiIjI6WpnqZt5GwupF+vg2lEHX4dpZNPPuCH6EzwB8AagMgDuwN79yXaw3ugBwO/34vd7sP95QPKBBLwnRatCIODDjHFSlKW6nFSLjomIiIhI9asX6+Di9vXp0qgOHRrGHzTdnPj74fpy7Dd6iG4+hCQ71LPv3V/qB+c3LXB+YmfHx9Hs+rQOzknXU1KyGbe7lPz85ezatRq/f0/A4KHw9+vwfBpcw8Dv9xDw7V4DqjoGKAe8ofOUl+8kb8JVlH6yz3oKfypDcCG2wJ9zOXC+VZHmJKNgQEREROQ0ZjKZeKhvK2wWE23qx3Fxu+AYze6ZiQAs2VLChqIAC7eUQdYHcIMH240ekvpvB6DCD2XOjZT59uZZlvMl5bP+RkHBGny+SjyeMkpLtwFQUriGyo1fscsDvnXvk//b1ez8OIqyr5vg/NiOf/pgAgEfHk95lV6n3+9l129Xs220ncKP7Hj+uImSaUNh63hKfWCsf5/yKbsXWts9e5JhGOzatZIdO5bi8ZTtvZnf56be56uk6PfrKP3EjnvqjWHnNPxuysp24HLmUvj7deR/GDzvqUTdhNRNSERERGqBcrePKLsFr98gt9BFQpSNrv/3W1iaRy5uxdDemQQMA6/Xg+fzKCp3PzS3mYPdiMJkzwLT3sldIlc+R8Wmr0OfrZZIfP6KsEMizBBoeBWeNo8SFVWXmJgU3O5SzGYLTucWoqLqEhubdtjrMQwDd8UuzGYbNkc8BROvxpM79uAHmCMhECxLkh0cTYfg6vAixcUbg/uXPknE9vFYYhoTKN9IZOMbiDjnfxTtXE7F9+1C2cTENsJ2yRxKZ9yBb/N3YIkCvyu032KClFZDgoFVDdGYgSOkYEBERERqs/5vz2R2TuEB90XZLXzX+ycy8l/Dagre5BLTDK9zHe4AGI1uoLT5A8TEpFJWlrff+gWH9adAYl8Wix2HIxa7PZbIyERMhi/Y59/nArMNw2ShcOK1uHO/xQTEZF5Lac5XB8zLBBzoZtduBs+Fu8twkLJH2qKp8B59C0aiDSqzFxNfrx0mU/V3xFEwcIQUDIiIiEhtVuLy8vJva2jXIJ6icg8v/Loaj2/v4/8zGsbz8S2diY8MDr5dvLWcBZt2MeDMhkQ4InB73Pzfj2uJt5ZwY35vAKwmqGODEh94AsEgIsIcvCH3Gvu0LmTPwmKNxO8/TD/7pU/i2D4emy0Gr7cMuxncjgw85bn7JY21QowFAkCpb++2Ei/4DDCbgmUCoMEV0P5xHLZIIn9uS/FBiuE3zKx2t+C8+DWU+gK4/MHtJoL5xVjA5YfvSy5kvqsd/eJ/oG3kesBPVGxjEq7LOdyPocopGDhCCgZERERE9lqxzcm7f2zgm4VbQ9vqxtiJsluJj7SxdGsJELwJ7tKoDhe0TmHkT6sA+O6sH+lQ8iaVATtfWx7l/Lq5OLa+R4w1+BQeoMIUS1FFaTDfFoOw9/4Iv9+L07mFiopCLBYbDkcchhGgoqLosK0NUbtvxPeUqZ4dLE2GBNdHGN8GytZBTHOo1wtyRgNQUv96Kls9hN8As9mC15bJuPFv09szinqWHBzm4JP9Im9wZqX3CgbyXsEA7m6xnGvT11G6cRxNI3YQYdlbjsneyxiy8i8ApFp38Gzas6x2t2BQ3d+JGVAI1qjj/+EcBQUDR0jBgIiIiMiBTVmzk5vfn3PE6a/v2pDnr27Dsz+t5p0/NtGkXjTjzhxDzJZ3oclQ6Po6hslKyScOLKbgE3tu8ISm/PR6XZhMFjDZsFrMeCqLKPksEV/gwN18oizBxdEq/cEWhwgz2JoMhp4fhtIY3nKW7vDSIiWWCMvuJoHd5zOMAIXlbs57cSrOSh/N6kXzS9PbsbiCAYRRtwfFa7+g08qvw84bafExofntNGx5KUa3t/l15U6e/H4V20sqQ2laOdayyt2cQal/8My9I4+4DquKgoEjpGBARERE5MAMw6D/O7OYk1PIuS3r0Tgpmh3OSu44uwlev8H1b++/dkGf1in8tnJH6HPLlFg8Pj/ntkpmV5mHeRsLebTFFC5zPxMMEPZZzMzt83P7R/NZlFvE+LvOIiMpCmbdSmD9++S5g2lsDS7Du7uloK4d7DeUw7y7YMP7rEm6m1d33cyWIhddGiUy7LymvDFpPe9Pz+GWXo154vK2oXNt3FXOp3Ny2Vzo4qdleaHtP9zdmzp2P2Pm57N8m5PEKCvfLNy+33We1SyJzHoxfL94G0WuYP+i9MRIYhw2Vm53htL9fO9ZtEqt/ntMBQNHSMGAiIiIyMFVev2Uu30kxTj22/fSr6t5/fd1XNO5IbM2FLC1uOIAOezvjIbxjPtb99AT+i1FLj6dnUues5JvFgS7J3VrnMjAHhlsKnCxtbCU64quJcpUzs+l53Nu9O9kOPIpNdLY3HMeLevXYc6Gndzz+RICB7mrNZlgw7OXsH5nOSYTDPzvbPKce5/kxzislLl9xDqs+A0Dl8cfdvwtvRrTMT2BHc5Knv1xVdg+i9nE7Wc14bazMvlu0TaeGb8CCAZG797c9YjqpKopGDhCCgZEREREjo3PH2DS6p30apbEqrxSflq6nc/mbKbU7ePePs155be1Bz12cFYjVm53kp4YxZTVOyko9xzxees6KhmWOJqnt9+JgSlsX/fMRC5sk8KHMzeyuTA8OOndrC7T1u3aL7/myTG8d/OZZL8ylQpvMAhIjYsgMdrOiu1Oejery9uDuhDtsGIYBv/4dhn/m5NLm/pxnNm4Dtd1Taddg+CiboGAwTcLt7KrzM3NWY2JtFv2O191UDBwhBQMiIiIiFSd7SUVrMor5byWyXwxbzNT1uykUWIUb05ej9VsItJmodTtO+jxKXEOruuSzrcLtx5xS8Me7RvEM3ZYLyxmE5sKyvnn2GUUlnvw+gOs2VEWlrZOlI0rOgTXMrjtrCakJ0bx719X89rv64i2W5j04Lkkx0bg8viIsu8//WmFx19jN/pHQsHAEVIwICIiInLi5ZdWYjaZyNlVzvVvz8RiMnFd13QKytxEO6wMO68ZK7c76ZieQHpicOad3AIX707bwFnN63H7R/MASIq2h1oRzm1Zjzdu7Mwz41cwO6eQl/t3pGN6wn7nnrQ6n1s+mAtAh4bxvDO4K3ERtv1u5is8ft6ZuoGL2qbQuv6pfV+oYOAIKRgQERERqV4Lc4uIjbDSLDn2iI95+OslLN1awr+v78jN78+hXYN4/t2/A3ERtsMeaxgG//l9HT8vz2NE31ac3aLe8RT/lKBg4AgpGBARERE5tRiGgclkOnzCWuxo7nGrf31kEREREZFjpECgaikYEBERERGppRQMiIiIiIjUUgoGRERERERqKQUDIiIiIiK1lIIBEREREZFaSsGAiIiIiEgtpWBARERERKSWUjAgIiIiIlJLKRgQEREREamlFAyIiIiIiNRSCgZERERERGopBQMiIiIiIrWUggERERERkVpKwYCIiIiISC2lYEBEREREpJZSMCAiIiIiUkspGBARERERqaWsNV2AmmQYBgBOp7OGSyIiIiIiUjX23Nvuudc9lFodDJSWlgKQnp5ewyUREREREalapaWlxMfHHzKNyTiSkOE0FQgE2LZtG7GxsZhMpmo/v9PpJD09nc2bNxMXF1ft5z+Vqe6Oj+rv2Knujp3q7tip7o6d6u7Yqe6OXU3XnWEYlJaWkpaWhtl86FEBtbplwGw207Bhw5ouBnFxcfojO0aqu+Oj+jt2qrtjp7o7dqq7Y6e6O3aqu2NXk3V3uBaBPTSAWERERESkllIwICIiIiJSSykYqEEOh4MnnngCh8NR00U55ajujo/q79ip7o6d6u7Yqe6Oneru2Knujt2pVHe1egCxiIiIiEhtppYBEREREZFaSsGAiIiIiEgtpWBARERERKSWUjAgIiIiIlJLKRg4wUaOHInJZOLee+8NbausrGTYsGEkJSURExPDNddcw44dO8KOy83N5dJLLyUqKork5GQefPBBfD5fNZe++m3dupWbbrqJpKQkIiMjad++PfPmzQvtNwyDxx9/nPr16xMZGUmfPn1Yu3ZtWB6FhYUMHDiQuLg4EhISuPXWWykrK6vuS6lWfr+fxx57jMzMTCIjI2natCnPPPMM+84PoLrba+rUqVx++eWkpaVhMpkYO3Zs2P6qqqslS5Zw1llnERERQXp6Os8///yJvrQT7lB15/V6GTFiBO3btyc6Opq0tDQGDx7Mtm3bwvJQ3R34925ff/nLXzCZTLzyyith21V3B6+7lStXcsUVVxAfH090dDRnnnkmubm5of219bv3cHVXVlbG8OHDadiwIZGRkbRp04ZRo0aFpamtdffcc89x5plnEhsbS3JyMv369WP16tVhaaqqbiZPnkznzp1xOBw0a9aM0aNHn+jL28uQE2bOnDlG48aNjTPOOMO45557Qtv/8pe/GOnp6cbEiRONefPmGT169DB69uwZ2u/z+Yx27doZffr0MRYuXGj8+OOPRt26dY1HHnmkBq6i+hQWFhqNGjUyhgwZYsyePdvYsGGD8csvvxjr1q0LpRk5cqQRHx9vjB071li8eLFxxRVXGJmZmUZFRUUoTd++fY0OHToYs2bNMv744w+jWbNmxoABA2rikqrN//t//89ISkoyxo8fb+Tk5BhffvmlERMTY7z66quhNKq7vX788Ufj0UcfNb755hsDML799tuw/VVRVyUlJUZKSooxcOBAY9myZcb//vc/IzIy0nj77ber6zJPiEPVXXFxsdGnTx/j888/N1atWmXMnDnT6Natm9GlS5ewPFR3B/692+Obb74xOnToYKSlpRkvv/xy2D7V3YHrbt26dUZiYqLx4IMPGgsWLDDWrVtnfPfdd8aOHTtCaWrrd+/h6u722283mjZtakyaNMnIyckx3n77bcNisRjfffddKE1trbvs7Gzjgw8+MJYtW2YsWrTIuOSSS4yMjAyjrKwslKYq6mbDhg1GVFSU8fe//91YsWKF8frrrxsWi8X4+eefq+U6FQycIKWlpUbz5s2NCRMmGOecc04oGCguLjZsNpvx5ZdfhtKuXLnSAIyZM2cahhH8wzWbzUZeXl4ozVtvvWXExcUZbre7Wq+jOo0YMcLo3bv3QfcHAgEjNTXVeOGFF0LbiouLDYfDYfzvf/8zDMMwVqxYYQDG3LlzQ2l++uknw2QyGVu3bj1xha9hl156qTF06NCwbVdffbUxcOBAwzBUd4fy5y/HqqqrN99806hTp07Y3+yIESOMli1bnuArqj6HuqHdY86cOQZgbNq0yTAM1d0eB6u7LVu2GA0aNDCWLVtmNGrUKCwYUN0FHaju+vfvb9x0000HPUbfvUEHqru2bdsaTz/9dNi2zp07G48++qhhGKq7feXn5xuAMWXKFMMwqq5uHnroIaNt27Zh5+rfv7+RnZ19oi/JMAzDUDehE2TYsGFceuml9OnTJ2z7/Pnz8Xq9YdtbtWpFRkYGM2fOBGDmzJm0b9+elJSUUJrs7GycTifLly+vnguoAePGjaNr165cd911JCcn06lTJ/773/+G9ufk5JCXlxdWd/Hx8XTv3j2s7hISEujatWsoTZ8+fTCbzcyePbv6Lqaa9ezZk4kTJ7JmzRoAFi9ezLRp07j44osB1d3RqKq6mjlzJmeffTZ2uz2UJjs7m9WrV1NUVFRNV1PzSkpKMJlMJCQkAKq7QwkEAgwaNIgHH3yQtm3b7rdfdXdggUCAH374gRYtWpCdnU1ycjLdu3cP6w6j796D69mzJ+PGjWPr1q0YhsGkSZNYs2YNF110EaC621dJSQkAiYmJQNXVzcyZM/e7X8zOzg7lcaIpGDgBPvvsMxYsWMBzzz233768vDzsdnvoi3GPlJQU8vLyQmn2/aXZs3/PvtPVhg0beOutt2jevDm//PILf/3rX7n77rv58MMPgb3XfqC62bfukpOTw/ZbrVYSExNP67p7+OGHueGGG2jVqhU2m41OnTpx7733MnDgQEB1dzSqqq5q69/xviorKxkxYgQDBgwgLi4OUN0dyr/+9S+sVit33333Afer7g4sPz+fsrIyRo4cSd++ffn111+56qqruPrqq5kyZQqg795Def3112nTpg0NGzbEbrfTt29f3njjDc4++2xAdbdHIBDg3nvvpVevXrRr1w6ouro5WBqn00lFRcWJuJww1hN+hlpm8+bN3HPPPUyYMIGIiIiaLs4pJRAI0LVrV5599lkAOnXqxLJlyxg1ahQ333xzDZfu5PbFF18wZswYPv30U9q2bcuiRYu49957SUtLU91JjfB6vVx//fUYhsFbb71V08U56c2fP59XX32VBQsWYDKZaro4p5RAIADAlVdeyX333QdAx44dmTFjBqNGjeKcc86pyeKd9F5//XVmzZrFuHHjaNSoEVOnTmXYsGGkpaXt97S6Nhs2bBjLli1j2rRpNV2UKqeWgSo2f/588vPz6dy5M1arFavVypQpU3jttdewWq2kpKTg8XgoLi4OO27Hjh2kpqYCkJqaut9I9D2f96Q5HdWvX582bdqEbWvdunVoNog9136gutm37vLz88P2+3w+CgsLT+u6e/DBB0OtA+3bt2fQoEHcd999odYp1d2Rq6q6qq1/x7A3ENi0aRMTJkwItQqA6u5g/vjjD/Lz88nIyAh9d2zatIn777+fxo0bA6q7g6lbty5Wq/Ww3x/67t1fRUUF//jHP/j3v//N5ZdfzhlnnMHw4cPp378/L774IqC6Axg+fDjjx49n0qRJNGzYMLS9qurmYGni4uKIjIys6svZj4KBKnbBBRewdOlSFi1aFHp17dqVgQMHht7bbDYmTpwYOmb16tXk5uaSlZUFQFZWFkuXLg37T3/PF+qf/7M7nfTq1Wu/KbvWrFlDo0aNAMjMzCQ1NTWs7pxOJ7Nnzw6ru+LiYubPnx9K8/vvvxMIBOjevXs1XEXNcLlcmM3hf84WiyX0xEx1d+Sqqq6ysrKYOnUqXq83lGbChAm0bNmSOnXqVNPVVL89gcDatWv57bffSEpKCtuvujuwQYMGsWTJkrDvjrS0NB588EF++eUXQHV3MHa7nTPPPPOQ3x9dunTRd+8BeL1evF7vIb8/anPdGYbB8OHD+fbbb/n999/JzMwM219VdZOVlRWWx540e/I44aplmHItt+9sQoYRnIYqIyPD+P3334158+YZWVlZRlZWVmj/nmmoLrroImPRokXGzz//bNSrV++Un6LrcObMmWNYrVbj//2//2esXbvWGDNmjBEVFWV88sknoTQjR440EhISjO+++85YsmSJceWVVx5wysdOnToZs2fPNqZNm2Y0b978tJwec18333yz0aBBg9DUot98841Rt25d46GHHgqlUd3tVVpaaixcuNBYuHChARj//ve/jYULF4ZmvKmKuiouLjZSUlKMQYMGGcuWLTM+++wzIyoq6pSf4vFQdefxeIwrrrjCaNiwobFo0SJj+/btode+M4qo7g78e/dnf55NyDBUdweru2+++caw2WzGO++8Y6xduzY0NeMff/wRyqO2fvceru7OOecco23btsakSZOMDRs2GB988IERERFhvPnmm6E8amvd/fWvfzXi4+ONyZMnh/1/5nK5Qmmqom72TC364IMPGitXrjTeeOMNTS16uvlzMFBRUWH87W9/M+rUqWNERUUZV111lbF9+/awYzZu3GhcfPHFRmRkpFG3bl3j/vvvN7xebzWXvPp9//33Rrt27QyHw2G0atXKeOedd8L2BwIB47HHHjNSUlIMh8NhXHDBBcbq1avD0hQUFBgDBgwwYmJijLi4OOOWW24xSktLq/Myqp3T6TTuueceIyMjw4iIiDCaNGliPProo2E3YKq7vSZNmmQA+71uvvlmwzCqrq4WL15s9O7d23A4HEaDBg2MkSNHVtclnjCHqrucnJwD7gOMSZMmhfJQ3R349+7PDhQMqO4OXnfvvfee0axZMyMiIsLo0KGDMXbs2LA8aut37+Hqbvv27caQIUOMtLQ0IyIiwmjZsqXx0ksvGYFAIJRHba27g/1/9sEHH4TSVFXdTJo0yejYsaNht9uNJk2ahJ3jRDMZxj5LlIqIiIiISK2hMQMiIiIiIrWUggERERERkVpKwYCIiIiISC2lYEBEREREpJZSMCAiIiIiUkspGBARERERqaUUDIiIiIiI1FIKBkREREREaikFAyIiIiIitZSCARERERGRWkrBgIiIiIhILaVgQERERESkllIwICIiIiJSSykYEBERERGppRQMiIiIiIjUUgoGRERERERqKQUDIiIiIiK1lIIBEREREZFaSsGAiIiIiEgtpWBARERERKSWUjAgIiIiIlJLKRgQEREREamlFAyIiIiIiNRSCgZERERERGopBQMiIiIiIrWUggERERERkVpKwYCIiIiISC2lYEBEREREpJZSMCAiIiIiUkspGBARERERqaUUDIiIiIiI1FIKBkREREREaikFAyIiIiIitZSCARERERGRWkrBgIiIiIhILaVgQERERESkllIwICIiIiJSSykYEBERERGppRQMiIiIiIjUUgoGRERERERqKQUDIiIiIiK1lIIBEREREZFaSsGAiIiIiEgtpWBARERERKSWUjAgIiIiIlJLKRgQEREREamlFAyIiIiIiNRSCgZERERERGopBQMiIiIiIrWUggERERERkVpKwYCIiIiISC2lYEBEREREpJZSMCAiIiIiUkspGBARERERqaUUDIiIiIiI1FIKBkREREREaikFAyIiIiIitZSCARERERGRWkrBgIiIiIhILaVgQERERESkllIwICIiIiJSSykYEBERERGppRQMiIiIiIjUUgoGRERERERqKQUDIiIiIiK1lIIBEREREZFaSsGAiIiIiEgtpWBARERERKSWstZ0AWpSIBBg27ZtxMbGYjKZaro4IiIiIiLHzTAMSktLSUtLw2w+9LP/Wh0MbNu2jfT09JouhoiIiIhIldu8eTMNGzY8ZJpaHQzExsYCwYqKi4ur4dKIiIiIiBw/p9NJenp66F73UGp1MLCna1BcXJyCARERERE5rRxJN3gNIBYRERERqaUUDIiIiIiI1FIKBkREREREaqlaPWZAREREaq9AIIDH46npYogcNZvNhsViqZK8FAyIiIhIrePxeMjJySEQCNR0UUSOSUJCAqmpqce9VpaCAREREalVDMNg+/btWCwW0tPTD7sok8jJxDAMXC4X+fn5ANSvX/+48lMwICIiIrWKz+fD5XKRlpZGVFRUTRdH5KhFRkYCkJ+fT3Jy8nF1GVIoLCIiIrWK3+8HwG6313BJRI7dnkDW6/UeVz4KBkRERKRWOt6+1iI1qap+fxUMiIiIiIjUUgoGRERERCRM48aNeeWVV0KfTSYTY8eOPa48qyIPqXoaQCwiIiIih7R9+3bq1KlzRGmffPJJxo4dy6JFi445D6k+CgZERERETkMej6fKBkmnpqaeFHlI1TvqbkJTp07l8ssvJy0tbb/mHq/Xy4gRI2jfvj3R0dGkpaUxePBgtm3bFpZHYWEhAwcOJC4ujoSEBG699VbKysrC0ixZsoSzzjqLiIgI0tPTef755/cry5dffkmrVq2IiIigffv2/Pjjj0d7OSIiIiKnhHPPPZfhw4czfPhw4uPjqVu3Lo899hiGYQDBrj3PPPMMgwcPJi4ujjvuuAOAadOmcdZZZxEZGUl6ejp333035eXloXzz8/O5/PLLiYyMJDMzkzFjxux37j/f823ZsoUBAwaQmJhIdHQ0Xbt2Zfbs2YwePZqnnnqKxYsXYzKZMJlMjB49+oB5LF26lPPPP5/IyEiSkpK44447wu4HhwwZQr9+/XjxxRepX78+SUlJDBs27Lhnz5FwRx0MlJeX06FDB95444399rlcLhYsWMBjjz3GggUL+Oabb1i9ejVXXHFFWLqBAweyfPlyJkyYwPjx45k6dWroFxbA6XRy0UUX0ahRI+bPn88LL7zAk08+yTvvvBNKM2PGDAYMGMCtt97KwoUL6devH/369WPZsmVHe0kiIiJSyxlGoEZeR+vDDz/EarUyZ84cXn31Vf7973/z7rvvhva/+OKLdOjQgYULF/LYY4+xfv16+vbtyzXXXMOSJUv4/PPPmTZtGsOHDw8dM2TIEDZv3sykSZP46quvePPNN0MLWh1IWVkZ55xzDlu3bmXcuHEsXryYhx56iEAgQP/+/bn//vtp27Yt27dvZ/v27fTv33+/PMrLy8nOzqZOnTrMnTuXL7/8kt9++y2sXACTJk1i/fr1TJo0iQ8//JDRo0eHggupGiZjTzh5LAebTHz77bf069fvoGnmzp1Lt27d2LRpExkZGaxcuZI2bdowd+5cunbtCsDPP//MJZdcwpYtW0hLS+Ott97i0UcfJS8vL9S89fDDDzN27FhWrVoFQP/+/SkvL2f8+PGhc/Xo0YOOHTsyatSoIyq/0+kkPj6ekpIS4uLijrEWRERE5FRSWVlJTk4OmZmZREREYBgBtm9fWCNlqV+/EybTkT2bPffcc8nPz2f58uWhaSUffvhhxo0bx4oVK2jcuDGdOnXi22+/DR1z2223YbFYePvtt0Pbpk2bxjnnnEN5eTm5ubm0bNmSOXPmcOaZZwKwatUqWrduzcsvv8y9994LhN/zvfPOOzzwwANs3LiRxMTE/cp5sDED++bx3//+lxEjRrB582aio6MB+PHHH7n88svZtm0bKSkpDBkyhMmTJ7N+/frQolrXX389ZrOZzz777Mgq+DT259/jfR3NPe4Jn02opKQEk8lEQkICADNnziQhISEUCAD06dMHs9nM7NmzQ2nOPvvssH5u2dnZrF69mqKiolCaPn36hJ0rOzubmTNnHrQsbrcbp9MZ9jqZ+QMGeSWVHEe8JiIiIqeRHj16hM0vn5WVxdq1a0MLqe17fwWwePFiRo8eTUxMTOiVnZ1NIBAgJyeHlStXYrVa6dKlS+iYVq1ahe7bDmTRokV06tTpgIHAkVq5ciUdOnQIBQIAvXr1IhAIsHr16tC2tm3bhq2uW79+/UO2WsjRO6EDiCsrKxkxYgQDBgwIRSV5eXkkJyeHF8JqJTExkby8vFCazMzMsDQpKSmhfXXq1CEvLy+0bd80e/I4kOeee46nnnrquK+rujz9/XI+nLmJjMQovvprFsmxEYc/SERERI6KyWSmfv1ONXbuqrTvzTUEu/Tceeed3H333fulzcjIYM2aNUd9jsjIyGMu39Gy2Wxhn00mE4HA0XevkoM7YS0DXq+X66+/HsMweOutt07UaY7KI488QklJSei1efPmmi7SIU1ZsxOA3EIXn885ucsqIiJyKjOZzDXyOlp7elHsMWvWLJo3bx729HxfnTt3ZsWKFTRr1my/l91up1WrVvh8PubPnx86ZvXq1RQXFx+0DGeccQaLFi2isLDwgPvtdnuopeJgWrduzeLFi8MGMk+fPh2z2UzLli0PeaxUrRMSDOwJBDZt2sSECRPC+iqlpqbu17zj8/koLCwMTTmVmprKjh07wtLs+Xy4NIeatsrhcBAXFxf2OllVePxsKnSFPn85fwuBgLoLiYiI1Ga5ubn8/e9/Z/Xq1fzvf//j9ddf55577jlo+hEjRjBjxgyGDx/OokWLWLt2Ld99911ooG7Lli3p27cvd955J7Nnz2b+/Pncdttth3z6P2DAAFJTU+nXrx/Tp09nw4YNfP3116Gu2o0bNyYnJ4dFixaxa9cu3G73fnkMHDiQiIgIbr75ZpYtW8akSZO46667GDRo0H49P+TEqvJgYE8gsHbtWn777TeSkpLC9mdlZVFcXBwWgf7+++8EAgG6d+8eSjN16tSwqaMmTJhAy5YtQ4tVZGVlMXHixLC8J0yYQFZWVlVfUo1Yv7MMw4AIm5kYh5XcQhdLt5bUdLFERESkBg0ePJiKigq6devGsGHDuOeee8JmZPyzM844gylTprBmzRrOOussOnXqxOOPP05aWloozQcffEBaWhrnnHMOV199NXfcccd+Xbr3Zbfb+fXXX0lOTuaSSy6hffv2jBw5MtQ6cc0119C3b1/OO+886tWrx//+97/98oiKiuKXX36hsLCQM888k2uvvZYLLriA//znP8dRO3Isjno2obKyMtatWwdAp06d+Pe//815551HYmIi9evX59prr2XBggWMHz8+LLJLTEwMDQi++OKL2bFjB6NGjcLr9XLLLbfQtWtXPv30UyA46Lhly5ZcdNFFjBgxgmXLljF06FBefvnl0C/8jBkzOOeccxg5ciSXXnopn332Gc8++ywLFiygXbt2R3QtJ/NsQl/P38L9Xy6me2Yi8ZE2fl2xg7Nb1OPRS1rTMjW2posnIiJyyjrULCwns3PPPZeOHTvyyiuv1HRR5CRQY7MJzZs3j06dOtGpU3Cgzd///vdQlLlnvtktW7bQsWNH6tevH3rNmDEjlMeYMWNo1aoVF1xwAZdccgm9e/cOW0MgPj6eX3/9lZycHLp06cL999/P448/Hhb59uzZk08//ZR33nmHDh068NVXXzF27NgjDgROdmt2lALQMjWW3s3rAjB1zU5uem+2uguJiIiISJU46tmEzj333ENOdXkkDQ2JiYmhVoCDOeOMM/jjjz8Omea6667juuuuO+z5TkWLtxQD0Lp+HN0y907dtbPUzeYiF42SgrMFLMgtYtKqfG7olkGDhOob3S8iIiIip74TOrWoHBuPL8CizcUAnNm4Dk3qRjO0VybvT88BYPk2J42SosktcHHze3ModfsYPWMjP959FumJUTVYchERETlRJk+eXNNFkNPQCV90TI7esm0lVHoD1Imy0bReDCaTiccvb8OAbunB/bsHEj/23TJK3T4ASit9fDB9Y00VWUREREROQQoGTkJzc4Lz9nZtnBi2ymDbtHgAlm1zMienkClrdmI1m3j6yrYAfDFvMy6Pr/oLLCIiIiKnJAUDJ6G5G4PBQLfG4ct8d0xPCO7PKWT0jGCXoWu7NOSm7o1IjYugzO1jYW5xdRZVRERERE5hCgZOMoGAwbxNRQCcmRkeDLRNi6NpvWgqvH5+XJoHQHa7VMxmU2iQ8Z5AQkRERETkcBQMnCR8/gC/Ls+jyT9+pNjlxWwK3vzvy2Qy0f/M9LBtXRsFF2HbEzjM21hUPQUWERERkVOegoGTQLnbx7kvTuaOj/euypzVNAmbZf8fzw3dMkLvbRYTsRE2IDjrEASnGvX5Aye4xCIiIiJyOlAwcBKYvm4XW4oqAGiQEMn5rZK56/zmB0wbF2Hjv4O7EmEz889L24S2N0+OJcpuweXxs2FXebWUW0RERE5vTz75JB07dqzSPEePHk1CQkKV5nk8Jk+ejMlkori4GKia8p1s13goCgZOAtPW7QLgxu4ZTH/4fN4fciY9miQdNP2FbVJY/lRfbu7ZOLTNYjaFuhUt3VJyQssrIiIicrrq378/a9asOeL0jRs35pVXXjmuPGqSgoEaZhgG09YGg4FzWtQ74uMsZtN+29o1CE49unSrggERERGpPQzDwOermunVIyMjSU5OrvE8qouCgRr264odbNhVjt1iPmRrwJFovzsYWKZgQERE5LRz7rnnctddd3HvvfdSp04dUlJS+O9//0t5eTm33HILsbGxNGvWjJ9++il0jN/v59ZbbyUzM5PIyEhatmzJq6++Gpbv5MmT6datG9HR0SQkJNCrVy82bdp0wDKsX7+eJk2aMHz4cAzDwO1288ADD9CgQQOio6Pp3r37fisljx49moyMDKKiorjqqqsoKCg45HVu3LgRk8nEZ599Rs+ePYmIiKBdu3ZMmTIlrMwmk4mffvqJLl264HA4mDZtGoFAgOeeey50vR06dOCrr74Ky//HH3+kRYsWREZGct5557Fx48b9yvvnLj7ff/89Z555JhEREdStW5errroq9DPZtGkT9913HyaTKbQ+1IHyeOutt2jatCl2u52WLVvy8ccfh+03mUy8++67XHXVVURFRdG8eXPGjRt3yLqqCgoGapBhGDz340oAbj87k/hI23Hlt6dlYPk2J/6AcdzlExERkZPLhx9+SN26dZkzZw533XUXf/3rX7nuuuvo2bMnCxYs4KKLLmLQoEG4XC4AAoEADRs25Msvv2TFihU8/vjj/OMf/+CLL74AwOfz0a9fP8455xyWLFnCzJkzueOOO8IWPd1jyZIl9O7dmxtvvJH//Oc/mEwmhg8fzsyZM/nss89YsmQJ1113HX379mXt2rUAzJ49m1tvvZXhw4ezaNEizjvvPP7v//7viK71wQcf5P7772fhwoVkZWVx+eWX7xdIPPzww4wcOZKVK1dyxhln8Nxzz/HRRx8xatQoli9fzn333cdNN90UCiQ2b97M1VdfzeWXX86iRYu47bbbePjhhw9Zjh9++IGrrrqKSy65hIULFzJx4kS6desGwDfffEPDhg15+umn2b59O9u3bz9gHt9++y333HMP999/P8uWLePOO+/klltuYdKkSWHpnnrqKa6//nqWLFnCJZdcwsCBAyksPMHTxhu1WElJiQEYJSUlNXL+LUUuo9GI8UaTR34wSiu9x52fzx8wWv3zJ6PRiPHG2h3OKiihiIjI6aeiosJYsWKFUVFRUTUZ+j1Vk89hnHPOOUbv3r1Dn30+nxEdHW0MGjQotG379u0GYMycOfOg+QwbNsy45pprDMMwjIKCAgMwJk+efMC0TzzxhNGhQwdj+vTpRp06dYwXX3wxtG/Tpk2GxWIxtm7dGnbMBRdcYDzyyCOGYRjGgAEDjEsuuSRsf//+/Y34+PiDli8nJ8cAjJEjR4a2eb1eo2HDhsa//vUvwzAMY9KkSQZgjB07NpSmsrLSiIqKMmbMmBGW36233moMGDDAMAzDeOSRR4w2bdqE7R8xYoQBGEVFRYZhGMYHH3wQVr6srCxj4MCBBy1vo0aNjJdffjls25/z6Nmzp3H77beHpbnuuuvC6gYw/vnPf4Y+l5WVGYDx008/HfC8h/o9Ppp7XLUM1KAFuxcXa1M/jhiH9bjzs5hNtNkziFhdhURERE68WbfCZ/bgv9XgjDPOCL23WCwkJSXRvn370LaUlBQA8vPzQ9veeOMNunTpQr169YiJieGdd94hNzcXgMTERIYMGUJ2djaXX345r7766n5Pt3Nzc7nwwgt5/PHHuf/++0Pbly5dit/vp0WLFsTExIReU6ZMYf369QCsXLmS7t27h+WXlZV1RNe6bzqr1UrXrl1ZuXJlWJquXbuG3q9btw6Xy8WFF14YVp6PPvrouMqzaNEiLrjggiMq88GsXLmSXr16hW3r1avXftez7883OjqauLi4sJ/liXD8d6ByzObvDga67F447GAMwzhgc92BtG8Qz/xNRSzd4uSqTsddRBERETmYgBc2vB98v+F96DYKzMfX5fdwbLbw/E0mU9i2PfcLgUBwzaHPPvuMBx54gJdeeomsrCxiY2N54YUXmD17duiYDz74gLvvvpuff/6Zzz//nH/+859MmDCBHj16AFCvXj3S0tL43//+x9ChQ4mLCz54LCsrw2KxMH/+fCwWS1i5YmJiqv7iDyA6Ojr0vqysDAh262nQoEFYOofDcczniIyMPOZjj9aBfr57fpYniloGatDCzcUAdMpIOOB+wwhQWLiOHTuW4PEc2doBe8YNLNqslYhFREROKLMNmgwNvm8y9IQHAsdi+vTp9OzZk7/97W906tSJZs2ahZ6S76tTp0488sgjzJgxg3bt2vHpp5+G9kVGRjJ+/HgiIiLIzs6mtLQ0dIzf7yc/P59mzZqFvVJTUwFo3bp1WOABMGvWrCMq+77pfD4f8+fPp3Xr1gdN36ZNGxwOB7m5ufuVJz09PVSeOXPmHFV5zjjjDCZOnHjQ/Xa7Hb/ff8g8WrduzfTp08O2TZ8+nTZt2hzkiOqjloEaYhgGa3cE/5japsWH7XO7nRQV5RAI7J0iq6hoA8nJbTGZDh2/9WwanJFo4eZi8koqSY2PqOKSi4iISEiP96qlReBYNW/enI8++ohffvmFzMxMPv74Y+bOnUtmZiYAOTk5vPPOO1xxxRWkpaWxevVq1q5dy+DBg8PyiY6O5ocffuDiiy/m4osv5ueff6ZFixYMHDiQwYMH89JLL9GpUyd27tzJxIkTOeOMM7j00ku5++676dWrFy+++CJXXnklv/zyCz///PMRlf2NN96gefPmtG7dmpdffpmioiKGDh160PSxsbE88MAD3HfffQQCAXr37k1JSQnTp08nLi6Om2++mb/85S+89NJLPPjgg9x2223Mnz+f0aNHH7IcTzzxBBdccAFNmzblhhtuwOfz8eOPPzJixAgguM7A1KlTueGGG3A4HNStW3e/PB588EGuv/56OnXqRJ8+ffj+++/55ptv+O23346oLk4ktQzUkDxnJS6PH6vZRKOkqLB9FRWFoUBgT3Of3+/B5Tr0VFwAaQmRdG1UB8OAH5YeeES7iIiIVKGTNBAAuPPOO7n66qvp378/3bt3p6CggL/97W+h/VFRUaxatYprrrmGFi1acMcddzBs2DDuvPPO/fKKiYnhp59+wjAMLr30UsrLy/nggw8YPHgw999/Py1btqRfv37MnTuXjIwMAHr06MF///tfXn31VTp06MCvv/7KP//5zyMq+8iRIxk5ciQdOnRg2rRpjBs37oA32vt65plneOyxx3juuedo3bo1ffv25YcffggFPxkZGXz99deMHTuWDh06MGrUKJ599tlD5nnuuefy5ZdfMm7cODp27Mj5558f1rrw9NNPs3HjRpo2bUq9egdeM6pfv368+uqrvPjii7Rt25a3336bDz74gHPPPfeI6uJEMu0evVwrOZ1O4uPjKSkpCfV/qy7T1u7ipvdm06ReNL/ff27Yvp07V+L1uoiPTycqqh4u105KSjZjtTqoV6/tYccPfDA9h6e+X0HvZnX55Lbuh0wrIiJS21RWVpKTk0NmZiYREWpBP9ls3LiRzMxMFi5cSMeOHWu6OCetQ/0eH809rloGasiGXcFBLk3rhQ+wMQwDn68CAIcjHpPJRGRkEmazFZ/PjdO5+bB5n9k4EYAlW4qpxbGeiIiIiByGgoEasj4/GAw0qRcdtt3nq8QwDMwEsFqDI9/NZgt16gSbt1yuXQQChx6k0iIlFrvVjLPSR26h6wSUXkREREROBwoGasj6ncHZgf7cMlBRUQBLn8T6a7ewOYsdjjisVgeGYeDxlB0yb7vVTOv6wSahxVu03oCIiIicOho3boxhGOoiVE0UDNSQzhkJ9GyaROvU4E27x1OGsziHshl/ga3jiTQTnLM44A0d43AE07rdzsPm36FhcIaiPQubiYiIiIj8mYKBGvL3i1ry6e09aN8wnoqKInZNGkDZN01g2w/EWiHaCmQOCZuhwG6PBcDjKT1s/mc1D45m/2HpdvwBjRsQERERkf0pGKhhgYCfkqk3w9bxAFhMEGMBGg+GrA/C0jocwWDA663A7/f+Oasw57SoR0KUjZ2lbqav23VCyi4iIiIipzYFAzWs0pVPYOv3WE2QaIMkG5iaDIGeH+6X1my2YrMF1yTY0zrg93vx+z37pbVbzVzUJgWAWRsOvz6BiIiIiNQ+WoG4hrlmDQcgygIRzYZA93cOuXiJwxGL1+vC6dyCy7ULtzsYFNSt2wq7PXxmohYpwZaETZpRSEREREQOQC0DNcjrduLJ/QYTwWDgcIEAQGRkIiaTCb/fGwoEACor9x8o3DgpGBxs3FVelcUWERERkdOEgoEa5JpxOwARFjA3HXpEy5nbbFHUrduK6OhkYmPrExfXADjwDEON6wa7FG0qcGnxMRERkVPcueeey7333ntEaSdPnozJZKK4uPi4ztm4cWNeeeWV48pDTm4KBmqI4fdQsfELAKLMQLdRR3yszRZFfHw6sbFpREXVBYKDin0+d1i6hnWiMJmgzO2joHz/cQUiIiIiUrspGKghbm8FgbTLsJjA3uyWI2oVOBCz2RqaZaisbHvYvgibhbT4SAA2FairkIiIiIiEUzBQQypm3A5bxxPR+DpMWe8fV16xscGuQi5XAT5fZdi+PV2F9qx4LCIiIqe+jz/+mK5duxIbG0tqaio33ngj+fn5+6WbPn06Z5xxBhEREfTo0YNly5aF7Z82bRpnnXUWkZGRpKenc/fdd1NernuG2kTBQE0IeAnkfglA5NYvw1YZPhZ2ezQREcEVh8vLw/8jaFYvBoB1+WXHdQ4REZHTlWEYuDy+Gnkd65g+r9fLM888w+LFixk7diwbN25kyJAh+6V78MEHeemll5g7dy716tXj8ssvx+sN3nesX7+evn37cs0117BkyRI+//xzpk2bxvDhw4+nOuUUo6lFa4LZRlKrofjWvY+12ZENHD6c6OgUKitLcLkKiI1tgNlsAaD57ulF1+44/KrFIiIitVGF10+bx3+pkXOveDqbKPvR344NHTo09L5Jkya89tprnHnmmZSVlRETExPa98QTT3DhhRcC8OGHH9KwYUO+/fZbrr/+ep577jkGDhwYGpTcvHlzXnvtNc455xzeeustIiIiju/i5JSgloGa0uM9rDd6oMd7VZKdwxGL1RqBYQRwV+xdcXjPWgNrdqhlQERE5HQxf/58Lr/8cjIyMoiNjeWcc84BIDc3NyxdVlZW6H1iYiItW7Zk5cqVACxevJjRo0cTExMTemVnZxMIBMjJyam+i5EapZaBmlQFLQL7ioysQ+mMv1KxfRyRrYZCj/donhx8OrC1uIJyt49oh37kIiIi+4q0WVjxdHaNnftolZeXk52dTXZ2NmPGjKFevXrk5uaSnZ2Nx3PksweWlZVx5513cvfdd++3LyMj46jLJacm3RmeRiIdsZRuHYcbMNa/j6nbKOpE26kb42BXmZu1+WV0TE+o6WKKiIicVEwm0zF11akpq1atoqCggJEjR5Keng7AvHnzDph21qxZoRv7oqIi1qxZQ+vWrQHo3LkzK1asoFmzZtVTcDkpqZvQacRqj8WS3g8DcGfcFGp5aFpPKxGLiIicLjIyMrDb7bz++uts2LCBcePG8cwzzxww7dNPP83EiRNZtmwZQ4YMoW7duvTr1w+AESNGMGPGDIYPH86iRYtYu3Yt3333nQYQ1zIKBk4zEd1ehexZuNs9FdrWKGnvSsQiIiJyaqtXrx6jR4/myy+/pE2bNowcOZIXX3zxgGlHjhzJPffcQ5cuXcjLy+P777/HbrcDcMYZZzBlyhTWrFnDWWedRadOnXj88cdJS0urzsuRGmYyjnVOq9OA0+kkPj6ekpIS4uLiaro4VaKyspjCKTdj3TaO5NbBcQNvTFrHC7+s5upODfh3/441XUQREZEaVVlZSU5ODpmZmZoxR05Zh/o9Ppp7XLUMnGbs1ghMW8fhM8C37n0IeEMtAxu1CrGIiIiI7EPBwGnGbI3A1ugaANzpN4DZRuOk4JgBdRMSERERkX2dOkPn5YhFdP8PHp8bd85nRDuiyOg4CoCCcg+llV5iI6p2SlMREREROTWpZeA05LBFwtbxuAPBKUbj7JAc6wBgxTZnDZdORERERE4WCgZOQzZHfGiKUU/GQDDbODMzEYBZGwprtnAiIiIniVo8h4qcBqrq91fBwGnKcebL0OAyKjeMgVm3ktUkCYCvFmzG5w/UcOlERERqjsUSXPX3aFbrFTnZuFzBsaA22/F1/9aYgdNUpCMW19bxuIDode+TdeFLAGwurKDfm9P5/I4soh368YuISO1jtVqJiopi586d2Gw2zGY9G5VTh2EYuFwu8vPzSUhICAW3x0p3g6cphyMOhxncAXAFoEndKAZ0S+d/czazbKuTJ8ct54XrOtR0MUVERKqdyWSifv365OTksGnTppoujsgxSUhIIDU19bjz0aJjp9miY/uqmHoTRevGYE2/kuQLxwIwd2Mh142aicVs4o+HziMtIbJmCykiIlJDAoGAugrJKclmsx2yReBo7nHVMnAac/T+EFOFE9/m7/D8cRP2sz7hzMaJZDVJYuaGAj6etYkRfVvVdDFFRERqhNls1grEUuupk9xpzEwA+/bvAShcNwb/9MEADM5qBMB3C7cSCNTahiERERGRWk/BwOnMbCOh+SAsJggYULH+Ywh4Oa9VMtF2C9tKKlm0pTiUvMzt45q3ZvCPb5fWXJlFREREpNooGDjNWXp9RExmfwDcaVeB2UaEzcIFrVMA+Gnp9lDabxdsYf6mIj6dnYuz0lsj5RURERGR6qNgoBZw9P4QGlyGJ/dbAjNvAeCitsFgYNLqnaF0v67YEXq/MLe4WssoIiIiItVPwUAtYDWbsW4bjwF4142GgJezmtXDYjaxLr+MLUUuNuwsY/q6XaFj5m/USsUiIiIipzsFA7WB2Yat0XUAeDJuALON+CgbnTMSAJi0Kp9XflvLvmOJ520qqoGCioiIiEh1UjBQS9i7/weyZ+Ft+wQEguMBstsGF6oYMzuXn5YFxw78+/rgQmSLNhfj8wdqprAiIiIiUi0UDNQSNlsULHuWynGtKf7YjjFjCFd2bIDFbGJVXilev0FafAT9OjYgLsKKy+NnVV5pTRdbRERERE4gBQO1hM1iw7xtHAAuPxSv/ZCkJbfRp3VyKE33JkmYzSY6N6oDwDyNGxARERE5rSkYqCVMFgf1Wt5MzO6Vqyv8ULLuE+6p90koTZfdQUCXjN3BgMYNiIiIiJzWFAzUIpaeo4kb5KFO0+C6A5V+aFnwKn/v05SODaLo2bACwwjQpXEwGJivYEBERETktKZgoLYx24g85zPsGf0wCLYQDIt8ljeviSPCXE5FRREd0xOwmE1sL6lka3FFTZdYRERERE4QBQO1VFSPtwBw+mDH6o9hyRMAVFQUEmW30jYtDtC4AREREZHTmYKBWioyOgVrVPreDdt+gKVP4nY7CQR8dN49bkArEYuIiIicvhQM1FImw0eCbzMRZrDtfpm3jQfDh9tdSof0eACWbS2p4ZKKiIiIyImiYKC2MtuwNxtKoh3qJTajnh2iMvuDyYrb7aRdWjAYWLHdSWDfpYlFRERE5LRhrekCSA3q8R50GwVmGwS8OLwVlBWsxe120qReBhE2My6Pn5yCcprWi6np0oqIiIhIFVPLQG1ntoX+tdtjMJlM+P0ejICbVqnBQcTLtzlrsIAiIiIicqIcdTAwdepULr/8ctLS0jCZTIwdOzZsv2EYPP7449SvX5/IyEj69OnD2rVrw9IUFhYycOBA4uLiSEhI4NZbb6WsrCwszZIlSzjrrLOIiIggPT2d559/fr+yfPnll7Rq1YqIiAjat2/Pjz/+eLSXI/swmczY7bEAuN3O0IxCK7crGBARERE5HR11MFBeXk6HDh144403Drj/+eef57XXXmPUqFHMnj2b6OhosrOzqaysDKUZOHAgy5cvZ8KECYwfP56pU6dyxx13hPY7nU4uuugiGjVqxPz583nhhRd48skneeedd0JpZsyYwYABA7j11ltZuHAh/fr1o1+/fixbtuxoL0n24XAEAwC320mLlGBgsHZHaU0WSUREREROEJNhGMc8OtRkMvHtt9/Sr18/INgqkJaWxv33388DDzwAQElJCSkpKYwePZobbriBlStX0qZNG+bOnUvXrl0B+Pnnn7nkkkvYsmULaWlpvPXWWzz66KPk5eVht9sBePjhhxk7diyrVq0CoH///pSXlzN+/PhQeXr06EHHjh0ZNWrUEZXf6XQSHx9PSUkJcXFxx1oNpxWfr5L8/OWYTCY2lDVk4HtzyUiMYupD59V00URERETkCBzNPW6VjhnIyckhLy+PPn36hLbFx8fTvXt3Zs6cCcDMmTNJSEgIBQIAffr0wWw2M3v27FCas88+OxQIAGRnZ7N69WqKiopCafY9z540e85zIG63G6fTGfaScFZrBDZbJIZhkJHgB2BzkYsKj7+GSyYiIiIiVa1Kg4G8vDwAUlJSwranpKSE9uXl5ZGcnBy232q1kpiYGJbmQHnse46Dpdmz/0Cee+454uPjQ6/09PSDpq3NIiMTAYi2lJMYbccwYF1+2WGOEhEREZFTTa2aTeiRRx6hpKQk9Nq8eXNNF+mktGcQscdTTouU4JSiGkQsIiIicvqp0mAgNTUVgB07doRt37FjR2hfamoq+fn5Yft9Ph+FhYVhaQ6Ux77nOFiaPfsPxOFwEBcXF/aS/dlskZhMJgIBH+0bBAODhZuLarhUIiIiIlLVqjQYyMzMJDU1lYkTJ4a2OZ1OZs+eTVZWFgBZWVkUFxczf/78UJrff/+dQCBA9+7dQ2mmTp2K1+sNpZkwYQItW7akTp06oTT7nmdPmj3nkWNnMpmxWiMB6JAW/HfBpuIaLJGIiIiInAhHHQyUlZWxaNEiFi1aBAQHDS9atIjc3FxMJhP33nsv//d//8e4ceNYunQpgwcPJi0tLTTjUOvWrenbty+33347c+bMYfr06QwfPpwbbriBtLQ0AG688Ubsdju33nory5cv5/PPP+fVV1/l73//e6gc99xzDz///DMvvfQSq1at4sknn2TevHkMHz78+GtFsNmiAGibYgFgTX4pJS7voQ4RERERkVPMUU8tOnnyZM47b/9pJm+++WZGjx6NYRg88cQTvPPOOxQXF9O7d2/efPNNWrRoEUpbWFjI8OHD+f777zGbzVxzzTW89tprxMTEhNIsWbKEYcOGMXfuXOrWrctdd93FiBEjws755Zdf8s9//pONGzfSvHlznn/+eS655JIjvhZNLXpwLtcuios34XDEcd3orWzYWU6H9ARev6ET9RMisFlq1XATERERkVPG0dzjHtc6A6c6BQMH5/W62LlzJWazhc2VGdz+0TyKd7cMdM5I4Is7s7AqIBARERE56dTYOgNy+rBa9wwi9tOpYTSf3dGDpOjgug8Lcot54MvFlFaq25CIiIjIqUzBgByQyWQKjRvwestplRrHHyPO47HL2gAwdtE27vt8UQ2WUERERESOl4IBOai9wUAFAFF2K7f2zuT5a88A4LeV+SzZUlxTxRMRERGR46RgQA5qz/SiPl9F2Pbru6ZzZcfgzE9fz99S7eUSERERkaqhYEAOymqNAMDnq9xv3/mtkgFYvKWkWsskIiIiIlVHwYAclM22p2XAjWEEwvad0TABgBXbnXh8gT8fKiIiIiKnAAUDclBmsxWz2Qrs3zrQOCmKuAgrHl+ANTtKa6J4IiIiInKcFAzIIe1pHah07QrbbjKZQq0DS9RVSEREROSUpGBADikqqi4sfZqyrxvhn3FL2L5WqbEArMsvq4miiYiIiMhxUjAghxTpiMW+fRwGUL5uNAS8wRfQNDkGgHU7FQyIiIiInIoUDMihmW3ENB0IQLkPCr5qTukndph1K03rBYOB9WoZEBERETklKRiQw3L0fB+rCQzAXbaJUh941r1Ps7oOALYWV1Dh8ddsIUVERETkqCkYkMMyWexENx0Qtq3UB4nL76ZOlA2ADbvUOiAiIiJyqlEwIEckqtcH2MxgNgU/ewJgrH+f5snRAKzarulFRURERE41CgbkiJgsDuq1GkqqA8xRGRiAN2Mg7RvWAWDJluIaLZ+IiIiIHD0FA3LkerwHN3hwZE+CBpfhzhnDGZWfA7BIaw2IiIiInHIUDMjRMduwWx3w/9m77/iq6vuP469z7s5eJCEQIAzZIkNZggtFxT0qigNnbR1V22r9tbW2ts7WVq3VOliKWq2L4sSBk6GoyJAdNhmQcZPc5M7z++MmNwlLRgYk7+fjkYfJud9z7vdeIZz3/Y7PltkEInBUxVMA/LDViz+kRcQiIiIihxOFAdlvTncadDqLQARye59GSpyDQDjC6kItIhYRERE5nCgMyH5zODyYg/6EdfLnhIY9Fqs3kL+9qpV7JiIiIiL7Q2FADohz+Z9hzrEE5l1Dt/TojkLrFQZEREREDisKA7L/IkFcm/8LgG/dS+SluwHI36EwICIiInI4URiQ/Wc68PSajAGELOi8YwagkQERERGRw43CgBwQc/hTuG3R73NKXwJg/Q5fK/ZIRERERPaXwoAcGNOBK+8SADp2OxqAkqoApVWB1uyViIiIiOwHhQE5YI6Rz8D4+dgH3EaXtDgAlm31tnKvRERERGRfKQzIAXM4PJjL7sN6bzj9XSsBWLJFlYhFREREDhcKA3LgIkGcW98EoHf4AwCWbClrxQ6JiIiIyP5QGJADZzrwdJ8EQM+cTAC+36yRAREREZHDhcKAHBT3mBkYnc6kd8U07EaEzaXVrCuubO1uiYiIiMg+UBiQg2JYYdwF/yPeVs2wuMUAzFle2Mq9EhEREZF9oTAgB6fBVKFj4+cD8J+vNlFeHWzNXomIiIjIPlAYkIPmGjUFAzgx8TMy7KWs217FNdO/ojoQbu2uiYiIiMheKAzIQTNsTlxdLyDF5uXJYz4n0W3nq/WlPPTeytbumoiIiIjshcKANAnXiMeh0xnklfybfxz1KQAvLtxIiSoSi4iIiByyFAakSbgcHtgym0AETqi8lwE5iVQHw7z89abW7pqIiIiI7IHCgDQJuzMRW+45WECw26VMPKYrAO8vK2jdjomIiIjIHikMSJNxHf13GD8f/4A/cXK/LAC+3VRGkbemlXsmIiIiIrujMCBNxuVKgqX34n+9O1nLb+Co3BQsC579Ir+1uyYiIiIiu6EwIE3G5fBgbJlF0ILAmincdFwuAM9+ls+mEl8r905EREREdqYwIE3GtHtwdj0fgO0BGPFNV0ZmFBGKWLz6zeZW7p2IiIiI7ExhQJpU3IjHY9/7wnCh5zkAXv92C5ZltVa3RERERGQ3FAakSXnis0jtNQmAoAXjBubhsBls2OFjc2l1K/dORERERBpSGJAm5xnzPM4u5wJgp4bc1DgArRsQEREROcQoDEjTiwRxbHkdgFD+C3ROdQOwqVRhQERERORQojAgTc90YOt2MQDh3AvJTYsHYFOJpgmJiIiIHErsrd0BaZtsx/wTev6CiDuV3KU2QCMDIiIiIocajQxIs7DZnGDYCYcDdEnTmgERERGRQ5HCgDQL03QAEA4HYwuIN2qakIiIiMghRWFAmoXNFg0DlhWhS5oLw4DtlX6KvDWt3DMRERERqaMwIM3CMExM0w5WiDiHRd/sJAAWri9p5Z6JiIiISB2FAWk2tqV/hPdGEJ5/HcO7pwGwMF9hQERERORQod2EpHlEgti3vE4Q8K97nuGD72PqFzBj3ga2llUTDFuEIxZ/+8kgspLcrd1bERERkXZJIwPSPEwHcT0uA8AXhlFlfyTJHc2eH/xQxCerivl8zXb+9fGa1uyliIiISLumMCDNxjXqWRwGWIC5/hluOqE7AIkuO8f37gDAK4s2U14dbMVeioiIiLRfCgPSfEwH8T0uAaKjA1c57+fhnwzi3VvHMnXy0fTKTMAXCPPe0oJW7qiIiIhI+6QwIM3KM3oKpgEhC8Jrp3DeUVl0SvFgGAZnDcoB4K0l21q5lyIiIiLtk8KANCvD5sLd7UIAqjtdCLXFyABOP7IjAF+s2Y63RlOFRERERFqawoA0O/fIp6HTGdSsfwVr3lWx4z06JJCb5iEUsfh+U3kr9lBERESkfVIYkGbncngwt84mbEFg7VSI1I8CHJWbCsDizWWt1DsRERGR9kthQJqdYXPGpgrVhIGF18ceG9Q5GYBvN5a1Qs9ERERE2jeFAWkR7uH/AqAmAqybApEgkVANR+WmAPDtxlKC4UjrdVBERESkHVIYkBbh8qRhdD6LsAXhbldQ/smlFM7w0Cv/F6THO9lRFeCVrze3djdFAAiEFExFRKR9UBiQFmEYJvbB98P4+fgH3EP1+pexgJr1z/PzvAUA/PF/y3hvmWoOSOt65rN1DLj7PRbml7R2V0RERJqdwoC0GKczAZbeS9l/uxCxosfCFpwV+iMn9cnAH4pw63++Y01RZet2VNq1P7/1A4FQhD/+b1lrd0VERKTZKQxIi3E742DLrNjPdiP632AkxL96PsHI7un4AmHGPfwJg/74PmuKKlqppyKQ5Hb8eCMREZHDnMKAtBiXJ52MXpOIs4FpQLID3LV/AmvWTufRiwbQJzsRgPLqIK8s0hoCaT3pCc7W7oKIiEizUxiQFuUc8zwpR0wm2wWunlcR3/NSAHxhSF9+E6/+bBTnHJUDwMcrilqzq9IO1QTDse8zElyt2BMREZGWoTAgLW/kVJgYgBHP4ho1BbsBFlC9ehrxDou7z+qPacCqwkq+31zW6AZNpDkVef2x7+OctlbsiYiISMto8jAQDof5/e9/T15eHh6Phx49enDPPfdgWVasjWVZ3HXXXXTs2BGPx8O4ceNYvXp1o+uUlJQwadIkkpKSSElJ4eqrr6aysvHC0u+//54xY8bgdrvJzc3lwQcfbOqXI83FdMT+G9/9YiA6OsDC60mJc3LcER0AOOufX3DMXz7gVU0ZkhZQ4K2JfR+KWHtpKSIi0jY0eRh44IEHeOKJJ/jnP//JDz/8wAMPPMCDDz7IY489Fmvz4IMP8uijj/Lkk0+yYMEC4uPjGT9+PDU19f8QT5o0iWXLljFnzhxmz57Np59+ynXXXRd73Ov1csopp9C1a1cWLVrEQw89xN13381TTz3V1C9Jmpln9LMABC0Ir50CIR+/ndAXuxldYeytCfHLVxbzzGfr+Gp9SaNgKdKUGoYBFcETEZH2wLCa+M7qjDPOICsri2effTZ27Pzzz8fj8fD8889jWRY5OTn88pe/5Fe/+hUA5eXlZGVlMW3aNCZOnMgPP/xAv379+Oqrrxg2bBgA7777LqeffjqbN28mJyeHJ554gt/+9rcUFBTgdEYX+v3mN7/hjTfeYMWKFfvUV6/XS3JyMuXl5SQlJTXl2yD7afuHFxDY8CrEdSY5sJm4Xlfydce/sqPSz9Of5bNoQ2ms7f3nDWTiMV1asbfSVj3z2Tr+/NYPAFw2oiv3nDOglXskIiKy//bnHrfJRwZGjRrFhx9+yKpVqwBYvHgxn3/+OaeddhoA+fn5FBQUMG7cuNg5ycnJDB8+nHnz5gEwb948UlJSYkEAYNy4cZimyYIFC2Jtxo4dGwsCAOPHj2flypWUltbfODbk9/vxer2NvuTQ4B7+T8iZAL7NlIegYvVUju6SyKkDOnL/eQPplZkQazt93gaNDkiz8DeoPByKaGRARETaviYPA7/5zW+YOHEiffr0weFwMHjwYG655RYmTZoEQEFBtMJsVlZWo/OysrJijxUUFJCZmdnocbvdTlpaWqM2u7tGw+fY2X333UdycnLsKzc39yBfrTSVOHcKnsK3cNb+iawKQWTeNQD0ykpkzm3H8d1dJ+O0m/ywzcs3G8tar7PSZoUbrBMIhhU4RUSk7WvyMPDyyy8zc+ZMXnjhBb755humT5/OX//6V6ZPn97UT7Xf7rzzTsrLy2NfmzZtau0uSS3T7ia191VkOMFRu7tQ1doZEAnG2qTEOTl7UHTb0Uc+XL2HK4kcuIaLhkNaMyAiIu1Ak4eBX//617HRgYEDB3LZZZdx6623ct999wGQnZ0NQGFhYaPzCgsLY49lZ2dTVNR4j/lQKERJSUmjNru7RsPn2JnL5SIpKanRlxxCRjwLEwMk9IjuLlQVBmvBTxs1uenEXthNg09XFbN0S3lr9FLasHCDqUFB7SYkIiLtQJOHAZ/Ph2k2vqzNZiNS+49sXl4e2dnZfPjhh7HHvV4vCxYsYOTIkQCMHDmSsrIyFi1aFGvz0UcfEYlEGD58eKzNp59+SjBY/8nxnDlz6N27N6mpqU39sqSlmA7co6dhNyBiQc2aqY1GB7qkxzG+fzTszVq8tbV6KW2URgZERKS9afIwcOaZZ/KXv/yFt956i/Xr1/P666/z8MMPc+655wJgGAa33HILf/7zn5k1axZLlizh8ssvJycnh3POOQeAvn37cuqpp3LttdeycOFCvvjiC2688UYmTpxITk50msgll1yC0+nk6quvZtmyZfznP//hkUce4bbbbmvqlyQtzLA5ceddBEBNzvn1NQlqnVVboXjWd1uJ6NNbaULhcMMwoD9bIiLS9tmb+oKPPfYYv//97/n5z39OUVEROTk5/PSnP+Wuu+6Ktbn99tupqqriuuuuo6ysjGOPPZZ3330Xt9sdazNz5kxuvPFGTjrpJEzT5Pzzz+fRRx+NPZ6cnMz777/PDTfcwNChQ8nIyOCuu+5qVItADl/uUc9Q6a/Cv/FVrC8nY4yaFnvs+N4dSHTbKfDW0OO3bzO+Xza3n9qb7h0S9nxBkX3QcGRA04RERKQ9aPI6A4cT1Rk4dFnhAEUzXIQtcJqQ0mMS4WOewGGA6Uzkjv9+z3++rl8A3r1DPO/8Ygwuu60Vey2Hu9+9sYTn528EYFSPdF64dkQr90hERGT/tWqdAZGmYNicpPachAEEIlC0eiY7Xsqm8PkkAq/35OzaqUJ11hVXMbP2Jk7kQDXeWlRrBkREpO1TGJBDlnPM83ToNan+QNiHBXjL1zKyq4ffnt6Xf00awh/P6g/A/77XgmI5OA3XCajOgIiItAcKA3JIs495HnfX8xodC7hzCVoW147tzukDO3LqgOjuQt9uLKPIW9Ma3ZQ2ouHIgCoQi4hIe6AwIIe85LEzcJqQ6oA4GzDmFSor62tMZCW5OSo3BYDfvLak0Q2dyP5ovLWo/hyJiEjbpzAghzybI56MPlfhsUFCz8vBsFNTU0Yo5I+1uePUPrjsJh+tKOKz1cWt2Fs5nGnNgIiItDcKA3J4qK1ObB89HZcrEYCamrLYwyN7pDNhYEcAFm9SZWI5MA2nBoU0wiQiIu2AwoAcPmqLj7ndKQD4/Y1v+gd0SgZgyZayluyVtCFhTRMSEZF2RmFADjsuV/SmPxCoJBCoih0/snP0+PebNTIgByakaUIiItLOKAzIYcdud+F2J2NZFtu3r6C0dB0A/XKSMA0oqvAzb+2OVu6lHI4a7yakkQEREWn7FAbksJSUlItpRqsNV1eX4vd7iXPauWBoZwB+PnMRX68vac0uymGocZ0BjQyIiEjbpzAghyW73UVW1pHEx3cAoLQ0n1DIz91n9efIzsmU+oLc+vJ3WJY+3ZV9pzUDIiLS3igMyGHLMEySkjrjcMQRiYSorNxGnNPOC9eOwGk32VRSzZqiytbuphxGGu8mpJEBERFp+xQG5LBmGCbJyblAdLqQZUVIcNkZnpcGwNyVqjkg+65xnQFLI0siItLmKQzIYc/pTMBud2FZkVjtgeN7ZwIwd1VRK/ZMDjc7LxpWNWsREWnrFAakTXC7UwHw+70AHN87upbgq/xSqvyhVuuXHF52XiegHYVERKStUxiQNqGuKnFdGOieEU9umodAOMKX2mZU9tHO6wS0o5CIiLR1CgPSJjidCRiGQTgcJBisxjAMjj8iOlXoze+2UBMM460JtnIv5VC387Qg7SgkIiJtncKAtAmGYeJyJQFQXR2tLzDxmOjC4tnfb6PP799l+F8+5L1lBVoUKnu087SgoHYUEhGRNk5hQNqMuLgMAKqrd2BZFv1zkjlrUE7s8epgmJ8+t4gLnpzH5lJfa3VTDmEaGRARkfZGYUDaDJcrGZvNQTgcpLo6uk7g/vMH8tRlQ5l65dFcMLQzTpvJog2lHPfQXF75elMr91gONTuPDCgMiIhIW6cwIG2GYRjEx2cBUFkZnQ4U57RzSv9sTuidyV8vHMR7t44lM9FFOGLx30WbW7nHcqjZeWRA04RERKStUxiQNiU+vgOmaScU8lNTU7rL43kZ8Tx/zXAAvt9cTki7xUgDO/950MiAiIi0dQoD0qYYhklCQv3owO707JBAostOdTDMysKKluyeHOJ2GRlQWBQRkTZOYUDanLi4DhiGSTBYjd+/682+aRoMyk0BYNGGXUcPpP3aZc2Aio6JiEgbpzAgbY5p2oiLSwegqqpot21G9Yw+/uZ3WwH4dmMpT326lpUFGiloz+pGBtyO6K9GjQyIiEhbpzAgbVJcXAcAamrKCIVqdnn8giGdsZsGizaU8r/FWzn/iS+59+0VXDvj612mikj7YFlWbCTA7bABu04bEhERaWsUBqRNcjg8OBxxABQVLYsVIquTmeTm1AHZANz04rfU3fNtLPHxyardjyZI29bwvt9pi/5qVBgQEZG2TmFA2qz4+MzY917vll0qD//f6X1JcNljP/frGK1grC1H26dQg21EXQ6FARERaR/sP95E5PAUF5eO0xnP9u0rCYcDVFUVYrO5KC/fiNudTMfkrjx/zXCmfpFPdpKbk/tlccGT85i3dgeRiIVpGq39EqQFNdxG1GXXNCEREWkfFAakTbPb3SQldaKsbANe75bYcZ9vB3a7m6Nys3lk4mAikTChUJA4p41SX5AVBRX0y0lqxZ5LS2u4c5DLbu5yTEREpC3SNCFp8+LiMvB4UoFoleI6fr8XgHA4QNEH51M608PQ5OgUodMf/YxLn1lAlT/U8h2WVhHeTRjQyICIiLR1CgPSLqSmdic7exDZ2UfRoUNfAILBagAqvZuIbH6TsAVnOp/GJDp3/PM12/lsdXGr9VlaVt2aAcMAuxYQi4hIO6EwIO2GadoxDBO73Q1AJBIiHA7g++q2WJtj4xfyct5NsZ+XbfW2eD+lddTd+NtNA3vtepGwpTAgIiJtm8KAtDvRQOACoLqqCGvzLEwD0hzRx3OdG7i745MALFcYaDfqFhDbTANbXRiIqOiYiIi0bQoD0i7Z7R4Aqv0V0Oks7Aa4el6J0elMwhZkx0crES9dv74VeyktqX5kwGwQBlqzRyIiIs1PYUDaJaczAYBg0AcD78Jx9hqMkVNw2p0A9GAhBhEKa+LYVlrRml2VFlK3c5DNNLAZGhkQEZH2QWFA2iWPJ63RzkJ2ZxJEgsRvfRUDiDer6e9eCcD7b/+jdTopLarhmoG6kQFtLSoiIm2dwoC0SzabA48nLfazwxEHpgN3r6vIcEKKA05InAfAe+sMiARbq6vSQup2E2q4ZiCiMCAiIm2cwoC0W8nJXUlJ6UZKSjeczvjowRHP4rgkQNykACcdkQzAQt8gqoKqRtzWaWRARETaI4UBabcMwyAuLp24uPTGD5gOMB30OP4vZCWahCyTrzeUtk4npcXE1gzYGmwtqjAgIiJtnMKAyB44HHEM7RzdgvSKKQu5YspCHn5/JTXBcCv3TJpDw92ETIUBERFpJxQGRPYgGgacsZ8/WVXMox+t4bl5G1qxV9Jc6uoMNCw6pmlCIiLS1ikMiOyBzebgtIEdObWPm/MHJZOdFB0lmL1kWyv3TJpDOLJr0TEtIBYRkbZOYUBkLzqk5vCH8an88jgPz/wkCdOAxZvK2FTia+2uSRML1u4mZLdpAbGIiLQfCgMie+FweEhMzAEgLc5G3ywHAIu0oLjNCYfrRgbMWNGxiKUwICIibZvCgMiPSEjIJjOzPx5PWiwMLNlS3sq9kqYWarS1qNnomIiISFulMCCyD+x2dzQMZNaGgc0KA21NwzUDdpvWDIiISPugMCCyj1yuRPrUjgwsXF/CV+tLWrlH0pTqKhDbTQPT0JoBERFpHxQGRPaRYZj07phBWlz0r80VUxZS5gu0cq+kqTQaGVCdARERaScUBkT2Q2pKLs9clEFGvIkvEGbmgo2t3SVpIg3XDKjomIiItBcKAyL7wWZzMiCvLz8fnQjAM5+to7w62Mq9kqZQPzJgquiYiIi0GwoDIvvJ6UzgtP5pdEu1UeoL8sxn61q7S9IEGu8mpAXEIiLSPigMiByAOHcCVxydAMCc5YWt3BtpCuFwdAGxTUXHRESkHVEYEDkADkc8R1c9BsCKggpKqrSQ+HBXd+PvaLSAONKaXRIREWl2CgMiB8Dl8JBe/DJ5zg0AzPnffa3cIzlYDdcM1G0tGtbAgIiItHEKAyIHwOaIIz7vQobHfwPAXYsH8t2G7a3cKzkYDdcM1BUd08iAiIi0dQoDIgcobsxzXDWglKGexfgtF+c8sYCfPvc1lf5Qa3dNDkBsZMBWX3RMW4uKiEhbpzAgcoDsdhepLvhTxwdINCsAeG9ZITe+8A1zVxZxxmOfcfesZdQEw63cU9kXjUYGVGdARETaCXtrd0DksBUJkrDtNYJ2+Gfu//FW+Sm8XHYmc1cWM3dlMQBLt3gZ2CmZ84d2buXOyo8J1e0mpKJjIiLSjmhkQORAmQ48va4i2wVHuPK5JfPfnNZx14rEX28oaYXOyf4K72ZkQFuLiohIW6cwIHIwRjyLeVEVHlv0x4udj1I73ZyOyS4Avl5f2kqdk/0RarCbkE0jAyIi0k4oDIgcLHsc7u6TAOjjXsEnJ77FlEndeeK8JABWF1WyvdLfmj2UfRDeTQVihQEREWnrFAZEmoBr1LOYBoQscG1+gj5bfk1moo3eHaLLcv4+Z1Ur91B+TChSv2ZAC4hFRKS9UBgQaQKGzUVKj0swqC1UtfUtWHI3N4+Njg7MXLCRZz/PxxfQtqOHqoYjA/VFxxQGRESkbVMYEGki7rEzSe0xEQNwmZBcOJvBOSZn9E8A4J7ZyxlyzxzOeOwzVhVWtG5nZRehcH2dgfqiYwoDIiLStikMiDQh93Evkt3nCtKd4Ok5GcN08PNRcQzqnITTZlITjLB0i5c//m8ZwbCq2x5KdjcyUBcQRERE2iqFAZEmZoyaBhMDmKOm4nIlkeIxee7yPL6/+xTuPrMfAF+s2cHRf/lAC4sPIfVFx0zsZvRXY0TThEREpI1TGBBpDqYDgLi4DgD4fNtxmBEmj85j4tG5AJT5gjyshcWHjNjIgM2gNguozoCIiLR5CgMizcjlSsLhiCMSCVNcvJyysg38+ezezLxmOAD/+WoTRRU1rdxLgZ13E6odGVAYEBGRNq5ZwsCWLVu49NJLSU9Px+PxMHDgQL7++uvY45Zlcdddd9GxY0c8Hg/jxo1j9erVja5RUlLCpEmTSEpKIiUlhauvvprKyspGbb7//nvGjBmD2+0mNzeXBx98sDlejsgBMwyD1NTu2GxOIpEQPt92Kiq2MrpnBoO7pBCOWLy6aEtrd1PYfZ0BjQyIiEhb1+RhoLS0lNGjR+NwOHjnnXdYvnw5f/vb30hNTY21efDBB3n00Ud58sknWbBgAfHx8YwfP56amvpPSCdNmsSyZcuYM2cOs2fP5tNPP+W6666LPe71ejnllFPo2rUrixYt4qGHHuLuu+/mqaeeauqXJHJQ7HYXmZkDSEjIBsDvLyccDnDx0V0AeO2bza3ZPamlCsQiItIe2Zv6gg888AC5ublMnTo1diwvLy/2vWVZ/OMf/+B3v/sdZ599NgAzZswgKyuLN954g4kTJ/LDDz/w7rvv8tVXXzFs2DAAHnvsMU4//XT++te/kpOTw8yZMwkEAkyZMgWn00n//v357rvvePjhhxuFBpFDgWEYJCbmUFVVRCQSprBwCcf17IppRCsUby710Tk1rrW72a41HBlQ0TEREWkvmnxkYNasWQwbNowLL7yQzMxMBg8ezNNPPx17PD8/n4KCAsaNGxc7lpyczPDhw5k3bx4A8+bNIyUlJRYEAMaNG4dpmixYsCDWZuzYsTidzlib8ePHs3LlSkpLS3fbN7/fj9frbfQl0lIMw8DtTon9HK7ewJE50QDw6artrdQrqVO31aut4daiCgMiItLGNXkYWLduHU888QS9evXivffe42c/+xk333wz06dPB6CgoACArKysRudlZWXFHisoKCAzM7PR43a7nbS0tEZtdneNhs+xs/vuu4/k5OTYV25u7kG+WpH9k5ycS0pKV1yuRACOzo3+FZy5YIPqDrSyRiMDtUXHtLWoiIi0dU0eBiKRCEOGDOHee+9l8ODBXHfddVx77bU8+eSTTf1U++3OO++kvLw89rVp06bW7pK0M6ZpJy4ug/T0I0hOzuWs/h6S3CbLtnp56tN1rd29dq1+zUDDomMKaCIi0rY1eRjo2LEj/fr1a3Ssb9++bNy4EYDs7OgiysLCwkZtCgsLY49lZ2dTVFTU6PFQKERJSUmjNru7RsPn2JnL5SIpKanRl0hriYvrQIdEF7eOjY4SPPTeSk5++BMue3YBSzaXE4lY7FBRshbTsM5A3ZoBzRISEZG2rsnDwOjRo1m5cmWjY6tWraJr165AdDFxdnY2H374Yexxr9fLggULGDlyJAAjR46krKyMRYsWxdp89NFHRCIRhg8fHmvz6aefEgwGY23mzJlD7969G+1cJHKoqltDcEpvNwM7Rte+rC6q5LPV25n0zHx+/+ZShv75A56Yu7aVe9o+hMK77iZUV3tARESkrWryMHDrrbcyf/587r33XtasWcMLL7zAU089xQ033ABEb4BuueUW/vznPzNr1iyWLFnC5ZdfTk5ODueccw4QHUk49dRTufbaa1m4cCFffPEFN954IxMnTiQnJweASy65BKfTydVXX82yZcv4z3/+wyOPPMJtt93W1C9JpNkkJGRhmjbun5DCTwanMjwvDZfdxFsTYuaC6GjaA++uYM7y2lGwSHAvV5ODsbs6A9pNSERE2rom31r06KOP5vXXX+fOO+/kT3/6E3l5efzjH/9g0qRJsTa33347VVVVXHfddZSVlXHsscfy7rvv4na7Y21mzpzJjTfeyEknnYRpmpx//vk8+uijsceTk5N5//33ueGGGxg6dCgZGRncdddd2lZUDit2u5v09F5Y1kpuHeshM3MAX65cz2UzVjVqd+2Mr+kSV87pcW9xxygHxqhpAKwurCA9wUVavHM3V5f9UTcKoK1FRUSkPTEsq/1ul+H1eklOTqa8vFzrB6RVFRUtIxSqgSV3w5bZ3L3tl7xfcQJndNrEYt8RbCqtjrV9v+fldO1zDrdvvpE3v9vKoM5JvHnjGGqCYSr9ITISXK33Qg5jxz/0Met3+Hj1ZyPpmh7PsD9/AED+fadj1C4oFhERORzszz1uk48MiMj+S0zMofTTy2HLbAzg9qzHGehZwelxn/Gy/3T+zaWxtn/adgO+rYl849sKwOLNXtZ98At+l38x32ws5b/Xj2JAp+RWeiWHr4YViOtGBiA6OlC31aiIiEhb0+RrBkRk/3lcCaQUzSbeBlkuSLXXcH7KW3gML6ckfoTTCMTafl41nG98/XAafgyiU1ue+SbMl2t3UBOM8Ls3ltKOB/wOWMM1A2aDMKDCYyIi0pYpDIgcCkwHcb2uItkBZvfJJF6wBbsBBtDRUcSUrrfywRFX80r/v9PTmY+dIHdlP8wvOkSre79QclrsUt9tKuOlr2praGjB8T5rWGdg55EBERGRtkrThEQOFSOehWOeBNOBE8hM7wWVq7HMBLJdGzC7T4aRU3n7s0tZv+J1Emw+qiMenq+6nu2+6A3rEZlOVhUF+O3rS9ix9EkuMe8jvscluMbMbNWXdjhoVIHYrP+cpG7LURERkbZIYUDkUGI66r8/axWEfBj2OIxIMPaYc8zzdONSwutnktTlHO4amMLjn1cwvo+HCwfF8dDHXmYtq+bhVSPI6TSEEatfIC0SwX3ci630og4PddWGbaaBo8EagaBqDYiISBumMCByKLPHRf/bMCQQDQSMnkrYgtFl6xneLQG3O5Vw2M8dJ0anvLz9Qw23b/k9j3T+PYPWvkJHmx3bsc+1wos4PNSPDJgYRnSqUChiEQwrDIiISNulMCByuDId2ID09F6xQ5YVwTQ38uezO+G3NvHhimJu2Hw/WfYiXrFuoItpwqjprdfnQ1hszUDtqIDdFg0DmiYkIiJtmRYQi7QhhmGSktKNtJSO3HPOwNjxwlAmr5WNw7d2Bsy7shV7eOgKNVgzAOCoXTegkQEREWnLFAZE2qicFA//d3qf2M//LTuT8qCBtW4ahHyt17FDkGVZsWlCtrowYI/+etTWoiIi0pYpDIi0YdeN7cGyP44n0W1nczCHzyuHURIE78x4rHlXtXb3DhkNtw+tGxmo+28gpJEBERFpuxQGRNq4eJediUfnAvDfsjPwR6AyDP41U1WHoFbDT/9jIwM2jQyIiEjbpzAg0g5cOqIrAF/5BlMeTgcgmDtxl12K2quGIwN1IcBeu5A4pDUDIiLShikMiLQDXdPjObpbKhFMzlg3nb+6PsDb54+t3a1DRsNP/02j8chAULsJiYhIG6YwINJOXD6yGwBhC15bUsPzC7ZqmlCthp/+1xUcq1szEFLRMRERacMUBkTaiTMH5fDA+fXbjb60cDPbpifA/KtbsVeHhrpP/x02A2OXkQGFARERabsUBkTakYuO7sLqe8aR4yikNJzKq6UnUb16SrvfarTuhr8uAED9mgFNExIRkbZMYUCknXE4XPy07zYAXiw9l5IAlM6MJzLvSiKhmlbuXevwh3YNA7HdhBQGRESkDVMYEGmHfnLBb4h3mmwJ5rC0pg/VYSj4YRpFz3kIfHbpfl8vHA4SDh6+owu7GxmoWzugNQMiItKWKQyItEMep41T+ncE4JOq42PHIxaUrJn5o4EgFPKzffsKqqqKqaoqpujDCyh6Lh7/Z5Oas9vNpi4MOGsDAJEgdjP661FFx0REpC1TGBBpp84d3AmA18tPxW+l4jDBZkQDQemamVhh/x7PLStbTyBQRXn5RsrL1mFtnoUFlK55AevLyS3zAppQLAzYTQKfX07pc07s5YsBFR0TEZG2TWFApJ0a0yuDo3JTqA7bmbjpKZbWDCUzrQc2A8I5Z1FVXbbb8yorCwkEKusPGHbi8y6MBYmatdMPuy1LA6H63YS2r3qO6jAYvnxARcdERKRtUxgQaacMw+DP5wwgI8FJYY2HK9f/kbt5g4QLtsLAu/B6N1NZWUAkEo6dU1a2Hq93MwCJiR1JTMwhPb0XySe8jKfbhQBUhsFa8FMsyyIUqMAKB1rl9e2PRmsGOp0FgD0+p/YxjQyIiEjbpTAg0o4N6JTMp7efwJWjuwEwfd4G3lgWwOHwAOD1bmH79hVYVoTKykJ8vh0AJCRkk5iYQ2JiR1yuJADij52GaUAwApWrp1I851yKnk+i9DnXIV/LoC4M2Iz6UQC7GWn0mIiISFukMCDSzsU57fzhzP78bkJfAP74v+UsKkgkPr4DAKFQDX6/l5qaUgCSk3NJSuq0y3VsNgdJ9uj3FSEIbX4TgIAFrJtySE8dio0MmBZsmQWArWotoDUDIiLStikMiAgAV47OY8LAjgTCEe7+3yriEjoTH58JQFVVMcHarUNdruTdX8B0ENdzMq6dfqtELIjkTQbT0Yy9Pzh1dQbsDacJJXYBNDIgIiJtm8KAiABgMw0evmgQGQlOCrw1PDdvQ2wKkN/vxbIsTNOG3e7a80VGTiW116W4TXCYYACc/DnhYf9qkddwoOrWBThswMC7YPx87B2OAVR0TERE2jaFARGJcdltTBreFYA/zV7O6Y9/S4EvLva43e750WuYo58jrfdkOjjB0eU8sLkJ72Wb0kNB3af/9rrfiIYdmxkNAUEVHRMRkTZMYUBEGvn5CT24anQeDpvBuuIqbnxlK0WBbOx2NwkJ2ft2kZFTYWIA29CHAKipKiASqm7GXh+cXYqOATajNgyENDIgIiJtl8KAiDTistu468x+fHHHiXTPiGdreQ3nPPkd934UwOlM2vcLmQ5sNhd8ei6+N/tSOCPuRysbt5a6KsN2s/7Gv+77kEYGRESkDVMYEJHdykxyM+PqY+jbMRoA3vhuK399fyX526u4etpX3Pf2D1jW3j81d9sd4NsEgAWUr5mJ9cXlzd31/Va3ZsDe4Dei3TQaPSYiItIWKQyIyB51To3jnV+M4eGfDALgX3PXcsJf5/LhiiL+/ek6Hv94zV7Pd8Zl0jG9J9kuojUILChf8xzMu7Ilur/PYmsGbPXH6moOqAKxiIi0ZQoDIvKjzhvSmV+efASOBnPqAR79aA0bd/j2eq5x9mrMi6pI7TERAF8YwuumHVJ1B+qnCdUeWPIn7KsfA7S1qIiItG321u6AiBwebjqpFz87vgeGYWAacNmzC/l8zXbGPvQx5w7uxFmDcjihT+buT7bH4Rr7Is5ADYGNb1DTeSLxLdv9varfTcgCK4S5dRYO44zax8Kt2TUREZFmpZEBEdlndpuJzTQwDIM/nzOAeGd0Xs3r327h2hlfs71y71uIukc8AZ3OoHLdS4RfdML8q1ui2z8qEKtADBh2zNxzsRvREBDSwICIiLRhCgMickC6ZcTz5GVDmXBkRwBCEYuPfija6zlx7mRsW2cTtqA0CDWrpxwS04V2rjNgG3w/9gF3ACo6JiIibZvCgIgcsDG9OvD4JUO4ZVwvAN5fXrjX9qbdQ0qv6PaigQiUBKH68yuavZ8/pq6WgNMWHfUwDBt2W3TUIxhRGBARkbZLYUBEDtqpA6LFyOauLGJr2d6LizlHz4CcCbGfvWtfxPpy8gE9byRi4Q8d/Jz++t2EDAwrgmnaYjsLBTVPSERE2jCFARE5aH2ykxiel0YoYjH1i/y9tjWsEJ7Ct2I/hy0Irpu+39OFlmwuZ8yDH9Pvrvf4blPZgXQ7JrZmoPBdzPeOxvj2jlidARUdExGRtkxhQESaxPXH9QDghQUbKa/ey4296SC512RSHeBJ7AqAv9NPwHTs1/O9sHADW8qqCUcs3l1acMD9hvqRAUf5txiAsenl2AJiFR0TEZG2TGFARJrE8b070DsrkapAmBcWbNxrW3PUVDyTArgmLIJOZ1Cz4eX93llo0YbS2PdLtpQdSJdjYnUG0gZgGGB0nYjdFt15WSMDIiLSlikMiEiTMAyDa8d2B2DqF/lsK6/mpYUbWV1YsfsTTAduZxzGltkEIxBcs+87C5VXB1lVWBn7+fvN5UQOYqFv3af/ji5nY56xHHPYIzhiawY0MiAiIm2XwoCINJmzBuWQneSmqMLPyPs+4jevLeG65xZhWbu/oTbtHtzdLgCilYlZeP0+PU/dGoFOKR5cdpOKmhAbSvZeCXlvYmsGbAaGzYVhROspgCoQi4hI26YwICJNxmk3ufXkXo2O5W+vYtlW7x7PiRv5JADVEbDW7tvoQN1ow6DcZPIyorWMNx1EGGhYZ8AwbBiGicseDQN+7SYkIiJtmMKAiDSpnwzL5eyjcujbMYkhXVIAeHvJtj22d7rTsMV3IWKBz51HJPLjW4Wu214FQF5GPNnJbgAKymsOuM91YcBpMzBNG4Zhwx1dMkB18OC3LhURETlU2Vu7AyLSthiGwSMTBwPw+reb+WZjGV+u3bHn9laIeP9GvEB5eT4Vz3nI7D0Zc9TUPZ6TXxwNA90zEthRGQCgwHsQYaB2XYDdBoZhYhgm7tqRgeqAwoCIiLRdGhkQkWYzrGsaAEu3lO/5ptp0EN/zChzRe28iFtSsnYavsoCCgsUUF/+wy2jBuu3RxcPdO9SPDGxrgpEBhy1afdg0bbhrO1QdDO9xzYOIiMjhTmFARJpN51QP2UluQhGLxZvL9tjOGDWN9N6X46r9jeTreC5V1aVEIiGCQR9+f3msbaU/RKHXD0RHBrKT6qYJ7b3y8d7UrQtwmNROE6ofGQCoCWrdgIiItE0KAyLSbAzDYFi3VAA+XVW817bmqOkkXVwOnc4gsPF1gt/8JvZYIFAV+35lQXQxcodEF8lxjiYZGfAFQgB4HGbtNCFbbAExaN2AiIi0XQoDItKsTh2QDcDr324h/CO1ABwOD0mFs6M/bJkFVvQmPRCorynw7cYyAAZ1TgGgY7IHgMKDWDNQVTuFyeM0YrsJ2Zbdg9OIrkdQGBARkbZKYUBEmtW4vlkkue1sK69h3l4WEgNgOkg44iribECns/DEdQAgGPRhWREsK8K3tTUGBtfuVFQ3TajUF6TmAG7ag+FIrAJxnCO6m5BJBLbMwmVEpyNV1/j3+7oiIiKHA4UBEWlWboeNs47KAeCh91fGpuTs0YhnSb7UT9px00lM7EJ1KPprqqxsPZs2f8PX+dFAMTg3BYAkjx17bYGwkqrAfvfP12Bhs8dhYBgmmA7MzmfjMaOjDTVhY0+ni4iIHNYUBkSk2V0wNBeAxZvKOPOxz2OfxO/sh21e3vxuC16/QUGlg1Mf/YIJT21jmzdMdXUpryz2UVgRIDXOQbfEMrZt+5aamlLS4p3AgYaBaDixm/W7CQGYR/0Fd0J2bRtNExIRkbZJdQZEpNkN6pzMyf2ymLO8kLXFVbz89SZ+MiyXSn8odiNfEwxzydPzKfUF6ZYeR7eMeNYURdcKfJlfQ/cMB//6Mlp5+GejkyBcjgVUVhaSFu+kqMLPjgMIA1X+2vUCDgOsEKZZGwbM+kXEWjMgIiJtlcKAiDQ7wzB4+vJhTP0inz/+bzm/e2Mpv3tjKQBDuqTwyMTB/LDNS6kvCMD6HT7W7/DFzv9mS4CvNwcIR+CkXm5O71P/qysY9JEWF72B31G5/3P7q/zRkYE4vPDeBIy+V8LIKZimvb7WgEYGRESkjVIYEJEWc+mIrny5dgdzlhfGjn2zsYyz/vk5phG98Y5z2naZlrNoc4BI7cyiK0ZkYxo1GIaJw+EhEKgi3h6d238g04SqaqcJxVklGICRPxWG/zsaBmpHBg5kYbKIiMjhQGsGRKTFOGwmT0wawp/PGcCFQzvzwrXDObJzMqW+YGyKz0vXjaBTSnS70CFdUnDZTbw1FpUBi0SXnVF9+pKS0o20tJ6kpvbAZnOQ4on+KjuQaUK+umlCLg+mAXS/CkwHhlFfhVhrBkREpK1SGBCRFmW3mVw6oisPXTiIUT0yePmnIxndMx2Aa47N48jOKfzf6X2xmQbnD+3MkZ2TY+cO756O3WYSF5eOy5WIzeYgKakzqXHRX2UllQc+MuBJ7oxx2rcw4lmARiMDWjMgIiJtlaYJiUircjtsTL/yGJZv8zKwU/TGf8KRHTm5XxZOu8mGHT6+Wl8KwPj+Wbue704h1RNdM1BcWb3fz1/3qb/HYWDa3bHjmiYkIiLtgUYGRKTV2W0mR3ZOwTDq9/N32qO/nnpnJcaOndIve5dzDcMkIzEOgB0Vvl0e/zGxBcROA9Os/3zENO24tIBYRETaOIUBETmknTYwmzG9Mrjt5CNIjnPstk12SjQwFBXlw/yr9+v6dVuLxjnqawxAdGtRT+kXAFRvfOdAun7gIsH9Oy4iInKAFAZE5JAW57Tz3NXDufmkXntsk5uaBEBxMI3I2qn7ddNcV3TM42g8MmAzDNxVy6JtSte02I24//PLKH/OSWTelYQCFfi8GwkHfZR/fBFVzzth3pUt0g8REWkftGZARA57ORkZGFiEcFDY8Ro6mrsfQdidqkZhoH5kwOZIwJ3aA3aAz9MP9uOa+yoY9GGF/Tgc8Rg2JzW+7ZSsej7arx+mwQ/TADANiFi1/VozDTfAyKlN3h8REWl/NDIgIoc9p91Genz0s42NnX61X+fWbS0a5zQbjQwYhkFqjzMB2O4e1EQ9ref3eyn+6GK2v5BGxfMumH81VVVFu21bFwQAqsJA/jRNGRIRkSahkQERaROyk91sr6piy/uXQemA2BahP8ZbE72p3nnNAEDH5Gi9g4LymqbtLOAty4ctswDwRcBcNQV/eWGjNulOsBtQFoRABCwgZBGrhSAiInKwNDIgIm1Cx6TotqBbgxlYa6fs8yfnRRV+ANLjrEbThAA6psRH25Rs3++FyXvj93sJhkOYnc/GIPrJvzcEbHkLpwlZLujgBFePydguqiK992SyXECnswifMh9r+NNN1hcREWnfFAZEpE3ISU0AoCiUQSCuxz5/cl7ojX7q32HJVZhf39zosbpKyBWRBKpWv9BkU3PqpgN5jn6YFAfUbaiaYIdUB9i6T8ZxSSC6LsAeByOnYl4cwBz0JwBCoaYfqRARkfZJYUBE2oTsJCcABcEOVHvXQujHaw6EwhGKa0cGMuwlmOufa3TDn5bcgThbtKrxtqxrmmRqTiQSxu/3AhCfmIOn11VkuSDTCUn2aBBg5NRdn8t04Fh2D7w3At/nkw+6HyIiIqAwICJtRLeMaK2BzcEcfGHY8Xw8lXMvIhys2uM5O6oCRCywGRFSbeXYelzZ6CbcZnPQwRUNFZuqnE3ST7+/HMuycDg82O1uGPEs5sUB7JcEYGJgz7sERYI4Nr8KQFX+KwQ+u7RJ+iMijYXDwdiHApZlYVnWj5whcnhr9jBw//33YxgGt9xyS+xYTU0NN9xwA+np6SQkJHD++edTWNh44dzGjRuZMGECcXFxZGZm8utf/5pQKNSozdy5cxkyZAgul4uePXsybdq05n45InKI6t4hOk1oY6ATlgX+CHjXvUzJ8wlY867a7Tl1C4PT4uw4TpuPMXJK4waRIFlsAGDLpm+bZJpQdXUJAG53Sv1B01H/tSemg4Rel+Oq/a1dtW6mdhQSaWI+33YKP7iAiuedWPOuYvv2HygqWoLfX9HaXRNpNs0aBr766iv+/e9/c+SRRzY6fuutt/K///2PV155hU8++YStW7dy3nnnxR4Ph8NMmDCBQCDAl19+yfTp05k2bRp33XVXrE1+fj4TJkzghBNO4LvvvuOWW27hmmuu4b333mvOlyQih6iu6XEYBlRGEgibKbHjQQtq1uy+EFndeoGMBBs2R/yuFzUd5KTWjji4jz/oaUKhkJ+amnIAPJ70/T7fHDWdpJ7REYGaMETmX7ff13jms3Xc/OK3fLFm+36fK9LWlZeugy2zqAiBf81UgoEKwuEgpaXriETCrd09kWbRbGGgsrKSSZMm8fTTT5Oamho7Xl5ezrPPPsvDDz/MiSeeyNChQ5k6dSpffvkl8+fPB+D9999n+fLlPP/88xx11FGcdtpp3HPPPTz++OMEAtH5u08++SR5eXn87W9/o2/fvtx4441ccMEF/P3vf2+ulyQihzC3w0bn1OiC321jV9Cx92Uk1G4OFIjs/pzC2vUCHeJNzD3c6HfvOw6ADc5RBz1dwOeL3oC7XEnY7a4DuoZj1BQcRnSbUf/aafs1OrB0Szl/fusHZi3eyq3/+Y5Cbw2RiKZAiAAEg9VYS++J/VzeYDJCJBKiomJLK/RKpPk1Wxi44YYbmDBhAuPGjWt0fNGiRQSDwUbH+/TpQ5cuXZg3bx4A8+bNY+DAgWRlZcXajB8/Hq/Xy7Jly2Jtdr72+PHjY9fYHb/fj9frbfQlIm1H94zoVKG12/0Yo2dg7zYRgHDnC3b7qf7m0uh6gMwEA5tt92sCemSmALBx/WJCX07e7z5ZlkV5+SYKC5dQWVkAQHx8h/2+TozpwJV3EQA1EWDh9ft2XiTIO0u3xX4sqvAz/N4PGXn/h8xZXriXE0Xah1DAS9WmD3mx9BzWBzoT7jgBAI8nDYCqqmKqq0sBsKyIpulJm9EsYeCll17im2++4b777tvlsYKCApxOJykpKY2OZ2VlUVBQEGvTMAjUPV732N7aeL1eqqurd9uv++67j+Tk5NhXbm7uAb0+ETk09ekYndKzZEsZALYR/4bx8wkNvHu37VcXVgLQreBv2Bb/ZrdtuqdHP8HfGOhE9ZoZ0RuAPdwEhEL+XaYSVFYWUFVVRDgcHdW02Zy4XMn79bp25h7xBBCdKhRcs/eaCuFwkLKPLqTqeSdvL/wu+prid8QeL/T6+dUriwlrhEDauWA4xL98d/NY8TVctv5xNq9fxEMzpnPxE19y26wKvsivYeXG1RQUfEfB++dQ+byzSeuPiLSWJg8DmzZt4he/+AUzZ87E7XY39eUPyp133kl5eXnsa9OmTa3dJRFpQsO6Rj/B+2p99NM7m80Fhj12I76zVYXR0cE850ZsG1/a7U11tw7RG/eKSCIFgSSqXu9N8IVdbwJCoRqKi5dRVLSUQKB+B6OamtLY905nAmlpPTEMg4PhdKfi7nYBFlAZZo+jA5ZlseOjC/Gt/y/fVHUlvyoRpxHk39nXM73rTbzfMzpyUl4dZGWBFkhK+1ZZVc6c7QMACGPjb0U/4/XyCazwpjB/fRW//l8Z50wt5vqpX1G2cW707966fS9wuK9qgmEmPjWPxz9e06TXFdmTJg8DixYtoqioiCFDhmC327Hb7XzyySc8+uij2O12srKyCAQClJWVNTqvsLCQ7OxsALKzs3fZXaju5x9rk5SUhMfj2W3fXC4XSUlJjb5EpO0Y2jW6PmlNUSUlVYHY1B/LihCJNN6NzBcIsbk0uoA4z7UJd4/Ju51K5HHa6JgcHR1Y48+lvDyf4gDUrJ6C1WDb0urqUizLIhIJUV6+EYiOCgSD0ZHK7OxBZGT0xuHY/e+n/ZUw6ikgumuStXYKkZ0KkdXUlLNt60JCm97kw4pjuWzD4wAcE7eIeFs1R7jySTArGRm/CIAF+TsQaa9CX07mi1cmUxmoHyFb4BsKwHGZBXgc9dXJvyvP4fmS84lYUB4Ea/61TdqXV7/ZzPx1JTz03somva7InjR5GDjppJNYsmQJ3333Xexr2LBhTJo0Kfa9w+Hgww8/jJ2zcuVKNm7cyMiRIwEYOXIkS5YsoaioKNZmzpw5JCUl0a9fv1ibhteoa1N3DRFpf9LinfTKjK4bOPovH/DkJ+uoDtmB6BSehlbVThFKdfjIdHgxzT3/OuyfkwLA8pojYsdKglD0fAKRL64AGo8ABIM+Kiq24vVGFxw6HHGYpn2fXkOlP8SyreU/2s7hSsGM60LEgsIAFHx4IcXFywkGqwmF/JSUrAHDzsqkK/njtl/Fzjsn5QM6OKGDM1r5+Ej3UgC+Xq8wIO1UJIh31XTmV0Vv/k9N+gKPI/r7oEOik7svn8jLPx3J45cM4enLhwHwWtkEysJJVIWhfPV0mHdlk3XH59euRdKy9u1fp/2QmJjIgAEDGh2Lj48nPT09dvzqq6/mtttuIy0tjaSkJG666SZGjhzJiBEjADjllFPo168fl112GQ8++CAFBQX87ne/44YbbsDlin5Cd/311/PPf/6T22+/nauuuoqPPvqIl19+mbfeequpX5KIHEauPjaP37y2hHDE4oF3V/BuJzf/PDcZr3cT8fGZ+Hw7CIcDPPVxdL//gc7FuE2iw/3HPLnb0YGhXVP54IdClhonAK/HjoctqFgzg0QgmHczEN0pyO/3UlFRv1g3ISF7n/r+0YpCfvf6UraW1/DoxYM5a1DOHtsaVgiXfyPVQMQCtswmCBTXro/YWBriP99V8cGqCwhhcXTcUn6b/QRHxm/AzLscRjyDZ+7FHFG1DoBV61cDw/apnyJtSdiyqHHnMt83BIDz+5r839jj2FBSxZAuqcS7ordKAzsnY1kWAzslsWQLvFZ2FlelP091GJLXTcMY/lSTVCm30PodaVmtUoH473//O2eccQbnn38+Y8eOJTs7m9deey32uM1mY/bs2dhsNkaOHMmll17K5Zdfzp/+9KdYm7y8PN566y3mzJnDoEGD+Nvf/sYzzzzD+PHjW+Mlicgh4sJhuUwY2JEeHaJ1AxZvqeGFb6oJBKooLc3H7/eyfFsFby+Prhe4Mv2laBjoftUe/yGvm360tCSFJBskNPgYxRcG/7oZYIWw292kpHTFNKNTCgzDICtrIB5P6u4u28j8dTu4atrXbK0thPboh6tZtKGE372xhPXbd1NF2XSQ1GsyCbboJ/wArm2zwYpOh3riywpeX1JNhd8iwWXnn2M2clTCBszuk2HUdDAdxI+eQp4zOqUpvyKOYNC/6/OItHHVVYVsLguxJZiDwwgy8tTf0iU9jjG9OsSCQB3DMLj+uJ4APLNjIuPWvMKzOybi93RvkiAA0HAHY1U/lpbQ5CMDuzN37txGP7vdbh5//HEef/zxPZ7TtWtX3n777b1e9/jjj+fbb79tii6KSBthMw0enxT9hO+/izbzq1cW8/T8CtLiYEK/OCKWjUc/jY4KnJw4lwFxa7GbREcF9uDIzsk4bSbbw2kUhDvTM8NDUuVqimy5hKo2UZF1NgBbKhwUBavpldGTQKAClytxj1uW7uzlr6MbGvTOSmRlYQVriio5/4noVslfry/lfzcdi8PW+PMb26ipJI14ioT510D+DMweVxHMHIjXV8Vn6wpi7Z68dChZvcZD5B+NblgcriS69BhL3HofPiuO9R/fQa9T/rFP/RVpC6qrS/BWFrHAEZ3uNzS9jIQ9rDusc1LfzNj3voiHV0rP5Gfel3FHgk00MlAvGLZw2g9uwwGRH9MqIwMiIi3h/CGdOHNQDqGIxV8+8HLLrGoumVnKN1sCuOwmtw0uJ9XOXkcFIFrQbHj36E5Fc3t+DGetgokB3KfNg05nENr8JvmzLuTCZ1ZyxmOf89CcjSQmdsTpTNinftYEw7y3NHrzfu95A5gyeRgpcfX9WVFQwemPfMaCdbuZ1286MEdNx7w4ACOexeGI48v1QSIW5KZ5WPXn0zi2V0as7c4SRj1JN1c0iKxc87X2Tpd25f0l6/jje2X8bfWxAJxw9JgfPcftsHHDCT2Ic0ZHAMsjyXxV1QdrwU+bvH81Ia0fkOanMCAibZZhGPzjoqP42fE9AFi4vpyNJdFCY/+8ZAh9T38K+yXRm+gfc3zv6KeB/1tSSDAciU6z8aRgbp0NwAeVxxGyor9SX1m0mUBoD2WPgbtnLWPsgx/z6qLNAHy0ooiqQJhOKR6GdEnlxD5ZLPy/cXz7+5N5onaUY3VRJRc9NZ+zH/+C1YW72Qa0wY3+c/M2AHDOUZ1w2vf+a94dl0FeXHSkZGX4yCab6iByqFtVUMbtswp5b2V0al6Cy85Phu1b/aFfj+/D0rvHc+aR0XpHX/uOJLh2apOE6YY1P2oCCgPS/BQGRKRNs5kGt4/vzVOXDeWkPpnRn0/tzcn9aosW7uPN76kDsnHaTRZvKuMvb/3AtC/yeWzuJhxmPB7TYG7FsbG25dVBPl1VDETn/H62upi3vt+GZVls2FHFtC/Xs7HExy9fWcyWsmpe/za669CZg3JiNQicdpPUeCenDezIgxccSe+saEG1xZvKeHjOqt3OJZ65YAM9/u9tFq4vwW4aXDqi64+/sEiQPNtqANZXujUyIO3Gc/PW4a/dcfiYvDTuOac/qfH7Nq0PwDQNjuqSDsCqmh7UdLqwScJ0TTDc4Ps9f6gg0lRaZM2AiEhrMgyDU/pnc0r/bGqCYdwN9gzfV51SPPzz4sFc99wipn25Pnb81bgpnBH/NvmBzsQ7bZw5KIeXvtrEQ++t5G9zVvHDNm+s7YMXHLnLp/rXTP861ubcwZ12+9w/GZbLhUM78+LCTfzf60t4Z2kBxz7wMe/fOja2wLHSH+L+t1fEPlW8ZVwvspL2ofCj6SCvc3cohg0M1MiAtAuWZfHBD9HA/sgFeZw9rN8BXad/TrRe0crQAPzr/xItRrgPI417U91gNEDThKQlaGRARNqVAwkCdU7pn80ZR3ZsdGyTL54nii8E4JZxR3DDCT0xDVhZWNEoCAD8cdYynv4sP3qt2pGJujY/Hdud3tmJe3xuwzC4ZHgXxtTO/99SVs0pf/80dv4/P1pDRe3HnE9MGsINJ/Tc59fVY8Qt0dcSyNrnc0QOZ4s3bGWbN4TLDif1zzvg6/SrDQOF/kSKQilNUpG4sqY69n21pglJC1AYEBHZDw9ecCRPXTaUd34xhq9+O46BnZIBGN8/iytHdyM3LY6fHd+D7h3i6Z4R3d504tG59MxMoKr2H/bOqR4emTiY447oEDv31+N779PzP3XZMH5zWh8gGgjOfvwLfvb8Ip78ZC0Aj148mNMGdoxNN9oXPbKiW5+WVluUfdK01VRFDkXvLlkPwMi8pB/dPWhvktwOBtQGgo8rRmLlXXnQo2s+f32YaDhlSKS5aJqQiMh+iHPaOaV/fRGxV64fybKtXo7KTcFmRm/Afz2+D78eH71hL6qoISPexfx1O7j02QXYbSb/d3pfPE4b0648mg07fHRNj9vnm3eP08b1x/UgLd7J7f/9nkAowju1OxHdMq7XXguV7Umi0yDNVkpJOJXlKz5l1Ggf2OP2+zoih7pIqJqCouV8vjZau+PkAfu2YHhvzhnciaVbvbwWvpkrBx9H/EFer6bB5gM1e9mIQKSpaGRAROQguB02hnZNjQWBnWUmujFNg1E9M5hz23F8+ZsTOX1gdKqRYRh0y4jfr0/x6/xkWC5Xju4GQL+OSfzmtD784qReB/YiTAf906JTE76uPILqF+Ojc59F2pDgF1ewbXocH334HEsLop++n9Rn36qD7825gzuR7DZZtyPMjAbriQ5UdYNFw5omJC1BYUBEpIX06JBARoKrya73+wn9mH/nSbx187Fcf1yPAwoVdY4eFN1f/fuavlSEaJK5zyKHjEgQ7+oZ3F94E79bdjIAfbITyU7eh0X2PyI9wcX1o6O7Cr23vPCgr9d4N6HQQV9P5McoDIiIHKZM0yA72X1QIaDOsG7RhcnfV/cjEDGI5E3WzkLSZliWxfcJV/I/7/jYsXP2sHvXgTgh+C8AFm+uoPjjgys+VtNoZECBXJqfwoCIiHBUlxQSXHaKQh14t+vHePv+Ybe1DEQOJ5FIGO/ciZQ/7+L1/GjhwDM6bWTOrWO5dkz3JnqSILnbp9PXtQoLk2nflMO8Kw/4co2nCWlkQJqfwoCIiBDntHPjidHtSJ/40kdxWTHbtn1DWdkGLEuLGOXwVOndROW6/+ALw+KKbgCc45hGrw7uPa7z2W+mg/gjrmJyxpsAvFByJr41LxzwNLtGIwPaTUhagMKAiIgAcOXobnRNc7PDF+Hxz6PF0Xy+7Wzb9i07dqwmEtGnlHJ48fvLAfCG49kQiO4cNLjvkKafAjfiWc6//j06uisoDafw4o6TYOH1B3SpGo0MSAtTGBAREQBcdht/PvdIDAPeWFrNb9+pwlsTvTHx+72Ula1v3Q6K7IdwOMDWBffz+22388stfwSgq3Mr6WMebZbnsztcXDo6Wi9kdvlxB7wIPxSpn56nOgPSEhQGREQkZkyvDvx+Qj/spsHHqyu4bOYOrnhhO9f+ZwdFZaWaNiSHjUBNKf/9wcWHFWNZVhOt+3F8p+pmXRh/xlHRasaLq/uy3TnogJ4r0mCtTiCkMCDNT2FAREQauerYPN64YTRd0uIorgqzenuIZYVB3vmhOjZtqLq6tLW7KbJXgZCf5dbI2M+GAVecd1WzPmfX9HiOcK0lgo0529IPaGQg3GBkoOH3Is1FYUBERHYxoFMy794yhv45SbFjH6wOxL4vLV1HeflGqqqK8fm2t0YXRfaqZuEtrPCmAnDjCT158tKhdO+Q0LxPajoY28kHwGfhsw9oZCDcYOAtFNEonDQ/hQEREdmtOKedGVcdw29Oi06xWFbgZ0cwI1bXoKqqmPLyjZSVbSAQqNzl/EgkRDBY3aJ9FgEI+r2sX7uAqkg8LsPPLSd2Y3z/g682vC+OP+5iAL4oziD4xeT9Pr/hNKGIwoC0AIUBERHZo/QEF9cf14MT+0T3aH9/ZQ0dOw4hISGrUbuamvJGP1uWxfbtKyguXk5p6ToAwuEgO3as1kiCNLvqedexLtAFgCOSfdgdTVf5+8cc3a0D8WYV5eFkFiz5cr9rDjQcGdA0IWkJCgMiIvKj6qq1vv7tFizLIimpMxkZvUlOjt5w1dSUNSpSFghUEAr5AaiuLqWiYhuFhd/X7kq0ge3bV7B9+8raUYWqH33+SCREsHo7lmXh8+2gqnw91VVFscdEYiJBguv/w3p/dCvRXnn9WvTpXa44RmfuAOCTiqGE103br7UDYavh9xoZkOZnb+0OiIjIoe/kvlkkuOxsLq3mxhe+5Vfje+MLhOmZkYRhGIRCNXi9m0lOziUU8lNamt/o/IqKrY1+rgsAgUAlPt92DMPAbnfjcSVFRx1MR/QGynQQCFRS8lp/Ir6N4OkMBuDbDIC381mEB9yF3e4iMbETHk9qi7wfcmgL5pxN/pZoUO2RmfQjrZveCSNP5f3Xl/NJ5QhuDr9E4j6eF9lpJEAjA9ISNDIgIiI/yuO0ceqA6Jzrt5Zs44S/zmXCo59z5xs/kJIS3U6xqqoIr3cL5eUbiURCGIZJenovbDZn7DpudzKmGf0cyuHw4HYnA9FpRcFv7sT731yKZzgJvtGT8uecVHx8Edu3LYoGAYDqzbEgABDePAuW3F0bQNbtEjqk/bCsCJWfXEz5c07yt27mg4qxAPTKbOZFw7txSv8cbEaEVf6e/FCdQ3je1ft0Xminm/+dw4FIc9DIgIiI7JNfj++NzTD47zebY59YvvbNFipqQvzp1GSskJfKyoJY+4yMPjgcHjp06EcgUInLFR1FCAarCQar8HjSASgrW084WIW9YBY+IBiB4pK10Yvkvxz9Ajw2qAmDy4RUB5QGoSYCnoLZ2IY/SqWvhIqKbYTDAeLjs3A4PC36/kjr8lVuw7v2Jdb6u3LH1p8RwUamfQfDu7X8yEB6govRPTvw6eodzPGOpefq50gzbTBy6l7Pa7h4GBpPGRJpLhoZEBGRfZKV5OaBC47k8ztO4MNfHsf/nR7dZWjO8kLeW20SH98h1jY+PjN2M26aNtzu5NguRA6Hh7i46K5EhmGQmppHRuYAUnpfRfIePqJy1waAbFf0v0be5aT1nkymE1KOuJLE5G6xtj7fDnbsWEkkpJ2M2hO/38uGQCeu2/hXtgazybTvYNaJ80iOj2uV/pw5KLrO5oOKMdSEwdqHtQM7TwvSNCFpCQoDIiKyXzome+jRIYHrxvbgt6f3BeDpzzYQlxBdVJye3ovk5Nz9v/CIZ/FM9GKLZgbibZDjhqzaAED3qzAuDmBcHIBR02HkVOyXBDBGTsEwjEbrBSKL/0DFzDiYv2/TM+pPbHyzFomEYqMNDdXUlFNWtoFQqGb/X6c0OcuK4P/6Dh4ovJFqy8MAzxpeOu4rsk98otX6NH5ANi67SX6gKx9VjibU7fIfrTuw8zQhhQFpCQoDIiJywC4b2ZWMBBdbyqp587utVAWdXDF9GX97f2Wj3YXqNDz2zcZSfvv6ElYUeGPHTGcimX2uJNsFyQ4gbzK2ugAw4tnozVTDG6oG3ycl5ZKcnEtaShfYMouqMFSvnlJ/g7+XT2UjkRAVn1yMb6aTmk8vgUgQy7IoKVlLRcXWRguiA4FKSkrW4PNtp7x8I6Wl+ZSUrKGsbEN9aDiAyrNyYCzLouyjn/DVmo18Vz0QpxHg3zdcRveTH2vVfiW5Hfx0bHcAZpacTzD847tehcONdw8K7+bvkEhT05oBERE5YG6HjWvG5HH/Oyv4y1vLefTD1Wws8TF/XQk/bKvgwQuOJC0+uoD489Xbuf2/izl/aGeO7JzCdc99jWXB20u2cfrAjrjs0WvljJyCMfzfbCrxsbywmpOxY5rGXvsRDEewm3bi4zMhEiTBBpVhqAqDB/B9chH+9S/jzptEZd//Iz4+k7i4jNj5pTtW4V/7UvSHNS+SuP5FjC4/IdDrNjDsBAKVbN26CMMwGgUav7+iUT9qakqJX/kA4fVv4u4+Effof8cCS9DvxWZzYtrdsZ2S5OB5y9ZRveFVvqq6AoCzc7fQKSOtlXsVNXFYDo9+tIaV/h5sX/1buhy79//vO28lqgXE0hIUBkRE5KBcNCyX+99ZQakvSKmv/hPxD34o5JS/f8o1Y/I47ogOXD5lARELHvtoTaPzS31BZi6I7hb0+Zpi3r55DDuqwpz9xEJKqgKc2CeTvh0T6Z+TzGkDstmww8cTc9cStiz+cu4A7nt7BTMXbODIzim8dN0IHDYH8b2uoHLFdAIR2PpcMoSj6weq18yEHjdRFqzGbnfjdCZQXV2K/5s7G/WpIgSsexnWvYwt9xzC/X8HsNvRDoiugyj3VePzV/PVt4U8VvwMwZV2/vr9MZw2dAgVNT4q1r2EAbgSu5Lg34Cz51XR0Q4FgwMWCFRSteAXAKwJ9ARg8JAJrdmlRnLSEsmNq2STL4GvfX3J/uJKnGOe32P7nUcGlAWkJSgMiIjIQUmNdzL2iA58uqoYgIuP6cJFR+dy1bSv2F7p5/53VnD/Oyt2Oe+Ufln88pTePPrhakp9Ab5cu4NVhZX8+9N1bC71UVIVnXLz0YoiPloRLTDWNT2OLaXVsbnV/11Uv83oog2lTPk8n58e1wPbiKdxr5pOTYRYEIhZei8MvIvq6lIcjjgqyjfAllm4THCY0R1cqsPRpm4TUoveoHjgXYQi9TdqcXEZJCRkUVGxFdO044rrxHlTPmZTqR/4ZazdrZt/R47zV2Ta1gNgATUVGwgZkLluCj5/JZXrXib1iMtxjJ6+X+/7vW//wNfrS3jskiF0Sml/OyeFw0HK5k6CrW/hMWF5TTQMHJl7aIwK1DmmzxFs+mYr31UPYMzaGXSwO/a4q1DDP2OgNQPSMrRmQEREDtpdZ/TlgqGd+eC247jvvIEclZvC+7eO5fdn1Fd/ddlNPrjtOP5wZj8evXgwT1w6lN7ZiTw+aQgvXDuChy44EoCH3lvJiws3AXDagGwyE12xm90NO3y7LLJs6JVFm9lU4uPhD/PZlnUjphGtUZZsB7sBDgNSimaBFaKqqoht274lFAljdj6bVAck2SGl52Uk2qNbmSY7wOg+mQ5Zg+jYcTA5OUNxJg3ARyZ2u5vU1O4kJ3dhxrz1tUGgsRrLzb+Lz8ECnCYUh3OZmP8EM3acy7YaKFv7MiELqtbM2K91BptKfDz16Tq+2VjG1dO+2uOIRVvmnXsxoc2z2BjozL+2X0l5OBGX3eSIrH0t8dUyhudFp6N9V92fYASq10zb4//rnf9oa2tRaQkaGRARkYPWMzORv144qNGxjAQXVx+bh9th8uiHq3nogkH0zEyg5x6KQF0wtDNzVxbz1pJtAHRK8fD4JUNi6wVmzFvPXW8uo1dmArNvPpbPV2/ngXdXsKqwkscuHswt//mONUWVjHv4E/yhCP/LOJ85I7yYG2Zg5l1OvGmHdVOI5E3GtLmIRMKx5049bgZm7Vaohukg0eaAdVPYlPVzZvtv4/zKAEluB09/uponP1mLLxjm2jHd+dUpvbn37R+Y9uV6AMZ33ML/Jf2BksxLqAzCZfNP5MuqYbxWdhoLfCP4rrofFWEP/9x+NWclv0e86aPGcuEwdw0SMTtNI9pc6uO0Rz6L/byioIKF+SUM756+7//D9vAcoUAFNpsLo0GhuEORFazCv/FVllT34cbN9xG0ou/PTSf2xGk/tD7nHN49OlKxvPoIqiMu7CE/7vnXYoyatkvb0M7ThDQyIC3AsNrjxwm1vF4vycnJlJeXk5TU8kVJRESksUJvDWc89jnBcIS/XTiIk/pmNXo8f3sVmYku4l3Rz7Isy8JbEyLZ4+An/57HwvySRu2nTB7GiUek1d9M1930hvzs2LGKcDiA251CWlqPXftSVsHJ//gSb02I0T3TyUp089q3W/bY98FdUnjqsmF0iDfBdBAIRRj8h1lUhXe/HuAXmdP5vHIY3/r68GDOPZw3rB/mqPqpQuGgj6rPJ2NueoX4nlfEbh7/7/UlvFC7xqJLmoeNJdWM65vJM1ccvfc3dw/CX15J5epp1LhzCVdtio6I9LocY/jTh1woiETCeD+5BP/6lwlETK7Z+DAr/T05KjeFScO7cP6Qzj+62LylWZbF2Ic+ZlNJNT/PmMalaf8l3QmuSwK7rBVZXVDKyf/4MvbzoE5u3rzppJbusrQB+3OPq5EBERE5ZGQlufn01ydgM43dfsKblxHf6GfDMEj2RG+obh/fm8c/XsN5QzqzeFMZz3yez0sLN3Fin/pAEcZOOBTBaXfRoUM/qqtL8Hjq55j/86PVlFcHufO0vry9bDvemuh2kF+s2RFrc/upvQF48N2VAJgG/GvSUE4dkN2ob067yaWje/PvT9dhEOHGI1aR2e8CFuaX8L/FW3mk6IpY21fLJ3DKmj+SBDBqOt65E6lc95/Y45HV00nCovyop3nt67WAgynHzMVDIZcuPJ8Pfiji4xVFnNAncz/ebSASxLt6WnSNRFV0alZ1GKpXzMC5agbpvS7DGD1j/67ZjLxl+fhqK1LPLj+Zlf6eJJqVPHvZ8aQnxf/I2a3DMAyuHdOdu95cxr+2TybHsY1zjsrFtZtF47uuGWipXkp7pjAgIiKHFI/TdkDnDeuWxtQrjwGgd3Yiz3yezwc/FPLPj1YTilgclZvCL176jkp/iIcuOJLzhnRuVDV5U4mPv76/CoC+HZP4pHZBdEM/GdaZnx/fk3DEYtZ3W1lRUME95wzYJQjU+c1pfRjdMwO3zeKYHmcC0YXTs7/fSsNx+YVVg9nqj8exdgbOcJCqBkEAotukmmtm8Nw3JjXhC+juXE/v0r9iGHBRqp0XSs/nD7OWMqrncbjs+/H+mQ4CHc+CzbMwiBZ6qwpHFzoHIlCy+jnStn+JcfaaH7tSswuHA/i+upUdoRSW+ofw5I7JANzaf+0hGwTqTDy6C+8tK+CLNTt4zXYXEwZ03W27nacFaZqQtASFARERaXOOyErkyM7JfL+5PHaD39Bf3vqBcf2yKCivYf66HThsJnOWF8Yev+PV7wnWrt58/urh/Oz5RfjDEW48oRcANtNgxtXHsGyrl+OP6LDL9esYhsHYnR7PSnIzvl827y4rACAt3klJFbztHUdu9VZGBl7CNKAyksxNm//MkLhl3JTxJN4QzCo+CoALUmZj1M6GuSr9ReZUHM/GknT+89UmLh/ZbZ/fp0BNGWErggFku8BI7El8xRpqwuANgT8C1d61xIV8YI/b5+s2NcuK4CtbR82mOfxs02NsDuYA0Csznssm/qbV+rWvnHaTe88dyHEPzWXxFj/bXx9K6oCLolvLNhBU0TFpBQoDIiLSJl0wtDPfby7f7WM7qgKc/shnbC6t3u3jdUGga3oco3umM+umYwmGI3RJr78hzkx0k9nbfUB9+/tFR5H21nJyU+MIhSP8bc4qHi2+FoDbM//JOSnv8o73FFbW5LGyJo/TE9+lq3MT+YHoJ8rHJv8Qu1acWcPlaf/hb0U/57EPV+Lz+7Es+OlxPTHNPY8S+D+/jNLVz4MFLpNouDhjOTYgHoi8fgQV5eupcXUlrhWDQKCmjB1vDMTybeaN8rNjQSDRbeexS4bgsB1aC4b3pGt6PN0z4li33cd3vr70WDsF85gnG60biOxcdExZQFrA4fE3SEREZD+dNSiH1DgH2Ulu5v7qeDISnHRK8fCLk6Kf7u8cBJw2kzMH5fDBbcfFjp06IBvDMMjLiG/SLSs9Thv3njuQnx3fgzMG5dBwzeurZRMoD6fxXMlZsWNvlJ/DpnB3gpaDOLOGPs6NJNghywUJeRdydvL7ZLkqKa4Mcf+7a3jgvTV8umzZLs8biYSwglVYYT9lq58nYkW3PE12AHmTozemtV/us5ZDpwn4KzdgzbuqyV77/ij/+CK2v5CK5YvWk5hfNQyAm0/szud3nEif7MNr849BuakArPL3INDl0l0WEO9cV0B1BqQlaGRARETapJQ4J+/fehw20yAt3smHvzwe04AdlQEe+XA1ACf07sCUyUfz5doddMuIj9UzeGTiUfxv8VauG9O92fuZlxHPK9eP4qMVhTz+8VrWBvI4bW3jRbtvV53CoLjlAPRyrcfZ8wqc+dOg+1UkjXiWpOOC3Dx/Lb+dtTZ2zgtfFzPyiApcrmiI8fu97Hh9ALbqTdjiuhD2dMZWvZn02loKOxfCctjsGFvewgIi66ZiG/7vFq2U7K8qoCr/ZYKWndnlJ1MS7shC32AAzjqqc2zh+OGkf04Sr3+7hVXJV1PZtwsuy8Iw6pNgaKfCAsoC0hIUBkREpM3qkOiKfV9385jodvB/p/ehsibEz0/oiWEYjO6Z0ei8s4/qxNlHdWqxfg7tmsrQrqmkxjn581v1U4Beum4Ev319CWuLq/hzwQ0A9M10RW/chz9Vf3NuOrhkZG+KfSb/+CAadD5eXcP6go3kpqfhciVRU7kNfJsIA+Gq6NakiY7a6UHDn9q1U6YDW5dzCW18nVDXy7C1VBCIBKn89FIq1r3MU9svZVrJxEYPd0710KPD7mtVHOr65yQDsKIohN9fQUXFFpKSOsce33makEYGpCVompCIiLQ7143twW2n9MbtOLCdi5rLNWO6c3S36FSSo7ulMqJ7Oj8ZlgtAIBLt6/gTfhJtvNPNuWEY3DLuCNbfP4FBnRIIRmDGW2/wyBO/YP6zAwl8+3/gid542gxIdUCcDWY7f8exD33GIx+s3qWSsW3wAzB+PuEhDzfny46p+exSdsxw4l33Mour+zYKAm6HSUaCi0cmHtXo0/TDyZGdk3HYDAorI2wpD1NZWUhFxdbY4ztX11YWkJagMCAiInIIefLSoVx/XA8eOP9IAM4d0glXbc2FK0Z23adaApfV7ig0c+NR/HvHFfxu66+o2fAGz2wayw1bH8NHDh4b+HKv5u4VY9lcWs3fP1jF1xtKG13HbneBYaeysnCXoNCkIkEioWpKVs/EX/vh+Ktl5wAQbwvyzOXD+OFPp7Lg/05iaNe0PV/nEBfvsjOkSzTsfVMQXXxeWVlAOBwAILxLnQGlAWl+CgMiIiKHkPQEF785rQ/da6fCZCa6+e/1o3jpuhHcfVb/fbrGGYM6k+KoXyCdH+jKnwpuY0rJJXxbmcej7jfZPL6cS5dcyfbKQKzdvLU7Gl3HVluBOBSqobx8w8G+NKywn0ioJvpDJAiAd+5Ets9wUv7JZZBzGgCVkRTmVkZrRvz3xhMZ1y8LwzCwHWLVhQ/EibVh7p+fFLC2xI5lWfh80fc9vNOagbCygLQArRkQERE5xA3snLxf7d22CP/q/Ae+qDySNf7uvOcdxZyK42OPz15axNebvGwqiQaG447owCerinl4zircDpNeWYmM6ZmBw1FfzMvn20F8fCYOx563GQ2Hg5SWrsM0bRiGjUCgkri4DOLjM6n5/HLK17yAYUBych6hynzMLj+hcl20ojAbXmV+1RDe8N7Nyuo8gpaDwV1S6Nvx8Nox6MdcMaobH60oYkF+Cbe9UcjLl6fhqCkjMbEj4do1A3YTQhEVHZOWoZEBERGRtsZ0MGrQCH7d8SVuHlI/QuA0w/ToEE8wbMWCwM0n9uSuM/vF2tz79gqunPoVxz00lzU7ImRk9MbtjoaRqqpiQiE/VVVFBIO71mgoL99AIFBJTU051dUlhMMBKiq2sr1oCWVrXojuTGRBaVk+FSEoX/cya/1d+bRyOCWhZH695S4+rRhGYSgdgJ+O7dGMb1LrcDtsPHPFMDqleCiuDDJ7mY9g0Ed1dWlsWpDDFh0BURaQlqAwICIi0haNeBYmBuh/6sOcNSiHjskuHpt0DDed2CvWpE92Ired0pseHRJ48tKhTBrehUGdk0l029lSVs0D767E6UwgPj4LAJ9vO0VFSykv30Rx8XKqq+vXGFhWBL/fu9uuhMJ+ABxGdPFy7Lhl49bNf+I3W3/PfUW/ItxgwsLFx3RhfP+spnxHDhmJbgc/PS66be20r6up8keorNwWW0BcFwZUgVhagqYJiYiItFW1Ow49evHg2KFwxOLjlUW8+d1WLhhav63lqQOyOXVANgDrt1dx/F/n8vnqYraWVZOTkkh8fAeqqoobXb60dB2W1Y24uHQqKrZiWRY2m4O0tJ4Yhond7mbHjtXRkNDpDOKLZuNK6I6vYh0eE973DmF7ODoK8EVltI+/OuUILjq6S6NtYduiiUd3YeoX68nfXsWsZdVcPMQkFIqGAGfdyEBkb1cQaRoaGRAREWlHbKbBPy46ivl3nsTVx+bttk23jHiO6ZZGxILJUxfy30WbSUjMJTOzP5mZ/WMLiwG83s2Ul2+isrKQ8uoI07+uYdb3JfjDdkqqAiQkZMOSP8GW2Ti7X4bt3LUk9pqMz4rjrztua/S8HRJdXDgst80HAQCn3eSaMdH3f/byGizLoiZQBWiakLQshQEREZF2xjAMspPde92v//7zB5LscbCqsJJfvbKYB99bgd3uxm53k5zcBZstOuoQiYSoqioC4LfvVPCvz4r55SuL6f+H9zj2gY9YUxwgsXAWiXaoWvsa20orsEZM4W+J81hXlUhOspsPbjuO357el1evH0VWkrtF3oNDwVmDcnDaTfJLgmwqCxMI1k6n0jQhaUGaJiQiIiK76N4hgfduGcuD767gtW+3MOXzfPzBCBt2VHHXmf15b0U8hWUVXD44TLzbzTZfMt9sLmh0DV8gzHXPL+bFo29k2apv+OXm2/Et/7RRm/vOP5KemQn0zDw8qwofjES3g8G5KSzIL+GbLYHY9CCHpglJC1IYEBERkd3KTnbzt58MosQXYO7KYqZ9uR6Aj1fOjbVZui2Vfh1dzFq8HIDBXVLomOymb3YSr36zmfU7fIydcypwaqNrux0mN5/Ui+OO6NBCr+bQNKJ7OgvyS1i0KcDwLtHpV/UjA2BZ1mFbcVkODwoDIiIiskeGYfDA+UdywZNfxrYjbeir9aV8tT66q1BGgouHLhgU+5T/oqNzmfTMAlYXVQIwqHMyXdLjSfE4uOGEnmQnt58pQXsy9ogMHvlwNfPW+xnYMTr1ytlgzYBlRTAMW2t2Udo4hQERERHZq6wkN5/++gQsC2Yt3sqmEh8XHZ3Lv+auZdqX60mLd/KHM/sxtlcHUuPrFxdnJrn5z09Hcst/vsMguqtRssfRei/kEDQ4N5WOyW62ldcwZ2W0OrPDVr+kMxyxMLXCU5qRwoCIiIj8KMMwMAw4Z3Cn2LHbT+1NWryTUwdkc0RW4m7PS4t3MuOqY1qqm4cd0zS4+JguPDxnFcsKgwA47fXTgsIRC8UnaU7KmiIiInJA4px2bj6p1x6DgOybnx/fg5Hd02I/OxuMDEQsrSKW5qUwICIiItKK7DaTX4w7ov7nBndnobDCgDQvhQERERGRVpbkrp8MZLfV1xfwB3xUVWzFCgdao1vSDigMiIiIiLSyRHf9Mk5Hg7uzHZ//jPJXOlHynAvmX90KPZO2TmFAREREpJU1HBloKLT1fQD8EQismQKRYEt2S9oBhQERERGRVpbQYGSgJhimbj+hiKdz7LgvDCy8XoFAmpTCgIiIiEgrs5n124lWB6FuQ6Gwr5DU2kEDXxjKVk4h+IJTU4akySgMiIiIiBxCgpaTUO0mQufmT+PDimOxG9FbNl8YSoJgrdWUIWkaCgMiIiIih5Dqne7xb9z4G35Z8m+s2k2GwhZUe7qDqXJkcvAUBkREREQOIVWB0C7HPivuyFL/EGy1s4lqvOsg5GvhnklbpDAgIiIicgipDoRj32clObn62DwAnq+5gbTawYCaCHhnxmPNu6o1uihtiMKAiIiIyCGkyl8/MpDscTJ5VDcMAz4rymLLycW4a+/eKsNQvmqqRgjkoCgMiIiIiBwCUuOiH/sPyk2JHUt0O8hNi+O4IzoAMH1hIWm9J5PqAIPoguLKF+K1u5AcMIUBERERkUPAaz8fzbVj8vjbhYNix5Jq6w9cOrwrAFO/WM/9ZXfg7n45SbWlCSpCEFozRSMEckAUBkREREQOAXkZ8fx2Qj8yk9yxY8me6GjBCX0yGZ6XBsCTn6xl4tLrsXe/CqcJFlAcgHKtIZAD0ORh4L777uPoo48mMTGRzMxMzjnnHFauXNmoTU1NDTfccAPp6ekkJCRw/vnnU1hY2KjNxo0bmTBhAnFxcWRmZvLrX/+aUKjx6vq5c+cyZMgQXC4XPXv2ZNq0aU39ckRERERaTVJtGLCZBv/56Uj+cGY/ABbkl/Bu/B9IsYOrNhBUhWHHyqmEgz6CwerGF1JNAtmDJg8Dn3zyCTfccAPz589nzpw5BINBTjnlFKqqqmJtbr31Vv73v//xyiuv8Mknn7B161bOO++82OPhcJgJEyYQCAT48ssvmT59OtOmTeOuu+6KtcnPz2fChAmccMIJfPfdd9xyyy1cc801vPfee039kkRERERaRZK7cS2BK0fn8YuTegHwr7nrCeddQ7oT0hxgGhDoeBaFxT9QXLycQKASgOpPL6XieadGDWS3DMuqK2HRPIqLi8nMzOSTTz5h7NixlJeX06FDB1544QUuuOACAFasWEHfvn2ZN28eI0aM4J133uGMM85g69atZGVlAfDkk09yxx13UFxcjNPp5I477uCtt95i6dKlseeaOHEiZWVlvPvuu/vUN6/XS3JyMuXl5SQlJTX9ixcRERE5ABf9ex4L8kuY+6vj6ZYR3+ixHZV+Tv77p5RUBUiNc9AlzcOfz+5Hr3SLkrINjdrGe1Kper0HAMl2iL800LhYWSSo4mVt0P7c4zb7moHy8nIA0tKi89wWLVpEMBhk3LhxsTZ9+vShS5cuzJs3D4B58+YxcODAWBAAGD9+PF6vl2XLlsXaNLxGXZu6a+yO3+/H6/U2+hIRERE51My8Zjjf3XXyLkEAID3BxT8uOopEt51SX5DFm738btYKHO500tJ64HDExdpW+Ypj3/sjEAr5CQUqsMJ+Kj6+iMALTu1E1M41axiIRCLccsstjB49mgEDBgBQUFCA0+kkJSWlUdusrCwKCgpibRoGgbrH6x7bWxuv10t19U7z5Grdd999JCcnx75yc3MP+jWKiIiINDW7zSQlzrnHx8ce0YHPbz+RqZOPxmYaLN5Uxk/+PY8A8XTo0JeUlG7RhkvvjZ3jj0Dxa30pfj6JguluKvJfpiQIkbVTtKagHWvWMHDDDTewdOlSXnrppeZ8mn125513Ul5eHvvatGlTa3dJRERE5IAkxzk4oU8md5/VH4/DxqINpTz47goA4uLSifekwJZZJNjAbkQXGVu+zdH/1l4jYkGls6umCrVjzRYGbrzxRmbPns3HH39M586dY8ezs7MJBAKUlZU1al9YWEh2dnaszc67C9X9/GNtkpKS8Hg8u+2Ty+UiKSmp0ZeIiIjI4eyyEV3592VDAXjl682sLqxgW3k1yak96Nj3SpIckJSct8fzfZUbsL6c3EK9lUNNk4cBy7K48cYbef311/noo4/Iy2v8h2/o0KE4HA4+/PDD2LGVK1eyceNGRo4cCcDIkSNZsmQJRUVFsTZz5swhKSmJfv36xdo0vEZdm7priIiIiLQXY3plMLRrKv5QhJP//inHPvAxj3ywGv+wpwleWEPk9GW4au/64mzR7UgznWAzoqMDZaunE/AVU1lZQCQS2vuTSZvS5LsJ/fznP+eFF17gzTffpHfv3rHjycnJsU/sf/azn/H2228zbdo0kpKSuOmmmwD48ssvgejWokcddRQ5OTk8+OCDFBQUcNlll3HNNddw773RuW/5+fkMGDCAG264gauuuoqPPvqIm2++mbfeeovx48fvU1+1m5CIiIi0FVvKqrn0mQXkb6/fzr1nZgLbyqrxhyK8euwH9C35O86kXlC5GrpfRUV1JRX5L9dfpNNZ2AffS0pKN5zOXRcvy+Fhf+5xmzwMGIax2+NTp05l8uTJQLTo2C9/+UtefPFF/H4/48eP51//+ldsChDAhg0b+NnPfsbcuXOJj4/niiuu4P7778dut8fazJ07l1tvvZXly5fTuXNnfv/738eeY18oDIiIiEhbEolYbCmr5qH3VjJr8dZGj10xsiu/PqUHYewkuwDTQSTgpeSFZIKR+nUEjJ8Phh3TtJOQkEVCQv39WSjkJxysxOVJb7HXJPuvVcPA4URhQERERNqqyVMXMndl/daiGQkuXHYTfyjMf346kufmbeD43h04fuWxRCpWUx4Co8uFWEfdT3V1af15GX0wTRs2K0zx3EmENr1JWs+LcY99oTVe1n4LBCpxOOIwjGbfUf+QoTCwjxQGREREpK3yBUK8+d1WMhJc3PTiN9QEI7u0cdpMvr3rZOJttcXIancVCgQq2b59ZbSRFYLPLgDf5th5dgPSe12KbdQUgsHolu4OhwdMB5ZlUVNThsuVhGnaoifsT3Gzgy2E1uD8ioqtVFRsIz6+A8nJXQ78moeZQ6romIiIiIi0vDinnYuP6cLJ/bI4tmfGbtsEwhFe/WYz2OMa3YA7nQl06NAXlvwJ3hvRKAgAhCwoXPU8xTOcFM9MpnhmMlXPRwuYVVUVUlq6jvLyjYTDQYreP4cdM5yEvpxM0F8OkSDBYDWV3s2EApWxa/qrd1Dw/jlU1F4nEglhhf37/HrD4SBlH13IjhlOquZeRDgcoKJiGwBVVcVYVoRQqIZweDc1FSLBvdZaiETCuz+nlhWsorKygLKyDVjWrqHrUKaRAY0MiIiISBv32jebue3lxWQkONleGWj02Kge6Tx/9XC2lFWTkeDC46z/NH/7DCeBSHQHIrcJEcAbiu5AtDsuE/wnR9ccADiW/ZngpjcatfHYIODuQrhqY/TnLueCYRLY+Crh2uuaBlgdT8NR8A4ZvSfD8Kd2O1pQd5NuGCbbPziv0XMZns5Yx74ENjcAdruLUMiPYZikp/fC6UwAoPyjC/Fv+C8JdojrORlGTq2/0Tcd+Hw7KCtbD4DN5iA+Pgvr65sxN76M2e1iKrZ9QahqI8TlwtjXD4lRCE0T2kcKAyIiItIeRCIW7y8vZEjXFFYVVDLty/VcObobk55Z0KhdvNPGvecN5OyjOkXPm3clkbXTsJtAt8thxDPU+IopeblT7BybQewmvu6GGIhOL3pvxEH33W3WhpFeVxE48n4iGDjdqVRWbqOysjC60DkuHe9/c3d7vj2+C6ExrzU65vGkkpqYje+LqylbW18c12MDe0I3wpXrcRjg6nEZRXm/aHzBJXfDltm77+zJn2PYPWRk9CEY9OHxpO9xc53mpDCwjxQGREREpD37+cxFvL2kYJfjWUkurhqdx1XH5uEwaqfINPhk3pp3Fda6qVSFwWNCaQiCkegn+q6zVhKXkE15+UZC3/4WtszCILrOwGGCr/ZyThMsC4IN7kQNiNVDqIk0Pu40wV93rNNZMPCu+ga1wSPJDgl2qA5DoLY/8TYoO/l7akINRkQ+PWeXqU971OkMGHg3CQlZVFcVEX5n6G6bmXFdME6YTTgcwGZzEA4HW22UQGFgHykMiIiISHtmWRYf/FDEF2u2M3lUN6bPW8/UL9bHHj9vcCd+Ma4Xf31/FacNyOa0AdkEwhFcdhtEgkQWXM+/5leSEW/nbM8LuHteiTFyChCdw19VVUScOwn7u0OhcjVhI56i6ipMAzo4wXQkQqiCYCR68+8ywZnUEyrXELZge6DBqMPOxs/H4UwiGPQBYCy9h8ziN7H1uCoaDvJnRNsl9IKzVgHRaUWF75+NtfWt2GVctSMPpXteMkDi+RtITO6CFfZTNdONwwC/FZ0u5TKjoyNzBqzj7SXbOL67xei86NSkDh36RRdWtzCFgX2kMCAiIiLS2Mtfb+L2/34f+/mIrARWFdYv9HXYDHpmJhKORMhMdPP5mu0APH3ZUZzcvxOWZfHdpjL6ZCfVrz8ACPnAHkf4i8sx1j+H2X1ydH5+yNd4PYDpiC3otRb+HN+a6ZTvpihyfN5PSDr+RcrK1uP3V5CS0hW3M77+WnWLgu1x9SdFgvhmOvFHoCYMRm0osSX2xO9dw45A9OY+zREdWagMg7P7FSzIeICxR3TAaTdh/tWwbko0ZFSuBuDzhDu49MsxACS7Dd66NpOE+AxSUrod1P+LA6UwsI8UBkRERER278YXvmH299tiPxtGdFrPnozplcFzVw/n35+s5b53VtArM4H/Xj+KD1cUkpXkJi8jnoX5JZzQJzNW9GxfWF9OZtuK6QAkdTsf7/pXsRmQ4QTbxYG9Xuet77cRsSxOH9gRm1k7d7/2Zt6K70GNdxNPh+9hme1EJh3TidE77sTMn87y9FvpccK9uB02Hnx/Lf+au5azBuWQnewmwWXnpuO7YticBIN+HnhvNc98vqHR8067JItj+w3Ebnft02tsagoD+0hhQERERGT3ftjm5bRHPgOiawievnwYL3+9icqaEHkZCcxavIW1xVWNznny0iHc/OJ3BMLRyf1uh7lLfYMJAzvy+KQh+96RSJDAC07W+7N4ufQMrhhk0qnoacweV8GIZ2PNyquDzP5+Kw7TZPaSbSzdUk5JVXSdwM+P78Htp/ZpdE1MB3e98T0z5m8CIDXOwbu3jOUfc1by4leb6ZTi4bmrj+HEv32yS5eevHQo7y7dxhvf1Vd5Pm9wJ9YUV/L95nK6pcfhstu49eQjOHVA9i7nNzeFgX2kMCAiIiKyZ/e98wPz1u7gnrMHMCg3pdFjBeU1PPbRai4b2ZVLn1nI9sp9qwlgGnDtmO6sKqzgtxP6sXybl5nzN3DJ8C58tno7m0t9/POSIWQkRD9VtywL5l/DT+b05itffwZ2SuaO8T3559x8/KEIV4zsxsDOyVw742vW7RRO6thMg58d1wN/KEyX9HgKyqtZvKk8NsVpX2UluSj0Nn6diW47f7twEKf0z2bGvPXc9eay2GN/OLMfV47O26/naAoKA/tIYUBERETk4L2wYCOPfriaUCRCotvBX84dwDXTv8YXCJOT7KbCH2JY11RKfEEWbyr70evlJLvxBcPYTQOnzWRrec1+9adLWhxH5aaQm+bhze+2srm0eo9t8zLiKSivoTpYX1jsN6f1YfqX69lW+7y3n9qb68Z0571lhdzwwjcAeBw27j6rH2cN6hRbG1FaFWDwPXOAaEiYf+dJxLvs+9X3pqAwsI8UBkRERESax+ZSH1vLajgqNyW68Bb4Ys32XWobHKiemQmcPrAjT326lppghL4dk/jHRUfRMcVNosse299/XXElf31/Jf5ghNy0ODaX+vCHInhrQgzqnMzVx+axdIs3dpN//XE9+M1pfdhc6uPZz/OJc9r4xUlH4LSbRCIWf/zfMj74oYhHLx7M0K6pu/TrtW828+7SAs4b0rlVpgiBwsA+UxgQERERaTmWZfHc/A2kxDnJSHBy84vfkeyx89zVw1m6pZycFA/e6iBl1UE+WlHEfxdtZmCnZJZsKQdgaNdUFm0oBWDmNcMZ3TODFQVePlpRxKRjupIct2+Lkts6hYF9pDAgIiIicmgKhCJ8uqqYMUdk8Nmq7awpruS0Admc+o/PGN0znacvH9Yq1X0PBwoD+0hhQEREROTwUh0I47AZ2G1ma3flkLU/97gtv6JBREREROQANSpkJgdNkUpEREREpJ1SGBARERERaacUBkRERERE2imFARERERGRdkphQERERESknVIYEBERERFppxQGRERERETaKYUBEREREZF2SmFARERERKSdUhgQEREREWmnFAZERERERNophQERERERkXZKYUBEREREpJ1SGBARERERaacUBkRERERE2imFARERERGRdkphQERERESknbK3dgdak2VZAHi93lbuiYiIiIhI06i7t627192bdh0GKioqAMjNzW3lnoiIiIiINK2KigqSk5P32saw9iUytFGRSIStW7eSmJiIYRgt/vxer5fc3Fw2bdpEUlJSiz//4Uzv3cHR+3fg9N4dOL13B07v3YHTe3fg9N4duNZ+7yzLoqKigpycHExz76sC2vXIgGmadO7cubW7QVJSkv6SHSC9dwdH79+B03t34PTeHTi9dwdO792B03t34FrzvfuxEYE6WkAsIiIiItJOKQyIiIiIiLRTCgOtyOVy8Yc//AGXy9XaXTns6L07OHr/DpzeuwOn9+7A6b07cHrvDpzeuwN3OL137XoBsYiIiIhIe6aRARERERGRdkphQERERESknVIYEBERERFppxQGRERERETaKYWBZnb//fdjGAa33HJL7FhNTQ033HAD6enpJCQkcP7551NYWNjovI0bNzJhwgTi4uLIzMzk17/+NaFQqIV73/K2bNnCpZdeSnp6Oh6Ph4EDB/L111/HHrcsi7vuuouOHTvi8XgYN24cq1evbnSNkpISJk2aRFJSEikpKVx99dVUVla29EtpUeFwmN///vfk5eXh8Xjo0aMH99xzDw33B9B7V+/TTz/lzDPPJCcnB8MweOONNxo93lTv1ffff8+YMWNwu93k5uby4IMPNvdLa3Z7e++CwSB33HEHAwcOJD4+npycHC6//HK2bt3a6Bp673b/566h66+/HsMw+Mc//tHouN67Pb93P/zwA2eddRbJycnEx8dz9NFHs3Hjxtjj7fXf3h977yorK7nxxhvp3LkzHo+Hfv368eSTTzZq017fu/vuu4+jjz6axMREMjMzOeecc1i5cmWjNk313sydO5chQ4bgcrno2bMn06ZNa+6XV8+SZrNw4UKrW7du1pFHHmn94he/iB2//vrrrdzcXOvDDz+0vv76a2vEiBHWqFGjYo+HQiFrwIAB1rhx46xvv/3Wevvtt62MjAzrzjvvbIVX0XJKSkqsrl27WpMnT7YWLFhgrVu3znrvvfesNWvWxNrcf//9VnJysvXGG29Yixcvts466ywrLy/Pqq6ujrU59dRTrUGDBlnz58+3PvvsM6tnz57WxRdf3BovqcX85S9/sdLT063Zs2db+fn51iuvvGIlJCRYjzzySKyN3rt6b7/9tvXb3/7Weu211yzAev311xs93hTvVXl5uZWVlWVNmjTJWrp0qfX/7N13fFXl4cfxz7n7Zg8gIey9QQSB4EDrAFfrqAqiqFi1rfycdVZtq7Za6x7VahVQcbaKiHUgIspWZO8RNkmA7HXn+f1xk0siYeZmkPt9v155kXvOuc957iGQ8z3Pevfdd023223+61//aqiPWS8Ode0KCgrMs846y3z//ffNtWvXmvPnzzeHDBliDho0qEYZuna1/9xV+eijj8wBAwaYGRkZ5jPPPFNjn65d7ddu48aNZkpKinnXXXeZP/30k7lx40bzk08+MXNycsLHROvv3sNduxtuuMHs0qWLOWvWLDMrK8v817/+ZVqtVvOTTz4JHxOt127kyJHmxIkTzZUrV5pLly41zzvvPLN9+/ZmSUlJ+JhIXJvNmzebMTEx5h133GGuXr3afOGFF0yr1Wp+8cUXDfI5FQbqSXFxsdmtWzdzxowZ5ogRI8JhoKCgwLTb7eaHH34YPnbNmjUmYM6fP980zdA/XIvFYmZnZ4ePefnll82EhATT4/E06OdoSPfcc495yimnHHR/MBg009PTzX/84x/hbQUFBabT6TTfffdd0zRNc/Xq1SZg/vDDD+FjPv/8c9MwDHPnzp31V/lGdv7555vjx4+vse2SSy4xx44da5qmrt2h/PyXY6Su1T//+U8zOTm5xr/Ze+65x+zRo0c9f6KGc6gb2iqLFi0yAXPr1q2maeraVTnYtduxY4fZpk0bc+XKlWaHDh1qhAFdu5Dart0VV1xhXnXVVQd9j373htR27fr06WM+/PDDNbadeOKJ5h//+EfTNHXtqsvNzTUBc/bs2aZpRu7a3H333WafPn1qnOuKK64wR44cWd8fyTRN01Q3oXpy8803c/7553PWWWfV2L548WJ8Pl+N7T179qR9+/bMnz8fgPnz59OvXz/S0tLCx4wcOZKioiJWrVrVMB+gEUybNo3Bgwdz2WWX0apVKwYOHMhrr70W3p+VlUV2dnaNa5eYmMjQoUNrXLukpCQGDx4cPuass87CYrGwcOHChvswDWz48OHMnDmT9evXA7Bs2TLmzJnDueeeC+jaHY1IXav58+dz2mmn4XA4wseMHDmSdevWkZ+f30CfpvEVFhZiGAZJSUmArt2hBINBrr76au666y769OlzwH5du9oFg0E+++wzunfvzsiRI2nVqhVDhw6t0R1Gv3sPbvjw4UybNo2dO3dimiazZs1i/fr1nHPOOYCuXXWFhYUApKSkAJG7NvPnzz/gfnHkyJHhMuqbwkA9eO+99/jpp5947LHHDtiXnZ2Nw+EI/2KskpaWRnZ2dviY6j80Vfur9jVXmzdv5uWXX6Zbt258+eWX/O53v+OWW25h8uTJwP7PXtu1qX7tWrVqVWO/zWYjJSWlWV+7e++9l9GjR9OzZ0/sdjsDBw7ktttuY+zYsYCu3dGI1LWK1n/H1VVUVHDPPfcwZswYEhISAF27Q/n73/+OzWbjlltuqXW/rl3tcnNzKSkp4fHHH2fUqFF89dVXXHzxxVxyySXMnj0b0O/eQ3nhhRfo3bs3bdu2xeFwMGrUKF566SVOO+00QNeuSjAY5LbbbuPkk0+mb9++QOSuzcGOKSoqory8vD4+Tg22ej9DlNm+fTu33norM2bMwOVyNXZ1jivBYJDBgwfzt7/9DYCBAweycuVKXnnlFa655ppGrl3T9sEHHzBlyhTeeecd+vTpw9KlS7ntttvIyMjQtZNG4fP5uPzyyzFNk5dffrmxq9PkLV68mOeee46ffvoJwzAauzrHlWAwCMCvfvUrbr/9dgBOOOEE5s2bxyuvvMKIESMas3pN3gsvvMCCBQuYNm0aHTp04LvvvuPmm28mIyPjgKfV0ezmm29m5cqVzJkzp7GrEnFqGYiwxYsXk5uby4knnojNZsNmszF79myef/55bDYbaWlpeL1eCgoKarwvJyeH9PR0ANLT0w8YiV71uuqY5qh169b07t27xrZevXqFZ4Oo+uy1XZvq1y43N7fGfr/fT15eXrO+dnfddVe4daBfv35cffXV3H777eHWKV27IxepaxWt/45hfxDYunUrM2bMCLcKgK7dwXz//ffk5ubSvn378O+OrVu3cuedd9KxY0dA1+5gWrRogc1mO+zvD/3uPVB5eTn3338/Tz/9NBdeeCH9+/dnwoQJXHHFFTz55JOArh3AhAkTmD59OrNmzaJt27bh7ZG6Ngc7JiEhAbfbHemPcwCFgQg788wzWbFiBUuXLg1/DR48mLFjx4a/t9vtzJw5M/yedevWsW3bNjIzMwHIzMxkxYoVNf7Tr/qF+vP/7JqTk08++YApu9avX0+HDh0A6NSpE+np6TWuXVFREQsXLqxx7QoKCli8eHH4mG+++YZgMMjQoUMb4FM0jrKyMiyWmv+crVZr+ImZrt2Ri9S1yszM5LvvvsPn84WPmTFjBj169CA5ObmBPk3DqwoCGzZs4OuvvyY1NbXGfl272l199dUsX768xu+OjIwM7rrrLr788ktA1+5gHA4HJ5100iF/fwwaNEi/e2vh8/nw+XyH/P0RzdfONE0mTJjAxx9/zDfffEOnTp1q7I/UtcnMzKxRRtUxVWXUuwYZphzlqs8mZJqhaajat29vfvPNN+aPP/5oZmZmmpmZmeH9VdNQnXPOOebSpUvNL774wmzZsuVxP0XX4SxatMi02WzmX//6V3PDhg3mlClTzJiYGPPtt98OH/P444+bSUlJ5ieffGIuX77c/NWvflXrlI8DBw40Fy5caM6ZM8fs1q1bs5wes7prrrnGbNOmTXhq0Y8++shs0aKFeffdd4eP0bXbr7i42FyyZIm5ZMkSEzCffvppc8mSJeEZbyJxrQoKCsy0tDTz6quvNleuXGm+9957ZkxMzHE/xeOhrp3X6zV/+ctfmm3btjWXLl1q7t69O/xVfUYRXbvaf+5+7uezCZmmrt3Brt1HH31k2u1289VXXzU3bNgQnprx+++/D5cRrb97D3ftRowYYfbp08ecNWuWuXnzZnPixImmy+Uy//nPf4bLiNZr97vf/c5MTEw0v/322xr/n5WVlYWPicS1qZpa9K677jLXrFljvvTSS5patLn5eRgoLy83f//735vJyclmTEyMefHFF5u7d++u8Z4tW7aY5557rul2u80WLVqYd955p+nz+Rq45g3v008/Nfv27Ws6nU6zZ8+e5quvvlpjfzAYNB988EEzLS3NdDqd5plnnmmuW7euxjH79u0zx4wZY8bFxZkJCQnmddddZxYXFzfkx2hwRUVF5q233mq2b9/edLlcZufOnc0//vGPNW7AdO32mzVrlgkc8HXNNdeYphm5a7Vs2TLzlFNOMZ1Op9mmTRvz8ccfb6iPWG8Ode2ysrJq3QeYs2bNCpeha1f7z93P1RYGdO0Ofu1ef/11s2vXrqbL5TIHDBhgTp06tUYZ0fq793DXbvfu3ea1115rZmRkmC6Xy+zRo4f51FNPmcFgMFxGtF67g/1/NnHixPAxkbo2s2bNMk844QTT4XCYnTt3rnGO+maYZrUlSkVEREREJGpozICIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkSikMiIiIiIhEKYUBEREREZEopTAgIiIiIhKlFAZERERERKKUwoCIiIiISJRSGBARERERiVIKAyIiIiIiUUphQEREREQkStkauwKNKRgMsmvXLuLj4zEMo7GrIyIiIiJSZ6ZpUlxcTEZGBhbLoZ/9R3UY2LVrF+3atWvsaoiIiIiIRNz27dtp27btIY+J6jAQHx8PhC5UQkJCI9dGRERERKTuioqKaNeuXfhe91CiOgxUdQ1KSEhQGBARERGRZuVIusFrALGIiIiISJRSGBARERERiVIKAyIiIiIiUSqqxwyIiIhI9AoGg3i93sauhshRs9vtWK3WiJSlMCAiIiJRx+v1kpWVRTAYbOyqiByTpKQk0tPT67xWlsKAiIiIRBXTNNm9ezdWq5V27doddlEmkabENE3KysrIzc0FoHXr1nUqT2FAREREoorf76esrIyMjAxiYmIauzoiR83tdgOQm5tLq1at6tRlSFFYREREokogEADA4XA0ck1Ejl1VkPX5fHUqR2FAREREolJd+1qLNKZI/fwqDIiIiIiIRCmFARERERGpoWPHjjz77LPh14ZhMHXq1DqVGYkyJPI0gFhEREREDmn37t0kJycf0bF//vOfmTp1KkuXLj3mMqThKAyIiIiINENerzdig6TT09ObRBkSeeomJCIiInIcOP3005kwYQITJkwgMTGRFi1a8OCDD2KaJhDq2vPII48wbtw4EhISuPHGGwGYM2cOp556Km63m3bt2nHLLbdQWloaLjc3N5cLL7wQt9tNp06dmDJlygHn/nkXnx07djBmzBhSUlKIjY1l8ODBLFy4kEmTJvGXv/yFZcuWYRgGhmEwadKkWstYsWIFv/jFL3C73aSmpnLjjTdSUlIS3n/ttddy0UUX8eSTT9K6dWtSU1O5+eab6zx7jtSkMCAiIiJRzzSDjfJ1tCZPnozNZmPRokU899xzPP300/z73/8O73/yyScZMGAAS5Ys4cEHH2TTpk2MGjWKSy+9lOXLl/P+++8zZ84cJkyYEH7Ptddey/bt25k1axb/+c9/+Oc//xle0Ko2JSUljBgxgp07dzJt2jSWLVvG3XffTTAY5IorruDOO++kT58+7N69m927d3PFFapNQR4AAQAASURBVFccUEZpaSkjR44kOTmZH374gQ8//JCvv/66Rr0AZs2axaZNm5g1axaTJ09m0qRJ4XAhkaFuQiIiIhLVTDPI7t1LGuXcrVsPxDCO/Nlsu3bteOaZZzAMgx49erBixQqeeeYZbrjhBgB+8YtfcOedd4aP/81vfsPYsWO57bbbAOjWrRvPP/88I0aM4OWXX2bbtm18/vnnLFq0iJNOOgmA119/nV69eh20Du+88w579uzhhx9+ICUlBYCuXbuG98fFxWGz2Q7ZLeidd96hoqKCN998k9jYWABefPFFLrzwQv7+97+TlpYGQHJyMi+++CJWq5WePXty/vnnM3PmzPDnlbpTy4CIiIjIcWLYsGE15pfPzMxkw4YN4YXUBg8eXOP4ZcuWMWnSJOLi4sJfI0eOJBgMkpWVxZo1a7DZbAwaNCj8np49e5KUlHTQOixdupSBAweGg8CxWLNmDQMGDAgHAYCTTz6ZYDDIunXrwtv69OlTY3Xd1q1bH7LVQo6eWgaaoGDQT2npHiwWKx5PET5fOamp3bHZnI1dNRERkWbHMCy0bj2w0c4dSdVvriHUpeemm27illtuOeDY9u3bs379+qM+h9vtPub6HS273V7jtWEYBINH371KDk5hoAkqLt5Faemen23bSXJy50aqkYiISPMW6Zvy+rJw4cIarxcsWEC3bt1qPD2v7sQTT2T16tU1uvFU17NnT/x+P4sXLw53E1q3bh0FBQUHrUP//v3597//TV5eXq2tAw6HI9xScTC9evVi0qRJlJaWhgPM3LlzsVgs9OjR45Dvlcg6Pn7yo4hpmpSX5wPgcMRhtYamBCsvz6eioqARayYiIiKNbdu2bdxxxx2sW7eOd999lxdeeIFbb731oMffc889zJs3jwkTJrB06VI2bNjAJ598Eh6o26NHD0aNGsVNN93EwoULWbx4Mb/5zW8O+fR/zJgxpKenc9FFFzF37lw2b97Mf//7X+bPnw+EZjXKyspi6dKl7N27F4/Hc0AZY8eOxeVycc0117By5UpmzZrF//3f/3H11VeHxwtIw1AYaGLKy/MIBv1YLDZSU7uTltaP2NhWABQUbCEQ0HRaIiIi0WrcuHGUl5czZMgQbr75Zm699dbwFKK16d+/P7Nnz2b9+vWceuqpDBw4kIceeoiMjIzwMRMnTiQjI4MRI0ZwySWXcOONN9KqVauDlulwOPjqq69o1aoV5513Hv369ePxxx8Pt05ceumljBo1ijPOOIOWLVvy7rvvHlBGTEwMX375JXl5eZx00kn8+te/5swzz+TFF1+sw9WRY2GYVZPTRqGioiISExMpLCwkISGhsauDx1PMvn2hvntxcWkkJLQFQq0F+/atw+stxe1OVnchERGROqioqCArK4tOnTrhcrkauzpH7PTTT+eEE07g2WefbeyqSBNwqJ/jo7nHVctAExEM+iks3AqA251MfHyb8D7DMEhMbA+EugsFg4fuhyciIiIiciQ0gLgJKC/PIz8/K/w6Pr5NjWnDAOz2GKxWB4GAF5+vFKez8VsyREREROT4pjDQyAIBHwUFW8KvY2NbHXQKUYcjjvLyPLzeEoUBERGRKPPtt982dhWkGVIYaGTl5fswTROHI5YWLXoe8tjqYUBEREREpK40ZqCRlZXtAyAmpsVhj61qDfB4ivH5yuu1XiIiIiLS/KlloBF5vaX4/RUYhgWXK/mwx9tsTtzuZMrL89mzZzV2ewymGcRujyExsT0WS+0LjoiIiIiI1EYtA42orGwvEJo96Ehv5OPjM8KrJPp8Zfj9FZSX51FWtucw7xQRERERqUlhoJGYZpCKitBKw2536hG/z2ZzkZzcCavVTmxsS2JjWwJQWrqHKF4yQkRERESOgboJNZKq9QJsNidOZ/xRvdflSsLlSgJCoaK8PJ9AwIvHU4TLlVgPtRURERGR5kgtA42kvDw0cPhoWgVqYxgWYmJCZairkIiIiETSn//8Z0444YSIljlp0iSSkpIiWmZdfPvttxiGQUFBARCZ+jW1z3goCgONxOGIx2p1hG/k6yImJtRVqKKiEL/fU+fyRERERKLVFVdcwfr164/4+I4dO/Lss8/WqYzGpG5CjSQ+vjXx8a0jUlaoq1ECHk8RZWV7SEhoG5FyRURERI4HpmkSCASw2ep+a+t2u3G73Y1eRkNRy0AzUTWQuKxsnwYSi4iINEOnn346//d//8dtt91GcnIyaWlpvPbaa5SWlnLdddcRHx9P165d+fzzz8PvCQQCXH/99XTq1Am3202PHj147rnnapT77bffMmTIEGJjY0lKSuLkk09m69attdZh06ZNdO7cmQkTJmCaJh6Phz/84Q+0adOG2NhYhg4desBKyZMmTaJ9+/bExMRw8cUXs2/fvkN+zi1btmAYBu+99x7Dhw/H5XLRt29fZs+eXaPOhmHw+eefM2jQIJxOJ3PmzCEYDPLYY4+FP++AAQP4z3/+U6P8//3vf3Tv3h23280ZZ5zBli1bDqjvz7v4fPrpp5x00km4XC5atGjBxRdfHP472bp1K7fffjuGYWAYxkHLePnll+nSpQsOh4MePXrw1ltv1dhvGAb//ve/ufjii4mJiaFbt25MmzbtkNcqEhQGmgmnMxHDsBAM+gkE1FVIRESkOZo8eTItWrRg0aJF/N///R+/+93vuOyyyxg+fDg//fQT55xzDldffTVlZWUABINB2rZty4cffsjq1at56KGHuP/++/nggw8A8Pv9XHTRRYwYMYLly5czf/58brzxxvBNbXXLly/nlFNO4corr+TFF1/EMAwmTJjA/Pnzee+991i+fDmXXXYZo0aNYsOGDQAsXLiQ66+/ngkTJrB06VLOOOMMHn300SP6rHfddRd33nknS5YsITMzkwsvvPCAIHHvvffy+OOPs2bNGvr3789jjz3Gm2++ySuvvMKqVau4/fbbueqqq8JBYvv27VxyySVceOGFLF26lN/85jfce++9h6zHZ599xsUXX8x5553HkiVLmDlzJkOGDAHgo48+om3btjz88MPs3r2b3bt311rGxx9/zK233sqdd97JypUruemmm7juuuuYNWtWjeP+8pe/cPnll7N8+XLOO+88xo4dS15e3hFdr2NmRrHCwkITMAsLCxu7KhGxZ88ac+fOH82ysrzGroqIiEiTVV5ebq5evdosLy+PTIEBb2TKOYwRI0aYp5xySvi13+83Y2Njzauvvjq8bffu3SZgzp8//6Dl3Hzzzeall15qmqZp7tu3zwTMb7/9ttZj//SnP5kDBgww586dayYnJ5tPPvlkeN/WrVtNq9Vq7ty5s8Z7zjzzTPO+++4zTdM0x4wZY5533nk19l9xxRVmYmLiQeuXlZVlAubjjz8e3ubz+cy2bduaf//7303TNM1Zs2aZgDl16tTwMRUVFWZMTIw5b968GuVdf/315pgxY0zTNM377rvP7N27d43999xzjwmY+fn5pmma5sSJE2vULzMz0xw7duxB69uhQwfzmWeeqbHt52UMHz7cvOGGG2occ9lll9W4NoD5wAMPhF+XlJSYgPn555/Xet5D/RwfzT2uWgaaEbs9BggtRiYiIiINYMH18J4j9GcD6N+/f/h7q9VKamoq/fr1C29LS0sDIDc3N7ztpZdeYtCgQbRs2ZK4uDheffVVtm3bBkBKSgrXXnstI0eO5MILL+S555474On2tm3bOPvss3nooYe48847w9tXrFhBIBCge/fuxMXFhb9mz57Npk2bAFizZg1Dhw6tUV5mZuYRfdbqx9lsNgYPHsyaNWtqHDN48ODw9xs3bqSsrIyzzz67Rn3efPPNOtVn6dKlnHnmmUdU54NZs2YNJ598co1tJ5988gGfp/rfb2xsLAkJCTX+LuuDBhA3IzZbaKCKwoCIiEgDCPpg8xuh7ze/AUNeAYu9Xk9pt9cs3zCMGtuquvcEg0EA3nvvPf7whz/w1FNPkZmZSXx8PP/4xz9YuHBh+D0TJ07klltu4YsvvuD999/ngQceYMaMGQwbNgyAli1bkpGRwbvvvsv48eNJSEgAoKSkBKvVyuLFi7FarTXqFRcXF/kPX4vY2Njw9yUlJUCoW0+bNm1qHOd0Oo/5HA05ELi2v9+qv8v6opaBZkQtAyIiIg3IYofO40Pfdx5f70HgWMydO5fhw4fz+9//noEDB9K1a9fwU/LqBg4cyH333ce8efPo27cv77zzTnif2+1m+vTpuFwuRo4cSXFxcfg9gUCA3NxcunbtWuMrPT0dgF69etUIHgALFiw4orpXP87v97N48WJ69ep10ON79+6N0+lk27ZtB9SnXbt24fosWrToqOrTv39/Zs6cedD9DoeDQCBwyDJ69erF3Llza2ybO3cuvXv3PuT7GoLCQDNit7srE6Rf6w2IiIg0hGGvw2hv6M8mqFu3bvz44498+eWXrF+/ngcffJAffvghvD8rK4v77ruP+fPns3XrVr766is2bNhwwE13bGwsn332GTabjXPPPZeSkhK6d+/O2LFjGTduHB999BFZWVksWrSIxx57jM8++wwg3OLw5JNPsmHDBl588UW++OKLI6r7Sy+9xMcff8zatWu5+eabyc/PZ/z48Qc9Pj4+nj/84Q/cfvvtTJ48mU2bNvHTTz/xwgsvMHnyZAB++9vfsmHDBu666y7WrVvHO++8w6RJkw5Zjz/96U+8++67/OlPf2LNmjWsWLGCv//97+H9HTt25LvvvmPnzp3s3bu31jLuuusuJk2axMsvv8yGDRt4+umn+eijj/jDH/5wRNeiPikMNCOGYanWOlDayLURERGJEk2wRaDKTTfdxCWXXMIVV1zB0KFD2bdvH7///e/D+2NiYli7di2XXnop3bt358Ybb+Tmm2/mpptuOqCsuLg4Pv/8c0zT5Pzzz6e0tJSJEycybtw47rzzTnr06MFFF13EDz/8QPv27QEYNmwYr732Gs899xwDBgzgq6++4oEHHjiiuj/++OM8/vjjDBgwgDlz5jBt2jRatGhxyPc88sgjPPjggzz22GP06tWLUaNG8dlnn9GpUycA2rdvz3//+1+mTp3KgAEDeOWVV/jb3/52yDJPP/10PvzwQ6ZNm8YJJ5zAL37xixqtCw8//DBbtmyhS5cutGzZstYyLrroIp577jmefPJJ+vTpw7/+9S8mTpzI6aeffkTXoj4ZlaOXo1JRURGJiYkUFhaG+78d7woLt1NamktsbCsSE9s1dnVERESanIqKCrKysujUqRMul6uxqyM/s2XLFjp16sSSJUs44YQTGrs6Tdahfo6P5h5XLQPNjMMRGkjj9RY3ck1EREREpKlTGGhmnM4EDMPA5yvXuAEREREROSRNLdrMWCw2HI54PJ4iKiryiYtLb+wqiYiIiByxjh07EsW92BucWgaaIbc7GYCKioLGrYiIiIiINGkKA82Q0xkaKOLzlREMHnreWxERERGJXgoDzZDV6sBmc2KaJl5vSWNXR0RERESaKIWBZsrhiAfA4ylq5JqIiIiISFOlMNBMuVxJAJSX52kQjoiIiIjUSmGgmXI6E7Ba7QSDfjyewsaujoiIiIg0QQoDzZRhGLjdqQCUle1t5NqIiIhIXZ1++uncdtttR3Tst99+i2EYFBQU1OmcHTt25Nlnn61TGdK0KQw0YzExoTBQUVFIIOBr5NqIiIiISFOjMNCM2WwuHI44APLzN2vsgIiIiIjUoDDQzCUmtsdiseL1lmjsgIiISDPx1ltvMXjwYOLj40lPT+fKK68kNzf3gOPmzp1L//79cblcDBs2jJUrV9bYP2fOHE499VTcbjft2rXjlltuobS0tKE+hjQBCgNN3K6Ccmav34M/EDym99vtbtzuFAA8nuJIVk1ERKRZME2TMq+/Ub6OtdXe5/PxyCOPsGzZMqZOncqWLVu49tprDzjurrvu4qmnnuKHH36gZcuWXHjhhfh8oa7DmzZtYtSoUVx66aUsX76c999/nzlz5jBhwoS6XE45ztgauwJycIGgydh/LyRrbykD2iby/k2ZuOzWoy7H4YintHQPXq/CgIiIyM+V+wL0fujLRjn36odHEuM4+tux8ePHh7/v3Lkzzz//PCeddBIlJSXExcWF9/3pT3/i7LPPBmDy5Mm0bduWjz/+mMsvv5zHHnuMsWPHhgcld+vWjeeff54RI0bw8ssv43K56vbh5LigloEm7MtV2WTtDTXVLdtRyNyNxzYrkNMZWoDM5yvXQGIREZFmYPHixVx44YW0b9+e+Ph4RowYAcC2bdtqHJeZmRn+PiUlhR49erBmzRoAli1bxqRJk4iLiwt/jRw5kmAwSFZWVsN9GGlUahlowj74cXuN17PX7+HMXmlHXY7FYsNuj8HnK8PjKSQmpkWkqigiInLcc9utrH54ZKOd+2iVlpYycuRIRo4cyZQpU2jZsiXbtm1j5MiReL3eIy6npKSEm266iVtuueWAfe3btz/qesnxSWGgCVu9qwiA35/ehX9+u4nv1u855rLc7mR8vjIKC7fjdCZitdojVU0REZHjmmEYx9RVp7GsXbuWffv28fjjj9OuXTsAfvzxx1qPXbBgQfjGPj8/n/Xr19OrVy8ATjzxRFavXk3Xrl0bpuLSJKmbUBOVX+olt9gDwDXDOwKwZV8Z+aVHnvirc7mSADDNIHv2rMLnK49ENUVERKSBtW/fHofDwQsvvMDmzZuZNm0ajzzySK3HPvzww8ycOZOVK1dy7bXX0qJFCy666CIA7rnnHubNm8eECRNYunQpGzZs4JNPPtEA4iijMNBErc8JDfZtm+wmLcFFq3gnANvzy46pPJvNRUJCGywWG8FggH371ml2IRERkeNQy5YtmTRpEh9++CG9e/fm8ccf58knn6z12Mcff5xbb72VQYMGkZ2dzaefforD4QCgf//+zJ49m/Xr13PqqacycOBAHnroITIyMhry40gjO+ow8N1333HhhReSkZGBYRhMnTq1xn7TNHnooYdo3bo1brebs846iw0bNtQ4Ji8vj7Fjx5KQkEBSUhLXX389JSUlNY5Zvnw5p556Ki6Xi3bt2vHEE08cUJcPP/yQnj174nK56NevH//73/+O9uM0WVVhoEdaaPBvu5QYAHbkH/sT/bi4dFq16oPdHkMwGKC4eGfdKyoiIiIN4ttvv+XZZ58FYMyYMWRlZVFRUcG8efO48MILMU2TE044AYDTTz8d0zS54IILWLlyJR6Ph4ULF9K/f/8aZZ500kl89dVXFBcXU1JSwrJly7j//vvD+7ds2RKebUiap6MOA6WlpQwYMICXXnqp1v1PPPEEzz//PK+88goLFy4kNjaWkSNHUlFRET5m7NixrFq1ihkzZjB9+nS+++47brzxxvD+oqIizjnnHDp06MDixYv5xz/+wZ///GdeffXV8DHz5s1jzJgxXH/99SxZsoSLLrqIiy666IDFNI5X6yrDQPf0UBhom+wGYHvesbUMVLFYbKSkdAHA6y0lGPQDUFi4jX37NmCax7aegYiIiIgcf456tMy5557LueeeW+s+0zR59tlneeCBB/jVr34FwJtvvklaWhpTp05l9OjRrFmzhi+++IIffviBwYMHA/DCCy9w3nnn8eSTT5KRkcGUKVPwer288cYbOBwO+vTpw9KlS3n66afDoeG5555j1KhR3HXXXQA88sgjzJgxgxdffJFXXnnlmC5GU7JyZ2jwcK/WCQC0S657y0AVq9WB3e7G5yunoqIQpzO0DgFAeXk+MTGpdT6HiIiIiDR9ER0zkJWVRXZ2NmeddVZ4W2JiIkOHDmX+/PkAzJ8/n6SkpHAQADjrrLOwWCwsXLgwfMxpp50W7tMGMHLkSNatW0d+fn74mOrnqTqm6jy18Xg8FBUV1fhqivyBIGt2h+rWr00iUK1l4BjHDPyc0xkKGQUFW8jJWRHeXl6eF5HyRURERKTpi2gYyM7OBiAtreZc+GlpaeF92dnZtGrVqsZ+m81GSkpKjWNqK6P6OQ52TNX+2jz22GMkJiaGv6qm42pqNuSW4PEHiXfa6FA5VqDtQVoGyrx+tlQuTHY04uLScTjiDtju9RYTDAaOodYiIiIicryJqtmE7rvvPgoLC8Nf27dvP/ybGsGKnYUA9GmTgMViANAuJdQysCO/DNM0w8fe/9EKznjqWxZs3ndU57BYbLRo0YOWLXsTG9sKlysJi8WGaZp4vSWHL0BEROQ4V/33qcjxJlI/vxENA+np6QDk5OTU2J6TkxPel56eTm5ubo39fr+fvLy8GsfUVkb1cxzsmKr9tXE6nSQkJNT4akpM0+Tbdbl8WLny8IB2SeF9rRPdGAZU+ILsLfHuP379HkwT3l20rbYiD8tud5OY2I6UlC7htQi8Xk05KiIizZfVGlr192hW6xVpasrKQl3H7fa6LSQb0eX2OnXqRHp6OjNnzgxPbVVUVMTChQv53e9+B0BmZiYFBQUsXryYQYMGAfDNN98QDAYZOnRo+Jg//vGP+Hy+8AecMWMGPXr0IDk5OXzMzJkza0x3NWPGDDIzMyP5kRrUC99s5OkZ68OvLzqhTfh7h81C6wQXuwor2JFfRst4Jzvyyyko8wHw1aocSj1+Yp3H/lfqdMZTVrZX6w+IiEizZrPZiImJYc+ePdjtdiyWqOooIcc50zQpKysjNzeXpKSkcLg9Vkd951hSUsLGjRvDr7Oysli6dCkpKSm0b9+e2267jUcffZRu3brRqVMnHnzwQTIyMsKr3fXq1YtRo0Zxww038Morr+Dz+ZgwYQKjR48OL3Jx5ZVX8pe//IXrr7+ee+65h5UrV/Lcc8/xzDPPhM976623MmLECJ566inOP/983nvvPX788cca048eT7bsLeXZr/cHgRPbJ4VnEqrSNjmGXYUVbM8vZ2D75HB3IoByX4CvVmdz8cC2x1yHqjEEPl8ZwWAAi6VuP1wiIiJNkWEYtG7dmqysLLZu3drY1RE5JklJSYfsEXOkjjoM/Pjjj5xxxhnh13fccQcA11xzDZMmTeLuu++mtLSUG2+8kYKCAk455RS++OILXC5X+D1TpkxhwoQJnHnmmVgsFi699FKef/758P7ExES++uorbr75ZgYNGkSLFi146KGHaqxFMHz4cN555x0eeOAB7r//frp168bUqVPp27fvMV2IxvbtulyCJnRpGcvZvdO5eGCbA45pm+xm0ZbQuAHYP7bAYbXgDQSZumRXncKA1erAZnPi93vwektwuRKPuSwREZGmzOFw0K1bN3UVkuOS3W6vc4tAFcOM4tEzRUVFJCYmUlhY2OjjB25880e+Wp3D3aN68PvTu9Z6zNMz1vP8zA2MGdKexy7px+hX57Ngcx43jejMv2ZvxmLA4gfOJjnWUev7j0RBwVbKyvYSF5dGQsKxBwsRERERaRxHc4+rTnJNQDBosjArNL9/ZueDL/hVtdbAjvwyvP4gS7YVAHDZoLZ0bhFL0IRlOwrqVBenM7TisWYUEhEREWn+FAaagNW7iygs9xHntIUXGatN1ZoDa3YXsWRbPh5/kJRYB11axoVnHlq2vfCg7z8SVeMGvN5SrTcgIiIi0swpDDQB8zeF1gg4qWMyNuvB/0oGtk8mNdbB3hIv1036IfwewzDo3zYUIpbXsWWgatwAqHVAREREpLlTGGgC5lcuGDa8S4tDHuewWcIDi8u8oaf2Va/DLQM7Cuq8CIXDUdVVSFOMioiIiDRnCgONrMIXYFHVeIEuBx8vUOW6UzrRJyOB3q0TeG70CYzq2xqA3q0TcNut7C3xsmpXUZ3qpHEDIiIiItEhoouOydH7dNkuSjx+Wie6DlhXoDZtktx8dsupB2x32a2c3qMln6/M5ouV2fQ9xNiDw9F6AyIiIiLRQS0DjWzy/C0AXDO8I1aLUaeyRvUNLTzx1ersOpVTNW7ANE21DoiIiIg0YwoDjWhnQTkrdxZhMeCKwe3qXN7JXUNjDjbkllDm9deprP3jBhQGRERERJorhYFG9O26XABObJ9cp4XCqrSIc9Iizolpwvqcut3EOxyxQKirkIiIiIg0TwoDjWj2uj0AnN6jZcTK7NU69ER/7e66DSK22UILnPn95XWuk4iIiIg0TQoDjSQQNMNTip7aLXJhoEdaZRjIrtu0oHZ7KAwEAj6Cwbp1ORIRERGRpklhoJGsyy6muMJPnNNGn4zDzyJ0pHpWzki0NrtuLQOGYQkvPqauQiIiIiLNk8JAI1mUFWoVOLHDoVcdPlo90/e3DNR18TG7PQYAn09dhURERESaI4WBRrJoS2ihsaGdUiJabtdWcVgtBgVlPnKKPHUqy2ZzAeD3V0SiaiIiIiLSxCgMNJLiCj+GAUMiHAZcdiudWoRmAlpTx65CVWEgEKhbqBARERGRpkkrEDeSt64fSmG5jxhH5Ff37Zkez8bcEtbuLuaMHq2OuRyrNTRmQC0DIiIiIs2TWgYaUaLbjj2C4wWq9IrQIOL9LQM+gsFAneslIiIiIk2LwkAzVDWIeF0dpxe1WKxYrXZAXYVEREREmiOFgWaoanrRjbkleP3BOpVV1TpQXp5X53qJiIiISNOiMNAMZSS6iHfZ8AdNNu0pqVNZsbFpAJSU5GiKUREREZFmRmGgGTIMo9p6A3UbN+ByJeJyJQJQUZFf57qJiIiISNOhMNBM9UwPdRVatbNuYQDA5UoGoKKigIqKQrUQiIiIiDQTCgPN1OCOoRv47zbsqXNZVS0DPl85eXkbycvbUOfVjUVERESk8SkMNFOnd2+F1WKwPqeE7XlldSrLYrHhdieHXwcCPjyewrpWUUREREQamcJAM5UYY2dwh9AN/Ddrc+tcXnx8BoZhhF+Xle2rc5kiIiIi0rgUBpqxET1aAjB34946l2WzuUhN7UFSUgcAPJ4idRUSEREROc4pDDRjw7u0AGBhVh6BYN1v3B2OWGJiWmCx2DDNIF5v3aYtFREREZHGpTDQjPXNSCDOaaOw3Mea3XWfVaiK0xmaqcjrrdsKxyIiIiLSuBQGmjGb1cKgynEDS7cXRKxcpzO0hoHHozAgIiIicjxTGGjmurSMA2DL3tKIlelwhMr0+co0bkBERETkOKYw0Mx1ahEDwJZ9kQsDNpsLi8WKaQbx+7UAmYiIiMjxSmGgmevYIhaArAi2DADY7aFyNYhYRERE5PilMNDMdUwN3bRvzyuPyIxCVarGDVRUFESsTBERERFpWAoDzVxGkhuH1YI3EGRXQeS69LjdKUBoEHEg4I1YuSIiIiLScBQGmjmrxaB9amjcQCS7ClmtjnDrQGH+5oiVKyIiIiINR2EgClR1FYrkIGKA+Pg2GCsfpmJaLyq+vzqiZYuIiIhI/VMYiALhGYX2lkW0XIfNQczuaQB4Nr8NQV9EyxcRERGR+qUwEAWqZhSKdMsAFjvOzlcBUNH6V2CxR7Z8EREREalXCgNRoFNVN6EITy8K4DxlMkabCwns+AT/3GsiXr6IiIiI1B+FgShQ1TKwLa8MfyAY0bINM4Bj96cAeDa9qa5CIiIiIscRhYEokJ7gwmW34A+abNpTD12FOo0BoCLjEnUVEhERETmOKAxEAYvFYFjnVAC+XJUd8fKdw1+HNhfg3fYR5vzxES9fREREROqHwkCUuKB/BgCfLttFMIIrEQPYrTasu6ZjAt6NE9VVSEREROQ4oTAQJc7unYbLbmFDbgmvfX/gImG+QJBrJy7imjcW4fEHjq5wix1nx8sBqGh7mboKiYiIiBwnFAaiRKLbzkMX9AHgqRnr2VlQXmP/hz/u4Nt1e5i9fg8vzNx41OU7h70CbS7As+VDWHB9ROosIiIiIvVLYSCKjBnSjmGdU/D6gzz/9QbyS73MWJ2Dxx/gpVn7A8Br32+msPzouvo47S7YOR2/CcFNb6irkIiIiMhxwDBNM7IdyI8jRUVFJCYmUlhYSEJCQmNXp0Es3prPpS/Pq7GtTZKbnQXlJLhspMQ62LIvtFLxy2NP5Nx+rY+47NwZl+Df/jGp3a/CecpbEa23iIiIiByZo7nHVctAlBnUIZkT2yfV2FbVZejCARmMy+wY3v7El+s4mqxoH/wUjFyAt99fI1FVEREREalnCgNRaMIvugIwtFMKN5/RBcMAm8VgzJD2jBnSnotOCM08lLW3lE17So64XLs9Blb+Dd/HHTRuQEREROQ4oG5CUdZNqMr2vDIyktxYLQZ7SzyUewO0S4kJ77924iK+XbeHu0f14Pendz2iMr0VBex9JxkDSHOCZYxXMwuJiIiINDB1E5LDapcSg9ViANAizlkjCACc0rUFACt3Fh5xmQ5XEvb2l2AC+T4wF9wQsfqKiIiISOQpDEiturSKA2BTbulRvS9++CsAeIJQtGEyzL8u4nUTERERkchQGJBadWkRCgNZ+0oJHMWKxa6YliR0rlyALAhkTdI0oyIiIiJNlMKA1KpNshuHzYLXH2Rnfvnh31BN7Ih3MdpcSMAEf4dxGjcgIiIi0kQpDEitrBaDTqmxADVmFMor9TL23wt4c/6Wg77XMCw4bA4APH61CoiIiIg0VQoDclBdWoXCwMbc/WHggx+3M3fjPh76ZBXzN+2r/Y1BH/Yd/wUgsOVddRMSERERaaIUBuSgeqSFpqJak10U3vbNmtzw95Pnban9jRY7lo6jAQi0u0zdhERERESaKFtjV0Cart4ZoTCwelcoDOSXevlxa154/6EWJLOc9CJ0vY2gK6V+KykiIiIix0wtA3JQfSrDwIbcEip8AZZuLyBogsse+rHZuq/soDMNWa12MGwE1UVIREREpMlSGJCDap3oIjnGTiBo8ub8LeHuQmf1SsNps+ANBNmRX1brey2VXYMCAYUBERERkaZKYUAOyjAMBrRLAuBv/1vLS99sBELdhzq1CA0u3ryn9kXJrNZQGAgG/Zjmka9TICIiIiINR2FADunRi/pyctdUAEq9AQB6pe8PAwcbN2Cx2DAMA0BdhURERESaKIUBOaS2yTG8evVgWie6wtt6to6nW6vQCsVrdhcf9L0Wix1Mv7oKiYiIiDRRCgNyWLFOG+/eMIxureIY3iWV9AQXJ7RPAmDJtvyDvs+y4s/w5TCCC29qmIqKiIiIyFHR1KJyRDq2iOWr208Ld/0Z2C4ZgM17S8kv9ZIc66j5hqAP+86P8AGezVNwnTxR6w2IiIiINDFqGZAjVhUEAJJjHXRuGRo38FNtrQMWO67OVwFQ0fqXmIZyp4iIiEhTozAgx+yEtknA/kXJfs55yptY2lxIYMc0vHPHNWDNRERERORIKAzIMetSOYh4897apxc1TD/u7E8BKN34NmhWIREREZEmRWFAjlnn8FoDtU8visVObNdQi0BFEAILbmyoqomIiIjIEVAYkGMWbhnYU3rQhcVsmf/GUflTVrFxkloHRERERJoQhQE5Zh1SY7AYUOzxs6fYU/tBFjuuTmOAUOsAi37bcBUUERERkUNSGJBj5rRZaZscA8CmPbWPGwBwZb4KgCcIwU1vqHVAREREpIlQGJA6qZpedPPeg4wbAGyOOGztLgbA2/6q/esNKBSIiIiINCqFAamTLi33jxs4FOeQZ2HkAjx9/wKAZ844Ct5yEJx/XX1XUUREREQOIuJhIBAI8OCDD9KpUyfcbjddunThkUceqTHA1DRNHnroIVq3bo3b7eass85iw4YNNcrJy8tj7NixJCQkkJSUxPXXX09JSc2nz8uXL+fUU0/F5XLRrl07nnjiiUh/HDmMcMvAwWYUquRwxMPKv+Gd2gXmX0fe+rcoC0DBuklqIRARERFpJBEPA3//+995+eWXefHFF1mzZg1///vfeeKJJ3jhhRfCxzzxxBM8//zzvPLKKyxcuJDY2FhGjhxJRUVF+JixY8eyatUqZsyYwfTp0/nuu++48cb9U1MWFRVxzjnn0KFDBxYvXsw//vEP/vznP/Pqq69G+iPJIXRuEWoZONSYAQCn3QU7p+EzIbB5EmabC4DQoGJzwQ31Xk8REREROZBhHmxOyGN0wQUXkJaWxuuvvx7edumll+J2u3n77bcxTZOMjAzuvPNO/vCHPwBQWFhIWloakyZNYvTo0axZs4bevXvzww8/MHjwYAC++OILzjvvPHbs2EFGRgYvv/wyf/zjH8nOzsbhcABw7733MnXqVNauXXtEdS0qKiIxMZHCwkISEhIieRmiRm5xBUP+OhOLAWseGYXTZj3osXu+vgTfto9J6Hw5Rd3ugC+HAeC2QnL3ayFzYgPVWkRERKT5Opp73Ii3DAwfPpyZM2eyfv16AJYtW8acOXM499xzAcjKyiI7O5uzzjor/J7ExESGDh3K/PnzAZg/fz5JSUnhIABw1llnYbFYWLhwYfiY0047LRwEAEaOHMm6devIz8+vtW4ej4eioqIaX1I3LeOcxDttBE3Yuq/skMc6hzwPbS6gNOsDWPEItLkAAygPgGfTJHUXEhEREWlgEQ8D9957L6NHj6Znz57Y7XYGDhzIbbfdxtixYwHIzs4GIC0trcb70tLSwvuys7Np1apVjf02m42UlJQax9RWRvVz/Nxjjz1GYmJi+Ktdu3Z1/LRiGAbtU0PTi27PO3QYcDniYOd0Aiaw6zNiilYQ0/HXAJT60RoEIiIiIg0s4mHggw8+YMqUKbzzzjv89NNPTJ48mSeffJLJkydH+lRH7b777qOwsDD8tX379sauUrPQNtkNwI788kMe53Alkdp1DDaj8nXFVmKHvQiExg5oDQIRERGRhmWLdIF33XVXuHUAoF+/fmzdupXHHnuMa665hvT0dABycnJo3bp1+H05OTmccMIJAKSnp5Obm1ujXL/fT15eXvj96enp5OTk1Dim6nXVMT/ndDpxOp11/5BSQ7vkI2sZAHCe9g4t8xfhL96EPaEbxKRhb38xvm0f42k3BnfVGgQiIiIiUu8i3jJQVlaGxVKzWKvVSjAYBKBTp06kp6czc+bM8P6ioiIWLlxIZmYmAJmZmRQUFLB48eLwMd988w3BYJChQ4eGj/nuu+/w+fY/SZ4xYwY9evQgOTk50h9LDuFIWwaqGL/aiH10KfwyNK7EOeQFaHMBFVnvwoLr662eIiIiIlJTxMPAhRdeyF//+lc+++wztmzZwscff8zTTz/NxReHVqA1DIPbbruNRx99lGnTprFixQrGjRtHRkYGF110EQC9evVi1KhR3HDDDSxatIi5c+cyYcIERo8eTUZGBgBXXnklDoeD66+/nlWrVvH+++/z3HPPcccdd0T6I8lhtEupbBnIP3zLQJgtJvytyxELO6dTEVBXIREREZGGFPFuQi+88AIPPvggv//978nNzSUjI4ObbrqJhx56KHzM3XffTWlpKTfeeCMFBQWccsopfPHFF7hcrvAxU6ZMYcKECZx55plYLBYuvfRSnn/++fD+xMREvvrqK26++WYGDRpEixYteOihh2qsRSANIxwGjqCbUG0criRs7S/Gv+1j8n2QPG88llPeimQVRURERKQWEV9n4HiidQYio8zrp/dDXwKw7KFzSIw5+n7/pcU7KfywLQAWA1KTO2O/aFNE6ykiIiISDRp1nQGJPjEOG63iQwOzs/YdeiXig5YRl0FCp8uwGhA0oaRwM/iPraVBRERERI6MwoBEROeWsQBs3lNyTO83DIO4Mz4gJbkzABXOdgQtmvlJREREpD5FfMyARKfOLeNYsDmPzXuOrWWgiv2iTdh3L8ZnQkVFPjExLSJUQxERERH5ObUMSER0blHZMrD32FoGqnPHh8YOlJXtq3NZIiIiInJwCgMSEV1axgHUuWUAwO1OAcDrLcHv99S5PBERERGpncKAREQ4DOwtxesP1qksq9WO0xka+V5RkV/nuomIiIhI7RQGJCLapbhJcNnw+oOszymuc3kuVxIA5eUKAyIiIiL1RWFAIsIwDAa0SwJg2Y6COpdXFQZ8vjIqKgrrXJ6IiIiIHEhhQCKmf9tEAJZvr/vNu9VqJza2FQAFBVmUle0jL28jJSU5+DxFdS5fRERERBQGJIIGtE0C4MvV2Xy5Kpu6Lm6dkNAGhyOOYDBAQcEWKioKKZp7I3umJOKZMy4CNRYRERGJbgoDEjEjerSkb5sECsp83PTWYv72vzV1Ks8wLKSkdMUwKn9MTT/snAZA+aa3IOira5VFREREoprCgESM02Zl4rVDOKd3GgBvzN3Cuuy6DSa2WKykpHQJrVAc34YW3a8GoDwA5sKb6lxnERERkWimMCAR1TLeyavjBjOqTzqBoMkj01fXubuQ05lAevoJJCS0xTH8dawGmIBn40S1DoiIiIjUgcKA1Iv7z+uFw2phzsa9fL9hb53LC3cVsthxdbwcAE+bX4PFXueyRURERKKVwoDUi/apMVw5tD0A7yzcFtGynZmvQpsLqNj6H8z54yNatoiIiEg0URiQejNmSCgMfL0mh70lnoiV67S7sOyaTsCE4g0TMX2lEStbREREJJooDEi96ZEeT782ifiDJt+u2xOxcg2rk/jOYwAo8cO+KXGY866NWPkiIiIi0UJhQOrVad1bAPD9hsiFAYCYUyYRZwMD8AahcMNkmH9dRM8hIiIi0twpDEi9OrVbSwDmbtxLMFi3WYWqM6wOErqPJ8URel0WAN+mSZpdSEREROQoKAxIvTqxfTJOm4W9JV625pVFtvBhr+McXYrbGnpZGohs8SIiIiLNncKA1CuHzUK3tDgA1ufUbQGyWtliiO0SWoisIv1CTMMW+XOIiIiINFMKA1LvuqfFA7C+jqsRH4z95MlY2/6S4M5P8c4dVy/nEBEREWmOFAak3lWFgXX10TIAGKYf5+5pAPg2v61xAyIiIiJHSGFA6l2PqpaBegoDWOxYO44GwN/uMq1KLCIiInKE1MFa6l2P9FAY2LynlHJvALfDGvFz2Ib8E7reht+ZGPGyRURERJortQxIvWud6CI9wYU/aLJsR0G9nMNmc4Jhw++P3ErHIiIiIs2dwoDUO8MwGNwxGYAft+TVyzlsNhcAwUAFwaC/Xs4hIiIi0twoDEiDOKljCgCLtuTXS/mGYcG66lH4chj+eePr5RwiIiIizY3CgDSIqjDw45Y8vP5g5E8Q9GHfORUAz+a3NKOQiIiIyBFQGJAG0at1PC3jnZR5A/y4tR66ClnsuDpfCUBF64s0o5CIiIjIEVAYkAZhGAandmsBwOx1e+rlHK5TJkObC/Btn4r3+6vq5RwiIiIizYnCgDSYM3q0AuDjJTtZm13ExLlZ7Mgvi1j5FkxisqcDULBxCsy/LmJli4iIiDRHCgPSYEb2Sad1oovcYg+jnv2ev3y6mrOens2KHYWROYHFTkK3cVgM8Jvg2TRJYwdEREREDkFhQBqMw2bh9rO619hW4Qty13+WEQiaETmHZfhk3B1+DUBZAFj024iUKyIiItIcKQxIg7r8pHZ8cFMm953bk5l3jiDOaWNtdjErd0aodQBwD38NgIoABDe9odYBERERkYNQGJAGN6RTCjeN6EKXlnEM6xyacnTB5n0RK9/hSsLe/mJMoLztaM0sJCIiInIQCgPSqIZ1TgUiGwYA3MNehjYXUJ71Hiy4PqJli4iIiDQXCgPSqKrCwA9b8vEHIrcYmdsZj7FzOt4glK5XVyERERGR2igMSKPq1TqBBJeNEo+flbuKIlau1R6Ds2NoIHGhH0o/7hGxskVERESaC4UBaVRWi8HQeuoqFJ/5cvj7kqIsTF9JRMsXEREROd4pDEijq+oqNH9TZMOA3d2C1qldsRoQMKF8/k0RLV9ERETkeKcwII3u5K77WwZKPf6Ilm1cuJpYa+j7ss3v4K3IJydnBQUFWzHNyKxtICIiInK8UhiQRtcjLZ4OqTF4/EG+XbcnsoVb7Li7XguAt/Uv2Zu3mUDAS1nZXkpKsgEIBLzk5KwgJ2cFFRWRW+9AREREpKlTGJBGZxgGo/qmA/Dpsl3MXJPDc19voLgiMjMAWYdPJP7SLdDvoRrbvd5iAPLzswgEvAQCXvLzNxMIaOYhERERiQ62xq6ACMDFA9vwr9mb+WJVNl+sCj2xX7B5H2//ZihWi1Hn8uMTO+CKaYVpBgCDvXvX4vdXEAz68XpDA4stFivBYICSkmwSE9vV+ZwiIiIiTZ1aBqRJ6JmewOk9WtbYNn/zPuZt2huxc9jtbhyOOOx2NwCBgA+frwwAq9VOUlInADyewhr7RERERJorhQFpMv54Xi9O696S168ZzCUD2wCwKCsv4ucxDAtWqwMgPEbAanXgcMQB4Pd7yM1dyZ49a8KtBiIiIiLNkcKANBnd0uJ5c/wQzuyVxtDOKQAsrIcwAIRbBzyeqjDgxGKxhrebZmg15NLS3Ho5v4iIiEhToDAgTdKQTqHpRhdl5XHfR8v5fkNkZxmy22OAUCsAEG4pcDoTahxXUVFAMBiI6LlFREREmgqFAWmSOqbG0Kt16Mb83UXbufr1RUycm0WFLzI35m53So3XNpsTgPj4DJKTO9GyZS9sNiemaaqrkIiIiDRbCgPSJBmGwUtXDqRFnDO87S+frubxz9dGpHybzRUeIwChbkKh81pwu1Ow22PC+xUGREREpLlSGJAmq3PLOObccwbf3DmCBFdoFtwPf9wesfUHkpM7ExOTitudUiMYVHE44gGFAREREWm+FAakSXPZrXRuGceyP51Dl5axlHoDTF++OyJlh6YT7UhycicM48C1DKoCgs9XqoXIREREpFlSGJDjgmEYXFw53ei36xpmhh+bzYnDEYdpmpSVRW69AxEREZGmQmFAjhundgstSjZv4z78gWCDnDM2NnTO4uJd7Nq1mPLy+pnqVERERKQxKAzIcaNvm0SSYuwUe/ws2V7QIOd0uZLDaw8AFBRsUZchERERaTYUBuS4YbUYnNGjFQCfLN3ZIOc0DIOkpE44HLEAmKZJefm+Bjm3iIiISH1TGJDjyq8HtQVg2tJd7C3xNMg57XY3LVr0JDGxHQAeT1GDnFdERESkvikMyHEls3MqHVNjKKrw86sX57J6V8PdmFetTuz1lmCaDTNmQURERKQ+KQzIccViMXj92pPo1CKWnQXlXDdpER5/ZFYlPhybzYXV6qjsKpTfIOcUERERqU8KA3Lc6dIyjqm/P5m0BCc5RR4e+HglFb6GCQRVswsVFW3H4ylukHOKiIiI1BeFATkuJcbYuWpoBwA+XLyD+z9e0SDnjYlpicViIxgMkJ+/CdM0G+S8IiIiIvVBYUCOW+OGd2RIpxQApi7Zyfa8sno/p8VipUWLngAEgwH8/op6P6eIiIhIfVEYkONWotvOBzdlcmq3FgRNeHvh1gY5r83mxOmMB8DnKWiQc4qIiIjUB4UBOe6NPqk9AF+tymmwbjt2eyyseBjvfzNgwfUNck4RERGRSFMYkOPeiB4tcVgtZO0tZdOekgY5p8PmgJ3T8ASBzW9AUKsSi4iIyPFHYUCOe3FOG8O7pgLw1eqcBjmn052Kpe2vCJjgaTcWLPYGOa+IiIhIJCkMSLNwdu80INRVqCEYhgXXkOegzQWUb56irkLNiNdbSn5+FoGAWntERKT5UxiQZuHsXqEwsHR7AblFDTPDT4wrAXZOpywAgU3qKtRc7N27lvLyPEpKshu7KiIiIvVOYUCahVYJLga2TwLgywbqKuRwJWOLDQ1ezvGAZ55aB453weD+xetMM9iINREREWkYCgPSbIzqkw7AFyt3N8wJgz7ivNvCL0s3vqXWgeOc17t/VWmr1dGINREREWkYCgPSbJzbtzUACzbnkV/qrf8TWuzEdBtPi8p7Rk8QggturP/zSr2puYicVpcWEZHmT2FAmo32qTH0bp1AIGgyo4G6CjHsdRyjS7FbQreOFZsmQdCHz1dGQcFWAoEGCCUSMdXXqVA3IRERiQYKA9KsnNs31FXofw3VVQjAFoOr02gAKjIuIYhBXt5Gysr2kp+/ucEWQpO6qx4A9PcmIiLRoF7CwM6dO7nqqqtITU3F7XbTr18/fvzxx/B+0zR56KGHaN26NW63m7POOosNGzbUKCMvL4+xY8eSkJBAUlIS119/PSUlNReUWr58Oaeeeioul4t27drxxBNP1MfHkePIuf1CYWDOhr1kFzbMrEIAruFvQJsL8Gz9iKJvx4SnpfR6S6moKGiwekhdmQf5XkREpHmKeBjIz8/n5JNPxm638/nnn7N69WqeeuopkpOTw8c88cQTPP/887zyyissXLiQ2NhYRo4cSUXF/pu3sWPHsmrVKmbMmMH06dP57rvvuPHG/f2xi4qKOOecc+jQoQOLFy/mH//4B3/+85959dVXI/2R5DjStVU8J3VMxh80uer1hazcWdgg57VbbTh2T8cEyrb8B5b/CYvFBoDH0zB1kLqr2TKgbkIiItL8GWaE28Lvvfde5s6dy/fff1/rftM0ycjI4M477+QPf/gDAIWFhaSlpTFp0iRGjx7NmjVr6N27Nz/88AODBw8G4IsvvuC8885jx44dZGRk8PLLL/PHP/6R7OxsHA5H+NxTp05l7dq1R1TXoqIiEhMTKSwsJCEhIQKfXpqCr1fn8Js397dE3XduT24a0aXez+ufczV71r8dfp6c3HUM+V3vxGq1k5bWv97PL3VXULCVsrK9ALjdKSQnd2rkGomIiBy9o7nHjXjLwLRp0xg8eDCXXXYZrVq1YuDAgbz22mvh/VlZWWRnZ3PWWWeFtyUmJjJ06FDmz58PwPz580lKSgoHAYCzzjoLi8XCwoULw8ecdtpp4SAAMHLkSNatW0d+fn6tdfN4PBQVFdX4kubnzF6tePryAZxTuSrxY5+v5bv1e8gpqmDcG4v4w4fL2Lyn5DClHD3bKW+R2PlyAJwWcG1/F8MMEAj48PnKI34+qQ/qJiQiItEl4mFg8+bNvPzyy3Tr1o0vv/yS3/3ud9xyyy1MnjwZgOzs0KqeaWlpNd6XlpYW3pednU2rVq1q7LfZbKSkpNQ4prYyqp/j5x577DESExPDX+3atavjp5WmyDAMLjmxLa+OG8zok0J/x+PeWMTQv83ku/V7+M/iHfziqdn8a/amiJ875vT3adFtLMl2MLqMx+lOBaC8PC/i55LIUzchERGJNhEPA8FgkBNPPJG//e1vDBw4kBtvvJEbbriBV155JdKnOmr33XcfhYWF4a/t27c3dpWknt1+dveD7pu2bFe9nNNx6ttYxnhh2Ou43SkAlJXtUevAcaDm1KJqGRARkeYv4mGgdevW9O7du8a2Xr16sW1baKXW9PTQbC85OTXngc/JyQnvS09PJzc3t8Z+v99PXl5ejWNqK6P6OX7O6XSSkJBQ40uat7QEF3ec3Z3OLWN56rIBfH/3GSy8/0wAVu8uorC8nlYMttgBcLkSsVodBIMB9u5dQ2npnvo5n0REzdYAhQEREWn+Ih4GTj75ZNatW1dj2/r16+nQoQMAnTp1Ij09nZkzZ4b3FxUVsXDhQjIzMwHIzMykoKCAxYsXh4/55ptvCAaDDB06NHzMd999h8+3/2ZuxowZ9OjRo8bMRSK3nNmNb+48nUsHtaVdSgxpCS46t4jFNOGHrPrtvmMYFlq06InLlYRpmhQWblMgaNK06JiIiESXiIeB22+/nQULFvC3v/2NjRs38s477/Dqq69y8803A6H+3LfddhuPPvoo06ZNY8WKFYwbN46MjAwuuugiINSSMGrUKG644QYWLVrE3LlzmTBhAqNHjyYjIwOAK6+8EofDwfXXX8+qVat4//33ee6557jjjjsi/ZGkGcrsEurL//nK2seXRJLVaiclpQuxsaFxMB6PBq43VVp0TEREok3Ew8BJJ53Exx9/zLvvvkvfvn155JFHePbZZxk7dmz4mLvvvpv/+7//48Ybb+Skk06ipKSEL774ApfLFT5mypQp9OzZkzPPPJPzzjuPU045pcYaAomJiXz11VdkZWUxaNAg7rzzTh566KEaaxGIHMylg9oCMH35LvJKvQSCJv9ZvIPv1u+pt5tAlysRAL+/4RZDk6NT8+9eYUBERJq/iK8zcDzROgPRyzRNLnhhDqt2FZHZOZVerRN4Y24WAH84pzsTftEt4ucMBLzk5KzAMAzS0wdiGEbEzyF1k5u7KhzWbDYnrVr1beQaiYiIHL1GXWdA5HhgGAaPX9KfOKeN+Zv3hYMAwDsLt9VL64DV6sAwLJhBHz6tStxEaTYhERGJLgoDErX6tU3k39cMxmmzYBihgcYuu4VdhRWsyymul3PaVj0CXw5j7zvJeL+/CoL1NJuRHBN1ExIRkWhja+wKiDSmYZ1T+er20/D6g3RLi2flzkK+WZvLFyuz6Zke4a5jQR/2nR9Tdfu/d8MUErOmENt9PAx7PbLnkmOiRcdERCTaqGVAol6H1Fi6pcUDcOGA1gC8OX8rFb5AZE9ksRPf7VoSbWCpHC5Q6IfyDW+ohaDJUDchERGJLgoDItWc3y+DlvFO8kq9DHx4Bre9t4RAMHI3hdbhE4m9ykurHuNwW0Pbiv3Aot9G7Bxy7LTomIiIRBuFAZFqHDYLf72oL0kxdsp9AaYu3cXMNTmHf+PRsNixDJ9M0pXFGIDfBN9GtQ40BdVbA0zTVOuAiIg0ewoDIj9zTp90Ft5/Juf3C3UZmjRvS72cx7DH4ezwawCK/GAuvIlgMEBBwRYKCrbg85XXy3mldrXf+CsMiIhI86YwIFILp83Kvef2BGDB5n2RHz9QyT3sJQA8QchZO5Hc7CWUle2jrGwfBQVb6uWcUrvaBgyrZUBERJo7hQGRg2ib7CY11kHQhA05JfVyDrc7mbjKsQNBE4Lm/tDh85VRVLSTwsJtBIMBKioK8XuL1Z2o3hx4468ZhUREpLlTGBA5CMMw6Nk6NMvQmuyi+jmJxU589+v2v175N1q3HojTGTpvSUk2paV72LNnNXmzr2LP2wmUTXHAgutDxwd9CgcRUnXjbxhGtdWh1TIgIiLNm8KAyCFUrTWwZnc9hQHAGPovYipbB1Jyp2GYAWJiWgJgszkBCCy9H3ZOxyQ0viC46Q0Kv7mMvW86KH27WjioxjSDeCvy663ezc3+LkEGhmH52TYREZHmSWFA5BB6poee0K/aVX9hAIudxO7XkeYEV7fxYLHjdieTnj6AVq36EutOgp3TMQCrEepOlGtpS+mW/+ANhsJBYNMbBP3l+P0VmGaQ4uLd7Jn5a/a+k0Lxt1fUX92bkf0tAxbAqLFNRESkudIKxCKHcFLHFAAWZeXx7+83M3pIe+Kckf9nY2S+gXXov8BiD2+zWELnSUzugqv7VVi2vA3AXi8Ey3dATFso24EJ5Lb8FexZu//m1fTDto8BKN78AS6rDfupUyJe7+Yl1AoQ7iJk+lE3IRERae7UMiByCB1bxNInI9RV6NHP1vDbtxZHdBGyGqoFgZ9znvIW9iu92LtcS3LVYWU7iOlwCYxcgNn3wZpPsQ0btLkg/LJg4zuYc8fVT72biaouQYZhwVj+Z/hyGOZCLQYnIiLNm8KAyGFcemLb8PdzNu5l6pKdjVMRix0yJ+LqMo4kO8RZITH7I1JTuhITk0pKSldSU7uFD3ed9CypXUdjMcBnQsmmt2D+dYc4QXQLh6mgH3aEWlXMLW9pgLaIiDRrCgMih3F1ZgeevnwA4zI7APDh4u2NW6Hhk4npei0JdjC6jMfpTiUpqSMuVyJOZwKtWvUhLa0/KSldcJ72LomdQ2MGSvzg2zRJN7cHVdkyYHVitLsktKXDVYdssRERETneGWYUT5dRVFREYmIihYWFJCQkNHZ1pInbVVDOyX//hqp/MRedkMEzV5xQbRrKBhb0HfGNav7MX1O+9b84LNCi53gY9no9V+74U1FRQF7eJhyOWMDA6ykgOaU7bndyY1dNRETkqBzNPa5aBkSOUEaSm/P6tQ6/nrp0Fws25zVehY7iiXXCaW9iAN4glG14g6C3uP7qdZw6YGpRw4YGEIuISHOnMCByFJ66bABjh7YPv359TlYj1ubIWe0xuDtdDkCBD3LeTsA/79rGrVQTU31q0f3rDGhqURERad4UBkSOgstu5a8X9+PrO04DYPb6XArLjo8++Akn/5tYK1iM0PNu76bJGj9Qw/6pRRUGREQkWigMiByDrq3i6ZEWjy9g8vWanMauzhGxOOJJTO6Gu/Jfvb/dFRocW02NqUUVBkREJEpo0TGRY3Ruv3TW5RTz3g/buOTENo03kPho/HI9tsItUJJDIKZlY9emSdl/42+E/y4VBkREpLlTy4DIMRozpD0Om4UftuQze/2exq7OEbM6k8Gw4dcg4p9Ry4CIiEQfhQGRY5SW4OKqoaG1B+74YBk7C8obuUZHxmZzwYqH8X12AqYGEYftH0CsMQMiIhI9FAZE6uCukT3o1yaRvFIvv31rMe8u2sbKnYWNXa1DshoGll3TANi3frJWJa6kMQMiIhKNFAZE6sDtsPL8mIG47BZW7Czkvo9WMPrVBewp9uAPNM0bScPqIKnLlUBo3YGiDZMIVjTieglNRM0xAwoDIiISHRQGROqoU4tY3rjmJE7rHhqQW+Lxc9Jfv6bvn7/k02W7Grl2tXOdNoWYjr8GoMQPe99NxT+1KwFf2TGVFwj4CASO92lKNbWoiIhEH4UBkQgY3rUFb44fwn9+mxneVuELctd/lrG3xNOINTu42JNfp2r+I78JuXmbyH0rlpJvRxP0VxxxOcFggD17VrNnz6rjOhDU3k1IKxCLiEjzpjAgEkGDO6bwylWD6NwiFggFgi9XZTdyrWpndyaQ3us6WjkIhwITKNr8Pvlvu2HB9UdUTkVFAcGgn2AwQFHRjnqrb31TNyEREYlGCgMiETaqbzrf/OF0fnd6F4AmPaDYyHwD2+hSku0QYwVX5f8IniD4Nr5x0BWKfb4ysrOXUVi4ndLS3PD2iop8gsFAQ1S9HmgAsYiIRB+FAZF60r9NIgBLthXw1vwtzNu0t5FrdBC2GFzdxpNkh5SUrritoc2FfjAX3FDrWwoKthAM+iktzcXnK8MwLFgsVkzTxONpuuHnUDS1qIiIRCOFAZF60r9dEgBrs4t58JNVXD/pR9ZmF/H5it14/E3s6fmw12G0F365gfgr9mEQmmlo99rJlM8eXePQsrJ9+Hz711SwWGykpnYjpnJF47KyUOjxeIooLt6F11vaYB+jLqqPGajqOKUwICIizZ2tsSsg0lxlJLpIS3CSUxQaQFzuCzDq2e8BOLVbC4Z0TCHGaWPs0Pa47NbGrGqIxQ6AzRFPgg2K/KGOMwWb3sdhc2A9+U3KyvZRWLgNgISENlitTpzOeCwWGxaLndLSHDyeYkpKcsLjByoqCmnZsldjfaojpjEDIiISjRQGROqJYRi8ctUgPl+Zjdcf5IMft1PmDbUIfL9hL99vCD1B/2lbPi9deWJjVrUmi53Y7uOJ3fwGe72hFoLyTW9h6fcoBSV7AHA644mNTcMwjPDbbDYnsbFplJRk1xhIHAg0zdmUDqSpRUVEJPooDIjUo4HtkxnYPhmAm0Z05qtVOaTGObjrw+WU+0LB4MuV2RRX+Ih32RuzqjUNex2GvELM9+PwbnqPIj/wnw7Q5gLiMl8mPr5NjSBQJT4+A4+nCF+19QqCwQCmGQzfYDdVtU4tGvQ2ZpVERETqXdP+7SzSjLROdHPN8I5c0D+DGXecxv9uOZWOqTH4gybzN+1r7OodyGLHdfJErNXv+XdOJ37lA7UGAQg9VU9N7UZcXDpxcenh446H9QcO6Ca04mH4chjm/PGNWi8REZH6pDAg0gjaJsfQOyOBEZWrFs9YndPINaqdxeaiVc/riK9sQ0ywgbFl8kGnHIXQgOKEhDaVYwocAAQPcXzTUa1lwAzAzmmhrZsnHvLzioiIHM8UBkQa0QUDMgD4eMlOtu0rO8zRjcPIfIP4q7y07nkNcTag8/jwYOPDsVQedzy1DBiGgWF1YLT9VWh7p2uO+POKiIgcbxQGRBrRSR1TOLVbC/xBk2e/Xt/Y1Tk4ix1j+KTQ9KPDXj/it1mtoZvo46FloObUomAZ8DCMXEDwpJcbs1oiIiL1SmFApJHdPbInAB8v3cn6nGIqfAGCQbORa3UQR/mEvKploDBvA8Ggvz5qFDHVxwxAZSgwbJhmE1sTQkREJII0m5BII+vXNpFRfdL5YlU2f/l0FWt2F+OwWnh29AkM65yKaZoHHbDb1FmtDvjuYijbTl5se1J/vR7D6mzsah3E/qlFQ3+G1n7Q9KIiItKcqWVApAm47uSOAMzduI+8Ui/ZRRXc99EK7v3vcgY9+jXLdxQ0av2OVYzDTYxnOwDe0m0UvO2C+dc1cq1qd0A3IUsoDASDahkQEZHmS2FApAkY0imFIR1TamzL2lvKez9sJ6/Uy41vLqagzMu2fWU1uhDtLfFQ7m26N6sWRwJJSV1JdYQ635QHoHD9pCYXCGo+/a/WTQjUTUhERJo1hQGRJsAwDCaPH8JLV57Ih7/N5Px+rWvszy6q4ISHZ3DaP2Zx54fLANiYW8ypf5/F+Ek/HFDe7sJy/IEm0r3lVxtwdhlHUuVwg9IABDdPalLTdVa1CsD+EFDVTUgtAyIi0pxpzIBIE+F2WDm/fygExDlt7C4sZ2D7ZM7tm864NxZRVtkC8PGSnZzVK40vVmVT7gswf/M+tu4rZen2AhZvzWdPsYfPV2bTJyOB1685ifREV2N+rJDMybiH/pvimZfh3/4JnnZjcDeh6TqrtwxUjRmo6iakMQMiItKcGWb1R2JRpqioiMTERAoLC0lISGjs6ogcVF6pl425JfxvxW4mzdtCnNNGmddPVY+hEd1bMnv9ngPed0K7JD78bSZ2a9NoBCwq2kHJ/N/h2j2dlB7XQubExq4SAH6/h9zclRiGhdatBwKVdS3JIS4ujYSEto1cQxERkSN3NPe4TeMOQUQOKSXWwZBOKdw9qgct4pyUePYHAeCAIHDLL7qS4LKxdHsBby/Y2sC1PTiXIw52TqciCKUbJjWZsQNVT/+rWgNA3YRERCQ6KAyIHEdiHDYe+VWf8Osnft2fM3u2AuDUbi244+zu3DWyB7dX/gnwxtwsAk1k3QKHK4n4zpcDUB4EsiY1ibED+1cf3v9foroJiYhINNCYAZHjzLn9WvPYJf3I2lvKJQPb8OsT27Iup5juafFYLfvXI/j1oHY8NWM92/PKeXvBVq4Z3rHxKl2N+5Q3KfaU4ds5HbPTdRhNYOxAbWFAswmJiEg0UMuAyHFozJD23H9eL2xWCxaLQa/WCTWCAIQGJN9+VncAHvt8DbnFFY1R1QPYbE6sFhsm4PF5Grs6wMHCQGU3IX/TuG4iIiL1QWFApBm7elgHBrRLosIX5I05Wxq7OiFBH65dUwEo3vwO5rxrG7U6cIiWgRUPY/6vHyy4vrGqJiIiUq8UBkSaMYvF4HcjOgPwyuxNTFnYBAYTW+zEdx2HxQBfEDybJjf6uIFaxwxgws5poYHam99o9DqKiIjUB4UBkWbunN7pXHRCBgBPfLGOCl/j94G3nDyZmI6XAaFFyFj020atT21hwGqPgTa/DIWBzuOhCYxtEBERiTSFAZFmzmIxeOryE2iT5Kaw3McXK7Mbu0oAxJz8BgCeIAQ2Ne6T99pnE7JDv4cwRy4gcNIrjVU1ERGReqUwIBIFrBaDywe3A+DdRdsauTYhNkcc9vaXAOBtN6ZRn7zXPmbAwGq1g2EjEPA2VtVERETqlcKASJS4bHBbLAYszMpj856Sxq4OAM4hz0ObC/Bkvduog3Srh4GiCh/Tl+/CFwhitToAFAZERKTZUhgQiRIZSW5O7xFaoOyGN3/kin/N5+mv1jVqnZx2d3hFYvNnXYVM08RbkY/fW1zv9ageBn75whwmvLOEj3/aGQ4DQX9ZvddBRESkMSgMiESR+8/rRbzLxqY9pSzMyuP5bzby9eqcRquPw5WMtd1FBM3KFYmrDSQu+nY0e99JIfftBPxzr6nXelSFgb0lAbbsC934f79xbygMrHiYwEdtNb2oiIg0SwoDIlGka6s43r1hGPeM6smvKmcYuue/y9mR3zhPvg3DIHbo8wCUBQhP4RnwlVKx5YPwcZ5Nb9brAOOqMDBzfWF4W6t4J1bDgJ3T8Gt6URERaaYUBkSiTN82ifzu9C48fkl/+mQksK/Uyw1vLqbM62+U+rhj06HNL/EGwddhHB5PETnfXEnA3H+Mt+1l9TrAuCoM5JXuvwbFFT5sjgRo80t8ml5URESaKYUBkSjldlh5ddxgWsQ5WLO7iGe/3tAo9bBa7ThtoZvsPdu/Yd+7LWDntP0HZJyPr/d99VoH0wytvVDuC4a3FZX7sdtjoN9DBM6ao+lFRUSkWVIYEIlibZLcPPHr/gBMmruF7XmN0F0o6CNu938xAMp21NgVawV2fYb/fycSmHct5aU54af4kVRVZpm3Whio8GGxWLGt/ivMOAXfvPERP6+IiEhjUxgQiXJn9GjF8C6peANBnvxqHaZpYprm4d8YKRY7zi7XkuKoti3jfBI7X0GCDaxGaFPO2snkv59OyXdjw4eZAW9E+vGHw0C1loHiCj8EfTh2fgyAP+ttjRkQEZFmR2FAJMoZhsH95/XCMOCTpbvodN//ePSzNQ1bicyJOLtcS0sHENMWdn1GjDMGY4wXW/tLaxxatvk9zICHvG8uY/dkJ2VTHHWe6edgLQNY7Fg7jAbA3+5yjRkQEZFmR2FAROjbJpHfjugSfv36nKyGX5gscyL20aUk+XaQYgcjayIA9pOehbPnhA8LmJA383IqtvwHgFI/dZ7pp9YwUB4qzzrkRRi5gED/R4+5fBERkaZKYUBEALjrnB48elHf8Ot/z8mi1OPnldmb+GJldnj7jvwyPl+xm49+2sGeYk9kK2GLIabbeFxWwrP3WK0OWP0EAJU9hvDsmBZqQQB8JpQ6OtbpqX0wGJpFqMwbCG8rrvBjmmbo/IZNqxCLiEizZGvsCohI02CxGFw1rANdWsYx5rUFvLNwG1+tymFviQeLAR/9/mQ6psZwwQtzKCgLPTU/sX0S//3dcAzDOEzpR2HY6zDklfDNvd3qCM8u1MoJhT6oCIJRtgObBXxBKCzagmPO1dhPeeuoT2eawfAYieotA/6gSbkvgKNyFWKFARERaY7UMiAiNQzrnELnlrEA7C0JPfkPmvDwp6t47fvNFJT5aBHnxGGz8NO2At5ZtI3FW/MiW4lqT/kdriRSuo2lpQOsXcaT3O1qEmyQZIdk2/7WgvLNxzbAt6pVwDCMGi0DEJpe1FoZBsygl0BAA4hFRKR5URgQkRoMw+CB83vRv20ivxyQwf9uORWbxeCnbQW8NGsTAH+9uC9XD+sAwB8/XsmlL8/nk6U7661OrlPfxn6lF4a9jnHym8R1uxa3FWxdx5PUdQwAFQFg0W+PuuxgMBQADMNK6c8WXiuq8GEYBtZVj8KXwwjMr9tAZRERkaZG3YRE5AC/6JnGL3qmhV+f3TuNzyvHDfRrk8g5vdM4uWsL5m7cy9rsYgDu/e8KkmIcjOjesn4qVX1MQOZEGPpqaFpSfwVsfBe/CcFNb2Cp1sXoSFS1DFgsNko9oe8dVgveQJDiCh8Efdh2TiUA+Da/hWP465pVSEREmg21DIjIYd09qid9MhKIc9p44PxeGIZBnNPGh7/NZPL4IZzWvSXlvgC3vrckfENd7ypvyC02F9Z2FwHg73D1Ud+oV60+HDAt+AKhsQMt451A5YBiix1Hx9D0ot42lyoIiIhIs6IwICKH1alFLJ/dcior/zKSoZ1Tw9vjXXZGdG/J69cMpmNqDAVlPibP39Lg9bOd+ASMXID/xKeP+r1VLQMV/v3/HabGhcYJlFeOIXBk/gvaXIBv23/rvKbB0VXOh+krqaxnILTImoiISAQpDIhIndmtFn53emidgie/XMd36/c06PltNhcYNvze4qN+b9WYgXJ/aCiy02Yh1hHqQVnuC+0LzWg0PdwVqSFWIi77bix733Sw+614Cj7sSO6Mi9n7ppPgvGvq/dwiIhI9FAZEJCIuG9SOS05sQ9CEZ75e36DnttvdsOJhfFM7H/WT+/0tA6EwEOu04XZYAfD4QlON1rUr0tEqK9lNwcZ3qJrptKx4K8Gdn+IzoWjDmzD/uno9v4iIRI96DwOPP/44hmFw2223hbdVVFRw8803k5qaSlxcHJdeeik5OTk13rdt2zbOP/98YmJiaNWqFXfddRd+f82+yN9++y0nnngiTqeTrl27MmnSpPr+OCJyEBaLwb3n9sRhtbBkWwE/bInwdKOHYLNYYec0/CZHvRpx1ZiBCl8oDMQ4rLjtoTBQ1TIAYB/0Dxi5AN/ApyJX8VoEgwGK5t4UqosVYq0193uCQNakBmmdEBGR5q9ew8APP/zAv/71L/r3719j++23386nn37Khx9+yOzZs9m1axeXXHJJeH8gEOD888/H6/Uyb948Jk+ezKRJk3jooYfCx2RlZXH++edzxhlnsHTpUm677TZ+85vf8OWXX9bnRxKRQ2gV7+LSQW0AuP+jFXj8gcO849iZpsmKHYV4/UHszkSMtr8kYIK/4zXHNJtQeeWzhliHDVctYaAuXZGORul3VxLc+Sl2I7SWQmK3q0h1QIodjJh2oc/YYZwGMouISETUWxgoKSlh7NixvPbaayQnJ4e3FxYW8vrrr/P000/zi1/8gkGDBjFx4kTmzZvHggULAPjqq69YvXo1b7/9NieccALnnnsujzzyCC+99BJeb2gA3SuvvEKnTp146qmn6NWrFxMmTODXv/41zzzzTH19JBE5AneP7EmLOAcbckt46ZuN9Xae52Zu4MIX5/Dqd5swDAv2E/8eenI/4O9HVU7VQmLlVS0DTituR+i/xnLvz8LAiofxf9IlIoOIg0E/AV9Z6Al/5VN+v7eYks0fABBnAzpdC8PfwnmlF9dYL46zZ8LIBZT2fbTO5xeRQ1DLm0SRegsDN998M+effz5nnXVWje2LFy/G5/PV2N6zZ0/at2/P/PnzAZg/fz79+vUjLW3/POcjR46kqKiIVatWhY/5edkjR44Ml1Ebj8dDUVFRjS8RiazkWAcP/6ovAP/8dhOrd0X+31lhmY9nv94AEP7Tbo+FlX/D+5/0o7pZD1b+0q+o1jJQ1U2oolrLRl26Ih14Tj+5X19Kzlux7H3Tgf8dByy4nuLi3ZiAywJuK6G1FCDUCmCxExPTAgwbpaW5eDz120IhEo08nmJyZ1xCxRRHw84cJtKI6iUMvPfee/z000889thjB+zLzs7G4XCQlJRUY3taWhrZ2dnhY6oHgar9VfsOdUxRURHl5eW11uuxxx4jMTEx/NWuXbtj+nwicmjn9WvNqD7p+IMmd/93Gf5AMKLlz1qXG/7eZbcSDJo47S7YOS3Up/4obtYDldN1locHEO8fM1BRrWXAYouBNr8kaAKdx9epm07x7CsJ7pgGgDcIhX4IbHqDih/vACDeVvs53O7kUCAAyssbbkyGSLQozN+Ef/vH5PnAbKCZw0QaW8TDwPbt27n11luZMmUKLpcr0sXXyX333UdhYWH4a/v27Y1dJZFm6+GL+pDotrNyZxFvzM2KaNlVqx4DlHj8bMsrw+FKgTa/xG9C4AjHDQSDfkwztNBYuS/0Z6zDhrOWMQMWiw36PYQ5cgHm0NeOue5mwEv5lg8BSKxcA94ThBxLW8ydn+GwgN0CDHml1ve73SkAVFTkh+suInUXCPjwL3sw/NoTDA3or5p+WKS5ingYWLx4Mbm5uZx44onYbDZsNhuzZ8/m+eefx2azkZaWhtfrpaCgoMb7cnJySE9PByA9Pf2A2YWqXh/umISEBNxud611czqdJCQk1PgSkfrRKt7F/ef1BODV77IiOph4fU7NLjIrdxVisVhxWEN31xX+I1ucq6pVwGKxUeoJ1S/GWX02of0tGhaLFcMwwLDV6ebAF/ARzLgAiwExXa/B2f7i0I7yHVgNSKoaK3CQMONwxGG12gkGA3g8hcdcDxGpyecpgJ3Tw6+9bS9jb95GcnKWUVqae/A3ihznIh4GzjzzTFasWMHSpUvDX4MHD2bs2LHh7+12OzNnzgy/Z926dWzbto3MzEwAMjMzWbFiBbm5+//xzZgxg4SEBHr37h0+pnoZVcdUlSEije+SE9uSnuBib4mHaUt3HfZ4jz9AUcX+Znmvv/buResqWwY6t4gFYH1OCQR9uHZ9BEDxpncJeApqDM6tTdXgYavVQZk3NGgg1rF/nYHqA4ihsnWA/TMQHQvP/N/Azuk42l+CMew1ErM/xmEBmwGpdrB1HgeZEw/6fsMwcLlCkzKUl+cfcz3U/UGkJn8wCG1+GXrR5gJKut+J31eKaZoUFe3A7/c0bgVF6knEw0B8fDx9+/at8RUbG0tqaip9+/YlMTGR66+/njvuuINZs2axePFirrvuOjIzMxk2bBgA55xzDr179+bqq69m2bJlfPnllzzwwAPcfPPNOJ1OAH7729+yefNm7r77btauXcs///lPPvjgA26//fZIfyQROUZ2q4VrhncE4PU5WYfs1hIMmlz80jwy/zaT7zfs4dXvNtH9gc85++nZFJTtf9JfVOFjZ0FoXNB5/VoDsDG3ODTAttu1WAwImpAzJZl9bzrwHGIgYFXLgNVqp7Tyxj+m2gDin7dm1DkMBH1UbH4PAOfOUHCxdR1PCwe0coKty7UwfPJhi9nfVagA0zzC8RiVN/+mGSR/1hh++Hdf/PN+c/SfQaSZ8vsroN9DuH65GrDAl8NCXysexjRNCgq21Pw/TIFamolGWYH4mWee4YILLuDSSy/ltNNOIz09nY8++ii832q1Mn36dKxWK5mZmVx11VWMGzeOhx9+OHxMp06d+Oyzz5gxYwYDBgzgqaee4t///jcjR45sjI8kIgdx5ZD2uO1W1mYXM2/TvoMet2hLHqt3F1HqDfDbtxbz3g+hMT0bckv4dt0evP4g05fv4vdv/wRAx9QYBnUIPSHfmFsCgGXoqyTbK/vcE+rzW+CH4EEGAvr9oVBhtTop81S2DDit+9cZiHDLgNfvweduhwG4E7uGugINex1Ge0Nfh2gRqM7hiMVmc2KaQSoqCg55bDAYoPjbK/BUzlhUVLiD2+Z25rLNT/OvhYW6oRGp5K3IB9OP252CY/e08Pak3GlYCOL1lpCfvwmPp4iCb36N9x3NOCTNg60hTvLtt9/WeO1yuXjppZd46aWXDvqeDh068L///e+Q5Z5++uksWbIkElUUkXqSGGPnssFteXP+Vl6fk8XJXVvUetx/F+8If1/qDbB5T2n49aIteWzMLeHFWfvXLfj1oLZ0bRUHQNbeUvyBIDarHWfX8bTc/AblAcj3QcCEMlcn4n7WB980zXA3G5crkVJvaAxSrLNaNyFf5MJA0F9BafFOKNuO2wqW0o2hG/HKaUOPlsuVTElJNuXl+eGWgtrsm/lrfNunYgCpG9/g0w3xzC45G4C380Zx47zx2E9566jPL9KclMy+Ev+mdwGw9RhHi57j8W98A8MAa5fxGMldyc/fTEVFIRU/3A47pxOwQOrmN0KD/bUIoBzHGqVlQESiy3Und8Iw4Ju1uUxffuDYgWDQ5Ju1oTFCY4YcOOXvj1vyakwnGuOw8utB7WiT5MZlt+ALmGzLKwvtrHzS7h5TSkLl4w5vcdYBT8B9vlKCQX9o4LEjntLKloEYhxWXrXLRsaMMA7V12QkEvOyZcTHZb7opnxFaGyXWSp2nJ63eVehgaw4EfGX4tk8N1Q3Y64VZW53h/bt96axc/Q3Mv+6Y6yFyvDMDXko2h4JArBXsW9+EIa9gu9KLdYwXhr2O251MSkpXDDMQHmTsCYKv3ZWNWXWRiFAYEJF616lFLONP7gTAXR8uZ9Wu0Cw4pmnyydKdvDx7E/tKvcQ6rPzpwj50SI0BoHfr0Ixf63NKWFW5eNmM209j5p0jSE90YbEYdGkZah2o6ioEhG6ybTHYO18NgK/NRQfcePt8oS5CDkcchmGExwxUH0BccbBuQv4D1zIJBLzk5KwgN3clPl9ZeHvRt1eGb8gp24HzMFOHHim73Y3dHpo5bd++9RQXHxiyAub+AZEG4A3amF86GIAka+h6vpN3Ab5Nk9RdSKKWx1dO0N0Oq0HoAUJVUP9Zq53LlUhyanfiOl+BJbQsCXs2vHPIcUkixwOFARFpEPef14tTurag3Bfgly/O5Y05Wbw5fyu3vreUf3y5DoDMLqm47FbuHdUTq8XgqmEdSE/Yv15J5xaxdEuLp3Xi/umDq7oKbdxTws/Zh0+EkQsI9L73gKf5fn8FADZbqPyqMQPVpxat+NlsRhaLDVY8jGdqF4I/e5peXp5HMOjH7/dQWBga71BavIvyrf8FwGqEVhVOtnPIqUOPRnx8G2y20JP+4uLdB3zGQMAL/R7Cef5SUuyw3d+ZMjOGZIeHF8adAcC0wnPITbtS3Rwkavm9xVC2HYcFDINDBnWXK4mE094KtzpCaNHAuq5KLtKYFAZEpEFYLQbPXHECQzqlEAiaPDx9NX+atiq83zBC4wAAzu3XmrWPjOLKoe3pnh4fPmZo59QDyu1aW8tAJYvFim313+HLYXjmjANCffdNXwneitAKvuEwUNkKEOe0HXQAscsRh3XXNPwm5K2bREXJ7vC+6gN5vd4SSktzKSzeDW1+idWAtNSuJNvB0vnaIx4ofDguVyKtWvUNfwZPtVWJAwEfhfmbAbA6E3F2G0+WtxsAAzq15ZTuaXRIceExXcxduxFz3rURqZPI8aaqBc1mcGTd9yx2YrqNJ90ZanHzm+CL6aJALccthQERaTAt4528f+Mw7ji7e7iZ/bJBbdn8t/NY8/AoRvVtHT7Wbg3999QjLS68bVjnAwfKVrUMbKolDBD04dr9MQD5G99lz/sdyH7Tze634vF9dgKs+HP4RrrUWzVmoOYA4upTCVqt9v3jEIKQ90EGnu+vIhgM4PWGBjxXlVfVOkC/h4i/bBf8csNRzRh0NFyuxFCLxX/Swv3/i74dQ/CLk2DFn7FanTDsdZanPwJA/zaJGIbBqZWDuReVnkDFpskaOyBRqWpKUeslu0Njjo7EsNexXFGKs/IuqqJoU8RaBkzTZNLcLH7Yknf4g0UiQGFARBqUYRjccmY3Zt91Bv/9XSb/uGwAFosRfhr/c+nVugQN7VRLy0Cr/S0DB6xjYLET3/Wa0BM/wFe6reb+ndOx/XAzQHgAcWy1bkIAFdVWIcZix9W15g1z4cYp+OdeA4QWL0tM3D8A2jAspKX1Jyaudfj99cFpd8POaZQHoGzjJIo+7BjunsTO6Vh+ugOAZTtC4wT6t00C4JTuaQAsLhtAWQDImqSuDhJVvN7S8AB8myPuMEf/jC0GV+fQAGJPxkUR+/f97bo9/PnT1Vz2yvyIlCdyOAoDItIo2qXEMKjDwafErHJK5dPr5Bg76YmuA/Z3SI3FMELTke4t8R6w3xg+ieSuV2IAFgNS7JBoA3tlH37L1jfxej34AqEgUbXoWFXLRbGn5s2xMfRfpNhD74VQF4HyzVPA9GO3u3E6E0hIaIvTGU9qajes1vrvOuB0pxLT8VJMoMAHJcVba+7f/h7b9hayIbcEq8UIr89Q9edWbzsK/U4CHa9RVweJKkVF28PfV7XqHQ3nyROhzQV4t009YBzRsdpUy/gnkfqkMCAiTVqP9Hg+nXAKX9x2Wq37HTYLGZWtB9vySms9xn7qFFr1GEcrB7i6XkvslaW07HltaDBv5/GU+ozwsbEOKxaLQZwz1B+ouOJn04ha7Li6jSfZDs649gCUBoCVj2K3h2ZBiotLIzW1O46jfdJYB4kj3iHWGurDXCXGCumVKxt/sXovAEM7pZAc6wBC3bZaxDkJYmGzpwMVvgPDlEhzFQwGwjN/JSS0Dc8WdjSshoFtV+VUoxsnqWVNjksKAyLS5PVrm0hawsGf2rVLqQoDZQc9xnryZCxjKvvs22JCf44OzSFeUB76BR7ntGGrHKsQ7wo9IT8gDMD+tQzOW7B/287p2Jf84Wg/2gG255XxwQ/bqfjZGgeHY1gdJPYIDWrMcEGrlC4k2kIDlktPfI035mwBQoOzq+vdOhRY1ns64dvyrm5mJGr4fKWYponV6iAuLu3YCrHYcXa8HAitO8Ci30augiINRGFARI57HVJiAdi278D5/2v4eReYytcFZaEn4kkx+/fHu0JPCYvKD3JzbLHjdqfiqvxf1GkB5/a630zf99EK7v7vcsZP+gF/4MBFzA5p2OsYY7ww2ovtoo2h7zMn8t4P28kuqqBdipvLKmdsqtI7IwmADZ7O+Ntcom5CEjXKykKtZU5nQp3KcQ59CQhNKhCJKUYDgf0tdMH5Wr9A6p/CgIgc99pXLlJ2qJaBQ6lqGageBhIO1TJQybA6SO5xHS0dkOoAo0vdVhUu8fiZszF0gzJv0z5O+fssvlqVfXSFVF8oqfLP7zfsAeCazI4HDNTukR5qGdgS9yv8ve895rqLHE98vnLKy/MBiI1tVaeybI44aPNLglDnlcUBAtUWNfRsmqLWOql3CgMictxrl1IVBmofM3A4hWWVYcDtCG+rahkorjj0L2Ij8w3sV3rDXY7qYm5lEKiSXVTBhHeXsLpy9eVj4QsEWZQVmqJweJcWB+yvWsF5254igl8MIaD1BiQKFBfvBMDtTg6v5H2sLBY79HuI4DkLMIe+VvfKGftvzSraX6fWOql3CgMictzrkFLHloHKbkKJ1VsG3IdvGQir/jS+Dj7+KXSDcu3wjrx7wzA6t4zF6w/y2vebj7nMH7LyKPMGSI6x07PaAm5VOrUIdbHa542hJBBD2cbJehIpzVYwGCA3dxUVFYVAaBXvurJYrBiGBQxbjS4+x8of2D9FcsWAp+tcnsjhKAyIyHGvfWUYyCnyHPXAW6jWTch94JiBw7UMRMr2vDK+XB3qEnTl0PZkdknl8Uv6A/DN2lx8Rzt+oNIHP4amThzVNx2LxThgf7zLTlqCE4Bt3raU+ME7V4uPSfNUXr4vtMgY4HDEYrM5I1Ku1RpqVQwE6v7/RYV//7/1cu8RPIwQqSOFARE57iXF2ImvnAp0+zG0DhSUHThmIDyA+EhaBiLgP4t3YJpwarcWdE8LPcEf1CGZlFgHheU+vl6dc9RlLt6az/9WhALGFSe1P+hxnVuEugrt8rfFBIo3TdFqxNLsBIMBSiu7BwHEx2dErGyr1Q6mn6D/2Fonq/P497cMKAxIQ1AYEJHjnmEYdRpEXFhe25iBUDAoaoCWAdM0+WRp6Cbl0hP3z/ZjtRhcPji0ovHd/13OrLW5R1zmws37uOrfC/EGgpzTO40BbRMPemzHyq5Ce+LOAcBnotWIpdkpnn0l/v+diGXlI6SnD6jzLELVWZY9AF8OI//9dILzrqlTWZ5qrZsen8KA1D+FARFpFtrXYdxAbWMG9ncTqv9fxl+tzmHLvjJiHFbO7l1zvvPbzupGn4wEiiv83PLeEjz+I+sG9crsTZT7ApzYPolnrjgBwziwi1CVtsmhAZS74kdCmwsImhDseK0GLkrzEfTh2fIBAIk5n2DBPMwbjq5sx44Pwy9LNrxZp5a16l0dyxUGpAEoDIhIs1AVBrbuO4YwUMuYgf1Tix750/Eyr5+pS3ayp9hzxO8JBE2e+modAONP7kSss+YqqC67lf/+bjiJbjvFFf4DZhyqjccfYMHm0AxCj17U74Ayf65NUigM7Cwox3rCX2HkAvyDXzzizyDS1AX95fgzfgmAs8u1kQ26Fjux3ceTWPnPrDQA5uZJx9yy5qk2ZqBCYUAagMKAiDQLPSpnylmwed9Rv3f/mIHaphY9sl/GxRU+zn76O257fymPfra61mNM02Tx1nzyS0MtEdmFFfzqpTmszykhwWXjhtM61/o+l93KRSeE+jd/+OOOw9bl+/V7KfcFaBnvpFfrA2cQ+rmqloEd+eXYbC4wbPgrKq+jugrJccznKyPn/Q7kvJ0I2TOxGWCx1MOtz7DXib3Ki7XtrzABT7sxxxw4NIBYGtqhHxeJiBwnftGzFVaLwdrsYrbsLQ33gz+cYNBkZ0FokZ/0BFd4e3JlMNhXcmRTBc5YnRMuZ86GvZimeUDXnEemr+GNuVkADO6QzI9b88P7fnt6FxLdB795uPykdry1YCufr8zm69U5nPWz7kRVcosruP/jFQCc36/1IbsHVWlTGQayCyswDQd8dzEFZdsptcUQa5QR0/VayJx42HJEmprSom0ESreFXgRKcVoJrRI85JWD3qwv3LyPZTsKuO7kTrzwzUbKvX5uP7s7MY7D3DJZ7LiHvUjJ/ADlWe/icriPae2RGt2EFAakAahlQESahaQYB5mdUwH44ihW7d1VWI7XH8RuNcI3xQAZlV1ncosrjmhaz9nr94S/31fqZVdhRfh1MGjyxBdrw0EAqBEE/nheL248tfZWgSp9MhK5ofKY37z5I9dNXEQgWLPfsz8Q5P/eWUJusYdureK4a2SPw9YboFW8C5vFwB80Ka6wYJSFpiP1+cso8EH++kmUfXvFEZUl0pR4A36I2T8o323lkKsEz9+0jyteXcDf/reWC1+Yw/MzN/Da91nc8OaPzFqby7Z9Zewr8XDPf5azYkfhAe93OeJg53QqAmBueuOYWta81WYTOpapkkWOlloGRKTZGNU3nTkb9/L5ymx+O6LLEb1ny97QGIP2KTFYq83D3yLOgdNmweMPkl1YEV7luDbBoMn3G2r25f9xSx7rXXYSY+w89/WGcFi49//Zu+/4LKv7/+Ov697ZExLC3nsKMhw4UNyi1oFURZyt1NVa6886vtpWW23rqNVqFXDgrCKioqgoshHZe4RNCCRkj3ud3x83ueEmAQJJCCTv5+ORh7nv61znOtdJMNfnPud8zoVdWJ9dxJwNOfRumcCVfVsc8lP+g913Xie+WbWLDbuLmb5mNzPW7ubsLk3Dx/81fT3zMnOJcdl55YZTjrhWoILdZpGRGMWW3BKySmMYlNyewoINlAQgaKA0AKUbP8AXDBBz5tuhqUQiJ7hAwIt/0cNQsg2XLfTpp9MiNCpwCAcG7KuzCsPfz1qfw6z1OSREOemcFsf8Tbl8umQ7q5+8MOJ8lycRe0wrAsVbKI9uh+cYpgqVRawZUDAgdU/BgIg0GOd3T+ORT5ezZGse2/aW0CLp0A/wFTJzioH9O/FWsCyL5olRbNxTzLa9pYcNBpbvyCe32Eus28E1/VvyxqxM7nlvcUQZj9PGn0f05KpTWlRdSTV4nHY+uGMw1782jzW7Cnl/wdZwMGCM4f0FoU/0n7i8B+2bxB5V3W1TY9iSW0LmnmIGj1hP/JybiM98kyxfFMFAaPpT8ab/UewrJ3bwy8TGpmOz6U+InLi8ZXmwfTJOG6RWLAc6zKhAcbmfGQeM8CXHuPjXyL7szC/j9/9bSiBoyC/1MX9TaHF+mS/I5pxiWqcc8P+OoA932RZKAF/hRjxB31GvHSj3KRiQ40vThESkwWga5wlPFXpp+oZqnbNpTygYaJNSeY1BxbShirUAVfEHgrzyQ+haQ9qncOsZbXHZI//XmhLj4uNfnVajQCBcV6ybF0b2BeDrlVnhTdbW7ipiZ34ZboeNi3s1O+p62zUJ3f/G3UWhNwZPgGuKSbaXEmWHGDvYLWD7FIoKt5OVtYTS0r34/WX4/dXPniRyvPgCXmh+CS6LUBBwnfewc/g//Gkr5f4g7VJjWPLY+cx96FyGdEjlqlNa8MXdZ1Q52vjp4h2Rb9icONuOBMCbccUxtfvATceqm0pYpCYUDIhIg3LPuR0BeHf+Fi58/ke+PsL6gYp5v+2bVv4kPZxyc2/VwcBbczZx5t+mh3f5Hdq5CRmJUfzxkq70apHAqIGteGB4Z96/YzDdMmpvg6PO6XGc0TGVoIHXZ2ZSXO7nDx8vBWBQuxQ8TvtR19lu30jCxn3BEQCOaFwdxpDkhISkDqS5wd36KrBCIwJ7924kO3sFu3evIBCo3kJrkePFu+Be2D4FZ5vrQkFAFZ/QvzZjI4Of+pbpq7N57cfQFKExp7clIcqJy7H/Ealzehz3n9cp/Dp+X7axifO2hLODVXANfh2aX0L5lk8oeccFc285qnaXl+zPiFbm1b8rqXsKBkSkQRnYLiX8Cd6qnQX8cdLyQ366tqeonJ82h4b8z+zUpNLximBgXXZhpWOz1u/hkU9XsCO/jBiXnQFtkri4Z+gT+RsHt2Hy2NP58xU9uevsDnSoItCoqTvODN3j+Nmb6P7YVyzakofLbuOW09seU33tUw8aGagw6PXQJ6qXrYPrvCSf8wFNmnTF5dp/T8YYvN5iqqTUpFIP/N5CvJv/B4Br63tV/h4aY/jr1NXszC/j5vEL2J5XSpzHwS8OMYLncth47to+/OKUFky7fyiJ0U6yCso485nprN21//8RTrsDz84pABT6j3IhcdCH17e/bPma/x51MCFytBQMiEiD84cLu/DlPWcAkF1Yzj++XosxlXcc/WLZToIGejSPDz/4H2hIh1QAvlyeReaeyIfd//0cyvd/ae8MFj5yHh/eOSRin4K6dlqHFLo1ixxteGlUvyqDmuqoCFi25IaypUSo+ETV5sSybDid0SQmtiEqKim8bsDvL+NgxTOuJ+8tF/5ZN4bf8/lKMYFamFYU9O1/wDrwexGgeNatAHhs4OhQ9TqBFTsK8B+UkeuSXhmHHVkb0bc5z17dm7R4D2/fMpA4j4PCMj8T523ZX8jmJKnzzdgsCBjwRrer/roBmxO/bf/6pICxhVKh6vdb6pCCARFpkLo2i+dvv+gFwH9mbGT0uAXcOmEBZ/ztO96dv4Ws/DL+MW0tAFf1q/qTwFNaJ3FW5yYEgobXftwYfr/UG+Cr5aGpQTcNbn1M03JqyrIsXhrVjzvObMeVfZvzx4u7cl41sxJVpWm8h57NEwgamLxkxxHLOxxukpLaERsbuqbfHzmVygTKKVj/LiUB2LP2LcysGykr2cPu764h5y3PUX/aGQh48ZXmEAwGKPphJIVvuyh5x0X5J+3JfdNF0dsuzOzRR1WnNDxlZfn4indSuukDAKLtHDJ70Hers4HQ/iIxLjtdm8Vz97kdqn2tHs0T+MsVPQGYn5kbccwa+B+i9j1hlRRsPKqH+cCBwQC2wy56FqkNSgUhIg3WNf1b4gsEeWTS8oh9AB76eFn4+67N4vnloNaHrONXQ9vz/ZrdTJy3hSVb87AsSIvzUOwN0CIpilNaJ9XpPRxO29QYHrqoa63Vd1W/5izbns9HC7dx82nVm27kcIRGVA4eGfD6vZjml8D2KQQN7FzzFqx5K3QM2LP6DRyd/oDDFY/Hk4jD4T7kNUpLc9n7aR8o2YotqgXB0gN2Yd4bCtLKglC2dgJJQT/209+u/k1Lg1FSkkPe5L6wb58MmwXu+A6HfJCuCAbuGdaRq/q1iFgjUF0D2yUDsCqrgOyCMppWbFxocxLd4UaK17xJWbPL8Pq9uFzVe6A/cLAi2HoUDDr9qNslcjQ0MiAiDdqoga354I7B3H5mO/q2SuTADXmbJXh49YZTcNoP/b/CU9sm07N5AhCaVrB8ewHf7nuIuLxPRrV2+D1ZXNanOU67xYodBazOKqjWORV7Dvj9ZRHrBsrK9kLPxyHj4irP8wahpDSXgoJtZGcvJzd3PXl5mykry6tUtqxoZ/gBLyIQOIC1r86969/BP/OXx2dahaYnnVDKivf/nlhArB2s4vVV/ozmbsxh8dY8AM7u3PSYAgEIZTDr1yoRY+DvX6+NOOY8bQKey1ZiejxKQUHVv7dVOTAYCBg9pknd02+ZiDR4/dsk8/8u6sonvz6NzKcu5vWb+vPIJd2Yes+Zh90/AELTcV654RT6tUqkZ/MEzurcBJsFcR4H1/ZvdZzu4PhIjnFxzr59C175vnqpWR0ON1FRSRhjyMvbhDGG0tJciotDIzEJp/2HGHvoU9ooeyjfu90Cml8GlgObLTTFqqwsn5KSPeTmbmDv3kyMMQSDoYXfPmMgqgUVYZfbBs3coYe9GDukuSFl33INbxCy177D3reOPotLdRljKPj+utB6iIn7rhP0gb+kTq4nR2aMwfvz/wNCv2Ppboh1UGmKzd5iL5e+OJPrXp0LwMW9mpGeULNN9P5wYWh07rOlOyolK4hPDI2w+XzFVa5bqsqBO4sHq3mOSE1ompCINDrndj26ufXNE6P4+NenhV8Xlftx2W3H/GniiezOoe2ZtnIXkxbvoH2TWK7u3/KID0sJCa0pLy/E7y9j9+6V4SlDbnc8UTHp2DqPIWHjG9B2NAx8lWRfCeW+MmJiQoFHXt4m/P4y7HYX5eX5lJbmEgz6KS8/YHRi6CTSNj0HmW9jAVa70cRb+xZXAvb2Y7Ayv8bsGzkoDYBz7RvEnvpK7cy3PmDzKG9ZLkUb3w+9bcBa8wb+VW9ggKTEdjivqF4gJbWn6PvrCG7/DLsV2mXYurY49PM66Gf/0cJtLNueH3799JU9a3zt/q2TSI11h7KTbdrLafsSD0Bo5MxmsxMMBvD7S3E6D//hgzEmcppQUMGA1L2G95dMRKSOxbodDTIQAOjbKombhrQB4O/T1jLoqW+55MUfeWNm5iE/2bTZ7MTHhxZhVwQCDoeb5OQOoU/+K9KTDh4X2pTJnUBsbBqWZWFZFklJbWnSpCvJye2Jjg49SEUEAoDd7sI25C1sI71YI/fVVVHvdV449RUS/Nuw7xuBAChMv5xADZ+lAgEfBdOv2T8CAPgCvtDIBqG1CqUB8BnwG8jN24iZfePhqpRaVlK0k8LM0ILheEcoUMQRXWUQ+MXyneHvrxvQkjhPzQNFm83irM6hLF7fr8mudNzpDKXt9XqLKh2rzBw0TajGzRM5oob510xERI7Zr8/qQNQBGZKWby/giSkrD5tlKDo6haZNu+N2x+N2x5Gc3CFyPUU1P533eBIjXsfGpuN2xxMf33x/PQfWVfHa5iS64xjS3JDUaTSuS5ZiejxCUVEo69PevZlkZS0hEPAeMrVpxdQkY4Lh17nfXUNR5ofk+QmNQvhL8JUXQM9Hofkl4XMd+241YMC/8a1KU4aCQT9FRbuq+UAo1eXzlZI363YgNG0syg4MfLXKsltzS1i0JQ+A35zToVYX31cEA9PX7K50zO0OpQAuLd17xHoqjQxompAcB5omJCIiEZrEufl07GlMnLeF8bM3hd9//tt1XNb70IumHQ4PKSkda3RtlysOjycRYwLEx7c44rSKCINeD6WRtDmJLcsnN3c9xcXZ+Hwl4YfwnO+uI7D1E+LaXUPsWe+HTy0u3k1+fihXvM1mJympPX5vAb6tk4DQWoQdvmhsb8WEHtYyLiZq1+eUEVoD0cQFuU0vo3zrZHY7WtLkvRic7UeHHkxtTvLyNlFWFpqe4nRGER/fErc7rkZ9JVBStAO2T8Fjg3gnoalohwg8P18WGhUY3C6F357fuVbbcUaH0Fqi9dlFbNxdFN7RGyAqKpmCgm14vUV4vcW4XDGHrCdw0LSgg1+L1AWNDIiISCWd0uJ4/LLu/Pj7s1n6+PlEu+xs3F3M8u3VyzJ0rCzLIjm5PSkpnY4uEKiw70HQ40kIpysNfxpv/Pi3foIBCjZ+gG/mDfuOF5Oft38fiWAwQG7uegqKdkHzS8ILlwmU7P/UdsfnxCW0J90dCgSs9mNwDnwJzpsJJVvZ7YW8teMpn+jCN+umcCAA+z7Nztu0/9r5WwkG/Ud/r41ceXkhJWX50PwyYuyEAoHB4w5Zftb6PQBc2DO91tuSEO0Mb/j37NdrIqbU2e1OoqNTAMjP33zYegLBYMRrjQzI8aBgQEREDqllcjTxHidD9z3ofLRwaz23qPoq1jEAJCa2wWbZOHBMo3TD2xhfEXnfj4KvBsGyJ8LHjAlijMHe5y+kdfpleBpQhTgHOEo2YF1bHFrDMOj10J4LK58OlykJwF4flG54E4wfjyeRhIRQBqpAwEt29nL27FlNcXF2OPuSVF9h4Q6MMXgG/AP3KG+VgUBusZfHJ6/gz5+vZN7G0MZg/VrVzd4gDwzvjM2CL5Zl8faBOxID8fEtsSwbPl9ppfUwBzo4GAgED1FQpBYpGBARkSO6oEfo09QJczbz3Ddrq50msT5VPHwnJbUlOjqF1Ka9aNLlJpL2zSIpCsDOt+Lwb/sUuwXpeybTLK0HTZp0xW4PFUpIaIXt9Ldo0vkmmrmhWUp7MjyhYIB2YyIWqka5Y4nKmkK8Y99xQtmGipyhoMTtjiMmpgmxsaG+9Pv3r13QWoKj4/eXh/ssIaHlIacGvfDtOsbP3sRrP2biDQRxO2x0Tq+b6VndMxLC048mHhQM2Gz28OL44uLKi4wraGRA6oOCAREROaJLe2Uwel+Woee+Wcc/v1lXvw2qppiYJkRFhXaJdTjcOIaMx3NdIbaDPulPdICt3WgsuxunM5qmTXuQltYTjye04Zw1ZDzWSC/W5ev3ZzAa9HpEHZbdTVLnMcQ6IK7DjSRWPJ+WboOvBuFa/AAA8fHNSUpqS3x8CxITQ7tf+3zFVKW0dC9lZfmHD75qc+OzE3wjNWOC5OdvYffuFQA4ndHY7a4qy5b5AnyyaHvEez2bJxx2k8Gauv7UVthtFqt2FrBpT+TPNCYmNLpWVpZPIOCt8vyDH/61ZECOBwUDIiJyRDabxeOXdefhfRlYXvh2HVtzT85NtixnLKmdb8K17y9gtB3cB2WhsSxb5YfMik+fq8hfH1aR7nTIBKI7jA7NZSeUbcix6c3wg3ZUVDKxsWlERaVgWTaCwQDl5YXhakpL97Jjx0L27t1Ibu56ior2p8QMBLwEfKG+L5kxivJ3arbBWllZXmjK0jdXkTXBRdHbLphz8wkZFBQUbKO4eDfGGBwOTziYqsrSbfnkl/pIiXFxSa9mDGmfwh8v6Van7UuKcTG4XWh9wJfLsyKOORye8OLhQ40E+QNaQCzHn4IBERGpttvObEe/VokAzNmYU7+NqQHHkPGk3FBOSsfrSahip9oaqahn8DgSOo2OWGR88DUsyzpgcekWgkE/wWCg0kLTwsKdeL3FeL3FZH/zC3a/HUPh9KvJWz+RHB+YDW8c88N7cXE2fl8x3i0fEzRQ4Ifda8bvDwpOEIGAl5KS0CLgpKS2NG3a/bCLzCs2F+vXOol/Xd+PibcNok/LxDpvZ8UC5S8P2NOgQkV7fb7SKs8NGE0TkuNPwYCIiByVwe1DD6+z92VnOVlZdhfuM94JLwCuE4PH7d8o7RDXiIvLwG534veXkZ29nLy8TILBABDaZ8GyQn+q9+xZzZ7p12G2f0bQQGHmR+E6vC2vO6bmGRMMfUptOYhrdw3OfdOnfMFQUFC8bvwJExCUluZijMHlig1P/TqcZdvyAOjVPKGOWxbp/G7p2G0WS7fls3RfGyrsDwaqHlULHLRiOKgFxHIcKBgQEZGjMqR9aCHk5CU7eGn6epZszavfBtVUbY0IHK5+m5PHJ6/gzL9NZ332/ulAU5dncflLc8n1Z+BweAgGA+E0pImJbYiPb05cXLNQYeOH7VOqvMTeDe9R+LYLM3v0/nn/1RgpKCnJCWVNsruIO+t9UjvfRLKT8BSqfD/4Now/IaYMlZaGsgFVjKQcTjBoWLAptMlXjxbHNxhoEufm8t4ZADzzVWSaUYcjCjhMMHDQSMDBr0XqgoIBERE5KoPbpXBB93SCJvSwM+Lfs1h8sgcEdWxzTjHjZ29iS24JI1+bxzcrd1FQ5uPOtxeybHs+//lxK02adAtnGnI4POFPv2Nj00lP7w2WI7zrcUW2omg7WIQWmhb6IWftBPLecrH7zX1z/w+zlqC4ODu80VrF4lZryHg8o7yk/rIYz74nhNJAHXTIUQgGA+TkrMXnK8WybJV2qa7K9DXZbM8rJd7jYGDbI48i1LbfnNsRl8PGj+v28O2q/dmDnM4oLMsiGPQTCFQOsIJBLSCW40/BgIiIHBWbzeKlUf148vLuABgD//ru5MguVFfW7irkrbmb2V0YSheaXVDG1yuyeGvuZgrLfLw7f//+DLsLy7n1zZ/o9fjX4fc27inGsizi45vTtGkPUlM7R+z0bLM5sJY/Adun4Gw5grhOY0h3Q2Kn0TRJbk+cA2xWaKfkkkBomk+hHwJVrSUI+jAmSGHhDqBiMfMBG3HZnOCIJrr9KABKg8D8O2u5x6qnvLyArKzF4cXVsbFp2GyOI5732ZLQvV3TvyXRriOXr21tU2MYNTC0p8SBC4kty4bD4QHAV55f6bxKqUUVDchxcPz/hYiIyEnPbrO4YXAbhnRIZdg/fuCbVdms2llA12bxAPgDQXbml7E5p4T0BA8dmsZWWU9xuZ8Yd/X/FBljeO3HjXy+LIthXZry67M78MPabD5auI1WyTH85pwOfLRwG3uKyrnu1FY0T4yq0X3mlXh5b8FWrujbnLR4T/j9H9ftZtysTYw9pwMAo16bR6kvwL+nr+fRS7px3weLKfOFHuzmZ+ayPjuUPebJy7uzYXdolOBAq3YWUOYL4HHawzsnRwj6SM2eTIEN4ndNgnO92E59BWxOHECcvwTPnNso2TgRy4LyYCggKPG0JW7fNKhgMEDRjFHYtryPv+U1BDv/HrvdRVJS2yrv3T3kdVj3DgEDwQ1vhK93vASDAfbu3b8zdHR0KrGxzap17sItoSlCFbsC14fzu6UzbtYmpq/Jxh8I4tiX0tThiML380OUZ03G03lMxFqSgxcMa5qQHA8KBkRE5Ji1bxLLRT2b8fnSnfzhf0u577xO/HXqGlbt3L/Lalq8m9l/OJesgjLslkVavJunp67mm5W72LC7mBF9Mvj9BV34yxer2JxTwjNX96KwzM9z36ylc1o8czbmkBrr4p5zO/Lp4h28NTeUaWfJ1jz+Pm1tRHs+/GkrOcWhHO4/b9nLO7cOOuZ7CwYNd038mVnrc/hyeRb/u3MwDruNmev2cMPr8wHwBYLYLItSX2guzc78Mn71zs8R9VR8Sg1wYc9mpMa66ZgWy6OfrqBZgof8Uh+FZX6Wb8+nf5tDTGmxOXF2GEPKxjeqznzkiMZ5xjskOFyQOZ5iP+QHwVeYCf4SsDkpKcqiaOP7ofKZH0Cn+4mJaVH5WvtYdjf2liMIbJ2Ev/UNuI5jIFBeXrAvu1KoX6OjUw+bRhRCgeK/vlvPv7/fQKkvgGVBn32Zr+pD/zZJJMe4yC328tWKXVzcKxTIuJ0eSrdPphjwrHsDd/8XQ5vXEQqiD6QFxHI8WOZk2EayjhQUFJCQkEB+fj7x8fH13RwRkZPS+uxCRrw0m6Jy/yHLRLvslO17YG4a5yGroOyQZfu3TiK7sJwth9nH4JTWSSzemkcgaLBZcGrbZOZuzI0oY7NgwcPDSImt4pP2avh21S5umfBT+HWntFj6tEzkg5+2VVn+hkGtw4HKNf1b8H+X9eCpL1fx5pzQe12bxfPlPWeEy2cXluGw2Xjo46V8tWIXD13YhTuGtj98o4K+I386H/RRPvsWcta+BdEtsUq2EuMAf/MrKdv8MU4LLAs8V24hNr7lYavas2cN3vI8kpI7ERWVdPjr1pLS0lz27s0EQqlXk5M74HYf+W/0VyuyuOOtheHXPZsn8NlvTq+zdlbHP6at5YVv1zGkfQoTbwsFpibgJf9tNyX71mIkOiG6Y2iEYOW2LC761/576NzUyVf3n18fTZeT3NE842pkQEREaqRD0zj+96sh/HXqar5bvX+x5C9OacG2vSXM3ZhLiXf/KtSKQODins24oEc6v/9oafiTdYCfNoemeCTHuHDYLLyBIC67jezCcjxOG1f1a8GfRvRgd2E52YXlNE+MIinGxS//O4+Z6/eQEOXE7QiV/3rlLkae2uqY7qti99q2qTFszytl7a4i1u4KTfdJj/eQGudi+fbQCMjFvZrxhwu7UFjm49S2KVy/b774wxd3JbfYS36pj/vO6xRRf9O40LSjU1on8dWKXSzcd9+HdUAgUOL18/8+Xkan9Dh+fVaHiDLOIW9A6ztg2ukYoNgPZvPH0PxiEnZ/jqvDGDhCIAChXZu9XgcBXxEch2AgL29zeC8BlyuG2Nhm1QoEAKat3AXsn69/Vuf6myJU4eKezXjh23XhwNVus7DsLuI73oh3zZv4DeT7wLNvGtbBm4xpyYAcDwoGRESkxjqnx/HG6AEs2JSLzYKkaBdtUmKYtWEPczfOp0fzeO4/rxNN4zx8uXwn0S4Ht53RDpfDRqe0ON6cs4neLRLZuKeYV37YAMADwztz3YCWGAPeQJCtuSV0aBobXljbNN5D0wPm8f/j2t5MXryDS3tn8NHCbTzz1Rq+XJ7F6R1S+fCnrdw4pA2p1RwlKPcH+GZV6OHy+ev6EO9xMndjDi98u44d+WXcdU4Hzu3SlC+XZ5EW72Z493ScdhvPXdc3oh63w86/ru932Gud0jr0kL1gUy6+QBCnvXq5PR7837LwFKRbTw/1ZQWbzQEr/xZ+bQDs0VjbP8fZ5aZq76tgt7tg2RMUbJ+Mo8P1eM58p1rnHY3QBAVDIOALBwI2m4OUlE7hPRaOZOPuIj5aGBqx+b/LutfrWoEDdWgaS7TLTok3wIbdRXRKiwPANmQCTYxhz9q38JnQou9YtIBY6oeCARERqTUDDprzfkbHJix4eBipsa7wQ3yPgzaB6pwex5+v6AlAfomPr1ZkkRrr4upTWmBZVmhKi81Ox30PUofSNM7DrWe0A+DCHuk889UaZqzdzRl/mw7Ajvwynr2692Hr2Jpbgi8QJKfYS5kvSGqsi57NE7AsizapMZzeMZWFm/dyaa8MbDaLW06vevHt0ejVIpHUWDd7isqZvjqb87uHMvuU+wP8Y9pa+rZM5IIekQtn80t9fHVAlpoNu4vCi7cBCPpI2DWZMlso/eheHxAoIcoO1qYJMOi1ai0GdtjssH1y6JobJuJ2OLGGjI+4TkQ9R5jG5PeXEQj4cLv3/yxzc9fh9RZF5ONPSmpX7UDA6w+G13C4HbZKv4P1yW6z6JGRwPxNuczLzA0HAwDWaW8S7fOSv/F9yjOuINbm1MiA1AulFhURkTrVJM4dkSbzcBKinUz/3Vl8eOeQcPaVY9GuSSy9D9ps6qOF29hVUMaXy3aG1y9UCAYNXyzbyRl/m84Fz//II5OWA6G1CAe2vUVSNJf3aY7NVr37qQ6n3cZV/ZoDoTnmpfumVL07bwv/+WEjd779Mz/vy44TCBrueW8Rvf/va7wHLDZdnVUQWanNSUynMaS4ICq+A8lOiHdAggNoO7raWYE8nkSi7aHvAwbKNkyAoI+gv5Scb64ga4KLwOzRGBOkYPo1FL7touj7aykt3Usg4MXrLQ7XVVy8m927V5KTs5a9ezeSk7OOrKwllJcXRgQCcXEZEcHC4WzJKeHsZ79ne14pAC+O7EuUy16tc4+Xs7s0BeCFb9eRXxqZ5tV9+gRofgneLZ8QmHVj5ZEBBQNyHCgYEBGRBunlX57CRT3TGdEng8To0MPvwL98y6/e+Zk//G9pRNknP1/Jr/dlAfL6g6zOCuW1P/U4fcp8y+ltSY11sTqrkHfnb2Hh5lz+cUCmpDdmhhbUTlm6g08X76h0fkV7Iwx6Ha7zwuXr8HQYTawDrHajYfC4iGIz1+3h8n/NDC9+PpBld5PYeUx4k7NCPxR83ImsN6Mp3zKJoIG8tRPInXY5RZkfho5v/IC9M25k165l7NmzmpyctZSU7CE/f0v4ob+0dC/l5QUEg6FF505nNB5PAg6HO7zZ2pHsyCtl5Gtz2Z5Xit1m8dL1/cKjKieSm09rQ7vUGHYXlnPKk9PCgR2Aw2bDvXMKBihc/xaBFc9EnHvwSIFIXVAwICIiDVJGYhT/HnUKz13Xl1tOi5zOM2nxDmat34Mxhj/8bynjZm2qdP6ZnZpweZ/mx6WtTeM93HV2aBHwk5+v5Jf/nU9B2f7sTHM25GCM4dUZGyPO65Ie+gR9QWZkJqWwihGAweNCgcFBgQDAM1+vYcm2fB6ZtJwlVe0kPeh1oq7JwQL8BooKNkUcLg9C+bYpkedsnwIm1P7y8kLy8kKBhseTiMcTGrGx2124XDHExTWjSZOuJCd3oGnTHlXvs1CFP05azva8UtqmxvD9784Kp+480Xicdv5yZWganD9oeHLKyv0jITYncfs2dysLQiDr24hzFQvI8aA1AyIi0uAN75FeaU+CUf+dF/H6nnM7ct95nZi1fg8tkqJonRJzPJvIhT2a8X+frcQYKPUFOLNTE168ri8Dn/qGnGIvI1+by4odBdgs+PHBc1i2LY8ezRM4/a/T+XlLHvM25tC3VVLEQuIIVUwN2ppbEhEA/LB2N71bJlYq5/Akk9T+Oooz38NmgXvfWoQ8X2jxq9MKpch0xrcnULiBvPSrsEWHpseUlu4PVKKjU/B4EvH7y6v90H+gVTsLeGzyCqJddr5fsxubBf+9qT8tk6OPuq7jaVC7FD64YzDX/GcOi7bksWJHQXjtjPP0t7Btn0GwZCvlroyI8xQMyPGgkQEREWnwOjaN5f7zOnH3uR356Y/DSIiKfDC+9fS24dSfp3VIPe6BAEB6gofbzwwtgG6dEs1L1/clIdrJ6R1SAcL7KPRvk0zzxCgu6NGMFknR4Yf3a1+dyzX/mYPXX/2dqj5bGjnlaOb6PYcs6xn6LinJHUhyQnR8B7immMTOY2jiglQXOOM6wGXrsY/0knLuRyQltSUpqS1xcaEHXJvNgcsVGsk4lkAA4M+fr2J+Zi7fr9kNwGW9M2jfpOrdrU80p7ZN5ux96U4XbNofIFnGj7t8KwBlJdkR52iakBwPGhkQEZEGz7Is7j63Y/j11HvPYNXOApZtK2BXYRl3D+t4mLOPn/93UVdGDWxFYrSLOE8oYLnl9HZ8s2r/Q+INgyJ34v3T5T144KMlrM4qZPHWPG598yeevLx7tQKaKUt2AnDHme34z4yNLNqylxKvn2jXIR4PLlsX2tF43465DHod56mvhLIIVbx30AhEXFyzfRuWWdhsx764d8WO/HCw0rtFAn1bJfGHC7scc3314ZTWSUxfs5uFm/dyc8XUNZsTd9vrKV0/EX/yENi6v7whlHq1ugvwRY6FggEREWl0miVE0SwhinO6pNV3Uyo5+CF+ULtk7j63I/5AkPvO61RpH4KeLRKYeu+ZTFu5i1+/s5AZa3cz4qVZfPfbs0iKcR3yOht3F7FyZwF2m8UdQ9szZelOtueVsmDTXoYeLk+/46ApOTbnEbMTORyewx6vjv/+GFpEfWnvDF4c2fcIpU9M/Q7YU+LAh3z3aeOhtIDA2gXApditIAFjI5QwygAKBqTuaJqQiIjICcyyLO4/rxO/v6DLYTckO69bGlPvPZN2TWLYW+Ljyc9XMnvDHtYckGmozBdg055Qus8pS0OjAqd3SCU5xsWQ9ikAfL50B3e89VM4g1F9envuZi59cSb//XEjny4O7Qh92xk139uhvvRrlUSMy86ugnKWbssPv2+3wLNzCkET+vk68QIQNJomJHVPwYCIiEgD0b5JLL89rzMAH/+8netfm8fw52bwt6mr2ZlfygXPzeCsZ7/n6xVZfPxzaMfeS/Zl4Tm3a2jB7wc/beOrFbt4YspKVu4oqPpCx0FhmY+nvljFsu35/OnzVQRNaJSkV4vEemtTTXmcds7qHOrnq1+Zw8x1+9Zo2JzEdbyR4L7Hsoo9NoKGiD0YROqCggEREZEG5KKe6fxpRA+6NYsnNTa0UPc/Mzby/z5exqacEgBuf2shm3JKiPc4uKhnKBg4r1s6bVIipwD998fIVKZ1rcwX4Plv1jFuVibvzNtCsTdAQpQTu80iJcbF/7uo63FtT10YeWorALyBIDeNm8+WfT8T26DXCPQJ7TPgdEUBHDBNSKTuaM2AiIhIA2JZFr8c1Jpf7ltofPO4+Uxfs5vp+zLwHGjUoNbEuEOPAnabxXPX9eWjhVtJinbx4nfr+WbVLrz+4KHTldayl6av58Xv1ke8d9+wjowc2AqbZR12mtTJ4vSOqfzx4q786fNVBIKGl39Yz1NX9sKy7AQJLbB22kNrBDQyIMfDyf+vSkRERA7p2gEtw98nRju59fTQnPtuzeK5+5zILEp9WibypxE9uXdYJ1JjXRSU+Zm7Mee4tLOo3M9rB41ERLvsXHlKC9wOe4MIBCrcekY73r1tEABfLs/CFwhis9kJ7ksl6rRVBAMKBKTuaWRARESkARvaqWn4+zvObM+vzmrPrWe0IzHaicdZdapPu83i/O7pTJy3hakrsuicHodlQdO4mmcFOtiybfk8/+1adhWUU+YL0jolmk/vOo2Pf95O12bxxHsOn6noZHVq22RSYlzkFHuZuzGHMzo2IbDv2d+x78cSig1MKHXrETI2iRyrhhNmi4iISCVRLjsvj+rH3ed25NZ9mXjSEzyHDAQqXNA9HYCJ87Yw8C/fcubfprNhd1Gtts0fCDJmwgK+WZXNsu2h7DrndkkjMdrFmNPbMnhfhqOGyG6zuKBHqI8/+Cm0mLtij7H9IwOwd/q17J7gwjfzhnpppzR8GhkQERFp4C7s2YwL9y0Urq7B7VPo3TKRJVvzACjzBXnpu/X849o+ACzfns+arEKu7Nc8nC9/S04JP67fTYcmsZzaNjlis6zicj9Pf7maL5fvxG6zaJYQxYA2SewuLI+47mV9Mo79Rk8yI09txTvztvDV8izyS33hYODAkYHyzZOwLMhZ9zZploV12pv112BpkBQMiIiISCVOu42P7hzM4q157C32cvtbC/l40XZuGtIGCKXG9AaCJEQ5GdYtjUVb9nLD6/MpKvcDkB7vobjcz5AOKfzr+n7c895ivlm1K1z/roJyFu8LNPq0TARg9JA24e8bgx7NE+jQNJb12UV8vyY7vGbgwPXaQWzYCRI0ULLhLWJsdhg8rp5aLA2RggERERGpktNuY0CbZACGdmrCD2t3c/lLsyLKvDNvM0M7N+GRT5dTVO4nNdZFiTdAVkEZAF+t2MWQp79jd2E5LruNJ0d0x+sPMntDDlNXZNE6OZoXR/alZXJ0pes3Bud3S2N9dhFTl2fRyzcFOBNn6WYgNJITxEa8PUhxAIoCEL1xPNaAlyrvBC1yjBQMiIiIyBE9dmk3bnxjPtv2lka8P33Nbro/+hXeQJBYt4Ov7j0Tp8PGsm35LN+ez1Nfrg5PBfr12e25dkAoz/4Ng9uwp6ichChng8oUdLQu7tWMf3+/gW9W7aJN0hYA3L4sKoIBR4vLid/zP0qtaAL+Enb6o4mbGENcpzEw6PV6bLk0FI33X5+IiIhUW7smsXxz/1CGdmpC7xYJfHXvmVw/cP8GWonRTp6/rg8psW7iPU5O65DKHUPbc9fZ7bEsaJsaw+1ntouoMzXW3agDAYDuGQn0bpGAL2B4c++1AETFpoePW32exrq2mFhCm5MRKKHQD8ENb4SyDInUkGUa8W4WBQUFJCQkkJ+fT3x8fH03R0RE5KRS4vXz6oyNGAOjBrU6ZOrRUm8Al8OG3WZVebyx+2blLm5986fw6/O7pfH1ytD6ilnnvkvz894mOPsmdq95M5x+ND6hDbFXZdZHc+UkcDTPuJomJCIiIsck2uXg3mGdjlguynX4NKaN3bBuaZzbpSnfrs4G4MCsr64dkyDowzZkAk2NoXTjW+T5oLhgE9H+MmyO2t/7QRqXxj02JyIiInICuPm0tuHvXY79n9Xa29wQ3nDMOu1NotrfhN2CQMZlZO9ZTXl54XFvqzQsCgZERERE6llC1P4dhg+cThXo91xEOWvIeJKvz8PW+wmCwQB7927A7y87Xs2UBqjWg4GnnnqKAQMGEBcXR9OmTRkxYgRr1qyJKFNWVsZdd91FSkoKsbGxXHXVVezatSuizJYtW7j44ouJjo6madOmPPDAA/j9/ogy33//Pf369cPtdtOhQwfGjx9f27cjIiIiUufiPAeMBlgWFfFAsIqlnU53AmlpPXG5YvcFBBuPVzOlAar1YOCHH37grrvuYu7cuUybNg2fz8f5559PcXFxuMx9993HZ599xocffsgPP/zAjh07uPLKK8PHA4EAF198MV6vl9mzZzNhwgTGjx/Po48+Gi6TmZnJxRdfzNlnn83ixYu59957ufXWW/nqq69q+5ZERERE6lTsAcGAZe0fHagqGAiVsZGc3B6bzY7PV0pBwXYacU4YqYE6zya0e/dumjZtyg8//MCZZ55Jfn4+TZo0YeLEifziF78AYPXq1XTt2pU5c+YwaNAgvvzySy655BJ27NhBWloaAK+88goPPvggu3fvxuVy8eCDD/L555+zfPny8LWuu+468vLymDp1arXapmxCIiIiciIo8wXo8kjo+WVEnwy+XJ5FuT/Im2NO5cxOTQ55XlFRFgUF2wFwu+NJSWoTXmMgjdfRPOPW+ZqB/Px8AJKTQzsYLly4EJ/Px7Bhw8JlunTpQqtWrZgzZw4Ac+bMoWfPnuFAAGD48OEUFBSwYsWKcJkD66goU1FHVcrLyykoKIj4EhEREalvbsf+R7ISb4ByfxCAG9+Yz4A/f8OtE37CFwhWOi82Np2kpLZYlkX5T7/DO9EFc2+pfAF/SZ21XU5udRoMBINB7r33Xk477TR69OgBQFZWFi6Xi8TExIiyaWlpZGVlhcscGAhUHK84drgyBQUFlJZG7o5Y4amnniIhISH81bJlyxrfo4iIiEhNWdb+RcOlvkDEsd2F5Xyzahf/+WFDledGRSUT5Y6H7ZPJ90Fgwxt4S0JpSv3+cnI+aEPu2zEEP+1YdzcgJ606DQbuuusuli9fznvvvVeXl6m2hx56iPz8/PDX1q1b67tJIiIiIhFKvIEq3x8/e3OVowMAcXEZ2CzwGdhVDnveS6P8x19SlLeR8qLNlAWhJH+9RgikkjoLBsaOHcuUKVOYPn06LVq0CL+fnp6O1+slLy8vovyuXbtIT08Plzk4u1DF6yOViY+PJyoqqso2ud1u4uPjI75ERERETiQHBwOrn7yA1Fg3e4rKeW/+FoLByss97c5o4tqPjHgvf/07lHxzfvh1aRD8836Fr7wAgj7KS3MJ+queTSGNR60HA8YYxo4dyyeffMJ3331H27ZtI46fcsopOJ1Ovv322/B7a9asYcuWLQwePBiAwYMHs2zZMrKzs8Nlpk2bRnx8PN26dQuXObCOijIVdYiIiIicjEq8+1Opd0mPw+O084tTQh+sPvLpCm6ZsIBAFQFB9GnjibYTTkvqN0DJtvBrXxCy17zJnncSyJrgIufdFPa8FU1wzs11fUtyAqv1YOCuu+7i7bffZuLEicTFxZGVlUVWVlZ4Hn9CQgK33HIL999/P9OnT2fhwoXcfPPNDB48mEGDBgFw/vnn061bN2644QaWLFnCV199xR//+Efuuusu3G43AHfeeScbN27k97//PatXr+bf//43H3zwAffdd19t35KIiIjIcXPgyED8vs3Irhuwf53j9DW7+ff09WzOKSavxBt+37K7SOw8hnQ3JOzPVIrHBtHxrcOvDVARS/gNFK0bD0FfndyLnPhqPbXogQtgDjRu3DhGjx4NhDYd++1vf8u7775LeXk5w4cP59///nd4ChDA5s2b+dWvfsX3339PTEwMN910E08//TSOA7bo/v7777nvvvtYuXIlLVq04JFHHglfozqUWlREREROFG3+8DkAsW4HReWh0YFhXdP47039Afhy2U7eW7CVH9buDp8T53Hw7f1DaRrv2V9R0AdBH3vejsEbhBQXOK7OY9c7iRHXc1ihYMBmQVrnm7CGjK/T+5Pj52iecet8n4ETmYIBEREROVFc/MKPrNhRwJV9m/PxotDeAVf2a84/rukTUe6+9xfzyb7jAHed3Z4HhnepVF9wzs34N4zH1WEMnPoKxW+7KA5AvCMUBETbYbcXAvu+T7i+EMsZW6f3KMfHCbXPgIiIiIgc2YQxp/LnK3rwf5d3D78X76m8gdgTl3fnzqHtGTWwFQCvzchk8da8SuVsg8fhut4Lg14Hm5OYTmNo6gZPQkdiHWBrP4aoNlcDUBKAnW/FkT/9WgKBI0wZ0pSiBkUjAxoZEBERkRNMxZSh+4Z14p5hVe8PEAwa7nh7IdNWhrIr3jm0PQ9e0PmQU7ZDJ/lCOxTv+6+/LJc976Zw4Hpkx0WLiEtojceTgGVFfm5cOuN6vJnvEt+xGtOKKq51IjiR2nIcaGRARERE5CR22xltaZUczeghbQ5Zxmaz+Mc1venaLPSw98oPGxg3axNlvgDb9h5iP4GKB+J9/3V4kklL7kCqa9/x5pfhDwbYu3cjO3cuIi9vMwR9mICXwu+uYu/6dykOQMG6CTD7JgACAR/esr2YQGgxszFBin4YSeDdA3ZDPprRhJqMPOxbL1FRR2npXnZPu4LSdw6xM7NoZEAjAyIiInIiMsYc/lP+ffyBIH/7ag2vztgYfs+y4KkrenLdqa2qdzF/CQFjMJadkpIcSktzQtOFlj2BY8fkUJrSg7hsENXmGgrKSzHbPyPWAfEdR5Pf6Q8Uf9oFpw2auKA442rsWz/E0zG0dgGo8lN6r7eY/Bk3ELPzE6I7jiHY/yUsy8Kyuw/d7orAweakZMYoijZMxG/AbYPY9teTU7wXdnyJy0Yo4LnOW/UIwQH1HAtjDOXlBQB4PAnHVEdt0gLialIwICIiIg2BMYbHJ69gwpzN4fcsC167oT/DuqUdU51FBdso+KhlxHsWodSkh2K3QguSK7gd0ZTv2/XYZQvtdRDvgJhOY0JrGQ6wN2cNpZ+GFkK7beANgtMGqZ1Hw+BxEWWNMXhn3kDhhncAiGt/PTnrJh6yXRaQ3uUmvKe8iN0Ch8MDNifGBMn59ir8WyeR4ICojpXb5fUWkZe3Ccuy4fEk4XbH4yCAZfdgWRZl3hKK8zdRHghlgEpMbEN0dMpheqnuKRioJgUDIiIi0pBszilmxtrd/LB2N9+sCm3eemanJmzNLWH8zQNIinGxLbeUTmmxbNxTTIukKKJdjkPW5515I96Nb+G0gcsCyxFHua+QvT6oYt+zarEIjRiYq/bgdMeHP43P2vETwakDKpVPcoKn3Q1Yp70Z/gR/z7dX4936aaWyjgM3XCMyeLG1uIygCWBt/5xUFzjb3UheWQklmz4Kn5/sBHNlFqXlhTid0cTGNmPv3g2UleXvv8iMK6Bk6/7X9mgIlEB0SzjzE+x2J02b9qzWqE5dUTBQTQoGREREpCHaXVjOgD9/E/HeHWe2Y8rSnWzPK6V5YhTb80rp0Tyej+4cgsdpP3RlFVNogj5wRIf+O/9OvOvfIN8PcXYo9IPPhD79d9sgygZ7IgIGOxCoVHWsHdxtR+Lv+wz5s++E7VNwWKFRjaDZP8rgskFcQjsK8zfiDR66qU1c4IzvQKBwPUETCg6KAqH2HeiQIxzNL4Oej4Zf2mwOgsHQyR5PIgFvPr4vTqny2g4LAufNwtjcxMamUV5eSGJia5zO6EM3uI4oGKgmBQMiIiLSUP3q7YV8uTyLKKedUl/lB/EKf7y4K7ee0e7oLxD0wbzbIXM8/uj2+Ao3EJXQAYrWQ9vR+PxeCjdMxGULPZA7LYiyQ95h1gd7bJC8bzFz0OzfB6EqUfbQlKM9+8pE2UOjCFy3f1dmgj7M/F9TsG4C5UEIAsZEBgJRdoi2Qc5ZM8Ee2rzNbndGpFh1uWJJTe0cWhvwSQdM8UYK/Puvm+AAK7Y9+UO/oaQkJ3xebGw68fHNj65fa8HRPOMeelxIRERERE5az13Xh4cLy4ly2hnw528OOa3ny+VZxxYM2JyhufwDX8Vhc+I4KG2pE0h2uCBzPLGeePAXQEwHfHnrKQns//T/QC4b0HY0DHwVG9Bkzq3sXfcm5VWMBsS0G4X9tHE0+awb3oL1uG1AuzGRi4BtTqwh40mwLMgcD0DQFkuZr4h8X2j35XgH2NuNJi6xHYWFOwBITe2Kz1dMYeFOPJ4EYmPTAbAsC8+VG8BfQtSCu8J10uZGGDIBT1leOBiw213ExTU7+n49zjQyoJEBERERaeDueOsnvloR2o8gPd7DnqJybj2jHa/8sAGAa/q3oGfzBEYNbI3NVstz3SuCBH9JaJrR3FswG94IBQP2WGyBIvJ8UBYMTfOxj4zM+OOfeQPZa98GQg/vwagWULKNZl1vxhr8xr5CJaFzDpcNqCLlaMVUp3m3Yja+idVuNAweRzAYoKBgG9HRKbhc1dyJ+aAsRMYE2bVrKcFggOTk9ng8iUfZWbVD04SqScGAiIiINAYrdxRw64QFnNo2mb/+ohfBIES57Nz3/mI+WbQ9XO6Kvs25oEc6vVskkp7gqbsGHfgQ7S+Bik/Z21XO5kPQR86bLnwGUpyQ7w9NJ4p1cOhUoUfTjlrajOzzpTtZvHUvvz6zOVFOU2+BACgYqDYFAyIiItKYlfkCPPPVGl6fmVnp2F+u6MmV/ZpHLC4u8frJK/GRkRgVfq/cH8BuWTjsNdzL9jAP5mbOGNg4Dqv9mNAbG9+oOnCoJyt25HPxCzMBuLxPBs9f17de26NgoJoUDIiIiIiEzF6/h7HvLiK3eP8C3B7N4/nwjiFk7ilm8pIdfPDTVvJKvPxyUGvapMRwVucmXPOfucRHOZhw86m0TN6fOccfCNY8QDjQgcFCLX6ifyRef5B5mTkMapeCs4r7CQQNV/x7Fku3hdKPuuw2ljx2PlGuw2RoqmMKBqpJwYCIiIjIfnklXmas28OHP21lwaZcynyHyeN5kAt7pPPyL09hR14pY8YvYPveUj65awgtkqJx2CzyS33M3pDDWZ2bEOep2wd5XyCI3bJ47pu1lPmD/OacDoe85pwNObw9dzOX9s7ggh7pbM8rZUFmLkM7NSEpxsU/vl7DC9+tB+DUtsk8fFFXerdMDJ878rW5AMR5HJR4AwSChjfHnIrdZnFah9Q6vc9DUTBQTQoGRERERKo2fU02N49bEH6dGuvi7M5NcTlsvDNvS5XnTLxtIFOW7mTivuNN49x4A0GinXa8AcOeonIu7tWMl67vV+vtNcbw+sxM/vT5KtwOG6e0TmL2hlBmn+sGtORPI3rw+sxMFm/No01qDPec25H3F2zlsckrAIh22fnynjO45MWZFJb5GdI+hbdvGUi7//dFxHViXHY+vHMIDrvF9a/NY09ROQB/GtGDhZv3RqzBeOSSbtxyettav9cjUTBQTQoGRERERA7tnvcW8eniHZzfLY3/3HBKeFfdEq+f2etzuO+DxZzXLY1l2/JZl11UrTptFvzz2j58uSyL7hnxtG8ay0cLtzFqYCvWZxeRFu/h7C5NWbEjn05pcbgcNuI9TvJLfMzesIfO6XG0axLL3I05fPjTNm4Y3JrWydHc/d4ifly3p8prpsS4uLxPc96YtX9tRKe0WNbuOnybE6Kc5JeGFjtf1DOdnzbtJbuwvFK5l0f144Ie6azYUcAV/56FL2CwWfDyL09hePf0avVLbVIwUE0KBkREREQOLxA02A+RbtQYg2VZbNtbwjNfreHTxaE8/a2SozmnS1PmbsxhdVZhjdvQJiWaTTklADjtFo9d2p0nPluJNxDEabdw2m2UeCM3VrPbLDo0iWXNrsNfv0VSFLee3pbHP1sZfu/ins2YuiKLwL6NEH53fifGntORjxZu43cfLok4f+q9Z9Alff9z5Oz1e/ho4TbO7ZrGxb3qZ58BBQPVpGBAREREpPZMnLeFWev38IcLu4QXE6/PLuL/fbKMc7s0JTnGxQMfLa2z64+7eQDdM+JJjnbhDxrcDhuPfrqCt+ZuBuCSXs341/X92JxTzE1vzGdXQTnjbx7AwHYpvD13M3+ctJxT2ybz/u2DWLw1j7fmbKZ901huP7MdTrsNYwyTl+zA7bDz4U9bubJfi3p74D8cBQPVpGBARERE5PgpLPNxyYszaRLr5l/X9+P/PlvB5pwS/nhJV+5+dxFp8R7iPA4Ky/x0axbPhwu3MaxrGt+sCm2YZrdZ4U/re7dM5P3bB/GLV2azfHsBowa24s9X9Kx0TV8gyIvfrsNht3HrGW2JdjmAUErUMm+QhOiKDcMM09dk07dlEkkxruPUI3VDwUA1KRgQEREROb6MMRhDpZ2Ovf4gDpsV8X6pN4DHaeOiF2aycXcRz13bh1+98zPJMS7eHHMqPZonsDO/lGkrd3FN/5YReyI0ZgoGqknBgIiIiMiJL6/ES2GZn5bJ0azJKiQ93hP+RF8qO5pnXMdxapOIiIiIyDFJjHaRGB2autM5Pa6eW9Ow1OK2cCIiIiIicjJRMCAiIiIi0kgpGBARERERaaQUDIiIiIiINFIKBkREREREGikFAyIiIiIijZSCARERERGRRkrBgIiIiIhII6VgQERERESkkVIwICIiIiLSSCkYEBERERFppBQMiIiIiIg0UgoGREREREQaKQUDIiIiIiKNlIIBEREREZFGSsGAiIiIiEgjpWBARERERKSRctR3A+qTMQaAgoKCem6JiIiIiEjtqHi2rXjWPZxGHQwUFhYC0LJly3puiYiIiIhI7SosLCQhIeGwZSxTnZChgQoGg+zYsYO4uDgsyzru1y8oKKBly5Zs3bqV+Pj44379k5n6rmbUf8dOfXfs1HfHTn137NR3x059d+zqu++MMRQWFpKRkYHNdvhVAY16ZMBms9GiRYv6bgbx8fH6R3aM1Hc1o/47duq7Y6e+O3bqu2Onvjt26rtjV599d6QRgQpaQCwiIiIi0kgpGBARERERaaQUDNQjt9vNY489htvtru+mnHTUdzWj/jt26rtjp747duq7Y6e+O3bqu2N3MvVdo15ALCIiIiLSmGlkQERERESkkVIwICIiIiLSSCkYEBERERFppBQMiIiIiIg0UgoG6tjTTz+NZVnce++94ffKysq46667SElJITY2lquuuopdu3ZFnLdlyxYuvvhioqOjadq0KQ888AB+v/84t/742759O7/85S9JSUkhKiqKnj178tNPP4WPG2N49NFHadasGVFRUQwbNox169ZF1JGbm8uoUaOIj48nMTGRW265haKiouN9K8dVIBDgkUceoW3btkRFRdG+fXuefPJJDswPoL7bb8aMGVx66aVkZGRgWRaTJk2KOF5bfbV06VLOOOMMPB4PLVu25G9/+1td31qdO1zf+Xw+HnzwQXr27ElMTAwZGRnceOON7NixI6IO9V3Vv3cHuvPOO7Esi+eeey7iffXdoftu1apVXHbZZSQkJBATE8OAAQPYsmVL+Hhj/dt7pL4rKipi7NixtGjRgqioKLp168Yrr7wSUaax9t1TTz3FgAEDiIuLo2nTpowYMYI1a9ZElKmtvvn+++/p168fbrebDh06MH78+Lq+vf2M1Jn58+ebNm3amF69epl77rkn/P6dd95pWrZsab799lvz008/mUGDBpkhQ4aEj/v9ftOjRw8zbNgws2jRIvPFF1+Y1NRU89BDD9XDXRw/ubm5pnXr1mb06NFm3rx5ZuPGjearr74y69evD5d5+umnTUJCgpk0aZJZsmSJueyyy0zbtm1NaWlpuMwFF1xgevfubebOnWt+/PFH06FDBzNy5Mj6uKXj5s9//rNJSUkxU6ZMMZmZmebDDz80sbGx5vnnnw+XUd/t98UXX5iHH37YfPzxxwYwn3zyScTx2uir/Px8k5aWZkaNGmWWL19u3n33XRMVFWX+85//HK/brBOH67u8vDwzbNgw8/7775vVq1ebOXPmmFNPPdWccsopEXWo76r+vavw8ccfm969e5uMjAzzz3/+M+KY+q7qvlu/fr1JTk42DzzwgPn555/N+vXrzaeffmp27doVLtNY//Yeqe9uu+020759ezN9+nSTmZlp/vOf/xi73W4+/fTTcJnG2nfDhw8348aNM8uXLzeLFy82F110kWnVqpUpKioKl6mNvtm4caOJjo42999/v1m5cqV58cUXjd1uN1OnTj0u96lgoI4UFhaajh07mmnTppmhQ4eGg4G8vDzjdDrNhx9+GC67atUqA5g5c+YYY0L/cG02m8nKygqXefnll018fLwpLy8/rvdxPD344IPm9NNPP+TxYDBo0tPTzTPPPBN+Ly8vz7jdbvPuu+8aY4xZuXKlAcyCBQvCZb788ktjWZbZvn173TW+nl188cVmzJgxEe9deeWVZtSoUcYY9d3hHPzHsbb66t///rdJSkqK+Df74IMPms6dO9fxHR0/h3ugrTB//nwDmM2bNxtj1HcVDtV327ZtM82bNzfLly83rVu3jggG1HchVfXdtddea375y18e8hz97Q2pqu+6d+9unnjiiYj3+vXrZx5++GFjjPruQNnZ2QYwP/zwgzGm9vrm97//venevXvEta699lozfPjwur4lY4wxmiZUR+666y4uvvhihg0bFvH+woUL8fl8Ee936dKFVq1aMWfOHADmzJlDz549SUtLC5cZPnw4BQUFrFix4vjcQD2YPHky/fv35+qrr6Zp06b07duX1157LXw8MzOTrKysiL5LSEhg4MCBEX2XmJhI//79w2WGDRuGzWZj3rx5x+9mjrMhQ4bw7bffsnbtWgCWLFnCzJkzufDCCwH13dGorb6aM2cOZ555Ji6XK1xm+PDhrFmzhr179x6nu6l/+fn5WJZFYmIioL47nGAwyA033MADDzxA9+7dKx1X31UtGAzy+eef06lTJ4YPH07Tpk0ZOHBgxHQY/e09tCFDhjB58mS2b9+OMYbp06ezdu1azj//fEB9d6D8/HwAkpOTgdrrmzlz5lR6Xhw+fHi4jrqmYKAOvPfee/z888889dRTlY5lZWXhcrnCfxgrpKWlkZWVFS5z4C9NxfGKYw3Vxo0befnll+nYsSNfffUVv/rVr7j77ruZMGECsP/eq+qbA/uuadOmEccdDgfJyckNuu/+8Ic/cN1119GlSxecTid9+/bl3nvvZdSoUYD67mjUVl811n/HByorK+PBBx9k5MiRxMfHA+q7w/nrX/+Kw+Hg7rvvrvK4+q5q2dnZFBUV8fTTT3PBBRfw9ddfc8UVV3DllVfyww8/APrbezgvvvgi3bp1o0WLFrhcLi644AJeeuklzjzzTEB9VyEYDHLvvfdy2mmn0aNHD6D2+uZQZQoKCigtLa2L24ngqPMrNDJbt27lnnvuYdq0aXg8nvpuzkklGAzSv39//vKXvwDQt29fli9fziuvvMJNN91Uz607sX3wwQe88847TJw4ke7du7N48WLuvfdeMjIy1HdSL3w+H9dccw3GGF5++eX6bs4Jb+HChTz//PP8/PPPWJZV3805qQSDQQAuv/xy7rvvPgD69OnD7NmzeeWVVxg6dGh9Nu+E9+KLLzJ37lwmT55M69atmTFjBnfddRcZGRmVPq1uzO666y6WL1/OzJkz67sptU4jA7Vs4cKFZGdn069fPxwOBw6Hgx9++IEXXngBh8NBWloaXq+XvLy8iPN27dpFeno6AOnp6ZVWole8rijTEDVr1oxu3bpFvNe1a9dwNoiKe6+qbw7su+zs7Ijjfr+f3NzcBt13DzzwQHh0oGfPntxwww3cd9994dEp9V311VZfNdZ/x7A/ENi8eTPTpk0LjwqA+u5QfvzxR7Kzs2nVqlX4b8fmzZv57W9/S5s2bQD13aGkpqbicDiO+PdDf3srKy0t5f/9v//HP/7xDy699FJ69erF2LFjufbaa3n22WcB9R3A2LFjmTJlCtOnT6dFixbh92urbw5VJj4+nqioqNq+nUoUDNSyc889l2XLlrF48eLwV//+/Rk1alT4e6fTybfffhs+Z82aNWzZsoXBgwcDMHjwYJYtWxbxP/2KP6gH/8+uITnttNMqpexau3YtrVu3BqBt27akp6dH9F1BQQHz5s2L6Lu8vDwWLlwYLvPdd98RDAYZOHDgcbiL+lFSUoLNFvnP2W63hz8xU99VX2311eDBg5kxYwY+ny9cZtq0aXTu3JmkpKTjdDfHX0UgsG7dOr755htSUlIijqvvqnbDDTewdOnSiL8dGRkZPPDAA3z11VeA+u5QXC4XAwYMOOzfj1NOOUV/e6vg8/nw+XyH/fvRmPvOGMPYsWP55JNP+O6772jbtm3E8drqm8GDB0fUUVGmoo46d1yWKTdyB2YTMiaUhqpVq1bmu+++Mz/99JMZPHiwGTx4cPh4RRqq888/3yxevNhMnTrVNGnS5KRP0XUk8+fPNw6Hw/z5z38269atM++8846Jjo42b7/9drjM008/bRITE82nn35qli5dai6//PIqUz727dvXzJs3z8ycOdN07NixQabHPNBNN91kmjdvHk4t+vHHH5vU1FTz+9//PlxGfbdfYWGhWbRokVm0aJEBzD/+8Q+zaNGicMab2uirvLw8k5aWZm644QazfPly895775no6OiTPsXj4frO6/Wayy67zLRo0cIsXrzY7Ny5M/x1YEYR9V3Vv3cHOzibkDHqu0P13ccff2ycTqd59dVXzbp168KpGX/88cdwHY31b++R+m7o0KGme/fuZvr06Wbjxo1m3LhxxuPxmH//+9/hOhpr3/3qV78yCQkJ5vvvv4/4/1lJSUm4TG30TUVq0QceeMCsWrXKvPTSS0ot2tAcHAyUlpaaX//61yYpKclER0ebK664wuzcuTPinE2bNpkLL7zQREVFmdTUVPPb3/7W+Hy+49zy4++zzz4zPXr0MG6323Tp0sW8+uqrEceDwaB55JFHTFpamnG73ebcc881a9asiSiTk5NjRo4caWJjY018fLy5+eabTWFh4fG8jeOuoKDA3HPPPaZVq1bG4/GYdu3amYcffjjiAUx9t9/06dMNUOnrpptuMsbUXl8tWbLEnH766cbtdpvmzZubp59++njdYp05XN9lZmZWeQww06dPD9ehvqv69+5gVQUD6rtD993rr79uOnToYDwej+ndu7eZNGlSRB2N9W/vkfpu586dZvTo0SYjI8N4PB7TuXNn8/e//90Eg8FwHY217w71/7Nx48aFy9RW30yfPt306dPHuFwu065du4hr1DXLmAO2KBURERERkUZDawZERERERBopBQMiIiIiIo2UggERERERkUZKwYCIiIiISCOlYEBEREREpJFSMCAiIiIi0kgpGBARERERaaQUDIiIiIiINFIKBkREREREGikFAyIiIiIijZSCARERERGRRkrBgIiIiIhII6VgQERERESkkVIwICIiIiLSSCkYEBERERFppBQMiIiIiIg0UgoGREREREQaKQUDIiIiIiKNlIIBEREREZFGSsGAiIiIiEgjpWBARERERKSRUjAgIiIiItJIKRgQEREREWmkFAyIiIiIiDRSCgZERERERBopBQMiIiIiIo2UggERERERkUZKwYCIiIiISCOlYEBEREREpJFSMCAiIiIi0kgpGBARERERaaQUDIiIiIiINFIKBkREREREGikFAyIiIiIijZSCARERERGRRkrBgIiIiIhII6VgQERERESkkVIwICIiIiLSSCkYEBERERFppBQMiIiIiIg0UgoGREREREQaKQUDIiIiIiKNlIIBEREREZFGSsGAiIiIiEgjpWBARERERKSRUjAgIiIiItJIKRgQEREREWmkFAyIiIiIiDRSCgZERERERBopBQMiIiIiIo2UggERERERkUZKwYCIiIiISCOlYEBEREREpJFSMCAiIiIi0kgpGBARERERaaQUDIiIiIiINFIKBkREREREGikFAyIiIiIijZSCARERERGRRkrBgIiIiIhII6VgQERERESkkVIwICIiIiLSSCkYEBERERFppBQMiIiIiIg0UgoGREREREQaKQUDIiIiIiKNlIIBEREREZFGSsGAiIiIiEgj5ajvBtSnYDDIjh07iIuLw7Ks+m6OiIiIiEiNGWMoLCwkIyMDm+3wn/036mBgx44dtGzZsr6bISIiIiJS67Zu3UqLFi0OW6ZRBwNxcXFAqKPi4+PruTUiIiIiIjVXUFBAy5Ytw8+6h9Oog4GKqUHx8fEKBkRERESkQanONHgtIBYRERERaaQUDIiIiIiINFIKBkREREREGqlGvWZAREREGq9gMIjX663vZogcNafTid1ur5W6FAyIiIhIo+P1esnMzCQYDNZ3U0SOSWJiIunp6TXeK0vBgIiIiDQqxhh27tyJ3W6nZcuWR9yUSeREYoyhpKSE7OxsAJo1a1aj+hQMiIiISKPi9/spKSkhIyOD6Ojo+m6OyFGLiooCIDs7m6ZNm9ZoypBCYREREWlUAoEAAC6Xq55bInLsKgJZn89Xo3oUDIiIiEijVNO51iL1qbZ+fxUMiIiIiIg0UgoGREREREQaKQUDIiIiIhKhTZs2PPfcc+HXlmUxadKkGtVZG3VI7VM2IRERERE5rJ07d5KUlFStso8//jiTJk1i8eLFx1yHHD8KBkREREQaIK/XW2sZk9LT00+IOqT2aZqQiIiINHrGBOvl62icddZZjB07lrFjx5KQkEBqaiqPPPIIxhggNLXnySef5MYbbyQ+Pp7bb78dgJkzZ3LGGWcQFRVFy5YtufvuuykuLg7Xm52dzaWXXkpUVBRt27blnXfeqXTtg6f4bNu2jZEjR5KcnExMTAz9+/dn3rx5jB8/nv/7v/9jyZIlWJaFZVmMHz++yjqWLVvGOeecQ1RUFCkpKdx+++0UFRWFj48ePZoRI0bw7LPP0qxZM1JSUrjrrrtqnEpTImlkQERERBo1Y4Ls3LmoXq7drFlfLKv6n81OmDCBW265hfnz5/PTTz9x++2306pVK2677TYAnn32WR599FEee+wxADZs2MAFF1zAn/70J9544w12794dDijGjRsHhB66d+zYwfTp03E6ndx9993h3W2rUlRUxNChQ2nevDmTJ08mPT2dn3/+mWAwyLXXXsvy5cuZOnUq33zzDQAJCQmV6iguLmb48OEMHjyYBQsWkJ2dza233srYsWPDwQPA9OnTadasGdOnT2f9+vVce+219OnTJ3y/UnMKBk4GQR/YnPXdChEREalnLVu25J///CeWZdG5c2eWLVvGP//5z/DD8TnnnMNvf/vbcPlbb72VUaNGce+99wLQsWNHXnjhBYYOHcrLL7/Mli1b+PLLL5k/fz4DBgwA4PXXX6dr166HbMPEiRPZvXs3CxYsIDk5GYAOHTqEj8fGxuJwOA47LWjixImUlZXx5ptvEhMTA8C//vUvLr30Uv7617+SlpYGQFJSEv/617+w2+106dKFiy++mG+//VbBQC1SMHACMsbg85WAv4SSub/Gv+UjkjqNxj5kXH03TUREpMGxLBvNmvWtt2sfjUGDBkVsNjV48GD+/ve/h3dV7t+/f0T5JUuWsHTp0oipP8YYgsEgmZmZrF27FofDwSmnnBI+3qVLFxITEw/ZhsWLF9O3b99wIHAsVq1aRe/evcOBAMBpp51GMBhkzZo14WCge/fu2O32cJlmzZqxbNmyY76uVKZg4ARUXJxNwZQBULI1/F7RuvEkDHpVIwQiIiJ14Ggfyk9UBz5cQ2hKzx133MHdd99dqWyrVq1Yu3btUV8jKirqmNt3tJzOyOcey7IIBo9urYUcXsP4zW9gyop3RgQCACUB8M/VkJiIiEhjNm/evIjXc+fOpWPHjhGfnh+oX79+rFy5kg4dOlT6crlcdOnSBb/fz8KFC8PnrFmzhry8vEO2oVevXixevJjc3Nwqj7tcrvBIxaF07dqVJUuWRCxknjVrFjabjc6dOx/2XKldCgZOMMFgAF8wCNEtSXNDhgfcNjBA4boJofUDIiIi0iht2bKF+++/nzVr1vDuu+/y4osvcs899xyy/IMPPsjs2bMZO3YsixcvZt26dXz66aeMHTsWgM6dO3PBBRdwxx13MG/ePBYuXMitt9562E//R44cSXp6OiNGjGDWrFls3LiR//3vf8yZMwcIZTXKzMxk8eLF7Nmzh/Ly8kp1jBo1Co/Hw0033cTy5cuZPn06v/nNb7jhhhvCU4Tk+FAwcIIpLc3BGIPjnC+xX1sM13mJ73hj6FgAymfdXM8tFBERkfpy4403Ulpayqmnnspdd93FPffcE04hWpVevXrxww8/sHbtWs444wz69u3Lo48+SkZGRrjMuHHjyMjIYOjQoVx55ZXcfvvtNG3a9JB1ulwuvv76a5o2bcpFF11Ez549efrpp8OjE1dddRUXXHABZ599Nk2aNOHdd9+tVEd0dDRfffUVubm5DBgwgF/84hece+65/Otf/6pB78ixsExFctpGqKCggISEBPLz84mPj6/v5lBeXkhOTmjuXlxcBnFxzUIHgj7y3nJREgCHBU27jIbBWkwsIiJyLMrKysjMzKRt27Z4PJ76bk61nXXWWfTp04fnnnuuvpsiJ4DD/R4fzTOuRgZOAIGAj927V4YDgejolP2BAIDNSXzHG7EAvwH/hvGaLiQiIiIiNaZgoJ4ZY8jNXY/PVwqA3e4kPr5lpXK2IRNwtboSgPIW1yqrkIiIiIjUmFKL1rOysjx8vhIsyyI+vgVudwI2W9UZAdyD/k15wEvZpveJmROlqUIiIiKNyPfff1/fTZAGSCMD9ay4eBcAsbHpxMQ0xeFwH7KsxxWDtX0K5UEoWT8e/4/XU16agwlUXqUvIiIiInIkCgbqkc9XgtdbjGVZxMQcetV+BYcrlti21wCQ54Psde+S824qu9/0EJytLEMiIiIicnSOOhiYMWMGl156KRkZGViWxaRJk8LHfD4fDz74ID179iQmJoaMjAxuvPFGduzYEVFHbm4uo0aNIj4+nsTERG655RaKiooiyixdupQzzjgDj8dDy5Yt+dvf/lapLR9++CFdunTB4/HQs2dPvvjii6O9nXpVUrIHAI8nEZutejO2Ys96j5jWV0S85zehkQItKhYRERGRo3HUwUBxcTG9e/fmpZdeqnSspKSEn3/+mUceeYSff/6Zjz/+mDVr1nDZZZdFlBs1ahQrVqxg2rRpTJkyhRkzZkTkyC0oKOD888+ndevWLFy4kGeeeYbHH3+cV199NVxm9uzZjBw5kltuuYVFixYxYsQIRowYwfLly4/2luqFMUFKS0M790VHp1b7PMuySDj3Y9JT2tPMDQn7YoiyjCu0qFhEREREjkqN9hmwLItPPvmEESNGHLLMggULOPXUU9m8eTOtWrVi1apVdOvWjQULFtC/f38Apk6dykUXXcS2bdvIyMjg5Zdf5uGHHyYrKwuXywXAH/7wByZNmsTq1asBuPbaaykuLmbKlCnhaw0aNIg+ffrwyiuvVKv99bnPQElJDnl5m3A43DRt2uPYKvGXEDCGXd9dB9unkN5lNLYhWlQsIiJyOCfrPgMiBzpp9hnIz8/HsiwSExMBmDNnDomJieFAAGDYsGHYbDbmzZsXLnPmmWeGAwGA4cOHs2bNGvbu3RsuM2zYsIhrDR8+PLwVdlXKy8spKCiI+KovFVOEoqJSjr0SRzR2uwvnzlBAVKypQiIiIiJyFOo0GCgrK+PBBx9k5MiR4agkKyur0hbXDoeD5ORksrKywmXS0tIiylS8PlKZiuNVeeqpp0hISAh/tWxZOZ//8eLxJOJweI5qilCVbE5i240CoDgAwXmH3pJcRERE5Gg8/vjj9OnTp1brHD9+fPhD4hPB999/j2VZ5OXlAbXTvhPtHg+nzoIBn8/HNddcgzGGl19+ua4uc1Qeeugh8vPzw19bt26tt7bExqbRtGl37Paaz/P3nPYGDguCBorXjdfogIiIiMgxuvbaa1m7dm21y7dp04bnnnuuRnXUpzoJBioCgc2bNzNt2rSIuUrp6elkZ2dHlPf7/eTm5pKenh4us2vXrogyFa+PVKbieFXcbjfx8fERXw2BZXcR137/6ICZd0c9t0hERETk+DHG4Pf7a6WuqKioSrNY6qOO46XWg4GKQGDdunV88803pKREzokfPHgweXl5LFy4MPzed999RzAYZODAgeEyM2bMwOfb/wn3tGnT6Ny5M0lJSeEy3377bUTd06ZNY/DgwbV9SycFz2lvYNs3OuDbME6jAyIiIg3MWWedxW9+8xvuvfdekpKSSEtL47XXXqO4uJibb76ZuLg4OnTowJdffhk+JxAIcMstt9C2bVuioqLo3Lkzzz//fES933//PaeeeioxMTEkJiZy2mmnsXnz5irbsGHDBtq1a8fYsWMxxlBeXs7vfvc7mjdvTkxMDAMHDqy0U/L48eNp1aoV0dHRXHHFFeTk5Bz2Pjdt2oRlWbz33nsMGTIEj8dDjx49+OGHHyLabFkWX375Jaeccgput5uZM2cSDAZ56qmnwvfbu3dvPvroo4j6v/jiCzp16kRUVBRnn302mzZtqtTeg6f4fPbZZwwYMACPx0NqaipXXHFF+GeyefNm7rvvPizLwrKsQ9bx8ssv0759e1wuF507d+att96KOG5ZFv/973+54ooriI6OpmPHjkyePPmwfVUrzFEqLCw0ixYtMosWLTKA+cc//mEWLVpkNm/ebLxer7nssstMixYtzOLFi83OnTvDX+Xl5eE6LrjgAtO3b18zb948M3PmTNOxY0czcuTI8PG8vDyTlpZmbrjhBrN8+XLz3nvvmejoaPOf//wnXGbWrFnG4XCYZ5991qxatco89thjxul0mmXLllX7XvLz8w1g8vPzj7YbTkg53/7CbH8dU/j9dfXdFBERkRNWaWmpWblypSktLa2dCgPe2qnnCIYOHWri4uLMk08+adauXWuefPJJY7fbzYUXXmheffVVs3btWvOrX/3KpKSkmOLiYmOMMV6v1zz66KNmwYIFZuPGjebtt9820dHR5v333zfGGOPz+UxCQoL53e9+Z9avX29Wrlxpxo8fbzZv3myMMeaxxx4zvXv3NsYYs2TJEpOenm4efvjhcJtuvfVWM2TIEDNjxgyzfv1688wzzxi3223Wrl1rjDFm7ty5xmazmb/+9a9mzZo15vnnnzeJiYkmISHhkPeZmZlpANOiRQvz0UcfmZUrV5pbb73VxMXFmT179hhjjJk+fboBTK9evczXX39t1q9fb3Jycsyf/vQn06VLFzN16lSzYcMGM27cOON2u833339vjDFmy5Ytxu12m/vvv9+sXr3avP322yYtLc0AZu/evcYYY8aNGxfRvilTphi73W4effRRs3LlSrN48WLzl7/8xRhjTE5OjmnRooV54oknws+8VdXx8ccfG6fTaV566SWzZs0a8/e//93Y7Xbz3XffhctU3PPEiRPNunXrzN13321iY2NNTk5Olf10uN/jo3nGPepgoKLzD/666aabwj+8qr6mT58eriMnJ8eMHDnSxMbGmvj4eHPzzTebwsLCiOssWbLEnH766cbtdpvmzZubp59+ulJbPvjgA9OpUyfjcrlM9+7dzeeff35U99LQgoGiol1m+7a5Zs+etfXdFBERkRNWrQYDc8YY8w6h/9axoUOHmtNPPz382u/3m5iYGHPDDTeE39u5c6cBzJw5cw5Zz1133WWuuuoqY0zomQwIPywfrCIYmDVrlklKSjLPPvts+NjmzZuN3W4327dvjzjn3HPPNQ899JAxxpiRI0eaiy66KOL4tddeW61g4MBnP5/PZ1q0aGH++te/GmP2P49OmjQpXKasrMxER0eb2bNnR9R3yy23hD90fuihh0y3bt0ijj/44IOHDQYGDx5sRo0adcj2tm7d2vzzn/+MeO/gOoYMGWJuu+22iDJXX311RN8A5o9//GP4dVFRkQHMl19+WeV1aysYqN62twc466yzMIfZmuBwxyokJyczceLEw5bp1asXP/7442HLXH311Vx99dVHvF5j4XLFgeXA6y3CGBMeqhIREZE6EPTBxjdC3298A059pc43AO3Vq1f4e7vdTkpKCj179gy/V5Fp8cD1mS+99BJvvPEGW7ZsobS0FK/XG84QlJyczOjRoxk+fDjnnXcew4YN45prrqFZs2bh87ds2cJ5553Hn//8Z+69997w+8uWLSMQCNCpU6eINpaXl4enia9atSo8pabC4MGDmTp16hHv9cCp3w6Hg/79+7Nq1aqIMgemql+/fj0lJSWcd955EWW8Xi99+/YNt6diWnpV16nK4sWLue22247Y3sNZtWpVxAa7AKeddlqlKVsH/nxjYmKIj4+vtNa2th11MCAnLqczCpvNQTDox+crweWKqe8miYiINFw2J7QbEwoE2o2p80AAwOmMvIZlWRHvVXwQGAwGAXjvvff43e9+x9///ncGDx5MXFwczzzzTHhvJ4Bx48Zx9913M3XqVN5//33++Mc/Mm3aNAYNGgRAkyZNyMjI4N1332XMmDHhBCxFRUXY7XYWLlyI3W6PaFdsbGzt33wVYmL2P+sUFRUB8Pnnn9O8efOIcm63+5ivERUVdcznHq2qfr4VP8u6Uuebjsnx5XKF/vF5vYX13BIREZFGYNDrcJ039N8T0KxZsxgyZAi//vWv6du3Lx06dGDDhg2VyvXt25eHHnqI2bNn06NHj4gZHFFRUUyZMgWPx8Pw4cMpLCwMnxMIBMjOzqZDhw4RXxXZHbt27RoReADMnTu3Wm0/sJzf72fhwoV07dr1kOW7deuG2+1my5YtldpTsbdU165dmT9//lG1p1evXpWS1hzI5XIRCAQOW0fXrl2ZNWtWxHuzZs2iW7duhz3veFAw0MC43XEAlJcrGBARETkujsOIwLHq2LEjP/30E1999RVr167lkUceYcGCBeHjmZmZPPTQQ8yZM4fNmzfz9ddfs27dukoP3TExMXz++ec4HA4uvPBCioqK6NSpE6NGjeLGG2/k448/JjMzk/nz5/PUU0/x+eefA4RHHJ599lnWrVvHv/71r2pNEYLQ9KZPPvmE1atXc9ddd7F3717GjBlzyPJxcXH87ne/47777mPChAls2LCBn3/+mRdffJEJEyYAcOedd7Ju3ToeeOAB1qxZw8SJExk/fvxh2/HYY4/x7rvv8thjj7Fq1SqWLVvGX//61/DxNm3aMGPGDLZv386ePXuqrOOBBx5g/PjxvPzyy6xbt45//OMffPzxx/zud7+rVl/UJQUDDYzLFQoGKtYNiIiISON1xx13cOWVV3LttdcycOBAcnJy+PWvfx0+Hh0dzerVq7nqqqvo1KkTt99+O3fddRd33FF5z6LY2Fi+/PJLjDFcfPHFFBcXM27cOG688UZ++9vf0rlzZ0aMGMGCBQto1aoVAIMGDeK1117j+eefp3fv3nz99df88Y9/rFbbn376aZ5++ml69+7NzJkzmTx5MqmpqYc958knn+SRRx7hqaeeomvXrlxwwQV8/vnntG3bFoBWrVrxv//9j0mTJtG7d29eeeUV/vKXvxy2zrPOOosPP/yQyZMn06dPH84555yI0YUnnniCTZs20b59e5o0aVJlHSNGjOD555/n2WefpXv37vznP/9h3LhxnHXWWdXqi7pkmUb8xFhQUEBCQgL5+fkNZgMygKysJQSDflJTu2jdgIiIyEHKysrIzMykbdu2eDye+m6OHGTTpk20bduWRYsWhRc6S2WH+z0+mmdcjQw0QFo3ICIiIiLVoWCgAdK6ARERERGpDqUWbYAOXjeg/QZERETkZNGmTRutezyONDLQAFXsN2BMEJ+vpL6bIyIiIiInKAUDDVTFuoHy8oJ6bomIiIiInKgUDDRQHk8CAKWlufXcEhERERE5USkYaKA8niQsy4bfX4bXW1TfzRERERGRE5CCgQbKZrMTFZUMQElJTj23RkRERERORAoGGrCKYKCsbK9W5YuIiJzkzjrrLO69995qlf3++++xLIu8vLwaXbNNmzY899xzNapDTmwKBhowlysWu91JMBiguDi7vpsjIiIiIicYBQMNmGVZxMSkAVBQsA2fr7SeWyQiIiIiJxIFAw1cbGyaMguJiIg0MG+99Rb9+/cnLi6O9PR0rr/+erKzK88CmDVrFr169cLj8TBo0CCWL18ecXzmzJmcccYZREVF0bJlS+6++26Ki4uP123ICUDBQCNQsXagvDy/nlsiIiJy4jHGUOL118vXsa7p8/l8PPnkkyxZsoRJkyaxadMmRo8eXancAw88wN///ncWLFhAkyZNuPTSS/H5fABs2LCBCy64gKuuuoqlS5fy/vvvM3PmTMaOHVuT7pSTjKO+GyB1z+1OwLIsfL5SfL5SnM6o+m6SiIjICaPUF6Dbo1/Vy7VXPjGcaNfRP46NGTMm/H27du144YUXGDBgAEVFRcTGxoaPPfbYY5x33nkATJgwgRYtWvDJJ59wzTXX8NRTTzFq1KjwouSOHTvywgsvMHToUF5++WU8Hk/Nbk5OChoZaARsNjseTyIARQVbIOir3waJiIhIjSxcuJBLL72UVq1aERcXx9ChQwHYsmVLRLnBgweHv09OTqZz586sWrUKgCVLljB+/HhiY2PDX8OHDycYDJKZmXn8bkbqlUYGGomYmKaUzr+P0u2TCdogqdON2IZMqO9miYiI1Lsop52VTwyvt2sfreLiYoYPH87w4cN55513aNKkCVu2bGH48OF4vd5q11NUVMQdd9zB3XffXelYq1atjrpdcnJSMHASKC73U+IN0CTOfcx1uBxu4nZNpggoD8LetW+SAnBgQBD0gc1Z0+aKiIicVCzLOqapOvVl9erV5OTk8PTTT9OyZUsAfvrppyrLzp07N/xgv3fvXtauXUvXrl0B6NevHytXrqRDhw7Hp+FyQtI0oRPcsm35DH3me856Zjo782uQGtTmJK7TGFJdYBEKCIrXvwlzbgYg99ur2TXBRXDfaxERETkxtWrVCpfLxYsvvsjGjRuZPHkyTz75ZJVln3jiCb799luWL1/O6NGjSU1NZcSIEQA8+OCDzJ49m7Fjx7J48WLWrVvHp59+qgXEjYyCgRPc7z5cwp6icoq9Ad6dv7VmlQ16Hef1XuLbXQNAcQDIHE/QW0jZ5o8IGChfP15rCkRERE5gTZo0Yfz48Xz44Yd069aNp59+mmeffbbKsk8//TT33HMPp5xyCllZWXz22We4XC4AevXqxQ8//MDatWs544wz6Nu3L48++igZGRnH83aknlnmWHNaNQAFBQUkJCSQn59PfHx8fTenkqz8MgY99W34dVq8mzl/OBebzapRvcYEyfp6BGb7ZzTp9EuCA/5Nzve/hO2TiW7zCxLP+bCmTRcRETlhlZWVkZmZSdu2bZUxR05ah/s9Pppn3JNnglwjNHvDHgC6Notnw+4idhWUs21vKa1SomtUr2XZ8Jz6HKXzDSUb3sbu90HPR4Eg3s0fwdxbYNDrtXAHIiIiInIi0zShE9i0lbsAGNqpCe1SYwDYsLuoVuqO9iTA9ikUB6Bg4/uw5BHYPgW/Af/6NzRVSERERKQRUDBwgvpk0Ta+XJ6FZcEFPdJp3yS0gcj67NoJBtzueDwH/vR3fokVHcpI4G15nbIKiYiIiDQCCgZOQP5AkL9/vRaAu8/pSJ+WibRvGgoGamtkAJuTxM6jSXRCvCP0FevdCs0vpnzTe6GpQiIiIiLSoCkYOAF9uTyLbXtLSY5x8auz2gPQvklomlBtjQwA2AaPI3qUl9iOo4l1gLvtKNj+OeVBYKOmComIiIg0dFpAfAKaujwLgJGntsSzb2fCDvtGBtZlF2GMwbJqllEozOaEweNg4Ks4LQdWaRHBbZ/ia30jTk0VEhGRBqwRJ1SUBiAYDNZKPQoGTjCBoGHWvixC53RJC7/foWksTrtFfqmPbXtLaZlcs4xCldicWIC7/7OUdX+I8rjmKBQQEZGGyOl0YlkWu3fvpkmTJrX3AZvIcWCMwev1snv3bmw2W3jfiGOlYOAEs3x7PnklPuI8Dnq3SAi/73bY6ZIez7Lt+Szdll/7wUDFddzxlC34LeU7JxPbZYxSjIqISINjt9tp0aIF27ZtY9OmTfXdHJFjEh0dTatWrbDZajbrX8HACaYineiQ9ik47JE/3F4tEvYFA3lc3KtZnVzf5fDA9sl4AbPhDaxTX1FmIRERaXBiY2Pp2LEjPp/Wx8nJx26343A4amVUS8HACSQYNHyyaDsAl/SqvBV47xaJvDNvC0u25dVZG5zueOwtRxDYOglvq1G4FQiIiEgDZbfbsdvt9d0MkXqlYOAEYYzh2a/XsD2vlDiPg/O6pVUq07dVIgCLt+ZR7g+wamchz32zFn/A8Ndf9KJ5YlSttMXV/x+UBv14M9/B7XRrqpCIiIhIA6XUoieID37ayr+/3wDAr8/qEM4idKAOTWNJjXVR5gvy9YpdjBm/gO/X7Gbm+j1c+uJMxs/KrJW2uJ0e2D5FKUZFREREGjgFA/Xsu9W7GD1uPo98ugKAB4Z3Du8tcDDLshjcPhWA37y7iNxiLy67DZsFucVeHv9sJcu359e4TS5PEjS/DF8QTNubtWZAREREpIFSMFCPisv93PXOIr5fsxuvP8hpHVK448x2hz3ntPYp4e+jnHa+uOcMZj54DjGu0EjC58t21rhdDocHW+//wwyfi7/fP2tcn4iIiIicmBQM1KNvVu2i1BegVXI0X95zBm/fMrBSBqGDXd6nOaOHtKF7RjzPXt2bDk1jyUiM4q+/6AXA50t31somKk5nDCz/C973E2HuLTWuT0REREROPFpAXI8mL94BwIi+zenaLL5a50S57Dx+WfdK75/duSl2m8WW3BJ2FZSTnuCpUdtcDhfl2yfjsxNaN6AUoyIiIiINjkYG6kkwaJifmQvA8O6VMwcdrRi3g45NYwFYWgupR53uhPC6AdqNUSAgIiIi0gApGKgnm3NLKCz343bY6JwWVyt19tq3Y/GyWlhE7HRGQ89H8Z8/DzPwtRrXJyIiIiInHgUD9aTigb1rs/gjrhOorp4tEgFYuq3mwYDd7sJmc2Aw+HylNa5PRERERE48CgbqSUUK0B7Nq7dWoDp6Nd8/MlAri4hXPAlfDcI397Ya1yUiIiIiJx4FA/Vk2b5P73vue4CvDZ3T43DYLHKLvezIL6tZZUEfzm3/A8Cf+a42HhMRERFpgBQM1JOhnZtwducm9G2VVGt1epx2OqeH1h8sq+kiYpsTR9vrAfC3uEoLiEVEREQaIKUWrSd3Dm3PnUOr3mm4Jnq1SGDFjgKWbsvngh7NalSXc/Br0P5ufPaapSkVERERkROTRgYamJ7NEwFYtCWvxnU5HB6wHAQDZQSD/hrXJyIiIiInFgUDDcyQ9ikAzM3MYXNOcY3qsiwbjhV/Di0inj2mNponIiIiIicQBQMNTJvUGM7q3ARjYMLszTWrLOjDueMTAMo3vqVFxCIiIiINjIKBBmj0kDYAfPjTVorKazC9x+Ykqt0oAEqbjcBYWmIiIiIi0pAoGGiAzuzYhHapMRSW+/n45201qst9+lvYLlhAoPsfKS8vqKUWioiIiMiJQMFAA2SzWfxyUGsAPlm0vUZ1WZZFVEwaAKWlOTVum4iIiIicOBQMNFCX9GqGZYWyCu3IK61RXdHRoUXJpaV7yclZS1HRrtpoooiIiIjUMwUDDVTTeA8DWicDMHV5Vo3qcjqjcbliACgvL6SgYBuBgLfGbRQRERGR+qVgoAE7p2tTAOZsrPn0nri45hGvi4uza1yniIiIiNQvBQMN2KltQyMDCzblEgyaGtXldseRmNiGqKhQnaWle2vcPhERERGpXwoGGrCezROIdtnJK/GxNruwxvVFR6eQmNgay7IIBLz4/eW10EoRERERqS8KBhowp91Gv1ZJACzYVDuf5FuWDacztH7A6615gCEiIiIi9UfBQAPXu2UCAMu35ddanW53HBBaTCwiIiIiJy8FAw1cz+aJACzdXnvBgMsVC4DXW1RrdYqIiIjI8adgoIHr1SI0MrB2VyFlvkCt1FkxTSgQ8BII+GqlThERERE5/hQMNHDNEjykxroIBA0rdxbUSp02mx2nMwoAn6+4VuoUERERkeNPwUADZ1kWPZuHRgeW1eK6gYrRAa0bEBERETl5HXUwMGPGDC699FIyMjKwLItJkyZFHDfG8Oijj9KsWTOioqIYNmwY69atiyiTm5vLqFGjiI+PJzExkVtuuYWiosj550uXLuWMM87A4/HQsmVL/va3v1Vqy4cffkiXLl3weDz07NmTL7744mhvp1Ho2SIRgGW1uG7A4wnVWVqaizE128NAREREROrHUQcDxcXF9O7dm5deeqnK43/729944YUXeOWVV5g3bx4xMTEMHz6csrKycJlRo0axYsUKpk2bxpQpU5gxYwa33357+HhBQQHnn38+rVu3ZuHChTzzzDM8/vjjvPrqq+Eys2fPZuTIkdxyyy0sWrSIESNGMGLECJYvX360t9Tg9aqDkQG3Ox673UUw6KesLK/W6hURERGR48cyNfhY17IsPvnkE0aMGAGERgUyMjL47W9/y+9+9zsA8vPzSUtLY/z48Vx33XWsWrWKbt26sWDBAvr37w/A1KlTueiii9i2bRsZGRm8/PLLPPzww2RlZeFyuQD4wx/+wKRJk1i9ejUA1157LcXFxUyZMiXcnkGDBtGnTx9eeeWVarW/oKCAhIQE8vPziY+PP9ZuOOHtKihj4F++xWbB8v8bTrTLUSv15udvobh4N7Gx6cTHN6+VOkVERESkZo7mGbdW1wxkZmaSlZXFsGHDwu8lJCQwcOBA5syZA8CcOXNITEwMBwIAw4YNw2azMW/evHCZM888MxwIAAwfPpw1a9awd+/ecJkDr1NRpuI6VSkvL6egoCDiqzFIi/fQIimKoIGJ87ZQUFY7GYAcDg8AgYB2IhYRERE5GdVqMJCVlQVAWlpaxPtpaWnhY1lZWTRt2jTiuMPhIDk5OaJMVXUceI1Dlak4XpWnnnqKhISE8FfLli2P9hZPWlf1awHAnz5fxaUvzqS43F/jOu12NwB+f9kRSoqIiIjIiahRZRN66KGHyM/PD39t3bq1vpt03FzdvwV2mwXA5pwSXvxufY3rrBgZ8Ps1MiAiIiJyMqrVYCA9PR2AXbt2Rby/a9eu8LH09HSys7Mjjvv9fnJzcyPKVFXHgdc4VJmK41Vxu93Ex8dHfDUWLZKiefuWgfxyUCsA3pm7ucabkNntLizLwpgggYC3NpopIiIiIsdRrQYDbdu2JT09nW+//Tb8XkFBAfPmzWPw4MEADB48mLy8PBYuXBgu89133xEMBhk4cGC4zIwZM/D59s9tnzZtGp07dyYpKSlc5sDrVJSpuI5UNrh9Ck9c1oMWSVEUlvv5euWuI590GJZlaaqQiIiIyEnsqIOBoqIiFi9ezOLFi4HQouHFixezZcsWLMvi3nvv5U9/+hOTJ09m2bJl3HjjjWRkZIQzDnXt2pULLriA2267jfnz5zNr1izGjh3LddddR0ZGBgDXX389LpeLW265hRUrVvD+++/z/PPPc//994fbcc899zB16lT+/ve/s3r1ah5//HF++uknxo4dW/NeacBsNosr+4Yy/3y2ZEeN63O5QpuPlZXVXtpSERERETk+jjoY+Omnn+jbty99+/YF4P7776dv3748+uijAPz+97/nN7/5DbfffjsDBgygqKiIqVOn4vF4wnW88847dOnShXPPPZeLLrqI008/PWIPgYSEBL7++msyMzM55ZRT+O1vf8ujjz4asRfBkCFDmDhxIq+++iq9e/fmo48+YtKkSfTo0eOYO6OxOKdraOH1/MxcgsGabRjm8YRGasrK9ta4XSIiIiJyfNVon4GTXWPZZ+BgvkCQXo9/TakvwNf3nUmntDiMMTw5ZRU2Cx6+uCuWZVWrLmMMu3YtIRgMkJraGZcrto5bLyIiIiKHU2/7DMjJwWm30bdVIhAaHQBYsGkvb8zK5L8zM/l5S/U/5bcsC7c7tMNxaalGB0REREROJgoGGqlB7VIA+Nd369maW8JbczeHj70zb8tR1RUVVTFVKK/W2iciIiIidU/BQCN105A2tG8SQ1ZBGWf8bXrEYuIvlu2k1Fv9tKNudzyWZSMQ8CqrkIiIiMhJRMFAI5UQ5eTtWwfSp2Vi+L0HhnemRVIUZb4gP6zdXe26LMsWzirk9RbVdlNFREREpI446rsBUn+aJUTx8a+GsGZXIbFuBy2To9lb7OW/MzOZunwnF/Q49AZuB3M6YygvL8TrLSY6OrUOWy0iIiIitUUjA42czWbRtVk8LZOjAbiwZygA+HrlLorL/dWupyKLkEYGRERERE4eCgYkQr9WSbRNjaHEG+DzZTurfV7FNCG/v4xAwHeE0iIiIiJyIlAwIBEsy+IXp7QAYPLi6u9QbLM5cDpDowvl5QV10jYRERERqV0KBqSSi3o2A2BeZg6FZdX/lN/tDm1q4fUW1km7RERERKR2KRiQStqmxtAuNQZfwDBz3Z5qn1cRDJSV5WNMsK6aJyIiIiK1RMGAVOnsLk0BmLWh+sGAyxWL3e4iGPRTUpJTV00TERERkVqiYECq1D0j9Cn/+uzqZweyLCucVjQ/fwulpbl10jYRERERqR0KBqRK7ZqEUoVu3F18VOfFxqaF04wWFWXVertEREREpPYoGJAqtWsSShWaXVh+VIuILctGcnJ7LMvC5yvF5yutqyaKiIiISA0pGJAqxXucNIlzA0c/OmCzOcKLicvL82u9bSIiIiJSOxQMyCG13zc6sGH30e8qXLHnQCDgrdU2iYiIiEjtUTAgh9QlPfTp/qz1R58ZyGZzAgoGRERERE5kCgbkkC7pFdp87MvlOynx+o/qXLvdBSgYEBERETmRKRiQQzqldRKtU6Ip8QaYuvzoMgPtDwaqv/hYRERERI4vBQNySJZlcWXfFgD87+dtR3VuRTAQDPq1G7GIiIjICUrBgBzWlf2aAzB7Qw4786ufJtRms2Oz2cH4NVVIRERE5ASlYEAOq2VyNH1aJmIMzD7KhcT25U/AV4MIzL2tjlonIiIiIjXhqO8GyInv1LbJLN6ax6wNe/hi2U4sy6J3iwSuOqUFGYlRVZ8U9OHY/gk+wLvxbdxD3oB9GYZERERE5MSgYECOqF+rJAA+/nl7+L1vVu1ixY4CXrnhlKpPsjnxtB1F6fp3KG12OXEKBEREREROOJomJEfUr3Vile/PXL8Hr//Qi4Pdp0/Aan4p/q2f4v3xl3XUOhERERE5VgoG5Iiaxnnokh4Xfv2XK3qSEuOiqNzPz1v2HvI8G0Gisj4DoHDDOzDn5jpvq4iIiIhUn4IBqZZrB7QMf39K6yTO7NQEgGkrdx36JJuT2A43YAHlQfBvGA9B7TsgIiIicqJQMCDVcmW/FqTFu2mXGkOHprFc1DO0O/GkRdsPO1XIcdqbuFpdCUBZi2u0iFhERETkBKIFxFItCVFOpt0/FLtlYbdZnN25CU3i3OwuLOf7Ndmc3z39kOd6Br9CecBL2aYPiJ0bC4NeP44tFxEREZFD0ciAVFu8x0mMOxQ/Ouw2zu3SFIDlOwoOe57HFQ3bp+ANQnDDG5oqJCIiInKCUDAgx6x1SgwAW3KKD1vO7ozB0eoKAMpbjdJUIREREZEThKYJyTFrlRwNwJbckiOWdQ94Hn/XBymPSuEQ25SJiIiIyHGmkQE5Zq1TjiIYcMfD8r/g/bQjzL0FYwzBoL+umygiIiIih6FgQI5Zq33BwJ4iL0Xlh3+wdzncsH0yfgOBDW9QkLeRXbuWUl5++PUGIiIiIlJ3FAzIMYv3OEmMDs3/33qE0QGbw4NzX4pRb8uRFJfswRhDbu56jDF13lYRERERqUzBgNRIm32LiNdkFR6xrGvAc9D8Evaufxe+GgTLnsAYQ37+5jpupYiIiIhURcGA1MiANkkAzN6w54hl3c4o2D4l/Nq2YzKWCVBSkoPXe/iMRCIiIiJS+xQMSI0M6ZAKwKz1OUec7uOJTiW14yjiHOCxQaoTPJ5EAEpLc+q6qSIiIiJyEAUDUiOntknGabfYnldaraxCrjPeJq7jaJJd4OgwhujY0M7FpaV7tXZARERE5DhTMCA1EuN20LdlaKrQrPXV/HR/8Di4zguDXsflisNudxIM+ikvz6/DloqIiIjIwRQMSI0N6ZACwKz1R143ELZvF2LLsoiKSgagpERThURERESOJwUDUmOn7Vs3MHvDHoLBo5/qUxEMlJcXYEywVtsmIiIiIoemYEBqrE/LRFx2G3tLfGzPKz3q853OaOx2F8YEKS3Nxe8vq4NWioiIiMjBFAxIjTnttvBuxJl7ji1FaEVWoby8zWRnr6Ck5CimHImIiIjIMVEwILWibWpo87FjDQaio1OxrP2/jkUF22qlXSIiIiJyaAoGpFa0q2Ew4HRGkZ7eh/T0PljLn8T/RV/KZ95Qm00UERERkYMoGJBaUTEysPEYgwEIZRayESR656cAFK5/G4K+WmmfiIiIiFSmYEBqRTgY2F1Us4psTmI7jsYCvEHwzr6l5o0TERERkSopGJBa0SktDoBte0vZU1Reo7rsg17FYw99X7bxLY0OiIiIiNQRBQNSK5JiXHRJDwUEczfWcPMwmxNP21EAlDcbEd6gTERERERql4IBqTWD2oV2Ip6zoeY7CbtPn4DV/FJ8WydROuP6GtcnIiIiIpUpGJBaM7h9KBj4bnU2/kDNdhK2ESRm12cA5K1/l/IZ1+P3lxH0Fta4nSIiIiISomBAas3QTk1IiXGxM7+M616dy+7CGqwdsDmJ63ATbhsYIGf9u2S/k8Kut+Mp/V+7WmuziIiISGOmYEBqjcdpZ9Sg1gD8tHkv//xmbY3qs4aMJ7njDVgVbwRKMEBefia+maNqVLeIiIiIKBiQWnbn0HZ0bRYPwNxaWDtgnfYmMW2vDn0P4ZGCog0TlWVIREREpIYUDEitinY5eO+2QVhWaAOy7MKyGtcZd+ZbxDog1QXxjtB7pQEIzL2txnWLiIiINGYKBqTWJUQ76bxv34H5mbk1rs+yu4nvNAanDZztR+Pa91tbtn6CRgdEREREakDBgNSJMzqmAvDhT9tqp8JBr8N1Xhg8Dk/b6wAob36l9iAQ+f/s3Xd8VeX9wPHPOXffJDd7QoBA2BuVLXVVVNyToYg4aqv1px22ttVa22prW9vaOqvIdNYNLooCylQUWTITVkJ2cm9y9zi/P05ySSBAAjcJhO/79crL3HvOec5zEZLne57n+32EEEKIEyDBgGgTN43ugarAsu3lrN9XE5tG6wf+1nEvQZdL8e95i8jKW2LTthBCCCHEaUiCAdEmuqXauXxoDgA/fuVran2xW85jVA2YDixEA2p3zIaQJ2ZtCyGEEEKcTiQYEG3md5cPomuyjX1VXp5YfGJlRptQTcT30kuLusNQNT8OVskMgRBCCCFEa0kwINpMot3Eo1cNBmDuqj0ntgnZIWzjXiKhvrKQLwJ1O2ZLQCCEEEII0UoSDIg2NaFPOgOyHYQjGit3VcSuYdVEQp+ZJNXnD9eGILBrtlQXEkIIIYRoBQkGRJsbX19ZaMXOGAYDAKNfxD7Fjc1QvxFZKLbNCyGEEEJ0dhIMiDY3tlcqACt2VqJpWmwbN9pJyJ8OgD/7MsIxbl4IIYQQojOLeTAQDod58MEHycvLw2az0atXL37/+983GQRqmsZDDz1EdnY2NpuNCy64gB07djRpp6qqimnTpuFwOEhKSuLWW2+lrq6uyTkbNmzg7LPPxmq1kpuby+OPPx7rjyNiYGReCiaDQlGNlz2Vsa/8Yxw3B3O3K9GK3se34uaYty+EEEII0VnFPBj485//zDPPPMO///1vvvvuO/785z/z+OOP869//St6zuOPP86TTz7Js88+y5o1a4iLi2PixIn4fL7oOdOmTWPz5s0sXryYhQsXsnz5cu64447ocZfLxYUXXkj37t1Zt24df/nLX3j44Yd5/vnnY/2RxAmym40M75YMwIpY5g00iASxFL8DQLDwFckbEEIIIYRooZgHAytXruSKK65g0qRJ9OjRg2uvvZYLL7yQtWvXAvqswD/+8Q9+85vfcMUVVzBkyBDmzp1LcXEx77zzDgDfffcdH330ES+88AKjRo1i/Pjx/Otf/+LVV1+luLgYgAULFhAIBJg1axYDBw5k8uTJ3HPPPTzxxBOx/kgiBsb1aqO8AQDVhLnnjQAEsq+QXYmFEEIIIVoo5sHA2LFjWbJkCdu363Xlv/32W7744gsuvvhiAAoLCykpKeGCCy6IXpOYmMioUaNYtWoVAKtWrSIpKYkzzzwzes4FF1yAqqqsWbMmes6ECRMwm83RcyZOnMi2bduorq5utm9+vx+Xy9XkS7SPs/vowcCnW8tiWmK0gWnsbOhyKaH97xKWXYmFEEIIIVok5sHAL3/5SyZPnky/fv0wmUwMHz6ce++9l2nT9E2iSkpKAMjMzGxyXWZmZvRYSUkJGRkZTY4bjUZSUlKanNNcG43vcajHHnuMxMTE6Fdubu4JflrRUsNzkxiam4QvGOHZZbti3r5KBFPxQgD8UmJUCCGEEKJFYh4MvP766yxYsICXX36Zr7/+mjlz5vDXv/6VOXPmxPpWrfbAAw/gdDqjX/v27evoLp02FEXh3gt6A/DSikJW7qogEolh6R/VhK3nZAA82VfJUiEhhBBCiBaIeTDw85//PDo7MHjwYG666Sbuu+8+HnvsMQCysrIAKC0tbXJdaWlp9FhWVhZlZWVNjodCIaqqqpqc01wbje9xKIvFgsPhaPIl2s+5fTO4clgOEQ2m/mcNIx9dwhc7YpdDYBs/F7pcSmDv2wQ+vzFm7QohhBBCdFYxDwY8Hg+q2rRZg8FAJBIBIC8vj6ysLJYsWRI97nK5WLNmDWPGjAFgzJgx1NTUsG7duug5n376KZFIhFGjRkXPWb58OcHgweUgixcvpm/fviQnJ8f6Y4kY+eNVg7l0SDYAFXV+7py/jqIab0zaNihgL9GXCjl3LoBVkjsghBBCCHE0MQ8GLrvsMv74xz+yaNEidu/ezdtvv80TTzzBVVddBdQvF7n3Xv7whz/w3nvvsXHjRqZPn05OTg5XXnklAP379+eiiy7i9ttvZ+3ataxYsYK7776byZMnk5OTA8DUqVMxm83ceuutbN68mddee41//vOf/OQnP4n1RxIxFGcx8u+pI/jy1xcwqIuDOn+I/ywviE3jqglH/nQUIKhBQHIHhBBCCCGOStFivCVsbW0tDz74IG+//TZlZWXk5OQwZcoUHnrooWjlH03T+O1vf8vzzz9PTU0N48eP5+mnn6ZPnz7Rdqqqqrj77rt5//33UVWVa665hieffJL4+PjoORs2bOCuu+7iyy+/JC0tjR//+Mf84he/aHFfXS4XiYmJOJ1OWTLUAb7YUcGNL67BalJZ8YvzSI23xKTdmk+vw7P7v9gNkNR3Jox+MSbtCiGEEEKcClozxo15MHAqkWCgY2maxhVPrWDDfic/Pi+fn17YNybtBnw1VLycjAJkWkCdEpCEYiGEEEKcNlozxo35MiEhWkpRFH74vV4AzPqikB2ltTFp12xNwtjtKjTA23WyBAJCCCGEEEcgwYDoUBMHZjEqLwV3IMx9r6+PWbv20c9Al0vxFL4Kq2+NWbtCCCGEEJ2JBAOiQ6mqwlPTRmA2qGwqcvHdgdjsCm23OlCKFhKMgGvbLLRwICbtCiGEEEJ0JhIMiA6XFm/h3H7pALyzvigmbapGG9Ye1wJQFwbXW32OcYUQQgghxOlHggFxUrhqeBcA3ltfzOtf7mPaC6vZX+05oTYTxj6HUdG/d9fuIfD51IMHpeSoEEIIIYQEA+LkcE7fDBxWIwecPu5/cwMrdlZy32vrOZFiV0ZrChkp+dgM+mtPwSuE/U5cn11P4GXz4bkEEiAIIYQQ4jQjwYA4KVhNBi4ZnN3kvS93V7OmsOrEGr5iB3E9pwDgCUPZgiTqCt+gMgDBnbMgEkTTNFxLJ1M334y2csaJ3U8IIYQQ4hQiwYA4adxzfm+uHt6FH57Tiwv6ZwDw2dayE27XPG4O1vq/6Q3zDBrgDgNr78TnKaOu4DVcIajZMQdW3nzC9xRCCCGEOBVIMCBOGjlJNp64YRi/uKgfVwzTcwg+23biwQCqieS+t5BqhjQzpNRvOxCIAAWzqFt5Z/RUbxi8u+bCqltO/L5CCCGEECc5CQbESWlC73QMqsL20jq2lZz4ZmTKmFlYpgYwTw1gmuyGLpcT0iDc/SaC+94BIK4+t8AdBgpnSw6BEEIIITo9CQbESSnRbmLiwEwA/vN5QWwaVU2gmjCY7KhDH4Hvf4Fv2F+hy+UYFIjLnw5dLiUYgUiPGYRlbwIhhBBCdHKKdiLlWk5xLpeLxMREnE4nDoejo7sjDvH13mqufnolAEO7JrKr3E2XJBuPXTOYEd2ST6jtyiXX4t/zJubu1xDo/wAWk5XU9IGUlm4gHKiFLX9CKVpIau9pmM+eH4uPI4QQQgjRLlozxpWZAXHSGtEtmR+e0wuAb/c7qfOH2FZay62zv6TU5Tv+hiNBTEVvAhDY8yZoIQymeAAsW/4Ai8dD0UI0oHbXAskfEEIIIUSnJcGAOKndP7Evc2eO5IGL+/H8TWfQOyOeak+Q978tPv5GVRPWnjfp33e5FACj0QKRIAnFb2Bu9K/CH4FwwWzJHxBCCCFEpyTBgDipKYrChD7p/OB7vbhwYBbXn5kLwBc7K06oXdO4OahdLoOihfDxaIzf/EzPJ+g1kzQzZFvAGKffK9T9Jj3fQAghhBCikzF2dAeEaI3xvdMAWF1QiT8UxmI0HFc7ihbCVvI+bkABTHsXQOQlGP0ijHwWBTBU7ybkqyKc3Ctm/RdCCCGEOJnIzIA4pfTLSiAt3oIvGGHdnurjb0g1kdh3JhlmyLSAodfMg0//66sOGY1WUIyEQv7YdF4IIYQQ4iQjwYA4pSiKwtn1swOf7zixpUKMfhHj1ADqlIA+I3AIo9ECQDgswYAQQgghOicJBsQppyEY+OJEgwGIzgI0x2DQg4FQ4MQ3PRNCCCGEOBlJMCBOOePz9WBgU7GTKnfbbQxmNFph4yOEFg0jsuLmNruPEEIIIURHkWBAnHIyHFb6ZSWgabDiBKsKHY1RVTEdeA8NcO+aK/sNCCGEEKLTkWBAnJIaZgfu/+8Gpr2wmltnf8nOshgv51FNxPecAkBdCNw7ZqOF224mQgghhBCivUkwIE5JZ/dJB8AbDLNiZyVLtpbxpw+3xvw+tgkvY+l2NRrgDEH1m31ifg8hhBBCiI4iwYA4JY3tlcrFg7LokmRjaG4SAEu2lrG7wh3zeyVPeAl7/XYGvro9eJdPjvk9hBBCCCE6ggQD4pRkMqg8c+MZrPjlebx71zi+1ycdTYO3vimK+b1Us4OkpHzi67fo8xa8BpFgzO8jhBBCCNHeJBgQncKVw3MA+GDjgba5wRU7sPWcCoA/AtqaH7TNfYQQQggh2pEEA6JTOL9/JmaDys6yOjbud7bJPUxjZ2NUQAO8O1+CkKdN7iOEEEII0V4kGBCdgsNq4qJBWQD87v3NaJoW+5uoJuLqqws5g+B7JQ5W3xr7+wghhBBCtBMJBkSn8cuL+2EzGfhqTzWrCirb5B728S+h1s8O1ISAglmSPyCEEEKIU5YEA6LTyEmycdWILgC8unZfm9xDMVhI7zsDgIgG4R4zQDW1yb2EEEIIIdqaBAOiU5lyVjcAPtpUQpW7bTYIM4x9CeNw3/Q+AAEAAElEQVQlX8PE1YTOeLJN7iGEEEII0R4kGBCdyuCuiQzq4iAQjvDW1/vb7D5GcwIoRsJhf5vdQwghhBCirUkwIDqdKSP12YG5q/YQDEfa5B4GgwWAUMjXJu0LIYQQQrQHCQZEp3PlsC6kxZvZW+Vhweo9bXIPo7EhGJCZASGEEEKcuiQYEJ1OnMXIPef3BuDRD7by5e4qPt1ayp3z1vHbdzexu8KNPxQ+oXsYjTYAAoFaIpHQCfdZCCGEEKIjGDu6A0K0hWmjurNqVyUfbirh9wu3sLOsDk9ADwDmrNqDQVX4w5WDokuKWstiScBkshEMenG7y0hIyIll94UQQggh2oXMDIhOyaAq/OqS/gBs2O+MBgIje6QAEI5ovPNN0QndIz4+GwCPp232NBBCCCGEaGsSDIhOKzfFzqi8lOjr3185iNfvHMPCH48HYHOxi0jk+HcqtloTUVUD4XCA2triE+6vEEIIIUR7k2VColN7+PKBvLSikG4pdiaflQtAv6wErCaVOn+Iwko3vdLjj6ttRVGxWpPweCqprT2A0WjFZks59oVCCCGEECcJCQZEp9Y/28Hj1w5t8p7RoNI/28E3e2vYVOQ87mAAwOHoSjDoJRj04HaXSzAghBBCiFOKLBMSp6XBXRIB2LjfCcD20loOOL2tbkdVjaSk5AMQCNRF9x3w+WooK9tMIOCOUY+FEEIIIWJPggFxWhrUEAwUOSlx+rj0yS84969LWfJdaavbMhhMWK16ex5PJZFIiKqqXYRCPmpqCmPabyGEEEKIWJJgQJyWGmYGNhe7+GJnBYFwBF8wwh8WfXdc7dntaQB4PBXU1R0MKEIhP35/7Yl3WAghhBCiDUgwIE5LvTPisRj1JOLXv9oXfb+wwk2J09fq9iyWRAwGM5FIiLq6EgAURQHA65XSo0IIIYQ4OUkwIE5LRoPKwBwHAGsLq5ocW1PY+sG7oigkJuY2eS85uRcAXm81mhY5zp4KIYQQQrQdCQbEaeuq4V2i3xtVhWvP6ArA6oLje5JvtSaRkJAd/d5q1WcLNC2C3+868Q4LIYQQQsSYBAPitHX9WbnkJFoBeOSKQUwarA/kX1m7jxtfWMPdL3+NLxhuVZsJCTlkZAwiOTkPIJpYLMGAEEIIIU5Gss+AOG1ZjAZe+8EY9ld7GdMrtcnA/4udFQBcODCLy4fmtKpdo9Fy8B6WRNzucjyeSuz2dEwmW2w6L4QQQggRAzIzIE5ruSl2xvRKBcBqMkSrDDVYurXshNq3WBIwGExoWoTy8i1UVxcQibRutkEIIYQQoq1IMCBEI49cMZDx+Wn8ZlJ/AJZuLycc0Y67PUVRSU3ti9WahKIoeL3V1NYWxaq7QgghhBAnRIIBIRoZ3i2Z+beN4uaxPXBYjVS5A8dVXagxo9FCSkovkpJ6AOB2lxMI1MWgt0IIIYQQJ0aCASGaYTKoXFKfUPzuN8UxadNqTUZV9TSdiopt1NbGpl0hhBBCiOMlwYAQR3DFML306AcbD1DrC55we4qiEBeXHn1dW3uAysrtaNrxL0MSQgghhDgREgwIcQSj8lLIz4in1h/ilbV7Y9JmQkIOmZlDSEzMRVEU/P5a3O7SmLQthBBCCNFaEgwIcQSqqnDHhJ4AvPhFIf5QbKoAGQwm4uIySEzsDkBdXanMDgghhBCiQ0gwIMRRXDmsC1kOK6UuP/9asjOmg3abLQWDwUQkEsLjKY9Zu0IIIYQQLSXBgBBHYTaq3F4/O/Dvz3Zy72vrW70r8ZEoioLNpu9x4HTuw+eriUm7QgghhBAtJcGAEMdwy9ge/HxiX4yqwrvri7noH8upqPPHpO34+KzorsR1dZI7IIQQQoj2JcGAEMegqgp3nZvPS7ecRWqcmd2VHv61ZEeM2jaQkpIPQCBQRzgcJBBwEwrUQeTEKxgJIYQQQhyNBANCtNDZvdP519ThAMxbvYf/rtsfk3YNBjNmcxwApSVfU/HZZMrnJ+BbYIbVt0bPCwY9hMMSIAghhBAidiQYEKIVxvZKY+qobkQ0+PXbG6nxBGLSbnx8Nmx8BD4eDUUL0QBXCCiYBSEPfr+L8vLvKCvbhM/njMk9hRBCCCEkGBCilf545SD6ZzvwhyK89XVRTNq0mu04St/DooLDCAoQ0sBp7o5zQRzO5dMB0LQITuceNC2CpkWorT2A3++KSR+EEEIIcfqRYECIVlIUhakjcwF4/at9sWlUNRHfZyapZog3grnb1WDritu1B3cYQvveRdn4OxRFJRwOUldXQkXFNmpri6mq2kU46MHvLiHgq0YLB/B4KvS8AyGEEEKIo1C003i3I5fLRWJiIk6nE4fD0dHdEacQpyfImX9cTDCsMWvGmRhVlfH5aaiqcmIN1ycN+zwVVL2e0+RQsgm4uoRq5yG5ChsfgaL3mr5n74rBu5/0vtNRx845sT4JIYQQ4pTSmjGuzAwIcRwS7SbG56cBMHP2V0yftZa7X/maSOQEY2vVBKoJa3w22an55FghwxZPmhlsvWdii8vEZkuOnm5U1Wgg0CQM8ewnrEHV9rlEVt58Yn0SQgghRKfVJsFAUVERN954I6mpqdhsNgYPHsxXX30VPa5pGg899BDZ2dnYbDYuuOACduxoWqqxqqqKadOm4XA4SEpK4tZbb6Wurumyhw0bNnD22WdjtVrJzc3l8ccfb4uPI0Szpo3q3uT1BxtLWF1QGbP2lSt2wPVujFNqMU8NwOgXAUhK6oHdnorZHE9axhBSet9IigmyLJBqBouqf6kKBCJQs32ulCkVQgghRLNiHgxUV1czbtw4TCYTH374IVu2bOFvf/sbyckHn2Y+/vjjPPnkkzz77LOsWbOGuLg4Jk6ciM/ni54zbdo0Nm/ezOLFi1m4cCHLly/njjvuiB53uVxceOGFdO/enXXr1vGXv/yFhx9+mOeffz7WH0mIZl0wIJNVD5zH5t9N5LKh+pKer/ZUx/YmRrv+X9UUfUtRVJKSepCW1hdVNWA9ex7WaQGUG9xYpgZI7TuDVDOkJPVEAXzZl1PrLo9tv4QQQgjRKcQ8Z+CXv/wlK1as4PPPP2/2uKZp5OTk8NOf/pSf/exnADidTjIzM5k9ezaTJ0/mu+++Y8CAAXz55ZeceeaZAHz00Udccskl7N+/n5ycHJ555hl+/etfU1JSgtlsjt77nXfeYevWrS3qq+QMiFiZvaKQh9/fwjl905l9y8iO7o4+E6Ca8NQdoMZVDEB6en9MJnsHd0wIIYQQba1Dcwbee+89zjzzTK677joyMjIYPnw4//nPf6LHCwsLKSkp4YILLoi+l5iYyKhRo1i1ahUAq1atIikpKRoIAFxwwQWoqsqaNWui50yYMCEaCABMnDiRbdu2UV3d/NNZv9+Py+Vq8iVELJzRPQWAr/dUn3jeQCzUzyTY47Ox2fS+1dYWd2SPhBBCCHESinkwUFBQwDPPPEPv3r35+OOP+eEPf8g999zDnDl6RZOSkhIAMjMzm1yXmZkZPVZSUkJGRkaT40ajkZSUlCbnNNdG43sc6rHHHiMxMTH6lZube4KfVghdv+wEHFYjLl+IZTtOriU5CQnZAPh8TgIBdwf3RgghhBAnk5gHA5FIhBEjRvDoo48yfPhw7rjjDm6//XaeffbZWN+q1R544AGcTmf0a9++GNWIF6c9k0HlujP14HLuyt0AhMKRDuzRQUajFbs9FYDa2thskiaEEEKIziHmwUB2djYDBgxo8l7//v3Zu3cvAFlZWQCUlpY2Oae0tDR6LCsri7KysibHQ6EQVVVVTc5pro3G9ziUxWLB4XA0+RIiVm4crVcXWra9nL9+vI38X3/ITS+uocYT6OCeQXx8Noqi4vfXUl1dgM9X09FdEkIIIcRJIObBwLhx49i2bVuT97Zv30737vpAKS8vj6ysLJYsWRI97nK5WLNmDWPGjAFgzJgx1NTUsG7duug5n376KZFIhFGjRkXPWb58OcHgwZKJixcvpm/fvk0qFwnRXvLS4hiWm0REg39/thOAz3dU8MHG5pettSej0YLD0RUAr7eaqqpdsmRICCGEELEPBu677z5Wr17No48+ys6dO3n55Zd5/vnnueuuuwBQFIV7772XP/zhD7z33nts3LiR6dOnk5OTw5VXXgnoMwkXXXQRt99+O2vXrmXFihXcfffdTJ48mZwcvYTj1KlTMZvN3HrrrWzevJnXXnuNf/7zn/zkJz+J9UcSosUuH5pz2Hsb9te0f0eaEReXTlpa3+jrUMjbgb0RQgghxMnAGOsGzzrrLN5++20eeOABHnnkEfLy8vjHP/7BtGnToufcf//9uN1u7rjjDmpqahg/fjwfffQRVqs1es6CBQu4++67Of/881FVlWuuuYYnn3wyejwxMZFPPvmEu+66izPOOIO0tDQeeuihJnsRCNHepozsxob9NSzfUcGIbkn877syvt3v7OhuRZnN8cTFpeN2lxMK+Tu6O0IIIYToYDHfZ+BUIvsMiLZ0wOllzGOfYlAVNj08EYtRRVH02bGOVFdXisu1H5stheTkvA7tixBCCCFir0P3GRBC6LIcVtITLIQjGq+s3cvA337M9/6ylK92V3VovwwGfW+OcFhmBoQQQojTnQQDQrQRRVEY2jURgMc+/A5vMMzeKg8/feNbAqGOKztqNFoACIc7vsqREEIIITqWBANCtKGhXZMACIYPrsbbU+nhqqdX8OravVS7239AfnBmICh5A0IIIcRpToIBIdrQkNyk6PfXntGVf08dDsDmYhe/fGsjl/37C9z+ULv2SVWNGI16sn5V1Q4OTRsKBNxEQr527ZMQQgghOoYEA0K0oaFdEzEZFFQFfnROLy4dksMfrxrEhD7pmI0q+6u9vPB5Ybv3KyUlH1U1Egr5qazcTjis79fh99dS8dlUKufZ0FbOaPd+CSGEEKJ9STUhqSYk2tgXOyoAGN87rcn7739bzI9f+YZEm4nVD5yPzWxo13653eU4nfrO4EajlcTEbrhqCgkuGgpAghESes+AMS+1rMFIEFRTG/VWCCGEEC0l1YSEOImM7512WCAAcMngbLom23B6g7z3bVG798tuT8Ph6IqqGgiFfFRWbicYDkKXSwGoDUG4YLY+yD+Epml4vVWEw0E0TaN26RRq5pnxf35jO38KIYQQQpwICQaE6CAGVeGm0d0B+PviHbh8+qDb5QsSDLd9tSFFUYiPzyQ1tW+0whAAgx9GsecCUOqHuuU3NbkuHA5SXb2L6upCKiu34azeSW3Bq3jCUL1zgSwvEkIIIU4hEgwI0YFuHtuDvLQ4Slw+7py3jnmr9zDyj/9j4j+WU1bbPkm8JpON9PSBZGQMwmZLISEuncTgPtT6vdFcBa8R+uImNE3D46mgvHwzPp++q3Io5Mfjc0VnEyIaeHfNaXY2QQghhBAnHwkGhOhAVpOBv98wDLvZwMpdlTz4ziZ8wQgF5W4efGdTu/VDURSMRgvJyXkkJHbD3nsmWRaw1P+E8BbMp9a5m5qaPUQiYczmOBISslEUFUVRSTp7No6eNwDgDgFr79QvjAQlMBBCCCFOYpJALAnE4iTwzd5qfvPOJvZXe+mblcDawipsJgO3nZ3Hp1vL+Ofk4eRnxLdvpyJBPJ9Pp2bXqyiA1uVSGPwwcXEZOBxdURSlviyphqKoREI+Sufa0IBUEwRzbyCw+zXsBrD2ngmjX2zf/gshhBCnqdaMcSUYkGBAnGQiEY2Rj/6PirqDG5JlOaws/fk5WE3tW3EoEvJRPs9GdM+0nElkT3wfRVGaOTmIc54Zd7jp2yYF0i3A5IBUGxJCCCHagVQTEuIUpqoKY3s1rT5U4vLx14+3cf1zq/hkcwkAoXAkmnTcZn0xWknvMx1j/djfVroIZfXMI5xsIr73DA4NEyIAPWdKICCEEEKchCQYEOIkNGVkN5LsJkblpXDFsBwAXviikLWFVfzq7Y04PUHOf2IZQx7+hPteWw9AQXkdS7eVxbwv6rg5pPW+EYcRHEagcPYR8wAMo58nyQRGBQz1UUHkgi9kiZAQQghxkpJgQIiT0Jheqax/6EJe+8EYfnhOrybHKuoCDH3kE/ZUegB4d30Ru8rruP65Vcx46Us+2nQg5v1Rx88jvvcMfYB/tKf8qglb75lkWCDDDHS5HM1gRdPavlSqEEIIIVpPcgYkZ0CcAj7adICIBpXuQLNVhswGlUD93gQmg8KE3ulMH9uD7/VJj21HWrrLcP3MwYHSjWiaRmbmYAwGc2z7IoQQQohmtWaMa2ynPgkhTsBFg7Kj32c5rHy46QA9UuMIhSM8+enOaCAAEAxrLNlaxtaSWj6//1xUVSES0VDVZpJ+W6ul6/7rz1NVI+FwkEgkjKF9c5+FEEII0QISDAhxivn+gEy+PyATgBKnj1e+3Ed5rZ/z+2Xw1LQRLN5Syo9f+YaiGi+PLNzCx5tLsJkMvPfj8cRb2vefvKIYgCCRSKhd7yuEEEKIlpGcASFOYVmJVt65axwPXNyPv143FKvJwGVDc7hpdHcAZq/czQGnj4IKN6+u3dvu/VNVPfjQtPAxzhRCCCFER5BgQIhTXJckGz/4Xi+S4w6uyf/Rub04dCuAuav2tHPPQFX1tUEyMyCEEEKcnCQYEKITyk60Mf/WUUwanM3/fjIBg6qwt8rDAae3XfvRMDMQiZw6MwOvrt3LWX/8H1uKXR3dFSGEEKLNSTAgRCc1Lj+Np6aNID8jgX5ZCQB8s7emXfug5wxAbfVOwkFPk2OhkA+fz9mu/TkWXzDML9/aSHmtn/lr2n8mRQghhGhvEgwIcRoY3i0JgFfW7qU9qwmrqgGWX4W2eDxl8+IIfnFT9Fh1dSFVVTtxu8vbrT/H8mGjPRpS7FIKVQghROcnwYAQp4EzuicD8PmOCv7+vx3tdl8jGnj2AaAB1TvmE/r8RgCC9TMFTmf7BihHs7/q4DIqX/DUWdokhBBCHC8JBoQ4DVw0MJtJg/W9Cp5csoNrnlmJ0xts8/vaErqQntKLTAsYFAhpULlzAeEV05ucFwy627wvLeFpFAC4A5L0LIQQovOTYECI04DNbODfU4czpGsiAOv2VPP6l/va5d6mK3diuMFNWu9pqAqENajbOQ+0g4Ntv7+2XfpyLN7AwWDAtf/zDuyJEEII0T4kGBDiNKEoCv+cPJwku7478Jtf72+/5TlGO4bx84nPuwEAdxjY9Ifo4UDg5AgGaj110e/drhKItP3siRBCCNGRJBgQ4jSSlxbH0p+dg9mosrWklvmr9+ALhtlf7Tn2xTEQd/YcjA37HxQtxLj59wAEAnUnxV4EHv/Bwb87YuvAngghhBDtQ4IBIU4zSXYzP/1+HwAefHcz/R78iPF//oxFGw4c48oTpxgsOHpNib62FL+LyWBC0zS83uo2v/+xeIKRg98bc0A1dWBvhBBCiLYnwYAQp6E7JvTk5jHdm7w3Z9Xudrm35ewFYO8KgGbvgS0uEwCvt6pd7n803kYJxB5jTgf2RAghhGgfEgwIcRpSFIWHLx/I6z8Ywyu3j0ZRYG1hFTtK237tvqKFcAT2oyoQ59+NzaJviBYI1BEK+ZucGwr52nX3Yk+g0cxAo1kCIYQQorOSYECI05SiKIzMS2FMr1TO65sBwJ3z11Hra+OkWdVEfJ+ZZFnAlD8Tg8mOpT4gcLn2Rwf/LlcRZWWbKS3dQDgcaNs+1fM1XiYUkGBACCFE5yfBgBCCx64ZTJbDyq5yNze+uJZd5XXHvuhEjH4RJgf0/wLx8dkoioLPV0NZ2SYCgTq83koANC2C3+9q2/7U8zYKBrxB7aRIahZCCCHakgQDQggyEqw8P/0MrCaVb/fVcPucrwhH2rjsaKPkXIslgeTkngBEIiEqKrYRDh+coWjYrbitNQ4GQhHwrbi9Xe4rhBBCdBQJBoQQAAzpmsTCH4/HbjZQUOHmk80l7Xp/qzWJ+PisZo8FAu2zQ7Ev2DQAqt31X9lrQAghRKcmwYAQIio/I4HbxucB8MyyXe23KVk9i8XR5LXNlgJAKORt876EwyG8hwQD7pypUl5UCCFEpybBgBCiiZvH9sBqUtmw38mYxz5lZ1kb5w80YjbHY7enkZCQTXp6f5KSeqCqBjRNw+erxunc22bJxP5gkIZQwFj/k7Gu74Ntci8hhBDiZCHBgBCiidR4C7eM02cHSlw+pr2wmi92VLTLvRVFISmpOwkJOZhMdhRFwWi0AlBdXYjbXY7bXdYm967zHwwyUuOM+nttXVlJCCGE6GASDAghDnP/xL68d/c4clNslLr83Db3S4pqvABomkakrZOLGzEabU1et1UysdunBwNmJUBcRA9+vAEJBoQQQnRuxo7ugBDi5KMoCkO6JvHh/01g2gtr+HZfDb/47waGd0ti9srdeANhLhmczePXDsFqMrRpX0ympsFAWy0Tcnv1IMOm+LCGy4EkvEEpLSqEEKJzk5kBIcQRxVuM/PmawVhNKl/srOBfn+6k1hciFNF479ti7pi3Dl+wbXcINhgsTV6Hgm40LYLXW43PU44Wo+DAWz/ut6k+rDY9kbmtP5sQQgjR0SQYEEIcVb8sB7NmnEVavBmAOyb05D/Tz8RmMrB8ezn/+N+ONr2/xeIgLi6D5OQ81E2/h49HU7t0MtXLZ1D1aga1Cyyw+tYTvo+7PmfA6uiCNbk3AN6AzAwIIYTo3CQYEEIc09heaSy//1w+uOdsfnVJf74/IJO/XDcEgDe+2ocvGGb+6j18tbsq5vdWFIXExFxslgRMxe8CUFf4BhS9B4A3DBTMOuH9ANz1+QE2szG69MkrMwNCCCE6OckZEEK0iN1sZEDOwX0ALhqYRXqChfJaP0Me/oRAOEKC1cgX959Hor0NavOrJhLzb6Rqx3xCjfKXwxrUmnuQcIL7AXj8+iyAzWTAVh8M+CUYEEII0cnJzIAQ4rgYDSr3XdAHRYFAOAJArS/Ei18UtN09x88jvc9NJBgh2QTx9bnLta7d+D+/8YTa9tQvCbKbDTIzIIQQ4rQhwYAQ4rhNHdWNhT8ez2NXD+beC/R19q9+uY9QfXDQFpRxc0noPQObARISe2Gt/ynmKVhwQkuFGvIDbI2CAX+w7T6HEEIIcTKQYEAIcUIG5iQyZWQ3fnROPsl2E2W1flbsqmzbm455CSYHUK7cSUK+PiPgC4O25gfH3aQnoM8C2M1GrCZ9BaXMDAghhOjsJBgQQsSE2ahy+dAcAN5ct7/tb1ifI2AaOwtVAQ0I7XrpuGcHvI2CAbtZDwZ8ss+AEEKITk6CASFEzFw9oisAH246wJvr9vPN3uq2v6lqwph7NQCh7tOiQUJreYINOQNGrPXBgH/P+2irZsamn0IIIcRJSIIBIUTMDOmaSH5GPMGwxk/f+JZrn13FJ5tL2vy+xjP/BhNXExr2l+O6XtM0fCVrAbBXfITNqADg18xECo5/tqFFIsEm7WtahJAv9iVahRBCiOZIMCCEiBlFUXj82iF0S7EDEI5o/O79LWiadowrT4zRaAXFSChQe1zXR0JevLXFANida7CZ9QRiX8RCpMf0455tOBpN06hdNoWaeWZCL5th9a0EAm5KX8uj7OVU/G/3ivk9hRBCiENJMCCEiKkR3ZJZ+rNz+Pa3F2IzGSiq8bK52NWm9zQarbDxEULv9T2u3YgjKPgsPQGwZwzHatYH//6Us4mc+a+Y9rWB31tB7a5X8YTBGQIKZlFbuZWIZy8AwdoCCHna5N5CCCFEAwkGhBAxp6oKiTYTZ/dOA2DxltI2vZ/JYIKi9whqENnV+t2II5Eg3rgBANj6TMdq1GcGAmGIRNomidgXcEOXSwHwR6DO3AP/hoejx0P2HmC0t8m9hRBCiAYSDAgh2sz5/TMAWNXGpUYNpjgMuVcCEOw2tdXLeiKREL76PQUabzrmD2ltEgxomoZv7b1QtBCl/j2XazcULYyeE/7eoibX+P0ugkFvzPsihDiGtswZEuIkYOzoDgghOq+zeqQA8O3+GvyhMJb6J+5twXzmE3gjIQKFL2MxWWH0iy2+NhIJ4asf89tMB4MBX7BtggG/t4LI/ndRFUg3Q2UAwhrYDGBToTLjUvxBL2VlmwmH/VityXi9VaiqgYyMQaiq/OgWoq1omoaihUA1UbnkWrR9b5LcezqGcXM6umtCtAmZGRBCtJm8tDhS48z4QxE2FcU2b+CzbWX0e/BD/lu/p4HFZIWihfgjQEHrlgqFw0F8QT3JWd+BWP/R6G+jZULuVT8EwG4AQ6+ZpPe9mUwLJJnA2PMmGPwwAKGQD03T8Hr16kKRSJi6urZdciXE6czrreLAJ1dSO99M8Iub8O95k0AEqnbMRVs5o6O7J0SbkGBACNFmFEXhjO7JAHy6NbaD2D8s3IIvGOFnb3yrzzrYUqHL5QQiEOkxo1VLhSKREN7oMiFjk2VC4XBslwiEg278e94EIM4AjHwWZexs1CkBmBxAHXvw6aPF4sBmS2lyvc9XE9P+CCEOctUUQtF71Iagbtf86PvBCHh2zpElQ6JTkmBACNGmrhreBYA5K/dQWeePSZuRiEaJ0xd9/dGmEgwGMyZD/c7BoUAr2wtFZwbsZgO2xjkDodiu0/euvB0As6rPCkSDFtUEqglFUYiLy8Bsjic5uSfJyXlkZg4mPV1PcA4F69osqVmI01kg4Ca84eHoa6++KTn1245QF4bIypkSEIhOR4IBIUSbmjgwi4E5Dur8Ie6Yt459VUcul7m6oJIPNh44ZpvflbhwB8LR12sLqyASxFb8FgC1u15GC9a1uI+RSBBvqH6ZUJOcgTCRRYOPq1xp8zcK4i18Rb+PCox8ttnTEhNzSUvri6rq/TAYzJhMNoxb/ggfj8a9fFps+iOEiAoFXE2S+LHrO6onJ/VEVfS8nood8wm/Yo7dzwQhTgISDAgh2pSqKvz5miGYDSrr9lRzzTMr8QbCOL1BimsOPnVfW1jFlP+s5kcLvubrvdV8saOCS//1Odc/twqXr+mTuEOrE63bUw2qCXv+DBT0X9ql8xNwL51MJOTjWEJf/wp/QwJxo5yBsKbii6hox1GutNn7RMIEsy9HAWz5M1pX9SgSxFr0NgC1Ba8TWD71hPqiaW2THC3EqSoYDkGXy/WZAHtX8OxHVcCUfQ6p+VMxKBDSoCpQX8JY9gERnYQEA0KINjeoSyILbh+F2ahSVuvnqqdXMOaxJXzvL5+xbo+eHPu79zfTsFHx3JW7efLTHWwqcrG2sIqPNpU0aW9lfTBw+9l5AGwrrcXlC6KOfp5EExgUiGjgLHiNynk2tFUzj9g3LRzAs/eD6Gu7MRLdgRjAF7ESisEuxFo4gNtdDkQwq6Cqrfzxq5pI6H0zlvrL6gpegVW3tOjSUMiPFtaXaGmahttdTkXZBkpLN+DzOVvXDyE6qVCgFgb9CvtVu8BTX5hABQpmYRo3m9Te0zAoENSgxA/BV+NkhkB0ChIMCCHaxVk9UvjVxf0A2FpSiycQJhjW+PXbm9i439lkl+J31hfrS3/qLd1Wxu4KN795ZyMfby6JHrtiWBe6JNnQNNhS7NJnB3rPJMMMCUZQ0H9xu3e8dMQn+2FNw51xJQAqGlazFYvRgNmg/3h0n72Y4NA/t/yDHnIfTdOoWnINB+ZYcH8wFooWEm+g1RWPAJSxs0nM15cI+SIQLph9zDY8ngrKllxL+Vwr4RU3U1dXgvOLmQQXDUPb8Duqq3cRiYSP2oYQnV1wxc0E3h8IH4/GvOlhMvpOJ8kEDiPQU8/tMY6fT3zPydFrXPU7h0sOgTjVSTAghGg300Z35+oRekLxpUOySbSZ2FpSy2X//gKA8/plMLxb0mHXfb69gt++t5n5q/fyg3nrqPOHSI0zMyDbQX5GPAAF5W795NEvokwJkJA/Xf9Fjr7D75GEw35qe94HQILNjKrq2YIJVv3ius3PE3wz+5hPADVNo3bpFGrnmwmvuDn6vmfZFHx79FwGvPuxqGAxAHkzjmu2wTh+PuZuVwHg6zr5qG1oWgTn5zOhaCEhDUq3zaV24ciD66KL3kOLBHG7y1rdDyE6jUgQ1465aOiJ/aY98zCOeQH7tACGKYEme5bYx8+m/kcE/ggEc09suZ4QJwMJBoQQ7cZkUHni+mFsePhC/j11BM/eeAYWo/5jKC3ezO1n92TG2B7R8y8amEWC1UitP8Sy7eVN2vrB93qiqgo90+MAKChvlDCsmmDsHMw9bwQgmH3ZEQfNoZCfuvpowWE7uJlXfH0w4ClZgy/CMfMG/N4KagtepTYErp1z9SU8kSDe3a8B+ixFvBFSTECP6TDmpWP/gR2BdfTT0OVSfIWvHjFIiUTCuGp2oxW9H70/AN79GBV9g7OE+o/rdpfJ7IA4bYUiYfzWXACSjKA0VPlq+GpEMVjI6j8TQ/0/qPIdLxN4WRKKxalNtrEUQrQ7h1X/BTumVyqrHjgfBUiOMwP6E3Z/KMKagiru/F5PXO8FozkCg7o4GJ6bTHmtn+ljegDQK71+ZqDCfdh9jOPmoridRIreJ/jFTZjGzzt4MBIE1UQ47KeuPnu4oV9wcGbAbepBWNuK394T61GewvsCbsiZBMWL8IUhUjAbj99DoH5WIiO1Fwb3Ln1G4AQCAQCrOR5X0UL8QGDnLExnPYPbW4XJFIfFkgCAy7Ufj7caulyO9cB7WFS9NKJNrV9CpYCWdwteUzyhkA+Pp5z4+KwT6pcQp6KArxo8+7CoYDxKla+okc8Sv30Wzvr8e2cI0gtm6dedYG6REB2hzWcG/vSnP6EoCvfee2/0PZ/Px1133UVqairx8fFcc801lJY23ZBo7969TJo0CbvdTkZGBj//+c8JhZpWvli6dCkjRozAYrGQn5/P7Nmz2/rjCCFiLCXOHA0EQN+o7Pozc/nb9UPpnZnAkK5J0WNXD+/K768cxLM3nREt/9nszEBDW1oI8wH9yXj1jvmEVkzHU3eA2qXXUTffTGTVLfjW3kPt2t8ATYOBeIseDIT8epDhcRboT/q91YR8VRzKt/ZeKF4EBjsaUGPshqvgdUCvU27IOBsmB044EAAwmuOx510PgDsM/pUzcbmKqKzcjtO5j3A4gMdToZ88+CGMVxYS12cmmRZwmEDpOQMmB1DGzCI+PhMgusuxEKebUCRysIpQz5nHHtCrJuL6zCTLUp+XFIGQvZcEAuKU1abBwJdffslzzz3HkCFDmrx/33338f777/PGG2+wbNkyiouLufrqq6PHw+EwkyZNIhAIsHLlSubMmcPs2bN56KGHoucUFhYyadIkzj33XNavX8+9997Lbbfdxscff9yWH0kI0c6Gdk0EwKAqXDY057Dj+fUzA3urPPiChyx1UU0k5t8YLQlYtm0eNa/nUFvwX1whKN86m9Det/FoekDhsB6sIpRQHxgEUs8H9PXBtZ9Pp/rdoZS9nIrvrV7RCj3hoIfI/ncBiFf0coM+995oW3EGoHD2Cf5JNGUf81y0X4HCBaDpD0vc7jJKSzc2OddsTdLXPU8OHAxI6gcuVmsyiqIQDHoJtaAMqxCdTTjsh8EPYbhqX5P8gKMa/SLqDe5odS+va5ckEotTVpsFA3V1dUybNo3//Oc/JCcnR993Op28+OKLPPHEE5x33nmcccYZvPTSS6xcuZLVq1cD8Mknn7Blyxbmz5/PsGHDuPjii/n973/PU089RSCg7yz67LPPkpeXx9/+9jf69+/P3XffzbXXXsvf//73tvpIQogOMKFPOmN6pvKjc3qRnmA57Hh6goVEm4mIBruamR0wjp9HYq8p0ddKo2Ph+lKmgfpgoGFpEEBC/cyAO2cKZhU0oHbXq+DZB0BVTQFlc61EVt1CWNOfLBoUiHf0iq4nVhXIskBco4oksWK2JqHauxHRoM7UFRQjVmsiBsPBWRazOZ7ExFys1qT6Dh2+BlpVDZjN+tIiKTMqTkehQB1oIYz1/w5azGjH2lNPIPZlXykzA+KU1WbBwF133cWkSZO44IILmry/bt06gsFgk/f79etHt27dWLVqFQCrVq1i8ODBZGZmRs+ZOHEiLpeLzZs3R885tO2JEydG22iO3+/H5XI1+RJCnNziLEZeuWM0P72wb7PHFUWhX5b+S3zrgdpmz7GOn0OSCZJM+uA820K0IghwcGbAdjDYiFYTCmjYezaqGGKIi34b1sC7Y7Y+mBj8EMZLN6FeuZOU3jeSaIR0M6i9ZupP41v6xLGlIkHs/vrZB+9+2PBb4uOzyMwcTHb2cDIzh5Ca2oe4uIxjNmU267MrwaBsoiROL+7lUwkuGgofj8a47p5WX28dPwe6XEpw3zuEV86IfQeFaAdtEgy8+uqrfP311zz22GOHHSspKcFsNpOUlNTk/czMTEpKSqLnNA4EGo43HDvaOS6XC6/XS3Mee+wxEhMTo1+5ubnH9fmEECeX/tkOALaWHCHAr99/wG7Q18srN7hx1NcLN6tQG9YHw81VE6r1hbCNm3VwRiHsxtroJ6c7DOGv9NKkBpPejmn8POJubFSWsC2eGNZvQhbXsLKpeBHGr+4CQFFUDAYTiqIc+fpGTCY7IMGAOM1EgtTtegXQZwwNu+e2eqmPiob5gF6q17dzjiwVEqekmAcD+/bt4//+7/9YsGABVqs11s2fkAceeACn0xn92rdvX0d3SQgRA33rZwa+O8LMAHBwzfyYl8Box/69V0jJn0qyCVy2QcChCcT697W+EIrBQnwvPXhQgJSU3mTVzy6ENHAXvgphH0Zjo2VMzSzJiTVl7Gwc+TcRb9A3R1KPYzADB4OBUMgnJUbFaSMUCRPOuRyATEujkqKtoZqw5unLEH0RYO2dMe6lEG0v5sHAunXrKCsrY8SIERiNRoxGI8uWLePJJ5/EaDSSmZlJIBCgpqamyXWlpaVkZell7bKysg6rLtTw+ljnOBwObDZbs32zWCw4HI4mX0KIU1+fTD0Y2Fl2eM5AE4f8ordOWIBhSgBX3AgAHLbDS4vW+vTBdfz4OTiMkGIG6nag3uDG1kOv6BPRgMXjMXzzsxh8mtZRxs3F0WcG8SeQl2AwmKK5BoHAUQIqITqRhhwZiwpqzxnHvZTPPOppQH8wIDsSi1NRzIOB888/n40bN7J+/fro15lnnsm0adOi35tMJpYsWRK9Ztu2bezdu5cxY8YAMGbMGDZu3EhZ2cFdMRcvXozD4WDAgAHRcxq30XBOQxtCiNNHr/ryoiUuH55A6BhnH0I14fLqv7wdjROIG3IG6vcgUAxm4vvM1KuH9JwJRjvx45uWCTXvXdAxA4ExL51wXoLNphd6qKnZI1WFxGnBV1cMRe/py/4KZx/3v12DyQ5dLtcfCsSgUEAgFOEH875izsrdJ9SOEC0V803HEhISGDRoUJP34uLiSE1Njb5/66238pOf/ISUlBQcDgc//vGPGTNmDKNHjwbgwgsvZMCAAdx00008/vjjlJSU8Jvf/Ia77roLi0Wfhr/zzjv597//zf3338/MmTP59NNPef3111m0aFGsP5IQ4iSXZDeTbDdR7Qmyu8LDgJzWzfq56p/+Nz8z0Ci4GP1ik42FDAYTKSZ9M68EIxh6zui4iiIneF+7PZ26ulIikRA1NXtIS2s+YVuIzsD7+Y0EdiwA9N24T2QQr6omGPwQ2qBfEck+44Sfsr7zTREfby7l482l3NxoR3Yh2kqbbzrWnL///e9ceumlXHPNNUyYMIGsrCzeeuut6HGDwcDChQsxGAyMGTOGG2+8kenTp/PII49Ez8nLy2PRokUsXryYoUOH8re//Y0XXniBiRMndsRHEkJ0sLw0fXagsJmdiI+lolbfLyCl0eZnDfsMOL2HPC1sPGBQTVh7zyTNDJZeM2KyoVhHMRotOBxdgfq660J0Ulo4gGunHgjEG+orix1l1+HyWj+BUOSIxxVFwWAwgWIkHA6ccP8O+5kjRBuL+cxAc5YuXdrktdVq5amnnuKpp5464jXdu3fngw8+OGq755xzDt98800suiiEOMXlpcXz9d4aCiuOkTdwiFpfEFf90/+cpIP5RpkJegGEUpcPTdOOXJnnkNmCU4EvGGZvlYfeGfFNPpfdnorLtZ9wOHj0zyzEKSoSCVO25Hoimh4EJBwj12ZNQSXTXljDJYOzeXLK8CO2q6omwuEg4XAQ0wn+KAhLEr9oZx0yMyCEELHWsz5vYFtp64KB4hp9fXyizUS85eDzkQyHviTRH4pQ4znGk7pTKBBYsbOC0Y8t4cK/L+fppbuaHFNVI4qi/1qIxRNOIU4mfr+LkgNfRXcLt6mgHDIrUOsLMmflbsrrZwt/9fZGQhGN974tpsx15Fwag0H/GRCJQc5Q4xK/mqadcHtCHIsEA0KITmFENz0BdtWuCiKRlv8CLa7R9yXpktS0CpnVZCC1ftlQyVEGAaeSUpeP2+Z8FQ1unl9egNvfNOG6oaqQBAOis3G59sOmRwEwHWFW4E8fbuW3723m2mdXUljhZlf5wWWH76wvOmLban0bdXWlaNqRlxS1ROOfXsGwBAOi7UkwIIToFM7onkyc2UBFXYAtB1q+u3hRfTCQk3R4SeJMh75UqMTZOYKBl1bsxhsMM6RrIl2SbDi9QV5Zu7fJOQ3BQF3dAXkqKToNTdMIBmqh6D0AUs2g3uBuUoGr2h2I/nvYU+nhzx9ubdLG00t3HXE9v92eiqIohEI+XK4jBw0t7Gz0W29QlgyJtifBgBCiUzAbVcb0SgPg8x0VLb6uKDozcPgmidmJ+nsHOkEwUOsLsmDNHgDuOa83d5+XD8CLXxTiDx0ccDQsd/D7azlw4GtqavZIUCBOWcGgl7KyzVRUbAXFiNL1CrItoPbSywM3tnhLKY0nFT/aXALAhQMysRhVajxBLvz7smaLFJjN8aSk6P+mPJ5ywuHjXy4UbNQJb0CSiUXbk2BACNFpjMpLAWDdnuoWX7O/+sgzA1n1wcCpvkwoEtF49IOt1PpC9EqP47x+GVw9oguZDgsHnD5eXnNwdsBsjm9yrcdTQXn5lvrlDxIUiFOL211GKOSLrsO3nPlXlCnN78nxyRZ98D+hT3qT98/uk85TU0eQk2il1OXnoXc3Ue0+fBmdxeLAbI5D0zS83qrj7rM/eHCZkbe1+6YIcRwkGBBCdBojuut5A1/vrW7xwHVLsb4Lae/M+MOORWcG6mcP2oM3EGZflYdQOML/tpRS1cygo7Ve/KIwuvzhrnPzUVUFi9HA/53fB4Bnlu4iXP800m5PIzNzCMnJedHAQF/6sJ/q6l3N30CIk5Tf72zy2mZLaTbhv6zWx7Lt5QD88qJ+TcoMXzIoiwsGZPLy7aNRFX3mcfjvF/PcssP/PdhsqQD4fDXH3Wdvo2DA45eZAdH2JBgQQnQag7o4MBtUqtwBVu2q5F9LdrCr/MjVhVy+YDRBcGjXpMOOd0/VKxTtKGtZhaKl28qOer+j2VPp5ppnVjL0kU84+/HPyP/1h9w29ytueG7VUWucH4vTG+S55QUA3HN+b64a3iV67NozupJsN1FW62fFzoNLqwwGEzZbCmlpffXBUz2fzym7E4tTRjDojS7XMRhMGI0WrNakZs+dv2oPwbDGiG5JDMhx8OLNZ9Itxc4frhxEarxeWaxHWhx3n5tPQn3VsVe/3HdYOxaLo/7ebiLHWSK08WyAR5YJiXYgwYAQotOwGA2M6qkPXqe+sIa/Ld7OHXO/ij71PtTG/fpTw9wUW/QXfmP9s/Vf7NtKao9ZoWjlzgpmvPQl1z+7KrqjcUsFQhFum/MV6/ZUHzbw31FWx9xVu1vVXoNwRGPaC6upqPOT5bBy97n5TfYOMBtVLh2SA8DCDcXNtpGU1IP09P5YLAkAVFcXnnC1FCHaQyCgB+YWi4OMjEGkpw+Ils5tbNWuymjAfNvZPQEY3i2Z5fefy42juzc59ycX9mXVr87HZFAorHDz+pf78DQavBuNFoxGC5qmEQjUHle/G88M+IKyTEi0PQkGhBCdyp+vGUK3lIOJgbvK3Ty3fFd02VCVO8CWYheaprF8h74soLlZAYAeqXYsRhVvMMyeKk+z5zR4/nN9MFHpDvDs0tYtp/nfd6XsKKsj2W7iv3eOYeqobozKS2HqqG4AzFu9p1XlUht8sbOCTUUurCaVZ286A7Px8B/55/XLAOCrI+RZKIqCyWTHYkkE9BroBw58Q3V1gQQF4qTWEAyYzfEoitpsIPDZ1jJuenEN/lCEs3okc/GgrGO2G28xMra+WMH9b25g5B+X8PXeg/9+GmYH/P6WVzVrrHEFIckZEO2hXXYgFkKI9pKTZGPJT7/H/movH2w8wF8+3sbjH21jZ1kdY3qm8sBb+iZCF/TPYPl2fWnMZUNzmm3LaFDpm5XAhv1OvjvgIi8trtnzimq8LN1WHn398eYS7r+oX4v6G4lozF6xG4Cpo7pxZo8Uzuyhz254AiHeX1+slzn8aCuXDc1hxc4KpozqhsN69I3OVu2q5OZZawGYfFY3huUmNXve0Pr3C8rdOD1BEu3Nt2u3p+LzVRMI6MuqvN7q+mBAQdMipKT0anawJURHaPxk/tCk+MbnPLJwC6GIxsWDsvjT1UNavOv2X64bwvxVe/jvuv0UO3288dX+6F4nFosDt7scn8+JwxFp9b+LJjkDEgyIdiA/uYUQnY7JoJKXFsePzunFbyb1x6AqvPV1ET//7wZC9U/Y//ddGYFwhAHZDr7fP/OIbTXMGsxeubvJ03lN06KzDW98pa8d7p/tQFX02YgDTj3puMTp46UVhTjrN/rSNI06f4jyWj9OT5DfL9rC2t1VmI0qU0Z2a3Jvu9nIjHE9AHhueQGX/usLHvtwKw+9s+mI/fUGwvz8jW+Z8p/VgL7D6rRR3Y54fkqcme6p+kzKt/trjnieqhpJS+vXZNDv8znx+Wrw+13Rp7CHicGOrEK0ViBQSzgcRFWNRwwGVhdUUVjhJs5s4K/XDT1iINycjAQrP7mwL3+8ejAAy7aVRX8emM0JqKqBcDhwXHsO+BrNDMgyIdEeZGZACNFpKYrCbWf3JD8jnjvnr8MXjDC2VyrTx/Tg1S/3khZv4acX9kFVj/w08I4JPXntq32sLaziqqdX8OKMs4i3GLnmmZXsr/bSJckW3eRsxtjuvLx2H9/uq2HMY58ytGsiRoPKuj3VzFu1h9d+MIYXvyjk2WaqkPzhikF0TbYf9v6Pz+vNuj3VrNxVGX3vnfXFJFhNPHLFwCZPMhdtOMAjCzdT6vIDkJNo5Z27xpHhOHwPhcaG5Saxp9LD+n01h5VVPJTVmkR29nD8fhd+fy11dXo5xlDIF10e0cC7/EYChQuI63UjxvHzAD0YUrRQsxVdhIiVhmo+Nltys0/7nd4gD7y1AYDLh3UhznJ8w6ExPVOxmlSKnT7mrNzNjHF5qKqBpKQ8qqp24vFUkJCQg6oaWt73YON9BmTTMdH2JBgQQnR65/TNYNUvz2dvlYe+WQlYTQYuasHaYIDcFDt/unowv313M9/ud3LH3K+4eFA2m4v1AKBhR9IL+mdy5fAuGFSVb/fVAPDt/oNlDQsq3Jz9+Kf4goevs//bdUO55oyuzd7fbFR5+fbR1HgCLFizl83FTj7YWMK81XuYNrob/bL0Afjy7eX836vfEIpomI0q14zoyh0Teh4zEAA9GHh3fTHr6/vdEhaLA4vFgaIo1NYeIBhsWn5VC/up2bkADfDumE+maiB01tNUfDoZa8n7JPedCSOfPTwoiARbFShomkYo5MNkOnyfCHH6avj72NysQKQ+sX53pZ4HNGVk7nHfx2oy8JPv9+HRD7byr093Mn1MD1RVwWpNxGi0Egr58HnKsMdnt7jNxsuEvDIzINqBLBMSQpwWkuPMDM1Nwmpq+RO6BleP6Mq7d4/DYlT5em8Nf/zgO+DgPgQXDcziP9PPwGI0cO0ZXfngnrP5/RUD6ZelV+DpkxlPkt0UDQSmj+nO0p+dw8SBmfzu8oFHDAQaS7KbuevcfJ6edkb06f3izaUAbCpyctvcr6K5EGt/dT6PXT34iDkOh2rIJ1i/r6bVG4sZjfqfwaElR/1BL1qXSwGIaODcMYfKT69DK3ofbxjKv5tFzTwzdUtvIOyvAaB26Q0cmG2m9rMb0DSNoN9FOOhGC/uPuNyopqaQ8vItlJd/d9wJm6Lzafj72PD3s0FDnsCmIv3vyqVDshncJfGE7jVjbB4JFiOV7kCTpXZ2expsfAT3GzloK2e0uD1fk2pCMjMg2p7MDAghRAv0TI/nimE5vP7VfgC6JttY+rNzqKgLkOmwNFmKMCDHwYAcB9eflcvKnZWM6pmCLxhhbWElWYk2hnZNRFEUnrvpzOPqyyWDsli+vZz3vi3mimFd+Mnr6wmEIpzTN52npo3AYmxdwDMgx4HJoFDlDrC3yhPdX6EljEb9iXwgUEcw6I0+off5amDww/pJRQvxhIGiD6LXBTUIhoGC16krfB2zwY4vpD+prS18HV/ZaoJufaM0VQGrCqYeU7BPmI/f7yIY9BAMevD59NmXYNBDZeUOHI4uxMe3bNZHdE6hkI9IRH+ifmgwsHxHBbNX7gbg15f05/YJPU/4fmajyoQ+6SzaeIBPt5YxvD6R2GZJoLboPYLowXCSosCYl47Znj8sy4RE+5KZASGEaKF7L+hDfoa+7OCe83tjNKhkJVqPWIHEYjRwbr8M7GYjKXFmLhqUzbDcpBZXLDmSiwZlkWgzsaOsjgl/+YztpXXYzQYeu3pwqwOBhn4Oz9UHMJ9uLWvVtUajFbNZDx5qagrRNA2vtwqPR89xSBn3PJb63zRWFdLN+uAeQAFMij5z0BAINGgIBEA/7gmDc9crHCj+kqqqXdTWHogGAnZ7GnFx+myJy1VEZeWOdpklONqMhWh/mhbB5SqirGwzoP/dPLSSz5vr9GB+4sBMbjs7L2b3bijR2/jfj8Fkx9FrMgC+CFA4u0V/XyKNVhL6TmDDQSFaSoIBIYRooZwkGx/939l88Ytzuf7M419nfKKS7GZ+cUjp0td/MIbsxONfN9+QQ/GP/+2gos7f4usURSElJR9VNRAMejlw4GuqqwsBiI/PwhqfTWpKbzItkGIGU8/ppJggwQhZFkgzg8MIcQY9UMi0HAwWTCpkWyDRqAcOdLkcFH1C22Q6mGydkJCNw3Hw/4ff76KqamdMdkuORMK43WXRJ82gLzWp+vQ6Dsyx4p5vRls1k4CvGi14fLtPi9jweCqiCe1Go4WEhKYlg1/4vID3vtU317vhrNwTDsobO6dvOooCm4td7Gy0Y7l9wssoXS4jokGox80tyodpvEnikTZMFCKWJBgQQohWMBrUZqv+tLfJZ+UyvFsSAD+f2JdBJ7ju+aJBWaiKnhA946W1rcodUFXjYUtzLBbHwcHY5dsx3OCGyQEYOwdz/kwSjKD0mokyJUB87+kkmsDUawaGKQHS+9xEkglSTKD0nEHcjQGyZwRIOnsWqmrEZkshLa0vNlsKDkdXDAYziqJgs6VE769pWkx2S66pKcTp3Ed1dUH0Pa+7FN/u/wJQF4aqbS9R8XIKZfMTCL7d64TuJ45fw0yRzZZCRsYgbLbkJsf/Wz8rkJ1oZVx+WkzvnRpv4Xv1uTx3v/x1dH8ARVEwGfQAIBhqWTJw4/G/BAOiPShaa7PFOhGXy0ViYiJOpxOHw3HsC4QQ4iRS5Q7w+Y5yJg3Oxmg48Wc7i7eUcvvcrwB46ZazOLdvRquuDwY9OJ368h59tuAoaWmHVg1q7jW0qrJQJBLC53NiNsdRUbGNSCREQkL2YU+Ij92Q3pdAoI6Kim3Rt+Pjs6LVk9j4CBS91/z1XSahDv0jVmsicXGZ0TyKcNCDwWCSsqptIBTyU16+GU3TyMgYeFiuQFmtj5F/XALAut9cQGq8JeZ9KHX5mPTkF1TU+fnhOb302btIENc8M3VhsBkg+abAMf//9/3NIvz1ccN1w5P5yw1jY95X0fm1ZowrMwNCCHGKSokzc8WwLjEJBAC+PyCTW8fr66h/v3AL1e4AgVasWTaZ7KSl9SMtrd/RAwE4fEDU3OtWDppV1YjdnorRaMXh0Cs0eb3VgJ5LUFGxVV/u08y6bX3HWjeeZTfgWWCGVbcclndQV1eiBwIAg36FqdEfe5IJzA2vixYRCfvweCqprNxOJBKibtkUSufFUT7XjP/zG9HCgVZ9NnFkwaCXysptaJqG2RzXJBDYsL+GsY8tiQYCA3McbRIIAGQ6rPz2sgEALNxQrM+uqSasvW4CwBcGbfXtx2wn3OifXEhmBkQ7kGBACCFE1D3n9SY9wUJBuZvhv1/Mdc+talVAcLKwWpNQFJVQyEdx8Trq6koIBNzULptG7XwzoRXTm5xfU1NIxZv9qNn1OjVBcO+YjX/VnaCFSEjIia4vN5ls2O2pJCX3Iq3PzTiMes6D3QDJ+VOxqpDQczLJKX1QVSORSIiqiu+o3fUqAMEIVO5YgHO+BVbf2u5/Lp2NpkWori4gHA5iMtlITm66TOv55QUUOw/mjtx+9olXDzqa8/tnYDGq7Kvysq20FgDz2BcxKqAB7p1zYNUtR7xe07Qmy4Qip94/PXEKkmBACCFEVKLdxD9uGIaxPov32301PL/88B2TT3aqasBuT236phbCXfg6tSGo2D6P8IqbAX2tuXfNPeDdHz3VGYLA/vfh49HYNz5ASko+yck9SU8fQFJSD+z2NJSxs4nvPYN4I9BzJobxC0iZHiDhnFew2ZJJTe2NoigEgh40DlZPAr06kmvbLPzuEnw+Z6v3dxA6r7eaULAOg8FEamoffRlWvTp/iMVb9L04zu6dxv0X9eWKYa1cMtZKdrOR8fX5CJ/U7wOCaiK+p15VqC4MkYLZR6wqpGmRpjkD8vdCtAMJBoQQQjQxLj+Nt340lquHdwHgr59sZ+6q3UROsSULCQldsFgSsFgcZGQMwmC0g01fPhTRwLdrLkSC+DxlULwImwFSTWA3HqzKZDeAYfccLCbbYQmpgF43fnIARr+ov260tMlkspOc3AvVYMWQeyVpZkhP6YW1/jdvXRgqX8umatl0vN7KNvtz6Kw0TcO94jY9YNv62GFL077dV4M/FKFLko25M0fyo3PyY1pB6EguHJgJEA1EAGwTXsYU142IBnXmHkdcAhcKN50KkARi0R4kGBBCCHGYIV2T+Ot1Q6O7sz707mYefn/zKfUEW1UNpKb2ITW1N0ajhdTkPKz+/Rjrx4OujEkEg158X/4U0MubWnpNJ2m6h5SkPBKNellTes48ev7CUY5ZrYlkZg4h44K3ME0NwBU7Sep9I3GNt4Moeg9PfUlM0XKupTcQ3PcOCmDb9+phT9s3FenVhYbmJrZLENDgvH6ZKApsLHJSXOMFQNFCJAT05Hp37W4i9bNShwof8s/rVAvAxalJggEhhBDNUlWFf04exmVD9aUVc1ft4U8fbj2lAoLGjOZ4UvrNJNkE2LuiFS+ifEEikaL3Man1S3hGvwCA9eoC4qa6UaY0eup/nBRF0Qej9UGDOm4eiX1mkGauP6HL5UdcDuL3uwiFWr7vw4kIhwPUufYT8lW3y/1OhOavwbv7DUDP2TD2mnFYULaqQJ9tGZhzYmV3Wys9wcIZ9bsQ/++7g0uFrPkzorkD/oK5zS4VihySJCCxgGgPEgwIIYQ4op7p8fxrynAevWowAM8tL+DX72w6JZOKARj9IqbJbmz+g/kBBuXgngZNBpRGe9uVAR3zEuapAbJv9qEM+S3hcKDJJmk+n5Oysk1UVu6gvHwLfn9t0+vrB5KapsVkF+RIJET5kutx/TeXildSqP1vHqFA3Um3w3I4HKD6jTzKX04moukb1NkdvfTlWo28/uU+lm4rB/QKQu2tYanQy2v2Hny6P+YlLN2vBSDY9bpm/24FD1kmJNWERHuQYEAIIcQxTR3VLVo28eU1e/nxK18fNnA5ZRjtJPedSYZZXxqUYtIDAkY93779UE0oBgsWiz5YdTr3AfquxzU1u6MzApoWoaZmd3RGxrNsCt4FZsIrbqZs8ZVUzDWfUGWiSCRMTdVOIvvf1V9rUOvaTfn8BHwLTqztWHNV7cBbu5tQ/RjZbgDFs+uwoOXNr/Vgr2daHGN6pR7aTJu77oxcEixGtpbU8smWg0vATKOfhS6XEtjzRrN/rhHt0JkBCQZE25NgQAghRIvcMi6PWTPOxGxU+XhzKdc/t4p7X/2Gn73xLb5guKO71zqjX8Q4NUBinxn6fgHHygtoQw5HLoqi4Pe7qKsrweMp1/dDAFJSeqEoKuFwgLKyTbg+u56aXa9SHYTSbXMJ73+PQAQCO2ehBd3Hdf/a2mJ8ATd0uZx4A1jqRwYaUB2E4M5ZJ8UMQTgcwPv1rwCIr0/2djST0+ENhPlmbw0AL844C4vR0ExrbSs5zszUUd0AeH/Dgej7JoMJihbqwUzB4X+ukkAsOoIEA0IIIVrsvH6ZPHfTGZiNKt/sreGd9cX8d91+3l1f1NFdaz3VdHg1oA5gNFqw29MBfXM0l0v/s0xK6o7VmoTDoVd1Coc81BW+0WwbFQEonR+Pb/k0CHn0QWYLB/C+hhyBwQ9hn+Iite90si16UKAB3pNkAsjr3A1F72FRwWECyxR3s//vPth4gEA4Qk6ilR6p9o7pLHDJ4GwAPtpUwtd79T9jozkeulxORINIjxmHBaDhQ3MGJBgQ7UCCASGEEK1ybt8Mlvzke/x8Yt/oe3NX7WmSWLy7ws2clbtPjaVEHTQj0JjD0YX4+CwURf+1rCgqVquehBoXl0FaWl9QjNDlUv0Cw+GD3IgGVTtfpnReHCVzzNTOP/YSn0CgjnBYDxrS0wdgNCfAmDkoUwLYe04B9J1zWXtnjD5p60VCXqre6IHrHf3vm82APhvQTE6H0xvksQ+3AjBtdPd2rSJ0qCFdEzmrRzLhiMZv390M6P9fDcN+DxNXEzrz34ddc2iOwKHVhYRoCxIMCCGEaLXcFDt3nZvPNw9+H7NRZXOxi/X7agAodfm4/rlV/Pa9zby8Zm+z13+7r4bFW0pPveVFbURRVByOLmRkDCQuLoOkpO6o6sHlLWZzPGx8BIoWQs4kUlQPJgXSzJCclEeGWV8/D/oAMqJBbejoS3w8ngoqK3cA+o7NJtPB/RVQTVjGzgIgpEFkV8csFQp8MZ2SuXZ8tXsAMCro+zSMfPawc/2hMD95bT0VdX56psdx29l57dzbphRF4R+ThwOwqdhJtTsAgMFgAcVIOHx4lahDqwnJpmOiPUgwIIQQ4rglx5m5dIi+HOKqp1fy/SeWMenJzymr1Qc679QvH9I0jRc+L2Di35cz+flVXPPMSm6f+xVXPb0yOkhqqW0ltTz12U58wTBltT5e+3IvTm/Hr2mPBYPBTGJiLjZbStMDkSBxJe8BkFC2CGv+DNItYM6fie3qAoyT3STVlytNNoG5/re7t7lYK+QhEgnhdO5D0yKYTHaSkrofdppqtKJ2vQKAcI/p7T6DEvbXULVjXvR1nEEPftRezed3zFu1hyVbyzCqCn+8cnCH5AocqkuSjT6Z8WgarNyllzo1Gi0A+Hw1h51/2MzAKTCxJk59xmOfIoQQQhzZnd/rxcebSnAHwuwoqwMg0Wai1hfkm701fLatjMq6AH9Y9N1h1353wMUFTyxjeLdkRuYlc37/THqlx7NgzR5e/LyQBy8bwJ4KNws3HOCnF/ZlcNdEJj+/impPEG8gzJKtZXx3wMUv3tzI6J4pzJ05CrOxEz7nUk04+tyCZedLWPJvgTGz9OpHDYNio10vVzrqeYgE0VbcSmDXq4S6XoumRVAiQYLhENVv9cPo3UvY3h1t/JuYTDbS0/sf8baG4Y8RGfgA4dR+tGco4Fs+Deeul6N19pNN9cuDrnfrn/UQmqbx33V6BaEHLunfIRWEjuR7fdLZXlrHoo3FTBqSjbF+h2uvtxqLpRK7/WBfJWdAdARFO1V3j4kBl8tFYmIiTqcTh6P96xALIURnUery8fKavfxzyQ4MqsK8W0fywcYDzF/d/DKh8/pl8LML+3L73K8oqt+l9VjS4i1cNjSbl1bsPuI5913Qh3vOz+fTrWUMzU0iLd5yPB/nuJXX+nnnmyKuHN6F9ISm995X5WFzsYvv9UnHZj7Op9aRYIue0AcCdVSUb4ZNj0LRe/qOx7nX4N79ZvQc5cIVpKQPxmJJOGI7VVW78PlqSEzMJS4u4/j63ErBL26iYvt8NPSSr2nm+tKvPWceMdH7uWW7eOzDrZiNKl/+6gIS7R2fB9JgS7GLS578HLNB5ctfX4DDZsDp3IvHU4miKCQn98Jq1TdG+66ojIv/9WX02kHZZhb+3/c7quviFNaaMa7MDAghhDhhmQ4r932/DxcPziIU1hjUJZEzu6dwoMbHkq1lANxwZi6/v3IQG4ucDO2aiNGg8uG9Z7NiRwWFlW7e+rqInfUzC43ZzQY8gTAVdf5mA4HHrxlCjTfAox9s5dUv95Iab+Y372xiaG4S7/xobMySSNftqeLXb2/invN78/0BmfWfI4n91R7mrtrDsNwknvpsJ1tLannrmyL+cOUg4i1GemfEU1jp5tpnVlLtCZKXFsebPxxLSpwZTdNa178WLtUxGq36N0X60iJ3GJTdb4K9K0bvfuyOPKxZZ0SXrByJwaBvk+x07sNmS0FV23bYoIUDuHbqgYBF1WcE1J4zms6CNOILhvnV2xt562t9OdovLup3UgUCAANyHPRMj6Og3M2awkouHJhFUlIPNC2C11tNbW1RNBg4tLRoRJYJiXYgwYAQQoiY6Zd18AmU2ajy/PQzWba9jNxkO70z9SfQZ3RPjp7jsJq4uL4E44/OyWfdniq2ltRyyaBsPtxUwvLt5TxyxUA8gTBT/rOaA04fZqPKm3eO5Ucvr2NQTiLXndkVfyjCP/+3gwNOH795ZxOgJyl/uKkkWuLxeHy2rYzHPviOK4d34b9f7aegws2PFnzNsNwk1u+rYdKQbNbvrTlsduO7Ay6ueWYlAEZVabIWvLDCzS/f3MDtE3ryowVfM7ZXKn++ZghWU+zWuKuqUZ8VaEQz2MGzn7Q+N6KOn3eEK5tqHCxUVxeSmtq7ZR1omMFoSDo+VhATCaIpRso+vSG6Tt6RfyPq2FlHvfbfn+6MBgJ3n5vPzHE9Wta/djYqL5WCcjdrC6u4cGAWAImJ3fH5nASDXgKBOszm+MM2HZMEYtEeZJmQLBMSQohTwt5KDz//77dM6JPOXefmH3b8vtfW8/Y3Tfc76JkWxyf3TcBoaH0ewf5qD99/YjneVlQ8Oq9fBhcNzOLtb4rYXemmyh3AH4pE+/KHKwdx06y1h20m9cuL+3Hn93q1uo9HFAlSPc+ML6xvzOXU9zDDrOrLbpgcaOFyIzcVFVujr1NT+xx1WVEo5Kdm6WSU/e+gxnUn5N6DTYW4/JtRxs5uNjjwfn4jwcIFWHpMoXLnK4BeNSij3wx9H4gj+GJHBTNeWksoovHE9UO5ekTXY36ejvL2N/u577VvAVj44/EM6qLPBNTU7Mbj0fMGkpJ6sK6giGueXx+9rne6icU/vbAjuixOcbJMSAghRKfTLdXOaz8Yc8Tj91/Ul893VFDp9vOPG4bxu/e3UFDhJv/XH3JWj2SuOzOX/Ay9ssuw3CQM6sHlOd5AmIUbirloUBYJVn2gOm/VnmggYDLo5z5wcX/e+7YYlzcIChSU67v+PjV1BBcOzMRUH3Rcf1YuAJ5AiH1VXirdfgZmJ5JoN3HDWbmHlVz9ZHNJq4OBWl+QRRsO0DsznjO6H1J9SDWR1OcWtIKXUOPz8VXvJKhBkhHIm9Hi5UZmcxyZmYOprT2Ax1OB11uJ2RyPpoVxu8vx+10kJ/fEYNDbq/5sMsF979R3UC8HGoxAcMcc7KWf46opAAUS828iMOh3mM3x1OxYgAbU1QcCAEkmoHB2s8uDNhU5eXbZLhbW7+x74YDMkzoQAPj+gCxyErdR7PTxzLJdPDV1BAB2ezoeTyVebzUOR+5hCcSyA7FoDzIzIDMDQgjRadR4ApS6/PTNSuDFLwr5/cItzZ43LDeJubeOxGE1oWkaP3n92+iswo2ju3HNiK7cPGstLl+I/0w/k6FdEwmEI3RNthOJaCgK+IIRHnx3E5GIxl+uG9okuDgaXzDMvz7dQWGFm9vO7snVT+vLif509WCuPaNri2YxthS7uP/Nb9lU5MJqUln6s3PJSrQefmLDcp1Vt6AVzEbpOeOoT9uPJBCoo6JiW7PHrNZELJZEPHXFBBcNa3LMqOj7FLRGohHijDSbMOwPhTnvr8uiy7IuHpTFH68aTEqcuXU36QBf7q7iumdX4bAa+frB70f/P5eXbyEY9JKYmMuGYh9TXtwYvaZ7spFlv5jYUV0Wp7DWjHElGJBgQAghOiV/KMwP53+NpmkkWE28921xk+NTRuZiMRpYtr2cwgp3s210SbKx/P5zWzzQPx63zv4ymmTdPdXOy7ePpkuS7Yjnv/dtMfe88k2T964e3oUnbhh29Bu1sBLRkVRV7cTncx79pI2P4Ch9D6s5HjVchxrXi8qaXfiPkQjrqF+nEAESDKDc0HwJ0VfX7uWXb+mD5VkzzuS8fpnH8Uk6RjiiccYfFlPjCTL/1lGM750GgNtdhtO5D5PJzrYqOze+tCl6TW6Sgc9/eVFHdVmcwmSZkBBCiNOexWhg1oyzAAiGI4QjGgZV4ay8FB58ZxOvrN13zDZuHN29TQMBgKdvHMGsL3bzn88L2FPpYc7K3fzqkv64fEFeXrOX3GQ7Fw/KQlUVguEIj7y/ucn1igJvfVPE+f0zmTTkKMnSJ7hpWFJSHm53GSaTHYPBhNtdjqaF8XqrATCZ7CSe+zJmo1m/V8gDRjuWZVPw73oV7F1xBPajoA/6rSrUhfWqQXYDkDcdCufqMwLNBAIAr3yp/z/71SX9TqlAAMCgKkwanM2CNXt59cu90WDAZkvB6dxHMOghEGyaRC6rhER7kGBACCFEp2cyqDw1TV+n7faHePqznZTX+pk0JJuReSlcOjgnWpLy673V7Kl0892BWmaM7dHmfbMYDfzwnF50S7Fz18tf878tpSTZTfz1423RweBlQ3P4xw3D+Gp3NRV1+o7NqgLzbx3Fsu3lPLe8gB+/8jV7q/rxw3NimIjciKoaSEg4GGwkJXVH0zQslkTC4QBxcRmoaqPBbP2A3jzmP+Crg6KFmHtPw2yyQMEs6DGdZEXVcwMalgSNeqHZoGV7aS01niDf7qvBqConfY7AkUwZ2Y0Fa/byyZZS6vwh4i1GVNWIxZKA31+L19e0tK7sQCzagwQDQgghTitxFiMf/d8EIppGcjNrzUd0S2ZEt2SuGt6+/ZrQJw2TQaGgws3jHzVdn//+t8X0TIuLJjQ3XhY0qmcq5bV+3vqmiL99so0rh+eQnXjkZUbNiUQ01OOYAVEUpckOus0xGUwYiheCAqa9C2BKAEY+e3DQ3zhJ+JBAoKzWx2/e3sQnW0qj710yOLvdN5OLlYE5DnqmxVFQ4ebDjQe47kw90dxsjsfvryUQ9DU5P3L6ruQW7agT7tkuhBBCHF2i3dRsINCREqwmfnjOwZKpU0bmUvjYJTxx/VAAnvx0B88vLwDgvP4HdwM2qApP3DCMkT1SCEU0Hv9oG2UuHy1NCVywZg/5v/6Aq55eQZ0/FMNPpFMMFtL7ziDdDEqvmfqAv/Gg/yjLl+57bX2TQMBsVLnn/BbudXASUhQlupTrkfe3sKtcnwkwmfRZlHD9/7L64lWEI7T4/6MQx0tmBoQQQoiTxH0X9KZXehzxFiPn9s1AUfQlMWsKqnjtq4M5Dmf3Tj/s2nsv6M3UF9bw9jdFvP1NEUNzk3h62giWbStnXH4q3VPjDtvxOBLRePqzXUQ0+GZvDUu+K+WKYV1i/rnUsS/B6OZ3ET6SfVUeVuysRFHg7R+Nw6AopMSbj5pcfSq4Y0JPvthZwTd7a/jd+1uYO3NkNBiI1K8LMxkVwkEtGhwI0ZZkZkAIIYQ4SSiKwhXDunB+/8wmy3YeumxA9Ptku4lE2+GD6rH5aTx06QDiLfpzvm/31TDuT5/yq7c3cu2zq3jqs50MeOhjbnhuFZV1fqrdAf780dYmuyc/uWQHwbZaqN6KQGBriYvps9YCMLZXKsNykxjcNfGUDwRAnwH6+/XDMKgKy7eXs6O0FoNBn6VqGPyb6v/f68uEJCIQbUuCASGEEOIkF2cx8vsrBwHw8OUDj3jezPF5bPjthfzvJxPIabTvQHmtn798vA1vMMyawiqmvbCGC55YxnP1y47O6J4MwK5yNze9uIZAqGMyVyvr/Hy8uYQr/r2Cwgo3qgL/d36fDulLW+qRFsd5/fSlXq/VV0hKS+sbTRg2G+uDAVkmJNqBLBMSQgghTgE3je7ONSO6YDcf/Ve3qirkZyTwyU++x5e7qzCpKjNeWksoohFnNuAOhNlaUhs9f2jXRObdOpK/L97Oi18UsrqgijvmfUWizcRZPVKYOrLbcSUXt1RZrQ+nJ0h6goWJ//icijo/AOkJFn59SX9G5qUco4VT05SRuSzeUsprX+7j7vPySbBYognDZoMKhOurSUkwINqWBANCCCHEKeJYgUBjDXkHAP+eOoLtpbXcMaEnlzz5OXsqPdw0uju/vLgfVpNeDvTXkwYwMi+V2+d+xdJt5QC8u76YQCjCzPF5sf8wwFtf7+c372wiEIpwdu+0aCAwtGsir9wxulWf91RzTp8M+mTGs720jh/O/5oFt50VLSVrrK/QGopoMjMg2pzsQCw7EAshhDiN1PqChMLNl1UF+PNHW3lm6a4m7/XPdjBtVDduHN39uO+7qcjJ4x9vY+sBF9lJNpyeALsrPYed95tJ/Zk+pgdmY+dfyfztvhqufXYlwbDGWz8ayzc7NvP7xU56ppopqAxgVGHb7y/Uqwud4KZx4vQiOxALIYQQolkJ1qMPKu+f2JeRPVLIz4jnTx9uZdHGA3x3wMVv3tlEXloc4/LTDrsmEIpQVOOloLyO55YXkGAxMrBLIsu2lZGVaGXmuDzumLcOpzcIQFmtP3rtFcNyeHd9MQATB2Zy6/i8JhWPOrOhuUlcPCib974t5oMNB8iw1lcTMjQkEIPni+kEC18lsfdNGMbN7cjuik5KggEhhBBCRCmKwrn1ya3/mjKcm8f24B//287KXZXMXrmbYblJPPjuJj7aVEJGgoW/XT+MX7+9sUkeAsCSrWUAfLvfycebSw+7T5ckGz/5fh+uOaMrlw3JwR0Iccng7NMmEGhwyeAs3vu2mE+3lXH9YH19kLl+mVBEA9fOV1EUCGyfR6aiooyd3XGdFZ2SLBOSZUJCCCHEUe0sq+WCJ5YDMLxbEt/srTniuZkOC5oGqqJw7RldmbtqNy6fvpnZ49cO4ezeacRZjDiOMUNxunB6gwx/5BMiGtx8VhxzvnQzvIuFb4r02ZPPh/wQg0+vOJRqAsu0gCwZEscky4SEEEIIETP5GQlcOiSbhRsO8M3eGoyqwp+vGcLslbvZWOQE4OlpIxjcJZGuybYmT/eH5iZx+9yvsBhVLuifScpJtvNzR0u0mRjSNYn1+2pYWagHAPU53QBEvAeiOxJ7ImBZeyeMfFYCAhEzEgwIIYQQ4pgevHQAdrOBrEQbFw3MYkCOgwsGZDJ/9R5G5aVwZo/mS4B+f0Amb/1oLKqiSCBwBN8fkMn6fTXsqNBnUCwmE6AHBuHsy8iuepuKAHjDENo6i4Qds7D2ngmjX+zAXovOQpYJyTIhIYQQQnSgEqePsX9aEi0teuGATD7ZoudZLLunJ90zulM1Pw5f/aZkCpBpAXWKLBkSzWvNGLfz1+0SQgghhDiJZSVaualR2VZLo3VCimICo53E3jfRsPebBtSGQAu627mnojOSYEAIIYQQooNdd2Zu9Ht9B2KdoloAMIybS3qf6TjqF3i7w1DxcjLhd3u3az9F5yPBgBBCCCFEB0u0HVzu07DPAIDVfnBfB8O4Odgnu2g4GtTAVbMTAs726qbohCQYEEIIIYToYI1LreqlWRu+b7rvgmpOIK3vwRkCbxi8ryXB6lvbqaeis5FgQAghhBCig8VbDxZ4rAuEMNRHA6HI4XVeTOPmED/VTXx9aoEzBOFdsyDkaZe+is5FggEhhBBCiA7WMPgH8PgPBgPLt5cTaSYgwGgnoc8tmFR9p+JSP9S9HCczBKLVJBgQQgghhDiJuP1hfEG9jugv39pIz199wNxVuw87Txn1HMlGojkEtQ0zBJFg+3VWnPIkGBBCCCGEOInU+UOHvffQu5vZV3XIMiDVhDF/Jun1e7lpQE3WNWiK7CkrWk6CASGEEEKIk4gncHgwADBn5e7D3xz9IsapAVKnVKBMXIO//wOUlW2kpmY3kUgYgFDITyTSfJtCSDAghBBCCHESqfOHo9/bzQZmzTgTgLmr9vDC5wXsrTx8hsBiS8WRlAdAOBzE46mkpGQ9tbUHKCvbRGnpBgIB2aRMHC7mwcBjjz3GWWedRUJCAhkZGVx55ZVs27atyTk+n4+77rqL1NRU4uPjueaaaygtLW1yzt69e5k0aRJ2u52MjAx+/vOfEwo1jWqXLl3KiBEjsFgs5OfnM3v27Fh/HCGEEEKIdhUMR6Lf981K4Jw+GeSlxREIR/jDou+49tmVlLl8h11nt6cRF5fe5L3a2mIANE3D660iHA4SDgfa9gOIU0rMg4Fly5Zx1113sXr1ahYvXkwwGOTCCy/E7T4Yjd533328//77vPHGGyxbtozi4mKuvvrq6PFwOMykSZMIBAKsXLmSOXPmMHv2bB566KHoOYWFhUyaNIlzzz2X9evXc++993Lbbbfx8ccfx/ojCSGEEEK0uSenDCfRZuKZaSOi7yXbzaiqwh+vHBTdmbis1s+PFnx9WJUhRVFITOxGTs4ZOBxdD2vf56umvHwLZWWbCQTchMMBtLC/bT+UOOkpmqY1U68qdsrLy8nIyGDZsmVMmDABp9NJeno6L7/8Mtdeey0AW7dupX///qxatYrRo0fz4Ycfcumll1JcXExmZiYAzz77LL/4xS8oLy/HbDbzi1/8gkWLFrFp06bovSZPnkxNTQ0fffRRs33x+/34/Qf/0rtcLnJzc3E6nTgcjjb8UxBCCCGEODZN01AUhR6/XATA1cO78MQNwwAoc/nYXenhlpfW4g6EeeX20YzplXrEtmpqduPxVGIy2QmFfGhapOkJGx/GemAhKf1mwugX2+ojiQ7gcrlITExs0Ri3zXMGnE59i+yUlBQA1q1bRzAY5IILLoie069fP7p168aqVasAWLVqFYMHD44GAgATJ07E5XKxefPm6DmN22g4p6GN5jz22GMkJiZGv3Jzc2PzIYUQQgghYkBRmu44nGg/uDNxhsPKyLwULhuaA8CU/6zmLx9vbX4fAiApqQdZWUNJT+9/2PIhNvwWihbii0Bgp5QjPZ21aTAQiUS49957GTduHIMGDQKgpKQEs9lMUlJSk3MzMzMpKSmJntM4EGg43nDsaOe4XC68Xm+z/XnggQdwOp3Rr3379p3wZxRCCCGEaCt5aXGHvTd1VLfopmRPfbaLjzeXHPF6VdXLjMbHZ2M2x+tvbnwYihdFz/HU5ytrmkbAVx2bjotTRpsGA3fddRebNm3i1VdfbcvbtJjFYsHhcDT5EkIIIYQ42fzjhmFce0ZXpozsdtixIV2TWPOr87nhTH2Fwx8WfddsQnFjqmogLa0vmen9iS9ZCIDNoB/zRUBbdSuupTdQ8XIKdUtvkJmC00ibBQN33303Cxcu5LPPPqNr14NJLFlZWQQCAWpqapqcX1paSlZWVvScQ6sLNbw+1jkOhwObzRbrjyOEEEII0W6uHN6Fv143FJOh+aFaWryFX03qT15aHEU1XkY+uoS/L96OLxhu9vwGBpOdhD63kGGGpPybMCgQ0eDAtnm4C98AwFXwOq75ZnzLp0qC8Wkg5sGApmncfffdvP3223z66afk5eU1OX7GGWdgMplYsmRJ9L1t27axd+9exowZA8CYMWPYuHEjZWVl0XMWL16Mw+FgwIAB0XMat9FwTkMbQgghhBCdWaLNxD8nD4u+/ueSHTz2wXes2FnBP/63HX+o+cBAGTML49QAyri5JPeagqocfk5dCKp2vkLlPCusuqXpwYZZg8azB5GgzCacomJeTehHP/oRL7/8Mu+++y59+/aNvp+YmBh9Yv/DH/6QDz74gNmzZ+NwOPjxj38MwMqVKwG9tOiwYcPIycnh8ccfp6SkhJtuuonbbruNRx99FNBLiw4aNIi77rqLmTNn8umnn3LPPfewaNEiJk6c2KK+tibTWgghhBDiZPTnj7bywucFBMNNh3Q3je7O7y4fSETTOOD0kZtib/Z67d18wrW7AFAUcIXA2yiOSDGBNX8GjHoe9+c34y98BUN8DwK1u4nrORlv0I+2/20SjWDK1ysTBQJuTAYTisHc4s8RCvlwuYqIi8vAYklo9Z/D8dK0CFrYr+dXqKZjX3AKaM0YN+bBwKFZ8A1eeuklZsyYAeibjv30pz/llVdewe/3M3HiRJ5++unoEiCAPXv28MMf/pClS5cSFxfHzTffzJ/+9CeMRmP0nKVLl3LfffexZcsWunbtyoMPPhi9R0tIMCCEEEKIzuK2OV/yv+/Kmrw3c1weX++tZv2+Gl6+bRRj89OavzjkOTgQXnMHkYLZ1IX1GQIAswpG5WCycXOsKqSYwX1ZEc6VP8BespCkvjPRRr2AooUOH2g3zCTUv19TswePpwKA5OQ8vN5qzOZ44uObFow5mobSrA3C4QC1tcXY7emYzYcnY2uaRvn/riK0710SjJDQewaMean5xkP1Oz8bDw+qIoFaXJ5KIpEQiYndMRg6Nqjo0GDgVCLBgBBCCCE6C6cnyH2vr0dVFCKaxqdbmwYGlw/N4ckpw6Ovd5bVkZ1oJc5iPLQpiAQJBr2Uvz0QPPtbdH8FSOw1mRqvE4o/BCDVDDUZl2Eofp+UvjPwD/kTFksi3pUz8Ra8QrwBrL31gKGs5GsOmdxAURQyMgYfeXDdKKCoqyultrYIRVGxWBKJi8ugpqaQUMiP0WglI2MgXm81BoNJr6wU8uBecSvOXQcL3SQawZ5/M4x6DkULg9GO11tNzbtDMXj3oSqQ4OiJ5cqt+u0jYere6U+dazfYc2HC21gsCaSm9mnRn1lbkWCghSQYEEIIIURnFApHGPOnTymvPZgAbDMZmDNzJIu3lFBe6+ed9cWMz09j/m2jmm8kEqR8rplgBFQFTIr+XwX9y6qCOwzxRqgMQEsHlGYVgpGD59sN4MmaBEWLoMvlKEN+S+PhaWJiLnFxGYe14//8Rty7FmA1gC3/Fkq7/5DIUdJhExO74XTuBUBZfhWKdx9H2KIBBTAo4EjMo+qMl2DJOU2OGxUINXft978Ag5XExG54PBUkJXXHZGp+eVZbkmCghSQYEEIIIURntXhLKe+uL+L6M3N58N1N7Kn0NHveG3eO4aweKc0ei6y8hUjBbIxHGmPH50PdTpxBPTAAfaDsMOq5B80OmI/CqkLSjV5QjXi9VTid+p5QKSn5WK2JBAJuVNWAa9k0fHveil7XMDhXul6BfdST+Hw1hMNBFEXhsKHuht822WfBZoBAhMNmJQ6VaITaMEcMIIxx3VDP/5hAwB19Lz4+C4ejS+v+EGKgNWPcZuaFhBBCCCHEqe77AzL5/gB9vf1lQ3L492c7mz3vja/2kZlg5dY5X2I3G/jLdUPpk6kn8KpjX0Id/fyRb6KaIBIkce2d2HfOQlX0J+rE5WNIGUntrpcxKvV7GaAfC0T0S82qPgDXODjAtjryUI1W/bj5YBJxVdVOLBYHfr8LtBA0CgTgYNCRXPou1oQ3SEzshqZpaFqYUMhPRYW+rEdFw1a6iIjhYElNhxGCGlQEDraXYoKqRsWREo0QZwS12zVUF7ypt6UcvN6ignLNVrz+2mgwYDCYSUjIPvKf3UlCggEhhBBCiE7u5rE9+GDTAQrK3fxrynC6pdhx+0NMfWENCzccYP2+GnaU1QFw/3838PaPxh5MxD1WhR3VBKNfxDTyWf11JAhGOyYgxWiGwtk4jA4IuQgo8VR49fskm8Bgqn8/ogcJNm+hfr1qwmSyYTCYCIf1Ubnf79Lb36RXllQVSDVBdVAPKBKMYM2fHu2voigoihGz2Uh6en8AjEYbSt+ZUDArOqtB3gzMikr2rlm4QvpMgVmFtG7X4Sp8Q89rMAB5M7CNeQnUqZj2voLRUX89QM+ZYLRhU83U1hYTiYRJSuqOorTp/r4xIcuEZJmQEEIIIU4DgVCEUtfBEqPhiMb4P3/KAefhuxc/fs0Qimq8nNE9mQl90k/sxvWD+4aKRZ4FZlTqB9iTA/rxL++Cwtn6oHr0iwf7HHDjdpfi9Vbrb2gh+Hg0AEkmsE9xwwfDoG4HxOXDFTta16eG/za8t/ZOPVBo6MeqW/R+5c1oWmWo8fXQJGAKBr1EIqF2LY96KMkZaCEJBoQQQghxOlu6rYxb53yF1ajy72kjWL69nJdW7I4et5sNrPzleSTZ9f0CKuv8VHsC5GecwEB39a1NB9wNGg/MG9G0CAcOfANAXFw67tU/hqL3yO5/C8qYWfpJIU+zJT+Py6H9OEK/DvXssl2sLaziJ9/vQ26KHaOqNF+pqR1IMNBCEgwIIYQQ4nRX4vSRYDUSZzGyt9LDhL981uT4zyf25cIBmcxdtYe3vt6PLxTh9R+M5ozuKTg9QX4w/yvS4i385dqh2MwGIhGNlbsqyU2x0T318Nr+QIsH2A18PiehkJf4+Cw8ngpMBjMmS2zGbpGIhqIcea+sBnsrPaQnWLCZDYcd+2JHBTe+uAaA7EQr157RlRe/KOSnF/bl1vF5Melna0gw0EISDAghhBBCNPX3xdv555IdDMxxsLnY1ew5yXYToYhGrS8Ufe/W8Xk8eOkA5q7azUPvbsZkUJhzy0jG5qehaRpPfbaTggo3d0zoSb+sw8dd4YjGl7uryEiw0DM9PiafpaLOT5U7QH56PKp6+GD/o00l3P/fbwF49OrBXDokB03T2FzswmxU6ZOZQFmtj0cXfcc764vJTbHxzLQzGNQlEU8gxGMfbOW7Ay7W76sh1EyZoSenDOfyoTkx+SytIcFAC0kwIIQQQgjRlKZpFNV4SbSZOPMP/8MfikSP3XN+b55ccuR1+YvuGc+v3t7Et/tqou/lpcWxr8oTHSyP6JbEWz8aFz2+v9qD2aiyaMMBfvf+FlQFPrp3AvurPeQk2ZoNHJrj9AT5fGc5xTVewhGo8wf5z/JCAuEIFw/K4m/XD+XjzSX84387yEiw8NvLBjJ91lqq3HoZobR4M8vvP5cfzFvH5zv0nZDP7q3v2NzwGvTE5V9e3I9v9ztZtOFA9P1e6XH0y3KwaKP+XoLVyJe/vgCr6fCZhLYmwUALSTAghBBCCHFk/123n799so3RPVP523VDUVWFdXuqqXIH+HpvNc8s3cWPz8vnlbV7qagLHLvBeiaDQkqcmbN6pPDJllIiEa3Jk/VhuUmsrw8orh7ehUevHozFqOLyhnDYjOyt8vD0Z7v4dn8NpS4fZ3RPYXVBJXX+0BHueGTpCRaq3YEm91cUMChKk/cmDsykyh3gy93VTa7/+cS+9MtKYHTPVKo9AS7/9wqq3AEeuWIg08f0aHV/YkGCgRaSYEAIIYQQ4vjV+UPEW4ws3lLKP5dsZ1ORvqxoxtgeDOqSyP3//RZFUQhHNBKsRvpmJvDVnupjtHo4h9VIMKzhDYbJS4ujyh3A6Q0edl6mw0IwrNEzLY4ku4mLBmWzqcjJ7JW7o+dcOiSb3ZXuaF+fvXEE3+yr4bllBdFzXrz5TPLS4pj6nzWUuHyMz09j3q0j0TRYsGYPTyzeTrUnyKTB2Tw1bUSTPpTX+qn1BWO21Ol4SDDQQhIMCCGEEELEhqZpfLWnmhKnj0mDs1FVBacnSKLdhD8URlUUdle4ueifn2M3GeiSbGNrSS3JdhPVHn1gnxZvoaLOH20zLy2Owgp3s/dLspv4zaQBPL98F9tL6zizezLzbh3VbILvzrI6nv5sJ5cNzeHcfhl4A2H++/V+jKrC5LNyAXhyyU7+/r/tnNcvg1kzzgKgrNbHzrI6zuiejMV4sF23P8Su8jr6ZCZ0yDKgY5FgoIUkGBBCCCGEaF8b9zuJtxpJiTMzb9VurhjWhf3VXlYVVDJzXA9W7Kzk0Q++4zeT+nPRoCz+8vE2nl6667B2fjOpP7ed3ZM6f4gVOyv4Xp/0Ex6Ybypy0jM9Drv51N6XV4KBFpJgQAghhBDi5Hffa+vZWOTk5xP78oN560iLN/PFL847KZ/KnwxaM8Y9tcMeIYQQQgjR6f39hmHR7+fOHEnP9DgJBGJEggEhhBBCCHHKmNAnvaO70KmoHd0BIYQQQgghRMeQYEAIIYQQQojTlAQDQgghhBBCnKYkGBBCCCGEEOI0JcGAEEIIIYQQpykJBoQQQgghhDhNSTAghBBCCCHEaUqCASGEEEIIIU5TEgwIIYQQQghxmpJgQAghhBBCiNOUBANCCCGEEEKcpiQYEEIIIYQQ4jQlwYAQQgghhBCnKQkGhBBCCCGEOE1JMCCEEEKI/2fvvuOjKBM/jn9mW3bTE0ISAgFCkSZNQJrtFAU7dhGxwIl3J2c99bw70VPvLGfX+4neKViwnJ4ih4qioihVkC69EwgBQnrZNr8/NlmyECCEFNj9vl+vvMzOPDPz7BiS+e7TRCRCKQyIiIiIiEQohQERERERkQhla+oKNCXTNAEoLCxs4pqIiIiIiNSPqmfbqmfdw4noMFBUVARAZmZmE9dERERERKR+FRUVkZCQcNgyhlmbyBCm/H4/O3bsIC4uDsMwGv36hYWFZGZmsm3bNuLj4xv9+icy3btjo/tXd7p3dad7V3e6d3Wne1d3und119T3zjRNioqKyMjIwGI5/KiAiG4ZsFgstGrVqqmrQXx8vP6R1ZHu3bHR/as73bu6072rO927utO9qzvdu7prynt3pBaBKhpALCIiIiISoRQGREREREQilMJAE4qKiuKhhx4iKiqqqatywtG9Oza6f3Wne1d3und1p3tXd7p3dad7V3cn0r2L6AHEIiIiIiKRTC0DIiIiIiIRSmFARERERCRCKQyIiIiIiEQohQERERERkQilMCAiIiIiEqEUBhrYE088gWEY3HnnncFt5eXl3HbbbTRr1ozY2FiuuOIKdu3aFXLc1q1bufDCC4mOjiY1NZV7770Xr9fbyLVvfNnZ2Vx//fU0a9YMl8tF9+7dWbhwYXC/aZqMHz+eFi1a4HK5GDJkCOvWrQs5R15eHiNHjiQ+Pp7ExETGjBlDcXFxY7+VRuXz+XjwwQfJysrC5XLRvn17Hn30UapPFqZ7t9+sWbO4+OKLycjIwDAMpkyZErK/vu7VsmXLOP3003E6nWRmZvLUU0819FtrcIe7dx6Ph/vvv5/u3bsTExNDRkYGN9xwAzt27Ag5h+5dzT931f3mN7/BMAyef/75kO26d4e+d6tWreKSSy4hISGBmJgY+vXrx9atW4P7I/Vv75HuXXFxMePGjaNVq1a4XC66du3KhAkTQspE6r17/PHH6devH3FxcaSmpjJ8+HDWrFkTUqa+7s13333HKaecQlRUFB06dGDSpEkN/fb2M6XBLFiwwGzbtq3Zo0cP84477ghu/81vfmNmZmaa33zzjblw4UJzwIAB5qBBg4L7vV6vefLJJ5tDhgwxFy9ebH7++edmSkqK+cADDzTBu2g8eXl5Zps2bcybbrrJnD9/vrlx40bzyy+/NNevXx8s88QTT5gJCQnmlClTzKVLl5qXXHKJmZWVZZaVlQXLDBs2zOzZs6c5b94884cffjA7dOhgjhgxoineUqP529/+ZjZr1sycNm2auWnTJvPDDz80Y2NjzRdeeCFYRvduv88//9z885//bH788ccmYH7yySch++vjXhUUFJhpaWnmyJEjzRUrVpjvvfee6XK5zFdffbWx3maDONy9y8/PN4cMGWJ+8MEH5urVq825c+eap556qtmnT5+Qc+je1fxzV+Xjjz82e/bsaWZkZJjPPfdcyD7du5rv3fr1683k5GTz3nvvNX/++Wdz/fr15qeffmru2rUrWCZS//Ye6d7dcsstZvv27c2ZM2eamzZtMl999VXTarWan376abBMpN67oUOHmhMnTjRXrFhhLlmyxLzgggvM1q1bm8XFxcEy9XFvNm7caEZHR5t33323+csvv5gvvfSSabVazenTpzfK+1QYaCBFRUVmx44dzRkzZphnnnlmMAzk5+ebdrvd/PDDD4NlV61aZQLm3LlzTdMM/MO1WCxmTk5OsMwrr7xixsfHmxUVFY36PhrT/fffb5522mmH3O/3+8309HTzH//4R3Bbfn6+GRUVZb733numaZrmL7/8YgLmTz/9FCzzxRdfmIZhmNnZ2Q1X+SZ24YUXmqNHjw7Zdvnll5sjR440TVP37nAO/ONYX/fq//7v/8ykpKSQf7P333+/2alTpwZ+R43ncA+0VRYsWGAC5pYtW0zT1L2rcqh7t337drNly5bmihUrzDZt2oSEAd27gJru3TXXXGNef/31hzxGf3sDarp33bp1Mx955JGQbaeccor55z//2TRN3bvqcnNzTcD8/vvvTdOsv3tz3333md26dQu51jXXXGMOHTq0od+SaZqmqW5CDeS2227jwgsvZMiQISHbFy1ahMfjCdneuXNnWrduzdy5cwGYO3cu3bt3Jy0tLVhm6NChFBYWsnLlysZ5A01g6tSp9O3bl6uuuorU1FR69+7Nv/71r+D+TZs2kZOTE3LvEhIS6N+/f8i9S0xMpG/fvsEyQ4YMwWKxMH/+/MZ7M41s0KBBfPPNN6xduxaApUuX8uOPP3L++ecDundHo77u1dy5cznjjDNwOBzBMkOHDmXNmjXs27evkd5N0ysoKMAwDBITEwHdu8Px+/2MGjWKe++9l27duh20X/euZn6/n88++4yTTjqJoUOHkpqaSv/+/UO6w+hv76ENGjSIqVOnkp2djWmazJw5k7Vr13LeeecBunfVFRQUAJCcnAzU372ZO3fuQc+LQ4cODZ6joSkMNID333+fn3/+mccff/ygfTk5OTgcjuAfxippaWnk5OQEy1T/oanaX7UvXG3cuJFXXnmFjh078uWXX/Lb3/6W22+/nTfffBPY/95rujfV711qamrIfpvNRnJycljfuz/+8Y9ce+21dO7cGbvdTu/evbnzzjsZOXIkoHt3NOrrXkXqv+PqysvLuf/++xkxYgTx8fGA7t3hPPnkk9hsNm6//fYa9+ve1Sw3N5fi4mKeeOIJhg0bxldffcVll13G5Zdfzvfffw/ob+/hvPTSS3Tt2pVWrVrhcDgYNmwY//znPznjjDMA3bsqfr+fO++8k8GDB3PyyScD9XdvDlWmsLCQsrKyhng7IWwNfoUIs23bNu644w5mzJiB0+ls6uqcUPx+P3379uXvf/87AL1792bFihVMmDCBG2+8sYlrd3z7z3/+w+TJk3n33Xfp1q0bS5Ys4c477yQjI0P3TpqEx+Ph6quvxjRNXnnllaauznFv0aJFvPDCC/z8888YhtHU1Tmh+P1+AC699FLuuusuAHr16sWcOXOYMGECZ555ZlNW77j30ksvMW/ePKZOnUqbNm2YNWsWt912GxkZGQd9Wh3JbrvtNlasWMGPP/7Y1FWpd2oZqGeLFi0iNzeXU045BZvNhs1m4/vvv+fFF1/EZrORlpaG2+0mPz8/5Lhdu3aRnp4OQHp6+kEj0ateV5UJRy1atKBr164h27p06RKcDaLqvdd0b6rfu9zc3JD9Xq+XvLy8sL539957b7B1oHv37owaNYq77ror2Dqle1d79XWvIvXfMewPAlu2bGHGjBnBVgHQvTuUH374gdzcXFq3bh3827Flyxbuuece2rZtC+jeHUpKSgo2m+2Ifz/0t/dgZWVl/OlPf+LZZ5/l4osvpkePHowbN45rrrmGp59+GtC9Axg3bhzTpk1j5syZtGrVKri9vu7NocrEx8fjcrnq++0cRGGgnp1zzjksX76cJUuWBL/69u3LyJEjg9/b7Xa++eab4DFr1qxh69atDBw4EICBAweyfPnykF/6VX9QD/xlF04GDx580JRda9eupU2bNgBkZWWRnp4ecu8KCwuZP39+yL3Lz89n0aJFwTLffvstfr+f/v37N8K7aBqlpaVYLKH/nK1Wa/ATM9272quvezVw4EBmzZqFx+MJlpkxYwadOnUiKSmpkd5N46sKAuvWrePrr7+mWbNmIft172o2atQoli1bFvK3IyMjg3vvvZcvv/wS0L07FIfDQb9+/Q7796NPnz7621sDj8eDx+M57N+PSL53pmkybtw4PvnkE7799luysrJC9tfXvRk4cGDIOarKVJ2jwTXKMOUIV302IdMMTEPVunVr89tvvzUXLlxoDhw40Bw4cGBwf9U0VOedd565ZMkSc/r06Wbz5s1P+Cm6jmTBggWmzWYz//a3v5nr1q0zJ0+ebEZHR5vvvPNOsMwTTzxhJiYmmp9++qm5bNky89JLL61xysfevXub8+fPN3/88UezY8eOYTk9ZnU33nij2bJly+DUoh9//LGZkpJi3nfffcEyunf7FRUVmYsXLzYXL15sAuazzz5rLl68ODjjTX3cq/z8fDMtLc0cNWqUuWLFCvP99983o6OjT/gpHg9379xut3nJJZeYrVq1MpcsWWLu3Lkz+FV9RhHdu5p/7g504GxCpql7d6h79/HHH5t2u9187bXXzHXr1gWnZvzhhx+C54jUv71Hundnnnmm2a1bN3PmzJnmxo0bzYkTJ5pOp9P8v//7v+A5IvXe/fa3vzUTEhLM7777LuT3WWlpabBMfdybqqlF7733XnPVqlXmP//5T00tGm4ODANlZWXm7373OzMpKcmMjo42L7vsMnPnzp0hx2zevNk8//zzTZfLZaakpJj33HOP6fF4Grnmje9///ufefLJJ5tRUVFm586dzddeey1kv9/vNx988EEzLS3NjIqKMs855xxzzZo1IWX27t1rjhgxwoyNjTXj4+PNm2++2SwqKmrMt9HoCgsLzTvuuMNs3bq16XQ6zXbt2pl//vOfQx7AdO/2mzlzpgkc9HXjjTeapll/92rp0qXmaaedZkZFRZktW7Y0n3jiicZ6iw3mcPdu06ZNNe4DzJkzZwbPoXtX88/dgWoKA7p3h753r7/+utmhQwfT6XSaPXv2NKdMmRJyjkj923uke7dz507zpptuMjMyMkyn02l26tTJfOaZZ0y/3x88R6Teu0P9Pps4cWKwTH3dm5kzZ5q9evUyHQ6H2a5du5BrNDTDNKstUSoiIiIiIhFDYwZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVAKAyIiIiIiEUphQEREREQkQikMiIiIiIhEKIUBEREREZEIpTAgIiIiIhKhFAZERERERCKUwoCIiIiISIRSGBARERERiVC2pq5AU/L7/ezYsYO4uDgMw2jq6oiIiIiIHDPTNCkqKiIjIwOL5fCf/Ud0GNixYweZmZlNXQ0RERERkXq3bds2WrVqddgyER0G4uLigMCNio+Pb+LaiIiIiIgcu8LCQjIzM4PPuocT0WGgqmtQfHy8woCIiIiIhJXadIPXAGIRERERkQilMCAiIiIiEqEUBkREREREIlREjxkQERGRyOX3+3G73U1dDZGjZrfbsVqt9XIuhQERERGJOG63m02bNuH3+5u6KiJ1kpiYSHp6+jGvlaUwICIiIhHFNE127tyJ1WolMzPziIsyiRxPTNOktLSU3NxcAFq0aHFM51MYEBERkYji9XopLS0lIyOD6Ojopq6OyFFzuVwA5ObmkpqaekxdhhSFRUREJKL4fD4AHA5HE9dEpO6qgqzH4zmm8ygMiIiISEQ61r7WIk2pvn5+FQZERERERCKUwoCIiIiISIRSGBARERGREG3btuX5558PvjYMgylTphzTOevjHFL/NJuQiIiIiBzWzp07SUpKqlXZhx9+mClTprBkyZI6n0Maj8KAiIiISBhyu931NmNSenr6cXEOqX/qJiQiIiIRzzT9TfJ1NM466yzGjRvHuHHjSEhIICUlhQcffBDTNIFA155HH32UG264gfj4eMaOHQvAjz/+yOmnn47L5SIzM5Pbb7+dkpKS4Hlzc3O5+OKLcblcZGVlMXny5IOufWAXn+3btzNixAiSk5OJiYmhb9++zJ8/n0mTJvHXv/6VpUuXYhgGhmEwadKkGs+xfPlyzj77bFwuF82aNWPs2LEUFxcH9990000MHz6cp59+mhYtWtCsWTNuu+22Y55KU0KpZUBEREQimmn62blzcZNcu0WL3hhG7T+bffPNNxkzZgwLFixg4cKFjB07ltatW3PLLbcA8PTTTzN+/HgeeughADZs2MCwYcN47LHHeOONN9i9e3cwUEycOBEIPHTv2LGDmTNnYrfbuf3224Or29akuLiYM888k5YtWzJ16lTS09P5+eef8fv9XHPNNaxYsYLp06fz9ddfA5CQkHDQOUpKShg6dCgDBw7kp59+Ijc3l1//+teMGzcuGB4AZs6cSYsWLZg5cybr16/nmmuuoVevXsH3K8dOYeBE4PeAxd7UtRAREZEmlpmZyXPPPYdhGHTq1Inly5fz3HPPBR+Ozz77bO65555g+V//+teMHDmSO++8E4COHTvy4osvcuaZZ/LKK6+wdetWvvjiCxYsWEC/fv0AeP311+nSpcsh6/Duu++ye/dufvrpJ5KTkwHo0KFDcH9sbCw2m+2w3YLeffddysvLeeutt4iJiQHg5Zdf5uKLL+bJJ58kLS0NgKSkJF5++WWsViudO3fmwgsv5JtvvlEYqEcKA8cx01NCyezReLf8h/iTbsIycGJTV0lERCTsGIaFFi16N9m1j8aAAQNCFpsaOHAgzzzzTHBV5b59+4aUX7p0KcuWLQvp+mOaJn6/n02bNrF27VpsNht9+vQJ7u/cuTOJiYmHrMOSJUvo3bt3MAjUxapVq+jZs2cwCAAMHjwYv9/PmjVrgmGgW7duWK3WYJkWLVqwfPnyOl9XDqYwcBzyeMoo/KQL3pIt+ALdADHXTiKp/2tqIRAREWkAR/tQfryq/nANgS49t956K7fffvtBZVu3bs3atWuP+houl6vO9Ttadnvoc49hGPj9RzfWQg4vPH7yw0xp4VYqivcHAYAyH7hn39x0lRIREZEmN3/+/JDX8+bNo2PHjiGfnld3yimn8Msvv9ChQ4eDvhwOB507d8br9bJo0aLgMWvWrCE/P/+QdejRowdLliwhLy+vxv0OhyPYUnEoXbp0YenSpSEDmWfPno3FYqFTp06HPVbql8LAcciLAdGZOC3QIgqiK/99F22YDHNubNrKiYiISJPZunUrd999N2vWrOG9997jpZde4o477jhk+fvvv585c+Ywbtw4lixZwrp16/j0008ZN24cAJ06dWLYsGHceuutzJ8/n0WLFvHrX//6sJ/+jxgxgvT0dIYPH87s2bPZuHEj//3vf5k7dy4QmNVo06ZNLFmyhD179lBRUXHQOUaOHInT6eTGG29kxYoVzJw5k9///veMGjUq2EVIGofCwHHI662AMz4h9updGCPcxHYYhQFU+KFg3VswVy0EIiIikeiGG26grKyMU089ldtuu4077rgjOIVoTXr06MH333/P2rVrOf300+nduzfjx48nIyMjWGbixIlkZGRw5plncvnllzN27FhSU1MPeU6Hw8FXX31FamoqF1xwAd27d+eJJ54Itk5cccUVDBs2jF/96lc0b96c995776BzREdH8+WXX5KXl0e/fv248sorOeecc3j55ZeP4e5IXRhm1eS0EaiwsJCEhAQKCgqIj49v6uoAodObpaf3xGIJDOso/e4a8jf+J7A9Ciwj3Bo/ICIiUgfl5eVs2rSJrKwsnE5nU1en1s466yx69erF888/39RVkePA4X6Oj+YZVy0DxxmvtxwAC2YwCABEn/UBtlaXAuBufb2CgIiIiIgcM4WB40xp6V5Y/jC2r/rBvDEh+xynvgBD5+Hu/kgT1U5EREREwommFj2OlJfuoWTe7yB7GlE2YOMbcOqEYCtAVFQcpfNvp2LnVOg8Gga83rQVFhERkUbz3XffNXUVJAypZeA44Pf72Pv1FeS93xyyp+GyQqwVyLoppDuQwxYF2VPx+sHc8EZgZWIRERERkTpSGDgOFH53LRVbPw6+jreB0e4mOGDFYas9BkurSzEBT5tRGjcgIiIiIsdE3YSamNddTOnmj4KvY6xgNYD+r9VY3t7nH1R0ewBPfCYO2N86oGAgIiIiIkdJYaCJlVUUQsuLiNo5jWbJHaB4PbQbfciHe4cjhoqFf6B0x1Q8sW0oK9qC1YBmnW7EOmhS41ZeRERERE5oCgNNyDRNSufdBtnTiO4wAs54N/BJ/2E+5Y+yuyjKnooH8BRtAcBrQtn6N4kd8C+1EIiIiIhIrWnMQBMqL92Nb9sULAY4t71XYxAorvCSnV8WfO1wJpHU/hocFoJfABUZlykIiIiIiMhRURhoQiXzfgcExgkY7WvuGjT2rYWc9Y+ZLNmWH9zmOvN9UpI7kOKAxIR20PIi3Fs/wZw7urGqLiIiIhHg4YcfplevXvV6zkmTJpGYmFiv5zwW3333HYZhkJ+fD9RP/Y6393g4CgNNxOcpwb3lvwBEWwmsJ3CATXtKmLNhLx6fyRNfrArdeck6uLoE26Wrse6YhgmUrJuo6UZFREREjsE111zD2rVra12+bdu2PP/888d0jqakMNBEyt0l0PIiHBawHqJV4H9LdwS/n7cxjx3VugsBYIsGi5249tcBUOQF/7yxDVpvERERkeONaZp4vd56OZfL5SI1NbXJz9FYFAaaSFnlSsOuttfUuJKwaZpMrRYGgJCuQtVFnzYJuwVMoHT9JLUOiIiIhKGzzjqL3//+99x5550kJSWRlpbGv/71L0pKSrj55puJi4ujQ4cOfPHFF8FjfD4fY8aMISsrC5fLRadOnXjhhRdCzvvdd99x6qmnEhMTQ2JiIoMHD2bLli011mHDhg20a9eOcePGYZomFRUV/OEPf6Bly5bExMTQv3//g1ZKnjRpEq1btyY6OprLLruMvXv3HvZ9bt68GcMweP/99xk0aBBOp5OTTz6Z77//PqTOhmHwxRdf0KdPH6Kiovjxxx/x+/08/vjjwffbs2dPPvroo5Dzf/7555x00km4XC5+9atfsXnz5oPqe2AXn//973/069cPp9NJSkoKl112WfD/yZYtW7jrrrswDAPDMA55jldeeYX27dvjcDjo1KkTb7/9dsh+wzD497//zWWXXUZ0dDQdO3Zk6tSph71X9UFhoCn4Pbiy/4vDAs7sD2p8eF+1s4j1ucU4bBYu6ZkBwNLt+TWfz2Inpl2gdaDUByz4TQNVXERERA7SiB/Cvfnmm6SkpLBgwQJ+//vf89vf/parrrqKQYMG8fPPP3PeeecxatQoSktLA1Xz+2nVqhUffvghv/zyC+PHj+dPf/oT//nPfwDwer0MHz6cM888k2XLljF37lzGjh0bfKitbtmyZZx22mlcd911vPzyyxiGwbhx45g7dy7vv/8+y5Yt46qrrmLYsGGsW7cOgPnz5zNmzBjGjRvHkiVL+NWvfsVjjz1Wq/d67733cs8997B48WIGDhzIxRdffFCQ+OMf/8gTTzzBqlWr6NGjB48//jhvvfUWEyZMYOXKldx1111cf/31wSCxbds2Lr/8ci6++GKWLFnCr3/9a/74xz8eth6fffYZl112GRdccAGLFy/mm2++4dRTTwXg448/plWrVjzyyCPs3LmTnTt31niOTz75hDvuuIN77rmHFStWcOutt3LzzTczc+bMkHJ//etfufrqq1m2bBkXXHABI0eOJC8vr1b3q87MCFZQUGACZkFBQeNffO5o05xM4L81eOKLVWab+6eZt7610Hxv/hazzf3TzBGvzT3k6fzecnPH65jZr2N63sY0fe6GqrmIiMgJrayszPzll1/MsrKyYz/ZEf6e16czzzzTPO2004KvvV6vGRMTY44aNSq4befOnSZgzp176GeG2267zbziiitM0zTNvXv3moD53Xff1Vj2oYceMnv27GnOnj3bTEpKMp9++ungvi1btphWq9XMzs4OOeacc84xH3jgAdM0TXPEiBHmBRdcELL/mmuuMRMSEg5Zv02bNpmA+cQTTwS3eTwes1WrVuaTTz5pmqZpzpw50wTMKVOmBMuUl5eb0dHR5pw5c0LON2bMGHPEiBGmaZrmAw88YHbt2jVk//33328C5r59+0zTNM2JEyeG1G/gwIHmyJEjD1nfNm3amM8991zItgPPMWjQIPOWW24JKXPVVVeF3BvA/Mtf/hJ8XVxcbALmF198UeN1D/dzfDTPuGoZaCoDXodr3TV2EQL4fs1uAM7vnk6PVokALN9egN9v1ljesEZhb3MFAO7W12maURERkYbm98DGNwLfb3yjUVoIevToEfzearXSrFkzunfvHtyWlpYGQG5ubnDbP//5T/r06UPz5s2JjY3ltddeY+vWrQAkJydz0003MXToUC6++GJeeOGFgz7d3rp1K+eeey7jx4/nnnvuCW5fvnw5Pp+Pk046idjY2ODX999/z4YNGwBYtWoV/fv3DznfwIEDa/Veq5ez2Wz07duXVatCJ1Tp27dv8Pv169dTWlrKueeeG1Kft95665jqs2TJEs4555xa1flQVq1axeDBg0O2DR48+KD3U/3/b0xMDPHx8SH/LxuCFh1rSod4YN9bXMEvOwsBGNwhhQSXnSibhaIKL5v3ltCueWxI+cVb97F5bwnn9HsBd+d7cbuSiW7wyouIiEQ4ix3ajQ4EgXY1TwZS3+z20GsYhhGyrap7j9/vB+D999/nD3/4A8888wwDBw4kLi6Of/zjH8yfPz94zMSJE7n99tuZPn06H3zwAX/5y1+YMWMGAwYMAKB58+ZkZGTw3nvvMXr0aOLj4wEoLi7GarWyaNEirFZrSL1iY0OfVRpKTExM8Pvi4mIg0K2nZcuWIeWioqLqfA2Xy1XnY49WTf9/q/5fNhS1DByH5mwI9Ifr0iKelNgo7FYLXTMC//CWZxeElP10STaX/d8c7vpgKSt3mbDi77g/PQnmjWn0eouIiEScI7T0N7XZs2czaNAgfve739G7d286dOgQ/JS8ut69e/PAAw8wZ84cTj75ZN59993gPpfLxbRp03A6nQwdOpSioqLgMT6fj9zcXDp06BDylZ6eDkCXLl1CggfAvHnzalX36uW8Xi+LFi2iS5cuhyzftWtXoqKi2Lp160H1yczMDNZnwYIFR1WfHj168M033xxyv8PhwOfzHfYcXbp0Yfbs2SHbZs+eTdeuXQ97XGNQGDgO/bQ5MFBkYLtmwW09K7sKLd22Pwz4/SaPf746+HrOxkLInorXBP+GxmmuFBERiXjHcdfcjh07snDhQr788kvWrl3Lgw8+yE8//RTcv2nTJh544AHmzp3Lli1b+Oqrr1i3bt1BD90xMTF89tln2Gw2zj//fIqLiznppJMYOXIkN9xwAx9//DGbNm1iwYIFPP7443z22WcAwRaHp59+mnXr1vHyyy8zffr0WtX9n//8J5988gmrV6/mtttuY9++fYwefegFVuPi4vjDH/7AXXfdxZtvvsmGDRv4+eefeemll3jzzTcB+M1vfsO6deu49957WbNmDe+++y6TJk06bD0eeugh3nvvPR566CFWrVrF8uXLefLJJ4P727Zty6xZs8jOzmbPnj01nuPee+9l0qRJvPLKK6xbt45nn32Wjz/+mD/84Q+1uhcN6ajDwKxZs7j44ovJyMjAMAymTJkS3OfxeLj//vvp3r07MTExZGRkcMMNN7BjR+gUmXl5eYwcOZL4+HgSExMZM2ZMsGmnyrJlyzj99NNxOp1kZmby1FNPHVSXDz/8kM6dO+N0OunevTuff/750b6d49KKyk//e2YmBLd1bxn4fnl2fnDbwi37yCksD76eszEfW+vAVFfu1tcf17+cREREpOHdeuutXH755VxzzTX079+fvXv38rvf/S64Pzo6mtWrV3PFFVdw0kknMXbsWG677TZuvfXWg84VGxvLF198gWmaXHjhhZSUlDBx4kRuuOEG7rnnHjp16sTw4cP56aefaN26NQADBgzgX//6Fy+88AI9e/bkq6++4i9/+Uut6v7EE0/wxBNP0LNnT3788UemTp1KSkrKYY959NFHefDBB3n88cfp0qULw4YN47PPPiMrKwuA1q1b89///pcpU6bQs2dPJkyYwN///vfDnvOss87iww8/ZOrUqfTq1Yuzzz47pHXhkUceYfPmzbRv357mzZvXeI7hw4fzwgsv8PTTT9OtWzdeffVVJk6cyFlnnVWre9GQjMrRy7X2xRdfMHv2bPr06cPll1/OJ598wvDhwwEoKCjgyiuv5JZbbqFnz57s27ePO+64A5/Px8KFC4PnOP/889m5cyevvvoqHo+Hm2++mX79+gWbpAoLCznppJMYMmQIDzzwAMuXL2f06NE8//zzjB0bWFRrzpw5nHHGGTz++ONcdNFFvPvuuzz55JP8/PPPnHzyybV6L4WFhSQkJFBQUBDs/9bUfH6Tkx/6kjKPj6/vPoMOqXEArM8tZsiz3+OwWVjwp3NIjHZw30dL+c/C7Qxol8y8jXlYLQbf334SFt9e4mJbEJfQuonfjYiIyPGnvLycTZs2kZWVhdPpbOrqyAE2b95MVlYWixcvplevXk1dnePW4X6Oj+YZ96gHEJ9//vmcf/75Ne5LSEhgxowZIdtefvllTj31VLZu3Urr1q1ZtWoV06dP56effgqOAH/ppZe44IILePrpp8nIyGDy5Mm43W7eeOMNHA4H3bp1Y8mSJTz77LPBMPDCCy8wbNgw7r33XiCQBGfMmMHLL7/MhAkTjvZtHTc27SmhzOPDZbeSlbJ/8E375jF0bRHPLzsL+XDhdk4/KYWPFm0H4A/ndeL29xazo6CcjfsMOmz9O56dU6Hz6OO2D6OIiIiINL0GHzNQUFCAYRjBVdjmzp1LYmJiyFRQQ4YMwWKxBAeYzJ07lzPOOAOHwxEsM3ToUNasWcO+ffuCZYYMGRJyraFDhzJ37txD1qWiooLCwsKQr+PNyh2BLkJdWsRhtexf8MMwDG4Y2AaAv32+iotf+hG/CcO6pdO3bTJdMwLdiNbsckP2VCr8GjcgIiIiIofXoGGgvLyc+++/nxEjRgSbKHJyckhNTQ0pZ7PZSE5OJicnJ1imap7cKlWvj1Sman9NHn/8cRISEoJfVSPLjycrdwQCSreMhIP2XXZKSwa0SwbA4zPpnB7Ho8MDXaJObhm4v6tyK7C1vgwTqMgcoXEDIiIickJp27Ytpmmqi1AjabB1BjweD1dffTWmafLKK6801GWOygMPPMDdd98dfF1YWHjcBYKqloFuGQf374qyWZl086l8tiywGMiwk9OJibJVlg+Eh192FOI6/2WKfB7KNr6Hy+FSVyERERERqVGDhIGqILBlyxa+/fbbkIEL6enpB62k5vV6ycvLC85Jm56ezq5du0LKVL0+Upmq/TWJioo6pkUnGpppmodtGQBw2q1c0afVQdurWgbW5RZT4YuC7Gm4DTA3vIFx6gS1EIiIiIjIQeq9m1BVEFi3bh1ff/01zZo1C9k/cOBA8vPzWbRoUXDbt99+i9/vDy4PPXDgQGbNmoXHs7+/+4wZM+jUqRNJSUnBMgcuADFjxoxaL3F9PMrOLyO/1IPNYnBS+tGt3NciwUXH1Fh8fpNZG8uwtLoUvwme1iMVBERERESkRkcdBoqLi1myZAlLliwBAotVLFmyhK1bt+LxeLjyyitZuHAhkydPxufzkZOTQ05ODm63GyA45+stt9zCggULmD17NuPGjePaa68lIyMDgOuuuw6Hw8GYMWNYuXIlH3zwAS+88EJIF5877riD6dOn88wzz7B69WoefvhhFi5cyLhx4+rhtjQu0zSZ8csu3vhxMwAd0+KIslkPf1ANhnYLtIp8tXIXUf2ehZYXUbFpslYjFhEREZEaHXUYWLhwIb1796Z3794A3H333fTu3Zvx48eTnZ3N1KlT2b59O7169aJFixbBrzlz5gTPMXnyZDp37sw555zDBRdcwGmnncZrr70W3J+QkMBXX33Fpk2b6NOnD/fccw/jx48PTisKMGjQIN59911ee+01evbsyUcffcSUKVNqvcbA8eTxL1Zzy1sLeWP2JgCGdEk9whE1O69bYED1D+t2Y7NFQ/Y0Sn2BrkKaVUhEREREDnTUYwbOOussDrdOWW3WMEtOTg4uMHYoPXr04IcffjhsmauuuoqrrrrqiNc7nm3LK+W1WRtDto04tW6LhXXLSCDeaaOw3MvG/CjSY1rjK9lKmasd0eoqJCIiIiIHaPB1BuTwvlwZmAq1XUoMvTIT+e1Z7clIdNXpXFaLQb+2galHf9q0h5iKrQCUFW5Uy4CIiMgJ7qyzzuLOO++sVdnvvvsOwzDIz88/pmu2bduW559//pjOIcc3hYEm9tXKwIxIowa2Ycptg7l/WOdjOt+pWYEwMG9TAc72NwBQ0eIifD73sVVURERERMKOwkATKvf4+HlrYEXlIV3SjlC6dnplJgKwOqcQ2+A3sWVeCtnTyH07Ft+cm+rlGiIiIiISHhQGmtDaXUV4/SbJMQ5aJdWta9CB2jUPTEmanV9GeUU58TmfAmACZevfVHchERGRA5imSanb2yRftRlrWZO3336bvn37EhcXR3p6Otddd91B6zgBzJ49mx49euB0OhkwYAArVqwI2f/jjz9y+umn43K5yMzM5Pbbb6ekpKROdZITU4OtQCxHtjx7/2rDhmHUyzlTYh3ERdkoqvCyLd9Dx46jiV/7BoVeqMi4nFgNJBYREQlR5vHRdfyXTXLtXx4ZSrTj6B/HPB4Pjz76KJ06dSI3N5e7776bm266ic8//zyk3L333ssLL7xAeno6f/rTn7j44otZu3YtdrudDRs2MGzYMB577DHeeOMNdu/ezbhx4xg3bhwTJ06sr7coxzm1DDShFdmB1Ya7t6x5teG6MAyDtikxAGzcUwIDXsd5bSG0vAj31o8x546ut2uJiIhI0xg9ejTnn38+7dq1Y8CAAbz44ot88cUXFBcXh5R76KGHOPfcc+nevTtvvvkmu3bt4pNPPgHg8ccfZ+TIkdx555107NiRQYMG8eKLL/LWW29RXl7eFG9LmoBaBprQyh1VLQP1FwYAslJiWJ5dwKY9gWY+m82Jbcc0vEDZ+olE939VqxKLiIhUctmt/PLI0Ca7dl0sWrSIhx9+mKVLl7Jv3z78fj8AW7dupWvXrsFyAwcODH6fnJxMp06dWLVqFQBLly5l2bJlTJ48OVjGNE38fj+bNm2iS5cudaqbnFgUBpqIaZps2h14WD8pLbZez51V2TKwuTIMYLET3e5aCje8T0HaJdi8FTgcCgMiIiIQaFWvS1edplJSUsLQoUMZOnQokydPpnnz5mzdupWhQ4fidtd+9sDi4mJuvfVWbr/99oP2tW5dtzWP5MRz4vzkh5l9pR6KKrwAZCZH1+u5s6p3E6rkOu0tijrchWlY2bNnDYmJbYiOTqnX64qIiEjDW716NXv37uWJJ54gMzMTgIULF9ZYdt68ecEH+3379rF27drgJ/6nnHIKv/zyCx06dGicistxSWMGmsjmvYEH9RYJTpx1bCI8lINaBgCr1U6z5t1wOhMBKCjYitu9v19hXt4GcnNX4Pf76rUuIiIiUr9at26Nw+HgpZdeYuPGjUydOpVHH320xrKPPPII33zzDStWrOCmm24iJSWF4cOHA3D//fczZ84cxo0bx5IlS1i3bh2ffvop48aNa8R3I01NYaCJbN1bCkDrem4VAIIDiHOLKiiubH0AcDhiSE5uj8uVjGmaFBZuB8Dv91Feno/XW0FFRUG910dERETqT/PmzZk0aRIffvghXbt25YknnuDpp5+usewTTzzBHXfcQZ8+fcjJyeF///sfDocDgB49evD999+zdu1aTj/9dHr37s348ePJyMhozLcjTUzdhJrIlsow0KZZ/YeBBJedZjEO9pa42bynhJMPmK0oISGT8vJ9uN0leDylmKY/uK+8vACXK7ne6yQiIiLH5rvvvgt+P2LECEaMGBGyv/qaBWeddVbw9UUXXXTIc/br14+vvvrqkPs3b95ct8rKCUMtA01kS16gC0+bZjENcv6qrkKb9hy8cIjFYsPpTAKgpCQXj6c0uK+iorDOC6CIiIiIyIlFYaCJNGQ3Iag2iHh3zasIxsamAVBaupeCgm3B7X6/F49HKw+KiIiIRAKFgSby27Pac+/QTvTKTGyQ83duEQ/A3I17atxvt0fjciWFbLNYAgOZy8s1bkBEREQkEigMNJFzuqRx26861Pu0olWGnZwOwPxNeeQU1LyKYGJiW5KSsoiJScXpTCQuriWABhGLiIiIRAiFgTDVMtFF3zZJmCZMX7GzxjKGYcHlSiYhIbNylqFAS4HHU4bPV/tFS0RERE5EGiMnJ7KqVaePlWYTCmNnntSchVv2sXhbPjfVorzFYsPhiMHtLqGiolCLkomISFiy2+0YhsHu3btp3rw5hmE0dZVEas00TdxuN7t378ZisQSniq0rhYEw1r1VYErR5dtr3+0nKioBt7uE8vIChQEREQlLVquVVq1asX37dk2dKSes6OhoWrdujcVybB19FAbCWI9WiQBs3FNCYbmHeKf9iMc4nQkUFe0ITjGqT0tERCQcxcbG0rFjRzweT1NXReSoWa1WbDZbvTynKQyEseQYB62SXGzfV8aK7QUM6nDkT/rt9misVjs+nwe3u5ioqLhGqKmIiEjjs1qtWK3Wpq6GSJPSAOIw16VyitENu4trfUxUVOAYzSokIiIiEt4UBsJcZlJg6tLt+8pqfUxVGHC7ax8gREREROTEozAQ5loluYCjCwN2e2D1Yo+nVNOuiYiIiIQxhYEw1zIYBkprfYzNFoXFYsM0TTye2h8nIiIiIicWhYEwV5eWAQCHo6p1oKTe6yQiIiIixweFgTDXqnLMwN4SN6Vub62Pq+oq5HYrDIiIiIiEK4WBMJfgshPnDMwgm30UrQNqGRAREREJfwoDEaBqRqEte2vf/7+qZcDrrcDvr32LgoiIiIicOBQGIkBW88CD/ea9tf+U32KxYrM5AXUVEhEREQlXCgMRoF1KIAxs3HN0D/X7uwppRiERERGRcKQwEAGyKsPApt1HFwaqWga83vJ6r5OIiIiIND2FgQgQDANH2TKgMCAiIiIS3hQGIkBVGMgpLD+q6UUVBkRERETCm8JABEiMdtA8LgqApdsKan2c1RqFYRiYph+fz91Q1RMRERGRJqIwECHO6NgcgG9W7ar1MYZhYLUGQoRaB0RERETCj8JAhBjSJRWAr1ftwjTNWh9XNaNQWVleg9RLRERERJqOwkCEOP2k5jjtFjbvLeW7tbtrfVx0dKBFoawsD5/P01DVExEREZEmoDAQIWKjbIwa0AaAF79ZV+vjHI4YHI5YTNOktLT2IUJEREREjn8KAxHkljPaYRiweGs+uUW1HwMQExPoYlRSkktR0U7Ky2s/CFlEREREjl8KAxEkNc7JyRkJAMxev6fWxzmdidhsUfj9PoqKdpCXt15dhkRERETCgMJAhBncIQWAmatr3+XHMIxg60CVkpLceq2XiIiIiDQ+hYEIc3bnwEP91KU7+Pvnq/D5azezkMvVDKvVEXyt2YVERERETnwKAxHm1Kxk7j73JABem7UxOJj4j/9dxql/+5pzn/2eZ79ag/+AkGCxWElNPZn09F4YhoHP58brrWj0+ouIiIhI/bE1dQWk8d1+TkeSYxz8ZcoKJs3ZTL+2ybz/0zYAcosqWPfterx+k/uGdQ45zjAMDMOK3R6D212M212EzRbVFG9BREREROqBWgYi1IhTW5OZ7KKgzMP1r88H4KIeLXjwoq4A/OuHjeQU1DzjUFRUHAAVFUWNU1kRERERaRAKAxHKajEY96sOIa/vOa8TY07L4tS2yXh8Jm/M3lTjsQ5HIAy43QoDIiIiIicyhYEIdnXfTC7v3RKH1cKzV/ckKyUGgDGnZwEwdcmOg8YOQGAhMsOw4PN58Hprv16BiIiIiBxfFAYimGEYPHtNL34efy6X9moZ3H5Wp+bERtnIKSxn8bb8Go6z4HAEgkNFRWFjVVdERERE6pnCgBAbFTqOPMpm5ZwugSlIZ/yyq8ZjoqLiAbQasYiIiMgJTGFAajSgXTMAftlZ8yf/TmcSEBg34Pd7G61eIiIiIlJ/FAakRielBQYJr82peZCwzRaF3R6NaZpqHRARERE5QSkMSI06psUCkFNYTkGZp8YyDkegjNdb1mj1EhEREZH6ozAgNYp32slIcAKwbtehWgcC+7USsYiIiMiJSWFADumk9EBXodWH6SoEaHpRERERkROUwoAcUpcWgRmDVu4IHRNQVO7B5zeDLQM+XwWmefB6BCIiIiJyfFMYkEPq2SoRgCXb9oeB6Sty6PPo15zx1EwWbC7EMAxM08TnczdRLUVERESkrhQG5JB6ZSYCsCankFK3l215pdz+/mLcPj/Z+WVM+H5jsHXA4yltwpqKiIiISF3YjlxEIlV6gpO0+Ch2FVYw9q1F/Lh+T8j+FdkFOBwt8HjKKCvLw+VKaqKaioiIiEhdqGVADmtw+xSAkCDw6qg+WC0Ge0vcFHgC04tWVBRo8TERERGRE4zCgBzWH8/vTHKMI/j6wu4tOLdLGh1TAyFg9a6KaouP5TdRLUVERESkLtRNSA4rNd7J/35/Ght3F3NahxQMwwCge8sEVucUsSK7gIGtE/F4Sikvzyc6OqWJaywiIiIitaWWATmilokuTu/YPBgEALq3SgBgeXYBTmciABUVhZimvymqKCIiIiJ1cNRhYNasWVx88cVkZGRgGAZTpkwJ2W+aJuPHj6dFixa4XC6GDBnCunXrQsrk5eUxcuRI4uPjSUxMZMyYMRQXF4eUWbZsGaeffjpOp5PMzEyeeuqpg+ry4Ycf0rlzZ5xOJ927d+fzzz8/2rcjdXRyy6owUIjN5sRqtWOaJm53SRPXTERERERq66jDQElJCT179uSf//xnjfufeuopXnzxRSZMmMD8+fOJiYlh6NChlJfvX6V25MiRrFy5khkzZjBt2jRmzZrF2LFjg/sLCws577zzaNOmDYsWLeIf//gHDz/8MK+99lqwzJw5cxgxYgRjxoxh8eLFDB8+nOHDh7NixYqjfUtSB13S47EYsKe4gl2FFTgcgdWK3e7iIxwpIiIiIscLwzyGpWMNw+CTTz5h+PDhQKBVICMjg3vuuYc//OEPABQUFJCWlsakSZO49tprWbVqFV27duWnn36ib9++AEyfPp0LLriA7du3k5GRwSuvvMKf//xncnJycDgCg1f/+Mc/MmXKFFavXg3ANddcQ0lJCdOmTQvWZ8CAAfTq1YsJEybUqv6FhYUkJCRQUFBAfHx8XW9DxBr63CzW7Cri3zf0ZWAbCwUFW4mKiqNZs5OaumoiIiIiEetonnHrdczApk2byMnJYciQIcFtCQkJ9O/fn7lz5wIwd+5cEhMTg0EAYMiQIVgsFubPnx8sc8YZZwSDAMDQoUNZs2YN+/btC5apfp2qMlXXqUlFRQWFhYUhX1J3XVoEWgPW7y7G4QjMLuR2l2jcgIiIiMgJol7DQE5ODgBpaWkh29PS0oL7cnJySE1NDdlvs9lITk4OKVPTOapf41BlqvbX5PHHHychISH4lZmZebRvUarJSHQBsDO/DLvdhc0WhWn6KS8vaOKaiYiIiEhtRNRsQg888AAFBQXBr23btjV1lU5oLSrDwI6CwHgQpzOwAnF5+b4mq5OIiIiI1F69hoH09HQAdu3aFbJ9165dwX3p6enk5uaG7Pd6veTl5YWUqekc1a9xqDJV+2sSFRVFfHx8yJfUXUaCE4CdBWUAwSlGy8sL1FVIRERE5ARQr2EgKyuL9PR0vvnmm+C2wsJC5s+fz8CBAwEYOHAg+fn5LFq0KFjm22+/xe/3079//2CZWbNm4fF4gmVmzJhBp06dSEpKCpapfp2qMlXXkYbXIqGqm1CgZcDhiMFqdWCafoqKdnAMY9NFREREpBEcdRgoLi5myZIlLFmyBAgMGl6yZAlbt27FMAzuvPNOHnvsMaZOncry5cu54YYbyMjICM441KVLF4YNG8Ytt9zCggULmD17NuPGjePaa68lIyMDgOuuuw6Hw8GYMWNYuXIlH3zwAS+88AJ33313sB533HEH06dP55lnnmH16tU8/PDDLFy4kHHjxh37XZFayUgMtAzsLXFT7vEB4HIFwlpx8S6Ki3c2Wd1ERERE5MiOOgwsXLiQ3r1707t3bwDuvvtuevfuzfjx4wG47777+P3vf8/YsWPp168fxcXFTJ8+HafTGTzH5MmT6dy5M+eccw4XXHABp512WsgaAgkJCXz11Vds2rSJPn36cM899zB+/PiQtQgGDRrEu+++y2uvvUbPnj356KOPmDJlCieffHKdb4YcnQSXHZfdCkBO5biB6Ojmwf1lZRo7ICIiInI8O6Z1Bk50Wmfg2J39zHds3F3Cu7f0Z1D7FAD8fh85OUsASEvrjtXqOMwZRERERKQ+Ndk6AxJ5MirHDezI37/CtMViDa47UFGhtRxEREREjlcKA3JMWlTNKJRfFrLdbo8GwOutaPQ6iYiIiEjtKAzIMTlwrYEqFosNAL/f2+h1EhEREZHaURiQY3LgWgNVrFY7AH6/56BjREREROT4oDAgx6SqZWBnvloGRERERE40CgNyTKpaBnYc0DKgMCAiIiJy/FMYkGNS1TJQVO6luGL/g7/FEugm5POpm5CIiIjI8UphQI5JbJSNOGegFSB73/7WgaqWAdP0Y5r+JqmbiIiIiByewoAcs05pcQCsyC4IbrNYrBhG4MdLXYVEREREjk8KA3LMemYmArB0e37IdovFBqZXXYVEREREjlMKA3LMgmFgW37Idsvyh+HLAfjn39rodRIRERGRI1MYkGPWq1UiAL/sLKTC6wts9HuwZ38MQPnGyaD1BkRERESOOwoDcswyk10kxzjw+Ex+2VEY2Gix42o/CoByP5hqHRARERE57igMyDEzDIOerRKA0K5CUYNex2aA34TSdRPVOiAiIiJynFEYkHqxfxDx/hmFsNiJaT8CgGKfWgdEREREjjcKA1Iveh1iEHH04IlYDPCZULFerQMiIiIixxOFAakXPSsHEW/cU0JB6f4HfsMahavt1QCUZVwBlSsTi4iIiEjTUxiQepEU46BNs2jg4PUGXIPfgJYXUb7lv5hzRzdB7URERESkJgoDUm+qWgcO7CrksDmw7piGCbjVVUhERETkuKEwIPWmatzAkgPCABY7UZVdhcpbXqmuQiIiIiLHCYUBqTe9WycCsHDLPnx+M2Sfc+Br0PIiKrZ8BPPG4PVWUFq8E9M0aziTiIiIiDQGhQGpN91bJhAXZaOgzMPKHQUh+xy2KMiehtcE34Y3yP9uBPn/yaDou2uaqLYiIiIiojAg9cZmtTCgfTMALnl5Ngs35wX3WWxO7K0vB8Dd6hrcWz8BoHjTh/hnj2r8yoqIiIiIwoDUrzNOah78/tkZa0P2Ofo9Dy0vYt+GD8DVKrh979p3MOfc1Eg1FBEREZEqCgNSr67tl8mNA9sAMG/jXvYUVwT3RdldkD0t8KJsOxaLC4sBHhPKN7ypWYZEREREGpnCgNQru9XCXy89mZ6tEvCbMH1FTnCfMzqF5PbXYjECr2MtZUS3CXQdKvMBC37TBDUWERERiVwKA9IgLujeAoDPlu0M2e488z1Sk9uTaIeYhA64Bk8EoMIP/g1vqHVAREREpBEpDEiDqAoD8zftJbeoPGSf5dL1RI8owbh0HfaoeOytL8dErQMiIiIijU1hQBpEZnI0PTMT8ZswbenOgwvYooPfuk59AYAyP7BRrQMiIiIijUVhQBrM5b1bAvDfn7cftpwrJg1aXoLbD942oxQGRERERBqJwoA0mEt6ZuCwWli5o5DVOYWHLGe12onq+zS0vIjcNW+z550YvFM6NGJNRURERCKTwoA0mKQYR3DdgeqzCtUk2pkQnHbU7YfSgg3gLW3wOoqIiIhEMoUBaVBDu6UB8OXKXYct54pJpdlJo4i2Bl57XG1CxhWIiIiISP2zNXUFJLwN6ZKGxYBVOwvJLSonNc55yLJRp72Fpd9LlOauwGOPbcRaioiIiEQmtQxIg0qKcdC2WQwA63YVH7G8zRGPYXPh93vx+dwNXT0RERGRiKYwIA2uQ2rgU/51u4qOWNYwDGy2QOtBRcWRy4uIiIhI3SkMSIPrmFYZBnKP3DIA4HIlA1BUtAPT9DdYvUREREQincKANLhgy0Atw0BMTCpWqwOfz015eUFDVk1EREQkoikMSIPrmBoHwNpdRfj85hHLG4YFpzMRgIoKhQERERGRhqIwIA2uY1os8U4b+aUefly/p1bH7A8DheoqJCIiItJAFAakwUXZrFx+SisAnv96LUXlniMe43DEYrHY8Pk87N27Fq+3QqFAGsXaXUU8/vkq9pVoNisREQl/CgPSKK4f0Bq71WDx1nxGT/oJj+/wD/aGYZCc3AGLxYrbXUJu7gp27lzMnj2r8fmOHCZE6uq852bx6qyN/P3zVU1dFRERkQanMCCNokNqHO/dMoC4KBs/bd7H/83ccMRjHI4YUlK6YBhGcJvbXUJJyeFXMxapD2trOeBdRETkRKYwII2mb9tkHrvsZAAmfL+B3UUVRzzGZosKTjVapaKisEHqJ1JdUrS9qasgIiLS4BQGpFFd3COD9s1jKPP46P/3r5myOPuIx8THt8LlSiYpKQsAj6dMXYWkwSVFO5q6CiIiIg1OYUAalcVi8MQVPchIcOI34c4PlrBkW/4RjrGRlJSFy5WM3R4NQGnp7kaorUSakgpv8PtEtQyIiEgEUBiQRtevbTI/3H8255+cDsC/f9hY62NjYwPHFBfvUuuA1Ls9xfu7rkXZrE1YExERkcahMCBNwmox+P3ZHQH4YkVOrcYPALhcSdjt0ZimX2MHpN5V/zn0HmHGKxERkXCgMCBNpmtGPN1bJuDzm8xcnVvr45zOBECrE0v9CwkDtVgtW0RE5ESnMCBN6tyuaQDMWFX76UKjouKBqtWJ9cAm9Wd3tW5CR1oLQ0REJBwoDEiTGtIlEAZ+WLebco+vVsfY7TFYrXb8fh9FRUeejUiktkoq9v8Men0KmiIiEv4UBqRJdWkRR8tEF+UePz+u21OrYwzDIDa2BRAYSLx371pMU5/iyrHz+ff/HHn8+pkSEZHwpzAgTcowDIZ0SQVgxi+17yoUHZ1CTEwqhmFQUVFEfv6WhqqiRJDq4wTUMiAiIpFAYUCa3HndAtOFfrI4m+/X1m79AMMwSEjIJDm5I4ZhUFaWR2np3oaspkSA6gHAq5YBERGJAAoD0uQGtW/G0G5puH1+bnxjAaNen8/bczfj9h75YSwqKi7YZaisTGFAjk31lgGPWgZERCQCKAxIkzMMg+eu6cV1/VtjtRj8sG4PD366kvs+Wlqr2YJcrmQA3O5i/H7vEUqLHFr1MQM+TS0qIiIRQGFAjgvRDht/v6w7M+46g5sGtcViwJQlO1i0Zd8Rj7XZorDbXZimSVlJ7ccdiBwotGVA3YRERCT8KQzIcaVd81gevqQbF3QPdP35oZYzDEVHN4flj1D0USv8c25uyCpKGPNpALGIiEQYhQE5Lg3ukALA7PW1DAPOBOw7p+I3oWT9JPB7GrB2Eq5CZhPSAGIREYkACgNyXBrcPhAGlmzLp6j8yA/2htVBTLvrACj1gTn/1gatn4Qnn08DiEVEJLIoDMhxqXWzaLJSYvD6zVp3FXINfgOLAT4TytZPVOuAHLXqC42pZUBERCKBwoAct2pajKy44tCzBRnWKGLbXRso51XrgBw9jRkQEZFIozAgx61zuwYWI5u+IofZ6/dw08QF9Hj4S96Zd+jVhmNOm4TFAK9aB6QONJuQiIhEmnoPAz6fjwcffJCsrCxcLhft27fn0UcfDZkv3jRNxo8fT4sWLXC5XAwZMoR169aFnCcvL4+RI0cSHx9PYmIiY8aMobi4OKTMsmXLOP3003E6nWRmZvLUU0/V99uRJtS3TRKDOzSjzONj5L/n892a3fhNeGjqStbkFNV4TKB1YAQQaB1gwW8ascZyovOFrECslgEREQl/9R4GnnzySV555RVefvllVq1axZNPPslTTz3FSy+9FCzz1FNP8eKLLzJhwgTmz59PTEwMQ4cOpby8PFhm5MiRrFy5khkzZjBt2jRmzZrF2LFjg/sLCws577zzaNOmDYsWLeIf//gHDz/8MK+99lp9vyVpIhaLwYTr+9CmWXRwW3KMA5/f5LNlOw55XMxpE4OtAxXr31DrgNSaV92EREQkwtR7GJgzZw6XXnopF154IW3btuXKK6/kvPPOY8GCBUCgVeD555/nL3/5C5deeik9evTgrbfeYseOHUyZMgWAVatWMX36dP7973/Tv39/TjvtNF566SXef/99duwIPAROnjwZt9vNG2+8Qbdu3bj22mu5/fbbefbZZ+v7LUkTinPaef3GfvTPSubZq3vypwu6APDtmtxDHmNYo3C2vRqAMh9qHZBaq74CsboJiYhIJKj3MDBo0CC++eYb1q5dC8DSpUv58ccfOf/88wHYtGkTOTk5DBkyJHhMQkIC/fv3Z+7cuQDMnTuXxMRE+vbtGywzZMgQLBYL8+fPD5Y544wzcDgcwTJDhw5lzZo17NtX86q1FRUVFBYWhnzJ8a9Daiwf3DqQy09pxZknNQdgRXYhOwvKDnlM9MAJQCAM+DaodUBqJ3SdAbUMiIhI+Kv3MPDHP/6Ra6+9ls6dO2O32+nduzd33nknI0eOBCAnJweAtLS0kOPS0tKC+3JyckhNTQ3Zb7PZSE5ODilT0zmqX+NAjz/+OAkJCcGvzMzMY3y30tiax0VxattkAN6ee+iBxA5nErbWl2ECuyqgbErnRqqhnMi8Pg0gFhGRyFLvYeA///kPkydP5t133+Xnn3/mzTff5Omnn+bNN9+s70sdtQceeICCgoLg17Zt25q6SlIHY07PAuCdeVsoOcxUozH99ncZKyzYiOkpPmRZEQidWtSnlgEREYkA9R4G7r333mDrQPfu3Rk1ahR33XUXjz/+OADp6YHpInft2hVy3K5du4L70tPTyc0N7RPu9XrJy8sLKVPTOapf40BRUVHEx8eHfMmJZ0iXNLJSYigs93L1q3P5YvlOSt0Hh4KYhLakJLUPLkRWPk9jB+Twqi80pgHEIiISCeo9DJSWlmKxhJ7WarXir/wjm5WVRXp6Ot98801wf2FhIfPnz2fgwIEADBw4kPz8fBYtWhQs8+233+L3++nfv3+wzKxZs/B49vcFnzFjBp06dSIpKam+35YcR6wWgzGnBVoHVu4o5LeTf+bcZ2exdtfB0406Ll2Fq/LH0b1xMvg9gWluNYZAalC9NcCjFYhFRCQC1HsYuPjii/nb3/7GZ599xubNm/nkk0949tlnueyyywAwDIM777yTxx57jKlTp7J8+XJuuOEGMjIyGD58OABdunRh2LBh3HLLLSxYsIDZs2czbtw4rr32WjIyMgC47rrrcDgcjBkzhpUrV/LBBx/wwgsvcPfdd9f3W5Lj0JV9WjGsWzqnZiWTEhtFdn4ZD3268uCCFjtR7QLjVSoyLqWiopBdM4aT/7YD5t7cyLWW4131QcOmqa5CIiIS/mz1fcKXXnqJBx98kN/97nfk5uaSkZHBrbfeyvjx44Nl7rvvPkpKShg7diz5+fmcdtppTJ8+HafTGSwzefJkxo0bxznnnIPFYuGKK67gxRdfDO5PSEjgq6++4rbbbqNPnz6kpKQwfvz4kLUIJHw57VYmjOoDwLa8Us5+5jvmbtzLT5vz6Fc5wLiKY/AkKC3Au+1T9r73KQClQNT6SbgAf/9/k5e3DovFTlJSFoahhbkj1YEP/x6fH6vF2kS1ERERaXiGWX1p4AhTWFhIQkICBQUFGj9wgrv/o2V8sHAb1/TN5Mkre4Tu9HvY+5aDigN6fTgtkOyAogu3UFSyGwCXK4nExCwMw2ikmsvx5JxnvmPD7pLg6xV/HUpsVL1/ZiIiItKgjuYZVx+BSlgY3rslAF+s2Inbe8BTv8VOcqebSXFAcwekOIDoVnhMoN1oSsr2r0tRVraP4uKap6aV8Hdgy4BX04uKiEiY00deEhZOzUomNS6K3KIKfli3m3O6hK5BYQx8A0f/VwEwTT/sWoHP9OJJ7Y5/9yoMwyA+PpOCgq2UleURF9eiKd6GNLEDFxrzaEYhEREJc2oZkLBgtRhc2CPwAD9t2c6aC1nsYLFjWKOw2QLjU8oqWwWs1ihcrmQMw8DrLaegYCt5eevx+32NUn85PhzUMqAZhUREJMwpDEjYuKhHYKapr1bmUHyYxcgA7Csehi8HUDZ/HAA2WxQWixW7PQaAkpLdlJcXqMtQhDmwZUBrDYiISLhTGJCwcUrrRNqlxFDi9vF/M9cfuqDfg2P7RwD4tk0B04vVGgVAdHSzkKKlpbsD3YokItQ0m5CIiEg4UxiQsGEYBn88vzMAb8zeRLnnEF18LHacHW4MfN/yIiDQMgAQHZ1CUlIW0dEpAPj9Prze8oatuBw3DhwwfGBLgYiISLhRGJCwcm7XNFLjoij3+FmyLf+Q5ayDJmHPHA7Z0+DLAVh/vie4z+VKJjGxDVFRcQB4PGUNXGs5Xhw8gFgtAyIiEt4UBiSsGIZB/3aBrj7zNu49dEG/h8RdU3BYwG4Bx9Z3wO8JKWKzuQDwehUGIsWBYUArEIuISLhTGJCwM6BdYAXiuRsOEwYsduwdRgfXHrC0Hx2YbaiaqhmHvO6iBqurHF+qHv6d9sCvRk0tKiIi4U7rDEjYGdQ+0N//5637KK7wHnoF2QGvw6kTAt8fEAQA7HYXLH8Ez46p0GV0oLyELdM0q4UBK+UevxYdExGRsKeWAQk7WSkxZKXE4PGZ/O2zXw49kBiCaw/UxGaxYWRPxWdCxfo3DupGJOGlepegKFvgV6PPVMuAiIiEN4UBCUu/6pQKwHsLtjHiX/OOuO5ATSw2J66sqwEo8QLzfl2fVZTjTPXxAo6qMKAxAyIiEuYUBiQsXdMvM9g9aPHWfCbP21Kn88QO/jcGUO6HXWvewv1xu3qspRxPQlsGrAdtExERCUcKAxKWOqXHseKvQxl/UVcA5h5uZqHDsDniiGl7JQA+E/IKNuGbfX291VOOH9VXG3ZY1TIgIiKRQWFAwtqpWYGZhRZt3ofPb1Lu8fHmnM0s255f63PE/eo/JCa0xWqA34SSDZM1fiAMef37BwtXdRPSomMiIhLuFAYkrHVOjyM2ykZRhZfFW/cx6vX5PDR1JZf93xy+WplTq3MYhkH0FZuIb38NAOUtLj3koGM5cVW1AliM/S0DfoUBEREJcwoDEtZsVgundQhMNXrlhLn8tHkfEHjwmzRn81GdK+q0yRgtL8a77VPcP6irULipagWwWS1YLKHbREREwpXCgIS9P57fOThVJMDvzmoPBAYWe45iHnkLfpw5/wOgYMNk/D+Oqt+KSpOqahmwWQxslWnAr6lFRUQkzCkMSNhrmxLDxJv7cV7XNG4e3JZ7zutEgstOmcfHyh2FtT+RxU5ch1EYgMcPe9a9A3NvbrB6S+OqagWwWgwsFiOwTSsQi4hImFMYkIgwqH0Kr93Ql4cu7obVYtCvbRIACzYd3SxDtsFvkdT+WgC8Jvg3TtJg4jBRtdpwoGUgEAa06JiIiIQ7hQGJSAPbB8YRfLdm91Ef6zzzPaytLgHA1/YGDSYOE/tbBixYjMowoDEDIiIS5hQGJCKd0zmwQvGcDXvZureUJdvyefarNSzeuq9Wx1tPeQqGzsN7ynMNWU1pRKFjBiq7CSkMiIhImLM1dQVEmkLblBjapcSwcU8JZ/xjZnD7f3/O5of7fhXsM34oNpsTt9uG11vR0FWVRlJ9zIC18v+/phYVEZFwp5YBiVj3DetMerwzZFt2fhlzNhx5HIHNFgWA113UIHWTxuerXHTMbt0fBtQyICIi4U5hQCLWsJPT+f6+sxg1oA1X9WnF1X1bATBlSfYRj7XZnLD8ETxTO8G8MQ1dVWkEVTMHWat1E1LLgIiIhDuFAYloUTYrjw4/mX9c1ZPzu7cAYNGWI48bcNicGNlT8ZpQse4NzSgUBvaPGbDsn1pUYUBERMKcwoBIpV6tEgHYtKeE/FL3YctabE6is64GoMQHLPhNA9dOGprHf3DLQFXXIRERkXClMCBSKSnGQdtm0QAs3V5wxPIxg/8NQLkf/BvUOnCiq3rwt1n3Lzp2FAtUi4iInJAUBkSq6ZWZCMCNbyzg0pd/pKD00A/4Nkccjtg2AOS6wTvvlsaoojSQmsYMqGVARETCncKASDXXD2gTnElm6fYCpq/ceejCfg+xFVsC35pQtO5NtQ6cwKrGDNirLzqmFYhFRCTMKQyIVNO3bTLPXNUz+Hrm6sOsUGyx4+w4mhRH4GWZD3xqHThheWsYM6ABxCIiEu4UBkQOMLx3S6aOGwzAj+v34PYepqvIgNdxXFtCVOW/pNL1gdYBv99HWckuTH2yfMIIziZk1aJjIiISORQGRGpwckYCzWIcFFd4WbY9//CFbdG42l0HBFoHzPm3kjfzGvZ9kE7hd9c0fGWlXtS0ArFaBkREJNwpDIjUwGIxODUrGYD5m/KOWN456HUMwGvCnjUTcW/5LwAlmz7EO/uGhqyq1BNv5dRBtpABxAoDIiIS3hQGRA5hQLtmAMzbuPeIZS02J3HtrwXAc0CvotL1b2tg8QmgesuARWFAREQihMKAyCEMbB8IAz+s28Pb87YcfuwAEHPamzgr/0XZLZBkD3xf5g90HZLjW/UViNUyICIikUJhQOQQOqbGck7nVAAenLKCqybMoaj80J/wG1YHyZ0Dsws1s4Oz3SgsBvhMcK+fqNaB45y32gBitQyIiEikUBgQOQTDMPj75d05pXUiEFh34NXvNx7+oAGv47jOjWWEG2PwWzjbXg1AeaurwGJv4BrLsahaYMyqMQMiIhJBFAZEDiMt3snHvxvM89f0AmD6ypwjH2SxBx/8nQNfg5YXUbb5Q8pmXYfpq2jA2sqxCLYMWAwtOiYiIhFDYUCkFn7VORWbxWB9bjGb9pTU+rgouxPrjmn4Tdi3/j12v+XEN/vGBqyp1JXPVzWA2KJFx0REJGIoDIjUQoLLHhxQ/PK362t9nGGNIuWkUbisgddeE4rWvwVzb26Iasox8FRrGbBaA78aqwKCiIhIuFIYEKmlO4echGHAf3/ezpJt+bU+zjr4LZJOuolmjsDrUh+Urp+E6XM3TEWlTqqPGbCqm5CIiEQIhQGRWurTJonLerUE4K25m4/u4IETcYyowNrqEgDyUy+huHRPPddQjkVVlyC7VQOIRUQkcigMiByF6we2AWDa0p1MX1GLwcTVGFYHMYNeg6HzoPt4iop2UliY3RDVlDqoPmZAU4uKiEikUBgQOQq9MxMZ2i0Nt8/PXR8soaD06NYOiI1NI6Nlf+LiMgAoLs6htPTIKxxLw6s+m5BaBkREJFIoDIgcBcMw+Od1p9A5PY4yj4//LNxWp/PExbUIBoLCwu2Y6pve5Koe/K2W/YuOef2HX3VaRETkRKcwIHKUbFYLNw5qC8DE2Zuo8PrqdJ7Y2HSsVjt+v5fi4qPrciT1r+rBv3rLgLKAiIiEO4UBkTq4rHdLUuOi2FFQzkeLttfpHIZhEB3dHICioh3qLtTEvFVjBqz7Fx1Ty4CIiIQ7hQGROnDarYw9ox0A/1lYtzAAgdaBqKh4AEorZxdyu4txu4uPvZJyVHw1jRlQ7y0REQlzCgMidXRJrwwMA5Zuy2dHflmdzmEYBomJgRmK3O5idu/+hT171rBnzxry87eElC0ry8NTUQD+oxu0LLWzfwCxBau1agCxWgZERCS8KQyI1FFqnJM+rZMA+O3knykoq9tDutXqwOGIAcDj2R8qysry8HorcLuLKS3dw75ZN7J7ciIl7zhg3pj9J1A4qBfBlgFrtUXHlAVERCTMKQyIHINbz2yP1WKwdFs+Pf/6FW/P21KnmYESEloTE5NKbGwaSUntsNmiME0/ubkrAq0EP9wM2dMAKPSCd/0blJfuZveMyyg6MBxInXirrUC8f2pRpQEREQlvCgMix+Dcrmm8fmPf4OsHp6zgr//75ajPY7dHk5CQSXx8K1yuJJzOpP07TS9kT8NmgMMCJrDXlkneD6PxbJtCkRf8G97AW5qLuzwfgPLyAnye0mN8d5Gl+piB/VOLatCAiIiEN4UBkWN0VqdUfnNmexy2wD+nSXM2s3jrvmM6Z2xsOvHxrUhIyCQ2riXRWVeT4oBEGxiAr3RbsKUAIMcbTe77aex5N4ndMy4j7/vryXsnBnP2DcdUj0jiqbYC8f6pRRUGREQkvCkMiNSDP57fmbWPnc9VfVoB8MxXa1m7q6jOi4lZLFZiY9OIiUklPr4Vib/6AMsIN7b2N5Fg31/OYQGcLcG3vxXAs20KZE/DY8K+dW/j/7TDMbyzyKGWARERiUQKAyL16PZzOgLw4/o9nPfcLP70yfL6W13YYoeBE4lufwPN7JBgg2Q7xHiyibNBqgNiraGHlPuhMH8DeNVl6EhqGjOglgEREQl3CgMi9SgzOZqTW8YHX7+3YBtfr8qt34sMepOoDjcRYwNL+9EkdBpNnA1s7W4g/qSbSI+CFlGQ7IoFoNQHZXN+Xb91CENVLQN2q4FVLQMiIhIhbE1dAZFwc9/Qzoye9FPwQfLjn7dzbte0+r3IwInQ/7VAawHAqROC31v6vwaAE4h+20GpD/LXv4fNMLCfPrl+6xFGqv5/WS2WYBjw11erjoiIyHFKLQMi9eyMk5qz5rHz+ez20wD4ZnUuP23OY1+Ju34vZLEf+vvKr4SON+KsnIGoYMO7MPfm+q1DGKlpBWK1DIiISLhTGBBpAFaLQdcW8XROj8Pt9XPVhLmc9/wsdhWWN2o9jEGTSOhwPQbg9kP5+klapOwQvMHZhAwsVYuO+RQGREQkvCkMiDQQwzAYd/b+mXx2F1Vw9tPf8fUvuxq1HtbT3iYm6yogsGCZOVcLlNWkagBxoGUg8KvRp25CIiIS5hQGRBrQBSe34Mo+reiZmUhafBQlbh93vL+Yz5fvZObq3GNej6C2Yk9/E6sBXhN2r32bkv9mNcp1TyT7xwwYVGYBdRMSEZGwpwHEIg3IYjF4+qqeAIHuQq/OZem2fH43+WcgMHPNf387iB6tEhu2HjYXSe1HkLfhPbwmFBRsxvbDdUSd/m6DXvdEEhwzYLUEWwY0taiIiIS7BmkZyM7O5vrrr6dZs2a4XC66d+/OwoULg/tN02T8+PG0aNECl8vFkCFDWLduXcg58vLyGDlyJPHx8SQmJjJmzBiKi4tDyixbtozTTz8dp9NJZmYmTz31VEO8HZF64bBZmHRTP249ox3RjsCCAB6fyZ8/WdE41z/jXdKS2hFV+a/evek9jR+opmrMgO2AloF6WydCRETkOFTvYWDfvn0MHjwYu93OF198wS+//MIzzzxDUlJSsMxTTz3Fiy++yIQJE5g/fz4xMTEMHTqU8vL9gytHjhzJypUrmTFjBtOmTWPWrFmMHTs2uL+wsJDzzjuPNm3asGjRIv7xj3/w8MMP89prr9X3WxKpN0kxDh64oAtz/ng2n99+OjaLwfLsAtbnFh/54HpgDN+As21g/ICn5ZWhsxBFOF+1bkJVLQMAahwQEZFwVu/dhJ588kkyMzOZOHFicFtW1v7+yaZp8vzzz/OXv/yFSy+9FIC33nqLtLQ0pkyZwrXXXsuqVauYPn06P/30E3379gXgpZde4oILLuDpp58mIyODyZMn43a7eeONN3A4HHTr1o0lS5bw7LPPhoSG6ioqKqioqAi+LiwsrO+3L1IridEOEqMdnN4xhZlrdjN1STZ3n9epUa5tH/QGdLwHt2ENtAwoEAD7xwfYqi06BoGQUP21iIhIOKn3loGpU6fSt29frrrqKlJTU+nduzf/+te/gvs3bdpETk4OQ4YMCW5LSEigf//+zJ07F4C5c+eSmJgYDAIAQ4YMwWKxMH/+/GCZM844A4fDESwzdOhQ1qxZw759NQ/KfPzxx0lISAh+ZWZm1ut7Fzlal53SCoDXf9zEjvyyRrmm3R6NsfLv+Kf3o/AdB8zbP7uQ3+9j7951lJTsPqpzmqYf0/TXd1Ubla/abEIHhgEREZFwVe9hYOPGjbzyyit07NiRL7/8kt/+9rfcfvvtvPnmmwDk5OQAkJYWuiJrWlpacF9OTg6pqakh+202G8nJySFlajpH9Wsc6IEHHqCgoCD4tW3btmN8tyLH5qLuLejTJokSt4+nv1zTKNc0TB/xOVMBKPZC2bo3MD0lAJSV5VFRUUhBwVbc7sN3XaqoKMTv9+L3+8jNXUlOzhKKi2v+t3ci2L/OgCW46BiAx39ihxwREZHDqfcw4Pf7OeWUU/j73/9O7969GTt2LLfccgsTJkyo70sdtaioKOLj40O+RJqSxWLw0MVdAZiyJJv3Fmzl5W/XMWfDnga8qJ2Yk0bjCoxhZp8H9k2OxZxzE+7y/a1qRUU7D3mKwsLt7N27jry89RQX78Tnc2OaJkVFO/D7vQ1X9wbkrbYCsd26/1ejVwuPiYhIGKv3MNCiRQu6du0asq1Lly5s3boVgPT0dAB27QpdeGnXrl3Bfenp6eTm5obs93q95OXlhZSp6RzVryFyIujRKpHzuqbhN+GBj5fz9FdruXniT2zcXczqnMKGmc1mwOvEXbOXqg/Ay/2wc/WblH3aCZY/DAQ++d+9+5eDWgiKi3dRXBz4t+Z2lwS/h8CYoLKyvPqvbyPwHTBmoHIRYrw+tQyIiEj4qvcwMHjwYNasCe3usHbtWtq0aQMEBhOnp6fzzTffBPcXFhYyf/58Bg4cCMDAgQPJz89n0aJFwTLffvstfr+f/v37B8vMmjULj2f/1IgzZsygU6dOITMXiZwInryiBx1TY4MP5xVeP2c/8z3Dnv+Bl79d3yDXtDmTSe98E8l2CBkemz0N64pHAPB4yti7dx0+n4eKiiJ27/6FwsLtAFgs1uAhcXEtSEgIjMEpKcnFNP14vRVUVBSeMGMJqlYgrhovYK+cUcijMQMiIhLG6n02obvuuotBgwbx97//nauvvpoFCxbw2muvBaf8NAyDO++8k8cee4yOHTuSlZXFgw8+SEZGBsOHDwcCLQnDhg0Ldi/yeDyMGzeOa6+9loyMDACuu+46/vrXvzJmzBjuv/9+VqxYwQsvvMBzzz1X329JpMElxTj43+9Po7jCS36pmyHPzgrue2bGWnq3TuLjxdvpmBrHr0/PCunGckwGTsQJNN8wiVJ/YAyB1YDk3KmUOJ+mtDzwMF9RUUhZ2V48nsAg57i4DOLiWuDxlGK1OrBYbJimn+LiXXi9FRQWbqe0dC+m6cfpTCA5uUP91LeB+P1mcArRqmlF7VYDt08tAyIiEt7qPQz069ePTz75hAceeIBHHnmErKwsnn/+eUaOHBksc99991FSUsLYsWPJz8/ntNNOY/r06TidzmCZyZMnM27cOM455xwsFgtXXHEFL774YnB/QkICX331Fbfddht9+vQhJSWF8ePHH3JaUZHjndNuxWm3khIbxbhfdeDlmftbBK5/fX7w+615JTx+eQ8Avlm1izbNYuiQGlv3Cw+ciK3/a8QDrjmjMTa/g63DaBKTO2It2kFR0c7KIFAKQHJye5zORCAwM1EVw7AQH9+Kffs2hsxG5PWWc7zzVeuKVdUyYLNaAB8ehQEREQljhhnBy2sWFhaSkJBAQUGBBhPLccU0TX7euo/EaAfnPTfroOkt//vbQRRXeLnxjQXEOW28d8sAoh1W7FYLmcnRhzhrLVVbe8DtLmHPntXBXYZhIT29F4Zx6Hn39+5dR0XF/jU8LBYb6ek9j61ODazM7aPL+OkArPzrUGKibPR9bAZ7it18ccfpdGmh3w8iInLiOJpn3HpvGRCRY2cYBn3aJAPw0oje/LBuNwPaNePHdXv4cNF2Hpq6Apc90Ge/qNzLRS/9CAS6tvz3t4NIj3fSPC7qsA/th1RtETKHI4a4uAyKinYEdllsRzxnUlI7Skpy8fkqKrsK+Y6+Do3MW2360GDLQGV3Ic0mJCIi4UxhQOQ4d0H3FlzQvQUAgzuk8OXKHFZkh66e7bBacPv8eHwml7w8G4B+bZN45fo+pMRGHdP14+JaYBgGhYXZxMSkHrG8xWIlLq4Ffr+vMgyYmKZZt2DSSKq3vNiC3YQC/9U6AyIiEs7qfTYhEWk4KbFRPHjR/ql7f3Nme9b97XzWPDaMqeMGh5T9afM+7nh/cb1MTRobm05aWg9iY9OOXLiSYez/9XK8tw64K8cFWIyqsQKBgAVqGRARkfCmlgGRE8xVfTPZkV/O+t3F3H5Oh+DMQj1aJfLwxV0pKPNyTpdUrpwwh9nr9/Lhwu1c3S/zmK9rtdqPXKgawzAwDAum6cfv92GxHL+/bjyVD/zVZ2kKtgxoALGIiISx4/evs4gc0h1DOta4/abBWcHv7zm3E3/7fBVPfbmaoSenk+A6uof5+mCxWPH5/Md9y4DHG3jgd1QPA1XrDCgMiIhIGFM3IZEwdeOgtrRLiWFPsZs/fby8YVYyPgLDCAxyPt4XHqvqJmS37f+VaK9sGVA3IRERCWcKAyJhymGz8Ow1vbBZDD5bvpOFW/Y1eh2qVin2+4/vlgF3ZctAVQCA/WMHvBpALCIiYUxhQCSM9cpM5Kq+gfECr36/odGvXzWI+LjvJlTVMmA9uGXAo5YBEREJYwoDImHultOzMAz4elUu63YVNeq1q7oJHe8tA1UP/I6QbkJqGRARkfCnMCAS5to1j+W8roEpQf/1w8ZGvXZVN6GaWga83goqyvIatT6HUtUyEDqAuLJlwKuWARERCV8KAyIRYOwZ7QD4cNF2np2xlvGfrqCkwtvg1w0OIPZVgN8Tsi//u+vY+14zymZd1+D1OBJ3Dd2EqsYMaNExEREJZ5paVCQCnNI6ic7pcazOKeLFb9YBkBjt4O5zT2rQ6xqGBZY/QlH2VLxWSOhwA5bBb4Lfg3vrxwDkr38Plz0KBk5s0LocjqeGAcSaTUhERCKBWgZEIoBhGPz2rPYh217/YSM5BeUNel0LfsieCkCZD/atewvfj6MwDSu0vAgAE/BsmHRQy0FjqqlloOp7rTMgIiLhTGFAJEJc2qslPz94Lhv+fgG9MhMpcfv4y5QVDXrNqKh4bAZEVf6mqfDD3nXv4JtzE3R/OBgIKlpdA5bGXxStSnDMgO3gRce8frUMiIhI+FIYEIkgyTEOrBaDp67sgc1i8PWqXfy8teHWH7BHJZDaZTTNHJCSGFgd2WtC+Ya3wfQGA0HF5g9g3pgGq8eRVA0SrnFqUa9aBkREJHwpDIhEoJPS4risd0sAHvp0Jfml7oa72IDX4Vo3jss3Et32SgAKvcCKxzBMH2RPw+0H/4Y3mqyrkLum2YSqwoBaBkREJIwpDIhEqNvP6UiCy87y7ALGvr2oYfvGV3YBihn8b4JDdLOnEbX6SWyZl2ECFZkjmqyrUHDRsapuQn7P/nUGNGZARETCmMKASITKTI7mg1sHEBtlY8GmvEZZg8AelUB8u2uCry3bP8bZ71loeRFlG99rsq5C+1cgNqj4cRR733JgzfkS0JgBEREJbwoDIhGsc3o8D1/SDYB/zdpIXkkDdheq5DrjneDAYVpfhcuVDNnTKPeDr1pXIdM0KS/dTXnpngavU9UKxHaLyd6171DhBzN/aeU+tQyIiEj4UhgQiXDDe2XQrnkM+0o9DP/nbCbO3sSuwoabctRisVH1q8fAwB4VT1RsGwCKHW2C5QpnXk3e+6nkvd8c9483NFh9ACoqBwlb8EJ0ZuB7RyygMCAiIuFNYUAkwtmsFl4b1YdWSS625pXy1//9wh3vL264C/o9pOyeissKcTv+A95SYt1bACgp2sKetxwUfNiWks0fBQ9xb3y7QQcXVz3wWw0flG4DwOLZC2jRMRERCW8KAyJCh9Q4Pr/jdK7q0wqABZvyKChtoIdvix1Hh9Ek2cHSfjTYoolqfxOxleuhu/2BUFCdp+UVDTq4uGr6UJvVgJaXBL6P7xjYpzAgIiJhTGFARACId9r5x1U96ZAai9+E2RsasK9+5XSjDHg98HrgROI73oTLWrk/utX+stGtcG/9b4MOLg4OILYA3cdDy4uwFi0HwOtXNyEREQlfCgMiEuLMk5oD8OI363j+67V8uTIH09z/6bjPb/LpkmxumriAact21P1CB37SP3Aizit3BQYXl24HINEOlG7HZ1auQ+Atrfv1DsNd+em/zWIGFkPLnoYNHwBer69BrikiInI8sDV1BUTk+HLToLZMWZzN6pwiVucUATD2jHb86YIuzFydy1//t5LNewMP5Ys27+O0DikkRjvq5dpRUfFYd0zDaoGUylMWOVrjK9lKUVRbvO/EEN/xBuyD36yX61WpahmwWUww7NDyEmz5gZmV3GoYEBGRMKaWAREJkZkczX9+M5Axp2VxXtc0AF6btZGJszdx69uL2Ly3lMRoOy0SnBRVeHlj9uZ6u7bF5iSty+hAEGg3Gq51YxvyNZz7IyWFm6nwQ/H6t/YPJvZ76mVgcUgYACw9/4qt+x8BLTomIiLhTWFARA7SvnksD17Ulddu6Mvlp7QE4K//+wW3z895XdOYff/Z/OmCLgB88NPW+n1grj6ewGLHbneBZX8jZoUfvN5ytk+/jI//OZCCt6OPeTyB21s1m1AgDFitDmzWwAAGLTomIiLhTGFARA7r3qGdyEhwAtA5PY7nrulFTJSN87qlkRzjYFdhBW/P23KEsxylauMJrNYoMGzBhcr8JuR+O4IPVsLd2X/lT9m/h41vHFMLQbBlwKgMBVYHNkvoPhERkXCkMCAih9UiwcW020/nb5edzDu/7k9MVOBT+iiblV+fngUEWg3Of+EHPlu2s96vb7e7YPkjkD2N+KoGgh2f8a891wPwWeE5FGWMOqapR6sGENutBlAVBgLfa50BEREJZwoDInJEyTEORvZvQ0psVMj2357Znt+d1R6rxWDVzkLu+mAJ2fll9Xpthy2KxNypNHdArA3iKgNBjGX/zELTlq7HO+emOl+jap0BuxUMw4LFYtvfMqBuQiIiEsYUBkSkzgzD4L5hnZn7wNm0S4nB7fPz6vcb6vciFjvRHUcH1gBoN5q4jjdhGons9SUHi2x0t6Fs/Zt17ioUXGfAamDBj2FYgy0DVUFBREQkHCkMiMgxS41z8tAl3QCYtmxn/c/AU31Q8cCJrB2wMmR3tieNUh+w4Dd1On1wzMDW97BM74vl57uxVS6ApkXHREQknCkMiEi9GNS+GUnRdvJK3CzYnFf/F6g2JmD97vKQXTs86fsXJqtD60BFVTehvNkYBhhb3sVuCWzzaMyAiIiEMYUBEakXdquFcyvXJfho0fYGvdb63GIATu+YAsAOf2Ags7/tDXUaSBzsJtS8PxbAaHs9UfbA4IQyd8OsQGyafvbt20hBwVb8/sA13O4Sdu/+hT17VuPzHfv6CSIiIkeiMCAi9WbEqa0B+PjnbM555jvufH8xpln/n6xv2B0IA2d3TgVgd0UsFefMxdf35Tqdr+rTf1vHG7FcshZL/1dw2gJjBso8DRMGysryKCvbR0nJbgoLtwFQXJyDx1OG211Cefm+BrmuiIhIdQoDIlJverdO4tSswMDeDbtLmLJkB9+t2V2v1zBNk/WVYeDUrGSiHVZMIKfYwF/HAcTllQ/8DquBxebCMKy47JVhoIFaBioqCoPfl5bupbR0b8g2r7ci8E3le/L53Pi9od2jREREjpXCgIjUq9dG9eGOczoGX//7x431ev69JW7ySz0YBrRLiSUj0QXA7mIfPp+7TueseuB32Q0Mw4phWIItA26fv94HRJumSUVFUci2/PzNmOb+6/h8FXh+HEX+2w7KZ11H7jdXs/dtF+bc0fVaFxERiWwKAyJSrxKjHdx17knMuvdXAMzbmEd+ad0e0muyckfg0/M2ydG4HFbS4gNrH+wp8de5n31VVyCX3cBisWGxWHGueTy4v7Seuwq53UX4/V4sFhsJCa2xWh04HLG4XEnExbUAoPynu9iz9h1KfZC3/j3M7Z/iMaF8/cRjWm1ZRESkOoUBEWkQrZtF0zk9Dp/frNeuQsu25QPQMzMRCExrCrCnxFenbkJurx9v5cJiTruBxWLFMP04dn6ChUAIKC+vOPaKV1NWFphtyeVKIiamOWlp3UlJ6URSUjuio1PA9EL2NGoabVF2DFOoioiIHEhhQEQazDldAgN8v12dW2/nXLo9H4AerRIBSI0LtAzsrWPLQPUxAU5boGXAsDqwZl6K0xIIAaVe49gqXY1p+ikrCwwOdrmSD9pvtTpgxd8D9bFAehTEWKGy1xJeE9hYtylURUREDqQwICINZnCHwNSfCzbl1cusQj6/yZKqloFWCQCkxle1DPjx+Y7+E/xSjxcAqyWwArFhBFYbs/T6G05nTKBMPQ4iLi/PxzT92GxROByxBxfwe0jMnUqsDZLsYLmmhISTbqKZA4jOxGeCmXVznaZQPfA6IiIiCgMi0mB6ZyZhtxrkFJazfV/ZUR1rmiZF5aEPrF+v2sWeYjdJ0XZOblkZBqpaBkoDLQNHO4i46kHfZTPADPTjB7BYbDhtgV+R9Tm96P4uQge3CgQubCe642jibWC0Hw22aBg4Ecu1FRhnTsEcOg//qROO7qJ+T8isRLu/vpzidxwwb8yxvBUREQkDCgMi0mBcDivdKx/aj9RVyDRNfv/eYi7952xKKrw8//U6uj/8FVe8Moe8EjemafKvWYGZia7p1xqnPfAJfvVuQhBYuOtoVHUTclIMXw7AUtkf32Kx1fv0on6/Nzh96CHDAMCA1+Fad+C/lQyrA6s18F6D047WQtkP15P3loOSdxww92YK8zfj2foJhd66r9gsIiLhQ2FARBrUsJPTAXjii9XBxcJqMnfjXv63dAdLt+Xz+fKdvLdgKwCLtuzjkf+t5MuVu1i4ZR9RNgs3DmoTPK56NyEAj+cow0Dlp/5OswAAY9Mk8HuwWu3B6UVL3d6jOuchr1UW6C5lt0djszkPX7iGbkC25Q/DlwPwzr2lVtczfRXkr5tMuR8KvFC4bhJlM87ZXx9n1rF3NxIRkROawoCINKjRg7MY1L4ZZR4f9364FJ+/5rEDE77fvx7BvR8tI7do/6ffU5bs4N6PlgLw69OzaJHgCu6rmlq0zOOnqMIfsnBXbQS7CUU5sBiVXXMs9kA3IXv9rELsdpdQUpJLcfEugMCMQUfL78Ge/REAhRs/wDf7hiMfgoHZ8pLg62IvULo9+LqiaJNaBkREIpzCgIg0KJvVwtNX9SQ2ysbPW/OZOHvTQWV+2VHIrLUHTz96YY8WDO2WBkBRuZeTW8bz+7M7hpSJdthIig58up1b5MPjKTuqcQNllZ/6O+NaYL1gSbBrTn11E3K7i9m7dw0FBdvw+dxYLNbDdxE6FIud2A434rCACZRuePuID/J+vxe6j8dy3pzgbEROC4HByIA741JMw3b0dRERkbChMCAiDS4j0cWfL+wCwPNfr6OkYn+3m0Vb8vjd5EUAXNwzg9dG9SEjwcngDs34y4VduGlQFgAJLjuvjOwTHCtw4PkB9pYFnnKrpu6sjaqWAafNwGLb3+JgsdiDLQPHMptQScnu4ExKhmEQH5+JxXLwe6gNY9AkYtqNCNSpFusN+P2VMyVFJdCs000k2gMzFEW1vwnLsAX4T37wqLtViYhIeFEYEJFGcW2/TLJSYiiu8PLZ8p34/SYf/LSVKyfMZfPeUlolubh/WCfO65bOnAfOYfKvB9AiwcXA9s2YdHM//vvbQWQmR9d47qowkFcR6DJUWLidoqKdtZrONDhmoHL14SoWiw1n0ZJAmY3/qfP7rpruNCEhk9TUk4mOblbncwE4B0/EYoDPBPf6ww8ArgoDFosN66CJRI90Y4xws6L189z3WSn3TN3Hjj07j6k+IuHE4ylj7951lJcHxhCZph+/v35XIBc53igMiEijMAyDq/tmAnDfR8vo+JcvuP+/yzFNuLB7Cz753WBaJdX8sH9Wp1Q6pNYwJ3+ljITKQcSlVhyOwNoARUU7yMlZQknJ4Vc/ruoC5LIbWKoNprVZrDjL1gJQuntFnfvWV3VZcjhiAwuKHSPDGoWz7dWBeh2hdaB6GAh8Y+fn7cWMeG0eszYUM3dzBZ8s3nlUsxOJhLPCwu1UVBSSl7cej6eM3NyV5OYuP+pZykROJAoDItJorju1dfDB3ec3iY2yccvpWbw4ojfNK6cIrYuqloEd+WU0a3YS8fGtgMCneoWF2w+7MnFIN6FqLQNWezTRCa0BKIk9pVaz7hQX51Bauif42jTN4LXrIwhUiR4YWGegzAfew7QO+DylAMGQs2lPCTe+voCiat205m6poLT08IFJJBJ4vRUhExAUFe3A53Pj9/vYt29DMFyLhBuFARFpNAnRdv51Y1/O65rG89f0YvH4c/nzhV2xWoxjOu/+MFCOYViIjU0jPb0nVqsD0/Qf9mG3NKRlIHQwbXSrswEoSRx0xDqUlxdQWJhNfv4WCgsDM/ZUtQoYhuWgcx8LhzOJqDZXYAIlla0Dfr8vZHGxsh+up/jjLFj+SPDa9320lKIKL6e0TuTT2wYDsCTbTV7B7npZIVrkRHbg+Jny8vzg9z6fh+LinEaukUjjUBgQkUbVLSOB127oy/DeLbFb6+dXUFUYyM7fv8qxxWIjNjawxsHhmvirZhOKsplYraGf/sc4A60VxRs+OuJqveXl+wctl5Tk4vGUsXv3LwAHnbc+xFS2DlT4wbP+DXbNuIzdbzrwvhtYXGzfusmBgtlTsWCyLa+Unzbvw2LAy9edQo9WCTSPi8LtgzW55SEPPiKRyOstBw7+9xobG5jRrKRkt7oLSVhSGBCRE17LyjCQU1geso5B1fgBT0X+IY+tGkDs2jQBy8LbQ/Y1jw10adrrjcc8wmq9VQMOIdA9aPfuXzDNwEJohlG32YMOx+FMwmh1CV4T8lMvwcz+Hx4Tdrth1+pJIWWNxfcy45fAGgf92iaTkejCMIzg6tBrcj3qKiQRryoMuFzNMIxAa6XDEUN8fCscjhhM08/evWuOarYykROBwoCInPCax0Vhsxj4/Ca5ReXB7TabC2PFo/inn4p39o01HltaEXjAd1oqsG4Jnbs/o1lgcbA93mTKXe0OOW7A7/cG+xM3a9bxoP11WmTsCCwWK/bK7j+e7VPBVTlOgsBMQ8FyBkRte5cZvwRmDTq3a1pw38kZ8QCszvVSUVEUfBgSiTR+vy84XsDhiCUlpQvx8a1ISmoHQHJyR5zOREzTJD9/82HHIYmcaBQGROSEZ7UYpFcOTN5RrauQYXqx7/gUgOL1b4Hfg8dTit9dhL/ywbegPPAQH2spxdLu5pAH/tTYwMN2ni+J8qKN+Dwl5OWtP2iGoqqxARaLjaioeJzOwCfu0dHNaNHiFGJimtf/m/Z7iN358f7XZdtpnpRFjBXslv2Li6U5oLDVWBZszgfgvK7pwUNOrmwZWLs70DqirkISqQoKtuL3+7BYAjOS2e0uYmPTggP/LRYrSUntsNujMc2jX+lc5HimMCAiYSEjoWrcQLVPty124juMAgLTcO76+kp2/7cTOe/Ek/u2C++Po9hbHJhWM2XAoxgD3wg5Z/P4QDejfF8CJWmXUlpeSHl5AQUFWyku3hWcf/zAGYOSktqTnt6TxMS2we4G9c5ix9lxNC2iIMoCLivYyzaRcNINNHdAcnIHoixgtLuJb2MfxOc36ZweR+tm+6dv7dU6EYD1e9zsK/Xj8ZQd4mIi4cvrraCsLA8I/Ns91GB/wzCIigq0ppWV7dWgewkbCgMiEhYyEg9uGQBwDHqd6Mou+77tU6E0MNOP34T89e+wNy/Qlz6l8sG/uqRoR3Cmo71bfqR03u+C+woLt5ObuwK/34ffXxUGAq0KhnHwzEQNYsDrGCPcNOt0E0l2oN1oGPgmXOuGS9YF/jtwYnC8wHnd0kMOT41z0jk9DoCF2yvwVE5FKhJJ3O5iINA9KCoq7rBlq8YhVVQUUVSU3eB1E2kMCgMiEhaqrzUQwmInrsMNWA2wGpBsD3SfAajwwd6KwIvmca6DzmmxGKTEBvbv8SXh2zYFzP1zjfv9XkpLdwdbBiy1WIvgSDw+P5v3lNT+U0eLHQZODDz4D3h9/7bK/5Z7fHy/NtCt6bxq4wWqnN4xMJ5h4TY3Xm95cNCzSKSo6uZnszmPWNZu3/+hQWnp3gark0hjUhgQkbBQfa2BA1kHv0lqpxtJiwKnFaLa3YC11SUU+2PwEnhwTln/1xrPW7UYWp43KbBhxWMhYwBKSnLx+QJdjepjYbF7/rOUs57+jt++8zNe31E8mB8iiPz981WUeXy0THTRrXLAcHV92yYDsHpXIORUfUoqEimO5t+v1WqnefMuQODDgJycJcEwIXKiUhgQkbDQ8lAtA5WMQZMCn55f64ZBb2Lr8zT7BnwOQLSllMQd79Q4dWhqXODTwn2+yjCQPY34leNp0eIUrFY7Pp8n+Anhsa4nsCaniKlLdwAwfWUO36zOPabzrdxRwFtzt2AY8NDFXWscv1A1iHhTnge316SwMFsrrUpEqXqYr22Yt9ujiY5uBgRmIcrP39JgdRNpDAoDIhIWgi0DBYcZBGuxBz9Bt9mc7CsP/ApsZs3HdojfhmnxlWsNxAZWI7YbYGx+E8P0EhMT2u3mWFsGJny/IeT1/323gbLKFZLr4tXvNwJwcY+Mg8YLVMlIcJIUbcfrh415XjyeUvLzN9f5miInmqqxMjZbVK2PSUhoQ3JyewAqKgrVOiAnNIUBEQkLVQOI80s9lFQc+ZNti8XKvjUfAtDcXhAYfFtDV5uT0mIB2Bh1Ds06Xrd/oK7FTkxM82A/Y7s9Gofj8IMPD2fj7uJgq8AL1/bCYsDSbflcOWFOcMajo1FQ5mH6ihwAxp7R7pDlDMMItg5sLQzMNKT1BiRSBFrCAoH7aMK8YRg4nYk4HIHfD1qITE5kDR4GnnjiCQzD4M477wxuKy8v57bbbqNZs2bExsZyxRVXsGvXrpDjtm7dyoUXXkh0dDSpqance++9eL2hf+C/++47TjnlFKKioujQoQOTJk1q6LcjIsepOKedOGdgBp+dh2sdqOSKimNf7joAmtny4dQJNZY7KS3wgL9uVxFRp0/Gdt3+gbqGYaFZs47ExWWQnNyhztOImqbJvR8tw+c3+VWn5lzaqyUTru9DsxgHK3cUcsf7S/D7j24awy+W78Tt89MpLS74sH8o7ZsHHmh2Fgf+JKibkESK0tI9QGAmobq07LlcgTE3WqNDTmQNGgZ++uknXn31VXr06BGy/a677uJ///sfH374Id9//z07duzg8ssvD+73+XxceOGFuN1u5syZw5tvvsmkSZMYP358sMymTZu48MIL+dWvfsWSJUu48847+fWvf82XX37ZkG9JRI5jNa41cAg2RxyliYGuPynJ6YccgFsVBrbklQa67BxQzmp1EBfX4pjGC6zLLWbRln1E2Sw8dll3IDAN6HtjB+C0W/hx/R4+WhSYEtVXy1BQNd7g4p4tjli2VVLVfQu0QPj9Ps0qJGHP7S7B7/disVhp1uykOp3D6UysPFexViWWE1aDhYHi4mJGjhzJv/71L5KSkoLbCwoKeP3113n22Wc5++yz6dOnDxMnTmTOnDnMmzcPgK+++opffvmFd955h169enH++efz6KOP8s9//hO3O9Avb8KECWRlZfHMM8/QpUsXxo0bx5VXXslzzz3XUG9JRI5zVV2FsvfVbvGsNdYzAejU/cJDlkmJdZAc48A0YX3u4WfambV2N5v2lNSytvv9vCXQxaB368TgQGgIBJF7zu0EwONfrOLmiQvoMn4636zaVeN5qvj9Jj9tDiyiNKhDyhGv3yop0D1o+77yYOuGWgck3FV9mh8VFV/nVj2r1R5ce0CtA3KiarAwcNttt3HhhRcyZMiQkO2LFi3C4/GEbO/cuTOtW7dm7ty5AMydO5fu3buTlrZ/cN7QoUMpLCxk5cqVwTIHnnvo0KHBc9SkoqLi/9u77/CoqvSB49/pk0ky6YWQQELovUMAZVUUFburgoAiuru6WNcfuq7r9lW2ua6udVdBpFkWBUFFpIqGIr0TSCAQSCFtkkySaef3x00mGRKqKUjez/PkMZl75s69x4Q575zznheHwxHwJYS4dNR+ip+eeW77f+85rv0b0DPh9MtodDqdf0vObUdPvy5429ES7nlnIze8/PV5J/1uzS4BYECHiAbHJqd1JCU6mGKnm1X7C3B5fPzjywNnrEPwvy3HKHG6CTIZ6HOWJUJQNzNwrLjSXytBPuUUlzKllL/qsNXa8O+u1qxvsnh11cEz/r3Vzg40ZTCQU1KJ0yUBuWgZzRIMLFiwgC1btvDCCy80OJabm4vZbCY8PDzg8bi4OHJzc/1t6gcCtcdrj52pjcPhoLKy8U8FX3jhBcLCwvxfSUlJF3R/QoiL03V9tCUxK/bmnXVAXlzh4niptpyoR7szJ/4O6qgNFr47cvpgYElN8m+Fy8v8jdnnfM0AW7K18w5sJBiwmgwsfGgEU0em0C8pHIA9JxzsOFba6Lky8sp46n87ABiSEonJcPZ/5pNqZgZOllfj8kregLj0lZZm4/W60OsNWK11AbNSiukfbmfon78i/VAhv/t0D39btp/VNYX7GmOxaB8WeDznNiN5NpkF5YycsZKrX1zbJOcT4myaPBg4evQojz32GHPnzsVqPXs1v5b0zDPPUFpa6v86evRoa1+SEKIJ9UsMIzEiCKfLy6c1g/PT2ZClfSrYIdJGqPXM6/0Hd9SSBL873HgwoJRi1f66mgCf7mj42m6vjw2ZheQ7qlBK8a+vMnjpqwOcKK0kI78cna4u6DhVRLCZ39zYk0XTRnJjvwQA/85Dp5q7IRulIM5u4Q839TrjfdWyBxkJtWjJ1/k1q5x8rsaDDSF+6Hw+L5WV2uxhWFhHdLq6odAn23L4cPMx8suqmfCf9f7H/++D7ezKafxvwmDQtiT1et1NkmuzYq/2b0nOaWqmCNHUmjwY2Lx5M/n5+QwcOBCj0YjRaGTNmjW8/PLLGI1G4uLicLlclJSUBDwvLy+P+HhtH+z4+PgGuwvV/ny2Nna7naCgIBpjsViw2+0BX0KIS4dOp+PetGRA27PffZoKvkopXlt9EIBreze+/359/TuEo9dpb86N7VS0JbuEQwV1uQI7jpVSVlW3zKbU6eb6f33NXW+t55qX1vLT9zbzz68O8NJXGaS9sBKAXgl2IoPPvpvJjX212Y+lO0402GGoyu1l4RYt0fivP+5HcnTwWc8HWr+1r1kqlFvmg7W3UvJRR9wfp6K857+tqRAXK6/bSW7uNpRSGI1WgoLqAvDc0ip+tXBXo88rrHBxwyvreHjelgbH9HoDer0BAI/n+/+9eGVWTrSwJg8GrrrqKnbu3Mm2bdv8X4MHD2bixIn+700mEytWrPA/Z//+/WRnZ5OWlgZAWloaO3fuJD+/7pO25cuXY7fb6dmzp79N/XPUtqk9hxCibZowrAMRNhOZJyt4e11Wo21W7stnx7FSgkyGM+7BXyvEYqRHO+3Dg/qzA0opjhU7eecb7XXuGJRIxygbXp9iY1YRh09W8O+VGfT7w5dk1CQflzjdLN/TMAF4ZOrZE30BRneLwWY2kOuo4kB+WcCxz3aewFHloX14EJedQ+JwfbVJxLmlLnBqs6YFxZnkz7bi/eaeRqszC/FDUrl2EnnvBcPOPwBgswX+jSzalkOl20uf9mHcPawDQ5Ij+Nnlndjwq6tIqQmsl+w4wS/e38arqw4G1P+omx34/sGA2y0zAqJlGZv6hKGhofTu3TvgseDgYKKiovyP33///fziF78gMjISu93OI488QlpaGsOHDwfgmmuuoWfPnkyePJm//vWv5Obm8utf/5pp06ZhsWh/cA8++CD//ve/eeqpp5g6dSorV67kgw8+YOnSpU19S0KIH5AQi5FfXd+D6R/t4JUVGdw5OMn/iXuV28vcDdm8WVPp994RyUSHnFvV0cEdI9h93MHmI8Xc2C+BvScc/OWLfazeX7eWeMrIZCwmPUcKs7n/3e8Cnh9sNvDu1KGsO3iSdRknGZQcwcjUaP62bD+Vbi93Djm3HCaL0cCgjhF8nXGSDZlFdI/XghSlFLO+PQzAhKFJ6PXntztKbRJxXmUQIaHJlJdp5/IqyNv/HuaM9wjvPAnjqPfO67xCXBR8bioy52rf5yzGnvYqISGBeYdLdpwA4K4hSUwa3jHg2OePXcbE/25g85FiFm7NAWB/bhkvTxgAaNWL3W4nLle5P6H4QtWf7/P6FIbz/FsW4ny1SgXif/7zn9xwww3cfvvtXH755cTHx7Nw4UL/cYPBwJIlSzAYDKSlpTFp0iTuuece/vCHP/jbpKSksHTpUpYvX06/fv34xz/+wX//+1/Gjh3bGrckhLiI/HhQIr3b26lweRn9t1V8vPUYSimeeH8bf1yyh/yyatqHB53TrECtwcla3sC3h05SVOHizjfSAwKBHu3s9EoIY8LQDg2eOzQ5ks3PXc3g5EgeH9OVjx4awTPX9eDyrjF8+sgovvrFaH/hr3MxvFMUAOtrdk06kFdGz98s8892jG/kGs6mrtZAFfY7sojtOlGrtlzD5YPCjDmob6ec97mFaG1K+XAn3ARASKe7CLEnBhwvLK9mZ01OwNheDZcOWk0G/nJ7H67sHuvf/nfF3jyqPdpGBbWViMvL86iu/p47FdbbuajKfX47kwlxIXTqTPtlXeIcDgdhYWGUlpZK/oAQl5j0Q4XcN2sjVW4tbyDebiXXoe0e9MCoFB65sgthtnMvFFZc4SJtxgqq3D76Joax41gp7cODuL5PPB9vPc6/7x7gH6RPm7eFL3fn8vMfdWZUl2j6JoZhMRqa7N62ZBdz22vfEmw2sHr6Fdz2+jccLdKWFky7IpXpY7uf9zm/2JXLg3M20y8pnEXTRmoPepyUzg2mot54JMQA9okVWvG10xRqE+Ji4fFUU7pmIhz9H9XWJAyVR4nrMdVfRfxAXhmPzNvK/jxtyV33+FC+ePzyM57T51OkzVhBnqOaqGAzf7qlN9f2jqek5DCVlUUYDGZiY3tfcO2Cl5Zt46VV2uzDpmevJCa08TxIIc7kfMa4rTIzIIQQzS0tNYp1T1/Jo1d1AfAHAr+6vju/vqHneQUCoO3oM2mYtnSgdlvPZ67vzrPjevLdr8f4AwGAf93Vn12/H8sTV3dlSHJkkwYCAAOSwkmJDqbC5eXGV9ZxtKiSqGAz790/lF/UFCk7X0mRNTMDxc66B4027F3vI9YM9rBkAMq9kPteMOVzzLD+fq2d5BOIi1RFWQ7VR/5HtQ9wHsWsBzLf8f/O/uHTPf5AAAj4Oz4dvV7H1JEpgJZYPG3eFjZkFREe3hGDwYTX66Kq6vTbEJ9Nladu44NKqTUgWkCT5wwIIcTFIjrEwi+u7sqgjhFszCpkVOcY0lLP/mZ/Ok9c3ZUQqxGfgpRoG+Nq6hqcymjQN+s/rjqdjglDk3j+s33+IOcPN/fmsi4xF3zODpE29Do4We7iaJGTpEgtoViX9g7GYW8SrBSeORacXvApcHjAu/8ddM4SfEcXEtb1PnRp7zTJ/QnRVFyuwCR7qx7oNBX0JjxeH5vr1Q5pF2b1D/LP5qeXdyLEauR3i3fj9irmbchmeKcobLZoyspOUFlZRFBQ5AVdc/0aKRXVrgs6hxDnQ2YGhBCXvNFdY5g+tvv3CgQAgi1GHh/TlV9c3ZVbByRe8DKApnBPWrJ/h5Ore8ZxfZ+zb5F6JqFWE0NTtMHLst25gQf1JnQGM+Fdp2CrN8lR4YXywwtxesF9aGbrzRDIzIRohM/nwb3tN/6f9bqaYGDoGwDsyy2j0u0l1GJkzfQfsfLJH9EhynZO59bpdEwc1pEPHxwBwFd786hye/3Jw9XVZWesWnwmznrBgMwMiJYgwYAQQvwAWU0G3pkyhOlju/Hinf2aJDC5tiZxcuY3h8mtqc4cIG0m4V2n0M4CdiPakosanqQ7WyWHoOrrSRTONuP6ehLK65LAQPhVVxZBzmJMOoizQIwZdKlT/b+nmw5rhQf7dwinY1QwQebzX87XLzGMmFALTpeXXTmlmEw29HojSvlwucov6Lor3fWDAfl9Fs1PggEhhPiBSokOZtoVnc9aQflc3TowkeQoGzkllfxu8e7GG6XNRDfBRUjXqUSbIdgABCXiGfBig6alpdkUFOwN2F3F7a5skiqtAF53BUUZc6n2wcmMueTPtuCeVy+XQbRpLk8VtL8Bsx4MqVMxTHD5E4dBS5oHbebwQul0Ovq2DwPwVyi2WLRkzQvdVShgmZDMDIgWIMGAEEIIAMKCTLx1z2B0Ovhidy5zNxxpvKHepA2qxrsw3pIFoz/B4wmcSfB63VRUFOB2OykqOoRSPqqqSiko2ENh4YELXkJRn9NZGPiaCko94D30Dnicp3mWaCuqNz4OOUuwpEzQfl/r8AaRXQAARHFJREFUzVwdLXL6ZwYa20r0fPSqDQaOa4N/q1X7uaqq5IJ+zyvd9RKIqyUYEM1PggEhhBB+XeNCGV9TAO3Zj3fx2c4Tp2+sN2G0ankGp1ZerZ+4qZSPgoI9FBUdrDlWQX7+TkpKjlBenovHU13TTuF1Nz6I93iq8VaX1P1cVazt2NL+JkKMEFkzznP5IK8aSucGN+sMgVI+vF5J7rxYuaqK8Rz9GB1gPjq/wfKxf351AJ+CkZ2j/MnyF6pPTTCQfqgQt9eHxWJHp9Ph8VRRVnb8vM9XVT8YcEswIJqfBANCCCEC/OmWPtyTpm2j+uj8rSzalnPatkajFQCPpwq3u9L/eGVl4NaKtQP+Wl6vG6fzJA5HDvn5u8jN3U7e8lvJey+YitXjtUY+t1Y5tiyH/I+6kDc3AseHKeQu6ED+vEjcS/sDPix3FGKd6IKEcf7zV3hrZgiaIYfA63WTl7eTvLydlJfn4fW6KCs7jstVceYnSj5Di6lMfxCAIAPo6+UJFFW4ePC9zSzcov1OX0hNjlON6hxNdIiFnJJK5m/MRq83YrdrAbXTefK8ZwcCcwYkGBDNT4IBIYQQAQx6Hc/d0JPresfj8Sn+uGTvaSuhGgxmrNZwlFIUFh6gqqqU8vJcqqpKAIiI6ITZHIxebyA4OIaYmB4YjRZAW29tMmmfyvq8VfiOLQKgNPN9HB+lcGKWmdx3zZR+mAjOowCUlx3GV/M9ADlLMG19AoDwgqXo6+VRu5ImNEtSs8tVhs+nDdIcjmMUFOylrOwEJ0/u02Y6XGU4HUeprMhD1cyYeL+9j/I5Zrzf3Nvk1yNO4XPjOfIBUJPkXrN7kM+nmDJzI1/U7JbVPT6U/knh3/vlgswGHruqMwAzPt/HtwdPYrNFo9cb8fk8uKqKzut8lW5V73upQCyanwQDQgghGjAZ9Lw8YQDtw4M4WV7NyysyTts2LKwDOp0en89DUdFBHI4c/+NBQRFER3cnPr4/YWEdMJlsREZ2ISIihXbtBhId3Z2QkDisQdFEdZmobf0IlDsOo9BqGgDowD/QN+ggomaMb9KD/vBsAGxdphJvgZCUO6D9DVRlzf/eS4U8nmqczkJ8vrpBWf0ZEMAfGAA4vvkZ+XPslHzUgeL34yl6zwrp91F6YBYODxQemE312gn+IEE0A70JT/tbADCmTPYHhGszCvwFAwF+cXXXJnvJu4d1ZEhyBE6Xl0cXbEMpCAqKgJ1/oPz9aEi/75zPFbBMyCXBgGh+EgwIIYRolMmg51fX9wDgtdWH+PLU+gM1DAYTdnv7gMeCgiIIDm58lxaj0eIvyKTT6bDbE4mMTMVy2RxCUicGtI0wQYgRoswQa4Zos7ZFZFDqPcR0naTlCtQUkapNaramvQk5S6j0QmXGhS8V8niqKCjYTUnJYUpKDvsfr90y0mAwA6DXG4iN7YXVbEN/fDEApprApdoHZRmzqLIkaudUUHhwAcU1QYIsHWp6Sim8vX4NY9djSKvbPeiTrVqQet/IZA7PGMc13zNxuD6DXsfM+4bWFO6r5lBBOcFBkZCz2P87cK4BQbVXZgZEy5JgQAghxGmN69uOKSOSAXjyg+1knWx8XXxwcCzx8f2x2aKx2aIID0++oNczj5xJmFHbsjTGrK35tne5B7NeW/ttvtuFfoILRryLadR7DbaLRG/CbA4hpGbLeGe9sZTP00jthFO43U7/2v+qqlL/eu+qqhLy83dz/PhmfzAQEZFCXFwfYmJ6YTRaiYzuQXyPqSRYIcaiBTEAZR6g8hhmPf6ZjyofFOybRcUc2Qq1qdUuUdMbLBgMdcvE9uVqSe0jU6Ob5XVDLEaGpWiFDTceLsJoDsHe6U6g5vcwa9Y5BX9eX10wUH+WQIjmIsGAEEKIM3p2XA+GJEdQVu3hwfc24zxNUqNebyA8vCPh4cnodBf49qI3Edx1KmEmbQkQnaZC2rsw3lW3PWT9PIDGcgL0Jmyd7wFqPplfM4n8L28ib3YQ7kbW7Cvlo6TkMMePb6agYC8nT+6jutrRYJ/4+tun6vVGjMYgDAZzwICzdnaCOysITZ2MpV43hBkhMiIVe02Q4Fbg8IBqpkTntsbn81JaepTi4kxAS27fdLiIgX9czsxvssisCWS7xoU22zUMqani/e1Bbdtb2+XzoP0NeBV4k6ecUw6Lr974v35gIERzkWBACCHEGZkMel69eyAxoRb255Xxr69Onz/QJGoH1OPrfep/nonAxrT/asEEUJb1AZ5jn6KAsozZVJQcwuepW/dfXe1oULOgsDDDHwxERXVFr9dG8AaDibCwDsTE9ECvP03FWr0JjDZ0I2cT2WUydiOE1wY3N+4lpMsUYs1aHoQCvMn3tEr15kuN03mSiop8QCv8FR6ezD+XH6CowsXvP92Dy+PDatKTGBHUbNdwRTdtadyaAwVUe7zo9QZMNcGi23tuAV/98b+3CepxCHE2EgwIIYQ4q1i7ledv7QPAzG8PcyCv7CzP+J5OnQG4gOfb6+Uf1CYfV/mgdGFnTr5nw1ezhrv+lqBWa7g/FwDAYgnFYgklJqYncXF9iYvrS3BwTECbM9GNnE1IlynYDNTlNqTNxHi3C+O47TB2PZ4Bf7/w+xR+1dVacrDVGkZkZGfcPhNbsgO3uO0cG4K+/pZTTaxfYjixoRbKqz18c/Ak+NyYcj7Wri9z7jnNAHnqRQM+mRkQLUCCASGEEOfkqu6xdIoJxuXxcfvr35JbevY1+K3JctkcIjtPINIE8Ra0AXkNj4LKjFngc+N2V4DyEB7ekcjIVGJiehASEofNFk1ERCdAmxEIWA50PtJmBs5ygFawzRwKu56naEFso8uXQFvC1FJKS7MpKjp49noJFyGn8yTV1VqAarcnodPp2JJd3GDN/S392zf29Caj1+sY17cdAB9+dwz0JqydJgFaIKo2/Oys5wiYGZBgQLQACQaEEEKcE71ex1uTB5MQZqWsysPrqw+29iWdlfXyeVpBsjsrCOt6H+EmLTkZoDTuBiori3B993+wbDimrU8C1BSNSiQ8vKN/edD31sgsh1Gvhxxt96GKg7MDPjX2+Tw4HMc4cWIr+fm7Gmxn2tTcbicVFQVUVZVSWHiAoqJDDQrHXawqK4spKTkCaDM7tXUsth0tAbQk+LuHdWD8kCTuG5nS7Ndz52Ct4NhXe/MoLK/GMuJt9DrwKqg6OPOMswNKKbySMyBamAQDQgghzlnn2BD+fkc/AOZsyGbPccdZnnERqF3Dn/YOtokugu8qgvY3QM4Sit+PR+V8ikkPxsOzWzSR12IJ839fr86Uv4BbeXkeoNU6cDiOBT655jpdrgo8NbsbfR9er6ve6/uoqiqhuDjTvzPPxcpVVUJJkZbDEhwcQ2Rkqv/Y1polQgM7RPD8rX2YcXtfDM24RKhWj3Z2+iaG4fYqPt6ag85gJqSTVlW7zHPm2QGfz0f94b9XYgHRAiQYEEIIcV5GdI7m+j7xeH2Kp/+3A4/3B7T9od6kbfmYt8T/kEEHUSbQdZrSoom8Zms4Md20XY88PlDrfwJAZWWRfyagdlem6moHpaVH8XpdFH51O0WzzVR/PZGTq8ZTODcUlT71e12Lx6MVQQsKiiAiopP/0/Xi4sxmn5W4UM61Ezk5LwK1bBjWvTOw25P8x0qdbtIPaUnhAzuEt/i11c4OvL/pKEopgkfNQq+rWZ52htkBjy/wb0lyBkRLkGBACCHEefvdTb2wW43szCnlJ7O/w+X5YQUEIV2nEmvW8ggiTTUJxsPearKXqHJ7Wb0/nzfWHCLfcfrcClPafzHqtF2Fyg++C+n3+esYhITE067dAK2SLVBRkU/eV7dTnb2QKh8UZsyDnCV4FbgPnXn5ydl4ayoiGwwWgoIiiInphdkcglKKqqqLcLmQz01F5jwAjDoIz/0Inarb8nbexmwqXF66x4fSPym8xS/vpv4JWE16MvLL2ZJdjE6nJ7RmeVqZpy7wO5XvlGBAdhMSLUGCASGEEOctNtTKX3/cD5NBx6r9BSzccuzsT7qYDH8b490uwrtOqatn0ASzAuXVHl5ekcGov6xiysxNzPh8Hzf+ex0nSivx+hRVp1aU1Zuwp07QnusBb+Ys3FXaJ9omkw2A8PAUQkPbgfJAzhIa4/QCG356QddcXe2goqIAwD8joNPpsNm04lxVVaUXdN7m4vFUU1mRh7vdDYBWlVqfGvj/b8VebYnVpOEd0emaf2nQqexWEzf2TQDgxeUHampf3IuhJnfAdejdRoM39ymzbJIzIFqCBANCCCEuyLW945k+thsAb6w5FDA7cLTIyX+/ztS2V7xY1Wzz2WCnnwu0an8+vX+7jBeXH+BkeTXRIdrAOs9RzcgZKxn2/Fd0f+4Lkn+5lJe+OoDPp/jm4EmePj6d4tiJKOCkCzyfDYKdv/MHAzqdjpCQdqAzarkOgNFoC3htpxcK9s/C981k8Di1geY5zhSUl+f6vzcYLP7vLRY7oCUXq4vkE2qns5D8j7pQ/GES5CzBpAd9pyn+/39KKY4WOdlakzw8umtMq13ro1d1wWTQ8c3BQg7ml6MbMQtzh9sBcHUY32jw6TulnyUYEC2hibZJEEII0RbdPawjb63N5HChk78t28cz1/Wg3OVh0tsbOFLoBOD9nw5nWKcoTpRWsulwMUOTI3G6PHh9ii5nqAb7dUYBm7KK+NnoVIItDd+u3F4fr68+xPrMQkakRgFwbe92dI4NOb+b+J4zAqWVbl766gAzvznsf+yJMV352ehOZOSVc+O/1+FTcLK8Lkn3pa8y2HeijC92awPxmLQneEA3158wqj++BOOmB7VgBS0gMO7+M56cJZiTbiYsbxEVBgg1QqVXq2Ts9kHu/jkEHZyDUhBkgKAuU88Y6Cjl82/JaTCYMJuD/ccMBhM6nQ6lFD6f58K3Vm1C5aVZ4DwKaEXcwo1A1iwY9hZKZ+SxBdtYvP04AEmRQSRF2k5/smaWFGljeKcovs44yYq9eXSODcE8/DUqu0/HXS95vL5TB/8SC4iWIMGAEEKICxZiMfLrcT15/P1t/OfrLHblOCgor/YHAgC/WbSb+0el8OtFuwJmDwx6Hb8e14MrusWSHB3Mkh3H+ffKgzx6VRc6RNq4f9Z3uLw+Fmw6yri+7bhjUBI92oXyvy05HMwvp8TpYsEmbWD4bU2y6H/XZfH2vUPoHh+KzWxo8iUi6YcK+XzXCQrKqukSG8I9I5L5yezv2JpdAkCEzcQz1/XgziFaAmmfxDDevncwu487SI4O5r30w2w6rK3Brw0EANZmlvNsp85UOQ5S5QOLHv8gF70JfG4i8z6m3ACh+YswpE4hPGsW1R0fIFjvw3zoHQpdWu5BZc1KpGofWA69g37oG41/Cu3z+ncpMhhMxMX1bdBGpzOglOeiCAaqq8vw7Pg9OiDOUldIrnaJ1xc7T/gDAb0Ofj2uZ6tda62re8bxdcZJVu8v4GejU7XZnl3P4z6+GHo0DNROTcaXmQHREnTqYpn7awUOh4OwsDBKS0ux2+2tfTlCCPGDNX9jNr9dtBtXzWAmKtjMyxMG8PC8LRQ7z75cZWyvOFbtL/AHCyEWI+XVnoA2JoOO6/u0Y9G24wGPd4i0ER9mZXdOKRWuujX5N/Rtx8vjB3yvirM7j5Xy60W7ePTKzlS4vDw6f2uj7exWI3++tQ839G131gDE7fVx9YtrOFzoJM5uIc+hJe9u+NVVxNl8sGmaFgh0OmWwuP5+yHwHlTKVZaF/Yt6GI6zNKGRU52jmTB2IJ/1+PJnv4VZakiqAPSyFkNszG72OoqKD/nwAuz2RkJC4Bm0KCvbgdlcSFdXFv2yoNSilKF75Y6qOLCTYAGEm4M6KgErVv/5kJ3PWZ3Ntr3ieHdejVWcFau3LdXDtS18TajGy/bfXgK+a3NlBALSzgG6CKyBQO15cyoi/rPP/PDw5iAUPXtni1y1++M5njCs5A0IIIb63CUM78M6UIeh1oNPB65MGMbJzNM9c38PfZlhKJDOnDKFrXAi/HteD/7umK70StDepZbvzAmYNagOBv97el5hQbR2726saBALjhySxZvqP+OBnaWx4dgzX94n3H1uy4wTvrT/yve7rd5/uZvvREu5/9zt/IHBZl2ievLorFmPdW+ivb+jJjf0SzmkmwmTQ8/7P0pj3wDDWPnUFA2q2vvxiVy4YbafPYxj+Nox3MU//Gx6cs4W1GdpsyLqDJ8koqMI4cjbWiS5Cx5dgr5n3d5dn+XMHlPJRXp6Hy1VOdXWZPxCIiurSaCAA+Iuu+XyeRo+3BLfbyYnjG6k6shCoqSSdMkXrq3oD6S1HSgBtJ5+LIRAA6BwTgsWop6zaw5EiJ3qjFX3izQB4ku9pMGPTcGagxS5VtGGyTEgIIUSTGNUlmjkPDMPng6EpkYC237rZoOervXk8NbY7HaJsXNE91v+ch6/swtIdJ5g2bwvBZgP/Gj+A5z/fS2ZBBT/qFsOdQ5K4Y3AiuY4q0l5YCWjBxre/vBKjXu8PFECbTXj17oEs3n6cRduOs3JfPi+vyODHgxIbzTk4m6yTFWw+EritptWk5993DyQsyES/pHBeXpFBu/AgbhvQ/rzOHWe3Eme3AjCuTzu2ZpewZMdx7h2RrDU4TR6DWxl4dWXDys/vrT/C72/qhU5vAnMYxpSJkDEXT/tb8aFDD1RUFDQoXma1hp/xE//WDgaqq8soLDxQkzx9E6F5izGlTvHnUgA4qtys3JvPnhNaAbwBrVBX4HSMBj092tnZdrSEnTmlpEQHYxw4A1evZ/CEp3Dq/2XvqXUG2u7iDdGCJBgQQgjRZEakRjd47JYB7bnlDIPlcX3b0TFqFFEhZtqFBXF51xi2ZhfTo2bWQKfT0S4siPk/Gc4/lx/gR91jaBcW1Oi5dDodN/dvz/V92jHmxTUcKXTy6PytXN41hlFdokmNOffk4o9rtksdkhxBSnQwO46VMml4R8KCtCHc5V1juLwJdqsZ17cdz3+2l02Hi3ni/W384eZehFiMOF3eBkHMuoyTHC/V6hb86vruRAZb+L8PtzM7/Qgr9ubz8JWdmTC0A8a0/0KnR3DrjOTmbsdmi0KpwIGmyRSE3Z54xmtrzWCgurqMoprqwgCRo2djNQfOBhwrdnLtS1/7Z5IGdAg/7e9Ga+mXGMa2oyVsOVLMTf0SMBqtuDY/jSdvMXQNXAp26syAFB0TLUGCASGEEK2ud/u63VXMRj3DOkU1aJOWGkVaato5nc9k0DN+SAf+8sU+VuzLZ8W+fMxGPaO7xnAov5znbuzJFd1iT/t8pRSf1CxJmjS8Izf3P79P/s9Hu7AgxvSI48s9eXy8NYfsIidmg570TG0Z0L1pHfn9zb0BWLg1B4ApI5L56eWpKKXILa3k5ZUHySmp5Pmle7lzcJK2Raiu7i3e6Sz0fx8V1RWzOdhf3fhMWisYcDoLKS3NRimFyWQjLCwJs7lhILdwS44/ELi5fwLP3dD6ScOnGpoSxbvpR1hf8//TqDdCzmIqdGA5+A7mwa9oS55oWGTsh1TLT/xwSc6AEEKIS9KtA9pjNuox6HXodODy+Fi+J4/MkxX88n87qKgZRLo8PnYeK2VrdjEvLj/AHW98y2V/XUV2kROb2cDVPRtfT9+UHh/T1f/95iPF/kAA4N30I6zLOElZlZsva3Ygum2gFpzodDoevrIL235zNaFWI2XVHvYcd6DT6fwD+VOZTLZzCgSgLhioqCjA7XaepXXTqHKepKTkMEr5sFhCiY7u1mgg4PMpPqkJjv5+Rz/+NX6Av7bDxaR2ydy+3DIWbz+OzRaNSadtG1roAveCYC05nIYzAbJMSLQEmRkQQghxSYoPs/Lxz0dgMujJKa7kvlmb/MfyHNV8tTePhPAgHpm3lVxHVaPnGNsrHpu5+d8qeybYOTxjHJ/vPMH8TUeJsJkwGfR8tFlbqvTON1l0jw+l2uOjU0wwfdoH7lNvMxsZmhzJin35pGeepE9iGJGRnXG7K7Baw8nL2wmA1RqGXm9o8Ppen0IphdEQGCTo6y3JKS7OIiamZ7NW9HWunUjJwXnQ/gaCh7+K3Z502tdbtjuXzJMVhFqMjO3V/AHbhYoJtXBNT23m5/8+2E7qtBH06HYPxQdmU+2DUg9EZ74DQ99opAJxK120aFMkGBBCCHHJ6pWgDZpTooMZ3DECvV5H17gQ5qzP5tPtx9mYVYSjykOw2RCwLWmticM6tOj1XtenHdf1aef/+cHRnRjz4lpW7stn5b58AO4e2qHRAfKoLtGs2JfP85/tIyrYwu2DEv1FxMLDO+J2OwkNbbjcaWt2MT+Z/R1en+Lzxy4nPszqP2a1hhESEk95eS4eTxWVlUXYbNoSLq/XhcdVpiUgf4/CbT6fB5+nEp3OoAUCgC5nCaG7I9GNeLdB+z3HHSzccoxFNTUF7huZTKi19QuinclrEwfys/c2s2JfPm9/ncWLd71LuIK8/bNx+cBjS8WoNzWYCZCZAdESJBgQQghxyTMZ9Hz00AgAluw4zpz12Xy1Vxtc90sKZ/5PhpFd5GTLkRLuGJyIDq1icP2BcWvoHBtKn/Zh7MzRtgG9J60jU0emNNr2riFJvLHmEHmOap78cDvhNhNX9dA+MbfZGiZ213px+QF/deSPNh/l4Su7+I/pdHrs9vbo9QYcjhzKyo5TXe3A663GtXk65CwhxAAhXafgG/QKoKisLMZgsgE6PJ5KrNaImqVJOlxVxfh8XixBkXhc5RiNFk6uvAvP0UWYO9wCCdfB8c+xG0F/eDYM/29AoOF0eZg6a5N/JqdTTDA/G536PXq4ZRgNen42OtWfv+L2+jCl/RdrxmyqfOAsPYTd5264tajEAqIFSDAghBCiTRnUMcL/fajVyL8nDMBmNtI93k73+LptNls7EKj1z7v68diCbZiNep65rsdpi6jZzEbenDyYaXO3kFNSyZ8/28uV3WPPuKyn0uVlQ1aR/+cPNx/jwdGpDZYL2WwxlJfn4fW6qKwsgp2/g5wlAJR7oXzvLNg7q+4J7W+CPr/RjpfnERISj9r8CyqyPqg5YSI4A7c5dWV/AkCIOZhgfYW/snB9s749TK6jivbhQdw/KoVbBrS/oG1jW8OgjhFEBpspqnCxNbuEoSmR2FInUZUxB6cPQjf8DG/07wOeIxWIRUuQBGIhhBBtSruwIKaP7cYt/ROY98Dwi6ZA1el0jg1l6aOXsfChEQSZG673r69/UjjLnrgcq0lPZoFWJ+GLXbnkl2mfpJ8orQz49HnV/nxcHh/hNhMRNhNHCp3M33S0wXn1egNhYdqSKT0+LCeWYNLDqWGG/+ecxaDqdiAqLztWFwhAg0AAwKDTnm+lAn5c0qDoWr6jijfXaNWUHx/ThamjUogMNp+xPy4mBr2OtJpdsjZmaQnilhFvY6hJJq46OBOPxxXwHIkFREv4YYTTQgghRBOadkXn1r6E83auibshFiPX9ornk23H+fEb6QAkRgTxk8s68dvFu+kWF8q8nwzDaNDzjy/3A1puRGyold8u3s1rqw5y1+AkzMbAzwuDgiKwWPprCcjdp0LmO1S3v4uiQ+9j1EGESRvQAzgTJ2CI6o7VGkZBwV7cLq0gmEUPbgVKQbABqnxg1kNYzWjEBxhCu4BZy/VYtjuXpTtOMDQlkheXH6C00k2EzcSN/RK+Z2+2jiHJESzdeYKNh7VidjqDGVvKeMoyF+D0gnffv4Ex/vYyMyBaggQDQgghxCVm2hWdWbrzBO6aRefHiiv57eLdAOzPK2Puhmw2ZBVyqKCCcJuJn16WitWs59VVBzlRWsWCTdnck5bc4Lz+nYiGvw1D38CiNxFXshl9xUEI7gw37gEguN7yHpstitItv9S+N4DFngrlh9DrwB7SGcoPakuChr6Bwef277mfXejkkflbcXl8LK5JFu4WF8rzt/XBajrzDMnFamiKNjPw3eEiqtxerCYDtpH/pSxzAdU+cOeupH4wILGAaAkSDAghhBCXmC5xobx01wC+ziigV4Kd5xbtDjj+4vIDgFbgbc79wwizaYP3h6/szG8W7eZPS/cSbjNz05k+ga8Z8OtvzgCP0z+IP5XVHEJpzmJAmxnQ37g38Bw+d11uQM1/q9xeps3bgqum6pZOB7f0b8/zt/Y561Kpi1mPdqHE2S3kOapJzyzkim6xGAxmLHqo9oHTG3hvMjMgWoLkDAghhBCXoHF92zHj9r5MGt6RocmRBJsN/PX2vgFt7huRHFD9+e6hHRiaHInL4+OJ97ex6XDRqadt3GkCAQCDyUZU10lEmUCfWpMUXPsFjW5L+vtP97Azp5QIm4l1T19B5vPX88+7+v+gAwHQlnqNqdnhaU76EZRSoDdhSZkAgDtS2/GqdrmVxAKiJUgwIIQQQlzCdDod834yjI3PjuHOIUmM66vVMQgLMvHzHwXmThgNeub9ZBjj+rTD61O8sy6rSa7BMuo9LBNdDZKCT3WksIJV+/JZsCkbgFcmDCQxwtashc5a2j1pyZgMOlbsy2f4Cyv4bOcJzGn/gbHr8XbQggKTUbtfrw8tYBCiGUkwIIQQQlzijAa9fwvOf97Znz/d0pu5D9QtDzq17c9GdwJg7YECqj0Ni7FdkLMUJissr2bcy+u4b9YmlIIrusUwqsvp6yP8UHWLD+UPN/cGtErYf/liH0ZjEOiM/roCpprtY7WiYxIMiOYlOQNCCCFEG2I26pk0vOMZ2/ROCCM21EJ+WTVrD5zk6p5xzXY9//hyP98cPInT5aW8WtuO1GLU8+Q13ZrtNVvbhKEdGJIcwZgX13Kk0MnGw8X0jm2P13cIAJMhcGbgEpoYERchmRkQQgghRAC9XsfN/bXk4ac+2s6Vf1/Nm2sONemSFbfXx4KN2byy8iBbskvYl1sGQJ/2Ybx3/7CAXIZLUefYUCYMTQLgnXVZWK0RNTMB+Ld11XIGZGZANC+ZGRBCCCFEA/ekJTPr28MUO90UO9288Pk+OseGcFWPOA7ml7H5SDEDOkTQNS60wXOPl1RSVuUhJTo4oF7B4ZMVFFa4qHZ7eXrhDo4WVfqPPfSjVK7sHsuQ5MgWub+Lwf2jOjF/41GW782jyNnTnzDsnxmQfAHRAiQYEEIIIUQDSZE2PnxwBMeKnXy6/TjLdufx1lqtAvBP39vs3/bynrSO/OHm3pRWuvlo8zGW7cplY80uRLGhFp6/tQ9X9Yhl0bbjTP9ou7/2QS2dDv57z2Cu6tF8S5EuVp1jQ+jRzs7eEw7WZ5VQWxy6dtMknyQQixYgwYAQQgghGtU/KZz+SeEM6hjBir35bMgqYkOWNtCv3S9/dvoRQq1GFm7J4URpFQB6HZgMevLLqnlg9nekxgSTebKC+uPa7vGhLPz5CIJMhktqt6DzNapzFHtPOPj6QAFdIrQOMuprZwYAVGAtBiGamOQMCCGEEOKM2oUFBRQg65sYxtdPXckNNduUvrrqECdKq+gQaeOX13Un/Zmr2Pzc1YwfkoROB4cKtEBgdNcY/nhzL+4bmcxrEwdiMxvbdCAAcEX3WAA+35VLWVVNzkDtzIAC1zdTqZhjRn07pZWuUFzqZGZACCGEEGf1i2u6Ul7tobzaw19u74vZqOexq7qw+7gDj8/H9b3b8ehVXfxbmALMuL0v1/SK41cLdxFiNfLSXf2JCDa34l1cfNI6RZEaE8yhggo+36flUJjq1VY7mTEfgw6cB94lRqeDtJmtdKXiUqVTbXgxmsPhICwsjNLSUux2e2tfjhBCCHFJUkrhU2DQt+1ZgNN5a+0hnv9sn//nYR0sbMiuBmBNn2mYqo8AEGVCK94mS4bEWZzPGFeWCQkhhBCiWel0OgkEzmBc34SAn031dmDyVub6v6/wAhsfbKnLEm2EBANCCCGEEK2ofXgQ1/WO9/8cbA3xf69rfzOxNSurqnzgOPAOHmdeS1+iuIRJMCCEEEII0comp9VVhbaa65YBGfr/CeP4Ciw1I7ZyD5x8Px7PJ51b+hLFJUqCASGEEEKIVhZhq0usNhnqDc90JjDasHeeRO1CK58Cp+MQeJwte5HikiTBgBBCCCFEKwsLqpsNqB8MWIJitMdGvUdst8nYazZrKjcl4nZLMCC+PwkGhBBCCCFaWf1gwOXx1SVc6+r2GTWMnE3QhHJoPw4qj1EwP4aq/3Vq6UsVlxgJBoQQQgghWpnNXDfor6j2YKgpxub1Be4AbzCYCclbSm2sUOrIwvfNxBa7TnHpkWBACCGEEKKV1a/EXF7tQV8zQjs1GEBvwt51KnFmMOjAq6AkYx6k39eCVysuJRIMCCGEEEJcRMqrPehq0oXHvrSWKTM38vrqQ3UNhr+NboKLyM7j0aFtOVpyYBbuysLWuWDxgybBgBBCCCHERaSi2kOl2wuA0+Vl9f4C/vLFPnbllNY10pswjZxNUM3qIqcXihZEw/r7W+GKxQ+ZBANCCCGEEBeR8mpPo4//e+XBwAf0JsK63OuvQeBV4Dr4DvjczXyF4lIiwYAQQgghxEXk1GDgyau7AvDF7lzuejM9YIZAN2IWUd2m1M0QtL8T9KaA57vdlVSVH2/eixY/WBIMCCGEEEJcBC7rEg3AHYOS/I/1aR/GI1d14aZ+CQBsyCrigXe/w+mqFzCkzcR2ZyGMXY+z21OUlByhoqIApRTV1WUU/K8bRR+0p3Jhaovej/hhkGBACCGEEOIi8NrEgbw1eRBPXdvN/1hksFaZeMbtfRjXpx0AuY4q/rR0b8BzLUGRhIS2B8DpPElpaTYFBbtxFGeA8ygA1WWZuJz5VFcWylIi4dfkwcALL7zAkCFDCA0NJTY2lltuuYX9+/cHtKmqqmLatGlERUUREhLC7bffTl5eXkCb7Oxsxo0bh81mIzY2lunTp+PxBE6brV69moEDB2KxWOjcuTOzZs1q6tsRQgghhGgRoVYT1/SKx2qqqzkQFaIFAzazkVcnDuS9+4ei08G8Ddks2pYT+PzQ9ths0f6fPZ5q3Nt/7/+5ygeFiwdTOD+ayrlmqr6ejFeqGLd5TR4MrFmzhmnTprF+/XqWL1+O2+3mmmuuoaKiwt/miSee4NNPP+XDDz9kzZo1HD9+nNtuu81/3Ov1Mm7cOFwuF99++y3vvvsus2bN4je/+Y2/TVZWFuPGjeOKK65g27ZtPP744zzwwAMsW7asqW9JCCGEEKJVRNXMDNS6rEsM44d0AOCxBdt46asD/mM6nY7w8I60azeQoKAIUB7IWYxJBzrAp0DVzBIUu6EoYw6Fc4JR6VNb7H7ExUenlFJnb3bhCgoKiI2NZc2aNVx++eWUlpYSExPDvHnz+PGPfwzAvn376NGjB+np6QwfPpzPP/+cG264gePHjxMXFwfAG2+8wdNPP01BQQFms5mnn36apUuXsmvXLv9rjR8/npKSEr744otzujaHw0FYWBilpaXY7famv3khhBBCiAsw6I/LKaxw8fHPRzCgQ0TAseIKF098sI3V+wsAWPjzEQw8pQ2Aw3EM5/qHicpfRKU1mXLH4UZfK8wIwZNcDRKPxQ/X+Yxxmz1noLRUy3iPjIwEYPPmzbjdbsaMGeNv0717dzp06EB6ejoA6enp9OnTxx8IAIwdOxaHw8Hu3bv9beqfo7ZN7TkaU11djcPhCPgSQgghhLjYLP/FaJY8MqpBIAAQEWxm1n1DuW2gliPwy//t4B9f7mdrdnFAO7s9kfhrPsF0t4vQm3diPs2or9JX7wfJJWhzmjUY8Pl8PP7444wcOZLevXsDkJubi9lsJjw8PKBtXFwcubm5/jb1A4Ha47XHztTG4XBQWVnZ6PW88MILhIWF+b+SkpIabSeEEEII0Zoig830bh92xjaPX9WVUKuRA3nlvLLyIBP/u4GjRY3kAOhN6EwhREV0JtYMsWYINUJMzQoklw/K10ykfPV48t81U/31JAkK2pBmDQamTZvGrl27WLBgQXO+zDl75plnKC0t9X8dPXq0tS9JCCGEEOKCdIiysfSRyxjUUZs9cLq8/PmUXYbq092cgXF8BcbOUwk1gqnTPf76BI6sD3Fkvo9HQWHGXCrnmvF9cy/K62p4ouYOFCQQaVHNFgw8/PDDLFmyhFWrVpGYmOh/PD4+HpfLRUlJSUD7vLw84uPj/W1O3V2o9ueztbHb7QQFBTV6TRaLBbvdHvAlhBBCCPFD1SHKxv8eGsGyxy9Hp9MKk93073Xc+UZ647MERhsMfxvGu2DEu4SlTiLIACZdYLNiN+Tun03RexZIv8//ePW6eyifY9aSjusP2n3uhoP48xzU+3weHKvH45lnhvX3X9A5xPlr8mBAKcXDDz/Mxx9/zMqVK0lJSQk4PmjQIEwmEytWrPA/tn//frKzs0lLSwMgLS2NnTt3kp+f72+zfPly7HY7PXv29Lepf47aNrXnEEIIIYRoK7rFhzJxmLbL0I5jpWw8XMSE/6wnI6+s8SfUJAvrR71HRERnYiyQYNWWEFnrjQ6rfVB1cBaVa8bjceZReOA9HB4o2DeTk7PNVK69m8KvbufkbDOumkG8z+elbM0EvPPrDerPQVlpNuWZ71PgAu+hdyj66hbK55zfORoLSnw+7xmDCqUUylvdZgOPJt9N6Oc//znz5s1j0aJFdOtWVzQjLCzM/4n9Qw89xGeffcasWbOw2+088sgjAHz77beAtrVo//79SUhI4K9//Su5ublMnjyZBx54gOeffx7Qthbt3bs306ZNY+rUqaxcuZJHH32UpUuXMnbs2HO6VtlNSAghhBCXCpfHxz++3M/+vDL/TkMjUqO4pmccH24+xmsTB9IxKrjxJ3ucdbsJbfgpnkOzKPeC03vur2/RQ5QZSsbuxbmoByYdxFhA3VWNzmBu/Ek+t/91c49vwvfF0AZN4i2gn3D23Y7c39xL5cHZ6HVg7Dge6+j5lJdk4djwKKF5SwjtOlWbFakd9OtNKKU4+dVteI5+QqgRQmrbnC+fm8rqMnw+LzZbNDqd7uzPaUbnM8Zt8mDgdDc/c+ZMpkyZAmhFx5588knmz59PdXU1Y8eO5bXXXvMvAQI4cuQIDz30EKtXryY4OJh7772XGTNmYDQa/W1Wr17NE088wZ49e0hMTOS5557zv8a5kGBACCGEEJeirJMVXPmP1dQf5Y3r045XJw4EwOdTfLT5GF3jQ+mfFN7wBD43Xq+L/I+6oyqPnfPr2jvdiaO6AnKWAhAZnkJp2ocYTCFERXXF5SrHbA5GKR/OtRMxHf0AS5epeAa/Sv6KOyBnSYNzhhkhuJFBulIKj6cSozEIfG4KZlvwBIxqDYAWzejQEqZL4m+GY4sIN4Kx0z2Uu6pwZH4AgFEHsRa0JVSnBB5erxu9z9VoUFOx7l4cB+ej2t8EfX5DaGg7QkMTzrnPmkOrBgM/JBIMCCGEEOJS9bP3vmPZ7rr8SoNexzU94/D4FIkRQcz85jAAc+4fxqgu0Q1P4HNTPdeMS4GtJtFYV/PlVmDQQbkHgg1Q5OaUgfgpagbKAEajFbXtWbzHFqEDwkxQEnMdHP8csx7sRlAKXArKPBBkgAgTdYN0nxu310NJSRZudyVGoxWbLQrHkqHgPIpepxVYq3Xqz6AN/BXgrfe4Dojvfi+6EbMCZiwqKvIp/XQQOucxTHrtuT6l3W+Dex67Hp3eTGRkKuXluYSHJ2M43axIM5Jg4BxJMCCEEEKIS1V5tYcXPttLsMXIhsxCth8rbbTdTf0SeHnCgMZPsv5+yHwHUqbAkFcbLtXZ8FPImoXLB6UebRBv0GnBQ7lHCxr8xq4HnVGrjLxseKMvF2IAe9cpMOwtqiuLKFz3U8hZTLgJgjrfR0V1BWR/QHn8zfh6P1f3xJpzhhkh2Kgtb/IpMOu1/xadIR0g2KC1VwnXYc39HEtoMp7yw5g63olx+JsUrpqAOnH2grYmHfiu/S4gwAgOjiEsrMNZn9vUJBg4RxIMCCGEEKIt+HT7cR6Zv7XRY+E2E989Owaj4TT7ytT7lPy0xzc+qAUNtYI744sZQdWh2egBR/ytmAb/A6PRSpkjG5YNR4f26Xx9EWHJBN2eBYBSPk58ebN/6ZBRd8on8WPXYw2KpqqqBADD7j8Rm/8JutSpWnCQNRuS74Ghr1M+Lxiv0mYJLHotMVopQAehBjihT4QzLIcy6LSgwaOg0ht43Ra9NnOhS7kXR68/UlGhbYBjNFqIju6BXm84fd81EwkGzpEEA0IIIYRoC5RSfPjdMTYdLiKnpJJvDxXy1LXdeGttJiVON09d241hKZEkRtiIs1vZl+sgp7iSq3rEnf3ktWoTc31ubQvT+o/VBBM+n5eCgt3od/6e6LyFuPShGLxleGuWBYUYQDehbjlQ0WwzVb5GXithHCEj3iQ0NIHy8hMA2GwxGHR1rxUQxNTOcAB0mgpD34AND/gDBkfGbMpPkyxt0kGkGQwhnaAiE19wKvqKQ3hsnTBUZKLToc2cpM3E7a6koGAPAOHhHbHZGll+1QIkGDhHEgwIIYQQoq1xVLnZfKSY0V1i+GjLMZ76aIf/mEGvo1eCnX25Zbg8PuY9MIwRnZt2QFs79NQpjzZY9zhh0zTImqUN1OsnCqffR9XBWY0u84ntdg/Gke+e+wufEpj4H9ObUOlTcWbMpNSjfdIfaQIfUOXVchb0IZ3h5oy6AKP+f2vO6fb6qHJ7Ua48PJ5qIiJS0Omatb7vaUkwcI4kGBBCCCFEW6aU4qE5W/hid26jx9M6RTHvJ8NaZqvM0yxHUt/cQ96B9/ApCDdBqbtmwG6m0Z1/vs/re9b/BEPWu9pSo8Gv1A34a2c6TsNR5WbifzaQWVDO4kdGkRoT0jTXdIEkGDhHEgwIIYQQoq2r9njZfLiY1NgQfj53Cxl5ZUwZmcKrqw7i9Sn+cUc/kqNtJIQHYTEa+PfKg+zKKeWK7rF0jQvhn18doFN0CC/d1R+9/vRBQ5Xby6p9+YzoHE1Y0PkN4D3rJuM9PAdL6hR8CnRZs7QB+1lqAhzML2fG53u5f1Qn0lKjGp7X6+NQQQVd40LqAp5TghKvT/Fe+mHWZxbRv0M4Px6USHSIJeA8v/p4J/M2ZANwS/8ExvVNYMmO4zz0o1S6x7f8GFOCgXMkwYAQQgghRB2vT+Hx+bAYDby4/AAvr8g45+f+9cd9uXNwEm6vj1dXHSSzoIJ2YVY+2ZbD0JQocksr2XS4mNsGtOfFu/qf/8XVH6SfZhbB4/Vh0OvQ6XR4vD4G/ekrSivdJEYEse7pKxu0/+2iXbybfoSBHcJ5beIg4sOsDdq8ueYQL3y+z/9zqMXIV0+OJjbUwptrM/l0+3F2H3f4j1tNejpFh7DnhINpV6QyfWz387/X70mCgXMkwYAQQgghROM8Xh8/n7uFL/fkYTLocNfsmdk+PIib+yfwvy3HyHNUBzznoR+lcrTIyZIdJ8547nVPX4Fep0MBCWFW/6fyFdUevEphtzY+c6CUCliyVFrpJizIRFmVm+kf7uDLPbn4FEwY2oHkKFvAIP6jB9P43ae7UQr6tA8jKsTMq6sOBZy/T/swfntjT3736W56J4Tx6xt6cteb6ew+7iA1JphDBRX+tuOHJLFg01H/z3cMSmTNgQLyy7Q+sRj1rHv6SmJCA2cRWoIEA+dIggEhhBBCiNNTSlFU4cIeZGLHsRLWHjjJHYMTSYywkVtaxdvrMrm+Tztufe3bC36NoSmR3DagPRuzivhkWw4GvY7rerejQ6SNXEcVy/fkMX5oEonhQfz9ywPcm9aRJ67uynOLdjFnfTZTRiSjlOLd9CNNeOeaEIuR8moPOh1senYM27JLeGD2dwFtxg9JYninKG7sl8Av/7eDDzdrW5ROH9uNaVd0bvJrOhcSDJwjCQaEEEIIIb6/V1cdZPG243iV4mB+Of2TwvnfQyPIOlmBx+fj6Y92EGe38uCPUnni/W0cKXR+r9erHaSfaurIFL7YdYLjpVUAxIRamDIimb8t2+9v8+NBibg8PoqdLhIjbPzy2u7szyvjzjfTA86l09XUIgCu7RXPG5MHAbAhs5AlO04wf2M2dwxO5Plb+/hnK/IcVczdkM2gjhGM7hrzve7x+5Bg4BxJMCCEEEII0bSKK1yEBZlOm0xc5fayMauIvolhfLT5GEt3nkAp2Ha0hNhQC6O6RJNd6OS7I8VnfB2zUc/Q5EjWHTwJwPBOkSz4aRqgzWjszyujY2QwOh3c+tq37D3hYFzfdrx698BGz3eksIKfvbeZmFALz9/aB4tJz7JduTiqPNw/KgWrKbB4mMvjw2xsna1Dz0aCgXMkwYAQQgghxMUht7SKIJOBMJuWL/Dl7lxmfLGP/7umGz+fuwWA397Ykxe/PIA9yMS/xvdncHIkn+88wez0I/z51t50Os2WnpUuL+uzChmRGoXF2PIVgVuaBAPnSIIBIYQQQoiL36bDRRw+WaEt8fH6MOn1Z9zGtK07nzGusYWuSQghhBBCiAsyJDmSIcmRAG3ik/2WdHEudBJCCCGEEEI0OwkGhBBCCCGEaKMkGBBCCCGEEKKNkmBACCGEEEKINkqCASGEEEIIIdooCQaEEEIIIYRooyQYEEIIIYQQoo2SYEAIIYQQQog2SoIBIYQQQggh2igJBoQQQgghhGijJBgQQgghhBCijZJgQAghhBBCiDZKggEhhBBCCCHaKAkGhBBCCCGEaKMkGBBCCCGEEKKNkmBACCGEEEKINkqCASGEEEIIIdooY2tfQGtSSgHgcDha+UqEEEIIIYRoGrVj29qx7pm06WCgrKwMgKSkpFa+EiGEEEIIIZpWWVkZYWFhZ2yjU+cSMlyifD4fx48fJzQ0FJ1O1+Kv73A4SEpK4ujRo9jt9hZ//R8y6bvvR/rvwknfXTjpuwsnfXfhpO8unPTdhWvtvlNKUVZWRkJCAnr9mbMC2vTMgF6vJzExsbUvA7vdLn9kF0j67vuR/rtw0ncXTvruwknfXTjpuwsnfXfhWrPvzjYjUEsSiIUQQgghhGijJBgQQgghhBCijZJgoBVZLBZ++9vfYrFYWvtSfnCk774f6b8LJ3134aTvLpz03YWTvrtw0ncX7ofUd206gVgIIYQQQoi2TGYGhBBCCCGEaKMkGBBCCCGEEKKNkmBACCGEEEKINkqCASGEEEIIIdooCQaEEEIIIYRooyQYaGYzZsxAp9Px+OOP+x+rqqpi2rRpREVFERISwu23305eXl7A87Kzsxk3bhw2m43Y2FimT5+Ox+Np4atveTk5OUyaNImoqCiCgoLo06cP3333nf+4Uorf/OY3tGvXjqCgIMaMGUNGRkbAOYqKipg4cSJ2u53w8HDuv/9+ysvLW/pWWpTX6+W5554jJSWFoKAgUlNT+eMf/0j9zcKk7+qsXbuWG2+8kYSEBHQ6HZ988knA8abqqx07dnDZZZdhtVpJSkrir3/9a3PfWrM7U9+53W6efvpp+vTpQ3BwMAkJCdxzzz0cP3484BzSd43/3tX34IMPotPpeOmllwIel747fd/t3buXm266ibCwMIKDgxkyZAjZ2dn+4231vfdsfVdeXs7DDz9MYmIiQUFB9OzZkzfeeCOgTVvtuxdeeIEhQ4YQGhpKbGwst9xyC/v37w9o01R9s3r1agYOHIjFYqFz587MmjWruW+vjhLNZuPGjSo5OVn17dtXPfbYY/7HH3zwQZWUlKRWrFihvvvuOzV8+HA1YsQI/3GPx6N69+6txowZo7Zu3ao+++wzFR0drZ555plWuIuWU1RUpDp27KimTJmiNmzYoDIzM9WyZcvUwYMH/W1mzJihwsLC1CeffKK2b9+ubrrpJpWSkqIqKyv9ba699lrVr18/tX79evX111+rzp07qwkTJrTGLbWYP//5zyoqKkotWbJEZWVlqQ8//FCFhISof/3rX/420nd1PvvsM/Xss8+qhQsXKkB9/PHHAceboq9KS0tVXFycmjhxotq1a5eaP3++CgoKUm+++WZL3WazOFPflZSUqDFjxqj3339f7du3T6Wnp6uhQ4eqQYMGBZxD+q7x37taCxcuVP369VMJCQnqn//8Z8Ax6bvG++7gwYMqMjJSTZ8+XW3ZskUdPHhQLVq0SOXl5fnbtNX33rP13U9+8hOVmpqqVq1apbKystSbb76pDAaDWrRokb9NW+27sWPHqpkzZ6pdu3apbdu2qeuvv1516NBBlZeX+9s0Rd9kZmYqm82mfvGLX6g9e/aoV155RRkMBvXFF1+0yH1KMNBMysrKVJcuXdTy5cvV6NGj/cFASUmJMplM6sMPP/S33bt3rwJUenq6Ukr7w9Xr9So3N9ff5vXXX1d2u11VV1e36H20pKefflqNGjXqtMd9Pp+Kj49Xf/vb3/yPlZSUKIvFoubPn6+UUmrPnj0KUJs2bfK3+fzzz5VOp1M5OTnNd/GtbNy4cWrq1KkBj912221q4sSJSinpuzM59c2xqfrqtddeUxEREQF/s08//bTq1q1bM99RyznTgLbWxo0bFaCOHDmilJK+q3W6vjt27Jhq37692rVrl+rYsWNAMCB9p2ms7+666y41adKk0z5H3ns1jfVdr1691B/+8IeAxwYOHKieffZZpZT0XX35+fkKUGvWrFFKNV3fPPXUU6pXr14Br3XXXXepsWPHNvctKaWUkmVCzWTatGmMGzeOMWPGBDy+efNm3G53wOPdu3enQ4cOpKenA5Cenk6fPn2Ii4vztxk7diwOh4Pdu3e3zA20gsWLFzN48GDuuOMOYmNjGTBgAP/5z3/8x7OyssjNzQ3ou7CwMIYNGxbQd+Hh4QwePNjfZsyYMej1ejZs2NByN9PCRowYwYoVKzhw4AAA27dvZ926dVx33XWA9N35aKq+Sk9P5/LLL8dsNvvbjB07lv3791NcXNxCd9P6SktL0el0hIeHA9J3Z+Lz+Zg8eTLTp0+nV69eDY5L3zXO5/OxdOlSunbtytixY4mNjWXYsGEBy2Hkvff0RowYweLFi8nJyUEpxapVqzhw4ADXXHMNIH1XX2lpKQCRkZFA0/VNenp6g/Hi2LFj/edobhIMNIMFCxawZcsWXnjhhQbHcnNzMZvN/jfGWnFxceTm5vrb1P+lqT1ee+xSlZmZyeuvv06XLl1YtmwZDz30EI8++ijvvvsuUHfvjfVN/b6LjY0NOG40GomMjLyk++6Xv/wl48ePp3v37phMJgYMGMDjjz/OxIkTAem789FUfdVW/47rq6qq4umnn2bChAnY7XZA+u5M/vKXv2A0Gnn00UcbPS5917j8/HzKy8uZMWMG1157LV9++SW33nort912G2vWrAHkvfdMXnnlFXr27EliYiJms5lrr72WV199lcsvvxyQvqvl8/l4/PHHGTlyJL179waarm9O18bhcFBZWdkctxPA2Oyv0MYcPXqUxx57jOXLl2O1Wlv7cn5QfD4fgwcP5vnnnwdgwIAB7Nq1izfeeIN77723la/u4vbBBx8wd+5c5s2bR69evdi2bRuPP/44CQkJ0neiVbjdbu68806UUrz++uutfTkXvc2bN/Ovf/2LLVu2oNPpWvtyflB8Ph8AN998M0888QQA/fv359tvv+WNN95g9OjRrXl5F71XXnmF9evXs3jxYjp27MjatWuZNm0aCQkJDT6tbsumTZvGrl27WLduXWtfSpOTmYEmtnnzZvLz8xk4cCBGoxGj0ciaNWt4+eWXMRqNxMXF4XK5KCkpCXheXl4e8fHxAMTHxzfIRK/9ubbNpahdu3b07Nkz4LEePXr4d4OovffG+qZ+3+Xn5wcc93g8FBUVXdJ9N336dP/sQJ8+fZg8eTJPPPGEf3ZK+u7cNVVftdW/Y6gLBI4cOcLy5cv9swIgfXc6X3/9Nfn5+XTo0MH/3nHkyBGefPJJkpOTAem704mOjsZoNJ71/UPeexuqrKzkV7/6FS+++CI33ngjffv25eGHH+auu+7i73//OyB9B/Dwww+zZMkSVq1aRWJiov/xpuqb07Wx2+0EBQU19e00IMFAE7vqqqvYuXMn27Zt838NHjyYiRMn+r83mUysWLHC/5z9+/eTnZ1NWloaAGlpaezcuTPgH/3aN9RT/7G7lIwcObLBll0HDhygY8eOAKSkpBAfHx/Qdw6Hgw0bNgT0XUlJCZs3b/a3WblyJT6fj2HDhrXAXbQOp9OJXh/452wwGPyfmEnfnbum6qu0tDTWrl2L2+32t1m+fDndunUjIiKihe6m5dUGAhkZGXz11VdERUUFHJe+a9zkyZPZsWNHwHtHQkIC06dPZ9myZYD03emYzWaGDBlyxvePQYMGyXtvI9xuN263+4zvH22575RSPPzww3z88cesXLmSlJSUgONN1TdpaWkB56htU3uOZtciacptXP3dhJTStqHq0KGDWrlypfruu+9UWlqaSktL8x+v3YbqmmuuUdu2bVNffPGFiomJ+cFv0XU2GzduVEajUf35z39WGRkZau7cucpms6k5c+b428yYMUOFh4erRYsWqR07dqibb7650S0fBwwYoDZs2KDWrVununTpckluj1nfvffeq9q3b+/fWnThwoUqOjpaPfXUU/420nd1ysrK1NatW9XWrVsVoF588UW1detW/443TdFXJSUlKi4uTk2ePFnt2rVLLViwQNlsth/8Fo9n6juXy6VuuukmlZiYqLZt26ZOnDjh/6q/o4j0XeO/d6c6dTchpaTvTtd3CxcuVCaTSb311lsqIyPDvzXj119/7T9HW33vPVvfjR49WvXq1UutWrVKZWZmqpkzZyqr1apee+01/znaat899NBDKiwsTK1evTrg3zOn0+lv0xR9U7u16PTp09XevXvVq6++KluLXmpODQYqKyvVz3/+cxUREaFsNpu69dZb1YkTJwKec/jwYXXdddepoKAgFR0drZ588knldrtb+Mpb3qeffqp69+6tLBaL6t69u3rrrbcCjvt8PvXcc8+puLg4ZbFY1FVXXaX2798f0KawsFBNmDBBhYSEKLvdru677z5VVlbWkrfR4hwOh3rsscdUhw4dlNVqVZ06dVLPPvtswABM+q7OqlWrFNDg695771VKNV1fbd++XY0aNUpZLBbVvn17NWPGjJa6xWZzpr7Lyspq9BigVq1a5T+H9F3jv3enaiwYkL47fd+9/fbbqnPnzspqtap+/fqpTz75JOAcbfW992x9d+LECTVlyhSVkJCgrFar6tatm/rHP/6hfD6f/xxtte9O9+/ZzJkz/W2aqm9WrVql+vfvr8xms+rUqVPAazQ3nVL1SpQKIYQQQggh2gzJGRBCCCGEEKKNkmBACCGEEEKINkqCASGEEEIIIdooCQaEEEIIIYRooyQYEEIIIYQQoo2SYEAIIYQQQog2SoIBIYQQQggh2igJBoQQQgghhGijJBgQQgghhBCijZJgQAghhBBCiDZKggEhhBBCCCHaqP8HZM45uXLa+HwAAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 900x7000 with 10 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_examples = 10\n", + "\n", + "fig, axes = plt.subplots(nrows=num_examples, ncols=1, figsize=(9, 7 * num_examples))\n", + "\n", + "for ax, pred, true, mask in zip(axes.flatten(), predictions[:num_examples], true_spectra[:num_examples], masks[:num_examples]):\n", + "\n", + " ax.plot(wavenumbers, pred, label=\"prediction\", color=\"olive\", alpha=0.2)\n", + "\n", + " ax.scatter(wavenumbers[mask], pred[mask], label=\"masked prediction\", s=1.5, color=\"orange\")\n", + " \n", + " ax.plot(wavenumbers, true, label=\"label\")\n", + "\n", + " ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "f8ca3553-0de7-4b48-82e9-092e0ac8d891", + "metadata": {}, + "outputs": [], + "source": [ + "model_config[\"fine_warm_up_duration\"] = 5" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "4e7b3cb7-0949-496f-a0cc-e692ff68404b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n", + "epoch: 1 \ttrain_loss 0.42\tval_loss 1.02\tlr: 1.00e-06\n", + "epoch: 2 \ttrain_loss 0.30\tval_loss 0.57\tlr: 2.01e-04\n", + "epoch: 3 \ttrain_loss 0.22\tval_loss 0.48\tlr: 4.01e-04\n", + "epoch: 4 \ttrain_loss 0.19\tval_loss 0.39\tlr: 6.00e-04\n", + "epoch: 5 \ttrain_loss 0.16\tval_loss 0.36\tlr: 8.00e-04\n", + "epoch: 6 \ttrain_loss 0.14\tval_loss 0.33\tlr: 1.00e-03\n", + "epoch: 7 \ttrain_loss 0.13\tval_loss 0.30\tlr: 5.00e-04\n", + "epoch: 8 \ttrain_loss 0.13\tval_loss 0.31\tlr: 1.00e-03\n", + "epoch: 9 \ttrain_loss 0.13\tval_loss 0.29\tlr: 8.54e-04\n", + "epoch: 10 \ttrain_loss 0.12\tval_loss 0.26\tlr: 5.00e-04\n", + "epoch: 11 \ttrain_loss 0.11\tval_loss 0.27\tlr: 1.46e-04\n", + "epoch: 12 \ttrain_loss 0.12\tval_loss 0.27\tlr: 1.00e-03\n", + "epoch: 13 \ttrain_loss 0.11\tval_loss 0.26\tlr: 9.62e-04\n", + "epoch: 14 \ttrain_loss 0.11\tval_loss 0.25\tlr: 8.54e-04\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[46], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m trans_encoder, fc_net, train_losses, val_losses \u001b[38;5;241m=\u001b[39m \u001b[43mfine_tuning\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrans_encoder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmae_model\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmae_encoder\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mtraining_set\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtrain_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mval_set\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_gpu\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/git_projects/raman_master/raman_master/models/mae.py:448\u001b[0m, in \u001b[0;36mfine_tuning\u001b[0;34m(config, trans_encoder, training_set, val_set, num_epochs, use_gpu, loss_fn, val_loss_fn, verbose, use_tune)\u001b[0m\n\u001b[1;32m 441\u001b[0m cls_encoding \u001b[38;5;241m=\u001b[39m trans_encoder(one_batch[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mspectra\u001b[39m\u001b[38;5;124m\"\u001b[39m], all_patches)[\n\u001b[1;32m 442\u001b[0m :,\n\u001b[1;32m 443\u001b[0m :trans_encoder\u001b[38;5;241m.\u001b[39mnum_cls_tokens,\n\u001b[1;32m 444\u001b[0m :\n\u001b[1;32m 445\u001b[0m ]\n\u001b[1;32m 446\u001b[0m predictions \u001b[38;5;241m=\u001b[39m fc_net(cls_encoding\u001b[38;5;241m.\u001b[39mview(batch_size, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m))\n\u001b[0;32m--> 448\u001b[0m mse_loss \u001b[38;5;241m=\u001b[39m \u001b[43mloss_fn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 449\u001b[0m \u001b[43m \u001b[49m\u001b[43mpredictions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 450\u001b[0m \u001b[43m \u001b[49m\u001b[43mone_batch\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mconcentrations\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 451\u001b[0m \u001b[43m \u001b[49m\u001b[43mone_batch\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mlabel_weight\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 452\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 453\u001b[0m mse_loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[1;32m 454\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mstep()\n", + "File \u001b[0;32m~/git_projects/raman_master/venv/lib/python3.10/site-packages/torch/nn/modules/module.py:1532\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1530\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1531\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1532\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/git_projects/raman_master/venv/lib/python3.10/site-packages/torch/nn/modules/module.py:1541\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1536\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1537\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1538\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1539\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1540\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1541\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1543\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1544\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/git_projects/raman_master/raman_master/models/loss.py:15\u001b[0m, in \u001b[0;36mMSEIgnoreNans.forward\u001b[0;34m(self, input, target, weights)\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28minput\u001b[39m: torch\u001b[38;5;241m.\u001b[39mTensor,\n\u001b[1;32m 9\u001b[0m target: torch\u001b[38;5;241m.\u001b[39mTensor,\n\u001b[1;32m 10\u001b[0m weights: torch\u001b[38;5;241m.\u001b[39mTensor,\n\u001b[1;32m 11\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m torch\u001b[38;5;241m.\u001b[39mTensor:\n\u001b[1;32m 12\u001b[0m mask \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39misfinite(target)\n\u001b[1;32m 13\u001b[0m mse \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mmean(\n\u001b[1;32m 14\u001b[0m torch\u001b[38;5;241m.\u001b[39mmul(\n\u001b[0;32m---> 15\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msquare\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mmask\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[43m[\u001b[49m\u001b[43mmask\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 16\u001b[0m torch\u001b[38;5;241m.\u001b[39mtile(weights[:, \u001b[38;5;28;01mNone\u001b[39;00m], dims\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m1\u001b[39m, target\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m]))[mask],\n\u001b[1;32m 17\u001b[0m )\n\u001b[1;32m 18\u001b[0m )\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mwhere(\n\u001b[1;32m 20\u001b[0m torch\u001b[38;5;241m.\u001b[39misfinite(mse),\n\u001b[1;32m 21\u001b[0m mse,\n\u001b[1;32m 22\u001b[0m torch\u001b[38;5;241m.\u001b[39mtensor(\u001b[38;5;241m0.\u001b[39m)\u001b[38;5;241m.\u001b[39mto(target\u001b[38;5;241m.\u001b[39mdevice),\n\u001b[1;32m 23\u001b[0m )\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "\n", + "\n", + "trans_encoder, fc_net, train_losses, val_losses = fine_tuning(\n", + " config=model_config,\n", + " trans_encoder=mae_model.mae_encoder,\n", + " training_set=train_data,\n", + " val_set=val_data,\n", + " num_epochs=100,\n", + " use_gpu=True,\n", + " verbose=True,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d98bccd-af56-42dc-bf41-7de42f3b92a5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/visualisations/plot_spectra_issues_with_low_intensity.ipynb b/notebooks/visualisations/plot_spectra_issues_with_low_intensity.ipynb new file mode 100644 index 0000000..92ca74c --- /dev/null +++ b/notebooks/visualisations/plot_spectra_issues_with_low_intensity.ipynb @@ -0,0 +1,568 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "49f210f4", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline\n", + " \n", + "import numpy as np\n", + "import raman_hive\n", + "import grpc\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1b1ab1f2", + "metadata": {}, + "outputs": [], + "source": [ + "from raman_hive.grpc.client import get_sample_ids_remote, get_spectra_per_run_id_remote\n", + "\n", + "\n", + "local_channel = \"127.0.0.1:50052\"\n", + "\n", + "client_stub = raman_hive.grpc.RamanHiveStub(\n", + " grpc.insecure_channel(local_channel)\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "5e1d715f-45ae-4e76-8086-f0844c0d7c09", + "metadata": {}, + "source": [ + "# Plot Dillusion Spectra" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d8f8dc78-08ef-48cd-9994-32e88e693966", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import math\n", + "\n", + "from itertools import groupby\n", + "\n", + "\n", + "spectra = sorted(\n", + " get_spectra_per_run_id_remote(\n", + " run_id=895,\n", + " experiment_id=0,\n", + " client_stub=client_stub,\n", + " # Cedex is 0==Null\n", + " device_id=0,\n", + " ),\n", + " key=lambda x: (x[\"sample_id\"], x[\"measurement_time\"]),\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c2d7f103-1ee2-4c0a-b61a-f56ba667dd38", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "431" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(spectra)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "962afd60-6e65-4491-80e2-8b42c7019340", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['spectrum_id', 'run_id', 'experiment_id', 'container_number', 'sample_time', 'raw_spectrum', 'spectrometer_config', 'duration', 'laser_power', 'wavenumber_per_pixel', 'wavenumber_raman_shift', 'sample_id', 'sample_label', 'measurement_time', 'meta_data', 'annotations'])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "spectra[0].keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "29da381a-a962-4ff1-8165-5a828cac77b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wns = np.array(spectra[0][\"wavenumber_raman_shift\"])\n", + "\n", + "mask = np.logical_and(wns > 400, wns < 1700)\n", + "\n", + "pure_spectra = np.array([\n", + " np.array(one[\"raw_spectrum\"], dtype=np.float64)[mask]\n", + " for one in spectra\n", + "])\n", + "\n", + "ax = plt.gca()\n", + "\n", + "\n", + "for one in pure_spectra:\n", + "\n", + " \n", + "\n", + " ax.plot(wns[mask], one)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "bb188cc4-39d2-4832-b56d-d3d5140ebd36", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'number of items')" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "glc_peak_mask = np.logical_and(wns[mask] > 1000, wns[mask] < 1500)\n", + "\n", + "peak_intensities = [\n", + " np.mean(one[glc_peak_mask])\n", + " for one in pure_spectra\n", + "]\n", + "\n", + "ax = plt.gca()\n", + "\n", + "ax.hist(peak_intensities, bins=20)\n", + "ax.set_xlabel(\"glc peak intensity\")\n", + "ax.set_ylabel(\"number of items\")" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "efbb2893-564e-4b37-a42b-bf7bc141d5f7", + "metadata": {}, + "outputs": [], + "source": [ + "# read air spectra \n", + "\n", + "air_candidate_spectra = sorted(\n", + " get_spectra_per_run_id_remote(\n", + " run_id=0,\n", + " experiment_id=21594,\n", + " client_stub=client_stub,\n", + " # Cedex is 0==Null\n", + " device_id=0,\n", + " ),\n", + " key=lambda x: (x[\"sample_id\"], x[\"measurement_time\"]),\n", + ")\n", + "\n", + "pure_air_candidate_spectra = np.array([\n", + " np.array(one[\"raw_spectrum\"], dtype=np.float64)[mask]\n", + " for one in air_candidate_spectra\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "d4a5e70b-3425-4189-a1c9-cde608de36e3", + "metadata": {}, + "outputs": [], + "source": [ + "intensities = np.array([\n", + " np.mean(one)\n", + " for one in pure_air_candidate_spectra\n", + "])\n", + "lowest_idxs = intensities.argsort()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "73aedbe5-55c4-4c9c-a664-76e6e6d175c1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "ax = plt.gca()\n", + "\n", + "for idx in lowest_idxs[:3]:\n", + "\n", + " ax.plot(wns[mask], pure_air_candidate_spectra[idx])" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "721b36b1-bdb4-49a3-823a-58ffeec55637", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x727bc40a0f70>]" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "air_spectrum = np.mean(\n", + " np.array(\n", + " [\n", + " pure_air_candidate_spectra[idx][None, :]\n", + " for idx in lowest_idxs[:3]\n", + " ],\n", + " dtype=np.float64,\n", + " ),\n", + " axis=0,\n", + ")[0, :]\n", + "\n", + "ax = plt.gca()\n", + "\n", + "ax.plot(wns[mask], air_spectrum)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "17e75330-5876-40cb-aa78-d4204648c497", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# high intensity spectrum\n", + "\n", + "test_intensities = np.array([\n", + " np.mean(one)\n", + " for one in pure_spectra\n", + "])\n", + "\n", + "test_intensity_idxs = test_intensities.argsort()\n", + "\n", + "ax = plt.gca()\n", + "\n", + "for idx in test_intensity_idxs[-5:]:\n", + "\n", + " ax.plot(wns[mask], pure_spectra[idx])" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "b81b03ca-3cb9-4363-9e83-53f1a68cd051", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x727bc4393ca0>]" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAGdCAYAAADwjmIIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABoDUlEQVR4nO3deViU5f4/8PcMAzNsM2zCAALiBi6ouIZbixyXbLE9o+WUp06dOmn1M4/fTn47bZq2WVYe65xTp7T1W1ZmKmmlKaKguIuYKMgq67Bvc//+eGYeGNlhYIbh/bourouZ556Hex6Veft57kUhhBAgIiIicjBKW3eAiIiIqCcw5BAREZFDYsghIiIih8SQQ0RERA6JIYeIiIgcEkMOEREROSSGHCIiInJIDDlERETkkFS27oAtGY1GZGdnw9PTEwqFwtbdISIiog4QQqCsrAxBQUFQKluv1/TrkJOdnY2QkBBbd4OIiIi6IDMzEwMHDmz1eL8OOZ6engCki6TVam3cGyIiIuoIg8GAkJAQ+XO8Nf065JhvUWm1WoYcIiKiPqa9oSYceExEREQOiSGHiIiIHBJDDhERETkkhhwiIiJySAw5RERE5JAYcoiIiMghMeQQERGRQ2LIISIiIofEkENEREQOiSGHiIiIHBJDDhERETkkhhwiIiJySAw5vezYxVJ8sOccjEZh664QERE5tH69C3lvO5tfhuvX/QYAGDzAHddEBti4R0RERI6LlZxe9Mn+DPn71NxyG/aEiIjI8THk9KKLxVXy9xcKK2zYEyIiIsfHkNOL8suq5e/TCxhyiIiIehJDTi/KMzSGnPOs5BAREfUohpxeUt9gxKWyGvlxnqEGFTX1NuwRERGRY2PI6SWFFbUwCsBJqYBaJV32pqGHiIiIrIshp5eYb1UN8FDDz0MNQAo+RERE1DMYcnpJbqkUcgK0avh6uAAAihhyiIiIegwXA+wll8qlW1MDPDWoNxoBAMUMOURERD2GIaeXFJZLgWaApwtq6qWQw9tVREREPYchp5cUmio5vu5qVNc1AACKKxlyiIiIegpDTi8pMFVtfD1cUGUKOebqDhEREVkfQ04vKTBNF/f1UKOqVlofp6iCU8iJiIh6CkNOLzGPv/Fzd0G5aZ2coso6W3aJiIjIoTHk9BJ5TI6HGmpnpcVzREREZH0MOb2gvsGIYlPVxtfDBR4a6bLnGaphNAoolQpbdo+IiMghcTHAXlBkmkWlVADebi4I8FTDSalAXYNAPrd2ICIi6hEMOb3APIvKx90FTkoFVE5K6LUaAEBWSaUtu0ZEROSwGHJ6gTnk+Lqr5eeCvV0BABeLq2zSJyIiIkfHkNMLCuRBxy7ycwO9pJCTVcKQQ0RE1BMYcnpBQZOZVWatVXKq6xoghOi9zhERETkohpxeYF4jx9e9sZITqJNCTr6hWn5u3a40RD67DbNe+xUVNfW920kiIiIHw5DTCwrlHcgbKzk+7s4AIE8tB4BvU7IBAOcKKpCSWdJ7HSQiInJADDm9oHHgcWMlx9tN+r7YVOUpq67D2Uvl8vG0vLJe7CEREZHjYcjpBY2bczZWcrxNgce8hs6xi6VoOhSnaeAhIiKizmPI6QWFLcyuMldySqvq0GAUOJpVavGas/kMOURERN3BkNPDjMbGVY0HNKnkeLlJY3KEkIKOOdTEjvAHAJzNr+jlnhIRETkWhpwelmOoRm29ESqlAoE6jfy8s5MSnqY9rIora5FeIIWaWSMCAEjTzjnDioiIqOs6HXJ2796N66+/HkFBQVAoFNi8eXOrbR9++GEoFAq8+eabFs8XFRUhLi4OWq0WXl5eWLRoEcrLLW/PHD16FDNmzIBGo0FISAhWr17d7PxffvklIiMjodFoEBUVha1bt3b27fS486bwEurjBpWT5eX2cW8cfHzONAZnzECdXOXJLOaWD0RERF3V6ZBTUVGBsWPH4p133mmz3TfffIP9+/cjKCio2bG4uDicOHEC8fHx2LJlC3bv3o2HHnpIPm4wGDB79myEhYUhOTkZa9aswXPPPYcNGzbIbfbt24eFCxdi0aJFOHz4MBYsWIAFCxbg+PHjnX1LPep8oRRyBvm5NztmHpdzrqBCnkoe7ueOUB83AEBGIUMOERFRV6k6+4J58+Zh3rx5bbbJysrCX//6V2zfvh3z58+3OHbq1Cls27YNBw8exMSJEwEAb7/9Nq699lq8+uqrCAoKwsaNG1FbW4t///vfcHFxwahRo5CSkoLXX39dDkNr167F3LlzsXTpUgDACy+8gPj4eKxbtw7r16/v7NvqMeZKziDf5iHHXMlJOl8EAAjUaeDmokKIjxuOXixFRhFDDhERUVdZfUyO0WjEPffcg6VLl2LUqFHNjickJMDLy0sOOAAQGxsLpVKJxMREuc3MmTPh4tI4G2nOnDlITU1FcXGx3CY2Ntbi3HPmzEFCQkKrfaupqYHBYLD46mmpedJtqEF+bs2OmdfN+f5IDgBgVJAOABDiLbXl5p1ERERdZ/WQ88orr0ClUuHxxx9v8Xhubi78/f0tnlOpVPDx8UFubq7cJiAgwKKN+XF7bczHW7Jy5UrodDr5KyQkpHNvrpPO5pdhT9olAMAVg32bHY/QewIAquoaAADThkpt5NtVrOQQERF1mVVDTnJyMtauXYsPP/wQCoXCmqe2iuXLl6O0tFT+yszM7LGfdTLbgCWfp0AIYPbIAAwP8GzWZnSwzuLxtKF+ABo378zmDuVERERd1ukxOW3Zs2cP8vPzERoaKj/X0NCAp556Cm+++SbOnz8PvV6P/Px8i9fV19ejqKgIer0eAKDX65GXl2fRxvy4vTbm4y1Rq9VQq9WtHreWoopaXPvWHvnx47OGtdhuVJBW/t7X3QXD/D0AAEGmqeYMOURERF1n1UrOPffcg6NHjyIlJUX+CgoKwtKlS7F9+3YAQExMDEpKSpCcnCy/bteuXTAajZgyZYrcZvfu3aira9y8Mj4+HhEREfD29pbb7Ny50+Lnx8fHIyYmxppvqUtOZjeO9blxXFCzio2Zp8YZkaZbVv9z7Qi5+hXoJVVyDNX1XCuHiIioizpdySkvL8fZs2flx+np6UhJSYGPjw9CQ0Ph62s59sTZ2Rl6vR4REREAgBEjRmDu3Ll48MEHsX79etTV1eGxxx7DnXfeKU83v+uuu/CPf/wDixYtwrJly3D8+HGsXbsWb7zxhnzexYsX48orr8Rrr72G+fPn47PPPkNSUpLFNHNbOWPaXDNmsC9eu21sm23fjRuP9IIKeRFAAPBQq+CpVqGsph45pdUYaqrwEBERUcd1upKTlJSE6OhoREdHAwCefPJJREdHY8WKFR0+x8aNGxEZGYlZs2bh2muvxfTp0y3CiU6nw44dO5Ceno4JEybgqaeewooVKyzW0pk6dSo2bdqEDRs2YOzYsfjqq6+wefNmjB49urNvyerMIWfSIO9mCwBebvAAD4uAYxboJd2yyinlLSsiIqKu6HQl56qrroJoul12O86fP9/sOR8fH2zatKnN140ZMwZ79uxps81tt92G2267rcN96S2pppAzrIXBxh2l17niTF45ckqqrdUtIiKifoV7V1mZEAJpprVxzFPEu0IefMxKDhERUZdYdXYVAUYBvHf3eKTmlrW4ynFHDTRNI88sYsghIiLqCoYcK3NSKjBj2ADMGDagW+cJMwWkC6a9r4iIiKhzeLvKToWbNvQ8z5BDRETUJQw5dirMV9raoaC8FmXVde20JiIiossx5NgpT40z/DykDTwvFHIPKyIios5iyLFjIaaNOjO5UScREVGnMeTYMT8PaZ+tospaG/eEiIio72HIsWPebs4AgJJKjskhIiLqLIYcO+btLo3JKapgJYeIiKizGHLsmLebFHKKebuKiIio0xhy7Jj5dlWxFSs5QgiU19Rb7XxERET2iiHHjjVWcqw3Jue1HWcw5rntSDpfZLVzEhER2SOGHDtmHpNjzdtV634+C6MA/uebY1Y7JxERkT1iyLFjciWnBwYec8YWERE5OoYcO2Yek2Oorkd9g7Hb56utbzxHWTXH5RARkWNjyLFjOldn+XtrjMvJM1TL31fVNXBPLCIicmgMOXZM5aSEr2lczqWymm6fL6ukyuJxwu+F3T4nERGRvWLIsXP+Wg0AIK+sup2W7csqtgw53x/N6fY5iYiI7BVDjp0L0Er7V+Ubuh9ysk2VnCED3AEAe9IudfucRERE9oohx84FeJoqOYbu367KLpVCztQhfgCA0qo6GI2i2+clIiKyRww5ds5cycmzQiUnq0Q6R4TeEwAgBGdZERGR42LIsXPymBwrVHKyiisBAOF+7tA4S3/0Bs6wIiIiB8WQY+cCTCEnv5sDj4UQyDZVcoK9XOXp6aVVDDlEROSYGHLsnLVuV5VU1qGqrgEAoNdpoNWYFxpkyCEiIsfEkGPnzJWcS2U1aOjGIGHzGjl+HmponJ2gNVVyDKzkEBGRg2LIsXO+7i5QKgCjAArLuz4u56JpPE6wtysAQKtRAQAMVRx4TEREjokhx86pnJTw8zDfsup6yMkskio5oT5uANBYyeHtKiIiclAMOX1AgDzDquvjcjKKpEpOiKmSo+PtKiIicnAMOX2APPi4GzOsMk23q0LMlRxN4w7nREREjoghpw+wxlo55kpO4+0qaUwOp5ATEZGjYsjpA8xbO3R1/yqjUeCiaXPOEO/LKjkMOURE5KAYcvqA7q6Vk1lcidp6I1xUSgR5SYGJA4+JiMjRqWzdAWpfQCdvVyX8Xoh1P6fB280Fa24di1M5BgDA8AAPqJykXNs48JhjcoiIyDEx5PQB/qZKTke3dnjxh5M4kS0FmzBfN6iUUrCJ1GvlNubbVRyTQ0REjoq3q/oAcyWnoLwWdQ3GNttmFFbKAQcA/vVbOg5lFAMAIk27jwONA495u4qIiBwVQ04f4OPmApVSAUDa3qEtPx7PAQBMHeKLUB83VNcZsSetAAAwMqh5JaeytqHd4ERERNQXMeT0AUqlAv6eHRt8vPV4LgBgXlQg5o3Wy887KRUYF+IlP/bUNN6pLONaOURE5IAYcvqIjqyVk11ShSOZJVAogDmjArAgOlg+ptWo4ObSGGxUTkp4qM37V/GWFREROR6GnD6iI9PIT5rG4ozQa+HvqcGIQC2CvaRtHGaP1Ddrb96kk4OPiYjIEXF2VR+hN1VyctsIOTmmY+adxgHgy4dj8PH+C3hwxuBm7bWuzsgurebgYyIickgMOX1EoKkik1NS1WqbvFIp5ATqNPJzQV6uWDY3ssX2jasec0wOERE5nk7frtq9ezeuv/56BAUFQaFQYPPmzfKxuro6LFu2DFFRUXB3d0dQUBDuvfdeZGdnW5yjqKgIcXFx0Gq18PLywqJFi1BeXm7R5ujRo5gxYwY0Gg1CQkKwevXqZn358ssvERkZCY1Gg6ioKGzdurWzb6fPMAeX7NI2KjmmY/omIactXPWYiIgcWadDTkVFBcaOHYt33nmn2bHKykocOnQIzz77LA4dOoSvv/4aqampuOGGGyzaxcXF4cSJE4iPj8eWLVuwe/duPPTQQ/Jxg8GA2bNnIywsDMnJyVizZg2ee+45bNiwQW6zb98+LFy4EIsWLcLhw4exYMECLFiwAMePH+/sW+oTgsyVnNLWKzm5BumY+dZWe7hJJxERObJO366aN28e5s2b1+IxnU6H+Ph4i+fWrVuHyZMnIyMjA6GhoTh16hS2bduGgwcPYuLEiQCAt99+G9deey1effVVBAUFYePGjaitrcW///1vuLi4YNSoUUhJScHrr78uh6G1a9di7ty5WLp0KQDghRdeQHx8PNatW4f169d39m3ZPXMlJ7e0GkajgNK0bk5Tna7kcJNOIiJyYD0+u6q0tBQKhQJeXl4AgISEBHh5eckBBwBiY2OhVCqRmJgot5k5cyZcXFzkNnPmzEFqaiqKi4vlNrGxsRY/a86cOUhISGi1LzU1NTAYDBZffUWAVgOFAqhrECioaD6NXAiBXHlMjmuz4y3h7SoiInJkPRpyqqursWzZMixcuBBarbTabm5uLvz9/S3aqVQq+Pj4IDc3V24TEBBg0cb8uL025uMtWblyJXQ6nfwVEhLSvTfYi5ydlPKCgDklzcflFFbUorK2AQqF5cDjtpinkHPgMREROaIeCzl1dXW4/fbbIYTAe++911M/plOWL1+O0tJS+SszM9PWXeoUc4WmpXE5Z/LKAAAh3m7QODt16Hw6VnKIiMiB9cgUcnPAuXDhAnbt2iVXcQBAr9cjPz/fon19fT2Kioqg1+vlNnl5eRZtzI/ba2M+3hK1Wg21Wt31N2ZjQV4apGQC2S1Ucs7kSiFneIBns2OtMd+u4sBjIiJyRFav5JgDTlpaGn766Sf4+vpaHI+JiUFJSQmSk5Pl53bt2gWj0YgpU6bIbXbv3o26usYP3/j4eERERMDb21tus3PnTotzx8fHIyYmxtpvyW60WcnJl6bgDw/w6PD5OPCYiIgcWadDTnl5OVJSUpCSkgIASE9PR0pKCjIyMlBXV4dbb70VSUlJ2LhxIxoaGpCbm4vc3FzU1tYCAEaMGIG5c+fiwQcfxIEDB7B371489thjuPPOOxEUFAQAuOuuu+Di4oJFixbhxIkT+Pzzz7F27Vo8+eSTcj8WL16Mbdu24bXXXsPp06fx3HPPISkpCY899pgVLot9amutnDTT7aoIfWcqOaYxOdygk4iIHFCnQ05SUhKio6MRHR0NAHjyyScRHR2NFStWICsrC9999x0uXryIcePGITAwUP7at2+ffI6NGzciMjISs2bNwrXXXovp06dbrIGj0+mwY8cOpKenY8KECXjqqaewYsUKi7V0pk6dik2bNmHDhg0YO3YsvvrqK2zevBmjR4/uzvWwa0FtrHp8vrASABDu597h87GSQ0REjqzTY3KuuuoqCCFaPd7WMTMfHx9s2rSpzTZjxozBnj172mxz22234bbbbmv35zkKcyUn57JKTlVtAy6VSdPKw3w6HnJ0blLIqak3orquocMDlomIiPoC7kLeh5grOXmGatQ1GOXnM4ulKo6nRiUHl47wcFFBYVpTkDOsiIjI0TDk9CEDPNTwUKtgFEB6QYX8fGaRFHJCfdw6dT6lUgFPNdfKISIix8SQ04colQp5YPGpnMbVmjO6GHIArnpMRESOiyGnj4k0hZzTpnVxAOC8qaoT0pWQw8HHRETkoBhy+pjIQGlhxaaVnAPnpf28RgfrOn0+HRcEJCIiB9UjKx5Tzxkf6gUA2H3mEs7ml8PbzVkOPFOH+LbxypZxrRwiInJUDDl9zKggHSaH++BAehFiX/8VQ/2lFY4j9Z7w8+j8lhW8XUVERI6Kt6v6oOeuHyV/fza/HAoF8MhVQ7p0Lg48JiIiR8WQ0weNDNJi86PT5MeLpoXjxnHBXTqXvBM5KzlERORgGHL6qLEDdZgxzA/BXq5druIAgFbDdXKIiMgxcUxOH6VQKPDxoikQQkBhXra4C3i7ioiIHBUrOX1cdwIOwIHHRETkuBhy+rnGSg5vVxERkWNhyOnnuBggERE5Koacfk5eDLCqDkIIG/eGiIjIehhy+jlzJafeKFBew1tWRETkOBhy+jk3FxU8TdPI8wzVNu4NERGR9TDkEAJ1GgBATilDDhEROQ6GHIJe5wqAIYeIiBwLQw4hUCtVcnIZcoiIyIEw5BD0vF1FREQOiCGH5DE5uaVVNu4JERGR9TDkEIK8pDE55wsrbdwTIiIi6+EGnYSxA72gUADpBRX47EAGDp4vxjWR/pg/JtDWXSMiIuoyhhyCzs0ZkXotTuUY8LevjwEAfjqVh2uj9N3eAJSIiMhWeLuKAABXDPaxeFxaVYeC8lob9YaIiKj7GHIIAPDo1UMxeZAPvN2c5ed+v1Ruwx4RERF1D0MOAQD8PNT44uEYHF4xG1dHDADAkENERH0bQw41M3iABwDg3KUKG/eEiIio6xhyqJkhppBzJq/Mxj0hIiLqOoYcaiYy0BMAcDqXIYeIiPouhhxqJiLAEwoFcKmsBgXlNbbuDhERUZcw5FAz7moVwnzcAACnc1jNISKivokhh1oUqdcC4LgcIiLquxhyqEXmnckv8XYVERH1UQw51CI/DxcAQBFXPSYioj6KIYda5OuhBgAUVrCSQ0REfRNDDrXI112q5HD/KiIi6qsYcqhFrOQQEVFfx5BDLTJXcgpZySEioj6KIYda5GsaeFxZ24Cq2gYb94aIiKjzGHKoRR5qFVxU0l8P3rIiIqK+iCGHWqRQKOBnumWVX8aQQ0REfU+nQ87u3btx/fXXIygoCAqFAps3b7Y4LoTAihUrEBgYCFdXV8TGxiItLc2iTVFREeLi4qDVauHl5YVFixahvLzcos3Ro0cxY8YMaDQahISEYPXq1c368uWXXyIyMhIajQZRUVHYunVrZ98OtWGgaWuHjMJKG/eEiIio8zodcioqKjB27Fi88847LR5fvXo13nrrLaxfvx6JiYlwd3fHnDlzUF1dLbeJi4vDiRMnEB8fjy1btmD37t146KGH5OMGgwGzZ89GWFgYkpOTsWbNGjz33HPYsGGD3Gbfvn1YuHAhFi1ahMOHD2PBggVYsGABjh8/3tm3RK0Y7OcOAEgvqLBxT4iIiLpAdAMA8c0338iPjUaj0Ov1Ys2aNfJzJSUlQq1Wi08//VQIIcTJkycFAHHw4EG5zY8//igUCoXIysoSQgjx7rvvCm9vb1FTUyO3WbZsmYiIiJAf33777WL+/PkW/ZkyZYr485//3OH+l5aWCgCitLS0w6/pT9b/claELdsi/rrpkK27QkREJOvo57dVx+Skp6cjNzcXsbGx8nM6nQ5TpkxBQkICACAhIQFeXl6YOHGi3CY2NhZKpRKJiYlym5kzZ8LFxUVuM2fOHKSmpqK4uFhu0/TnmNuYf05LampqYDAYLL6odeGs5BARUR9m1ZCTm5sLAAgICLB4PiAgQD6Wm5sLf39/i+MqlQo+Pj4WbVo6R9Of0Vob8/GWrFy5EjqdTv4KCQnp7FvsV5qGHCGEjXtDRETUOf1qdtXy5ctRWloqf2VmZtq6S3Yt1NcNCgVQXlPP3ciJiKjPsWrI0ev1AIC8vDyL5/Py8uRjer0e+fn5Fsfr6+tRVFRk0aalczT9Ga21MR9viVqthlartfii1qlVThjo7QoAOF/AGVZERNS3WDXkhIeHQ6/XY+fOnfJzBoMBiYmJiImJAQDExMSgpKQEycnJcptdu3bBaDRiypQpcpvdu3ejrq5ObhMfH4+IiAh4e3vLbZr+HHMb888h6wj38wAApBeUt9OSiIjIvnQ65JSXlyMlJQUpKSkApMHGKSkpyMjIgEKhwJIlS/Diiy/iu+++w7Fjx3DvvfciKCgICxYsAACMGDECc+fOxYMPPogDBw5g7969eOyxx3DnnXciKCgIAHDXXXfBxcUFixYtwokTJ/D5559j7dq1ePLJJ+V+LF68GNu2bcNrr72G06dP47nnnkNSUhIee+yx7l8VkoX7SmvlnOPgYyIi6ms6O23r559/FgCafd13331CCGka+bPPPisCAgKEWq0Ws2bNEqmpqRbnKCwsFAsXLhQeHh5Cq9WK+++/X5SVlVm0OXLkiJg+fbpQq9UiODhYrFq1qllfvvjiCzF8+HDh4uIiRo0aJX744YdOvRdOIW/ff347J8KWbRGLPjxg664QEREJITr++a0Qov9OmzEYDNDpdCgtLeX4nFYcySzBje/shUqpQPyTV8ozroiIiGylo5/f/Wp2FXXe2BAvXB0xAPVGgU/2X7B1d4iIiDqMIYfaddP4gQCA/yacx7pdaTicUWzjHhEREbWPIYfaNXmQDwCgrkHg1R1nsOijJFTW1tu4V0RERG1jyKF26XUaaDUq+XFRRS027s+wYY+IiIjax5BDHfLGHeOwcHIo/ufaSADAP3efQ1Vtg417RURE1DqGHOqQWSMCsPLmKNw/LRzBXq4oKK/BtylZtu4WERFRqxhyqFOcnZSIuyIUAPD90Wwb94aIiKh1DDnUadePkVamTvi9EEUVtTbuDRERUcsYcqjTQnzcMNjPHUYBnMw22Lo7RERELWLIoS6J0HsCAE7nMuQQEZF9YsihLhkeIIWc1NwyG/eEiIioZQw51CWRpkrOmTyGHCIisk8MOdQljberylDfYLRxb4iIiJpjyKEuGeTrDk+1CjX1RqTll9u6O0RERM0w5FCXKJUKjA7WAQCOXiyxbWeIiIhawJBDXTZmoBRyjlwstXFPiIiImmPIoS6LDvUGAOw/V2jjnhARETXHkENdFjPEF0oFcO5SBbJLqmzdHSIiIgsMOdRlOldnjBnoBQD4La3Atp0hIiK6DEMOdcvMYX4AgD1nGXKIiMi+MORQt0wfNgAA8P2RbLy6PdXGvSEiImrEkEPdEh3qBXcXJwDAup/PIul8kY17REREJGHIoW5xdlLi79eNlB9v2H0Op3MNKKmstWGviIiIAIUQQti6E7ZiMBig0+lQWloKrVZr6+70aUcvluCGdXvlxxpnJdbfPQFXRfjbsFdEROSIOvr5zUoOWcXIQMu/ZNV1Rvzt/46hwdhvMzQREdkYQw5ZhcpJCY1z418nnaszcg3V2MtZV0REZCMMOWQ1b94RDR93F/z3gcm4cVwQAOC1HancpZyIiGxCZesOkOOYO1qPuaP1AIDhAZ7YfDgLRy6WYtfpfMwepbdx74iIqL9hJYd6hF6nwawRAQCAs5fKbdwbIiLqjxhyqMeE+rgBADIKK23cEyIi6o8YcqjHmEPOBYYcIiKyAYYc6jFhvqZKThFDDhER9T6GHOoxoaaQk1Nahdp6zrAiIqLexZBDPWaAhxpajQpGAZzONdi6O0RE1M8w5FCPUSgUmBzuAwDYf67Qxr0hIqL+hiGHetQVg30BAAm/M+QQEVHvYsihHmUOOQfPF3PlYyIi6lUMOdSjRgRqodWoUF5Tj+PZHJdDRES9hyGHepSTUoEpvGVFREQ2wJBDPW6KafBxSmaxjXtCRET9CUMO9bgIvScAIC2Pe1gREVHvYcihHjc8QAo55wsrUFPfYOPeEBFRf2H1kNPQ0IBnn30W4eHhcHV1xZAhQ/DCCy9ACCG3EUJgxYoVCAwMhKurK2JjY5GWlmZxnqKiIsTFxUGr1cLLywuLFi1CebllJeDo0aOYMWMGNBoNQkJCsHr1amu/HbICf081PE2LAp67VGHr7hARUT9h9ZDzyiuv4L333sO6detw6tQpvPLKK1i9ejXefvttuc3q1avx1ltvYf369UhMTIS7uzvmzJmD6upquU1cXBxOnDiB+Ph4bNmyBbt378ZDDz0kHzcYDJg9ezbCwsKQnJyMNWvW4LnnnsOGDRus/ZaomxQKhVzN+SX1ko17Q0RE/Yawsvnz54sHHnjA4rmbb75ZxMXFCSGEMBqNQq/XizVr1sjHS0pKhFqtFp9++qkQQoiTJ08KAOLgwYNymx9//FEoFAqRlZUlhBDi3XffFd7e3qKmpkZus2zZMhEREdHhvpaWlgoAorS0tPNvlDrlw73pImzZFhH+ty1i4/4Ltu4OERH1YR39/LZ6JWfq1KnYuXMnzpw5AwA4cuQIfvvtN8ybNw8AkJ6ejtzcXMTGxsqv0el0mDJlChISEgAACQkJ8PLywsSJE+U2sbGxUCqVSExMlNvMnDkTLi4ucps5c+YgNTUVxcUtz+KpqamBwWCw+KLecW9MGG4ZPxBGAbyy7bTF7UsiIqKeYPWQ87e//Q133nknIiMj4ezsjOjoaCxZsgRxcXEAgNzcXABAQECAxesCAgLkY7m5ufD397c4rlKp4OPjY9GmpXM0/RmXW7lyJXQ6nfwVEhLSzXdLHaVQKPDSTaMBAKVVdSitqrNxj4iIyNFZPeR88cUX2LhxIzZt2oRDhw7ho48+wquvvoqPPvrI2j+q05YvX47S0lL5KzMz09Zd6lc0zk7w91QDADKKKm3cGyIicnQqa59w6dKlcjUHAKKionDhwgWsXLkS9913H/R6PQAgLy8PgYGB8uvy8vIwbtw4AIBer0d+fr7Feevr61FUVCS/Xq/XIy8vz6KN+bG5zeXUajXUanX33yR1WaiPG/LLapBRVIkxA71s3R0iInJgVq/kVFZWQqm0PK2TkxOMRmlzxvDwcOj1euzcuVM+bjAYkJiYiJiYGABATEwMSkpKkJycLLfZtWsXjEYjpkyZIrfZvXs36uoab3vEx8cjIiIC3t7e1n5bZCWhPm4AWMkhIqKeZ/WQc/311+Oll17CDz/8gPPnz+Obb77B66+/jptuugmANDZjyZIlePHFF/Hdd9/h2LFjuPfeexEUFIQFCxYAAEaMGIG5c+fiwQcfxIEDB7B371489thjuPPOOxEUFAQAuOuuu+Di4oJFixbhxIkT+Pzzz7F27Vo8+eST1n5LZEUhppDzVfJFLgxIREQ9y9rTugwGg1i8eLEIDQ0VGo1GDB48WDzzzDMWU72NRqN49tlnRUBAgFCr1WLWrFkiNTXV4jyFhYVi4cKFwsPDQ2i1WnH//feLsrIyizZHjhwR06dPF2q1WgQHB4tVq1Z1qq+cQt779v9eIMKWbRFhy7aIl7eetHV3iIioD+ro57dCiP47l9dgMECn06G0tBRardbW3ek3Pj2QgeVfH4NapcTev10DPw+OkyIioo7r6Oc3966iXnfnpBBE6j1RU29Ewu+Ftu4OERE5KIYc6nUKhQKTw30AAIcyWl64kYiIqLsYcsgmJoRJM+AOXWDIISKinsGQQzYxcZBUyTlysRQ7T+W105qIiKjzGHLIJoK9XHH/tEEAgNXbUrmXFRERWR1DDtnMktjhcFEpkZpXhhPZ3CyViIisiyGHbEbn6ozZI6VNVd/79Xf5+QuFFUjJLMGa7aeRdL7IVt0japfRKJBdUoUGIyuRRPaI6+RwnRybOpVjwPy39sAogNHBWsRNCcMLW06isrZxNeQfF8/AiED++ZB9MRoFblm/D4czSnDD2CC8tTDa1l0i6je4Tg71CSMCtbhjUggA4HiWAcu/PmYRcADgt7QCW3SNqE2/nMnH4YwSAMCu0/kwsppDZHcYcsjmnvxDRJurHp/K5Xgdsj/fpmTL35fX1OMCN50lsjsMOWRzAzzV+GXpVfh40WRMCPPGsrmRcFIq5OOpuWU27B1Ryy4UWoaaY1mlNuoJEbVGZesOEAGAh1qFGcMGYMawAQCA+VGBqKitx7y1e5CWV46q2ga4ujjZuJdEjbJKqgAAYwbqcPRiKVJzDcDYIBv3ioiaYiWH7FKorxsiAjwR7OWK2gYj3vjpjK27RCSrrmvApbIaAMDUIX4AgMyiKlt2iYhawJBDdkupVOCFBaMAABt2n8NN7+7FpwcycO5SuY17Rv1dbmk1AEDjrMTYgToAQGYxx+QQ2RuGHLJr10QG4OboYADA4YwSLP/6GB755JCNe0X9nflWVbCXK0J83ACwkkNkjxhyyO69fHMUFk0Plx+n5pWhpLLWhj2i/i6r2BRyvN0Q4i2FnILyGlRdtvwBEdkWQw7ZPY2zE569biT+88dJ8nNHL3ImC9nOxSaVHJ2bMzw10hyOrBLesiKyJww51GdcHemPG0yzV45klti2M9SvmSs5A71dAUjLIADApTJWGInsCUMO9SnjQrwAAAcvFNu2I9SvmSs2wV5SyPFzl0JOUQVDDpE9YcihPmXaUGm67oH0QtTUc/wD2YY88NhUyfFxdwEAFFXU2KxPRNQcQw71KcMDPODnoUZ1nREf7j2Pfry/LNlIg1Egp0SaQm6u5Ph4SCGnkJUcIrvCkEN9ikKhwC3jpSnlK388jb9sPIT6BqONe0X9SX5ZNeqNAk5KBQK0GgCAr1zJYcghsicMOdTnLJsbib/PHwEXlRI/Hs/F2p1ptu4S9SPmQcd6rUbeY818u6qwnCGHyJ4w5FCfo1Qq8KcZg/HKLVEAgI2JGaitZzWHesfl43GAJiGHY3KI7ApDDvVZ148Jgr+nGkUVtfjxeI6tu0P9xEXz9HGvxpDjy9lVRHaJIYf6LJWTEndfEQYAeGtnGipq6lFWXWfjXpGja6uSw5BDZF8YcqhP++O0QfByc8bvlyow6n+3Y8w/diDpfJGtu0UOzFzJCW5ayTHNriqurIPRyBl/RPaCIYf6NK3GGf+8ewJ0rs4AACGA+JN5Nu4Vtaeipr7Pzoo7X1ABABjk5y4/5+0mhZwGo0BpFauJRPaCIYf6vCmDfbF/+Sw8ctUQAMCxLO5rZc/KquswddUu3PzePlt3pdNq6htwsVha7Xhwk5DjolLK+1dxrRwi+8GQQw7B1cUJ140JBADs+70QW49xILK9OpZVitKqOhy9WIrK2npbd6dTMgorYRSAh1ol71dlxrVyiOwPQw45jOEBnnB2ktYteXTTIQ5CtlNqVeOvnd/zK2zYk847Z7pVFe7nDoVCYXGMWzsQ2R+GHHIYzk5KvHlHNABpbE7UczuQW1pt417R5apqG8fipOWX2bAnnWcedBzq49bsmI9pGjlvVxHZD4YccijzxwTimWtHyI83Jl6wYW+oJU1vUaXll9uwJ51XUC5VaS6/VQU0uV3FVY+J7AZDDjmc+6cNwoxh0m7lb+86izd/OiOvbUK2V1XXuHt8Th/7cykoaz3kcJNOIvvDkEMOR+WkxGu3jZUfv/lTGhZ/eljesfyDPefwzDfHUNdHpzD3dVW1jSGnuq5v/RlcMlVy/EyBpimtRlrGoKy6bw2mJnJkDDnkkPy1GsRNCZUXbEu6UIx/fH8Sx7NK8eIPp7AxMQObD2fZuJf9U9NKTk19Qxst7U+BHHKaV3K0rtIUcgMHvBPZDYYcclgv3RSFvX+7Bn++cjAA4MN953Hd27/JxzcmZtiqa/1aZR+u5BSUSbeiWrpdZa7kGLgYIJHdYMghh7dk1nAM8/do9nxKZgkOZxTboEf9W3WTSk51L1VyGowCO07korC869O7hRDyLuMtVXLMq24beLuKyG4w5JDDc3Vxwvd/nY7Vt46Rn/N2kz6QHv4kGduO58rjdajnNa3k1PRSJWfVj6fw0MfJePbb410+R0llHeoapL8nvi2NyXFlJYfI3qhs3QGi3qBxdsLtE0MwbagfqmrrUW8UmPvmHuQZavDwJ8n4y1VDcPcVYQhqsuki9YyqXq7kFFXU4v096QCArcdyUVtvhIuq8/+/O3tJmu4e7OUKtcqp2XGthmNyiOwNKznUrwR7uWKovyci9VrcOSlEfv7dX37H1FW78HHCedt1rp+o6uVKzuW3JJMvdO0W5ekcAwAgUu/Z4nFzJaesuh4N3ImcyC4w5FC/9fJNUTjwzCy4Ojf+r/zZb09g39kC3r7qQRYhpxcqOUcySyweJ50v6tJ5TuVKqzNHtBJyzBt0AkA5x+UQ2QWGHOq3lEoF/D01uGVCsMXzd32QiJd+OGWjXjk+iynkvVDJSbko7Uo/eIC0a/iRiyVdOk9qOyFHrXKCxln6lcpbVkT2oUdCTlZWFu6++274+vrC1dUVUVFRSEpKko8LIbBixQoEBgbC1dUVsbGxSEtLszhHUVER4uLioNVq4eXlhUWLFqG83HIJ+KNHj2LGjBnQaDQICQnB6tWre+LtkINbNjcSj109FO/GjZef+9fedJzILrVhrxyXxWKAvVDJSS+Qfm/cPlG6PXnkYmmXKnUXCqXNOYcMaD5Tz8w8jbyUg4+J7ILVQ05xcTGmTZsGZ2dn/Pjjjzh58iRee+01eHt7y21Wr16Nt956C+vXr0diYiLc3d0xZ84cVFc3bqYYFxeHEydOID4+Hlu2bMHu3bvx0EMPyccNBgNmz56NsLAwJCcnY82aNXjuueewYcMGa78lcnCeGmf8vzkRuDYqEL8tuxpTh/hCCODLpIu27ppDalrJqWsQPTp+pcEokFMi/V6ZPTIAzk4KXCqrwaFOLh1QXlOPAtOeVKG+zTfnNJNnWLGSQ2QXrB5yXnnlFYSEhOA///kPJk+ejPDwcMyePRtDhgwBIFVx3nzzTfz973/HjTfeiDFjxuC///0vsrOzsXnzZgDAqVOnsG3bNnzwwQeYMmUKpk+fjrfffhufffYZsrOzAQAbN25EbW0t/v3vf2PUqFG488478fjjj+P111+39luifmSgtxsWTQ8HIC0emHiusNPnKCyvwfKvj2Lf2QJrd88hNN2gE+jZcTn5ZdWoNwqolAqE+brj5uiBAID1v57r1HkyCisBSEsPmKs1LZFnWFVxTA6RPbB6yPnuu+8wceJE3HbbbfD390d0dDTef/99+Xh6ejpyc3MRGxsrP6fT6TBlyhQkJCQAABISEuDl5YWJEyfKbWJjY6FUKpGYmCi3mTlzJlxcGtermDNnDlJTU1Fc3PL/0mpqamAwGCy+iC43Y9gAeR2dxz87DGMHKw3JF4rw6MZDWPJ5Cj49kIm7PkjEgfSuDXJ1ZJevctyTqx5nFUsbgOp1GjgpFbj7ijAAwP5zhR3+cwWAjCLpVlWor3ub7VjJIbIvVg85586dw3vvvYdhw4Zh+/bteOSRR/D444/jo48+AgDk5uYCAAICAixeFxAQIB/Lzc2Fv7+/xXGVSgUfHx+LNi2do+nPuNzKlSuh0+nkr5CQkBbbUf/molLiq0emAgDyDDX46VQe7v4gEet2paG+wYi3dqa1OEPnmW+O44djOdiT1ljBWfXjKc7UuszllZuerOSYd583r380ItATGmclyqrrca6gvK2XWkgvkCo5YT6t36oCuLUDkb2xesgxGo0YP348Xn75ZURHR+Ohhx7Cgw8+iPXr11v7R3Xa8uXLUVpaKn9lZmbauktkp4YM8MCN44IAAA99nIzfzhbg1R1ncPN7+/B6/Bncuj7Bov2FwgqcNs2+AYARgVqoVUocyijBr2cu9Wrf7V2vVnJMIWegKeSonJQYM9ALAHAoo6TD5zmdK1V9W5tZZda4SSdvVxHZA6uHnMDAQIwcOdLiuREjRiAjQ9oMUa/XAwDy8vIs2uTl5cnH9Ho98vPzLY7X19ejqKjIok1L52j6My6nVquh1Wotvoha88epg+CkVFg8d/Ri44yrh/6bhFve24cdJ3LlzT5HB2vx3WPT8P1j03BvjHRr5B/fn0R+WTWsKel8Ea5c8zN+OpnXfmM706uVHNPtqmDvxpWso0O9AACHOxFyTmZLIWdkYNu/M1jJIbIvVg8506ZNQ2pqqsVzZ86cQViY9As/PDwcer0eO3fulI8bDAYkJiYiJiYGABATE4OSkhIkJyfLbXbt2gWj0YgpU6bIbXbv3o26usZfJvHx8YiIiLCYyUXUVdGh3nj99rGIHRGA9++diKsjBlgc33EyD8kXivHQx8nYsFsayPrkH4ZjzEAvqJyUePjKIQjQqpFeUIGnvzpq1b49++0JXCisxJ/+m4T6hr6zk3eDUcj7P7m7SIsw9kYlJ7jJdh3RIdLvh45uzlpd14DfTVs6jAxqJ+Rw/yoiu2L1kPPEE09g//79ePnll3H27Fls2rQJGzZswKOPPgoAUCgUWLJkCV588UV89913OHbsGO69914EBQVhwYIFAKTKz9y5c/Hggw/iwIED2Lt3Lx577DHceeedCAqSbiHcddddcHFxwaJFi3DixAl8/vnnWLt2LZ588klrvyXqx24cF4wP7puIP4wMwJt3RGN0cOsfclOH+OKq4Y1jyXw91Phk0RSolAr8knqpSzO1WtJgFPKHLgB8vP+CVc7bG5pWbcy7djfdldzaWqrkjDdVcs7klaGsAwOEf79UDqMAvNyc4e/ZfPfxpnQceExkV6weciZNmoRvvvkGn376KUaPHo0XXngBb775JuLi4uQ2Tz/9NP7617/ioYcewqRJk1BeXo5t27ZBo9HIbTZu3IjIyEjMmjUL1157LaZPn26xBo5Op8OOHTuQnp6OCRMm4KmnnsKKFSss1tIhsiadmzO+f2w6Hpo5GADg5uKElBV/wI+LZ2DTg1Pw8aIpUF52e2tYgCduGS9NW/7CSuvunMguRW19Y/Xj+S0n8dG+81Y5d09rWrUxVz1q6numkiOEaLGS46/VYLCfO4wC2Hw4q93zZJvW2QnxdoNCoWizbePtKo7JIbIHPbIL+XXXXYfrrruu1eMKhQLPP/88nn/++Vbb+Pj4YNOmTW3+nDFjxmDPnj1d7idRZykUCjx85RAEe7li/phAeLm5wMvNpc3X3DguCJ8nZeL/Dl1EbYMRby+M7lYfzOOCZgzzg7+nBv936CJW/ngK80br4a/VtPPq9tU3GKFUKJoFNmswV3KcnRRwk29X9Uwlp6SyDpWm1ZUv313+j9MGYcW3J/Cv39Jx9xVhbYaXbHmGVvvXtnHgMSs5RPaAe1cRdZKPuwvumzoIfh5t37owmxzug3A/aX2V749kI/lC99bOOWEaBDs6WIdXbxuD8aFeqK4z4gUr7LdVU9+AWa//ijs2JLTfuAvMlRxpnycn08/smUpORpE07dvPQy3/LLNbxg+Eq7MTzhdW4vBlG3heLvuyaeht4cBjIvvCkEPUw1ROSmxfMhNzRknrOD27+YTF7abOOmnaU2tUkBYKhQLP3TAKTkoFvj+SjW3HW14jqj05pVVIL6jAyWwDLhRW4uD5Yry+IxVj/7EDT36R0uW+Xs5cydE4K6FWSb9+eqqSk5onTekfHtB8ryl3tUr+89hyJKfN82SXSrergjsScky34EoYcojsAkMOUS9wUSnx4oIoeLk542SOAf/vyyOdWnHXrLSyDqdypA/v0UE6AMCYgV7yOKF/fH+i07Otks4XYdZrv+LatXtwJq9xrZ+3dp1FaVUdvj6UJe/A3V29Wck5ndP2ruFzR0tLTew63fY0/KxiqSLUkUqOeaXsytqGbgVZIrIOhhyiXjLAU4037xgHlVKB745k4/ktJzt9js0pWahtMGJEoBZhTTaKXDxrGHzdXZBTWo1Xd5zp8CrLheU1ePiTQ6isbUBVXQM+O9jyApn/d8g6g6ZrTFUbdZNKTk2PVXKk23oj9C3PiJs+bACcnRQ4X1iJc5daXv34RHapfDurpYrQ5Tw1zjAP7+FO5ES2x5BD1IuuivDHG3eMg0IhbQA66G8/4OmvjnT49TtPS4tk3jphoMVgWY2zE26ZYN588nd8f7TtWzBmXx/KQkF5jfy4tQXyTuVYZ5+36vrmlZweu12V23Ylx0OtQnSotGZO0vmW18z5NiUbQgDzRusx1L/t1Y4BwEmpkMfllFbVdqXbRGRFDDlEvez6sUFYPGuY/PiLpIsoqujYB+Lv+VLFYcxAXbNj5llfAPBNBysvx7Kk8T3Thvq2eHxCmBQCzuZ3fJ+ntpirNhpnZY/errpUVoOC8looFMDwgNbDyXhTyDmc2XLIyTGNxzFfh47wMt2yKqlkJYfI1hhyiGzgkauGYLBf447WD3x4sN2F6arrGpBdKs30afpaMx93F3z0wGQAwJ60AnlWUFtOmAYxPzhjMFbdHGVxTKkAHpwRDkD6sLfGtOjGSk7PDjw2V3EG+brD1cWp1XbtbfGQZ5BCTkAnpuZ7uTLkENkLhhwiG1CrnPDFwzHy1PKUzBK8vLXtKeDpBRUQAtBqVPBxb3ltnqH+HpgS7oN6o8Ar2063eb7K2nqcK6gAAIwK0uHOyaF4L2487o0Jw96/XYMDz8Ri7uhABGilqfLWqOY0VnKcoO7BSo68oWYbVRwAiA7xAiCtflxe03wBv3xTyGlvpeOmdKZ1kzjDisj2GHKIbMTPQ40/Th0kP/70QCbu+VeixQynpszPDx7g0ebidc9eJ22Qu/VYDkoqW78NdiavHEJI/Rhg+hCfFxWI528cjWAvV3kdoGGmsShn87ofcnqrkpNiGiw8op0NNf21GgR7ucIogKMXSyyOCSGQXyaNV+paJYdjcohsjSGHyIZunxiCv1w1BCE+0liaPWkFWL0ttVm7qtoGvLpDen6cqfrQmtHBOowI1KKuQWDrsdbXzTFXZob5tz1raKjpeFp+96eRN63k9MSYnB+O5uCGdb9hi2ng9dRWxho1Na6VW1blNfXyisn+2o5Xcsxjcji7isj2GHKIbMjVxQlPz43ER/dPlp/76VQe3v3lLE7lGOS1dL45nIXMoioE6TR4InZ4u+edZ1oDZn8bm4LKIaedqdHmgbtnrFDJqemhSk5dgxF/2ZiMRzcdkre9cHdxajcQAsCYYGkQ9+UzyMxVHE+1Cm4uHd8Bx1zJKWYlh8jmemTvKiLqnMEDPHBkxWyMfX4HAGD1tlSs3paKBeOCcCC9SF51d9GMwdCZKgVtGWv6cD9uGljckrOmyszQdio55hBk7TE51qrkHDxfhK+SLjarWt19RRicndr/f9xAb2m9IfNMKrPzpvFKgR3Ys6qpAaZbW3mGmnZaElFPY8ghshM6N2fcFB2Mb5rsjL05JVv+3tfdBbdNHNihc40KksaipBdUoLymHh7q5v/UT5tmIA0d0M7tKtPxrJIqVNU2tDlbqT1NKzka5+5Xci4UVuC29Zb7bE0b6ouHrxyC6UP9OnQOc4jJvSzkmMf1jBno1ak+Bemk8+WUtj+7jYh6FkMOkR156abR+POVgzHYzwMxK3ei0LR+zqggLZ6/cZS80Fx7/DzUCNRpkFNajVM5Bkwa5GNxPLukCheLq6BUAGPauaXj5eYMD7UK5TX1yCqp7NCieK0xBxq1yglqlXkxwK5XchJ+b7wdNyXcBx89MBlqlbLNgdmXC9SZKy/VaDAKOJl2XzeP0TFPM+/4+aTxVTkl1e20JKKexpBDZEfcXFSING1D8NrtY7H7TAGW/GFYh8NNU6OCdMgprcbxrNJmIedAurQT+uhgXYtVnqYUCgUGervidG4ZMouruhVyzAN5XV2c5EpOd25XJV2QFvEbPMAd//rjpGa7jXfEAA81lAqg3ihQWF4Df60GDUYhV3KiQzq+ECAABJkqQ4UVtaiua+hSn4jIOjjwmMhOXRXhjxXXj+xSwAGA0cFSWDqe1XxLhqQLUsiZfFn4aY153MrFosou9cWs0lTJcXNprOR0dO+q9b/+jnHP78Bjmw5BCAEhhBzWnp0/st2w1hqVkxL+nuZbTFL15fdL5SivqYebi1OH9qxqSufqDFdTsLl8nA8R9S6GHCIHNcq0S/mJFgYfn8mVBhGPCm57HRkz8xT3i8XdG2dSVdsYcjpTyalrMOLdn8+ipLIOW47mILOoCr9fKkdGUSVcnJSYHN6xsNYac/Xld9NGnYczpArRmIE6qDoweLkphUIhj/PpyKrTRNRzGHKIHFSUaWp0Wn65xSacQgicMc2sGtbBW0/mSk5Gdys5tdKqwq4uqiZjctqv5CSeK4KhunFF4kMZxfjRNJvqiiG+cO9iFccsZoi0ns6OE3kAmo7H6dytKjPzthvW2vOLiLqGIYfIQel1GowN8UKDUWBzkxlbl8prUFJZB6Wi/enjZtb60JYrOc6dq+RsP2E5PXzL0Wxs2HMOAHDj2KBu9QkA5kdJ5/g5NR819Q2NIacD6+y0xDyuyjyDjYhsgyGHyIHdNkGacv5tk6no5ltVoT5uHR4Ua94e4VxBRbemfFda3K7qWCXHaBTYcVIKOXdNCQUA/HQqH2XV9RgdrMWC6OAu98dsRKAnvN2cUVNvRPKFYrnSNa6TM6vMIvRShcy8hxYR2QZDDpEDmzNKD4UCOJZVKq8Dk5guTbvuzPovAVo1vNyc0WAU3armNJ1dZV7xuN4oUN/QejUn5WIJ8gw18FCrsOK6kZg0SLqFNMjXDf+8Z6I85bs7FAoFokzX47/7LkAIYKC3qzwgubMiTSHnTG4ZhBDd7h8RdQ1DDpEDG+CpxnjTuJL4U9J4k9/OFgBAhxfLA6QQEClXJ7p+C6ZKnl2lsqgiVbVRzTHfqroqYgA0zk749x8nYcM9E7BtyUwEe7l2uS+XM2/vsM3086YN6fj1uVyIjzSGqaK2ASWV3MOKyFYYcogcXOyIAADATyfzcPRiCY6Y1n/pyOaVTYX7SeN3LhZ3ffCxeeCxm6mS42KauVTWZFDx5XadygcgVaUAwFPjjNmj9FZff+aKwZbXY16Uvsvn0jg7yTu7Z3GGFZHNMOQQObg/jJRCzq9nLuGGdXthFMB1YwLlGVMdpde2vP1BRxmNQl7d2NXFCQqFAlpXaVaUobrlakd1XYM8rXtKN6eJt2faUF+MHShVc0YFaTG1G5UcAAgyVZkYcohshyseEzm4IQPcER3qJc8YAoAV14/s9HnM2x/kGroWcpreknIz7X+l1TijoLwWhqqWKzln88thFNLWEubKSE9RKBT44L5J+Pl0Pq4dEwgXVff+DxjspcGRTK6V01VpeWVoEEKeqUbUFazkEDk4hUKBD/84GTeOk6ZJ/+WqIV0aUBug614lxzzoGAA0pjVyPF2l1ZwNVS1XctJMs5yG+3t2aj+qrhrgqcbtk0K6vHpyU0GmPaz+8f1J5Jdx5ePOqK034g9v7MbcN/fItziJuoIhh6gf0Lk5Y+2d0di/fBaWzono0jkCdZZbH3SWeY0cV2cnKE0zorSatm9Xnc4xhRx957ZWsAdN1yC6/z8HYTRyllVHlVTWyt8Xc+A2dQNDDlE/otdpulwR0ZtCTmlVnRxYOqOyrnHQsZm2jUqOEEKeWTUxrGfH4/SEm8YHy4HyRLYBKRdLbNuhPqRpsKmoYSWHuo4hh4g6xFOtgrspoHRlMG3TNXLMzJuPGlqYXXUi24DzhZXQOCvlwdN9iVrlhEevHorrTSsyL/rwIIoqatt5FQGwuE5lrVT5iDqCIYeIOkShUCDMV9re4XxBRadf3/R2lZk8u6qFSs6xLGlj0UmDfLq9N5Ut3RQthZziyjp802R7DWrZf/amY8W3x+XHrQ1KJ+qIvvubg4h63eAB7jiZY8C5gnIAnauulJtuOzQNLI2VnOYhJy1PmjoeEdCxTUTt1TWRAbh+bBC+P5KN41nNd4QnycofT+GDPelouGzsUmvjtYg6gpUcIuow80ad5y51vpJTahpn4e3mLD/XOCan+f/WzTOrhgX0vUHHlzNXc44x5LToZLYB//z1XLOAA7S9UCRRexhyiKjDBg+QAkdX9q8qqZLGWXi5ucjPmWdXmY81Za7kDPXv25UcABgdJC0yeDa/HNuO59i4N/bnA9OO8i1hJYe6gyGHiDpsdLC0MFvShWLsSbvUqdea93DSuTZWcsxjfNLyyi02srxUVoNcQzUUCseo5PhrNbg6YgAA4O1dZ23cG/uSXVKF745kAwBW3zrGYvYdwEoOdQ9DDhF12FB/T9w5KQQAsPlwdqdeW2IaXOzV5HZVpN4TKqUChRW1yG6y/s6hjGIAwDB/D3ncTl+34vpRAKRqTku3ZfqrD/ako94ocMVgH9w+MQSHV/wB10T6y8c5u4q6gyGHiDpl+jBpT6fzhZ0bl1Na1bySo3F2wnDTwOJjTdaRMYecCWHe3emqXQn1cYPGWYmaeiMyirq+yakjKaqoxacHMgAAj1w1FIA09f7ff5wkrzHE2VXUHQw5RNQp4abBx+mdnEZuHnjctJIDAGNMm2Ievdg4KPdopvR9dIjjhBwnpUJeBTk1t8zGvbE9IQTWbD+NqroGjArSYuYwyw1Rg7ykxSf3ni2QAzJRZzHkEFGnDDKNoymqqJWDS0fIA49dXSyejzKFHPPMIyEETucaAAAjgxxrc8aIAOn9nMwx2Lgntvf90Rx8eiATCgWwbG5ks5W4/zBSj0CdBoUVtdhhWvmaqLMYcoioU9zVKgRopR3BpfVyOkYeeHx5JSfYCwBw8HwRhBDIL6tBcWUdlArL/Z8cwdgQKdClZJbYtiM2JoTA6m2nAQCPXzMMM4cPaNbGQ62Sx+ZcKOTtPeoahhwi6rRRpinRv6UVdPg18u0qV8uQE6H3hIuTEtV1Rtywbi+mvLwTgDRdXePs1Ow8fdm4EC8AwJHMEovZZP1Jg1Hgzg37cbG4Ci4qJR6+ckirbcN83QAAFziGibqIIYeIOm3uKD0A4IdjHVvzpay6DmWmFY99PdQWx6QPusEALBfLmzrE1xpdtSuRei00zkqUVtUh6UKxrbvTo/b9XoDHPz2MLUezUVpZh/iTeTibX46E3wuRmF4EAJg5zM9iL7PLhfpIt0YzOjnInciM2zoQUaf9YWQAFF8Dp3PLcKmsBgM81W22P2Na2C9Aq7aYXWX25OwIeLm54PktJxGp98TiWcNwdZNpxI7CRaXEgnHB+OxgJv79WzomDep7u6t31Mqtp3Esq1ReA6clf7l6aJvnCPVprOQIIZqN2yFqT49XclatWgWFQoElS5bIz1VXV+PRRx+Fr68vPDw8cMsttyAvL8/idRkZGZg/fz7c3Nzg7++PpUuXor7ecirhL7/8gvHjx0OtVmPo0KH48MMPe/rtEBEAb3cXDDetRJzcgYpEWp40m2h4G/tQPTA9HAeficXWx2dgXlSgw92qMrt1wkAAjjsup67BiLs/SGx3C4t1d0VjfGjbs+cG+bnBRaVESaXjV76oZ/RoyDl48CD++c9/YsyYMRbPP/HEE/j+++/x5Zdf4tdff0V2djZuvvlm+XhDQwPmz5+P2tpa7Nu3Dx999BE+/PBDrFixQm6Tnp6O+fPn4+qrr0ZKSgqWLFmCP/3pT9i+fXtPviUiMpkwSPqASr5Q1G7bVFPIidS3vUXDAE81lErH/t+6eWuMnNJqVNc12Lg31vdxwgX8drZxrNZ7ceOx44mZOP3CXNwUHYxgL1f8aXo45phuebbFzUWFm6ODAQDPfXfCIa8X9aweCznl5eWIi4vD+++/D2/vxrReWlqKf/3rX3j99ddxzTXXYMKECfjPf/6Dffv2Yf/+/QCAHTt24OTJk/jkk08wbtw4zJs3Dy+88ALeeecd1NZK01DXr1+P8PBwvPbaaxgxYgQee+wx3HrrrXjjjTd66i0RURNTwqVbLd8czpZ3GG+NefftCL1jTQnvCm83Z3ia9uxytFlDFwor8OqOVPnxwskhmBcViOEBntA4O+GNO8Zh79+uwd+vGwlnp459/Dx2zVDoXJ1xItuAH7nvl9VU1zXgvV9+xwXTeKeskip8mZTpcKtx91jIefTRRzF//nzExsZaPJ+cnIy6ujqL5yMjIxEaGoqEhAQAQEJCAqKiohAQECC3mTNnDgwGA06cOCG3ufzcc+bMkc9BRD1r3uhADPJ1Q0F5DSa8EI9Xt6eiooWwU13XgCOmxf0mDXKcxf26SqFQyAsqdnbVaHsmhMDSr46isrYBVwz2wdbHZ2DFdaO6fd6B3m7yViL7zhZ2+3wkeSP+DF7Zdhr3/fsAPthzDtNW7cLSr47i84OZtu6aVfVIyPnss89w6NAhrFy5stmx3NxcuLi4wMvLy+L5gIAA5Obmym2aBhzzcfOxttoYDAZUVVW12K+amhoYDAaLLyLqGheVEqtuGQMnpQI19Uas+/ksnvnmmHy8qrYBmUWVWPXjadQ2GKHXauSBpP2deUHF4+2MW+kpDUaBD/em44nPU7D1WA4OZRR3a0q7EAJv7zqLA+lFUKuUWHPrWIwM0rY5c6ozYkwz7fb9Xthvp95bU12DER/8lg4AOF9YiRd/OCUf+9/vjiP+ZJ7DXGerh5zMzEwsXrwYGzduhEajsfbpu2XlypXQ6XTyV0hIiK27RNSnXTHYFx/dPxl3XxEKANicko2H/puEYxdLMeHFeMxY/TM+3HceAHDl8AGcHWMya4Q0c2xTYoZNxpl8nHAez31/Et8czsJfNh7Cze/uw5s/pXX5fN8dycbr8WcAANeNCUKIlcPs5HAfaJyVyCqpwvGsnv3PaV2DsUfPbw92nspr9bZUXYPAg/9NwgtbTuFMXt/ffsTqISc5ORn5+fkYP348VCoVVCoVfv31V7z11ltQqVQICAhAbW0tSkpKLF6Xl5cHvV4aiKbX65vNtjI/bq+NVquFq6tri31bvnw5SktL5a/MTMcqyxHZwvRhfnhxQRRuGS/NGtpxMg/Xr/sNlbWNH94jA7X427xIW3XR7syPCoSfhwsKK2rbnYVkbVW1DXhzZ/NAs3ZnGvIN1S28on3/3nte/v4vV7e+uF9XubmoMGuEVLl/+v+Ooqa+Z4LhyWwDRv/vdvz54yTU1jtu2NmYKG2K+ucrB2N+VCAA4H+ujcTyJv9G/703Hde9/RtySlu+M9JXWD3kzJo1C8eOHUNKSor8NXHiRMTFxcnfOzs7Y+fOnfJrUlNTkZGRgZiYGABATEwMjh07hvz8fLlNfHw8tFotRo4cKbdpeg5zG/M5WqJWq6HVai2+iMg6Xr1tDFbfYjmTct1d0Uh9cS6+/+t0eLu7tPLK/kflpERUsLRq9Ole3sfq84MZKKmsQ6iPG35cPANqVePHwNoWwk97iitqccQ0HT7p77EYMqBntuL480xpwchTOQb8dDK/ndZds/VYDmrqjdh+Ig+bD2f1yM+wpe0ncnHjut+wJ60ACgVw95QwvLUwGpsfnYYHpoXjz1cOwW/Lrpbb19Yb8cTnKXjn57MwVPfNTVKtHnI8PT0xevRoiy93d3f4+vpi9OjR0Ol0WLRoEZ588kn8/PPPSE5Oxv3334+YmBhcccUVAIDZs2dj5MiRuOeee3DkyBFs374df//73/Hoo49CrZYWHXv44Ydx7tw5PP300zh9+jTeffddfPHFF3jiiSes/ZaIqAMUCgVunxSC+6cNgkqpwDt3jcd1Y4KgVjnBycGnhXfFiEDpP1mnenFH8nOXyrF6uzT76U8zwjEiUIt9f7sG/7l/EgDg25TsTt+uOZEthbRBvm7w82h7UcjuGDPQCwsnS7dFfzt7qUd+xsHzjcsh7E7rmZ9hK+kFFXjkk2QcuShVDs23FZ2UCowL8YLKNNttoLcb7p82SH7d/nNFWLM9Fet2nbVFt7vNJts6vPHGG7juuutwyy23YObMmdDr9fj666/l405OTtiyZQucnJwQExODu+++G/feey+ef/55uU14eDh++OEHxMfHY+zYsXjttdfwwQcfYM6cObZ4S0RksuK6kTj23BzMHxNo667YtUhTyDGHhJ4khMB3R7Lxhzd2y7Of4qaEAZC22bhy2AD4uLugvKYehzNKOnXukznSh2Zv7Bg/MUyanffpgUx8mWTd4QY19Q0WCzTu+70QRgeZTi2EwJrtp2F+O4/PGoY1t45ptf3yeSPw05MzsXROhPzcpwcyerqbPaJXtnX45ZdfLB5rNBq88847eOedd1p9TVhYGLZu3drmea+66iocPnzYGl0kIitRKBRWm1XjyCaYPrCPXSzp0NYY3fHDsRw8/qn0u9JTo8Kbd0RbVNeUSgWmD/XDd0eysfvMJUwO79h2Ew1Gge0npLGR5k1be9IVTfYz++ZwFm6baL3JI8ezSlFTb4RWo0K9UaCoohancg298r562pajOdh6TJqZ/OYd47DAtMBia1xUSgz198QgX3eUVNbi/T3pKKuuR3ZJFYK8Wh7zaq+4QScRkQ0Ee7li7EAdjAL4+tBFq5xTCIFtx3Oxblca5r65G49uOoS3d6bhsU2N/xl8ccFo6HXNZ77OHD4AAPDrmY7fptl5Kg/JF4rh5uKEG8YGdf8NtCPYyxXr754AADiUUWzVAcgH0qVtI2KG+OKKwVKY2ttk5ea+7AtT1Wt+VCBuHNfxPyeVkxLPzB+J6FAvAMDuTvzdsBcMOURENnK7aZG713acQWZR26sf7z1bgP/sTW/zg/2XM5fw8CfJeHXHGZzOLcMPR3Pwmmlqt7ebM5L+Hosbx7X8v/iZw/wASDvBn+rAYOj/7E3HQx8nAwAWRAdbfdp4a+aMCoCfhxrVdUZ8m9L65p+dZR6PM2mQD6YNla7F3j6++GDiuUI8+XkK9qRJYe3puRFdWsbhquHSkgefHsxEfR+bYs+QQ0RkI3dNDsXkcB/UNhjbHGOy63Qe4j5IxD++P4n5b/2GP/7nQIuhaJvplgQgDWwO83WDq7MTJof74KMHJrc5MNhfq5FvU81bu6fd6tI/vj8pfz+5F3dTVygUeHBGOABg3a6zVlm0zmgUSDKFnMnhPpg2VKrkHEgv6rHp6r3hjg378bVpltjVEQMQZlqEsrNuHh8MD7UKRzJL8MOxvrW1BkMOEZGNKBQK3H2FNAB4cytViRPZpXjgwyT58dn8cvySegl//jgZuaZNPr9Kvoi4D/bjc1NQ2vinKfhx8Qz8uvRqnPjHHHzx5xiMGejVbn+enT9S/n7drrP4OOE8XvrhZLMBuJevnTKpg2N4rOXuK8Lg7KRARlElzlth/68z+WUwVNfDzcUJIwO1iAjwhJ+HC6qabEnSV3ybkoVVP55utsjkoumDu3zOEB833Dc1zHT+7D61GnKvDDwmIqKWzYr0h0opfWBnFlUixMcNO0/l4dylCpRV1+HL5MaKylB/D5zNLwcAnMwx4IqVO5udT6mAxcDhzuzqHjVQh4Tl1+DKNb/gXEEFnv1W2itw1ogAeZxKfYMRU1ftkl/z0QOTEdzLg1Hd1SpMDPNBwrlC/Jqaj3C/8G6dLy1PuqYjA7XyVOroUG/En8zDiezSDg/EtgeLP0sBAKz/9Xf5ucmDGqtTXTU/Kgjv/Pw7dp3Ox0MfJ+Odu8bDRWX/dRL77yERkQNzV6swNsQLgDRj6ExeGRZ9lISXtp7CW7vOIqdUWoV4flQgtvx1Ol6+Kcpiai8AeVdzAHgidniHd/huSaDOFS/caLmxpnl5/4LyGgx95keY/yP/5ysH40rTgOXedmWE9HN3pxWgpLIWj248hJ2n8tp5VcsuFkuVqaZ7q0XqPQEAqb24jlF3lVY1X7DPQ63Cx3+a3O0tVUYGafHc9SPh4qRE/Mk8vPNz31g3hyGHiMjGromUBna+Hn8GD5sG8zb14IxwvBM3HhpnJ9w1JRSPXj0Uu566Es5O0gfX+/dOxNHnZuOthdF45Krub6tw+2VTs4+ZFpD7t2lTR6nNQCyfN6LbP6urZg6TQs6u0/kY93w8fjiWg0UfJbXzqpZdLJZueQ30bqxIReqldX9O96GQY34fTf3v9SOhVllnSYc/TgvHatP6Op8dzOgTt614u4qIyMb+NCMcFwor8EXSRZwrqLA4tnxeJBZNb347ZvAAD/zfI1NNi/tJtyKsNY1boVDg20en4cZ39gKQtjsoq67HthONA5sfmmn9Pao6Y0SgJwZ4qnGprMbi+UtlNfDzcOlU5SLTVMkZ6N1YyTEvbngy2wBDdR20Gmcr9LpnmStSZo9fM9SqawkBwNzRemi+ViLPUIMzeeWIMFW87BUrOURENqZWOeGVW8bgHtMg5ECdBnFTQvHr0qvw5yuHyONELjdmoJcccKxtbIgXUl+cizEDdaiobZADTqTeEyefn4Oh/j2zR1VHKRQKbFs8o9nzk176CXe9n4jjndj4tKVKziBfNwzz90BtgxE7TnTtNlhvazrjbuoQX3mJAmvSODshxvR37oej1pvC31MYcoiI7IBCocDzN47Cr0uvwp6nr8ZLN0V1ecqvtahVTvh40RQ8fs1Q3BwdjA/vn4RtS2bCzcU+bgL4eqix7q5ohPtZXqeEc4W4+1+JHZr+XV3XgAumGVphTc6jUCgwb7QeALCnD+xjlW+oxif7LwAAnvrDcGx68AqLypQ13Tx+IADg7Z/PWmyFYY8YcoiI7IRCoUCYr3urlRtb0Lk648nZEXj9jnG4KsLf1t1p5roxQfj5/12FV26JwjB/Dzw9VxqUXVJZh4i/b5MHTbfmRLYBDUYBPw8XBF22EvQE0/o/Ry/a/zTyp748gvOFlfDzUOPeqYN69GfNHhWAQb5uEAJ2v3Gn/fxLIiIi6qI7JoUi/skr8ZerhiLMt7GCMfuN3fjTRwex40QuGlrYcPNwhrSdw5iBXs3G8YwdKO1blV5QgZLK2h7sfddV1tbj/5Ivyqsa//OeCdC59uz4IbXKCa/fMQ4A8NOpPJTX1Pfoz+sOhhwiInIof7psoPZPp6S1XT5OOC8/l3yhGEP+Zyte/OEUAOCKwc3XwvFyc5GnlZ/swFYXtrD862N46ssjAKRVrs0bv/a0McE6eKql25YPdnFWW29gyCEiIody15QwfLJoCp67fqTF858eyMS+3wtwvqACXyVflCs7kXpP3BszqMVzmQdYn7tU0eJxW7pQWGGxf9ftEwf22s9WOSnxxB+GA5D2/bLXag5DDhERORQnpQLTh/nhj9PCcfqFubhrSigAIDWvDHe9n4i5a3djyxEpHLiolPjkT1OgcW55LZkhA6TByL9fKu+dznfCht3n5O+jQ72wcHJor/78B6aHI9THDfVGgQ1NVli2Jww5RETksDTOTnj5pij8YWSA/Fx1nRFlpsrDj4tntLlx6ZABUiXndzuq5DQYBZ78PAUbEzMAAJ89dAW++cu0VoNaT7p5vLSr/Tu//N7iisu2xpBDREQO79248XhrYTS+ejgGatOeS54aFcLbmaY/LEAKOSeySu1ihd+6BiMWNtldfFyIF6bYcG+tx68ZBh93FzQYRafWJuotDDlEROTwnJ2UuGFsECYO8sHKm6Mwc/gAfPTA5HY3MB0drINapURhRa1d3LL67EAGDpwvkh+vuXVMt/el6g6lUoGYIdLigF812UzWXjDkEBFRv3Lz+IH47wOTMT60/ZlIapWT3G7/uaJ2WveMnNIqPLbpEF7eekreGR4ADj4Ti2EBtt9WYYLp+nxzOAu/maay2wuGHCIiojaYt87Yf67QJj//xS2nsOVojsVA451PXYkBnq2PJepNd00JxVWmXeFf3noKlbX2M9OKIYeIiKgN5jV0dp7KR3Vd+1tFWEuDUeDj/Rfww7Eci+dX3zpGHhBtDzTOTlh18xjoXJ1xMseA/+w9b+suyRhyiIiI2jA2xAseahWq6hrw1BdHeu3nvr/nHJ7dfFx+7Ovugs2PTsPtVt5Z3Br0Og2WzY0EAHx/xH427mTIISIiaoPG2Qmv3z4WALD1eA7O9fAA5NzSakxbtQurfjxt8XzS32MxLsSrR392d8yPCoSTUoHTuWXIKqmydXcAMOQQERG1a/YoPa6OGAAhpAG2PeVQRjGuWLmzWUh47baxNp1F1RE6N2eMDtICAJLO22aQ9uVUtu4AERFRX3DDuCD8nHoJW47m4JGrhkCjcoKAtMJyVxWW16CgvBbnCyvw7ObjyC+rkY+9sGA0rh2tR0ZRJaI7MBPMHkwc5IMjF0vx6o5UTBvq1+ZCi71BIexhdSMbMRgM0Ol0KC0thVartXV3iIjIjpVW1WH6ql0oq6nHIF83nC+shJ+HNE5moLe0kWdheQ1yDdUYFaSzeG1xRS3+szcdd8eEQatxxtu70jB3VCCe/r+jOHXZ5p9ebs744N6JmDjIdov8ddXJbANufm8vquuMcHV2wosLRuOWCdbfU6ujn98MOQw5RETUQUnni/Dgf5NQXNm4hcGsSH+8e/d4ZBVX4akvjyAlswSb/nQF0vLL8P6ec1h/9wS8v/scNqdkI8THFdePCcK7vzTf68lJqcCEUG+8fHOUvDFoX3Q2vwyLPkrChcJKAMDHiyZjxrABVv0ZDDkdwJBDRESdlWeoxos/nOrwLKKh/h44m9/+YOXj/5gDD7VjjCJpMAq8su00soqr8NbC6G7d0msJQ04HMOQQEVFX5ZRW4UB6ERZ/ltKl1999RSgiAjxxKKME04b64dYeuK1jaw1GYfWAA3T889sxIiMREVEvC9S54sZxwRjo7YpHPjmEcD93TBrkg2tG+KOgrAYjArXYdCADG/dfgKFaWgX4h8enw99TA1cXJ7lqc0+MLd9Fz+qJgNMZrOSwkkNERD2ouq4BPx7PQbifh12vc9OXsJJDRERkBzTOTrgp2vFuRfUFXAyQiIiIHBJDDhERETkkhhwiIiJySAw5RERE5JAYcoiIiMghMeQQERGRQ2LIISIiIofEkENEREQOiSGHiIiIHBJDDhERETkkhhwiIiJySAw5RERE5JAYcoiIiMgh9etdyIUQAKQt24mIiKhvMH9umz/HW9OvQ05ZWRkAICQkxMY9ISIios4qKyuDTqdr9bhCtBeDHJjRaER2djY8PT2hUCisck6DwYCQkBBkZmZCq9Va5ZyOgNelOV6TlvG6tIzXpTlek5b1h+sihEBZWRmCgoKgVLY+8qZfV3KUSiUGDhzYI+fWarUO+5erO3hdmuM1aRmvS8t4XZrjNWmZo1+Xtio4Zhx4TERERA6JIYeIiIgcEkOOlanVavzv//4v1Gq1rbtiV3hdmuM1aRmvS8t4XZrjNWkZr0ujfj3wmIiIiBwXKzlERETkkBhyiIiIyCEx5BAREZFDYsghIiIih8SQ0wWrVq2CQqHAkiVL5Oeqq6vx6KOPwtfXFx4eHrjllluQl5dn8bqMjAzMnz8fbm5u8Pf3x9KlS1FfX9/LvbeurKws3H333fD19YWrqyuioqKQlJQkHxdCYMWKFQgMDISrqytiY2ORlpZmcY6ioiLExcVBq9XCy8sLixYtQnl5eW+/FatoaGjAs88+i/DwcLi6umLIkCF44YUXLPZX6Q/XZPfu3bj++usRFBQEhUKBzZs3Wxy31jU4evQoZsyYAY1Gg5CQEKxevbqn31q3tHVd6urqsGzZMkRFRcHd3R1BQUG49957kZ2dbXEOR7su7f1daerhhx+GQqHAm2++afG8o10ToGPX5dSpU7jhhhug0+ng7u6OSZMmISMjQz7eXz+XLAjqlAMHDohBgwaJMWPGiMWLF8vPP/zwwyIkJETs3LlTJCUliSuuuEJMnTpVPl5fXy9Gjx4tYmNjxeHDh8XWrVuFn5+fWL58uQ3ehXUUFRWJsLAw8cc//lEkJiaKc+fOie3bt4uzZ8/KbVatWiV0Op3YvHmzOHLkiLjhhhtEeHi4qKqqktvMnTtXjB07Vuzfv1/s2bNHDB06VCxcuNAWb6nbXnrpJeHr6yu2bNki0tPTxZdffik8PDzE2rVr5Tb94Zps3bpVPPPMM+Lrr78WAMQ333xjcdwa16C0tFQEBASIuLg4cfz4cfHpp58KV1dX8c9//rO33mantXVdSkpKRGxsrPj888/F6dOnRUJCgpg8ebKYMGGCxTkc7bq093fF7OuvvxZjx44VQUFB4o033rA45mjXRIj2r8vZs2eFj4+PWLp0qTh06JA4e/as+Pbbb0VeXp7cpj9+Ll2OIacTysrKxLBhw0R8fLy48sor5ZBTUlIinJ2dxZdffim3PXXqlAAgEhIShBDSX1ilUilyc3PlNu+9957QarWipqamV9+HtSxbtkxMnz691eNGo1Ho9XqxZs0a+bmSkhKhVqvFp59+KoQQ4uTJkwKAOHjwoNzmxx9/FAqFQmRlZfVc53vI/PnzxQMPPGDx3M033yzi4uKEEP3zmlz+C9pa1+Ddd98V3t7eFv9+li1bJiIiInr4HVlHWx/oZgcOHBAAxIULF4QQjn9dWrsmFy9eFMHBweL48eMiLCzMIuQ4+jURouXrcscdd4i777671df018+ly/F2VSc8+uijmD9/PmJjYy2eT05ORl1dncXzkZGRCA0NRUJCAgAgISEBUVFRCAgIkNvMmTMHBoMBJ06c6J03YGXfffcdJk6ciNtuuw3+/v6Ijo7G+++/Lx9PT09Hbm6uxXXR6XSYMmWKxXXx8vLCxIkT5TaxsbFQKpVITEzsvTdjJVOnTsXOnTtx5swZAMCRI0fw22+/Yd68eQD65zW5nLWuQUJCAmbOnAkXFxe5zZw5c5Camori4uJeejc9q7S0FAqFAl5eXgD653UxGo245557sHTpUowaNarZ8f56TX744QcMHz4cc+bMgb+/P6ZMmWJxS6u/fi5djiGngz777DMcOnQIK1eubHYsNzcXLi4u8i8is4CAAOTm5sptmv5FMh83H+uLzp07h/feew/Dhg3D9u3b8cgjj+Dxxx/HRx99BKDxfbX0vpteF39/f4vjKpUKPj4+ffK6/O1vf8Odd96JyMhIODs7Izo6GkuWLEFcXByA/nlNLmeta+CI/6aaqq6uxrJly7Bw4UJ5k8X+eF1eeeUVqFQqPP744y0e74/XJD8/H+Xl5Vi1ahXmzp2LHTt24KabbsLNN9+MX3/9FUD//Vy6XL/ehbyjMjMzsXjxYsTHx0Oj0di6O3bDaDRi4sSJePnllwEA0dHROH78ONavX4/77rvPxr2zjS+++AIbN27Epk2bMGrUKKSkpGDJkiUICgrqt9eEOq+urg633347hBB47733bN0dm0lOTsbatWtx6NAhKBQKW3fHbhiNRgDAjTfeiCeeeAIAMG7cOOzbtw/r16/HlVdeacvu2RVWcjogOTkZ+fn5GD9+PFQqFVQqFX799Ve89dZbUKlUCAgIQG1tLUpKSixel5eXB71eDwDQ6/XNRrWbH5vb9DWBgYEYOXKkxXMjRoyQR/eb31dL77vpdcnPz7c4Xl9fj6Kioj55XZYuXSpXc6KionDPPffgiSeekCuA/fGaXM5a18AR/00BjQHnwoULiI+Pl6s4QP+7Lnv27EF+fj5CQ0Pl370XLlzAU089hUGDBgHof9cEAPz8/KBSqdr9/dsfP5cux5DTAbNmzcKxY8eQkpIif02cOBFxcXHy987Ozti5c6f8mtTUVGRkZCAmJgYAEBMTg2PHjln8YzT/Arv8L2pfMW3aNKSmplo8d+bMGYSFhQEAwsPDodfrLa6LwWBAYmKixXUpKSlBcnKy3GbXrl0wGo2YMmVKL7wL66qsrIRSafnPysnJSf6fV3+8Jpez1jWIiYnB7t27UVdXJ7eJj49HREQEvL29e+ndWJc54KSlpeGnn36Cr6+vxfH+dl3uueceHD161OJ3b1BQEJYuXYrt27cD6H/XBABcXFwwadKkNn//TpgwoV9+LjVj65HPfVXT2VVCSFP1QkNDxa5du0RSUpKIiYkRMTEx8nHzVL3Zs2eLlJQUsW3bNjFgwIA+PVXvwIEDQqVSiZdeekmkpaWJjRs3Cjc3N/HJJ5/IbVatWiW8vLzEt99+K44ePSpuvPHGFqcKR0dHi8TERPHbb7+JYcOG9anp0k3dd999Ijg4WJ5C/vXXXws/Pz/x9NNPy236wzUpKysThw8fFocPHxYAxOuvvy4OHz4szxKyxjUoKSkRAQEB4p577hHHjx8Xn332mXBzc7PracFtXZfa2lpxww03iIEDB4qUlBSRk5MjfzWd6eJo16W9vyuXu3x2lRCOd02EaP+6fP3118LZ2Vls2LBBpKWlibfffls4OTmJPXv2yOfoj59Ll2PI6aLLQ05VVZX4y1/+Iry9vYWbm5u46aabRE5OjsVrzp8/L+bNmydcXV2Fn5+feOqpp0RdXV0v99y6vv/+ezF69GihVqtFZGSk2LBhg8Vxo9Eonn32WREQECDUarWYNWuWSE1NtWhTWFgoFi5cKDw8PIRWqxX333+/KCsr6823YTUGg0EsXrxYhIaGCo1GIwYPHiyeeeYZiw+p/nBNfv75ZwGg2dd9990nhLDeNThy5IiYPn26UKvVIjg4WKxataq33mKXtHVd0tPTWzwGQPz888/yORzturT3d+VyLYUcR7smQnTsuvzrX/8SQ4cOFRqNRowdO1Zs3rzZ4hz99XOpKYUQTZZiJSIiInIQHJNDREREDokhh4iIiBwSQw4RERE5JIYcIiIickgMOUREROSQGHKIiIjIITHkEBERkUNiyCEiIiKHxJBDREREDokhh4iIiBwSQw4RERE5JIYcIiIickj/H5PME1bj/fXxAAAAAElFTkSuQmCC", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "high_intensity_spectrum = np.mean(\n", + " np.array([\n", + " pure_spectra[idx][None, :]\n", + " for idx in test_intensity_idxs[-10:]\n", + " ]),\n", + " axis=0,\n", + ")[0, :]\n", + "\n", + "plt.plot(wns[mask], high_intensity_spectrum)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "c243080b-0acc-4149-b42d-aba2fff61e8a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x727babb1b6d0>]" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# check for random spectrum\n", + "\n", + "idx = test_intensity_idxs[20]\n", + "\n", + "rand_spectrum = pure_spectra[idx]\n", + "\n", + "plt.plot(wns[mask], rand_spectrum)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "b848d3b4-4130-4478-adda-b2f78111d718", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(dtype('float64'), dtype('float64'), dtype('float64'))" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rand_spectrum.dtype, air_spectrum.dtype, high_intensity_spectrum.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "d7c7acff-b53e-4bac-acec-9d42bf59fafe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 0\n", + " fun: 3348294.4971461324\n", + " x: [ 3.294e-01]\n", + " nit: 25\n", + " nfev: 50\n", + " final_simplex: (array([[ 3.294e-01],\n", + " [ 3.294e-01]]), array([ 3.348e+06, 3.348e+06]))" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "from functools import partial\n", + "\n", + "def least_squares_diffs(x, actual_spectrum):\n", + " return np.mean(\n", + " np.sum(\n", + " np.square(\n", + " (x * air_spectrum + (1. - x) * high_intensity_spectrum) - actual_spectrum\n", + " )\n", + " )\n", + " )\n", + "\n", + "\n", + "result = minimize(\n", + " partial(\n", + " least_squares_diffs,\n", + " actual_spectrum=rand_spectrum,\n", + " ),\n", + " x0=1.,\n", + " method=\"Nelder-Mead\",\n", + ")\n", + "\n", + "result\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "6ea7db74-3b87-440e-a1e2-791f2ef82df8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x727bb9857670>" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "ax = plt.gca()\n", + "\n", + "ax.plot(wns[mask], air_spectrum, label=\"air\")\n", + "ax.plot(wns[mask], high_intensity_spectrum, label=\"high intensity\")\n", + "ax.plot(wns[mask], rand_spectrum, label=\"choosen spectrum\")\n", + "ax.plot(\n", + " wns[mask],\n", + " (result.x * air_spectrum + (1. - result.x) * high_intensity_spectrum),\n", + " label=\"%4.2f * air + (1. - %4.2f) * high\" % (result.x, result.x),\n", + ")\n", + "\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "251939ed-4623-441c-a41c-c8f8014f1916", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8a12e185-c186-47c9-add6-46ba0b699532", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/raman_master/cli.py b/raman_master/cli.py index fcc04d4..fa99c7f 100644 --- a/raman_master/cli.py +++ b/raman_master/cli.py @@ -1,14 +1,17 @@ import ast import logging import click +import torch import ray from ray import train, tune from ray.tune.schedulers.hb_bohb import HyperBandForBOHB from ray.tune.search.bohb import TuneBOHB +from ray.tune.search.optuna import OptunaSearch from ray.tune import CLIReporter -from raman_master.models.hp_tuning import train_and_evaluate_model +from raman_master.models.hp_tuning import train_and_evaluate_model as train_cnn +from raman_master.models.mae import train_and_evaluate_model as train_mae from raman_master.models.loss import LearnedMeanSigmaLossIgnoreNans, MSEIgnoreNans2d @@ -351,7 +354,7 @@ def hp_tuning_bohb( # new API trainable = tune.with_parameters( - train_and_evaluate_model, + train_cnn, data_factor=data_factor, num_epochs=max_iter, use_gpu=True if num_gpus > 0. else False, @@ -401,3 +404,310 @@ def hp_tuning_bohb( ) finally: ray.shutdown() + + + +@cli_group.command( + help='Hyperparameter tuning for a MAE Raman Model' +) +@click.option( + '--results-dir', + help='where to leave the results', + type=str +) +# hp-tuning parameter +@click.option( + '--num-samples', + help='number of samples', + default=1, + type=int +) +@click.option( + '--num-cpus', + help='how much cpus should be involved in one tuning step', + default=1, + type=int, +) +@click.option( + '--num-gpus', + help='how much cpus should be involved in one tuning step', + default=0., + type=float, +) +@click.option( + '--max-concurrent', + help='how many trails to run in parallel', + default=1, + type=int, +) +# Specify the parameter options to parse +@click.option( + '--patch-size', + type=int, + default=32, +) +@click.option( + '--batch-size', + type=int, + default=32, +) +@click.option( + '--n-head', + type=int, + default=8, +) +@click.option( + '--warm-up-duration', + type=int, + default=1, +) +@click.option( + '--decoder-depth', + type=int, + default=1, +) +@click.option( + '--self-super-epochs', + type=int, + default=1, +) +@click.option( + '--fine-tuning-epochs', + type=int, + default=1, +) +# transformer parameter: +@click.option( + '--embedding-dim-factor-bounds', + cls=PythonLiteralOption, + default='[16, 128]', +) +@click.option( + '--dim-feedforward-bounds', + cls=PythonLiteralOption, + default='[16, 65]', +) +@click.option( + '--t-dropout-bounds', + cls=PythonLiteralOption, + default='[0., 0.8]', +) +@click.option( + '--encoder-depth-bounds', + cls=PythonLiteralOption, + default='[1, 3]', +) +@click.option( + '--num-cls-tokens-bounds', + cls=PythonLiteralOption, + default='[1, 4]', +) +@click.option( + '--weight-decay-bounds', + cls=PythonLiteralOption, + default='[1e-6, 1e-1]', +) +@click.option( + '--base-lr-bounds', + cls=PythonLiteralOption, + default='[1e-6, 1e-1]', +) +# data augmentation +@click.option( + '--masking-ratio-bounds', + cls=PythonLiteralOption, + default='[0.3, 1.]', +) +@click.option( + '--original-dp-fraction-bounds', + cls=PythonLiteralOption, + default='[0., 0.5]', +) +# fine tuning +@click.option( + '--fc-dim-bounds', + cls=PythonLiteralOption, + default='[32, 65]', +) +@click.option( + '--fc-dropout-bounds', + cls=PythonLiteralOption, + default='[0., 0.6]', +) +@click.option( + '--fc-lr-bounds', + cls=PythonLiteralOption, + default='[1e-5, 1e-3]', +) +@click.option( + '--fine-lr-bounds', + cls=PythonLiteralOption, + default='[1e-5, 1e-3]', +) +@click.option( + '--fine-weight-decay-bounds', + cls=PythonLiteralOption, + default='[1e-5, 1e-3]', +) +# general configuration +@click.option( + '--data-dir', + type=str, + default='', +) +@click.option('--lower-wn', type=int, default=396) +@click.option('--upper-wn', type=int, default=2000) +@click.option('--experiment-name', default=None) +@click.option('--reporting-interval', type=float, default=20.) +@click.option('--loss-fn', type=str, default="mse_std") +@click.option('--val-loss-fn', type=str, default="mse") +def hp_tuning_mae( + results_dir, + # Hyper Algorithm parameter + num_samples, + num_cpus, + num_gpus, + max_concurrent, + # explicitly defined parameters: + patch_size, + batch_size, + n_head, + warm_up_duration, + decoder_depth, + self_super_epochs, + fine_tuning_epochs, + # transformer parameter: + embedding_dim_factor_bounds, + dim_feedforward_bounds, + t_dropout_bounds, + encoder_depth_bounds, + num_cls_tokens_bounds, + weight_decay_bounds, + base_lr_bounds, + # data augmentation + masking_ratio_bounds, + original_dp_fraction_bounds, + # fine tuning + fc_dim_bounds, + fc_dropout_bounds, + fc_lr_bounds, + fine_lr_bounds, + fine_weight_decay_bounds, + # config parameter + data_dir, + lower_wn, + upper_wn, + experiment_name, + reporting_interval, + loss_fn, + val_loss_fn, +): + try: + ray.init( + _temp_dir=results_dir, + num_cpus=int(num_cpus * max_concurrent), + num_gpus=num_gpus, + ) + import time + time.sleep(10) + + click.echo('Start Hyper Parameter Tuning for a Raman Model') + click.echo("num cpus: %s" % num_cpus) + + search_space = { + # transformer + "patch_size": patch_size, + "batch_size": batch_size, + "embedding_dim_factor": tune.randint(*embedding_dim_factor_bounds), + "n_head": n_head, + "dim_feedforward": tune.randint(*dim_feedforward_bounds), + "t_dropout": tune.uniform(*t_dropout_bounds), + "t_activation": "gelu", + "encoder_depth": tune.randint(*encoder_depth_bounds), + "decoder_depth": decoder_depth, + "num_cls_tokens": tune.randint(*num_cls_tokens_bounds), + "weight_decay": tune.loguniform(*weight_decay_bounds), + # optimizer + "base_lr": tune.uniform(*base_lr_bounds), + "betas": [0.9, 0.95], + "T_mult": 2, + "T_0": 1, + "warm_up_duration": warm_up_duration, + "dtype": torch.float32, + # data augmentation + "masking_ratio": tune.uniform(*masking_ratio_bounds), + "augment_slope_std": 0., + "baseline_factor_bound": 1., + "baseline_period_lower_bound": 3.33, + "baseline_period_span": 3.33, + "original_datapoint_weight": tune.uniform(*original_dp_fraction_bounds), + # fine tuning + "fc_dims": tune.randint(*fc_dim_bounds), + "fc_dropout": tune.uniform(*fc_dropout_bounds), + "fc_activation": "ELU", + "fc_lr": tune.uniform(*fc_lr_bounds), + "fine_lr": tune.uniform(*fine_lr_bounds), + "fine_weight_decay": tune.loguniform(*fine_weight_decay_bounds), + "fine_betas": (0.9, 0.999), + "fine_T_mult": 2, + "fine_T_0": 1, + "fine_warm_up_duration": 5, + } + loss_fns = { + "mse": MSEIgnoreNans2d(), + "mse_std": LearnedMeanSigmaLossIgnoreNans(min_noise=1e-6), + } + if loss_fn == "mse_std": + search_space['fc_output_channels'] = 2 + else: + search_space['fc_output_channels'] = 1 + + # new API + trainable = tune.with_parameters( + train_mae, + directory=data_dir, + self_super_epochs=self_super_epochs, + fine_tuning_epochs=fine_tuning_epochs, + use_gpu=True if num_gpus > 0. else False, + use_tune=True, + loss_fn=loss_fns[loss_fn], + val_loss_fn=loss_fns[val_loss_fn], + lower_wn=lower_wn, + upper_wn=upper_wn, + ) + + algo = tune.search.ConcurrencyLimiter( + OptunaSearch(), + max_concurrent=max_concurrent, + ) + + tuner = tune.Tuner( + tune.with_resources( + trainable, + {"cpu": num_cpus, "gpu": num_gpus} + ), + tune_config=tune.TuneConfig( + metric="rolling_val_loss", + mode="min", + search_alg=algo, + num_samples=num_samples, + ), + run_config=train.RunConfig( + name=experiment_name, + # stop={"training_iteration": max_iter}, + storage_path=results_dir, + progress_reporter=CLIReporter( + max_report_frequency=reporting_interval, + metric="rolling_val_loss", + mode="min", + ) + ), + param_space=search_space, + ) + results = tuner.fit() + + click.echo( + 'Best configuration is: %s' % results.get_best_result().config + ) + finally: + ray.shutdown() diff --git a/raman_master/models/mae.py b/raman_master/models/mae.py index c0ca717..3ee5320 100644 --- a/raman_master/models/mae.py +++ b/raman_master/models/mae.py @@ -1,9 +1,14 @@ +import os import random +import numpy as np import torch +from ray import train from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, LinearLR -from raman_master.models.loss import MSEIgnoreNans +from raman_master.data.torch_datasets import NormalizedSpectra2D +from raman_master.models.hp_tuning import load_spectra_and_labels_fs +from raman_master.models.loss import MSEIgnoreNans, LearnedMeanSigmaLossIgnoreNans, MSEIgnoreNans2d from raman_master.models.transformer import PatchEncoderBSC @@ -236,6 +241,7 @@ class FCNet(torch.nn.Module): fc_dropout, fc_activation, dtype, + fc_output_channels=1, **kwargs, ): super().__init__() @@ -248,9 +254,12 @@ class FCNet(torch.nn.Module): layers.append(getattr(torch.nn, fc_activation)()) layers.append(torch.nn.Linear(fc_dims[-2], fc_dims[-1], dtype=dtype)) self.fc_net = torch.nn.Sequential(*layers) + self.fc_output_channels = fc_output_channels def forward(self, x): - return self.fc_net(x) + batch_size = x.shape[0] + forecast = self.fc_net(x) + return forecast.reshape(batch_size, self.fc_output_channels, -1) def self_supervised_training( @@ -270,7 +279,8 @@ def self_supervised_training( if (torch.cuda.is_available() and use_gpu) else torch.device("cpu") ) - print("Using device: %s" % device) + if verbose: + print("Using device: %s" % device) spectra_size = training_set.dataset.spectra.shape[-1] config["spectra_size"] = spectra_size @@ -335,16 +345,16 @@ def self_supervised_training( ).item() ) val_losses.append(sum(epoch_val_losses) / len(epoch_val_losses)) - - print( - "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f\t lr %4.2e" - % ( - epoch, - train_losses[-1], - val_losses[-1], - optimizer.param_groups[0]["lr"], + if verbose: + print( + "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f\t lr %4.2e" + % ( + epoch, + train_losses[-1], + val_losses[-1], + optimizer.param_groups[0]["lr"], + ) ) - ) if epoch < config["warm_up_duration"]: warm_start_scheduler.step() else: @@ -365,24 +375,24 @@ def fine_tuning( num_epochs=10000, use_gpu=True, loss_fn=None, - verbose=False, + val_loss_fn=None, + use_tune=False, ): random.seed(0) torch.manual_seed(0) - loss_fn = loss_fn or MSEIgnoreNans() - device = ( torch.device("cuda") if (torch.cuda.is_available() and use_gpu) else torch.device("cpu") ) - print("Using device: %s" % device) + if not use_tune: + print("Using device: %s" % device) config["fc_dims"] = [ config["embedding_dim"] * trans_encoder.num_cls_tokens, - config["fc_dim"], - int(config["fc_dim"] / 2), - training_set.dataset.concentrations.shape[1], + config["fc_dims"], + int(config["fc_dims"] / 2), + training_set.dataset.concentrations.shape[1] * config["fc_output_channels"], ] fc_net = torch.jit.script( FCNet(**config).to(device) @@ -412,6 +422,7 @@ def fine_tuning( start_epoch = 1 train_losses = [] val_losses = [] + rolling_val_losses = [1.] for epoch in range(start_epoch, num_epochs + 1): # training @@ -468,15 +479,16 @@ def fine_tuning( predictions = fc_net(cls_encoding.view(batch_size, -1)) epoch_val_losses.append( - loss_fn( + val_loss_fn( predictions, one_batch["concentrations"], one_batch["label_weight"], ).item() ) val_losses.append(sum(epoch_val_losses) / len(epoch_val_losses)) + rolling_val_losses.append(0.8 * rolling_val_losses[-1] + 0.2 * val_losses[-1]) - if verbose: + if not use_tune: print( "epoch: %s \ttrain_loss %4.2f\tval_loss %4.2f\tlr: %4.2e" % ( @@ -486,6 +498,15 @@ def fine_tuning( optimizer.param_groups[0]["lr"], ) ) + if use_tune: + train.report( + { + "iteration": epoch, + "train_loss": train_losses[-1], + "val_loss": val_losses[-1], + "rolling_val_loss": rolling_val_losses[-1], + } + ) if epoch < config["fine_warm_up_duration"]: warm_start_scheduler.step() else: @@ -496,4 +517,137 @@ def fine_tuning( fc_net, train_losses, val_losses, + rolling_val_losses, + ) + + +def train_and_evaluate_model( + config, + directory, + self_super_epochs=1, + fine_tuning_epochs=1, + use_gpu=True, + use_tune=True, + train_dirs=None, + val_dirs=None, + loss_fn=None, + val_loss_fn=None, + lower_wn=396, + upper_wn=3400, +): + + train_dirs = train_dirs or ["train"] + val_dirs = val_dirs or ["val"] + + # load training data + train_specs = [] + train_cs = [] + for dir in train_dirs: + spectra, cons, _, _, _ = load_spectra_and_labels_fs( + os.path.join(directory, dir), + lower_wn=lower_wn, + upper_wn=upper_wn, + ) + train_specs.append(spectra) + train_cs.append(cons) + + train_spectra = np.concatenate(train_specs, axis=0) + train_cons = np.concatenate(train_cs, axis=0) + + # load validation data + val_specs = [] + val_cs = [] + for dir in val_dirs: + spectra, cons, _, _, _ = load_spectra_and_labels_fs( + os.path.join(directory, dir), + lower_wn=lower_wn, + upper_wn=upper_wn, + ) + val_specs.append(spectra) + val_cs.append(cons) + + val_spectra = np.concatenate(val_specs, axis=0) + val_cons = np.concatenate(val_cs, axis=0) + + train_data = torch.utils.data.DataLoader( + NormalizedSpectra2D( + spectra=train_spectra, + concentrations=train_cons, + combine_spectra_range=0.5, + combine_within_group=0.3, + augment_slope_std=config["augment_slope_std"], + augment_intersept_std=0.0, + rolling_bound=0, + spectrum_rolling_sigma=0.0, + baseline_factor_bound=config["baseline_factor_bound"], + baseline_period_lower_bound=config["baseline_period_lower_bound"], + baseline_period_upper_bound=( + config["baseline_period_lower_bound"] + config["baseline_period_span"] + ), + dtype=torch.float32, + original_datapoint_weight=config["original_datapoint_weight"], + augmentation_weight=0.5, + ), + batch_size=config["batch_size"], + ) + val_data = torch.utils.data.DataLoader( + NormalizedSpectra2D( + spectra=val_spectra, + concentrations=val_cons, + spectra_mean_std=( + train_data.dataset.s_mean, + train_data.dataset.s_std, + ), + concentration_mean_std=( + train_data.dataset.concentration_means, + train_data.dataset.concentration_stds, + ), + dtype=torch.float32, + ), + batch_size=config["batch_size"], ) + + config["spectra_size"] = train_spectra.shape[2] + if not use_tune: + print("spectra size: %s" % str(train_spectra.shape)) + config["embedding_dim"] = int(config["n_head"] * config["embedding_dim_factor"]) + config["dtype"] = torch.float32 + + mae_model, train_losses_self, val_losses_self = ( + self_supervised_training( + config=config, + training_set=train_data, + val_set=val_data, + num_epochs=self_super_epochs, + use_gpu=use_gpu, + verbose=False, + ) + ) + trans_encoder, fc_net, train_losses, val_losses, rolling_vals = fine_tuning( + config=config, + trans_encoder=mae_model.mae_encoder, + training_set=train_data, + val_set=val_data, + num_epochs=fine_tuning_epochs, + loss_fn=loss_fn, + val_loss_fn=val_loss_fn, + use_tune=use_tune, + ) + + if use_tune: + return { + "iteration": len(val_losses), + "train_loss": train_losses[-1], + "val_loss": val_losses[-1], + "rolling_val_loss": rolling_vals[-1], + } + else: + return ( + trans_encoder, + fc_net, + train_losses, + val_losses, + rolling_vals, + train_data, + val_data, + ) diff --git a/raman_master/models/nn_training.py b/raman_master/models/nn_training.py index 2b1aa53..21f4741 100644 --- a/raman_master/models/nn_training.py +++ b/raman_master/models/nn_training.py @@ -15,8 +15,8 @@ from raman_master.models.transformer import ( ResNetDecoder, RamanTransformerEncoder, PatchDecoder, - PatchEncoderBSC, - TransformerRegressor, PatchEncoderBCS, + PatchEncoderBCS, + TransformerRegressor, ) diff --git a/raman_master/models/rezero_net.py b/raman_master/models/rezero_net.py index 0f8be71..a960b25 100644 --- a/raman_master/models/rezero_net.py +++ b/raman_master/models/rezero_net.py @@ -252,10 +252,9 @@ class ReZeroNet(torch.nn.Module): print("Number of Parameters: %s" % num_params) def forward(self, spectra): + batch_size = spectra.shape[0] embeddings = self.cnn_encoder(spectra) forecast = self.fc_net(embeddings.view(-1, self.fc_dims[0])) if self.fc_output_channels > 1: - forecast = forecast.reshape( - -1, self.fc_output_channels, self.fc_dims[-1] - ) + forecast = forecast.reshape(batch_size, self.fc_output_channels, -1) return forecast diff --git a/scripts/run_local_mae_hp_tuning.sh b/scripts/run_local_mae_hp_tuning.sh new file mode 100644 index 0000000..95ff481 --- /dev/null +++ b/scripts/run_local_mae_hp_tuning.sh @@ -0,0 +1,28 @@ +raman-master hp-tuning-mae --results-dir /tmp/hp-tuning \ + --num-samples 3 \ + --num-cpus 4 \ + --max-concurrent 2 \ + --patch-size 32 \ + --batch-size 32 \ + --warm-up-duration 1 \ + --decoder-depth 1 \ + --self-super-epochs 1 \ + --fine-tuning-epochs 1 \ + --embedding-dim-factor-bounds "[36, 65]" \ + --dim-feedforward-bounds "[36, 65]" \ + --t-dropout-bounds "[0., 0.5]" \ + --encoder-depth-bounds "[1, 3]" \ + --num-cls-tokens-bounds "[1, 3]" \ + --weight-decay-bounds "[1e-6, 1e-1]" \ + --base-lr-bounds "[1e-5, 1e-3]" \ + --masking-ratio-bounds "[0.3, 1.]" \ + --original-dp-fraction-bounds "[0.3, 0.5]" \ + --fc-dim-bounds "[32, 128]" \ + --fc-dropout-bounds "[0., 0.7]" \ + --fc-lr-bounds "[1e-5, 1e-3]" \ + --fine-lr-bounds "[1e-5, 1e-3]" \ + --fine-weight-decay-bounds "[1e-6, 1e-1]" \ + --lower-wn 396 --upper-wn 2000 \ + --data-dir /home/christoph/git_projects/raman-data \ + --loss-fn mse \ + --val-loss-fn mse -- GitLab From 6f11eaa2166f3baa093e69d053bb011376a2092a Mon Sep 17 00:00:00 2001 From: Christoph Lange <christoph.lange@tu-berlin.de> Date: Mon, 11 Nov 2024 18:07:23 +0100 Subject: [PATCH 8/8] version 0.1.16 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 241edc7..4b919a9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta" [project] name = "raman_master" -version = "0.1.15" +version = "0.1.16" description = "Package for training models that predict process parameter of 2Mag fermentations from Raman spectra." readme = "README.rst" license = {file = "LICENSE"} -- GitLab