diff --git a/README.md b/README.md index a82e641..dc2e538 100644 --- a/README.md +++ b/README.md @@ -69,6 +69,11 @@ Please take a look at our notebook collection to get started with DeepSpot for V - [DeepCell training](example_notebook/Xenium_single-cell_example/GettingStartedWithDeepCell_2_training.ipynb) - [DeepCell inference](example_notebook/Xenium_single-cell_example/GettingStartedWithDeepCell_3_inference.ipynb) +**DeepSpot2Cell** for spot to cell resolution deconvolution: + - [Spatial transcriptomics data preprocessing for DeepSpot2Cell](example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_1_preprocessing.ipynb) + - [DeepSpot2Cell training](example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_2_training.ipynb) + - [DeepSpot2Cell inference](example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_3_inference.ipynb) + ## Pretrained DeepSpot weights Moreover, we provide pretrained weights for DeepSpot, which were generated during the training of the model in our publication and were used, for example, to generate spatial transcriptomics data for TCGA skin melanoma and kidney cancer slides. diff --git a/deepspot/deepspot2cell/__init__.py b/deepspot/deepspot2cell/__init__.py new file mode 100644 index 0000000..0f402ed --- /dev/null +++ b/deepspot/deepspot2cell/__init__.py @@ -0,0 +1,3 @@ +from .model import DeepSpot2Cell, Phi, Rho +from .dataloader import DS2CDataset +from .loss import mse, pearsonr, pearson_mse, wmse, safe_pearson diff --git a/deepspot/deepspot2cell/dataloader.py b/deepspot/deepspot2cell/dataloader.py new file mode 100644 index 0000000..cd8d2ee --- /dev/null +++ b/deepspot/deepspot2cell/dataloader.py @@ -0,0 +1,390 @@ +import numpy as np +import h5py +import os +import torch +from torch.utils.data import Dataset +from sklearn.preprocessing import StandardScaler + + +class DS2CDataset(Dataset): + def __init__(self, dataset_variant, ids_list, data_path, model_name, standard_scaling=False, shuffle=True, normalize=True, norm_counts=1e4, minmax=False, plot_cell_dist=False, neighb_degree=0, scellst=False, load_cell_types=False): + self.scellst = scellst + self.dataset_variant = dataset_variant + self.neighb_degree = neighb_degree + self.ids_list = ids_list + self.data_path = data_path + self.model_name = model_name + self.shuffle = shuffle + self.normalize = normalize + self.norm_counts = norm_counts + self.cache = {} + self.cache_size = 1000 + self.standard_scaling = standard_scaling + self.spot_scaler = None + self.cell_scaler = None + self.minmax = minmax + self.spot_gene_min = None + self.spot_gene_max = None + self.spot_gene_range = None + self.cell_gene_min = None + self.cell_gene_max = None + self.cell_gene_range = None + self.patch_barcodes = [] + self.load_cell_types = load_cell_types + self.expression_data = self.load_data() + self._compute_dataset_statistics(plot_cell_dist=plot_cell_dist) + + def _compute_dataset_statistics(self, plot_cell_dist=False): + """Compute max cells per patch and min/max normalization values separately for spots and cells""" + max_cells = 0 + avg_cells = 0 + num_patches = len(self.patch_barcodes) + cells_per_patch = [] + cells_per_spot = [] + + if self.minmax: + first_sample_id = list(self.expression_data.keys())[0] + first_patch = list(self.expression_data[first_sample_id].keys())[0] + num_genes = self.expression_data[first_sample_id][first_patch]['spot_expression'].shape[0] + + self.spot_gene_min = np.full(num_genes, np.inf, dtype=np.float32) + self.spot_gene_max = np.full(num_genes, -np.inf, dtype=np.float32) + self.cell_gene_min = np.full(num_genes, np.inf, dtype=np.float32) + self.cell_gene_max = np.full(num_genes, -np.inf, dtype=np.float32) + + if self.standard_scaling and self.normalize: + all_spot_log_expressions = [] + all_cell_log_expressions = [] + + for sample_id, patches in self.expression_data.items(): + for patch_barcode, patch_data in patches.items(): + num_cells = len(patch_data['cell_ids']) + cells_per_patch.append(num_cells) + if num_cells > max_cells: + max_cells = num_cells + avg_cells += num_cells / num_patches + + if self.normalize: + spot_expr = patch_data['spot_expression'] + spot_sum = np.sum(spot_expr) + if spot_sum > 0: + norm_spot = self.norm_counts * spot_expr / spot_sum + log_spot = np.log1p(norm_spot) + + if self.minmax: + self.spot_gene_min = np.minimum(self.spot_gene_min, log_spot) + self.spot_gene_max = np.maximum(self.spot_gene_max, log_spot) + + if self.standard_scaling: + all_spot_log_expressions.append(log_spot) + + if self.normalize: + cell_expr = patch_data['cell_expressions'] + cell_sums = np.sum(cell_expr, axis=1, keepdims=True) + cell_ids = patch_data['cell_ids'] + is_inside_spot = np.array([0.0 if cell_id[-4:] == '_out' else 1.0 + for cell_id in cell_ids], dtype=np.float32) + inspot_indices = np.where(is_inside_spot)[0] + inspot_total = np.sum(cell_sums[inspot_indices]) + + cells_per_spot.append(len(inspot_indices)) + + if inspot_total > 1e-8: + norm_cells = np.zeros_like(cell_expr, dtype=np.float32) + norm_cells[inspot_indices] = self.norm_counts * cell_expr[inspot_indices] / inspot_total + + outspot_indices = np.where(is_inside_spot == 0)[0] + if len(outspot_indices) > 0: + norm_cells[outspot_indices] = self.norm_counts * cell_expr[outspot_indices] / inspot_total + + log_cells = np.log1p(norm_cells) + nonzero_cells = log_cells[np.sum(cell_expr, axis=1) > 0] + + if self.minmax and len(nonzero_cells) > 0: + self.cell_gene_min = np.minimum(self.cell_gene_min, np.min(nonzero_cells, axis=0)) + self.cell_gene_max = np.maximum(self.cell_gene_max, np.max(nonzero_cells, axis=0)) + + if self.standard_scaling and len(nonzero_cells) > 0: + all_cell_log_expressions.append(nonzero_cells) + + # Fit separate scalers for spots and cells + if self.standard_scaling and self.normalize: + if all_spot_log_expressions: + all_spot_log_expressions = np.vstack(all_spot_log_expressions) + self.spot_scaler = StandardScaler().fit(all_spot_log_expressions) + print(f"Fit Spot StandardScaler on {all_spot_log_expressions.shape[0]} spot expressions") + print(f"Spot Mean: min={self.spot_scaler.mean_.min():.4f}, max={self.spot_scaler.mean_.max():.4f}") + print(f"Spot Std: min={self.spot_scaler.scale_.min():.4f}, max={self.spot_scaler.scale_.max():.4f}") + + if all_cell_log_expressions: + all_cell_log_expressions = np.vstack(all_cell_log_expressions) + self.cell_scaler = StandardScaler().fit(all_cell_log_expressions) + print(f"Fit Cell StandardScaler on {all_cell_log_expressions.shape[0]} cell expressions") + print(f"Cell Mean: min={self.cell_scaler.mean_.min():.4f}, max={self.cell_scaler.mean_.max():.4f}") + print(f"Cell Std: min={self.cell_scaler.scale_.min():.4f}, max={self.cell_scaler.scale_.max():.4f}") + + print(f"Max cells per patch: {max_cells}") + print(f"Mean cells per patch: {avg_cells}") + print(f"Mean cells per spot: {np.mean(cells_per_spot):.2f}") + + if plot_cell_dist: + np.save(f'./cells_per_spot_distribution_sample_{self.ids_list[0]}.npy', np.array(cells_per_spot)) + + self.max_cells = max_cells + + if self.minmax: + self.spot_gene_range = self.spot_gene_max - self.spot_gene_min + self.spot_gene_range[self.spot_gene_range < 1e-8] = 1.0 + self.cell_gene_range = self.cell_gene_max - self.cell_gene_min + self.cell_gene_range[self.cell_gene_range < 1e-8] = 1.0 + + print(f"Spot Min values range: {np.min(self.spot_gene_min):.4f} to {np.max(self.spot_gene_min):.4f}") + print(f"Spot Max values range: {np.min(self.spot_gene_max):.4f} to {np.max(self.spot_gene_max):.4f}") + print(f"Cell Min values range: {np.min(self.cell_gene_min):.4f} to {np.max(self.cell_gene_min):.4f}") + print(f"Cell Max values range: {np.min(self.cell_gene_max):.4f} to {np.max(self.cell_gene_max):.4f}") + + def load_data(self): + """Load all sample data and collect patch barcodes""" + data = {} + for sample_id in self.ids_list: + sample_data = self.load_spot_data(sample_id) + if sample_data is not None: + data[sample_id] = sample_data + for patch_barcode in sample_data.keys(): + self.patch_barcodes.append((sample_id, patch_barcode)) + + if self.shuffle: + np.random.shuffle(self.patch_barcodes) + + return data + + def __len__(self): + return len(self.patch_barcodes) + + def __getitem__(self, idx): + if idx in self.cache: + return self.cache[idx] + + attempts = 0 + while True: + sample_id, patch_barcode = self.patch_barcodes[idx] + + patch_data = self.expression_data[sample_id][patch_barcode] + cell_expressions = patch_data['cell_expressions'] + cell_ids = patch_data['cell_ids'] + cell_centroids = patch_data['cell_centroids'] + spot_expression = patch_data['spot_expression'] + if self.load_cell_types: + cell_classes = patch_data['cell_classes'] + + spot_sum = np.sum(spot_expression) + if spot_sum == 0: + attempts += 1 + if attempts >= 50: + raise RuntimeError("Could not find a patch with non-zero spot sum after 50 attempts.") + idx = np.random.randint(0, len(self.patch_barcodes)) + if idx in self.cache: + return self.cache[idx] + continue + + is_inside_spot = np.array([0.0 if cell_id[-4:] == '_out' else 1.0 for cell_id in cell_ids], dtype=np.float32) + + nonzero_mask = cell_expressions.sum(axis=1) > 0 + if nonzero_mask.any(): + cell_expressions = cell_expressions[nonzero_mask] + is_inside_spot = is_inside_spot[nonzero_mask] + if not self.scellst: + patch_embeddings = np.load(f"{self.data_path}/embeddings{self.dataset_variant}/{self.model_name}/{patch_barcode}.npy") + else: + patch_embeddings = np.load(f"{self.data_path}/embeddings{self.dataset_variant}/{self.model_name}/{patch_barcode}_scellst.npy") + patch_embedding = patch_embeddings[0] + cell_embeddings = patch_embeddings[1:][nonzero_mask] + + if self.normalize: + spot_expression = self.preprocess(spot_expression[np.newaxis, ...], is_spot=True)[0] + cell_expressions = self.preprocess(cell_expressions, is_spot=False, inspot_mask=is_inside_spot) + + num_cells = len(cell_embeddings) + emb_dim = cell_embeddings.shape[1] if num_cells else patch_embedding.shape[0] + expr_dim = cell_expressions.shape[1] if num_cells else spot_expression.shape[0] + + padded_embeds = np.zeros((self.max_cells, emb_dim), dtype=np.float32) + padded_exprs = np.zeros((self.max_cells, expr_dim), dtype=np.float32) + padded_inside = np.zeros(self.max_cells, dtype=np.float32) + padded_centroids = np.zeros((self.max_cells, 2), dtype=np.float32) + + if num_cells: + padded_embeds[:num_cells] = cell_embeddings + padded_exprs[:num_cells] = cell_expressions + padded_inside[:num_cells] = is_inside_spot + filtered_centroids = cell_centroids[nonzero_mask] + padded_centroids[:num_cells] = filtered_centroids + + cell_mask = np.zeros(self.max_cells, dtype=np.float32) + cell_mask[:num_cells] = 1.0 + + result = { + 'patch_embedding': torch.tensor(patch_embedding, dtype=torch.float32), + 'cell_embeddings': torch.tensor(padded_embeds, dtype=torch.float32), + 'spot_expression': torch.tensor(spot_expression, dtype=torch.float32), + 'cell_expressions': torch.tensor(padded_exprs, dtype=torch.float32), + 'cell_mask': torch.tensor(cell_mask, dtype=torch.float32), + 'is_inside_spot': torch.tensor(padded_inside, dtype=torch.float32), + 'num_cells': num_cells, + 'cell_centroids': torch.tensor(padded_centroids, dtype=torch.float32), + 'patch_barcode': patch_barcode + } + + if self.neighb_degree: + curr_y, curr_x = patch_barcode.split('_')[1:3] + curr_y, curr_x = int(curr_y), int(curr_x) + neighb_xs = [curr_x + dx for dx in range(-self.neighb_degree, self.neighb_degree + 1)] + neighb_ys = [curr_y + dy for dy in range(-self.neighb_degree, self.neighb_degree + 1)] + neighb_barcodes = [f"patch_{y}_{x}_{sample_id}" for y in neighb_ys for x in neighb_xs if (y, x) != (curr_y, curr_x)] + neighb_embeddings = [patch_embedding.copy()] + neighb_masks = [False] + for neighb_barcode in neighb_barcodes: + if not os.path.exists(f"{self.data_path}/embeddings{self.dataset_variant}/{self.model_name}/{neighb_barcode}.npy"): + neighb_embeddings.append(np.zeros(emb_dim, dtype=np.float32)) + neighb_masks.append(True) + continue + + neighb_emb = np.load(f"{self.data_path}/embeddings{self.dataset_variant}/{self.model_name}/{neighb_barcode}.npy") + neighb_embeddings.append(neighb_emb[0]) + neighb_masks.append(False) + + neighb_embeddings = np.array(neighb_embeddings, dtype=np.float32) + neighb_masks = np.array(neighb_masks, dtype=np.bool_) + result['neighb_embeddings'] = torch.tensor(neighb_embeddings, dtype=torch.float32) + result['neighb_masks'] = torch.tensor(neighb_masks, dtype=torch.bool) + + if self.load_cell_types: + nonzero_cell_classes = cell_classes[nonzero_mask] + padded_cell_types = [''] * self.max_cells + padded_cell_types[:num_cells] = nonzero_cell_classes.tolist() + result['cell_classes'] = padded_cell_types + + + if len(self.cache) < self.cache_size: + self.cache[idx] = result + return result + + attempts += 1 + if attempts >= 50: + raise RuntimeError("Could not find a patch with non-zero cells after 50 attempts.") + idx = np.random.randint(0, len(self.patch_barcodes)) + if idx in self.cache: + return self.cache[idx] + + + def preprocess(self, expression_data, is_spot=False, inspot_mask=None): + if is_spot: + summ = np.sum(expression_data, axis=1, keepdims=True) + norm_data = self.norm_counts * expression_data / summ + else: + cell_sums = np.sum(expression_data, axis=1, keepdims=True) + inspot_indices = np.where(inspot_mask)[0] + inspot_total = np.sum(cell_sums[inspot_indices]) + norm_data = np.zeros_like(expression_data, dtype=np.float32) + # Normalize cells that are inside the spot by their contribution to total + norm_data[inspot_indices] = self.norm_counts * expression_data[inspot_indices] / inspot_total + # Normalize cells that are outside the spot using their own counts (as if they were inside the spot) + outspot_indices = np.where(inspot_mask == 0)[0] + if len(outspot_indices) > 0: + norm_data[outspot_indices] = self.norm_counts * expression_data[outspot_indices] / inspot_total + + log_data = np.log1p(norm_data) + + if self.standard_scaling: + # Reshape for sklearn compatibility if needed + orig_shape = log_data.shape + if len(orig_shape) > 2: + log_data = log_data.reshape(-1, orig_shape[-1]) + + if is_spot and self.spot_scaler is not None: + log_data = self.spot_scaler.transform(log_data) + elif not is_spot and self.cell_scaler is not None: + log_data = self.cell_scaler.transform(log_data) + + # Reshape back if needed + if len(orig_shape) > 2: + log_data = log_data.reshape(orig_shape) + + if self.minmax: + if is_spot: + log_data = (log_data - self.spot_gene_min) / self.spot_gene_range + else: + log_data = (log_data - self.cell_gene_min) / self.cell_gene_range + + return log_data + + def inverse_transform(self, scaled_data, is_spot=False): + """Inverse transform standardized and/or min-max normalized data back to log space + """ + orig_shape = scaled_data.shape + if isinstance(scaled_data, torch.Tensor): + scaled_data = scaled_data.cpu().numpy() + + if len(orig_shape) > 2: + scaled_data = scaled_data.reshape(-1, orig_shape[-1]) + + data = scaled_data.copy() + if self.minmax: + if is_spot: + data = data * self.spot_gene_range + self.spot_gene_min + else: + data = data * self.cell_gene_range + self.cell_gene_min + + if self.standard_scaling: + if is_spot and self.spot_scaler is not None: + data = self.spot_scaler.inverse_transform(data) + elif not is_spot and self.cell_scaler is not None: + data = self.cell_scaler.inverse_transform(data) + + # Reshape back if needed + if len(orig_shape) > 2: + data = data.reshape(orig_shape) + + return data + + + def spatial_upsample_and_smooth(self, genex_data, cell_expressions): + # Not used for now + pass + + + def load_spot_data(self, sample_id, patch_barcode=None): + try: + with h5py.File(f'{self.data_path}/expressions{self.dataset_variant}/{sample_id}_expressions.h5', 'r') as f: + if patch_barcode is not None: + # Load specific patch + if patch_barcode in f: + spot_group = f[patch_barcode] + data = { + 'spot_expression': spot_group['spot_expression'][:], + 'cell_expressions': spot_group['cell_expressions'][:], + 'cell_ids': [id.decode('utf-8') for id in spot_group['cell_ids'][:]], + 'cell_centroids': spot_group['cell_centroids'][:] + } + if self.load_cell_types and 'cell_classes' in spot_group: + data['cell_classes'] = np.array([s.decode('utf-8') for s in spot_group['cell_classes'][:]]) + return data + else: + return None + else: + # Load all patches + result = {} + for pb in f.keys(): + data = { + 'spot_expression': f[pb]['spot_expression'][:], + 'cell_expressions': f[pb]['cell_expressions'][:], + 'cell_ids': [id.decode('utf-8') for id in f[pb]['cell_ids'][:]], + 'cell_centroids': f[pb]['cell_centroids'][:] + } + if self.load_cell_types and 'cell_classes' in f[pb]: + data['cell_classes'] = np.array([s.decode('utf-8') for s in f[pb]['cell_classes'][:]]) + result[pb] = data + return result + except (FileNotFoundError, IOError) as e: + print(f"Error loading data for sample {sample_id}: {e}") + return None \ No newline at end of file diff --git a/deepspot/deepspot2cell/dataset_creation.py b/deepspot/deepspot2cell/dataset_creation.py new file mode 100644 index 0000000..c179843 --- /dev/null +++ b/deepspot/deepspot2cell/dataset_creation.py @@ -0,0 +1,524 @@ +import os +import gc +import json +import h5py +import pyvips +import pandas as pd +from shapely.geometry import box, Polygon, shape, Point +import argparse +from shapely.ops import unary_union +import numpy as np +from hest import iter_hest +import cv2 +from PIL import Image +import torch +import torch.nn.functional as F +import time + +from deepspot.utils.utils import load_config, order_genes +from deepspot.utils.utils_image import format_to_dtype, get_morphology_model_and_preprocess + + +def process_batch(batch_patches, model, preprocess, device): + batch_processed = [] + for patch in batch_patches: + patch_img = Image.fromarray(patch) + if patch_img.width != patch_img.height: + size = max(patch_img.width, patch_img.height) + patch_img = patch_img.resize((size, size)) + batch_processed.append(preprocess(patch_img).to(device).to(torch.float16)) + + batch_tensor = torch.stack(batch_processed) + + with torch.autocast(device_type="cuda", dtype=torch.float16): + with torch.inference_mode(): + batch_embeddings = model(batch_tensor) + batch_embeddings = batch_embeddings.detach().cpu() + + return batch_embeddings + + +def get_spot_embs(X_spot, morphology_model, preprocess, device, dtype_to_use=torch.float16): + with torch.autocast(device_type="cuda", dtype=dtype_to_use): + with torch.inference_mode(): + X_spot_img = Image.fromarray(X_spot) + # if spot is not square, make it square + if X_spot_img.width != X_spot_img.height: + size = max(X_spot_img.width, X_spot_img.height) + X_spot_img = X_spot_img.resize((size, size)) + + X_spot_tensor = preprocess(X_spot_img).to(device).to(torch.float16) + token_map = morphology_model(X_spot_tensor[None, ]) + cls_tok = token_map.squeeze(0) + + return cls_tok.cpu().numpy() + + +def sort_genes_by_variability(adata, config): + ordered_genes_path = f"{config['data']['data_folder']}/{config['data'][config['dataset']]['ordered_genes_file']}" + print(f" Using gene order from {ordered_genes_path}") + + if os.path.exists(ordered_genes_path): + print(f" Loading ordered genes from {ordered_genes_path}") + else: + print(f" Ordered genes file not found. Generating new order.") + order_genes(config) + + with open(ordered_genes_path, 'r') as f: + ordered_gene_names = json.load(f) + + + adata_genes_set = set(adata.var.index.values) + ordered_genes_set = set(ordered_gene_names) + + if adata_genes_set != ordered_genes_set: + print(" Warning: Gene names in adata and ordered genes file do not match.") + diff = adata_genes_set - ordered_genes_set + if len(diff) > 0: + print(f" Different genes in adata: {diff}") + + return ordered_gene_names + + +def crop_tile(image, x_pixel, y_pixel, spot_diameter): + spot = image.crop(x_pixel, y_pixel, spot_diameter, spot_diameter) + main_tile = np.ndarray(buffer=spot.write_to_memory(), + dtype=format_to_dtype[spot.format], + shape=[spot.height, spot.width, spot.bands]) + main_tile = main_tile[:, :, :3] + return main_tile + + +def fix_invalid_geometry(geom): + """Attempt to fix invalid geometry""" + if not geom.is_valid: + try: + fixed = geom.buffer(0) + if fixed.is_valid: + return fixed + + if hasattr(geom, 'make_valid'): + fixed = geom.make_valid() + if fixed.is_valid: + return fixed + except Exception: + pass + return geom + + +def create_tissue_mask(tissue_mask_json, sample_id): + """Create a valid tissue mask from GeoJSON, handling geometry errors robustly""" + tissue_polygons = [] + total_polygons = 0 + invalid_polygons = 0 + + for feature in tissue_mask_json['features']: + if feature['geometry']['type'] != 'Polygon': + continue + total_polygons += 1 + + try: + poly = shape(feature['geometry']) + if not poly.is_valid: + poly = poly.buffer(0) + if not poly.is_valid: + invalid_polygons += 1 + continue + tissue_polygons.append(poly) + except Exception: + invalid_polygons += 1 + + if not tissue_polygons: + print(f" Warning: No valid polygons in {sample_id} (total: {total_polygons}, invalid: {invalid_polygons})") + return None + print(f" Extracted {len(tissue_polygons)} valid polygons from {total_polygons} total") + if len(tissue_polygons) == 1: + return tissue_polygons[0] + + try: + return unary_union(tissue_polygons) + except Exception: + pass + + mask = tissue_polygons[0] + successful_unions = 1 + + for i, poly in enumerate(tissue_polygons[1:], 1): + try: + clean_mask = mask.buffer(0) + clean_poly = poly.buffer(0) + if clean_mask.is_valid and clean_poly.is_valid: + mask = clean_mask.union(clean_poly) + successful_unions += 1 + else: + print(f" Warning: Skipping polygon {i} in union due to validity issues") + except Exception: + print(f" Warning: Failed to union polygon {i}, continuing with current mask") + print(f" Created tissue mask with {successful_unions}/{len(tissue_polygons)} polygons") + return mask + + +def process_sample(sample_id, st, model, preprocess, device, batch_size, config): + data_folder = config['data']['data_folder'] + dataset_variant = config['data']['dataset_variant'] + print(f"Processing {sample_id}") + if os.path.exists(f'{data_folder}/expressions{dataset_variant}/{sample_id}_expressions.h5'): + print(f" Already processed {sample_id}, skipping") + return + + with open(f"{data_folder}/metadata/{sample_id}.json") as f: + metadata = json.load(f) + print(metadata) + um_per_px = metadata.get('pixel_size_um_estimated', 0.2125) + if config['data'].get('spot_diameter_px', None) is not None: + spot_diameter = config['data']['spot_diameter_px'] + patch_size = config['data']['patch_size_px'] + else: + spot_diameter = int(config['data']['spot_diameter'] / um_per_px) + patch_size = int(config['data']['patch_size'] / um_per_px) + print(f" Pixel size (um): {um_per_px}, spot diameter (px): {spot_diameter}, patch size (px): {patch_size}") + + ordered_gene_names = sort_genes_by_variability(st.adata, config) + gene_to_idx = {gene: idx for idx, gene in enumerate(ordered_gene_names)} + + with open(f"{data_folder}/tissue_seg/{sample_id}_contours.geojson", 'r') as f: + tissue_mask_json = json.load(f) + tissue_mask = create_tissue_mask(tissue_mask_json, sample_id) + + #patches = h5py.File(f"{data_folder}/patches/{sample_id}.h5") + cell_shapes = st.get_shapes('xenium_cell', 'he').shapes + if cell_shapes.index.dtype == 'object': + decode = lambda x: x.decode("utf-8", "ignore") if isinstance(x, (bytes, bytearray)) else str(x) + cell_shapes.index = cell_shapes.index.map(decode).astype("string") + #print(f'Cell shapes index data type: {cell_shapes.index.dtype}') + + + wsi = pyvips.Image.new_from_file(f"{data_folder}/wsis/{sample_id}.tif") + wsi_width = wsi.width + wsi_height = wsi.height + num_patches_h = wsi_height // patch_size + num_patches_w = wsi_width // patch_size + print(f" Divided wsi into {num_patches_h} x {num_patches_w} = {num_patches_h * num_patches_w} patches") + + # filtering --------------------------------------- + filtered_df = st.transcript_df[~st.transcript_df.cell_id.isin(['UNASSIGNED', -1])] + + qv_thr = config['data']['qv_thr'] + initial_transcript_count = len(filtered_df) + filtered_df['qv'] = pd.to_numeric(filtered_df['qv'], errors='coerce') + filtered_df = filtered_df[filtered_df['qv'] > qv_thr] + print(f" Filtered by 'qv' > {qv_thr}: {len(filtered_df)} transcripts retained from {initial_transcript_count}.") + # /filtering -------------------------------------- + #print(filtered_df.head()) + #print(cell_shapes.head()) + for col in ('feature_name', 'cell_id'): + s = filtered_df[col] + if s.dtype == 'object': + # decode *only* the bytes, leave real strings untouched + decoded = s.str.decode('utf-8', errors='ignore') + filtered_df[col] = decoded.fillna(s).astype('string') + #print(filtered_df.head()) + #print(f'filtered df cell_id data type: {filtered_df["cell_id"].dtype}') + + cell_dict = {} + cell_batch = [] + cell_batch_ids = [] + approx_total_cells = metadata.get('cells_under_tissue', 200000) * 1.5 + total_cells = 0 + cells_inside_tissue = 0 + + cell_start_time = time.time() + cell_count = 0 + print(f" Starting processing of cells for {sample_id}") + + for cell_id, cell_data in filtered_df.groupby('cell_id'): + cell_count += 1 + total_cells += 1 + if cell_count % 10000 == 0: + elapsed = time.time() - cell_start_time + cells_per_sec = cell_count / elapsed + remaining = (approx_total_cells - cell_count) / cells_per_sec if cells_per_sec > 0 else 0 + print(f" Processed {cell_count}/{approx_total_cells} cells ({cell_count/approx_total_cells*100:.1f}%) - " + f"ETA: {int(elapsed/3600)}:{int(elapsed/60)}:{int(elapsed)%60}/{int(remaining/3600)}:{int(remaining/60)}:{int(remaining)%60}") + + gene_expression = np.zeros(len(ordered_gene_names)) + gene_counts = cell_data.groupby('feature_name').size() + for gene_name, count in gene_counts.items(): + if gene_name in gene_to_idx: + gene_expression[gene_to_idx[gene_name]] = count + if np.sum(gene_expression) == 0: + #print('zero ex') + continue + + cell_shape_data = cell_shapes[cell_shapes.index == cell_id] + if cell_shape_data.empty: + #print('empty shape') + continue + + cell_shape = cell_shape_data.geometry.values[0] # shapely polygon + if not cell_shape.is_valid: + cell_shape = fix_invalid_geometry(cell_shape) + if not cell_shape.is_valid: + print(f" Cell {cell_id} has invalid geometry after fixing") + continue + centroid = cell_shape.centroid + cell_centroid_x = centroid.x + cell_centroid_y = centroid.y + + # Check if cell is inside tissue mask + if not tissue_mask.contains(Point(cell_centroid_x, cell_centroid_y)): + #print('actual outside') + continue + + cells_inside_tissue += 1 + cell_area = cell_shape.area + cell_bounds = cell_shape.bounds # (minx, miny, maxx, maxy) + # Calculate the smallest square bounding box + rect_width = cell_bounds[2] - cell_bounds[0] + rect_height = cell_bounds[3] - cell_bounds[1] + max_dimension = max(rect_width, rect_height) + square_half_side = max_dimension / 2 + square_minx = cell_centroid_x - square_half_side + square_miny = cell_centroid_y - square_half_side + square_maxx = cell_centroid_x + square_half_side + square_maxy = cell_centroid_y + square_half_side + + try: + cell_img = crop_tile(wsi, square_minx, square_miny, max_dimension) + except Exception as e: + print(f" Error cropping cell {cell_id} image: {e}") + continue + + cell_dict[f"{sample_id}_{cell_id}"] = { + 'cell_expression': gene_expression, + 'cell_shape': cell_shape, + 'cell_centroid_x': cell_centroid_x, + 'cell_centroid_y': cell_centroid_y, + 'area': cell_area, + 'cell_bounds': cell_bounds, + 'square_bbox_coords': (square_minx, square_miny, square_maxx, square_maxy), + } + + cell_batch.append(cell_img) + cell_batch_ids.append(f"{sample_id}_{cell_id}") + if len(cell_batch) == batch_size: + cell_embeddings = process_batch(cell_batch, model, preprocess, device) + # if scellst_model is not None: + # scellst_embeddings = process_batch(cell_batch, scellst_model, scellst_preprocess, device) + for j, c_id in enumerate(cell_batch_ids): + cell_dict[c_id]['cell_embedding'] = cell_embeddings[j] + #cell_dict[c_id]['scellst_embedding'] = scellst_embeddings[j] if scellst_model else None + cell_batch = [] + cell_batch_ids = [] + + if len(cell_batch) > 0: + cell_embeddings = process_batch(cell_batch, model, preprocess, device) + # if scellst_model is not None: + # scellst_embeddings = process_batch(cell_batch, scellst_model, scellst_preprocess, device) + for j, c_id in enumerate(cell_batch_ids): + cell_dict[c_id]['cell_embedding'] = cell_embeddings[j] + #cell_dict[c_id]['scellst_embedding'] = scellst_embeddings[j] if scellst_model else None + + elapsed = time.time() - cell_start_time + print(f" Completed cell processing: {cells_inside_tissue}/{total_cells} cells inside tissue in {elapsed:.1f} sec") + + print(f" Created cell data for {cells_inside_tissue} cells inside tissue ({cells_inside_tissue}/{total_cells} cells are within tissue)") + + patches_inside_tissue = 0 + total_patches = num_patches_h * num_patches_w + spot_dict = {} + + patch_start_time = time.time() + patch_count = 0 + total_patch_count = num_patches_h * num_patches_w + print(f" Starting processing of patches") + + for h_idx in range(num_patches_h): + for w_idx in range(num_patches_w): + patch_count += 1 + # Print progress every 1k patches + if patch_count % 1000 == 0: + elapsed = time.time() - patch_start_time + patches_per_sec = patch_count / elapsed + remaining = (total_patch_count - patch_count) / patches_per_sec if patches_per_sec > 0 else 0 + print(f" Processed {patch_count}/{total_patch_count} patches ({patch_count/total_patch_count*100:.1f}%) - " + f"ETA: {int(elapsed/3600)}:{int(elapsed/60)}:{int(elapsed)%60}/{int(remaining/3600)}:{int(remaining/60)}:{int(remaining)%60}") + + patch_barcode = f"patch_{h_idx}_{w_idx}_{sample_id}" + patch_y = h_idx * patch_size + patch_x = w_idx * patch_size + patch_center_x = patch_x + patch_size // 2 + patch_center_y = patch_y + patch_size // 2 + + # Skip patches whose centroid is outside tissue + if not tissue_mask.contains(Point(patch_center_x, patch_center_y)): + continue + + patches_inside_tissue += 1 + search_radius = patch_size + nearby_cells = { + cell_id: cell_data for cell_id, cell_data in cell_dict.items() + if (abs(cell_data['cell_centroid_x'] - patch_center_x) <= search_radius and + abs(cell_data['cell_centroid_y'] - patch_center_y) <= search_radius) + } + if len(nearby_cells) == 0: + continue + + #print(f" Processing patch {patch_barcode} with {len(nearby_cells)} nearby cells") + patch_img = crop_tile(wsi, patch_x, patch_y, patch_size) + patch_box = box(patch_x, patch_y, patch_x + patch_size, patch_y + patch_size) + cell_expressions = [] + cell_bboxes_adjusted = [] + cell_centroids_adjusted = [] + + cell_ids = [] + cell_ids_tagged = [] + + if not patch_box.is_valid: + patch_box = fix_invalid_geometry(patch_box) + if not patch_box.is_valid: + print(f" Patch {patch_barcode} has invalid geometry after fixing") + continue + + spot_radius = spot_diameter // 2 + spot = Point(patch_center_x, patch_center_y).buffer(spot_radius, cap_style=1) + + for cell_id, cell_data in nearby_cells.items(): + cell_shape = cell_data['cell_shape'] + cell_bounds = cell_data['cell_bounds'] + patch_bounds = patch_box.bounds # (minx, miny, maxx, maxy) + + # If theres no intersection at all skip + if (cell_bounds[2] < patch_bounds[0] or cell_bounds[0] > patch_bounds[2] or + cell_bounds[3] < patch_bounds[1] or cell_bounds[1] > patch_bounds[3]): + continue + + # If cell is fully contained in the patch accept it + if (cell_bounds[0] >= patch_bounds[0] and cell_bounds[2] <= patch_bounds[2] and + cell_bounds[1] >= patch_bounds[1] and cell_bounds[3] <= patch_bounds[3]): + #intersection = cell_shape + pass + else: + if cell_shape.intersects(patch_box): + intersection = cell_shape.intersection(patch_box) + if intersection.area / cell_data['area'] < 0.6: + continue + else: + continue + + # chek if cell is inside the spot + intersection_area = cell_shape.intersection(spot).area + if intersection_area / cell_shape.area >= 0.60: + cell_id_tagged = f"{cell_id}_in" + else: + cell_id_tagged = f"{cell_id}_out" + + cell_expressions.append(cell_data['cell_expression']) + cell_ids.append(cell_id) + cell_ids_tagged.append(cell_id_tagged) + cell_bbox_coords = cell_data['square_bbox_coords'] + # adjust and normalize the bounding box and centroid coordinates to the patch size + cell_bbox_adjusted_normalized = ( + (cell_bbox_coords[0] - patch_x) / patch_size, # normalized minx + (cell_bbox_coords[1] - patch_y) / patch_size, # normalized miny + (cell_bbox_coords[2] - patch_x) / patch_size, # normalized maxx + (cell_bbox_coords[3] - patch_y) / patch_size # normalized maxy + ) + cell_bboxes_adjusted.append(cell_bbox_adjusted_normalized) + cell_centroid_x = (cell_data['cell_centroid_x'] - patch_x) / patch_size + cell_centroid_y = (cell_data['cell_centroid_y'] - patch_y) / patch_size + cell_centroids_adjusted.append((cell_centroid_x, cell_centroid_y)) + + if len(cell_expressions) == 0: + continue + + cell_expressions = np.array(cell_expressions) + spot_expression = np.zeros(len(ordered_gene_names)) + for i, cell_id in enumerate(cell_ids_tagged): + if '_in' in cell_id: + spot_expression += cell_expressions[i] + + + spot_dict[patch_barcode] = { + #'patch_img': patch_img, + 'spot_expression': spot_expression, + #'patch_bounds': patch_box.bounds, # (minx, miny, maxx, maxy) + 'cell_ids': cell_ids_tagged, + 'cell_expressions': cell_expressions, + 'cell_bboxes_adjusted': cell_bboxes_adjusted, + 'cell_centroids_adjusted': cell_centroids_adjusted, + } + + spot_embeddings = get_spot_embs(patch_img, model, preprocess, device) + + # Save patch and cell embeddings + patch_embeddings = [spot_embeddings.astype(np.float16)] + for cell_id in cell_ids: + emb = cell_dict[cell_id]['cell_embedding'] + if torch.is_tensor(emb): + emb = emb.numpy() + patch_embeddings.append(emb.astype(np.float16)) + del cell_dict[cell_id]['cell_embedding'] + cell_dict[cell_id]['cell_embedding'] = None + patch_embeddings = np.vstack(patch_embeddings) + np.save(f'{data_folder}/embeddings{dataset_variant}/{model_name}/{patch_barcode}.npy', patch_embeddings) + + + elapsed = time.time() - patch_start_time + print(f" Completed patch processing: {patches_inside_tissue}/{total_patch_count} patches inside tissue in {elapsed:.1f} sec") + + print(f" Saving data for {len(spot_dict)} spots to HDF5 file...") + with h5py.File(f'{data_folder}/expressions{dataset_variant}/{sample_id}_expressions.h5', 'w') as f: + for patch_barcode, patch_data in spot_dict.items(): + spot_group = f.create_group(patch_barcode) + spot_group.attrs['spot_diameter'] = spot_diameter + spot_group.attrs['patch_size'] = patch_size + spot_group.attrs['um_per_px'] = um_per_px + spot_group.create_dataset('spot_expression', data=patch_data['spot_expression'], compression='gzip', compression_opts=4) + spot_group.create_dataset('cell_expressions', data=patch_data['cell_expressions'], compression='gzip', compression_opts=4) + cell_ids = np.array(patch_data['cell_ids'], dtype=h5py.string_dtype()) + spot_group.create_dataset('cell_ids', data=cell_ids) + spot_group.create_dataset('cell_centroids', data=np.array(patch_data['cell_centroids_adjusted'], dtype=np.float32), compression='gzip', compression_opts=4) + spot_group.create_dataset('cell_bbxs', data=np.array(patch_data['cell_bboxes_adjusted'], dtype=np.float32), compression='gzip', compression_opts=4) + print(f" Saved spot data to {data_folder}/expressions{dataset_variant}/{sample_id}_expressions.h5") + print(f" Processed {patches_inside_tissue} patches inside tissue ({patches_inside_tissue}/{total_patches} patches are within tissue)") + + del spot_dict, cell_dict + gc.collect() + + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Process slides for patch embeddings') + parser.add_argument('--config', type=str, default='experiments/config.yaml', help='Path to config file (default: experiments/config.yaml)') + parser.add_argument('--indices', type=int, nargs='+', help='List of specific indices to process') + parser.add_argument('--dataset', type=str, default='lung', help='Dataset to process (default: lung)') + args = parser.parse_args() + + sample_ids = [] + config = load_config(args.config) + config['dataset'] = args.dataset + data_folder = config['data']['data_folder'] + model_name = config['data']['model_name'] + model_path = config['data']['model_path'] + dataset_variant = config['data']['dataset_variant'] + sample_ids = config['data'][args.dataset]['train']['dataset_ids'] + config['data'][args.dataset]['ood']['dataset_ids'] + if args.indices: + sample_ids = [sample_ids[i] for i in args.indices] + + vram_bytes = torch.cuda.get_device_properties(0).total_memory + vram_gb = vram_bytes / (1024**3) + batch_size = int(vram_gb * 32 / 14) if vram_gb > 13 else 16 + print(f"Auto-configured batch size to {batch_size} based on {vram_gb:.1f}GB VRAM") + + model, preprocess, feature_dim = get_morphology_model_and_preprocess(model_name, 'cuda', model_path=model_path) + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + model.to(device) + + os.makedirs(f'{data_folder}/embeddings{dataset_variant}/', exist_ok=True) + os.makedirs(f'{data_folder}/embeddings{dataset_variant}/{model_name}', exist_ok=True) + os.makedirs(f'{data_folder}/expressions{dataset_variant}', exist_ok=True) + + for i, st in enumerate(iter_hest(data_folder, id_list=sample_ids, load_transcripts=True)): + sample_id = sample_ids[i] + process_sample(sample_id, st, model, preprocess, device, batch_size, config) \ No newline at end of file diff --git a/deepspot/deepspot2cell/loss.py b/deepspot/deepspot2cell/loss.py new file mode 100644 index 0000000..c763995 --- /dev/null +++ b/deepspot/deepspot2cell/loss.py @@ -0,0 +1,48 @@ +import torch +from torchmetrics.functional import pearson_corrcoef + + +def mse(pred, target): + return torch.nn.functional.mse_loss(pred, target) + + +def pearsonr(pred, target, eps = 1e-8): + y_pred_centered = pred - torch.mean(pred, dim=0) + y_true_centered = target - torch.mean(target, dim=0) + + covariance = torch.sum(y_pred_centered * y_true_centered, dim=0) + std_pred = torch.sqrt(torch.sum(y_pred_centered ** 2, dim=0) + eps) + std_true = torch.sqrt(torch.sum(y_true_centered ** 2, dim=0) + eps) + + pearson_corr = covariance / (std_pred * std_true) + return torch.mean(1 - pearson_corr) + + +def pearson_mse(pred, target): + return (pearsonr(pred, target) + mse(pred, target)) + + +class wmse(torch.nn.Module): + """MSE with each gene j is weighted by f(rank_j).""" + def __init__(self, n_genes, upweight_hvg=True, power=0.1, device=None, dtype=torch.float32): + super().__init__() + + if upweight_hvg: + ranks = torch.arange(n_genes, 0, step=-1, device=device, dtype=dtype) + else: + ranks = torch.arange(1, n_genes + 1, device=device, dtype=dtype) + weights = 1.0 / (ranks.float() ** power) + weights = weights * n_genes / weights.sum() + self.register_buffer("weights", weights) + + def forward(self, pred, target): + loss = self.weights * (pred - target) ** 2 + return loss.mean() + + +def safe_pearson(pred, target, sample_wise = False): + """Torch-native Pearson along feature-dim (or sample-wise after transpose).""" + if sample_wise: + pred, target = pred.T, target.T + r = pearson_corrcoef(pred, target) + return torch.nan_to_num(r, nan=0.0) \ No newline at end of file diff --git a/deepspot/deepspot2cell/model.py b/deepspot/deepspot2cell/model.py new file mode 100644 index 0000000..54c9a7a --- /dev/null +++ b/deepspot/deepspot2cell/model.py @@ -0,0 +1,280 @@ +from torch import nn +import torch +import numpy as np +import lightning as L +from typing import Union, Dict + +from deepspot.deepspot2cell.loss import mse, safe_pearson +from deepspot.utils.utils import fix_seed + + +class Phi(nn.Module): + def __init__(self, input_size: int, output_size: int, p: float = 0.0): + super().__init__() + self.model = nn.Sequential( + nn.Linear(input_size, input_size), + nn.Dropout(p=p), + nn.ReLU(inplace=True), + nn.Linear(input_size, output_size), + nn.Dropout(p=p), + nn.ReLU(inplace=True), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.model(x) + + +class Rho(nn.Module): + def __init__(self, input_size: int, output_size: int, p: float = 0.0): + super().__init__() + self.model = nn.Sequential( + nn.Dropout(p=p), + nn.Linear(input_size, input_size), + nn.ReLU(inplace=True), + nn.Linear(input_size, output_size), + nn.ReLU(inplace=True), + nn.Dropout(p=0.1), + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.model(x) + + +class DeepSpot2Cell(L.LightningModule): + def __init__(self, input_size: int, output_size: int, lr: float = 1e-4, + p: float = 0.3, p_phi: Union[None, float] = None, + p_rho: Union[None, float] = None, n_ensemble: int = 10, + n_ensemble_phi: Union[None, int] = None, + n_ensemble_rho: Union[None, int] = None, phi2rho_size: int = 512, + weight_decay: float = 1e-6, random_seed: int = 2024, cell_gt_available = True): + super().__init__() + + self.save_hyperparameters() + fix_seed(random_seed) + + self.model_name = f"deepspot2cell" + self.p_phi = p_phi or p + self.p_rho = p_rho or p + self.n_ensemble_phi = n_ensemble_phi or n_ensemble + self.n_ensemble_rho = n_ensemble_rho or n_ensemble + self.loss_fn = mse + + self.train_batch_losses = [] + self.train_cell_inside_preds = [] + self.train_cell_inside_targets = [] + self.train_cell_outside_preds = [] + self.train_cell_outside_targets = [] + + self.val_batch_losses = [] + self.val_cell_inside_preds = [] + self.val_cell_inside_targets = [] + self.val_cell_outside_preds = [] + self.val_cell_outside_targets = [] + + mult = 3 + self.phi_spot = nn.ModuleList([Phi(input_size, phi2rho_size, self.p_phi) + for _ in range(self.n_ensemble_phi)]) + self.phi_cell = nn.ModuleList([Phi(input_size, phi2rho_size, self.p_phi) + for _ in range(self.n_ensemble_phi)]) + self.rho = nn.ModuleList([Rho(phi2rho_size * mult, output_size, self.p_rho) + for _ in range(self.n_ensemble_rho)]) + + self.cell_gt_available = cell_gt_available + + def forward(self, x, mask, context, context_mask): + return self._forward_superspot(x, mask, context, context_mask) + + + def _forward_single_cell(self, x, context, context_mask): + x = x.unsqueeze(0) if x.dim() == 1 else x + n_cells, d_cell_emb = x.shape + phi_cells = self._apply_phi_cell(x) + + phi_context_spot_own = self._apply_phi(context[0].unsqueeze(0)) + + neighbor_contexts = context[1:, :] + neighbor_masks = context_mask[1:] + d_ctx_emb = neighbor_contexts.shape[-1] + phi_neighbor_contexts = self._apply_phi( + neighbor_contexts.reshape(-1, d_ctx_emb) + ).view(neighbor_contexts.shape[0], self.hparams.phi2rho_size) + phi_neighbor_contexts_masked_for_sum = phi_neighbor_contexts.masked_fill( + neighbor_masks.unsqueeze(-1), 0.0 + ) + sum_phi_neighbor_contexts = phi_neighbor_contexts_masked_for_sum.sum(dim=0, keepdim=True) + num_valid_neighbors = (~neighbor_masks).sum(dim=0, keepdim=True).float().clamp(min=1) + mean_phi_neighbor_contexts = sum_phi_neighbor_contexts / num_valid_neighbors + + phi_context_spot_own_expanded = phi_context_spot_own.expand(n_cells, -1) + mean_phi_neighbor_contexts_expanded = mean_phi_neighbor_contexts.expand(n_cells, -1) + + concatenated_features = torch.cat([phi_cells, phi_context_spot_own_expanded, mean_phi_neighbor_contexts_expanded], dim=1) + return self._apply_rho(concatenated_features) + + def _forward_superspot(self, x, mask=None, context=None, context_mask=None): + b, c, d_cell_emb = x.shape + _b_ctx, n_total_ctx, d_ctx_emb = context.shape + + phi_cells = self._apply_phi_cell(x.view(-1, d_cell_emb)).view(b, c, -1) + phi_context_spot_own = self._apply_phi(context[:, 0, :]) + + neighbor_contexts = context[:, 1:, :] + neighbor_masks = context_mask[:, 1:] + + phi_neighbor_contexts_flat = self._apply_phi(neighbor_contexts.reshape(-1, d_ctx_emb)) + phi_neighbor_contexts = phi_neighbor_contexts_flat.view(b, n_total_ctx - 1, self.hparams.phi2rho_size) + phi_neighbor_contexts_masked_for_sum = phi_neighbor_contexts.masked_fill(neighbor_masks.unsqueeze(-1), 0.0) + sum_phi_neighbor_contexts = phi_neighbor_contexts_masked_for_sum.sum(dim=1) + num_valid_neighbors = (~neighbor_masks).sum(dim=1, keepdim=True).float().clamp(min=1) + mean_phi_neighbor_contexts = sum_phi_neighbor_contexts / num_valid_neighbors + + phi_context_spot_own_expanded = phi_context_spot_own.unsqueeze(1).expand(-1, c, -1) + mean_phi_neighbor_contexts_expanded = mean_phi_neighbor_contexts.unsqueeze(1).expand(-1, c, -1) + concatenated_per_cell = torch.cat([phi_cells, phi_context_spot_own_expanded, mean_phi_neighbor_contexts_expanded], dim=2) + concatenated_per_cell = concatenated_per_cell * mask.unsqueeze(-1) + aggregated_features = concatenated_per_cell.sum(dim=1) + + return self._apply_rho(aggregated_features) + + def _apply_phi(self, x): + return torch.median(torch.stack([p(x) for p in self.phi_spot], 1), 1).values + + def _apply_phi_cell(self, x): + return torch.median(torch.stack([p(x) for p in self.phi_cell], 1), 1).values + + def _apply_rho(self, x): + return torch.stack([r(x) for r in self.rho], 1).mean(1) + + def training_step(self, batch: Dict, batch_idx: int): + cell_emb = batch['cell_embeddings'].float() + spot_true = batch['spot_expression'].float() + if self.cell_gt_available: + cell_true = batch['cell_expressions'].float() + mask = batch['cell_mask'].float() + context = batch['neighb_embeddings'].float() + context_mask = batch['neighb_masks'].bool() + + # pass only cells that are inside the spot: make outside cells zero + is_inside = batch['is_inside_spot'].float() + cell_emb_masked = cell_emb * is_inside.unsqueeze(-1) + mask_inspot = mask * is_inside + + pred = self(cell_emb_masked, mask_inspot, context, context_mask) + loss = self.loss_fn(pred, spot_true) + + self.log('train_loss', loss, on_epoch=True, prog_bar=True) + self.train_batch_losses.append(loss.item()) + + # Compute cell-level predictions for training metrics if ground truth available + if self.cell_gt_available: + for b in range(cell_emb.size(0)): + valid = mask[b] > 0 + if valid.any(): + spot_context = context[b] + spot_context_mask = context_mask[b] + + cell_preds = self._forward_single_cell(cell_emb[b, valid], spot_context, spot_context_mask).clamp_(min=0.0) + cell_targets = cell_true[b, valid] + is_inside_batch = is_inside[b, valid] + + # Separate inside and outside cells + inside_mask = is_inside_batch > 0 + outside_mask = is_inside_batch == 0 + + if inside_mask.any(): + self.train_cell_inside_preds.append(cell_preds[inside_mask]) + self.train_cell_inside_targets.append(cell_targets[inside_mask]) + + if outside_mask.any(): + self.train_cell_outside_preds.append(cell_preds[outside_mask]) + self.train_cell_outside_targets.append(cell_targets[outside_mask]) + + return loss + + + def validation_step(self, batch: Dict, batch_idx: int): + cell_emb = batch['cell_embeddings'].float() + spot_true = batch['spot_expression'].float() + if self.cell_gt_available: + cell_true = batch['cell_expressions'].float() + mask = batch['cell_mask'].float() + context = batch['neighb_embeddings'].float() + context_mask = batch['neighb_masks'].bool() + is_inside = batch['is_inside_spot'].float() + mask_inspot = mask * is_inside # mask out outside cells + + spot_pred = self(cell_emb * is_inside.unsqueeze(-1), mask_inspot, context, context_mask).clamp_(min=0.0) + loss = self.loss_fn(spot_pred, spot_true) + self.log('val_loss', loss, on_epoch=True, prog_bar=True) + self.val_batch_losses.append(loss.item()) + + if self.cell_gt_available: + for b in range(cell_emb.size(0)): + valid = mask[b] > 0 + if valid.any(): + spot_context = context[b] + spot_context_mask = context_mask[b] + + cell_preds = self._forward_single_cell(cell_emb[b, valid], spot_context, spot_context_mask).clamp_(min=0.0) + cell_targets = cell_true[b, valid] + is_inside_batch = is_inside[b, valid] + + # Separate inside and outside cells + inside_mask = is_inside_batch > 0 + outside_mask = is_inside_batch == 0 + + if inside_mask.any(): + self.val_cell_inside_preds.append(cell_preds[inside_mask]) + self.val_cell_inside_targets.append(cell_targets[inside_mask]) + + if outside_mask.any(): + self.val_cell_outside_preds.append(cell_preds[outside_mask]) + self.val_cell_outside_targets.append(cell_targets[outside_mask]) + + return loss + + def on_train_epoch_end(self): + if self.cell_gt_available: + # Compute cell pearson correlations for inside cells + if self.train_cell_inside_preds: + all_preds = torch.cat(self.train_cell_inside_preds, dim=0) + all_targets = torch.cat(self.train_cell_inside_targets, dim=0) + pearson = safe_pearson(all_preds, all_targets) + self.log('train_cell_inside_pearson', pearson.mean(), prog_bar=True) + + # Compute cell pearson correlations for outside cells + if self.train_cell_outside_preds: + all_preds = torch.cat(self.train_cell_outside_preds, dim=0) + all_targets = torch.cat(self.train_cell_outside_targets, dim=0) + pearson = safe_pearson(all_preds, all_targets) + self.log('train_cell_outside_pearson', pearson.mean(), prog_bar=True) + + self.train_cell_inside_preds.clear() + self.train_cell_inside_targets.clear() + self.train_cell_outside_preds.clear() + self.train_cell_outside_targets.clear() + + def on_validation_epoch_end(self): + if self.cell_gt_available: + # Compute cell pearson correlations for inside cells + if self.val_cell_inside_preds: + all_preds = torch.cat(self.val_cell_inside_preds, dim=0) + all_targets = torch.cat(self.val_cell_inside_targets, dim=0) + pearson = safe_pearson(all_preds, all_targets) + self.log('val_cell_inside_pearson', pearson.mean(), prog_bar=True) + + # Compute cell pearson correlations for outside cells + if self.val_cell_outside_preds: + all_preds = torch.cat(self.val_cell_outside_preds, dim=0) + all_targets = torch.cat(self.val_cell_outside_targets, dim=0) + pearson = safe_pearson(all_preds, all_targets) + self.log('val_cell_outside_pearson', pearson.mean(), prog_bar=True) + + self.val_cell_inside_preds.clear() + self.val_cell_inside_targets.clear() + self.val_cell_outside_preds.clear() + self.val_cell_outside_targets.clear() + + def configure_optimizers(self) -> dict: + optimizer = torch.optim.AdamW(self.parameters(), lr=self.lr, weight_decay=self.weight_decay) + return {"optimizer": optimizer} \ No newline at end of file diff --git a/deepspot/utils/__init__.py b/deepspot/utils/__init__.py index e69de29..bafc1e1 100644 --- a/deepspot/utils/__init__.py +++ b/deepspot/utils/__init__.py @@ -0,0 +1,3 @@ +from .utils import fix_seed, load_config, order_genes +from .utils_image import get_morphology_model_and_preprocess, format_to_dtype, predict_spot2cell_from_image_paths +from .utils_dataloader import * \ No newline at end of file diff --git a/deepspot/utils/utils.py b/deepspot/utils/utils.py index e6a204f..5bff5b3 100644 --- a/deepspot/utils/utils.py +++ b/deepspot/utils/utils.py @@ -15,6 +15,9 @@ import pandas as pd import numpy as np from sklearn.preprocessing import StandardScaler +import yaml +import json +from hest import iter_hest def model_fine_tune(model, dataloader, rho=False, gene_expression=True, max_epochs=10): @@ -98,3 +101,99 @@ def fix_seed(seed): os.environ['PYTHONHASHSEED'] = str(seed) os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8' + + +def load_config(config_path): + with open(config_path, 'r') as file: + config = yaml.safe_load(file) + return config + + +def order_genes(config): + """Order genes by variability across samples.""" + data_folder = config['data']['data_folder'] + nc_min = config.get('min_cells', 20) + qv_min = config.get('qv_thr', 20) + dataset = config['data']['dataset'] + sample_ids = config['data'][dataset]['train']['dataset_ids'] + + all_genes = set() + all_sample_filtered_genes = [] + all_cell_expressions = [] + gene_to_idx_map = {} + + for i, st in enumerate(iter_hest(data_folder, id_list=sample_ids, load_transcripts=True)): + sample_id = sample_ids[i] + print(f" Sample {i+1}/{len(sample_ids)}: {sample_id}") + + adata = st.adata + all_genes.update(adata.var_names) + + transcript_df = st.transcript_df + if transcript_df is None or transcript_df.empty: + print(f" No transcript data available. Skipping.") + all_sample_filtered_genes.append(set()) + continue + + print(f" Filtering transcripts: QV > {qv_min}") + transcript_df['qv'] = pd.to_numeric(transcript_df['qv'], errors='coerce') + df_qv_filtered = transcript_df[transcript_df['qv'] > qv_min] + + df_cell_filtered = df_qv_filtered[ + ~df_qv_filtered['cell_id'].isin(['UNASSIGNED', -1]) & + df_qv_filtered['cell_id'].notna() + ] + + if df_cell_filtered.empty: + print(f" No valid transcripts after filtering. Skipping.") + all_sample_filtered_genes.append(set()) + continue + + # Count cells per gene + gene_cell_counts = df_cell_filtered.groupby('feature_name')['cell_id'].nunique() + filtered_genes = set(gene_cell_counts[gene_cell_counts >= nc_min].index) + all_sample_filtered_genes.append(filtered_genes) + + print(f" Found {len(filtered_genes)} genes present in ≥{nc_min} cells with QV>{qv_min}") + + for cell_id, cell_data in df_cell_filtered.groupby('cell_id'): + gene_counts = cell_data.groupby('feature_name').size().to_dict() + all_cell_expressions.append((gene_counts, sample_id)) + + if all_sample_filtered_genes: + quality_filtered_genes = set.intersection(*all_sample_filtered_genes) + print(f"\n Found {len(quality_filtered_genes)} genes passing quality filters in ALL samples") + else: + quality_filtered_genes = set() + print("\n No genes passed quality filters across all samples") + + print(" Calculating gene variability...") + gene_list = sorted(list(quality_filtered_genes)) + gene_to_idx_map = {gene: idx for idx, gene in enumerate(gene_list)} + expression_matrix = [] + + for gene_counts, sample_id in all_cell_expressions: + gene_expression = np.zeros(len(gene_list)) + for gene_name, count in gene_counts.items(): + if gene_name in gene_to_idx_map: + gene_expression[gene_to_idx_map[gene_name]] = count + + expression_matrix.append(gene_expression) + + if not expression_matrix: + print(" No expression data available after filtering. Cannot order genes.") + return [] + + print(f" Creating AnnData with {len(expression_matrix)} cells and {len(gene_list)} genes") + combined_adata = ad.AnnData(X=np.vstack(expression_matrix), var=pd.DataFrame(index=gene_list)) + + print(" Calculating gene variability...") + sc.pp.highly_variable_genes(combined_adata, flavor='seurat_v3') + idx = combined_adata.var['highly_variable_rank'].argsort() + combined_adata = combined_adata[:, idx] + ordered_gene_names = combined_adata.var_names.tolist() + + ordered_genes_path = f"{data_folder}/{config['data'][dataset]['ordered_genes_file']}" + with open(ordered_genes_path, 'w') as f: + json.dump(ordered_gene_names, f, indent=2) + print(f" Saving ordered genes to {ordered_genes_path}") diff --git a/deepspot/utils/utils_image.py b/deepspot/utils/utils_image.py index fd9046b..de790bf 100644 --- a/deepspot/utils/utils_image.py +++ b/deepspot/utils/utils_image.py @@ -2,7 +2,7 @@ from torchvision.models import resnet50, ResNet50_Weights from torchvision.models import densenet121, DenseNet121_Weights from huggingface_hub import login, hf_hub_download -from transformers import AutoImageProcessor, ViTModel +from transformers import AutoImageProcessor, AutoModel, ViTModel from collections import OrderedDict from torchvision import transforms import torch.nn.functional as F @@ -44,7 +44,7 @@ def get_morphology_model_and_preprocess(model_name, device, model_path=None): init_values=1e-5, num_classes=0, dynamic_img_size=True) - morphology_model.load_state_dict(torch.load(model_path, map_location=device), strict=True) + morphology_model.load_state_dict(torch.load(model_path, map_location=device, weights_only=True), strict=True) morphology_model.eval() preprocess = transforms.Compose( @@ -65,7 +65,7 @@ def get_morphology_model_and_preprocess(model_name, device, model_path=None): num_classes=0, dynamic_img_size=True ) - morphology_model.load_state_dict(torch.load(model_path, map_location=device), strict=True) + morphology_model.load_state_dict(torch.load(model_path, map_location=device, weights_only=True), strict=True) morphology_model.eval() preprocess = transforms.Compose([ @@ -124,6 +124,11 @@ def forward(self, x): x = self.model(x) x = x.last_hidden_state[:, 0, :] return x + + def forward_features(self, x): + with torch.no_grad(): + x = self.model(x) + return x.last_hidden_state preprocess = image_processor_edit morphology_model = MyModel(model) @@ -354,3 +359,99 @@ def predict_cell_spatial_transcriptomics_from_image_path(image_path, counts.append(expr) counts = np.array(counts).squeeze() return counts + + +def predict_spot2cell_from_image_paths(cell_image_path, + spot_image_path, + neighbor_image_paths, + deepspot2cell_model, + morphology_model, + preprocess, + device, + gene_names=None): + """ + Predict single-cell gene expression using DeepSpot2Cell from individual image paths. + + This function is designed for DeepSpot2Cell inference where you have: + - Individual cell image + - Spot image containing the cell + - Neighbor images from the same context + + Args: + cell_image_path (str): Path to the target cell image + spot_image_path (str): Path to the spot image containing the cell + neighbor_image_paths (list): List of paths to neighboring images + deepspot2cell_model: Trained DeepSpot2Cell model + morphology_model: Morphology foundation model (e.g., PhikonV2) + preprocess: Preprocessing function for the morphology model + device (str): Device to run inference on ('cuda' or 'cpu') + gene_names (list, optional): List of gene names for result mapping + + Returns: + dict: Dictionary mapping gene names/indices to predicted expression values + """ + from PIL import Image + import os + + def extract_embedding(image_path, morphology_model, preprocess, device): + """Extract embedding from a single image path.""" + image = Image.open(image_path) + + # Ensure square image + if image.width != image.height: + size = max(image.width, image.height) + image = image.resize((size, size)) + + image_tensor = preprocess(image).to(device).unsqueeze(0) + + with torch.no_grad(): + embedding = morphology_model(image_tensor).cpu().numpy() + + return embedding + + # Extract cell embedding + cell_embedding = extract_embedding(cell_image_path, morphology_model, preprocess, device) + cell_embedding_tensor = torch.tensor(cell_embedding, device=device, dtype=torch.float32) + + # Extract spot embedding + spot_embedding = extract_embedding(spot_image_path, morphology_model, preprocess, device) + spot_embedding_tensor = torch.tensor(spot_embedding, device=device, dtype=torch.float32) + + # Extract neighbor embeddings + neighbor_embeddings = [] + for neighbor_path in neighbor_image_paths: + if os.path.exists(neighbor_path): + neighbor_emb = extract_embedding(neighbor_path, morphology_model, preprocess, device) + neighbor_embeddings.append(torch.tensor(neighbor_emb, device=device, dtype=torch.float32)) + else: + # Create zero embedding for missing neighbors + neighbor_embeddings.append(torch.zeros_like(spot_embedding_tensor)) + + # Create context (spot + neighbors) + context_embeddings = [spot_embedding_tensor] + neighbor_embeddings + context = torch.cat(context_embeddings, dim=0) + + # Create context mask (False for valid embeddings, True for missing) + context_mask = [False] # Spot is always present + context_mask.extend([not os.path.exists(path) for path in neighbor_image_paths]) + context_mask = torch.tensor(context_mask, device=device) + + # Predict gene expression + with torch.no_grad(): + predicted_expression = deepspot2cell_model._forward_single_cell( + cell_embedding_tensor, + context, + context_mask + ) + predicted_expression_np = predicted_expression.cpu().numpy() + + # Format results + results = {} + if gene_names and len(gene_names) == predicted_expression_np.shape[-1]: + for i, gene in enumerate(gene_names): + results[gene] = float(predicted_expression_np[0, i]) + else: + for i in range(predicted_expression_np.shape[-1]): + results[f"gene_{i}"] = float(predicted_expression_np[0, i]) + + return results diff --git a/environment.yaml b/environment.yaml index 72a52e1..00aa677 100644 --- a/environment.yaml +++ b/environment.yaml @@ -4,6 +4,7 @@ channels: - conda-forge - pytorch - nvidia + dependencies: - python==3.9 - pip @@ -18,16 +19,22 @@ dependencies: - scanpy - squidpy - matplotlib - - torchvision - pyvips - scikit-learn - - pyvips - lightning - pip: - - plotnine - - ipykernel - - huggingface_hub - - transformers - - timm - - scikit-misc + - plotnine + - ipykernel + - huggingface_hub + - transformers + - timm + - scikit-misc + - torchmetrics + - h5py + - pyyaml + - shapely + - opencv-python + - pillow + - tqdm + - hest diff --git a/example_notebook/README.md b/example_notebook/README.md index 7cfee26..e3b31f8 100644 --- a/example_notebook/README.md +++ b/example_notebook/README.md @@ -1,5 +1,12 @@ -## Should I use DeepSpot or the adapted version of DeepSpot - DeepCell? +## Which DeepSpot module should I use? -`Visium_spot_example` contains a tutorial on how to apply DeepSpot to spatial transcriptomics data generated with Visium at **spot-level resolution**. +DeepSpot provides three main modules for different spatial transcriptomics applications: -`Xenium_single-cell_example` contains a tutorial on how to apply the adapted version of DeepSpot - DeepCell, to spatial transcriptomics data generated with Xenium at **single-cell resolution**. \ No newline at end of file +### `Visium_spot_example` - DeepSpot for Spot-level Resolution +Contains a tutorial on how to apply DeepSpot to spatial transcriptomics data generated with Visium at **spot-level resolution**. + +### `Xenium_single-cell_example` - DeepCell for Single-cell Resolution +Contains a tutorial on how to apply the adapted version of DeepSpot - DeepCell, to spatial transcriptomics data generated with Xenium at **single-cell resolution**. + +### `Visium_to_Xenium_spot2cell_example` - DeepSpot2Cell for Visium deconvolution +Contains a tutorial on how to apply DeepSpot2Cell to **deconvolve spot-level resolution** Visium data into Xenium-like single-cell resolution. \ No newline at end of file diff --git a/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_1_preprocessing.ipynb b/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_1_preprocessing.ipynb new file mode 100644 index 0000000..016f2bc --- /dev/null +++ b/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_1_preprocessing.ipynb @@ -0,0 +1,149 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "04790142", + "metadata": {}, + "source": [ + "# DeepSpot2Cell Data Preprocessing\n", + "\n", + "This notebook shows how to prepare data for DeepSpot2Cell training by:\n", + "- Loading HEST datasets\n", + "- Extracting morphology features from histological images\n", + "- Processing spot-level expression data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bad1a6c", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.chdir('../../')\n", + "\n", + "from deepspot.deepspot2cell.dataset_creation import process_sample\n", + "from deepspot.utils.utils_image import get_morphology_model_and_preprocess\n", + "from hest import iter_hest\n", + "from tqdm import tqdm\n", + "import torch\n", + "\n", + "dataset_variant = 22\n", + "data_folder = \"hest_data\"\n", + "model_name = \"phikonv2\"\n", + "model_path = \"/path/to/your/pathology_models/phikon-v2/snapshots/93276a02a78253429f566882de5302867f747394\"\n", + "samples_to_process = [\"NCBI864\", \"NCBI873\", \"NCBI856\", \"NCBI860\", \"NCBI858\"]\n", + "batch_size = 32\n", + "\n", + "config = {\n", + " 'data': {\n", + " 'data_folder': data_folder,\n", + " 'dataset_variant': dataset_variant,\n", + " 'spot_diameter_px': 160,\n", + " 'patch_size_px': 224,\n", + " 'qv_threshold': 20,\n", + " 'min_cells_per_gene': 20\n", + " }\n", + "}\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model, preprocess, _ = get_morphology_model_and_preprocess(model_name, device, model_path=model_path)\n", + "\n", + "os.makedirs(f'{data_folder}/embeddings{dataset_variant}/{model_name}', exist_ok=True)\n", + "os.makedirs(f'{data_folder}/expressions{dataset_variant}', exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "110ecf00", + "metadata": {}, + "outputs": [], + "source": [ + "for i, st in enumerate(tqdm(iter_hest(data_folder, id_list=samples_to_process, load_transcripts=True), \n", + " desc=\"Processing samples\", total=len(samples_to_process))):\n", + " sample_id = samples_to_process[i]\n", + " process_sample(sample_id, st, model, preprocess, device, batch_size, config)" + ] + }, + { + "cell_type": "markdown", + "id": "2cfca82e", + "metadata": {}, + "source": [ + "## Same, but with a script and config file\n", + "\n", + "For large datasets, use the preprocessing script:\n", + "\n", + "```bash\n", + "cd /path/to/DeepSpot\n", + "python -m deepspot.deepspot2cell.dataset_creation --config config.yaml\n", + "```\n", + "\n", + "> Please note that this script is GPU-only.\n", + "\n", + "Example config file:\n", + "```yaml\n", + "data:\n", + " dataset_variant: 22\n", + " spot_diameter_px: 160\n", + " patch_size_px: 224\n", + " data_folder: hest_data\n", + " model_name: phikonv2\n", + " model_path: /path/to/pathology_models/phikon-v2/snapshots/93276a02a78253429f566882de5302867f747394\n", + " val_fraction: 0.2\n", + " qv_thr: 20\n", + " min_cells: 20\n", + "\n", + " lung:\n", + " short_name: Lung Cancer\n", + " train:\n", + " dataset_ids:\n", + " - NCBI864\n", + " - NCBI873\n", + " - NCBI856\n", + " - NCBI860\n", + " - NCBI858\n", + " - NCBI881\n", + " - NCBI866\n", + " - NCBI859\n", + " - NCBI884\n", + " - NCBI867\n", + " - NCBI875\n", + " - NCBI879\n", + " - NCBI883\n", + " - NCBI870\n", + " - NCBI861\n", + " - NCBI876\n", + " - NCBI880\n", + " - NCBI882\n", + " - NCBI865\n", + " - NCBI857\n", + " ood:\n", + " dataset_ids:\n", + " - TENX118\n", + " - TENX141\n", + " ordered_genes_file: filtered_ordered_genes_lung.json\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "ad8cbaac", + "metadata": {}, + "source": [ + "## Cell segmentation\n", + "\n", + "HEST-1k dataset comes with cell segmentations obtained using CellViT. If your dataset does not have cell segmentations, you can refer to the [CellViT documentation](https://tio-ikim.github.io/CellViT-Inference/usage.html) for instructions on how to obtain them." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_2_training.ipynb b/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_2_training.ipynb new file mode 100644 index 0000000..d0bb47d --- /dev/null +++ b/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_2_training.ipynb @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "af0836fd", + "metadata": {}, + "source": [ + "# Training DeepSpot2Cell\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e66da9d", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import lightning as L\n", + "\n", + "from deepspot.deepspot2cell import DS2CDataset, DeepSpot2Cell\n", + "\n", + "\n", + "morphology_model = \"phikonv2\"\n", + "batch_size = 256\n", + "max_epochs = 400\n", + "num_workers = 4\n", + "save_dir = \"results\"\n", + "\n", + "data_folder = \"hest_data\"\n", + "dataset_variant = 22\n", + "train_ids = [\"NCBI864\", \"NCBI873\", \"NCBI856\", \"NCBI860\"]\n", + "val_ids = [\"NCBI865\", \"NCBI857\"]\n", + "\n", + "\n", + "train_dataset = DS2CDataset(\n", + " dataset_variant=dataset_variant,\n", + " ids_list=train_ids,\n", + " data_path=data_folder,\n", + " model_name=morphology_model,\n", + " shuffle=True,\n", + " normalize=True,\n", + " neighb_degree=1,\n", + ")\n", + "val_dataset = DS2CDataset(\n", + " dataset_variant=dataset_variant,\n", + " ids_list=val_ids,\n", + " data_path=data_folder,\n", + " model_name=morphology_model,\n", + " shuffle=False,\n", + " normalize=True,\n", + " neighb_degree=1,\n", + ")\n", + "\n", + "train_loader = torch.utils.data.DataLoader(\n", + " train_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + " num_workers=num_workers,\n", + " pin_memory=True\n", + ")\n", + "\n", + "val_loader = torch.utils.data.DataLoader(\n", + " val_dataset,\n", + " batch_size=batch_size,\n", + " shuffle=False,\n", + " num_workers=num_workers,\n", + " pin_memory=True\n", + ")\n", + "\n", + "sample_batch = next(iter(train_loader))\n", + "input_size = sample_batch['cell_embeddings'].shape[-1]\n", + "output_size = sample_batch['spot_expression'].shape[-1]\n", + "print(f\"Sample Batch: Input size: {input_size}, Output size: {output_size}\")\n", + "\n", + "model = DeepSpot2Cell(input_size=input_size, output_size=output_size)\n", + "\n", + "trainer = L.Trainer(\n", + " max_epochs=max_epochs,\n", + " accelerator='auto',\n", + " devices=1,\n", + " logger=True\n", + ")\n", + "\n", + "trainer.fit(model, train_loader, val_loader)" + ] + }, + { + "cell_type": "markdown", + "id": "df49f631", + "metadata": {}, + "source": [ + "Save the weights, display the metrics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0fda3610", + "metadata": {}, + "outputs": [], + "source": [ + "os.makedirs(save_dir, exist_ok=True)\n", + "model_save_path = f\"{save_dir}/final_model.pt\"\n", + "torch.save(model.state_dict(), model_save_path)\n", + "print(f\"Model saved at {model_save_path}\")\n", + "\n", + "trainer_logs = trainer.logged_metrics\n", + "available_metrics = {}\n", + "for key, value in trainer_logs.items():\n", + " if isinstance(value, torch.Tensor):\n", + " available_metrics[key] = value.item()\n", + " else:\n", + " available_metrics[key] = value\n", + "\n", + "print(\"Available metrics:\")\n", + "for key, value in available_metrics.items():\n", + " print(f\" {key}: {value}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_3_inference.ipynb b/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_3_inference.ipynb new file mode 100644 index 0000000..fd5b261 --- /dev/null +++ b/example_notebook/Visium_to_Xenium_spot2cell_example/GettingStartedWithDeepSpot2Cell_3_inference.ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4ffba161", + "metadata": {}, + "source": [ + "# Inference of DeepSpot2Cell on H&E Images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3bdf259", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcoAAAH4CAYAAADKLq16AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvQe4JOlV3n+qqqs6p5vvpE3SSkhCJAMmGxNtMAZMMjZgcsYEg3HgD5gMJmcwBmxsHptkkjFgjMk5CCQE0qbZyTd0TpX/z+/9uofZ1WhXKw1Ctu+nZ7S7d/p2V1d93wnvec97vLIsSztbZ+tsna2zdbbO1l2Xf/cfn62zdbbO1tk6W2eLdeYoz9bZOltn62ydrWdYZ47ybJ2ts3W2ztbZeoZ15ijP1tk6W2frbJ2tZ1hnjvJsna2zdbbO1tl6hnXmKM/W2TpbZ+tsna1nWGeO8mydrbN1ts7W2XqGdeYoz9bZOltn62ydrWdYZ47ybJ2ts3W2ztbZeoZ15ijP1tlar/vvv9/+yT/5J6/za9///d/f3lTW//7f/9s8z9M/X9/f/dEf/dFnfe3f+lt/y17ykpe8nlf5f99iv7AX3pjrB37gB/S8nnjiiac8F/482+L3PuMzPuOv+Ar/71tvMo7yT//0T+1DPuRD7L777rNarWbnz5+393qv97Jv/dZv/Sv93D/7sz+zL/mSL3nKpnum9Uu/9Ev2cR/3cfbwww9bo9GwBx980D7hEz7Bbty48ZTXLRYL+/Zv/3Z77/d+bzs8PLR2u21v9VZvZd/5nd9peZ4/5bV//ud/bl/wBV9gb/mWb6nX8fr3e7/3s9///d+3N+X1n//zf7Zv+qZv+iv/nOf6jP5P/9yzdbbO1pvWepNwlL/5m79pf+Nv/A172cteZp/4iZ9o3/Zt3ybn4/u+ffM3f/NfuTH80i/90tfZGP7zf/7PFYF/0Ad9kH3Lt3yLfcRHfIT91//6X+UEb968eft1jz32mH3mZ36mIaX7uZ/7ufZv/+2/tQceeMA+7dM+TY72zvXv/t2/s+/93u/VPfj6r/96vf4v/uIv7G/+zb9p//N//k97U11vTEf5XJ7R67u45zyHN/bn3ov1ru/6rrZcLvXPs3W2zta9XRV7E1hf8RVfYd1u137v937Per3eU/7u6OjI3pTWN3zDN9g7v/M7y4lv1vu+7/vau73bu8nBf/mXf7l+dnBwoCz5xS9+8e3XffInf7Kc5Pd///fbF33RF9nznvc8/fwf/sN/qMyl1Wrdfi2ve7M3ezP9/D3f8z3fqN/x/9VVrVbt/9TFfgSJ+b9hZVlmRVFYFEV/3Zdyts7Wm05G+eijj8qhPN1Jsvb29u6Ksf+n//Sf7AUveIGMw9u8zdvYr/7qr77G7/7RH/2R/Z2/83es0+nICb3He7yH/fZv//ZTsP4P/dAP1b+/+7u/u9772eo8ROx3OsnNz7a2tuyVr3zl7Z/t7Ow8xUluFpko687Xcv13OknW9va2vcu7vMtTXvdM69q1a/bxH//xdu7cORl8stdP/dRPtSRJnpLl8n25VmBjMtaf/dmfvWu9iiyZAObChQu6x9y7Rx555PbrqIfwu5cvX7593+6s1cRxbF/8xV+sYIDruXjxouBlfr5ZH/MxH6P3fvp3fJ/3eR/r9/t2/fr15/yMfuqnfkp//yd/8ie3f/ZjP/Zj+tkHf/AHP+W1BCIf/uEfftca5ev6ub/+679ub/d2b6fvAQz/H/7Df3iWJ2XKUHkvUIbv+Z7vsYceekj36G3f9m0VLD59Ac1TluC58TkgD3zP16VGCfzPddXrdV3nr/3ar73WehbO6Zme+Z3rD/7gD+wd3/Ed9b7ste/6ru96jdcQ5LIn9/f39X5v8RZvYT/4gz/4Wu8F6MTmXpDNsyi9cI7Yr+wJvjtIxjMt9vz/9//9fzpXBODNZlNn6Zd/+ZffoOfw3/7bf1N9lu/CP3/iJ37Cnsv6uZ/7OQXUlFewSXzO07/L7/zO7yjw5rr5zrz+N37jN+xer3thP//X//pfsoXc6zsX34n7SpnpTvtE8M9e4B7zTP/9v//3r/GZr8/zfqOs8k1gvfd7v3fZbrfLP/3TP33W13LJL3nJS8qdnZ3y3/ybf1N+zdd8TXnfffeV9Xr9Kb//8pe/vGw2m+Xh4WH5ZV/2ZeVXf/VXlw888EBZrVbL3/7t39ZrHn300fKzPuuz9J7/8l/+y/I//sf/qD83b958Ttc/nU7LKIrKT/qkT3rW137P93yPPu83f/M3n/W17/iO71g+/PDDz/q6a9eulefOnSsbjUb52Z/92eV3fdd3lV/0RV9UvtmbvVk5HA71Gr7T/v6+7vO/+lf/qvyGb/iG8i3e4i1K3/fLH//xH7/9Xr/8y7+s63urt3qr8m3e5m3Kb/zGbyy/5Eu+RO/9dm/3drdf9wu/8AvlW77lW+o5bO7bT/zET+jv8jzXM91cz3d/93eXn/EZn1FWKpXy7//9v3/7Pbi2CxculG/7tm9bZlmmn3HtfD7v9/o8o9PT09LzvPJbv/Vbb//sn/7Tf6rvubu7e/tnR0dHes9v+7Zvu/0z9tHHfMzHvE6fy2tf8IIX6J7y97zPW7/1W+uz2XvPtB5//PHb9/h5z3ue9vDXfu3X6l5yP5Ikuf1a3qvb7ZYvetGL9Do+513f9V31OXd7bvxzs77jO75DP3uXd3mX8lu+5VvKz/3czy23trbKhx56qHy3d3u35/zMWfwee21vb0/PlPd953d+Z/3+933f991+3WKx0P4Lw7D8nM/5HL2O6+B13/RN3/Qa94Lv9+CDD+qc8vmXL1++fVY+5EM+RHvom7/5m8uP//iP13N5pnV8fKxzz/f9zu/8Tt1bnhXX8kd/9Eev13P4+Z//ee0hbA9nhzPEc3nxi1+svfBs6/u///v1zPj9r/iKryi//du/vfyET/iE8qM+6qNuv+aXfumXZEfe4R3eofz6r/963YeXvvSl+tnv/M7vPOW9uG6u/87ncuczfWPYT9anf/qn61z/wR/8gf77+vXr2mPv+Z7vWRZFoZ9xZrifFy9e1GfyTD7gAz5A18J33KzX93m/MdabhKPE6AZBoD9ski/4gi/Qxrxzo24WN5I/v//7v3/7ZxyqWq1WftAHfdDtn33gB36gNhgGb7N4iDgKDM1m/ciP/MhrGJjnuthIvAcb/ZlWHMcyCGy4NE2f8bW/+qu/qoOFw3u29dEf/dE6xL/3e7/3Gn+32aw4LK7x137t157i4LmW+++/X87tTqOJkeN6N4tNy8/vPEzv937vd1cjgUPheu78rDud4G/8xm/c/hnPmZ99+Zd/efnYY4+VrVZLz+7O9VyfEcbrwz7sw27/Nw7sQz/0Q/Uer3zlK/UznAz//bKXveyujvLZPpfX8nc8pzudL4bk8z7v857x+jYGent7uxwMBrd//pM/+ZP6+U//9E/f/tl7vMd7lG/+5m9erlarpzxTgqjnP//5r9VR8ux4f4KQO/faD/zAD+h1d3OUr8sz5/f4GYZ8s/gdgiac5+bM4gx53Q/90A/dfh1/x/nmGU8mk6fci06no/t35yKo4lk+10XQdef32ARlBDUf93Ef93o9B74fTmM0Gj3FbvG6Z3OU/A525+3f/u3L5XJ51/PJP3me7/M+73P7Z5uAgzP6Xu/1XvfMUd5L+zmfzxVk8JzYo9gEniXvuVk4O+7dycnJU67lIz7iIxRs8B3fkOf9/4yjZP3u7/6uHhRR7OZhkgGwae9c/JzD9vT14R/+4fpdDgl/+Pc7jeVmffInf7KM+Hg8vieO8ld+5VcUUd3ts56+PvETP1Gf9bM/+7PP+Lpbt24pAiPCxpk908LBsTHvzNTutshMn54dsL7qq77qKcZwYzSJrO9cf/iHf6if3/k8XpujJFpkwxPZ3/nnVa961W2n+PRnwqHcZKh8/zvXc31Gn/Ipn6KDycIgE4D94i/+ot6bqJVFltPr9W4HCK+PoyToefoiA7jT4NxtbQz0p33apz3l5xhrfo6DujM7JhB7+r380i/9Ur326tWrd3WUBCP89+b7bhZOs9/v39VRvi7PnN9jv89ms6e8liyB1/7Wb/2W/htE4eDg4Cn3l/XDP/zDT3FCm3vxsR/7sa9xn3gWGFJsw+u7+HzuI/eM/coee67PAQfBf3/hF37ha7w/e+DZHOVmH20Ql7utzb3+wR/8wdd41mSeBGCbe/mGOsp7aT9Zv/7rv66fYV+ejizg9DlnoG1P/16b78Hv36vn/Ve13iRqlCzw+h//8R+34XBov/u7v2v/4l/8C5tOp6rNbOoVm/X85z//NX6fdg1aMo6Pj/WHfweDf/qiLkUt5sqVK2/wNVM7ouZIvQLm6jOtr/u6rxOj8su+7Mvs7/7dv/taXzefz9Wfx3f/yZ/8ydeoXT598V0nk8mz9rZRS3xt92Pz93euS5cuPeW/qReweD7Ptl796lfbK17xCtvd3X3KH57R3Qha1Iiov/3xH/+xmMRPr0s/10U9inYd6mswqqmXvMM7vIN+To2OxT/f6Z3e6TXqzc9lPf0ebe7T63KPXpd7zPVj2yB+Pf1eUv99JrLb5nluCGObValUXmvf3+v6zKmDU/e7c22e7YYhzOdzTp9+f1/bfqPOeTeGOfuf2irv9emf/umvc72OWuhLX/pS1eCo93PPqKmPx+Pn/L0313o3u3O3M3U3Dgbrmc4oZ2ZTt3/6s8a2UNu/27W/Pute2893eqd3Eh8Cuw2/4E5WP+81Go1UA3769/rYj/3Yp+zhN+R5/z/Ber1zwXTDafKHh8fN/JEf+ZHbhuFNZbFR6JGk6P7f//t/V4H+tS2IIWyCT/mUT7F//a//9TOSECCcQET5+Z//+b/Wxu4gCO76cxeUPvPiIL35m7+5GMJ3WxB7nk4a2BwWmMKwgN+QBSuZBUEBAtNbv/Vb3yZ04Ihns5k+E+LKX9c9el1+n/vI+mf/7J/JAN1tPd0R/nV+nzdkQQq6m1GmZednfuZn7H/8j/8hUtZ3fMd3iDxC285rWz/0Qz8kUtYHfuAH2ud//ucr8OK7fdVXfdVtp/Wm8r03a/OsCajpp77berag+a9rxXF8m0TG/cXJQsa583v943/8jxUE3G0R0Lwhz/v/SUd554LxxHp6M/8m+rpzvepVr9LDIVJh8e/c9LtlgUS5G2NNtvFc1+npqZwkGwQBAgQCXtsiK6QnFAcIA/G1LTbUR3/0R+v9YJzCdntdFt8XVtrLX/7yZ3wdQg6v7X5s/v65rtd272AP0hMLS+7Z7i8ZNMHQi170IrEov/Zrv1ZZOoHSs33Oa1tkCPwha8RR4iA37GR6VAm8EH14tp7D12dv3MsFW5UVhuFzbhHaPE+yUli7d7ZekPVtjNPrs2Aj89zuzCo5f6xNtsrnE/Cxr+/MKp/rfuMzYCbzZxNIEuCAOL22dhgUhrh3IFR3PsPXN9jeXOvd7M7dztTdzgOLM/raApvNazjLf9XtYPfSfm7uK8x1kCESgi/8wi9UQMri/UgiOG+vy/d6fZ73G2O9SUCv0LbvFr2RqbGeDgH81m/9lv3hH/7hU7I7HBLOi+iQP/w7P7uzWfzWrVuiGpNxsCFZm8MOPPC6LAwE0Cl0Z67vbjDGZpHRIEiAQYaO/UwwH+IE/+W//BdFUE9vY3imxXsSOf/0T//0XZV8NveVawYa4d7d+V2ARDBuOKrnurh3d4ODPuzDPkz3587m/c2iKZ7P3SwO1pNPPimojAyUayHyvLON5Lk+IxbOEfo633njKDfKR1/91V+tDAZa/LN9v+f6ufdykQnRxvHd3/3drxEsbmCtZwoygRx5BjjHzWIfvq7Q8GtbvB/XtFkYNP4bo7i5p+w3BDjY03f+HvR/MqPXJRAkIH062sQ+ZU+nafpaf2+TId5pU2i7uHPvP5dFIMzeYY/eud9/8Rd/8TXKQndb2CL2HRntarV6yt9trpH7hrPE2YB4PJdn/VzXvbSfv/M7v6Nr/uzP/mz7vM/7PGXw9JP/yq/8iv6e9/oH/+AfKDu8WzB/5/d6fZ/3/zMZJU6CdJ1M4oUvfKEOHrUlDhmGc4NlbxaQJFDUZ33WZ6knB+fCujM9p/GfjcxDRQ2H2gyHGQNM1rJZHAAe5td8zdfoEPB+f/tv/+3XWif7R//oH8n4gsMTRd3ZA4gBwGlt6hof8AEfoIiWOitZzJ2LiH4T1dM/xnegjkYkB3R05+K+PL0mdOf6yq/8SvuFX/gFGZ9P+qRPEoSBYeUz6fOjP5Uo74d/+IfVF8V9oybIwX/88ce1iV+fWh2Hm2dElkYGyPf/e3/v79lHfdRHKSsGaiYIooZBREk0ys+BlTHkODK+NxEp8CgLMQacA3W5zXN6rs+IhXPEKXD/N1As70HWyufzGc/W0P76fO69XqAQXD9QNqpVZEoYLIzd1atXlbnfbfHdEKvgbHHNBC8YPcoAGOQ3JFumRsk94f0oj7AHqC8TdJH9stiHnDcgUHouOcdketSc2O/PVKrYLIw1wh3sH/rvOGsYYeQdn+n3qfGTTXJueC17nD5PjO7dnNDrsnByvBfPgrM/GAxu9/w923viVL7xG79RyBLn5CM/8iNVB+XZYfc4h5w/apGcT94Tm4eMJwEnZ4j3IBi+F+te2c/VaqWglmRhU8bgPbhOrp8yCnaLwJTv8PZv//bawzwH7h/OGuUx/v0Ned5vlFW+Cayf+7mfE237hS98oajjMCChHH/mZ37mazAguWR6d6CdQ6eGDUYf1N2YiTDJoFvznrC43v3d3/2u/Yvf+73fK4Yp7MhnY1du2gLu9udO9tuGSfja/nzxF3/x7dfC9nqm197JbnttCzo2bSIwhbknfB/u0500eaje9CjBQoMODkvtZ37mZ57yPpvrhql359owBGGqbRbMx4/8yI/U+z39+9MKQI8W7FeuB6YlPXqwNWHMwUbl9bRuPL1VBkYqLLoNg/K5PiPWK17xitstD3cuGLf8/G5tN09nvT7T5/JaWJRPX68L+3BzL7/u677uNf7u6Xtj89x4trBI6QU8f/58+f7v//7lj/7ojz5jHyWL/kWulWfA84YNy3N43/d939frmfPdeKa0F8CeZB/x/nf2o24WZxc2K2xjzjRtLne+17PdC3rpaEWgfYPrp//z8z//85/CuLzbgmn5lV/5lbe/N/aBfc6zvXOPPtfn8GM/9mPaT7wnbFdajJ7+ns+0fuqnfkptPfQswlTnecACvnPR5/nBH/zBt78z7w379M7WszeU9Xqv7OfnfM7n6Fzc2ePJYm/AjP7UT/3Up+wFPpdeSvYwe5nWpztZ2a/v835jLI//s/+DFpEwbCgijbN1ts7Wc1vUDIFIgffvBo2frbN1tt5Ea5Rn62ydrXu/gMaeHgcjsQfU9bqMZDpbZ+tsvQnVKM/W2Tpb936hy/k5n/M50qyF2ENN6Pu+7/tUo9ro2J6ts3W2nn2dOcqzdbb+L10QaKDxQ9Uni4TARQsS5IqzyRxn62y97uv/uBrl2TpbZ+tsna2z9cZcZzXKs3W2ztbZOltn6xnWmaM8W2frbJ2ts3W2nmGdOcqzdbbO1tk6W2frXpB5vu2jf8rGw6HNJlO512otsmqzao1OZPc9dN4OLu5YvRNatVGxsOpZEAZmZW6r5cIWSJaVpTVbHQui0PywYqVfWpZklixTC4uKLU5n9vifXbbJycICq1uWBzY4ndrpcGRFWVhRmiVpalEtsr39PQurVTsZDu3W0bGdnA4ljVaYb9WoJoWYVqNqrUZNChjT+dwuP3nFVqtEJIYoDKzZqNn9Fy5au1G3eDm30eDUSistqlXN9wNLs9ziNLGo1rBqtWZJltpssbThaGSnpyNbJalk0HZ2dqzf7VueF5LsQsEFlY0iz63Xa1tUCSxPV+YVpbXqke1s9Wxve8u63aaFoW+eb5asUsvSgttls9nCZtOFVcPISs+zWq1qjWbd/MDX91/GiQ2mMzsdT2w0X1hRqVpvq2/NVtdWy6VNJ2P9GU+QKSusUgksyzMaUC0K69bgT61uoVV0TbV63fwotOF0Yifjgc0Xc8vy3Mwzq/ie1aKq1Ws1CyoV83xf96gsPSnt0NPabjSs1WxaGATmm/vvKKpYkq4sqAS6T/PFSs9gGacWhlV9jyzLLQwj3Z8g8K0ahkZPf1Gk1mo1rdFscAnmVwILw4q1mnVrNEMLq75Va76FkW/7+zsWhJH9xSOP263jIzt37sDue+CCJencgkphnV7T4mRlSRK7516v6dlUKqG+j1RkykJ7B4ks7ku71ZJkXVmUliap/tmo16XQs1osLfAC8z3Pyry0JM0tSTPLMvZnaQ3Uk3zfompknu9ZmqWWZolFYWjNetXG45FVq5EFkek1WVZavMrM8ypWZsj7xeZ7vjXqDVsuVjabrWw0mtnRzYHVq3z/unU6TXvwwYtWa5gNR7esKDOdNb7XcDg1zwJdR7xMLGVfrXK9V+BXLIwitYxUokjPwQuqdjocSw83yxLr9jrW7XbsgQcfsLxIbTIZWpat9Ez4/s1W33rdbXvkkct27cqxBQH3sbCDw13bYQ/W63b92jV79NWP2YP3P6zzzXcy37PZfGa1RmQH5/as2gwsanKfAqvoGTg92zhZSuauXq/K5mR5YlGl6u5VmppvFcvT3BaLlc1nK+2rInev5954fmkeb+aV2lNcn2eeRVVfsomc69l0ZdWoYc1mR38/Ho6lBBYEmMLcgsCzOs8orOiZFnlpcZzYahlbWAmtVo10b6bTie4J9/v0ZGJPPH7VorBhtVrL6o2mzh33jTNejypWqXiGEUMQqVqp6IzyuVv9LdnSVPc5s7IoLPQDfQ4qOOydWhUblVmc5FIg4XrGo5nduHFs1Vrder2+zdgvy6WFUdUeePAh2brf+70/sEde9ahx/KNK3cKgYhUvt4pfmJfntrO9o/sQViJL48Su3zqyk/HQ5snK4jyzJE9ssX4mRVlYlqdW8UNr1eqyC5aXsiEe4xo90+vn8cJWeWKFca251WtVi3zPyrKwWli1iufps/hez3/4YWvUO1ZrdK3R2rLBcG5Xrx7LvvCeq3huSTKzZTq1sGo2mg5tNBlYVibuDBr3s7QoCgzrU2aFeVghr7Tcyy3JaI8qZGdCL7BqpWbJMrd6ULN+a9t2e3sWVav2fX/2VffOUSK1lKaZNqBTO8stXs0sK8ziVV8brBIElmeZlVZYLahrY1aCyNrtUBfMxuOf/L4XBFbFmUW+LccrixeZFRm+1bPZamXzeWKzeWKrOLXpfIaftaLMrZx6lhelbe/uWr3eEO09qEQydqskk8PJs9zSlANal0Ot5aU1m20rypnFSWxF4VmtGloVJ9RoWFjxrcwxeqkcB3JJbI5VnOiaMTLtRtOiSmjxcmUDj89IbDbDgOAePGu32pKKY/NjdDHyq+XKPIwmjzTPrcidQDQOZrmKLc5K29nZtm5vy9I4tflsLqPSbDctiVNdT1IkVqwKC/zAYgxPzPtntlgsdZBwrjdv3LRGY65NKcOgYCC0+XxqqxXPA/sdmBW+VUrf6mHVqo3IfP4XEBRklqaJ21SVyvr5MpKJ50fAU+p+ZLmbBMDv8B342WLtPPJqRY6Sg04gslotdO9qjabuc4Lz9THoFf1u4GcW4gSDitOXrODA0HTEgNasWq3L0TiDh9HB6VesGlUs8HI65+W4OEDn9g/lmJpyroXFq6X5ldIaKd+RZ12zCocpwOlGku3aSPaxr3hf/o5/4sBxggQCRZHrvnlEM4V8qsVZ7Ax7EOo+lDhTM70nAUaeJgpqxpOx5XlmjVbDMnYDwUlYs3q9poArz/iuZpNxKgPpl6H5Ht+7ajeuj+3lf/oKu/zkNUvT3LI4t/39Azs42LfB6cTms4V5/sr2DvoKGvI8tSiMrFFtWBRWbTFf2Gq+kJPxw8iKqLAoIthBA7U0r+KbX+ErZVZrVOz8RUT9Sz27Vbyy6WysvcQX5hlxbwlWwpB7wb5eaG9hoJvtlu3sblujXrOyzGVQubd5kVtW8qfAVOjechu4z91+xyoNgu3QfN+z+XRuy+X89p5jf/DzogisxHnkPsfCsjS2CkFTp2H9rb5leWnTyUT3ezYby8HUG3WdP66htRbjPj090bPY3dm1RqNr08lMQQD2o91t2Grp6awmaWxVP7Ks9K1Ic+1rzl2WZracLyxotfR+q9XSKoGvMxbHqfW6bXv4oQft6HhoSZpYkoXmc+8DX0EqWz+KqlatR+aXpd7r9GQge9CstxQkeB7ns9B1VjwCUs+K3KwMuLbE0qS0LC1lN4aDsQ3HE6tUatZsdG00WtjlK1csyQs5ztwq1ml3Lc0Kq4SR+V5uvuVWDQPZsU67YRUv0PdPk9yWycrCStW2dnZtiR2clBZz0Wxs7ftSjikKQquGVdlHEpIYG7Rc3bYdeZlZXhbq3WUfsAfSVWx+GLq9lSfWZJ94ZoPJyP7i0Vdbq9k28yJrtbet096xIo9tMllYGETm+y4oV2Ab4ARLqwQEqewjnGQhZ1zmmWWlmV+yRyPzKp7l8dKKXGGT9gPXVqRmYRlas9a0fqdnW/2+eYGTXLxnjhKD6QfuwEQRET0pR6E/tRoGFcOZWoTT0Y0qrciIQpyBY9qKF5SW4w1Tz8rEs2rFtyAPbDlJbD6NDd+WJBiQQl+gDDLDzOcl751bGFUUpR6fDgyZZx7KdDbXhlMkH4ZGIitj4Hs6cGxqrrnX69h8MbOALKkWWbfXVTaHYWAnFwXRI9ebW8CDLTH6scUrovHAqijX4yyIYlepNnPhmyLLNEm0qdrtjjYR2o9lkctwsMn4X5VotFGXAn5YI0urWqvbtP52X9dNxFyJKnKUHHKcIVHsaDK2Rbyyeo2sEieD2fWN3UbGQ5RN9EdGwvfAuawWc/NLU9S3TDD6BCEYrcQKP5QjIwrP0tyWq5UlZW5pnlng+xZUIytLnF6paJ+IGQvH3/N5HHwcBA6V+8vPVgFCz5HuQWpk7aFzoqulNfJS94TsGwfIc8T5GY6BQMrnvQIhBeyrZbxU5qosWEpM3IvEloup1eq+tVo9qzeqiiLxcjhFL4zs8GBf+2s2m+rz682qnGu16u47+5HrrtXqLjvG8GapJUkmZ8kz5vnPlnMXlAFhEEh4gf47LzAAronfI2mpekI5mBvK64JKaIsVwWRqy+XKZov5Omj09KzHxcQqIe/ly+gVvm/TaWzD05WNhnNLVoWMbhLHNhoONKFjNJ4I2QiDqq2WZkUeWLtVt8HpwJpNX4EZ2b5PEJqa2wM8+IyspCLDloEaVKvKmLIiNc/nnkRWbzV1xupxTagFhg6zwnmo1yJlQBgisqdGvSrNToKcokjkMHEOnU5LTg/EReOUSoK0mpAjDCUBmAxVklip4CawJE9lH8ic2fcYwwXOl+fuedqXxHTYG4JvMgsX0BQWhJ6yr5xMxtz1mo8zCKzTbcnRsU9XZGJRzcKobgEZWqUqp8MlNsk8PZxQfntvcW38qVR8fT5/n6eZnDJICdegwEmBometRktnezqbKONst3oyvn4Q2vHp2ApCkDw1tnmRp7ZSRm7W63YsWyMsw+FEAS17YQWqFrkA1QOpIPgqVwr4fZ/gKzfPKjabLe3oCPQsBvuyRqtnYaVho/HAbtw8tSCKrLJIbRHn1mye2o0bN4UUdJpNi3zf+u2OHezv6UTX6g0ri8AGw5FuTMLzstJCssUss5w4cuXJ8RdEOiQMQSC0A1ukTDtJbKXEw2W6PHPuD8EpZ8PHI+LUworlVsiup3QlBRVL8sxunt60+pzMPLIeaKEy+UJOMU0X1miBflWFKuX5Us6e4C3wTDaDc0yQyHfkfPJ4QDgqcmu+EhztFB4+eygvrRpVrdVsKUv3fJCv7N46SiCZdrNuo+GpIpRmq6asxKvk1mxUrSxSm89XNp4mVqkG1syB1nA4pfkFDrKwMAr0T4womSMhdbHIbTZaWRZ7ZmVkWb60RAfe1yFfJgm3x3wiUqJ7IIzAs8UithwDn2YyLsp2lMGGctpkshgtJiX0+j3b29vRwePc+V6piPX0dGCtet3qUVVZql8JLSEbzYmOHOSynC91UAocWaVibTZKGFm2Wq4NKBuboapDB09JvLy0+Wwm58S/16LItns9QYX9bkeQcK2Oo+zomoFNwopnYT2ycOWyuLSIrQgyC6uhmZ8ruyWSwnDjeNKitDhLbTRfWZymlnrAhLkyEjLf+fqebA66V/oGUKR/1yQHMvW5zeZz8+QQCweTrI1DQBThmc24z3lhHnCIi0HkKDB0yo7XsmhpQuRM5OrLuCsJy0ubzxe6jnqzYfVGwyqVwooi1OHk94jaMdT1Rs0qVQfLK3uVk4sEoxAccSAwanwgBqZZ51klyloMIxdWbLlcWKvbsGarbmkem2HoZXgy84mg0sIW2cIqVZxyqL/jmvlOfF89T/ZR6TJNPkxwszync6YV37d4FVvKXiTbyNh/OH+uFWhvaqUtrdPpml8nS65YFNZsuZqbn3hEi2ZrZ3n9+okgzNWqtGatZTeu37KTY+ZylsoW+r2qHR2fWhg2LI5zu3Xz1FadhmXZ0u6//9Dihdmq4owpmRcPJgdBIPs2XxH/cpnIift+ZmmRWCX0zCc693AwntUFn/py6mQNjRxI2AVEjWbNKmFNr200qlYJyBoDO3du37b6OzZfJMqMrl+7ofMEujOfgtoktlg6uBdkZ5UkVq2D4ESWZLHN5lOr1JsycDgcnDF/2E+l4YxzGUGu2zlJEA2zFZlPGSqQxenlKeWQqS1PF3bf/ZcsrFXktHMC9MyzVeyCzZ2dQ1ss5goCFstTi2OybbI4Ampf+8n3qwr6dA9zPo89n1oaZ3JYZOcEAviCbrcnFGA8HCkDJvBMylI2cpVmNl9yZlKHIOE2CShxOOuAXFlSCJrVkkO3MjDzKlbxHSqzWCRC63TWzLOMYLfIbTpd2my6tEqlbs1G27yyYqtVavEqteUitTLBQCQ2XawsGk+Fbm33e3bxcN9qBBONhu1sbdtkMlOWSzkJJ5StChtPpzZfObSK+9uudGRLCeAtBcVLLQoqCviTOJGzJ8jGOXqB78pj8kee9lFQYgm4ndgcz6IKzz5zzoyAseJbnC4tj8l067ZYjuzktKIAmii29Ao5aYXpRWpxurB4Nde/VyOCfWxFYGlCxr9OSIQ6un8Cq3P2CKYITioWWMULrdvqWb+7Y51Wz1rNjs2fNs3lDXaUbOJqvWarZdWqEfBJU9EXWR/pOIeTO8UGqlSiNUTrDA2HENg0ZiNipGMcj1kyX9nwxtTGt6aWxkBpZES+jHeK0VKEU7MkXyn7INH2AmoOkYwsURs3JdtEYV5qmQ/syX87iJhMhgNwsN+2ne2+3bp1ZJevXLbpeCx4ZafXtwvnzsnokY1lVgjWKPNCtRDiI2CWRAanVDTSrDdsvpzrd6j7AHvhJDGytVpFNS3qEIp6PLN2s2bbW9QlWzK04+nMrt28qSirVscQmW33O1ZvhJaXqbUaZF8Vqy9rtmpkgiKGg6kczwYerEaRrmW+Ag4nQ8L4pnLKvW5P2eF0ASzlsjL+5xVmjWpNGYZz7gNbxLGF1Zo2LzWETqNpvU5bhpaax3KZ6jpxiKpxcFhqoeo1wNjuOLgRSjgdjKPlnhwP90c1lSTWYcIJ46CsUtH9lYMCWiUoAh7xXK1DWVijYc1G3VbLufl8XkRMgfMm888sSakRAuvwOdRMiYdzGWMQBOpbPDuuy/NyqwXOuGrM0XwpeDtc1+rcCcNJkl2WMljFOiogvMBwOkgEZ+lrjycJjiDSPeX+k7X4QWSzyU2bL5ZmpauVA4X6fmSVEKgeeLFieUE9cWiXn3jSbt2klhxZ2sxtOBrIKe3ubgtGnswWgt+3t3ZkYIHah+OpATxEUdNmk9iGJwM5znottG6vbUWaWK0eKdhazFeC1qp1QnCcEKiCKWClJEf9UWETzqFMFJwIpq66s1sJ6pZlsYwkv1uUZEm+tTt1q1VLu3nryF75ykft+OTU6tWq3XffJT3jRq1G+UqGerqYK0CNanWrVKlzU4cme3O1aQeTesr8XeAFEpVaCY9BwYoLyICsC4+sO9b3xcaQFfT7PYvjlV2/fk1oTb+3bbVqU9kDwYhnoY1Hi7VDq1u1WrE0q8uBuSzWhFD4PnstcU4yTdznYA0yT44IZ7WYjq3dzq0e1WSsa1FDe557XIvqlmexeAk4HwJl9jTfXYY9itw5KF2NvBrVFUCFOEqvVKmlqJjVwlA10mmy0jlX0JiR6a/HTKkUgPtw+5JzjHPjHsZpZqXvSlxwHFqNhuruvLrTbNj+9pa1W66sQ3A+GA3t5vGJ+AlJ5hIFSldcH+c7DAqL/KrlfunqplFo1SBUFsk9EjxOgMmZ1XF29sn3KuZFpQU6q4XOp++HevaUYMjcgWM5M6vlzNI8WQfCK9vqu5LaOJ3Y8a0Ty4sEVyfeAyhHGDUs8AnuIiMaLwj/i8y8Eu6AQ4BAwYSIrCFjzjmOuxE27GD3nF04vCjIuxY1zaaTe+soZ5ORxTHprwmf5iSAB/uCDAKLV4nNkpn1drsi0KgeQlEdA27un0GVw1e1GIdWUPcc2/GNkZ3eGNnwdGKLeaJNwc0kswgijI+rWZClEEUoowSIAGaIQkVqOKhNbTAtY1cQJ2JZrezChQs6kPP5TFnO4088qtE1bPBqULGhlXa4f6BMcHIyM4CGyWxueZxZtoqt1WhaSzAF0GrbqnWin6UtkoW+F7Aw10f2zOdfvvyEeWUho3Hh8EAZXLfT0mE5Pr5lx7du2Ww6seVqKcMUAoPVI3v4effbntcT6YE6F8Nim42mHR8NHSzr+3IYylyyzMazmSA+HEK90ZLh4PsS/RJB7W5tizgBmQTnQNRFwbvbaIksczocyhgI1oxXuv6iUbdWrWo1onkLbJ7PZfTKddSlKK7i62fAKeXIwVcOWne1CQIGjAKHh8CIrNAZSG9NqiHDgtDi6zMxguwdno9lgWqJODiyzKACdL4w+B6NRl0ZIsatKGNr5jg5X9F9qQNE9tGz0WSk78Tn4mRUo/FDSxIgnUA1aYwPxoDr5plRG4ZgoNop2TSeSFllebsWCzoQAgX6jiiCFWfP4T9bra4O+K2joR3dGtvx8alduzbSObh06YLtH/QEBefZXJkRGdfJ8cA5Mowb9bxq3er10JqNlp073LV2p2k3j07NPAKhQHU1bw0z7h8ciAD0R3/8clvMRna4v237u33rtjqK3DlrOOiiyln19My8ilk9iqzwM32HPAf5iZxxXCytVq8o0MIZcl+AV6njE5AQqI3HcxmgatS0PKcu6tvJyYldv3Zk80VqcbW0Zn1iFy4c2t7eeZtMxnZyeksEnZ2dvuBvoHVKINu7XTkQ6oJpFuvZsi/4HZCJCntuDXcSvLBPQErI0tnLEN4g5yQxQZCreypIrAKfezYZL+zJJ2/Y1StAj4WVgvs9IQ333X/eej0CGOdoCHo8bylCC8+az53PlzYZTqweNZS1TccrOzo61XgzBOXDSk3nbjGb6vP5PGZWYkPSYmatFsQZADOH1PA8CA5ESPJcoMvZJQPb2uJ+ByLRhX5ptX7HGo2mgoXFKlaiwXMHoibwmkwhFlH+APIksCus1+va4bkDO9aZTlQWmc8mttXtWLfVlhOvYh+WKzs9OrUZGWte2pWr1+yJq1ct90iCmuZXciFx2IoiK5Wx49gjcGPPVyAdsJEsViBGrXs1nwOQaBFE8awo+WBbsXkEOPPlQmWFfLmwVbrS2YGjovMeRoZJB2odTWPb2d6yTr9uUzL/dKRyAUFaFLWt3e7J/pHksv95fmUBv8T5CAJkMkmRKUEVktzVVil7VWpW8SM5ZyUWWDifwL96bx0lEAr+G3YiqTSpOxvKz31rFtRharbIZvLqANQU3kXQiMg2XVE1z11hNskKG56MbDJYWDzL7PjWSOw+mGyKcEPfihUHgKK5qycBk5DeA3+pThT4clzKKEVGof7iaiTUITFiQBxEduX2tjbjZDrW93DRhqsfUDM9HZ7od1ntVkfvOT4dWK0dCWYkw2VjLOPYult9Ozx3zgbTsc2TWN+PCA7nDVsS+K/dbNjx0ZE1qpE974EHrN1u2mQ81PxAoCkMQBTVrS5oulBx/+jWidXDigwhcOR8Mld0FM8XZhA6MGLUVYJMGD/RKPeaWinEIr4/kEitEloecvBya0Vd1TW73a7eiyyRzIogBri81WxYOS+siGPdiyIjG0wtz4A3Auu1YSnHeo/FcmFpEltOQOIBCAFNAbe4mi4bHwPAAl6nBpFChskzi4DTiHqjirJB34u0+ZcrR5YCHuMOZsBccaGMlvsSxw569nygVcgZdet229ZokjGxl5wBSlaZsgoYbLBDiXTZnxBmODSQIHgt9V/2BIGdYCFKAtRdk1RBAwaGTJ2DRSVY0DCISJJaAlu0ARmHzIH/zmS85TSy0m7eOLFXvfqy3bh+Ise8WpT2yNE1S1ZkTqG1Y1iUoU2nibLUZr1jYTSwIKAW07JWuyFiTqtZtVYnsv5208Iaxj20o5snVq1BZKja/t6h1WtNu37tus2nEKlcnYuAShB/vy2HvpzNrVpv6BwsVwuL6hFxthwgsFaj0xK8CTvSxATwLaqFLtPn2fpsu0R1RowQ2Rr3TjDjypG6qmHNFnMMPYS4mq1WhZVFxVYLgo9Y793pwgVgb6TW6XV0HTwHDB3Gn6o2NTec8la3p7MNcZDrhnwD50HwfZprL8yXS8GrOBzsD8+o0+mpXsvrCLavXr1l164eWZ75liS5DD1nFwh+q7cU/Cj4vtGyRoPvVdjVK9f0uY1G20HsMsiF4Ea+E86wLEJLE88ef+yasvJktRCrGjsURROr1VOLVGP1LY9XysQI2EICNUonjjLlWJmQZhLYswtrNqvag2WQ65y1AxeItgPQh9LGy5kFZSRi39ZW305PJ6obAkeS2VFrvnTp0C49cEnfEWdJYJdQiqi3VHKZT1c2ipd2cjKwerNjcU7po1wjdS4o5HeA5zlD2PMoaOkszMZjXTPZKKjeiAw0dcQdBSly2K7+Jy7FuhxDwIvtJ0uF9Adix+fpu6e5fl/cEJVTHLJz4+YVOxkeCSbnO1KS4j3Zk8PTE0H/YdS0Wr2pQINACl/AZxLgcR0x0HNEIByoTs++xzGSqQJ3c16DekWMfGzGPXWUQBZiTa5JMtTy4mli1ZLNk9l8DgRBCowdJxdnI8WCN5UNVWBfRbaYJDY4Gtn4eGKT4cpmk4Xo67D7YOiRhaygs5O51F2kwOHEeSpjTBJlJhujrAxAbEpnCLlBQJ4cbF4brqFCItlGg6zumq0WFcMnAM8QZcKiw3NSl6n7ZrVawwqcb5JYBiRCcd8zsW8rg4HqpTjLyXy+bn9Y2GQycdT7SqDrAwJbzIk4iXqApKm51dZYeqnPABLAMCfJ0nqdhtXrLTHTcAJseMhOXKOrq/pyRmsCvCJNZfTrGhqbpOJVZejIVmNguelEGSuOY2drx2qVyEYwRWExRhW1qfBZ0dJR8zGwatMQJ6S0ejWkrGdlEyqB2QL3lqfK1nmPZg3Y2BMxAMs6D/juwJKJeTBaVWznDcjCIGrA6oSM4diykC7kWPPS1aRgNDZg8tX1OWSTaQqzFXgnUgsAtS6fDJL9aKXINwQykLC4p2SMihgrQDHOiUynsKZxthwWyCYNHVDqVjhIgiSeG/cSA0pgprprmliqzIaiOc8ktVa3peyvzGFgUg8D5oWkQ/bgy4l5HqUBz8Acblw/0r09d37Ltrb7CiJ8LzXPC63V6NqymcrQdtttC6O2eZbb1lbHtrfa1u3WrdOuWhi4VpSt3o41Wz27eeNIsDkGAbLDaDDWay4c7Oo62YdCCGBcloVIYtzfwsOYRaqFu/YVYFVXT8b5ixWstoSV0COcKoEIwUG7jYEpBE+CgFQ7bdvf29Wg3ckksTr7GThsjVKPRxNXR6R1pmB/OrYxGQFOjjQEhwu0z94gC+Hei+wWRoKmITSBXjnSTe4YxLAqC5Cn/DaSwcLJwaC8MTm28WhqSczrILDsyB5QPgGBCIOazSaJDHhORrTgvVJbzhM5LWp9ZE0EolaCrEQ2mZzYdLK0g8Pz1mw0xImYjEfKah2UTHmmZu1uab0qqADwoNlw6Igm1IJluKmDUMMnaIRYVm8IAXJ17cQ67ZbshdpCgAu9wKbA70mq7C4Iao6o1qBFpbRqvaV6K+enAWekRpmpkFPGcTRr563MSpsOB7reW9dv6POb7R3zqTmGkZwiQQQPi8wQl0PgQPYLDAz6VFCSIOCNaiIq4XBWYrq6QNSFnRBsXAuZHC7ckjTT2YSgF2egA9QpnC3DeYGu4CUpp+FACUoJUPhDuaTd3rIA9CMj6FrK4RKgm0cSFq6DjYUCCHElVpTiPPHZxLPAPdLOBYs5w5419P2Oj09swJmJ6uat6+D3zFHCFiNzwQGUJZFBpEhE0N1yIcPqLtgTdR6YDgoyjgF6NRTw0lykeXpjbKc3RzYbAj941utvW5wPLE9geDmmINgdTgrYhOneMEqByGC5uvJRaVMo0vRlUisMq0rTVf7GeFdreh0wGZBkmae2v79tafI8O9jdstFoKKz/8PC8NeotO7l1JAYdPZ+KTCzXQwYeIoUHCmx3WjaNVzY5ntoygSwCK8y1TWCoxZQsOQSetTr0J1VsNBzacjGXk8cA6JB4sDfbMrQq8Gcr9dMtObRrR3nucMs5SbahF4hMgLEp/cAW6TpYgKlKTQBDAIyY0FKzcKxZjGQSW61oKIrFCGx1etaE1VrxlVHu7Wwr64XUM5qO9exEmoQ9CDeqUsrIlBZarde1dqtmc+AmtWLUVewX/k8GlpVWmUxshIFUi4CjcXPIMLbAzxhbHJXLGujPou7laqjAU0BwMJLBuReLmeqAQI9eBtJfs7AKOxajb8p+RMSJgWVbtpgvRbwoaz4P3fJs076ysMWKZ0r/pSOXUeOGG7aMHUuV6Jl6hZjGBDtNAjTXykR9HccpZjK1FL5nADM4ldPAgNLGQCAJGtFpAQvigEq9L0bo+vVbyurSzNN3BPbkQNPveCD4N7bFcmrdsKH+2r3dvjXqfEZhjXpotZDWioqyndk0ttF4qLYI4CVg+sByO3+4Y51uW7U+vgebP05jtQzAKA5hc1YKwbC0UKguRiuVHE3pGOXZ+iwThG1aZUrX+oJD4mw6EhYQtGf7B7t2/33nbTBYOEOVJ5alzskSrNEmJpZokyC1bUt6RqfzdQBFfzEBGQgVhAuMIOcXpxraVm9Lz47PxTnQLkRgBW8hKR1TmTruBvJnUQNU+4+cLchIYOPxzJrU6aiRRxVbLekzXlq7BbuV/U3pINB7z8bO2YZ1eo8JaDwbTaZ28+hYPafUx/Ii0POFv8CtAyKv1Zp63mS01PN3vJ6Dr6NQZCoCLVjaytqK3CazichO9F1St6ZVqtFyZQC8FcFWHbJTQs0fNnpoE/gGfm4t3wWKJCTsn9JgoLp7sJxPdQ4oE0VBZM1uz2JIgYVjVC9WmeBrvhs/4+zCt+C5EuB6oFnsx3ipLHI2iQQn15t1h6yohs95ayrjC2BRA6HTOSBb60oWLmPMLOHZeIWl2OU1ORA0EhdWo6YvdjD2jWfvSmogG5naOiILq00L1IrH3xHQ5bftO88OkmMpTgqBp+PDmIJWGRU5SJig3B91bXgVtdeMJ1Pzgoq1Wp5VquW9dZT9fscZUG7KOnujwFxvNkURz73ESiCwVWKrWWx+E8JGoMNsWWhFnNvJKbXIqY2Ox7acJpbGjoJPod+PIlvOaORPHGMSNmkeWxUCCNkl7M/CZUxsejbaYrVSbUmWjBoa7DUcI72GON0sE9uL5t7RaGC7e13b29uyoohVk+n1tuzw4JwgvpOTI2XCQBlEjBz0AVF7nCiabxQNy3yzk8nUZY/AG+sshjYKiDYceAw+hfRuBwjHtxs3bui6iMr5w0YETqav83Q4UaABqxNYAoIQBXgidfNCm80nNp0vVaRXVEm2HhEQFIro+B1qgcCXRKF8X0GIZA1RJEepYj+QLRBIs2WeX3UEgSRVD1lnry7W7HK1LZYZG4rIl+ZdDFWAkaF2hzOmobvhxA8gchGR0ncKu5DvQRQHkYkQis+sqF+RJ5OLGt/vdR00EsfOGMM8LTdkGLKJqjJq0c2pTdE+hCMOOJw0nlfEFiZCJ9sJCt8aZVPUebLH0XBsgwFZvKQKlHmvkqXuAZkoGRMQHtFyUiHLBf5zjD2CNLIwMlL2rCBi1aAx9r6gXxwLhgjDSJshwQfRe6PZFWIxmc5ta7trQWWmftcq8MQUBmgpB3zr1k27ePG8mLkisbDR/VToCX1v3Xbdet2mVatkHpnQmwrOvVm1NIdN6NqrgL/ZnwgK4EQvnN+3Bx68z2pNIv7MQtilGF3ft2anpf+GCMNzD2E/VzBGLkhhz2zIIDhNYGICDyweDpxnDDRKRA+MRd2cTCCJXTZ78eK+5fl1m0xGVm86du3x8XUxFJuttlAl6qs8t6gW2CSnju45olvgkAZYuND/CV5g73Jbwjt6W20Dg0MmA0qXA4dNTrAEkxLmr69n0eu2bHd7ywbHU2esYQET9eEYEBEoYPDWLF2o8UwBlHrAQUmsZrWwrhIAYiOtFrVI+pk5UzXxJAoILDA6UY3wqZ/B0MQJAPHTs3mqIAqIFLIdiL8jOPoukCvX9cqcHvHYMo8abGlVdT4A9UeqpdE7SjbOvaKNA6gaghs9yR591Mu5iI+gJLw3djGk9SdwTsLy2JKFE6DQGQSerEa2hNW6IIgpldC0my39LvaELJdzDhkNYg1nmppiu9WydrOt76/2MB+0r26VNFBfMcH1hgHPftoEWA7Eh/WL+3PEGmwH9tEsFOExTgPXokM9GlbxpiRC2QkWb5EJYq1Wm0qOdI/Ue12REyZooPxH4Ia95Tlg6yL2D8Qp0Av1bbvSEHuC2jzkJYiMOOJ76ij5ykAu9aqDcCbzifmh2d7+liLZVTq3RrsqMsZkPFPtggZoHkY8X9rNq6f25JNHql8ki9SyeL0JiCC4jRiswBdTGjiC6LCOU+GQ56lgTGwWmzdKYDCWOuxuo5JxuMI/e0RtKRm1y1xRHgeSSJmb3GqhngEcSeST2GQ6ksPc2u5JtAColquCcDGZT+WUIA2kNLKvcXciF8gJZMpEK3EOFJyJTUqWRpsFSixEqkAOZKUYnl6/L0xc0NRsLtIQ8J+gzIrvnGKcWbPdtsUSFR6MANBECF9RdbJkvrDBeKLWGRwk0RubTPCrhwOrO+ZZWJGz4oCob0oOzjXuw1CEqewpavatXa9ar8NGpCUHOCOx2WRm8Wwhthtw3GIOeciJGtD0D5xcq7nC/WQ8VbbPtarxnGAlTYQEkB0fH7l+Ltd2wPvDgvXW/Y1AYlUZRm6MCDfAnz4N8vR7sQcC6/WbqvXSRuJVXCc0ahuVSssmo6WgvuPjgTIvsgoRbYRZk1mtrBpTG2lKDWbDsvUCl/ny7Djmm4BGdW1lNhhlDNUaYvI41C7zqVSq1m6RvVH39O1kcKxrOjjYtvMX9kW9h/R1dHRst45OtJ9gTWMjWh36+hCdWFkz8Kzb2bUL5847Vh97dTZTnb/R6ijbXkzm+lnpx6o1TadjXT8tJ5fOPWRv+VYvtQuXdqxI5jIe1HygzhM18093SkA52lIr4jkMhgMHedPS1HCog/oTPeBzeiXXDrPE8DlCEbdTSjulaznC0e4fdC0raO5u2+7Ojh3fOrI/ednL1RtYow2qAgqxUDbBGcstt+tXb6rXl6Di3Pk9kWvKkmweKJ5+xdQxqJUFOvKFHiURk6u4iIcAnE5mAczJc6T/k4AVdjn191vXr6h3M2r1FOzoHKOmFGe2nEHeohZbiqm7swNRJLDh6Uj9uCh0wdSvt+vW6rXt+MbABUg1ssrClQroxc0h5pDFEXjQjwlLfWoRNVeIOTT1w+/AwQZkrzWpea0WtJ24DJOWIc6hI7eBwvmWp77YusPRWPeSAIZskM6DAHJenihZUTucGK8LB4+qB9W3ZUpZi37brlAGlK54/mTY7DtH2ArlBKlt850o7RCIZUlisWvV1h6LQQgIbsnQsDMwzXFIkJ8guYEIUbIhWOHckeHyfMiR6HMsM51Vavc4MGrb2CuCGB+qL6jTulWH84v9gO2JzRbpzPeEfOkeqjfd9dVj39RsgQNlL6ukhOZYRRA+FG+/cDYPn8KeQoCm3W+JPe76Ve+xoxwOB6I+k9nFeSIj2e5tW7vTsFU8E/YMQ5T2itHxiaXJxBrVlr7UyY1Te+RVT9h4vhKWXySwaOdOUg7aOKxSz7dOr2tN1C+42cCGgpsikWPU+E2cXdDA7OopNI9DNlBRWco1K3czKpE2qmuVly6KlD3IGGHgHZ7bVeRHH+VysbAo2rGt7Y6dHJ9YvdpUZLOhrqufsqBeGasATmGZZm4feCOsifCAc97Z2bUeDdhtGGtsfueEBA8BRWKxYfrG1OYSOx2MbJnmkrzDIKNYIYJMULGT4dQ6vYmun37JxTK22QJIb2Hj6UL/jmgBhBm+u5stCDQGJO7aOFTQp/0E2jpBRVHYeDaxyO/apXOH1m00bT4eW7xYqG6IAxczEYiRlIF2IKTDgG2WK6mxAIWGBCUYdNht1DjW8m5OVWQdrKg+6MmxxyVs2/W/c92Qc9CqQOILx8MD1QFxdVkgcq9Vs16/bZ0uvZewm82qyNcBDwr+dMQtV6P1bDKd2tVrNwRdk8V4m5YYaO00MVfIGFydiDox0B5wdZzOhYDwc/aSKPbxypHHQHChuRswd+oybRqlk1y9V1HEaxEsIGCIbJXGVhjECtRhAqv7gTVa1KFMsBr7aP9wz7Z2IFhR/8ytntMK0HYKIcCW1LNEo09VO8J4IbF2cnwqBiTs0tmc+qNvWzt9oRZv9Tfeyi5cPDTPWynTVl9vCgmqpqDHSxy7lUwE48h7SvGo4olFScZBIKCyQGEilmH4MWgisC1X2k+CIyGfTOai4tPeAEnn4RdcsN29phw353I+88XyXSyoZQM100O6EkP26PiWC5LE4GwKpoectb2NBCP1OXrnlpYmS+0jMYLXyiyuLYq6NWQeejoDOQayYxFE2EdrFRZkEe+/74IVKSSroc1mE8tTWJyQ6AjkKjYbDdXmwL7Y6net1+5a2CL7yK3baynYGM/ok6zZufP7qkOidsS5otQI1I78GxkdLTSo22Bj/BBxjlzOkuyYwJ5MFqdO6xKtR6hxwSQeHI8FVXKOuq2W7BZ/ID2eHJ3a5StXFZhQKuA7o1aDc+We4DilPLPOUMUCXi2tVa0JaqbnneDAC0ATqHxDzirl0NQbLkWxtUxls6HzrHuMYINq90udXUH0eWpBHFu71RUxiu/FfqYpUi1j9G5LtMK1g+SB4yWotxISJhCsOc4CLT0wcCVCwUWpD4vAy5XbVNcunFoV91ViD/SWLrHjoCo43EB2CQiZ7++VrlyjPk7s3/qcI7CiFhslNIiRzERwg8xEndWCRFJ399RRCtrLG4LuYHHVW3XrdjoykGJKRXUZOoxmVZTb1MYnYxuejm0+iQ2pBy+H9QczDTiGDKQwb74yLyQbbcrg80Voaq1CP6ZNxKO9AlWQQHDrjVtHdjw8EfRB8RrIAEMp0s+6liLdVx/YFXII0HDDavVQ1HdqXGSnwC1EuJMK2dlKRJ+Dwz6P02j3HE9c873OH5YXY079DqitVdU/ORDonOIstne2rSOd0FOJD6j3q4p8X1vajzgO9ZSqwd1JMS3GU2k8ZgWHa6VNixHESAD/NiEV5ZCIFiINTZeJzWCIoiiRFcpStOGBNGhYDn2r1GFu1kQ88gtUaRoKSKipKgIjM8JYABWpPgUMZ5avEmX1wHTSha2Fqv/imDF0fH31xxFBz5cWdmjwd9qS/B3RnAEJwe7jeiqhasgYCJ4fJBKiayjl0PF5ThDCFiucnoN8oarmCU3VQLG+bfXb2gsIXAQQAbJENTcyeEXfkDyK0gbjsSLYertpMSodaWFbvZ61qIkihqHDAJkKvVKnCQp0TB1/IT1cJ3LAfeQ607WAAnrEODT+nZ4yCAGo04ByUGt/2Z+80m7cOrEXvOCFdvG+S2LjEUGLpMQ1h2btbs162xe1B3pbXWu10Q1Gsm0qY0BaVq95gieR+0q9QOeL7OX61WN77LEnRcTgWUB0I4N48Yufb63mFT3n++8/sFWMVOFU95nXSDDDXGtBq97WfaD9AFZqperIPqrbhIRvLlNkj2OsCBhEiPJLGUyyCwwXCBUOi2dIxuNqRYVdu/roup4LarOyc+e37fDwwK5cuWXHRyPLcrJJIE7geFCGyGoNskQyKIJXl7mLxEJfrudZt9vXvaEUIWINGQ9nDWdCgCYSGcfRIQL8UT17TShZLpbW7dXtbd/+pfbk5Rv2a7/8WzYeUgus2uFhR+089F5L2QRSU5HZIpnbXv+8be8cKkA8Pj6yU4RQ0sK2t/et2+nbn7/y1TYeTtQmQQAG+5oABCJjVgC1A9UillBXsIKqlmtt6sgBcK/ZQyIgwlbPEwtKd275THgV9MeORnN71SNPSMOaNrgagQwtWQij5Gvlp/lM/dKQ6iA/pnEsTogk3Mj0VPw3i5eUHnA1rld1v75jR8Wx43lgf2GrwjUIKK94grZ3t/pC1SarhbLEZZwJat3d21Xbx2I2U39zSdsU/Ak5chyyqweCX2Q4OvpuvcptWUMRDtVn6TgmYu0jGegXei3+QGhCuS47KADHHDlomBX5kUUS7XAKZhWrmod0Iv2s6GVnmTVC4PSKU44jsEA1Ls1sMhvJfgRhzaJ6S05XRKZ76Si56zjLVRRYrUmPW0WHr90layylL0kRHfyZQrJUbiD9sBchQKCNAEljxoYOLGCzCWcWDUr4PZBIUc3Nr5XWkJ4gEBXFcKL2uk2mMzs5pQ9obn6Y2YIaHYcjCtV7iV4qD5am+i2iPa/Uwdzb61q7TY1hYbP5WA51EaNFmtv2LoLmTiThoOyZVyBevZCQcVO1ntLajaqYraVHr1jNuq26LdVj51u7weauWCPCQRF105sIdLSmX2PoMepAe2Fo/V7PiYnT8A6kmSz13kRPRIY4zFwFeNo9aDqmdYEMoK7CdVgrRdKgLmPrWuJqvrTtfl/KKC6ro8m8ZjNaOjD0MHep0ZD5ZJk9fu2qtWma9itSJnI9iLxvJrUfmvjpJSRDrTYREw+VeWPIIcSwKZXF0kYzRtPUZSghhz6nvuMagLlX7vr5Tg1Xn6X9IqraCAgIQhJBAu0pRSnBfWhUddiptcgOdvsWoksZ0PDsm0/t0C8sIJJGBxJjh5pMq2nnak1rtZs2HA31XFFAwjBwXqjXuv5H/p3fQRzBKYhAkuLvN/CioGG0PZcrMQbdgawIJuI+UpfvdPqCzq/dPLbHn7huRycLe8tFabv7iExXRViqVDKD8T5fIFVGtE7fJQ4SmH4lOS6uiXh5MZ8oUvfZ7whYB3U7ORrb1Wu3BEc2mh2JCBDYsYeoI1WrtGpVbbE61b3DGRJL5CVZEa0rqD/VBMORhRdepmCO5xTHnB9INETvyZpUpnhdnyexfvQyM2qU1PU8m46ntoQzUCOgBXUopLBDQIzEHX2wKBZFnaqex8Nv9jzb3h3r+1LvPR0cW5bHdvHiOev02rIlQGuVEJFzVK1aIohJwQaUBLRIJB8cP4beqWCp1YSzVTqCneBgWlzoHVWLQWBUWCFagXzt7DXtxS99vj3yqictSynx4B+Rp6tafyeyvYMt1QgrYWp+1axS4zW0HGClgN5pH6JtpGUvetGD9uSVa2Lk1pqBXhvVkWerKUBzOS31M/SdHTSsUJS9S6kHQ654LxMyt4NYwiq1dquhnkMyxcFwYjdvDu1oOLOo3paMG7A0WSFnE9RJBCcE36l1IuFYFspIOZe0cjHIIV0HTCBUjQZyiQsnYO4V6lUE3cFJUjvc1Hph2bOH+p227u1oOrN2c2HzGPgUtbGpTZHTKxnw0LBeq62yGiUZ+s4hiuF006gwr/Bd/bJwtUPpvsKrCFZWepTOIPqAFlQspCcyo/3Nia/jpNuNtjXqTZHWqJfmvAbYVXvWtY1Q6iJAJsBKIVHKS4H8UMoJpWsdeRWLFZSAeMHaXtpwOLL9OsS3mrox7qmjBMp0jcu+hehoQhtAWsgSW+WuDQR2UxoioUYvkTNE0iRdF3fVnE5vkESCaUpnU3Loq6rn8LBWFIHpUwMTh4CQxDqIu3sEB+vaABAYNzbDGNWUNYU58AOyT2h6etbvd61aQRvS6Ue223VlF0y1aPc6VkyY1OF0PSXEXJoo7hW/KuUKIJPd7b5NZkspcLB5cMo7/S1d+yA4dUo8kTNcGJXZBOYqTs+1gyhaUSsNB4O6pet9BNaTaku9JpYcENliObPTkyPBzhgnMl4mQxCp43iBKdSELbp/ZPlyqQNHdEakjyUR8QTH0WxIGMFOB1JNIS2l7YNrAqIpyfzoqUTGa2fHKkFjbRCB7dAy9SyshVatB1ZpuPphdV6x+WQqxhrvhSg1NSOMYx4WVum6Okc4ndl4OtckF1G+Axywa6GBHNRXLxN1Yid1hmeAuUmLEJm+mpvzypptjIYtOy23hKyGrIfi/bp+wv0nW9RkleXCer1D293r22B0IiZfteo72rwcJrq0sQQYeABAeGIir1sMREaQhBrtQXWbTV3rCAxXouR0SdmA50L2A5zasN3dHVssc1slhb360cel6ES9bWu7ZdVaYRcv7ggixahjoOYznDjZFI7etU0BBfKdED7HEcMEnccTydnB8Ka+SG/l4bl9NbLzO+xXshka4Dlj9SqtDL4T9k5Q5kGA3alFsVcxtsUc5mNiFWWDTsgfaJM/UbFWpcogKI2l59oEqgUZkNqgU75igkWaMXEGCTxfhovSAkzx5Sq1FvBlBdWn1Pr9PUmtccYIpA7O7VqaLZVBwhTFMeZ5X8aTczsakZEd6P4OBgM5fuDYkYREHP3fORzXDsV34TuI7MNmwKlhxD0yVLSZK1ZwPyyz+x88VNZz9ckjOz4eSUMXKBYWO60zzVZkRelUkHDKEaUVeikhm0AGS1fWizrW7vTNAkRCNmIUEHFAgdjTNRtTq58sbaVyBnwBVLvEUHKOUvJqpc2ZPOJ7IrjFNe5VT7AswePJydhOBhMhM81OT5kv9gzIlDITTFGy+rCJzaEFzbHDIV1h+CHU5aBXAWeIPkuHGnG/JLSBG8r+ciCBq/E6tEuTXBAYlxiC693mQFR8X0HsKh0reOCMhmVpna1ta/drdlLk0liGQBmDqKQrlYUkf7fOWPEbbvKOxLhvt2WxhwQBKzJxxC0c9l57W4xcPy5shnZxSDKEIIaDckHDtD+x3UVF5S7VTdGbhiCZ4fid0IkEPdJQfBgSU6D46vBUpUPEWu6po2TjMq6GRuX2dlsOsigcmw4GHt6PzCOoOkeGziTpMpuDL0e0Vy/AqHGKaJtCMiDScEaKoiqGy03tWOttogG5xv7pCdw/OLRL999vjeHQbt46FiSJdqcbk4Njloq2mKuj8alt91rWrjYtqkNIgTWGviKiyEzt2LXVLLGjWwNt3nazKbmnnMJ74Fu/17EH77tPn0FsCSUaGJcNiXNo8n1oQfECiX9DXoF6rPFTOsCh9EfZfMLJK4x9ydQmQFTDz2XEOi3b295Vw3m8Wth0PFJxXPqzCZJ4vI8jx0hqLEt0aAQ7iLXpepC4j9p8RGn6XOjPRO7Uk2s2ok4jzVP6/ZxQNWIAamdRIZ1/wpqrWLWBkyRaMwtxbDDeksSGx6e2nC0Fw2l8lE/21FD/K/cAJSOec7cbWSzSBFJXaHm6qJ9IjqyAYMe1iSxVV4ZNncSoACFMgNhB1bZ6XdWalrTrRCAwsATNokYoJid1FdAIoOjVaq5snL5LRNMfuHTRZTgJY3aQAWOPUSciondqSApkFkibEbg5jVxNKVkLILga51r4PXXyi7V2w2lN1nA+HXve8++3Tq9n40ksUWrqUnwnssjd/ZY9WD1newddRcQ0knNQqW1RtpDRhzy1rp/QOsW0nMHJUA6JwAEWK+xesngyStELJXkMexB/z1QcqPsIZsOCpL+MwJMo2VOwBFNyM+VFfcINyFhuwoamoFQiOVj1M1apA5NlN8U2T2CWz11NnTYHggZqY5umeWrGaI3SdtBs9FQvWi4z9QfeujnQGaUNizre/fdf0CACYGJQCL5Xs9XUaC/qjPzs5ORY7QicRxCqjbPfqCONxmPrdbsS0Ng4Sxz9ZvqLk1F04hsOSqcNq2p+yyEmnINub2pPPH7DhgvKAnUbj0bmB/Sw8hlkawRCTmeW+6ihAQmapnyv0LZ3unpW2ByCXewZ14B9ICC/kR2J6YsRr/e6Kr+w5wiG4TcM5iMJnyDjScsLhLdmu6NAGV3fo6ORzRBx0KQbp8NLGwSHViQr9TqiRIQjcg6B+FgSh2giB6VVPcdOHo7ndnI6UNaq0VX6PeQvXZuUtJnFIkb4YCYxASbCxNjgJNWEpuPTUxsMj9xgBWw818Pz4fVce6dj/nZf+xobYPFSJEjOAfvV7RPsRF19jChGqQUQmyCyjsuQQSUJwkGS0NPu19uCpzsSZnEjB8fTkS3EBXBJE10PZUIrnCN/EeDDHeHsE/LSCocwOwG3xptR20a6Mc1sTDCtouY9bg9RZkNEg1JCB/YgrERucmJFlflmhXUbXSmFkHbD6mJWIArtotdTyCX6whjliPGK9K0LZSNS5MfQScFHkzecUgR9WWQd8xUF89T29g5sd2/P6s2WJJhgXJJ1MkGDm8HGJSMQWysNrN7sixgCJMaMN5p6oyq9R0Q3oQ2OXe+fCuDtlh0e7IgFiICuZq+1Guvrd3AKkdPp8cDpOHb6LrLWZnX6iv3+lg6wYIV1gRyIWqOHYHoh5Dyb6e9UC4qo5Y0FJUApZ14lSjAoqyQlajHQqX0JgNMhs6DBOUemyjXUa2SS2nUCFevZmGiEQjzCEUOQ4l422g0ZLYScF0ki6BVBgQoEigRmMI3MzBOtyZCrpYAyBrW/BgEONeOOzVF2yYGPHHkHCAth4+FgZNPpXN+r1miLwKAxPxBxfNfi4SYwuPmJGGKUPqT/CrFHU0NMxv1wf1e9hAQsmv4CpEtgrokWUNid1qNYj0A6qm2h80hN241A4w9kD7XWMI5nPRVCGbhGvFH/Bf6EDOFAM54jhnE5dxG6Xydqd43tWYhQ/lpkPY6tFlSs0yUb7FsQzuyRRx6z08FExn33YMsu3n+gmhIz+vywVF2lpHYPyIKyFZGv+iBRBwJy96zT31ITNFkJhkmDBxjN5Lt+PQyaHDfIS4JTROYxVM0RUkKr01RLAlApzgLjqQBKbUIow7gsSgxQVEkgMREgSDsTONK3lQe7vSrSiQswEHvAGThqHNAn959MkuxPfbNkqX5ow+FYEG47r9nJ8dAee/yyHCDvRwDyZm/2fOv1d2w2GwqGhiCY50DkzpBqEgtBK9wHRATWPc2QwYBbCdZ4v40Sl+rU1J9yWrjcOCg3Ss2hJwRzyL8FXmatTmg7u/fZ+fP0dRdq8ZJ+rVoyAtvq90Qeo/7KPuaecn/E4lY5zzlhiFt7e9v6e5HdxG5eqDTS7zctXrRsPsY50EIBgrRu+0Ctp8gk4g4yl8epEJXtnYbO7dHxwK5dv6k6clRt2W69fVueTyMKaW1AdYesKuG/sTkQXGhrqrrapDJEfuLZyXBsRycDOx0M9UxarY7u5XQ0sUrPsYCp76ujYDlXnR+0aSFhh6Z62GGI7u8falTfYDx0RD03j0P7GDSD7J1nxz1QD6za46inE1wopNL+ZrgQAZ3QCfmRQMmXBCqUfaK7W4rYJPSL8k0QKBiBEES5KU7qNHdLE5ozEKs8xQAF5/CxBcSS1NQZA5fHaIK5maSwezUKr1LayiPonlgxZczcPYZeNYmiwqzAqnq7iqi0qFk1/lfv1NUU7uWeVYOaXbt8Q7CQl4XWaLWtzMCgYYHm6odbrpwRVjsAUx9ienZQo19K9kyQmqANdTFrADQsWG82lZgv4gO9rS07B3uz25F0HDeGNgnEoclMpBzTrVm73xT81e4QnTt9STKck6OJiEbUqhbzzCaDgZ1GHPTcnve8B21nb0cbZaMpuVzEqhWSTUr7MwfGpPmeEJ9xLTBxoT47ijr3qd3tyPBi7DmQHHz1wQFD6+Bnlq4SGyzmNh4NbT7bsV6bJlvXJwgEyTXTfI5hZFfhNDOiQ4kjQ8NeO0o2JMXwstAhTk5PFJ1Tp8IQUEfd39m17XZXn91kHqcyEyJLl0V3uj2pFGEwcZTIjTFRgL4wIGqiSeZOwqTFUTI1g2wDkQMIQ8Ah6psFNl8HArAKGzX6LV3QsJlryObHMXMve72mbfUbup/nDw5sZxshBGZrFoJ3+b1mhwI81+SMAT1znAqCNeBOpwdaUV1XtT+CMYIKMY4ROkeImfYOF5kLapKwBCCEo5vLyKALKsgYpklhaYzzdbMsmbBATVe/7wG7g5TA+IQYo3BSz4CoeXdv3zHvckBuRxTiPdhLpYfYvpsPSt8c+wGWISzqBo5ObRu+Bg9wDRhjRMsdWxgyESWEWAHHfAHklQopwahQ20F0nf0B5Ks6ol8qCEN4gCCSPS2mMhrOanh3rMxYlHw37oq6cLxyMxmjEB3Q9RQXWkNg5kLjV/9cqJomurWICiCcceXJ67Za5TYazpRxgio8+urHhfq8+CXPd6WKZSEDzdrb25UuruC1dWsK2R+KNQTnLmsqZOwgSgHNcp36vh0nYsEzoCa2+V2+3wySTZZarYkYB0EdnIW6nb9wYJcvX7Gj45s2nQ1V0222qFUjICJu/RqWD5X1akkxZylmOPwCjhz3kRovhLz5YmzNWtt67YbVpT1cUSuVWkOUzTQc+a0S2gEoQ8Izz1QfPzo6sps3j6xaa1izg/IPWZbrQeT8aOwdZMbp3CajsdimkM4gQVGDduhCpIyV7BZloj/7s1cocAEF6HUpF7mWDHgLkIb4fRAG/huxEZCeMgjsdDY1htzgsG4dn+h6+/2+YE/1WfuBFLn4eymmsQk07m6l4N5nYIYYzATsMyF8ZJCLGQIjEPgQP3cqWQRblK5CH4Wythv6LjLW3E6HcFGmIgiRrUOaUpDHxCNq2+sxbG5a0XrerlA211PKnouZjwlBD7awqlJMl0FfFsTAjRCbjk/uraPUyBfN5nOZEX16OBIOqZOnCs0Ss+V0JW3K0enU6lHLyszJNnEYgyARlp8XHdUCpE7S6dhgNLbZ0smMsbEda89Fh7CfpFJKpCi5t8yOTo7EiOu0O8oSt/tdjV2CjcWmDAPftraaduHing5Fu4douEv1p5MTyVQtl7kb5OnRT+go8kRz128eCwoBWuv0mb5dt8HJyI5PBtqATI4nSqJgLsiAgnnhRI4xTiwc1cbAU19dLR1rT1PWEdZeS6Rp8gDQmyaRMgA7NsSscJQt5N7CUPR5waxhYGNUN6jY5UTRpVGBAb5W76OmNKAGUlVNGCFi0d8nblo6hff93T1rb2+r6N1GGKACUjK3OFm4moU2b11z/3BAKMu4sTqE654hYpELVvJVg0C5iLoKLQu0hFSD5prenUuzVWLJXmS1VlfjflSnm08UbTqBcqDwnu4J2QIsy2ajJuNM0MO+gSCmWhJN+IzcIgjRJAH6eQsJxLc1bQUxCqeWwx5THVPkhfWoLDEB3T7WaKzpVLAxxowol2xGTMH1uB7JMRaOwEaQxF7lPqzo3UTInc5ayeKZ9foNu3D+wE6O1xqYtAEtgeNjq0du6DURPw+ZmhiOlKALoQQa2VG5EpQGqUw9uohJA31nNpkOld3lGgvlq1bbrnbEduY8UI9pthtyGipbZLHVay1Bt2IeMpWefYiSEmiApoCgHeb6JtFL1SxOhkfTp7YWk2b0Guo5QOir5URD0dV/WtDvOHVtI2uIv0D8vl6Togy11Ws3rtkMbdGxa3/wg5qGhXMumCayv98TGzScUTtb2WBwKmO8s7Ml8g8OhYeAw0tQ9FoP197ozhIA8k+eTTHO10iSg5g3kKJ6Y7mX8A7QBM7d60+ORgriqZczS7YsG8pIQaDSbGbtLqIPjLByo+VCCaWDUhQ2GAytkcTaj9xXoG6ylFoN2H+lOZX0/WLzqPthi9SaRRASu9f2+0RUBLd1jU6bDJfqs+U6gaypAU+mR9pvwLKcS64dcYnB6YkcTq/TcVNp1ugIryUgCSqMC0RxKtFzoy+70UDbl2zWtQDB3i3Yy2mhZzFZzG26WIo8lfu+6renw5GCkjItpfW6u7tr5w/PCQGi/kqPagfN1CSx45MjBaOOYwLL1QkggBJhhzfPDJsANAvDmOeDKDtjtrDvBLLYJzgc9DyfTAZ2PD2VTyD4bsRz7Q8yw7mQwtj5BloE6U1dNwLS20wtGhtNHynELuJ2nmWY5tYEshJylK/va2aT0em9dZSor0CLR32kvmw654OUF1E9GU4O4zOzq09cl/JOsszNQzhgHlu8cHUnWKOuybWpG0DmiK6n1GT4wpAcYhfZO0aeI+/oQBKNrzc/qT51gNPVseuB6nWtQURSdzWdTrdp3W5Nkwx29hBER8ZuYaPhxEGEk4X1ujvKeMYjCDcVGQtm5eETmNrQ7fdtd2/LqjTFe0ObzmYyKkyhwMA064GuezadOXKNhv+68UQSBSdamU4UNQGBikRDrZZmW/VA0ThronZjpOo+0mauPgaUrJ4NZjgySBV1HNiiAzeVHTSfaJSAAoUJRIo1mkzSZUSYzmFuWLNsCiA5iEgizswn1oactd7UHDBJxZVsIITs2RaFWMoU2ZHY03w3DDyTzZkUM53aycmpnaKrSRYW1qWBS98sSTaGAqNKYEMdlOZ+aio4eiaAaBpEA+JL1zqdtqB3ZLMYxDzXvDzmnDIM17Ec8xWM11xqPDhlRkFJXBtyATKGmjHqiC4idKl2W3Gwz3o5p4nDdFMiOLwELE7XlXmehECuDcgJOZB9poLp6KeDqCLiiGjwzMjj4KfW652zS/edtytXTmw63wSDwJYYMUQWnGpTJiUvRjCt1EfL86eJHEIRNWigNKGYKBG12zaaDCTlR90IIQ9aCzhDZJMINlBrpW0EZ48TXI5jS2ZTu379SFkKIuQXLp1bt8ggV0cG7uT5gGPdcGp3Jgm+1MLDYCBNtSe4rYolfXo6drKSZkJvyLy2dzp6djW1GzFay41v4toob8xnSzXcsyfJrjQ1ZKfn6mMS/kBAgiyLySSUP0ZrdrsTKeeeC3YTorQZ3uwmtmz+Xa8PaE9y8LmgdQ09JxBeuulFAZrPqCCBXphdu3pdIhCcSfo36Wl8+OGH7ODcjiXpTOQz2lk0q1KjrNyEDt5b5191UO6l6612Y9Q4j/SfLsQkh5MiApKUxxz6AxzOuayETuzfTXDJVc8bTyd27uBAmRPZFuxmyjOp6vdMRanr+2C/CFLhAYBksTc2WThydiiIMVkFibZ2Z4t8VHsMiJ8aOxDt1vaOYFXaS7Dlk+VCjFoI3szS5Gc4PIQOItoAsSNJonm+CCVoIki1quzx+oAJOI5Ayb5UsIpqmEaE8XluX9s6qOXoCCpX60qpQBrWv8aqIdiCkElZ2K3jWzZJZjoL+Jc5cyvHrqVE91XKQ5zr4PYeln6sMtOaRCZQM+INVIZEnQfkJvdVqwdBk7AFYu7roc73zlFCaUboecFU9onV+g2ziJaAqtUR2z4Z2eVHnrAnXv2EjU/mFi8Ka1TRMmemnamRGIhGkku0hdCOAHwmeTWw5dI8CUY7pQVuKBztDcNJtST62TTnsSI8nl3A75Q0GTdqtk8vYxf1lqp1ejVrdRinQyRPXQkIh6jSRYoc7IpPXyiDthxuzndMEQQujqUAA/Nze4cNVyoaotEcrUeEhxvIdUWezZOhlTDw1t+JGWxEbgyYVVsEWHqMNiTCBtTquHY2ABqvrnZBHbCyzhgkb4WKBNqRs4UIRtIE3d9XxEkGxzNYhkA+NL8nVl1Cya6uD3GuuhU1ZDkmhuCqSZhMAa3eWPUNxvBQbweuRE+Umh9tIrAfidiAjCiJIzQMgQfoKKo29Aw0HgpBA2pg9FXSY6sWFjd0laywBrmhQl2QYIcMGmcKW46h0khUEUy4gdcENxwq2LoS5UBiDsiXEcirlU3mM0Fg1Qb9q7mNpie694ibV2vw8FzNwjaqTDyHihONkKRgjazNyaCJ0gDsSH8YEHWc3K5rcdg4N6u5G4EEVAR8yqQXaokSjUbpRtPUM8FRVTEsHarBQGNGbeEoVNtaE4lQImGCCQLtQKU035Od4HoYKn7hwnm1WS1mYwt8N0BbtTXBanw7x/RjHwKbScQbGI+6FMacRu0U7c7auk8vUZ2P6FqZT6phT8pSOYOcLWk356Vk/zQQW9Dbuj7oBTaZUDJY2OnJyI6OgDoTEUOocyOXd3BwzrLUs1kx1yQNAl4ED2CLv/CFz7P777tfBBGgXeBfnD/1fkhyHmP2NEmC3j7XToNjPD09UeagWZwT2JxOXMIRc4AaIQ85Zq+TtHP1Mf5JjYzn5ya6rAcmwF71uD8uuJ0hOZikGs1WjRqqd9JXqwHVtN0xC7LhHI80mBOHBqhHG4iQcx1CRGvoPNPyg9MEDeCzpdDjO41XzbdFRhMpRjFrKeNQy6R9AzKZm85COxOvB7nS5KBKYD0j6IDoQuCKbrbrj5TwfLBu15ktJA7Bc8ReEBRSW330scsKmtsdhBz2dP2T0UTlLUkAavJQKCIM9WV0oyEUksnD2iYDFHkem4+tkCZsKGnRmmQyEcOoSj0MUh3IngZbA3fTesTQCqjbhJx0NJAlCtlYj7aj/ihZPxwn47YgtQVCSiazqZIldromsKBHRl2U+iMZoiqkYI2UVNYJCSx2Mn+Sj4Sz3lQJAD4bveUESOwBbN7JAG/LKDHOdqyWMwcz3UNHGa8KGw6nVllVLA0L6+1tWTvybDGZ2aKY2/DoxG4+ccOKJbJBofmwEJepDZcrGw4nirYolvd7yEu1lHFsdEVRqWdgMFlb0/dUh5RsGGxP5JbUmOpgM5wLUQYUZQSMYUcyokfpfugL80Y+jizTzQ009cBNhgtLl+RijgAjKnnE2CpvDaMgMQbUlFg8Wdojjz+mrAVYC51KRM6ns9hKhhIz84wenPV0CVof1P9DbRFFlppL7SGq0PDLpgBSI0t2LR3AMo495nROuRfU11IRl/g7GGzUH6fJTMo8GHs2r6BQ36mPUG/l/mioNjU91Z2cLivZV4FAAAddAvIjW0izsW5p7KJu6hZOlSeyTpdp6xT7+Tx3SJ0MUil2JhJqfkj/pkmWj4OpbJ9+SolRuOZiMkYySb4H2YEybAwVrT1MGNEwaMglbuSOxJqXqH7Qn4cgMwozkWjbYmvOoe0nVgBZhxVJJ47GAzURExB1e03b3em5Ia7KDp2cmZO2YjB2Ve0SyjJixrbh2GoW4Uizip6J0Iv1zMl4SSsOEapTftGAYNpFMqdxzDPJS5h2HDYcs68oHph6d6dvU2o86czy0tWymYIwWSxV7+P1p4NTCWTAmMYhIP/I92Dvhv2Wenf5HrAxEdRoNjpOWnDdcuRmiLqAqF5n79QUsLCPmvX1QPMMecCmoEEMTa3W1qBqjc7C+OW5slSUXmIQDNAi9hXCFAF7rSGje/36Tbty9cjGo5VNxnPV0QhaDw75/T3L8qmauunzI+BCIIVGdGbkbfX2pFsc92MNpF4mjI3j2ni+rubneuacdCBwqnNurhkfHVkyFFoEHPHGaYXiGNnvOExQGhAYDQunVMb/1pN0NuxZMWPXQTIzNSHAUSOCgY1N2tohoCDzh+AxEwERx4AiWCqmqWNUKtBj0o6GMIcSGQDy5P2BoamhEaxx1sj4MP7YFO4jKAZ2hpYVgklehxOFUY/0I9wAkWs0wYUMNJdkI+xWAqElurSFyTnBjRAngNaX1UI2pN/b0h5BOpTMHMF2stdmm2AcZwMR03UncN9gDVOuoTfS7Stbtww5prcKX9Ta4VnA7G021Cd69fr1NSnR5CzJREG6pgQpqBBVCKarVtOYPer7KyFyjByDGS9mOf3m9HOj002AtrZZ4rXTDle4JKge1M1H9UytP048QRA4magUjbli6pCuFAZvI0sDC+Yr29ujzMN+cZrawPJCdHD6QWDzKWiOG57gFGnvoaOcz1c2HMOE8i3zcjt+8sSWpzObjsbmU9+bzs2S0pq1ls2GtFy4/snrt27Z0RHzHn07HR5ZfHhgaH6rwRrDUyErLK3f6QhumK/nSBKTAOUxGoqHgoGT6gPjuJhoAEykWW9MqUA2DcFk9+9kS341FyFnOoYoM7NrV1wUT38lBwvVC8bidDoNqacwSYIMAAekNnCYp/OZep646Tje+ZR2h8BWTF2gnQWHgKNVRkq1sLAC5w8MrcPlnKfYrSjhkCnyZ32Y2QKSYYIJRl1vDkxZWAvWIXAwbRdL2g1OXTQrqjmbu1R/oUaaObBQGYGyp7XWKxqybEyfeWvr+pOmDkhGEeVaYBA38oeNeHB4IAMwGjOBALFgRO09iwIMekfR8JK6HfPnSiYDlCKe1Ntd20oTGzJtAFEClIuqoW1v9ay31RPJiUwXCHZ4jDj9aD21AWk5NjmyahhaV8cQMUbwMbUdFDucwHorpOGYOtFIkS+ZD9kLJAAavDHUin6ZnF4N14IMnAXX3kHkijMgwpd6CmQoAowKMLjTgsTYKNhBDSWqm5X0xALRusxZrSSQg2Drw4oOaOz2NIS53dq2fq9tUQixYWxVDSluS+yb+hEHVtNWVHpoSweV0VqItdOnR52YujFZCWQVzV8Mca4gFA4qdplNpP0UR+6cYEEwuoPpSEaOEgcxjpuiQfN/VTAnxprGcDIhMiAMeKcVWLfTlZwkBqkM3UgxWL20MFE6cNAe0OhYIv7c45s3nWJQvenZS9/mIYvCQuSO0yM3kb4aOOlB1LioQyNK4M8ca5T3ZW6Esj2NV+K5ODk97q8QIIJbWr58ZC3dJA7uC5kSe1ZqV+oVdQOdcYquNcRlkipxMKQagy2o1g1nwDi6cwd85xRldne2lGnX6sxlpNd37gI8shGk6mpkhtTGEUIg8FHRa9025IJUrgfSnOQoA6fmRfY6nSL96MTXuV6gVTKu4WhkVFduXD/WM9pkxJD25LS81A4Ot80vKxr/NRsfy6nggDmvg9OJDU6ONfAYtaxGFdZprFYeWQPV4gLViJHdc612RI5uLJ90fNtta9Ouc+wGWYDY7O3sCZKlNML5gbTURPt4MbOb6DWnmeqVp9OxjS/zHRi6XdMA+wz0rORcIyJjKglUsGkioCEyUtMZJIiuMjy55tuc0hH2XPuWlrRIIh9cKoEf9UcY2UCkoheso1rKHeJq4CDdKCkR/0hOVrB2aS1pOWcMu7bdhYUfWg9Iezy1o5sQjBCNBxUI7q2jnCE7N51oAkBnu2WnNwc2r4bWRSfQ922RTJ8i0USkjf6hiq8oKWBgiTIEozIvsGLRevBwU7hyadu9vpWjkTZEjkHfHCiNmXKTAzQAGOdDLxvjg9bsJx4oOqvctPF4ZNUGkcPMypRJ7GM7ujGQTJhfRiKrQLenNiajCsxVDWxwPNTGpDjVbNetQ2sITiUvxKTttpo2W5DuE9Uj7eUMMA9Dtxu8XHOrXd+UE0qPrNMC5nU0frFDqelJco5DRU9WqmI9MIJk4pnw4FFLjJ2MWEZjN4bd9QFqfNlaIzKJiBSdEDGOlZ9Lj1Ii3k78mwNFFoWR1EBtNVOTtSZWMqtQEk9u0iUT3WthS8aXWgcTIY4nRzYYjrRZgYgw1IpuOZaVirVK+vmagmCJ3FxdlmwN9i6tAbTVrNTsTa8pWSwqS6fDqQbu9rd61m67ET9ihjJ/jpmkGFIYkqlJm5e+LnpIGdqK2HOvu6u+OiZ5AFsx19Npx2KcXFaI6DpG0iMMFkjrhnqHtNbwvTesWBwmUS2N2ewxCE1MiNDfITCf2eloKHKVy8ZpHdqSgTu+NbAVNXkPWcS2Ndo1jSSD5WyemzivNn8IKrTNRKAJiWX50gKmOaC3udZ2JUhhjgVwrZtzGLqmbykMOUF3N/EDdmhN2fkTj161G9eOVEOtNxt2eP6c1Wo4HjeomnIBhAacLg4CBSmcJdq4GpdXICo/sHrkJBd1nminqlXUZE+gxNk9HY5l1Pb29sV23jvcW9cHXc2LcUsYbk7D8ORY6kwQ/jgD9fqu0R2jSR2aq4oTW/MRRJgpLVtCcJI2nWDBND21Xnvq+v1gX265eZ6bdh6cz21SzyZIojEf4QDpHjunQP1tM3sT5SEHv9LfyiQYxwbln3v791uczGXnxoOJgjYMNf3jZeJJiADhFQw39gNHyu8SiADBKvgiXfYrtsooSWRqWyEg8xFikDoMAhnMmRzJHvRaO9rznPMoKK3RQDsV9ryrbZYl4i6OTa0yDfwEZljOF9ZrYaNQmIlsPJk4CDSqSRZSyMqmdKWe2Vxa1Dxf5ui6Wt16pqd6EGlBcnNR2dMwzAlkbh3dtNPBQGgXyAWBNEeJurKGrzOXVUiLp3qn5DlBzzQpxIkkONuCW3PJgwW0peRq3aD2jm0CBaNsAxztB0w4goQGM59JH66EpCwRHstmqg/sbI3eAnF0PJN2vS1nDp8CXW32+Xg+1vPdYoh4SY/wReniSnhlNbm3jnK+SPTg2aLLWWzT6tSau9D4G7ZC4YZWGTZDkUtRY5kUthyNbZGu1ArAgF0URtRfCN5PszxxgOAtYKOmbfXY0Llwc74+I2FwDIoXqHVpCHNt7SircmQRQtCSdnIFf9W61sN7B6cjDTMG9oKsUK93FeEhq7e7R00gVJSCSDo6hsPjkT32qidsNhlZD7JBvaaoBiuV1JHtcyLrkFMYg+NUcRw924n7OifpBoomtkJ5hc29xuO5RAwdSiyuP2oN8alZGGhwLRhQQfeVw4L8HX2psRvrJSzetTnwPalNSdp4PdhZo2SQoYMchYOBWQbzVdce2Pb2juodZHVu2rhnVeCJdleIwXI5liGR0Q4yW6Zje+yRy3Y6wkkWbkOPfUHe2ylZUlOSdXwXMgK0f4mWyT5cwz8qMU3VzuiBRdh4ASMNOTixfQk6PFsl1O84YzSuu+wQmIohyYKipoi8Q85gBl9LcwFh76GIAryPMwGWgUWomsaK2oe5mqho9ARpbtAszoalOYwwdGnr4VBrGju1bIIVpp/HirQRCRA0iIg3LE6IDxyChIGIZCeQU5iQciQJvRe/6PnW7JCNZrZaQvRyrTsSeUYg3ofABkxuTgCDGg6ksNlMdVHBRRDcYDHiJJUxrtSSxe/Rt8xrdcXUxRYL3W8mv3teVdJ3zL1kMC2TLBrt0C5dOqfMSL1/NRi1EFzcbD9EtnFOQJwcYuDMqjKyivX6XY1y2o4a9tDzHlSdkvYPMjHEFRYLMmZk0qidhlY72Lduqyfy3vUrt9TjDJuYYPS+h86rrQslJbgYG5UdHJrLHqlzUpLxhV7gTGFCO5IPknYMRm6vmb7OEW5gVhzmpnYpQX91njmYmuAQh62WBDGtURJCVhFinoPtsLkQdXCIBGsY1WllJkY15B4pdwFJ6vNoJYoFx3c6rXXG6uBARDpgfVL/LG0qNjjScQRxh4fMgO1IV5qzDuQqhap6TSOsTukTjBe6R+wjPoMZlpxjnPxkMrY4geyWOWIgOy8CGqU9yQ1L39wP3pPaJTX8xQyZQZdh872oNdK2oXIQGXmt6uQpCRDXQSw1cgLi6Xxsg9HAVlkiNAvkD/uO+AuZIfeFcw0zNliXJTSiEJugdihG2zGcorBstS5HIfWEUhuoB0F5vWaNdkslL/SpOZacb4Yzu4HOMI8pKqIJ7cg9GqSOzWPcWemGkBPQMKzivkv32UPPf1i2inID9WGIbY8++oiN5yPrNdvWatbt5GYqzkejWb23jpJMyJE3Co1gCvzUtjttm43X8KSyYgelIFkGFEChV83Q/J0iATeWxhl2DmlmCZMKaPsgAjRGDnXM03QMtE19G06mypAw4BBJMPREvtCr2RjiKWp8FJT82KIcbxbYiHoqmWmJQgwGFOHp6VrFP7Br1z1bJEROoaLDra0da993wYIc2GRknXZNjp1oWe0CMdFS5saMcbDWw0prNNzCQhOuT0bmisX4V5WeBTvi+J1WqOwzf4gu0bTUdAv6NDynUgH7LM5tWi7MazclRoyCB0aD+4rTTypkMy1BHAQWGnxMYVrZJqPKkJajPQDGXFW9qtQONEh2sbDJdCIjy7OAHMJ7rhZTtRRAg4+rpc0WS7tJ0/j165aUrgmdZ0DBfp7kdjQ4VeR238WLIqgwXokoEBYwmx4HL+m39MSana70ROfsCY0IAmFYH1Kk2wYTZRfca+j1sN/oraw1I9va6tkWdVSpiZgdH53ardMjO7qJ4gtSiblduLBj7W7TKpGb2SjJOHRd83C9bx2RiEOphFNDXV2vqhRoELuAfZy6WpSm02iKh3tOfDZTZ2AqErljJKk945zIBg8OD204PLVVgvYx4udtCTBTHqAmQ/TM5Ao3JrNQP+qGfUpAgcBBvoYGIbtTyxsOqHvT2oPesZMcs6ZzLpspIJoriq4wMmXM3gvo25zbtWs318LjCDj4GhtGrylOEvZpo9YSuxijBnMd0hm1fc6JBM5pN4oT293Z1mDdyXRlF8/v2+XHn7Tj4yft1Y+82jFbFwOzYGaXLu2KKwB7keviTA7GI7t+7VhQK838XCuf44eFhQYs5hSOnA4vBQQkG+l/dUEm2RNG29036qCFHZ8cax87hRU3JmoDSfMzbM2mLUQN6OveVe4pGTJndH/f9XoyOUiDz303tJnYB0ZqljM9BrjbiXdr0HDFt5oPO4Sg2KE5QLEqHyCfKPEHMk1gRN4vlfgEgvkEoLRTLFaoO0HSA7o+0hlA95l7Q5DSaVdtOhlYo16RA6bW7cRYnFgENpRgeb5wsphM66D8ALJD0LIESkT8pSz0bLa3+srmJ7WRnJZjDLsZpa6XEfEAX6Wog/091za1lpSklQj1oFvHN52iTQ0WN4z9SAifBjWvByHQ87uEdVuvS/CCuiRSl/ROKgDViCzslwtIQblAOXDa7EG0YNczC1xZivMJ4agOMhAL8UGBC9a8w5BdtwC/o8ZDUBf6nEtG/jXs4vmLdnB4zpGitrtCPV7sv8hecvwCe9kf/LEtxjOLvMiyuCsEEeLhPXWUc6JjefhA8kxNmlb9ioSyIQGoKZs6GPWisGany4ngLj6AKFiwROZYglKU8EI9MCIcboxqdczMa7UtRNSXVglIHAkMSNRSFoZrInrEAPHgGD2UlRTeUfNnoHFg0+FcjgBFlE6vr0I+E8lhH0LF5mE08qqKwkAhUNQ1QTsfi2EKZMz74TyZtEA/ouojGFIvtXqnba0e9VTk11I9LJUqJTxNpFRa6JXWVsbbFlmp4DtWkAeLtNlx3mwwpyriBveSmYpBl+U2LeaWiRzgJgli3DgQo+HABqdDq4YwFFEjyW5nomKYSZ0/MFpXM3qQOMx1ZuhVVZ88GQ800QPDSRRYqbQFc4xHc1cXQlABUstiZaPZzG5R44C6DXmCXrkaEJ4vGjm14OPByHpbOxJNuHXiIn8cMYcVA80z9ysYbxh0UOtdFgCtvqSfP0eBw+mtasan4GHqlDg7Zvq56B5yFgcPWIkDfnx8asMBTEoo/ysbDU/t8Nye5MUgi2HhNGtOo/5czYbG49FgJinD3lZf0mIw4IBmxHCkP5DMjb5AiAG0BQjhc1rBOE1GSI01DssJXysgQOC+27atvb5lOYpGCP5D3HA1sgUQFUYAZydnzagkN0uSOiL7gKwuoJ+XaBtW8CyxwSnawUs36BYJv7LLOGwLmIhguZ5hxXejtPiDchUQK0FXI3Dao4Phsd5rf3fLWo22AhEFA9TzyBICX5lgvID0AtOXwKpmETqhZWrDwdCiWksQP7AxqlGPP/aE6jycwcHp2P7ilY9rf3a7QPluIADEn1sntMpAcqqLDNLt9S2IqA8z5ID5iW7ouMQBGAAeucxGIvtrWTqMMcxHzgl92gTT88z125INIYnnRByQCHQZJSdGAvpkpDgDKWcB+0Eco7cOh+jGteEQhV7QKhW4nmax0iVkAVt7TTRR9oKYuqtj8zyddB11ZDJcVw6i7ET2RcB5fPPEkiVDtgsrq77geVop0G2nxYzMkUlG1Sbj2FCnQs4S1nUq/Wf2NtD7YjWXkhi9miAx7F/XIhfZDtB3LbR07Gp2wJgNsbDrtr3dEydDoi5AmkDtS3pu27KlZJUEKDuogWnyUVsBHNOP4AxMp5CYELJAbJ+6Idmq6wdndBsZ/u2gRLXJSJNqUtCdFVOKKC+558C+z0OCo8Waj+CCHQWO675G7KYQSXEI3HPgnrpRWvT+4h0RvKDuia+gZMIAcEfIA1+n3556++nRqdU7DQtqFavPJ9Ksvu95560oVvbqP3uVdWptcWKQ9Fx3Ht07R+kK2RUp3m9vdTXod6u75UbcaPKHo2xTA+l1+xYnhZqOpdO3JkvAbhWbLXTMJyJ/sHJU8aWCs1xpAC8NszhQV7Nhinws4osb5bO0KYfIo64TWUFknhS2SBeqXwK1EPWnJW0E1AjWswShJXMwm25aBptwNqE9AIgstXSJAn+sLBKaO2wuysXAhrAA/XBhQ7KJesUuXbwoivaNG7fs+lqcux5lNp9OLaEW0G5oVE270XS9XL6bf6gxZJGDRNk0bAgxI0t+5tQk+O4LGJNopdL7hE5iE0YokV3danWYrpktBiPXDkJELZYzJKdc5JR6SM23ZcsYck+kGgr3U4xTHDyQYpUmZLJYslJac+jPK2RwMUYTRMyBS2EdA5Vrxhsz7hBucH2OwCMnp2Nt2KxwguIl31V1J8aauXo1USyGmXrFpg8OZEDT6dc6qxg0ghkycBqHqS0ORxNrNWvWunhOGTNGlGic62+3OppAMxye2K2bp8q6mFta329oTA8ZK1E3NdE5jc4EMkVhzU5TAgI8K0gyGEphHewn9ChrLUtXPAvGTCE04NSeqE0tlnUbjCoONlZmR13Twe20tjB+gvosZ4AWApwJtTZH36f1iV5F2jK4B7C0q+ZF1NIRNcDYOuj8yctH9tgjT9p0jKRjbq02dfX7rdnakWoSko8YGa5ptXRUerKQWrWte0h4DtOU99rZ3VI7RLfVlgPHQUwgkyT0O3aUEal8gNGhHsQUCHgDtbotRBgq7bHHH1d2S9ZweHBgo5GDfmmbWSAscDpRi4uUmaj3tRCtqIiIo8ZwMsAq9zAwH8gf9ijsU58xR66ezh7oMlnH92w05PrcZ4sZCwuyUbeAPUQGvd4n9PK6kVuOGXn79YJ03dmHhY673TC5GR9G/yH6wEwyIfiDbIRzpJ6O02RfOuY0zsXV8qjtIRTv6pZu/qU4CDUQH9p/XDYp7efZQOgSddDl4kh/f4pgydjNJm00K9J2JnNrtEKrtdiDhUX0ciNpiHoTZ4aWorQQCWhnlxo29+tEAcbO3q7t7O9ak5o5M1zDwKJZVdfVqFOyQMzB9SjqF9YiGghybK6dvSUGdmMoTeleh0lKdY11yxAFodtBU0hK2R5l7xLicf+UvCDngOtWv/HU2rWGddugC24YOnZeULlmoDZlg1XKaDC3l9mXJBwwkxMF0mxsCfbzufyBba6RdX85ukt9rUrKgKadnit9/PRMo0aEMEywZtZO51PLvMjy04U1OpGdv+/AmpWWzesLi+fMN73HY7a4OWxmRjmhXMG0DHB9shU2CRAXjoCfMU9OKhDdrm1tbVkkYfFSPVIaB1QWgvYEqeIs4pWFzFucLezo+ESHh0OH4SJ2UGVUw3Sp9yl40IEkYh0h0YWQ9SZapEGdFzGLLS3vmNbuiCeIA6ALW1IgVqpPpF+x0+ZIRnlnuye2Iso74PJQ7um1qgwG9upHX23z5diancgOz1+woO7b6WRo3qRU/yYRWbyq2d5OT6NzUOKn1uM+g4kPTZFYxlMGiAYWJG60lWOkuWGn/Lv0OclWAk/ZItJpkiJT1r0WxeahiNot7pcy4SCg/hXadq9ny6Sl3k8UlFDmoPUG506hVbCo59tsubIj1EY0jDoQ03jG581nkonSvEvBK7mgXJyPBNjXkTpROoEOxhDpQW14EV0QosDQwM7N5LCQWCPbnVBroJ+L0WprSBGnCcqA45c8nQZzuwj/qOILjidr495B0OLzMP7MeMQpjEfHbrIIvOPM1WM4dNDlxRpGQtAwUjU5MCJjfZZmMZIJ8R1QIqKlgMyFzAgYzokWAKUxpZ3vgRAFOqYwUyG5EIhApmJ+Z6veUg18fNOJSGMg3XUFNhxM1ix41JY65lVqmshABA/iEYUN1SYHw5ldvnzNnnjiqrJ3PV8fgg0BiJuSgJNttxGNr1lZRJosAioCYWo0Hq4z+tB29y9Yp41jTm2+WlgzqN3OHInEabugHrip+dPgRu8j2fJkxrDloeTBjo9OrCgQ8ti2+++/X+1enCvEPsI6teu6nDLlAYIOoOr+dtfGo4XqtyADOB1Nn4/qrp7nI8vogqdOsyWjSu2VTOLSfZckKHL9+nUXVIHEqNHc9TqCIhAY0pYhAQ7gOcgobUe0wk5xfVGTCSW5LVPXw2zNyDJEtNNUdVoEENKc++LUe3hfmKxcA0EIWaO0miXmwZ5cE0gYnQeEXmXKjNNJhoCIsDyoEYgW555gi4kv+/vbaj2JqtwLz1odRqZ1b8/hzEsXzMMo94Dg1Q3huA3U32FSj9PZOkjAZqEXvbAbN49c0MNkG4YgtFuSXNz02sqeIMzAYAJJkNI65xx7SJtRTgCxtOPjYyF93WZNCEPGVCO0gtWGBPHGzK9BElwJGpcueoFtcy0fMkW6P06sH7au+kVDGNp18TOA4lNqofSVU4tEfxq+iVo0nJ3GhhOUS9gfpixtcpq844T+uU/z1UyqPnLWBPgEWQFdEcyR9ZQITEZT9YbCxSsrmbWzmqU1xP59nb1uvW+det/iWW4vf8Ur7q2j1ItxQvQZUmuajZTCI7PEQ8MzA3/wT4g8ZJU4VWpusKZYsKqielX9O2wmBqxK6os+wSpwayHHidHVDDoOB0Z4rffobmBNZBaPyQWzlQ4XdGYnUly1TrvtIn0wdY1FcuQaNoqmkIxHjiEKZCBSB1nouuhe8e3m0Ylt7/QlSba721e9MwzdZ1Mcny0mdvPkqh0+cM62DnsWPerbPB5Z0NiyFmIHyKIBV1CToUct52BBMgLOrVqczS0fIxtGo7UTWgdeIKKkvglMQnEJ0hNZLWaROu1qMROrttNsqPjvjA6HHpYmUFCkjAoxcbKt08F6WDEqRsxXpJGE++YFtmIUT17YgukeMOWYUA7zWFEmvtQNyw2Q62q0HOtOzpIMyzHwgNTclAq3ackgmEayEaOumauJisBE76JINQ424hCDMpBlqzlbvyPBRtVs1V9lpYQQmEwBWxZ1DYYl4ySIRsWsVWsA2pgNza4juudeogalQcUwQ8nIay3BWUTW1OHQWuXAY2CFptFuVEXDtbQnHn3cTo6GCipo8N7b7YmMEflOWJoxWbBFj3lNObUsb1C6lhFrNi/IcF2/cWyj4dBOTtj3vu1uH1iyAjpbWX/7xO6777x1Ok0bDJg9eEv1rX63YcezoV1+/JrdvI6jhegF+SiUKgpBJj8je4Co4XRqXQ2IGh7N+kdHjH4rNUSazAikIcZJ5KW12/va17MZszXRZcXBYJFPdQ6piRXrFgQCgnxCawwEOqc/yx5D8L8O6a4/saPjY7Gw77t00S5cOKeMHufFvYKIsn+w7ZxYYYL2EPAgawFSpC8WdRrH5oWoRSM72Y1Tstrd2RHZzzFwN9NDXKO5OBBkm/AllD3b2gYkdu7w3HoShRvGzedDdJI+buDazE6OIRiN5CTbHfYwsoI0ytPfi2Mn00eEoOHGZJHpdoFZXd8f95s6ppPkdJqhmzmQqMKMhwiCQAyi9juz/cNtqzdpUeg6kZIKetcMT0DYwaki8T6Oxbkef5agj+tIRrCaT44G9sQTN9ywg8RlylzrydFNBT2gQRcvnLfDc4dyVptpStxzprPwfqBmqG6xVxj6wNnwGZ0WLxUIMCxhttW1bpt6ace2+1s2mVJGcUiH6o0a6uCgUzkoDWMHhXFzRCU6ElLP7wmuB9kjC4SsU07HKn2pVSxNFPzjtKlfElwwcrBSODuLQ+dZRY2mJUDcMeIa7IPIKoVnkwxpO4caVb2aHGWr0ZGjJCg4PTmRZnW9ua02Olr9AvUVp26aCP3SSSqC6ZNXnry3jhKxb244sAgHCviHQxmEKLkUKjLDaMTgQbEmam+22rc1KDESmp7BhkdbE1LJZKqUm4fvhVCEof43rPCWimiYVamLXGtKYsA5BBSt+dKOgUifHfg8B7wux4zDxojQKqBZilWalMl+5m7sD8wwcHKizLVyhwrdCawuz1bZqRu5I91LWjdwzkSsHTF45/HcltncujsNu/S8Q7tx47rF06UTXE88aYRSGmNz4WBoiqeBmCi/lVatPnJTKeT0q2TAQLGJMH0rHBOPa+Te8SNqG9DvcfBkeBgA2JJ16hglUTIZSWDnzzlxaaBFrLfk6rg3mlPF93EwMRHimvSJXLfYxWHkal3FunjPFyCr5IVsyBw5ODkXBr1GIiiIeSvyBUIJ/JysxDFtafGAqo0hoB4oY5fm+vdMmqLA2g6eJcjRiCtcMrJ5GhUVrlWYELiuWYHhyJ3cnhQ+kLFDjxbZwr1d1ZSdCHkhdir7DcQJAoUidXqyoOFLvJ2AANlAvkdH95Po9/R4ZFeu3lLJIAyqNhnHMs4EQA10NCEhhbRH7MpZTiZzW86X64HOq3V7AqOC2hZsYVw9Gw/ndnoyszSmbWlqN64N7PTWyC5eOqespVnvSkUJtadrV2/alStXbc4UFkmUwYzsWLcHpEp07wuC5BqcypCb6wfpIar5tnfQkyMjIF2sFsriEFY/ONi1qO7bdM6YM1gQiHoAn7tZoZwjiFVeNVSAyyJ77XTZS7k16227OTmxa9eu2X333a+hAefOHdhgdGz333dRI+oWSxr4GXcGTNq0re2OglY+A8MHaYmm/yB08oLUY0Fw2E8nR8cyvpDDyExu3bx5e09sssQwdAMU2EfcA4w36BNMSdAX+BHcB7JaeplZeZg6JZtKYYuFUx9iBBps4IsX7xNyVG+4jIYSDypCCJJnKaO3nLYwTGPkCVHvcTrLbig7CQPCBdTweLZq5cERWSBHQ7Z7cLin+i3k5Z3trqT/Sno4fdRuOFqOEe36d11AQB2Z0grEzniR2a0bt+zJJ2/ayQmlFoUKaxJXafGS64jX0zoIUt24LTdYncDEjWAjJXBSmYXmjbrJH45DAGwqNAeGMDVlMukosksXLghJuXl8bHPkMldMcVrbNJ6HF1mzWlfASxmDhYgGZR4FsK2W9ba37OTkyAmvz6YOyVvPkuUPfdcEZgT5UVazkEEG66C60+pYT3qzqa3oi/cZro1C0MqOTo8VGGnuagXZPBORp1GJhEbORmMb0TO/27WIyUVI2BWUFqoqTQE/k40zQgz1oXvqKNnsbGI0HNXr5BVWzGPLPZikfGk2KSQFnBQO1E0fx9hvb20p/Z4x207jtMjgiOzQLnRZxmbKA86QmxWta0bSWkT2dt0YymYmopSqBLqCTB5hMDKtCsCqa0q4ejoR1BXUUL1DLNkpiWBsQ1i6as512YWMdowuJNMQyJphAwYKDPA1HAP69hjHJdZX5Nv9D12y8XBsl1911U5uTizJ6DfbMHgbonqL4QhpsQX5ouUamumVq7CRnaPnZ2w0itns+K3tvu3u78mxA79SP+ReADdTeCfqbjVofZlaHADx1KzfZzK5Y1nS70fkNGVkE/UXP7QyYMICwggmlZsMzVPu6XLuhAFoNKcejHzUunkb5+bIKOSVjn4OioBD5sDSa6kIX9G+62nF8Gh6vWDVjtRxBN8iRC94GWawLwOrrYRqD1G1U1CQ1JkbUUTUSj9hYMMRWYPTd+R7MZEF+vfB4a7EK4D3uPYpDFLy8LUAMo6TgIdAi++KU2en0QrAuCPIYaLNLxkgDHWfawRFcBrE1IyQ91Nvb0FLTSFRbIxgWR5LAEH6tUiCDcdOEcqj/cms16FpnJFTE5tOGERNvZoeQw5+YIcHe4L140UsqThEr4O1cSZbqm61pTcM81cTRAoH8blh3g6yp3zBHjs8d+Aar4nQeML+lurCBBAH+7s2nU2k9rO1ta3+Ttp4NEOxgewdSAasRrKrUDAxZRR0aBfzgTOqQUXT5l/9qj+36Wxse7s7dv78vuYHskHkqKQfm6hRHRat12RqkLvnOH2hxjTfy9l76rDRXEwNy3bPm2Bz07sqQg9PPEBSD1JGTQQUnqV6lyu+WNacXQT/Xd8ke9AF1DhN3gPiHdDw9evX5Axe+tKH7eLFSyLSSfOT4CxoCdVZLFwLBs8HDgXPkuzO9Xy6/ZLGG5H8Qll8rYpkYddmMbNTOeOlPXn1qr3whS+wOhOW6r7t7PfdaCe1qrjRULQWEczTQgd8C+sU8qF6gXOzxWwhBSFaSQjGRFdhEHRA7yjfyTkWRrOR6SH7B1Fso3imOqLEw524CfeEUwwfA2eolijIexJvd3s4z1q2Kty84IO9PQU65QAIniARUpwbQA3fhPLJaILqmhuC7tSQnFQmSB3qT/T13jw9ESmSz+H8Y7s1jBp0gFIMAxwQLADRQslLWroE9IVFaEw3EOtwA8r5Bo1q02YMrl+TH6kbU88VCsAEGwZaz6Y2GQyVpFDWKDNf9cwiRbZxYrduHdvxyYlQjHvqKDUJXVmFtq4il+s3jlTb6fW3VCgWazNlVA+je5zwNxuUOubBwb7gR9JxIhMUd+aogWCAfTfLEfiigbNQXdGJCBAxMgNSotFrUWQipcaKh+IGNfMPHR4M/LoRleiRzcHrNwLLZBwbp0kNlchH0E6Co16p8A0LUU3KWaZ2EpqAi5hxYRSgW2jrSjIqChA6p0cqtAcevCS929Ptqc0HsV154qaNBwynxV471Q5N9obo1Gc8GI3tQAIYvIUbZMp3QHC4rCNlLA1Q/ownZEexq7siJkAdeLam9rfrVmu3rWyGYu86PXAGzHJtblySxukkpQg+FRiTRK3IQ9EqIkkr994rzW9zrFQ1tKvhl+ftBkzfuZxMGtBZqZE4bGpXO6KtAvUYlFQWGh0mpSEasumPha24HpSMmQC6pY6NmAQjl7gmDOBGv5PnzHO6eeNIGxrjQEQPpZ335HepraGywUDs4WSgaF19ZG3aITAgTndS8oTZUhAhxoqMK8kXLhPVzEH1jWjQMVF3XqNU0NFh50Cyb4HqcGywOtV6UXOMvk0/4HTCXFGyXicnhvoNIvhkq6vFQPegA22fbAKxeGMv9dQriFgC0Xyntat9zVmqNZEVDOQomRWDkaePD6EMMj9ew1l0o7Fcb+L27s4aPocg4+TW6MPj/jhVG+ar0jg+FplEWSWElYy2A8Z2LRTsjicza9QRAp/Z0a0TQYD83mQysslkYFev1Gx7t2/nL+zaS9784dtEH33Wcq5MENLS7fYPbzO/NhWJSfJyq5WCWgIvXs+/Oy6E2xcbMQFWi32uYgKIBaPd5s5xep5IPa4VhMyMvlYTOZBrBjJlD02zud26dU124AVv9pAgeCbbzKZz1YRR8GLRYkZ9sNulBw9oEdiZ1rKF1WqOwERtkpYegu4nHrus/uydbTB8N3uXezsYDtUe1+pcktJOmq80QB6mLIPpgf5wXARQIBgoN5GpiSxDjyGjoTLOlxOvR3GJwBZnzTnPAzeAXWSpCrrS2AVUl1x2vZxxX5nDixhCZnNN7KEO79rRqH3OER0AncN2Q7hJUkkxuqkaYwWyz3/oQYtqN4TScfaA6TkjoE4IykAKcwMIUH5aSKBg0WhpQtDpcKDnpVmW6+HVGkNXq4oTQcM/e5egV1KBTPmAhFTE+t14trBWVNMAZghhyAJSStnq0fI2txPQzYJxfZAdIWLRotJW6WeZLoX2lGkhJSCcK8nejevX7U//9BX25BNXbDycyoHfU0fJBdE4TOSH4YF4g6OgrtTpbUswmwNP1MiIKowERAQ2w2wyljQcrQSwnIKGb0WPHkrU8Z2iBuoxQIVEOD6TIzASiK2rd9ARf1Tcpqi71l6Uvic3d91jpyneGhRN9E1mSN9OKAOlcWDAt9DJheFDCOnKCZDdOoUQWJ1E/ebIJkR4wIq1UHJu+1sHamu4de3IksK37k5Xm47I2ztXWK1St6SHrmvFHtfkk8D2Dw+t3a7ZYjm1o1sD2z04Z/c/8AJR64+u39J3ARaBFcdUDOTNYM5yP6hzUX/BuBD9aiBNRkEbmJuG+NS8CllzJChZw1MlIVux6XwiKjXSUB4CCZrIQlNwZEv6qBIidwKbWO0eUkcBz5cKCnB11bFdw8B2d/fkTAenp24kU5mLGQeysGGzUk/b1C7U9pLxHJDbc/WS8+cuWDUMRBzgefI+NNwD4S4XM0uzUAy8kLFXsOyimqCSFcpFGchBaqMRz6nQPjwEhtM0i6ENTtAgzazerAnGFIWd/jnaH4LaOphi7zjGaeExpLgi1SHUWai30yRejWhHccxHHCx9YfQF8BmlByGoq0yeNhTIVbQRnTu/J6Yo+2TTo8vsRxR4wLrJzKJKqT45YPw8I3omC9wTWkFgs7NLUPRiMcclPrCe7ACEHVQadnJ60w3VrhKAOK1OAiG1GMkxuB66fr8ngzEaj5RBcj1cCwxLDZ9mkj1Bp5Rp3CBfJinw3FKvlDFUyQEWb6vpxtjVQUDqdvnykxpPJVQh8G0xW1kcI0Qxt16/bhfvOxQ8iV8Tc1OM5r/U0UToYSMzx3fEqYtwo0EBgfY5toWM3Amkn96WtXNsVs4lY8bcVHquWfU9QfqIWKCp7FpysDmj0Up1SYznchrbjRs3VDd8+AUPqlYKWpSngV2/OrRX//kN1Sal8FNmQmOYj4rtGA6Wrs68R8aJ5jXqOcgC1mwyPpIJZe7m1Ssvt/OHlxRYuSlDMNdRX6KtChIPwQKI2Er2ikkXk9FScnS0Zx3bWKULOgI6mnnqsiUkBhnF1WrRk0sSkcm4pwtX7hCRCViRqT6Uq5SspNKi3igVcR1ky9gzoFuy11aDnkjqoJkNBs4WSJNW/e1kr6WeSbXe0mQTymTSWuX5kaw0GubPnbIapEHsoCYirZEnnjyBo/az1MWcZi43QT2uynGQtKNNCBKQ7xw2JM5G3dLlyub5Qu2Bljdly5G7o3QAI5jeTbJoym2w5Pn+7JPJeGzjyUi1eYKTJF1Y68m27e/vCnF65LFH7fLjl103xQqRh3sMvTrdSKAa6n30FLn+PeBO2jqAwzho2rzokgpaABd2ajrU3649eWU9ObyqtpHtbs+SVapCLht/ykRzqcvQRJ1ZGaRS3ylKGIwMSaYnDpUeJ6rMgeUBOWUKJ82mnid635otOQmME3VLSX9p/qPLmoi02RQcShiM/DuRLVBogTFlBlziKZqeT5iOvm07u5kdXDg0hp7ceOKWBKOB4B584LxVyDxWpQrNtUbFDs/vqrYHAQRJPSA6Ns/VG0ONgIFhCamCNozBdCKShgaxVgJDBEzyZ0Aa64HNfD/qGA2gnRwa9MgaUcXCHipEROgOhqYWsEqcfiJSWhJ7d5JCjvUWNWyRuD5JMeOYD6fajsv+uYdVzTqsWx1R98TVh+mJhU3nyDj0whF8oACkicWKSBN6CmEwwmLV5AyIC0wEgfkJqWNHUBCZOs+x3+srM5zPG4IMyYZwyEBI3K/xeKaatTOqPDfHpEWK8OqV6+qZwtEjUICouwSzNeIIia+Z6hmSKNOnI2YAikBwZVaFHcxAbwaLr41wq123ra2u2k0w+mQ2RMZknUGlJlIa7Rm7O7tS9yBwWcwTQdlAQ5qLKIJWIWeKuhBGsFFdGQI9IpT5pqHY5y8eiuVaFLEM5/butsugVrCcJ1YfjsSuJciizEE23WiSeWGw3fxB+kkxnBrQXWvZaDi3m7dObHdv28n1lTgMDMdQxo/PEaN6Rb3KQeXlOluhcK3WHET6225Yc6sJvO5UeigbPPDghXXbAUPWQQc8ISyL5UzKRO0OMyGds8cBin0Mm1Gf53SP+Rk2QoN+l8vbNcjNiCycJq/hXPI7SByy6LEkk9EgAUkwAuvmt9uLqGdz9vWZ2CWUqLa4fs+uXIEcVdgLX/hCu3TpfgX6MJYfe+S6/cnLXmWzSWad9pZZwYDnmZzhaEiNt7CT0yPrdGv2Ev8h2z8gi6fu6aa5QC4D1uPeIhQAY5j3pseVfYc0IzV030doBNEON1yZfkaCJSD9RqNrs6kLHjIk2srSRglKZ6A0kW3vbOtZhGFT5+HJq9csXlISim4PFuCsq6lC0qC+GMWCNWOg50AkRu4L4IoGB9DPXq072c8O7RzUyGNJdGIv0YcleGW0HM86Fa+kWAcnJCr0IdBms1CzPz2mcE2wz+xFniOOle/EJCLBw+a6DSRht54TS4Yp0RimRilJaMm2yy7RdghEzf1GH7niRrbRokd5yrXFBVaVSHthS8b0LUBxxrZYwZ72bDwd2qsfcWx1giTQF5IJMmGeGf233Jt76iiJrjUKJuDhVq29hIwzE0OT7AYIT8Vo9cmhSFi4GWSk2kQbsIyYAsBNQju13rBWvWErWzqHlqXWaVDTa8v5khFg+E/GQ9X3EDbg5rARaXZl0CeGcxaSIUGBLiwLHJzlahsuM5T6DQK7EQVvdAk53G4j8XDJcMHUMdSCaWToiHDnNqduCVQEtKEJ6XVDsPLJazftT/785Vb4pXX7bbt55YIEscHQqZVhjPvbLU0quXV0tDbcuR0zeFUydVC/19q2zN4juiFLhmKNZJ2GmaIv27AlsANsUNVoaXZ2sKfEu9fkBrFmkZHrdiwNSks17NZFaUAigSsOiEzU7nZskdY0n5CAYLWGHJ2RJ4t0Tb9kJZuWHBytas3b29rYjMYienT1SJqkmUlI+0BHEyP4LuY5uTEIGtDMH3n1o7eZyVKsQcEEJaWIlo2mMgY3/NpXcMW9hPmMMcXYSoCe6yzIVp0zpZ5Dhtk63JUTF3oxW4hIFGah9gssStjK6l30E0E53RaT5HEukUg9TjHKkSx29/p2fNJXDZn/RlEK2EejhrKFTRdT6yQtOVLaKFbLgQwHgVePQd/04aWJDGQt6qreXK8GttVvqeaiPtKAOZTUXnO1cwAJE1kDTWpO4s6WjOzhwb72inrJ1NPr6nYuYKB+XNrp8dhOjoCF2wr0apJpBD2pMvhFGT91axSBCEIZsTTnbOZovTLhZ2UZ5Q6CpIpjmvLgKQ0MxieOjFOt2NZOEzmQ29AcGRz9qlD26ZXj5wx8xllgvHe3eyqXQCja6Lk6sgo+mdmcmVjzlFxiI8tCqMT1LjvUyg3Y3gS3miSzcGOq2IsYZPbTmKDakNUjc/pL1vVmhBNiGJtMG/YtpKkrl6/YY49dtz/541fbydHC+r0D6ebSJ+5aMBC6X9eecWqrmV1u15QVM0SBrFDsV1Ss4lQZJI4WiL1WD+2h592vswkbWGfUd4Q1F+dTWmhaTA8jbPvJzCli5SA6iXk1nA5loFyauZSLWgd9kZFQE+LI8T44fpAF2qRUs8YmJK7qBGzrZqGSPzJ6iv/2bLXAnmWa6KFzqP5wCFzA3kuhIOqrBeEjG4X4IknMRE4YO0aNnu+AolotrNnhwTk7GZyqxxmCDueZMyueiAZ95670hLPMSVoIuIFCXXvUhpzEPsch8gU05kyqa/ADfDfCC9nE+cLGC+1e8QzgpYDCaewdpB8myjDcQpwTsn/GIjJUml5Myi/Otnrr66K3GiLUPXWUKDpgbKWlGdSVWQLNAePQ4iGsWBO62ViJcGWKpxsSDQcSOJG0mYelQvRa9k6jdUR35wDFumH9LrqQqFdE+qOJ2oXbEKFmBFYVtQjrpgak2XUuIyK6BNaCokysRVaD4SKKIIqX9FWe2WIG88/1A5HSU2+DiFDmgc0xgGLbMXamsPE8tutHAwtqLXv0iav2yKuf0AaAyn/t8jWRLp734P124XDfbeTCRdaQqny/ZvMF89Bm0vvE6NK+INWdfk/BRkbNEsp26iLlRlm3xjb9YA0boRxi9DatJcuKtXoINVnJjQExVKy11bLmTse6ZKrjqZRBPASJ00LOim6NoFJaI6hYr8WE3oZ51CbizPI6z69lQbVqx6OhTSXx5fRAXQ04VD8jWRtKNQQ2QDlAImTk/PvuFhM0enrGyOgpwmw07InHH7ebN29qH/FeGDnE7Nk3QG3S1pxMRVOnBuEG3Yp6eXvEzsZo6nkxcSTHWJDtBOt9AQzN7wENxSI8AKPWm3UpoHBgyM5gH5I5qvcT51mWcsrS0s1TtW3cd+m8Xb96JIcQ1ZGrQ+QB6NtR18niqmpOdxPcMQo4NhHHQt9Sn328kuHsdOu2WlIC4Jqpr1VEkaeWh1Hn+zD+y5/5+t6tJtmrm41J4EH9hp9DbKPGS80Q9JGJODjK2Sx2Rr285Wj9u107f2nbsU77HY3vajQxlNwv16umlh05YLefFvTKlZ6UtpwCC/VhWojQYUW60TE63RBgHBlKWGRGCzeMt0Kw5IhyCcOKvUzXBcmoWnVzI528HJkj290FBBrGDgyLlvJ0JigMu4LT38jQbfgCgms5+8xSBEpfD8Ym6JLkHuIc655HjCyBi/phJbLtiXxGSeLPX/mE/dqv/o69+i8ekzbupYsPSZ4QoXg44JpOoYk6sMtBFWoqM9E7ihoU9oxSB39HnU+yjlxHlSCD7xtpHidwN46W4BtkwWXUa2OqwQWUEsZyUASbyr7odVxn+W5kXCkRAkoBzKClpYnvRRsY0m7IbiKfCMnq+rXrykJJShIvFQcEtrvLAnFyrtzE33e4NmVyTr3KlZp82cRljM2jfLCl+uzxcKLSVFES9LhzyHtydqUQVKuJXEhGq/pyFAkN4/p5xgxbwUa4weiOZ7GZ7tLrdG01n1uGza4xhNxJmWbcKCBgjWBz7UrMuFzBONb0EMoDuYUqy7huAX2HEKcKN6bUMA6ePwEYdArex/VPY+9o2wPy5X2ye+sor9+4LskfIoGA5vaKr1oRKS9EAPqjME4UTrFiGivTaugBiE5N7YtC9LpO6Nh7Dg6sRBgPB0/wQJeDY0Ee9BFy8yCiRFvcRAdZYICVxbLJdLArFtAgm601Pv1ASiTUxHg4OEp+B/wfuJbohgctRXxpCa7H/UiE2teQU+QzmQRQYLRhZPqBjZlocXQssWMK90Tugj4st9NyZpXyuprOMSQ4Dprjk5VrU5nMyIhpBcktXVGnWtrpGKUg2LpV88DKJaBBAzICwm7A6t7OlrJLdC4X04WVVROTDFIJzhInSTSW0HbSatr2+T12vcZeHV+/ZXNGI61Sq4dNN0HDZ15oad1WXcHMTrujQcx870a7ZyWMQWCL+UwtPDy7kQSZE4kW4AjJytUbWa1Zj3FXjYay8+2dHR2A0XQiw6jAiVrCWqwap45RpMbCwaLOAOOWvUL/k3orgY0qaAuvlJGQFTjBCGA92jCW2jPQ3kVs0JisTD+vNtdzF0PIH2R9dU1B0Hc2GIsoDLnhrzgtObuag5I0TUAHnT1L1pNrH5Hbo9CDoQij0s1wXDFwnNogwt00f88EiUoajkMfOiEGDi4zWIEoNT+QNh6ECaKmzoMcrno/cxljx+aNtV8kOyg9TfYEPYT06jn1GI0Ky8jsF3b5iet28/qpsqFabWi9Wy0nNsCkFYtUsyGyZngAhKE4hRfgAhwsnwZMmyOZcJdU94xcCQDYElJSvM5ecAiUC0AwyBwg3FWqNRk/1ypWs6IRqL6IstBDz7tP8zaZfMM+AsZzEKvT+mSPa4JGv69xcIJpGcOlGamukd21vzhimdjxEKtGY8nrEXCJ+AU6kcSub9NmKhOJnYq0HBw6yinULQdT+5Vf/l377d96mbUbHXvooYsSa4BlLbjYL62WUPpxLUpYeVeqwdlTqnEiAlmouTnaeyhsibGaJapDulmbvN5V6rTn1/YOUiLQpWMtO7gZJ4YqE5/J85DYBqINNOuzF4PQ6lJz8hSMUYckWWG8IGUBauUELPyBJAVqQBaMKpiUnjK+g+tzx/5CfqM/maRC02QCpsu4LganebxQEEtixAzewg9tgNoNgTetchJrqGvPq2Sx7nOVXVCyYza2kc4yzxbFqM3gZ1ejBznLLPR82+72rY2CFRNf8szGs6l6HrWfMngavoYRkJDRSkK2yBBofAX7F3ZrsJzpuxK40AWCuITTtHXfbTMZhuCTTBhftUF1lGgQKdxLR3ntxlWptdOIOltSO3J6fU1YaGQkMJo1QgumZVWKMGKiqfcRUXJGukA/h3hSc6Oo1pCnZvwhLpy77FRUdjZVVNMhojbBA+dmiVa9hi41FmotcM1CL5DNWQa5G/arANHVnzhUaFUSzUuWCqeLcVT9ymnIMumC+sGUQj8MK66dDUn2MptbZRXbYOxUSbg2Nha05DKrWJ5GagOgreTixV1FOYOTiV27cURFRFmgyEcc/iy22WpmSZHZ8XAodhkkFogJEuqWAlJ/zVp0guDUJNBpVZDRqNv+dt/qsCtHDAkuLZgHGiuzXwtte2/bolYVIri1WqFl1NESFPxpZEZDd2WZpmQg6B7afDwT4zHYwNqdrrITIFRFeEhpJYnaC8gASGm4Lolmo6zS7lrQpm62siuXL9sAZjMM5hZSWrAyV9bCIau/lazKtTaQCaJSVK9Tc6npOZKBAJWr1Yd+XYIWprCvJwEghq/JM+usk/dH8JznTvDWaFfFLsRRSl2lzlzGUP1rIPLUu1GgkcoTogs0cZORJ2SMFcsstulkJLbuxgi7+i4GARiQVgiXEQjayd1YM4yTiBD0QxB2QAZjSHFA64NrsseZs+81lLqA9AJ7k+8HyuAygLzwtQelPGKF+m8hYZHduQyrYtdu3bKTo5mIJujXTiZLC7yaLWZuYsYTj16x3e2+MsnlaqbRXxR/KCcAMXNtouV7JjidyOL0dOxIVDoHVUm9oQW8jKc2PEX/c6U2CJypE6Z2JC2ciGqLJfwAhpND4KLNIrabN0+UqdIHyrQXjDhBEvea4AoINT49VUnGQb5uCf5ciwYQJG2gMs1cJePKzZYJ8zJnt/VGgVrZA6hpQaJDSSkzN3eViSUoNl158pZduXxqtWjL9nbOrdn7LlMCtwSiz/KKTcZo7DqJRaw216mRfDCccSwwFjXJpiFoX3BzwJlwfaJkMnFG1kxg5uyg4DMCMOBchj0zDQeGOGzOwLXIOGEFyImYZbIw+ikZgOzup7LstfHXwOjVWI6SspOg8AxAkq1b2nJV1/0GeocvgAIQrGr+mcru4ezR5ybodLCvsk5mOuJI5gsRXnDs7XZLoizA8yLKSZeZcoaD1YnoOG/0matbYDrTeQBd5KxudXv6PWq3yuJ4zXhizbBqly5clJMFusWZ57XcGmhLL5jP2bB+18kguv589Iy5P9H6bEIAQjQFzWQXMNOWwt7gTpOAQciiDYp9SzDnpjNV1EIm4qLrIrt3jhIvLk2/LNaUdtJhbqgiXBQRZHjdjDnqgW7MjcOAySJgazo8OrelOcKCJKs0UbtQfYWbPNAA4Lkc2mxJYRaWX98Vz5nYwMQMTRQgO/1LLF7TS9ZT0PlvjSISQ861iJCRACdIwiujjsrBo87GQXQFceAx4dnrSd+beigF4OFg5FpMKIpL2o2+nKqDURg9VHEiwJYz8aFh82Bp8ymDYMlGiG6cHB/Gcpks9BAxmtDtMRqa/g18AIWb+lKKHCCbdamfUc/sasQUjnDHalj9PLGGnEBucb7SdAe/VhGMgfoIiiP3Pe+SeUlmR1duWjpH0cQ3b0RP60IRHpMV+CcFcLL0Sq1uQ3pV5wvLV4k+GwcvNYt1bZRocZMlQsHeIiNgYsRgIOYzcDwTR6gx0rjOvd/f69oINpp6rHLLEjdT0fVr4mBcDy3tQBCSNrAbKjxEhjDWaGBXBCoBA0fQ2uo3bXe3be1u3fbP7Vq717R57CB17gs1Y7JI+nprVSJehJDdJAIgJYwyNSwk4YCrObAaSySxbCfcTAZFdC5NXTnzhuXqreP+kFG5EgTBosTUY2qUkeBVgjvainjWfHdGjRUFpBpIMBBoqK2t+1U9shcGB0fq/0LJhdoime1GNJ+WAYhcEQ3WDU/QdrWKLB2ZUG6LeWav/LO/UH/tQw9dkqNdLSaCC1GE4Xw4NRwHxTVbPbWwoNVLH6kMoqZBVNVKQkM9Quoo7rgalBNyx3DxzNDXlAEyt+/VLtbruhFUaaprJcs4ONizxm7T7ORYAWpaye3g4FCQKGxaWJRN+iXVBhQrsIWAATSGoXekFDdlhP7D5Yp2nLlQnU6vo1KHapgouDDLVhKCTpsVAvbpydT++I/+RApcZJN7ewd2cNC1equ03pZDZ9qdrh0dM6YstXrVyfIRYGn+apMMlUB+Iq1rDCzO8wUvfFhMbvZQki6FpoFSUDsny0Q3GrvniDdOlg54eaus2PERmfF0PcUl0NBiSlGgGtyjGzevqY7r48zWEoauNkywRhBBCwz9uY7oxvXR5MJzna8FBuh3FBkLqBiZypTB2tS63cAAUIENtJ4k7lqjatNN+wE58Tin6e26I/fC9bhGUjnD+UnDWfM/1yW0tdC4xNhXsdR3Os22DSoDN1NYMzIzIVS0I216mSVygLIbLNqdXd0v7AM+AAcJggXKiO+RkA37i7qkSI8kBS07t3coUfzBeKDecYmtrO8JYg461z4yqgSlCCPc4+khmmNRpKqtYTiAHViQiYhyywrq74F1t/oqyiPlBW1/uWLAbkfQEyQex8D0bYTmKfqlGMmysPESNizMqMJmKABNx4r0WllhUb2lWWObuhXtAlL3CIjKEc5N3IT73EmgAVvhlOivwiI1+Uz0YTPmHdYs8LdthUgyEk6SZKpbq93VxoskJ4cQgYlgMRkPNYmEQj5z94CdNYSVqL9APsrNhIT0U2+3bHByYuOdrtM7FBvVUbjpr0OjVsoVzGDEWGCAJJYONAaEy3BYMPXMJtPUrl67Ifx/C/EA+vM0XiazBIo/ETeRXIuRPBP1hSGycPWJm2oqX2botU7UD+YFuTX7TVvynZYUDZwAOdALI51QPLEk0Xvx7WuwYxHIZhKAX1pZY9AsRXJQXe6Dq2XJqMapeu64TiJhyEI+mSN9dzkMZRwSvbAwAk2sP3439oDUNJpbEbGEHXBjypwwip6yXubNdVD40fSZXM3bEYwGj4yP3llahVwfWr0KCWWqvJC6kNBFz0E5kNBms7GuUbqcq8V6WsSa8MSUjlrVmqnZ1haM51MbnB6JeEHWoCCRsT/ATxLyhjyEc2hbvYauKVNr6DED7te2k/oMaAq6xjwdJqlQokA4ALk8RPlpGZLiT+SmWFTISDyzxcKsTsYFwazia3IEjojG8yzObPegZ9UgtUsXD50a0XBqSy+3sOrYg2ToBG4M4oUiT4tWrbYlSTNIHGU5FgGM2vkkJ2BwUBkByd7engQuVjG1pK5FNadIoz54ShyKzF3dt9XZWUsBuuwL1iGKPhg1hvsKIrdANVX1wWK8q021+8SnI9sD/ahXdW/7rb7VGntrSTr6eyFoLHSmOZuuzkUtzdfor5i6fh5YI/Wt3e0bcauYuIFJzIQaJOpJgY/0JGPncqkBofqyu9Wyna229fqgW0uzSqEsnGxsrt8h00LdhrOC+MjEwkpL5wmoFscyGJxIXL3bJUBw/A0F4ZowggiGY6O7IQHwCZxQOMIq2BdJ1TGVB2SOOiQkIY/7BWQ+EFKgYQ6+pyARwW/snTJsWrlgmyrRdu1P1OdxDlVEJAKkNRMbT+bWgkxTmtWDhoIdKYQxcSmqWpzm2mOgLwxHQB8bNSwnWJ/Z9WvXFLywx5gAQ/A6paxACUUj+6ZKdHiP0+GJBFkIsmCiLxepSJwkUb1my/pIa46Gsq9krpueWNWVqXFr4o/LikXwpNWkcIME4hDImcEVTXVRsFfpMaUtEZ/CmQTN26s37b6Di2L3U6dcxCubxbDssVvuOYgdHUTmqXWmuLeOEuhUgtxkAYK83MBc5lICm8Ao4+FjMKlR3Lx1Ux4fZhIQG5HAYjI3in/KMBEIYCYZX3AV2yxeCbIlmqV9wamfom3pqMmMiXJwHTBY5XZtR9EjmHeAEk5TG8npStKLlFiifjNuuCMpEPH12k2bb3Udqy0BsnON7apR0Q0ulR6oyW7zOek2/sAECwQnoAaTxZE2Aa/vtqvWbgKTutYODsn99z8gqPD6zROxMYGXEdXOCphzU5GeqJ2pd6rV1PvAHFQ2ydSL+UKGhgJ8t1lXz6H4LRobBLECOJR+Ihr9YccGlqFDev3Iam3XjwX+TAYcRr75rYbGJwXhUnXONKCHE4agi7g2sHnHzCaTmujWQM9L1bQ4YC6aJNtG7NhlX1KpFeIAuSlqRRpfhqN0QgQU2l0P38YQaz+ts30x3cw1lkvBDxJA6GYJauoIRLB1rUPRMHBqA6r7ysoSZMAZiY3aEzGRInqk0qTuROuJE5LPKebHOE43rV0TN2pO4ILngYHbaPpWa1PJhomJi1oO00HWwwF4juj48tliAJJBM0N0MjfPbwjOc8NyXdQPokAthD1Z5NS2Ezs9GUs1idqPBLo1dgl0JJaTJ4MB2gukl+tqk7TwQGDDGHXbTWvWyfBC62y17PLlK4KxISTB6j083LGXvOgFymgGQ4SsWyLXAaMn6UxtS9QXQQowIGjZOtEIhjc7NqqgvPV8RfpkgeA0ZHxJ3ZmJDpBFMKr0B07dPfQRJRhbtYqMIo8Qgs1KSigErmRTqPpgCOkbRZGIrJVgD7UgppCwcJaQl7ABaM1qkHPGaLKKJOr4XYIDgrtGI7Gtnb6FFQJZMquVPrOk3IGCznqYOfVY+ume/+ALrN1oWIc6f8kwcebSMsN1phrj4fkdafMi7IF0mtjPtKOFQIw0twdqPxqPEbiAnMagYYIHV/fakHYczEc2SK3QtaWp4gzqoNpZ1Wo16oKEUTgozzGHJ1PVhkkM+H32N/dUU01AeDTzF9Uo2uIIXCAxkhlq8rdY2rDr5aBpnVgtbR761mvVxXBttarW6sA2r6uVDBnLyTx2bRfInTBjEtb/cqYhzYVKLZBqmEvpHIsU1BDxACYn609K2R++K5ApSBDdAgSKOMZWo6WyHWeN3yELpfbKGeKMQbBx47ZEi9Zn4hC5l9TF+d6gJxsIlyQDOF2dEPoMhkanQvHYp8Ct/B3DH8p0pf5hnV3QGVqg4KtolJt/bx0lsAdf2qXm9Hb5t7NB/ocSCg8L6JLWAqJo9VwB61EoxyBWgA4gE8RqqtcUNQyYbzYdz6xZB1JVT4L+aEITBtzYVMxydJMcpP0qRQpqBtxIGtjdQFsRJtZTyjWgd63xSW2Dht4iZwOVirLKfteWK2jC7ntArsAJs/EkNgAmtjbmXBaZD3WpCjBuryNhgclwZF6R2YMPXlDPJ4aJuoCvcWKBjAKRlfQbHairDVLfdmQD7gvvRfTPAGwyLFi9Q3oEIUCkmWBSNFKVxZfQ+hmV5SAyHj7GBydV0g9AfWIyt05n27YQ8Waa+mRqPpGicV/qdnjIJPot1bdu3TjRKCh6Dm2KWktbmRBF9B7CwwQzaSKYRRnSmrih+QaqEyIJCKQcK5PhZ66bmCkvuepr9JOimEKmjOD9RjPWqYq4hnIdwDvYfoKr1w3Qjg2dKvvY2dlS7yEDhXGItOIAc0osO84sUKuKZ0XMe8Js+0skAJ1YsnIQhDZ1dGpbImo4hqXLshGKdo6OTNMJpvM5ZNE0xwO9ImOW2HI51YQM+tsgytB4TsbGd12sgGIhZUB6QaSBQKC02XisMVXzOezCqvW3OspQ+tvUwDhbbWu2aNPxrL9Nfca38WAo4hoD0zEE5w7Oq2+TOlezE9oLd+6z57/wohMqmEykoHXh/KGCPTIpmL+0BgggJaNlwPZ8rrq7M36OFMZzAVpzgTH7bqZr5yYM1xrJtANYy7cnL1+18QzW5souXroggZD5GiHiviHCQRY/GS+kDw1sx/mazZipOrZmrWYPPHS/1ZjYYol6aqm3bcawYeggcbipHZBzyCJcgCOFGSatDJBPYzDCXJqoQNXdbYQU6KsEEneM0TQtrb/VlbDDhcOudVs91UVns8zaPTLVWJkH2TjIUq/bosddnzk4pUyRqpdW7FiyfuxOaWoHEntXdoepOWRBkIqqEoJwJBLKOpSL3KB3N1Ca+mUgeHlSW6q8ghFUu1XoiWXNNWlocsT0EMfmRRADO8eZIpABXqU2y1nDBouf7uM8EBhBEB9MH7lPsyZ1cuif1CrRraWmy3Pqd6WzfTya23Q5N9BWNIpR7aFMpWHbFYY9Iw3pauRcWEjwBqMWeFwDvz39O2xcaom72ztq/wOy3fRfNutNzUVtU8tnwg0tQZVIZ8nJ79HH69AkyJnOhjilMJw6/41SGe+PH5JdhgBK2Q8OjMd1LxT40ZcO0dTNW3KRi7MtLsOnXIJPAxm4p46SyBmn1WhgSKkZpTK6YMAoMzBNgIcoDVe+9PryqGvBbkT/ELKORjghH6a+OOAuWLRu3qE7FHj8QL1RGFDgRbBuyCw4C+AKZI74fkCG9AJSt9qwqyhY99oti9dRCZsUY8jGI+JSVlnCKnQZZJYtbsvjQWBgA6ep0ywNmHG2pvsokeOgZzM9kNbOthip6U5XvXM721ua8OFGzTB/MZMzo2ZHhuk+K1MdrFqvWrcDK5eIsmZb/W1rNZj43beT06HdODq+rWGLoySDpRFfajNETsC2zJaTvJUbyYMT56DXmqGtpivLFpk1QqKq2CbxUBEb9a4gqlqz0bYaUw/QgY9TG4xGavTFACn6XUeNbG50etn8RI/UhXAijpiCs1pn+zgcpjmIyelGcknDUzT+jVMFegyk/i/WH1AdER+cSynI+66+twm+mDlH2MCeFhmM3qpcY4uqtZbGFhHwMKwWA4UgAIxZrmc+c+zYNI9tK+8royTGYMwWjFLIFHIaa+ktIDFQByaGQGQhsHF9ZmQ9BEtE+wgv0IcK4uB6dd0kCcfw5gADjZ2/cOjgMg2cxUG6WY+8H+0DPH9qpltbLenJIkUndmto1u0iu8fvoOGJ0DNBE/J3OJyJnCAZB4EiZ+n4+Jbq+WGtYg+/8GHb3juwsHJBohSoKJ0eHwvSbYQNa7TbUuMR+9Fn2gxiEq7OzDMQcQaiGK1TGDHBhkTqhSZdUN8BUqZNAjAAog66w9vbW2vyTabszl9gwJxkIyPMpMOZeVYJ6pYzU5Q+13hmJyXSjJnk7+pNPtvJv5E5YWs0UQIWrZjFnuVSYqK2CkznDCpZHtdI5u3aSAq1RFUaFQt9lJDcuD32ILMnLQtteDy3y49ekXEN9vu22+haI2+oXqw2Ms0xdOIM3ailwLcb1yWg7npnHZLjapRIDDo+AY6SQBb7IT1W4NDS1Z6pV+Lg1xmHk1SULXUKP8v53FZz6vWuHMLeRSCDsVAV35FwqiEBGEPgC5vOljZn5BVQK7U39VKTjDjyE+ePqUVuoAG161iBMLKNoFkEoU7Vx01jwRFqvF2a2mAMuQ0SH8PlmbnjZtzyzJcEFOsa6TalCuqe0ox2/ac687R+0LeOYHnVtWNA0CQD5Wfb8BlAijSBiECCqUAzm0BQgvtRAw3kPgdKsoTGMIdSQzA2JE56IdlTgQEqpRqzVqqVi71LEEh2DDIpjXCRJCnHJWvlIDYF98C1J95TR0ljKzg5Acx0Rq+S+xJihdIDtFbj0LRpDCdHbP3vGHgig+libhNFLS7NZ9dhVLhh9e1tKb5rkj3qPusvjXMkqsXBSV1n7UyFsWGIk8z63bZrbC9z/S7Q7uT4RDArFwEzivoI79dB2QQBaNho5gnDp74otpymMuBMEeOuao5jEXMwnBIE3j9fK9kky7mGI+/v9uV0iYQHaJsiztBC1SRQbe7G9Zt2MnS9b/T/QGoCCsHh83s4UehM4f7euqjtBIYFaRZouzpCFI6JojX3g4QOhi6RsxQ9JDvmhs1CSKI+Oh3M7EZ0y1qdutUrTUvc1C0n/0edM0aTF23NQv16VQTAET7muxCpMkg2CvWd2MwopGwFkZqek3Rwm96OS1V/I8SkKTUptx9cz9y6J2w9HmmjzrJZZOyaZk57D5k8ajFk/+vB3DhL6tHIvDHg9v9n77+WJcm3M09sebiHe2gdW6XOUkcADYDDps2Qc0HjFd+FjzNvMQ9AGi9pRk5P93QP0ACOxKmqlFuE1hEewoP2+5ZHntPTJK0v0ng1CUurg6rMvWO7/8Va3/oEc2KpkHj9qtK5tKlscW+hY4z19egy5sREYR9WwfsWITOfE1ahQ49Uyhx0CKk92YKAZvwgYXMjHMdGEVchZDtu4kwHy0EEGYl5Jl0mFmAc1HIcYu4+W1q17h0Q71chwtIeFkX+WLVWIq7hDAORCto6z6yY4M3qZhWFAmvvZPvj1uJK5HFvMLoPmawUvSPhIi/ZhIDmM8QcmIjA9KGNhw92f/8g1yFnHbvd3XQ2VxH34vVLxT6R94gxNAcYowQJt3MmI3M5ukyePVA0iSlwAB4eRpq/pTtM7nkveC4z02XWD+wMHFwWggIvgUxLOmikC7BMibAqBN5F/PzTRx2Kf/23P2jt6vwo5K43MNzFMC4rUm+15CCmuEm0ZzgAmy3MFfCWxa+TbsntMGHVl5KyrY8bT8xBenY8Co1496dPCvOtKWWlIamRu+g07ObuRp3b/rD07EkySOOC9fvY8yWK4uLdY6IgOU2eOsSMjPXNLzppre3cAczdcXi3IEhe2HK5y/A/idTlcrZNhhNbTBnHsG6B30OrJhUV1ECOwJh076dOQ0WFoEoIk0JAUu37dquh+TDF0FQox9FiRjYyCyHAm7SUikvzAqX8ag9ytoisI3MPlyexZqURLSJnihUsgDxQUip8jVfA9zVrNJt2mroxyIXFw1mItnOFDy/z5pxw05DfNtmRnp6EflnPCr07hU5OrivAls+lJmg7RVKSnzFFAeNGR7I0E8YqVPdI/jXyZCmpI+Ta4wWBCpQ8FFoYJcW6CsWv3FHe3T3Xh3IWVvjnDSjmqHdQSa53Qt8C7IYNHFWn5HuFgm56dSL8N7nDI/Lf6JbHaaeNAJVBMc4sbF7YTRXkCjWlZsvLb7H0ZOwMk+JEuqBOqy3rtAs7Dgo6tlru0OCwHTj3ZrW2dt3NEuhUqFg4WLiIlNXGPE5mxRwWLivRpZw/WMp8II9Os6GBNbcfThW80fFkbp8+PypfEHbtL3/xS1H9mbEqtYTZjvIecyhRjiPMZHe2WsxsNp1o1ivT327XVpiVs+j47KSGbLY2nEys32m5iJevA/M3TrS5gSCA2BiFEyY7mgzt6Wlgt8+urdVCU+UJDUGGpATx9Mo+fvhss/lSfp5uaVYQhMv3gn26o2s9uCMSFyUwmef8ldUp67ko5gyIlTlhwaUAxabHn+UXoQJWo1wuRCWKM0dY9pkl3SdQCrNJUeW9eNKFyoxTP6OTggpoAYGwxDwtGiz68Zz8x3vPA8x9XmW5ReCv9GJ0rO6yI3NpEb2Av+lYPLPRDRSo/Dng0ATTaeLpibGFdwk6B88nzbS5SFkvHJ6nM90p3qgekCyoB8/hvyhU+Vqiq+vZAflyYdAFwMIj0LuUw3dbde2C4OiWE5CbhVUT1gWG5nWrV1s6/LlgsWPDgafaYCZUc41nyoG3ElmDrpG9V2+0dIlPhnNrddo65Eejkd5376qrvcHBhXZP7j0EJe+wB0Q6cbDj/GCtJu8fO8FQ3QrPgc+qMGk911J+Efi8mK4cghPpGsxk221HTyoVh7j3IRaYR/t8P7SXr5/by1e4EDFqIPF+q4OZCxl7zPc/D8Seffbiyr777o0d9gV7nD6pa/XP6t1SlZSa+qVTwOGG4Y6HGDBz/OnH9/b+wwfNk4EBQUzo+LFqu7m9EToRHUJlGfL5QSx8lMAogN3onAXZXyr04awiC8IXf441ixH75dKkW59Op/r/KcrYuNIRgpRFJOggXYrs6rpltUrRFo2qbdd726642GGslixhzEQGa7VmP/74syw2Ww1i4W5tdzzaw3Bg0xnJHTV7dndnHQVUnOzj5ydxRTBd6bQbguJLOspAgDxAgncHiYsLUpI5oE+0l3AGdhTOR+u321qb08VUiBrjKxmErFfSm3PWtbttZ4fnxbNUB+uVZ2vyHtEi71IrFcmGLYsLQGG2moM8+uXKswC/4PzlvKsU8Hp2/1i+PwoLzkqchLi8L7/gpvhoB7iVvehzWqeoe8oKVTWXJhe07FNLZRGGWB+y1PuaFyXkAuYSVA28eBYL/1v+jQhGcxGtz6zcok6XFM71OK7QOeY4M1UQXZpMzukmYDlFiKSvJUaFnCMGorxlcVQIRRKiisQuChkCVQsYdy0nZLjnI8GwDiNwTrERcG7gYnKq+ljuNHc3V47/w+6slGVP5x0cjLycLYnODZaaApSZd0DdzkTYubu5tate08pxaLUS7Kq9DYZII5C1mK3We3sczDT/OQBx4NSCKB74lwE/NnV0yMAWHChLDJSBKDZWb7XdiDqp2GbH4qAydXmOpBXMzOJIZBLND/BBZYgPbEO3v9nZaPiomQhRXcwY9V6OaBnLZkfg8a0SC5g1ctDyPPmsvetb+/b7b63xNFF3OZ7O7bBAF7XwzrIQW6/f/1+IpsVwEcmJS/bm5kaXHXME5loewpzrHeX4QrdV8Qsx3wjbE7FFnh16iVlTpUgljkl55PAoOYVhkNmL59e6kCmwTkFmD4OBYnXkHMOlHSCYrolNqdmN+A+XeSSdS/lLYUSXWi57Fe5aNf/+RDNx3rnBO+xoGIixFTE3ZTCQ0ZGW7eamq6IjTTeG/xiXK2QyNJdsbF0ugpWB8yJV9Q5revwULE3SOOhUgGa5bOkcWh3yCwm/nSkWiYg6ii3YpiK8zZErkZTAjIZng0Shrve8Xi2dLHNIFVDALxItmEVSiJFGo7SWIsSLWHubQxMSB7pSQeLe+uQFlLvJwASl4x4+kU35qM5NkB0m2chhtP8xkZ/omeCDS6ECcYjPSsGCgbz8WhWFZSIzffhwb1fXbZd+yUfY0YhqrWGj4ZP9u3/3P9vHj4+Su1xfPbfrqxc+G07nDm+SWkNBK6jTddJ06YxEYBmzPQBpfvvb3+vyYH7JzJFOmpSPcwCZa2PHNd7VnsZxOkF4w4Wqotnrbgcz2Ucykkcwd9ZFudZFzZ64hJLzfi8IisOyeM8CaTOe8D0jUlLsWka6abGVW1W5X9Gpb1c7BnQqgEEPmZs2GzVxGfg77VZoO0T9SFKOe/na3vba0qvynrmw6Zw08zu7V+7ZrdFUNAHDA23TuXNh8ezosiG6gSaAOmEu43F6e12c0nUqsKKqQniNXtpMPAxrQ3FAi3vSuuAZKXZx7yYTwTHQiEvPJTcVYLzEZSyYFq14GXKnh8Nfnh8FdK1COAFMZ4IevFgBVbn4A8s0P0dDpMBgJJKnkSiwQdKlkpjzXPQYFGitnz0R5atelBzEHIYszA0i1yMQqSc4MHx2xiTSDDR8sLA8lPciwHanGc8yXO/yRHXpfBKf4RB7VYTajL1ZpIsNiIXsOyr2OSHQuROHgkuPf+nrSorEzDsDLubNOrfGA7MH44eRCtHGPWWRZsi5pVKxVitTZQtdXxFM5lltLCiqmLjAC6zpe8AoBMajKmFDnmSTVrLlFjiViw6HfNh5Tl9v4Q1LRSqXk70uTMWAnU/OMFOhwOGxswWaou1GuZ5+uHmw6gWv5+fkGXM5xpHnCDKQR2ME/MVn4vKFqcrFzYxsMltZEJFwcGOVEo4dkJFSj4CabwT/1TQH8nmvOmi65lIicgXGAFTEl6pLphBA3ydn40nekVuNaV6UM/2AuDa7tSQYSq9HWnD0PwPFXgJiyQy8iwGe5XJSXh4VJP+b5517WArewl1H6Qu4kECMaFmpUrIePqr9rqAZh1xXOvyIeoJFejwChQEv1+Wuc8y2SoSHM8LcjA6fUYBmpbLA87xMuoikElsZ1idzmWxvxVJZUJwhYOewLxbs5llXukFgNPYG6yMp+yWg1j/wipiOl88EqeWU4bWJzyxFXGTtTl2fnXfrc+KiDkuccXbrs51CYK9IpI/7D3+04WCswpMLbLGcWa/ftrffvJShNl08+0x7q+wFDckZPLxnz5/r3TrJhIPIYXguM6wwQiXZF3TI4PrCPkLvi/SG+a93S8CgJK5srNvpOjwXUdQwB/I1wTyVC/B4YHbNxe4i9Harq+eLbMS764qdVjt7ehzYavXGGu3kC1mHTocDmc55MlvafLG1n9892j/+04/2X//rv5NuVDNsoQKgP078EgwZnq1ew8uXZwTUV7M//O739nD/JJnK3V3DOv2ejFM+PXyyoHDSWuleE1oN29ptFjljSI7houP9oivmIBZTGgKJ/En9uei8k9bPYVjOIxe0u9AdtrGPHjBHcJRSKFUARBjKpJ9fARI3dfbuU5viSLNe2gegx8JJRC9ISnSNu+PBmtXEmuUbdZJAm8H5pLzFIxZz5MKuN7ZMN1a0k91ctRWADvmMz1RD6nTkvUfWbnakwQ0L5OFubJPsrARsWy7bgvOcotabdWmDfc8H4qSI85Ekfqkq7SPLO1OaIfgFR9tLUYDloKM4QoyOZssZGb6p1dDeturG3SuJH8Qo+kOKy1bLjjM/C0ArISnJfzaHUTUXVWyiG7TssXpkPJgzZWQwryBuz6Tk7NLIR0kq8de9KCfjoRNCGIzKM9BDdXlgwqftrGoI5iNP1AfTPHRufKYTsB/D3FopkK8jMyhVghy4/B0lhhBM6m08hzSLmQsmnk6tgvHyAVILCzQRxAY7CwkKh/jTcOD5jdudPEvRF/F5MFsvIesguBNhu6rP3PoO2nEJ2IyKXamkmnWyUJv1hp3EmGUuiJjbJQ7D0djSStEKYiVSkeMaU1SVhR3eEU9P5n140gL1reYa0MstHxslXcf82K5plK9hzu7KVmtb7dyEmEOcz4gUo6QD2skLdDQM0U8bshXP0i5Wa3WbziY2wHcVb1d0jvO1bXCcKRTtzctbi89o31zmwgHC9/cgY3RFkTrL3//ud4LWIARwqWrMzEWdw8XMHGq1pjo2Ln0RCuRN6sbPVOzM9jioep22gGYOSqXUQ+ZRtA/JI3uHagSfuB0dm5ICgvlNEAUqHC6XB6QGKm86XQKc6YrpgpQlGWBYweehm1kIEpXJcxUKPF+bS4e1C6x+cgN9LmeRAxxydbNkF0nj68olR9Enlh/87DPVqocFK+KNq/WMj+hZc+CrU9cm46mgVC4N4Mao6FAiWjfmhXwfZlAUDmHYyC9FR2cusgyIMJgYcGjt07WNxwuJ6idjSGGE9eKbvLVv3r6RjWH/qmWVStEO+7UtFm5AUUGGIoIDpt7OOqyqyveumrUPBHgJLuZAD88FmahzATLe2GzcfQvrunRzsMNuobU7Gs5tDJcAhKsQ2mAwsG5W10yWn/sSxMyBReHD3BhyzGDwpJ/RrQ/R7LmnaL3pJBnyPuMyBSL7D1eVovaONL+8ryNn0No+vHuybuujkoZYPx4/VhFsC8ucgptOBhiYLqpW69l4NrZ//z/9gxjeHJIYKVTrdC+QW1Jpq1krvAf3xPWRjTJkFSTs0CTognfQl7QTXW25I9PpS/ft4naf2/H98EwF7na5DZA9nbjbdbLGOPJATNzyLpPePIr9UAcB40Yhim932FscQqDxeTIyj1L5SuHGnKuluCzd6Ho+s/lkYosV5zKIn8daYb3I+i5smT/OxJqV81exZM16bMMiZgt4Y1et1w2s2W5Kk73jHMjnjzJ3yX9efnMB0VVzXgQQxuoN1YcXs/HdcadziAJ4kyRfXMbYyxRhnO1Y0wVbkk9CER1BZZjLygWXBou1kBTNVnnws+xOIRK6R7HOizj44viGYTuzTdmqc57Qkqszd7WEJ7WpzNK8+atelHwvNjnUZAbfsMNYGJptwDjN3eaZ/ZA2DhwzHo11iIEP8yDrtYqsi8azidN4o1zTIosqNhWxUO7YoAHwZmtzNDOwAAXxklIAMw382h1y6CSa5CmGoXRkOPsozkg2U4GGzbBzk4j5WdOqJc+jVFpBiYsykpt+jL+jGGzOcoSgwOFyPAc2ns4EXcngGOcPAxoB4zd7hv9rBK0c+CC0dEV3bYJ0qS7pcv1ePumQ5eCAOk6HLelLgTQGYDqHKBEXU5ExJ1WwtGQv7r1ZLAC7grNjrwUcwoAbz91YzDVizyYzOnDfwPq6p7Mt13vbM7TeZdJs0T3DyITdhpyH+QubGDq1WIqYbi+W9jQcazbIYU7EE/IKGTWL7ezRXXIp8qm7D/HluLSwfr9n9R9+0HMbjSY2Go80Y2MDKJGEylqRT8wn6eZcExgbhguZDCdI6lB0ELNTqPHM8bBH22HIAOxctKrhDLWzdUDVG1qrWbWb274OYipV9HGSGRV8lg7RifcL61aMT607tw7UYaDUFTpm12UJhjpD/Qdu8yra52IeCoxDDt3FdD7SBSOdJ6iDHIHcIJw9ogOywlwWX1H0pDvNSlzi45Z4zMWooEFWlgs6/9QmA6A9DPYzazf7dn1zpaqcS/oE0ywgGJ1q2fWhqk0ls6EAcVG33Ff8JekzUOwAi9PVwuwFxudwSze+fuiQQHNwm2k20CxyceCxmdnHj/fyWcXisN3u2HJDOs7R4UdBky57wIA8ic8yY8BL+P7+UYYPdB3dXkuFI5d2vdFTIPZ/4ulKjNXZtYq8H8y/lws+Q0EwLe/x5csbdaRJzHONhWaJsAeZiMt5k0pKU44z++nHD/bup496znT/BBgkJdZ0zX5V+U4G5lc3OMFgorHWBQcykYRlkXO44IUMIN1IdyrgOe8uIfDyWs6LwV1KIVTVueJnIl09cWsQVdzFCJ/cWgk3IP4MUhyQKFjriR0LZ0tXqdyQ5PNbIOg4sgAHqAjer7vN4LPNfhABCnnb3hnKIARuycjlRpi0B4vTmUP/Zj4P25iLea8ItZMlFWZNdPFIzzaWoomMIM/52OaY2wSSbnRBlzwJJhNBsVxygg5NRruOLCj8kgTCbFOsdmK58GMmoSgp2nI+lVmBPKDRj68WQvl81umsZooeFeiS6XkBRaHv91FoBeRUYayzhD/L5cyISggcc1ZxQqh13GRAZjcoBHifopzke/5rXpSI3cvJXN55JHuEwH7g3sTiKM0j9kodmALbpKhsGw7wvLpUq56dbTqZKPmbzotql//Wu72T1+kUajgspTyrbJcdBS/Q4VFJYEyAQPZcDxRdBMKPwTPVJWbTPBjmdFyadJvOuvTECko9Xj6X4WzypO+BrRn/1UkmkTpLwT7M5yYT22BqjuvJbCLLPRmWH3GSCSwNwbtjexw82d2LO7u769nD54+u0ayVrd2CYFG0XpsQ66oOiQMDRvALOkPYuLkzT8AcRTZxyAKIKPNukkvSk0iAHpknJYKRsaWicMjaTTlrnJXy4MQGd60g2QN5jdOol+vUJtMV9D9lOFJZogGVOBpiFtUd7D/im2RP53CnILwotLjALM6jiO4fHm22WLh8glmMBv87VayVS1YpwdhBYJ1uR5l3sq06oYWqfAnL5nuwpriMdFnkelW3IAt9rqtUdPcPLlfr2mQnXFnkbUqxQBdbtFodAwpnRktLRjBzhHQkslKlaBkxTLlPJ1pSCcHDoy5gDmsPK8iTSoyQ5bqqbLRdMCp9fuIuK4GYteQHApUCO/qBIM4XJvX5TFbPAowaCKrAz+i6OEYHsGd5vuwfCbnjSMXfPNjb0yPOJUsrRmXogHY+hhZkoUVB0arlmoTbXFrA50GBrD3PG3RyhqnzgFnKOgF5oTNkZkOlL9SDbpbOOIRgsdN6lJ4sjmw+mWtGiXNOUKaILemi41Ln4nx4GtinT/fWqHftxfPXTtrRHu4LLnMplp8XXFpc/AQQR2GiLkoB6odU8CFJLop1UwyV69s8NNxJaqBLWzylk0QmBMs5cpiJPT48KrXl9q5t9SL2fcyYXdfKAYu7DR7ETqDpiN398eOD4GUu8LvnN3b3vGdxcrZWu27FpKl3z9eBRCR3qQbeuCGjP62xS2oKekw+v1xlVYy49yznjJ8jXqRcEjZgzotpfWBPZYKs5dBDpBb+vTqsONvoeiI7SILjesQMv2ocnSDDkQBDcQp7LaPTBMnL13EU2nKMp/S9IsRSusUDXtWOVslyEXOFTkf+1o+DsTos1l2t4J6n+BsTK5fliga6SkzRQbjG45XWNGMqXu0ldNsRA1BAb2IgDTFLZO9cUkJI06E+c3Kak21wy+HCX+43dgwdHYTsp2Kd+S1F4x5t6UZ7IonwsHYuBhC7W1P6yI3P1CD/VsQtfLcxwSkoqIF1vp3vnNgj5qvrKCnsT4zl8v9TNfI1L8pjurWuUtFxtXfXfHpYNIX7zUaJ1FUs0DK3NCNFhINWbjdJItak4L3ZVF0EVcVlviV4EjeY1VLwapRg5rwXRg1bEraVu/JkioVClykwV1XNWeYGDTY/By1SFGzoFLflejYRYg4HG5yGikFivSneJlzkWZFrZcyRC4dZAQ8XGGyNJCNl7jVT5cRBSwzNYXe2mLQIHC2WK7s+ptZtV+yH71/qcMEnkUuFQ7RWudJsjBc0lbDfdUH7U8H2EUVGIjyf6o2qUp6JMDUpPHJo48TFUyNkteaXpUyTzdqE3vJ3srPtkDgQ4os35wmJCaQM9m9o69XeHh/GKm6AnknqOKGj3JIwz9c6Wtzm8GKOZ1akOsV9p1a37Zm5iM8VgTX5TH7ROcOR6B8OTATwLF6wfxx77gtQw6HZuzav1+k4GzWPXZMelmzBigf3Xoou3ler0dJ6Yf5Dh8MaoE1HozmdcXntJD1ID5gtl6xSbea2g95Fp7xb2H2wZU9M33yDiMGoosAPN6V+Cj6mhuBz0T1790V3i66RQ91ZqxyAHud06eQ1X4aNl2a5D3AtN+bg4OX9k8jujF4+Mx2c4pmKHjvFdkXiQ8eGiQRr8OlxonkWhhBEr1HUiHgZAGFvbTod2W6zlNUdBA9QGi4a1jEylQT04kQ3mXh49RqJSVmzqsXiqMuSC4MxCZ2wHKtCzPFLtq3WJOJXzBQa0FOoZAvmwsSk7Q4ne/XyrbSfwPa8XyAx9//0OTyHHesbyHpx2NhyMdAsHDjNA8jxkz1bp9+ycpWuJZEJPeSoIGCUEbkjj/Ry7psK8YTCQ/MuFZMeGRYnhGMXxTyli6RT42dyqYrPZ//pn35nf/jNv+jCwJXn2+9e2+3dlZvkx649Br1h3R6PwPwwKHGUimy7Si3dkg4C+sKlv3XXpFpFpDQ5yXAS5SYCnopEp+dm8d5po9F1Ag7/G7h1OJhYFHWsWqOj9C4PBARUR7pbxbzisIPkIRTLX0aZEZpG/znpjDTaKphtj2ubLjGX57JwkhpQcrbjZzrJWrPe6tjD5w/204cPujhZA419XU49EQHYuZ6c+SOlevFYsWy7sdkCQh7P/BKWDdGypEuQbZEywtLsr/gFhpUBACYHyIr6PXuaDCQNlKMVlyFoSqNq2XrjPIW4KEQACFme4ZnZarlQw1WjaEE+s1rkBapnVRouTKxbCKKQmnITFu4a+BudRsv1vRS3FJH021rXzsLlLJf729fuKEvMUxJmeZlueR5+rZx4HJJgFwggDY9i0SHqh3xUdtp0ul1bpdMRs2+Oj6uqbs90Y9aguSCEiKigjlP+quXEiiziXFDq7Fgq5YvI1j1f6Q6xtIMGzgYD1tWBT+fFEmWuKhNyP6TL8r8kBmstJxpmZz5j21qQlPXf+LokK4TrpS2Yk2aedcllT5zXCbIPBJ41B9zC+td1++7bF7oolyvmI3tbb/AYDFRMUPlkx8CSPZch0J9QPj+ogPWI24IsA5SpFwmujuzC2ZFh0LA2PorkbBJWekJrhtdqqst7ozQBtJnAtcAzEKJ8CM+lsFzvZNLA8/OKig1FAgLapkhG7Sw8jKGD3d4Wq7V/9jASMYHDkqKAX0m5+sUwnLmgOxf5jBLoKd1S3HCBuH8sbDY0a8y/VnO3kpJJNLOFmusl2YBARQzqV8WV0kOk04WgAo1bcxLP29slRdszR8SXlkir9d4OgnWKitYq5cG1mgEWWAMOscj2ivmo4D2KNPfhFaci13Nc2HY8O0HCSlqHkOTPUgN0DpJSbCUOiDC26YH1QSeX6N151U28FJAiF3hkBaDhnNjhcVlA8GRUQohY22qxtzXrRnPwkx3TuQ4iuAAUjzByj+j4Dnx/DjafadIpU+ycD4GdmWPnUBNwJzy6BgcGF8yBgGXv4MQ6lak8hzfmH2exAXu9njSPD/cDK5fqVsFjN4LsxXsHSWqKmc7fH0+n1um0rFzzyD06bOlPSwT3YhcHG70qqRLM30oZwhkF9k4JGwSew4zHYjA70QF5QgrzfTox3gfenTwvsjV7V7hodXXZ/s3f/MrunvWtUubvANnu1WlziFbLzIKBpgs2Ho7sd7/5vQTt/esb++WvvrcXL24Ml0q6qrBIJ+uOORdijTqffWoP90MbPa6sVm3qnALZgC3NKIVOB2id3EfWLb/Yt15Eupcwa0DSLs1L3e0GuJqinPddHAG5lq1hxBEysyzYLturaNa6OMMtCL4YovOuCkRFgZlwyDNDjQOdXTD/+9d9K5U2tlmxbiOLawebztfSiYPOTVcLGy/mtjkebDld2nS5sepiYYX4leabck6iW9P8MZP8w3YFWWkeibMSZEJmbVkhCHS4Y3go0nD+OVCePc//v1mTanTyGfeJOL2twtfByvboU6PEml1SiuqC/leznOCF3CksqiCQXA1JG3masupzgxON1vKkHvFCtF/hq2ykUe8XIdi1nPyoEGg0lzlnJieW8jyxwPOAhK94Uf7wzUsNizlEqO44wSVQ5RCh02NonKCvW4nQsF7sREPncKH7mC4WwtBLSWjX3Y5eChADBtt0JXwNDi90lkoByJO2ge6oNgTPQW/P2bEy0QWWUOLN2dqNVu6/6vMWEX7A2WHqit0nCF3xWXKLgd1IQDJ6SGtIt7QJd6IQr9do6SCe0Jw77LECgisCRZUFL6uFpzuDZrxJLTi3FFwM24+KeLf1Snw2X6g7FkEEzRakkSKyh8g75y3WVMxYirYXm5a4GycLcAgAVxdELrJ8TuazOqAibNKYl+CSxPyQnxVKt/SepUhMQ56/NJuy5cssI80AKNsysYi7V31R5d+//1mXaRAl6tCBV08UI3a2+8c/EzFwtSmmB816IOyUW56yMJ9N5arCYSWiDh1BgZy5zOIU0gKHDabLfmjzi+4NZqwuTEFX2NGVBcfyGTi8b66udEFD9tBlKlbm0VYc/Ak6W+bW+ED64Xg4rHX5MMNJ8GHNRcesNQ5iCClsELa929Q5XOsMRt8OGiOcmL/4e1C+ndxrKFCcRAAZTZ9bpgJEEx3lgcoMnRky81/IPFx+dGdBwDySp8ll4DNPdxzRFMWTQfQb0tjGwnMkjbA6VjZ7ru1dr5inejYhhvYwXVnzmk1tCSw4WbPR0qV81LzH3xuHLGMT0eKlU8R8nu7a+QNoLzFc4FJgvxZDTNWZE5Ws3eyKZcmFxGyT4oe5PN3c1RVdoMOHSG7oIjbrsszLuSyL4VR7SbP13CIOIwW0sRUYnOzdHoEEdPceCYUEhXexJ4ruvLNGs2ivXnWVa8ma/fWvv5Uxw27LmvDszpQLH9MTUuzpCEmNCM5i/n7z/St79fqNff/9G/P4zKNVq6xHd+RyFx06a/cxDgsQpnjeMCKLQjH4mkmZn4EuD49bEDH2qBetIRCr9NJkHWI47vFgHMMc4CDy3U7fTU0oCPdcZDhv7awfdEVIRDPJpYQMDXgc9EdhB0HRgjPnHl7BTmTR2CS3WIfYyBy3WWPtpDKDaGdnXcCMcgrRyWazsYpfPMBBNzBhOJ4wp98LlqfDhI0sORT2nakHcXFxns8+5hDKUiekoaUzMQ4Cq4AkpAedYRR0nEFwSSgU+HrVRk3kv2ZzJ24K0hWM44G8/+v/5n9ndzd39qc//Gj//I//bEnBOQpAxPTq3BEXRjoFMpclTQ9TSopSOmshjyQbMaqTMxCOPFWRDZuNpl/cISqElaXmIdti8OaRjF9dR/nyed8xd+jn+SI4ZYhoz/phNM9JT4r1qaQlO+1H7nKBKw5dEikSpDegiaziuoMkATecWDpArNsUanyRfqiad2E1+D0XABUHBBd+OAgJeBp63iTSlKJMykn2Dqq+kb0jcvE3nZkONjRFa1znnVCjcNByYhvCo7cuDPdxFVmFKx0iwJnMF+WEgWEC87sAcX5FSe9E9wBvXvVIoR9rcJ9lmsR72gELmgM689khzBXIRXQDxQIuPjjgh8pi4/sKRkVPRxdoZxFgoH7LO5dg6zy6iaqYqo1nXMeNpMLngSlIF4PMxd0tIJlwUVOtRxHL7qzuhGE4TklZeLaA+LA0tY+Pj9IrQYTY04kw5xDZikXrDFQGklTGXDBuDOEZgDwf2UOxidlAZrbZH22xdnMCwcIyUHe2bKXic0WNFZkD4SQSlUUg4v1rQM/PwwXCBRy55krJIqyVw0mhsjBii9ddrReKBmC1eG82Gq9tuVnpsEIeAimiXI3FlEQBRIMox6eQ98ShZ0qVQevnWlwOIrx7865Zlnp8Lve8pUql81RBcMD5ZmFRr2TdTk92a8OnqY2GA13c2y0H3NEaxIGR/CGZk3cdXC6nY0EzOKDJI9qzSl2XH4UQ++3li2fWahFFt1Pn00QKEGS23RDTtNEldRIJKVJxxm9Y1612T8bqwNYKKqf00UHrczke/wEz+jPPDYtACDLIE6J8r8D2LFiv09VaG4wHmhUx3+PvsJ+JKtJcCTs91nQR+QJwNLdSUwdzqcxR4+ECzJCB97ICRcfJKjUPz+Y5i7pPgPPh5FICMi6ZJr3q2u1tR1KV83lng0d0vRi1u5wMw3WewSVfMi5W7Oa6b//bf/13irhDxwnhbn9cqojQdSmTfUcBPFrPPzdQKZcPSw9WJR7CkndZYvsqFoicH06w47wAYpXJNr64AUc85h8VC+fMX905B7Qn3mACUZEk7kS6CB12ulO017V5dqoQD+kuPeB+BVFsNNeZ1e9fWaeFptD9iSH8ANljGXrYEYPIrDuxpJgJYXPjfIpVUDonu0mNoPmluykBKVPoAaUit9LMGK9jOVkxM0bG5IgeqAExXlVgUqFkZauXrtVMSDd5OP7Z7KNUsmyzVoB8o42hQsPmy7WljCK4rQOzl69e6t1RpIHmhfg2l4pCDGnASqSS7Hce58i4hDshCEQYZR6Kpni1xCWOuabzWTj3YMuX1ksVTXwu8n4LkBdjmptjXgQzXgqUtvJVL8pi+Wz74+UA93R42mZ+ARPUGxWLUgb3FZvN11aMlzq0EZeSnQgkhh6Iqg2zXJwkYIDSOaR0mzBj1aG6AwY/PeQcM1ilkDVKOfkid5ApEXPEoJ2K0mNXZFgOyUbQKqxHhuO5q780gkCauT6yhJzDzbxLlbI12y09bA4/rMZ2CIWBvk6xHfF2rVYFdUEyoIOiq+awhh2KU8hm64Py+8ehjcczVabMnyQ4JkkDMgCuE7hbVFhUQEap5oJf7N1yqUTcqMstJcwlCbUq+r1YHfwBd4pcwE8ljQSD/79aSdQZKh5nt7VSkflfVe4ZdOiHwknONpiepriuHFMtLBYMnZsMqBVv5l69VLxKT0ErWs6jsfYgBO6/StW3XDoUwibjvcjeLc+XlHk+cHi7LQPqwdNI0KtmCPz57BKYzWz2qM5yi4+sfHjRjtI57rQxuJWAuyIyUfMCyBN5gbxcLkLOI8QZ6Uuz0KaTtQ1GIxtOCB0+W7VesXqzao0WyRpd6/awr/OQYXfyPVmWHr/Mlb4YZORFjnd+FGbO9mMt0iliQEAB8fj5yd79/MnuqwN7urqy589v1D2SEoJ+FXPw42FntSZVfk6+UWWMXV6iLMJKKbJaNRa78Jy5gQHyj36/q/k0hVVYrOdrhzkps/a1+yEXYmkv6VgGk5n9+ON7q9Zb9stftkUyGg7Htk03OoB6vZYuEQo5rBi5KJBY+Hs7y9KwXETDGNjT073NFnN7/uLOXr19Y6VaUbNP5ou79Kgc00Ju/J7ARIeNfcCxC81w0fo3nTxg2dmTEJHQpK7Xe8mINCqgS8jN9dUJ56QRnn+1FitOicvVZV08U9J4FkKb8HVmKKtLEt0gc1fOqFwO9uzu1t5/eLSPOOSEMGgbdn3bUWetiDfWq2RqGKjkF4ni5zCdQJozczYtl18FeZknXNCZyB8cNrAMLTzthvUjA4SqB7BnNTxRlzaezNTlwklg/k8MGjCuGUxocmt3FsVeMEOFpag/U/jhTPThg40HU/vw/oN9991ru7vrehHOgb/3ZgH07IypP3yGHCXhTHh2c2PLDTZ6udhfMCXFv5vOi1eCsxj2hny+CjIrDDLOljEfB6IsMBumMN2Js7DZxIZRNCEQFPBI8Pie+ABjIMBIibOXs3yxmqs7pPBx7MSL7s1qaw+fH+zz50/2j//wjzYbzZUTmjUKch9rNGsi5aCuQI4E3+Wq27bJdObETJxbNxip89novJ2XwKaiMcOuUZ6z2PUxbkvKKnBRSRyDk3TNhZx09VUvymq3btPxRDMkvRQ9DA6nPBqJ+Qd+qSHxTAeRUer4g3II5yy7evUbCf8hDvCCp7OloFe6Mrxg5daTC3EFYegAy0Xnq6Wca7R5mOflGkhZxNlZRKDjRd8EbEpHQLcgQ1zgShe7Ui1Lr2gQFZiNnK1DV1mtWqd7ll4tqiYWHk9WwwwhWthgPPFZRD741WEdFlQtrVYFe/v6TtrDP/zxJ/erhY155FJxyyoPOWY/OiFIuZvybnVBPv+/nimC5SKejdiFlaxBRYjdnu4GoCa+ZiAaNRAuFeir18/kF4mht0wAjswuubyJxgrtyGLnvwFVhO5Vygz2pBnK3g6nmTRGXPp8BjFnyyS94zLkUVIcHkoUD0Nduu5E4k4jsCHFes1dMvj7el8iP+Tm4p2+NgYBtyAB3333jTUbXUF5dFMcBvKYhAiyRzzsllQXowVRz0UEIRnevxeb3Ds7Jys9ZdDQA2u1mxaVEl0MwOU4s/BzZotdfpAdrJTE1u22PCP0sNcM5fL9iHwC+kT+4b6lyAC4zM9iaXOo4tvJ7JPZaXrG0xRaPTOUgt1/GtjHd/e2mL21N29faqa4mC5sPsVSkcDag42aaIITu7ru2vX1lZCX4WpupXJoL57f2L4HrBtaq93y2WLOKI1Cd4fhmTvj242oC5rpMQct2HqT2bufh/YP//FH63SvbLMtyEQb9i4wK10083PGCDfXHSuXG5qZctBzeFAQ9vsdOx/psDKbLZD2DC0uFdSNJ1X0yVx6gVX539le9nLlclGHm74O3cphb7M5pBVMRqq2Wi+E4mBo/zQc+vyXFBAxI127zN9T0gSkkVPm5gwnuuZUXaWYrRSbu411m00hSST1UAghtK8Qjisz+kzQ8hLC1x7W+kzfk269+Itv7PmLW+3jyzNjhKN8WzGpcbxyQhB7brthpri0ZhtD+Z0dj7gvIY/Cr9RjuLhAORouEhmqOCwAieSqViDnhPb4MBAZCKOVGr1pTMHjo58M7WeOpMHWvszLLykprGvQOELer66adn3dEiGPjh9EDOSF8zjDIo/ZOkjACvldbFFctvOJXFdQSch3mbWIdIvZA12NCt69/6jw7HoNt544DxrnrPMwh9AiWx/wai3bqxfP9M5QBDDeYv6HBOzi0iR9N649WwpfnHcONhiPBP0zIz/tMjsf9tQ99m//h3+ri3I2mVkppqhP7fHpybJ9ar3v31inVff9TxdZjKxVrdigWtUYD8gYZzXOiul8kZselMxCZ7iSUsWq4WwBbbju36jZkpwH7TIjv3zM8lUvynK9ZQcYWZh4n2n7j3oQagzIYkMHhBA2KFgBGJAE6gIssbK6JhZ1s1q12WhsH0ef1F04g4lKLLJ0A2TiWkmqWg9p9VmjrLdVYQWCDXgJLAguIQ5RwaElt0Fig2rBwjpkHqcNt7MVFnfqssrW6bQFI2wwVN4zYxXgqkuaLoqHi/N8udbU3AH4C9s9zWJzwwUtbMyxGzU7FyLNCyHXrERAcPFxqURGppskz5Ybb/VhxxW8KxFL8EwXkzoMHGLn56bPgv5grqHzI7T6BLSG76kzNxHkE1QG7Z5ZD1UUc6Tzjp8TkgbxY8xSEfADLzCXRHojqfwXeydZQoHxS77A4UcKS6LujIoQ3eE5o/qHwVv1Tj/PlLx0thcN6MVFSEkJhVCQ7/uf3n/Rm/FPqnOZDxRhlTrhhfkWh6jsdHPHGYob2I7Mg/R8DqElJ3dsohgQlI6M5BzI6o/vRzGz2VMtFuXOQxEEuzM45xFfKT/rTsXQtNuwToBHZ17/0LgqmJrNl7isCJbdzgkaEmqrboM1zfPEGNzDn9Md7k/M4wgK3ynBYjnd2HYBzBQI9uFAdkeh0E5EgO2ZLZ5UfNK5MHuiMKolzCm5cOhEEptMyUoEvakpho1LFXiPOQudL3Ma1sbxBOpSs9ngyf74x082nWFagb7zT3pmOGLhF0vxhgRA+Z/2rT17duXh4VgcVor6Pkg+RsOp5tiVamylTWTpYW0fP7+zl29eWq1esp0Mwv2dopXmkAtWZ6s3atZoNfTumQ8t1zOluLi1X16oHT2D1k3F984SRZO7TW0JWVDC9Nyxib2fcPFmVqGrBirD7D7nKaCXo/jcbPZiRzNq4R3JJSg9iu1LYgVRX8z6EdPzC84CM1RppiH0cKaJGEKijq9nCilgO4olZqrkRUL6AwFhTcJopgng0FUgsHxGfR9wCUrKkzHaqdnj/YNsEXGcIf1IdqTyBUZmApsTSZbb52m8gbQrwhC/o3ivTx8+iBdwd3cjPS+sX2BDihs0teihWWfOhmU+To4lMhvs7NDo7qGgOdmJ2LmoYLVqTWjBw9NQhW0h2quTVKiDgh0qKoJPRzrSg6LK3n7zRogb8YK73PSBc5wzW9m5jLB0WZNAstOZDZOdYghouJKUlb3bxH6R8IX9WQRD3hdzQ9AUuA6wrBsVJ0/x5yG1Za2mCrl3Hz5Kmy3yaxJZs15R8QungGIbZIx3xD7lebL3OOd0LvNPJZJ44c3n+6oX5b//+98L7gJm6+aRM7sCUOnedYvQOEOkFguxMOkuT1DSV8A0VVXHy9nc3r17Z/cfP+cOOWAXMLzONoepilBfnpAF/bCpYuL9IHMGmEOvwsJFYMgsFMtua3tlIXqHKX9PHFjkg+nkIP6J1odDQ/6n6VYdMWJdfDQTpXYwh9vbaDzWRVk7ZLZFjoLTA58jT7Sg86Po0wtUgsNcHSviZC7K5WisKpJ0dBdfo6/zy1Pujrk7SXrAdgn2oy8mKiI2ppxS8HBND7a0tc8d+HPyDD1ZekxF8c4KR9tn+FcwTzg6YQeGWgQMilAcWJEDwOUudO1UdWLoyX0fhpPP4zBg4ALD7CGJ83+XFy3O1nRSCBfPF5/X/HK8MP7cwsz9PilsSBuYptMvcCuHNUbwdJWPj5m9ePHMCgVcjWJp187ZUt+TU0TuPvW6KkMXymPIHcCMkGMNelY+F39Xz4QAWkHFHN5AeW5QXS4xr2Em5KG4VjxLcoHNWq0OvEoH4xmDkq1o3uT/vyy6VhCUnPHKuqw1GrnGj7xVGNDM8VYWAMNGwL6ucwPSJUEDdl+tWtfBh9WmED5IGju6UH42ZocUHpBJAgtkgcal73NcwaDMe6T3dO/ODIKc4r/c0But7+HgbNv3H57sabiwqFi3bQrhbu0pKKHPv8jq88gnrwx0WCgo1bNWmXlB0oF4Q5ffu25buRbbcDQU8YQZJgfteriwYrEizgCHE/Bxo1l10lEBUk/VetjErdY2meCnyiWCgf5eXRLEOooX15J6iG4WIQ3BopBgBD84mfXSNSCJmcxGOmgBFinUWQ4crCqqQTF2OxV9IAES2ctoAjnUXu8ZowGMMKRhxtwc5qqIUrmeMed1uCdxbNPxQl+jVa7bbr9SUQe0r/lZdrFudMMAkURg3DHdyK0Qne8QWFKO7fXrV/bTT+9kRkEHz0XrelrIe5CKCP/GHg+jCiBmT4nhfX/73RtdWhTTV/2uTArQS/IQL6gL5w2EMnSwMPEJVmDvUryDrpCmw3HaJNYtPCpFBENzYE0J88+BzZfM9dwIpdNuWqPSsozzvWDW2das3WvZ7U3fuu2Wbdotu//4SVmpYcWzdRW4zIomxB3tMfmUO7SpJO74+66WK0JRyJD9+PFnl8bhmMY74Tw+w8AHpZja42PFuiBEKkKIhst9ovOOW3/+wAyybuXqWdaoUkwwi1dMp6sHuDAvyMHl3FM6CqlXiGW/5kX5T//4s5ihSBhePOvaX/3yreyNqCa5QJ6eJkoKGY1XmhdxOHPIYSIAxVAShC0aHY/C4fbngICBFsiD9WiFPE9NtkoxYls3tMbTlJb+Yn7r5tbIJzzFnsNdf4+vczjqMKerOOKAT8XPvA3SBa4qGPXuvHuCKCSbI4lhT/r8fC1Ro0lEySnPXNKKgVJSvXdgVJJtFmN2lCMQl1ij2bJWp6uDmK6Uyk6dU6sl6KEOg/GAF62798jCCckDrF5YlOauJmKXrte6GMR8kx4IiPlkBZx+yoklDQTNTgii4oOIdApOdoI0gvdlFFhw8Od2Wm3zbMu9niWfVTPe8ymHe2Db+fNxohTf22csbFrvxmD2ni2p1Rwuy22s+LteQVPFeSqMYFkZlLuhu34zT+Y9RkgEgGHRyvk8hwOIg3U2mXuGqBW0KTiI5oSAr5lhe4rL5RKjspcpOu5DkhexT11eQiXNPAjSBxsYqzeCXZVjWMYxhvUFc5i0EgoJfnYuRgoOfg636AXdkGE1Div6mSBBwWJ1HTNfZ7VY2ng0UefJ/LLT6uqggAFLZ9LotASTY5Bx1WuoKifwt9qAOIGt2Nqmk5l8Ocn+5OJVkgmSFlJORNP0MFz2lLxZmL8FyIAym883mn+G4VZGDO/ef8YRUuOI7XIpY29IGrTgwIfNps/93r55Ztc3HZG7QCAySCjZ2RbzmeaGr9+80CwNUlBcjmyTblTo0Bly2dFVcDmyb+hCYkwLZCvp+4mCk/3V7nStVq/bbD6VpISLhkuFFHoub5AdZuoUg150oandKhWCro9nyL8nXSLItgq+5uCFna6LgE5KXeHJUmZRpbLkExSzpErQGRWKR3tTe+XSIRxtJGtC/wt0Cls/luMLxTnPCVYxc9zCuSCpzHa7EDQM0Wu7xfzf2a6wUz2t1sOTORs4j9B1eoG6tjqo1DG1Xr+j2a5QBY2ZUjttnDnPJa7uT/Fdua8xRWB+xuGEVsGqURAzPIqL6YGuCw83Zp65T3WGcWZMBEcWbDJb2+NgaLP51pK4Is4ARhjAx3TXhCgoCWrvZxUjDUZcCu2uM9dz1n9gB43NWrXqFygUhI5nyX5EQcD5S6d2SHfWbfln/jQa2oJGBXkT3br5KIgxUKagebc35b+5Y05gRGnC0P388OgkoRPevTVJ+XASYp2BNJEOpHxZ3htduopZ/y3Ht9C1+p7qwtw8NzhQ8+XEMg9p/4oXZbpjsHzQQ1gvZjqk//bvfq1OBwMBVgqDdBYJcwFYgPRP4OvrJYQGKMglzTG2q7Wt6UAiYJuiZkerndttUVFSGUPnFyMtROtHAgMpCwvNKSTWhulIpZ1lGkirsqU6w/T8sLeICobKQVWOcDqXooitC4kDKjkXJe41mEgzu/FMNi5It13yX2DbXJIctADBkUStFW1YnEDoXILCShfmy2fPdeCjDeLPyz/0TOJ73QpstBFerKQ3oC+DBEE6CoP4k342ZW8WQtuImYgRARUmn/tk6+3SrHSw61rbus96Vk4ipZ0MHh8lOcGdrWIVy4KdFle72rQ9JsgroFw6raKIH5rHiHXbUKfCIpTMBOcjiou8QuYI4DNdosqcuFMR4YgFuNPl43IPLix3CnFDcJIptG7SNO/WYJs5eYdny+AfQhWORxxCHHBclsz9nMKNU8o+Zwy6GwisXtiiHhDtAdKQlpiDUFRRdOifzIASyBKsD2zDDoKr6CwrVbI1azp86Jr4XHh+ItrnZwNmwy+Y2W6WudOQ2/F68gNdqQwKTvxse5tNxpoJH9NIDFEkFimwzhYUw9l68ttMSMfpqQAQ/M3sjTnaimQKKP1OZGvV8cf1v3PMQlX8wKEyo9gedPjgCDUcQmjZ2nq5syVORUWzz5+e7OHxSc+DuCLWaL0JNI++tGjNdsm63bpdX7Xt5q4D/9izNjF8OTijeCMHIzO8ooEIIenxRL/7/jvtR5jeiVGEYACCXAUj/40zQUtuC8l6tmArol5BUVKJZCH8XX5OCHBc+s2Gh0VvWD8UXHGeugGZBtIZRQmzyT2fj4eGtMd5XFlIwYpmj88a6ZlSYIm/ysHN6CIIrV4E9cE+EqY+J6QT9gST5lAl7GF+y/CCfRex52OrV56pG//48ZPgQEYlKnq4uCXl2OXB3aUvfs0e6E1H6JpZ2MC43nB4X111JB+DLMdnAD2R81tGR+4sV842yGisRTgCFAtRgYKNyxX3IQ52hw75P40y4CXsNipE5OcfRHJo4nPM1ytbwCOQDd9ejHbMSDiXejvO2YpmlePRLEdtPCVJdnWnRJGI2w3z+Y3NRmZPJTJaI83r95hoRC7xgeTFeodpX4lbbhfYbFgQh/bh8dEymK4UD6fMpqOpRhnMRCmEOYe3Kxm5qgBVCDf5xeRqojHe+iVbrtR0hpPFezIchriY9y5jyS6MdywNq26DB5u3QuIKaBLQNrIUD2BH0qQx0dc2HMAYWUN1sOfwZMMB7M6pPX9+J4hAAtstrNPIDgUulKNVkA2EFR3OXJLX/b4d040Me+VkJBu12LJCaN2wpWpIYcz50IhKT2QQDcvRb1Zsj0ML7NY4UfclckY+pOWXhMrANxsuJO+SlENWctceLkGG89KQCd93GBE/TboS+bbWqp5/lu5VJdGh0h0HezdA1tc5nnzR6SBnw2D3NLGrDp6RbnRNB8bcjIucyvzz58+q7vaCKWN9JsTRumQKgapstJiqMDN8Iz3qCYNkuknwi6QaWb1Xt85tR3q9835vUano3o9Q1OX7Cny5szOM3TOWZXSKe0lx6EDl5p9fypAJEJLzeamoeQ5Qri8deAE4MU9EVz5o7tKjC2wD/OgXIvAlP4OSXdAJFpAehBzF7nyi1+PpDtfX13rGk+nEPn36JK1k0MGntaWZnYTLzD2x8aKbhWiUm+9z+HEQC84tVS2go16vXAcnT1xPzhDdHHIKzLxG3eIE8lNgpYr78sqBh6BvkS9KX2Yqmkciw5EkwMN3L92yNrJIL7k0IE9NEIEJxmwOY/IcpaHLII3hbAQBBIcZX1fr1daCFBmFG7AzR2ZdAgehtGQfDQdz+3w/kvn7D99/Z3e319IaDp8mdv/5wUajcZ7gAtGqZnFwtsFwpE4J+K5cx7GorJ8Z8i42f+VKwa6uG3b3rGulCpmcJdtuFp7xKqI51Tr6ZXRnM2u02kp0EBuyVLXpdG6z2VKm4urYjyclUWBryPwR1nWcNASjsb7hBhCLBytRfsEVEntq6gaYwyNKZ9zAHnl8eJDhAZAr5wzyj2q1JdODxXQto4psj6EAFo4lHeZUclxwFBAQP4ix4wCPThDSYMm7LkzJLvlsEa2tLle6ciDBPIbNU+b532gwPRwcXTaMYyQoHkaeynCfooT3XyrV7Xji3ICp59Ic1os+mtBBYH46Ni5FxhTIFVoy8If97p+HP4cjD4xuL2Ld1s+hcdalW1h6J3Sx3PQCn+rAYVx0xnT39XpLMOdugf2mj5IoOOm2gN35c+v11IMp9kfr9HoyQjgxz4WnoJ/DZ7zykeXmLTCbdfLjaDgRjMka1TgG0w+kdknJErKDW2hii0LU+HppVrHpvKyOki2EUQihzswcC3FBqSdIQCS9UxawJrciIsWlqoxZGB+4eUosv27In3SXuKZNFyuNv7iDWHdwDHjfxZosVXx+LBqNnz1c1Lj6KD6RpinPDv1qF2WDQXzBIaF2uyLadR19YerWS2JKHYFLEOce7ACpJwqtW64Lq65VE4nC+/2WbZY9i6SVY0BOB1SwGl1csWhbWIg6pI406Z5PNncTX56g8sQgnOSmxGnOxuDhu8G0w7MadMtxhUQIJ51I44Wm7Hi0Sj5HUqQSG7uADIMoLndxWcK4o0xFhpGweItW4dCGAKPAaWd7AkXJPUI+m3gUrjW7LBaIuFlrEVQDhL1bm8xJQ1lLhF9hocJcI2qJSwh2INFf1ZJsyXa7pk1nWFQBlfpmqXfLdvvyyqrtsoWlQHIPnl3nuiu9mXLlgg0ApYWFkk1GS1Hie92muiFJcbYr0bOBDfk+wGIs2nKn7Vl3AfNhCCowbGNB594VRl/mrVjU4XZC53Jhusrtggt0ywV9sqzggnaeOVIZHSDE4cjbFE2szzOxL+Pw5SBu1hrW6vZ0qJaQ42BrRzhv4kYXEh+Lmg/8yLCvYOGJtAyM1NlI+edHGgShAHMw5iudlvS9tSZp9sxjgbvpCJhv+f8uEokmI3mgyNi2dBunvENmTR2dZLKVxIkqWhQzThXtD9aePp+Cpc+6jMniw1BCc/ciiAvw6EYSosV6Kfi42apYuRJZ/+pGLMnpZG7vfvpk798/2OdPA+td3akrQ0u9mK3EqiVGqVyiK+5IYsWlRSHG9+h06nI86fQ66mKdKAXUWbVmq2qdXs2SMkUoWtiZKP+yOzu4axVkMchmMngvQbLwgnQ0Wti7d581I2KOxOGZJFUJ3emSKhX0e4kyDel8gL1QP1CssLZ5F4rjo/ii6oclKUb1UcWXGNSrrdIy6Ig+fHiwYjS1Vr0j39vldGujp0cxL2/6XasiK2GuKzgfX9aTO8SQ14nMCOo/wdtCbZy5zaVGwQaB8ICR+EXYT5WA+T8+w6EbTNAtcrhKeiBWN+MjZ3rzi69HB86FCzok2VrenEiGpfvPgVnAKcaX7HvltspeD+G/8wvcaAW41kcT7E19BQzRY7fh5JzVhaGor5z4IvtIt5Ik8uyqD1qT2Gg8sULoSTOMjJRKcjxozUjmLOcqZ+nOcVjqup72tHepHJrZF89urVYp2WI2y43SnXh1zuaO9AkGdt/qyyiiWa9Zr92UTCOOznZapDoHuTuWc5DFlWbz7N/x+WSv3r7Ss5nPT9aptxSAIccuYGcK0ApZvzRoG5vMZtIrgyJy6TewuEwPtpY8zMmF0nty9ouo1HQ70jxiq1C5FNHuFXuJQCt87Yvyu29eC34iE63Vqtrt7ZUE0HjyEc/kzjOhDskCFkPoGwtF6zLLYGh9gBo9lf7qitlIAJaNvqVm6SGzOX6tsOBmEEydC+IAAQAASURBVCq2YiOxANGJCapXHFJg1X7Zbq6v1elxKXE5UUlRSQKbfun4zmhkPEhXh2oOf7HpmQdqkUu3lXzxCHXmqWchotFCGA/sB62aBQujF6jFA1ndIYP5GikL/H1ZKjG/YSZ2BrpAdsCBxAJA3IxmrmQRJIUC2kvXm4H5w+IDZl4uSSkhJDiQzyjMVipY2GrXz/r27a/eWuOqZsUS0A7yHNiAFdsu/xx4SvdOUcPBitar12+qsyJtnhgsNiIkEafhnxRvxedy+8GDCd+SNi2wGEYkzV3eIV6MsMWS/RJO6479nr3nzweYCuYqsBRQCAemhL4HzK1HX8KxYUXjSgLJQPFQgpNgJG/FNGZubUe6YMhirC/kL2gSjxIek8VZgWAi+Yg/A581cTo5WQOd2vFI8cChD0wG49M1uCIE6BCsfJlFyixcbjnu58plA7wuyR11lboTHy9QJGJQQPeEDpdgABEZBPs6mYOxAJ9/Np/ZaLyw4Rhv05Pg3wLCdrpNgpp5XrtUpInhZGbVZtVevnxunU5T65vihI7r2e1zd3JhNnw8KepqMpvY7YsryW3efvNc5DkuPbFT5ZoD2YTOMrFGo6I1RvHpInmfW1MzQiyJyxCpMMH2GTDjjH/3P/3P9uOfPlij3rTnz+6s328rdYOZz/XVldixijBT9ihOVDsVl+565OYNEKqUQG8+l5eGUq49IEccylgBhlatoM8ObTZZ2/BhoYuykIU2Gy9tNpjYYrSwa12WscVRYN1OXY40pZxVS1GDXZq6QCK7juwtN8AH1hXyKsiVQpQryfeRwsVFpFqKiBZXSypmJpOBOh64BqBAcRDrMvbuz43H+QUaw2UNUiVZy3bryFEM8cQj6y5rVDM0LAfR5Z4JDHBmOI3thcynTihPfeGZaYaIPjv0UAHOPrzDqpodY0ZxViA7doHWDmTiovzMJLH1eqdREHs+lZTrMibxpKJaFScmnkEkAg0QP1AyRLEd/A1s5pbkA0PoqknexNkg4xmKYEDPEBId7Pudiq12vWLT5dya1Yqtq1XbLrbGpI0ZI3/PgxFqGiXAUo9bLc05KP7LzJax3kznutyVRjUZiwnPOQUqiBUpd9D7j5/ETeAcYx3z7nTG15wVjNIAb/FmhuGJ8xg8Su3PecZf7aJE6AtuL/ZVHKqroNJiM1HlKLUgLsmxgUMOfLhJjiIL8bizM44iuFGU3PG/0axAubBGvWOzxcZW6U6VqLz3pMPyCCR+cBaLfFYlHfCIJrnGZ2bj09gOeQqCNkl+OLE4ul1Ybn39O2ZwPGz+PjIHVW3IO6Chs6ihzOf5Z566AHtsl5MVTA9XkGXetUpcD0039wcl9ww2HDT/KKpptgHxiSW+XMx10QI5wuRdbYBqPWmCTc3Byp/lgKdqRI4hWn4pEjGBvMP+bd+ubnvW6dQMZy0OHJfN+MsOzGUpfA1cQUpiW5bslGIdCNsstute29rNmlepGHXTsVFp73eW4eyyJ5qImCEo4eQ2OrGCTqBAFZ7CPtw6UxCGqVxpnIl8GZYDeXIYQCayABSBvE6IA8zZPERYs4JiUWuIYoNuEiEx8Ct/9+Hh0ZZY+1U5iD1JRTMn5qbAYpEf4BhGsGlKVPfKKvV3EwVAbU4I4r0A52IUH4RAZ1eWlBwipnCiuheJBxKKCB0ccMyCnBzE2pP35hFDZ4oH4HvvSiQJQLR/gHVL5RprusglKYnJGaIU64RuEt3swY4ZEp+KirRizMamiwk1C2I1da87shVsdzv2+fPAOq2+NIwYK5ChCIMTWIt9sdlt7MOHj2LuUfhcXfft+cs7azRI8+H7wCjHNSef8ZZjkUrolobDmfazXI4Eeckq2pEX5tfAXkeXf2A8//NPH+z9u8/WaaU2HS3ENWDe++L1M3v+/FZpINstYc07rWcs0JB2UNDg7iSy1GU8ossA1MjDutm7EOTkZ4p2OSAfsWO7pcezzWYDPedOo27FILLJaG60hrfXPfnbTsdza7TIfEQdrdvFLwFm7HnRBESoJJBcpuCdOOMRTwbxdehuORQ2+wykjNg5tI6xdNfu6MPF4gUplyFwtQLMZcPogeR8HxmN7DkLKNLdB5lLiC/h4wkMztG/uqUmszMfTfiZwPfyicefyYvoVtE0Mt89YtW451O5BGQxndv+gHOYs2Fhl67itVVLMOkrtlmttc/Za2Gh4Z2ljFgCazfqGo+NifYDasCBafikyxXo9sS+psAIQltjyrJEBQBEH2vUQ1EC5K+74ACJMbUq/s6YEUyRhB2t24TUFtsM71k6a/FLvPm5u7tTo0AhzvPbQjCslm25WGqWTKMVZHBQHKHxeLqtHeZubsD4RMxjdKeQuZC77VI7ldw/Ww0FTZEYsB6wQFGjwkSFyFe8KO8fBwqI7fdamqUlVFU8NE6UMxU5czUcVIqWkiiAHKBWkUsGmycqZLJT4tCHEMQlVSyUZLALHIJrCIJaXjYPT10KlQWMKxwXcncWfi6q62O5qg3OYe7uO745Lq00FTcHpXR/ZFvmdno8NCKIEEwzg/BN604NVLVADzw6umSfZYYaJItGnDOolGTOBSuCz0mVvrMMoPrvtDk5gLkrHgcDwUDdqxtrX19bFob27sMnWyw3+pxsDOZvXEY8S2Y85QqkCU9WIE+x0a7qAC0mBUsxL4fwYzDOYJo4o2s0HNpytrLD9qB3QypHh8MDH08FuJ7FJCQ+igVJMcM1jq4UY2EqZyq7TeDaKC5KZhu8Dy2yHKaQGFpkFmfMAj1xaF9SQS4zSpEN8g432XBwQ9Tw+eFkPBGs591/Ubo+Fu5kMst9GZciiIS7nQg8grZhOeZwiWLbct2Q2LQE4iY+sL8YnF9idbDo2mwg8vghpHkwzy4nXfD1VFXCEJzMbT4jQqysSjxTRFKa55+i0+XzIyOiGqU78k3HYYe9Y9ROhJJQaWs+fsLQgVn2SvFC69VOhud0SzBGmbO0OolVG6EYfFxu7g5asLffvpAwHq3kacdhjOEEGYLMfnaeP7rb2mg8kLbx9TevdfGjcYRJTgoFEBeXD3M5ChouRg7sxWKSE8mciS7xP0xjzL5LfAL2FYeYvy8Kp8WSA6pmb95+pwt9tZ57vjzdODNy5EgHWKrY1cFM9rXCfwNJcbmDN/pZBl8AswC3YPNZsrNgD3tnRLYaXfvTHz6rsKANWc6XVjwX7Paqa0mJQpd0Ijo+Pl9qQUghVLC4ENkeeK1w1pwSnoPYSuzz3DoNIhvvj0tQ80nY5bAtM+bPpKFULQkh11E4bUUyC3A+YsZ19CINX1MiwZDMKPUjP3/C2CP7LmvLu2afLwL7KahB+4C9AuJ0YWHyQfILHuQuv/DdKvFkR6WQ5GBPFkp3DtyMfh13JH4WOjXGBYfdXqoCWKm42/D/YxCAexMzV2QUKA7Y/yBub1481z4m4Jn3xGxxtljacr1Vg2BnCjk6RvS0ZPEuxXz2oGnkOqTSFGwNpwJpGpIc5ZfCWMacYSc5SJxULCyWbIWXMTZ09Yo8ornIr/p9neXT2UwEPUh+ICXY9JVzropit0gUIb0lLtqnx0eFaDDHlb4VBAoyI537bu/uZqQz5UUHe8D9nAPbMXoROe8rs15H07m1MmyPWHgMwUOLSQqnrV4v1IGhh2EjN1t1q1UqeqvoFRlmAz3wGa/6bUuiyB5PT7ZaAJfyd+e2Xs+c9qyYmVzUzRlNAG0SqVvgQuAHowo+wNBkkwUFOcVTNfNS2Rwy6MUbFlE2OkpZ4x0E5dnubI9PD9Ztd6x5dW2VEibORFLBUIR8hHkA0hS/fJ1R6c+AioR/J2Yan5MLDhPrzcqdcuJYBy2VM+466YbU+YUuPIgerW7JXr54Id2mYow4yNGtxSXqwtyXENirLC/JdrcuGQGbjxnlZrGwUqFstbiuKo/NykZcpisbjp/sTDoJAv0MU+Gj1dt12+wYhNPhR7Y80O0drNRoWbNYEyEC0wW/5JjnIRY+6ZLinxyQConVPDin2sN21VzEjezFjP+LIuUi36GylCORIEonqmg+SQcnxMBdlP58qZ2/wNocSLqol2vpPzE4hrYOFCPXf1WB/j0riQuS+YVVmg4xnJvQYyJiJ6OQeesqsGRStFarbmFQs0odUwW3GQQeW8wW9ng/1myu1+9bU/Ak4mcuTqDwyKqVkrW7TelAOZgoEJh5Q2IB1t2s9tIW80zw9aXSdelB9mWGCZVd3Yxs30zd9vMXV4rkGk8ec2eUkrSW9CIYS3MwUiQhxcKft9tr62f88GFptQYZi7d294y8UCA/F4DHCRZ9eLy6DzPfO54yC+3quVEEMudzVxy2NKZgsE3ZMzt9r+ubvoUBySUb++Uvvrf5LFVhCwFjOhvaLl0quuqiDUT6wTrlQgCSLCXo61hHG1vp3WR6XhyarFvMAHjvoBbsqXIZ+j9OTbnG+uyEGU/EMJvN5vby9sZevXwmuz+QF2buPC91bEvm/mB7JNyQleos2SDyou0iL2Juybrk84BSYbV4YUvTke0I0JZeATIb80IviLRGxQ7mkibdBl9YzgUQGjcOSFRMOZLADBeIU4lAZJFWMIfwfWYWf0HNFPwsz1WsBHEDc+KJXMkOqdYbexsOyIF/fYpwkLP1mvhA4H4KbooO+AQwoyuw67RGs/1JHWP57RvtQ4rAajWWVpyzgmxhCH2y1ru5sU2a2vinn6V9JcAARmlcKkqDDvrBJTTfbW23ZDRCiARGMmWLEop2dMIeng5BMyUJplwxPFdO54VQFxyxIDdiJccapLjBarLdaKi54NxE6vL445/EPucb7nYFu+n2rN/rqUulUNZZlHfqx8s5JB3ayc1wtmub8+yTkmz2pMEW+uY2psq+FUHr+HUvyofxzLaHk232aHR2dt3r2iEtyN5qsZjKHu6bt6+VrQYFW4nxOiDy+YgRd2SWEg0UFez6hh/aZQzJumA3tx2RTPC3RHi7KqQKO90dmFNy2aJrczmHUqxx6GBuRorGxi3V2s26Dgsqf1p/Fh1/dgf0G54tXVMFBVYUNEJ3UlQMEOJzzRzClSV0wWr4Pdh5j4kvTihQlnN2Kge3PBPlbkLr76xJhoxzYAmIVYXYfRdxuOGQKnKoO028Wa3JlYUD9IThOfTyzOcUHJzdbtsW67FNpkM7WcN6N11t/GxzstHTxIaTqbWxYLvuW1xkMR/sTELAYmZ318808zoyf8kCS4ODRdWi9bodqxH9NfOCZjadqyNhMzGLA+odjMb2MJ7a7mhONMKggXgpbOLWCK6r8l4ENeAdHQ/O0ONiRFvJrAJSyR6pi/gRWGrh6pHYmk5m5Yn1BaLCMArA6oq5mxUtLpytEpdlCA2sjBgcBgsmCvsNBgNclE4Mkc+mZpeeaEEBc3N7Y+Vqyd5//OgMYazl1lwYiSDa7fZoH94/KdHlh+/fWqvXUHp8mySEKjOSne0PdEUFm01wfnJmLxeemH2xH+xcCpq4yQ4PTWVqSRzYLqA6XWqzg6asVzPrECXFfP4I8zO1UrVgnX5HustinMpijgtytSCyqmG9dk/zbOBvJbJHsbrtdquv7Mfd8WjlRs3q1aZmzePFxKqtinV6TV2YdDtyQjlk9ocfP2ltUhjgg8l7qrVb8pRFy8xcnNkUHQUUeSQGpVpF+6mWtDQjp2DlQJ2Ml/bq5Z0tW3t7vB/YZPQkaP3tNy/s9u7a0j1ZgVxGLtuRSWkuvcDfmWdO96f/nnoOaWq7fNYEY9lZpBjxJ0ndCgF+0aAKW6uUW9budZTDiZh+uV7miAUGCegSF7Zd42OMZGFndQ7+atlWKcVMYt2rjpE/wTqiyGBGdjzDAGcNFV1nzE3D6ZSZzSdLT5bI6OAPdtyRGeuXIheNUBK5MkEKcZMCNJh8fkZSdDuMT7a7pQ70S4oJs2CKe6FRiQeW87U0MjhxYfK1DkrBgF1OR6ZZbiW2+cPMNsu9vbr7RiOigPDy6do+f4YVvZIjD6gGcCNIy6lTtAo/6BmGuDuJoXukWKZgxc8oOrdcJ40F3HjkbNI4su1slmvA3ZdaqTOhcwTKFKuhBzDz2WQRSbFgJ6tvm2bRydLRwrKwpJQo9jZnN0b2rS7JSguNNdD/EjtH88MZoGRWzE1ASfapzF6YuTPHZ/6PLy7QL0U95DJ+QeiELf/x4UGWlVzImM0zhJriLXxy1zPiA7fjtXzJ67W6u5KB9uTRav7uv+JFud54t5emmIY7jXe+gi48tOl4qKqOzun5sxt1g+ggOZA5RHwgTRrHzmZFzAFikRJg3wXMispFa3Xq0sFMxmtJUKgwuCgni6PtTgdVok69ZtGhPXTHDio/2Ktl8u7E8vNg4e1lliZHHQbIRaUoaEZJAvaR6BnP/HPnnNTS1d4ixboEsslT5husuByegcmnSiTKOxuIQfgZYrGWJJrD8bMnRC2J1Xe2WqGmg5sFy0HhZsqeCXgJQa43myLO1ElV4VmvMZWP8+QU//OkdTw8PSBus1a9KwNhZ8cFOuyePb/TYqhVG9aoEGQMqzOzu+DG3r/7YIfz3l68fWbz0dyeHvBeZIYF89TFx8Ah2ELN52ssIHRBUkXScUvQLY0ivqPOMl0tKDk8R5IqlKIFY3kgJzaYfCAVY4Ue8M9ZcBcbQOZyQCK8F/nLatNCpHAJz0WXyfNUVBhEo1NqRxivMh1wDR6l+ng2lageeUyn3xaKwPw4VNanX1xccLPJyKbjpf3800crPhA9ZTogEIW7XyhdCiQxZEEu2UDr1e+1RTkna9M7YarcrXducVGJDsBbW5jIcm4ij7Fo3U5TbML96azZYLVedV/R6GjXVz27vUP87Wy9BTN/6YBBTCBk4beZWa3e+HOnv2Z+jd1MZMvN0r759hu7uurJxABEBdbzZLa0n97f2+//8Ecd8P+bv/sb++7b107hh9l4BIpeynTA5QoFzZgYvGaGJg3dI+bdENLwld3pgIMJjSkAlTzFicJxO4Q/r900RA4rPmfCk5iuFA9YOjBP5hD/0yF8XGS2ODvFVorrunAoJA7wGIS0eEA20DdsbtJYHsqf7LBmTx+FMvAccLMBri0pDcYPffY3hzGWc8yqOWgtweOWaBUSsJhD5qQf2TjCfMbFywteZsuEBWDkgD6VoiMs7PSZ+DnrNe+Ss/NODkXoufk7XJLId7jIZUahvFafj7EnFGqg+X+qr0tnx2W8WeOilJte5B1ZzAirDCvfSXLXV9c2DhZ6D9PxSvO6+48D+3w/kNk4xbgE/GKb4TOdWbudibzFuEWsz9ypiAOGgGSD8BfFYuPzLugaIQEp8E779fRnn+393m0tOcUzj6YCNkbaytdOQAVgma/cwOF4GokVyxmskU+80DmihBUu3egkEs9iBQTsDHUQIHgI+PiutjDqmXueVfihfae7XQDZivzFJR/bixcvrFguy8e33elZi5BnOZzFNp2QxIOC4qBz23+BnjhyJV9xsZ2/soUd05P9dq9BMeypbW6TRCWJQS0b/P7hyZqNuj2/u7IKGxwyA/lmOMeIch3YbIpRNQxQTwOhDcbiq9Vi3ml5nhqsOWQMmCbHdgBTPx6tSPSPzA9SEdWYX0rEipwDd57UzddVnZLqwUtG6A5+TaaZDn439z5DwGCegktLQqUVqwhmoVLJrnGmp/vJMwqhitNNgpnjTyj3oKLDiBzQCjzNzOr4MV5fS++FiwuQMhckBA/+7Hq1VnD1nFR34DXCSmNmv20xuigopvOpyE4KGyWZpVmW2S++sZV61UqNinUwTqfSPe2tUqray2cvbN918/WQ2ZKEyier3VzZcrkQ0xR2blLxogTImgqeC4lNvZkTdZN60jtzkTw9hXkBMx0w/8HDo11dX8mhxU3dEZXzPp0Ry4al6+SQZLjvm9M3qTw9FfPj8KqnjDgRSWxDBvlU1rnnqps+kJbhz58Dy5MeHD7TrFjB15ltedennDnIu9bgnoIFGnwkKArmKGbL4/GjJcVAz2F72NpCukAkTVTlnv6A1pQ9JwE7aRYcqPgLZ3tLsK0TCeGswoy5Dw4unc5JlzkCfKBzQsw5OF17V7JYWsqyoMl2tyajcIm7cYIhExK3kjhWZy5WcZrqOVvHk1BwORIsB0U+LtqbN691QbI/KJj4rA+fHuwf/uGf7d2HJ5tMl9ZuNe3zx6ECzW+vu5rdIUfi+dXrDQUPwCDGvafdrciCzd1hcD3CEPxg959HYp+COgDTKcw8hD0LWzmWtnk8mVtYKFu17r7G09lYZ4TQARnLu16XrtIlBhisN0WgshPsW+b/7D3me1ykpOJ0rVp+0N9v1Jr24tkrew8suj+K/BcnTRlpn9EoKmuUKDaAQS5tiF7AyWc7RZnVS7Ap2VnuPsSFhAwE6gOrTRpijMw3OxVJ89nanp6mMtuXnzQGGAXPtqQ485AFoqTI5IydiIIMCi/YkxN2YPnSKYvwo0uW74k9nCNRzAOBa3HB0sUdF2TDx99Jw6NVYfoW3G6RYkBr4RDbsVW0+QSTe99/nDkgLUdIZ/lcXhrww8F6/bbi/vbpXLF+3SbFNe5JJ13aaTrRutJYYYd1KKMnHLlgwAZWkFrBYU1popnxo2ekAEDPLOkcsC3WhcxrM/09YgflM50zyvm9TdDAuiuTmONyJKrZbu8EJGBZDBGW87nN1/Mvl77kRHphuYGMPLfd45vx3u3VtQp1OA+Ew2OUcCFL0dHu+Bpn6oKyznoZQ+Q5oXwdutavelGC8yq5PXcVgRGVlKkAsbDDCQOdECkeaznBMJxHh8PhRpWlgOP0ZMvN3NPiFT4ciyJPCG23F+rlC77AdHmb2XHt+j1e1G6TWlRxT0j5ypKfJ+coKiAuymXuPkO6wcXoey/HigwnmrycUqDS8WilAoxAf1By4QnJOStbgCMI7EbYfpi+58JmIErZveX6TRbkGi0lOk8OOyQBsTtzcKlnq73isUj62O5cTxkfWdzLPL5nY4djYNRckFBgxsLquu55xIz+fFKwqlhqodWIiGo33JFfnpZHCzJsoBio80MVNLs4krCAYTK0dDwUT0dR/QtBVxBgNa7Y3bNre8yelGrBjwc9HXIFVWwMPMRmYDGJQu3PdD1f2mA20czt5atXWpSVxUKdKCxiunuehTZOuaRn45vOK1H5ceZd9IUle7lEL6J+Zz1T8Xm1R1fNIXJhMutC5mKF5avK9c9VIWsHNKFIik2eLAOZRRcd7MNCwW6ur2wxHwkObrf7Fq7ZtGf3wT1wKAHD4BhStW2T7gpSCFID0BRgXKwWwQlc3uBJNFTugTVbRA25OwkFHExJsUC5XIUy8LkxQnd9J44qQQD5wsOHZH6v9JJKzh7e2XA0VsoHEC/sRNYSVT+XHLA2HTgdAe9YndB2Z7PJQjO9uFC1cly3+WwjuLQGqaZEJqjPximEWu22zReBbdfMJJnlOfwiRvX5bOslBavHmGHJd9yPhSzws8r8mi526X+HZwGJDaIfEU6Ya9BdcMDzHuRqo4KI94bRwskGT1MRNrgowxDGJczcqjXrBBf07Pvvv7NPHx9tOHyy/nVPJEAs7CbLldAL3hVdKxcRGCgXFlpR3IjOBawqd3ZCi4h8CCFj6JZplzm63LZkuYiHaNFOezrVvSUx4exTGw5I1iHzkjgpvFbZT94pkW3KWaXVoOLiKGs2Ch3OCc4fXZck+Mj96WJKQLdOhBfFB0zpxMMQYGLuPYOTi48LTtK1AmcKLH60q2gsWTtzXQR0Ylx6lsHSPkkFwB5RIByOWy0MEZhC7O0UBYo3LFbRfJ/1bOazuXgdrDkalazEPqPYZabn5uYaARRoStxTW4heFGvZKioujxOUH8cRhy04LPzMoFAwwg9ucnIAYnUDFwryyWxhxQrFohuIOIETXSgSNaD0gheAhaKMRZRDLEciT2SisOFnBd3gHY0GQ30+Lk8+K2oH/nnY7qwYhGpC5PeaX7Jc3pzTzO6/6kUJ7MLTEPQk6j8RJgxDyX3M5PXIbGoyXzrT7MzlWlEmWlSs2GQ+tvef0Hstvsg+ECm/ekVMVN963YYc7h8ehlYIIEL4hbbJJR0anit/koiaRAuWapg/w6HIpetMMthh7gwiPD6fIdB58GeZGxIzg8YO+JHBvISouSwF3ZBg1rgopiv/XpZU+sxo0Tw8mls6hfTC5+PrBK7HJK5mMhxKjtGsVVR1A9vx+dTpbiGorHQpgFjyOVn0bJz7+wdlrL18dWvPX1zLRgyiiGAQNIdJIjbu/pTartG0EpeT9E0r6acW05WgBhYCno5Ngn4xsq5y8DQkZufA5QKm+iWfEebiakkBhB+pa6P4PNj0KWyZWDNit3Z7BUizqUAC+M334LCBkeozXmKgqEYL/wlMc2EKX/73hdXMu2JGw+Upxizp7ZoF5VVeLn25XKbyQIUlqMG8X5yuTfM1EjA6UZID83Gs9dwm8HA+y/mlUffoMrr3H779xjbp1qaThT09jfWZORAwlK6UIQZtBPWerazOBEKaJCEFhyUvjkSX9IhTEbYfekkIHm4QoTFAOdKhSr1Hp+H0eeA4j2oCyha0rFw9sjB3X57NcomhuRvrc6AeSZ3X7DLwOCURmgq55MAPoWe3t1aMujaZLBnTus443Qk9URLEPtKoYzZbyVA9sESFQQU2umZPQW6Nh27T462YOXoqzzzvEBh1QGJKtPbaHb/AJ9Ox/juwGmMAz5/15wThDekUhvH7fSBIFx/Vz58fPAC6yLoMrd1CmD6yyZDs1YLd3vVtOh3T79nt8yv7lB0EtQuW11xyI1IbSS7oOxvylkXihdn42labtR2HgZUoWhtoT5ndeUi41hBhzQqJZr0DCe9tPl3bcoG5dib7yaRYtk67L9OUAn7KZ9iVnm/LL1jitLCMGyS+l9+op+EIfYBTDAM4oQFg33s0Ge+91Sxpz6og2QHll7Rm9qmTxdwUPpJXMQkpuhhzCRJolEhJQmi41CCXedxhlUxdiHul2K5vbu18ICmJtCH34uVnZ9+yLi8JG+wh0l+wAGVccVhgCo/Xa2KddsOIX0dmAk9AYykhRspv0eUmLTokotxzmZk5fw7EcRtspXuFyLlFTgghMszj9PT1eI6p3HmEDnChFXF7alq93lRXj2UhZwhkS5iwjWYi21CMXSaLpT2NBroQX9zcWavRlM6a4iFgdp/DyC4ry75ckvy7r3pRMoPEEBeqe3rRDeGSj9F0EcLEQRvMw1cjW2A5dUztmzev7e721g6niY3mKxuMprrs5A9YigRHMZtsNgmo7enPfvr0aKvRTDMhZjMsMg5owSY4J4JnExVDRYGFmxJUubuwZsNRBsmCM9XUMbH96SrlIeqLG8o37vkE4nIoETBK8C2f5UC+JrOtPI7q8nCBaPjkvCi6Ls/hhGXrOkgZIBBqi5j6ti/Ic73K7MWrZ7JnYwEHcjKmCqVSbXoSCj+jod3c2jjbW72BiUHdmu2ai5fPB4l9z5u1ugYZOGwPti7sRMrhwFnO1lqsEnnTYS1TW8ymqtIxLsC3lDOLz0kVXJEpAsxEyDYQKtYqGkgv4cDQkybrjuDTc6ALB4iOmR8ELo8Co1Jr+UzwBBUc+M5njpWsrI6eDXG56JQFp1QSnxkIIskXqoK7uSi5UM+Q9nLIlcsxZP1VHb6nI1VYeL5Rge9VQInC49CudJW+YekWkcBMlkvbLE2H+s1NXzB0J2zLxPy4ByGBeHUU2YX1SwcgZELM60Cdqnx4NaPOZ8zaBx46zDwYmApyhW9+GkV/zsh9UsKWYX5jMl2petwUxIXt2iVWEBTqdXXlXJQUCBBDuODiHJJMqiVpy6bjmXw0dxvyAvGoBdLiMoaUVbbqJpQUgvFFVDhLO3vV79ghXcr0AxMCfDMr5b0MH2Cz/v1//KNm469evXKnnIzuJbReryIDcA54PhcxR5hw/PTzB+t16/bsRU8d+3g4Evt9PBhYu43xO6MB7zqdxV7Q3IpwdtiapIWxNjw3OdIcl7M+hHwWbmw2Yx4b2PMXN3Z9+8pOGRq6vQXFo51/2tt4PtIhB4GjUsfCr2ztq55d3V5ZktCzA08GtlfQMPPEyOpN5tuednLCAUaG+Hxf6C1clMwysV9LZUkonSPkv4gAAg9PB1kQAIWfLAxLmLG5iTkkH5GV8ig8YEJ5x8IKRy5igdy3cDACop+SvBGQ1+lmAULd1nR4EjjqUnQ43OFJEYfEIgei9cCDCLYufAKsPqNEDF7WKmcd0CxoF/7IZzyR1yuRXs7yeI01M79kglJA0GnKwpB4sTqsb8+TjIr4tuK8drL5bMLUUcQfCjMuf+1vGgmei7pMh0qpl3V+7PCM3tp2lylphFFX5VzSOExpOHYpfnE7QnYDT2Phoczqal23jmlAklv88f9zJnmEI8+eYhzm+ESozk3/yu761yLwrOcLEeQ02iEsYL+35WatsZxUHF/zouy1O9brYlc1s/ungUx2GbLq8BMjwSFAXvinzw9aTAzK+HdhlFil0ZYVGdUM1YaLR00EksVibR1Cao9HLZp2O5VJL6n3NBfHMzR79E34xvoLAt7iBV+IOIQCaz6Xu8cQtQTcivieSo9DdLdZfanaWfSkOEAWmc5n9v7TR9HggT0a7a7d3N3pZaA5Go5HtlivrHDy2BaflaHrZI7gw2BFJckN31Mt2MAsrv1+rY2yXi6tdKqo0nn5/Lmdswdb0MkVoMBDImDwz8HpXTuUfhaOQpGLmbpLpDi1CjFXJ9uSCLI52mgwsenT3A47NvzZsiJhryxCE8wHO4xOejYjRDdWuCvuJNoUUWSdTtWKIZXu0d04mp41RHo9K11SHKpD9zJRx4xDhlyJKjWr1uvqduo1NGvMCClqqpotHmcYrf851PlyUepizLvMSzfIxhXLlAIqLmuDcUhdsi9ZF3yWi+2ZnHry7tRlKmdLIFvhpJN3Z0CUfA/IR1f9piVFLOPo5AKbjAdWbdSs1epq7rZPhyI1IDXiM+9TYDRPIbgkolDUcVAyg4VaL7o/VTM6zkJsq+U8l2fAwg7t+q4rezjgfy5EDhEuaA+9hqjjshaMF/g5WN/OtEVk7VKa/X6ad6JOeGAmVoxbymSElCOWadawWo00j1goznaVWRLWbLFAl3u2ZrNilVJohwhXoro6nd7VjTrK8XBh/69/82/tn/7599rHb94MVZVzUPav+tbvX9mvfvXXVi79bJ8/3wtaJQlk8Hhvx9PGbm8IwC7KNNz1gSTDjHUJ9Xpdm80I1HYbNvYXxgl0amvltrpTDH7HdKysX+aCk8nQ0m0m9y8LMAyPtY/DqGXffPfSxr/+1v7wuz/Zu58+aM4+w5cWotT5QJKxxVUg0kyavrhattl8pQORSxIoj0NFEV6QfZjnEXm2nonJyvriWdaq6IwdPlXHo7OMwsihfl+7FHXO8FfxlwFBwyIGmeBnTVWYogOiC2cUov2QFeztmzc2qjfs6XGgrhwyIsSj1Xqo98MYhIOcvT6fzjRLb5TbtqXI2K6115BKEK7MFQwsTNJMBAO/ULDPD5+F/JGEpPOS8xOyE2OAslm319GZRY6l5oGWz2AT1nVsd8/6Vq3H8oatNWrWbnOWwZ6mN/OOlDV6SQ4CZiVSjs/NzywEkqI4Sax31VNHS2RXq06c3ln+wKvdwbKA8QtGNLFVorLVakhocO8KhagQukwx025R1DY0fiDmkaqB8RNoF3CrUm6KsbpEMjbp8kEDaFoowkEWRBCMcKtyshlNEMEBX/WixAuVNAFmlUTbPAxHefdG9c1h52w8LrZUieSuKRpPFnb/NLSXr99Yo9W0xmpl0xOzLpxaDp7/OByKTSaXDrE4K3Z7i9j6ZKPxzKG03F8V/BwbJeYEHGpUFHZwpw8wai4F5Y8JY4fcwuJ2jZh0VKJs49pxlts+Gq+LxhKGKVUdn4tqiINwOCGihs3uWZQXGzagCSpHIEdBiHFipQrwGJmNdet1OlYnkuiIBimRATWVdSmM7ardt/lsa8fTyoXJ+eXBPANyBpU0YxcOAXl1npEtuPtMFRYqWkb5yu5EX4cuzgwRk3oWFc/v2fMb67e7YsOFxbMSxenwYoS/OLYczFb7hU1GIwUPKzCIWawIBT4L8LnSn43Gx9OJihcOecHapMBsUomKW62OC8h3W2dw8gwvDil/YVjPL/d89fxLzTVLJf17uhU+RCVx9IAiQTo3pDkiAyHohngFxIWoOj/I8lmFvEoLHFRHsVB34SZnQuJDWbVyBQo/2BgidaBHswFQ23wiEgiHAWJ2Lq7xjMOeirvuPrZo3GBT7yBiePUt3VxSUpIFFT8w6moJrOo+ncDbzJuPs9T6ta7ey+X5cmgzExXDmeq47IXC5cKUqb7GE/zvsmQoVPhcQECvBwVKs9Y6CsGV+L8RWOFl0aqVlfSgzabJjL3bJvEhk9sMFTwaTsKlx+up/eH3P9nvf/vBJiNIR3XbbXCrOdlkPLLxaGNP7bn1+3P9HL1eX8zUH37xjf3N335vh+PWGJ0xShCsTgdNcgORbsrb5KJwa7ZKhedYsulsbqcivHKH2ICVr67ubDIZ23TKuUCc2dHGk5HtDys7ZHMrFPvWjWpWLtCNnK3ZKdqLNz1pS4HNx4OxnVjgIfmxa8vQzBJSLcox/AHGG5ngZOmjKdoCxhYujVJINxFmMhBxtx3Xg+LKU9M5xtwfCU12Jp/xZJ1qU3NnCv7zId8/RH1hlE9IA90LfrMljBQ8cpDUHUzB6TrhJdAZNqp1dVPySIYQsz3Yxw/31u51dRHBrj6fIa60NOdjz0tyFybSsGJCTqGmOXFSkdHEuw8fxNng0qMo/Pxwb3VCkNFNtlpytkKKx4XLXFnpPhjiMwpg3TnVRfF0yPhK1arcnjab2JoNCGnazWJks/dBbShkmQuybhlzsAcvullIWtVqQ9mUFHpczOh+n8Yz+/w0UKPEhYq8C/QHWPXu5sZWdc7Is8IyyENFQgdJUrGA6c4+fnxvUUzObd1qy4WNFgs/b5QQBcJD57iRKQNnBYVHs1a1YwB0XbZNik48/LoXpaDF1VI09D2WZ/lCgEnmByLSCW9jScegeqB6YnBbldn1lX3z7beSTXwinop0bOYqSB9WKxs+PamlBvbgYX/77VtVf0Hhg1xBoAdzEXK4aijL4DfPsnOHCKr6gh6SuhVlxQGd4q7hYc6e/VhWJ8gF/fg40FwFvBpIGYIKC4ULZZZb3iE4h8HFouOAvJBQ+N8UCkChkAiAwtAbHsOCPbu9UcsPqBBjHC/4CeYcEG1sp8NChvJrDIJjLtdUBB0552iADaOMOBh30mFAvk2ZmXg0kC7J1UZEHhb/rliyh9WTpautNINczN51404US98EoxeXGP/ssS3SjeYkzOKWS1IvfHFxaLPog8JW/osSptdqmhko6JoOgJkI8CBEGVXaJ5GMNDP+4vVK13f8z7rIv7w0xT7OIVkgFmAmmNRAU9C7te4gBgBx4nICzEPOqBLmidQ5WxjnIbmaYTLbc0cn5c3ThUWsFZyZllZrtq3erFhSKqiYYZMgpzicNlpDEpWfoO5DANrYcU/CgBvxw+jlQACiUvw2s94ctmGNcymwbvFaZY1UG2VpX+lCNE9iFp3Pl5Ay8GeA5uVBDGEpDym/uLiI9CRNXZTLaFyXTAXNc9oCowPJyrPU7cgo8BCdn7Od1WvAfA1r1JkrE1mGFhXSDzPCsz09PNlgtLR/+eN7medjPBVC9MiQ/hBWDqyf2s8/PlkY/lEs1+ubtr15e2udbt1a7Yrt9+hNSdnZ6bNzsdAFR/mexn3KyXd0v7CScdSp2WqxsNl0JTiXcwqI99tvX9l8Ude66HYgABVcKzrE3zO2eh39bqjUIM4IkIF2+xsZKDBP5H0juanUye90ZiQHNWMBZn+MBQiaBuVmnc4WKxXbXKIUvYRMg8B8+vROYw4PxmadUjTDkF+rEcCqjy5EkKhYnk7EYR5MQY/VY7qBbJdZWeumoH1KqgUOUvw3ihgKQSFJEMIgcgnWDRUQwJ5ixAQ65yYBJREekdeNB3M922o5sBcvXur8wWycs4U/Pxi6LIKvq2BiqOs4lWEZZ4GNKEbiggff55adsqE7nexpNBKasFyR/2oaS3W6bRGsOE/QBU/a7rVKYYyiFG4Fwy3WJ8+E31xcrF3QJ3TNXLivnz+3SuwSK9YhY6d+oWOTxVxOXIwljuuD5DIwVF/c3liv01PEVnEys/vHB60HeB/nm76C3glMX28wUylYhxEQoxY69pyNy6z13ccPOl9BPfg7Nejs21CXpkYcX9sUXbNETMr5cFgYCSrxw0WQ2AWiy8NMqVphgzFjnM6W9unzvb0svtRs8Kp/ZbNoaqfDTtpBEqyxIKKSocqHTk+36H6CkQ2exnb/+JQbLp+ENSsua+02SRLEHg+qCNV1YKvGQmZhYt5NFe2xBPp8mjWQn0n3A/tMRB6FDvpgO4cJ57OZIBQ2LQe25q9cNLAxo6KtCf1UB1fOmbEc3th7ra3TaluEoxDzEMJFSTRYc/ks7PFpaNP50uOLsGeqVb3wOOx0sFGZXRE9RYTOaSc4hw1N+sRkNBUk9NOPf1LB8OrZK0ui0HqdlqczFEK7uenZ9VVX5gXMT5zq54w/rMnY4M70q+pQPB0pfDwwWI43mj34palFQheOp+J+p1kbm6tMZ4OjCKJkOqyCk7uAnS+yEC60i5vRRQ5yuSxFuhL7MHdNyS9U/h1FAocXno1csYLn8vR5abyUDsJs1eVCLinIDbghuzD3wBj7wOXFRmBmfZZ9YqNFZxk5IxuIs0wAd02sYeaMzCbrpaI1myWxr7mAKHR4L7VGxVI6ljxHSUWBbLMKusCQqwCncplW6p6viQwBwRlzaBFQdLkWbDYj3mohQhQXJx0qbNMLlM/eAb4uYoANo5fDs2AivHAQLlezPFsU4gfvD6nBQkVBs5nomQHyIJnB2xXUJylWBDcOBk/29DixwXBlD/cj19FBwgqRhPifxZuWr4nhAdDiaDSzxXJqlVpoz1933RaugEUfNoNkf7YFrerwESzt5h9cUmhjmXPzM6bp2RaLne23JwuyQIUqn/mv/tUP9uyuo2faalS13z59HKjA2a2ZHUeSaFGAE16Mg1VYwFWLMUssiRXkQDGKYYVjsZY76ZB4woxxt07t4Wloo8lUKS44NkE8urp2Wzx0w1i8MUeEHLdckI27s+UKUgz2m0i46jr4+T6HfJZJZ8azAlanu3Rval+zqwUXw8nKFfxJyfPdy7Rbkgf9PPAi8FOFBFRUcYPcge4XuBm53GQ8t/gZ0P5Gz5MucLwZi8+BKxW8iPGIgGmYvgerMiIIzUaTsbgjXry6cflwTHxZKV/TXpCA1mFiCGr1/sMnFZfEq5WqiYcOVEB4fBZ+d3Ols4Pj5N37jzYaz3WxT2dTG41G9s03NDh+tgJ3MjMcjzM7Hw725sUza1TL6uiApYF7mcOvt1WRcjYLTP/98zw+PGpeDryMqgI0azGdiMxIkXnT71g5fmHv3n3QZUmjskDbrLAKmOiRLkqs++CxeI4wsYNc6pH00xSYjMS+6kVJ9U3FLCsuDLBFzXfBLV2SkhjyxHsqIA45aefoOo5nG4+mNpvPlfTAJYOkoBw3hTfDJuMBQTZhUZdrJVuuJ7ow757zYjx1m4N3s9vlRAuHB7PUdU4c8OhklMYNlHFIc4Yh1nQErbp+5yJm1xBfi8ftjERIElXfZwkXQwAObEF/GQGtZSvUXB/FYa3ZFbAkieKTmf431RBzAeKpCu2mum8gMrwT+frj2VzOEbC0joSXHg923e9pZoCwvxyj4eMlwkjD25WfwzsYNuUucicYXj5Vk7IB8RqVCN/JJu1OW2bkZIICc0jMzAVioZ32Z9ueU9H9ZSZkBUEoMOoC/CSRzEgkzky0qugbKtNmu2n90pWNpmNbLZYesSXZx8nik88mlU7OptNQ3y/Ii/fu5UK82NxdGLCsly9aykJB2ieMr+keJXUh21E+jVh4wQT0v8MM03M1kRT53DrKGXow/05QzPH+VMcJTAk5pqwkFpyWdkfm0cBHifVOdXcokqMSLNSibdOFLvNDipMRnsW5cbf0onl8mMhGXOxuEL3a7rRBRZKIea7MkDztRJtVnqPu0Tp4GuWQpUPemEZActD8kkNYQbt0n5j2u/k7a+lwdIcbsWXVSXpaxXaNDymkjqKVydSU1yojO+QYJ0HwMJJHg7GgPXSPSE+YbbWabRE+lCSi7oAMJmBI1+5iBwZkC3zozjjA3JBWIgW6g9aA7lxMMii4IAvBIEa4f6H4Z+dQkCCmFjwLTMi5tO8fpvby9ZXm5XTtk/FCyAlMWhkfFPBd5aMVbbc+WBwxZ67ackFKRWTdTssGg3ulh8DcBqLeYi+VsVbYB47m4EU6GaEpnmtOShG/3y5VyDLfu7nBGhAoD+9R5Gp7EYGQ+CBxIKoMU4b1xnNb09VG+xThMb6r8/PSgtjJcix7kAS0iVbgog9sMZ1pJuhazsCWU4zKMefAojCWg5Gbr0OGXLgEQwYeQPSYHtBEEFI/s/F8YqPBwK6v+orwgjHqiAFuZWWZ7MscRUiWckic5KfzE0/VidWrS0/MCSO7ucairmCf75+0ZzBdeFa6E/QcFQKdb9hzcsGz/37++b1+w2Blfs67h4xVLj+qOON8FjFNfA60tTPFcMGiJ8AbxALJH50ehLKQoGkCEHKZCAUKmvMe0HRuNEMDxOjn8fHemrWSNJQgQ3Juk4VoIs00JCp+iYiJrjo3PVmlW3sYPGktkzGMVhdew1e9KH1zxl9YURgUi7Goww/YJw8UzVO+qc6Vh6aZg4tQ2VJAC5BSWvWqVZtN0cijiOH+XOxMKiSq5vvHkUUh0gEINLjHJBYvQtJPXadHsods6HB4cT0ezEi+Hi9oMp/ogHSc3jWUOjgj8igPdt4iLyEdHKcUFioGAVSh+mEFtzJIpgqBHctC6HQ7ehZ0AvzmFxUiUC0vUQbC9Avlsg1GQ22GfcrPfdYMtN7uGLpaYmRgn2HNRvgzDK9uq2k3V30rx0Af2G/tJd/g0CYcdzB81OH8/fdvBE0lv/6FDmwuxArdJl6sVQgA7jqxXE6sEFWt1ijJQCAQocKrbFb0cDC2p8exnTOgH+BJd+NA4uNm90ex0ni+VIZ0x7VmXVFD/LyrKdFVXMCB09DZLEriwFQZgwincl9g18uvi+OOF1SeaH/594JNz7jzHHXxN7CcypPJpS/MXTW4OCHTSHpAl4Xfaq2adxZQ+At2JgsRqUuW5rFtmezZgCstOMkTmIuGwwftnfw25Qbj88N+v2nzKcbffD+ccxa2XC+s0krEaA2spFkK4bP7dep2XRhhIAOgiwN2DvKOWbw2j//iOXNB+j4papPTiXFRuvGCp1IIdi363N6N2xG3F/MLkPzBjg5kbPUwDH96HAmCYzZOdX2JyJLO9OwQPvOxDx8+qzPp9zu6EBq4QsUkzlBMRh6eHEU2Hs9sifUcUqwMM2tMTQ86YNhnkrSc0jxLkg7hIL0oexJIOYoOsuqj02deLf3qkb2zsul0Yc16w27oTuLQHp8+aVb79DSwx8cnG4+XVkl6IpjBSVDQwg6mYGTnE7rpolCq9x8e3L3lzNgASBWmrDvhlCtVEFjnJaD7E6MUl6GNLaZbyXxkFs/BH2BmTyGSigSIVIWWqdWs2PVtx8OThY7gc7wT3IgsC8iXi04Wclq3jijwjig2t8dcB87boEbiLDu7YTqf67BjVGFWSXKjiXSvZ8dFhh80Ei0IUW7QgS8tpD8n33g25smW85lGDNh3nqrsvYPtlW4CEoP7lvu4Mk5B+sVykMbRIhtNKEicG7CmKFgupfkGBTlkZ+tfXWl+uF0v7eHhXmhRo9Gy5XxlT08jT0kRY5zZI907Z+7Zbu+unFS5dyN3il4ZEuzQeMPCrqt4Gk8dMpYnbri2LHOGPMUNDmNlAprLdJtLNz4vkCF6sqfhQPNgWNTseQiSa1CX4yUkg3m8F+M8CM53vl9KozUZybgGFBOZoIIzvuZFyUagKudQwvEDw1uYa7CIqKKhO4cnLiPIKXw4IowI6EVqAJXeW97ZdCZXH1g/1SIsPWAbugzmMbkzfLVk3xRfaX6E5yZaIi5GmaJzMO+IeQLyBCYFZsu7V6DMclVaHJ+BuYUUg2WlrEMKCvla69yoAEIaFShXAg+YSiZV+CyxRTrAEe7W6+4bm3s1ctk+v3umA27w9KRIKNIKmOGla8+dUyjsfGrbjc9CwMQb653FZSprjl+iu9wsmZnfXGHsJ1sv5jo0sWNqbGrWbNZEZ4f4wabzC2X/xRSYvE75dmKPx7wHSPB4FAOzEEI177s/IwGnW2CfvUWFo6Adihe0hrhicMdD0lJMDwJ4zYE97QC3Ig50QrU5WOuNlubGx/x98+zd07EqGG53wDTeqd8Xi6jLPPJyeV7MCC5uPTKbV5KKd2ocVBJik6IC1CshPgxnh92pEGUlqK6xKOgTph0dFvCfe/6GFmaEvHZkIaciL2H2y5rMJHPizxNfxGeXni09yH3p9as7WzSdtu/Zee7qwixRNlzMyNnYuWaU56/fAfKhlb4Xa4kCScgHWmSo7wWe5UYzHj2a88m67bZgWsmbdowKfI5JtT2fAQ1pteow1f/iOSoIeWNPj4+229CtmqA/GLx8Xg5woPDFCtYgh6Ez0mVWYO6Qk1TqYrGuVkO9A+DBTrelw/mbb1/a49OT/e73v5fPbKWa2He/eCNnJoKakzKFTlFSExU9Zc/G3GzR02IPhxwr0UELgx3ZFaxWP/BxMqrby1d3dnXdsVanJqbjermz+Xhj6/neFqexBw0b8W17sw2z55P1uy3b28GGo5kKPRyn3v343l6+fWatVk1JPLIYBDE5epLHZr20zSa1xwcvDhdzxhkUqzgA9a1/1ZFJPsSUQuiG2uwxBOvxiVAGOmXnPpQLRLedRKpLorItpuhVsbeEw4AOmbSjs84pZp68I5ALifgzUn/iPxdNqeuClT4CesXssxir66S44OxkXar4XGxsvoZTsNCevLrq6wwAduVdg8SFldjig8f4KdeVwjOKRPihEGc0QyfHxZaZp5Swd6IiEqGFYFI+OxArTGTmm7/77R9ttXB3sZt+TzNxUCW6Pc5P0ENgewVjq3A2peRwA9NNg1o4W5tkpprOMbp0xkk0Qux5DziARBbojJYNZ73pRZrmmXX5Xz884Jns8hgalY8fP9ntzY3iFIMpBupo2z3HVsNvzkVQGe075qek5fDfUxsM2XpEHH7li1JGA2SGBKGMpKk4SvFW5A5Baida7b3V6s0cEnP7J8kQ0AIWzprdcRgzG4Iuv9wktkvJtWsIXqTqUGZcVrB+/9qO+DkeQ9tvxqomuHgFw4awIWOJy7k05cCxQwjspuWctArgZXOS/QMRpIKPpzvCwIjkMMF/kMMLI+p0t3XXnvPessZJYbTkR47HI/etFNY+1tfn37P4OIxZuGhyIHMoxiUCOitYmJRtme61aF0vdrb1YGzXVy4wP+yXqmzUeWheSmc6sW29anelG3sYTmTe0Nt2rN1u2M3tSyuX3JoOMkC1UlTWHNWoV7VnW85mqrCpCEkV2EKCwhmlCKPyaPstrDlS5KmQPXSYbhVIjK5SnaS8dIsO2WUnWfkx4Ec7OiU/UjpZGZTmh7aJUbbcrNSxeyQWsziHdCgGdJHkXaNLI/g3njrP15LuVQyWxC3CmAdT/ODYIoIL804XY9Ph479b2G7dpQgUgEtjD3wfyn+SsSzFAXcYZgvkeF7fdAVL0Y2xJimguHzoNvh0sGD5XBw+dAzAiputB4AzKyzkNmQkycPiwzOVWRgsDghgcnMh+BY7Q80SXVLAn9Haxc849xheLID7YeACIYdWrXEwuWicx4AlHpA/Fy37BBN0/IY5YDHB0BgkicUWZw7FoY1pRyFzWJv1hs2jm4ejxfNnBirzvNaw+XRjf/jjT5ZUKkJxkGCUKy1LypiwL8XYvbu7tldvn9nT+F6aRJjTPMPX37ywsOBuVqxdOkp1yBmSCPS+OA6R33mw1WJt7999VDV/1bvV5SXHnmpRRhy7dOEzyVZFXdFsyiXARZTa54+frX91Y8kutg08mvBsH959sLtnt5IK8KBaLXx9YfIWLDgXbQXMa6ZumU4FS7/ZdKkMRgodRP1JmFizShGPhCl0m8nV0hr1SJfZfu9IEYWLsgxhCmeUpLlWNif5sLZ5n81aU7m6J1zH5kubSA0AdwGNNYU8h39gYZZHuvFsmNVCO+d8Y163g3HPGin5oQ8ZpeJWc5z3eAbPsrOKaNjC/V5dBzxdUZAV7axcVS6e2Mo53QJ7PS58ZsNVElsgQVGwcw4c0MT6egbqZJy102wZIxU5NOv5kXeJSclGzwc9cNla7aYit1brnT0+8bP6jJX1AGGK9ctZCQHw9vpGBET+XavZVEc8X2A8YdJfo/ncL1a63IC+QStYv5whkG7gAiAvYlx30+/bjji+7VqQulnR1htvnprNpoo2OBnJIlbnyCUonWbuL3spyrO5z7C5A3jezCq/6kXphBbYRQ1MGW0y5wY/WoYlFwcMyRelRBsWyIYOg8ObjcoCgXK/w/kjjzlh40rTIp/YkzUabUuKVBx51t1wpXisasU7Ow7uCPEss68yc5rU1mkqc2gqjCNdY+b/RJBPZ1ooZHpBVD1FEtQZGGOoLKN29FE5JEtLf8QLlgGW08M5ZKhkuAyHw4G0ORdNH3Zzg6fH3O+Vww6tDoQixPFFJcQLAoF0QvWIswnVluXsWuz9ypiNu/m6+xe6YDfAsWQ4UQe1WO9tfwpskx7kXHQ8gv07zASsEp5Tq2C+gN/ueiO7JgKqWfDY3WE8f9z6Yb1OmT0CU3FgNuxwQCdIRifzJaKFgEVOIhgBIfNeJOzFquyQ68Gysw0en2T+Xi5VdNFevGLxWKS7IBKN5wr2D0RH8K6cfvJuGDNonr3LduSm6mba/J1GS1U8c0Z0eXiOwqqEmIBsRtArWYO5aQGbimfHJetRRgiXz4L1+NzMlkh9KWKQjTdnjC9wKvbhJemCRAc2JptIBUKxIOifw50LEVcPuiekQlDb+W9caFzy7m7iVSsGNuU6c0Y3zedn4v1D6HBBt3u9zmYzOcQ4UYq9wSW/1rNmPSm3kGIRcs6SQwUPWTyTiwqyVpB26iG11Vrd3r59q66YapwOhW6HIojSns/R7WNdCOHK8sP3bL2kbaNZ06aTkXShwMy9m55gd+DlTbrSn3/z9rX94tc/2ONDTX+31WlaSFdeJJ+V3EmHFZkr4kqEHtey1BMiKI6xBdw6EYaLG6IQLPfrfj83FyclBeYoQeVlOx8qtpr7vAndNuYXnnfqAcbbfWC/+d17u7laWrffFtLCc7y+urGr3pUNhvcyKsCajwsQXgQ2kbLXhEQ097gvTCU4R5IyMzPi04qSeeA6w/EqiS5XLrXbGe9U8i04IzIdsJwVnGUwXpmhUmThhYwee/g4lgl3hXUuky+wKrPtciMjAJ4LM3T4yto3XJSHnaWrnbXlJlPU2fj8+ZW9e//ettu5FSOisIiIg9dRkNyBcRMFwOlIocIM/KDZO6hfv9vUxbdbwyZFU8tPg6zfC0QaBsiYrEnOYs4HCjDpCkuJZr7oZ3lw+hnjspAHyGx4JFfTkl31u9q/kI2QWkCwJGmGTpzPg7IAHkGv21b3yd7nv3OHMFKYL7D1pMiJBNnDuStYVXuG0R55lETo8ec3i6WVw8i+eflaLHz2EDrvbtcNUDivKUSJ8BpxTueesMqvZdIEkVLa1LLbcrLzAozcU7M4+soXZVjQzY1tmtxrGDBD6sBEWu17ZJ1uX4QBHhSrhIoq3SMd2PhvmKnYwxXLee6a+3oBgdXLWKMhuchsOB7rRVPBtVtOldbQWZsmtMOG5HGWn7Ml3ajSyQYkgnDQMsPpd9tK8gBSQUcFRo6VEpc+Z5uTSmAuuv8fFQZzVLoCTAZY+HpIMGbxaQQWZBaZpjYdT/Q8ZC8WETS6kkAWiI2v6a77wGgFDbSpwvTS86RzFqnHG3nVDwzCj5HKJQgXCd4h/qlHQVcwGlv1it3coF1q6FLgVOWihUXHTBDRLt0flxwDc+J66FTJDt0f6ARh2dLR+QYA/sBtlg6LbljzlEIoiBUKumwGy2K/iOXGocZMdnlyEgCFhCe6n9TFsypZtJ4Q4QHLXJYO//m8zmc9kFYiXSYA6xeLQt4ZFlfIYYBbEdQD+ylXklQNKPZ0sJIepR44LcG6Q7rqWCmkCuQIRhaqC6RrdaccNjEXJZCsW/jyM3Nh4Ul5lCMT75pRAR0sgvVKzX1AWV9cgjgQUalzWXkqBHFvvIqz239Rre4Jm22qSyJA263I0LEe9ZtZGoQHDlFMsmEmA49CqEIaA4FGjG0uFs0W+dmBySpah1gJQljhswZWFitW67NYtAPwb27GwBqMcgeXqqwQcSKB5t+Vuf7/7f/6f9fF+Obtt/btD7+wj/cP9vvf/94Oa6Q6ZxUGsM9fPH8togwF5cP9ozVbJbev42KBtY3RdupoDagQnY0HF3OYx7Kvg5dQrpBQ0bFnd9fau2j8NKfVPNvhd8YUdEeNZ30RSYDNuCTH44nZ2TvedP8gFEdz3QKzd/TMXB4ucmeOSbGAByna0M3OBNWOhnOxUJk5U/iUq7E123WxQCt1l2DxXH0miecrzmEU3Eh0uNhCKwbY5VG8eXHNXJLREAWavE3poIqRrTHDr0AuQS/LSGNrVaQiSodDX5iogCdW6uJZDeGLUUqlQadTs96mrbNmt1tprWK2jw0cTlTsXztH6uqY+TLSwoyFC445My5bi3pNTQT2feUksk0RnSTSM5yC3NUKogzdP+d1Ui5av9+2v/6rv7JatWKf3v+sz93ttOzmtmfdq56+B/aInJV04BTfQP68I5ivkC4592bzmdY6yEelWpFLGGML9OSnw1jzTwpomYewT/MUJ8vPxBQTelCpONY4Yp3utG5hibMX8TguV+vWaLZzYimKCU4T/8XZIreknOwmpCrnRcizHBOC9Vqky696UcJ88qRyOi/o9RW1yh5p5ESfRtMZSAiREeYSf0NoarpYiKYsHWNEC1+1MkP6clWdHhflYTzXEJfKkg5nNJ1pgZYrDfeMrdcF5SCqDcLEwnhj8yU2amihXMKw32L0O7Vip2PXPZxHAv0ZXHvkR/oXlmoXKYKaeC5hWSIxo4CYGChMFIKGMhjLbm7OJcGLo4ORYw2wX6lkL+6eWWe7FbVaxBfF8RUM0JHD0l+iMxrpRKiaBFHK3aKsyxcd0V5emzBzfYYBm5VNxXBaDLId3qUwNYtWr5L5RrHBsByLLSLHDtbpdz3m6HhSeCqtFN3iXOYFQKWB0hEgNkDqcIP5QGyxVYbNFAcFlwtSgY1CbG/ublQhM99geO9Cf3hVDoUjiuaiYIHDikQjyqJnFsfzYxOxKD2UeW/lsktsuD48D9N9IilLKICAS4G2Ye9yWOuwIP4M0hFzyr3r/E4kiVBhyyjEL1x1h0RH5bNpDkvmzUBah+M6Zx1Sn9HBRSIFUXwhYPaDaqN17AQtZwt6DBQQPh2sz5W5IP1y5nv4zwO8JylKENl0QpWPeUBNaRqPTx9kbI8eDnIba5GCQHB/fmA0m21drDAoF7OVVUoNMSEhufDfYplNqMRTx7ycQfryDgGoGmcUOvbTCVnDURc0B3Gn3/MMSpibsAT3a2u0m/arv/pOa+Cbb3/QgbNlHFA8a8SwVpGC886dflY6OGKxlO+3Xdh+T75fYilpJCHRVOgp3dIN7Z+kOgpVb0pS0b/q6WelniINR+dDXhBR6OErywy1VoNgwQzY2brB/iiWMHIa5mYI79MDXcXS010Csx//9M6eKgOrN0rW6zfF7u40Oha8KtpktpOT2Gy+UVKFrBkFXRd1PqF3xYGmVMXoey8NJWEICPSr6CCJXqMmB8EBmgzNUmQnjC2mSxUxIACgScMhbmLwIbjWQDfQrwKxnjT3FalL+8THLRS5FC9c2lyqrOviiUYkFXsW+BvyEzM9RgmkpciRBrOCFKh6ZZ8+PwnOLSc1FSrMjxsN2PYkNuF+BKkytTOSpUps/S7ZnsRe4cGNtGgvWR7uVaAGv/6rX9r3v/jG1is8kCPrXbftzcuX1r/pWKNVs8HTRFI9LmmeAUU5M0+sA5Fz/Pz+vXIj2Wf8k0IDeP5iLYnsiDVbAy2EF7B3SPqi4aaBoJA9HVJJQs5ZQ/wD9MgUSYfZ3EaTifYjxVu7VbNuuy73q/F0rgL6Ikej4KLQ4+tzcfN8HLXx/cezR+v5VS9KnENgC17Mw6m6oEtz2PADcVH6YcnF6QkWIbZGCSbidFBFYf1FXEYw0ZVhwMEWSzLmdnqZ610q4S/wEOQdQZlKHnBXe8T7mBeUamfLRhN7GLmmBriQg11zN+nwgF6BJLxN10yvBrvWK8SLCPrCCrzo/i4EE4mlFyt1M7zwfq+vKh7pgLxKQ4fJ+PtQnGFn4m9J1ZRuVnY+EfaLztAt2Jyl6X60QC1f7NwUaJ3xWJ3QQkEleOSk4OXtGfp7qEuRg53PM5sn1unUdLAghaFS9MUVCTqio8iA8USrj+3h44N9fniSDo6vAUMMlwwo6FgLQvoiAQRLBmlU9Vz8AtBcuoBh+0ZFDbNZDj/eGzMI5X5i+JCi96QgQEcKyaZgFcyduQwh62TuuGMrfIIhWqHaclILC9bd/GkbD/kG36lgiuOqumK5KgUUEy7CV6Wo4GS3Q8NpxGWw7kl7cerhouN94hZDZ4bkw+UYEG040E6WlXC/cYkK8ygZkutnZ8N5XJeM3MW7cetCqnS+BjNTyUTkdRmoKy1xYG0O9j/+D38vZ6l268oOx42tNhN78erG+t2eFQQX0REfFGPWrOM3C5EptvVqa6PhTLO6YgGzahyf6IpSjS9wYwGq261W7vmp2Du3LwRxoaB0FOMomQp6TuRKXPzPX75wMwPNzCP74ddv7elhqEDp9WYsUt2zZz0bT4ZyV+LChg16d3fnxulAz6Ff7gjsoyC26Wis9ZQdiWI72WRCXNteGj1gyWMVWJWu3CF8ZklBiEdrUWbWFJq1ZkvfnxlTeNO0z58G9vH+k94thydrjPd1NjrV2ErFioUhNn91fU/YtdvS2qZjs3JSsG0T2LOk7gfPaRi8ICtcThA6Ot2GPX95Z+1e00rVolWbVc1qdcadj7acIRep6H2gi+S9bk90vXARKKbQMp7s/jPaRdZqVTyLKKzJapK1AQllTfDzAVQgsptSVYzYHQc6vAcOdCRPZ5Au/2cYB1ZtkxYEZ2Ft9bgmLS97G8IQzx4d9D5I5U6GFptRTKd3I5b8dvfgpDMQoMxjBbNiprOYWD8KdL5Pt9201cY9scPAE3Eo4l6+fG7Pn9/qDKewevHqhXyKy0nJAyNytOv+caB5L++Boh7dJ2cLFyUcCfYln42L35jjczYTHyZVQWp3N7ciSMFmFT+EkRYa43Kie4IL7OHxUY7T/Fy9djsftXgQBvsA7gMoG/Plf/1f/Y3egUhsOdtVjNe8mOcuYA9DAELBwB7nXuDnh9j5VS/KRrOqhbTZbTSUPwZ7qzZKlq0OFizOVq4CT+HUA1MysONqZxluHDAhydkDnuGWCJjxLV2HSIWR4HYDhr23BXqz01nMunqtZR8/f7Ll6pMeOunvUJ0dKnMZA9WMh6Myf/PEBVntQajIzpotgmljo+S2dYHVcsYll6EiskTDL6prlLAWYgfdBYJvfS8inCDA4L7TVKfHYSm7NajndI47GL9u/wQ9Hes5wzYP4kvOvuVwESssd1JRxUPqQcpawhbO5TX8HyLkAEq7dHx7O6tI4dviFINmkOoTdh5uPokuHC5nIAxBezAPo7Ltj6n9/One/vCHH8U+5HICmrm6OtnV1bV8IU/r1BbrrVe3QEJQuY8Myd0+D8xV7kR7mLZk1vFzevfGZcJClc+tZYKiZatVb2oOJOs3RWkt1HVqLpdfOnT2fA8VQ0otKYoJjIdlxMGQx23RcTPvoFJOjy7e5u+r2EEqQGEA5R027AlmdqwDF3IM8KEs0WATY1jP81J0V2LbzVIHukwAEmdPA+Pxc4ilLP9KF8prNnXwuRQHiHfdOMocv5AFWGN07J+HDxLK/8u//CgZw3hIdmJg1QaQV6xZHaHJOBAFREDBKg5D+zD8aOczMzwi0Zj1FW2zO9pgQNL7QXmaQnRyeRIdsBjbmFZHJcV6cYiy3vl3sI9BF6i+EMS/fPNCa3u1msuMY3/ifSS23a9s8cl9ThuNjv31X/21JUnNfvPPf9CaYX/w/HBUWa3wp02s272yVpuIJG7MhW03RzsdCzYaLezjB2RMidWqTenigOUuhKEQ67UYjTPh7VXPAyR5qIiTSk1+xawLukWKBd6rPFXFYgaBQVe8s2KUWblZ1kW4Ixg5YL/Tye5tOiHBZC/j+1JcESuU9Ykuj0IOd5/r6449e3lrcSVUMgz6WiB2CFQb4pjQVUaJZB9nEBRZDW5tOkUDutIlBeSKRILuuVKrW7nkmkogZOZi+n6aBxJZd7bNPrUXL+7E3oTIgocqhQPnAD9fkiWyqqRAKRRrVm6wx2kCSHshPxeLPe5xMnJDFbacU4w/WINPT49yuEEb6JAwULCrFUB5JIOTWUpJ8qFy4o0Ca4UAhlanZaVK2e4f7l1/qyi7s01mE7fRy466ZLAkrFbrNp8ODM8ARgVA8D/++KN1el0Rx5C+ZfOFBzFTAOb7Hncq0K9bfLSjyH78+WcRJTU3BKXZuqsT5wKknTjEqWgmfgrFGqhHsbS04WRmh6Wnf+DRXa4m9qtf/GAtZHyfH0TyYV9LlTAYaA0B2XLews6+BMVfUou+6kVZKJ4siJVZpUF5tVtWd3IcHKyZ8WLR40ENhwlHdlmil1VNSlaKsJ3aW7FEqC/2cDCpPMdQlP89pJuWoCLYVF0Ja1l81byCgCGKxrJui9VKHY8ir7gU88gXudyHXCQI01kER12GkDU4XHXJYJh9yrMN8y5SMo7c8ghWF/M0Dd35GswuxdL0/DYWITAomjowb9eThYJ2m6266NN0sYOnoSowujpo4lRSigHOqeBsDOaWRSjoZQTODc32YN6qY9L/eWV68bDlsOLnQ1vEJUQnu4Iph2YrYC7o8x506mF4Vif8OFootmw6XanSBJrNzlM7nEKr1InIyuzDw4OYkxCnYCs2cERiAP7FFtBjrMSkVF4oEhxCUEMdpLjCMHyXswizRuVHwlz2io6FyMUFu5lL0RMYclstXDowBsg7Qb6OiD6EMe9TJwWVca3xyC2FAdPxuttbbqgNVu6RVmio+HUJ70ZLrPnlmXfupvKYWGDAAEP6dJklY6AcQXdwRi/PgQKBjg2quxLtce4BJpYUxOOUEPmH4d66vbbVqmQ7ziWp+PHHnxyaPblEhUP76qZhV30M0X02x6VOeK7SE0AUjhQgVfv8aajDmIMZJITP3e+3BGHCWP4zAsKhEttRUW3uv4nloOY0hbMVS0g30JCmgp65ZDkwqdhZj5GkW4G8PGGGHvYrwWrNRmBv33wrmO/DBy5vljIGFJCeqvnM+qRiUESmc2SLJZZtpN8gSwJCJSLraM+eX9nzF31nYWIBmbiPsrN7OcyPVm5U7P7zk/3pX95bISjLjB79Xbvd1feG1MXeFZAVnlVQhXHODubrRgWhNYyGNH6hUztXrBQzAw9ku1Z+nNgy2FtSLojocn3TkbRsn221l7j1giyRIUABCQ2yFCQbMENphSAlrVJbz2Fo7mVqrvWh0GEQCMy7OfsgrFEoIz/jvThbm1EMnIvheGIvXzyz169eyPs2neIYA+rGu/QijXceJmcLS/w8/KbAJ8ILsxDIgUSVFS2K0Qi77nc4Hsq1q93tWLPV1t5Hi00XDgmslFQkFdOBDxOdBCLGNQmITUnuOyAQw9FInSejFS5f1hqs/h0FZlSQ7vXm5s7HWErOYa9FIjjh00vHCVtV5ynxedlWow06uuVioWLSdbtFjWKUESyUze0nxW9Ql4cPc+jnOg2QRnuJvjavA/OTFdyMgwcqfLi/ty4a9BJa6sTi2OFXzgoKZP7J9+M583MCx3Ih4yTkDkFf8aKE0MbLa1brViijTaFyKForrFnrumZxVLLZZG7bXWBJVlQaOsN19GIwoxaTpVh/HIopieR5lBVQHJ1Mq9PXoqJ6Afbkz+JCgQ0RhzQPj4e+3jOXdBcYOgHFFylo2Csu7Ny8ksNVpyIoiyqeOShaI7oJHiadoToe5dr5jJKuAihBwcBcprLCY0GeLFQA9UodHnNIKjG+Lwci8ApD8hcvX9j30TeSnQB/wVwd42ghr9oc6jvx9/JNhW8tMxuIFoeKZYdUFktukQcUjLbIFE0EmaPdazkMgoMMhweXH7IaDIgLiG8dohUciH/s9mQbpbSTsFEQAWFDR7xY2XA612aYLBf6zfPg0oGIwHOi6wiIEJI9oLswiSWaG8LjsIFJfcgiV7oI8iBkNFPNVoGeYZ+ym6TRY+PUkZtwwPpGkigZ55MjnaCnxCsNZu+SGpAI7zr9fSr4F10uHR4aMZ4PhRFCbs0p8d9EtrG1Iwny5PslgW22K6sf+fpMzs5CRZC9cJdXY7cj41C+RPeg9eLiGg9JuWemQrHArJgCo66Ok8+HlRn6zGJEaDMblNzCjvX7M8FzWUa+YtOePe/LG5UCBtTFUWjs5g62g3hy5GeI7P39o/3mn/4gOJFnRLUNpM9sTpxA4rliYOVUpBy6MWb2vHOKNUT4XNoQhUB/OGSB7bKA+KGx9Jly+9GlhZvPVsUKX3+1yOzp8YP99KdH+/abb61Rb9nNDdmJGwtCih0MD4gCK2utwOpmLEIwNLNj+aru0CFnNh6NFQrM8240me9HimhDWrZfY2LAZ/dgZT77z+8+2b/5N//Bmo2+lRIY2TjdeKA1+xEkQ+YiSpqA9Aas6K5L1VJTpgusGcU0VdrW7VGQwCM42bNnV/Y0wlhjK/j47ZuXdnWFccjRjoRe28mWs6Lmfri+VOOSlcKSZnT4L8s4RR2aj3TiiIIbtqeb8KvIytBk+mXH50QCxznDzA+NEiQgfgY+42g8FdmGzrK88xAHFY4ZM8iyHbKN1lftgAF8+Qtipu6QDoi5Oyk5CXm6Zp8/fZaXLDNsZvqyHVxvdO6xztRF8QdFGnK+AzNJNNv1RsV6vWs1Cw9554UhBhZ/PH0uQS6aE05LZdzRgDtRNNBRk8QBHMrEBG0zaj0QtbNHeFWr0lmTOMWlLLiUPZ3yDCjMQd3YDw4Ty60oPGsfc0kyi+ezaqqcj6pYu1zqZWntK7bDH/Z8tNVma4+Dob184baRzEYvDmCcHXSWQLXqvhVfhz69qfnkV78oy82ivP+qxJxE6Cg9VfvF9Z1ddfsaeL//8ZMzntKFDrl2s2v1WtOydCp2IzoYEQpqFXVqaNaWTwNVDsgmlFQuBqMHGgPSUc3wkNLcKYculoUCxMhlzCWxmM3FIAT6BAq96Nw9IdsZs3RwfA0uE2aOQHVAMhA1LkJ4kXvCy0vxS8LZgwdd0nR2vimZozEEDyT1AEe/Jxi40bBnz19oQ13wcqeB49Qz/vKzOKzhjDMlUMh4oapKnYsDU3NZ7MGaddBWm/z29lrpLQUG3wHst8D2m72dCZIN5bCrDna/I6OuYHEh0RwhClceQRQgbXBLtafBQLZl0rXyXYp5PBVQUcyhiBQFlqtHD6mIkMwDBxKcVkh/Z8O5hEO5nGT5wXhGEhGXbBdt1bXR2dNf6iJKnMR0SeSI6z7ovwz7FZqtmTPP/vwFImdxA6nHIq84A5cOW7ONfECPJlbm6HSWbC7DpaWYW7+lQgrcAo+fjyKNudVZRYFM7ZWEA5SZ2OqwtsHT3Hbbkyzs+Ccd3fEBRMONKSAS3X8eySv21asb6/Sb8umF/SpN6p4K2QlqyFu4tJHuhBHPZCsryOUytdl0Z8s5gviJzUYrdQDM/puNrl96SUUQF+uewqpaqesSZ1ZcMHf3QZ8oZjDm1HFLUJoQjSOWkxQn8FEiFQlVIEuZZwB94mWb2XBAdBaFwc5Wi9/Y3bNr5aLi7ATLFcIcBSEza7I+mR/OFhsReLAgc7u6Ze4qA5moIGKMYs7yKCPBkjCSOcROsHhL0uxRGGNrZ+eKBS3cWOr2OB26LaTMuClGII1B5kNjGMhNqVbFsrJuy/nchoOVnhkQdaOFjAHZQWJWiO3utmW1SmSdVste53Nantd8MdFah0uhfXTMrFRn5JHaYrrQwe5HAYUzumts/ohao7ABPi7amTVx3lti/jNqfs57YuQgv106fLMd7P8N6MTeZvOlXfVJ/uioA+bSgF+BnrJCuHQZqU9mWYkZjRPwpBcnqSf35E0qkCerZgUurECzRGcHTwWjw5gWwWg8zQPPiQ/Dh9glPaAOpJPQ7EDOobuiOJOdHC42uOqQinKAIY9xfE1G5oxCwnCVj2HYW0ehMrxbLlXOSIVinB3h4gK8wJv8k+IoKGCFh0SPf8t5SKFLkewqBOe7uOmIApobNf0ZilMliQxHTiAtoTXeqngYjMf27PlLu7qGAAUr3V2RvmTeFhyKvcjUnj17pjHFn37809e9KOvdumyuYMuxmNITLLfU6rWGdZtdZSNyYXiW3FZU+yA4qTJDo9Tvdi3DRqycSEaBPROLSCzUMBSTiYMQyrdfDqZLCNcS2nqcZoLj0dq1mioXaNJZs2bb3coWSDxgjHJwnh2KKV0EpnlQ8l+acasSzLsjdZ9nbJjWOnR3ssY76lCR5ghRelhUxYR7P/+NTe7kH6AEor7orpbqHputrv4unbIbS3t4KS9fUhSgMzbmlkvwbNVKW4dAHNUsiQq2Cte6JLhUgT9ZkJB5elcte/HsWpDnfgXjDxr82WajsSAbIEpsvpYwXtNzLiHB2QOXi73FUK5VNe8Em0xnC0vwUoVGD5uP6VuQB3Kf/dljGE31KEcioJHTSZuNxYsjP/RtCB6n497Oh71l6FIhCQXEsdX1NcfDoTu2kOGYgDCQS4r2E32axz7pXZHoopgpDhvYosSScSBBclJUvOKK6BToMujgZaRfCCSnoBJVnp7ilSiWXCfLoa4792LpVYyskTQU14WMyYsiJyPR9UMiq5YaIuTMJji6nKxWBTUIbDRcKnUGItNyQXLBypIS0Hts4/HQvvvhld3cdgV1wvSkip4yZtjOLIygsrdkBSddGetQSzMSXPnwaWTpFnMO3HcgFzHPKSsd4/nz59bpYEwN7X6qw/vhYSS5D3pijMvR616SVeS7mc/2LpZ4sDPrYU3QPesNMgqi+9lsJZs5vp+kXLujPQ0+6iJ9++1zi5OKtVoNw8BkuZrbKSN8upwfXNsvKffbLebdEz0TGIpAlzx3yDv8JniZ+TO/KFijL1IfyrTYwhDnFqQ0sWZbSr/YwbAFqdjKABzGdxHJTqkopqP8cYuJ3H2QUPSuG3Z107Uq4vhyJBYwl8wvfnitwuJIsU3w8DlwicU5tOlgYdvFQVKpGPLUPrQM6dvK2d+sSS70GK0gRDUuqZguuS1iInO2+wc3b+eXuq3LXuCAZQadE2EIj+ah4BKkUZTQAc5NH/9AEqQgKkrXzTvDLAJnoJJh90I3ApKAswwXLh3kdz98a+ej277NJguNpjK0o8pACDTi4hnLCIO9HSCp8Zg79jffl7EL36/Zblkcu2lEduTcxmAGyz03e7m5vlKTgekCZ6HsCffuC80slMuWX3SauviILGPshUaZlBVYwFxgRfdaZTbNuQiRTcTJzUZHeFJx+WATR552S5mSHAzb1VrfAxMCDG9cGYiWmXvkoEKNAoSGhT8nxn3eALmjmX9WtOZ8DvYVc92velE2b+p6uFEpsLMYZ8SWuGh+s1uoei7VI3v24koXwmy4ooSw/fZg58JJxB90legIcf/fM7jf81KZFTHEBxpgRuTsJCpwMPG727798Q9/1IHbbXVUPRbDjT1/8UKkHnAx4BBo9Wjwep22vXzxSouYLoSHBV4vL1ixUzuCqfge7jLv8UVcmvq9d49SxSKRgk7XowgxLrOinQ7AtnRxjp9TDTJMbrS40Gf26dMn63aZVa71M41JMQ8jDfjZZNoYoiazCF0rWTgDTcZWwRQbUgmmAtWqLi0gGqo+DKQ113F3aM0swSJgn2HLVghwMIFFDCkHer2TrqiCgUATSD4RTjImfJ9FSVcLHKG0bw6EIiYBFf18DOS7V9eCNcis5F1yGeFG0lGMDmkCiXUaDeV6sjAlDC5XrVJrqGMEIrzMKmUvlaY2Gg2tVq/Lw5EDk+eLr2ut7npXdZeYuNN1kO2Hpq7f1bukuIEEQaeRRh4rxWaVmb7E03TVBNBGWmvHI3IavHo5AJxle8hS0fHRgMlWDBkM1oiC64GqEpeo1Cs62Nl8XKisV5kMFCi20FIy+0ZGQ1p9aovlTN/zhx++tyTx+QdkssvPxM9dqUbWiDzoloKOEG4IC9PRkb5KiAKFAMUDnxcWLs4hXLro+zT/Howk7wkDbMOA/9xGsN+7lk4RsoxHjtFNl+xp+GTv3r1Tp3t9faNDj+6EThvSTilhRhfay5cv7fPniU2nPwlS5bVRLAClrlY7u8VJJeGg29kOQwLYuOznlC6R4oZZMDPkrZ0DSHzMvjCoh4ELBA6ygyOVv3MPxGZ9EAfWcalYVNJn4/1e9XuaJzs8VrR1o2J/9etfWSE42P4IMgVE54kkkhWUY7t9dmf9m57FCTM2bDQD2yyxPQO1iey4YTQwk5sMcOoOY/SdiXNxRA5bcZOEw+6o5BBmZhSVpKRUDzAuQSZOVm+aXSObeF37wgadL5YyHsCIIwjqOlfkzIQJhP4J05hxD5IoCpjQGtWq4q5AOyhMG82eCETwD2LsOc+JpRsKc/ysY6sydcln1I0WzHUE9EUbPU3laoSERjCmujmKDxCZrVt6YiiAhjk6KzkHRzXC6JciOZ2tf31lvW5XFweyMMWnhd4JnlmXIeQ871yBziki2Acq+C7Nxw4dciwyFAkhx78IxnASYKJRGUgK4xuMJ1gTjEtw85G8rd2yWrMh4xrp0IFOlxDvgHs9o5ZCj7E5em/nmMCqDcSU5XsQl3hBqfjN2YGBwYUJy/n/29/+1glC5Bl/zYuy0QOactxXyeSWKKuPXMnDloQHJ6tcc1HKOmhs50NBaRVU5vPJQq2utFLVinLGlsu5HhQie+kElTYOVk+XUDVrYm9XVjxLm0W13dvDeGwHNInhS9m3gbWTm3Z909el8PLZc6tV6wqM5pKEJOS0aKCHmj80Lts8QopFzOMD/mSmmV1ozFyEuWQEnB/SjapcfBiVe8jC2JpNJmJCotOj23j/8bOy7oB4LzZtcu7IcxIvXS7djWyoOOXla+puLiUuVQC1ONesMoA+EvmzVEXZqJWVWylrMoutWHI3fipVze0KpS9ayQVpBGwaVavM40p5pFlBF/wZFiLwEIdq7p7Dn+FyQ5qwmi9sxZyGxcZ8Oe/sLhpaBdoejzrUHmp1+3T/2aEYnP+Xc5F+mAWwSIHF0EA6jM6iZ9YSWb3S1OJ2dhwzHb+QMFCAuQokDWTGAJ7Ogk7S0xmAUtxCUZ0mYdSybPN5dczihOXcqOiiOQce9Iy133FJ8sXFY9Kt5jjYgN1JA0k5DFt1Jb0TeIx14/6IDCC0c8FT6iGmoAdmIwJl4wyCxm+5BHUg+aUsz0qhFFvildxfl1g53KZgLDP75FDkfQPPp7u1LnZCktFylmt0boG61X3qzHBsz/AY3accqHutOS4E9H1ApaAbzGQPc+bgZMhu1VkBm3mQPT6wztrmEE63Rx1UV9c9+1d/+0sbjsY2GQGV4yaFOD6yd+8eLIoLdnPdsqx4sv0ZF5jMStXIlunWVlsYqqms6GC3Jiuzdqdut8+AoeElwCx3xu4FiiXRo5QoEVGXJGSzwXD0JXWi3Wnaq7evZFagAms4sMXsWqEAhaihzpb1gIEGa4V5Ll0uHZycdWGaI7NIXc4BCQdP49OJy/4oBisOYnQkIoCIxIVk5WCz8cyGw7GHJcS53nDv2kk3tUfb+mQHTExI1qE7Ilkpn6NK3yxZFHsfaYu71bjpupuXDIcT2623nkCT5effKbWb274l1aKtF1utD9YAqINMA8pFm81HLrer1my7Zh65tZ/efbDlfG2VEtr0ut45F7wi6ZDrUahEHkPGfuTngTS52jwIHuZzEujM6IJ9qoDkkssx1A0f9t4MNGo6b4kG7LSattsxvgKFcrY+8+ZqxccOkDZlpwgRkW5OSIcz0DnnySRNiqGYtCSA4EjEviZekOAF4NsxofKbtcUqpmPbIFuBAEY6VTmyEN0ziomMNJdU81MKVNAs5sA0K5ezu7qo2cPjg/Yu/z//vL+/F/nuq16UYeJODuGJQ8h9PPE35JJU1FEE7b5oQbFg/VuE4olnus02GriS3LBbbOUHiIXaeLpQRQMBAIYjm1V0cRiBnaYG8xB4jvutWu9WrWY/PfzJNiu6zYpNxyNrdtr27ds38jZlAfCSMRMHFqObAbZTzmHueoF7BbNJDveLvygMRuj1VFNUMkAX/BlFteR/l8OdzSTGVnEtZxVBkWxqqqH5Qj8DgDHPAigDobYweiaMsjzzBcZGlvQgO1udjkakO1h3Z4W+lirMKvN/JwiGWSiknb3tNmdrVIsyRFAIc0bqSUmyGeYfs7kHXGPvNJkuBe0p65DChSG5OkYs4ko2X8Z+4ad7i4n0EuQTiaXss93IHgcDW9P9suE3W3XCaztbp17TRtFMMcs0m7y9vtYCVq5cbgRN1QihCep3hk+sChBcdpzAoMoQeQ2ELkJ0i3Q6wK0QXigmHITnWXz+9FGXKCSv2+u+NLxPg6Fy9Mjtk9aM41f1z9lmhcT+vvjcmlnDWhMMEKCgAwc6nKv009wtiANBcxK5TTi5AMPmd4W3Nm9d+5yz5AJ+IRDnTPAZHSVdKJczBc026ts/fS6p06KrXG9g3tERoDc7WfVzYq0NUV9YNXpXSkLG4diwZaNnu2KqfYNcAXkHB8thtrdowbnvxg2wSSEW0amgtspiaKlniw+h1ZZlq57wT0ZTZlZJ+b41CyqB/f2saDYDQiMEALOKkmZe6zU0+cyaraKdCq/spxcHGyZYP4T2c6lu9Qzt38L6nxvWOzSsUKjnpBAQlZOt920hF+mxbsfWtf03dzNr2tp6vZY9f3Uj83HeH3A4BzH7nGIzk0G6Q5Wtdkew9MMjYwTTOOXDh/f23/63/wd1gr//3e8U0jscPdnf/O0P1r/qKxuTbhrINsum2oeT6cza85rVm5gHuN8xhS+cgfFqYbPRUrAk5Kk09d+sTdY7ZDdIXNvVSkQkumoZelNkNDhbKFgpogkSyLTnKbjRFUo+VuISaohjwBel+KOB0diA/XwquTMSsVJxWd0RP3uszprzwX+zvppZU6zs2XRkQVSwWrMmTSwzcGfHwmrf2HA0tcEAg3LQhtTsVLQT7kGcB2tIVigQCHio6cIFQpfONojs8eFJhDJm9ZyfyQbvXcz6G1YIOtaslz1aR5FvByuWcGBy6BQuCAqB3XahQpvmQ7PZKNQ8WaMA/KdxcyPzElb8wnXi7pbjFpY8twt7/YTcjJzV+ULnJ/F+BEiXcQAjSF6o40EFF30BUcjUfYxMYCFDyuQXUY5Avjc3Nx5AD7+mUtZeQo/7cP/g/tI5kvTVdZQcLHL+B+qygo0/j+zpYeD5h+229H3IB3joxVJo/Wdda6ADexiJMCMpQLVqRVzpd0fF2ZAWnp23FhEmIocY3zzMAOVtAaFG4uZMDjc+0zhaqQIVfmKnILPeVe/PtkQ4169XegCCPUcTWdFR3TAvhLiCEwUvEGyc6kdmuqQmtDuC+xBBU0EJGiUfTRRp0hJKol9j3cSCkPk6hypelzv0n5BeQGKIvuJQAxpyJi0vly5OvqR2tla9ppa/Vq55TmGeK8hnowABmpGRAswviDzAgEVmfy4q9+mDG39z+CgLcUWoMnaBqc0XBLzurNZouUt/dPL8SS78Mi4gmMGXZXTO8+Iz8TnoNrks+azVsuutlk9PuhCXEBvQqUKE+HQvRiCXJZ+L24Ju8KqH8XhsozHZpFSbhPqWVTVCnNmiGxOzDkMFl5J4bihMVQ/gjvMOkU6BQ4p/x3NBr4lt1bnT0dcrVzp6blkQ2kZQ2lEzSmaGVJiPVrb/PvpbM0YQ/2VjiP8P1WHXrPv/5b954tp//muV/9av3n/630DN3RXxP/9Vzn/zK/vLr/FfuHP5O7hx/Zc5cuW/qn/+QSb5v6r8V2av/xd/zEM8zN7///hSbNTY7P/83b39dWUuoglpKHTJQLPMoCikgaI53Les1y0FwN5ubr+x77//zkaTudiUzMWwrHv/7p394ofvLA4DBRPf3HQtKYPynO3582cKh4d1+3A/0Nx4lbM90XhConNzi1AzdoIWMNKGbMR4gssFuz2KLOaiFC0pZA+xx8sW4+5yDqyusOaWPTw92ufPZDXGVm8mtt5ubTyZ22rrF2VxA2R/1r5GxiFyIWSZBDN8914dDIY6e3D5Yu7Jn6HjkUkLOugDfrTIJoCSS5qLIzUhcut4vrfb1bW9fHPrfsOCxl1zSoYlczpkIfjsYtzPeIEZr3gftbK1e23NuykaZjPczEq2P8zMCgcZnXORMI5aLWfOPBXZ0HVYESS6Im5TE8200VJSsIJoAJ3XAoxnnDhJmkcym3lkHXKwpPjFnIULk656JRKZEySvej0RMCejoQpn/v09mlB4LoRLV6vywOVc4iygScI7e8N5dXE7E/PfXb/47Jx90tTTlNCpp6lSdTjzjkR9UbBQSRaYoX/l9JDzriCj6/1qa08fHu39v7xXJUnHUPqmalE78exJuh94lEAwFSyQWrbbbGw9A8IDItmK4YoUrd2piCCQIX6mQwXYlhwC4fDUOk0fNnPrkICBt1/v+s5qYNDZUUG5xcXKrq/KqpA15N2j0yLCCgwbw2kPaJUkQYG2PiMg6SGq1zTT7LTbLnSeEu0DQcJzNnmWdFOym9rs7HEwyhmTBEsvLVPXw/yRS9A1UXxeNiPfs1oBly/JiF1hv4VAnrZ9vBhLiQUYpov6764vdDqadWADSDVYreg3FxVQLtU5jLTzyWNsuCzpECAM0eHK/ECelG66zGLXjECBqMxkSIGIVL3jVpNsoerHdhgM7WCYjVtuMIzvrlmz07LRfG572IzbnYzReRpovbiwMVA+n3x+61lwe9tvVjI4pt3Z5TIajIeRKtDxz0U8OSoce7HF//fkbEIuRAn6Dxad2RCxNJ0UMZDEMHdm7uIQy1JQbL/X1fzlXEBrC4v0YKWErDuH1P/XX////4U9Ya2GLzPzKYgwHnumeToHmXG4VWyy28iC7bAnDq4iL9FWs6a0igo2leezDR+G9usfvre/+7u/tsVibAes+bKlhaW62KEwiiEfkQmqOD8xnpkbOyEQ2A4m6Wq+0mEKCQUt43SyVDcqpraV1Flh2AExjU2g1JWzKby40enZbL2yd5/vbTKeiVwX6JI5yY+Z8+VI1iIxdIQY73BncqmIAr1zrW8lNwuRU5d0wThCYRTBrDm2yQSf1FQBCNPFVjII5CVILaQDt4INn6aCXV9/8yonoblciq/HPzmDgNkzzSMPuoCBVns3d3Z107d+v6uZ8/09FzbSHQhRFZ2BHCYUo4vFTGQXzhWaGyD6Jhm/ezSeK8UplhKzdrevrtgCPKGRqvg7AE0hV5czm58Jngf7101AAqFSNBKMFJq1us4sXWqgS3wGdPOrhY3mHnZBUQM37NntrbyO4whHII805OATKiRUxy/L+HSWexvPhoIc9i/nLDFotaRi37x6KROC8HJ2tlpf96J898dHa9cbdlhv7eOfHmw7TUUZDnahTR7mtpiuLUgy6z/vWRD7gF0JF9WSLJNiS6xcyGR9RRqEfGBHI+v2KjJmhm4uoI0E+JQE+KE1SRpvtyRfoGsqlip23uxsTXfJ/wGRDsfqaoE9mMetdtigQbpIrEAOWqXsEJUIOk7c4RwHAlrN57o8mXGKALE/KNKmfqiKhEOXy7AYbSMvBh0lh710nDI2OH+Zifl8zG3VcO0AGlVyORFHaKkUqVRRdyizdqosSATE3hwzsUIhCjA/kQ6oGGoGohy3hMxNd2KhE0YkTefKZeUGznKRtCIEhj3ykI1ttnTtQIqxChf+HppEumONtHONFFWkiE6NuqrGorxSI8Gj7ANmF8rtxDAduGSzsQIvEd0qVWeeJ4ndFO8ccTVwGSQhbizcllZivMJI9WQNYGCueZ4pEApdN3+H6pvOWkHgeDxdjCWiiu2hr+daye16Z+fT1BM9ymW76rY0V2Fe4e4rXgFffv13b9/bL6r4D7sbEoHd79/f67mhs2u1axYVeX7+c6/mFAUV26xg8s0ky3Bfyq1mgKw1CqDt7mT/9Jt/sf/4H39nwwFSBve4RcLw+s21/eKXr2XAARMUyIvDCamGu/mAHDjZg8LODwpitNC/YSBxtpvba0HMFFowqrdrrNOgz8W2XufG8Me9YN5mq2LNdlXw2C5d60AHOYMqD2QFyxTkhyLn8RHrtVSM6G7XWYyL9cyKinFjrpmqs5mgPySH8KZrf/2vvrNifJIuko6G9cY7Zpb3/tyz/8s/3+pZH0/MCnMbsdNBc2p3QTmrkKHuBSkA2qWYKyWRLVfuwvPs7kZrm8JQs8dDaoPBg11fN+312+e22c2t2cF7uarZLFrj6WxuH95/ckgwCUUepFsN8G6FxYsMZ72z8XBhg8FMs3tQFwov9nWtjsOPr8XzmVFAJMKY4uH4+gvXQT88Dp2hi9wH6YSKY4cDVbEGzDFd04eTFDyJRh3bSw998FkpDNSDZuK4zcTtpmDBNA3txLrm7FDHs7J4tpJesNNtyvUMkozQlkJsB+zjZJtXVbEOoxjNKg0GzGeMzVkXjBoa7bp998M3Vq1XtLbfv38vYhmwssxBJHU6eJZsUrH304/q0NmnQOLtFgUqGmAi+dwZC69fzrp6s2kNdPF8ZhlsnGw+nVkxSYRIFTDJEInJ4xb57+pwGS9Uy/bixQt1eVzMMjWRnzNQL1rUrVyPsjiwdUqDdZRxDUUHe4XimtzJYhbrnNluFfmicZgYvZD/djtbAL9zEYNWFQp23etbO3dYAwm4QLZf7aL89//ut9ao1KwWJ7YarizA9SE7qepZL3aWrTI7BHv7eP/Zrp/37Lvv3jqLMCrb3fVzu98Nbf40FOssKoX25s1La3bK1u7X7Zf/6gdbrzNp0gYPzClcbMrMjcR2fhT8BDf4+zHPhF7OgYtB8f6oeQFd0I5MuyUyD9cKcSMS5Ez1RodEq8+FJr/OXaqXo1T0AGKGW9hVAj98MTuYzRc2w2rqyALHS3GrA5/fYNxcwO547/MtSXmpbuSAT1IEgm1ih7Zirp0tsSjFVxNIBAimYmkxtQiiAHOvHRv4ZLvDyRhtU8G1GlVrNtqWnqnO3UxA0Iy0Ru4zSlSTi3SdSMABJreQ1drCaJ8z4HAwolrGlmru7Da+H2zWglmj1dR8FK0hCemuhdvrsmYxS5MEtZvcucgvQu9cHW5mFlqmQkNXKq9YHntgvVbbCsuF0Sue6g3bEozMgB9jaYb8JNKrcOGgcVmHGLNHunK6x7ae0xl7MNyWlh6VhGUbECyXer1a14WHvRmXBnrfyblulo8fStnWKqe15C8R8O9xb6UDgdp7C1Z4fUZWBiLH5YjZlh0tOKU2mYxsM8TtpmjpFAr61u73Gw+LhvxVbdjw3b0dp1PrEjuGg8/5bAg8mMmunx6tWoksPO1k/cZowI5rEaMUOkL4cUzCg1fGQjBIecHoHsPwotlxN7c6rN5WyeZBpgSM0WBuQRBbHWZ3u6LDvlItSsJRCPd2U+dyKtpUvqtLW04WdjyHVohDq8FgTHGY2Yi1XA+OtkcWVCzIWJ01d5itrJQFdl0pqTDAS3c/GVi9V7Eq8zfDJrJg+8XA6na0ioKk/BeXBMHgFJC1Rk3kFi5JYDQfJ3jqPTKIShkjg4aKZIsye/niRkHHhAhDrKNYKdcgUO1tueYZAvFVFbwMkeR4mNmP//KzBxEjeRpP7arX0WHOJT8aPOmyxMsURiixWzItzzV+zBVlaxASPQdZBg2h7ykuUztFIuYRsUfBDOKCXARizmV8gVepF8sYerhmm3k0CBUXJYXuaj21z58/2Xi28uguBRyfdaFxiawobNFTkuGLrVzq5wZnQrVWESFNLj9i5fOO6IhP1u91ZGYRkHQTFO1EtF4htFanYlf91/ocWFNCHGNASBDC4Albz5UcpZjF872Gg5F3lwz/kM7kEXGa2e64wBj/VEXw2u794tsOBrbBPxeNp+DNgwxIuAzFfC9BQnJOAQcMs0eeiT4H+uUgk/0c5B2K127/Wp7hXJq4i1VwZTu57pFzazybWxLGHhZRdIcf5DqrzUAEIy5mjaRy5zXOQfFeKAQwW1A0WcHqfZCLpgqWyXSu8/CrXpQffhpaUpxZC19DZlr4tVbP9qLectPsZkXRKYPJve2XB9uvkS0UPadttLDf/ONv7f/5//gPkiC8entrr99e2//x//S/98smCG0y2tpvfvOT/f1/+K0tqPrWO1ss10q9KCdFaZUehyNbbhGs+kEFzdk1i3RlXEwn4fm4/ENTh2rOYUz3oipEaeEQbmAmgqHDHgXTPtgx8gcGDNCME3vz+o3ILFTt22gvCQvwoESxTPUVOwXE52nzXFp0CgqxttAdaGysrk/uMdCl2UBUR1DkI6ziPHGDl6XQ52LJCkW+luPox+NO9nKdXs0arbq1m4SZoqhylwp1t3lXF5WKFmyQnwPpVC1l3kEK+dGrf2BvSEB0slTjEHkU8SPYN7PCdqOLD6gHZxtyJJkN4nfK5ker2KwSajwX4QdCBSxYqNsKRlX8mA/rSyEz040KCAqpbrtj56hgxcVMhIud0nQ80BZkgCzLzZ6ZkZMZlGWXJNrgdESwbPncvhkQq3OpAFmTzrC35OAsyUJU00ZkTllO4y8XJReQdJXIHs6Io4+avwZnoD+PjOPgZ2zA4QAzG3MLLN3cecZJJxgXrNYLHdjShHaQDDD/3rutWAghyp8/fweIb7sK5GxDaoc+F5dTDZYn4cpb2T0CS7G+5D1Mbl6FP4MRw9nSJchAoi45DN0WcjQaewZkDDu6alGR9eDjBaA5CBlcRkBeqheVGsMB7cb3FLDonym2YBYCp9GJQLTbLJgdsvZcgqS81bLlxR4VvQvFgVWZQ3Gxkwl7+eUUfCB/nw8i0+Cf2N+BwM5nSzE6gWCZV7oBB+8GV5tQOtR6raQ5XrfXsKvrln4+3FxW24XVmQdGEJEg57m7EajHerlUQQWBg24dFZXMNdYb261Nszw8o7koIYAhUaop5ADYkDSespUIOIeIJrZ7pAsCW0D3DmUfuYUiFpZcqEipsnZbpBOKbpilnG+yfiO+iQO8Wvl/0/bnsZbnaZof9Jx93+8ecWPJPbOqq6u7Z6ZpezaNBRJGwzCMbMZgY/9h+AOQWG0JJAtLYEAIhFgkY5lNAiSwEAgZGQzYlj3j7umZ6a7qriWrco317mfff2dDn+c9NyK7Z0b0H+Hbiq7MjIh7z/md7/K+z/ssIvoPezj25L1shDEDJD90zaA8oDu+8DkTkkXsDRdOoW3mvMNEfNDtmb062U5UrlX14QePddRuhhUknzMm+WtUBxzuGT1/ceWCr9Vu2xz+7ha5WpinOKqP8fN84QsV8h3vq9M+iJi9dHjoJnTQQJpliF2QFWlUCE4Olx7GH7xOxjMhA1trnsd5JwpwJDMhvwuCIt8bwk9uMPLmPDt94LFa1VJBkqBKUn/gn200YrvVbe8uElmU8jl+UI1kEH6P7+cIP3KE1zBg45lCVHS+q9m/SJ2iWLvX1AORN5r1d3tR9rszlQtF5XcltTpN7bIrdzZsMFKrSezGkaRODE4y090FtlFbpbYp3V139Yc/+kMNu8NwfsnC6HrivEH0Qgyj8+WdKjXcLNY+1JnhYWoMK/W2P9DV3a3u+n13W3yA1TJstVxEVNlCiezAqrVvoSVkJgcMy8HHzAEYs+CN76RyFqBnd2m75nAB+tjeM9MePmpYkBs6P9r7kBLcmxVQrTCstgsTdm++j4JF6YQNSyDCn5WKpszsgE5jDzs6vHW3MaHGIuUtvrMYqGM7FjmUtFrA0ByCh8cnatar6t5euQpMLXGUgbkbhYZFmVzITBHTSAXqms5g4uI3yXW098bExYa0+2VVG2ATB77ycxLd9XuGnDjEyeLkQiIWLXIly2YUc9Dn05CIStrgTkSu22SiZD735RPEpOgynQsJF4R5aKXk782cm3k0l3aGxc1sFHgbiCQddmFpJ38g1M7aWmy7myk1nmhdq/tnOKvSvrNzB8kC8QE9AQnyvDggvwuoBPTDDIVNH4nrVPvAMZChTDeHxUm4NWbSm/T+IB7r9o7E+7A25LMtVRqq1ht7s3eIVMgHOOSpXoPJazcoZtcpUjMKduTBtAJ4mZk+7jHAjVOt3fGtkvmby4VbzNpaSCg2zq84NgnoKp2eRmaooN2T1MKlBVQVxWM4SWU0GUPrh+Sw8kyIgge9J+QLyCTNOnMZ41QaUsX3Ri7SavWtpRGYLgQTmDVPMbdVpZLea02xWCRzdmntKq+isH5LiIBJm24jE6j7eXEpw2L0BQ2ru1DUIhNh7RQ/pHsEXE03s9bhQVOtZs05kUDidMkEW1dq6FWRWkxtn7jJQwZLq9NmzYF6ZHXQASoM8wk6PtJuLjfXGux9SN08eKOyP1caDCeWYSF7sJyLIjeD1WHeiURYw83GyDqiY2Y/+9kv5hqPQoNM0ZPN7DTow8LlwqBMxkcWg/qRUQ72N+WDn9/eUIP1w7rnNKAQxQBD1JYOfg1UylK8PfmNi5oLBwckUoJqTWK1JhEB+PDYxTvSJiL2kjkyImDhRNdXly6wKOIuX13beIGzhzEO6BB71F3vZGKNLpB9ZOwW9sUSLPEgDnGp8fK4LIHgKTiY1YLqQQZk3/mMpICGXMnjHsNKA9pmmEITEYx93qV/7myuZ/YU3vo5W6pDwQ6btlIzm5zzdoK2ExkXvAurKCgIm86wBZK2DGeFGUbWxQcFDoxiD6XMN8HKcqrxJK8cCTa2KE2rXWm924tyeDfWIr9UdpvSGaLQOjfx1mJ1DmzYk8+/fa56vawKpuj9qbVGdAe2tRqPg0UF1DAa2SSXRZgr1W2NRayN08CTuaYTBvp1dY4fuOodMsPYLxzo8SSUUDVmQTJKRSUEpU7JPqyFa8okkjBgr97riXjYzspEwgJ8hLG3/UbT7lwRBCOdQABOtQNFnA+LhejsQAguTi9ApgFFPAT/bu5ieBZWTnRnTr/YKu00j3Aw4gJjoyhV1tx4fKJKkQSMtS/L9RrYL7Rr4SKBlRrG4UVTw3mmuULElgElsSgyq5zDiTmsIQbA6l1t5l5c5HjS1VlcjTDfrjl2WvfP5LVwsJbK4SLEjI/XlIL5Z8F7CO+p4BjoO/EE0+NqVVs8K+/ubPDAM1rai5GMxPxeu2UlW9R/QNKbjatwPBJYD5hOAO1YD4neMYUXTdDAMHq2NjCDuxK075j78tL7o1FYH5ZLnjPSJZUr5OgRc7UO2j2+t478ekvmYZOPU3Pn11kaxByUTr+EFKPizWVLQl9wXHy8Hzties2Qj+oM1SJQZMX/DCGK+dsQT00Ezyu0cpMwVU+vfRFj99ZqkMdXMezjg8mEk8SXs4mi+egSgRKJrTKpYpzo5mroQpSLl4xHbAqZPQJlEdeFbo4CjAaOgpGgXliFNi3I4F/Ma0VTx/ude0aJZpOuoVFpmEbPnsQhihkdr38yGlrbtsjsXBQBYTusOBem+/xsniv5kZUS/sQ4nURxeP9FV3F3t3jjimKp0d7dhcvSZgNYvxHizsWUgnDHoco/B9Pc1mo4b1FC45maKSlbCPMNxgkJM7wCCFFWs91KjXrkolpiscY/NjTMFHdHB0e6vRxFKg0mItb0RWgA+5C9wmUHn4KHCWRXrdU1AUni4AZKznJYgzqEbzEXMT+LuDOkbtVSy2xwIE2KXXSdZMHmmOWauc4XLEt+j30dc320n8DfXh+9geeK/ByKLpvlR3xKkGBWK9WqNc3mio4Wr9sixWQ61hZrOgOpBQbt0qQe/he7UBJpioxfgq1n3kQYYVBkYUzBhcnZtlYGx6C9LGa75fKTYdUZSNoOjgJhBSQ+oSIYBqlpn7lrI3I/33DTchzbPonE5+Eb/1W+V8iLYB4zj+TZwU41ObSYd0eNOoB92luGdj1IYXSOkCgpeCKdCaMCLkunM+29vilE8H1Fs207UUiFvgdiDsrZHxyBd+z1msDqGo00uL3QYnir95+eezYyGHd1cHSo3S4E6PVK2Vg1EMCj0wdqtzseuH/43lN9vXql4XCgMqbIEFYg7gzmyhZxQBmpd3NrHVNqb9zLzIiNCPMzsGouSw5CWay7XSxUQFOYSevm4lr1Jlj0zi7yo3EkYoTdHOyQnS8tvofNBZi3Vsvu/CbJ1C4xHEqFasSvEF6LMw2VKdVizCTiz9u5whVy4K9UfZ5s2aUCuIpukdCBsBBztJgzLsMSiwvXvosnhLlGt0e9FUJdugwYwitfip1OU+123YbBwK54PNJBcYDbds42WWnDMDAlFstLda97LhRYHMzw0umVD7nZcu5OkYvKVTyEor2vbaEUbhZ0grBZgXV538BRBFhHp7hzIPGw3w3GbR7ze6CVoipm+sWFQ+UIOYgig03AjAem6xJLq/07BnJ250e2J4b0UMchIJhwzDONdA8fEsRG5dCxAS+Sv3eo1rat+XRkyArdHMJm5jmOXErvDMm/+dqFIDq1C59abzAcGJjPJUAx8RzxRqU7T6cjl5NkdpIKZpd3kYJCkYD5e5IYSm22Wnr1+rVJQrgCFYqm2ypJqFxZawu1miUdHNV9wRZLac0XUSSy9nhNnpPueAYV2z4S3cSMjgOMuRVC/4fnx+p0GnHZbLA+wwmqqM0ay7owzObCeZOokc+HBGffxSEJ4LnQjfAz6QgJhsYXlIuPCxV2Me8r36jZ6/Ts7EAnJ8c+7A8OKUCJdkp0e/vaBzOdMkUFBYr1tG++0mbDw9y26XwFAhs2isB2iYk1ZFHuEO6PkYxESDPOQxEdB6O5o/WqoPlyEh1PAWZ1xtmr7EEC3Km5MTVwsUVXmydubhrRcOIgLLgQgeDCZ9U+wOOYS3loJIQHxaXMLP7y+lqzOSYIuNaULdxn39hRC9MG0lDWkTph/R1JFDC5syAmAeFhikGRPdzbIt6HwZuVmQot3y6dcaBCmKlTWE3VqpE5WXVXSxcU444g5zFv9CHNvlpi6l20zGE6G9nQns6WzxqmKR2dwwlg33vUEN68JB7BnoT4hOb8+ORUI8hN/YG1mCAH/EJa5og9hxIkPu/uDcU36L7FGvdA18/FWZjbQMfoMLl4saQLJI083ti3nGMm+fl5gpSFdSesdMiT9xaLrD2QMngW6wRCGHB9hLvfh1xELFj4M3MxUuCCVoEMjfeciyDNQURqqt1s2S7SIQnJwiiFCzDrS3l/Wz17/vzdXpSbxcSLEE/F2SKvDz/5867q+sO+1qmVB8vtRsui8rvrK3u0YkrMAYa26KOPPvAmqVYyOjhqO6z48vmVNTxHZ1VtqWy3OVVyJaUb+BDWHdeDKTC9P92LwxdggjJwx94sWxQuS2mgxdVaCzIXqdCtnwp8m4cfVSpVZ7xdhviegS2BRSCtLKNiIf+RyyKf02AMfo69VkUTs2Lx/ASGzOryMmrEqGLDjQOHD5hhdMDW9+FHWkb/SPoGXVIEtXp26XiaSL/lfVX39OvtNjYZHQQCeNiuFRIIuEZ3QMgxlywftFVHp+Qqz1HPnldF91lWdTrXzc214TkbKRep0nLqDu/sFWpXIfRqFB97QwU6Ejxc6TiYj81m0MzJf5LnI5gKUCCgpcJ5h8qbZ2zvRmDIKkkvK5OjqFj52AaTscldwCYcFvjA8owpLKj4mK2SDgPhwveZYZIwYA/zcFiY0bF7Fgv0YxgHK7CMO4I0LiMTWKUlFWekYaBjY+O/PbzzBbIPIWHEZwD7FCizUgnLtM0uorWcUkLOH8kGAm4seWPxvwcHR/493JGA6ewrm0s76BaoutftRoKJB9f38hTeJ3FdC213JLuw+Ut7yzeg2TgE4JehS/7pT35huJfL4OCgYzcWnFqKeSKsJh5ZAO+WS3FIUy3T7TBvZBVwcIaQe2molQ4K6B0CyHI5NlMXA/RsihGDLMPwoZ7OqtOqu2PFuu39Jw/UPmzr4LDuhAq0dhngwW1azRoMY0hGG62EWQga17fHCNBhGZchUhnwLp7M7HdL0YQIHASCoo1D3Z0DM90Sco60P59udxTIz5o1yZ/jQCxoNpqovxyHuB1SXCZ0dcVCuIJxsMKWckEpZGsR7QREV6wU1WqhsQ5D8vUu5sms3XCPQWcZl0yq3VEhF6kdICQOjN4bjrDXbX0JYrEjiH2rRrW6HxPFeKJGMUAX4/UO65jwd4raGFfYJQx+wHSiCX7FZ8cuPB6cnhixefHylXXlNvmnAMVQHnNwh7enDVdm7HdMhNREV68vvWf5PaoHW2UahQnSCyz7xXSl3WYdgQqZrJ6/vjBRz+99ySXIecRZFiREXnxomjMBaa6RYOGHjBF50esfKBio2fw0iHcJKEbFrxepG3uCAidQqWh8zD3IZWwas9qkLQ1BkhMjOn4uem+i59C3VtVkBmxzdPSYQdAEekcPi6EMvyqVIz8fx3mhP1+tVK81bCPK+wWOn0LGstUqGluC68lSZQyz8NnxTi/KZDlTq13Vw/NHOjxqqn3U0Nn5iV5evvLmSOdS6vZutJwsdHx07FvehwKhrJWi3v/4qUXIQJoMuqlkP//J5+4a/vxf+Ev2By3nynry4LGrG+aeHDDMNCAFPTg5MisLNxb8N4ESjjptQ0TMdGwyANSKHtEeg+EJyANE6Mych8UEq4rKk0p3uyV1HXZlhD5T7eHwQpXD5kAOErOE6By5VKngIw0h2KueSUJIyISw9t4HltkXf445ZJADQu9E+c98jbkouiZMfIFJGOTn82TvcbACwWDPFVZ+DO9ZgAWio+yfy8EbcVxcjMxe6AxJVydVAXr7ZkOFHv65lh0sme/ggMR/czy0Kz9YrTB8OVTqECgePAjbuQGp6iRmxKXIoc5shM3l4NN9rqRTP97MZtFwIi/J2U8WeI95AZ8xM1A2LhcoFyv6VJ6pfSMpBfw9uGbi8ncRQPQOV4+jeOLnujtnUL9KLGYH+sJkOar/yA7l+d7dcVDH2gWSzapokwrga0gfa4gqzH1KpooGDIPmNtlYPoFjDoJ20Ix1OzI1eZ7kjp4+ODa0SqHIM4O92GpVfYBa1sBcCjKTiI+rOo6L9+W5iSOXytYMrxCUT1Z6+eJaX37xUt989dzP4Pj4TCcnFYdg1+t5Bz0XiuR0zsxwDghyHAcRdH0Ly0OPS3eHZsym6JAq5nPNFhPlMrBja+6uCcOlm9nt//nBg1Ozy6dztL7yBb1ZzzQahYwLkf9gsKBHMLQMFA7ZjjVg7+LvSFYpBkzeKZScnUi3yqGPv+YXX3yhahn3gigogA4h+7GAsdij81kt+fzWtpJbJVQeU7N8b25vPLKh2MVv+PHjx579Xl32jWA9fe+RymWKSxAUKVkRoRWza4pSPHDJ4qSYpDOGKELRxCG/onBgD8FSr0aWIZefg+SZqxchls3VH0QHTtFMhBrd9KLGods2CsOlEEYe2EiGow0JKvx3zrSdIegg3+G2RQfqOZpDHTYuUPE/tfbZiTYN55AC2dOBrjYUmuyjrM+4e7G8oczt2pehCxFkdCT4FCtm7mKmz9wd0tFtl0ScWfA3ljFbBOKH7EbXx2dK8XKfjQuMX8DjmzzTGeYKkUoSnWxJ/UEkvHAx41R0dnZqkwC0qZAmcyRFpaRWo+mzlSLisN3SYDgwmpDerpVLb5RLh48yzHmaB4IgKiUM8vm7GLgkmmzWKuUDKeCM5iKsYd7ATNm617WmnDeblc95s4u5jFnPvlijueDMoRhGJvPOnXmYu6w2eFyShl1V+7ihWqeq4/RBHGTLjV4PXnnOwdwDdwq6qDzRXK2q/txf+C2dPDzSzdWVXn773JAIlyBWSn/we3+gDz78WKn11hvWCRS5W1diYNCeG+xNrLFfY+aEeThDfQe0ZiJ1ZIoYHfcdLmInf0C0AR/fZ/hl6SyRSgTV3yQUIAtaegx0YR0O+n6ItjnCdgsK+d5/0qxE7b0hiyV/COD6HN5cJMB9+TKdRmwIukKgXy/AfZoJi9AXazZriIqDecvFSJRUuWTIwB3kNjHT8fC46ffJRY7DCA5FYB5c2oslnexaeTwaCyVfMBwIiPV9ONONbTN7w/CUrQDpGu8vVmYELHp8WXlYpUOcO1K6eP1KVxcXft/MupjfsmmcRu5ZBPBMCLS5yLikTCYxoYTNHGbSkHE4jNnIHuiTVgLJHEQgFXMNngu/GyHRIciOize6cjaFNaNoPC2uNk/W1TxVJpcVnQezDapi8v4urq50NylKIe0zuetq3tPLly90eNTyM+ZQZSbmynoF0QKSAizJuZZzzPCjsEFKwuyc6pr4p7Ozjk3W15ulhn1E8z2nsQOt1ut40kJiWWk6mrjLazcahnk54GAWTudb5Yt52xdycf/yy2f66otnceAvIzOVTpA4O94bHXqhtFOn1oL2oSQJQ3uq/3tW5243C2mD/UWZA8Y8fzgZap7M1GzVlUOEzzPfSePZSFd311pOQ4ZwdnzsQ8Uzjd1avbtryyMOT46UytS0ppNsVn3wcrHMZlxiwYTsYvKxe2tT9HZcmTKiBHTJjP2+SMW5y7FrnmPJLGF7qfK5rwNC1ZbgAXJpZw4eR8oE6YNuGKZaPocJ/1JHR81wgAFRSmW95plrp3aQ9xIHH7MuYRb3ulE8UlzQJTJ3tvPVPtpJW2Z9zAVNyQ4hPl1IKebpUxx4ltGxcxAXrYWtRje2j82Lg5h7NFIqoHDyHq0YZc1DUKPwXtOZF3R2dqJWs+7vz2iGDguyGq+J2TV6XQox2L5chOl02VBmqcoFQjECCSmIOWzg8XDs+WVvPlSj2nQRA2EJMhEsY85N4Ek6OEZN3pe7tzwLRiCcdzU6Lvq2NBFsi5j31aoqTDDZv3PxS5FSa8OcLviy5L2DqPBMubzYD3TNVWawlkPBXsWtq6hluWgtOcUnDQXSoWJ66/m24/R8YRfUrJLPudHJQVuI77hwMWzhJXNJE5WF6QiX99XllS6ur62A8DkI/Ark3mwYeufM5fL3eVEuORC8NyDt5h2nh3AZcvH1hz39+tGv6OT8WOlCWs08rKGU1vO1vv3qW3v0DRYjx6rc9rpqHDW1HXVV+mlFv/7rP9Cuv9MqvdZyu1A5W3JrPB5OdP36pVJUBgDh2QgzzmA0zOVAW24eCoLnqp1tbGLsCjoIJ/lUUblSgSAEpYZ0IFEt8UHCNqT6A6JhcM/B6w/bcVwhh7ATD++RCxGDbhNaYkYBfGqLJtPdY7CPwTdUdFtfJfGL+STm6Oj77iO9gggUNHi+uDzogB09hLPHYm1XHP4snSMMOi51XHjqdaQDoQ+i+wv3HnSHEENYOuH5COO4jkQEX8haSYeHTVOje7mRVk4voDLfqVoiAb4YIdJukjlsfRX5M6TCncF+u7r0jJbXWSziu5pyZ87iNVnFIcow4IIJyu/z3iF3oDW11SCSF+K6KtXYi9CyIUdRRNC1TyaGZJ1JmcW5J7+HXdO2QoTBR+apKfeuXmElQuZaakfKSpbPhEVPph6EHqQtOR+qN7e3SrL7W9LRR3NT6++6PSexcECQK8gMR1gyQtYw7X9sGQFuJmxEPhtyNyHatBqHjhl68ODQuYh09RzkzHExPF8VCHuGRLAz4xizDLoR7B6RBOSKaaVzkW4CwgDsTzFBV+N5GPN4ZquwOYtAzBDAgIrZ+Gt3AxRPoY+ObD3eF3IW1mj4iAasydHM+6CYaHXqdjZBPsCewEKy1aro8nKrq+vXajcPfUGMeiPrJdm3wO0O0iUseLlwUkO6E4YJGAIAleZSWSMGtoLMlN9IcazF2cus/L8YZycLu+CESw2M77xhfAgoIAsUuyX7ny4NbSPXQbh+fdNVb49KAN7hKsMYgb9DhiJ6U4zYIU3BLm3kQDOiMOO8CpLW0sbs5SoMfUwl6BbpgBa+7NHzcbmhw64WMawnI5P9BjmMojevHtmrDnrI7rW//Ep77s5naI4ChbIt0yisjMH70vCsjSKG4pSmiU6wWNCTR2d6fH6qBqOdKbpg9JZzPwsuXTpaUC/m5PMVMqZgyGMHVG1WnDeK01fouNGd837D9nGzJvRgbd3oy2cXHi+Arpl1XKyoUqpqNCYmK2XHrAiU33gf0pRwOcNHgGC3Wkax4bEVFzhadOaaNBak7FSrMbrKwuyOfTmfExUYPIxyPhtGEjacmCnJZzVLMcaqGFnhGZFDWsrAOk/cVftsg+jFbHYlFdoNRxDWKmWjVXTAPNPDwyOfIXd3Pa9FfhG/xftyWAGB9MuFzk6PnZ4D8sBZQvfMujXqV62+24tyC+69WalSq+ujTz62QBn8v1KKxcOcJF8uBtsRJiRVeS7nfEQgiN/5/b+rHDFcR4dq2TQ9Bvqr7cKzl9l8qOy2pK27CmyMZsoXK05xWE4RskIBz9voAOh0s9c+oVkD+6ac6Y1GGi1nKlfLnuFxiPAh0j2y8AzzQRAhJaPMLK6iRaXsyxKhNeYCNiLfQ4mOl8nl1Dw+1ONHj32JD4cTp2SAHAJR7rYjjSchAIaxSWUMTMoConLu9Xo+ILgArInaJ3bTPTGT4RCuM/vMYaBAJ4BEgMOPjQ1DEsiUDidlEgTzCWdRUglj8u3NAvlkaWYfhtoQ1JlTQICZTXBzYQhOt8n3TPk9wOjjMKAyjqgaXHFIs5hZIlPZa9xcJeIsxPPjc10uvYliFhGOF2D+bESLpM1MCweke7/FpskcxNmknEyO4wibczQda7akM44kDxJlKEa4jE3koSvBW7NWMSmBooihPAxNXmyt0zEMCfycwd4vn7ZbjyUUcV77C6eQVq6lB8lZaAwdyp1T2TBTxJN1727t2oI8hOeM61Q6FSknwKgIpnNPzs2OvOgGNEsHivyCRQ+jNClBqgC5iCIvtVg7yHqXRnpRM2xr4wrPfWDSFvX+B++p0znSyxcX+vzzXwSTt55RrQGFHVIFGzqCbONXeC4H0zCIOY6A25NHKO4QiafSW9UbOMMU7LzjWX06a0JTA2nBYqbri5uA9nIQxOSLa7UAui06pQbC28FhSwu4AoxfeO4QoeiK0LuWSsoVc7qY5d4W1ISPkzEL/rk3tKcQbeIssw/YZs4VAb9rG3/AoIWhmFJOm2Ss1ZLOqK/BoGuCjwO69whNuZpXpV42W7Rcw8eUywEzD0TszPKDwekLmU5rt/Tsi1ky4dur5NamB5jaLxe4JGUQKLmgPjqmaIixy2w6MYwHpsF4AiTDlx96XDp3ngechr25txMykFrRpSHlYbiBLtC/wFEitBvNcph0pP3PZmyayV02umGJmRnAntPEGeQMSuKyFkplMPOAnId2EoQpUSaF2QQEwqoj3+7GYw37dw7j7t4gfYswdGdu5tJqNNqa42CG8411lGEAwuthpAGKQucFApWF2JYkmjrermfUw+Yq5MnO5gHFJ8CxwWKejNca7yFqn8+sy7R0dnLqsURquzIcy0w4n+Z9gq5llG8jgWJuXvIZbM6I1znMpOh0IQ4CW+PNCxeFguny8sq2nxxUrKvVLOQ8vJZtKuR8ZtruE4Luv7jEOb9nOCu9y4uyVG+oXEjpgw8+cXYdSduz1dxVsH31yFSslTWG9DPbKp8p6PTRQ42TqW4nXVdLvelQH7Se6EHuoUrv56TlWq++eaFnX3xt/U6hWtImndd1b6jr3p3aBxm12k3nNMKiY4bB/Onq+tLJJe1WXUeHBOXW3E7PgEQWZbV3OFmnNBpSiYWwe7kM30I6FJopICs2E4ueDpDuMN8tmHwAvMGFCiXe8TcMiBshTCWWBVo9dnoQHKAj+zBm7uDIpojW4bDm7xnatS9hysxDp9TzvBAIu6BItC7klc+lHFm2Xc1d2bPBV6WM1gXgzAiyZVGahINeEhYYiRj7RAuqJFoBqO/8c6vTEG3jvMxmSjlNpER4Kh1dKqO8DaDTrrxZ+I1WS8eHR+4kB707Q428fi57u9CgN6zVzM7jwmRzE6TKye6k971w0cQmMytxMML4AeINRtLE8iwizHq5MeTEJfjiYrp37Vi5GLPeM8rxgMpLxPvU4/LD9tcG0mb4ePYArFitFyyP4wDhfZ89PNZroNf9F4Scg3Jb5RqhtfHaOJR2VMk5cuxu9M2zl5ZcUHHXqgXPeUAgeO1J0le/S0oDFWrVl+OSzMBCVa1G22ubrsYECOa52PsBDefDbQjJii3RMjnPwemYuOCQwbDWENY3GlXPIfHjPTrqqH1Y9kGTSW20mE+UW8Vs9f5BH3WODNuzjrl8LSNwmjwFUUZHRwc2yOZpMrLANYiDDbYr8WynZ4d6cM48qe7Xx/fZABEnUq5U9EW/WnJQUUQFqYrOk0vEKfXblCFo64Knb4lTdBLWkVIkw0RkfGLmmkKuskDYXtGTJ0/V7UaGKV0CpgfEQ8VMMKvjo85eR5yYfAd5CltkJCunp0dqY1soLqmZTQLyZeRVdPBRMAThC9PrkkOGmfU/Pj+zVOL1Rde+rRDSGe04l3bfAXHhAUtG2lDf9pJ0HdZ/eiwAES5tMg1zSg5ojDvoZrhMGoyISuHa44gnFwW4HzDGCOIKBEd8qctkpI6wqiQCDjY1lo4x8LU93Yb9N3KGqpnVqaxqjdobwwdybEHKkjUFKpAwVm5LXV/f6tqz25VW20AIPDfOkgeJNrdk43TOUuaOUcAg3aALmyjD2oUw2GkaXu7e3WqAfIMEI4hJOJ1ZswvzOsIggGu5bEekd6BzzKY1Hq/ARFQnGKFW25t+pDyHXM6Yf8JXCMtKnhkFquVioEBJWnlrm9caTmGuol3HdpA1EDaYNCWMhVhj7taB+THzwDGIOC7Wzd4haDQZ+7OmQaNId+h3qeCi651elN/77BN99uF7Ojs50PWLG1dLX7/4SqVqUe2jjh8cF+Wv/cN/SsvJXPVSVY8eP1Lr5ECv7650O7zRg/NDbUilx60DuGiz1XufPVW1VfJ8onVwpGST0vzLZ0pfXniBwFbMZqgK6BDDWYEqE0uqy+sbffPipR5e39p5AnbW3OSCrToHEfbrYGIc+CdTvbq4ijDnalU33Z67H/sC1ip6eHqmB48e6Zuvv9VoPIyA0AxMvIk1g1wgdE5m2pVK3sCQM7hsuTxY1JFdWfLlwmCbhUNnFG4lwfTkw+Ty4NLgGeJDqN2hjg6gnvMhAuWEf6T9aanEybDLSAN8O6dTHXU6Yc2H6sUGzts38AvDal/cwNhEHM3Xto9DoufYq/1cwHRsKOE59FI7s0XzNpYfGhLmwmWWyayGC5qLimdHPiTPxjPVKlKC6BrtsJLPqZquuiMnY5QukwODg9XaU/tKMhsJRigyFQTQMAm56XBCYY7DJjMUvglLwHuyEBcoEBAypGqtqOOjg8iazEU+onVt1aKePD3XRS/zJjUEWQbSjUyOy2npOCEeO89jt6Ozn3jO6I7JUUBHb+K3ImqN/0z3TJrDcK+FhKgCTMU8p6tter0njYSmE1N7oOpIkglIv9ftWReGZpjDG4cdz7KbIR/4lL2wt58DIcCj23o25m25QBG4UHhdT59C+uBQ5/DCVSn8LSE5zJKZnwXwIp9vBDwjuKd3Wrsaz5dy6hwhaWAOlChTrO/Dx4fq9YbaQe4opGwMni8jyyAiDmgNwsz9msR4n8/krY6SDoGDD01gaOaA7tOenWFIEtF2BKbDdi1pPBgYRt7lZeILKBCEsKPjtpnM1AWMYcq1kirNokPguXw48ICSF8uCZtNYfzwzyHNY33FhMJ/3Z1CrWoTfajVUq7UNzb568dpOV0aC9tpIB6vT/e223lPM8IHkS5tdzM7QdA8H+0Bk9g8XZ0CvaJGBYYH4LbFCPsPIhmeGBGKdKIPXcC6r1Abv1qIvx8uXr3R9c2O7PwiNmJ3YD5lxBNDjBikXXR1SoZ2K+aa7UR4Ml4Nn+RzkGQpCwupL4WkNWQirTWeSRqas188MJ61g52eXKdtS4ugDi9imDJuVP5Ma3d/JgYOUd7u1rn3Wsb5pAOIyp7jgBWRc+IfO0WHVMPyXpCTVfYF2WgchZ6OZKuWM4NAYwHlAA8x+yaXLytp5yz3FXnsaukyIjyTLMFtmL52cnurwpBiENTTpewTDhgT4TOPLTBD93rwATSuFPkXpdL5UbzgyqZAz9PS09G4vyvOHB3rv0ZluX13om5/feUG9ev1M+VpOR+dH+t6f+YE++N5HAoznQCuns9bZpbOJTp+0daC6Vng9slGyKa3QhxQzWiCRaEMS2GqZQZqRd57lWbdtF/hMaqnVDEun0BZxMAj7skxBi02iyWCm/uRr1WrXYYKAYHsa3RKuDXgCAjF0ByNX69NFoqKdcHAMWZokgNaPruqjekNPnjzW9dWV+r2uKyguRy6uyWyiUgWheUO3dz2HIrMwGLg/evTAhxJ3FIv47rZnRyH+LsSNHt+L4nOvg3OUGJOQ9E6j+VT5fjBzW80q1DvPb+hkggSTVqFc1Hg+0Vob1dpNH3QsUKox5lBA4o4mC4a4LwOlEhVqzI+qKjiYcuEZXHpLh8Pv0/HYZXU/Y0z0+rZrRjEWUrsF84hgAGNiXMoX3bEM+7DmFhGds0KDKA3GWHshVMacG3ZxVmlvDC6bOIjCrmvmjp1nCJs2U8jr8OhEC8yrfRDgTrTzAN/xzPbWTNTvj1xN4u/KQIlDn0MPoTlzJyBou4YwV/MhxaVReHNRwvpD0wiRC7MAxy/B6LOz0UZHR231bNk309HhkQ47TW++/t2dRdBQ2s/PTtRpN8X9wLyW7EwuA+aNwJxImTBF5463DphqeAGUzCG503Q0MxmFQ/D6rutxBMQdAp+RABVLwERcMqEto4vDupE1M5kyw6Y7oqirBWGj1/OFwvySA5GDwqHgXIYQevbpMobCCzCvA3EgF7bW4NAv6vLyRtcXXZM8JrOBFmvWcE7TBA3rTtvZRr0hZCJCt8PdiM8YX91PPnnsC51DrlqNUGa+YDJSLNgFyJrUvGfAwH8UusgVuEwJl+ZQRkSPyfd4RNIMhWFokLcbsjmZZwLtZ9RsFlWsFTRZTLScjw1vcxlZRoWZO50aBdl0rg2XY6WmKd8zWbt4nY45Q6J4OWw3ddJpKGsRPDKPlD1iGc/QBXPZjenU0f1u0h590OGdHDQMSXe7dMhkuYYbGXthsBr6TEl2YeiNNpIsRQqKWrXkVCIgf7gNdLUc4DfMYXsjuLlaz1da7KZGtyCzcDE8PDvyyGKRkAIb8jbSMDgbFpmQwJVKde1ysf+4iGESV+pFw9C+HLdZS2boOkfjIHqVyxmlVlsnN1GJ0sROZkOvO7ySjw/bOqH50d5VacP3iRB5ZFeW4qABZg+Xs8qj06WwItnI89pgNTswfo82gaSxl1mOwObW/XrMxffeaoGmcrHcS9bkS5GzujsYazBN1J9iYg6nQNrddekEvOY5E5JK0UU3+4XvV4LdjCMWUDOoFpsHdDBZGurHgJ4RHzFkXLTv9qJ8fOzNjAbm5fNXdr/B/mq+mWk8m+jJZx8SxK18FZEoeh7o0DvbpK33FRr+g7AEMRUg0NNaKOZQ1ZIykDeYpa2WNgL/3qcfmKnVu73VZB7sSIa99vx0kgNRWjsbswNd3PYGurOZcliuLVZLDQbP9OjREzWaLRvgAreZdPMdqQGVEAui3x/o2bNn1jNBPx/08Gll0L3akxBixmiRvP0uY1bEImIB4ZxzbyFFlcqvYKTlLDFgJkr1hwMF3WfAHWGLNSbFY0ykViUEtHnIGWPPy6hSwdy5AFlEtptLFirmC8HUxRDZ2kA6mX3nxaLY66EabaC1kG5Qpq3N0s3txeK875G1lma/TkYajvoe/nves2edVkp1QxWmlS8Wb4yZuSjYXJGJmTFEZvsv5p1E5ABHjcf+OWwuOlHmLyxOYCas6hArw/DLEF3kaCA2fUBc7khgJPsZwAJGX1tzjBOvB5MCh8JSmuHbZ8LXnn27F2vz5Utkz3DElQlYGejbBJgMB1lF54/OVavU1ai1TKDgs+L1MkNCxgPcB/KAHpEZmCVChsBmSmc3NtGgy2WTclHxmRliX5FqMvehwnMPq7sIEwYWpAOoVHLukCA0Q4QgUYTZO10yzkZ0pawjyxlW6z3DdW8gT+LJCtepaXQwuMG4cIj3TlEBPBXuK2FLR+p9pVrTZ9//ROv1z3T5+sazxslibpLScoN0ZWPYz0XANg4p1iPFWK879M+s1nI6OznSmiDK/Rezboo2PleCADj1gAxtE6iN52CgMXQTGUDgfMEuPUgzWN9Y/bHveB9Imli2oO6scycM4c61We276DAiINWFNUiDszWTexUoCHIEWPCQdjh8k4U/42azpnaroQIz/0zeVmwQsALN2dqEAE9iChc8o2wC7uIw4zlZFSZ/hZl9XmcnJx7x2G7OEpOVhnsbzJNj5sslCU1vBnnGxJA8KAg/i0SYnYv+uEAJPadAWjNnT+1UrxZUqnR8fnAm8CwKOQrWtC5eXRvuPTs7dkQZyAvv2/F09aqLCJ6ZO11D/Oz7rTvPQHYmZmFTvJEaUreCIGfpH2lKxwdkDBPMMHBRaxN5S8JgWXNBl98YjvPfYZ3zuRXnjFsgD6VULRZ03OmYHMRzgQAElL8j2JysLvajk1eocwNhnC8jjAH1wjzZajyN5ga0CftSI2ajse8A7AqRnTB7L06JJly5UMfggg725vZOXcZIoHKlUC8geaNYBixiHV9dXbzbi/KT73+gZDBRKuflrrvuwNozBt63Nz3dkbSNJR0ej2l8ZpxKuReLh/8nvp2lMgkeeXdaOYyQLdBFhEsEFx8ksE5e6UZN2VRGKWydpkvNxlQjIXA1JXwn29DxpLFz42JgrjDTwpULHywfKExHgldbrbqr38l0qtRurVKupGK2rBkU6H181PXlpbFvHEnoPu7lI1S1VFTW6hli43Ciyo/LJGQZOUtDuGS8afb0/dRq5SqWmQow2PXVje7uIp2djesBcypttnD6Lq2HpwdmAg9HzDChVIPFc0EjI2EuCd8848OMqyBgGkwNAsM3ixKIdxNkAw5T5knAgjjO0FXQGb3/3geG9b744hs9f/bSGy1MhCAQJDZ04GZlFk2VyQUwnd2bHGAsAHwZCeoM0X1gJ2tdXF5F7JcTy5c+FO+d+yk4EILznjg05qOhDwccadAyopd1l7yL7iogp8TnPv+Zg5CDvryL+S9dDx6hzFQccTSdaNC/due1Sh/+kYvSnd2+gIliIpiik9XMTMp260CZHdl/EU3FAkPqghMK2rD2QdsHTaS2RNdKRqp9lTJcAiuvbQ4koFk+JmaX2lJVx2VIlcyBQNwaPsesH6DrxRJ8gcOczyfY0owYivm6ISQQEuZdtkpk5uqg8sgk5Rl5bmbxdEr1DMSmfbh3Kr4XZDYTb2zaz+EzNHJQqzf0yacfmEzD/J+ZFjrn2RTaa+qNA9bCrjn8N0gyO43HS+d/+vmNnuumAsP1oV8bAeKT9FyLGSQeXtNU5cXaxKk0Tja7cF5hrZgQiIQou9PWjNvdWwnVBlY3iBSs4LBzM5zKZbihgIyRQ8xN92MNAscrJf++RwLubmsa90fuCpGAoOHmz7NuKY7xYG42W55Dvr68VG8weGO7Zt8Zip11sJ+nEy7PAz19eq7z81PrVXlNg97QM/skQ0HLfk5pPJursUgMA0Im43zgEh7PMAsPswiKEdaQ14zNJ3bq47c8J+y5Yi0osWnNTt0ZjfgjV6t1751uf2R0B1INiA9qANi6fMYw7x8/eajLi57ubjFsXxvqjTFKyhadnN3sMQpbs7SbNC5IO6IIM/Q8T8wo3W7pAitKtmkzvTlfGd2Y6Z7B4J3RB/B0xUzdKpc77GvIn2g9HUQA+x9HNPy2QRosLNuPpHD1yr/xkaVQga/gC31vPcp5AxQORJ6kE/M5yMnkbK3XsCusehR19vDMcpVvvvnGUjHLzpCbLEKehxoAPT4BAZzhkLre6UWZK6Ucp1VqFVSsFQ0xsOk5uIEpmMnBrMvuL8fA0AMX95FLRZ+G2oxODG/CnFJrDvCctoudJqQKDEcexNJVIbYtlCuqljCRbms2v9N0ObGO5+KKKBY6GCotKu1YnGs6Jy40u9Wgs8u5W+OAPey0HSjcTZP4MMGC2g+MM4UoHTbWJpsNos7DBzo9PtaX41EIo6Ekw8q0DV0QFML5jcUdw/lmo+yFuFxe+APmEAfGoRqkEqWq4fdhiw4yvE9IDgEZLXeJUquUsouZg5KRi5B+kp/nVZhj4hueqmnrwoJ557w5uoo0dO1wD7l3xTdcWipqB4vUxJqA8fobArG7WhbnevL4iTrtIxN4vvnqW3d4wL84tHh+OLVDs/J5GHMYKLBUuEhgywaMzKEEtMFnSLkbs9fQm0KVp9goloqmac+QWLSa3sRUjhRS6wkEmPB6tQ0lkKjfUxyG4RmZ1obCgI09wjaLOcXSkCvm/O3UkS/X7vhGr19fWUAPm21x/J1A1n16BgvRVfAyMTnE3pPofTdLzRdbG6CTblEpkSVI59owXf7o+MAdHyxktKnoN52sALS5j5ojMX6XDk0eEBQdjd15dnx2zFM4GIlpKwecz2x5Lx/iIA3bvmAUxszXqJiDiHmuYVgREgC7Si1mEmQbk5uYacdlG6SMmFOHbdh9ccAhiiQpAoN3WzS+dKd5F3F3N6RkYCixCRapLVGIm8KMY7tHHWJP4WKE0TadGBfu5agr7UMYXr+81mFl4mJg2Bu5quf7pdZrtQ4jgQbJDM+REQxdHwUz7xuNMGuHTpbX7A6FIiRGxW++2EuG6d3phd0gHTUXG2gAFyYdvL1Bdzsdnxzq6uJag+7YMphcBkZv0Xv38vJSG95rOucusj8YufADurW39P7584wh0HS7PdXrFT2tPQo5GbKnSPQLyzpi6IqQXJBzhLUb+xRYmQAGE6sIAWBOb3kWZBjn9flSxdSB+V10/shiwl95upiZqV6rNzUldzKFlKNs68+rq1uT3lijnCkRTUjhSrEWGZV8ZhQLzMVBVCiJjbrsYg7IhbTO7FTE1J2UmrDEijnhiiIurfQ25o67Rtr6TLP5ISQmXG5TI0Gwd2vloqU2kAjJxs2WgEJ5bRRaYffJuT3fE9HgU2yQTnG4ubFCAZDVepbsJTxRLCGN8V7Yn3OkF7mBMHpX8pyXgvDbZ8+sRHDYwmbtIh0kCVkd7yPWGD9780eQp3dyUVabVGoV1Y9rOjo/UIfIlusbQ63vf/REH370ob31eBNmUvvNhHO7q24K72zKrXX4UG61We5UIhQ0lfdliYUdF9FyOFMWO6XpwqGdqTSH1Yl2qbKevyLpPCK1LNBGzMqBXCj5A+WDzxVDfM8FiCgeuBC69+nRgZq1km5ur/2AG8gUtmV/0FQWmLZDj06Wcx/qHJLAmbT36NOAKW9ue74MkE+wv5g18f0R1LJB7H4DbLgLrRsC/+WOrLyeFsxGV2vHVHFos0CBP7jgWQhshtXtQlddqVQg9SNifbjsDjqIe4umh692idlfzPJWWJtl0BjFIoGQYnkL1n5ArURApbP+bOje5+O5w3b/9t/6OyY2TCZz9bvk7YUu9OToyAfbiAp4k6hWrnh+g/UTzvv3TF77MO7ZjBBVPB+zacB+VsZscu+EESzVWBNUnGYEowvl9TmkFQtB4oTQZwG/El0V5ga7/N6cwYzDsJhDSF6pFrwG2Eij6URfffmNqeI2NyfVoL3+jmQhLo5gX3JAkGWIu0hkeEIiubjs69mzC0e8wXA8OT5W5wBzAhjRNWWyuAhxsKRVSvJ+vSb70Euy7mAS24CBYivyEldY6c0Rzk9c7HhOB8lgPz6gYOv2etqluJQPlBXzTC7L2Ja9bj+MFoBd7XkbBRHrjXkaX36O+2Bu6+gc+M3FCgEntLoUbCRZAE/ysxGE84xGI8g+1dDoTYFW8e+tK50uGJaazMc+0Phl2DUVzjOGnXe8z5nWy60WSt5clPP5SrfTkXJZKv6GIf7JeKBXr15qMLwLof4+mAAZEx0B5iEEVc9ncTFRCPFMeR0rGKZ0jhsE++Gmw6UAg5TvwVrhiw6b94YxAIcsjOj1OuvEEeBZ4GvSM7YYAUGCM4GtrOFopmyhoEa7pWq3oYvrWyWrqc0VPBKgOLIpQRQr/JyL1xcmNYUVWnqf/bkyKQZLv4jzw2Jx5Q7S4cgeWcDghUiHdA4Wc82fn3a5fVFKCZFVNheGIxQ+LAUM0HkGl1fXqjXaRuCY6bK/OEcH/aEuizkrBIgc4/lgF8jnO1vgWz20bATkjEuIZ2zvbN+F2NjBGuWC3qNOSDamsGSZsZZNJmOfoZNs1Rva5ZBvQRMBbSqYvWxCHDNA0o7WS1XzWTXJkSV6jkB5ux/Fnqdx8VlAgMVotDd0uZ9pgwIU7RZWqJCR29D2+labHefKwoxzYF2sA3n+dNecIanMyjrT3CyIXZyd3AF8ZrzXkFBRuNO4YF0ZrmV8xu/0ooR9Wm1X9fEPPlK1cahUvqCXzyo6Pj3UD3/9+3rvk6c+3L0z8Vx0MWI10T4zkQ88rMKouJ1VR0W/kJ5/8VKvnr1Up95UvdywqfTt1Z0Zn8yuZmsEyw218O9rNFQuj02wIQFACey8rCs1PgSb8uL4gsCZ2SFByxny98rqHDSV3tXVqMbQvlKuOeKLB0oyBQ+cDwG7o1Kho4dnp+5g6VDYfM7kW7GgEN4HCQBGGBuB33O1uOH9cVjtXf85UK1ZZA4DZT2yBvn7N/2enwOdNmSWyXzqITd6o029IvWQTVCx7lTI5oO8wjjIMCTJ6ctIPIBsQyVNh7+EGTnfRytlbba+2CLkZiCa1kHrQOtF5PN1b7CCoy+A0ZiJ+Vy56AsTcg8dB1A0ZtCOJUvvLNYejmIego4LyARcF69dLtFgte5nl4X8G+YjGxiHIUyKKQpwaRmNJ0ESoPskOglms+N6KA7iJdukeQ18HZ8Tm53PCV0oJC0KnNvrO11f3hj6N5val9h3jLr3bj6O2sqlVVTBa5LPDyiJ3Mmbm4EGvYnGo7ldfMZjTKcXFrRzsdabvD7Wc+RZMj8jyBbSls0rgBYzJfXvhiZz8bM4bGE2Ey1HFDfdJGsUlq8LjX10280GezwYqykXOluCjCFSTFfWCFNs1Lc7HZp8FUgFBvBvLkuIHHuLRLokDi86Di5L4LUITMY8PxiVVP7QqCmIsPdDyhXG7Ng70uFQ/csXLdDp66tL2+jhDBPZkSAMBbVLDZMj7pK3h0210lA7xWee6MHpmQ//0ainq6tLIxsmj9g02yJLowjrLM9npUx+q2quqEI5Y7gwui4OyGDJAxv6f/eHHwgI57ojmjArwLqOQtVWbhQ1O7v10AlymSElmg25sLbu4gsYfPD6hkO9fv1a3V7fDHkO0WotsbEJa98wvUcwYai9xMCi31eFbNF6S4sJDPmMZ7zUZDDGSxjsb3cuApGn8ZnT6ab2pukFEB/xWRE7xxiKbmujZDlWFsJNpaBWu+6CnREOTOSL11fKZCsuagmVh2jGZZEkW11d3PnCnB7PdXx86rAB9hERZf3enXq9kYsbRlLhGhauWpwbXnfJMmwlx0HuY1yygp09D6s7UBvQpwUB2aTM4KiDMxRzzn1aD+eWzdAZhWG4XmbezMeCEiHIcxShML+d42sUJcYgjNMYH3jdz5aq0gRV66o1W3qYpVsue92jEuAM4nPhObpg9Tgozhm+1/HJsV6+fm2XLYxMWOOM38wb2ftz38sD0Wi/04uSKtXOL62KHuVLyhQy+v4P39eDhyc6OTk09VyZkEHsXZGimzSF2MzggAshMiAspvlLUupf9vWzH/9Cr5+91GGrrc8++9gV7+2IxIqsWgdNbdBX7WUTdjkh16/ERkE/l35TMXABOTiVrgF9ZAfz9Y2yqbXnftgfAQWA6TMzpbJAvJrOnqo6rLibxSKPzpDD5vj4xPi42YOkYjDz45Iif9KidWCshtabhQ9+LtPQJYerD9ARi9WBxJYG4vKzn7/tc+hge7nrQg9F8jevHmu89VapWeKOsFaeatEhlgsN5k6ZEobFKT9zxMZFPGUNW8BKZCaAfAMyyU6TEV0s2qmiVguIS3QzTc2mkW7OZ8PBwkSIrgLsHgKH01KwWivzPPJ6fXVtY3TmOZMpc+Cllszg0gFNcajZYJ5KTThvULnFDNoM3T2cEh0Ymy/YvWxoftG9Z3JxKUxmeaVGKXfMwUrEr7HiQxBUgoOCw4yNM5nU4/lCdMDSrkhMUllb6Kn78YON0GmvgSbtlBMuKlTmOPkAt5HByOeCiJ/ZLXNKWKGDIZl7Ez1JP7DYHVMInIBY6eEmuEdONhl9/dWFbq9v7G5EdZ/uhPMThCEg2rD/S2uSrPXbi4b1nblcR//by0e6evlW9/n3+/phZaR/7Kjrf57PJvqPngDjxtzFRJ09uYxnklky6+VQhDlNFR+2gb5YEHMvV/tZ3lp3dzeqlpru0IfDFARZ/5kt7OhNRoMhs2jMpNEsH3jNglatPNtFj0pxBNc+XiedZ7bMhcylD/zJfD3R6emh9c60MTO6P1tLAvnNtCMQwNo71gjxVFkztTmggwjG92P8EXaG+Efb4QrmNbmte49b2+bhBUoRif45WXnUwWcAvHt6eqyXywsXDY1aR5PJUuXySM9fvtAvv35meBT7Rd4gHQ7rFMQqLspY1xSQmICw1u9DrGNmXfSYx+bdlnWx/8OBiL1iO84M+xMWMFF+E79G5GtkqoaxelqLHORAOYsTq0Uivyga0H1y8PuMqmDEXnb8FfsXg3cYnKxlPFwpyE4IQy7d64bDX3i1wsZt5c4wXksI+U2Y42xe4VWMG1nGs1Ng95HdbbZG5krHXHIr3fXiYuT3MGlhbohMiMsUk4IKayS1M2lzkVp77XCm38+R/UGmIpoxecOijfm53czWa932+ho+f6U1ySegZft8UdYHBuqYnVB8WFrEewRBKeN7jXd1WU/ee8/zVWbIEOMCQl7ZHgkkiCAPzigY7+/0ooRgkwI3T29UrGX19KPTIAdYibx2LqKNqlcLHyS8eDSTwCseLzhpHcH42vomsMNxf6Krl9eak6o+XWmkiecIfHjMvTwHcqvO/AJT6Z4PS6qPDUIYEzTWWu/nFDbLpUMzmYQII9LNJxbxpzdLNSuIT7deoGZqurrKqFRtmTJPHBiCYxh3VDdsgnvRPBv06KCjfgbXiUh/4FasYIm2ZUA+NnUblh1wLSbs1uK5ONgY7mGxoqHjcMFBxCa+bKBs3obcQEv8d+Z+zIjs5o/cw56wuIBstdsmFufWq3VfLhyOEZMTOYvMtOhS6Qrm08TQBuzCZL42XJP1zIeKDsioZAhptQqGLV0mhCfMxpl3HBy0tSFIN9XYe1ViNZZV5+DACz2VHvh/76HCMMMLggAdZKfVNOQ0GFAlzsxYLpu8RLZh2Yw8PioqU8gZlUI54Lp8ztZ8HJSWX0CeMlLBrAKYCggzhvyG3HJpHR62XWi0Om2dPTjRl7myROay9V7M9uxWEDOhXdrriM4b8hXPFTiM18DBTrFh5q3n7diBLd+kP6QUTh5cJhRC213Omt6rqyu9urgIaL1c9Pwbcg/m146Kyub1b80PdbXOC77nv5k8lKKA/hN9/Xha14+/DXyTGc+z9StV+mV9UujrB+mFNY5OnZ/OlE7CKzObjXxH/jsbkM7S+jnPLrEaI6z3RoPM2GxK0m9aLS6GrIb9W43HAyNJhCnTTW02cz140LaxOLNcPGF73Ylez/GSi9fZ6/WdEYmJApcp8OF8PrJhB/Alz40Lm2fCgnEnYItK2+GH9tiONTGzilAMRglhpsG+5c+ERCnE4/e2eO4o7FoV2lvOBwpsuiMSQRqtutc4Z43h6mJOR6dHGo4JD76w7SKKLAcpuwDhAqYIC2cqxje8FhjnEA1hnwB/opOslDDxLhoZ4rlx4XTOWm4uSOyJLEpINZBWgk/A2mZfcMgjSSpaCgPrGhvDCBXnrGPkQ5fF3gahaDVb1pL2QM1smEKUYd/ruHs31Hr1pTJZvGIb9jq9vrr1fL1IobqFMEnodTCmaWxsMQgikoYx24gCfrEwQZNi47B96PdI8DGGJ/xvjxEZnAJsJc0tyIiGsFogXB1GcdwN6H+5kDqHB57bkv0bWvjZnviIgUXklHLm07yk8kW9xG/67k6LZKtUFoJnGMYwBsLODjs68yholPbh6cxJL64voyEpFA3tmjvhDFpgWBq0GF9ApGQ9Hh413vFFmUe4GWbU6+3SLhnrNJl7W0drlbN53V1eeFh8dHaiWqflyo9B7H3a/G6TsqNOisttsdV8sjBsgbavVq45SYNKmI0CgYeLFrYTOrvxmIMRCDFEr3QVbGiLTgkxxhS5BH0ffdHGieF0TM7FS+a61U5XrRvrgxClBtkEf1C60qyrWBY1lZ9zAvHzRODqTiAGxg3CbPM5L/ToxOIQXJEEwaZNgF3ZNCX/L18UvCy8RrsRs1SqPBi56aXSI9pTP5kQ2du1B+9TKPPAEiEk5kDHpgmB+y6dKD1Ds8SFE1mSfFFdbk3NB/pAw0cCA/l/+y6YIOJV2jTryJnb6zm36PQiBogO2bFPFh5v1U31I7rHsVd5LQZDLzzMHGDR5YpFazNZ8I7RAeZG8Fuv6eDgwFomLkzIBXRZ96+VCpK535aqE7LIdOZFzuYEAnKQMxrO1R6KtPwB31cOJzq0ohrZSkCMkLaKGT15eubDEkiI+VRu+R0Pu1TkRbpgswcts9BgUQIt8nECN+82OS0Xd3Z7gcEHzTybi4ufLEGqcS6f+y7CM6vZ2gQP2Mw8e0gTFCBAyXymHEI/Xrb0b2/f1y/XTU2YR/2xr//y+aUeFkO6FCb6kWNoWJ10k530t4dl/Wu3weRFtPB/6J5LXemUxJ18Q/+lB6/0cLd0twiZjfEAi4sOpl4P0hivxUxH9g8B41jamdxAmoYMjTUbaJrXKuZTardqFouzh/lvg1HXXql4biLj+Pqr5y4QRvcDSo7dPcsQcX6hsA0DdCUaT/saTwZqMEMD3QAtsItTQG/MLaOT5VLLeTxjEpKLQwLdOeAoCkNSgP1dJNPsu+W9kxS3G58BBSWwnnnEFPObpYow3ct5TUb45MKITCwVOXtw7HxG4EkOczNvM2GN5yi0vcdpplpzzBPaPbSRXMrJYmHEhCIKFuZ2BHEK15m0Y/lM8slyAWKCsIg54f2eXa/dWXMJQ76rlGH5btRshxyEETgd5HA0DYkLBTFEuWzadnvImviM0aFyBm238cxev76R0r/Qp59+ogewQPt9LZev/ferlZwLbCBQmMwU1RxVpLeEkUTWBWj37k79bl9NAsrLxGNlbehCx83nl2Y/78jvLGm5hOGOMQLjm4qTdeSg5HDL4TOiAIU8w7hsuDdqt/iMZmfLHkNGx1mMX+7KmZlj1A6LRJn8WkXm0Q5aYP2hix2bwEXnm2bGjkvVbKpu7zbs8+rwSvbPB4VCCmvGiDy03Z7vNPbZO7awQ28IhZvhAgNuihMPhFcp7RYb6w6ff/2t7m7xUkwrXypHxIpnBXFAGdbjUpknmvRn6l7daDwYOjrl+IP3zYikAmUQi+cf84XxbKHZcGxqPbMESAkQhoACuEgwZwbmRMbAZc5DYQGx+HDYAS6Eusyc6643sFCd14bnKD6XVFWzxdR2YoiIufjuvRvtdPNGz7f2Bq4UMR0OiybeV7fXdSV83D70hgUiYcMxuOf7HxwExMZFyfdBTwZjGtOABq73d7fWhCH+d1g1HouFoo3BTchh5gYbkOdv/wEo9mlbTTnbDlgTJmSeDhnP0UTdW9Lrp9okaFO31pSuF0E/p/JzuvoicadkvSB2WNjZreiAI7yZ52Ih8oRop64rt+kcYfpMhfFcxycndkMC3uAzxPk/3Ik4IPNmH09GsH4rdvPhQLCkhOfJ8Uj012ppxjRzHAoUfi6fEwWFA2JzRBeFRZZTK8jOw90Es3qPHgmAXVvEjouLSSJ0ulz48+9ugCDd+HgyuSz+UzCX0YGWrKurVflcCyZdcRgwr6XypZOBAAFykE9TeZOIB0QdAudyBYp9WXj08B6wS8NNBkegZ5ui/pXJDzXS/Rxvp3Zmpf/Rg688A+Qob6fHKmV32uQ2e7ckuretL6RiMXSnv1Lo6T/RvDS8RGfyT/zsY8O/l6uSf339bV3/uw9+5kKGi5qZDJ1xzH/Co5XzGch6Nh0qncISkfHCmQZ3Q91eXxsWhWwDTIacKpMBNi+4QDg+ONR7T8+iOLEjDzAkBiALpcpvq3ITlTAgSDHPZrRRU+G44WeKWT2XYb1ZN0LA5TudwSDfKb0JNIQOKpslDBmNNRdVuFllC2HWgGYaqJB/vpdUWCK8t2lzfWGmY8xobQqBpyhw/WrpmT2mKJAK6eZIG2F/4gEMUoGRiE3OWSf2CYUoBZSNvIwZIozmCBfn8s5zuZnkv7OuzxroHT6nDZuWY6C/3SQ6PDwIucJ9LB3PCsTKMYAU6XGZ5vKgUaGh7fVHMAzcBLAXLY/x38mGoD6btT/xq9cXur6587nE4b/ZZvX1V99aT3n+8KF+9Qffs5vVzU3P66FBuke14eIT5KnbG3rWafRkNvGYyc5hLqa4aIChFxpNRobzy9WKDrnEDfUuVCBZp1BVFRkMxQUOVXR5loBsfdlPZwvvaWwVyQRFH0najhm3mLYXtkrhhYskpd/zuT8HRaOYX2+VTtYeObHmOatJQWHtbFOJ1tuJvZPRVIOM0Vkn3YHGY7S2xYBaeTY0SJ7jUww5wG8vs3qHF6XNjWFUen6V9xvM7ahmEuW3ad3d3Gk9T3TYPFC9SLhqpHsE9Tlo8xBhCH/Fzqx7ea1nX36hm9e3KmZKajZok8kAzBg/niQzVfJ1dapVDcYzB0QbNgvE1Qe5W27PATeGdSOENqMaMgxMCRB6ezIV0gBbpGVwQcG9Ao9QjLphz0KiQZOXM4TJ+wRysMZL8VC5IKkQgZchIJDK4eqWHcrr2m5tDE8I8aA3MiQD1IhrPQ4YXCZcBi8RVqeyOn3wSK1Wy5fpzQ1dzcYdmXVXvEG6Sj5QIE8WHMSnCAHxoYA9HGw90jqS+coFCzFCsNv4tZytNJ+gdQqR/QZhcC70jmb20r3s1maBcbFw6PCeEyr0vWgfliYQGEUKECmd5223LyFv2efn8TqOT45MVEKjtkmQPCzfeNzi5TkuA+sB1dL/RQAsxQi+pzBWIcXwWXJzgQjQLWBwfq93DIFnxj/D4a2Luavkcaeu0xMgaA4ZciWxxeLzgWH3lvYdhCK6kyh+IE+srD90EFscuPtElEANgMfCcP5+zjMacuBtVD7uRP4lRaO9crFLLCmTbQcLu1A09JRtNPSPf/uRVsSM4a6Ugs6z1X+n9O/rqJRWJ1dRPoOQG8eQxGYEEHTszkNHROwZxSDzIyLN0jvVKxlBOMWQ4G/+xi/1k3lZ//wXDzTbpHSzKuiv/OKHOs0v9b/57Jd7SD5mWPZb9RyITFW8jyH/sLZ2KhdrLuyuL7vqQJBYy4EGzAArxbzWWEoB0W2JaSvr9vYm8gcTadSfGLKl+7v/oopnVgxTcjwbq1rLK1fMuHBtHR34QMXvlxkmXsk4vcyINuMSs58sKRU5LcwtSEes3GY/8yswCmFmHqYbwI7ZSuVN5imdMZcjci7GGfxZLsrJfKjdGvY3rwX7ONYTwep5byZ0uNjZFSksMn0/j9ATB5fAyTXr8FfNYdHo1JmI0KIT55xj7AExBhkQLP1iEShyqkH3zpKlLHyKvYQkil4g3UgAIhzgrsdnC+Ra3BtLcLgzEiBCjSKupWT53JcYhuJc8KPlUs9fvtRX337rMGMueuLDeE+ck7fXfKYNPXx45i744uLS5ECkcsw4R4OZet2pbm5uzVxlr5t9S9h1kTFR0ZfqaoXEhCEChdHU4n0iwk42R7q9u3VOKEUdOZOtZs1OVlyQzIcpHDExgSHNmsSMnWQTPDUHw6mhaH6soxlT+MzC8IW0RSOUsn92oVTZFz3s40AcnCbDv4NO8veB4FdwESIoIMZRdBrxLO7TnBhrYZt3D6dTGL/Ti5KZwDa7U6ZIxUBiCEsIKm9JpR3JE7T0Zb335IlqrYZtpKD0et7AIBwtDt7NhMlilmzh/9aXD7Arh/xmhxamqXSxrMV2ocVuoXqh7DfEYdY5aKtcbunly0tXQzWkIYWiwzeddeh5xS663wJdaUG7Zn0v7l2aOHPbH+r7Zx9pMhu7G+QM4EByPFGKBIqSPwQswujquDRzXCLrSBuAsUdHY4H7jIOCjZ31/IIDmEsJWJSLG3jglmrWfBR0mGP1h6M9G5XDoxKWVbmw7AIaKBcq1quuyd6DQcfxhnUbr81esvzhgK2d6IHmaZ3SZBQpI4v5yjMYBvdcQPw9XivzOfSQZhvvYWc+DzYFMyc6mQSiFIuIz9WEJeZFfAsusY2t+zBGIIvzm6+fmRACXbyDLIiZdLKyEBiIhy8+B3ffzBbLzEOzNpGfLkKsfh+J4exHLlFQB9hwjtjCL3Xlg4QumDGWiRx7T0c6TCrEUjmIDNV1QbkiHRSQOGYBb6HXSGPfGfbnEiLVBpeaew9ZXstyQWoFHWqE5HKp4JoD/IpH5KA/tt/vNtmq0SyrXINpjMNISo1WXqUqhRsm5jldbqr6rzx/pPkuo1J6o48KU/3HK6/066kLQ5FZsfHDks6h3Dt0lOgXgQwpeAKC5LPkkOICAI6FIxAEkrTyqZ3+ofZa/85vfKV/+VlN/16/qi+Tml4sS/qvf/Wh/tuPvlUnPXF3Ga5MQXBBD4lGsFioaDbFr3io16+uzPY9aB5qPlnp9ctLXWPDuMlrnTArqxjpWCzKevnqRTA71/i3MrNjfbwtSpC09EsFffLpI7UPCDEeGHKl4MARhfWECUVEHZEjWtViKReXQKKRBZpSvVQLdxmKtyVEmJTjx/DybbYbvsC4YAvkHVar7oCsga6EOxTsVdY93Ws1C8yOiF0me7E6sZ57dH6gYY8ieWwYcr3GOIDgAj4DHJVCH+49bTgXcXygPMwII9cW6HW7T+YA2QoTCpclXIasxyTRqxfP1ewchuE/Dhr7As7EtvlUa4qKCgX8SXxWMIMzebuKIZGhwAm2fcbaTQpeeCOEtCM/ymYwlChGZB372PKPnW6ub2zxB7msUn1qZzQsE7kUV5i/3PQRJZnwF2S2OENJHmo2kC1VA5HAjCBbiyQa9NLY9JUrenp+HlrITEb1amjGp9OxETVgdswjCvmKVgW5qyTTE6UBIQkYPuCu5jmyyShB1sSohsICkiJrhblvsZhWfR9E4bEb8JktAVFkQ+iMy4+LE1Qi9Jhhueh5MyfJjqIn7wuc+EIHM0D6e5cXZciPI0EAVidwA10VFcCcB5XnoomZpPMO0wxPC7ZvAnZBIlHM0I5jUFvW2empKrmSRr2h55JsRCqVTDGlUr2gPNAJVdlmqV0agWpWdMksAqjBhQJVeOTlAXvwf5YmkA1odufO+YRHlUM7tjBzBGpBVAzuDQSAVIF55gbD5XLJ1Qvu/Pw9WKj97UDlTMFCW2uAtokHyXQwJLWTwA18CcmBC5Qu0vMSomUyaU1GA02mA5NLqNDoMB3bxMB/9kKlSs3M3Pfee6JSIavu7Y1W85U2hVxQ6M0MDD1QMGUJVy1oMuybjEIOIgsJYTMb3SbZDEW3YZrMZUlHb4H/euv5wHITCwZzdGLRuGzp8OjugFk5hCGC4IzCZx5G8Dnd3hJyGhmKy9XYlRkEKyz5YpOQfpHfk6XYSDBo6VoQl++0mmNuT/p6ScPV2Jqne90la2YvdfQBRLgvvqO8P76cm+eCJPIc6RQODg8N1QP1rdcTw0BMJGyAwPSDeJ79l+dNmbxn7LxmiioOP0OxW0Jec+7SaafYWByivHYXiNjtLRdmkwIv71YpHS6aOlTDlW6uuFOJTmCb1q2q+r1hQ//nm5bu1jnlUlv9Zw9v9E8e3O5JEJCv8A0tWugfhPDQQHptdkmLpyikY2N+BZSMTRv2c3SSQM+Yom/cfQJ74dP6V4s3+suHG/2ro0/0r4+P9Qfjiv6Hzx/qz9YH+o8cztUqxrNgLMHzYh6LUcV6ldLLF9cmi/B5j0bM8ficKsrnlhqOZ3ZnuXh955lyKnWs7Sqjy6tLd+zMtTjkmEPffyGN+dloZD/hDz8+c0dJd0BdNJrOlKfbKpf8HoDPmCciqxoMprq6utPFq0uTrVr1Vlg/Fku2QAvLNNimC/99Cp0dczmHeO8MWy4WuOBQOM/1/MUrw4SYRXQO6ypxyFLgE6vk4jWlagMrM4pJfD9Xury+8+fP5UBxxPr0544/NKOgInNnDuCQJVDJhpNU6K9xdm816tZGmuCWzurs7MznIjIzdz/IxHaRl4nukPOqgGSpVLHTWKXaMOo1GnbdDGRyDfV6jHMGnpPCoOZ9MBd/8frWLjS4CiULRlsbxOqhj8TUBZLgMjEsy+XOa8M+j9xPxiRcmFxsnnVuF05K4YpnX0C2O+WMrpR1i+cxiCBnvs8Y2PggVlO16nGZ0qVxQQ0GPWenmsBWKBp14vuyBmzDl4aFj6sWIAVEmziz7AUN65Zi10YG2ArWMKH1ZcilTCHJ/JSzlYuRMcRW85Di7VndqSS02ZZ/GfqF5xGMe583exmV7fgk3VzfvduLkkoG82kOXKzUnErO5bBJfAh1zg5d3UGFni6mSm2yqiPYhfSwyTnqxd6cuYxqePTVSfeoK5e/suC1Wq8oV8oRiqdyq6xivaQecCU6QuYR6azNxRcLoCk0hWSqhSt+FfeX1NSMP0N7zO4GQ9OrbYeXoRNBFxbaNaKtqNzt87jlIORQXKrewMsQE4Osjk/bnvlRAcIW2wF/5dMq+KGzMUsqHnd0ddvVCAPwve1TGZ0Q5tO8ks3a87k6cS6VIPjgkdvtjy1GXqwGZginUjDFaspsSJcfKOv5EVUR3RN6Ii6zrW7JllvVHYZL0kiyAApZOzoJXSEmB2bP7pmoEIPNuA1iu8bzqQrMSJhz4ORBK5tJGcZER0p0FN0ulbi1jbjvF/Pu7rr9XnjLwlKFkAB93Dl78rwBKjyaVQ768ASF5l90ZY12li93tnhvrja2rlvgspHN+d9Z0DGvyZsEloUmTCFkyYxcZPBeCtms6rW6082B+bg8gPbYcBxQxSr6NZyR3s4omSebAJakzbrmEAQVqVcqmhRnmoyxpc5ZG8wQPuzSYGxCWGLWPderV7ee2TCnBC4q1YpqbstGG+jC+8uc/vvfHOvvTggyl/6Zg0u1dhP95UbPsBgzJViwWIRx8WFmhBYT/gkzSeC46QTKOvN1LO4mmlqvicxhbl1doRDdLlrQRpa807khM7rkfL6k/2LnpR7l57pMN/R/vW3rb02a+oP5QP/iB9cqZmMWW6oE/G7nE3IGx+Gw0h9M1b39Wjedlo6PDyz2r9RYAymzQuk8QVCG44Em46Eh+7Pzx2p1airliLWLL157Mh/oD378S716+VI/+NWP1GhVtMvtlAbVwGUqk9WMAm9KcHdO5UrdRuW3zYouXm50fXOtfm+gOoLzArZoVZ0/eqDz844yaC43IQfg7OFWQK6x2gB9chiHZAWID3kCpg9A5gQOFMsh29pordlyqvVuqWKFYrSszBXoF8UuWawVn1XoLCk46So5rCEBFtJRxEKMQm6GUTvzPw5/UCvsCj3GsLg/SD4PH5xZ/23N4ZYoLRCPnGf+nKeMXDqNmgrFmh3Hru/G+sUXL1y4HhzCDoUIQ4ELaWanrn//W728uNHVTd9MceKlOF/oaAkr5orgUmOMMputPHZaQWLDZnC6cFA2BTWMcZqqBGMP9Ob1pjt/Wy1iTZkvuMiDnc/sFvnJ/eySbnro5KKdVuRDbta6ub2xHjzm0+QTQ3KEB7GxdR7WfswTV9OJxy7sQzrEGWlGs7VKy6WOTo7UKjT8z3GhcVZjHgHhD1s/zgAkI6UI2Yb7AXmOdUWgOfp6xh3oy+2TTDA7fAzkP8hPMpHm0+8b2XzHF2VYY+HXuqbCR+8EMcRaibCpKzRLym1Lrs6o2mG58gHPEfkuV8p3aj6goRXzodXbbcN4GNeudiTXkwKfVhq7ND61bMZzxN2mpK+/ugxB8IRDlaBTDgyS4WG7rQ1poU3iZ9Lxzuhqt10fipAtaLcZNCPg5YGSEALxyGSQBsSeuir1msrAJ+W8KjWqrVTMYGnjk5zMZdql1Ok0Pdcr1ap+FiQA1NNcumDrUr1S0Hq283D74dmJmYsQQ6iCDMsCneULWqwSU8mvr5hh7VSimoWskWUawKHIIeCmxzq/BOu9rWw2zPMMc26YeFsNh0Ce3IzADzu7ecDUZEEAXdHVwcrDaQbBMAs/mUzsun/bvXOVWNhDO0CT5VrddHc6zTeRUxwAzINxRUGyQ7e6nw/wmUPgYZ7GpQV7DaKV6eNr4oo2WtHBL0EIAg7FzBrBtzce73eThDbQobZcWZGa7hk0QgtrxtDQ0mUQC8briPxFEhJYgwz0743h779swp5GixsoBDM0ihDD/rh79Lva0p3s4Un+HDA5HpZU6FyU/cHMm3XXG3l9lBpZHSRVpfOgHin9c19/qM+nkW33Xzi50l+pX2i7xCw7sBigVRAC6PKrTYi7QZsgZJmkoZz1rSkVdHs91uuLaxOlwm94qqPjpt7/4JEODjhQ6TSB+zL7jgZDfOKOdvprzTutSjNX8f+P/oH+P/2Gxl/k9C9//8oVOnNp1h9wmYN4IWcVuDw3JvRcXXd1dX3r2Tkz93KxqoOjA716daHXl3eG1q2j3E613ix1cHyu/oahYTxrd/RJwTKMfCajQq7uzM7x5M6XMvN94C+gOToDeurpZOhC+MMPn3qffvnlN7p4davesK9Meq5UF73eTJvdSk+fnNq0I/JXQzri7zEeRoZpjvxSjL07mo5u1O9hpwdBLrI9c2V4Ax2Ni3kCiMKMIrPWPJlal7eYb1Up5FSvNfTo/XNzLb744guNJqSbhN2c8ysZ8exF8yACO8h9oFoEc+OFao0jmu/YKyBWEM4o7imKdgTU+4zCxUu66wNRT7WwM9FO17djFwujcQQ40CWyPkEVXzy/1MXVpeaMVzYZd72MZFrtjkX/k9H6rUVdChIdGb49rzl8VhezjXZ8DtgzHrY9yqmUZn4d/J3OYdv7lz399bfPHE9oFfKG3E5QLTJtA+m518xTBNDt99AkI9miS7ShPPsbWcjYPrqceehAOVOXwKT3odF7gxF8XnP9njWvQKnsQ/YHn6vTP1ah53f8mWFUQjCyOj098dlwd3vnfFnuJd5bs9kxKsSceE5iUB6WcTjzkNvJ33+nFyWXkjsD5yRGwoMd+h2BASU6FSnb5P8RVjpBwLrR5YtL3V3d2WHEAuBaTUvS4adg7vmYD9br6o26JgaQb5nL4WDC4mqrWmlK27Em87mr0BXyByCnKWQU5ldUG+RGTj2XoKO5n6+ZCMLhCtxbo3XnYt/ppz//mR8olzkPmbguOle8VDO5IzXaxypXy2bHXb+68FynUSyrUawqIZJoNHWwrU0B8nmHBa9uB7aHo3fCCurQkTxl1eukwCMy5iLYethNdTeckGRQ9dxz0BuolMHyqeqLnlkqlRxuJbD1fBA6sDdtuHu8mnqGAiyyIdAUsgPav/nKsBPzxnxxbcciNim4fiYXllHAO+X1StvZTIMxJIKeBqNxUPFLVNXMUGil0za85wCiU3Yuu/1LCaDGJYU5CIJlaO3hCsRljisHFSK+linjKzED5POhIi83676EMS4YYIxuOQ6QDMShiPNBC+usu72h+T1hi67V9nfJKvJBSxQ1FT9b5B/3fqh01PaQ3X/ZqzMfVXDMMKhU0QuGnrNcnmk8RDoRsCxFhmczeJzuK2mehy/s/ZzUFH8OCuDZ9U6fT9FY7vTPPhjqn3kw03aZV5LlZ8RBYhYhM1B7JId5NQcse4VDcDjAPWdnsszPf/6VGYpU0ByChSKyjbK7fAKl6TDJjQSmYgY3n5FJmdhcPL3LqpXf6b/28FLDTU5/Y1TXTyZYGzIPm/k5cXgjVbDrUyrlMUJST6nWmGq5XmgwGph9Tm5nuVRXo96yDtW6RmBqRyhFZFlU6d9lDgK9z1UqF/Xw/KEvZ0T1293cxvE8NjRsLOtg9zK7IpJt7Qv7o4/e05Mnj/TlVy/05RfPdH09MOlk/HKk6Wygfq+np08f6uH5sZm9o2nPcheTBWG3L0OaUSkTDD6L8OgpBSeFEHFhKXUOT1Wq1tw9AnnQmTSaNc8OOZi1hmWb0XCA6fa91+x+tGObzI1yuAAxDlpiToCrUdZowE2v7z3I/JdlQ+GHVMg+sJuICXTxmcpo0O353xlFUcAwluF8Y+9PxkuN0fkmG48ZglQDsob2EmIZiNXOmvPFkn00UaV6pia5lsQXkopEOtJqo+WaKMGpL2l+H1LbCpkTPIlSRYcnEImmGo8mJpYBYXJGkcN7ifxnNAk1wBKofGeVAmcbhTfifpoG1AikofQnY6NfMFbd1RNqbo4LzPaF0nxW/DsFIkHunreGbpXmi/cPMkigNElQDodDcVAoGVWK0HRGICvl0g0zhIHo7SFMgtKmaVegIQ5gdjDDQpO0GqILc2pUGy48eL18PjBk3+lFycHlw8u2bRtt6Ays+QsDaAbHwPIMe1nwFWZp6HGYOzx7baunnfK6vQ0zWnece9cQ0t0xTCY7bTrC23XjtIbFdKbrwcCzt2IR7P8iMhqBP/CwpOpPFj5wqAzZeMwyOPwQGbO57fu7p61DArm9vbVAnIoPVx4O9SlaTkczZU3wqdSgQCMZaKl3favpYqAiwcICrqua7sxCtfs85BUBuWa1mm6VS62VBl4qZQ27YpFUa9fVH/J3uByLGjHLo/WkK+PQgFG3WGuZC8/QCZ6wAipwsFuYrNujEkcaiCZBzuH6MmyJqTQC8iUU7okPzlQ2rXa75VQB9Cg2EN6nq5sKns2qOx4qvdeUYooOY5SZKx0gFxJVWORVxqHG62Hju8KF8ctGzRc9v0lmYdPltWIvyLUXNUIOOnmzzaiqK1X/PIve02FV5u7PlTmpGFSPdI1lp1YgLOZnc6KxmTiwmDm/ePHSLOl07kj5SsOsPg4YJAZrDh2g2/uvfRoE1TK6POZE/LO7YFIPamUTZ4jphBxkM/9V6EfoIi2JcNoI+aRlHR53VK2X/X2uZgX9U1/8mn/IX6z39E+3X2o9DxjvXrTuuDRIKevEc9yYuUHgSb1ZdxyMPFOIEENfVBE5h/fmo0cP9eFH73neY8F0mNB4BlWpgPSgc9yv933SRjmT0r9w9Av9s/Nf0YtVSf/EH57rf/z4cxVWQ0PWQJ68r/DdDeLSR5881WG/qeur1yq4sMJDOeOZFrAxqIgtBvFJtcE/DNe8lmOo//tHnYZJndbZg1Pvo6+//kKL5YEarbLnY8DG9qy1sB9SSXRKJhohaAfSpJt7cqpWu6Vn317om6+eazzElnGlv/t3fqxn3zzTD374mX71h59ajI6LUK4Aa54Z2k6DSc9jCpiW7IWb677PJNiQDg3IRvHJReHCJZPS6dmJfu03fqAf/97PNexPNBhuNPxpb69ljpHCYEJi0soHerkYAeLbCoHAkf3Ic6GAYQ/NxpEO4plnnegn4vNyzm7kJLE9MPZ8aYq/nDkTjE64OIBaWTuMLnguXIyHnZba7Uak1mQxj5hp3h/6ImnWy2q1ai7Kz06PfODBZMXrmv1Fp8iFaUIQ82IIRNmN8lmeB+SwjIrVqs/zoxJGIBt9/fXXuri60ZrCfblw5+vZKuMW5ptkbFYrzt3k+9l/G52lxx47I034UuPCxL1hvSsjFfTmaHrJ/SQEAw0+7kepVLhz2Yt2peuLK7UPGM+RnQpKicwn7T0AeQ/dJg5VB20sSSu2CIXpT+N20G55DwwHPe8nLsTZeKSTkzOvd7PA01mbKwCrv9OLklvdfoBQ93G3d1QKeqqsmYC3N7fhYVkoq9PuqJyvOKGeX6v5RrcIjuc7E2mA2QhsBe4cD/uaTu501x96/oLwHGJQq3NsAgkX18FBR6cn5zo46BlKQf9FO55bRqYjFdD9QVitRgXL0JfqcDXBtSTteSrwIbTxcqVGTRz6mk3kR7KoGQJXgRyAJedzzxU40GYI2Quh6ZsJXSGpCuQjcnBMNR2N7YN4etBRKZPnZtOo13WILwfOZNjzPLDdqNi5pEDcUBrG2sxwbk6hGWNmigFCeZc2zMw9CcKEO88Wk9c9kw3iExs4bP0QERdtxkDFBgs46xinmZ8RlHVMEvCFBAZlxoO3K2ctB4ensHyGJq5EhiJzwy0zCFir28TkD9LXt2gqcc+gOsamK41AH2u/jYXXXNQenqsQPq3MDsoldZp1Q1ZAHmwcFicdJt0UP8s5n8y+HU+G7+3cqRERdQTsPFWlEpFT6yRlNyTHlGGUbrMGGImRJLAh1srC6bcZifcdAdCn8wF3GBlElBWXGBpW2L+sbWY8TlKYkDCCxdWhstmhLvLXzvArlXN2AarVc/pyntV/9/mnmm0zKqc3+qweoctBJggHGgpBujdgthB3UyCwbnnfK8/zeS/M6Rv1sgs7GOB4Dj8446Ao6ZNPPtKjxw+81qmQYZDakYr800Xi9wJ6wAUcxgJzf6bAsr9amenVoKRvFkX9iy/e0z939o3K25BZQawCbRkvmRVmzcB++PBAn376yDaPXAhA/8zC+/3I4eQLuB7jDA5+s4xNSY5njTa0kYGUklWzyQyJC4CoMOatkFYouIJwwbOA9coohpmsJRdpwgAWlpdUGwV9+tl7joUjYPrmqqduF2P+tX7x+Zeed370yRPD7kg+2KOgXcNBVy9fvNDV9cDrE3iW5w/TslyBbc5s7h4SJ4YMbsNan37vQ6//n/zh50aRQnO6tCc0ZiZb1uoCdv1SU5y+Gpw1TR0dtdTvd3XX61oXjFGJZ+YrvjeaPww+Zg6StwQI2cdqq1J+oe0KFCZkD4yRIuKLEVHL8XNA5KPRUINBWY8enXrMgIHGctVwEHR0iRVLM2DjN5oVz/oJIWeE4Fiy5cZzQqfAkBMKorXAuL6gFtpFLkCkdSCC2axePXuui+srzfdra2cVVQQWsKaMzO2IAUwboXLk2Z4o44SaXYRK83vVyv4itUvTvX45WPGc1Vz4/s97Yh+3Gn+eQpPxUqleNvmKLp0zmb2OM9LaRM7E5w4MX5j1zJyBhul2+XN0pUC5vGdyRHk+IGQmhBXJ3yypvxq824uS6hmohssM5xN3krBfN1mHvfYue/r2m2+9ENIfpFU6qWo2mmvYHdsRJkl2uh3QnS19SS7nOw0HE82mY3UOGlokc3/oeGzedV9rkXzpStGap11WpyePdXx07I1Lbl6IjaE0h2sGDhJ8mMBD5CCi+oHV5QQH8u8cwMxQF6PgoBCH1iwONS4gzI6zrZxKWH5xYE/GlnnUyxXbxm23S80R8tPU5nOajibuetlzudROp4dHalZrGt721SzAXKRTlYbjgEGouphFHtQqurzqqQD7tFZ1x0RFZas8s+4qhkqotugEGdJTuUNkCU0gTEvSS7ZaY23lai8o0yUumByGywzb57aMUqXs7m4NvEmvAiqA8LjZ0vVd1xUe1SzdlsXV7hgtndMOpmq1amu4+4E6ZC4uFOB0iidYt0BuuP5vd+TTBbsP3xcHOuchokRR0x+TtD7250FXwkUPK3oGc5goKIb3diBBY4j4veY1wbMJH0+6Jxi+iavhZhN5DYdveHMioUAQTRFz/8WFlc+Td4ixOuuDz35tLR+HB0gIRBDWBa8f1vN93BSQmtMUssF8zjl2DHh3q3+t/1DXa0J2t/rPn13oP3M6CDjLnVrkGA6HA5PSlgkiel4TKQkwVyOVAuco3ovzOvd5gI/OT72mj48OVC0XzfIuYzAv3EeWPjg5mLiUQRUYQfAeHV20mPlwpPstl+v6bz66UXo51f99/lh/MG/od5MTfdC49eHszr1cNKLitJf1XNVKXUdHp+7QnYvpqKOdOoctz2yni7F26ZUJOtV6wZ11O8m8sQvE5eazcs2oEOSjUjlyDskw5T0DQUcXHXPSRiNrL1A6SdYFzxc4DWYrpJMC7jbplAb9gWdTFM3AkIVS1pDgt98+18NHx/ZLtdcrWuR61edQ6qbvoidZEC/VN5zd6VRVKNT2e590jrRnhwSls+cfPj72M7y+urPjTbKIqDdY68zcbXLvaLPQCSM3aXUgM2HFRrABZ8tcu1Tk1no/EBY/SNztMEOk0GSf4a0849m7SETWlqi03vrZc+Ex3gElGI36oRuejMyP6HRaNk6BYMUcM50K7eRsMtJ8Ola51bYJx2Q6ctYpEGSEf8PST4z+cMmQhARXwT6sWeQ+Q+9pWPlUvFzcuDxliTQDQcJMHp9YeAD2YY7PkUKQC4k9TfdoaYooPpnPhkQQiRcFO5ep9akgSOzLXC0CnZ36A+oV8WrsYS4z9rr3pRG8kKUw4wZyhvTI66X4xTrzXvvKZ8FeYB0B6yPJQzIEIjEZhbsYXxQUjfo7trBDgsGCNROSAbWADUMgTjhFTkUV0yWVMmW7l5DCjUMMVWAyoytYK9kxvyNzreDOEH0PB2mt3nGlAh4OcWGVpM1QhKqMbhxz6tHod/TxR585VPmrL7/1Qo15aegNHXjrPMTQ6AGp0dIDEXDx8Atokc4SCMyyBDv9c4Bi5ltQtVTykBk5625JBFFOD4+ONEoNNOkNNb7te9MBdfUnI+WBVutVGwm8/uYbPfvZ5zZdWI4nXhRkTjI8brZbKlWrdsI/PzzUi1e3qmRShvwIzwXyWGwhOHGJS7VyQaenB56vYD5ZymYNL2AVyAFIJUkgNLOB0ARCwAE2RHy9sbkBlS3PgqpqvDdcdoYklwwZmlw8hqkr2nX7vqjXFBpm75J6gHVgPGNSETopqdGKNPFRt295BdmhfE/+LkQbGxcA5UCtd8B02H9Bg3cVujcynkDqgBBWpLPOeobDDzJfyCScPXkI8gGh1+2iZxzu1jj4gP21NnOWbmRhrR8jAJxQ6Ky5iN52lHRGTkNgs3s7xRcFXya70WK+VrlWdAeNUTbz8QWC9vnMCe+L+VT1Bt1eU/Uqc5ONfnfW1C8SDCuiSPpPHV1ptQoyFXq2uNDDtou9woHH/DeZAKeihyWNhMKk6Ag0oGaIO1ijffrJB17LdFKgADi7zKYjrzMIHxjE05070Jjr0yhPxqNlnguM3ziQNl7zf7V44YuSr/93t6k/25rpPE08GzNa9H+h0+Ow5SCnCFgs6CB5VomhyZOzQ93cVXRxldWD88eO1Ts+6UBfMepyf1GuNqAaIedBG0xBujL7M54J+459yf50WMV4aJE90Gd5UNJ0NjLKw8EWPrkwjRN1B7d20CqTFdqs6cnTc337/At98+1XqjXzOjhp2IQdhOLouKWPP3nfBJCry76GvbFtILEZLJchQjX31oyR64qrV7Ve0qA3Vqma04NHx2F+Mds4lgvmLWjAzU3XBdw2xyUf5wfwIZmbzmKs1wVes0xuwnMXl6QibG3mPxGkDUTogrZUtAabQtiFug/5yOe1XeCgbxcsUBPPsdcrvXz5whaCSF580W9WOui03B1zeVOQMKrY0ukyGti0zQvo9cc2tMAsPbWbK5kB80c83n0TQQHiEcwqZpScTSbgrWKNOt5tOXexCeuc7vj0+CQiDMeTyJbcEl2H2QL5tCmzgud7pIu/n82C5gQ6aX9eZv2MNFJSrdI0IoLcjGYGHgRogHX4zHZhy9tsAcSEj2djlr0LRPJbsdZDl7tHWwajcEFi/OU8z9lUQ3y8zYCHqYzdZlGL4jsm88DDpNqHWcRiRxycJ56JWz/ZqlZu6fRoYxwd0TywHCLWaqWlySrRxfBCm1xBtQKaH/Rq4ZyRh+lKOkQZj8CmPv/8a93c4EhPmkRRecg7uMwnS/syRr4cA19YcztVmnVXORygFhWTSLDABYJDinnHA1dghl2Bw7JZJalEUxYEydrFokrFjCqQUgp5M1UzzHvwH4RpgPh7kejm1YUWeC7OV7q+udV8neij73/fNPVdDpeJgS6fv9bwrmd3IJK9fVHSkaw2uru81sPH76nRPlBhu9VBnaq47O5uhgbLob1EfGGZvVarXVMhs9MU4lAKR/yiVvu4qLiA0n79QHN0Xql0omEq0gWwbjKjzjMDWJXkYmZ9QHmzEI8zw+1o5AMVjRKblO6KBcxhkL63tsukTJxx9VVtGNbk7wCRm0yA4LtWcbqMdWHQrzfoWKmSw4mEipTDlq4dJxuIC0Dw2c1KhSI+kkXPU7nw+R7eEPTEQPx7c3wOM1jNob0LD2BmqHi1tg8ryuwZsCnsqyB92cUnvtbJWtM1jGgKtYD+4gLNKk+ie3qhVGajdgo2M+Hcc3sF07GDdNTqJdWbD5TJPNQhcohyXi8nZd3C9pT0v/rBiz18tTfpt94PSAmGYNEevcykIsIJ8wCYzxOVYCq2yH9M+b1gjAG5jW6dZ0BXwAWPkL7Xu1O3O1Cz3bEJAs+RAy4s3dYq5Ur+vDgQMNfmwOIw4ReOcv/Vxo/1Pxn+UL+clfS8P9dJNfRsrAus1wJChxEbLlxY99H1ILBH2oQeMl/YqnNU0kcfPdbD86PoaHd5VVIF6XpfUO/Q5I5MWgNmRcIRiC0dQciEvM63mFGACFEcZe0NzOE8X0wMzVM8puEi0DnjkFQuaFkl1D2PaZVlHcxAX76eqDe40wepc78eZrqsuVa7qvd1bgMDZBDDwchxbM1GyczhVosZM55JsFcTFctFlZZ5zacQDvM6OmlreDc1fwBi0HgE61lqNOr+/CAscYlhy0euKDptChegRsT9jBOSBW5YwNdBLATBYGPZmzrBQSht+zfQqU0amBr0IyQOFMmgd5Fvy+XF5QzBZ6SH5yeG7pkd21lIQPyR38kFBRrF/A15HOiO2bSk+pD+0yBCL2BhPmwKWchbdpvKpX1xAmWzp03A0dwXMXuwVSvr5OhYzUZ7H0wuDSaciQuv01KuaESvSMdcYnzWUTc11NX1tWfnmN/7sywUfSmy3rnEDNPuO0DSR8jdZC5K8WaEcJ+Be79xQSLIfS3RgODM5JxfslJhnVOQLo1SgawQ1UXhn63Wwkd8GWcPZ7Sdz/a+u+/souSN8oepkniAVAr48V3NBlqOl04tr1VYgAd2G6FziIMSicFI1VpTs2TlHDe60lQqr+vrK1/Bs9nYJr8vX77yAchhM4Fp2iY4tKhmra3f+I1fM6zz+c9+rs1mpuWMfDXyzUijr3tz5BCqe95SUJKwufjgthoN+64ibAZcJPpmabkBHwrQViGPwz0Pca7VZKPFeumLjh1JxTQfjZTQoUHVnydqN+sq1io6bNXDHQe2HT6HGeQMDJnCZqlWQnBb08FhW8PRRL0rUtaHSm1TFv/mK5HluB0mb6oxBuJAeevlLIyc8/jaliNCKlNVlhQDMzOzqlRr7ggsAcEzcZU4/Jk5IJ0yVZwZpbwmDNOZaSwXmiznnvvRbQAP8XWMF+Vdz3M8oK1etxdG01sYqzNdXF6ql+ubibZLOIADYYBxCFFnPYdAA9UdXROHEzOLgIqBVlxR5hig111kzHsDd/ab2U6r7FrF7cbSFYuEPfwnpJm/x/tAIwnbEFIZRviJu78gyGxMEAjiDNV5QLx2/tl/QYbYFMOEm//uy5c/DykDA3Wi1RbMYqDGH+r1xY0hatYv39ewN96jWRiJGf1sd6D/4/Dc37uQ2ur9UqLcFriVkPClO9Tw5QxHnOmMKKrIwDP7d+/swvpFCzkcwnAdu6qn8HGmKhf+fGaiB//OfqJ6ZnYVUUR8/3Dq4dDi4dBpcyE1Gm1ffJG3R05rSp8AGY8I/U7rX3j1qf5vv/qVSqu+kgyji4g54zDk9YcFGfMi5uBRtDDrhmlabRbV7jDmmPnAccLN+i18FR7BkeaDTjq95vmP/fpwBKJj8nKks6DI3GJxRorJnR48OHMSBoUZBzyMU7SAMFI//ugD3d30zXyOnNelDo8OtE19YNjcMjAOXYvMd2q3a14rFDn93jR0hasIPB4NRxEwgNlEDqF8omS7tMTg9etrjdBgN9GHluw+NMOAex6FgzWnmJbMGAeQPLPSXXenyWToovLJk8c6ODi0vAavYy4lCgXDhSXOPchLET3Gv7faDXdUGFkAorjoTQWxi8uVYgoyo7Mll+g0I1CA/cF6pNOsdkgpyej68pUL9g8/pJsGYUm/yQ/lf/kFTBukLDyn+VkR0J6sF9oAZ6EeLoGeVP0M7AKVK7r7I90Hpj4Fde8OTfvKFxKjBkiOpK9A9MMGstZoqt5s+bWzdu4tLS3pw5Upn9cJwQnsA4c6B0fBWZbLmRJiGZG53RdLNqqHuIbDWN4yPxA0kw/5w3b2IT8V85G+x16geXTjzN6B4LEpXTYg/qw1GZECFeTUd3pRQhaATAKMZKcT5fTNxQt9/fNnmg1nvigJOqYKBsOG/TUYDfXq8lJXNz0Vi2SoFVTYm5hTId92b1RrVlWrI2qdq33QsD5oN1qpVKON5oMkI62kB2cHqpQzKhWp0ndqNqEFN1XI4qoTG4SOfzAAGs2o9fBMdRs7Z+yHymHbqFf9Qb/KXapPZwx9m8sttVWzXFIRl6H+QOlKUdtqXevsUpPeQOvl3CGtOSJqiKEhULpUNMMM7eVoONCOAf9wpGIm541m6j5h0sxAdzu1643QV6131u7w37fLmYr1mk6O2sr0h4JoSdhvZrdWHjC7WvHcYJ3gYlOxrROO/rd3XcNVhKjWV1iAzTQYTnzx8eVOYxURSyxCa49gG26ymixYiJArYgbKF4u71ELOUom5leG32FwYGtDFurrFJAERMP6LIALkdiL0ZVOuwq3JbEyDZiHtoNvh55ljuM8N5ZfzE9f4rYZdeXads9uI4UpYp3YkiuDee2YmkCVzTdHBpEpqtNt7iQKvcJ9CYfnGHyvy7s21LesIuAdPWlfqkFKQKfhn4rVZ0oM0birAWMxcUj6sIJv0e121Hj80VByhbtK/8sEvlDMaAAsSeKuoYnmr1HBiJisM67vbgbabyP/jZ3GBQHcPicbWpAWuJqzOmDOZWAGsanu9iP5i3xkmJ7R3EOb+UPMxkrDbC5KtNTR6ikFgzpymEw6HtC/X783n+uc3z/QvXbynJdDyYq008WFbWZ5weoLPKZ89FX5opjGvwN2J79tL9X1Rnz84jYtpu1JuGbIWuqv7Lxxw6qWWqrWw/+OzmJVKhu1YbxzadlDxjUEhwRXGPH+j0XC2h6i3nsseHZ4Y7oQZCzRKh8b74j0CaZY5lNush4hPQxMKMxOSSrGIdKGoTz/9WNt1QV9OvzYEOIEJSpe5wdOWy4oOvuQZZjaNrvBIhWzR/IrlcqQdGbtZtMPGlS1N4JKkoIBzEDpICpeNitnCPse15JB0BxsQi1cv2UUK711bJxKMDSmF4O10JgxLQF14EpBhVmsN+WDsP5xRGbewPVGHTFBmtVNYwOvEBRFQ7umDB97TWAzixxys96YZ7gTWU5SB9HGZZbMgb3RrO89Bq/WOO83w0Eb7SvA3lEskXzO7GRFkMeqP1Fss3K163IJhSCajk+MTtVptdbsQEEkhwsSBeTR5syTzYI4xCVtITC9AJkEuOH/yUYg6AgtkBM0rJMnx3HpqE+JS4b3sbN9kaw4FsjBGQ89fvo5EqWxWzcbUuaHA6R6REDtobkqgZRhTwC+oVZFkgfwQkF19txclcJ8DcPeHzq4Q2jAutsUoZABcAHQ0pXVB2SLOMFv1Jn0txYOeqlPK6PT40NBet0t4LOLgqivUDz586tkLrK/0L762Y8nhAabhFR0c1VWtEqm00sMHR+621iscJcqeI8AyA3bi0NOGwXRK548eupKZTKkGQ6+32bR0cnTqCKvtfKlhr6cU/rVUNEv0YxNpNVVSKxtCgXzBh1UrV1RlZsIlR5TXeqUh7kOpjUkFB4W2alWqrYqmw7FeP3/lDGtDaDNE58Q80bWWVCN5nsy1XEbLzVzlUlbtoxMPvu+wErNOTSpxwQPB9Ppmn2G1lClUdddjdsEcKG/tJxWpB/GjiWY2m84GGYfcRKK1XKmtnX3IRcF7ovji8rTZMYdiloNzZvYc5ghQ3UvFrJIVBxdQezDy3GWwBjjEuYB3GyclAP9x8LGpk+3eyB04xQ4wabMrObzp/Bb7+aVBFMuN4nvSwWE9Z5sv9IpYlHFROBSaLhXtXuQswrjERILuI1h294s0JDB0UPeWeD68rWOLTEnb8zH/wAkkiSrdRgrWBvPMcGaC0HIYsCD9FPBhhkuoo3Spoj9cxOb6tDBSWSQtkDoSsql8AfgHCHCv5dwxWsh6xh+p6pEvyqXquSkwXAbvy5YNnJkro0sFXUinYBWvfLnWsJ3LZJwvOp2MPOLge2wY4tvgnceY9qV3L3a3rCHL90G+tdBBaqlH+YVeJEV7w/6jeS5lOm/s6KruDolNY71QHEQSBb7FaQ37MxWKrAW8l6H5p5Ul0xTzg/Hbqvw+FxNojIsPKQPfBx2ojR8ciMznyieONGvmeboDodNjw2/lcjW0syATKWRLC6NUkwJ5m4nanY4Ojw6NOKSzQPlIViJyyzaaO8YFPb/mVvOBO7xvv35pS0QkIxjcT/GVBWbcpXwOtZoHGg9nulkMXMSwhzJ5/GXp1oHOg7lK52WfKwh0xOw5pIHnXjE6AUS7Tm79s7AhpHBC78lFwuyVEVI6w1ggDFVAedjHEOp4dvlUznyKjpGDyLpE4sVctoIbVKPp0QI/mwuGcw1CDiMJkO1kxViCYhjpHV08ZxgXJZdg2SQ//HJrzQh4oNAq10pqt7H5K5hzYe4B7qgYaU0nHmE5qHnYt9Yyc/44DB/cCcae5UF475EAxIyRyLzN2hm/lpIBg5KYtE8SQhEAFc2BzyBBzKMzzIMzvizn+bXPQrrbzZviH0ej8IFF481clOIAT2kKd0ZOnIUk4DjeC/Id89sNa6ZpZGMLzF7kpCkrk2JfvWMyD5Wanf33xB4gxzZpAJWyRr2JsnmcJyq2yMrCGlxOlKsgMC/pbji11Ve5iuNFXqPdQoeHDaWzLfu7npwe7mGzrf7cX/wtNTsN/fKXX+vs7EgHHSrLhl01Nms0gDk12xW7S1BlyNy1AAEAAElEQVRdFAopi/ShsLOA6fwISCamhwqu273V1eVrw2CQJsb5kp1tqDi2i4JqHAgwGgnqRSeHBR0ehHRkXCzFgqYkbRBBBCMzzQbHXSSjZD1Vf0T129bB2YHt6EY9GFYxl8y7c1l6sXXvuv5QKkXgp53T3lfKe8bKgZBHJI18Yp54ZlQiMBpvzFRWo+VU190bwSPFaB5dEQueeKrsdG4t0wqmaLJyNBXVOPIY4LpwsghLLYTA1X14Ml0AlVfmPpyDQ2azVqd55Nc/7gMHcoGYZuANC3xtMJcLMSGlY6vsDLOCxCbKDty2wD6MhoFu6VZtQ7WL4GCgXypBLnAOGHd3+MPC+EP2YUZcZAzGTCJSz+mOORzobCmEdltgzoV9KGttZiJhFu6gXdh431m7/GwuHgoHc4wIrmUW7eDuYI46ogcHkeFI4zEIRMZFEV0y8BKzJnRYz8Y7/a9fB4nnr9QudJSJXE++zMojaWVLsCxQU3RYjQaG+PM3FyXz8iD5AC2x1hZaplMxb87RVYQnMIYHnEGWAlleQqoEYblculOvcyB43u+95SCFDQxC61NTecs/6Fjm85W+X1jrN0sDvUhO9D+9fqR/9HFf283MP2O+Rg6xsMgcGJhg8HarbWNqmKHrbXAJZlP0uzPly5ElSaFBJ37/hVH5YD72RcjrM2txufRF7NECcXkjxO0zYXxkX2BCE/icgVQkdTpEWvG9Z04qcrQeXWK5qCFMergCWLoxy2/h0ASRifVHVxIh3MP+VL0ec+mhrl5fm7nKjJ2ZZPe2r3YDWJEim5k2XfpI4wmEEcJ8j/Tk8UMdHnXsWXx9eadstutCkd8fjZm1MyrhUqtFIonlaaAQifq9kWej4auLDd/CYnwQDBjLdKNbuqUCDjEbO9bYCjSbdZFULZMDGg5i/AyjdDn2X8wFGR1RwlEA0L1RuE7p+CYLS1FYd3xv1pr3d0aeB0KEcY5sbqd2KTpIIHzmpvyZXIE5KsfAwj6/cEzI39xuwmmNfYc0DRgaCV+92TADH2MEiEdjgi72Jh5wGMbTiXrjiTtFSEx5OlFIdIy1kJeAWlkxgKNZ6q2tZG2uKaRJQ0PsAXSqWALiQ40Nadr5vFggci6HTI4iragCjkdEr80XLrCzdCyMI+oVzdChOux+50xMihUKsHd6UQbmzfyN2KClH8jJ2bF+5Ve/r0790vmRpw9OzL5b72BU5nRw0tZnP/xE5do1haHODpoqA7tlyqpgfA5MVCnr0dNzjacDLQhFxaC8ntfjpyd67+mTSKZOQ9CZqH7Y9iLgUl0nM9z8XH0yRM5nIKEsjb+zQZ0ysQ/ohanFIiR26/rqwh0lspTVYqZJslO5QHWXUqdd98wSajJD5vsk+BQHNLZqWxIF8Cgc6+T8gRpHLRNxiAXbEOdSJCJso0anbn/YPM9rvdHVxSu4iE4mJx/SUTAIuV1ZJxpMRhoMgI1SyjJ3xYhgkahRCi/S1/NbV1MTIFhlVc2WlIFkRETYHEIMMCubNSjy4XJBAcCQP9yLDHU6CxgdXlnbBgYPOOGsrZnDro7BNhqkVqel3u2NGYn4NqbtwJNXuVYzxMT8k4OAkiFF8sFqqUKzbTE+Qa52v1mt3EnSRbNxOIS5SOzFiNaMgTyWfjawiBBsWJ2Whez1WKZxbtI2M+fihG3Mn+V7EXOVyW+tsz2cVK2Py5Pe4VllXMD3X1zqYaQT/pT2nLXOEeMH4OWloSr6Ikws6EQw9G83gaRqexOCuedgDpvdf0X6SHzfiOqi8w3IGyiIQ5W5k51ZCkVXxVx0dNc2+ba7FfAqWjpMECpusv2cJtDtI4SYC5YDFsITX3QaPCdLnpwkH7R9oHBHm00T5xTOiTPa5ZxNiqYY+H2Ui0uer+l4qctX1xbYm41aqZjlOB4vfCFOJ2RthpCfar/WQP6DETVDRpl8s173tcbLef9ln1Ul5iYU80FCS1Zomvf+nyAq6KCnQNMQnpCAkXk5c5KHQ84d6o1Gdum97MNuF4G7ICe3N+gKRy7Q3v/wqR6en+rgsKFtLms993Aw9EGIG894cKFXzy/cmTtjFL9nrODmW7Mz14uN0aHJmKDghV68eKWXL28MFb///iPPLenma9Wmbmpd6woZK1EOukDJA1fz+TInXWuR4B3MGkffF0YZoDhcAv3hrW0DWecUtMVS1VCyn1vCusQwAaP0RIedQ+WZJe1i9kxTkJ6TvDK3fpRmBZQPQmAE2MdskW6Y3EvmyXR3vMZgGPP8KL4Su/FQJFCWcEQFrImTUFbL2dRF9GDQNQkOwl7K5fHWmZq7A8wh6IhxOYoCa4y72Hhoe7p7v1/gaJPvIGKSD+pZYEg3nNRER857xcsZK0bIn4g9MfyvlNTAKpWYPztfJYZ5YdVTzPKMrI+co0zgCsMWEnMDbE0LSm+Ik1vajYvfHgyGb+LzDprtSBdxnijfff1uL0pfGPb2DCo6VWuxktev/vBX9Nn7H2ub7HRzc60Xz16qWMvp6cfvKZ0vqt7u6NPvf6Y+mp3unUOYC9WM2uW62p0DQ4Xc+DC02PTDycAUecguDrZdY7qe9X/DlYGD7PCgbbw8tHvZ8B+F8eZOoeiH5gWCLVwDc/OCNw9VHVmQkJEmva7m45E6zZqajY6266WrtpOHD5whyeyB3EMIFbDTsH8DnhxNR+6CTx+eaJtN2UovU8opDSy1wr9xoQIMN+yUfHCupVxGx+enrgR/8sVP1WkfqnN64NxEDkFmVhfXXc3mKz04e2StJq5FWC4VEY5j7MA/p/Iq1hp+XxYn49+zQqC/dhQS4QHMCWCB0UFDnKHYR+phMb4F0AtfZq72k7mNCFq1uo3licyC0s2vp48f6fr2yrZVVL9GSTkcgFgR5efy1jRhJbVOpz2P5ZJFDOyFuwLiKBtawQ7rttdXb9DXik25947N2pZvf+HQNVF5IpnYG0jYVi9cK+3EFIJsZmbMIUw7cMcHCsSft1YTMTtiZdqk/ZcPMFuFoaELs4p72n3GrjBzd04Ov04jA7hRoUCiAvuaAodA3ShE7sXS9xIWCjFgxpjrBTMPdADImddFpW6pjLaGteiUYE5ywN4MehoNe/YUZvZHQQHczaW72+85qmIuTuK/IDawBoEvQQsgq/GcDddWcIFquPga9Of68osXSpbA4QXLCjj48M/cvPerZtLwkn77t3+kyxcv3DnUG011Dg+8b1brlHKlkobjhb759irmPIWUTh8cKl96omKl4MuYC5ROMTt7C71SAGSSkbsmii+KEvY4xS0FC/FOXByPHj1ytNbV9Y2mYzqDrcPYM6ITApYmBSjROh8kLcYr7JXrq66LwzCo2Onyoq/1OqWrq1tzGkBuwukp43in2QiZ1MrZjDzzp08eqlJqabeF9UhxUIp52nytVy+/1fPnF9Zz//RnP9Ennz7RX/qLf0Hvvfe+JRmcfzDIKbjBIfg71krTGQEJ0h1RIOfy2hKctNpY/0lXDQRKegbdLgSU9Jrw6DBdgNFqxq4vttSelBXrjA4fRjlzSUZZrMPDkwOboANDNjtt8zQocBrNurabQ3XvrnVzc6VWu6xGHWUB2mT+DMVoosliYN006wsdKAYGQX7bhawNw49CRtlSkKl2q7RW+bX9kNlHmy02lQQlIEMDKVk4Oo+fw9q8L0x5FuwDEBfOBXysQejowplPoobgzzOyo1N0kDTFer2mfLnq+CzOt2y3q+5uEJ7Rey9pzgJH6dm7OYLOKQhYjxCWet2Rk5bY887UhVzHeZzfaDGba82YysSyzLu9KGGyecODS1M9Z3bKl7JhWVcq+DDGwxUz40KdyKyKDh4eGmqlyq7UG9qeFdW97tpqiEoZDJm4Fg7E8yePfUj2Fl1tIX+UUuo0qxoNBtomSy2nOy3sIgGjraNeB7PcjZLdSv3xWOPB1Bfi9DoCnhFCQ7TJF2oa3ww0mQPt0JGsdXvb1Qo6N3mYWCAdt3XQwgC6qAEJ33cs+rQ2HEDIBMDsWWzozpp1M64sJh8NNZzP1S5jjs5BudPJ4bHWo5kS4mHokhZz3Q0GqrAIyyU9/uxDHbYPlG+U9Ojs0CSVq9uekxmQvgz6JdWAVlcrX+5ceHb8aTTVn+HnWTAkwfcu7me6+EZSJfZdZSNiZ4YbDFRgGQ5xGLk4/wCfs7mRBRzgEzoZa0snj0ckaS/bnRm+OF4QKzTO4/KCVWFezUrV3dLFxZWyON3wOnzJbdUdDtTpdFQoV7UCpjFcuMGXxYe6c/NmM5MH8oWS8qvoEvm+2CczKwn3JC45nJRCFoIBQ0CfGCkwe4hEhlwhpXqtoGarYo2jc4n3nqowNbPZt0N6SEHuBqHSs3nZZGleBy5EWRPV0Ix5zpNAPuJgohuqGsLG5aSOrmy91H/u4k/5e/4nyxf6rfSVBt21NzZJE0hvkj2MCGRWKkEQQhu7MJubtqzBLDKFVd3EpBC6hpPjjuqtpl838zouUwgmOCctFxtdXlx7nsqeyecrSpI7FYspFbIRz8V6Z2sigcAkezaVunckgzDjQvtWUrVU18fvf6y/cJrorjfRj5Oq/ueP/rr+7O/+tyx3yZZWyozn7j45+Ejn4WImh9OOQDQLNzdK5db69cZnOkLWktm6W+BAvP+iByANwx1zstJl71aNdt1cBJO9shutyJdUXo8eHphx/vOff6lBfwbJW+V8VasOYxpyJWF87BzqO51s/Vrw5gR9gS1LIbZaZrSYcBAuNM3h6boNi8Bi2ZaYvdXEUCGs8GS61s8//0pPHp1qMW/p/NGRIWsOXZxfOIfYIxQ1GEF889WN2o1fqlZuG+ItV7M6PKopnXqoej2vZMpsrGxCjUk1tN1rEBrMWFKa7phHRreH0TzhC0DE6+1UO0IimPVm8BWumX9BkgVdz+HhsQmM7Bsu7cF45LMRBCnZbXzmsObwxW40q4KETNRZPgfUCPFnqXKFSyA0iKw7oGvWFwHZN3cjPX95uSeVAcWm9eEH51qkVjYYgAWNIQxdJB3bbA5yUVChAjeAkUnW3Tekxult14HufN5jCIWLuaFVIGe6SIoH8F8SThgJgToR1zcdY0A/dVFcU8qB8aBVmH2g87ZxEkbwS1jYOeXQb88iHYpC+x6CXScLNzIgQs6eTG/18ORIlRyuRROVC2Vn9s6niRq1isdFsJE53zDEoPN9pxdlmE1Tc4TJtbMGc8AKGb16/lrXz641Hsz8gta7re6uekoXMyo3i8qXwj2fQz6TOTDcgXfjcIBrj4t2vX7x0vOWb7/5xoPiR48fajmfOmUd/1LE5fPpwkU+2hgAdvR58C/w8R4DqS0JcF4ZcuQABxpgsI8NFYSYCHNlML1VplDQ49OH+pVf+74enXOhh1/pN19/q5vnz1RK59TA8cFpFhwIK1XaTetFp/OJeq9eurtGWoDfKaQAXGuWvaE2k4U25FQSCLynrdcadc90Dx4eG7ost9sm9VxfXunHn/9MV91rFbIFdW8vle8c2rCBCgmbv1y9ruxsqUJ9o1Sh5KguwkzZPDxrKtFXr19pNplacEznGCnpVPABa3Lp8RnQpRdLzIpLytPtlQrh4A/JBjh0L+dwdmSprIMOcOTMg/hOo2mD9e4tWXkYWUfhCyEBNuzNPoVkOSUtZuku3LArNlzzmSbYDm43ngEdHZ+GYbVN0QMiAs7bJQibQ6DsjhQqONZfJrjgi4nShUssq4PDmmUADOypuIPMAxKQaIELxv3X7jvG5I5Xy+41wZhMA+VH7mO4NOEGVNdqifXc0gkYtNNU7Hwm8E/5oqNI71L2M+bvHWTbmm2A9yJzlc+YSpfNTKbqckVlzRw+BprT2djuMYeHTcNgt3c3ezIQCTM4wOBpi9l4zjpTHKn4LGHldtrHZoHSFdBtm/iThmmIFGWtr798qdcvu8qkCs4aPH90rseP8ADd6Pd+9++o365KhjeBq4sx00VQf3un7l3PpiBJ0nOXj37VtsTpSIaJcy9mopBoTIBymNrbQmW2m5pclLKO8/78CERgAXlnOFKpAGGOS6Ghk5NDXV78XLeXAxfbyBYePQ6YGdg2h9xrMXYBQxdAwUBXCTN4t8navKTeKBoBIPWDZBn0fq8IeGdGhqc0mkk+l9XKfs+Qm4iXgq3eaDRiHkgxli3YHUk7SB5r3VwPXBhiosChSlh3bZnXclHSjtCDMvyJMOqnc33x6srGCHgHUz8Y6bKDTcbdXK6QMRmN0QSzeMhQQI3aRtKO5Vx0llR+dvMCNQo3MYri5YZCh/SfhTJd6UFyrHqlbnQBZCKf3+noqCmmCqwlW9Z5T4f7FmSzQglv37m6dwOlUlMTEXvNsQ46JBdhtA6CxSUE/D7TYra1ooAiij2BsfxyvTZnoXNwqN2u50KYYtBdY4l1R8IPHWR+ny3ZDOME/Iznc2eTQkwDhXKeJI0JxCCkMPZYzuuu23Nqy5bPbR/uzPkfJKqUL75Nwjw/MemS728yEIjf6ZE2SdPkMJ4pd8xgMPGYybF0uJcxxuEce5cX5RvrIZiDuaxyYMXzlZaDpa5eXer64la9m74r42q57sUttEF8wDnIF+i1gCjTmiyn9ka8vrzFMlvlYiR7MHch0Hk8Hdoonaqpe3WtCR3JYGx4LFeCIo9rP/OinCtMM6CsaQKWC/4k2izj2euNh8x0N/bwXMPoZCZHlFTFuB3VpgN6V4lfP51VCULPZGa3IOZzxH+xszq1kj8sxP+lSlXtZtvuObcvLzS6G0jEX1G9Gn9feT5VrtfsoMM/b/Np9cYj5To1x1RtxnltS1lNVwsLd4u1pt1gnKCRzduI+bI/VG+eaJVCuJ+LyBkIGlhNZTNK6IqIPFvjWrMwjGPzYS6/vdepRbppkurzFoK3Dlrq1KtazeYaXN9qPBy7+zGxKJ1Xu9Myq5WgZ1iaDPMJOGb2iZ0fw3RbCDrmiCZpY5stIJUdYd1OCyBHEUo6FzddXMpQHDODQgF4OOaErI2Yk8Dkg5UaKRvuzrAQrNd1fHwY1ol52NdrVWpclA3VG5x2oAWQVyAnBQmIw/jNPYldHMbkhmODLBN6vPBhlVbapXKWK+Dr2ag1dbfom01Hg0GXSZHYOnjLkKMwWGXwg8XQGe9OQr2BgNBQrv38SUixYTYHoH1Tw/QC9ijUfQhSVWDMvc6QooJcVv4cZBfgVi6FEodxBhelujLQ6Ut0rQHpvplLpwuGAr/64pk+//wr9XozFfLMijb6pPLUGsDf+Z3f1ddffqP5n/5NybVmyhozig3WEkgLlz8lB5mG/JBkt1W9iMQA3+OMEyMw91gh1cgGLKzUW7tAPi+QlXvNH7O7ELgnqtbq9jkGVgUl6PZuLYeCsHfYaWsyuDLsXf4Wn9i8TqtN2yNC+ilmK2o3U1rM80rmWRVzOLGgRU2bcFOvMnLZKMmtla4zayPmL2Q2rX1iBntqvQ7HIjp6pFeVMg5A5l+a5emw8DQm6BFthZXdzz7/har1vE7POiqWQptZa1Q0H0WgQYqCgnzaJK9Z0vSFls/jMzoPy7hk7kuPtbFdcG6FNpjul9kb6xy/ZtYGf5ligHM2rCWjLHNniGmH81+nNpawYQUsWKMNsKyzHrvQaGRzML2LLnaI8mPsg+EHJCj8uLEqvLro+rKulIC2gfcjqxdlA1pvSJL8+3y2lgphXA+RKpslZzKzjwGkx2PUAvOaf0bzmFKz1QhSXiY8o4Fj+SzhA5j9vJi7AOC99PpYPwJ/z1XMRYYkZ182O3b3iaUePK9729L7hUYhX2rmtcE8BllLHleere7Q4ZKMs4OoNTfvZIOlobNxgfAnfi8UVDaBeKcXJZZvZiSm7PWZ2aGWS2sKa20SUB0XGnABpun1JmQFAoxxvKmY3MKCQvMDvFDBMLfMnCz0QuiMEMvCcDPTCYJCHpgsa50ZLgqVYlmHJ2fwnDVdbMyMYv5FVY+HbGoH3TpyGIGH2ThU9u68gI634QXLMPn99x6rWgnhuZMLZsBWax92iOoLG6k3utLnv/jclwsHWKqYValRUbPTUfWoZfupcq6o3k1PV68vXZ3Mx3RfRVXp4Pb2SNFhMEfNqH18rIPHD5UqhrFvetBXppjT06ePtBkvtB7jhJHR61RZ/8bBn3a1NdJUSZ0lGKQcDpxILLAmYM/qxM1l5dmxY7DezPhCikHvASuSAxOIgiq2lC1oV9loeTLTshkyBazDuBD5nJadxJuVZ2bBsLWZGc3Kn2j6BKo8KRDRMrDH+aygfvOzHJllIlFU0xweRiKsV+RzoAsMl6f7apHf4xk5IQPajDWPmTd+jja/J6/UWryMSqmCcvO0dvPIJLTm2KSaY13N326A/9Poif7NWeQw3pOdIpKLpPqQ0ZiysEvrP5xJlFpvfDlzCCHf2GEQUArLufuvSHdAQkC1GvR47xHPXDfWnk2JFTPBAmuwldrN8BiFOMFBgl4VqJILh04jZDXMpHeqFKtQ5kysmUzR4xGamzg42HU1iMr++VnTh9F1f6yf/+yXzuNL4WyFAX4OiUNWlzevddu90sNHp5Yf3Oz39OnJoY6POy4sgW4zKWZuKRc5d6efqvfer7tLJv2CZw8aURznVFpHdNx8caDB5q1d4P9z/VT//u7M6Su5bc4B3KTOZ2dplYYxU14ujvyavTdgHqfyGhydqJsZ+vlQqP6/rupqLqrabGPMARKw2Gw1Li+0OIE17fIszkzgX2PvW2VWKdWGVWUmcASaWh4+0rQy1/IEF5v9PJydhMUl87J0RbkNblM5dc9O1K+EUUq4J8E4XulHhbz+xs2xmitg1zDwXq9OQyKCjhJzD5vyb7Wor7QsrJQcQWgDxg8bNr9WNJRutaOYMD88S+pNdm9AEefTX51+qS3wNCS6ctlnWxqmDwS0NNAtz2Nr1ASUjULWF9Z2p14POdzYM1GISBigXF+TO4rVYDlCE9JEJlJUcqYH94A9zz+xxycrRh1ontl3WxMnbTpRLgUngtQd2NQjclNv9pKfYGWblZ5J6fCo7Ut7NJ2qOxiEXzN2pz7X92zzzc68EfYldwEJLZDleF6O0gSNcTbsRFleO1Kw/XnEhcmn38HRy8+eiEH05DCOF0YjgX77mDo06jrHIhGrRRogPid4HSA8LjTf4UVpgoFjGFiYO1+WjN4tPkcOsqEjW6g/HKrcKqvcKipVIOmCh1CylRoXBjMHzNQ7GD3nSv6g0eY4xb1U0MXFUOW9aQGD87C7isBUz8rIJNs/TC5tKlKw9jv8HKdclvyZoi9KliIdjQfos54vDsvbadubmBXExqHTJMOMi3KTXyuL+W+2YGIIcTXdflcnD05VO2ipdtjWgw+falvIOEF9PV7YpWIIiWa+0I9/9CNDIT/4/q+oUcU1iPzJpXV6LKxUjTSNU3u7kmdJZdlpNnR0cq7dZKHlZKrDgwONFwX9du6H+g/06x6e5z7/45aH9tP6zr9/l0X9J5Me/Qf75bTYP9kf/e350Z/42/7W8UBnlYoNHFgPjgBCiM3mZkHsvxqths7Pz00uw7SajjiMHSg26FwQXM89X4FzQIW7Q/9ZLhkdsXOIk0LCb3PGWmJGk8srny0ptUXqkDIpAYIW+4EZVbnCZqcrAeYMKj6wKcbmr15c6Jtvnger1yHKoAc5rbZ09xN99PF7Ojs51b+1KRumZG8dMHsr4iqV1eT01PmBQGhc4nePPtTz9/7M3/vcQaveIFbNP/Lbv7/5zrNmrhlEyPh6E9Twlnn75ivdkg6/8+8gurd/nw8o/8fW5d/vyynD+3/O7ddr40/w5xtH/8A/91PudYzE/v99sU/+ZIqDf+DXP9L7mXajodcQM07WBCgRlwQzTevYuUSShR20Xr24tO8qcpZKtaFurxeh39OF2bOpNOch6xM7QhjXJa9tkDVLRjIpw5XhfBMICpdpDnP2Oqc8kpC5IVQudfTmnMP3Bh5c0hQ+dHDA5iAJFFXZPIUe9ot9axxprCz7wjg9l9YcVrituumUkbBtTP4r5QpOqIH8hz6eIhTbP7pm8y4opvfFAuxypC89sjAHIb1hn0J45IuOPpvdN1KQPYvkrra1S481nkNI++4CfRcX5Zv6Tfbyc1TMbG6mKy4d1WZVZzpRaUD4MlAl0CHD6ugwmOEx4sYTcTqcabVYmbRS33ebdEJACyQJQOyA0blNb1SqF3X26FTzCXqfrIbjkd1lRgRv7nLWbQLRYgoAixT4hNfpJI50Sp2Dmjst3GyoyHg96I+AAKjIJmMOw5xnofYUnM/VKhLtknLI9NHRsYbTkVK5rBmgQFS7LNTonQqVim7vRqq32xayjwdj/e3f+VuaozODcVWuGmNnlks49e/9+Ed68f+90j/8l/68fuvP/kOeCZ7UW6q//7GyhJymR6qfnpjaUkTEvR+zpZmd3Q/a9vv6Xu7Am33LxIzO0X/GMPn+79x/cPf/6n+nO93/+e/8fvzP7k2n+ObD9//7zn/77tf9f0YPtf9fStW9rcDf98/+A77T3/Mj463te2K/5+iq73/Mm2/73W/o4Gj3av5XrMP/iFnPH3s/Pif3WkDb8mUw9L82SeApEiUKql2iEmHe+y+cYWAZOknBUU3YBjK3j07v/lca27tsWiXLgRb226QjHo77Gk2ATJn5RTdMZ5ulo4SZnWzt6PPFl19pOOrr8LATc6ciUi1pNB6arAF8m8+UlLVuLg465kcchI00Bdix7SG1JVEFJm5Kudus15aDptKRksOM9uTgUOXzsoOFkZos24/0o/37JQ/ij6+A/cfs/3b/rNPAzNGm7D+rv/fz+eOuYfHe366W/V9/sy79efvn7J/Tm09v98f+7B9byN/9xz+21t+s0z/yOvaNgPGF7+yLN6/7733h31mef/T399/n7ZJ7a8b/3fd6/4bwtuXy4+slbjOTgSFY630zaHrL1hszAuKcgnkL+jWfzJ0dyUX3ve9/qlIRvWpYuw2HxFLNbMAPVJoH5j480XIxVaUccjAbeBTJNS3HOtzeIz2sV5ypYobKemd2aA3iGEh5bm0JowdkbXQVuOLwOvjznN9IbPrDvh3aKN5g8ae2GaVW0fRQGDJXZCyB5GY8GqjZaKjRamu5mprbwOUGBgCXwWSp/Xwcsw6b2m/IAB1YdmNnMjdIkZZOZFg6A0GooDyOUa2WZ592ACrXHF6PTvzdOvN8ZwXYJgpZRnqn11cvrKF5+PhcP/iNH+jm7s4HfRW7uEbVHwCHbjKDzYjT/FTj/th071QVKUDBrTNdJ3YN+DfO1jOLeOF5tQ87atXrNmG/6w40GA7VH2FcPRGFczmJKBxmdIhVqYaY1bmqAQqk8jHNfu2FQdeKSToY/4ZYE/RFSUHFo441jrA5eXYQiPhA/syf+U0dn50qV86p3KorB4V/vdJkubBcpT8dqZTLq37Q0cOH52Z+odM6PTqN2J3ZUifnp8gB9aOf/ESj+Vjvvf9Uv538ezo7fqBkstDg9bWOa00TaS6vL7Up7JSqPHhzUf613/9f6En3mdJTYDsYx1nHc/2ZP/fnVGg29OWLF1piB7dL6aCDeUNGX3/zjV68euX5LTAqMwcWGwuNwqJRK+uQrujhiQ5bNTNF8LUEtr66vdPv//inGs/m/l4I79t7/1DDpKZB8osKb+Pw6mI2o4NWWyeHR96Y17d3uundBdS0JzQwU2PWOVvuTcNdwW738yxiomB5opEEHi/7gOAC4qLASPnk7EC//uuf6exhR41GUQeH9TiR1ilDO6Tb4+VJFftt8Uz/vfVv+vn9z05/qk9L4ffJ94TNSrWLnRioxVeLiv7JX37iP/vsm6+17H3l98kBAqWfmRRpJHjo3n9FwkO0SGhu471xUCBByVq3aG/LbKS2oMcE6WBjc4nxGvnvECmQE+QcqBtWdcx7YGH+4U9+oi++/Ebn5w/1K7/ymR48ONJ40tPN7evI0DSZLaRAp4cP9fHH0s8/f6be6HOtU1uzevHrhEiGZhLyGQeeEWjDnhknlYh0i3TeZgnMhzhIxpOhbLi5//q/HP9MnQoMSIz0Q/bkeKrUWr/Xy+u/cfPr/nP/6ct/Q0eDZ3rv/Uc6PGro5LTt9nCFVpTkDIX/rJEia/Syunh9bUIOspbRkLzSieG4zkHbiBRFAnDps+cXur0dOnCYtUIaSK/bNzQPIYfDH1ch9MEOv94iwZh6RFItFvXw9ETtVgOAUY1W3RaX1Ubd6xiS2jdfP9Ozb194TlksEFpQMiM4hwl7GcOJg4i32zH3m+nutqfLy2vLW44Pj3V+/tjaWOBkOvzhcGo9JbNDXh9zWkYYV5dIbiI8+u5uYIvNrz/8Tf3BD/9jfoYc+vlkHqHhK0KSy2aMIgdh61EkLaeQlCLgme/5xRdfeR89fe+JGvWmhsOxiXCQ0CbjnsdakI7oQI+P217XxWJFzXrLpDOy0Vdk8xIdtreYXBjRAzGMfEc8b3HiKlWIQBsarTtEvtYfGZWATFktF8JesVy2NAZjmrKTY/ZELKXNNalXa2rUyanFQpGLrKQ8ySw7eZ9xSdrwPEk0GMUM3ykhllwF0ck6cfNBInbRWvE9lOzRnZntRXsMoxA4OD5V9/ZO3z5/4U6dRs6o+Lu+KB2saYbcTmu8IotpnTw+1i6z08F5x1qj2mndcy0gKWQjFAHATMPbnkbdgXIE1sJeo2JBm8ODpu2ezZXKZzVPbVWoFNRotfx37ZiCvGGXV25ZVCZJVBEV08rhug75xCrKM6O0FjCnmJcxH+LDGo510yVzEc1SSucPH+ro8NByApLcR/2eh95sWFPid+gNyUosKpWsRKjSw9MzrTJb7bgsIQbYoWSqi4sLFa2PKviwHkynrmgOWge2wINBWWrWdfL4ob568bU++uQTO/9//MFHunj1Wq+++FbVXEkN0tkZtEO+KWbUeNDRSeeR9Hvx3B+//0jbu69sgFwr1TRfr01QMGV4u9b7T5/ott83G40LnrsDNhpzMdhoQMLMENqtlisrk2c2crHBxZLdbbxY6SIgNTHYv59XAA1ziEO0cpVmyA8xuMw6Rr9Hojhylnaj6dT3bvfOOYx0FmaW0sXAMsVEoAbEsnI8UX/Q94KG0Uo3xuviz4IuTDY4u1RVrSCO3plcAsxPVUrBA9WdzxNJDYbSu3XKFmQ4v7Rbh7oAXtzDb45dA4Xbe4xah8mFtQN1iC7y/gvW8BpS2cmZ2q265SqbDZqtGCPcf/EeKBaY+6B1u7lFoJ34eUBd9wyTjW3Py3BFqZSxhcu4IMEhBCOIfDHvz6lcyKmUK5sgZxP6iyu9evncSSC/9Zt/ytphrAQhoT0+P1WfbNfJwGuWovCeDHR0dKR288LVNRcMXa+joXY7HcK0TkWOYHxBpkqpezvSzc3QfAPIPbyHb775WteFrfQ4CgjIOxmcttDW2YoNLSHa5ppaKstDTx8SYXiNJymXJBaN9swVkiZnsdk6LKwJIwyYuaxTZrIYhpAhS8Ez181lT+2DulKHe2N6Pv80/QJC+IUenB7q6KDtMcnp8ZlfN25Tkym+vHeazaNoQshXRq5TKKlJtmqbg7OgdAEoLmf0i4Lt9EHHKSkLHHoWsMmJsIuwbAghoGKjAVD7TFeXtw6zXic7TUYLDe6e6fqqp7OzE0f7waokgYMDGTLON99+q0GvG3ZuzJczvM+tC3vDj99puTlf+MFIQyx1q5Z1fHwcSMRw6OxSUD0KApzRbN0ptKSXLoRIYqEo6/f6YZeIY1O2YJ9bftVrJNrABkVjPFc1X/BrJiZu1Iexm5jPwGfJWGCbArKFwV4wMQeWOQUE65Qir1LK40+nUrFjhUCtXnPUH3NEOmHWDJc+EhVkO8hhrDywUUcQ94jX4mLkjHJhT3YnDHKP9opKmwcQkV/oYUl04fcodCm83MxPpr57mLH7cssEEza6Uswalp6X3vT7Pg/hWPB63ulFycaPGR9a3pRSubQHy2dPz9Q6bFnszA0No9KpIWWkI6RKLDXuz010ySmn3nXXgcdHB0dap8F/sg5KHqFfXNFt7JRd5VVullWr1m2DhGB8A+4M/blcsIaH1p1KEuEwQlzo33Q8zFqK5bBas1QBksNg6Gr96LBjV3+GzRzkhlqonBIOTEJWuXvCxJwKhJy7aben4majw+OWklJKcwKsYdgmK/3yi1+oc3Rg7WSzVPclRTTMV7df66Z6Y1Pz+Xaj53dXah8f6q/94/+YfWrHvYEaxYrZr5//4ufqVBv68KMPtEqldPjogTpPjvV6H+HE15/9R/68fvsnf0NpZgy4oUymPgBZCBQkqWLJLNQXr6988VG5YT8Gs63dPjAVnerOhJMMYvGQkcCynbUWqpayDnjFDJlu0HZvDjeFnBKRXHhMQqbBVg+WITPXzBKIA01TVgXSSciB6/djgy4jE9EwE0kjEG32cBTi4zls1z3cZUH93oQgSGPpN2styB5cOgx+Qrwc4csbu89AHktvIMIgbt94LlOtwtCsShGeHikevhEj9+8+YYLv63QFUgT2X1w2h4WOLa+KkHXSQejgOVDR/+XGpf714Zl+MinpYrfRg+XEbF+8RQnH5X1n5xEPxHuyD/EiHEhgE1LB3nfQvCy6gSDL1DQdzyP+yMJ2YswSvffkPZ0/ONYymeri1Z3jow4OmyqXs3qJRGkTxu0QiFjTzEvhwiMrenB2aiiL14azFUzbvzsv6yJhyLfTXz/oWvPK97m+GWo8j9gouqtet6vpw5M3z+Xrb57poPaRtY3sJdYIlXxmXdgTU+KLZ3BYOvB8lo+f50tnPh5hpo9LU93knYjQQra1ULFUse0fM7RyGXZ0Scsl6RSJeQfk0T5976FTeHAoinKNA7mg46NTszBJFrm+Qf5FaglJJ+FH2ut1Nez1Vcpl9eDBidp1wgV2vjy2yDdyGZXIeiWlhpSNjHQ7n+ni7tIFNCYcmXLMmZGZTMcT+y6DXsCSBkVA64rbFBfHYjG1YxmvixzaanWj65s75yOOZxOPflrNjovP0Tq6RkuyvvMMKS7t/MMPZeU5v5HLuqRNstB6UdRmWYh0DCDTAgzRrIsCLlLWEoX6q1ev3FVTiCC6Ryd+H0ZgH+sMaoTNnqk990UI2kLIA5IvvKvZm1tAGyQYsOmzMLVhU6c1GvOMSAQqO2OWl1vj99YbI2c216hWNW8tNRzjjZ3R8dGhDg6P/OeR08H4JRIQhzD2WLm8Ug4TBH6mbR5hvde8L3bY41WwlYTpvNQ1Yy1fqEUX1HSlDoVPsAGNfEu+/2gy1u4iovkmk9AzAw2zNxfz4bu9KOPAQUu0P2jyrJydap26Gp2GHyYHMrkijmZZ55TdprSh+4B4s5FataZWo6VWo7lthgYEoY6mDmeuNKpme46TmaarmbYvdzpcH2kB6xAbuxQsO0J+iyqV19okWc0mK/W7Y7vjcIgiXmcDwBabzBcaDcIhhEsaOAFBPINs7LSAO1gEjWYrqvzx1M4gyByAaogQW66nun392gv08cGBsp2Kxuu5CuWS2gdtNZqN0PhVqoYnc4cppd/f6nf+3b+pP/yDP9ThyammJAYUc/rBn/41fZL52H6vUMRHt1C25z4E+tm+L9Jkmyg9Kem4dK5k8FYIi5TjvU8+UPfLC1VKVeXLZXdUVHpUlN9eXevrb1/o5asrS2N4j1zYiH7PSHsolb3oqL74BT0aQ2G0ZN0u1Xiw+bgQzLx0NwQcU/CcgaIENiyXJRsdXSWErIDoRiYDtC0byNh+yxl6K/xTEQAHq3i0DLkGF0StWXcxAgxnI3VQARtaIN0I28CoJJl3VPz3bq6uTdX/tgZswiEZshJgKrr53Q7XGoKXcbbJaba3e+PL4daZiIuyx6xt5nBDYa0GW/H+Czi9lWr6vQf7FrNmyAnMGnP6px70fFH+wbSqrxYbvX9AkCzSmJEy6bx9LylIkH04jBrJS64Q+XeMIBZhn+UA2/3r4ItiMCKIEKgvfEB875OP9Cvf/55SW8hmIAVrC7XxN+b18PosCyBRHtOH7q0GQ6BIBP+wtwvOsvz6q29s+4WN19/KfKpXKxCUnf569aUGs8SWjenBVL2rG931B14vQeN/C71eXNyoe36ieiNS5yEVgfaE7OrtWoXIdE53V42LEBkNBz37s1HvaDJK9Hd/+vtmDH/62fd84eFbi3doo5VRstip252q24sUFQqB5Wqm04cHJiZVaoTuhqAds3GYmXc3Q/3ii59r0A+ok2IHE2wKg+l0rMlwrGohr06jIY4t5EVYfQ7nY6Xwmibeq9Oy4J3CBas2NhdkQbTHBDw4vYSLcjY22tRpNzToT9TrDm0OMB6NtUzmWq6XGs1GKs8qIT+zZ8JKzVbVpuhcEINRz2DQiqYAO0qTYt6iGsDaQLgwVlk/LmoXM+UwjM/nlcINCYKYNsqVCJ2u7wt/CoyFL8yHD8697sisRS0wWY/3ns0YYZT9uUUtGl7KXCi8dzPLIUNiH0eGrxGcndcDe5m5PWsNWQ1abIiSyKMKQLlkZiacuyurICK7HUZvwRed4WZ0+DREBMqPx0aVcJtiraabDY/E2KN8cdlbb0qCCUQ3xmgpfJPHJoDSCHGOuDCoVg1v888Uf8Hs59zDQQyZ37VlKBA/Oa/TGTgFFD+bd3tRhmtFQBR2undmIPBTyB+AENAdE/BsorZNsBEop1XOl7TOLSHr6bBBcHHGXcVg0bewGtYoxsu1IqbhyEmyrgwuNokF/bCtIDJghH5z3ddytvWGQtTLHIC5IB2HLdqStXFpLkpmmnxRIdNJklvJnISuC/iY7gmGKZUinRAHEFBCCVd/BN+ThZM66ELu+l01Kxm1DpuhDdsmOjt/oPefvq9iOqfRdU/pzVbtTlvnjx/bJQfm1myduIukysHJh9R6oOHBbGpKOt0PkBKm2ak8pyeVX1XN2lva8nwy0ycffahfDtZaz5ZmMzLk56InUyVcRXaO3uL17uaJUmVy84ZeaEfHzA3p9EMPSZ9o/dAW8wj0bZjIZzwfBGrBmBc4D0jSeYx4iG42thzEfs/vbY77DyYF0MfjouP1AD9CDoWRR+I8cKuJWibAkNQuE6aAUrkjID2xWZdA3tbbbd0h0GXFekMKgnsIesOZXrx47fkKwcFsDogLdz3o7wjS1xZiw3TrLitSM2BDtie6Rg5az0z9H4OB4YBdQ83xhRbrpP3AOl0QCtIiKjuCi4s2aLBt1v6Ljbtc9nXx+srdKYQFYG4OGw5TZlC8bsg8xDOxR0xqw/R8t3kTq+SZyz6LkPUJUeHhgzOLsc0YT6barpZa4yaSCwcUoDKgQebziMLTivQYYCnmcMgKcMi5urx0gQE78PLqVuvjj9+8/l6/6yQNik80bjDWoc7XnZrCTPnt4U0qBZcXkBv7hgKC9zGYUqW//XNOjSF8ukQXg9NUP2RFaZi2RX35y5f6d/7t37HutNdb6OzszMbbfKbcFXSVPgCNCK19qFbrTWtomX9h6E1BQRxWsVDR5eWt1uJ70YFij5iykw3d22iCVGBuK7wZZ0AFgXpNlWpes/VSL68ulS4VNGOCkSkotSb0eK1sOa+DIwzH+bxBOaQqcjei+iasubIa1QPlC7eevdKhtDqViNDK4EJWcnH+xde/sL9zrpRWo1VRsp75+2FmQbGqHUlCBRdFjtzaf9HlsT1toG9W0M5dJ+YX23x2b/O31Wyz1NHZsU7PH+jzzz/3nh72Rup3uzo7PtVDnu18EfA2SAqIHxafyVavulf24aVDZK9zwYCGMC4qlMjy3NmkhTFFtVbxuuLssClHCr/ovB49fuAwcZ+/+UAPJqOpEAWy3ngDNBB432LrSKYle/9yvgzzfRzAEtisHEUkHkGq21rWB2TL5ch+4ewKe7ylBn28cheR+uNiMxo0Jx6VuOC36s8JdScLlBFazK/ptPmZaD9Jn6EAwBuXZ/1OL0rPNezOA8wTNpgc9ODLkHvoCg3V4ae3h834X3IVoXrPh3PNpkNtFmtNR2Pnn/Ew6Bjuure6ub7ReDlVpVPTYedEygNzElzMQyJktKr1YqLFNDGUO5/tnIVHjhzibKAcZkFUZp2DA3P0iMNyppnp1eh+hup1ObASJ1ucP3rg7hLhMe8P2vNqMTFmj+EAcE253rA7yO/9/o+kX2T08Q+/p4fvPbRHImkpvN9Xz5/p+c++UiVX0naVUq5YUuvoUC9evla+WtLjJ+f66KOPXAGDR5WaDT396CP9/t/8fUsFWNBs5nqhrHahorsvn+kXL4AE/kN+jkVlddo+1F3rSj978VNspHWUL0SElqOpNoaDYc2hb4JmTe5cIQtEkVjgf3IC7Ix/LtKblEbDnZI07hp8Zgh2Yb0VlEpDHsAaruoKO5VumOFM90IlD6QLsQC9VD6Ft2roHbl0eRbAMpAgMkPst4CWMq6M3aXug5xx7WHmtedD2+7L7mb7zgiCEO/NTFLmWFi6wdzbQUyY6eLVlS+ix4/P1eYAAmLdYfzd8xqkYmPTvz3kY55pYhnmBHQOCMt9OUG2ebsN6tWmctm5IX2bJOAqgsNQDagro0ahqFJmp/kmpeveUK91rU8++9TCbGZEFMMhunfN4445Yq6Ar0LLy2XLzBzzBhAGNIALXKfIldyEFyrFJZOV1C4MpekK+OY2qYaY5fBxLljez3ZPaEg7/DmbKero6MQHxC9/+YWh8mylpqubgbpFNDWHKqe3ntNhYNRbJrrr97R0V5/WaDq3hZ7FbPsvfEmZzSXJ1paBmy3G8fx+fIb3X06kIA0lwZt2aX1b2Mnl9ezbV/rpT36p2Xhlktnf+Hd/V+9/8L7OHhzo6IhZK+kQGT08P1cx3w6rxNxOH3907rWb2i29Lj3iKedMHhlO+uFoxFgAbR1MyEUUbXzuEEMwUUCKgNNLFmekVF3D2cSFdLZc1S7b02wZF1ERpIHsRhdVMDW5z1LaplYmsTx+/1yvX19pm1roweNDNdrVN4UijOcUeYfNmk0jvv32mWfosDBqLaBBRhUZTccLPU+/sjsZSUSsES6i+y/2GlZ4TrnJECdIYwHhK61suayNtdAZ5bcFffTRBzp7dO4L59mz587sZC3e3d3o9PSBuys6dkvzaF5mkOPGRoIgNdo9yLVfRK2RpMLPzeEjvObsGBvtODs9NjkoWQ+U4wTKIk0Ksw2QjrHtE0MiwoyFsHnGH9RadJdrzrdG02TBEfaepBlxZu0ilJmC8d65B5IcMiWeKXApJvDomlerYvhF70c1fDmJZ02BPNf1zbWmk4kGPYozrO/ynu0+ee+p/+xXX31lTWa1VnOeZWg2V+/2osRtZb6YBTwEKcMOHrCMQgZgBpGthaD9JsruSKjEsmqhr3/xjX7xo5/rqNZSs1rzpmdx9bp3ESyMzVutYoIEUCKVermQVjIOI2QuBuAn2KRPHr2nrxcvHZ2FGJsMtuUKwgRxT+EEUZgx9wg83snZO4bSVJ08wIXZsbyP+CCAYeOCdbiwIZCo9CEjrXNpXb++0k9/+TMdnx2qc9TR6YMjNY+PDDmuJnNdv3htk2POjZcvX+oWI+TtVh9+9pHahwf6wa//mqoNsP+xJguSGlK6ubjW7//oD7QZL1V9+r4eHp5ot1lqdtXVs89/rmm2LTgSfF188a0mX/9MpUxOH73/oV5fXHmh2MWGnDfg6FJJ84Qqf6flGmhjbsMUFj3zyZQS+0LalaNaNkOQir9ZZ8YU+Y/Ffac6d0QSSRFArgXd3nQ9E3j+/Lm7Vy40NhWfG8LkguEZSFuJoSFEwFwApAdQ+fHnmSfTsQJfoY3CeYkHxnwCCHJBOgBzaHoVLv75wpmnzCvpMHBVIV8ROncqnVchX1IuQxVPikXT3UQGeLiKv282os7uDx4cOlgnpBA4KR7XFsTbVPOkb7ztEkEourOhu19T83O814bqLdxCdmpld/pf/umR/um/1dC/9O2J/gfNZ/qLH7Q0yc3U2ZAOEu5AvvC3kShCBBrriU3NgWFyE+vLjMCSD0bm9vl0pGski7XmzF92a60gkXheLJUKFb8XDAOmi6nS6YLyOTL8ILHsjDxwKbRbTZ2dHNn1BDtAOuPddqaflJ/ob+iJv9f//sOf6iDX1DSz0evXX4dejVmnSU7UGzy/txdlsVRTOp23MwsSldL/j7z/DrY9X9P6sGflnNfa6cQ+fbpvd98w9w4TYIYwMCaqBMIwUDYCLMuFkKo8VjFIheRRSbYlC4FFSRaSS9iykVU2FCUKBINhjPBIQ0YTb74dTt555Zx+v+X6PN+1zz6D05R9/pLXVFd3zz2991rr9w3v+7xPKKa891nLHGLqhj/HHoCRC/Q1Hl2bARm6YOzgemZ5WrCzTWqzjHT24tzPnDWMIUOpzHwtp3F35QOW9UeBZCs0uvklFndZJTLIWqY26MbJinEIYwKKBv48jF4gWPYJloq8cIiCwDGASGZzk4W2i0jbRE6n5wNLW1q1sqK7h/qu73pfpSq8haUiBYemOLlWOie1DqrhrOCz470cBS05bM5uv+covuO7x8oXs7o4u/TlBfOSgh35BVmYEFouzns2l2cs9eaLvVnMhfKD30MzwXoJ7ljYDmKUAhO9Y8gYp7R6BT/dqh2PFBOdtlEM6a9ec/HK6IKZ4LWJjcEij2xPXKKm05HRvwcPH4SOEWQlh7EF8oycLq/6/i7vHB26UcLXm73IBduolbxK6Hhxv9quiLnLKEPQfY6LFa5CuFQ5kxlx4bW6WYZzhDg70AkrTOzis9RgP+/nHrDByZ59D2eFYh01AZe+GzJ/SdxDsRUXs8nEdpzc37PVRINM2qghjRDfoeFxZ9DicDT3PPWtXpSj875venz8WkdtZanO3TUGAT9zHA48Wx/t6FJ22iy3evXsVF/9+W/q6dc/1vEP/Cp3IFyIDM4dGwqNt5JT9aCuQr2kk3fuKFnMaT0dadoFNpDKxYaePXnhCuzk5J3gb5nKW5u2WOyUSa60xIB477xCJ8KmCuYdYdbgBxIDreI/WDDRiDkem9QVOa4nVDU4mSD6JsmA/Df0PqjEkjt7C6JpTJESHqMrZvHOVcxXdHj/yBmU5xddH96HRx197w/+SjXaLbPAPvnsqVlXeLJeX17r029+rO7ZpQ6rEBQgYVS1nI7NasSzq3N0K+R+9q0n+giGVqmkw8OKc9cyJZLU8+rPZqpWSnYaKlx2dXp6aad8Pj2pGFRbwBabLZlxE9WrdcMsQMR8f+UiaSpjd5gMxIn+YYh/3Gmr3Urq7IJoIdwxJvp0/kTdbs8VMKStYpIg1rIZxxxqMN2Ws7kPO886HAgdRMHNek2rVd4zK6CSdDZtqHg0nQZXHszcV/gEMyOmQd36L+Asvs8978oHTKvRslwFuytmMrxfW/pVS6bSc8aXU7dkKBtIF4B/qV6Be1O2PNwqeH/OV7cw97Pnr9TMzf3fIJre7laaLIa6sz10J7XbrTQeAZMFZfqnufv67tm1mX+ZTEvD4cAHgw0ImMl4TIG9VsZGzxuKkmzaMBiXCWJtLoztCueTjLaME7pjjQdDS3joIIGDgRLpVg6OD5XKZlVg/3i2FL+OCuNAsbtROqHZaq7BsG+jj4jPsMvqonz8+nNiDZZskSHLAZ92ETV1Kgdm8y3b352/4VrSbLQ8p2bOs4kXOjpsOiqKuVapcetW4VnuXroSRwnlUgWtF5FmY8zlgwMTsDDRWqlk2nMociLnk4UdrigKSqWari9HuupeKTdHXzhTo5XVu4/vagt8uQ/6Jde1XClos730erR5TQp9HQsm8nOOYM2n8azN+PkRWuywapjxONRsd5Z3MLLhLIghKqWTev/DB6pS3HAWu3jGHCQQ05hbcmbYESjPWRfYm+wxUAeHj2+wTsvp0aO7Rlu8vmdLO5Hl23XPyqrVus5OrzUz0eWWzAOTt5VJmDjEIXbQbrujZA4a2Pw5S+eykXT24lQvn750tNZsCKt1bu4DQdJktXp+vd3q5empL5H+cKJypWZSDIhHAa03JKBxCLR2BFXiRk8MeTCn4XCpFy8vPLpi7e2Q1sG9SIYsVHx2E2pqMqYoI4ezqCThy9FGk/lEyxif3UCmw3wFxAHGN2+Ay9NEORi2eDzjakUDg50drPm9lSDFBJcn5urAyTAOqG9BzsggxgVtvFq5AeMPU2ZY5jeZ6Zvf+rbTqSy3sS412PHxfb5BeH87F+X18ws9f/7UrEuqO2QREZeizemxHbM5WIi+wg4JQ4LFUt/55sf61te/o9Q6NvTFQYbnJhdRvlXWirlZcqPCQUWNw6biYtIXZz5VVjM6UJJFGKXsQznoTZXYFTQeopkL1lB8MXaXILWemRn+JVwMiGXtT5sI2j+2FokDWDhlGUKv95ZvYOQ4/JB4HZslSJo4DQnGB6VqWe/lHqtzgJXWyiSk5DLS9Gqg4WDkxZ9OAlPsDJ+R3dhuN3TvwYkOj1uqgI9Pxp798WefffuZzl6cqZwvK1GH5r7VeEK6CQy5vI0TgF1eEmMUeCzuqDPpoj598sLwBIwuBtJACwUO5F3sS9RzAQzNsSCb45PqlGJ/J9sIKQUbtWe4rlbJq1AFZkwqV6lbezpCXuH0JGKzitrECX26mGq5mrszQeBOFicyjUKx4QXaaeJwlPEmTG5Jzcga7saKEBKCoZh9ZJkPcyjlzKHzJVec/DYIAZCQslgRzmZ2oNkl936YRFe54QumFVTTHDyQIlYwDecT6wTxvcznqBp3TvIoZ/LSXvYYOkxE2uQdpt05xzjm7+dg8e52GyzXO73sXqs0mBoqS2V3Or8+1WI50clJW6VCUvdTJf1gdai/O67rf3d5on+qfq5mrqCTEyj8kTtp3nscsya3irBDo2ggry+ddFoJBeJN+DVQ344Oa7HTBju+LfBfVrsopXKpEWzSYALHkMwWWkT49oIchHxMx4YttrbLY55XKBWdW1ioFHWCCb/WOkvV9MnJ9/oz/q7DsQ5reR+ilq3AHu00lE4ihsJrN+e1AFR884IFOx8stVxNVG9U/L2dRFLrsKqBBzHhxfyPR8S+bJH9R8e2RvOWV7vZ1mGHwzrYxIEyNBoNV0HIEtjTeJEuZhjCz0KYcRwCDmBNwoJ1KWzz8MhFe+cwrzsjYtfASKfqrVifoFsbJ+SwN6No6XSOXB77R+acJXfzuWJJ4/lGwzkWgIwfwpgny1wY32NtDPsxNng92zbUR0ERYHS0ehCYvE+RxuCGZPlH4GtgeB/mzsifVia15HIV8wJg8dpkfItn8O2Mkrl0QVsVQWZKJbVabReY5nKksHWDGLPRAK1kJuXxTTqX0wBPbEhl6Yw7fzJV0Xuy9zAIIFyZopf9Fmvm0RFFC2xREByeC0UXqAIXStCjzlykTqcbh0NDYuLy4twEUUM6Q+xeulkzOWixLiuKkppZy55XudVWutvVqD9Uel3wHmDdMitEBgJRM+S57p3YPNrju+UZ8v3hHBQCuSEIthpNzaYjrftTP2fbiOLnS4j5LtaEOfsmcgfrkHNY9HTBcxJOiFQLSVjsqTC22L3di5JDrVIv6+Coo1Kt6EqbwXlwxwiHDguYBcG8bTMlbHOlarmgo4Om8om0dulIIh6pVFOuVFSt09B8u1SmlFalWVG2HCjb0IChbLcQqG4TWo2B6hpazNDbzNwlAdFG0cKGuHbhN9s1ZR0gLw4qe2xCzTe9OsxPWPjBQzawoXACoLsEBuBAJxYrPUuo0YTGznA+oUarpTsnh9oQuMq8ZjDR2dOXliYAKyV3aY37I5NYWuWKtqWcovlK3/7ZX9T7X/i8Viy47kCvXp7p+vRKWu10eHygbKNjXP/oEMp0Sw/u39FiONLLZ8+0yJZeX5TIVz5++UQfP32uSqmsRw8fKmJuBRxXq2DpreWW3EQ6uYdq1GpOguC7YF7JHBafRevC6D7WxBZNVUHom86rVClrOgnm8WwG2K1Aq6TJF32ZxYGUs9pqoaXytWBBhv7RECLBu5BYgFuQiZitCKsOKBhYNmmWLYcRhhFFU86DcQUXCJc/1SIG4DBLJ/Oxbdd8kLuKpwvMqIj7TMx8cWV0gxkHXbPGweQa4SSHA0cU1PebF7AN3csOCRCh08iIgLLW0NGLSo5vD3o6Gr6n1TrMnLDTYu4FC5LvcINfb3KkLxWqvih5/Zunj/Tv185C0kU2rC8uoMAchKEd2K1IJqDd83NvrIJgDlOYUO3C0oa1yb3D4cjMjsDukOkIu7HgQhM0Bg9aIDS2nnMBRwuzfZuNtqt4NK7E0Z3cPda99x7rRz+99Yf7dbW+mkUukUw4TLgec1ndOW6oWGyo35s4aYE9dPO6uLhQvCQTkMvyQMkEkXcJlet5DSfAqaFbPTxsK58baj0jI7Og6XBmUhPyA2REeDr3B0jBIHBt1dvCRAyB2yR3pLRRvzv0bJGLNJe7CSEPaQ9A4glYgWQzgv7k4ADc0XbDPoY5n9WUWKqt1DkgRqql8aRmMhTFwFGHWSgaxKTu71LqjZb61qfPTLTDFASyDWQcxi6GNvZCdljQwc8VFn6IZ2L0YBPwfaHFOcR3yWUEo9zrulTSOpEwS5O1zJkxmVw7AgzGLiOnI3JzM7cIEmHnJa1thUlRh71nt3vttU5TwhnF5c0Z6HEFcod9ShJwarmc02K+1jA58+XHhQbKw9npmZ7PyJ2WONOsN/bdRuLE93vzOWEy0xA5vD4JPMrnoqgMnswOM6AYxJLU0plgLcefuboaqFiu6733H9oVB+OT7mVP48nUzYmdc5wmkw2ORExq957c2X3X56zYZMqkKLpfzu/1YqYGmZtHh9JmYZJSrlLW0dGBDpoNs7o5B667/cBpACffxW4+QNWQmrHOIAECHzMKoxh7qxflwd1Dffjl9838WibX2hDgjPMNM2IGopCzcFmBYTaaKprjx5/Se+8+Uitf03w0VgJDADF3yKvRLKnUqipepZQvZZQmRR5IBcLHjjQGDsSNL0pgjuOjExVyVfWu0eeA+RfNeqX6MJyWI4U+SEgK5YJZclR1FxfQ9bcmqDB/pEuA7cWGpetBHG8zbTqNLKLbmc5710oXA1RD1Ym9XbNS1nzQ12I81aw/0rzX16g3DOLcbEEff/tj+3V++ctf8oOfrRaqd5p6/P5HnuuNiXjJlfX93/urNB/OlUH4vpqrVACGKZvJxQfJFOi4I2XpLPcvZm+kdzMD4VJDrB8ndhrN58rNptowW0omVGviDnSsO0dHGu4jrDzoni8tjsa3lsw7k1cSSZMfWKzMaJnb0M1xOAGL1WpNRRrp0aOHdurZrDAQwE1l+1psz2Lm51NdjyZkvK21yQR7TTYSC5814Qoccft+YM9AHaYqrnFUo3xuNgqbBnZytpDRgsQFDN/tpoNAPRi/B7P/2M8uJCjk1Bv1whyrGA636XSs5RsepLY7M3GHbil2V5tOh0oSyy26zZuXCUmIsS2FWjtaqFrPqVQsOxybmSC+k7+tdKpfKJb09+dt/eK8qs32hc4vzsOmIiGDYGCbvGPQwQGcULVW8XeN5IFLihlMlhnXmlSHtU4vzhXxz4swkz08OPCl6pgmCs0IZnJkPTGQGV0WUBfbj3klhLoxHcRmqUIyuNSkM0XVKlW9en7o9/b7Dy/1Uaav7RopCk+FWV7JQm7mhoYAHRDMfPp2RkmBAaM3kLESGvRnwXQ/udHq7vuv/xzszdl0rAJhBpuF2a+JXcbEmcl8ZMec8WisbLbq3MHVcu6D0R6ge1OI3WxiMw0gxlQuaXE8BDLemoOlCRggLJk0+2TSjORHj+8pmTg3g7bdPlS7XdM779wzWQuPZWDQPAYPaWz8qMaZsRKEPrUAfTzDNm2t/vBagyHRT/etOWZ+5pmYfUqDNpbDFoeeYqIYTNYNEcIozQQHsFTJhzz7j6CI7YoLlJkgftQgK3AjJprOrwyRciEyprh5QVwq4k6WTXlc0uv1XPgi2M8ZqqSwIRuSMQP5jTutzCEhxJsiYuloP2esukuLdXjQVr6Yd2eJm5PNMxJ0uRtfzOgz51Gkil1v0kEj639OKI9ULANJkFFIUhVkOZCm1utAQkNmsYl1fdXXOVruKWgWrPxY+ULoDAmuQG7EGZLLFaRUMFF3zqaZtOg2iypwHvDZyEhNZnQ2PfMFCaGO2LZCNqlHD09ULRBbNvXZi80oTk2TxcYsY4pcdj3rCrMDyHJ2gMMJq1C1IcPl1ZWur67/H20J/3+9KBP5lNYp8g+3r01sU1yO260P3yy04hQ0/qJWu7Xd4HG92Iy2Smb5b/l7WplaQdl6UalKVhfDK1+OSbDvJN1FoGDBWGT2CVS5mq21mKy0Jv0hmVKNQNBksIfiIILY4Kw2+glIGp4nSsf4W1KxXl/6YDlo10I2oAcZ1IHQkMlGW4a8OnxGygVX5WiCSHjnMEIcGy/n6ncH2kxmEjE5y60yRDKlqXyoTqVUtFWSoGbiqnCWyGRUKjf19MmppmDnWzSgBdWKNWk30JRIqs1OBC8w00Vu8ZM/+bdMBuGi6aUOpL3eG6/Exfm5KfzMJRH3UzxkycCczJXGHagYDihkGcEtI6dquaYIcf420sOHGM5f6vz0zAc38AyXJc8R1w6w/oWjywIrLQXrMcWmqOrBg/ueLzHTXS6ImFobXrwc9D2jhEDSHQxcJNEZkr4OlAQUjKQDVqtnDc5PDE45dLVAItimAUdCxuBQc6pJKW9WJLNMpB50BxhBLHYL1SF9RUtb/5Hh+PkP3/PQ3kQzStsksAqw/K22jwtpvZ64o4PWzvuwLytJAngC33i6uXtfqD/r+WDm8MObmDBcGxjQOVgKtlUxGamTYcq50yJO6g9++wP9mc8/Uy5ahHgp3IzWQasLnMR7M8nEsW5bU/TJ23Q2IZhAikzVqTaLSMP+yMSc/mjoHFAM/BGV5/lMi4S7RdJ6UWRt433CSjG37ygWith/tbKh08vZWv/MtwPrL5eIda+cUBtEIJLmY5yMiL8r6t7d+5rNcAXikCPwGQ3cG4dIAhiMzpwFy2we5vTKF2b26PbPcSk113PzGGA3M4LhMGt3GnpxeqXeoOviAXkYiASdf6WC+B33l2JgBEdzJVIh+7HWKOvkuKVinkKBZ5ZVRAdFp05YAn7QBVykszq5g/EJ+r6yGo2ymat0YZCQ+N7j9dLGBpkc8VOkvrDeKfTCZ0a/lnEREogq6JQpBrbMVdH54Sa2pfCDkMWnDfrHG0kMCFY6CuYSXDTA+0C/K0h65PSuMVSo2f0nN55ptbnUdDYxMrJM3nlt9t4+aiu/BEJG0whkv1TLczxHagRXqThSb9BXmUsLR60tjOSgReZ357g8l2vPx0ng4C8zhxOxxsORRxSMlxhXVLH/K2PWP9WGQtmm/htN55Hyu4zHbBBtMFvHF5uMUyBy1ngyjS4ydjgF59l8ulQGPfFoqk+//Ylah211r69dNMRpjA6APzFRiPx7KIy2oIarld2GSGOi4Chh1J9MqY22Ep0tlnUYJABTpwu6f+dApeIDf1+LBXAuoRMDo4e4S5HKwp7jOyTIHj094yqeF/pNUCkuUghgb/WiLFbKntlZW0VFtqYaiDTDe/X6WpU8SdsHyiTzysQldbuYn89MG6bSSZeK6jzs6OCkY9cbOqDB8ytnHmJCs5v01Gy3PeRmE6d2Gc0nS00GN4fHOCSDpArWLXFh8HDdiSXDAcElaF0MmhqquyjYGPGl1WoE/GYc2gre//z5S/XsqNIzFFGpUOFNgrdku+Wuiwt4sdpq2h3p9LNPbJZeRYy7ipRP5pSrBu9CKtGPPvrQ0Aa6qHKj5fCDl5cD/YOvfsczqkSSth8IKaPlbKHtfKHUdq2jdsNyima7YxiSFBYIT8M3dFUEqHLZOCfTZuvBBqpAJ+rNDuMUOBNLrJW2sOKSNW4I08DxxmX2CDwDMw6IiCoSkhGV2I3PahRR8U+03u40X3LYVt3FffDBe2Y5v3x5ZqkJriTE2fD7cOGBtblE3wlMs8kpS+anw2dDDBSXMlVlH3NkXGlIQM/lDH8gQWHWSrdZ9vvJ7s3QmcktpJgqeRUs37BOpDslQLcAC3Jnp6aTO0e67l16FolTSXNb0zLZfG2rxufl4nQ3kMxI2TAu4P0hdlbi1sYKW7vpHNJaRs1STbtEOCCRYzh80KhFxkXAj905VZRM668PWvpsntMff3Kkf+fD870MZadVH6gLCKtotiKJJPxOjwQo6kBngGOZ15WKlhUsUnRtUchn3VIsrF10JcjVw4GKO51mgA4EnSayiHUcYrIGU180MYe/D9NY/9LpO1qgW05E+v0H1/qnGgMbdQDxTgZzjYf4qy5s3MFBS9dC8WmWIQHG+xcXGXA8nX1wUGJFJq1t7p5eSqUvhrW63apz0PF+G3SvTc5CjkSnSTEIYQOZAHPZ1WoegsTzRTUaFTU8/0qpUku784Z4c3DUUqfTVD4P0hRi2PCmhRASr7Fno/jaar7Y2oSiXiPblgsMI4SlAwm4cCnoIR/BzgxpRCH6jouKf4fBWi9VdOf+kT73/kNf4nQ/rD1miBgcsO+CXhjYnoxF1hQEMc4aUJUlm3UfC0b9l1MBTaJKlraMBshlGDlEyhXzuv/wvmeDdH3Etd28YM0utwtt45WyxbRanbqq9fDd00Qs95pXpBP8nFq9/XrW5hBuYv1oCCCM5bMqQl7MZtTuHOr4qKXra4xJYjPPGTE1GnXbHTIW4WczJjNysF0pmw9B08hxZtOevYfbrZZajbqa9Yafy2g+ClFzu6Rn7gkTqmJ3gk8+gVvSVS6VtKlAucgly/oO5B5rq6NYA2Iap1NLT2oHbZNzQKqQo8H8hTFPiITipUqFju7fPTHSwHPgAh9e9H0BAgXXm0HCBmyLQQd/hu+Yv+fXWAsSd8d7SJtt/VYvSrRJbnWoobcJxTPCcGMtLmfqPr/WurhWblVxe75cSj/3sx/r4uLS8o9iKaNf9+u/X/cetaV05EqNtv74nTt6/vKlLntXZhhC/ccDMd4mNIXC3UV3CbmB34qLSvANZe6IJRNMQvR0dFfT3dR9bgg/jc384pCiMuTQyWZCDuUAp/oxM5jgaM9Dw2mGKg0258lxZ69Vo6RM6vqyp97puV48P1PEYLrW0LjXVbSie8LsN2nYtnV4qFRh6nSIfLmuF89e6NOXp7ro9vdkjoCRc8EnmQFMxrrbqDn+5TuffmoC0HvvP1Kr0dB4ONCn49sqnYXeuXMvhBiTxg6DMstmXSoBs4/ZCdZpXJC7tNaLrS4mlx7eD7HVWxCaipl5kHIAVzr4FNJAnsON6qrgeQ/dItAu8FZnFzspnAMR6yk6SpiVbDKYcpAV+DkUGjmyLZk3LBYe0KMLA54qlcs+2ZlhUgjkUiSz4BeLFirIJG4ie+gyoZPbXGABuxT6P24iLFNSDSAJDZXN7VQ/PrQODKhtl8APk2KjYTP+9Xal3rr2+qLkgqXDxUnGUGg6a9gG04xMPqXc5nYb3Ll7qOruXMk0etKsyknCwYM0hoiiZqvqeTLVKIf1jx0+VWq71F+Z3NGLRVbfnOb1pXQwAKf9DJ+NogHInxQHpFTBy5KiYbPBLzNvgk/7oKlVZS0ddbRebFwoYnwB5GsP35scTFAM5sDEEu2/Z1xiLq4vzSKFCTqdLPW1qKUx9n6K9TuzT/R7ymPtopJm05XOHbQ+1sVZX9dXQ2dR+iApFHV0dKyDzqGNw29etXpRjWLRzkPz6cp7K4pwx+I5LV/P0xmBZLOsj3GIRoIBzyyaSK92S2eVgWaTtfkEdIUUFVjRFUopZXOxcvmUipWmn1M2x/6GYMN/z8x7o8l0bXIZl689QPe5iHTTTl9JZlyIYExPF0xXTDEC6rXjmYBCFdGukkQ0N6zKfJiDFZgbmBqYj8IKUgoz8/DPwbWHDhhGd7BzgzUb5BChswxyKmaqdDnD/lRLzOUjCkYMP0AwViqWi0ZqaBC5qCfTpPIxJLXwHc5XU6XjlXqDsUchrH+KS1CDEvrcbfDrpVDlErc/MQUVM2XzRLaKNyANwKNLX4aY8uONC7P63r2O/zvmduhSgbFhzsOshTHNs7JGHvOTclE1ZDsOuN464eP6eqDlfK3xYG4WPacz+kxUA5yJNAwYrsP8RQZSK+bVOGwYbeLzYMQCkjeaTtyd0/VWsB31+Y9Jeri86N6RuyA54fyYcN4lqtodY/aArjlkc9KRYzhhS7w4YynbJDGx+w/SnOCvS7g0Lj+7QNrKZn3hz5eFt3tRgkxkkmm3wdt5rLyyipeR4tFGyTnFQVLT67m6/ZUmy1hPn517IN8dXdtsuHLcUbKUUSINCwzWnlRslHWcOPGhxcKlpWaRIdIddIeaDWbKpPK2e6ICRDtH675ZjR1TBFzKgQwVHTZjcHGhigNCxbh8YaiMecENxftGozebMWxHh7dRIrVRNofcomxj6t1a6l0PDLcIA+/uUM36gbVQM/wwu32bqT+4d1eHRwfKYerNxVOtaRnvdEpyxnCi0Xyt2SYI8oNr6k45Z6ptXBQMGTxfnWs+HXsgXaoigo2dlAF8dvNyckar5UOn0qzbVWQNdMylUih7hgnj1/6ZW+ZdJBBM1Ue4C/s3gyF5IVjFkXwwnQYru/nUs4s7x8d2v+F7MyyKhGMFXERCQS0kn0MgQGrj9Hrg66R1dCEnNKUk1hxm2BKYHZtGzvzRM4ho54iqbBHIi24V2HXhMDUOfCpWqsvheGg28i6BecTa81+eJ0UBg3sOQggzdJzASNV6zSQMYDo6QLoI5i6MYDHev3nBEM2RRmM/SWQDGeV3IW6HzpUK+Ob1+L37utNZ+eI4PjpQpVrWYNA3mcWElnhrQwuKKw5gwJV/9vDMF+V35gX9W58c6Mfffak7u6HnsTw7KmbWH10KhwSQJM/B+lVb1nEJBC2h480cuBIikNAib7axaumyCXUQeapAaMlwyMIKZ64NG52DHnQjs0zr25m6fiL9nkaJrPLa6DfHT7RZdeyQUyvnNS/vdPZsqLPTrvr9sQ8kikoKR5Nm+F3N2+/lcx++q+Nm3TrIb3/rYx8IzF2jGInNLXOQefJiOVS0mqmYK/A4XHyl00Xdv/9An31yoe7ludKltPV/SDiQK1X2hg7kJtrZCM9QMgejtVGLdA4EIasF7OsEPs/lEKxgb+aEtXcQOECPkH9wKTFeiXehAMQxBtN8h8YXickLbkN0gxRjzjFJAysHm8UsFoGOcsKAO0B27BmK7huze4fo7C8s3oMLeaVdpFxe0ElNFG1wfwr/GxfcfDnXjHWTgYFbUKVWVKmaVXFYkILLo+MF0e2icdyuI0sjSNyBdQ6Mzfzxjtm5+TCHnC/sMIWl3BqDBZqDFJA6nf9OzTqIBhcEhTZIUjCKYd54E81Wq5VM3gH5yhVCpJbijAuSar1ihA4iV3knG7Q8f37q8AikWg/v3jfjGgkGJMXt9pX3IpZ2+PuSTlTG6MQWeBnVK3AbYr08j3RF/GGcVJmkHny6s3nPKvkdPHeQwvkU8wEYrER3rT0a8ngok9VsvtZgODM7F3ezNRcVz4Azbj4L9wphCPtUNewUIXuRJ4sXb21bebsXZSJKaDqYOP8smtO25jW6vtZqPFe72FA2WVRqk9QC55TLvm/3WbTCN1j3Hj/UJkFy9tZYsxl/VC6JlFqdpuoRBt9pX4jbBZrGrfWY/DsXGl09lmKpJFrHhbtJTkt8LG8OGES1u11YyAxrK6WaLs4uXI20SSLZycJ7WGcYD6xWzDZgQQKRUIGWvMnjdWSN3fXFlUkZyCfQTZ60W1ost54tkm5Ya7VVqtdVrtZ84GNfRxfx5PlLrYk6zeXV6hwonStrMkf7FSjmyZgZSEk75CKrqXrXF74ETlKH7r4hxcA8Q+h+8wKvP0i3NRtO1L+6VJRPap3aKcVBXCpqFcdqVFo+sIjXwdaMpHPCrPmqktnIJCDLeZhjwLQEssOnc4UN4MgVFgbqvLhAbB+33WoKS7VYdoYdTFkgJiozVh40c/tU7rP7gCTx201T0ReLnnFyKfLfWcNO6gGQyk1Wpc3JEyE7Ek9LLPSYT+9Ct0kXZlswdy9rX9SI2UlgIU6IWSCQW8mGCxnDksCyMBKpsG9eQHb8PooqPhfvg4uAtQXEvFjedu+lUkZfvP+euwmzXG2EUDOkzQbjOWLbhesQ1Xe1Vtadw7b+17WZfvRny/rWrKh/5eOH+hP3BjpJrr2O7We7DpAcZApXzphqIEnCepFTO8NMkI554uio9WLlfFVMBvhgVNDOaDWtffvap7ZWLVtbx0zu7r1jR1Z9mmjorxS/S+NEwR3/7z79G7oqzO26gr8ohxFSkEKhblathffrjWdPaDaN2nCZvzHn/dzn3tX9o5bX13jS04vnF8raFzgQw25e7EcKWggMHHjE6i2nEEOCnIJkj+VioWqhauQAGP8asti2rHK1qAII0Qy29s5QHT6rMClpv7AQDGHGSZ8JNtRGe+toqJz3MYU2sVB0lQlm3wQzLInNqmiVww2JkQqs4YUt+fpDoHd8QckXLdu/2ZcfLkWJrbs+ivCQuHJ7Sd48TzOqKXYiZnWR82eZ9Z2f9TQZzrVjHaGVJQzepglETQ41X0/04NEd3bt34nOmEpdeX5SVekk5YSNJ4cuxkLQEBCvC+Xxt7oGlQGW+w4z/N+aO7WbdHaV9WdE6ZxN21Hlw/8TRXCMC6I8bSucJYt7HdCWRVQHfVt3JYduZzzYU8x0sJ76ccnkcpKqGslnPw8HYYn3KAmwR59O53nv82LPBQ89nGZmEZB1oAziwWTZpyV4w2rDpxA4zdCBsmLescwg9Fa+b87Nz9YcjrRYbJ4vwrOl+Z8uNrntDHd5ZKZFhbDBzAPNyHRk5W3Np+DlBSFrZ7Ypii2rA4QwmxnFOUahBUsq83Yvy4298bLsooMGTVkfTXl/TUV/lXF552Fg5SDVSuUA1RtTJyq4v3/+FL+p7f+ArqldL2oj5F0P6YiCS7AW8QImKgryE6puBMMJcKOGzEca5pM0HOzCqDuZsnQ7wQZA+8Bd5a9bxzJdq1FdqVDOGr9A9IR4HkeVCGPSHmk/Iu8RYmGSKtNKpKAzOCQUljma20MTU4ZBt1yB3Es0iQtUF5tI1HR+0jM9jSswHZ4AdFeiKs6rXm+oZzpVadxtOG7derVwy3GliRKOiejmn85dNTccjvfv4oSu32WKm0WKsWvv+6/QL7PJW3eCLSDZjPldV4+BAE1xX4rWrYy4buhVmTDiCpFMFbeOJKzCYaRM2TzZl+jXjASpEdGsM2S/XSycLEBGEtaDtn5CFRCF5hUWPTpVuhznNag0rOcxGgXd4LhQowFJmAeK04jlXQrNXr3TV64YE9EQ4uAi/xpiAIFUyPLnIrq6uXBWjmbtxRmKzh5y5nQr5tJnLxVJWX/zSh36vg1HfXRadMNmLZg7u83aDvdrNK5gvUNVvMYd02lNwA+Ff3mS+QReHhEN81ZRNvIoUrdeG7uyuksccO9LB0XGw/0sgUE/p19cH+p9/bq5/65OOXi2z+mc/+x7VUhv9p49/XvVSIUDLi5XXHpCXLWP5qED+6MiAhfMy/R0/zCX7A61eRPoIBLpYhTQOJKz5ieeZMEqJyYK8xD9Xjw71r2Z+k2JIShBv4q1+15O/qsb0XC/jrc5eXuisfuEOvlFrm5hTKtbVqMHKg/JP8g6owsoXNs9s76tgk3GQkFIpp3tcyGfnWiwo6rLeJzcvUIxlAZp/8Hu2tAVZTrwzGmWYFDitHNuukn3x7OmZtp8yQ6QgwGs065nZ0THRfS1Vqwf+zm5gc8NoUWQmOZAcr3bzwPNL/hyPGJJYcrPTCo3kcqNioaZdNa3+dc/uWZv1TuPZRkvqKfYE8CZSJ+KlErGms7FnhSAKvhQp1PYpLdyZwH2MfAIkHPR4MJC7eFEvIp8HaG6x/bMRBK41u61nfewT4HxIhLkCdnRJIyI3L9Z2KwsitnRgPd7UiVTG4dzRbK2r3lDz6amLioODjuPtKHTL87mqlaKLHNvvZVJ6/713fAmy3i+vLowUlepVLdZB6+oCdxdmh8QkTmdotSl0C9r0p4EdngCSh+SY0TrNewUGLiqbwmt4rfOrK6OHjx8/0mG7o/aqbWYzJhCVUsHcCutP0azv9yPjkXw+pXffeaApLHQ+XyqjWqW+l7GEiw3zGFASz96RwCzXenV2aQLT48eP7SDFMb+OE4GkxWFIiIadmUq+KEHD8obQ19qlIKRRSAG/hkCGt3pRTucEtiZMMU7mEpptpoqTsTe4uxYOORzpMZHOJfTlj95V586RHn/w2PDeCjZgIWO9Hz3ITTK4Y1w83N0HLK+X6l33NekvlNhCWGC+WDTphwUwXc18MNI1QgVmsw9GrwyVNZotX2zMtlrVpaGrVLL02iexUgyMKvLywMXJsTTlHCgnmzFT1xWGWYrYRGXMikpS+XJR4+aRLxrK2SYSuuz2zOpsVeu+HCDIvPf4kV5edxVtSCCXUvFG7UrBVmX3792zW8rXv/5VPXp4X1/+4od6dLej66sLb/DpYuqLIlcukrj3+rsfL+dK5rNqIIVYDy07+fALH+l6PNbz83Ott7Hd7jAUZuEgaWkdHmiy3mg7GCq14i7fKo8xhGN7CEvmEggEHKyprq5OzQA8OTlWp9WwxgoSCd0Gi5VZY6MBsQQId6cUpBoG/utQvQKPMn+F6cflyWHM4p5vVpqu8f4MRIasZ5BpFaoVHR0f29cTqQdEgvQmpziJCUSA/MJFyaLf2UyewFmyBCF3AK1wgNHtZrOBqedQcZJETOB5IztyE2m4In4HWJFOhc6FAwptXlKZ6I2qEvnIAoN1qlHQhmAC3mi0VK7GqtbrJl8RKox8ZLEKAc34hP7I/aX+e++e6ce/VtNffFXS2Salf+HZl/W/fPeZ2lmCZJlhUVHjkclaj5QxasFMa+lCAQE+uYl0BbAKqd4vzq7cVTFvseF4Lm8nJOAsDoHBLi+MHv/o6FdoyYEfb/R9z39anz//qgtAilNkGHQbuSzh5sw+h2bxOqC6kLfrFAcgzGxkDO449p7NvHBkynAh5ykEa3rn4X1dXfc9C2RW/rrQ2JIzCdszYcjMc9Q0SM3utbSI50q4MOOUZ0+fqT/qhSDwNIUHnAbgavR7OC9BDmpaoA8PC8TAkOv+vdkohM7WnUK4XM4vr50iw/4lrYU52gGZlpmQufji+bmmcwq9nFnhO4gmZdxlCA2YaDLCjCOjZgdjD/yc90hAMtJ2H54MkpLK8v0FhAUWLXsJd6t4O7ekolCAkUkW6Ha/J8L8tNU5Uq6YCT/bM35sFW+/QxwLUQzAuj9bXeniqqdcmkSUQ/X7C51fvrJ0LupudXpxqQf37unk+MBnM98dcGmGszqXNYRNLqcNSvJ5XXavTUL0jDWD3Git1XJs6RpZvYRm83mLBYhRZaXzwJULpdKYxCSUX+PFe6RKpajBYGjom8Lm1ctXvvC+8pUvh8KDMxZjj708LAWatk+egqAGx2Ewmejo+I4arabHM4kdKBYez3OvM85pc1yI/yqWwrhoMlUml1Hq9NJjJ+b3U279VNZFRxJ/akdvcUmXPK+dTwPLFf96ih0gfiOF6GNRWrzNi/L9L3ygTJ4/TgW8U/mgpsvFQuPNRo1SWd3eyLNFNt3dg6Y9TsmSvPjOd1TYrFVsFs2u59IiHSHhEFZmEkFADtM1GYPJb4ObtFl7cpVm26dsUeVCZe9LuNIl3oWzuW2UqKYCBg1hJ2irOOjYe8yJgA5gSBLE+86Du1ovnzt/cTmfebiPxyMDbSpFZmR4c+ZKFWfVJeZpX5Rc78vNViUG+DugYOQSgVUFBMUli9nxbLVUr39pwhIHOrNW9OX3j0706E5bZ8mVruoFlQspfesXf9bzlPsP7uv9Dz/QYDrWxfW1TZiBf1+/6JYKGGXndC/3QKXDlqZE00CDXzfdcW93OI9A8MGkfuP0eaKQeqPI8FUmdWuqQCc555jAxHlvRo62Gtu044OOqkhuFjN3NG58ojgQECobDacLf9+5EoYEA/Xqx1qVm5YxYHEFYQnyxjqqmAzwrA7rsqri868ZIoTEAHEC8hBFyeX1lTt9umG6vZDjCEwXoGwM23E6wVv04LDuxAKeab8/NAkmlWKuhzFB0v6ObDhgO57P60P+eqjspmdoneIJ6z5gyBIMYmj/izcSQWw4nfYBwCZEuwgL+d7de5bPgJ1Bl0eLiTUcXSWdPp08XqLZXVL/2vsXms/K+on+oT5ZFPUjX/9Iv6Pd1feXBvruPP7GYTbE75iPQ+GHdRpJF4l4Z2Rji5VboaTNMla1GohNaDqZi2ZygdAzWCf0iVr6iemJfmEZWr+sIv3Q6hN9MPtEfaBJ0mSQOKzx5aXNSxlJobudTAeG5LgcmYeFyDF0ydgP4mF6W6z9ws99Xe/dO9LBYcf7Eu1apVq3A1R5c8vQRt5TqsBnCMbezNy5BBIJoF6Qp6RhcqfaYxACyQsfX3RuCMKRJtAtTlbqMO6ZrZQYDJXMJG0bafkX3XaE/g7yXkq/uKlpOeE9w5Zd6QoP6G1JOXItdxslhtLd+VifJx99ixF2yhepreZ2MPrxysVXGpgdJuROzYOaqqWKzyj2Mqxr62MN4/Mego80nRIQpB1tdqHz9jxzyhhhbQu4ZKph8iDEJGbJ6HRxngruMElLQN5U821jbBV3irdrd86MMdC4grTh9LSN4AeklS3gwDTXp0+e2+Lw7smhWo2akSPrPA2lzlzMI9rHr5fAe8chciaYMEP0G89pZw9oCHK93sDmHYcHDe3SdJOMTKR6AyQko8Qu7YI1+QJIeOxZZ6lW87iAdB/Wc6fZUhUt5xxCHgUqe1u+mFKwz0Gg8AOeTpUvBhYqs1aKK74/0kuQ6ZF1yZnCTHM0Ir0EbWbBTdWTJ89sekPjYn0V5C0LrYOzUKPZ8HxyC+cCVGg5M5mxWi37+7Ez0NvuKJPZpFLc2L4rdyolmnpYbmh8OdGzT17p7NmpDalbqZTajZrm/b6uXp36w49enKt61ND973lXnUfH4RLYhWxLYLvFJla0hpZMjZlSpVTVYsjQdaXJiEHtwlo/HryzKS23TJvmyxcYzHU5HJemhwfjXDohPDtxfQH6wtosr3vFEwt++8OZutejfZYedHEqw5XiRKSIg7lcCWQT2FazuXZU8k4WYG5EpYZOK2vTAOCqYq1sr1ZmSl/6ni9oDlxDF4ewd422Bwx+oVolq48+eNfCa4gg11ddxXeP1Tlsqww9vljQdLtSI9mWXobvfpOSesupB9W7fEatowPlKyUTdRZnK2d2cqXRIbHzGbpzmEMUyPSS7vRZPLb1854OpBzD3LOZri8vvLCoEsmeI5ezBVFmMtY24gAN3R0Qduq6p689+gHLYGCVnXYea9S48/964XzpVyizmOhe854vxqtiUV/pfkPxcmF3HRYwBwpUdxI1HKhrBxQ+EcfsWqlM3vOJu3cP3F0ARTHrKhbQn7KWmPkhlUg6EYOKcR9n4xczo6N80hePZ312isGrL2GKvGHm/QuGr+O3GBHUioboBv2+smmgWkzcAwlpOOxptZmpjUdxIatSsnBLkIilf/HoiXWWl+uc/tqgo/+i2/Zfv6dZVDO50o/ULwwJUpVzeNBdWKe3Rm6QtsH05dmVta90aDhT0RUwJ+Lf/9r6sV6t0/qvN7ff/e9tdqXBtX5l4pn6tar3DtU7DGO8cFOVkp85n43vdzjqBYF+p2lSGl2SJVEL7ArD7O3m9erlpUqWHkAcW3mW2Wg0vYY365wUSLleI8USHIOVUSCAeGvkuBhtHlBUq9rR0VFT2/VO7VbdelH2i9mxmNQnpOli7uKJYpBDjee7jZYuBqNsTX/+supkDC7Kv7G+q9Hu9hnehAn4tb/D7276+vKy57XcParo89O/I+5yvhf2xWaTVK1c1OFhR4cHNY+Y+Nl0bmYtw5BOA9WFi5qLksLOjMr9emHsw58DrSjkGPdMvDYymY4G/bLm65U/P10SI5b5cqdWe6YOHA/GT/sXLjx9ZCtbHHcoHtACohvuB90xxCCkedhUWle5UbdPTGDasGm1AcEw71D37p4Qox6jqViNdsUFCYWWiTyoOuIwiwcmp9DB3YaLCslOrpzy/DuZAiaG2wihMxi+nNw5cIeI7pfxEKS/5YoQ65FJmCAJaJUZj2Rc3IRLCcITI6taJu2g9Zdnp4bRbcKx50YAR3OW0xVDUuQM3m7RhZcVJ2LzTUCKaGLo3M2CtUsYWudwJ/CdcmmnTO7EpAQIOMjCPN+ejrXYO7m9tYsyS1ArBsAO3bY83xh7CoE4GYsvz6yPBFJh8V29PNNuvlKBQ+lq6Fy6ZC2jowd3TAziC+ZhAwesc1vFq1jdy6565wNFy6ARYyOhz4NAsFh0fcBDGWezoHVkc9M2Amc59WKBy0fBs5/NkopxpSy+jg7EJaqJzZTWnbtHyudJA59oO1nZyJmfS4Xj4fFsLs2hMON8slAhkzXRgSqGBIoFcMsOC7eyvWDRYfVmMxv1Vpo1FetVV0rABCyOg0ZLtWJZl2dnhhnZ4MyEABiL5aqjZ7718Se6RghcLimiay3dHvSVTkvb8ytwpiCC326URTiLL2qMz2vRGXdUyMyw0ELmiDZKRIZwuDMwqAaWCtDr1jo2iDe4dMxmUqfdNMsTejewTatZ9RwBwgpFF3OVv1X7UL/47uf0ceV+oJD9Ml+bQkVPvvRbXv/7dfVYucVUX/m5v2Qqd5gREkS8U5wOOj1bWqC/y2a9YZmLPXx4z7ZhdKFPnr5QPlcLNnG2xNu4mmy0qzo8bisq3kobgDpPjtF8FQwjc3kwzySyi4zIdap1+2YTQWvaI2fy/MwuNLAWx6O1Xr068+GPDSLNOZIJumggNV8+6PP2Ymq65v9xY6Lz4bUyiZ3+cv/AP/4v9O8om4j09XnVzw6I9fcmvqaH27kvwu0O0hIewHLaxumrM6+zy8b7+kndU5Rlbr7TP5phSXf7DP6Fk65+a+6Vnl0913CCiBpYfGn2MGuYgyGZKPu9sSCoqpnDIcSns4Nli36yDKFoOrXl2psvoMXzc8gkwL8ZJ8QguTo6aqu9Lby+KEFzgCkZuXFBchizdvh+MIynmH3n0btGW4a9sR48vKvEaVKb6yvNMQQghQcLwF1OlWoxODURKZXNev7/Jy7vaayC/tHsl8dWvHm9yjT1Ss3wLyePdVnoqDa80P2v/nUf7vcfHuujjx4Jnsmgf2X4GQOSZhMPZgqMtRTBAoVpu1YilzGKkkowRyaDd+e0HvbMZk3+Yuie16uQ3Zg5bHq8gO0eLPFqqqT+sKury0v/zvWqeftdE2o/GotAFxJyiE2D5wDyEhKRwuyabtOzI/tepT0mmswmerf0UAcHB/r69ZUur7u6uOiGSyWR1jvJe4oiGL55J+gQ88X/hlkLTmfAnQcHbRcmXDrAryUsOdF3I/vKw2pmjk9OaFFH6rjQw35xu8JEIGuDhF5/6M9bLeIj3FKzWrU8zGbqwMLKa7fZasSZ3xuZnMUY5aTT0XKOMxNmMrj7EPAgzz6RlmBYMZ6NjYDZ8QrwEUliTH7mPKCHBNTFELxSWiGB47KVnNPJmqQwZlQUgjPestcrzKVljL9ebLYQrLFu/1qlTEmPP/+OGvWSUmtpPZz7ACKDjUUCdLGazrVKx0rHacVY26HRgSDCHAp6eyLtL5ecwSffeKZolVa91FYC/RFyCnBuSA04x0x3hmfGxMlks3r48L46u4SDS2FPkfSdKGP6XdTDh3fUaQeHFWYD9iyEYIhdXZHLlcy8nQfZXLY8qG733DRjFgKwBp0ouqpSveYHu5pvtEwl9bzXN8aNkHk2HZrNxiYqX490cHTk7mi7gpQU5mVAH3ihbkexhfXJZcYdyiaZ0/lgoYvJS03ZGfmpXVi+vplKzfv+7jO5ot55/3PKAtfhClOt2BIKazpmNPjKAtkBswCN2DJqMrMMolGrhvnWeuvFwgGQ3AXrP1Pr82QY1jz/w1eT7pqCgEsK2Ojlsqz/1fa7/Rx6u5xW1ZBrF4KPpXd+/ifUefpzniG02we2lYNsUuTQLQGVz3SdLurnfvAPvF5Lp/UHStR3uvqhIx/6j7/5U7r78msmPzlHdYffatCp1RuYjR/Y2YUNRj7eVW+gOJFWb7QwCYz/iIqRYGoSSLg8pwe3Bw9rsFqpeINwedCt5KoVxfs8xZArFV5IlyCVNNoh2QEofDGJ1OtO9ezZKxXLFWt3MxnIZkeKMFVPU0kHb9TJOjh+cCmDbNypx/rR7Ll+/8m1fvzJQ31rXtR6l9TfmQeGMa/nu6ayc8z294k3+7cTJSNt7tHREIxe0PDGuiUcp/7rN9WH+kP3J+qkNppcL+zItJhstJjMfKBvbjwxs2lDa4wf6BpanbYj0lgTBDD3uj1X2sDj6B/X0dpF182rVmurktmFWc8G0TdMXhioNRUyaGXDiwI4zOyIF0OCwZpbuSvhhUZ3OBwrn+x7Zt05OvJoAY9nyFmbaKUMocB3O7pz0vYs6afmDf319Xu+JF6tcVbaf/59nfDvnDzTg3zoVs7OrjSeLlQsBkYv/0y8488mDvRfVUKQN68nzcdKVe/rk877Lo5+47sT3a9TKE/16lmwI4QIBxT5/vvv6sH9YxvXA33bro555yoyWchcCLrvVDA4iTLEpCFbGHgODAkMzWelHFvvR5EGszV/1LYLUGLHbPTWIYYuKMqV7C3NbB+/aQLtZ7mMpSMP7x36ecHeB5WDtFMqpFWrllxg+uJYLr1XkPPw/Q9HM2s88xd9vXxx6QuNbm29HAeJF0znxVwFkLJi1TaSsMmZu4rOGX0m5zQRcHN8eufKtXNq1stKxFtdlbOaYcSOn3Ym6zNnSSG6Yq8EmRgOTOjlIRRGCYzwgf6nJkJBwIIYBtHo4Kih2aRnj2R3w3Fg/+IhXoSVjZczHtEFZCYhKxWnIJC1yZr3gN8yRTTyL4wgMESIbRrPmZiisIlkT2v+m7d6UVJ1AHtyi1+8PPVFSHIEYCmbM5s81Omnr/Stj7+t3DbYu+H2ms7mlSuUNF9PtZpvFa2YVJM7BoSF00lC28VWo95IiS2C36aWO8gHkDrQQwU6uH0/McbdMPSNlI52uu4NPPPChcL5gdDecZi1CXBO7XbdmD0zgBCgC7sw5SqJS5VLhDkY2ivmMdD+x+Op2X50B1THzDxZRP1RsBXjy0eOkeDLJs0njlWv1jy7WS5nFvlvL/tmX8HiZaB8dtE3RZzZT7mO8BbT44RG840KmY1GdK+TAJ8ysxlOrvQsUdFNAcxiH1U2DnBFGjBbrzyLMYFzK01IU4EeTfGgYEzMZVnKlNWsNVzJAdGQdnJ1ufO8Cu/LajGvZq2shw8IxkVkjZh7JsvJshVNinX9sflXtN37cOYVqayNfuzlf67u1bW1Sz37xy5VWJdVyWek2VTJxVy1zE7NYkbD7VTp/rl+41/6N9wNUiT9w9/wh7UoNjQth8viq9/3u1TYbpQ/+0QRc2NLTRyAZijpzt1jJ1YscCtBZL1jjgN0z/e1cSyZGWyrtTtg+9XyIfaveqPm+KXVemZ2qBIVa9qAemxOgUPG/gWklEhMzQDlvxsNl9a6Egpr54/d3mGETNNU0tIX+6x6phq6N9YjxBx+BxBSu5BUeTfTv3f0c9rFGV1t8/rDrz7a1xs79RKFYBT9j0fjcYvtPwbJCMVEyLKk+/uLH3yyHxnEdlJhPs5szzOglHTQaVkeBVsXswiQnhoid1xbOF2i2IUNUixgLKBvqnfwSJiOhTz0/ds3RP5gq0HwN1II6NgLzecTDfrXWlZuv2u0onbWYu5dxNR66jFFu920KxYf6fLiwhcJ8pCjk6RanY7nhMv1zM+c8CFcV0gBep4/0X+yuK9oE+bI+d1GrXiqH539TTXq2NsdqJxPq2ozh4Tq9bSGfMZoqm0yqbv1nC6uh/rg6U/raPhXPZNKZhL6K7/uX1KcTWuaDp3+j1619WczT5RZ7SytOj8dBNLVbqGvzr6j8XCi+w+OlU6Texp03Sb+xRieY3OYMbwM+xxbrnweWL8aiGlU5zjBJBO6d+fYKI8dJHGwca0Gsnb7HZZLVW1yQ203E62WsYsIvtd7JMFsGOdk9eDBoS7OL/brL6mTO8eq1kvuKp+/eO61ShcekLaeyyre72Aw1te+9i03G/VqRav53PNqIhF5MxQ5tuLb5wvjiCP8cshy3ES6PO87TgvGK2MKeAO1akGdA6w5pXib1jSxVjznN6Y0HC+Uz8/N98Dco2DDE5KDinry/Dw4cNlMDaIPllMJF9loPXtXA+WRpi2AyHFIAqqGVHfi4AGCtGGln1/29dnTF1oQRQdZpwwEnbcblNNWZmvrbP3MihjVl71PKNhA+N7qRYkzDu0sB+np81faLtZ69PCROgcH7k5wWADSYmu1j4/VLNX14rNnjlQpttrKptued3326Qsl8hnV2hVlC2nNh0sNugN1L3qKlls1ynVtMyS4Y+gbKb/eKotwFE1beqcdqQl2mif7LjASu2NsqLiYkl4AuGtg2sst4lafP2yXfXp1bMMiDQhYjTeu1NAD9vt9XzY49ADD4vnKruYLB9LkAuXgI20BQTGVZXFvugtzLpkPmXKRiAVK20aM7nt6PTCTl3liuZQPkTdb0k4KGi3W6g2nuuz2NYOnnkpbdzgYjzRrhG6S12Q609mUqohFjEyCwzw4+pMSgFgc4a31WkA/bsvQawY5B78rhZsPuiGkHCnCfauqVQpqVIAm2BjoBqlsl3qWrejHRx/oIg6uFZXERh3N9M+XX+rDzFJP+1nF84I73DUwdRT8YikS6PqNGOygwGPwsPMlkrX0JjiY/Oq/9R9JuZL+4a/5g1pli5oVavoHv/r32V7sh37qP1ZzeqkNuYOZndqHNT18fNfWh1MO3UrJWrfRkBlwkBfRh/G4mWUhKyDVfJ4vSoRamP1P6xFss3yObVbWSIIUMP9IrW/JPGzIWSpECxGhdHjQ0mxMmOxQi0XBXqLtdkXvPDpRq1VSuYz1P58Td6KUIgwz5jAdQ2JJJlU0QWjNQGwNQSpWdbPWn1j8F+oPkEos9OdLv0rdVC24u+yDeT1jyRBcG+ChL8bn+u+mP3En0jxoKJfKOeya9UnRNx6PjNIA/bFP0QUSmtyoNdRqdCy4JyHi1XTiAg8o7+7duzb52CyvzQavVYtarolam9jesJ6/7RQxW1gOuj6sO51aMLGPIUnQ8d4eI95ie0NqFy50WUkYnlkdHbb04N6Rnnx6Zu1fsVhxEsbJvRO12g0182VVahQNWz2Ly/oXZ79C8SzofZrRTKV4pX9+/neVj1feR+PVUrko1rpa0jg5MKkDZjNa5d0aFj6cwEiL2VRrIt82K6WiSLVSSX8m9Q80Pnqsf/eiqos4q+kuo9/36l21oql+RF+1rd/qeqYicVx5oLwQElyrF/xZeD5chLxcAGZCZNQNG9dFNpyKHMk3nJ1hjoashGLFkU/a+HlR1NIU3LzYM7D6gSNhoXIZ4G+MtAwcjkIboT9cB/uYrlZ2meHMYeyCixRaRohFXHxwCSi2t9ulUlGwpwumCmnLiIisg4hpFQFMYWRJ04U7tewmo1K1qHyJonChy8uulvOtamVISxRBBVWrOR3dOTBqM5tuNOgtNBoCQWOWABSPA8pY5UpZ7UrT393Vdc8EJZzYQD2IA+OY5nzdrA718MGxSsWqCkV0lAPN12TYEgadV61Rt2yIxQYbG1cunId4DiCPIJ78xUpk9ABzHM00Iwzr8VOEySOzmjr27K1elHxoZgdEylSLFfUnV5qNJ6qWK54n0oWRCLFCesAbZMaYznmel+Kft7FOP32h+SefOSfv3c89NMaNf5/tiYZjbeZIRRjm8jBDZh8tPxuRSyEEMAdMmkqH4FXgvYvtmS8x2H25VNYHJg4UUO9NXd+Fg8d2a6uNLs8v1etd+zNR7cHuBIaEpo0TDIJYqjFo9cHbETNfqPN5LRNo4WZarqEpMGfcaLIYaLhYuMuw9AH5BDZQO5lCz2ckzIgsN2ZDiVw+XO7KaLbaajJbmFELcQVyiw2jmVDvXxjAv5xeuEOtokfdkHBR9ryo3x/ZJYZqj+8J6zeyI13Z4paEMDiN2wYDbbLuqvbwbLdqviirpbymY4qE1etZzn84/7wuVDC7+bfWh3qcHOgH1p9aepEuNnV099BTkd31YK9RBQ5DWB3cc8LvCmuCbg14leLDFnswOhHxx5F+49//P6rbvK/PDj/U+eFjrfJl/b1f+z/Qr/n6X1bj/OfVOqjpvQ8e6uTekXMhs3FI/zhstzTpr7REUwrV29V8RrVaUcd3D8z4TQLJ7l+z6URRDas8NIL4gwbP3WDOHNyFXl+URImlKDrYTPieVvX+595xl4p2EMMKgl2qFeY3eXuNgkqQWEAnQCdL8ULbiyaXmdt0tTCzkO22U9oHzre+/dzuJiAIx7N/qLvORIWpWNTx4bHu3b2jdqtpshGz9ul6ZKiYTo0Rwo120YevtWOYMxAosLJEAL0pKAdwIe/nDFP9GYXMwnNULk4MKljXdKIn7QNbnS1XmAjgPtTSYa79Wss7GHQ1Yr6TTalWx0EqsDyxjssc3h4jHNzZciBUsO7peCl6yFxl5viFL35O49HcnTp7p9u7UgZj7npBtULTsPY/WuT17y4/5w6xkVzrV6QG+q7Zt3U8uwiFF7fvNqSCQBZABA9Emc/NQ4wUIwWkUFFCk+lSs/FQG1x1YF3aySuj2XiqWuJT/S/SSf3ErK5vbwr6+cJD9VJl/YXWr9H72edKXj3VIr1UJrtTq4VDVTA6MBufmd4KA/pt+JmQjHB+2mvDaRzsAoVeD3Y5BKAU7mUDTQlYiKrWaJrABXOWNvWNYqNUzuve/SMdmVyFVClhwhdvAPg7inEoCmx+oFe0v6AX7O0PP3rfIn3WBFIO9uir03Odnl9YqkHBjp2fQ5crUIG5qC90zaVTqvjcJZig0iAbV9qOF5ozYsCpiOJ4TWOERpZc2KUKBSK/ciYu5ouYYeCCNdNwQKcdLBwHA4bYZ+5CkaxcnPdshYeJC8+J+2HQH5lMCBkUlIyUF573YDQNBXg6pfPutWZb0AIctjjvCDrI7/25U3Y9chSb/WEpqFZ75m+Yf7M/4HYgCQyF6VtODxn3xyZKwOp8cPehOtWmLxWoxFCEK8WGNXyd4ztONXhxea0uhuiL4GCyBUItwJhj4L3Q009PbZuEfpEFnBU4P9U4YueZrZSgQNPP24KOLWciQhjgAB9SEVhPZ9JAwjMsW1Gl0oae4ngRQj5XMKZgOSYd4Dkc9i2B2BYgacyQt6uQT2gUjwOrNgl5JandKoTrIkPARCBc1iRVIOyna/Q+NbYeJ9GIImKGeHTpRVirVKzvoWMdTJeqtjqqtI4NA/cmuEmQqJJXgmQNX3RAvUX/lT+4zQ/kIJzOAwGlGHEAAFfY3sjQBbM9u6FwOa0wGYDUE2u9GVjnxYXPe2RQn01mXIHNpyObQNSx0MoHstNpuqH/7eY9fWaV+U4/dnSu33NINYedXUXTCZpSZpdQqxnsZ9Q5aAMiO0kcMwhIBpZ12HkjEHNg7TmtZB+1ZfnDitDirdqXT9S5fqLz4ef19z7/W7XKFPT3Pvgt+qFqWt/XXuj4btv6OazLOGz4PBQSkAMmhbniLBczziLANVS3wRSboun1IrfkYKPZPMxucHGBGg5RzFpex/KEFwQnoHjDSNaJLmybePduR+Uy8pu18jls16BTUtgAwaPDZd7DxZCy7RyQHKJzOhEIYj7UkjsTqgYDUujRz6UVbUPeJ+QCfFZZd0DlOCmBaMAmzOyYyQ+94QuVvJRoWMoEo5ALk/dJYRejY2AcEMH6I+cza2Y3IwWbq++T3YPperCj5M8eHh3aZJqgY4wWYKR69rWHO3nhr5rZbl1ENpptrdZT9QZctmgmbw959mL5oKTVaqoJ0W2smQThwiM7tTx+/I5nhk+fnBni5FIDzsXkghnz318d688sH2rGntRGf7jwiX5zY63L3UYvJ1EIus6lVMoTyURCTVKz8cIFNR7HHJoh4i0y/4Dur74qSJ2WO3zOGyA5rPV6Vz2Hnn9+9VLvLpdqVrr6m53vVb9+V9/8vt+jL+z+ooqTC+t4KxXMw5vKFUGtmImxf+kMbZbsboYuGsYz3zEdJt8/BTznHdApxDlGQqs1FwNsZFi8FPSEIdzOySEX4mSUKaaVqhYUx2XbvIHg0pwAQfLcsNNk7OGZ/HQSNK0geCVM5kkKQbMYkBRgTwqhXr/nWeZ6Oddilrd8gshB9OgvX56aX0KXX981VGs1lEjiYDXVdkSkHT+3rdn00mSjnaqeA3MOpVKgdzRTkUrltAs1hydvSRaBDIRbGP/NqQ4Pj5QCydhyqqcMhVJ80NRwB+z2cDbFJZ3njLgyclrN4Ik1mCc0nA3dWVeKFVWKdVtF1is1j998F5AQhE5eaCoLLhaR1hBwbR35zfN6I5z8rVyUF2fXhguodMrFigW1QGzQj1+enumwTTzMsa5e9p2JtyAeK4oNL4IbO7IGc1viqFIshJVaEARyZVeeuIFwYBEOvLKAFL9QnFzyqtaomDjkmAGtfRFS2YDXY4dFh0mXYqZsAi1UmHEAT+J5aOslRVquYXhODNW1W8AMeZULs717xgpuu0k4yTQHysKLD4ZaDkcYHGnoHLZrjWc4giCKzTtLDhiDxQWRJNpsfdFjfEAVVG9UrTkkS3K+3urJi1OzhRlik0yC4wacOT4nlS7zh1azqZe5W1d7DsD5HPr2zCkW6bsnARq2zyqHOq4VGI1TxaI9agT6+T6Pks4uiR4tmB2qUi5ouyYIu6DxEAZxXZtKQ/924kM9xUpL0r/efqofOVgZ7sY5ppTK+3uxFm+xVbHC4sdtKOjeSCmB3o9YmfmpsxYJ087gBMTzDqQs2I92Mdy7nFA0QDK5F1/q3cuf0v/+5DdrXmjo7z78rfr+g6dOkiC7LxBatup3J+pdjXwZsTEwRKBj5bDgUgbuW60oJt6s0INjENCzpReWn1ChZszA5vC9eSGlQZqB3grIkwt2uQjhytUKBvxAoml3SojZKc1sWo2FWppsy7xq1diQKtICLlGvy0jq98b69ree6+p6psmY9U4XnlbC0hLQj1jFWtEXip1xFmgOcSPK2/YQdiZICnMVDODx9eUycqLPPrkDNMU2wWaD08HidoV7zHav9/Sx5lQIXGVK1Zw6nYZ/D0Sn5F4TvFhBgnmDOs9+RDRfynlNb6OsJrOutaarNw55w+yZnBazhM5eXfmz16sNW6/BvC6Xa/rwww+UyZV0fn4VDB/o/uK1/uEsrz+3u6/eDl30Tv9q7mf03Vk6xZZNMIAg6ToYNVhPV4QwFdj3owmoyNpMeHw8ma9yeTFKSarqwgp7SkwxeFb9bk/PXr5UOs/ohO5oow8HP6PcdqOfOPlBjQ8f6Wu/9p/Wb/v6f667pYSarYa9deFd1NuI93M2pKdLxLzkxs8XJiqkGRyTmGGTkIJnMazsKF65yzSqlEyZXQwYgPQHQtDNi9EnnTvFIX7LIBMkrDjsmkQZusEE6wZUBGP9zf75AgNv1R+gg+T3QIw5dsqSi9pWQ+1B1SbnFFIUtBB9olzkZJhHjx7p5atzzc9XHh/MpmvldnTrsf/cap6wE1C7vdHVJbwLkBQ8WBm0sufIP02oUIY4Fqvdqen89EqrFRfczrApZCBIRhRqdumKVy76QJxYgxQXZveiLsBYnguZKVoqfDbIOdEqoU1vrMl4oWFmpnY9sqkEpkroKs1kdT7yzsUkmZ/zQjBIsc80BXGGEVms/BtWoW/lonz+2Us16nVr0fzGd0RHpVWtN3XgUOWyK7p8saRxf2UbuDmEHIwEkIisV3r64oXDWsHOmf9Mh0ulN2gTYdJmNB0NDQkRAuqk+X2Qa5VUi+XGw1fPAMJJa1nAmpgiLkp7+rEpQrUG9l8qJj374FCkytNoormp5sAEVMYdHXSO9eknz7RcXnuTQV/HMml6dW24KF8o2b5qNCUoeKrBqKfZfOwBPMbf9SZi5VivzvsW9lZKaI7CTINulwLg5PjYVU1/MNJw9MwbmkqPTccQB7iBdG77EG+3PqiYQd28IFxgkMDCAW6iWuq02z7UgHkctLqK1MeFJ80M7UA7IIrF0lCg7Qy5TGwcGeZHxHTRaaFVuxjO9MdLv9kG2r898US/t/BSjzhwd0hMdiqUgOcwyg6RU8USaSgpfetrn7iwYW7T62ZcBeLFCjU+6codJ5QAX9+wNHkOWfII0S5mYQ9m1KhXLDc41Fh/avNTOq3d1Z9avKc/OfhQX/lgpBORvp6wN+fLl1d69fRctVLTSSkw/8ZU04WMDg6bah2UNV1kNC6cvLF6EyoWyi5sVoueL0MuWjbmdDTTfHZbVeK7ivYXKNcQZirMALmkKYhIvkBDB4xDscZ6GQ2uTNoA2q1WaoYMSc/gc1Ot47zDhT7g/Z+eazKJlUa2lGdLr6z35feWmhU1W013H0FXh1Zuau0yh2s9TfIK8Fe4kCySJ5oom3eCi6UbmZyLPQqGoI2tuIuF+TqZgFqk7CBlh5iDkr7whfdUqzbU7/W0WEw1mWy1jlaqNYrKbiFnhe/l4aN7auZDespqDRs89nwKq7JpoY9SMdyn+NoumYutPINtN5APELK+chGZiIBck+ocNNRoNUL3MBrraVzWf5L4fi13Gf1Y/uf1vZWNKtu5C1SbgSRim4XA2MXEgzkahZr2JvHz1cwsdfYssVpc5vl0WtPRVOVW3YlHFEB0Zdglnp9dOGN2PN8zPUm5iTc6/vgf6p95+U39wv3v0c8ffVl/5fv+h/qT0d9WhhgCiibPuOp+ruiVF4uZOydkc8jNKKpIX8HExNmwWTxokcIFRyL2A3+xp+q1hlYYpZPIs7uVu0Aki3cLQ7owtZ2isQwF/fU1odvBA9i2mfv5Jl00/Iz7x0dG8TCSOD8/9Xl8fHzkS433gh7ZF9yKpmG6VzAEFI/gBN6j9eMbEJi5O+41eu1ZpHk8tR/00dGRC04QCVjunM0QwBjNwOIFMcrl16rVOBdIbwENCmxe9j8/t1ar+bwFkeRMI4mnkM96n5y/6OmD999VkYgy1ATI95RxCMeSixmehX2GYbHD9l+oXKj72XL+x5bQBBkc1o+czyHkOq1uD+MRotyA0hlhFd/uRZmK03rx2SvNxnNVcKPPB19FXBU+/OiLmo8XNh5As7NeEuoZNEbg1hyRmNbioILl2Wy21mSy1HS81oaWeMbQvBAkQZCGiLIFvtgltdri7MDlF6yJaOO5aKItC5f55sIHGjExfOHYipG8Ybd5LhtvsqTyqbxnAZg4I8xHU4TJNeboXIQQRCAwRHFRg+EwhAgXoTPjQlHV2QX4/sppI/Um3V9IPWh2Sjo/vVYcLfddxtyXPtpNKiwLmg0p2P7bNmRLRPbAfUlikrKe/fLZ+J1csBCLNvXSG5ZWacOvMD0xdL685mBK6eTOHS++5RYv2Z0NGMDg0ccxI6HqplKl84LAw+agqwh6wpUtwiaJvP6j49+pZSKn79W1/mDyU+WddBB8OrMVoGE8RjfapcP3B3U8n29os36g/vXIlV20PdJnn8K2mwdNI0pvG39ntNomfJCTlAg8w8/j0uY9LZZT5eYJk2Y6B3dUb5T0lRpmExf6jwfH+h1/t6m/9H1btTZje4I+/eSVJoOFBtcLZRJZV+tcBOi7cGpanU11L32obfr28qtWiAJa+CCjO2eWCyrBn2fmuF7fdp/uyqpFnpR1uVxYzIYy9awNMDbLQFBgfe/w/yTrMV1xKDA2Y3ynpBZQxWJ6zloFUufyM+N0G/twKBRxRMKpJWOnlkwyDrFEtoOjY8EhBjP6heboHbMVFXkvZYgVWWsf0cIZ6mZuZyOMvKFMZqCxI6IQYQfBeLWc12xGoROrVKRQKuqdd97R4cGBri6u9fLlc0tzEjBeK0XPlt70y/3gg3d0VKt7Pc0XY41GfUsdMAG4nmel2pf855ixDodXms84PDF4qGq1Smo2idVo0AFC4gv5jZ5f76SLdEX/s+gHPdr4Q+Un+g3ZoQ+mAg42hBkMByZkcNZgl1aqFVSwwTW5tAXFFJpRVcn8LphOlLFxZA0jg1orm4yNaAG3UdDstpGZvuwBfr4LiTipVrOt7Wqhwnyk3zH4OS1rHX2rcEf/Su6H9aerP6daCug05LhOmXMBaZIOAwM7jnV5ce253GK20Z1jLhM6TQXm5gqv5rUDD7gYkylg45w7G96EXX72Ly6NbBJtMPNYxhacpWgyp8GpbEOhBnkMmJeLbGe0zCzVlXT33okODssu8lkXEBFpHuJ46EvdMVa7tLXTvG8KQc9YKT640DmHnI4S5qIFJ9qk9eL5K40GP6/v+u4PdXzSUrcP5DuzrrnZrKrTOtB6Pff5WSiCvBCMXDf8T8JHvEvb8pTgB3gM9+/f80z6xYuNRxC2Fi3mVSmkjQjS5U4XNdWTKY1mC52fn7vz5HuENRptVspzWaaZja/sfYvRDJ/ZiTz+Xump8LhO2SmO85JCwWMMQtPfNpknnympdzlUrztUrV1Wi4qw3fQgd72c6ers2rPKEMPF/CRUTBzcfDFUAsl08OJjIM77o7IkcXyLrVYm7+rYbhNUYBxt05mzIwN1mIMDOyNovXQYiLI33rTIPO4/ONHpy1dOLcHEF5NsBgbU7FRlHtwyvK7VAkQZE5sz0eXltQ93NI2M0diIOEJs4wO75bgLHPaUSiL0SduUGbYeneqHH37OkO/zp8/dFZawP8OGC+u8LLFgRXu8Ht85seVXu9nyw7+8unbgNN12eOhQyCkkwobjAGEGcvNixkMlhhE5pRnEnTVwF99JuaLG/jDhUgfm9iIrl9zhUmZR+ULJbrehtzMP2mg0HOiTRUH/lw/+CS1TeWV3ke7GI8tIkqm8D3yeCf6LwMLMe5eIrg0FByu3zmF9H9gaaXdY03Z7pJcvLzQcBzbZepNS5+CuSTw40DAThF0JOxhikj0tk2n7ph4eHtg6EDuuQjml+sHn1M5E6m5S+pH/pqN/o93X6LNTpzJEy53hUiKHqKSd+k5lPluoiNdtHggnz90YCo29oYEPhQ3rBvu+cBBA0CowJ9z/2RCGFnIkOXTZcLAGlVja7Ppm7RBhRJfOoZVKYd8HI7bpYgTJDvmS/PzQTXOwkWcI6gENKsgnPI/ZhYMRSD+dJAopzBZZNwGSAt5jnYTM1GSqrOM7neAFyxyMzhMYTildXnXdbQC5Q7BilMGhfnjYUq0C3Ad0BSs5xM3VqlWv+curcz1/+cIG6bAJ7SULg/0Ns/OTO4fKsTZnc3WvgdMC/EnRyaV882I0ojwzybkmk5VK+Y22WNXNI12uCFKY6vCkY30iOsOfGab1P42+6EuyldroXn6nnIOQb9I58CRNm+0MWalcztt5iXkTnQVQKu8zmamrXKMwSFogj6wIIlO0Lur02TMXMcz56Pg4JxjZUCwx+rBRI8YV640v3jzSoGpJHxVWeoKjyy6jf23+Xfo3j56qUwy5lEjbMmgBLKIPKISJOcjWrvsuWlotCrTYEiaKXeoObPDgFzAmMBGlhKCfDv8WQeLihUsBMkEYwFYbFXLkZDZ0nSDBBkY5aUh9z0QJxAYhq5Qr3nuLT58ZTieyDPSBixL/YtYd3SHdKUYOXPo+XywLIdll6e+UufjVddfSny02jen9jG+50nAxVLfb1cm9jg4yTRdiKAAoOovmOmBmUVO8ZgS10OFRzRdSvsCsfGyGLeuYs4nnSsA3DHy6edZ9jbFeNu3ZM6zvBw9O1CWxZjaxyTokFzpXE/CYa9LlO+wcEhe2osicsCYEAg9MfzIrQcACFMnYBc110JLPZ5O3e1FuFghIlxrNJxpPx1qDFyupZjNhJimXJNBGuVDShDTqVbB6Cp0SAtCQT5iGVu6TgsDjXJglQGsnFxr/TyQOJBkQbpuOlPacjXSOlOr1RnDtx60hGVnjCFEnla7o4cO7KhUyNhwA1iHVIZHAriz2vMWsV6Rq8cbtNuxGFtIE71hHQS20mI907+Fdz4MaiZKrTP5bLksqEWDgZhs9WtkQ1N27xxoNBvrce++qXWtbi4QJgWOqgI1TiI3Lenj/vqFOIMJ41zJsQUUN7Mnhntjr96jW6YQNqVkT+fqmDOQcKlI+RyLlOJ/rXt8HIZcvPoZAvcbwo43a7Y4+yr7vRc0i5tDN50heqYVLbL3SLxx+r4YFIshi/brB1/TD8TP10gnNYVwlUirUqsHAYI17S9FVKLMzDi+eBU4p21aw+CLmDCJNs1nX5VXPTDV8MzEx4P1ROdpjdgYzkXSFYFwMDNhqtdS1Wfy3dXF9paOTmn79byrpjz5q6U88qau/SepPvjzU77wcajIK8VNBdZ5yNw4E6MoxlTLjLVTob2Yk4g4Tkt/ZyJ5hGD7lsE2qCPzSC3+WznS1HThlICm0wBQaIUUGtjGHIpo64FfgHyeerNl4wb0HmAmWaiOBdtPyb8/EkBu8fP7SkURcRDxHihrDcaRQpKWjgwMHh/OdQEay9iyDXi3M9YHxx+OhO9ZyGTs7YrzolgK7kg4KFiGIRbNeMxuYg6xYzqrWgiSW1nIBPDhXZneLXlxcXqmPs0qUVueo5eIBcob1y/vXneNDDc8uNCWmrtvzn+Fwxz+3mL+FDZFsZXMlnZ5e6uqCgzxnS0oM3oFfufCLFXIPN56//XuT7+HTqZZY6w8Vn+vXFwlgz1ti5flqaAn8vOyxmkn4It0tmUGCHpH4gvYTM36ik3CcAljfGWqrEkPXqJtFuYRVjysY7kuVqq0qYZsvkJIY3lxaKhUIZwn9gcwTFeNY/6f4sV5s8vpPL6r6n9Q+VblGNmjwA8YFBoiUsQ9nFLwGYpzOL9OWpjBWuCH1cBmF4icETiOnYt6MHnU247sODlF0muR8nl9cKpuZqNk8MNu1VGnq+GSnZ09fet3xeZmbMkpIJLZKLVbeA/AfmH9yseAKBPpFgU+SBufjDv/UWUJo+TkXm82WZXKUiDaYg4eQ3Nlmc0tkVoSnLUS3lKa7nZ4/f6H2Ec3JfZ+JRGLRYW+JwqpXzKaHlQojnDAKXJaSyaYLRTyaGatxlnF2ki4CGpjCp5WjznKvMF/kO6JggRNSyKZUL5c12c0Yl7tY5S9iFEF+5suZMvmqkQO4InALshEgsmugwJXA6pRV5YSifVHyBunvrVyU4z5izrRyKQz/dpoNFuqrr0KKMOWcsmQ5ZhNKZFPaZGPrAk2fZp5CpiBdhw2FOWxgwcaaAitNJhr3Bx5AA1mixeFymS6C7ZblIHGkfJIZGa73DL/LKpdyKpahIUNZh8CSVzF/otW6tY+y2pkFC4QIdTyX2Jm8YQODTFIREEbMLBPSAvMDDI0rlpVQxaczRW2jhB7m7qvTWVijxWVZ3Fe0UN1ZrEArnVZbu00yxHdxAFrTiayFCrhspl2ve6XPnj7TkmBdtEDVqmeRiTbsrBBZxSFDlTmZ9rRBd7d/8Z1xEFI58llSmCQTaTQaKvMKA2RSFhDkYke1Vn/QCzOoVnsPua58+FL9AnmSZvCsekenlWP//O//1v9VH0w+0WcQE/ZV78VlV/3JVHceHqpxULccJYWUYB37d+CSwSFO0QFrD8ciLkMgRvwyCVYdDGEA857m9gZl5kDHxH8PIQYbs3az6e7mW9/+WC/PietZKNnbmSD2w5+7p/LnpB/7ZkPzTEnfaH1F9/s/o8UaeCUS/0exAwQOFFWBaFYOMhgcQF5vBgcj002FZ8Jh4iR4YPl0iBC7eXG4cEgCs3MY080HUTQdwNLdNb8DBiXP35mcadjEWc/lmD1DRY+JYiJGyZZaGZs9d697/nuuULc1H56bVEmZdcp6vWajbqkSl2mx0/T3RB4ngb0kiiRLbNewtrjs6Mi4hIH16YTqtZqG/Vde4zybRqOu4aDrQ3e5DKQfDADopngWMNGxDwNSZg7G2uL9UHgkUkulNrfUefbcelCwFq1Rb/vn06lAtDrP96VH+z/I3Ha51nTOpT5VPj/2AVVpVR3/lkouzZiez6f6y7MjDeIcGR760dx39N2bKw0HFFZFB32boGKJFrT+pUocqGl650BiS6zouYJBAs8UlIGDGc0ulxbcCG6mo4OWkuijUxsbF7Sb2D0OtcInmk7SYnZmcDNfstwT8+lO82lBv7fyQvVUQv/B5rG+uqropy6kX6+5A4pxaYfJTPe4LWz87EBH6KQgEALtTsZYILLfyy7qcD1yDbdPIeFAh00+mdyOWtKpopJY3PUmmk2vtX2YVdmjtKmtDekKYRFD6KnV637ezuXc8xDQG9oYZY1Oc61qraSjdsesWPgVfEYuQq9x+tVoaVOWbAFz+qI7PVC4w4O6i64ooitlHrtUMttyIfjixZnTf4gOJB5wOp5oMBgFcuWmrhyseNjm7ou3lq0g4Rj0p0ESst3aMCF13HFBV+Q7tOvTVkv7dzPeoZiDcJNVrVyyo08pm/NMlIsZ2UyCQOosXJagl+au8NiJxgJKRhRYtTj5mA2PJ7jlO7ekwrd6UWLXhLVXpYBnX6wd5reDmeblibJ1LtCsVlR4cL8dbwdMtfCBwZ1NdcXDc2wS4vccfz7ScDK2kHy+CIubB3OcyXreto6wMGJAP3ZFZpEuLXU64W6SygX2HBsLBCoc3Dl/KVQ/lkag2YP4QxURRR7qUg1jpYUGClF2shlmVscnR8oXUxbsg4Un01Q7IbC52x3o4vJSp6ev/EC4iO7eu+PLvdft6/z8wrFdFezw9v6ZXNjMuLi40CjxcCkAonhkiODDx+9aK8c/0yH6887n/nPxGzNmHnqllNNqgXxmEeDBBJDLTC/PSD6nGtm7siSTOmwd2muU458LmaoJQoQ58UrpvNTRX2t8qHEmbM7mZz+rF+tZ0KVSCGQSuroe6MXpuTpPG3r47n29+94jX2zZdMmV+WQzDQXS3tCbjWwnjMTIFXa+CGEqazgHAgRVPBcMbGMWMofnnZMjX7Ivnj/XYDzQllSBTM4Wc+cXF47i+d4yi7SmWSqnn7//g4qXWx1/+o98AFCC5oo5z+3C4cKmRLOZNnR580LfxqHAnMbcJ8hWyEwcIJvQZvRmgkDseQ2bkQucP8vRvL8FDGPjqEKnTLfGaZeMgfYpwuhcSTpgD4Q5L8xU9g6HNgzpqxQ+lkSylUy0YKNn0vyZufrdrlazqY3CWRfVWkVpj9k5OEKQNdpgKvzlcuoc03qjZTcqOqmjg7bZ6Zttyp1GFtgOS7gsBDygsBDWy4waFmW0Tmsx22o8XLigyRdjF12EUcPw3k1vq232C4QPumqSfPjzz59dqDcYqdvcvr4oIV2t9vuO4o6fB3GlUA56Qo8m0rH+6qijP7d8pAUCem31KzNDzedbTcYjyygaiYYy7lhhhTPPZz8zuw7dvPWJSWK5GOAEw/INMhugQ2KeeGYmWya9B7HwQ28ZZdJqJ7PqDabqDQf2NmJmCMJDGADkHHy1Z9mdmwN+0g9UrvUf6LGuk1X9WX2PKtf/jX6osrC8DYSKfU+6CDaf2ULZrE7YyexFxijM5zlfGIm47GUcEjGD3IYDnC6cQIOb7xqS4ypWudS0O8/FRU/lwtpkHC5FmM0Yg3Cp8Pn5rrkgspif7GO/YJ8a1seKcxFyWqu1qspVztCNM2lZGxB5MCcwepElU4t1G0YZYVRVN5M0n6dxWSsxSGq9hbi38Pu6c580joqJcby3Ya+rzCChTgszBqKsgsSKM5jLlz+LxpKLHe9VbVdOGSnmyEYta5NYauR1xveE5AWj9LT9tu3iWs5YwlLMsc9CGDgjEmQ3uwQsZ1ZBCCmkcMjszRVgCjNC4eLleYMiwri3NvVtXpTAhRwZmUTQweGmwKYbXY1saA6jbYfQ3joyzg+aXDREkeIULKisJRQsSCi5wE6IZAcwQzdbVQo4mBSsLewNRzosYBpQVW1cdVIEs0+gRaoCDv0gyi2oc4iIn+SFkMdo9JoqkcE9aRnpAM1xMAMjkvdHGoTZf+WSCoWKZS68Sswnm0WzXrkcGQlCWDi/6OnVqwtdXl0ZY6cboqtMxkm9//77ymYC9MdGxhUl+FKF0GE6yul85mKB9n8zgVINkQXLNaygMGbgok76ssQ8njvdobk3RzeUc8wCygVnzqWyeS0JP56zqSEnJaHLapfL6uT4SO88euBndXV5bfIQLDjel7MMYSVXqxp700q/5u/+We3oMohXAv7ARWSHvm9rCKM3GOj07FJXVwN9/gsfmNU2m9Gd4LpCFA7EkoyNJ/CzZaMmkzMVS2mjA4PRRN3rQUiwWC+9yUvloPHi4CduCH9PF1F2KkxaQ2i7tURgzP3r+pv6l3e/WZtMXqsCJuR5pbOJQEAAwoZtXOWiTBjCZHYX8ilvDu8Q8xNQjX08UjJhO0MqTNbizQvPYTpNDh0OdeZv1kriz1nFsxPkYGTiFnNMOpkhkpXe2KQK2Md8Nuzv+K7CLCSYUMMurZanGk2IiTu3trSIVAdJDe4xDtROGzbnUGSD53MYRxBiu1GOtVwI6AFMWXSlHMKg0Ik0VmFIqcoEW2k0nurqaqUj0k2KkM+QnwBnIVvAshF5FXZtU/uA8r0gd+CApUPb3tDs969XL881OL1yPBms5vV86wgwzAOSrVsylN8LRLnpVCXmoyeH5hCYF5QiuzDoDLtRSrMd/91Of7b+8yoSmYbMIkbeMPRYotUhHD3IN2C/UnzjbGRkIEd4MMVQIMhlPJvO2FrNBiJIr3YJw3Q2Dd+7vjBSYMzRaDZ1cd0PqTU2jGAOGD4H72+9zITA7G1K9URK/2bmW/rxzYcaJEv6xscvdLS81PvvP1a5ktdmTx50WPA+1HgyHvuypD4FMSIphzORywJ2Ks/NoeFJ+eCGJ/F6vcZpJXZZNeqHKhYbur7uupujM3KAeoG0nDAPpoBBUWAYck74Ng5ZY89uKVLIpkXSR8eI3C6LzIuorARdKGVhSHjh/QeUG2u4rM+TKebkSoU8307F6wGoezimuJjpyWcvlMoldXzccgTgnTtHRvri1W1GbZgj57Tdko+ZUbvVdlEJW32+Wejq+tpSu3qlolaj6YIhjiA+Ac3jm4wnd8pwO1plkBzMWBjlsc+4T4DgmakPxjPLmBgJeL6dDmgbjc1iPPeY4UYqxiiFRWkuw9u8KHlAHBwsuMQ2mMpiJTfuTvZC36ITKRzOuReWcxHJcouNh8p0WWxuDjI2BQ96SS4c8ApxNo2kmo2G6cmfPXmier2qZrNpd5l+DwumnTcDUBTMudZhQ0d3EIJzUQWWJsN6MHuskfK5mxgcROU7zdbMBDAcGJllCykHrRuVEpsHlwqMpNl0MyCR2UKvXnX18uWlRq7GadlhJ65VShR0cd5Vu3Gog+aBiwRs8WDKcthxccNqBN5NZpDR1DRbUcERJDrVcjrRqxJWS1zqhJVgtbRn9xVw3bk1SYaWDmmGTUjaSCpfVK8/8CUB6xF9Y63S0slhRx999IElPF/96td0iRck3WlEyQL0nFIyk9ezuwdSRSpv5jrIZ7TJkDDCzIVMPirHlKG+AGMGX9CXz86VTqR0/537tgYcjocewHM40KkBGz548MC/A6iT50sVvYT1SxwSZgTb2Mw1Ojm+w6vzjC3ngK6aNWanSUGTODyo6OT40D8H39Q7tbwOBnNd0XvkS0oxz40wNKDT75qBulpVdHBYUyFf8wD/zWQNnn1k7wqgl6BUAdph3XF4ZjK3MzYuU2ZzzjHNFq3/w0OSS5v3DXkNoiKjBjZ1Is6oXJr4Snn+4szifg6rVrumKMpaXI83Ma5PVOjHx4cqFKc2aICeDtGDg7UIsgH0aw/LkmH2LKxFCBJc6sx7wZh2UvfyOjjw0MbTbGWSZnKiIWYWC/zIfqNbIEKLNQkZLVkO6EK0uek28HkduRsBaaH45ILjUPbxeTvK0YuX51oPpo5PypTJjtwpV2AmnHEhfPPi+1qZNJRwxw2JCIF7MDeAnJPTapfWOA7epieppbQaaLoO+wA0YjeJNOwTCp3zZUc3AruR4gzwhHliDEqB3yimCzAdMdVIQnyKnNozGU2U2oeyczYQvMA6oQDGUtJz4mxWm9FkT/YKtnOGcGMCl0M24qax9bMraamGVhoop3Gmrm73QunEE1WrBVv/VWAjE/sHcEVRQxB8CUs9pBcU+DiN0Tis3UzQ+XhengjOSd3+UPb5kPTxt5/o0Nrtgoq5ko4OUpqM6VJnKjXqhvfp0rgE7tx97O4P6RxBCMDdzKPZsxgjcDE77CAR2TSCdVGploxCmeiYD8x+IFMQHC5c0KhSraT1bqXRdOROj8AIRlOcgTea5eFwZsY/52a5mPXPZSY7HmJovjIpiHMW1G89xyCBCz5vJ6YoniuVxFgeNGyj7vWltsuVzWwOOwfqMTMnFQg9+nypYqNixIzumZEV7PsFDkXboIBAJYECwpQdHOSSpJFgkIBpQtBwc86z7jmjwvMm+/UtQ690KLwhZlQ7exeiE5wpR9YjGpdV0IJx0KLrgR3IPqsWioqLCc2WK5VyRY1hh0XAVYkQDMzfefBJxN1IIGAvrVzNMK/rdA58oWGBBCRZrhQMATPvqPHlMVTfRW7He72JVgugrADLUtHxHqmC2GxcoBwCtmvbTazbwSEfWMa6J8snltYrjSdrDWdrkzAWa/Q7IcaKuRIdNcQE4KfxaGIZACYBOesnaelD5c58iUsMGvPNvBJIcDmfu6AYjMYWPfP5sISytCIK3WRESu3ri5LpdXAoQr+VKze8WThoYUxmUjvH6tCBsxCYDVN1e76w23keTCUdJzKapyv6G/d+nX/ur736Rd1LLDTBmSORdmfGAeFw7mTGEBuLGjKACTNRSvMxmXoF5dJlW8MRKAzDMJ8LVP7FPu2ez/vpp0/1/PmZsllCY8l9LNiKa0aSQRpT+IWWs5l1WR998DnVLy88Ozk6bur+nY4PdyDTUi6hP1b9hv7I+Pv0rZMv6f7ilQ5Ov6n1AnnQRsrBEpxrMk2rfdBwxToa31boFvdTpLkYwFIvluvIWBoPh9q8YUgNXJzJBLal1woszv3cg44bCJ/ZC5+TjZpJYnlI5h6RYFLRZuKxZSfIlbIcRLArdwm1DztqdojPulazVXOHwM/jkkWuQNex2xX8zKDPMzOsMItzTmfWnrrOFmX/EAQZEYUENhuS2iE92OQ/lzHhjcPbJhZ5Io3Wwp8bwjLvJZ/N63p2aTYkzw+GIAc6TlVE02GGwaF582JGBfS1mE0M333w+XdUaxW0+tmVXr4xT+dZa4tLU8gWpMDg7KAAQLPHEfWN6Eh/bRm8jP94+1tKTTYm1fCZDKVBuoik1WSpjNM3Skq5O4TFutZ0ONLpdG6yjrkDeBmzv9cbdz8x5iWrtQoUgAn0dBBoCg4qcNQcRBUi8LhI9xdjndDxFIUNwcChK+QC4Qzh3PugnNZ/f/1c/2H8vv7mO79dP3D15zzfXE4WKkDOS2Y12c6UKuSUMlxIQYV8pGCTBpAobm4Y/YyegBxdUKaSKldqyg9uZy3f+c6n6uYR97f07qN31Gk2FW/QpTJvpnhFn1vxeCOVjlSp53V4XPOYikIbWBPSHV0jblWYJbB+yBEFXRmfT61j5IziQsdWkb8SKSK05nbCKealUpUUEbxYmWPSNTOWSDiDlVWbnme0mG71/Om53n3vnvLWBeNAhotXpMWGPcj8OKNEZqfNdGEk6OReU7l87EJ+Pklos1gpW666KKBQRcbHM7eLVLT2WqIDB+VC74p5C9CpyY08Y9slzn2X4NpFN0qRwWfmgqMA4L83BAtdGOceVOyMbm7BkLdzUTpmxVFXOIrQGYZ0bDopZjB0lcTScLiAJ6AX4pDg5gcCxSQaNinepmZdLoO+jIflzZTEl3Tm+Y5nQ3uHCh461QAdGlqkq+tz3X945NkirT3VIjZH3/7mpzo/75upmEnn7WeIu0VILl/4PTGboWJEqwbEQwW2KodBOwQczAvYPT5846T/bpo2sEa0M4xsFw5kAVsuVrqNpbrX3SBXwYAdfJw8Rb6fnTQAb0dOkCua9FGp1sIcwTZXOUWJlOZe2HNDnRxYJoi8oWHjqMlkC3vPxLES00Cd3z8YNVqkpDTdcdIRoGU7PDz2n3UUD58NXWkkfe3RV/yfdYanqvReuFtp1Gv+OUT93DBEeQChS2eBUXRg3kx6BRV92GT4POI+dOfkjk5O7tl0Ga0iXfpmOdPzZ6fq96ZOArDudQsUGQ5TpD2chvyMs+2lHj1+R4d32tol6ZzTKtXytq4Dos7kd3qvXtYPa6y/Na7qk+Z7Kp9/onQC6nqQYdD+8LlBLAZk4b3RUfI7ZlmZeIRfJ1IM2HKrJRR15le38AsFVUjYACzHlxLdGezqQJYCSwPu4X+HdDPsjlSr1K1Jo3spFgZaLLb757jVoDcyrM7zZP1xObKWgcxMusA9JE0MGP6psJFJQEmqUiurkKe4yti5igucn09xAiTFSAHoFDMK5rQODrbuMwQfM2s+Ou6oUkLLuVJizx3geYXniJXa0rN4ZqGBrDS3TRs2YLPZ0H/2dbGBRSHWX4u5pTB0M4/fe2h7w/HV7Z8DOuc50EnBQidZCLMAMk4N96XL+slxiMX5jaWu2rlYWZGTyX7CeYhnmlE2mTfExlxxMVloncTvFLMHoNZY8+nKlzzaQBAEYt7WZq1mnSRCAUyHCnpEl5XLMQ/mOad8HjA7ZDbIfwusHdY6vxszezybgdWD3zSXZa5U1EfZtd5bjvSJavpb+Y/0P0p8ajgQ28ObsO/lLFI5WzbasYH8ksJdie+LOXogE5ohayMQ/p20kLI7nxuJEp3UGDZ/IrY/NJcF4w6kDIMh45yQ01lrVt0p2sA/k/AsuoSPq58zchWK3CCVYr/SxbI32ZfXVwOPEgxt0+njfsjCVFrn59dG/UDzXCAnAkER8hImGZVEWos5YRIh9/Ty4tLf4ec/es/mIxjEUrQTo7VYz12cIVfK5ume0c5G6nSqqpWzlgttFsx58WQOlx8IOd6y3DWcE0lPksmnhJRDY7RzUAQMer43km7Q91OQUqiGcRRadvyd08quQ6KUGeRJCpgwrmJvvHXDAYTdGFJzWy8jdFoB67UNWBKfP4Iz13uqe1p5+2lmvfBH47Fm2H3Zciloy7gAgVbYlFyON62xvxzE02yS/eUJ7RjYgaFtvVE3hZ5ZDAdHvzfQ17/xHbvrkDaCjMGJEHagwbkicmXP4oEhxtyMwTNzRQwRyMykysyUwb3TnnfwmSAtIJzt90ba7AKdmerUFGO8NIFNdmTtUTUxw5JyaS78/YZB+rFcOzeTh57JFFUql1WpEEuDHRcmxin7lLIZJ1S6VJiUOWYf3s6H+F7pXvndq+1McXJh6M0yGX53ImUI0uxdpBu1mo6OTvTo3fe0WH5L8yUw7c7kqq+ffJd/ZmPwUvmrJ1qXy2EBol3KJJVaMzeBMUZlGVhhQKv8BSOUv0Mi4tmx6XO5ol2aEEIHw+4QXcUhy0GOWbrTD7DywogCOK4O1BncM3bphCFu5lLtAlmJaOZyZuCliEej5APaTyT0G1pzX5RPGu/pc4m0yjEetnSzaRdO+PuyLimA1lmzgPyi4FnMuaBD9BU3CQc6a9GHSOLNoiRQ/XlvToynKgXOTJf956D0GzVZTbz++M57vZ7SiaxOTk5UzFcN75MowwFt55pJIC+xDqvVpTcsa81RYvaU3dogG3/Mbu9CV9enunuvY2NqDkKLpykWU1zgIC4hsYL95Zgx3h8U+FRqr/2FBHFoQhBkIcNLvPfBzGYHPI847puBiENJoVjVVberx+8/1gMo/5mMEZPRAO3wfg3OlyazwbbFQ3U+e0/Nds2azse127Ici8htOfi2Ru6auJj3eXBKaJbM6qeXwcf4h8sD1RJbLR0t6bhdf6eB5eDRrC8NoEV35TgII/1I4VEae03Brp5GM82mkFhWSkax+lz+SCCSKc1n2AWOlcmsVKk1lXTHweWStEyD38vPNiLPd+z3EqazFKzbaGym+i6Z1DuNnT5ILfVJVNPfq35RfyR7FSDtdNK6WfbyjKgykIc3cGv2nr1cDVEjTwhh4pRydu+y1O52v/twjxG4RIb9gTVxZqrWiipX4VUEIwmQHhoY9qHZ0J77h1XMM2XNUfTZ+5QCd45703wfayW9dMwVXeeNljOYTFBTcdGulle+KOv1uiFU0BiK6EqZAqKsdTTXdbfvz4DUh1nkO4/uuNCtN4qq1EhumdmohGQnu60lKZzYZXjSrdSoVbTKMqOn2AqEuNFsopdnFz7D7SIFeLINaGB6MlMqg8sUjkBL5fMUkcxCQ8FM4Y8zD98e34+D6LM5TRaMAINGHaQAUhERjI1a+S1flCtMxckyDKQIbmXP/pjzEOgcQ7zYeLCM4J/uiNJ5Op1rNp07bcJUG7RskIHstAMGjWg7zBJDF+VWZm+Su9Y4YhbG3Ih2PKN79w5sgA2ZhsODZI3xgIDQIEIncBbIky5hOuOAh4EHIWOjzRZYInali96vBXRrpUCwlAOm4mFg1jsa4fXK5ZxVLp0PEVKbpWKqlDT6NIbMWcOcOAlxWJcbNc/quNjPL65syI5eE+Ynbv98PyQ6NFpoKVum1pv1BkmKFIioH+Yv1u7dGg74/2edIOJ6/n2jOXFJaACh0W+2uhoRTUW2Zsb6q+vu0Ad3uVZXb8gMDduVNzxN0dzNp04IgcTQqHdM9kFnZR9am9mHP8fBlWbmUoWwUzQkaNaYKddpPX+OJGGrh4/u26SAQD4KoEazpc0WD066mV2QY8COdrUbyF6QDHL5iv+OuBl5UTKbCJsLX1K6sSgY1fsU27/oaNKLpJMwMClnw8GewxWIg6bI3HHf6EwgtqxYI1hiJezkxAXNM7TY+g1jZDpSaOesG+dFQpKKQ94lAmhkFWx6Qml36PSqVU3Hc4fD3jm5q3QHzViI9QHOJxScS4fCELkH69zyiySZqQVX8rBySaeYzRvqDy7sCsSYFUSFUQBuIzbS2CU17I8MdzeaNVUqDWXy6GqD+TwvNHtki/K8gNVgZcLI5ECEINMb4OJEukfWZKJOvaHJaO7O8OGD+5YSnJ+e6ur8Stv1weuLElu6oaPG5qoU834PWFGiUzyuNKTr8OfIJjx78W37BzOfRPvJPBD3IZiN/cktTMt7Rr8M7My4pFoqUwFoulxpy2W2wqcW9Cb8NxRiGGdw2FJP8lzmi+AtvN3MXXywXpB1bSPQoWAjx/eGIwxFPPP+KUHG44kWyLJMg0YTG4wNgG7Z1xQl2G3iD2sb6V0/sPnLN3sooWazpvVmodV2oR2jmUysDJpJ9J7oJa2L5tSD8VmwPyqNAAd6q1l1IWRTihjUaxLyR5nbnhwotSRtBTmMd6udb5gHgxZw9qH3tXQowUUYED7W7M0PocCFcMPvY7YOBwOTCOz7GIcU8hXv0W732mceLk3M8rfoMRPZMDslichSDimu8buCuxgNU7mS0VGyYaY5RRCI2PVlX0eHBy4uaT54v1LBZy8IDm5uBAwgLWPuiEkLhJqYu6SIVCr2d/Ty7NwoG1IzYFb4zCBiJCKB6iUpuhwzmFRvMDT3JXjthghBRnpA3zxLmPm5YlrtVVNr7po+9wyoEYRU4hPftuFAHDqSNbc6MEopLC7eOJUYTE9udWzZwIFxiJjMyEqzQ7OynrkEvSCXgn+mIdlQvdP5cXB56A1JBSIHnYyjhKApF3Tv/oEeGwunKglGxuViQ+88/Jy0y9tlhwPJG9sat0AdT9E98nVvtvYFhC0KS4pN02yUnZ5hjSR5b7uduv2JxdywGkt5WIRpZUcjM8SAlWB4Nkh34NNYg0n6A04SZC4mlYxJKcgpB0tzNXdix5qDag6lGqNoWeNGJ+U8RRuEw+Zj4I7gmurr9lJAsF9Nhc9l4/EdUBbzmZQzMTlEEaFbO5QEHkw6CeC6P3RniffrxeWpNskAMSZ3kSqZRLhcqiF1gwSHer2kVqvqGSm6VkToYZMFwwAkOSxmDm7mWfw5vg+qfDa8w7NzaZO3+Dx4r3K49QekyACrTJXa5jQYkk1X0sOH9w1/sA6QHBH+WqoHyJWOxIgFsWVQz7fMtZfKJUhXT+rwnQdqVtFvEvMTUkMs7Uhnw/vAFH1/Ua6XkfrjkTuMUiXntctGyRn+ypq9fPOCDJYrVbVaEuIN+QGYFX1sqMrbrRNDaBQkjA8greHPClFpMOypXm+78ue5TvMZz5l4Lr3+0F0DXXkF56ft1tAhcoSDTkeHR001mkUTkoDCcEJiXKH9oQsjejpeaNAbe/bfPjxWNod/Lan3QQtHZU+R1Trs+PIMFmowWDdK0j0j2QFKztVVLATyFOSbGcG+MEnTOxOyvvmNrzrTMKqFYG1fUkZQ+JmMUmJX9Mx+UtmEK/Obi5L52Wo59p4tFEGQNiqVSHeAjLNTd76PB0O/N19oFpGkstIW03USMiAKmnGb3kchBaYlxQZ7o1QJ80ZMupFhQCghpomfDccBVARNKZ0j+3yx2Zn8QUeILpgCZkysHSYDsOSTeE0HpChIFIqGL/nSb8gfPHsIhbqEOTVTKo88K6FFKq9mJavpMmVp3GKzUDIHAz3A/nQ85nHkkJk1jXQET1UOcZCQnJGZUin2RXYDvX7py5/XbhLgT3SvIA8Q6f0Xe83SDli9zDghp1hn4L9zCbAXQXhuzhAKU2B9Dh4KLByTBn3W3sKXZ6/XdWPy8OEDu+jwfYIg0OSEHIVkiPkqZF1kMpMn47eSgCTWUbPR8rkG0SZEFWZd7HEWU8itF1P1+n1llFYhzawYRy6IhZmQp7uAFbzQ6XlP/cFcQ3glEWgPXf3aSUegf5UqxULe7m1237E6YO57yKQhm11kVMgQpZYO5xW0NOLkYAEX8D4mXQif8oRG45EGbxr/v42LEggNph7VBy4JPOwk0EUckit8eIABM7Bfbw21UhUw4wPrXxFZxOwRGjeRUMwEcNnhgtjDuDx8GKL8bFponj8PhaDYuycd3b9/ZO0SMgAwfqygbHCdzOqgc8dWS4TTAksa6nVSRKi03JXBgIUEkwqWU/3+TukUzvOHatQJCcXAGNeblYfViZh0hpGjwbjcSIlv1plHddSqVQ3rLGcT5TKxGvW8aiRuzyfarjYqcYCWylrOg9ekreNCixLyGTMwKBlYQ35aeePQjXKw4LACk+7mheZO0yvPHHnI0P1rDLXpHmoVXV1e+nMGGycgUOBwKPpLH9CEup4kT/QTH/4eX6L3Zmf63fFT1b/wQTAwBt5ksA8pAviUTuOwo9PTc+dbAs222y1XiHQU/I7xeGZWKEVQICBBVZ94I4EdZHI7y0XIqSOMd7aYB2s+zAIUq1nP6OROVbVqzRsVNmBgNEMZ2YNfN4gdBI9UQj/cnus78yv92csj/W/q/x39hfs/pym+uB7Q49kZHLwzi6Wmph3vD/kEDFcYpjiX7Ox1SvwShZhJV28Q39CHdXdzH3DAM2y2MHPGXHmj/nXXlStOM8wc7SCCKf1yrcl8Yjp8CBDnUuSgW6vdqSuTD5R4Zo/YdvH2cH2qbLI6PMR0YeULtt541wcsn2e1mLnj5PAmVR44mwO+VKzYOu/s9HLvfUpKyy4wX7cr/7PjSG1hFiQ26AlrzZqKpaqy6bJ61xPLna4ukf+cqdmo2COUTp+sVj4bHdHNq1Qoq16r+/DjGfEdFPNlXXSfaZZpSDrynxuPB3rQrGg2H5qlynvgwGf+1xtP9c+d/Wr/ud+e/FRf2L5yB0+EFVAcko6I3NtkzvmjSRcKgVi229FlF3zxc9nMIHItmTOHLFDWLPFyXBZ45EJC23CBKq3BZO4uEds7ijbyW5EGwUq3D+jefJw9SCdJF4hEzEYltPU4PnEupdL6p7ef6umupW8kGvqDFx/or77zDeWQ3zD/RD+NzaW7O7gWFLUhxo3AAGbbfF68h0lRwUQfWQYOP+YF7F85ZtQtotR2WuRg4lKEBrgeeHe5AaFgvhzgTEcRYhbiKLv9OQCjE9IjQfKWflB0ErVFkVT1/qVwp8Pr9fq6OL+yDWY2e2iEj9k3TlwOfs9SzMYarMaG/FuZegjNJGirUlK2xRw/4z2uJNK6qWeVmCsw6ueCAyGYj7Bh3CoFrIzEz1D9Qq9Or3RxOdRwvKSUVBLxMK6CSpgHAhEnXynZrhNEEoczkmdgPYPIJem0adISwWjDZxlymBRWh5jKYJISDAb4PIxrKFANQwOVv82LkksPJwvcPTbRzn6jxULWWhWgPxLPJ9hjoacEYrWPYloxYn+0lJRBCIWRhtgxJxAXePdcDAFj59Dhw4bZEBBtpZrT+4/v69G7d+3AMFuMQvpFsazxeK2L80unaZdKFdtSsSAgJSQziHBJ7yZuKghNg5aO4TB0afDy4I4F3m+fVBuQc3EgdA55ikDLwKccOEgVCNq1jRtMyDWkkIWrZTrMMqa8sLbokrMcmCReDDThQE4HEwJbKVEZYtRsf8+k1vHWrMDW/Ts6bJLOsNT0JKQx8MLZZ7PEa3RO/o4SZL0Vcob9mENBNDHpCSJIYmeoMZMv+gBiRgbT9s4JPq9hFkcl++DeHZWLBcMzYPx8ERQ0iP0TETZ/Nd27d0+jMfANF1zIb6thjG13mnqY7aazGo4G1tP1CiN3oMxTkkl0kbBBg1aQg4nvmjglNjBvJZthnoCAH2p/wos5tcZ5JhjB46wEXMn6SKewBWSGdXurNeslFZKxBcqG+GcBagKfmpSzUuCMeLYI6jwajLTZZu2fiWkzVXYcYxd2270TZ/ase+bnj79mFt9KvFuBipNIZ4CsZ8GhpoGXJ9/3TKst3XVZi9XMJgOAVLlCUmvcYsx4pghJmEABEsCay5fwtKyZnAH8BsTGxif/0FZbdAHoG5PhQAwaUH4mvpyY66NLzaiTwucU3Rym4WSUwnIm7zKsW2t7AdAxZ68UtFzEOr04c5LJdIohQVoPHt3TwVFLX/36L+jlyxe6f+e+ijn8UfdrsECnVdUav1YSHs6udXjY9h7A+1V633/uBqa+c/dIMd1FDvIb5LggYL950Z3eXOCgAECKFDOB1avXFwCwvXkRGEDsQKBWjvHb+pFR5FCoB+tIz74yjDCisCYmUyedUHaVdsE6LpXhwhwpWq3N0vRetzlI0ZehBfqOzAsB6DYyWK500Gpa5O4UlLxjKvwZ4Cjkanmv1Qz6Xp9362BwwqVHiMMycnSUPVo3G5PNkKGtV3UjMIspVpa3LO3LqwulqgEu5YJ31+hM1a2Wo6E2McYtARWhMLLe1nrA/Rhrrw2mk2Jd8XudwQkZbLZQuVq0BadzVzFbX97V1VXP0iYs+EYjtO07227WmOsmed+s/a1leuwNCjQKJop4tuTBYUO5/KHWW8zZyWXNu9gazUZmsNabLSXilLYzHIxiX3aEyPOz+A752ZjeUyOyXmH4c/bC77gxK0D7yGfjGQ1GQ1ugQoSi4FjQGHG223MbglbwMw4apxvLy1CQ8PMp3Jwb+sY4561clBfdXrjQ6MqSKd/SHH4pmHtb8ghnevHqVHNilPJ5VSo1k3oYpNLRkU1IhQG+7gfquUMQbS8We/JENq1yMWQ/Qm0H1quUs4avCvi4jgO7NFcu28Lp/IzQaNhOmPbSBZAwgH6zqeKC2SDyjtFrBwwqO+sO8R+tlnTQaarZgPyDzd1CiUSYAdIJGWraB+IC4dpKLwK6DeYHV6mEGtWaGthtZfMhMQRSBa4Zwlhhp0Q5p3IBynVWaVyF2LLAJpulRsOefV4NbeaBaVNqlEtqV8veoOfMa/YvoNIIRqpbLEzlN+5KQhxTzqHS3S7zj2lIxmDAZWYudnU7fwdHnfrtz4OiHnGQLpTA0i7CgB5ICnLE1BKYfKFnoT3NGl06UHiz2fDlwOFCzE8yEWBfX5gmA5GcwSxuZYG7DceLpBgA1+QtZGamsVoT+At7mkJp686L+Qh+nINekMjU6gTl4hEKw66rXQYWMmGuOH6EF0w4LvnFOqPZFdKIkDDP85nEk9cX5X9del+5zJG1m8ztiqu8ctdUo0ll5zkNUPrvX399fqz6ruaqN3udUXGGFo6ZeLCPg/nNYZcYJ1QYBcE7KIuJSaPAHKTrCQSK4HBifwOsHdEXbmIlI6p/Kt7A+k4t+fe0NGLWyGEQjNktnIcIo5SWm0OtKhsTH/j/5TNFsVzdDa2yyowCJJfEv3OCzCKwx7k8whguGH9zuGGx190ktWy+o3V569nrp6WW/uanOfV7R5o3fq1KKulsdxse/n87/D4tSh96lMJ7flUq6qdHFZWr9zW2cUB4WdSfI++16b1GQcwcn7XKtOnNl7+zfbg3TGS6BxAExiXIV3jC83Hf+4SD1E6kQN5EtwHOULQj20mHv8MnwJADhAqkihEPelDXViBZhaKaqaydZpDv8BzDOgrdTaJadqfDRUtnCUsdydj1ZGqSEMxPH9a1cAnarIK0y3JV8+3SQcEI/OMECBJFdvj5dJIUBZ5QKWG932R/kDNDpShIJVvBwmxvLB+XMjbv5xIkZoqfFSIAV/tLKnA0AtEuxKdRRJEeA1rl92dfjQAzQm9hvdn3NYmPL4VHmD9yTpMdycX8/NkrPXlyZc5JeD4h4o3RCw5SHgtESa3mfEc00Ri7A3WyhpEmURgxJ14bWUF/iUytkGb/lzRn/LK3kkNiVWs21Dk80HB8agiecQCf+ebsgsiI1pzCj//zZ4BgBzluEiwyQRIYdSV33E9b1StH5p2wl6yHTqY0Ww2MUt4gLBRA6PRhZb/Vi7I3HPqXWLaRrSqbL2hGGgKZk5jtzmb26eSDMQTf8eAgqWAdZdbdzrRdbnwOSSoqYBmqOC5FKgDwY2J/YLbSeVaKRWeaVUgFX0LGgHkZvP7Ozrq6vh4puQuJ9LDx0BTWciVDZunMWtPppeItmYx7whkHY7rgITwbmQSDUoGFE2K8iGbi/dNB8jlhtvLQmUc5GxPaTYIh+VwrDiIO3lRH23LaBr8RLEkPlrF5xrAXHd5U6SRenVjjmVLjBY8ZMlo1uuuTw0M7abAqISHxHTGb0N6FzcQFui+YhI4Kq/hZsNlZUEAulXLVCw09IYN4XGuovFhQdGXAs1E7VMKWCWCttQMVyFvXCbt4NJxqYTuspS3siCTiwp9gWoD+ajKxgbZd+YGtbCiAv+laR7WWq/luf+RYKBijzEbrrYwmMyDPsS++VieQCBI3EBEd+5IuP6ur866fK4SZZnOh6E5Cd+4eKJ2Y2g0H6BMXp5vXeoEOkzxIxNhrzyq5IAL8fHv5/ULmSOKvmxcPYZ+z+I+/fjHeXw6Or9n/pdvL+Ze8pvr/7sU5+8tL9/mlL+6O/2dGIqBHvzwEaf+qSfnDX/qz1vu/0s3Xwvc3iJj6auuDG8/uX/p60/0vlBL7GRAykZJRIRAnYM41iMj+xTwpj6PVJkCrdEvswcVsZVi7XGl5fbBHlnToqZxmi6kStm1LGJkxQQoojw1uE3SKBdZUOCT9/6dAZsSzXGkTj0xyqrfqDmgYQGwCgSLQfcn5sfLZQddpDWhqo1ShoAiEZwZMB6unpfjwlvzF7C6dyKlMzNtqYeIQhTVnB4xYzN/Ra3PpMcawrSAxT5Opi272cS5f2huShxf7eJ7nBOH8BJXhRgopOBz8/IWbk5nQMO6AKNdBUsfvN4EoEYiUJo+5eN8quQ1oDN/Rzg8OpIJ/ZwaKhC0gAU4YIfHEqUUkGaVUgCnO2KJcVi5bshkDSBYXE4x+HJ343ZwN9tSOgL5BEkFEIOoExAqYmvnmapVQtMKrWWodtPTpk9Pg51tu2CmKTttGK7tI5UrVnrKMqCiAeEYwcUfTMM5hvIeUqFYuqKaSkUss69C5MqYq0nxQsG3xH9/4zANlI/uXC/Uts14RzYdYm3y5pFQur/4oxGpRyZH1xQXJjAYWIaJVnhxfHIuBSgCWH+yuGSQAzxIwICeOCrnAzrZfR0cHdmnhSoG1ROIB8AKSBcyvuXyvL3uGAIBQgbAgXDBzyuTDvI2LbzTo23eQfEjekxMuyDqrlm3zViqG9xXgm+AYRIUKzv7q1aX6vb67NRxY1puZhc6FUuE1A49qkMuuj+FzPqVoPtYsm1SrxkIirbtoE20sroq1rMrNjmEE7PmGfYbWQ+vsgiDbO05xpWgIib+Cu0x4OXapXdOWcpsNmErq8vLSFzbVF+Jh5r7onthuLHQcWOhMMKUHRhkMej48wgvzZGa2uLRsrek0CcYVOF6dO21mJGFA9GCOHCALuonXBCS0VbDMrFnCW3QhXff8nbCBCLC2HCMmUBdxd6R+va/V5lBHR213mjd6RFf4E2zgRrq+HKha3mk0mKt7BUQVqVbPeeOBpAD937yGmFCMprrs9Y0CtNttXV9TDeNWBE34l7cJvFDjfVdk8fwbljT///xiRug5oX7Z3yUHrh2pKIA2aweSYzV3cXap3vjWbYquoJQtazVbGyKEwQg/lEJ1mYhV3YDiJLTAJGTNaGflospELcKBKbrRzZkMtrWIn5/J2ucCYn9ioWd9NoWtXbGCOxL7hLFFM9mwrRlrjAsFWQLFPmQ99hTkDzgJ0Wqpl0+f+eeMpwWThvz17Jhpz9W7HChTyjpRqVJtKonbF/IvCCWFona52OcOlw+ELIT1IUd1brtC0okY19w03IgnRuQ3WhIEUSlSrVkxKx3hvyFrRhmOBgxWh3SYdilCArGAYQ/SE0zugwwKKR6dGp91S26i0QVenpOaKUynGeu99x8GS7wt7jsj/z7Gn6ViyXBsgrknl9Y8wOfTKXAvkCa3eR5CtTkStpizHjnxmnDP+zZsTAcapR24jbSmUi9ZIkfaCc+ZuwaZFU0Gc1W4GPBKKHQoHsqWy9SMLIBo2fwjndRizZk1N1udIgLfbu6aBw/u+ZI9p9C3ZShhEZtfUry9lYuSj2vXCks8CFdOaraANLNWhY2BIN/zSVhqOyW2gaADRh7SqKHl5t09ookE7oB1SQUDpEHadnB8YWa59OKAxc4iTmeCIwPZdywgiA0Mhw2jFYBbQhhnYhFpMR1rNBw63RtyB0xULlfmgwyeK+VygFnwYk0yzwF/32lNrBBYQpzwAl5gOhynzCa8SWUJi2LqeYMd+LFxmoxVHWZVaCMAbiqfT2s+HnnhYgQQI4jPldU8uqv+aKbptz/R9Ozc3xtORnwGNkpg01bNQuRSWqdvWw4G+XS/+JBOF8Ghg2rRUJodZBYql4BOSuq028bvKVw4FBhW48gCVHr7wu8zRM7wvbG50lDiKTxSQCSQVDKaz6491He1a/1r+PNU+mjpUmj0TKpCQD91IoRnImzYKKXFHO0TBICli5h4HCvXG6rWQC9ZcxeMETukLBLUgYz4eZAz6B5tyzWb6J1HJ2Y7R1FR6ckeKtlJo8lG/e7IFWhmbybhe5RIsQ//nvRHf/svb3Gff1n60z8X/vkP/JPSez/5y90W/+1+/fS/LP3kHw///OMHUm78//m/+Wt/WtHVdwehPmbb6FppvucLE25uXoxCgPqQN6zna68vikMszniA8+XKPsGn+BUzMol3lq7YuDu4pBpKJSGHkQHrEgYy5xDblUsrtQqjDdYEnSfaRrrL3qBrBjuFIeQzZEfsbeQjzK7Yl1z0WLMlSOcI1l6+pOk2b9hfSBKuz3t704eszrtXujte6d47dxVl89pumY/CziQSMK880qkIYIuUpLp/D2xwSFHp1e13E60DGYdIWsaIIHbMFhnbMP9L79IqozN3A8LFgzdzgLFvSHVhVBSCIhD7xxidc2kq5fPCOtJsYDKbzZyEnJbVNk2mI88N4g+ZlWGuiZNWKIIostf27AVtWy6wDOSywQovp2iL4UVIvDGpkPPfRQ0ogDVehtcL2I5qrtUWXXHayJFnlcuFqpWiL8AoCo0KZy0yJ/I9i5WKTs+ug7Qsg68352xD68XKUWSgU0QUlorkyWZfJyrhcU0sIhft1eWVRv2evZMxm3mrFyVwBzcM7TRzLLs80N5CTmHgvEL0mXxdtZnpBl0YhhaM121afE/vPLzvC4s2+uTkWPfv3XWLDeMqdDpocoh0malaLil9wBykbCgDYs5sCr5MUjrbIfzFoBmGGvPEKJXSaNRzhwbcSl4eQ+VqtaFavebFhQaMuV0mTSJ71k4jUaXsC5GFRT7iepPQxdXAcpJ8oa6UDRWCgz6fzzNMhNfzpa3oDloNpdPhsI4URMrZcsnm5VzIsDpH06muej31SRcwuw9JTcYdFTNfCFK4urAZxoXMa6iLB54ltNTVYbBTgxeBuJ/OEKiFTp3vHNw9kawHI+Al9G+ChllDb8R27WITk5h3son9zICbgMfsmBNmC+XyysJ59HcsOFPFGYrvgnsNrF3P5JjbOMqK/z8dJlKApLVVrBNyRUtJ9GUYR2A/hWwoZOUlVAzRZyzFXVbj0dKU/4UNCzaavDx3J82c8969Yw/ub14XV2PNhgtrYDkUbNkXbz23Q37ypu7y/+3rDX2p//mX+9/9t/31hkTpl/u92AsZ3j6nISc7CMVqbRPyXSonwftxpByetjglkWfLJQajl/k2c66izTq6/UGQchCWzc+JNi7O3WntsH7DqSUgIWa0+wLDnCAlLES5EDikuSwhqZhBm76x3yQQfhvIILmcxxjsoyCpQaa1VKVAmgYHflLNTktpYFKMvm8uyjhW7xrbwaRqcUX966GePPvb+oEf+tW6e//QRbhRNfsfMxKILPXqXr9S/3qkO3ceuCOFG0H3dqNZBVnJ1WBbJ0J+prgImQemzZpGQ+nwAmtMSRwKZL6bgHDYwME0hWaCszIgYYyUuPC264RWTG/tvRuKliAvYdYYiIyQ/BbLUYgJLFX25Beah63RJ3SU+XxK21XO0iXClDfrhLZ0iiaf8SgCOhOQLFCohGI8ZjEqARXIhflpvGbE0vF7/PjbLzRfjExMIxWqWSv7gqQvgQToBCAyXkEQuNg9GkNXm7bfL1pvGgZsJmkEZtxVoAXTuXXdDVKVLN2icAm5o2/1ouQSvIl34oJMLOkgA2Sxm860XAdnfnRUHJ6wwOzj6qE7Q/Ctq6pWs6HC8YlxCw52qioqplDJrZXEnNnuFSEjEscIHibxOr3uVMsVbK8QQMwIAv0i7EXIPkQH7aKkKsWyxd9n55duy4mKaTTbPty73Z7hBC5wrKFgn+L+cHx0oOOjtg4Omta1ae992HDYalanZxeKF2Fo7uBlD9B56Ph6zm18MKovlM6UVawS2rtz+G/zsK1MsapENqPuoGe3fKpla0udvi2V8DhUSkOKALpJcuziW5iKbrocB1lBCfiZdAb0WGnMxQNpA1gFeUG7TVpE0R3lJ598YuIPFw4LhgXqZ4mdHw78ZCbuJTrAuLgUMZeMdgHGYcOwUULnGQgoDtC1TpgDKJjRe2heCNolCg1gZ8MeGIGnMEIO8Cx2XhQaDnC2Q8jas1wnwtCd5pIq1QomiG3Oe4ZTIBVMZxt9/MkLLVaRepvbgNsXLy+FbK1cIxM1q9lkbELLyf1jxfXb74/Xl//qDym7pRvdvWbm+j3nqDAP9V/u/9wPn/423U2843/m8AGyw8WHDtaH2i54ohKMCxMRw4dSKTAUnWhiGCykelCcULwhgjerm1goZ2IijA6svvAd8S3sdcV7gTpPypDSAlZj1tV6uVRxQDoFKJcRYw/r1nJZF5OgJSZ6YI6E7B33HuZPngni0rKXYdn0IFiqsS6A6G1GTneBx+pibROCb37nc3q6/17e/z9/vzaboQ/UG8s4JFW5Zlp/4/v+/O05kUjae5UhLMUhJBxcaBizrN7IyOWMoPi2Ts6GDDBbzSyxKQWX5CleoMwhsXzEom+9cJHOC/9P5k543QaLSy5kZokzd49O6sjknFaBgT/7w8UixR5o1Q69NzKwghr1huPo8JbmZ1DAlnM51ZE+UPDHkYPJIYPxmV4H/8LiTxN/t9E0uVAmkVe/e6qf/q/+tr77e76odx/fs24WLoZZ6Zwlidi+yFdXT3R9NdLduw/V6w40UfE1+YwxxjIHgkMaThhxAIHPZ8xjsZFL+3eCBN10kDig2bwEZx3QPWsnAxmHNce6pJClAGBPJTYBjbLJC9Foy8Aszuy7P7TTiX3XljLHBNXCnjWP2Yt5MympAOM3ZdOHxRxTgKQqqYL3Br/XHrzbjRFJM3j3cjJivfiR1XpZ0SpWJoFzGcbnGe91mP941J4cdEzwBBmjuSJ8mvzLynSuq/7AZhaQNIH5cynCJ+o2dJlNxx7/jUi3mS5UKK81ni6CEQrMfQINrEd/yxelk9gjMHO6RR5+aNkZpuLq4QNzD7uGOpKOJzi6bAnXLRctSTho40la9uZAOnF13bezzXIxdgfIYVPHNee4ZdcP9FBcogiFWRh0iOD7VBRkVkLzb9QJOe0FgWsqp1IT2jVda6RBchTSFwgfWq3sPENs103cEsQiDiR0Qgy9j48P1GwTXEuQKSkJOfW6Y11eocxgs+08N+HTorPEoIAh8ZDhPLZ8i7XnqlQ7wIG4xVSaHV12R8GMHauxdMpVED+PGQ7fB4uQjpNB9QT9aeqWnQEkUtggicHub6cGHbYjlmKV8kGwD3uuVimq06p5UyOnKGZTmvtgQIcYMunCIZVQgYixHPAqBJ61XUo4BFwFxzAVlyYUUSCRhbndomULDDmclsze89w6zIU5sPg7FxbdH91sFAcXEipVEk1c1Gy2GlxNtF1iy8Z3hZNN6DpCmgEaxIyK07zGOAelcw5gRWM1+dZTnZNIcxguMlw56qWcDu81Q86e1jpoHOvgoK1h+eyXrN/v/c/+CZWXFFdpFcs53TlpqVojjSWv57vS64vyn3z6O/WrR78tEEuwH5wGD8nNcqPPPn2lRFy2yfqz58+UL2Vs4XZw0tDxSVupTKwCBvGeBRFDReFDykjK5Cb2zo2RBZ+RIiV4W24srkd6hAMOZA4bH2SLyufZK8yGlybHvHp1brkE19/pqzN3BeyXerPmhJqD44YKFUYjG+vZ8m+K6DGkMMIR0lGQD90wmj0bgnSjrCbDpb7+tY+1HB3rKRJJSd/zf/gt6p+emnNAF4aX8PHRoTbN6S+5KEMyCwQ+1nlAG6D2m1n6hq2bPZeJ6RuTHsT4g8STnIsXmPOX3a66w4ERLIZ3Tn1w0k6wwvMlMJ9aqsPZg8SGTgLiCUYGfNZ6raXDg7Y/M3NHUCfmcJalWf9K0krac0hGH4xVYM5TaNfKRTsrOUzY8y4IinSyQaPqexIRBN0snQteuMCX6YJOn50qx6inVNLDd++agLhdh/nnaMDcnQagpk8/fqJCruYiaLu6/W6ALJHiUTdMYcDG6M/5hYjuF6rVg/Z6F1G05DTsBjN8CHwUqmgdrSBFZ4kpQYKzy/REQ9fBU3tlODMXZ00gxM+ZLhRyHOc5fJJQtFO8rbSlgto7QE0xWWE+mkR3KuUrGUXJ8L0ykiMPNbFOuHCGUJVI0b3idIVune4G5GFtcqe7aBJikHVkc/r8lx8rX0nr9Kzr7g8yJ/sIZGq1I1Iu6csRq8br4dh7I05ESpBDmAqhDIQtYIQzX261jII0bDuLlOb9xSt1u+FOQNb31i9KYlsMs+61RlxqOOFTvQERsIGoEE1z35EJhqsNFk1kVa7VOWjpg/ffdfV2fT1wsgReqmwAzHLxb4UhhsFAsVJUu9N2FYSgny8jwthASASoDKaeo7UzzcDqRNu2gJW2VSrHQJvIla0JPVgUOciZlBFnNwdCALAg/50XJpZL85XOL6/Vadd0cNhSsZRRKouLBUSAmSplYBigDWkJfIP+k8+OoHgbObfx8rrqThW3nxTWd6Qh2Ot0pelkbIiZrjo87IJhBWAjOjlYdXSBDJ+hVtucYP+yo0SUV6VUULc7tAwlyuU03Sz2LvgMx1N2zsiRX7gDr1/ZoQK3EYJs6SD+uf7f1r9//Nv0qar6y7qr3x29MkmL2Q2QC1Rr6PA7DOtTOZsaAI9AbMDT8dXphQ9T0gAoliDj0EnRuTj+poIZNswynE8wUSdkGxp7xt1zHIW8w+mYrpJDe65SmRkzsC8OPHnVmiVdX0+0S26C12sCp52SIeJPsof6WvNDfyff/Xf+M2tY43LKiTLVOkYU+X026Q3cc/uazzZKzJlVAMlsNJ5ghIFrTaxN7pb+SRCuw3jjTZhzpJhZI//AoLqpVy+G1tLdQEp0xZhGkPmXzTHroSOEdYTzEwzN0J3TheBkRGGpFDN4JASsS4KJY40Rwk9mKuZL1q6en17pS1/8bhsEDEdXDg5fb7uKNrEvvvkUwdlOtUpVbTRqpLGMhkrnpQfNkz2pKwi740QoaEEXuGKQX8F65junQgcWnI2Jf0JfWvKhyiUSOO7h1Wy2tJvPjBQwL6/XSo7CWka/lAzBMyd42S4y1iiH82C7Qi4Q6089eqY/8uQd/YWrqj46rOlOcuBDcDZe6pJ5XxRrOB3r4urK+bWIx5mFG8XhwoKdibk4bNXl1KbpdH2bDSjTgSO96C7Ym6BOyACK+bxWOcT9ISs0fC4Y95kg8arVjXAlCnlVCsF0JMtMjZFIlBLQC50S++y/bHxRZ8WOL8w/tvwZX/j4mfJ8y9W66uWavWUvXl7qG1/9tn2dC8Wdur2J+v2RulcDP0PnlirttdVqV2WseP8inmo8G2v87FXgDzA+othIbI0odK+Qrm1UK9dUq+EzyeCC2yfh9QtyxHy4Uayqapkds9sVrAx3ZyHsOUDMQfLGTJP0p4Quz7rOfARhqzdLKufI5w3JSva0NXSNVV/OTF4Y75hp1PMlLZfBE5towcwu+GXHDpEObkF8/7y3YFsaKZfO2buWBCbY/6xNkqA6x3XlSjnLhJBjxYmt0mSNUkyuA7KQLRb1uQ/f06uzSz19+txjAWwKh/OxL0x09vlyxVpLKxqiSFfdvtE1ilbOLNZGq1l/uxclnYPTN0TA8MSbwExRdyyYaLM4I4er8uHqpYoevnPPlRVVDZIM7Ia+8c0zD2OBK/nvgXCa9arpvuJwzMgdScDNEYbhaVh0BTQcLyx2ZtDLgQesAyP2ejHzZUyVMNvMtVpOzJhaLEiuQBxf8TyDLpaqCJgByJcw3SDGhlG5M5P28vLKUC4Vd7PVClTrJGw2MtAyhhCo6D3LC0eryWoWoi9W2pTJMFwpM0LsvFY2P9X85Uu9OrtWr9u19KPTaqhMePEO+AT4F8iEbzbhLD2H574hzgbxoABgUQ3GQ74mzyI58CC80N8CaeOBi/ck0WDMAx6/90gP0CdO534+9Vy4PFZ0r8mQMgBDDDICBxHnh2esW2jgaEnTKvgCyOnyqhvo4DiLVGshHHUX+3uiQOcyZxMhgsfEO0CMSc9HkW6QexgClYEfy4YNDctmwqyJNAQu7KMj7Ne4PKCrFzSdghIkPV9ZJbNaZgIpqTA69xwspCYA8ZPaHuy0V0B5xGO98WLYnyEJJZvWNs2ltdB2i/kFM9Lbat4b2YG6BENTbecC0SSZtV1ir79UfziyDy4X7nIzV7dHxFdHR+Vm8G4F7t7iF0vVHBiJhvvQDeMQw1xpNjMkzdpO7JmYjTrrDbcStIHBb/T58xf65OMnho3W253RBzovS2oIUU8xf0paOsWarG2Cto9nlkpXA/vP8oGgf8zYSi7Y4nHRUyhhZIFfLd3vusooBLZi0LG9/l6iSAfttg4PDk24Yqbnn+lW5/bF5et5FM8Cv1PQJ0e9kS0a6V46xLD1NimdDWdqEJy8wm1nqrPTMyXTGc3tPBPCf1kTvtTRKROsjnQsnbPpB7aQPC0QopAXWrCPrlGu+dz7fTJ95Q1EEDc+UiAvoePFiSrnODP+LJwF5B90+xBKaFBa6HgJQWBfYIKSKWhZrGtNJ7WLVeidabxkhkpRyNNN6+TwjrvMJUYHm6RG3bE+6z/XxdWlVsvg0MOeAEYvF8r+LFxMb2pxGM9kVpwf4WyCi+BxRoL1k1DdlpMwwWGHkyqCuX3F+4tLILXdqVZvhrEVH8TytJzLA4oNzC/IbKHD4xKZz7CJW2k8Xujp8xeW6JydXeru3RM9eHhilIe0GS4zSE88d/gJkHOwFdwuaXAYfUHsw1AAc9iQHTyhuErtrUlh2tt2j/dJYQ4UijsSusugANglI0cnBjOPpOMTCwnGAlifJpRd09mGzridzqlYJcw+pVevzrRZBmP8q95VWBP7HMpAeNopW0yp5VxNuCrsU9CdzNu9KJGFAHcaIrNYNAyPaYPZcHR0/HIousBzGN6m4kiVQtEOMFSYnzx94s5kvgTzrxov5uEyv+Bn3XiFQlumktrEaDQ5BLOeHyyWzEjR8AWD4+suIlKSSGbuXjmUbB9GysZ6YJYcFzDUcVe2SSQpRM5M/bCAP8MMHN1hNqTA75lofLF86XkM1Bs1H9jZDLMSGJnIX3DS34hE4B0YPAtkrw/jkOfs5TLudfs6uzjX+UXPuZZ0R816zS5CsM4GvaE7CcduuYIKKeV0ga8PKcU+kONkZHx+sepatG8BM7KZakknJwQCZzWZDm0Tx4yhXIJZF3Isp2jQ3pA9UNQst0svRDa62aZOOcHBA8ZdpPFyptmShZ6y/RpbmcVMFTqbM2gI4cCgBqXyPhUAQkAKKnrIhWP+TBe6WpGPFxxG7EGZxN8y76qTyhr7PATQvDrtEFRcyGOYPbenJ102RKabl+VFxYxp98w4qYr5eYkKFx8M7V9KPHE2qB1OgKsCJMh3wNrLvSEodIrE3iibLhloDmJQ5ET5SB9++J6JU/3hpSUGj99/aFID3y2UfC5uCjZmstjMUTDwHUEyAtHgYCAn0QHLmAXkWes4mbBnyMuMdXR4JCwo+Wdm6mhXCXFmT1xP+7Z4qxZJomEeJT19eqrhdBQM0jPS4d2maum8fwcdbZgdI88qhmJmPvN+xmHJFmHMt9DMzVcaRmN3MEiU3iQ6tNsN1XM5NRotnZ5euHBiHpb/x44QG4p7jo90KJD6AswZDDDIEL15MR8d9PoadufqX8EUz3gGv5ng2ZsJXqz7EHBSfw6ODnRy58T76rNPPw2B4IT5OjWDbphiNqnhaOhEF+a4jIuYkVbKjGmKLoJw1WJOzagFqcfL01eaYo4dIkR8seOGRcdPAZMplIyk8XWY1Lh/cRHbHKFQ9ntCi0Ue4t3jezbXIP5sOprr+ZMXloXh2IS8CUvFRAHmeTDsYFacSN6y0nvXlyoQUp3caxJRBYxWPgew8EzXq6pgY7jG8YdYt5nJewXRFNSU4xLLJtRohsxK3HIIdOBSsD4Rxjr9Jed1xHm7h1ETWX/e56NTPX9+avkVRMR33rlrK0pIu+VizXA9TlwgTdVKzfIv20yCapUKGg1pVEb+/jzz3M/GOTdCfCLxV8wIQ3qKL00gdGs+y1otMDWHNRxConm3FDMEpTPYYx0l05HiLTB0Xt938iWdvGrp61/9jsYDFBUpB4vjLc3Z5pSmfEZHdw915wjUoWg4nNHHcNh/uxelLcZWAe5xdXDDZkrAQELomzfriLRxNC9O/S6SCECoKgxS6G4JVat1JVKwKIFBsJGiY4S8EHQ4DIRdde15/hykfHEc4tuI3wOUF5yAqIqK+azWa8wMAtadTqS9uHCrwaXH0NYNJLwfnt44Q6zt/sC/k9lGlltgcr7Ot0NasdmaQs4ht9rOzRrjPbNhOPSAfhg0k8JRrzdUZAiegJTA7+BvpE7kTBZoZMjoLDmayrAbHRuw73gmxBm4GAEJ+YB6I9EChlg83drVghBYLOGAcfjeStWckwXqTRiAWHJlPCdjM7KBoNZjxGAtZrGgX7G71s8kDvRim9XZNmuyDt008LkJOI6iAU5kkS1MVoEtTO4bjFP0jraJ450y+8gxK8ZQvuhqngPRRveJpCJ0Smjg7LUYWLPFdMq2bkCb4QbDE3VquKlcymqxmptFCA0dyCifC6big+Vap8UD/yedwXPV8lKzUFPngPlSNpAkDO/CvsPq7pcubV+shoyZqabt4ML79+X9RlHCrIfP5/kKlSjyG8gV841ymaIarbK+6ysf2X5uPB36kuvcv6N0GsekZYiLykJNp+WkG00aTmJORpHlsYXDlIP+DSiIog0Ijg1eyJQMSXMp3niFsldyoC+lgmHYkEyS8UVBUdftD80IzRIxNZgE71uTDmFacjEFHZ8vySUOVCGZh8OH98TP8CFOcaq1EhQTWAx6U4XX5z96X/Ne8IV9/uLMFnqe/VX/8SOERQ8yAQIFczPE590AJAWt9F2FiX5xUdHT7LEO1t/Rq1evNBuvVK92vId2WBcSsrxaKpdkHRTUbDR19949ow904xTAjE4gvrH2yD8EXhuORrq+7mlEtJ610Ts7t9xIJbgLSaRgnsk2Y2QyxB96jrl2SKEAkqXLgXeQZh7WafuAfzKPdF4OHswfTl75TMBqESkFHs1cuoPuwHsGWI/sh9513wSpDSkni5ULZTrjXQxys/ZoyBdC+/j1NwiZcHb1Uglhy8Z5QxA0ObtpZ4e26k112i31uz1D2pPxxKQhz/xLWZWzzBsDcSwY2SfdEQPDz9cL2+rRUbsu2CsHKFwT6VjVRlmHywPD4GcEOJCiso50925bjRZzbVJgypbIxcUQ8YdpRIQXMmvH8G7R+9BjHMYgzCBdnG9vJbmMe3LAs2FvQlhkRs9Yg+fJhGLQ72s4AJZFMhbOlRC0HciHFL67FETChI5OUCq8o4uznm07/RzRwbYJfSj5omw0Kjo4KHs8w/cTRRnV2rd69bfDesU6zYddiIXh34EfEPQzp2qQ3sDgPlNXp1XXQaulzmFLlWLJX1B901A6X9Jlt68oCt5+CGPBq/G/pJoETqISmUwDVZvZDrOsEUJl5qDZUJ2g0SHWClsQDkguJ9wbMFH2gc+lk2OeES4fSD9IMPqDqX8veh0WOQcHEC+fBz9YcG3nt7kjBOsPxr8crugjd6MQF+VKeQv5IOmLchND4oAkUlIayItDGkafhbPACC3liZKiW0ulDYVS1Wc4vOiwuAyzKQ/OKSpwKwq8x/13n4hVwFx8U/F7AoJFYB8YX8xvgwcmRS2WcJabkFAfcZnTQUOKAvbM6PetvqGfyR/oq8m2Pk539IPFwIJDDM3CI9nDyRbzxZ6lGZhzwFq8f7p+DhcOY6rzXC6lg4OOzSDQUTp/Duu2KJiQU+D4+HR4NZc1uqXgXYpFXnq1deVK4bBaAokB5xZtXJ7LATsR/p3QZaKor9VDlub3DL+mR52iC7JWu+FLyWkM+byJXlSRwbHk9lWvV9RON131cqjAtuO7cuCuCSPhFS4n4KF93JKS6i/6RgbQqmayS9UaJX3pyx/puncVnFOMcAApgiyE5wbkiJUj+rQQirtT1idTsFdjT1CIcUhhcu5sy02sl5enur4cqlJuGmJKJ1m/dWesdg4OtUGCg1wg3mkwJutyarNv8kRtLYmZN+hEqhbm+q8vqsQebt4YTuYQZR9QkPKsN9ON0omMZUiQ8Og4S/u0GV79wZXOnj7TixeXGgznKhQqLjLHxEP939n7D2hL0/2sD3x2znnvkyt3uLlv0hUKWKAAkpBGIAMCLGBAgDFBNsYMgzAGYZYxCNbImBmQJWDAC7CRyBJKCAUEEtLVzbf7dnd1hVMnh51znPV73n3qVF0WRkAvL681fKK43dVV55z9fe/3vv//83/Cc8dkYFgyNwzPNATwBiOQqLbSK/1njXN9cr+gfzy9oXco7ZnrEjaz9xYQFbqxtGeDpVLRs2FY2sBzjx49svCcQ2NrYyN8/slEu3t7fmPaQMIw0uOwPJGq8CzJpO246wzrOGGWJhD5eDQKJugcujZxDx1jbBLzc6IHgoUNfP2JWEOvZ8OB9nXH/8rh26xj+AY28PD3gwjHLHqkVC+lVgtHKVmShowjkwFtyIWYQR8gV+/Y9ft+Y29Hg0SY79MJ46dKfm6QZqGJTvuA4j2hoKd7Nns6kg/hCIul8hn2VAzecb8BTaHrZnAciFC2tkP4n4BxTmGzJt5oQ+VSxQxUeAbn5xdGhi4uq7p1e0s3b5LehJxFjsSqN5DFwTwOjmY0T4HpHXdBwwmDs5C7ZvZVbPtwGPO8mHWR8vPjcyBtuWhdaHNzVxfNS7U6HY+x0skgAcE4hdkmew9dMqYimTzIQFq5Qt7knxt7PZ2dnpsnAX+RvRSjBljgTkoqZF0oB6OalOfjb+tBySA7lYg+JQXYeNlerWD3URVzgWyCHyhMTkSjja2Guu2OTo6PbR3U7QOfRa3rmRk6XHiBUv3xkOiAsJXqDwfBVskWSjj+h2E5HxQoFIIFX2clWKOkfVesGTo7vXDVZoo+sOB8YqitUqt6rsnH3djY9CaIVgmiThix0KH2lIgSJr1UpXjbpgPRycpwDQ8CJxm8YwmHRgLjKtCuMgGmY6HR5QIBQp92V7dON8cowZRsqi+7VawlGwNggogZh2Tx4QZEN8k8tAu7c30RB/NiJa+tvW3PEirlYLxt0+R4VMMRLN6gVQJ3pIJG3wWUxqLm+zOIH3Bfe219/eyT+seFV/QDkT3dmJ8qO2r6XjidAcQA5hybDb6sk4hhdTafEDgbEtGhb1/BXVTnEFo8F7JZAwUV5t3cp2DgHGYFGERwUOKWwcvFNgRsSqQUpLC8OzZmIczoIkBUJKPndvT9veCr9uH5ob5kO6Ni9K7h/Xw+baIDMxvkAIsZjNwwA3n2QtDciDaCN6jXT7hfdHNTwo/XFx12LsfLHvdLlIiSoJDR6WKmtx7cd7GA3OjWrTvaTm4ZTYlFkCdh6NxbJxiEpAk+N9pU5s/BpDl4wK5wVgHZ4N1hxssGQ6hAd6Dzs0ttbOxpMYvpzTce2g5tZ/eWERkq80qlalh8Tpj3eGRiBu8EBPyQEyq7zRBJB7TKARn8RK9YyhGvAyA2xhT4qAK19qe4njBnDuuWdy03zEhrrs6jh2/p8ug4mILbC9XUi/Vhf32Z2U0JtQKKHnsDZw3g48zF9/9AcaKvLrf0Q+2K/m71l+r3LVY6WDzRchXmWIHpGuLneB4UuqytJ0+eqN1uW3dJKECjXrUWm02W96yPvMMEvaDntbn2+rDwAUgiy3SsaStIovj6WJ/xPe3DbFyLJgof4JSNTJCqHJ2eqZer6V/de7c/w1cef1SREZmtQdaSSIzMSCYwnefaxscZGUZrpQHFyRL0aqXBkJzenuJOQeEgjHhsY6naM+QzipS9F1/wuoGE59DiQYi9opgiOB6ol3EUBz+OVBSLjMU41LYKDRfRrHH7va6lQRQEjJa4pyZYkXBijkZAneM4izWwiwMC5UBJuDs/P7/Um/fv6/TsWIfH53rHSy8admVNXFxe6u69GwF94Js5Ei14gsMBmS9BK1wfBhKPCxdg+evUHv4d/gPPKZbA0Tp0wpwBjD/arVOPkSIrUB6MUvjZATP5k2MXI9wnOkdQl83taghTWE49ygrveXj+rE0b1k+d0P3cHP5tOSjJZONlxtPcD2pJ3E/G1Tkyg0alqHqjplWE2dXcfopQio8vz3XRQRqxUL/HBkqlianvRKtIiFbipgBBdLpkAHZ8c66qLCCYUAGxOMY2S47G2Mii7hLK1YoPq4ODQzMFSZXnDhTyOS9GKvnE4akXQrlS0+7uTe3s3NCDtx7q0f6+Op2mIS9s8KDTRyIV3zwO2+ls6IqTxYOVG1Zc2UygSyeBgmd0EQytcfjI+nBAVtFs9rwxVCEDYAq/YJ7Jhpt3twNbjKoYxjDZeSxqXrJKpaRep6lCKauOtWjriw2jBLEgpVlSyheiFlzD2gSWQRIwm47NHgu+t0EHR9Aum8h2fUutdkut5rkTRl5IoYeT9iN50SRrGGzpiJZi3VARW5sWD/FDXHQjmK2zETrM2dLCMOsJfy84/tOxe0M2zEmGJeG9QLCYNwc/TwoDhvo2+zb9fGaz6UoRX82FFrG5X1pbdSbj6nameisadAqNVV9FsQ6AjfG9DNKDo8NjMwIr5aqhbUhOz150kPlVWr3+3IQjaD9IcYIu9Ppl4efkReIXnSL/PZ/PqVQuO6AapAJUoNvrGoai2IElmrFncEilN1xKZU3WpY0pwqG4GE1Cp25dHALyiPKZrE67534vgLbv3XvZUonHZ8dGQCiwRtOuLi7bGoxmtjzzvSNgN76y8NxG1QQkZ9Z5ocOxmudNVauw/qKGzSlqODivzNI5eAp5uk6QmoTRiHgi41QUh1Wv5oqMr+dxzMZGraSj9mwUEaWITCpRwX7y+oIIR4JKMkWSTxDlU0gxj6Lrh1sSn4y1G+MEruhBctOjEYqRZnOowehMiyiHytCfjZ+TDpcD8uLs0sUA940EFAoCiDMQz9iPpuOxYVMMx5dP46tiZlXbMANzDALLRyM/QyQlZv0ugnk2nW2KmDcn6cQsmeoNScOYaxCv6iIb9LuliyeO3xthQ+c8VAhlENPSHkWlC3kX3rAzZ+s9LJrMaBWbmNvAZyuV1kkz7AER9MjX/AEcujJRCGlDSyNCrF3Hhepkwt6HxGNkZAcolpkkRMk52vN1yowh/7XOnXsPPAoUWSnB5Gceu85oJC8SM4HFyG5bPHcQExAs9udqvaCt3YYO9g/taPPm6/fV7w700ssvKJsrqNU+16uvvq6tzYafM9+P+8lBCk+h22s5qBk0Mpdl7446Xo61aMPyVMrP2CzYdT4nxUwyk1CKgItpRpPhzOS8wG4OhCt0pTRHENiOjy68Zzc2QB7YD0AjSSlisQXMn+aOopCChvMHNJNOHJLU23pQ3ry1ZUIHm+BiFnLUwPxJOYdiu7O7bdLD8fmpmVZTWKq9nprdrsb2HaXrSpqgAJmDmUljs2rIjg2UF8Gzk7VXI4PnEBq6UJZ0jRQVZEUvvnTX3RoVGALrWCIVHO8fPradGdFCHJRIHXhQpvc3g19h4bJr+AOohOpqd3dL5XLWTj4UdJv1mn1mefk4gAoxJAeEI2c0naADCxpIFgFRR8TScDggY2CBWEA+4yDIaXt7U5ubGx5SM8cihBdrpWDzF4KlI2RUOloIPVnXDhSbuYZmi6HKlWsjbqo7INnPvPqaXv3U6+q1Brp986be//73uOuDWMNywAbQLifAc5GIyRvcpwuKlYsLw7QOdl1OlV7NNY7E9R2lX6pv75wrNh5qMuibfs1hjhZrxdwKZqSZbnTnIaHABmJERxVCTiUHifMGLy58cBgCnpM0gKooiI6BzljowJzMQXlhQmcHxXyiXmegVoZOYKHSKq8i2YDARPO5fvPjF4LpIAxO/EMrZW1sVPxSs8Ewpzp4cuRiaaOxpQYzno3nHcuZ3cTG6EfTimJagU4WiytT5K8PBNa1WdfQ1Tnw0KQtI5ZEvOPd79TR8YXF8EChBN2WS1UlMEtwbCFddIDybNIfhz0dZoWOHloXIRQzwdwaaVCwb0PLBhSHRvPsjNkMkOLSlHZnrM5nyo3GJj3tbG24E+FntEYRAku3pdkK6juzL6DziTuTyWyoeTmnLea7aUwT2uvCtBucqGBdUtQAl1EUGW4Hsg8zsavr9s0dpQXNnjQa0mKwlKsquf08dMW8CVgLCNUgMQHjcSzUQrKLO0Y2u+VMcJsRrPzxra/XH+n8bS1XIDJ9z1tHs4n3BgoXDEJIC2Lv4Xkhd6F7GQww++h6pmfGajyqcqFgGUo4VII/LIUBmmyM0Ln/LsIpBO3zTJGTUSFXULlAsABsWRjzY0OPHPbDaEI/+MFfHzbM+UTL6cTFIe8u3VoIs14Y9mXfiIKGROPBo9Z5u7A2gyl4LI5v7cKmLblCzkRBOuMH0WsrNfbCyWyw5hsEfTCfJZFKu3CESQqRiC7Yx6sNAa7W78Kz604b162pshDRZgvtH+6729zZ27UEKRSz4cBmbadTWbXW1n4443AYb2wF5ul8FtGNvW0dPDnWwweP/I63W23dvLWjGzduqdk89dnQarXtBwtJKR6baJaK6OKcjFpQrZVGFHfM/YVhCilB4bB21Fl0fu1Zq4AULRrwD2gu5jo/aSsZX9iVDcIcrDUKunyxouGwo8MnJ4pEF6rUCiF8I3Y9kwa1mkWkYgFOgHR+1jZ82+9xn0Zv70H5jnfecyUCDDgehoqeA6XRqBkqzJcgsUij+dCdCD9gp9fVBKYTYZp0uvGV4lTTxNAkIPaETD/IGrPlVOML6MLBho05ILNLjAr8C5/WQsYCYpv7AuvNFg5iPTs5U/Oi6YPIsynHzazMBDO7NZH1vAdI8sGDfT8cNsl7d29pd3tLhRzC+45JMSzOAFGtPJTn4Aam7fTIOxwZ3uUhcfCDdztGacUL21ELjWYqZRo9bMP7Dx55IM1mYdbc+sAA3mIGcOXNyO9TGV22L1QsYjqPScP1BsTPe3L8RB/9+U/q9Vfvu8I6PT03S/Tll2+7u6aaxggAsToLkS7ZrjpY79nzNqFMve5qvL6a6XevXtVfi7xDnUhSx/kt3V4+MQmDAsdDd6cwTNTr0VlygEXNaAsp8gHOAu7kcOCfQQQuLpuusHmhbTlGCsE6wcRyEg4l/guzYzaP9WwQGz+6bAgOxG1xkPJzU0C82osKLXZ8OdP7Lz6hd7Y/raa2XD1n07ASK059qW9sWRvZ7vJi5szue+6KssHCOkaXGWZvXnczjA6uB/rOD5zCXmX2GGQdrCc2062tLUPRrRYWfByGeHjKjElm2LBfmSmiPZ0nrrIlw9fm6zGDT2dy9vykeOAzU0zy++ji5rOoHu0f6XOvPjDbdzKks4YoVdC03/HmTMg1hhObjboPSnRqdI1SzizRze26XnzxtmfeHN50Gq1LNj7mw6mnCRQh4mmmQr7swGFE/qnxREWKwSjOLyF78+oqlvKK39g2o/v0FJMQCqW0clvPe2Xy/lpiYRcVSHZJzTlgSRri8ITrE4nqt9Yu1RpF9PdGe5pFYjpIlBWNYNyPlePYBcQUjfEUgkg49NhTWMeW86zt9Tjw6FTopDpo+mJSgfnmKqp5GokMxWjwoHZIdC5rf0+6HBtmI1VIp93Z87XRXvc6LXMYBAqUyeqidlsr3t1xTx/5zA+p1n6iaSQEEgOL8t5h82j+YaygdDylDN7UpCkxs1+FTE02buaOvEdwLEjT2d6qBcet2TWCdHZ2ripB3MucpjlmjFGTJ5GhUcy0Lltqd3q+D6MpwQisOzgXyGx63g8q1aIPVQLFQTN2tm/o0eN9/dMf+Qmjcttbu2psbKjXhqg2V7XOngsicRV/GNV4AZTLO1PQjVvbRgw3txs6PTmz/OmiRcB3QvWNupGdEZF7w4m73X4/GGYQ/hxZpEOKy2QpEtl4R9ibIVBdLhdGNFiTvGuecadQWKQ8qohGKIwZS7WDk1oMXeQ0kDrRcQ4nDhWfr4JEh3cCpi/nB83F9Ar6T6VMDMIeE2Ieo8nJgDURe3sPSg6RdAYiRAhihnVmU+EsMGqoqGl/88gE4inbjbFR8tKRNMGLxwFqd4dF0N0U7IxCNxbRxkZJg0HbnrBo6nZ2t7S1uelFjcB+PBr4v88nA6XiCIMdhgABAABJREFUWbNbqapGfRingbXKDJGbR+fDC42fqiVyZEDabIC5R6iYuYGwxZJx5hRZZRHNFgoW7QMDMmsDPiPnEXs6NmGcHi4uuw4JpSuFDcohwMuA9RUHIIzZbq/vuSsMPDZRY/LruRWHLwN6/j5MPQgV48lA6VxaKZJSCDxOx1Wo5aU1c5lKeP+1I91//ZErIEg6JyeX+sQnPq1Go6J6o+wDKshF8IAMhxdyHrpdXHGYZxlOjdDJxfUliwt9fHmun4zu6i9Xv1jfHPsFvXN1350is1b8VYFFId9mCYEulQw/AleYiLKGsOhUqfx5uUlNZ3ayWBFUDbkkULltvL62D8svc0/nh3akgR2ZJAoneDu6qRFRRCt9fJDWnz27rfEqpuqsqy8+/6jGi4j29w+CC08deCdpCKixseUujNBhKmy6wmcvZiXAgqyJMCcPdnauN5/RAnIgrlbdNRmIrpjQ6HDAMJNCa4aVWHQ11ePHJ2Yfk4O3s9uwrhHrRtu8+euzziA4BNnEhP7JcUMhN5CCk8qaTX007ALiWypEejudJczlu1t7DuolCsqkjGhM5+fnZqAncbeZwnRkowddiatRbqhe2Qym0fHweY6O9l1Y7exu+B0AOs15BE7lDYQFAWyl3miodLenWrlgZu4zQS3WqeIHnssltLFRVK5QNuQ5rT6fV2aNoudRa7vHdXC7IW28oSMY71M4R/Qb9bp+UjUdR/P6mze/Ul/emyuDTngd8s7hCCzH+8m7g1QH3SNsSjZNnj1wLsWfjU2wwNRSWa8viEFLQ2vM7ph9hfUYEJIhs/gVZJli0DETC5ZOq1Yp2woRghSf5fHee/TP3/s1/mw3Lt7Svcv7mvJuJRLa2tky+tLuPrDUhc+NTpH3LpVJm+2eiIVop0DCCeueMAjGMmWvdwStrDEcz8M9RHMMu511gYiehCXeJw72ZZSyY6kI6A4uYdORFMOQPNgxOhQ9gesRo6K0+R6j9kSNrU299MLLisfS+vmf+wW1mm+quH9qdGznxpbn3qkMsVR4dONgs7IWF5hyaROUoSFsDszGRkXjCUb0jFPQJse8FnA/6veYpY7VavZ1cc7httLFedeQaN6adgrVIE2Bq8JoK7r2oeb3+JqBlRuciPAALsNW3a6p1wom8zxP4Ob42mRjr7Rj31aeBUULBySFMo02v8dcdzoh6Wqi+XTlvXfG25YMcr639aBE7BmdUF1gz0bcCkPmmVq9Cx96xUTBLCweDrAUFSVaKDZpHB+AoYh9AR7hYZCwXavllXQiu1SubimZQlg+c9TW7t62rb+G/Z6GwETogBAwx1ZOGxlhN9UZmHpdr22oP4RYEIzAOVjSyWzwmXVwKpT/4HsJTAg0RWpFr9PTbDRUoxFiXFKJYLAMrIP+jwMJ2n6r3QupJY6tgUwUsh45TDOQmAqYtl8ZhWcNTUAqsNV3Eq3gzBUss1W8KyGvoD9iPsRsM7qc2uZvlVwpW87ppfe+oEex6tODkgdNKYa4PKqpu7LgCCR30Td8j4NrBzCatXGYMcA4Xa08/zTkSndKCnssoWazrfd1XtWnSkW1EgV9b/H9+oZERh9Jv6lMt6PMIAix2YgKpaLKlao7NchKDMyZX0FCsL4pmXK3baE78xMi1ub4RAZCS2BKc0AxB44qMwnJB2xaVIH4O6KRAv7JYLullf5VL6e/1L2pi0XSwdVf2v64Nx7mV/Z8FOQfuUDo9MY6P7mwdIUOwvIf9HvPXNh7LW0TFg5FNgPfExONrokUZsym+Rxs5mFOzn0DEnzw4KE+/amHdg4CqssgacnjHZkzJV6rjLJ5BMwkTQBHU5GvDeVZDWYC9rwWOKink5DEwsFAwcQhCxIAo5WDK4X8iPlmJHQ9wEk2/p8vjKDUKhU/48Fi5JEGhR3zI3yJIfhsblZ194Ub3uxanUsjOLCK+Ww2BLCNHC5EyHlC1BkIgLTpwPGnmg6TcMJugddosZzRrTu7NuTYn165wYYr5BuGEQVkIdADkAEbUFAkmMGx0mIaDodvGH1W3535AvVSBf34S1+uV3odFQ8++5SEwyy/Wq6GYmI8czHq57KMWHIFokAnyFrElWc2IeuR/NRgHjFh9IH1Jl2MT3C4BRO/45icA16yTzkgB4jW7MmKY/Bev/0hffJdX+5usjTt6QtGh2bhUqjQoTJrA8plTMH4YOg5YUApeM8K5WLgOlBYw5z17r9QGrSChJtkVKUchxzea9czStZCf4XZOfDvVLWNirJ59NNYma+UymUUh71rpxyZPAnR8opEyN5Mp3cVDg5RhjxaCkqK9K3NHR3sH1sCgiwH8s1sstD2LoYXsL2D6cg8EjruBD+fyVsEHCxFo5iCEARSQH7tmjjDjBvjA0hZjx+e6PDwVERAsTdQ2EDUu3tvz98HtKpYyth4xZQca7nZQwMJMxuFJJhxwRzVXOVKzs0W7w7IULePVzQG8DPtP3lov2eKuHacURaywyANvGLt0/xA/6QgAh7uz0fqdUmCYkTzxW/fQYkHIq4eaPjSCJdTcQ+bT5tdJWe8dGFGw8NhEa/A7zmlFkvNxriDMOObq1CqqFJMqVBO26aMD3sldYhEa94IfLM1UbPd1Rh7qPHUhgKpHPPMmbp4xJ62dXzS1mgWUTaDf2xBtVrD4a68+Ih16SrNbjTlP0A2dvzAUkwkCPQ1wRWlUnHEFLAlMIkNpJ0UkPa8MZuFhBLTZNrzYJ5BNF2VNXdjPPgwxc5pa2vbHetrn3t9DYHgMJQ004yuAnYhD46uxjrQVVTNdkvz1Vi1zaKKybRqm1Vt39jSaecaEqArKRXLajS21W2TqweTNIhzLWFZyzdWRViWaZ0cndn5Yzmbe27Ii0IXwQsPaYLNmJ3kHYumfk/3Z/XnKr9Mo2hCb2a29NWxUx8qhQmVcDBpp/PN4STkhPSgvXQqPXZ2UbR5geDDQXnlugFL9io42hCh09gxIAiVOqs3JI/MNehjZxVRsRD0q3y2t8YZHc5DV/hb2j+qWveh8vmKYchur63lamqHICrItx7t+3859HLFnCN8etFAWHq60ceCgcRyFeY+zL79/KYYWlx3n1f+q474wQ0GJ5vFws/p8aMnOj4+13CANVdU0wwaxLFDganY7r2wq0y2Zg2ZSVXoUadzQ7gUBHTOqdQ8EFpicZNuuI/hgIz6PWHuRVFntnBWTlqpNhq6kd417EoFzyHL4cMGN8SKcQakG1xYUCbNz85Mqjs9pRibK5ONKZ8tWC4HzMUhwmciZiiQl0J2KQe5O2f0i6bPX69BHHKALZlV4XRDlU9Xjzfr8zc6uHhRlKI/VTK4/ATP35iJgBwYbIrUJ68MHuibz871129/nbr5mrrlbeX3P225jIXqi5nThuKVqu+NJUmeZRGZx7uJs9HK3SQdWxbCkg1A0F9CwqqYWNNqdxysAIEuGNZTyCU8z8pbwrY0QYefnWDfbjeqo8YdzRJppRYz/d9Pf1ZbsZFGhbzJJnRCRPlxqLGu2A/9i8JgTvjy0IgTvrhjnJZAlPBFTqaVJt2k39Msh5Xlhk1Q0oQ4rptzutxCLu3wBPYItmncxaLJkSa8Z8zeViF+D0Rvd2dbaUKrV8RMwYmYqDXqmSFNQeTkkB7vIn++qK2NTY26Ex0NzsMYaR7X6TFw81I345sajfFmndgmlP0ikQySPNlK0LzRYMFo/ga8E7lA4YCDnATSBFpHIUiEGEQzCI7N1qW7vFK5oEqVTM6xsrFU6PbRU8JbcJbpwnNayIA0TxhsbG7WfAYwUoPYc3Jy7iICbSSMecxlkKqE9UhjwXkDWkQsZESZIlrclA/uyWilNz93X/uPDx1C/Yu5ftEH5Wufe6B7L9zR3Z1btg1KZOJmPjabFz6ZL5tt+xdube2564KjkCFVBJeb1VyZFPOkTeUMN0AWQKc015iXibkJ3UQmpf6gq1bv3FURfwc24Qy/VKAnJ2UE/ddls6OT03M128gULq11mi7WVHUP0AMNmiIS9wVvGEB86YzJH3SPiOPNNvNLSYzVwvg6bF6gFeQJsQQHy9BaLAgP+EvCXDO0yew1knpqxVcqlf1QwNvZID2jcoIKEF7QF7FhsDnBfGP+yQGmOId2V7fSm6a7Wwm/7ny4PvGxz+qFZV8v3n1Zm409tdpNG5Xv7tR19/auu0kq8O3tbUsycHLBKFuzhVqXIbDZlk2EQy8ZiMfMlqNAqY1n+pOdH9e3lb9Sn4xU9f2J2/qK1H1lopBwqErDLDro8JhZ9kwuubxs2Th+c3MreD8CfTgwlhllgDX9z2sXmmBAjxE6Q3TYuYFR64JjOlUvJl3iapOM60Gqrr81vIEVtv701n2lpwOdDePa2avr9u17dsCBkRyPrkxdBwriRWGNVKtl3bt3Q48qz7Nea1UOsKhhdOZ3PO92e2ST+WT6mrlJgZFOh7kxv+wljIyFwsmEpJSWqWATBwucTs4w3xRtcdSHYyBPNdXqdszS3NnZ8eEIMmAGbT5vUTRwPZU7hRnVPqSsq8KCdQEExf1x51GuKhLBE7XnAhS4m+8HuYbZ+yrCxpZSaj0TBTIHnj89/eeu4j/wwfcqlwNSDbaBfG8XO5OxuzYgcwo7NhieW4Tsx2fmvOPZTMVU1jNQTLuJkTs8OpA2r+PbuExug+nLkM/dOBaQzNeAGMOscY7B+IxUGAwPVro3PNVvffTD+hu3vkqfefdXSYf31Wg+UG4NlXJwVat1FxBOD3FweJjvI0+go4EVP8d20tZtOZ2enbuorUHs8roMxB6ruaIxM1wd86WVLppNFw4QgyiCx7O5Pv7il+hk60W7+Pzhox9VA81eoYw3jtc2oxVGLDx7+x3P5j7ArSNMxT2TTafInSxq0kevGpxrGtWy55Oty1P12vJcj+dN4XB1sR6cwpJhT4R4yGCXsVfaSRvMoiHoMG4qlHJ2xQK+tRnMIuw32DjCEaFFoyDgXQH+rFRyqtfeYwQHcwp+LsT+MKb5euUyyUlTtTsXujgP+2apVFR9q+JsTGBPfh4TZeA0WL/JzwdJjw4z+EqjbR+PseykaGEEwPhnoYPDIwcJ7O5uOqVoOOgqBcMVxARTG1uRgqCA7NnvwM8bF654gtBoxnBTxdOgEzHfc94FOl5Y2GgkQW1g6QP7m3joeMLgrdy66OnspG2CGM+OdfG2HpSHh22Np49UqFR1o8jhQVUdzJzZLGJp4A+WXZBB7GaJhMrr5ORUw/7Ah2Eqi00ZdGUE2vit0hLHdXrG3G/lobZZYhgWA+cWcpqi84IpSyL1GG9KvB3n6gKJdvvWJ6XjDHFtLhE6xjjkkKlmk6HZdgsiZyYTw4e8IFOcWRCnQ1vmBekFs2fgg0KeSCOErHk1ewOdNzvaPzo2jMpsk5p2MIIin/X3YaMbOA8zaOn2bt5QrgCcEBx88LBMpfNOF6AboCqm25gsEIXTZTGMTgYoBueNTEGT7kzHj+mIAvP1jdceqd89VblM4kVOL927qR1STkoYgM99MHHPIOJwxsZTEbW6l4pMg8sIjjXAO1dejPie4oQTnS416I9UXU30Jzv/TH+m8CX6vuhdfV/2rv4fi1/QC/ETQ15m9M5mOj4+0fHxadC9xpLeaIBdg0h7vQFPxxqOQqcJW9h0cYydqaiBl1frf2dWujZ24OWAwTjMlfSH519qOD0fXeqP7RzqlURHg5t1NbYKlnOkMlTqHCAcSmPli5vamtQ1YQa7mrlaBQ59YnX/9UWXWqsA4WGQzjPJ2JCdn78fuZ5TANeBOAz6PWXqNa0SIVbt1u3b6nRm2n/Y9trC95NSul6qaLNa8WHEc+xctt3ZMfOJR9NaoAdekrKAJCjMTyifJ/OJSVLsgUTU4e+aThWcQoKw+2D/SDFLPXqu7nnp79za1HhcMZkLf07IPkgrIvGYKvWyUpmYihXMNZBXjHR0dKx2mwSYczU2m0Fi5AN75Lkm3QZQLbT5+RTUh0J0pgzQcyauBMnp66tQLFtXOMYHdjzVG2+8ocvmmfYK69DU9YW8J5vIaLQc2nkKyM3r3ublaSVSGSWjaSflxOM5pXNRabBStflYXzn6If3ki1+hT37Nt9pG7qt/5DtUGrU0h306p3vIm/CB5pdDyqxpNHLRmPNgYWLSpaeZS+LlnE7o9fsPrflkrojjlGVi1bre/c73OOD80f6j9YG3UiyT1uH2S/o7t77KnyU96esb/tXf0Cwf17RWsQzOh5FiWs4xGck6rolxBPBuMFwJbkuJNEzfmYr5jLbe+05b1WHDWK6UNJuMlIjVvd+cnlw4DHpuEk24BqO2RhcjVWtbNvhexVcq4YW63ufQDY8Y15Cnmc2ZSEaXDEKyjC/s1kOMFfFgvJkZmo4cc9O4Jou+EpGldm819Mr0XXrw1r7OmyfK5fOqbVXU7nR9mG5sbms0zuniAu5B14YmITg7pVQUQ3SZwOR4PGZiyIWwpJxENBlKmVzObF9coxxlGsNCMafVauRZ8MrObCsHM5PMQ/fHmkxkeMZApAHNsFX6CmkPGZb41TLOYhRYCpp5XLBSzPzDAW4v2ThjjpWma6Y5hT4FEoc8jGOKvtkCIDBn4uDbelBeNruOidl81FC5jiVQQSfHJ27XWSzDHp56BVexkXjHVRbV0M1be66uEDkzuxqOSGIwB80HKwfNch7xhu20icTKiyuTwPh5rAkuHFirTXDtwVEnzEhhP9n2jkoScesz/o1UO2fnZ+q2myYC0JlA1IEiXkZTliCiirlCy8LgyGhso+rRsK88ndrultLZkp4cnujg+MhdGgcNTFWqMxivgYjCTAATZhxPljq/PPeC4GIOBEQ2SwVNKOwJoA+gOmQcIVpqZPE6TFt8SrHpQopwcnKi1189lsp3w+bNoTCa6aB3pNR5RM3LjEbdXS1u7MhNbWxp1nG6kDVZqL5R08O3HhvWKFSKhrWptrCTmrLoYtFQdU4D7RzGbkZd/fbxT+lv1b5IZ4mi/mzsQ/p9iY/qpe6+51LooR4/2l9rJoOsA6wfMgD/3GxyeF0FOCMrCbRsfo9fqVXwf3Vm3hp6vYI5yR49zO7pB3e+xrOy/Gqi35Y71C/NEfpNwkZM23u7nmUCE1I9m7SRC+xluqeQ+IHBAl0wVfTz8TmsxegionKJQOrgLRyLBTLV8pmgRNxW5rkwC7PejhnmInzed7/nnep25jp4dGqYdNDtBw/VLM4paV2cX2o46qlQzqtWqGi1RFYT8ko9ehDGz2hqM5Z5pLML9c87ZhFirHD7VtWSgfe98g4Vi1m1m+jNEFIDOQ2VKBRVLFSci9nvn5twZV1hIqLaZkX5QiBBAOtTRPAMOLCJ7LI1IYxoHIJsch2E3kCD6Cz5MxTgyLbwCKXoAV67uhgfYFt3coI8pu3ZNLpakJRnLwqo1ZQ5M9aNwfXFxgs4FEUTGnYnto4EPhtNpjo5v9D9h4fqDycqRU/1kUhCH733pRonMvqxL//9+pUf/98807Mjl1GNoZn3rB3n2Xbxqh0rk+RgWlqDS7EDm5E5PZ/BLPBozIgAXSYzM7JqO0CyHYp0kIWZzm+/T/+UQzISUXl4qS/8he/T7OShTnI55dJJH5KGf1nPzB7nbMZ0VNgihgQcRj3ob4kwg5kMNAkcC8OVUwveRds2jYF4x3OBWzDKXHc2tXpZZ+22HcpsehCB7DUSmeWgQXY94tlhHZlL2PnGKaZm8MJ4j2ixAh4G8o2GsRWGHCls9ZK2QORQ29mrWcuJzA1nqcvmiSIJ/s7cRQkzYLri4ZBCAl1wIkD4YtwyVYp3LEKWaQimhnkvBUcrjDjQg08m3aAhNhqI5WFQMPDOQwiKxJAMLTRek78o8nlmFAGgc47oQ4frIO7gmczBDBKB7ISu0oEIyajffxAIZ79ijYkEyzIndJcEyROqMTAquVHfVCyKScX47T0oIcTw0uMCA5liOIiF8OAoCwFSA/mPKz18+Kb6o6ESqYRhMOQX5L1d0f2hK1uYjZUXrfoUqzXI5tJwPrBT/TQeUjT4sFG01Q5KZtHHNVtDTWxMxVJFkQGbEYPvoR10OCh5OSHn9Npdx+EUcnn7NUK68RwVUsVs4BkcN40FywtAxQlbjCTsVqenw+NTY+GwpJJEY6WXKhRgWqbVabW86TM8twME863pWKcnx2ttHqa9wQaP78G/20knycsBXMwiSJsYA2uYOelGvWGoev/xgStNrRNggh8j1nkAWCuTmPCUrBeRsxCa2tPF+ZkypZz27txSuVpV9PETa1grxai1VMTSAOMtPPMgoJkKe+woI8oWSAl7OtNv7H9c/3vxgzqJFfSXkx/U1xVLuhEd6+bovosinh0vHmwxnHB4iTGrZs6yv//YBw0hsmiaMilgdjwow+e3pGRdyPAMWFMX2YYel27o/s4rmsTTSi2n+pr+x/WhOB6YELwSyuYRzIfIKP7PeahmlOJGE5IwTJHn/0xwWB/Gz23gSDU4QINGEgsz/gwzStJYnh4IHDzo3YguQ7bDZgvzN8tcU/rAB1925men2dPBoyNpGRyIDp5g7XbhFx9JR0Q4D0EsGev8tOnIJg7vxgbJK8GwHPiXjfInPvDDmtSnjrJyJsm7sVYL7EEY468nY6o+qOuL97/MBzPvWirVMkN2FZ2HWViBQkSGiQkJYE0wbyf6zF7Fi5nfXUt94pDRAuMXhubm1obvBYcRByVyCxyiot1nyDyRhJ48OdRbb+0bNeLnv4FmdSP4715dJsMRgmo3lKCVXdqYPa3FbGX3IWKhYFTjqPLo8ZMQ30anFk3qZuyj7g5/oP5+TZJZ/fMP/DpNeg/07vGpymNE/iG9wmxqrPkQ9xSDDMq6z5AUb+sy57BC1LGFYAiR579RAJ2cnvqA5H17WL+rZraq117+ZT4k7yQX+ob+Aw0XbbXQWSInojsj2gtYDxYrT5hDME64AiHshAHEQ6LGeOzNnRkqBTVMcdYVnQ0jJeNu8TW6M1l3uplrBKRRr2twcrb+2rB9IUatzPvg+a4i2BBmVCgwwwsxZLzTjHIgJsFXYE6KRhaZGgdFKpFzLiXFEnsQ7wka8o2NsmeQbJoZZBUJ2K94ageiHc8vBxJIZBz72DToE8nSpSgjzotmZhXB9GJhlIyghmgcyQnksUCI7HYwxIjbIatcLfjd5z64YgjTsuD/zWdZIwWOgVuxLwd7KM6LcN/TSpSCRzWNFpcdr0zTXudexuGDQPabmCDIu9JqIWHD0H2s+YT9fB1K/XYelDwIHgAu/sZ2Sc+IwohKWp4RT2S1f3DsRGlmMxhxHx2dqN/t650vv2iXEvZ7YC0+MBUlXR30YRYTG441WDFSQIjmIT08SComg6lanb5hpF5/avbpfBFRjE0vsdQSZqFnglDYgVBJlofGXjcUxOYMbEeFwffiBcVLEMiFSpNfjimaYQeW8WGMITCsMwoUHDqWkbii9sYMQcpAw2y+pCpkRykbBrB5w7gyLBRNkAIV4Fr0Qa40IUFgc7UM1aKNsdEnpnTjxp4Pm9PzU6cf4FV4dXEIoFXFsQPSQoTAVRYCySD4IEbinu3C5KzVKQiK1jY96O+rNx1p2WmrMxgqFQ9dLgcBLz1LLBweQCeQV5L6YGqsW4UT/elxRufLuP5B6iXVVmPdqDX0zo2ZilMkJCHxhRkwByUHI2sD8TEsVKLKmJ2ZcbymfpuNyvAfvRovWbagf7r9BeokC7rIh82WzeDXnPy0Xhw+0CSz5a6OlwuGqztHWLL8Ijh7ncoOpIp+kefuxBZeQHyJ1wbM1wfgVIV4MaStL8Lsg5QVOu1s5NrujjkQm4Q9UVMhzBifTg41d47JhcqVpJLxgkb9oprnPSfU87OBOnAoDYcLdVp9jR0KPtHRwalTM3AOubGzq5f/4v/TGzwFxK3xVPnbH9Mw/bzM4vOvT7/S0Hd9888Gz8xVTP/Z9/zBtdwpYmkKAbeL1UgRRNxZ1kvaTEw6EjbT/gDTDYgZMbPCPZOn74tii1e0t65zBNfew/SEz87NuNdoiHl309lc6HASKYcPPHvxjJ9ugp4NhSQYxi2YArBpLiagSJDnxp5525wgStj1wm47Hzj+jDZTUf3lwgfUThb0I7VX9JnRpYr5rj509Pe91niPCRZn80Y2Yl03NmogSy7OmCMGZiRrA9Yjh2IIfwc6neosU9bP3P0ynZe3NcwEi8TyYqTfPL6vl/ML/TwzwWJeW5v1oKnFWQqWJ5Z48RAdxSHFPcvnMj5QObBzWTgDYY8EgQG6DFKKmfehWq1qM5CVk4v4eehEw/3iKpV5fxsutmD1UuwsImMn8MCs5cCP15CN8IzCDJiOi3s7WI6NcgW0K21on2Jv0aWRIAWFnzHoxAvFjPZuNsxiZu9gveSyQOTM85bOi+SZ9HoY4AdrwDEyGI09x2Wcki9mnehkfNXjKcZkC+UKSEnqdsQ6OjxVIlXQ1lZN9+7sqViBpT9VBAkhxunMnC1T4nMsgg55bT1nP1oTcgKhzA3XCM/uqWfu3q/XIQB0jYFpDtoHOzwQfwgQYL5NY8c+zzocj5mnhmSZt/WgZNh/JX9gs1rZRICUAYaucUfvHBycOGSZWSKHDRDjeaalnc2+K5DgRRgSD2Ccsi542ZDTsrghmDDkrdfLrsaZ6cxJqR4tTDUmtYCorUiMVHEMBIBPQ+UTvYITJ+QSRpRPp21mQGdKBUR3wAJHutHr99VzynfY3CA1OJcPcXO0oNF4bg0kbjr4n1qHFQsRWyGHL+mZGPAHUAoG1jivsBlOGapjRMzPh3uG5/ABf6crqVXJQgMmhMQ09+Il821vb0ujMTDIuaFYvDivLiJuGrmKZ2zIYmbjoRMVOBA4mCEpsUkw91zis7pc6cbeLaXzJbWbXX3mU5/RsD106sDO5pZKhYKrVF4oDvdxarzWn6JrLaiigX5v61/oY/f39Y8++M26jKR1mdrWWy99rWK3x/p1H//f3e0Dvx0eHmn5hCEENmdEh8FQ2/bLbJgZqNa+jyHwlUP1h9799d6Ymqm1+9BqpV91+NO6q4G2Fh2tcKkBPrKMJ+n5FgUV6w0tFPqsbgf7L4TwWe3sVAw5MTPm4ORnuzK3vrp44aMJunvufTh4Ycvh/JEm5WN98TxxB7pi8hJbhNYRfeYLL9yTIqwRwmgDiWP/4YkPS6BUfIRz2ZIji0ajoE3Eqzj4LlOk5PVHvuG/0Mf/4MfDvrK+9j7zf/zu8UkGuXN99D2wFIP889Efvq/N12/pV3/X73BnUCwjHyEPdGRIDp/lRw/3/QycHJNDZ8cgfy3hsGwHMtAsSHOyYSzgOddSwRThmVSVV199TfEFeaE76nTxFsa6kSikf70goXsK0UoWMgUYFDSJDXtBVzaxuQTfP3QnKTEq8mx3PtPDhw91bznXH2qc6zS/ob9efL+OMjX/Ov7C36rCuKevf+2faDLKazGZGDGiaEN6BgxrchvxV5Dn4pA7woFKTq4lUtmC/tq7v1GTaEK9KyLXaqWv/Zm/qkoqIsjWn0b7O5loo17T9s62UtGonuwfOJR5BQKFSUQEeJu1jYl8SOchWJ6vZZIUI51J0CRy4ykwKKLNOiZfEZkIOlAaArrh9QSA+R4H6vFxS8vTU21FGlpFJ7YGZT7pwAhm/3NsQOmcQhOTzwdPWIT+JCHxnOFOQLwj5g8pxgsvYEbBfo6RAUSxmGIEzZPYwv6xohgYmTVL15pO5KwoiMcWLggPD450ft52Qg/G9ciEdm82TL7hPUc7n8inHUa9WpChOzMRh64bB6Kgswd1wSI0mH4YLvVn5yDkVqXdVfJ+g7xxiIZwCozuKaqAuonJwi5xaCIoByksW4pbGjiIRayrVCLj93E4ZA9nxIW1KRXc1EUne9bbHNyMPg9P1RPbEW1tVb15gVkfH17Y3oiMMroym2IDu9ClJDP+u2E2h5k3dyRqaISJMO4qnOplBOfumjKu3gyxjMaajUM+JEL/s4uuu5l4ChLEUn0s4YBu14keSzQ3UIE9iyyrWq4oE0+EQ9mLd2IBroW75MJZHM0xvfKAF/NiPF2T6aldOeyURUIILwZzDwfScQAwk5z6ZQebLwEBRxpqnrcNu1gIjrja0GqAPPMZYEpMiieWQcRjNXeDVJe3bu9ZhHtKFBni9e1N3SONZR3dB66fJ9kgOlWumFCUVPZCXqVsxvfQeZiQoPCEvGyG9I1qVbubuzo7benhwwMNu0P12mMNumg4CUouqJhn1htYumg7GXRjz3Z8+qbz6GYXTX3ReVM//+W/yz9HP57VKpHXX/vi//zpuvjw/Z/SzcNPu9B4goUgyfKF4tPqFdink6nqB7/gm9a7fkSLdbJHck6WZURfdv4JvXT5hgqZtFJ2+C/ZqQZvyVR2x04b9okl1Hg4sVPSxUVbqyWsyJlKpbR1g8FGjl/P+7euv+1aBB8gODYEDlcKMoqcq8sWaeuwV9seFui4Kup0enrzjTf9bICiICPwslI8cqhGlDSczXqEXMPMLyTJz/SZr/sZ/dg3f2+Ah6LBYebHv1z6v/2j8D3T04wAjgMlMxyMoR+Xyu2V3ri7diZ/+mGk483HOmns67Nf+LP+un/uJ/6SPtz8Ai0WeKyGnMpsNuGfG4sydMt0yql0yOO0PnQNSXJvDb/ZYAFpQFS90dgH2tVFLua9vR2jIOeXF7we3syHJEQ8c9EhUkBhWs67gTsP+kU2cIoH9gxrmg37Jj0jHY55l7mHwIjoObv+OndrA700O9Nqcl9/J3nbG3EnW/Wv7/6i3/n0e37L4x/VKhMXibDDydwzWrg12FtCuAFt+tTWy/qRrQ89vYFzh3yvlCL4Uyt9zce+VxuTlpbjuU5aS+WzMG2ryvlU4VDIqFKrWBJ10exac8q8E/E/Bx4d+apeNXsdbgUMW4cG5LJKTHGowoIupW5/oNOLSxNhiMrCAtRaWuYH64OSbpk95uzsLJg2QOYppZQzvI7/LZAxAfWklqBtHtgwnHSbZCyzNuFImfnp7jMRcyzWyfG5v+69uxva2q6Zb8EBsxwNXFzSzARfkEgIbxgv1XUodsqHbyJaUPP8ke6/fuBDB8IQCCLckZ3dqqoNDtxAdOJr0SFmczg4bXiP8XrDGEIL76U4izmAAc9WDFtiSUWTOFbxM6+D5JlBYniwlpXRRATnsKjSuaxlOjia0SxQvEbR7y6AaWfWX5sLMptrSPACjdEazq6wZ6Qw03+b5SHM8fBPfe2z9+3Lh5MNPxxMJII6sePi5CaqxskedgDJqFyq2Sar12srm6Y6CJUB/NHpWqdnHRFOCjDa2i21m+c+1IBfGQ5TDSA2JtVaMToBHCsISJ5YS4NQ2KxOpZTIJy2EDg71MW9yLI4ro2ssxEbTnmJ0xHafjzzjHsMcNngo8oJhy0YnzdcyJZ3Dk6ppCvForkI+Y9iKX/z8EHFo7/nsGgdjYKjLRIdxIMFwHU96NpiubmyqUi37nxHWAsWOxl13npVqSTuluvQo3HtCmatDnHKGZgIThF3IZlUtlrSaTdVpXard7Fn2QgFxujpR7KKjfLWqh288sP1TQilDMxfztjqtjkaDsma1igfvDO2xmCKdoNcf+2VWFP/PlMqXB/qav//fe8F98gNfp97mXV0Cla47tp99+Sv869/lqgwulZ2P9Y1v/IA3XiYSdPjpGB0fJK2VIRKIM+NBxUUXVSWykrNTsgaRCNCNJM1wpEoMOXUYS2BjKI0yz3s4UhBRgbLxJNDdLfFhJTAW96HrISV/l3UJXZ4DqNW8VDqdtwzm0YOH2n9wqEZjSysCb+Ok5TQ06IY5JrNkYPP4CCp/SmcvPNGDu6/qh3/H37x+4dbfKrXMaW98yyjF7/t7f0IvT95tyQsTimIJeVHf7jqJITKXr1d+XNCdE2aJCT2s3reD0wrzhVQ45L/1V/x2/X9+/K+ovtjQC6N3efa1u7dp6Uxjo2aBPQbWwFUcYMFJKmwkJj94KwiaO7gGmKq3+3Rbm/76mIAww+I9hjQBEoQzCgXhs5e7KGDuQs78AsNqmCgQQUURsURjCsKTUmyCcw7mJdglRjRHPzqbOtuV2TZaSrx+f+XsQO8/+oQOTk71t176Og0TWXVL17PR77r7tdc/QP0XsQBXK22OLnVreKmv2v9Zm+SDSE1S6Cc7a35FXcVs1pZ4HIQcPttbWz7wEbszf2W8wIFPoRWkPnOnLEXSSRWSBe83MMQhD1FARWf4vJLuQ3HW80ZfXpb9e9y3q92Ywh4JFmQlijYOuXyhZsIaYyIbCmSCxpFnxihpPFyoUd0yTIkFo7WlmKTHVw5buHFjR/uPj42MxKI8+5j3GXJZHUuYjCuXT/tzABnTDcKvYPzUZP+IZRymHFVKWsTUo/AZj0IKE/uFXtLW9o6isbkW2GAuWUeBXIOOF6jbowDGVo7+C9Ur+w8HJXFsuIg5ihDT+/HMOa6sIzSkjPKGw1CUBTRoZfSAYotuGmKdCVV0ndOpXYWYhXPwOw5xHR4NwYv3vlZpeISBm9fbHLMFgYMFvlC7NVCn1VN+O28tGZh6pzMy7MNhQzFMa11v1FUqVq1dA4bkMEEUysYUKO9Lh+6Stxa85rhho+BuT6WdzFrMS0fJrIMFBss1kwPi4+fBqHvmwFBHp9inkge8Uqfd1nQ0UDaVtRTCXChgn3Fg1/qzINrPM1hm9sVmR+WCSz0G5iOLXtlYuXhZgJUMq66w4QsQH18nT3KIcwXTqlUrXsyVCtUsA2f0RSMfYPXGpkrlvGcCUJrLtawPSr7OvIvOK7iLsMionq8uYNXtfFXJVCOkNqSTFi9z1qOpQn+6KpeMzccjSS1Gc00gbkRTKmVLSsfTSkZSqpaqqldrToIhFNmzYkyzl7J3ZLvT12gSbN7ouLGJAhGwV+Zqofd97B+qUq3q4x/+RlfLIAQnhW11s8/PqT7/SkxH2jx5I5AsUil92eHPq4yWh47eFW+wPWPTNSkH0hJJKTO6kKlSuCktMPqGLHVm9hpwIZAeyAHwCTpCyAscliGJ4XnolW4v6FmDjIXZN7NO4HNcmq4uZqjZDMSxQK1HljExMy6mG3t3dP9zDzQanCseyWgxh0mZU2Oj8TTCxzmE8Zw+95GP6q/9tj+tZeyaUcv1xW/+MkVWP6H3XLxf3/OP/qo3Gt6nR/0nZgFWa3lls9vKZPI25IitQlf3kYe/RN/xN/8b1etb+q4v/k4dTg7Vzbf0ids///Rr/55f/i2qTur6M5/4Tr3j4XsdW4dchtkW7F70fc4nXIW5WCCZkQIUfIeXi7gtF1uIw887mqZvPP3abLqXlzj+5GyFd+f2Xe3u7eh0sa7m1hfvCBut79lyvp5zYbpAJxAC2zmsux3eczrlkKYeQgVww2IjS3oGii1coli0YQaHBe/0V/yLv65eLKuP45hjG7KUnmy+qCnJHf8HV2XY1G7/1NpfH773f9yH3Qi/0HWyCB3OVZYikOkqEwhcfCa6RA5uZ2WaxAMqEX52m22sQqJRtlG2jIqtleKbbg+q4ozaudv371kXGYEN3dOT1VLbO1Ut0rRR4WfF4zr45TL+waUpkLLyhYTqVcYMQVuZK/DzMc5Y6PTkXP32VLu728oRgD5Cnwmcjb90TPUGcoqRTk6mal629OZqpRs390zkwogE2JKGBRJMRGHPal/2vRY6rZEiq4H3FkZtmzj7ELk2wXAFrXbf3sSd5tCHInsoM1Dm0oy5jSKS4oRiYLF0hii8EWQxzBC5h2i6Ga14phiPmNGNO8EYExgnZK/zgW2BGownYMZyP3leaEQdATgPZh1m5hueCSMAFxf4TU+Q8eXs+IMHMkXJ23pQZuw4jw9fxlRv2GutVFOlQsWOHY436Q1sJMDdqdZrqtXqFl6fnxz7wMtk4nrhxdva2CDIGMf4wE61RZJlBTP11xUNHR3VGtqos7MLv9R0DlMy/WyICx2WDjWq+JJKhEijqLMTO52YPVwXM+CcqGnhQIPMHfGHdT7cdKZiqeQst7Pzc00nI882OURIQ5nPL9cBvrizQDEOcKqJR46IAuILBtBBFEyWZdzwMexMw67ZfJBfDAL7r1wr2t0+ncWzMqZSFXgSaUzf9GxeQO5L6HqwQgsXLinFfNbwLAxb7lt8bSkVTISDHRod+Lg/MhMSF6PIPKr4KuGDMpfKaatORiEwCtAbwcvBtgvJDrPXloOtia4h0QMzhqiLDBaxEYDx0Pf0Vz78MdVqNc9+PtUq6zDGRrtmFbIwVyF3LizYlXLLqW7uf9IHZaVUVrVesZ6V502n4ySaeNCdOj0Ar8ZEUsvZwmLx3CyYPUB352tCQOGFwLqragP9iAYj5El4SeZ9gPPcnr3oliuZ6jp/LmxUvLjAMM/+2TBfi7pQCbM8BOprxjZs62TOEHa71XTnxQvnTgKXm9nYMpqPf+WP65/9pu997pB836c+rBf336nf+OibFdFPGljlBSYa7eDgWKNhiAWCMVirl1RN5z3WiD2z1uig+fx/4BP/rTWS/UZH//z0R/QTd39Urzde9Z9rpi707e/5I/qD8z+q995/v80ZOCApDoBcbTyxhj9JYbCtXSTmLFQMoy8v+nrr/r6h4OiNQMDjgsGeInaphuFAymHdzLku2887IFFosIavLh8Mc7mbBA7DXpFJ4ZV7C7C1D2/Yq8wUVxSmbPwnyuCak0n7gOx2Ol4/zNYLi5G+5BP/2N1wqZDXwfxSmTqdb8gx9ByU0c0cdjwdy1TFywO9NDw1uYnDC6eeYJYeYEYQC5zHKAApurGn7CLWR3cKWgT8mkr5MKGTy49z/h7Ic3gXgV7R0SJH67bbtpsL44IQpM4exPehe2QWSLcEhBr0v2P107elxnXM1sbGhrq9qXq97jrNiO+dsN+qi3pmugjuM3kV8nM9nhypefHEM/qbN3e0WMK8hb2M6nNlyQ+fkQO3TXjBYKzz86b1kzgKcTAis+PvMOufL/AcPvVaWM4IXibdBpE/BRZB6MUQIECXjEH6aUfNs64am/hO09wwt497pprMheIj+Cqv55KkPK2Dq61hd0MRioikkr5XFFu4O2GLCtJGUQVwi9vtVbKUI3i10NgRfuwjgTRIE2CjFRgwxCba/CFvgiUjBcIq8GnGKP1tPSiD4TbdGrTjpD0DYZvhqoIu7YW7N+0J2mx1QiJ4POSM4UDCD0S8Dw+ahdVsNnRjb0sbmzWnwNsYACd/U3wDe4lTn8E4lPRme2AI9dadmqbLqPqjqbU/GkDUQTIS0gkQ5K6skcSCK+NNEQnEBB/UPqxZhMHOr/Cmw+brhezIorCJbOMzu7NpUTrBwNhBoYPil50h7c0ZUklg88Gu4wHTgTjKKVbC4ctwMVE5dguKLVWuFz0XKJQCUzdfzEgQhEgGn49tflwsFw2BDXpjtedAblu+93RdwAxOoE/F7brf6vX9AqFhhTY+6PHSzdW8aGs4mqm6saV4uqR0MqON2oZZso7T8WcmR68fQl0RT5NjOgkp70ROUUWz2fBZF2gJSTzBZxfhLjDTGMF0RHfu3tbywQM1jl53F8oB6w/vXM6JZ0109wWLj2FYQqii2IDxHAkWXBQxJC+sMLmOmR5OQQJFhC/HS8cByTyIDZ0DNhqZ+Bns7W1qe7eu0ejSsyGqWAhcHAJArc9erWZbpUJ57ScZoNdsNqIY+tJniDV8ZjZxZBIcmONxxwxmNioE5Gyg+/tHrqJLpZpRg5k9bMkZ7OhjX/ZT+uhv+GFNstdzxXe99oq+5cd/n16IvWBNoC+bAgzNEA4evZA0YBgGGG46IWxbyoTEcW+6zDuXuK0Yforp9uqm7j36nfrq8Vfrv/7w79XD3AP/t4PcE33H+/+Uvm3yJ/TK+fvdQdroYXl1T8J7xuejIMXvklnT0eGlTk9aal72td3YMini6nrfK+/Rckw80cLhABiJJBIpnfTXBKP15dikJALvhUlluG/hIwo9nzkRBAqQIjMp6bh6wenKdoeRmCUM4bALYcusfcLffVBaVgbCQqhySPuAJPJK803dKY6VReRPxzIZeQ7Y6fXXWZh89oWy1Yo71+msaRiQZ43VIgdIlHn3ejbNu8jPkM/SiTDHSnrGyMyPRqFSDkbqDj0YkF2b0Ua9qnI+70OMn8NyNnefKXX6Qy0j0zAmYrt3O0p4AOkq6B4J0B4+PShbl00XmhR9yKJIUxkMe9re3fNhwAEJ6kLxF00mTKDjxLi4ONFiDqo30OYW6TIhMJlit8jhnseMvaTzYkEnZ6c2T2HvzCSDDSD3wzp3GwTEtLm9ZXWBFkCnMop4cdFy50ZDYO/6cZh5k337xufeUkT3FIlgndmx/SD3jkBl9g6s6hiRQdCho6SpAWmgYOVgC05eFAVpI0Ay4WslLVAT8AxD0DT7hg3g/VyDlZ6fK91pMsiMbI/psPkgrSNhhJEYiozLi64uLjpqXfT1ZP/47T0omZBC63dO39ppn00XiIQNrOpOKaXt3U2dX7Z0xoZNbppDOXGxoKLBdmqpdnuoYmnoqol9ADin1WpqPBh6wUAI6vbG6rRwfB8ZWtu7cUPlWkO94UydwcizKeZqwBcTyBP+PsCqIV4KujYXFQ9ZdsQZ4UASrOXiKpWT7qa6rZYmw6EFxLBQHUYbj9hkmDgj2LuG+fBMdHZgIFwE7SWehB2dZxN2NQHmyBYyNjGAbk3XMhsyd8JKq6jNnZqlIBbGF5JKpIkjiym1yGqximvUn+nR/UM9uv9En5uWpHe85M/QbQ80KyzFVHbUH+rwyYE7wEw2GwwLEmkTqcDbjw7P1OkN1BnM1BnNNGH+wTNKwR4eqFoq2AWGN5bq3tCOk1YoGHhB4kowz1sET9kQfo1UJ6ZsmjkGGZRVlatFd9FsJGz4/dNL9XBRYqGT9hCPr6t55oYhCJqvQdXNrJaZczKZt5tRLptQsQjpi+4fyHUd1JpBo8q8Ym6XIV50Ohlcc8L8mY0JOA+qeDCJDqxLvDyfd9w4Pb1Uug9RKOdZGwc2ET7RSFKTybPm39dfA+IA3QMdKjAt8pC9vQ1nZ56fNXV2dqpqZalyuWLXkU+++0393G/9J5rl8H6VCuOS/vR3/0Wtugu9c+tdrsLPjo78fUqvf1S//L/7VfrSdRUdWLqBYAMUbfst1tma1LP7iZ9S/x0f0eGXfoM34cGgEwzKS3m9OHxR3/VTf1X9aE+/9ld8g8cTR7kD/dEv+YP6Cz/6l3Sre8vaMwhWtpdDBhIP65pvQofVbnW9zuiQIYZwzzncGEmFg5l5WcKszZDnR3J3RLP889DylSAfYk0EprzF+Gx+C40TCwcIh70L1ACpEixjdIhJG6VzsOZScfuR8qx537gXFOUUW0DFFAkwXJFrRGFqZ7PeZ8zynIQQg1av62g8QgiqBLyXirbC6w9Hfv9tlwbUi8ctsqkMEXIrH2apKJ0luGU05E1COFkHlidX+Dpn/XsQlibTorXUaD8h6uF/jUUi4xsOKZ55IpXTKp7QstXy3slzBRXhEAH5Cuzi6zWIddzl2ZmarUGw4mSvyCQ94ur3OiYKDfoT5kFKZpCYxbW1XcfCxWOZXD7IZwYDcCDmcwj0A7rDP29u1/xuDUdD78l214nEgpMNBS2GCamcpYANYg3jWc9mYbxiCMC7YfvPKN8/Zn1su9XSk8eHyjnbM6NeC8N4MieBUtdHCHrndNx5suT1ggTFc8Eda5VamZhDEc16pOA2ssb9J6R5OLd8ie7R6wVjf0KqAwUszHMpJqHSwpRF9kejg6ORZ54D75N0nPwNmjDC3WHyvs0HJVX93BRn4BqqAroo2IaeS0z6ZnUN+0Mdnxzo9LzltAsuKhUqhQiLIkHmGTT+lI0DWo8O3ZECL+LvnoaKHM0aR2czSqXyunnjlmobDW/EJCO0uljOhdkg1Xe/A9WXcCbw9aDVzOXyphhPmm21e11HQHEoGBb0IhooQ+gtQ2HIOWZgLpUkAmmCj2jElSMu04lExtZOFjo7dDgM8TkogXDwri0UUqrmKv6+UL4JXuZwHY6rancvHTFjqDGaMFRLVaQE2HtcxThFx1znk7ZOzy718MGhpo3rnL/PffZN3dhJO5an22xq0OwayrhstnR62FK90TAUTnV0dHTqedp0ca6TZks9iExaOg0il0moXkOewoyS+QbuPMSNDazJBFphDgD0yTyGKtODcDNGQ/XGZruxtWWRO4SDIK9ZWpOIPsmjYqjva/N0hxZj8K2Vc0U50JwTCjSOBGjUV7lYNLGAQFo6UYJzsXgrp8ru2tHw4QcJtEpQNAck8DPEl+Go60MzTeYoXk3R4IpyFeX19ACMMFcKGXfOuyRqbQKtmY71+s/x+XnZApMaq8PQHeAMNZkOdPvulv87GuHjo6bGk7xa7Yh+rvGT+ke/+38ywYarOqnpR37iX2pQ6Kq76hhNYfzgMQM/D/FEEHXSOdsXhpQS7pKH6cGfcsmhEg78+GyivHMCU+p0mjbGYCNKjAIZJ7csqJ7Z1Pf/5I/pN3zxr1Y32VEn1dFv+9pv1t/8/v9NL6xeDpmgBIXzPGxMHubMcAIsIyErM1UyMSREFl0flMBrzPbYgLDPI5AXb2Pln8/z8/wTdiIs2hiZnQjco67oZznE5113Eq43YVYaclvnkrIBxlPuem7dvGEDhl4HJCpjdjjEJ6LA6CTDiCJsmDCtj05O3XFgl9kDRUKMvoj4z8NrtykAxLVSyQcr4wSi4QjETmZInsj756AAdRQaB8d05tHRiAONkGw2bRtZABPjUpN1N5VOMSqh4Ageoxy87mQnc8Hv5QCaLBba3Np0Fz3s930PkEnQoeLIRWzhMzfRs910cmaG6N17d3Tr1k3DtczvgryuR5SS8uO8Nkobeunlu7pzezu8fCsyU3sufvqDsWfo+VI2jFuY4UdXlm/kJmlbg/IZPJFHPsMBCAoAiTGK2UcyeGRn+Uy3tbVT1cHhsVqtrgo2U4k69vDoIGbbxbfuP9Kdm3sq5qsq5su2YWTd40/d6XWkHkQ9Nomo9va2fc9jMUhHFMsFs7SJzkIxwX7EM2NswPuQLVCEg1bSIwXt5tK2fmEEBtJgD2NMCJwawsEZAqIZpTAmhIjJO8XXnoxQC+jtPShzeU7whHWO9+7dFnF/4wH4eXLNAEO8GdfJOS8eOpuxMsW8DxbDEHg9RlMmiURw80lmDKm++plPW7R75/ZN3dzdMUQ4jc2UGU2VzcwUzdMhFi36/twbb+ox/pXdgSIxKNBF3yQqfb4fRRkvAYuZ+QSViBf9uqTxzMCV1VJjrO9mWePWudxmIPLMRtrb2TJ04iBdiD0pYA4Yk5AqQuXvG08AKQbZLMpOz/ZMdBYcJHatSY/80iTSebk2iC09b6CbRKQ7jySVjhFlxNwFLB9bs3HQpsZTymWv9T0nhyfaH8U026hp1h8pgpsMusn+SN3RQNFV0ukZvU7INgQa4R6Q6s1QHM9LUl8sXLZuLhiVs/HgUEOFzMsdiw8sucFvNzgY0VnONRoOXMGTBABkQrFxfhkywAzbTtewoO9hiMwBPuGw5OvUamVVyiVDMEwZSBjAJIAOE9YzxZZnEDGpDyRMd25T8qBxBUqlyh1BSEH3RUJ6v+Piplza8osEzETFb1MDYDnDUdcX3fFktPDLT+wbzzF0zMxLniH+MFNFXwqkPobdGddWo+GCgmiy49N9VRtZfeEXvaKH9090eTHQW+/9rP7hH//Op/yhzf1d/YWf/h5F0wv7yRaL29ZuAe2BAFxdT7701+lTv+q/dOo60BOwI0kyzJdIS4DWvuxc6uv/28DqZIMMCA4OPw3FYQmaERz3HCeTymm7k9Cf/+m/rD/2Bf+NTgqHWkaX+m1f+1v0l3/6r+qDoy9wccfz4pnzi2R6IC9IHHRco2GwgAN+NstwbeXKoZmOot2jwFgYcq5VN3Q623/uPlsX6Zk+bwu6yaGNRQBYzCyfUhzNnOsJIxStNAUoZQKRbuU8KTybdtIi3aTH/u1A7YxSJJDY7AOf3pzhV3BCmJynp6cajtDWLjUzSgKTM+s1NKIb9I5I9wb0Fzd/wrFnkPvW1nucgY73ctoPo4iJvxachNm6wElgxbZGSGaJUEixqSOV8CeGuIQhRzaj6Wqs3mVTJ+dNDe0zG1OWIg64lCKd+4NUzVrM6zn5bBKMyCu1uj13b9/btZQrkaSAChpjCuxLjEk842RsEfVIjGdHPR668ahJejxjmhreP2cxwiyOw1/FjhMuQdjbrCGOR2zOwDODRASiMcLFiSSOpFTfKCtXTLm4ts48hoFB3OxqRkGX5xcuvvDtxsfVDUepqmw6p9KwrAQHHeMxnKLMOGcEMV4br0BuLJiQOehRqPU1HCD5IFUkomS6oUw1Z4MFimynAzgJB7Y0HXpwvMLIAk4BTF400sw5QUD57+yRdJWMVnhnOJzf1oNyeweHiLK7O1xfJiNM0scOxPXi8wkfVbFIzmRVicRIuVxRiynhnUHnF5lRpeNHSh5hTEfHZ9p/dGb9G/O3rXrDTDleKDbOja2Gq/8xotlW2/6M52eXJuMw34NCTCXI/HK5SGk6GprFStcbGH0hpQOfWbphNhjnDC4XKmRSKucz2mxUXWVy2GKVhCdssNjDgZ+MRTrnEPfDZs3QhJ+dAxH2nlmhi5ma7ZH0KDgTsfh4gUFZnJqxQnSLwz+VOUP8sSbLiTKFukkMzMyQ1dAlYUHFi3Nxdim9uH5xSNfozFVDX8hb7QQVZpLBDpANHwIUInbMxhPR0A1mSwXFCYPWUvWNqrtc5pNsI8yminEOTlhnUeWXVMc8R7SkIy3xlCQqarLUYEgSQs7Ep0Zjw9XbZYuDElefjCrVhl2TlvOBomunJYzX+cVAf1VIq1zKmqQC0/gqygy424clMEos4pekP+opMgzwI6QncWjauYQDGP/HjCF0wo1hCLOpQoEH5uKgZuNwUvvnXeSJPrk80eZmw9E8EKPMdmaj0jPuHOhrYylDjMBzdLqJtLOjlEyT/sJBWlA+UzSU8zcyf0N/77d/99NDcu/1u/pV3/0b1M8MtfyALMoOkVoTLW2Hdy3QR0YBBM0hGllGFaOwUEzlh59R/ef/cSh2uqQchKvw2s/p5gpSCak2webLZg6uqFN67ZWvVW86043sPf2B2bfpf/7iP6uDwmON42P9oS/8A/r2T/8P+sjRF3mmA6xGkQs4F+bvwTS60xpo0A+s1Un+2gcTc/9lPKonT078a2/3XuAtwHZ55oL0xu9Aw4emH6zv11FrC/I+Sabo6+CE5J+eNczBDYiODWg+pVIh50MTKJaiCwJemO2BFhT8zkPcMwEMeUkhp4ePBz4QyYplnAMvIRIn+5H2wyeg9ycTcMYh55E/B8IFq5JCr5jPq0T4cKenwbCvJSMHuxgRcI2Wmtgz7Bnl+Ts/Mw47o3FSlXJBSazVZrPgHsN7Phq7GCAlZUgMFXKLycSMdYoifn4017HlQoPSUFqDSHRP3AcO23Q+baJhpz1TFTSIMjGOb6ss+4AXERhXIV+UmDXcl7jvu4kN7wPM508O+pqUy3YGM0M0nqIh9fzTeax2tmQeGPJKPZrxXHzqNcv+aBs9TFIKKa2ihNvzftPdYX+36T374RuEy7d12bqwXzf3E5SO5iGfzTtwmnlvvztUPlfUisKLgIAoZQRxYhnVq2lp0fKhyztPpi/cjESqrzSJR/WSHaiWS8zfA2+EPcXsY7v4BJ39UymJtdHcJRQTJADhUEVa1ErV+ttsOHDrzrZyBSCCYpAv2GiaziUw8uJxKhVOhqi2NrdUr5M4HlGn2fZByIeZz4dKp+vWAsJ4O9w/1XQKoSCjHBsPcEqMKoOXjKqBeB/c8Oc2IE6kqBBJoYjY/xUGGRKOIAwPmZbLSFRnl5eKkp9XCLMyKhQ6FEsRYsC/MW3WKqrksypmU4qucE+ZOCXbxsdeGHklEkBcc00XgTnIkB/ojsqJ4GXDcjP+PCxRnHsQITN/gMI8d7dEtqMZljE0PEvFkoG2zP2wcTiFqI0IIJeg1drUk8KxOrFrunsqidA2vLQsp9lyrNkEATMQdohFovrHFopD0gbRWJtt1FXeamiynJqVR/L7eEjHArU8bbIG35dNEPiyWiaCp+ikBSpwuggg5/GUgiAw77g38wU6pphTV2DV8Zxx78ChCfNjs/no8JlTrVbqdi40GpVULG6sjczj1nxeza+YL9ENMP+k6p3Ox6GTT4YOHqjfBCGMtAdTnZ93ddnsG27tdYPxOIJ5oHNHClHQPM/lUSZb0PB0pnYTkhYuKXHF0/KMFaTj6vIMj809AvNvHoTwa8JBvlDQcbfjIOVSrqqtzYo+9it/TItEOPxuPXpR3/R9v1P13obydZISgoEBhVR30AnWeZYUXB0+A732+hs6P2spFkmomC/5Hfjln/oJvf+Tf+dfewd3P/vT/vVvun7sW99JNIYPvA9Gv1Df/pnv0B/5wLfqLH2i88ypvn/nH+hDjz8SyGgQlQjYJmYpndbFYmyiRudy5GIM6BAXrquLwnO2iOr4CNE61TowGEbzz/8MISFn7mIUdIG6wOYj9s8NrjLtblenl5eOtMPMI2gtPTNRKha18cS4D9HpVCfnl5rMEKgzh4qtCT4rxVN0Q2ysaeuMD08O1Gq3NRkFWYHtISk0IIatELJjVJK0L2nXgb09dYcDxWGT5nLrn3mlZCRmrTQoDwU96AQHG+8eH4bZXCqdNNKCtIADlmcG6zpZRl6RcEczHHZd3JPtCXkngvGC+R2xp12kbTq9riEKXZteONaqGPx0iTrjfRgP47oknSST9jwXuDeJyUGcsQeQPvNnZvoUYxTdrHHQjIyZuxjpDzoDTUdIYWTiINA57x9hCRTz5NcGX2Y68IXyxYLX7HBABx08lT0jjGDuEfH7udTYox2q/MYWDPTb2n/0RB30lTDRYxRNwMw0H0uNBhN3kE7zGCzU74zsSMb7i8PSLDHXMga0HTXPZDBoa9jtWxtPwX54cOI4OaBgxg8ORI8E8hcyIic6EehM148MEIMB9PcQt4A10PFnYspHQLE27Wj19kKvyA2EuWxfU3cD8iCZD0SFsyQQEx890+qDkS6Lplkt6PycoFlyzwra3thUo1bTm288ULfdDY70ufy6CwXeXWkWiao/6KvXncn+w9Hkms6eVr5QdKUGhk41fUUw4sZQ2UAWgolryQpwTYaAUMwKep6h0dHgunHn1i1hDQl7czrDVb5rTd58DjjI58V0OO+N0s78FuCHTQ5YEZiKF9wMRVic8xBYCtOqXORApzlGjwdsBKmFXMyBMjzceNGHFhAmurEFL1k8pVgmoZu3d9W56GvYvo5+4n4yR0IqU8oV/ZJiFYVgeTQYGLriJcGRx8dwFDp6yoP4d7znnZqsYLkONZuMn5p90wk4SJYNZ0mRg9xmqQKJAeks5bv6g4E/E4uvPxzatYf8x0ikY8cOui8IQSxQfkbYrRQHsQ3mSVMNRl13sFS5oYuM2dyA53zSP9Zw2PNsxq4ka6IG95YqncOFz0IxxqaNFKt5SdLGuY6OjjRBc1isPPV7tX42QrEyc/7osPi8Psrs1GRAIXr9kXrDqbK5NQkgdT2o4POqyMuHzCnce4vqKXoSzKvjwUBiGdV3feAv6aB4DT1u93f1odWHNdsdGw5G7kPwLN0J3alnt9yM9fXON35Km/ufcvflc2Jd0JUmz0surq7XvuTXqPvl36j6RsWdczCqXmnv736Xah/7SReFTINhKFJQvPjGu5R7Z15a7wX/YuOn9E9u/CN97f7XO6/QJvnIgGCS9wY6PDzWYoqcIG5SXWTNwuQyuQmm5XAcWh7MrkcDzT9PJ+pEGDYkCEowayNRTcczXZ4T2ptWMVfUaPjIVoZjW0PydoW6BnNzzDuq1ZL2H+7r/ltvBftC279lTYDpttqKEDCgrOdfvVbL7jcv3bur09Nzz+SwwwtkYZIlVh51QDCjmAWKxFUHEmCLMPpsxpA4vAUkINmNVOhaQTcTMGGDttqyJO8L6HcxFC+7E6fYYAbfGcJ5CAXXFH0fkiHWC76z46GLLmKnKEypkJNrCRQHcDDLuHaSYk9D9sJcHvi6O0SaRCeOP3TI5uRw5qDFxi4EzgetN2xjEC26OMiWoEgmTUUTOnxy7PUP4nNydO4ub2NzUxvbGybZWHJHxukKgln4DMHUI+nnQ+4nhzw8J/TvNOkUxcwB8eomTaReLyq62tGTiHTw+EBDj2wyjtbjvtGFg8aRisP8+vziTO32pTM1t7fqSlCoT2lMEtq9sWsi1PFJc01pg3QIZAv7GHP5MPahWWB0YAvStXkM8+oreZdRQHANZwyz3gK8TCFXqlxzQd6Wg5KQ5E53bHLFRr2sSgn25sjMrXSKKiMcjCTQ46UKywjt1Usv3/YwvtXs+KHU6hvCNardZMY0M8Fjd3fDLCgOOEwIgPkScQwJKOIm6vSb9l8NnqshhZ3Lleg6ioVNzN3VaOShe6mYt6EwnquQh5JZrKWGWkwnKuZw8c87EHc+H2tGcO1ypmS6pk6vad0TFTN/P5Obqz+AOIGFHJVxSKagzXcGGnj+HKIHc5hx6ExhnmXSflhQ7+OjcJgrvlRulNKKyjkL4y+pwXio6XigerXunx9YcGd3S58dXUNuyDEOj55o1BnaMICuDZF03IbSZLMx8E7Y7JqfCxiysdlQkfzBNX0cUwLmQZFVMVhkwVSd9L1B4lOKZpJ0ifPzC/9zBlJSAvLHygxYDkrP9CzZ6KnZ6XgWwzOAEeiqO5HQZmNDezd2vPD7w56rRTZVZko8O7xP6dbQcUFGMhxuxjEHOHMIhvolzRfIB0KaCzMPujzIXUeHJ+582BBg+tKVFfKVcOCvJnZ3YrOcZ64rdN/DydT5kGEms/AL0thgUy5rsLyGXnm2HOpU5MDgjnJirjcbaELAOFKZSEzfs/vd+usv/RXNiB5ZSS9cvqw/+rPfrnQjq+kciJa/M9YyGjNkK2WslUwD9ZHhORkrO+4pxSbz1G4vMF9BQ7jmGKDTQfF785kG5YYeYuBdaejGzR1LJpoXLdUyAT6CIBJJ5Wz2wZfgcPt//YPv0Tf/hq9XP91TJ9nR//jhP6nNyaZ+SfNLwixuEdIdjo9OfdAkYwVT9vu9Cw0a1/Z0bEh9yEPA5ehwRe5f0Ac/e1mwDxFmNnamIPKHYWdq+UAmXXQ3n0lSYCcVGY6D33MS9mfMLHh+ASHaIg4nrWzO77DNq+e8//hNZywlo91pN9EEDlw0bm0wFshpxYyLYhrSFsK9KG44E7Uumuq22HfCDJzP4iBpCGfE5nGw04HAEiUpZDpxeAJITYoN36kvESM8rKfdnR0XTRBr6GDZ8wowi+NR5eIZxTI5dYYTTS/aPjzZnG3GwvcmdLlYVtHQPD7L11sxBbm9Y3MY1cP2nNtN68HDx4pEE7p5Y6Gt7S3lSsSqBcmMDTXWJDDIhgRc824WCmWlKJRKUSXPL3Xw5EipeNr+xRy8EAdv3LypG7dvKFOAKLN0fmUyDb0nmAfM0TnDhk/GtFobmUejcCqAL4PHKnPV6WTAZNioEHv6sNe1JpR9AuSPNZnJsb6CYQL3kO6bA66WLjr1CXIfaJLlHcuVahsVpXJ5OwEFY8dg1MDsH8id4p9CdDId+j1lH2SNUGxYbwo8soy4oAQdAJJm7+MzTCZEhyXf3oPy4aMji5Hx/BsPBorebihFdu2Qh4M2Cu8+mKDLNUQIRBHTzc0t7exsmYUF9BhRQm88fmQ6Md1jvVbQSy/eUiaNvytuHD2LWqPrr4kInk6KGwULDd2T5x9r/Yy9V8lLwy6vkFc0mwk6yjQ4fspJI7AogUmYhEB0AaZstlt64e6ec836Yxz7C8oUk+qPe571mWUFq835aNCooWGHxAD+AHE7MKjsaMJAeR1u3J2Plel0/KAZKHs21R+baZbNQ1iJK9mZqFwPrDwo+hMqcxwmInETNKjQIKto7dIVDI8L3tSAjAwjI5COxs0QbKMNumy5m6vWKi469u7eVBwIazpRrdrw10M7BnORyyQWtGp043QAKxYnzMy5O/bFkiQMuu25Tk5PdOxEEDRnwYnfhy3ZhiSdY35NEGqCmCYYihAtEipW2RCxtQqIgP03I5gnAz9hDjExM8+Eqjwz35wH9HTXi2VCzVbTBChYltSEdDBUjplkxjrQYR/G80jjYs4FFmoHZBBBGfK812u73VJ1uRnSTnAfwmlFpdAF9J/5s3Z3CnR6Z2UCNa0lUXTqGN8DjUXz0XBIcgQuMvpbP/p9GsfGgqeIDy+pCRQeUNBrnqEzJFkpmUnr0ff8hO7+5l+iz37hN+iHP/xrdXx05hklnw1E4qte+wF91es/qL//LX9ByZffp42zh/qiP/PN9mB9/PBYn3vtvr7gIx/0Rs37dCWF4VnlmKlZ5xv19+Rn+yt/42/rm37X1/nPTOITjRfBrJ73lu+JjV+/DyoQfGun0ZCQYber9WXGrP9M1HMxuh0yAD8/pMhrk2fIprogwDpwA0CNLk6b/nlv7d3SyPVFzLIkipxMMqFKsaxSEbvLgYlMQIMcesR0cSCwjjhPSMHhqJ6yXwz6mmWAEyNKpNIukO2KM0ZG1jPrFYkFn2uFE9Vo7FkxVbgTbVATMM5J4gGaModgQnE2Has76hvZwn6tPZs6aIG5IsxxOkN+7nQK84ykuyYsJvOlglbxmE4vmjq7bKvbR/ca9ipGGjwb+7d6XIX0BDF+GF893ZT5rMww+eyLYPBOEgYowcS67gtFYxnVIwUlssx4cbJZR85huZcMY6LecKg0QcjM5vIZ7dzcdSE8GZBuklC5WFOz1dXHf+FVnV/29M53v0PlWkGLWcjv5GCDhLhYH/LZNCS5EJsHUgTyYLeieCykGaWIRxx6TVQrRd25e8PIAR0tgiHMTGhNYe+CTkFAdDxiLqd7L95VqVJUu3Wqar1sU4tkNqHlaOGxVyNb9VwYe006SngjSMc4D5hfUcyE9hG5S1TRRdSOQxR9jBDGAw73qOF9ELJ8Ka2krQT1Ngc3n3fVaQPdsTnMtHejrmq2HPDzKdV9W80LOghO/rlyeSqdvKsi2FosIggx6H9OT48tJ2Bwe+Pmhja2SGhoaTTu6+T41C/Txsa2K8vgfhGG+k4fcPUdkg+4rl5UQyCLmdls00lqLR0Z6a23Huqi1fZDgs6N0B2903g2Uhy4YUICeNJwFu4VzAsxtMatDvx0MgyOERAmfCiaERqy6EjeppvEjP0qVojNimoY+IZ5DIG3nknOl0rMqMwJBx6r1Rqo3B6ZQZnPcXix6YQsOw4mTL8VcpsDZGE6P3AH7FSG51ltbm+qvrnhtAVeaBhct+/d1e7NXaVzaY34nBP8GC/dBUJWchL6hLzDiasr3IOYQTydk6zQgMEAJOyU4mXmwF7CXpnH8IuODLN3M4zNfyGZAYcgSCVsYXTSPRvQ5/JFTSYwfoPGEiLTldsN5DAy9fLFnF128Jqki6Qix60KUTP+j8tlzAw57nkqBTGK2VHaKSXlUt2dIlAiP5eH986oe35IycuVWY3DrMmPCugcxAIW9LXEwQWEk3KYbaMDxE3ErCy/9LxsB4tD7VceP/07X/jkl6jTuww2YCRITIcaTzCDLngD5uDFu5SvzQtNl8zFvPbmzS3Debhdcd8RTVdOAhNvZ2dX82pDkydv+d/xuX0YBT7jOX5M/8l/QvpLYJyvF4rXIwxBV9+WakjZWFYfOP6QPr79C/5jn6p/Qu8//5DSC1iuPNugj8EEfNgLLGdvDs9kekJmmc4DJAYqFKwoJ8p8HnEKr9bpdKysTaoTWkRWumx37LLEpsp9xaP4Ns0VzM0WMPNyPUviIEzqsn8eUkcIR7DWl+czU4ZulveEGXM64Q4u5F6GmDyQEdYPCTwHh0fq9keaEvuE9y+xgF7xYdOwfpI1VsgbcYHlSfeJ5zDvOneUTbnZCnwHiGcw8EFrGElUSnnvOXSDIF8gHNVa1fPORDqjw7NzZ15S4NvUexKMTjjJgIMHo6HUXNi/GCnNpPTC03sIUsWoBCiVjoi9A9nddMxhuFSr2bcOvVTNK7ni0IWtSnQZ8/AFt8qsWhiz8WSIT+O9rVQrevd73m2t9ngwdUCCFsjhljo9BBp/pFt391TbKqlUpnteKZUjFYXIsJE/NwUTkjDfCG+REfwAjOhlyL2NgxZN/Kw3tmu2HgSFjKfq1h9fXnZN1OLr4EoFNwLbT9Ye7/R4nFQyHUhJFHt2+iJGDO7FMqnRNG7EEkJfaFzSRhs4f5jPOpaLZiQR0cwB81pLUOLqtEmsAhHEAS2r+WwQZDZv50E5JTYokDmDBGACJIAGhx9yqP1Hp2peoDVkuB3V3i7+nyFIk3nSeDowjAX+jF0SxBUoxbdub2q5GikanavZPLc2r1bZUjaD5+nA1R0tetB/hRsGCcU6M9ufQSwKmwItNdsjXRYzUl4ywnTZpOmWTPnGOSMTU6VWVq1R1nAk5UoJu/hz+ABzIKheTdn0ihoM0PW0zG6l22IzBlqlc2J+FpnIKeHEvQReFUPjmRlwsXTcNHgOfHvVkp6wGhnGZMKeyWNksFQhj9mwzAQ72D9Z+5leQ4feYDE+IF0jFRxbWAxU67i6sLmw0GAhN7ttlcdVTfC/jUnj5dSQWWDRwaAbazhhXgk7L2LHfjZEqOp8PaBbmH2rbvDh5OCnG4RugU0gO298CXuMOSyHe4jGcbeqMJvlsEc3BWkj7/nKSt0e3p7BPxeyzc27e7p9Z9dmA/jO0rlj3wbxK+q5FXl5WYusJ7OlJiOcN2bqdwcusBps1vX6OgAYFm/U4udBDz9gJDfPb+Dct0k7mJcncmjUUkHEvg76fbrOMRuYTQKawKHqjZj5KZ1GIHK8WXtT/3DnHz79O//9J/+UBdNo1Hie3E/E3DyvTCroZ9kQIM0A1Q8Ga3edRMwpPOVSXskY3TeRcxFtvRGGg4l4WgdHTfXfeqJfhmNLq69mYhgKiol0fHShmzd2/dm4tne31Y+xeQTROPCoZ0qLqH7Xz/we/Rff+C3+c//f932PfsPZb1apk9TlOQHQfSMwrNnIcmi5QKlU1ahee86K7snBvqVd1WpRjUZF8WREycW/nhCPBGTB5oiwf+3lyhphgwId6I4ufVh4/judWno1Ay4dDOzFPJ1j55fQAME6ZReIBSMGLOVyEPZkRxlg0lu3bjuYvNfvGdFCG7m/f2hYHzOCiP1FZaJfdM1kd0SYN3xkAgUfvH02t+XKB7fnWdmUWZ+OZwP8jQavYNY2BXi9QnHf99qFOc56jSfKdqDpu6gnXivwKDh1GX1ASLQMxBaPkOjmGkU4mKXuRlgTXAjuLxaEKxANhwMP1oItFzXzZVytZlfpzKXtMDkkQG9gMEPeAZqku6Z4YnSCZzUm5JMFY6K53XaSsawevrmv1sU66YS5X3+qy/OOiTbphwkVKkltbBd054Wt4E1NMUGhDExNAebOmI6NPNygpaezS+UgBwWJC4dnNVlxIQbblL17/+AwdMb4di8XNi954d4dpSG9LOdGYpgpgqyFUUxGsWQYp/D7vH8ctp/5zKu6dfuGbjDHJCYuE+R85gL4UXJIUsFAMGOcEbWjFjaUFOyw/gnxeNZu8W05KFlowe4NKBApATBE2rKHbmdqSjndYkgfR/uCUW3alRMvK6xUKn20lqW1+HV3lzkaeDV/BsZSTMVyScVK1eYFvbNTW5NdVQn2OQVScjI2o6/gKwoJggrGmWVUKJWKPSFZjDyA1bLjzZMOEClBMpM0o80dULqo/hArq4miM0gDWC0R1QWDDeccxOd0wjxYGK5BXI8rCqxa/zzMBngmiPXRWTPD9MYaBuJAPhw6E3SLWHXR1JzJJAM2teiy6DQWEkAuz9qGnvmeVxd0+GKhbGgoyEECru/OpHkZsh61MpzcHnZ9OOYredU26yb1MIulswHioFtIzVKGNxHc8lI5eiaZdKRUvw+lnRnz0BsPkDFVbXD7p3LlnmA8AByc07DfVW+CZnSsXheoCtekjHq9sYlV2WyAmSBedLsXrtSZoTkWDUsqniNQUYJ/oDMN9nMcwEmE0LCHIR7lU143owFmAySelHR+RnF24WdNhunWbl2JRFGRZFwzzASeuYAZ2Wy9YceA9gNsSF7pCEhofV0lxQB5wbtwVxYNmYkcAO1MW9/90v/y3NfmkFmOV8rm8kZUrO9j42eTInwaGDKkeHsOb0KHv1fQf0L4YVVPZn2ljRqEnx1E4uT8XKPz1rVxB9VwCv1gkA2ZJMVOK2ljs6JCKuOujg/HiAEUh2fnzL9nrj/1yn+nv/Az3+3iChjbwcSrkJs6ngxcxGhvR1oX3JeXFxaClyp1vxuwKTEUyOv5mKKQRoL0ZaLFhLVP+LqrH7+/SI965LYy64aIxpyKe4YVpQN1SfKgEyIJYqapqf8BSL+KwxsgKldS8VRKtUbDJLxsr6uTszOb0ncGXTsDrdg4VwtlUrjFYPCfUK8LSkW6BuQX4NawmXrmSVrJauWDac5ohQKHOCmbSJCvOzAJJ7ax4X3As81leM7cOwpMPEeRnnAomB8wXa7h0Kybi2DIgX2dnpLgWItOD1lfHCID+x9DICS1CZ1j0BUDY2KPiT914ZDorRvKLoFDQ1i0ORQ4CQ3HOjtrKpfJaZUPMz+uQHThEKUzxyCftRgiCCEHzSdLZ1GenPZ0dBh1aEPe6TxJxdCXE6M+n607b8wWAmnLz25KE4KhCN643M6gTojPgzd3OpdSqVLQwzefOCgDE4rNzVtOUWK8ARcilSFXdyx4kz5wF5MQzox95IiCOK3dnV1HkD188Fjj4Ui379xUroDReZCRzadEDwbJTIgwi1mGBcKADR++5VnsCXOEaNff5o5yMnUFDnxZLpW8caOLga6cz1C1YEGGIBwiQ4Dn+HBUX1RR9ubLxhQ/XzlGqFTOaXevYQil3cErdWXoIp2iCouq1Wl5RmUN5CLQ820+zstib9AgkA2MOViKYUhua0AYavx7PLBv2WiBHziMqSJza3ox0JEi+BGmTDd3hZSMaWtnU4sZJIe5yTW9ellnZ5fuloMVFF1yPBhF47ifTKsyo4KC6BAo2jysi/NLNalQcfehojW7c6HYNETgXJyFIOdZYaUlXeeMZIOIEoiKn8lI9GcidHrS9+yBjtLg2hhSz8IyEQ5CSEJHZ8d6fPpEL7zzRb2vmDUzmeeFNR/uKuj6HP3VBbYaeIGaIr6kQ+2Zau4NPBpVp9ny14TaDTTm6n7FAZawp+qtW7dsi3dyfKRHDx543oADUiFf0nwKHIZJAMJlutSx7/MYiUyCmR+w9FDpCPcveE3CWnUMWzJoHM1Qi0dUyOTUHwLnp/TiS3cMzbcuOjo/P1P7AhePpGEVql02OwLXTyPPW1Mhfsbzkp8BeQqEDNJeOKyjhmrXG70Pr0Bl5+UPSRs4FrHuJurlevpY8WNP//yf/ak/r+kl3TkSNO4lGYEhcssdIrFHC2BHXJCmdomKrzMcKRZgV1PR837Zho1idK21bHdb6g+WhFT539nMsUcjwefWzW1tbpYdKE7nyDUatxTNJrVZr4cM1mggd9Cx3e2/qN//yT+o//mVP+8/+y/qP+VDkneUjZxw3eUqEcK8I1NtblV1Ucg+PSgRydtyLA5tP8By89XUxc1zGwqMePSZ6Nyww1uztnl3kFDQXbR7A43nkIE4CCByyfPWTDZn0o3JPUmeTd/oEaJ1UCx+UFI45pyc60OBTdl5qhhVIHXJQURJ2iuY+R9dVaVQ9s9BBimHPIQxCmvmipj0h0OCrxvReDpTzIUWZMKY4hng7YX9YuEKkD3Lc0UbCYLFvM2h9rG559Gtfk+1Rt1mAY3+SOk0XWAIUA5NBPtHMLYwnG/XqthzhgOeOcfhODACWKlUrmhnZ+HwZTyo2QB4py6bF+oPyqqsQsHOugZJgEdwcvzYyTT1WsM+zkDMEJJ67a5Oj85d3FewoVwubdPXavF5+iqXgY+L6o9XWk7HGvWXiivjcYo7/Xjc5geY17O3U2yzVzDfdgFg1QOmD3OtbFTAaAufZGkWX2hnb9MENA56pHAbm3XviZATV4uxuRfY67GOAHt4pzOJSCDuzKZOE0pDhMoX3BhgI8n33NndNgRuMpNHc+ACIEFhVIZZCJ0ls09m3ZCO4rGU8oXS23tQ4knIYQbpBmNn224BV1ApmLWGkwvtVEJFKN71mv0TrypMD9vxR8yntLlTdaUWidF1zXzQRGNpQ5CTwkodIlswHKayW/DhoC7bYNW2c5A+HAKNCUAMY2SkDhEvfA7z5RQGK3Y4C9WrRS21beEv1Rmw0TveeU+Nzao35RBaC+0/EV60POkfUXXbQy8O4GGEz4Nux50A3RV/zk4RKdi1zDapJpm9hQfUB67td4IkYzZfbzKBrRvg20BfPnhwqN2NDY0LRS1HS12eddU87arXDvTnq8vfj3sL1R4o2vmJCLgJD06rWKpoupyrfdTWebep0WKi6H5CmUJG7868yzBVOrLyPdnO562XAs4Fkuk0e+uQY1iaaJyAxpeGaeuxqn1rg26WrjShXKGkSr1mwfqg2/X9wLDhva+8z2xG/pmZilM1pjBil174hWJajc0S30WJNFl4OGPgHQtjl4pz5jXFSxcID/SUHAB8bqCelTY36louYq4KkRHs7e0axhn1yeqc6OyEPM+iUtmkOqnnA4VhZ1cTFevuplNmI6xlOp2EUs9oG1mnHHJU/HSebAhUpaagJyACXYcZc20PdkPYrRNwQRMo6pK2HnNKgnVtFFFR5YrEgUW16Ab5R+Mf/6+q/+Dffso7ugprjq4ZBr/iO3+LvpJ/WJNq7tzZ1Zf/sg8rV8L2DKE95JOxA8G5YOaS8MEgzoLrKEgB7xn61qUK3efj0OjaQFBqDTbHsoul+ZSEl7TqVeRg110oeYaJ5VLlat2s5lhibjkFz+XZiztJJ4R20hdmC/2R9YTj2VQrE3OApvuGRlnTBWaWd+5YAM8MF/cYW8BdXAZf1EhMc2tNgu2e0yEwlxgNdXRC3BMoSDuY2RfIh61o1e4qlckaOcGCjXcOE3MOEtjgsFPLuOQkEg6lxlqEEQ8FBvIr3m2TfdaB38HPtabNas2FObmVPvicu8s4JKXhGGvDU81WURtzvPjCizq/pKBrajJu2VDBcdFr8h9dPOscUlATItv6GgwmKkbiGkbWbHvIJ/m8bty+aa9a/Gt5JxVF0wyqECR5lpg4GWmq8XCmYW+i5rKr5TTAo8PlTKcHRy5es8mMbfFu3b5pA4jPfe6hTs+a7jJpQPJRjMxzmjM6Gcy1SiwdeM+4OIqmchlXJhGM6cMSDZ003W80TjsZCl46YN4ZCnJm8dGNml5+xz1/5o36puoNRivsd5B3MG8JFoC8J54lRyiwejY6JxABVNLz6HRa25tbRkNMPIP05PcVU5f1P/vwXhcy5HjmMNngRcPQnj2aOS9OWdfZpv/BB+W73nHP7SttPWnphkrwzVubUlPlIoIFM79775Zu3mj4hgG3OKnDEUFYejF7XNpwwHX3IqpspuLNGeE60GixRCxQwnj5eEalPFcXt5ApQZ0JNRoNz6fQPrKJAK+ACUOGuEr44GAhHnpzs669W3vqkGQRWWhvd1O7OxtOweAm0ulS6fMwufnpZSZocNbzMiDnG7e2XY0idu32w4vOnJKDEBgaSBPgJHhmDoIeac0AxJYJJ4gYeKuFsXSbuNbMHVCLYHvUHeqo1dT9z72l/fvHNkdPbK5teUz7H2g0ZrGwMc48t2X2Ab7OZ0A3SDxZu98x+w0B8NnlhSKvf84DfGDv4TimcrmgWC7vDTxXyGsGUSceYFa8Gy2bKOeDoDyeVKNRM/zBfM1kIhiisZhOz8716muvGorjrYeIc+/ePd25fdubZLfZValEpz5RvowMYz3PysQ9R4RJd9U5UuTwGcYjDpa4iy8OJQb6lIiYSkAOAfrhAH18cKiLs5Y2GoTUhk2BSDDg6lanr8TRmWO8WunnD0pYylDQkfwAYReLIbuSnMbJ5Fp0jJdkMhWkKVyWhwDDOo09rjeKbzz9s7u9PVVSODtV1jZwwQieNTVfQczCng3hM9o5IEii4OKaxhJq3nppzX6E2UjxFdaLDcCbp0o2zzTavqUlaxqmbkSqveNFJd55w25HGGBH4mQ4MhsOB+lyFbSn+JUSpovG1GxKzMtnc0XOkyr3a2rnL/3nP1d6TbvlW8rmCq6sKToWk6Vq5Yxnx4vhNapBIXpjd0elStX64/mSYm9i8fazF2uLy91eGvapnNxzdtk0iW08RNwOpLbSoN9xvin+vV5jfBIgzNHIcCRdQ/cUP1bcnNjs14YDnnME6PYQstr5uddGgbFNPqedrW1FYglv2pCoMCgBdenCH5iMNZ8mlS6XzGVIRmMORSA4AclAmF+G2RUFHHAkQBA5kJv1hskqSFLYm/iMkxlGKJB8AiyZSue1//iJ4fo7d16wXIXNnQOSA3lpT5OwR7Fesjbzj+vhM/zhs/OWEuNguo6GEe14rV5VY3vL8Ofx2ZneePN1r1+KfC7GWyDEOF4jq7Fj2KSl3mxkhCqTGKvfa3sPiyzjipSjurGXV66QVbWBjA4yHl1psLmLJrI2KYEh/Oj+QxsbYNSCfCeOgYMwIV86ng1mPYV1MENIu1qyrGWxcEEa/Irxk2W/jWl7p+FnjbMY3BUcl6Icqjhf4exlrWnIDA5wOYqJrgqZsv+d/QAnMoqpWqXuURbwMNpO9g5QCxP7+Ps0QIo4FhDVAKMlindm2sx9QUl+uV5+Oy3syJBkwwcCZX6HFGToYTDVarEQ4nVwhr91c0uZDOLkloXtDN+d6j0NAtbUetFSSSLEZyZ2dHhqUgFzFzYbsiKLpbpu3UrbhJdhLocf80GkDpVK3QSWFd3RbGIdFASNgMpErZkETsKRJV8paScSQo+hts/mA83GI1PYM9EgIEaDA+tz3myFWWkpr3mGDZxWP6Lbd4CGkmq1EY8n7V07HE2f5qjhSzhy7FfQjtmf1PmYREqRjxjYnCxodJAUGFVYYuDnvYHOj850vH/sZHmCf3mxrjcfutCJltFgNAAcwYuGsTq/P+4NNGVhsVGTTWl28FI9TBsGfW/wpCdw321kHo9ro9rQ5QQbOiznIFRQ7DA/Lgo/eeatVLs+WCBhod2EFm4d5UBHR4ee07DBkb2HEB14mvkw8g2+F90i3U+pnFKhnFEyQ1ca0XAy8KwqEmMzwoyBFzu9zpBbukuNJYEAOaTRRSU17E11cXFhBi/mAVww8ZiJhPBcbMgmZgtThV/Gn4deS/mMqgW8fYH1YDtiCM1nx1DieqBvM/dSSc3mhc2sIRXA6KWQmqzG+rav/8NP/+zv+vTv1sblppaxYHjgqCjP+uZ+VpxRCeY+6/nS1bxkkCvpx/6rP2eiQiFPCgsuLeGgzKYyuvX3vkvbf+f/rVd/75/WYHPPVbnZfziNLJjrIfjm2V9p80JXh7sPdnFXbOUgg0FCEeKLXh59RF+y+yv0A1/4t52Z+l9+4e/QD5z/ywCssYaHHWeX1mqI1Fda9a/t9tDK5iB+2SN4rATkJRe613+Gy+kYJpNA4sLbNeo1CCzPHjAcLwxxBpgcGzY0sEk9efLEDjI5C+mRIoTZ2GJ+rEF/ZDLJAhYtz3k8dZqGdbysXUwF8jmVsOVLpLRRrXltYo6RhyEd5x2XBmRFDro2ayD2r5tOubPESAFTc7vuMC83whRTBqiekYkt5TA8IMIvzFSDWQJdZ0KxyVLJaSCxHRyeqtm6UD5f1p3bAeVKMhM3eYtntvB+iBE7wnvOfODmkJMaLtCYGUz6NBINfKaB1/HPT6rcqCqei+qicxL8tLNp27ixt3jmmoibZHR+cqGLs6bSiZxyyaKGybHDuNuXAyMguGjRneLfyr66uV22O85ywf5e8F7P/Lbbbarfaam+Wfe+cbZ/4nXHAW97PzckCUXmES2nQQJFeg0HJX++Nx3YnAUeAdIcNLaeyccgPk7VH3RUAylaBaIlKGRkiZSMvQAXtLSW2YWag6YmGhr1SJE9jGezD2IKTSBtil6ashCjx3vNCM4MfgwX4mjD0/blJn6NtcvI4uLi+Zi4/+CDkpY8lYL5CBFi4VgrXDWwa1vFV365FEEkmzMrL55aqRDLm7FGB4ITRCGb153bt8wuzWSxLZuYdXd81NKT/SN3KCQi8DJub2/r1s0XnUt5xUa1bICwW5xRojFDfZ7fwTJ1okBYzKE6XQTIE9weazMG0au5+r1miBmyiXF0fbMhekRdGSHep43iJrsgwDi5O7AmtN4IhtYTZoyLoOOhUh+NSDo5d2fN4U21bUN0KOXRiZlWbERAOXw2dEfRZFa721u+J5NRVzHCXelG4klXwc8EWriSo/VkHoJrBk4izMyAm+r1hm7evKHT5qWO2measblj3bWam0yFPpQOx3Zj0ZWOjo/t5lP6MBBV2TOGk+GpZwDkv+F4RNVGVXmVCtLvTc3UHZH5STGyDEnwK7slpbzk0L6Nho8t72Fzymfxv8xL8bJyhaWK6wgtXsx0dKWRzQt4SiEqB5spDlD2ffSnFBa8cMDFkeTKJKHT0wsfAqwHkyDWUBwMaqj8nhOu+JlDpNCzV61WUDkLUxmdHy4puABl7U2cHF0flMBvthJeaxpD8s3azGJ8nTHJxecGqqabdabenE00hMRGE3RHkCaYK6ZdzcJc5sdixsUsk00WyJjZe7FQtJAaYgisaa5b3/9XNcsQrBy6jZC9x0YQhP6B9b1U4f5n/d+zaToDNKsUVsFxZziEGY0xCJsuEPU1SYyLn8mpGwNCu8dKs0bx6o+EIPXr9x99GuMTxhxh7uluNvJ5ByUJ9EgagGWjCUPZtkVjLc1nYZOKEJKcthcrVH8Y0pcX514JW426ijmeb4DtmKfDNvaskmJhPnO6SZooPIhlhApQIOKRjN0l0J81iMEakz2CTRoEhs0dORskOIwCAA2jtbqfD1peEj7cQ5MSEiPxJJCAbDe3ZqMC+/GMmDkapsQzuD80hA/xEP0nXRXs7Cf7B+sMV7TBCRPQfCj6Z8nZtxSo1yOm/PV9BHqEfAaGDrR7fHKmy35be3d3lcgDay91686u9z38kZm7m1S4WvprkeF7cnRmQht2gAC+0/Fco/7EBvzRaMps/MtmW9l8CCRYLuKaF4PBubtwoEtIe2m6x5wdpUa9iVpnQSPOwdhfDNzxliHjYPo/XhjKp8BGSjWPzJ03HArBgPKBGIEywtjloEIxMBxlrPOkyLLUiaE5xva8f9GYCvm8jc3Hg4nJcCSWoLP3eG1tOuO8VWvaw/iLWToHOns1KA5fkr2Q7hTXqXI5b5e2LB7cb6+FXd6bhrsPTn/cZDYqwfFljKMOOjvg04nlIMhGcNgBJvjMpz6n+28+1It372mjsWn8v1Co6vS4qfPztg6e0E2OXRF4k2OuszzVfBpXfr24giA3ZMIBZ0ITpmLFu3ExHXtmZsILLi7LqXZ3K2FDBEpJ5g2lMssgFQSfQuArp2h4dhjXwtZGSCSC2S6QAi9prVpTrlBwlzqfX5ogQVQQLv7pBAbdM7tmwL7igOYhwLxjQ2QTpyOzRhGPVQv2V66Ui/mMiUwwFDmU67Wqoi9EVUpXnEbwRuR6ZvHzH/4mJdYOLlYzrFm/rjJTKRMYmA9039tzYUL5yqK5SKd1WKno+/oZxcehQx0saprH5yo/hEULjLGpceoFKcVAIGzGlLm2hHPHsHCUzSITgpy9mEtzjXdCFWyN4ZW8f61xZaPCbowDBuJEaphQ8iCh+EnwYOWZWO9lWCvMbJxEvtYfeSbbDJFTfinJx5zONVrecYEUH4S5yCR3R5Ob0/WGEp41Lw2Q2DD95dL/8pue3sO/tHqXUqOk4meM+sPnCNZhS/Xn17DXbBYJB0u6IBQm41HfBtBsHunV876QdoVKxJzWzuHEuwASQmdLgQECQYMV6PBBm2kLskrV7xOFGUxJWx/6wFpDqOv/3fwXP6h/l4vNFT9MDiSLrOF+LvHRJF4M5mrXRdvVxf2m+MAdCwSB54WJAAVl3EXxNarxbafv9TuQOAsG9hRtPqhjS+mtH3/6576j/ZLyU4quEB5A8TJI3dboxWA7GSzHAovd0WJmrjPTDlFsFGlOqXeeYFSzHZyUYAyHtcDaMtLgGVQgxDhD0QVEyDBE4jdtzLSohSxLYFlrZjcCC/0qYxUTAHcc6DALkA+JDwh6VJNC1lD4FflmdSXV2gyITsilDQEKvOueld0J6UT8/JDkLA3bWmq5sd7IKXJ9aDDCCUjW9NZM/eT1+87BkE2H9cln7w47WnYXSmQTKlQL1jaiNiCOkDXn8IX1hsDXw3UHSVahUFG1VPN7znMAmcmk8ur1Q1B2z39upukYo4CuRfkcmK1Rx1pInjPoWiSyMDGILo5UD0ZOx4doXZeWd4yZY85GiiQi2tnbtsQjToakUQVmzslw6JFchDbXkXKoJ6jIQtBEmKVHPMeG5xACKThvAkkSKHwxYT6JX3PbBjDAqfBBHFoguuBcmDPjXW0HtTDu46CmGUqkk4Z9y+WS37lWq6OtrX/7fPLf6aDEVBfLIxZDsZyzBRipEVTSveGZnVZYRFSnGBOXyxnj+A/fPNTB43N1m0NNdubqdxF9pwyL9Lp0KxysxKTwgXh5eWEZvkutTteVGnMxyzLwasUdBWZmVB7EDhJxTQawaoNhN38GuR/yCuAD9H7lYk5959LhEEKANIdBgCZhebHILajt9OwHeXHZtrgbAgtpE7fv3NDWZs3aS7q4y/Ox2b9UadH5UsVs0bDxBOu0dUBq2ODpKBLaaOwYzz89PfHwHcp1MY9OL6Zer6VBr6dcKm3YqVYlvWBoScfV1are/Lc/IBDIzyNwMTc1ABk8IsIVI6dz/R99paToM36Hz4+c/jVz8afXLy6dJlzsMM+2yP++V3T9Aa84JpyX12TBz7u2pYch+Jrr/tXf+7c4cew/vFT2rVP75N66QbhsVrNFP3gLr0XWTy8s7XJpm6I7zHYNrXv+FEtqNub5x5WIZZXMcjDwl1YmiCBb8iw2wSyNFB4stgBBVzr9xm/R6Nf+Ns/d0Vyy0bmI8AHB32MDpeIOdl502E6SwRPXAeZAWMghsPKKh3R4yHBmJV7fANbp5XlP6WReyXhay3gQwieTEVXyNb87V9dnJut4sH9dNim1UHmG63qC+8wVK/y7rZe34/rFJ+2G69+4jv7Pv7J2Kor5IKGYwqQjmeWwiXhfKtdLnouC7oVig0M6hLCDzNCkUGyzZ6fjHaVSjEM4JLNaFTGKb5pTQkfabXY07CxtQsJNY++2Xpe9cD5TIs3amxtqxpiDURSzYRcRWung4NIyuc2tmkdbBMe/75V3WwYymXTMFmZ0wdrn8MX1ieSS8CbBaYl5thnmmuTOYjgPgYlA6JAzzDsRRnb8naT63YmtQYG6ieirb2yad9DrznX//oFOjs+0Ua9pe3vDyOJiMvY4iaSWOBFd8749aSESfX4c33/wcnpwf9+zuBgvfjquYqSgEyKvZouQkzcYGQ6kwcgzzxotdHp0pkdvPVG32XclwwAYUwLmUe0m3nyR4OvKDEZBKwRVmofMxQFKN4YtVDaTNX0Zppvz7YCsKjDQpBSVEoNnjMmpbKIre6lW61VXdaPpWK1m00w89ExseKGCX3negQSCBHsOPvQ9s9HS8A55bEfYiyUiKlVzQWi9WQ208HHU8VXcfCDTWqGis/Gpooj4E8EPFpcWFsHWVs3Vz9FhXp/+9Cd0enagfO6OarUth0STSJ6KJRwx1e+2lYhSLf57vmX/8fr3vhKzsQ4ODrToHygSue9Z+517W6o1skoUmbtiOh/irbjoQIAgmWUBQdHKODllMjXJDIQBiIguCucgJAcQxIoVGL/M09HbLrXCuCLCxhc63BVkIEgLo5GmMGgRW65t5JjzIcHJFothLhvPKZHLajmbWnhesI8m0ouk+o5ugxGJBybzeKQx1ycCmxcMyPOTpl2pTAqCmb2gg8Bf+f9Cp8f/H13lUkGVFLrT4FGLa1O/N9LJyYWijFGywJQpLWIYlIfxg/NWp8j0wgiK0TH+2oUMTlHj9RogOzN0tVg3wgaGTZqIwNqfq3nRFKTu4Yh59VTDCdA6zmsTNxrAmrMr+0fIfY4LW+nivG1uAAcTxiH7j050W3EVymV1xi17CYOkwEB2GDlpS445w+5+zXK3YoLOP8T0BVLmQtMFMXRzj9joOkF25pOVzRf4Ted2lstm57/66kO99tmH7n4fZU91+2ZHmxtVj1u2VAv3BmSImDpIiiBez7hPvT3QKzOuXMHCfTP7YrAbO86INHsJcXUqZRwYSJG5SzqR1Iv37qparrgq2trYcpLHgwcHGg4ntjCD9Qo0RBZfFD0TFGQPtKmCg4s9FG7IKPPJyAN/8G/MvEelSQgxXYcyY5DLQY1nYKFUMj4OFMkcZBUJwZ4sEmaETiQgeJkDcjZVZIHwP6p6uap2pK/obsL2cDglz1YTGySveh0lszlt7+6pfd5XDLFuGmJPCBZFLE8o6ZX1FJZMbKDJOF6oMGSlWjVv5ipaUliKtXpNlVJRrfNLjQdDz2GJoFr+u1bE//H6D77eu/+zyh2/roFJWD2zBHv9S7348g3dvLWlRA6zhesrzEUCNT24z/ByLw17MpOG+AGbuNvuaz4NOZJUwIwHqJ7tKoXI3Tz4sOZt3WYBeOj8QEUwpWauBmnChg2JEHEFdAR0ZXMPiGm5jGOZ6FCBmjJLbPKIo6MbiCjqwOpnPwDh6zON+xca9vtOU9nYqVm3t5yHLNb/eP2ff7FvMb9jnMJAKJXN6fKs5yzeBCHnBeQoURdHk2Eo8jmgKNScERqJuVhjPsyYinUKOS0RYy6XVLmErnRh96rVPKrOqG/iz8nxpU1CQPXGs6VDrdFNzxZTu5zR5cFEgsgY9MHAvUslFlENj/HxjSmbT+rCDOeudvY2FE2vVFFU1XJVq2RaPSRlrGFmn+yXTjMiOk1aMVfHqH+NxCFfWs5mwbAe+0E7aTHfJWmkYfSDOTkSkfEsxAViKoBMB/iZr4e/Hk5s3CPOCByl0F13O/BOlppjdPKLuH7R2zGpENb/8AAnA/XayBWI5EEkvzKbyfJ/MGG8CvvwWqO6feuG7t65q3arY2z80aN9PXjwyAnd9QUuM0szJgM9PghvmVHwG7gwVMolh6KOx3ENei0tl9i9RYx5g1czo2Nz4uszWyxXsiYTMehFjE/lgik6mDUVBekeZpQuIZUk7brP3HM6Xmkxnqlcr7gCatQy2tquKZKOarKYGIJgoUA7z5fj6nenGs96Wpg9G4wDLEzG9HeJ0cLAHo7AWPE4Vf1M1Wpe1corrtpDMcA8MeKNk8MTxiXJ9a3zjmdAV9fdR59UbtQNJCWbOUetFcwVMW2Pq1DCaQL3CkhKDK7ZPKNmNrpKY09kUSN8Hk9tXEwlB2GHlw/LPKQEV102LwOzFc8P13pyNmG0XMx0efH4mixUXgheSs+A0HMh5aUD8kwE0gbuCOToJdTYqJoQhTsTL4i/DrOftWMOwmjM3SFTAScyl2AWTQfPz0gVWanWTQtnDt4ftFUq0Z1xmEBHD7ZZwPCdSlM/tPUDT+/h13/216t/NtHlRduHBgnnfG02hJ9Jr30211pJOjJo98BZ7XZHnXZFndJA0Qk34xlzAku9gL4CjGnSQgQyRNprE+IM7iuYP/M4Q94qs6mQB8mcjo3NRtx2TOH7BlY4GxHvAut8jgYRcoStDNGEFjw7otvgHfNM056mfE0OXkTWcuZodVr07IesWObvzupcX/zMaFKxacx14tq92QiYTiSmdLbwnAj+63JPlM+SupMLsUV2+5mrN+vo++5+79M/99WHX62NYcMuRoEQErN5PbAbs9pms6MOpJh1HB+epOlkOiQ9sAlm8D4OpDxkLhQc5JFubODiFezN+LMwx/lfYGbmUIxMSAxp93o2DYClTe4qT8uSm/W+4s/niCtceULqEP9uR621hzPPaDRB0N9Wvz80ihacDgMLk/fAqUGQCNEWr8llTZJMIHdFY/ZddtgxbNv+wDChWc/2bGafW0td+ImiUR1nqnorE+ZlEJ7wsbXhBXNavEohRilioxBUBtkkoetwHyCYRVSOB8QOnxKi00AbaFy4p6xnnlXz4kRaxH0/MXpnPjn0z91xBCDrA9cfvHXZO2FOQwpcMEPGBs4yoYD6cW/ZL/ye8zPOI2q2gGszNqKYzPZ1ftnU9l7dHBb2GjdRGZKKllrNgkub31uiBychHpA5vt8nEzDjWvEO0GHyjBBFEc4clQplQqCRDhKnF8YW9Rr67rZmk4hmkZkNYy4vulqW8xr0T20RCsENjspk7ImzJoPh23tQBveFYIWVRMgM0y+aUiFTVCYeXOWZ+zH/S8Pmg801HCpfLKta2/DiR1rx6PG+ev2h42LS2bGrVyi76NlYGCxe2nT+FyYa7jeQDdD0EEfFw0ozp1FcnVZLvWjU2qjpbKhSOWONJ0ww9Jr4rzJ75EACHsVOjI4Y3JwXDbZiZLbUfDhTpxkipzj6l9OpiuWslsux0kn8RmteLGyw6VhSo/lIx6cneu3V1zQdTLW3c1M3b9xWJBIEwEAgQYqSVa4IjRoResQbOoLo4Ju4cJfNCdM6wyljqXSOAOtsMOXuXVfz73nwc9ppPfHXYdMD+q5uFFVeFpUpJbW3vauNrapt+HKFEH8TTyc000wxIBwOI/TJUMI7Q12S4rCKqVKo6mB1po++9XH7PMKKQ+yMYTqDf6o6Dk3uJTA2TD2789ChkJE5HOng4NCMU2/4a4IO6yOyjJjJWazktFiNlC8l9e7Si3pv7UWVahgZM+EgEw4C1WJtJDDRfu/UbL3oOGbT/a16w4Snjx1+RkcX57qTf1mlTEnt4bln4y/cuGXWHUxoCgiG86nURB/f/Jh+6CN/6Ok9/E0nr+jJ46bePHgiJJL1jao2t+oaLqJPD0qeGbMbvGRxqYlF0trebmhjY9Pm8ZHU2gBhfVi6+EokLC7Z+p/+uwDLmqAUC+bz2MZBXILe71xS4uCj+vhv/P2aEApMBwjFFEaojR2CCxBVv630lmwEaMJIqkh7wwbG5UWEeRkgVrSmwecyv0QknlSGYnJddEKswM0JiGI0DJmgVxcbN8bUFHWMJDhk7RDUH60DAq4P1W/KvqG9jbL2buyaQYi7Evrdk8Wxvu9rr+/zr/+Xdb3/+L1+v+LIBpYxHT+50MHpuY4Pm3pw/1DHl03N3QnH7BpVr9RMEkzEEpYXpYcJzcZjBzfDedjd3tS7yi/pTvGmWaZsnMP+QAMcfiYT20KiocV8/a0nh2oPhuoj9VrgExvSRthI+V/cjZjX5S39SKiQy/h/gSS54YxB2MuanYEe7B/p7LLlzTvqGRmuVvjcNowGEO/EjLlaqXju/OR4344zHKhbW1uqVavex4hDg+THHscxg4wOtInvwwEOy/Wn9cLTg/Lk7Fyp6SBI3QhjxoaPwtFwPfZssGh5x9PqrWu36QTkrOf3CLMBipT8OuqPd5nRz6B75IaC9KdGo+r1ahRjCWEJ563o0+AJn4H8sm/qygc639O2oc4CDmcCBZulF3GIZAOHQDA/XSyDFWG2FQ6iy3zL+zp+tOxTHIQxYg7HgSDKFzTZDV0o7wD2meYlsnaD2UowAwlschjZtgY0QzmE2jfqdRXyJ7o46/jvoKo4O22bhZxKRnV60jbTfHdvJ3APpitdnjXf3oOSWR504dEETVNCiUjS7fr+/oFhVhZLvpANnrCkipMdx4dbLQzr4KI/W1d+zGNIBKFirNYaqmBuPT1Zm58HVholMZTi5Vqgz0G7u7WlND6GMJ9aPbXaIVvOKQZZUg1KTjWgNQe3bx61XdEzR8RDM0UHDG14OnYlw+EEHLUczdU9a3n+M+mNlCtnFVsuLKwuFVJK5lIWTTMbGiih08NTHR4dqNdvWwQ9nffV7pwGdtkq0MapnhqNsoqImlOptTTEbuZeTNDLicCplEpKJVJqX154htVpEs3TUiR27UGI3g9ZRSQeOh4nrxfyYXZbTmmGcH48NDkI5x4CZ4nsokNxJ+noo5CAgeUYhzfOGjBS927u6vjJqUrFqpYwPlt9HR/isTvwn4chxsYQbK5a6vZ7LmgCJEOliWwo5WdKMUEBgMcnUUEkpLMRTme8YHQB6BGB6QnMTrnbXCIvsMkyCSEDdwKRaFqHRyc6PD7RZD7W3t6O/VOR7lzYtqvntATg9Wy2ZEnEdBpRLknIM/cbxt3zrB1IXp1uJzx3UaUHTW8he51FubXd0IvVW17HHFyT0VCNjZq7A1szJp+HaSDWsHEWYTf/xA/8ooBK6O7R3/St7kJYu9NlMAzApSVpI/HAovQvUAegLVJTKB4TCd8fxhV0aI5Csu0eUqlssA/jgEykvfkQqcbhx8GfTOSkatRBvlcX32M87PnAh3XNeIWDGrYpG+az/rBU8pgOsDmy+a4WUWcJxj7PcMA6YUuaEoab2VTRxzmJo9szhGfGMweWY7HKDkHmeTCiKRcK6iLoJyg6kVQmk/cB2rpoB5P8St7LmKK224HFS7cU+Ax4E9PRA61BhGGmBnwZvIxZoxAOF+5mMTyIzzFsoFvj8AoMVw6Efrev4+MTd4J0nJifQI6iG6I4OT8/D93gSpaOdS7b6yYC8sm6U3S3DnphP0MjXyBuDlkHueCZpZF1JKwDZd59dbW6XaVnMOeDDzPPHkN9a4oTMpp3ed5UvVF3KtJijFZ7povLllYLCDmBDczhDcpEGEy2XrUyACN0SGQuSPAvnvH+QQ5jjODFFPTMLvgi1qrGVqEYQ2dqNyFR3IEEwTbGXSvnz9k7Jnpwqug44vEb71cz3lPREYEY1GBaAOFyGmwGkYLxdSHJ8fX8bOgYo1rOY7a9c3OAEYkle2G8ceVbG49nfNagf0+m8mbLVitlHcTONCJ8Y7pUfzFStz3Qzu6mRuOuLi96KhUxrkGhMLB+/209KJFLtFqXAWogPzBXNAxwdnqhchm3k6QNzdkoCW21YDcL7XylXh+R78J0ZKCzbp8k6oghmAePHjsBYG9vTydHhxr2ej7cwN9hKOWzCQ0jC0Vs7hxVAVimmPDCQHc5F7+/tI7z9p093b17UxubNXv7kVSBITKLctQbqrdaqloqyAAMrEEc7zHsHU817AzWrLGECvhdoiGbTexoD96VTafcun/u1c/p/ufeUCoS04c+/IryqTCPojovl4v+GSF4FMpF5Qt5axlxPcEt4rU3Hujo6DikoERiqlbqymdS9hzFf5aXu9tpafvGtprz6w0tU0gqhwk0hy0m2zmIShXt3NhSPBPRZfdCmVlKhUrVsVqL0UixVNzQKxsDGwEVGJAJhupYeFBZ93sdtZt9H0QkEsDSLBXw8S0a46doyeWA4OL2KMVWkCBbNjomyXwONvHY2q+TQoB1MI/N/YKVyiUbUIxGQDN9QzWeQdiwOAQ9M3OYRyElhBDdx/v7KuTqthu7uEAXCvogF0CQxk6OLjSbpX2oZTJxDYYTjdt9Q8AYHgBR3rq9q0XieQ9S4tpaLWjldJ27hoGBOEdX2LJko+8XK3ueK3P4D7r4hy48V+Sa9mf6rn/wv+o//zXf7H//9g/8Cd35sXv64sUH/O/Hr3yZ/tU3/tc6Pb1UIpa0mB63JroPaPxf8bf/uGoHrzuZxN1EIruG4ZExBJvD5fqwYQPioMrMEW6TExlIQiAxbA7WeaLjnUwddA2pgQ4HPSv3lntlCYIhRXgAUf2zvR/W977w19enZETf9j98pwaNqba3tvTyu+5qFYVsxEEZsWvJYHDdUfJeUAzjnUyMHM8y6EefD74NRu1ryBOYHtkJhdQ6bxEkgoM9my+4U6fzokvhYOq2O9re2PS7z9qywXc04SL95OhU/WFb2QLQ3coSgMV0DUlG6bQ59JbrzTupdDzmbpLC3BKwdQYkB6Oj3uyMk/W/UwCQ5RqsJpPqTTE+IdYtoWqhpGqdojXiZBHMuNmY+Voc5C7qDfEG8hbvsH2LVxBW0FAHUxL2hb3t7bX1Jq4z8RBOvAqytaGuIUCKvCVGLtxj9jx3bsC/c9UaFe+7+KVieA5hB/0rzx9/aj4/hgXog+F0AHta74kfdaWqt15/qJ2NepCm4fIFOYwmoD+0bWZjs7AORZhoaWdz/l9ckSnclIjRPUt32EtIiSGNJ465DHRovLULwf92sTTJB0Iazl2FYk/FUsH31PIYdLHwOuYL5/8yS8QfmzVO0TCaTjw+Q5eOLIVu0wk+47nj+zjgadAYb3DgRmNjRVbpdafOs8fwJRSSPG/OJUY6HJ78+2qAwQwxY3p7D0oMf4HXYFQhsSApAnpvo8FJjeYmZcboeNI33EaKtj0mETPDEsV023OFMJey5sj+ihOdX56rkMtra3NTbc8nYaAOzWIl6Rs512I2thkyN4dNbLOB7VXUcUbVRtkH5eZ2TZV60W5A/WFPi3mI+5kgWyFNgblCHwZuwl7OwA5kpHVbyDFgJ84cIDtFSpJcaDPdYIloTgKKNWFzG0K/5z3vsudjrVjSdDT2wU5aQsjJg8EYxF4YkDNTBBI6PbnU0dG5Dp7QEQ1NiHrrjX3rOvO5pDY3a3rfe17W7s1tjfoDFcdZQ29cu7e2dWeCvRQuExhJp5QuZByXhfctByfuHPb3tJ/szBt0Lp8125Gukhc2/OeIZ7+jXjg4Br2x0rHw51g0bIA8Aua8HJLWL659bBHJB20cszTcYjjwYb9hMB+8Ygno5Vkyo0KATXfH7Bakgc5gPJwqm42bIr4E9mGjck5hVOVqRRubm9Yx0vkxo7y8uHCW5s7Whm7d2vUGyUbFXG0VTdubl8+KQXqI97qw0Xjm5vOpFmwuHCxsGFwcXs1WS/n6xtOXpYzkqcaGxcY2V7maNVyGIB7xu3/G1bVf6iQ2scC82enoBv++WKqziCmSq2nOfSpAmU/bXDpTKxu+o+skpzKQLMJcM5gQ8JLn/PLyPenTYnRHiKWt5Qv9KgfTdBKINvxdXvrT03O12m3Dhp4Lx1Oe9xrdgAFOMRMbaTTvaxa7tqUrRXK6+75QpDLPbHfPzZCMxyl4GU1cd4ubm5uODbu4vFzr+4JG0R3Jc1fUsCu5jO4oQWZgPDqariRFcVbKupNE98a+cvjk0AHM6AeHvZGN4WEjVso4BMEAD9rO8WShyaLvg5NZOx0RnSAIEz8PM1wkELPFSIu1TpZnFJJigrOR5364P0EKnM2Vz5IUVLBBgeeVMbTPVUWdpckBlXSnSnfVZi4LsWStzWTvcpSY48LYzYhpm3mOSxEBq5KfkwMzmI9EQ/HU7T71rMWxCNOBKR6964t9E7QG1MmkmWbbeyyFOEUmEDBd5UXqMiRlLGGBjk1QWczQhmZ9j/uLqXLJrLWO3sM7HXdSzPVJEeLdBUWjIKOZGI4HXjs49NC6pnMhN5JrMhn5fbeXNkhcZGXWLNp5nLnmBErHMSwJOl5IlPgbc2ifHF16X2TGDBKUytK3c2gBEQfbOe5Vb9z3zzIeTmwwMj5t6+TJuba2t1UoFf21MXkBzaCPaQ67axMOPKXb1o2y9rDFhCAJx47nwegBa08OYLTx3C9WRLlQCZmcb+dBiddqJsXBh0A4qjILPVsmI8kehmcXLQ2fDJTKxISFNpUvD9uuCYqp2+17nvXkyYk9Yz0aXlPwwPCNm1eqHjSP8eXcaGhnc8tmxHhKUikYA58M7aZQKmdVruVNhsHKrVjJqljJWBw+nY9MZgj0/CuhcvBXxNWmNewoizWSBdB4hU4D3g3xJLry3CMXwz5rqdmEFyCqwbir1Xymu3du+GUExuUg92aEb2k6LHyLjDH0Nq4OnDjR4eG5u51+lziqmWdwJCkRnkqI9GKOtlTqDbqqVHd9DwoIIIMlp27euaG9CakMOJUUQ7eBO9JyrGUszCPohn2g+f849CKajYHpVp5r+mCio4sBcSy9SC2KTiQ87wHHR9rCTKJSLWk0nLoYAoJzjBAbfD6veq1uH9FlJKIsHYvjcYBqZNNnDmuKFGAU3JS4N9Cx8QehQubrdlrBcowmg6qWDoPar1Ip6QMffJ8ePzwyUebsdKZ6o+TsT9teRVOeQXNQWnqTxiszpWx+07PF4+PjkPRBlT5+3rycLNBkPGP7NwokDJozmNfl4tI6CpD5ermS0Wg0DH6jhFhbgL9OqbHB//MA60d3f07vaN7yP1sqZWIa1e9M3U4/MMHrRcOfPvAgQfUHwRqPfFR3YBGjLatVeOAOIo6HWSQMb4hFzLUcOMEseLqwFyuFK/ZudNN4dtpNCUIW9ivMnRwpFrrCpi71yWdST/x543M1tkoqllMajGAjhnBsJ9hzmDxDXDK8brJFxEUhhReH6mT5vLCSztOoiiHPYE7ADwKFPyZkYX37o+Ive3Z+4e6U4oetADME5AfY5dVKZDtmvJ54T4EpV9GliXnM4Hz4OY6OLRcLw/E6aYSZ1lq7B2cCogdz2ywh1UMf3FeHFL7UdFGO6rOLF+5dfIaUtrfzRk3sBUzyB7P0CQb0RPLRyQaym003MC7w+IF7M1XBkWJLDcchDo/iEhSBP+tUnPUoJBDZVuYEzNPXrQ2SiFBr87nosoL3Mj8b+xXvN0XI6fGZQ8+5x2jYIap12xPdunXX3dtk2lWtXnYhdHhwrLfeeksJ3nnMWvjZGDXRibMfLAmFZnYYDFHowJkF05hkMlkrEChOvXbpplOI+cOscs7Mml9xyDbsBWiJmcsTIsDBN9X5Wcs+yhi/sOaWM/dD6zCBpe+LSVlTTGOAS0FiOEdi5k/gGEQoA3pO9PUUPOGKrQsViE2Xfqdu3LzhmTx778GTQ7+LFCuFPByRgtcZ9nzNJhr2t/mgTKap1BY6ODzzjKdQrnkhHJ6c6ejoZN3NLA1bRezwAWHjylwY3c8kmELb2HjdKrFRmA0WJBvRBdBf3mL8GzvbKmaxeOq4u2GGwqbV6WFz1wszjnTWbEwWCpyI4binCK4z5aIyuZTnMZlExsSjOWGq0InpVCDTsDiYCzCIhgCTXSd2YzGXxvgd3Q0LRFrCYCThOQL1P65CPqUY4tshHGBo3LT9jAWIKqI6i7tDoErjIUI6ujg914SMxCVkAkgcCSXyLHAYoORmhrkqm2KSzM5V7ulBmS3mlZ8Ww0YZi2i+mluGUkjntIgzc2M+E+ZTQM3uloFVBshV0E/FNeZAJneRr7GQJkNSyIG2gEuBocMmz0Fm+7NFIB0A5bFZM6PkpSkL79e0o6OmdsPBhgrHpJBgP5pCygpCYX6fmXaOwGnkC3QV6wzPUZ+DFI/YnqtNxO3pbE4bjZL2H+3bcJ9D8V3vflGVCjOQqUOcX3r59jpAfOXUAQc/52Hk3tLOTi0wDgtUzM+/AIQ+k/QyNzwV2J/EIaWrJenV9cFhh5Opv++gjzflzFAPon0b2wP/TEv62offoH9yJwQ3/8X3f6d+/WvfsF7OS5s1O/tS2McNQsrD2ungynGHQ3zVYp5kzMisaQePj6be8NiAmV8WyoXgNBRBbsQhMbTGmHUPdFopVTXsz7T/5LEP28ydwvrr8NkD6SEepyNY6CD1RN97728+vR+/+hO/zkYc+SICb4LHu8GZB8LbmkFsBvTT9z+YfrORMlqgezcs90zX6Xu4Pizo6ErJlPK5lAbtiYulZT6iW7f2RA1zeHxqjsJVDqPTHtZQMazNhcN7EybvsQnCEQCSplthnUEisXtMBISCvMRwWJklCnQHyjNbWLxfymc9X5yPYb8Hk3MadL4+/9Kjqxv0VC4WbKrOfJX7BySbR+KVXqk3GBpi5BDxnHVOJxXmnxCo2Nd4dqVizlAzDFx8dimm6WRhlTsRAzKPi+n1IYs8CLb0M/eQKSCHNiMlEJ2FWeWMUQinHyseZebMfY94HAK4UypXza4m0ACmdjJV9mF548aezeXPTj9potF73/Vuj2IockgLuWx2rZnkfQZApkjHTWyzEUh0dNBRWMOZrNIJHg4OSoFdbTaqme5B0hQc1YIzEeuWtcCfBe5snre9rvgzJMRMJ0Ub12D3SHMCAgWpifgw+AT8Papvo0f9c3uCYzATPIQXRlD4vKlU3rF+0wRoCyHbUcPO+RzB2iPHcE1heztKjjlvzL7c81hMnTZF2vPhCf/BB+VowiYwcnXYH890cHqqJ0+O9PDRk4DZJ6h4Flp0u+rjl6mYIbAQTBpSujk8SP04v2haH8SCDgGgMS1jQBkjRQtZ1So1zwyQmMwnE41jK8N6bFh0ELC/gBWRbLDQeYFhqcaS6yFyMq5iheTyiJPjSUTozGam4NuYDVZmlKSIjGKY8JIDqKiDd50WT4XiCosZwcpByGyuqSwOQMxcAuNxtoppgBi3Pwiekom0oURYXdQCeOCSUpLiUENUPp9oRtgpRsyptMajnrPjCIGucqhnkvamZfNEG3d1tXsjHbabhnzqtbILB3exdDtASEA0a+Ex/papGAxhDIf7ns1iAh/mVZAx4oY85+OlSUTxdVc5IONzGfEihBYPa5VUjEAmYDNduroerPF+ug02S6rQIFOAKRe1kTiwJhso8B3/DRIPxEuKg3y+6MOYwXyv31K703LCCV0zbDsa8VQiojpQ+lZDN/Y2NJn2PPPO5REcM9fEgHym0STqwgyiEAdmpbRl2jq+u73kdWI8V6mQU3xBNRkq52I5rY3NspZ4+15dkcDonc8JHSeoGR9fnGqoRPFcjUvtub7i4a94elBykeIQNvuoGc8XF8fKZguq1esmipHZGY9Vn5qX8/8zi7F/uCFUOhSeBczBkAvohITx2GMFuhEOEBiqs+XEmyTEJJ57NkNhWTYBhY6CIjFECwVj6fk8WBEC0z57/advfVOQXFRy4TBaMG+DVLSON1oTip7eGjfTIdvPs0P/imtmU/rry7Z2ZCyufZktao9jDp60ZhN4EzvHy3PkPmRmxgJzEWPy5HqNxvMqVUpCNM0GaoKQ53xhNqYrTR27yFrWUc2X3cXxe7Mse1Eg1uSJ1CoStQeCk9BqQZG8CDaLsZh6QwrBkWYT9HcjjSclC/4z65EBa4Xvl87k7M1crlR1dHruLp7jAZQFNri7H8H0zvm9Gw5GhhTh0gXDfswp5jZcpwP1z7qWyDCWQEh/dbHGYxBm8Nul/7iy/eNQvZJ7MBNNhni6OOhIFp9W9LdTS6wy2Zhu39lWrVbV2em5D09GKcDKvJOMf5hvnpw2NRhh65lULBHVdNY0Z6JaLnocReBEHH1kKumig8MLZG8+IfOX7NfAqme/vloz7BmgacEikpQQDjdsCnm3Jn7uu/0NRW5tKVLOe64LQ5bsXNArvK1532YTtPQD6yTZYxP4xi45uGMqFHFJG6p/0TLxB1a6Z5M0PzEiBCHrJSwlS6U4eEPgNEUkXXl3MHKTwL1/Ww/K/mjiChvpBZXRebPpX6RaG51fsWEvzHSEwf7k+Mw3D50PkBQttskruXwYrJKa4Qc28AFAR8lBgQcrByyesbMRYb9pV1sermfjquXKyhZSSucDxLmi6isUTG6hMpnM+DnHXvSrGFmIKac7LKNBzmAoplh0UDPkIw7V7qBnXJzFAswADHbZHihJOHUy74flF4sDEupzlJd3qeFsrP5k6PuRTeVMn8ZwHIhiGBu48sfoqcCmm88qGYmpmMkqEU+7SMhnkc4UlS+mVapkVShl/fLhgtEfXVfqr33uLbW7B+7wcPy/d3fLEhyy/eja4+mo2YEwXUms5WujkSI4F3arcwOjzKkCCYq5JFFeK8KeFxEd7p8oHgsROakUs6eBIbFef+SFRsU8G4zUabfVG4w8WAeq4rkwo+IFBeYCykHyAe1/Zc/NcGBaVB+JmNB1dHihszPp8eMjtdvMa7va2N5UKpPXi+UdLRZj3by1Y7YpqQOLJR66K/um0u0Fv0xmIRN3GgQIG/JhE8rijDO2Mfsw83yleOvOlkaPiQVqK1dMa3OjpHQ2rv4zbEMzBdk8+z1lM7n1Zhw2HyDzWCy4n7xw/57+09Kv09/9UNAP/o6v/K22buPlfuHFO0okD7xREIzL+rWTCYXKWsKP4JtiajQervWWHJTMmiJ2hwJaTcSxswtFpud8bJ5RUAzkG2hhJ+p0R9a8OftztlKn3XVln87GfOjbTnI81jw31R/75X/g6cf8wz/7x3VDN5UsA5/RBUAuiWlEgRcJ0pIw1bu++Fp25I0GJqLF4SZlPG8hxdGKFAOoi4MeyJ+zl70TtjkpHVlGJTnes64PLcsLsqm1W9HKbPBiueBiFpkTEDtjEApyMZ+isxrhDiNDsqADbJLsK5jxp1MlZTNhzpcvFlUoV7zRjjJZIz/sO8zpQbv4GZHdcDiPZxM92H+iermoRrWgJBFRPvQDLwAiCzFj1Wpd7W7P70Jwz5m6iKiUK54f0/WFexV3d81FQcBel12mQ36kvXBhf2POkgra8fXlZ72IaYE+HZg4TnpPUAlolQ5BFJD1CJavh8KZ93QXI5TWW0aAuP/Ao3yvs7NzH+Q0KWY62w916L0EcwEQkBk5jwt06VEXAXSqq2zWhWKajY+0EzSQ+WXYX9f7Hg8J3bTD0K03pRGhOAvdsx0TQfxg4c8W6rUHHtHwblNoMQapb1YVSyX8+2nL+aAxw7gNXEoYuEDPdl6bjLzXFMtlVYZjNedtv/u81yCLQYqXUnvZdmPGPYDAeOWmdRXozLtSKlCEPmPf+XYclEBvq3HAzOkeQWUQR8NManf7ll9kCwX/O9DMRYtEjCDGAZWlKoY8soHnYCZjNhqO+oSnWkOYgv2ZdWVJagMs07Rd35mB4aU5VjxF+G9Zmzt1i02BD8guyxfS4XAaw1wN+h8G15C2UomcId8YsAywEnOUTM7d6Iq8Odzv83VDZryImAp0Bn3/Wp1eKD+dqFzPK1soKZ7FQzPpWYnZfGls6nLrLmSl6bCnTqup3qBjMgLSiFKprEIu7VQDWycJMXlg5G1ub9ppg5kqA3TLLno9V0oHXUgld33v33rriYa9I5OdCoWMI6rSxbi7t2yUJIqs4ZHRYKzORUfNs7aa6L9goeWDtAH9EBAn+L89bTErTsDoDUL0waSv2awTkuRXbDwZM/RgDufzDMCpyCAXhBQANlend6yNxZEx2IqKBHGG58sw2w0BqnQhKdP4gXqoCpmjzRZBGnF+1rGH5Z0Xt5SJRB30zP7LnxOQawl24pUnsBVd7uIwjxgC9VjaCKQat0CcTeFZDSBXrZ7zvDWTD0n1hSIp6lGl1vZwXuMcEBQfCRIPViauVco1/2zMP/O5DJNWFSJZVeeVp3/vOHfs/6Wqf8c7X9DNSkGzUTDG5+AaUBjOBor6sJFWl6dOmydMO1qqaoy+tT2yLrDbHRqqS2ekQgXj+qQNIiZEtxHrZqvFxdMO5tJM37H1xojQhz0Kz7jn7aGTGWtWGesid/b0592cbiubyPs9JEUDMhX3BMSAQwhoLGg0n4FV16HjrBub2QO9wVh8zurHlF0jFMBydBDMKnmW7lSX8/XBlnJOLAbYIEoUViRY8DxYqzvb2+5o+PMYmSAvM8EpHlMBMpZN1NnUE0YK4CywoTP2cBeRzahYDF24V2F0pUwipnIRw4yIEpO44VXWF9FLkVE4kGaTAMt1ul3VK/jfxi1t2ajVtbG9p/NWR4fMBUtld5Gd3sCSKWBZvpm9fpmxDUc+hJnpsg4pygE2uVcgHnQ1nkHieJZem9E/c69hF8fRjeNOtsKQZKheu+3nXMgF4wSY6Th72RrOuYtJ3bhxQydHLbWaLfU6bZ0eHymX4RCcBUY/srzxVKV8zqlM6RRZuUD0zF1D8e/kTA74yUy9BUz1hfd+IEoOOtYH0q5MhtlmMMq4IgiWy1Kaee78en3mSejJhASW6XTgGSVB0sDxifggSLSKReUw2rBxeUZ5ECNMhY1MBeMZD0VYe36BIv5Z+PMplBUL9JhTJ5iEnM+kCYxOc5mEEQFWotwrCtaQEwxxDuRTb+9BySYO7Zd5Fx0cqdNsjEApLAoSQfhvzEXsvG+mGcTNMDPBVYWKMdUNjj7Q1/lzpVzBjCRgFxLgqWxZeJlk2TcQhmV8zkFE2vdIcxWVKWAoHlFulVS/39Nk0NVlq+mNgU4A5lYmkvIMYdwZu0pKRtHMFQwjhsRr2HJTDcdDu9yEcGkWRHCBebJ/qk7vNXeQL7/3Zb303juqQ332HDN8ZjYkYDC+z5DBNosNOjqdHb6IOIgsYLVmXHWhuWJwz8KuNRqKY0+2mnvWl2C2iDn7eKqz05YOm1H7enNh+9ft4Cpx4nnJzo2S5vOM5QrRODADVlQLLyR7Qh5f6PjgzAs+l2UxUmXBIiy70/QMCxp5FPYkcBeV78RzFKow/uygTzjqxOby+ELy83PgA6PZu3Q80YQXgoqbhBZX3dDrCS0O9lcGiNBW2k0jquV4oeg86p+VzQ75DN0CHSNrhU2KVPXZLDiZOOooD9MXs3E26mCcz2QYyngykwszEFh7JMHECHpduOIvFJ53iGcuTveO1tYmyykkE7B1rzd6XiIOCOa89pKMRlUslHV+1jZEzBpsVIsqV2q6Fb2t0qSsTqr99O9HOxdKfvpf6uZf+zMqvPnJf+O79JHf+9VP/3n/W/9HHXzka/yMB/2JYWUqYmBYfoZxJqSLmChiclbQCuJMhEE1xQvPl46F54KEoN+fqhRnvhnTG5XP6o/+yv/q6ffbGu6oEqn4mcz7C5Ps8hmKyYSWWNxh1D/oO0nHh9vVvXnazY59YAHLUTDaGOGZC1IGha31hCtgNwhmIc8xn8mo3Rqr1+fdx1os640KWYdzXWGdp1PaatT0wt3bznc9PzlVF00opvGMSUQU09zrBjYnkC7QKV0GxDpm0ct53JFWuXze8HSn2/P6RYD//2PvT4BlTfOzPvDJfd/z7HerW0tXVUu9yCBZAknQiF2DBAKG8QxgGMABDHgCJjCDDeGJGIzHw4BZLIYYDxgFArMZBjAwMkICSa2l3S2pq7v27W5nP7mvX+aXOfF73u/cc6tNGDlUMRET41SUqrrq3DyZ3/d+7/v/P/9nWTN+gbVL9x5dy2xgQVNAlbWzuxvkKTDlmScW0U/yPiudnp7ZsjM+PtEEF6DR1F2ZY9lse8g8vuIu0npU+65ykGV94LhgTebPXnXoHFekIVUMt16/dro7yi6BgVd+f8wK/LIDU9BIbpEckSCSZdzEKAYNNRAqBJqF+pczPc5jmUl6SMhsBXJkA0OvSrAsBRf2m8wo423RzyhFKsk2uPL0ITDGmLUUfBCbZVwkzzWnSr3h8YtHL3Sv25sUIyQpFNwUyY1ycCiCSDUacxhDrNlqOJz5+Z1OISullF9yX7eajpbO6MWsnNgu1jmf0cEYfD+aMxJTwiTXIy7WTq1eM5FrNBp69APCEE0myqTXaiMFK3GtaMLWntEiIUSLutl+lPT3859RzieefzVbTQ9MqW4hhfBLS3kEymy6m6czF6BU/jsXDIo3BA8eIhhusEYRmdI5pphfkE/pPDIW8FZ97O94D5wdMJv2Qlup2WmqWK140A8DDR3gdDSwLrIcbBqUInEcWGOyUf9xX/PCXAf7h075iKZzRVSmrYZSlaKH6JACoQysZ5EPb8zcK6WGtusL9S+Hmq3mmq2Wqu/U1T5sa7kioHSpOB1rjYZnNvH/9kPPvJSBPu/P+0JgqVZCZiberxhrlx1tok1qqZUbn7TnjTxcWW76Oq3peKX+5erpQUlXQfYekhk6OmBsDIZZNBAOrOWiqsJyahFrNiYwF3P5rCaGfpbeKPCQseg6CpltULCBRt1JwTzNBqKJdazkHFarWkWzZGHt6H75rmdoZ+fnzhjtDQaGnJjtQv3nuPPDDelEwamfw2UD05aZJT6U6xBwTKBtyMhcqdGsam+3o2ajZcs/Ho54G2j9QJhAQvwdDZYp9ZPIbGRmyGxIYaYbrkeJImwJnPjR9cshyoYEMmEc3ZAqHr7PWNI5pwhrRIhn0OC3iV1gScuzc528f6zppK2XKy/ql3/4q7TIrfQXXv0zWmvoP1/5mc/rxZ/5/P/ocwQEffG571Ghf67Gl/6V545oWCeTuec4zLkpXhYw82CgruREhzC+gDDips0bO5sCkGgJOQ4ieliKkNuyGy1XG5My/tJ3/lmtsmGGemtyW3/4tT+qb1z9Qi3LK8Put4/u+EB+4/W37Kv50kugK5fa3emoMLjZHlKbtJYzpDxFW1QqT+We0mwTfc2FDpaJFC58WPTSPBPoozmMcxnSI5DJzFzIsQkCo6LTw64Sf+hUHKuKTzMkm+FI1XJFpQL2iytvymEGtnYkGKkaUTyzPyjZlHaLuY7o4uedGhRcZBgS0eny+UjYCG5b/LesR0Jphxxw9SvuQmFZBw3xVKvByIdWA3OEeKPxDKPvspExnIHY5CO6+RRzS1xf6MqZP2KTubJhgAl/yBmSvEYTXix3Y13fFCWGBvsDk23MA3CGJQdtwUU+cG3gFmAmge8rMYFpDWfY981ULHAgbGwZyNwaZi8aymi6sOSMrreUy2u33fIBiFPahMMyWZ9+hs32hUsQK7WdJEUonSuMVwrwosdw8AsoUFiHvC/r0gHdeH8DfeKnTTxjYg84hwWL/rWQ0mA4dy5tpd6yoxBI3Jtvv6Fbh3s63Nsxme3sAtcy8Ncw6+UMyROmvQX9wdkoQKs2/S8QJ4e8CQb12Lahe3st7e7sepaMKmDQ6xtyxF708DaOa18rb/p5HpRg3Qz/OzsdDQZ9z4FgHoUbGw7M9BZ7u0KwPzLkCnMso2022N8BB9HJUZngysEGbwgbhxYcPKyfIvcxtrZo2WypXiOxAaEZBuNFEyRY6KPxyCxWVznprBaTeSi4kCCgZwN+PLl0ZR7PmC1FevzkiVmIO/vdBDrkbQOU4WzLOWJXdFF8Nlh16DBx6ljp9dfeNeO0vVMz67WAvmk812oYKRunLPeggsKdno6RzfjpUDuHxVNauSJw1MobWhr912bljSEvNKYYX8NsQweHfdlNpcP8qtEIxgXQvSFssIFT9dOdb1doVekmp/apDW79FY6qYHw9m/sQY8MNXqB0aCElYLVi5ggRCDg9zHiBznkYeTCXmVjFYuicqeDv1e5YPmISRTbtg9UByNWqK/BqOWj94mHflV2QVOA8woaK52bGBxo6QnuGppCF1NztsTk5PYM4Z8t7gG6R9mTMLEYfBoxOB4FNFXZ7QDUc+giu6/WM4WJMMM5yN1AjLzooZtbcc9YC/xt5gOGxp6+0Cx4OcpANfgZ2MFrQO3eP1OnWnfbOrIm57W949Bv1t+5/vz4oDfX7vje8wy89/5x+3V99pMKDd3T8u/+EpnMIQfw+vlNKlVpFV7/iN6r25R/1QQnJ4xoKms96uro6d6fDyGE8yWk8Lpv4BbPT8x5MTBwknHaBWS7D0sbnl3sL27pg1jRZrP/o/t/VZekmwf1Tk0/r20ffqkk0UolOqVxxV0FX+c7b72l/d88wH3NVh/n2nnGLYbYLQuGw4cjPD8XbR1ziE+avyR3uRiGc5TUfA+sDo4VDgD+TSizKkJoBLxrW8yGQtfHAW9hDJt0ohB7WLMJ8YFEKLLyDOSBu37ur89O87wnP8cpdNgX51PAim3bEtUGfh2FD4hO9jCbWOLMHcb9ht8JGjZA0caE9y1wpg/FBLMOpFNJbkBHP3GHZplRPVZWaTENiDOvZNoYBseIvZoVszHSTdMLcs+IGGQ+hCWVv4H72KT6Sl4lZV33PCT3uwJvWoxMgV0InggVeq1XW0eGuzcZBtNYbDuyQ1zsHKmWeS8DyJLj8QKRDD8vhMvfsH2u/YLqwpVDO4Y+98YECREwhBOkhWgV5BTA0+8BkvtFgxP7B71i7MOBmws4G4qRY4I/ye0Bn7LmN9ncOqYw9hsJ37oIjuqIjXdkABNSnfzGy0QfFEXaU7Z2uLRVDrmRYbjBtwxgAtj3oBUEU7GGMmoouTtI44WXJ68T9qaq9/QOdHp9qOhqqmCcrmdkviMFHDTN+/jNKKML5nIkOj54c67Lfd9Vk8S0PeqnsCrbVavphu7zsaSFEwUGMjikzbDyf5kkaCF0L8SgwuGznhakAcxtb4AcWLQ4Li2hqCJTKihs2mU8tmIUcUKhUlc/kNZwNjK/nM0WLcEnDJt2EB6d3dum5HvRoOrsHDz7U4dGh2p2W7ty77aoKO7zZgmonreOTK132GJwHuBJB/+XJQF9efVV37uzrlZeec8U8PBkqmkTKp2GH4alIFwXkRNUPU3dtb1k8PW2szBGwWVlfpFzGHqEMUln0mw3m30sztg4Pd7Qf3ZBR9nfbeqGIYXpDu4ddbxIktfOgQo+mg8fUwebqYPdITTJl5dLMc4IkBbkFc1hmyDiZsGmMxjP/ne9fKjEwDx0bOcbX2tBsoewKmIOKeRYLCwjDhKttIElY8uOcxcBCZWY4mk3stevA7Uxitp7YpgGh1WpU7SvDr/fuHaneKPtA2qZXyiChKeGwwedBk8hMOKP5dO3u6+GDU5s4LxcgEuTlrWyDRuU5GvfMfN4efe30ITz41VrdOlAgOQwUFs8487BhAV8y4OefzcLOYCJdVqdDHuOeuymgLYgVbAr/56/8p/rt3/Tv6P/+e4PM4R/O39Lhj030ix5IJ7/kN+vDR+f68METy2z4rswwq3SLi9DlWZNWhFEYPCuZt/OR6jwfG5iSkeeHHJbQ2e1fam3d3JpaNrsgz1l77oY+MZPb6p+/9Pf1X37Dn9c4H7rdO7O7+j3v/XtPXaQoQriPMSRrOpxE6sB4o0gQrslAN9cGHd5eo67d3V1rVrFt9OYFe+zZDQXtpK3gwJeY24WZkA8lbdwRWn6URJLRTW4oEJMDERSBg+v8/NKFMMUM3Q2F3WA41mBCp4BJQNFo1NHtI3dBjinDbxRomHsJqzhXcPfCGIDDgE26XK0K4G44Gft7I1nKA0ZlUt5Tzk5PDHGanJLP+/nPbtJ69PjYIfQcFoxJ+LzsdRBxWNO8j23gPFbAmKVo4MJB1TQNW9iiMyNyu7tdTUZjk9G45kEid3MNzy7ONewxe0ZLi1dt0HdTuDHX7Q36JrnVm7DAs8pWC0bSmi1Mx7PazENSjc0porW7MnJLDzq4WZVNiAHu5oDiWZgSHo6R/HgW2Oo+nBl7VJ+OI1YrJB0L3yN05xyGQ7gOZEIW8rZ57LTams9HtoZj/s1eNx5TVHEdwt5NIDPSmdksrXQB9666s4mvej37zzabXZ2dPdH7HzxUq93W7t6BRsXRU3kMhVIw0MhqmoOXEOwQzTDeRFYCUHhDDMWEhcKBf7+cs08RZl32feFgpRPGzORjPSjZ5xi8T85OdYI2xVqXpJtk3lAsqVNvaae1o6hKbJV8+KDPYe1wwYFEYKpRjfJgU9lxQPIvPejmsIS6Xypaz8TDDM0deA+K+HIx8RdebRaec2GTltria5pTpVQPw+9NcCyh5S+kaPVnDjCFBs5MhzOKTWs2jVSrX9juqlLm0A6U+/Es1oNHDzWcjJyIbVf6bseJ77VmQY1CTamFtJottZ1tlI2zJkNsqYiBNayi3To3jjtC9UsbM7OVFIzEimc43GAOFLou/GsRtYOSUo026gXt7d5UOi+/ck9fXyW3sqAcptCKvBDZwNGCzUaIrUlHgdgjdTo7urocKpsDisoY00ef5OQRqsZo5fgnAqqpmnH3Kdn5o+ENiJtHBUg3BFTJQQrdf7leajqfmIADgcKbs/0zw5yAwsBaOypq7qnZfhB+gIYoE8LcmuoTb15CsQ8Pm7r/4m1Va/hzZrSk8yQ5AKjYbiYI84HeIQOQsTfxzHC1Yr1sTZICdmG+N50NtViO1G7fMi3+2RfV+HDY15PjiYowjwshcYSO4+lBib3ZfPn03/H98jbdxy2HrmilpufoMCvxmVzr/sXz+ls/+Pf0G77j1xmOPy490TAZN+Er+eEHx3ry5NzwVqk4VKfZlnbrKi7DARO8XdHAbjw/xVyB31Uo0DE27SjEpsCsF1sviix7sNoBYavZEmu7ledAtWpwL/mhzj/TX/jmP6lFLmhJ61FD/9Xn/7p2011F2chjEd53GM9Vq7bU6expp8sBiAVbUa02RI+QgnL9Go0WiidTHR4e+JmY9UmWx4Dko/sEYxYOCq4VaAn/HIyzg58o3XxEusXmWpge1oz1vZtgloFlGvpBdJBkbKIspDCBabqk45nPNV7MPdvnXkLoSSFPA/qPmE8VvC4n04Uu+wObYyA+Z7NlLlapIEeoey543dHR8dHBOcB9zGEckBHWbLES6/Ka8Q36NIXxGZoHmM5oJylOiT2zY1DizmXbwcTVivemIEa2tS6TUOA3cJEDOrbMP9NR4tRDF23HppytQNknGG8tFuyJyNlKGo+Kmk/GTnXhwGzUQ3jEeDZyM9JuNj0uAy2jI17WaQTWFuGzz0LG4dBipjhllEXn6bg4OuDgyMP3KvAZnJGa9SE4nwPHBj02gn0Y0JUSHrwh5ovvy5qGTMMMEd4De58ZK5Dw8HNljICDKAUr8pBtSqP+xFKnRqOjk9MrPX5yplde/oRJRuxDjLLmEfsPXrEFF5XDCYgE9wpHopTHPcgEc8Ww//A8s0eeX565AA2FDftLYNLiXPWxHpTAF64AFwsv0BX4PrAE9OA8IB8zMrq4vt0P2vWG8fXZcGCozBeebqJYTtJAyn5oeGAgfwTsHscKmTTSaTUS+AuxO7ZfmAsUbFTNA1quNjSfTNS/6CvbBKuv+/DjgeBsdVpGKth5of0DQgtRRaHyxtEEF4iTkwvtHdxyZYe04OGjx1qtZ9o7aFuoi58jcVt0cWzu9WrJldeSSh+XgxSuFlR6C8VYdvlhRBSOgDqEkULvztmRP/YsEBq1WVzMT9gEk26GB2yVje1c5A4mMRzo7NbUKocuYEt8UqXkhWKLPCBgkwOyhufSIgd0q/OzngbTwVMvTkcO2Vkl7QfjEi9cGJYW9a40hVxluLhhC8BottRsDAsy9nXowKzLU6FG9tiluwdB4IGeThcW/wIR8/QAb0L/jlblYIRgx+jQNSAZ4ns02zW9+nUvaX8feQwsTX4k5C4aWkyFA+FarwfBAKsquisHfTvZPXjHhvk3M5+ND3seoFn5o8nlyGjiYRD9G1rF9cWV8o0jCrMqNmUOQTYnrPGwuWPjQjrkbrhQ9vpOVcnsY+Naqr3o6r/6Z39D//53/D718slNk/T6/A1dnE8sB6pWOHiyCYxafRphZQs0OzmBSCCRwIMTWQqdH9FrzGLwMr0+0JnTRIbX8K9lvfN++L1itfcjlR/QX/1Nf/KpgdDufF//6Md+QJptlWsh/QAuRXGP2w3ru2J948H+ke+dvTJzuP5Q7NxsD5cXfS1zsVnQuXzHhx6wHuzMZ190kIbPIZy4o8KfFoE6aUFl1RsgRzNUuJ6trnAlmga7ytB5rDWKJ1pOpz4cyuW6oeVldKUFKSzM1HnuMEafzPXW2+/q6HDf9n3NWkOVRtMaP+bvPM8znnlgW9xvkrFHq1W3eXYFWYbH4KGzLBV3fM9JLeH59sHLmGQF8xObyHxAiXjG83k/A9w7nmfSObiXeOSyrtj7ppPg82tGrbkCoaqwhrHfc/HPvgcSFLduKg4+u1NGrKtGBgYxMMCq21TJ/w40gzHSYjlTA4lUnkO7qMPDXS3KdY9Z2u2OU1RA+Ni7WatEXx2fnfvgZo1btjJfBjZrNmdY1J6qTrPBnCWnVL1mFnK5VdVyUdHF2aX6vZ6ieWDyQqyxocIG9666SVx8Loq7Kg5a+aKRtcwUtnQYqWTzzC5Tbl547iACQfi5PO/b5o4g6S9+6TV/96Nb+yYu8Sygowdm57DE/AVtNfsX7m3ZDC5CwYLPJhDsd/NJaMwikqmw5Cv7u3HvCvmKC6WP9aAk/JgLC5wSIlgQrztO03+xARKRYjPzlFSEDUvmm3MHWRChiyo1m3a3AB+OF+uncCpMRnQ0eTblVtPQHHOOdCZWvpxWtVHxPBFmZDOHDjKraB5pPpkrLm01wnZsFkyjeagfvPWBLk4vzYJlVlFZbZwliQVW8P0jIzGrs9NLff7zP+kOhFa9Vsnr6GhHe3v7rsh4kVxCFYR+iWE/DwvdlZVlzFtyGVOoDe8hhWBGyUB5tdC8Nw+C8aeCXKoZDoa8tnR3LMwN8wGYtCWHV8epuWeETzf5Uka5UtrMYshBOVxGzARemyXbuxzYR6pYCEYGlPkcpmfDy6dWbixQFh19HfFnzKXCXCWYYLNZULEDf+I7SzwTOjcKIRiErUbTmy8zzHDw5H0YcoDlCxRCeVf6GCzDmgTW8fyPbnMdZjf46DL72tvv6M7tQ3urYhyzWE3t47tcwai8cS7x2ljSIUBwYfNeq94o6bn7R5pOV7q66BspcGIKmxdz1J2a9vZbipofjc9hg0TLBVzJrIP3jdfMWG5Ym3Q0zKXPTvvu2G1YvqXYQoKAf2aJ6a51XsFjEielQBx5ZfV1+r996Xv1x7/+j0h64Pf7E7/n9+qXL/9dVc4a6j449IyXdcYhd50LyZwFaM62dauluyxbwy2wEJwaHs5m6MQ4KIMajO+LdOraZ5X798bBl3SWPtVf/R03h+T9i0/oe7/611SKqxqvYQMi4IaJGpnoMe6jDz3TTntPtw5v6+w0hBJs1gsVITA9023Dyr3VbdtJBaY2s2Hm2l9r6RfWc+xZPShAIMuACkTBCJ7ObXxq28spLN7tNimC0vZb5XSFvQ0aBZzf6w88m9+I4gGSUxTM1tkxNsSNRRoMpw6zjqtpp3yYvMb3ZDa6xfcZaVEUgo4XFHRbhxFMU7GW1rcGV6ZytaJuF0IZUVBrF/AYR+C9WhqOlZnObQFHh2N9IzpPfzdCkFMqO1x+5c8M9Ht9b0LhQBHXdKCEIW1DzAn7t4Jm9GYdOsow0aT60GIfmU2UTlHooWsuJ7rTEKPF3kpsXqWc1/5+R4tS5Fkf46Gzh4/9rEO0Yb84Ozu1uTuHM8YrkHQgUNKV8Z2vWcyesTJCYp6/WGgTE1NWVr5c0qJS0nSU02K9DIgBSSilUMAyJ0ZLn5nDg8BxjNkvByUz0sgIRDZPUU7xFzgqHOQm6nDNox5RxdpkYq2GC33xS1+2Ccu9e/s2WGh06tpmYsPr/M61cCTCBIXiepvEboXvwGHJWiHQGW4DhRrfE/Yy14yR2EdFZB/DQWk204IvGDLr7KIC1Ei8UgTLMqRQAxXwy5GOkPQxXwBzThy3BZzKIcjgHKYYC4CKKwie02rWquq062rVq+4m0Qxm81vly5ngZVkpajwmSxJ251KVQknVblGVYsUzjQkBsfOVXv/KG7o4OVchTXWRVy6VVj05wHy48cB4BrXW7OxC733wgVrtpr7xGz+rX/CZTxk3h06MOwsPA5BCtJibsGR/V89LWSEEGle0ASLO3MxnkMlQvdCJAOcCKfNguRvKAxeTSs6RhSaTrLtA34YFGxEjU8i70rp+lRt0MXGgZheBUdFjpS0XIG6MaKwMwtIN+X/YteGsXzTcRbfHg8nA3RZszjhcBh9Kz1WRdIRoJXeXMD5zGd29c1tXV5caj8bODEWqQ5FCZUphbPNpd8HMNxFBM99auuM4H/S0TjjQMP/swUlUUaGger2ivb22as2icyphrubyiJ3ppHFvgn7OjDWnOBNrid4ycfQA4q3W8PkN9lRKLZUdx9rN19Rs1txJ7uwGg/xBPWgbn31RHCHOB3IBZmSTdvRZ8gKOfufkoQshumiKGaJ7sDLEbCPG3LyALhRkAN1kgG+DIXZWLz/6jH7XxR9S9/I/YdKkqLzU3/8Tf1k7bx7pe/7G79Le9hXP/1brudJJwcFG6E61XPGzA8SE/d5sQwJP3rZs/B36PxU667YcB6Zjdplx4fraiz+p//o3/kUNmpdPv8utd57X7/mR/0C3bz2vdJZQ7qFdidjY1hHpGws9fnBmH80XnnvJhAcMJTbbuSFg2Lehw06uXbSx6J41TkXuzhSe6DPuPbws6/FBlrwownytYUOSdzrT+cW5YX88XzHfZn0RukshxZ4xHQ+CCw+Zp2Q4Yh+YK7jD8+9zhNrG3ADWL5+FCc7J2YXm0/kzBDDkFRh0B/2i2d3pIJOwWTYHPhpG5vIw2VewOjM2O4DNiha7PyDyLvjAoklmphr8idMqIJMpFZyOUSZGi7iyNnN7mKfMwBMNIzrxYlG7+/t+9oBaaTzYR3kmcoa4n0lqoXs1RIk95MKSH8dzpZnDBa9aB9wjicpex54xZmG2mtJ4jWRl7X2XTpYnkTAHpDTc42vYdzgeG8oPe1PQGQZiH5x1CkeY1sEpiIcPSQr7OhaRFGmgGSB2zCfr9cReDiIh2vRW25/LyBLd3BpCYsPITIE9aZvy2IcCEJ4DGkve29mtma118pA/e1dDe7Leuh0CKmr1imeOc0hnFTruliol0MIoEKKYVbKXwLwHLkhcsPIODMhp2B/ZPpFrcRvfm5/jSflzD26+pssjaYG8Yfst6OywGFls0LLBiMHmZx78sug3agXD2sVSrXpNjVrNNxEYgY0oPVtos4Qtm/f8Z7fTMW5Kwrd1poiMmVk2sYqC4Uhq9aX9VzmSc8rapq2Sr2iV3erND9/To4cPNB3NtNfZS6jVIXcOhhadB4cCN43DCaE9DLSLs3Pn2+20Wp79IUnY4OiQCcQA/lw6kw/zVKpQ3EAqRRUbVU1Wc//7IhFgiQNLKfEvddWTZPsRnLycBncZHrzFmrnfWuMxQ/WxnVqYydy+e6hi9WY+VIDJVYc1meQsgmnZIDnIQdiko/lak9VM8YpAW7RXHHg8SMGhx98/MYVnUbFAPVPYXouMuY+BSUgFjV8iie2j8cSbJnZ22KU9evBIvcueCTn2qy1CAADOXerk7EyDEYYCUPUzCYkL8lZYG9DKy9as0g8slaMyrmCdlSSomyWIt+NMm5L5bU9TFyDiWAVDRFE+VmWb0q07LR2l2q6sw4B/6zluNo8u76Nm3cEgvOjtKMDRVOrcixvIazie6eSyZzNu7MsWVwP1ewtvhKz7NrZqEI6gu2/Wym0gEiEz4bBc6/jJhTZvVVR/2PFBef26ePmJ/unv+X59Zfij+kM//kfUWjWeahTZpNiMHC9kmzNgsEDyAYVgU6Pb51xCI0dhVSjUtUlldLzzSH/3m/6aPrz99kcOyYMH9/Rrv++3q5s+0no/xMShO7XTSwbyyFyPH53q4rSvWrWt8XDmrpaiiGtXr92zdGQ0ICGI7yIfcoUSgdZbdxpU9/ZFBgZ/5sWzZON2njUOpo23XB+cEHmMZoxHZrBGZMFSujqbsahKueP3dPJOEeiekcBCyk69JjmA06ugzra3K5puEA1Yn8zglkuvWToTy0PQS2fQTV+TycIaM1fQsVthXYbeDb/prNLVsvojzL/Hfi/+2Q406ZyfGU/aPXenEyzaxxhZS7NRtX6aYsTh0MWCxyz8PGs4WMdFfk+KSScqxbFZxHy0VOumM6cL264xUwlpJ/716C/jEIvF92IPoHkJBW4w/8C9yg5WzJ3gdKzmXmcUYD7MiwVhfe+sYIhchCRQONG1kv/peWTBP0cYxXWYRHrLtUl5j+dTcq8a9brSKQK/wz7FiIJ5H0Qf/s4IhNltsIjjOSaTt6hipapyFU38SuWIyCwKD6RO5GTehA7YED7Ncxxp0O/7/gXG/saoxmKJKxvjA/gCBT9/oFl2jQKYxYxkRtAA1z8YrvhZXQQfWQxV+AylZwrlj4fMA717sw1Bniw2BuDM3jxzy9hMl4OMUz3PAsS2iHlaqaCdTtubQKNW9wxkguCd8V1woTZ8wYIF4mSBGarDRWK9tM1bo9Owk44PL7b1TEqz0VSz4Vi5bVb5VF5Hh3eN6/cvrrTiIJgtNM2PLB9hszFGjyfpNoQK7xDTZbZrz7ZaLJTFeKqr0yulcfnXyiHHSBVINIDxy4fmYmO9m6/VHXWVRucpSEI88qFz5IFxdiBCWQeOSvMJHocj21tRNPAe09VWF72BczkHw4Fmy4k7on/7W75B2ec+8/TaY7BQqG9cgQKdcfDG0Vaz8UKT4ULRLPb7j9YkV9CtbgPVHhZkuWoRMNpA6O0w/q5p4TAo4wSmhXKOcTnyCJtuO9wYT8ycBv2RcplTk5ZIxOD+UJ2RBfmjra/XW+0XgjvPrXWYuyRbT4Capeqkp2/6wt92JwZhp92paX+/ZbkFJvbRau4ZBg8q702HYFcbPzfWEriKTyx4tF5DpohVqQJFI5EoupoFTmH0h0kCm8pH1i8RWwQa49XCXN2HZUrL1U1JSRdPh4t932gYDMrpME6fnAa3l2rVxYFS/DdM5KncYUtG+vCDE73+xnu+H9e+qv/9L0g+sl/v+q/b/Xe9ZjPLICK3XIYZFk42CfLAgRRM7sMmR8fvOCTPMTP649/1h9Qv9TTPzHTeeqZz3kr1Xlu/8c/9fmU+zGlyn40DwgIjDEgroWCFMEPxxAGZ3pQUTXkmMOsoqdvaUblY11e+8pbefS8t7YdkFNYHhCEKGeKXOFjsKfs115nfx+8ANWLzgrHpksfuTAkDfr32s4wcio4S05DTTfCZ9VgfKQRZg0ukSsz7liqUMSRnvgTMmvNmzfxrp9PR3771bbrMXMeWQRLi+icyFGwuKaoev66vf/vHvMabFN3Oyg2GGPxOdI1otensmVNuYgoWRkMLhzwz0gE+dK5llmJ4Y57Fwd6OdrodyzaQpKCZ5Lljzs0ChrDomWKhpNOzE783IwpnujLLtGZ3FswAkhfoVpQijD0EzNM1oq8GxTJESbiB81yLLsCBUUv5qhNqWKcQehajkEpD7FS1XA7B3IWC9ndDtibQp4PX4zBv5fPZm5V0E+sMmS0C74eRE16vSDY4LEPcYsnIT+iQcRMbWQYCv4HnloIZNuxOu+MigX3FOk0O9VVs5yp8nTPcjzZJMWTxjtyBk+WK9hatJD90edGz5K3VrimKQmEOCsBoiNALPGwz9qMuqFavuhhjVOZItUTGRmddaoXwc/KTeSzxuq1W9z7eg5LqggvJ4iCFfDIeGa+3SNvC3Y3lAzzYuKLQfqOzWfMBkTZ0274BEBEKHIYip/HcCQtcfM8cyDIzsw9roUACabTq1p7hjQnmzYU1bZlzDBnIaObDhkOpWmuq3ajrSS6rlbtcqk7Ykwi318baXTtuVloCffDFVpFazEzJvktndHZ86kqxWCsoR7BvBHEniNQd/AqzFk/BclGZIj6yKWULwczcrN5szukgdLQ48aA/o93HX5U5AdUgJIyrwVg9LMvmkf83w3q8UWHKFUpf1kH1kCTKsP8BqRA3xlVitc03mo3mGiPYneC2AZwb2+qLA8b2VEUSFhier22Xh6cos4pyLGsOeUDA7tm0mCGwYVOZcsAPhxOdnl7o4vzKByMPyHyy0Bw3j1xZf/HT/1vrybwxwV57Zr7yr3vNWgf6J4f/UfA6Taf0vQfvq7FXU6WGdRYzRjtjumukS7h2BwrBspCu2LSC7IVijBfXKYvVXoEHAQ1ZYEdbUpQk1z/74vAKYcihOIjjMB8Kc7bwYlO29SsPqIDPYQCi11rY+KJYpjINuZ8hHYiOBShyrQcfPlHvisKspnWmpChb1EtvhsM+zsZPRf/ML9nGTeCqSf/Jt/8pfcvOPb0wetkEpThFEO1KUQqXHubqwbDjX3zqn+k//+z/NXz3HLZcH4U8c8u8/t0/+B8rdZXRfLRUtBro1crzJjmtFjPVG4HtCdmkd3npIhWo7eLi0uYQ6DHRsu7tHToS6cc//wXNap9++v77+3sOLc4Xd5Ur1pVK4wJDAUrXefPiMLQTVAGBPRBtICNxuNnUArelSlkDCCuJ3SQIhOU4hkSRK6E/5jqTU5g3ChKjmS5k1To40Kzc0N/81G95GkW1Im7ra630vub1Rq2jtz/xLf5nju4/cfwDWs0nqmaIfGMeC+uTuC/SWgLpDE13pVTyQWkdJ9q9daQ0Hsk8Z0U8g3fVqCGhgk0/1HjCLDj2QXMt25r15oZxWaM8MxCe6PKveQuhILgpOCCYYE8nbDhtGUl3nPF+61zUFFpvrPpg7haekm8YzbA+q7CAo6yurnCm2aqIMUE5r069rk6zpr3dPY1hBPcGnktiME7hwPuwMJF8cGC6I1vHdha7TrThezlSKyF8YZAOcWc0Gbn7z2CCks0ov6BhAErd+LohHWHNk93a68NOB+kD3ckZtqU44J9xIcI4wuM49twcs9K0DzXISvA1QuwX0O+l1QbsFex5dNP2gF4vlCsE1jx7n4szJDMu4uY+KMejge93OsM++zEelPwS/qLlBs/noKHzorayhx60acSuVFJ0aMwfEdQXgncg8weqZSjbWyIAJ2PbgmG7tF3EqleKnoFl01QlG6XzqRBZU8pbMoDJOZs5w2IMDNLlklJ0epu06oWaLk4vnHix2+3o/t17Glz2AxyBtx9f1C4hK6VtyZTTxjNHqcohxzwUv8FGzWW53YKwyStlpAWHe7C9ojLkoOcp4aGHRcqeijyFOR03FDeQGR6081j8KC45vcuJhtb9oU/KJuJ+bOeWdiHJbpN0+zQEExxaQtj19WtqSUwqJDLEG00GU50fX2k2ihTNNtrSFUVpZTYcBGuNlmNvQEzFcanp9YaJCTN1MGkYCJaBsXm4xxqPhl787taSYFqQAzrhtfI6K3Y1y1f1d/Y/rQ9zkHpuNqVaNFVxTReFDCjM2667yZAykdUmk9WgFIhRvH738UuqnW30Vz7z0A4pTXIDVwMjFPTrQEOBSs7BR2cQICDKwzCoT96biCMWfwKvO11hix8xHfVH1y8D/2oGt5QkfWHFQ1/4yCFPVY3/ZWufBHj0uLBKB4qijeoNNn5YqBXlUkVtU8A/MP0wKaib0n5+TrpOVn/9m/9AYLkWpG6nqve+5cv6O7/4r3s09EHzA8Vop65fqUh/bfs7fm4P4decBcVVSQej2+4qvvMv/i6lnhTdqdFt37t/W889d0uDwYWTJPKFqnW0IDd2jCrRIZZ0dTYwmxOzB2KZ6Da/+pW3NBzMVN55lhG4Ub8/VrNddcgzxW4mu1Xma65zEMiHUF7uhz1GfZ+QEwUDa/yRs9mRiWGGD5PD1ekXxHdtmdUiI+EwzmqRK2heqqtWLervvfrrFTECeWYNdpZD5hDuvq4vlA8kGNaJ1/A8W9AkH8K8+ak/dvs7dWd+od88+LKmlYq6acxJ6EaxOGNckHVXDLLFcINxag4S1HwZuiYTYOg0sV7DujKwr5GWAL+iK2cD53utxiPvX8ybLRdLJVIqfwd8a8Neef0ajvrSlJkyZgVBGmcXM6f/gPRgYgEJEgw5dLgUb4wSKKAYRaSijCbjSN1m07Iixh8w8TnsODym05HOL078/RgPraJgwedYQRsEUKghXcP5JlJ/MdOCNJENGk1s5Chm+b3o3DGWT6uSwcIuSKzWpCxlsuoNJn5W1uugabSZ/GTsAt0okFLWheICVq3U1Wg3fO9APyiMovXMpjGYwUxGU2WzpPiEOa4/N8HYK+xR6SyLuupfmf3OaACVBEQS7xFznJwIaGCNzT1aIsJxOr/ZZz+mGWXYUMCD97u7tlvjQgJlgH8j8raNkbFxIIMQAhtmMCxY0iZwTqjoajTW6dmpTdJNxTeVl4gXxNwpFW03VnbMEosSgwFDPfZ5DPRlGHEeOtt/sKD+ec+2d7VyRZ1mUzUqOkhGOHLQSWIRx6xGW5WoePJ41lb9eVZxpHa3o0qrrjWZaxkpTVBwHqYmVQwpG+FA9KyFBUk5nKKaQf9XUSreauDgVMyv0/bNBBrtXWHoDCxYMKkAdhqzOTrdUgHa91ir+doSE0zCM0V0kG112m3pqecAXTtgS9qsOkJNYfuulymtIRUBoUYhQcIEK+CYOcYMkJuYfW3cgHBNvWnM5+58mY/QteG0BAPNETnOaZuoVp4plS3rq/c+q3++86mbhbDd6tXLd31w8YB+6uJtdc/f00Wvr95oaKYgMhg2Edz5nVjQaOnH7/xCV7u1ellf2uxpHGf0m774nN/y13Qu9bv3JrpdDJ6YrAOTF3wYBocgywzoAElEpy4Afo4JveVehBm6sZwt3XWAWp998b9tNcYDar9HZnVr9ea4SwV40R1ruWwomsIHrWYmy+fIq9OumlhGoQT7OJ3OO/SW5A+Ys/VaW93OKsBFWyQoM33i5Rd156ijl69u6zv/4a82cvJnvvk/00X5Qj989MM3H+5/vBn6H7620q949Gt1p/+8ftMXf7euLgZ668k7Okv11GhUtLNzoFdefV7FUlrNVtmdopNK1kvbFLbbDctC0nFex4/xD847SBsz7l5voC998csuYHBcun5RuB2RuJKYHyDspqABQfroRwviekOJQMnpvArEyjGDrFD1Y0zSdke53g7tfAOL05InG0wEeQkzTvaERamqL738Ob13+Mmnv6OwXetTy1OPIdgLvu3Bj2t1dmzpgyF7O2LJxS9JLUjX3it19drOSwk0K314+Ioelnf1p8vf4ff8ru1X9JuzJ8pj2p3NeB5NVwyjlk5pGq2SFBQ2/NhcjLCWsGuja1+Y6AOfwRmKpCKR8EPBSBFsbkSwmzSB63pdJuQkM9CT18mTY2UjNvBgPu+fgWnrTjvE1yF9wcO22S05DQcCjPdofJNTYaZMA4CxSxVSTZlOFCkbhJxgI0nnyMODFSj6SIpmPgfETMY7jNPqBwd+P0iMdPj8Xmu/K2VV66ytpgv46zSVdLRRwaRegp+B2IM39HA0SYKsQc8CnM6hFYojkoAi7ymFfMvkISSC5VJB4wlWqMg71i6Y2cvwly2V6SLLhiTYD0ywMilxY4mVu2sMCbYhHYXmBPtQnoWvfuUNdfHAhW9wnY38sc0oyYRDU7TlQWuriIB4BXyF8wybCkHACNohHyCsp/tsGEaBjk5XHzDxWGcXxCvN/M8srt1W25WfHfQR62eCg0KjWTMkmSmEqsCJExx6drDPKlMo2mUCaI7DhW4ADZKzHy3Mw5VjoTGdEqkFrl/CUBrcukLSQCEntN/AC2iT0vWisqWscgidc7HNAHKZsnWFwLtRnNHSM5Bw46DBF9I5H5LD85FGw6lhSsyr0ZlBbmQj9W92mkBW8TbntBOMl5uYN8M2y0qlal6lWkZf/8qL0v6e9CjZGLJ5xeTljabqnfV8sEJjcuzMbKFchrQL4MgAWfNwsaGhO1vToa6C1R0G0MA6PAykiFDYsMDYKCFCcMByGNMV/3DlvhbVln6i9eLTNfDKk9d0uF3oW86+6lkDszRCbx+dXeiKQxKyl+nZeFEmJhLxWs14rP/F8Q+q2Srq5bvP6Uu1rJ7M1/orpwH2+CdXXUHIvDPc6PffOvH8h40keHaGRACzghNTdLMxk/gprA/RSAab1mCwQGGGk89HNvAYU29gzaClBN5ntjyd35xSFFQcKP0BMCwHBaSmomeh9VrJhwzf5xIP4PnCFf1ige9wyp6toCvcYt6ju1PVwf6ujQNsvs0mtt3o3//RP6hFaaZPv/Ipb7SQM/7+p/4bXVVv9Jf/utcneq/ocw++wwUBM+Tv/tnfYibqJifVGiXt7LZsaI27yd07e3Y6YgaMU8tw1HN3Q7cERFep1C1nKGarevjwkdMgTDaZRfrxz/+U3Y+IJWNed/3a3d+13yowoMN2BZOzoHK2/NENJZsJzFeIfbaL49BE1JxRtd5QtT4UpkQttH1z5DDBHP2aXANEu5hPTMz42Vd/uebVrj7Yf/np+3/D+z+iu5WsPrc5DfP++VJXV0iBgNYoZCF5kOpTthzDbkOTiVq9N/XLzt97anb+5nKgSWNHX+6E9f3/qn2dVnFdO9u5vjP3rtqdhtqxVDq/dBGYsjE583PWRjCi5/lBbgYbFHieZQrbM0UYsNc+xLO8NZYcllhw8vNzxgaJnMqMeAiRz8RsAQ9WdB0mEMY56WeSeGDwAlejQQ+fCSg4hDHglMT1h0mayTDrxqqOQAM01htzNkazMG6hAGXP4Gdh4oesRhjSwQCCNUsIdc4HfWxvZ7xzmSW/mEnr4HBfR7cO1d3t6vHxqdOW8nTWBA1g3ZlKO0SevYJRD/sCCArPKd83NFOBLRz4KsF7mwOSw5pxEZ+3N77QyfGJVRAUqqt4ofqaNROuQ9XvwX7DXgDCNPMZlLY/binYKvpApSAhAxV/3onu3bujnf2PGpP8/A9KZBxo9yK8Qct27y8VYTYCPwW39iJ+rEXghmCtRvfAB4fFOFtiPzZRrz/RwN6IsbMS7SiTgWlFTmOAhZCCVBuIYTkQA9yKc4M7Bg5cIlWo3D3YXrmDMx6NDm0VOf+RsFNsflepjQ2WN9XYXR/wMV2vnSKokOYLZctFWAiWeAA/tXY6NlWATFTJBYEv22mM9i6NtRtJ6gzKU1pO1oYORhcDG6rPh3Nno2G17oDhJd3FWjPCSykUSO0Yjl1F2a+x01Q2tVWzwXcuCHTo/r1DnbIrJa/1NNZ4OdHlkwtdng60jXOKcduP6KgW2hLgysODCX1M5Zm2bAWmHuba8YbWFP0nLE+g8pK/N0UK9HMqOw5xDiRKgC+/8C167eAzWifzu4OrB3rlnR9TZ3CsIzxAYfKy+BZL9YfBMQVGH91kxQ8gDNSgz4SJiqtRqZrR/q0dowTfXe7bwPkTuYF+atbW37va1w8OutJgq7NFTv+nux+6W6XC5KHlYQCm4wDE8rCYJi0hdPl0HYH4E2BZnvHJdKnh4qOQyhtvPtLt0h3/HEgHCAgHX+GGbZPMLQOBxN3wTsvJM/B+eAg9h84V9ODxezZ0iNfM7JtqVFsq5oqaaGR5B7Drvbv79gTGVJ75PbR3NhicpHLjnH77G7/Ncyk6j89eflrzwsIzq7ARBlYn8C8bruU9vZruD19Urdb0pjtcEyG0tGSj2UZ2dMuHLibZzSZsa6pomKzhEEnRlVMRwlCOYEVHyqZLarbLajU6jo1646tv6md/5nWzEw9v3dIxayhBiZlJbVMBHgSaIyeSC39jhBBesMO592yO5UpdmVTBaAddDMYfRPJhm4ZEx4YexZILPpAfJCoUjlebtT7/2d+gB7c+9RRiff69n9D+2du6P32iT9y7K4zH6II4aOAu8GNAyVSc1+YZ7sRsenDN8GYzDTD+px//tPLzru4cv6afOviMzrv39U8yd1SEkV9I67emzg39ddsNX1OkVKx1HJbI3YW4AiFmNCFvd+1DDbStudNUqR5cgCyFKCCsD7CovYMhJM7hGlCUwh7OW3f+bAqLi5rlMiSNQH5J5RJnGxooOirGU4j0Kd4yWk4Wypdz2i5IFUHLulV/NFETsmEma2u+Zbnk9BZgYdjZZ2eXGmP3l8vZ0YyRS2CGY1sJWargA94h4+uV1jZdn9lUnHizyvGZdcVIadaGhLee6do31haJlEkYyAR7RKND5h8UQmQfyIxldGjwg9ylXqmpXqqqmCtpPEfaM7GlJ/UAbFWvb1VsFsMXxZidXMkCmZ5t/LnxOw4Je0HnHBKiOJjJCp6O+4pTkXYPg1Z256DpmefHelCulwtN47WG/Su70/Al0SQtsNhKE+fStlZns+WihAMHCBOjXjIXWRSXw5GOzy41HE1NuIBEkMHzcTpVrVKwqBj9IocH8JCzyyA0OF0GbQDwYqzpeKLlNq1yJmQfEt1kqjedVxS74zO71QLU8O9N8d4mFmr4WGI6EK89W2hVGqp0W6q062rsNrRCt7SK7EWYyUHsqSrC5WM1cWAxImQgC0gvx+enWgxn2kRrJ3IvZzBSeb4TBh7VEzMVMiZghq1gwZFIXlIasXoa1uRYac1VrrRULREYyw1GZxcq+kl/quPRifqnwQ3D4aiEF6+Yt5G7Ng0MNwoA5ot2lql4/kaXDK0dyMQm9qmUPRTZlJkT4LREbqBnd5utXr/zb+mrz3+zYuZG66V+/U9+n+LZWKlRz/eiH5PmHvs6IEamY4fGHpgVyBeCv6dzB3MptbsN3b23q72DprVQwNjLaGZ5z6ey5/pke6x/Z/dSf/zBc3p9VtY/u2oqju/oP7r1vmVC9guFtZnDLKBiYTmbhfPziFvyHChoVAl0no4jR5KNsx89KN9640NF9bR2d/csOwIGqlaZtdRuHoYstnE5He7vaWen7kKQ0QKIF6xca1gJoGXIniKKa6HFbKxihvlKUbMpxdFYxUJKpTLEpACHI+mB5p6HHl8gOxEofGs0gpncq8cvW3NKx8EMyy5K+Icmc2SKEutXzeDceJYPxAmcRgfPeq7Ucj4w0YcZfiphroG0h24FZ5u12YEUU8P+ODg7ZQsO/sV9ini5t976wP6id+7uBG/S6VRKVEp4hVY7mHhT0MJGDK5Im6+1ANsG3R0sTdY2HRUHIR33w8eP7AhDZ3GwS0LEgfWEjx89sjbv/nN3vBn+jfav0MNGgMMbFx/qkz/6/cov52oXM9oWsWhbakuB7vuf83pGnoA7DRAb69EFlMczpIusgx41nw/m5jMcsSRC89rjob5z9Fh789v6M0ffqUU6p7+bvq+4N9a3jd80QsCIplWvqFEr+WAc9Ke6HIw1mi0VXYGk2LdNqWzBkjUz9gl1N7s1dHj4vNq6koB7WPlJdBrWn1m8mZ/pKPHTXVyeBmgXElpSBLIWsJME/rV7VsT6m0oL9gKueWDDoh8l8SSfr/sg5LtTMUA2Ozm91BMfktjVhVD1VbJvMAIjsalWrQRjc9ABPFrXRCxulSoUVakDZRMSPtbVZS/8zAp0BYQmNB8h7IIxCIYDZaMEgbuwTSB+TD8C1GwDh2jl5yAPWZQZrtLerzAuibd49m60XHDIR86KpZhCj91oVuzmZkLUfKFiJR9iFG2JiPQn+EQbyENWUszr3nN3DPGTslKpFT5+6NVtePKFZ5OpVmxOaNdcoWecWJAvZ31ycxFwV2Aj9iG72erJkyc6PjnWVZ/wzkS/5KDVYE3E4DVfZJPP2W+UTWO9Rnw9dediGQnkgBWzqQANkMju9A1gjAn5fBh3B+YnNyfoJ2FdLTVBroEhuNDalQwfbVKxSvWKdm4dqNxqapMHtgkbWwHLJLBu3IbWSAFmQYzntIG5u+Hp1VAjzNOhjxMaShalECJDRiBgFyZmQitP2Gzojrg1bBAwz/q9S+W11q3Djk0NFtO05qOJRvj2KcACvYu+Sr0rxXMo03kPzLkG0O95OOhYmaOxAVkKkAbaXehy0LdYl9lDlLAKMYjeGpotuirGzo5XvljR8f1P6suf+lU+8ErrhX7bl/6mZpNBmGEuFyEd3laAkWEtmzngplTKKRVnVIRlXAR6tf21rce6uzXdee5AR7c7KhTJixsEqQcLFL1ZdqtWca2/9MJb+h1vvaz3lyX9wKCtUmql33/wSFWbO0OzSzsuyCzHdeTuDGssunI2RQg8FurPWHPX8o+bF/MM5iJPnjz2/avUc9o76KhzdKNXpdt9qbpSHXMGO0rRBQTDCTYyKl/4IlTSnVZOudRc0xEEiJVnNns7Ta1aFFL4bmIUsNXae1TOTjgczrYuxP8znXIKDNcREwGTM+jKLa9hPJDTkkOFihumI+0vgApwOYHXkGSKIeyYKrTMTBFDAA7GNNaPJKAEmzMs3ahaIepYJ1dKm1y2mMxsEQcSgjzpqtdXo9XU3v6e4WN7xRZvZpSZ3ZpJYED7sJEtRP8atmlAa9LeEwIbMW9IdzIdOtyAQhomPCUrj9PFKeHCBf3Cb/gGlRttfe+0ra9kQr5cc3yuX/rj32cjCjqVySa4fI2nY2u08XkF2qPAuXfvtkbTmY26l3iiYtyNFKCVMyudQmM1HQcrO+ssg9gcO8JOraLSbKj/8MO/rT99/zdrlMrpb1U/q+2or89M3vHM3Zt8re7Nl3PRzOrl2m6A3DMTbgh5yE09EuB+YrUGzHp9kHDP0BUyBrFRPKxQitVNSDC5fnVbbSNXHLCgNKG4TyWyGDrU2Nm3iOoX85KKlYpNL7J5IM5gWdcfwhLtaLe9o1Sx5J9//PhYj5+ca5MOJg0wl1l7FJ42Xs/nbaCAhSEdJtIfDvfLXt+Zu6xZCtPUdWEA2sH+MwfVozDE4m9rPbuhWwLqMafg57b4w6ZM2um220YgXVc5WxNfWPyNmVPndXZ+mfxOLDZptNJKXa518gTf7ZaKpYzTVJAbMr+8vLpwwV+oAsFyRuHEFCLFbLBh60PQf/a9vLo7bc2XJd/TGwLYx3RQvvLKK0ETxUGBw8Z4pHanbTd8BOOrzVLTxUqlTkvNejfRpWEtFKt/2dfgahjMdk25rikuY1cUchLTha2yJZimBZWrhANngtZotdR0iKtPCPblsGYexZCeAwnyYBlW1ixWnxnZbKXldG6rsnqrYYhqEq013640WWAKABOxoFsHu04EwWIuhwC+WlAkdDdrd471dt2ateWYCz4PGw/JG+gj8XmdrgROO7wc2CzBHSMEtFTWeiMSTJgBbmO0QmlFm43Nk1sOapYuETIP+8FoO1pov404F7OFHRWKKS0mC6UqN/o+jAryzBsywBpZFbIpLeJIs2kwxLa2M8lspIOdRSNfjwucdRIzb7NPUZYsIAGQYxgso3ixCQ2e+6x+9jPfrdJsoNpiol//5CeVW0ME4mEBMmZBh/SXDNXfYq4i8+QceaIFM+twHSqWqGCxdpMazZJ2DxqqN9lcSU8Yqz+8CiQsE3VCsoT9V5cL/T/uf0V/+NGrGq9z+gf9fXXLef2uO2OV8iEEGzLsehMCv3mgQkJWYLkieyBqDDjR9WOSVnL9Iqi1tWnbDKM/QBaz0XDYU6p8M2NDNE5SC+uSzSKbBSbipGQmhRZRdnwCAZlN11rOKeDipBMtqI0GsbJPLKoKRcTmkVgaFEd8/gWdjCnvhAUHg3CKDUYDIABsrDCc2YSzZYKwmSFRmIxNhqGzCeYE80TPFgwTqLLZeJiZOfasEKB1CowQWxZE7HawiShOi+r3jrUAfs3kHYDbanX1mc9+1sbeURx5zKLazTXEMo1uErN7M5LtqBUMIp59sSk5UivPGkA/CEEneO3i2ZnZBtvI9YqsybGqpZzu3rmncrOp/2Z7oB/KdtSeXKgQzfUdX/h+bUAMHMAc+XNRMKVzGe0d7ltXid8zMC8az9kqMpseqYI1wk4ByQVTbQ6WBRpmNu604UNQCBCG/Z22MinmYxv96dTP6s/GL+g8VdTfOvplSh9v9W8tHyg1ntgeL7gkAS2HNAtOe0drQUphXxyNfL3NTOWgw8kL9xsL2z3FDoxcy2b4c8CyENieNedf2z7Tco1Eesc/m8PBZD1a2CrT8jwQpCzImhwfNV3MDFPSMIBecYhuV0sNriY+PDl4eXbi1SykiCTd5Ba2sghgRxfP2qfgwr1nZoMEtNgw/eFsVEhVqVVVLVet17YpgnNtgVJj5xPDBud70yWmshkzU5kpctDv7XV169aRLi4udHFx7kOsaje2nE3je8Oemxs+q/X2LlA3LoQZf5Ewdc2qNhLGbNOaleCKRhPAvQldeGDCz+ZIWCYqb5kTl2ziASIFwvGxHpQvf+IlwwWXZ+eaRQlxxxUBg3qs7DZmhtVVUaPb9MUDrloR5TSfq1mr6+pyovrOjjrdjg/CyWwc4LlWXY1uRZ1OQ50kIgWdpplWOEY4hTx4FQJdoeU0rJLK2Jg8Wo5cQbLo0nS9yVzLM+VsTpt0rAlapW2kFh6lnZZaXQ7DpWarhWY21I59aPJg05ECO+FpyfcsUwUiToedNVspEzOoziu7yTprcJ1mYw2RVnwGROmVchBY8xBkSTPhYV/HOjs+1vnllRcOcho2X1i7DNdbjbaKZYqEsWJoxU9vUk75dFkzNIfMHJUJC5TIGxNFgmvIIgLq4aBkdjjQhG48cRSiJuZh5brRzfIwwh5jG334/Dfp3U9/l6rzob7xrR/S/cEj/7nJEnIL7DQ6bcgooXoHBgXewGKBe4Wujs2JxYd+s1zLqVylcmuqs9v0YToYDy0WZx4KakDBci0hYX7FNedB+3P33tMHs5L+L08O9V8+aZv48V2Zt7VdQULhQMn7velY6AjQaUHgIiGGTpp/yQxjGn8Ueo03IVeyWKwqm4vVaJVVLGeVZj4dYlUd+FoBGk7HJnsFZmOYueHEQpbdww/fV69HIs1SnKGdZsfpFWiFyxWKBKBxROpLpbDMY56XZayAZjSYjiPsB+6G2JGGul8KlXQJy8YiVoAYOGOf1/KG1yfSzv6yQIpcYwy6gc7pUpgvBZsyIFSuK5U/OmbGB2wcQaO48MjAfr+bjR1iCtmKZ3wLIFZNgvxpE0J3uzs7/j3Xr0YN4/VKiIzwKCQwW9epj1bkbFwcGHR+aKTZ/CiccEyiiMvdObSTzTbaWGsMsWidyuqvDCv6p4WO9voP9e1v/FNVhpeGNCGzBI0vG24hBA0Aw7cadsVhqg5PgUKYjp3DyVB9YjZ+dn7m9eVNvlh8ikYxKwMZYBPmGm/WCP+3asZr/YeFK/1Uqq2/XnhVf/Pgl2nV+wl96+J93z8KCxyqinmM3Cfu7tmgWS+etRWCmb9Z5BuTVYPeeMOGT5Az0HUQ8pupaWvNMKO7fvkZT5EBy67DYUGRmjHixIdvwTjF0hN0akNDgiED9z0cVsFIPeNiiYLR8/skBxanLmZ/PsRREPhDBpOH6+IV6RAGCqyT4/MzEzUpkFh/dIwpyEsLMjU35MUnJLuNuSMQAR2B7liztdLlssdu7kIpHRnhTadPE0Ywh6ebDNFv+cBqR5VQLhpBA2WxthbbSbJL43BIMnt0ApUPU+SIq8D0NaLFPDTsBdfeE3wX/r01qg5dgL28Cc5PH+dBuUq6SGeoOWcO+AC8faY1DyZEB2QVedtGP32I+VJAksg2Xnjujg8u5pDp3bpK1TsWVLP5MRcql3Iq5jNaL5Ya9maumJBnAK9ieQWm7qTyRKyLCofqIgf8lscpZuzBLhBAUMVm3c1hnE3llGH43G2rsdtWvpJzsPFiDPwQqUr4cL0e0jiitbIKln3W6mVLhkMnvbGiaaQKGZBu24PnKpIN0raBJsHaM9kwi8Do3XO2IE4K+YKkYxjKCaJ14LDALkyZvVcYU33NdTEmcPe+rz1at70NWXBb6wGndJGuaIPGEJgOeG+6gKI9deWEPoiNhmoNaMjGEA7S5XshH5l50b3/6uf0/tf9ci+29vRSryzPVdvpqHd1Fap4Uh2CtUrAquzyAoN3a2YZbv6VWkvVOZvQynqqGhKFva46O21VqzUXLSQ9wLpE+8QiDg/KdVAzM+acVhEm2BPlpn19NpXRG6rqr5+39e56V981+QkXVN1uXasIHSrpDsQslZw0wLy2AszHPGg6Vbb20SE9GzWyIKCpvf22Do527Is5hR37OPmhFAQM2LUbs/soerhPNlpOrzQcT9Rp40na0KSycCe21901Y5SOGUeUVQxchJF9yZsZ8BjsWMOrwNeplA9FZygmBAegvfFs7A2TLjIPW3RDOPnEnQeyCshMHJh0aYizkXrQLXlt+XMHEhzrlVm0I6W41zFuSJiRF32A8cifX54bgr59eN8owZMnx56f82fpbDrdtvYPdlXY3mzeFEQ4cJHHGWFgD4zMdyh91CyT7oqOeLsBqvcp4fQUMFJGKUiU6FiGVyOvxelsou+vf6P+Vf62//yd46+qePlEUbBUMZrjYGdYysxo0ymblzdIriFuC/bshIQWGFd08SHajWIBRImDkEOAQ9t2lhidE/xMQeFnHRcvtNFxYtMW/JDvL97XbntfvUpF/6D9jYomVX139EibbEjPplOhi8Low00DeZi2sawHAwFLPijAw6zMwQPwAxqI+0tP1ynXkz3tOtaKF90p143v7rkjqAXPnNdhyoUZa4uxF93jfLZWw10bhwb7SdUG4DY7mM+Vw7SAqKxqVaPJQgvyPXlPDhMMNegW0zkbFbAHXnu/8ndMFWSS300oNYWX0Y/Z1EhZ4jnjw4uuD5KT3cE4SImqK9DV8+wX/F5kfqKggJ3a7/UTw5UwMrGBOqHk1YoPuEC6RNsNUWBrxDDXKNrTF9IkevcNaNUCm0MK7tCg5JFyecYbOnV7I7MezLYN3rh8J4wKPtaD8uriXOPBwPMF5AxUR/gBluoFxdlIrNNKvaJag6w/rNBamman6p0PvPjqlYoOD/ZtIABMh8dqtVVy2OjOXtuVE3BSCUeWXFo9Knr7DKaeLh7gJy4GBxtO9sxoPO8shPxH4J5CqWzHlpmTGOQDkkoTggkiWQtliwVHJOWKZEzWVIrXftCoiKjskBxwAA2vxup0uirlqnp49kSXJxfKpQva1PIajYY2Yrcof7VUex00pnR2WWBKP4TYdAXLrvQyRNhw44Ef2DTz25wa1ZoZh1e4ZMynajWqhmOX+IomqOCQDMZl3xg/LFbmBcChVJB0GhwYWWvbsOvDQxMSTOKeQTWLqQPsv1WAR+lgYfG9//K368OXv11bIOlJX3d+/O9qUk5Z1sDDiZsI1lJbDKTtEITWkuWFNowoGwgkdd197rZn0kArHKJ43NaaDT8ouHAwpyE0Fco9M1/+mY3M0FPS/ZMOQqd7eTGyYffz67lezJf1Tv5AP5l5TuNCSr/l7PMhrcbTeajzdGvoRkMqRogMW1pI7EDXZ14kihSmKWXjjNptZoM1+wYjGbnZ5Kk8sZED3grD/2u4y3FYsLNLaGFzujjt6YP3Huitqze1s7OjnZ2uttua1puFoDLk6CzitGZkenpGiEYsaH4hV9jKKyMzFy2Cjqja6Uywaow9f6ZLYg7HRsqfZfY2meI9igFC1exdG2SkU07goDgjuYLvQCdHRQ+6QSFFl4jom0r/yz/7mospft9gMHLBRhCAI73SaWtfORhTNOUJsAFln02a97RW2mOTEKD7kYMyde2FG/tacUBl0pDF6JyQIMzUvxypfz60J/F/vf8r9Frulv/s4embOvrwSyEphWSWHBB9PmS3cgADE5o3BhS/0en5pR48PtZ0NLa9YIDw2YAxIk+plKFDCYcUzwGdnlm5wJXAi8y+bXvH+oPPEJixFL8US7/k0ef15P6v1Thf1f+7+oo0y+hXjt51ogxJM6GCDO/HuuZ54PDh/l3PIH3YlMpJkDOHZpDPUITZEi5d9Z8/LgbHKV50ak6ryYNYrYxcAIMeHB15FMD+wH0kYB14EhSphqMOBTSeZ4mLGvccxQHJLUDLLk7TIfknmoRQaFscpkISB0QbCjcfKCA9SWeW40B1dmjQY3OgmYkerZSn+IK0BSRt8oytlkySdC4pVqCpgDLw2EIUggT3YPIgzHLt9Ur3nbKowbmZDpVG7ynbobpDJVZtCIHoSqXKgc7P+uqPB3r1M1/nUUYGxySKqsQ+MpgWrLSYMabAvJ4MUu5tyB61v60Dzz/mPEpnQaRJsYe5BHW4Zcccuodqu6vJHOJBWIBc5JDaHZK2OVA5WJcLSCUpFfEkbDRU79RVb8KiXPjBRErA75gnadR0XvlswUzXUNsHnR4asOFkqNRsrJ3ujvLVsop18vnmykDCSWU1uOo5VQSZhGE+EgIIv51NdHl5qWYHBiCJHDk73I+HzAsRwpKgEKK0gB3HqanWM2kywCt1q20+rYfHlzo97+mqP/RGUi+XXMlUi7hDlJ5Wkk4v92G5shMQ8KUd+Y3V581IhWVGFb8C2pux4W+M669vyJha48ARB5Yqs097gDI4R/eYJiFkphU+k4Z4ggnC0jMkHo4QnAtDkBcwSbmCzqykRWNPcbag7Gqhb/pv/7Ry84kWqZY2MeGzuA3ltYVZS7mYo3reuNulO+DAxV5wd7+jVquqhk3ri+60sfyaRStdXI5cTFxeXlicfu/ekSOyanUcZzlUPbZJRM9L21RdXgz8z+toqG+8+Du6eOU3aVDf15N0UxeXUzMtkSbt7jUMY5IoA9pg6HkOkWHiDZ+D6iMLPScdHHRdNdOJIWNyV8aD/fRn2NRwTglQKRpAm1xYgsBsnoePj5x1N8BhwRoim4/q/cMPKZA2qtYhMbU8C4VswwFMqHK1UrPbT7DySyeZfRhjo9kMpCSQEtYe4wDIORWyGP1ABy0mfzG2CPPHUAy0Wi3HssFMRcNLlBgC7WKp5vXBdZnPYMLW9P7DB7q6HGl/75ZG45kZ0rduN80NgKGOTV2lXggz4IjqKlwbYED0jaAIlmEl+abAls++wmcEHWBj5c8Fjat1jjASKXKJUcvk1Z/09DDb9H8+nF/qe578iAbEjGWAjVdOkLBRSLKncCCAUJGYc352qcePTuwDCnQ3Hk18fbcC1qTghYQXNkug8xhyE4cEBSWRXlhb2mPaLgLeqCkkKVhz2anXcWe70e9/8N/qz77wPVqmsnq4yunsqucCgai+DPeAg4k5JfNQ7CsrJV31L23th6MNs+fm03nj1nNBnqN6pepCkX2SJ5Pfff3iMERdsKRQS0MeAyYuuKg0jAjLE0MOSGsZoqJSDi73s7AKdnjsu4yjeoNLdZuNEOCeQ8KXV9a67ZwG8DqcxJKQk4CLC0iyQjTebIFXMOkgTe+3nBbxkhEXXq+k/2zMueh291z4m2kL2z2dt6wI71YecsYjIUNWGg9GPif4C+g4VQ73FRgUXS2JJjQ2cTrlgHGkKcgGmZnjZNYZt901j8cznX54omq7qXsvPqesi/lAfAMqDnsl0D9QNPJC9sbwDHlNJB7EwO8f60HJRsuFJkAQg/JCNa92taXDO/vOi+yPcoo2UWDELiMtJ3SeFe3tdFUtlDQZYHgLi3BtgXOzhpl13ovW0AMbMVmJw4EGw54rgEqxagmJzavRIGHqTORSYtfErGwFm4qlBuu2XlKl1VApV1ChUtJ6sVJ1K3UWHY0mUy3WxL6UNB6OFMVz04PL5Z0Qe2U9ZkbpOHlo5pi7l7SJUroa9rScM+wvGuZ78vhCD09O7FdrH1lgfijRa4wWyirX6kkFthWOfrBMicbCF5YHZtgfeDHgfFIy3BvgJaoobiIzUcgpqodrD518MCZfDniGLmWpfCmtcqWqVGZhpyMObYNCQDDJIQnc4YfA9m7sByF8eLxY6cHX/xI9Rqcm6df+0H+hfCmrVLGhWpmcwRB63W5VpeFU6TQRR+Q9Mjdp2PeUhJX7z9/RweGumi0qUbqxAMcRpHrVm+jk5Fzvv/dQp6en3qiuLnqGNF959b5arYo/C08dXYqzLAcTjUZTjYZzRYtY0Wisb/uRv6x/8iv/qAb5pv7+0a/Qr7/6lzqK4pAxWi1JzJXKreA7OYVVCVQcYsaefVl8vwnpJe7onJHKfO9mxsY/A5sxP8rnSkqV8HThQV87G/LygsKIfxcqUa5/yCOk018mtmSkkFzZRxNYeme3bVlLIHwEGG2RTtaLIaW05T0QVAhfDtFWIT2jWsLIPKwJDlaE+ZU6nVOIP6KT5toh7VguAgrSrO8YEqYRvjjp6eTkzH60gwHzNIzny+q2j3yYDnojky+q1ZwqdQw3qmp1K6HLZ57IyZIclJYiwK4tw4rElQih+kTFvY+mh0DgY9NlnOCZuO9x6FyA8dJaOM4q3czpHzV+qQa5loqblX7f+b9QqtNWNJ05tQX4LWgRgQFDKv0S6zOIKiOi5UZ29jLLlZCBHEkSVTOh4wIwL88fXS2yobU3SvaMchEuQMOfhY2YQ/tqPHyKJsAQN9wNcQpmcjalv5T9qn5n/Gn9TOMFdbaRftElWlOK+uC0A6sdcxFGD0hygouUzNy/VgpwD3lvDjwKL2B0QpFD9BcM0ZvCLpiDT13UEeBeybB+MoERzWwYFme01max0fxyEAg7SEbyxP7BtqYQLIJYmqXK88p3XTcpJNKao5vE6xkeBlIvJ0NtdHl15e/TqNZ98FH8wdjNcu8Sf1U6/WvbUohoIE58Lopj1mzDx3bWlnPZAgULLHwg1Zw/i5EUULU8qCTfGdLQNiSFrDYmYnIQ8zOe4XIYY1oxJ9Krbgkh8+p8qaoo2ur4ybl29ved+MOIgXED9wXImq7cvrPIQWhUPCflnA3SIZCPkFjyMR6UPPB45FkoiqlAOavufttQ62Q+8s2HfEMFnUFLBSSzXilfLKsIvJnLqI8PHy35Blx9YocF2E6ValnT4dSVIAfqhOqQG5PQzdlEOICym1Dps+sTPWVCTyFjRlsqn1GhVVG5U1M5XwrxWINYhUZZO+mUdrb7YVhcyqk/Ilh1qwgbriUGxkhatna+se5tBUNzpgIJCMupA4JxQQkHFYGja3sHbsG7tyuTjdLZgoaTmaL1mVotDpPA3rUjB3R6sh8LBVVrNV1cXrkadNVvk4aiYWfEwFT/fM4YjOS6SCFPDxYfqRiem6XcRQI5TOYzSz4g3ziCC5q6YxO8JBK4JMTxACuz+E7LXb390rf6vRun7+KCbEgQnRikjWYduI/uAEcRtJE8pDxicvbc/kHXNG3soOjMMjhd0I0uIYWktdpS8Y11eXHpjb5ehdwF4STrGSvMSAgYRKnRVdo0O8NBUVelNzXJg5lMowHLM6vnl6d6K3tXjxr39G51oW8snzrWrITMh5m4NyKglzCXA1blIH/2hS63uixrMhkpHgUdI5vCen1znenQyTPlUWej5cDk+7BJxeusOu1Dh4Kf48IEExBKOmSVPCy6nBqVRgJJoenKKZWJkxihlRbFnMknfDY2fhIzkJY4bQf4KwrsPKfOczynM2Ejc8B4WEs+IJ3/yNijnMBZeWlLp4Zt4kYp4M3JQg8+eKT3P3ikt995z8SOcrVpp6yDQ4wH0iISgBm7XbXWK3fpewfMWtMa9jFT2Ki8LDy1UVzhR4rPKLAeXqeOKioG44FnXsgitmu8UilUYGyGxAtGJnSXlpIVUvpX5bt6c7XvLuuw94HOzy7Ubu84UIGCY90b2IXLwe+0VXih8jkZJ5AVedWzJMxpRgXuUZDUMEsGMkxhgoLhdqWi2XykWqWkhtOJihb4oxkErrX7TeLKBKuWawoxr2hrPZ6XtS5Pj3W3eqAHpV39YOuT6py+r5dTa5WKkKGYjWP4HkYPaBxDGEEyVoiDjIOimY4Tqza+M+ciMhe+D3O+YPURXj5AGOnYiCFE5DHftUUokCEEO3McQNZGam+zKtfWWvUGqm/Kbkb4fmjKeY4ozkKwOeboBcVzDquQ2clewwycw2+GmcJirXURs/OJZ5DO4azUrIt3sLiJNTnttOAfcFitdHb5WCN0osjjcmTJpl2wN5pNo2eQnGAZszeFXF8YuiHGi/sEz8SoV7GkeYGsXNQCOIzx3AUj+VKl6tALzBbQglIkZzIFPXl0pr2DS917/m5AMhhzOQaSdYYOOZB4LKlxoExA4WgeHIH2cwyk/DkflLPx0C0s3n4sTDaCaovDLNZ4NLLgnsPBuiDie7Ypi1mj7NwVKIPc+Ry4MRgaL8YzzXtLDVx5A78yYEXfhMsDFGwwZcJ7SS4MHMs88Kzp05GNBjgogTIQ2G4LaTVaHXX39+3QUWqWlTvvaTnGAi+vYqZkn9Xzi43hjSoAAQAASURBVIskY41Dcq0pdlOVAG8CXWnDDAE2mLTA15CqnXTwBQciuYd0w4RPj6zN5EzyEs/kFMVLTa56IbOv21aJ/ENgHtwoFpHypZKajYZFxjFBuIWSq7dKmfkSes/IzNg5c81nHGP4nvwOx5rRKuDyMZ97UWAFOLEwF7INDygs0oDRB+q6OWeBlGQYLFDTr18vfekfajMbKl2ou/PZ221pb7dt2JUC7PCQwx95SJhxmBUHvJ1LazzuazDgYIcsEBLGPdNwJwFUPbS/pINe1yuVK7ixVPw5qO6A4/l2HBawiFuNsqbdmqtJO9viSKKU7q5/Wv9R4seKW86tg42ZryYKQhLBPmwTaxHRNS184JKW8ewLiNNm63xG1g432DXXzbWgMzs7uUgq2uAFy0ZVKbNJ0IFmfPgMhyN3Knj80knOl5NgZ1is+hAkWLrSwM2F9Ab8kANiwkyR70plzncns88wEISeGLnKyH/nAYdkw8HJBs7PUADwga+9VVmjzNEooob9vguQ3mVfERKp+doRWvj8zkYh0oqRSS+aaDZ96Gg5skEpcuu4QQGXFSAXwWqcWbhdxrRieNMtopkmJo3Nk7XFc8ChbrH9My/b1SljGI+OKMCekDqATTlM8BhuKD8uMsDy69ve+McaRSsHZHNd0+22HbYgCuYzG+VSsECBOImwKiib2hiKY8PlWafQ5fcisWJFAXua9FKtBrZuteBZKRs8myZzK+zcwjUl1Lzi7gkiiklWtncJOk/7t64v9KsWP62/fPtX+vP2B0ONUsGsmwMEYwq047BN+VCMBFjBLqgXkYtGrhmmLGa72u4TF5ycLUFDaPSNzIaDNrMO80HGoJNEYwsBD3IMBZ4hbvvOcpAyX4WSHgp8UC70ikBMFBqMUiiWMtcHwxrDBnr2IFvxDBW0aR0IUMCgFObA4/y5FGhGBV/VgjvzWqmsekLSg8H/5OxMY8hvPAMwuHPck4JqZeavWxeIyAK5nxnlVGIcVyoGL1iQHdjEFAyYbdRWTmgJnWzOfsu8LI3K5nV20dN0PteLn3hBtVpbp2fHevThEx0dHXl8QDGB9yyvYLQf4FY4Kp7R8h8ghUHu9Az2o3rrn78zD+whcuTWwK4lu2Ag2IdeixjfrC/BdlrboJzDgCpinkpphHQDGCUxSHflXCj7wZjgSziAul4yJBuYkFRCEHXAADfKkIvGTTbbUmFQzCCbQ3m58CFRaVTVbHVU7jS8mbS5aJmtFiUq9pK0xJCfQGlkGZH1hbkinyfjmCQzXYGUkHs417AYYLnNVhVIMpj94p6Szmqn1fTiX19carFeuQMOFnts2mtfkwomCWDg1ZJqaPUC20XFXEHVcs1mBK1W23MoKm7s8mawxoDvcP9IjW4ufjK78hyLWREHC+y8JPEeqjfkniyU92xglAbiABIH1kVgWHJIrvIVPfjMr/LbHr35I2otCUzF2i+jnU5Dhwe76rQbYUYMNEHyBll9iUEzvrrECU2mm+B9uo0MZzaTmBugGKJ2WKyIfh89PDdcxly71W7YbJoNDuiTzddUeqrM1Mq+qi8Ubym+G363KedU09tYfzB/rj9/vKcfmbX0S1MLfVOVKnRjYbzjwRzPtlKrXdXe3q5Om4lR7vUhOBlrPVkls+OcZ9/Ic0ijv37BpBvGE28SDx8c236Q2Kn8UVNnJz09OT7T6fmVr+e9e001mm1lJqNkI5Su+r3A6iy1fCBj5QhhI51iIwDKZv4LjDsMRg2GtEIOIAStzTzAqSsB3YXrF+bd3AUkRIQHhFEE51M2W9RyvtKDD499wKNVpgCk+CoXKspnypo06BylZr1tlxXgJjYplnS1kVO1mQ3ZoLs15csZLQdYp5GSwwF9U6xZ0uBZacjMtIYNdrBNFG5e3DOIVcimIBg5dimT1mgxNaKEnd17247+5SLMFb71wb9UDCyG6Hw09Ca602k5H3M5n7jz4DCbTNhr6AQip7e0mlXNp+PEDg9yVMqzcpAE5FXMqvG7NRM52ioDj8Axf2GEBAQKHJlJF3z4U9zSkfjYN/knxDPBF4CkVxye6pOZn9ZXDz+rn3nxF6vxxb+nnUJO+/s7NtiAsAUCki6QrFJ0RmO/PzKiwhyS60JxSNEYr+FdIGNJbCBw0LJ7TnhREKMM4PAALVvgWT1b+D0pqFnDNB8sC+4lKMh4PFUzT6OysYVhCjnNRiEAgsO7WHDYRForPXpypeUMb+fAircJQyrYCGI3BynIEpssMYNLLVdDE8kqxZx2Ox0zdxmvse75TN5/6H5pjpYgfDy3oelhXykVYSFj3pJRjvGBGbXIuNZmGjORYE8AqdxuKw6I6I9id6XVSjMQsWKsQodm65LOtD8hAaSts7NzHT8609mTC5PFcpUgyQm2eeyBgYgXyFsJSSnZH+n+3VB8nAelY3kqJVUbFTV36zYOx5EEATc3DSu61XRpUTUU3latEWKTcK1IGEkhxR2NWk7dbkPpLAfTwCLr095VqADcPYWODqgzD7GgyoIJfaWdaPAejGDSBbEslkbNdlvZYsnzudmYai+tTS6tbCmv6SB4FF6eXKp31TebcbqcK78KTg58JjRozL3QP+VgerqDCunBVHHWAWGbhZdnLqNbZjludA4E5AzHoQ8izNW59EGnhHNHSu02LMK0FzsdEkxaDrpWK6TH81Db7mqzcvLBEi3as44RGFEzc8DrdLH0vHZB1TWbuYL0rU7kFtbOOYmcwiKwGFkYwLImpeRKGuw978/aHZ2qmd0a74ecdXi4b0iVquz07MwUcDoqZjD8jmDVFYJes3ls9laq1Us2r4fURccIOQpNbQ6tWfEFNRs1jYYBzsLxpkFcFQIiw4aB/m5yRZZDNqdqOQhZmHuYMJIY8n92jlxmVx8s8hpl0G4Sr4OxPrNeQn7JmWuYgWpCjgVUNy8cnkopJCzB2Wm93Dhot9+7OSj5DLk0/pF9z/JefP4FJ1ucnl7pzbc+cIeJ8w/zFjZoKPo8zKEjhAg2F7GT80VOK01VLMHORIC/cBftb8aBMB25mCuRKE/OJbMsnIc4FJJuPzCCw1iAIgConfXGhmqyDkSuVEG5NEgMGwN+y0XttHe01257I5xMljbAOLvk+5TUaDW0f3tXtSb+xbEq9bSqjbxazYoyeTbj8DsgbC0dI3WzeXsW59irnPWddM58hkn8NOImOSkDCYprRFoL3wcYls/3wfsP9OTxmd4sPa+Hd0L+5guT48BiBV4rME8r+MCplXGHmfswYz46hBdRKtnrl0zEnXZTi+lEs8lIy8S5h06t026p06KzXDug2Trf1EZxhlnwxH8GGHKGvMNuO7XgS2yiT7AEpKPnILV1HBaTGJlfnKqT3ZEOPqOL7j1NVmvVyD9Nb3z/qrUQfl4kLqoOoxqC2iyBHQNRi99D90rk4Hq9dIHIPkVX/LCREBJATbptVUDqkHph9wkJyKOK66QcOA2kmWDAQkFFwTdRuRpm27aBi4MpPYpngsKwZkxtci4iOJnoLvndFN7o44f44zLSSfyTa3wHhdn7arUSTnmbekUHu7s+eK6urtQf9J8ekrbrVNqMe0ZvYfpDsQi8vVStglFMzevceynkp1xauVpF5VKcaGZpWjFwxwqVuCb8bCtmw/cvBt73OOzSy5SuBgMnPlUrDV1dnemrr72uxXqio+f2bd/I9TcCV8iqWC75jMk/laV56Zk4yfn1sR6U4NFY/8DoM6y0XpiWDb0XQ2gsjNjwwe1hnwGhoDGys8R6qyUUZSjEUH4LgVV31R/rnXc+0MC2U0FvCImHTdiyguVSO6muKrmKYV+o7hzIVMvM96ASw06rVjqWFxw/OtfDR490cXam2XSidqOpZrGh8flI8XSNosDuFWgQ6WjZjEzagflprU8wC2DDhM3HQmJljhcj33xgi4jqkz+fz+nW7o5vxkV/oN5w5J8/PNgzIebaIIGK+7paXS7DLBdICnwcdi/0fEzVp8sANVxrjdLNENrMiweBJJBoDcyMRot55MYPEuxAYIWtQ2WDJyOCbHdOzoOkk+SwD2nvn/+uP+L3/MSjL+qzk/dV6dbVbte0v9dRo4HZOeb1fT15cqrxbKFOZ8dwrn0qFVJhmEOzkGEs7+52/HelY3fq8QJ948YP0263Ybeh5WJrFyGgT9xktlpZOM7nBlxldusYtlTQQzELZ2bRhJhVLnvOWlnF+lO5U/0f3zzQ/+HL+3q+9L5uF1eq15peUzvdou3IKBYgD50XzqSb0ImgV5yHDEpSFpB/XFsd3vwMQu2Q0Xnr6DntHxzoZ7/8lt5996H6vbGrdQqBdrvlmefuXtvpHKenJ3YvIQWn1Wy6YxmMrpy2TuDxcok/6MAhyRyGzKXNAN3E9iitx8wt6QaCyTmHI+xOmOawi73lZTKG07gWo9EoseSbahsHzWAI+A2C6u7uro4fPVFv0DMjdz6ZGvZDUI9ByN17ByqUcVVi441slMCGOBuN/b7LOXpPKu4bWNpdpC0LMTUouqhkcxxtvsbZBOkEiFGF8HB0oYm9ZSFrPfPPXMz0A9/yq/2jv+7xD+t2Xlrs7uv48WM/B8DWdNtFd+JlH7gUqo1mS5PZ0gUk6FalmneE2GRSsm6Ugq7fu3AxRo7kNi6rVS8Lz4Rom9bFcOgiknmgZ1Txxt1SJV1Xs93S2dWlO6s61nhFRiKwUvFRnhimh1X88tkbOqvs663b36B//qv+9/qt//Iv2Eyl065rp9uyeL53cWZJD3sfhSrsdiBf+7rms9ptN2y/uI5yKlCUUrRhxVm42YrhAWTmE8O0mIa4CDBPgeIo8AUoXOBlMO9H34o5BgUy8DNmAdqkE57Iws48rP9UHIhiFOqxsspzn7NZk3j4HsCwzmktoHsNs3/m86l08M4O+ZnAzHSeyHBC+g0IBJ0/xTjlqREsd+VrNTxqSalaCcROEqDGw4EhY4+D+F1buQAK5ilhfgxRCMkbyoono6GfSeQjWeJyMim7DLGPEzqNPepbb7zjvQMolyQdorZAQTKbYIxBgZxKhcLP13y1NWI0GXzMByX0ewI3SWqN07iJFLSY4U6ytTsDX5y0islsrnK16oPGU0THc62trQMHBEaFNTtFE7aYa86cbY4In8FyWbPlShVyCxvNkDwyGjn3sdUKuXJAZRyq0MBPTgfOOdvb2zgZmwU5v1hp8HjqjiU/mWqdi5UnkopswRh4OMCRbPxsBqUc1ddG8+nMmxwHIr9jtVhqGq3Vae94cyVJ2wGpuFKQqRbNNZrOVc4XdP/2kW2w2NygYlM1GRK0vRNMyuAiwVy1XWv5Wl71LjVCUzYZmpDjnEvPTsI8ER/J69daKY0pCoC1tkCsbFjIBvqKwIjQfgITY2tGUe/JJC4WkJQDrRwCgwONMSdAgF/I6rlbO+q0ayqU0jo6wnotpavelS4vx1puc3Y5Go6ZmRHQGuLP0tirFbKeATZbQGsZQyUMybepYNfF3GW1oECakVmSwIRoBWc+LKk/8M2k46Z7Z+MKsHxKRSrmLBIJ9KBLbSEepDOqlWqqOd5Jnt/mc5hUV0Mnt5y7oz49fS8YpUOnb32UzGMxdbbm2RlMVtPtSbQAk6dZ5fpHC0001Ysvv6jDg7u6uhrr7OLcDyVG/s5I7TT00vNH2t1rqlSFsLPVwWFT6Uzk7xJvcIghJq5q4TcbS7u5Y3hwkB26Omc2HdxbouBpDPGkCGpC8PbSqARdGdcMMgKHJJrYIJMicKBiOJb7gQ9qOkWMmrR/+5b29vb11rvvadifWA9IJ1/j0ePaFrLuxKqYrecj62I9i4dFDWmDcUiupEiRafMWvicvCjsgSDZFnmeCCTi0882PznhgJK5iYDVcoTLKFSteu9liWp/+hq/T2+PXtTGzV7o4O9fVduh5V7XRNBmGze786lS3jw5VMVkkMqsbYX28CfZ/d567ZaPsTXquUjWtJ48zmgxJo0AukdbBble1clblIuL8gkq7HZNhmOcXSxWHJFz1huqPh/Y3bTZaJrVkcmQw1kKaCfaWHNilvA3AgeuRJnEdefEcAWeWMI9ASjad+L9hATeH67DaqgRvAQlKAZOJrHZ3MKuAvVzUFsN92KmFoscQb4AZJq9GvaSrwYW12tfQIAgXzwioUmBab5VJnjVGrTwaPP3M+UhVMmGpWvZzmCnSSQYVgglrIFvblNM60PD2HeAa8E87H1EsTsbWpNONbWfBbADOCNcfr2nIaxT/SGWyGfTb2N2NjRAF16yUZ5PArfl02kxlOCjArsjUbd+Odt1cga3n/dksM2j+C+sFO9OKHjx+bEIUMGlkBJHZLqHUE52enumF55/T22++6WKpOV7o+OGFivmyASUOfNjJ1ig73Jr9i/FAyuEV0/FS8TL7MesoSQLZBmeZ1AIT4HVS9VKdB+IB8AoG2rj0wDKzv6gbnISVhheog5KZyYXhNw/DxcXUbva5HHqblHZ3atrd2VW1zE2Zaj5aaDY88eExmXLobLXepPXk5ExX/YHeLx+76tvrdn1gVFIVrbCtipiZxtriOWk/TDwD2VgXwZiY8mVDZiR+nsGgmGqaTYBZI/NLhvk8JCwMug3gBDoBhO1UfMVs0cy6arls+nmYRwZMfQK9ernQ48ePTeEG1jk+O7OQn8Me5xWnkptmHpLMrx08HBH0tEhZagg1ngWKvqgQwmf5DPPVwlaB4bNBdFoFb1yE1t4EFyEXTuT+4UYSZG1oW9upim4d7SlXAgZu6+T0Qm+8+a4Go7mq1ZZq1YYrRth5wOH4l2bjrUrVuvb2u0pn+b1Y6kEawGQ5m6AISWakI3/mnqMyG+aaAD9x/615TWBhKsk4nrkL4Vozv9hMgXPWLk6ATOwo9Mw1obIG6oRRGMylYVIvgiXglg39o2w2KmWqb7uMbIMpNvMLSC3XL6Dbz977eietL5ax3nvvQ6fNw/aji5nNxqrXjtSoU/Eioh57hm6SW7fmUQHrHMSB30+Xd3V1qTlwWLWi/YND32c6D1iRdElY6+EGxOfx90Z4nfiGOpDFRuixPVK5FiEdLmjfnL9XyOrW7QPt7x+q09q1lIdDYDYjq5MRR/hMHKqz6Vj9wbkur3Lq7NWUyyOLgtG6sftVqUC3wyR+4Xm+to2n14YDvbDh2WMePA9m1ujiOGyeebERo4dVqqx8hUIm2DRyLZDofOqzn5SSPzIYDXS+vDC82u42ffCAOMDAxTMYNxkgQjS5Hzx4YGvCO3du69a9fVWqdOV7inc7zqLFxGCBQ00dRKus5QLrNK7BQpkMY4EQlWXvYhvYYIuFthpLxbyanbZyYztI+zuuQMJwbbL9G0S4oslMH4nDsuVbQG8gArEfeI4MrLsFNs9pt9s1ugb5DSIeGz4Ig7N9VfZBx7oaFapScrn5+UkhzK8hWPG5ef7C+g+MWSomuCG4UZEYQ5HAfJdrSGHMDHE2GvrfoxVabbYOcof4+OgJ83uC62t2tmnUayYEhjgyoHc6TdYizysERpjVASG76F3ZZc3XaJ3oI70rEtReT8gywcQLKQ77LOgaOle6QieTcNDbwzaw8kEMqhViGclPTRk988x2S3dZdJamw9Yxlmc1w1glHMMa2UyQOg37zgJuT0J6EANa1hHpTxQQdlmDHBpvPdfHqH9wNdJs8lFjkp/3Qekvn0urWC6qVCWoGdJLsiFsYbZtNRxP9cGHj9Gm697tQ+122974/DPQpzMZs6eIqsF8nCgednjbOTHzqaa0v7Ovg/0jZ5LhTA8TC30dDwnJFdi2kVg9XUS6OO3rqt/X+bavMun0aajfKcPAuVReG0JE0aBt0u6CoM5zmphq7xlWIIwwtHcCB6G/dvdg/rXy5sxcgIrXodE8ZHymLRsP2WqhuuTA4oACFuVVa9StsZsuI11cPXGlVW013Bk8OcYujCjpMEaznRurKjGvZsGFLumGJIFN1/qyF8zNHQBbeepvCJzEHBSownmMccjG4/1yXPRNbBE0M9gv3v+3vdB2NxN9rjbTJ+497//GzTk+vtJXX39Xjx/jsQmlnxsOrF1WCoZcNqvDo10dHOIBCjGJpAJcN7auDCk46GNtp+dZ8tpd/jX5g4PSGlGgGBM8qDqpjL3lG9JDguOkc0OEqadJDdY2xhvtb1P6hbWCvjCu6y++XdAfvv3EId3IHux2wuadxOZQxH10+eIZipdp0Jhav8kBGN08KBAtdrolTcczPXr4SCfHD83eXa0nPlybza67aLSEVM3rLe4laZUwiK6GjEzPj5LOn+2DuRkuUJtprFaz4wOTDQN5FAcsCSuklKCNazbbwVAisSGzf27ICPImyVyTZ8g+tBgZeM62sTtSIV+x8fVXvvLTOr+Yqn8xUmaT1353TzvoE1dTXQxP9ODhu4ozQzV3PuN4OgoORg+D/kLz6Url4laLGfKd2LPPp68U3SzdMHKgYO+Ir+hVlLTjyYtiBcSErs26T8/s13aI2aRT+oHUS/65g9472onOtYwm6g+QhtzTnTv7nl8jMKdTRyzPdQFxoSCeTxfBljG90ideeU77+x1tCmQzFrS/d9sbH/7PdsnJbxVHFFJzffj++1pi2rHFvSYKeZwgRjMg/pzmdYq2kHvLPfOMn6QiOtgshiS4zkRGhr5+fqpH0XPq56r6wp1v1K+Zvm1SDPc4uPwEiReyJs8mvU+AmgRCJNa4OOtMRxNNR1MfijBmI1qd5IX0B15DbzDRbDEIhWRSRAd7OVKb0p5D2+SlgMSkEpilju9aaXjVd1PDnJY/XynXtV6ldHF15f2IDpr9vMb4ZL/r5wY2LyYrMFcrtbq13fBPVp6RTzRFyrGKdOvWLecHl8ur5PAJ5Mo6toAZdN4h5Jp5KbN8ngEaEDgIVjJQbGFQTyiAgxGAwqVckfVS8Vq/uLx0ihENZ6VYtlOVQ+Ux3thiCB9SmmDrIvOBTIq8xaktk6nKVT4Xe3VyeCF/YW0Sep8im3KhBx8+1mz8MaeH0JLTuYDxoGlEfRyPl/4Cm+tcxClYcMbm0b3qyObHDIs3yeKj/Q2WbgHjhhjBxsgNBg6iNTekAIEGZw93IhsNL2Y+LCHdlEpEVeU1H021GCOToLvdqlGqm+llk2fstai+hSdlSOxGe7VKqi3bcyUifzqzwHoFItzaZSfMKdngc2bUstjNXKPjxBbJTDAOj4IySWwWbT2V5wxDaNLFsxk/jAzhIzoCPG8VaYnQnA5otfZGY6Fxwkq1tg9mKkQd+3KGF4eh0HmtiE7C2AEYNGQ/AurbqiyZI8GijdBZIQmggy/mzBAk+eGD+9/g33WQ3+pznWA/5iSJ/tjsVAT16TRBssxNYCpHHqgX8lvt7LR1/3ko2AWnV7iKtNYrtlyIRBjgIQ5HTAUgcNHtUW0X66GyXKfYBHFqCj6SdNLOi3P3hdF8wQSbeUQ3s1KzRfBv8N7EyqwT9/RCdqgvqK5/cFrT791duTAql8kPDekvQEkc1Bysz77YzOgoKejsX+mg6lilzc0jwJxnMRlpNBw4iuqFF26ru9PVVY9uHhivoeeZ7+WwRpy7kCpV8ia4uVAC7s8jsA7rha4RuJb1x/ebLWZGGZyUUIDhFz4j383dDRwHI+l568v4Z2dWRsyCmHXXfAhcR1lRNa9i2H1EexX03jvv68d+/Ec1nfCfCmrXutrb2bOcJ71aqbIu4G6sepNuLKwbPCmA0v77n3xNH773RI1GQ41GRbdv7bnTvH5BHiEhCBh+4xABTMZLSpN2/uw+wSFfYuMCmguHhKv5XPAi/WeDpn/u7vpCX7fDCOHQmum9PTxQgwCf+wDicHF1oRhHKpArhPle67EePzlBjRXsEk0q2mqVtN8OQ9gE+H2bS/tgzaTnAdVKp4zinJ/33Ply3fBp5sDiMLCpN8WlkUg6OKKtQhEXWNhr3R09UX01VT9f02s7r+hXT94KzNYlaxsJRnDQCgVNKiApm63hVljt0XAaeBtJTB52e8xC42fUTKBrw8HQciGuA0Ujs1oKfCNH6YCKANowiyuUQnFqVJikjMlMw17f+9GmhoRpYZcmyFoPnzwOxi+MnmbQ43bMEjeh7OTUftN0dowMnLZRKqlex1ZzZindZBq+X7FZdoOxWo3C4Wwj/uDWA9IDekRhQOO+QDOPfKdRN4mM+8m8n3vAfkqRQlmZL5ddODJqwrCDPYaGAxMJ/PjRx1tKlsuYGNRtNO1shvvOdcIK+w/Zp208obkv82VIvinV3dAQccchDztihMPTSf/jPShrLYKYUU1urWOxIDveatAfatCbOlaFzZBUcxziGbyPp3PKAUNKRE85ODXpDIE0xyM8QAkq3bHNEfsGMAKmvTM7X8Weg85GwAhRmNuwUHCXGcw0GyNu5mEpqtPser6SyW0VUQ1aZA8EgP1YcPKh+uL3wcICE6dCIbG81xuYkbtcVrRZYv1FziFQIjZQsM2WGozG1j5RyYDTx0BjHBZAgIjp02m1mi1XSZBsHJ46HGqEGTM2TGU+Wy6I95kZGk4Mg2w+q/WPPOQWaLPIbiqdp0URm7thxEipOG3oGicLSDzINoC6cb9I2wR9o2oFhmTZf683C4Y5ffAul/rZL79mM+xbt+5Z1wYcCquQg5dNDQJGsVywh+9LLz2v23duuYvBR5XqGFgIDSV6Q/6KFsgexiaP8PkMnZlQFNxZnF3paCxQhNDxOaiYeRxuRcOp4bOry6FGUwKmYx0c7TnKjcqUKnQyhRx10ylmUiHOLJcdJ8HdZDYCs9gk7iPr93/5y77H0omwmSf+wfzfoiZ99R3/779w9z/XX/nm730aTfWUHWetYIDELQZPQmjD3oxkKeDZnicl2aPhnxPfh/BbE7iSTix8jqfU9Kc/F37GjFcoUWZeI6cKxCOKo+vPHhSo4T34Z/v+/oKVZv8rmKvh+19LYa4/czDjD4cW3ZN/e5CTavmLkjk6MD1pKdmsFj/xv5P+xR/37/utv+5/I+VGIRA5MT3gcyLdefaFJAJ2MIcLwAbdVToTm9Ri44DkdXR0oM+98Its7WfLOWB7vnPMWg7ZnZhla0tngI4TKDXvAw9MfzZd6vzsyrNdk/GQeUzmWs5nJtq1m1XDjo4YK5W0Gs+9huiUI7SRHKDIEZwriS0bOk3g+BBKTSLNfAliEmw5IS8CwdPN2Y4uWUdcpxAOHKz72AeI1qPg5/cMBkTaEbKNEQB739SjGv63vVnX5CZuNCr71HqKIFkb7mvMqCLyge5cZheG5OkWlAXSheGJqB8PZ0KdLdOjuyKEIDbUSXPDnn3RZ+STpAEl5ubsi6wze0IjnWFPyWTsGXx6cRlM5MvkwAannOk6IZMVyiH3cjw0O7tC2kgKRIHrNn9q+8hawSCB35FbrJXK8Z0DjLyiw1+EfQspCoVEfzTS6cW5LoaD4K5jG7qgzQbZAwamAIE9TIoUSF8Ib4ZDgtyMVKQoJCutwjyW9Y9TVLGY0SS18JpE67nT3tfV2UctGH/eB2W5ATEBbUvaXRIPSrQm7WGsx4/P7WjTbXeUS0NkaDo9nsoYVxGqoXqjbtx/PIXQgEYqOM0zU2nUgv6HxHWqAx5AJB6w+tgY53SuSxYjsA/SjazNrOkWmWO0W117viIZ4SZvgQtwo3enhpg9bHCOwclQ5eG3SLWpINifTH1o86Bl9jrGvIEyMOddAx/aUzNQpVNOSofWD0iUth4TdqE3uyTaBe3vYrV2tBfVETooWLEF3IWwbsov/UC5OwR3T7qqEMeDJRZzqWeqef4fsxGgBKKf6ARinD7yvmbMs1jkzD7QKUEGYWMiIBXqOYkspVJISOdFYfDDP/wTLlYePrrSrdu3tLu3o1u3933YcM/MbFsv9OLLt7S33/FBzffPYfw+n7vyDAcHGXIrjWcTMz8No9pncxNkEw5Uhs0ZZo9+/3zRAm8gzpQ70IUePDzVB++fazwJszks1UrlptarkTbbseEcZiLTuJ34w0pvv3usOnKSzdayFuYa4XMzP/7oBn5Z+ihE+PSVojtONqjsSOPSqf5/9sW46BmP4P9Jr3+d5WV+8tHrVxz/G9/m0eNjvXnynvZIH8njNRtiyoBfbYn3jJ8pjk4I0jls7U+aw2JRPlxYSzATnbu5Zi6VTQ53nHAqFpsv5hsXZ5XqxsQdsjSHvZ61ecMBz0ExMIWZSy1BacJMC0MKGJs8YuBOOVjDhBlvKS4poJGErDVbBBccR+6tMf+GIwA/IHk2KWqjyIW04VWKizlQPfNrQqSxYxwlzzLXge4WrkDZ83xGDHTZvB2b/PULxn8pFYwAQN+o0OnUmLkhJ0KfatP7FSOamUbjtbrdMNKgQIJBTdNwdnGqXrmvgztHZpdut4Mgf7E2NaQBsfednpzpsndlcgwoAbCsjcrJqb3CS3dsdy/nOzrpJ9jp0ZVSrGPfh356uVqoN7h6OgbhBfpGU8IePGOuOJ25MOB+h59JEBjkaxSlqZTPF7pwd5yjscr5og/FQiOvbqcTbOo4hxLPYwweKMILxZIK5Yr5Fly7crGibYqkk2DCwP0aD6Ya9mcq5mu2SO22Qnbyx3ZQEiXkkouMSaQIVGYRGsilFwfYLwyoQi5ljSQbqh0QfFhxKBElROTQOplNAT9Ad06GdfZZnJoUU6zVfIAw71gsEhnIGuIFmz3D8+CyEGC/nGEW3p/NdMnnW3AQUeHx9Zxllbjhh/URjHEj+7bC4HMSN9XVfK5qKatmo6ltKqsZB8Bk7G4PthlQGGYCHGoW1+J2P5+52wTugSUKuxcY1dWVE8q5ZmkNCH6NVmq0Wl6010Lta7PkpxsIn5hD8RkPwhAZlFGK9AfmVckck5810YVEcuQOLO54rWKtrGYD2UdTFeYZWZiSpdD5GEaTavW2dvaCswzXCpP0erOWpICXEjP5rKqNkmazpYZDgpFhOq4MxwB94P3q5PjV0lA5Dyp/FnYlBsR2BkqS2WFMBlgUbRVQYdkEAhY7By3fjw0VOI0Db2dn13o9ugpExXOcaNYbzRp3JGq2rfTaz76tF+/vqdMCGoKgQ9cUHuh8vCe997l/88KOnsG8rl74uf2Z/395cT2uXx98u5T/N1PpR6dZfeW1t0wQ6XRrytDt5be2N5w/A4fTAUwnI1eBdFwUyrPNzHvA+fmF/YwZ43CoUGwxHgHeBgrf3en6wDEMl8ZQQDof9i3lYK2ugZ0SZypi3lrdrkXw8Wai4jalnVxB8wUG+jP78ZoBbRLa2gezkRkYrSvQieDKBdQJJMzGfI3M0BWNYa2PydWsBWlWhpSTjYX4wIdBUlRUioPFJKGQ/tPK4CcL+3nsUQP72vXr/KKn3QpB2aB4dIPTADfWSGbCOxZ4k30XO0iag6Dj7jbrNjFfrpmnt334hY4q69mfmbuGonnOwpyZzovDvH85COEKzOydjhK6eLrSjALMzpiIg5KD2NpXpyEFspP3rAQNoHu0bpRoKw5uuueI6z31Pk3DYl4IhTfNwnKqIcxW9gXkOeWyMtOpjxug0ggDmFVktI7DHfLVbD5Vf9zXMl7aec2IVbIXsn8jU+Q708VPp0OnjtAIXZ72dPz4UhtGBnFWw8HH3FEGV5gEythIl5cDG40zm4TEQMXIhYP5ZB1QGgydA2brqgMXlF4fs/OKagyWYdv5pgDb4QQB2ytvBxcovWsPxBHU5pSLNsok50mvB9xSCuQioFRov5vY8wzYtgEODW74dDAWn29woA83mc7L8zE64hWbKp0ds0JgJMy5F+HwM3yKdnHtBAAgC2/AVHL28+QAxz5uGuCLlAwbTIBAEbpiqwW7E2gQ+68EzuPwN3OORYC+B7JLEgXETb4+BPlO16/ruJvtNWHFHrghusZaIcM9DN6JyEE7CQWdDSDjYX6jUVN3v6XseWCi8nuq9Yb1Xp1Cwd0YkWVUfxxwdJLjGZ1/ZCSAB9N2YVV0iivP3ax9mkxckTp9HZo499tZpMH4mMOP38VDgy0VVTEdP3IONI/uJJgnpdK6//xd3X/+JZ2f9339+e/1BhZvG2+cNixfrLSu3Gy2iI3v3Lpn3ZivGZBO8pAuP/ik9N/9oP4nvX7q3wt//c+v/+Hr+/7Rz+nHUqd/UfH6DTOGO1+s6FPf8KIOjlqeW86QeiUvk7mSFBVDoqBMNtMfaY4hfrT1nG6UiRIINyANEPz45+kUKUGYVVEkMeNt1FuGKFdIs0yaDMkUZg1DJDRkyfpA07wKOkcQlyJwI2bv2E0ykAm+D+iCaQzYj6y9LhXUrHPg3HTGtm00OTCB45PvdO2m5VkkDFcXqTBelybzcbDms8zVA2QYAPTwopnoLWd+9kiGqTfrLsTRpAI9emRB+He01snJY60WA+sgIco4IxPiJESXUsVIjhngfL44thn5Bl0l/IsYtnPBewLEIPTpfEbQGM9YnQHJfkF4RCXA5NwMd9xzF/t2HNpuDcfacKFYdAfKtUJHXDTzfe3CJ4wdbO4cXIGC+WpyjZnhT53sxHnBnomHNUhaoUwqU1UFrE6RFfV6Oj55rOF4qFq7rjv37nj/tVsZZ0ocIODtum6bwWajnRgLLHR4eEvLeUr9XiiqWEsf60F5dnZp7aTxfiQX24xqjbYePjjzpl0qQxDAIJpKIngw0tGw8Fh5LCQqK5hg0JIRSkPTXS1j64LQK4XuKGuY5LpzokMAf8/nCtZsEg20WOBtim5wa7YZFVe8ZaMOcUVUPswYQmuf8aEJ84ooKyAfBLq04sHCKuB4UaOi+RymZdqwIO44aDqBj8PMKrheoM0B748VSD1oQQ3MInugakSuACNrUw5VFWQmd88hQouKzrmsHHRg9s9cYwf6brearmZPPxcvcPfkqTTsatkvXTFdtw/IvDVLiH7LhZxarZr297s63Kcrq7mbA2oOQyny6Ao6uh0c99vtjg+Zs8tzjccDbwro9KCxQybQw6wh9YOjfbMgqTqnE4hVOOIEkwBT5LMhCA1WKYUTDyKFDJZToU3m2jNog2+AvAfpR9qmAteaFWa3nd2ymptiIp5nU6hqND7U66+/Z83s0sbrARn49Kc/qf3dpsolutFwbdmUgjzjoyST//n1/50XhSv3mDn9V15/Q+V6Vt3dhg0HyuUbXBh0w2QWGOMrEnLIJlyrD/dgCguV0GDY5tJkhpcuJLySoVqH/kaMSgIJz4dgKRTyjUZTcz5DColB0eSkPAcMM3M/ixToSI9WtlxETA9KAmmNvSqQdxgVEfYwUz+amISH6xTGHJjaX2dwekSAwUENqQ37X8md0mZMHFlIzUi+bSh0mZ1f7zfE74GubUP+47PkPTqnLXm5+ZxdxHiO7HBUKKrZbho65pl2gFuMhWE/7C1c/1xO0/7Uc05L0jLBDpL9p1mv+S/2WfZS4F/GNPA07H2bQ+LG/sKGzQglp1KuHMKsVxuVqgUTlpiz4jJGU8GL6zWbwchnxIML08wMcrTEF5cDzegkCS1IIgZsDp+iYQidv+3kfH6i/V57bdjpJw6h6Zw59VZT+XJJvdFQl5fn/ot9HwUP1pPMqXEK42CHUbxYpNRslK23xWIT5LBSKjtdp1xsOwXo4YfHeu21Nz/eg/Lk+NTUfvBfrIo227Ra2GXtDUzUWc7mKlKR5UgVSKtaw08ykCtsc0TETQUYBeuw4HLCQFblQEuwHVgqePTh8EDAM3BJBAU6gwi36nkYRITJNFCNkargtQoI6YrOsSk2Nw1+p7hV0F3garOc28aKqhEsnDkGhwsHZjudUqfVcBUSUjq2ihcLpTgomYuYhIG3KQd6yUwtHgLHyQIDW8yKLRsVFnT1jCuhgOmHw43sOxY3cxjj88zwWDkMtaNIa6ecExMT/vuzOkAnG7AhmB2ac/W0ZXdxlbhxtE61WlKJB7xe0dHhnu7ePlCtWgyazs3KQcPr7QsMUl2JNztEYxWdvvLwg8f64IMPjf0zj3SRRxROqaA+UgMNfJ1oxDEix/kiWy+HDahIx8h9QxaweMrKs2wEiNoJCByeIeyVh4Pix2QlUgQgeWyRFo1CLFKNue3GTDt0gpPZlZ5/8ZYOjw50cdHTk8s9/XSyp9y7uy9FwR0KJjMP6XWAcXV1c1D+sYN3dS8ztuNHQOSCUxKxZrN1Rn/wJFj4fPPop/Ud5XPt7HVdOe/u75o4cNXre811u7f06ElfX/nq6xZSP//CHd2/f6Qq1n1msaKfxXghZG3yz3QfFG8QN8jQY2TBrB14eTQcutKF+FSr0e3kNBqw6THnrz8l/yC7AtWgu+C+jEYDE6tCMgVrzsMdz6XqTXyIJ46gsgVeLu88RO4F4u48HrC5ir785Tf0r37o8xoPIZdgQViwicIrr74QPDPzaf3Q/EB/66zta/NfvPBWYvjAZljVB+8/1GuvvaXlPK3L/K7+xZ1fkmyawHAYerBmCTgfG3WobPPuDK5fdF+n5ydarzOO/VouCd2ODbemUsgpeJ+0i/NrX07s6RotCB0FXVwsdXrVN8MSHSX3i0MOp6R8nvSYqna7HftNEw7PeyFRmU3xz4UoE4w07CO6iZT1nNCCHrOsG82SUrmOsoVYk3FwvSEsu17Hmzc8m1zTnd2OcgjbOchKZafF2I5yjflGEutkyJbnhHleWLx0loBG9ry+lohdH6tmz2I+EWK/QGN4bur37toRifVreY7jD8nBDDmqwK50q2+89bbvPzyLZrPi/YPfD7Hn+ft3NRrgEBYnYyzceFYusnkPJmb5UtmI2HA0cqeYp4stEBTOEHzrRgIkjH+mCZhMcHKC4V0yPMz2hyY5ELqCNj11jYxh41cum3BIVwp5i4fSfGGbKCTpKRgsEHdWrpi4xCgP9QDyFswFzJMBCk6xx2CGUbLEED3JchZp1h+p2Sips9vQ5flF8M7NZPX48ROHwx8d3AthFR+312sF785S2ay2s4tLnZ31LEWASLPb6Wp01bPhLuG4e7tNJ9AzaOYA4cbyMOfN0Nua8rxaANehI0OqgZN/wLRZtGuRNZlRsUJXhm0dB1ughqeSVHEgR1hQRWzvHJMVe75Bblna+Do+roG9h7NOTEYc2p58ycxabiqatkJSsVHRsciWc6KR5spEaXeQ/HkgQuaOFAoM09Mz3BMJNl3YZo9UcavMEs/DPBURBxnm7hxU2FkR3ZMYGcOC3a4j5css+lAJcgj7gfHiZ8O4gV7dkdq9goF8cC9xll4uVJVQpJu1hsXW7VZdOzstf6LT82NDxhx4zFifblJbulrIDDBzez6Em+2Out2OKfrRklkkRhGQIZhFBHEvpt77Bx1V60QzUaxQhBDxtVahklOpBpmGCCsq83BPTC7IFROCUDARgDt97d2LpDzoBO3kq1Znxw+QdWfIZOZjrTNY1bVVyO+quapK58n32DBTmQSj/M3KBRbVKpvIDNp08rqXn+vT1UilAmJjmJSYX5R1uRzrkhzHxOuuvp7p9qqvl2o7mi0i1TY95bY57ZUi9aO56hppGw/1sP9IzUZFr5R3dacw0RYDC6RkFDAwoyF2QMBIupp6Na1svaBhlnECjkokiETK36pr2I+0jMYqp5Y66O5qmAudfCkXRNc8x2eLgYqZpbpogTMpLdJhLROFtK2AVsgBA616yd3P5XKicTnpErJLdRokutOpwJgs6tHD9/Tk8z+o6J031S6W1M221VVVX7fX0vNN5kAUX3m9fnnDMH6hOFXd5gywuwtK54fqxxd4+Ci1uXFBau80VJw2PJestSpmpTI7rFSIbLvZbth8QWQ++OBE0zlwX1qFXFXZPOLya6ZviKlCKgTxp1kPbHSe7dzhnr8LBw4JEUC3q/TK8yoKxG6rbivB0XigfDFt7TfPeqkcimzyLFnXFKZ0QJsUGaQQECmwt8oVU+pUa2q0y57h4Slbq5btEEYwvE01Mhnt7TH/xFwEwk9gX/KZrAd2DiPPPCOhtKIF8XHhULNlITPQGIs1SE0318asY+7eZmNI9dpZhgMeYpxDvJkzbmMNej2z/llnwK6Pj0/1/oMPtZgzQokCES+J7qKr6zTralZBBRmVERe40qpe1np/TwVsCel+sZVLpd21Z2YwRksuthq1sg9VOk1GLRyifG+eV74ThyfuZvfv3EnyLfvmnjCwM0cENyki4jh4sw2NeMajMA5jXyT0wubt5aqqyIpoDlIYZUxs68hzRRGC1tOFQkIugjjIXjhG77zG+IDCcKPTk1Pn9jKnZL2xw8CTeXJy4vByfvdN1/8xHZRcnKsLzKHf1oOHx1rFKaevlwpPdP+5e/rEC8+pkE2ZXUkEEjg7OkIqJR52uqTpFGeGpofF7jQSP0sgPGvC1viYYgUGvl50GO1kM9YSuchkEizYcFghxYQcP/RjxMlst+pd9bTm923i8Ln29/xnqN88hKboJrE+pvoo+6HggaPDTGc5DDZOn3d0ERVOOmtSEufyPKJqX1uoOyCBG9IQDAK6VjvNxIFhayJZ+DuLO3iqp4JAlgPbgmZM3bCcSrwI7SxBEYLwP8wwwuD9mU3FeVLXdPSMrdhgdWEzhu1dpVRQvUbH0XBnzsHXH55rRP5nlmiqjm7dOdLd8VqDxVZROqdptqTcfKLBcGIm8+HhnueCROHwwIHtc4LhQsOGzX9vtetGCmZL5pdzZUllSW+dUkCnD2OQeUaoUmN3EzZYbtQ91+SeUSR54J9CpkJVGJx1nJa+XuvqCgPv0GWyhiD9jEcLnc1OtFRRl/OwKe+l54ojbAtxHdkYyjJkT1FGJT6/cZWhYEFq5CZcdPKBnUgG4ofnY6n1beE654tmVEdL2k6qzzPD/rsH+7p1q63Nls3hfZOaymV0cjitpB2NBqmJz01kFagKjEBrZVMrnR5f6PJ8qE2c1QsvvKTZeK7X33g9yG5u3dFsNlBvcO5waGvHSsGJJEqFbEW6AYoJ4rFscICXKcWb9SnoAxP6e6FiSRLCfCQPsD4xhwjOQsEi8r33Hugf/cP/Tu+8/aF1bUBxR0e7euHFIx0cdrTeLG3Wzub47CYCXEdx6VDpQmBslio5k0au5jeMzTt3DnWrGzsJBieenZ2mCoVQsAKlHRUiPVkWtKm0dPeVT+rxyaXee/891Sq7KhVhcgenF9Y5nrgUFEgoSgW63I1yGfyg6e7q7paQAjiUl2LUSRUERBdcOPWuxi7Uh+OMY5qQcJQruORQkDLjTyKYMmHvsSyKvExIadWS52QQFLdHO0lubUETwtwvbSCrW7lI+wc71saOJgONxgstlonMwn7LzoFzBBvXkiQT9jrWLM0mnwEDFZPhnpHZUBywniEPGX1hLhjHevTwsa56vcTUIlaWQjSO1N2tuvOar5b68OEDnff6yqbzqjofkqIN15682feZzUZzSFAEE2zoepc2dMdTuVhteKZLkXjZR1+4dVhC2Rmp4dDmAOT3s0YieA3O7wwoFYgQ/JTdva4GvaFN3yEcWebEGqJIyOdUZUyELhSFRAVkKvj58nN2AUKSk0I3CYKID/HK4x6eBfM6yBaIg9kNcDbkoFqpqs0yDnPt/kDdvbaG00szg23e0L90o0dHi66UGSUm8eQKf6wHJZXP6em5zs4vk8OEPMKpL96DBxvt7TR0786BMhkGtwh4QxIBixKLOC4iC4b5Jl0hmwhf2pZraTwH6QqCcJz3viasWI/DvwvugN64sou0oUtazXw65z8DTo2tEZEy6BmhEZ+cPNFVb+BWn7icgsk4wRXGxgRToDApm6eiZaMFMmFRc4PkDgqsf+Z/H9u0meoYEwX8OjnQc8usqzxbXVnnljwbJsBkbcHEAgEeCtCZNBqhC0xMhlNyRiWUbA4WurFWs61JMQizeZWSRAA2KjZiHrrrFPNUu6GdTkeVMu+51Hwx8SIEduGgx+oL4T4WXn9574m+5Ssv6UG6rR8uf1q/Pvua/TPZ1DNZIMHI0O0qKvh6wCxMb9cO7e7SKZQyyuW3KvIQNsjcW1u35SxRiqH1xpU5EUK2+FsHYg3QG0JgH37WUG1CV2Cz6EBkKpdqAXYGSkdnCsFhSwQXC5lCZ6svzur6x+MgNvsTrZ/W+CoUVmB9185EbCohyfzmoLROELE3XbnZt8HEgcr06qIntcLPUUAVVLEBOkbvZGQGxyDIDdwvGNRr67FSabqRtIlQmTRz1H6wELQbCBsgBBLW+0pPHl/qzdc/oLfWaLCy9OkLX/iSHrz/QL/6136HajVmKBRqkFLYVML/+ZoZzsz7YHA2pYNsw3OBgwsbEQclBxEFHOMDqjtgKw4brn8w5Yf0lnKCx8nxeUAoSkW9+nWf0Gc/87LanYouro4958eY3KL0Z9yNOrs7yq4DpJjKhDxQgrvTKqr4zDZSb5a132ip0azo6GjP18jpHmzO25X+/Cdm+p4vv6i/eVLXZ+6/qs/9spR+4sd+VoP+XOlFxmgSxLpCreRxQqXEYc71WTh5hvk6VpfzxcgHHZvf7m7b14TUEfYZtHlcO+KzgslAKkgESOxptkPMUjatQgpOBcQ22KfE8XG4ca0IQg4MU6BmtLq8F/vd/3Pzot7YlCwl+WPxF7TdHroIZE8ZzsYuxlhxDkkHPbFHayAMtho1d6QwOdEbu7DOMHqhj7uBAPn9/DcE+9eaaswPkEsw++V+Z7ZbVbJp3d7rGtmjcEYq8/jJE884sbMj/5bvPeyzN67UhsBXZLRDNB1a7pSy62B+DrEGeJsRyeRqZJtFwth5RREB2hlb11kX7X0ZuR7+wQWvdQpQulqe4ZOTUzcukB3ZGDjw+X6GiIsk5XDQ5lXY6arbafm+4GsbDEogBKbUadRNmGTmivWeDdfRY8OkZRzmYiSnUr7g0UGzVvc/v/3uW3r44ftqdz/lLpc5MLD44dGRr9FkFunD9481ujpLimp9vAdlo1NXc9hU6bis8XRpNx4f7aRAZKjGEcDTHZXs3AGUYskEzK9ySq1OU5PRzHpFEjvQMVHVZ7PEqyxU2ZYD9LrClWOhDTOOBQGtJD5gkcb6Q2YSFhQXG6YnDwUwBwuBbq5YKqjVbbmzyl8hxl9ouUobY2emyYPmxA13NEtDkFSiwBDzCXAFLN6N/SD7/b5FsIhvWawkb4/QfjJ/hBDAJTA7lQtOhR9weFthYX8FazfxLGQAv7e3Y1VksRCgJUtE0sGVCFYYRYeZvgWIOSTEhxeVKJU5UDMHJd0YiwCjby84HgqIM+usFz8DeubDlQqRRXWTZqhYI+5X8oIo0Km1dbC/74rWmqRs1pUphwpsXtthpujw0W8utCWn0HRjDg024UAxN6yEpSHsX9yHloGdCxwCYYBQYTPpPE8IbGg2mkqtEgb3W4zPg7+taeee40EqCFUq9nN0nBRrN6dfTpPx0AzakjsnSFxsJrCIOVxuuiFYdLV6w4co3xFeYyklxyG12s/kKVKhKqeTkwtT/DE7AGaOSTwxfL7RCy8caTg6NUkCA+fNFus3DgISIErewHgA2USwPwshxtLFOfOxkR5+eGUGNPNW1uCTR491cNRJcga9gDzbvGYTKtmM0JFRtSNXsh0BHUWezg8GcpjVDHw9FrZ/gx2KRR7PHzN1kJzh5VQnxyfusIG5QFNefuUFff2nX9VgeKrTi5Uq9a6zZnuDsaLVjXQG/fF2Rbg0zi0VdToNlT/zqoaDtd54+8bv1czRTUqL+USLOQkjSK8w5Ahm97n8TQHIofTyy89pPV/pC1/4Wc/44Q7AXEVnHZczqnZ3tdc9MInLCRbES0EyYVa/hR3OWg0uWmzePIdEUxG6DkFouVqqTNoOMjBgulXKRBNv3VskTQWvAzMv+Y6pbUCfIJ+lMxoNpnrn7Q/0/vsPLVV7dL8uHRz5WHv73Q+NBNmBDM6C/ZqZe6ZtfUkhRpFD4Y9NHX6kHMagSewL7D8cOlhhUtxevzwvzIDArMx0t9wsZOkFkwes3zIZNSoVNepFE2w4hM5OrjQchhBxZnq5fElX/YlGg0sN+0M9f++uDvd3VGnUYEgptdoot0lrupzZNCWeTHXZH+rBwyfukkHN2M8K+ZLWdHmkhBRSiuGRrMPBZcMLuCC5cFj3hyNdnJ/btNwG6chsBDeFwi6QgTCcJ5Sd1JVGraTZaKIVhzLvydyM6MRGLRgu5AoqQh5CgkhzRQHPvsmhWw4+tSgasD28fUQRvdR4NvD1RsXQv5qZTXv3/m3vmWRp3r51Ww/fPwvGCfmPhif8vA/K/aMdpUsZDafjgJVP0O9QodX03HNHZi/S9dnEGkiuFNLcmUUZly/SvuPMA6mB9wiUcAx4x5OFdneAVrKazphLQQRYazmN/FAXgRtrTS9qormY6tmeKd66K4REEkxDqRQBCZBujAKdGlIQWpscKRkF33wIMbjk8D08bI5iM6ZWS3LfIjNaUzx4uPEYxtlqiDHBjFgrkktibXCUoCOiYkePtCKcuBp8TG1yjlyB2K7g+Uh3gWMR9mDVyo6vDaJqoIVKGZsmtJBAZLCDkcnc3ECKj6NG15AsUEomH4wZIB/A2lvHczXrTc+RIXuEeKCRJtOeU0w4eDkkrwZ4zD7v97StH6SpMhT7hlYRs6aQCQdRBNIABVC2gLg5pXQ+1gyzZCefp7WJKI6AsZiPVBSvuQ/L4PSyCRs05IzFfBAkN1jTTel+Up5L89DcvndLlXo5JIekQy7nNTWXjYYHlDBeDloSLThArl+PH51Jublho93uru+1CzMVAsMSfUDy8rXKYZkVck6RF82iqb/f4e1Dwgr8uri80ruj98PcGKIRkWepWMVyxnNtZrG3jjrKZT/lTbrbrWk86hmJADIChgJOZhPhO+bzZc95Mde+vAwOVnXMLIhhY2a4mGs8Gmn/oGlqvX1+bToOhEwxBGsxEBoYObhoSKW0mE1dGLD5wLSkuKIAcQflwiCtLQYdzLo8m2H+n7NJxMX5WXJAvaBPfepV3b594DkzZKpQUBE8ANMTw4gbQhSf7Zq0xcFHEdXq1LS3X9MX+x88NTqv18raybU1nvQ1Ho8cR0ZnSyFVyBT93D19T+bk64Xu3NtRSq+qfzV22gVkDApxiqXx8Eq5TE2lQojv4veDdBCmAGdgtWZWu7DEYjRZmNwCdE7BzX5DoY1tMuYFS5CuRazNPk45QXcXHGoWJqXRyeHEZSepLDO/nJ6cXOjt9x7p9LSnZbTVaPemsLrsjdXrjQx7s78h+bjqY2CCbIw5eyDo8f0p0oaTkVmdnVYrIGPZYuKdARHr5roEe99g4k3ANs9MIPBAQMpqE+WEMWgVz+EczHoK/ZUuL6+0XETK5Evqdvc8HoNFjIcvCoNy+cpB8pVyXkNCygdjETrEIYT5Oc82pDUfShGxfbBy6XBDM4CHr9nsEBjTIRmKg5DinZQRDudHj080GA29DrENxVykUihptQyyObsvbVaGfrd43FJQTYeW8Fnm5hQT7i/qiEaIF6PmpcC1mUMYc9EYETBPjB3XhxQdotd2d5sqzfjzBa23Ba9lvid5xKBltUrBOstgwblVrpT5mGO2luhOhpYdFEhWn2Jom9PBwY52uy1/6dFgoC2ZevZVDGJ6P/TWz83UqLW0v3Og5STWMJ4pjpaaYy1ViHWxuXR1bDXSmqoyuHWweU+BEhjwFvAgDIbirmLwSrWuka6QuWjIMXT2WjrloFoq/f5Vz9AVrMhRn4Dl4CZPBWi4kIeFGZdtjzBNZjaUU6WetZcoi9RJHXhBIo1xcxs0QQTioocCMoV+TPfLnITOkcOhUiTwmpkoLjWRUluqmrphHWA7d6TbVDhAa3kTfWx39QxB4u69O3qpuPRGPxiMrZ26vLywuz/348WXnlcXKY51rrHvw6NHj9wlHh0e2aLu5Kyvx8eX+u7Npf7+S79RPxztqHbyhj67fc+zR6Q8rUY12A3iq5mGDJVyZQ0bHsIVXYqZxDz4lCubEN1l5ttsaWeU4MoBlb/oroAcRjaH8WhoOLCz07Vfaa5IQcVsDe3oxp0hUA/MaE4pCC3pFAVA29f54Tyjv3R1x9fj1wx+RLuFpfb2DtVsYYxAFxZcmUoEzuKFOb7RWwKjbVPLIDOwXnbruSyd6Hqdf3pQ0kpwje0RiQUh7NHRyptVZ4HUCUlUXc8//5yzRCEzDQZXZqTS/LFJAV36+5GoLrxEwyaz3RBqPtBet6GXXrqnW0c4ywxtwbWYTlWuBwQhxG8BK5GkwToNelkOCL4XhhZD/+8AixaLIVcVksJ1sYbhg2HrZGNDuO4s13RK9+/f1auvvqrnn7+v23cOlS+iJ555lllv1FzAAR9ep8I/3Sggk0wpMkl7CUSV4Daz1e5e5+lBSYh3g6JkBdGKn0+rUim6yOTPNNYD/cH9SH/+9I7+s4dHejH/lvbzab3w4l2Nd+aOB+OwZNKyQl+tjU0HKNZgSHKPg8NVQdsotlQLq8xKJaveZT+w5CkMUiGhgu8CQZCCwxmKi7lW8UqdTl0tH+L5IN0yYY5IwBAID5OVovn49FynZxeaTCKd3f0FenL3s/6e3/363/XBTeIOIxqKmnx2qigK2YkI67GTdGJODm0jBLestX9A5BCDuq225SshzuwGLSkQYUV0XQKZ245zK5uA52ADF9mXAgGQIjdXKmi+whxl4g724NYth8JjeIDV5ooiYROpP5660chkmi4uHj851maDxplDuaRiBfZECLDmQErhlkMXt10qTQcMszhi9l0JzFwY/oyzEk4BKFSv1zM8zD5owwCUA+jXGaFt8erOq6ySEabpZKz1MmhNDeFiUoh8sNl0PjDGDI8/fKzj83Ol8+yjde3u7BghATMFauezIldZpzYaDIkz4zoz18/aTJ39NdqAHIa4PopHF/MxzySD4s3He1DykGFd+8L928rcL2g8mHsW2WbTz6R1/PhUs8lYk0HAkO0ZyCJMDhngvGF5pk6L2Jmys8D4oK6GSQhYB32craDwTUyTAB9SwSejoe2V2JTTzBjzK2fAmZVKt+AMtY16/bmH9YiQi4j8vfDxFsQ0oBwCT4kNNvkmkWAA9UEpjlYWuDI3BFLkZU2eDX9p7SEAJM44drQIDx/2TO1WJ1RXJCtk5OBYOoxWjRuJZKHsWZ4jp2CUxkW16g1l8nThW0OuPFCVWiap7Dc6qLdBEfyiEoomQ733wYc6Pj7WYrW0tyvVF1BUYLbd8sPe613q/ffec3jx7u6uUyiQC9DBz6aRmhopv4k0S+d1uc7p5PJKT5481osv3VMxf8tdFB0J8odMLnTTdOQ89CxUd5eWfSBTmOvy7EznF32dnxF8G7m6xlWHawWDuMTsMRsy+Dw33W0HvVo+Y1gTH1C+CzIJOllbmeUDK7DfGymCfVpra7DOqrfJK0dXV4y102qaice8cLEY+/5DxrEJOXFwvZv5Gt1WpcFDE6QTxERVyjU99/xdTeP80zxKzKAPS0ee9aAx5cBmD7u6Gpkqz+d/pUkiDoXQzNFLNgDPwLTdaKfbcRcCUnBywiw/8sHVblb06tfdU6dT0b07z+mbv/GzXp8PHryvzZZCUorJWEXikefwDpaJzqvEwD3xnYVgxdo04SUV8vb4eWZofC9v8Amsx8blhB86qmWkSrnlggp5FwcxkHylCkkIhIRiANi+5q7EuaD83meQbnew03B4UoDxO4D8KRielaw62SSLnrHhw5LuIZerBbIaSMF4ql2KsVSsy1VO/U1eHY2VitEpZzzbjCFTrTOe2ZqoUefeRWaegmqBZBDFBEv94qqv/hDji4Uuzq8snC9mCx5dQOID0cpXiu52QIlYo7AxmWGGtXakXIXOc6MtpJcSJvTIbuaazNF2zj0CiFNZLYoNrUFR1pFeaWFs31av1/f9hhQFO/a6UGSj5v25h54p4u7lBIu5ouVAkxGSkrQPHbgTzOCvXxTa2VTssY8Ti6xBDHNriE2ezTFuKJUdpg3CVIjhQUDGSuvW7TsajoLvbSgYSBoiLAJ3tLla67r3ZTpf3Anw6d4wDskF8lKVGK3ERWmOwfl6rQ0WcEkuJuusgqlMJmNzEP47ByQcjmv/YYo74OBsiq49aOhhKTOjJVC7US0qgr0P6kexzKEKAocNXb5g85aT83OdnJ1qbrnHWL3sUK1Ox1yPQq5iHsXj3qlJmLB5s5b3pbXNxJ6P8l4gNWvh0lP2/jIk2g1oeAqUn8R5fZwHZSGd1dHuPoCMRsOJRsMLX5xt1PWQmpkJs8e1qe9ofIAcgebo9GLflOHlWNPhXFnEoWwMcUrFPBZpU8/WYChhSRQcdJjZYDi89Q3GXm4enWr/8JY9FU3txiKIoyYFnJa3g0UQsBO+PHV1GFh6JbMpwfY5pOlCqZhcbVDBr2J7stJdAlUBnQbj4JCObZMAloAZrcGUOTjBAGrhKFR0pVurorGiUoGgFKve4hBthkBoTBAmHIIwyWoqFFMW8MI0T494oKDkl1VvMddLa74tPj0oyehDjoHVExsT8zM2LA4Grj3pCzycfMez01NvpC+98IlAjkk221Y9q351qMp6rd9y8UP6vr1fqR/c+1bdWZ/r041Yh4dHquFssll5Roy0J4QRI5EhVDh2sHG5EkhE8+XC1n3MhSAtMQNObVfKpQpKb/IaXk3NDgU2bu42tbvfNlN2swUGJ5+Rh2Op2Zzrj0nA2jMECBMUSTxQVOnMmubrlf7A41d9LT4XvaaXogeaz5s+XAvMnm21lRAf1nHi1Xtj5cBmtm5A7W8lSSUp2yIitcgWbzp3V6Kp0DXaNzOTU61UsSPRbD5xFX522gvVNr6duJsw4xlNDb3NZysdHz/RxfmlRwOYbmzitLo7Lf3iX/wZJxkU8wix8S3FCg3Gd0n1ajmEYiem3DmiiJAWFQrOScTMnWvB5+ZAjBZbB2YTQBvcRSI/R9x31iM6N4rVWq1h27DeVd/ifTZvumIgewKm6ZQQ0hMNbrING9906gLEWYiJ5SEvfve15swG17hg2bw99mZ082LOzMaYJO+g34R1u+IwDkS0b6lP9Jsmj/X9g7v6nW+9qB98dagcM2lkGdwD/sycLE8yJudqL1ouFuk4eBaBuJdxCA+giw/knTBnj5bsFSvNcyu70AAlZ0oYk6xsB8czY8JDChkOh+CJdvYgH5UDSYsYvnTa/Ak4FezgHGbn1Y5e/+x3+hv+mnf+qeoo4Hx/0Q8vNR6nksBn+A8wMRNKFnCiiVmMHpCQMIMjom3jkQQHp+jcC8/O34GJkYXANLG7qika2M4hl6CTZM/LoMWdzlXYbGx8QGGMZaAdutJBUkcTcp2MhJ6c4vMAJy6Pw4qep2YyzBeDaQLxhWRDhtFUZDh/vQY9DGQ5+BGQGQM5LOyDFAdce8vBYOYnkDPIGBF4dMNG3zi0thvL6jLkuAqiE+HKeQdf83xtpwtd9UcaTifeX0ABkN2xpm0cA9EPslO1YgIQTRRFPSMrhyHYzS2QESnA4WIUNmHPYv0z/gG9Yo3aSP6Z2fDHclD2L3rmnVJooKXELHc+mWiIlMCCUXQ96aeHJSbmsyzuLQGWQq8T4JjYDEcWdGB7BZNg9FZ0j7ZFAhu3nyvaHzoDhMdVy016g6EvCht1oVLSchE6W3aZ/YMD7ezu+sIyH2EGV8KYvVDU5cW5oUMgLZYkkIIdIhjAu+IpqeKIBiBjgqWBCph3oAdFpBxmE0ECEliGzBe5KRyUbEA8zBBo6AjXMaccrvokp8eOQdo9um1tF10glfYmBZssq3qTYiHlcFM0nGz2p4RJZ17x7wQSu908dNdUa1DJ0VEw2JdJFWi5zCrLZXV0dGhdKYN2yAIUCWx6dIDAbBwavWfQhv69X6iXDufKbvHKRUO68CxrOBxY58bhcefOgXb2cDjht+SeUtZZZOUSwmLCWEuajKli+W44HOUCfOjkkKxp9FyXwfBC2dzWHptAKDCiwzXGPLlsQgAPJS/gW+Daf/zgRn7AhrDf3nVHCGrBw0wAMdAgmzywV7dL4Oze0z/Dxg6Ui/zlGs4CQp7MxlrMuBiH/jnna6Y3wf+zVAs6tiXs1lAIMI9l9pQhx69RDlquFGQdukEKmZk7awgVfA9m8MxVm62S9vZaPszwRL44vfKMEsMBbL5W5bwK6YwfYjo7G1A7lSRtyRPWfRQrrONVhK4s0p3uHY83TKnPM8euhdl/RCHKrIdvFDpdfzdmmJOxRqO+4SdMvnG4yuXbdsWCG5BahTQMNjkL5J/R3rLZ8qLDcRHhqDhgypWKxRvHHeQPQKQUMSA9lWrJzzTwKBQaWwyalHLThv6L8a6+Z3fotbBiHS6XenJyrrMn50qRicg4wxFOkJhgTWPqEOwe2UDpemAvslmz73C0UKpjPgHCsU0jih/7fgX2Js42eS3mU52dXfi+p1M7JtQQlAyvoNUsaZPKufMeL7Y6r37ymd2Q7Ma+Oq26ZVMUBTzPkJzK45nG+RBmX07yKC1vmIImLYObDp0hB70h14BqPZsWhAaXUD42eTZ+7hcKgJDqAmM/pH7QJWYiqdasBTnRYqYKlp+ZlFr1ihsDiiQ+G4cXi85zbZCXTkHR3bVHOdN5KDI59Im1g0VLUTPNzvzsZuAkbAg3APnCs5bQ+XEITXchBGqQe2olyb4Ikx9OyQ3RkTkiaSo9peKV8hmpSzwdJhLVuqaejRJNV9BqS1YoBUjkhmcwmnjPLpjnEkiYM0PpRG4FfSVJL9kM8W9SAScemLgbXHmq2qZjd5SshfmUwg7HpppHQyA6H6+F3ZMLNVptewiSWIFOByPuYW/kbpOuBvgC6IMhqdaQYjdap4OsA5kQm/V6NNNiulK93nYKAA833SDaMboinDO4aWyC9i0kXQAvQoguG9w8LoP/KtTn2VxXPSAuwkYLHuzWGk2TZpzUbYslBK5FFcYlD5fRmQHDUvUBB2xXaWvOcNgJTo2hQ2UxMMtYJTce7Hy6xD0mIQ3ZdB2SBMP0tDebcq3gCt2HYxboC0cMrjI4/1TzFY5DDP6xxctoHmGQMDeUROX27vvv6/Ji4E3utHIHNNUvuquDctGbe6PZUqFILiEaMyLBQoA0rC8OaWZ1VGdUpCzyWr1g2y9SVG7faejgsKpOlNW784l+cFDVP1jd0W/bvqsnb7+rh4+OPYPlwbY9VXqjWh14LlatWVR3d8ffx2HRZEs6rimnidBKhVmcLbx46BGLb9aq8FDWSlpGM5Vy1zAaRIGVHwYq/O5O0+/DIYiJM+G6tqHDCi+d0V8640Kk9EJhpl/aXWs31000j8D6c82n+EgyFyPhQRpkRhqKTjFISep19B8hSo2Dks0VeQDpK4tnnpNrRyG6Ne49IbAmz0TBSQVYvaKcalu6uyCUphhz2GwieQJinE6XLkjoqG/fPlSh8JyymRDijJ8p0XTAXUBKxSJEsmDITXGVztBdgm7gRVoIRtLIsfKWVjuflcBZWKweb0C4cdxXMOQwqzqBa699SGFcU32/9ebbvm4UXmwonW47EMSAHJl1whovBkclv9cz/ooUb3QI1x0E/9uzKRJyMG6+3uTTKZt+8FzgjkO3yc/zvPJZ3HGmM/oF5YF+ZNzUh+uq/tzxkb6rDeQbsljPzo71/vsfaNSfmaSGbWJAdNbOQ6VThtEJ4YsCu5VlPl+Ujs80Tyes2FJFO3u76u4TgHyh05N5kANQ3CCYzxI+T2GB9m6EfxZlgHb32ipXyypVq6rUWiYGxeWRXm98q7/fvYu3VBicaJ6PVTrcUbvbBP9yRB4bM7wDEKrhGEQm567Q5CjPw4IHLEUQsKS7W0T3zCATtx9ekGPoVoORO5prwq8pUogf48Cd21gEVvN11z8eDUzyYgxEF5lLbVUvFRRhNhIHhy7sLXe55yVgaUxkSi7sSPHhehJRaCcvWMIb7AR73vu63a6bHWbekynhzhRjwYnqmrAU4t6wjWt6TfkzjXFlGtuBrd5oBq06vJBlpPEicFT4M3w/rg2dZQFiI4ggJuqzRIMJwsfoIZt1IIPjtSxRiUMxmwJJorjEeS04Gm3SoaCiiNmmC5a74LTFGubPwB5nHNbpNj/eg5L09HS66IVlHDrGdIjIpYUp1ypmDKVuVsG7j42TG8mHZhHbHo7NM6noEabXqjXDWAMsufJZO+VU6/WwcBHjs5Ex9F2uXFlQPTjok0FyPmffP9pz51auIp2cX6jWbHpe2LvoacyhCDZOdAwzp2ys2To2bZvfbYs8uhoqLW4aBySaQDuHFAKMzEV3yCtzysRMHdKP42NCrBOdHl6SQKn5UsoMy0aLKKAd3yxmkORq0sHMliycsoW5uORDiKH6xMC41e5qHXNUZ7QoBeswXk7QmF7q5PRUw/FctSqiXx6+WK0mVP26ZzHT4dCdAvsRkhIKEPSRQZu3UBmLvEJFjWijPzD7QOPotn5q1tR/fLqn//X8Zxy/1euN7eNLR1QoBUcRZnNOqndFCumBwO1AEshny/5dPeYZ04lhQ+aYNp3OyVrOWg14hYckyQTNZM1WBBm/dkdhjoXHpwubUskdDLrSP/XBkeablHYyC/2RnTf1Uo2ugM8SjJn5K+TR4RMJ/LUxGSTmob8+AKmSi9iYAc8QlZTVCoIHMGwIMQsHaqOqyoa5OgQa5n7jxLov6y6bDgw9KZpKvKRzuao3lq0NMDZJfuLG8oNgwSXLb2yvNR3YsCOXLtvjl4T1yXhhog2HHOgDxReaNd7TzG53EIwCcirmgdezujjr6+p8pK98+U0bVRBKi0kA8C7PQTpNTiwB33ThFGsYK/T06NGx+r2hnnvuvqHEcFjS2aysD6XaZgRC12pYzck+N5s3n2U2CkHcjnhCT2lNbxIsnryg3K88lwydadhMITKmgg4Uo5BKUV9fX+uP6h398dNX1Yvz+pMPb+k/OPzA6JDZ03wbkjsc8k7lD0MxpUa+FhJ6lLawHVOAVQQZb2syXa8PczrIFaCU8l6WMJF5iBwkC1oAizgQ+YjtA8kAKXj8+ES1Bmxa7j/FYFrtTlPfNwnd5J3+B/qWD39Y1e1CzWbLWmu0h8i2KLMdQBxnPD5gMzF7dDn3s8IYCbcqrilnop15YsYlPRuGqHFTldjgG/MKa+8ZsQSz8avLS41GQYdMEUOhSnGMiB5o1wcwndZs5ueA7hKdda2Sd3G6023b3pI1hvkJkh84HFgDIvlj3eNoY/P5TSiI4ikG7pVQ6OTolDF4WNhpi0Ou9EySCHs9s2nWD5+HfY99cjQK5Ci+hxuSLZIwJXmfWbsBwYcAsnz46JFyePoaCSx5ZMc1A1FoNuseY0GEGo2nSYJU8PFmD4B4CaOXuSOoBJwRSIg0MRdXl8E0Zkgs5BMX1oxYbt06+HgPyuVyo/Fw4YRwVwVJWjybKnIANikeahYd0gM+vD1T45Wxb8gRbE50ecaoL65MKjClfrW2MS+Ho13tt9LF6bnKJcgjzMc2miDH8DyRWUNKqRwOC5Et5HDVoBrdPggeonQnCHpJma/SweXzzqtssCkFh0TTy68rZ7qgPIbtpYIG/Z5hWOKwgCEfPH7sz8Z2ClRrb1e7oQQto30JmV2i5SlkVW9VVShtfcgUMfVmDrBpuCsIMomJv8NgNPNGguzFG29+rdt37mjv4MAPbRw3Ifj69eDRQw3O33H1x0yKpAOTA7ZrtVsV3X/+jnYwns7jPFJ2tQrsxXUBjweWJstuFU+1hhWYzauVjtXJ0HFv9eVlVReFX6RfsnjdB5ndXrJb5QoIdfe8mDodiDPXFl048Qe2Kw8Esgc2BDZuKjZzq9J02TVVqmgt6Y6wX0v7WnNQNhtdRYuB3njjPRUKfVet5XLatHDYu0A7f+qdrv5xr2bIv5bb6lWS3iAHJAbQHn4AOSOXyQKBk+I+VrRcB0p58qKWsdwEqLhS9WdlU+PBH0U3eZRIGQ4Lu3r86NQ/S6fLGmeOxGZPZ4YcxcXPYqY1JtG8x2Siq8uexjC4o+DTiksSgnwioUBJHj441vnJlbptDs6a3nnrseevu3t77jINOecLmkcjH3RmcjMLShf9noP+SKMxh17fGtLzU9xXCiFgIMWzObZxBh6lRjrYBPEBLsEKnqteb6jd2nFcHqQl1iXdOPFVTu6pQHwIBYoJdcC+z8hxnMjirpoUjrLNCq6DiwPElhyU45FG8ch2iJD4uI78DKOZ9RrmLpswRLyCnt9MVM7Euoilf9zvKqdYv7P4VZNS8tmqehdD5dIkdrRNGNpm6djLibHE2oQ5bBs5JCFRQXJhTxlNIOrQ6a6DuSQuRpARYZM6SDyQathkmfEDyw2GS7tUjUYzX9NYcxFE8ftPX9CboBPbrbqZtV7oIuVq6OBgV12Ysy1yDTM2EfBhld5ot9NWNjfWaDI2052CLAjm9VRywx7Af1vMKO6qH0kLgjEbkK2Mu7erwcCMV+z4wryXURAm4EttixiezJybieCehoQDle/KYX7ncN/7ElmRtQqEmoKNSXiPaz9nniZQgVQGAuRWlVpD2znEodXT8OUiZKx0xkhJQBTQKwcXI+4XP0PyB/+NteL0Dowv7HwUvjOIS9BfUkfAFUC+R/cJurYyw/jk7NykolK1onKlor39A8tNeH+yRTkweWGwwisQs7juaa2iuYMUKATYpzBZoZggB5lnl6L60eNHT+fxHOqwwD/WgzKdKlqQPx6EdHAeQggJeP4RcrqOJ84MxKePjbrRRhdZMBOKjYA+bR4BZ4bYlSEHRqLlA3qA5k0JTlUOwxUILpcdGZcGBgOjd6WTZpHP3FF6SMchhdlumpiWSOcXVz7AcLLgxmIcsF4sVFks7Nize3Bo7D4Y6CRVey7YS13PHbnxd597zu8HRXwdnyWO/sEM3XADfoUwAeNNMOPNxCqU02rvAdmw6VElsRBgICKiZ8ZQsOEzzNUP3/xAuVxJuzv74YZm5e6g1awrXdgqM94+PSiJELt4/z31LvkXYR5Hh4fjDjrESh1KNYnfeDCGHL7/D3t/HnT7vud1Ye81z/Naz7znM91zzr19e7pAN9VIg9j+IRGEiGmjSVUilZCqoJBSKQiaKLbEsiiqEoloDIokiFExgIg0km6h09Odz3TPsPd+9jOueZ6H1Ov9Xc/Z+zaoxJzKX65Tu845e+/nedb6/X7f7/fzeX/ew3qzVCRBZxCqQ6AL4F5gPRYRs6Q/dP9Go/Os/taooOvMkX7+nd+lv++jP2/3jqOjAz18dKaz+we2I2MmOZsFI3fMFPJoNrdLd0bMetAZlkr4sSaCv2OsoAQHawQfzL4UR96TUySZtsym2Rroo+8917e/9ZFKpbpGg6Xefudh8LKdTPR/v6nrL3aZM0b0ILPQX/jqZ9qucQUh2BXyRoD/YA2zUNwxZ7HQS/oAeDW4GdSLTXEnLBXl+Q7zcuZnr7LemBfeO8BdKsCihueWG11d3Wg+j5tNWz+oBYp7LrGHqYBzOdRinlehmaQl4BkBJoLk1roZWD/MmHs6WatUoKjJaj6FKEanBbsxqTwRTmk6KcTqYaaFno/nZjqYqNPsS+uIDqpH7jpwiVo8v1b9sOiiDC2aCU2rkJhDVmMiDqEs5p8NhOnQgRXwZKgk+PyW/NiDNGm2NMWjjQxeed1phb1GOBwh6WGtBmHnlexUjMdXiWAzebdWDDuin7ULTtH3hhkdiMyfefMD/fSHb+tyldF/2DtSKdvX70hfW6PaqJ/YdpKCgmdiOB5algRxh80O9ALkwqimYhqPZxoN+j7sPLtKJU1Oo1O3WD6Dz3PGTl14P69XHPaB2WyUYb1Trz8yaz6rtP7Z5mt6b5F1Pfbm7EL/cP+XvdcEq0jITkD/E62XIFLL/Vx25ygunuNmMmE/U7dKJouRwxo6Mea46KYdxQv6EHtJKmF9LLp9d7zpLIVOKtgwehHTCBCwkPTeSVPC+8iTzBKNaDBGExuCimlQmLEiF2KvIk0DBjrXaTgZeWRE/B5WfzDRLbvDQzrNSCLkWEJY6/f7ngPyXrim/BzPrG2mEBiu9rgG0mbPhQTkhmBpdnt0B7N/vk9uCeMPDkn0zClIYy5wFuoM+yZV2vBhtlCuUDRLvlqv+GdQLODTy8E72xOJTOhyYERMGyzxCsW9BGT7eToMXJpsntEVl3FjFGe3bfl9/Nrn/P/ng5IHG1iFjubOPQSzX2QjMAh3k2CyzQePE+xboGrNas5ccXyjqYX8UTstxO2wI7fHdrUvlV3d4KV6dXNtZw3stnabuaJxiBEZ5yXavo0qbL0085M5DukhtOYM77nRHJA2tsfPc4lwFop0VK1O3+/39ORIaRyAeD9cbMs60D4SnxVs1ug0QscC7FhQvNPVYoLXbHDjsbNPPGyGLFH8Sxe819hGhSKQSV0FDpfV2tABxeJsFth4FADdzsxSFp657a6t45MDZQl+9T9LpbIxJV6ZnTUOq4qM64rFgCh56DmkEzo8aujB/RPDgcBAayc24I3JJk+sUXA7YuZnc/RscLABpoxwkEQ3+uOPn+kPnT/S3+zltS1U1Hj3Xb1eTujk5FgHhw1DMegFqUINVcLWI8iWzzSea9gf70Nek+KqsRA5BDY7iEAYLEPlD9cMiHkXjej6uqv3vvuxPv3kQqsFGy0p9C0dHBaVydU0WMf1zP6hEf1AcaZ/8wfOFd8xK+TGAnLhakTXwEax06A98IbJveIZAWLpTXovNx48KhM7B/BCzKLChoKOlgrU4e7FTHknbPxg+uLgAowfEnGOj4DRd6ofwghNmfRBVQ5iAjqRSuG9m7O0JbKL7dMhgi8mzx0HJXtLNou1XkxHh8ef6/c4mDFbiCU37giD1AXUgOgjktnhAwxt5D0aAiVOlNtLj3ifyTiwVsKFKYHdfMblameoCtF9p93U5QXyKrrFo2DzxiYNYcS5hBubfrCJ87pDWu7SL3gxazIcu/+zyCuHIJ3j3cvRcvuoOgo/+8KGfCXDj1T2IWCZnNaY4pud/vTjb+kPPn9b78+Luo1W1N+0lZhizkBhKc/4gMHb/a7X/SYfNl4OnNWcojdA/ZY/jPi7FK57BGO92d8XNIgJJfPENjHfBq2KelxA4Q7pw8L16Ua93lS3saL624QlMl+aPNU/cv2zmm9AkpAjwc4ea7WMaQE/IIa/Cs9U0vo+AoLZq+ksmVfOZm0XBcCPjTrEO2nQ62oIGebXRun5Wk+0JieRdcrEiI7M8rydi2/u61GjZqh1OBgpe3ioYrnmvXMwxFEnBDEQE7jkniXwwGW+x71emkwXje8soQFdIPUkV1i4SDCxZx91xeEIV6PT7VrTyKiI+3oXKh/2orQ7SfYd1h96SB9cNCDbwFIGpqfjZYrpogBrz0La+wuHJbpm9n4akzFzZ8zM0IwPBi7iyNZlL8vtJSagkDQb7W7P8C2NFocwJMZavaZ4fK4ZxjBoJ503HCwEWS/VWt3uWB7tDIbmuEinX9xBia6F6JaoEvb4ZCbGgttsEdVCbEGGkbR8hFggtE3MBbq9gQZD9DIcILDD0MvszJhao7PLpj2zYD40Ws4MvxLzMpst99FS9ppzLhpkHiAMswG3oYVnIE61C8GHGSIQL1WQLeE4jV3pxLXB4oscxefPbcpLdYIfIi+7Z5Afx6gVzD0K9De2JIIqlIepNxq5o7wz74UdxibDhrbekDACiWahXqunIhFjydD9QBKApdi8HajZ7Go4wO7MQK5SRSq0lB/+6D7H0xVYMq7s5mUk0cFRTdX0Yw2OCUQN3q1s0MAolRLiawgSwf7N2L6S3jyAWOkeYVJyKfipwNp0AJAmmNWysf2rb1zqf2+Y81h/s/wPaJIf6X51KEVCpTidMAOCIk4TxTxiYx/UXLqobTZmFADnmNmO+wwvPRJizTZR5Yo1f6bRFLkIi5RuJ2rtJVBlNlWyDIBZ5fVNU38j+kSXq7T+k2ZeP14e6l9460aZGCksaDth1QXENdaoBjgbQpDz8sK9oto0LDRm4ByuHx3mJD77XIhsIhbSo9XCJLPPN6jRUM3bC88UM2mE+gnPE3PZuBmOyJJ4SCyHiATyhn1pmceloopA0HHqPHZpIVqJZ/jq+lYff/yZRwnAacHIPOZnGBOEagPJEjmsC03nkf2Mkeo8bDR2OUEuRRhRLGkyEFIUhP4AJ3SJ1WROmSzQIk5PWS37E7VuJ8pmoup1Z549Y2rBfJ3Okr9LB8mz4cQXZkWbYBJOYepM1vlL/JrPxToJgQR0cUSIAfGjk3vZUeZzBfVuP9Px8aENqvkZdh3C+N7d0767wkELp6F4VIV0VP/ivY/1r1090V8aH2mZ3Km26ut/MLq2f7O7a7oT1lsio1gEf9GlKfiYk1AM4ncM+QrEZqe4NYh01UhnZmNcYaJ28aKLo6D3M2R4eq3+AHQhq2g86Xnpz6/u64POkd7b5vRbYpf6rf2f1zwSNTzIQRNQj5Hj1Zi/Z9MxZZKMJiAHzrWILGwIgA0bhvn9IZKuiMXyDx488GH62WKuUb/rgg2o12Hu+9d0NFESL1VMwCG02M1/40L0oHGghw/O/L2RIV1fXyubLypfLKvbn2iGFA9rOorW5Uatbt9ZsfUaXIKwx+RLMIF5PuEOZJTKFTSrr6Vnl5rfdLxePOIipGGJe1lIRAnNw122ZigC2XPYDwloYFZrdIGqPV/wNQoWk3nvy5AEKdoT6bhKJWbqUQ3HE3d5GLnDAQWtNDPCc9KtWu2W7xmf9+H9+4rFskaQBsNg7IAEyTIkbEUhgDL3wcLE58NKuWxRqWxQCfDsM6KhcOUc6nQ6Oj8/l/QDX9xBGS5cWDi01CxOLkowK2d2FzYgKMvtTle3zaaJPwHWiKleb4TUcBaq3TQmpgtHR9JoPtapTtxqF0rMMSaeb1G1mUW542Cd2VbMBs/oiPYeg3QQVI1mOhFQapE4Nw9NVlLbSJhPsJZxrhh05w5uhvHVqFZcgdMhBONhKNsb3baaEmkksM4MdcZVrVa07SDFAn7Cqi9UzsxFYFphb8UcBsGurbq43cBwiql5fasPP3xm6JTKF9lEuVpyTl6FmUeGNHQkE2ll80QlrZTZvIQEa42i3jh5YJs9NgW6NroBe6o7jgj6dZAkA+EYkprDGoNFGdLdgzE49G7mYQE2otKnu9Jmpj/w8FbVbEL/7kVJ35gV9d1FXv/q61eUuj4s6cqtcwUWWmB8PvMhQ7AuHRSMTBsgE94Ka8+kkrU3WOczRtnAuGYJMxmr5bpat0M/Vzg5kV/376/e0c8/xzwhoh+vjPQHH16qHIEQAZEDnRtFEbMOKN4Zw5Js6O1m2xAnRZO7nbiUWsUJNPdrHzjvQo1ijmo3GKdjGPH9VneQrKhiaaYWCyQFZKsy+5nr2WeXNm6gEq43MOJmVkl6QtIzEyBCtKzN26YqxaIeP36i9qCnDz/6yCOBRw+rrpKhwY0nQ0twNtuEDo4Knk3jk8t8hWsIqxk3I8/+rcHFNALD8CCaBz6DVVp0vBKfJxyYVze3Dq29venr8qLpuSSbCIRgZnn8HZChQrFhUplZhTDAUyl1u4QEhAIVYs+Sa/j5tUkqC0mDLMJNCDSANc7v4+pz9+JnjcYT3U+E+Dy7a+2lHBRubGAcUOFgCDNmZtbH6a3+14fn+tevd/prMwgWR2qvcvrHlt+0Xytyr0gMfZw03a60mK73VpF3xV+Amw17u0xhpMKIQZrznlcbH0Ajp/bw58y2E2ab9wd99QcpJXJ5/aXXfkIfxs9cVf72+Av9dPpCs8NDdXoEPQw1wfB/hq45IDcEwWuTVrQWdLO4BUWLkLzmWo6J1UJXiI+x1fpO1HD+rOVVKRUgymCG8Mpem02mHTMV9jL2FZ9Q7sYPqhUbmdCVUZDN5mvzHVZKakQQfAw/5oQmo5kdo9BZZsd00SAPwI5pd/r8CpmsvA8CDgLkSmoMjj4YkbOH+idHcW9a2/uWA4x7F8umVSwTupD3mkNZwLrmfiOlAxoPBhhxVctlbSMU1D1LRSi0kYKwh4Jh0PVStNO9Am0D6XNvljDPp2NtlivVyiWjfnw9+n0kIia97f22aVjgSFDskVZjjaiJe0C5Yf/nnAB9ZI1T9I2GPRN7/l5ef88HJW3znYAdFpe7SWdNhsPzbr53d0jetrquNFPZnDceKjyYprPhWN1eL+S37SvKHUX2zY3tzcDF84Vi0FmiJYzgRTg19b+QKIS50X6hGt7yh8fgmSonHOjoOvk6w0AJLtTO5JDVbKpyIWci+HAyMfvvYa3uqJdutwN31lVjs33tOQEVEA/qwdGRCiUSFYhzCg+AGWKQiiDKsPkmoOXHVG/UbaYNsYbLe35+rY8/OteLp01Dwk4VySf8oOaQk+SZA8CyxQoqsZctZJScvRKzlWURMgvGH9EofjBaQFe2t09h07YVFovLuL0lykrGyNijFt2aoOO50T6qKdj+BbLBUTGr35cbaLLc6P/RrOpvD4v6fR8l9G88/sTBsVRtzGLxTTTrF73alkIhpeOjQ3fzg2FnH+i678zZ4Bch7QDjaYoeDk+g48Ojui6vrh0N9ebrb+nP6l397VXDld9Xywv9zFeHqjK32eJasnUXxPwLNxzsBukeSiUO2Irh7GF/sJetAJ2Ha/nqAchixUyChWxvzhQQ7Uqj9cstii6Ov3sHm4YYJirQpJ4+/Ux/9a/+DUWiaZ2enelL77yps5NDb/58ZHRg4wHkDezRKp6DgcA0my2zg3l2gNSA4jlQp3gmr+ZKbwK0yHumE6K7YUPkADaxJoeZRcJ6Ys/AIpBXFv5evR5dUF6pISJwkjQSevb8Uk8/berqsqNcpqybK+b8KT24f+ruhXuIjve11x6azNBCX2w7xyBMh+HILyCuYjcp05m9TQfHKhN43JWHw45nAdj57sVnq6aDfMb+xmhMeU5xEvJMcfEyqimTNgSMjjYaS+phPqJ/7vhKf+QyqQ8WOf3s7kzTyEb/yObnDbny7HNI7bDI3JFfmdJmR5e30WQwsfG3maZcu8Vc0UTaBvhZDPM5OHGIymYMi/J3GNNCNnLCzWisv/zu79FNNmhqf3z8of7B+FMVshXlqhRvST/zd4lG4dnPKpsOci9Y654b5gjG3hr+BFVDGw2sns4UbTjw9OlTH5a4md07ObaxueP3XvEbOGQfnAUEhvFSlH00lbQkBIes2QQiYMoMTmDL8Xyl8bKr0XhmX2IaGlu+JMNeiX9rJoOEbGe2M4gfB0g6BvI2URwnm8nG74/7QVGxWQb7On6lUnsNK+RMGpBkVGnmrS4yt76+ZEAybqPA4hf7ANeDIAoMLNBCOssyEbS9l9dXWm8byrIf79idGMXBps0Z5g2ZrkEiyDiE90vnyaEa8j5DpxuK7wAB8zwB6bO3MoawD/BsqhHMXWIIyw0NYoFQ5sPdJh5fsDMPWhtkAlRQ9gNN4o6zMaSpNCbCibDAF0udv7gIgaieg5kbbqasO7Z9xT8Hut3RmSW0oTKgzZ9zIZNa47hCVY836whvQqR8HH4hryyxTQRZip1xSMsNcBz/b1HtMqQI8Csw+BC7En5KtDT6obTWXOxIVJ3hWNPF2lDWYLJUezxRC0eIebhZFAC9AeGveA2GRcYDw2FEFwUcqehCuXJc9+8d6+Frp0rn6OhW+vY3vqv3vvtU7ebIzGBuZCYb18FRScUyPrkVReJrQ5OY+JL16BkQZgSvwFkchlRYPJRUUqQsINNgM+IfqioYx1RRFBfMkxHt04WvYxCW7hhn4UHF2i/Q9tFBBgYtD1sustQfuH+t4Tqqv94t6dvjjH7bd9/Rr0+19D+Of1erMW77aWXxt41iDxiITK1myx03MxoOReYybMbMZJgP2XKPAoZDCHee7U6Hh3l95Uff1S9tHumfnr4uHDohqNzPLPSn3jlXkq7GnSybBDAkXqVsd8ZkXGUupjOl41n1uhwaI6c4ZAuwl5NK6yV0nS/lfZD4QFijOZtrQaxYdKfpK/RYrimH3mZFWYhXJKQM6JYxy6M2q5gX/HJ57SQJ2JgPH56q2bxVKg+MNVe1FuaFSIvIvBuN5i4G8AGdjlcqlxoaRid6ftvVJpLWcrLSn55+Td1vBIOE3e5LIWdybwV2998/uk3rd5R+VcP+XJlyQfPFxDKcUrnozwx0W6yUFHkWd6h6uz1WpF6yIf+gv9CgjAZvrlSKzxhRq9l3UcCzgjCfg7nROHSXyTNIRN18hrdyeGH0UTyqmx0+mWD6AYyeVRQE9BUdZeu2pfuFgrs6UuzZdJHg1A8PnUjBQWMP233BhMUfRQ/z+0Q0qVp8pT+c/hX9geWP6kYZ/UL8gX6lfqrfuvuv9Gb3YxX25uAulnY7j1FwHQohyM62MVvBLGt3csB4SCFiKuQyKpFYE9kqyswSIlM2q//q5Cf0Xv6+VpDtdjv90OJKv3v6Pbsv4dWLfy37F4YNGINAwqJcnUFmKXAv8FkdSduUOszNxsS/wXQFop3tLQ6DyxffH3cdOsPDekWr2dxepdvCyxkA3sUJfIJZR5ZshMDtTAb/0+CAk0xtNWO2DBOZGCqvOYKQl1pRBGCvSaA9KBDFSiSp0Xit5QYSZJDNIJeiI8QoBOSHZ80yvFhCJ8d1rc9fuAtegbbRs9CQJGOGQZ37yTpDCYCMgwao1Q1saKQaCVjlZJLWg663P3InDwRvZCSeUKvTVbVe24cQBHQQv27uHX/PvseL0BjwjIBUeDwxgVEbSIk2YuDn2fhgrZtWU9XGExtvDEdTVRpV77uwkWNRDn2Q4a2LWYIKVqsvOLiZm84F440hQWABwtbj0CT9giqdDRf9IQfMZooeLMwAmE1gBBzMhQeuHnCYsVh8CfFgqcFgYBPbSrEs7KTR4GTTUCx36g57wZJoNvefQz2mXyME1MbH7jwDy5RNFHiSC49uk0VqCHYXctPADnDjgVREPuFVq+1DloMTY+npZhmYssDKvHdLXEIVg/Cf2SbhxlxfujIG5fHUVvcfHOnegwPly4T3Js32vW3d+gEsV6pKxLMWlGfzUbMUz+7VVK7mTOkP9RTwA6w54BYDVZ9fe4bOgwgLbt+94/VoNxA29WCAgB6Mjwf9mkDsuw6B6nc2DzE/gaEZsvI4SG247aivoG1iMWeTcf2JL3f1v/x2TE/HMZ2vsvrZ2aF+Vof6H61+VW9uRjre4lcbiCbMJlh5fE6s0RJIhoABl1u1+y0bniczKeU9uiBmKaaP+1t1IlX9/tFv3H/CiE5SK+XjW/2Zdz9kUKGFYXQKKGDFYGDs7El/VoTCFS9eutLnz68sxEaLhQE6sGzmlRkvXw/MFVFCoyESm5GaN82Q6pKHXPPQf48Kftif+trYYYQZFrpbZD0TrBl5LwkNB1Dgu/rs0+d6cP+BNsxcm101akXt7N0anEjoJsgqTZEiEgseop9Odhok6vqTb/749y8wqoTP37D+jv/+m7qvv5m5L87/yPFO/0T0/yY1GiqWMjo4qChXwvdYnoF98xufKhoNFfwumVWpVHYh1Wpe6fAIFmTJcq94jENvquF64vvCwUlheHl56WeDTVS34edz2NiAej6yBADWZ3AA+n5TaQ7c/qoXhO2FjFnPdLTsG3xdJAohLWgxKdx41llXt/OWZ08gBuV8Qn86/U39/u5XNd5GdbtJ6y8f/Gb/+p9d/+cqrOY6hFkdDQgABJLJCkhz7oORJA7qavgMQMEUVTCQeR9s2tzXj2cRfRKr6i8d75/BSET1RV8H67H+0fYviARc8m4peClcMe9vNEqO3iOtCEg8C1mRPTCJPC4YNNi3d7MzoQgHM/ZNLDsBe/j87HGHB3XdPz10R8tBR4H76owSs5JSqqB4DFRi8LndGhbUHHrIhYS+dq9L5Ieyz+JSFkT3YU7vfzOvAqtIpDWfTfXBh0+dNnTv9DiEbne6ajbbWi9DaDzoDQ3R2dmp1/P1za16g0EgAcXj1giTT1suFg23chBfXTS9fyM1AjEqlgtKpUoasdfvgibZzFhg9zjOXsF+MJ3DaGXu+8afsxGHMHKQMa79wp0pjHrQEKRaUJroFhOJhSKMA3BaI8t4tzExB3Y6CSaMqyDBEcBOqgve3jYkUZCNgDhxn3AR+0IPSlqn8Rzceq18PqU07gswS+dTDWDERZB50G1Cny4bwgS+dNJAXJpMN76YdEVBl4OfZ0WRQdc3h6q002nZkLdeqxsK6fd6vvB2A/IskhBOYJeNElCii0Wzofi+/PI8NIQKmeUWkgD4mrQhwtlmtk8LWQfqfiRu4aorOmBVHrbt2sQXD4mXG7vabCLy38GTE4g3guE6M74I1XhahUpKZ2dHOjppONwY59jxuCdFyfeDKBQqSqCiSi2nQjmvcr3kjZ/akWvGe+ezrvad83r9EhLgvTMbDUxj2Goh9JgDCccWPjXxQRj98nPoaGJbKrpg1QYhyq5IU+ziQkDzXTAEDwsP6p0HKuud+/PHHz/VcLbRH37xmn5xFCzK/lziR/wA/+PzX/DBVclW9EZipvTg1hsDcgvueb8PEYrCY+RuDur6L/bLSs0DseiPfVZTd/lyY/hSfqE/9mZTD7NoGqEhBInL5wcGB6bJSHTB3GHIPQnDKi8uLzwX3+7inte0uwjeN5psXz7abGaRCMVdkEIAhfX6A6VSSy0GLxmbGGvfbvBFDXZXZCsCb0EsQ2qBfhW4HtYd1/Pi4sYifn59+tlH+tqPfkXFIgd0kEbwotLvREv6uPyG18u/o3fgNX+f682vK4xVimMNts/LZNaP3dkeboLZ29rl9P4iHy6HIvozb/y07sXm+un4jUqrvH4yDaQy1MPH9/TDP/KulstvaDScaDhCrF9UOnNoyU8iETZ/upV2u6dW+zbA9mhya2UdHx+7Mnfhuw8H8PJPMu9LKr/JaTDEdQiIE/u8jDevl9d6rt6it0+WwWAkbIgUvuYNwHKJBH01qBQdiudpmaSLUGBYtLRAm//X4sf6aBTTz3Qe6ZN9Nua/dfJTyq9n+u2dXza0B8LxG6IT/xzPUVMZbXnfg7HTX0ADiNQaF+o6Lx163YMy/VsHX/mcvcnrK7ueftfVX1cMKRq+pEmK/rjJVovrmYtfNuggr8JaE9nTWNEurlXHLs7Z2BkdMf4Yjyb+xTWE9MN+YhtCintFTHKMQwizzjLsD3evYN9JkcaIKejEZwvmbZU9GY3CdOZDirXBc80a727Xn2ucgZgZKc1j8DsmhiEhUfb6bWcAHx5h9Ym8hXi2pTLJnO9dOptSoZhxATZfVizLWbLvxpOWjpAl+zm5Z7P1Z+z0MOPgmQrjqFKsZMh1MB7Y1DyfL3rMdueKxbzT64PxBsggcWtGibAYjZtdi+oBxMgG806yQb6zMAJxL33q4g9tPRp7kBKY3oGoBau+ac9v7AzHw5kqybyN/6lMaDK4fzwv7Le8ly/0oBzNZ+4GgTUicTRKIdaFuCdEsDAwqTYODw9VKBdVXa9tN7cC7oGVuGUuOP48copqhvYXrH40Htrv1QN4wwxY243NiCIIFAoZ1SwGySDWHFhLXGC001G1CslSMzLQYlGlslSOwfUCgXNw9Qg3hmrPTvkcHI41g8YZ08QzjYUHyQaKHLRKaRiQ4/W+q2BIzYwAT8diNOdh9OHxoY7vHShfCUJX5DF4HtLxMB/dRdcaz7Asi+te40xn946d1B7dV1Z2uSebLhlCitlEqNz2knq/0GxSAUVg+MFWsyl8yNLkYAOewEsXiIKN3JKCQMYO8TYcwKZLB7gC3J/Z0ucPgbVxwY0lkDnC4VHMJPS/e3yjf/fTpjuFn1/fVzOS15/N/1j4wo301V1PDRWcTJ+GgDSDcLX9/FduldW2X9Ff6mIj9/KVjm31e5/0PWj/scpcr+WZ4c1MW2fmzAFh5q4htKiSaVjEwc+Wgw+d12Q+tTSH+wNUyjWARIChdT/1Mviaz81si67bqIdp5MR95TUgqSIEubvyj0YznhPOZjuNR6E7hhDz8GFMz561NBgSZguBJRB+KBCQkdDZv3hxoTffeBS6M8wnSiV93I7o/5n4QX1YO/r8/aS2S/3E9H3V6yH95HefjNVIhSgtsifZaDEwYE3hskKWYid9qv/XsKRBnxn/QH81/4N6sUnrZ3oPpZ70O+dz/W8eDA0tPXx04s7nW9/80PcTSB/C2lwQ7a50FK+oWq6FxJE1m2ra7j6WYoyZWeGDunI3I5U/hwORWtEJkpjCgUb0FF35XeQXL9AechdZL4wqgg1lzKxoLAP5GXjEckCORnRLRRebFMqw2pEUOXnOblgJvZad65/ePtUvTUsaDyf6TyOvaRzP6M8d/sTnP/Oj7ZWS6Ybmpw/sfsPcalLCJD2wuTicmtm6Pit+vwygvh7pa7NzHzQ/lRxoXcw7WWK9nmm7oYDNaAySMMVys6BaFoN8hPAUpHMXNv0B+8uRfy5zZwoj9pyQ2LMw+Yp0D9AOnmM2IYq0fndpR55CBoa1c+xervdkyq5i7e7A+wMBBZlsiOnK4/pEGsicgtfmQzY/556hl2QdU8zTFbJAIQ1xOHU7/dB5rjGXSFkSwnWaTld2e3r4oOJDkKuXJJx5S6EGOocMiDXIjrRzig73LZtJ2gmJtYbhBgb9LurmzGYHms6ZtzPCwrPV3jtBp2mPavYxhkbIcXB7ChFiyXwwswDe9/VD3oHBPtIOoPJYQA8ciYZD2mZjEwZIoV7njAiZ36aS5gyAaPDvaqNkNCk0AaERuCv+uKZf6EF5fvUiDGOBWovYeE1022rZD5ANmY1rNJu4K4OUww1N9HARecnKJGneLEfIFkAJEXR3cUdOnZ2eehBrqnD7VucXL2xKsN5LMajYqLBhrBYyed08e67ebKIz/BzJ0TtouFqIp9P+GcwMKO62rnSgh5OsEG76He3ZFlbYSoGJw2aN8ZjgcxjmWeaRejAeKPH8Ao5AwxgcTnK2QcIUnbvEJoL8owtjdrV2xzwc7DWNmbIOj45UrTUUia7Usd/nVNHE1tVPJVX6nHTjHMBXEYF9YoCzNoFogCLtOrK3jtpsDS8ABXFoUMDwRMCO5aGi+qQIQfYALMn38+/ZWQVKaKDtc8jQWdxRviGhFGM7/XRt4E70NwJvLOP6Y723nIjA65vbipTi13/NgwNauieE3L3++SfP9KSW1G86grLI79D5pjVfBUME5r+2RbP8JxzkfHZDyWZNOsnVKEOlWrY9HoxOOorArF6r7+zJ8POAyQLhJljehfiqjLVz21Ts84MSxuon03NvRKGgIEkvpmEVMkRe77zzVZ2/uNHzF8/V7bVcedM1NQ7qFuzz9ReXSWsu4/mC/uXB27pN7/Rp9KUd4e+Z/IoaibV+uDIS7lmRyEIpwgSWQKE4vCDfmDvqi1k06wed5BvZpe5Hr3U77+nZ8kqVmxt1cof6a8Uf9vf9j67Sup4e6yy307/4VmCTBv9N2IgHNrwgGIAZVyp5ZB0izzoFajpFIYKmLu/3QWfQaWNnyAEYnEtm87Eur7ohuYHNP5a27Im/Nxi8NK2noOp0+rq5abpoS2OCEUkoCtxqKVTUXQ3PKfcVJKhUJO0lr34Xn2NY5cnAdscsILbTO/m53s6u1IuM9KDX18VU+g+Kv/7zn/nXoyeyte+r2vGXPu1/xwsE66fe/4uqxNZ6J7n2Wk4rqz6yIhehEKmYaeWNDplp7Sg+YGRmnKA1kICQWc2CjtyKgJgzVYNmeOmYsJ0lPmtDnxQRyOKQTrGPUsDyIp0Gx6i7F/M5UDoaCxu8A73iQlSBpV8IM9J10HzbM5a8y0hM5SJuYxE7jHGgj8b9YABxp+f2fBdTdNyI8rZEHPSnajUHOmgszYZnbg+EP5sPg4PPGoMKDDoYSRGcEOKplktGGba3dzdh43McoRIxIy7T+cR8FZN0MIiJhcBnm7XQFXMeIFNzaDSylYg7z8Z+H0ffGgFe56D0IRlMFpyOM5t5Ton8xN3yKtw3Cn0+JySdVqtnn9dMLhR9h0dVDYd9oyl09sxSyQR+xZv/C/J6HQ2VolNh9mKLNXmmB2OJQSouO7hTtDodbaNRQzgclh7UIxS3jRrpCxNFZzPrf/odrK2kg4O6HpydGlu+vr7VfN3UbbPtbs+1wxy7JEwM8q6i0CWsFviKxpSK7vaYODsqs4mtmu22od1YHLPqvbkz5KA91IgZLjMT7O+Ym8VIJ8CdJJEyXZpuE3iCG4nTBhIB4FC+F7Ams8lAvJELhckirUgiYhbrZoscAkOCpB48eKSDg4eaTbdamPSw1adPzzVfQiDqq1iM6fispoN9SjizEyfJx+7MDMIrpF2EjhgKNTBWIJ7ABMSDNu18NnSLwGkwQK1bxRkoheNQzkjAllDqMfDzwu42wY8zrlQmzCuZhdhuisLXjLKwmZWqeR+a7y5nDsL9vxQ+8KbQ7Q70ZwfH+nr07PsP9rtmeP97j3Jr/Zs/0goH2nqpehRmJ+kcgbML+YYuuBQphc0H4g8Q1V6wf8fuXW/Xhod4T/hAMu+tHcA8Jq2djYD8wkCrR69l7rkPwIHG2YwLGvxVgUpxfCL15O7A5wUJiSXBc0Cn2Ly5tMYwn2uqXKr4YCWdhUv09DmC8AAFs+gQWy+WIz179tzd0u9/8Za+MUUmEKDjH7n5JX2p/6HeOSrorYcPVWvcRybvAoQigM6av8oB5kgmLNZIVKHqjdKtBPiMapmq+0nvqX7yNKn/6YPn+jeaZf3cpKhf6GcUJyx+u9E/c9LTu19+UwTrQACigCMFHkYgJJfr6yud3TvytWezp3jlOgM7o5jb7UZ7u8fwcqwbBC5D9SsNemz6dPZTrbMvbcDuYEGucavUtYwmB6EnHmZgpSybNBFJfaMFWOvxmZeREDpNAoThMPuXzkJ0WAwdMLOzvL626Ovt3VQ/PP8vfGizJ/3L+qqud//NDiuvt7+nH3r+C5YRgbLEupeu0W5gmGLKwahoGp7LfDZlE3lv+IYymXUmFE8uVCiUlc0BNQ4CLyKetOgfVIdwg/W6Z2lP/JUZ7DZK2gnuXCEuioN4FYegsg2fi8yuVyLNIE7RSbKX0XnxtZAdU9m0cyBX68Ge+YltXZjTsY9ta2UXGCAaIAjIgCzBsME6aU2h8MArF6QXq8xWZ6B4MmuTFzShRI5hfE4gQiKdCAflOrD/2TPNEWCUtMMhK9iFIvhHwsN1RO/O2M/BCnvUin0aswC7ObEu0UraCCUwj9Gw2zuY+SjuSTwfyPFWQdVQzOXCSMJRbxuTBkExYNvO00FWYkLQlr2SbFGp2+77GmDdmc+lHXdou1XQQn4+o4RsxrybL/SghDhju6ctETN9zTMLt77OWpuDDcNiw0kjhHmyCEplMgOXmrc6YeQUDa01xx/i7nU8ZiE3sTBYOgEd0BGsZkTILD3T4UFj+A/L6v7piaqlgp3x7907tRYSurMFpoil0fBlMl6ci2XGD2E0kTC8AOYdxVHerN203f6D/VHoFNnw6FaCzCVEAfE+PRFzjl2Yr2FPR0IAB8xN89rDaISyFBK1Rlmvv/XIqQxoRbE5I9mj1b7Q7U3P14mKkgSEaj2v07O6nrx+Zph2swkJGECsAR6Mfl+VPkvSAcJODdILx5YBeeFytIro4ral29u2mrctH1RsRlRYwOEQK/IZ5iDMGpDSEM4c9ITMWoE02QiZQdmIeu8zaoH5JsTSsBFA+gCOOUvSeaLLGut/OPt5/YOjmY5PTiyGxugBXRqVXq1e0sPHxypVUspnoHHvtI7R3YeDsT8IaSyQv0aLkDTAwR4CsUPwrglHe49Rfm+4RJ7CjBXSGPNwOnryI7vq94lWQ7cX4OrPN57OQLfxqY5PYJYGuN3i9NhA69jLSh4YsZSruAN1QkU0ZaIDFl7tdtckHzrL119/pGTqNTVbV96M+Lovf/nL+u57X9d5q6d/9uJNfZwkVEp6Wy39nu5/GZjdeTR1W9UP8IwFfRgZasyjnYXhhwYvugnG8rGE8rlMKJ7Q36GvTFCgZW3HZUPsVEyV9UD/XKOnf+lJRv/YBw90uUrpP7rGgu1U/5NGU8M+9ntT/wzszMrVvK32CgUsBwtarkKHkE4X3TWsV8FFCBLSbveyLXPoro3TF/rog6f6+q++78PwKz/4rtK1l4cUmw/GDHTjdLGwEzHYwAu1O+hoNq8qk0upWg1esHT/yEuAnSkEmQMyKwZmJQKrnC+rUqm7oIK1DgO1BgIz6KvdbCoyi+qP6laZbEnjyULPzq/0ydMLfw+gXNbBQaOmLRyI1q1dY9horbtmg3V8U1rlQvh/tKmZXMmQIZv6dIwJSkyxCdmpLQv7s9mCut2xCwKsKiGBAS8S+8fDxzryTA2pBVyHyMbGA4FIxxhq4w2aMRPOMtfNtrqlPtE0fuGEk9iGIHJfF1HABCJSbP882DzDYfIcXQzwdyoVyJQkXCKr3nAQDkng0QWxgyGoGrKe4wvXW88mW62Osmk06xOPAihGEOozJ9zuYvr0kxcBfcAbORbX1p1hoBBQ5HF/eVHcg06xfu+yTCHYWY3AYZlKqo7MZhvYw0hcsvtwa8duMXKDWwFfZTXXg3unSsainlNi2m4UCWtOhyigEIDJHnezA/R7l2QCsmZEgvkrbmjzrUbDqZ5++tRWeFjsoUnm/bF3sP6+0IOSrDY7smAs7O4mwAEcaIFdFnVrTvQVRB+qwtOze67ImRVgMH6n4dNmqWIh50PvwdmxDg8adoSH4t7udnVxe+uDCVrODhmExfJzY/FsdqvZRG++/brnm9xY5k/xZdxfzyZZrlS0Wmdtpmvf120gqUSKUT8wwIswzYDuhlC5gYOh9DMMNo4duqvgqQjEgANHRuVyIfh82iM0oewkq9t2U+eXV4ZJZqtjvfnOYxtMx1NxbyrXg7bmi4HGs56hh1Ilq1KlqMdP7um1N46UL9ABBVMACjZuYmAEvsQymRmGDpPhO+9xFzxWpytl0gyt13b+ub7oaDIO/pH9bpgzdmJDDbsTnZ5Ulc/HVclxqABTrM1G5eCEVMTP3EV3SqJJihLoGuzKZEgzqkKx5Ggt4Eus25KprKr1oqPCtMNGjN8fOhMvmw55g/lcTKVCQtsVxIOkMgWg39DmDftDi6Y30cCGpMgqWHMbLNKovpkZw2hz6CxuKnthPBA9eaTARwnExRBB0gfK5mF2tgMMi9nD58ViROfnF6F4KxXN9kxmE0GbF3tJyweOTVNEReKeEYYZV2DoOZorEtN8OlanknX1fXp8rEG3YynF0fGB/vZ3kvqP0z+hT5KwaHf60dxAf6jwPX2MRa+Nw5Ou2I+P61ptxloh6IeViBemYbml3xtzH3dLsBp3UPsp8oJX6mKFlm+h+w/ODEtRkKSzcc1GC/2J2oX+UPdr+nhZ0L93XdV2MtVv2QV2NKQdNtt6hRBkchRrNoVY9LGIhBMw8YZMR45BO7+AqO7cjYAT2Xzc3e92ajQOVC7VTFahGL17ER7c/4Q5cjj4QD6C1WswxGB2qkjF5vaJGJpYCHcQ0DJmqlK0URCCQsEVwLs0GmduSk5iKBQSMDuTkM92Pqxx79msZ4ozoiDPnlDrZNQw224x0wTCYDTihCH2L2RrIZB9o9Q+dJi9JJBBFqqVQ8A30ifeW7VaVr12oOcXl2q3z20a7rm4Hd59TKjT6qterurJkye6ubpWsQj7OqHFGjlINHhFg5Dt5QyA4hQUQLZ0a3Rtdy/uz3aw9aHEjJFuFr4D/03H2+8PbKFpmV4cL+mwL5Cmkskxegoac/aSUoW1kdB8AVK0c4HMe0FqMRoArYYAcjraDNmNdGVGbFKiIeRgj8C/st8vc+bQkTHm4Ovs1ETHqbWKpYoJfWRRsl8HdGfj/69Vg/Uj1nRaJ5XY4Zo0sVyGb86zDRuYooZ9ezQcGqLNVksu6HhxP9in6PQ5rbn8FNneEyh80czmSG0ikWen5XypKfmgmZiqlfw+CzTI5cqlnFpLkLfYF3tQVsoFb/x0FjxgHiQTXIzxMDoqMxMh+jD/w4k+uPGQPm4/UA1dPSGsL5SrquQzqpZzOqzXbARu+IkMu3LebTZykgR2dFGMvqWMzXgDIxQLphwm0EhDVisNZyMfxOCbmWzBrii4/LARwsbigBphHbecKh7lwYWthzsPmXQsFDRyq5BGjos+szvHakEsSqqQL/mQRPBbqZWd7HB10zKjCzHrNrLS0Wldb3zpsdK5uJYbXIR2WqzH2mqm49OqyrWSF4dTv8sl1Q9Khr2YSTL7DW4lCKIJLo5r1365cMz0xOwaqQcb6oSFnTb8yAYEAaPd6qqDLmgBPBaMEeyCooiGvYGSiZ1KpVPPpMLMOHhIct1ZdDxDoWBgg8YsAKpUMDII3qBo8Fg0aRMJzFg0Db2i5RLYk8WCn2zI2cttUg6yJouOaC8OWx5SGI4ULlGM9hIZU7b5E4ylgdF8UMYwVuAzsElgtsDsjAJgp20sfH/ukS377L0ZFtDZWUOHBzU/p7c3Melqf0zSNeMnadZ10JSymWCbOHkltcEp6Ep6zmFShmnrc0O2pSIznYgNn8mZPD6u6fjkyHMSjAW22YL+RunH9Un6UL+5MVc9Otb/ovZU0W3BKST4vNbrVc9KFis2YCz1gocM19ZJ9/ZA5r5DYEiY0MIMhc2KDYFnhXvknMcsdn6cQNy3hVYWsUs/c/Y9/bnx6/pomta/PzxTaz3W1zpPlU7wHONHi0/pUDc3a5M6YD366zcLZXIZpQpBIoL2zOOM/WPI8zcakkOY0ptvvqW33kgZ5l/vVnrxypigUi1pZYeUjWPSnGW4xeACwfdao+nAh2g2WwyZnDPWW4hRciewY35MDB3e0jONh1PF45iDFLScD7zvgCQx/zy7d+pNkc6zedsxtMZzVq3SWe0hUZvEB8E6zxRsx+DghVtLSPUA5uRQ49Rj04cNiUuNi1XMMjJ5Fw0cIo4AZOYKlIqECMnMdK6b21s/e41yQeVaQd0eLltJZXbAxlFFplhG3hV7aS3XMT+D2C/m3Am+REA4NNLlkqFZJHSsUdi65lyAiGF0YngcBCpl9IrmBQtHp6MQrs1BZ1MWkAgOtYjyhZKKJWDWgfNMW+2uRy28J4IgMFEnjaPdvfV7TCRz7t4q5bJNPUCaHKHocRDzPeavFNTy56AQI8rLBZ5JW8F83w5myaTqtYqRyXG/r/Ggb7IcagLIR2TdHjRKwickkybgYquEfV4zeyOQcP1D9Nran3lh29KEwy5isYkLYt53MJ1nX4VYFdCRyWjicVkyk9Bbb7yuROKF901mmF/oQfno4ZlDhXtdbMeCEDxgxvhd7mGFCC79CM6hHKNrYpVx4CSVSWV8I5iR1KpF1Sp5FfIplSp5H45AHSOIFjYiCEzNmOUQEds8EdsDk7A/6ptunc8RIkvMSl/NTktbor4Ypq922sUSuvfgTKdn973AMNBFW7hdh2qdjo/qhqqUTplqkqqXwTiyEyATC1R9cCVVLRcNj8KiwlFo1p1YYsD8tNaoqnFWtdzj5PRA2ULcWYUcutl8QpUtOraqkumcq1CTchzNRWGxkLUnHKGOnYFxGzIyebDuXmwK+VzUi5QDHSkL8wsIAXSX48FQzZsbdVu9PXGF60cxEFcCnD4VV71W9mYPa5aMO6p1qs74DoB5szcUR+uHsJfsUSAkTIjD+6ajcjXsA4qlEuBZchAhNcH0CwSNELXG3MDeo1SgJLIjLdrY3ynERHV6Oj8n1iuid959y8SYCZAInbwPTKpvDnv0YDD6YLDhCwnZIEBnzFi4dzt3m1svVsJnYe1hSn93UAIpHZgYEzL8DI1Px17QvQEzqPDi0F0v1pqOp65ogYK5DseHCPHzZtRdX994vt7tttzVnZ6eKluo6l95UdLPLtL68XxXf/jJSGXhxwp9DPgdEhvPXVKZHEUgZs/BsILF7USP5XrfHTCDwUcYC0QDjkHoTRYrcOFu7fdvXd4yjBuQOGGHSJFDKPk/U7zRzz0d60+u7uuvxd/UsBLX716+5+/DOg3EDkLMh+p22q6zU1lGK/iWUqBMDUnBur0jOvE+uLdApciLqpVKgMwnkGtewles03WtrGF34MOFpAbQmgi2jtEwU6SL5HChg6djQ9JARwRMCgEmfhfllc7o9gbDbYpzAoxhz1IwhWfPBI90Uk+ePPTfbzW77nboMLIZfITplEIXB/OWA5Jr5WQTp3UE9qQF9Y5iynoexvdkg0Yug8EEBz6HCh0N7x1dIJ+YAgNeAPes3+3p/PlzpeJn3p8q9aKOTuqazwgJnjtHN5evOMqK9wRcqMUeTZjxfV7qUVkvFIasZQ4IDje6Kg4d+AWsCYqrEAYdfHhRE7CuWRtawKAGOg8Mcj4nBczJyYmfn08/bbljpzNzAHOEIrqkAc9Dr+UDdrXiWUEtEFOlVNrHrq32vr7hWaCgQJsJDEeBgpzqiIzQeELddsf7kt8HhTYSjulEiR0uSVsVYN7Gcsoc1wyFF0tFVeow4ykB1tahU6CC6oUg6Ij666G7b35RQEeMVoRC19IvF9GBtInVJIjCqDdSZLdUrZLRYsY12jp4oMy9LmZUKOW+2IOyUa9YQE0nwabO4qdKs5n4PkUg6H/CoYNx87PzC436IRGbg49ZAAcThxTdFJBAOpdyh8hssm0x78wfhs0CkhCLH10mv3iAMShIZKIqQ0rgRu1WGsIii4UQZDw0CSHFL/D07GhveB4z1FsrF423Ay0YzrPANpimM09xhFRkp0K1EETL66Vp0AhsYTZi5dYfdDzLhIEGAYcEhFhqq1QhpmKFTpfU8lA8lMokvCf3XoocjMz2gkYzZkIRHXJgslLtAmNTMdkekDDs/Qucf0MQst1F8opuWSQ2vrUbifM1Gd4nSaEIxIzDw6oruEIhq0ajontnwXWFA8Up9XRLq4VKqaJTNHjo3bHtq21myyxA5h7e3EggQVztYGbmqGEB4v6BOwydDptdIV+0ATKFEl0mkCId3878jJQXzCeffaKPv/dU5xfnwmd8Nlnpa7/+q6FKX821ipPoktoL/3fB2zUVV6lYtq6Rg4U5K7q18YxDPUhR2DyBkoCNE4mXczPMIO5vE7q9adlqkBT2XYsElI0NxJG08KJTx06Og5L/ZsE5HDkTdICIs6lQ2WRMWOm/p08+eaZv/Obfr/d3AVJ+OztTfjXUzib7cdPy0QczL5vO83Z2wfkraBdD2g2dZDqVDdW60y6gwFMkhk2e4oDngvm2i5gELiRbmzGw/tIZ+AB5z0rRymGOUB3fqLwu6zpR1y+mH4u+/XcOfsEjhHwh56Kk3+trOpn62jE3zxeqfh900gU2kmVeaoZrY4kUMCAaT2LOZiPPvzYjyB4vtxGQl9Kbr+vy+Y1HA08/e+Y1kMw0lMmzDosez5hduiRpY2qhOIf448ePgnvWmvufU7VWU6vZsVaPPSSbKWk5D4xtNk9CkoFd2VofPbrnwq7QQ6LBXGqmfnbsOZqLPQvYkT5xSAK3EekXvFhpfzBXKJVzSiU4+OAuYCifdWQWHfB4TOQZ+sq4NsuZDk+OVKnkdHN77bXAdbm9vVahGNGj/D1VD8o6Wx2p3R465LjaaHgkAJTc6ePzS+hA6MRhOHMf7l4cEMznVgmKwqgLXHSRQJEQGWGm2mM7Ko1nE1u+Ma+7bbXtvzrEJQdI2rKepBEjslGrdYzUWyarmYTkKKyFUuukJR9c15BPmtwf8CM/w5kMblfIKxhBLLRehmIVKNtRhRGK+Yy5G41a1WsQy0iKzmarqQzdIHv1dKI4owR+ZiKiZD5lqJWiBNMGOklGnoVdVvk+uaNJj1fujFM42OkCmWODULDPNDsdv2/rwG1nFzVEn3DwA0/9PrbLcjPmmCBLHVuCnp7UlcxmvtiDkow8Kj8WOBsxD4w9Q9E3poh32otG6WRSQadH/AoLkg6JDiNO5UbSxhq68V2ixdazLxxVyFbkYKSSxWMzncx5U6vVyO8DforbDi+RSSqeSXrjzdPq94ZaMrgltHUA7h0N7vLjocqwK10t5k1soSpzhzSZqd3uazbdKUGy/Ab4aqV4OuLctoN6w53f0dGRyUHAJLdXN/4szAEIFq3UqiqSA1lOOIuSTT8EQYfuimKHqpquhAKikIcVt9ZsifZvbW9E/h47ZmCW7clEtmN6CQlyuC9izCkxHM8pnYCAQsbgRsPB1MzIx48eGPYAwisVMdk+UKVIdNDOuWw8hOwPHIBATcbq976mwHtm0W2AOoO7kg8ODodm17TtxSyQTSLOtuNzBDMHugrfzz2LFpIB0CTO/jyYbCLYk4HOY4P49NMbfeNX31OvO7IAGJeQb33jQzUaDR0dlexeFIux+TEfznjTogNCj2bTeHSGtrQK8pZKpaZBn7nkWrMoc9lgkUbk2N0Ls3EYskcnVc+/6MQV2TgMOZarf/73MCy/uL40fIXUBuMLDkro8QSBh8R2RN0YUdBRrPVzX/vH1d2WXM18LdbST8Uvtd2gFcZXdqSnT5/p8vpG9UbNs0WqcmAri663zNRigdyUifo+hwirQN6BCYvOkQKTn8UBtlzN3Q0Do7FhcM7Waoeh804S9IsVWQgn/o1P/4puHv2j6qXr+mb6obLxiP6p6HNDnsR1dVpjjUfo9Mj+S6neOAy2YJtxSLcnPPxuo4jHNep1PYagSRkMekZ/bOs4e6n5Zc288faXdO/4kX75F7+ui8sLFzeHp3XlMjnFkrsgG+Bz4vZDscncaZ+/aT/pNfcxaFHNQcCIf0mRik0cJJhYyEjksJ0vNJ9MDKNyzfFexYQjhxQqEXcIN18DooWHKs8Gwc6OmkPwrxCzR2Qdo6DZZOB7u12vNJr0lE2XdO/syBKSm5u2er2uIfxao6TX3niiWr2oXq/jNJNCPu2kH0ti4lGd3jtSrdYI0V39mb773Q/14uJWw/HMBEDGU6Ac8WwImrh78bOSC6RyofN0wTmDSFfxuMOa9SIB5HL2JAUXpEQrDtBYYlKw4bnJqlguWoMM7LhaUQgOzd5m0ePzSweNyxL+rKxzoHXWGwc5CgV+Tq2G/2/GUCprBp4H4xM8agv5nOZLCqSiPZ8p3DvtjgviPG5IJyd+LpHEMGbAcjCahdxHsc21J2w+6MTxPsYIHbTL2ZHbMH6xHGS6cGdP8Z6AtxJDfcAsPWObU9YNRXXAcELjBvAFwglJaI3132phH+3+aKRcvmikCUefL/SgrNbLavSqymZJxwaWxD6OzZSNBwsnNqcAJbF62ejQP6JNjKSCZRWdGw8hQ/PVEtNkcPCYraKoCHCFYHFgKh6NpJSKZzzYhinIIcSgeEcqxXZjzSaOHwfHDR9IhNp222Nte0ABbrbU7fV9c3mA+Vq6PY9udzsVc6RPhFY9lZpoiNsOoauVrI6Pj3R2dmLaPxE4N9fX+uDDD9XpIwLPKDVJaUG2XzqpXJGE8GCZtTPsCZTGfAXyEtlx5eD7iHME0BmdGzZKhYwNpNl4rWV0wgbZdrFgKGzTgPCis+JwgrQDE4+0Dg4hhtUE1WIEAUvywf0jFwPA29FYICTRoWG5h4eAmapJki5IK+eQgg03DF6zkZw7XBwuYIQyh+V9JCLxwBDdb+hsWg5PhrRjUXPofHlQeTETAdKj8qNS5D5S3c9GK7Vuhrp41nRI82IO5Z1oLAqiggrZsl1eomtmrrDieiqW6PIxgV5qMeson+d6BTo4BwJBscV8SYV81R17+LwI58O89+6FS9IygfMM0E7MYcxYeNHlNofMNsKLjo7ngWtsh5I80URsEIlgF1coe6Njo2bk0FputUwHP9R3dz39bw+QNPGzk964oc9jQIGkhE4LqB97MmY9EDO2Kxymki4IufdAcHxfJAwUS3SUVOxs5EESk1ItmTIjkQg7+/9GiRji+ZElF7tdyhD15cWVTqsl/cHp39S/Hvv71UmW1VNSl92xYvOmjQvwoYX8BVy5WEx08aKlt760Vq0GtDtTZPhy/dOtbjAZtzE6QvWJYguuLQX0y+6d+1PjsEggkyJtibilqXrdvt1eku6iQCworELaDNdmOsWNaGZkiWJiOu153s6sn/DzxSwcruVC3qjKnXEBRbDjlSIBpuTs4dmAS4GQ//ikYbcnLBUPajWzIgltALbOTDmgJ2bUMwIAvs2kYjYOwJ+Y+4DdIZ0qMCwHULONjd9Qrea1zs4O9PZbr6nbLdutCEivflDxLJGGoporK36Y9b709Nk3dXFxrm6PaKjgg2okzusmJKrcvejIlhQwdtsaa7GaKjXamYC1q0Bgwz2HCK+I5mvg1dW+kFqrO4A5zn6RU6WSdz4jDmHM4kDIwoFY1+3NjVELkDofgiAR06lDr5GK0JWG4ItheM62FK9bjzqQzQ2nk0DiRAcKTA5yF4no6uJcN9dtzwUJNGCujjwN1AwE0abo66U/O41D8JtNe/9zdiZWmkC85HrOFuph/L4NRgKT4diQ+QaDAUz204w1COWi0HDiRAiE4GdDEEtAJkTuE9YxVUmIBCNlCD0pBjNfsNfrw9ceBG0OziAdssBmNhKnOk/C2GQ+xGbPsBqIwkLYhE2HgeU43smgi0SIzQoONNl8znILHlBgJeeH5VKGUNG4YYQNNBJc55kbpEweWOCcAQlkm3DkTP5hSpVCUTfZnm2QlnNmgcEMHTKPzQ2iweRgtZ579pPN51WPl3zYQeqYzSvuhir1kisjDmgqlcubpr7z3Q90/uKFDQNSQHUc3IhVo2zYY+UVMs6YyRLbg+EAldDR0bF/zyngdCPIHLg2qbi2y61G06Hh6ztJBDT0GSkU47GG05dVOrKH23k/+LpuceYJ18g2YiZYzexqwaFdqVItbvcRZaFKtWftJkBWFDhcbw5tWMtAG3fvIbnDwT9EcZFKzj8cfGy8uLEwe4RcZWN1C4eDJ6pNiW2wvR/sJ3kWIp4LDztDXZxfa7dO2JybGTfdKfNAOuFSKaNGg6DrohfcYLDV1UVXo8HIEg1+zxE8y5lOzo59vXlPzDTQlrVuuyZesJhZlJ6DYnq9h7XCJg9zmSKDg4jOP+VZYblW1Dq5ka73ByWksRxi5JhyRBHlsM6CsAosSSBz1LO5q4srXW0S+tbJT2icO1Bis9LvePGfKfPkNwRdId7Atuba6s233vAhBxrD881i9TxqF6K+YA7aBINcS6pB/Cm3K8VSqRBMjWYY2Gm99IySg5c3yu/BmqQjxUEH4hS5r3yL66trO/wcHJyo2+np93z2H+j/+NY/pfcTp/qLWusn+r+oSY81zOGzj4BCPtHt6ubmVo9yxzYGuHMw4YWQHMkNPxcoHB/T6CBigXg2/VJig+EI7xnewAJ2u+0ssafsG30pKWvIDHjU6ReEjCciYdNLcW8C9E8nPdsQ5RdTJpXTZhFyUDH2puBg1EARvtTMaR2OVNqFAHG6iuUSw2tg17QP8+fnz71Gy+WaGhVm1FPFdxvVSrDZi/aNYdMu1epaXQc0DPMHeAT401ZiCY8YsAGke0QPDNR60MAEgO8BsjLTZNj3vBBGd3CggXG/UbvTcjoG6wYmv2fWDozP7VnbL1nuRFLNVzs1O30NKH60Uny0cfwVJt+cDBS3cC1Kq50PEKwYyYXlszIXRutdLJcVS0Y9MiIg2VanDnKI6uL8XMVc3uQukCIOtuvrVkg44mowRotF3f13sNuLRdxccOCYdY9xgiUuWGxiKhH1Htft9rx/2XcaaBYm8hT4E9kH8Xxr5RwwkfZBCE/FMLwPTxAz7P4WPuzhg3APB5O5Q6jxWuY5ZXzHG40wj44FNyJxLiMf2fNlYnj+5tKqlAruHKv1jHIFDNtxakq7ULItIwvmizwoqTqevHHfM5Srixt98MFnGk9GFnQyx7NbzF7IWa+WVK/jw0p+HNVnoBPTDfpDxIEDU2FAzYIU4vbgE8g8EE8uNnYSuYECORjoqli2UI7pujJkAEJrXi6UYw54VFU6kbKf6u11zwnv9k8EE8fSajp3QgczuzuNIDIPEhfmSyr8jR+mbD642zy7fKFnz851fnHpqjtXrKpYbfj7kTx/cnLk7hNqfjoJDDoNxr5b5nbkzOX3h0V4AMxTQ1KDKwRdC1AluiPc9s2Qdg/uh52DBHeWu9eL59cqZcYqZjmsMtoAc7NAxiETkhlipQIUF1V/FKjwXE9ExvhB8udUzNUa7NNwUPIwU5aH68qsM2gPMbZaLIG3Y58vcggWdGKG1oGU8a0F+t7nYlI4MMOgmwYdYBaK3RSw7eWLK03HS1UKZSFAoBv2PXdyzNbyGCpzKupBd6jLy1t9/P5zmxlP8sDkfcNdGD+Mh0tVayVX1NPhUutkOFyiittMAciOTRRUAtjy7oWIPhlfOVibvZ88UebL2UJSeZjU+4MSA2/IWHQlzHXxHbYOeLawFheqOahILhvTp/FHusyRmyj9hsknJixcXr3Q0QkMPLrwqV1wDg6Pw9ds8AqNqdW+0WZl/kPwtd0FQ3nScai6E1Hs3IKwmveB9RmbFexNO7jk8zb1t/k3XR4G/5BDhqQ+cJCxCa91cHjotXp9canFeKof31zob8XO9IuJB3q0e19V1usGFu3WBy7yHApFR5VZjD7VYvkS1WB+ziaPrhBnGDYtDirM/neQUu42+R2awaW6g647QUzOgfCQ80Dhh/wGW34+H5thaWu4ekOr1dRry3rRaNwpH0nkI7OBxnMMGNAeYnM4VX8ws43lowennqWuFhPDatPJWIPVwPcbGRBdEjm5U4zEtyuHAN9cXnuck89klQR2xTotiiyGdA8OxahK1bo7v9GkY+IcGkgKz0q1qpPjI3X2tp0UN7h+UfTx3C1BATD8dlYv1zemZByiWyDIUYACqWVSSOFAstLeCyDYcCjcva6bXfUvrj0emi3QpO8UWa50cd1WqVZRpZz385ta7DxeSSdibkaaLYoDyHrIkBouwhhrUfzxi8bh5PRQ0xHs+bEalQOlE5Ait+rvY73IrwQSxjDBhCm7YiWVyxU9wmH9Q0SMJSOKbSKWe1D0p6J5d3FwLxzzRcRhKmLIEyIgxRTz8zkOVAmp0xspm6KjxnAe3WVwP5oNhprMsImMuChs9bvaRoKjm0dZJpHulEkllI4RyJHV8vBIsW7fc2Ua82K6bCSMZ6iKiiIRLPkymZLWkDX3WkxGTzsTE7/Ag/L84kJHjaoOahVvihTBiJfZBNnU2YSCdoo0gLyODvM+jKYzurcgQLWgebszu+zkXsOHDJsBH5CLDyGBipWFThOKfMCtNl0C1eMyQF5oquhuqb7Ho762u7Gms6WaLcTfZTUODz3MBrawCUGO5I6dPTyTqZDRhgiXzQHhanrLjJAOK612t6fLyxu9uHhh8gayk3yuqPoh7zdtxh0sNFiiVPHxJJDXwAbgIYYmHCA2JA9uc/vUjs2+w52apZkBwk3GtUaqgdGY9YX7zi6ZVvoVMk+9dqST0soaP4hSw97QCziKvpOuPJexS4UJIiKCB6p96PDmhDeL8GEq19C5Mg8NCzOqLCEJECim5CUEQgwdGGkBdHJAxTxUdGzMJZD/mKJNRhyzBGQtEK9wdlkw84FhSGcQD9Vot+9uoJwPMBwwm+Vnu7WS6ajuPzixfAJfXqQjdIjd9jCwCTdpZTOQNjCcnunmCuOKiGr1shY7iCAh5BgXEGQoHJRIBLI5UjxePru2+oKKvNt73prmgO1fUoDKdy+sBI/S9eDmkc/4gOMgZ8Nt3XStlRswx7bW8KWX7I82v67lBoib4obCcOn5N7OVeWOlGBmBzEyI7ILibkY114eiCGID7ioBirMpsiUsgaxB8bNBYgCEsLcDQ2tMOg7XnOKF+R7PnVNytPO9ptDAl9Pddzat37x+7oOSF7B0SP7AiCMUduUyHWjdRQ6Xjpnvq25LQF+pTTAQYMZpAtiK319qPn/loNzu7ABkfbW1geHPIEFB3FkQLmy4kBipiNqtnp+3ajV4vk4mQ/+95RbJGUQ8whBG+4glnu2UJsuZu5dCLm2WJesYszSnlGAft57bmhLIjeJ3tl44qWc06hvKLeSTqpYwys5qF4XIhN8qPr/MPjG0oJOnmM5qup4aueFQo4BGTwxhDRefUqFoyBECifMvYxHD9nSieIuCTETIuJ0trDGs16d2wSGejE6JzT8EoU9D6PT+9eLyXIteM6A2OZIzor4f3V5HV1fAiE9CGk4xqUV8qQjkwmLW73PQh10Ka3ukWgMyUlHFCsgIAeBrLQsbLadDHzAuzinid1HvcYlkXzus4bw3BCs8YMpiPmf0Cb4FhSOjL+6DZ4g7cisxPsFMg1D58Pf4fxjFNEow9EF/YI4nM+ngXxvZahqjfYUDwPfDQ7ug0fXUe5td0hZ9F/sTJB6gipam0GiFkOw7m0ZmlVnMV2jENkhSiMjL+Hkyx2HYVyoftJWsMbxjKSjNeXk1CPSLOCgvzq+0g45umI5BdU1HJzXNpmw+tNU73xwgBaA3NhI22YhzAaOeF84WyC0qDu2FhQUNnbeJ6S+bci5b0MMn950KMl/sNBrM9OFHT50fyBCWmafjfzIsLPD3gkkIg2FXLy6vdH2DtRTBp6c+tKA6wyYr5PMeInNxSZhAt5nKkDYx0sAuDbTsKzPjqCRxY4HVd3x66I4A2ypgGwgq7GXAcOFAS2i1BdMfODmFB4HZCX+Hf5uQ4c0GghMwIxAVDNPgHsOhxUHgyt4kEZxRKASAI16KuAkcTcXJe+ubTQzpiAOSazfdoLPClCFtmjUVJFTtEFIbNEXBjJron2GA0yxD4aEJ8Wd20YC6nQzkCYbvIU2EmRpSksDITaUzqiC23gb6OoxfkjyYyTgGyCwI/ErZBILrCj+Er71tNU1CokjCmSWZjvnX6YMDlSoYzEvdbtvaN5N1pnMN4iNfC4i9wKUJnoEoMGoIusWdaLKZe9ZKRxpIMMzbQlrIy01+onWGYO07w4OQHuD7FHu5UBwhVK7ZUQh9JIsuV6QLT1pHfP/+iV48vdTXxxn9XOQNf80/9Ow/17Tf9bzNko3ZUpdXLbMhgYcX07WSMRisG63wNjZsHeK7gFyJWaOTDGHkyK5Cp2c3oiQYAySmrBKZEEnUumk7cw92oz2TyWeF4JGDFJNSbBWeNQ4h1gDsUDMB+1f6bemv66+Vfkh/ufFj+unJjSL9rjsgHKQODqs6Ozv29aGAW22SIQh8/2LtUaQGr2QOSTapqHqdkUav8CG4VqBZh4cNvf/e9xRJRw2tgyDhwMOBx7clIovN9Pqq6QzL1994pLe+9Lrq9WPF4wP1OiSQ7Lx5npDOGE87cJiCduAuK+qwdTTRB42yi1hGDlNH1OHiwwx8rflqrHsPD61d3W4IaEjrqHGgyBY/443y5YI3cnS8/VHH9nGMlUBauH6wyA3xLjdqtVpeF2gO2YwJmKeIZE+C5c11Y02jOWTOmc6gCV2aW/D44WMVCzW7B/UGE/W6t/5ZsDLNen8l7mnBMy20nWl97cd+WE8ePdRHH72vD7/7Ha2Xh1pOZxp3h4ZJGcUwz4ZtupyvNZ9Q4M51e32hg6OsZlOKPlxsQNtAvtou0j3jnEKypEDG8aisUn+oCdKQXdBiU0RhndjWLjRIzPjhUWCPCTPeSAcHJfA5rFWg2Y2SQ9YOBxFrNmoeBd8rZFMm9fTjjtaLsVLxtfIZCvpAwAM5ZI0mEzm1e2ONGVfR1CxJVSK3N5iYwzfhPTAjXYAiTBdOMFkuJx4zRdcJczwCTwGCKfsDnAyIcpxfGU3nA+Vidw3KF3hQrrkJ/KKqy3JRsFNKKF8ELt55flZrQFigTYYxR1pFsIKDaUiYcR6fRAT1iag7Uoba2JqNbvomCwGToGvJ5Aqazjf61tff04vLS40GHLhJFXJFFfIFLRcTP7SNYVlPXn+gZmeg2Wqr47N7evb0Wp89e2aG5GgyVB96frencr5kcsnlVdOyCVhr+QJegJi1oyQMxrr3Hx2pcVz17ObwEMZWSp12SEPgEKE7RCKSzmy12lF9L5VIY0hcsgMHFT/XgM7MAnfgVpTgiZjdNWyftQT7D0nvQCaYMrCZczjQdVAwxGIvacsfvP+pmt1ztW/DQVLIoCutmhyBVrNcydhrlrlFmIHtbfliceWLBTPrcHChG+R782ebydwPL90hC4eDLpixB1/JcOgxW8NogMMqosWQ4F0gXOQ6Jc0hCq3poky8NuQCJOhonsXGjL8HDza6PL/RsDvWdMuMlFy9iB11qo28c+MymSBypxvmWp7eO7XhtkkYq6Xa3ZaJOKQbwADlOXGW6RyIJjid0D0DuwR5y/fDKRQHUMyZe90VALgRhcigl84cbIwsHPxw7b2Kb+l8qsmUwxupUlpv/8C7+ujpRqPbtCOZGrupLbYOj2rK5wjBnRhyno7mPtRvLm41K2dVLCVVrZYMMUB0ojBiPpxiQ/ZGzaZFIHBIg8AKDq9NEGSuP2n0aAC5tsBhNiVIwX4s+BqAdFhvKOZdiO0xNW+6i3LgNZX3pqVYcaN+oqB4uajTXcOJ8hiD1A+rHoVQzHG9sObbvJLpiTPNgii75VxpQsF3I/U6YxNjboGgk2+FDQUhenSre/fv6eCAQjqEhZvIBmlotlTtAFeguIrjnC4vApzK+oKAg3sUHaLZ0ivgsqISiYI3bAqifh9D7JFiERK2mXNHXTCvuV+YM9ixJ+Jrx79h5saTOz157Sx0kciUInET6QzDJ4jaG+sWw47hxL7Ak8nCG7bdspjvr0mpIDEjY4JbpUQc2Ynf52odAoaTiZCKZNnZdGy0Y73GzxQHmaQOD46cRHJx2VSr3TOZiWcsmHrs58T712QxUTy60ttfeVs/9Q/9Jj1+dKhaI6EXTz8y1AvE2Wv3bUiPnV61UvI6B45M4KccDUS89WKq5Syj5ZwDi/cWNJCk2nDYtzedEG4NfI9NZxqyJaSoENHH9VsZOp1oOBpapkLXTYEECxk4GhtNdJaVas2oBixUzobFCDg8GBQwPpsvKRAGKmxy/lr7Vcc25pAwQlIkp8QMRjjFfsQSIiB7Rg6w8UP03s7f3847aN83a0P6HJLtTtdFE2snpFCF/YwQoahlNmQS77zeKIKsFV0QWPEFW9ix6GFSYcNEBtgWdxbUGqQIYOvV7hmGoJqFMUkFiZ7FmLai9gLl8Lm6vtZmt3R2IxAmBw+m5gQ5o8sCgsD8t9271eX1CxMgbPzhXL6VYQokDyEvDuuiqUbTiR/ss3v3dXh4X8+evtDNzZUPZSAQFgWDY7BvWDAcnNVeyXFE9x8eKpsHOozYWq7aqIc5agyCTlLf/c6HroxhZCIXAFbqDztKJNeKpxDbpwwb4DjkgGHmrTbfDR6pDBF5gNiguU7TCaQBiBwhZxIaNlRqsxrTzHqDyXb0leTtp5+dq3P7VLMxsMpck3SARx48PFa1cWQykg9I+9gyNwACCv61ATLdenGgIYJFyiFtuzLia2LBMzWVRoKzn1fa8YiHOCTP5zN108ypyHhoxyO+fqX5Cq9LDjlcM+iCIHrgXjKxeP7s9J6Khaoa1UN3mcz6nAHnw3WlSq2gYgnLLeKyNoZgeciZR11ftY0kAN9gIcbfpwAAJuY6ITtj1slBQfNt0wvLUehs49oQn7V/ORUhwucJmyP3ApIDc9RXLazujBroDnjO0NUdHx0Y3vXhv9rq/dZYf/T2Nf/9H//kr6i8ail/eGCmKEhDu3NrIhfWbc3rpt/Ho+iRctmiZuOxbi5vzdLE7IANihUIlMQ8GyjUCfXbQEoBQmdTmSLhiYRNp1Spquzw8ZVt5jjMgzh9n/CwwpcVT1eMIqrq9TsOqUYf+OsL15puP9N/EXtdf7LxD+s//PIvu4umGOTClCtFa1KfPn0qxSh0X65/YMJUIq1FfKfJeqrLi1t999sf2lN0dryQ3r0rSoKsCHbpW2+9qe98+32/B69Fa9tWzj/N5LPW+iryxLIYrh/XvNuDGb7yPQU5wJiBwPb+8NYpFyRegJRwiCGvKpbKLsTNX3A6Cd0w6BDGBRy6PCtDFfNFnd478EHJYT1NBwkWhCLILmbew5q0zCDMJDkIs+mMYWPDefm846+IU8PMnc7EOYxrDlZi6lYmoeGSxfcubJMu8OkYJ8OpSWDtZssHMRUQkDPXPh6J69YGCOFFQkc9H9ebX3pNlRrjqK2vT71W0mI2UT6T0zK/FH4lbI4wVIFSsYlDW8weu41sncCxXhThhpnpzb1hH8BZqFwtG+K0L2x3qE63ZWSMPYqu3RaWmIvYdjQSGLBOGNqoNxzaRg+YOp2Mq3HIHlQy78Ee3fAc5pjHbIOkK5c1z+PZs2eqlEmewrs7q9gWc5lAGOI+8jnZc5n/spd4BEfg84pM4aAhRcvqMG5LETc2cgBBssQOSDie2D8DNHVzIy1cZ+BZyIjMWtED8zzz9RRgX+hByaLlyHt6fq7xpK9Go6paFY1QR1eXN+p3B2YE4nl5eFjzvIDNejpZuMpmNsRDRFZdNB7c5h88PFUcF5VSMcy+sEtju2NTMOEnZkZZEqbsBnsqxMFLa26YbeGXypwrEuOGcxCkXEkbtoJNGIupXGn4QCLCB4G1WZnu7iDOQLhY7jdsGLgYA2zcaThaC8d9umNmq7uobq+vPdPAiJ0KDsZuvki2W2JPUImoVC0rSnrFfBlo5wzG98yqzSYsJid5Q5wghTxJ8kcwUXZnBLkiEg63uxcFBiwyC6y3iGqDlqpWK6tQynvT5/2yiVCXkA2328Y0Z+5hij5VOX6QEy22E+vxYPvewQ6e+/IeGZHZw5IDNuWOMo0x/TKufiv4qxKfs1yF3EgclaKFlN36+d5sGkClkW1c6yUHDnqrsIHhwARcSqbhFl+0yMoaKubUHBDMWejucwU6op2ms4yLKODVcpVcQ+zRCkYBCA6PxSqhQkwlNF2M3I1hbQaBhMX3an4O5s4LklaAOu1PuTIpADj6ZdSJXIS8eHZp9x3IOBBGRq9N9ODRPZXLdc+s3r95+vnfN5MY42tyPA0/Ye4AGW2tdis4KQGLgYKQ3YemGAvCs8axuxMz8FjUSHKWGDQghkdeFSQC88E4RBgR+RZNqFI9UKV+5E2KGTPcAFyyONw4nCkI7t8/diB5tbLQa08e6fHD+/rk409ULVdMcPnVUVHayz6OT/A0DekNGA3Q1UFI6vSaevLafUUnL6ttDo7EElu6mc6fX+njDz9xQC4Em1n+pVie5/gupABt4s11Ta3bcFDG9uYIw2FXo1nbkODhIe8BjS9Eorl287m7yWQmpmgWQ4Gt+QRIL0YD9LQZVfIl/4yjQ4ptZk/YDyYN97N/ANOzk3CfWcMQbaazMQInz4jni5nF8p5CYIEaj3g+zXVbbSkYgqk7HQn3lu/94P6Znx0s9xSd6ur61p0oa4kihc91dnJkxqg5G9bEQkbjOQsaUNxqrPWD7BKJev1ZcjWj+3xpWQkrOJGgW8LDuaNVqWimrHkIYAaMVVJJTQlHIPuyP7BvNqzc+L0jF1VNCEc8V5hojCbB73W51Hg0VipdCCM0CFxxDCTmur5pqt3ruwCn8WT/ocjmZ+YxislgS4d+eW49I1pKDkV4D0Cu9sYljxPryQUpQ4xmKMIDhJ3OANXSsEyVs5lIwsoIfIZ51uke530mzSBaWGuiRQWWHRtOhcCJcTqKCopKVi1FAbNi5tLBjjPhYoafOyKlKrpUrlBTic9rkwV0x3HdXF861BwTHYrnL/SghErLAwVhAwZkLJa1FvL8/FZPPz33QmURRSJJnZw8sAsFpBhMi0leoMrEii5fzEuEGY/nnlcUk4XgMEJlDEWYOeRurUq1qDffeqxkNKH1LOLugmE+Q16qA+BTFiVsw1oFKCep8/Mbffy9Z7q97boq4kE4PrqvgwPE7FO12k1XWRAGIGyA1QF5JNPAVym1O0NNFwPdu4f1Xc7tPdZqDOXxJCwVSyYKISvIFQhHTZrYhP0Xh5VzM93NrH3gIQ1BC6YIbDrcO4LzD5ZRnC6ENyO7gDTCAcoB71geW0W93OjdAcGIZA62iZm9e3b/WI0jnHc4jHdBKoC7v0OK57q9RXyM3y6QNyzMiTtOTitMHqgOqezsPUm0kruWkEPJAi4XK+qthmq3MHMY2M8Us2LmqxxoeCYOelmdnB7biJi0Bw7zwWzsBxjI9vLiMrBFJ3M9ePjQNHw7nmSBdoDJgsE3L2aUnBF06By25XLJnSvpBsCAyHXYsPJFnEZWKpaYeWW8+JbYF9qsAWZfwhCk5zf7FzAwsxQOEljRnj9FISAwMng5YGMe9fT2XM1mx931fLzRoPe+nj+90v0HoBVHSqdeSiE8LxuNVBj3dbClUt7Z6hALPTo46PegHhw3MIdn06Vy2ZLTGjKQytZzH0DudtnksS7cR9mFGLjgewpBxAqO7dTFFeuGe8d9YtZGQYpJPWYArA3mSLiq0DE/fu1M9+4fmo04pkh9RXa0IcoZI5BE3p3wt775HY0mYzUOKp87bd29gr8ws09MPegm+u6+gkHBK/Zr+AsnIViRTh9CoZFLcPgBl6cy+XCvObM2c8B2r12TLFLcP0IUpnuEJeZZMlIHzD0uX/TdxdQrdT/rEPao7jiQnVCygJQXSFAYiLCdwkeIijR7bB832jImwsElCYNzq2SWBoBNfKWTs0Odnp65K0f/2+sP9eLFufcuSCz4cMA8ZkTCQQl8h5Ul951uD77B2cmhGo1DFzPw2CHrkAzENWPZ07Wy3tnHAmKw8ud99aDk+eTeDXtThx0klFLzpqdWs6dHJ/fCDHs+1/XVpU3yQSSc24uEo5D1LH25ngWpBYfQaKpypWz0xzIlRTUcD0LmLgYue5c19gjkOk5L8ZgjaZJclhjAJAb2+OLO/Pzh7OXng8MTjfhq7WJoMptY/kYnmc5CAgJVs9LRiCFdKp+ZLMhqpernm7k30ibgWeIJQS1BEwq5gg80Pm82FVceWYm7fKxIyaPE9xryD4k7zOlzQfoxn2s6HGq5wHh+oXThRAebuhIJfI5nur5pBT4D8W+vyMi+kIMynSU4tKjaYSnoHONp4/DORSSjDour+cKeiE+fvrAnIlokKhDgDePju3AhmKthBJzO0ZUVrJ+iI2Hxc7O5WeinYOFF19J2EdWwP9VkzPCYCpPInKaF9maXxmPq98Y6f36j4WDmTojugAfexsjLmTdk3IWiya3yCSrE+3rwAG1ozofAt771vq6vL7TYTPS1XzfXl999J3SedE6llBqNsh49emISBZUrkggWK9UfcKCN4SEFQVMfTk2jx2uQTcR5krBD4zj0Z0yCQWMEscMzSlefYbDOwsKYZLFAHB9ebAT3ylHPvm5vSKqo6NHjUxVKPMDEg1EdI9hGyL/VZ8+uXDCgQ9xu8Yosm4EbQqiRcuB1S3BxNrjYoEmim9wEIXy/t9C4P9F2HdF4OCLsJRwopEewETG/2EgzJxCwIciMNGakkDA4dB2iam9UYr8iOjiqqxLNqlzJKZ1hlkkCSXAGsqzIXTzsN9DxdXA/QgtWxFItVK78OYVGiB6iZwjSIkt9MlkvWs/L52t1+j1JgeVJcZHyrAutmo+t8DnoPmIv9WtYNGKOsF5GlE4yc8qZqHB90XP+4qfFG/079X/Af/fs9j3Vup8pEretveaLsaZTihZgUFiPEAcC0eH25lqjITrBjA4OTpWKZ00egRnb7lwZgWFWtt2bTtjLd4v5ARl+JLngD7vUxVPQnLn1cVTk8ykuMiEzFUQE8ttq3fR7Qhxvf11Y2oWiN+nUJqLfddrTtxYFfTTN6l94dk//yhsvNBz19Eu/+HXdXLd078F9m2Q4LPsV04a7OTAbFBZrpyfHIUKLP2P2un95CmYK/tysde6xA3TTmbBW9xFoIAfMmtjY1jawYEZJsUbXTz5qKHDwcMaurF4v6Oxsq+92v6er62awKyT/tt31KIWfYZOM3XK/SQfIjQMJ63kyIRkfQTrk7xBKPIdhv1hqssCQXjo5AWZP6/zZlYsKDBzYdOlYye/k/WZzeNemLXVBM+j0lnTCRbTN/mNJ1RsHRrGcmjQOYeGwdGE0E+4Qhb1OnuNiEew9KZpfyaMkf5RuazxYqtecaDdt6v3vvG8dZKVc814B8Q1t5nob9yFIYcXBRQOAPOq1yGPPga1BXpGHu3LX+ejxAz0/v/J+m/Q4LWFHLxqdq+atooQpOOCCuWvC89gUcrpE4AsMxyNN53Ot9ogXhySQKywPYqxifR6AnbtSDrycna129mV2ZJ9TdKRUJuu934HsEILsDV1glmeTga2Qd5QCAxaYnaxS/KcZSSQSRjDdTS7XdvzB3jKdJ1Js4XnqZDw0p2azHap2BOcj+Fs3b4njm1pvDjvZAMgXeVACh/IZIdtQnbqCW0YctTQalw0z0WZzKH366cchJaNEvlnJDLlut6+V52W7vVdfPvgFzueaUK2lMR4KCRZ0J+vFzjoqrOTW840KmUDwgYzTbLV84dHyYcIM3vzixY0WCxzyq4on6C5SZmfiNTrGsi2ytJwFeQJaokcPHvnvfPI9svW+pfOnlx78lw8KGo2hzUPFR5sWTHQrlaoKJbRwdKBhU4YQYkbuvkOCoAIEOByMzX5ksdDB8ADz8MLMC+xQXCWyhjnsNGNTBOjkKesiJ6PR91lasQnG1i1ffzaM03sN1WposbZK52JabxLWGOFvymH74vzGM6RylQclsEHvPzxQqYy8JCSEcGBzKLKImb/hwL+crWxugH6LDiiTCOktuxhwlpQvppVOl036QEc1WzEbQdYAISjtvM1EfGMjepLg+wMo/djcEWSLEfxG1QY2citX8GyiDoZ1zFJaqwiOHEvbWMV2YVNN51M6LDW8afF9WOBT2HbASFMcu9lYgZAwP9gGOA0ywCh0qrwuL5o6qIYkAj53HocmE3nmwUFk/2LWgwXibo2fZ0xzOhBLS5i1x8yI/iaa4Yj0IB/V64e48mBFiOSI2XnRpuwUImzkkXhfyymwEPKBjUXbaGSbN8/NQKajXK7HLgZKJKyAhOMp4RDtAIeyoXJIMboAhvOcXUnDZIa3ojHLlJj5nxzVlasXNZy1fICGBBmSfCiGmH3OdZKcqBSn3Y7oG6O8iRN0R/jgFgslnZ6cqWyPYgzaX65/ZCOb4VC77cIpOsV3IdbltWb2fvyG/srdPiE2/a2vGXMlDPMZe8BU5ABllg8fgI4BCQsHo5mfSmgbR1NKPibjikTQ3EYT4jYbIYuQlxo1gQhJAgcYBRSFernKzBACD+sLklPVECXSDLh0zL5Zh+wFFxcU1AN3v7DHSfPhM4EgEVpMJzsYLq0T5xryfofjoQ+KOuEFwIxTELGZLRUZwZB0xDNvuQ3PyC7vQoOGwa5YgjOwdYAxMCCdILA9f8LcDU7D3SsdzxhqvXnR1bBFEMJCm8VUX3r9beVSeXdZhvwhA27xbSaEYuH1h/UYhhv1RkPz2VrD0VyFas5dIo5QxJQxi758gdUiRKuIgw1AEhgx4UaEgTxkmEwSeVbW4dDM/trDjgZ9OlFkZGGEweFHFwlzGAME1hRjNBiqzPSny4U63YGRRUd67f1Y6Zq5x3zdHF9ljGsU9d6PpIzuzzP5fEHVKqYOBZNv6NLgglBUmZCzBOHKuBicMyMejdyk2AN7t9QSgxYCJmIJ3dx29d4HH+vy8kranemgVlWm/AV7vTJLgs4fT2AssDR0UijFdRIhniXiDYbOiQoE5icPOXRw2mPrw3Zb20EBrUViBc/1+MUiDqnOIYsOI13mEtD/6DSAYkP2HFIM7NG6NtrlxmeLaR2dHvpQu2l1PJ9gQebzuLSUfVDGomtrzhpHJ3r7nTfVOCgHw4FESl//lW/r537+b6tz21MiFthUVEUHjSNDOgGG5MAv+aGHxZpM4XIB8zLYzsEQs2djFLYpc0BsooLNHxRl4DYs9NK4iyAGZ3FYX8nAnFkdcGMh2L3hzrOdKZ+XKruK9PxulyqofbtRf7lSvlpRpFJTc7l1COtkRXAzMo6UYtusbsd9PestNM9UtCscaJ7O62a+U2K2VaxOJhvV3UixKVo9shbjimdqai0jKlZOVSudaNfuWKvZHk8NfRNwMmVCHU8qVa5qnctrFdkoyX/j67tdabaNah2PKlo5UCybs73WcLBWrHpiWPiWANX2SEtYz0lYaCllo2lNiQlbTNVfs+kVNVyNfM2osCEW4AJyvA7JMFlSQ+LSMLLUDPcWHpN1RFGkEDPgamQkSc+RXnSn0h4l/fhqpMQI5ivJCDNv3vdOj5RJJ9Qazb7Pwo7oqOguZZs9bg5EJzbRRCKvePolFFmrVfQkeaZer6Xjk7oOj4rK5xLWPXKND46wTovr5qIdICo0rtuodaLPnl/o6vpSpVJOZ/cbJh9ZoL6v5Hm2OGSAHe3gs9sZSmWT5xCASRri7qKaLNHOBRPszXKn43vHSidylkawHieYxg+CWxLidcyn7WSyn85uVhArinr9zbeViCbMhiTCLtjmvewoB1ue87RmibxGs7myhYIqj1JKFXK6STU+T2ppTpZqJSNKM/wjpCCaVWfN9gixZafUNqHENq44Gsou9zlA5i52Ekk1Cf4msxLAdE2SDwgC86itD7gJIv7DMyW2kHKmGswXiq2wxywqmsv6sNwSH5bKCcAaCVg2GpIlNsuILntLPWuhM1y4w60TwN6a6FAZnZ5klK6WtYkM1bkeqbeNqweDEiZ6MqtdOqueEspUy0ofjZSIZBRLp7VO8nxL37ls6X4sonqFYICs1pGkySnxdEHZRE5ZknpgjGJUQPxfYqSlgyAWWrtKCq9CJq/EYmoJyNWwr8h2qR/8yjs6OTyx7IOAgGK5oqOzqJsHigD2nW4Po/W8CSxcv5tmy85iCUK7t3krDRabmY4Oa+oeN7Sc4fSU8MgIkg2kuc22pzi62lLFM+TpeKJkPiplIu4cGTdQUPArTtwYAL5tL4Fti5boUDxDElus1vqlX/2Obls9d5XcY1AvGLiWGUWZ506tGcYE/sXFtW6aTSNFiXiQABWyGS2yKU0xXdh7DvPcYojAGslkiGas+brx3PSHQ+FXBUE0HllZB53nTJotddvu6rOnl3ZOw45ydDBVmVHgF3lQHhAhlUvZXggbOqCNbARSBUzKourVgudDHBDoI/F2HF9eeTMGgsHJRvGVGodl1Rp5w6/mjyThpSa0wSEeAfN4rt1y58XODg3N2d0WadZUPHS22aiq9ZoOIA6d1e1DudjODZkQuBsTsAvVUMhUDBl3SZNPUtmUjZSHhk66e3u8hP07CVsmGufgsOLNZDbZGs7td3qmvSOYrzUoGLIhrzITUSafMtQ1nU+tkQJupVoKiSS44kApjxgKvbq5Mhv4+OzYKfXo12Bd4inKww4DFkae6fHLl5vUz/Rfk2r82v8GZIxXfDi//3Vfevsr3/9b7Pkf73/5RSHw3/T6b/jzG/13f/Ge9y44/1+9Ln/tbxCM/N/yeuX5//ON3xb+41XJVOvv8iW5vA7rDfV6E1evkLOYVTGTYg4V37w8KMuVvF4/uafb26gqlYKOjque3RruxEP2tqXxKJCb6NjxsFxMScro6+aq5a6AeSYByDybzP/t/2rrQNpKWH9zlStVJbbA6yA6CRWLdQfqwkCn6gcx6fbaamJeny1o0J0olQsSGMYKk2nbBIpMrmoXKJ71kJ5xx2OCnfxYB/X7Zireu3+seALJRvdz/15eP/W37n//xbojC3a+/7f/4Af3fs1VPZT0hnShv8fX3UP+a14sh1/zFv6ur+X+F2ft3/X1pnSi8OvXft2zV/6/8mXp5fTj73z92G/5r/+zl7UXCicJ0vZLf/n/1letUlRsEtWQsQz8RezzQGkS7GmwvGNqda+0xdgjE9dyuvZzhW7brmf5jNGRq6tbZwBP5zObBIDOTKdhVIK8bAU0uYDF2nah/pV339Fnzy7sGRuLJgPPAr5EthCShZBn5DKakxRkrbKnMMEreMmoi+AGiuBQYPIzs8w5sxkxuWE/pFGAjwLqQ4ADfAbruedL3dy21BmOVKrUtADJYabL/HXDz9u5w+XnIB1hTFE5aLjzZKQBuY1OGC0mEhH0w7vNzA5GdmeaEQaB3SfM2cx+XS5s//jFHpRHB1qtR15MLGJMB4DbopG0jXKpGNyhLKFWxw1tAOdAi6+d1d3uN44LypfTZqoitCbod4WMAWE7Q7LdTj3yJa87iu0SOqge2JiAYGRDE/GVjh80VDoo6vD4yGHI+RK+ijF9+Yde1/FpQ9/8+nf1/NmVduusEhhW260GoszcBIPkPK41OPZg7HQRfiwPHhDMo9fu68tfed0uJcvZQp9+8lzf/uYHWoyhh5MlmNZrb0ZVrtZ8yCkOdDYymcJWYBGsrDLKshntEhr1J4bLrm9u7ewP/MoPBI48PCqZUMIMiY0YLRb6OqAmYOv49u8tefu/f31xL8Tyx8fHikQ6nocjFA8zcMgnYfHfvWDsVoC0olUjBpkMNmHMStMa9af6xvc+1GIeVaN87EKJbgl7wul4YSYvHp8UX2jOonjTOic0BGgjGwFxsGIgsrHomiL14aP7SiZLev782lU4MhMqc5AbmMs8P83btg5PYflJK+wb91CuHYngkHl4FD4DY5BeZ2qvVGbmkE6o+CGHQPAAnv7vX///f2GOouVMy0RUkXzO3qbAorPJxMUPyoH+AKH9TNFEWvEobE7GPhChlp6LcigxosDZDFLYBqY9AvtMUokdJMSkxzww8DjgMHQ5PTmxIcvF1Y2NTWA6otVdm/2PsUwgHCG72W7RCUeMBlDA8UjB1WD/gzcQOBcLa4zRmjKGwSHJY6hE3GSgbZf5b2DXQuTByxiSFeMAV0aYxpv8GPyWgZnhvXCoYqAAWYjn3/7UkMjwFyfcYm/YAfs3k63YIo9vAhrLGWWzUM/Bg6fwF6ujTMQ1xsEfSr4XaAhtBlVi/mShN3wPN85BwlCt1rzxHB8d2SewVE17poY8BHmB2Z9AZ3yv7R62nMzV7400GcBcWmobOVK1ETB2Ejfe/erbhjg5dBDwx1IcPFNFdxudPqwpnfuqGkdVdZoDLWaksk+Dm7+d44PgHCwd4hBWaND1U8msjo9O9OaXnqhQoROc28T5g/c+UY+buYobNo4nJ56tPn79niq1hHWE0+XQh2gqSQfMwJgWNupZ34cffKyby6bJRuVKxR0EMglisAJsS6rBSoPhOARfx9k4YQjG9DC/0x957dYMVt49bDFmORbJEmcVj9miL7AfmYlBdiHebGtnIQbap6dHwa0fCC/KQQ7awXfBAxN4I9x+HhwWAjA3XS0PT6Vc9XubTyADbJwLeHV1Y9E7FSQ//+TsQEfHDV9vUhqms6Ep4tYtWbCd0GiEbGT5ORWdOQ0lEgcEn5muDUcR5kyRXdwFx0cffaJPP3mq8XAchvzplL76Q1/xHGq+mDjZhbXELBVKuIkIVzeuDhv1Q0M8Hw93+luZN/35vtb+turAtdOZer2e7cgMp0eQq+zdk3Y7NVZdjZYzzzzi8UwIEU5EHcKLLSOZ03evQHlPqBLDeo1g6RBjxue4uW0G20URZdSzmYBd5WzWUPcsCe9NOgCTKtLM7vF9xbUJiJa80oiT5TmwODyPjuv28cQUHIMBclt5XqBU8HxFcV1ZzjxLa2wLSsYSlkRA2iJw3MzULZtUYBnyYuP7+Z/7fyudIA+QsGuYmBGVq2nPs3/TAfPM534e0RGDliCS5+uREfEcILO6Xqf1pz4t+Hv+k/faeh1fBUhipKPEkiZJYedHWgQbGeuVcGJmR5YoRUi6nwc2JGsglzPkigQBGL7VIjQZ4wti1rJ+PmFDU9igLwTqg1HN94TR3sdxiPVdrXqvYrPlvWAt2Gr3/X3v3K94Jnm+CCAGPrQtIHradbA9BJmiI2cWxvPsaaeZ+Xsjiz1THeIfgc337jUcCAxT05FpXJQdsWbAlsyKg9co6SEQbW6bEB5nvo+83zpzs91ag/lECez10PIeHhhxarXaHvMAT2J6xbwW1owJ8gRTY7CAZGm+8jME3wYSIfsrQfegZ4Yu+VoOSHyoWfvM+2JkkFZtQryYYhZAi42371SzQjBboYDjOiC/YP7LVgexxsxuM/PRrcb9HOKtC/vVVLcVWlP+P6lqpeaDC9cryEycIbEk8sC4D0kCK9C8c1jOFzBkp1rvMFTIq9cf6On5CzcqhWzBzkYQf5ChBbKOY86NviyWZNhGLJmB7MRMmQMZKJfrjuQEpi4a3C/0oASmZMaBhg33iyRUXzDm4cgHEjMI9HswJZOxrA5qBxaX12tFlcs8rCv7L/JhWDzOG8NGLB717I7KF2YlHxi6OIfbDBLQYKoszibYeCUhY+RCpMyK9hsnlxAphdE1OYb1RkGZ9JuOc3r+7NqbNKwyGJiQgIB88/mk0rmI3vmBxzo5rbnCx/auflA1rZoFe3MTsiqx6Jv0ETpvDBuj4wNuZmjcG3UtkyjXYSGmzcwFPsYHs9lu24mCkF3E+kAdkInwszWETZ5jLOkbyoOBYw+HCT6dXpTTkX4yPQYZc8dshux8oSXsOcJd8zmNY4T4xkw0isbxjFxZh9RUV61IS48PMoFwscWlJwz5bXScjJngAzJAtwPhIZcpWth7G8X5ZK5Zv6VSqSoVpBcXl7oe3Cp3/ZlRAog3EJ9ejz3Wu4dv6H5qpdcbCUUTRONg/4U3Js5D0maJNdWezOMNBS0afre43YQqFOIT1V0sktZkuNSvPm/pb9z+qunwFFCQh3734dtS7FazyEiv10IKQPqMHL2hU16G8Zmeb5tKaqTYlpT3xOcH5ePRU50uexZek2pBYRNtI8nBzSa4cyB9YONrE91VLGowHgQ2LvrVwUbpXNKpOXfwH6hkNo2rEOSeuaFTZnrMXGDpEjq8W2f07BOg+74W5ZXNEdCGHpxU7Ko0HLcUSwevXMhbmBAAd2GXBoOP1AyIEmzG3lzg98VgV881Www9p3E+5mpm+P/+Ewo4CEUxB/risgMMZjLQkg1rp82C8UiootksP/v4qao4q9QZiWAqgZdnxASRx9m1nmTpIIDPIvbghYZD1wzzm+vHSfCdSV5/igdF0t9XW+qHyhNvSkafdlENE7hOzUw6Ih2o22v6+adb4WW4uUAhG6KyKCaAxVrqKXuQ1/iADTum+XSk+bxn27zrccvrtKGG7udOdFY4UirJu9uq193o9uZK0dG1pWF0Umtm7MW4eruJPu0/12yMP3BBiW1K5XRRk81Ig8VQmwkIz1Sr+dKGKaVC2VAf653rQBHGQQlhy/mhWwwSljbgbuSKehhbq8gsbjX3oU8ng4n8bDvXTbttHTQ66Wr9QNvMVp+ur9Ue9XzIlaNd1aMV+xhzkFDQwpKlKPOhNV9qPJtrNF1Ya0hLwoYasVFGkAjRWUL44r1aRr1eWCYCX4LCbbNcadQb+lmObiLWLxN7OF717drFHgFjG5TDUQ2Ql4SjV16VUlWL+U3QMuayNiQx+Yc0pgyOO/hl462d9iwaUlanO1UihVQJuQoBGjiPJbRbR7W2ERjm6dglonNGX4okaJ9FuVlrPFspVymqP1/q/Lqp/nimfInw5aELB1JFBkis6GxjcZN/CEngkKzVczq7dxyc0XaEtCf18MGRLi6vtMFVbJGwK9QXelDS8iZSpKdD0cfUd6dEOq5isaxNNqLFZKX+ZKrZeKFBLzDXyiUOBTZJGSYKJulTDYakjqBDDIMkp1NsEbmnzZLNpJkRzeCDaTTGJ3SgWCKjnEhLmDt6Zjwd+tBTlGBm8HLINSvj1BxmCJELhYkND3r9rtYjOiMWh/MxDHvS4eLaBnO1UE67+sLAu9shSmxoggTzSeZAR8c1vfnmAz16eOSqFRd8bmo2UVJsl/Hn5+FE3oH7BpsTbC0IQJiWI4vAagoNJIxRNhkM0uk8EPcTM0VlS2XGcHyEhdh6464ik8QBZO4IJyye0G5NZyu766PL26yjn3d5OFWwCZcrD83upHxc40iD4TnMW7xBcdLZp9bDlm3UjtVu9qwX5HBq3nR1ddVUo36k05MjV8N4SEL2gGRl0+lkXNPRzKxOulyg6mySe7g/iJldYFRsiyjcWMjP3Oh2ONXFi6uQ8VetmDGIExFyAsKAceW5f++efsOv+zF9+1vfNSHkN/74j3nmMJn2Hajb7bR1eBJm5lgIKpbW4XHNLibXV7f+OZVdxl/L68njM91fF+wYtNvBlowZurIF1xJv4pSyGPRHwqGdyTFnSbhjn7mg2eim3dFtu/P5QcnP+TTW06MnR57brNZYrMG6Df6kFHb9DgXaZM/SRPxMRNbWSfONo7ISXQgdOyMlyShdH6cyh/bO9x4iHPd9BXM1ulMUSy42mnzC/rjTMQcHcNhW77zzht5593XHQlFRc7Ay7iBUmCKXzE5IOzCAh0NaY4wRIq6wHzw4VfWgotP7h6oflJTKoLSdQmfztYFFgEsK0BaozHJDcRGMKkAEcKS9e2FrN9hOXXRyAEZASvbyAjpT0BHWKibbdDpIoxD54zIE+9MOSxjxJwjuBi2JKEsUXAMjj4jXZDaVMNzNxgypZLWZuOgoEf6eTeve/SMzGq8vbm37iKyNuSx6wHKpZCMJIGq7gKWxXMMAP+JuFyIio6BEIeaN1047t3RySRXwU0UvPh4Zos7gsJRO2FCcWLZ8FiboQtPx2o4v9i5NhQ6eZ8MSm3VIKRkPh+7EGtWqZ+O90dizNVAfeBloTjkkOZC7g4E15IQNEw8FjEkeKczScKAE0wnHu5GBSowZbHeE+cRbcZDS3Ucynvm96N7YprFcqCDO9dqiw3ZQ/UFDl5fXRnZssbeJKLHPyT2o17SyYchOkVTCpgfcr2Ku4H0PfWJtU9ThUcVzd7rnYqWi5FXXqA0HvxuEVcL/DdrIfkUTgz4TNMZoB8Yks2BoQC0wWW501erqttt30wC6wZ40Bv2CbMguAMM7snFYNOS7w2PMbyo6Ojr0iBDUgsg5yKhEo5F5zPNA0fOFHpR0MiRgR936BcEr80gcWLSNWpzdvOno4tmN+liYpXFIqbjyJ9suF8+4iuH/2QAGvYG6rZ7p+jUuZiqpdQQpMA4lMEhhui1dUa/JY0tktWsO/SBjos5GUS4fKBHFTSNAZN4ZMZ5OI3IOVQWBtDhFALOWisVgfVUsW8fnaBcCP4fotTaGXtBGffrZJx40M6KBuISX5Ltffl3vfPkNlSrZECFEVxyLazIC5pgYumMGxMLiQCbKB7o9hzqHMwJ63DtMBrRjCDMhNhLCUInjQYG9s+5z0Bv6MKuXa95UuA54g0K3ZnEn4tj95ZTNl4zFAzsiDiZdHbd8KnVkMEAg0KQzWbp02dYJ/9v5Ak9HHkiG6nHDkR988D39yi9/24t8NEA2AQy+0WQ0scDXCQg5PCIXGgyh0GPCHfOh6KSQ+cwZnXT4QLrAP5EdpgApLadLe1MSF0Z1/dknzy0OrjUaFjSjl+0P+vrs02eeDVaKNR0cHOonf/LQCwYBfMbzXRxXkur32zo+xWRi5WuaQmpkgXpNGTq0aFrraUX6Vnh2o7GFopGZMtmNKtWEIbj1dqzVdmxGL6490cXOTL9cBp0cguly0EcSIQSzEQcaw+DhdXPd1HcHH6tcgZRVc9ER5jVBH7iZp/S898IFZn/QUyKOG+6pqfPQ8R/iSpVAHB+stMxdxBfTENpmb2cYNteMHU7iSqSTSqTyevudN9Q4AMkh1ijurubx41OvCVLsmf+wMd1e37i4Ipy3kKuo25nqG7/6dfVjOakILJnUb/ttP+nrG4lvlQZpSRG2jtMQut+4BfoYWzvrcR94C2RsSHgb17A71Gz50oD+00/PdXKytUUazxc7nU04LHlh4w6Wgjw7dBGGBzchCi04sQBZMmMK2Z3Mz4hTIqcSPsNho6LDwwMXPe0OphpIV/IOfeZZ8xx2QyBxIRy2NwlNZnMf5uwbdP3HR3UTTDDQoDAiR5KZXTLD3IpAbUYpwIBbze0lW1KxVHMRjxlFp9NUu33tLpKUmVSSORzdFO5HpWCA7+zFoPHFNg3tIddhscPli2eJIggrtTB2cJGUQCmQ1ixKQYcVYc4jm02v50IpFBrAmME4ARiWOSDXlRk58CboCuQVEG0OHdC3fm+o2+uWkTASNfj94NUKczdhz2EOe0hi3APuD3p1ttMkUptSCLAgTvCwUTUUHeK3MKHB77ugZuvWhdt4gn9wxoeRk6HmXcPqDmPYyY5lpJU4IH3J/Y/YBKDdISmE4p9YMhJYFn6OeeZn46kmg4EbljKJLamskuWEur2eBtO59014MongderGBAZvpVoyMsnvgRoBBVMMBIP+pM051nvDky/soCztM9yQNFCBASkM+xN3g7l0wSQFNkLsrRB4JzNo9NAaYbF26sGrZzMsEjSO64263aHS47mqxZpz2sCyWSBs/my8i8VOqSzu90UfXBcvLvwgYLb84OGZq1CzbEkpcWUAxIQWb+HuipBVYKxOhweu5HkDB+FWWaXS4cKx8JlTuVtbr3V1ea5O81r5bFmPHp4YJmBG8ANffVu1WtEG2alEQnmgSuQsq7WhIB4EIEVeFQ5+Er/jGJYHH1YG3E5WiXJIBU9MvHFx1OB/mMURQQYhA7gRTJ7ZILNRNgg2Dx56+1/GgBx3enb+mV68uNRo3FfjsG64rFzNumulK6VLQ6DvDpLq3aLupXbptCtoyEdASeD83e7I/qqT8UqrOSJfqraphfnAt8wzYMYdHR5Y1wkN/N79E+WzMPEQLqf38ODKm3fmroPYbN2JddsDrZYLXby41O3NrSqVuqJKOV2DX/3BQLMh9y6iy4sbXb64dfVfw3x9PlV2GXGsEvOMbm9mXWWI0aGaJKtu48273qi7gIvMX7rFzBYjTdZdHR+d6q0vPdbFxbWlRkgoWKhs0p69ER62nChXJEEjpL0k5ridFNzx40hy0PlMzfoTNZXVR9cDPXhxqYPDsqtctIqWAFHgDRY6P3+mXrfj6pmDAc3fVktXstDnkZi0uzd+BpO5PAojz++TeL0mCTdea4PGNpXwuIO1F9kRCF6zo1O1fGCZSKfdVDYd9a8NVl1kK65mhuNquJ9kc7aR+/STC31vLE0q0H93+jHb3N3Xbrf0jHITAXakyEXCDf0+6evKYZKl2NrLobCKdIcGcUkLIzKvbilcBzZHWMDsExR7d5aMdJcRuuc10CIbfPZOHfZ5N84zSj4ls3fP1DiwgPSjwJBRF5U4dwHbM6u8urza6y7jjtZKE2HGRjuHnxBMvuloeU7Qr9oblwM7nfTPJO0DtiabJ50h0zeH0a/XSh/i6JKy/SEFK2MersVsvtVg1FYsztwce8Gs12Ahxx7JSGPrrscRbxwK67U6mHGgT04DiXNQ4FA29bhiOB6rVqf4IzAi5vXkKCv2iUzOnsjBMm8ZvExJ1LD9FHwQ5pF364DObWTiCtIq9tk+MpOLpg+ug8OaqtW6JsOZ5uOZ0vmMZ9QhjWNlqQoHXQKCIvF1oIL5rP1nIXBCLIIJ7mSQZEq5Ah6taw36Iw2xVpyEeetm88hObFx3nhNXRAQmjEbq98fek3DtwsAFi0LLRHB6QluJO5B5GSEFCxITDmwczk7fIXOyWPSzvYn0Pc9EjwmMDApC6AZwOF9jrae9XZd7o3e8iKceQdF5JqNfcHoIpsJIIpCAxKNpdxo9ZhbbqMa7ta7Omzp/dqn5LKTLo48MYueJre0qtYq/DmPskPQAMzTm9pyHx+ozXPQ5LCZja3by+bLOTo91hGfk7bVZq8z6Hj584MOaiiyG4e96Z+0MldJyttGKoN3xap/y3vCi4SHCISgazxn6olK3b+FoZK1ZNl9UKZN1hcghzKKkCn3w4EinR4fW3lG1Mi+yefsShw/s4na6vsX3secN9d7907C4HfcD8SL4u1JhUs3GY/g7xj6vIj3bwo3E1RByzKhp/hwYbXtD0nFiQTd3WDObZ+9Fz/BLpzv0Z8J/dYg0ZbXSl3/gDUNu88XI8yk65cUa2JlkCSzFAtsyEuUg42HnsJnZrgtbwdUiojVtFg8evTxRYms+RwhbxnWkUnus/qCl1Xam+WKoaKTuB5iNbbHYajXD4QfYjq6I6pcDfqNcJqmjg7pqJZI2cDKJuqLuNHu2/GKezPyQz85GgfoOkkVrPSE9UqfZQy9UCp7RYKyTI2AYNjsQh7iJE7yP0bClAQ5New1ANp+ShlvFUzs9eu1MpxzwpYI++eyZ/UoxVaB4wwWESDLIGFx3z/hIks9kdNhoaDqa6Gsf/lX9pd/4+3TReEefjT5Q86ZtL03cm3imd2vmS3yfhOdMZI8m4hFbueHPyzNDdiGRdGwgiL4x2sfYHvNzNjfHbu1WJvksiBgjbSeKnhAUAi1yzYfiaokb0FS3t+caj5I6PfmqhuhCed4WICaQ5KQhJhKQaQp5NZ+8pd7y1BvRH75/a2hrtw4HhxN/2Gi3IXsR1q9NDZLEdWG+PvcMEa4BhycM7Wgkq343zJt5sVFzeKMlFs81GtG9BaO7JpAX7PlgbBL/BanL9nYhzSa52oSswAQh66yDrTdRiCTo8gjonmlphKNvCURTV5dNm/dD7jk5OrSF2y6CHrPta1AoVAJEHNoLu7fYccc/HyOEmL8fTHNM8ClUDSZjtL1iEw+hCqwnOrdCKRSjoEXkaJ7cO9DZ6YnNFNxtESyfIRCZgGNQJKwyMRiYWc6AHR+sy06/aS4D0CMSDjbvUTkcPCAuwECMqZjFJpOgQeP9wZkG67CMjPsB+RAfYbqlEhwKgitmdG7M/RMmyzVve17DrC/QNaRui+lij1gtvAfHkxkXVRgwZD3rC+srEU1Yy0oBxKHDwcyIhTk0exlrF7OSNbre7kjb3Qtls3ndv5+yzzGKAq4l64wuG4kKhfdqPVAiFa4TjQKHdGYdWOAc6skdZhSM5paBYRuLey+EKMrzxLPj7Fzfp5Wy6ayOGhSRHLYYMoQgBe4T3SMdKkxuEBYaNu7/Fx7cjLgZog5zB3Dt+WijYWem1k3HN4Hu0C5u3JjNApMwpRnaOupm42ocFh4Yvt0VyDhczk1woGoIYutgZAwJgKrs6KiuJ08eKJXlQc7q0cNTHZ+c+ibgNcmFDUbF02D9heExrT29AVDlYq2bZsfQIt0GpsCpzH0NBlNV44FaTAfi6i0OhBK60FwGOzCKAFm3lM2BxS/9YJQSVS9iXDn4zN1+X5dXl9ZqNuoHThUAvnG4NZ6TeHgaYkJDtFF0hrUXTjpBo5RkM8FqC/Nxp6NjyRSzVyGdETsZtGk6ZggbLaQmrZG6vbHmzn1cawYTbbG0241tNz3oR+6ADyd1O/cF2C7tme3lZVuJRNo5l+MB89iRkxl8QEaYk+DqwibPpoYtW2DN5XMZW/kdHDeUSC71ydNrbTbMlnhQSb6nm2BektB2vVSrR16glM/mlCF5Yr5StVCTdtyztbtGmKq4dtxZbUHIYrOtlsoucnAOGY47nifO52VvVqlESJmZDAl/pivHvSXobRPFtHabhCajl0JTkhUyi7Rubm6Vz32m07P7+tI7b+rJG0+ceuMk+clMtzdNMwKp9ingQrUe4FD+qQBXJl5JG8DCbb6y9nWZCuG4IBrMS3Bk4roRI0dRV6/RdcYUT5IPScJKT9k8gvSY3UjS6VFgKDNnwtTflmELQ/SxDdaBFB90EIw75t4gmk0yPlMqFdPqddu6unjuedN6Md+jFdgIAuOx3UQ8DsF31ZpBXjEIdqRDBOce1g1jFBAFfFM5PBRZ232LDiVITELx1euObaG3mGzVaY+kXPiWoBCTZCh4OAwzGcCiYHDNZrbb3RnxB3nK6g6yTlCwYUpCgRMC0C1rWQZbR0t1ouil+Xl9PT+/sOMLY6zVKqrlLKLOpK/29cCxbklmm1nkPkcadDHnD5aTpGVwXhPRZks+RgSRmBEs3lQunbPjF440FDs8F1LfxUFgSJICNDFz/uT0SJUqz2nF80VmYIv9bJH74A2AuSQkOoy6p2PHraVyGReJwLF0k0COuATBVOcXhv3MTiFD2mVmRzPBQYSzUcoQIzNK4Hj7vPKccG23rF1ScSARRe0bzAGDCxDxYeyXHBSMO0I2ayZ0nYaIQ8eN5pe2izQQCDpAoFMyOXFdm62MFLhDT69tRckM2kUPIQOskihua0uNJnj9hvQiun8OVP6c78UQgqKdNQwrfjof+5lfb0IqEQ1ZhNSlGPNpTCT4HKaUO1yAQvIuVNxFKeO0bNYm5406MDGoSFzHxwf278UesdPvmhEOd4VCm+s1Gg28p36hB2XIcJupeXNrKQQMwuvzrt577yP7q4Ktc5FgTfFwrBcr7eIpHeZqyhdzrmg7nY5PeS4ZADjzHB7I4F0YTHqBl4jfAmcm44/5CfArBJVwMcN8qNXsutJjAQNpcIMhGPGgcIOhL/f7PXVJcLAmDGbhlclFh+RNssk5Hge8mk6AANSUSjhnQCUmkw3cOwG5ZqJ0igQLIqDmGvSnGo3n+uyz52p3GRBH9OSNRzZTp9KB2WdD5w0tPwstFABUxhh8MyuF5o7vIZ0Q15bOHNMFEhJm0YU7RW4mEAP7F9+XWcGQxAgbtkQ1Gs0tpN3YcRPcDs5f2IDQ6RFRBGTFpp+IA3GldHN9q/ff+0T12qHWi7SrcWYYw8HUJIDJaG5quYOs13Pl8jUVilkdHjR0/+zEDz3woCJlZfJvKlugA8saTqTa4/2zkVDRTidjL6piDus8WhYgEaJtpp6D4lLT6wGFUUSEuQ3PBGbJp6enXtA89LgjLZZDLRBIr2LaRelUCRMnrDW4j1xe37hjw6+zUiFt4aU1VSyStBMHTLnvfe9TPXt2qTfeelOvvf5EB426N2Le73vRiIlG2HBRDHlORuTYfGtvSQqH+/fvh11+H4oM2cTuOXuDKaMp+zBenrXj40M16mFUANRP2kupmnfBCGuyRzbhaq5iqWLWK3MyukTmR0geYHnj9oOMxKb3ONKwDtYYGyy4pDo5PlAyttMnH32kt7/0JW8mSK8Wm6XlPBRSOPo4IPiVtBTrmNcwFjmw4xqPF/rk40uNh2slcJIhq/KA0PJgJs2hjbfwfLbRbLJW62ag68uuLm62UoijNCEPNxwODfJpec+2LHNW49qB7us1ZuGQjvCHxjs2CMQ5iP3sZjhItibCUSwCM2I1OLfjV8pku5vLgfcdYtw8yy9HDMePSCYZzBUZ78yEnowp3AKblu4GFOVzo3wizEwEZP4K+SviIAeKDGB/9NEjIMXx2LAnnR+yL+4NSSxvv/Mlj4XYd26uLjWbji17wmybfEwO06xh1IxqjarnbXSyvX5Pmy12ekitwjWDqxGEjcwJObTgApDSgQC/Yg9UCGGLNYdWCIvm+WH/4I7y7PDkwZrm+cjgQY2JCgTFHRrtqTkKg8FE3U7f4xLLXRg52Oxip8+efaaL21vP7ClgeMwpFpIJSEc1RaP4rHJv1jZaZ1aYSgQUh8/N4Ujhyp/DtcAlh/ULRyKXqXudNy3rCdrf4Nu9MILIemDvB8FgsIjfM/BsrVK2vSZEO2RW/Cze2MiRYMh8ovtIuoTyWTpsjFvGaqSKDs7gWer2us4vNhu9XDTCQsoUTdq9k9Mv9qC0JGO+1vc+eqZ0ksSLrG6aQ83mDP1Jn0AbB5uNGQQef1MldjtVajnVG0WNJ0PP68YMkGNkyuX2rXvcN3yxx5JX24XuPzpTqVRRvX5kditSDZwgcO6nze91R5pPyUrkhi3Uvh0alqJrgjgzHi49g5tPYdBRcTEjCR+XBU93UirDdISEwAMRNR6/JFkcGBc9EL6r2427YB5kSCocIHRL3c6tPn36wocmDvfVg7Lu3bunUqXsB6M/7Ck6QdYR0WQamJXcZDZ84CE2Zqps5DbAS2sK1e1KnWbHZgvEbjGfNFy1BjpMO6+TTQ49XcHzS8J1p1oud06873SQvkAsSWsXCVFZfC1QLxt3NJJTpznXd77xmTvS5TSpzTLjzqHTBuqemQnHw7nmn/XchAgYbCcnhzpsHLhCA+ZhhrXeJXR4/MBxSBzSLJx+b6JvfusDffTBU60XW7WaTR0cVvWDP/COjg4OTT+PQmffLnRzcaXWdc8m1GhpYciyGHjomQnThTInpKOl0yH39Pa2r1Kh6BkLafff+Ma39eLqyhFrwFG3/Z4unl/psFHW6PSdz5/dQr6s41RC985gDJMecKPvfvc9L9K333rTGl+kMcwQna6AifNubC/S+ZRUnKldQ7im3Offu3xP/+fUu/orR3+/fiT2tzw3hvHMs8R9M7txu9HDh/ct8Tg8bBh+na/GKsdzJnwMBsitoKgTG8cGFO65xdX2TCZijJl+ypurPXM978HEv+fCCjgXCQOaS8hjxC0xs240GkplYXJSIMQVXwCtbfXXeyX9xz2ccqS/8AOfKpuCQZt2gca8nU4/Hsmq1771RgI0RbHabrVVLCfM/O7c9n1IfvLxC91c93Vz3dUtdov7g5LPU2qUbLnXOCyYRIauETiStcmfQ0xhE4YByjpIM9dDJwx8T7pLDN3y1J+RtA27ZzF+2DLna6t5M9b1Vddjgu1ypnRia3/aeDmi6Batd3j+Kdj6rbF29phN2uoPE/X6Yc3SkHgcbWQocjht2FPo8GeTha7OP/IBjcvWeEqc2UqT+cIF8nJFh8doIumZ/gjz9MXU7x1xPYxp3HTw6YVYQyOaL+Q9f4VtTYOPjRqkOICLCiRDnp712iMWhyigJ0XatQvewayB4SoUPfElXTBjiwVcMKNQ9mVNZdwt8SzR6YHqkK87b83dLTKesoSPkQez7W5XxSzko7iur65tNNDCQ3izCSYFhqCjKuZLSsXSKuZRGCRdfCGLCrF6wWkH1AXG8cxZklMT2ChctAWmn6pWOdg32Ds7qqFTB0pkNMVIi+4Yn+oYPsHJqGbIv2D9ghJZ+41yIsyUQQbpWlkrd3p+DkxnzUNuivL/zGxnWi6THk1xD+r1uvfwwbBnRKZarYY4wS/yoLQ8gcp7Abv12jDIcslAvGhCzUKLgMebxr5VIZvSkzce6OzeoebLsTZb7LgQbpdsxcQNBVqwSXc6YfZVu9PUcETW5aEPBDacVrOvp58+s6tJqVz271HpZzJEsHRsBUaUFd0srDfmMFyQYZ8bxSG1VTqWciXCRmNrpf2hjCUZLFEHkuLssOVgC5FYrBzmR3SbsOqAZ0l7+OijT9VuDTyIBxY4ODxQ4wi/W8T+M28MgWCy1MpMWHSARW9aHMhAHXwtMA6bKEkBq8VO3VZHreuWItuYvQmppl2cEGpaziuTo/PGZzZmdiOGsXQD6DaP+zV1eg1fW+ZqvH1Xkkg50FZuwhzio4/O9enHl66KqcjHw427YAbxkEc2WQhDHOgJpRIFByk/fu2eO2SciGCOEXPU7U8ddg3kjQk9FedwNNXl1a2+/a0P9ezjS03HOG3uVK8caDraqqWhphmCpVPqtQaGPNH20QOzOdFpsAEdNmo6OKz7wWeOh7Sn1bq1TRtkh9hpWtVKUp32jb77rQ8tOo7Gr/01b771RKXymfNSLbDfuwDyTBRT5D5iqrCw2Xtn3tev/PI39PzpCz1+/FjFfN73hMUDGxstLKvTs2b0prbz2ur66sqB3fnoRONETv3Mkec6Fpe70Yxax8gGT34ms3dYqVTXHBQUZ6HTTqjZ5Plc+2diJO/UBQJyN4QOhzmMCV0TSFlRpXIgLfnADMUgQoE5Op5hPhC3wcddBFZpJ5XxBY7JgmzYgeezmtm1D3NrPTwuKT5ZaDKeGKpLxPMar5l10XVg+hHgSl7T2UAnp1XrdYv5mob9Ww16U7Vuuk7tGbtICC/W5717Jzo4IlQajJdkmpCKYunHLurDnTXF4eNJzueZaBD6Ni4mKZo47LrdjiFx5m1jpGLXPU0YiXKuI66fztTvt7Rc9Axr5grBaJ31ARxIMcTPB8YmIAAiDB0VBJ5iMe9uDHkTiBEdljWUEFnQp87W2iTuDlKkEmggCWKGa5BRrw/Lc+qDgFckG1jfswX8hAAhYzthAlIqoeOTI0Ps9nWODn1/+ezAm0C2cCoYK/EsMHqCLENHzvwS1Mzxd+Wyet2e9xdmQ+xrAJkETFdLlX1KCwgEbjVAoYRQBDZxfMd7T/pnwB9BXM2ePp+NdXsLO3vkDpdZMDIUf27e/3iiTnKoCIVUDLpMzNcv1hv42WHcxP/z7FKok2DCDJMDcLCZmLRWrZbUbodg6PE0HMJ0p2bPJ0OaEogQRSXXh8KZ+Wh8H8GILASuyWA49EHu+2Yjg/1aMUjJ+CWj46OGmfQgfYwB4RlQcIYFunWXyaHP3m6t7xd5UEKVdyQUbw6LrS2sK6BS85O88HkYGodFlWs55YoJb7I40RAJUy2UbaLLjWIWhXbqTltEGjoehTDUOHy44LvoRpsdYtKhFKWqnioymOnx44fuCswYw7llsbDjh6FXzyVZKCUL+yujkt8fGxf0bzokuiKqIYTVsGo52O7gsjvox5CM3R6kcrFgOGGxJnx1oFan7a4Uqjg3H2eaw9M6fElDByl8Xu2mErMYd70hZy9U997gEPTa6Bo0JeU0CRhorRvg45XKSFfWIU+BhzKE+AZKPjeeB5EDkyKDE5FrdpwpqXaQVwrD6yjvfy5t4lrMFoaoyWUbjXf65MNnajf7JmKg9V7OtiYlcVgzlyWJAmYj75/v+/DhicoVckdnum1eqtfp7k2J6b54yFb+/sy+orG05QqrGabIZSViG8saatVDH4hYBqLBXK/Gurq42cdzBTo3DzJzwceHx54nIgnptNteFMhGgE0gclGQHR/ec1o8Gk7kHJBwsLAa9rt6cR7T4cFXdP/eG3p/W2S05Bds2/FiYHkSRcIY/ediYzOJZ8+v1W71de/0VE8eP1b13aoG3b5np8x1tpuRNwxURMzsODxSL97XV6rS3z75DfoTkzf0O2YXynNP1jN3YkDqwVgBWy78XTsqFfOq4q8JGw9WMcQNwpDJJGXjCqlfnkVBmmI9GeF16gW0dnoODpuw0LepkLoQSGN3UHDRnQLM1VQSqHKhRJaNMaPuLKN/rxs8cv/oOz3Vkku1+xRRMDwTev78Vh99cKnvffhc3TaSKooY5kgLFUv3lYXlvYwYXru5aGk1J4YJ9mrfHdvdi80Hs3fgNg589gxnIrjbhjUamLMUqralJJ+QaBDmbvxydiGuXUgcYAcXfJAAtadTIEgzs4Nz6aKmI2LlYNi2dXBwpHgcR5eQjMLWVq7llUkf+mdBZOGwxBQelSjEDp6bCHsAGuRY1BszhvhjE7JgUIZBmEdCLpxC5cV1rtpQhd+Ct0FXhDE4UDfsTcwGIiaFMX8ke5Ei9vGTJ2rl215zsMVLhYIG27GRKwoHYNxSueKCn7GRY7owO5hM/O9CqeyDEqIjKBXXBokKnXelWArFFnNfCFhxCHHopU2D9V5BAV4o1bw3sW5g387HvO+FPWHZzyH1YIKCBR7dHsXGerPVaIxJSEyFXMbzWiBZ9m72JvSvThQCBoY9PGI/gLlNURuyg5mB49rF+5lh1O84soavH0Uy1woi5BuvPfaz3qg2tFvj70oBE7cuFcYsiMIc9v+eHQwrn+DmBOjXQV0HR0UlUhEbaLCX0eyQmIIXt8lwSGASBN/DbA9M3y/0oGQzY3MmYHaCvVKc4TiG4GxEbLxxVeolvf7mIz14cmjxNwYAwwmZkYh544pS0URTwUCXuQMLZLexy0yRlI7k18diAAEAAElEQVRKRaVqyQwu5oo8UNxkBtux2NgVc61e1U4dV7Vg9hyAWNDRdVCtJJNUV/dthAAUwKyP2KZULqHTewe6//hI8RTGBEFywcJEj0SlCJZP288sFqiGw5Y5GdWS52dpsh0LgZ2J5Vc5sw8SdoyFYZbAdIVNl7WG0RZN+wBcNlzkJLAr6V4g4uB2cnvd1NWLa2XTeVULh5pOIFZgEwY7j0N7psIm50BcDhZYiNtl0JvZUhC4hQDd9cqeiczSTJCCnAPMwoF23bEeCWaYYev50ouf94JTEpsKzEtE/DYeHg/ssxuNYVUWXGU4wIFpbJ21I/08740vQnDyNq5BD5JJyYQfCC6GrqGLbyC3xDQZjLVAMjTCuSVmYgKHrMNhc4RFF91JsxhYuNDFYcTdHRDAOyyq0G0v9PDBPSMNozEGDJCflhr0ejo5riv5SujwzdW1tuMrGynQETPXneJJTCcWjXvDScdzOmpAgoFFiGB8amY3wbAUFiATdG5YprEWXg18/T+d5/V7D55pOOxYznN8cKRYFj/jqHLFjKZzOp0wN2ReQmcG7IYUiCKKw3BjN54wV6UoBG4k8w/kBc0rZAgKOWbcPF8mOCBvWoSNmPsI0sLBi0QEjgCmFWnltUkm9Rf2kCsvSB2EqWMKQtcG/P7BB8/0rW9+otY11QVsQ+zuAp0eFmUyFuZTm+VMi2mwssulSdzJKx152VEyHwbOhTEEBGatLSQlE4HCrH4+DwHhZn2TmAPMRgSdyUygIEvNDalSaFUdck1RxgZeKNS1XcV1c9XVi2cXNjXJ56s2GSCwgQKeboXOKB7Leh2ymUNiicSjJvOwadKlscbnUzTQSAtkA4FoBmLdzs48FAtuBNyJSPEN8Dehy1GPZgL3YP25uTd/xpqmqVigpVxzcG/2jOeMi25ME3DwQnI1LQaWM6QXOh4KVHgN7c5IV1dX5nXAgIVfYTLUOhhYgFIBHeYyacthYMpzKFHo4g0MvEjtVATpcC4k0V9py9aQgWCxSDYlgAEwKqgTSI8Jg+R2xpOOi3PY/I58kIhHY+Sd8XnKFEKZtCI7oOKJvb35eUmKv8nEhQ0ify4bDQI8FLv4mHWfUXw49vtgnET3yPXh+aaJgaFMEcB4Yr1YKhUPblWM55jXmvQH2ofFoHDjiSmbStmYBSQDNx4IQZB57EHDQZxM6+j4yFDxdDR3h+qYPTNt51/sQQnJALs2RJx0kMzITKNO7szKyzjOJOuMwl2kqkIxrcV6p3ws66/ZrLCcSDon8ZNPnn2ea1ZvVFUoF7xJg1Fjt8aBycaIaXmukNN4hDFBQq+9ft+awW77RtPJwELgBW4vNx1XHFSuuNtYVBvbqFrL6vCQIXrCkVzZQkKRONEy+Aoy9wpYPdCk55CxmN0eKFmxYmKjQ1pB9htyDq7BvQcn1jgSS4P7CESL9Qa9FjOjMFtyOrzvEo4chE2v/b1hhLIBe0ieyKjdHOh7H36q26uWN6Zq6cibV6vZthCW751AG6eFssWUKqmCK1e6PVveJWKGIXgB+7JJcJByMLPR8kdmh47otlfKOwE8pUqpZFgaPJ/PS8hprXKqcolqDPixoHT6VA8eHmsX4aCYOaPx048vHO4L5MrCJmkik8O5JarZYqcXz24tF8CWMJ7LWA5C12B/Wlv14AKCpWHdmwyQN5sOpAecPNB5ctCwKIAcmcewWXA9cdh460uvW77TwyFnyzyZzimhaIGZeVTzFR6VG29yLKe7F4ky227LIvXJhMp2YRuwNeQskIL2lRKRuOqVmkcBHKwsIqLRgOSYbcGwZJEyaz+7f6avRVu6Wbf1abyu/6Sd1++MtLTeYNNGhBwm1eTzBS2cr5EJxRFlizkfksyEKDqYn0LhpxhzjmUsqWUEYgNSCjY97MlgGAavXBY2v2bLuYkOEzZS3ErQt0VXWrIJoFvckH8ZnFtwzPrPWiG+4rc3bnU/SoeO/rmo2WTpQ5pgaiQ1CK0gk2AsgrNTvV5RpVz0QTAZTryxA5XTuQAl1zZVdba5V1JViobSuO9AnnwvqACQpRxOjO+q5UIBOsNnlE0rEyHQnIOSLgBwLxCimNvxYsZPqPZsujUEiinCk9dOlfMMd6L5YuBnMu6RztawJfArsXz8rHQcuBffz4zSjIyWMW/mq0VaszFZjBvl0imWjwp55DdpXV93DK8i4/G1Xy8Mp+OQgxHJcMgIhiIK+A8WajCGsGmBjT8C27jd6bpg4FBDs7vJwa5NOxC5lM+bOEYMuTWl2Ch222q2WwGCpoi3PzWwbDj0bbuI7CWf98weZq5DjDG0NzF3axZ+MZvXLh5TvN+1NWY0EVer3dZuizf2zq5I5AhzDPDeKQqcZ04vTa6nUz4YJmNWQoADcradUvOd0klE/oHR7OxVmMOLpVE+rkc+j5Y1rDVsLPG25bmhMEpS2O9ngzaQgdjlAmqu589emI3K/p6KJ3RQqbsgt0+tUcvA5KW5cfPikUPVByXh2ITO414VSeD8hExv5WxjZHAczokkmZxBaWGSl/17v8CDEqsmZlbvvPumvVivrts+8ID5YKTCjNxFVlqwWcFeAhtORFTgQxrvX2rYG+t7H36ijz956k2HSgJ9JbOBAYGd/aZhG5wegI8YwjLfXKyGahyUlEhttWwPtFyNXfE8uf/Y873ZZK6jw0PPmR4+vKcqCe1Jst+wmYNExcKh82J+BOY/UpROCtLEAnNcTEaY9wS4YrkMrhF2xI8CoTD4x/UDJiOOOBl3XvjLGk+0+wu+rQsTH+hACoVA4afU4nBjnuKw0TnD77hG66mefXatp5+9cED1m6+/rqPDIxcQbKJQpu8/OHPu32DQVqYbV6lKMDNuQyHb0MxH6jQbFoDpk2FIF0a1zmaS8uwxmaRCg9kmtW6b7v6r5ZxdbZAGEIrKAnzx/FyT6UD1g4pef/Oxsz1t7R2N671vf6z3vvuhxsPgZEFhU6uu1OuN1B8MNZ6sTOzAuJvOmYowl85rMh5oNOj6OlIB0zWiycPQnmoSFALWpb1BZ1NDOpPS0kbxzH+A4tebgt/Pwwf3DaUMelvbuM3mIaMOoXm6WNF0nnC3w7MWfSU7cjkn1QZZSV6RzE6b5VSjLRAshJ2dkYd2q6v3v/uhXnvtoTdaFj7zwFQKk/mWNyI2gs18o+hVRF85KOtnngz1B2/Ker6I6V8a/LD++IMPdXxY/dwMdhPFUiwYSuNa5CSPzdbMYzahRh0D7aILPCB9h/j6ud0EDeWKjgJ6/iQYyecyJnAY7gI2YobteLqNtbjRbcwQN+QQZ2mmE7Ya+yd/NUCuP3Uy1x/50kiLYTDA5/NwmEAUyuVKTvrZbQkj5j7ldHRQ9XrkkKCap4CB6QijklHFeBzmrg3yKPcvXE84KFifIAJcX7tmgToYvsTCLhCWWJvbxdzf3/IwWyqatx30lXZDmlkiQbHy9LMbP/+lXN6HIkziYi5j68Nm8zZArow0nFOILzTh5hgKjFUsU+jvtFzDgo8qEaFbnKtxWNEoicE+hwecgIVieIWmCTdPqktmJuRDZBnZaiAhpjI2OnD3xsQOK1GsJFYLb8K4RzEDpFko5IDQV+r2Oh4TRUpIWUhgClZ9HKXOBzWyG/187ANMzUFJlx3sHqs6PDxUr8/8faOUHXSye1u8tQthEjWAKe3ChX+y6GYxE4i7uOe6dvs9ZRI7zzlBTnAtomgnC5aEmx16bR8iQafIIbhZ0V0Do/NvrudW+Wzchz7fn66N6wZyhY8w++hshkxqYAbxdbPj2Slm9BzCPPN00dzzi4tLqyFouqy33HNDaDp4xrEoNOO/WDRHYIQ+OEKSD9pOZDFLrwEc3FrtpSrblI5LdfNlgn1mcIRif0HnSdFJ0QICY+ThZZLcF3NQsujQOjEsxZlhTfDqTdchy3RmaCbjSalYzvoB2e7QS0aNn4O3s1G9OL/W8/NzDQZ9b4DAqCcnJyoVq/rgo/f09PwTfe1rP+TFQnWZL6b12aef2Ibo5F7dIvp7D45dtU7GwVItmy7r6OjE3o0X5xeWOfzKr3zb9m2034hnCfEsz0par0um3K8X+EOulUrDuoLIgOvJ1sJvfA2BTzloLehNcgCu7UwBxTq295Klgqfy4SbmC2V7sEJLbjeHZituV1GlGvhIpjyD7HW7rsqpPOkUcEpBf4oF3+NHjyw7gJh0dXNjerlNwhN0I3nNtiPr0oB2qYIK+YoXBhl07jaywVEEWGk8CsbkmA6HTZAuFueMiTsXL/gkBt5pw1KwKLGF4h4B6zDPQ4PYvL7ReSHtWLRuO9jL4dfKYcuMhIX0wQefaLMlCR7HEA7uiH8WeikWCxXraNSzPy9WfVR/g/zQ0h90podHDZVqOXc3EHlsP1VMKF/KqVyD3EL1iWfkymkbwOqxaEqZDPPbrJmQkEmABYOxO6xi71+eMd29GPSn4lHbDiaAGmdSvRTCuwmxplKaDifqp1hAZzo9PtJwOPK1BQpkUbOrs8D4XnQTRPgcFeI6Hmx1vojpO4uK/rX+D+iP32tqNxv4PlMMAFUBK/ItkJhQSKEtfvDosbtVDhKbQnANlqF7RNuF3QXwlhc4MzO2vc3a3WI8hQvQzm5HbGpU9VyrHCJy2Nu7rZGD29lW//P37utyCSlip8P0SsVkVHgFWe5F5Z8tqNW8VeOgqoePTnR723JB/Nprj9SoVRzc2+90van2Ok1zDCDLZfN59UcT9cddTavBEJ0Xh+lkLFVqGIKAnix9nc3C3sLWDMkrIRQ9bWcqoGS6yy2sX0oCQhLwu11Aghp7Ht3uDs3WZCQBLI8p/2hMkLqUyib14PFDdTudoJJijWH5xr5xeqjtrmqTeIKwmXVvF5vQvSfR/WJtSHEcIbjWh/pmGSLJSoWMJqWc54z4zVaqDRfK5xcXWkNSqVc9O+y0uv7cSLZ4LyHwOqNiMa1chvUOiQ0ORIjSG3bxig06ZTZ7PnMymw6HjbtCGMJ5P688b/gGH9TwT+Xh3qpx0LCEaoVJA+0e8HVspx3uZni/zhZa7UPkU3n+OOroPxBZiD+sFaB5WMd4Rm93CaWz2FEyEy5ZtgPag+bWgd/Tmaa7qRb+fTSfwZbQh+hma4QEHgLPNTKXzRz2MzPolT57eq7BaKSTkzNNSTVRzHswc1IO/R4yD5jQJFFNCBFnXwLaTXnmGktmFEHaUyxpFYkpNR5pupibLcw9xLXnttW0nA9TkmwR5UXGDQT7D+MqNKzmnsyndmbDli/o6CAcrb/Yg5JFb8ZpZKf33/vAMBttOzi3kyiiWxUrBb31zhsqVFKKxMDW+RoWfEb92cRiWm4AqdrgyT/yIz+ser2mTz/91J0mZtvo6k7vHSqFTdSSRIRT56exudJtUJanSTDHwmm70HQxNCz27Pkz+xmi1TF0QJbZaOnw3IuLpg9L2Fk8hAz86ZaOTg9VqectnF3t5iEZJBqxENwJ8xsE0Vt/Tlp/kCMOSBY7w/8ShvBrxOBxNZsjfefb75ksAiYf32VVK0U0WSFf6YT0BOyeljvdXnVsPk71eHx4pDffeM3QW7PdtH4pSTWcpwtJO6XltPxQ0fhaw8nEDv7j8co/5/Z2oG1kq7P0oaEMmG48cMsZ1HoE5ymzF8/PW5bMwCgDBi8U4qrXy57BQPQRlO++w9FCGgEuGhFZysNmg4fvdBrssiiWEjHkLVDNg9sPc7Rg5r7zpsPfQyY0nIwMPaNtgrXGjKa4X3xm8mZhtrZ8CAJpeVaVDmzP+DJY9oECVHPA8kDYEzP7DuoVs/SYJ9q5Y7OwD6XfSzJu66zEK4/2QaOo14+Y+cY0Giw9W8Nqq7pEY4Uf5dSHewa7s8hWjx+cOWEAz+LApKbSDSYZvL979w70zjuvqVbL6t+ut/W/er+m/7KZ0s82c/rzNxX9E8dTE864VixUTM3dweHBSlFJ+grzOWbVzH8gofHfsbgGk57HBczeM8mkNXd4zVaq+CEnjFYgiRr0+sEKkg4ssrKv8XLZc8wda4XN4f/w0bGeLzOKRXb6nSdD/fOvtUwkM6tyzT2RO2XGFNH4QgdHGT1+8o7tHg8OqnbeGSSjhtsp/DIZ5kdU70uVKg1l8hUTni57dw4GoStCl4sWGqu7AENiOkLwdMpdFFAbzSVQIigML4f7Aq997r7CgbjUZBS6GDLO6A7jiBxiUiLJubZ1FeRZ+GLqsIHgQRq6ZWDy9QaBfyCXUPTw7ClKd78zc5iigxkkTHw6MGZyjgq0g5DsC8vBHLXmmy4zofsPTtQ4qOnF1a3WI4o4GL5J7wVIIhwpWKAITXmWXi7mvaH7Z+C41emr1xm4S/NsERJRLGbNJs8NJBZOAub/RUy+C3klIlL79kZN6xw3toWkyAYNKpeJxwoEJHykNzNsD3Nab7G6oyhK2iIUPsN2QxG/1drdK/I3eA0TTaYUaqQP7bx+WFcYaNAx5hMJ8+LGu8BeBi5mzs7oB17AHL9VUj8Y9XCYOo8SYuTGuu+ok5Fw/pp5hotPczqX14vrG40moXs2McjEtKAjRYbX6Y2k3tjfs1Y7UJl5db6k7ogRAJKhQLaiM0Qit4sVlS0ntEOHaav0kJcZGNLEh83NQoeAuFnBs4hrPPqCZ5R0eZPxSBcvbtS8aZpqb5MBIAQFh5RSueB5jOPuKMkMS7DA0lpmtzbtZmEQQfTGa090dnbq7MT33/+27drIG6T9t9YqEbdekEWPZILCiQfDbjEMs9Nxt/Uw/3q9pqsFhsl2gyegbe//x98h8qbb7OniGa74K3eZaAWPb9r68g++qeOziivJfAFTgQDdgKsTv8V8zixDa3iCqz8wAFAC1mXzOQfIWs+f3eizT69800vFjerVhnWnzA2xrYpmk3bFaSKy7waXDODLH/zhr/g6Xd9e6sXlhZLkWqJ3wgGFfMnV1uQC5hmZZN5Sjtubrjd6ZrqwiqmsWIBUkOgUE7GsUsm82u2Fnj69VAe4eg6VHPsqqrOCcoW85rO+yU7JBHFRaW3WWRt1M5fCFIFOYIIDUS/Yy9nDN5nSwQGB2iXP5OjcrX9a0BnBokT6wrAcAg4HxM6st6PDmp0z+BzMNiC3gDwQ4p3Ocq8ZwlOYMFuMKp/gOoTOw3qrFaQTIsn6SufQcNYtT2DjwjCbrzFLDycciCGrl9ArP69I0sg2yTRGuVTWVTUw9YN7dRMS0KGCGmD+zAaBnypQGt1yqZLS6b2aTZhrjYq++tUv6z5WhQkZDv23f6yv3/9Laf2nVyX9Siep31pJqo7h+Q42OH6psDg3JuBAyuA6WhaxoYPcucqlmx8MgfMjn2cIwvq1lV6xZKiSQ405HY5MTovHPHoFE5RM1Jgah0ClSInSen+a0fkcks1O/x/2/uTXsnXL8oTG2mvXdXn2qay2e1/l7uHhGZmJEDSgl1JCC4kGNACByEZmhhBCKJRCglZChzaCRiIhEK34F0CCIIkIDw93f+7vvltadepd1/Xa6De+bfc5UjY8hDU5IdPzuNeu2d6r+OacY47if/Bqrv/Z10Pvqy2/wBc1w6SAO02QcFTreb1+80z1esNkOnacQfSNUXpBj8OhtsTpxSmbBJACBBxov8z56Odr7XzGQnCh8nO8D88AU6Qn4z1nAs0mU+Q+uGJhi8eLZycspBNprWYQl+Yn+8mjXWk46G3KArS4w/1lpsYOY3IcwI92GUKDTLE9nrS909lG7ULOXrzRLuQf2gd5v7cBAecFaShMexz6EEcoqKAYfEfuIXmGNK1MTPz33I/h+KNlP9ihwVaXIPyxA1+o3Qb6Ji4NYh1eucDvVfsJYMSAGJ/7wASpDE1lLsSz4XVt/ezKco/ry3N1II95N73RdDy2nGe933uaR1LHNDet1dWsl81IxZoytQO2Pyi9h7gV7gOFApLVapE24hRSTTLWCCNdimwnSuOQVcJeHSZqJbhx7bEYxRc6lfaaAtUAcG++XFISx1rO4RYQL2fh9unzBtkFaSU09ZAKYdCGPNGgsUYPzPc14RFy436n+Xxm3kEwoFh7GuUcGI5nak7YQ0P+KZrPwHlPMwL3gYg1zDm4TxCK0OznCmU/F/yYTJSwhtnZcvFIDJgybvS+aKEsZHO6Hz5q2B8E/8RaSTksiBZzS0bogKG/e2HPgH0irxwOK2scyaKDEXtu5xQgUx5uCCtHnZ3VbVr76vVLXV1c+sWElu69NO4ShryCLR37Gjwh262aMnFO93OKNo4de+Uzae1JxEbRG9gTJ/PvtPInbdv6FBLNxcfhh7ijs/O6D277snphiZluOHw52LjxPPSfmW0Uf0OVc6YG9nBb3d8PtVjywm3UaEQ+rLbYj1niEXnqpRukuPIQ1FstXV+f6xBt9P/6Z/+5oWTMzinuuJDQpRIojgtQnNmppoJvdL+HruzR5sHdi45haB7AoPNKu5gcD0WxDri7HXq3E6zHjlosp2pFbTt7UMQRT6+RSawmfnH3ydY7JqZt5AvsQLB+wq6PA53Dk6+DSQI7yFy+4YeZw+GpN7L5Mg+iiQEHkgowD+jq7ZtnOuvUVSFmCtPitLzjBRpHUnM4brXasi9MWR4BTALzjk6b688zBX8EuDYkklMMc95v8jkHvbH1r/liIAWBbmx3f+gUgZNXZEZigEzSObB7DrYlDF7ML7D3S1kkDWmB6ZU9Vveqqets1kzTKL3V5aEddhrAt4i949AUxslW/+SXQ6WTlf7pw7kWmwudZXf6T149hBi0A5FZC9P9P0+ofI/9JkBxHBg8jxCXWq2Kp0x2czzn5WrtJBeY+J/xTNKpc40x+YC9zMQHixhT7lWmov/0+7a+m2f07SKrf/y6r//gq7mh+mAvGGzY3BASyBJDuklUruTV7NTMjEazWsjA2o719DB2YxdM+XdaTdkb5x0W8Hj3wakR5bOvf77WIzIXaZYJDqbyOTXi+LP/Mc9bQGSiU+JLxgcd7w2EOP4lsF4qxTULns/IEvjMNBo2O1/xHtJMlP1n+rpEwYYPj1v+SsxAYFfTHPCd0TKzs2d6JCElSYCIyWqk6S7bj3q6WBl25e8EvseLGqg37/uN1ypG+qBrUzf4IcsQPTEwI0J5HGpydrGClEYhBPVA68okjj8x+2mKWzYdWL7Wyh72zq5d2gc7eCQ3Gw2VypiyUPjRYgaj9nC8Mg3DGMadi9CEtSJhDYkZe9DdGv05+aiiz+T9woZyu2G6xWc3ZEhyfYizItXH7wqG9JktWpxACrPn79aNDBwDChPSFpqfBB0sVwDoF4onZMpCIaAoyG/WPMPyasvWeEccwyjWS73/8MHrKBio3t07RiZlSN0qikxWh3zBzaLlKY4WXFg+w/lTbUO4ItcXHSpNW9Ue3ky6FF87eUbA3TuvruGGMEyw3oAfw9+LKcTfdar6IoUSaApm0aQ6034zU5LEOuKmspWKMCkbNTUbdTPYTHCx/ubgwlPIAoXGztNpnmFIjkHwRBFWkrEcX/X2668MjWJ6TkguQc+bLWP31jAe9HIgAg5W04nRXy2WNoDGuiipYHd2tCSCz8rfX2sEUelygZA20TATezrqdLuGwD49fNLD7aOun52pXOmacsw0ieAY1hcmx+5mRgMXBOuFqlUfVBCN7J5fqqjfH2kyXfrFyeWl6xcXap3VzNRj5zi2Lo/d5ULlalHX110ncLTamDVLmUKs3BFaesHQbLVOUalZN0hQMobbWIkBhXEwojur1pCqlD1BBLuvpc3Fp8OFGpUzHQ5pPT6MDHuxbyURY7tbetfll3udaDrfajrfmIZPp06+XBn2crUY7iP5jBT/9c60dvYfdNrg7dDpCYOF2Upwaz8Jvq7QzkkfsFVhHOvZdVfds5qKpbQKpdhMPRLFAht46QMOliyHGQ12OlMJmX2kyNANR8QQQViB1g27k/3CPnjzFmkmEnUu0iotMMTYuPhCXMgy6J9sWWkqeNjYmcHuXJIdykGFaTucXQyYswXV63gFHjVbrmykznWgIUA6Q9oI93A63euHH3/SajvTP8z/WqUKTNlE+eNS//jrrZTO65/ewDA96mGd0//xH1IEeZ6CR2rw/U38WTk4QRm4TnTJprVngAk5fOfeM1oycdpl+bvEgUnNThwJBpPIYDgy8jJf7fU//+2Fvl8GucY/fvmo/+7V2LApRYO9EcWJpo/mD7ISsDgNCPeaA91mB0ycKRjgK/V6I+/TacBgx3JfiVDCznCzmapcOGjahcUcfsbDkW51sLQqV4isq9skEPtwu+J+YSrAJEsBC+scTAFAEiDvMG20WyU1WkXlbx8kBWG+I77QbTsVIjRKVWRFkEkiDBg2SkjI4WC3DpCiCdFj74zc+eQxONywryMUO1sxrD2bbUxkKhYr3pUrz8QbyB6BEZlVcnL06g3Gms4XdghbLGGV44FccGNLKAJkmz/5499osZho0Bt4F4f0yXFdK9xxgncvyMA+3qtWaXgKWp6+P8YQZjCXsr5eZsjv2SMHUg0TFO8AQwGlicBl63qdYxkmdCZOw7c0hJBeCjnfC85OmJ5IodhP2tTeWs+iRqO01kCkDCNIJjZrrVdZTSG8JjtDqyFYHEkYGsyUmdBUOJ5LfG7hH3hvGaOLL3vFFpsVHLTpkDP5+9lDrxZzDXqPP2eV2toSljR7yiilEqunfN5ICYgckLBXH0lANXHsgcwEzM7vxcXHgxQIFgb0nFM8x4egj6dpoGFYWTsNMkbdwfA94ySqL1ooEXUiiVifh30L6RUTHFCOa7VaddtbMe6yFKbA2RnlRPHmB+YZO4dsvhpuxHJhTR30YTMMHVu19YXYY1uGzRWHeoz0gSRtMHj2XYz2Ka1IzUATEx2dSNEoBwE5nq3ARX6RWMRvob0HW6k4Qvg+8o6LyC/gCHY9d59unTlZKDYNK2xWY9PW2RvSCeEOAqu3WKwGlw+SGKpFVSstjUdbPT492MKqUi3o1esrXV13tMabFJnDYe2d6vPqlTtO/jv+fg70SpnQ4pKhKHRsvSd2uFKpXPakYc/U/ULd87e6vLhUJoMmM7J4nQcJ6zGuHQcHe8Qfv/2g209PenH1Vs1Gx/AsTyep9z5gIlkHiCH6cIZ3KrZZkZbJVp2zqpqNnArF2CQFm9tvQ0qD22hbbCHCxmg2RODwUPNc0P29efVKz66fh6DsydhpJhTReo2HPvYvmKqpeO/DE//PrLVbCLYxp+aFQKS/8xRMqgsvJ6zR5XLq68a9IVrHaGwC3AiJZ2UST7FSUrFS9sSLDCM0bKdCSchtnNHDsK8fvnuvzRrGc0mVSt3aMpYHWK4htWGF8OHmzy09Qv5ClwuxAI/WKS5Qu5XvzV//9kmjaU9/9o9+rc5FSELpFLP6J1/dqb9M6f8xrOjPJwX99/619L/96sZkG4Jq6biBsUfDsQOVIeLYcCPGezg41diQwnaJsafZwDwA2oZMFbL9OHAdH7TdaMv92UX6H97+Aw1J5QFufTHQf+fqyab7QGzoNTk8Odg8MZ327RRKJn2bnhsBiX19e4Ohnh5Opgt7ee9I4SmXmDQwqXAyov7oN691X+xKDyd2fDqn8fDRDVutVVCcOwZRN0SXHByAnIuY4+NghvH5kAykcloBK+6QBgUpEyuCbG7oa8HndEp9GYY9mYpMaSvDnUiGssCrufDMAknzTALjYmAzH6/0w/fvfA94Rtrdtrrn58qmy9YsE27AdEajDqTrcPd9CM/eHWL1BxONpmj4ILLEurvvuUCfdc69z+X+cV+vr69taoCTEEblXEtWNOzTHOKwXruQIDdBUoW2nF8LJ72E8HVPwxTOJFG9UnFINagUqASQeb0MrMvZuzRc6cCCctnPO/AnyAPQKucI8YOsx3h3KCoUEApLqt3UYECYMhM/BQqkiJ0oEySPW5DwLBZoRIOml8aqWWPlRALUQocy8paMYWCjAyepBftC9JxYXoJIAd7RAKyZ7glpns+1H4+VPkaqUOS2mCMEXoMdkvDFbTT9Oe+QlXmrGD6TzQ+wEpzPPNFWSjmV8lnF5aLfe+4Xa4E4i7d0yLrkHXJyTJTTcY8UJcjmzIQlANxs4C9ZKIGkDlsnacBGHc5G2h6Ip0rr+Yuurp6feTJCGvJZ5/O5ntNJ0BUAmUSahy+1o/KHiY3cNhIBQsoABrd8rMS7iFI9p3YXaybcTigOe+0oQNDi2dGs9jruUtbp0VUupojGC168p5Kdjvs1CXkq5/M6a6F/eq5Wo6rDYGRtI6M7DzG7uEJhodGg706Xjh294KdPRMbkg7CapIoDuZGIbpsuvpPpvRarkb0wn798pa++fuGIn9kMskWsV28vPQnCzEQvBe2fFwWdHTDlAbZmtaZCuajVp54266MWi7uQJ3fcWdpiFh0+l2ircMx5cX1KD2CHSMbjnSb9qeIUxA1gurH3PHzuwDQEpjnYau/Vm5d2orm/72k2h2V3MEO5TJhzrmh2s63UeGGhnKewo8pquof1y9+BvV3atnYUX2jw7HbYLUdRRrPxWBO8PXORquWcI2/iDDoqnqFQeJ1PeJpQYR0bFp6vNRyONRgt/H+HdAl2YmhjyRIt+gV9N73xIQNyABOTe1Uu5dVqd3R1eaWnByQEe+3T5z8/uzmMEcR6IEiP1msQgKkm45UmsyB5QOIyZh+SwlwjpQ8fH/TDTzd69fpav/r1V2ZWl4ttxfFHpXNDDYdHT//EyulI+gy78UjFONH/7t960v/oX8X6Z8Oi/uWkoP/qn3+l//7lQP/Ny5UuVkuNB6ShTP3ZubY0UDRFsKw5XAOdPWvdHQ3YkUQI4pR2OyfEGDIlqzKd0bjY1f/tzX9ZfxUFc2dIH/+ty6n+4+cPQcieg0ACAnC0FyiZskwgMLyZSIIYP61SperVBvcH6cNkuBL+1FybKJob9sRQmmmm93RvQlehcFTpWdOQ4OefTqOr413fCR7p/IWKKXxPgx1diJXLqJTHEHvpd+/zqobvG9dYHSANmvq5dIB2Mef/mwYVRjPTLnAthRNwF6SHPSSSMFihHNqGC4mBYa+5O6r32Ddbm6YCkgsSp+XyJryLJeKX9t6RAz+bAb1ZWc7Fs2+uA6lEO8iDR68tSib67SzCZ0qFkNho1e0mdfOxb6QlBDizsqHB5z3CVm7tifHZs2uvjTgT0Wd/zlSlMeTcib0aUrBs1FHrBfDq1n8u35N3x/BhjEa1EFCaKNZsvTbhD4g/5CSnlBn0rEQIcjY4BmnLqTJnTUs5HtcQvPZm+3NQg9SFXyFDlEksi49sPvvzWc4fvlkuVG42PNXTOM5AEcpNE3K8FnQuK+S1jMqlsjr1pr/DeDjU8rA3o3q6Wvhso5Hl+4PinLXbdiwCQbKG02cXxCLs+DC9IcFkoSo7zC3ytJGZ/Lly3k0LhERbEDrQAEs7PjdEPj4PGaHB2P4Ig9ZGB/rCZJ4j1XrpB77RqWgf7ZQrRsb+0TPR5fHy0T35xYyzhi/4lcocQ/bk6qAlWqNyJRjt5nJ+UeiaITNAnWf3Fy9TJtcg2UjnA+TIf+88OXwLYBHSJXCqkeu4DfEv/UdE5fPARj2gi2oqj3FAxB6DpfDB0xxSinjsBtOjf+pU0unwSfsALmG3yv+f3cOLl8/sGoHBOV23IRzwdODYXKw3X13rzVsgv5LZpOs1HXvbHRc/HHD+tE4xgP0YPi8uLRT/ZuNM9VpL6fS9tqkAddrEGBYmUV3bYIsFaeX8nKmXKTRvlum797f65rc/qlQo66x1Zj0dkAgaz3o2r/Vu4oDZTrvmSRczhu+/C6kdRFNhu8Wkx65DUUtJdHTBwMprvQy5kkCXsHHpDIEtOPAoYjzk7CyAmGmO0FUBHT67ulCJnVe7bD9N3I44LH0I9/umrmfSWGFhIxXYxUzmo8nKCAOaVTpXvCKBZkEsrq4vDB17ckcGsd7ph+9/0nw61WMPSB70IqPb+3sbJ2wqjb/z7LL7QLRd1+s3BeVy2NaxMx4Z2q7XIe6wIzyYPEBzkc7hE0oQQKDR59JFQ3ZA4gRdNxotw4/1WlfreaQoHbIK2X1y3/4Pf3av/+lftzXaZ/T/Hpb0n9219Z/dSf/kxa2yq61+EY1cIIFcTSTZ0/0HT2EaCRpG+5R6/xMiovgex3Vgjf6z5bneb0v6P22vf/a0/aPDvX7VKep/+cuJdvtgAce+n+kBwlDIf8yFguW/I3hycpggBTgUsFakeWQ/uNJhF/ZvvK8cSkBehACgtaQ5OT+r2/qQJKHPP7CRJ5/uLccoVHLqxg2Va3nfGwoFnARgbgo/Ppux9cBhh8535/cBSfM88p3p+Mm2BOHgHYUsRqHEkYfvwoGKPzRSLa4lkwjp9sss2ksMKHYOWMjn6s4eJWA+ipANpJ0+RFwXq4nzy65evbxWvpgL8Wa7tQXveJHWmnWNYRpPh9psFy6Ci1UImGePSmPY6/VNULHI//PFiNCaLh140KjVlTiAnaiosgo5IM+x4764Fm7A0fYdgERDIgj7+hSZpqcdb47JOx9WWhCbeA5oxn0PgSOZ2MkMjvFF3Sm1pWGf+xwrFrsmOdHkIo/I5QhMZpoe+HmFkAkkS6EOofMwZrf+bwom0JBOAktb3nUix4DsZTPyE8JAE48mHK9YJIBoW5enKbFZa3rYoajzGTjz4alwLfl+DEvNekPXF5f+/CB/QLOcLbCT+UxIdMLqCJN7nofw7/dM3AkFucLmwzJCzqpyCgQjQNagoCZumWB5YrAXcMz6wsHNPDhMD/FpT5crdhyjw26SyW+9nhlmTWeKwbsxAUuHYs1uIxFeSoUMer25Pvz4o5mtQEcYBb969VyNWlv1akOjEUtyoJAQjQNhA9NznFOgjR95KfFCPaR03MJbongeNXh60v2nWy+wW/W6D387mxwCQ3Zn8wEc/cN3GY0Hhh5gcJJ7WK/XLLZfrTFuRlQLEWCn58+v/e94KdgxfZ4op/OZ9xpXz67U6oTO3FU82rk7NeQMmwvC7gGWHw8eU8jB2Y+YgtM5I2DGzYbuHwF6/zjSfk8HD11+ZYPhdOZo6cphh+MQaQI5Pxj920d9/90HQ6i1ct4QLPujRr1sfSAxPq2krEwO2A4TaATrS/X6DyY+fCYrcYAVdlnvXigQiNYtXp8Suk0ANA9pSZlcSN9AtIwmjeX+ZlMwm5ZlM4c6BAQci4Dg+cW0AqQDREyo7VNv4kk2m62oXGoo6zTyo6eCp/7A9mJAWTgPwfxLkT+ZC16/QPuNDNCTlM1t9frtK++H0NBCtKKw/epXvzYS8LvBH8KEkQdlNQtWbDB/zy6UyyOwLpgqjgOUUllDRTOHfm8MzSPpYadym3tUvfxe9XYtMATx01xv9e03P+jm9sGQMIzTdrsWmoNawd37/+ZXH/S4jvW/+uZc/89p2OP9px+uVIi6+vcKBXsfZ/d5/Tvrb3RWKhlGnk4oTsBCwY+S7h4y1adFWf/3Mc8hPr+J/s/9S9PfP//8qv+X+m9H3+m/8ss/1mad8zPiEPQ5cHHQL3I4BMg1oDY0hExmWLA9PD6oVCJ0gGDbhuazRIdtyvFdE8g8+M/mKChtFZHsNMo+GO/ucCiCbPArf45PH2+Vv3nQzcO9Usg1Chmz2TnEVpv5KTkEL1sK1UFpwnlPIepOUrGTT8GmEUwBuGH5aKRJsOMOetq0STlOyUmxX86YgAcMy54c9yeeV2v79sCfIUCb6KzeIOTTtrtdk+p4ZocTNM09T13dc8y08TrmmUVvTSA0+9WQysMkybOPXId1EPyFyYi4N+Bimh4SMNgXBkG8FZWwnePY2ZVAh3APGARg32sy03E88/nhJA2ipGgckkSPj4+K9lu7D5VyOUOpGLtTRTHuSDcho9Fk7bRlCuZwY9fsc4jiEeD66WSqWaXguDuuAQ037z/3gbNif32hONWztR7sYK4dGusdhgfpAP1yTmRido1zNy2VUuMEuRLlhVUdphRTZbEM9HM391TH349vMlwHZDJnLZjSDT+H/UFf5XwhxC3m8ioXSn7nTcBxaiCDWM3pLUyqDGk0UiZ32lgBRzXUCAABBxf+TrNpVzOaCFZbnC24WDE9Y1xBw0jTTm2o1Us6v/zCO0oeklKteGK0HtVsVJQ08HMNVO0I5tr2YIpzWAxngk3QZ8YbAvh9Sh9+uNM333zvF2OxXKjRqesXv3itP/6TX+visq12i7BeHjQ6P0eBKoXQeB/bvGC/TrQYz7WaLE0uoACnFCjhkDM4VElNaDaABIbWBdGpQvpB7smke//4ZLcbG1U36+qeQ37ZG15FbsHfSxcUnFmQq3CjQpIIL0yWvcs2EH+4AEA+yQkKdGqB0mEHkc2ZUch0yw9OMMQD9Z7ImcMDFTgAEg10ZeBeFmxHL9+BGvDELJViFwj+HHadwBE0K+PBXDc391qt996d2giCiTXNziKnej0vRWd66g/18PSk8XhgfRdOPEAcpcXB0xyf43CM9fzla+WLZU/DDulOIo3GUy/yKeAXVzm7eByjkeUDmJVPZynVqzVHPNFMNFotTyZAGnDT6dpJU+BgoSig1ZrN2XvYuMbd/mr5GAwajBRE3jMjW0kpo3arZV0bpgJMsKaRZ9FrcUDSIGW8K726fBXo78WsI6YMEU8wEgjP7jfffa/lfqp6JSSb47SEOP9FIW+2883No0aThaU4huxV0Hy5syaNDMTRYKD+46Ov7X6Le1CsYz5vk/wfvv3RTV3nqaVnz86Vy70NBtt5woF3yq1G+o8uFvr3muzajvpf37zRPEnrny7fhg+3kP5VnFXlFCeVWoXngELLAc37xSHa2+f17fIPGZv8PIvn+m8c/9YWjvmP32jVaXmHhr0kUgCaC+DGMKXC+FsHz+VTkgcoAMxZG/RHKZtOE0lXoXM/9j3VvHj5Qk+FR33/wzcql1K2cMxn+b1jfffdT36mp93fSKF/8fufZ3eGGD0hqBdtZFGFYkXb/Sro/E4SAgpkKCx81+zPJurochGug0Cw7qBh5hnh3bKUBIMQR+CRcBJCjxHfs6sOzQHylpDiE4IWYAjv3bTy3WEXwz7n2aRRRR6SpIL+mv+ed4zPRwFi55USjHh23ZEJXtVKyZ7PNGRMPlxjkDM0z6vd6gSz8s/2Kp2feVcKGoXuz03jDiPvsEflnsBGZ3rj+eY6cPjzbBHeXs5lXGj53BB10D0CqVbqdRc0JjOK1+4IyoP7WMG/hynR+kEYt5uNU2VaDXae6FGBrNnB7lUiB7MVKZfOa3OGDpOwedxdaTBIBQpEMibXQg5yH6uKksljgdDDPV8rs1w6J5dawJQMt4Pm4WB9JPIeXKpQDqzVqlXtpAaLlWvqlBDe54RVBhadoCEFIwFF6+7XWqxXbpiosJz1NHQgDJ/dg5guafCrTRAsdN27U3MlIxS4eN3f9cwIxgDEbkgRDlfRly+UMMiAO6AB8wCvNisfmE4oR/y82amHOH2GHomum44KbVPGkGgcFTQfLrWZkVqOZ2NW08Faf/PXP/hLpVK/NBkGwgAQm5PiEbMDje4S2xSNnkaaDEchv5D/BnZqJrbp7XKzs/UZv49Udm44EjtyMekM3WnZjWLhA+PsvGM9ILDCfDaxly1Fih8KbviV8YuE2wU7BC6wQ16PBzNQTYvmmTSjERo3XSEU+ETZGuGpWMlxMEm3t+/013/1rRYz/DlD2jysTQwNrNVEKpGQA9nwzS9XYXkipYD5uDPJB8gFo4DHp74+fPikyXSrSinsEyCDAOfE0VbPnl2ZhRfig1KWHUBuAsP/+utXSulG97dj732K+ZILjD1NB08m+5y12mq1DnrY3NknkWBhyE0HqOkHFv1oKPc6QnCBaez0+LJfiOV2bl/dauPCrD46PNiIs/lWyxXWZillj1D9DxoOZidILmsPXvacdKI4LJGlib2dUsCSOU/ae1JrDviQ1rz/gTjx4uqFafgYnu/2TM74C9elp/DsErr7/e1PwVkql1On3dZXb194V93uNCy7TT0MLLMABUEsn8sTU8a+G+ieVclexSzwTsNp73m0XNu9/tVf/ms/cw5utt0fSAa7NmzFKEAFva7ndbYYujj9X/40pft1rP/x7179/G59c6i74fMPp8F/YaBBkMXww5Tyf/3jn7Qh8+/DJ12mVhpVyyZmsXveH4IeM/i2U3hjoxyHAwWD/RyOOaGBtLlDGm5AxrtA7OnStZL+9nfvDZ+122RbpnX5/BxVJFtBbQ9H/f6732s8GOv66qXWvA+nn5dvXuq8Hds9hXvEcEAgdHY0NUkFdMS7xwJkKmBkkCpWBRZfu7nmOgFDmumZxg6O/STPRmBH25qSxonw9S2Q5d5IEfcF3d58yj59YVQEXgBklsVs6b+X5nC+JCUDZidkO/ZeaJV5dwNZBDgul42dNcnkRxPGHg+nmWAHVzhZ+2G+Dky78bWgQNcrjRDcbSgy2MsFWU7K8Wo0S+xQ2eNx4ENyZJfHOWF+JgXAv3fFmKZqp6VOp+1dJWsL/jn7ZNirPMuj0cDFfI29HBaACucTxDQ4HJwJIE7BPjMwb9G+c/5RwDm/kE4AhwKPYkqOYT5Mfkv2acxjfKwLqteKWuditVqszTAFCNcLeBriFUx60A/+Tu4pusg1xCC+q92naMzQxRLxJe8jd4E9FAz44R44mjDxuW+DUEg81IBFcKjiIoEKQU7izMnR7OYLHmaAufnc5WpO1SpQMY3YwdMmKN7d7aOtSQullOV7+PHiBSy9/nKFEq0PMKvpycgGNuiZMKXNeORdL/bKpcvarBL9zV/9YKkCwm66JorKYr7UxdmF0sdYqX2k4cPISdoNkr/T0vsfPqjdrNgRpAw70tZjuNfD2A8swD2JGcC4u6OyEZAAAlhuEKnYpHmQsJF2wsnDU98dci4fa5tsrK1jcX/EN7BeUa3VULVRV66EZhATXfROGPMufZOcJWcnCvxS8/auhdaONwiECmKXIKJAShoMpmadTpCAAAECPevoyeX6+tJdK5DGqLfVcsbkgBMQ2PvMjjRohICkrq7PbXrAi4eYm8KJBRgQjfH5KPYuN47y7raxbsIkGscf4qniCPZa0Qf1pw93XlxDXrnsniudR6JzNOWcfSWJJfcRocEhzuvDTx80X6OXg9Uaazo+qN1oqtM+O+3Pcup0O3roP4UpvVyG4aDtIdF8s1N2Bkw89b1kj3KWrWu5DoJhdroLKOa4z6QJ54X+ntV0OfekDkOZLtJpLkqfDN+L5Fcoly7Yog9GJDAsLxvEijiqOt5oOl7rX9z+hb/72VlVZ92GUjERO39ItPjVb34jFSLd3T5oMCK6a2ZY+ze//tq7xvwSuLegTrdlEpXhwQPC6I3KhZyK2Vj1Skl5XJ0CzqMj8VOVkn71i9dm/gX9KWzJRIsJGrKlmZ50xeEQ2HtfW09t1Yn3+qv/GpmdvEM7/U9+eqZv50D1QX+MTtnECQvcQ4rDf7021n94/ilozbZbtQol9eYbLdI8zzXCEDUZzvXxw71Wy5ydYSDdgVpAgnJ0FYXOkVKRCnngNfw3FxqMgPuZQiChVNy0uhlazXVz99H/3ZtfPFc+lVK1UTYjHCis2mz6vdnYXCT8tM8b+uWznB4eB5ZicdjWbwc6Hmtu/EKgLuHEGQv5J+MQo8Z3xciDyQJdNk42NB1BThSITOydQlgvIb1h6s5jZZhhrzkNMgL0myeZS9APE3oxc9wZ1oeEMKRI6fCZwvvCxMZeDUNtGMaYyUu5uGCdXixs75jQSbkhaxL9LAkbUrGCmw8+yTC1p8HsHeJVGncoVhKQebYajYZmTrNbJBYq3N3T9AVDFe9W3Jp2QUbHd+O+49CVzrFmCXs5u5yhFS7A6kQzSUTZKqyJWBdBcPRvTbth4L0zm5XDlHu6T/z+I71h0gSkhTB2qBw0m9I4rFQsVHyWzHIzp+UAzx7F9M79OCiTSlwYaezR7jroPDl4f22ThyVxgOhjc9oPR0qAgnE7Qu9oQ9uQ+sU0npx2jXR0EJ+Y/iikm+nG6BVNeZSOHdgcLDwDacwwcIbmDlkMsWlhnzvfLhSPgGQTFfLYE7J6A5E52tAGcxV28+yyu90zdbstcwr+Pj9/70KJ/Rkmw4zevHw2Lz7l5XGgMe7ulkc93Y806s/Uf5iqf5i606+Wi9bI3H76pBjGFQG5tabDZHfrveaEaRYzthOajmaeNFkum8q+WyqTytqVZwvRg3E7C9X3cKKyo7ML6e8UwCyxM6mM3RnApdFjEnuD+wv7CPYPV88u7Qd4xHwgAnrah87x5CjDLx4sQwfsKLwXySifY7lfMLRgaDVT0rA/19PDTJ/eozc75SZit7aFon3U99/eGO+vVhrueJID3rJBoItpAodZgJJgACa6fnZutw9r2aKj1puFJ0qcTnhJmerYiTFV4QwClFNvVGw8sMcabAM8glRm4ey+YmlsIXrpmFeCiloImiN1OjWNh3Nb75GCQFcKQsBDb+3oYKFepeHPiFMP3Wu5VtWr169MKgGW3e2Dfyb/xWq71cBsW2B5dJQVR2Bl8ln7WNLxAssxORK6nVbWLhywqGvViqE/NKeYgpNBxyFFVw80w3sOmWQ1wyh/aS9IvwT4PXI/5guz4ewzupyqSSTZ3zFFZ0KvvHihDQ4vB+DdpX58/9Ev71dvv/aUTt4eTQ55fxzEWKodDxuV0ZYWstbLMQnAlWIS2G9W2qWPurxoGvaCaUuKPf/t7e2Dfv/dT96PkHpCCku1AZEBCdQOtoEORGlhqZVE+k/y/0J//d3f+oD/za9+oWa75meh2ihqsZi6y+ee2I+USSUXfDbZiXmv3Vta4M3zDhmqXqM5JS4s8eSP21LYDYaGh10s0zXXEFIZv/jn7H8gp9zefvJ0xIEHZAhJiSnqvN1Su9vyhPXqzSv99NNH7Xh3S8WfYe4omyhbTClJ7fXw9KjZnGzKnKr1gvd/Ubwye56pljOE/SjXzObe1l0HI3UjJ+uFiRhMB7lDRrsjq4yQ0WqJ2XpjuRTsddYcHKxQ6nH+ImYPTSewm/MZbW+X9WfNEtU2W2m+Xiu1SalQhpwXJBGwbnHOoaBT7NYHZGSJ9/uNekmrh0eNhqAukRrNpo5HUKG9avWFV068sxDROMyZxHhfe72hGy4kEzSsTg8iDm33eZIKEKmNNRxMH6RryzjlZzqplD1B8+dBrHPqkc3w2XfC8CQkPti/cU85f9JJ3g0AZDuayOAPjun8wWJ75FCgHlxMIFxkdZiWf3j/zukeFHCeBWDtAs1iERJcVtEx6LjjejHIUuJIy+Wjzw0ztctFZfagjwF92+yCeoFr0igHyQ8OStEmuLYBuxN+gB6YCMK9o82O5gjwjWBJEwxhmB4NdyBJ/7ybZGCjkQAVABGBfMdzj04UO0sgZHak7CZpPtqddiBnXnWdtbvdz75soeQm9PqDEA1URBTOkik2W2k6XqhWbWsLpLHCKq2sWjVto2m0hNs0+h0W7msXNUhBvoE5nGgYEMGuSa+4MWx4ec2XuVaUROoTPLzaK8NiHSZTPhiAx7mcJ8nxdKJ8qWLIL4sdVjGwKLlguOln0e9VIKNgUp1SCpsrdoqkrEGBxmECIsCCiYjOFSPslV88Dm0XTvw5c/ngzmOJC8zSlJ56Q737/k7ff3Ovp1vSKCgeFEpiuUKK92qGA8lSjToEFA6w0OkA79G9Q9YBAoC5B7P1In2hXK7rm89DQHYiCRJBV3pwAWWaXM6XajebijPsUtERpTSZIT0YKu1JGD0mhA5CcYdarnKWbOCqAiRBcb24ZJ+3+dkRhJthDRrOSJu9JoeppyqTJyhWThDHBq9pmBUT9xlF6hR0S04p3fjuiIVW8I2kyXBMGYc0sVsRO7Cim5/VOqvZkWdieYKOJjo/v3ITBfRmiI3AXyyq8sB5Yc9EKs1w+GBmH9AyU/tqOVYqwoPWOOnJmDr8/PDjD3odbfyi45tqks4+0of3d5qM16rV6ycyCbucuZuOs3ZTxWzJUWQw7WBbspemLXTUELszPkucaDmb6WhSQ5h4v/3uJ33/7Scdj2n99MOjHp+e9I/+na8M11kriWE8BuDHyMkkv//9d2Yf/uY3v9Hl5YUNrnmOQsT8CZIFXTkRr5hEwr68oPNztICP2mwebDrNM1rIy6Spzhn6TCAr2Iyw/MIkwAFDIeQ94R2gqHgnx+G83Kg/GJiUVSzH6vd7nmwIKa+1yjrGgYjz7NVzm4BHsK8zuZ9DsuutogrpRBVkXWcUq6luPt2o2+V5qyqd3oU981Fhv7aCZc7UmPZEw4cLqRnYVSa2EHQcW5o9HRwDj0fK2Rw/ZxmD0ySqyAKChhLWJVMd8DhNbTGKLTSnmaHJOTtvq9mJNHHjBdKxPcHQFJOUCrmSfVmZPmhq/W6kMO4IzGZHx8HLQOgeS51OS7VyRf3Hvq02IYBNCRY/afQwls+e9sLwIIBjKe5JfHRU2nA8V55nC9vHhHsTDPkXi8Ts3y3uW34WgjSD3SeNCPaJ5+dnZuk+PPX8vjg95UQkXK+WysFZIITAhKfgrsWzbhN3E4Nwd1pbC97vj73fzOVLSiIkKBi94zIWXMusdzXbfvtzNBYDCu84rHPWLJjl4/gF9G1rQZjj7P4h69B8sk/ebgOLtVwyOc6OZehC0TwmENnyHmiA73c4+oAe4LqGaxHEqAxn5tH/zWSPSQds81wwSFlhAbhVqlmxIQST62iCFWTIBe10mjbKx40rihP73n7RQonNEbo9oCLYiUCoRBp9/+1Ha6ZePH+ldJQ1s4gHC2gN8+3lNHFn1mqWbL5Nh8UhyG4+PrKYzypKl1QoR1rNZvrx2x913K3VqeFbWVf6OFNvNHAEUz4l5dDSxHvj07zopH4f44ymFDASsQtoZrCb2phWrFRJ1TrQXqwcf0BYOHla5M/gZQfOiRR2Sw6nZQ/Gw4zxtyn5QTzMy3NM0o7lwpLux+8+6NvfvdfD7UzrxdEPFjeGeT8c1GktplsnqwAbW6qSDdFWTFF0hRRB3IsWHN5JYoH3dPqNH0C6LCZAxO+NBtTolBlcpWLQfzZqDdUbZzo/u1DMQ0HO4mRhNh7EE7q9UlzQbnXQPkvHyoMEQYXE97TT0VuYkeMre0xpMgbK2ZhyvV7hfrNXOpU4z3E8Gv1s6s0LU6sWzHykMGxtoSVNpiMlsPQqeaWysVLAcru9CwnfsVZjz4HRAHq3rI6HqnCc4zBYLseq1TDLx5UIKv9A60WgllOgmbortaqbGa7bcEByzd5emezNMLZn0oScxZ+Ny9Lnn4e7BxUiotiug/UXBgPTqTtmDK9XTz0/szRENDm7w1JvXl+q0e7quM14stknJKCwezxqvT2qkqqoXINABcuSpJO0g8aBdnuPU202wTCD5/bDh41ev2XXFOzsLBU64vkqjftjR59dnJ/p17/6Wq1O3YkrQE4Y3tPc0Z3DmvZ7A6KDSDwC0cj6+zjLb7Uxq7ffG9mYm3v06z96rWabAoDRAx0//IK0mz1b+TGVB+cwN4tcMfSk1rQViZZDG5s4w7HVhunOpLjVIT6o1qnol7WvvI+fzTM/F8pKJad26ahq5ZVDl9/9+FFr0J3tSuv5QrVGPlifWascpn6+AysdJF/sKPOZoLXs93ounmuszwp4GQP1I00hFor1SIAPP+/nsX9kb4xkxKb9Tl2hmBN6vPFUUa5UVWs2VckVbcM5HE/s4cv1otkGiubdZLfJ6oMA+UJMswdpLjBCuS6tVkPbDe/n0YXSFm/FWIPHkeaTpdbThSIydoF/OfxPZDuatSQd9p7s4iqVohr1inLFqq8lzS7OPmgADRuvltYbhyDyMHmzjqLg2F0pA7GopuFkesq6JYIK7eDREPlhR8QfZ1dRJYK+8bM9FH2Ww6fAFH5FYV8u9MD13uKUNQ+Im3FuGjSm/6PWEIvwpnWBx3wF8/ogF8lkkAUezGLlWizqFS1mZeVXO80XaxWYKkHSUA1gFF8n1xirwZXNRfiONMAUe0zcOf9yoCJIdZCJHWlQIKejpjgYLbN9HwS4GNSh4vUJyBNLUcLkt+uD2bZMqsDE+WrBjmZRih3pTscobWnQFy2UWH5NJwu9++mDO6bz1oUGj3P91b/8zsHD6zEwWE6T+cJ7nkwayylYCQeVy1ldXCBwhZ47NtPOiSOiUCJIZpROtEOcHEG7Omramyq1TevxbqSPHx+9iC5lItXoSrKR91R8JuQo7+4e7ATDFIbtFzuAxyfYmUvlHznYzvTm7aXZTmjzYm5CnsV/TvPl0g42eW42adqn7hG7WFPQvX85GpYynLU7ajaaa/A41XK613ELbTqD5twuQj5s2WWyV+BBA0HH8xaLrUNW2TLaobInSbpGT+aWaeTsErLZDNydOanebhwpVStVM82A4XhxWPtzgDDlkvkIaWE0gH1H2n3WxZCOnf+eF5WfwHYMRg4ctJB4IDY0amXv1fBBPWt1zJJFEjJPLS3HAeZGDmGm4GJiQwLcUYDNWs2W6rWOX34nxy/Rwj5pvmY3SoBvRk+9vqazoWrVoiplkt5zvpcpktIbMNaYyiDQ5HR11VK9WXdkV2aUUQYZkE2XySRd6vLqzPKX0ZCd104bXoIDSTBFVcvsimAO4uVZUJz84dFmT4GPa7ve9m6CYtof9NTv970bIdCXRtC6PvxADyvLZM66bR8My/nERdUMQiZL73EphMB1EDqCXyXPDdo9Dhj2SUQwwawrlmtmSXrKoVgJDeFO29VMw0FfzUZN/+Af/LHp6iTMZ/KxhfIUWnfPdhIJk1MwGg++rcCBhG7zTGPHBYmOPQyd8t/+7geTo47RuYqlKDSqmED3p3bPQWu8OC5NvHIElHXSO43GEzcnDdJBCgU9f3GhNGG3VUg16DoTwZCji88WczrO5oo3f+jKgSSRZhExxWF4cd7y/WOiZY0RRUWTK6JMYPWa6c3ziSNFDFQ8d/NFIDE6xmw5mJI4HWdHXwTbnN0YKMjWN5eUm3y2qHSKaQP5QGDBuyGIQoPPOcOBSuHjr4JURFH2X5uG2bmyPR1NGNrwQ9IKpgbw/w4YAwSIuQy8h2MMRB12nDCU48BYLVViDXtMmnvfR6ZO3u/1liSThV6+eOb3emO0aReMxDchl5dpslJhFxdrMuprvArGLEDtTEv5NEMIxB8mjLR16BTNiR22sPnMK8UzhS9rEhrxI4YKaHULWVXKBad94LOaLma02YPqleyPfMSkgS/K1GYod+cQAsZlB0dnNj5rOJeYwnl3m5OqZrWld4GoA9LptTkaCTGE+Zwuz1qefIE9z+p1ZWNyNZk+gxyIIo6e2pKtbM6JRwtzO6Qsn8tNAGdGyecwyAPNRcYesxutF/gX4zaGnn1nbTMTfj1TtMQEFjIGEaCSNNTAsM1WRY0WeaKQhSAFBTLoFy2Uy/FOP/z+gx3567WG1quUbj70dfOhp+1ip8e7oaNnwOntt0p3t1yJXW0dfL9Kd5U1Br2YbD15sLtg78nLx64uEuJTHB6q2q8Sve/d6JvffqsndFy7rRrlvP70N7+2WN3T21p6vLvX+9t7bXZQwaH2+2j0ZAVlfKq1CkXp7dfXnhL5RZHkLTkQOYNzjeGkYNRN8DTdDFZmn/cmwGr4yM6xsZof1O9NNe4v4JfponutfG7hJHQ6HPB/om3YGdlyCeiiEPsQzOa4Luii6pZqIPq1xZU1RQM99UJMGPDqHHeahOkDk+OlTRc4IDkk+J4QIerVM0+s3333nWajmQsbUBEvrV1vMrFDpkMUFV65B+XMEgmwJh0lVnp0VUwk7JAyhMQu2U+sfEgUvLuKNRz23YnVYLwV8IqFXLNVo1Nyh89EcHnZsCzl/unJ4bZMtECWOGecddrqdIJucjINQcNM6AjXYakCf5bKWfuswgTGCYczYdgfqT8k+WKhl6/OzUo+JhicH7TKAHHvVTGMXfJkC7xkSG7zh0eb/Ug8ZQcz1Vn3TJXqmZ696HqfBPRJbwSsCpLAHm+1BPo6aDKfKV2vq1CGil8/ubGwY8NAAoIbBSLAemSHsguHdezcyDQw18ppOhRcGIY0Tm5cEswb6IhHPqifd85tf8jhitQEmN1hxpZipRQdkXeQQhKmKpyXEJJjPMGOmneGgtwfPJjZTCOWincaPA1UKcV6+fpShULTa5D9lgLCQc7hziCccXOFpyhGHsDo9sM8PrpYdbsNE86KJWQngcTC30dsFg8uu8v89g8wN8S4VBrWI9Mf+aKIuhueCsw72K48KTsUgZbW1mkWefqZpJBw2CM7MeMdFyGmaFYpqVgV/3dBGkKBYZfNgclkUiqGptX4EPu0KGWdLQ5YaDmxIQzMWT461wApVVbzRcppPY1m1UUJD2YQKFYOFDSaB/JS+fvZQ+cL5KdiAILGGYQFadxGmw2m3UXzF7zvxDzAzQDI1NEHOvfUcVboMWGmEiWXSZstCrGkUavo6qLrqYnpiP/F0GAOgxNnITN3YYBvFO9iX4ew5w12ocEMhPVXRiXeK3J/MUJpVpVidQIis1lrPJ+Y3FgsnRjLcWQv3rlNVXgPoGyHoPvsPhgiwOKmQQetgm/B0ENqCe8bbF48o3k3aD7hdHTbbVtvzuZzTbFAdOOAayHnb0j0cCizd/dYF4Oc+ObYRtGSs0bdMXhkjdLok1NMfB/3POhfArmH/wPSWlLBwS3j68q5xn3kHGLl1MRqtduxAQZnFqsozAq+aKGcDWG2YoDeUi5V1cOnsb7/3Y3m450vEI5ReFTWSlUXjOGgp+iw05uXV7ro0l1sFe0T5VIhPBi1oQXkjYbifEr1eskPDzRmAoa5kqvZXAfcSQ47e7oSy1VvtNyFo4saThf67t0nLdZALFxEWLHbU1YZU1rowP1FcelHzEsYcyanDSzWA4dqRgXyJ802xHUnOMqbWcd/g3XVdm/69/ufbjWfgIEnGg8WWi2YCqBBHw378N+wO8oRMBzng5dmmuzHtoWzIcgWajZ7SyCvo4r4MGYg5xxCsZ1PrCW0Nsu0eZkVuNk8N1trf2AXhii8ZSbtd9980G//6ht3ilzX66tLx1px6FIQPW0Q1szDaR5ECGVFw8gEnS9QdCtaFRM/WPsZKQ7k/QWYZ7mZu7hVanldvWyre9Xx4TBbTPz7OJBJ7sCWb5/APMZ388pwC4f69fWFd6jkOOayuC1tfcDBkuN5wQyCZBmMImAHfrx51CGB3n1mZIBwV3ZZrdYpeSQbqdVpGoLdlMndSyudCxKclEo/54ZyYHz+gUWL1pOiD8mJ3QmJMa1O1Xs8vDt5gf3MrYlEKnjH+vHTvfpPI8ub7D9JakaloTjLQYid3NrgH9N2vOc5g8WXU7NdZ7Oq9SbW8xfnevP6haE9mg8gThAB4CcIO69ePbPw3ZquDAcdRQZyGd6cTCzoy1I2iecrcSBxwBBtNMnCMibcmYDrlPM9eeYw+VeCFdzAB3C13FIurur97YP3UcBVsByReGFfOJoAAaKH7ajd2qqXDFzoWFWQzco74oYyFeKymNppgDjMchRwU/zDT6VWUbka9ug5J/WEid7oCnIOXKPi4LPJIcd+EtBly3e2ng7UBpN/CiW2ZkEXR3VjymBPa8ea096K691qtXWohtSN6MCeOBhx0/hkQG6SQwgs5z3bEa8WMjxNfEk2qjWKaudg21eDSw4N9Y5mjHcgMhTMfheSIEx3GlWbG7hJ2YWA7QyaUYhmWR1rEE/21iTO0YUWc/5s5GOyI4MDMB2TqkTaSEq72Vp7w6R7i/HPmoQyg8wl6rRb3msup/Ow1jEZKxS3ENMGkQUYNxB9TMo67bI7rZplX9UiMjes62KHToyWI7/f5ALDwQCJCQYkYb+J5SWIFBBqMCVfazGPFWFUgVtSCflMcHjCt5jCH8wB6prM0CyC7sF+zytXKCrOZH1W4WrGMw3Uzp6T7we7lft7eR6C2g8nWYnfXxud89DLZyjnNtr743Tis4Eax7lJkx7cd7BqDCxdM+gPIW0FxGufcJ8Ipq74zAHmxzSEZ+mLFsq/+Od/Y0jp6rKl6XCj73//Uf2HsVLHrC2scMwBNaWjnY0GOh7W9oa8vOz4gDxsYcse7RnYbgaHEXIDcxls2gjMJU81ozRMOHsVplQt5nXRaWi54qBs6e3rl9YyYlCczZe0wy+UeCnFhk3iZfizsphiZyhGKZXKdMUd26vBIMVijYsTYQmVSylbYH9Brt/SfpDg+xySZM9ZJgL7dXPUw8NQd7cs6zOqVzvalzKaT/pmS6Kj4yAEkoQ0VK9X1G5VfbBSsNGi8RJNJiy/T5qf7dIQESbQZ92LYMd12Gs2nXkfxSEUiCsZwzbg+J1OxaJ45/KlguXe7d2tA7E3y43lMNVKWc+uz3V+0VYNh6B0YMi5X4hZhge/RH7xANmyKk+HzE4DX9S0HYMeend+6Wkcqs2Wrq4vncXI9eLQbBwLPtRn04lhLqQVkwnhrAtTzBkSmIloFCBFYJa+WqJLw6wYGn0oGPxi6X5Y4ftKYsDeS/rpJOh2n54e/Jk4gOkmgT3NdMyR77m0HWAxnVM6C1kgbzjNmaXTPxzeTCwUYyBX9qyjYV/NTsYOQfh7vspfWO6DdrMZNXzYcM14oelk7+77ttfrdtt6Vj73bhDWJGbZ7HbZa2WyQRpAh/6seG6I5/mrri4vu55UIAnZ/9jmzRwEHHI0DQWjKch4uN+Q46DWYxwfXBlI1Ni5MO7xR2bHCQQRYjoNRxm6Lmf11dtr3d48aNC/DdKHTKRyoWzi0mgwd5oMkyxIQTa7dH4sExAwXaGIRjelerOtRqvtQwjTApoGmpv1Yhk+O1MGaR4WddN5BULQ5x+mBg5WCDIckjBx2dEh++AXpBI6fA5EYDfs8RaQwoBwBYEHE+0gDwh7smC4wF9RrTb85/Lc8Vf7/iOAP4Ufm6C0pRCHVBgaXpOeIJTZH3rjponYKf48J18cKGqkAWGF92RGMNAzBXS1CMU7+NQiHWOK5H3BECGnciHvSDJsN3mXOM+Wx63ycU5FArOVtisOpEDDuCdGK8YIZG1SXJpNIPmlrSRpuJysssfGMWWdIRpKClD++koP9w/BXJ1pEshwHZx3THSBwIQsI5cP6NF6HdYlS0Lc9zrsIOJw3VmFFVRqFD05Z2ISgEB/iEGDSAV/gIwx3hsm7aA+mDExpmpqtevqtOpGLZjs8U1lF8wEyZnNu8v5jRQslc7qOOdsJCB55rON784EmY/SGo2JzoKZX3GTArrBc8EZAgOf1chkOrbawAzbDITE0Cjwd9BYoG8l83Rz2JlBD0rEtB1sPplODyrYozvlxBF00kDLFPflembNvfTHX65Q/vYvf69f/vI3eGPo9uN7hyDjjEOHwbSH4wMdHxU9m07p4qypi25bjRo2QrARA6sLKCVKYfEVtFrr5UoH6IPHxOOwIRmLUzeKc3Kwbr1ZULPVUamSU3/4FPZE27Ueh31NZoQKo3Xa2uyZHRrTE0Xq4qKjF6+uLCpHg2N92D4yGzbk8zERhNDX4Nwf9Fe8GBb+RmFZTUvswNzVzjeaG4/zBNoiXgA6ytUmSBMKpYphw9dvrv0Z6GjQgj3ePGm9mrkwbHi43T3tNe4/qlQpmSHJJE4HhZcp+1egmFSKFyBAPUc7hDCNsJ9FED3zvg7HDjpxujamRDQMQMUEyrIXQJ4CSy7ORRZfM8mwp3Rm6OGoXEH2PV1tFypVWe4vUQhrtV+o0zzX21+9tEQEw3sIjg7WXWP4EKuispsJrv/d3aO1aJVyLUSdkVaxmiiTW3pPAnOVTnC35dDdhwQUkschShSg/od9nK3HErIyyffcqtNt6MWL5zo/7xh6ApYjJaH/NPB0cnnZVqYMTX9jogPdJMy7zz8F9qoRnXbK0XD8fUC3TkE/BpeYYqFs+QY7aH44kMj+JEVjNpk5ixDCQ76aV3GT1w8/vLczEi8vh5PZpASY59JqtGp69orYOArF9mS6v/a+BTRgNBkGrWy96uYKuBcT/dU649xDYsosPoeVxw4bI4uwAvVERfMB4sD0XCjD5Gv4PYLfkiQNbVcYlpdVrlQsd4EENBiQhYroPucCwvuAGcD93chZqjzrTEzA2C9eXmpH6v2MxItJSK9I9sHoG97vKZILKNeZin/nGIFNuS/u3BSwS8KKDjIRE5c7e4dNH3SEHZ/NqVlv6pAnMzZnBuLj45OLGv8NBcLa3yVevgctN3ge7/xM8OzSuGMHl8oHyNGMYDS92eBlC9RJo0FzwQWkuEKOgsxHs2k/6YgzDIgxmC8w+YEiQdShABQd0cYUj0Vc8GoGDcC/GHMLG3fbKID9bFrNJqHg7Lu3QQecJyA75caHz47jDqYOFGQ+OwYbsEUpzpajoRGOY7VAjLBu5B3oD/3egCpU603v68ajsRuJHWHcJGUgmcggq4u0WPL9EvWHIzdb60pRrVpF9UrwFbYSoFY8ffbEzVpwuKGJCueg/0A7GbEfD7aDnz2Ckcjx/MDmXWNplwqwspOGovika9xrPp1rudupPxppNBiaJFgsFHV9ceXcYT53cMVIuTgeT/83aygIbLwjIA8LDwVjnXU6thxtt9pubriWtillr5khgSoXUJJk7zUaayhQRQYizvdauRziApne0ccuNjan+Pv8/L0LJfBPPpPXqDfSw6c77QlPjdFe79WolNWsld2xYEB+2e2YtEHMEsxKxk0ODDpP69+QYNjlI+D+OMEgd8AuzDoc6PeG6Q6qNOp6U3muxXqnT3ePTu4uVCoaz3Cj2PjBTx+ky0ZTTTrkCh1L0fs2J743qj5URuOhu6/Fmkm25JGdX1E6yC4mi5mnk+551wd4JltwdJKh1x05jOiJij40gGUYn+nGIV2Y8h+l7ceKDV+jGeLGqo2CnfB9eByDVywPQj4DhLrTcNI3aSikRwBXwLJLG+eHDEMnNJ8PzBYFKgGaI5oGDSPXxplrdEmnwl6rtwxhPtz3dX//aKs1IBemwkI1q3q7rFT6zNIUNFZ0uPvlyo5K7InjLLDawf/7D/7hHznMOA9MnE203sFMQ68VUsr5MyiEi9Rajw99fRpCuIL2XtJmSQHa/2wJRsC3vW/DuGf/XaYJDn9r53xdmEY47ILBOvtTOsX1iqU9WZF1d73szwiJvrm502ax1vPnl375mDKBpiAbM+F+ZlTyU69V1IhijWdzU+Zr+WDBBUSIxIWA4gxQeTanfv9RHz589HSMSJnCBZHLcND0oN99+539fyfzldZovvCExZFktrRWkJ1dpRKCjQkIXiDzEEQ3DAxg7aHJxB/54AQFmH7AXqAGMDTZ1bLj4Zqg32NfRxHhEGb/7bPlxBY0w09HPbu+ULvV1If3Nz5cas+anppskp1FwE9e4jikzqfwDUa/W9FkPNNf/MVfO4wg5HHW9fLVpYp5pr6dFquxCWQ4PPHv0ymyQCM3SByeto7DOH/1dyLNgNPTFGPiolZuXu2qhIaP5B8kPqwBOPjXCOBpltmp5TVbTW1Sn0ezW2Figc26d4PNswGZLP55D8dOjr0tlnXApEh2EMFjC7d348o0SkMKC/xzVJUj3TZhtYFUyDaB/E1krGKZyZAMIuXdcMZNMNMukHWhFDShNjY4YsW4D/twP2tHbb1WKBhlviqc+z2n+f/x+3c+26x7RgJiLDpy4/LtzY/mB0AWohEBhrflZxTZk7Z39+QGgPOHhowJk39OU315WVV0CIQy3n/ScYopuBYQ/+a2C6SgcO0MhebwVcVgJVyPkO3Id8rbjg4jlP1+bJs3nknr5WkmUzjkBKnK0MHjZa+3puOJjnsmuTwxrqfw9JI7Ov/+xULvH+5dsNmj4lucWSxs2ELKCSYL7G4ZDmgs+G9tVwjRhxWK+R577a1xpYYEFyaeU+wtuTdMqgREM5Swf4SwA+/C0DIEKSIJ8Qs+HIza8b/8ObwHWKJyPn3RQsmkBwNzNh05F7JSzmk2HKpZy+vr19fOhORQZurg4ga4IbJVFDse6OYkCkRgyZgbs9PDLf+IYcDG2iqIKhQKJino3DCXglchnqAwCFNK5/NKILZobU9XtDgA6njP1glkhcKcD+HDpG70nzgcbDRn7PzhsecDvN5s6frFtbWGk2lfcVTSMYEwE6J1XBC3iR/m+7u+YQnrL3e8vCvlC0x7aXfvJCIA1/IdYSIWyjnBKUilQ3LKcQVRgr1OiAniNen1HrU+rvTy7QvvCQfDvrI5MgH5rAT7spPgzww7RIodhwE7BWAPYEI+Iy8Wh+sBMlycNZyxxZ8yFUgtaDXz61gLYLv0zsW72iz6uvNdKM6QUGaLqeE3rs1ihYEzTE1+31IiQ1JAuEvNIUeQrODkD+jYiJhjcQazw8aJib0O7Ud4QUmO2WuWzGz6sM9FbjDYnbIzIhSXgg10elyQZkInv1OR7NPV3CSu5WJhiIdJginyp/fv/f8nNsoEEwcdY8+1Vvfq3AdkYfIHJibPJQ3BZg37Us5VZSqyfEgYfDc9gVOgzVamdUq2Wu8Jug6TgkNisfDarZ2riq1f4oImM/qYdNmDkrQemgSaA2AeCDSwPQtme5KuUSpldXHWdeA4U8lee11dPTP7mp0b0xS7UnpzE0ZIDkkg0EACWge2bhxkCcFtZ+e/N5t96YOlkEUiE/R+XOfdnrUC78/axS2TrRp2e3wcajxZaTReKRMfNJ3wvyldXXTU6VZNoiGQAO/icqHiNJnbT3e+bhQzNxsYfBz+cIwkiL2na++7YUtTRGiMMQih4XRPBLKXznn6+/7uRsPe4ERUg92aN0TLIcizyUqEpjswjPF/zun8/MJ7fFj4NBEMQFuvEniWkEcAle4NzymN3WA+TMFmoQc5yWcmrIs4E+4BfbQCLMdzAfOcnSYIBAYAJuFsNBhwfvCu1b1rZ3IL5JlYEcxcF2icYdDZxnr2/Mpw77uf3lnnyZTG+oDAgg+fPtk2kc/FY2d0p1hSrVIzAYb98mA88dqFvWY9l1d/NtfsBG3OV5iPYNfYtB6RAgM50k0ShwkSk0OITmPKnTPxPfV0+bJhZAs00AkpmbQuumcqFTFth9ewU0zxTraWT6XgaSPpYpreH/z8bYoFIxy28UzRxFd87YHMWSmNp3PdPjzpaTi2Y9AO83bIjYRvzybaR0eHYFDgIRltyIKNpPmKhCCaw+BbCzzNdAnxkpUQ7ky1+shrFJjeFM3yHi/so7qdtp49O9P9460OeByjFijiUT0PEitYvJDk/FzSKCCl+8I6yl//+peqkG+4WfsAiJK12o2CfvHVG111z72T4i/nwsKcZIlOYeXUYvdHMGutWbEVXDq/VsbLa2AU4IatKb08UF6UW9C6+pkBmMKZKkkrnUYIm9E33/6gxx4HDqytvDrNhtliHMimy69jjacDU5F5iJgg2d/d3D7aWmu53Or8EsFu3YJ+Dh9OUDqbu+3QTh2lMkcky+Csd4y1atPd9HYd0tmZgIHkxjBy8aLMQpNG/4Pwlnw/XkTgZl5iblLKzjakzWNQTip97SxvUTaEiUa7osaoolS8dCg2HSY5d1V8J/P4N4YwagqgWZGZ2KwwCE5KspqNV0ZLkAc4wZ59kslKBTNsLTYwOzJIWCgE9mQ8QsmfebfMxAOdnQOYibfXf9T5RTOwMVMQVdjPcHBnQ1eWsMSHmJXVHj/JZYBrgTzo8DjA2PMtoKwjIYhgm1VMS8ekGLkCMDBNAPKY0bCnDabjWTrciuH6yahn+Iw91tN9T9/87vfe70CHr142nE5Pw0KCOx2o90ArSDN/MDsmTie9S9mNA80ZkV2lEg3RwR0/hgtPjwM3OnTLb9+81np7ocZ93Qcfgb4hWxDkgEzCYMBP9ws0FTIB2U8H+Jd7gwE2RdfGzbmiOCMhJfHvaTKdTIFMwkSEvNcCno5mS6VgebLfBfqCDm+iGAUbo32Yl8Dn4T6CMtCUunkrZnR53dXwcaHJFJkKqMla1XpJ3Yumqk3kVFk1mh01Gme6ux+Y6ZhJFz25giyMBkDaI5ufdzuXengI2aie9Fcr3X6814jIrig245QTftTEK/O5rzVs9aQYUBLkNvsUjFDY5vip8kzEmm9W+nj3Ub//9gf1n55ssg/E/ObNC/1bf/YnLsIUVnay6CS5T3zv447nOSRb4JtaKFTtU8yevF5vnuLtEr8rGPPnFgEahgWJVpi8TXa0HNaf7c/YobImqNWaLtSD4dCfl3tCAxZisYrBsYmIvA2OWwfDtiA6HOTslDm0gcJxD3PgOukVpZrKxYr3eqtV280+ayHykqfLqSMH8SplWueZfhwMlCDHSGc1GIz06e7eZDbOw1o9oyyT8m6phcPUScXYutAwZfGLAgMyQTGzoQqZrodt0C/CcI4jrTawYdkNk/K01WR07wEE44PoOLc6AaYwjcZ8RQhzaBJpLMrlunfKIKRInyiwoBNOiCIGkZCFyVTrGSL/ifqjsR12nIdhVrPbFHYrms7n3oVjXAKkPRmN1Z+MDcenySOGUHUyJmB1BTRM4hMNBO8DqxpqCygLFqGYSHBehuQRmudgYg/0yjrkCbvP9dqkIKdALQOM7HPsSxbKRqWg5WLmFI5GpahaPqNyPqNmtehgZKA87gbBVwcF9wcSForFsh4eeBmetDrAAMvq/KJlWQCdKiYEvChxxPQVFjEcvIXT8p/umu++XOIjmOhx1NfHTziRoKGyUlqHckW5OGtoeAGFnl2Gggk6RZDorMF4qsFwqin+muu9Pnx40GK1t2i8YQu4smYsppNdII5kgUoST2z1ekPpQtZar0KXNPij+k89v4Dk8yF0n4wnNo8mJLXeQARctJH8YgWki8MFj+4+OIEctirXSnr7ixd69vzCDisQPpZrEt4/Kr3c23auWESrFquM/KHBMhtW5tLOQDj7xzHRUzUddhkd9+wHQ2q8g3/zPNil4AsZsaQP+xf+l0MC0gOHMLvDMQ/+hFBmvEE55EKDw0teKVY9vfB2R9sgsOYOuQQgWt8lmo+Xmo3n9vtNmFyRD6xDFx7chBDHZ0waYELyriMDEw3oHpg9o9Fw5j0bRRG5DrT4armsi/ML3+flJJAEYBozwe7WBxdcxwZlMqrnSQYJDkJQ3NOZ+s/PLhD8dVNq4uuK+bxDwQOzmUJ2c3+jH398r2azpVevXqndrGuX5JUrBeIKkBhMScgiZlvGdLqxp1oCv6E3YpB9FCSMtNqtuifMyWRiGJBUlMB4hV0K7Ft1UdwyzcOEcyc9PO0OgbmYikKWKTsf/jmdMQ0K01E2/8oHAo0S8OExApXZefXB84fU5aF37wMba8h2vqJ6s6RmjNl7yAE9ai3IpDRhEF44lHhuMN0mjWTcn1kD2foFSFHOBukwMUuQ6IohsgjmN8zWbW4vVv38jJFOMZ3tMeBYmXQFu/HAO7yZ6+6ur/cfHvTh5tFesDSbkGwcibTlmcpYDxkE9elgJ2kDdDyS995lFXI7bVYHffr06CmVQ7M/GhrZgUiHATf3rVTFQQwbyJU/A1A19wNIkSJMSk6tzr0IyUecGPx+zh3rOinTCOUJu8ar1cEHEOH4pvCd0TtDggFCXpiNbAY8kwGFIU9Iw9DvYb2FBGJ7mlq3Lgad83Z4ZxK6oKymn250e/dg9AZjFpoLoNI9pife4y218sF+DOHGe3bxoB7IioK5PRMd+kz8CawT5VV2Bu7WpLOjsvr44c67P9y8RsOhn6Fm/cw7vquLMxduTDTGo4lWO3SegYADgQgNvc8A96Ep7RNs6Hing61cJl/UZDF0XB0FnvfRijSyROGBwBIytB1WL5bCLZb2vsbBK0qnVCuX1CxXNB2NTUYK2bcUbPgAYYfLtTlaIQFxExOBwERfzKaWJrJi2e3hQLDOwpRkq+F4ZntDOADj0dCIggMuvmShnA77IUomyuis2TLhJhcnytFZQc7I4+la02g20XA60WwNE5DuNaXbu0fdPQxME640gArLKpJVmEHjCoEDqnjsLsnMK7oK6wZh/CVmtPZ4qVZ7vftw44mOzoaOFgOCMtRvx66Em4ZoPJereKpNktgwBaxOrJQQuULGWe92duWgfJE0wcNxnM20WGy1O4SA5mCvVdL5xSZAcgkQdNEPKBDgZrVzDBSdGXedCZroLlhldDQMNXRxrTPy1zJ6t/yk5XaqUi2vyxev9Js/eqtsgcy7lYN/n7048yRaLlUt/0D3x9SAx6QX0oxtHPOntIWQAoEbSlnpDEYFxMaEwx/Yd39cKorRKNbUOquo0gjLbmNf4jAhpgYj7LKGAyzgKAZLVatp08otW4B27odwa4cP/7fsGjCHSOQl/WI6s9sKRA0iz1jJM3ED7zLN4dwBTGdhNZRurK+g0XOBDMfIhzMem3x2OniYjHTGvJyUZpxFppOQc0pQLFPcs2fP1KhjHj8PsAoOLMQcOebqD6boTPu8fFjPsX9loc/BGw5NmIg7H3S81RAG0A0etkc1YYOWOKgOOm4TH8JIJSBaoYvEsOHhoefJKZUmWSdv3SGaWXYnFFbv9uyWQsh1xQfMfE4BRTResGQISMsC8BJIRilkhNj4+8TddFwU9H9m8Ei1DPZcsBfLhqqZUr0ry6Z0XGIyn7IN5HRK3FpFzRZG8TCFYx2jnXfxOm5UrWbV7da1haJv3Se6XSKY9np6GBoOhbXu5wABVhqySsPGGMPlWLvV3ub4OBZ9/qHQ0XStl0+qNmDAzw0pct9Iivnxm3f68cOdQ7K5v8g5yoWqrs4v1W6e+xmjqIKEMM2k00F+BXEoGHvLfraj0UI3n3p2r2q1mpovenr99pkhZXZ6TEQwVCHdsTaiAbFnM8J5p92jFeXJCg5F08X8VPx4xI8nB6Tw39AcActT+HnH3NCcDCBMIsKP9YDBeuzJGNjz8yQ2mRIonfP6hEmHswvXqykOPGRuLhkr2BuXdXF5ocf7R7/3HDehUcCQJWMY2JaWy/CcUsyxhQtpG6B5WR1Zd+2D56r30VhZRqGoOJDceZb4buf0eNuzvjd4zu4dysy6FsiY9RVEMyY5dpwR8CioDcU72QXB3fGozRLC3c6uOKkDAr1gYI55AQWRnepmRXj2QZzODD18MZinIIiYb1DcbP25w8oS+L1oedvz8wsNSwU9PoZ7zD2iYNO0MdHz96YgsyH5Wq308PAgJXUVC2EgCPKwYCQBuoHufH8gdvEQzFFWC7+3GPF/0UIJfz51YIEeSP1cQB9C0IqJmtmSQh4Oabqh9XZjFhPwXzqLjijvjo1Jk+V4vQ7poaCcMcKjjQiwcEJveYC6aK95en9pvplruphoxd+fjZQ9BJgTs+piLvbSlsOTA50OjMxJY+J7tHsQKyAKELgsL4x5CPPs94p5T2RmHppvD1GFCxdpfUB0G+Axukxeah6MYR+d41bj4cyF0h8QqnuaQOUQR8OEQxwUE7JJGVGiXDlWswtscVC5WNbV1aV3k0wDMDChvXfPGyohFSBFHlJEseaXLU6FnSVOF95x7kPyAb6jTAM4drBPYPJj3whlmsMX2cH1i6ZevX6hRquqOEO6/AnO8vQSmMdoGs+7Z/YHBU7iAOZ7f/x45xcJCA8npXq9aMcVDhiINoZLHvue7rJpNGObU7EGImazkfYOCxmCY6uSjSf/EN0Ta4eZMYcgZBPgZk+X7MJxKeI5mWnwNHQTlQV2PxDN01WumFWZNI9sWnd3NyqUA+mI/M5UBOuROO/M3ymUtNeJPt6883TQOjs7aRnBhkMuIi8iUpDHxwdVqjilSCWkEQfckiiEaRf6QxLimtqdogqFS1WqOX9OGpl2k9DqetAVYv1Wr5l9CtTvEzg52AoQ2BAZTwFWM5A8vqpRwdMT0CHrB4cHezfpB8xwLlg25DNCBZDJrrcr09uZXkFieFvQlBaV0fPKuUbDvC3bKOqktLAjXq3mPpywU7y4bOof/aNfeyd5d/NgCQsNDppYCFeDPmzdmTbPzv3c8jfw/kNsGfbHOqwh6EiTeC5dh2s9m6y1KQU96YSMzw35hYGNvV2PNRkutJiuFMU5TylnrTM1Gk016nVPeJMRBQsjBZ4XpoGgnQWy5XrkChXNJit99+073d/2PHHvtn3likwsIaswRgJlVzDMPgg7p1EJRCTgc9YaMcYIUWBbctBCNjR8ai4BBD1WE4my+AyDlsXIXCg8qQANwg5Fq+mEilCQ0PmRw0sxZELHDAA5GzwN4D8Y5ew+y5VATuKwB/E6rPc2PKDZsZYWZT+McRph8CP2gxD23KDy9gYda0BEQmAAxQ7CGffG3stUT+tdj9rDeIfBjztOrqxKERJiZEmf948Zmjg0xuzT4R/EgoKGuoB3bjFDxgHrnr+f90X+bEzOlVJJS5yBIMpEKe9USefhfeG+gmDQMGIawOfnnjBsdJottZoNDcdE/WGJWSEPz2ESwOzLBRmd2EYCkYZAav5iVwYIgDS5R3b/hFhgSrHSYg4agTxmp3qh7OuAI9fZZVdN+1MjwcJvOvIKZunM1O2XLZR0xVDcFxA58iW/TNGRmKCNCxU3lo6HC8QHcQdQKjkeqt051yHJaMODnwl0ZE+ELOxZlO/SmgzHZiAeDyl3cQ5P5WHOZZSkdipUc8pjUYVv6iFRo1JVIZ1S6rDz/+I/yN6AIv3YG2gJ4QIaNpNMpaw1koB0xqxYCgR7fQ7adrdpyQSsQAyY87lqSOYAETv5cVKQEnD1KfAg7Cs5oQP4h8kXaJGHjR0rhzQPhJ1v/KzSgcpuNhfXTTWaJbOtChUCTYMA3VDllh0TLv3ACOHhYJq0xzci7XTKE7GT0CM0jOEwQhfa741NQ4ckQyQQ7C4mgVevLm0uj30akwofiL+Hl4gDj8M7pJ3gV1pUZYnVE8nwO/30wwcfnBQ7SDLEf/3m12/VrNW8D8MWiokDAkWcxMoRe3YI02HwiKS7ZI9aCQbEBDnbjQyCD1MxziPIIlZazmA+0mztVC6WVCqU3PEvZgvvgLGFA/FBIlTxddtZTvHnf3Hna/X69aWun3UVp5Hj0AAEd5KfCyXM3xiCF6bk3Dcs30KKxn7DZAa8XvdenD2V3X6AOJHgrEEXNjbj13ErI6I2cg8uSY16UY1a3mHYhQJQLXZ/W3/vXK6sNc9ImogtbLV4sStqNEqqlCsmznDo2Lc0pqli2luJus4LbbkQEV6YyUN6cqAwiQghq4h9pokjmD2wpzKhJaP5ZmE2X74UrAU5IBdTVglbT9pQ+dGxopd7/eZCL15caDx8pclopu+/fW/NJjsmIE8kKqlob4nVdrPyxAjsB2FkMBs5VHsUT34ulB8+3qqcHuniqqVWp6K0d31ZN0Q0PK12V9li8FvF4cuZkrtA4np67DkXttgnfL3kd6VYAZWqeBfObpKCORigaX7Szc2TCyOZsn/88hc2TaAN5NkGmqbB4cfPgjV65FAiqwEJC+8Ombl23+KCskqweD8Aht71HTeeaNhL+5+edKRBBnFKUDpJtpBDYOfG+cffz/PEsw5LlWeo2W74z+Qenl12lIfhmrlR/3Gk4z7WdEMubcYoFe8C55Pdk6xRgy0OdEviSEgyCp8zyKEo9gwn8Cz4viBrtM2Wc2RpSlhT1FUqlIP5CNfdBRpnIPTsTK1MY3hil5yyMxiO9UiztGBnHjTmEJRoKBgquBYU5+NyqWyxoN1sbhkH8C8rAu5vp9l2aLRJUAc0jXmbzFx0z/3nVIm8Omv7jGZ//MP3P7g5i7dbLSAorYJ/LfwIPHshTbpo2swd8t1pQGLgMiOc2gMcXzTLOMswhT1pLqeogbQMSHbr1VQqnVKv//RlC6VdJuZrhwanFnuN0wiENzo7q2ibjTWa4Rt5UB7XhlxOu6SgUrHsA48+AvimXSE4F+9SOtZE0/FcCSN0hCi4oimFNM2B33TKBzRq9jiH9VqX11cq1Wu6u3tQo97wjZ8N+kq2a5sVsCMCxhoMB7q/f7K5sA3TIa8QkVVBkpFYpI+/YaNVV/uspatn506A6A9hqx2dwcYESSHigEHGkM+W3YHNJjeGBwvZsiqVqkrFlB2J0AQiNYBYRPVhT8iNxA1itZgpW2CiLhgOxeEG2MQOMjEpEnznjCpV6NlU5aA/5B1wF4bcAbhytzJ7Eo3kEaux06RRKMZqtiA4nHvKJP7z4qJteUy5hDQE/WBspqoPj+3Ssg/vIZ0Lx/eVGW9fvX2j8Xipb/72e61mFMOjPVHpHB2ssA87RTvuA1shFSnkNZqTmgJtu+z9JTtg4G1fd8TzZDABw0JGQhvolPKsC81+s9SCvws7tHLZhRJpCGQGjCTyxbJGk6U1i8hfYAAu1jNt92s9PvLPSm4mOLg5pPJl9qzsR/6u4wYOQAX9+o/+SOPh2J6UNFQY4c+n7ECOOjvr+NmDTm7rPSeX8AxI+TSC55zNGmgGSVYOWaXygUWDZrg9fdRw+GS4rVFtKUn4bjBN+bOAvShk7LWYHLiWG+XTeU+F/F1MHRzCwR0lwH3szoAhgb4c4cQBQALElCIQAo05OHn5QWYMd2026vUG3mUzFQHl87weRYoIMVBEJuWC/jbNPcmoe1736uCb3601HA2USUPKIsoLW0c0lFWtV7FRFPShSLEW45mLn8mkp5/ZYqWb+aM9ZPPlrwyFohtczDeWV8A0B1OmGcZBh2mTZun9h3eW4wRDjI19fX/xqzd+hvZmoiduTtlrvv/hk/pPE8Pm4Crca8hG6EDZWcK89+F2kk6BiND8hABlmLU0G7BfQ+PA9QN6p7Hl2i83K+8baZLjJKvVaq80hETMC4rBISqY+7LS2Z7eB9AAzCdm1kEDR3IfQBdW25WL9nLB/QhwP/D99fOuc2cHDyM93fX1lI3U7dT93tnIP51x3i6xYGiM++ORRtNJkLXx7tguLlgYUrBMjLQenOcAXfLRzNbCaTAJjkLs1JmeU+aJ+GyA2bsOJgesCNi9O6GlgDkLDlvrkItJ2AMWgCbJpJ3FC0GGzPHheKT1fmdrQ4qQLe0oyMdE9UpZOSsJYtVrVf97S8P2e7168VydszNPr2jsIV0SjnGwKxL3EHkP7kNwExJtuH5eR3DtmSoxws85aWW1YJcakqE2O4a6jV6dvzS0zeqC+//5bAZWZ2BCD/5FC+UAZ5FiyYSUx6eBCRM4yGd8E4lIkTKlklq1jvCjPvSJH0I4jO/q1CwpcOizi3bIk1vvVMpnbFJMsVkBHxz54Ikmd0Nj3cAR7Dqn87Fqs53+rNNVt9My0ymfibRkisyFac5/6D6Qd3gpybY8RHPTpTfrmeqZtF9KHhQeXvZLQJqzydjJHFno/+WCRlMW8nRvuKCkbDq+nB3szsPeKoSLInjGEi52VxXBRiznPDE/9Xuqt166Q6MbjfKyji1JUSSrweMQGIODElcJYE2c8RP0X0d/dhbN7LiYRq8vz9RsV+zziSMI7jY8YBCWYhJBMlu9/cW5H1xibHB7Ab5jSuL34D4RQqgDdMFLxgKc4F12Nd7TQP7JpjUdY9N34y673Wyp35+oVq1pPOgHOI4OLSYIGzs2XIYQkIe8OozZMTuvV+qBCAEMn6L7jDWc9lRuZFWpt7UxJIbfZKTlPNHTw1iTAZmLZe8meDl6vXFIcAEtqJTU2Lf8ubfJ1tosjigmtXwOIhMoQqQff3rScLzUxXlDnTNSOv6OKXoCzJbXdk1xAmzC+HzjNHSi3dhjXV5e2pAdWQwwKs+VyReYZkc0UBPlhZxjoxzdM9dORyMWdOb9p3EwF9/TKtAIRuoN+n6u6FyZFGggWD3kckU3TezOYF7yXDEVFIpVM5BXi63RDP4k2Ik0FfweoN8tsojpxEWV/QyHIob70OGz6ZzzXFcbJDtpu/ysVn29ePHKYn8OiSCx4KLs3LzSJOAU5bQGskEbRTebvM904ngel6t1HyjNRlvj41Cb5UrXz5qaTQbq9ya+Xp9/LLcYs4uDrITcAfLUEa87VbsVxTP0iEhlMHCnSTxqO91otl4KH27D4cposthrs89otYk0X+w8fdDY3H2a6nd/814PT2NPmHwvdpc/fP9Oq/VEr16dq1EvO2TYe8kMyAYoT2ynKLuBIeRfLF0cnGVoRi7WkDi3IEg/OIfSocCHSI/3Y8sraHhpQEvVjEqVTLBmowWKWRlh7B6sMCkkrEkowpxpsNXn86mLAA1PiD5b6f7ho8+kZiencvFMZ+2Shr2RGZlFisaEs4qBIeWEpIszmqq1A9bJgh1Pht7b0QjxDuLYA6nHEDXMXybPLM9JxoRF9qc8j2S6TtGepiOzyyuQIElfAj7O5jRf9bVcHrziwNBiQfal8J2NlDL/A11iiHSjS2W/vpjy57HvPDiYPQ/0Wq74XKFJL3TxVmY9snZjxXNLIwgTHBOBKtpPAh+SvapFhiyGqrT/2ZoIxBIxWzQdrPQwMoHsRIoOTPGZMiq50cEdLluIvReOaILQomMUkguJKYfjxO8mEA52e4vV4csWSjQxjQYMuKLifFbpQ1bpXFaLzU7z+ciSiGa3oyXwayqtWg0artd3xrG5MBjxHu7Xur7qqlIILh8wwCBEfLrtqT+YOsJosdxqRueOWNh2ZbG624bu7+51eYlv7E6LOVFCR8MejDt2KzFhh2R2mKV77bF2222VLxMJ1VA6h5gVU4NAN6b7xlOS95hw3GOEg/3pcCUZe71zkY8Z/TEYR9dj27zEEBkkELoSzLy3TGUmC3AgBocKGId4EKa3aXd8pJlwOCFXwdM2RA2yO8m6cExGS3368KT3Hz7Yxoo9rB2LKkUTE6w1S9MxASemfKix2ylRIJ1zuFdsQhRsuIE7TKbVQAlhMuaA5gDmZeXw3aqQbxiGAc6NInaumSDAzxR01sppVVrZGu7y8tzdrzttDgd+6x4iF0kmex/qbj7MuA0OIRhCAFUzobFTpKkgh1JRQYvxUTcfH3X36dH7wnq1ZqiZ8gNpYnty/0dqlC3tFAMpob1q1WweD90cqI2XFU1dLyGcdeh9rU2Sy62fn91/+bDR04DILogqXI2SyuWudumdHiqxRvuh7qcpFfcrdZKiuhddJYstfF2lQRMSWJZrZbZIdBpKWJtiiZWtaD3Y6f1PdxoMBrq86OrsrOXpOTVLKUqTqgCZbKN4xQ6tqENcVz7KKXUAKgo7fMhnPEd/c7vQlFi6SlXlpKzJLCTdI90BLVjczQxZc6CxLuD+WhNoI3zkNExeKY0nFEi0qoTiZvTpfq+WPa6ZHhHZx4r2kZJZ6MjZCRbMEMzr+ObfVqH4whZ92UpdszXh6VmVpxkVPTlVtIOwUUu0/6qkZbGn+6j287XmOaf5yuaLnlyJsELjCKEM4li2CGSYqFGo6eyyae0ycpEofdARc/E9tocZTecr/c3vfm8rSNylePZq5YbNLBYz0iO2ysQFO/9girBeA4dCulubUHXWqVv64yQMGzUEhx5QJ/x+YVd7B8xhy9MLFyBiYiY2bm/LRTxB0+mCE3F6vZGK5aKn13orr8vnLTXreAuH1xgCSTaddyg1BzvnkZNABhNPnrDPK/AjTtMQrHFPm2j8jinvndnjl0tZbaOD9iQArQ9unGnMd8nayE2v39OSs2cf3I/M6iQkodlyI87Zx++nEUEhDQekgGsayEc+WDOyEksSdnlkOq78OVfFELSMLaD3fWtSeZo6O+/aJpS9o5kNxGDFkSoldLsZy5C8MzQ6tfF3BAq1nGodzN9pWNhxooPmPoA2cSJRZHHYuvl446aMcw+3nPNO22mITIF49BIfmOANCycM4w/j3UHiQ/HcOOChYu6H7SuPIXvymCfTd6V0tujEFa4Z94n9+mIxViZLuPwXloegXzmm6C7RA5atzSOAF0LOfEm2H/g4XSjaxKV2y0CX5j0EH67Q3RWAEPFLDJIAO4ys2DetbS1XyJftYENH0MIIeL3WeDYxOYebQze8Ws6tVUTXB3EFFiZEISZHFvQURUvooCBn0/6shlk7Tf+z+ZKpjsU5ZuRFPd0PtJxv1eq0tVjgEAF0EfnzMaiSpbhYHBXx55s5SNICriUIuXcqVcoqVnIqVmA8Ni19QV8I5Xm7J/+RfdHBerUcOxYKMALnJMBiMNDms50+vHvQ7c2TiQoc/IYA0yEnMuzlEfDvLHSHQq1UwS9Xq1FzpzYasjBf/Rw0Czz3OQWcYsn+jiILGWw2xfOSPzcUTWDO/Q6jgoOentjDbrVdw+oLxuguVqScl/HI5PrABASeWjt7cTlb6LzTNWuTa0Mzwj4B2Hc4HSkuptWot8NuzZ3kQaPhUvcPfe8/kIE4L7QAC3Tta7feHAz1ExoM2YciiJsGBBlIUIcEyO+gDmkARQzVe+5sg7h6pyT3h2f3f7/5tQRiCk/k8w/nFz/519LF3/nn/J7v9W/4c06tkaanX/+//vy8Njn/An8Y7hanX3+vn46kV8EbGDUQP7h8/Rc5fUEsfvX//Y843Gg0rq6uDOnSJOCcwo6Pogwqwn4UK8SwEyvoF7966Xv52BtbgD8YjI1OfPpEkHBDZ+2Wg90fNfJUads69KkQrHIhYxOiGAzafKagehXnFuLfYstayCbl/bG8K5czJMqUQUMDnMeeFIkXTQuxUEh5DONu5QzLyZhoO6K7QCXIc43sMBTQV0LiA5yJLY6JP5D4gPkwjc8UvPdm0rIS6JSdhUcvBBve3c/yCe8haYPtEiQzYbFUnBKvh/QEfTRG7BSb01TGew77HR/cVrujym7vd2U6HrngQbrBLY1i2axV/d3ZNVLIYMISeRvsLFOq1qs+H6yZXcMn4V0Ceg3FmkYa+zds6xo1kj0a6p5XNJrNHI5sljrOSRCLcDvDDQcNM4lBk5k5IPA30H4C8wIJs5p5957JOqfJGHSv7tB4VgpwUlrlumKQwvVGETpVWmkkcOZZRK4AFHDrgdmdpiiG8GTQ0zJBQsSEJ7LxTho5lzXGB1ZEi0AW/JKFkrEaDHoJtFgrq4TINseIWzBss6LS7yO9+3jnw464G0TM6Av5wOgKO+2aFMFWxB1hb+cJ2HbLGWHBFAJYdRl12nXFhYw1NBgzAyO8fH5l953NFiF1WKgDHTCdsQ/IZksqJjl1L851czvQETPifNasVkzRSXRgjKfbQHTNRUN3+HA/CDq9BQsKOnwGWcTekXIFHqiMjuwCYiKGIu1WZKBFpqTz8mNOgBdtq112ViJOP7PJyAQcCiJEAIgKxSLu9RUV2CfhNLQ+6P6+Z4hjOJjr5tOTw0hxo+DwYDpgGkWmQQHZ7mC2JjriT8t+jBJno+WwvHe6w4kAFIokxKBScCcBdooz6j0NdXv7oOFoqkK+qouLZ2bP3d/PDdOxTx4N2f1gmDpywcPxBYNvXmASQ5B58FJncyXdj8kKfVKy2atVP1e2QmYgHWTQspK7hxi7c940qYuIKohR6LMgY3AgcgAK1ipxYwc6z427XJouHnKgJJ4vyDvsI8vVrnYHSEtoGiO9eHnlqWA0fjRRwJ6rCSHSX6Ji/f9//k1/KtWKumVIdBUXm3K1rMwm51g20J9UlqkJMw72RXi3bt1k/umf/UqHJK3Hx4H+/F/+hW4+3mkxD1ICig/PM4xzIDQOwmCXGYol+7fVZqZ8KlYxWzCz2hFVELtgCGOEsMP4fONQX5o/iqMLCZ6sPquCcxZIBk0lRWgxIyB86r1s7jQhk6lKQDOwJic0U6qRsz2yj7XSUUbT8cJTJVMkayKmGQrl8cC6JwREU2jD2iloZ0G4NodT2PcW7fdSmVQIkXeSSy6tSqNr/fX7u08ajJDvYHwfcmspBkyWwMhA6c7rJOprj5sQq6Sdzx7vs82FSLRc70zE5BzGJ5Z7FqWY+IE2YbDPtZjMzI3gewJTszucz2Hy8vnzajSLJhVyZNgnF3OJNWzVo+0LQR1Xi7UGo4nNO4LdHxKwvJsT9tS2+HTYA4Yueyfv5CA65TJqVWuqEGhBpudqpcl6pdFipsli/rP1JQ0Y1wDlAOhesYwkZqtKBiQGi0NMTI4qtVnJ0MSAwuTNRl/MPneDX6hQMo0Y1qQFOW6VbiKgzboIXl8/s5h1OJ6r/+6jf//5WdddAmxTurfDca18oepltQ12dxjSztR/wh4O27myheYQPYoEG6M9agapBiN+swGMsgp7OYxu8xnlRMxO3h6HXGSoyOdXF3ren2v/7oMhQCAbiiXdKxZpdGpAALP51J6oTC0ItOdzDIerZi/i0RnHe8PJHOB0cAjvG4e6nX2wjgqWZsgBGqrWYReSYYmlGQt1yB5JCCfdwo6kOB416U0VJ3nvHYa9hW7e9fXwOFLvcWLhMCSPuB70f0yrHA5Y0HkQg7iBRRcv/0mSstng4hOyEQ1pIIaHdZygDYQiHvuBYL+E9OFv//ZbjccLzSZL5QsrFXIdd6zj0VJPT0O/7BCsfL+BPjJHkwfy5dis4FS8UZTqaLdJtJrvdXv7pIeHkf09Hx4GPhTiFKbeGR0iXES2yqaCGwwPKNMxAasfP9yq35t7mjS79aQHpUjimUoj5AilAte15HvdH2B8kOj8su2mITM+6tXL546U+v7b7x1HBpmKpglt1LP5SP+L+D/3IYsxAf6tpC+wG+dQOGsTqxS8OMnsNKkjF8OVCrmBEEtPUCZsvPWKCDaml8h/BoL1fn+q+7snreZoN2XziJcvL9RuV3XYw5QEBcFHF5JEzvB4iBpCcoAOs6hBb6K7m56m7OmmK81gp9qXMqPuZU1vv37u5stm1RwhFoBDxiH6Kpg/cCjayi+FU0rViQxT51VCPIlsfGBoMFB2vadDEgRCQmi6DcaRrownZqAiTwLSsi7wsLepOztkIDVMISg67O/wrAWqx5YPZjIw5EUrq2fdKzeQpI5QOAtH9p5P3htx4HOfINCxFbBw/IjlXd7Ekxcvz5TL/9v6m7/6W/3lX/7Wu1SmJ6daZJB9bK3dpqohkG8if+GsIA6sFKtTJxEjNoseRAk0h50XO0gO/8kKbTKsemzZ8hbjg9JA0uOdqVZweiIEe6NSkbg3aTTi36HNLJp9S5EsOIAbHoNsqE8Y93K+cYg93AxWSptsWH3AKLf123rsZsEksXSsTreuTYJVZwgcRxLE703WR40Hc+/2FsuZ7wHmCRAlyZNk581nIKeV78E6p9PuWJf4cH9vjgNrFeArVkWfA9iZniloM6zbMIrA+CAmLgtfXuQqsHxhDWftPZ3Zo3EteYCxYYY+T7EyA3+CtGYLZB5CrNnRYlOKdIMmhmcunStovmEVBiEH8/QQcs01QD5CUwsi6GYF5yEcjQp5P7+HDTrJrAq48xQLTgAqr1fKT0DCEhuux2bfA9kD+YcJFttP2Lsp0DW0qigEMkUtp/haB1md99vZuj6+u/uyhZIXjBeQqYuXhsmCZW/7vKNqo6Wffnynb7/7wflkXEwmBZa02DE5eHM0VqdTcoEhh9DmyDE5lBRcNH9NHKNN6mGaxOwcETCFmSVtMd+0/gijdSoDD26lWlO1WvcDNpouNJoNdf/UV3+IXKJoaICbwS6CwxhSDYciUMVwOPCCnY6XznE2XhiyrFa7nmgLRXBuyAkwEGOVSw3FUVHVet3dEdlyJNFX63nVGgUR2sG5CvTJYt0d6j7sBdGLRQmJIxsNn6aOleqb6TbToI+rzdr/LkqR9pGzKwXEAxhiTLdoJHELgqka0gv22m833idwwMEKo0gFgwY4O0FeQ2PjJmC20f39SLe3Q8G0SsfF0DVuIHSwA4I1FgokbGPbcmXSOr8g5DinVAb631E5HPmzsYspiROjEfTtvWOfgMwgUVSqGcs3KvWS8slRj72eer2U9aE8uDwfc/Ralq2yV16q1+vr/cdPTgiBhIVptolADumlYKfVPmuatYnG8dmLc5UrGb1+9cpykM0Wn9q0atWioWjgtcpqoV+mp0procP8Sdv5jXKbkQsyLj7Pa5BjtioXgedzRAFrtpxpOp96cqdXxV6MFwqYHTJHLcNaYe57u5jtNPjpRsebR39PXszMcaCLzlGvuonWh7GtuijyNFtRCqlA0Lfx3CMD2m4mere90XZyo6i/UHq+VwPjDUXqllu6ahx1npmoQYI8rkyrqZRDzrK3GNyQ2HqvfZR4r2V7t+JcCy20iUkQgemXaLCZ+nmo4giUIM/ae4fDZ+blYlfG8zTPz5UqZlSpMHUwxQRB+DjGg3anaqWq0WBh/1egq3olr91mqdTqo6LBQKUSwdxFH8SP/YHqzYoP5EIFij7Fd2X9J4Q6gg8gsvEcoJ0t5GFCo3PE97ap6Pi1hqMnE71gHLNiYd3DXgVCDRredqOuF9dXwa7xSJLHzrKl6WitJHXQWbkTOAPzmVnycalingAWbez8OSMIRufvZBcIJBeMzjmnssqV8iqTSpRjZbPUYjlSEVu3GH/pRDuYtthcHtntrTR8mmg2XiqLVu8QeWIj93K3Omq1QRPJu0xBIsT6aFN4ngXY0sL43jrwrIoVKV+a2UM3nZkYRvTqiQShY6TnV5c2fuCd4XNRaHjO0B3OJhMXSefpMnRggtFp2zAckt5wPNWWvXgacwTuPQgaGbxkzC7dRPLM25CcZyCPnCQ06LxrlnbZjo56QBwaJtPBOATkDIIU0yQJTdSK26cHGyiwF+bPA4ZG10uDNl/NzbHgpaR4ok82EslgUsIgBO9w1AN72AJGBnhkkfhRapfWoa68ouMjQL5jWGHI4tkNP2jjyyrmioZ/0fbilIXzUOBjfGFTdMeeYFZdrnqf164XDe0xwdCpv3v3ST0W185xBIJDtAsxAd0iWheSJSAMpBQlCOg3PvTPL7tmA6K3IiEEthPq9fefPtpIGDy71Wqo26mo8byrzQ6WXc6Zb1Eqqy1BrfudprOVxpONPny69a/eYz9Muw8X6l60dfm86yxFrOrIIITxyGhWKuEZiDMf+z/c5gt6/rwrriN7OCAix+s4ef1w2keeK5W5sC2SUtCNg7Zys5p7D8LLSqeEsLZeaeqwlbVS6B1ReMzpPB+GGgy4yYH1ms9Bu+bAxRSez5nVi5d4khIDtjWzF5LLbhu6fETOwewAMXYI02VXwzRGYc/lKxZXB9E4SQBZG7/zoOMCxIOfaKOrZy2xVvn46Qd3kTZBwFoOU3oOdmif0cE7R0hFTgsvFmxJ9zlV3UksdJRAn+W8jgRglwra2ggBH0iIOYndfBD9MrGQ/FGpJapVSZWP1TljR7wyuQpJRASjOYtXKXTw3Wmy5gBI9ObNM+2fd90wAe2fdasmYLCXorhzP/GPRSqDexN7S1IFzPCr1NWsNkLKiGVFsZl3NFez5cqmzOSi0hlzWFxcXtp0HpryeAz1v6rHu1t9hIh086T5fGURNvf17Nh0Fz0ajzRf9A3HsxJgx2opHzFOHISeCEk+gLmZ01dfv9F5d2fYEUF4ODx55oLcoFhix8xEyCqhEpJj9uQE7ixzMQOb+SYiem2lNJrPU8Ayvy9EUvFshVgz5ADs+FkyAvuRWo9ejcmDHwoHhxeTKBpN5A7T2UTLdGAsZvMFN0hIZdhxQxD58PGjDocbZXNlT2Z39482s6DB+fUffaVnL7s6JCu1OzWT7vCitlfzyfkG8fgKU+9C2c3Mq9fE4/37+uZvvlW1XHemJvIRjqzjLtLjzZ3vIVMlxS6VYn++NRS7QbucYKO50oZEGRfgnYtX8HwNRgGsCwf9qR6f+mFNslp5HUIRenZ97Xch1SzqatdRr/ckqny9EQw0bKG5xmKOVctSH97faTpaKNqnLK2y3Vo+7ygoowrwIkoFM2JHk5ERLbSlIBuw2i3zCFLOIGnzpJuzZ+1xRswYZvdlkxTR91L4ORf998+X6j0++hnhmrOy4fu3mw2dn52pbBepbEj7sCab5ynjKQ+TF2LP4s1eh9FMjWbDzwmFBGIm6FiMgxc2eLuDz0EGD541TPptCr8NWl7Y4+xMIEbxHdCtsgJBksbvA01h+gyNejDl8Dlku8KMNa7830ClpItUeT5QDxTyhnFh3GMClYLJnMloyooGBcBiafISRC2KLaQxmlLuMQSrOM1UfPS75UQjvjcJJmMcsr6wPASmJ5DUWZlpsuggZQgxPLw2FcbBHkLP/hCmnn2i8XQWrLuKRWVSIR9xNmHc5wJhz4RcAX+/g9Y7zG4hj6T16f0Hffvt9z5c2EsiDoZ1uF6sVayW3EWxCCZSajomcHVmk/RE2VO4J+bdRR8WQFJcDPamObxB8UaFlUgWHX2JtVRSjIdghs4OGOgQXFns/BBibKbzkR7uxprNNg4ZxbsRgX+I69rbsoruEjwf6CeO815KA4/A5Hr3061JAblsSYPBRHd3A80XB3fhTlpISWfdhq5fdC35uLxiWQ5TFNkMBgjk29FkIAdALB5CWoMDPgUr7/vgjD669vVaT0+Eys7tTbqcH7zzyJfCoUSKCPuFw3GuaiPSb/74hXpPI+sKYXTyXZhgWbqzj4VtXC5wX0NkGnZ3UNzZFfrgOeZ1c3+nxtlX7tTXO7SefL/iydiAAoQDUqDts5uiKcBcAEIYWkK68pknW4CsrA+jerOm0aTnZfybt88Nh7HjRp3Lf5/PNlQpIq1hnxUrScgKzAVz8pikkoot+s67LU1Z4kPcwF+SF/hwSh5ZY4k21X1voO1BKlVriojdorOO8y60TrM4HB1NNRxOLQf5bK7AM8ZzhSmzo5uyB51VOi7UTKcUAiBkdqgcmFwTJzQQeN3peHd13k2pe95R72lgjS2FEmiS+Kx8LgSAp7IQJUgQWbhxNdSeAUJlH41+cquPHz/qxZsXhqAtKt+O/fuYEvgeIAeNBhKYohEVN0Tst1LEuwWB+nIL/B2cetM0uNnYEVvAwhyiHBsQ59gb0cDBjGyd3evHHz5qP11YukPB5v5v75/8fPPdgLe5RyFYmfcyxM4ht3M4c5QywcIC/xRZlS19/Yvn2ixgZOb8vrEqWc92usL8vf+o6Sw4vKQQMOx3Ggz6lhIc09yrsaqQ4shOJFB4sVYJnkAB6VSiyWSpn376pB9/fKezTteEkGw6xOsNR0Pvu2rNkpJUQ60O58nRmaLZNPrnIHjHzm80mGo2Wmq3TuzetZrTvOy0uAdSn7no0X0CH0MsBGIH408dyQDNnrTHJDIVVUSLnMxVLC8DZ6GY9QoCtIMi2WpjJF7wMPBwe29dIQgNMDuG31hokgNayJfM9MdIg4aQ5y4wcZFZgFzzeUJ2oyHnKiusnLWJoDncC9QBIHKL5UKz+Vh7S0Ao6ESFhcQTmhoK836zVuJUIdADghjKwUHIK4PARKUWUOTtTRvFOms1jfpxv3lPtlP8aJGuzOhglRunVSsW1awUNZwN7SgEypannmCqlUQaaaJSLqdaqWSJSa1Rsy3oYjtTwbtoUoJYg5E8NDSrGeInDlm8dxABv2ihpH3HUJpuiw7TQZ8wV1ewo0g0qKhaW2gynnp8N6nEPn4zRceSsuWSdhu5QJDXZxwZhrC78ZWiVM5d07v37+wNu1ouDVmx9K2VK04pJ7LosIetmrfmkN8/Gq/10/tPeur1LU6HpIKvH4c9y3oHihJ1hCA7gigTOcqm3alb3Hx/86D1gQMZE/Gi2mdlm0WzX+HF4GGiq2IPNJmMQmdSID+Srpj08pSK5bKdIPbbg4XLLJUd0Oxg0LkPLGArmK5MnnRlmMhvWJLT4bGPy6bUOavr7dtnSudgc5ZtZACJxaOj902BGEA352geW2elLdSFTQusRlFfLHeeztgBcjiyw4RZ65fkuDGJggSJi4uGWWLHzVrX102bYJNCQtwmkB4H7PlVxwcUNntThMhMjjEwZyhAs8Zcm9Ve4+nIms1yvaivf/HCGigO3gb2abZ0OxpC4tBttWqajzcab5c2eq/gNTt+0sePn5TPl53U4khZs/uwpwsawMvzc3U6Te132GEFtjPObtl0mGJAJiD2zOczy2+qbXSZSFlCTqCiookFhF2PB0MXLKYVKrd5lHHwqd1sE1Vr7L7Knq4gflGsYCk+3H9yo2NLL2RD7P5gWxfzjnYrlvMqlylqTHIw75BjZPzuEPUE7E/BZT+Wzey0RgQfFoUmbeB6xD6S5w4CGrv1QBgJWsUd5uyz4GdLZB0NJwctu8Xf/e73mi9mKlYgXHW8V6/VG57ecNCiYWT644Bj4uG/gUjBAcqSlR01Fmjs/SkmrCo2K5gqOKFgFI5lItmfFLqtlru1vWfPLy/07/6Xsm5cv/nmB0WbxEYDTC0Wp+N7GgOVX53cgTDlwKLS2zpfD541fpy8sVmL6MvtBnQh5DiCTnr3naSVbDb2st2tl7YlLJUyJhiOe5hRTNXONq0DBo+zMB3zCVPhYZGzcthbT8s1RScJu3U8WSq3BmEqBnOVGdZ2C0P9/PkUDs403iGY+zR1JAtBxoE1DxyP6NYi/2yw8eTQJ/sy4qBGl6SljVBoElldIXtg3w8aQrCz3WRs+Zn1igfOTW6buLgCF/szAJniSrNZW12AbRy8C54r9selfF7rfM7/yx4TGJTfYLs7J9ZgChC8akHmHGNlD9lT4IFF/iA/JRd4GuVataLry3M98phm8gJRHoznPt9BlczSTQjGiFWtlMI+HjifHTr/GvlGSpaOAC9jWkADeH5+5sCB/mCojzc3XofharVkOlwyvcbaHpCj7ZUCmVrTBIO2oZXuelhCV+8BKp/1303hh1RqWRaBBAeM3/GbjXRLhu06wMu8E6ArBZvEfMFCyahbyRfs0AE+/e7de5uV06WxWwROgeHY7Z6FIgkh4sAUFBkzXy6APA62qCoUYlt6cQBjmH3k4E+Oenh41O3Ng00DmFgKeRhtsMzAzQMRwX6LKaYN2TD38WmsDx8fNZmic1rp7ZuGXr16oXTqVr2nnveG3GzOIl5SdmKp/UG1Rklfff1MrWbZ1nlYX5Ek0DojdT5n1w57Nu72Jm/wBzBFI3IF+tqRkwc04Akn466c3WHmhP2zD2BtT/Yh+47uWdYSDvwpmdZara5my4P6g4nhguV6ol7vTtv9ha6enyubZ/m98p/BS/lw9+QJ8vzi8ueHAMiMv6tCcCoaqBPRgpeAqcrxP6axA8Uyxe1sn9c57+jq6syZmnR3sPmwOMOfDUibYnncHnxgcu+e7uaaz8dm8mKWzM6I7u3Xv/pKb169cizTX/72b0wGef/+VpV6RS/fXLvhUJyonC/jlWE1MPsYoKbpeOVig//oxeWZer1b7/8gRvD5ObCRg0C/hySwXIyCndWhblKJC4vDZdn7BTcSXkrOhflsHggnqZTF+RLxShNDp3TxdP5AoLhzDCeTsEs6aT3xIGJ/Vapg3l89yZnShnG4b+yycG7iZaMJ4cVkmux0G06PgaVdqWWd4Rkin8KezweR93Mby3AOSUpPj0M93g1sLtBo4uQDLEYxyqrJrrWQc+pMsDBj30jzEmwCSXGoeHcEdMwuf+E4OKZauAEUJqj9cATM+IThuQkkM9Aes0FT6H4LKpIFaktE9JXEbSUazMYuWqSdkMtsY4yIAxqJB8gAEXhAYAENefvVKzusPH/+XIPB1DIOtIjkrgLZm5BShK2MdzLXhkke3gBOPwT2MlWt3BTYDBzSHdMuqI710tzjrYX+21WkZpvG80rj/lij2UD5Uqx0PlaFRqtBqEDVTlzL5dyoD0xy+zCn8hpN+pYn7ffwt9FodkOoO85jW1jxGZWyuNgQyh3OItAJulHOAprSw+agOIf8a6vpGGP6AK3DmF3sp5pM8UfdaLFGGB+IUTOs2ZzdiOUmRSwgBESb5cgfOCZqNVue/rfFRKnpwh6qNa898MlemRGb3mDUkjZyhs8q7zrPBhO0qqw2SmrW6rq8vHCR4z72eshuhl7fMM3yHSMhHwv5nOEXkDRnXaR0Pm24lr1oKk7p7KyhZq2k5eag23ueWZimISgCdnqxQDpQ3TZ5NCOj6cx7ZFAF0C8aRgxFMO847vdqNZqWutg8Zb12eDgRYRzYTHy4uiKHganMOotCxXm3G2901x+oNRjq8vxSnUZT9TKGLDSAwQid67dPpe0ShZfvoLfQaAAfZKhqGRtE5Ilo3wngiL9sofwcloLZ726b9eIbkTV4Mp0P7hHsb+i6u+dnyqTy1tuUchm7QXCT5ws0PHl7Eu7sILJVrQaBpqbJdKaPHx+8F4HmVq0U9fLFla6vz1yIgER5rFlOr7ZH07bfvyeqh9R6mIzAJhnbMrVabWFuJa2tQdod6Jb23peic8RKjSU/F7VauwrfzakiaC+DkbkPkog90tKTMJBpulUwU4z0Bx52Ui5y4EanggqcAZGE5ceaPwOz/B1JBUvv1yCcXF61TwyzSI0kq/l6Zeo8BzkC+/VqplTUsVAXizNYs+PR1HBfswHNPKQ88PJBxfae0gzNz7cJIS6QXE5RXHfRYY+GaTRMtVqlrD/901+rQYMwGwVomdgrmpVDpOmQPMKxVnNSKLa6u525A14ZDos0qU/dCUIO6HTq7s7ZV97ctz3JPvXG+vHdjZnLTFh0rHwev1QR/r/s6PLeDSU3NC4L74KAAykSlXLVGq0pVmIQZ9b4TAaSBinxXA+IIDZY5nAnfcYvVZjisdDikEKYHHZftuYJaSkceGkMmFuKo6w1c5PJVPlyUZV2Q4fgYRYmLhrDStWMT2Ca3mqrZuMsTJZIk1IheQWSCjvwRhOT/5wLP8xG+6mmIkXYq2HTtwBtmZu40mqem2D1/befdPupZ90q1n1XVxfegQExka5wRHjHj4P8ONBgKu61nONmHalSDpMOZAygrjbd9SaE+fIson1eb2e2JMPeL5NhGp2bqckemOBtzLCPpGlAWsFWzpmuSz3ePzkLEZSFkFxi3kq1siL8lwnmRnKUOWo8o4GhGHR0cX6lztm/q7ubR33/w3v7ClPoshlMKRbab7cugHaDIk4vZpqBLEOjF/xRuT4c+rxPkNMoHkEziC0iTQxZzDhySfVWxWgEjcghtVP9rG4nMO+oDhS0sAMD8fJ0RKoGzl/TpQajqdEdRI8gVAQ1AO+CZMFeJUOSVRDTO5IQyGw0yfyZNKefI+am45kZmhBDOPQ55yD7sXbi969gcq4Q9YOwQOYhHo2c2arhVuwUy7WMU2247kCmTPsUH3Z27MqZhin02sVeGaAdZFqv2qKTZwqnKYK3J4btaUhosP3/36xtZsGUzmFRLpXdQIBw8A4xwQUfVSKzDt4T8x5AyIvMJt2qWa2rVi67b2Uw+XH5QSlSntKw6tPiKC3lY9WrJbWbVa1B1kAmQBz38D4qtrMrc16y8trhjJZ18aY4k+IETyAQi0KmbHzELCGYwTt1hOcGS0YFA/jH3tBnD1KUi07bAxVFj3MdRO+QCiku08PCNQofY2RpfA9Y8GiuqTVAwl+0UOKuEWPwOxjogK3QClFu+mTGjOdwYLeClU/HVO6Sx+JCFqr1VFtG70rwG5xMSF4nF3JheQEXDagCMgkEIb7w1bOu3rx95sLIgUHhwhwaWjAPFNmRu22wuwJuxfMUmMRi0+PGyQj5QqTZauaXp3vRsrFzrVl1XBEvUzAuDvZd0IrZa3lvCVU7XfBNhsm1nG1VLmcNy9j7NZ8JRtUJhxY2U7yMWT80OxtrU1jJTMRSCvJDKljnHWJVG3UVdrIspN8bGmrbH5ie9jYvh2hEYUoj7CcKarMzhfvy4lqFbNHJC6kMaQjpAPf6UNlpl5D/yD4sdJ6GyVs1S0qS+ycfNPU4r0oVI2Yo4hMfUhS5wzbSdnVUdEB6EgJyMRFgx2pfTmHPt/c/mw7vNLdZeqKzbkv7/drG4WCW5DluNgcNhjOLiP/kT37jiXqxGdvGC2N4YEqgHRoWDM8hSE0mQ38eyCQcIFeXl2quN7q9v/F3g+SE5MNxR5jo42nKfQaSPJLyAUQ602YJhBRMrznEwn1JG2plwuiedT3Vs69CbD5b4P6EqXZDpXpRCaSlTIDX2AGSqbndLnXz6Va3n+4sh7i8eOXdDbA3zQnkMPJHiyWkSuxi2R/iLkSqB89Jwcw8WNesGQi/Jfrt6XGiD++e9HA7cAEFwkMm9Oz5mZ6/CKgMzy9wJ80pEwlwLFMPtnHsrfHn5fdxirBL4sXHqILpgOsWqPyh87dD05GdcSW4PAE7wT6MEk2XwPsB8emdTCCwzCvlKtouN/pp9FEvXj8zqYnnjlhgzgOinJBa4c36/sMPlhB99fZr1ZusR4KpQKeDa09ihi2/f7maqIBvbiavw5L9GDrf4P2rI5Ay00PKkych2XznIC4HoqXBnAVUolVV/ziBlaB8HpevgydXmtINqBGoAQctocU2LMkES8zFQqMxjedYuy0MTIg5YaeKbCasWKa62J1ph5fpcq9S6RRdh1FCNmvzZVYwq+XBaNR8uvCkbU5Fu6tK42hIfdbru3HD6g5iC1riZqOuFrF+MfBsOCsKZczcaUACKoTbA4MHn3c0nfqMYUXAOcmEycorTud01u1aDsRzPxj2TjApLFVWQ8vg3UrhiYgmY/d/PEWmETbOnhbN8vx0hnO9A+qUdbRdopnzTHN69vzSGsxJb+T3nnvO2YfmEnb85VlT2czR3AGY59F8rXwmdq4rRZNn7rjda7vaKhdDLMJtZ62Hp3s3RGTTQuLKJliZwsBm1bD3xAmbH209UzNExSMRiawvOI9WK0/p1TLnvlSKkJLlPBhhns5ulyaMZwg0hXUCmltD8jahIEUm9WUL5Xm7HcJQ83mnYateC1ZBhYImDgQNC+JqBUbcSqv5QelW1ebPQG5Ma5AZmETpaGw3B73azhR0TCW9fNk1bb5cyZodV8ijz0FfyA60rDhLwVkbauIiUeSAftEW0XGx6HVGZRU4Fyi4pY4aLkSWJ2SCrCQXoceiuKeUwVjZ2sfI8M+G8TgJ0onVEj1TiNbK5efqdoFFkE8g/D8VsjXfZaM4i74rmBNkSNW212vw9qTDx4aMog7b9/Gpp+mcA2bnwwQoq9Mt6eq65UM3dOJhEoI5m8ZeTthtMVGslQPysmckxtmwD3dKG0oL3T7G8xRyCEk4nhRndIwH1WtnToQfj8a2Fms32yqkC5pNx2bi4pO4giG7k4OdF5ulGc7s6I47ujymzpzypC7s9n4ZgXmwHORg5r4i2TlEW6dPYDWFofMmAUihKYEEhGFyZCgnTv1Cg/5Ek+FAt3ef/Cxxf4IpNyxdyF57pXPoUwP0ctiSAYoHMAb96PRgVS8MjQKVAVOzu1yi350tdXXV1jQ11Hp9ULWEgXhWh4icwPVJG7b3VHTM75QppJRLpb33IUgbreh2U1OtVtegN7YsZrX4wUWp02L3R94mpCpSUiCKVf1O0BxBaONgt/lDJqNim2tfMdHl++8+6qfvbzQeLg0BrhbEIMU2nWDytC3faqHWWdluT0FOEKmQypptyv4Y3V+tjA0XUqrgrkIzRBfOTpgpLxA4gNgw1AjvDRMi9x+TbrpwvIEd58TOf4Mv80xRlFU+i2tKQePJ2NORtWo0INzDLLmF2DOmNE8RclCyT/B2s7CkA33oi1eXtlYk5xQ4/OKq49WHf5EyA/vdhgBH3d7duhFiWuO5ppCzAzWUmWLSDHtVJkMyDykcPHeXzy7sIgNhBmecRr6qTA5v56P1dxyyZnRmaIIR1s/tU43FH4J5pEg0HkEqAgxJpmjQlzLhHFUyQ9OZpdixsYtDe0qU4GKt/tNM8/Fc88lCvcEYmlogiKXJeIU0eDQigY46NDNVtVshy/fgJJYQkWXHrTQFJJC9mMYoCsipIBgxOaUyaZvKW8zAzpHztJBVtVa2bpGXF/QFZAZZCCgm71MgZXEmcIYEcwL26hApcxGFBG4IiEXgTuC8xbPLPUYWhnXl9YtrJcu1pr2hryv7yvcf7r3XxnimdpokK6WcStiDFpZGLWiYkwMkp83PoeyGnHMwyIdmuLOTJWWG92c6W2i+mrkJZK3iiYa9aJJSKVdUPpP3sDBPTx02YckKAQLoezdrrZZBIlcol7RfzTUeTnXY57xz5tlvtZsqVmG+BtSNVKNg4fgFC+WbV1em5/La8QJwkvMBq4WMeoOBmad2Zt8uVCWNPcIqradMuu4piS8/Gvc1m4eHgBeZg7ZZr/sLAO/AcI3EohtiAAw4zNbp+oLDPzcU+AJHBV5eAmiZAoBzLRbH2Q0Tawu9D04n36ORWq2cC40AGUd8HhJs9/iBLOJuGsYoFz1Jabs8aNCfazbZazxaaTxcm31aoJvLlH24HvZYWuUMN0zmY623pA+EImlWGHmRGa5PzWQGPgCkgf5gpPunJ8M9RBGlc3sTX9CG2Zzd6Qlr23ExRQS3jQCH8RCYdYdptycJdrahYKeg2Z9gC2jo1iJSqo5MpEe1W3yOjGnu8wlkmIz1Xe8f79R/7IXrQCjubOFOnB0CRd3C4ZPhumGThMkQ9hoTQGTIioPlvNvWzf7J7FR0Z2hR2UEzyECMmS8HLuQ8+Q7EhqFWC7urUf/JSAENBSSKxeI2LNyxJ8xh1JzVdMjesRaCdHXUx9tPxMSq3Wq7w/QUieOJSRNpN1KQBN68faFmq2uSFShBo8G0Q3zTWofjndYEPQPNxbHhTrSToAP8eezaIAO8evXGMUj/6l/8a82nKzWqdfvM8tmKZVJj0m4e2d9jrwjZi2l0gTxmA2uZdwV5R8EHBqjAYXMMGYERWZshTYFGkwkb8wHdDe2bSqNEoYTcgC/fbIpnJvaDrAVg7Saq1PP+73BR4p0KqRXBjIAiSYNCcaLYsJcjNg2bwORQ9WTNgQ1Tc8f0VKz7ueYQo7ng92NcQZPHYUszsSdmbAeBhTBvDECyXp8wuQCBBz0yPqhoZicuAFXCx/NpZQrBn5RfIfotZaYuDQ77uSidOO8VQ3wuCjtDmiCgRLyNeZbQAu6Svbrn5y4isNgHIAU4STVgRWZCgXVOI3BpMLOA1c1emAQk3r9UCvvMqRnCzVbZ8jB7k3qSxekG43/AEq7Dzru1Lez92VTz6UajPnu4qdmvhBoTf/zu3UdD9l+9fas3jZeeeLxfPqAGyARzfxj4Mf7P8BDWauwrhj15z/OZomFhGPI2yDpAxMl6n0xiAO8C19mGJ1EIbSc5p9Mq6fbjjbNOVydGdUhJSWk6D4MFUzV6bK49kiX2xLb/M5+EvXvGkyOsURfKdPkU01fWnNUUGstCUc+urrXfBvMCBhNWMu1Gw3t1EJ9UJeWGDSh6PJ16zwuZjHMKAxokatNlMDCwHScm8tFR6x12eSCVAUnBJIFfvJdOFWIlVyyqWsxr1CccfhrYtmjvrVUO0o809p6pnHarpVbrrYb9uUlVyBU5I/OlnJv71WZuEuoXLZQvLjvKQSSgu3VocMgEy1eyKsQNTYtMS2tDVlgzse+ge220sLKK3Q0iaoUUAyHCrv9AOHs63b5qNXRv7Bk5tHi40V2mXNhgN+HYAywxnm/UH048WpeqRYu9MSvG2omJE0cQhKocSBwQwAuWnSjjThx6cM4p2FChWdavlE7hygJmz3I9MQT26cNAq0UQ63NQHY7BBqlYvFaxBKsLyvnGrNx0qqQSLyfhrkfcCDHu5QEPzixL9mXHtK2fxtO5JQT1RsvU8/MrfHMRtmPYjk5t60kXHN66t/3RhAmmqulsaviykMIGMDj47LO4JSGUXnlBj20W18xaIcgSm5VJIYVcyXvdh5ue9pvgVBFtF4qjjIq5mob9/ilFnmBgXIayZpByH9bLqUkp7XbTOq35enYi4mCyzY4CHWTDMDUC80arppdvn6law4VoqyQK1P8C0zFT+wZGIVMA/21keQjU9klvp/UK55u1RruZBebZfNmQdCL2ZBUfEhQ1XrwSuqgkFBombUgDHEZICKCcQ1SaTpeKIjJMYVrKEBvC/QIEANxhUkD2VUNYwHTAcR/e3endTx91e/PoTv/1y7c665zrzZs3+um7n+z/Wy1TNIreSadTQJw770VhVDPxgkoAJ/oAxc4rH/v5Q987eBqYYZrFVCGdVqYY8lvZB2HJWCGn8UgiyUylPPIOIGRIWTN/pvu7vlMcSkVIQcFSkWmWewcZY8u9yWHgjZsQHTRuQ8g8IOEgz8h77WFj8Qy5hCsNeiNLHLLpokO0Hx6B8kiP4POULTwvYoSdDy4uTDsQ8YaDmaPLQogwGuqsQ9nZlWE4sN7Uveucc80rLaWPWQv0nSZHnJzIDiSUO3HAL5A619IxY8Bj+8TfBfQFHV92F6zfeNZXm0BQYrLM5JmakfxwuMKSPijhM9Fgk4Vp6JRplcg7OYXHjjZnLTPw0acWCyAXwNwUINi9TL28x7AnQ1QXHqiwVTHZyII+MMHkCmrUW1oRc3XylF3N526iz149d6N+e3ev+4eetYc07+yhM+y5bSTB+oYdMhyLim7vBtZ5O+yeBvCAJSSNw9ryqJBxy/nAWUluZaLzbk2p40b9x8jZro6RwhSdAuKihFvXRhnvzhM3JgkBFNZ8Zvyd8vm1zmo1VRtFpfP4q878fOzJSSVvc7XXaDL31P/y5XOf90Z5UBYs1xpHkdEpzn3eD4LMRxPyVXBD29m0A9Y2a4sj6SjzIBEjhswsfjoaE6cC25alKNec8417CreB3WUBPXKjqeF+53h2kAMkebzLNAZ8eZ6xQqasp4eRNes0kl6P4a6ViVSsFlRcEGxe+LKFkkmG7TdaGbpfdmg8gEzHGeQe+ayTOsLDL2PFpLiTBs5D225lVCzXNJ3gikPHxASaDbs276/A8SkyQKGRi0OVmBZCabXXYDTS49NQOzIQybUr1b1fQsvFQQFsWjhZReHAABwDLIm2CtskimKuRFeGy8xe5QqTJV0XzMrYBxU5cOwbeo8DDftIQWAUQgRKDJGiyXHSAxDqam+P1vvV2K4bpUpeZ92a4U66NIgrIBpE67Dz4e+gi23A/CKXDYgkE6lUwZ7sBAnn2LeEnEB+KEp8RnbANCdMTExwkJsglfAS22z5EKQyzlHkQMHwWSzJRyfoF8hv64eGTpiOazqaap7Z2jWIA4G9AFM+XaUp9aSLA1/zdxWyXsjzi8NpNyRjEbbaxoJnDsl6tazsV69cYHHlqbcxPIDExOAZpCkw33hhgH5oWGi0aFjOOm0NnqbOF4W5x+6Q3SJuNHSRHGj5UtfXjMaDgov+qpQt+VrlEeQjk4A4kiW6Cgp8ovTucOrOh/rw/kNgrS42fmmevXoRslO9b0Z+VPEE+v79R/3um+90++nBtoNA1ckm1jUMQoyg6/hhhl0w+8BGvXoKpT6ZyEexvXyRHQCXMx1NV3PFlpdkbVjNteU7tCGMkOAAe3y1ck5f54wk9qLu7j5qtYCUlOj62YX3W9PJSve3j7q9f1IqBRGHAl+w6cJiBrQGiQskwml/PlBpSCA4MJVgTGAizz5oGJEvgDRQbD59utFkNFcpX3U+JJaUFMrHQc+7P5qU9fra0zeQaLDQQ05R0hNGCXlgc5I8li58wHc81yAVjuvKZlysfV/TkKzYQfFOpPWLX35t0xIYyqlU2baCPNvoUyGl8dxstyR8yJo+/h1aPZ5xZF9JkvVnjCL+bybM2DGA7GDZQSWfz6MaDNC9RkPyU7eGQVttUmvYeVIoWWfQRAL5osELbGFcZSC8UMjG04mfZedfRqlg6B9DRsops9r4PIKUzTN3cd5WIZ/Vu/c/6t1PP2k6X/rM4hCH5MckVi1mDQMHQ4qwS+X7coiy2wa1AXrmXXShIJQa2zivliAl0lDgCxt7HwzqQ+zbEIZ3hJyGQgMhD/Zw7PeLOC6IgKAamIAgreH8dE4je3/svfC/Rqqz3YRA5R/f6a9/+zstZ0udn5+7ud9tNyGMHWeuh3v/MwLL80WM0I+2m5yvt9rsn4yIcT6BhDlYYslzyPnMd+O703QwkztC25Aqq5zdAW/rlDILnh/4CWh+I3NfuE4oIoCYg93iwQMS1pGce7bFXCy9u/c+mOeWaLs06BGDRjc4qn/JQjmeTLWFvZWSynmyHRnr0TqRG4c3JTpEDhF0kWDmIfMLRiqjNi9KPrtTjpuZY/oKX4Yvy2QC/ZuECiCb4O0Yu0sI0WEZ7fhCmVgvn71Qo3Wuu/ue7h77tjTiheXAJZcNuIXEAPZPQHmFPMv6ofdXIVS66JeZl46wXXZhPFjz5cziYfaR/R4d3cCwExMwHRI0+Waj5R0T5Aso3bhxDHtjT4Lo53Bief6qrRcvus415IWGZYcvKCHWpu07n43ii6lBKTD2mJ7Ry7kNxJQ5dL88sCZ3mvp8khps+IxjM1QDczdl6IXuKxQjonQgSoW4nQz7xSTS7adHrVfY6mU0goEJ6w+HFkWmkK/mU5M9EG+HQ1/WBuJUxP2iszSTUAcXFyDJz2bM3oMcj6pVSrb9inOwPtdazoO84Ij/q/+MzIkBmFGSoTjj0BSCjXkOmO5td7VKjBKE0N2wdOegoPvkM/LyMwHArAbeSRIQDPYxdPpoTD+b25MUcdDNzYN+//ufPD2zb6JLX+2Oun55pddvXhrJwBDiu+9/0O9//4ObOYoIMPye1JHkzvDkWbuhl6+enfbAOV1dX/ggfv/pRzVaZdX25RAI7UM+sa3fpw+flMRH1ZoNU+dhSzMpY8kFrMpLDjV+vS2qddY2sWi2nFsPmUoiuznRCTPNbWB7j2cuYsQxcf1pUigWEKJS6bwKUdZsbP5dYDQzOYEwBCtGnFE4LG10ncqoUW0o89nkPw67SQ4TmgLe49uHO79Pk+lY0ylepYjJQ+YhRZjiC7mJaYViyZ9NyPZXX30dzCkcHB3cmIDWuDYQzWzWIKzZCFZAq0iTy/PKyRuep8/3nPeDnephQ/RTUefdC6dl7M0GnRnJsG/tKVHDf/KRPW0gUNEkYJVJ8wLTmUM8k0XmArN0Zj0wO3OeLYoKdQI410k3xDvZOAMJAkTCtQjOJGuWZ7ZcSrRajX1II5nAQQYiV/B6Xunp/k7vfvxeo9FIUcy7GZy+TBiEPXzAKzerSi2ner1hrSt/LkYZ7OxMxCIBKIMBBRN7iMjj7+KaEeW3YSIlaBmp2pZ/H6musj1qyZ3EWMJNfip2oUfrie8qk2EIBadxSU5GAZBfgkeuIwELJT+f3373nW7u7y1xKlWrvo9kQ0K25DzARYpmCgJhnA4pKLUSTU9ekZsiYFqSX2iQQxISaIzzUfl+qdgRbFm0qI6NO2hHuosbbQKbw7DDIIDEZJmKlScwnc8CU93+uRA5gyGL9cpJOG9AWYB0QeQCrwa4FZ0m+t4vTOb5dPvonWGjWlGp0DRUyX6MzEYnhxP/QqeKpGEXSAwwvejmgLQyWR4AditctMT7OG404Zn3T4+GM5kcI3IWq2XM4UzkgLzL5JotFtXBgKBS9uTKy8EOjuW1pwjDJDjjbJWNCxquWCSj3ePBwWC9bK0bD1GpUHNOm/VQOFvMFnZtIE0kkHOgTEfuTPgGaLRqzbIqtbrzKW9v710oIYs4L25NXuFO68VChWxKV+fnyqbI4Ex0efHCkMNJcuQOCUs6oCcKD80CXTDFablaOLWE74Ijx967kuByxA/Awmg612Q/VSFbUBYWBxIE6jkbKQTJju4BlimpVg4pCRz849FCuUzdL/XNpwfDM1ubEZAMTtbO7gTrQAnfBFjd2tXEh/ZhijM/O9QwSfCZEU2j34TRyXWkwBOkzP1JH1IOq6a7RDPIM+DvwB6YfagLXmAwb9aMzCnv9IJpeHBqAX6mmJMxWa5CRecK8JKRqYf2c2UoDPN9drR4kHKtMV1gGmInSMFi+qe7bjbPlcuWna0HnEW8G9mzd3dD/fN//hca9EdaLhLNp+h/8z4Y0ThCBsBku1kv6+rq3PcKJxEOE/ZCHz5+UqJz73+OWJEdEt1j6/jjB0/pnYumiWwUSeLe+PfzyUprAomLRz17debmAdcTXFcK5VjzWceNAFIBGjHSVoAbYVfCxDzrYMuF1+VcxWKwN2xFIciYX0wB7L4R+IV4ITIWZ5ZEbGFmG33Yu6lCCP7Lr98azuZZ6/eHegSK7XPg78xuxiSikMMaDfIYyA87npUbZorXaDRWIUd/nLLp/WevZzS8BB6wW8NBl3s3nQTIjevIuw5xyezwDOkaqdOek+YbAl7KKwATTJBkMIGvNprOH3yP+T3sR8eTvtc+GaQRjtErWOoB6xHCip2OCrHqnYqudm2TO5BrccDX68VgOE/Dm2fyz5gl6iYQw4sikynuYPyzgz1egxQsc2p8kU8tAnkN2Je/n5D73dYxcxS1CoxaMkiZstGv4tYDRMgaYbNT72msbpfCCPN0r06npRIsXtjXO5jce213M603QQNIg4/rTbkOHJ52uHohk/M5NRyMtKXIEi3FOorw4sUuGKWfvF3rFYhKwNKhOYDBy6693io6S3hzWCudsE7bmp0PtPq5OMLkZXVBmtSH2xsXrq++fq3LZ0TtQZDh8+68L4UoSaEs5EDj8vYBXiVHQ6huLDI0dnkbsIDEbWxTmfLfw/Xnh2FpC1JATdlv3NilEIZzpqQgNkHMyXtHChmLv9vEMDukIS8JxE1WUQnQs637lkbmaF6/aKF86iNlCIJjvhQQAQ/ZHtGssKfbaDzueXFrVg1MGmjfhlpYGieq1YJ+kamOnQdCb5I4gIJY+s43M2URs+Osw2tFMK0CpRuqNAfGj+9v7MnJTa7V8CU8RcdsDzZRH/aGhrKGYzrxjFPriZThoUOjxIREygDOO/YbTLGwz4apjJf6DH1TkFqY9LNYOOmhWm15amGaY6KkSGJ3VSlDNjrYKgqGJdT+Zg1hLR6tMuGIqYCFOtrFs/Oqd6QUpOCGwQME3MkOKlHKLwETETpADpP4BIeSRL+1jrJebfi7cGhgQgxjjxeU6X46HboLxVO1VGj4s04nGxewyXJuyBsBOn8WcC/LeF5Enjn+HL4zHTnXlBeD78+hxgtttw3TqsO0wm3mAOKXd1/A38WC1nSrmaPJUzZ7SLAmDA4gfDamyGQXpmbYjrs8shT2tMEphO9u70YkRBueDyzMAlvNfzfyG4oBbRQCZkPcWH4trRllqgPKIQmC5oln58Xrt+q0LjVCd7uln8QViXOD3TcvNvpUTAKZqnBFgth1DOzhUjC8QD4EYgJ0k0uldPfwZAbz2VnX0hGYkBRt3Kg+vP9oHdz5+aVaZzRzwVmKP6v06srp9RSX5ZxUioPF9zwHzbMzSyfo0ieDpQq5oOV8eHowKGUnplNSPHZtR1V1ff1ctXp4BjjkIfJxTdxkmexFoaFJCR6nTrc5sNvPW9+YLpLnymTI+4kRCFA39yOtRrvi3XT3HLkVZJSVZsiDGHMspQrFnR01Vm48rx32zZOp98GNJgEDeRPsQBcgwuFwtdoHt6QszwvPMHC8JwIQIv7sAGUzlfqgygEd8b1pnKaaEk6N/CqK1W43zH72dTutAj4HlqMPXHJAJlhTFvT81ZUdj+4+3YXd4PGg5Wau9DSlFL7ROOCmgR8pWCT28O7X/Pwz3XCm7HGtwmjBDSqTGVupjf2ODadWgNVbJsBBljprtjSczxVnsXYM9p18T5rLYoGptKxqhfAGJiz+feTr1kwx1SNRwggBL1PeU64DrmDYHNIIsno6Bh9Zps5s2q5jFI5Rea7pONjCIWehKSzli/ZkrtdJ7kg0GQ7dsJDIRMMyGg0tpcMqj+4FouYYaJ+4QM4fm4iTHVtSejG3J+t6PVOlVdQvji/V6nZ1OGIJOVQ6SVnGAwQNrH+M0pY6sZ4rVZrKI/HiDYTIs2DfCTEHBUHOOaMUPK6R48JO6JJlWSAlCWcYGmt0szk30TxD3A8SV2y6kuEMKKpayWs47mm7gYELOxZIeen1DRKzL1ooZ2SGQYZYUdmBYhfKZzK2UXIiQprOKtFyFejO5tydvAW9EI/IP5t6L8AUCB0IdhbLb6AeOph6q65yraZKs+aD4PvvP5nODbYP3MCfBcRaJ57FsUxr7R6fzNKDWDMbz+zZaU/L1covYokdXEYaDcfq9yr+uw4JbhNHf35YVRQ8djMUgVy64IMaD1qEzbxI6TQ7g6yGg4Vfcv5uXkhuBCJ0u2nQEYk93069x7FGw5knq6c+zcNK5WpBZ9mga+RZB06CsUbH5sKUJvuSw4wJEbw5+DPSwVo+E6dVQQOnvEoFdINhj8iOIpeGAh1MGDjIO+1zF4z70ZP3MQQZF4tV3d4++sUKe9CZd48UAiLPqJQBYi4HplkBOQv3NeOpECjLBwNmBuxYIKywb7cbSXwyL6eIHVXIZJWG3RgF+It9M4e298VbQmA3JhBZYEwh24f8PZqNh/uRoiUZgaFg07kDEfF6OtH8lN+3Zs9XJiUg6B4hyTCRUvTYUfNh+Tsp+CHRPbCRgzQJJ57POsKgMUMCgr4RW7mL7rV3G/bsZTdUCPsfxPOYXJdrVRcCdh8cyB20c9WCGYzsJ/lBznR5ealu98LNGEWFSd0IhVl8TaMcJvvs9l5t8Gx0L+pm3O73VUcCzSYk4YSg26fe0IcbxYhmwNq4iGn8pdqtc203Ux0JC+dewJpGeL/nkMWfuKa04XyikwpGXqD1E+CNDSONAukQWBUC1b56da3zi05wlUHPluH9XtnpKqSOnFIkor1Zps1jzTFWNMjNWssHKz7HYYLE/QgGcc2QItwFUAkmsbvbW0N89sjJQHhDk7gL5iXE0zmsIKARjmNKFbRbHzQ6YOAAQ3puVAbWOE0ITF/uORAm+00fcpju2vYRG8WDmh3s9Y7qP/VCcDLPxh6DhhBzxvsEIY5nGd0i5xgNHKYNGA0QK7fWxmga7yvm5AwIMIlx8HHWIgx7CIyFvDIX53pdrmm+3unj3YPmi7UbsVKhoDJkwDSNfuLvUygRTRWC6Yn8yx1gLR9VSNKqR2Uz6GmI+TwgGGiuYdRmi7mgAceIolFSqVpykPOwjyUgzkBYzqFFr7oZogGFPHWAqY/pOcqCbNrFitVT57xrli3P+Y6QB0rQCSGEG2V7ujSNXVupVF2v3r7S5fMr5SsQxULGKNemkq8ofYz04w+ftFwdTADDOQcnKiZdGl72koNe3ylCEDJsZJDlXAoRgnwnp4hQeLyGYQ/PFFlwBBfnJnpOrj0ImZmvFM2UjIR89dVLTTFXOQbj9PUqeEHbsu/vWf/+DQwHEFHj4JLR7eNE949Df0H2Clw+Yn9a7RZjiT0+OYxIw6YD4qaarn3gAhCjFAyy7VwPZTeTdYZfs1NVpVG16Jt5O87n1Dg708VzHogQVvw5PuX+7t6m396r5MuaTRYa9iCvhK6H0GYOc/Y5qTShw4n2ppEP3P2SbUjyAMWBG4rYnSQLWK/ZfKQYd4dkbQPkTBbcG+gDiyUgCphzactk0BTx4uN4gjEBUBN7zAHBxKO+5QcIdq+fXVlHheyB6RGtmrs8e6oGvRufm5eeqsD1ZMl/YJqKge3ynnBY1vMZIfUES7OifThJmfj08UGVakOlYqIfvr/TTz++N6EEiKp5hj9iS816w8QJDkQkGlg6kZsJ9g/1npBoWKT8N0DBVRblLHQxrbFRd4hmgtJNF2t4JIUWNBRT9q/WbynsXel88Xak4XAMGAJ4NHkUj2PK6QKDp5GdepB+dDq8eBP/O2QpFh1jgUXxdbpFIEoF/RMZpDl/HAonkyeEEF5UCpUt2GrscXL69BFT+qniVN6as0CcImtyYo9V7ikdO+xFdt1MqLASQcjySFQypL7s7CqV3SIfmhj2xHTb+lDif+qBYALL+PXbl36Ra9WaYR528MDNqNpoxHipYV8yReZyZRUqIUUDeZT/jFJa1RqFjh320VPecr3wQYXzFIWSKYPAbSwEu2dtO7JQdIHFCVqnKIIe0Jlz+ABHwToEjmOPSSwa0CrT0OG4NaTm3RyG+BiYx1lNJsHT1iQSzLYzWU9KBAKDIsArgEFLkaB40sjSaPFMc2/cYGGekTr492WXfO9c4B8gVXHIewhDAOWgwQMdard47tD1ce3DOqJYrNnkH6chCHIU1HqNxrtp4T97cE4JzoRsFtE65w5aPJp2YGt8nwmDD+EINBA2qk8iQ+H3Nz0zpmcHUoOQWWV9FtUaDZ8nDAU8bEzI6SStwWLoHbCTbYRuEDSHpjfthCTOR6Dc80bLk+mf/+VvrTdFS84Dw+9bYEqRy2rObn6zVKNVVee8cZLQ+ITVIeFQD+HOOIFx9vAu8DmUyms6HXlSd46uCdchrYfrQIN+/fxCuSxRVzCMq0ZYgJrHo/De7yNg+BDkwDvV6w11CWq2Ao2aGqkgDmsygq0eTFqA3xlG+JYYyTx7+Vz1ds22m0DyPlNpFA4hkakBYz0FMz/nfTuNkN8DX6uDG3S+LTpmnnnYupzJ49nUCgdKdYwrEgxXogyzGVVKxRPjNWVWLKuE4A2dU4T7h4lkeb14cWUTCu9FT2x+plRgXxOXvmShdJeewiUn6Jq2q6UJAUw0nhZ5IaOUzZAJQ+UiYM/GheClNDPJEpGMViQ9IHS2K0NGzWpNxXpeSWqnYgWZR1rZKKff/PEfmdY/I1F7tbM2DXjA0N0x+lnvxgGITRF7GfuyplJKMR14EoHwEHaNCF95GfkuFKs5E0rrYOYiui2wfRhrUYxJ8cb/S+dHwcSMGQz/9Ztn3vfNSEaB9BJv/D3IpKxXg43b3d2jfvjxB7u0PHt16c681QILR6SPvIazkEMsdIZ0Skx+MOX4ThQwjJY5MKhCW1GAeenREMY68iAhpcmgPSzbkPnhbmBCynz+o7LZbyymZvqCgJSpBt/P5lldZ+2uLq+7flg40Fior+YU2Y9mndGNAzVzItNJ9ocjL+m9OysSunnUZo+Wb6fMFmbaXustnrQwlSP/3+wnHYFUKpulyA6BP5cDmaIL3Z5JAxjR47nbupAGEkT7EA8yuri4sMH0irT4XNP3gv8H9Ol4H9x3dNBqvtRyPfehhTtMoVjRebdrjS2HIfrGVWfhbE4mp3wBuDCjSpkGrWZkguJbKHRsiADTeTrvazGZe+p6+/q5JSz4hqIj41njF8gFEz/NVpIUHZW2Om4s4Wl1mt6X8F1BL3j22acCsxrX086NQEhSQfe4cbFg541I/nAAyk7U6UJQw5s2sIbHY8K6sfIDZp/4mfnph3e+3s9fXPqzAA+yR2MHRMMJWjEbjz1Re/9r3RnNUNhX4VtsObFHfA5YDk0+F5KVILXJr0OI9lGYvhdUQ06Ty2gwGfqZzmcKOuu2LfnB1SchMq8A5Fr0FGrTkTRRRzSZHPaBzQrDlP+/+QW9oTWXAf1nF44uODjyQJ5ir/jdtz8YxqMBBGoF2oYQ4uioVDiYgWd5frDOozGDActE7KIpmiNkUSk3A5wNZNqydjGoGMMyP4TCn06U36z1/tMHozBGdjATT2e0Tj6zwtMhtDiD8UTG6BbFERMG7j8oCPu8u6dBgApxwEnQP++12mL2cNQGuDipBJeYKFGxktV6XVQmD7oEYY73BlSB3WfIUCTPl+B2mNKGZTd414KIpLXx+UfKB+dTpHoTIlNKg0emw6UnZ84Z4Or9gT0oCBtDCD7FFet3WWPcPeA9vVO707FHLu8lTH8IgshXxrOJ9eOJcOdaasWfE+1PzWBAkw5rEMOMrp5dqNkBoeO7Ab9PXaQg2XBXrFFPVT2tM0lyL4tmipMFutCSYIs014DnBju8rHeVnMEhAYR3JpBAc0JOyP2EnU1DkfZUCaxtti4rvUOQUkFE/aKFckmyNBKQDZh54kMHmjMidXQ2DP5VXEnIKUTkrowa2YY7ath9HArY2rEU7qGrWq4NTQIRVHNlTRYjXV2fmUBDpAyFhL0mwtvheBn+LpwsdqELaTUaJrOsFlt7odKLE33FJOKdI9g0N32Hz+bU8o1qrWhDAMgh7EsqparSEebNKxcfU81TiXKFSPkiv4B8UnawZz8HnICnJpRyYCZ3gXO0jQWdX7U8UQ5GY90/3jqTEDeei4szNZtY99FRoxdySXBhAJKiUw8MP7r2gioFYsXyGg2ZdHD2GPmgurp8pk6rab9CJkpuOsVvn6AfW+ndBwJSd+6Igcg4XO35aRszCgYkjZ6DXR33Uwd+4pAgNkjq9bJaTpleYbwFmQz3iBeBYGBb2XG4MmJxICU76+v4/wMvT0YjMyYz2EbZmIFGhimJ3wstnF2ygZvAlt1S7IE+A4SSOS+oH001HjEp41iETpBpH3/JD+p2ScLgRS5aDgJsx8OOh+P2sLXp/XiK6fNCjWZbecz2U7wYOXXKwfTCu777R1XImbxq6fnLc7149Vp3d/ee5GrVtn768YOenj5qMYHgNdBohF6QOKzfGMJNc2DPp27WbCiw4wAOGq5RH30j/rtF7WsFKYfxBMzwlQ6rsCs0mQkiDUbutjrMudkAXjS0hf3cBh1hMBMo5JEqlH1Qs3Nt1Lb68adPlvOcd9p6eoQ0ttXHd5806LEvbatWr6leL7u7Br5NZ8NETzXksGeK4l12niAQZY6pphTIDqf9JpMgUCyH3D7BYBrHFOQakCcwDyj4nzGl/X9Y+68myfIs2w/brrUWoSNSluye6Zm5MAxB0IxGErgvBPhhaUbgjXwBCMMdfXu6u0SKyNDhWrsf4Yf2W9ujLj9A1lhZT1dnRbif8xd7r70ECEGTwiBftuFg4ukfKdLsd1bEkg6Wu+DQnSA2UAgOZebZkCw8Bgy4smjddknxR3Quni3opgz8vV7PD3moRZGFfN6NLnZtxyeMY/BjZezj8DSXJx0zYxEKGvYcGkyKHIUAk9uY4G+6scenB/17FDhAu8+DJ5GUCEL49dMHMX+vLi+s34ZklbXI0LwWNH8fjTHejyVno4CVsb06a1T7CONXNhmP5dxFegaXpIcruI4XqJBOlH3N84Sxj1yoVM0KBm/mGipknMW8c1cugTw+qxb7OeO+xsCUzBOI5GIPqSNX9mfelgVQEdxqHB0DpiTrFIMQ1jbnZpF4rir/f9GbkNlU2ux2u23bzbGtVtdOwMO5i8YkPtiOYhEIIrHfyoOZGTj2m+EmsHKhJn074yxg5/libaPpxDkAOCjhNXtIOOFsonlQM5DzKC4yiuUBfuiqmfeDijAWqZZJosJ6kPUJtO7rl/ORObKM8IGUg7UVMH7gKMvC9q2rQPMz6StelMBijsND7/UUdmi5ScYdUahWgSuYASArgG5O9YgYFzadchOXe3seDBSJpSqsVLBsGV/Eor16e2Fv31+J5g5BhYd8/4Cl19bCOKWEaipjmLUitqBvWm3U/bAIgiBr9XZLg3GXNiBryNpqnbJeHzP0Ix3gQEYImIEqwegRyIbhRnZcIjTUy6K70yHmCt6JStsZm3Rs6wVar5zMqxEAJwmWe0VV3lwYj4M7+Zaenh2JCfbm7ZlmQERbcegjfqdSBhJT9JNYnLE+E+J2DoTVgsozb7/8/Kv9p3/4BxFejvqXtlwE9vHDF0V3wR5DCgMbTzKUABZqQzAsJsNc0hcX+HMSYzOSbGKMv+jnaxU7hLr2u1373Q8/2NXFqayqFiX3XoUkApQNXAVzmWBYQEMyJluHOXImXbNytaJZzmK7tOH42TIxcVMldYVUwRyISt5A37TFKiynTUVXh45SriHbmUg79WrLwi3mFA8uA0nFIgRIHhDtlU+ayYV2nulbAHsQuBcrvTgQEQF96ubffxGdvVSpHzR7BB/jvlGUJSKIQC4TW61StZOzE3cwSkFs2VipwJyGuffU4pB3BYMRGH1jnz59ssuLc5kiEAHUatdsNCzYdDqyTqUulnMqjRn7ynVlwMxBYFEIFLj/jYhBt1It01FDBPHEBtYjnQYHC+YSjDaAhXluQXbjurEsBuwHaj2tfhIpkuivfvc7e/fq0ibTkV1//tWWs4VYfWh346hnhcKR5m2Y3x8dHR00uR42DFzGPtlslioicW/ioHtxgpIHZxZYrSIDCQgdQnK4yGXUj7XdTF2LmLQ7ih86bczP3biaiwCWZnVftna3ZaW6a4aRSjCPIv+Qw4p92G51tfZpP+eLrV3f3AvFwDYSJiWzf2aYb96+tueHoY1GE6tWvWvDPYZRwmQyVJSdrzm+g1uVFUpVEX/owgXfI18SKuW6wdVyrDBl5BVKOimnbB0sVGi3ui07C09ssZq7TKRasn0A+lBQ4IKyMnEPq1etWK4reuvx8dHG67U7mGFOvljYbDyRgw9FSquVdnIMbjmYwzODo9P87bRlHujAA2sGrSaIApF7fG6KTp6Vwo5XrrFEWiJZGTxKpenAO0iLeIQbEFa6uEhtd1nlXmICwSVaruKhTFdPqDRoFgjLxh4ef5Ed4Wo3V/FQrVesMnVWOu/47LynznE336oocE030g1mvjCrI0snzh9gjjqfb+32fmjPQ4orbnTXqnIxLta4RMUyLM9kAkmMcHaDQwATX/CqwhWcKc13ZG+yL9y7Om07orXyOd1DmCOgUMSqFPP8HbmBCojmUkxbpVJXw0R0GYXUV70oXfsEy8zJFMwd5LWXTSk0s9Ouiy3VbMC2hA1aVfcILEq8ic+LarZPx9owXFq9k66dX50ohLV/REDo0iZ4AE7nNp/CTIo9TFWEFajcJFw7wWWb/JcDxLAsyqes2oCs412PmFD5lF2+fuUZhvtIG7SWr9uvv37yjLrEbIckI5uy3qtzEQKiBGmIOzygPZKnB9VpBv/U/SE9ADPdvbXasGgPBs+u0VU3TOf5V3/9o129OrN0BsnCXP/pJANgSw47hxo97ojfl7HdOrLFfG6Pj0O7vbm3n3/+RYP4P/zuG0vvc/bnP/9knz9da0bD/Ab7Ni5Zxy4hy8ACg11clgyh1ePzFa3aPBHbczRmoyW2WYU2DCeCAtuttp2e9CS3wNFlPH6WvydRUJk81fbWsjFG2Dh0xHK2aPVgG6cEh8TpRJKdE2kKs1aueWC2FqWo8BQJXv1z+SghopBXVczBxWGHuTts0104lRwA2RCSDvw2lUMahyKMyMwiwcdyc+juQQ0aNh0R3Vayk9Nze3qEEbmycqWhjta9U0lsaFouC8e1Zc1aw5oNQrdDGw0fLAiWkgPhL4pZO+Lt56fJgcFtikqCmAJxAf0jNmtElOFPiWkAzMVdsNKaz2bRaTnxjA6RGTk2WqynTOKWbBzQwJAibYlAk7FMkYIgZRFSGZJOMhmxy0ELOFCoqleLQCiGTKEj2IwzOz3uWcpqtmg1LJ1qHgJys9LwAamD0HDxMXKoFZC8cKEldn83EFTGHsIPmYAeKnJgLKXMK4HF7RW5zLCa5LKkS5U5R7zTfJB8RSQsuKwwSqCS592CzKC0BmKnSJbJRoOItqbGBUgHIJSA4nCo8j0Zs2Azd/tlaM+DiebMFMW9fkOMcfYOm5aILYKg2Xd0YMyYIaNgbMAMHyIM643vDZJChwfUGEgXSQfkSIWyObFOrBTsgjkWPrpr/86n530rV53Yd3zck+UlHsfM6CnsWPPL8UI/++T4WByKDZcSsXy7SHIRZsOsDZCf1WJpZDg06w3rdPG8ntvjE7m7oBKBRTobkDY5tOpaYLrySG5ErkOGuEK+Z8blInKjSmmEwpnEJZBG367ZHHbxXJQbfQfWGeYm+TzIF+EPZScpkb4jVjrciaw9Pw3tl4+/Sje7jVYKl2hj4g7fAB31wcuYfSXJ6iG6iN8P3J8vcVak5RUtkqG3wocRgzdUuszYE/wnLFf2Q7NptTL7x89uBVQkzMyZNfuMHTUA/w7npohAZQ8sh3tSqBR0/rsG0/W0ns8bidXMCA77PDUjzO8TN4IHgv+qFyXVES4jGbmSRC63kKEuNO+8vX51au/fvXGT3SjUfI3qh5fJxhK1Px3bq/eXVm/WPOy5XtKiZxiepPzi63U7NpsQf5JYv9v/jX1GJcgD0JwnguxDHA06JtfNpLNNtdq8SKACKj8GyOQDgt9DqEDUCzSCuJiNyUXOGvKLpSUWJSJ1YFYOtDQLVindDHy93sPaShTnPdALhAOCXkm1cJssiBTf//DOvv/xreagHAach0g8FOPFdwFOywCfQOVnAWK7lLXxeGYff/1iHz58kaaPC/Xbb763fL5s/+v/+r/b09OD/Ay5XKFv9/snqsaZpyDUlxC/XRcxBdgY4irdNIG6Ij9suM2puIuHLg9zBkKIV+6IARRYJLSVomhpz8NHsVrL2YqlMhV5O0LSwvFIieTRRi4fdK+E98p6L4a2jcg3PlSMZJV6ZqR3Kng5UmniFbu3IsYMScam44WExXQIoAbEG/Gz6ay5YJnfiVIPSQIkY0/AMh1WSnFDGItfXL2yp6c/StcIFgsxAj9P3hcVKHNtclCzWQ4gbMP4jFTjtcPPNjs/6+lSwNKOCwBtLYUJHr2X253VWkVbbSF0ZaxaPhY5iu6XApKNTBfCgcTBxBwJNEUuLoi7iwRgY9S909ril5bSUNvJP6WbzMgQnugmCggCzkWA3iOQx+TDDRZgegLn4t7Tabk7EFl/QLuw+pjDsJ6Z38L2JmcTFKFAlqJhhbiyP/75LzIjZ7/99R9+tMuLnqVEqHFWMsQVLnDgdN4bNo58dkgdnrJBJ8UcsCyIHg9VOk4uRpiIENzo6lhUFKWD55HkM7Ad+Tw0W8wHcdUBNtSaSLGXE8G3+DmnUltdnBxyGEzQHXKAd1rMFkGysOijI+Vd0v2WnJyikHZ2rju/pNPMY4tWLNBRuXaUWTt7VedkOrFqAyQJrR1FAMkjTdc6w+7Ey/j4SJAfs2a+F3NcEIliHi1k2h5vb+3m5tHSOc4HCFQUDuGh2/JwagpCYFu+K81Ep9WwtQwWmNEVD12Sz2w57+j+mblSgUNSZN+xxkDucI3ic8Jmx6ATPgjNEd2jzhsuT8HtmpRojiwyS6lkxUJdcDzQOzNqyVUoVLexXV9/scHzULNq1g9oVk1G4rCcnaBHoUHTQRfLrJq/hQzgv70Et4+VQMS/u1hOZOhOp86dMZ67Jegan+AD9FoueLrH0/OzVfIFeX/jKibZGm5wXL0pvJGdVMY8k2aGggYbSkZ/wOT8Hi4/SbgyKRGagAJ5ptwpjKXarYIjiYuJwjOAb7/qRXl+diwCCHRmFiciZLRCQEhUO8zPYI1ia7TlEN0SmomQ1S3guPAYUvfPvELRQy9gZ8RiJDMN7R6bJ9FB7Xodqm40kCURXDhIgGVF0TYcgJCiQH2GmYpQzHPufDCNTyjdDHmPc1WNdE9cGDAImRPUqrBWu0oswUYP4S2bV3IGMuH2mLBD7HlxwXHWphNTfBZoAf6wLPaC8HEu27fvL0UYgdVbyRYtUC6wi/SRY7BYdzij7DFyZ7gd2tPjk/30p092d4ONG9AZRuOnciF5fnrWrBI9GxZZ5XLNjqBv4ytZyFq/2hIUTAJ8CTu3TGJNdbslsb74HcDIVGlcpkDBEC163ZaIRsB4zKfkzo9+rlyUd25oaMNwySkKeuHZ4O0Kq1nFEIzMJGXFgAIDliMHletBWQPAy0DhdGZs1BeomcsUdxSgN2j5cvwvQxSDscn/BnGqrLQO0AM0ZQTDMoPhgMYjl1kVlSk6OchiYYRtH96W0MKBu2YikDCDWC09mYLiC6iG/p0TBNce/h02IVq0F5s9ZpJUnmg9gcSBc4HeKSo6x1UxtKNd11LyqkX7yWbk4JX+WVU/lTqBpLnM1pI8kDRMy6YKNiBSDnrJXSB2hFjNQdOHJMFFiVF3XWudQkMmDAmfLf+b8xJ7i//8Uru1UvGtFemSUszYmi5PKLnAn72z2qzUxQI/Ant9+Hhnd7dDm8Jo3c91GbWaFYv3kGR4B3SFPt8REWiJ7GomdykOYJAAviuSJMwErq+fbEyYbqejw15pHoju0cWm6XDIWaUwncj8AqMKrPfUFQCtoyle7VR41mtN1wev6V7Q3VJsrNS9F8tcKHQ+yNCWVqtikm8amSDd0Ux2D5nkJYjYxxvMQyncuNyyWZelyDt2t/ICNu0zdEw8gOX4rqvNUpcojFpm23w29KGgLmizw1Ugrel8vLBfP/1iD3fPFu72YtCKSEnBiE/p2klfuriivQhYQIR0pKcnR7Zd4YeLvpb9i0NPWe5MXEacXZgRlGLv/mC/A7urCQnJ9iwoyxSTeLghUbK3x2fsDVOSrCEpExKXS2y7G8ssZV8zycsarabOQgxfpjMyRSE9eo4n+xIt5HfffG/f//hO0DLSJsh6eh87jFzQfzNLQlKyExFykhAMgY9txapFzlhGdkDUC0tn6dovbB2mbDT5fNCpkxHKeAKHJE8L4fOC+7BX4FSwofhz7mmMMXta8VnwAIN9KJifc7+Sqfh8ko6TUHbmq/OZ5SFhYnoSkZpSsKMj5qx4Ga+cfCe7z694Ub7/5rWEvRw20JA5ZBv1plIZNJfYRfZ0P9BhzEXng2RmZzjRpMSGPXt3pGp7Fy0PsGlVzDRdkJmMO8QkobIfPbAVdmJByQNYmkEXNoMQREQNVWhJ8xKxRzNE0rjIX38lLjwFxpLoGRr7ZiV9HF1G/7ihBAwuL8gjm4B/DrTHwY31HJ6SjrFzOfDg3SLLD/YX2IzqNY6zklTQbb55Q8dctnI1b/slcFKkaDIRJYK9KOE498uBI4SsM7OH+4l9uX6w+9uRDHw5hKi0+id9K9UK1rSKnZxhwpDYckWnRR4gQ/xADkdo3rgwqbzdegNo2J2FuPgwKbi87NrTbcuicGK9ftPevn1lb9+81sUwGU/s6WFpX+6uxTQ9OupbpZ6zcv2VBQk5f1C5U3Z/92i2cJIQF7AIILulTJ7LzaqKI7xhc6WSzCnoDBEpUxjo4Dqk14sQluBtW1RqABU7l3GlXrLpcmyd5pmSVoC6S0V3RYFsAJmFf0fsRCCw7VJ6T145xAoKMSAzNgKBym7CsFJHSLRSpcqhwUUDS9eDxmFAQnAg2YI1ye6ma62VPRlmOpxau0GkHFE9U7u5i+3bb98IEiZ1RQXhKrBapWQJ7NYMHa9flBRDCLNx2pHheoQXKAnzBOOa7ZhJRhhqoO0iOBl3pIrkNHhRphD1C4KjyyFOrirEAK9MpKBcQotVZNe3A8sXIbttrddBHC+Fh571cMQscSLmIozV58HSxhPE3aRGeL4l8zJR9XMQyzCNKMuyjYMF4gsKoHq9beEukOsOHREkvWqvbZtdykbDqQ1HM+sdnQuRuL17lI6tqIBcRhyYctQloQL25+cs5zNdDq12W6JxNNVYnGJ1Vy5V7f5moqQUFX3Ngo2OpnZ8WrcS2YPZnK3mSxkUMDYhkonDUUgDDHHckTgwZcThxgMcpnTt3rnDqgbFoZnE7II/4u4/khkpdN01eeQ8Ij05Oj1xByp1iW5Mkd1kbPW4sG20tRRkrAiLyJ0u3EwaTSfnCZ+Foh5PRQ+e55yiiKCY35fy6tjxUU6xfvJmpydddXx//umzCuNXr9/Ycb/vpvOa32N/x8ULEQj2fFp8jSWX8hYiVdp2q5H1Ox35cAMv5rIUoks1Fssk0LkMIYp9xl2DNIj9RDJMtZ5VsdzqVGRXWCg5KgTbHGJMtF9boVR2CWC4tWmysuvrz3bUJ+ILG8yS5UtlW0d7K5TLViJxZRNatVmVew+XeV5uWUhDmG0S/p51SV/Ku1+OV84ZvTqpC+TuYCn02ORIAvfuYytl3VuaLpsRGRrlMESnmqhpY6+XSzhEpazf6UkOF4dbuSrxc9GAf9WL8uLyRIer2moFfQY2GY3t4X4ger2HYuJo4pEyHBadflPwF9FFHUS+pOpABEtnNcuEQs1Cp3pSygbp6ySAt+rW6/Xcm1ICPmjFoWZFfLlckYXqdrLMBUm0ZkFGONArsNct9PAbBcKgmgBqhSHHxchcU0JjseO4cJ1k4MxTN3Xnc+j/USKDE4j4Th4GzOEVKYgWEXSFrs3SqpKrtRNVuVhq8Wc4wDVbQUAsb1egSQ7Eum3RdoZr0d7xIx0N6IKAEisi1/SOm9Y9qtv5ZcOKedh1YyussIwDWort4vTYLs56ovnTPXEosEnogHk/YikC5WSzdnrWs7//b35v335/ao0miRy4gdTkt5pKNVWhjkYjmy1mIm+cnvXtTeUCjqpMH0bDhYyPoeWLcDLPWbffUFeJSBnYDW0q4B5zRIoMdyxxeMu1tL6QNTvaASX53xQs9VpLAms6Vwnaq8z4vNJncyuDdFuzZoYki5zQCObJmCGQdsKs9tWrC/cAFYPZoak4Wmk9cDnX6i+HqfsD838QILgkee8UHqwFZiAUfkBJHOrtdkNzNdyG9nv8aBd21Otqs81JztCwBpgLSN1j27hksvmKNj3flZkrsT7qfIRYeFbiZjNT14boXsHVZ9Xf3IkodiB8MOIgKABqPwcoMg0uYsgXEN2YE2Y2aHMD+Wxud0s7PTnRTPnh8cm+3H6x2XJjp6evJV8aj9c2n4KIcECXZZdGocK7wthDTle4N209lYbCjTHAfA5TkosL0lhaNo5hkrG721vLFyv6eeVqzc4vX9kYM3UISsogTEtOBUR4esyFgwnGQuL+1cqN7DmAl1mciPAxTYmsg7MP3UCl1PP5IJ8NI3W57sD6xvjc5VTLzdryymmEKJW1mGIRg/qQHE0ccPAcdk4Da4FLrULXA21fyJU/cxlNZCFUgWDx+amdIMlQ6HhwgMlkHneZinWO+0YmFZeN7XHAYkbMunUIFXE/p+xyC2qFI5nP1VototoqLnnb7ZQ1yfpK5SiOAiW9IGuaXN/bn/70i0xMzk+P5G5mvGfKYl1yFM+kEs0Fu4KE8fOYYY9SC6EyXA7ZLMb02PuRx5qx+8cnjX3Yd5hp0OxMZwPbK0CeP8e4BLu6nbWKLcsWOMN71j+Z2PMAQg6Ey0CGHyAdNEXM/GG985xLdTrlnU2HA/leF2BcpxP9eeannANIgUaDsQXrrVWKbngAL1vceOnH03pejP1owNgLATrfGAlIwZI03WVJaw7kkV1IZxrucd1yBImtWSqU7eL8yobDoY3HEL721qzXnCtxMHf5ahcl3d46QTvprCQWFJg51SKHCHAZcAYQJ5Anm7xTrmkIS1fFnA8WHZUtSRMcBsxT2GxQxkULplJtNNTWe3YhDy05uMhzqJKhxpypLkGvhNWHDEqYhsxL3Qx8q6pNODYJ6QeHG9pNWLIvZttsXA50LlWFiwbIDKBMVzRHwUECHJ2KW4NfQTe8cPcspRuj6gEIBoYiVkqJBjE5dzP3ryy4wwwblRnQcsHsMbZCDtJNw6Iwo7QGuugwoIrrCprGUaLXx18W1hsdWWCZeWjVWsY6/Z6IDlDHM2kw+b06OQ5/NJ0E1QLr0hlBlAAhwWf04tWpHR03RTHnGfEZXxJRjvrHkvQAbUIRLxSBWiEYeQrB+dml7aOs/fSXX+z29s6OSUZYQZKgcvMLT/aApL1ApAg9zFnzGMyRS1VtHOUvZnKWznOZQGAAxkbEvJS1GOYMywk6J1IfEu+2ditLTwPLlfZWbxWs3PCLnRkMG3mDHAYHIwXdZu3i8tiGQwhJOLzQIXd87hoDcRIyDryLkTKRTYQ15y06eEsqn28fWBglMrTgb+LRgPna3ZqV8xmXmJQrls9gfVi1ShFmt3emkK82VObjtYVRSr6yZD3yHNBTVrFxLJlQEg4YZnqwXZV3iLdszjev1uR+p2IARAJ3E6pmxgawbjP5jNysQEIanZK1O8DTaMryOnS4zLggsPUCAoel2mjgeuNyCNYoUDdOKRhhcGikKBhlrYiMyVm6yrYEGme+1mq79AOJE9KGTFpmBxQOTUmapkJ4gA57fQ71qjog8hv5d5C94GwlDa2xPlP2PISPMHOf3KRoQWGlKDrpotH7ZRnFQNqC6ME1TcHq/0wzb1IxYooOiD6cCZxW/LmUDOARxtPxEkkGOYp9w1lBg1cuYZNGUR1ZrVJRQhKfHwYvHRiFNWxbzhvGCnAayL6t1mtiFqPBq5DDaVgBEta+sSzdHg4xB0Yn5026RJ/rOnJMHiCWMaZi/e9jPHv3iuAKl1urtWDkzyyjMPCGlYeErAN9T3X5VcpZOzlpW53Q7SSx4WSs2R4jEDJos+irU6TWbGz1NBZZUcHKraZlCYkoV5XehD46n8N9q2BVgql3EGaKdn5SV9dH/m6UwD/ATIHiK9C5cvnqjc1moc3GoCAba7Uq9td/+M66/arNpk+22S5stppbq9ORbAvCWG1PA8V4DG5F007OjoTw0HnPpibki+ZDlyHoFDP2o45QQFk/QrraeLwWjQoFWbQmvg8iVmLZFecPKUJ5azKKqVQ0Q6VrZg2/2Brerm9tiowN6RljASQ10VfuKIFNgAnB6KG6U1Eik5D+JZPWS+Ol8EVf98kiLAse3G7IFSxJUlCp13SB4QQDe4+LjvYYPRrVFzZiipjhIlN9wMA51Galm0NXR4Wq7iTHBcyAN22VtGeKOWEE7gMPq/hb7BHtNRXPi1ZHrDz8EvGulam7ogyEpzdwz6Ez42CTOS+apqUuAuagfM6X7hIYdRosxEKkc1WXmmL2RuQW4nWvVgRRRMzXgHdz7gAU89/dtBjpwukZ+jdIMadK8yD+qNliiI4OjJ9bUFfITA4MXwYKIfFNOfm+YtwNw49Xug/4M86kheSyp/RMEi0g2cKRJypvKDexZg4G5IgHrwJ+I7o/ICJ0mPz8ti5zrPG2V6FdX1/LwUXRZmUG5+i/tpZZ+4HPISHHDdSJQWSL2dphFDLxmEmGUL39WdI9BruMIGV8TYHox4NbW21i93mlI0BThf4Vw3MQLN5fEvvhnnJtrcPSJKBk1SHyc7FL5FnSoSPPsRRzYSpl7Pf33ulC6iDINtjpckywN7SULZdIMKY2nS7s+WlmxdLQXu8vrJ1hvlMRKxvfSF5squF7BCgJo/Pldqcg4TE+u3O8JSGm4PBStVdvMFGA8p4T7Z0ZMG+LvFV8gYkJkm6Q4qaMFV7ZiRUxM1RPoO/1e9btDmVSQQdLd3JxcWSlIro85xHwPlkjJ6cnghIpXmBHrjNEvoVyUEGjeXTcEVmDd0YhyvuTcP8w5+OQSbJkLGaF6BD9BUOTNVPOZkQE4xkzx+J3ckBxcV5enqh7BNkaETvFiCPcqVsj1gySynA0t8XMDRZms8Dmi8iOjk6t1WwLrof1vN9nxYco10oW7ZeSOzBmUJHJ2RCGMu33jhCGJOiTPoplSjmdU1g7PtyNVKzyXZGNKcqL/yPNhEIki1MQlmnsrr2gXS5bmL0gW+MRMiYIfEVBu6xF/q6Vm7rEC6WlMi4hiNC1iqHJWYODV5y3SgN7PjpgXI/M8iUkKlzEO2n68B0djp79rMubnqFcb9CebwgKwLx8JYlYqYQrWFlnIEX8gp9brsuVSOQj9v02sMHzs575YDiyaXtu3757a/li2aaLOxEAuWzhQyBHo4isVvEYZv4PDJqV4J9zdBeE9vw0sA+fH62Ub9n5+YWVCmiS75XKwuVHBmmSYIlHk1KwXbhxEmY2Lb4AYzqIlaAu77+9UmGwnJDNi6cyMH1eJglYjB71e1IggPZwGa93K0HhIA9CijL+nnPpxII40aXLvijVKUwgRTmcTdGOhAx+B++ZonCDWTyetUWP6aqWq1/3ony4u7e7u0fhydlc0WrVproJsTrTax1Oe9vZxWXfas2y7VN0E3urFcvS8nkyd2LjIS/PfUOpnDksgCkI6x1HIz0ovqAGuHSSCg+OVS2x0V9SJUiL4CLjxMd7VDqkBLYXEEfp8LBityvCDAUI9UAXhrHKYgCu5Z8LKiu4KTeXJ7pAMeMEvbiHqTrlA5HBGaMcuKahPPMceQxiQM1yBT+HLr7zA9KjqHyekKFqNypJwlCBtSDkpOzoBFPkjJ2dn+lwxIOTw9L9GJmZVaxS7eqCYMZJ55yCsAT8Rgp8CG2f4GFo6nRYiH/poKCfE5SN3pPLyjVI+cNh5wn2SC629vQ4UOVKITBCclGtyIOUapMNxfM+Oe3bu/dvJHfhAMPhBt9M0DA2syjZASxkmIOkP+R0UG2WHkQt79es6UAJ0/x5aOCwTx3u5pCBAQ3jFSNsIP1dkJO7BlALLHg6EQb7wHEu1iaVgk4oUFXMM4M0UccvNONpFFSXPGcZhWutJLrsSVtxZmDWiqTO71JWKtTkVMR3558DCbNeKUMwqei2ugo6/vzxgyzd0m8yiieDbIlhAtD4eDi34XBu0/nWFkQzJWmFgMN8zGbrmr0zl2G9sf6RX633W81MKWx4Rp06Qu2q+8fuzQajsf30p1sLtu5QkssBXxGTxLwW7W2gTMUoydl2tVT3c3QMcxzmNykiFVutH4VO0OP0jk4kh+G/Qzhhj1LkCZnAlk8ezWnBohSzGBpQXzXrde3bxXym7gfuAnKcag2yEpc93SAklrVYxaxjyHLAeSoCSJ/fZmw6ebT1KlYHt1hP7e5+ID9lZpt0FZiw+3p7JetI9phSiihUgfqEWngEHd0blR9kLi5Jlx+46xOXEZIruk0Y2dj9/c1f/84lFwQClzyDlXQVSlAuOeLxuCAJNqaIW2933o1aWof8eDSW2QDBybtVrFQf9IDNFobyyONwJErpgAfBwDTckqPf2M2wibnknocjKxXRV9bE65ivJhZaKOs81r7kT/xsiG3M6cgY3UJE4gz1dCGKUhWLBJRHmDDQXDAyGavr57mBWlxdJrYLnagFRAlaUyVwHmZyGNtitbHsLC35U7mWFfrh4el5hZsv5x/sL18+W6vVt7OTU/v9X/9oKYpPKR/qVm9eWGdZ176D+Mb5i8SGSx/XIRA+zsz+MRaiiW0adXXfq/nWyvmK8oAx0qAAYP8z0gAx2cXBgdRGcgz2gs5Z4Gdg68ioAYUDcC5nv5+3eBa7Lv358UH/PkUf9wzoG2dmah/I4OWrXpS4lDw+PHtSfalqUeR6ncWKyisUgaVazys3jL8RdyNO50tT/bDonp6e5UvIIc1AXnh/4gszke0ZXRpdYMoHsVR4WE1Byz449LsEg7wx5knezSpsdO8EGxfPFnTpuM7nAK0CsXDpslm2VHF+mTLv0r9L5ycx7dIp+fRkOU7QRHMRz8ULMUoS3MLcApIInSKzJToVfo5mGaTZEFcVQKnG3iovzRdx3Fw6GHfz88S+gzm6j6zTqbmjSruuy4LDC29M4ozAl4ExMnugpK0PtvcOSWOXhl3X02Boj/ckeavJ+S2PcLdbCfsHzo2p8sj6ZAaYeJeHHyYkkMV8Y3cPD/bw8KTDm5glOlDsrtB0qghB9Lyc2nffv5WOjYXKXA8z75dQZg4xYF63SqPDKVoUpOQ0FOw8CgnIOHeRt06haiGQeeQQLUULvwOYdLOKrVCpWyZb1qYrFimG8Df1wgc3DxipzqzeyaEJmU6KuQTPaRvZzZd7WXHhx2ppOhFIKcxqgKj4fXSiVLHINhB8e6oLlwbyHJ4vsxmqYdYWs8Fup2/L2dL+/O+/2N3tjb2+uBCCwWfiUN0s0QUSP8emN+ny5pOVLpxUEtvzw5MVC3tJGboYQ7cgpwFj7bQucHmhkCTXLyLNArNyc8s3iFM3N882GW1tOtroPTebWR3qFDb5XGDF044Kg9V2ZSUKvbWntWB0IfQAh6w6ZJ2ivf/mldUbJVtuFlbJ5ARRA9USEcYL57KCgSvZbxTpOXqXUZarFmhBv9+xsyIwclX0e2bJm2Rv08nYgu2ZCqjB8FlZhLCtmWshygfSfnwcqbgDCZHlonR6z/b27Vvr9zr2+HhjtWbJimXPcGWvIvFgj4HSkBaky5EgYHx0hTLUdBGhnRVywixR6SYdQbkkSPjoxNMltBfYuxH+uwT6UmjR6SGHoQECcSlYOoxsMiXLER6Dew5zakxmK1vPcchKlNMIu3OP7R7QKxcxJCtUyBFhwwVdfqwT3jVdHRpzs4XVak1dSDjiCOE5jIUQ3MPXQJuFuw/w+wuhjZGFZ+7ymV08n04F+tmMgiA8YjTCFyasYjKdW6PZtA7z9TIaXUwRGuqcQee2y40kHMjWODMUQoFzTpZUIcZDSHSmNhg8aTbc7b/1giXeisgm6YjC0LNWDHxuS+EKx4SzlHkwJCtnp6ctneSsf9SyTRk/aHKBY1vNSSnZ2uLJQwK46HfEa9F4pQru/KZIOkhFgVQJvCPm/lHiUhLQEAomEFC4BhRTQOygNch1mI1SzFOAzifLr3tRgrVTDVNd8cBXa/LiSrIOgwDAwy1Xic5i9rWwYqVlNdiCcrSHUJKTdmijYT1VFQbKvqCpPDm8pPtRhJODixAsXM/qMhE6TJxd+IfEP/HlMxz0iqrySCpmisBvUMxfqOlYMSmAFag2kxGNnUuNbpFqT1oqBKoMfsvM/YBqXVfoOizgGSritE2m0PKBQ+kk6/4Ctm5FxeUJPIUYmz8vr0pYXKvQJpOBqkkIT1SB3p84IUlhvp2mUlUkjJUQG0gK56GcpCkcdpkkK4o/lWepiBQnstFwaZ8/3dn/9v/9J3u4HVmj3rNaFXp55RDymli307Z0UhKkyj+Lg1h6vUwGtuPeOp2eLkWqVzYv3bB39Tkbjx+cxJEy61famiNMZ2O7et2TCBwyipu8+zrhQgBeXm22NhktzfZrsXmh/1N14sgzn01U6cHwhMFpBC5zqANjprz7KJUDaygmiyy9uc2WC8GnGCf0+FkkYexT6kZWq8BuPt/Z+dlrvZf9finnD/Im42gqHR/aUhmiJ8xEMUNIXOycAaKhCgU+jnVBX396EITIfIZOFZIFXsV0Tvf3j/brL7/a4PFZF93V1RsJtf/8p5/1vUQkiTM2Gy9kg7decnmu1JXlt6AjWHLVLJsq2GaBVCdr6X1Rfw54EAgbMpvYsiWQCmBm0Je89bqndnk5tfHwL4LCKZDEZktIvYdIQqeYkhRrPnc4fDanu15btdJW8gYC+JPTnorP84u+iBXVOtrZorrZ8WjkJI0s80qKRIozfldWqSPsG5l/J3ur1mrWKJctW0DORboGpIvQPn8eaYZJEQMprN/v2Xw2UmfT7SGxwHj7F7u5ubNy2a3vcpm8yBr8/vfvX9ur15f2+csvsliM9ti2udwooCONI0mh5O/KhZdHH7lS16QLEws3+AY4s2SydvX6zAo55sh0zhuHC1s1EeCYxcIYRSYgQl7FL0L2OgUXkLyMNQTVUwB6kDgjAGbgQNHBhvKZAJ6Mfjdrnz+fZEqW53JBKxnC7oZ8ApMY5jNM76okDaPhyCbTlVUbVXv7zWtrYZEZEAHms04uQqBmxj3aa0C6wKM0CTDp5We3tfWCQHYIkVzwuEDVFPSOHhGy09PT0F69utJeb7VbFoRu6i5isgInigcdMLrpnXghfLMo5EwHmcLXuGrv3p0oWGI8ebI4Xttl+VgkMhok+A+MTXIFZtBYny4lRaEACRP3OqaYZqw0S5ZWb1YtCme2nM31HMUcyWVtvYxshSyHc0jRduhPs5KH8FlxhaKTZP0ihalW8Nn1VCZmy8w3J5NYY7NysaJGBeMLYH3GiDRX9Socka9sYYd2jzih7fb+oF9E2O9p5Ahv0cMUCyXLFxzK7PWObM2QNQpsOp5K2MxhQ7gmi5KKTQGbVD7AEXIrAT7BRowkAGBFt9PKK58RiIoLA2kFGxjNHrALkwZovnl5ykIYWW0gUmAvx2FBgklOTDqG6HJMgQSCpVVIFeYp8e7LzabzGanHMwFreQfLnBOiTL3RErmFjDfo1QpVhgIeOcOPRYrJMtAALNHPnz5Jz8PPYZYE1OOpG+5QQ6dSI+6Jbppg3tCZqjKD3jNziA9dfEluOcVSw0Jg3wyxXu4juloCvUK8SGw8XlgmXbFgxwbyTELml2GYEiQrSDr2WRSHIybaMBLznbx98807zQrQ8rm+DKYhs2GkL6TAM88qyF9xuZwZNQtkjfVmYavlXIsRZiJ+rlxSdDm//vTF7u/Glk4RrIo5fNvGg7UlkUccvXt/rm5kshirowM6AdJVNFiVYNm01RoV+YqORlP7y19+sXQ2tu++f2VhwKVclFlDmTDuHBc3tHOYki0rF/eqwplD082UJny2jDLy5BCUr2lDcXhS7CALIqaNjoSMSRIVWC+sG2Y4dPWfP3yx2YxDAz0eKRd9ueCQmYoJQ7NR9YupWrViqWbr9Y2cfyj9dkFJULi8XPfYj5lNxytJBSbjjU3GmAXkBOVTvYN+5DMFT65YOfpA0HFR4czu6sSzZh/AhqSKBl5ivXT7PXXG0/mz9gdrVJddtSrLQmbjpOKgK+SyAUmhMCsX8V/FcBziBOvbc1vd/YsgOYZ/pNjk9bnouCG1yLYuTtl8OrZ8NiNorogF4Hop6Uwu03YiFXKMdMaTauiEFksrtEE2WKM7K9P272N79+17G42/s6tXJ2J/7oKlRhmQd/jvqTSz86rY3aA0kKhglbJXId20m8Du7CeSKMqSneCTzPlUreVUdMFGh9nLg6ZrwmuVOaMYymu+T2QZcjKDrU3nU51rVfx22z2r1wr2/DgUh4C9gB4Y9ySCmpGPZAoNC4HAg41VmZuVciLYTBdTdV8gVc12w968f2dB9MG229hmi5V9+HBt3WVHJhh0d3SGFJXAvhTtvHfxJzS2AnmDQJSyaqFkAGB0ccDyZaw8o5Td3t54ekwuK5/nD7/+Yj/+/ls7vzy165sbSV8orEFn0GHOV1M7Tje07mXMgbmKuacsM1JIY1xy2EJGe5yKctbq1Gy+ZI7PGIPkktBqlYJFSd6qhbw1WlxIgWwagWDxyeZneWdJV9nRJRgUIZik7eb20eZIDhWpR6HvlpTsU1Jz5PKVhQ+xsTSSqnrf6k3IVwubzRPXVYceEs5zo6uWr2vTO3Wcuzzkfqc82f/r17woz07PLQjoiJYWRO5WouzDfsctsnSIF+30rK15G2QFhrgSpYfkjU1sJ0/WjcgSwBm6YCTip5sjVikvSNUlFc5oZMjNIS0oj3gpkiKWWG+5euPF4YZA6fliqKqYjgySRqtdV3oG3RWdJpAiIlYeoGQTOZirzHqQInDwIXsBPoWBhVCd1BAsqejucOgnQxI92UpWTwjKIXDAlQH+E8SlLMK1fiadF3BUrdYQjAMZiBfPnASvTYWTKu8PwlFWUJZ/J3I+XWzPBud/SyDYADfsYNWV7PPnO30+LuTTkwu7749sOETTiN5vIaF/sVrSQv9yfWufPt5owA9sxndBa0S1//2P7w92c7y/gsKngc1ZaLkMw/6OoFLBjgztW1VlJjZbJVVwDNy9Q2Z2CFTu9Hxs5iBAMPsEIhRzLV5YFKUPId9j/Xlmj6fnXdHUR5Ox7ULX2BIizGG2j5lPuhCaDmX1CbP4QBc8nRlEISjwOC6xJnH04cJjTUljG8FaJuSXSKyyNWFVg2jkYrGzWRPyLVanGakYQbYAE/jq6kICZYy5P3z4YB8+fFQBQCcP8Ys9ATnl/v5GhRSSArpfaOgk7RQLNZlZEBwbJg6NsZ6GgtvS1uv25bs62axtOIAxi/ECaQcVVfVcZhR7/MUBOdtDXIHNt7BMNhKcXiT0OrWzZqsl43jmsKAvuiQI55Z9Hk42ORUMgqGYZVaZAWYPIvJYc8xsISuCkkpP9gAOPStMCDCuBxbE7YU5Yfmgk06LeQgaIMkH45BMYpfnJ3Z+caKUEaB5vEPZ50ge3N5tY7V6Q5FqD8FIrlKwVtmLir3LkvHYtP/+v//v5NXJAYgW0ef7xPaBQuDDi/PO7hAGX9RFhDwC2RMQG4UCNnzrzUzWdph/k/85GQGF++xQGbBKF2KMkzvM+HGf4qI0q1cqYkmCdGECzllzIB5msQAA5MxJREFUWqQ7cVawa4SHHsIs2BFZSaycx9liYtli04r7jO02a/9M65WSkEhYwdQChvDV6yu7vn6wcAliAiN1LDQLYuHxcV9/t7sdaUijYPNbig8XDWcYYROVIhaTfg6izyZsGi4HNoZrgoyxj9xt7fn50d4GF+pa8aK+vX6U5SJyvafBo80XsUX7Y/khk6MKcpCWNAadbUbxZMjg1uuZdMnIBiH0McZwopxrxWFcyxS/VNFeoREIVqE4I1o3EV05rGzPjG3ta7acb7V/GS3BNqZr550xm2QfK180tTtYdcK1SEsdgN6zVi3YKuO5r/wFU7nX61uwDRQyQSEFMjMeEXO2VNE4m29c3/o1L0pmVZBROAQ5WESUUYisQzMIZln42Gk1G02RNl6s6IDY+JRk/IVQdg9BqNjHcQ6w8GXvJRcJV0uL5ZonWLZqUUA0DvMFXDqY8VHh4hUZCFbLHyrp9Y4QaY8kYnGJvELI6tbnKQjjFxibw9RrNESGwESZvwXhyA8QeAabPHSBLgHJZKqW3UdWwXYrKdrtzSe7vr5RGC4/YzqaK22D58FcB2mGtHnpvDXqLckNgBOBfLj0mfVQ4UyGI4dUM1lZ0kE24m+eJ0NZdHJUh+DbvH5etOjug6F9+PRZl9nbt++s2+/b1ZsrG46n0mJy6VPAHPe7MtWG7v/5842NVzPBRUByQDuQLI5Pu3b16ntdTGD+lVreChV3MKI7fBUd68DBPg1XG9jMyCQo/KMIwgbzxUN6PXPT0KOcgI2Y21AAUdErnHYX6/IUPLOey5RhOutbsxNZo1CyVqNjw9FQHQUzSSBVNg3MOS46/ILpGG5vn+yXn75Ys45Hacpq5bq7KEEGiGN7fBhIXsJm4JKkE3uBvJkz0V1WIYaFe80G1QXrMNvogudvNIv1SmSNWs3q1Y6dn53qokn2A13qRC3RdeJqghk3iTIQtHBJwfcVh745npr7nTbzagsZyqxcLEgGAky2Kq61nyR/Yva6T6RJfnoeWpgEdnLcsVxC4QHLHHtB5m1ZK5bIf03Z6Undzs9P7Pi4LRN/uesY3TNJDnvFvYmpmS/bermzbXovZ6BMLrJWhkPdRwxcYprb5so2BbIkhUPpLDjbEMOEble+VD6zk5etd2vMlRnBwPzMZbfWqFU0hgBmXeKOlHYTdsTgQMX8WXgIxXzT5lOIeVlB+5p3H+airCW6OC4LrCHX21h+naA4vD9QqXfvMMuoWi722edsPtahXK9iyB+rQ8ZUHAkOYwzB/WnY0Jw9dBawxHc6/FUkU6QmOAgB3XnBB7nMDcdrVq68ssl8rkuUuDXitLAZfLx7FKpz3D+ys9NjpYrQUXKYo5vleaErROMYQUTBAahcstlmbuPRo5ULBB501VHugnt1vYs1YdRrG43nWnMKN8eTtpy1AvKfekloUgjEe3Da4n1Ea4qQteejplLWqlctPju1x8c7BRfzLC7OT1V0Afm+fnep/QQkXWsVLFfqK1M1V3DjA4oPkMIo3tuMxBxIhMHGNkFWQQKYpTNjlObSuNi8qWD/Y3zAWQaXYLFeyV4RvRzB08rLxMsVPAQbQQwEMJ4hmCDKOfN9srbNbC2pGnNd7Aw5Z0R0LGRsuZxYu9NRtBzzdv7ZbuvIoGwiA9jBxd8aJJUVmIYsyE4lBANGrMvxvupF+cuvn8UShT1H1UM3CSQl4kwusdevL63fa9t2O7M4qmo4vl7ObPA8EDyFkwcOIU7bxb6KjgQJR0rY9mQKXIo3pFsQdXoEsrZ00dEqA03JOiuBCQq0t1ASyXK1FBxAFh4MKeDM/tGZoCu3nKOiRCS+USW3XpNraTYOcemJJdXgkuDyoAOEIs7shS5URPGYWQ0G3n4pr5ZTu/48FJ2djgrYEqITlSuXNdAtwbqMDUajgdw8UunYLq/OZc5OUDCwA9CfTBbWK6fuk9cJ5JqBJUug804VKocHnTafi24ZFvD6xc+zWtGlRRzP+eu+zZeXlsleq7s/xsy41dDqOM5iCYcZAsbSHlMGwSDcb20yGdlw9Gj15rk1oMzLA5Pw6pzmVNDZmU24ry6bnH9GZ+zzBIbvFBkS72q2A+km81uXTOdRBUIPUjaNVr+Jgul2MGnnQmajurVfwYkzCv3N22AAoSZrm9Re1HUWv2DLJGW//PmjnR6d2u9/9075e2w4AmfpPpg9oeMDohmOHtTV5POwhunyPKOO2a9Hfrk0iDIJ+AwCBJsZssp8trCb+FbwPHO2t6/fyJsUiBHW52a7ttHo3jXDvaYF25WNxqYcQcgKdPccPNV9ycpb1ntac1fIYc7a3Ik5ypyW4mi5WFgQZWy5mVltWLZ69W/UYeFWJelCElsbJ6arY3vIjez16xMRPUjP4Z1UK/jQ+qGvgGxJqYDQc/L5VcWPMUXBjaXdXANon2fiZgyekequPoi9cSDahehyEXAT7pER+1hZF2k6NE/jQauHXByCHheMovhCMl1du8zlBBuYtckzBlLmmYZBSvAffzYIlyqeKCRfMmYns6ktVjN1Z8znKSz7/bb2GVpeYqKcZQ5xxNcghQ5G5EgD0EIzp8SUHJMeIFb+OyMQl3rxvBjnwGHAK3Uv+QdnEEUy82K6sVS6rKiosYp/Hy2gIZ2MhtpneO3yTIGksfwbDMc2mQ51yb5588qajRN9BhnKE5MXpm212Fm0XVi7U7Zmu2W3909KAYKzyH7ZpiNZ/gH1o7vtdGtmabp2dwnDMzpaxMqHZT5KB0eKz2y6svuHBzs+OVY3TBGDmw5GI2/eXgo2XW5W1unVzexKeabz1UDnExcfNpjsFTp7qrsMzG7iwJLY7u6vbRc17P07gpr5uRQbvl4UuSgzemBP1lra1uu19jzdNLNG3hOoADF8ccD4DT9b9MuQnxgHIHsp2MdPD5p5Qy5DSsiZAUrGSCjBZq9QUOZsr9tTipO0sQFFSv7/L63I3zGJP6TSqPmq1mw2X4szYamCTaZfmcwjn0hw9BmzDNije7u9vbXNtiE/wG+/fedODsHKNuuZPBn7nabtiKcJN7aaM5RGdE4gsYfENmqYlzPsDmx6fys6O5g3LTOHOrIC4EUgncEj0U9LWwd8DpcUABUCrWKqjrYMATkHPbo5vGTpaoGNeIAcAJyJuRwWYRWx7sYfHrXJqPBUWW0XEnP/0D6yZqNvX27u7cvNteBT2JNUJsxEFVRbKttqGdozcMVkrGQE97Dln90f4oMWqoovibtqIADHiIADYGnn56dyRaHTZIOKEs2z2Tu2DvkEKy8xAflm8qbciFaOHk+G8u2mVevA0rF1exX767/9RibzpLWfHJ/KCk1061RaFoSnZ8eCioFluMg/33y0h6fPitO5iNrWgdKOLhHnJToZTNZbLhfQnFdJJ85eU5q4SE5ussB3A1ZHBlMo1VWpQ1SBHLDd7G26c/iNy5NZC5chhxnrgcJASQkyOTddCqViTgchVk6jEcVQw6ErOqNVaA93Q/vLv/9i5yTP9Kvq2tdrCB4dO784tXqtLf/J21vYyRt1TxgR0NUzO6NR59DXfItOURl2XEamg7+Yr//WWbHuyEpEz4a2UnmGuB8FQH2J/fjjW5l2x1HOCsV3umCxmMP5ZDaF/LaxStgS+YJhg3JIs0CexIRtzbLMlCmCdtYsdyzBfmtHd7O3xWxgSQTUjGwKWLFir19fyQf49PRC75eoOEsK1qiWLJvK2mQ51cEChBvsBhbt8PFtqigjFxXUQBAVhh1ZWJ0ehSYz8INxhd6DbAc9iDcUrEa97ikS+oKWkoYSOzj+XSBzun/Nc0O8niFbuOcnrNYvNw82Ga8sDtxcYbtKbDCYqwBmLZ+dHVun19Bh+OXzjS4O9qnJEhAC30KXNwxP4ub4NK9en2lMA/KC6XqpwKHJKGRrqz0sb/YA+YiwnF2ryhkFKYS1SzGqbMMMYxDkW1sLsph1uxdthuDw3VK/H4YslyG/h85vOp7IPOXkqC8jhp/+8he7vn+w5+FQ5w3dMTP5JCrY8bEHx2P5CVkOzWCwS9tyMjdk6Qbsi4ECkGTExYPEBKlFS5c/+4tRBYUejQlFDvPTyq4syDgOMrYZjG22msqZh70VJ4HsKJG2tVIN6/abcpnaZ/EQ5lemhCgp93c+EVzO/45sCikHzGm66/zBJejoCKLWJ8tkcF86VnoSfrTIZFivnI9C4XIFdaUKSE4wcClbNo2MzQOTKd4ZcVBwsnZ4pzxXjz3jaghEFtquQcNIU3pQV8nuYT/iR0wRAImHjpECHotHLkkhIMipZB+Y6KwGwgXlxBIR1iyX5nq7sHwx9VvO5Ve7KGnB52iK1sycPINyM2ZDLnWYTsavrNMtW61StsVkaMsDht6o4c5RQp1k5Xpb2D4d2GA6snkttE7bU8hXy8TG00d1W/3jkV29utTg9vbLvU2GDm1SjaXzGVUaGJwzCMbjslSF8ZS2YpXEgsCCDRZLwJQOH/oAmG+R03/e3DxpDrVcMrgH8x5aIUs2G4P7oZ2cLC2XqdrNl0f75ZdrbfLZbKHqhwtSeqpUJDE6llXv37/1cOYMNGufu3EgU7nTjeCfCrSEgNpTMBDHL62gQFa8GiObDMaKAiKxnIoPHSWXbTpOaU6AHRlFAFAWyRUcWoRLw07DX7RCGkuto8pzH7Jw9zZSosPS5rO5WJVckpCeJtOBdXsd6/Wa1j/+0YIIOHRj88X4kDpfkBhZco89hCufK/iF7eQrIB83xMf1whdlxOwAOUyyF5vt+LRnSUL6w8bKGq5jXYcbTsZyRcguwLN7fT8xiYtl69Sq8uglPZ0ug6IHtAIHEdh5//yPf7Sn+2cdhr/89MFevzm1Zus7se7IAAUuUvAtJtuVtL16fWLrNVCdS1qoPKlIMYpGNhDkczaNSONAEB+IlMLFqVihiMsKGGttwfZBodyfP34WfEMRUCnnrd9ryocYejpVxtnliV2mLzQLge1cLPJM5rZYxmIgUsnH+50OYWZDqy3CbIT2LZEi6Cyo4olgeryfaJabhGv580J6YETRaLTs4rwtpONp/mTPD0gxsIMsaI7FpQHyA2yFqfdkRLeKNjiydMz3dDZngcw+OVWhF1xpbs/PhnQTKXvSGYrMD7kjmREpJok+FBMDeZRW5H8KOW+H3Av+AXaAyEkaVRFFIGk9Pjza54+3NhoCJ3Iz7G233tt8RsJQLFE4do67oKs9AaEDiRJ7DHYoXXe51NRa1xiFQ1n5hH7AQjulw18X3GiEsQSjFvZBtdS0YEXkGXAusJzPiuOa8xFAL9jXrBkMMVbrneLRSEpRjB6ewVrbe5GpWvWC9Vp9m3cXsmBza8dEkqI//eef7eERRjmmCE17vFvY0/3Sjo/xMG4ovgyXpGgX+vMCIm2vLFskc5O9nHFSZL6keTrF4QJfW4xNwrm9+/bMas263hU6zCwWftmCLWdb6R9Bgng2RE9JgxhtrCCGbU6XYCaHj3nacomjSiArb7+9sDA8FuveDQqeD565NBYeSs4oi6QYkKT331xpLbJuGfEDv9OVa1REl75nDTAyoDMHfUqJ7Y5cjBkkIzlQIawHKdIqJZejOOuE+WSk2MVff75Wlu5sOv4NSeJ5gOShH59N5jYZre30rOMG+oeCGzs+qSgOunnY487En4qnUarUrLiORM5EsvhVL0qYbBws9V1VeDkzQ8XJkKown9rDPSkGR5ZK7yzZ46uJTV3WYoKdYz8IP998sPU6tsloao+PzxqM02XOFnO7vbsTCYJL8Oika/91gCdr0X798NF26/jg3MOMj0OJCgxRemjNSkcHoMTFOMTn0vrdqxUZhZ7YjZ4R+vGXLzd2/flJ7ha8DLGncgSZVqxFbNVR0+JkKZYlBBIW1tFR14qF1SFXDx3OATaIIASE9u33r+yvfv+NVSt5HSC0/BwufF4uAg9kpZNc2v3DreZUjWZNC3C5XkhnxMG1hlKNFg/j5Ri2FhBRRi4wEsfnQ9sghKY7QFeagf22P5gnuBMOhQEsvEqtZreTJ/v0+Re7+/Jgt9d3IrwAgff7xzpgSC7vHrXs6LRlZxdvLJPHSMLp1ctoJfiRbpsDCiMJFjvrWBDcQTStS14+uM4cFgwvx52sk0O4lCdzy60hZ6A9Jfx6JRgLNmWx6PAlxcXeijos6ZoRrAOB4UakIN501k6OOlb7b/9egv9//od/k6EA2aV//OO/W62Zk7MRVmzMPsfTsTqtcrlq3//w1l2BKE6WyFJS6vrjBDjaXTy8InXDdjk4HeZ2uvSRPZE+YckhGzKjsYGM2AtlXR5A064hjWw4eXajA9ikBbNyrWCVVcFmi7FN5jP9fq2r/pFVm2XLrxcqvIDEODTpsHeb2IaPYxWJdGkcZkB+dGoEMFNQQK5gyd89PNlffvpg337/3pptku23ygRldMDB8rvf/2gff721P/3bR+0FfUeG0xDpJHfwRBZGIILcqbg5kJB+aT1vLKfuilSZksVonOkINIrwwgLZGN03nS0HfbfXt3zx2GYTEJWiOAWQZJCoBFuYzFMVioxDONRh2dLZ0knTzUD4gGjVbJR0tsBrIHoJD+LZfCTtMBmRFBub7Ur7UXskdrtJnk+jzu/CHhCt48YGo7WNnsfa8xDXcLfhXZrNLQjyVijFNhwt7fFhrMub9TCdki5Cpu2pfE65ZCnkt6ud1vvrN6+t3WrZv/7rv2hMgbqtUqhYNb9Rl7tbbC1YBZa3nLWqbQsKXOhZs5gZMl66aHYhlEQKjCcrU9F0pLbkITQG8lVNZwJrdstWWnkBIDlcNi1YPpcLbbMMrdGu2vfldwoXv795dN1ySKxZRdm0IFSMqCJztj2yD7p/NjUMUrrZ1Wbuzl0HAo/s45jvxVgYoosvW6nyyr799q34DdJ0azzFmeCyJM4FGOB0lpB62HcbhUOkVLRgqv9w+2jn5+dKy6FJwDOZ80A62WJR+3O5nNrT873QRD4bPtTIEJtnzLan9uXLnWXuWTv87Qxu7idSdOZA3FwHQqu8QwcKh9A4HS+ViUpRyTtEKvhVL0rprLYrqzdL0sPsOKBj/BSxbONwZJAaa3Yj+7TkYKeUwvUiJyH1p8/Pdnc3VAvNBsVUG6bfzz9/li6SQTfwK10XLTH0bYg5LJqL8zM7PT3SYQ5ZAlYrGxdyTK1SdMkHfo97KN6ElbIZ6GTxEcwKOqK6QaLRaOZEt2dgjr6t229Zr9O0Kiyuq29EgsHG/ugIuHRt7VbF2i2gr5L1+335bC45FLJmr99cWqdV16EKHs+BwqGDHrFQQtSM5dVO5A4irThhqWB5SZBHSAEPY4b/OSWHzLEJDNb27psz6fQIQ1VFj4YUv8mETYy7BswxmKk5y6YyOrD4G1kdEUHY4b15/0ad8+6Xz4JQhoOxZVK4tRzZAo3fdmXz5dhWm65dvuprNoDigIULrEUHHcIepVLDZBq3pMQrdc+UZIHSkcC/ocPgs/klAxTKs6Xo4f2Fu/Rv7wJIjjudUGmKGqAZxULFKcH6+wRW4VYkosnwyU5OSRRYCfr89psred/CQGW+WqlW5XgzeJrpEujh+pHdi7FZRj6ADjIFnEucrBslUyFTuaKJ9WR3NigXJsJxWJpz20dLdVuQT9C+IQIvFobqKMh1hE0Ke1MRPjF5o3mzzN7IjMDXmPlRTtrcvRWrlOY728VL67WP7fT0TJpVHH/my7k0raxzDrDNcqlOMh2TIFKU9zDPiZmnZqwVtKDK8lLnjJfsehfZzd3Q6nXe45lt2R8pikZmxpgX1KxaQ9fryARzVgnbs9iO8RlTVkCatNvYJJiKGa0gMnWRRUshk8CyrlyV1d58udR67LSc1MTO53NzSUoWUyZ4m+fIwY+WkVDw2GIyFAM8VptCCMrFlkYSFHpAy+fnCOEztk/Flnz+ZHFqaz82uYy61un2tV4tvRJx6vKqL24BQdmQQXh/+TwpLynLZ0tCgW5vBjqggxCZ0MJ2a+bOS6uU8nZ03BBywHyXA13SkBVkP6RjORH1WMmQ5v78y0e7ujq3129fCykidJuOkBxE5A7EDRK3hm7x998Fdt4/ttlsJRIjRauKq3LFpoORLluINnSN7gyGyYobHWiNpg5a63xRAeqw3/EqieKCzL/lRUzgA3aVch6iuNgJKRIRL9+xeiWvLFTCoYF/662GLjFGUzSSAXI3/KBl0kCMYNY2wcoyedjCea1NLjDJOeBMFxlppGUqUyqd6n2NJ0MhaCBKsj3ExjTCjYxxFzaYe0uroXBdI/ru+WYtQ3OsKqMdTYTrf8NyZIvtTF7PyNEgxVHMcF4vV3TKWWsgd8Ere7WxxRpbOzr8wM4u+vY0mMop7NvvXluK8zBPZOJK5NFapSXW992Xa/v0643O/VYLaRw6WteLf9WLErr2HNZkTB5bxdIFWKxoXKr2zfev5RnJYsWkG6E9+DPzDGZWj/cD+8///sFG08Amk4XgMSoxhsscML98zMjNotNp2evXF3Z8QnfHTR9bOkenU7arq1Pr9Vq6uDZbf4joMkUyyTrLEpcGOhSixJlfUhWp/lIsUM3azb69e5ez5+ep5B1hVFG2XKNVtmYdqz1mCjUlRLAY682svS703Ig36KtK57KkaooiYEXXPCJ2ln9oBCnA4SrmcJojKHTYRfREYnF5cEgz/1kTarw1e3p8tsUcKndkz49TYfTL461w/HUWxu7aZxTEMslw2Q4zQOynuCQ9Iw7fQ/whJ6OJtepdu7q6tGK6aM1y3T788lmBuBBDqMAh90DsACLhOVKFK/wUooAsvLZKR4eckMbPVUxGNrkXOW57BGMQdq67hUhsHzG/FDtG3Vq73dJ8Ao3g8x5JDfOouiVJWfDK5eWRKkFs+diYHG6Dp7lNJ8CFK+WVfrvZSdoxXyx0CEKb/93vf7DFcq55GZDVjllvtLdcOmM5PG3pfpS6vhVbj7kFl7kIAoWCbcJAm24wmFqr2VF3yDyNbo/UkFQ+qwIMuBi4idkQ6AJQcW61lXnGfDH1znYyse++vxRxhexP3gIVCxaPWJz1UhxKHBA1K+TKnomZJSFjaB8/ftK6BXaHEYuN4HIO3JuzZr1h2SLvKi84n+KH9QdPgI4S9IF4JHJPYQJjjYg5drNdtFzBczaJWQNZQaA/Hi1kUF8uo5MjFk19sxt4A9PgARvtbJfeGc0GkDpFwHwOS7Bmk8lOgbq9o551WkQBJZq7eQoM8hcIPIEIbiAJFFjMCufTjd3dPcnsgaiyAYb1EcEAWEL6HA0yXqXO90trlJLKRPbq1alVqwSR12QlyMHfOyHQuiSZEk5NwPMUjaxPNyBAghEqtu7Dr9eyD2y2+7q4uShhkXI5V8sNdcK4tGxXgd3e39vnz2Obzuh+4S3k7NWrY7s4f22/fvzZfvrLR7kOYYTgkGHOprOZLiTs3ZDDJfuNXzLMRPekIhGuwGf31BwZpazX6nTYIMUD9AifghFRpYjOEPgS8wdPy+CcKBLhV2+qWOCy9KaYrFyeuRujKGsTO08YvQ1PcYK5SmHKd0ln5XngYQDJYdyhyybysHZkMMWCCuoXD2jvKv1i5swA+VBW6A6zes4BOBs0Q8CsGL1Iiv6i0NC/R4gGBQN7G+i1XKxZpu3GFfPJ3DLpyNakQWUZQYW2CtGKwnztWP8IqRhxYsST1a1ebdpsNnc7O7m0sUb5PonkLBTkLnV7KbixwKyLHIXJA9A4zGkK8F4/9gInn//KF2W/aZtobekB9mE5uyqS+J21Yw67M2JwKHJx1oE1iXUSlwTMxSf7x3/+d/vl1y+2DZhtmL15+8qOThrW7VXt7OzIKvX/k2QZLmonGYMUipwO4PPtic/jsMDKRYJcmVPSgWQFPeJUQ2eTt3S2ZOkVn4GPASyI2TTVJqnZQEo56TQ3u4kdndQ9LLXMIQL8isSEhPknzaqokhG/g+3rpUfQ4JHHENkFYxaImV/FwHgu+AK6uOy1FCFF0gAOMz7D42/R3Yn6SmG7VbJauWE3w2dJVghsHgzcHxHdIo4s/A1xgA2jLi1yz1nMfV3bBRzIJeqi4AB3mQBh7tZy6aWcfGDjNf/D39r712/s6eHZoSmxW1NCAkgKwCaMsF++M88NyIoZFxucA7mG+B2QajYX9VyWXum0rNwUzgp8La0oECXyAiCXjA4RLk4ueez4eE50k6QiHB317JtvYAMSYo1YP7HnwcT++Mdf7eZ6KHclniWmFrBZ15u1LKlAHaD5A9G0uy2RqJ6fHjxdBbP8VEqMyQLVE50XFS0Ra8hAgFmV6FCwXbxXN8bsjN+V6xfFJD4+6jukeXcvOIc1HoYraa6Oj3oyiwA+kpaykKi7AAKXi1MYSjYje8QcaRMIqHc62CuVtrWbG49hytDZRtLCAXvePzwr9QHbNvS7HFo48dDWMZNpkyTfYi3SvXqcGge+XKsU65XWOvnpp0+KT3r37tyu3hyZtbkIkH2klck6nSDyBu0p2D7MC7VBu0oBgetQrQZZiJxRjD6ARTEJ5591bbtK2//z//U/K3nk//4//kdrdytWIhg9jmwxd8juZS6ETldm9YGPHIiBkuMUl1WA9AbB+dYW4czmMyz4mPnuLZU5snzRmfRA6expPhtrjgKLJJ1OH+2pmyFQjCIjoUMDSpNDWDpvw8FQMNvgeaauNgzhDLQl1dFcD7ebEubfeVvMd/Y8eLZPn+7s8/VQXIlcrmyVOvtrY99+89bevXljd3e3Krw+f7rWd+11um5wgnh+7mQvxiiTxdzGC3TmM4vHmA/gfFS3brd3MEDwkREPqFYqWqFUs9lkZIPh0GqVmnUabe3jh/nARykQpHL8DCRZxd+4Arj/0Ei8BAtAtqMrwAM5lU3JhQZ0CKSCGoiukCXHaIO9T5HPmmXWx+ei7lUAQcCl7ZCsdJoFzqCd2KzI6jgf3BrQL0ouav5SIpNuSGUTOgFMub1kjFbt5tOjLeecB4mIUFyKwXZh/T5s4Z5lc/FBMuietZC7vvvei5in+5FNp0tZoWL3yDkbhqyBQM5NnU5dhTTdKIxjDHH8/KfBwSO4IK9qECmpLHZuuELzRATYV74o61bvVOxo3FELD1TCbA/XllwGFtPSSRrZskXSFMI229tPP1/bf/qHf5OOqHvU16zqb//Dt6IiMyOi+m33f9BmF3VYg3jYYTslWXNZ4fZA90M0E9E4aPNewleZOZCZmMWpngXDA6R0YnXguJNglAw0jCYrtmC2EEMUkgNtN67zCs8wvBCHsnfrttuHTD5cSXxRMGzm0GfjYy7AYJtumEOCRQq0xaKge+TnuggfKy18Np0dCsQjij6sN0P3E9ovP320n/9yY7PpVuxaJTfsC6q2FcAq1iqONTVdWkmKuTDQC5U0NH86vYKtudw2gcS0VH2QKyp5nD3MlnxG8ivPOxYGTVWpwDG1ZlXCaNw9FoudlRJgRmenAS3SJcL0w8pKjNwQiMVjadTdYhCBRduaDUA1T6eNhGerzhmHolK+YsvMTkw3sgaTCq45zBxb1m6VpVcl7inYbkVrZ3aMFpNLjl/FO+O50O2RPI8+ksOBIofOjDi0KG5p/eFYk0ul5YTCYQgrcTaeiaZOtc1sl8sfAg1Wi8wtxrOFlcsTfVa6Z35eEDaFTBR18LO2coK1U2myKatielOMhAEsV949UPr+IPlA9xZaERirkLP7u5Hd3n6y8ZjPB0PyyIplGMSx1Ys1JTGsVvgQA0Nx0bvDFaiFslbDUN6XjVTpt+QXzaaysF3HOqg8DosLhQ4jZZ8/PAi+Kv34yrpt1lkgVyXWFd6q+XzVPn98sJv7mwNbeWdfig92ed6zb747szIXYLA55KYia6nal5uRffj52Xbh2j5/erBi5UrrXDN1iGbqICB4wXxlvWIA4e+ketK0bvdIyJIygdLYFzL6gBgYyvXmy23K2r2ydfYVrUlmvOvdVPPeaqsuQgtzzWKmqm5c+EbmMEfVz4mcpBPt1HFTOCj+Tm5BcAF4l6G1GphOYIMZC5rjMppPQ1vOYyWZrDeR1iVSnM1qLs1nt911VCcKhCA4kYbUlKbyT5/2FLsQe57t518/S+utT4g8Av3nZuuZofm8zNSZNTPnRl/JA+FnVslnLJCOEYtIxPeRQUnWGa6cJ8pyDbFlg6zibFF1UQp64GIiDd6JVm4/x7npDR7zX5d7cDSmNK4QYzQLichZopxfEvYj7YKbhiwGQ4m0yAm2gnWscYQHD/CTeX88DzgXfGZ1lmmc1typDH9bziDOJhCizTKWM89sMrXR6FGzyffvr6yoLErQrKwt15y7KWvWqrZMbe3L7k6a3CSAw8GILmWlIprSorI0MaLP5yFS0oVjt8ln2dtyvrZUMrVCrmZLGhutTc8yzWdT1lABW/i6F2WhkrYq8FC16ws5Q35pTlEncQzZA5AzpUTweq1jz09T+3//f/4X+4d//qMitv7+7/9ru3pzKi0QocT+gCGgoI2iRedFoonicmEov7N4trJCKWPFCi00ui7E/yyuRJckFwgviEWJdAVHGhh1pIx4OglCfS4W4ASHoY4yTevsGwezBM+VTBL3Q4QcUKCLLAG/7i2UJ613dVweCkXeu1kCl9wuBVQVSyuH6FXesXu+B8YJHrtFB+0aMTpMxLIFwXlcuriUcAF9+vRRwmp+LxAMMDdwGf+eAnwReXMhpg8aJUwbUrDL0rYPkcEEwt5xBdlHc7u5vlV3mHn7rdVKZZtPR7YmhYSuGNi70xGUiLyBCBtqCmZX22CteRwPT91cEePkuQoVt43y0FyG47Bf2TTbVSRiF3FqfDYZUSjEGLH3XBTuQqaoeatGKilmS3yGmtYNwmy8boF6tyuITHgtcBm7OJwihs/CgUnXQCyVPHVXuJhM5BbEM6JTgQwR8feWSz221XShMHDWDd6XmrsddKLMxGGvakNt1tLaSjtYKEgPzEYEumTWwlojDQN4nxl9KtMTDCd7xXxWDMH5cirLLw5WDhGMGARXjuf2n/73f7Gbu2erlCr2/bfv7Xe/eyUYFSj7/OLSptPI7h8H6m7q1bx1Wml1kmkQBdjKmb21O2SEpjVXl0wjYR7FfA2NLYWLG1CXS8hQKGBCFXTueYpYHfhubw93U7t/eLTxeKyQbjEWd1urlgrWqhZts1rZpgwjEIu32MrFxJbrjcKDmYGi07u9ebK/+ptvRW6jIKNgZt5O5+cQXl57g4xJbB7Zm9DzVQAAlUVmV5e9Q+oJBiALy5fSQhqA/1nrHOZYqqH1ZWJeazCja+ssepEiUfSwT5CqQRZS/J+kTDiG9SyX5b36OOTp8c5qtaJ9980bO7/oKpAb4h15uM9PEwUjUySTS8klhFzn6tW59fqw17P244/vBf0uFg39Hi5unmG34+hGKiFQPbJKvWmzxdPhIvGUEy44xcthJoJ1ZxTYbDG1yXws3kGlUBA6AmyLnIEEESLQSRfiAOlXm85mTyJ14nAf6KrQDrMG2f8QiXDiEQGYoiEOBcszeiEyiy6T78eoheKfz6Z0JsntuIwxZvBzkEKiKm9k0qHwnCXcmg7NOzX2iYKVxTpGWsNoBqKhW4J6ugsdn7udLReD35yhuIj73b6NhyNJrbi3gOdloccsPOuQP40qMrTB86MuP5CxxRTpIRKhnCwQX1+d2FGvaSkRenAJS4RKMlqYTT9rNs2sepWiGcIgoiqiIJ+504bRXJZE6qtelHjqATMVaOdzbk1FJ+AWW+DcVGyJopl++fiL/cM//JtN52v77/7j/81+9/s/WL/fVXutByMokZcQy+R6NlnpP7lU3MaNGSQdSUUbBJQpTkpWBCrNFakTxehTIsiOqgfiCZcaWXCQgUwVX6HAA+QlalloXqisQmCGwGEL4Adway5CzHOzqbJNxzjXwCpkCI95tRsHQ6Lh8iIlGwLGi9Yvk6kcUlBc+oEWlL+8k8QoOtBF9JJxySLg0uJl/9Vf/SDiyqcPNzo4j0+O7Pvv36lKisKNWK2wvhbTnZXKHmBrdFrbnQykZ8OpBvy1WkvfHWu8XrdruRQzMQzoY++kyhVtKP65DNxDZolUVhnbRmt1x5gbcKjUGnURXNiEXCQsTAoU3ttyttYBjlmEDB0wjg4T263XWvCyvjuYvj9uRjaqzqQHw4y7VUP64BotOh6gZTpifg8zUzpEDjMkRBywdNAkCDDfRc5A7ibQIB0Uc2E6IdJMyPOMIy4nrAVjS4WBredowDaWT2fxedImx7qNTa0UhwoU9FMbDgbu/zgn2xFdV6LqlrkO8zMKMcwzgGGZk2XypMfgbIJcoaX/nd8rW2lV03awIwQHi6zT6svKLgqHNl4v7C9/+Yu123mrN9/JvWQ2xaB+ZQ93dBqBtRslifjZyDmFy+6lkYOcFO3S6rzBI0AV0DbTYTjjuKh0BVjkovTLTID9xEzanzHQ94dPPzlPQIHOW1nuAeWjW1OnJcQD55y8pUiKj0Ac6NIw48BuEYb2WpW97Vda66AvzKKwDaOTFLPUrWGlcZ7ulwfCSUqzSFjo+Qxjipwu0Fz+XJaC2KOxhnEP4uaHZ8B+3VFk5jAiwDt3re6ZC4VnXqswb4VF6oc4szfQhsvLsvW7rKuyXX++tloNO7imvXt/aqcnbflPL5dAlBjne0cMmYpLmqL8+OTM/vYPP2g0wPtlhh1StBecMBRh9D5fi+lLwYvfMAzKx8HMsqOJpTdbQdBc3Gni7zAfj8Lf9MfwArR/wo3F+bRNZm5QrjSkJJCVY6Xmvsdv3l9a/7gtgguwKMx/iDicL7KHS/l5A8GIixhYljFDBc1wqWABDktpwhVgCbu9Jn7C23WouTXfH9P5yXSkrhvddb1WFaNUAfRpt/jjrNxucZMCZuec9S6U90/3zPd5ySeGPc0+rRTrNthOVdiABZP+Mh5PbPCM1nRnp8fHVq9ihIJaILC8DD8835gx1XQyIv9J/96arhhSYXqvAOxOF89fDEN4zvx6n1FTkIHMQOQCTaOpoIAXo5bRRRbf76rOJAr0r3pRIs7k/MOGik222cRyrpcpOPMJRd0kFq3WIoN8/7vv7fTsyk5OLt3wNiQhGys6AqDnglmfniaKhloTLnyIlaHih8pMpciByr+jjgraqKUOWrydPBs5+LnkmGEBgzBDcp9W1zyhlcpo2O0SgxeTdNhmPEgE4XSJmGMn+5ySI26f70XbBnYCtkFTqK4ik5GkYjh8EqHo5KRv/W5bHoluk8VG8JxLBugsGGmLNJ/0FBF3tvc4LiywmFOdnvbtf/h//EcbPaMZmwpqxiaOaioM6LCYwdAJebgpi3y5dk0pVVi+hwQG3ZULj0vnFTs/PpVUhhnhnnDobseW05XljHkNVn4wQD1+Z4FTELB5kPGqcwUr12erMN94rnwHnItgKzOnESVf7iB5kWTcsWh7iDGC/IK8IGfhNrHH+dge9iMdcudnR1aqZsRKpkiiW4Q1ys/nQA3PkB6YCgiZTayWYgp/98M7DfGhxHNBsEkbzZZVa25ogF8kbi5YhK1Xezvp9CyfytsEiYnYucghnMDEfuZncKhfXSE/IcdyLSMI4NNCgfWAO4iHTuuAwFweu7cUWj1o9xRgKb0n1oUIr1lmN0QnLdX5FvPEZ+EIRKRVwwqFqu0S77o4NIHyQVNu7x9lVcb75cuDpKRTE6EW8tWsI7Nhjre1VQaINhKDcr9O3LcYRyhcrrJkGsLObtt2A8lpL7KKDsfNSogF7O5331za4HmkTD4adw5GiiS6QooQ5EU4K7Gmk7wHkUPQ63ZrekakClMHzqZTazZ85kuHx97lHbD+PeIKJIT5GnNm5sp0FEguBpJJJRGICQYHdLply5WoMEIrVnqWKwG71ZVBCdz5MgfjcqSbU6Yj5BnCqcVH8FQgRiAR71dm71woFRngv3t3YXVs39K8D4qZndVbJWmWgR27XRzFYnt4fLTFfCRdOEYWzaZ3l5UKYQp0SBiduJQiX4MnkJf9HsUlMzBCCWAatwk/SGdsvmCmD1JhKs5yhYpM+jkryMB08wIKPEwXVrYL656usl9ZrmT2+z98a6/eXFmzXZWeGAYz7E4Qgu0OVr2T8GDvamRTUFaTldB71upW1iwP0trcJTiZnC5KkKBsGvMOwgxAHpDipWyz9jOTQoQ1nM04WSctohSG50QI0nAQQoDZAL8X4wYkbLGiwuAicPYxT+XZQeSjaJxOFkLLICo9PX/4LaDh2+++sXqzLp9qbjuc13iPFONxhnGHy3k40ykaK+WcxncX533rdpoWxswkgXyd1LMPPMYQvi4jm/Fwpf0sh7QUqJ2vX5698k2537/mRSmDXJxvLOfUZGgBQKWKfOFBehgo/8vb92/05zARX2+mVixBGYeI4ObiHKS4q5CBSFW23bB4qeQK1mqSy1iySi1rtQZU5Yp0YVSWfFE2BWQJZni73VCdI6xRLlLfUFy0zt5UDlzqEKiMMHaProrrlgRvkiaIJvLFv1iEdn19q88FpMlml0k2lTxh1eTA5TPWalTs6PjSvnn/VrDhasUix6qLh1/QXEreNRrY8+KZuR10ZwoQ5hAxq1bJsSQmik4nEcO2WsMXls+MnRaCcd4iHRSs0gN5R5W0RwtJ/iDWoVerVB/oD5GLZKiuY1yQdsqZQ7/4cDeQGBdXC+jVgdz3mVkktqdKq7Xw3FH1jm0eYmZ+royDSeiAsYYVmRHMu7UvX65FfCC+iucLPMlFieQDRAOKPPMWsf2WW0k5ukeX0oUh/h0OOJToIjkU0yJwNFo4+ST2/EwBtRIjkssQaBMIafg8VwdRqTVUOFBYwAjNWMlGy6Vtw9genwZiBeL9KVJJjGaTpJTKwd4qPJiWw8ptOyu54GsNrS5IAc9NhBvmgsyE8T6FIVgqWpRslLNJpqXDa0D4oGRcqw75865gf2o2WoSl2dWcpZDHsYVuyv9dOeIwK8oxP+Rihrji+lsuGVjDSCb4PMs9ZtBcDuR78hmy1j86ssWcrnGtP6t81ThtjUZZMBQ/ZzKd2Gy6trPTV4IQV1fH2hdRzPz8YD+m4o1CmO4IQ3kSaRKtD5LQ3r07tUazLDlLtVVWggxdAx1nkGB75+Q5JUIUoOdT5NHtmpjGsHhZ13j2kpFKcUOnP5qO7OH5Tm5T6dzejs/aliN8mkZBelbYw5wvMMSB1N29BRMT12fTZYFw0DUTbEK34/7OnAaNZt1aTXgNeIvS9Qc2nT9ZJlWwXLZqvaO25QsVoVm7aG2NqGSnJx355qJZxj+Yz0+kXr1W1v6kOOBwlqyjBKsYXfCjTafA6wU77iPRKFp1mtOzp4Am4JixQK2St5PTS2VuUgSQ6OHwJusVTkDeAqvY2eWp/eFvf7BsnmIDxmlexbuMEvaw3Dfedcm/2lNZWOMgB+TaSsOYgsyTs06xI86ANN6MZNIQ1IAld9KUO+msaEnsKgWKB5AhikqcyCJpXR1eVbzXwdIOUw7eNciUsnHzJc1b1djAfDekauvDWoD5CHoylC0hsPnxMWYhTdsGyLJgQXusGOY2FOGyTMSlKtxYq9HQSI/Jm3ysT3BkK6t73sraFKcs0LeMzWcDdcvArsiBCsVY7mvVclOE0912qXGPgq/5gV/zotRgl629j5SMzcIlEoX/zoGOyJNKi0uQBcBglSpeMG2yEZUfAkMuzwvgNk9pTgUJJR5hGO06MSzkGi2s7JxBKIPeNJeX58xhEABct8+k1dUhMyHCC8o3Fy0GxfwNU4xDAE9aqg3gEQSvREel4qw9DIc2m1LN7Tz4WaG6hEr7vJHPs0l2EO7t+Lihl8MmqFWrIjAVdW/tBQkIchWZw6UTVNN+SOB1uDnQqOnA0iKMcLEBpe0z/F4uUw+OTqNFVSBzJNamnHlkKRfqAuTiZdYG3EYCOkxR7yYRBiOJRyITWpSgIa0I3oSgAGxJ98Kl9fwMm25n3U1H5sqdeluwV71LaHRTjNwihsGZvOaBD4/P2mBi9MKoE4uNywyq/daKubIg3nwLD0b0ajO5M2Hj9nT/qAsSXZMClGvOTuv0MFfHXSSRbAGoxgeYgYqjbq+m2BzgcAgNECBiZlUgEqu5CC1U2VSHdIFIXpSzGUe2WmztQVq5sn37/p10kYyoW922no8WfTanjcVzh+2bSTdVBPHeETsfLIc96ozKyjKqhLkouagwZi4VqkrH4K8IZmFmb9Mp1mBOaoI9SOEEVM2hzXui+KnXM9Zst3/jBrrnqlm+RKwRfyYWBA11nXEFa1qONbutrMsUx5YGDtxYvQapaCE4jI6WscZqPdHavIDNXKvYcj226WRug+ep5bNle/X6tfX6zNmQb/iMXrNbIC8Zl7s/JnDt2jaa+QOJ4brVP2nbhvk4iRX1mrIYOWzcrADnqYXvicOBzc+mo2KmzLkN/MZ/tjp1S6XIh4wU8Es4OTFqj49Ewb2xZoccUM4KN4AAAdntgYDdhpL35/PNneDxDNmkCcYJ7s7C/7ksCzLL1uarhTrlIqbbpawC4ZmXMYfLkcHYrAm5oJgHtu10m9bvNy2bT2w6G9riGZs5ZlsyRrOkWNTPgK8Ao5NCAzYmc095tBZjKxfS1m6Wrb+qC4niolE8WCqxk5MjGUFwqXjhD6kwY/PlwiaziX1TurLTy1MxPyEoYkWHTCrcM5yhiIAzEEuzqwIni4sURT2BExQVQJexZZgXKpiAAjr2NBmalzUcB6wpKbjm+h75nJPB8JIFBkW3nM5AQHSmNRcyv04uahgKpBiJVFW0Ma8HFVrviS3j/XNGOQmJZik4/E0jhb8zTGWexftv3gklAsYX+kdMX95dejwLFFh0rxHcxZUnmkDmVM4uiE9EsRBpLs6lys/frHb2y8+fRC58CZRgXtxu1a1/0hXpM9pVrd/rigwJuvVVL0rZONExEqMCJs0Lw7ke4Sq6QNilJfcFFVNQ3R+H/NbW843c/fHrVIVXqioOBlkH8oyjk45gKl4+mDPMNWZZaMKAIOlcEQbzUEXcUEoIxsFU12nZx0GBx3cwl/cKngpFXYAKdBIa8GglaHVrv/7ls3349Yu0XiwkqPP4Z/IyF/OhDglgNWZYjUbRh9tE3IQ7hfAiyUinqr5JOBRJSH/xCk07+UZJBGgR5ZX58gx5yW6o8OKEolR2kkYyQMah5o9EWiGUBxITcUOmDe48sg+9+GBWAUuMSxlDdZrPDeLdxJ8jAmIcamDlFlJ5HW6wXPF05FBq7hvWYKDdwEouaydnJ0oIh7gRbCNbLyfSoj0+jHQxs1g51DGJbrVEE9YhjqyA7nETkxDPJgHqRFpDJl7ZZrO1JSAQyV4d+2T2bL3jip2et5U1WGtgi0UhlrIkzdxt4esnB2TNkYdnaU5xVfOs+/hiJ8i8rdO5tFKZnsNnj6enp4KYd9W2KtBKs2WL1VQblxQDTDJknJ3NyqAbL2Ad3CUYxW7mDVTKHAP6OqxMMTQxYy7AQF3rGXl17TNJCcBTzgh+0dByyfKfFFXj54HYgkA/FHiXV5c6KDHzRlNH3FFvSoaqz8SZDyKZOj05EhxNOC2m0EiYClj9HGLYjo/PbLPZ29PjL3I0AnYNIxJW5vbXf/WNLkM+H+xxnGYW88BGxYV1uksrdCu2T9FNApnCBMIchFdEsgOFHyOJgmUIt96QE7q3RgMtpwfoIupGhgP8L2E4HV8uI5jPPXvxJ/Yzg2foHTPG7UX58B4dn9losrZPH77Ic7eULsk8woX0rjH0Th2jb9ixsDwLmsurQKc4oXjESzRCD+jB76xTnT/4yBIXRuJEFk31i8SLS5+c2Zrt0vFv7i3ofvtoQ7tdPTPmeszwmJVyLnmmLd0UpdbeJkhq9rxffGnJsQwsn93b8VFLuaYQi5YL78CiqGrLlReGf/X7Hw9zvo2VKlyAbjzS6/e1h5HqlEY5dfGst/Vubt1623bB3nYhxb+fARQhrEn4CCBSTqYheMBjsRglVDRjBAZ3drHkG/AnuNRJA5LVHIxbIupqemZ0y1gEIsVToHNEvFpZ/x7Ma9YwoxsgVC7OMFxoNIUtnf7MZq2iF+SQEUK/d6Tzbb5cS3NKIUhTAbkOg/mj4xNVpNwpnE8kJnHG06XOF6gAVnoXp8dHdvXq1DZr4FlcvHzkt0/xu7DhgwcCXEzjtlFubbIvCgqnAyZAA8hZ+s9ixs7PTuzouG/j55Ge1Ve+KAlKdgYiOkpmVRKZy8Ys0MzIDosA1moUoFXx6BoWH4QBDj8uPqqWUi1n/ULV2j1eEo7/gboRPClhX6b3iWydMAYH8uBAA0qkS+KSBENXpCXWSClYcBBJQktyKWObsmCoJugmqZKpcB5u7uxf//lPdnc7VjeJvyUVMJ1Oo4Zp9FKi3m+/eWO1OrIUOhXmo8y1gFlnlnAY7tHqRe5fGPO7YiuUPTgXXRmbyBM6/MB0v8zYopQPzd2w1xVHkCFevDMLWO4VygfvTVJHcNiAQOTQnEx+V2t7ePhos8nYfvj+vVXLHPoLa3aYo5hExsVsSWSnyqZsewhPGz5fxpodwl8RzcciBzQald/mSCyiGSnmYqwluiT/+Z/+qPmxUhjyWWu1q5bP5KxWrlijWrff//CDPBiBdanOk33dri4vxO4bjEYybg9vAouDvRUwbeCgSud1UfJ9J4uJ1oGSKxLChpuWXcGApRtnJuSaWFAGih3sD+lQKZaA0hJDo1j3VJjlRs8qRbeYTuz28dmeJmO5fZBLug6ZF/OknTWJsJ5Dj9/N34jjqYopWGAobsNI4bGwcOM9pK6yNG+dmh8iJF6sBsR57UXPp6N0yY6/dw4tAkqYsctDM5W2VrMhJqXgYH5/NrF2t2rrXWhPhADHsIrRh9asUgUuJJ6taGGEiwsoQ1GEIgq6ag3JBPPSUJ0jVTU/t96EQYnDEhcJBRsjEdZIYrMZbM2VVfAKNmeHSqEAnZ6ijb2SzYm9uVlzaGbUhWLczjulq1WYMQzIHZ0cHTfscDRwWe1J9qs66jC09daNOzisgISVFUlXlSnYZLbUs3l6HgnGZ92+fvdazETp6bg0t8woI3VR8nBXHJaTLyiQX4yvuSCLBfcudb057GUXtXNOUczBrGU2HScZsYLZ28zJYQYTfAzUh00gpC6eJXFphAXMFyPrtuua4YKo0y0Tt8dYgDOO0G7SL2TUgKzqYJ0I85LvzALeBS2rt+tWbRatWodUB79iZdVmQcVSKp+IUAfTFRLPfDq3JNXVebDZYRbgbj6sRWBMLkdSjyjy6SK5WOgq/QwE3qbT2it9SdrWQ/EiHkUIRJpXV7iAmStNNwYP7AuyIPcyABHkGW2tUKxqjJaTYb4/X9kgWloX5GIxVCfKc5FhuS5kmqmMpfo0KLDFE8uAvAHZIjHLeToLDHsKBy5OR3tAzoCX3fKUBCj+HQKxcbvi+fCOM4ZnNWxzjNUdngchogCAwQz/I1+q2/X1L3ofRUUcVtWoZUnPyfuzAu1zD/CveFHyYLC9yiRO+xXbCcYiXaDkCzm9RMGCQIx6eegGuSiBdequ0Yu2tpxvLFeE1QbESkp3aLUMlXvHttu67N9gANKeewVEe8w34mf7p9nRdSYE7jKPcAo49nEQFGjZgSIhLJRKQCPoohxSw7+RKpGKRN2wjJ9j+YRevf476UWJDGIoTcUu2SDdXEClSrwSLitORYeZyZvG0i7ZmijZfDzgEk9s51L378/C41lwsHgKh+tApZcS4cE/Cy/bw2mB3IBuQ7/Ulytl8THXYzbYqJft8vzUKuW6Zi/Y1mULGbGF3aUjb50+ouiKLcdziwoHL8UyeYZYx3FgOQV7Bb2czydDa2a/exGklLgQpW3Nd81CKkps2cUztqUqnQJoPByIBFGt1K3ZJBqtLlISTh5IhvgbXWsUZcS+JWD42+++s9PLpgLARXxCrB/t9B2pSJmfuYbVAUqYxmIA9ttuQUaQdCVvs8XQ+j1mjTlFF0FOoGpNUqE9PA+EeCSEQLdIWPFYKMHQEr6TfI/htQuXuZAU4H0gjnC4rDdueUbUUbvdtW6vJeiKPweZATtBgnj5i6LRjQBAXV5YgZDT8B4uU9npcAM+X+Dvms5q1MDaRI9K0bcPAnmLUtCwzlfLBUW2ZjuYZtA1sPaZcXKQ3N3eCtaDmIT+k0u+Uq3LDB5kI5cFLqcTw5TabJEm9WJj9ToEMPAIskSZaTLfcxb5Il4LQge6xr8YYgdG0hxeXCA5Dn/Wtozl6fRLgrY4vCmauWgpnoCD2Yf8GZ4F/8k6ByFhrYHY/O6vvrFvQ7OHh6H98vMvdn5xJr0sxC0KU/YepCIQH+mP0T6ulioy6aCpzN2a0l24eMc8f8ggzA09jJ0DcafvwdpA3x0EaUtnyxYslvbh47W8dYkhA/3gTOFcIOORSDy6SL43hRR/ZTKxDDsKBQ7pWDNaMY8F6aetf4QfdUPkGsHS/A8ZIN+SDcdPFiSMH2qyZGOksg7XktthREExhEMNHfRskbWj6pFlck664oxUCHEe+RrJNvabRMPTX7j43cHLQ8QLv40BMpi0sBcPEDmXZDZd0udAqsc8j/AEfr/8UksgXt616exNhDnruXDRcn75O93bYv6kc7/R8DMflqzM8oH9l1xEWDDWLJstaua9UPJO2oplYrwo0GIrQxzKYoXnYye0rQrFLuc0UuDiJU8Ttqos9w7fg3XgSJ7wBzVycBt415zhsuAMd0IF8bs9Pz+2aLfyOLjtTilAT0/Dr3tR4ryPryiDV16MmJDh7hD4ioYI43DYRz7rQG/HwS8RKjVhFsZVYOl0SdXXfst8jQ3t3q2087Bls4XEajKsxWnBae0Krc3nRF5QBBSQj9vvaINIvE+UFiytHQndBMBS2QLTUN3SBZodH53Z/+Hv8/aXP/0sijILh7kU4Z/nlz3r9uoWxAtbbUaSOnDpYY4RbALvbvbAJT6LxIGef5+PkaPD5vRIIQ3JCG/HBULzH1XpXAa+kblA2cB8br58toCHIRZLW1U5dFbAPLzIz58+2sP90PM4J1NR2ikgXr06t//jf/MfrNfraK6XV0HinS4nq7ocmRsnCj4uVou2x0S5VrTaDqiTRZ3TIqXQgWRDp6IxaBq4pWQ5ILhM3gqClgO7PDuxZrNkdTorJALLhVz9gWOYFQJNA49GISkUiTXqJSsX6dAQTkPtL8kFo9HAxs83AHNQWM7MEXHFcWcPtyLz+4q5pRdlXBZnZ31ZjolclaMS3VsQBbJRy2eL1mi3bD5F2J2zQqVuy9HQpou1tZdYi4EQYITvZtBiXGZhPye2hZEduXsSnSNEDVxFmC3yHmF4c9HTxYzHnp2pUFvgb1jWmCxgKJ7HrIFyQ2ptzWMeH56kF0OAwCaHpffDj5dy+GHuzwHaaHlKu/Ib9zAnCyKVhaHLHpg/pVN+EVMAckkOh1P79cOvNp+NBeVyGfNsGw1MEDzyilp7QZ4h0Va7tG1TpHUAQdV1aXFwYdUXhMQN7Ww0XthoONZc8qjfs9dX54cEGeRIQFvIF1yaI0Z0s2mbcC/SFu+K2RKieiwVVxvmtRmPWEIc9xLFRjdP8ZzJ6d/H6/nxmecSKFWD2RhB2ETw4ZQFyQcOAkubn8H34rJ7mfnLDpIzIeMzUdYNB7fyKcXI9bk5FzDSgZmCuxlvVA/EqazNFzNbzp1Fz4GNvygXPfIsOceIAcrcDHb3WoQS9rqSSOQ65YUEfwbGK90S64wzSQ1GmvNxLmLOcsNa2ClViZg3kCsgfWarsM7hYGAR2Oo0hXQAnXIOWpyyAjNsdJLApPJ5hqlOhFikC4bn7SxsWNDeSfJsXohhhAzw80i1QXZVapWEtj09DXz+mmY+63NARmDuYkOB7Pmd0omrKPwvTRCXZzbr4fCgYbwbin1vACAunVmlvETfZ0keCU1L3TToG+fmdje3XGDWLBVFquL9byFHpjBccVjWzS/W1m6ivQ4kUwzDlKeUQOoS+WwvJEpRXyAdUazisZklHqwl/2rJ5HJVCzY7e3h4si83dzadfOU8yowVLNhAbEirSleaxGGm8AK18AJf6OKy88pzoBS0iLjcVGWluZzAz6FUefZgES50ymyx5LJFHAqJxQ1/Bf8w1E+53RfwgXcdXlVAG/aoplgicn4fXSSUecGiIXDlSlUTDwuq+HG/raoFckiFTMxa0er1rG2iqW13ZAVizBwoJQCzZPLVYL4xt4KoxPfcx0B5HomTln+ru9jzOQPspdKJ5aHYx3QxnphOCycj4DCRzZqcWJQ1t7HJ5FmHwNX5uSzPbj7d27/845/s/m4gwwOeH4uL2dbJSdd6R5h/u6csC9s1Wil1Vnu0mrJJ84SIFL6wSG8wDdBhHmseqKBTTI3DwMI1syQ2KqL1vATo68VUaQelTNrqhax162Vr1UoWbZYKXYUlgxE+/qh0iqwNnhEs1F24V3LB7358I7upXK6kdwJxYzh4tnfvj5Vcz+GDDABkgQIM+7/9nvdN5U/skOmCl4C/lBahRI4nEDSSwAqlqjoiZmew5rKbneWxv8twKGDHB+M20EXCpQhsKpY22kKiwjKesh6sQstCsAIAgrCw2dloMtOhotDh5UREhXzRrNWqWaNB546AnEOZvEiION5JhruUtIp3d2P7fH0ntxc8POm0kbT84Q/vfFPhOGU7rctWu2y7HYUGM6CC4qU2QSiZRFJ2KEwQPekuy7lCgGHUNpAp5NGFFa3VKsnYP5vfSzpAjBVoBDIhilgOUggxAakV+IJm0CxmlPc5me1sOo9siil4EFm5hJEEHROs0r0gf2kz99Dv6RbZCxA7IGlwUMeC2jGAR64Av0A+xNSzMTO29YH0stUlWczmBd8Cfd5ef7Hh89iijTuq8E7IIqxUmVtxuTiRhqdFx0r+oXTTgsrztt2HlgqJ1IMQ5YcmXdk+KmrP7SgAsybzAT5vekNwck7F1eX5K8uTcFKn83RTfzrE56eN5Sxjx72OteuNgydrrBxJEKSXkGvQEtZeGX02EW9LXMmcnMfZljGeAZKLrRC1XRRpbELIN0xMuYcpBotxRGK1qGS5HabpOekLebasKy5czbbY0/JezVu1wlm7VMHK2pC+MVd0pyxYT00nigHd8tmBPBXKALv2QH5rtAtWbZyqCIE0hn0oeY80FxzxyhktcFHyPfi9h9BxGZc74Y0fip4TByzIUWWwihAdKfs3saN+yyZIz2SMEdgYZEuOYokVsnkFP6Tq8D24G9ivSwVC89LIDU2kozfbYpiAZneP4gJ9M+MCuZjoc/J5WB8tfIjR2NbK1m427OKsb3sSkdSCmjScNzf3dj8Ya59+1YuyVe/ZeDL2aBb0PPxHyi9FVSzkwmkA7JWdi1B5oBx8TmkH9vJgWA4EqnEqBh9Q016zSKmiGPrzM3x+5LM5LfzExdwvRBguXRirIgHhGpPOKU+PBchhp0s0YNi/c3ZTgqUdCy6009OW2G4uz4wtQLoSrZXnRyXjNltVedYCi2CFR2FcODyyICYMmvmMu1boMyECprI+iG0hXRBpBJTJYcmCwoj78WGoXL7VHAozutInpbt/8/7K+s2epeK1Pdw82nQ4s2BNnBEuRi7ObrYK0tYxvyKlhS2EMgQeEIUEEAThvqKAx85wQ1helO0XEKisb9TxtFqYAhfs8/UHVaDMl1S97iPR2+uVgs3GCzs6O7NmvWA5iB8hlnVbFQe9TksDdYwgFIa6Is0cOJoLIyUj+zdv3kiuQOfAph9NhzbVQRFatVw1yzJTwSvUiUk8e56Z1oYGTv5+vZCaycgb307Mppk7bQ6H8mI2PYTZZlmeOshY3utlbOsFMDmetXQcaptV9dMR0H0mzHSYfZCiQDg2zkz8vsVKYa+FPOsA0f9EMUUUYHQSGYPFWtIsCCkGf17kmflOJvCwOpnv6JmnYHRuD+zXAwxP0ReCyvpnlcxEer1EeZyPjyQ0ZK3faTmEvYfIhlk8ms+MXV6ca07V6bfF1MReD/cenJYowibr1cFBiFBmqu1Q+mNkWciOKLA4fJ6f53b/NLXheKn9wvqBCDEeLoxwhXQBQ4+Q2s9KeaRA7tkMYzKKiFbjgpjZcjVVQSBhfI6IMQpifIsxTw8UKo1cgXm757BurVGrqHv96U+f7Hk1UrA6HTbIkxCGNH7DrB1mV8xccYzJiSfhfsgpGanHIfNTZ4NK80iy0Z4iKLHFamuDX+90kbSbTQEVhA9wtjAT7fW6lnS8EAd6xdlrMe1bEgeC7PCdjkDSiinLV0qKBSTujPc+GkwsCFnvGQn1/RkTGO0IRZLis0MI8iSkEtaUHCBkzKIOUGecsXyRMRQFXNrmg6lGP8zoZE13iCmkc6eIYSe3Oy0LdxQfhwtLF10kKBoJ1WS2sl5vaxeXR7osISShq4Uo+Pz8rOcPQlcoVzXPZQwUhnkLNusDmctnjgp+yLhJCZIeCmP+uRKQMq5dBFXiHKpUTWMdtI8gRewJbjkMHPb10sEoImM1/KqrJUs4uIRMM/JwU4Nmk7WesjXQ/dbRqEymqQB3SXMwFDhoUIGFec4eEpGV6xg6Vu4ImcyXS7bbrCzcbOzV5ZnlU2l7fB4ovm4wnNgUktHqK7Ne/6f/6X/WjIsED3Bs4CcxqsirI8EjBx3XLzG/NLCu8hZcQ3W8XtsdQVXAl2735nR9/ny93nD9I19S7FYnE3Ag0Wmy0elQX8KRuRj5i0VXKZYlHpaDf2I2nk1/E8KL0UcnlQFqcmNfz4DbKg+STqPMrIg0klxN0TkweAVPyp0kbatwqUtHQVEsMKQEaeYW7lyjqCIYkAyZZZuHLokN7hqkQr6hPDUcQp4eR3Z/PxC5Z8WsVjOQnL25urDvv30nLRyeiOGOhAp8dIkIYwEW7Pz81I5PW/bu/ZlkJrGCadM2Q5y/RqdYEtzAYZ3JbNxfNkdlX1BJhuB4L//OqroC2J0fPt5otlEjdSaztSwzH5wwKjnrn3RUSb/75pXVykULthhFBGKm8XnyGKlnMXoG7oZUgCQnd5hfAzdDdKDrrttmE9lkOpex8cPzVLMB4G4ONS4oSTZwL+Lfg/1JR5JzEgtrAWjqp798sNFwITbd5dW5FQtpjQKUE7hhxhJbXUHB7iCC5dh6s7VyNSO5SaVcE1lGFznFTNZzEF+s+UA6NCbIoa9s2uUlAcwLxfRAtMH1JMeMOoLIgF0as5mqLj+gctHroQjtExuOx9Lm0iksVhSQrv/rtPtCVmQsD0kj4wJ2wPI0dEcjz2+t0QAwH0L2TrtuJTrgMFIc07bAfD5tjWpT8B1yFTpyNxFwLSP/Lhc3hZh79GKgEMq2jwNXaE+OeRgmGOT/gWrMPVoJq0bgaIvtzesTDyQAKpdmloM+tnwGU/xnZWzOF3SYO+syQ56uLJXFZad6MAhxNxpBiJwRCrimcEg0q8wWSvbq9an90z9hNj+2Iqkn2ZQdnzXlyXx0VFO6CxcEUVnoQbEho7BjfXNWsK7lCwP9OuEQBf41e34a2+3to4UkGVHQYclIuDF8CuZTj2OtWYwS8J3GEYbLmbDmo6Mr8Rq4GNa7tTqc9J7DGSIZqJefeZoLl3DASksS9fw89LSQUkHuOPKJLriM5CV4XiMbFYRZ43Gw9incdM4ZCEpdhRDnI3Ax3SP6wz/+55/t8ZHosMTevnll/9Xf4RzUdBMN3KPYQzF/3lnro2RqZ2fHBxLxwf90CcKw07lSqiEDYnSwU5IJ0WJDzT1B8VzH6E1P3uVuB3kVZ2cByznGXQGmLwudsbDOOS/uF1z0FIUYWEA42sjWkqIBExlGRiXsLwPQuUDPXmhgaOoC2RuUV8iJtltPKSJ6D5cdRnzNt2e/yXwclaRpgLnt5NHlAk9aMpMXtphO7KjTtHq1bqsF2u1DgsjWeSqMUL7qRckgmVkeUgxudkVJhbEOdb8M/Z/xgNGBcWlSvfNBqCxYVEAJDJJ5qFRb7kPphuFcXlxGqvJJSJe20WeQQG1KwAYzZwfo9yDQh/Tgm1GRSjGkHneOIRwaGDfLIUfXRcg0Ac646qfM5hx0Ih+k5TiPDlKJ7A2fPe5DEsihn8vGWd1WmuqQOCjFyfjwms6J9p+OhEtVc5gtcDT6vJzo47c3z/ZP//hHRSHhAEKCCcP5fq9pFxfH9v33r+3ysmdlIEuSP/KJwqDfvrmS7pOqmueJ8B7aODKV2YZOwaQbGo6gqzO39TxALhdSDYBvqKqZZx11zixlRQt2M0kkoLjf3d/Z3d21/fjDt+p+PRXA4StYlxAuGrWaNTt1Qa0cYBzMSDlYzFD2U9DDdzMx+XJ1j+qhkKBShpaeZLOiguMAhPiaqCxpTeOUOptccS+iDnMQsp3ElIY1jIsHRJ+Dbuzh7sn+9MdPNptubDLiAk7Z1eujQ8oM2ZZlXQryINbsYyPZBGuy3Ubq07DlsqAOUOYMutCwEPN1+4KCcGgB0dEtfP9Dye5uPeg7r5BZxMoclHgH07k4WYIDEK9Y4E3igGB24UObzzlxYw6sCcuTuVyjpcspv97JN5ZCRp6+QiMoCrBVW9oGkXYU2fPTo7r5Lp6W+9DzAms1PRecpRhrpJOULo8N7lkcHPIA9Sg6JyxlLYE6byTc1HTJMntlnXIhj4YzrROMPCDiMAcns1J+yRn2Wc3SKbdiHA7nTuypkh04t3//t3+2cgXovY6TpS3nKytVsiKdwGkA3gfZoZuLscTj3Sd76XI5kDe7paQv3/7wje3jGxHodDDlgNA61qiTjZi2wfPc/rf/5V9sQvwaMWMKjC5YHTZjt2bv3l5Jo2vJWnFKMGlBbR6fhrbehNbvn8ocAPkGhUqj1hVSQN4jRRvrBglUImLNyo6PW3LP4SLpN9u6bNDscVbUWy1dYk9PT/InptvibKHbr1f4Xo4kcU5SJDAHViAClxW2dpgDlPG0pajMiPUpb+IlodMl63b7WkswORmfQHIZDWZ2d/tsk+lav3tUX9qe9x+bfGd9/ZaNMjeJtzYaTMXKH43mKhJpQlzy4ekzL3FzvBP2aQFCIXPDnM/FgTc4e4G2E4Uzu44yS9eMQ5UQOjTuKTvqdZR4QhoNhQud+W9NEzyPCKMZ0BA3TYerwNkh/klIJNbW8gRZGCYlM+XiIuOhmbq9vbfZeC1od7fBXSeURSf3DOuYkUSwZ70y/uP8Zw8hkVna4PnZtuRSrtb2PBjZboOigtEdHslI7A7qiK95Uf74ww9WrmYtAZs+/Ku07N2uH7Cw0ZgpQcpQzJByvpLDzJAZS9oGwyd/OPIDZGbnjFA6Af35MPFM2gPuDRav7k4ONxhU+1AaUTALWM4diPU1O0EH5MHFYPHSGGGxt4UCjp8jWh3SIdDEsQEQzGIVB4zmQ3yST+SfvudARKiOno5OMm37olfqfEcwqGzkzFUuDS5b0WeYJaRgHlaVPYjs5dOHW/vH//QvdvPl0R/33qzVbKoTef/+wi4uenbUa1ge+6mYJI2tlfGUzBfFiuSypWKGdQe5YLHzZA/JJVaB8HYWV/+4a3lmNCSKZNK6QLk7K8WmrUspu7ud2M31o93fPokdDIFqPp/Y0XHLmu2ONZt088yYnY3Lc663KpYxfn9iMcbCsilEI0SAc2JPBNFmneaNbouDQQkSiQnC5OtS5a53JMwPbDJfqOqGyANtm1BoOVSZO4XkixnbInwVaSOnCpROkuf4/Dix3Zrv07ZyoSmXDbpqcFbWTjEuHGRINYmN272WNdo1u72+tcFgYN98eynoF5hMcCDMWtjROJ3IzN3dTjgWeEk8B8wQZNCdwRAeXWvRquWKNFlhDEQF7EdwNckyIAfoiCFmMVPLWL9/JBiWQ4cLh88Jpf55MLZy7Vh6O5411b5gOhG9gGSdwV3IlJSNyUbvtNyqD3gJow8ut1gEJDdFgIbPDJcLLIgI1M1aVNw7mxeSjazE0I4CDWO0AaKA3AbPVp+1r9ah7WJIGRCv6tLJMpMCiuPd0qFD1Gg0u1YuN61SXokgR4A0htts3t0aFAnD8cAaVleh6MxiF8R7jmpeFwnkPVARJnrnZ+e2nKdsOHATELlILRb26vWZtTtt+/DrvX368GBJlNVlDDlG8B1zs6xJh4lbC3uGs2W3Haiw80Duio1GYz172LwgBy5Sp5smcQKZ10ajFTxvGb9gWYicg9xRIq5ghmP+X65kNGKAv+AaTMY+7s7UatQUUO2h9fQ4Pr9kFLAYL6xUB3kg0ByJSs5D20VMhLGKBSFnkxNu1FHKLzdruyBR+kgYp61aaYtjMB2v7cv1rZUrF1bK468bi6UOHP5v//Yn+/zpTvPGSr1o33x7YbkcRYFHVO2LPt7SXk5Mfs9ycBqPJY+BHMhI5kXGFh9kgXRudPLsVwLhQWdofiiS5XCGRAYwLYo01qI40P5SN8nZTifOWoMRDrLAP4PkubBMHrtFkn221ixWbIf93GRtN7dDu/38KNQJKLVazdloCPMdBjOwqzddfA9ga9fMgtL42VNsYukYSHuNnvl5MNVcErMxL8KDr3tRFg43OoQT5jqi2O92gvqoml8qRB6EC6+d2EP1wiHEC8CGi/9OV+JxPE7H52JSRJUcWoBu3RvV1QFcrPysrOUrJGy796WMxhnM8eegqwMDHBJJEJ5G0KIJGQa/zuZkSwa8y//+opdjVgTskC80VOUyiKciEmmHTEppl+gqyXEjCQRxdU4zUA4ALkneN671LIR0AWyfyzCran00GNl4NFRH/f79W8sX6CAgBiFZ4ZDbWRVNWwLLzqOFXqAzD6SmIvNZLtXgcj6z6Zzh/UaHLBcAtmjqhKtnqqjlhrHZKT0il8ayL7a765F9/nRv19d3YgCqkrVISfHfff97qzVbVqigLVoc5qxmpao7lLgkhoOOuQ8wB1KFkiBX6b7oXKuwLeu23ZIgEvjknVeZSamLvP78ZA8PEzPj8sNEPbTheKocTA5xrLlK2KHJyfAAqWspeNIHukEOhiRmPdUsn64ovgu2c8ClBRlJxY5Dl7BGgalxpJnPJp4sIgu6sozEGxQxcixxSJ7n4bl+7qWLg5Q2YCaxZssT6jdLbMaAioD4dkpeKVEEHuA/ugJP8gByzlm95kLxwWCiQxBBNTAsh211jeY0a9uNz3sUDA3rjw4V5x3yPasVK+UqNhDzcCN+QLfdsHLZATCgcy4/YFG50yC9EFJz0DYqnQa4k07jwITG4hCW5gZXm71gMxF3KlVrKhCYZ72URAVqPsk9+SLwtks9YAMTcUfXOxpOPb6r27d0H5b21hKM/mtNOT5BcuH5c3HB7CTfcjZfW7PQEAyJXhdSGzpPyDfAtzC/S0UKgoY9PNzYv//7T/bx4429fftG6xb/XE4sLtxavWNn50SWQRCkS4BUtFShfoYPaK8ladV4uLQ///TR0mRTrgmedgMESCg8V0zw2+2OCkcuc84FDWPTiaQw4T4UqYvOjMKbfRnvU5rVkgkLNMv4hHnbHg9lQddSHtJge/QX/AtLbLbbitMg2JYcSIp9dmJur1kqI4D1aqNCjCKeLowzlPnsZDpVQaLotzgt79RPn77Y2UXDyhSYW2Qm2CaudO5wtuGp/fT0bG/fnep71apYgbJGPTcYpqrzMTz5gzXFeCFTqwvelavPIcwhORgZAI3TcCKLqtaQ4RRk4E/HuZrPpJ1lDkquaz5HzNjKYXZcggBItb8PKUiHnFo6Qb8DOINgEIMmmvSkRGVxKUP6QoecTjW09nBOYubLz+K7cWYzF6fAmyn0PZDpCExckJzZfGXD4dCuv9xJolIsNyyVKR5sQr/iRQnlm0NoTRW+QNM31Xzy7JwZBvCO2z9xKGnulHFcG5umFzs3ujy6Ph4Wi0IkDY5PCBXILvCLRESL1m1LtBWsRJw16JSKlk5ytltvbKOkDkJagRa5TRlvO3UZnSfnNFUNQ2IO8XrVTXA94opQYlwfWJDoLd1tiL/kxi8atTMSNasRW4yMQOQLSCcQdwPDuiCXy0IMMZzt5YQB9Mr8ig4iZ+fnZ3ZyfG5L2H4HkhBmybiJ4BSyXs2UJ6k8NTRZYqK6C5AgHIoGEP5gK80cG3/wTNWNU8bcjk/a9sOP7+z121NnsqkbTmw5i21wf68Z2+fPt7oguHTQTyr4dbW1Xq9nJ6cnqqY5zKGYMx/BPJz3OZ5MbEdnyiJnfVN47DO23kW2mq3lpdqolFQVA0PlCymF/goGTjHMJzWDmS3Phh8A1OYdI7+LWSBVp6BQLOXEanSdLv87xYgOijXrCC1pYAX542JCDd0+a5lCLNcPdHPKztws3UWmVLRet21/+3e/t9USXR5FlbOEgWXEAgSmPWROyt+WuYw2sWs4+RxAtU4OgWjknSMjgmI6q8OYg4f1KsG/ZW209Bkg2+Xx+cHGE2anTnPHaJ7NzUH3cD8QilAsM1Yw62gmDqrBM3Ejd4owuiY6X7qBeO8OKnR2csEh9y/tc9oeySw6/CBWuMkFsytMJdCdkocp55S0+93ynbnoWK8cUOzBYjFjlRo6YWatzDULqvY14wNuZf69hLU8UMg4SAefGZII7ELYqtgwQsqTYxGdOogMMihZofk4hWJJhzXXjATj2IytZXPIPmN+ha8ns69PH+/s6WGsgqZeLskL+pv35/b67bmdXfTlGYypOO5WYbyy/Wbn79QSpUtcvrqwertmH369UR7mzc2jPY8eFOheKRMnBSrWtHSmac+DexuPRxaEmJnEYjhLH5rCzzRrpVL94GE8sU1mY+UCcGXWUhzsYWIFckuT2LZY+e3dqSyPrSXflPg1HIRyGcnNptFYxSjddZE820pVRRTvTD6kaf59nm3FFsuRzPZ5HlEhZZVizbIl9JRlnVsvUVgeNeZm48fHHnDNf4qxu8f8vaMLkS6YhoGLniZGGarIwkrunAPsLbKai9aNAoL1L5/pfeIuaiFjC5+LYgdHviY/6/HpUUUfTHgZxGxiIUicS5KMsJekh3eFAAUYxb2khDKTYc0ESi9hfpyH1KmZMxrZ6LeLE/iZWMLE1s432a20d16/vrBxfW13twNxQEAf5sDaa+b+Y5vMFo5mJTwnUKPS170oWeTQ21eQYXYrsVkxv+Yw9By/vOjAXHgvXSS6QGev+kXKhpfGJfZqwrtKZiEeE8RhDYRC9QBGr9kgji9RxuKt2ZrDQRBXwbIw0SQ2BR6lC8pbLgOTam97Otd0Vma51DFcztPZWCQbKg8milTbHMK082xkLm9F36Tc/YOqDlyQ/42uuViAScrCgnLvTvTKUszT7gNHJLYhBYXs1J13xRxEsE5xNWK7DEdDOflzqPJ7gfJE36ZjPKSFy3lFl2VeBCVYXnc3T4JbOHSen55ttfQcuZOTtv34V2/s8upI9lZc0EgY5rPIpqPI7u+fpL/ku+FM0TnqaYZJ8XJ9/cnm66kFMYN5Bf7IxZ/fSWGA2TCLCMo7MyEOP3V8uaJclJB/EKYdmRsZcBkwf1ZOIvBHOqW1USyRPlKyP//lk02my4OVVUYaKg4JzX4Uy+RFhJtKuBOJ3FClOXW9orRauY2yIrWGgHmwaVsi+iYmDYtA71B4xlevL+wqdWZPj/fqEDk4YE/TuaOBZPaTCgi/dls0Lh8uatYwl586Dxls7KxM4LSE/oFVqmkrkbBSpLtwlAR4H3gVQwiIVczGUAnJ9UaOJX4BA4XSuT0/jQiak69t76ghFulmt7OirPuA7mLbhc66JBAYkoMbM3j0F4UfhuBLTBbyh+6oUNRck0sCNIpZLeQ7SDDo24C9+fMve09/FinMcmW5YloOSBHyBMbFWcYdgZjGhKxTeAAbbsOlCDx0DlkFJ6M3pWugmm9ZueCRc5I0iBCOzMfNAtwtxwtbLmhGFsyq5AeLX28xK4QEwwCgNcW17fc2Gg59rlZsW7fbszdvj613jLECMieg9KwucQp26VkLWXUNo+lA8pKrV30ZbWAbR5bj08NIKSKtDgSbUJwGYNvXb/8rhQlvA7pqkkXQ0zormZnZ7f3Ibq8fbDIaa/3g53p+3reL0560kkrMwJoQCzXGRDBJ8W0uFxVUUCuULaBr1ewuY6mAzt+hv3qzYZskch/lMCXLuFzsbl+ecOHuTwTM83ezUZc/bQpv3RIIG7pv/GwzMq/vdI/t8urE6k0kZZAi8eV1AwYvUPh5HHc0B+5XzUVMJ8v+I1Ad2Jj13mo0bD4f+wwfr+kI3SyqgJLtQBn2kZAXdaUbgs9BeNBCJnZ2dioiEoUtcDPvE2Yq770Yo2oAOmKtMb8mgabuYQT70Nr1iohSBVyHZNnp3TqXMucRzVStUXIZGcYM+M9CdtvE1m7U7Sa6lzaXhBVGV5tdaCFGBYSiH9KTGJV81Yvy8+dPNp3MxOTCAQa3BdwX3HEDCJWNwDwr/xt0yQWqCxI7K6Ai0fIRWmOcDuEgPAhgOayhfzOfgahT0iGkDo/BAandSU4078lw6jCFjNWpvIjXyWp+xi3FBScIYUdV7J0kF97LQUmbzsLzzc9Al/kNcJvbepFswCaFyEKHorSPgxaSy3uDEDxwge18PpW37PFxT2QGGJ4MSYGcbr882fX1vdWqNfl2ciHm0mlrNeryV62UudjdoEBwD90KODFEJcVC8RyA4hxHHw7H9nj7YPPJ1Bqtnl1dvbZXb46tXEPMPLUYWWFcsNEA9iKFBhu8ZKenFev0sM8qiRXLM9vs6tbt0wHxTIhzqlsuz4Yj93Fra8yTtzsdhhQ65VpFRKXpmEgbKPf+eTEmCsUCTKxUzFidOKk8M1t+ss83oNq/e/vG8oWy/fLrJwvYgNKOEUI74w3pUGaTpdDTitXsUgYuy0IWuCjngcsJDOiJGG1h2LNMuioIiIaUDmUxmViv17dsBg3vXpuXjgjROtUt8B8HJsUXomPZsRHEzRz44JKkTpdYKwWKAwlBnnL3JvSdhSLxWjXB0TvZNe6tVHKHKuCvHBFG+byVazURVYCh1msOh5RIbhQR0O2x2YMpOhiOrVZ3Fx+KAv4CmaGKpsvm/1+umMXuDzA/2ZnIMNJWyeVlOi0jd2ZBjDx4ZsS+rTDCX1sxXxVEySVFTBYXNJfJ0dGxHfeP9PN0+ddydnTSsiA4PQQdwJJEUpCz3nFX/+4S9CONXrKo70vhhjfw2dmZ66fj2NbbpZ7heDnxjMt2Q9+DyxILu1LR8yrZl6BPwNx0dM/tsf3807WKqeVqojMF6UOvX+MakYTk23fnypQkXSiVDtwgH9eiEuHJeZvPZjYaTyyXLyqKjEMfCzoO05OzpjploLZ2h3UTCXblcF6uJ3Z7t7BW+3slH4H08LMZu2BAQRTVn/70wf78pw+2XO4EcReRIzBrzGatQ+B0Ia0Q6KKlrd1oijcAKQtTD82DU2YVYsjkREX4QdpSEZ1WYGuSYap4SlfVgCi6b1ew2XJpd7fXNhiMdB6Rzct+y+ViOzpuWJvwby4ZcSPceq5S7YhcRSjC0XHPktRaDlhy7YkCXW7MMVlfdL1c2fT0YidLquKqBUGgMjFAaeAZuhSCKnNYY8oK9YIYSJg1B2LCuCLB4WkxU+GSSrGWiVKrabRAR/5SmDLCwagEItFiRaweM3DY25gPINNJW6/TsMVkJWISIQCNlls18llJLcLqkwLOJXrcfaSQHGLBDqxdqnGKSi517g6QQf7iu8On+KoXJW4Z0rC2224ndtrRAkUmwsFDVcGBvpp7VeLDcoeGgCb5oNUyov29Zhm8GKjKavkhSFB+0xdmoOxzcOT05/YRBAG8PBeCq2A/8kWJ2aL7YkNVoTbDWMMRByo38VLxTgeT7KgKdKZ5Dei5mHhRVCWQdbZrjLLRPMKaioRp87K5XF8ikBIuMQzew8Q2W/B93ParVipikDyw3ZZhc9E6rZ5cdH79+d7+87/+yaajhTWbTUK9ZO3GAdtolSxXAIqDGeuHovtcwX4ECtsd/DwdqmWx4jJ0dFSwarFp5xdrGQjgNANjlItHZgSFuhVzXXt6fLDrz1+0qKksgWZhh9bbFduGSGO2li8Xrdk80e9ud5qy6pqv19aIcS85SBeAUgIE6DMxJel+t8FMTkEM04HjkjTOKwW7ujwWMxJG2gukw5m/W25sLFjMTeWJeCrX8iJskbVIDQN8zGEZxnSyaZecJG6GDTEryXgSxN/87Q82Hs3s+tOjlWodO708tnwxsg+ffrU49mgzEIXnJ6C4nVJIypW208hDZxdyUCDJYH2k+LkHaB3YinqVv16MozkoBLtncpav0HK7ST2fpVSGWUhR5/msHH4QR/a7SL6id/cDzaBbhABUWzYYRpqlVRtozJih0yUw40autFOxB5QPLKeMPJAWYPwNEWo7daHk8OU5mAjtjjHpLgnai43L2q3PPKD84Pok+JVLFM0z7POMvX5zqQOPwpRDjG6VNeCEOC7FjHL+ZFCv5wIkR1d9SLMpIRzCRYUEGJiHTtIjkm04HNnkeXxAHUjTSezLlzuhKN9+91ZQ3HSKRRyPEtSAeSZzOBypZnZ+3rHPR9iOba1WLQn+L+Y7OowrJc/ZPO7j6jLTPJGRDDN8nFko1GBJI1+JwqmNRkOr1rZ2fskMPGXPgzvFqSE3yeT2dnTSltMQLkV0toslmtmZfbj+xSaLpnWkiwXWTGw4mNvHD7f28eO1LZbMNAuCColoozjknGL0MNsubTp4skapZCfdnhWQuuVDh8xjn+vjCiRnL+w6NddviIm7jjc2eR465E7Br8gqxj2gdGS2Fu3q6kyjU4hXMKdfX11ZuwkpbybEg1qbdywP1Tz7j88WCgGEQwEDfoNRiC4q5tqRmNkoDjSSgmQpmJXLkoB7n9trfhnSdOB2xpnpsC0sWqxLBZyLUe0scH4/BTfrS4bo06lHr5H4IuTOiTeMIiBr0RQUYMtjj8e+gDwUBjafTuzh7tYGz09CR96+vrDXr9/qwk9nQQbhqOAUtxazG2TSIwF3TqRK7a1Zr1kqgSwU2Yq4RJ3l/plFPBS8/JUvyuPTrlUrLWu1u5ZH8FlEf5boMgIuC0Lo8VtZwrH5qMZl95Txbs11cj5NZEYo6DNL5eA5ku4EwWDexaf8d6oPLF1n463dXD/Yx18/2/MzsAkQ24FebMx+cCXBSLoo1hPJFc2mR2NxkQOPlmtFQYVycoCdt/UkkcVsY5vNRBpIquJSGWJGWgxMhYZCZEJDuItU2T0/zUSiqELvVi6bV2YvXpNPTyN7fAQ+jqxQqFg6gdgT22JGUUBEE6JrLmYuSypWIokSwc6yYlJIdGylSkVCZVxVxFzERitBh5azIEEbmNXBm8lyOOwtlZTEgoQh+eHjB12Ir96cWGwzK1ZD655+I40i6RjSv643Mgdg4bFBcc4BYhpP0EAFEvXjbxrEbpY9mc01CP/44UFaxmiPLCatwxYLNS5XiDVpCOq4bez8O2NIQMWLt2+11bD331xaJHiepYfeC/IRkqFIwc+HHHB9J4g+Pu/c2ftvL+V1CxR4dNpU7M5yNVT3gk8nsM4+zbyF+fPUZou0NXEdQSuW14BVXa2isuKD3RmAs8YAOBSwidlEwPleIEmWJHgewwGHyElGADGh4wb+ZkYT7YHizUoVOi069Ko9DkbWb7c8cDyLswsHiieLKBZJ9GqvqjUb3XPwM79kRk/RSALM1tZbtL74cnpsGhKFcrVs+RxFINmYGN5TFOQVE8WcR7CxdMgUBVubL7AaDPQ+t5u+Pdw/y93n6elBVH1gxGIpZcsksk6nLmkHhuEcpugzubzrjYYOcViy/O+MStjP3nnspcmrh6xZ9ph7eI6HE3t4XKrbU3g25Qg6W4wD0h4KzIUA0e+of2l/+MP3dnoysVqlJkQJMEmHbg5ImcKE1CB0wAUdzJtgY7kEQgnELuZyHSsUarZcL3UgQ3KDlPQ8eFRBhvYPdjezZGA6N4dYWHsLXMglDKFoaqUCxaKno8ALQKCPfI01i2SDfc87ILOS/FRYvQU62OKpTZ4Hdjd4EnGw0WmaLSDabF33TYh7wiwaVyB03Q6B091hijIeju3s8lxdUokZHXF3sK9l8rC3zKtTeSqjGwfNg0i033oyD+9aZjCJh3tn8E6NcZna/KYOgJ2KpKhZr9p6CUFprAKC7+NBAfjdzrQeSXlidCIuxJLn6XK47X4n4hojGkwUKARYA4wDTk6PJbfhAlaqTN7hXC5mCLac+5pJH4zVeS4Uh/yP0qPKdjQl16ndZiPm62w4tTjKWL99pJgtCIOgcozJXHrkVnVcfLSHyPk85pCmp2BhOSMjDEkIXVJxMMwAVg8O5fFXvChfvT334Eyg1T0OMNDyOcgifRBeEt0aD46/5bWo+SMkFWAOxLAp5VYyfKY6oVOhClBWpWBUZwwytJV/YpSy9SKy2+sn+/L53p6HU1tvQ2l2gHw08CZCiS+ON2mpaK1exVpN16/R2TKXhGTA54xFvAFaowKeapaYSZW1aB5u7wWdITbuHzdFFKD74UCNwpRsvr5cP9p4ROgnc03iuMz6vZadqrvmEGFTPeg7cVFH5F+KAAquDrQCUaZsmSwviQguiEWIakPh55B4OJBKpJAEG0V6YdNEKgaFQhKSsNFR4Gmh7LZSQMyqWkXPxm/TRBCZzhe2XJNOAMx5Jq9Eihk6JJ95OBONReUhpviYjsWSgwUJrMYhgu0cB+NosLAH5m74YeawaeOgc+o47wqJRKvVlrwFqQBhstcfryVkLmBQQYZjnQ1YtB0MweQg6yg2bLspOGNTuXrIebyzRuLAJmKdpdMLe/32yO7uT613VFc2I3Twbq9jnz7cy2aNw0SQpQgRQDHIOtKiqkNMyhkQHVo7T/wI6Zg4vlkgh2ratbv/xUdUEKOIYciVXnRtjBLI3iM8GYTiEMsUJtJtJSmIUWu7uPxWEWkpY36D+H93CDBGQ0oKxMYazYLWqfRrujydxs3Ppqqvt+rWaACZY+oQy/Kr02sr1QOUhg6FvUTRxX6AoEZxylyeTNhivqxE+DgGrk0Eh45HI0H5dMcwBWWEbTl1jevl6tBpJ/bzz7/q+bZaVX0fDpdqtezuQqxLnksuEYmsnqoo2B0oGrbvaDzW3JI1jdZ6OBjb8UlXlxQcBMhdwNt4FeMWhK0bnSSXAGsAH1YYveQHxvFKhTX7SIxkvRu6SPd2RVrkbjF7rVeNCjIcnGTaZkRiYVRCfiroFXuaS7qeQ1dbkCmFuvCETM2Z0APY9jCQuTAuLk5ts4ukIWVeRv5qXWhN1zrtsjF6yxbTVm21BPfDrgRtCYHLi1nrto900WB9p0sFRjtdXRgoQD1TyFhW3zVruzVoR8bqtZbd3t8JSmcuyzNpHggunCnMImV+ICgRGYrk1gomppjDdBzeQl5hzG7byD6Gjwv7l3XGBcxoh3cpdq6yV/FQxm3JjdApVNYY0asL8+xcLknOEC46RjUyBDmwWmmSQDwg9FBQgtql83wWSE9pi4nSW7vFp9x+OLAouFAf5Mo+x4zTFm1C261C23OGWk5r5OnhwUaTJ+v1nGW/2c1tsXYNPcU3xRhITpjHuhTWt8d9cdmLuMn3E98BlOQA1X7tjpLcQA4f2JgwPdlcfDAqUw5cTIfdqu4Q5Ir2BsgSSUGMq0f24JRxp093fnFiuQKHu8c4ySGBIfLBGovODJNb5gPPzxO56DAbxWmeallmBsWMhvBv3l7YxWVfw3k6SFp1LMckqgbKxKsgzfzGNKCH0BCHGZGERqOZff70YJMhHR/i3Y38IVvtjuZZL3EyiH1HYzD02LJIRWK8Yk1QFZsDejo6xEIJZ42cKp6YuKhU2kpVql4uNlAVQlPR/JAS0XF9qIzWfabH/88gfz4ZC4KBITebrLTR31y9s7OLUwtsK+9MEWoSl9lweMxWM9sEY+sfVSxf6qnL5s8fH5No74cKlTEL9SWIVQ46iUPAONVg0g1sTlW6hhiFLjPPvBZPXITnEFoySlrAgxN23MPDo3U7Rbs67+h9YsS9WR6MFyAAhGyIqiLGMIBWUDHSILVpnv/HhkWGwbxjC6FH4uxYYbjs2SjtDjs//PhWejNCW3FJanc7dv35QZUsTep+h6SjLEYq3SHfly48g90ikTtIY9Kef8e78Ug0z8Jzj05njHJxuaMUJBzIKE4o4lmRzMKFl0mDGgB1ubBf4nnRzQmgzlm3hy6uLJSDSv3u5tl2G5xKiGTCmzRtnS5xZ1TIwM10piRbpASzArF1Om1lBHLRan6Ucdga9indtGbIlZItVh7QLW0cye35jGV3MGo5dJt6f5u1G5zzz/hz7N3FgjGJH4w8D1AAKg26NBiGENIq1Xfa+5IyoLebjgWNwzTWKWfEkMFd6IijsOUAh0aHGHyH/ApTccw3sLrbCKpkhNTptWRfuN9vJYso5MiVzdpyx2wYjNClRD4jdvcZzhEObLF+tW/cKKJYRHKVkYWhZDwWeWoLvMiV2xNyGeRyzvB0spYHzdO5erGYsnYeM4e0bRYrfY92s26dds+a7Z799PMHMXNZM9V63o6OmvLXTRmJP6FtYmKudpan8CiWlXCSCegKgR1TVmnWzfCz5vuh5wWqBObfO8MU79nlgoszJ+vIYB0a1KxdDSYvzH9IaJ5mBCuZl8llA1+ABBwxiSUvY9YOBMkZnLJ0jvcL5F+0+XSp7o5noJFKvujOZWnGSQ6bKo0FDsJ2ezA/33swMvKWKDo0IDDT3S4QE3P202KFoJ/u0gOTKXTLFeackJkYboCY7FVEg5ygZ6eoEz8gRK4UWSGdlz9uep+z2WBhk8HMCkUKvZHm+RRsJ2cti/ew/HMiscEGZ3TBmYWGFb9oeCoyrEfjST7pzjNjlfaUEpVKmnOe61e9KHkwHM7MU5g1MuuZr2aCQXB9Z2DNXyxGKhcPUUU4XbMg2ekw+/DrZ8sVwa9z6iwhtWAAwDwOVh0vHOiGGRMzDy4ozI/ZdEA7PWZOZWYDzAOb1um37Oi4KwhknzCrw87M9T+zKY4jE12ODJIz2Ypl5KjP5cthvrKHm6E9PUwMCL6Y52HD9mJRsPmKYqBx6ExJFiBzrVCWPGUymVmtykbpW6fbEuwVxTjip2VYDvRoe6zOXHeF1ohYKMy9yQlkUK1ZVaGoro1FDJTDC+VgkRCeKjkI7OHhwXaryM5OL+30/EwuF7t4q9QMr4i8JILqjCMKXrB/83ffqMNhFoIEhM4LbSWHdjpFOPXaaeFBKAi23m/r4GBm7DmabkxMZBMIwnxOAjl0+45tSpFnVBayVtkgz6ErA8Ze2GyStnwmUfUH9KrOhEIonZG5N3scH0xmxbD1EuwAOUQI6CWlQzouTMEzlmPGTWg3Yn8usYO+8+27KxVAxAJxSZ2cHlnq71L25fOjCh4g6hrM2wKsYpx1bvTze92+5lpx5PMU8gvxROU5cPB6h+1FHrAqJA7mN/zvON8wfEPr5YXJC1Ob1JSakAgINrAegfpevT6304tTkRMgt1w1L+V0xOwH0TMXFmhCs9Gwfp9ZH5XcC3zmqQxnZyeHAx24jFBsDAmg5q+t0iEMGIkIh61HWDnBwY0K3BHLQ56JhyPtA+iW9I8oWNjp6ZGkBUhuXkhLqX1dbjbeVdA9mzXrTfvLzz9Zp9fTvwNBBiprEKYttfUZqOBxnGYqWcvHXGyxOuAfqu/s8elZ65dLD9gYyFFrI4T1C9dgrxk6h6eil4pFuczwfiDngRxxqfC/yZwbFiwm6fOFLkmkThzKfGae83KzsGa7qWKUDE2cmfn94XZv/f6JOkf22EtGrIokOj3xFhwi5TCtVOqWaQADAmEz9yvZm9fnYjoPB0NJSCjGSlXGT2irGdvkdTiDDO32ka0535pdWcxtcCNjbRXzdtZtCy2g6wy4dAhwyFZVVMj3NZO2u9sH+/XjZzu/uNDcfjIeqACFAwKzGF4Gzk0BI5fDHsISk78oeDAxl6Xdwf+UwhuSYzEP4rCyZr3lzj90iKSeKKqLQHOXx73I9oQaUHztIS3BTsYNCLkHnTFzS78oeW8UBug6YVATRD2PGKfE9vTwJM4BhB4ybFnzyizNOamSxoDt53Nx0IiNbfHDvn222Xhq8/Hc0rnY8mXIfimrt4uaN86XrtHlInT9DbKxSDmww8FMCg3OLJ4x8ik6TFkCMv+nq1QweMpj7L7mRUkUkRx2smabaK3Dg0tLQ9kVQ+JI0B/wFA4smOrinHBzfWPjMebVgZWrbY9NkpuNHw4K5EzvJeylWt9CNMgVJeidBXNlPBITdfH6xLrdrujDynOr1zXHYANuN1DekUZsfmPYUlXI2LwKdEjVlNYlzCE/UKWytPFoLTsxug2lfoRbDfthcEmXFG2t0QTuMNkd0SZjjs5gHELT2cWJwoZdI497iVn/pG/1ekvzT5egkDtY8iicVCA4h5RaFjcdDpUXMAV/zv1Cfa5LjNf9/UdZdvFdi9WyrXZLJYZkcimr4JUo1iU0bPcBJR3j9LijuSYLUrR0huT87gSz4Lwga9hfvsH8+cBuZVbKYucwhp0WF3hPGV2SQHy1cs3evL6UrozDJ5vmueSsLOkP0WBoV2GWOtS8wv8xwEpvLcg53kZarKk8JJ+tRYiuC244ASkFv9JNistyojkGhyNwPp+JmSKbTukiSAnEeMNkwokSVJjM8dq9ujqtGsYSuYJdXz/Zv/zrn3WhvXqFOXPR2k18PZG/rFW8QDLAVq/Z6ogxCYxardZ10PCzqfiB7Jh3yK+UZwgiEWOhVtS64TuIyUnG4x62LbBQICYfWsMAwoEOU/9OXAJPzLEaLKzESpW8bNPwtsRUoVFrWDFD2shMz420Dc6ubLpgK0wd9qFM+SlQ6VpAG1g7QKkysk5H8sHkMOS9aT60WatjyWVSmlFVSxX7sr9Xh7dBG/k8t+VsouQXyHEcIo0GNnVF+9MffxVkd3bR07y/UIKBicGEG0p7yPL2YGFZkL6QeWYq3bCUYSpfsHKxbLPxyAPa6ShSaaXYt7pmWWV54l4EjJuymK5ATj8QpxouORPRKdF4gIKa0UaRjhYLS2L7Ep5H3kbjR5HmKHA+/PJZkCHMa3WQB6tBWGJgB2hBKbbgNGA6UlbRg6Z4LYi4UC7bcrax5+dHkf6atYaV813rd9wZzKK1pFqR2P5oAWG2Ni2zC+WcdD+c2OnZmU2xK6yBuO1std8Z1suVHnA8RQl2dx5D9pKvCCzLfBr4l2fH3D3Hhc5xTVEhsxQKICRssEPLlsYLmGQc2TFylrgDmnSryplFwhXL1xZIGmcwLhPWMiMT15gTTn/wiEYHH5qi/cKASES8Zz1j8yXDl+fOudeoN/Vdho/OOEY7zfOHNHZ7O1XjtFkOrN/t2vffNaxUJpeVgOucjWbPaijo7BiTgULBdXh+vBMcPxwOLF+NrQYqlM5aOl+w+Wot4xXGbnhrbxYbazVbHgKxYIZeseX6znYhM0nOObgKGSurCMRBjfzRtcwhKDK/6kVJhc1BQ2WPmofOTdQcmVoj90djhaUTCRWJHFGGsgtaa07Dh2WWQkVaKLj7CA9cFH3yDTdrzfTCnc+eSIVnERchB9UrYqFxYWgT4wWLTjMkhHetSwk8fD4DxnENXYHu7UBj1qUEYWaLgS/ONlDdoaYj6Ga4L5M6vahytWCVKgQQCEV0kkhaSNqoqeIuVRJ1widnXev1qwrcFd6Olbjs27zT4C+gHwbGgkGiUJBFuVpVFBb2c8UyF7RfkDKGr0FKoDOge8naq9dvrdPpawMR2RUzf8BdJWAx8/IJJPYhPQuMeSNwEkxPosOYKcmPUbmeEIbYCD5rgiYOnVvQ64FpKd9SyABKZMGUM6XCZ7PY2nKCoDdjR2gxK5c6dLgYmQly+UsPCjwGWzRi7oWwHccVzyMFVtnFgYgnQRLKk1SkAMUmJar6qAiBMfn9nkLj0h2ce+jWQC2cSe1wm2jfIXAQvy9vJyctW66ApMgtDXTJA5WlUzu7yz64+TXPrQKDN7JNam/ddlcFHb8PnSSzDDoL6fGQKCgUl8+wFczl6Tmuf8PdJgE5OASZs5413tL8LK3LVTFKSEG2m0OaQs4eHkbWbNb1/JmjcgFQmHH4wKKUwQSz4wx6Ojp/5Bp0yOg29zLYxzKwVu1YJmHGthJJjs6AM5d9KLnUYX+yd7Np3IRcIjWbBfb44PFtoAbMXaeTtbp61upsMlWxyP47Oz23Xz58tF9//aR/t9OrWf5ASIL09BJ07QxxTxVKEOGbyTHm9aszd1zZYTwAYoTX8dryRSD8SHmdb9+fC1oGngbVYY3efLmX5ve7777Xc1mv5kq1wQGMyxgSB+xWZ5BiCu+SHooZ1gtEHZA2DvFSoejsxzWFJUlEc3l/8pk5V/xiISrNCXoURvxNBwLETreZxPAnQqtWCtZuVSSVAZZmjgwcSQFQKJYV5wVxinSKx8eJMj7x4b24PLVKBTYwb1cpz4fPhS3oATU5ZJpSOJer6EiZm7qjkp5r4uk/sJAVIE5Rd2DnkqKjhJoNekr3xX4JN3bPVt+jrFOYxYx5QbqirP9s1rSMNQgjUCrIXs4+g2esEp1Ri30crmTsFxmrhFzk/LOyTE6ieG/lLI5FVbsfPYjMSQrN09OjzBiCzZMu+5PTnswgIHTxHSgg+EDyIUt7KDqacDp34N0CeygDI75g9VZD81cZlIjdmpI6ItpFtlky1nKEAQOLxQJyHwUYnT9uWDgiAXFT1Td16r+c1V/tooSMIzNz/aLcgV5LnmAsfSAHPh0NeDv2dm6WDqW4Ytk87gd+cPBweS86hGRld6DlH9xYWLRckmwIUc+ZOWZJdfd5yGI+16HD5+BQFiOLcOR0Vp2mB4k67i1oUpUeBxqGvO41CCEAx5V8q6JKEWYWFX+1XpWBMLIKBQrHbvZeq5Qk7peXbAytvW7NbtXqDZxc6BwTK+YqKgcJ6XVBNQcpNmMsSOj9kBT2wtwhM2gGpjkrlZ4nrbAp8MyVcfQ+rQVYb9R/SzHHZ1eWT7Fr8DgcPADaw6PleQsVu8gBbTK4FsyU2tvj08C6R0d2cnZsw2FaFbrrYDOS9NAps/ilPeLdoJlyG0rNSgaDobpGTJ9hOvuMkCrfLwinfrNB2WRcgiWrwV4W+ww4kA4wslzRvSLd6g/GqzP/QBikjSLS5/D+XKLhVZ+z8ryrFIMPxhyaXmjngvyZyaCfJMib2UVshTzVblXP6OL8VOsKmBMCFJd3sI2cWCIjdHw8y/qZSIwYB3CpAdPw+WebLZblh3T1Q2KMLL6cGa2pEbaHSD3SOSuWK1Yn3YW81RfKfyFja6W0h3Z01FUMGcWH5ui6UP170PHQDYqcQfGyAx6mgMyp8sfYAT0mBgKL6fBwwGasQOB5jlfga4uLlX3GzwRxobtlU5DAQEIJpzoMbpAg4EwQYC5zOhbci7ho5DCTBRJdyUC9XPUO6DeLSVIbQCzE1oYl7DmHBL2/FDr8xX5irR31u2JMD0dz/QAfAVD84Q1IGDyjEUzlOaQnmkfz3iCUIJFpoMejq1gutacpsIBqMT+RtCmbV5jBZsWcCj/WuRVzXIJ1SyUcsNjErZQcwmwYZjpOTyRK4LuL3pbnxn4VNC2oODxYDLqXsvuLJjJ6QBPJ+QPPAga88yoo4Dk70vr/6dJms6WVSuhUIWW5O1UJd7Fs1uIUBEWIXs4G5syrpvn9c8sEDkvynSkinYwD8hJKo8rzgRDIeqZA44JnRslMnd/PBen8BF6YS4jcTNxD65Vgp2hh1q6zsvkzFB2EeIM4JHuKDORsFGJpoRWQLglvyDHPFAkTYhda96WVppzRnpgDNM7ctdisyA0NeJaiM05OrNOvabTjUYkAdonY5YwTIAyyXpHRADd/9/sfLVfJW/cImV1esCujKW/D97bfxRYx7skVbDIeaew2n0M65Xx11rtMOPDllgbWneTQuX/Vi9L9VNm8fuvrxRzis6TeElLi9m9AZ7wUFq3mPhycyo9zqSdMJ6BV8umUsp6CAZW1tKA4NzKuZX1gLP9XSAHBxlbrpajDHIh0MnLHqJRUmQmqQcSK79RBD+dWdB7WSxfFIdloVuzd+1dKNKeaY4bT2mJwAJOtap1eQ5eXxN26ZB3ywUrs7KyrzcT/L1H9HuyfmaLZNFjbeIi0wmcDCOHpPk6PgWJrmrsNnsaSjgDLcEC++e6VzACImWEYLxOGQ7GgSRoWUNLCMfQmwy85ED3cDoyLkYMUe6wkdNZols2UydhivRZeXyZjcbPWPBLtKDl2xCQBu+JVCqHDzY/dV9bjxZhlwrwEpkhZsAltNp7p4gEab9brKgp8numHnc918xLbWxo6vM+GcSJBV0entlytxUik2IC8oTjaQ/YkcJBsDaWx48DFYccRg3SKCyzn4mBFszkzFMjGfQvTh1mKs145MHlnioQr/16fk/gyfhezRN4BpB5m5SlbCip1GZN/nnzCuvWf/5Ljp/QCzY893cTdgvzS5Pu/eBdDHqJQqNbxNC3ZdOojAeVs4gi1mcsEAXIMkB/pJ+5i4p23ZFSxi9QhV5QqSFpegghSYiQzxuDw4zK5+fSkzgydYv7q2GrFkqUwlN9TfK11wcgFpYQEBYKFMy7VPW8SkdmUnU28FPrnMnAuxgB0Du6Epdk9FmMBZJKs1Sp1JyPpVnZCFN9HmuoyVo9eSHCIcYhTFLkEDIlFRZri4Xhiz4Mn61pDnp50N/AZ9vFGl9fpyYXkC0+PQ3fiyhVU2NHl8rzoDNrtuuaOjBJY3xACMfGHkQwre7eObLNYW63MTG+h5zSajDULXM53ls8Gcr4SgWufUmG5WLHOId6hOwRFcdSFYofnAIdAZxgC+7TrD1XE0C2TxjLD8MTDvinsXjJJi3A1wsRiRkIZz690IhlaUOz3tjrrYKdDiKKjRAoEF0HpTOzPTM7m0409PDwLDUDLzLnH+YG5COvKQyY4L/0yxlTBmcK8H6R7QGCez0ox5p2sF3xcgkKYUimbz5B5zKF1WbJnbMXnoGvn8+asBoegxKwfqY4XSadnp/b0OLC7hzshHKB4jHtw4EKaw8YA2v78+Qa6kdWb33p+LN0mbj6bnSXAvCmeK8YmKStWK3Zyfmz/5//Lf2v5UtZWu6llc5FBiIfwGNMMFM3Wi43ukuiQOEJxEkWumaZo5rzl7xTh9kHKIhADQhKA4r/qRZm4/yQHN8w4CU1p6b1vl+YRZxlMsqkgoImTTSg4MIaM4Ic/c51mvWGFXEkHMDg3C4QXLG0bNGOo2aJw4/+Hr2AicokkA6Rjwyaj88hkNNTmP/3PQ1/m0HKqtw4vYBMdA5ynacunslYq9u0xNdQlWe5A2jhShSHBO0nlpHXrSwMluv8gjLFy0d1hhNErfstjmnDr2azdFo/FWKPjxIGnUtShw+9dTBdyFZqPl7acMicMLE8O23rpBr9oN2EqAknTMdL1pOioXio816cKUpPtG1ZW/n+qSmEjazDPbCgj0pG0nSzYOLGTk1N1S0qql+E6nRWsYMgIsNw8pocCB5Yy8KXmqVg7J65xamC6Du1d3TIpEiR1sInRL3l1j/yE2SjXAj8X/iNdGB0bzNTFkoP0kBKTgtDE7IEFHVqpAvLgm4n3ybN0sgmHpwupXzSOQiBgoOqypusrWZx1a0Tmg1z8EGjIcuQCp8NilsdMBgRhm8lZu9VUqjuQURUjb3Ss4UYQIs+aaLb1koOPA95NFJjFae5z6Ch5RMocVPfmFwcHyXYNU5lnjWbWD1icbrgYX706c/PyvWfiIYXAuccLADpTZBYe1o0lFzoyEARGDfjbAkM7RMiogYLVk2QwypaGMA3RpaI/h7zCiwy6VObBeathYzgLNJudzuYWBylrNTwKj9m1YsdSKenWNo29pFQccmIJ83k5WOP9b6ON/197b/bkSJal9x3HDjj2JQKx5VrZVdXLdM+MpKaoB+kfF99oHJORppmpvbIqMyMzVgT2HQ44XPb7DqL6gcY2PuSbwmnF7unKjADcr997zne+JdDm7P83hxEFIggQG7zMG6gkD2xbZlMYgMBW/3BJrBbJPrj8UPRgDVi1u81IhC3XOgKDYtnWtDzp9jv8Pmf6nBQRkjBI40oxRrHEuAAXrJyFRZicJYV9Jzss/Cb2y8/vtRcwumDtAwmjexVjWuQe0Aiei5tNYGSApMGJUy6Hwiw9ODiR0VXxvDZ0xkpRQleIqgnz8J2gTa1pSTm2lgRbK5dh+ZM642iMAuHzBDdw2DmhSkx4mMh7t9fkMKaLJAVjOKRj4/AbqmvGjAA4EoKX0BkZsbiml4OaQ4N3FnQv2dcPbGVHLSRFP8zZOdQ0EyWtZDxTZw+asllBlmIOPFBBSxg0UDKGGZDNeOdArYQ0RVu7u/9Jlp9hWJfdXg0zc3XeKemk4UTIuYg0lsA7Ug5O9h1kG8yvCZQmsDqFCQEs+RwNSlZEHh14mJRQhLG3bymKSFdJbLYiVcXDH9JpDCdC7cNCFyEEUtTBBCfhSVrg+PMelL3bnhYULyGts9iWbLBsQsr2Y87jThbTCe06Grm8x7WwkC2tl56sQw4C5oqu9fJq3Ns/hwkVy5IGO3dGJy4MEsXTkiNhKLiBNTsXCfbBow1d4qxbHh4zHcVFAXVZWu46/rMgmJC/ZpYrFQU1QVKig/GU7ZRdfSJp45MWLQ+3Wq4JKoP4AgMO6QmDOKBczRTjrSox5ncsCLpTNk2GxtCWmd1hzjvqT20131myzdh6trK7m6FYrMA6xZiXOrRisSzBruANMHQ0JdSAuud7CwO3DVTViP4ri4UaDilpMQqd6RXbHEgxzcbCoZO3eqPt2sgF3UxGLw6HkLrXgE0XPVKgeK6H3o02hKNOV50UEA+zHBarNmKkTnEkiJJnJp0qjLXdWqblhQruOi6nKO7Q+MWWh0yQYgaITyRwdKgihA04oCpFkwl0yYFB1cXDJIYNgkgafRna29A25AUmkJP4/htLk24vAwPMJvIWpTe2lYWdu4rQFey2BBUTCVS0ZYgG1A3M2RAgbM3If9yQdE/X6ab8kq+QuCFj/5lCnwW5HmLgCPH1rtJhHdYwkCgEE57PYDgQs7vV7ogGT3fHjOjouG0lYEDgeQz6V1O9U8xl8Kil06Y7gjHMLUAeoxm1DgkgL2A4l1kMhmML0jBv2fSX9tAnqACD+Kxi1wjtpdMjwBZkABcbOiHB8sp1hYSVswwsZLyLBV1nLYMsY+fEMzZtChXQnMTOZDgAggvJzW33XE/3CP/CVOaghBwmlyOQgR1ICJITh/ooElVfk4W4QOQ+E/TKv+MAYZ1y7xHeM4+lUysU/miFXE2jnqXyXjlAgJR59/Iq2GBLith2ODhx7mELYRMtVxs6iNqttmLfQKKI3JpMphpDJCVOK95dpFE44lDAMLskvcVsPSfRo2glknOClGaUrDsKON4h7lne9ooEw7wfkguMWNjn3DO646PjuiNcO2bQQLcQlxin0FhsxHx9DK4HTWM9Y5ASHA5tiId8pjLh5AmQrgvueWYU2xDfQN5Am+qNhrJvN+uF5GBD/GcTXItG9sWbZ/J+hgzG83qcLSMLYf8D+ZnNN7aL04LQlwvYqGu5LAXpnTTmEH6ImtPa4h2FfbyneC7rHzr1Vqsu31WgfeWcbtyCsV1tKu/VO2U/J+A87DJISfKWwSqyWLaY+WOys8HwwW57n+xZ6UTrnHeb5y2TDva4Tayma0VeLHaMIYRPinlkQR7rxWSY0SB7MotWARQyQ/nMB+VwwLyAEFec/QlMprtiwkxlspcTDRXPiLSEfUGb73S8UdUgrz9iuOr4wK5UrUAMQGeDiwebrqpRRSFhXMtDApaiZcdiic7UzaolKoVxZgSFepK2AmeZwdgjVZlKwdlZVEy87LxgPhNxH1Fc/wl+rVQ8r48bpwU1WthPP/3s8AAzsUzeahVe5MSeXTyzXKYsijo6ysTQraXEIHvUM7pBQSRxvzROe4b7a/lA8jPIqaSqITi6359YqYLrvleqdODyUwSywuB8hTdjqFmlR0Cx+fDiujDdQ67ddJ4Nm5dms2BhkywCbZoXIBJbmKKeypK5Cwe+ROpAN5vI8pXQiRCbvQJyv/n3tzo4v/pqb81O3TbbtYqB6Xhp/cG9vcw9t06bl5W5BDAVs0m3T9PzotsRcQKPN2KIUi4LKma1HtQlQjrQnCTUZs1sJZMtCk6me2MjBMZk3o0NIM9ZXqYHwgP/YPhOBQ/cnmRgwhK8TMGwtOkC6y6Pc1OQ62JmR0ddHVTyZV3xDxsNmkpYoR4zVCp5jqo6R2RpsjZ0qRObOc/iUezOQ/M15gb7Xog58YiDjs6tHCL7cTcgnGIyaTb1jWY7eblQZW0HfR1iTOxw9mMmJWuYbjbeu+UZRg7uk5q1h+XY72GStuliKtN/5u4VZFStjmzYPKKJEUDW8iGjioLt46w2R+Z6sKeprpHRZNNwBBiIwTSFHANygHWlayYVthx616mgX6WmEAqQ197AKAKXJgpWz55kPgQky8ZPUeG6PKRfxKnjpkLnzaE4E0s+IwJGNkPcFTKpSM/49es3TvCKKBoonNO234GIABmyZ3CffM4sEp/CFUgo8t/HnI/vS/dN0fj8xal+/nyFEbsTo3geR8dNy6RDSyDQQOIxDBGQsQzt04dr+/D+nVIy/vIPf5B7EXNCjxN0pirFEHKJ46OqLcqMX6aa6/JueD4vaxPYExIUOtCdo0MBZDvMwL3wcParh9FjC0kD4WQ/d3PiZ+AtDCKAfI7imXky//niZVfjIr4z64bnxxpnvjidwozmP2d6Hq9enWudptJYFTo7nwIMNBCtOCYrFM50pDs8yhm9bXd2ctS0o6OO7i1GM17Aw9tgD4FsVbWXL55pr0mnYhVt2G1ul8zaQY+29vz5uSL+GAeAEMJ+jyIveFMHQlylXjvkgC5suiTwfWD7BCkRkp1AWaDiUMhlDbTGmy+q+N+9emPtxond3D5oNsx7TcPSaTUtRPKls4IGxie7n/WgXM5JC3D4CzkTUBn6GKCf2Xhql5d3dn8/tumE4OHa4SVDoO9sQeYxvV7JOkcMY8MDvZiXgdmbM6104O18sbgHobuV8FWAClW5SycZa/bBBoXQmf+NjZ+qy9OtcQZyDaM6T7rUQ0IF+r1Ws6GqQ4JyUhqIvFIEkNOHYZI9e36mA4fD6dnZC9n3DR4W9u7ttQ7zo27N6k3ClTNWgN6P1g2ZV/pQ/Uc4e6Rtu97Zx4+fVJlRCUarlN2SULDcWqldlq0YsBMU6mIJs+aZvjsvAbAFMhE2Xdhc+11anqzcEyozZWruMWkf6UXyWRDQX1EJ7eS2YRi+WOCreOuaPBIs8qHtNokgYOJn9hHuHOQHLuz6amD3t2N1LNncJ8vjTpRxyyc2VoT8DNKBKtlsRZaiGpA/KZ6LZE4Gtk8nNp9BtCLn2R2a6CogaQHLsRGxMUKkiLceDQXkxdyFTYX5dgiNPFmq42B9sJZACjhAFd0WOJkJ27898WtyhHKoPDgURxHRYTA7SalYLSyVyUtbCvIBHCaGbexsRmhAkhKQto5uDyIKUDTELiXD+8xdsC86NNCQg/6Sz8cc0hPiHbUoVcp6dhwOfH+IKJjrs5kxAxZsCByOP6V0cAQuQ3YKbLOncOHz6bg5wGmY1vNcgEidwLWDbbhnTkWxtrOLi+fWqOOk49oxigIgP0H6ief+EciduQYOHwsqZiYoc+oc4dwpQwas4Oc9dnTK37EQX1a5JVVlik5h+igWZ5OFQMZzZdN2rSLvg/snawRw8E1WEQED0VJ2cX6hTFUKEbrxVqMpSBBmO/ZtrEmJjdT5FuzTZU/fn06N7kyEmgwHkDNe8USuN+hi1mK348W6i7CKA7KOrcbBAJyZ8pkgnwNNMwcmh0s2FVgZu8Ismsqdvf35o338cG3XVzfSRa4Xezkiff3VS90T99ZFOxpZJqFgzAuJgF1LCDtaXdaIjw08tDuvyECxDJ38pXnlI/nQfbE55IH3uScc/uxrmLEzYuHvQ8aCFClLQAKe0STLkCGRSQV76n2PhJOC5rVYbxLUgGwtBKIFzbrrW6NJV4mjmpMrYbcCMcNaNVvaeDS33TYlwwr22G2ckdE6xdV4PJRuO7/ne019XEKWahonJPIpmYF6YIJ05qhptkWLi+wBFM18D+w1PcGDpmg6Zl8ndzYtOVwFpQFJLnlm83jfut6VPVomDqWywgWQ0uDMw3cdjPuabWLAQfHLO0TDA6kPYmQKOVouY1VGK7xf0oN+xoNSNRYVO7gbG2MSqzom+fvm5kGGAuPRyhbQ8/cLQSo+M/BDbl3O2no9EWuOcE2sryQszkFfdwIORKEgxeCemRNO9W6LxM1Huwg6yyEIxu0vKLNJIEvPpXyMRno0Y4clyCIS4QhugTa/tMx4OQQRLNOqA8/hLEQHAsT4+vVzkRgg5rD4SKa5/HBpP//0XjM+HGY6d2X705+/sEoZe6mNTLZ5aVn8QA0cBMxLSHcYDqa2Wuxl5H5zTVJBT9XkcYUgaWe+qa6RUw4mvgur1Sryi8RxhBcfAodrGt3Rha4wqzxO8hEdTgCqqddaItbQrULtDoKc3V6PxMDFZYSMRmZeo+FcLkQcVsP+pSyzPl7e2o8//CJjcTZoYrqef9G15y9PVLSYLN8OpuAcjyK8xGKyyldUkobcbxA6Qm5myEhOquWq5j+yyiJgO5vV3IkubYYLSrS2fZDRjJh7z5+VoT0p5fmC5orc+0N0qBNMJKlwQg+bKqQZXlDm4HresHGhuwNjHuzOlNKehoWMS8lMZCHYf0DFRLTZYb7Fn8MJn/+NdQNcSZfFARUwd9PMEUYvBhjMQL0bVKfJAZhHh4ZkaeJFZQrqvmtkOUyR6jB7Yr3wPWVRVoPdudABx9gAyzPy8/geFBGwIenuGQkAHXoKj0eDlYslS+KVChHlux6gdaB9PhKHqaKVgr1Ia53jhgrZGGZwvWi1Wsny5GOWST7BOIEIpakVywXrnnfdh9Z2gmDrrdAKJZJZIEIkvx2SQMaP6ROP3qFs5BSQFNki+vE+ISsq+Mx9s6naakHhAy8BglPRTSjSKft0eW1XH29tMp6LyQyjnOL4/KJjzdb/YmE6b7Pl2MplmLauZeVwodtB7+kRXkvLSBvtWadiaqtoKYqlmc1Wf9MvT8Zo/vKy6uT9QD/67pdL/TzKdz771dWtvX71TB65xdCZysz3ZYag94ENmhmqC/P5XiArdFj+bq/l1IXrF/cgSSIRkigONH9XEojPgz0w2Q7dHuubgtVNJ+gYWdfuqLUXlMn3oIg+Ojqy7TawXm+oIg1mN/siLk/A38wWhQLAYq+7i9BjIyFSE+/klM7eSUHL1cJThuolq9fw9nbiDx8O9CgoV1QcZNOsQUw9dlbFxSuVtvFk4aL+PKMwTEgq0g2XKnmb9gc2mY7kNBViPVjK2WA+tmDPuOfYXn/52nYpdNE5q7XKMgzB6EQIWhxYihFNitAMSKbIjjByIE/UbLZYyUqRwgxbUgiV4nJEwPh5WYUqCOFzQ6+Y50LIYRPjQWYlh0grqeK7b9/abMpmUJJ4n1/NbC2fozJxBwQ+bK5IFExJLypVhogxSv/eOilIFTk2alSJgQAiXF00e9z4HIQXhZ8nggKrVAbaO7XtMK0eXTc4ePj/mQ+IOUnXalQkRZEBqIjI6Wt32tJKgd3X67jsFPSysilz0y8/XNngYW7T8VqVGDe3WGD2aVYqoiEUlUm/k04nWtMx5CS657+797VHZU3HA7u9e1A1mCvltXFiTH2WO7Jcru4OJmz8hxQIukQWoGzdJLmZ60Aiay2Ncv9g18RBJBmOIMzYPn26VcQX3288Xoh8lcsENm83dGAxs5yMcRjhZcnopdhFgV1f39lDb6hqWvcSGyqYcmW3ORN8fWAc06VALtHJxbwFI+lUXp+fjUHxZ2yuwN10GJpj+7qERIHUhS4Dvdv9ved0NrtVO+4SQIxVokdTsQlxUDJTRYCfChyS02nEdWD4IVmSpgo4hXk5G466kcMsFwJTgdSP2HYJpCtILUWbjNxOjw8Ho3fC3EPuJMzaXGYR6wDwjQtoEn0f/3068lPboX+PKaKL4vP4DM03Zn4GByJ/hsQIfjfEJrmoAEsyK4HkIt/LxW8HDJAn4wCo8vqOhwKFf1j/VNd95A85EBo2a/e3Za0piQb5luAvSA1ZS6uITFlql1j3rK3ikkdYrdb1nYH0cHbK5BmrRBYHOzs+advZuQcEL1YTW29XgmhDirwsqACfl3efZeA62CRhW+GeoO3ltXYrS3XI0P8J3M7wfR0u5dlxSHK4gaLwwpdKuEyVbdDL26fJrfV6Y1sTjYWLTj5ro9FMhvesA4oI3j9gRaB04G6KbwpgnJCYVeJu5PZ9mBvw+8piv2q+yLNidkgRgsNYkraPlx/t48ePOsRg1fs4hfcTeQcmEHxepGtsxvw8l2fw53DgosRn1EI3eXM9sHfvrvS+NttNqzZKMixpZYoirHBAsFap0mToDXQMWUmhwt5ZAvXSmERJbMPBUMW/bDDrVTmCsWboNCWBQ2BfrspYhdEEqAIGDa1WS9rw8QRTj41dFLoq7Oj6XSXAuwvjmggzDyoAWUhnXNfbrFb1TLiXNAYaSfAeo9FeRpYqekIK65kMSw5a1i9M6FK+ZPMSfBU4FGuhcKeFrlyj5L2W7BQqoHSftSMZf/6nP9np845l827KMV1OLMi4NlhJPpAqhVQtLZNPWa1et5u7oS3nU90D7CEhfrIHsRYxGVnNCcD2orWIRzPWqZ/zoDw+6h4SvNKWS+dsMVvb5fuP9s2//2zDPszTsthejM/okuSTGiApwXDYdABVmxnLlYgK2lsKM+XDfItDUYxVOj7lRXrytUJGxcY6ZDYyC5CRtpsJ0GmxCB7T6HWhqcSNn2720FlSSUjvt/MNGAd+rMyM5I8ESG9lV1d36q7Oz88057i5vrd/+3+/s7vbgV7Q3doTFMixxJfz7LylrheLrWIWp34/IGAgogOS+XUusdtBT04kszHJBJGG84Uwb5vd0nqDhZWbJ8LrYWiSFAFsyEY6l3kBEw2o6SXBhAh46Z4XGZiAJDu4l6eG/ntmCsQFrezq053dXvUEgyMsF5UqhZfi1k5PT6zZaKibmk1mcl/BZmsfI7GgxIFN7JWsYFRmE5utrXiJ1ZHEvmggMrHo+XcQUNYFaQd5VjCa8avD4JmfwyYAvZ2DQ6nq27TNpysb9ieCd0gF4YXZ2VaaOWBXCjJmUFDTqbTFaly5Ju1xRsk8jM5KHRpw1GbtbEN0hDu6GK96RRvfuwjfC6m9lXI44IQ2AN4nsidKKREGXWGejpE5EaYEeEkC32r+HNhi5c4lbGJUpytBjb4GHyUioB5U1XwuX7esP++yRABivqb4K4K705rR4UZF16yuVOudWR/wukeEUQhC8gBJoJofDnAHIlh5bK1nDWUiFooUN2Sy8pkdguY9xL/XTdfdCYq1CpHk6LRupWJV7G/+HU5F+2Bti41LgEplilnCcGtCd/ajtW3ipU3mEzE/WXc8L9JJeFdzAYQjOrtYxYR3SPFvcyQ6QvxeG/jwaua1laWhWLIHGQw2mbyXdLCNesXq9Yo6CLfFxPl0r27hYTiy47OaApt5UdaTpRWKQMh1HeD8mdUCBrBrfbUPYIXH/JN9BcjyMGNkrMC99P2CvRw4fiNvZmBmZuAUFBCjHrXHigfbmhUPEWv8DHEjyEPEfi/ayeqzVGrYr79e2eXlle3ilK0ixhVdhQxwgJSrrimmCN1HjmiIlc7egsXkmsIE5yM8Vj1KikOMpoW/DxltOYLYdW0np0fq7Cn6gxGI0UzBxaBOdJLc56PjUxFjaFyIgcPpyzW2yFsgV7r5OcUMnwF+Q76QtdHwXt2nwsp3jhRKIrc1eVEL5lwGMikgMkskybDowQbSFlM0IMcyGz/0rT/YW+u4ablizbW08EaKRR12wz6GEDf2l3/8R3v55kzm56SgsA54jybDqaBgWPvrGabnG/kv0yywjnA7KteaGvlMQavQbcIl2OJzjWlJrEMTX9nS5zYc4FDj4EP2Mej17fLDtf2k1PqVhQVMaumaDpEvaCJTsGChWa99aFtK2/nzMyuGgWZdmQPu7JgzczSo9GgvOdioGnDzeaRs++bBouHlcvjKcX2wdUgtDJKXB7EtlTkbsszCxahkI1B4oA4NxPPMUNvk22H1lGAc3ZTmjPO2d9e3d79+so8f7q3fZxML7dnZhf31P/yzZn/4uorIA1lGHU9ZszAWO0LnyQJXj40G72zAIiBQYiBjyTK/Wont1m217eL5iWAwNjnlKkKGiPca7sdbZqpUwHRNVHdomth09pZk3fvUjbyZj0FGmtkvb9+LtTufc7BurN061cbFQocWjjExIbz8XU9Y8Z+pHlLkF4gJsHaJN8raRv6YzBHdtEGzYvRQS1w3NmLYUlkHkER2zsjk+U/nMx2GVNX8HTYDKmI2aeQ0SA4It0aEzCHI/Ba4GZYgUCibmjpCeTg6rOKxVMzSoIwf5l4xhUXe1nOHYIs5cgxDMXCx8pMrB0kNu0jkKLoB5jJAq7AdSZZAm0tAeBbmdCyPGytgmp5Ettq7h7EY2FJFe4XP55LM5RDZxsb5t9BbOid3OPK/69CoYMEVUGlGm59iukTQ8nxW0AdCe21PTiOeo2VbrnY2mZIjytoPBXNSXJbLsTWadatWsQ1DBoUZP5ID70qcyUgxmhMrnN/HQ390aGFGlOPvkc7BrC9bkHREc7OYOSUdKsUnHIGd7YPEipWiFRBvK5EeEhMCTId05RYUIrVCLsI6Sls5rNtkOxWTl4O913vQd8Iajvtzd3ure/Ls2bnW4mQ60O8DXsRYI50uyUuZzmAywXg71HOsKISctJJEonQ3+M5apVxX4QtS4qHOkRAuoEKKTTZa9pDFGnYyXTj7AvNlN0WPRaxxSRQetH/40xu5i9F516rnVgnzdnTUtPYxxgF0r2vLxsiGyNt1i0++F6Mi3t8kyQm2JUfViWFZGw/n1unslYWJzCOXr9tsOpDDTaiChhxHWfCLYQ7UzQEiL9SDZpf1TiHOvoqjEZIb1h3ze7FRxf7cqtPmXWf/ofF46N8rxPvNm1ey6uTv0ylSkD6OtfC2pbmFU0LHziw4JFS6kbGTk5aKBTpQfkc2hv4eiABEk1EupGzLeh1MZVZw9uxU44IMQevwFhRr96jFT6l4KpRw0mGMl5X2OFrt7cP7K0XBvfjimZ3Ujm2LcQRwbhXzlayg1uV0pbzT4d1QnIuTo1P9e+X/pjfSbs+XSykINKrLUJhtRHBUkS1ULLCx7s9nPChhmLITUSnDbIWazE1l3oOIeLF001lVbkBOdB50jTluAAnXWUtlqHCLVmtWlKgOW225nKqa0HAWbRl5f1q8rk0D8qKK0GGNpgZygXR0VF4wCB3aA6vmRfAOJtDh6gc8zDrXPlI1sRkxm0GgC8tQndhBb8TtiFY7sTujFfh71cJi1s5OLuxPf/y9Dprr62tLkpWVw5xVq2i0zObjjUyPweOvPt3abMymBotwbxWMr7vn9uZNWS/wx49XOihhk/7uDy/t+Kwparlo9Qc2LxdwYdrcS5T5Ad+VeSXdm6zI+O5bs60s1yJ1g2zQ09FU/44Nt1JyXRo5d9FqbsdHR5ph8fOQpGQybB4UFeSHMttoK/mD4iEslqUH5Z6ikcSWB20dHTQMoT3JHkThbCJbGWQU9Ewpmw2GNplNxYaj8+H3VPAuLTCD2VvvYagi6/6GbE9mpzst7pNu17qdziG41dm0Irg8ahUTTLqJnOJlceNmNlnl7wFpSptbsBhykHISYTfHli5SbfncBUhRkVrMdXEzISWmVtb3oYOFsCGW63ItmJaDYLOILIUPKfCo0iqcbMZLRwdIl05UG7CaLPvQGB+6S2lw8eZFpoABB0xMWIIc+OjcdliABWLHUiVjK8g7IL3rknkTGteiJYlX7P3BSFV9aMDhRRmVo1fjaGcmulnPFVIrM3rZniFRcBY1l3R7h6BdEAz+HNZfqLfZmt1tyREhCj8kSsQ/oaxy+Nk7DaXIFyCYzK2UJwS8Zjc3N25NlytYkfCAFQSoyGbTjZiH87lDyKAtwO2T2UQbLs++0ah77IIKT6BuZoaRrAYhj7x5w2GMwcJCm/jrN2d2dn4qg3+WJgULGam3N5ODQxDoBYcoWbJ5daZwE3QfAtdaQkRc0HnvttZqNmVAgY2miOr7rXWO6np3YYlTpDEDpLCiiMNXWClDB5hYTOs1kOVK0WlrW1slrCv5iFEIVpN0evh3U/BOxwv76vevrXvctO0OBySkCzsLikjN6GbpTssS9avAByKPthYW0+ro6rCnQe3gBmQww6BA9XVD0SnyECSddN5uOveeMbthdltQAXLx7MyWq+mhmPOoLiBqOtBSiXzStGBwosRyeTKHc3Z69kwkGP6cW2K6tSL+wXGU2HK6tjBXs06bnFgKAP88ziFIbEViCraj7AvoU9Ewiu9Q0dpjRKIioIQSoWTTStEehg/W7tZVlCFdknkFkKXQmVhEROLc9mWzcXasjh3UAc32ZrZQlu5WMraV7SWtAbHEcIDnlrYMhKpDtNhnOyiZqeBC8WiJFlYL1jyqmQ0W7vy/Z0YE1kxH4gN85CNUmbVG0ZpHJVUoHC5UJZjSMhMgmLRRrbnDCjE+eIJuNr8NtWHPMdjnkJMOjMMUlhdzLzZEZge80PLWZKHAdCMBGwFwcvA0dfNkhKnIE9AFhkWgqqLyyu5ubjSToHpd1JZKuvj6d1/YWfeZXk5Fc01Hdn31q00mAy1qXpY/fPWlnZ7XbTnb2ngyl4vI7d3A1srkY4gfWXz7YC9eXdiL1xfWPe9Y88jZicSMFcK0pWHdGQcOw0xPfqebK+XKtphF1ru/sbvboW13aT/Md3ttTvstcWD47iJHyEi3xNCeShT2JtrA7SqxScwLspEpNYcfxQaCXTo2NnvSWTIhIbmJNuzz81MdXjj8N7Hpkxcuh47PvmA1AiTyGd3DM7Gr61vL5idWqTTEUCVflJfs9LSjdHpgH15qbMK4J3RLqni3Wy1UIB5i3Pg+BDPnt27V5pR6lqjDjjKfZ02w2QPjSjQeqdIG9gUGopPF5pDDlr/Pzk83JVahHIjQvrqzj/S5zFJhUivai3uX1awSiB7d2HAysFqLDaCtWdV6M/L5iJirbssmLSkFHT6adFmayLqdlWA/XuzVWqntRBLhgCM2LIy8LKHTPNuVoF8ORHn4kB6zh+WL5hLdbtbmU/dSZnNCj6yqv1xW5y3t5oPZQ69nkHaBuZjfgMxwr6g0+H8c9iAHMtEXaQ42K/OtlS2Xi9+C0PnsdMu4N0nesj9E1u35vVTjiPB9LgUSMBo5m3K9jEW8+fd//VVzRDraMCzanpEICAUG7YOxikNYroSrQ7jwjhzPKA/SFqubAiOV2OlFS7Fj4/FShffL1ydK7yB6DxlD/2Fu/8+//CBUqVIpWrtTkyRBaT1siGkCCPCBZaaeKPjXC7fIphDANJd2kpUsEg+FObD+0VFVBByfPW9ESOF9TedAJdCNPqJfbrOIVIQ3moMBkh3jmpcvLuz6050C4tmgiRaDACa/3E0gFj5EOdagR1sdHJQSn1NTNIDSgMywlZHOAoRdKoNGuEewTFfkqsXh5AcJh/rJSUezTwq0dgcDgL1GOPJI20PQI4puIz4Ds8ks61GJIJgpFJSQUm8UxIqeT6eCpGlCuEMUH5DtMH4HCeMg2y9BGQjyDmWzSKElFGk2F1LG4SweA3NlDEfEbg+09kSqLBTt/MWZZrHEBo6nwKwe24g1IaAg7wDFDu8FvAiSiu6u+9p3h8OJLWgc4Ihgfo4qQEQRzPFh0/s9nQNfg6BJY/IZD8paA/Nkx/pFNUkC63Tb1u9NrP8ws+WclwntUaQ2lzmbch1bwCdl/VlgI9dnYZwNKSdlAZDt2o1/JTRWQwWphyErrFG3GJJxOrRr9IqYHBzcQWQSjHwCmFUHKF0vm6dnsfGZ2UwfTbZ5ULiJFMsYtJsgA+Z4mCSQtMD8lVatGmbtuNOy+4ex/fTDe+sPBpJMACciHl9MV3bRXVunBVshY8VMaIUMQnU64p3FGUTzOVtuZvbp+sraRxX785+/tNdvTiTMLZdzto2hL+MV68UAInwWH/MI7slqtrFBb2y925EtlnRQkfw8O42aqkq6NQg3dHqwNjmUCFWP1gObjF3EzAbx6J+LfyVvMlIfOj5cahA4Syt1MFdnBtPusMmUZeJcKGI4XrIg2VqUOGMM9yXo9ywfKukkKdh4FNn1x48yZ2YuUcynbLNMLCrtLOEZyeYqEKyLPiwsb6w0X1kuv7Nmq2zlOmuDLYY1jakFzx2hNY45LiUC/nxMrOAg5fuzsc8nM3VGj2HSrKtSpSKtH1U+BwRG9iQRcEh3j4mMIq3dNZB5dYw4R/ksUbmoOxMR6vLjrbVWkWQXIahIGvII7NXQzbjRQsYOx9JRygVIml2PIPJsVDrQtc2YF6krJ5wXAw2f2TxKufhsdA4gAhBg5P8bQOJaWkHOTXkbr0EzQB/cNo4YMrxH8Qhtdhqi1+N/nDsUjfJIxkN2h+53r+fMG8xo4hECpmLXs8GMgNl0tmDBng7YO3q6bxBJ6P8c+tiR8X496gOZXXPIgyhwoF9fj+xf/uUHKH2CCRsHxmKx7DZ0kF/YyFe89zFoCqQnNuaiUn501EpmZJpNhdWiZXJV7SO80/lCbNEW79SiTdZ7++nHW3v79sGNOADOc07uaLdcKgG8iBCfA9i5DRQFIAqBDAh4PyTLADImBWgHY5/5JrAnRR7GKrJ2UQcG0AHXgHtHfVtIg/YUNf+SUXm5rM2bRoHOrNmq2MuXiOVXB6kCyTD3Zqm5yGtYQ8qWDzgQ9nWS2Ix30/UnIjvVZSiA2cFKpuzsa1IO4IWcBjInQm1jqdKB9Wzuh4yxQKFwLkJLp3OsdUoRz73DdAMW/X2vL4iSDRF0TcTArM/sj48bVmtQTMEHWevd9mIOZIF7BTpVtHqzqlQhLCtpRLhfCqTOZjRqg5RIA6S5vf6uj1XE2o/83eY1YJ3WWxVrL1siLQGVY2LO32EEQ1dPjCHvNUW54VxkzkngPIz3HiQABWXNs8L5iDEdZxeac3mBZ22OvSPr+mBq89kOShY8N5JfAqrJC1cI99JknT1DpweMin3dXPMNz2lEHAtrCl0kGwjVy1obBxuRKPgFChu/WaSrQ3RgbpaVJZYIvKrQ1Jpr9kN3gbVUIHcWNko31ZYflGvbAiKP/GVU7NBB5+Z/DtmGC1UZPN/dPYhUQtQQ3hpik8JkTSU2mQzt7ubaZhP0iMlvEF60jm2XDez29kHCdHU1MgNP6RCieq5V6rbarsU63O7ByqFqL6x70hARh9ktLw7sAWUHijwS24Z4pM3WFuOF7beBpTkAc6Etp3ObjRYW5bbaznl58VKlkmOgT2AqBr/VWsYe+hPBWHRhbNa8uN2zmtVa6PBIZriyh4eRFh7aqrvbiUtxEiry0JqtkoVlZARApyxowrVzgg7lHLNmkE81y+yDWU1gswnOHcDzPLGKLWexDbOzQ4DszirIcWp1wbCrOpt1XmbHiH+RJuSyyAzozjAbcG3YozOTNgPB6nt5X3KYMGvk2aLhGj4MrUjkVN4hKZiUbLQSaJMCAwFiDhzs3QOHI5mKvD0p7KxKNR1KyxmFRSQpDtaKQQpTgyXHtU2mkdVbdKjofpEblGw5n8t/k9QJbPPI0HEWq0fIuSTJkzUwC8AzlnR4l6nADE6po6Zrw4KMwk+mGHS3ckQHzqdIQsaD8ULDlpul5Xsja7YIDSDdxHP9+FscYJ2jjtCVxzB0DkrYkMxRNSNizkxHUHAWrx8ezCSzVgCeVIGZ9hlwxolasuzTAeszaK3/iHzShmBK0AHWcK2GHCNt337zrZM7MBOYzW26GNtxt6nMVdyHpNnD9WiftsVqZ+PxrY2nA3UtrVbNdbZsdIRuQ24iMB4EUg41MMEnrl3MhHb5YWLffvO94EUIJPN5zkoh5BEvlJjnIv1YrpdWJKOUYmM8tQkEqkLBOp1QUD2zSu4Dv4fCVbm0ac9v5FFA6IFDAbJF8DQX81YOYdYO34miARkOkKL8ogMKsY0VC4G9+eJCvqvpbM7Ozs+se9pRpBmw6Wj8YJkMHbzD5fI5FmPYPxMHOXAq90TysKwng+x3qwPqwmcG7VlZs0WMVfaARmRlpABiQNcOH2A0HolEBosWVj8hDLPZRAUgjGygcOmQFYNVPOyDI6EKSgkBqg/4J21LDkw5lMHHyCnejmKiUqnr56GrxpWJ9cjejwlKGAaOghxyIN3n2YtoOkDWY62EJzWN2V6GKxodrV1GVSzsLVuBBQ9rHumgR2155w2B04TajBdz28kcmjm8S3fg12QwahGZjgSg7eEM+YwHpcJt5QbDMDajiryMByHpEuFesU5OODnTBsXDlu6M9126oLTdXRPkem8Z4K31SlBUs1mX9Ru4NNUo+wsem1EKEhDsQg4RZ7WGhbxmgZBKgBdETFCijItB3I3HyRNAKPhjsiHJMUcpB3ag4Jta9J9++GAP9xOxWjMp2G1Fy6URppOqzoGVWL3atFlta58+3snNhc/GcJyKv98bCY5gQXFYTomViRJFCJHZVyoWbTYfqd2no51Mp1ar4xoEI9EDquncYNnipciMgGG4usOQ2VnKFtOtzbM728MQXKxEVgHmYfOlQmNOgni6mMYAgDi0op2eHesFgwHL4Us3+fLViVLZb6576o6vr/sY5FkqIHWBDTSyUghhi44bP0six6Cfh+r0tYmAq8tCqyOD7fvbgQ2HK/vp5/faXJiJ8CzQ2xbyMIsTu/rYt/cfPmhDv3j+QgczEoXjblfm8nHs4mzoRGwEvHCqduWo42xSNjEveJxE4lmaSJWwV9tYtVbXzOlxFse9dp9RkImUNkV+luZMmOkTdLtz+KyC+8meDQyvVip20gfYPDaWXiBU577m7NOnnmULRWt0a9KUkY6CwFkbvrxDPQbMw2BVaR0+P4hDWtR31+pmFOzLd2JDhRTlLFfSUjY6WKMD/EhRkdjqkJpDKrzrIVX8VFgHhBnHEtEz2+LXym9TJuxYPRYOlnc5y8cwJF0AztpV/FgKiM+1qhmKyJTrNd18g5mRGzJA9wfzouOdjBc2kZEEh3HR8kV/F6Dw0wFy0EinWKsp8my5hnUIexMG+9/cXihmUqm8tLvXnz7YZruwbrclqLTODJFsSqWlwCB1TegjOUseuYQC39/at9++UxwT95kCCGgO96Xzi1PdC9vjBMSa9E4NsoycqnaJDvF41xOqwuGMhZvPOIFgfS27CYnD5+hngVmZk1EE8N7v4owtZlOHS3NY4o1tR/KMAiHQFB4MG8oZ+4c/f6mfBRxbqYWCvtkfZG8Y4mscHZid6I0p6hiHYJ0IujHWfWX04age6wo0ASQC/2FmcDtlNCaprdymgAEg0/HOjMbY1zGrRAud+k1zCeGJPQONJRwF3gfQDz4zhSsZoWtlnbKXZ3zetydvdqWmgJEP0LYHYUBiquo+AJXgzpbXoU7RC58EwtBG4zjgW95N5pmPRvfIjijuKGwgECUx3AY8wWO7uX7QvTk9O7GEwI8DMQ3ukWs9yRGF6EmRRGzjCgqaJ7uA3GBzmcnaYreSZttbTE9J+awHJS+O5lQEhsL2KiJbwDotazmCPiFATeZ2df1R+joEtLDycJJAp4bB7mKysXGPGzyRsJqXOyMv1JVd/nJvlXLBjk/bnjmHhg7vVZi0soWEpMFiSOTCsEXLdKB7yyEEi7uDRIQFhdmBcuuiyP0pxWpEBO6Ms+tPPfv+ux9sNFgoYRzmFIbl73/9KH9EjxFioy1as9a2bQd2Y/w3w3KgSAXtMsdBVoCI3OerJIfw8oSpitxH2h3cTLgPEET28pxkbIS2SJFF8iNMW1DLmJUDyxFpFsW2xstREgTX1pGlyMsPLR8WItE8dEzMK+R4Q3ZnKVQaBjTpu9ue5rXtVkvszs0OY3JmNYRUU7wAI7pmDXo8BxsFERUlhzczMInlsxlbTNdKXKkUkZJkRUp6/+6jXHFg49L1VOs1zUIxQmD2u+rPbDztWZDhxU3ZevPRnl14BlwGNmKYtbDgtnOIoNGmsXodQgN4ZVa9U4Yf8CabPvCoDLjpxMO81dEFYgO3TQQJU7G73d1OnpN0D4PxyE5PYeAVVTTxDLAwKwQFq6RIm0CWkZaB+5oZKcSLbWKD0ciy+ZIVyq7PyoVlqx21bLeNxSoO0szA9kqQh1mbAu8B/lcr6T6onpfj1hlUvmRFsn7RA0K4Yd5O8ZcrulSEYo41ivSEjZA5ExvJPlmIWJIvovFljdFRsfGTVeqkN8HTRsVeEppCNz+fPxrH+5znNws1RZjBBNxrLiRmJZ0laRMK4d7aljAAzeLgclGw+hwqSDw04O5+YqdnLT0zijIl/5Tq9tXvv7Tvvn1vi1XPs/+CxB5ue2IVN+otG29nIt+xMQ4GPdk9YiVZryXSKyPRIcs1wcYQ9OWACvn7rqwKHWzzuY9sgKFz+0Bi+PNnJ/bs+bkMJdh8Ib9kM6VDIQIzfqX3BWIehK8lwQATDA1cY01RqBxP0oMyzPyKPtPXe8qIB6Z+UbILdZJY1ElW5J7UbPQ0SZB6HkPQ4SEwM+e9Yoa5WGLCD+yOi8/cu1GMRw6bPPM7Oigd3kRXzUBtPM9WAcdiurPX87xABnyOD58jSLvfKUUOlpCzDSHHCxtPXB+aShdsNp4fnKYouIBmCZcn2opGCJtG5wfYoSMuFLw4n80XNsPztlC28WRgg4ehvgPSDHgBGIjU6m3JBNVcqUjwUQhNxvt3l7bbbyyX/4O8syn2ZBcZOauVd4aZJYc+954A7tUMNn+k0dhmM5alKOYEIlGBFi0jdb0wtlfcY0ZYyLdgOB/0oRR7aCYVE6bIN8xK6Pz3limkPu9BCbuVWRgXszU2zhlaIzLwgkhVOLIEqjvgMYbVp+dHoiOfnZ644H0aWbQIbNxfyZGeF/j6w8h+Xd9IFFypYva8s/ZxTcJWJBOQCDxY2GEHy5BYQJwOG43HeUG8gBjEJkGKhIu1196ek6dHHiaw6MJpzBBVWs29XZycWWY/0ENESzfo9y1aE1TqWLoIUQEvZVV2anUxdQObTSeCZdlweL5AdSziozaQwL3NSZxfrgRPUzmzQJF03C0HNpuNRDaAdEDwsdI+cPTRXAT6sud97laR9G3MBIBTsBmrVskhxAKMYoB5EzPLglWroXxEeWnny7HNJ3Pph8IwbY1TTLkLgonvHx6Uw4cBAnZ5GEawhc8X7iQCDi6XGKJoYujbQIwOa4AiQKmnbqEjvbq5EdwIHEhZi3VUq9XQQYnZ+2g41bxMpuw519FmUkCiRHgxs1jaQ+yfsdVCc0XQNM/StW0yyk+Qhuy0ObvUYq/5MjMUOjo55sh4gWzGsQzd43guw2pgZ1kk5jN2dNw9MHhDrQEcjpACMPvi5wtpOPx5oM5shjHCXtR6oHqeCaSCX365tPFsbF//4Qs77nJgupYMRh6MU+4/81jPlFfJpsP9UL2pwGR+ncG7+JD8wr+n0wMOYtZC9iSdbi7GQg5iUEZoC6MNyCO5QkmwOp2Z1h4asrwnz7BW2GgwhWfdi4W7gAmLCTqtHoceJtUuJ6CjmE68UxPMpwDmA3ysQAFHGOgSYGoS/8Q7Opn17OFhaLe3Q5HGmDEDVSvtpJS15y+ey4kKuBeU5NF2ktkrbFFgUqBT1gfvtO5hhI8ohBRHluhGKHhgaWqEABwvu738ITqPkUtG3Ql6wmYTDsCfFQoMC3o+h5Ri6mrDPN11XlFkOqgOkiTsI3lXe+ueLZYUnaQZUTDCkPdQd8GPoFVKeeE7IQMpqbhw9iU8g41FFEiMGMKq0KiIiDyIajnXOjOC4qDmHxoO1kuQYl/CEJ/fQ3HjSAhz0segAzef+FvAsHfOnq7EPZGmOO9uXkGGPYFsS3opCijm+Htb3Y5lgQdaAjKxmntoPbNon9Exz4SUyd9yFATOhBOF9oK0yYLM5iKxznO5kpXCmWR008lQkji6Sg5KciD75EEOBp7Ju4ns699/ba9evbCTkzPrD28PlofspcC7dJDAxPnfcmelkVzPrVk7FhMdZ7Pbm772++NuJI4KTdhy1rJhPLbdynQwLrc7EXmAfaWtxvhEJDvm75wZKatXKuqgR5Ohun/u0Wc9KAW5jOdyvwA2HU/G2nTkC7hHkDoXNZ42nwKW8ON6eWNRY2u71dbG/Ym6PjZ/WmnYXniNcnBxw6C7c0iStJ59m6gL63bbFpaIxfJNQLZJsJ8IGaUiR7fGYoH4I0o8FSfdq6cdIEaGIQh2jyl2sk3UORZyJSt2QysERbttP9j9bd8GDyNbi9FJ18fGgQsPvxMPwnvJJ5jTKTpqh+P/8rcEcY+hqmgzdxYlHq8bLZIbu9GGi69iEqxtNGTBIgkg/qWm7htIi0NVDhJQqKPIsnQIeLpmXR+HTgyIbYX2jqSCQlaetByS/HeqcoTf5EtygMB+k6C5krX7+4H9+ONH+/X97cGQnooxJ+Pss7MTDdJ4bkzE6XYpHJZzxNcbyxao3NCpwb40ddWIlPOlnJVABPgsxYz95R//QSkrP37/k/XuRpKL8PJXga5hr42AU1bWfxjpWRbydLNo/nwOKqNuipml+6Kq6lPM2k5FD506TMCwUlbmJZ0v3TLGEaPRyn764aMqcQ46XnjE15DHyhUQCoquonJA37/7ZL1eXyHdlXLLNrOpZulbDAAsZc16XZFV9WrZvvryd7ZcbW0695iim0+3dnt7rTn7f/iP/yzYcUO0UQqkgUoZxiTbKeQgJwWJHIMOGP/QaCkjBrRlhEezfjn4BSOp60Nys1ahxMySTobPgoF4Lr+wLDFJAWMLJw6xOeGaImefZC/od4P8QdKZldAF9HzAmQTqyrghAxXfLfNcigQ0hkE8shWHW/nYjDy433QHizkdzc4yubLNF7jXUOAxLljZzc1Q34MZG+5NbNIiLUGgqngOK2sdByzuxeXltTtXxbjYcNi7m9KKAyCm+M1p/SClQsKChIz17WbxQGWsEy9CMqm8PX/20koFpBxN6x53VTCjk6T73WCyAbQfuqZaTktwhDNby2kenjZb0hUSSQUUOztkqxLwzojBZ2vA/juZP3iYOEQdoGXeh9V84WHDMsWHfZ7zMUAON6a14GD2A0K7OQxABXBMuru700Gsrt62tk5FBzvNlaDwx/Ds5ZLiwA9JDhQuDhq+v9jXxLrxvQrA4N41JRE+q7FchUphzTaba7unqJGuObZOu+Ph0+Js8P5lxU3gH3V4slXkfnnubUpG93i28mfwsU7E2pdUTezaqhvSxGYf3n+QNvHTp0/20HuQzpU9HqOTv/71rzaZ9iUNRCOPXpW197eZtSchrTaYvLu/NI0GutrxeGblsOKEuyBjdTrXNXmSsU3Ek6AozkoSkomcAUyhwpyUe8LnxCSDcAH2Relsd8SjfWbW63/5z/9V4lucWJjNUFntNtxsDg+3rlPaBkkSGShxZrkka+VMyYLt3gpAEAGBqSObjB7kCbuNeEmcUIDfJ90LsgsYfrwU5VLNQkT2OyQhZulCRt6Va4JuDwclw9h8zqvl6QQvVDbWrR13jywTlC3Yp2zU70sCwsKC5WYFcjO3hmyxGhZskgM+5aXFWHfh4c/Jwflnt/zNqHi9WMjdRZW3Zhcwb8lF29p2TQXJQ0f4nFKCPCQHt4QCqk0sTvAzXWkuC6xazPoGAM09YNFjnoCtGYnkzJMgrMQY/po0ZUfpmk3mM0EidG+1OsbuWHO5HgrYDMhJCRYM+bNU3nRQA7u/71m/N5QNHLPBo+OW5pZfffXa+oOeFizMNCBOOnH5axJtRvyNYGaYqy4nINwaz1Giw2RMUDi2405XOXBs1qs1odEy5NDvgYF5fXslGJRKjxezVoF1SURQUR3NRsQSoB46BeYuTtYBSuDo4WVkgUMUoLhgE0CLCIHq559/tcvLB9Hn2YRgg6K7Q1qRyYYqnvC9/fGHd3ItAj4q5LH1C61eK9pptyXiBiiA530RJL6385OOIORifi4z5cloZPP1yt6/vZS70Z/+8pWlU4wfIsuXkBvlbbYdy1xbRRNhzytSNGhKE0HY6jAP81dZuWmY5AzSBOu4AxeAro+ZH7wgSRBkCr8SRM2mInMPC3QYZrMYVnsxoc0PMXe01GbTKnfEMs7m04r9ohgTBLwCJvQNkILDoU1gfw8R4O8qUJ3OIhMoMWO+9MgxWZ5pTk+iDU5EzLMIMzYZSbz98ZMN+gvbrn0T9PSgqp5vtVwXe3sVkUgC/46isSqEZDic27ff/aTMw1qlaN3TloUlj4Bb7n0GpQIgLAv+A83CVSqbRpPKYb8QuQvz9/U6EZwIWYZ5FRAjcg02baWUZAmyxo2Kd4XZpN8DQZ8gUUQ3Rbi+8Ex2tl2AnvmGrpg1Yx5X0f1gntooeuYiKBQ/FySKAwZIllQLnyuim8UAxYk6nkpjFq8gkTHP9FSRfDmn7oeMS+pXDkNm315APmIV7iXNf/Iz5GYldi9zZmQmyK446DE1x9/5WnIzycdEEDJ1ijXlljJTrlqzUVMTgD8xhdSCQAv2o7QXbPTU3Dd4HJApidFinRLwkCKhZeuwbaV+pv2Hg30ynYsN+5/+7/9k//t//Gd7+ercNtuZOAbKm42IPKRwBFp1Vj3yJNAGDPAzmZq0974v7WTSsFisLWzXRR7KFwaWpOZisW4wRWF9a1+Hhbz2CEisMhW8CRrqzwD+CGNKDtPPelBevr9WcjeY9GbBbDFvxWxRDzdaUNljvEvbjp9l0SrnbasUS7aZL+16NtICuL25scn03rbbhVps6ONhuW5RFKi13u4Q0DLDq8qxnuqMhwBxn5kkN4mqqdJoaZMB+tuuV9YbcfOWevkZwgPLbRaJzVJbmfOSjrGYbW0SLSzeJNY9CmwxXfiAPtlZtYxusaOKU8nhQFGYEGTxF51ps8Lrlq6LB0glDdyijeVgEgAlnzVcxp2f1OyDYTjFwWq2tnFmZrlCIP9M3CdwyCdDTSbgMgtY6vCns2BTM5jCh1DjID4EE+/SdhzjDBRploI7FJlynqzizhNoGKmMYRlzCHOA8oI6NIhmCxIBG9TcsvnIqo2MTebuu+paQzR7MHh9FivNasBcdyaHFDYeoNpWp2znZx11B4rrwuHIYmu26jocZlOHzYDWiMuhu+DFgXnKAUn6uF6qck2MVebLZej+s5kyApUzyMsUFgWPYG0lEg9+thty5mBar+3tTxhn98ySvMT3zMsgKIRhTXZmZJiyNj68v7X7OyCordYCaSwYQ6Qx0i4cOnY2Hs0Wt7ZDhgIpIgmsHhYsiUo2IKh6kAix+On7t9LHnV60bR1N9J3oXHF3YmOWZlXWehAtWAdYDeK84rMuDj0nOVBJu9ha1nghYvaZu4lAPsnkVZwxB8OmDxKLEI9DJJcC0WHvJsw3kYk4eY7nz0xsOht5so1kCyWRmNATU9HLfEFjFQ5u16dJYkVRRwG29Tw/ZDB0I4PBzO7v72xGx10/tmKKWK+KujY2pUKedTK1TyTMT7fWbnbUMY2nEyWdMPLwnHe3M3uEeNvtjg6l/sPAfnnb18im3Wy5fWEsObo7Um1Y3xg6cEjAOfBDiwOfz4ipuYxRsFdMMzbIejcqYqET4GQ8kjL9HAhNcAvIAnXiEES7vYwU9J4vl/qcsIZ7D3SAoZAjDgsILjQMHIbMuCmGFEN2yCZFrkClw8+PIt4DD//mHtCpEU7sIctukMIhQDEEDKtxjS7nXIi4B8okH2wPyqZh4XlpzAQ8K/kKc340siA/W0tlNpatpu3Z+UvbzFJ2WbjWaIwuF8QF6UitFupecbhwoHmsnGdkugsaJDnCtn2clZD+In4ljNScpY6aQhL5no2mRxwWSmV7s35pL15c2H/9b/+mUc1g2Leff/5ZMH3nuC4SE/yWR0UCkDpnBPeVPdG7f2pWIhF9Xgqy8eHDpRzVOMAxZDi/eG5BkrXt5trGkwdFBXIhbYlqOxEs5xiIiKiFGQEWiU2rVSpWw+hj+pmdeb54+aVSQpABFCt5ywYeByTCwG5qloKl5+npmPSWi8CkzDJhiFHdMmwv2IuXHdt0m6K7LxYeRLpepWy2Ar7tiwyQzdelNUSvxiYK2QWT8pu7e3UglRktNRpFiBHQ7iv26uKZNoqffnprP3//g7qSbvdYc4vNcm9BnLFUHFshXcB1y1K0+kBRyd5qlYJXSVjOYUpAqDT5ZmTnxTtVWFkc+pvQnyuCsa7vbrXgT7rHChaejKeyoDo+OdLGwOISrLIzHfh0Yo0WiQsjGQP07ge2KbnTB9Ubeh9+jjR2mF7D6MX6rFx0u2SM31UNpSy9cyG4ROVAbhQJh4WNPpL7wEwVSJHq+Ph4a3/8I4LmrJK9sQ+MNgs7OetYLru34+Oa/r5yEKlw8TkXacmlGGwQVHciVQgGA2pL23w5kUuQPHQ3iUM45aJ9IF8Rb9WM50rCgH7+7FxVMVKWfD6lKKhaPZQfJqnmftBTcJG+gr1cVtFRzBOIq5I9XT5UAC0XBK1//7fv7fZ6YpO+d6YQLSAEsZk1Wk0ZzwOs3Nz17Ieff1FmaoD8JEX+Yt5y6ax8ekUao7pf4z7jFbzM6ekKMeoHJamU7LzbUY4oG+psNBMU+/z5qS1j5tSEA4cWViq+SUFgiCAapNQZUjHzXYC9mVnF+1C+sU4ao1By82gOHnU0dBw8E2KKSqG1WiAaidJEtju0obGqb8mlJNtCC+hscxGHSHMhwHs+E8IC05IO11m4mKq7dy4Uew5MTA/oerEkkz4OCAcNGjrb9UIbGVKD0Whi9/13InGdnD7TvG61YcbFwW+ajfs4BU01DEeYoZE99O+s1WxbbDtxD3aMH6rIM7pyxvn+hx+li5svVrIvoxPN5F9budpUB8Zcvts9kRwHb9FonVitUrUiSRBVjP5TNhq4WD5fCAWtyrw+ze/zTh7ym0zVLS+DELqnUrn4G7vV8zUzVqtXLDXb2/39jZj2zJ01UkFry9wchGiPYcTGTs66OvhlxJHOWZrq1ZVBnlUpG0aHcDW2SDEfRvvsRYLyGLM5L9wPrmaMToB4WThKSILEJvMVNK0HmQRG7TGzvLXIYOiEhU6IzJK26XRj//bfvrV4+4NFq0CkxdmI+f3UGp2S/e7rM1lnMoJntMNIwROZ8FH2DFYvtJ15zgHOgcV+wAy4XCgpsILPxjOG8OP8BqLt9lbKZu2LL5/bsxcX9s0332veyf5wfYPn7dJyBe6Jm7+LBKY0mbLbYhLNhgRxC+pWsNdfPLPLr1/bu7cf7Ob2xv7lv6BCuLLzszPrNOoqAl988dJS2bz17/sqZPkczJeZU2YwfkGiFcfW7/etmM9au1aVE1hFs+bPeFA2603NIqM6gvWtEimAIsG6Yaw1Gm2FgQLLwcYryLCb9IidlQ2rNOYkUw3UmVvJH3WLUHtng9HM3r79xb759hs59ozGPeXHkdpdKoeCNz68e682ntSCXz/c2oyBPCQYWG/prL1580a6PJieny6v5Lww7I+t0zwSXZ7ZKCG3OcJrYXfi3oPQ9SCkxo2VdFis0DgY0BmlU3NrNqs68DlQWi2YpWDoZUvnWEh5kQmiFQN+Dr20tGTFUkMbGd32aLoW847qB7husabijG0xnVsyN9sVN1aqVS1EAB7kbUj3jZNOqyaGlkthPMhXyS04dBzmoIP7B90TzBnkkgPbTXFFWDnxd7G8ylu3m7UXz18pzQRNFMPudPpIGzvEkWoatyDH6tGIMYNjdlE8pKrLK7NQUGXPPITfc3d7L7ePJE4pkYSXhI4F949Go2K5LLRrD9kGgj0769rJybGcjRCRN+okPLBJIKNAhrATBI1Yut1o6kCBESwjdSQ9FthivlA8EDD4oD9Q5NF4iDVWQezS7DZt3VbDnr88lZk1hzUbFqQnDoz5jBgwh+NF2AgSazfrQgG2G0ziJ27eIIeTosyumW3EyUZ6rdPjIxuOVhYHabu6Wdm7X361L373TL6ZzE1wHsKzE6iIw4lO3/M6fdbKc5S7TTqveY/mlJIsOL2e+4rrjdiO6YxFuZx8cTnMeI7MDXv9B3U4OGWJ4LR1Aw3m9GyUzvJzWJZLbE1cSmC5qtthnuZeyEEw06Euu0eReRLB7RRBELkYrwBhMhPWJhlv7dUXz8S8/e6HX2w87rsXM4kPB9iQw1pMTEYUCvNWVSqyD/7IzB2zhbrlF1nrpJo6KOnKgIzd1zmvTu/9+ytrdZr24tW55qHqyIrEI1V0T5hPImlgs11hx8aGbtw/5ytQcLRbHUsC4q0cUlXxgyOSDnXPKOSzwuzUwbdbWGYDyaepuepwmLO7+zt1rCfdM+0TFNLYOE5WaI9xi4mkmZYrDkQjDmTSatSsu4cvxRIzfuamzNs4oJ2J7Acqf9dt8NYHkxVfC3rnBLk6NM860IyUQPQsEV9OxGE25519fEgjIQx+YD9896P17sY2HaykEYb1T45ssYocD+tRyEIggezhEAwrKvgZ3eAExM/loM5m3VA+C1MdbTqs3EOAPPsTH5ARDwU0zkoURvI3xu82TtnXv3/lAdpJbINhz3748RuFS/xvf/1ftUrd/AFmMTDyXgWJZ226vrLTbdif/uFL93UOQ+15Hy5vlKl53G5Zu163r3/3pZCBXzIZu7m8Ovgxs/adIczsHbRlutjYzW0inX4DFnsp/LwHJTjyafdEZrzMAkdYBc3x/YM4Al5fkixBYv+85xOiY2RBAiF6gkVGwmaq2sWKoTapDkA7efvy6y+s1gzt17e/2GQ80oJHMIwglvxINsJypWYgtsC0+yStZIQdBsr7jd3ePEjXBUGGG6ZZKq47N/fu5pDOae43H00tWiB3GIPyK7uQtjxHJWewMWdu+6WqO5ARssUVWfYVCujnTK4vlfoXVioRxBvb8GFgjXpRgaxJspQrERAnhuJu17ZQrFfzCI0RDiQpq1Vqtrx/sNF4LQF/sV51eUHEi5OWjSSQJ9UsB1SGqpSHDumH4fZ8ZuP+SGkNSRaGWto2ihujckICcm+VWkVzBA5+osYQ3c9nMEKJKsrrZU6tgQQLmjeju6IL3GVdx8cLiu0Tnxnoj/xODCV+/QBxZqfcO4VyS+vEoRnZ2dmRGJnvf70Www4Yqd1uaqYK07dU7th2txAjkXuchSCheU2kEGOPj3JXGTYdQUukhqzWNpo4TIJ+slZr2j/+5Z/sh+8/2O31wHaJGwRgWP3qzYUtl0N1EFS7J2dHgvP4s7NJ3+rlpsYDYQnSBMLjlTZyZp90DIIzk4ztIQt5TpSbZuRLdnrcsZv7vqrp4UPf3r19Z8dnbcmaOJgxkwD+57Oi25R7yo61RMC4d5Yuyi5rXUp7zEEp02a3MNNFJ8vBl03ZaLa0+RQIKidNLKze4fDBhqOmSGJB4NU8hyUkMzZQzbo5qPePZhvuOgNZDHTAvZJzFhRh9TL/YWaIj7Jpzem/02nRVUpGgksQwctpOzltC8mZjJe2xEFGUUe+IUEQG9YJ/gb+LsqRJyM2bkYhvczQIVjUI7qHWIUxPAWg0/HYtYQc5HRho9FYcCxrqlrD6CGS1SHEQjx4KdJLRfYTs/WCYtZsk3i+KR3J6WnbOkdHFsVuHE63QpcNRENHzTHFrJ0DicMRuYecnA6B8sfHR/bLzz9bHNPBufk5ZBKe0+3dnZCndufIavWaVVIUmRQWEBSnVipg3E9YA+8i3sl0TGRfRrbBhUeEnL0ObTpZJfSQ6SjPa/ZKd5HR/512azru7zbvzFhJ1JCYhW4sgWct5EESMzSzTDtha71Yas8g5QTJHuuU4GlpVoF9g7S9e/dOiB/FLyYErCWMB1IrN4vPokdO0yzhp5zHYFpNEr+ngnWk5INMMCk+3Uh/hRPSnne6KIP5Zruiw/Z18sy++74olyzeFdYIRSKQqyBrkXuQv8ExxDZxbeRmtDsVmVagw8YEhMfY7/Wt9zBW5/3h00dr1RqHRBVP9UlnQKuAldESZ4S0uL0poysSg1wi9VkPyssPH0RcIKJKzhTkAhaABLTj2XS+sPGPI30xGKztdkNO+416Q3RfGQZHLFCEpynRsakMVsyb0LdkMnbUPtJwHuPdElZn5Yqss4AeafmRAmB+jKMMLFFOFboOdiDYnOPqRIuerpCZIU+SmVHl6EiRSiSdx5u1zSZT2yyXVgXWy7v4VcPieGuzlbv1U7EC/zTqVQtJ18ZFI4uhtLvuF1JsfN41F3IdS8kVaKuQUypouk82pRmM2xFzN1hnTWt0mF1B1kns4bpv0QID7rGV23Urt2rWwIwZiQs2WYjr92zcnqK+lz8imqRIs1Q6WbSb0/lI1Wq5RkZgVjO+wWBquf7Y+v2RrLxwBeFQgvULmxQyE9pDuh9ehkwamCJSgcHhz4bC4uKQ5TkAz6GFJVWFhXp+fmGlfFVhyaSnsyAzIZVzaBfnZ+reSgX0cbCB93Z1fWUfr361Wq0gCLraqVtMwseOnFECkL165WB6rCx55ygOenc9G42n1mx1vGKXj2vOjjpHlv4j7NB3dn9/L1Yx5vu1et7WrBeLLZdHI1i2L79+pe81HW2s2zmxNy9PrRayuNhgNn5o4/O5Y34GHJNSVJtyNVV5Q7kHZaBoMeu0GraJ1zYbT6X5Y7eg+0WPqrilPTZ8a3kNs8OhR5WhwCE/kwpXBJ7ELfnoWLFnpDOiA5TGVQSqtAo+xOLt9qmdnnZF1JnOe4KRyhXIIe5AQvLK40HLzEjBv7j8KDrNrbtoNnGM2m5nIlNwIDEfdrMGJ6fRNVHJQxTif+ZdY83Asl6ueO/N3ry5sPv7sf34HZKZhWB0OoqjbtseegNbrnsyoe+eHlurjfH1RsJ63iWKrswc6A1939yW841NpxM9LxAaXKvodvhMvfsHdT8Xz7o6/Imo82inmch/hbzrVPO5UJ7ByHpYH9K3Mo+yihAUZ6i77pLOHE0nM0g+c61WlisQzy6fYKfnUVywpjFsZ/Nlzgnvg8MLxGU0HEqniF+tyFdyHcNLFgQCExAeOpI2Z6DOY34XKSApjX/4eaBtkABxmeKgoYAFTtfzw5hcoRBuw7lZQywkqNh1f3wP5sjAyiAWGxoP7OQIR99gKF+y05MTm48WlqnkrF6u24uL53b6rGunLxuWDmLtc+ypaD6/++5Hq1UbYvnDbGU/duZzSvtGSp8Vx6K1x+oRZEGcIaiI/DUwATlE9LE3KoeXtb5QIVouVTxOMUmLncz6djmM206qIRDE7PNaCIzox0F4qmXCNZIDUkUebNuCAH5Dwx7ur0UKGwwHeteAd2Wirq4dt6iKhQSiY9mJQxVM2hJFMn65aQtcXPz5Dsp3v7zXwF9pBYr540vidQjOTDRUItEpX452nMPy4qKrgW63e2TVSqih66eP9/b+8lKwGQcl1SSbtUflhHbx7FyQCgLcUr5o5VLelnRAaSoiLM8+iBhRJkmi0dYmzEMtV0t68MCcpyfHNp3QlRZlZo3gngex3eLTGtl8MrVkt7YMmpqC2zKNJxMn6SRUQ5ig3+vlOjs5UbWLFCAJOERWli1gBpy26QKoLmtV2nekHMw/M7HNlkvNlegsqWzZgBkq31xfqRN9hDhu70eW5YWablxYHcXWqtctTTRXQCYn+iSFaHnHtqOiz1sUYHtWtKhA5R9ZWARgcCEyDh4TZqqYIweBjUczy6SI8CkQYKQZBV0ui5iZVSlkMTPby2r+13voiZZNIGz3pK1DQyzH3c6urnuaLR81TyybogvFVza2yWhqJaJ/krXNJ8xIfTPpj0Z299BzS0AZuEciAb14eSa2qQ5oNGJOgZDIWr6PwGMrSDC8fAUxKYcj5r5ssn6gQ6RgBgUb8y//9KVdX5elxzu7aBkIGOxpNr7tdml5LMR+99yajbaN+pCu0lYPcetY2Z5A5d1azjwK34XEpPmQ53NCXnI1Am4xzJASKxUwRNhao9VWfilFoUcFBXoheVmVoB64E5QconQAxQfSwlZQFJsim7BIOAQvo7XkcNZOyLwwsR0dCOxrpXckOkiePbuwt79gYu2m9hyo+R26v4ogZsgakphKf8emBw7ognve1WIhFDRFx6/PjW3kwbcVkhjWcTCcOfjZ6PGl5e/DGZADDXO7gM6yaVcfb2y53qtjaB/VrdXsKLyXQ4v3+NXrC2u3a7Zaz+z65pN+FwUnAQlsrmRUQoZZr+YqbjkMmBF++dUXinjitJHNGYQSEecSPfNauaT3CJ31akWOa9qa5YalR0slk3C4EhgAklNtuvE7hw8dK/sWwQK5nBdxjCBY87zb+CEXsnnlWdIQdI7a4hFI/6pMUpeJUFz98c1XQsj6gwd13zLyh1SD7CHeywADYhyFOAx6Dm7Zt2mducsUs2GKfXyU6brdpcaD7B9hV9mzIRvJogUlTcPsZsp7vFTeL2S3UgU0j4MZtCBtjUbV/q//8/+wr9+8sUycluscLHG4JBlSWjC632w0AvjzH/9onfaRjOJLYcWbGpnGoCF1jToGITGchc1OBSSEtaDiDllA/mKrUvjxqCJcmtC4JxYwWmHv3SxtNqPj3tp8thDqd3Z6pncDZJJ7BFGJrno8HFtFcVkZ+dfCNh8NxjLQDwLQua0yb1+9fG7r5cwWs5FV5VSFuUTW6hSxOCfly/IP3mE9uodVPZAGvgYpq1iwRjnUf/+sByW2SqPh2FbzvkxuYWsxhGXTZe4P5R7YpnTo0jYbvFS3dn+/sHg/sezzio0GPbu6+mBXnz7pEDpqopOsaBOCDckL9nb6g/Ubdc2zKBbzQWhJtLRqkWzHlaWTrZ10MOo9smK5Kl1XMSxpKP7r+7eqIF68eKY8QiyqEBRHV3c2G47lAgTiguvIIU1QlHEqUA6Ah/Hc9rmU7UYL/V26DBib3fOuLZcTVSnM+DhU33z5lSjVjPYk0CVcl5cJgghs3+3OsnSmeaDdxNJL/u5Mg2ZMuS/vLm0F8xWm5Ta2aDOxPJ6ONM5rupyt7YLYosDhOCEaqrIwqE5ZIcSejMBbur9EA3TAr2TATIQ4KjSaW5EvSB/fkxKiTa5i0W7mVPTF3v71X//VwjIp6SVJY4CFqs3QWpmCrPw0ww1SCuoeD2eCH3EEkfn8fmuL6VL5cNMRm5zn/tHBQcPGEYeuGjE9c48CLLn51jrrxBar2GpAf/hAxpEOBn6egqlnc1HN+UzAbDgCjYcwB/sa+DOXAnKis0vXCtY9qdjp2VcqENCN8nMeVy0dIWYCMrSouKifwiHe8kIOrFmpKi6OzQnrLb4/BQubInCXnHNiN1YGfmS0xMGLnKdaLwsWYhFAXtizQWJ9uIaWnlij6bFhFYTjY2azbuAv3w6ll2y0uZRLVRsTirxxHSsSKpG6kE8Bf2HbiFMOWYqCqbEqK0sCM51xMFMshWI26zBAzpQJLEHoH+xts4MdChMWM3P0qZgp0C17FNXDADtDU9HIfBRnE4phfg5rHucpDnzNeRR8DTnCRLMvlCDlIIPAIhCLvp29+d2ZHXcrIr/RlZDBWkiRQF+SEQUpP+h/OZSJyqKwhn0ObJeXGTca36rCqNEHg1bQnbM+KVTojjlQMjlsyHK2TdxAHX/ZfJjViIP7gGgd67iE3MSDiL7VrKnI4t1gRFTl+xaLNhoMtafBxJbH9DqxfJAWe1lWbxy7cXSAtc3Onp9bqVKw3qCnPU+BwKRjYHgIiQ23naDs5hY73m8Yt3S5IFaQsDAYYVyRaP/iECTAwJnQHp0by6DCCywINKBLvbsHmZpziJfQB5dAO7a2pxjbYzLgeb/RemrVatbCXNdylrPtbGUPt3c6eHaFvW2xdKsHFiVzWSa+eI5s40Ai2+3FC8ln9laHYLNl/IGp/0SImZuB+EFPx813hgjGPN6JaxSaHjUHygZaIoLTFoTMx0nKKqYwZuQCMbFAzNncpiOeQ9qCbWgxoysgZtyWhY5EdnRUsSQh7/LO8rkjO+m27Nf5xEbjuVWrMzvqNO34vGvT2cxzQncU1JiN5CwfxHbarFurVrWKzqmCJHr/U+df8miQ+XQ9XU/X0/V0PV1P1393/c8Z3T1dT9fT9XQ9XU/X/0+vp4Py6Xq6nq6n6+l6uv7O9XRQPl1P19P1dD1dT9ffuZ4Oyqfr6Xq6nq6n6+n6O9fTQfl0PV1P19P1dD1df+d6Oiifrqfr6Xq6nq6n6+9cTwfl0/V0PV1P19P1dP2d6+mgfLqerqfr6Xq6nq6/cz0dlE/X0/V0PV1P19Nl/+Pr/wPvkrCh6DTm7wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import json\n", + "import torch\n", + "\n", + "from deepspot.deepspot2cell import DeepSpot2Cell\n", + "from deepspot.utils import (\n", + " predict_spot2cell_from_image_paths,\n", + " get_morphology_model_and_preprocess,\n", + " )\n", + "from notebook_utils import get_example_spot_context\n", + "\n", + "MODEL_CHECKPOINT = Path(\"path/to/deepspot2cell.ckpt\")\n", + "MORPHOLOGY_MODEL_PATH = Path(\"path/to/phikonv2/model\")\n", + "MORPHOLOGY_MODEL_NAME = \"phikonv2\"\n", + "GENE_NAMES_PATH = None # optional\n", + "OUTPUT_SIZE = 1000 # number of genes in the trained model\n", + "\n", + "cell_image_paths, spot_image_path, neighbor_image_paths = get_example_spot_context()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da552ea8", + "metadata": {}, + "outputs": [], + "source": [ + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "gene_names = None\n", + "if GENE_NAMES_PATH:\n", + " gene_path = Path(GENE_NAMES_PATH)\n", + " with gene_path.open(\"r\", encoding=\"utf-8\") as fh:\n", + " gene_names = json.load(fh)\n", + "\n", + "morphology_model, preprocess, input_size = get_morphology_model_and_preprocess(\n", + " MORPHOLOGY_MODEL_NAME,\n", + " device=device,\n", + " model_path=str(MORPHOLOGY_MODEL_PATH),\n", + ")\n", + "morphology_model = morphology_model.to(device)\n", + "morphology_model.eval()\n", + "\n", + "deepspot_model = DeepSpot2Cell(input_size=input_size, output_size=OUTPUT_SIZE)\n", + "checkpoint = torch.load(MODEL_CHECKPOINT, map_location=device)\n", + "state_dict = checkpoint.get(\"state_dict\") if isinstance(checkpoint, dict) and \"state_dict\" in checkpoint else checkpoint\n", + "deepspot_model.load_state_dict(state_dict)\n", + "deepspot_model = deepspot_model.to(device)\n", + "deepspot_model.eval()\n", + "\n", + "main_cell_path = cell_image_paths[0]\n", + "cell_predictions = predict_spot2cell_from_image_paths(\n", + " cell_image_path=str(main_cell_path),\n", + " spot_image_path=str(spot_image_path),\n", + " neighbor_image_paths=[str(p) for p in neighbor_image_paths],\n", + " deepspot2cell_model=deepspot_model,\n", + " morphology_model=morphology_model,\n", + " preprocess=preprocess,\n", + " device=device,\n", + " gene_names=gene_names,\n", + ")\n", + "\n", + "print(f\"Single-cell prediction for spot {spot_image_path.stem} (cell tile: {main_cell_path.name})\")\n", + "for gene, value in list(sorted(cell_predictions.items(), key=lambda item: item[1], reverse=True))[:10]:\n", + " print(f\"{gene}: {value:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "166256d8", + "metadata": {}, + "outputs": [], + "source": [ + "from notebook_utils import predict_spot_expression_from_image_paths\n", + "\n", + "spot_predictions = predict_spot_expression_from_image_paths(\n", + " cell_image_paths=cell_image_paths,\n", + " spot_image_path=spot_image_path,\n", + " neighbor_image_paths=neighbor_image_paths,\n", + " deepspot2cell_model=deepspot_model,\n", + " morphology_model=morphology_model,\n", + " preprocess=preprocess,\n", + " device=device,\n", + " gene_names=gene_names,\n", + " )\n", + "\n", + "print(f\"\\nSpot-level prediction aggregating {len(cell_image_paths)} cells\")\n", + "for gene, value in list(sorted(spot_predictions.items(), key=lambda item: item[1], reverse=True))[:10]:\n", + " print(f\"{gene}: {value:.4f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/example_notebook/Visium_to_Xenium_spot2cell_example/notebook_utils.py b/example_notebook/Visium_to_Xenium_spot2cell_example/notebook_utils.py new file mode 100644 index 0000000..7ead630 --- /dev/null +++ b/example_notebook/Visium_to_Xenium_spot2cell_example/notebook_utils.py @@ -0,0 +1,311 @@ +from __future__ import annotations + +from pathlib import Path +from typing import List, Tuple, Dict + +import json +import math + +import anndata as ad +import matplotlib.pyplot as plt +import numpy as np +import torch +from PIL import Image, ImageDraw + +NOTEBOOK_DIR = Path(__file__).resolve().parent +PROJECT_ROOT = NOTEBOOK_DIR.parent.parent +IMAGE_PATH = PROJECT_ROOT / "example_data" / "data" / "image" / "ZEN38.jpg" +META_PATH = PROJECT_ROOT / "example_data" / "data" / "meta" / "ZEN38.json" +H5AD_PATH = PROJECT_ROOT / "example_data" / "data" / "h5ad" / "ZEN38.h5ad" +OUTPUT_DIR = NOTEBOOK_DIR / "outputs" + +SPOT_INDEX = 222 +NEIGHBOR_COUNT = 6 + +# Bounding boxes around single cells (x, y, width, height) in the low-res image space +CELL_BBOXES: List[Tuple[int, int, int, int]] = [ + (3524, 4294, 15, 11), + (3525, 4304, 15, 7), + (3534, 4306, 15, 11), + (3511, 4325, 12, 12), + (3516, 4335, 10, 12), +] + + +def _load_metadata() -> Dict: + with META_PATH.open("r", encoding="utf-8") as fh: + return json.load(fh) + + +def _compute_scaling(meta: Dict, image_size: Tuple[int, int]) -> Tuple[float, float]: + fr_w = meta.get("fullres_px_width") or meta.get("fullres_width") + fr_h = meta.get("fullres_px_height") or meta.get("fullres_height") + if not fr_w or not fr_h: + raise ValueError("Metadata missing full-resolution dimensions") + img_w, img_h = image_size + return img_w / float(fr_w), img_h / float(fr_h) + + +def _compute_spot_radius_fullres(meta: Dict) -> float: + pix_um = meta.get("pixel_size_um_embedded") or meta.get("pixel_size_um_estimated") or meta.get("pixel_size_um") + if meta.get("spot_diameter") and pix_um: + return (float(meta["spot_diameter"]) / float(pix_um)) / 2.0 + if meta.get("spot_diameter_fullres"): + return float(meta["spot_diameter_fullres"]) + raise ValueError("Metadata missing spot diameter information") + + +def _compute_interspot_fullres(meta: Dict) -> float: + pix_um = meta.get("pixel_size_um_embedded") or meta.get("pixel_size_um_estimated") or meta.get("pixel_size_um") + inter = meta.get("inter_spot_dist") + if inter is None: + raise ValueError("Metadata missing inter_spot_dist") + inter_px = float(inter) + if pix_um: + inter_px = float(inter) / float(pix_um) + return inter_px + + +def _get_full_coords(adata: ad.AnnData) -> np.ndarray: + if "pxl_row_in_fullres" in adata.obs.columns and "pxl_col_in_fullres" in adata.obs.columns: + rows = adata.obs["pxl_row_in_fullres"].astype(float).to_numpy() + cols = adata.obs["pxl_col_in_fullres"].astype(float).to_numpy() + elif "y_pixel" in adata.obs.columns and "x_pixel" in adata.obs.columns: + rows = adata.obs["y_pixel"].astype(float).to_numpy() + cols = adata.obs["x_pixel"].astype(float).to_numpy() + else: + raise ValueError("AnnData object missing pixel coordinate columns") + return np.stack([rows, cols], axis=1) + + +def _find_neighbor_indices(full_coords: np.ndarray, spot_idx: int, count: int) -> List[int]: + spot_coord = full_coords[spot_idx] + dists = np.linalg.norm(full_coords - spot_coord[None, :], axis=1) + order = np.argsort(dists) + neighbors = [int(i) for i in order if i != spot_idx][:count] + return neighbors + + +def _crop_square(image: Image.Image, center_xy: Tuple[float, float], side: float) -> Image.Image: + half = side / 2.0 + left = int(round(center_xy[0] - half)) + top = int(round(center_xy[1] - half)) + right = int(round(center_xy[0] + half)) + bottom = int(round(center_xy[1] + half)) + left = max(0, left) + top = max(0, top) + right = min(image.width, right) + bottom = min(image.height, bottom) + return image.crop((left, top, right, bottom)) + + +def _square_from_bbox(bbox: Tuple[int, int, int, int]) -> Tuple[int, int, int, int]: + x, y, w, h = bbox + cx = x + w / 2.0 + cy = y + h / 2.0 + side = max(w, h) + half = side / 2.0 + left = int(math.floor(cx - half)) + top = int(math.floor(cy - half)) + right = int(math.ceil(cx + half)) + bottom = int(math.ceil(cy + half)) + return left, top, right, bottom + + +def _save_image(image: Image.Image, path: Path) -> Path: + path.parent.mkdir(parents=True, exist_ok=True) + image.save(path) + return path + + +def _display_context(image: Image.Image, + main_xy: Tuple[float, float], + neighbor_points: List[Tuple[float, float]], + cell_boxes: List[Tuple[int, int, int, int]], + spot_radius_img: float, + tile_side: float) -> None: + annotated = image.copy() + draw = ImageDraw.Draw(annotated) + + def _tile_rect(center: Tuple[float, float]) -> Tuple[float, float, float, float]: + half = tile_side / 2.0 + left = max(0.0, center[0] - half) + top = max(0.0, center[1] - half) + right = min(float(annotated.width), center[0] + half) + bottom = min(float(annotated.height), center[1] + half) + return left, top, right, bottom + + # draw main spot (green) and neighbors (blue) + main_tile_rect = _tile_rect(main_xy) + draw.rectangle(main_tile_rect, outline=(0, 255, 0), width=4) + draw.ellipse([ + main_xy[0] - spot_radius_img, + main_xy[1] - spot_radius_img, + main_xy[0] + spot_radius_img, + main_xy[1] + spot_radius_img, + ], outline=(0, 255, 0), width=4) + + neighbor_tile_rects: List[Tuple[float, float, float, float]] = [] + for nx, ny in neighbor_points: + tile_rect = _tile_rect((nx, ny)) + draw.rectangle(tile_rect, outline=(0, 120, 255), width=3) + neighbor_tile_rects.append(tile_rect) + draw.ellipse([ + nx - spot_radius_img, + ny - spot_radius_img, + nx + spot_radius_img, + ny + spot_radius_img, + ], outline=(0, 120, 255), width=3) + + # draw cell bounding boxes (red) + for box in cell_boxes: + draw.rectangle(box, outline=(255, 0, 0), width=2) + + # determine display crop boundaries + xs = [main_xy[0]] + [p[0] for p in neighbor_points] + ys = [main_xy[1]] + [p[1] for p in neighbor_points] + xs.extend([main_tile_rect[0], main_tile_rect[2]]) + ys.extend([main_tile_rect[1], main_tile_rect[3]]) + for left, top, right, bottom in neighbor_tile_rects: + xs.extend([left, right]) + ys.extend([top, bottom]) + for left, top, right, bottom in cell_boxes: + xs.extend([left, right]) + ys.extend([top, bottom]) + + margin = tile_side + left = max(0, int(min(xs) - margin)) + right = min(annotated.width, int(max(xs) + margin)) + top = max(0, int(min(ys) - margin)) + bottom = min(annotated.height, int(max(ys) + margin)) + + cropped_display = annotated.crop((left, top, right, bottom)) + + plt.figure(figsize=(6, 6)) + plt.imshow(cropped_display) + plt.axis("off") + plt.title("Spot 222: cells(red), main spot tile(green), neighbors(blue)") + plt.show() + + +def get_example_spot_context() -> Tuple[List[Path], Path, List[Path]]: + """Prepare image tiles for the hard-coded spot and visualize the context.""" + + if not IMAGE_PATH.exists(): + raise FileNotFoundError(f"Expected image file {IMAGE_PATH} not found") + if not META_PATH.exists(): + raise FileNotFoundError(f"Expected metadata file {META_PATH} not found") + if not H5AD_PATH.exists(): + raise FileNotFoundError(f"Expected AnnData file {H5AD_PATH} not found") + + meta = _load_metadata() + adata = ad.read_h5ad(H5AD_PATH) + image = Image.open(IMAGE_PATH).convert("RGB") + + scaling = _compute_scaling(meta, image.size) + scale_x, scale_y = scaling + spot_radius_full = _compute_spot_radius_fullres(meta) + spot_radius_img = spot_radius_full * ((scale_x + scale_y) / 2.0) + interspot_full = _compute_interspot_fullres(meta) + tile_side_img = interspot_full * ((scale_x + scale_y) / 2.0) + + full_coords = _get_full_coords(adata) + mapped_coords = np.column_stack([ + full_coords[:, 1] * scale_x, + full_coords[:, 0] * scale_y, + ]) + + main_xy = tuple(mapped_coords[SPOT_INDEX]) + neighbor_indices = _find_neighbor_indices(full_coords, SPOT_INDEX, NEIGHBOR_COUNT) + neighbor_points = [tuple(mapped_coords[idx]) for idx in neighbor_indices] + + spot_img = _crop_square(image, main_xy, tile_side_img) + spot_img_path = _save_image(spot_img, OUTPUT_DIR / f"spot_{SPOT_INDEX}.png") + + neighbor_paths: List[Path] = [] + for order, idx in enumerate(neighbor_indices, start=1): + neighbor_img = _crop_square(image, mapped_coords[idx], tile_side_img) + neighbor_path = _save_image(neighbor_img, OUTPUT_DIR / f"neighbor_{order}_idx_{idx}.png") + neighbor_paths.append(neighbor_path) + + cell_paths: List[Path] = [] + clamped_boxes: List[Tuple[int, int, int, int]] = [] + for i, bbox in enumerate(CELL_BBOXES, start=1): + square_box = _square_from_bbox(bbox) + left, top, right, bottom = square_box + left = max(0, left) + top = max(0, top) + right = min(image.width, right) + bottom = min(image.height, bottom) + square_box = (left, top, right, bottom) + crop = image.crop(square_box) + cell_path = _save_image(crop, OUTPUT_DIR / f"cell_{i}.png") + cell_paths.append(cell_path) + clamped_boxes.append(square_box) + + _display_context(image, main_xy, neighbor_points, clamped_boxes, spot_radius_img, tile_side_img) + + return cell_paths, spot_img_path, neighbor_paths +def _extract_embedding(image_path: Path, morphology_model, preprocess, device: str) -> torch.Tensor: + image = Image.open(image_path) + size = max(image.width, image.height) + if image.width != image.height: + image = image.resize((size, size)) + tensor = preprocess(image).to(device).unsqueeze(0) + with torch.no_grad(): + embedding = morphology_model(tensor) + return embedding.squeeze(0) + + +def predict_spot_expression_from_image_paths(cell_image_paths: List[Path], + spot_image_path: Path, + neighbor_image_paths: List[Path], + deepspot2cell_model, + morphology_model, + preprocess, + device: str, + gene_names: List[str] | None = None) -> Dict[str, float]: + + cell_embeddings = [] + for cell_path in cell_image_paths: + emb = _extract_embedding(cell_path, morphology_model, preprocess, device) + cell_embeddings.append(emb) + + cell_tensor = torch.stack(cell_embeddings).unsqueeze(0).to(device) + cell_mask = torch.ones((1, cell_tensor.size(1)), device=device) + + spot_embedding = _extract_embedding(spot_image_path, morphology_model, preprocess, device) + context_embeddings = [spot_embedding] + context_mask_flags = [False] + + for neighbor_path in neighbor_image_paths: + if Path(neighbor_path).exists(): + context_embeddings.append(_extract_embedding(neighbor_path, morphology_model, preprocess, device)) + context_mask_flags.append(False) + else: + zeros = torch.zeros_like(spot_embedding) + context_embeddings.append(zeros) + context_mask_flags.append(True) + + context_tensor = torch.stack(context_embeddings).unsqueeze(0).to(device) + context_mask = torch.tensor(context_mask_flags, dtype=torch.bool, device=device).unsqueeze(0) + + with torch.no_grad(): + predictions = deepspot2cell_model._forward_superspot( + cell_tensor, + cell_mask, + context_tensor, + context_mask + ).cpu().numpy() + + predictions = predictions.squeeze(0) + results: Dict[str, float] = {} + if gene_names and len(gene_names) == predictions.shape[-1]: + for gene, value in zip(gene_names, predictions): + results[gene] = float(value) + else: + for idx, value in enumerate(predictions): + results[f"gene_{idx}"] = float(value) + + return results + diff --git a/requirements.txt b/requirements.txt index 5c34358..13ebe64 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,7 @@ torch==2.0.0 +torchvision==0.15.1 +lightning==2.1.3 +torchmetrics==1.2.1 numpy==1.23.5 pandas==1.5.3 scipy==1.11.4 @@ -6,9 +9,19 @@ anndata==0.8.0 scanpy==1.9.3 squidpy==1.2.2 matplotlib==3.8.2 -torchvision==0.15.1 +tqdm==4.66.4 +h5py==3.8.0 +pyyaml==6.0.1 +shapely==2.0.4 +pyvips==2.2.3 +opencv-python==4.9.0.80 +pillow==10.3.0 scikit-learn==1.2.2 numba==0.56.4 llvmlite==0.39.1 dask-image==2022.9.0 -plotnine \ No newline at end of file +huggingface_hub==0.23.4 +transformers==4.42.3 +timm==0.9.12 +plotnine +hest==0.2.0