diff --git a/climanet/dataset.py b/climanet/dataset.py index 70fd091..344d737 100644 --- a/climanet/dataset.py +++ b/climanet/dataset.py @@ -1,7 +1,7 @@ import warnings import numpy as np -from .utils import add_month_day_dims +from .utils import add_month_day_dims, calc_stats import xarray as xr import torch from torch.utils.data import Dataset @@ -52,6 +52,9 @@ def __init__( self.lat_coords = daily_da[spatial_dims[0]].to_numpy().copy() self.lon_coords = daily_da[spatial_dims[1]].to_numpy().copy() + # Store the stats of the daily data before filling NaNs + self.daily_mean, self.daily_std = calc_stats(self.daily_np) + if land_mask is not None: lm = land_mask.to_numpy().copy() if lm.ndim == 3: diff --git a/climanet/st_encoder_decoder.py b/climanet/st_encoder_decoder.py index 7df74ad..e09171c 100644 --- a/climanet/st_encoder_decoder.py +++ b/climanet/st_encoder_decoder.py @@ -528,6 +528,10 @@ def __init__( spatial_heads: Number of attention heads in the spatial Transformer """ super().__init__() + + # Store arguments to be used later for model saving/loading + self.config = {k: v for k, v in locals().items() if k not in ('self', '__class__')} + self.encoder = VideoEncoder( in_chans=in_chans, embed_dim=embed_dim, patch_size=patch_size ) @@ -568,7 +572,6 @@ def forward(self, daily_data, daily_mask, land_mask_patch, padded_days_mask=None Tp = T // self.patch_size[0] Hp = H // self.patch_size[1] Wp = W // self.patch_size[2] - Np = Tp * Hp * Wp # check shape and patch compatibility assert daily_mask.shape == daily_data.shape, ( diff --git a/climanet/utils.py b/climanet/utils.py index aa6cebf..c000287 100644 --- a/climanet/utils.py +++ b/climanet/utils.py @@ -1,13 +1,17 @@ +import copy +from pathlib import Path from typing import Tuple import numpy as np +from torch.utils.data import Dataset +from torch.optim.lr_scheduler import ReduceLROnPlateau import xarray as xr import torch +from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter -def regrid_to_boundary_centered_grid( - da: xr.DataArray, - roll = False -) -> xr.DataArray: + +def regrid_to_boundary_centered_grid(da: xr.DataArray, roll=False) -> xr.DataArray: """ Interpolates a DataArray from its current center-based grid onto a new grid whose coordinates are derived from user-specified boundaries. @@ -20,7 +24,7 @@ def regrid_to_boundary_centered_grid( # --- 0. Longitude Domain Check and Correction --- - input_lon = da['longitude'] + input_lon = da["longitude"] # Check if roll for 0-360 to -180-180 is requested if roll: @@ -30,18 +34,24 @@ def regrid_to_boundary_centered_grid( lon_diff = np.abs(input_lon - 180.0) # We need to roll such that the 180-degree line is moved to the edge # and the new array starts near -180 - roll_amount = int(lon_diff.argmin().item() + (input_lon.size / 2)) % input_lon.size + roll_amount = ( + int(lon_diff.argmin().item() + (input_lon.size / 2)) % input_lon.size + ) # Roll the DataArray and its coordinates da = da.roll(longitude=roll_amount, roll_coords=True) # Correct the longitude coordinate values: shift values > 180 down by 360 - new_lon_coords = da['longitude'].where(da['longitude'] <= 180, da['longitude'] - 360) + new_lon_coords = da["longitude"].where( + da["longitude"] <= 180, da["longitude"] - 360 + ) # Assign the corrected and sorted coordinates - da = da.assign_coords(longitude=new_lon_coords).sortby('longitude') - print(f"Longitudes adjusted. New range: {da['longitude'].min().item():.2f} " - f"to {da['longitude'].max().item():.2f}") + da = da.assign_coords(longitude=new_lon_coords).sortby("longitude") + print( + f"Longitudes adjusted. New range: {da['longitude'].min().item():.2f} " + f"to {da['longitude'].max().item():.2f}" + ) # --- 1. Define Target Grid Boundaries --- @@ -67,23 +77,19 @@ def regrid_to_boundary_centered_grid( # Use linear interpolation (suitable for gappy data) to map data onto the # new centers. xarray handles the NaNs automatically. - da_regridded = da.interp( - latitude=new_lats, - longitude=new_lons, - method="linear" - ) + da_regridded = da.interp(latitude=new_lats, longitude=new_lons, method="linear") print(f"Regridding complete. New dimensions: {da_regridded.dims}") return da_regridded def add_month_day_dims( - daily_ts: xr.DataArray, # (time, H, W) daily + daily_ts: xr.DataArray, # (time, H, W) daily monthly_ts: xr.DataArray, # (time, H, W) monthly time_dim: str = "time", - spatial_dims: Tuple[str, str] = ("lat", "lon") + spatial_dims: Tuple[str, str] = ("lat", "lon"), ): - """ Reshape daily and monthly data to have explicit month (M) and day (T) dimensions. + """Reshape daily and monthly data to have explicit month (M) and day (T) dimensions. Here we assume maximum 31 days in a month, and invalid day entries will be padded with NaN. @@ -104,8 +110,9 @@ def add_month_day_dims( # Add M (month key) and T (day of month) coordinates to daily data daily_indexed = ( - daily_ts - .assign_coords(M=(time_dim, dkey.values), T=(time_dim, daily_ts[time_dim].dt.day.values)) + daily_ts.assign_coords( + M=(time_dim, dkey.values), T=(time_dim, daily_ts[time_dim].dt.day.values) + ) .set_index({time_dim: ("M", "T")}) .unstack(time_dim) .reindex(T=np.arange(1, 32), M=month_keys) @@ -119,8 +126,7 @@ def add_month_day_dims( # Align monthly data to same month keys/order monthly_m = ( - monthly_ts - .assign_coords(M=(time_dim, mkey.values)) + monthly_ts.assign_coords(M=(time_dim, mkey.values)) .swap_dims({time_dim: "M"}) .drop_vars(time_dim) .sel(M=month_keys) @@ -146,7 +152,189 @@ def pred_to_numpy(pred, orig_H=None, orig_W=None, land_mask=None): if land_mask is not None: pred = pred.clone().to(torch.float32) land_mask = land_mask.bool() - land_mask = land_mask.unsqueeze(1) # (B, H,W) -> (B, 1, H, W) for broadcasting + 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() + + +def calc_stats(arr: np.ndarray, mean_axis: int = 0) -> Tuple[np.ndarray, np.ndarray]: + """Calculate mean and std along the specified axis, ignoring NaNs.""" + axes_to_reduce = tuple(i for i in range(arr.ndim) if i != mean_axis) + + mean = np.nanmean(arr, axis=axes_to_reduce) # shape: (M,) + std = np.nanstd(arr, axis=axes_to_reduce) # shape: (M,) + return mean, std + + +def _setup_logging(log_dir: str) -> SummaryWriter: + """Set up TensorBoard logging directory and writer.""" + Path(log_dir).mkdir(parents=True, exist_ok=True) + return SummaryWriter(log_dir) + + +def _compute_masked_loss( + pred: torch.Tensor, target: torch.Tensor, land_mask: torch.Tensor +) -> torch.Tensor: + """Compute L1 loss masked to ocean pixels only.""" + ocean = (~land_mask).to(pred.device).unsqueeze(1).float() + loss = torch.nn.functional.l1_loss(pred, target, reduction="none") * ocean + + num = loss.sum(dim=(-2, -1)) + denom = ocean.sum(dim=(-2, -1)).clamp_min(1) + + return (num / denom).mean() + + +def _save_model(model: torch.nn.Module, log_dir: str, verbose: bool) -> None: + """Save model state and config to disk.""" + model_path = Path(log_dir) / "best_model.pth" + torch.save( + {"model_state_dict": model.state_dict(), "model_config": model.config}, + model_path, + ) + if verbose: + print(f"Model saved to {model_path}") + + +def train_monthly_model( + model: torch.nn.Module, + dataset: Dataset, + shuffle: bool = True, + batch_size: int = 2, + num_epoch: int = 100, + patience: int = 10, + accumulation_steps: int = 1, + optimizer_lr: float = 1e-3, + log_dir: str = ".", + save_model: bool = True, + device: str = "cpu", + verbose: bool = True, +): + """Train the model to predict monthly data from daily data. + Args: + model: the PyTorch model to train + dataset: Dataset object containing the training data + shuffle: whether to shuffle the data each epoch + batch_size: number of samples per batch + num_epoch: number of epochs to train + patience: number of epochs to wait for improvement before early stopping + accumulation_steps: number of batches to accumulate gradients over before updating weights + optimizer_lr: learning rate for the optimizer + log_dir: directory to save logs + save_model: whether to save the best model to disk + device: device to run training on ("cpu" or "cuda") + verbose: whether to print training progress + """ + + # Initialize the model + model = model.to(device) + decoder = model.decoder + with torch.no_grad(): + decoder.bias.copy_(torch.from_numpy(dataset.daily_mean)) + decoder.scale.copy_(torch.from_numpy(dataset.daily_std) + 1e-6) + + # Create data loader + dataloader = DataLoader( + dataset, + batch_size=batch_size, + shuffle=shuffle, + pin_memory=False, + ) + + # Set up logging + writer = _setup_logging(log_dir) + + # Set the optimizer + optimizer = torch.optim.Adam(model.parameters(), lr=optimizer_lr) + best_loss = float("inf") + counter = 0 + best_state_dict = None # Store best model state + + # Add scheduler - reduces LR instead of stopping immediately + scheduler = ReduceLROnPlateau( + optimizer, + mode="min", + factor=0.5, + patience=patience // 2, # Reduce LR before early stop triggers + min_lr=1e-7, + ) + + model.train() + for epoch in range(num_epoch): + epoch_loss = 0.0 + + optimizer.zero_grad() + + for i, batch in enumerate(dataloader): + # Batch prediction + pred = model( + batch["daily_patch"], + batch["daily_mask_patch"], + batch["land_mask_patch"], + batch["padded_days_mask"], + ) # (B, M, H, W) + + # Compute masked loss + loss = _compute_masked_loss( + pred, batch["monthly_patch"], batch["land_mask_patch"] + ) + + # Scale loss for gradient accumulation + scaled_loss = loss / accumulation_steps + scaled_loss.backward() + + # Track unscaled loss for logging + epoch_loss += loss.item() + + # Update weights every accumulation_steps batches + if (i + 1) % accumulation_steps == 0: + optimizer.step() + optimizer.zero_grad() + + # Handle remaining gradients if num_batches is not divisible by accumulation_steps + if (i + 1) % accumulation_steps != 0: + optimizer.step() + optimizer.zero_grad() + + # Calculate average epoch loss + avg_epoch_loss = epoch_loss / (i + 1) + + # Step scheduler + scheduler.step(avg_epoch_loss) + + # Log to TensorBoard + writer.add_scalar("Loss/train", avg_epoch_loss, epoch) + writer.add_scalar("Loss/best", best_loss, epoch) + + # Early stopping check + if avg_epoch_loss < best_loss: + best_loss = avg_epoch_loss + best_state_dict = copy.deepcopy(model.state_dict()) + counter = 0 + else: + counter += 1 + + if verbose and epoch % 20 == 0: + print(f"Epoch {epoch}: best_loss = {best_loss:.6f}") + + # Only stop if LR is at minimum AND no improvement + current_lr = optimizer.param_groups[0]["lr"] + if counter >= patience and current_lr <= scheduler.min_lrs[0]: + writer.add_text("Training", f"Early stop at epoch {epoch}", epoch) + break + + # Restore best model + if best_state_dict is not None: + model.load_state_dict(best_state_dict) + + # Close the writer when done + writer.close() + + if verbose: + print(f"Training complete. Best loss: {best_loss:.6f}") + + if save_model: + _save_model(model, log_dir, verbose) + + return model diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb index c6d2e0a..045f5f8 100644 --- a/notebooks/example.ipynb +++ b/notebooks/example.ipynb @@ -13,7 +13,7 @@ "import torch.nn.functional\n", "from torch.utils.data import DataLoader\n", "from climanet.st_encoder_decoder import SpatioTemporalModel\n", - "from climanet.utils import pred_to_numpy, add_month_day_dims\n", + "from climanet.utils import pred_to_numpy, train_monthly_model\n", "from climanet import STDataset" ] }, @@ -32,7 +32,7 @@ "metadata": {}, "outputs": [], "source": [ - "data_folder = Path(\"../../data/output/\")\n", + "data_folder = Path(\"/home/sarah/temp/eso4clima\")\n", "\n", "file_names = [data_folder / \"202001_day_ERA5_masked_ts.nc\", data_folder / \"202002_day_ERA5_masked_ts.nc\"]\n", "daily_data = xr.open_mfdataset(file_names)\n", @@ -79,28 +79,6 @@ "print(daily_subset[\"ts\"].shape, monthly_subset[\"ts\"].shape) # (time, lat, lon)" ] }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d70ba708-843c-42c2-9d44-3bd60bb3b13b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mean: [299.9357 300.31335], std: [1.187207 1.2649659]\n" - ] - } - ], - "source": [ - "# create monthly mean to predict mean and std per month\n", - "daily_subset_averaged = daily_subset[\"ts\"].resample(time=\"MS\").mean(skipna=True)\n", - "mean = daily_subset_averaged.mean(dim=[\"lat\", \"lon\"], skipna=True).values\n", - "std = daily_subset_averaged.std(dim=[\"lat\", \"lon\"], skipna=True).values\n", - "print(f'mean: {mean}, std: {std}')" - ] - }, { "cell_type": "markdown", "id": "11a1c896-a876-40bc-8f0a-9e7373d734b1", @@ -119,172 +97,87 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "id": "bcc04777-5235-4ef3-81bd-2bdcafd8baaa", "metadata": {}, "outputs": [], "source": [ "# create the model\n", - "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\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", - "with torch.no_grad():\n", - " decoder.bias.copy_(torch.from_numpy(mean))\n", - " 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" + "model = SpatioTemporalModel(patch_size=patch_size, overlap=overlap, num_months=2)" ] }, { "cell_type": "code", - "execution_count": 34, - "id": "766cdd9d-8a97-42f0-988f-cf0c003836d2", + "execution_count": 5, + "id": "09eeabbe-36ef-46a4-ad39-b82559a2da2e", "metadata": {}, "outputs": [], "source": [ + "num_patches = 20\n", "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=2, \n", - " shuffle=True,\n", - " pin_memory=False,\n", + " patch_size=(patch_size[1]*num_patches, patch_size[2]*num_patches), # based on the patch_size in model\n", ")" ] }, { - "cell_type": "code", - "execution_count": 35, - "id": "e64d64b9-06b6-4284-956e-1e9ca0ecfeec", + "cell_type": "markdown", + "id": "945ec311-53b3-4cac-a1e3-d16f4508e7a7", "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": [ - "for batch in dataloader:\n", - " print(batch[\"daily_patch\"].shape)" + "### Start training loop" ] }, { "cell_type": "code", - "execution_count": 36, - "id": "eb77d5be-a844-4bd0-bf38-4865ac1ca78e", + "execution_count": 6, + "id": "e84304f1-deb2-4f7c-b026-9ee4bbb38272", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "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", - "0.16787965595722198\n" + "Epoch 0: best_loss = 1.069344\n", + "Epoch 20: best_loss = 1.001331\n", + "Epoch 40: best_loss = 0.762150\n", + "Epoch 60: best_loss = 0.529413\n", + "Epoch 80: best_loss = 0.388629\n", + "Epoch 100: best_loss = 0.309013\n", + "Epoch 120: best_loss = 0.253549\n", + "Epoch 140: best_loss = 0.197170\n", + "Epoch 160: best_loss = 0.165710\n", + "Epoch 180: best_loss = 0.138168\n", + "Epoch 200: best_loss = 0.121227\n", + "Epoch 220: best_loss = 0.110783\n", + "Epoch 240: best_loss = 0.099818\n", + "Epoch 260: best_loss = 0.093828\n", + "Epoch 280: best_loss = 0.088739\n", + "Epoch 300: best_loss = 0.084425\n", + "Epoch 320: best_loss = 0.080834\n", + "Epoch 340: best_loss = 0.076881\n", + "Epoch 360: best_loss = 0.074472\n", + "Epoch 380: best_loss = 0.072305\n", + "Epoch 400: best_loss = 0.070293\n", + "Epoch 420: best_loss = 0.068516\n", + "Epoch 440: best_loss = 0.066416\n", + "Epoch 460: best_loss = 0.064231\n", + "Epoch 480: best_loss = 0.062087\n", + "Epoch 500: best_loss = 0.060969\n", + "Training complete. Best loss: 0.060969\n", + "Model saved to runs/best_model.pth\n" ] } ], "source": [ - "best_loss = float(\"inf\")\n", - "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(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\"]\n", - " padded_days_mask = batch[\"padded_days_mask\"]\n", - "\n", - " # Batch prediction\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).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", - " loss_per_month = num / denom \n", - " loss = loss_per_month.mean()\n", - "\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 avg_epoch_loss < best_loss:\n", - " best_loss = avg_epoch_loss\n", - " counter = 0\n", - " else:\n", - " counter += 1\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(best_loss)" + "# verbose is True\n", + "trained_model = train_monthly_model(\n", + " model, dataset, batch_size=2, num_epoch=501, patience=10, accumulation_steps=2, log_dir=\"./runs\"\n", + ")" ] }, { @@ -297,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 7, "id": "bda9f068", "metadata": {}, "outputs": [ @@ -331,19 +224,44 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 8, + "id": "610e6fbf-1740-47bb-a955-248f9aa8d2ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# load the model\n", + "model_path = \"runs/best_model.pth\"\n", + "checkpoint = torch.load(model_path, weights_only=False) # weights_only=False we trust the file\n", + "model = SpatioTemporalModel(**checkpoint[\"model_config\"])\n", + "model.load_state_dict(checkpoint[\"model_state_dict\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "id": "1fe7425a-5ab8-423b-8130-1311cd098077", "metadata": {}, "outputs": [], "source": [ - "model.eval()\n", + "trained_model.eval()\n", "with torch.no_grad():\n", - " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask)" + " pred = trained_model(daily_batch, daily_mask, land_mask, padded_days_mask)" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 10, "id": "15d5fbee", "metadata": {}, "outputs": [ @@ -362,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 11, "id": "ee2e5efb-d572-4162-95a8-9a299eaa3a7d", "metadata": {}, "outputs": [], @@ -384,23 +302,23 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 12, "id": "e581aa17-3916-47be-a1b6-447015f3f3da", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 41, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "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==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHHCAYAAACvJxw8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgmdJREFUeJzt3Xl4U1X+BvA3SZvuC0sXlF2UTRBEhYKjoFhQFhdEHZVtEBQrIotCRQVBLAqD44q4FVRwQWVUdJRqURTKIlKVrYoji0BZBFooNE2T8/uDaX4k99v0tEmXhPfzPHkecnPvuUsScnrve7/HpJRSICIiIiKRubY3gIiIiKguY2eJiIiIyAt2loiIiIi8YGeJiIiIyAt2loiIiIi8YGeJiIiIyAt2loiIiIi8YGeJiIiIyAt2loiIiIi8YGeJ6qTmzZtj+PDhtb0ZRERE7CxR7VmzZg2mT5+OY8eO1fam1KgNGzbgvvvuQ/v27REVFYWmTZvilltuwa+//irOv23bNvTt2xfR0dGoX78+hgwZgkOHDrnNs337djz00EPo1KkTYmJi0KhRI/Tr1w8//PCD2ObevXtxyy23ID4+HrGxsbj++uvx3//+V3sfnE4nnn76abRo0QLh4eHo2LEj3nnnHcN869evx7333osuXbogNDQUJpNJex1lZs2ahYEDByIpKQkmkwnTp0/3Ov97772HlJQUREVFIT4+Ht27d0d2djYAoGfPnjCZTBU+ytaxYsUKjBw5EhdeeCEsFguaN2/ut+309OSTT6Jbt25ISEhAeHg4zj//fDzwwAOG9xrQP/7efPLJJ7j44osRHh6Opk2bYtq0aSgtLTXMd+zYMYwePRoJCQmIiopCr1698OOPP1ZqXUQBTxHVkjlz5igA6o8//jC8VlxcrEpKSmp+o2rAoEGDVHJysho7dqx69dVX1cyZM1VSUpKKiopSv/zyi9u8e/bsUQ0bNlTnnXeeevbZZ9WsWbNUvXr11EUXXaRsNptrvokTJ6r4+Hg1cuRItWDBAvX000+r8847T1ksFpWVleXW5vHjx9X555+vEhMT1VNPPaXmzZunmjRpoho3bqwOHz6stQ9TpkxRANSoUaPUK6+8ovr166cAqHfeecdtvmnTpqnQ0FDVpUsXdcEFF6iq/JcDQCUnJ6s+ffooAGratGnlzjtt2jRlMpnU4MGD1csvv6yef/55dffdd6s333xTKaXUihUr1FtvveV63H///QqAevjhh92m//TTT0oppYYNG6bCw8NV9+7dVePGjVWzZs38sp2Sm266Sd19993qmWeeUa+99pqaOHGiio2NVa1atVInTpxwm1f3+Jfn888/VyaTSfXq1Uu98sorauzYscpsNqt77rnHbT6Hw6G6d++uoqKi1PTp09ULL7yg2rVrp2JiYtSvv/5aqf0jCmTsLFGt8dZZCmarV6926+gopdSvv/6qwsLC1B133OE2fcyYMSoiIkLt2rXLNS0rK0sBUAsWLHBN++GHH9Tx48fdlj18+LBKSEhQPXr0cJv+1FNPKQBq/fr1rmnbtm1TFotFpaenV7j9f/75pwoNDVVpaWmuaU6nU/3tb39TjRs3VqWlpa7p+fn56uTJk0oppdLS0qrUWSr7fBw6dMhrJyQnJ0eZTCY1b9487baXLl2qAKiVK1eKr+/du9fVae/Xr5/XzpLudlbGBx98YOgEVeb4l6ddu3bqoosuUna73TVt6tSpymQyqW3btrmmvffeewqAWrp0qWvawYMHVXx8vPr73//u6+4RBQxehqNaMX36dDz44IMAgBYtWrguf+zcuROAMbO0cOFCmEwmfP/997j//vuRkJCA+Ph43H333SgpKcGxY8cwdOhQ1KtXD/Xq1cNDDz0EpZTbOp1OJ/71r3+hffv2CA8PR1JSEu6++24cPXq0pnYbANC9e3dYrVa3aeeffz7at2+Pbdu2uU3/8MMP0b9/fzRt2tQ1rXfv3rjgggvw/vvvu6Z16dIF0dHRbss2aNAAf/vb3wxtfvDBB7j00ktx6aWXuqa1adMGV199tVub5fn4449ht9tx7733uqaZTCaMGTMGf/75J3JyclzTk5KSEBERUWGb3ni79HWmf/3rX0hOTsa4ceOglMKJEyd8Wi8AnHPOOQgNDdWaV3c7T548ie3bt+Pw4cPabZ55qboyx7+goADbt29HQUGBa9rWrVuxdetWjB49GiEhIa7p9957L5RS+OCDD1zTPvjgAyQlJeGmm25yTUtISMAtt9yCjz/+GDabTWufiQIdO0tUK2666Sb8/e9/BwA888wzeOutt/DWW28hISHB63Jjx47Fb7/9hscffxwDBw7EK6+8gkcffRQDBgyAw+HAk08+icsvvxxz5szBW2+95bbs3XffjQcffBA9evTAs88+ixEjRmDx4sXo06cP7Ha71/XabDYcPnxY61EVSikcOHAADRs2dE3bu3cvDh48iEsuucQw/2WXXYZNmzZV2G5+fr5bm06nEz///HO5bf7+++84fvy41zY3bdqEqKgotG3b1rB82eu14euvv8all16K5557DgkJCa7s1gsvvFAr21Oe9evXo23btuJ2KaVw+PBh5Ofn47vvvsP9998Pi8WCnj17uuapzPFftmwZ2rZti2XLlrktD8DwGTjnnHPQuHFjt+U3bdqEiy++GGaz+0/FZZddhpMnT5absyMKNiEVz0Lkfx07dsTFF1+Md955BzfccIP2X+VJSUn4/PPPYTKZcO+992LHjh2YM2cO7r77bsyfPx8AMHr0aDRv3hxvvPEGhg4dCgD4/vvv8dprr2Hx4sW4/fbbXe316tULffv2xdKlS92me3rnnXcwYsQIrW30PKOlY/Hixdi7dy9mzJjhmrZ//34AQKNGjQzzN2rUCEeOHIHNZkNYWJjY5nfffYecnBw88sgjrmlly5TXJgDs27cPrVu3Lndb9+/f7woxl7d8TTt69CgOHz6M1atXIzs7G9OmTUPTpk2RmZmJsWPHIjQ0FHfffXeNb1dlHThwwO29ady4MZYsWYI2bdq4pvl6/Cv6XJ25/P79+3HFFVeI85Wtq0OHDhXtFlHAY2eJAsrIkSPdfiS6du2KnJwcjBw50jXNYrHgkksuwcaNG13Tli5diri4OFxzzTVuZ3/KLl+tXLnSa2epT58+yMrK8vPenLZ9+3akpaUhJSUFw4YNc00/deoUAIidofDwcNc80usHDx7E7bffjhYtWuChhx6qdJvelLdO3eWrQ9klt7/++gvvvvsubr31VgDAzTffjA4dOuCJJ56oM52lnj17ltuhrl+/PrKyslBcXIxNmzbho48+MlxOrMzxHz58uKEER0WfgcLCwiqtiyiYsbNEAeXM7A4AxMXFAQCaNGlimH5mFum3335DQUEBEhMTxXYPHjzodb2NGjUS/xL3VX5+Pvr164e4uDh88MEHsFgsrtfKsj5SLqS4uNhtnjMVFRWhf//+OH78OL7//nu3LFNl2szPz3d7PS4uDhEREYiIiKj0NlWkvHXpKps3NDQUN998s2u62WzGrbfeimnTpmH37t2Gz09dY7Va0bt3bwBA//79cfXVV6NHjx5ITExE//79AcDn41/RZ+DM5avjvSYKROwsUUA5szNR0fQz/3p3Op1ITEzE4sWLxeUrykqdOnXKLSTrTXJystZ8BQUFuPbaa3Hs2DF89913OOecc9xeL+uclV02OdP+/ftRv359w1/9JSUluOmmm/Dzzz/jyy+/xIUXXuj2etky5bUJwLUdnp3DzMxMDB8+HI0aNcLKlSuhlHI7y+e5fGWUty5d9evXR3h4OOLj4w2fhbIO8tGjR+t8Z8lT9+7d0ahRIyxevNjVWfL1+J/5ufL8I2P//v2u7FPZvDqfFaJgx84S1ZqqFCisqvPOOw9fffUVevToUaW/ht977z2/ZpaKi4sxYMAA/Prrr/jqq6/Qrl07wzznnnsuEhISxMKS69evR6dOndymOZ1ODB06FF9//TXef/99XHnllYblzGYzOnToILa5bt06tGzZEjExMQBguOzYvn17AECnTp3w2muvYdu2bW7bvW7dOtfrlVXeunSZzWZ06tQJGzZsQElJidvdhmUZnIo6xHVVcXGxW0fd1+Nf9voPP/zg1jHat28f/vzzT4wePdpt3u+++w5Op9Mt5L1u3TpERkbiggsu8GXXiAIG74ajWhMVFQUANVLB+5ZbboHD4cDMmTMNr5WWlla4DWWZJZ1HRRwOB2699Vbk5ORg6dKlSElJKXfeQYMGYfny5dizZ49r2tdff41ff/0VgwcPdpt37NixeO+99/DSSy+53ert6eabb8aGDRvcOkx5eXnIzs52a7N3795uj7IzEtdffz1CQ0Px0ksvueZVSuHll1/Gueeei+7du1d4DDyVt67KuPXWW+FwOLBo0SLXtOLiYixevBjt2rWrM2dBpNIBRUVFOHnypGHeDz/8EEePHnW7c60yx18qHdC+fXu0adMGr7zyChwOh2v6/PnzYTKZ3C5j3nzzzThw4AA++ugj17TDhw9j6dKlGDBgQLk3FxAFG55ZolrTpUsXAMDUqVNx2223ITQ0FAMGDHB1ovzpyiuvxN13342MjAzk5uYiNTUVoaGh+O2337B06VI8++yzbj8SnvyZWZo4cSI++eQTDBgwAEeOHMHbb7/t9vqdd97p+vfDDz+MpUuXolevXhg3bhxOnDiBOXPmoEOHDm5nuv71r3/hpZdeQkpKCiIjIw1t3njjja7jeu+99+LVV19Fv379MGnSJISGhmLevHlISkrCxIkTK9z+xo0b44EHHsCcOXNgt9tx6aWX4t///je+++47LF682O0y2K5du1wlHMo6Z0888QQAoFmzZhgyZEiF63vrrbewa9cuV2di1apVrjaGDBmCZs2aAThdGuK1115DWloafv31VzRt2tS17KefflrheiQ///wzPvnkEwDAjh07UFBQ4Fr3RRddhAEDBlR6O9evX49evXph2rRpriFRfvvtN/Tu3Ru33nor2rRpA7PZjB9++AFvv/02mjdvjnHjxrnWU5njv2zZMowYMcJwWXPOnDkYOHAgUlNTcdttt2Hz5s144YUXcNddd7mVJLj55pvRrVs3jBgxAlu3bkXDhg3x0ksvweFw4PHHH6/SMSUKSLVSCpPof2bOnKnOPfdcZTab3ap5N2vWTA0bNsw1X2ZmpgKgNmzY4Lb8tGnTFAB16NAht+nDhg1TUVFRhvW98sorqkuXLioiIkLFxMSoDh06qIceekjt27fP7/tWniuvvFIBKPfhafPmzSo1NVVFRkaq+Ph4dccdd6j8/Hy3eYYNG+a1Tc8q6Xv27FE333yzio2NVdHR0ap///7qt99+094Hh8OhnnzySdWsWTNltVpV+/bt1dtvv22Yb+XKleVu05VXXunz8fKsvH3gwAE1bNgwVb9+fRUWFqa6du2qvvjii3LbrqiCd9nnTnqc+fmszHaWHZMzK3wfOnRIjR49WrVp00ZFRUUpq9Wqzj//fPXAAw8YPttK6R//su3PzMw0vLZs2TLVqVMnFRYWpho3bqweeeQRcYihI0eOqJEjR6oGDRqoyMhIdeWVVxq+h0TBzqRUFYrCEBEREZ0lmFkiIiIi8oKdJSIiIiIv2FkiIiIi8iJgOkuzZs1C9+7dERkZifj4eHGe3bt3o1+/foiMjERiYiIefPBBlJaWem33yJEjuOOOOxAbG4v4+HiMHDnSL6OVExERUXAImM5SSUkJBg8ejDFjxoivOxwO9OvXDyUlJVizZg0WLVqEhQsX4rHHHvPa7h133IEtW7YgKysLy5cvx6pVq9yKshEREdHZLeDuhlu4cCEeeOABQxHB//znP+jfvz/27duHpKQkAMDLL7+MyZMn49ChQ24VfcuUVcDdsGGDq+jbF198geuuuw5//vlnnSliR0RERLUnaIpS5uTkoEOHDq6OEnC66vKYMWOwZcsWdO7cWVwmPj7erTpu7969YTabsW7dOtx4443iumw2m9vgkk6nE0eOHEGDBg1qdAgPIiIKLEopHD9+HOecc47bEDL+VlxcjJKSEr+0ZbVaER4e7pe2AlXQdJby8/PdOkoAXM89RzQ/cxnPUehDQkJQv379cpcBgIyMDFavJSKiKtuzZw8aN25cLW0XFxejRbNo5B90VDyzhuTkZPzxxx9ndYepVjtLU6ZMwVNPPeV1nm3btqFNmzY1tEV60tPTMWHCBNfzgoICNG3aFHv27EFsbGwtbhkRBYs/9p5vmHbCafwvO9TkNExzQO8M9ylnqGFamMl4U4zZZExrWGCcVqSM7VkgbZ/eGZUTTmN8QmJXFsM0s7B9Bc5IYVnjMS1w6g22XeQwdh7syn3f9tvi3Z6XFNnx1nXLXANWV4eSkhLkH3Rg18bmiI3x7exV4XEnmnXZiZKSEnaWasvEiRPdxiuStGzZUqut5ORkrF+/3m3agQMHXK+Vt8zBgwfdppWWluLIkSPlLgMAYWFh4gCSsbGx7CwRkV/EFAo/ck7jtFChX6TbWTIL7YWbjNN0O0smZVzW2I3R7ywpp7S0kW5nyS60Jy1b4tD7aXQI81k82rOGGjuQAGokshEdY0J0jG/rcWp+loJdrXaWEhISkJCQ4Je2UlJSMGvWLBw8eNB1aS0rKwuxsbFo165ducscO3YMGzdudA3qmp2dDafTia5du/plu4iIiGqDQznh8PEWLocynhk8GwVM6YDdu3cjNzcXu3fvhsPhQG5uLnJzc101kVJTU9GuXTsMGTIEP/30E7788ks88sgjSEtLc50FWr9+Pdq0aYO9e/cCANq2bYu+ffti1KhRWL9+PVavXo377rsPt912G++EIyKigOaE8suDAijg/dhjj2HRokWu52V3t61cuRI9e/aExWLB8uXLMWbMGKSkpCAqKgrDhg3DjBkzXMucPHkSeXl5sNvtrmmLFy/Gfffdh6uvvhpmsxmDBg3Cc889V3M7RkQkkC6lRZqNgV2n8FsmXSKT2osx690tJbUniTLZDdOk9YYKOSbPrM/p9ozbVyJcNgs3C+sV2os3nzRMKxZyVuHCeqVsU7iwv57tnXS4565sIcZlqO4LuDpLdVFhYSHi4uJQUFDAzBIR+cVvf+qd3ZY6SxLdHJNEt7MkrUN3vVJnScwTCdMsUshdaE/qGEnTpPVKnaUipzG76tneXls9t+e2E3b8s8fyav29KPtN2pfX2C8B73Na/3nW/74FzJklIiIi0udQCg4fz4f4unywCJjMEhEREVFt4JklIqIaJF1eCxUuczmVkPURbuGHcAt6sXAJSm5P706nEuHvaqk9qcSANF+JUFBAugwnXUqzC8sWC/WidG95dwr7VqyM9Z2kdUiX6zz3N9Linn8yW2ous+SPgDYD3qexs0RERBSEnFBwsLPkF7wMR0REROQFzywREREFIV6G8x92loiIiIIQ74bzH3aWiIiq0dY957o9l8Zyk5iF+eTchN64bVLeWQyMCyzCD2aJMIacLmlwXbufUyHS+HNSYNwhBNAlcu0lYUw6j2Ma5lEwU5mNAxVT3cfOEhERURBy/u/haxvEzhIREVFQcvjhbjhflw8W7CwREREFIYc6/fC1DWLpACIiIiKveGaJiMhPsne2NkxLsLgHiKVq3XYhfW0XgscWIZAtDVQrBbx9GUhXoju4rlRJWwpf+0JchxDmlgbclULauqHvcLOxGrfnekNNDvfXPZ5XJ2aW/IdnloiIiIKQEyY4fHzoDhtTZv78+ejYsSNiY2MRGxuLlJQU/Oc//3G9XlxcjLS0NDRo0ADR0dEYNGgQDhw44NbG/fffjy5duiAsLAydOnXyx6HwGTtLRERE5BeNGzfG7NmzsXHjRvzwww+46qqrcP3112PLli0AgPHjx+PTTz/F0qVL8e2332Lfvn246aabDO384x//wK233lrTm18uXoYjIiIKQk51+uFrG5UxYMAAt+ezZs3C/PnzsXbtWjRu3Bivv/46lixZgquuugoAkJmZibZt22Lt2rXo1q0bAOC5554DABw6dAg///yzbzvgJ+wsERH5Sbz5lGFauJCT8aT7gyTlmCS6+STd9uxSMUcfMlBSe3ZV9Z8js5CfcgoXTpya65WWlRQ7QyucxzMTZa/Bithll9J8bQMACgsL3aaHhYUhLCzM+7IOB5YuXYqioiKkpKRg48aNsNvt6N27t2ueNm3aoGnTpsjJyXF1luoiXoYjIiIir5o0aYK4uDjXIyMjo9x5f/nlF0RHRyMsLAz33HMPli1bhnbt2iE/Px9WqxXx8fFu8yclJSE/P7+a98A3PLNEREQUhPx5ZmnPnj2IjY11Tfd2Vql169bIzc1FQUEBPvjgAwwbNgzffvutT9tR29hZIiIiCkJOZYJT81KrtzYAuO5u02G1WtGqVSsAQJcuXbBhwwY8++yzuPXWW1FSUoJjx465nV06cOAAkpOTfdrO6sbLcERERFRtnE4nbDYbunTpgtDQUHz99deu1/Ly8rB7926kpKTU4hZWjGeWiIiq4Lc/zzFMCzdVXCAyVPhD/6QPwW3t4pDSOnw46SAVlrQIJQyloo/SNhvLO5azXiGkXdlaQGcyCwF8s/JfKUbPfdV9v/zBn5fhdKWnp+Paa69F06ZNcfz4cSxZsgTffPMNvvzyS8TFxWHkyJGYMGEC6tevj9jYWIwdOxYpKSlu4e4dO3bgxIkTyM/Px6lTp5CbmwsAaNeuHaxWq0/7U1XsLBEREQUhB8w+V0uvbL3xgwcPYujQodi/fz/i4uLQsWNHfPnll7jmmmsAAM888wzMZjMGDRoEm82GPn364KWXXnJr46677nLLOHXu3BkA8Mcff6B58+a+7E6VsbNEREQUhJQfMkuqksu//vrrXl8PDw/Hiy++iBdffLHceb755ptKrbMmMLNERERE5AXPLBERVUDKJ0kD4krxDs+/SO3CYsXSYK5CY6HiQLDGv3nNwoC7Et2zDtK2yBko/xavFNerOTBviXBMJVKhSnlbqnicay6iZFAbmaVgxc4SERFREHIosxiIr1wbftqYAMfLcERERERe8MwSERFREHLCpD3OXflt8NQSwM4SERFRUGJmyX/YWSIiqoAU5rYIvyHOKo4oLwWFHT7c8u3L7eLSj6NUWFL8Ea2lkxBSLkcqkCmFtHXrEIWbjGUzpePiOc34nGdqAhE7S0REREHIPwFvdu4AdpaIiIiC0unMko8D6fIyHADeDUdERETkFc8sERERBSGnH8aG491wpwVMZ2nWrFn47LPPkJubC6vVimPHjrm9/tNPP2H27Nn4/vvvcfjwYTRv3hz33HMPxo0b57Xd5s2bY9euXW7TMjIyMGXKFH/vAhEFqHCT8VKERZgmBcHtntM0f3uk0emlat2+kH5IpXC4FOaWsjDFEILgwny6VbilZeWwubAtzlBhWb2fPGn7SoRlTzqtFbbluR3Fxtx5tWFmyX8CprNUUlKCwYMHIyUlRRyob+PGjUhMTMTbb7+NJk2aYM2aNRg9ejQsFgvuu+8+r23PmDEDo0aNcj2PiYnx+/YTERHVJCfMrLPkJwHTWXr88ccBAAsXLhRf/8c//uH2vGXLlsjJycFHH31UYWcpJiYGycnJftlOIiIiCi5BHfAuKChA/fr1K5xv9uzZaNCgATp37ow5c+agtLTU6/w2mw2FhYVuDyIiorrEoUx+eVAAnVmqrDVr1uC9997DZ5995nW++++/HxdffDHq16+PNWvWID09Hfv378e8efPKXSYjI8N1pouIgkvhvqaGaXHmMMM0mzL+USWOQq/cQypSMUvpSofclnGSmCfy4e9guSil8adCv3ilf7NIurkjaT7dLJKU25Lak7a5onWqGrwV3+GHgLeDl+EA1PKZpSlTpsBkMnl9bN++vdLtbt68Gddffz2mTZuG1NRUr/NOmDABPXv2RMeOHXHPPffgn//8J55//nnYbLZyl0lPT0dBQYHrsWfPnkpvIxEREQWGWj2zNHHiRAwfPtzrPC1btqxUm1u3bsXVV1+N0aNH45FHHqn0NnXt2hWlpaXYuXMnWrduLc4TFhaGsDDjX5pERER1hVOZ4fTxbriqDuETbGq1s5SQkICEhAS/tbdlyxZcddVVGDZsGGbNmlWlNnJzc2E2m5GYmOi37SIiIqppvAznPwGTWdq9ezeOHDmC3bt3w+FwIDc3FwDQqlUrREdHY/PmzbjqqqvQp08fTJgwAfn5+QAAi8Xi6pCtX78eQ4cOxddff41zzz0XOTk5WLduHXr16oWYmBjk5ORg/PjxuPPOO1GvXr3a2lUiIiKqQwKms/TYY49h0aJFruedO3cGAKxcuRI9e/bEBx98gEOHDuHtt9/G22+/7ZqvWbNm2LlzJwDg5MmTyMvLg91+evTosLAwvPvuu5g+fTpsNhtatGiB8ePHY8KECTW3Y0RUa4r2NzNMCzPp/bdo1gzqOj2KV0qXNaQClFKAWgp9S3cr6RaWlEhB5hIhyGwXClCKQXBxW3wJblccqi5vPnm9VW/P7qx4mz3D7L4WiawMJ+TjX9k2CDApxQuSviosLERcXBwKCgoQGxtb25tDRJqkzlKI0AmQSHfDSQX87B4/N3bhv9xjTl86N7p3lp1dnSWpgrcvnSWb0J60jorat52wY073z6r196LsN2n+j5ciItq3cyKnTpRizMUbzvrft6Cus0RERETkq4C5DEdERET6/DM2HM+pAOwsERERBSUnTGIhzsq2QewsEdFZ4tT+FoZpZiGJYDFJFaf1Yq46oW/5Vmz/hrR1g+C6LCbj/svbZ5zPoZkBs4jL6p3V0M0dSdssz1f1symenQvPbbNrfpb8gWeW/IdHgYiIiMgLnlkiIiIKQv4pSslzKgA7S0REREHJqUzalx69tUHsLBFRgNu651zDtHMsxr+GY80RhmlOzZJ7oUKhylI4tJY1e/zYhAq5o1AhYxRuMtZxsmvmmKTskFWYr0TMExnXaxZyK9IZBzHbJJ2ZkHI7wm+ylJfRzdAUK2MNJCmLJB0/7fk0MmSenQ12PgITO0tERERByOmHy3BiZ/csxM4SERFREHIqs0939pW1QbwbjoiIiMgrnlkiIiIKQg6YtGtzeWuD2FkiogAXLoSKzZqFEKWilP5m8fixsZiM2+YUwuJSfNwsFrQ0TrMJIeISodimVQlr0fxtlIpI6haqhLAtUujbLq1XeL/twoC24vYJ77cvoW+JZwDds0CoVDC0uvAynP/wKBARERF5wTNLREREQcgB3y+j6RXICH7sLBEREQUhXobzH3aWiCigSYUa7ZrFJnVJxSsdypg9cQr5IZ3BdcOEDI804Gqo0JS0p9J26BeC1Cu+aBHWIQ0SLA/CW/UfYF8GdjUL2wJhEF670/jTKA3WK03zzEpV9Lw6cSBd/+FRICIiIvKCZ5aIiIiCkIJJa0iWitogdpaIiIiCEi/D+Q+PAhEREZEXPLNEREFHCjjbVanWshapYKImKcxtMVV+ZHoAYuFGab+cQtBcl3RbuRTcLta8FCOHuateqNIihtyN76MUtJaKP9qdxnWIoW9NUljbc+DaUJP7zfc1W5TSJH+2KtkGsbNEREQUlBwwGzpvVWmDeBmOiIiIyCueWSIiIgpCvAznP+wsERERBSEnzOLgwZVtg9hZIqIAVyL+Z171EK1dGUfDkoLbYpVsgWcAO1QzQG7RXGeoECCXKmmbpdC7uGYhVC1WnTYGrR0qVGu9EqlyeIlYNVuvurZu1kaqJi7VJpLWIZ118Qxwe4bepRA81X3sLBEREQUhhzKJndDKtkHsLBEREQUlZpb8h50lIiKiIKSU2adBi8vaIHaWiCiALNnR1TCtvVXI7AjFDJ0+FAPUzSdJWSHP7JHDhyKSUnZKEirNJ+y/VNBSStRIxRelXI9U0NKYANNnkQpLCodPKvTo8KH2o5Szko6BVEizorZMPuTpqPaws0RERBSEHDCJVdor2waxs0RERBSUnMr3zJGTJ8IAsII3ERER+cn8+fPRsWNHxMbGIjY2FikpKfjPf/7jer24uBhpaWlo0KABoqOjMWjQIBw4cMCtjd27d6Nfv36IjIxEYmIiHnzwQZSW6o3tWF3YWSIiIgpCzv8FvH19VEbjxo0xe/ZsbNy4ET/88AOuuuoqXH/99diyZQsAYPz48fj000+xdOlSfPvtt9i3bx9uuukm1/IOhwP9+vVDSUkJ1qxZg0WLFmHhwoV47LHH/HpsKitgLsPNmjULn332GXJzc2G1WnHs2DHDPCahONs777yD2267rdx2jxw5grFjx+LTTz+F2WzGoEGD8OyzzyI6Otqfm09EflDsNBY9LBaKFJ5Uxr9CI4Vik7oswv8tdmnEeSkw7bFsqPA3qhQMl0LlugFvaXulyynSen1hLicerkMKc1uEoL5U1NHprPqlJrPQXrjZWK5TWq9UqLLCtsw1d4bECZMYxK9sG5UxYMAAt+ezZs3C/PnzsXbtWjRu3Bivv/46lixZgquuugoAkJmZibZt22Lt2rXo1q0bVqxYga1bt+Krr75CUlISOnXqhJkzZ2Ly5MmYPn06rFarT/tTVQFzZqmkpASDBw/GmDFjvM6XmZmJ/fv3ux433HCD1/nvuOMObNmyBVlZWVi+fDlWrVqF0aNH+3HLiYiIzj4OhwPvvvsuioqKkJKSgo0bN8Jut6N3796uedq0aYOmTZsiJycHAJCTk4MOHTogKSnJNU+fPn1QWFjoOjtVGwLmzNLjjz8OAFi4cKHX+eLj45GcnKzV5rZt2/DFF19gw4YNuOSSSwAAzz//PK677jrMnTsX55xzjk/bTEREVFv8WcG7sLDQbXpYWBjCwsLEZX755RekpKSguLgY0dHRWLZsGdq1a+e6MhQfH+82f1JSEvLz8wEA+fn5bh2lstfLXqstAXNmSVdaWhoaNmyIyy67DG+88QaUl5omOTk5iI+Pd3WUAKB3794wm81Yt25dTWwuERFRtfBnZqlJkyaIi4tzPTIyMspdb+vWrZGbm4t169ZhzJgxGDZsGLZu3VpTu10tAubMko4ZM2bgqquuQmRkJFasWIF7770XJ06cwP333y/On5+fj8TERLdpISEhqF+/vtcerM1mg81mcz337HETEREFkz179iA2Ntb1vLyzSgBgtVrRqlUrAECXLl2wYcMGPPvss7j11ltRUlKCY8eOuZ1dOnDggOuKUHJyMtavX+/WXtndcrpXjapDrXaWpkyZgqeeesrrPNu2bUObNm202nv00Udd/+7cuTOKioowZ86ccjtLVZWRkeG6LEhENecfF3xvmPbdzlaGaXbh0oNNqCUtha2lELVdCBqLYW7DFACe8wlBYd22pMrSunwJc4uVuaWK6H6uyePQvPghVfCGVMVdsz3dQow674dnCFz6LFUXJ/wwNtz/jkVZKYAqteF0wmazoUuXLggNDcXXX3+NQYMGAQDy8vKwe/dupKSkAABSUlIwa9YsHDx40HUyIysrC7GxsWjXrp1P++KLWu0sTZw4EcOHD/c6T8uWLavcfteuXTFz5kzYbDaxF5ycnIyDBw+6TSstLcWRI0e89mDT09MxYcIE1/PCwkI0adKkyttJRETkb8oPd8OpSi6fnp6Oa6+9Fk2bNsXx48exZMkSfPPNN/jyyy8RFxeHkSNHYsKECahfvz5iY2MxduxYpKSkoFu3bgCA1NRUtGvXDkOGDMHTTz+N/Px8PPLII0hLS/N6Nqu61WpnKSEhAQkJCdXWfm5uLurVq1fuAU5JScGxY8ewceNGdOnSBQCQnZ0Np9OJrl2NY1CV8RZsIyIiqgucyg9nliq5/MGDBzF06FDs378fcXFx6NixI7788ktcc801AIBnnnnGVabHZrOhT58+eOmll1zLWywWLF++HGPGjEFKSgqioqIwbNgwzJgxw6f98FXAZJZ2796NI0eOYPfu3XA4HMjNzQUAtGrVCtHR0fj0009x4MABdOvWDeHh4cjKysKTTz6JSZMmudpYv349hg4diq+//hrnnnsu2rZti759+2LUqFF4+eWXYbfbcd999+G2227jnXBERESV9Prrr3t9PTw8HC+++CJefPHFcudp1qwZPv/8c39vmk8CprP02GOPYdGiRa7nnTt3BgCsXLkSPXv2RGhoKF588UWMHz8eSim0atUK8+bNw6hRo1zLnDx5Enl5ebDb/79I2OLFi3Hffffh6quvdvV2n3vuuZrbMSLyiXYORcgFiVkXgZRjChVGnJcKSeq05e/ikFIqxiGswq6bzfGhYGQ4ql7g0SEU1wSMRQnDTcZ1FMNYwFQ6zJWtUF0Rz8teJ0oj3J7bSmvuZ7cqFbilNiiAOksLFy70WmOpb9++6Nu3r9c2evbsaSglUL9+fSxZssQfm0hERFRn1MZluGDFLiMRERGRFwFzZomIiIj01cbYcMGKnSUiIqIgxMtw/sPOEhEFNKmAoDRNCl9L0yw+/CUthbf9qebKGVZMKlQZKgS3JVJoWAq5h5uNwW3pIEhBcOmMiN1kDJGL75mwfRaTsaipxO50D5bbnCEez/1cuZNqBDtLREREQYhnlvyHnSUiIqIgxM6S//BuOCIiIiIveGaJiAJasTIWHywSpkUqm1Z7uoUqpWyTlLvRyUAJyRyflAgFOHULUPrCIgSKpOyQQ5jPIhWgFN4Kh1AMVMo2WYRj4NAssGgT5jNLAyA7jZ8zzzMxpxzuRTRL9KJPfsEzS/7DzhIREVEQUvD91n/G0U9jZ4mIiCgI8cyS/zCzREREROQFzywREREFIZ5Z8h92logooEmhXek/eKlcohTIlvhSbNJzWbEQphhu1tu2mihUKRWg1M3CSIF5KQguvhXCKqwoFbZF7yKJRQhpW5RxmhTmlgppyuF19/lOOdxD4CU1WJSSnSX/4WU4IiIiIi94ZomIiCgI8cyS/7CzREREFISUMkH52NnxdflgwctwRERERF7wzBIRBYynt15rmNbMGmaYVmgyVnQOFUaND5dGkjcbp0Vq/nEtVev2DHRLYXExQC5Mcgihb92/eKWQtkMzpG0Xws3Ssp7h5sqwwyKs1zitRBl/tkqE+YqF6tq6FbylMLfErHGDQIjH58kpfeaqiRMmn4tS+rp8sGBniYiIKAgxs+Q/vAxHRERE5AXPLBEREQUhBrz9h50lIgoYUu5IyslI+Zcip9U4n9CeBTbjNLOxSGGoUEhSKjjpmUfSLXCpm2OSiEUkhXiNNE03xyQdd+mSjZht0swEie+tkE+yCzkmaZou6XMmrVfK83geg1CPApdKKHhZXXgZzn/YWSIiIgpCPLPkP8wsEREREXnBM0tERERBSPnhMhzPLJ3GzhIREVEQUtAej9lrG8TOEhEFEClkKxUfLDIZC1VKoYNwGItXRgrTilXVCwmGevxhbodewFcKi0ukQpUOn4LbxvmKNcPSUnFIiRTAl0Lf4jTt0LfuNP/+DHqGw8PMpW7PTULRU6r72FkiIiIKQk6YYGIFb79gZ4mIiCgI8W44/+HdcERERERe8MwSEQUMs1DQr1gZM0uhzlLDNKtU0FLIxESZSoQVS1tTteyJNPiqRShwKWWRJL6UOJTySdqD5grz6WaRpEs7UhZJem+ljJo4TVhWLCypXSBTs5ioyf19i7C4f57MFmMmrro4lQkmFqX0C3aWiIiIgpBSfrgbjrfDAeBlOCIiIiKveGaJiIgoCDHg7T/sLBEREQUhdpb8J2A6S7NmzcJnn32G3NxcWK1WHDt2zO31hQsXYsSIEeKyBw4cQGJiovha8+bNsWvXLrdpGRkZmDJlil+2m4j856TDWGzSIgWmhdizU0gdmIX5wk3GAK4U7nUK83mGe08v676OUHF7pWlSCLrqoW+nZqFKaVtChWC9NM0qFO90iOF1vTC3FMovhnE+iRTcFo+zsA6REA73LEApTYuxFLs9Lw413nxQXRjw9p+A6SyVlJRg8ODBSElJweuvv254/dZbb0Xfvn3dpg0fPhzFxcXldpTKzJgxA6NGjXI9j4mJ8c9GExERUcALmM7S448/DuD0GSRJREQEIiIiXM8PHTqE7OxssWPlKSYmBsnJyX7ZTiIiorqAd8P5T9DeDffmm28iMjISN998c4Xzzp49Gw0aNEDnzp0xZ84clJbW3GlSIiKi6nC6s2Ty8VHbe1E3BMyZpcp6/fXXcfvtt7udbZLcf//9uPjii1G/fn2sWbMG6enp2L9/P+bNm1fuMjabDTabzfW8sLDQb9tNREREdUutdpamTJmCp556yus827ZtQ5s2bSrVbk5ODrZt24a33nqrwnknTJjg+nfHjh1htVpx9913IyMjA2FhwsjlOB0AL7ssSEQ1xyKEiuUq1EIlaafxRLrVZDyLfNwZrrVecfuEP8OdHuuIlEadF5bTDXNbhPytbrVpX0ghepiEixXSbkjhcKEi+klhWYsYote7SCJVgJeI+6bJcx2RZvcK3hZLzV254N1w/lOrnaWJEydi+PDhXudp2bJlpdt97bXX0KlTJ3Tp0qXSy3bt2hWlpaXYuXMnWrduLc6Tnp7u1skqLCxEkyZNKr0uIiKi6qIg91Ur2wbVcmcpISEBCQkJfm3zxIkTeP/995GRkVGl5XNzc2E2m73eQRcWFlbuWSciIiIKLgGTWdq9ezeOHDmC3bt3w+FwIDc3FwDQqlUrREdHu+Z77733UFpaijvvvNPQxvr16zF06FB8/fXXOPfcc5GTk4N169ahV69eiImJQU5ODsaPH48777wT9erVq6ldIyIi8jtehvOfgOksPfbYY1i0aJHreefOnQEAK1euRM+ePV3TX3/9ddx0002Ij483tHHy5Enk5eXBbj9dTC4sLAzvvvsupk+fDpvNhhYtWmD8+PFul9iIqO6QskhmZcyXSMUHpQKUUsG9YrPVMO24UNHRIeVzBGbLKY+VGucJF4obmjV/o2xCe3KOSyjKKeR/JFKGRzcnpEsuEFpimCYVubTAmDOTSPshHQOpMKkTxmklyvgT6pmD88wsWaXMWnXhdTi/CZjO0sKFC8utsXSmNWvWlPtaz549oc4IUl588cVYu3atPzaPiIiobvHDmSXwzBKAIK6zREREROQPAXNmiYiIiPSxgrf/sLNEREQUhBjw9h92loio1o3YMMIwrYH1pGFahNmYHLA7jf+NWcxSwFsIPcMYGD/pNAa8xWCwWa9wYbHTIxgshB9CpQC1VJBRSNuWCA1KwfUSYV8tQjheIoW5pXWECkF1qVClWTM1bBZOa0hFKaWioaFCwVHdQLu4LcI2S0VNPedzeBynqpe7pNrEzhIREVEwUibfA9o8swSAnSUiIqKgxMyS//BuOCIiIiIveGaJiIgoGLEopd/wzBIR1bpSp8XwsDlCjA+n8eGEyfBwCA+nMhseuhwwGx52ZTE8nDBX+JDbN26vpARmw8OujI8SWAwPaT5pH6R9dSqT4SGR2pPotieRjmqYyW54hJuFh0nvEWoqNTwsJqfh4VBmw8Owr5qfgepQdjecrw9dGRkZuPTSSxETE4PExETccMMNyMvLc5vn999/x4033oiEhATExsbilltuwYEDB9zm+fHHH3HNNdcgPj4eDRo0wOjRo3HixAm/HJOqYmeJiIiIfPbtt98iLS0Na9euRVZWFux2O1JTU1FUVAQAKCoqQmpqKkwmE7Kzs7F69WqUlJRgwIABcDpP3ye4b98+9O7dG61atcK6devwxRdfYMuWLRg+fHgt7hkvwxEREQWvGryM9sUXX7g9X7hwIRITE7Fx40ZcccUVWL16NXbu3IlNmzYhNjYWALBo0SLUq1cP2dnZ6N27N5YvX47Q0FC8+OKLMP+vVMjLL7+Mjh07YseOHWjVqlXN7dAZeGaJiIgoCPnzMlxhYaHbw2azVbj+goICAED9+vUBADabDSaTCWFhYa55wsPDYTab8f3337vmsVqtro4SAERERACAa57awM4SEdVJZpNTeCjDQ8qNSPkkKRdkgTI8pPYcymR8CNkeeT7P7JRu/kfOI3k+fMkYydku40OaTzdnJbUnvY8SKSckPawmh+Eh5ZikLJL0ED+PQvpI2hbP/JxujqtaKD89ADRp0gRxcXGuR0ZGhtdVO51OPPDAA+jRowcuvPBCAEC3bt0QFRWFyZMn4+TJkygqKsKkSZPgcDiwf/9+AMBVV12F/Px8zJkzByUlJTh69CimTJkCAK55agM7S0REROTVnj17UFBQ4Hqkp6d7nT8tLQ2bN2/Gu+++65qWkJCApUuX4tNPP0V0dDTi4uJw7NgxXHzxxa4zSe3bt8eiRYvwz3/+E5GRkUhOTkaLFi2QlJTkdrappjGzREREFJRM/3v42gYQGxvryhlV5L777sPy5cuxatUqNG7c2O211NRU/P777zh8+DBCQkIQHx+P5ORktGzZ0jXP7bffjttvvx0HDhxAVFQUTCYT5s2b5zZPTWNniYiIKBjVcJ0lpRTGjh2LZcuW4ZtvvkGLFi3Knbdhw4YAgOzsbBw8eBADBw40zJOUlAQAeOONNxAeHo5rrrmmctvuR+wsERERkc/S0tKwZMkSfPzxx4iJiUF+fj4AIC4uzhXSzszMRNu2bZGQkICcnByMGzcO48ePR+vWrV3tvPDCC+jevTuio6ORlZWFBx98ELNnz0Z8fHxt7BYAdpaIqA44URpmmBYVYrzbJtQsjS5vHOneLI5CX/X5JFJRS52Cg1IQWgpgS/M5hPbtwnZIxREtwr7q8qU9aT/MwukKi/Y06T0zhrKl91Z6z6RjKq2jRAhm6xwXz3mkZapNDZ9Zmj9/PgCgZ8+ebtMzMzNddZLy8vKQnp6OI0eOoHnz5pg6dSrGjx/vNv/69esxbdo0nDhxAm3atMGCBQswZMgQr+suLCzU3k7dy4lnYmeJiIgoGCnT6YevbejOqjHq7uzZszF79myv87z55pva6ywTHx8Pk0lvWx0OvT+IzsTOEhEREQW0lStXuv69c+dOTJkyBcOHD0dKSgoAICcnB4sWLaqw5EF52FkiIiIKQkqdfvjaRiC48sorXf+eMWMG5s2bh7///e+uaQMHDkSHDh3wyiuvYNiwYZVun50lIqp1VrPxtHiokDkJEfJEUnZGyrpIpAyLVDRQWodDWIdDuGRRrEIr3LZize0Vc0yaGRi70vvv3i5Mk/I6YnYIxvdHznEZM0bSfujmtqRplRko2ZO0vxLxc+GZUYL359WqhjNLdUVOTg5efvllw/RLLrkEd911V5XaZFFKIiIiChpNmjTBq6++apj+2muvoUmTJlVqk2eWiIiIglENB7zrimeeeQaDBg3Cf/7zH3Tt2hXA6TvsfvvtN3z44YdVapNnloiIiIKQSfnnEWiuu+46/PrrrxgwYACOHDmCI0eOYMCAAfj1119x3XXXValNnlkiIiIKRmdpZgk4fSnuySef9Ft77CwRUa0LtxhjxRGWEuN8ZuN8kWbjfL4UoBSXFcLMEovwZ7hnEFoKLUuBYikYLc+nWVvGhwsJYohc+BHVLVQZrhlU9wzHA3qFP8sjhsM1LzNJ663RApNUKd999x0WLFiA//73v1i6dCnOPfdcvPXWW2jRogUuv/zySrfHd5qIiCgYlWWWfH0EmA8//BB9+vRBREQEfvzxR9hsp0cDKCgoqPLZJnaWiIiIgpHy0yPAPPHEE3j55Zfx6quvIjT0/89O9ujRAz/++GOV2mRniYiIiIJGXl4errjiCsP0uLg4HDt2rEptsrNEREQUjM7SM0vJycnYsWOHYfr333+Pli1bVqlNBryJqEYNXjPGMK1BmDGkHSkEvHXD3NIo9BKrMJ9uSFkij1av8d+sEAuRKokXK6thmm5AWTfgLe2DboVsKUQvtSdtihSWlo6B7rbo7q9uYFw3zO25XqfH++P5vFqdpXfDjRo1CuPGjcMbb7wBk8mEffv2IScnB5MmTcKjjz5apTbZWSIiIqKgMWXKFDidTlx99dU4efIkrrjiCoSFhWHSpEkYO3ZsldpkZ4mIiCgYnYUVvB0OB1avXo20tDQ8+OCD2LFjB06cOIF27dohOjq6yu1WKbP0j3/8A8ePHzdMLyoqwj/+8Y8qbwwRERH5x9lYwdtisSA1NRVHjx6F1WpFu3btcNlll/nUUQKqeGZp0aJFmD17NmJiYtymnzp1Cm+++SbeeOMNnzaKiIKX1WLMCUUIRSl9ySdJ80l0i1KKuRuBmNkxeRal1CvwKGWdpKKUxU5j4Uad4pjlsQs/C9qFG4UiklJBT+08kWYWSXffdPdDImXZpEyVYVtM7ttrDrTeRwC68MIL8d///hctWrTwW5uVOrNUWFiIgoICKKVw/PhxFBYWuh5Hjx7F559/jsTERL9tXJmdO3di5MiRaNGiBSIiInDeeedh2rRpKClx/8/0559/xt/+9jeEh4ejSZMmePrppytse/fu3ejXrx8iIyORmJiIBx98EKWleuFQIiKiOussvRvuiSeewKRJk7B8+XLs37/fra9SWFhYpTYrdWYpPj4eJpMJJpMJF1xwgeF1k8mExx9/vEob4s327dvhdDqxYMECtGrVCps3b8aoUaNQVFSEuXPnAjjdkUtNTUXv3r3x8ssv45dffsE//vEPxMfHY/To0WK7DocD/fr1Q3JyMtasWYP9+/dj6NChCA0N9euYMkRERFQzygbLHThwIEym/z+bqJSCyWSCw6F35vlMleosrVy5EkopXHXVVfjwww9Rv35912tWqxXNmjXDOeecU+mNqEjfvn3Rt29f1/OWLVsiLy8P8+fPd3WWFi9ejJKSErzxxhuwWq1o3749cnNzMW/evHI7SytWrMDWrVvx1VdfISkpCZ06dcLMmTMxefJkTJ8+HVar8TZdIiKiQGCC75mjwIp3n7Zy5Uq/t1mpztKVV14JAPjjjz/QpEkTmM21V9OyoKDArbOWk5ODK664wq2D06dPHzz11FM4evQo6tWrZ2gjJycHHTp0QFJSktsyY8aMwZYtW9C5c2dx3TabzTXWDIAqn9YjIiIi/yrrq/hTlQLezZo1AwCcPHkSu3fvNmSHOnbs6PuWebFjxw48//zzrrNKAJCfn28Ic5V1gvLz88XOUn5+vltHyXOZ8mRkZFTL5UaiYHPtqnGGackRxkxgmNk4TQpLS9N8oT1qvOaf11J7RR6brB20FgLexUKAWgoZm5UQ8NY8drrFIaX2zELARQxkC9unSwppO2DcPolUgFL3MyDtr3QzgOexqt2ilGdf6YAyR48exeuvv45t27YBANq1a4cRI0a4nWSpjCqdGjp06BD69++PmJgYtG/fHp07d3Z76JoyZYorA1XeY/v27W7L7N27F3379sXgwYMxatSoqmy+z9LT01FQUOB67Nmzp1a2g4iIqFxnacB71apVaN68OZ577jkcPXoUR48exXPPPYcWLVpg1apVVWqzSmeWHnjgARw7dgzr1q1Dz549sWzZMhw4cABPPPEE/vnPf2q3M3HiRAwfPtzrPGeO47Jv3z706tUL3bt3xyuvvOI2X3JyMg4cOOA2rex5cnKy2HZycjLWr19fqWUAICwsDGFhYV63m4iIiGpeWloabr31VsyfPx8Wy+kzfQ6HA/feey/S0tLwyy+/VLrNKnWWsrOz8fHHH+OSSy6B2WxGs2bNcM011yA2NhYZGRno16+fVjsJCQlISEjQmnfv3r3o1asXunTpgszMTENeKiUlBVOnToXdbkdo6OlT1VlZWWjdurV4Ca5smVmzZuHgwYOukgdZWVmIjY1Fu3bttLaLiIioTjpLx4bbsWMHPvjgA1dHCThdrHLChAl48803q9RmlS7DFRUVuToX9erVw6FDhwAAHTp0wI8//lilDfFm79696NmzJ5o2bYq5c+fi0KFDyM/Pd8sV3X777bBarRg5ciS2bNmC9957D88++ywmTJjgmmfZsmVo06aN63lqairatWuHIUOG4KeffsKXX36JRx55BGlpaTxzREREAe1srOANABdffLErq3Smbdu24aKLLqpSm1U6s9S6dWvk5eWhefPmuOiii7BgwQI0b94cL7/8Mho1alSlDfEmKysLO3bswI4dO9C4cWO319T/goJxcXFYsWIF0tLS0KVLFzRs2BCPPfaYW9mAgoIC5OXluZ5bLBYsX74cY8aMQUpKCqKiojBs2DDMmDHD7/tAdDaSwqxSte5ws3GabhVuKUBc1RHiAcCihErNJmOAWFqH1J7Vo8K47nI2oTK3FLSWSMfOl3C8VElbIq1DfB99yOk7NdP22uF9gRTmdgrHXqqybtgOj/dWCpmTf91///0YN24cduzYgW7dugEA1q5dixdffBGzZ8/Gzz//7JpX94Y0k1KVvy3h7bffRmlpKYYPH46NGzeib9+++Ouvv2C1WrFo0SLceuutlW0yoBUWFiIuLg4FBQWIjY2t7c0hqjP6fPuAYdp5MYcN0xKtxrEm64UUVccmudEd2kT68WRnyUi3sxRuMnaOtbelljpLEp3Okud7VnyiFFMu/bZafy/KfpOaPzEL5vBwn9pyFhdj5yNTA+r3raKyRiaTqdIFKqt0ZunOO+90/btLly7YtWsXtm/fjqZNm6Jhw4ZVaZKIiIj86SzNLP3xxx9+b1O7s3Rm9qci8+bNq9LGEBEREfmirBZkRfr164fXXntNKz6k3VnatGmT1nxnjsNCRGeP9h9PN0xr1cBYbFI3i6RL9xKRQ7h8I11ys8N4+Uv3r2tpW07CWuE80rbZncb/nqVLUNLlJikDJl0ik7ZFms+ieQDMwvZJ67CYNQtkCpcna6Koo7Reic62eF6Gs/tQkLOy/BHQDsSAt65Vq1bh1KlTWvNqd5aqY6wVIiIiqiZncQVvf6tSZomIiIjquLM0s1QdeA8jERERkRc8s0RERBSEmFnyH3aWiKjSmr801zAtPFm3Fo/xf19ptHrdILhUsUcKFUvT7Jr/BUoB7KoGy6XlioWaSlJ4WDd4rFv0UaonJMTbAc26Qw6pDpTwPkr1oqTPhTSfbihddz6JGXrbrPMZ8AzH64bl/YKX4fyGl+GIiIjorPPwww+jfv36WvOys0RERBSM/DEuXACeWVq0aBE+++wz1/OHHnoI8fHx6N69O3bt2uWanp6ejvj4eK022VkiIiIKRspPjwDz5JNPIiIiAgCQk5ODF198EU8//TQaNmyI8ePHV6lNZpaIyKs2054xTkwyTgoNMeY8QoTig1IWRyq2qDsOmjSGmpRN0W1Pdz7dscdsHsUlpdxRqe62OfXWWWoWMkE+jF4baSmp8rI2KQUl7K5FKNYovRdy3klz34Qffqn4p+7YcDpZKc95imuwKOXZas+ePWjVqhUA4N///jcGDRqE0aNHo0ePHujZs2eV2uSZJSIiomB0lp5Zio6Oxl9//QUAWLFiBa655hoAQHh4uHbFbk88s0RERBSEztbSAddccw3uuusudO7cGb/++iuuu+46AMCWLVu0x43zxDNLREREFDQefPBBdO3aFYcOHcKHH36IBg0aAAA2btyIO+64o0pt8swSERERBY0uXbpg//79SExMdJs+duxYJCUl4eGHH650m+wsEZFXuqfhpeB2qRBIFotDOo2hXSm4LZECvw5hWc+gNSAXQpT2QyxIKJyYlwLYOoUL5aKXegOYSu3bnMbgsW6IPEQoInnCEWaYpltcMcQsFHgU3u9QYT6JbrBeIgW3pW3RJX1+PIupaofPq8NZWpRSKQWTyfj9KSoqQnh4eJXaZGeJiIgoCJ1tmaUJEyYAAEwmEx599FFERka6XnM4HFi3bh06depUpbbZWSIiIqKAt2nTJgCnzyz98ssvsFqtrtesVisuuugiTJo0qUpts7NEREQUrALozJCvVq5cCQAYMWIEnn32WcTGxvqtbXaWiIiIgtFZmlnKzMz0e5vsLBGRy4UPGat1l9YTZgwx/g9qEap1SxW87VIgWRkD2XalVzVarPIshHalytlQxu0Tt0UzuC0FtUs9tkWqVu4QwtwWISwizacTIAfkoHGxQ6p+blxviLCsTvVqQA5uSxXGI3yoEi6R9kMM6msG6SVhptIqL0uBhZ0lIiKiIHS2BbyrEztLREREwegsvQxXHVjBm4iIiMgLnlkiIpfNT483TGs1Z55hmrIY/9w0m43TpKKUUnFEKRNULBSW1C0qKOWTpPVK+SHdfJJU5FJur+Kih6W6uSPhz3xpWSljVKr0/rv3zFgBgFMo8AfoFXOUtk/KXklZtlDNgo5S4Utfzoh4FpYE5AyUDs/inVUvgVl5vAznP+wsERERBSNehvMbXoYjIiIi8oKdJSIiomCk/PTQlJGRgUsvvRQxMTFITEzEDTfcgLy8PLd5fv/9d9x4441ISEhAbGwsbrnlFhw4cMBtnl9//RXXX389GjZsiNjYWFx++eWugpO1hZ0lIiKiIFSWWfL1oevbb79FWloa1q5di6ysLNjtdqSmpqKoqAjA6YFsU1NTYTKZkJ2djdWrV6OkpAQDBgyA84zBn/v374/S0lJkZ2dj48aNuOiii9C/f3/k5+f7+xBpY2aJiFzaPG4sSukURgwwhRqDt1aL3qjxUuDZaTb+3SYVEBTb051PCG6bheCyFNyWiAFvIbjsGXCWwuK+FEaUOE16fwdrB8ulYphCmF3aDykYrbu/pcKyUshdIhXNDBWKpEphc2mbLRDaE4Lgnjw/n3ahEGq1qeHM0hdffOH2fOHChUhMTMTGjRtxxRVXYPXq1di5cyc2bdrkGopk0aJFqFevHrKzs9G7d28cPnwYv/32G15//XV07NgRADB79my89NJL2Lx5M5KTk33coarhmSUiIiLyqrCw0O1hs9kqXKagoAAAUL9+fQCAzWaDyWRCWFiYa57w8HCYzWZ8//33AIAGDRqgdevWePPNN1FUVITS0lIsWLAAiYmJ6NKlSzXsmR52loiIiIKRHzNLTZo0QVxcnOuRkZHhddVOpxMPPPAAevTogQsvvBAA0K1bN0RFRWHy5Mk4efIkioqKMGnSJDgcDuzfvx8AYDKZ8NVXX2HTpk2IiYlBeHg45s2bhy+++AL16kljL9UMdpaIiIiCkD8zS3v27EFBQYHrkZ6e7nXdaWlp2Lx5M959913XtISEBCxduhSffvopoqOjERcXh2PHjuHiiy+G+X+X4pVSSEtLQ2JiIr777jusX78eN9xwAwYMGODqUNUGZpaIiIjIq9jYWFfOqCL33Xcfli9fjlWrVqFx48Zur6WmpuL333/H4cOHERISgvj4eCQnJ6Nly5YAgOzsbCxfvhxHjx51re+ll15CVlYWFi1ahClTpvh3xzQFRGdp586dmDlzJrKzs5Gfn49zzjkHd955J6ZOnQqr1QoA+Oabb/DMM89g/fr1KCwsxPnnn48HH3wQd9xxh9e2TULA85133sFtt91WLftCVBsufNAY3LbHGOcrjRFGuo8xhlitEcbR1kOFgLdcwds47YTDalyvECD2rIYMyEFeX0jh3hIhzC3thxRc9lxWmkc38CzNFyKElnVD0LqBbN19FZeVgvVCHesTQvDfajF+zqxm4zSnUO09RAhfOzXD1br7Jt1c4Bn69lzOVoP57poOeCulMHbsWCxbtgzffPMNWrRoUe68DRs2BHC6c3Tw4EEMHDgQAHDy5EkAcJ1pKmM2m93umKtpAdFZ2r59O5xOJxYsWIBWrVph8+bNGDVqFIqKijB37lwAwJo1a9CxY0dMnjwZSUlJWL58OYYOHYq4uDj079/fa/uZmZno27ev63l8fHx17g4REVG1q+nhTtLS0rBkyRJ8/PHHiImJcd3qHxcXh4iICACnf2/btm2LhIQE5OTkYNy4cRg/fjxat24NAEhJSUG9evUwbNgwPPbYY4iIiMCrr76KP/74A/369fNtZ3wQEJ2lvn37unVmWrZsiby8PMyfP9/VWXr44Yfdlhk3bhxWrFiBjz76qMLOUtlpQCIiIqqa+fPnAwB69uzpNj0zMxPDhw8HAOTl5SE9PR1HjhxB8+bNMXXqVIwf//9jUjZs2BBffPEFpk6diquuugp2ux3t27fHxx9/jIsuuqimdsUgIDpLkoKCAtftiN7madu2bYVtpaWl4a677kLLli1xzz33YMSIEeLluTI2m83ttsnCwkL9DSciIqoJtXAZriKzZ8/G7Nmzvc5zySWX4Msvv9RfcQ0IyM7Sjh078Pzzz7vOKknef/99bNiwAQsWLPDa1owZM3DVVVchMjISK1aswL333osTJ07g/vvvL3eZjIwMPP7441XefqLq1O4RobBkpHE+e6xQLDBOyCJFlRimhYfZDdMsQnZGIo1qL2VsSoTz/1IOBUKeRi4qKP1HbtxmafvEQppi9qjiG4ylDI9uRka3PWlZ3eKQYmFNzXXoZq9KhOMpZa90PytOaX/NQsZI2BbpPZNycNJ8YUJ+ChaP74vHZticNTgyLQfS9ZtaLR0wZcoUmEwmr4/t27e7LbN371707dsXgwcPxqhRo8R2V65ciREjRuDVV19F+/btvW7Do48+ih49eqBz586YPHkyHnroIcyZM8frMunp6W63UO7Zs6dyO05EREQBo1bPLE2cONF1HbM8ZbcTAsC+ffvQq1cvdO/eHa+88oo4/7fffosBAwbgmWeewdChQyu9TV27dsXMmTNhs9ncqoyeKSwsrNzXiIiI6gLT/x6+tkG13FlKSEhAQkKC1rx79+5Fr1690KVLF2RmZhpuKwROlw/o378/nnrqKYwePbpK25Sbm4t69eqxM0RERIGNl+H8JiAyS3v37kXPnj3RrFkzzJ07F4cOHXK9VnYX28qVK9G/f3+MGzcOgwYNct2yaLVaXUHwZcuWIT093XVp79NPP8WBAwfQrVs3hIeHIysrC08++SQmTZpUw3tIRETkXzVdOiCYBURnKSsrCzt27MCOHTsM1UDL0veLFi3CyZMnkZGR4TZmzZVXXolvvvkGwOm74/Ly8lyvhYaG4sUXX8T48eOhlEKrVq0wb968crNQRIGgRCiy67QKodj6xuB2ZGyxYVqEEOaWRm8PNQtFAIWT+FK4VyIVQpRCxVKRQovmfA6hqKBdswCjTphbohuMlvZfm+YPnG4gWyIFrUPEYLTeOsQQuRDSlo5LiBDUtwmFRHWD2xLpc2szG9fh+fnxDIHXaMCb/MakdO71I68KCwsRFxeHgoIC7XLwRNWl1dPC3XA10FmKshpHIbcKVb3DxarMxvmkHzZ/d5YkpxzGatDSXVlSVW+J54+7WNVcukOuBtIiPnWWxLsV9TpLunfrSZ+LEGma5mfF350lafsiPO6GM3SWTtix4IoPq/X3ouw3qf3dT8ISFu5TWw5bMbYsePis/30LiDNLREREVAU8HeIXtVo6gIiIiKiu45klIj9p9ZTx8pdEhXr8qSf85SddNpOuykhjyKoIYVqM8RKUdMktKsx4aS7EIuSThMtr4mUPYeekS04yoXCh5mUeaT5d0uU1Xwa/9dxf3cGF/T24ri/7oF3Q0svIB27tSQMiC4kQsTCn8NY6TXqFJaXPlG5RSulSrPQ5O+UxKLTnPpRqDubrDwx4+w87S0RERMGIpQP8hpfhiIiIiLzgmSUiIqIgxMtw/sPOEhERUTDiZTi/YWeJqALNXzUOrGyyGa9gq2hhYaGoHizu06QyLyarEKAOEUK7pcaFLVbjfNHRpwzT6keeNEyLDDHWVJJqJUl0A94SqaaQFIQuFsLXVmFZp2bAW3ebdWse6eyHVK/H7hCCx9J+CaFqJUyzCAFvX/bLolnHSCKFzcWAt2Z70nxiAVMfakhJCRW5wKrwefSoq1RU6j50VkkpR1sLROwsERERBSFehvMfdpaIiIiCES/D+Q07S0RERMGInSW/YekAIiIiIi94ZomCTqv3nzBMk0KwEMOyxtkssUIwVghWwyEEbYWwdajVPQBqFgKw0vZKI7CHCOFrKZAdFmqs4B0daqzWHR1qHAxXt3qzRFq2WBioVmpPt9K37mj1UkA3xGQ8VqVKquCtty1iVWuP9Urba3MY1+nQ3H/pM2syGQPjUuhbl9OsNxiuFATXrTBuFd4LaVkpIC/yJUeteTZF5/32nMdRg+comFnyH3aWiIiIghEvw/kNL8MRERERecEzS0REREHIpBRM0nXaSrZB7CxRELIIxRul+ILFYpxPygCFCPNJeRKn07iWSKuxyGOER1ZId4R4iZRPCrcY80lSviTcYtw2iTSyeqnmSWnd/ZByPFKhQWm+EGEUd50sSXl0t1mX5zY7hP06ZRdyXMLnSczeCUxSsU0hx6WbOxJza+KahWKtmj+20nsrfZal91G3+Kn0XZPo5vSk9koryFRV9Lpf8TKc3/AyHBEREZEXPLNEREQUhHg3nP+ws0RERBSMeBnOb3gZjoiIiMgLnlmianPBBzMN06SA6m+DH9Fr70Nje1KhPYsQZLWGGoPQEaHGgHN4iHGaFPaUAt5hIcYwaqRme4Z5hD/ndIvxSe1LIW1d4ojumiPY+zKSvBjS1ixeKbVndgrrEIotSiPJS0ocxvdDOlaeBSeLhTC3w2FcziEEvJ2ahSqlmxekoLVTOu7CMRHqRcrrFb6PcjhcL6RdLPxEie+t7ufHh3C49N5alVBI0+y9KKXdUfXvYmXxMpz/sLNEREQUjHgZzm/YWSIiIgpCPLPkP8wsEREREXnBM0vkF22XPW6YZhEiNlLWR8oiScQsjpDNkPIa9SJOGqZJA8lKRfAkIWaheKVmMT8dvhRVtJqFQn5C3qJEGLxVzCf5kCeS6BagtGtmgqTjbnxn9bdZyoZJ2ywWJhXeI8+Mkph1EjNLQoFHIcckkT510vsoFa+0CNkm6XhK+SSHsG8Wzc+P1J50XHwhHYNQ4bus+72VPiue+3ay1P39L5UOZnXhZTi/YWeJiIgoSPEymn/wMhwRERGRFzyzREREFIyUOv3wtQ1iZ4mIiCgY8W44/2FniSrt4s+NRSStoXoF9HRHTZeYhQCoNdQYZg4XikPqhrnDLcYikmGaoW+JTsE7KRTsWciwMqSiimKoWjNo7UuYWyItK30upG0RQ88mvTC87jbbSvWC79I2S9vneZzlApTCcXfoHSeJkrbXohfwFotXSvtqMq5Das8hFIk1C/tr8aFwqm6xSeGjAofFv2kUz2Ngs7t/nhw1GfAmv2FniYiIKBjxbji/YWeJiIgoCJmcpx++tkG8G46IiIjIK55ZIiIiCka8DOc3AdFZ2rlzJ2bOnIns7Gzk5+fjnHPOwZ133ompU6fCarW65mnRooVh2ZycHHTr1q3ctnfv3o0xY8Zg5cqViI6OxrBhw5CRkYGQkIA4NH51xdcPGqaVCGFXixSoNRkr2UqBbLMwornuSOpSOFMKcUoVeXXD3BHCNKlat0VYr10I1Uo8q2k7NMPNYrVpoWKypFgIjEsh8lKhPV8qc0uBX91R3nUrlkvtWcx670VxqRBIFvZDqujsEKppS9vsWYVaWk6qzO2UqldLh044TEqYKAW3xYC3EMh2SstKm6J565Q0n/T9lvhyJ7tF2DebWe87JIXrpREEPL8vTo/31lFq/P+kuvBuOP8JiB7B9u3b4XQ6sWDBArRq1QqbN2/GqFGjUFRUhLlz57rN+9VXX6F9+/au5w0aNCi3XYfDgX79+iE5ORlr1qzB/v37MXToUISGhuLJJ5+stv0hIiKqdqyz5DcB0Vnq27cv+vbt63resmVL5OXlYf78+YbOUoMGDZCcnKzV7ooVK7B161Z89dVXSEpKQqdOnTBz5kxMnjwZ06dPd521IiIiorNXwAa8CwoKUL9+fcP0gQMHIjExEZdffjk++eQTr23k5OSgQ4cOSEpKck3r06cPCgsLsWXLlnKXs9lsKCwsdHsQERHVJWWX4Xx9UICcWfK0Y8cOPP/8825nlaKjo/HPf/4TPXr0gNlsxocffogbbrgB//73vzFw4ECxnfz8fLeOEgDX8/z8/HLXn5GRgccff9wPe1J7rl01zjAtKlSYUSCNBi9xSLkbITMAGK/7y/kA47V+a4iQJ5JGL9fME4m5I+HW2VPCfNLo6nZhVHJP8ij3xmlSPkkc5V7ImRWXGt9cqfiilKexlwrr1cyZSbk1MXsmjQYvvLdi0UOpeKUQC9HNT+nmwHQLRHoeP7EApXDcpXySlG2SwkNiFklcVig2KVx2kQpGyldn9LZPm3QMxKKmes2ZhcKcvmxLiPAZrehz4SitwXMUDHj7Ta2eWZoyZQpMJpPXx/bt292W2bt3L/r27YvBgwdj1KhRrukNGzbEhAkT0LVrV1x66aWYPXs27rzzTsyZM8fv252eno6CggLXY8+ePX5fBxEREdUNtXpmaeLEiRg+fLjXeVq2bOn69759+9CrVy90794dr7zySoXtd+3aFVlZWeW+npycjPXr17tNO3DggOu18oSFhSEsLKzC9RMREdUW3g3nP7XaWUpISEBCQoLWvHv37kWvXr3QpUsXZGZmwqxxa3Bubi4aNWpU7uspKSmYNWsWDh48iMTERABAVlYWYmNj0a5dO72dICIiqot4N5zfBERmae/evejZsyeaNWuGuXPn4tChQ67Xys4ALVq0CFarFZ07dwYAfPTRR3jjjTfw2muvueZdtmwZ0tPTXZf2UlNT0a5dOwwZMgRPP/008vPz8cgjjyAtLY1njoiIiAhAgHSWsrKysGPHDuzYsQONGzd2e+3MQmszZ87Erl27EBISgjZt2uC9997DzTff7Hq9oKAAeXl5rucWiwXLly/HmDFjkJKSgqioKAwbNgwzZsyo/p2qg6SiguIo70KAUQrtWoRktNMiLStNM/41ExFqLCxpFYpNWoUguBQgLnYIiXZhmu4I9tLx0ynoGCIF0oW2pMKSUvtSqFwKLUvBbc8CigBgtwsBb2E+saigWHxQryBhibB90vsokT6jUthcIn3mfeEZrJbD3HqFKnXaB1BOxUhpml6VS4fSDb0LrUm7q3myQvcY6BbrdDr8G/B2CN8Ds3gTyxnbIHyuqwsvw/mPSUllXalSCgsLERcXh4KCAsTGxtb25miR7oaTfqBP2o21psS7eTTvUJF+yKUfD93OUkRoiWFaeIhxvsgQY2VuXypJB1pn6ZTd2AkssUsVvOtOZ8ksVEcO1s6Skj47pZqdJfGPF6nXIkzSrbiteUjqemfJVEFHprLrMAl311XYWTpZjP8On1Wtvxdlv0kpfWcgJDTcp7ZK7cXI+eKxgPp9qw4BW2eJiIiIqCYExGU4IiIiqhxehvMfnlkiIiIKRk7ln4emjIwMXHrppYiJiUFiYiJuuOEGt5wwAPz++++48cYbkZCQgNjYWNxyyy2ukj0A8M0335Rbd3HDhg1+OzSVxTNLQUY3i2QVrqtLeRAp06CbT9Kt1CzFeqTRvKXK3FJ70vZJVa3FEeKFYyVNk+hWdPYUKgTSpX2QsjRSPkmqsC5mkYSgqb1EqOpdIu2/tK+awRFhPin7YdIoD1IeKZtiEoI3UlZIbk+vErn0PTB8LsQwt8ZylaAb+lbCRLn6t7ASqT0pfyi8F8qhu2+a8+lun2aWS44zCjMKgXF5lIIzXi+puYB3TVfw/vbbb5GWloZLL70UpaWlePjhh5GamoqtW7ciKioKRUVFSE1NxUUXXYTs7GwAwKOPPooBAwZg7dq1MJvN6N69O/bv3+/W7qOPPoqvv/4al1xyiY87U3XsLBEREZHPvvjiC7fnCxcuRGJiIjZu3IgrrrgCq1evxs6dO7Fp0yZXWHzRokWoV68esrOz0bt3b1itVrei0Ha7HR9//DHGjh0r3jldU3gZjoiIKAiZ4IeBdH1Yf0FBAQC4Br232WwwmUxudQzDw8NhNpvx/fffi2188skn+OuvvzBixAgftsR37CwREREFo7IK3r4+cLocwZkPm83mddVOpxMPPPAAevTogQsvvBAA0K1bN0RFRWHy5Mk4efIkioqKMGnSJDgcDsOltzKvv/46+vTpY6ixWNN4GS7ISNkcaVR2KdciZRVKxPaMf2uEipkOvYvdQp1KhAk1lUKEkc+lbI9UgPGUEuoMCftml3JBQrbHl1o8IR4ZpUirsQaUlFdxCHkQ6b0Vay9J+yDkmMR8kk3IWOjWv9H8DOgeTlOIEE7RLrYokHJBUtZO+J9St/aQ57Zo5ZrK2zZf6OZ6tNcr7YhecU3tzJLm50z4rwHCV8O3z4XUnJC1U56ZJbPn+197l5J80aRJE7fn06ZNw/Tp08udPy0tDZs3b3Y7Y5SQkIClS5dizJgxeO6552A2m/H3v/8dF198sTiE2Z9//okvv/wS77//vt/2o6rYWSIiIgpC/iwdsGfPHreilN6GBLvvvvuwfPlyrFq1ynBGKDU1Fb///jsOHz6MkJAQxMfHIzk5GS1btjS0k5mZiQYNGmDgwIG+7YQfsLNEREQUjPx4N1xsbGyFFbyVUhg7diyWLVuGb775Bi1atCh33oYNGwIAsrOzcfDgQUOHSCmFzMxMDB06FKGhwtBUNYydJSIiIvJZWloalixZgo8//hgxMTHIz88HAMTFxSEiIgLA6bNFbdu2RUJCAnJycjBu3DiMHz8erVu3dmsrOzsbf/zxB+66664a3w8JO0tERERByKQUTD4O/1qZ5efPnw8A6Nmzp9v0zMxMDB8+HACQl5eH9PR0HDlyBM2bN8fUqVMxfvx4Q1uvv/46unfvjjZt2lR52/2JnaUgIwV+pTCysQyiTApLS4UgpWC07kC1UukMaZuVMKNYQE+zKKU0kKwUhJYGPtUdbVwsyOcx6ZTuWKGa/2eVCu+ZOPixsA8iKWSr+wGSih5KhQs1W1MheoFs8aMnFQsUA95CocFQqXKq3sC8el8D6RjrFX/1idSe5jEpp+qjcS4pk+9LyFncZmEdYqDdhyKXmpti8hgA2VCTVLphoro4ob0vXtvQpDQ+oLNnz8bs2bMrnG/JkiX6K64BLB1ARERE5AXPLBEREQWhmr4MF8zYWSIiIgpGNTw2XDBjZymAtfv3dMO0iDCrYZqU4ZEKF4qD0koF5aRIg5AFMJv1gi1SkUuzlH0QCl9KdIsy2oTMkqNUGmxVOH7CfNLeSpklR4j7smI+S/P9kYiRDul91M2rCDtmLtXL2EixFjFLohuJ0R6AVVi2ggFO/3+9UhFFIXsm5Jh8rWnjRsp2+XUF+uuVRw0WlpWyQ9J75ufdkA6LL7Eo7dqVUq7Mo1ClZ1umkhosSnlGBW6f2iBmloiIiIi84ZklIiKiIOTPCt5nO3aWiIiIghEvw/kNL8MRERERecEzSwFMKj5YYhcCxZojd4eGGJO8UvhYYhHC106zFCo2TisViiMqi942S8UwpW3WDXM77cK2SMUbNf/YEtvzmOYQitRJo5mbpRHOpUCtlKcVQtVOm/D1twnFNqVpdiGAbjc2p1m3UOTTAPHSeoXPozhavXCcnVIxzBJpvcJ75FmUUPNPVDG0LC3rS15YN/Mu/R8iFoLUm0/6rOjWwhSPgbQtmvOJx0+3EKNQX9KzKKVhnSU1d47C5CznhopKtkHsLBEREQUnXobzG16GIyIiIvKCZ5aIiIiCEYtS+g07S0REREGIw534DztLAaykKNQwzRmul/Y0a1YzdmoGvEWlxklSwFsKoEvbJ4W5pXC4VK1bDHNL1bo1p+lWJZYqXRsOgRTcFqY5QoWkpXCcpKrh0j6gWC+4bbEJ748QbjYL77dEDGTrfsykEezF0eWF9WquQwqCm4X/KeVguVDtPcT9/VDGr62cZJbC0tKA9boBbx9+88SwvVRhXPgMSKFv3c+KtM3676PmOgTSZ0p8i0I1Av3Se0YBh50lIiKiYMSAt9+ws0RERBSMFPTLIHhrg9hZIiIiCkbMLPkPO0sBbOfQKYZpLZc8aZxRzDQY/9yQijlKo9VLlBA6cUjFHKUt0VyHFNiQM1BCPkkqfCkVjJTySUJRRt1CbVK2yZB9kIp3Srkj4ThJ2SbxL0GhEJ7llF4+yWIzNmcpFlbrS1FBzYyRyVg3Vfu90B6FXlivU/qfUrM9Z6j7jE6pIKNUhFU6dlL+RaqZ6ueB7cUMjzRNyOiJ8wnvo7he6Rjo7ptuQVTpcyt9pqTvlfC+GWNr7gvq7jvVLewsERERBSMFP2SW/LIlAY+dJSIiomDEgLffsII3ERERkRc8s0RERBSMnPBtoOWyNigwOks7d+7EzJkzkZ2djfz8fJxzzjm48847MXXqVFitVgDA9OnT8fjjjxuWjYyMRFFRUbltm4Qicu+88w5uu+02/+1ADXKWCAlQqeihEDxWUgFKIWFp0iygJxxacVkp4G23Gz+a4nqFdTiFfXNKYW5pm0uEAnpCoUazMJ9uKNQzuCyGWIW30SmEZ8VwqlDwzyJsr+WUcT6x2KQQSPYluK0bXNYP0eutQ7MOq7jNZiHkrl340mO90n45pUKV0nGSboaQtkMK/usSUtDaAW8pgK85TSIWw9TcNe3PozSbsG+64XDDe+mxoFjQtprwbjj/CYjO0vbt2+F0OrFgwQK0atUKmzdvxqhRo1BUVIS5c+cCACZNmoR77rnHbbmrr74al156aYXtZ2Zmom/fvq7n8fHxft1+IiIiClwB0Vnq27evW2emZcuWyMvLw/z5812dpejoaERHR7vm+emnn7B161a8/PLLFbYfHx+P5ORk/284ERFRbWHA228CNuBdUFCA+vXrl/v6a6+9hgsuuAB/+9vfKmwrLS0NDRs2xGWXXYY33ngDih8OIiIKdGWdJV8fFBhnljzt2LEDzz//vOuskqfi4mIsXrwYU6YYizZ6mjFjBq666ipERkZixYoVuPfee3HixAncf//95S5js9lgs/1/iKGwsLDyO0FEREQBoVY7S1OmTMFTTz3ldZ5t27ahTZs2rud79+5F3759MXjwYIwaNUpcZtmyZTh+/DiGDRtW4TY8+uijrn937twZRUVFmDNnjtfOUkZGhhgmrxOEILN0O4MUfnQKoUsp9K0btDZrhkylQLbuOkxCatcpVOGGUMFbqjZslqZpVrXWHUldaxRyIU0qVrQWgqhSSFuswi1ME0PVPlRClrZZnCaFgIVVSOSR7o3TpKC6yIdR7Z3Ce+s5n/iHum5oWXcEe+GmBN0K6xLdEL0vQXCR7vbpVjvXXIf0XZbeW53q34bjLt0sUF14Gc5varWzNHHiRAwfPtzrPC1btnT9e9++fejVqxe6d++OV155pdxlXnvtNfTv3x9JSUmV3qauXbti5syZsNlsCAsLE+dJT0/HhAkTXM8LCwvRpEmTSq+LiIio2rB0gN/UamcpISEBCQkJWvPu3bsXvXr1QpcuXZCZmQmzWf7z748//sDKlSvxySefVGmbcnNzUa9evXI7SgAQFhbm9XUiIqLaxtIB/hMQmaW9e/eiZ8+eaNasGebOnYtDhw65XvO8i+2NN95Ao0aNcO211xraWbZsGdLT07F9+3YAwKeffooDBw6gW7duCA8PR1ZWFp588klMmjSpeneIiIiIAkZAdJaysrKwY8cO7NixA40bN3Z77cw715xOJxYuXIjhw4fDYjFeYC4oKEBeXp7reWhoKF588UWMHz8eSim0atUK8+bNKzcLFRDEgmfCWbgQoVCl9BeENNK9FBCQskPSHyRSrkWz0J5EWlZJmaUSIbMk5DrEabrF94Scg26OyUDKgwjrlNoX80l2Y4O6uQyxQGaoUPhT838TMY6me6pfWNYiZLTkHIpwDDSzM1I+ySEcA6nwpSHDIq1A91KJDxke8Wur+fmUPtviMZZyj9rhM2GSD58L3e+QuCnSvunm+Tw+K05rxW1XG2aW/CYgOkvDhw+vMNsEAGazGXv27NFux7N+ExERUdBwKt97Z+JfvWefgK2zRERERFQTAuLMEhEREVUSL8P5DTtLREREQckfFbjZWQLYWQpoFzzxjGGaKV4IPOsWwTPppqqFdUgFKKVpejUzocxScrLiTQMAJRWWFILbYrHJU9KyxnVIoWJpZHopFKoTeJXal8KplhK94LZcLFAvgS99fsRlpaC+RDPIq1tEUToGYgBfDPzqFT91WvRudFDCRosBdMMKhM3wJbSseYx1j5NIswClFI6X/h8Q329fAt7Sx1Ez+K57TMVanR7zGdqvyaKU5DfsLBEREQUjXobzG3aWiIiIgpFTwefLaLwbDgDvhiMiIiLyimeWApnmNXmRVLxSzEgIRRo1r/uLWQUpx6S7zVJ7worNQgFKc7E0GK5evkQamFbKMYlF6zSKFGoPPurDNIluRkTK9UiZMt38jy5p+6Sihxab3gdI+7hIAxZrDmIsfR4tJRUfBN3imGLhUyl3JE2TBhcWCnWKNDNBupklZ0jVB4oWaf7/I36+hctMuhk6aaIz1Pt2iAU+q4tynn742gaxs0RERBSUmFnyG3aWiIiIghEzS37DzBIRERGRFzyzREREFIx4Gc5v2FkKZLrhWc1igXK4VwjySnk/zaJ6UrBTDsoaJ4kBSyEwbhIKUIphbqmIpDBNt0Ck7ojrnsdFt1igFMYVj50P/7mJxSbF0eql0LfuSjTnE9erty26x0D6jDpChc+osG9mqYirWKXQfSUmoWiqbhjZLIToxZsS7MKND8I0ke53T6Ck4p1SAUqz3k0DIh+C5bpXpKTjLG6fdIOJx/truKFDp0ipvyj4obPkly0JeLwMR0REROQFzywREREFI16G8xt2loiIiIKR0wkxI1HpNoiX4YiIiIi84JmlOuiy4fMM004mCqHTGOOy4ojhmn8YSGFus1B9WBzVXrOKsHbVcSlkKnbt9UKhYhVuKSwsVOaWq/4KK9EtYO0xn24QVRr5XgxkC2sVq2tLS4rvoxAsFysmC+FeMYyrF1SXR4MXlpX2TZok3FwgEatp67yR5TB53GChhB2Tjon8PTPOF3LKePBCiowLm+3SQRYqUEvHSXpvhc+jRPpcSJ9laLcnTJP+v5Da0/y/Rp5PmmjcGKfHTScOq8cKavKqFi/D+Q07S0RERMGInSW/4WU4IiIiIi94ZomIiCgYcbgTv2FnqQ7wzCiVRBsvopdGGpdTFqEx4eK9bo7JLBZzNM6nPaK5L8XXdAvjSZkYzfyUlE0Rs01SjkkqmKhb9M/QmDBNyuuIRQqF+XTzSWJBS711iKfmpdWKOStpW4TMjrReMdujlwFSQiZPIn3OzFJmR8r2iFm7itcr5riE/bKUGA+e5aQxn2QpEj7IduMBNQnvozMi1DBNWaT/bARSnsgi5HpCq35Rw2k1bouYY9LNQEmfUc2vsmc+CQDgkVHy/Bwr6XNdTZRyQinf7mbzdflgwc4SERFRMFLK9zNDzCwBYGaJiIiI/CAjIwOXXnopYmJikJiYiBtuuAF5eXlu8/z++++48cYbkZCQgNjYWNxyyy04cOCAoa3PPvsMXbt2RUREBOrVq4cbbrihhvZCxs4SERFRMCq7G87Xh6Zvv/0WaWlpWLt2LbKysmC325GamoqioiIAQFFREVJTU2EymZCdnY3Vq1ejpKQEAwYMgPOM4pcffvghhgwZghEjRuCnn37C6tWrcfvtt/v98FQGL8MREREFI6eznHBiJVQis/TFF1+4PV+4cCESExOxceNGXHHFFVi9ejV27tyJTZs2ITY2FgCwaNEi1KtXD9nZ2ejduzdKS0sxbtw4zJkzByNHjnS11a5dO9/2w0fsLNWwS0cYC046ItwDgSWxxuWcVuM0KdSoG6qWRj6XwtyWU8I6xOCtMJ8wzSmdy9QMbmsXlNMOQhunSccgxKY3grtURFAecb3i5aS/5nSD0SKp+KCQ2ZVD78YVi6O8C/+bKKmIpG6RVCHgLIb8JeJnQPpA6hXc9GduQ9x/KbheYvxgmKRpxcIdCMXCB9kuzBdifNPMxcaAN4SQNszCNGE+KUBtDhPWIZE+t8Ln0WmV1itts3GSEtahe4OJ2bPgJACnx8IOj13VvP+iziksLHR7HhYWhrCwMK/LFBQUAADq168PALDZbDCZTG7LhYeHw2w24/vvv0fv3r3x448/Yu/evTCbzejcuTPy8/PRqVMnzJkzBxdeeKGf90ofL8MREREFIz9ehmvSpAni4uJcj4yMDK+rdjqdeOCBB9CjRw9XJ6dbt26IiorC5MmTcfLkSRQVFWHSpElwOBzYv38/AOC///0vAGD69Ol45JFHsHz5ctSrVw89e/bEkSNHqvFgecfOEhERURBSTqdfHgCwZ88eFBQUuB7p6ele152WlobNmzfj3XffdU1LSEjA0qVL8emnnyI6OhpxcXE4duwYLr74Ypj/d6ayLLs0depUDBo0CF26dEFmZiZMJhOWLl1aTUeqYrwMR0RERF7Fxsa6ckYVue+++7B8+XKsWrUKjRs3dnstNTUVv//+Ow4fPoyQkBDEx8cjOTkZLVu2BAA0atQIgHtGKSwsDC1btsTu3bv9tDeVx85SNeqc9oxhmlkoZGePcH/uiDDMIuZLRE4hH6BZfDGkyDhNyvBI7YkDpkp1C4XslZh/0W1PyhFIA+QK+2spMTYYWiQMVFosZHY0CyHqEPdfOOcrFqUs1QsAOYRMh1mzMKBU9FF8f6Qcl1RcU2hPOsctzqebZRMyRtJAsiYhx2SSjqmUIZPmc0rr8FhWyk6VCB/QUuGLVip8uIX5nKeEsKG0D1bjF9IUJnxJJULeCRHhxvYcwpsrfWylj6NQDFOMPQrHXcosqRBhmg//14iDR3tMMynP58Z2qo3yQwXvSuT1lFIYO3Ysli1bhm+++QYtWrQod96GDRsCALKzs3Hw4EEMHDgQANClSxeEhYUhLy8Pl19+OQDAbrdj586daNasmQ874ht2loiIiIKRU/neO6tEZyktLQ1LlizBxx9/jJiYGOTn5wMA4uLiEBFx+ixAZmYm2rZti4SEBOTk5GDcuHEYP348WrduDeD0Gax77rkH06ZNQ5MmTdCsWTPMmTMHADB48GDf9sUH7CwRERGRz+bPnw8A6Nmzp9v0zMxMDB8+HACQl5eH9PR0HDlyBM2bN8fUqVMxfvx4t/nnzJmDkJAQDBkyBKdOnULXrl2RnZ2NevXq1cRuiNhZIiIiCkZKQb7mWdk2dGeteN7Zs2dj9uzZXucJDQ3F3LlzMXfuXO11Vzd2loiIiIKQciooHy/D6XSAzgYB01kaOHAgcnNzcfDgQdSrVw+9e/fGU089hXPOOcc1z88//4y0tDRs2LABCQkJGDt2LB566CGv7e7evRtjxozBypUrER0djWHDhiEjIwMhUnixkuyRxmkWoRab06OulxjuFUOsxklSuNkkTAsVwtwhQiY05KRu0UPjJKcQZpdDklrNiRN1i01KhSVDTgkB7xPGhS1CMNhsE0Zwl6rNSYfPMwAqBX6lYo6ao8ZLIVZzuPGD54gwhmedwrJOzVHZpf2XAuhSMFosuCkEl5VQCFE6BmKYWTp+0numeZxhl6qJCmwe4W2HsF8nhS+fFFqWAt5Ce04pMG4SPhfSTQlCe1JxSFOkcCeKtH1CiFwkFYeUjrvm50c6oSJ916TPlMQkhLktNmN79hj375U92v11h3DTTLVRTvh+ZsnH5YNEwNRZ6tWrF95//33k5eXhww8/xO+//46bb77Z9XphYSFSU1PRrFkzbNy4EXPmzMH06dPxyiuvlNumw+FAv379UFJSgjVr1mDRokVYuHAhHnvssZrYJSIiIgoAAXNm6cwAWLNmzTBlyhTccMMNsNvtCA0NxeLFi1FSUoI33ngDVqsV7du3R25uLubNm4fRo0eLba5YsQJbt27FV199haSkJHTq1AkzZ87E5MmTMX36dFh1/yIiIiKqY3gZzn8C5szSmY4cOYLFixeje/fuCA09fXkhJycHV1xxhVsHp0+fPsjLy8PRo0fFdnJyctChQwckJSW5LVNYWIgtW7ZU704QERFVJ+X0z4MC58wSAEyePBkvvPACTp48iW7dumH58uWu1/Lz8w0FsMo6Qfn5+eIth/n5+W4dJc9lymOz2WCz/f+F57LBAj0HGnTYio0LC2NZetZsc0jvilSUUopqSJklqSilcN3cJMUchMKNIimzJBTIlMbglTJLuuTsjHGaWdoPoYiilGtRQkbCLORp/JpZkgZ4lQooSpklIZviFLbXUSpkloS/n3THL67zmSXp+EnvmZDZEdfh1MwsOT2+WFIWSQlfPuFHSklfcGE+pxL+oxHeW7FoqPjjKGSWpEq50qLCMVYm6T80qTqkkHsUR6eWJukVw9TNLHl+bwHAIRTNLPX4P8RhM3s8P/27UBNnbEph97kmZan0o3UWqtXO0pQpU/DUU095nWfbtm1o06YNAODBBx/EyJEjsWvXLjz++OMYOnQoli9fDpMUDKxGGRkZePzxxw3TmzRpUqPbQUSkTfrRlMLGugHk4z5sC+Gvv/5CXFxctbRttVqRnJyM7/M/90t7ycnJZ30spVY7SxMnTnQVqipP2XgxwOny6A0bNsQFF1yAtm3bokmTJli7di1SUlKQnJyMAwcOuC1b9jw5OVlsOzk5GevXr6/UMgCQnp6OCRMmuJ4fO3YMzZo1w+7du6vtw1/dCgsL0aRJE+zZs0d7/J+6KBj2Ixj2AeB+1CXBsA9AcOxHQUEBmjZtivr161fbOsLDw/HHH3+gRLorsgqsVivCw41D2ZxNarWzlJCQgISEhCotWzYycdnlsJSUFEydOtUV+AaArKwstG7dutyqnykpKZg1axYOHjyIxMRE1zKxsbFug/h5CgsLQ1hYmGF6XFxcwH6By1RmsMS6LBj2Ixj2AeB+1CXBsA9AcOyHWffyXxWFh4ef9R0cfwqIgPe6devwwgsvIDc3F7t27UJ2djb+/ve/47zzzkNKSgoA4Pbbb4fVasXIkSOxZcsWvPfee3j22WfdzgAtW7bMdUkPOD36cbt27TBkyBD89NNP+PLLL/HII48gLS1N7AwRERHR2ScgOkuRkZH46KOPcPXVV6N169YYOXIkOnbsiG+//dbVqYmLi8OKFSvwxx9/oEuXLpg4cSIee+wxt7IBBQUFyMvLcz23WCxYvnw5LBYLUlJScOedd2Lo0KGYMWNGje8jERER1U0BcTdchw4dkJ2dXeF8HTt2xHfffVfu68OHDzdkpJo1a4bPP/ctBBcWFoZp06YF9NmoYNgHIDj2Ixj2AeB+1CXBsA9AcOxHMOzD2cikWHGKiIiIqFwBcRmOiIiIqLaws0RERETkBTtLRERERF6ws0RERETkBTtLGpo3bw6TyeT2mD17tts8P//8M/72t78hPDwcTZo0wdNPP11hu7t370a/fv0QGRmJxMREPPjggygt1Rxvygc2mw2dOnWCyWRCbm6ua/r06dMN+2kymRAVFeW1PWmZd999t1b2YefOneL2rF271mt7de29+Oabb3D99dejUaNGiIqKQqdOnbB48eIK26tL7wUQGN+LgQMHomnTpggPD0ejRo0wZMgQ7Nu3z/V6oHwvKtqPQPhuVLQPgfK9qGg/gMD4btAZFFWoWbNmasaMGWr//v2ux4kTJ1yvFxQUqKSkJHXHHXeozZs3q3feeUdFRESoBQsWlNtmaWmpuvDCC1Xv3r3Vpk2b1Oeff64aNmyo0tPTq31/7r//fnXttdcqAGrTpk2u6cePH3fbx/3796t27dqpYcOGeW0PgMrMzHRb7tSpU7WyD3/88YcCoL766iu37SkpKSm3rbr4XsyaNUs98sgjavXq1WrHjh3qX//6lzKbzerTTz/12l5dei8C5Xsxb948lZOTo3bu3KlWr16tUlJSVEpKiuv1QPleVLQfgfDdqGgfAuV7UdF+BMp3g/4fO0samjVrpp555plyX3/ppZdUvXr1lM1mc02bPHmyat26dbnLfP7558psNqv8/HzXtPnz56vY2Fi3dvzt888/V23atFFbtmwx/Lh5ys3NVQDUqlWrvLYJQC1btsy/G+qFt30o+0Hwtl9Se3X9vVBKqeuuu06NGDHC6zx16b0IpO/FmT7++GNlMpnK7UTU1e+FJ8/9CKTvRpmK3gul6ub3wpPnfgTqd+NsxstwmmbPno0GDRqgc+fOmDNnjtupz5ycHFxxxRVuozL36dMHeXl5OHr0qNheTk4OOnTogKSkJLdlCgsLsWXLlmrZhwMHDmDUqFF46623EBkZWeH8r732Gi644AL87W9/q3DetLQ0NGzYEJdddhneeOMNqGoq36W7DwMHDkRiYiIuv/xyfPLJJ17bDIT3AjhdgV5n8M268l4EyvfiTEeOHMHixYvRvXt31xiTnuri98KTt/2o69+NMjrvBVD3vheepP0IxO/G2Y6dJQ33338/3n33XaxcuRJ33303nnzySTz00EOu1/Pz890+wABcz/Pz88U2q7KML5RSGD58OO655x5ccsklFc5fXFyMxYsXY+TIkRXOO2PGDLz//vvIysrCoEGDcO+99+L555/3x2a70dmH6Oho/POf/8TSpUvx2Wef4fLLL8cNN9zg9Uehrr8XAPD+++9jw4YNGDFihNf56tJ7EQjfizKTJ09GVFQUGjRogN27d+Pjjz8W56uL34szeduPQPhuVLQPnura9+JM3vYjkL4b9D+1d1Krdk2ePFkB8PrYtm2buOzrr7+uQkJCVHFxsVJKqWuuuUaNHj3abZ6yyxJbt24V2xg1apRKTU11m1ZUVKQAqM8//9zv+/Hss8+qHj16qNLSUqVUxafklyxZokJCQtxO+ep69NFHVePGjWt9H8oMGTJEXX755eW+Xtffi+zsbBUZGakWLVqkvS1lavO9CITvRZlDhw6pvLw8tWLFCtWjRw913XXXKafTaWi3Jr8X1bkfZWriu1Fd+1CT3wt/70dtfjeoagJibLjqMHHiRMM4cZ5atmwpTu/atStKS0uxc+dOtG7dGsnJyThw4IDbPGXPk5OTxTaSk5Oxfv36Si0j0d2P7Oxs5OTkGMYjuuSSS3DHHXdg0aJFbtNfe+019O/f3/CXjI6uXbti5syZsNlsWuMfVdc+nLk9WVlZ5bZdl9+Lb7/9FgMGDMAzzzyDoUOHam9Lmdp8LwLhe1GmYcOGaNiwIS644AK0bdsWTZo0wdq1a5GSkuK2TE1+L6pzP87cpur+blTHPtT098Lf+1Gb3w2qotrurQWit99+W5nNZnXkyBGl1P+H9c4MIaanp2uF9Q4cOOCatmDBAhUbG+s6Y+VPu3btUr/88ovr8eWXXyoA6oMPPlB79uxxm/e///2vMplMFd5hUp4nnnhC1atXzx+b7aYy+3Cmu+66S3Xu3Lnc1+vqe7Fy5UoVFRWlXnjhhSqvqzbfi0D4Xkh27dqlAKiVK1e6Ta+r34vylLcfZ6pr3w1P0j7U5e9FeTz3I1C/G2czdpYqsGbNGvXMM8+o3Nxc9fvvv6u3335bJSQkqKFDh7rmOXbsmEpKSlJDhgxRmzdvVu+++66KjIx0uw30o48+cvsilN0GmpqaqnJzc9UXX3yhEhISauw2UG+Xfh555BF1zjnnuC6xnMlzPz755BP16quvql9++UX99ttv6qWXXlKRkZHqscceq87NV0rJ+7Bw4UK1ZMkStW3bNrVt2zY1a9YsZTab1RtvvFHuPtTF96LsEkN6errb7c5//fVXuftR196LQPherF27Vj3//PNq06ZNaufOnerrr79W3bt3V+edd57hB6gufy909qOufzd09iEQvhc6+xEI3w1yx85SBTZu3Ki6du2q4uLiVHh4uGrbtq168sknDf+R/vTTT+ryyy9XYWFh6txzz1WzZ892ez0zM1N5nsjbuXOnuvbaa1VERIRq2LChmjhxorLb7dW+T0qV31lyOByqcePG6uGHHxaX89yP//znP6pTp04qOjpaRUVFqYsuuki9/PLLyuFwVOfmK6XK7yy1bdtWRUZGqtjYWHXZZZeppUuXet0HpereezFs2DAxE3HllVeWux917b1Qqu5/L37++WfVq1cvVb9+fRUWFqaaN2+u7rnnHvXnn3+6zVfXvxc6+1HXvxs6+xAI3wvdz1Rd/26QO5NSNXT/JBEREVEAYukAIiIiIi/YWSIiIiLygp0lIiIiIi/YWSIiIiLygp0lIiIiIi/YWSIiIiLygp0lIiIiIi/YWSKiKunZsyceeOCB2t4MIqJqx84SERERkRfsLBERERF5wc4SEfns6NGjGDp0KOrVq4fIyEhce+21+O2331yvL1y4EPHx8fjyyy/Rtm1bREdHo2/fvti/f38tbjURkR52lojIZ8OHD8cPP/yATz75BDk5OVBK4brrroPdbnfNc/LkScydOxdvvfUWVq1ahd27d2PSpEm1uNVERHpCansDiCiw/fbbb/jkk0+wevVqdO/eHQCwePFiNGnSBP/+978xePBgAIDdbsfLL7+M8847DwBw3333YcaMGbW23UREunhmiYh8sm3bNoSEhKBr166uaQ0aNEDr1q2xbds217TIyEhXRwkAGjVqhIMHD9bothIRVQU7S0RUI0JDQ92em0wmKKVqaWuIiPSxs0REPmnbti1KS0uxbt0617S//voLeXl5aNeuXS1uGRGRf7CzREQ+Of/883H99ddj1KhR+P777/HTTz/hzjvvxLnnnovrr7++tjePiMhn7CwRkc8yMzPRpUsX9O/fHykpKVBK4fPPPzdceiMiCkQmxdAAERERUbl4ZomIiIjIC3aWiIiIiLxgZ4mIiIjIC3aWiIiIiLxgZ4mIiIjIC3aWiIiIiLxgZ4mIiIjIC3aWiIiIiLxgZ4mIiIjIC3aWiIiIiLxgZ4mIiIjIC3aWiIiIiLz4P83uGz/NG0MFAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -415,17 +333,17 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 13, "id": "65c7de6c-0b13-4cb8-912f-02e8ed953c71", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 42, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -447,7 +365,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 14, "id": "7d621ae6-52d8-476b-95b4-205bc05589e3", "metadata": {}, "outputs": [], @@ -459,23 +377,23 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 15, "id": "6e18ddd5-81b2-4583-8a35-e9af7978bdf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 44, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -490,23 +408,23 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 16, "id": "ea56d33c-fd54-4353-bd88-06990ed9641c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 45, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/pyproject.toml b/pyproject.toml index 7c9685a..660dfb0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,6 +14,7 @@ dependencies = [ "jupyterlab>=4.5.3", "matplotlib>=3.10.8", "netcdf4>=1.7.4", + "tensorboard", "torch>=2.10.0", "xarray>=2025.12.0", ]