diff --git a/climanet/dataset.py b/climanet/dataset.py index 17ef9f5..70fd091 100644 --- a/climanet/dataset.py +++ b/climanet/dataset.py @@ -1,3 +1,5 @@ +import warnings + import numpy as np from .utils import add_month_day_dims import xarray as xr @@ -16,12 +18,10 @@ def __init__( land_mask: xr.DataArray = None, time_dim: str = "time", spatial_dims: Tuple[str, str] = ("lat", "lon"), - patch_size: Tuple[int, int] = (16, 16), - overlap: int = 0, + patch_size: Tuple[int, int] = (16, 16), # (lat, lon) ): self.spatial_dims = spatial_dims self.patch_size = patch_size - self.overlap = overlap # Check that the input data has the expected dimensions if time_dim not in daily_da.dims or time_dim not in monthly_da.dims: @@ -30,6 +30,13 @@ def __init__( if dim not in daily_da.dims or dim not in monthly_da.dims: raise ValueError(f"Spatial dimension '{dim}' not found in input data") + if ( + patch_size[0] > daily_da.sizes[spatial_dims[0]] or patch_size[1] > daily_da.sizes[spatial_dims[1]] + ): + raise ValueError( + f"Patch size {patch_size} is larger than data dimensions {daily_da.sizes[spatial_dims]}" + ) + # Reshape daily → (M, T=31, H, W), monthly → (M, H, W), # and get padded_days_mask → (M, T=31) daily_mt, monthly_m, padded_days_mask = add_month_day_dims( @@ -41,6 +48,10 @@ def __init__( self.monthly_np = monthly_m.to_numpy().copy() # (M, H, W) float self.padded_mask_np = padded_days_mask.to_numpy().copy() # (M, T=31) bool + # Store coordinate arrays + self.lat_coords = daily_da[spatial_dims[0]].to_numpy().copy() + self.lon_coords = daily_da[spatial_dims[1]].to_numpy().copy() + if land_mask is not None: lm = land_mask.to_numpy().copy() if lm.ndim == 3: @@ -60,25 +71,45 @@ def __init__( self.padded_days_tensor = torch.from_numpy(self.padded_mask_np).bool() # Precompute lazy index mapping for patches - self.stride = self.patch_size[0] - self.overlap H, W = self.daily_np.shape[2], self.daily_np.shape[3] - self.n_i = (H - self.patch_size[0]) // self.stride + 1 - self.n_j = (W - self.patch_size[1]) // self.stride + 1 + self.patch_indices = self._compute_patch_indices(H, W) + + def _compute_patch_indices(self, H: int, W: int) -> list: + """Generate non-overlapping patch start indices with coverage warning.""" + ph, pw = self.patch_size + + # Compute number of full non-overlapping patches + n_patches_h = H // ph + n_patches_w = W // pw + + # Check for incomplete coverage + remainder_h = H % ph + remainder_w = W % pw + + if remainder_h > 0 or remainder_w > 0: + warnings.warn( + f"Patch size {self.patch_size} does not evenly divide image dimensions (H={H}, W={W}). " + f"Uncovered pixels: {remainder_h} in height, {remainder_w} in width. " + f"Consider adjusting patch_size or image dimensions for full coverage.", + UserWarning + ) + + # Generate non-overlapping patch indices + i_starts = [i * ph for i in range(n_patches_h)] + j_starts = [j * pw for j in range(n_patches_w)] + + return [(i, j) for i in i_starts for j in j_starts] - # Total length is only spatial patches (all months included in each sample) - self.total_len = self.n_i * self.n_j def __len__(self): - return self.total_len + return len(self.patch_indices) def __getitem__(self, idx): """Get a spatiotemporal patch sample based on the index.""" - if idx < 0 or idx >= self.total_len: + if idx < 0 or idx >= len(self.patch_indices): raise IndexError("Index out of range") - i_idx, j_idx = divmod(idx, self.n_j) - i = i_idx * self.stride - j = j_idx * self.stride + i, j = self.patch_indices[idx] ph, pw = self.patch_size # Extract spatial patch via numpy slicing — faster than xarray indexing @@ -108,6 +139,10 @@ def __getitem__(self, idx): ~land_tensor.unsqueeze(0).unsqueeze(0).unsqueeze(0) ) + # Extract lat/lon coordinates for this patch + lat_patch = self.lat_coords[i : i + ph] + lon_patch = self.lon_coords[j : j + pw] + # Convert to tensors return { "daily_patch": daily_tensor, # (C=1, M, T=31, H, W) @@ -116,4 +151,6 @@ def __getitem__(self, idx): "land_mask_patch": land_tensor, # (H,W) True=Land "padded_days_mask": self.padded_days_tensor, # (M, T=31) True=padded "coords": (i, j), + "lat_patch": lat_patch, # (H,) + "lon_patch": lon_patch, # (W,) } diff --git a/climanet/st_encoder_decoder.py b/climanet/st_encoder_decoder.py index 21f4dc3..7df74ad 100644 --- a/climanet/st_encoder_decoder.py +++ b/climanet/st_encoder_decoder.py @@ -185,7 +185,7 @@ def __init__(self, embed_dim=128, max_days=31, max_months=12): def forward(self, x, M, T, H, W, padded_days_mask=None): """ Args: - x: (B, M*T*H*W, C) containing spatio-temporal tokens, where C is the embedding dimension. + x: (B, M, T, H, W, C) containing spatio-temporal tokens, where C is the embedding dimension. M: number of months T: number of temporal tokens per month after temporal patching (Tp) H: spatial height after spatial patching @@ -194,9 +194,12 @@ def forward(self, x, M, T, H, W, padded_days_mask=None): True indicating which day tokens are padded (because some months have fewer days). This is used to mask out padded tokens in attention computation. Returns: - Tensor of shape (B, M*H*W, C) with one temporally aggregated, where C is the embedding dimension. + Tensor of shape (B, M, H*W, C) with one temporally aggregated, where C is the embedding dimension. """ - seq = rearrange(x, "b (m t h w) c -> b (h w) m t c", m=M, t=T, h=H, w=W) + B, M, Tp, Hp, Wp, C = x.shape + + # Reshape to (B, Hp*Wp, M, Tp, C) for temporal processing + seq = x.permute(0, 3, 4, 1, 2, 5).reshape(B, Hp * Wp, M, Tp, C) pe_days = self.pos_days(T).to(seq.device).to(seq.dtype) # (T, C) pe_months = self.pos_months(M).to(seq.device).to(seq.dtype) # (M, C) @@ -209,10 +212,10 @@ def forward(self, x, M, T, H, W, padded_days_mask=None): # padded_days_mask is (B, M, T) true=padded, -> (B, HW, M, T) if padded_days_mask is not None: - pad = padded_days_mask[:, None, :, :].expand(x.shape[0], H * W, M, T) + pad = padded_days_mask[:, None, :, :].expand(B, H * W, M, T) day_logits = day_logits.masked_fill(pad, float("-inf")) - day_w = torch.softmax(day_logits, dim=-1) + day_w = torch.softmax(day_logits, dim=-1) # turns inf to 0 month_tokens = (seq * day_w.unsqueeze(-1)).sum(dim=3) # (B, HW, M, C) # Cross-month attention at each spatial location @@ -222,10 +225,10 @@ def forward(self, x, M, T, H, W, padded_days_mask=None): z = z + attn_out z = z + self.month_ffn(z) - # Back to flattened tokens with month kept - z = rearrange(z, "(b s) m c -> b s m c", b=x.shape[0], s=H * W) - out = rearrange(z, "b (h w) m c -> b (m h w) c", h=H, w=W) - return out # (B, M*H*W, C) C: embedding dimension + # Back to (B, M, Hp*Wp, C) + z = z.view(B, Hp * Wp, M, C) + out = z.permute(0, 2, 1, 3) # (B, M, Hp*Wp, C) + return out # (B, M, H*W, C) C: embedding dimension class MonthlyConvDecoder(nn.Module): @@ -293,10 +296,10 @@ def __init__( # Refinement block: a small conv layers to smooth patch boundaries self.refine = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), - nn.BatchNorm2d(out_channels), + nn.GroupNorm(num_groups=8, num_channels=out_channels), nn.GELU(), nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), - nn.BatchNorm2d(out_channels), + nn.GroupNorm(num_groups=8, num_channels=out_channels), nn.GELU(), ) @@ -314,18 +317,18 @@ def forward(self, latent, M, out_H, out_W, land_mask=None): M: Number of months (temporal patches) out_H: Target output height (must be divisible by patch_h) out_W: Target output width (must be divisible by patch_w) - land_mask: Optional boolean tensor of shape (out_H, out_W). Values set to True + land_mask: Optional boolean tensor of shape (B, out_H, out_W). Values set to True will be masked out (set to 0) in the output (only ocean pixels exist). Returns: Tensor of shape (B, M, out_H, out_W) representing the monthly variable e.g. SST. """ - B, MHW, C = latent.shape + B, M, Np, C = latent.shape Hp = out_H // self.patch_h Wp = out_W // self.patch_w - assert MHW == M * Hp * Wp, f"Token mismatch: got {MHW}, expected {M * Hp * Wp}" + assert Np == Hp * Wp, f"Token mismatch: got {Np}, expected {Hp * Wp}" # transforms the latent tensor from sequence format to image format for - # convolution operations; (B, M*Hp*Wp, C) -> (B*M, C, Hp, Wp) + # convolution operations; out = latent.view(B, M, Hp, Wp, C).permute(0, 1, 4, 2, 3).contiguous() out = out.view(B * M, C, Hp, Wp) @@ -349,7 +352,7 @@ def forward(self, latent, M, out_H, out_W, land_mask=None): # Mask out land areas if land_mask is provided if land_mask is not None: - out = out.masked_fill(land_mask.bool()[None, None, :, :], 0.0) + out = out.masked_fill(land_mask.bool()[:, None, :, :], 0.0) return out # (B, M, out_H, out_W) @@ -500,10 +503,11 @@ def __init__( patch_size=(1, 4, 4), max_days=31, max_months=12, - hidden=128, + num_months=12, + hidden=256, overlap=1, - max_H=1024, - max_W=1024, + max_H=256, + max_W=256, spatial_depth=2, spatial_heads=4, ): @@ -515,6 +519,7 @@ def __init__( patch_size: Tuple of (T, H, W) patch sizes for temporal and spatial patching max_days: Maximum number of days for temporal positional encoding max_months: Maximum number of months for temporal positional encoding + num_months: Number of months to predict (output channels in decoder) hidden: Hidden dimension used in the decoder overlap: Overlap for deconvolution in the decoder max_H: Maximum spatial height for 2D positional encoding @@ -541,7 +546,7 @@ def __init__( patch_w=patch_size[2], hidden=hidden, overlap=overlap, - num_months=max_months, + num_months=num_months, ) self.patch_size = patch_size @@ -552,7 +557,7 @@ def forward(self, daily_data, daily_mask, land_mask_patch, padded_days_mask=None daily_data: Tensor of shape (B, C, M, T, H, W) containing daily data, where C is the number of channels (e.g., 1 for SST) daily_mask: Boolean tensor of same shape as daily_data indicating missing values - land_mask_patch: Boolean tensor of shape (H, W) to mask land areas in the output + land_mask_patch: Boolean tensor of shape (B, H, W) to mask land areas in the output padded_days_mask: Optional boolean tensor of shape (B, M, T) indicating which day tokens are padded (True for padded tokens). Used to mask out padded tokens in temporal attention. Returns: @@ -574,18 +579,6 @@ def forward(self, daily_data, daily_mask, land_mask_patch, padded_days_mask=None ) assert T % self.patch_size[0] == 0, "T must be divisible by patch size" - # Step 1: Encode spatio-temporal patches - # each month independently by folding M into batch - daily_data_reshaped = daily_data.reshape(B * M, C, T, H, W) - daily_mask_reshaped = daily_mask.reshape(B * M, C, T, H, W) - latent = self.encoder( - daily_data_reshaped, daily_mask_reshaped - ) # (B*M, N_patches, embed_dim) - - # Step 2: Aggregate temporal information for each spatial patch - # latent -> (B, M*Np, embed_dim) to match the aggregator input x: (B, M*Tp*Hp*Wp, embed_dim) - latent = latent.reshape(B, M * Np, -1) - if padded_days_mask is not None and self.patch_size[0] > 1: B, M, T_days = padded_days_mask.shape if T_days % self.patch_size[0] != 0: @@ -596,23 +589,45 @@ def forward(self, daily_data, daily_mask, land_mask_patch, padded_days_mask=None B, M, T_days // self.patch_size[0], self.patch_size[0] ).all(dim=-1) # (B, M, Tp) + # Step 1: Encode spatio-temporal patches + # each month independently by folding M into batch + # encoder input shape = (B, C, T, H, W) where C is channel. + # encoder output shape = (B, N_patches, embed_dim) + # so M is folded into B, and T, H, W are the spatio-temporal dimensions to be patched. + daily_data_reshaped = daily_data.reshape(B * M, C, T, H, W) + daily_mask_reshaped = daily_mask.reshape(B * M, C, T, H, W) + + latent = self.encoder( + daily_data_reshaped, daily_mask_reshaped + ) # (B*M, N_patches, embed_dim) + + # Step 2: Aggregate temporal information for each spatial patch + # temporal input shape = (B, M*T*H*W, C), C: embedding dimension + # temporal output shape = (B, M, H*W, C) C: embedding dimension + embed_dim = latent.shape[-1] + latent = latent.view(B, M, Tp, Hp, Wp, embed_dim) + agg_latent = self.temporal( latent, M, Tp, Hp, Wp, padded_days_mask=padded_days_mask - ) # (B, M*Hp*Wp, embed_dim) + ) # (B, M, Hp*Wp, embed_dim) # Step 3: Add spatial positional encodings and mix spatial features - E = agg_latent.shape[-1] - agg_latent = agg_latent.view(B, M, Hp * Wp, E) + # spatial PE output shape = (Hp, Wp, embed_dim) pe = ( self.spatial_pe(Hp, Wp).to(agg_latent.device).to(agg_latent.dtype) - ) # (Hp*Wp, E) - x = agg_latent + pe[None, None, :, :] + ) # (Hp, Wp, E) + x = agg_latent + pe[None, None, :, :] # (B, M, Hp*Wp, E) # Step 4: Spatial mixing with Transformer - x = x.view(B * M, Hp * Wp, E) - x = self.spatial_tr(x) # (B*M, Hp*Wp, E) - x = x.view(B, M * Hp * Wp, E) # back to (B, M*Hp*Wp, E) + # spatial transformer input shape = (B, N, C), output shape = (B, N, C) C: embedding dimension + # M is folded in B. + C = x.shape[-1] + x = x.reshape(B * M, Hp * Wp, C) + x = self.spatial_tr(x) + x = x.view(B, M, Hp * Wp, C) # Step 5: Decode to full-resolution 2D map + # decoder input shape is (B, M*Hp*Wp, C), C: embedding dimension + # decoder output shape is (B, M, H, W) monthly_pred = self.decoder(x, M, H, W, land_mask_patch) # (B, M, H, W) return monthly_pred diff --git a/climanet/utils.py b/climanet/utils.py index 558b0bb..aa6cebf 100644 --- a/climanet/utils.py +++ b/climanet/utils.py @@ -133,7 +133,7 @@ def pred_to_numpy(pred, orig_H=None, orig_W=None, land_mask=None): """ pred: (B, M, H_pad,W_pad) or (B, H, W) torch tensor orig_H/W: original sizes before padding (optional) - land_mask: (H_pad,W_pad) or (H,W) bool; if given, land will be set to NaN + land_mask: (B, H_pad,W_pad) or (B, H,W) bool; if given, land will be set to NaN returns: (H,W) numpy array """ # crop to original size if provided @@ -145,6 +145,8 @@ def pred_to_numpy(pred, orig_H=None, orig_W=None, land_mask=None): # set land to NaN (broadcast mask across batch) if land_mask is not None: pred = pred.clone().to(torch.float32) - pred[:, :, land_mask.bool()] = float("nan") + land_mask = land_mask.bool() + land_mask = land_mask.unsqueeze(1) # (B, H,W) -> (B, 1, H, W) for broadcasting + pred = torch.where(land_mask, torch.full_like(pred, float("nan")), pred) return pred.detach().cpu().numpy() diff --git a/docs/examples.md b/docs/examples.md index 1949620..2abc3f0 100644 --- a/docs/examples.md +++ b/docs/examples.md @@ -6,3 +6,54 @@ We provide an example of how to use the `st_encoder_decoder` module to predict monthly sea surface temperature (SST) using a spatio-temporal encoder-decoder architecture. The example is implemented in a Jupyter notebook, which can be found in the `notebooks` directory. + +### Setting patch sizes + +In the example notebook, there are two patch sizes that need to be set: the +spatial patch size in `SpatioTemporalModel` and the spatial patch size in +`STDataset`. These are two different patch sizes with different purposes. Here +we called them `model_patch_size` and `dataset_patch_size` and explained what to +consider when setting these two patch sizes. + +- model_patch_size: this is used in `VideoEncoder` where a video is split into + non-overlapping spatio-temporal patches using a 3D convolution. The patch size + should be set based on the spatial scale of the input data and the desired + level of spatial abstraction. A larger patch size will capture more spatial + context and fits in memory but may also lead to a loss of fine-grained + details. A smaller patch size will capture finer details with higher costs but + may also lead to a loss of broader context. + +- dataset_patch_size: this is used in `STDataset` where the input data is split + into (non-overlapping) spatial patches to manage memory in training and + inference. The overlapping patches is disable because the loss function is + computed on each patch icluding gaps. Otherwise, some pixels will be included + in loss computation multiple times. The patch size should be set based on the + available computational resources and spatial variability of the input data. + The `dataset_patch_size` should be divisible by `model_patch_size`. We have to + make sure that data is represntive enough for training purposes. Note that + large `dataset_patch_size` might lead to memory issues during training and + inference. During inference on a larger spatial extent, you'll need to handle + stitching the patches. + +- spatial extent of input data: the input data might be used for train_test + split or for inference. If a model is trained on a specific + `dataset_patch_size`, the same `dataset_patch_size` should be used for + inference. If the spatial extent of the input data is larger than the + `dataset_patch_size`, the dataloader can be used to split the input data into + patches in inference and the results can be stitched together to get the final + prediction.Also, you may need to preprocess the predictions for + edge effect because of non-overlapping patches. + +! Note: It is better to have larger `dataset_patch_size` and smaller `model_patch_size`. + +- Hyperparameters: In the example notebook, we didn't set the hyperparameters + based on any tuning or training. These parameters especially + `model_patch_size`, `dataset_patch_size`, `batch_size`, `overlap`, and `number + of epochs` can affect the model's performance. Note that the number of batches + should be always larger than 1 to avoid overfitting. + +- accumulation_step: in training loop we use `accumulation_step`. Gradient +accumulation is a technique to simulate a larger batch size when memory is +limited. `batch_size` is the number of samples processed before one gradient +update.Start with accumulation_steps = 1 (no accumulation) Adjust based on +training behavior i.e. noisy predictions or overfitting. diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb index 83494a1..c6d2e0a 100644 --- a/notebooks/example.ipynb +++ b/notebooks/example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "11ad68b2-7502-4dc4-8b78-d0a4fb53255d", "metadata": {}, "outputs": [], @@ -56,27 +56,27 @@ { "cell_type": "code", "execution_count": 3, - "id": "82bc2879-b788-492e-a0c0-53a35896a9d8", + "id": "11d14431-a9f1-4cb6-a18e-b92124f55209", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(60, 160, 400) (2, 160, 400)\n" + "(60, 160, 160) (2, 160, 160)\n" ] } ], "source": [ "# coordinates of subset\n", - "lon_subset = slice(-50, 50)\n", - "lat_subset = slice(-20, 20)\n", + "lon_subset = slice(-50, -10)\n", + "lat_subset = slice(-30, 10)\n", "\n", "daily_subset = daily_data.sel(lon=lon_subset, lat=lat_subset)\n", "monthly_subset = monthly_data.sel(lon=lon_subset, lat=lat_subset)\n", "lsm_subset = lsm_mask.sel(lon=lon_subset, lat=lat_subset) # True=Land\n", "\n", - "print(daily_subset[\"ts\"].shape, monthly_subset[\"ts\"].shape)" + "print(daily_subset[\"ts\"].shape, monthly_subset[\"ts\"].shape) # (time, lat, lon)" ] }, { @@ -89,7 +89,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "mean: [299.8475 300.13306], std: [1.9400501 2.0374947]\n" + "mean: [299.9357 300.31335], std: [1.187207 1.2649659]\n" ] } ], @@ -109,21 +109,6 @@ "## Create dataset" ] }, - { - "cell_type": "code", - "execution_count": 6, - "id": "31646135", - "metadata": {}, - "outputs": [], - "source": [ - "dataset = STDataset(\n", - " daily_da=daily_subset[\"ts\"],\n", - " monthly_da=monthly_subset[\"ts\"],\n", - " land_mask=lsm_subset[\"lsm\"],\n", - " patch_size=(80, 80),\n", - ")" - ] - }, { "cell_type": "markdown", "id": "8b69667c-18f9-4f2b-b7ff-0f737a6e1543", @@ -134,14 +119,16 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "91459025-ab92-45d9-9e94-d091fe09698e", + "execution_count": 33, + "id": "bcc04777-5235-4ef3-81bd-2bdcafd8baaa", "metadata": {}, "outputs": [], "source": [ "# create the model\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", - "model = SpatioTemporalModel(embed_dim=128, patch_size=(1, 2, 2), overlap=2, max_months=2).to(device)\n", + "patch_size = (1, 4, 4)\n", + "overlap = 1\n", + "model = SpatioTemporalModel(patch_size=patch_size, overlap=overlap, num_months=2).to(device)\n", "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n", "decoder = model.decoder\n", "\n", @@ -150,45 +137,78 @@ " decoder.scale.copy_(torch.from_numpy(std) + 1e-6) # small epsilon to avoid zero" ] }, + { + "cell_type": "markdown", + "id": "945ec311-53b3-4cac-a1e3-d16f4508e7a7", + "metadata": {}, + "source": [ + "### Start training loop" + ] + }, { "cell_type": "code", - "execution_count": 8, - "id": "3bfbc09b-0b0b-431f-b185-f89a2adc3c72", + "execution_count": 34, + "id": "766cdd9d-8a97-42f0-988f-cf0c003836d2", "metadata": {}, "outputs": [], "source": [ + "dataset = STDataset(\n", + " daily_da=daily_subset[\"ts\"],\n", + " monthly_da=monthly_subset[\"ts\"],\n", + " land_mask=lsm_subset[\"lsm\"],\n", + " patch_size=(patch_size[1]*20, patch_size[2]*20), # based on the patch_size in model\n", + ")\n", + "\n", "# create dataloader\n", "dataloader = DataLoader(\n", " dataset,\n", - " batch_size=1,\n", + " batch_size=2, \n", " shuffle=True,\n", " pin_memory=False,\n", ")" ] }, { - "cell_type": "markdown", - "id": "945ec311-53b3-4cac-a1e3-d16f4508e7a7", + "cell_type": "code", + "execution_count": 35, + "id": "e64d64b9-06b6-4284-956e-1e9ca0ecfeec", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2, 1, 2, 31, 80, 80])\n", + "torch.Size([2, 1, 2, 31, 80, 80])\n" + ] + } + ], "source": [ - "### Start training loop" + "for batch in dataloader:\n", + " print(batch[\"daily_patch\"].shape)" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "d2496468-7d5a-4f1a-9bf1-13e8fd4bad1f", + "execution_count": 36, + "id": "eb77d5be-a844-4bd0-bf38-4865ac1ca78e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The loss is 1.3227499723434448 at epoch 0\n", - "The loss is 0.25537195801734924 at epoch 20\n", - "No improvement for 10 epochs, stopping early at epoch 21.\n", + "Epoch 0: best_loss = 1.048081\n", + "Epoch 20: best_loss = 0.968199\n", + "Epoch 40: best_loss = 0.730395\n", + "Epoch 60: best_loss = 0.601687\n", + "Epoch 80: best_loss = 0.493798\n", + "Epoch 100: best_loss = 0.377198\n", + "Epoch 120: best_loss = 0.263445\n", + "Epoch 140: best_loss = 0.196352\n", + "No improvement for 10 epochs, stopping early at epoch 159.\n", "training done!\n", - "1.358122706413269\n" + "0.16787965595722198\n" ] } ], @@ -197,52 +217,74 @@ "patience = 10 # stop if no improvement for epochs\n", "counter = 0\n", "\n", + "# Effective batch size = batch_size (fit in memory) * accumulation_steps\n", + "accumulation_steps = 2\n", + "\n", "# Training loop with DataLoader\n", "model.train()\n", - "for epoch in range(101):\n", - " for batch in dataloader:\n", - " # Initialize gradients\n", - " optimizer.zero_grad()\n", - "\n", + "for epoch in range(501):\n", + " epoch_loss = 0.0\n", + " \n", + " optimizer.zero_grad()\n", + " \n", + " for i, batch in enumerate(dataloader):\n", " # Get batch data\n", " daily_batch = batch[\"daily_patch\"]\n", " daily_mask = batch[\"daily_mask_patch\"]\n", " monthly_target = batch[\"monthly_patch\"]\n", - " land_mask = batch[\"land_mask_patch\"][0, ...] # same for all batches\n", + " land_mask = batch[\"land_mask_patch\"]\n", " padded_days_mask = batch[\"padded_days_mask\"]\n", "\n", " # Batch prediction\n", - " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask)\n", + " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask) # (B, M, H, W)\n", " \n", " # Mask out land pixels\n", - " ocean = (~land_mask).to(pred.device) # (H, W) bool\n", - " ocean = ocean[None, None, :, :] # (1, 1, H, W) broadcast over (B, M)\n", - " \n", - " loss = torch.nn.functional.l1_loss(pred, monthly_target, reduction=\"none\") * ocean\n", + " ocean = (~land_mask).to(pred.device).unsqueeze(1).float() # (B, M=1, H, W) bool \n", + " loss = torch.nn.functional.l1_loss(pred, monthly_target, reduction=\"none\") \n", + " loss = loss * ocean\n", + " \n", + " num = loss.sum(dim=(-2, -1)) # (B, M)\n", + " denom = ocean.sum(dim=(-2, -1)).clamp_min(1) # (B, 1)\n", " \n", - " # Normalize per month (avoid division by zero)\n", - " loss_per_month = loss.sum(dim=(-2, -1)) / ocean.sum(dim=(-2, -1))\n", + " loss_per_month = num / denom \n", " loss = loss_per_month.mean()\n", "\n", - " loss.backward()\n", - " optimizer.step()\n", + " # Scale loss for gradient accumulation\n", + " scaled_loss = loss / accumulation_steps\n", + " scaled_loss.backward()\n", + " \n", + " # Track unscaled loss for logging\n", + " epoch_loss += loss.item()\n", "\n", + " # Update weights every accumulation_steps batches\n", + " if (i + 1) % accumulation_steps == 0:\n", + " optimizer.step()\n", + " optimizer.zero_grad()\n", + " \n", + " # Handle remaining gradients if num_batches is not divisible by accumulation_steps\n", + " if (i + 1) % accumulation_steps != 0:\n", + " optimizer.step()\n", + " optimizer.zero_grad()\n", + " \n", + " # Calculate average epoch loss\n", + " avg_epoch_loss = epoch_loss / (i + 1)\n", + " \n", " # Early stopping check\n", - " if loss.item() < best_loss:\n", - " best_loss = loss.item()\n", - " counter = 0 # reset counter if improved\n", - " if epoch % 20 == 0:\n", - " print(f\"The loss is {best_loss} at epoch {epoch}\")\n", + " if avg_epoch_loss < best_loss:\n", + " best_loss = avg_epoch_loss\n", + " counter = 0\n", " else:\n", " counter += 1\n", - " if counter >= patience:\n", - " print(\n", - " f\"No improvement for {patience} epochs, stopping early at epoch {epoch}.\"\n", - " )\n", - " break\n", + " \n", + " if epoch % 20 == 0:\n", + " print(f\"Epoch {epoch}: best_loss = {best_loss:.6f}\")\n", + " \n", + " if counter >= patience:\n", + " print(f\"No improvement for {patience} epochs, stopping early at epoch {epoch}.\")\n", + " break\n", "\n", "print(\"training done!\")\n", - "print(loss.item())" + "print(best_loss)" ] }, { @@ -255,7 +297,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 37, "id": "bda9f068", "metadata": {}, "outputs": [ @@ -263,34 +305,45 @@ "name": "stdout", "output_type": "stream", "text": [ - "torch.Size([1, 1, 2, 31, 160, 400]) torch.Size([1, 1, 2, 31, 160, 400]) torch.Size([1, 2, 160, 400]) torch.Size([160, 400]) torch.Size([1, 2, 31])\n" + "torch.Size([1, 1, 2, 31, 80, 80]) torch.Size([1, 1, 2, 31, 80, 80]) torch.Size([1, 2, 80, 80]) torch.Size([1, 80, 80]) torch.Size([1, 2, 31])\n" ] } ], "source": [ - "dataset_pred = STDataset(\n", - " daily_da=daily_subset[\"ts\"],\n", - " monthly_da=monthly_subset[\"ts\"],\n", - " land_mask=lsm_subset[\"lsm\"],\n", - " patch_size=(daily_subset.sizes[\"lat\"], daily_subset.sizes[\"lon\"]),\n", - ")\n", - "dataloader_pred = DataLoader(\n", - " dataset_pred,\n", - " batch_size=len(dataset_pred),\n", + "# one batch from training data\n", + "dataloader = DataLoader(\n", + " dataset,\n", + " batch_size=1,\n", + " shuffle=False,\n", " pin_memory=False,\n", ")\n", - "full_batch = next(iter(dataloader_pred))\n", - "daily_batch = full_batch[\"daily_patch\"]\n", - "daily_mask = full_batch[\"daily_mask_patch\"]\n", - "monthly_target = full_batch[\"monthly_patch\"]\n", - "land_mask = full_batch[\"land_mask_patch\"][0, ...] # same for all batches\n", - "padded_days_mask = full_batch[\"padded_days_mask\"]\n", + "\n", + "one_batch = next(iter(dataloader))\n", + "daily_batch = one_batch[\"daily_patch\"]\n", + "daily_mask = one_batch[\"daily_mask_patch\"]\n", + "monthly_target = one_batch[\"monthly_patch\"]\n", + "land_mask = one_batch[\"land_mask_patch\"]\n", + "padded_days_mask = one_batch[\"padded_days_mask\"]\n", + "lat_batch = one_batch[\"lat_patch\"]\n", + "lon_batch = one_batch[\"lon_patch\"]\n", "print(daily_batch.shape, daily_mask.shape, monthly_target.shape, land_mask.shape, padded_days_mask.shape)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 38, + "id": "1fe7425a-5ab8-423b-8130-1311cd098077", + "metadata": {}, + "outputs": [], + "source": [ + "model.eval()\n", + "with torch.no_grad():\n", + " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, "id": "15d5fbee", "metadata": {}, "outputs": [ @@ -298,51 +351,56 @@ "name": "stdout", "output_type": "stream", "text": [ - "(2, 160, 400)\n" + "(2, 80, 80)\n" ] } ], "source": [ - "model.eval()\n", - "with torch.no_grad():\n", - " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask)\n", - "\n", "monthly_prediction = pred_to_numpy(pred, land_mask=land_mask)[0]\n", "print(monthly_prediction.shape)" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "e88ecbc0", + "execution_count": 40, + "id": "ee2e5efb-d572-4162-95a8-9a299eaa3a7d", "metadata": {}, "outputs": [], "source": [ - "monthly_subset[\"ts_pred\"] = (\n", - " (\"time\", \"lat\", \"lon\"),\n", - " monthly_prediction, # remove batch dimensions\n", - ")" + "### Creat a xarrray dataset\n", + "data_vars = {\n", + " \"ts\": ((\"time\", \"lat\", \"lon\"), monthly_target[0].numpy()),\n", + " \"ts_pred\": ((\"time\", \"lat\", \"lon\"), monthly_prediction),\n", + "}\n", + "\n", + "coords = {\n", + " \"time\": monthly_subset[\"time\"].values,\n", + " \"lat\": lat_batch[0],\n", + " \"lon\": lon_batch[0],\n", + "}\n", + "\n", + "ds = xr.Dataset(data_vars=data_vars, coords=coords)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 41, "id": "e581aa17-3916-47be-a1b6-447015f3f3da", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHHCAYAAACvJxw8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgkRJREFUeJzt3Xl8E3X+P/BXkl60pS1HoSi3KJcoiApFV0ERUUBdz10PwEVQrKCACngLYlFcXE/Eg2MVL1RWRVepghcWcVlQQajiiiBSQIEWCk3T5PP7g2/zI5lX02kT2ia8no9HHtpPZz5zZEI+nXnNexzGGAMRERERoZx1vQIiIiIi9ZkGSyIiIiIhaLAkIiIiEoIGSyIiIiIhaLAkIiIiEoIGSyIiIiIhaLAkIiIiEoIGSyIiIiIhaLAkIiIiEoIGS1IvtW3bFsOHD6/r1RAREdFgSerOl19+ifvuuw979uyp61WpVV9//TVuuukmdO3aFSkpKWjdujUuv/xy/PDDD3T69evXY+DAgUhNTUXjxo1xzTXXYOfOnQHTbNiwAbfffju6d++Ohg0bokWLFhg0aBD+85//0D63bt2Kyy+/HBkZGUhLS8OFF16I//3vf7a3wefz4eGHH0a7du2QlJSEE044Aa+88oplupUrV+LGG29Ez549ER8fD4fDYXsZFaZNm4YLLrgAzZs3h8PhwH333Rdy+tdeew3Z2dlISUlBRkYG+vTpg6VLlwIA+vbtC4fDUeWrYhlLlizBiBEjcPzxx8PlcqFt27YRW89gDz74IHr37o3MzEwkJSXh2GOPxS233GJ5rwH7+z+Ud955ByeddBKSkpLQunVr3HvvvSgvL7dMt2fPHowaNQqZmZlISUlBv3798N///rdayxKJekakjsyYMcMAMD///LPld6WlpaasrKz2V6oWXHLJJSYrK8uMGTPGPPfcc2bq1KmmefPmJiUlxXz33XcB027ZssU0bdrUHHPMMeaxxx4z06ZNM40aNTInnniicbvd/ukmTJhgMjIyzIgRI8zs2bPNww8/bI455hjjcrlMXl5eQJ979+41xx57rGnWrJl56KGHzMyZM02rVq1My5Ytze+//25rGyZNmmQAmJEjR5pnn33WDBo0yAAwr7zySsB09957r4mPjzc9e/Y0xx13nKnJPzkATFZWljn33HMNAHPvvfdWOu29995rHA6Hueyyy8wzzzxjnnjiCXP99debf/7zn8YYY5YsWWJefPFF/2vs2LEGgLnjjjsC2r/55htjjDHDhg0zSUlJpk+fPqZly5amTZs2EVlP5uKLLzbXX3+9efTRR83zzz9vJkyYYNLS0kyHDh3Mvn37Aqa1u/8r8/777xuHw2H69etnnn32WTNmzBjjdDrNDTfcEDCd1+s1ffr0MSkpKea+++4zTz75pOnSpYtp2LCh+eGHH6q1fSLRTIMlqTOhBkuxbPny5QEDHWOM+eGHH0xiYqK56qqrAtpHjx5tGjRoYH755Rd/W15engFgZs+e7W/7z3/+Y/bu3Rsw7++//24yMzPNaaedFtD+0EMPGQBm5cqV/rb169cbl8tlJk+eXOX6//rrryY+Pt7k5OT423w+n/nTn/5kWrZsacrLy/3thYWFZv/+/cYYY3Jycmo0WKo4Pnbu3BlyEJKfn28cDoeZOXOm7b4XLlxoAJhly5bR32/dutU/aB80aFDIwZLd9ayON954wzIIqs7+r0yXLl3MiSeeaDwej7/tzjvvNA6Hw6xfv97f9tprrxkAZuHChf62HTt2mIyMDPPXv/413M0TiRq6DCd14r777sNtt90GAGjXrp3/8semTZsAWDNL8+bNg8PhwBdffIGxY8ciMzMTGRkZuP7661FWVoY9e/Zg6NChaNSoERo1aoTbb78dxpiAZfp8PvzjH/9A165dkZSUhObNm+P666/H7t27a2uzAQB9+vRBQkJCQNuxxx6Lrl27Yv369QHtb775JgYPHozWrVv72/r374/jjjsOr7/+ur+tZ8+eSE1NDZi3SZMm+NOf/mTp84033sApp5yCU045xd/WqVMnnH322QF9Vubtt9+Gx+PBjTfe6G9zOBwYPXo0fv31V+Tn5/vbmzdvjgYNGlTZZyihLn0d6h//+AeysrJw8803wxiDffv2hbVcADjqqKMQHx9va1q767l//35s2LABv//+u+0+D71UXZ39X1RUhA0bNqCoqMjf9v333+P777/HqFGjEBcX52+/8cYbYYzBG2+84W9744030Lx5c1x88cX+tszMTFx++eV4++234Xa7bW2zSLTTYEnqxMUXX4y//vWvAIBHH30UL774Il588UVkZmaGnG/MmDH48ccfcf/99+OCCy7As88+i7vvvhtDhgyB1+vFgw8+iNNPPx0zZszAiy++GDDv9ddfj9tuuw2nnXYaHnvsMVx77bVYsGABzj33XHg8npDLdbvd+P333229asIYg+3bt6Np06b+tq1bt2LHjh04+eSTLdOfeuqpWL16dZX9FhYWBvTp8/nw7bffVtrnTz/9hL1794bsc/Xq1UhJSUHnzp0t81f8vi58/PHHOOWUU/D4448jMzPTn9168skn62R9KrNy5Up07tyZrpcxBr///jsKCwvx+eefY+zYsXC5XOjbt69/murs/0WLFqFz585YtGhRwPwALMfAUUcdhZYtWwbMv3r1apx00klwOgO/Kk499VTs37+/0pydSKyJq3oSkcg74YQTcNJJJ+GVV17BRRddZPuv8ubNm+P999+Hw+HAjTfeiI0bN2LGjBm4/vrrMWvWLADAqFGj0LZtW8yZMwdDhw4FAHzxxRd4/vnnsWDBAlx55ZX+/vr164eBAwdi4cKFAe3BXnnlFVx77bW21jH4jJYdCxYswNatWzFlyhR/27Zt2wAALVq0sEzfokUL7Nq1C263G4mJibTPzz//HPn5+bjrrrv8bRXzVNYnAPz222/o2LFjpeu6bds2f4i5svlr2+7du/H7779j+fLlWLp0Ke699160bt0ac+fOxZgxYxAfH4/rr7++1terurZv3x7w3rRs2RIvv/wyOnXq5G8Ld/9XdVwdOv+2bdtwxhln0OkqltWtW7eqNksk6mmwJFFlxIgRAV8SvXr1Qn5+PkaMGOFvc7lcOPnkk7Fq1Sp/28KFC5Geno5zzjkn4OxPxeWrZcuWhRwsnXvuucjLy4vw1hy0YcMG5OTkIDs7G8OGDfO3HzhwAADoYCgpKck/Dfv9jh07cOWVV6Jdu3a4/fbbq91nKJUt0+78h0PFJbc//vgDr776Kq644goAwKWXXopu3brhgQceqDeDpb59+1Y6oG7cuDHy8vJQWlqK1atX46233rJcTqzO/h8+fLilBEdVx0BxcXGNliUSyzRYkqhyaHYHANLT0wEArVq1srQfmkX68ccfUVRUhGbNmtF+d+zYEXK5LVq0oH+Jh6uwsBCDBg1Ceno63njjDbhcLv/vKrI+LBdSWloaMM2hSkpKMHjwYOzduxdffPFFQJapOn0WFhYG/D49PR0NGjRAgwYNqr1OValsWXZVTBsfH49LL73U3+50OnHFFVfg3nvvxebNmy3HT32TkJCA/v37AwAGDx6Ms88+G6eddhqaNWuGwYMHA0DY+7+qY+DQ+Q/Hey0SjTRYkqhy6GCiqvZD/3r3+Xxo1qwZFixYQOevKit14MCBgJBsKFlZWbamKyoqwnnnnYc9e/bg888/x1FHHRXw+4rBWcVlk0Nt27YNjRs3tvzVX1ZWhosvvhjffvstPvzwQxx//PEBv6+Yp7I+AfjXI3hwOHfuXAwfPhwtWrTAsmXLYIwJOMsXPH91VLYsuxo3boykpCRkZGRYjoWKAfLu3bvr/WApWJ8+fdCiRQssWLDAP1gKd/8felwF/5Gxbds2f/apYlo7x4pIrNNgSepMTQoU1tQxxxyDjz76CKeddlqN/hp+7bXXIppZKi0txZAhQ/DDDz/go48+QpcuXSzTHH300cjMzKSFJVeuXInu3bsHtPl8PgwdOhQff/wxXn/9dZx55pmW+ZxOJ7p160b7/Oqrr9C+fXs0bNgQACyXHbt27QoA6N69O55//nmsX78+YL2/+uor/++rq7Jl2eV0OtG9e3d8/fXXKCsrC7jbsCKDU9WAuL4qLS0NGKiHu/8rfv+f//wnYGD022+/4ddff8WoUaMCpv3888/h8/kCQt5fffUVkpOTcdxxx4WzaSJRQ3fDSZ1JSUkBgFqp4H355ZfD6/Vi6tSplt+Vl5dXuQ4VmSU7r6p4vV5cccUVyM/Px8KFC5GdnV3ptJdccgkWL16MLVu2+Ns+/vhj/PDDD7jssssCph0zZgxee+01PP300wG3ege79NJL8fXXXwcMmAoKCrB06dKAPvv37x/wqjgjceGFFyI+Ph5PP/20f1pjDJ555hkcffTR6NOnT5X7IFhly6qOK664Al6vF/Pnz/e3lZaWYsGCBejSpUu9OQvCSgeUlJRg//79lmnffPNN7N69O+DOtersf1Y6oGvXrujUqROeffZZeL1ef/usWbPgcDgCLmNeeuml2L59O9566y1/2++//46FCxdiyJAhld5cIBJrdGZJ6kzPnj0BAHfeeSf+8pe/ID4+HkOGDPEPoiLpzDPPxPXXX4/c3FysWbMGAwYMQHx8PH788UcsXLgQjz32WMCXRLBIZpYmTJiAd955B0OGDMGuXbvw0ksvBfz+6quv9v//HXfcgYULF6Jfv364+eabsW/fPsyYMQPdunULONP1j3/8A08//TSys7ORnJxs6fPPf/6zf7/eeOONeO655zBo0CDceuutiI+Px8yZM9G8eXNMmDChyvVv2bIlbrnlFsyYMQMejwennHIK/vWvf+Hzzz/HggULAi6D/fLLL/4SDhWDswceeAAA0KZNG1xzzTVVLu/FF1/EL7/84h9MfPbZZ/4+rrnmGrRp0wbAwdIQzz//PHJycvDDDz+gdevW/nnffffdKpfDfPvtt3jnnXcAABs3bkRRUZF/2SeeeCKGDBlS7fVcuXIl+vXrh3vvvdf/SJQff/wR/fv3xxVXXIFOnTrB6XTiP//5D1566SW0bdsWN998s3851dn/ixYtwrXXXmu5rDljxgxccMEFGDBgAP7yl79g7dq1ePLJJ3HdddcFlCS49NJL0bt3b1x77bX4/vvv0bRpUzz99NPwer24//77a7RPRaJSnZTCFPk/U6dONUcffbRxOp0B1bzbtGljhg0b5p9u7ty5BoD5+uuvA+a/9957DQCzc+fOgPZhw4aZlJQUy/KeffZZ07NnT9OgQQPTsGFD061bN3P77beb3377LeLbVpkzzzzTAKj0FWzt2rVmwIABJjk52WRkZJirrrrKFBYWBkwzbNiwkH0GV0nfsmWLufTSS01aWppJTU01gwcPNj/++KPtbfB6vebBBx80bdq0MQkJCaZr167mpZdesky3bNmyStfpzDPPDHt/BVfe3r59uxk2bJhp3LixSUxMNL169TIffPBBpX1XVcG74rhjr0OPz+qsZ8U+ObTC986dO82oUaNMp06dTEpKiklISDDHHnusueWWWyzHtjH293/F+s+dO9fyu0WLFpnu3bubxMRE07JlS3PXXXfRRwzt2rXLjBgxwjRp0sQkJyebM8880/I5FIl1DmNqUBRGRERE5AihzJKIiIhICBosiYiIiISgwZKIiIhICFEzWJo2bRr69OmD5ORkZGRk0Gk2b96MQYMGITk5Gc2aNcNtt92G8vLykP3u2rULV111FdLS0pCRkYERI0ZE5GnlIiIiEhuiZrBUVlaGyy67DKNHj6a/93q9GDRoEMrKyvDll19i/vz5mDdvHu65556Q/V511VVYt24d8vLysHjxYnz22WcBRdlERETkyBZ1d8PNmzcPt9xyi6WI4L///W8MHjwYv/32G5o3bw4AeOaZZzBx4kTs3LkzoKJvhYoKuF9//bW/6NsHH3yA888/H7/++mu9KWInIiIidSdmilLm5+ejW7du/oEScLDq8ujRo7Fu3Tr06NGDzpORkRFQHbd///5wOp346quv8Oc//5kuy+12Bzxc0ufzYdeuXWjSpEmtPsJDRESiizEGe/fuxVFHHRXwCJlIKy0tRVlZWUT6SkhIQFJSUkT6ilYxM1gqLCwMGCgB8P8c/ETzQ+cJfgp9XFwcGjduXOk8AJCbm6vqtSIiUmNbtmxBy5YtD0vfpaWlaNcmFYU7vFVPbENWVhZ+/vnnI3rAVKeDpUmTJuGhhx4KOc369evRqVOnWlojeyZPnozx48f7fy4qKkLr1q2xZcsWpKWl1eGaiUis+PuGSyxtSQ7rl5/HuCxtpT7rP+1lpC3BGfoGmAouh8/S5vbF25rXZ+ydbd/vs0Yl4sn2+mxGbcu81u31kHUpJ/vPa3M6t9e6D/aXB7bt8wRuV/n+Mnz919n+B1YfDmVlZSjc4cUvq9oirWF4Z6+K9/rQpucmlJWVabBUVyZMmBDwvCKmffv2tvrKysrCypUrA9q2b9/u/11l8+zYsSOgrby8HLt27ap0HgBITEykD5BMS0vTYElEIiIp1fpFnEQu87vIlzjIQMZBBkuJTnsDGTZYYstg7A6WvKS/eIf1i97uYAlksOQw1nmdNgdLTp91Oh8ZLMUHDZbiPPxhw7UR2Uht6EBqw/CW44OiJUAdD5YyMzORmZkZkb6ys7Mxbdo07Nixw39pLS8vD2lpaejSpUul8+zZswerVq3yP9R16dKl8Pl86NWrV0TWS0REpC54jQ/eMG/h8hoyUD4CRU3pgM2bN2PNmjXYvHkzvF4v1qxZgzVr1vhrIg0YMABdunTBNddcg2+++QYffvgh7rrrLuTk5PjPAq1cuRKdOnXC1q1bAQCdO3fGwIEDMXLkSKxcuRLLly/HTTfdhL/85S+6E05ERKKaDyYiL4migPc999yD+fPn+3+uuLtt2bJl6Nu3L1wuFxYvXozRo0cjOzsbKSkpGDZsGKZMmeKfZ//+/SgoKIDH4/G3LViwADfddBPOPvtsOJ1OXHLJJXj88cdrb8NERIjzU7+ztDW0mTHa6bVmS0qMNROU4TxgaXORL8cyWC9BsYxRksNjaWPYupT4SLTBWWpp85LLQnt9DSxtZezyJOEx1q/BvWT/lRrrJTeW2yoqD1yX/+1vGrg8ROYONaldUTNYmjdvHubNmxdymjZt2uD999+v9Pd9+/ZFcFmpxo0b4+WXX47EKoqIiNQbPvgQ7kW08HuIDVEzWBIRERH7vMbAG2bd6XDnjxVRk1kSERERqQs6syQiUov+u7m1pS3Dac36JJPb+tlft26bt+bbzROVkgwPq3eU7LRmb1iZAJb1YVh5ArYuZaTNrlKSMdpPslKMj5QdYLktpyPwTEzDOHfAz2Wu2sssRSKgrYD3QRosiYiIxCAfDLwaLEWELsOJiIiIhKAzSyIiIjFIl+EiR4MlERGRGKS74SJHgyURkcNo068tAn7OJLUSk8gz0Dz0S8oaoGax7SSHtXglKyzJClCChLlTaH/WdS4lXylO+rgM67yuCNfzYf3Zfa6cl0zHimF6yPPiguf1mNA/S3TQYElERCQG+f7vFW4fosGSiIhITPJG4G64cOePFRosiYiIxCCvOfgKtw9R6QARERGJkFmzZuGEE05AWloa0tLSkJ2djX//+9/+35eWliInJwdNmjRBamoqLrnkEmzfvj2gj7Fjx6Jnz55ITExE9+7da3kLOJ1ZEhGJkN+2HmVpS3EG/k3K7i5iYe4ym3chkbw4DSPbxULfrD9Wrdsu1h8LVTMspF1mrHuBVdz2kjYPmddDqoS7afVvawXvcPZLpNVFZqlly5aYPn06jj32WBhjMH/+fFx44YVYvXo1unbtinHjxuG9997DwoULkZ6ejptuugkXX3wxli9fHtDP3/72N3z11Vf49ttvw9yCyNBgSUREJAb54Ahr4FzRR3UMGTIk4Odp06Zh1qxZWLFiBVq2bIkXXngBL7/8Ms466ywAwNy5c9G5c2esWLECvXv3BgA8/vjjAICdO3fWm8GSLsOJiIhISMXFxQEvt9td5TxerxevvvoqSkpKkJ2djVWrVsHj8aB///7+aTp16oTWrVsjPz//cK5+2DRYEhERiUE+E5kXALRq1Qrp6en+V25ubqXL/e6775CamorExETccMMNWLRoEbp06YLCwkIkJCQgIyMjYPrmzZujsLDwMO6J8OkynIhIhKQ7rbkWT1BRxuCn0gOAmxRudJPsSzyZ10OnI0mTMO5qYstlaRYvWZckp7WgZRKsbfE+azFMD01kWbHlsqtH8aS4ptNhfc+cZNsSndbyn43i9lvagnNMwZkol8u6DoeLNwKX4Srm37JlC9LS0vztiYmJlc7TsWNHrFmzBkVFRXjjjTcwbNgwfPrpp2GtR13TYElERERCqri7zY6EhAR06NABANCzZ098/fXXeOyxx3DFFVegrKwMe/bsCTi7tH37dmRlZR2O1Y4YXYYTERGJQRVnlsJ9hcvn88HtdqNnz56Ij4/Hxx9/7P9dQUEBNm/ejOzs7LCXczjpzJKIiEgM8hlH2KUMqjv/5MmTcd5556F169bYu3cvXn75ZXzyySf48MMPkZ6ejhEjRmD8+PFo3Lgx0tLSMGbMGGRnZ/vvhAOAjRs3Yt++fSgsLMSBAwewZs0aAECXLl2QkGAt11AbNFgSERGRiNixYweGDh2Kbdu2IT09HSeccAI+/PBDnHPOOQCARx99FE6nE5dccgncbjfOPfdcPP300wF9XHfddQEZpx49egAAfv75Z7Rt27bWtuVQDmNsVj6TShUXFyM9PR1FRUW2r+mKSHTzFR5naTtgqr6dutRYg8y7fNZAcSkpoJhEgtss4M2ebF9GwtJJJPDMziSwwLjdQpVsuXQ6Uhxyv7GeRSgjBSNLjTWkXUqLSFpDyXaLUpaStt2eFEtbVf2793kw609vHdbvi4rvpE/XHo3UhuGlbfbt9eHM47ce8d9vOrMkIiISg7xw2q6MXnkfAmiwJCIiEpNMBDJLph49vqUu6W44ERERkRB0ZklEpArFv7W2tKU6kyxtTvL3534TWMxwLym+WEpyMywj4yN5J5YJcpGiiuwMg8fm38tOkk9iuSi74h3W7aC3qJNELcsYsYfmsgfuMnYvU7EHDCeSgpuuoHyXJTtF5jlcIlmU8kinwZKIiEgM8honvGEMag/2EaGViXK6DCciIiISgs4siYiIxCAfHLYvR1beh04tARosiYiIxCRlliJHgyURkRrwGGtQ10MC2B4TGPh1se8e8sc7C2nb/eJiIWg2r7VsYyWBZ7J+4dTvCbf2TzBW0JIVpWTLZeFwu/uPF7QMbAsO1od7K7/UDQ2WREREYlBkAt66DAdosCQiIhKTDmaWwnyQri7DAdDdcCIiIiIh6cySiIhIDPJF4NlwuhvuoKgZLE2bNg3vvfce1qxZg4SEBOzZsyfg99988w2mT5+OL774Ar///jvatm2LG264ATfffHPIftu2bYtffvkloC03NxeTJk2K9CaISJTykLA1SMB7H2nz2viySSEVrUvJfCxk7CKZEq+DVcO2hpHDYTeo7HRY1y+BPZ6VdMcqfbO2JKfH0uYiy/WSdU5wWN8zFg6nyDfofm9iwM8HTELAz+Heyl8dyixFTtQMlsrKynDZZZchOzsbL7zwguX3q1atQrNmzfDSSy+hVatW+PLLLzFq1Ci4XC7cdNNNIfueMmUKRo4c6f+5YcOGEV9/ERGR2uSDU3WWIiRqBkv3338/AGDevHn093/7298Cfm7fvj3y8/Px1ltvVTlYatiwIbKysiKyniIiIhJbYjrgXVRUhMaNG1c53fTp09GkSRP06NEDM2bMQHl56Acdut1uFBcXB7xERETqE69xROQlUXRmqbq+/PJLvPbaa3jvvfdCTjd27FicdNJJaNy4Mb788ktMnjwZ27Ztw8yZMyudJzc313+mS0Riyx+/tbS0sUsR+0k+qYzkOxKC8kNsGvZXK3vKPUW+yyL9BWe3SCNbZ5ZtopkqIpy8DdsHHmPvK4/lrNg+2FeeZF1u0LvpDMq7Bf98OHkjEPC2k7k7EtTpmaVJkybB4XCEfG3YsKHa/a5duxYXXngh7r33XgwYMCDktOPHj0ffvn1xwgkn4IYbbsDf//53PPHEE3C73ZXOM3nyZBQVFflfW7ZsqfY6ioiISHSo0zNLEyZMwPDhw0NO0759+2r1+f333+Pss8/GqFGjcNddd1V7nXr16oXy8nJs2rQJHTt2pNMkJiYiMTGR/k5ERKQ+8BknfZxL9frQmSWgjgdLmZmZyMzMjFh/69atw1lnnYVhw4Zh2rRpNepjzZo1cDqdaNasWcTWS0REpLbpMlzkRE1mafPmzdi1axc2b94Mr9eLNWvWAAA6dOiA1NRUrF27FmeddRbOPfdcjB8/HoWFhQAAl8vlH5CtXLkSQ4cOxccff4yjjz4a+fn5+Oqrr9CvXz80bNgQ+fn5GDduHK6++mo0atSorjZVRERE6pGoGSzdc889mD9/vv/nHj16AACWLVuGvn374o033sDOnTvx0ksv4aWXXvJP16ZNG2zatAkAsH//fhQUFMDjOVjALDExEa+++iruu+8+uN1utGvXDuPGjcP48eNrb8NEpM5s+rWFrek8Np+PxcLMdurUxJPu2fkAL+mKBqjJ3CyQzQpVltksXsnq93hthpdZYUm7RS4ZF1kuK0oJWEP5LPTN+mO7jwXBnUEFN+uyKKUP4Yf9ay+OXr85jNEFyXAVFxcjPT0dRUVFSEtLq+vVERGbIj9YsrbF0y/t4GmsbaX0bi7WZv3yLYN1wMOmY3evhTNYsnunV4qzzNLG7jYr9lnvNis11urabN7SoEEKYP8OOX73n3V7t5VlWNqCHfAFrod7nwdPnr7osH5fVHwnzfrvKWiQGt45kQP7yjH6pK+P+O+3mK6zJCIiIhKuqLkMJyIiIvZF5tlwOqcCaLAkIiISk3xwwGfzEnKoPkSDJRE5Qvz461GWNpvPlkc8yfbYzTEFB6tZTogFt+30VR30DIHDXsaIh7mt68LOQbB5S0lOiK0f+6Lm60LaaNjeOh3LJ9nNLLFQujsoUxW8HrX5+BCdWYoc7QURERGREHRmSUREJAZFpiilzqkAGiyJiIjEJJ9xhFW/qqIP0WBJRKLcN5tbWdqSSNHDRBv1jgBehI/VQQIpUedxVP3FwvpysWwO6T/BZrHEeFak0WltY2cNaKaK9Oe0mWWxW3uJz8uKPlr7S2D71Ob2sgKZpT57aTZ3nHW6/b7A/vZ7g4pSkuVJ/afBkoiISAzyReAyXG1WHK/PNFgSERGJQT7jhC/Mu9nCnT9WaC+IiIiIhKAzSyIiIjHIC0dYtbkq+hANlkQkyrEnv7N/4D02+0ti/ZFsOIsts3A0DYfbwE77s4fysm1l6xvPClDS7SIFGWnBSHsP0qWZF7JcD3v4L2mzm6FhWR0W3LbbHyuQuddrfdBvsOAAeW0GvHUZLnK0F0RERERC0JklERGRGORF+JfRVOjgIA2WREREYpAuw0WOBksiEtU85B9zF8mF8GKLJNtk86G2/KGxVsH5IRf5Q5/1xaZjWR/2lz/LNvF8EntAMFsXkkUi+51ljFjeyUWKd9KH15J52YNoXWR7XbR4JSlASdeP5bus0yU5q07CBW+Xz1l752r0IN3I0V4QERERCUFnlkRERGKQgYPexVfdPkSDJRERkZiky3CRo70gIiIiEoLOLIlIzGGh7yQaUiYzk/BxPAlCswC2NaLMpmEBZWsbWzcvK3pJQ9qRvXRCg9ZhLCPSZytY6JsVpbT7UFlehJMV/7Q3XV3xGQd8ZN9Utw/RYElERCQmeeG0PUAM1YfoMpyIiIhISDqzJCIiEoN0GS5yNFgSERGJQT44bT8oOFQfosGSiMSgJFKpmf2TTytdEwks9E3avMbaX3CsPNFhXZNkR7ylzY1ysib2tiuBtJXS+uJWToe1KrWTbFeCsa5LGanCHU/eC/YFHE5gnPXnIvuKVfV2ka/BMhLVZ1XC0+P2W9r2+wL3fnClcy/ZH1L/abAkIiISg7zGQe8UrG4fosGSiIhITFJmKXI0WBIREYlBxjjpA4+r24dosCQiUeR/v7awtDV0kiKPpFCjXckki2QXKy6ZHJR/YdM4SV6HtSU7rFkaVqjSbazZHNuZrZrvuogrM9avKJp3slmU0kP6s4stIzifBFiPPVdQRslLiqNK/afBkoiISAzywhFWcL6iD9FgSUREJCb5TPiZI/pIoCOQLkaKiIiIhKAzSyIiIjHIF4GAd7jzx4qo2QvTpk1Dnz59kJycjIyMDDqNw+GwvF599dWQ/e7atQtXXXUV0tLSkJGRgREjRmDfvn2HYQtEJFzxDuvLLpfD+nLC+vKRF+OEw9bL3nbFkZfL8rLbP9sutv1MRc7l0FcCvJaX02EsL5fDZ3nx9fNZXozd/lwOY3nR6eCzvOz2l+DwWl5JjnLLK9HpCXjFO7yWV23xwRGRl0TRYKmsrAyXXXYZRo8eHXK6uXPnYtu2bf7XRRddFHL6q666CuvWrUNeXh4WL16Mzz77DKNGjYrgmouIiEg0i5rLcPfffz8AYN68eSGny8jIQFZWlq0+169fjw8++ABff/01Tj75ZADAE088gfPPPx+PPPIIjjrqqLDWWUREpK6ognfkRM2ZJbtycnLQtGlTnHrqqZgzZw4MeaZRhfz8fGRkZPgHSgDQv39/OJ1OfPXVV7WxuiIiIodFRWYp3JdE0ZklO6ZMmYKzzjoLycnJWLJkCW688Ubs27cPY8eOpdMXFhaiWbNmAW1xcXFo3LgxCgsLK12O2+2G2+32/1xcXByZDRAREZF6p04HS5MmTcJDDz0Ucpr169ejU6dOtvq7++67/f/fo0cPlJSUYMaMGZUOlmoqNzfXf1lQRGpPq6O3WdpYVW9WSM9JzjKzeC+riM2C1D6bpa6Dp3ORvjym3FZfnkrj5sHLtPKS1WU1dFj1cxbyZeFoj82LFawKN+MlZzUiXa3bY6xV0Vng3AtWPZ28l774gJ9rM9AdzIcIPBtOAW8AdTxYmjBhAoYPHx5ymvbt29e4/169emHq1Klwu91ITEy0/D4rKws7duwIaCsvL8euXbtC5p4mT56M8ePH+38uLi5Gq1ataryeIiIikWYicDeb0WAJQB0PljIzM5GZmXnY+l+zZg0aNWpEB0oAkJ2djT179mDVqlXo2bMnAGDp0qXw+Xzo1atXpf0mJiZW2qeIiEh94DMROLOkgDeAKMosbd68Gbt27cLmzZvh9XqxZs0aAECHDh2QmpqKd999F9u3b0fv3r2RlJSEvLw8PPjgg7j11lv9faxcuRJDhw7Fxx9/jKOPPhqdO3fGwIEDMXLkSDzzzDPweDy46aab8Je//EV3womIiAiAKBos3XPPPZg/f77/5x49egAAli1bhr59+yI+Ph5PPfUUxo0bB2MMOnTogJkzZ2LkyJH+efbv34+CggJ4PB5/24IFC3DTTTfh7LPPhtPpxCWXXILHH3+89jZMRMLyh896ljfJYc0A+WzmfWjChBU5tPnMLC/vMUCcw5qHYevLclIsT8USQQkO63Rum5klL9l+J5nOQ3Jh8U7yXtDcEWlzWLeEFaYsDcoJAUCC021pY3mneLIMdgeYkyw32VlmaWMZqKr6OVzqooL3rFmzMGvWLGzatAkA0LVrV9xzzz0477zzAAClpaWYMGECXn31Vbjdbpx77rl4+umn0bx5c38fmzdvxujRo7Fs2TKkpqZi2LBhyM3NRVxc3Q1ZomawNG/evJA1lgYOHIiBAweG7KNv376WUgKNGzfGyy+/HIlVFBERqTfq4jJcy5YtMX36dBx77LEwxmD+/Pm48MILsXr1anTt2hXjxo3De++9h4ULFyI9PR033XQTLr74YixfvhwA4PV6MWjQIGRlZeHLL7/Etm3bMHToUMTHx+PBBx8Ma1vCETWDJREREanfhgwZEvDztGnTMGvWLKxYsQItW7bECy+8gJdffhlnnXUWgINP3ejcuTNWrFiB3r17Y8mSJfj+++/x0UcfoXnz5ujevTumTp2KiRMn4r777kNCQkJdbFbsFaUUERGRyD4brri4OOB1aK3Byni9Xrz66qsoKSlBdnY2Vq1aBY/Hg/79+/un6dSpE1q3bo38/HwAB4tFd+vWLeCy3Lnnnovi4mKsW7cuwnvIPg2WREREYlDFZbhwXwDQqlUrpKen+1+5ubmVLve7775DamoqEhMTccMNN2DRokXo0qULCgsLkZCQgIyMjIDpmzdv7i8EXVhYGDBQqvh9xe/qii7DiUjMoQFiEnBmoeKGNgLZAC/8yKQ6qv5n1m6By0RSGJHN67G0cPEkuO0JI+PCCjCygpFOm4F5FuZm762L9UewdbGLBZ3dJFgeH3RzQfC2ltdhkcpwbNmyBWlpaf6fQ5XP6dixI9asWYOioiK88cYbGDZsGD799NPaWM3DRoMlERGRGBTJgHdaWlrAYCmUhIQEdOjQAQDQs2dPfP3113jsscdwxRVXoKysDHv27Ak4u7R9+3Z/IeisrCysXLkyoL/t27f7f1dXdBlOREQkBkXyMlxY6+Hzwe12o2fPnoiPj8fHH3/s/11BQQE2b96M7OxsAAeLRX/33XcBT9fIy8tDWloaunTpEva61JTOLImIiEhETJ48Geeddx5at26NvXv34uWXX8Ynn3yCDz/8EOnp6RgxYgTGjx+Pxo0bIy0tDWPGjEF2djZ69+4NABgwYAC6dOmCa665Bg8//DAKCwtx1113IScnp06fnKHBkohEtf0+cisxKRbIiiiyv5o9JNsEUmyRFqpk6xf0kFxWBJE/XJc9zJU95Nba5iLb4CPbwDJbDC1UaXPeBJIBY5kl9hDeeGMzA2UzQcb2M89U2esv0WlNh7EHDFfn95FUF3WWduzYgaFDh2Lbtm1IT0/HCSecgA8//BDnnHMOAODRRx/1F4A+tChlBZfLhcWLF2P06NHIzs5GSkoKhg0bhilTpoS1HeHSYElERCQGGSACD9KtnhdeeCHk75OSkvDUU0/hqaeeqnSaNm3a4P3336/mkg8vDZZERERikB6kGzkKeIuIiIiEoDNLIiIiMUhnliJHgyURiWpl5CnvTp/1n7YkV7mljfGxkEYEvy9YyJhx0jCydeXYdCwcHunLCCz0bbe4ZgILOZPdwopS0oA0WayvFi6csIGEL6hwKCvUWVs0WIocXYYTERERCUFnlkRERGKQzixFjgZLIiIiMcgYB0yYg51w548VugwnIiIiEoLOLIlI1Hjrpx6WthJfuqUtzVVqaWOBX1b5ucxpDYKnwFqpOZnMy2ozB4eyWWg5nqwbC0uz4DatCM6qkDOkqnc8qa5t969qDwlax9ushh0ODwn5u2xWWGeBcY+xfjWyqt5JpIK3Zb6g97G8FgPfPjjCLkoZ7vyxQoMlERGRGKTMUuToMpyIiIhICDqzJCIiEoMU8I4cDZZEJGoUlmdY2pIc1twIK1RZYhIsbV5jPbme5Sy2tHnIdB6SiWEFLdNtnL9nWSRWgDLJYd0uNp1dKeR7kCVqvDYXYTef5KWFNK07ir0/vD82r3U6X1j9WdtKffGWtuAcU7wjMANX7rBXHDUSdBkucjRYEhERiUE6sxQ5yiyJiIiIhKAzSyIiIjHIROAynM4sHaTBkoiISAwyoKW0qt2HaLAkIlGEFR9kXD5SMJIEdFmhwb2+REtbiqPMOi/5FkogBQ5Lg6azxswBJwuLk68p1sY4aYDaXoicBaPjbS6XF+W0rgtr4/2RYL3NY8AuFua2K54UmEwMuuEguDimsi/RSYMlERGRGOSDAw5V8I4IDZZERERikO6GixydERQREREJQWeWRCRqsIeesjZWQLAM1qyLz5CigqTIpctJCkQaa3HBMvJQ23ha5jFoPWxmgrwkJ2X3oblsOg/tjy3X1iJQZvPvb1aAssRnTXPZLSTKHnzrtXlGhOWi7GL5KXfQMZUY9BDmw/9Y4UOWZRxwqChlRGiwJCIiEoOMicDdcLodDoAuw4mIiIiEpDNLIiIiMUgB78jRYElERCQGabAUOVEzWJo2bRree+89rFmzBgkJCdizZ0/A7+fNm4drr72Wzrt9+3Y0a9aM/q5t27b45ZdfAtpyc3MxadKkiKy3iEQOK964nxSRTHRaQ9p7fUm2lsEC3qyNFlYk+Q5P0HROMhHLQ/ACj2QBpMlJwtwsHO5h89pcF8ZuGJgVgnSRAqFJYPvdOq/PaW1jAW8WBC8j+yA4pA3w940VpbSsW9D6hhMory4FvCMnagZLZWVluOyyy5CdnY0XXnjB8vsrrrgCAwcODGgbPnw4SktLKx0oVZgyZQpGjhzp/7lhw4aRWWkRERGJelEzWLr//vsBHDyDxDRo0AANGjTw/7xz504sXbqUDqyCNWzYEFlZWRFZTxERkfpAd8NFTszeDffPf/4TycnJuPTSS6ucdvr06WjSpAl69OiBGTNmoLzcWj9FREQkmhwcLDnCfNX1VtQPUXNmqbpeeOEFXHnllQFnm5ixY8fipJNOQuPGjfHll19i8uTJ2LZtG2bOnFnpPG63G2632/9zcXFxxNZbRERE6pc6HSxNmjQJDz30UMhp1q9fj06dOlWr3/z8fKxfvx4vvvhildOOHz/e//8nnHACEhIScP311yM3NxeJidbgKHAwAF5xWVBEas/u8hRLGwvZOo01LOz2WUO7rAKzM363dTpS/Zs/rd663HgSSq96LqCM/EmfQoLMvD8S5qYBZeu8rFo3DbMTLIDPAsKRDg07WRV32++ZFasSzqLcpSQInuJwkynrhu6Gi5w6HSxNmDABw4cPDzlN+/btq93v888/j+7du6Nnz57VnrdXr14oLy/Hpk2b0LFjRzrN5MmTAwZZxcXFaNWqVbWXJSIicrgY0Jslq92H1PFgKTMzE5mZmRHtc9++fXj99deRm5tbo/nXrFkDp9MZ8g66xMTESs86iYiISGyJmszS5s2bsWvXLmzevBlerxdr1qwBAHTo0AGpqan+6V577TWUl5fj6quvtvSxcuVKDB06FB9//DGOPvpo5Ofn46uvvkK/fv3QsGFD5OfnY9y4cbj66qvRqFGj2to0ERGRiNNluMiJmsHSPffcg/nz5/t/7tGjBwBg2bJl6Nu3r7/9hRdewMUXX4yMjAxLH/v370dBQQE8noOFzhITE/Hqq6/ivvvug9vtRrt27TBu3LiAS2wiUn84SeFClqdhWaSicuvNHvFOaxKllGSbWFFKD8m1sGhPadB0LnJhg2WMWLrGY/PWJLu3ObOilGx/+mxOx/YJywnZzUDZxQpaMh6SZfPA+n7bzTbZW6Yr6OdavLCl63AREzWDpXnz5lVaY+lQX375ZaW/69u3L8whB+pJJ52EFStWRGL1RERE6pcInFmCziwBiOE6SyIiIiKREDVnlkRERMQ+VfCOHA2WREREYpAC3pGjwZKI1Llp6wZb2lhI22usJTtYuNfnqHnCgD0VnrWxwoUsvF0aVBwxiT2pnvz17iTfUT7yZz4tLGltomHu4PA5wLeBBbJ5W2STHWwf+2yGw9l7VkaOKXacsTaGTRd8g0Bwoc4ynamJShosiYiIxCLjCD+grTNLADRYEhERiUnKLEWO7oYTERERCUFnlkRERGKRilJGjAZLIlLndpQ1tLTFO63BbfZ0+XgWmCbnzFm1bjYva2PLZcFyFiC2g4WqnaSNh6/tfZt5SPaklKyv/YC3dSfTquZ0Xex99ZQaa3Vt3p+9/e5ykIA8icO7yPvN+7M3XV3R3XCRo8twIiIiIiHozJKIiEis0mW0iNBgSUREJAbpMlzkaLAkInXO7bP+U+QjT4hn02XE77e0Ocn9znbzJSyvYrcopQfW7ExCUCaGF260LtNLvqQSHOXWOcmZA5YxspsnsptPKiXvBdvHbD/x9at5cUien7Kun93+7C/D2l+ysyzgZ1/Q+xj882GlgHfEKLMkIiIiEoLOLImIiMQkx/+9wu1DNFgSERGJRboMFzG6DCciIiISgs4siUid89GwdM3ZDRqnukprvAwW5maCCys6SXCdSSDFMUtszVlZiNyKhb7ZfqLzku1ngWe7QXiGbQc7VuxuLysuardAJgv+s+0IDnAHrxu7WeCwOYLOLBUXF9ueNi0trdr9a7AkIiISi4zj4CvcPqJARkYGHA576+r1kqr/VdBgSURERKLasmXL/P+/adMmTJo0CcOHD0d2djYAID8/H/Pnz0dubm6N+tdgSUREJAYZc/AVbh/R4Mwzz/T//5QpUzBz5kz89a9/9bddcMEF6NatG5599lkMGzas2v1rsCQida7Em2Bpa0yKTdrNMdnN3bD8C3sYbryxFoO0W+AweJ3Zg3rZw2vLbBabZPPaZTevw5bLHnJrO+/Esk208KV1GXYzPzQrZXe5EX6Ab+A8tTj6OIIyS4fKz8/HM888Y2k/+eSTcd1119WoT90NJyIiIjGjVatWeO655yztzz//PFq1alWjPnVmSUREJBYdQQHvQz366KO45JJL8O9//xu9evUCAKxcuRI//vgj3nzzzRr1qTNLIiIiMchhIvOKNueffz5++OEHDBkyBLt27cKuXbswZMgQ/PDDDzj//PNr1KfOLImIiMSiIzSzBBy8FPfggw9GrD8NlkSkzu1xN7C0tUiyFpmLI5cEEp3W8DUrSukk/+qz4DILPZeSUK6LtHnJ+rmC/jQvI0Up2foyLjIv2y46L1mG3YAyC0Gz/cS2325hyXCwMLePheFtFitlIXyGTVfVtoUTyBf7Pv/8c8yePRv/+9//sHDhQhx99NF48cUX0a5dO5x++unV7k+X4URERGJRRWYp3FeUefPNN3HuueeiQYMG+O9//wu32w0AKCoqqvHZJg2WREREYpGJ0CvKPPDAA3jmmWfw3HPPIT7+/5eBOO200/Df//63Rn1qsCQiIiIxo6CgAGeccYalPT09HXv27KlRnxosiYiIxKIj9MxSVlYWNm7caGn/4osv0L59+xr1qYC3iNSqk96/y9LWIjWyy2ChXRrZJblqGnom07Gn0LMwcxLKgqYhT6on85X4Ei1tDZ0HrOthMxxek2rT/39eEnon1bXtYlXS7VbmZliYmx8DLGxuL5PDgtulZL8kOaw3HNSZI/RuuJEjR+Lmm2/GnDlz4HA48NtvvyE/Px+33nor7r777hr1qTNLIiIiErbc3FyccsopaNiwIZo1a4aLLroIBQUFAdP89NNP+POf/4zMzEykpaXh8ssvx/bt2wOm+e9//4tzzjkHGRkZaNKkCUaNGoV9+/bZXo9JkybhyiuvxNlnn419+/bhjDPOwHXXXYfrr78eY8aMqdG2abAkIiISi2r5brhPP/0UOTk5WLFiBfLy8uDxeDBgwACUlJQAAEpKSjBgwAA4HA4sXboUy5cvR1lZGYYMGQKf7+AZ0t9++w39+/dHhw4d8NVXX+GDDz7AunXrMHz4cFvr4PV68fnnnyMnJwe7du3C2rVrsWLFCuzcuRNTp06t9i6sUKPLcH/729/w2GOPoWHDhgHtJSUlGDNmDObMmVPjFRIREZHwRaICd3Xm/+CDDwJ+njdvHpo1a4ZVq1bhjDPOwPLly7Fp0yasXr0aaWlpAID58+ejUaNGWLp0Kfr374/FixcjPj4eTz31FJzOg+dznnnmGZxwwgnYuHEjOnToEHIdXC4XBgwYgPXr1yMjIwNdunSp3gZXokaDpfnz52P69OmWwdKBAwfwz3/+U4MlEamU12f9SzXOyYoFWqezWyyQYZkd1p/dJ9OzApG8v6r/mS0leRi2HvtJjsmuJKfH0sayQwzL67B9wt4zlkUKJz9VRvYnyx05ybc8m85u0UwnyYaxwqTB0wVvKyuEGg2KiwOLxCYmJiIxMfTxWFRUBABo3LgxAMDtdsPhcATMl5SUBKfTiS+++AL9+/eH2+1GQkKCf6AEAA0aHCxa+8UXX1Q5WAKA448/Hv/73//Qrl07extnQ7UuwxUXF6OoqAjGGOzduxfFxcX+1+7du/H++++jWbNmEVu5Cps2bcKIESPQrl07NGjQAMcccwzuvfdelJUFBie//fZb/OlPf0JSUhJatWqFhx9+uMq+N2/ejEGDBiE5ORnNmjXDbbfdhvLyehTQExERqYkI3g3XqlUrpKen+1+5ubkhF+3z+XDLLbfgtNNOw/HHHw8A6N27N1JSUjBx4kTs378fJSUluPXWW+H1erFt2zYAwFlnnYXCwkLMmDEDZWVl2L17NyZNmgQA/mmq8sADD+DWW2/F4sWLsW3btoCxSvCgz65qnVnKyMiAw+GAw+HAcccdZ/m9w+HA/fffX6MVCWXDhg3w+XyYPXs2OnTogLVr12LkyJEoKSnBI488AuDgQG7AgAHo378/nnnmGXz33Xf429/+hoyMDIwaNYr26/V6MWjQIGRlZeHLL7/Etm3bMHToUMTHx0f0mTIiIiLRbMuWLf5LZwCqPKuUk5ODtWvX4osvvvC3ZWZmYuHChRg9ejQef/xxOJ1O/PWvf8VJJ53kP5PUtWtXzJ8/H+PHj8fkyZPhcrkwduxYNG/ePOBsUygVD8u94IIL4HD8/zN5xhg4HA54vdU/Q12twdKyZctgjMFZZ52FN998039qDQASEhLQpk0bHHXUUdVeiaoMHDgQAwcO9P/cvn17FBQUYNasWf7B0oIFC1BWVoY5c+YgISEBXbt2xZo1azBz5sxKB0tLlizB999/j48++gjNmzdH9+7dMXXqVEycOBH33XcfEhISIr4tIiIitcGBCGSW/u+/aWlpAYOlUG666SYsXrwYn332GVq2bBnwuwEDBuCnn37C77//jri4OGRkZCArKyug/tGVV16JK6+8Etu3b0dKSgocDgdmzpxpu0bSsmXLbE1XHdUaLJ155pkAgJ9//hmtWrWyPco7HIqKigIGa/n5+TjjjDMCBjjnnnsuHnroIezevRuNGjWy9JGfn49u3bqhefPmAfOMHj0a69atQ48ePeiy3W63/1kzgPVaroiIyJHGGIMxY8Zg0aJF+OSTT0Jmhpo2bQoAWLp0KXbs2IELLrjAMk3Fd/OcOXOQlJSEc845x9Z6VIxVIqlGAe82bdoAAPbv34/NmzdbskMnnHBC+GsWwsaNG/HEE0/4zyoBQGFhoeWNqdjRhYWFdLBUWFgYMFAKnqcyubm5h+Vyo0is6fTWFEtbk4ZllrYEp73T4iwY7PORMC4pGMnmZYUlWYg6kYSjaVFG8vejhxShDMYKKO73Wc9slzqsy2Shclao0kv2Ewtku2yeimDbbze4zULVTFiBbPLe8qC6vcC1l2ybnQKmwf17yI0Bh00kHoRbjflzcnLw8ssv4+2330bDhg3936Pp6en+kPbcuXPRuXNnZGZmIj8/HzfffDPGjRuHjh07+vt58skn0adPH6SmpiIvLw+33XYbpk+fjoyMDNvrsnv3brzwwgtYv349AKBLly649tprA06yVEeNTg3t3LkTgwcPRsOGDdG1a1f06NEj4GXXpEmT/Bmoyl4bNmwImGfr1q0YOHAgLrvsMowcObImqx+2yZMno6ioyP/asmVLnayHiIhIpWr5cSezZs1CUVER+vbtixYtWvhfr732mn+agoICXHTRRejcuTOmTJmCO++8M+DEBwCsXLkS55xzDrp164Znn30Ws2fPxtixY22vx2effYa2bdvi8ccfx+7du7F79248/vjjaNeuHT777DP7G3SIGp1ZuuWWW7Bnzx589dVX6Nu3LxYtWoTt27fjgQcewN///nfb/UyYMKHKQlOHXqP87bff0K9fP/Tp0wfPPvtswHRZWVmWKqAVP2dlZdG+s7KysHLlymrNA9i7ZVJERORIYkgphWDTp0/H9OnTQ07zz3/+M6z1yMnJwRVXXIFZs2bB5Tp49s/r9eLGG29ETk4Ovvvuu2r3WaPB0tKlS/H222/j5JNPhtPpRJs2bXDOOecgLS0Nubm5GDRokK1+MjMzkZmZaWvarVu3ol+/fujZsyfmzp1ryUtlZ2fjzjvvhMfjQXz8wdPDeXl56NixI70EVzHPtGnTsGPHDn/Jg7y8PKSlpUWskJWIiEidOEKfDbdx40a88cYb/oEScLBY5fjx42s8EKvRZbiSkhL/4KJRo0bYuXMnAKBbt27473//W6MVCWXr1q3o27cvWrdujUceeQQ7d+5EYWFhQK7oyiuvREJCAkaMGIF169bhtddew2OPPYbx48f7p1m0aBE6derk/3nAgAHo0qULrrnmGnzzzTf48MMPcddddyEnJ0dnjkREJKpVVPAO9xVtTjrpJH9W6VDr16/HiSeeWKM+a3RmqWPHjigoKEDbtm1x4oknYvbs2Wjbti2eeeYZtGjRokYrEkpeXh42btyIjRs3Wm5DrDjtl56ejiVLliAnJwc9e/ZE06ZNcc899wSUDSgqKgp4qJ/L5cLixYsxevRoZGdnIyUlBcOGDcOUKdZQqohUX2KCNRid4LIWfWXVlhkW+OVPjWcVmK3LYGFhGqwmYWY3C30ba1twqJgFillQ2E2WyYLmLOBtty0c4YSv7WJVs21X1yYB73hyI0E41cRdTnZMBe4XFgyXw2vs2LG4+eabsXHjRvTu3RsAsGLFCjz11FOYPn06vv32W/+0dm9Icxg7FxmDvPTSSygvL8fw4cOxatUqDBw4EH/88QcSEhIwf/58XHHFFdXtMqoVFxcjPT0dRUVFtutQiBwJTlx8t6WtcfJ+S1uzBiWWtqMa7LG08YGRPWywlOi0DtzYY0Gc5FoEm44NZjRYqj+DJXYMhDNYsnN3XXD/pfs8mNLro8P6fVHxndT2gWlwJiWF1ZevtBSb7rozqr7fqipr5HA4ql2gskZnlq6++mr///fs2RO//PILNmzYgNatW/trJ4iIiEgdOkIzSz///HPE+7Q9WDo0+1OVmTNn1mhlRERERMJRUQuyKoMGDcLzzz9vKz5ke7C0evVqW9Md+hwWETlyHPOq9XmK6WnWP0sTXNbT3uwyittn/eep3Gfvkgnrj11yY8tg2CU3u0UZg9eFXbrZ77XmpPZ5rTeZpMWVWtroJTeyrS5yioDtJ4bNy7Jd4fRnZ99VNi8pDwofu3/J5lkStly7l0qD34/g9zucy5LVFYmAdjQGvO367LPPcODAAVvT2h4sHY5nrYiIiMhhUssVvGNZjTJLIiIiUs8doZmlw6HunoQrIiIiEgV0ZklERCQGKbMUORosiUi1tZ33kKWtQbo1BJ2cUGZpS7JZlPKAl9UZss5rNzDLArrJtC6SNaPBwtzlpL9Eh7W/4NpDbL595dawNK8nRMLNJODtJOFrNp2LBJlZTSmG7U+7/blJrSk2HQtaszpVTtJmN9DO9jNrY/3Z4Q2us1WLAW9dhoscXYYTERGRI84dd9yBxo0b25pWgyUREZFYFInnwkXhmaX58+fjvffe8/98++23IyMjA3369MEvv/zib588eTIyMjJs9anBkoiISCwyEXpFmQcffBANGjQAAOTn5+Opp57Cww8/jKZNm2LcuHE16lOZJREJqf3jf7c2plubnOShouzBpXFOa24kjmRJ4ln+hWR2fGH8Y+7xsbyK9Z9Fu0Uz3Q5rm8dGRoX1RbNY1sgW4sg+ZvkaNh3jIvs4juSd2DqzeZ02n9HGnuVm97lttvNYNjNLdnNFbB9U9VDocmOvcKfU3JYtW9ChQwcAwL/+9S9ccsklGDVqFE477TT07du3Rn3qzJKIiEgsOkLPLKWmpuKPP/4AACxZsgTnnHMOACApKcl2xe5gOrMkIiISg47U0gHnnHMOrrvuOvTo0QM//PADzj//fADAunXrbD83LpjOLImIiEjMuO2229CrVy/s3LkTb775Jpo0aQIAWLVqFa666qoa9akzSyIiIhIzevbsiW3btqFZs2YB7WPGjEHz5s1xxx13VLtPDZZEJCRHubXgn/HYLATpswZ0y0moupwEahNJf+WkP1a8kvWX5LIWjDxAnlfPluEjRQ/ZdCxEHVzkks3HsG1gQXgmgRT+ZFghSLatDci+Y+8tC/QzCaS4KCs4yoLbjM9BClXaLODJtpdh+8rO9tZqEcpgR2hRSmMMHOSYKCkpQVJSUo361GBJREQkBh1pmaXx48cDABwOB+6++24kJyf7f+f1evHVV1+he/fuNepbgyURERGJeqtXrwZw8MzSd999h4SE///Yn4SEBJx44om49dZba9S3BksiIiKxKorODIVr2bJlAIBrr70Wjz32GNLS0iLWtwZLIiIisegIzSzNnTs34n1qsCQifl3uetTS5mpgDUp6k0mb1xpkNYYFo0nAm4WeSROrhs2C0KwqcxmptszYDWCXeq39JbDttRHwDQ6BH1wPsq0OaxsLMvN9Yi8EnUBCy27yjVlKgvUsRG8n9F5Zm4ccBKxKuJesn5d8ydvdBwyLcrMK3sEhcrv9S/2mwZKIiEgMOtIC3oeTBksiIiKx6Ai9DHc4qIK3iIiISAg6syQift8/MM7S1nGqNccEr73MUmm59Z+YsnhrDqWM5IRYHoRh+SSWTWEZG1ZokOV9WH6oqMxa3C4lvszWugQr81q3n+W94l32ijSy9WX9JcZZC0GWOazr4nTYK/xpNz9Fc2Hk7WaFKtm8Xqe9wpKsP4/PXo7JBXsFQesTXYaLHA2WREREYpEuw0WMLsOJiIiIhKAzSyIiIrFIZ5YiRoMlERGRGKTMUuRosCQifqwopZc8McAk2Qsa0wA1LUrJikiyoLG1Pzad3aKHcU5raJcVm2RogUOyvWz9grHwtQ/WtgPl1qA14yX7k+07T5l13RxkunhSWNIuVuSS7XceDifHACtASfaVi0zHClpShoS5SUFQH0myeIIWEby+Htb34aIzSxGjzJKIiIhICDqzJCIiEot0ZiliNFgSERGJQcosRY4uw4mIiIiEEBVnljZt2oSpU6di6dKlKCwsxFFHHYWrr74ad955JxISEgAAn3zyCR599FGsXLkSxcXFOPbYY3HbbbfhqquuCtm3w2ENBr7yyiv4y1/+cli2RaQudHiIVOEmRY9NIxKeTbK2OeKtbT5SwXt/WYJ1XrZcm+FrhlW/ZlWjGTYdqzruJdOVken2OhKrnM5LKkaz/tl0bD+xMLchZwN8ZDrGSfZ7UoK18rXLYZ2ujITjWWCchbn3x1vD63FkGSxYn0Aqm7N5U+NLLW1MPJk3roYh9+Cq4W5fLZ6q0WW4iImKwdKGDRvg8/kwe/ZsdOjQAWvXrsXIkSNRUlKCRx55BADw5Zdf4oQTTsDEiRPRvHlzLF68GEOHDkV6ejoGDx4csv+5c+di4MCB/p8zMjIO5+aIiIgcdroMFzlRMVgaOHBgwGCmffv2KCgowKxZs/yDpTvuuCNgnptvvhlLlizBW2+9VeVgKSMjA1lZWZFfcREREYl6UZtZKioqQuPGjcOeBgBycnLQtGlTnHrqqZgzZw4MO4d9CLfbjeLi4oCXiIhIvWIi9JLoOLMUbOPGjXjiiSf8Z5WY119/HV9//TVmz54dsq8pU6bgrLPOQnJyMpYsWYIbb7wR+/btw9ixYyudJzc3F/fff3+N11/kcOowY6alzWeNDsGXSDJBJItkXCRzwvJErKggyTGxjFFSvL2nxtOClvSp9vb+DmT5F7u5GxcrrMgKJgZlj1ixSbafWBbJS6Zj32UsP8awvwudLuv6uT3W6eJITohtGysEGU/mPeCxV3CT7Xe2XJZZcpJMGc0iOa0ZLQ/Zp+Wk4Ghwf8HHWJlXmaVoVKdnliZNmgSHwxHytWHDhoB5tm7dioEDB+Kyyy7DyJEjab/Lli3Dtddei+eeew5du3YNuQ533303TjvtNPTo0QMTJ07E7bffjhkzZoScZ/LkySgqKvK/tmzZUr0NFxERkahRp2eWJkyYgOHDh4ecpn379v7//+2339CvXz/06dMHzz77LJ3+008/xZAhQ/Doo49i6NCh1V6nXr16YerUqXC73UhMtP4VAgCJiYmV/k5ERKQ+cIDe9FrtPqSOB0uZmZnIzMy0Ne3WrVvRr18/9OzZE3PnzoXTaT0p9sknn2Dw4MF46KGHMGrUqBqt05o1a9CoUSMNhkREJLrpMlzEREVmaevWrejbty/atGmDRx55BDt37vT/ruIutmXLlmHw4MG4+eabcckll6CwsBAAkJCQ4A95L1q0CJMnT/Zf2nv33Xexfft29O7dG0lJScjLy8ODDz6IW2+9tZa3UEREJLJUOiByomKwlJeXh40bN2Ljxo1o2bJlwO8q7lybP38+9u/fj9zcXOTm5vp/f+aZZ+KTTz4BcPDuuIKCAv/v4uPj8dRTT2HcuHEwxqBDhw6YOXNmpVkokWhQnkxC2iTMHdewzNoWbw27skKIhhZMtK4Lm44VJPSQ0Pf+cmvglwW37Ya0WWCaYf152T6wWSDSExQCdpdZ16283Lr9LFTOAt4+Dwl9020lbxC5xkKXG2ddPxc5Vlj4mnE6bQbmyXTsOGNFKRPiSAA98YB1GWR77Ra5ZDcXJJjAcLgvaJqymtW2lDrmMFXdJy9VKi4uRnp6OoqKipCWllbXqyNHuLZP/d3SVleDJfZll5rstrQlxlnvPkpLtFZbru+DJVZ1PPjuv2gcLDnjyOAmCgdLGbUxWAq6ky4h6O64sn1lePXslw7r90XFd1LX6x+EKzEprL687lKsm33HEf/9FhVnlkRERKQGdDokIqK2KKWIiIhIbdCZJZEI6TjV+rBa+jxXG3/psYfXsj9tfKyIZANyyS3VWlUwuYH1MlyDBOt0rIgk4yGXkljhwuQE63ITXdbLcMGXLwB+KaSMFAY0xt4lIlZE0k0u4bE9wC7DsWUEX8Jjl7lYWziXyLweMp2LFRK1NrnirNPZLcrJt826DHbpi2bAvCwXZm1jDwlmhSr3Oq13ObMHAoMU4Uwil4rZJdskV+C6+IKObU8tPkhXAe/I0WBJREQkFql0QMToMpyIiIhICDqzJCIiEoN0GS5yNFgSERGJRboMFzEaLIlUof2jM+1NSEqQOEgBOksmlAa3SeiUXTRn9ZOSrenUFFLbKCXRGrROirPOG08Cz6yIpF0s3EtrJZHgtt06S6z+DQ0Qk/Vj9ZhYnSW7dZuCg++0f1I/iQWtWf0kWimP5cVdJPTN6h2RIDhbRByZjr0XbP3Y/mRBcDYvDXOTjwvbjrJye195LETuJccUu0GgKh6vvVpUUr9osCQiIhKDdBkucjRYEhERiUW6DBcxGiyJiIjEIg2WIkalA0RERERC0JkliTlt5z1kb0Lyp4IpJ8HTRqTacLl1ZlYIGKQCsaWwMAnZglTmBgmsxiVZqwonJpI2Un2YhblZlWIPCVqzkDar6MxC1SwE7CK7yS62fixETatrk+lYiJzxsRAw6y8ovM0eQmxN/dt/WDENc5Njilb/JscUC0azSuws4M2quLN9Es7j2520cri9edmxx7Awt92bGoL3c/Ayy8trL+CtzFLkaLAkIiISi3QZLmJ0GU5EREQkBJ1ZEhERiUEOY+AI55rn//UhGixJDHIlWfMV7PPOch1IsGYaWK6j3E2edG8z6xJ8XpvmS0gBwbgE63YlJVhzRyyflBBHMick+xFHglfxTuu85SS/QYs+2sz1sLYyUgyToUUpSZFHhq0zy/YccMdb2jwe6/p5SZYtmM9DpiHr6yXHHViOieXiCLatxrDPir3+XOzzQ7CCm2wf273ew44VtsY0o+a0TslyVnaPH16EM7AtOBvIPjuHjS7DRYwuw4mIiIiEoMGSiIhIDKq4Gy7cl125ubk45ZRT0LBhQzRr1gwXXXQRCgoKAqb56aef8Oc//xmZmZlIS0vD5Zdfju3btwdM88MPP+DCCy9E06ZNkZaWhtNPPx3Lli2LxC6pMQ2WREREYpGJ0MumTz/9FDk5OVixYgXy8vLg8XgwYMAAlJSUAABKSkowYMAAOBwOLF26FMuXL0dZWRmGDBkC3yEP+Bs8eDDKy8uxdOlSrFq1CieeeCIGDx6MwsLCMHdIzSmzJCIiImH74IMPAn6eN28emjVrhlWrVuGMM87A8uXLsWnTJqxevRppaQefPD5//nw0atQIS5cuRf/+/fH777/jxx9/xAsvvIATTjgBADB9+nQ8/fTTWLt2LbKysmp9uwANluQwav/43y1tLDv685gJtvpr+5S1P6RYw8xwkAAle7p6PHuqu3VWGmZmhQXZ+Wo7f5WRrlionPVlN4zLuEmAmhWbZEFrFmxlbaxYoN2Ckaw/tn5294Hd6XgRRbK9JARMw9uWWVkBSrIipDAiC3jz447teLINJJDuJJ8VFtJ2k68PVqiTHis2l0uxt5HsAxbS5sFyKx85BlgQnPUXvL2l5YE3B0RrUcri4uKA9sTERCQmJoact6ioCADQuHFjAIDb7YbD4QiYLykpCU6nE1988QX69++PJk2aoGPHjvjnP/+Jk046CYmJiZg9ezaaNWuGnj17hrcxYdBlOBERkVgUwctwrVq1Qnp6uv+Vm5sbctE+nw+33HILTjvtNBx//PEAgN69eyMlJQUTJ07E/v37UVJSgltvvRVerxfbtm0DADgcDnz00UdYvXo1GjZsiKSkJMycORMffPABGjVqFMm9Uy0aLImIiMSgSAa8t2zZgqKiIv9r8uTJIZedk5ODtWvX4tVXX/W3ZWZmYuHChXj33XeRmpqK9PR07NmzByeddBKczoPDEWMMcnJy0KxZM3z++edYuXIlLrroIgwZMsQ/oKoLugwnIiIiIaWlpflzRlW56aabsHjxYnz22Wdo2bJlwO8GDBiAn376Cb///jvi4uKQkZGBrKwstG/fHgCwdOlSLF68GLt37/Yv7+mnn0ZeXh7mz5+PSZMmRXbDbNJgSSKi7T+nWxvJGVNDMh1t5jxMJrQ2OVJJ8cY46/V/J2lzselY/sW6WF7Mj2VHCPZQUju5CfaQUjZfMilKyfI/rLCkj4Q/7D5olO27BPKwVTadnUJ+AOBh2SaaqWIFMi1NgHX1aGFF+jBYlk8iD12mgZqgt4MVkXSQNhZZYtPRDA/bx/Rps+TBv2Qqn4tsfzw5pth2kPeRTkcKsbIsl4NdDyHHhcNaRxTuMrIurJiqx3oM0M8GOc6CM2/BDyH2lpMD8XCp5aKUxhiMGTMGixYtwieffIJ27dpVOm3Tpk0BHBwc7dixAxdccAEAYP/+/QDgP9NUwel0BtwxV9s0WBIREYlR4Qa8qyMnJwcvv/wy3n77bTRs2NB/q396ejoaNGgAAJg7dy46d+6MzMxM5Ofn4+abb8a4cePQsWNHAEB2djYaNWqEYcOG4Z577kGDBg3w3HPP4eeff8agQYNqb2OCaLAkIiIiYZs1axYAoG/fvgHtc+fOxfDhwwEABQUFmDx5Mnbt2oW2bdvizjvvxLhx4/zTNm3aFB988AHuvPNOnHXWWfB4POjatSvefvttnHjiibW1KRYaLImIiMQiYyq5Jl3NPmxPWvW006dPx/TpJLZxiJNPPhkffvih7eXWBg2WREREYlAk6ywd6TRYkmrrvOh+S5srgaQpWbiXBTFJsJMWrSOh57gEa1iSharj4yIbqmSBZC8JfSeQEGxw2JoFre0KDo8CPFTNOElys5yFcW0/hd5e+JIVffTS/UmmI/2VkTAuw94zVgiRBbxZsUVa5JLeIWBj3VhomRVptJtvZTdIsG1g85IEtY8krY2PBevt7RN2g4TPZtFVB5mQ1aFloXwH2adsXViw3Ev+TaLzBq2z2wR+zfr2a/QRjTRYEhERiUW1fDdcLNNgSUREJAY5fAdf4fYhquAtIiIiEpLOLImIiMQiXYaLmKgYLG3atAlTp07F0qVLUVhYiKOOOgpXX3017rzzTiQkJPinYdVC8/Pz0bt370r73rx5M0aPHo1ly5YhNTUVw4YNQ25uLuLiomLXRNSxCx+wtCUlWitEx8eRYDAJxVLx5JwufVq9vSB4PAtQ2wxzs6rWrMgxuxvWQ8KtbL/EkdBzQlxgjWS3x3qseUnilz1FnYW02Taw0DerkM36YxWy2VPZnWRb2bqw4C3bNrvB8nIW8KZVwq2T0cAvqS7NbjiAzSruwfl9eoyR9aDr5rRX/Zt+wZGK4ywYzbbLR5ZrFwuWMz4WaLe5aaySP12XMN5vBzmATBn5bAT/OxX02fOV1d53i+6Gi5yoGBFs2LABPp8Ps2fPRocOHbB27VqMHDkSJSUleOSRRwKm/eijj9C1a1f/z02aNKm0X6/Xi0GDBiErKwtffvkltm3bhqFDhyI+Ph4PPvjgYdseERGRw66W6yzFsqgYLA0cOBADBw70/9y+fXsUFBRg1qxZlsFSkyZNkJWVZavfJUuW4Pvvv8dHH32E5s2bo3v37pg6dSomTpyI++67z3/WSkRERI5cURvwLioqQuPGjS3tF1xwAZo1a4bTTz8d77zzTsg+8vPz0a1bNzRv3tzfdu6556K4uBjr1q2rdD63243i4uKAl4iISH1ScRku3JdEyZmlYBs3bsQTTzwRcFYpNTUVf//733HaaafB6XTizTffxEUXXYR//etf/qcZByssLAwYKAHw/1zxAEAmNzcX999vLcwYTTq8bs0nsQJ9ZSSLxPIv7Ewtu+7vs1lAkH1CWbaA5V/Y+tnNMbHiiCxPQx/gTrD9EpxRYvknhq2H12c9+8m2leWzWH+82Cabzrp+PsOKFFqno/2RXAt7b1kWiT3BnhdCtPm3oc0vB3Y80sKPLIsTPB/bBnKQOTxsW0mxTTodaSI5O1Ygk2V96DoTLHpGv4BZd2zfsXUmK+1jx4/dXBTJd5ly63RsHwQXtHQEH3elNv8NjAQFvCOmTs8sTZo0CQ6HI+Rrw4YNAfNs3boVAwcOxGWXXYaRI0f625s2bYrx48ejV69eOOWUUzB9+nRcffXVmDFjRsTXe/LkySgqKvK/tmzZEvFliIiISP1Qp2eWJkyY4H8ScWXat2/v///ffvsN/fr1Q58+ffDss89W2X+vXr2Ql5dX6e+zsrKwcuXKgLbt27f7f1eZxMREJCYmVrl8ERGRuqK74SKnTgdLmZmZyMzMtDXt1q1b0a9fP/Ts2RNz586F01n1SbE1a9agRYsWlf4+Ozsb06ZNw44dO9CsWTMAQF5eHtLS0tClSxd7GyEiIlIf6W64iImKzNLWrVvRt29ftGnTBo888gh27tzp/13FGaD58+cjISEBPXr0AAC89dZbmDNnDp5//nn/tIsWLcLkyZP9l/YGDBiALl264JprrsHDDz+MwsJC3HXXXcjJydGZIxEREQEQJYOlvLw8bNy4ERs3bkTLli0DfmcOGfVOnToVv/zyC+Li4tCpUye89tpruPTSS/2/LyoqQkFBgf9nl8uFxYsXY/To0cjOzkZKSgqGDRuGKVOmHP6NqmOsmKPdJ7Db/TvDSQrF0aeIk+W6yLzx8daEZQLZjgSXtY0GjUkolG2vl4R27RZ+LCdPcA/ez6XueMs0rCCjl4XjWbFJFwnls2J81t5oxpYFrWmBR5uh93K3vYArPVZY8N/mfqFJY1LolIV7GbvFFh2eoP3HZmM1Fcm62Q1Vs+d50aA121YSoKYFOFkTC73bvY7DLhawoDU99sh08WT/seA7Qd9b8n6A9OcILuAZPJvN4ysSdBkuchzG6BxbuIqLi5Geno6ioiKkpaXV9erY0nmR9W4+u4MlOihgFY4J9oUfy4Ml9kVxuAdLLpd132mwBPuDpXC+UJngAUQ4gyW3vc8ZuxvOZkF0eoccZXOwZPfblt2FR+/gY4MWdkcbGyzZfShsGIMly6AvaDbfgVJsmXD3Yf2+qPhOyh44BXHxSWH1Ve4pRf4H90TV99vhELV1lkRERERqQ1RchhMREZHq0WW4yNFgSUREJBb5zMFXuH2IBkuxhmWRGiR6yJQkJ8Ou05PPiZNkYuxe0Y1PtOaO7GZsWGXqpDhrf0lx1u3dW2a9u7GUPP27jLSx7AxbZ7vTBbd5SObGFxwKBuAjTzhn74+XZTXIetDgLTsEaJViVuaZBUysTbYrGLNq2DRURdrY4chyW+RQtgSyKxNG2NoOVtXcdsCbhIjpnLQaP9nvLMfEDh9aKN/evyvsPaOHlN0q6Wz/2Y1j0YC83X0f1BD8ntnMnUWEKnhHjDJLIiIiIiHozJKIiEgMciACmaWIrEn002BJREQkFqmCd8RosHQE4LWD2BPdybxu6yFSTjI2LEfAilI6nfayM6y2D6tjVOawrouHbNveEmutEbYML6sBRLaNRkdIbsJL9kFcUG0otkxDcjMOkvWh2YpEa6PPZbOooM3MEs3O2M2NlJE2Nh15yrv9iqhkVUiWK5zCjwz9K95OfzQQYbNOEGtjeSJaeoplm0iOiR4/NjNqdnNCJO9Ea1mxL++4MNYvDE5yLFuWEVxmq4YZNqlbGiyJiIjEIJUOiBwNlkRERGKR7oaLGN0NJyIiIhKCziyJiIjEIIcxcIQZ0A53/lihwVKMKWMPZU2wJmVZINtLHoZrSCFEw4LbrEgjWwZ7KKulhd+uWk7mZeF1FhgvJ9tBizyygol2w8ykcJ8v3jpvWXB4mwS82dPRXW6yHiQs6mMnjO0+HJWw+8BYB3vwLS36aG869jBYGmYmfNaPAX3LDAkGs6AxK4ZJt40GsKvef/ThsCRUzYpN0sKxpA6t3WcLw8kaSeibTMcCzzTzwvadzUOUhc195GYAY/fbjT4Q2N6sdh5YbOmrtBZvxvfB9mcmZB+iy3AiIiIioejMkoiISAzSZbjI0WBJREQkFuluuIjRYCmKtX12hqXN2dA6HcsOsYfm0udEkiCB3QewshwTXS7JPvA/ZljOyt5DWX2skCYrtmgzS0HXj03HlhHcwB56ynJSNteN5ShY7MBuhiWsIo1kwXazV06WG7E5HcuwsPyYIYcPzSyxw8xm4cfg/nzsX1324SMhK/6AV9KfvZqzdH/aPgZsZqUYJ8sYsV3A3luSR2PvmY9l6Nh7yx7gy/aLzWPFstSg/VSrRSlVwTtilFkSERERCUFnlkRERGKQKnhHjgZLIiIisUiX4SJGl+FEREREQtCZpSjmcFvHur4GpOgjKSLpI0+1NzQpSpZLgqcsyOwjyUkHC1OyIpIe66HpI0Fo42PjffKXENlXDrIPWKDUduCVFR9kxSB9gW3OMrZupKsDVRfAq4yTFF9k87LiiC5SaJDvE9LGai26yQqyYDQJAdPilTZDu94EMh35F5CGhdl0dgPywevM5mPFRUlnLEBNl2lz3ei+s1sckuxjVxmbkCzX7nawmxrshrTZ8ciC22EEvG3dcBA8DTv+DxOHL/xAea0G0usxDZZERERikS7DRYwuw4mIiIiEoDNLIiIisUhFKSNGgyUREZEYpMedRI4GS1GMVWr2llpTiB4SPKaVpVlYmISqvSzIzCpzk2A5q0rs81pL8vrcJE1JQ8AsnWmd0FnKShrbq/Brt341D5mSfR+0D1wkuM0CsDQYTfhYENVmKNaQg4BW0rZZwZzN6yQhYBrktRnuZdWgGTYd3VcslG7v8KEHS/B+ZtvlI+Fzuv0s9E5WgwYsWJvNqvAMfS/svrfsmLIZ8Das+jf77LHjwsb7U+l0LCBvp2J58Hw1L4gvdUiDJRERkVikgHfEaLAkIiISiwz4gyGr24dosCQiIhKLlFmKHA2WothP48db2to+9XdLm92idSyf5CBtIIUL6XX4cvaYbmuTL976pw8rGMnWz8kKVbKntZPCig6Ss6L5F5v/VtCnyTNBuSBXKZmE5UFIZom9j066j8l6kF3MMjwsl0GPH5v5F7tFKV1suWS/uMpIDo4WmyTvNztEWaaIZZsYG1kXVgjTy3I4Nt8L25kbu/2FUeSSHsssumgn6wPAWU7e2wS7BVbtLYN9Nug+IO8b/feiqkxSLRallMjRYElERCQWGUQgsxSRNYl6GiyJiIjEIgW8I0YVvEVERERC0JklERGRWORD+HWd9CBdAFEyWNq0aROmTp2KpUuXorCwEEcddRSuvvpq3HnnnUhIOFjN7b777sP9999vmTc5ORklJSWV9u0gRfheeeUV/OUvf4ncBtQi+oRo1kbCrrSwJAt422TiyOlbFgJm1TBZhtxuqJgGt+0VoKTBU5vFFmmo2MY/NHH77c1HCxKy/WRz3WgAlgVbaxJiDYEFvHnhQlJclL5nJNDPiq76rNPZfVq9kxWlZEl6JmgyeiOAzQA1235eXJS0kffbRYpI0veWffZYwNvmTQjsvWX7kwWo2d1ZdHtJf+wY8MWRwDh5j1jInwbfg6azU5T0cNHdcJETFYOlDRs2wOfzYfbs2ejQoQPWrl2LkSNHoqSkBI888ggA4NZbb8UNN9wQMN/ZZ5+NU045pcr+586di4EDB/p/zsjIiOj6i4iISPSKisHSwIEDAwYz7du3R0FBAWbNmuUfLKWmpiI1NdU/zTfffIPvv/8ezzzzTJX9Z2RkICsrK/IrLiIiUlcU8I6YqA14FxUVoXHjxpX+/vnnn8dxxx2HP/3pT1X2lZOTg6ZNm+LUU0/FnDlzYHRwiIhItKsYLIX7kug4sxRs48aNeOKJJ/xnlYKVlpZiwYIFmDRpUpV9TZkyBWeddRaSk5OxZMkS3Hjjjdi3bx/Gjh1b6Txutxtu9/+/OF9cXFz9jRAREZGoUKeDpUmTJuGhhx4KOc369evRqVMn/89bt27FwIEDcdlll2HkyJF0nkWLFmHv3r0YNmxYletw9913+/+/R48eKCkpwYwZM0IOlnJzc2mYvD5ggWwTT4KTZax8s7XJ6bHOS/LTNBRryISsujYLqDpJxW0WSmfrx1KXdqtk2w0fs+Cp3bBwcH9xB1hK1N4yGVrRmhwDPBRrbaOBVJvZZlrlmayf3SfTs4CuiwS8fS6yvazN5vbSgDw5lpngoDGrGM1uSqCfC5vHnd2q3nYrafMbLkgA3+YxyvaxYZ9b8t4aFvqmx6i994e/t2Q6EvBmx5RlvuD3m4XqDxddhouYOh0sTZgwAcOHDw85Tfv27f3//9tvv6Ffv37o06cPnn322Urnef755zF48GA0b9682uvUq1cvTJ06FW63G4mJiXSayZMnY/whjxopLi5Gq1atqr0sERGRw0alAyKmTgdLmZmZyMzMtDXt1q1b0a9fP/Ts2RNz586Fk93LC+Dnn3/GsmXL8M4779RondasWYNGjRpVOlACgMTExJC/FxERqWsqHRA5UZFZ2rp1K/r27Ys2bdrgkUcewc6dO/2/C76Lbc6cOWjRogXOO+88Sz+LFi3C5MmTsWHDBgDAu+++i+3bt6N3795ISkpCXl4eHnzwQdx6662Hd4NEREQkakTFYCkvLw8bN27Exo0b0bJly4DfHXrnms/nw7x58zB8+HC4XNYLzEVFRSgoKPD/HB8fj6eeegrjxo2DMQYdOnTAzJkzK81CRQOXm4VE7BVkpJklcn2d5SsYH/mLhBWgNCyLRLaDRRB45sI6L80ikewDLYJn86nptPgeW0ZQQb64UlZU0Tqf3QdaBvcPAC43ywmRNrYMul2ska0My57ZWxewY4VF1Nh2kOWyp9WzZTA0K2Tz8kZwJoYVgrSdgbN5ScRuoUq2XHb80GOArYuNIo0H21imjPRH0M8oW2e77y3LRdks6snagt9vb2JgZzRPdrgosxQxUTFYGj58eJXZJgBwOp3YsmWL7X6C6zeJiIjEDJ+xHXQP2YdEb50lERERkdoQFWeWREREpJp0GS5iNFgSERGJSZGowK3BEqDBUlTrduujljZHBpmQBLLpk9VJqDruAOmOFNWjBfRYwUiChSRpsJw+cd7WIhC/j8xr8wn2DH1aO+EkQejg7Yg7wCoy2uufcbBtoAUJWVFB67o4SJtxsQSxvX3nLCP9xVv7Y0+NZxxea3++eOtBRW9MYCHgML5c6FPogxbBttVJisn64siNDyxYT9DwOdnWuFJ7iXGHx9507JjyJlvfC7ZtrM3FjhUa8mdrQz57ZP8Zsly7MR8vKfZa3iCwLfjfQWO3EKjUKxosiYiIxCJdhosYBbxFRERikc9E5mVTbm4uTjnlFDRs2BDNmjXDRRddFFCuBwB++ukn/PnPf0ZmZibS0tJw+eWXY/v27f7ff/LJJ3A4HPT19ddfR2zXVJcGSyIiIhK2Tz/9FDk5OVixYgXy8vLg8XgwYMAAlJSUAABKSkowYMAAOBwOLF26FMuXL0dZWRmGDBkCn+/gtdQ+ffpg27ZtAa/rrrsO7dq1w8knn1xn26bLcFGMPdiRZl1oocFwHxgUtFibxQxtF1akhefstTE002CzqB5Fi/SxjITN/mq6HvaeI0z/OnSSHArbBjYdWBs7XU9yMg6P9U0zPpJZYrkogha0pFg4jmXK7BVltC14v5AcjqPcum78wcz2HkJs998BZ5n1vaDHMdsnjN39lGjdOJYpc5KHLtPMEnvLWI6SbYfd95ss1xdHjqmgYz44k2m3+GZEGN/BV7h92PTBBx8E/Dxv3jw0a9YMq1atwhlnnIHly5dj06ZNWL16NdLS0gAA8+fPR6NGjbB06VL0798fCQkJAU/m8Hg8ePvttzFmzBha1Li26MySiIhILKrILIX7qqGioiIAQOPGjQEAbrcbDocj4NmqSUlJcDqd+OKLL2gf77zzDv744w9ce+21NV6PSNBgSUREJBZFMLNUXFwc8HK7yTOkDl20z4dbbrkFp512Go4//ngAQO/evZGSkoKJEydi//79KCkpwa233gqv14tt27bRfl544QWce+65lked1TYNlkRERCSkVq1aIT093f/Kzc0NOX1OTg7Wrl2LV1991d+WmZmJhQsX4t1330VqairS09OxZ88enHTSSXA6rcORX3/9FR9++CFGjBgR8e2pLmWWREREYlEESwds2bLFnzMCEHApLdhNN92ExYsX47PPPrOcERowYAB++ukn/P7774iLi0NGRgaysrLQvn17Sz9z585FkyZNcMEFF4S3DRGgwVIUYwUZ7QajWdFHVqTR7pPF7T6VnfXH8oNOcoaXbofNgLeLBEXZutA2tlxS3M7u09CDA7SsSCMLrLLgrSGBRxratRvuJQUowQpV+mwGvBm2T8hT6O0+NZ5xkL9SnUn2/rlj+5SyWTTTugCyP8k+sRtktlswkt4MQAp60mOAvbdkH9teLkk5G5tFbCm2C2wG5O3erEHviWlAjjNLYc66CyXDIAKDpYP/SUtLCxgs0UmNwZgxY7Bo0SJ88sknaNeuXaXTNm3aFACwdOlS7NixwzIgMsZg7ty5GDp0KOLjSSXkWqbBkoiIiIQtJycHL7/8Mt5++200bNgQhYWFAID09HQ0aNAAwMGzRZ07d0ZmZiby8/Nx8803Y9y4cejYsWNAX0uXLsXPP/+M6667rta3g9FgSUREJBbVcgXvWbNmAQD69u0b0D537lwMHz4cAFBQUIDJkydj165daNu2Le68806MGzfO0tcLL7yAPn36oFOnTjVe9UjSYElERCQW+Xzg1yir24c9xsbAavr06Zg+fXqV07388su2l1sbdDeciIiISAg6s1QPnX7xI5a2A02sgUhnsnXeuBLWI6mibLMaNguR2w1u0wefk2WwSrsustywKniT6egybFbhdpGnq7Ogtp2Kxi63dT5WNZvtJ4aGylmQl4Zdybzsr0W7f22y46KcvBlu9uaSI8jmJQGHl/SXkGBtIyFtE2+vxLJJsP7zaWdeR5n1gKLvBdnHNHxdSu7WCKdqMzlWEEe+KuLJ9ida25zsBgG2DPJ+s7A9Ox5ZtXfDbhpgxzfb9+zYs3kTgjchsM0T9O+0t1YreOtBupGiwZKIiEgs0mApYnQZTkRERCQEnVkSERGJRT6D8J4CDfoQ7iORBkv1QL8BDwU2pJJ8Ermu7iRF3OiTtkmkgeVwWD6J5Xp4ETfSZrPIJXsKt6uUrQvLG5D1I9GC+BJWRNJeGyv652L5JLuCFuEqtb4ZNKvB9jHLYLBcC+HwkJ3HskgsA8VOzbM2lk8qZxVMWWYnjKwUzTuRSqcsy8WeJM8yO2zfkzxS8HQ8d0TWzUP6crNqsuTfATYv2e+G5aKSrJWZHaxac5l1XRxl1v3kIFkxU2YvuEPzSXEsn0T6Y9dN2OHDskh0ZUgB2BRyXKQGLjj4c0sL/R4mxvhgwsmv/V8fosGSiIhIbDIm/DNDyiwBUGZJREREJCSdWRIREYlFJgKZJZ1ZAqDBkoiISGzy+cIPSSmzBECDpVp38nUzLW0piYFXQ1lImwWZWWg5jgSj40tY2JVMd8BeaNeQQCl/qj1Lglub2LrYDV/b7c9Vaq/wIyuW5yyz7nxayI6tCguPWgKfZD1YZyy0zOa1WWzS9rx2sfVjbSwszYoUglUwZcUCyQeGhsNtBsa9ZBleEma2TsX3c/A+YCFttzXgbVjom3GS7SdFOQ0JZIMFo8tYtVYSqibLcCSQp8OTsDkN0dssVOkgxw/tj2HHCiuGaeNzCwAutzX47gr6d88RdMyyfyul/tNgSUREJBbpMlzEaLAkIiISg4zPBxPmZTiVDjhId8OJiIiIhKAzS4dRt1sftbQlkxhC8ANYHQnW6+9Je6z5AJYJYpkTb5J1TMwe3uo6QArZET7ysFD2sEwn6Y8WlIsjxd5YnogVb2QPLiV5A/rwUtKf3UJ29GGwLP/CshTBGQnWF2P3wbIsm8LyOiR7BidZXx/bVpv9sXW2u+9YG8vYsAxQOJcOWGaHTkeWy/JYQcUgDenfkMwSxR4QbJMh75kpO2Bpc7IHDtP+yMOeD1hDkw7ywF22nxzkvWVnNRwkP0U/Z+y9sMnBsk2kv/hi6/vmiw885p2ZgfvT2Dy8IkKX4SJGgyUREZFY5DPhJ8o1WAKgy3AiIiIiIenMkoiISCwyBvyBeNXtQzRYEhERiUHGZ2DCvAxnNFgCEEWDpQsuuABr1qzBjh070KhRI/Tv3x8PPfQQjjrqKP803377LXJycvD1118jMzMTY8aMwe233x6y382bN2P06NFYtmwZUlNTMWzYMOTm5iIujHBgBSfJDyfss47y44sDg6JOtzWs6Npv7cy1e591AftKrG3xpFAcKzZZvNc6HUGfIk6CmIasCw1nkjClgxTa85EifU7yhHTb4VHyFHb2xHUaKmaBUhZ6dpD+goOxbD6ybrSgHnu6PCtI6LGmSllxP7qtrOghWz+7nxn2j284/bF1pvuPvWf2QvmGhMhpPdRyUhU2qNiiOWANVVPks8I+e/R4J8Uh2fFu9yGr7PNDC2mS99ZHtpd+HkkbO0Z9tBgm2S/smGfLZUUzE0l/5MYEh6eBtb+gG0w8DQN/77WZ5Y8I40P4Z5ZUOgCIosxSv3798Prrr6OgoABvvvkmfvrpJ1x66aX+3xcXF2PAgAFo06YNVq1ahRkzZuC+++7Ds88+W2mfXq8XgwYNQllZGb788kvMnz8f8+bNwz333FMbmyQiIiJRIGrOLI0bN87//23atMGkSZNw0UUXwePxID4+HgsWLEBZWRnmzJmDhIQEdO3aFWvWrMHMmTMxatQo2ueSJUvw/fff46OPPkLz5s3RvXt3TJ06FRMnTsR9992HBJu30IqIiNQ3ugwXOVFzZulQu3btwoIFC9CnTx/E/98lpvz8fJxxxhkBA5xzzz0XBQUF2L17N+0nPz8f3bp1Q/PmzQPmKS4uxrp16w7vRoiIiBxOxheZl0TPmSUAmDhxIp588kns378fvXv3xuLFi/2/KywsRLt27QKmrxgEFRYWolGjRpb+CgsLAwZKwfNUxu12w33I9fqioiIABy8FHsrrtuYXyj3W697lQTkHL7uu7iUFGX3k4rePFSQkBzvLLBkyL8Gq59PMEq2+xgorkmwGafOR/pzswaqskJ2PFbwjWQUfK6zIsi42H97KaggGrx99wCvJl7C8Fy0YSTJLPpLfYMcF21b2ntlcLsX+UCXrR49bVuSSofvPZmaJYJ8NfkyxD0dQZsl2VUL2wOqq+z+4buTzzfaJzbMGfFut+8QYcuyR7eXbQTJB9N8VNp21O5DPsoMcA/zfAdIfm5cEkMo9gV+rXrc36OfS/1vu4T9jUw5P2DUpy1GbVTTrrzodLE2aNAkPPfRQyGnWr1+PTp06AQBuu+02jBgxAr/88gvuv/9+DB06FIsXL4bD7j+gEZKbm4v777/f0t6qVataXQ8BQDLuIjGrNsPBh1PNC5Fz+yPcn13bSNvaoJ/z+Kx//PEH0tPTI71GAICEhARkZWXhi8L3I9JfVlbWER9LqdPB0oQJEzB8+PCQ07Rv397//02bNkXTpk1x3HHHoXPnzmjVqhVWrFiB7OxsZGVlYfv27QHzVvyclZVF+87KysLKlSurNQ8ATJ48GePHj/f/vGfPHrRp0wabN28+bAf/4VZcXIxWrVphy5YtSEtLq+vVqbFY2I5Y2AZA21GfxMI2ALGxHUVFRWjdujUaN2582JaRlJSEn3/+GWXskTw1kJCQgKSkpIj0Fa3qdLCUmZmJzMzMGs3r+7/T5xWXw7Kzs3HnnXf6A98AkJeXh44dO9JLcBXzTJs2DTt27ECzZs3886SlpaFLly6VLjsxMRGJidZbwtPT06P2A1whLS0t6rcBiI3tiIVtALQd9UksbAMQG9vhZCU5IigpKemIH+BEUlQEvL/66is8+eSTWLNmDX755RcsXboUf/3rX3HMMccgOzsbAHDllVciISEBI0aMwLp16/Daa6/hscceCzgDtGjRIv8lPQAYMGAAunTpgmuuuQbffPMNPvzwQ9x1113IycmhgyERERE58kTFYCk5ORlvvfUWzj77bHTs2BEjRozACSecgE8//dQ/qElPT8eSJUvw888/o2fPnpgwYQLuueeegLIBRUVFKCgo8P/scrmwePFiuFwuZGdn4+qrr8bQoUMxZcqUWt9GERERqZ+i4m64bt26YenSpVVOd8IJJ+Dzzz+v9PfDhw+3ZKTatGmD998PLwSXmJiIe++9N6rPRsXCNgCxsR2xsA2AtqM+iYVtAGJjO2JhG45EDqOKUyIiIiKViorLcCIiIiJ1RYMlERERkRA0WBIREREJQYMlERERkRA0WLKhbdu2cDgcAa/p06cHTPPtt9/iT3/6E5KSktCqVSs8/PDDVfa7efNmDBo0CMnJyWjWrBluu+02lJeT5zdFmNvtRvfu3eFwOLBmzRp/+3333WfZTofDgZSUlJD9sXleffXVOtmGTZs20fVZsWJFyP7q23vxySef4MILL0SLFi2QkpKC7t27Y8GCBVX2V5/eCyA6PhcXXHABWrdujaSkJLRo0QLXXHMNfvvtN//vo+VzUdV2RMNno6ptiJbPRVXbAUTHZ0MOYaRKbdq0MVOmTDHbtm3zv/bt2+f/fVFRkWnevLm56qqrzNq1a80rr7xiGjRoYGbPnl1pn+Xl5eb44483/fv3N6tXrzbvv/++adq0qZk8efJh356xY8ea8847zwAwq1ev9rfv3bs3YBu3bdtmunTpYoYNGxayPwBm7ty5AfMdOHCgTrbh559/NgDMRx99FLA+ZWVllfZVH9+LadOmmbvuusssX77cbNy40fzjH/8wTqfTvPvuuyH7q0/vRbR8LmbOnGny8/PNpk2bzPLly012drbJzs72/z5aPhdVbUc0fDaq2oZo+VxUtR3R8tmQ/0+DJRvatGljHn300Up///TTT5tGjRoZt9vtb5s4caLp2LFjpfO8//77xul0msLCQn/brFmzTFpaWkA/kfb++++bTp06mXXr1lm+3IKtWbPGADCfffZZyD4BmEWLFkV2RUMItQ0VXwihtov1V9/fC2OMOf/88821114bcpr69F5E0+fiUG+//bZxOByVDiLq6+ciWPB2RNNno0JV74Ux9fNzESx4O6L1s3Ek02U4m6ZPn44mTZqgR48emDFjRsCpz/z8fJxxxhkBT2U+99xzUVBQgN27d9P+8vPz0a1bNzRv3jxgnuLiYqxbt+6wbMP27dsxcuRIvPjii0hOTq5y+ueffx7HHXcc/vSnP1U5bU5ODpo2bYpTTz0Vc+bMgTlM5bvsbsMFF1yAZs2a4fTTT8c777wTss9oeC+AgxXo7Tx8s768F9HyuTjUrl27sGDBAvTp08f/jMlg9fFzESzUdtT3z0YFO+8FUP8+F8HYdkTjZ+NIp8GSDWPHjsWrr76KZcuW4frrr8eDDz6I22+/3f/7wsLCgAMYgP/nwsJC2mdN5gmHMQbDhw/HDTfcgJNPPrnK6UtLS7FgwQKMGDGiymmnTJmC119/HXl5ebjkkktw44034oknnojEagewsw2pqan4+9//joULF+K9997D6aefjosuuijkl0J9fy8A4PXXX8fXX3+Na6+9NuR09em9iIbPRYWJEyciJSUFTZo0webNm/H222/T6erj5+JQobYjGj4bVW1DsPr2uThUqO2Ips+G/J+6O6lVtyZOnGgAhHytX7+ezvvCCy+YuLg4U1paaowx5pxzzjGjRo0KmKbissT3339P+xg5cqQZMGBAQFtJSYkBYN5///2Ib8djjz1mTjvtNFNeXm6MqfqU/Msvv2zi4uICTvnadffdd5uWLVvW+TZUuOaaa8zpp59e6e/r+3uxdOlSk5ycbObPn297XSrU5XsRDZ+LCjt37jQFBQVmyZIl5rTTTjPnn3++8fl8ln5r83NxOLejQm18Ng7XNtTm5yLS21GXnw2pmah4NtzhMGHCBMtz4oK1b9+etvfq1Qvl5eXYtGkTOnbsiKysLGzfvj1gmoqfs7KyaB9ZWVlYuXJlteZh7G7H0qVLkZ+fb3ke0cknn4yrrroK8+fPD2h//vnnMXjwYMtfMnb06tULU6dOhdvttvX8o8O1DYeuT15eXqV91+f34tNPP8WQIUPw6KOPYujQobbXpUJdvhfR8Lmo0LRpUzRt2hTHHXccOnfujFatWmHFihXIzs4OmKc2PxeHczsOXafD/dk4HNtQ25+LSG9HXX42pIbqerQWjV566SXjdDrNrl27jDH/P6x3aAhx8uTJtsJ627dv97fNnj3bpKWl+c9YRdIvv/xivvvuO//rww8/NADMG2+8YbZs2RIw7f/+9z/jcDiqvMOkMg888IBp1KhRJFY7QHW24VDXXXed6dGjR6W/r6/vxbJly0xKSop58skna7ysunwvouFzwfzyyy8GgFm2bFlAe339XFSmsu04VH37bARj21CfPxeVCd6OaP1sHMk0WKrCl19+aR599FGzZs0a89NPP5mXXnrJZGZmmqFDh/qn2bNnj2nevLm55pprzNq1a82rr75qkpOTA24DfeuttwI+CBW3gQ4YMMCsWbPGfPDBByYzM7PWbgMNdennrrvuMkcddZT/EsuhgrfjnXfeMc8995z57rvvzI8//miefvppk5ycbO65557DufrGGL4N8+bNMy+//LJZv369Wb9+vZk2bZpxOp1mzpw5lW5DfXwvKi4xTJ48OeB25z/++KPS7ahv70U0fC5WrFhhnnjiCbN69WqzadMm8/HHH5s+ffqYY445xvIFVJ8/F3a2o75/NuxsQzR8LuxsRzR8NiSQBktVWLVqlenVq5dJT083SUlJpnPnzubBBx+0/EP6zTffmNNPP90kJiaao48+2kyfPj3g93PnzjXBJ/I2bdpkzjvvPNOgQQPTtGlTM2HCBOPxeA77NhlT+WDJ6/Wali1bmjvuuIPOF7wd//73v0337t1NamqqSUlJMSeeeKJ55plnjNfrPZyrb4ypfLDUuXNnk5ycbNLS0sypp55qFi5cGHIbjKl/78WwYcNoJuLMM8+sdDvq23thTP3/XHz77bemX79+pnHjxiYxMdG0bdvW3HDDDebXX38NmK6+fy7sbEd9/2zY2YZo+FzYPabq+2dDAjmMqaX7J0VERESikEoHiIiIiISgwZKIiIhICBosiYiIiISgwZKIiIhICBosiYiIiISgwZKIiIhICBosiYiIiISgwZKI1Ejfvn1xyy231PVqiIgcdhosiYiIiISgwZKIiIhICBosiUjYdu/ejaFDh6JRo0ZITk7Geeedhx9//NH/+3nz5iEjIwMffvghOnfujNTUVAwcOBDbtm2rw7UWEbFHgyURCdvw4cPxn//8B++88w7y8/NhjMH5558Pj8fjn2b//v145JFH8OKLL+Kzzz7D5s2bceutt9bhWouI2BNX1ysgItHtxx9/xDvvvIPly5ejT58+AIAFCxagVatW+Ne//oXLLrsMAODxePDMM8/gmGOOAQDcdNNNmDJlSp2tt4iIXTqzJCJhWb9+PeLi4tCrVy9/W5MmTdCxY0esX7/e35acnOwfKAFAixYtsGPHjlpdVxGRmtBgSURqRXx8fMDPDocDxpg6WhsREfs0WBKRsHTu3Bnl5eX46quv/G1//PEHCgoK0KVLlzpcMxGRyNBgSUTCcuyxx+LCCy/EyJEj8cUXX+Cbb77B1VdfjaOPPhoXXnhhXa+eiEjYNFgSkbDNnTsXPXv2xODBg5GdnQ1jDN5//33LpTcRkWjkMAoNiIiIiFRKZ5ZEREREQtBgSURERCQEDZZEREREQtBgSURERCQEDZZEREREQtBgSURERCQEDZZEREREQtBgSURERCQEDZZEREREQtBgSURERCQEDZZEREREQtBgSURERCSE/wftV6AaNw3TFgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -352,28 +410,28 @@ } ], "source": [ - "monthly_subset[\"ts_pred\"].isel(time=0).plot()" + "ds[\"ts_pred\"].isel(time=0).plot()" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 42, "id": "65c7de6c-0b13-4cb8-912f-02e8ed953c71", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -384,40 +442,40 @@ ], "source": [ "# original target\n", - "monthly_subset[\"ts\"].where(~lsm_subset[\"lsm\"].values).isel(time=0).plot()" + "ds[\"ts\"].where(~land_mask[0].numpy()).isel(time=0).plot()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 43, "id": "7d621ae6-52d8-476b-95b4-205bc05589e3", "metadata": {}, "outputs": [], "source": [ "# Error\n", - "target = monthly_subset[\"ts\"].where(~lsm_subset[\"lsm\"].values)\n", - "err = target - monthly_subset[\"ts_pred\"]" + "target = ds[\"ts\"].where(~land_mask[0].numpy())\n", + "err = target - ds[\"ts_pred\"]" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 44, "id": "6e18ddd5-81b2-4583-8a35-e9af7978bdf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -432,23 +490,23 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 45, "id": "ea56d33c-fd54-4353-bd88-06990ed9641c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAHHCAYAAACx7iyPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA8NxJREFUeJzsnXmYFMX5x79VPTN7wHLKKadHRBBvRTBRPIGgxmiMVwTxTDReKEYTFW88kmhMokSNV7wx3r/EBI23qEElahDjgXLIKbDLcuzOdNXvj+qqrq7umd3Ze5f38zzz1HR3dVV1T+9szVvf932ZlFKCIAiCIAhiC4e39gAIgiAIgiDaAjQpIgiCIAiCAE2KCIIgCIIgANCkiCAIgiAIAgBNigiCIAiCIADQpIggCIIgCAIATYoIgiAIgiAA0KSIIAiCIAgCAE2KCIIgCIIgANCkiGgBhgwZgpNPPrm1h0EQBEEQBaFJEdEkvPXWW7jyyiuxbt261h5Ki/Lvf/8bP//5zzFixAh06tQJgwYNwo9//GP873//S6z/ySefYPz48ejcuTN69OiBk046CatWrYrUWbBgAS6++GLsuuuuqKioQL9+/TBx4kTMnTs3sc2lS5fixz/+Mbp164YuXbrgBz/4Ab788st6X4MQAjfddBOGDh2K0tJS7LzzznjkkUdide677z4cccQRGDhwIDp16oSddtoJ1157LTZv3lzvvq677jocccQR6NOnDxhjuPLKKxPrXXnllWCMxV6lpaWmztixYxPruC/dxz//+U+ceuqp2GmnneB5HoYMGdLocebj+uuvxz777INevXqhtLQU22+/Pc4///zYZw3U7/7XxbPPPovdd98dpaWlGDRoEKZPn45cLhert27dOpxxxhno1asXOnXqhAMOOADvv/9+UX0RREcm1doDIDoGb731Fq666iqcfPLJ6NatW+TYp59+Cs475vz7xhtvxJtvvoljjjkGO++8M5YvX44//OEP2H333fH2229jp512MnWXLFmC/fbbD127dsX111+P6upq/PrXv8ZHH32Ed999F5lMBgBw9913489//jOOPvponHXWWaisrMSf/vQn7LPPPnjhhRdw8MEHmzarq6txwAEHoLKyEr/85S+RTqdxyy23YP/998e8efPQs2fPOq/hV7/6FW644Qacfvrp2GuvvfDMM8/ghBNOAGMMxx13HABg48aNmDJlCvbZZx/89Kc/Re/evTFnzhxMnz4dL730Ev71r3+BMVZnX5dddhn69u2L3XbbDf/4xz/qrH/HHXegc+fOZtvzvMi4TzvtNLP973//G7fddht++ctfYscddzT7d955ZwDAww8/jMceewy77747+vfv36TjdHnvvfew66674rjjjkNFRQU++eQT3HXXXfi///s/zJs3D506dYpcR133vxB///vfceSRR2Ls2LH4/e9/j48++gjXXnstVq5ciTvuuMPUE0Jg4sSJ+M9//oNp06Zhq622wu23346xY8fivffew/bbb1/0dRJEh0MSRBNw8803SwBy4cKFrT2UFuXNN9+UNTU1kX3/+9//ZElJiTzxxBMj+3/2s5/JsrIy+fXXX5t9s2fPlgDkn/70J7Nv7ty5cv369ZFzV69eLXv16iX33XffyP4bb7xRApDvvvuu2ffJJ59Iz/PkpZdeWuf4lyxZItPptDz77LPNPiGE/N73vicHDBggc7mclFLKmpoa+eabb8bOv+qqqyQAOXv27Dr7klKa52PVqlUSgJw+fXpivenTp0sActWqVfVqV0opZ82aJQHIl19+OfH40qVLZW1trZRSyokTJ8rBgwc3epzF8MQTT0gA8pFHHjH76nv/CzF8+HC5yy67yGw2a/b96le/kowx+cknn5h9jz32mAQgZ82aZfatXLlSduvWTR5//PGNvTyC6BB0zJ/vRIty5ZVXYtq0aQCAoUOHmmWLr776CkBcU3TfffeBMYY33ngD5557Lnr16oVu3brhzDPPRG1tLdatW4dJkyahe/fu6N69Oy6++GJIKSN9CiFw6623YsSIESgtLUWfPn1w5plnYu3atS112QCAMWPGGAuPZvvtt8eIESPwySefRPb/9a9/xWGHHYZBgwaZfQcffDC+853v4PHHHzf79thjj4h1BAB69uyJ733ve7E2n3jiCey1117Ya6+9zL5hw4bhoIMOirSZj2eeeQbZbBZnnXWW2ccYw89+9jMsWbIEc+bMAQBkMhmMGTMmdv4Pf/hDAIiNKx+FlqySkFKiqqoq9vk3hP79+yOdTterbn3HuXHjRixYsACrV6+ud5v2EnN97z8AVFZWYsGCBaisrDT75s+fj/nz5+OMM85AKhUa/s866yxIKfHEE0+YfU888QT69OmDo446yuzr1asXfvzjH+OZZ55BTU1Nva6ZIDoyNCkiGs1RRx2F448/HgBwyy234C9/+Qv+8pe/oFevXgXPO+ecc/DZZ5/hqquuwhFHHIE777wTl19+OQ4//HD4vo/rr78e3/3ud3HzzTfjL3/5S+TcM888E9OmTcO+++6L3/3ud5gyZQoeeughjBs3DtlstmC/NTU1WL16db1eDUFKiRUrVmCrrbYy+5YuXYqVK1dizz33jNXfe++98cEHH9TZ7vLlyyNtCiHw4Ycf5m3ziy++wPr16wu2+cEHH6BTp06R5SZ9vj5e15gARMbVlGyzzTbo2rUrKioq8JOf/AQrVqxoln4ayrvvvosdd9wRf/jDH2LHpJRYvXo1li9fjtdffx3nnnsuPM/D2LFjTZ1i7v9TTz2FHXfcEU899VTkfACxZ6B///4YMGBA5PwPPvgAu+++e2wpe++998bGjRvz6uAIYkuCNEVEo9l5552x++6745FHHsGRRx5Z71/Zffr0wd/+9jcwxnDWWWfh888/x80334wzzzzTaCHOOOMMDBkyBPfccw8mTZoEAHjjjTdw991346GHHsIJJ5xg2jvggAMwfvx4zJo1K7Lf5ZFHHsGUKVPqNcaGWCgeeughLF26FFdffbXZt2zZMgBAv379YvX79euHNWvWoKamBiUlJYltvv7665gzZw4uu+wys0+fk69NAPjmm2+www475B3rsmXLjJg43/mFuOmmm9ClSxdMmDChYL1i6d69O37+859j9OjRKCkpweuvv44//vGPePfddzF37lx06dKlSftrDlasWBH5bAYMGICHH34Yw4YNM/sae//req7s85ctW4b99tsvsZ7ua+TIkXVdFkF0aGhSRLQap556auSfwahRozBnzhyceuqpZp/nedhzzz3x3nvvmX2zZs1C165dccghh0SsOXrZ6eWXXy44KRo3bhxmz57dxFejWLBgAc4++2yMHj0akydPNvs3bdoEAImTHu1RtWnTpsTjK1euxAknnIChQ4fi4osvLrrNQuTrsz7nX3/99XjxxRdx++23x8T1jeW8886LbB999NHYe++9ceKJJ+L222/HJZdc0qT9NZSxY8fmnTj36NEDs2fPxubNm/HBBx/gySefRHV1daROMff/5JNPjoW2qOsZqKqqalBfBLGlQpMiotWwtTUA0LVrVwDAwIEDY/ttrdBnn32GyspK9O7dO7HdlStXFuy3X79+ib+sG8vy5csxceJEdO3aFU888UTEU6qsrAwAEnUb2qVd17HZsGEDDjvsMKxfvx5vvPFGRGtUTJt6mUvTtWtXlJWVoaysrOgxAcBjjz2Gyy67DKeeeip+9rOfRY7l66uxnHDCCbjwwgvx4osvtplJUSEymYzxFDzssMNw0EEHYd9990Xv3r1x2GGHAUCD77+mrmfAPr+xfRHElgBNiohWw5401LXf/jUuhEDv3r3x0EMPJZ5fl5Zp06ZNEbFqIfr27VuvepWVlZgwYQLWrVuH119/PebyrSdhernDZtmyZejRo0fsV3xtbS2OOuoofPjhh/jHP/4Rce8HYM7J1yYAMw53Enjvvffi5JNPRr9+/fDyyy9DShmx2rnn28yePRuTJk3CxIkTMXPmzNjxfH01BQMHDsSaNWuapK2WZsyYMejXrx8eeughMylqyP23sZ8r98fEsmXLjDZJ163Ps0IQWzI0KSKahPrEqGkqtt12W7z44ovYd999G/Tr9rHHHmtSTdHmzZtx+OGH43//+x9efPFFDB8+PFZn6623Rq9evRIDML777rvYddddI/uEEJg0aRJeeuklPP7449h///1j53HOMXLkyMQ233nnHWyzzTaoqKgAgNhy4YgRIwAAu+66K+6++2588sknkXG/88475rjb7g9/+EPsueeeePzxxyMeT5p8fTUWKSW++uor7Lbbbk3SXmuwefPmyIS82Pvvoo/PnTs3MgH65ptvsGTJEpxxxhmRuq+//jqEEBGx9TvvvIPy8nJ85zvfacylEUSHgLzPiCZBB6NriYjWP/7xj+H7Pq655prYsVwuV+cYtKaoPq+68H0fxx57LObMmYNZs2Zh9OjReeseffTReP7557F48WKz76WXXsL//vc/HHPMMZG655xzDh577DHcfvvtERdqlx/96Ef497//HZkYffrpp/jXv/4VafPggw+OvLSF4Qc/+AHS6TRuv/12U1dKiZkzZ2LrrbeOuOF/8sknmDhxIoYMGYLnn38+74Q0X1/FkBT5+Y477sCqVaswfvz4ottrLpJc8jds2ICNGzfG6v71r3/F2rVrI55ixdz/JJf8ESNGYNiwYbjzzjvh+77Zf8cdd4Axhh/96Edm349+9COsWLECTz75pNm3evVqzJo1C4cffnhekT9BbEmQpYhoEvbYYw8AKjrvcccdh3Q6jcMPPzwSubep2H///XHmmWdixowZmDdvHg499FCk02l89tlnmDVrFn73u99F/hm4NKWm6MILL8Szzz6Lww8/HGvWrMGDDz4YOf6Tn/zEvP/lL3+JWbNm4YADDsB5552H6upq3HzzzRg5cmTEcnXrrbfi9ttvx+jRo1FeXh5r84c//KG5r2eddRbuuusuTJw4ERdddBHS6TR++9vfok+fPrjwwgvrHP+AAQNw/vnn4+abb0Y2m8Vee+2Fp59+Gq+//joeeughs5S5fv16jBs3DmvXrsW0adPwf//3f5F2tt1224ITQs1f/vIXfP3112bS8Nprr+Haa68FAJx00kkYPHgwAGDw4ME49thjMXLkSJSWluKNN97Ao48+il133RVnnnlmnf0k8eGHH+LZZ58FAHz++eeorKw0fe+yyy44/PDDix7nu+++iwMOOADTp083qUA+++wzHHzwwTj22GMxbNgwcM4xd+5cPPjggxgyZEhERF7f+w8ol/wpU6bEliNvvvlmHHHEETj00ENx3HHH4eOPP8Yf/vAHnHbaaRFX/x/96EfYZ599MGXKFMyfP99EtPZ9H1dddVWD7ilBdDhaIWAk0UG55ppr5NZbby0555Ho1oMHD5aTJ0829e69914JQP773/+OnJ8vivHkyZNlp06dYv3deeedco899pBlZWWyoqJCjhw5Ul588cXym2++afJry8f+++8vAeR9uXz88cfy0EMPleXl5bJbt27yxBNPlMuXL4/UmTx5csE23ajhixcvlj/60Y9kly5dZOfOneVhhx0mP/vss3pfg+/78vrrr5eDBw+WmUxGjhgxQj744IOROgsXLiw4Jvvzbej9siNRn3baaXL48OGyoqJCptNpud1228lf/OIXsqqqKm/bdUW01s9dfcZf33G+/PLLsYjXq1atkmeccYYcNmyY7NSpk8xkMnL77beX559/fmKE7vrcf3v89957b+zYU089JXfddVdZUlIiBwwYIC+77DITvdtmzZo18tRTT5U9e/aU5eXlcv/994/9HRLElgyTsglCxRIEQRAEQbRzSFNEEARBEAQBmhQRBEEQBEEAoEkRQRAEQRAEgHY0KZoxYwb22msvVFRUoHfv3jjyyCPx6aefRups3rwZZ599Nnr27InOnTvj6KOPbnMJJAmCIAiCaJu0m0nRq6++irPPPhtvv/02Zs+ejWw2i0MPPRQbNmwwdS644AI899xzmDVrFl599VV88803BWO8EARBEARBaNqt99mqVavQu3dvvPrqq9hvv/1QWVmJXr164eGHHzYxahYsWIAdd9wRc+bMwT777NPKIyYIgiAIoi3TboM36qiuPXr0AAC89957yGazJgEjAAwbNgyDBg0qOCmqqamJJEkUQmDNmjXo2bNni6auIAiCINoXUkqsX78e/fv3j6ROaWo2b96M2traJmkrk8mgtLS0SdrqiLTLSZEQAueffz723XdfkyRz+fLlyGQy6NatW6Runz59Ylm7bWbMmEHRXAmCIIgGs3jxYgwYMKBZ2t68eTN6lnXGRvh1V64Hffv2xcKFC2lilId2OSk6++yz8fHHH+ONN95odFuXXnoppk6darYrKysxaNAgzHh2Djp16gwfgAcgG6wy+lLCYwx+sJ3NCbVfSHicoTYnzbZdAkDWF/AYQ60v4HFmjtXkBFKcISdkpKwJ2s76ItJWre5TqlIICc5ZpLTHFPYTni+ENPv1Cqp7vt4vRXhcbavr8YNxSSEBIeELASkkfF9CClVfBi/GWazU6PZ9X0DKaH0pJfycgMjVwq/dDCnUFwPjnnkvcrVBOwJC+Grb9yGlb/ar0ocUIih9+NlscJ0+GPPAPA7pC+RqqgEAXqYMZd16oe+Ou+Kd69pOvi2C6Cg8Om8phJTggVW+LM2R9jjSwfcDYwweZzhg263w2aoqbN+rS2sON0ZVVRUGDhxoEi83B7W1tdgIH5OwNTKNlAHXQuCB5UtRW1tLk6I8tLtJ0c9//nM8//zzeO211yIz8759+6K2thbr1q2LWItWrFiBvn375m2vpKQkMRFiprwTMp0qIIKJAZPOJEf/I/fUP1z9qHLPmigEpZ6YpIKJSCoN5KzJUiql3usPI2Xt96WEpycwwTleSvXhBeMx2ZGC42YsUP2woB73pCmlUO2K4LiUYTteMG49CWJQEyF9XE+WmDXpEXqcOQEvpSZFseOMRUpuLU8KKcGDyRqCiZFgEsKvhYSElAxgHpiVC0q/58wL7rUPCB9gHJIH7834fXDuQeRqzcSIpXyIoA7nHngqA5GrBUtl4NduApgHP+fjk9//GARBND2dK6qwMav/Bhk8jyOdUhMjzhg8BqQ9jv+szqKitDO6dGlbkyJNS0gtMuDIsEYu0bVLBXHL0m68z6SU+PnPf46nnnoK//rXvzB06NDI8T322APpdBovvfSS2ffpp59i0aJF9UpUSRAEQRBtFY+xJnkRhWk3lqKzzz4bDz/8MJ555hlUVFQYnVDXrl1RVlaGrl274tRTT8XUqVPRo0cPdOnSBeeccw5Gjx5NnmcEQRBEu4YzwGvknIYDZC2qg3YzKbrjjjsAAGPHjo3sv/fee3HyyScDAG655RZwznH00UejpqYG48aNw+23396g/jhjSHsMQiizbtbXT1KgC0KwhMVZRLeTSSnjW6gxCvVD9nsv0AylgrVzXbpaowznSkPkwWiRanPM9JFJMdTmfHicByWLaYlywbZu32iSdH85Ac/j8H0BxhiklOAeByDA9PFUqDWCUG1xDkAfB4MPAS/Fla4IAhwsuEuAB6UR0ktmnDEwzox2yBwH4PuB5khIox1i3APj4TKZvV+jl8iktU/DuFp64+mMquv7RpNkt8NTafPer92E2g2V9XxiCIIolr4VJajcnEONr5bOU8Gymf09wRngccAXwEfLKjGyX9dWHjXRkWk3k6L6hFMqLS3FH//4R/zxj39sgRERBEEQRMvQFMtfHmj5rC7azaSotbC9sYTlgQZEPcxsLzN7v2d5WWkrjS+kEVrbgmv7XF0/aTtecvhCRKxBfp52a3NRTzZfb2tPMu1xJkMPsIhHWmD6sT3WTD3G4ENtM8EALo21yPYo07geaam0h1zWBxMMwhfgnMEXgaeZH7UO2VYeQHmgGc8zKEsQ8zxTAkAqU6Y+01TGtCNytZH2/FwtvJIyY1nKbqhEl7G/QNUrN4IgiKZl6y4lqMiksGZTFjW+MN9rQkrjgQYoK1GWCSDXbmSwTY7XBMtncRs64bLlPmEEQRAEQRAWZCnKgwcgrSOUciArBICotijjcdQ6MYRcS45GW5O0tSgDGI0RgJiVR5f6ldPWKEtbZNfLpFKOZglGY2SPIWZlSnGjKUqKd8Q8pTHytJWHB9YhMOWmHxwPtUVcud0H2iLBJBgHpFDHebDfS+l7y0wpAmsRoCx0vi+QyqTh5zxj1ZG+sgYZ93nLesQB8EwZ/OC4FD54SmmIvFTG6JJ4KmOsR/b5IluLNJTVKZUpM3qizZWrmuahIggiwg69Qxf7fy9ai41ZH1nLmqzExQweV5Z6ISX+u6wKI/q1Tdf85oSWz1oGmhQRBEEQRBuHls9aBlo+IwiCIAiCAFmKCiIcj7dCguuktB7ue7dekvt8Uv2cc67dtiugrs35icf1+bpeLhemCAFg3PHdMinVB+cMfk4vi0XvjUYLqDkAIQAJtWSmhdn2Ep2XCpbiUgy5WqnCA0AtxfkFBNeAneIjzAvkBUtmTJfci5bB0pmXKQO3wgIIvSTnhe7/IlcLka3FVoffgNXPXQKCIJqepWs3oKLEQ1YI+FIi60ukLbOI3t6cE5H9WxK0fNYy0KSIIAiCINo4DI1f2qEpUd3QpCgPnDPjEmqCNyYIrj0Wip+B/O747jHX8pN0jmsF0sEea4JgjsnCa88IrbWbfm1OoCTFUZMTKMt4qr0UN/0pK5DuN0jEyLnZ7wquASCVCawrkIBg8DwVvJFxBgTtq3YYmJDwUsr9n3u29UlZhxhjCNKXIZXh8IPEtYJLEzyS8ajgGgBEtjZy/yJBGNNRK5Fbn6cy8FIcnseNpUhZpUqQq60BT2fgiTJkKnpACoHSLr0SnhKCIJqCrbt3imz/63Pl3OBZQRx9oYI4Zn2J+curMLzvliW2JktRy0CaIoIgCIIgCJClKC/2jDzrK1dQX6rM8dorX+/LZwHSpWsxslODJGmMNK6uCFDWInMssW+R2F7OGZMeRy4nIkEVtdbH3gYQ0RbFgzACwtdao8Ba5Mfra/d/rVXSCZ/tMAB+0I7kDFwAggOpjAcRnCd8Bi+Vgp/LRYIw2qXe76VSwfj0uMJgjYx7xkrkedxYpXJZ37j7eyVlkMKHX9rJWJ4Igmhe3vrqW2T9MIij+jpR3ydZASAF1PpbnsWDvM9aBpoUEQRBEEQbx2NoguUzoi5oUpQHzhhSngpEyAFkfbVPMIk09C8XpS1KB4HFfJ7shWZbhjJeuGKpf/2EnmNh6SaTzVht1lj7faYsRmF9zySKdYM4up5svpDwMqo+eP4/NuWpFtUWMa23suopjVAYDFIKCXjq154X3MtUxjNWJm1FYpwhxVS90KqjtEU8qMeD41KodrnH1ThYBtwae5g6JG3aB4BU2oOf8yAzafWZeBzc0hRxQFmjOIPnCQidciSwLmXKo5oHgiCahzFDeuLtr9egJqc80fTXk5CIpP74fNV6bNerohVHSnREaFJEEARBEG0cWj5rGWhSRBAEQRBtHPI+axloUlSAnC9iomrACniYILhOCrKol888ztRSV/Bge4zFAkDme7lC6SShtV2qJTMeccu3x6OW2LiTL43FtnV7+QTXgFqyggiCOfpqWy9F+b4wS19cB4UMlrh44LYfOY4wbxpjEsK386oxyCAEgt2O54Xu/1JIsLTqx/N4pJ4WbOt+U2kvCN6olv54xlNhA4Jxcs5QYwTc0fAJBEE0H6VBCBH9ZxfmnFRsZurv9LOV67F9b1pCI5oOmhQRBEEQRBuHN8HyGcXgqRuaFOWBMyDlcXBjHQLSYMo6FAirkwTXWZEcxFELrO2AkEJIpKFMonbwRzdoIwBjtUlxhpxt1fGYEVpHgz/ywBqUQm1OoCzDUZvzUR4Iq1MZDzkhURZs65fe1u3Y1qOkYI6Mq+CL2rpj7l9gddFWHG22TQVWF5bmUSF0ECwyxT34voAUEh9cNwG7/ervKmhkKvxzFpaVyfQXtKMtWh54zJrFGQNPe0bc7aWYEVoDgaDbYxC+BMsp9/xUJo2a4HyCIFqGTmkPWV9iY9ZH1rJa23+GWV+CMYGFq9ejfyaLki49Wm/ALQAtn7UMNHEkCIIgCIIATYryIqTSFGV9lZzQl0BWqCCOWSGQ9fVLmvVuIcOkqzFtkQx1SL5EpM1aX8Q0RHYbvpCoyQnkgrI2ePkyPFfXd/sOy6imCABSljUIADJW6g/XWpUUzJFZv1oYY6FVhjGT+BVArDRaopSjBdLWnpzAe9eMBwB8cN2EsI/gafVSDDyw9AChlYhx9Z47/dnjVxYiDi/FkEp75uV5XJUpjlSamxQgfk7Az9Xi89uPyv+wEATRpGzfuwLpwAruC4lsYElX35vqezArBEb264qhW1VgcU26lUfc/Gjvs8a+iMLQ8hlBEARBtHHIJb9loEkRQRAEQbRxSFPUMtCkqAA8iHQMqGUj5UKvXMizEPAYA5fScq0PHjgvXC4D1MPMGYPHEIm+rNsEOHweLlu5S2i2m7wWWqc4U3nQPKDWD93u9RJYJliaCkXcPOKun0l58IVABmqJTAuv7fPtEpaQWwuu1TXYIucworUSTiP8aVJHKXlwvziD70dXdedd/33s9qu/q+rpYGksrdz0P7pJHTP3NWiPB0JwT4RtMY5IvjOe4pHPQ7n9qzxo6SAMAOcMJZ07toCTINoinTMeNmZ9AAJZX+1LB6YSHcZDQ5GtiaaCJkUEQRAE0cbx0ATLZxRurU5oUpQHIZWAWj+EbqBGISQEAvExosEc7aCKOmCjOhfgMtoHgJg7fqHgjRo7mKO2BtkCaSOYtvKihft5THhdY7n/A4hYpyLtiTA/mRY1m2CMQZZ7bS3SQREBJczmHoMUMPsjpa8E2lJKlJSmsc+1LwIA3r7sYACh4HqPy1+I9GfupbXNUxwsGKct4DbhAbTQO3C/B5SVSAZCeiAUZvu5HDpvRZYigmhptutVge16AS9+tgrjduiNvy9YgZqcCvKa9X1jNdpS4E2wfMYbef6WAHmfEQRBEARBgCxFBbHXr90gjlkmI+vavlQZ3U2QR2u6af+g0UEbOWdmnbw05SkLFA/d4F0LjX5v77O3M4InnmOCOjopRQCd4kO565dnPKUtCqxGOoij0RRZ+EIClvu+plZrcoSVqiMVpOjgwQ3h8UCI2uojhAQLtErpEiUO+t7NL0MKIJf14fsCqbS6V3YbH1w3AXtO/0fo8s8YWDoMymhc9Bkzbv2R68kJEzBSE4YR8PDJLUfETyIIokU4ePteAIAJw/rgxc9Wme+jrC/x4merkOYM+2+7VWsOsUVoEu+zIs8fMmQIvv7669j+s846C3/84x9j+++77z5MmTIlsq+kpASbN28uruNWhCZFBEEQBNHGaRLvsyLP//e//w3f9832xx9/jEMOOQTHHHNM3nO6dOmCTz/91GyzdrZkR5MigiAIgiBi9OrVK7J9ww03YNttt8X++++f9xzGGPr27dvcQ2s2aFJUAB29GTx878tQIK3znNl1bUF2iOX2HVTIWsJme1nLftnEI1RHSwAJ+c+sNmW0Xds9397OFVqCC8qMs3RmhwMwAu2cAAtstVp4zZ1lMy2s5h6H8IWppzH1OQB45riHIIu99QvEFlTrSNlaWK2XzOylSz8XXG+tDyElRNCvXvozwutcLQiCaBv4QprMAmpHmE+yo9OUy2dVVVWR/SUlJSgpKSl4bm1tLR588EFMnTq1oPWnuroagwcPhhACu+++O66//nqMGDGicQNvQUhoTRAEQRBtHL181tgXAAwcOBBdu3Y1rxkzZtTZ/9NPP41169bh5JNPzltnhx12wD333INnnnkGDz74IIQQGDNmDJYsWdJUt6HZYVJKWXe1LYeqqip07doVf3p1Prp16wpAza5dC5B213f3G/d7x2XcJp9VKSqERsSN3t12hdZuaR+vcdsJQgCE7YnEdnSQyCTs9m3rkvvyOEPOssK4uG719uOof41Iy01eCAkp1L7Q6qOE0nZgRpMHzYvP+4UvVEgFX0ZE1ra1CQA2VNUglfbw0U0TE+8BQRCtw/OfrEA2CEMCAOVpzwiyWxL9/6KyshJdunRp1j4e6T0M5bxxiTo2Ch/Hr1yAxYsXR8ZbH0vRuHHjkMlk8Nxzz9W7v2w2ix133BHHH388rrnmmgaPuyWh5TOCIAiCaOPwIDNCY9sAlBi6mEnc119/jRdffBFPPvlkUf2l02nstttu+Pzzz4s6rzWhSVEBQl1Q6HovhDQWnqyIW4fUtjruW8EfbbQuydUSmeMJFhX3WK2tSUo4Vwd8tDVFdl/5NEUabSWyrUWuZslNPeJqjMzxFEcu0BRp645tSdNBFm3tkV3P8zh8XygrjpAm2KO2EmlX+tCNPrQS6eCS5v7khNIwCV9pmhLd8BlytT6kkOjUpfCvJ4IgWp6sL5AVEjW+wHG7bN3aw2kRmMdi4UyKbqOBk6p7770XvXv3xsSJxVnNfd/HRx99hO9///sN6rc1oEkRQRAEQbRxuMfySjLq3UYDJkVCCNx7772YPHkyUqnolGHSpEnYeuutjSbp6quvxj777IPtttsO69atw80334yvv/4ap512WqPG3ZLQpIggCIIgiERefPFFLFq0CKecckrs2KJFi8B5qNtcu3YtTj/9dCxfvhzdu3fHHnvsgbfeegvDhw9vySE3inYltH7ttddw880347333sOyZcvw1FNP4cgjjzTHTz75ZNx///2Rc8aNG4cXXnih3n3YQuue3ZXQOhq5WtXL+eEyj95vL4nZpIOHxhVUZ30ZW0Zz3d9tQbOOdF2Xe759nruMBiihdbSduIA7qQQQRqYOznPzqAEJwu5cspBbtRcNH2Dv033X1vqQUoIxhpfP3w8A8N0bX8YbvzgA+97wL/MZcM7AGIOXUktnXorD48y8zP0IxNV+TiCXDUXWGiElcrU+qtdtxmd//GHs8yQIonV58bNVWF+TMxKGNGf44U79WnwcLSm0fmLISHRqpNB6g/Dxo68+atbxtnfalaVow4YN2GWXXXDKKafgqKOOSqwzfvx43HvvvWa7LkU9QRAEQbR1GGcm9luD20Djzt8SaFeTogkTJmDChAkF65SUlDRZNE39K0QbM1yxtQ7EaFuAktzOsxAmPoRtJcqK0GJjW4SAqFUlSXidT5ztWmfyueMXayVSQRs9Yx0CYKxEYcki+dNcwXXStj1+d78OBil8gVcvHIv9f/OKqf/GLw4AoISDnseMJUkjpbL+hAHqLWF4ys7PBkguTdBI3xcQOYFsjU9WIoJogyxcvR4lHsd6hN+9P9ypP57/ZAUO27FP6w6OaPe0q0lRfXjllVfQu3dvdO/eHQceeCCuvfZa9OzZM2/9mpoa1NTUmG030idBEARBtDbcY+CNtBRxshTVSYeaFI0fPx5HHXUUhg4dii+++AK//OUvMWHCBMyZMweel7wWO2PGDFx11VWx/ZyF4eO1pkhlmg8eTieNhxASaTBkmTT1tdLffo7TYMoC5QEAh8ckfK7ahhf1DjAWKJ7sTm9bhZKsO7U5gZIUN+7yvpAo4x5qfWGl6vACKxAzpcbdBgDPWdPW27qdskyoMcoJlRJEU5sTKMvo/rS1KRqE0tYTeZzhbz8dY85/9cKxkb7H3vIqvGB8VsYV9YnowI+BtchuF0BgJZJARtXhHoMM2sjV+vj414eBIIi2x9CtKiCxHh4HKjfnsDkn8NTHywAA//h0Jcbt0LuVR9g8MM7BeOOSULD2IyFuNTrUpOi4444z70eOHImdd94Z2267LV555RUcdNBBiedceumlmDp1qtmuqqrCwIEDm32sBEEQBEG0LTrUpMhlm222wVZbbYXPP/8876SoUHhzrSkCLM+kJH2Ps8tOBqveM/Ne646yIkzSCgA+ohob1W7UKpTvfb7jOWefsSIxBh8yksAViCd+TUoAW1epg0ECMEEd3f51e3ZpJ5S1r+vY+95FTkhUb87B4ww1tb5JB8IYC7P3WcEeGWdBGhDErkvjcRaKxbwwLYuXIvMyQbR1ttmqAttsBbz99Rqs3ZTF5uB7rMYXdZ/cTqHls5ahQ0+KlixZgm+//Rb9+rW8qyZBEARBNBXMI++zlqBdTYqqq6sjOVQWLlyIefPmoUePHujRoweuuuoqHH300ejbty+++OILXHzxxdhuu+0wbty4Vhw1QRAEQRDtgXY1KZo7dy4OOOAAs621QJMnT8Ydd9yBDz/8EPfffz/WrVuH/v3749BDD8U111zToFhFKY+jxOORoI0eA3wWLoVpQXWK2bnR4OTughXkUSX0y0IgDQAC8DwGPxBxA0rcbS/HmeOOIFmXSS79Zp+1jOYKjc3SlcfD86wgkvbSln1eoVK77Wvscbn50UqCdu3SXYpLcYZMisMTEqnyNDbW+kilwvHqtnwR5kfT+7TQWgdwTLoOX0h4GS/aVsYD4wyjr38Jc36ZvORKEETbYGCXEpSnPazeWGuC4f53WRVG9GvewIT/+HQlNmZ9ZDdtaNZ+bJSlqJFCa3Tc5cWmol1NisaOHYtCAbj/8Y9/tOBoCIIgCKJlIE1Ry9CuJkUtjZvaQ6fyAJQwVwQCbF2aesEbu7RF1r4Esk5qDC209n3t+h9PiaG3Cwmt3f06y32NJajWVhvXXd9DUHoMtX48yKIeV97SCUCpwwIkjUP3D8AEhcykvIhQO0nwnbQfUO7+jDP4OWGSJqZM+3ZqkmShN6CsVTVBKpVcrSBrEUG0cbbu3glpvgE1OYHKmhzGbd8y7viVNbkW6ceGMQbWyISwTNCkqC4aZ4sjCIIgCILoIJClKA8eA9LB+m3a2p/VaTIStEUciCSI9VhYard8VUkCXOmVbE2RL6VJHqvbTKd4pA94oat+UtBGIGo10lodbRVKOZqejKXR0efa1qNMOjpv9oLrSCqj1pdoMEetbyp3NDxag5RJpYL6KcfahMCKpLRFJY42SF+nduf3reP6Zddzg0Pa7WVSXpiEtsSD59OvKoJo6/Tu2gm9u3bCvxetbfa+dCJaHdi3JQ0v3OPgjdQUcUl2kLqgSRFBEARBtHGaxCVf0g+9uqBpI0EQBEEQBMhSlBfOoqJhGy241ktlAjLiRm/E2ME+HRlbi6y16Bqw8pcJLYQWxj0/2lboNp8UvTpJeG2XOrJ0TZAPzRYYu0toniWIrm8ka1P6Sfu5ui7Hbd8ND6CF2W6EbI/zoIyfr/cjJ5DKeJElwqS8avZ1ppylNDUOhvKMxKaMB8DDxc/9FzcdPiLxOSAIou2w16DuzdLus/OXI+uLUMKAMEelm82gOSFLUctAkyKCIAiCaOOQpqhloElRHjzOjNDaRkgJLiSEVGJrk+fMyr2lRNPhOeYXBg901gLgkkWF1lwHbwyEv1qXHQkEKZEGQ5ZJ+DwUWtvWFW11sQXI+awjdpnktm7nIdPn2UJtW8it3fwziLq7h1YfL9avbRHTYQDs89S41HlagJ1JRcet93tO9mg7z5ltZdIWs5SxDnnGSpSxPu/OpQIpzshKRBDtjNe//Bbf26Zno9r4aFklNtT6WL0xC19I87/Ac+L8kId7x4MmRQRBEATR1mmC5TPQ8lmd0KSoAMKJnq0tLkoTFA3kCABZP67/sQMxak2RrsMZiwRx9LjaVhaUYM3aCQSp9UjaimNbc1zNTNJ+rbnJFwwRCDU+ZRmvoDXKtQbZ7dbmBDJpboJAAmHwR51axLZi1frh9bj92Nehx2uPO26VivZXlvawKesH7fvGqqStQ+WZ0Fq0qdaHLzz4pemI9YwgiPZBsVaiZ+cvN+mVhKP11CSlFhJSGr1oS8AZM4FpG9MGURj61icIgiAIggBZigiCIAiizcM83viEsILsIHVBk6I8cMZiGeu5F4ijwcCFynqfFRLplCp1RGsttDZRqYPo1aHQWgn3hAiyu0sgzRHUVebNJDOpbhsCKEt7qPUFyjJeotu55y5lOQJmN7KzHf3ZPW6fnwmyzseyzQeljlhtC7JzCSZmHUlaC7Q9wUz+N7d/u8w4XwqeF4w9zUyfSedViFRsCTGT4pEXAHN9mRSPtEcQRMfivcXrsHZzFiWe+puHL8x3dZoH3+3B/wCdnSDNbeealh1vkySEJWV4ndCkiCAIgiDaOE0Sp4gmRXVCk6IC2KJowBJDW4G89C8IzhhygVg4K2Qk0JcWUwOIuNeHLvxhG3a9fGPRARz1mOyxFbIW2YJpIOq2bvpJEiwnnFdXEMf61tMC7dqE+vZ4gNBK5AqrSyzrjn1d+YTZ7v6ytLJupS3rUfXmXOL9IQiiY7B6Y23oLBNzkgm/j+15SNb6XsqK8HuY6DjQpIggCIIg2jikKWoZaFKUB4+F68d6ndlohKxAXr6Q4Ez9wvBSHFkhUeIEcbTdPXWwxrTHo2XgPm70R4Bx5QcQ0StxyeAxaYI+JrnTA8lWpKSUHq6+yG7PrmfXSXKDT7LCuP256CCT5RkPG2v9vNqnjMcjOh+71ONx9VGRF2PgjMFjoV5Lh0jQ+zzGUJLyUOrxiFaLIIj2ydtfr8HGIBwHgEiIFI8zpBmDkAi+w8MyDQRBG6PHAf29qlIXiRa0JnMPTaApaqLBdGBo2kgQBEEQBAGyFBEEQRBEm4dxBtZIy1Rjz98SIEtRAUKhtEyMdmpHuNb1gFAkrcXRvlRia19KZLUYOyh11GtAmXbtekJIZP3w5ctoVmZzXl1u7MHSUpkVudnen2+pzN3O126+yNj5ltSSluJMe4wZQbW9dOZxFlkq0+SC5Tcd2dtt1+MMac5ViAVP5bMrT6slspKUF1lOS3NVp3NJCuVpDxUlKdwzdxEIgmif2FkJ7O9ZTdZX3x9hNoLwXP39U2ge0ZJL7JxzkxS2wS9O//Lrgu4QQRAEQRAEaPksL4wpq0JESB0Ip/VUUltCwiCNQdDGIMijFkcrES835wopkU7xyDl2cLCsCAXZdhtAKBRU7YU519J6TEE7Hgt+wXjKGqWFw3ZeM02+YIxAKITuXJoy+5Pq28EdARS0HiWdr/OsmWCO+ngQlFFbffSYbHd+HRxSB5nU/ac5j4iojbWIM3AvuP8eM5a9lMdRGpyvQyxwzvDUx8vww536Ne6BIgiixUlzHvkvZ76rwZD1JUo814mGmfO04wsAeBwIjPsQUmJzTqC6NoeaFlyOapI4RY1NKLsFQJMigiAIgmjjNIlLfiPP3xKgSVEepKX/cTPbuwEG7YBfAEwQR20ByvoysrYNKI2R0hBF17J1mXXa0NYi31iswrI0xSPbHEBNTo1V96Oz0AP5gyra1h7Xbd+2AiUFdSwUnBFAbBtApD9t5XHb0/0khQvI148uSz1lJdK/9tKeshaVpJSVzGPRYGylKW4CtmX90N02TV8kBNEuqSjxsKGWRQLoaiLBcu3wJ0x/T/BAx6j2SwkwBnAwdM5wVNb46N+/rNmvgWhZaFJEEARBEG0cxjlYI4XSjT1/S4AmRQRBEATRxtEeZI1tgygMTYoKkE9onQ7Eea7QWoucU1q8F7SjShZx1XcF1roEYKJm+1Yb2o1Um3zTwdJOCecQQkbKrC/hpVWONgQRsjMeR60vEpfKPB66wWsBuBZ6x9zzWXTbXXKz3eWBwm75SZG43SU295ykiNvukpy+nrTHlaiah9Gs9b60x2LXwpkylW/OCZSnPWzM+kqcTbE9CKJd0rs8hTXcR60fOqbY39mcKcG1ZznPeIyhe6mHzhkVIsQTWWRZCp3Lo0tl/QBUVVW13MU0gaYINCmqE7pDBEEQBEEQIEtRQVyxc1boXxZRMXDWF4GoOSq8doM4Ro5pQXWQz8zk1QksUtnAHdwVWBuxt4RxH9WWqZTlZl6TC84LOtdC60Qhs2V9sq1YtlA7KS+bx/ILrG3yCa5dt/0koXVdVibbSmVbnbRYUgmtQ8G0sgYFVrYgWKTJhs2DYG4cyDKJkpRnLIIEQbQ/elSUw5cbUV3rIyfC71H1J63zHarvJg5lKS7xOPp162S1UoqS1hi8A+NN4H1GmqI6oTtEEARBEG0cLbRu7KsYrrzySjDGIq9hw4YVPGfWrFkYNmwYSktLMXLkSPztb39rzGW3OGQpykM0nYYqjSXF0hQBofZI64K05cEN4qjaYlHtkPOQhkHEAiuKF9US6bHYOhk1Nm11UWNJc4aanIDHdGgBpSly3ep1gEPdXxrKCpS2gkQCAJe6r8IpQOygkLbWx32flDLELpP6cMmnYUpzFYQx7TGUBClC9L0K76P6laiCOXJoeZHHpQpzIDm8YMycAe8tXoe+ndPwpcSgHp2xbN0G59ckQRBtkV5dylG6cRNqfWms+WnOkPEYKsrJpb4uRowYgRdffNFsp1L5pw1vvfUWjj/+eMyYMQOHHXYYHn74YRx55JF4//33sdNOO7XEcBsNTYoIgiAIoo2jgjd6dVcs2IZf9DmpVAp9+/atV93f/e53GD9+PKZNmwYAuOaaazB79mz84Q9/wMyZM4vuuzWgSVEBso6Xgl0CiGmKXO2Rrp/zRcQ6BCD0hHASFiYFZ7S1RNnACiSEBPfCPm3rkrZkccbA9diyftwDLaivU4iE6Uq48bYTCFKMiFCjpPpDZNzg4fjNfkv7o7VCOkhjfYNDutonX8a1STHNkbamWR57EWuYY3liTFmDGAMgGMrT6osnLaUJ7b8x6+Ob9UqvtXFFFTIew5I11RjQo3NdjxFBEK1MRXkZatcuh8x0AqRASeeurT2komnKiNau11xJSQlKSpKVU5999hn69++P0tJSjB49GjNmzMCgQYMS686ZMwdTp06N7Bs3bhyefvrpRo27JSFNEUEQBEFsQQwcOBBdu3Y1rxkzZiTWGzVqFO677z688MILuOOOO7Bw4UJ873vfw/r16xPrL1++HH369Ins69OnD5YvX97k19BckKWIIAiCINo4nHPwRnqP6fMXL16MLl26mP35rEQTJkww73feeWeMGjUKgwcPxuOPP45TTz21UWNpq7QrS9Frr72Gww8/HP379wdjLGaSk1LiiiuuQL9+/VBWVoaDDz4Yn332WYP7s5dfdCmc5SH7uJ3pHgjLlMcjSzoqIKByB7dLvV+dG5b6HN0m58y0meZhPq80V0s/pSmOzhkP5WkPXUtS6Jzx0LU0hfK0h4qSFNKco1Na1S8NssmXaGFyKmw3zVW7SpCsxlma4uBc1UtzhlIvWurr0a9McF5Z2oPHGcoyqjRBFq0y43GUpT2Upjx0SntmvOXBe91PqcdRmvKQ8bg5rzTlKYG1FbRRY39mJV54neHnEQqvS1MMJSmGbqUpdC1Jo1tZCl1LU6go8YwoW9dljGF55YYGP18EQbQcme59UdKpol0unQHh8lljXwDQpUuXyCvfpMilW7du+M53voPPP/888Xjfvn2xYsWKyL4VK1bUW5PUFmhXk6INGzZgl112wR//+MfE4zfddBNuu+02zJw5E++88w46deqEcePGYfPmzS08UoIgCIJoOppyUtRQqqur8cUXX6Bfv36Jx0ePHo2XXnopsm/27NkYPXp0o/ptSdrV8tmECRMi5jwbKSVuvfVWXHbZZfjBD34AAHjggQfQp08fPP300zjuuOOK6ktIGRNU58sAbwdUTErb4Qqtk0TbdpBEzwqamBXCCJ/TPG65AhARWAM6dIDK+q5F315g+anJCaR5OA51XmiFygaCamEJoc1+V4jtRQXhAOD7+cXp7nla+J3RKU0KCKJ9CXhemNUevro/EIhdRyz7dSCWLkkhCM7mRa5fo7vLcAYJgHlATiixuS+YOW6fJiXw7fqN6FlRnudJIgiCaJ9cdNFFOPzwwzF48GB88803mD59OjzPw/HHHw8AmDRpErbeemujSTrvvPOw//774ze/+Q0mTpyIRx99FHPnzsWdd97ZmpdRFO3KUlSIhQsXYvny5Tj44IPNvq5du2LUqFGYM2dO3vNqampQVVUVeREEQRBEW4KxJgjeyIr7l79kyRIcf/zx2GGHHfDjH/8YPXv2xNtvv41evXoBABYtWoRly5aZ+mPGjMHDDz+MO++8E7vssgueeOIJPP300+0mRhHQzixFhdDq9mKV7zNmzMBVV12VeMwNwqiDANrbOrkgYGmJPL0/sFR4HMa3G/lTamg3eFtDpK0nHgsTm6aDxKi2lkmlsLC0SJ49FhirUdYXyAoJX8iI1ka3VRJcm6/7D+qkg3qe6TNoH9Hxw1OBKk3yXCeViH2eug+eCQmgr91j8eCUmpSEFZ5AmHFpdDDKlGMmLvEC7ZTnBfdGNcyC8AKeVQJAKkgMmeYSAurzlAhDV3pMfawc6rw16zfC4wxdO1EwOIIgmp6mdMmvL48++mjB46+88kps3zHHHINjjjmmqH7aEh3GUtRQLr30UlRWVprX4sWLW3tIBEEQBEG0Ah3GUqTV7StWrIiIwFasWIFdd90173mFglYRBEEQRFugNSxFWyId5g4NHToUffv2jSjfq6qq8M477zRI+e6Kdd1tO/O6x1mkjO13loCSxNihWDsUb+cbkx252RYmmyUqHq2f9gK3fU+53mu3/ZKUp9zX9fkJIQb0Ng9CAQCIlbbA2QvCA3Aeuu/rPtIej7Sjt9M8GhYgpbPZu2EMrDAEnrVUaCOkNO2r/GccFSUplAbX7QWRt1kQwVrfZl9KSAnkRNgWZ+qeZLwgPEHg6p8JPlvtlq/HKRM+M4IgiKaAe7xJXkRh2pWlqLq6OhIfYeHChZg3bx569OiBQYMG4fzzz8e1116L7bffHkOHDsXll1+O/v3748gjj2y9QRMEQRAE0S5oV5OiuXPn4oADDjDbOsfK5MmTcd999+Hiiy/Ghg0bcMYZZ2DdunX47ne/ixdeeAGlpaVF96UtEtFM9ixSlngscb9baquSL5VwWQmRw360UFnV5UZYDUTzkuks7/lc17VFyJxrWbc8prK/pz0PWV8aN3stuDaCb0dEnub6/OhxLWTmwYWUpKLmsHLGjRVMI4Jr9yUADnNvk4TVkbFb96Ak5VlhDCSAcJsHWe9LPG6sRPq9CkrJwjxnkikrUWAtUgYiJRAPhgdmfQ5eKn5PGUI3foIgiOaEcQbWyIjWjL6w6qRdTYrGjh1bcImCMYarr74aV199dQuOiiAIgiCaF9IUtQztalLU0iQGIPRUhve0xyAkArf75FKT9QP9jJCo8ePBEV2NkT6esrLdAzBBGEOLEcx+u8xHmnPlxu4xNSYOE1JAW4uyIiw9ziB87f4uI2lM7PEai1pwb7Rlx3aXV4EuGWogACEjwSA9pq6Xe44bvxUgU98nVTL4ggWWOgEgvF92qpPydJiagwUu9FIqCxAHABZGStBWIwEJD0zHe4SUEqkgmKPunzEGKWWk1Kyr3ggA6NaZgjkSBEG0N2hSRBAEQRBtHLIUtQw0KSIIgiCINo6OaN3YNojC0KQoDyxwAVdLZYHLOtSSlRYXh9GaYcrQbT5sK80RLFmppaXNORELhqA3U1pwnXKiPPOowNqOXu3x0B1e1Y1fjwcV2VrnH4MH1OTCZUAP0SWrNA+WxvQ94HqpK7xWfQ88zpAO/tjSliDZXvoTXBrhdZZJcC6DJcRQUG6HOjDjtq5b3wdfqLxuvoyKsNNBGIDytIeSFFdRqTnAwcJ8ZcxZKuNquTP8HJgSUFvPgb5eFixZMnUAACAZgz1iyVikPYIgiKaAeR645zW6DaIw9ZoU7b777kU1yhjDs88+i6233rpBgyIIgiAIgmhp6jUpmjdvHi688EJ07ty5zrpSStxwww2oqalp9OBaGy0atktuCaztDPEmA3yQ5iwMgMjAmYTHuXFv54xhY9YHkEfMzaPWFo0tsPYsi1Cah1nm49cQTb2m27ODRboicS2w1vnA0h5H1hexcboCb9ud3hVeC19bm5ixlnFPKZ21sJwboXdwvYi2awTcWige5JhLe8pKpoXVKrhiaMljgMlb5sswaCMHg4/w+pk1fo2U4QFX2G7fR3O/g/tJEATRlJCmqGWo9/LZtGnT0Lt373rV/c1vftPgAREEQRAEEYUmRS1DvSZFCxcuRK9everd6Pz589G/f/8GD6otoFJ0MGM50fuAeMA+N1iitlzofbauxuPA5pyAx2Cy1ttteFZ91RaPtK3TS4RBHK33TnoPAOAeYhYsYyUKghWqfqNWjrBfGWiQAktYkDHe1jnp823NT5juhEXaK+deJAyAH2iJ3JuaDlJ9RLdhLHOlKdWeHZwxxVmgcdKBFS0tEQLrEFP3Q2r3+iCII2MSHOE9ZIyBW585sz4fxgBmAkYCyg4VnOeEESAIgiDaD/WaFA0ePLioRgcOHNigwRAEQRAEEYfxJvA+a+T5WwIN8j5bt24d3n33XaxcuRJCiMixSZMmNcnACIIgCIJQ0PJZy1D0pOi5557DiSeeiOrqanTp0iUSzZcx1mEmRWlLXKtFyFk/KrQW0l52YmZ5SVgCbHu5Si0lcfC0WvbKComNQX96GU1jlri0UDmSg01hlr6sZTNXSK23teA664fHPQ5kc+FY7RLW0lqaqXACQsJEunYjYftafO5E+7axhdwKhiwLx6PGKa3jwWdhLZ0BYVgBnc+sNK0iWaeCaN9mmVP3EkSeVm74qh0p9T0CwNQymna39xLGbd9vvXQGKQDGI6UEubwSBEG0V4qeNl544YU45ZRTUF1djXXr1mHt2rXmtWbNmuYYI0EQBEFs0TDOjLWowS9yja2Toi1FS5cuxbnnnovy8o6d20kFA+SRgIXaCBC6Zge7HaG17Y6vt3WAxZJUaEnKCgHOgJqcAMAjAl0tWjbvrT611UmXxpUcocCbWWOTEgAPM8lrq1NWCGN9MmMUoVg8ei1SWb58GXFDjwWw5OF+N0SAvpe+JawO85vpBsK6ahyhlcgOjJlmHGnOkUkxYyVKB5YiHWQxgiW6llJZpLSVU0o7r5k63+Na1G6J2yEBKcCkTpgmnD44GPcgJbBx02aUl5WCIAiiKSBNUctQ9B0aN24c5s6d2xxjIQiCIAiCaDXqZSl69tlnzfuJEydi2rRpmD9/PkaOHIl0Oh2pe8QRRzTtCFuJtLEKWS7sMq6/cbEzv+dDWXgAzlQnXhDMkTMW0xbpgJEq5UbU5d9YcxBah0ysQS17sba1G75tLfKFiAac5E5wxmBbB0sEBIRkJhqkb3RVoaZIp0HR7WotEw+sY+F90MEhozotVYaaLjudCRBupz1mrGPKmhRaefR126X5BaD89eEhSPHBEMl2n+ZBO7o97Ybv55R1yNYUmTY5lGJJQVYigiCaEsY9MN7INB+NPH9LoF6ToiOPPDK27+qrr47tY4zB9/1GD4ogCIIgCAvuqVdj22jnTJ06tehzLrvsMvTo0aNedes1KXLd7rcEuGWJ0VIfj/NICg9XM2NbMmz9iw4iyK3UoTr9B+CBM3V/s0Iaq4vW1EQ1OqptjzHjecVYqG2KDCfQBknoxKdRrZCQyoqjgyBypqxbdhDJSJkKgyaqxLJBSg6EHmeqHTVGY9UKzkt7gdWIhalFPEsr5SaCte9pkkZLW8tSnqqT4sxYiThgJEqhx5m6l7Y8TBhrWqhp0hYirSfijIFLX1mJhA8mcqGFSJeMmxcHkEqVYM165VfYo6Jja+8IYktm+boNLdcZ5+rV2DbaObfeeitGjx6NTCZTr/pvvPEGfv7znzftpMjmgQcewLHHHouSkpLI/traWjz66KMdxiWfIAiCIIi2x1NPPVXvtGMVFRVFtV30tHHKlCmorKyM7V+/fj2mTJlSbHMEQRAEQdQB87wmebV37r33XnTt2rXe9f/0pz+hT58+9a5ftKXIFqTaLFmypKiBtnXs/GUaO4eYWyqxcFxgnZS5XuMxFrigcwjPyjovJLIiFDCrfF7MLEtpN3y9dGa75Gskk2Z5iINBQJqs8Hopj3tA1pKAJS0HuteY9VUW+6wQ1rYd9DFcRrRF6SY4Y0JgS5XtPh6EMnT759Ft+/q10DroV+crs5fG7PxuQBjMMaWDUPJosEm9zJZiAGSwZCZ8ML9WueT7uaDxIGgjAOmpPyUGNYbSVAl8KbF+4yYICXTtVJb3OSAIon2yIduC0hLSFAEAJk+ejFwuV2e9+fPnY/jw4TjhhBOKar/ek6LddtsNjCndxkEHHYRUKjzV930sXLgQ48ePL6pzgiAIgiCIYjjxxBPx2GOP5T0+f/58HHjggVi+fHnRbdd7UqQ90ObNm4dx48ahc+fO5lgmk8GQIUNw9NFHFz2AtoottNYBDYUMAhgGmedtMTEQdx23s7TbFiRtkRAS8KCtRR6yTAVxFFwibbn7a/d7YyniXGWCDywlxlLktMuY1J7zqh+rNEVKe5jnEToHT4ix/nAVDDItWSC4Di1A9nWaewNdT7usR4NFegiCUKbs+2MJ0o3QOgw7oK9ZBVhUFqCUF7rmM6h9Up8Ay12fRduLp/QIrFBShhYikQP8WiO2BmC54/sqaGNgNZIAmBTwAHiMQzIOMBXMUUiJzuVkMSKIjsCCFVUt2yHnTWApav9CawCYM2cOfvrTn2LmzJmxY5988gkOPPBAjBkzpkFt13tSNH36dPi+jyFDhuDQQw9Fv379GtQhQRAEQRDFQRGtQ/7xj39gv/32Q48ePXD99deb/QsWLMCBBx6IffbZB7NmzWpQ20VpijzPw5lnnolPPvmkQZ21JxizLBaBNUT4iKTH8IMAiLbVyNXDaEwQRQvOdPBDBsEllBVFAFBaHTdYYUmKGwuJ7eKflHjVl+q4NAlXg6CIzni4VKYVX8po8EfEg0J6PAx2qLVO2kIkLMuWfQ+0DkvfOz0CO7SBmybF1Ra549JaKh1CwOOBpsiymAmV/xVWApHQxd5EthTgWhPEGJiUkAxg2hrkZ5UFyK8FhDDWISZykIF1SOqEsMFnx/wcpBCqT6buoGQcHuPgXhrVGzeRtYgg2jmfr1oPIVW4E6Ll2XHHHfG3v/0NBx10EHr06IGLLroICxYswAEHHIC99toLTzzxBLwGisqLFlrvtNNO+PLLLzF06NAGdUgQBEEQRJGwJhBas/YvtNbstddeePrpp3HYYYehuroad911F/bYYw888cQTEc1zsRRtS7v22mtx0UUX4fnnn8eyZctQVVUVeREEQRAE0cRo77PGvjoQBx54IB5++GFcd9112HXXXfHUU0/VO6hjPoqeTn3/+98HoHKc2a752lW/o6T50K7eAtJkmk974VEgFAungyUYV1TtiqDdZSAgXJLygojVOmp2mofHtfjXMxGbnUjWelSW67tpF/oa9NhUaecEAwAmo425UbK5JUwWkKFwWyp3dimtiwrugb53emxAKNAWXEaWy2xRuh1awCwTOiEIdDTsFLfK4B6q69GRqpXAWt1bBqaF0zbWMhfXy2S6nshFcp7pc02p3fL1UhqTYExA6i44D5fSRA7pVAk2btqMzTlB0a4Jop2io/LzPA4qRPPSvXv3WGig119/PRaPaM2aNUW3XfSk6OWXXy66E4IgCIIgGg4JrUNuvfXWZmu76EnR/vvv3xzjaHPYVgthBTxUO20RsbIiacuIHSgRCEW/9e1TB1XUbQNW/rHASqStQFpIbFuIbGzBtT22JGyxdpLQ2rQX5C/T3QmmrFBm28p27yEI0ggGEQi+w+uz+2aR/vT1cWZZsKwxcoSWn0jJ7PYCy6W0gjZKqSw7dpZ77pkgjMaCJHxVT+QiAmttDWIiZ6xDdslkcHel6gvcA3I5SJ4CkzlITyh3/TRQlk4nfg7tldo130BmOsH3VPofW8yu7xGTAiy7CZlu9QvPTxBtFR3qpEWh4I2GyZMnN1vbDVIjrVu3Dn/+85+NF9qIESNwyimndKiI1gRBEATRZqA4RS1C0Xdo7ty52HbbbXHLLbdgzZo1WLNmDX77299i2223xfvvv98cY2wVuOX6rtJIMOMCrjPVpzk3+3U9W/tjXOdZaAXSbdlWmIh7eayPQLfEmWlXByfkjMU0O5ypYIg6PKF9DfYY3GuK98+C7PNBhnkl6wm3TeDE+Hk6bABnCLeD4ymuXmnOzUvv9zhU1nvdvzUO3Zepx8P2PGMtUroiZmmMdIqUFEMkGCMTucAa5IcvKcH8rErnkd0M5qt6kNJYj5i2GhmrkpXyQ4qwXSkAP2vahBRguVogVwuW3QSe3YzNGzdg0+bN2LR5c4s9103N5k2bsHnjBshMJ0BKeNmN8LIbwbKb1CtXY0r4WUgvg5qq4tf5CaItwbWmkyRFLU6PHj2wevXqetcfNGgQvv7663rXL9pSdMEFF+CII47AXXfdZdzecrkcTjvtNJx//vl47bXXim2SIAiCIIgCNEVC146QEHbdunX4+9//Xu+VqW+//bYoB7CiJ0Vz586NTIgAIJVK4eKLL8aee+5ZbHMEQRAEQdQF541f/iri/BkzZuDJJ5/EggULUFZWhjFjxuDGG2/EDjvskPec++67D1OmTInsKykpweYmtoa3KU1Rly5dsGjRIgwbNiyyf/HixaioqGiygbUV7EzxtojYLYHkqNUuruDZRJY2xy2hspVtHohHrgYQiRydL5p2ktjbFoNrbEE1EHf1t0tfSuu4M+5AYO0F9TweapvDzuLXoq/THoduz9wns5ypwhaopcnoeUz4Jns9A5RYGgiWyCyFpBRmGBLB8ppe5tL1g3rmFCvPmerAElybm5sDY1wJrIUSWiMQXjMpIKVQS3SAWlpjDDXVNSjp3L40eZs2bwb3a4MlwuCe5bs3dugCL42aDetR0qnjfV8QWw7Mcu7oiLz66qs4++yzsddeeyGXy+GXv/wlDj30UMyfPx+dOnXKe16XLl3w6aefmm3Xdb6xCNG8KveiJ0XHHnssTj31VPz61782CdfefPNNTJs2Dccff3yTD5AgCIIgtnha2PvshRdeiGzfd9996N27N9577z3st99+ec9jjKFv374NHmJrU/Sk6Ne//jUYY5g0aRJyOSUyTafT+NnPfoYbbrihyQdYDFdeeSWuuuqqyL4ddtgBCxYsKLotLQ4WkEjz5ACIxgXcnBSeq9Hu6Cazu3bVd4IlIqFtO0CjXdW2BNmBHXV/kfAB5lwZZI0PrC+RNpxrt/pwA1Ka0sm7ZtzeAwuYOT+4TunclyR0hnsbE2yShePyGJDymJX1PhCSS2lcv7XwWZ0cBHEUueh+IMxnFrxnfs5YlJiM/yIx+xIsILG6geu+zpWmEr55YLlaSC+l2uIp00ZN1RqUdOlR+Ca1Eps3bYoGvZQCXAez1OELAGWV4zz53oicul7hq+iaBNEO+WzleuP0kmtiK0ghGPfAGjkp0ue72SdKSkpQUlJS8NzKykoASuhciOrqagwePBhCCOy+++64/vrrMWLEiEaMumUpeoEyk8ngd7/7HdauXYt58+Zh3rx5WLNmDW655ZY6b2pLMGLECCxbtsy83njjjdYeEkEQBEG0GQYOHIiuXbua14wZMwrWF0Lg/PPPx7777ouddtopb70ddtgB99xzD5555hk8+OCDEEJgzJgxWLJkSVNfQrPR4Kxp5eXlGDlyZFOOpUlIpVJNYrqzAwq6QRldPZCNTp2hrUw2JqUGi9ZNKtUYgnrWmOwgjbq+OxYpkagtYgiCOVp6KL3fzibvWol0bnsenM9YstVHq3gYA3yh+5dBCo3oONz+7PG69wMIg1lyICwtKxZjCLVDjoXIDr4YwVgwAmuR7V6vq+igjFpLZC42lWwtYjy0mriBHRlXVhIOMD8H6aUAv9acwxhHbeVqZLpuFb+5rcTGTUog6RmLkO8EurSsR4xHf2bZOiv3HgGoqa5sdzoqYsvm62+r4UuJVJLAs7lhTSC0Dv72Fi9ejC5dupjddRk0zj77bHz88cd1GhlGjx6N0aNHm+0xY8Zgxx13xJ/+9Cdcc801jRh4y1H0pGjDhg244YYb8NJLL2HlypUx0dOXX37ZZINrCJ999hn69++P0tJSjB49GjNmzMCgQYNadUwEQRAE0RiacvmsS5cukUlRIX7+85/j+eefx2uvvYYBAwYU1V86ncZuu+2Gzz//vOixthZFT4pOO+00vPrqqzjppJPQr1+/JleWN4ZRo0bhvvvuww477IBly5bhqquuwve+9z18/PHHeT3jampqUFNTY7bdtVaCIAiC2NKQUuKcc87BU089hVdeeQVDhw4tug3f9/HRRx+ZRPLNwRdffIF7770XX3zxBX73u9+hd+/e+Pvf/45BgwY1SMtU9KTo73//O/7v//4P++67b9GdNTcTJkww73feeWeMGjUKgwcPxuOPP45TTz018ZwZM2bExNlAGNEaCMXCWhxtRMwMJi+ajZ07jDF1niua1k1oV3ZXpB1b+nIEz6p9qx2Wv15kzMGSno6I7WKHB2CMmUzzPNhO1TEH1se1lVctI0aJrLCYMcTV3lJKS4DOwmz3TC2heUE0a8aUG364/GUJroHo8pkU4TIbkFBHRvYZAXa+pTcgLia2+9LHATC9nCRFkA/NceUHANSids03yPToj2KpWb8uKjS3l/FsgnABYBwlFd1i7ShXexWF22Mc8LNhLjgb+x4IAdifNEdiqAIjPOcpNEDSSBCtigiWztyMAi1CC6f5OPvss/Hwww/jmWeeQUVFBZYvXw4A6Nq1K8rKygAAkyZNwtZbb200SVdffTX22WcfbLfddli3bh1uvvlmfP311zjttNMaN+48vPrqq5gwYQL23XdfvPbaa7juuuvQu3dv/Oc//8Gf//xnPPHEE0W3WfS3Uvfu3etUn7cVunXrhu985zsFTXeXXnopKisrzWvx4sUtOEKCIAiCqAc6eGNjX/XkjjvuQGVlJcaOHYt+/fqZ12OPPWbqLFq0CMuWLTPba9euxemnn44dd9wR3//+91FVVYW33noLw4cPb9Jbobnkkktw7bXXYvbs2chkMmb/gQceiLfffrtBbRZtKbrmmmtwxRVX4P7770d5eXmDOm0pqqur8cUXX+Ckk07KWyefK6Jrv9AZ5yPi33oIr11sgbNu1xUee5wVFGBH2kPyzLbQefkE2/nGbluM9Jjd67DbMRvB9aZZNHikEXgn9Ku3VcBMFunHCKs5C9zzg5AEttocyC+odvYnWYnMKYwHAnE3uAEKC6wtEbLUYuyEc421RGTVrz874KQUyK78CjJTXq+M8jXVlWC1G8CEUMEgC40RUGEBAMhUBrXrVkJ6GWMx2rxpk7GOQUqw3CZ1TnBtph0/B3CuBOOmXR665AP5+w+uUTJOYmui3fDl6vXwhQ6V0vKykZZO82F/5+fjlVdeiWzfcsstuOWWW4odVoP56KOP8PDDD8f29+7du6j8aDZFT4p+85vf4IsvvkCfPn0wZMgQpNPpyPHWTAp70UUX4fDDD8fgwYPxzTffYPr06fA8j4JKEgRBEEQHo1u3bli2bFlM7/TBBx9g6623blCbRU+KjjzyyAZ11BIsWbIExx9/PL799lv06tUL3/3ud/H222+jV69eRbcVzUCvXcLVMf3bP0ljpImkqkBoEbLDwie5oqv2rLbySG5UfQZuaX5sRKAN0mWoWWJGHxTRDkEafU9U+xSadewfRx5LtlC543QDXdpjB0KjgrEkGU2SjJyn9UQMgUs+A1JcWYmYSAi4GAneGLreM3u/xvlFJB2LhmkjX0BC2/Ve5Iy1xARtjI0jsChpd3xfxPU3ANimSmRrNkB6aSBdGnHVr9mwXmWezyr9TyQwpaNlChvUN1uXfvCztxa1uc0AT6nP1G1HhyyQjqYoCN5qPlpfRO4dfF0/sB4591Jb4uoTtLK2crXRNGW6t99ouUT7ZNGaajAAKR4GzOVITr3UbLRwROv2wHHHHYdf/OIXmDVrFhhjEELgzTffxEUXXYRJkyY1qM2iJ0XTp0+vV71HHnkERxxxRMEcKU3No48+2mJ9EQRBEESLQZOiGNdffz3OPvtsDBw4EL7vY/jw4fB9HyeccAIuu+yyBrXZ4OCNdXHmmWdi1KhR2GabbZqrC4IgCIIgtkCklFi+fDluu+02XHHFFfjoo49QXV2N3XbbDdtvv32D2222SVF9RFptGYbQPV1FgY6Kk009R3jtMRZZjXGz09uCaqBuwZ4WUrslEL3HSceLySXsxpuKRLy2lvXs9rUAuz6lutb8kbRtwbkaO4vVV+73oTssE35kOSwmnHavMcmNngVXFclfxgHGwlWoQpnftZiap4BAPM2EyhgvrXPMUpq5wbl4WzZ6icmvVe9zNcjWbjTtcpFDJDu9G1k633KftR3JZabHbkXvTiztcQOBMt4ar1TuB0ZwrcMfCAF4ThRwPQaeikTyrl29BLLUiSsWhBBgUqBm/brEUAIE0VzU5JR8wjjetMIYGOdgjYxo3djz2xJSSmy33Xb473//i+233x4DBw5sknY7zh0iCIIgiI4K88IltIa+WMdZPuOcY/vtt8e3337bpO02m6WovaNya6nfBakgkCAzVqDABd8KwAiozPF2IEZE3ybm9tJ9qf1xqxEP+nXL+tQzY7Dqe1aZ5BqvS88Zm27HPs+cbJXGwmPuBYvcA53V3h2Xa1nUViF3H2cMHBKQQbBGO1CjK6J2hMKRfflK+4bY5HNxTzhfeqn4uUgKAaDKiAXJPa6tRYCxBoUu83lsga5lyy1j7WcDa5AM2lcCbOaMmwk/OM+P9i2ib5gWWPuWlcmzwhMYAXY0f1pt5Wp1LzLlSgSedGk8RVYiosVYtm4DNmSFEVh7zndXG0rosEVyww03YNq0abjjjjsKJqotBpoUEQRBEERbh7G4R2lD2uhATJo0CRs3bsQuu+yCTCZjIm1r1qxZU3SbNCnKg6uDYYH1IEj8Ds4Y/ISAhkBUB+NqiIC4ESJ6LK7FsY/ZZdK5+Y4ntavHG2qUouckpfvQ6Gt0S3OuoxHS+/K1p13u82mOgCBoo3bBB4w1IWYlSkyfoTty9DuJQRgDV3V9BxIsL0Z/Y+twtN7GTq+hrUFJfQERa0zip1pAExS5hnzXYo3d1QiZLhKz2eeJHmoFmQxLy7ImJYzpyLYS2ePTWqM896OQpslPlZqh1q5bCYhcg1KiEER9qKr1zYoBc6xELQ7jTTAp6liKmVtvvbXJ22y2SdHgwYNjgR0JgiAIgiCagsmTJzd5m0VPihYvXgzGGAYMGAAAePfdd/Hwww9j+PDhOOOMM0y9jz/+uOlG2UpwFupr1A/hMOCggNIQqb0yrI94gEZNUloLHUgxrBNqcmAdy/frpJC3l30drvbHppB3Wex8RK9Ra4SMNYc5miO3neD8pHFwxsAQD2bJtG5IBznU20nJV41+qIDexry3rBoxvY9M1icBxgKixpagF7J/jbkpLhJ+qalkqyJ2yFhwkqxCSW3VoZcyY03q36pnLFYyT+n2HUuzEvoQqlQmTvBG4dyrBMteJICmpaUqLyu1KhXjX0kQxfHl6vUo9XjwPyD6HaZpSbuLZDyuP2xAGx2JRYsWFTw+aNCgotsselJ0wgkn4IwzzsBJJ52E5cuX45BDDsGIESPw0EMPYfny5bjiiiuKHgRBEARBEAWg5bMYQ4YMKbic6fvJDhuFKHpS9PHHH2PvvfcGADz++OPYaaed8Oabb+Kf//wnfvrTn9KkiCAIgiCaGsYaL5TuYELrDz74ILKdzWbxwQcf4Le//S2uu+66BrVZ9KQom82arPIvvvgijjjiCADAsGHDsGzZsgYNoq2jl7z0HNuXypzq62UzaOFyIHRGKBLW+7gT1DGeHT4qgC4mKGJduAEkNTzSv8qTVuj8SH2EyzD28Xx9Jfcf7VDd4zDHGrOF1EAorLaXzewSiGZq1znIrEzuWhgdNGh1nhBAMTK4BLGzxhJcR+q5AR4jYm4lypZ6aYhHhdBmp92OXSYt0bljq6fgOp8AO9a+KRME2G5pj98NGGcHdQTU/YH6bJLurV3qwI0169cp13/OUbt6CTJbDUj+3AiiAXy+aj3SnOVdOkuK2kG0PLvsskts35577on+/fvj5ptvxlFHHVV0m0Xb0kaMGIGZM2fi9ddfx+zZszF+/HgAwDfffIOePXsWPQCCIAiCIOqA86Z5bQHssMMO+Pe//92gc4u2FN1444344Q9/iJtvvhmTJ082M7Vnn33WLKt1BLTImgPGJKItKZ75yRAqh23LjUn7IeOiYSDaZpKQ2g1+GGmgHsES60skeCSLj0FdgyOQ1uOLpAEJz0sUWpvzEgTUgGU9UfJyZgtxLcFzRBCcKK62+rQCCNrn2mlBDFpwbY0nYjFJssI4bcSsV/mCJbrtaOuN7qpQ0EW7jF1wgmC5ju28YnG7Wet+hQJs/ZnwcDtpf+AukNcAJwTgheO276GxWjkvJgVq1y4H83PKuiUQTVdCEI3k62+rkfGYCuDL49/fGuZ8ZzY3JLSOU1VVFdmWUmLZsmW48sorG5z/rOhJ0dixY7F69WpUVVWhe/fuZv8ZZ5yB8vLyBg2CIAiCIAiiGLp165YYz2/gwIF49NFHG9Rmg+IUSSnx3nvv4YsvvsAJJ5yAiooKZDKZDjcpkoFwxv7tq7E1RkIGvygCQY0wFpjww7IlF8Ky0CRphYTRKNVnjGF9fU5SUMV8QRaT2mOMReq5mqKkIJX6eH01RdrN3ra8xNNgJKTasEsbR0tUUDfjtpdARF+Tz0qTL1CitqzoPq0Aj7odnSA2MfWHa0UqcC3Rm5qsCdLXbPoLxpi3Peta9CcQ00tF+rUfKG5pixK0RM547f7chLSx+2HfJ2tcMpWJj4kgGsDC1euNdSjJSmTrS1s8IAR5n8V4+eWXI9ucc/Tq1QvbbbcdUqmGhWEs+qyvv/4a48ePx6JFi1BTU4NDDjkEFRUVuPHGG1FTU4OZM2c2aCAEQRAEQeSBJkUxGGMYM2ZMbAKUy+Xw2muvYb/99iu6zaLv0HnnnYc999wTa9eujeQZ+eEPf4iXXnqp6AEQBEEQBEEUywEHHJCY36yyshIHHHBAg9os2lL0+uuv46233kImEzVZDxkyBEuXLm3QINoqthDZzjwvHAG2yZzsKbd7pnWnVghgvQQnGGKZ592yPstcgJWTzUKfYwvF7az3ntW/m9/NzmqvXe7tHGYMcNxSo66qDGEmey0y1yVjlrBaOKJnd0nGdcXPV9oCaxEsv/lRgXRBMbEt9Ea4NBRbgkqIuByhgLu+HQog0qS1NKbbYNa57tKYW78YwWQsz5mzROWWoaA6fl4isWVO+76GQvvY6Rywc8Uxvza+BOgu6bnPDmBc+gmiMSxduyFww2dRRxsby7nEQ93f0U0KWYpi5AtN8+2336JTp04NarPobxMhRGKUyCVLlqCioqJBgyAIgiAIIj+SsSbwPmvJWVzzoeMPMcZw8sknm9iJgIpi/eGHH2LMmDENarvoSdGhhx6KW2+9FXfeeacZVHV1NaZPn47vf//7DRpEW0QFUARQ4BlyBdiha7va9oVl9XGzzKOw0NoVUNvYgmZ3pqxE38mBxQqJA93AjC7aSmRbsGxRtt2GDlgpnEFIxkJrUawDyxJRyCphfykk6J4BxAXVdoVIPyZYQKTt2AidLyK7fTvgYEz8bKwcLNw2Y2CBlcQ3wmTJvagiP1/pXosrjM4riLbGI/xw7NY1Rcapx5N473h0XG4/hYTZdvBGKcLgloAJalmwHc6VRTCol+nWO94HQRTBkjXV5r2xtiPIcZkQNLe+1nyieejatSsA9T+ooqIiIuXJZDLYZ599cPrppzeo7aInRb/5zW8wbtw4DB8+HJs3b8YJJ5yAzz77DFtttRUeeeSRBg2CIAiCIIgC0PKZ4d577wWgZDsXXXRRg5fKkih6UjRgwAD85z//waOPPooPP/wQ1dXVOPXUU3HiiSdGZmvtHZlg0TAamuDXgmcdi2httOWEy+A8QEoWPeZYeJK0RYUwVhkdtBFR7ZBxG3U0RPY6uNtDXa77jDHTvj2GeDuOzglSmV9czY4bINHRooT7naCJtqbIdsW3x+q2kfjezbVSPyfbfLqemJXITXdhv7etNsyy4RkhmweTUkPvt59JN1hjXcEdIwONu8tHxp4vJILbflLemkggzOjnnFdbZAdfFEKdx53x2CfZVqYO8iVPtA7frt8IX0hkPBax/OvvX8/ZNnojqO/algzeSLnP4kyfPr3J22yQQjGVSuEnP/lJU4+FIAiCIIgkyFKUyBNPPIHHH38cixYtQm1tbeTY+++/X3R7DbpDf/nLX/Dd734X/fv3x9dffw0AuOWWW/DMM880pDmCIAiCIIiiuO222zBlyhT06dMHH3zwAfbee2/07NkTX375JSZMmNCgNoueFN1xxx2YOnUqJkyYgLVr1xpPtO7du+PWW29t0CDaKkKqBQBtuHeX1BKX2KCWlbRp1eMMnnZJZ+oYt8yuuo1iSztydF0W0WJMvLZLf9L59jiEDATpSBZnm3MK9W8v++ibZP8i0u+TXl4qXnopSPeVyqgXTylxMeOq5J4pC74Yz1/q8dr7g5fuT3oplbcooQQL8hkFYzJjBMxYw2zznnWPmNpWH1C4bb83Y+SI3F9dr65rjNS3lwOdMvFztR8gHl4nEC6N1bXkxzgy3fvG91vnS4/c8YniWbp2A5ZXbkDW+iK1l87c71sgKhfg1nd5S6FznzX21ZG4/fbbceedd+L3v/89MpkMLr74YsyePRvnnnsuKisrG9Rm0Xfo97//Pe666y786le/ikSR3HPPPfHRRx81aBAEQRAEQRSAcSRmvS/m1cEmRYsWLTKu92VlZVi/fj0A4KSTTmqw41fRP7MWLlyI3XbbLba/pKQEGzZsaNAg2iLKyhNu266YSb+UjXO3I0QW0g5oqCpKKeExbYHSFqPkX+HaLd8I/zhLDsaY8IslIqwOgjK6Y7TbdnOXRepZ42II3OsBE9RR1WcRN3xzir0vKTCiXdqHgj9gMwxXXJwv91isoag7t4rV6JRIuIW6PX3ALaH7c+oBoQVDW2l40J5+qPQlJIm2OYcEj+Rwi7ml227zNkmCacD6MPIItO1r0fUjY0oQftslYAnlZfyYrsIcd3y7dIJxAjnUrl0eD9roh+dlevSP9UEQ+Vi/cRM2ZAXSxs8h+F5l0e8y+/m2reC2o0mLiqyJRPr27Ys1a9Zg8ODBGDRoEN5++23ssssuWLhwYeJKTn0oeto4dOhQzJs3L7b/hRdewI477tigQRAEQRAEUYBCUoJiXh2IAw88EM8++ywAYMqUKbjgggtwyCGH4Nhjj8UPf/jDBrVZtKVo6tSpOPvss7F582ZIKfHuu+/ikUcewYwZM3D33Xc3aBBtETsAopDQkRahf0vYVpR87utSSnicwRfSuHCq4HrKauTB0ghpF/rgfDsbsxu7T9ez6xdL0piTMtwnuegnzb8lEoI1mhTrgbULPJIuQlmcopnag16DUulYpIxahvJlis+XSd60ywNrSJ5S5rNa5bNIFQyQGH4BRVJ5iJwakw5SyEX+PjxVaqtR7AvNSyWHJbDvsZ+L6wj0eV4q/7W4YQ5EeO8Tx2vc760wB9b1xyyESf14KcDPRYM7Btv2Zx2xnhFEEVTXChW7FIgEz/WD7zf9DZ+vBKKa0Ba1FTXFpKaD/c3ceeedEMF3xdlnn42ePXvirbfewhFHHIEzzzyzQW0WPSk67bTTUFZWhssuuwwbN27ECSecgP79++N3v/sdjjvuuAYNgiAIgiAIor7kcjlcf/31OOWUUzBgwAAAwHHHHdfoeUhR08ZcLocHHngABx98MD777DNUV1dj+fLlWLJkCU499dRGDYQgCIIgiDzQ8lmEVCqFm266Cblcru7KxbRb7CB++tOf4pNPPgEAlJeXo7y8vEkH1FYw8lNLO2qCDbOoSdVLWDrTJWcA91hsaSp0rbfc3aGW1IRtqzVLVkEEbC2wRrTU40oSSrsC66TI1PbyWNK1RevXz2icJLR2l2kSl1XMchNCca8VhVm3pl3ZTd4vZ7lKHY8vv0Xzd+VfDsu75JPnWuyxS/sLyA5p4KUjY4QU0aUgt9TRnL08Qmu9BGYLu63jMpWJjlcfN4Jv5zzTvrNMxhEXfhe6D9Z+8yhb9Yzg2o1c7S7ZWaU+n7kRrgmiDlZVbTQOLkAob7CF1kCyi32SoDoMXdJyC2iUEDbOQQcdhFdffRVDhgxpsjaLXj7be++98cEHH2Dw4MFNNgiCIAiCIIhimDBhAi655BJ89NFH2GOPPWI50I444oii2yx6UnTWWWfhwgsvxJIlSxIHsfPOOxc9iLaIQDQTvf1r37aquNYZXd/jLGa1YYAR9GlXe+7IlrULvy3wU+NhieJu18ITZqovfH121mc9FjfbvdFJIyo01IJq7YKfVIb9IBRaOzm3IhndWZ4M78YyAcuiwyLHTcZ5IFGA7VJIkG2LgmWC+FnyVDx3m5vJPhiXdKw+krHQamZZPUQ+ATMACN/UixxPutZ8YnBbeG1fq85Ozz3LnV5EBeF2vxyAyEGyMKu9FnLXJX4HEBWEu8JwuwQABCZxXc93xfgEUT9WVW2EL2XEQUVvu0JrP/j+FVKFP5FSJn7PalrU8EJC6xhnnXUWAOC3v/1t7BhjzASXLoaiJ0VaxHTuuedGOjcPVwMGQRAEQRBEASghbAwhmv5HUoOCN24J9OnaCTVg8G03/OCYtvpoPGch2rYisch+ZXPhjMGEBNPpPoI6LI/2KKZb0n2zZNf6xGz2drDJQO/kWqDstu1xuxYgPXSPMRUmwASAjNfJSz4djfNrxrZYJR13rTJ1rbsnao8Syvh5+rOKBkyMaKacuoAVmkACUgfjDIIumrZkQp9SgGkLFbxEi5RkaeckV22mgy6q8yW3SgDgwfkMkfpG+yRV/ywYD7jlxo+6711k29EIxaxFjCPTdStTvXbNN5H6ea1pBJGHyg2bAi0Ri5VA3Pqjv8vTPLC8B89nNGij9V60oBGALEUF2bx5M0pLSxvdTtF3aPDgwQVfbYE//vGPGDJkCEpLSzFq1Ci8++67rT0kgiAIgmh3FPv/dNasWRg2bBhKS0sxcuRI/O1vf2u2sfm+j2uuuQZbb701OnfujC+//BIAcPnll+PPf/5zg9os2lKko0e6MMZQWlqK7bbbDkOHDm3QYJqCxx57DFOnTsXMmTMxatQo3HrrrRg3bhw+/fRT9O7du6i2enUpx5r1G5ELxDYCoXeYCcSIUEMERPU3EnEri1tqfU4kMBjiWiJXI8QhI8uWdmmvgSfpnVwtEZBfo2QHZbS1RGF7UeOFazSJ7HetSFKG1hdbjhPsNyUsr7MEzZFtuRBgsfEUGl94/cnaKLuElBEFmPtZR7RXQd3EY8HFJAeGs/oEh+d55p6YU517lq9076U6yQ26iOi91qXwjbYI8CCFbzzlJE+FwSeTPhO3n8iNzq8pilnoWKACsVOx2OPmlAyWyM+a9RtRK2SihkiX9ne5x6Lf5ea7GjL2N6JpSY1bUyR0Lfb8Yv+fvvXWWzj++OMxY8YMHHbYYXj44Ydx5JFH4v3338dOO+3UqLEncd111+H+++/HTTfdhNNPP93s32mnnXDrrbc2KFQQk0UmCOGcR7IIm4asB+273/0unn76aXTv3r3oATWWUaNGYa+99sIf/vAHAGrNceDAgTjnnHNwySWX1Hl+VVUVunbtisrKSnTp0iU+KXJy5RiX9TyTIi/P0pMmFgXaOlcdr3ty45buefbymVsfQGwSleSab6Ovpa5JR75/1OZ4fSdFSf/QTSMtOCmyPhf3/iRNcApOivLsd/s0z1WrToqgBN96UsSsiNy6bMykKJjcSJ5CSZcepmrt2uWxCNeuW39mqwEgiCTsSZEWWAOIff/l+y43S2wFJkXr161B7/4DzP+L5kD/T1qxfHmj+6iqqkKfvn3rPd5i/58ee+yx2LBhA55//nmzb5999sGuu+6KmTNnNmrsSWy33Xb405/+hIMOOggVFRX4z3/+g2222QYLFizA6NGjsXbt2qLbLHraOXv2bOy1116YPXs2KisrUVlZidmzZ2PUqFF4/vnn8dprr+Hbb7/FRRddVPRgGkttbS3ee+89HHzwwWYf5xwHH3ww5syZk3hOTU0NqqqqIi+CIAiC6Ki4//NqampidRry/3TOnDmR+gAwbty4vPUby9KlS7HddtvF9gshkM1mG9Rm0fbn8847D3feeSfGjBlj9h100EEoLS3FGWecgf/+97+49dZbccoppzRoQI1h9erV8H0fffr0iezv06cPFixYkHjOjBkzcNVVV+Vts0dFNDjlmvUbjUUlZcys6pgR60UEzdFtIGohcY+5lgzmCrPthmEJevVyHMJfP7q0LU1uYElNkji8UGAyp9tIaYwSMl7f3i/B4F6WfU2xQGO26dd5b+rKeP9J4wGiVjoJBKJ6VTLruN5fV5iDyDVYv0Q1bm4l1Xb0uDsGX6jPX1oWMEhr7M61GaG+hDkvSeAN5oXnBUubUlqfiRFi66UyBli560xogqRgk+YmWO9FnvdWPSZyqK1cHdTJwQRzTBBa09IZUYh11RuNpR4I3Q4iVnMgEswR0N+X6m+NSWmsowzKMsmFExqiBYXWKnhj/u/k+rYBAAMHDozsnz59Oq688srIvob8P12+fHli/eXLlzdq3PkYPnw4Xn/99Zie+YknnsBuu+3WoDaL/mb54osvEs1uXbp0MSKn7bffHqtXr27QgFqaSy+9FFOnTjXbVVVVsQeGIAiCIFoTKeM/7BrSBgAsXrw48n+8pKSkcQ23EldccQUmT56MpUuXQgiBJ598Ep9++ikeeOCByBJeMRQ9Kdpjjz0wbdo0PPDAA+jVqxcAYNWqVbj44oux1157AQA+++yzVplYbLXVVvA8DytWrIjsX7FiBfr27Zt4TklJSVEPhM5670sglxPwuEqZYf/ScLUgMvgVbowZ9bDA6PpchwNwzknSuoQWnrqDOtpC66TQ9roP3be+prp0LPqPLqLJiQi6k8ctAXjamuG251rawBN1NbF+69AGJWm3fJGstdL7XS2dOS6TxNRR0bsv47ouu42sSNaB+bodER+Tfh6TdGJZkRB4TubROrn7g8vkjIF5aTDhh+k1mAcI3wiuIxojFztNiPkA40ElzbbWMNnHA2tRJOgk55CZTrHuiObH//o/kJlyQArwzesh1q5Aao+JrT0sw7frN8K3zLqusNq22Jpt/f0G6+vGeTb1M250dnaddkaXLl3q1BQ15P9p3759i6rfWH7wgx/gueeew9VXX41OnTrhiiuuwO67747nnnsOhxxySIPaLFpT9Oc//xkLFy7EgAEDsN1222G77bbDgAED8NVXX+Huu+8GAFRXV+Oyyy5r0IAaQyaTwR577IGXXnrJ7BNC4KWXXsLo0aNbfDwEQRAE0RQIKZvkVV8a8v909OjRkfqA0iE35//f733ve5g9ezZWrlyJjRs34o033sChhx7a4PaKthTtsMMOmD9/Pv75z3/if//7n9l3yCGHmEBXRx55ZIMH1FimTp2KyZMnY88998Tee++NW2+9FRs2bMCUKVOapP2uncryHtu4aTMAhOvRgFqT1raSfM9jQkoGFbTP8mSyvB8A2zPCNfOoTtIJ5h8RWBzMIPVbp16SlshYvhztUD5NkRt6QB/nYJE/TGaVtpee227kCh3Nlv13ni/0gV2KQK9jfxzaoqLTs7hpXOoKf2AP07YWFfL+c/t2rToAYr9w9Q9gPaZIKhoLvV9bkfKlcClURm59kIZFPcdW2pOkBLEuSZ5pSdtuoteEX+Hkcda65Jb8F7KkM2RJJ7BcLYQUYJ2ax+uqIdRWrgZ4ecRiCgBgLGIxT7IGq+MsoiWKpNthLCxNnUauZxWBlv81to1iqOv/6aRJk7D11ltjxowZAJTmeP/998dvfvMbTJw4EY8++ijmzp2LO++8s5EjL8zcuXNNovrhw4djjz32aHBbDVIrcs4xfvx4jB07FiUlJTFBaWty7LHHYtWqVbjiiiuwfPly7LrrrnjhhRdi4i+CIAiCIPJT1//TRYsWGWMIAIwZMwYPP/wwLrvsMvzyl7/E9ttvj6effrpZYhQBwJIlS3D88cfjzTffRLdu3QAA69atw5gxY/Doo49iwIDif0AVHadICIHrrrsOM2fOxIoVK/C///0P22yzDS6//HIMGTKkQcGS2hJunKJiyGcpqjO0er4knnYVx1Jk9ufxqEqy9ggpE38p1MdSlGixkfn35ztf2p5TCWjPj2Io9sdaUswhtT/ZWmNbY/JpgsxYgtK+hLosRYX61ufpdpI84Oy23B8orhdcPv1YEuaXs36e7V/PwTYQjR0UsfrYZWIHeWJOJWF5rJGlqPXILfkvZKrUWIpY7Qaw9avhDfteaw8NgLIUreflMcsogHpbijgSLEVJ4kkpsL6yEr0GbdMicYoWfdM0cYoG9a9/nKK2zvjx47Fu3Trcf//92GGHHQAAn376KaZMmYIuXbrghRdeKLrNojVF1157Le677z7cdNNNyGQyZv9OO+1kNEVbKuVlpSgvK1V/L477pOtmHpnc5Js0Wf8g9CSLSRl5D8SXmvItQfHAhGwvWdlwxiKTEsbCV2xojsDZLd0o2NpzQi+R5Vu2sesXU9r92eN3x+FOiOzlqKRI4LYQs5BI2p6rmCVPpw8t/tSl2S8R2xbSKp3zdN++kEowb50vpTTHk0q7PWG1b5fRcUjVD2PQeeUkTwVeAJ7ax1NhtN18Lxt7n1sn6TzGldhav4gWx5//CgBAlHaFqOgNUVIBUdYVMl0GlLWdf66VrNz8HQDxHxH2Urje5s73Zkz8n2dCFKnbAui/7ca+OhKvvvoq7rjjDjMhApSc5/e//z1ee+21BrVZ9DfMAw88gDvvvBMnnniiSUEAALvsskve2AUEQRAEQTQc/YOlsa+OxMCBAxODNPq+j/79+zeozaInRc0RQbKjUV5WirJS9WJSoLSsLJZNWS9H2C8mBZjIOWZbkfjSViIOZTnSpceV+dfdr/d5nAVhBFSZ0tt5zrNfZtywhdNxaxVjSrBsl64Vy9NWKSBSJgm66yrd/iLjyyO41hYzN2ill1ACql3OoiWzxquDZOrSfa/biJwTlKmgTfs8WH3blip1bdHzOYNplzEWq5dU2l+O9jXp9qJlglXTWHO0ObFIoXV9xNf234AIX7VrvsnfF9E8dOoOf/FHQCoTflf5WUBKeIN3ae3Roaa6EuuqN4Z/Q/qZtv6OPc6Q9tT+VBBKJTzOghAowfeZnd5Gl1JE0t2wpOeYaFFuvvlmnHPOOZg7d67ZN3fuXJx33nn49a9/3aA2ixZaN0cESYIgCIIgCtPBDD2N5uSTT8bGjRsxatQopFJqOpPL5ZBKpXDKKadEMmusWbOmXm0WPSlqjgiSHZmSThXqjRFQB+kVGFMB8ixhtRHp5vn1oZNxGqSA5F5iokJ3O9aW/ePfEnAnnqeDl9n1guV1AQZu9V/fhKz5kuQWOq8+pXs9Gjv4pB3MUafTkIjuTwry6Ja2G78bQNHWJbli52KT+RbSNdnnJaUWcevpsdqhB/KV9r3jUClDOCQk9wAB6EB2YfBGL57NPsnRwNmf6dYbtetWRp61yLNnnyoF/ThvBbzBuyC39BNkuvVGzfp1gMgCIod0n6GtPTQAQJVIm/d20FoAwd+9jO23/941kjFwYT+7+sslIeBoC9MUy18dbfns1ltvbfI2i54UNUcESYIgCIIgiGKYPHlyk7fZoDhFOoIkQRAEQRDNT1N4j3U07zPNypUrsXLlSggn2fTOO+9cdFuUarqFYEHWb70EFmYzD8Wk9rJZLPaLjnRt7VPLFn5QH4llbBxIXpqo6zx7CU21A9gRt23ht9nvlDrTu6oXCp8ZCyN0KwF68vluOyxY+rKPh9cTLOkZ0XJUgB1mzw5N53oceolNoyNg2+fp/WmuTPApHi4/6vvjsbDhyPKbDkkQCJ49Y9cPtoOlMm3212Uh4TRn1sW5OOr0iEAbUUG3XdqtmeVHvTdY4pI8FV3yYrLuZQZnf+26lXHHAtOxEwsp+BuoXb2E4hW1IOKLd8EB5JZ+YjLOp7besTWHZKhdtxLc6wzAXhoL/z7034b9t+t+DwCW8wtgldLZduMXtdxSmghejW2jI/Hee+9h8uTJ+OSTT2ITPsYYfN/Pc2Z+6jUp6t69e72jVtdXzEQQBEEQBNFQTjnlFHznO9/Bn//8Z/Tp06dJsmvUa1Jki5m+/fZbXHvttRg3bpxJ8jZnzhz84x//wOWXX97oAXVUIhnFbcG084va5JICEkWq9vmJ7ST8Qk8SaNvtJrbnnqdzXTnC7kgp/Pg4tEXBEWIDUeG1lMrKlE8wnlTaxyPX5QjDkwTgkftjjcPdtoXXrjDTFWx7Vume67F4zrV8AmdXtJ1PqK3GEOZeKyQKt/uDsz9yLwq044v4PWAMynlAcnM+4EFarstJn03is1pAYJ1Yh2gxRJX6sZvadu9WHkmcmkwFRE6aIKq25dP+29AU/L8Ze0bbjtBayuj3VEPb6Eh8+eWX+Otf/5oYJqih1GtSZIuZjj76aFx99dX4+c9/bvade+65+MMf/oAXX3wRF1xwQZMNjiAIgiAI8j5L4qCDDsJ//vOfJp0UFZ37rHPnzpg3b15sEJ9//jl23XVXVFdXN9ngWoPG5D6ri9o13wBeBpmuW6GmujK/yzIQX9M25hVtebEsSgnbsbYa+Qs7YmnS74v95WRZjSK7k0IA2P3Y++tjTbD7a8S12+EHTJN53P6TQgMktmlZoADnFywKW3tiv3gT2s+X866h6H512/lCKWiNV73yo0U6cDREjp4odl7E+shJV7SFU7lhk0lbA4RaIq2XU/viWqK84UtimqGopihi+QRQtW4teg0d1iK5zz756htUNLKP9VVV2HFI/w6T+2z16tWYPHky9t57b+y0005Ip9OR40cccUTRbRYttO7ZsyeeeeYZXHjhhZH9zzzzDHr27Fn0AAiCIAiCKAx5n8WZM2cO3nzzTfz973+PHWtWobXNVVddhdNOOw2vvPIKRo0aBQB455138MILL+Cuu+4qegAEQRAEQRSGvM/inHPOOfjJT36Cyy+/HH369GmSNoueFJ188snYcccdcdttt+HJJ58EAOy444544403zCSJSCbTI0xQV9K5q3m/edOmAqLUqNCvrmWzJCG2vdjhHi94XkK9ekUpzlciWTht7y/Ynhms7QIeF0AagXiBfmPtJGC79SdFzLYF3FpM7Z4LOOcGbemlqEJLZHZZ15KaFnIDcXE48rTjUmgcDDDRv/2EcXtgAFNR2sNnTkCnV3R/n0aeTcYBkYt/xpxHImS7zzKg3LEz3XonXA3RkanZsB6bpAdf2n8D6hhPeLh1SAkAsb//wo4izvdv4DDTGkg0gdC6SUbSdvj2229xwQUXNNmECGhgnKJRo0bhoYcearJBEARBEARBFMNRRx2Fl19+Gdtuu22TtVmvSVFVVVVRoqz169ejoqKiwYPa0igtK4vtq61crQLjAQAP8qXpXymW9aZepR2kEYAJApkQFLJQO9KyxhQqmRThLxLnuM73ZoJA2mWS4DZfsLSglNY1Sue+6JxcknFw4QTNdPsBEq1RbrBKsz/4VckhIRFkqLeCSdrXBscKxqAsV8aekiBeTgoF4OWpo7FDBehSOP3aZeQ2WGUhqxSsbTj7ow06hnpbnA9HuG8fL0Dis5zdXOd5RMeids038Mt6AL4IA6QGMMYSBdaJViKrNMFrtRUoj9C6NRPvCSkb5TSh2+hIfOc738Gll16KN954AyNHjowJrc8999yi26x38MZly5ahd+/6mam33nprzJs3D9tss03RAyIIgiAIIopE45e/OtaUCLj77rvRuXNnvPrqq3j11VcjxxhjzTcpklKazutDNpsteiBElEzXrQoe1zqkSKbyfJog92TGo/utX+mF2jF169AOJf7h1aExylvPGVdd2+54TWmno6iH5qngfiASxBIIflCy6K/RQoEozeUmRFHMFzAyn1aoUD2gfpok1U4QPDJP6dZz6yvtlPWcqNowN4gxAFyVgaVNBnXz6jSiBqZImhu9M7vyK8h0KTLd+ya3QXQINm/cgM2CAZlugK8+e/tZ9JLERAEmZIbWDgH5vy+TNEXcizyzrms+0TosXLiwydus16Ro0KBBRXmW9e3bN2bGIgiCIAiiYVDwxvzU1tZi4cKF2HbbbZFKNS6la73O/uqrrxrVCUEQBEEQjaAJ0nx0tPWzjRs34pxzzsH9998PAPjf//6HbbbZBueccw623nprXHLJJUW3SYmE2imlZWUoLe8Elo268+crAYRLDlKo5QprW1PwfN1GUGrha1LpvhKF0lIoU3YBIbU7rkjf9jiD5RdT5jkeaT/B3T9RiKnHae0PTfBSvSzLvXSW0ZJK+xyPK7d+/dLLAG6ZJKTOd9xdOoNTJgmo9epDvpIFL9f12RzXDcU+Syfct7UMGannbic9A+YlIy9Wuwm1q5eA6LhI7sHjzLwYi5acqWeTm/2IvqQEE37kO4n5WUD4qrS/F4UfPl+AWTrLG22faBUuvfRS/Oc//8Err7yC0tJSs//ggw/GY4891qA2G2dnIgiCIAii2RGQEI009TT2/LbG008/jcceewz77LNPJGn2iBEj8MUXXzSoTZrutnNKuvQAhA8ZiKe1G78rNAagft3YQlj75RA7P6GMiZkdwba7LxYEMqlMOC7dvhL6DgXQzvXrbVN66nwT5iAorSCSBcdnCa0BQIBBMhZ67sqo0DqxbQf7XNOGY1gBEAnOaJc695O7vz7BIAEllFbnFS6190tSfSElfBGIyGP3zLUSWaalpOdPb/Pobzb92asXQ9Q8J8ByNWQt6sDo59wL3O5ti6W0nnkgzzKTY/2FtvYG1iFlLbKsQ4Wsyq0gsHaMow1+dSRWrVqV6BW/YcOGyCSpGGhSRBAEQRBEu2PPPffE//3f/5ltPRG6++67MXr06Aa1SctnHYCSLj0AADVVa5TrqBvcMcHFva5fOpEgj/q9FMYd1f7BkeQK3+AgkO74CmmL8mxHrGPOteugi4X0PnnHYf1a1PU4JCD1/UIk/EFdbbuBIe1SBulDAMsrOI+mKF8JhOlH7NLVFHmBu319NEWw6utf6uEv9rDfeHoYy+QVK/M8i3q/cFLgFIDlagoeJ9onmzdtQkq71EuprEOMgQdWypTjjm+n5AFgvr8QaBjN82RrERkH82tDa3Bd31MtbC0i77M4119/PSZMmID58+cjl8vhd7/7HebPn4+33norFreovjTIUvT666/jJz/5CUaPHo2lS5cCAP7yl7/gjTfeaNAgCIIgCILIDy2fxfnud7+LefPmIZfLYeTIkfjnP/+J3r17Y86cOdhjjz0a1GbRk6K//vWvGDduHMrKyvDBBx+gpkb9MqusrMT111/foEEQTYO2GAFxbY2hgHbHlFqzY+l5Sss7xXQ9ur5MOoen4logezwNKO127e287bvaIXs7j94nUur6BTRIRlOUoBuqq4+66pnjdWiK6lv6ebRG9dEUudokextwPN7MdSRoi8xFCevnfFQ3Zs4x2iLnuYs9w2G7TApkVywE0TEx6YACj1DbW1NbKiNGScYsi2NgJTIeZoFHapJnKhD1ZHW1kfm8c5sRLbRu7Kujse222+Kuu+7Cu+++i/nz5+PBBx/EyJEjG9xe0ZOia6+9FjNnzsRdd90VCdC477774v3332/wQAiCIAiCIOqL53lYuXJlbP+3334Lz/Ma1GbRmqJPP/0U++23X2x/165dsW7dugYNgiAIgiCI/DTF8ldHWz6TeS6opqYGmUymQW0WPSnq27cvPv/8cwwZMiSy/4033qAEsG2Aks5dUbtupXJn5l5coKoD32mkH5ba1OyIZJkU2LxxQ1TEnE+AWEAgHRNA11Xayy8F6sWWCK3z6yuoNvtNUEbEzrdzl7lCa7cd01aBMcT6dvowx4PlAI+zegmu3XoAjMAaQCyIY10Ca533LBRax11dGQtcpe3rT3rm7OdCB8SEswzhLkkIZ6nCbc/5XmQih+zyL5Duu21snET7w1/4PthW20SXXwOMQJpxAFw9s/pZl4gIrJnI5V0qy+tQodt3c/NJoZ7Lllw+k7LRWe4be35b4bbbbgOgvM3cvKy+7+O1117DsGHDGtR20ZOi008/Heeddx7uueceMMbwzTffYM6cObjoootw+eWXN2gQBEEQBEEQ9eGWW24BoCxFM2fOjCyVZTIZDBkyBDNnzmxQ20VPii655BIIIXDQQQdh48aN2G+//VBSUoKLLroI55xzToMGQTQtmW69UbtupbKgcE9ZU3jK/OoBHBf9SEA9HtZ3fgXFhLBuULM8ZeS3SX3OA2JWGck9Y3lR4/NiVhsZGb+X1/JihiKlyW4vpbL65DtPBmJjARU4LkkM7boBu20JMNWHe21OX6YPGRWN+kIaQXOh0hZmJ6X80J+Hm+3eBGmUEowxSCnhcWaOKzf8wL0/sEbZ1xyxbiWFWGDJGcltkbwragUA2NkVzHERHtTtRz5bQdaiDoLovBUigT/tlBuMA9IHY+rz199bkZAQtpVIW3g4Ty69VN3fTyIXholoQcuLL9SrsW10BBYuVM4UBxxwAJ588kl07969ydouelLEGMOvfvUrTJs2DZ9//jmqq6sxfPjwiPmKIAiCIIimg5bP4rz88stN3maDgzdmMhkMHz68KcdCNCGZbr2RXfkVZCoDeJnw15X+hR37Ja/NEvmDLkaqB/vMn1g9tUUF90fcXgvocPJofZJShsQtGJb1J0gXAASXDhZrF9Zxu3Tbi3iba9fgpDZk8rUlaYiAqLVIW2fyla5Lspsg1tUS5QvaqEN2MsYiwd4YQuuT7se4SAPgIkEXFNFY5UKNB0LXZmYH/Ex6Lqx2Y0Eh7b4ctHt+us/QxONbOp+ecRR2uPPJ1h5GQbIrFkJmykzCVoOrOUTwbGgdH8IEzkwKwK9V1h1tLdcmE6eUvtYOCRMKwvSnS+3Wb+8nOgz1mhQdddRR9W7wySdb749syJAh+PrrryP7ZsyYgUsuuaSVRkQQBEEQjUdIaWKNNaYNojD1mhR17drVvJdS4qmnnkLXrl2x5557AgDee+89rFu3rqjJU3Nx9dVX4/TTTzfbFRUVrTgagiAIgmg8OvFyY9sgClOvSdG9995r3v/iF7/Aj3/844ji2/d9nHXWWejSpUvzjLIIKioq0Ldv39YeRpsg3XsIACC7ahGQLlWiZ56CyU5ui1YdQWGSGDbiVq8F1HUIpl0SRcbgya7o9agXEUCz6HKTFlDbouUkEXNEw2m1YyvEbdGyLTLO1x4QPabHYsbk9q3rOX1xxozAWpd1CbBj2zKe76yQ4BqIC6/1kprHwnxq6qDluqy3zQeTHOKhTmwnACAmhpVeCkwvc0hfORMEyybudz4TOWRXLUK616D697+F4G/OtvYQ6kQvfdZWro4KnYG4+3zC9xeA+NJZomNHNF+k9Kx/jXZ9QD179h860aEoOqL1Pffcg4suuijiAud5HqZOnYp77rmnSQfXEG644Qb07NkTu+22G26++WbkcrmC9WtqalBVVRV5EQRBEERbQnufNfbVHHz11Vc49dRTMXToUJSVlWHbbbfF9OnTUVtbW/C8sWPHgjEWef30pz8tqu9169bhn//8Jx588EE88MADkVdDKFponcvlsGDBAuywww6R/QsWLIAQzXTH68m5556L3XffHT169MBbb72FSy+9FMuWLcNvf/vbvOfMmDEDV111VQuOsuXJ9yu5Zv06ZTJICI5Yl9C6qOCLFoUCGObLCeaeV0iU7JauQNouC50HxC02ACIu70nWIbvdQm0X6jNfGclCb/XhCqoLCazdsq7gjUIqwXV0fygkB5BsJQJMcEaTa6pQgEb7eanLquR+z5ibKCLPqbZqslwNatd8g0yP/oXb3cLIdClr7SEUxF/wOrxh31MbIgf4Vi6yABV2xLH+IHzG4edCAb+UgMgG1qagDILXapd+bW1ifi54fnRfUecA1XnLrkW1Ze8z/f//T3/6E7bbbjt8/PHHOP3007Fhwwb8+te/Lnju6aefjquvvtpsl5eX17vf5557DieeeCKqq6vRpUsX810FqO+tSZMmFX0tRU+KpkyZglNPPRVffPEF9t57bwDAO++8gxtuuAFTpkwpegB1cckll+DGG28sWOeTTz7BsGHDMHXqVLNv5513RiaTwZlnnokZM2agpKQk8dxLL700cl5VVRUGDhzYNIMnCIIgiCbAbwKhdWPPz8f48eMxfvx4s73NNtvg008/xR133FHnpKi8vLzBkpcLL7wQp5xyCq6//vqiJlOFKHpS9Otf/xp9+/bFb37zGyxbtgwA0K9fP0ybNg0XXnhhkwzK5sILL8TJJ59csE6+9CKjRo1CLpfDV199FbNsaUpKSvJOmDo6JRXdwvQddnBH55eYPl7fYI35gifmC4qYpP3RuhjAOu7ob2yrjBuoEECivqY+JRDqbrQex/4yCV3a43ofu52wjdDK4pKk9dH1RcQaBGSFNG70zOyPj12P2XyGefrJpylyS1+oYI6+0MEclaZIfZaWHsM8A/qDUlqjyHETQBTRZ43xvDo0daH2e8ul2jwjajlfCkSexdBaVNiMvyWy3R8eb+0hFKZTt8im0TTGgikGejM/F3Wj1xZF13qdWHrqmQ2C3eYLNOriWrzbC65MpDn+D1ZWVqJHjx511nvooYfw4IMPom/fvjj88MNx+eWX13uCs3TpUpx77rlNNiECGjAp4pzj4osvxsUXX2xubHMKrHv16oVevXo16Nx58+aBc47evXs38agIgiAIouUQaLz3mJ7Wuash06dPx5VXXtm4xi0+//xz/P73v6/TSnTCCSdg8ODB6N+/Pz788EP84he/wKefflrv0D7jxo3D3LlzmzTvaoODNwLNOxkqljlz5uCdd97BAQccgIqKCsyZMwcXXHABfvKTnzRpCHCCIAiCaGl8IeE3clakz1+8eHHk/3c+K1Ex8hXN0qVLMX78eBxzzDGR8DhJnHHGGeb9yJEj0a9fPxx00EH44osvsO22dafomThxIqZNm4b58+dj5MiRSKfTkeNHHHFEnW24MCmLs/8NHTo0ImZy+fLLL4seRFPw/vvv46yzzsKCBQtQU1ODoUOH4qSTTsLUqVOLMgtWVVWha9euqKysbFOTvuaiZsP66A7bRGy5q7r7TF3Xfdqtk4ekXGRAw7SL+Za+iqGYHGGw2nfFzXrlSC+3ud9hdl4xV8Acvaawvj0GxljBMeRbDjT91+Ne2Nfpjp8z1a/Hw+jfrjjfiFq18DkiTnWer4TIxKaeu8RhRbdmbnuFHhzGIFMZElon8O0fpqHnz29u7WHkpXbNN1aeMRH9nM3SacL3jX4utNi/DgcQAJFwI6Z9V/zvPPPrq6rQc4fdm/X/hf6f9Ne5n6NT58bF3dtQvR5H77ldvce7atUqfPvttwXrbLPNNshkMgCAb775BmPHjsU+++yD++67D5zX/b8gMr4NG9C5c2e88MILGDduXJ31C7XPGIPv+0X1DzTAUnT++edHtrPZLD744AO88MILmDZtWtEDaCp23313vP32263WP0EQBEE0F7IJvM+KtIEUJV9ZunQpDjjgAOyxxx649957i54QAUryAiidcn1oDo/3oidF5513XuL+P/7xj5g7d26jB0S0LEZADThi2WhQM13PDaZoKJDl3lRxBNa2O3shQbSmLkE0YImD6xAPu1YfO8AhoM5X41RvsjoOHKzzgsCIqr9A3GyE33Erj7G6WH74SkCtLC/mMzGC6bAtve0xCR8635kSPtti8OQyKpjOZ63S49TBGt16MviwZHAJMgh0CeaBCd8RXPtxS5CLLd4H4mLW2C93DkC5ZRt9tqls/ZJ34yLUJeLegpGtHEalTrwMIDar966VyHzWCZ89Y/mtRNqxJCk4LU+F7WsSrEQR0XcL4cvwO6ExbTQHS5cuxdixYzF48GD8+te/xqpVq8wx7Vm2dOlSHHTQQXjggQew995744svvsDDDz+M73//++jZsyc+/PBDXHDBBdhvv/2w8847N89A60GjNEU2EyZMwKWXXhqJfk0QBEEQRMdm9uzZ+Pzzz/H5559jwIABkWPmh2U2i08//RQbN24EoJLKv/jii7j11luxYcMGDBw4EEcffTQuu+yygn3ddtttOOOMM1BaWorbbrutYN1zzz236GspWlOUj5tuugm33347vvrqq6ZortXY4jRFVWsA7plfTknk1RQBiRqk8Ly4tSix/TxPYD5Tsav5yYfr0p60bet5CrmkJ7UHhBYeV9/jWprq6sPV6ek+7XZ0Hc8JsphvDDrFhzv2JPJpiDT6OrSmiQX9GFlHoCFS77X+x49uA/k1RJHOCvz6rq+2yH0uuUepPtohtWuXq3AKwo9aaDSO5ifmPq9DQLgpPuxznbYi2iI3KKTzbFZVVaHnsD1bRFP0yDv/Q3kjNUUbq9fj+FHfadf/34YOHYq5c+eiZ8+eGDp0aN56jLEGaZyLthTttttukS9wKSWWL1+OVatW4fbbby96AARBEARBFKYpvc/aMwsXLkx831QUPSn6wQ9+EJkUcc7Rq1cvjB07NuKWRxAEQRAE0Vx8/PHH2GmnnRKPPf300zjyyCOLbrPoSVFTBngiWp+SLj2UW76VYdwVIKqdOvt0NDJ1krCaBUJdhsJZ6YF4frEkt/gk9/i6xMOuyDkrostVeluXGr1cpUstsHb7N+35MlF4DSQLre1lPF+GEaw9yMi1AdayXdC3DCJa5yQCgbU6X/jSLKHZom+9dGYv/9ljte+VQNT6ax9XIvjgfKilQS3w9mAajAuug+z1kvGwdSvKdFI4h5jYP1/peErHBddO+1KgdvUSZLaK6h2Itk2me19kVy0CGAMTCcJoxJfM4rn4rCUzR9yf17GkQD7ISJstKLRuy7nPWotx48bhjTfeiC2j/fWvf8WkSZOwYcOGotss2iXD8zysXLkytv/bb7+F53lFD4AgCIIgiMJo77PGvjoSp512Gg4++GAsX77c7HvssccwadIk3HfffQ1qs+hJUT5ddk1NjQngRLQvWK4m/HUFxK1EQPhryWQ+96P7bXf7QIBreZ4nlvkywgNR65D9xEUsLSJqFXJL1zJjl+5+EXxh6Pd2PSAUN3uOQNsVO9siaMZYJNhiUigAbQmzx6S3jbu8vieWlccEd0ToRm/fOzUWZsbGGDNlPrd8c7617YrM46XVr2U5dEsZWIiSnqnw/DyifVs0axME9Ys5CNjj0OdLGXnGiZC1d1zS2kPIS3bVoqhoX+SU4Dr4LJltxbFfdj2rhG1FsrfddkUufEkB5tdG2jVttCDaUtTYV0fiqquuwve//30cfPDBWLNmDR5++GFMmTIFDzzwAI455pgGtVnv5TPt+sYYw913343OnTubY77v47XXXiNNEUEQBEEQLcbvf/97nHjiidhnn32wdOlSPPLII/jBD37Q4PbqPSm65ZZbAKhfpDNnzowslWUyGQwZMgQzZ85s8ECI1kUGAe5CbVA9dB1SQHIvoiHKpxWygyPaAQWFRCTzu6vdcTO121YgINC/AHkzwbtaIlsTZM632gW0NiiuPdL1ASuwYmAJ0tqinGXhsbU4cK7dvka3r1BzpC1f4eckGMCDMdvnM13R0Ra598pGj0+Xpo8E7VPks9AaKLDAcibBwSDBwCHVM+FbQRwDbZF5drgXF5clBNILP5C4a7S6SA74znmAFloFpjVumdg46YoS6P6zG1D90NXofOIVrT2UGOlegwJNkYxaCpO+jzSOez7guNnnO1+X2n3fbi9ffy2pKRISopHeY409vy3w7LPPxvYdddRReP3113H88ceDMWbqNCT3Wb0nRdr17YADDsCTTz5JSVYJgiAIooXQS/yNbaO9U8ij7J577sE999wDAC2X++zll18uuhOijZPdDMZT6he8nRKhHtaiMOVHcArTBgvLHyhPCg2TViLYX0g7BCBuJUL+UveXpClyrU6+Y0FxLTH2eIyHGZSfk4fQ2qWu3wpX4Z5rjTGfbskes6ctbJbXXmScljZJb+vUH3q/3Z6rJbJThdj7XetW0nhdC5+6dqjUH4GlUXmS6cHbz5QlLrN+aUf0IUBcu+GWwvE6iliXnJtlUbvmG0oO69AWrUQG4ef3KLODMwb7mQ7uyTmYn1MWRSDuUZbgYVanXsi1VhEtTnPkO7Op16Ro6tSpuOaaa9CpUydMnTq1YN3f/va3TTIwgiAIgiAU5JLfMtRrUvTBBx8gm80CAN5///2YtwpBEARBEM2HL2XMqt2QNjoCc+bMwbfffovDDjvM7HvggQcwffp0bNiwAUceeSR+//vfo6SkpOi26zUpspfMXnnllaI7Ido2ma0GoKa6UrlMB8JpI7jW23Yp/Eg9IK6btYMwqu3oUpYtWHYztdvHk5Zx6sr4rs+PCLOda5aOq3nkfK4uyAsCF0aX2oK1fd0Os5e3GDiTZjkpn3jcDspo92GP3R6zvqe+ADyu9nMpE+9dIVF65N5YJYIls5iI3BJ8m+VCW+AdSR4nAanc/9Wzg2Ths/ugWILVmNA637ItT6llDC8F+DlILwXm56ICbbO0kSDQpmWPRLL/fhbpvYoXpjYnuWWfATylPlt36UrkosEYjXu9WjpzSyYFpF0/XxDHQvv1+S3sjk9EufrqqzF27FgzKfroo49w6qmn4uSTT8aOO+6Im2++Gf37929QsOmivx1OOeUUrF+/PrZ/w4YNOOWUU4oeAEEQBEEQhdHeZ419dQTmzZuHgw46yGw/+uijGDVqFO666y5MnToVt912Gx5//PEGtV30pOj+++/Hpk2bYvs3bdqEBx54oEGDIFqX7KpFRsxogjMGv+TdYI0scK1mjhm2rhVVN9ihTZKbfWQ7qJcklC4UgDCfxUU6lhBd3x6fHfhQHxcFrlOfbx9mTmkLnnUf9tjtQJCMsVjQRs/SKCeNOSmFh70fiFqvPKc/U9r1Y/cw7tav2zXj0s9ORNQaaTTc7/zqTgzumCSONb/cA0uA3Z99jtMeEzmwXC1qqtaAiNLWrEQAkOq3PdJ9hkaF1glBF2GCLObU8+X7YQmEz0iSYNt+BuuyHrnPVQtaHX00QUTrFhtt87J27Vr06dPHbL/66quYMGGC2d5rr72wePHiBrVd70+0qqoKlZWVkFJi/fr1qKqqMq+1a9fib3/7G3r37t2gQRAEQRAEQdSHPn36mDBBtbW1eP/997HPPvuY4+vXr0c6nW5Q2/V2ye/WrZtJEfCd73wndpwxhquuuqpBgyBaGSkAL3iA6gjSWEhLxHQgP8YS01eo+qG7O2C5dFuu4HZAwqTEr0Coc9GlSV5q9qvx+E5ARCmi9QQQ0cv4QiLlBclOg20Ex6VU47DVBNro0bdHJyxbtwE+U+3VS99kma70mBGUuj8hrfO19kgCUomC4Ol7ZYcQ0P04oQxsdH3PCt6YpCUC1D00cN2+tnYBOaHGwRgDl8otnwcJhpn7C1t1HrrpR6w+YVBHKRBYJBM0RlpTZMrkII6xoI7qAVBDoJQf7QrJUyrVRlJYEKH0ZEZD5Dv6NSB0y0/SFLnPFqxnh6dCLRJgNEWx1DItAHmfhXz/+9/HJZdcghtvvBFPP/00ysvL8b3vfc8c//DDD7Httts2qO16T4pefvllSClx4IEH4q9//St69OhhjmUyGQwePBj9+1PsD4IgCIJoasj7LOSaa67BUUcdhf333x+dO3fG/fffH8m9es899+DQQw9tUNv1nhTtv//+AFRk64EDB4Jz8uAgCIIgiJZACGks141poyOw1VZb4bXXXkNlZSU6d+4cSTsGALNmzYrkZy2GoiNaDx48GACwceNGLFq0CLW1tZHjO++8c4MGQrQiVmRhY4p2RK75BNb6dF3qfGdJEaWBUARsR3nWuJni9fn6PFMPiCx9RdpFuDyll30S+w+27XbCZa5g6c1pz4ikrf16XEvXbgBnUZFevkjSSWO36wPK5V4EN8FeeguX4FiYh8yKZJ0v9IG7Aqb7A0IxuVm+hAzaZcg5S3C+YIHgO4iEjXCZ1AvumcfsTxVx9+WIWtzNScUi27GnLU8Oq3yRrfMKt2n5rF3hCqT195TJau9b7vhAwrp+4Jaf5/stlj8NiOdNs+qZ55IX/S+UaEK6du2auN9eySqWoj/RVatWYcqUKfj73/+eeLwhuUYIgiAIgsiP3wSWosaevyVQ9BrY+eefj3Xr1uGdd95BWVkZXnjhBdx///3YfvvtE7PXEm0fUd5dCQkZT84mbZW2wFoJgbX7vBIB+lJCIi7alVJCyvCPWh/Xf6K6tMXG+nwtNpYyFDm7ouRcIIDOCmUh8kXQn/XS28I6z23Hl1IFZxTq+rJCC6zVGHJCqu3g+nPC6kNI1X8w3qxw+wz71m2ol6oTqx/06QeBGrPCLlV9EYzRl0Ctr/bX+mqctb4aT3hPYI1djVcivFdZX+3TASpzQfvRcUv4IrhXzmfpW/UlY5DcCwKCqmdLvZjjnu8EVdT1uRfU5ea5jPxyd9sFIL1QJCsZN+JaW2SrX0T7wF/8EbLLvwg/M0d8b76vnM86FiiUO1Yfu2RcWXyCZ0o9O0EeSLvknnJI0c8l9yB5dNmmOdGTosa+iMIU/e3wr3/9C8888wz23HNPcM4xePBgHHLIIejSpQtmzJiBiRMnNsc4CYIgCIIgmpWiLUUbNmww8Yi6d++OVatWAQBGjhyJ999/v2lHRzQ7tZWrAQQ6jMDVVL8HENODmBQgJmAgi6X0UPuTU2i4mqF8pRvk0ZxvtqMet+YHoZWuwg3aKBLOt4/rUntouPocIAx4qA0eXqAj8oJwFfa4TQDIIBCj8WZHtA1b32SXHocJ4siYrf1hiWONXKtELKgjt8au9VAiob7drq2/8qx23H6Mxc+cFwRxdHUZebRDejuvjkO/tY5H3KKDII6R87S+JCm4I6X6aBdIxsH82rimyLe0REKEn7WWb7h/1O4z4AZpDPqK7tcPvBepF7EgtWAeUG0Bb9yrxYbbbin6m2GHHXbAp59+CgDYZZdd8Kc//QlLly7FzJkz0a9fvyYfIEEQBEFs6dDyWctQ9PLZeeedh2XLlgEApk+fjvHjx+Ohhx5CJpPBfffd19TjIwiCIAiCaBGKnhT95Cc/Me/32GMPfP3111iwYAEGDRqErbbaqkkHRzQ/Il0WEy7GMpQjKrBm0FGQVeRnveQFxJfMTLRkIaNLakF9E7HaKfO5lLvLNm7Eat9avlH1gnHq8SK63176Y8EbzhhyUgZu+Yi45RtxeVBPt8egXe3VEpoIKkupSi0WT3KN10uDPqJLWPocP+jTvsc8uOlegbHq7WxQ6sjXCM7P6YjYwZizIuzPjtxtvJqDMftCueP7EvC0+36wrQfIgjU/jiAKuvBVdGCRcyJYh8+Y8MKw/NH6HhCEhIg+kzy6rOKlAD+XmCFdClgi3C176Wzdnb9EtzOub+1h1IvUgBHILfvMLKPFct65pSuwzie01pGtdQRrI+R2QkK4ka29VLhUx3mLPkvkfdYyNNoNo7y8HLvvvntTjIUgCIIgiAQoeGPLUK9J0dSpU+vd4G9/+9sGD4ZoeWyBNYDoL3k3mJmlXbSDNAKIBWvUAQc9ziJWIl3qnF1eINLVpS0KLvT3myQi9oUbbDG0BnGdxT744ehxlhhskgXnGVEzosEilTDaEpoHfen6ru7StXjlQ1p92m3rHG4czFiLjGDaukYZ3Et7rLDO12UYeDK0aPHAOqTrCxnmXnPHo7bDcQooa5Ut1GZB7jsgtDDGgizqX+ImFASL9qetQDHxa55f5nZAPlGg5KpepseWm5KovViJNCy3GfCCFA51fcZJ3hN28Ebtxu9YHFVHcdG0HRDU5FcDlFXSPpfoMNRrUvTBBx/UqzGW8FARBEEQBNE4dCy0xrZBFKZek6KXX365ucdBtAI1G9bHM4gXCNYIWBodx7riaoFsLREQzXqvSwTna+2Mmw6DMRbTEvkiuZ5JQ2Fpi1hCKQMdjh6Xq4UCAr2NCM4L9sXitFuaIqZMNkavo/s3+iOrH5vwJ4R1jwIXfRbcYxVsMdntHkHfEtKk2uCMIWv1qe5ttD5ngQaKMSvEADOaJ53aQ1v0YLXrcQYpZGScksmIBc4PzEYi0Cype8oA5imNkfVLXerPIrCCMQSWOCiNUZheRlsE/IjuQ+pM6X5toA+x0j3YGiLH8lm7biUy3XonfCpEW0MHAI3ox5I0Rb6frCmCCuyZlO1eBwIF95DuNQgAkF35VUxjabREXioWpqSlIE1Ry0ChXQmCIAiijUOTopaBFkQJgiAIgiDQjiZF1113HcaMGYPy8nJ069Ytsc6iRYswceJElJeXo3fv3pg2bRpyOcqGncTmjRsAOBFeA+ws0sxZg84nsI5GO45mbId13C5ZcD63ojW7pf2Aum73dtRlvdRmVlac8eltzxVeI74sZUfctq/bLj2uxNYpzuAxBo8r4bK+XqPztNpgTqmPS7desJTFrfqRe5mQQkyPzQivdfsSEAjzs+WCqLY5oZb2dD61Wl8gK6TJd2ZHqpbWvVbHwxxpOlecfe/0ZwIE+dJgLSPaS1/B0pkvwzxrum4uaFMGkYNjOamMa3UQbdjKjQU775m5qU6E7FZaAiGKJzVghBJbB59ZJN9ZXULroF4kT1qSI4kUyK78yhy36xuBNefR58ZyUGkJcsHfZ2NfRGHazfJZbW0tjjnmGIwePRp//vOfY8d938fEiRPRt29fvPXWW1i2bBkmTZqEdDqN669vX94WBEEQBGFDy2ctQ7uZFF111VUAkDdq9j//+U/Mnz8fL774Ivr06YNdd90V11xzDX7xi1/gyiuvRCaTacHRtgMYN9YEO1ijm6NK/7J3Bda2sFoHXQQsC4ElsM5XaoG1GVJgOdClXd8Nfui6mmvxb5KA2g4KmdUCcMvCISBDTaZUQt+cjFpiYtapQIgtWTgOjZQIMt6rtjUcUdOOPqb79qGsQD7CUAK2WNq9h+H5LBiDNNeoxyolgqz24TVmIeExhqwJfCnh8bg+NfxMw/3hZ6XusscYOJNIcSU6T3nqvDRnEEIHh9TBHUPhtX5GpJRmHCqvnvUsJAm1AwuTtmAykQM8Din86C93NwCpXerjRLvBiKQZB0ROWX+TBNdAssA6lnvPsRwyL/KAG2G1blcLrPUzRM9Ph6XdLJ/VxZw5czBy5Ej06dPH7Bs3bhyqqqrw3//+N+95NTU1qKqqirwIgiAIoi2hgzc25kXBG+umw0yKli9fHpkQATDby5cvz3vejBkz0LVrV/MaOHBgs46ztaldvQQ11ZXmV7WbOdzVGOlf5CawIOJBFu1SZ163tUQMUQ2RbkdriRhjJsZVGMAwDBBoEwYQDNuPlNY47XG59YB4fDd1XI8j+frswIn2OLj1qitcV3hO/Br1d5ate7Kz2xc637bcSRk/blt7ckJpjLRFK+eHFildz1iZJFDrKy1SVmuSfATaJBmWEsj52jqlrEA5oaxdOWtba4h8oaxE+rq1VUzIuKXR1SSFpRV4z9IeuaXSMAV1pcqqXrvmm8IfFFEUG2fd1GxtewNHItV/B0Dk0YgK+3tM/0E4WiJAnW9ZeiKhHgBkVywM29O6NN42LIxaF9jYF1GYVp0UXXLJJeYfYr7XggULmnUMl156KSorK81r8eLFzdofQRAEQRBtk1bVFF144YU4+eSTC9bZZptt6tVW37598e6770b2rVixwhzLR0lJCUpKSurVR0fA77yVCYhna4qk63HBvUDjEfwid7ypbC8jO3hi6CEWLbMJP7BsPZFOT6GTlxrtkIjWdZOU2toi1X/UwmBbgSL3IdDbhGPR7QT9iPh1SMsry2fKEqN1PG4XOuii7ZnFWFjX9tYKNUVa28MiYzHaJH1NlnVFJ3a170HOyosppKWHCqw65p4ba5RE2mParqSkEyx6HgDUmqCOQgV+5Errw5hEWqpAkBmPwfeVxkg/G1mhrisLZYmTUoAxpgJkBuP0zGcZWsd04lkJ7YEnE61rOgCp5NrS6VkXqQL6SYHQM42FT1jN+nUoqegWez6I4ik/5uJm7yO19Y7ILfsMACCDBLEMuSBhrJMMGEAsDYfjgWYSvZqgjtqbMY+WyNaltTAktG4ZWtVS1KtXLwwbNqzgq74C6dGjR+Ojjz7CypUrzb7Zs2ejS5cuGD58eHNdAkEQBEE0O43VEzXFpKoQQ4YMia303HDDDQXP2bx5M84++2z07NkTnTt3xtFHH22MGa1Fu9EULVq0CPPmzcOiRYvg+z7mzZuHefPmobq6GgBw6KGHYvjw4TjppJPwn//8B//4xz9w2WWX4eyzz96iLEEEQRAE0RpcffXVWLZsmXmdc845BetfcMEFeO655zBr1iy8+uqr+Oabb3DUUUe10GiTaTcu+VdccQXuv/9+s73bbrsBUHnZxo4dC8/z8Pzzz+NnP/sZRo8ejU6dOmHy5Mm4+uqrW2vIbYrsyq/gd+4VzXOm38ayRfPI0hkAa5lDBwgMghxaS2dAKPY1yyEIgzvqZRCzBAe9NBdmt7czw0sZzafmZquHU6r6Yc4tXyrBtHDa0SJkHzImWlb9SLM0ZouThVWqjPQSnnWeWkrSy2H6mLoJ9hg8FhVo/397Zx5lVXHt/2/Vufd20zIPMsgMPiDGCX0oahQjEeKL0cSYZ2KCvEcwGhSEZCn8koiaGJyH5zMR8wxoFi41iSYxg4pxSgj6jAmKBtrgk0FlUEGmpu9wav/+qFN1qs49t5uh6b7d2Z+17jp96tSpqlP3cqm767v3dq8TxRb+eEsJkJGvugJ5c+M+uxmbbUeYXz1mm08/s64Xu/3HcxbVQ5yx3hyLoa5XVMp+BgLE98XvuT43W2OI3ttSCJsnDUDsBWO2I6P7zZab+SxR9CDms2M/j0TWWYAcEXVyu0RIVNz20NstBTDtDFWKt0FdIbUbsDPa/07unpEpVCUg2jrTF6LPiAoBGUCEJS+IbTXQHrbPunTp0qRcxWX79u2477778OCDD+KTn/wkAGDRokUYM2YMXnzxRZx44okHc6gVaTeWosWLF4OIyl4TJkywdYYMGYLf/e53aGhowPvvv49bbrkFmUy7WfcxDMMwTCohKYTqAF/RIi8Zhiafz7fIGG+44Qb06tULxx57LG6++eYmM0q88sorKBaLmDhxoi0bPXo0Bg8ejOXLl7fIePYHXjH8E5Df+RGocx+bWsEIrcsEhIANjKeiTOU6271vUQAcQbUTLFE4xzA2BOh6iR8ornDaCIIBLRpOoyxYY9JV2+nfFTebjPGu8Nr7sWQsFU6QRUXxONwAiwYhAAojq5AwGeO14NhYxIzQ2gROdMcQhqmPqANMRk+hnzG2DiWF2aZcQpQFgTRCa2P9MteLIUWpPcp//WZJohhqwbUJHlmMBmzq22OohdMh6RQnoQJyGUTaZQFl5sGds2iyAylSg0Raa5PUD0IEKKHF2yokG2oB0C7+QgodcM8IqAHfsul8LiCkDvIoAq3cT7poM+2LKMyCCAs6vYuxHBmHEQnrOJIKKX2fm+rDfA/KwBdgw7nuHpNpQloB1QKWImOhTYaemT9/Pq655poDanvmzJkYO3YsevbsiT//+c+YN28eNm7ciNtuuy21/qZNm5DL5crSdvXt27fJMDoHG14UMQzDMMw/ERs2bEDXrl3teSXd7dy5c3HjjTc22daqVaswevRozJkzx5YdddRRyOVy+PrXv44FCxa0K10vL4o6OI179gCZGhuwTCDxSyfFSkRCWLdx10oEwKb6MC7TVlsEeLqPwNXwwNcUaa2PTuUhASgR6VFUXG60SuaoNTy+hcGMz6Qe8fqXur2kJcWQ1OOkpbEw+hpXW5SmZdJWIkQJYSPrjNEUSYIgkWrdcd3L09q2Y0WsBXLbcY/JZ9CWFrL3q8jtPl/yLX7mPS0qhayUVjtkwgMUQ5MSRP/q1u8RyqBo8o3OqmTCBjjPqd+ThAkxeg9LRgemtKu/AiCJEELYzxqAKK1KpFkCIEVg58szMoo4FYg/SEQWAWnjPeR3bEVN157lD8VUJ6oEkbTYJIM02roJHRn0e0+OdQkyA6GMhkh/RoS5blN9lHzLUFN9HiRCRZAtpCnq2rWrtyiqxIGEzTnhhBNQKpWwdu1ajBo1qux6v379UCgU8NFHH3nWos2bN++1LulgwIsihmEYhqlySgoQB7goKlXYUaxEnz590KdPn/3qa8WKFZBS4tBDD029ftxxxyGbzeIPf/gDzjvvPABAfX091q9fj/Hjx+9Xny0BL4oYhmEYhtlvli9fjpdeegmnn346unTpguXLl2P27Nn4yle+gh49egAA3n33XZxxxhl44IEHMG7cOHTr1g3Tpk3DnDlz0LNnT3Tt2hWXX345xo8f32aeZwAvijo8esOM/C0yxJnGk5GrFfQ+V1LA7J4Dabmp4j6Ni3WyHIgF1iHFImtTj4icCNJRfyrpFq+3d0o2urJp1+/HCKxdYbWJDK23xOK6UVBnL6u9aS+EFieD4ujagTTbOACU8CJRmy0rEzHbRJQmZ07tVlisHdbjMKeRiDt0BdYwwddQtvWV5l5vtvECqSNRB/FuERQl2zFC7NCLVK2iARaV8uorKxQnW99EkTZbYYDTH1Tk7g9kZLw3GD+GEW4DGQlQGG2jAhAgL0K3zl0XC68zTvgCFwn9BgnXwVaISIirxbkU6KzrvHXWfii9Vw8KdEBfYUTyiZALJCQyA4+w9UVhDxAEfj4zc18kuLYRrQ2utMBEtgasALtsO60VaMnts5ampqYGDz30EK655hrk83kMGzYMs2fP9nRGxWIR9fX1aGhosGW33347pJQ477zzkM/nMWnSJPzwhz88KGPcW3hRxDAMwzBVTjUvisaOHYsXX3yxyTpDhw71YtoBQG1tLe6++27cfffdB2Vc+0O7iVPE7DuNDbshKbQiax3sLhISphxdsa+xNLjBFs05oMWuRmCdtBKZcnPuHk1gPttedBpIbR0IpA4PHwj9Gz8Qfj13XKbdNJGyK2KW0UsI7fothO7PHE075joQ1xOReNpYRLJB9LcQkJEIWCbE1qZ/kfg7kKYdYQM9ui93TsixXLlWoqJSXrZr113eFcMbrPu8I5DOSolsIFCTkZBC2GdK3m+OWSm9Z3ePSdF1nOU+sm5FnyuTB86cm2czz1II9fOVFEFBf3mbdkJlrutjISQ0luK/Q6UtjAT/s0rkuOlX+lWftBAwB8SK8yYd3A5UCSJ6udnuy7LeR1CQ09fCMPrQKUApP2hjdJ9w24vMobavUPdnBNkU5OIAkkyHgr8RGIZhGKbKqWZLUUeCF0UdlIY9jRCRXsh3W3Xc7p2jSbnhBmMEnKzw5pjQ8sRBEWOtkBAitRzws9y77SBRv7ye/4851jaZcRgNUqJdpw2XkNKPcaBF85y+PsamyZCRbkcZi5A2VRjDRKjgWEjI0/MkdT/lkLXAGC2Pq+sxqTRcdJuh16YZe1EZt3u/F3s9EVmzGGqrUj6KMpnUMakQXnBHAMhKQjFMBGV0NFDZQEQaKhMc0tUckQ07kIF+77LGBOiMs4TYchl4FjYBSRQ9p27TWiAjC53Opg5ARMEfo1/5JCTyu3ei5pAuFd4LZl8QafEaWpDMwCNQ3PSW7iuMUrQ04Zaf7TsM4drtoEzW6odEyUntkmLpEaqkNUZRyg8Q6UCOCoDQ1qJc90OR3/lRq1qKWjJ4I1MZtv0xDMMwDMOALUUMwzAMU/WEig44ThFvnzUPL4o6KEIAQoWeoJCEtHnPPIF1SgRrd5uC4AulzRaXKVcUl1c6GkyWe3suEhnkZZQDC3orTdltEOHlYbMRrE1ka5PnS5DNIG/bTZkfcz15HpgM8SY6c9Sv69JuROFmnqWAJ6oGABJaMCxMmTT7c76IObktaK5Vihxt58LZQssGsSDalLvbbSZCtannisml0A+bdPN3+4EkO27z/ICeK29ccUBgTxiuC4BsEOdl83PRkc23pkIgFwBQvpt9YpcVIREy0TxJSQij8AF2R88MJHpjA6nzpAmhog+OtHnPeOusZXj9wn/D0Y/8/qD3I1IE1m42e0EKpXfegCCFYNCRCIYe490frns1crOX3n22bSCOcG3yRKow+uwoUK7OuaH1NluICHSAi5qk9xdTDi+KGIZhGKbKUYoOWBPEmqLm4UVRB8Z1T7UCxESeM4XYSgSkBGl0BNAispq4103QRQVtBTICZdOgG3xRROJaI9h2rUjlgufYimD6EwCKTr41ID0/GRBbdYoVfhkltMXeuRdo0RE3mzKphHVTRxS0MX7GSBSsYoG1ud+dX1d4bZ7DEBi3dxVbk4qhGQMiy5URawMIjXUpyuVFqqyunjPtSq9k3JcrojYWIiMmz0efn3js+r1zBdvG6iQFISwRslLa5zVCbCO0LirfmuVatVz3fyKgJpOcV//9Me3mAh3sMYM4uKP7XoaKkJECWQCBCCBlJNYmqXNe5XcB4OCNLUGpsdQq/VCUqwxu/rLEUQdYrJzTgoKU//qcPJCA/v6kSJyNKC9a9tDB9npNl+7Yue3DFn02pu3hRRHDMAzDVDlEdMDbX7x91jy8KOqA5HfvjN0Ko185wrirOr+GjJYoDaPZSWqG3OCM1k2fYq2QqxlKDapogzUKqyFyrUa2H2gZSyCEZxlwNU6K4gzwbj+hlxZClGWQbypTPRBbSsKUH5pu+oyyOUsEYJTW/TxllhMaozDxZRUq7Q1s+oyzYxCcE4vr6q/PK4/dDQlgtTyJ/pMWLFf3Zd/DlCCRxo3fWImKKj5KATRGKT/MOPLWmmmsSQqBlCiFAplAhzmo9B4G0J8dckRKyrE+KgAh4s+jCABhJlVI1HbqBHTpXj5RzH5xzC+ebJV+bOBGwDv6wRd1TIxw7Yq4TEQRW6WTBuSdN7wUIUmrk9EWWY1Rglz3/UuWuj+QagFNEW+fNQu75DMMwzAMw4AtRQzDMAxT9bDQunXgRVEHo7Fht976MibfKKuzMf1StH3gRh2WkejVurnDjRgdC6zNVpnZOjPXgXiLwgqlzdaaKne794TSKiE0pjgzvG6nXNjtRkM2Amu3H/N8frtxuesCHpqtN3KuOa7krljY1I9GErnr68aT22nx9lEkVna24lzhtXkmby4lIld56d1TjCLaJt3ni1HW+FApZ9vL709vkZk8aeljdXH7cC8bIbNxlzdbb9lARoLv8ucpKmryPiMGLypCNhKQ1wRAlgQyUoBE/B4B8XtbMuEkRBy6Qfcfz4HtD/FWLyDRra5T2TMz7QOSmTiaNeB/vwkJEaYIvu2WWFChPP3ofn8m86q1Nu7u4IG0wTQNb58xDMMwDMOALUUdivyu7ToooxBRkEbh/7qJgjaSiF2dXZGtMQi4dgNXYA3EloIyATa0tSgQ8ZEoDugnvV/yle/XfUbjcMZnXLjd3FY231mKFcpcTwqplYjL9PMIL/eWsQZZl/EoaGM2KA+oGJIvonavl+U3k67pJhH0MDrNythN3WShN20UQyBr+lau9cdcV5HFL27PtcrEbvle157Y3RxdYssf2fbdcmvxSlOlO/WM4DpuPpqb6D4VxnMlhUAeIQIZRPcLSCSE1tFRCIIkgdD251q4CETCWoiKCghJoV+3Q1LHyrQPXKG1qHC0H5QyQTZZV/1ww8r4myC6rj9uvtAaQiLbb8RBfKK9g73PWgdeFDEMwzBMlcOaotaBF0UdgMaG3QAQZQE3JqDAzxodHZPBGo2WqJLmxw3aGGsy/Ou6XdOefx2Jdtz2zLkJ1OiOJ/lP11gaXJdsrQGCLXcMDzbbvbIDKA/KGEjnHH6gRTfwIgAUS1GgwZJJr2EsNMZGEVmJotOmgjN685NAOhawYmju9/VEsfVFW4fco74vut+OKw4EacfqnJZbc3ztUpoWyLUwmushwWqCKtVL9m80RdlA2ufOQ6EGEo0lhdqMBAnf/d+8p0QmwCOVfXaN7iwT6PkKVRzIkmnfkMzo77qwEGuIpNQWICnjLwOicq0QoF31172q/3bvc1N/yOi/RiGhsqw/+2eCF0UMwzAMU+VwnKLWgRdFDMMwDFPttMCiqKKJmrHwoqgDIEr5OGePMRUnhNZGQChBIAjrju9Grnax5yKOPE1E+yy0jgcZt+Pe56JSwgKYo4lk7W61mXEq11pudg8TEauBWGStqNyFPm5PWAG1G+3ZzSxv6rkYQbbNIC997XEgkts25V9ORtxt8ocZzLZSIPXkGrfzIBI+JwXXSeF0nPXe3+pyBdluuRt6wBVWByIWXLtbbQBQCs0xmkcp7Fy69WKiziOBuLvVlk3MlRDONqiZPWcbVVK5AFzBjzAeUtoYmPZImtDa5jkz29lEvv95UnBtHK+jyNfmfuver0p6C40Ucr0HHsSn2XsUkXakOcA2mKZhl3yGYRiGYRiwpajj4AqsASe/mUyc65/Pxt3dCJuN9ceQJrg25W7wxuaE1mkCa6++EVDDv8/gWn/0fb7A2rjdG6uQW889uoEZdT+xADpIWDRcgXVlgbQv7jUBEd3AiCZLfVMkAzEC8MTbRljd1C+8pAA7byNbmjFFlibn/dV5x/yQAsVEf0rFf2elQAlAJpDlgm6lA1kWQwUpBVQknAa08NqO03424n6zgbYFZklbloKM1HnUBKEYIjr64/SsSoFv0bOWvahfSdqqFQIohIQj+nepOI9M+8Bkrrd5yRALqLVZMYwt52lBGQH/SyXKh2atTc59mcPGtN6DNQNRC2iK2FLULLwoYhiGYZgqh4XWrQNvn3UARKkRIizqX0IqjMwiYZw5GnD24PU/CmH1JEYjgyaPIqWeFLpcCKEDDsLRqVhtjfCOth2Ydnz9SHm/8Q9AfZ/WQ5n2jSUiiAJSuvXcoxAmiKHfrw3SmNAKWUuGlAii53OfO+kC7mqO3LqBFKkvMydSxC8XRb71x5+jeIxxmpT4Ps+qElmR3LZcN3n36NZx45mYoI1SOvdFqTvcOQS09SgkoLGkEFIUSoD88QHauqRIW4GMRcp9DhMWobGkUFQK+TC0L3Nu+1Plx0JJhxXQoQyAxlChc46/7joC2b7DtK4IKE+9Ydzw7XlSS+TUc1GxNklEViivHeafBrYUMQzDMEyVoxQgDjh4YwsNpgPDi6KOhpDaLJKmKSLVZEJYoHIQx2RCWHM9qSmyQRhVfB/gewV59Zx+/XGZ+uaCf59K9JPUEpnzYuIXotHBJLVEjaUo3YQN3mju8L+ErCYqoQUy3l5xcMj04IfuXOQrpMZI9pNmLXJx9T9mzG7SWVUkSCls+pBApLeT1C6FjlUoG0jkS+XaHlNPRVYZcx5EqUkQlM91HFxSa4KKAGoBKBJRu8L+bS16CY+6bCBQFOSlX0kepRKozUiE0BanHjWJZKBMu8UmagViTZG9qMo1RTJIBHU0JuWElkg635tVlj2V03y0DmwfZBiGYRiGAVuKGIZhGKbqIXXgxqsqM35VJe3GUnT99dfjpJNOQl1dHbp3755ax4h+3ddDDz3UugNtZYrvr4co5oGwAKFKUWAzghvczAoHAQgVQhBBRttCVgAdvZLZ7AFtcrVBEhEHezRBGIH4gxQ495v23ffDFWQLEQmko3Mp4AU/1O0JSAgrmDaC6kDG9c1LCF9YrcfhipLTBdZuMMdYYC08UbU5d7fITH3XBdytl3RLd4MouuduW+ZoBNlNbXcB/nZXWj2lyLrJm/pG+Oy+isrfcjNzBGiBtRuywLzcuTQUQoVQxfnj3O1KMx63HSO0Lir9dz5UaCwp7CyE2FkIsatQQkMxREMxtNfMfaEjxDbHhqI+FhN7jvmSanYbkmk/mO+6OHhj6K8akm747paZ++8uKbJROnijqDJ3fAA2IeyBvpimaTeWokKhgPPPPx/jx4/HfffdV7HeokWLMHnyZHteaQHFMAzDMO0FdslvHdrNoujaa68FACxevLjJet27d0e/fv1aYURVgooi9Ampg5o1I7ROC+LoNUcmw3gcbNEVWJNTT98f1aM41Yd7vSz4I8y5uR4JoxP3hSo9aGPoCJ9dcbZbx23XaJmN4Nq1eKRmlldGDOyny3Azx/uCZGMJUTpNRpSN3lhe3Dq2bkKE7ZJMuZEUUScF20nrDhBbY8w9xZJOpVEshqkpP9z2dJqWhDg+mqs8KWSl8O6TUti5s1YiJxt9LiOhSNj79NwoOw+5QEbvoxG6Sy/ViTteKYW1umWDqN1AWlF63kkZUhNZ6YxFsKgIQ3p1BtMxIJkBjKXIuOGXWYeUL7QGYmG1e4TzPQkAQiIYeEQbPBVTDbSb7bO9ZcaMGejduzfGjRuHn/zkJ82q7fP5PHbs2OG9GIZhGKaaMJaiA30xTdNuLEV7w3XXXYdPfvKTqKurw1NPPYVvfOMb2LVrF2bOnFnxngULFlgrVHsk23cYShv/AQpLEMZa5NhsrCHAJDqMfj0JIlCkzyFytDEiSsQapeaIgxOWa4p0B8IGL7SJYUWcENZae0w9RFYjYRLHRtYYq/ExyWujfmV0hChLoSpE7H6vSKd0UIL854lctLOBtmgYC4TpTydRddJGSJ0WIhvo8ZqjjARXAUy8gERaCUdDZSwXbpBE9zyQAqqCwMW1EiVxrTMmeKKZe9dalA20tQWRhclYaVwrT1kCVYoTvaa53ZtUHo2hinRYkU4rjC1v7rMXStrSVigp5DISSNFzAdq6FCe6FQhL2uJWRMKyJwQkxRopKfQ4pfL7zZfiFCnm/kAI9K7Lps430/4IN6yECHLaSqQcDVGTx1hTREHkzh/E//3ZRLBA1WmJDJwQtnVoU0vR3LlzU8XR7mv16tV73d53v/tdnHzyyTj22GNx1VVX4corr8TNN9/c5D3z5s3D9u3b7WvDhg0H+lgMwzAMw7RD2tRS9M1vfhNTp05tss7w4cP3u/0TTjgB3/ve95DP51FTU5Nap6ampuI1hmEYhqkGWGjdOrTpoqhPnz7o06fPQWt/xYoV6NGjR4df9FCmBsjkKgqtXdNwWmRroFzwbIXRRnidIrROuu0D5ULqsgjUpp+kILqC4FpRtD2W2DxLtmvq2AjaxlPX2SIDYpFvmRDblvvtFkMjtEaq0LqYiEodkvJE2brM37Jy84ftjZu42boyW1bFUtyniSbt9lOMtvOsaDzanrTn5l47V+SJytHM9VCR3hKDH2m6UNJC60I0PrN1FipCp1xgt7IKYXzd4LZXBJAlI5SO5i2KjA0pEYaErDShAQAV5VtrKIYohoSiUqgNJBoDidqMRDFUOG1E7+YnmmkXqGxd7IovJRCGsaAa8VaY/70nAGnkBbBHfRJ9uwQ5ZPof3noPso8QtcCiiLfPmqXdaIrWr1+PrVu3Yv369QjDECtWrAAAjBw5Ep07d8bjjz+OzZs348QTT0RtbS2WLl2KH/zgB/jWt77VtgNnGIZhGKZd0G4WRVdffTXuv/9+e37ssccCAJ599llMmDAB2WwWd999N2bPng0iwsiRI3Hbbbdh+vTpbTXkVsMIBk0uIEACFAJC6F9U0a8mXdn8ikoXWhtrkBFaBzI6VhBau0EcrdAafoohcqxKRpAN4xIuY6G1K1zORgEDBYAQQDYKvhgLt7VlKHDOoYQNNCiDSPwLYYXWJnijK7SG1FnUYwG2n6srm5H2XD+zsTpFouQgHjdgxNACIeIy/exkrR5SCJQcC1PSiiSF36YZm7kOxGMEfOG1254RjbuBKo1FzrUCAbHVJnR+iSatQ8n6laxKyfu9+hJl9dz+TdBKQCErZTwvkcDaFYQDCqHS9RtLylqJiiGhGIbIBgp7igKdc5zzrCOhA9TGWe0BxFYiE6TWnMPkMSN73bjzQ0hAZkDZTsj2Gdyqz7A/UAsEX+Tts+ZpNy75ixcvtgnx3NeECRMAAJMnT8bf/vY37Ny5E7t27cKKFSvw9a9/HVK2m0dkGIZhmFTS/v/bn9fB4LnnnqvoLPXyyy9XvG/ChAll9S+55JKDMsa9pd1YipjKqNpuAOJfSfqkGU1RInijq3+RwgnKqMjTDpnryR8cSU2RNYQ0ozlKZp1PaozCSFMUu5AnNUlxe5WCNxq3fKCypqi8X/9YTDxwcrxGW1REeWZ7V0Nknslvw3+25DHtPhNM0bUqff2EIQCAH7241huztdY4KQ1MkEX3eiVtEVBuNUo7Jq1NRnvkWoGMxiitfwD2uj6GsYYpis3gWhKlFJ71S6fyIK+/UBEuOm4EmI5BcctaeJ9MoylC9P2XCNroaYqgvw8pyCHbjz8TLclJJ52EjRs3emXf/e538Yc//AHHH398k/dOnz4d1113nT2vq6s7KGPcW3hRxDAMwzBVTjV7n+VyOS+TRLFYxK9+9StcfvnlNj9mJerq6qoqCwXvLTEMwzBMldOSCWGTWRzy+XyLjvXXv/41PvzwQ/zHf/xHs3WXLFmC3r174+Mf/zjmzZuHhoaGFh3LvsKWog5AEVILgaWzhaYioXVUR7gRrYGKQuukcNoIrd3I1mm/NYzbuiTSkaqlv8VlrqdFtE7iboEFAiDhtANhhdUhUdyPAAQJIHqeQAgtxDbXywTVTQuyXZIC7KTgOhaGx/X9RqK5dQTRboRpc09WSut+7wqpg0DoXGyOUNvdvqsUOdu2l7LVZd4zI4BuaivNbGk157bvHk37leqn3e+OJzmuXaVS6v1NjSOXkdjVWEqtz7Q/Su/V6+8zk/NMRXnPSMXfe24ka1cyoEIEQ45ui2G3GKRCkAqbr9hMGwAwaNAgr3z+/Pm45pprDqhtl/vuuw+TJk3CwIEDm6z35S9/GUOGDMGAAQPw2muv4aqrrkJ9fT0effTRFhvLvsKLIoZhGIb5J2LDhg3o2rWrPa8Uy2/u3Lm48cYbm2xr1apVGD16tD1/55138OSTT+KRRx5pdhwXX3yx/fvII49E//79ccYZZ+Ctt97CiBFto/viRVE7Z8v23TZoX01GIhvUQFJoXVI9gTWgrUPGSkQEFdmSkqJfI4xOE1qb68aaZATZQogyobV7HdDWoTgzW2wVcnEDSbpCan0/eRYoUin3O7asWNCtj8YSU1TKs7DY64loiiFR/OyKUEzYyVxRtRu00Q3wWEko7Yq3QyIbiNGMPy1bvalrxhNIHQwxF0j89/K3PSuTm43eFTa7QROT5a51KGm1ac5t372/khDbWJ3ccST7TYYBMPX2FELvPJ8cl2MBzAX68759TxH/87/r8LVxQ8C0X6zAmlS6lcgVWKP8e88e2zEtaSnq2rWrtyiqxP5knVi0aBF69eqFz372s/s8vhNOOAEAsGbNGl4UMQzDMAyTDinVAouilF+RTbCvWSeICIsWLcKUKVOQze57EmYTlLl///77fG9LwYuido4JlAjoX/BZo99IBG0kIDrXv77NUUJbjeJs9aauiDVECU1RGGmOdLX46AZvjLU+wtMUZaN2zBHCd9eXTptk+4s0SJGmKIxDVNpylwBOuIEoyGM2MFYhafU2oaPHMdezQnrWI+lYXGQgvH7MeNxM7UpqK1G+FEZWC8QBHoFIU1Setd6aziTKgi0m77MBKIPYKuJpkBL3JzVErrUmrdytnzxW0iZV0iQl73OtTUm3fNdaZO51rUWhIu12b+4lQiFvzlVZv6EibNmRx9fGjQXTvhGlPERY8C1EpFI1RCRkbBky1zuApag98Mwzz+Dtt9/G1772tbJr7777Ls444ww88MADGDduHN566y08+OCDOOuss9CrVy+89tprmD17Nk499VQcddRRbTB6DS+KGIZhGKbKoTAEhQdoKTrA+5vjvvvuw0knneRpjAzFYhH19fXWuyyXy+Hpp5/GHXfcgd27d2PQoEE477zz8J3vfOegjrE5eFHEMAzDMFUOUQtoiujgLooefPDBiteGDh3qRdQeNGgQnn/++YM6nv2BF0XtnFKohcwmm0lREXKBzvUkSOk8P6RAUpcRxVtmRnBty53owGWCa0fcbMqFs03jCq9lSv3k0RVeuyRFxUmxtREfe2Jrp9xA5ORJQyygToqV44jU2n0/rV6aF7i7/aSIoMJ4ntzo4K7YOqHhtkJrRX62e/MsxYQKPU1oDQAhYsG1S0Glu9sbwXLyWVwBdiUBtamXJqx286GllVc6pgmzzbhCRdhTCBEqQkM07j3FWHAdKmXLk/c17Cli946Wjb/CtC7FTW/pbbOEuNpiIlfLTPx9BzjJFyWEKkFl072rGCYJL4oYhmEYpsppSe8zpjK8KOoASBGLk6XNTi/L3VIRibIJECqMfkVFRwAKwmarN4JrhSiIYzJ4oxVipwuuAxuc0bfaxD/gdBDGAL7VyFwPousAIIx1SMAGWTQCats+xfV1uQ7eaNozQmpzvxUrR9aubCY+FpUqqxfPtRus0Vh6hBWiZ2HyoElI5bjzC4EMfMuREU4bjHA6KbAG/KCNroC6uXxkaUdXaN1UeaXjvvRXyZ2/knu/OSYF1g2RtcjgWolCRbZeqAhhSaFUDNHYUMTOrXvAtD+KW9ZqcbUqQYQlgMjP7egKq42VyMt7Frvrk8wgM/CINnqSloMXRa0DS/IZhmEYhmHAlqJ2T1GRtbAYt3ohI/d2J4O6UvoIQDusJ4KdJYM4asuE4y5vdD1Rv0ltUVkwR6MJcvRAgJP9IqFZioM+Jjryq8fapCiIo0q2T9o6lNQMhUqHCTD9l+lzjLbIunY3Xc/VGYWKYH5/mcCNoSJHMxRbh3Qb6W27miJfm+Rba9x+gXKNT1NBFk1993qalqc5rU9av5U0RA2FEBkpUFJkjzUJ93/TbjK4Y6HkWINCX9tkyo3mqFQMEZYUivkQpWKI3Tvy2L11G5j2Q+GjLUCpoEOG2ECN0b8u1/3eaiX1f2FGO+l+r5lwJMGwgxOSoWFPIxr3tJ4lki1FrQMvihiGYRimymmL4I3/jPCiqJ1jrD9EsXXHBAQ0ViJjRbIQyn5VSeiUHzKhKTK/zG2i2Oh2c10IYTVGiI5Ga+QmfjVjNEEd4+GISBMEq5Nxna6SWiQTzFGQsOOw6TAUkBFxwliFKBijkxg2LQFsMaQyvY6pZ4I5Zo2WCZUSxMbBHBEqKCkQSJPItTyIYzHUuqSiojhJbRBb2Exky73REKUlbE1aXeC8l24Kj721CiWtVKa9tKNbPx9ZpUrReckpr8nIsvuTHmReCg/nOgBkHKsYReU6np+2GhXzJeR3bS0bN1NdFN9fD4osOwIAwiJEWIAoFQAVai2RazGSARCl9vA9zhztpLknLB60cdd1qsWu7a1niVQqjOfgQNpgmoQ1RQzDMAzDMGBLEcMwDMNUPawpah14UdTOKSq9lSNhtpYEMmbry9kS8res0KzQ2hU2u1nuo50pez157gqwdbvmXB+1m3t5cEVTP949igXXMhq/IrLBHE3ARrcds8VnkBBlwR4B383e3RJLirOBpoI+OvepZB29/WNE1+aaK7RWUVDI0O03cT0kSt2+qiR43ht3+qaOpp18SZUJo5sSSie33Eop7adt7Zl+KrWTTxGEu8dAiniLMCN1mIOMQKno56hjqpfCtk3w3i2T9Z6U8+Xg6GCiILRenjPne0x/yelwJCIsxPUPArsa9tiguK0BL4paB94+YxiGYRiGAVuK2i1bdzYgH2orUSCFDZ4YiCiYY1TPiFglqMzNPf61JbS1h2LhNmCE2toq4mhobRDHSuVGeK2Fx/AE1ybRvF2Nm3JHya3r+dYtiThAZKgIJHTARhhrUyKYoxlPNhoH3HKUC6QBQKpkWAIqE2a7QvRyoXX0h/H/hwnkGPURCat1UMaoT4r7DAIjzNYTo98LLdQuoNwalBRYJ8/T6jUnsAZgrUCZ6Ny1EpnzJEkBdKmJ9t3zpADbbc8+g2O585838IXjGalDQkT/HjLZAEEmh37n3YlNv5hVNmam7ShufhuAE/TVWINUGLviG6tRGsbtPhJc6+8c6ZuEhQTCIkrvvHFQgjdKUf7v4KAShiB5gJaeg5wQtiPAiyKGYRiGqXKIDtz77GAnhO0I8KKonbKrqKxlx1hd7K8ue55IABul9ACQmhAWiN34VUI7Y9qnyHoEwLMiWS0R4N2XTBSrE2D4R7d+UoNktUi2Xqwr8sYN8jREseanvJ7RJwHlQRoBP/BjpSCOpu1KmqJkudURJXRDXn8qPWhjIXRSWDhviJvAVT9LbA1yy5Ju7pX0SZU0RHlHa2SsNDUZ6bnXN5Xiw2qWQoVcIMvG6QanrBRE0h+rQiBldIytT6QIpAiqpECk030IGWDHxrfAVBeU66Rd7oFYE5T4D18kwoZoc3FC8eGmMiKlNUSRiZmEhAiyEKWD45YfEnmGKaZjwIsihmEYhqlySKkDtxRx8MZm4UURwzAMw1Q51ALBG9n7rHl4UdROCUSsppZCb5XJSHRtolgD0RYa9FaZF/HV2Trz2o0iSsciQvKE02aLzmyZGeF04DQVKvIE13Duz5r7oLfW4mjNAJGAIF+YbTBbbUaAbSJ2w4QfgBF2iyjSdmzXtkLs6HqIOExBMnK1FMJzw89KnQ8tGdk6kLG7flJoLZV2t89KYV3yteBaQEldUIzU31407UBAUnp5KGO3eTvHCcFzU5GsCyVlBcnJiNa2vWhrLSmwNltl7lZVKbEVl3YsE1aLcrf7Qui73ftbf/Hf8XaZTJSF9r4wVChEec/Ckm4v06kzOvXoi95n34APHp8Lpu0pfPCO/sN1tY/+NgJruBaN5BaZW+ZusQH6Hzspz6lElBoPwlPor9/W1lozBx9eFDEMwzBMlaO3zw5s+4u3z5qHF0XtlDASLgOwP1cEtDUk4+QXM7/MFURZHjHjhi8iq4ubd8xYTUy7Jq+aShxDFQupgXTBdaogOyEmjoM66vbM85l/wqHzy8+ML9mPCegI+G753jnIe8Zke+4xJCorN8Jre4yCMOqycmF1WrntU/l9mbKk2LqSULpSPrJKguykNSZNhA2UC6eT58bK5Fp5yoIzBtKGLEgezX1mHIVSbO2pnN/NjN+3JIWKsKcQIp8vIb+nBFVSNohjriYDKbsAOAwNH77L1qIqoPDRFr/AFVJTqMXRACAlSOlvOE9wLTO+hSkpvE60SzJT2a3/ANjVsAchoVWF1rx91jrwoohhGIZhqhxeFLUOvChqp5hghlZPBG01cVNoAHGKDKDczd09uvV0e8Leb4IVmvaBOEhjICMtjzkKeFYjW8+532iTjKaIiCCltgFkgljT5GqPkhqjQCStWpHmCCI9mGNCU6TnMBYEuNoAa9lKBHMEgKz0U31IFYcvkE4fCFVkHQFkIGwASKnie0OhNURKOUEcBdkyY1UKAqO7Ep61KM193c6PFF55c0EerfUnyl6f1BAZXC1QU5qignm3nB/ygShvJ2m9Mqk9ksEcy8eh+28ohCgUQpQK+j6ZkajN5ECKUFNLKBVDyIwexO4t6zF61q+w+s5zytpmDi7FLWttNntBKVs4yWCNyg/O6NVL3pp23WiUDoKVCDCaS2JNUQeEF0UMwzAMU+UoFepYcwcAW4qahxdFDMMwDFPlUKgAcYCLopCF1s3Bi6J2SlFpd3EFod3Tod9Ms2UVqtil241Q7QqTzZaWQHwEouzyCQVhUjjtCq+BpgXXIu1+s31ixuUIwL37TXtmHAmRtGnXRp6OIluHRF577nUz3tQHdNrzBNBuxGsnyrW7lRaqWJhdVG79dAF2pejWxZBs25WiTzfnDu8/S2U1aDKidbLME1inuM/rLbfQc5l3XeeTW3BuJGtXYA3EW2duv2GFsAOBFNjZWMKeQggVKggJBJB2pyXISIQlBZmRUIqgSl1Q2tMT+T0HJ7oxU5ni++tB2Vq7pUUKgJQQYSkWVgOAIC2MJgUKMvq6I6y29YzwGrBbcrbcRLSOzg+W0LqoyEoVmI4FL4oYhmEYpsrh3GetQwV/xupi7dq1mDZtGoYNG4ZOnTphxIgRmD9/PgqFglfvtddewyc+8QnU1tZi0KBBuOmmm9poxAeXd7buQlaKKFCjLjNvpBS+O31aJmdr3XF+5QjverqVKHm/6Q9w8q4JYQXgUsRBHUX0skLtKJN5EOVus/WcQJRaRB61Fz1jEF23QSqRuC8qCex4TH+J69H9yZcpD6Seu8CM0auDlOtxm2bezd+BdNoVOqijFAKZQEJKXea+T+Y8iMbjvtz2kuX2/kRZpXpNWYnS6iTLY6uNtIEWw0QclL21arnC7uR9oSLkSwol59hQCBEqnetMSKHnMSMQZCQy2UB/tjISmaxEriaDXKcscl16Yvf7WmzNtA7FzW9rIbQJyGg+H0r5AmkXIQEhQUEm+odt8jXGQRwpeulzEd+X+O4y7vzqzWUt+lyJf0qtAqmwRV5M07QLS9Hq1auhlMLChQsxcuRIvP7665g+fTp2796NW265BQCwY8cOnHnmmZg4cSLuuecerFy5Ev/5n/+J7t274+KLL27jJ2AYhmEYptppF4uiyZMnY/LkyfZ8+PDhqK+vx49+9CO7KFqyZAkKhQJ+8pOfIJfL4YgjjsCKFStw2223dchFkRDpP1XsL3giTytEznXA1waZX+huPYOp14QspcnrTd2fLDfBGiUA5VjATB2jWXKDOlbCaIsUfG2RENr9PVlurplzqSsCytdXJYM4us/pXk/+HT9z3J4issEaK2GCHtpzR5Pj1UvNJl/ujm/KK2mIXJrKXu8fVdn9Jv1GbP3xwwCEStnnqDQO18KU1CaFisrmQakooKmMPiuKtIEieg4hA5AKsXX9W2Xzx7QspffqQTIDytQATmoW72+loiCN+lQIBYhAf2eRAlTJaosgtFaI3GCPABAEkft+usCHhNRtZWoO3sO2EqTCAxdas6WoWdrF9lka27dvR8+ePe358uXLceqppyKXy9mySZMmob6+Htu2bWuLITIMwzBMi8DbZ61Du7AUJVmzZg3uuusuayUCgE2bNmHYsGFevb59+9prPXr0SG0rn88jn8/b8+3btwPQ23HVys4du6xuB4iDNxqNUdLy05SlCNh/S5G7r17mzEV+P01Zksi1rgCeJYgoruN5t0VjVUTR0dxg2oktRW479u9EOhCg/MemIrJeaMp5HsD3QAOAYnQsGQ8tKrcUpXmhKUWelSk01iOnbTcFCOCm6fDbte07nn3JNBumXpqlSCXepL22FEU/9ZP3A7DeY4GIvdFCRQhJoWgtRf5zmHK3PRW1oxxLUamkQEQIQwVSet6kFBCRXk2FCmGJEDYWEeZLUIU9UMVGCBlU9b/vjkBp5y6QDECZQnnyVkMimWscuDHUCaxVSQd0DKNyx6uszFLkXnfbRxwsUrbge76zYQ8AoGHXrqjrVnBDC4tl38/70wbTNG26KJo7dy5uvPHGJuusWrUKo0ePtufvvvsuJk+ejPPPPx/Tp08/4DEsWLAA1157bVn5oEGDDrhthmGqk27dvt3WQ2A6EDt37kS3bt0OStu5XA79+vXDpr8/0iLt9evXz9tRYXwEtcoSN533338fH374YZN1hg8fbt/A9957DxMmTMCJJ56IxYsXQzr701OmTMGOHTvwy1/+0pY9++yz+OQnP4mtW7futaVIKYWtW7eiV69eFXU7bcWOHTswaNAgbNiwAV27dm3r4bQ7eP72H567/Yfn7sCo5vkjIuzcuRMDBgzw/j9qaRobG8u8rfeXXC6H2traFmmrI9KmlqI+ffqgT58+e1X33Xffxemnn47jjjsOixYtKvsAjh8/Ht/+9rdRLBaRzWYBAEuXLsWoUaMqLogAoKamBjU1vgive/fu+/YgrUzXrl2r7suhPcHzt//w3O0/PHcHRrXO38GyELnU1tbyQqaVaBdC63fffRcTJkzA4MGDccstt+D999/Hpk2bsGnTJlvny1/+MnK5HKZNm4Y33ngDDz/8MO68807MmTOnDUfOMAzDMEx7oV0IrZcuXYo1a9ZgzZo1GDhwoHfN7P5169YNTz31FGbMmIHjjjsOvXv3xtVXX90h3fEZhmEYhml52sWiaOrUqZg6dWqz9Y466ij88Y9/PPgDaiNqamowf/78su0+Zu/g+dt/eO72H567A4Pnj2lN2lRozTAMwzAMUy20C00RwzAMwzDMwYYXRQzDMAzDMOBFEcMwDMMwDABeFDEMwzAMwwDgRVG7I5/P45hjjoEQAitWrPCuvfbaa/jEJz6B2tpaDBo0CDfddFPbDLLKWLt2LaZNm4Zhw4ahU6dOGDFiBObPn18WIZbnrzJ33303hg4ditraWpxwwgn43//937YeUtWxYMEC/Ou//iu6dOmCQw89FOeeey7q6+u9Oo2NjZgxYwZ69eqFzp0747zzzsPmzZvbaMTVyw033AAhBK644gpbxnPHtAa8KGpnXHnllRgwYEBZ+Y4dO3DmmWdiyJAheOWVV3DzzTfjmmuuwb333tsGo6wuVq9eDaUUFi5ciDfeeAO333477rnnHvy///f/bB2ev8o8/PDDmDNnDubPn4+//vWvOProozFp0iRs2bKlrYdWVTz//POYMWMGXnzxRSxduhTFYhFnnnkmdu/ebevMnj0bjz/+OH72s5/h+eefx3vvvYfPf/7zbTjq6uPll1/GwoULcdRRR3nlPHdMq0BMu+F3v/sdjR49mt544w0CQH/729/stR/+8IfUo0cPyufztuyqq66iUaNGtcFIq5+bbrqJhg0bZs95/iozbtw4mjFjhj0Pw5AGDBhACxYsaMNRVT9btmwhAPT8888TEdFHH31E2WyWfvazn9k6q1atIgC0fPnythpmVbFz5046/PDDaenSpXTaaafRrFmziIjnjmk92FLUTti8eTOmT5+On/70p6irqyu7vnz5cpx66qle9uNJkyahvr4e27Zta82htgu2b9+Onj172nOev3QKhQJeeeUVTJw40ZZJKTFx4kQsX768DUdW/Wzfvh0A7OfslVdeQbFY9OZy9OjRGDx4MM9lxIwZM/Bv//Zv3hwBPHdM68GLonYAEWHq1Km45JJLcPzxx6fW2bRpE/r27euVmXM3RxwDrFmzBnfddRe+/vWv2zKev3Q++OADhGGYOjf/zPPSHEopXHHFFTj55JPx8Y9/HID+HOVyubKE0zyXmoceegh//etfsWDBgrJrPHdMa8GLojZk7ty5EEI0+Vq9ejXuuusu7Ny5E/PmzWvrIVcVezt/Lu+++y4mT56M888/H9OnT2+jkTMdnRkzZuD111/HQw891NZDaRds2LABs2bNwpIlSzgbPNOmtIvcZx2Vb37zm83mdBs+fDieeeYZLF++vCz3z/HHH48LL7wQ999/P/r161fmiWHO+/Xr16Ljrhb2dv4M7733Hk4//XScdNJJZQLqf8b52xt69+6NIAhS5+afeV6a4rLLLsNvfvMbvPDCC14C6379+qFQKOCjjz7yLB48l3p7bMuWLRg7dqwtC8MQL7zwAv77v/8bTz75JM8d0zq0taiJaZ5169bRypUr7evJJ58kAPTzn/+cNmzYQESxULhQKNj75s2bx0LhiHfeeYcOP/xwuuCCC6hUKpVd5/mrzLhx4+iyyy6z52EY0mGHHcZC6wRKKZoxYwYNGDCA3nzzzbLrRiz885//3JatXr2axcJEtGPHDu87buXKlXT88cfTV77yFVq5ciXPHdNq8KKoHfL222+XeZ999NFH1LdvX/rqV79Kr7/+Oj300ENUV1dHCxcubLuBVgnvvPMOjRw5ks444wx65513aOPGjfZl4PmrzEMPPUQ1NTW0ePFi+vvf/04XX3wxde/enTZt2tTWQ6sqLr30UurWrRs999xz3mesoaHB1rnkkkto8ODB9Mwzz9Bf/vIXGj9+PI0fP74NR129uN5nRDx3TOvAi6J2SNqiiIjo1VdfpVNOOYVqamrosMMOoxtuuKFtBlhlLFq0iACkvlx4/ipz11130eDBgymXy9G4cePoxRdfbOshVR2VPmOLFi2ydfbs2UPf+MY3qEePHlRXV0ef+9znvMU5E5NcFPHcMa2BICJq9T07hmEYhmGYKoO9zxiGYRiGYcCLIoZhGIZhGAC8KGIYhmEYhgHAiyKGYRiGYRgAvChiGIZhGIYBwIsihmEYhmEYALwoYhiGYRiGAcCLIqYDMmHCBFxxxRUdqt+pU6fi3HPPPaA2hg4dahPlfvTRRxXrLV68uCwbOdNyTJ061b4Pv/zlL9t6OAzDOPCiiGFaiEcffRTf+9737PnQoUNxxx13tN2AUrjuuuuwceNGdOvWra2H0uF57rnnUhegd955JzZu3Ng2g2IYpkkybT0Ahuko9OzZs62H0CxdunSpmqzixWIR2Wy2rYfR6nTr1o0XpQxTpbCliOnwbNu2DVOmTEGPHj1QV1eHT3/60/jHP/5hr5vtoieffBJjxoxB586dMXnyZO/XfKlUwsyZM9G9e3f06tULV111FS666CJvS8vdPpswYQLWrVuH2bNn260SALjmmmtwzDHHeOO74447MHToUHsehiHmzJlj+7ryyiuRzMajlMKCBQswbNgwdOrUCUcffTR+/vOf79f8LF68GIMHD0ZdXR0+97nP4cMPPyyr86tf/Qpjx45FbW0thg8fjmuvvRalUsleX716NU455RTU1tbiYx/7GJ5++mlve2jt2rUQQuDhhx/GaaedhtraWixZsgQA8D//8z8YM2YMamtrMXr0aPzwhz/0+t6wYQO++MUvonv37ujZsyfOOeccrF271l5/7rnnMG7cOBxyyCHo3r07Tj75ZKxbt26vnr2557rttttw5JFH4pBDDsGgQYPwjW98A7t27bLX161bh7PPPhs9evTAIYccgiOOOAK/+93vsHbtWpx++ukAgB49ekAIgalTp+7VmBiGaTt4UcR0eKZOnYq//OUv+PWvf43ly5eDiHDWWWehWCzaOg0NDbjlllvw05/+FC+88ALWr1+Pb33rW/b6jTfeiCVLlmDRokVYtmwZduzY0aQe5NFHH8XAgQPtdtW+bJfceuutWLx4MX7yk5/gT3/6E7Zu3YrHHnvMq7NgwQI88MADuOeee/DGG29g9uzZ+MpXvoLnn39+7ycGwEsvvYRp06bhsssuw4oVK3D66afj+9//vlfnj3/8I6ZMmYJZs2bh73//OxYuXIjFixfj+uuvB6AXceeeey7q6urw0ksv4d5778W3v/3t1P7mzp2LWbNmYdWqVZg0aRKWLFmCq6++Gtdffz1WrVqFH/zgB/jud7+L+++/H4C2Jk2aNAldunTBH//4RyxbtswuWguFAkqlEs4991ycdtppeO2117B8+XJcfPHFdhHaFM09FwBIKfFf//VfeOONN3D//ffjmWeewZVXXmmvz5gxA/l8Hi+88AJWrlyJG2+8EZ07d8agQYPwi1/8AgBQX1+PjRs34s4779yn94ZhmDagbfPRMkzL42bXfvPNNwkALVu2zF7/4IMPqFOnTvTII48QEdGiRYsIAK1Zs8bWufvuu6lv3772vG/fvnTzzTfb81KpRIMHD6ZzzjkntV8ioiFDhtDtt9/ujW3+/Pl09NFHe2W33347DRkyxJ7379+fbrrpJnteLBZp4MCBtq/Gxkaqq6ujP//5z14706ZNoy996UsV5yVtPF/60pforLPO8sr+/d//nbp162bPzzjjDPrBD37g1fnpT39K/fv3JyKi3//+95TJZLyM5UuXLiUA9NhjjxER0dtvv00A6I477vDaGTFiBD344INe2fe+9z0aP3687WfUqFGklLLX8/k8derUiZ588kn68MMPCQA999xzFZ+7Es09Vxo/+9nPqFevXvb8yCOPpGuuuSa17rPPPksAaNu2banX3flhGKY6YE0R06FZtWoVMpkMTjjhBFvWq1cvjBo1CqtWrbJldXV1GDFihD3v378/tmzZAgDYvn07Nm/ejHHjxtnrQRDguOOOg1KqRce7fft2bNy40RtvJpPB8ccfb7fQ1qxZg4aGBnzqU5/y7i0UCjj22GP3qb9Vq1bhc5/7nFc2fvx4PPHEE/b81VdfxbJlyzwLShiGaGxsRENDA+rr6zFo0CBPq+TOlcvxxx9v/969ezfeeustTJs2DdOnT7flpVLJam5effVVrFmzBl26dPHaaWxsxFtvvYUzzzwTU6dOxaRJk/CpT30KEydOxBe/+EX079+/2Wdv7rnq6urw9NNPY8GCBVi9ejV27NiBUqnkXZ85cyYuvfRSPPXUU5g4cSLOO+88HHXUUc32zTBMdcKLIoYBygS/QogyHU9LIKUsa9fdxtsbjKblt7/9LQ477DDvWk1NzYENsEJ/1157LT7/+c+XXautrd2ntg455BCvXQD48Y9/7C0CAb3oNHWOO+44qz9y6dOnDwBg0aJFmDlzJp544gk8/PDD+M53voOlS5fixBNPPKDnWrt2LT7zmc/g0ksvxfXXX4+ePXviT3/6E6ZNm4ZCoYC6ujp87Wtfw6RJk/Db3/4WTz31FBYsWIBbb70Vl19++T7NC8Mw1QEvipgOzZgxY1AqlfDSSy/hpJNOAgB8+OGHqK+vx8c+9rG9aqNbt27o27cvXn75ZZx66qkAtEXhr3/9a5lo2iWXyyEMQ6+sT58+2LRpE4jI6l5WrFjh9dW/f3+89NJLtq9SqYRXXnkFY8eOBQB87GMfQ01NDdavX4/TTjttr56hEmPGjMFLL73klb344ove+dixY1FfX4+RI0emtjFq1Chs2LABmzdvRt++fQEAL7/8crN99+3bFwMGDMD//d//4cILL0ytM3bsWDz88MM49NBD0bVr14ptHXvssTj22GMxb948jB8/Hg8++GCzi6LmnuuVV16BUgq33norpNTyy0ceeaSs3qBBg3DJJZfgkksuwbx58/DjH/8Yl19+OXK5HACUfQYYhqleeFHEdGgOP/xwnHPOOZg+fToWLlyILl26YO7cuTjssMNwzjnn7HU7l19+ORYsWICRI0di9OjRuOuuu7Bt27YmBb1Dhw7FCy+8gAsuuAA1NTXo3bs3JkyYgPfffx833XQTvvCFL+CJJ57A73//e+8//FmzZuGGG27A4YcfjtGjR+O2227zYt106dIF3/rWtzB79mwopXDKKadg+/btWLZsGbp27YqLLrpor59r5syZOPnkk3HLLbfgnHPOwZNPPultnQHA1Vdfjc985jMYPHgwvvCFL0BKiVdffRWvv/46vv/97+NTn/oURowYgYsuugg33XQTdu7cie985zsA0Kzg+dprr8XMmTPRrVs3TJ48Gfl8Hn/5y1+wbds2zJkzBxdeeCFuvvlmnHPOObjuuuswcOBArFu3Do8++iiuvPJKFItF3HvvvfjsZz+LAQMGoL6+Hv/4xz8wZcqUZp+9uecaOXIkisUi7rrrLpx99tlYtmwZ7rnnHq+NK664Ap/+9KfxL//yL9i2bRueffZZjBkzBgAwZMgQCCHwm9/8BmeddRY6deqEzp077/V7wzBMG9C2kiaGaXmSguetW7fSV7/6VerWrRt16tSJJk2aRG+++aa9vmjRIk9YTET02GOPkfvPo1gs0mWXXUZdu3alHj160FVXXUXnn38+XXDBBRX7Xb58OR111FFUU1PjtfWjH/2IBg0aRIcccghNmTKFrr/+ek9oXSwWadasWdS1a1fq3r07zZkzh6ZMmeKJupVSdMcdd9CoUaMom81Snz59aNKkSfT8889XnJc0oTUR0X333UcDBw6kTp060dlnn0233HJL2Xw88cQTdNJJJ1GnTp2oa9euNG7cOLr33nvt9VWrVtHJJ59MuVyORo8eTY8//jgBoCeeeIKIYqH13/72t7L+lyxZQscccwzlcjnq0aMHnXrqqfToo4/a6xs3bqQpU6ZQ7969qaamhoYPH07Tp0+n7du306ZNm+jcc8+l/v37Uy6XoyFDhtDVV19NYRhWnId9ea7bbruN+vfvbz83DzzwgCeevuyyy2jEiBFUU1NDffr0oa9+9av0wQcf2Puvu+466tevHwkh6KKLLvL6BgutGabqEEQHQTjBMB0cpRTGjBmDL37xi14U62pm6NChuOKKK1olBcqyZctwyimnYM2aNZ6AnYkRQuCxxx474PQtDMO0HByniGH2gnXr1uHHP/4x3nzzTaxcuRKXXnop3n77bXz5y19u66HtE1dddRU6d+6M7du3t2i7jz32GJYuXYq1a9fi6aefxsUXX4yTTz6ZF0QpXHLJJbyNxjBVCluKGGYv2LBhAy644AK8/vrrICJ8/OMfxw033GDF0O2BdevWWU+34cOHW/FwS/DAAw/g+9//PtavX4/evXtj4sSJuPXWW9GrV68W62NfOeKIIypGtl64cGFFcffBZsuWLdixYwcAHfrB9chjGKZt4UURwzAdEncRmKRv375lsY8YhmF4UcQwDMMwDAPWFDEMwzAMwwDgRRHDMAzDMAwAXhQxDMMwDMMA4EURwzAMwzAMAF4UMQzDMAzDAOBFEcMwDMMwDABeFDEMwzAMwwDgRRHDMAzDMAwA4P8Dq+9hwJ3y/VEAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -468,6 +526,14 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa58445e-2916-405f-b1e7-b6fcd525f3c4", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/tests/test_dataset.py b/tests/test_dataset.py index 76db999..4742f9f 100644 --- a/tests/test_dataset.py +++ b/tests/test_dataset.py @@ -55,7 +55,6 @@ def test_len_and_shapes(): monthly_da=monthly_da, land_mask=land_mask, patch_size=(2, 2), - overlap=0, ) assert len(dataset) == 4 @@ -77,7 +76,6 @@ def test_index_bounds(): monthly_da=monthly_da, land_mask=land_mask, patch_size=(2, 2), - overlap=0, ) with pytest.raises(IndexError): @@ -94,7 +92,6 @@ def test_index_mapping_and_mask_values(): monthly_da=monthly_da, land_mask=land_mask, patch_size=(2, 2), - overlap=0, ) sample = dataset[3]