diff --git a/.gitignore b/.gitignore index b1c7ce8dc..777b15a6f 100644 --- a/.gitignore +++ b/.gitignore @@ -150,6 +150,11 @@ lightning_logs # Autosummary generated rst files library/**/_autosummary/ +/models/ + +# Benchmark & example outputs +benchmark_results/ +outputs/ # autodownloaded datasets library/datasets/ diff --git a/library/README.md b/library/README.md index a61361927..af2b96f6e 100644 --- a/library/README.md +++ b/library/README.md @@ -27,6 +27,9 @@ uv sync --extra dev # Install notebook support uv sync --extra notebook +# Install quantization tools (NNCF) - only required when needed to run model conversion (quantisation)scripts +uv sync --extra quantize + # Install all dependencies uv sync --extra full ``` @@ -40,7 +43,6 @@ uv sync --extra full #### SAM3: Zero-Shot Text Prompting SAM3 performs zero-shot segmentation using text prompts (category names) or bounding boxes — no reference mask needed. -You provide a list of categories you want to segment in any image.

SAM3 Example: Text-prompted segmentation on multiple elephant images @@ -50,157 +52,195 @@ You provide a list of categories you want to segment in any image. from instantlearn.models import SAM3 from instantlearn.data import Sample -# Initialize SAM3 (device: "xpu", "cuda", or "cpu") -model = SAM3(device="xpu") +model = SAM3(device="xpu") # or "cuda", "cpu" -# SAM3 is zero-shot — no fit() required. Just provide categories per sample. predictions = model.predict([ Sample(image_path="examples/assets/coco/000000286874.jpg", categories=["elephant"]), Sample(image_path="examples/assets/coco/000000173279.jpg", categories=["elephant"]), ]) ``` -> **Tip:** Calling `model.fit(sample)` is optional for SAM3. If called, the fitted -> categories are reused for all subsequent `predict()` calls so you don't need to -> specify categories on every target sample. If not called, categories are taken from -> each target sample directly. +> **Tip:** `model.fit(sample)` is optional — if called, categories are reused for all +> subsequent `predict()` calls. Otherwise, categories are taken per sample. + +For more examples, see the [SAM3 aerial & maritime notebook](examples/sam3_aerial_maritime_example.ipynb). + + +

+Box / point prompting + +```python +import numpy as np + +# Box prompt — segment an elephant ROI +target = Sample( + image_path="examples/assets/coco/000000286874.jpg", + bboxes=np.array([[180, 105, 490, 370]]), + categories=["elephant"], + category_ids=[0], +) +predictions = model.predict(target) + +# Point prompt — click on an object +target = Sample( + image_path="examples/assets/coco/000000286874.jpg", + points=np.array([[335, 240]]), + categories=["elephant"], + category_ids=[0], +) +predictions = model.predict(target) +``` + +
+ +
+Visual exemplar mode — fit on reference, predict on any target + +```python +from instantlearn.models.sam3 import Sam3PromptMode + +model = SAM3OpenVINO( + variant=SAM3OVVariant.FP16, + prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR, + device="CPU", +) + +# Fit: encode reference image bounding boxes +ref = Sample( + image_path="examples/assets/coco/000000286874.jpg", + bboxes=np.array([[180, 105, 490, 370]]), + categories=["elephant"], + category_ids=[0], +) +model.fit(ref) + +# Predict: detect similar objects on new images (no prompts needed) +predictions = model.predict([ + Sample(image_path="examples/assets/coco/000000390341.jpg"), + Sample(image_path="examples/assets/coco/000000267704.jpg"), +]) +``` + +
+ +
+SAM3 OpenVINO: Optimized Inference + +`SAM3OpenVINO` runs SAM3 on OpenVINO IR models for faster CPU/GPU inference without PyTorch at runtime. +Pre-exported models are auto-downloaded from [HuggingFace](https://huggingface.co/rajeshgangireddy/exported_sam3). + +| Variant | Enum | Precision | Recommended Use | +| ------- | ---- | --------- | --------------- | +| FP16 | `SAM3OVVariant.FP16` | Half-precision float | Default — balanced speed and accuracy | +| FP32 | `SAM3OVVariant.FP32` | Full-precision float | Maximum accuracy, debugging | +| INT8 | `SAM3OVVariant.INT8` | 8-bit integer (NNCF) | Faster inference, good accuracy | +| INT4 | `SAM3OVVariant.INT4` | 4-bit integer (NNCF) | Maximum compression, fastest | + +**Device support:** `"CPU"`, `"GPU"` (Intel iGPU/dGPU), or `"AUTO"`. +PyTorch-style names (`"xpu"`, `"cuda"`) are mapped to the OpenVINO `"GPU"` device automatically. + +```python +from instantlearn.models import SAM3OpenVINO +from instantlearn.models.sam3 import SAM3OVVariant +from instantlearn.data import Sample + +model = SAM3OpenVINO(variant=SAM3OVVariant.FP16, device="CPU") -For more examples of SAM3 capabilities, see the [SAM3 aerial & maritime notebook](examples/sam3_aerial_maritime_example.ipynb). +predictions = model.predict([ + Sample(image_path="examples/assets/coco/000000286874.jpg", categories=["elephant"]), +]) +``` + +See [examples/sam3_openvino_example.py](examples/sam3_openvino_example.py) for all 7 example scenarios +and [examples/sam3_openvino_variant_comparison.ipynb](examples/sam3_openvino_variant_comparison.ipynb) for +a side-by-side quality and latency comparison across model variants. -Since SAM3 requires a text prompt for every sample (unless `fit()` is used), this is where **Matcher** comes in — -you fit once with a reference mask (one-shot) and predict on any number of new images without providing prompts again. +
#### Matcher: One-Shot Visual Prompting +Matcher fits once with a reference mask (one-shot) and predicts on any number of new images without providing prompts again. +

Matcher Example: Reference Image → Reference Mask → 3 Predictions

-**Basic usage with existing mask files:** - ```python from instantlearn.models import Matcher from instantlearn.data import Sample -# Initialize Matcher (device: "xpu", "cuda", or "cpu") model = Matcher(device="xpu") -# Create reference sample (auto-loads image and mask from paths) -# Paths below are relative to the `library` directory in the repo; adjust if running from elsewhere. ref_sample = Sample( image_path="examples/assets/coco/000000286874.jpg", mask_paths="examples/assets/coco/000000286874_mask.png", ) - -# Fit once on reference model.fit(ref_sample) -# Predict on multiple target images — no prompts needed predictions = model.predict([ "examples/assets/coco/000000390341.jpg", "examples/assets/coco/000000173279.jpg", "examples/assets/coco/000000267704.jpg", ]) - -# Access results for each image -for pred in predictions: - masks = pred["pred_masks"] # Predicted segmentation masks ``` -**Generate a reference mask interactively with SAM:** +
+Generate a reference mask interactively with SAM ```python import torch from instantlearn.components.sam import SAMPredictor from instantlearn.data.utils import read_image -# Load reference image ref_image = read_image("examples/assets/coco/000000286874.jpg") -# Initialize SAM predictor (auto-downloads weights) # Available models: "SAM-HQ-tiny", "SAM-HQ", "SAM2-tiny", "SAM2-small", "SAM2-base", "SAM2-large" predictor = SAMPredictor("SAM-HQ-tiny", device="xpu") -# Set image and generate mask from a point click predictor.set_image(ref_image) ref_mask, _, _ = predictor.forward( - point_coords=torch.tensor([[[280, 237]]], device="xpu"), # Click on elephant - point_labels=torch.tensor([[1]], device="xpu"), # 1 = foreground + point_coords=torch.tensor([[[280, 237]]], device="xpu"), + point_labels=torch.tensor([[1]], device="xpu"), ) -``` -**Fit and predict with the generated mask:** - -```python -from instantlearn.models import Matcher -from instantlearn.data import Sample - -# Initialize Matcher (device: "xpu", "cuda", or "cpu") +# Fit and predict with the generated mask model = Matcher(device="xpu") - -# Create reference sample with the generated mask -ref_sample = Sample( - image=ref_image, - masks=ref_mask[0], -) - -# Fit on reference -model.fit(ref_sample) - -# Predict on target image -target_sample = Sample(image_path="examples/assets/coco/000000390341.jpg") -predictions = model.predict(target_sample) - -# Access results -masks = predictions[0]["pred_masks"] # Predicted segmentation masks +model.fit(Sample(image=ref_image, masks=ref_mask[0])) +predictions = model.predict(Sample(image_path="examples/assets/coco/000000390341.jpg")) ``` -**Fit and predict with GroundedSAM (text-based prompting):** +
+ +
+Text-based prompting with GroundedSAM ```python from instantlearn.models import GroundedSAM from instantlearn.data import Sample -# Initialize GroundedSAM (text-based visual prompting) model = GroundedSAM(device="xpu") +model.fit(Sample(categories=["elephant"])) -# Create reference sample with category labels (no masks needed) -ref_sample = Sample(categories=["elephant"]) - -# Fit on reference (learns category-to-id mapping) -model.fit(ref_sample) - -# Predict on target image using text prompts -target_sample = Sample(image_path="examples/assets/coco/000000390341.jpg") -predictions = model.predict(target_sample) - -# Access results -masks = predictions[0]["pred_masks"] # Predicted segmentation masks -boxes = predictions[0]["pred_boxes"] # Detected bounding boxes -labels = predictions[0]["pred_labels"] # Category labels +predictions = model.predict(Sample(image_path="examples/assets/coco/000000390341.jpg")) +masks = predictions[0]["pred_masks"] +boxes = predictions[0]["pred_boxes"] +labels = predictions[0]["pred_labels"] ``` -### Customizing Encoder and SAM Models +
-You can configure Matcher with different encoder and SAM models: +
+Customizing Encoder and SAM Models ```python from instantlearn.models import Matcher from instantlearn.utils.constants import SAMModelName -# Use a lighter model for faster inference -model = Matcher( - device="xpu", - encoder_model="dinov3_small", # Smaller, faster encoder - sam=SAMModelName.SAM_HQ_TINY, # Fast SAM HQ TINY model -) +# Lighter model for faster inference +model = Matcher(device="xpu", encoder_model="dinov3_small", sam=SAMModelName.SAM_HQ_TINY) -# Use a heavier model for best accuracy -model = Matcher( - device="xpu", - encoder_model="dinov3_huge", # Largest encoder - sam=SAMModelName.SAM_HQ, # Large SAM_HQ model -) +# Heavier model for best accuracy +model = Matcher(device="xpu", encoder_model="dinov3_huge", sam=SAMModelName.SAM_HQ) ``` **Available encoder models:** @@ -224,23 +264,24 @@ model = Matcher( | `SAMModelName.SAM2_BASE` | SAM2 Base | | `SAMModelName.SAM2_LARGE` | SAM2 Large (highest quality) | -### Using Your Own Images with FolderDataset +
+ +
+Using Your Own Images with FolderDataset -Load custom images using `FolderDataset` with this folder structure: +Expected folder structure: ```text your_dataset/ ├── images/ │ ├── category1/ │ │ ├── 1.jpg -│ │ ├── 2.jpg │ │ └── ... │ └── category2/ │ └── ... └── masks/ ├── category1/ - │ ├── 1.png # Binary mask matching 1.jpg - │ ├── 2.png + │ ├── 1.png │ └── ... └── category2/ └── ... @@ -250,31 +291,23 @@ your_dataset/ from instantlearn.data.folder import FolderDataset from instantlearn.data.base import Batch -# Load your dataset -dataset = FolderDataset( - root="path/to/your_dataset", - categories=["category1", "category2"], # Or None for all categories - n_shots=2, # Number of reference images per category -) +dataset = FolderDataset(root="path/to/your_dataset", categories=["category1", "category2"], n_shots=2) -# Get reference and target samples ref_dataset = dataset.get_reference_dataset() target_dataset = dataset.get_target_dataset() -# Create batches for model reference_batch = Batch.collate([ref_dataset[i] for i in range(len(ref_dataset))]) target_batch = Batch.collate([target_dataset[i] for i in range(len(target_dataset))]) -# Fit and predict model.fit(reference_batch) predictions = model.predict(target_batch) ``` > **Note:** Mask files should be binary images (0 = background, 255 = foreground) with the same filename stem as the corresponding image (e.g., `1.jpg` → `1.png`). -## Benchmarking +
-Evaluate models on standard datasets: +## Benchmarking ```bash # Benchmark on LVIS dataset (default) @@ -283,79 +316,61 @@ instantlearn benchmark --dataset_name LVIS --model Matcher # Benchmark on PerSeg dataset instantlearn benchmark --dataset_name PerSeg --model Matcher -# Run all models on a dataset -instantlearn benchmark --dataset_name LVIS --model all - # Comprehensive benchmark (all models, all datasets) instantlearn benchmark --model all --dataset_name all ``` > Results are saved to `~/outputs/` by default. -### Setting Up the LVIS Dataset - -To run benchmarks with the LVIS dataset, set up the following folder structure: +
+Setting Up the LVIS Dataset ```text ~/.cache/instantlearn/datasets/lvis/ ├── train2017/ │ ├── 000000000009.jpg -│ ├── 000000000025.jpg │ └── ... ├── val2017/ │ ├── 000000000139.jpg -│ ├── 000000000285.jpg │ └── ... ├── lvis_v1_train.json └── lvis_v1_val.json ``` -**Download COCO images:** - ```bash cd ~/.cache/instantlearn/datasets/lvis - -# Download and extract images wget http://images.cocodataset.org/zips/train2017.zip wget http://images.cocodataset.org/zips/val2017.zip - -unzip train2017.zip -unzip val2017.zip +unzip train2017.zip && unzip val2017.zip ``` -**Download LVIS annotations:** +Download annotations from the [LVIS Dataset page](https://www.lvisdataset.org/dataset) and place them in the root folder. -Visit the [LVIS Dataset page](https://www.lvisdataset.org/dataset) to download the annotation files, then place them in the root folder. - -### Setting Up the PerSeg Dataset +
-To run benchmarks with the PerSeg dataset, set up the following folder structure: +
+Setting Up the PerSeg Dataset ```text ~/datasets/PerSeg/ ├── Images/ │ ├── backpack/ │ │ ├── 00.jpg -│ │ ├── 01.jpg -│ │ └── ... -│ ├── dog/ │ │ └── ... │ └── ... └── Annotations/ ├── backpack/ │ ├── 00.png - │ ├── 01.png - │ └── ... - ├── dog/ │ └── ... └── ... ``` -**Download PerSeg dataset:** +Download from the [Personalize-SAM repository](https://github.com/ZrrSkywalker/Personalize-SAM). -The PerSeg dataset can be downloaded from the [Personalize-SAM repository](https://github.com/ZrrSkywalker/Personalize-SAM). +
-## Hardware Requirements +
+Hardware Requirements Approximate GPU memory requirements for different model configurations: @@ -370,9 +385,12 @@ Approximate GPU memory requirements for different model configurations: > **Note:** Memory usage varies with input image resolution. Values above are for 1024×1024 images. +
+ ## Supported Models -### Visual Prompting Algorithms +
+Visual Prompting Algorithms | Algorithm | Description | Paper | Repository | Code | | --------- | ----------- | ----- | ---------- | ---- | @@ -381,7 +399,10 @@ Approximate GPU memory requirements for different model configurations: | **PerDino** | Personalized DINO-based prompting, leveraging DINOv2/v3 features for robust matching. | [PerSAM](https://arxiv.org/abs/2305.03048) | [Personalize-SAM](https://github.com/ZrrSkywalker/Personalize-SAM) | [per_dino.py](src/instantlearn/models/per_dino.py) | | **GroundedSAM** | Combines Grounding DINO and SAM for text-based visual prompting and segmentation. | [Grounding DINO](https://arxiv.org/abs/2303.05499), [SAM](https://arxiv.org/abs/2304.02643) | [GroundedSAM](https://github.com/IDEA-Research/Grounded-Segment-Anything) | [grounded_sam.py](src/instantlearn/models/grounded_sam.py) | -### Foundation Models (Backbones) +
+ +
+Foundation Models (Backbones) | Family | Models | Description | Paper | Repository | | ------ | ------ | ----------- | ----- | ---------- | @@ -392,6 +413,8 @@ Approximate GPU memory requirements for different model configurations: | **DINOv3** | Small, Small+, Base, Large, Huge | The latest iteration of DINO models. | [DINOv3](https://arxiv.org/abs/2508.10104) | [dinov3](https://github.com/facebookresearch/dinov3) | | **Grounding DINO** | (Integrated in GroundedSAM) | Open-set object detection model. | [Grounding DINO](https://arxiv.org/abs/2303.05499) | [GroundingDINO](https://github.com/IDEA-Research/GroundingDINO) | +
+ ## Acknowledgements This project builds upon several open-source repositories. See [third-party-programs.txt](../third-party-programs.txt) for the full list. diff --git a/library/docs/01-introduction.md b/library/docs/01-introduction.md index 6e635fbad..944106422 100644 --- a/library/docs/01-introduction.md +++ b/library/docs/01-introduction.md @@ -55,6 +55,8 @@ predictions = model.predict(Sample(image_path=target_image)) | **SoftMatcher** | Enhanced matching with soft feature comparison (Optimal Transport) | | **PerDino** | Personalized DINO-based prompting with DINOv2/v3 features | | **GroundedSAM** | Text-based visual prompting combining Grounding DINO and SAM | +| **SAM3** | Zero-shot text/box/point prompting with open-vocabulary concepts (PyTorch) | +| **SAM3OpenVINO** | SAM3 on OpenVINO IR models — FP16, INT8, INT4 variants for fast CPU/GPU inference | ### Foundation Models @@ -63,6 +65,7 @@ predictions = model.predict(Sample(image_path=target_image)) | **SAM** | SAM-HQ, SAM-HQ-tiny | | **SAM 2** | SAM2-tiny, SAM2-small, SAM2-base, SAM2-large | | **SAM 3** | Segment Anything with Concepts (open-vocabulary) | +| **SAM 3 OpenVINO** | Pre-exported FP16, FP32, INT8, INT4 variants for CPU/GPU inference | | **DINOv2** | Small, Base, Large, Giant | | **DINOv3** | Small, Small+, Base, Large, Huge | diff --git a/library/docs/02-quick-start.md b/library/docs/02-quick-start.md index 7ccc801d0..2fa461b2e 100644 --- a/library/docs/02-quick-start.md +++ b/library/docs/02-quick-start.md @@ -96,6 +96,54 @@ boxes = predictions[0]["pred_boxes"] labels = predictions[0]["pred_labels"] ``` +### Zero-Shot Segmentation with SAM3 OpenVINO + +SAM3OpenVINO provides text, box, point, and visual exemplar prompting using +pre-exported OpenVINO IR models — no PyTorch required at inference time. + +```python +from instantlearn.models import SAM3OpenVINO +from instantlearn.models.sam3 import SAM3OVVariant +from instantlearn.data import Sample + +# Auto-downloads FP16 model from HuggingFace (also supports INT8, INT4, FP32) +model = SAM3OpenVINO(variant=SAM3OVVariant.FP16, device="CPU") + +# Text prompt — detect elephants +predictions = model.predict([ + Sample(image_path="examples/assets/coco/000000286874.jpg", categories=["elephant"]), +]) +``` + +
+Visual exemplar mode — fit once, predict on any image + +```python +from instantlearn.models.sam3 import Sam3PromptMode +import numpy as np + +model_ve = SAM3OpenVINO( + variant=SAM3OVVariant.FP16, + prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR, + device="CPU", +) + +ref = Sample( + image_path="examples/assets/coco/000000286874.jpg", + bboxes=np.array([[180, 105, 490, 370]]), + categories=["elephant"], + category_ids=[0], +) +model_ve.fit(ref) +predictions = model_ve.predict([ + Sample(image_path="examples/assets/coco/000000390341.jpg"), +]) +``` + +
+ +See the full set of examples in [sam3_openvino_example.py](../examples/sam3_openvino_example.py). + ## CLI Usage The library provides a command-line interface with three subcommands: `run`, `benchmark`, and `ui`. diff --git a/library/examples/sam3_openvino_example.py b/library/examples/sam3_openvino_example.py new file mode 100644 index 000000000..2058667ee --- /dev/null +++ b/library/examples/sam3_openvino_example.py @@ -0,0 +1,562 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""SAM3 OpenVINO inference examples. + +This script demonstrates SAM3OpenVINO usage with the same images and prompts +from the project README and SAM3 notebook. It covers: + + 1. Text prompting via fit() — detect elephants across multiple images + 2. Per-sample text prompting — no fit() required + 3. Multi-category text prompting — detect multiple object types at once + 4. Box prompting — segment specific regions of interest + 5. Point prompting (native) — segment with click points (v3 models) + 6. Combined text + box prompting — both prompt types together + 7. Visual exemplar mode — few-shot detection from reference images (v3 models) + +Usage: + # Auto-download default variant (FP16) from HuggingFace + python examples/sam3_openvino_example.py + + # Auto-download INT8 quantised variant + python examples/sam3_openvino_example.py --variant INT8 + + # Using local OpenVINO model directory + python examples/sam3_openvino_example.py --model-dir ./sam3-openvino/openvino-fp16 + + # With visualization saved to disk + python examples/sam3_openvino_example.py --save-viz + + # Run only specific examples + python examples/sam3_openvino_example.py --examples 5,7 +""" + +from __future__ import annotations + +import argparse +import logging +import time +from pathlib import Path + +import cv2 +import numpy as np +import torch + +from instantlearn.data import Sample +from instantlearn.data.utils import read_image +from instantlearn.models import SAM3OpenVINO +from instantlearn.models.sam3 import SAM3OVVariant, Sam3PromptMode + +logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s", force=True) +logger = logging.getLogger(__name__) + +# Paths to COCO example images (relative to library/ directory) +COCO_ASSETS = Path("examples/assets/coco") +IMAGE_ELEPHANT_1 = COCO_ASSETS / "000000286874.jpg" # Elephant +IMAGE_ELEPHANT_2 = COCO_ASSETS / "000000173279.jpg" # Elephant herd +IMAGE_ELEPHANT_3 = COCO_ASSETS / "000000390341.jpg" # Elephant +IMAGE_ELEPHANT_4 = COCO_ASSETS / "000000267704.jpg" # Elephant with person + + +def print_prediction_summary( + prediction: dict[str, torch.Tensor], + *, + categories: list[str] | None = None, +) -> None: + """Print a compact summary of a single image prediction. + + Args: + prediction: Dictionary with pred_masks, pred_boxes, pred_labels. + categories: Optional category name list for label-to-name mapping. + """ + n_masks = len(prediction["pred_masks"]) + if n_masks == 0: + logger.info(" No objects detected.") + return + + logger.info(" Found %d object(s)", n_masks) + + # Show per-detection info + for i in range(n_masks): + box = prediction["pred_boxes"][i] + label_id = prediction["pred_labels"][i].item() + score = box[4].item() if box.shape[0] == 5 else 0.0 + coords = box[:4].tolist() + + label_str = f"id={label_id}" + if categories and 0 <= label_id < len(categories): + label_str = f"{categories[label_id]} (id={label_id})" + + logger.info( + " [%d] %s score=%.3f box=[%.0f, %.0f, %.0f, %.0f] mask=%s", + i, + label_str, + score, + *coords, + tuple(prediction["pred_masks"][i].shape), + ) + + +def save_visualization( + image_path: Path, + prediction: dict[str, torch.Tensor], + output_path: Path, + *, + categories: list[str] | None = None, +) -> None: + """Save a simple overlay visualization of predictions on the image. + + Args: + image_path: Path to the original image. + prediction: Prediction dictionary with pred_masks, pred_boxes, pred_labels. + output_path: Path to save the visualization. + categories: Optional list of category names. + """ + image = cv2.imread(str(image_path)) + if image is None: + logger.warning("Could not read image: %s", image_path) + return + + # Colors for different labels (BGR) + colors = [ + (0, 255, 0), + (255, 0, 0), + (0, 0, 255), + (255, 255, 0), + (0, 255, 255), + (255, 0, 255), + ] + + overlay = image.copy() + for i in range(len(prediction["pred_masks"])): + mask = prediction["pred_masks"][i].numpy() + box = prediction["pred_boxes"][i][:4].int().tolist() + label_id = prediction["pred_labels"][i].item() + score = prediction["pred_boxes"][i][4].item() if prediction["pred_boxes"][i].shape[0] == 5 else 0.0 + color = colors[label_id % len(colors)] + + # Draw mask overlay + if mask.shape[:2] == image.shape[:2]: + mask_bool = mask.astype(bool) + overlay[mask_bool] = ( + np.array(overlay[mask_bool], dtype=np.float32) * 0.5 + np.array(color, dtype=np.float32) * 0.5 + ).astype(np.uint8) + + # Draw bounding box + cv2.rectangle(overlay, (box[0], box[1]), (box[2], box[3]), color, 2) + + # Draw label text + label = f"{label_id}" + if categories and 0 <= label_id < len(categories): + label = categories[label_id] + text = f"{label}: {score:.2f}" + cv2.putText(overlay, text, (box[0], max(box[1] - 5, 15)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2) + + output_path.parent.mkdir(parents=True, exist_ok=True) + cv2.imwrite(str(output_path), overlay) + logger.info(" Visualization saved: %s", output_path) + + +# --------------------------------------------------------------------------- +# Examples +# --------------------------------------------------------------------------- + + +def example_1_text_prompt_with_fit(model: SAM3OpenVINO, *, save_viz: bool = False) -> None: + """Example 1: Text prompting via fit() — same as README. + + Mirrors the README example: fit once with category="elephant", then predict + on multiple images without specifying categories again. + """ + logger.info("=" * 70) + logger.info("Example 1: Text Prompting via fit()") + logger.info("=" * 70) + + # fit() stores categories so predict() reuses them for every image + ref_sample = Sample(categories=["elephant"], category_ids=[0]) + model.fit(ref_sample) + + # Predict on multiple images (same as README) + targets = [ + Sample(image_path=str(IMAGE_ELEPHANT_1)), + Sample(image_path=str(IMAGE_ELEPHANT_2)), + ] + + t0 = time.perf_counter() + predictions = model.predict(targets) + elapsed = time.perf_counter() - t0 + logger.info("Inference on %d images took %.2f s (%.2f s/image)", len(targets), elapsed, elapsed / len(targets)) + + for idx, (target, pred) in enumerate(zip(targets, predictions, strict=True)): + logger.info("Image %d: %s", idx, Path(target.image_path).name) + print_prediction_summary(pred, categories=["elephant"]) + if save_viz: + save_visualization( + Path(target.image_path), + pred, + Path(f"outputs/sam3_ov_ex1_img{idx}.jpg"), + categories=["elephant"], + ) + + # Reset fit state + model.category_mapping = None + + +def example_2_per_sample_text_prompt(model: SAM3OpenVINO, *, save_viz: bool = False) -> None: + """Example 2: Per-sample text prompting (no fit required). + + Each sample carries its own categories — useful when different images + need different prompts. + """ + logger.info("") + logger.info("=" * 70) + logger.info("Example 2: Per-Sample Text Prompting (no fit)") + logger.info("=" * 70) + + targets = [ + Sample( + image_path=str(IMAGE_ELEPHANT_3), + categories=["elephant"], + category_ids=[0], + ), + Sample( + image_path=str(IMAGE_ELEPHANT_4), + categories=["elephant"], + category_ids=[0], + ), + ] + + t0 = time.perf_counter() + predictions = model.predict(targets) + elapsed = time.perf_counter() - t0 + logger.info("Inference: %.2f s", elapsed) + + for idx, (target, pred) in enumerate(zip(targets, predictions, strict=True)): + logger.info("Image %d: %s", idx, Path(target.image_path).name) + print_prediction_summary(pred, categories=["elephant"]) + if save_viz: + save_visualization( + Path(target.image_path), + pred, + Path(f"outputs/sam3_ov_ex2_img{idx}.jpg"), + categories=["elephant"], + ) + + +def example_3_multi_category(model: SAM3OpenVINO, *, save_viz: bool = False) -> None: + """Example 3: Multi-category text prompting. + + Detect multiple object types in a single image. The image with elephants + and people is a good candidate. + """ + logger.info("") + logger.info("=" * 70) + logger.info("Example 3: Multi-Category Text Prompting") + logger.info("=" * 70) + + categories = ["elephant", "person", "tree"] + category_ids = [0, 1, 2] + + target = Sample( + image_path=str(IMAGE_ELEPHANT_4), + categories=categories, + category_ids=category_ids, + ) + + t0 = time.perf_counter() + predictions = model.predict(target) + elapsed = time.perf_counter() - t0 + logger.info("Inference: %.2f s", elapsed) + + logger.info("Image: %s", IMAGE_ELEPHANT_4.name) + print_prediction_summary(predictions[0], categories=categories) + if save_viz: + save_visualization( + IMAGE_ELEPHANT_4, + predictions[0], + Path("outputs/sam3_ov_ex3_multi_category.jpg"), + categories=categories, + ) + + +def example_4_box_prompt(model: SAM3OpenVINO, *, save_viz: bool = False) -> None: + """Example 4: Box prompting — segment a specific region. + + Provide a bounding box in xyxy format to segment the object within that region. + This mirrors the box prompt example from the SAM3 notebook. + """ + logger.info("") + logger.info("=" * 70) + logger.info("Example 4: Box Prompting") + logger.info("=" * 70) + + image = read_image(str(IMAGE_ELEPHANT_1)) + _, h, w = image.shape + logger.info("Image size: %d x %d", w, h) + + # Place a box roughly around the main elephant + # For 000000286874.jpg (elephant), a reasonable box covering the central elephant + box_xyxy = [150, 100, 500, 400] + logger.info("Box prompt (xyxy): %s", box_xyxy) + + target = Sample( + image=image, + bboxes=torch.tensor([box_xyxy]), + ) + + t0 = time.perf_counter() + predictions = model.predict(target) + elapsed = time.perf_counter() - t0 + logger.info("Inference: %.2f s", elapsed) + + print_prediction_summary(predictions[0]) + if save_viz: + save_visualization( + IMAGE_ELEPHANT_1, + predictions[0], + Path("outputs/sam3_ov_ex4_box_prompt.jpg"), + ) + + +def example_5_point_prompt(model: SAM3OpenVINO, *, save_viz: bool = False) -> None: + """Example 5: Native point prompting. + + SAM3 models support point prompts natively through the separate geometry + encoder. Point coordinates are in [x, y] pixel format. + """ + logger.info("") + logger.info("=" * 70) + logger.info("Example 5: Native Point Prompting") + logger.info("=" * 70) + + image = read_image(str(IMAGE_ELEPHANT_1)) + + # Click point at the center of the elephant + point_x, point_y = 320, 260 + logger.info("Point click: (%d, %d)", point_x, point_y) + + target = Sample( + image=image, + points=np.array([[point_x, point_y]]), + categories=["elephant"], + category_ids=[0], + ) + + t0 = time.perf_counter() + predictions = model.predict(target) + elapsed = time.perf_counter() - t0 + logger.info("Inference: %.2f s", elapsed) + + print_prediction_summary(predictions[0], categories=["elephant"]) + if save_viz: + save_visualization( + IMAGE_ELEPHANT_1, + predictions[0], + Path("outputs/sam3_ov_ex5_point_prompt.jpg"), + categories=["elephant"], + ) + + +def example_6_combined_text_and_box(model: SAM3OpenVINO, *, save_viz: bool = False) -> None: + """Example 6: Combined text + box prompting. + + Provide both a text category and a bounding box. The text guides what to + segment, and the box constrains where to look. + """ + logger.info("") + logger.info("=" * 70) + logger.info("Example 6: Combined Text + Box Prompting") + logger.info("=" * 70) + + image = read_image(str(IMAGE_ELEPHANT_4)) + + # Provide both a category and a box + target = Sample( + image=image, + categories=["elephant"], + category_ids=[0], + bboxes=torch.tensor([[100, 80, 450, 380]]), + ) + + t0 = time.perf_counter() + predictions = model.predict(target) + elapsed = time.perf_counter() - t0 + logger.info("Inference: %.2f s", elapsed) + + print_prediction_summary(predictions[0], categories=["elephant"]) + if save_viz: + save_visualization( + IMAGE_ELEPHANT_4, + predictions[0], + Path("outputs/sam3_ov_ex6_combined.jpg"), + categories=["elephant"], + ) + + +def example_7_visual_exemplar( + device: str, + confidence: float, + *, + model_dir: Path | None = None, + variant: SAM3OVVariant = SAM3OVVariant.FP16, + save_viz: bool = False, +) -> None: + """Example 7: Visual exemplar mode (few-shot detection). + + In visual exemplar mode, reference images with annotated bounding boxes are + used to "teach" the model what to look for. The model encodes the reference + prompts at ``fit()`` time and reuses them on new target images. + + This example creates a separate SAM3OpenVINO instance with + ``prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR``. + """ + logger.info("") + logger.info("=" * 70) + logger.info("Example 7: Visual Exemplar Mode (Few-Shot)") + logger.info("=" * 70) + + # Create exemplar-mode model (auto-downloads if model_dir is None) + ve_model = SAM3OpenVINO( + model_dir=model_dir, + variant=variant, + device=device, + confidence_threshold=confidence, + prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR, + ) + + # Reference: one image with a box around the elephant + ref_image = read_image(str(IMAGE_ELEPHANT_1)) + reference = Sample( + image=ref_image, + bboxes=np.array([[150, 100, 500, 400]]), # xyxy around elephant + categories=["elephant"], + category_ids=[0], + ) + + logger.info("Fitting on reference image with 1 exemplar box...") + t0 = time.perf_counter() + ve_model.fit(reference) + fit_time = time.perf_counter() - t0 + logger.info("Fit time: %.2f s", fit_time) + + # Predict on target images + targets = [ + Sample(image_path=str(IMAGE_ELEPHANT_2)), + Sample(image_path=str(IMAGE_ELEPHANT_4)), + ] + + t0 = time.perf_counter() + predictions = ve_model.predict(targets) + elapsed = time.perf_counter() - t0 + logger.info("Predict on %d images: %.2f s", len(targets), elapsed) + + for idx, (target, pred) in enumerate(zip(targets, predictions, strict=True)): + logger.info("Image %d: %s", idx, Path(target.image_path).name) + print_prediction_summary(pred, categories=["elephant"]) + if save_viz: + save_visualization( + Path(target.image_path), + pred, + Path(f"outputs/sam3_ov_ex7_exemplar_img{idx}.jpg"), + categories=["elephant"], + ) + + +def main() -> None: + """Run all SAM3 OpenVINO examples.""" + parser = argparse.ArgumentParser( + description="SAM3 OpenVINO inference examples", + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument( + "--model-dir", + type=str, + default=None, + help="Local directory containing OpenVINO IR or ONNX model files. " + "If omitted, models are auto-downloaded from HuggingFace.", + ) + parser.add_argument( + "--variant", + type=str, + default="FP16", + choices=[v.name for v in SAM3OVVariant], + help="Model variant when auto-downloading (default: FP16).", + ) + parser.add_argument( + "--device", + type=str, + default="CPU", + help="OpenVINO device: CPU, GPU, AUTO (default: CPU).", + ) + parser.add_argument( + "--confidence", + type=float, + default=0.5, + help="Confidence threshold for detections (default: 0.5).", + ) + parser.add_argument( + "--save-viz", + action="store_true", + help="Save visualizations to outputs/ directory.", + ) + parser.add_argument( + "--examples", + type=str, + default="all", + help="Comma-separated example numbers to run, e.g. '1,3,4' (default: all).", + ) + args = parser.parse_args() + + # Initialize SAM3 OpenVINO model (auto-downloads if --model-dir is not given) + variant = SAM3OVVariant[args.variant] + t0 = time.perf_counter() + model = SAM3OpenVINO( + model_dir=args.model_dir, + variant=variant, + device=args.device, + confidence_threshold=args.confidence, + ) + model_dir = model.model_dir + logger.info("Model directory: %s", model_dir) + logger.info("Model loaded in %.2f s", time.perf_counter() - t0) + + # Map of example functions + examples = { + 1: example_1_text_prompt_with_fit, + 2: example_2_per_sample_text_prompt, + 3: example_3_multi_category, + 4: example_4_box_prompt, + 5: example_5_point_prompt, + 6: example_6_combined_text_and_box, + } + + # Example 7 uses a different model instance (exemplar mode) + examples_special = { + 7: lambda _model, save_viz: example_7_visual_exemplar( + args.device, + args.confidence, + model_dir=args.model_dir, + variant=variant, + save_viz=save_viz, + ), + } + + # Determine which examples to run + all_nums = sorted({*examples, *examples_special}) + selected = all_nums if args.examples == "all" else [int(x.strip()) for x in args.examples.split(",")] + + save_viz = args.save_viz + for num in selected: + if num in examples: + examples[num](model, save_viz=save_viz) + elif num in examples_special: + examples_special[num](model, save_viz) + else: + logger.warning("Unknown example number: %d (available: %s)", num, all_nums) + + logger.info("") + logger.info("Done! All examples completed.") + + +if __name__ == "__main__": + main() diff --git a/library/examples/sam3_openvino_variant_comparison.ipynb b/library/examples/sam3_openvino_variant_comparison.ipynb new file mode 100644 index 000000000..f093b69dd --- /dev/null +++ b/library/examples/sam3_openvino_variant_comparison.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1334ece7", + "metadata": {}, + "source": [ + "# SAM3 OpenVINO — Variant Comparison\n", + "\n", + "This notebook compares **SAM3 OpenVINO** model variants (**FP16**, **INT8**, **INT4**) side-by-side across three prompt modes:\n", + "\n", + "- **Text prompt** — detect objects by category name\n", + "- **Box prompt** — segment a specific bounding box region\n", + "- **Visual exemplar** — fit on a reference image, predict on new images\n", + "\n", + "For each prompt mode, we measure:\n", + "- **Quality** — mask IoU between FP16 (baseline) and quantized variants\n", + "- **Latency** — mean inference time per variant\n", + "- **Detection count** — number of objects found\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "bfcaa197", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete. Using device: CPU\n" + ] + } + ], + "source": [ + "# Copyright (C) 2025-2026 Intel Corporation\n", + "# SPDX-License-Identifier: Apache-2.0\n", + "\n", + "from __future__ import annotations\n", + "\n", + "import time\n", + "from pathlib import Path\n", + "\n", + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "\n", + "from instantlearn.data import Sample\n", + "from instantlearn.models import SAM3OpenVINO\n", + "from instantlearn.models.sam3 import SAM3OVVariant, Sam3PromptMode\n", + "\n", + "# Image paths (relative to library/ directory)\n", + "COCO_DIR = Path(\"assets/coco/\")\n", + "IMG1 = COCO_DIR / \"000000267704.jpg\" \n", + "IMG2 = COCO_DIR / \"000000286874.jpg\" \n", + "IMG3 = COCO_DIR / \"000000390341.jpg\" \n", + "\n", + "\n", + "# Variants to compare\n", + "VARIANTS = {\n", + " \"FP16\": SAM3OVVariant.FP16,\n", + " \"INT8\": SAM3OVVariant.INT8,\n", + " \"INT4\": SAM3OVVariant.INT4,\n", + "}\n", + "\n", + "# If you have an Intel GPU, you can set DEVICE = \"GPU\" \n", + "DEVICE = \"CPU\"\n", + "\n", + "def measure_latency(model: SAM3OpenVINO, target, n: int = 5) -> float:\n", + " \"\"\"Run predict() n times and return mean latency in ms.\"\"\"\n", + " times = []\n", + " for _ in range(n):\n", + " t0 = time.perf_counter()\n", + " model.predict(target)\n", + " times.append((time.perf_counter() - t0) * 1000)\n", + " return float(np.mean(times))\n", + "\n", + "\n", + "def compute_mask_iou(mask_a: torch.Tensor, mask_b: torch.Tensor) -> float:\n", + " \"\"\"Compute IoU between two binary mask tensors of the same shape.\"\"\"\n", + " a = mask_a.bool().flatten()\n", + " b = mask_b.bool().flatten()\n", + " intersection = (a & b).sum().item()\n", + " union = (a | b).sum().item()\n", + " return intersection / union if union > 0 else 0.0\n", + "\n", + "\n", + "def overlay_masks(image_path, masks: torch.Tensor, alpha: float = 0.5) -> np.ndarray:\n", + " \"\"\"Overlay colored masks on an image.\"\"\"\n", + " img = cv2.imread(str(image_path))\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + " overlay = img.copy()\n", + " colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255)]\n", + " for i, mask in enumerate(masks):\n", + " color = colors[i % len(colors)]\n", + " binary = mask.numpy().astype(bool)\n", + " overlay[binary] = (\n", + " np.array(color) * alpha + overlay[binary] * (1 - alpha)\n", + " ).astype(np.uint8)\n", + " return overlay\n", + "\n", + "\n", + "print(\"Setup complete. Using device:\", DEVICE)" + ] + }, + { + "cell_type": "markdown", + "id": "490264fb", + "metadata": {}, + "source": [ + "## 1. Load Models\n", + "\n", + "Load all three model variants. Each auto-downloads from HuggingFace on first use." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d1bd5ec1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading FP16 (openvino-fp16)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 18 files: 100%|██████████| 18/18 [00:00<00:00, 60591.87it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Loaded from: /home/devuser/.cache/huggingface/hub/models--rajeshgangireddy--exported_sam3/snapshots/df86be5fa6f8743525849708b0f49e27414576ff/openvino-fp16\n", + "Loading INT8 (openvino-nncf-int8)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 18 files: 100%|██████████| 18/18 [00:00<00:00, 69775.85it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Loaded from: /home/devuser/.cache/huggingface/hub/models--rajeshgangireddy--exported_sam3/snapshots/df86be5fa6f8743525849708b0f49e27414576ff/openvino-nncf-int8\n", + "Loading INT4 (openvino-nncf-int4)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 18 files: 100%|██████████| 18/18 [00:00<00:00, 137518.16it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Loaded from: /home/devuser/.cache/huggingface/hub/models--rajeshgangireddy--exported_sam3/snapshots/df86be5fa6f8743525849708b0f49e27414576ff/openvino-nncf-int4\n", + "\n", + "Loaded 3 variants: ['FP16', 'INT8', 'INT4']\n" + ] + } + ], + "source": [ + "models = {}\n", + "for name, variant in VARIANTS.items():\n", + " print(f\"Loading {name} ({variant.value})...\")\n", + " models[name] = SAM3OpenVINO(variant=variant, device=DEVICE)\n", + " print(f\" Loaded from: {models[name].model_dir}\")\n", + "\n", + "print(f\"\\nLoaded {len(models)} variants: {list(models.keys())}\")" + ] + }, + { + "cell_type": "markdown", + "id": "57a62eb7", + "metadata": {}, + "source": [ + "## 2. Text Prompt Comparison\n", + "\n", + "Detect \"elephant\" on the same image using each variant. Compare mask overlays, detection counts, and latency." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2bdfabf7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FP16: 7 detections, 5867.8 ms\n", + "INT8: 7 detections, 4572.3 ms\n", + "INT4: 6 detections, 4576.3 ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "target = Sample(image_path=str(IMG1), categories=[\"elephant\"], category_ids=[0])\n", + "\n", + "text_results = {}\n", + "text_latencies = {}\n", + "for name, model in models.items():\n", + " # single prediction\n", + " pred = model.predict(target)\n", + " # Measure\n", + " latency = measure_latency(model, target, n=5)\n", + " text_results[name] = pred[0]\n", + " text_latencies[name] = latency\n", + " n_det = len(pred[0][\"pred_masks\"])\n", + " print(f\"{name}: {n_det} detections, {latency:.1f} ms\") \n", + "\n", + "# Visualization\n", + "fig, axes = plt.subplots(1, len(VARIANTS), figsize=(5 * len(VARIANTS), 5))\n", + "for ax, (name, pred) in zip(axes, text_results.items()):\n", + " vis = overlay_masks(IMG1, pred[\"pred_masks\"])\n", + " ax.imshow(vis)\n", + " ax.set_title(f\"{name}\\n{len(pred['pred_masks'])} detections, {text_latencies[name]:.0f} ms\")\n", + " ax.axis(\"off\")\n", + "fig.suptitle('Text Prompt: \"elephant\"', fontsize=14, fontweight=\"bold\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "75b2fd1e", + "metadata": {}, + "source": [ + "## 3. Box Prompt Comparison\n", + "\n", + "Segment a specific elephant ROI using a bounding box prompt. Compare mask IoU between FP16 (baseline) and quantized variants." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0673c3ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FP16: 1 detections, 5820.7 ms\n", + "INT8: 1 detections, 4574.5 ms\n", + "INT4: 1 detections, 4699.6 ms\n", + "\n", + "Mask IoU vs FP16 baseline:\n", + " INT8: IoU = 0.9957\n", + " INT4: IoU = 0.9783\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "IMG2_BOX_COORDS = [130, 127, 458, 400] # [x1, y1, x2, y2]\n", + "box_target = Sample(\n", + " image_path=str(IMG2),\n", + " bboxes=np.array([IMG2_BOX_COORDS]),\n", + " categories=[\"elephant\"],\n", + " category_ids=[0],\n", + ")\n", + "\n", + "box_results = {}\n", + "box_latencies = {}\n", + "for name, model in models.items():\n", + " pred = model.predict(box_target) \n", + " latency = measure_latency(model, box_target, n=5) \n", + " box_results[name] = pred[0]\n", + " box_latencies[name] = latency\n", + " print(f\"{name}: {len(pred[0]['pred_masks'])} detections, {latency:.1f} ms\")\n", + "\n", + "# IoU vs FP16 baseline\n", + "baseline_masks = box_results[\"FP16\"][\"pred_masks\"]\n", + "print(\"\\nMask IoU vs FP16 baseline:\")\n", + "box_ious = {}\n", + "for name, pred in box_results.items():\n", + " if name == \"FP16\":\n", + " box_ious[name] = 1.0\n", + " continue\n", + " # Compare union of all masks between variants\n", + " if len(baseline_masks) > 0 and len(pred[\"pred_masks\"]) > 0:\n", + " base_union = baseline_masks.sum(dim=0).clamp(max=1)\n", + " pred_union = pred[\"pred_masks\"].sum(dim=0).clamp(max=1)\n", + " iou = compute_mask_iou(base_union, pred_union)\n", + " else:\n", + " iou = 0.0\n", + " box_ious[name] = iou\n", + " print(f\" {name}: IoU = {iou:.4f}\")\n", + "\n", + "# Visualization\n", + "fig, axes = plt.subplots(1, len(VARIANTS), figsize=(5 * len(VARIANTS), 5))\n", + "for ax, (name, pred) in zip(axes, box_results.items()):\n", + " vis = overlay_masks(IMG2, pred[\"pred_masks\"])\n", + " ax.imshow(vis)\n", + " iou_str = f\"IoU={box_ious[name]:.3f}\" if name != \"FP16\" else \"baseline\"\n", + " ax.set_title(f\"{name}\\n{len(pred['pred_masks'])} det, {box_latencies[name]:.0f} ms\\n{iou_str}\")\n", + " ax.axis(\"off\")\n", + "fig.suptitle(f\"Box Prompt: {IMG2_BOX_COORDS}\", fontsize=14, fontweight=\"bold\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "40242d1b", + "metadata": {}, + "source": [ + "## 4. Visual Exemplar Comparison\n", + "\n", + "Fit on a reference image with a bounding box, predict on a different image. This tests cross-image transfer quality across variants." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "1c17f478", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading FP16 in VISUAL_EXEMPLAR mode...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 18 files: 100%|██████████| 18/18 [00:00<00:00, 62291.64it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " FP16: 13 detections, 5851.7 ms\n", + "Loading INT8 in VISUAL_EXEMPLAR mode...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 18 files: 100%|██████████| 18/18 [00:00<00:00, 66930.38it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " INT8: 13 detections, 4588.5 ms\n", + "Loading INT4 in VISUAL_EXEMPLAR mode...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 18 files: 100%|██████████| 18/18 [00:00<00:00, 69647.11it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " INT4: 8 detections, 4603.6 ms\n", + "\n", + "Mask IoU vs FP16 baseline (visual exemplar):\n", + " INT8: IoU = 0.9987\n", + " INT4: IoU = 0.8249\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB8YAAAHJCAYAAAD3gVO/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd8FEUbwPHf3l16SG/UJHQIvfeEIk2agIh0EEEBUV6qolJEpEovYgFEREQFEREUBaWICILSa2ihhJDek7t5/whZcikQOuLzfT/xZWdnZ2f39va53Zmd1ZRSCiGEEEIIIYQQQgghhBBCCCGEEOIJZXjUFRBCCCGEEEIIIYQQQgghhBBCCCEeJGkYF0IIIYQQQgghhBBCCCGEEEII8USThnEhhBBCCCGEEEIIIYQQQgghhBBPNGkYF0IIIYQQQgghhBBCCCGEEEII8USThnEhhBBCCCGEEEIIIYQQQgghhBBPNGkYF0IIIYQQQgghhBBCCCGEEEII8USThnEhhBBCCCGEEEIIIYQQQgghhBBPNGkYF0IIIYQQQgghhBBCCCGEEEII8USThnEhhBBCCCGEEEIIIYQQQgghhBBPNGkYF0IIIYQQ4gnSp08fNE1D0zRCQkIedXXyZfz48XqdAwICHnV1nighISH6vu3Tp8+jrk6+nDhxgs6dO+Pj44PRaNTrf+DAAZYtW6ZPa5r2qKsqxC1lPVaXLVump8txLIQQQgghhBCPhjSMCyGEEEII8Rhp2bKl3lji7u5OSkpKrvmUUpQoUULPW7Vq1Ydc00cva8NSXn/S0P7vkpiYSOvWrfn666+5du0aFosl38s+KY2N2bdj27Zt+rxt27blOMbbtWuXazmbN2/OkTevzhEWi4V169bRvXt3SpcujaurKzY2Nri5uVGpUiV69erFp59+SlxcnNVymzZtYvTo0TRs2JDAwEAcHR1xcnKibNmyDBkyhNDQ0Pu1W0Qe/o2dX3KTdTuyn7ezdvjK/Pvmm29yLef555/PkTfrdyir69evM23aNJo3b06hQoWwt7fHzs6OggUL0qhRI0aOHMn27dtRSlktN3nyZNq2bUuJEiVwc3PDZDLh7u5OjRo1eP3117l8+fL92CVCCCGEEEKIB8D0qCsghBBCCCGEuKlPnz5s3rwZgOjoaDZs2ECnTp1y5Nu5cydnzpyxWg6ga9euVKhQAYCiRYs++AoLcR/9+eefnD59Wp/u2bMnFStWRNM0ChcujI2NDdOnT3+ENXz8fP/995w5c4bixYtbpc+ZMydfyx85coRu3brx999/55gXExPDwYMHOXjwICtWrODSpUuMGTNGn9+hQ4dcO+8cP36c48ePs3TpUr7//vt/zegVD0vNmjXlOL5Hc+fOpWPHjlZply5d4quvvsrX8kuWLOF///sfCQkJOeZduXKFK1eusH37dmbMmMHly5fx8/PT50+ePDnHctHR0ezbt499+/bx8ccf8/vvv1OiRIm72DIhhBBCCCHEgyQN40IIIYQQQjxGOnTogJubG9HR0QB8+umnuTaMf/rpp/q/bWxs6N69O5DxxHnLli0fSl0fJzVq1OC5557Lke7q6voIavPfFBsbi4uLyz2Vce7cOavppUuXYjQa9Wlvb2+CgoLuaR1PGovFwvz583n//ff1tBMnTrBp06bbLnvs2DEaNWrE9evX9bTAwEBat25N4cKFSU5O5sSJE2zfvp2wsLBcyzAYDDRq1Ih69ephNBrZsGED+/fvBzJGAOjduzehoaEYDI/ngHX347i9U0FBQXIc36Nff/2Vf/75h0qVKulpCxcuJD09/bbLTp8+nVGjRunTmqbRuHFj6tSpg7OzM5GRkRw4cIAdO3aQnJycY3lvb2+aNWtGiRIl8PLyIiYmhu+++44jR44AcO3aNaZPn87ixYvvw5YKIYQQQggh7islhBBCCCGEeKy89NJLClCAsrGxUREREVbzk5OTlZubm57nmWee0ef17t1bTw8ODrZa7p9//lHdu3dX/v7+ytbWVtnb26uiRYuqxo0bqzFjxqiLFy/mq5ytW7fq8wAVGhqqz9u/f796+eWXVa1atVShQoWUvb29srOzU8WKFVNdunRR27dvz7G948aN08vy9/fP937KWofevXvfNv9zzz1ntZ7Y2Fh93sqVK/V5BoNB/frrr1bLHjhwQPXt21cVL15c2dvbKycnJ1WlShX17rvvqvj4+Bzr8vf318sbN26c2rhxo6pTp45ycHBQhQsXVmPHjlWpqalKKaUWLFigypYtq+zs7FRgYKB69913lcVisSov++cRFhamevfurXx8fJSdnZ2qWrWqWrVqVY56BAcH57mPpk2bptq3b69KlSql3N3dlclkUq6urqpmzZpq0qRJuW5X1n2+dOlStW7dOlW3bl3l5OSkXF1dc93+/Hw2oaGhVmVn/8s8LpYuXWqVnp9lMz+D/EhPT1cff/yxatKkifL09FQmk0l5eHiokJAQtWTJEpWWlnbLem/dulWtWrVK1apVSzk4OCg3NzfVuXNndf78+XytP7dt3Lp1qz4v+3fPYDAoQLm6ulp9XkOGDNHzGI3GPD+LevXqWZU3duxYlZ6enqNOFotFbdu2Tf30009W6QMHDlSnT5+2SjObzapx48ZW5f7zzz/53v685LavP/30U1WtWjVlb2+vvL29Vd++fdWVK1eslsu+z06ePKmmT5+uypYtq2xtbVX79u2t6v7pp5+qp556Snl7eysbGxvl5eWlWrdurb7//vtc65WWlqbee+89VbJkSWVra6uKFy+u3nnnHZWamprj+5Ipt+M4e5kff/yxeuqpp5SPj49ej9q1a6vx48crpazPm3n9ZT0338rFixfViBEjVIUKFZSTk5Oys7NT/v7+qnv37uqPP/7IkT/7OTs6OlqNGDFCFStWTNnY2OR5HruVrOeq7HEg6/kv85gH1AsvvKDnSU5OVt7e3jmO+ezfoSNHjljN9/T0VDt37sy1TnFxcWrhwoUqOjr6tvVPTk5Wzs7OerktW7bM97YLIYQQQgghHh5pGBdCCCGEEOIxs3v3bqub+vPnz7eav2bNGqv53377rT4vrwbtw4cPK0dHx1s2ovzwww+3LUepWzeMz5s375br0DTNqoFIqYfXMB4VFaWKFSumLzNw4ECllFKXLl1SHh4eVo2DWS1cuFCZTKY8t6l8+fLq8uXLVstkbRiuWrWq0jQtx3K9e/dWr7zySq5lvvXWW1blZf08SpcurQoXLpzrcjNnzrRa7lYN456enrf8rCpWrKji4uLy3OcNGza0mv63N4zHx8erRo0a3bKcBg0aWO2T7Otu0KBBrsuVKlVKJSUl3bYOuW3jrRrGO3TooP97wYIFSimlYmJiVIECBfRjL6/PIvt55umnn85X/fIj+3lg796991xm9n3dpEmTXPd18eLFVXh4uL5c9n2W/bjNbBhPTExUzZo1u+Xn/7///S9Hvbp27Zpr3qefftpqOr8N49evX1c1a9bMsw6Z37P71TD+66+/Knd39zzLMBgMOc4rWdft6empypUrl+uy2c9jt5LfhnFPT0/9e+bg4KB3HPvkk0/0PM8880ye36GsHc8AtWbNmnzXMTdms1mFh4erxYsXW5U7fPjweypXCCGEEEII8WDIUOpCCCGEEEI8ZmrXrk25cuU4evQokDFs+uDBg/X5WYdR9/HxoXXr1rctc/ny5SQmJgJQpEgRevTogZOTExcvXuTQoUPs3r37vtTdzs6OOnXqUKVKFTw9PXF2diYmJoaff/6ZP//8E6UUw4cP57nnnsPBweG+rBPg8OHDzJgxI0d6vXr1qFevHgBubm6sXLmSkJAQzGYzH3zwAZ06dWLOnDlERkYCGft+/Pjx+vK7du1iyJAhWCwWAOrUqUPLli2Ji4tj+fLlREREcOTIEXr16sWPP/6Ya932799PUFAQHTt2ZNOmTfz5559AxmcCULVqVdq0acMXX3zByZMngYz3Q7/55pvY2trmKO/EiRO4uroybNgwNE3jk08+0YfeHzNmDO3ataNkyZK33WdFihShcePG+Pv74+7ujlKK0NBQVq9eTUJCAgcPHmThwoVWQw5ntX37dry8vOjatSuenp4cPnz4tuvMi4eHB9OnT2fv3r2sXr1aT898D/OthsS/3bKAfgzcytChQ/ntt9/06ebNm1O3bl12797N5s2bAdixYwdDhw7lk08+ybWMHTt2ULNmTVq0aMHWrVvZuXMnACdPnmTdunV07dr1tvW4E927d2fHjh1EREQwf/58Bg0axNKlS4mLi9O3KevxnNXPP/9sNd2/f//7Vq9jx47p/y5QoABly5a9b2Vn+uWXX2jcuDENGzZk586d+vacOXOG0aNH5/kZbd++naCgINq2bYtSSh+qf9iwYWzZsgUAW1tbunbtSqlSpTh48CBr1qxBKcX7779P9erV6datGwBfffUVX3zxhV52yZIl6dKlC2FhYaxYseKutqtnz576OQKgXLlytG7dGjs7O/bv388ff/wBZByfzs7OLFq0iDNnzgA5Xynh4eFxy3VFR0fTsWNHoqKiAHBwcKBv3764uLiwatUqzp07h8ViYcSIEVSvXp3g4OAcZVy/fp2oqCh69epFoUKF+Oijj4iIiABufR67F6+++io7duwgKSmJDz/8kDFjxjB37lwg43jr27cva9euzXXZrMe9u7t7jveU59epU6coVapUrvOCgoLyPG8KIYQQQgghHrFH2y4vhBBCCCGEyM3UqVOtnj47fvy4Ukqpa9euKRsbGz192LBhVsvl9aT30KFD9fT33nsvx/oiIyNVZGTkbctR6tZPjGf6+++/1WeffabmzJmjpk+friZNmmS1zG+//abnvR9PjOf1l9uTwm+99ZY+P+vQtwUKFMgxLHTWJw9DQkKU2WzW5+3Zs8dqXX///bc+L+tTup6eniomJkYppdTx48etlvHx8dGHwN60aZPVvKzDT2f9PACroX937txpNS/rE++3emJcKaWio6PVxo0b1eLFi9XMmTPV9OnTrZ6abtKkSZ773MXFRZ07dy7Xz+ZOnxjPdLshpm81/3bL3kpERITV8MpdunSxmt+lSxd9ntFo1J9Szf4Uc61atfQh8lNTU5WPj48+L7enjfOzD271xPh3332n3njjDX1606ZNqmTJkgpQ3t7eKjk5Oc/PYtCgQVZlHTlyxKoetWvXzvU7dTu//fab1Tkqc+jve5V9Xzdv3lwfqttisajmzZvr82xtbVVCQkKu+6xOnTo5nt6/fv261agQn3zyidX8rPuqatWqenqLFi30dFdXV3X9+nV93rvvvmu13vw8Mf7PP/9Ypbdu3Vo/njJlP0fd7jt+K7NmzbJa38aNG/V5V69etTo/Zh1yPvvT6rNnz9bnrVu3Ls/z2K3cyRPj6enp+ugfRYsWVb/88os+/5VXXsnxmWf9DmUdOaVWrVpW6zl69Giux3xu+/XkyZO55m3WrJm6evVqvrZZCCGEEEII8fAZEEIIIYQQQjx2evbsqT/JCOhPH37xxRekpaXp6X379s1XeQ0bNtT//eabb1KvXj369evH1KlT2bZtGy4uLri7u99zvf/66y8qVKhA5cqV6dGjB6+++iojR47kzTfftMp38eLFe17X3Ro3bhx169YFID4+Xk9fsGABxYsXt8qb+cQvwLZt2zAajWiahqZp1KpVyyrvrl27cl1f27ZtcXFxASAgIMBq3tNPP42TkxMAJUqUsJqX+RRndsWLF7d6ArpevXoEBgbq0/v27ct1uawsFgujRo3SRxx46aWXGD58OCNHjrR6avpWn1OvXr0oVqxYrvPOnj2Lynh1F8uWLbttfR61PXv2YDab9enevXtbzc86bTab2bNnT67l9O/fHxsbGwBsbGysPpe8Ps97NWjQIEymjMHgXnjhBU6dOgXAgAEDsLOzy3c5mqbdc13Wr19Pq1at9HNU165deeutt+653Nz06NFDr7OmaXTv3l2fl5qaysGDB3NdbsSIEdjb21ul/fHHH6Snp+vT/fr107/nmqaxcOFCfd6BAwf00Tf27t2rp7ds2dLqCe0ePXrc8Tbt2LHDanrcuHH68ZQp+znqXvz+++/6v729vWnVqpU+7ePjYzWdNW9WRqORgQMH6tNlypSxmv8gjnuj0aiPonLhwgV69uwJZBwHr7zySr7LuZdj3svLi+nTpzN58mQGDx5MkSJFANiyZQtVq1blwIEDd122EEIIIYQQ4sGRhnEhhBBCCCEeQwULFqR58+b69GeffYZSymoY9WrVqlGxYsV8lde5c2dGjBiBnZ0dZrOZ33//naVLlzJmzBgaN25MiRIl8hwKWyllNZ2SkpJrvqSkJNq0aZOvIbXzKuNu9e7dW2+IzfqX2zDSRqORl19+2SrNx8eHLl265MibOcR6fly7di3X9EKFCun/zj6kcNZ5mY2bmTKHb8/Ox8cnR5qvr6/+78xh1W9l7ty5TJ8+ndTU1Fvmu9Xn9CCGx35Usn/OWfdnbtN5NfZl7/iQtWE6r8/zXhUuXJhOnToBEBYWBmQ0yg8aNOi2y2V1/Phxq+mhQ4cyffr0XIfPzs2sWbN45plnSEhIADIalz/77DMMhgdz2yH79yD7Z5TX9yC34/ZOvudKKa5fv55jHberT35kr0fWjhUPQtb15VbfrGl5HfO+vr5WHQ2yd8Z4UMd9//79cXR0BG4e961atcpzePNMWY/7kydPWsU3Hx8fpk+fzvTp0/Wy8+Lm5saIESN4/fXXmT9/PseOHdPj8aVLl/LdaU0IIYQQQgjxcMk7xoUQQgghhHhM9enThx9++AHIeAL3ww8/tHr3bJ8+fe6ovOnTp/Pmm2+ya9cujh07xokTJ1i/fj2XLl3i3LlzDBo0iF9//RXAqjErKSnJqpzM92Bn99tvv3H58mV9evjw4YwZMwYvLy8SExP1J6MftWvXruV4/2t4eDijR49m9uzZVukeHh6Eh4cD0KBBA9q3b59nuXm9xzr7E59ZZW8Mz4/M+mR19epV/d9ubm63LSPru7gLFSrE2rVrqVKlCra2towaNcrq/dx5eVw+z/sh+7uYs+7P3KbzGl0h+2d9P57Czo9XX33V6jPt1KmTVaeL3DRt2pSxY8fq08uWLbM6vjPfo33lyhX9vJAbs9nMK6+8wqJFi/S0CRMm8Pbbb9/xdtyJ7N+D7J9RXt+D3I7b7J//sGHDbrn/Mt957+bmpjeS364++ZG9HqGhoXh7e99xOXezvtzqmzXtcTvmPTw86NGjB0uWLNHThg4detvlmjZtqsewyMhI1q9frx/3Hh4ejBgxAoApU6boIwPkh5OTE82aNdNHKjhw4AAxMTH6sSKEEEIIIYR4PMgT40IIIYQQQjym2rdvb9UYMWzYMP3ftra2esNVfoSGhhIdHY2rqyutWrVi2LBhLFq0iPnz5+t5/vrrL/3fWRuVjh8/rj8ZGRMTw4IFC3JdR2YDUabu3bvj5eUFwJdffpnvuj5o/fr148qVKwCULl1a7wQwd+5cNm3aZJU3a2P3lStXGDBgACNGjLD6Gzx4MD4+Pnk2jN9vZ86csRq2fdeuXYSGhurT1atXv20ZWT+rGjVqUKtWLWxtbUlOTua777675zoGBATow1DfaQeOu5W9ge5OGrVq1apl9eqC5cuXW83POm00GnMMo/+o1a1bl5o1a+rT+WkgrF27NnXq1NGn161bx9SpU3OMEHErsbGxPP3003qjuK2tLZ999tltG8WzHh+5jeqQH5mjaEDGU9wrV67U59na2uZ7NA3I2BdZP38bG5sc3/MRI0bQuXNnKlasqL8aoUaNGvoymzZtsnoC+7PPPrvjbWrQoIHV9DvvvGM1xDvAuXPnrKazHvd3csyD9fnt2rVrekcsyGjozzr9sM5vdyLrcV62bFmrUVbyMmTIEKvP+qWXXrqjYc9///33XEcHSUpK4pdffsl3OUIIIYQQQohHQ54YF0IIIYQQ4jFlZ2fH888/r7/fNmujR9u2bfH09Mx3WatXr2bcuHGEhIRQqlQpChYsSEJCAqtWrdLzZG0Mz9rIFhsbS9WqValVqxY7d+7Uh63NLvu7ZXv06MFzzz3H2bNn9XekPyiHDx9mxowZuc4bMGCA3pC1YMECNmzYAICjoyMbNmxgyZIlzJgxA6UUffr04eDBg/pTmsOHD+fbb79FKcWpU6eoUKECHTt2xNfXl5iYGA4ePMivv/5KQkICvXr1eqDbmFXr1q319yB/8sknerrJZMpXQ3SZMmX0pyY3bNjAwIED8fPz46uvvuLYsWMPqtoPVPahwbt160a9evUwGAz07NnzlkNbe3p60qdPHz7++GMgoyNHdHQ0devWZffu3WzevFnP26tXrzv67j0sn376KceOHcPGxoa6devma5mPP/6Y+vXr6x1fxowZw4oVK2jRogXe3t5ERkaybt26PJevX78+hw4d0qdbtmzJ5cuXc3wXW7VqRVBQ0B1v0638+OOPNG3alEaNGrFjxw5+/vlnfV63bt1uOxR2Vh4eHvTr148PP/wQgGnTprF3717q1auHvb09YWFh7N69m/3799O7d29atGgBZLzTPfPYiImJoXbt2jz33HNcvHjxrs55FStWpHXr1mzcuBHI+G5WrlyZ1q1bY29vz+HDh/ntt9+IiIjQl8l63H///ff6KB1eXl63PRf07t2bd955R+8o06lTJ/r164eLiwuff/458fHxQMZT4K+99todb8+DFhQUxObNm0lMTKREiRL5elo9KCiId955hzfeeAPI6PBUo0YNWrVqRfXq1bGxsSE0NJTY2Nhcl1+9ejULFy4kJCSEatWq4erqSnh4ON9++61VB6WGDRvK0+JCCCGEEEI8hqRhXAghhBBCiMdYnz599Ibx7Ol3KjU1lR9//JEff/wx1/lZhxd/5plnKFWqlN54evbsWc6ePQtg1XCTVfXq1WnZsqX+1PWRI0cYN24ckNEAk/0p3Ptp79697N27N9d5nTt3xsXFhcOHD+vD5ELGULmlSpVi0qRJ/PDDDxw+fJirV6/St29fvfG8QYMGzJ8/n1dffZX09HQuXLjAnDlzHth25Ef58uVJTExk1qxZOea9++67lCxZ8rZljB49mk2bNpGeno7FYtGHI3Z2dqZjx4588803973eD1rdunUpWLCgPpz/t99+y7fffgtASEjIbd/5PGfOHE6ePMlvv/0GkOt3pX79+sydO/cB1P7elS1b9o7f+16+fHm2bdtG165d9Q4Rhw8f5vDhw7nmzz7Ud9ZGcYD169ezfv36HMt5eXnd94bxp59+mu+//56tW7dapQcEBDB16tQ7Lm/27NmEhoayZcsWAH755ZfbPgH87LPP8uyzz7JmzRoATp06xbvvvgtkHHPbtm2743p8+umntGrVSn9txpEjRzhy5Ig+P3tja8eOHfVza2Jior7tQUFBt40Tbm5ufPPNN7Rv357o6GiSkpJyjAhiMBiYNm1avt81/7Dl5ynx7F5//XWcnJwYNWoUKSkpmM1mNmzYoJ/3s8veESYtLY2ffvqJn376Kdf8AQEBeicbIYQQQgghxONFhlIXQgghhBDiMVazZs0cDUp+fn60bNnyjsrp0KEDb7/9Ns2aNSMgIABHR0dMJhMFCxbk6aefZv369bzyyit6fnt7e37++We6dOmCm5sb9vb21K5dm7Vr1zJy5Mg81/P111/z2muvUbBgQWxtbSlZsiSTJ09+5I0EKSkpdOvWjeTkZACaNGnCkCFDgIwn81esWKEPSfz9999bDTE/aNAg9u/fz4ABAyhdurS+73x9fQkODuatt97i77//fmjb4u3tze7du+nXrx8+Pj7Y2dlRpUoVVq5cmePd6Xlp0KABmzdvpl69etjZ2eHq6krr1q3ZtWvXHQ1B/Tixs7Nj48aNNG/eXB8h4E44OTnx888/89FHH9G4cWM8PDwwmUy4u7sTHBzMBx98wLZt23B2dn4AtX90KleuzD///MPKlSvp1KkT/v7+ODg4YGNjg6enJzVr1uSll17im2++4dKlS/e8PrPZbDWUf+3ate+qnBEjRrBq1SqqV6+Ovb09np6e9O7dm127duHj43PH5Tk6OrJ582Y+//xzWrduja+vLyaTCQcHB0qUKEHnzp1ZsmQJ77//vtVyK1eu5N1336V48eLY2NgQEBDA2LFjrYYhvxOenp7s3LmTjz76iGbNmuHt7a0fh9WrV8/x5Ha7du2YP38+5cqVw9bW9o7X16hRIw4dOsTw4cMJCgrC0dERW1tbihUrRvfu3dm1axfDhw+/q215nA0dOpTQ0FDGjx9PgwYN9P3s4OBAsWLFeOqppxg/fjx//fUXM2fO1Jfr1q0bQ4cOpWbNmnqcs7Ozo1ChQjRv3py5c+dy+PBhSpUq9Qi3TgghhBBCCJEXTd3JC8SEEEIIIYQQQjx0ffr00Z8KDQ4OvqsnUYV4HOzZs0dvDG/Xrp3+VP/tnD17lsDAQH1669athISEPIgqCiGEEEIIIYR4QskT40IIIYQQQgghhHgofv31VwAcHBwe+WsJhBBCCCGEEEL8t0jDuBBCCCGEEEIIIR6KzIbx119/nYCAgEdbGSGEEEIIIYQQ/ymmR10BIYQQQgghhBBC/Dds2LDhUVdBCCGEEEIIIcR/lLxjXAghhBBCCCGEEEIIIYQQQgghxBNNhlIXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSEeUydPnqR58+a4urqiaRrr1q171FUSQgghhBBCCCGEEEIIIYQQ4l9JGsaFuA+WLVuGpmn6n8lkonDhwvTp04ewsLC7KrN3794cPHiQd999lxUrVlCjRo37XGshhBBCPAjZfxdk/RszZgwAAQEBVuk+Pj40bNiQtWvXWpW1Z88eBg0aRPXq1bGxsUHTtFuu++rVqwwcOJDChQtjb29PQEAAL7zwwgPbViGEEOJJkxnH9+7dC8D48ePRNA1fX18SExNz5A8ICKBNmzYA9OnTJ8/fAFn/+vTpoy//5ZdfUqdOHdzc3PD09CQ4OJjvv//+oWyrEEII8aR42PE7U1paGuXLl0fTNGbMmPFAt1EIcX+YHnUFhHiSTJw4kcDAQJKTk9m9ezfLli1jx44dHDp0CHt7+3yXk5SUxO+//87YsWMZMmTIA6yxEEIIIR6UzN8FWVWoUEH/d5UqVRg+fDgAly5d4oMPPqBjx44sWrSIl156CYCNGzfy0UcfUalSJYoXL86JEyfyXN+FCxeoX78+AC+99BKFCxfm0qVL7Nmz535vmhBCCPGfEx4ezqJFi/TYnZuBAwfSrFkzfTo0NJS3336bAQMG0LBhQz29RIkSAMybN4+hQ4fy9NNPM2XKFJKTk1m2bBlt2rTh66+/pmPHjg9ug4QQQoj/gAcRv7OaN28e58+fv7+VFkI8UNIwLsR91KpVK/3J7v79++Pl5cXUqVNZv349Xbp0yXc5165dA8DNze2+1S05ORlbW1sMBhkoQgghhHgYsv4uyE3hwoXp0aOHPt2rVy9KlizJrFmz9Ibxl19+mdGjR+Pg4MCQIUNu2TA+cOBATCYTf/75J56envdvQ4QQQghBlSpVmD59OoMGDcLBwSHXPHXr1qVu3br69N69e3n77bepW7euVczPNG/ePGrWrMl3332njwrTr18/ChcuzPLly6VhXAghhLhHDyJ+ZwoPD2fixImMHj2at99++77XXQjxYEgLmRAPUGaPstOnT+tpx44do3Pnznh4eGBvb0+NGjVYv369Pn/8+PH4+/sDMHLkSDRNIyAgQJ8fFhZGv3798PX1xc7OjqCgID755BOr9W7btg1N0/jiiy948803KVy4MI6OjsTGxgLwxx9/0LJlS1xdXXF0dCQ4OJidO3dalZE53MypU6fo06cPbm5uuLq60rdv31yHn/nss8+oVasWjo6OuLu706hRI3788UerPD/88AMNGzbEycmJAgUK8PTTT3P48OG72LNCCCHEk8fPz49y5coRGhqqp/n6+uZ58Z7VsWPH+OGHHxg5ciSenp4kJyeTlpb2IKsrhBBC/Ke8/fbbXL16lUWLFt23MmNjY/Hx8bF6VYqLiwvOzs75iv9CCCGEuLUHEb8zjRkzhjJlytyy8VwI8fiRhnEhHqCzZ88C4O7uDsDhw4epU6cOR48eZcyYMcycORMnJyc6dOigv1O0Y8eOzJo1C4Dnn3+eFStWMHv2bCDjvaF16tRhy5YtDBkyhDlz5lCyZEleeOEFPU9W77zzDt9//z0jRoxg8uTJ2Nra8ssvv9CoUSNiY2MZN24ckydPJjo6miZNmuQ61GqXLl2Ii4vjvffeo0uXLixbtowJEyZY5ZkwYQI9e/bExsaGiRMnMmHCBIoWLcovv/yi51mxYgVPP/00zs7OTJ06lbfeeosjR47QoEEDfT8JIYQQT5KYmBgiIiKs/m4lLS2NCxcu3NXT3lu2bAEyGtKbNm2Kg4MDDg4OtGrVSuKsEEIIcR80bNiQJk2aMG3aNJKSku5LmSEhIWzatIl58+Zx9uxZjh07xuDBg4mJieHVV1+9L+sQQggh/sseRPwG2LNnD8uXL2f27NlWHdyEEI8/GUpdiPso8wZ4cnIyf/zxBxMmTMDOzo42bdoA8Oqrr1KsWDH+/PNP7OzsABg0aBANGjRg9OjRPPPMM1SqVAkXFxeGDRtGtWrVrHqcjR07FrPZzMGDB/Wb5i+99BLPP/8848ePZ+DAgVa9ypOTk9m7d6+eppTipZdeonHjxvzwww960B44cCBBQUG8+eabOZ7yrlq1Kh9//LE+ff36dT7++GOmTp0KwKlTp5g4cSLPPPMMX331ldVQ7UopAOLj4xk6dCj9+/dnyZIl+vzevXtTpkwZJk+ebJUuhBBCPAmyvqMsU2ZshIyG8MzG8kuXLvHee+9x9epVXnnllTte18mTJwEYMGAANWvWZPXq1Zw/f54JEybQrFkz/vnnHxwdHe9yS4QQQggBMG7cOIKDg1m8eDHDhg275/Lmzp1LREQEQ4cOZejQoQB4eXnx888/Ww3pKoQQQoi7d7/jt1KKV155heeee466detKZ3Qh/mWkYVyI+yj7DfCAgAA+++wzihQpQmRkJL/88gsTJ04kLi6OuLg4PV+LFi0YN24cYWFhFC5cONeylVJ8/fXXdOnSBaWU1VNnLVq04IsvvuCvv/6ifv36enrv3r2tGsoPHDjAyZMnefPNN7l+/bpV+U2bNmXFihVYLBarxu3Md5xmatiwIWvXriU2NhYXFxfWrVuHxWLh7bffzvH+8syG959++ono6Gief/55q3objUZq167N1q1bc9+hQgghxL/YggULKF26dJ7zf/zxR7y9vfVpo9FIz5499c5ndyI+Ph7IGI79+++/12NykSJFeP755/n888/p37//HZcrhBBCiJsaNWpE48aNmTZtGi+99NI9D3fu6OhImTJlKFKkCG3atCEuLo5Zs2bRsWNHtm/fTsmSJe9TzYUQQoj/rvsdv5ctW8bBgwf56quv7lMNhRAPkzSMC3EfZd4Aj4mJ4ZNPPuG3337Tnww/deoUSineeust3nrrrVyXDw8Pz7Nh/Nq1a0RHR7NkyZI8n64ODw+3mg4MDLSaznyarHfv3nluQ0xMjD70O0CxYsWs5mfOi4qKwsXFhdOnT2MwGChfvnyeZWaut0mTJrnOd3FxyXNZIYQQ4t+qVq1a1KhRI8/5tWvXZtKkSWiahqOjI+XKlcPNze2u1pV5Yd+lSxerjmrPPvssPXv2ZNeuXdIwLoQQQtwH48ePv29PnT377LOYTCa+++47Pa19+/aUKlWKsWPHsnr16nutrhBCCCG4f/E7NjaW119/nZEjR1K0aNH7WEMhxMMiDeNC3EdZb4B36NCBBg0a0K1bN44fP47FYgFgxIgRtGjRItflb9UbPHP5Hj165NmwXalSJavp7L3fMsuYPn06VapUybUMZ2dnq2mj0ZhrvqxDwd5O5npXrFiBn59fjvkmk5yKhBBC/Pd4eXnlOtz63ShUqBCQ8Y7xrIxGI56enkRFRd2X9QghhBD/dY0aNSIkJER/6uxunTlzhk2bNuXo+O7h4UGDBg3YuXPnvVZVCCGEEDfcr/g9Y8YMUlNTee655/Qh1C9evAhkPEh29uxZChUqhK2t7f2othDiAZDWKCEeEKPRyHvvvUfjxo2ZP38+/fr1A8DGxuauboJ7e3tToEABzGbzXd9EL1GiBJDxhPb9uhFfokQJLBYLR44cybOxPXO9Pj4+9229QgghhLipevXqAISFhVmlp6amEhERYTVkuxBCCCHuzfjx4wkJCeGDDz646zKuXr0KgNlszjEvLS2N9PT0uy5bCCGEEDndj/h9/vx5oqKiCAoKyjFv8uTJTJ48mf379+d5n1wI8egZbp9FCHG3QkJCqFWrFrNnz8bFxUUPvJcvX86R99q1a7csy2g00qlTJ77++msOHTp0x8tDxk3zEiVKMGPGDP1dpHdaRnYdOnTAYDAwceJE/cnwTJlPlbdo0QIXFxcmT55MWlrafVmvEEIIIW4KCQnBx8eHlStXkpycrKcvW7YMs9nMU0899QhrJ4QQQjxZgoODCQkJYerUqVZx906ULFkSg8HA6tWrrUZku3jxItu3b6dq1ar3q7pCCCGE4P7E76FDh7J27Vqrv8yG9j59+rB27docrzcVQjxe5IlxIR6wkSNH8uyzz7Js2TIWLFhAgwYNqFixIi+++CLFixfn6tWr/P7771y8eJG///77lmVNmTKFrVu3Urt2bV588UXKly9PZGQkf/31F1u2bCEyMvKWyxsMBj766CNatWpFUFAQffv2pXDhwoSFhbF161ZcXFys3m2WHyVLlmTs2LG88847NGzYkI4dO2JnZ8eff/5JoUKFeO+993BxcWHRokX07NmTatWq0bVrV7y9vTl//jzff/899evXZ/78+Xe0XiGEEOK/4Ny5c6xYsQKAvXv3AjBp0iQA/P396dmzJwB2dnZMnz6d3r1706hRI3r27Mn58+eZM2eOHp+FEEIIcf+MGzeOxo0b3/Xy3t7e9OvXj48++oimTZvSsWNH4uLiWLhwIUlJSbz++uv3sbZCCCGEgHuP39WqVaNatWpWaZlDqgcFBdGhQ4d7qJ0Q4mGQhnEhHrCOHTvqT2m/+OKL7N27lwkTJrBs2TKuX7+Oj48PVatW5e23375tWb6+vuzZs4eJEyfyzTffsHDhQjw9PQkKCmLq1Kn5qk9ISAi///4777zzDvPnzyc+Ph4/Pz9q167NwIED72obJ06cSGBgIPPmzWPs2LE4OjpSqVIl/WY9QLdu3ShUqBBTpkxh+vTppKSkULhwYRo2bEjfvn3var1CCCHEky40NJS33nrLKi1zOjg42CrW9urVC1tbW6ZMmcLIkSNxc3Nj4MCBTJ48GaPR+FDrLYQQQjzpQkJCCA4O5tdff73rMhYtWkTlypX5+OOP9YbwmjVr8umnn9KoUaP7VVUhhBBC3HA/4rcQ4t9NU1nHaxJCCCGEEEIIIYQQQgghhBBCCCGeMPKOcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBBCCCGEEEIIIYQQQgjxRJOGcSGEEEIIIYQQQgghhBBCCCGEEE80aRgXQgghhBAiC03TGD9+/KOuhhBCCCHukMRwIYQQ4vEVEhJCSEjIo66GEOI/ThrGxRNr2rRplC1bFovFoqfFx8fTv39//Pz80DSN1157jbNnz6JpGsuWLbvrdUlQvzMhISFUqFDhoa+3a9eudOnS5aGvVwghRP7Fx8czbtw4WrZsiYeHxy1j9IcffkhwcDC+vr7Y2dkRGBhI3759OXv27EOtc6ZLly4xfvx4Dhw4cE/lBAQEoGlajr+XXnopR959+/bRpk0b/Pz8cHZ2plKlSsydOxez2XxXZf7888/069eP0qVL4+joSPHixenfvz+XL1++p20SQgjx5JMYbu306dPY29ujaRp79+61mrds2bJc47KmaVy5csUqb3JyMu+99x7ly5fH0dGRwoUL8+yzz3L48OEc6/zpp59o0KABjo6OuLu707lz50e2T4UQQvy7nTx5kq5du1KkSBEcHR0pW7YsEydOJDEx8ZHUZ/Lkyaxbt+6+lZeWlkb58uXRNI0ZM2bkmuf06dN069YNHx8fHBwcKFWqFGPHjs2R7+jRo7Rs2RJnZ2c8PDzo2bMn165du+X6V65ciaZpODs735ftEULkn+lRV0CIByE2NpapU6cyY8YMDIab/T8mT57MsmXLeOuttyhRogTlypXLdfmNGzeyZ88e6Wn+hBk9ejQ1atTg77//pnLlyo+6OkIIIXIRERHBxIkTKVasGJUrV2bbtm155t2/fz+BgYG0a9cOd3d3QkND+fDDD9mwYQN///03hQoVengVJ+Om+oQJEwgICKBKlSr3VFaVKlUYPny4VVrp0qWtpvft20e9evUoVaoUo0ePxtHRkR9++IFXX32V06dPM2fOnDsuc/To0URGRvLss89SqlQpzpw5w/z589mwYQMHDhzAz8/vnrZLCCHEk0tiuLVhw4ZhMplISUnJM8/EiRMJDAy0SnNzc7Oa7t69O+vXr+fFF1+kWrVqXLp0iQULFlC3bl0OHjyIv78/ABs2bKB9+/ZUq1aNKVOmEBsby5w5c2jQoAH79+/H29v7vmyXEEKIJ9+FCxeoVasWrq6uDBkyBA8PD37//XfGjRvHvn37+Pbbbx96nSZPnkznzp3p0KHDfSlv3rx5nD9/Ps/5Bw4cICQkhMKFCzN8+HA8PT05f/48Fy5csMp38eJFGjVqhKurK5MnTyY+Pp4ZM2Zw8OBB9uzZg62tbY6y4+PjGTVqFE5OTvdlW4QQd0YaxsUT6ZNPPiE9PZ3nn3/eKv2XX36hTp06jBs3Tk9TSpGUlISNjY2etnHjRhYsWJDvhvEff/zxvtRbPFhVq1alRo0azJw5k08//fRRV0cIIUQuChYsyOXLl/Hz82Pv3r3UrFkzz7wLFy7MkdahQwdq1KjBp59+ypgxYx5kVR+owoUL06NHj1vm+eCDDwD47bff8PDwAGDgwIEEBwezbNmyHA3j+Snz/fffp0GDBlYdC1u2bElwcDDz589n0qRJd7M5Qggh/gMkht+0efNmNm/ezKhRo24ZO1u1akWNGjXynB8WFsY333zDiBEjmD59up7esGFDmjRpwjfffMOwYcOAjM5txYsXZ+fOnfpN+LZt2+oN5TNnzrxPWyeEEOJJt2LFCqKjo9mxYwdBQUEADBgwAIvFwqeffkpUVBTu7u6PuJZ3Lzw8nIkTJzJ69GjefvvtHPMtFgs9e/akbNmybN26FQcHhzzLmjx5MgkJCezbt49ixYoBUKtWLZ566imWLVvGgAEDciwzadIkChQoQOPGje/rU/BCiPyRodTFE2np0qW0a9cOe3t7q/Tw8PAcva81TcPe3h6j0XjX67O1tc2199eTLHMI+ls9BfA46tKlC9988w3x8fGPuipCCCFyYWdnd09PJQcEBAAQHR1927wpKSkMGzYMb29vChQoQLt27bh48WKuecPCwujXr58+5GtQUBCffPKJPn/btm16A0Dfvn314VDv5VUtqampJCQk5Dk/NjYWe3v7HL9tChYsmOeF++3KbNSokVWjeGaah4cHR48evW2dM1+X8s8//xAcHIyjoyMlS5bkq6++AuDXX3+ldu3aODg4UKZMGbZs2WK1fFxcHK+99hoBAQHY2dnh4+PDU089xV9//XXbdQshhHi0JIZnSEtL49VXX+XVV1+lRIkSt80fFxeX4xUoWecB+Pr6WqUXLFgQQI/3kZGRHDlyhGeeecbq3kTlypUpV64cX3zxxW3rERAQQJs2bdi2bRs1atTAwcGBihUr6tf833zzDRUrVsTe3p7q1auzf/9+q+WvXLlC3759KVKkCHZ2dhQsWJD27dvLUO5CCPEvFBsbC+QefwwGQ77ugy9ZsoQSJUrg4OBArVq12L59e675UlJSGDduHCVLlsTOzo6iRYsyatQoqxFXNE0jISGB5cuX63G6T58+d719Y8aMoUyZMnl2HP/xxx85dOgQ48aNw8HBgcTExDxj9ddff02bNm30RnGAZs2aUbp0ab788ssc+U+ePMmsWbN4//33MZny/9xqnz59cHZ25vz587Rp0wZnZ2cKFy7MggULADh48CBNmjTByckJf39/Pv/8c6vl09LSmDBhAqVKlcLe3h5PT08aNGjATz/9lO86CPGkkIZx8cQJDQ3ln3/+oVmzZnratm3b0DSN0NBQvv/+ez2Anj17Nsc7xvv06aMHlKzv+bqV7O8Yz1zfl19+yYQJEyhcuDAFChSgc+fOxMTEkJKSwmuvvYaPjw/Ozs707ds3x/BqS5cupUmTJvj4+GBnZ0f58uVZtGhRjnVbLBbGjx9PoUKFcHR0pHHjxhw5coSAgIAcPxCio6N57bXXKFq0KHZ2dpQsWZKpU6davYf9YcocAtbBwYHAwEAWL16cI094eDgvvPACvr6+2NvbU7lyZZYvX24139vbm5CQEJRSevqpU6dwcnLiueeesyrvqaeeIiEhQYK+EEI8Qa5fv054eDh79+6lb9++ADRt2vS2y/Xv35/Zs2fTvHlzpkyZgo2NDU8//XSOfFevXqVOnTps2bKFIUOGMGfOHEqWLMkLL7zA7NmzAShXrhwTJ04EMnrSr1ixghUrVtCoUaO72qZffvkFR0dHnJ2dCQgIyPH0N2T8/oiNjWXgwIEcPXqUc+fOsXjxYr755htef/31uyozN/Hx8cTHx+Pl5ZWv/FFRUbRp04batWszbdo07Ozs6Nq1K6tXr6Zr1660bt2aKVOmkJCQQOfOnfWb/gAvvfQSixYtolOnTixcuJARI0bg4OCQr0Z5IYQQ/z5PYgyfPXs2UVFRvPnmm7fN27hxY1xcXHB0dKRdu3acPHnSan6JEiUoUqQIM2fO5LvvvuPixYvs2bOHl156icDAQLp27Qqg30/IrWOco6Mjly5dyvHu8tycOnWKbt260bZtW9577z2ioqJo27YtK1euZNiwYfTo0YMJEyZw+vRpunTpYnUvoVOnTqxdu5a+ffuycOFChg4dSlxc3C2HqRVCCPF4yrzP/cILL3DgwAEuXLjA6tWrWbRoEUOHDr3tEOAff/wxAwcOxM/Pj2nTplG/fn3atWuXYxhyi8VCu3btmDFjBm3btmXevHl06NCBWbNmWd3TXbFiBXZ2djRs2FCP0wMHDryrbduzZw/Lly9n9uzZed7zz+zAbWdnR40aNXBycsLR0ZGuXbsSGRmp5wsLCyM8PDzX0V9q1aqVoxMZwGuvvUbjxo1p3br1HdfdbDbTqlUrihYtyrRp0wgICGDIkCEsW7aMli1bUqNGDaZOnUqBAgXo1asXoaGh+rLjx49nwoQJNG7cmPnz5zN27FiKFSsmndDFf5MS4gnz2WefKUD9888/etqVK1fUihUrlJeXl6pSpYpasWKFWrFihYqPj1ehoaEKUEuXLlVKKbVr1y711FNPKUDPt2LFiluuMzg4WAUHB+vTW7duVYCqUqWKqlu3rpo7d64aOnSo0jRNde3aVXXr1k21atVKLViwQPXs2VMBasKECVZl1qxZU/Xp00fNmjVLzZs3TzVv3lwBav78+Vb5Ro0apQDVtm1bNX/+fPXiiy+qIkWKKC8vL9W7d289X0JCgqpUqZLy9PRUb7zxhlq8eLHq1auX0jRNvfrqq3e8nzP329atW+942eDgYFWoUCHl4+OjhgwZoubOnasaNGigAPXxxx/r+RITE1W5cuWUjY2NGjZsmJo7d65q2LChAtTs2bP1fGvWrFGAmjNnjlJKKbPZrOrXr698fX1VRESE1brT0tKUg4ODGj58+B3XWwghxMP1559/WsXovNjZ2SlAAcrT01PNnTv3tmUfOHBAAWrQoEFW6d26dVOAGjdunJ72wgsvqIIFC+aIKV27dlWurq4qMTHxjup7O23btlVTp05V69atUx9//LEe+0aNGmWVLz09XQ0ZMkTZ2Njo2280GtWiRYvuuszcvPPOOwpQP//8823zBgcHK0B9/vnnetqxY8cUoAwGg9q9e7eevnnz5hz7y9XVVQ0ePPi26xFCCPF4+6/G8MuXL6sCBQqoDz74QCml1NKlSxWg/vzzT6t8q1evVn369FHLly9Xa9euVW+++aZydHRUXl5e6vz581Z5//jjD1WiRAl9PwGqevXq6vLly3oes9ms3NzcVNOmTa2WjYiIUE5OTgpQe/fuvWXd/f39FaB27dqlp2XGagcHB3Xu3Dk9/YMPPrC6HxAVFaUANX369PzvLCGEEI+1d955Rzk4OFjFn7Fjx952udTUVOXj46OqVKmiUlJS9PQlS5YowOoe+ooVK5TBYFDbt2+3KmPx4sUKUDt37tTTnJycrO513w2LxaJq1aqlnn/+eaXUzfvb2eNXu3bt9N8m3bt3V1999ZV66623lMlkUvXq1VMWi0UpdfP3w6effppjXSNHjlSASk5O1tM2bNigTCaTOnz4sFJKqd69eysnJ6d81b13794KUJMnT9bToqKilIODg9I0TX3xxRd6euY1eNbfRJUrV1ZPP/10vtYlxJNOGsbFE+fNN99UgIqLi8sxz9/fP0cAyN4wrpRSgwcPVnfSbySvhvEKFSqo1NRUPf35559XmqapVq1aWS1ft25d5e/vb5WWeYGeVYsWLVTx4sX16StXriiTyaQ6dOhglW/8+PEKsPqx8M477ygnJyd14sQJq7xjxoxRRqMxx8X37dxrwzigZs6cqaelpKSoKlWqKB8fH32fzZ49WwHqs88+0/OlpqaqunXrKmdnZxUbG6unP//888rR0VGdOHFCTZ8+XQFq3bp1ua6/dOnSOT4DIYQQj5/83qT+5Zdf1MaNG9XMmTNV1apV1XvvvXfbsidPnqwAdezYMav0PXv2WF1AWiwW5ebmpgYMGKCuXbtm9Zd5s3vHjh13VN87ZbFYVIsWLZTJZFIXLlywmjdr1izVpk0btXz5crV69WrVoUMHZTKZ1Nq1a++6zKx+/fVXZTKZVJcuXfJV1+DgYOXs7KzfKMjk5uamgoKCrNKio6MVoN566y09zd/fX9WoUUOFhYXla31CCCEeT//VGN6rVy9VuXJlZTablVJ5N4znZvv27UrTNDVw4ECr9BMnTqhOnTqpMWPGqHXr1qkZM2YoT09P1aBBA5WUlKTnGz16tALUmDFj1IkTJ9TevXtVkyZN9A502RsdsvP391fly5e3SsuM1dnvo2R2Tsjs2J6cnKxsbW3V008/rSIjI2+7rUIIIR5/K1asUC1atFBLlixRX3/9terXr5/SNE3Nmzfvlsvt2rVLAWrx4sVW6ampqcrV1dXqHnq7du1UUFBQjjh94sQJBahJkybpee9Hw/gnn3yiHBwc9PvgeTWMN2nSRAGqZcuWVunvvfeeAtRPP/2klFLqt99+U4BavXp1jnW99dZbClBRUVFKqYx736VKlVJDhgzR89xNw3h4eLhVepUqVfK8Bu/Zs6c+HRwcrAICAnK0DQjxXyRDqYsnzvXr1zGZTDg7Oz/qqtCrVy9sbGz06dq1a6OUol+/flb5ateuzYULF0hPT9fTsg6BFhMTQ0REBMHBwZw5c4aYmBgAfv75Z9LT0xk0aJBVea+88kqOuqxZs4aGDRvi7u5ORESE/tesWTPMZjO//fbbLbclPj7earmoqCirumX+Zdbtdkwmk9WQN7a2tgwcOJDw8HD27dsHwMaNG/Hz8+P555/X89nY2DB06FDi4+P59ddf9fT58+fj6upK586deeutt+jZsyft27fPdd2Z+0AIIcSToXHjxrRq1Yr//e9/rFmzhgkTJjB//vxbLnPu3DkMBkOOd3+WKVPGavratWtER0ezZMkSvL29rf4yh3wNDw+/vxuUjaZpDBs2jPT0dP09nwBTpkxh6tSprFq1il69etGlSxfWrl1LgwYNGDx4sNXvivyWmdWxY8d45plnqFChAh999FG+61ukSJEcQ9K5urpStGjRHGmA/psCYNq0aRw6dIiiRYtSq1Ytxo8fz5kzZ/K9biGEEP8uT1IM3717NytWrGDWrFkYDHd+u61BgwbUrl1bH74VMq63GzZsSN26dXnvvfdo3749w4cP5+uvv2bHjh0sXbpUzztx4kReeOEFpk2bRunSpalRowYmk4kXXngBIF/3SLK+HxVuxurbxXA7OzumTp3KDz/8gK+vL40aNWLatGn5Gr5dCCHE4+eLL75gwIABfPTRR7z44ot07NiRjz/+mN69ezN69GiuX7+e57Lnzp0DoFSpUlbpNjY2FC9e3Crt5MmTHD58OEecLl26NHB/43RsbCyvv/46I0eOzBHXssu8L5/1njRAt27dANi1a5dVvuyvSAVITk62yjNr1iwiIiKYMGHCXW+Dvb093t7eVmmurq55XoNnvdaeOHEi0dHRlC5dmooVKzJy5Ej++eefu66LEP9m0jAuxAN0JxeVFovFqlF5586dNGvWDCcnJ9zc3PD29uaNN94A0PNl/tAoWbKkVXkeHh64u7tbpZ08eZJNmzbl+KGR+S722/3QGDJkiNVy1apVA6BDhw5W6Xk1RmdXqFChHO+jyfzRc/bsWX37SpUqleOmQrly5ay2P3Ob586dyz///IOrqytz587Nc91Kqdu+N14IIcS/U4kSJahatSorV668L+VlvjuzR48e/PTTT7n+1a9f/76s61YyfztkfZ/ZwoULadKkSY4b3e3atePSpUt6PL2TMjNduHCB5s2b4+rqysaNGylQoEC+62o0Gu8oXSml/7tLly6cOXOGefPmUahQIaZPn05QUBA//PBDvtcvhBDi3+nfHsNHjRpFw4YNCQwM5OzZs5w9e1bvkH358uV8vWu7aNGiVnH566+/5urVq7Rr184qX3BwMC4uLuzcuVNPs7W15aOPPuLSpUv89ttvHD9+nM2bNxMTE4PBYMhx3yA39xLDX3vtNU6cOMF7772Hvb09b731FuXKlcv1/apCCCEebwsXLqRq1aoUKVLEKr1du3YkJibet3O7xWKhYsWKecbp7A+D3YsZM2aQmprKc889p8fpixcvAhkdvc6ePUtqaiqQcd8awNfX16oMHx8fPT9AwYIFgYw4n93ly5fx8PDAzs6OmJgYJk2axIsvvkhsbKy+/vj4eJRSnD17Nl+dAO4lTjdq1IjTp0/zySef6J3fq1Wrdked4IV4UpgedQWEuN88PT1JT08nLi7ujm7iPgh3G6xOnz5N06ZNKVu2LO+//z5FixbF1taWjRs3MmvWLP0C/05YLBaeeuopRo0alev8zEbpvIwaNYoePXro01evXqVHjx7MmDGDypUr6+nZG+Qfps2bNwMZP04uXryIm5tbrvmioqJy9FoUQgjx5EhKSsq1x3ZW/v7+WCwWTp8+bfWE2fHjx63yeXt7U6BAAcxms96ZLC8PstNV5lPTWXuHX716FbPZnCNvWloawC2fGM+rTMgYfad58+akpKTw888/6xf7D0vBggUZNGgQgwYNIjw8nGrVqvHuu+/SqlWrh1oPIYQQD9+/OYafP3+ec+fOERgYmGNeu3btcHV1JTo6+pZlnDlzJkesB3LEe6UUZrM511jv6+ur38g3m81s27aN2rVrP5RR9UqUKMHw4cMZPnw4J0+epEqVKsycOZPPPvvsga9bCCHE/XP16tVc7/Hm51rT398fyHhIq0mTJlbLhoaGWt1HLlGiBH///TdNmza9bSy+11h9/vx5oqKiCAoKyjFv8uTJTJ48mf3791OlShWqV6/Ohx9+SFhYmFW+S5cuATevoQsXLoy3tzd79+7NUeaePXuoUqUKkHEvOj4+nmnTpjFt2rQceQMDA2nfvj3r1q27p228HQ8PD/r27Uvfvn2Jj4+nUaNGjB8/nv79+z/Q9QrxuJEnxsUTp2zZsgCEhobedRmP+mni7777jpSUFNavX8/AgQNp3bo1zZo1sxpeHW7+0Dh16pRV+vXr162GSoGMHxrx8fE0a9Ys17/sT7dnV758eav8mT3rq1evbpVevXr1fG3jpUuXSEhIsEo7ceIEAAEBAfr2nTx5MkdHgGPHjlltP8CmTZv46KOPGDVqFN7e3vTu3TvXH2np6elcuHBBf+pcCCHEv1N6enqOWAcZF58HDx6kRo0at1w+s5E1+wgjs2fPtpo2Go106tSJr7/+mkOHDuUo59q1a/q/M0dCud1N71uJjIzMcfM7LS2NKVOmYGtrS+PGjfX00qVL89NPP1kNY2c2m/nyyy8pUKCAPsTsnZSZkJBA69atCQsLY+PGjQ+1I5nZbM7xShYfHx8KFSp020YSIYQQ/x5PagxfsmQJa9eutfrLfM3ZjBkzrJ6Ez7ruTBs3bmTfvn20bNlST8vswP7FF19Y5V2/fj0JCQlUrVr1lnWaMWMGly9fZvjw4Xe9XfmRmJioDxmbqUSJEhQoUEBiuBBC/AuVLl2a/fv36/dqM61atQqDwUClSpXyXLZGjRp4e3uzePFi/QlsgGXLluWIs126dCEsLIwPP/wwRzlJSUlW946dnJzuKU4PHTo0R5z+4IMPAOjTpw9r167VO7e1b98eOzs7li5danVfOvPp6qeeekpP69SpExs2bODChQt62s8//8yJEyd49tlngYzr2uzrXrt2LY0bN8be3p61a9fy+uuv3/W25Uf24e+dnZ0pWbKkxGnxnyRPjIsnTt26dQHYu3fvLYP0rWS9KM7rqeMHKfOJ8qzDncTExFi9PwygadOmmEwmFi1aZBWQc3snW5cuXRg/fjybN2+mRYsWVvOio6NxdnbGZHp4p4T09HQ++OAD/ve//wGQmprKBx98gLe3t9643rp1a3788UdWr16tv9MlPT2defPm4ezsTHBwsF7//v37U6tWLSZPnqy/p27y5Mm8/fbbVus9cuQIycnJ1KtX76FtqxBCiDszf/58oqOj9d7Y3333nT7E2SuvvIKrqyvx8fEULVqU5557jqCgIJycnDh48CBLly7F1dWVt95665brqFKlCs8//zwLFy4kJiaGevXq8fPPP+fobAYZ7/LeunUrtWvX5sUXX6R8+fJERkby119/sWXLFn3I0xIlSuDm5sbixYspUKAATk5O1K5dm8DAQLZt20bjxo0ZN24c48ePz7Ne69evZ9KkSXTu3JnAwEAiIyP5/PPPOXToEJMnT8bPz0/PO2bMGHr06EHt2rUZMGAADg4OrFq1in379jFp0iRsbGzuuMzu3buzZ88e+vXrx9GjRzl69Kg+z9nZmQ4dOtz6w7sHcXFxFClShM6dO1O5cmWcnZ3ZsmULf/75JzNnznxg6xVCCHH//JdjePPmzXOkZd7ADw4Otmrwr1evHlWrVqVGjRq4urry119/8cknn1C0aFH9FWoAbdu2JSgoiIkTJ3Lu3Dnq1KnDqVOnmD9/PgULFtTfHw7w2Wef8fXXX9OoUSM9hn755Zf079+fTp063XKf3qsTJ07QtGlTunTpQvny5TGZTKxdu5arV6/StWvXB7puIYQQ99/IkSP54YcfaNiwIUOGDMHT05MNGzbwww8/0L9/f32o8dzY2NgwadIkBg4cSJMmTXjuuecIDQ1l6dKlOd4x3rNnT7788kteeukltm7dSv369TGbzRw7dowvv/ySzZs36/GzevXqbNmyhffff59ChQoRGBhI7dq1gYyH3IKDg9m2bVue9apWrZr+atBMma8fCwoKsrrW9fPzY+zYsbz99tu0bNmSDh068Pfff/Phhx/y/PPPU7NmTT3vG2+8wZo1a2jcuDGvvvoq8fHxTJ8+nYoVK9K3b18AHB0dc72WXrduHXv27Hmg19mZypcvT0hICNWrV8fDw4O9e/fy1VdfMWTIkAe+biEeO0qIJ1CFChXU888/nyPd399fPf3001ZpoaGhClBLly7V07788ksFqJ49e6rPPvtMrVq16pbrCw4OVsHBwfr01q1bFaDWrFljlW/p0qUKUH/++adV+rhx4xSgrl27ppRS6tixY8rW1lZVrFhRzZ8/X02ZMkWVKFFCVa5cWQEqNDRUX3b48OEKUG3btlULFixQAwYMUEWLFlVeXl6qT58+er6EhARVrVo1ZTKZVP/+/dWiRYvUjBkzVO/evZWTk5O+7vzK3G9bt269o+WUythfhQoVUj4+PuqVV15R8+bNUw0aNFCAWrJkiZ4vMTFRlStXTtna2qrhw4erefPmqeDgYAWo2bNn6/l69eql7O3t1dGjR/W0/v37KxsbG3XgwAGrdc+YMUM5Ojqq2NjYO663EEKIh8Pf318Buf5lxsCUlBT16quvqkqVKikXFxdlY2Oj/P391QsvvGAVJ28lKSlJDR06VHl6eionJyfVtm1bdeHCBQWocePGWeW9evWqGjx4sCpatKiysbFRfn5+qmnTplZxSymlvv32W1W+fHllMpmsfl989913ClCLFy++ZZ327t2r2rZtqwoXLqxsbW2Vs7OzatCggfryyy9zzb9p0yYVHBysvLy89N8O2ddxJ2Xeat/7+/vfeoeqjBgfFBSUa7nZf4MppRSgBg8erJTK+ExHjhypKleurAoUKKCcnJxU5cqV1cKFC2+7XiGEEI+H/3IMz01e9wDGjh2rqlSpolxdXZWNjY0qVqyYevnll9WVK1dylBEZGamGDRumSpcurezs7JSXl5fq2rWrOnPmjFW+P/74QzVq1Ei5u7sre3t7VblyZbV48WJlsVjyVdf8xOpMmfcDpk+frpRSKiIiQg0ePFiVLVtWOTk5KVdXV1W7du08f78IIYR4/P3xxx+qVatWys/PT9nY2KjSpUurd999V6WlpeVr+YULF6rAwEBlZ2enatSooX777bcc99CVUio1NVVNnTpVBQUFKTs7O+Xu7q6qV6+uJkyYoGJiYvR8x44dU40aNVIODg4KUL1791ZKKRUXF6cA1bVr1zvexuzxLCuLxaLmzZunSpcurWxsbFTRokXVm2++qVJTU3PkPXTokGrevLlydHRUbm5uqnv37rnG9Owy78vnR15583sNPmnSJFWrVi3l5uamHBwcVNmyZdW7776b6/YI8aTTlMrySKoQT4hZs2bx9ttvEx4ebjX8eEBAABUqVGDDhg162tmzZwkMDGTp0qX06dMHyBjKc9iwYXzxxRdERESglOJWX5WQkBAAvVdaZo/yNWvW0LlzZz3fsmXL6Nu3L3/++adVb/Hx48czYcIErl27hpeXF5DRs/7NN9/kxIkT+Pn58fLLL+Pt7U2/fv0IDQ3Vhxs3m81MmDCBDz/8kJiYGOrWrcuCBQto0KABzz77LIsWLdLXEx8fz+TJk1mzZg3nz5/HxcWF0qVL07FjR4YOHao/WZYfmftt69at+vbnV0hICBERESxfvpxXXnmF/fv34+vry8iRIxk8eLBV3vDwcMaMGcN3331HbGwsZcqU4X//+5/+Wa1fv5727dszc+ZM/elzyHjqrGLFiri5ufHnn3/q21anTh1KlSrFihUr7qjOQgghxL0YNWoUq1at4tSpU9jZ2T3q6gghhBAinySGCyGEEI+vjRs30qZNG/7++28qVqz4qKsjhPgXkIZx8USKiYmhePHiTJs2zWposf+K6Oho3N3dmTRpEmPHjn3U1XlsHDhwgGrVqvHXX39RpUqVR10dIYQQ/yE1a9bkxRdfZMCAAY+6KkIIIYS4AxLDhRBCiMfXyJEjCQsL4/PPP3/UVRFC/EtIw7h4Yk2dOpWlS5dy5MgRDAbDo67OA5OUlGT1VDzcfAJ9x44d1K9f/xHV7PHTtWtXLBYLX3755aOuihBCCCGEEEIIIYQQQgghhHiIpGFciH+5ZcuWsWzZMlq3bo2zszM7duxg1apVNG/enM2bNz/q6gkhhBBCCCGEEEIIIYQQQgjxyJkedQWEEPemUqVKmEwmpk2bRmxsLL6+vrz66qtMmjTpUVdNCCGEEEIIIYQQQgghhBBCiMeCPDEuhBBCCCGEEEIIIYQQQgghhBDiifbkvnhZCCGEEEIIIYQQQgghhBBCCCGEQBrGhRBCCCGEyNX48ePRNI2IiIhHXZUcQkJCCAkJ0afPnj2LpmksW7bskdVJCCGEEEIIIYQQQojHmTSMCyGEEEIIIYQQQojH3rJly9A0jb17997Rcrfr7FahQgWrDmf3wmKxMG3aNAIDA7G3t6dSpUqsWrUq38v/9NNPNGjQAEdHR9zd3encuTNnz57NkS8+Pp7XXnuNIkWKYGdnR7ly5Vi0aNE9lSmEEEI8CP+F+L1v3z7atGmDn58fzs7OVKpUiblz52I2m/U8169fZ/r06TRq1Ahvb2/c3NyoU6cOq1evzlHetm3b0DQt17/du3ffl20W4r/KlN+MZ6+Go4wGiro5oQw2pCWnYjIaMBpt0UjDopnQAE0zcyEyikuRSbjZ2VHE1ZFzUTH4erni6WhPosVCRHwsrnYuuNjZAhaUZsKggZZlfZqm5VETIYQQQgghRFb+/v4kJSVhY2PzqKsihBBC/KeNHTuWKVOm8OKLL1KzZk2+/fZbunXrhqZpdO3a9ZbLbtiwgfbt21OtWjWmTJlCbGwsc+bMoUGDBuzfvx9vb28AzGYzLVq0YO/evQwePJhSpUqxefNmBg0aRFRUFG+88cYdlymEEEL8l91L/N63bx/16tWjVKlSjB49GkdHR3744QdeffVVTp8+zZw5cwD4/fffGTt2LK1bt+bNN9/EZDLx9ddf07VrV44cOcKECRNylD106FBq1qxplVayZMn7t+FC/Aflu2Hc18WJ0xFRRNo54O4AJjtbQKG0jN40Bg0uRIaRkKjhXcCFkp5GziYc4Z+oNMwp7hw6eIwWFepz8fp5/jl7noDCZakdWAhNMwJmwAA3GsOlUVwIIYQQQoj80zQNe3v7R10NIYQQ4j8tLCyMmTNnMnjwYObPnw9A//79CQ4OZuTIkTz77LMYjcY8lx89ejTFixdn586d2NraAtC2bVu9UXvmzJkAfPPNN+zatYuPP/6Yfv36AfDyyy/TuXNn3nnnHfr374+Pj88dlSmEEEL8V91r/P7ggw8A+O233/Dw8ABg4MCBBAcHs2zZMr1hPCgoiJMnT+Lv768vO2jQIJo1a8bUqVMZNWoUTk5OVmU3bNiQzp0739ftFeK/Lt9DqdvY2eHv6YkhLR3NYEEjjeuxEVyPiyEyPh0sFmyMNkRGgw1GzIZ0LkSeYv+h43jY+lDISXE15hR+7oUo4uPDyfAwTl+PwawsaJoCDZRSD3BThRBCCCGEuHMRERF06dIFFxcXPD09efXVV0lOTtbnL126lCZNmuDj44OdnR3ly5fPdSjTvXv30qJFC7y8vHBwcCAwMFC/mZ3JYrEwe/ZsgoKCsLe3x9fXl4EDBxIVFXXLOub2jvE+ffrg7OxMWFgYHTp0wNnZGW9vb0aMGGE1nNu9rFcIIYR41H755RcaNmyIk5MTbm5utG/fnqNHjz6Sunz77bekpaUxaNAgPU3TNF5++WUuXrzI77//nueykZGRHDlyhGeeeUZvwAaoXLky5cqV44svvtDTtm/fDpDjCbauXbuSnJzMt99+e8dlCiGEEA/TkxK/AWJjY7G3t8fNzc0qvWDBgjg4OOjTgYGBVo3imevp0KEDKSkpnDlzJtfy4+LiSE9Pv8OtEkLkJd8N4xazGUd7G9Is8RwPu8SpS1fZ9lco+0+bSVcaaEZ8nb0oUSSN41f/wWgwYp9ShGLurkSar1DevxrX48OxtQUnR0fqFKqAm40dZnMaiQnJYLnZKC4N5EIIIYQQ4nHRpUsXkpOTee+992jdujVz585lwIAB+vxFixbh7+/PG2+8wcyZMylatCiDBg1iwYIFep7w8HCaN2/O2bNnGTNmDPPmzaN79+453g02cOBARo4cSf369ZkzZw59+/Zl5cqVtGjRgrS0tDuue+ZQq56ensyYMYPg4GBmzpzJkiVLHuh6hRBCiIdhy5YttGjRgvDwcMaPH8///vc/du3aRf369e/5HdoRERH5+ktJSdGX2b9/P05OTpQrV86qrFq1aunz85JZTtYb6JkcHR25dOkSV65c0fMajUarxu7MfJAxpOudlimEEEI8LE9S/AYICQkhNjaWgQMHcvToUc6dO8fixYv55ptveP31129b58xY7OXllWNe3759cXFxwd7ensaNG9/xe9qFEDnleyh1k8GIWcH+U8f59egfVPAriZ93BaoE2OPuaotFmVGamXOXz3MtzoiDw3Uux9pQqVh1Dp+9giUhlavpZ0k4H09cQiHKeLng5OxBmiWFFBSOmgKlAAOapumN4zKsuhBCCCGEeJQCAwP1J68GDx6Mi4sLCxcuZMSIEVSqVIlff/3V6obzkCFDaNmyJe+//z6DBw8GYNeuXURFRfHjjz9So0YNPe+kSZP0f+/YsYOPPvqIlStX0q1bNz29cePGtGzZkjVr1lil50dycjLPPfccb731FgAvvfQS1apV4+OPP+bll19+YOsVQgghHoaRI0fi4eHB77//rg9d2qFDB6pWrcq4ceNYvnz5XZed33dvL126lD59+gBw+fJlfH19c9zLKliwIACXLl3KsxxfX1/c3NzYuXOnVfr169c5cuQIkDHUq5+fH2XKlMFsNrN7924aNGig5818kjwsLOyOyxRCCCEelicpfgO8+OKLHD58mA8++ICPPvoIAKPRyPz583nppZduuWxkZCQfffQRDRs21NcHYGtrS6dOnWjdujVeXl4cOXKEGTNm0LBhQ3bt2kXVqlXztZ1CiJzy3TCeZk7DotlQyb8C7nYu/H5sCwmphalVviRYQNMUKalmomPMnLtyBaV8aVyyPEm2F3BxteDpls7ps9dI5irx0RauhIdha2yIo0MSFyKiqFGiHAZNAxQ3xlUHTcucEkIIIYQQ4pHIbNzO9Morr7Bw4UI2btxIpUqVrBrFY2JiSEtLIzg4mM2bNxMTE4Orq6s+pNqGDRuoXLkyNjY2OdazZs0aXF1deeqpp4iIiNDTq1evjrOzM1u3br2rBursF+INGzZkxYoVD3y9QgghxIN0+fJlDhw4wKhRo/Sb6gCVKlXiqaeeYuPGjfdU/k8//ZSvfEFBQfq/k5KSsLOzy5HH3t5en58Xg8HAwIEDmTp1Kq+//jr9+vUjNjaWUaNGkZqaarV8t27dmDhxIv369WPBggWUKlWKH3/8kYULF1rlu5MyhRBCiIfhSYvfkNEIXqJECVq0aMGzzz6Lvb09q1at4pVXXsHPz48OHTrkupzFYqF79+5ER0czb948q3n16tWjXr16+nS7du3o3LkzlSpV4vXXX2fTpk352k4hRE75bhg/fP4aZ679A5rC09kH78LBBBWsgDk5CaO9IzHJ8ew+dImGVRoRdP0c206G8U/CJTwtMbjaOnI4/HscjX5U8KnA36nHMCUGgo0DHk4FiEtJITXVjL2dDQoLKA0NsAAGaRoXQgghhBCPUKlSpaymS5QogcFg0Id427lzJ+PGjeP3338nMTHRKm9mw3hwcDCdOnViwoQJzJo1i5CQEDp06EC3bt30C/CTJ08SExODj49PrvUIDw+/47rb29vn6DHv7u5u9e7wB7FeIYQQ4kE7d+4cAGXKlMkxr1y5cmzevJmEhAScnJzyVV72p8SaNWt2x3VycHCwGpo1U3Jysj7/ViZOnEhERATTpk1jypQpADRv3pwXXniBxYsX4+zsDICfnx/r16+nZ8+eNG/eHAAXFxfmzZtH79699Xx3UqYQQgjxMDyJ8XvKlCnMmTOHkydP6nG1S5cuNG7cmMGDB9OmTRtMppxNca+88gqbNm3i008/pXLlyretZ8mSJWnfvj3ffPMNZrMZo9GYn80TQmST74bxCzGHiYu/RFhYNEYuUCawKSUL2eNgq2HWwM7GQGRcPDGJZgoWDqSFkw8//rWdE1ExNK9eDr90N9y9AlDGdMoTT1jMKbwLVMbexoS3vStXki5Q2C4AGwygaRlPoWMGTb7cQgghhBDi8ZH1wvv06dM0bdqUsmXL8v7771O0aFFsbW3ZuHEjs2bNwmKx6Mt89dVX7N69m++++47NmzfTr18/Zs6cye7du3F2dsZiseDj48PKlStzXW9+h4TLKj8Xyg9ivUIIIcTj5HZPfCUmJup5MuX33duurq76DfOCBQuydetWlFJWvxcuX74MQKFChW5Zlq2tLR999BHvvvsuJ06cwNfXl9KlS9OtWzcMBgMlS5bU8zZq1IgzZ85w8OBBEhISqFy5sj7Ua+nSpe+qTCGEEOJx8m+J3wsXLqRJkyY5Opu1a9eO//3vf5w9ezZHvJ0wYQILFy5kypQp9OzZM191BihatCipqakkJCTg4uKS7+WEEDflu2H89PkdeLp5oWw00lITuRp5hvj4wjh62oDFwLnYw6RbIrE1wLW4i/x0JJRaxf1YtfUs5y5E4uv/B6kxdpQrVhpnVYGImGvsu7KVqt6NwKQRdvUM7nYFcXNwyjgBGSygDNz+gXGV5d/yZLkQQgghhLi/Tp48SWBgoD596tQpLBYLAQEBfPfdd6SkpLB+/XqKFSum59m6dWuuZdWpU4c6derw7rvv8vnnn9O9e3e++OIL+vfvT4kSJdiyZQv169e/bY/0++lRrVcIIYS4F/7+/gAcP348x7xjx47h5eWlP22WNW/RokWt8iYmJnLhwgX9yetMWd/zeStZ31FapUoVPvroI44ePUr58uX1PH/88Yc+Pz98fX3x9fUFwGw2s23bNmrXrp3jhrvRaLQqc8uWLUDuT8vlt0whhBDiQXoS4/fVq1cxm8050tPS0gBIT0+3Sl+wYAHjx4/ntddeY/To0fmqb6YzZ85gb28v8VuIe2DIb8aIqARiY3xwdyxOfEoaoaEn2PH3EZLSUkhOTWL3P8eJjI3lz3P7OXZpG5dCD/HbmdPYOqTj7Wvmz4ORXL4egcVswL6AC03KPENBu0COXD1DWOIJ3Jy8KODghEY6BgMolbORWyll9ZfRKJ75J4QQQgghxP23YMECq+nMd3+1atVKfyI747dphpiYGJYuXWq1TFRUlFUeuHlxnTlkW5cuXTCbzbzzzjs56pCenk50dPQ9bUdeHtV6hRBCiHtRsGBBqlSpwvLly61i1aFDh/jxxx9p3bq1nta0aVNsbW1ZtGiRPppLpiVLlpCenk6rVq2s0n/66ad8/bVo0UJfpn379tjY2Ojv+oaM3wiLFy+mcOHCVu8KvXz5MseOHdNvmudlxowZXL58meHDh98y37Vr15g6dSqVKlW67TCy+S1TCCGEuN+exPhdunRpfvrpJ65fv66nmc1mvvzySwoUKECJEiX09NWrVzN06FC6d+/O+++/n+d+unbtWo60v//+m/Xr19O8eXMMhnw37Qkhssn3E+NJSU6EX3Wn+1MN+OmveOKiUjh9Zic/OZyhTMlSBHo3xNknhX+u/khh76I8G9yUoxcPcMms2Lr3LxzSC3LZnMilQikE+tpjMaRT0qc0kVHx2DrZYjKAwWIBkwWL0jBgwEIa2o0qZr+ReDMtc3gLeRe5EEIIIYS4/0JDQ2nXrh0tW7bk999/57PPPqNbt25UrlwZe3t7bG1tadu2LQMHDiQ+Pp4PP/wQHx8ffdg1gOXLl7Nw4UKeeeYZSpQoQVxcHB9++CEuLi76hX9wcDADBw7kvffe48CBAzRv3hwbGxtOnjzJmjVrmDNnDp07d77v2/eo1iuEEELcq+nTp9OqVSvq1q3LCy+8QFJSEvPmzcPV1ZXx48fr+Xx8fHj77bd58803adSoEe3atcPR0ZFdu3axatUqmjdvTtu2ba3Kvpt3lBYpUoTXXnuN6dOnk5aWRs2aNVm3bh3bt29n5cqVVq84ef3111m+fDmhoaEEBAQA8Nlnn/H111/TqFEjnJ2d2bJlC19++SX9+/enU6dOVusKDg6mbt26lCxZkitXrrBkyRLi4+PZsGGD1c3yOylTCCGEeBietPg9ZswYevToQe3atRkwYAAODg6sWrWKffv2MWnSJGxsbADYs2cPvXr1wtPTk6ZNm+Z4nVm9evUoXrw4AM899xwODg7Uq1cPHx8fjhw5wpIlS3B0dGTKlCl3vI1CiJvy3TDuZONCQvLfrPz1OsnRbtQo58rBsxs4cDies1dsaVOvMcejN+JoF0GS+QJH4zRORZzClUCa16vBN9u+xsM2lkvxERTzKYymmbAxaLg4OWEyaWiamZS0ZIwGO4wGC8pizqiedrMBXAGojEZwDQ2lZTSFZ8zXQFM3msalgVwIIYQQQtwfq1ev5u2332bMmDGYTCaGDBnC9OnTAShTpgxfffUVb775JiNGjMDPz4+XX34Zb29v+vXrp5cRHBzMnj17+OKLL7h69Squrq7UqlWLlStXWg3TvnjxYqpXr84HH3zAG2+8gclkIiAggB49elC/fv0Hto2Par1CCCHEvWjWrBmbNm1i3LhxvP3229jY2BAcHMzUqVOt4ivA2LFjCQgIYP78+UycOJH09HQCAwOZMGECo0ePvm9PXk2ZMgV3d3c++OADli1bRqlSpfROdbdTunRpIiMjeeedd0hKSqJMmTIsXryYAQMG5MhbvXp11qxZQ1hYGC4uLjz11FO88847+g31uylTCCGEeBietPjdvXt3vLy8eO+995g+fTqxsbF6vB04cKCe78iRI6SmpnLt2jWr+wWZli5dqsfxDh06sHLlSt5//31iY2Px9vamY8eOjBs3Lsf7yoUQd0ZTuT2KnYv3VmyneCEXTl08TiH3+jzf0otPd07jcuRVrse4EuhXHgjHx64IVcsX5eeD8/jneBplA8tRvuTzHD+wm+ux5wkIrEXNMsWxaIn4OLtjsovFkuyBt4s36cqC0WSLRaVjQKFhwqAZUCjSScGECYsyoZQZk8WA2WRBQ0OzKDSDIaNtHA1pGBdCCCGEEEIIIYQQQgghhBBCCJEp391pvF2L0q5ReQa0b4KHVzzKYkspj1ZU8G1IUe8Ezp/6mXKuZYhJjeWHHf/gaaqCq5MN5y6d4tyhWLq2aI6zZyox8WdQaXDo6iFOXgzlZMyfXIw/iwUNpcxgTsKozCSnX8CiksECKIVRGcGSMcC6AQsWLRWUQlOgaVrGm8blVeNCCCGEEEIIIYQQQgghhBBCCCGyyXfDuI0lnPRUcHdypbCrHUkqidolK+DpG8jF8DCKFtFIcviVIt6XKFTkEleuFKVz9X7UDyrOubTPOHYtjuAyT1PO15XiBQtSyNUWe5uiBLm2xx0/Ui1paEYD8alRJKSmYWvwxoANypCWUVEzGQ+CW0DTDMQmRRCfkoQZhdIsN94wrknjuBBCCCGEEEIIIYQQQgghhBBCCCv5bhhPMpznr7NhJKWkUKyQNwXsDJjsjdQoFsSw1hPp32Iq/m5N2X15L9v/Cic1JZkEYyqNK79IpRL2bN3/ASZnDSf/65jsoWqRulTw98bGxoZDUXuJTkzAhC1GkxMp6WYMFjvMZjOpqemkmzXStHRiLVe5nnaJdIsZg40LYdePE58SDcoIWECZH9yeEkIIIYQQQgghhBBCCCGEEEII8a9kym/GS+cvYo8fxdzcKObngEVpGC0Ko2bCoYCBC2kn8fB0oUqxQuy+ZCQi5iq/HT7M1ehLaClNqFjUhL1WkED3ZzCZbShgWwgNSLck4+bkxF/X1lPJEIKvfSEc7CE5KQFbBwdMyoIijfjEGC6nbgGTG87GpjjZOuDlVhBzmhllY0FpFtAy3i2ulELT5D3jQgghhBBCCCGEEEIIIYQQQggh7qBh/MLVKGpU8CE+VSMxLZWjV2Io7eOOg42JBOMpbMx2pJrO06BEL+IjDhF9qRA1S/lgtJjwKumDi70jHk4OGI1gwZbohCgK2DlgsrHF074wtmYzV5KPEJ5yGDvHFFLNCQSkNiHVeBHb9NLYGl3xcWzCwbifsLE9SqBWCQ9HL7AY0DQDmgZKM6BljKkuhBBCCCGEEEIIIYQQQgghhBBCAHfQMF7QsxA//PkZdZJrcjY2gctRGr7OIdi5uJEQ58rphPP4ODjz48lvsItvx3MtauDjZktyaiRf7NpOndKN8SigSFPpJKXGEafOYzAXwdXkha9bEfwsAaQTS3jqJYxph0mynOBEUiSmlEC87Yrh5WhLATt33BLKcS0iEf+CYFQm0DQ0g4ZSBjQ0aRQXQgghhBBCCCGEEEIIIYQQQghhJd8N414e1Qny8eCXA8uodK0C7Zv04XzkRfad34a/XRPq+lTBqBlwCrDluu91vFw10iyp2Dq60yyoBudiT3Ex0R5IIz1FgeaAja0JgzLj4eBGuqaRnJBAkjkGd0MFyhlaciXmIIGeDYlTiUQkJlLUxhM/Y3HSXcBoNIICTdNyDJ0uw6gLIYQQQgghhBBCCCGEEEIIIYTIlO+G8SOX1nMpzokqpbpw+soa/g7dTZ0KjTkSs4wLl8LpE9CDI2H7uJTyB0XcQohNSaSAfQGuxB1H2RpIM19gW9jnVPbpRXH7ZhgN6djb2BGXnkRMSjg+TsVI15KISzqOt01bHGzdKORVhRQjuNq4U8DGjMEAaYYk4tNTUHhiyNYALu8WF0IIIazFRp5H0wz6tKZpGbHSAKChYSBzuJXsMVTTjFbLZXczLeM9JhnTBtSNlNzyZnZoyy0dcs7LjO2Z+XJbNuu/s86/MSfLv1Uuy2XNZ12H3LZZ5bKO7Ou+s856CoUFlKaPfKNQGf+2+hPiCaMsKM0MCiwWE2ZLPFq6wmTvfGOeAaWlY05OB82C0WSPOS0JlZ7E16tXkmJO5rnn+3H2xEGWLf2Eq9ej+N//RmDSDNgZo7maYMe7E94jKSGZESP6UaVKMJu3bGLRog8xqBSat2xIwYJl8XO3p36jp7FxsOH114fz8ivDKFOuPGlxcaSkJrP00w+5cPoUg4a+xskzZ2kc3ASDnRtR18Jw9yqInaMrmgKVnIjBzo50lYrJYiIxJYqLJ/bg5luGo4d/ZcrUDygfVAp3F1+at2pO735DaRBci2rlS/LUU60p7F+Ww/t/xdPbj/fnzGb9ui1ExsXj5eaOm4s9rVs3Jzk1jmIBZSjs401hv6LM/2AOffu/yPnjJ3j2+V7YOLsQFxtHr27P8cf+I9iaTFSpUI6FC2dz5vRhvv5qE97e9jSoVZfqwS3xcPPDaLLBrKXz+/af8XBxIKBkKewdfUDLOD9qgMo4MVmdz/TzoALQuHrtPAN6deP92fMJLF0BzWDInInFrEhIiOLZ9p3Zsn0X5DhPZzAZDJgtYGvSSFeKVo1r8sW6n7C1tUEzKPbt/Z2mTVqRmJiqn7wzzpYKNI3ixfxp2qQhDnYGRowaS8HCRbFgzoglFoiKvErvPr35acsuUGYsKJRFI+NdXEY0ZcDeUaN3tw68O/V9nBxdADAYDLnW13BjP1j0aYs+L3P/KKWwdXC78+/HDRLDJYYL8ViSGC4xPBuJ4dYkfkv8FuKxJPFb4nc2/+X4ne+G8bT46xgNDoTHH8BoKkBavB9JaQZq+7zAxwdnsOzYJs6HgpvRkWuunhDojZuNG2fTTpISn04BrRIVHF7keuQZ4tX3JKcEULd4KU7FryEhxYKXw/NEpJ/H26UGF2NO4eTjRIxlM8nR5fD3LkdyShp2JlscTGAyFQA0zOaMnZy5o6RRXAghhLCW6wV5JnXjclrLvsydxtPM/IabU9qtL25vpmde0N6oULY65PojMBd5z1N5dpzTtKy/DXPmya3MvGuQWWb+9p1etvXHgXbjf0I86ZSmoZlNWAwKDTCaHLAYFBZNYdSMqHQzmmYk6vSfGJ1d8SxcitMnD+DrV5h2Xfth1lKJuhrBwT2/8MrwNzDaOOHuWgDNZMPpozuZPWcmCUkxvPxCR86eOYuPTwCxiTFcDL9G45qV6T/wVTSDAwlRZzl1/izhV04xYtQYfNw92LJhFQcPHUQzpxBxPZZvN+8ipGEILbr1x17ZEhkRxo6NX9Dy2YHYOdhjNhgx2jpiwUx6cgxpCanYufnyx95QPl/9Lqlp6Rw/dQ6L2Y7yZRRR4edp26I2hw6HYa+SaduhMw5OBahSuyUYLXh4eRIZG4/R1oaYuHg6d2xJowYNcXZVFA6oxZ7t35OcFsngl/qwf/9BHJ3sGTpoABGJybw6qA9lSpYiLOwiypyOr5cHtraubNj8C+XKB/FUq+YUL14OW3t7FBbMKh2LBof+3EWFClUoV7kOFsuNG4OaZnWOVCq3c5xCaQpNWXBzcMDVxQMLZkwYM6/XwajhVMANNze3mzcfczu/KgNgRlkUBg2i4xJQygyaEQ0bzpw5TVJyOhhAWcCgGVGkgzICivPnz4NK4Y23p+Pu4YVCw2gwZqxLQUJCIonxSWQGv8waZGyRBZPJRMniRXhhwACcndzRtNzP+OrGMhYy9ocho/K55r3X61OJ4RLDhXgcSQyXGJ7jmJAYnm1Zid8Sv4V4/Ej8lvid45j4D8fvfDeMp6bH4uLij6dHMuGxNhy6uJYILYKW1epSrFBJdmzZTsWCrmD2JSE6nsuO24n3CCAx0pmSherg5axhMLqSEmHEnGAhwMmTsPjjXL9uobxfE64nRBAVE02AcxWK+zhhtHXiWHgKcTFnUAZ7ktKicbKvgRE7HG0dyPjIbm6sPC0uhBDiYbrdBefjJucFuXbjgj33nuqZfRRz6ymds1f7zYvr7L3Rs7Peb/nfd3n1EM+Pmxf4ZFlnzm3L+MF5izrcomzr9dy6bje3RWX7IZfbZ/DvOL6EuFMW0C/QNEPGd8Fg0DCma6Qb08BkIjXyAo7FipOamMzp03tJT0onLSWelLh4jpw6SLmg2rTq9BJOnoWxqIyewjGR15jx/hIa1g2mZdMm+ASUY/ybrzFt9osULupFelIyDZo0ITU6imJlSmDxK8zZDauws7PFt2ARoqKisChb2jz9LDZ2Zr7+8luS4uHjld+ibG25cOEiwfWa4F+qHAoTJmV/48JRw6xpmOw9uHj6D8798T0bf/yOA4dCSUmORymNZzq2YMEHn7Fj5z48vdxo1bQB/qX8WbvsAwa9Ph1sbNGwYcCLQzl96hQ7fz/IlUvhbP99H9179SQ9IZHXh/WnQeMWdHj2JSCdkgFB2LsVpFzZcmz7aRtBQTVo1Lg91y6fITL6AuaERCzmGBo3rMeJf/7C19sHGwcnzJoFEyY0DFhQdO3xHDY2Lihs0DSVcS5UWT4tTbM6Cd4812ugNFS6olbtcji7uWDQ7G6cvTKuni1KYcBA4ULeGDSw5BEiFCrLKVrj+OlzpCfHY2fngzIrft36GyhDRuzSzChlAQxoRgtGzUifns8yfeYsHJ1dUZhBUyiLEdCwkMaZ0yc5G3oeUFj0G7EGlDJjNBpApVG3RnXKl6+qb3xesf7mjdWMi/KMqcyb4EqPJbeKh3dCYrjEcCEeJxLDJYZnJzE8dxK/JX4L8TiR+C3xO7v/cvzOd8N4IrYY3S38duQbmpTqhm/Ng6z6bj6hV45yOuYXAnxt8SrogpubD+U9OnMpcReJURewpBfjUtQ5Cjh4cvTsadzsS5CiznA5KRpjehSxkU5ofs5ci75KZJwNRZ0K4GjnSbqWirdNCIU8TRhsUolOv0J8aiIe9i4YDDYopTAYDBgMBmkUF4LsX/qbZ9KMwS3yPiHId+fxljUY3O2FmXVv38xElesVhtV6MiNy9nyZFzZZe9uq3Op480Ior7pb9xbOLUNmxfOYl49dctt15EveFclt225s+S2/ezkXyqOiN9Lv9rua97Fz84L8FkvrZeRdrqb/ZV1XbrE5+7BsuW/uret0L/sht3pn3+15HatWR/Yt90fOsvLqcX/zqMp68Z21bDk/iyeXAQUGhUKhlOHGBZwBjGbAiMFiIS4+HFt7b04c+IXToRcJLFeNQK/q/L17K3OnzMS3aCDP9+5HtZpOnD91gIAytbkafo6iBV3o2PlZnN3c+P3HL3A2WmgRXBOTbTKVgwJwsU/HYGuHppkxp6ZRvUZdtv3yKzOmTSfNbCEq4irFip4h+vpldu74i1p1StO/X3dWrV6Di7sPbs57OH/qGIUCgnD18CEdCxYNbDWN9OQY7J0cuB5v5NDRM7zYpx2frlxPSmo6O7ZvJy4pETtXVzp07czR/QcoUqIUHoWKk5Ich43RHWVQmC0aPp4+VK5ciWvXtnL48GkOHzpJgzolmTR1Flu2rCcx/jqXzh7HzcOLAu7uVK3VmIK+BfEtXJw0ow0Fi1fFPtwJW1tHLp05h7u9Rqfu3XBwLoDBojAaMi4DNWXBZFS4eJe98aSMAv0pJ0uWTyzjvJn7RaqZ5MQoatcNwdbBGZQZpRkybv7eyKssGnXq1GDhR59hMZvJTeZFuTIYURaIS0gmOiIcZ1c/IJVLYWFomRf1KuPY0bSMY6dYUR969+2Jo5MLCvRrRDQwWyxoBo3rEZeJi4/PiEMYM27kKEvGjSE07OzsqF+vFkaTI5pmyfMmbfafH9njQ/anr+6FxHDr5SSGC/F4kBguMTw7ieHZ1iPx22o5id9CPB4kfkv8zu6/HL/z3TBeomAVdu77Cj+7hly/foi//96Bp0Nn2pRqww+HruDiFUpUtJHkxIJEXT5NrfINuRq3m6i4YyRFpOHjWIHUBDtS1F/sO3oAjwIlaN6gMQ72pzh6cQcezmUo413zxnsONLCAKc0Re2cD12OuE+BUHxuDM0aTzY1tzBhK4GZgBbCQdbgaIf6TFBm9c1BoKuPkaTGkoymj1Q/i7P8v7szdNFLfj/2c/fPK7XPMDEL6uTFLXTNPmZrKHNrK+pypX1BxI4++KguZ71vKKN66TGWxZAmAN+pDbm29mevN6CuGulGeZsyxDVYXOXpbfdZjFzTLjfVpN7bWklHnm/tIZVl/zv2U/ULKujd3xtA0Cg2DXo2bP0YsgEGpjKGIMvMqMGgGlCXjM7BoipujwCh9uYx9acn4jgIZHRWMaMpy4wIty7YCFhTGe7hAy37sGQya1XryynerY/bmDzNDjjR1i3Jv7v/blZv/utxObhfFN9NyKTfrgZuPnhW376Wusvw367R1uTcXl3OyePJpyoDlxgkyM9YoLChlwGgBjAr3whXRzGYq1mqFvfNRBg8dwutvvo6LgxNxqfEc3Po7Xt4eBAaWYtG8OTRu3AQ/H0d6932RqAuHmTXpUxo0aUyNOnVI0xQuzg7Y2TpQrnQ5PIpWzrggVSkcP3eed2fM4fylqzzTsRWnj5zix82/UKVOEIdOnMIr2pdlK76kS+dONG/ZBqPRROz1CHz8iqI0MyalkZqWTmLiNX7b9jMR0VHs/n0P9iY7fvhxO0kJSWBj4Jef92Dr5EBCbCxRVyJo37ELkZdO0frZXlw/vx/v4rVxcHDGy90ZZ2d7ftu+B4ONAVLSCDt3jJSqARQvX4ZnO/fmz1/XYe/khrdPMZTBBhsHZ4qUqYVRM6NpJjRLOl5eJUlSSZSuWhAv/yLY2jjg4ORCOmZMCgwGSFcaRqVh0RQmzYxFGTHosdGAfmGe7TSYdShKDQOxUdcw2tiiNA2DGTAasGDBgAWLAgNGAksWRzMa0CyWXGNv5pnPYDBiUYq0NDOnTxylWKkqxERd4/TJU1iUGb1XuGYgY+BLA/5FilCwUDHMKEyaAZQx4+YA5hu/SzQir4eTmpJitTmZp3iLUjg5OFKrRnWrU7DVbyusf4dYpWfbL9nn3wuJ4RLDhXjcSAyXGK4fCxLD8yTxW+K3EI8bid8Sv/VjQeJ3/hvGHdI0SgXWJyXJQKKHkUuHnQn0iSXUvB9XH/j7ciRuyd542R3C1S2Gi2GK85FxXDmfSGCps+y/dAgbi4FT4efxcmpKXPJxtv29hsBiFSlfMJhT14/gZOtGmiWFy3EGHE1OeLo6cyL6OPa2MXg6B+FossViTgPNREpqPBaLwtHBGU0z3tgVmQ0s+d0qIZ4sSikUFgwYwKKhDAo0C1iMaAbrk4g0hj/+sp7Is570s57wc/s8bzb2ZjR8K2W5kZYZWDMae3N2JLrRaJ1lQBIt4+oKpbSMBmDI6CamWcdng2YAdeN9KHp9br5XKrPnlnaj0dpi1jAYDJmt2VY9nLNuQ9aGa6s0sjTsa5DZiw5Ns4oBN6+rcg+iufUuzn6xlvnct1IKzXCjEVxpGLR0LJqGZjGgDOlYVEZItSiV8YPmRqO8dqNuGZ9F5k8JReacjP1suPHDwZAlsN/83DKHOrpbmpZ1+YzPM7fybnaWyDkz5zlDy5Gmbvxl/srJeoxmXe62dc1F/jrx6HvPqqycPcm129ZD/2wg+2/RfLPqoJG5d/SkrHWQ87H4b7KKGerG+c+gwGxBaaAMJozKhmtXjxAZE4GPjysGi4UqVaug0kwkpyXz1TebKFOhFKHnr9LUYEfZ6i35+cev+eyTlRw7c5mDp69w+uQlouLjcXOyp2/fThw/dAI/3z04ODjy/fdfc/V6LFGxcdjZaqz5/DtM9vYE+Lly7WIkM6aMxdHBgW83/cyhAwd4+unOXL1yDld3D+wcHElPiCM6JpqIyIusWL6Itet3EXY5giKFfElNTibdnI7RxpbktBRQULl8GZ59rjXLV66jasUAjPZO2Ns5cPLiebwDa2PRNE4c/YtNG3/G3t7IgN69OBZ6gSJFinMtLJSiZevh4etPWGQCSRejqf/Us2BOR2EhNSkRk6MDlpQkNDtbYqIvEnv+BEUrBOPhWeTGEwEapiznb+ONz8KIhlKGHGcjTTNk/Ga4cQ672dcr6w1WxeF/DmN0dKVybQuaMWNoNIMGymLEqKUDFvwKFcXL1YbL18xknl2zxlxN0zAYFWhmbExGzOmw5+/DNGmjOHvhHGGXo9EMCovZggFTxk0cQNMslCweiIenLyYto6O0xZKGZsiouyXdTHqamYOHjpOcZgBNoVRGZ2yl3fxdUa6kL4FBNTEYFAaLIcvW5vw9llVm7Mv6qypzv9zRyDF5kBguMVyIx5HEcInhEsNvTeK3xG8hHkcSvyV+S/zOkO+G8WsRiTjapHIhfC8nTl3D368F9Uo3Z8Pej0lNseO5kEH8tuscvr7OJKbu5kpsPCajN+4FDVyJ+4sCiU6kGaJJjPfD39eDNKMjYefPolK8cCjjxomIU/g6VMLd253Nf3+Jh0Nl6pWpSDWfSmiGjF4LSgODZoOyaJhMJpTlRiOFXksJauK/x+rkoHHjhAsWUgETymLAeKP3V27L3I8G8rx6l94vd1P+rXoHPcpOAdn3/e16Md1sENcyF9IvdjIvUjLf6aJpBpTFol8IKaX0xnDrobUMOeqS8W/LjeBr3bNWWW42qN+IflhURsO0waDdON4yXm+ButFBQ914KvzGv2+uW2W0tmtGzEplPF2tzBgMJjLP4dmXyWtoLMON7UXL+KlgURaM2s3Xa1hu7AtA/3fWcg2GjHe6ZD7RnXGdmtmMjT4vc99wo+zMPWOxaKAZM7bfrKGUGc1ogIy+eTd60GF1VacBFmVG0xTKooExo05GZcxcox7IDQbIfHfLfbivDnrjuob1T4fs34mcF9K5fWc0vSzrY1nPm6UTgvXymR0Fsl3Q59FxJ789/W7XCz73nuCa1by81nSrc0b+zye5lZ71x2jmtPyWEf8R+r1B63NGugKDUUNZwEbLGHnDzsmVQ3/tomXTEBqGNCE1IZrhrw9n/MRpnDx5iZNnwijmX5Kde36lYq367PvzAJci47h6LZrwqGhs7U2gDBQqXBhlsGPXn38xZuRwCvqXp3CpCuz4ZRMHj4YSbbZg6wAWcypVa1QhJjqOhk3aEFAigDade/HVyoXs+f1Hln+yjEL+xahQoSIurk4kJySwaeP3REUnYG/rhMkQSVpaKgmJSbgUcGDEyBdZ8+VmQk+dYcjgF9h/7ChtWwSz669/qFG2BrY2NhQrUxuTgxNmixlXNz9eGPgCly6cZcirr7Fty/eUKVOWijUa3egErOjVZxiJSRFw411kx/b9yrWw09Rp0omIK6fxDahEamIMdu6FMBpNWG6MsGLdKc66M5nVx5O1w13285eyPqcrFIePHqNp6w43OoEpDAYjGTcib3YUc3f3plDhwly+dpLs50RNy4jVKiPw6iPJhYaew5yexv4Du0lLM2fEToxYSAcMGIzgYO9I3Xq1cHYugIblxj4yZsR+gwGDBikp8ZwOPQ1YsFiyDCOnNDRDxrm3StUKGI22mM0paFrm7xLrznm57adb/ua8b+d0ieE3/pU11WqexHAhHiKJ4RLDrdYnMTxvEr9v/CtrqtU8id9CPEQSvyV+W63vvx2/890w3qpxYf65FkXi2XjsnDzBzkL5Mn6UKTn0/+z9d7Rt2VneCf9mWmvtdNI9N1VSlUqpSqEUkFBAiGwkoMEm2IC7jQ3d2J97fO7Gof21GQ7Ybtp2ezjQ9LCHe3i4we2AAQcM2EaAASEUEIollSrHWzedsOMKM7zfH3Ofc89NpVulKqmE9jNG1d1nh7Xmmmut+cx3vc98Xv7Dr/wqn31owK0vu4fOf5De6ASme4wufYgwHrI5OEmSBbO64ASn2Rqcp6vg7NOWrttmf+5wkxELP+O9Dz2A9a8nFXP292ccP76JVhEtBsUyAWQSTvdzPy6T4yus8MXAC50QfrY4sE6Pkus4qCQkgUXscBiKoliuQoUrJ+XXwvWsKK43AF0v6Xut/rnewHa9zw7ef7a2GNfbzrVwI4nqzwfXS/A+E44erywT00eTvcYsLUzUkhZVThDrI6u+0zIJrMjElJIsrwE5kjzOgdKy0syShvL+crJds8zXLv8GlCKlHFwprQkpotRy9fhyv0nSMrm7DMKSQiuDSEKIxBiQpOjaBc5pfAx03lNVFc7YS6vKlVomsIUYPQCh83ifX/cGQ4zRhJiIMaK1ylZlBwlppQgh4r1Ha43WmrZtcwI95vcFoSjKnKg2GmscXRcoiwLthBgSKSkWbUOMHmstBE/bzVlMZkQx9PoDfAyUZUlhCwpt0YUBpdDasLe3hzIwGg2JPmCsoWlbBr0RZVniQ4MzNp9DvZxQoJAoVIP+c7rurriiLpsgHL2+ns04lr97JHDOb173+9daiX/leHG9QPxG23Xl/XQpwD985+inz2pbV+JZj/lHhBGog+vyyvPw4uCRFVb4YsNwpCRGSnT1lNmZ+/meP/rf0h+dphysYVzind/4Hfz52Zh/+s/+Nd/7fT/AP/qH/ye/9Mu/xcXx/86v/tJ/IoTE/+d/+F7mbc2/+9n/gq00a5sVZ586x2/+9if5n39EUw7WOHnTKX7t197Luad3UKai6Bl++I//cX7gT/ww/+anf4Ku2UfTY/fpx/il//BrvOPr5sxa4Z/805+lUD/Drbec4kf/0v/E0+em3HrLzdz96pdxcfd2vud7f4j/4+/8Pe79xIP84T/8J7DFJv/sn/4Ue9Mpv/s7H2Bnt+Z1r30Zb/uGb0QFYePELWhjaSY7/My//Bf80J/+79l5+gHWNk7z9e/+LpwZkDAYZUAU2niGa6eJCZCGqBtueuWbMYMRWze/AmN7nDh9NyydtbSGow9Snz2W49RSILbU6SECT595inMX93jzW99OAqzWy/kFqGXZlIRQVEM2trZR6kHgUqkTEcFoA2YpnkMIIYAkPvaxT3Hx4jl+76OfoAsdShlQwqEJTkqsrw1481d+5fLYlg8D0IcN1ErRNBPuu++BQ/HfoRBOHYz5wuvf8Pojj0ZvPAC/ikvlQGL3fJcrWnH41a8/97auxIrDV1jhhcOKw1ccvuLwa2HF31e//tzbuhIr/l5hhRcOK/5e8feXI3/fcGLcbUKviwgOtTsn6c/wqQv/iCeCY1fBZqMZFT2SP8762q2cmbyP2NzG6c1XsDa8jSD7bFY9pJ7z4PR+ztXnMDrRl5Jz5x5l56n7uc8N2Z0n3njnnWyf3KBJuaaqSoDOygOtFCR9RQ3ZqztlhRWeD9zoxPCFSpA/24mpcCAgUihxhBjZX8x56MwF7rn99KE651oq0Rttx418/8rv3Giy+Ua3+0KvTH+ht3et5P4znhO1JA59KaA6EDjEGJbJ5USIEWsLjM2J1RQDKUVEIGXWBjI5dZ1HFDRNgzGGGHP9kSSJlAStcg0spYS2a1FKU5UVXd0QYyQlIcbAcDQiKSiLgqqs8vkhJ+2n8wWLxYKUBFeWWGuz9YpSNG0NRIrCErpA6CIiEVcUtF2HLNvgXIHShrIqKQtHUZaIRBaLBQqFM4Z5vSBKIIZA27Rok6nNOXcoANBaU9ctXdcRQ8Auk87j8T7iPcoahmtrDIdDBIghJ9zHezO0dQzXe4Suo2s9++Mpk/0ZW8cr1qoh43HDxqjAiqfpWigslBaRwHQ6RwxYYygKR2lhNpvyxMULxBiwCpquY7S5Sb93ksn4DP2Bo+r1MaYgpYQGFrMZt99513O6Dg/jvUsvrrrmDoLig0nUta7XK/8+GkgKV09fri1iee737vMvXLn2Pfe8S2MOJrBH/r7MAWKFFVa4DAoNKpISaDRtOyV0c7aOvxTpbWKJWLUOpuSb3vN9fM03/kEeePATfOgDv8OZ80/xcz/3FCePH0fFyCc+cz9/52//OI88eo4f+mN/lF//tffy0//6P7I5GjHolxgNk4sTfvcjn8UnoSoCt2ye5patE2xurvG2t70N3Zzjwtn7iSbxx/777+VnfvbnePLMGW6/dYtzZ3Z4w1u+khO33sn5C+f4wO99ih/8Y9/J3/wbP8E/+Sf/Fw88cB9N1/C///hfpdBC5Vrm+0/xvX/o2/jYpz7FPXffw4mbbuex+/4rlRlw4s7X8P/7s3+G3Z09+tVx2JhTuAqzdXLpLJJDySSCsrkEh8GiKXjtPd+CaI3WgqkKlIYoJj/kkGs/+Hz286mD78syPhdSEh6479O8+a1vp9cbHjqfKKWOMIQGiYBhfWP9cN+Xz3UkC+/IwjprHCjFdL7gs/d9kg998N48n0mRHOxaRCIJxekT69x868tARUQcqGwTp3X+vtGOhx++jzNP75OSXj4cVXCgbEdzbKPHa1/3pmVr1eXHegOq9cNvHgbl6XnhrRWHX3eLl/214vAVVnhxYMXhKw5fcfiyS1b8fb0tXvbXir9XWOHFgRV/r/j7y5G/bzgx/pvvfYA77rqHO06dYL97hLff84f4iptv56Mf+hcMmxPsx0/Rm51gsOl44ukd9saOQXMM/bJtdrpE1Ce56dgWvWrKA0/NOKErNm7d5sLug0z2GnplxSTcz95ey0OPBc7UkfXq5dy6tY7VGsnZcRIKow4SY+lIC69QCfw+xfXUeDfy/Wf73WdvnXPtfR2ck2dSd1z5+yu/c0OfXbpfbqy9V08h8wauePvwVryyDepSu5/dKuYbbOgVuPrcc5nK57BJAq0PPHXhPI+eucD+XstNJ09TliWX1EV5sDg8iGWTDlp26bzI4cAKR/vispYt23ONFeKy7OXDQ1Zkb+rrH+flip8r93Xl9XBpbfMyTLh0Xp/LzFot/3eta/UZNvls1LRXBkLXGrOuPNchBrquowshr/MX8F2bV0j7jraukZTrdLddoKx6CGC1Yr6o0caiVKKZz+j3C0iR1kfOnN8lRE+v6gOKyXQGaFIUyqLAOo0xeYf9XsWg30cJxM5T1zV13SJa46qCsiypehVKhOFgwHQyY7ao2R/v431EG4PWlrZrEYR64SmLgl7fMewX9AtHWzeM1tdo2paNjQ1C55nOdokoer2Kpqmx1qIUlFVJ0zSUZcF0OmV35wLz2ZzNzU1EG6wxGGNpmoZer8diMWdeLyhcwaDfp/WB4D0qJiQGisIRfct8lljUC+rFAqMVTS3s7E8oKsP6aABdYrw/J4knzhOTtiV1kZ0LCd12LHwHvR7Hb72VwWBAtWznZD4ltA2p8+xc2EGiEAzQepKCWTNnrd/j7FOPYActZTVgc/M4jz36BGvDAaNB/zknxi8F4pcr1T/X9XlwjV7z3r5swvLM27teUP9MfHa9CeMzjbVHhp2DrRxpK0deX/9+e94D8qOtOGzfgVvHYWWnq9q0wgpfzkiAPqL6Xds8Re9t34JJglIJJYpoRyz2d3jfL/0UX/E1f4h/9o//GevrI45vb7O3t8OZs+f51nd/Hd/5nndgbZ83v/blvO0d72K0PuCX3vvbfO1bX8vp07eDBH75F/45k/kCMYrhsMfrX3caZQNOO9761X+Q1td85H2/zIc++Wm+73v/O37jvR/glx//ELffehNuWFE6xT/8+38H7SpKJ7TtlP2dh/nZn/l5/pc/9z/xz37qp/jZn30v3/Xt7+SOm09x51138dLbX83dr3sDG8e2ICpuuuPtWKdJKfKeb/82Hvr0B7j3Q/+F173z2/EilFiizqFinr0tXWFSFrAlEZJR6JSIBIwuSUQ0lz9Ahc/3AefhTDEPtpID3/3dC2xtbeeWXTZuH5RD0bk0VlTcfPrEZds6fCAq5BInKWGMQWlQSrOzu8tP/fS/4MkzTyOow7lhtorLM8A3vuG1DIbrWX9+MJeD7CqWEojmA7/zAWI8cNi59HBZyMLrrc0h29sn8v7VpVnyM8Uw1+axXDbmQMl/Iw5Nn7vPVxx+vXavOHyFFV5cWHH4isNXHH60v1f8fb12r/h7hRVeXFjx94q/vxz5+4YT48eOv4z19TVee9sbadfexMapJ/nwA57N/bfzintOcu+9fTbX+8x0h9kd8zJ7F+0QLuxPaLoL2MEpTBJsepTdnXPU+xF123E2jlW8+5Xfyocefj8DbuVbv+mVfPrxj/D0xRG3vfQ2JAaS0Rgx2VpWGUQdTCwuefJfK4G2whcGz3Rj38hK5BtJ2F/ve5evSs5pUn10cnOQySWvYNVaXzUBk8OvSR7iJJJto4/UcCahZWkHoZfJV1Go5S2bNylcauIVk77lO7m0xCXV4oGN9SWhh1pu7+iEdCkKOdL+g4EgK2zUpfEREAKFsYxsxXbR5+V33crJkxu5HvMVU04RUFoOO+GIgXZ2ZZBLvZNLOevlivQD5dPyNQmVTP6+Jlu5A1qW20Evj/1gP0urbxFQ2a5FRKFl2UnLWtXLAs+gDQd+HZcS3/nfhOZo3Y1l61GiEfEo7XJfweE2QC35JCfWk4BWuR73pRXZB1bg+XfO6GxBrvWhuCAEofMtIXT4GFBa47tA17agFa4w+LZBEly8uMOsi0SjcBrWe+sYLZRliXMVMXaUlcWoMlvep44UEr6L1E1N2yxQWqiKEm01Uke0SQwGFd2sZr+dEBdC2SsZT3eInTBc32AxnbE2qkghsZjMmI476qblws6c+cxTdwuKsmAw6GOdwtmS0ATwLRfOT5innMjeXK8ojCYkhfcdg15Ff7BGGzrq3cDxjXV29zoGgyF7O/ucf+oCi6YhiBBF2N5apzCWBz/5ODe9ZIumi5w9s4fqJTZKsKbCWFif7rOY1ewOKobDPvOFh9IyG0MxKCkY0HrP3t4+4hMpJmyh0F4RusjTs6dY29ygwBBDYtq09IeGxSwwn9Y0vqEcFqgAMUY2+5aqqGiaGY2H6XhMv9ejiC17dUODo24DvV6J7zzDosCHBj9b0OgpIiWth95QYVE4I/h6wf4TT7BnNaP1Abs7c6azwKCECqGZLNClInWJrm5IXjGTmnTsZZx//CIxzZn5xNroDLYCCZFuvOC54tKE7MikTB/cCZcHucYYRJ55TD6KS8Kkq4Pnq8f/y/d1LUHI5Ur4q/d1aeyTK47rYGInXF6752gbLu+DG5mUfn5CO7ns9eFf6uhHn2/CZIUVfv/hUOK2LOGhE5SmRIxGSQApMASUjtz5yntY2z7ND/zA99B6xf/6l/8O7WxKVWmefOJR3vbVf52N47fyPd/3R6m7mt95/28yKgLv+pqvpdo4RlrMefih+/AhoXG85JaT7M1a7nz9m7FWgXV8+Nd/gSfPj0md5sK5HeZdw2ze8uhjTzDoD7jlpm3Onn2I7//Df5AYNB/6yG/yH3/pP/KKl9/Be775v2F/8jj/8O//HPfd/yjvescbaWvPEw8/zsc/+j5+8M/8GEkFtDUgELXlm97znUy+9pvYe/wzpFDj3DoRjSid50kioBISFUonRAxKWRQeZSyGEgCd9HI+FbKM8FmJOK8+K4fj7HLul5bBNghPPvEor7j7dXCF4O/S9xWSElpbbr3lNIdB85Hvi6TlNnNwnoNyxe7uPv/qX/1bmtCSROWJJQLE5Xwsccdtd6KMXoo5sypeUp7j5vm84v77H1j+VJbz9+WDDdGgoSwdpixIkpYi7GV0cPjQ4EruuvQw4ejz6vz7PClPSdCfZ8mvFYcf3f+Kw1dY4cWOFYevOHzF4RzZ14q/V/y9wgpfGljx94q/vxz5+4YT471en4Wf03Irp28f8uDj72NUHqeZf5r/+ju/yTtf8/2cax6DssK2QrQdA3sLm+tDzu16FBpdOPae2OTr3vBOnjp/H9OZYm/3LA9eeII33/2N+Nqzvb3G64f3sH1BOL5Z0UZhiFtap4dlRwpgrqFiu9GjefHimVZd38j3bzRJfb0VqlfesEopLtUgvno/19vnle9dnsCWGzq2633/yCeXPpNsuSBXfu/InzoXdrjsNwpByZHjRsh1EQDJSXZJ2Yb5Uj2EPJEVOcz6LtUxR/vqWqvkFfpgtbQ6qPN80N+XajBfOfE8ONYrk+IH+zlI+h7UX1bLgezEqW1OnNwmW1SEbPmxHEgvTQolu2ocKFIhJ79FUEkO/47x4Lji8tgTiBCTEHzIq4ENhJQgCbHzOGNBgzU2tx9AErI8zoRQL+ZYa1BaEZMQY66ZHQ/6McVlfWyLJvdvlIgPnnzGNU1X432grEpSXNpxKIVIpCpzTfW26UhJ4ZyhaRc4azFKQ5K8fwUhCU1d03UdCk3ddmjjmCzmtHXL8ePH6A1KutCgBaKPhC4xmczx3tO1DUkiSnIN7dZ3lL0CJFHXLd4nptM566MRPVuwY+ZMuxpPQIsmxkhROowpWd9cQ1KHFo0SzXw+o2kWuKKg37M4Z7HaYKzl3M4O+7t7nN3Zo7IO21tDRKh0YP7Y46RoWN/oUzc1Rgq0eEJUqGAoZIpzFb5LzMIcYx1R5kzmNZsbJSF2pNQxsA4bGmKTe72vDHHW8NTFfRZBU7eJs9U+Vd9izAV8TMRFJKDBB5RWXFQt2+tr3HH7GtNmQYyREDpYCLXvQZxjXSAupjjtODces1tW1G2iKEpGvQI3r3Eni6VIQBFToKlrhraP94nQdfjYMZ9EpD8keBAf6WrP7s4U3wamfkGaCIUyCBFlN7H1nN29mknj2ewZelpoxdPTFRcvNIxDx8miwjcLHj+/g7MlPRuBHjE0FNaSvND4fG8rZagnE7rQEes+F3dr6sYjI4eyhmZeI61jbWRI2tGEGbp1NOOH6dlITIY6efbmM6rW0IaOtV7vGcfJz4kjY+HheCqX3s/v6RsMyK8Ibq8xPh8IeY7u88qh/lpj+7V46uhYeu2APh35zdF9HrT1xnAtJrqyjc8+SD/Y6sFE8gCrYHyFFa6HHJQvxXaSQKV8b4sG5ZbfMQzWTvCyN3wtWjlecdc91G3kW7/pTXz9N/41mvYc68dfyfbpO3jk47/ObXe/lZ/8yb/Jv/wXv8g/+Hs/zp2veBUE+PBv/jve+c6v5tZTt9GpwB/8ru/hsx//LVzXQDliZ/dpPvy7v8e/+rlf5NV338pXf+1X8epX3MZr7rod30Ws1fzqr/0m3/Wd7+Hee+/j0/c9xF133cL7f/t3GY3W2dje4E/88T/H7NxFLs41b3nnN/K2t3w1FD2On94gdQFcgdKJFKBZzKh3HqfaPMlLXvlWDuZ1HIgHj4xrebjTh/GPxnJpUIdDNaIyhyPhtVcf3RgO+CHPi3MNsZgSFy+e47GnnuDd3/ptCAarAlGB5lK0KpLQWERBrz9Ck4PXgzkbIljrEIl5rhcjTrss6pTEomkOWnHIJwf/GjR33vmSAxnncmoe0UoTkmCUYzI7z70f+zSHIksBSLl7VJ77nzq2jXNDSAaxWcGesjrysjl55plIHsfVMnhfdrootAgxtsQU0dqgVPGs+vmaWHH458SKw1dY4cWBFYevOHzF4Uew4u/PiRV/r7DCiwMr/l7x95cjf99wYrza3GA+fojZZMYnJ4K0iurULmX/FordAePFhNMnTvDoxScIiwaptpn4BcQd5l3FHafvYq1fMel7qrU7uHMrcuFijY/H2Zvu8cGHPsEtNw34+L3v5RXDr+Ke228mRIUxOVkpywNDHSgRbrTlLx58rgTwMyn3no/tX2vbz5TAvl4brkxyX2/b18OVSfEbPe6rk/GyTOJmxYkcJIblyNxHZS3mlautgeUqZUCzFFscDDYJkZygPXhb0jKZrLm0bxTo5UYOktV6qXxZbvFg/3nDedt5jNTLhHMkpYhzlwbSq4UH+ecxRi6tLj8ygVy2QVQea3wdQUdigrZpkOSxtsS5kFc2dy1KQVn1qKqKGPNgaawhBE8MAd95Ygz0h0OszYNJDB6Jga4TUvK0bY1zhvlijiTB2QLtcgJ7urfPcNhHF47+cJ0QIs6Z5XEptLGkFJlMxyiEFCLee6aLBRsb62hjUAkkekLnsUVJJFK3DfPpjNlshrEOay2x6ZgvOspBn0TC6RLfNYSY2NzcoiogdpG2WVBUBSEkQvCIQFEVCAnrLFopLl7YZTZtUcqhNJSVpSgNjz34GHvnd9g+sclsPqYyfRbtgiBCr+gT2oAVoVRC5zumTUcUoZ03LOoZ3keSJFovRImMhiVdC23wJAJ+Een3evja07YznnziKbTJdT7Wh2ssZjO6ECjKHk07J+sPEtraTI4itE2kNMLmCYMPgWkXmdctvb5Dm8B4VpN8waAnjNYGzOoFTdOxiAvEGEbVkM3NdR594imKIMTZnMJpNJr10lL2ilxrRoSu6YC8ir9rAvM2ILGg6VoGRbYxr4ym1AkM1J0w2Z3gm4CWRGgT9WLBIiXKwrEfIqcGmkGlWBtVzKdzmuCZ1C1lfwMRoZ7nlfnjah/lFWUpjKqKgTWc271IU7eAMNoa0UxaullkfzanP1pDNS39osf5WUNdN6SgaI1i2LOcu7jDQFv25g3T6YRTo5PEbg7OUDnPdlXTTDsm0wIGCfGeeRuwvch8rpDU5mvIFijJNVO8bwBBK2F+cc5sV9ClIrSBIIaqEnwKEBVFWSDJkIJnvvMZhn1F3QhVC4sucmHssTNF7abXHVOfE5YDyKXx5mq7tcOvXjXOq0vvX+M31wti1cGYu8RRsdIzNvU6fHXZgVwTV7bt2U8cPr+A/Ip9q+fSghVW+PJDlsDmgPLggWGSI7aHy8BUoUErkhI2T93JRor8xb/6E4ADhChA6jh586uwRZ+v+4bv4qnHLvDSV76e0y+5kwc+83v88i++l7d8w1fxn379txhsHOfUsV/hO7//h7FFH4Xh/JkzjAZ9/vqP/QjzuuWnf/r/ZXu94t/8m3/O+ad3+b//yU9w18vvYn+/wSvDj/yPf4qvePs7+JV/+x9QtuHxBz/LHa96PT/wx36Aj3zsXkpfUwzWiErxsru/Cp0sQqKNgQtPPsm//7c/xe03b3L7La/g7re+G2HpZHPwkPKqgURd5/X18dzGssvPh0gWeIoITzzxFJ/59ANo2yOkhNZLZ6+srgQumy5z++13orRC4vJ4lsH7AUfk//LYrnXmVa2EtHz+epQLUhJObI+4+3VvylfN0YexStCS59Fnn36CM09fuOr3SqmsjEc4ffMpyrJCqQhKrvOQ+oD/DkSql2gwpQQkYopIAmsKlLYkUZjn0OPPiBWH3xBWHL7CCl94rDh8xeErDn8GrPj7hrDi7xVW+MJjxd8r/v5y5O8bTow/cP/7adoJQ9unbgXftuzImP6oz+tf+zZGJzVPjs9y7tHz3DZ4FcXJdZIfMz77JOO9i9x74cO87u57eMXLX8qMczy5d4ZP3PtbvPLEyxltO+azPdTi1czGn+HR3YLBxmuYt46XH7+NIRBttkYGDuuNP9vE8RcTN5K0vpGV1891f89ekXL5JOjg99eyI79ysnR01fnR3yt1aZX05erDo+0EuGRNfoBLluNHv39phbaQyKYNlwarw7Yetin/MMaYb0BZZtCX9goHFtwiARFo2nY5SBiUQIqRKBCjByLaWLQpiCGi9XJFd9TE6NEafExYY3KSV/LeJSWMM4QQ8V1OiieJFM7Sq/oYYwghEEKueZxSJCVFSoGuaymKKttBSF7NrpTONz959WzbNkx2xwTlMbYgdh39YR+I9HsFwTfMJmOUgv5gyP6ekFiqgpxlvLuH7zoQqP2CY9snGI7WSTHXkNBA23q0gjNPn2E0GrGocw3nfikszl9EK81gY0QTAqGeM55O2dvfY9DroRTUdUNZVgyGQyRl6vXTBSkGxjsX0NEzHI6QEPFdQ+ks2mgms33OPH2eyaTG2QoVx0hoGQz67OzVuHmNkBj11wChSx27jzzMnXfcgnSJp586T9KarouAsKgXiFIYp4kSCG1Eo5bHp5dXi+BsIgSYzs/y1PkzVKXDqZJSW9aGA0LIydaqLFA2Yo3CiOC9p60XxBRQAtZrSDDZXzCeNtR1S6ELYgpoo9AqYlSkaRO9/gBjDfPZnPlsRkpZOOCDEGO+FhGN0DAoHSrBaOCorOB3Jsx9BKdQITKZNMyaKUoSBpsFBOMJRQ2FKhiYiCo0027OmbMdi+mMk2sVfQ2jXknTtLS+yeqtzuf7zUac02yqioFLHAsJkuHMeJckJbUkROVEt3ZCOawIU0VoPa4qKBxMUkJFqOcNzgVGpwYMnUa8Z9B39KqC3bFn3rRIpdgeVczbBt0UpBBJuzX9YZGJruuoVGJQVjSTBWVZYZwiEVj4KS5FLly4wH4UQtNC1EQjEDTNomU3JNoycbxfEpoau14SQ6SNEzY2AJ14dHeH3dZw89aQvfGCwvQJvsOHlMsRoEEiyuhcT4VIVVhCGylNIooiBk3QCWsUohMh1WA8rjL4WtNMZpi+RkgUGgolBJ0oRDi1WT2rMfxqqMvG54PXBwH5QVB+PRXjsxVpHeWBo/u/et/Xae1z4ParA+hr7/u5bA+evVjtqu1d5tZxYCG0wgorHMXh3FFBnpOlPE07uPcumzMe3I8KxKG1JUUBLSQJoBUGy+jmOwjTfV7zujfzF3/0JMdO3YoWw72f+AijtR5vfdu7cXaL9/3Gf+Z1b/k6KAZYU5KisLV+jO3NPhfPXODH//7/zfkLu/y9v/1XqKfCb/z6r/Lub/o6zlwY87M//TP8b//bj+OnT/PJez/Nz/3n/8Qf+oavQFlHUQ04ftsb+OzP/BKD/hoQUGJISmXqUIKVgtl8wu++/wO89od+kM9+/CPc/bZvzg8eXqSP8w7Gca3g+OYGruihJYK2qBhzGZyDckASl78x9AZD0BotQorZgUiAEDyQ7USPWp/l0ODSQ4Gjq5eU0rzhdXdxyx0vR1LMCn6xOV5YlkEKwKMPfZbpvLkm94gITmuObW5ilm1WSS1jAFkq1lnGPzmWMSYr64WEIKSU8rWnIlpbjHEcxjPPS6y64vDPZ3uw4vAVVvhCYMXhKw5fcfhVPX3Y31f2/Yq/b6wNK/5eYYUXHiv+XvH3lyt/33Bi/Hc/+V+4be019I6XHF83hKbPEOHMU/fy2IUneVXzWra3T7J9Yka14bgwPYO2JRf3LlCpDRgkHn/os3zFseMIiYefvJ+4MyAODaZoCcpw2+Ybed3Nd1EU66A6HvLnefDc07zq1GmIGqUEjSxrIsvyYK89gXgx4dmu5D6KZ1qtfa3Pn2m7V0+SPncbDi7egyTztZR7l29Prvo7LVdgs1zhrbUhpfw7rdVS3XGQPM+qkRhz8jLGS+fXGEWIWT0iKeBDh+86YgigNN53WGexzmG0I4Rsa22dwVqL9x1VVWaFTFIkEeq6JXiPKxyNb/Bty3RvnySK2XyOMYbBYICkSIqgbcF0uoslMhwOcdUAQWEtVGVF13iaeoExYF2FUhprHdY5tM23mxW3tBX3kAISI23oiL5Dm7yq2gdP1zmMscQotO2MEAN7u7s45/C+RbTGWksI4bAv27Yh1i3j6QSjoZlOKft9knYcP7aNMzAf71EUBfPxmJggLAnPdy3NomE2X+BDpIs1uxd3GQ3X2D62jbWWJIl6PqWuW3Z29ngyPE3TdPT7I06e3KJyJcbCfGefqlegRIhhQZhlK+mycDSTCdNwkR3jqIYD1kcjJHhCvWCtqvBtwwKFb2ti2+KrAuZTLlw8i5+3yNxThxlKJYpCs5hH9vYWhP0pZWVIQZOIOG2IraceL0htzWyyj1eWvVmHKAhdg8RAv9/H+4iSREwQQ0QBZWEwWvC1YI0jxEAgkBSsb63hbIF1isV8Rmg7uhRQRSYnZ3J9clKktIoUhYQnNolCEnXbErpEHTuchc1qjelkzGhUMewPaTufr2dj8CESQv7b+4YkisJotDIMSkPPRYzRmBjYHJYMj/e495EdRGuqytB6TdcFjHWs9QqGtkBUoNgwFD2LNNlW3k0azuwuUAR0kaj6PbQC4wpS9IQmoEJAK42rDIVWaA2uhNGwZDKpGZVwYq3PZD7Hp0TqAlqgVxm2j20wndeMFx29nmHY02yIxSthszQMHBhdEJfXozaWjUFB3B1TLzS7bU3EU9cdrjKoJpGkZa1y6OWcJamAT57Ueup5JHQaG2FvXqNdH5MafARUIsSOutHoEBkO+vh2TL8YEuhYNFmIZYxidxHoushaZai9ICpw203HSV2gnk8JIYEFCR6jBImRlDy9niOmCEaxseEY1wkfOhoMVhmCBGLq0NbQdg39Yh3rXBaqtJoQI+2so+oXnFrXlO7zC+AuTWqu8/nnCJIvx0Eg/8xa8WcKYp9LgPvs23it966zT7XUTF6DY5+rQG2FFVZ4btAKkkREInnyZUBnMaBw9T2aS+IkJJnMB7JUICfoVOBDv/rz/L1/8JP85b/6VyjjhM2Tt4J0EPd54+tfy+bmcd719e/ha77hWzAq0s0usjBDkrbc++kPM5/PubB3Fu/nFEbzsz/3c6QEv/iff4Xv/Kav4L0f+Bh/7i/8IL11z/t+4+O86lV38//9M3+Ol54asnnzS7BS4Ho9vvP7v5teUSyV9wVaB7xKuGTxes7JUzdz08tvYWfvae56+7vy8R5ZWfTFxsF4eHT8VkrY3hjytje+hkHPYQiI5POkFVkAqdXh8KtQtG2HVkKI8cgxymEMcLCSKcaItQfljZb/XDYeK4xWvPUtX4G1FQeqd43O7k9KgcpOUg8/9DBNF689nosw6Jesbayjbb6GlMrzOJF0JN7J72ehb0QkIZIdgbTSFNaRcPkZUTroM5biuc+z7w82dr3PVxy+4vAVVniRYMXhKw6HFYdfOkpW/L3i7xVW+JLAir9X/A1ffvx9w4nxd9z5dlK01It9xmI4+9SjbPVvxtNQ3nQbT+/v89SZe0l7nv5r1yiHBefP3s/e/uNU7LJVvAxbKHZljwcefh8P/N4nOLX+Ks7sd6gnb+fUes3Hzn6Wu06+khPOE6PhFSdezsceu4/3PXCRt7zktRRVyqUN0sG5uZQ0/UIlyK9Hzp+buCWfzIMVzcJVA8vRbV1v31dOZG50snCQ3L7WPo6uBj9YgW2WCdqj9t0HK5mttYfJ66Pt8T4n77TO389/e0IIGJOVKiFEClfiXEGMCW0U3rcoyNs1BmctPgQkCd5HvA8URYFzhpgibdfmmsv1nHqxIPiY60WHhBjNcGONouyDaHpFiXEGkchisaDXq/IKXqUIKTCbztnf3WN9bY35Yor3npQ0Whe0TYekRNOv6ZeO3dkCHyNWBTZ7jjYEOtcSC41RkblSVK6PtDW6NBhjUVrhm46mhaLsURSOumtBAvV8hu9aUhR6VR/lDAIYY3FlQdPWiMB8VjOd7uJ9SwygRDEcVjSLlsIVNE2DUrn/Ot/Stom93QlbowrTBbpmhtfCua5l2CsR39EtFmhXoJRFQkSAQmmitngf2dkf45SmxDNv9hmYAlcUFL2KbhaY7M2Zj2sWbUNRlVgVmexeZGI06xsbOG1o2jkoIQj4zjOsBkhMaDRrgyHT8ZzkAq1r6VmH6/dBCb6LaB8pjSO4yHw6ofYdqk64pLEqoSxUVZ/x/hhlGlKALka61hM7RW+tR9nvgfYkhHk9pfGecduymAfapsZYEAm0PhCiULmK6D3WKPpVQWkUpXMYpfChozRgVUmMMJ5O6Fcl2/1NbrnlBOfOXGA+b/HeMxqUxOiREKisonCO0HmS1oQusGizjXtd18QkrG0OIXZUVQXKMpnNUEZjtaJpAkpbxpMJVa/CWUfrW3wXKAoDaWn3bxVWW3zoqDvBOmjaBnqKqiwpo0XEs9aHykIbIYqnrQOFtbRdYNDvccJ7UOv0ew6jNXpZpkBrRQoRJQadEsknvDIEPGiHb1qaxQJtIYSafmWYh44YBKMstrCYArYKiw4GrSOD0YBZ6AhiKQpN9NBJg3MV0FEWCquEtFaxc26GN541V5GSZzqpWR9WEEGLhpjHtrbxFLZPE2vwkUI7il6BiLC3O2a2aOhCQpcKg6BdiTMJUTVODG0jmCpQNxFXlEiy1HXD7lyhy0BpC/yiY5p2SW3E6R6u8ITkMcqQUsJ32TGibQLBasqiop1FfCeIjWjj8B0EBN8F/CTbsgc8SSV8EIoqUURNqQJSgtIVIYQbGuufHYSD+iwHY/kzUeghzx0K3NWRl1dz4JUWbgcB8QHPXPmdZ2zpYfuuLfC6enuXC7SuDMavnDOIXM7I1+LI54r8+wOl7aXVASussMLlOFQhLx18lILxZMzGxiZHxbBw5b0bsyZaZ7cSlRKJ7MQiMXLHy+7ih//UD1EVBS999btJGIzRfMcf/pNo3Wdaz3jqkYe47eWv4lMf/XV+90Mf46bbb2e2t8+r7r6b+z59L73BJqeP38If+N6vZbiW+H/++f/LS2+/lW///h/hE/f/Dc4+0fL2d97N295ygZQqdLPHrXf/ASKRKIGnn3qIhz9zP9/0bd+LSglUR0omt1EUTpdsbPb4S3/l72KSwlV9kizL9vD5r5Z5PnHJOWrpzJQCd9x+K4NBPws8lyr8Q4aQHJinlJXdiuzapHX+xsFpFWFZYigdBud6KcITUagrIietFaNBxetedw/WZgE1SUgqofIVQCLiu46PfPTTdG13zeNRWjMa9Th1+macK5Ztyl5US2ZZfvOANyCmsBT9KqyxKKVJS922VstYb3kdP+PT688LKw5fcfgKK7x4sOLwFYevOPxGseLvFX+vsMKLByv+XvH3lzN/33Bi/Nwi0k7HiK154uEJo+RQ0z1ue+UJLuw+jmpPYNMCHRNP3fsR7ClPN6nppYCvJ1w8/1Fif5O1Jx1j/3tUxxRFN+IPfMW7+Myjj/CKO9/Ch578N3zykU9xavM1nDp2jJ35mOn044TFEC+vQYkikS9QdXCeD8k2v/+FvmgP9nc0aX15PWuWSge9lDnAwcmN0ZNrpgvZFrlFUl4lHZOmbVpcaSmsxRpNTAFjCpSKxOiZzz3rG+tk1/yUE1dKESWSEELw2cJbchI7+BZjLNpYoghWm2x5oISYBFSi6zqc62OdQqNIAcQorLUYSfjoSZIgCiElSJEudISUk+Tz6QyrFUlafNPRdQlTWPq9AomRkISL85bNY9tZiURgOt3PN1FMGFcSo9CrelirqOs5ZdmHtM7+/px5M8O3nv3z56FtKJ1DgFZlaUlXL2j2LqKLgqg0a5vHcK5g2szQOJwEmvkEZR2DsgeiMF3L/OI55tMpIUAsBrhKk2JDUzfMZxO2C4NYx3zhsSoyVCViWprxFEqHScKg32OwVeCTJ9aBelYjCP3BEKUL6nZMZ8DXUyQmgg/EEFCmoFCGxXSflAwxaRZdS+s9Pkb2d8aUtmR0sDpddewtJvgoVMWQpl0g0UMSrFY8ubPHbN5S6C22N/rU0xpQLPbHmNbRqzTzRUPVG9JzPaJv6WKgqEq6eorpWrZdQZegaRKxgqfPPsn29inKYUUxKHGNpmhKwtLW3TcTymrI3t6EZtKw1nP0ewZlDEJCJ2E+3iWpiEqRScjlEXS3IOmKotdn/8JTGOMoBgNS6Gi6bPveNg1t3SDaEL3KFhspIqpjbVQQ6w5dLChDDyHhmz10mdjrplzcnxB9Q2gT89CytztHKUtIgk6KGKHxM7Ro+s6gHJSFUBUd670R2mhEPDFmVRVamM09XRMY24YYNU+d2WFcTxk4S89o6kWbLWe0QkThW09V5TrtCSEo4dyZfdpO6Pc0dTdDYo++c4znY2wxINUNlLnufF3XpBjwXUvVH1EZhfaeJnrmnVC4EppIZzTSKBbzBpug17NooyiUxavIoqnpgqFXOFylUZHsqsDSTMoIOI0yhnlTU5UWZSwqBbouoLXCWAMH9T4kEX3EKGHUKyhSQa/1WGdoU8S3Db2yorSaGDzR5To06ycMi3mHVpaq03nFdNsQYkGMHVoUrg9tmuOiYTzviO0CNypoCdDCie0SmzwqQesVWikkCUkUKTQURjEalszqnHiP3lNZx06o8RIxwVCqxKYzlD3LbAY6doQQkRa0M6SgEAeiHNPpgjjvOLHdI4UhoRZ6PQspJ7dFPBSW1HWkmJCkiUsnCpJH6USMLToJjUoYW6BTxKCwPQPG5fHPQOFc/m3paWMHU49ZK/D188drlwLoo4HpUrF1GKhfi+8gq7rV4aSFpQrxczuRcNn+jk6orycsuxEbtefC99ey8Pl8t3l0W0otp44CebKyFMVdFoyvAvMVVrgeEsBy3twfDEGZpVL4YJzKOHy4hiEt4wGRXA9MK4hK41LByTtey013vAYfPUrbXBomGZIdINrwiQ/8Cv/u536GP/+jf5tPfPJTtNpx9+vexD/8u3+Tkzed5t/9/H/iu77zW9m+6Tj/+Vd/h+PbA77j276R//xLv8hivsfb3/laQj1mODrOV7/n+3no3o/QWzuZ+TVZ0MLp217F+vpJtIHxzpNcOPsQd9z1NZiiQoxk2zA0ZTnCpISQ5wDXc476Ygboh1Z7y9fz2YxiMMIW/dxuUWQlsxwOc7l0Tj5766N1Rr0e+7M5IYFSub6YWtJPtk1LHJxrrRUimhTlsrBcac3pk8e57faXkZLP9cQAIS1jREWSwNNPPclDjzyJqISkyx/sKKWw1jAc9Dh5+nSet8b8oEdpfdkorbUmpYAPHiURYxxKZ7u2A/48iPsOHgbnBxDPb/+vOHzF4Sus8GLGisNXHL7i8Gtjxd8r/l5hhRczVvy94u8vR/6+4cR46F7K//wn38XP/9af5b5PlQw3HOcWC+YPnOfW225lrTJcuLBPRYEq1jj/QMPQrVEWoLVjtrvDzrTj6995N6G9yKP1x7j49Kc437yDm26d8+HPvpe9ycOk9SmyP2KwWRFC4o13fCNP7J/loYtPs3bLaVTUGG3oUq4DbLKE4Yt2cR6dTFx5o1yadCwT4Sll9YMkYvR0bU2KmhAWIIbzF84jSlEUDomRqhixvrFFExaIKFIMKGqSePbH+wz6awyHA0TySu5c+1rovCcuV1yLCDFFmtDhuwVVUWJdlW29k15OvbL/vlF5VbvoQOM9IoJTBUklGolITEQFKXpizPblhXWE4PPq1BghJrwEfDenntW5LjGJVJVYpbFFSQ+FzHPt5b3dC3SLGQqFsY4uRXZ291lfX6esLPu7+5RlRdXr0/mAtgYFTHZ22FobYhUsFguSgLYWp8Ei6BRpu4azkylFUTCrG5zpszEosTZhJKJSyHUVQoe1ip6zLHzDvJmQouBDJLY1fachlsxmM3ZnDdv9HmazZDrfp18O6fXXqJyjKB1Ighip2xbvO2KKTMf7ueaD1ohE2mYOMdckb7sOawsm4zGNbxAfKZxjbzJj1gmuv8bZcxchRXq9kvX+GmWpMUnojfqMd3dQJoFKNHWHxMRkZ0GUhEqBejEhhERIjtg1UELXLG0nYkcdQnYKkERohbIw9LY38K1nMh9z5sIetrFsrhVMx7toW7A7ucDu/hglmjTvKI3QK3so6XA6UVpIocE3CpaW38GHpWKrQwW4OF3QmYK1jXVkpii1ZTJboEjIbIxfzJGmRSUhJtDOYlRCdKQLgVkr9FNke1Tw5DjRdApSm0lbeoz3GpwSFo1mtmjZ31sgXlGIxWmPGQDJQlWyPxNIEZsEbWFQVOgU6JqORdOgjMLZEms6JvNItwA16HCu4OzOBSQEmi7gNkeUSlMUS1t/a4FIWRichdZ7QmwJMUCKFNZBCCRVMIsdZhQwJrCYTtnaWMOnFoyjKC1tl+t+jPd2IUb6/R4+BLq5R2nNyWGJVYn1foUEYTwbU9oKrYROOura06uqbMkeOzQKEqQoeWV4ofBdIPiWxawjhMDx4xtYIwTJduDGGBSCthplAZUoyzxRCpLAKnRUxBSxxnB8aysrBqVj0C9RQAyBwjmszkou5zIFjYZ9rFWopDFWCMnTV5pHzs7Qg5KtjSHnZnMKSQw2DDhNFUuKHsua8dl2xZjcLqWW5RgSjHf3Ga1vsbdzhhA7fPAYXXLi5DGcJCyRfqnplX20BqsSkvKY2MUWjWJQabAFo94AHRKFM1RlQddG6sUc4xR9pTBFARJIkihcmVfwNx4fFCEl1vplFjmFiIqRuJw4Gq1x1uax37cEH2iCYuo7XvWSk/QxjH39efCUuSz+uzy4PZj8HATi+gr+kiNBe37v0lQpz7n08r2jnCgiRxSNz4zPFRQfbe+1g/eDoP/geK6cD1xq+7UC8uc5Z5E5XyXyTbZs4GVNWgXjK6zwTNAc2LVZXGGXDwPhkmXU5fdQVAmTNEkJSeUgDiGrm1NgvPM0H/r1X+DVX/l13HzLSxGlEBQiHiPwpnd9K3e8+o0ksbzm1ffQNsLtt7+M191+il7pOX7sOG98w1u4/e438jd+7Mf4nm/9Or76m7+bhx9+kn/90/8XTfR83x/9IQweXWzzite9g7yaR6NNbmtZVhTHb0KkY7B+kgc+/puMtx5k65bXIKKWgWRAiUIyyX5hO/0GIMu+P5ApSxISirOPP8hwtIbSBqUjsgxEJS0Dc3IppSwUznPORDgUNx8E0qI11uilRZrkenXLoD2PqweD/dLSLwp333UnN9/+ErQpyK0BJRZUJKqIihU7u+fZOf80smQrvTwCyFw16g+4+abjvPxVdxO7FuNMPg8ISpv8vSQgKbtgWYtRFTH5LMzLk09SUmh18HCIwwe0ApjPo99XHL7i8BVW+FLCisNXHL7i8IwVf6/4e4UVvpSw4u8Vf3858vcNJ8br7kF+8uee4DMftNz9ypcwC/ucfTTQK9ZZW7uZEM9S+ISKIOsGUx7DFhFbthA3GIxOMZ13fObxM/S2jzNQm7QWPv57H+AbvuZWWu24afPd/NoH/wuvui2wczaxuSbMfeLmY6+kaea0KeB0gSJxYWeHQb/P+nB0ZHZw4xfWc8G1JgPXs5S4fFKRbcibpslWBArqeoFKkdC1GKNou5aispAUZVEiSlP1+4iOyws713mw1qEkkKLHaMNiviDEQIxZPXGQHD8QBqqULwjfLvDtgtTUaGMRbSldlVc3Kr1cXS5Ya3FdCQpCCCjJFgo+tnlihyamjuQbekWPTi8voaajnk7pFZa2qw9XR4okYgi0EgnOYonEJHSxoQ0ts3qMU0BUSFD0jOFYv0KFFll0rBUVVmuUb4ghkDpFGzoqq0AiISYG/Yp8A8jBQWMQCiDGwMBU2KpgMpkRTKToZ/vwJixIKeYBIkquOS2BpvFItLTzhvWBYb1fUBaanteUKuXEuyScUVSFRvmWSKSJLaKEZr5ADoQJy5u+W3iAnCz3yzrNRUHXLkjB07UeJSZbKSvBJ8/+pGa7v0WFpfWJia+pJ56tjT7H+33298akLjLoOyKJ+XSOc45eoeg6IbYdqqooCk1TzymcRUnMq9QBiR6RbMWtJaEkq4VSCsTkc41tSZgEJgWs9rSLMftndxBtSNLRKzWjgUEZT+w8lgSxJhHpBFAa7UoSCU3KdvqdZ76YM14s2NmfcUe3gWs8KkS6Zo42htC2mZIlKz5V1NhC4U0iaTi+YVnr9agXNbMmIGgKlehby8aaYzztCNGw4+fMxhqnDbV4RlXCaE2bBGPzoOlUZNjvs1ZBb2jRCtp5pOxbnCtoW8983tGIZ955bNmHKPg60MYGpw3Dasj+uEaPIpJmpBjRylE6TWFL5vNA0uBjIKVsXaIkglZ0TUPVt4gt6GqDpEQXA/vTKaPRGiFEQoxopem6lsIarE2cHA7Zny5YTGrOErh5bZDHlthQOMv5i/u4SgGG/UnLsVGFK0C0xSShcmW+tyCv2PYxJ7AlEVDomAjikZAFLymlXI9eK5xoqn6RxT4qi3ZECW3XUZQ9ynKZCPcdGo2zJierlwlrW2R1V0yJPFQmYiTfi0njTK4FP20Tr9juc/+FHUqjUSEy3m2xRjh9chN0rp8SfCD4gNUO6wp8J1m8Q6RbTGmHa7ReiJLPf/AtKTa4wmHN0sjMCChFaBPdMvltRBEFhgONK0tUSvR62bVjsZijMVijMEbnejxKUEYolEGTKJxFUBAiOI1WuQaKFyEliCmircl1xWOHKyqCXwbJGm7a3KDSUEtATPXcuYuDac+VeGbSvCpYXv5frowxr9zqM1itXc/u7eh7V3LoM9m35UnV5fu9TqsOv3/5r19AqIN+f/Z9v8IKX464bB7N5QPN4f2tDv93CJM0ogK5jJQh4SEpRAnj8QUQ4eGnL/Kv/8L/yN/9iZ9EK0NhKsQZ9PAUzpU8ev+n+Ym/9Vf48Z/8R7zk1nvQxvKDP/JjeNH8o3u+irJa41Mf+HV+7Ed/hLd+zbv5wK/9e777W76K3tYW413LsH8S7SqMRFBZoX60nUqpZUhoEdVy26u/khBqtEogCaVtDuS4+viOHv8X18ptGXDmlqCUJsVA19QMb76dGAWndbafW9q4XT5k53lXWZX0BxWTeYcxkkvYKc1B6Rat82PegxJQKQlGG5JOpHjAB5Feb8A73vFOjh27GWWWSvRlfTtQGBHEKJ5++il29/YPn9ketmkZ5DvnOHlyk1MnT6NNjnVQFq0CIhHEopQQ/AxrLUqVpNgQfI0u7PJZdsCaEpF4FYfdyMPpz93rKw4/+P7lv34BseLwFVZ4Vlhx+IrDVxx+rR5f8ffB9y//9QuIFX+vsMKzwoq/V/z95czfN5wYHw2OEaZzNjZPYVyLlU2++V3fx7Gbp6he5MzDO9kXvlzjwmzC1tY63vUR6bE4e5FysMH2sS32Zk9y32Of4K7b78QeD2y7k/zGx3+LW7bfzpve/C46rZnPNefGM+44dTsn1zdRBvbmj9GPJ4jtJkpHNrc20de9dF94XD1pyCc5+/JHtDbEGIkxEFMAyclxpXKtbyWCMZYm1MSkWHQt5/cucnF3zLBc5/SxbdLC01QWcQ6jIlarnFQOU/anF/E+MRiMCDHkmuAkJAaSBBaLGZIUw946ReGwaNou0XRddlfgwK7c0sXAvJ4xnU7ZXNvI9tFKo7WhsAXOuly0XhRGabR0TKe7tLpkMFij9YEkQiLRdi0qRnSCsleBNkymM3zbEJpATT5+EZXr8mrQyqAwOSmmBNfTtE2NFUeMgbbt0FpwRUkIiRJFWVXLpLYmhharDUpndVOuiw5FYbGmT6+saP0+ziWUTYSY8G3MqhYlGJ0TdMZaYtOwmC6YW8Nmkdha74NWKJ3YXK8wimw3rQQdE61v6SlNILCoaw5sKLTSy/Ot8wphuWT6n3zAJ6Gu5ygtdPUC60q8eJxyqC6S6kDoOp468zhaAlu9HkjEJI1vZ4xTzX7dMShLlGRbJS3CqNdj2HNMJwt6pc39K5rNtTXaukGjWDQdrfcUZaQqKnROWRObZlkP3mKMxpqSjbVchzx6j29qfAhgNKFtGJQ9hn2Dih4rQhcTVeEoC0fX5msyRsGqiO8SwUdQQk8VlFpzbGOds7v7TC5OGTmw2qKSoGKHRRFSxBpyLXAiyXsWdWBvkTh553G21nq0leXMhSlbayfAjzm+XqEVnFzv4WNESUccFKiuwQToRFEkS+wa+muaqiwQNefYmmG9cjgLKSmGro8roWlafDQIcyQkSmtpusCsm1OYAly2HZ9SE1MkNcLGYLCsUQ2FSzTeo0xJ0zakpNjbn9F5T+07SpdXKs/rBfuzGSTLsWMDnjp7jvW1DVJMXDx/EZbXU79XEhIkrbn52BqDHqyV28ybORvra4Civ15gTY3O4in264ZjoyE9pzBOMRlP2FxbR2tNr98npYgxecVyiAEz7JFSoA0NZdGnKivq+QJRCoXFe5/rlySNtQbfBZQIXd3Sq4pcQ9t7lFa5fol1tF3EWk1MEKMgEogxk5Qsa131ihLxkapYp52NufeBKadeWjGfj2naluHaGo00FMYxHBiiSvi6wzhB63wMwScW7QyRQOl6SNL0bJmFCoUlzCMaQ1GZnMDuaVQSJIEQsMZSDCrqRYM2kRQ1GNAp4rtAxJJiTa/K9c1dpXCFpiwLnAMvCmctSEJiQitFGwLGaJTWOJ2wWtEpTUz5egJBidDr99BGY6uK+WyGwjIaZcWf8gF5QWqMHzLYkseunkRcawKYlYXXxrUC6vz+556YXBmcX8uR5dptlyv+Pvrvla+PtPUZW/NccK0tKi55+KwC8RVWuBFcP/C8zr2sE4hClCZJwChF0rB/7ix/66//Jf7IH/+jHNva4JHHd/nLf+4v8j/86T/DS1/+CqhnyCirl1/z+q/mj/x3P0x/uAVFQcSQ6GGdZbhRgUS2jm1wx9ZdzMd7lK5AnOLBTz/Ce77jj+B660AgoVAq19a6vJEgSRGV5okHP0yYd7z09V+9VE0vY/jlMX5xA+/r4yDWOag0JknQEujaOYO1LfIYqJePIrOl3lFbUKUUMUZGoxHbx49x7sIc8PkBjOgsngx53DfG5AcZWmPMMlw9MpYao1lfH/K2d7wdllyhlQERlE7L/hZCqPn4xz/CzsU8Nzho+wG/WGOJMfCqV76a9bVjKJNrfirJcxXEAh1tl0vAKOWAQEwdrugvOwWgQIiX9VdWrH8hHqSsOPz5wYrDV1jh+cCKw1+cY8WKw1+MHL7i7+cHK/5eYYXnAyv+fnGOFSv+fmH5+4YT41obNk6sUzc7LNoBp0/fxUvv0Tx49gnc/hYvvfMruXDxM3RmwHw8576H7iWe2+eWUyc5dvol7HULjpVrnNt7lLa7yFPMISqOb6zhpm9io38bv/nZ3+LxRx5ktLnJmScfZLOEteHr2Rqssz18KRI8o0Evr8BTOaFyeJV8EZAvNkgp4r3PdbyXyYvsgZ+ydXHIq7shJ/hIEWMUTZNtBELXcP78Yzz08Dnm08ixY4FmPmb72HE2NrYoUsQTmIca5yrGk10efeQxtjc9p0+BdYZEtkdAIr6raad7xCagBxGzuUEbGvZnM+azKVVVojTU9QytFUnBY48/zv7OmFPHtsnXfl61ubG5hjMVa+ublIOS6d4F2sWU4AMqKkI5ISmFNrkWekIwSigLRxRhd2+H6XjKsOqhJGA0xM6DUuhlqjikhCWxNLygMIrpbE4tirIskBRQtiBGj7M6J4K1pgvLahZa0cYOI4bgO7QxdE1AlKWq+uhCo7RifzImKaEqHFYVhyujtdZURYGgKJ2lUopz413WNyu0ygnEIB2+9RiV0K5Akme8s0u1tk656cg15LPdvNKGuqmXk1OzvCYSMUU2N44RvSc0HWZpVWGtzQObkuW1FOgVBafWNONpwwywNrHe00QRvNekkDCSiF2LrXqEIFRFgSbSRU8MDZIsIRoMJSlqtCEn6ZWibjyL2nPieIU2CqOWSVHjDlfaOqvY2LA0dSRFR1MHkupo60BKkaAMsbRUrgAlFJVCSV75qo3KAhAltG2LJJVrdKuE1tl6ezIfU1ihi8K8rimdQcRilAatscph8Pk8aYWPjtQlTg0dRiwhGZoovPTWm5BCQdrEsrynQiIQMLYjzBXbg4L+CDTCeq/EVD0UhrppqdY3GQ0K+lUFMSKSV0GDEKWjQjDrFef35izaBXWjGPYKBi6SomJtWNF0iVm74Pwk4JUn+g7T1myNKpQ42uk+Ac1s5qkXHZISIXQMe0OauiFGRVmWLOKcvUmH0ZbON3RtpF9VjCdTBoMex9eHFBo2K0dHzWitoKoKjBOKniWJZr6Yok2g6gtGO4xzaG3o9yuUTiwWAZ08xmRxiXaGymq6tiVFj9XZLqXoVVjrQBRu0GdndxeUwdksnCjKknpeIzFbmGtrQGva0IE2WJUJtfMRlENpxaJuKUqDiCEljzFu6YRhabzHGI1XHSjPZqkZhJK5jxzbWme0XjLbT3gtWJPQktDaggREwPtc3kFrodfrkTykIrG5OeT83pT96Yy1UUnqAFpIEe9bekWFIhHJirgUW0Q8kiAkzaLJ9vdOO5QGV1rK0uLbTOplWWKMIcVEStnWxmpFUooYIpKERWjxIbHZL3PpAacxKa8wL0uHsQpDvke00axJxWd3x5y8ybFpHfMmIfZysn++oFSegGROu3ZZkjx5UYfinmeDg0nJ9fevrvnvQXtuBFe3+WgQfO3tvTAq9YMeul4Q/rk+X2GFFZ4LJEHSktXJ7YLkhki74Bd//l/ya7/+29z1qlt49NHzNIsJv/3R+/iuZsarBhukaUQLCIbhxhrf+t1/AmNzgAjgrELwGBxKKU7f/iqMgc988kOsHzvG1uZpnnzgXtAGV/VRaIJEnDZceX/nsTDx8ff9R9Y2T3Drq9+AaHeo0v5SgJCFtXkoE5RWJB+YzfbZOn4Cu3TiyQF5ru115VibUmI0GnHT6Zv5zH1P4kNW8SlAiRyK5g6CZu89SoEPHo0F5UEnUjK86Q138dp73gzagziSZFeWKB6FRSSwWCz44Ad/lyQJDtqlsiOR0obCWUqnuOf1b0LrpcsLQiKiRRA0nZ+DUlg7BBRJ5iir88NmPEpplMoCZVI+nwd8qpQipReGv3M/rTj8+cOKw1dY4YuBFYd/YbDi8BcXh6/4+/nEir9XWOGLgRV/f2Gw4u8Xlr9vODE+m58jdJrF/kVM4Vg/pfi9+36He3/3Sb7l676Nk6e2eeDxlq71tFE4vnUbSQYUdojWFaNBHzGG9VRgR6e5ffs2lL3Axz/6fmzzFrx6gPvO3k9vNuDETafoD/uc23+Y372/4l2vfROjcg2lsp14XomoQS0v4uV1/0KqO662mMmrw5s21331PisgDpQY3ueEq1IGRSTEbH+uyf9OfUMSS/CeFBJOl7z05pewaAIhCs18j73wNKmtKfoVShc07R6mUDzx2BlmE896v0NSg0STaxw7R4qB+WxCU88wYvG+YTbbp/ENTT2hnkxJC0MXPF1TZzWINYzP7RIamDOhKKAsCpJWTEPN2nALbyqK0tAsxpAiZVUSmpamnlCUJSFAChZtFJVztG2kS4HJZJ/YesQW2fpHK1AaYx2Scq11JYogniQBnTRdJzhXomOi62rKskKh8qpPk1d3piRLJQkocq15Sdl23ihNFzrG8xknTlVMJjssFg1dI+yFMeujHv0yopVCqwgpgTi0VvR7JTdtj5h3e3ivIWpSaGkkQYAoglPZpjnESNc0eaAQg5bcrqZtsmV2CChll+qeCFrT+Q5XFoSQ8kpZFCnmYQ5Aa8Ap6qajIzELLRcnNT0ZEtsIzmIVGAyVUlhjiCEQk2RxBAnvPYP+EI2j6zyGBuNyYhJhuVJ4wGw+I9e8D8QQ8D4uB48s+JBoiBJpmxoRm/teEvNFYLyo2RgFhtU6xrYEQMRRlY6urQkhYG0WgxhtSAhlkR0PFGCNozIKq7NwJHaOJBFtsxSq7nLt7I1hj65uqGctpixZG1pGfYsKLW2rstDExhwwJEtILQly7W2BXk/hAoz6ho1hD3GCsyWJSGkdCkU9nYMUdF3LoBoSQ422IGLwCKOBYd4Ig8LSdh4xilJrelW2gdmb1PR6GpMMlRjKBP1hhfctoQvs7zeElEB3JBGMUjijGVQlqQv0CsupUye4cHGf+UIRraYqNCkFmqamtDn5vT4aMHCKtZ6j7Llcf1xbiqJAK0VMgdApJFYYa+kPciLXunyPBDy9smTAEB8OHAwEkUiUlB0YUFhboKzK1yJCSJGqV3D6puM4VzCfL+i6lrZZoMgJ8aAiqsgWNISENQarNaRs2691FoiUZYE2go8JRBNDQkToWo9VECUSrcaVBS+7cwNTKp56qmFzfcR6X1jMhPWeZc0lQsoOGM4ZQlCApqgMumBZLkChTK6VUimFMrDW1xTDAU0Lzmh8FzDJE1OH6JzIT8GjEijJFvFaKwpdZTt/C9YYjBXKcshkvIezDsQgcamOEyGEiO9aIDs0oAsMiqosMUYIEtBEJObzVqgi2/sIhBgxPZMt/aeR6CJKF+jnccH45fXKrs+bl1unKS6NVM+87Usq80tK9aOfXdrmpQcBz6SOf6a23cA3b/B7z3a7z4Qr1fMHPbcKwldY4fnCpXm5YBToZJjO9nj0w7/AbW/8A3z6d/49D555GFsUvOT2V/PQExf4U3/mT/Mv//XP8tinP8o9r3gle7uPc+vGMaxTSAJjS4SUa1FJIGlFEofSCYnCePcMvf6Q177lG0ke9i88zHf8t/8LbrCGIqGSppClellf/kDw4AFolI56b5fitVtoUdluTl9St79YlepAVoKT25iIaJ0dhaqqx2Btg2XIfshnSnPkWWR+obWmqvpsb28jKeTPUhYOC2CUuUz13XUd1rmsWE8KgkKjsVrzHd/6Hoqyj0hWkh8MtUpnpbxSjieeeIAPfviTh8E2B01ZKtKH/YLbbtnm9K23ogzZQUrlMkOCQ0mHEotz5XKbQvIJV/SWT5xVds1KgtZZyX44p1cQUxZ4wvB5Ow0rDn8+tvtMWHH4Ciu80Fhx+BcBKw7/onP4ir+fj+0+E1b8vcIKLzRW/P1FwIq/X1D+vuHE+JotqGdTXn7Ha9ibzfjkB38Pt3YLX/H2u7iYnmTx8FmSlLSTx5k+PWHz5M2Ux27inld/A7e8dMb7P/QAXhTDY7fQ6w3Y0q/goXpCNx7S+CdpP9lybHuDeVL4aURXY3bamv2ndtneEl51812UboARhWDysnh4ZhncCwCRrHCIqWM6HtO2wuaxLWKco5IlxoioSOdbtNaI5DriIhFSIIhnb3+H5AXnCi7un8N3kX7vGFiD6AWyaOgbQ6lz4jyOPT4s2N2dcHx7C5nPkTrQzGcsFj2cVqQuUGvBh5bxuQsooOyVtO2CdbVNV3toPN1iQYei9TnptjEaUYbEVm9AZz3D0tCrHGiV7dlTtsRAElo5lGjCZIFUSyuEFOmaFm0UVgkKjVdC6Dxd1+FipCwtQkBi9vyPIdcplhSxRpFiIsRIklx3WSTXAkbl2gkkwWkh6mXtAyO5dkLKF31c1j1QWsBofIyUZUnZdZx98nH6/TUEGA0dIIS2pSUn340Fa/KoIeSkVFFohhWIBVFdXkGtND55vPeYRhEkoq1lOOhDTHjf0XYtXReIMVEWJSiLkBAkl1oQoakX2GUdhEQiplxvXCm9tKDuiCEyaz0Pnd1nvOsJoWO3sOiNgjJkAYS2Dhc6VCEYA02TEBWhiJTGZlsKBGtLQheQTnCFJikPydMrCnxn8aGlawMC1E2Lc2VeBVs4pvMF+/tzwNFJh6hE6jy7+wuCGPYpCHGXm09uQApoFVi0CwprSDFirEYrTVPX7M46vCi0SjilmDcda4N1nC5wRCR01F5oVcRqmHWe2azhpq0BG/2KwaCksAqtDFEUWsAvGgRISqGW205KITEhBmKIjKpBtrCuehgFikhKCaMNXePROrE+cFSlQWmF1gHlDNbqLNwoHdpadqZzrNU4bYla0bfCRq9H8IGbNgqKyhDWNdNFR1mWOE1OpkquBVW3nuleIkqkY5/SrKFSj6oKbPYLzl04R9QKo6BedKRmgXUVxgilM1SjPie3B+jkSU4xa1tOb4xIKS3rdGdib7saZWy2M9GGulvgrEMLmJQg5Xur7JUUhSHGDlqbr35lKPsFbZtLE7B0Xyl6DiFhtcH7DkkhO2Jg8ckT2gZtDEVZ5VrjqSaJ0MUIUdAoUgigVXZd0Aq0oigKJHWECF0XMZVDQoeRluQcMXhoIv2qwBWavcmMXmEoKxgvWlKKlBT4ZPM4myI2GbQkQquwWhhaiyaxnxbcOioY9g39YQVdhzNumaAWlBR0KYtXkqko+wXaGOJ4RhcjSSWc0xSFRidNag2+jPRGa4RFk4/bGEQllFUoZdgYbVCVJXXdkILPn+kIWPAx28HYTOBt6xkMDMFHkkSKnlAEzYW6ZaPTtD6i4w3T9VW4lq3atYLEzzUZvPIXR/WV16pbds1tLBWDl7/37LTjV7bzcynir7kNbuwBw+ePo/29wgorPL/IUVjQYGKicIZjd9zDg5/8Vf7dL/wKY9/nr/7YX+PRRz/Kb/za+/mmr3k3f+0v/6/c97u/jXKOm1/6VowuSKIxSpa1sczSWi2PuVqym5FY4eRtr0ORmO49RW+0zcVzj0HXcvylbyBhUVqISrKz0TUeOAqJr/yq7yYTLEQlGC2X3Mle5FAHlmVJyI5pQgyRUydPgXZwEExLQmm9/NuQ59iyFBAbBoM+r3j5HRirCW3uI2UUxFwSSen8AFdrTdt6jEkkURidlmJTxS23bPLub/6WpVK8QiSgjSbFlM9hzH/f+6lPsT9eLOfh5rCNWhuMVlgD3/t9380r734DUQ4qgcbl/D0L/EQ0YFEq0XUtzhmaeh9XDHjyyYf42Mc+znve8+1ZYCj68LyHEPG+wRXm8+/3q16vOHzF4Sus8KWOFYd/IbHi8C88h6/4+xrbYMXfK6zwpY8Vf38hseLvF5a/b9w3wK2zvyjxcoz+sMegsPT1RSa7Zznz6BPsPTTm1MYJ1rdOQGFo28TFM2eYLD7KR+//NLfd9HKOH+sxWL+Fxiz4xLn3M31qigsKozruufv1vOzlpzm2fpxy3SFmDusPs7Fe48yCneZh2m6KUgZ9cNKP2L584dQd+c4Z7+9z/vw5os+rw733xBQQPL7r0FrTNFO6dkIMCxazPep6wnw+YTYZE/ycnYsX6bljGCr29y7QNjV0eTV6URm8r1Ghw4eaumk4cewERmk2N9ZYH5Ukv2C2c57JxXPMprt0swlxXudEfIjUkxmLyYS9C+eZjPcZTyZ4H2nrgFEmWwinhBAoC82p4xtsbg3pDyuGox5aJ0gNTb3DubMPM5vuIiknbiRGIIGCGLucwI+RGCNt3dDUNYhQlWVe1Rw9LOurgxCXlvPBh0N7g8MV34CSRJJESjnpnGu3B2L0S3FC/gzJFuQgOVkneR8xRqqypHCOerFAJFI4k63Sq5IYAvP5lMV8xmI+oW0WpLg8h0pRGEO5rBOfRAhdIEUhxrzPuq4ZDPrL1a7tMjHeISIYnVf7KiW5trBSSEo4k4UObdfhfSB6D0mWKXmh7QKLRcdi7rl4dpfF/gKb4Ph6j0pHYhtIODAWSQ0paRZNYG8ypWsXVKUm2oN6EkJKkGJuAyTqek5XN4SuI7QdRmkW8zn1oqVrO5TKthNIomsbJAqlg73ZPk9e2OGJp3e5OAlM2zlra31Ga5qnLlzgiXM77O0t2NmbMp4sWCw6QhDaJh/nbAHjWct41jCZJfYnHpRlYy1yettx4uSAfmkYz2vaOjLdb5nveSrt6BUOTUDpFp8iXUwkwEvEOJN7TgRrLXVTM5vPCZIIkpOZw7UevV6BNQrfLDBESmcxOoshYowMB32KwqEgCxW0IknCWEOvV2Gd5dTWJmHh6drEoGfweHojy823bHDy9BrDYUnpStb6I/qmwOb1wKhS0+uXnN7e5Nabj3Fye4MT69uc3ByyMVBsro0YDjfpPDS1z0qwlFgbjRg4S6GzvcjAWmbjfSoLfp6PI7RNrg4fYyYp8rlO0aOVIgSf1W/L+8VqsyQvRUqBEDrS8r6SlEgxEGM4LAPRtB0xwWLRAAofcp1t7wNtF6gXNRIFaw3OmEMVW1EUCFm8IiJZ9ELKZRYKR0jZlgUlGFst+9mRkgJxSAQJLdZYEM1wYAnNnLrtmNeJvZ0FVbTctOYoqxbfzUE8lbUoaSAGjGlBNyjrCYzZOFZw621DUkzMxnNc4bIdvAvYQhOLgNiAslCUdtknAWUE6xRVYVFkxxJX2GWcJQQf8DEQJObENwqtDVoZvPfUixm+a5AEXRtom0DrIzHmSZtRCqMMMWalm9V5bb9VjpuO99ks++ztJKJ3GPvcE+NXBr3Xsky7Epd/ll9ryBNNLg+r80TtGrNKlceiy9txo/u8/ufPHMQffPbMSvz0LB8E3BiO9qvi0hTrSvX6i1iNusIKX1LI95MWBaLpmpb/42//OOXgJt76Nd9Glc7xypcc4+Ks5i/8+T/Lz//Cv2c22eet7/oayv4mqnQokwVceVhf3sPkuEKJIuvOsj0ZOkcg1egE1lW84p6vZ+u21yDopTh9+Ztr3ONKZVsztMr1R9AY9FKl/iWgVAeQ/DhBdBataok88fAn6A8Gy/VMGqVk6YKXlmF45oEDNb7WoK1lc/MYVtmlKFGjkqBUXM6Js92b1joLaQFJuQ4dS95899e9g7WTt5KiRyVBY0kJlBaUDmA0iOJX/+t7iVEO57cojVK5tE5VlJSFxpkK6/qwPHcpaQwWpCDGREpzYmyQzqNtQkTz4Md/mf29MxxbP8VHP/hbPPXU4ygcSSkSGozCmAFlMYD4+dn0rTj8aqw4fIUVfj9gxeFfUKw4/AvO4Sv+vhor/l5hhd8PWPH3FxQr/n5B+fuGn7TvTC5w0x23UKz1mVwMGKN5+vH7OHb65bTKsLEVmfoxYgxrW7fQqY5eHFJPZjx07hFu+Yo3s7m9zhOPPEnrPFP7APVszubwLmaTQNuf8/T8EcTeQl3P+MqXfS2T3iPE3qeoixOU07cyVh11t8t6/xjZpVmueeE/3zg6AVCKZbLW5xrcG2vE4LNFthFirFHKEHygqSeUJq+WHO9dQBtF6ALtoqYYbSAsOH/+ASQ42q6jns/oV+sA+K7FkLBEFs2C5BOqBxDo2jkajw6RbhHJt7ZGymx/7ozBoAlJ0AKxa2m7SNu2hOBxylHovBq7Ki3WQNuG5Y2j0FbnmrcefBMRAWM8fjFDJJBSR2o0Smv00nI5RE9KObnYtW1WnnAwFVF5VbTkGtpGm2xpoJbJNJVv2iSCkpRtEiQRQ4SlWiXGkMcsowkh5KS4MjkJLNnCPEo6TJrDgWIFrFV0dU1ZOiAPBrJMoIeQiDH/LkWHAM4pepVh3DZ4Skie1AaaLltWhBBz0lGVdF1LsdyuIq+QZlk3QUhISJeuIRGM0jmR1gWUJLTNx4PKifEQBR8ig17Fba7EmZK1oWHWNMQYGRQGqyBpSzCRnf0JJ9YHrK/1sEWRrTCsQhud6xuLWtb7DqQYSMvkXQiesGxbDAnjDMZmdY8yeunIkOhXhi4G9meeQqllSQBD3Xm6oCCAn0emtmM4WsOYAoVBYiQBAY8i10N31uGMorAF1hkUljoKhQR6axXHfQda48oh5y80lGVEp0D0BWgLOluxR99RYmk7IUVAK9q2QatMaItFTdt1jIYDYgyURYlVmqgFUsCUBVo0WpVUVUUIAa2yRbbWajmXVsSUr0khUZUFm5vrUHpQnvki0SwaBtZgnUNrKEtLWRgkCVEskGtnIwlloOgbbBc5sTnEGYvTNWIV+9MJRVXSTBq0Fo5trbG1NmAwXGMyHjOb76BU4tTxdaqyRAXo9QuMVgTvAYU1FqMVhXMYa1AoYsgTDQQKZ/FdolksnSyWNbWNscQgS2UZpBABtSxzkFAhoo2hbhqqogRRGGPpfIugSD5ijAKT0OSEekoJpU22jTeaSAIlsEzeK6shQViSdYigtCGkFmcixpJru7s+s3mEIkFSxGhZ6ydObCqC76ibvM3RSKNVx6AP+3stqXUYDUpnsUSMgjYGbTSbWxt0TYO2GqsURpc00WOToJUleEUgoVUCHeg6n68DoLCaXuUwCD5BbLqlGMBgrCamhIRIEMFosETEZBGQcQMUhiiSp19aQwQl+T5BGWKK9MoC3bWUtqRfBdZiRA80EiOdf+4c9uyD8Cs/yyPcs92nZHngDQXT19v/51LBX922KwPgI5/IpbZopV4A/Xium3NZG64pQ32RT7xXWOFLAJfbRQpBd3TtjJfcdoJ+f8THPvh+/tif/As8/OmP8dHf+yw3nXgpXZzy9Pkdnn7yIe7/+Mf5+j/4g7jBBsGBjQrU1XZqIss7dhlUK7O0FBN1MI29TJF+EJdcd9w98uel77xQvfQ8Q4FeDnFBaUKCX33vb/D1f+C/WX7hivGPS2/L0ZhNoCortNG5RlrKvJmyWdRlNp8HZXkO1OsinrKAt7/zXThX5IchOj8wNqIQsYQgaBXY2XmE//RLv5kbLnJpPBYNOlH28pyv6zxIQiQgyqJNog0N0XdcPPcwg+EGmB6lqpAUiXhe9rpvphysAY6/+Ff+FtoalKpwOtvRKRWRpFDKEWL6/Lp9xeGH+19x+Aor/P7AisO/CFhx+Becw1f8zeH+V/y9wgq/P7Di7y8CVvz9gvL3DSfGt/oLkmmZxjEXzu1y16teh16vGT89Z+P0zSzinCc+8HFObWxhRj1mT014yUtezTm/Q713kd964P1snjjFaL2H2YFTN23x+MTw4EfG3Hz6NRQzxy39bT45fZKeW2fz+Ev4zJnHsPub3D99mre8pCT6ERO/S8/1sKbHF4XY5OAGhLIsAaFtm7wCU6Bp5hSuBylRGmjrBU29IHYdrQ+EENjd2YNUYKyjmwvWZKXNYr9mJg29Xsl6v8IT6UrLqOqxkAZJNW0zxyAUBlRSqBBQhSFJQi0TxtYVQE7kBA8KoTSKDoVzlkG/JMWEcyVVVS6TywpzUPtbge8iCkOvtKAjRWnRIqAcXYgURmdrC4EYfO6TGJGlaCDnFw2gUDonWmMIdF2L1gZr3WFyWiSv3NVKgyYnvpfJasUyWadBYiJ0QopZRWRMrgvO0jIhixbi0lpaI5IIIeAKh3aalDzOumyzoBUqmaWNQz6hMeZV6iShQCF1h583aK1o25auS9l63SpEIkendN77nMjXipg8WiW0KVEK2rYDWCpxNDF6nDMo0QfCKBZtoIsBpy22clSFQlsDxhBbz83bA7QzhGRySfTYYSvLYHubXk8jFtqY7aGd0SSJ2creVVlooMBaTewCIkIbEm0XAI34iE0Ok0xO5JJAQ9UrSF2itCXrg5KeChgLIa3Rtg0hFmwVfW47sYaPkVnTsjsdc2JrE4kda+sDev2KXpVABbSx2OV1Y4zCiYIukQpLW7d4yWolqyK9ytCrFCKeqHR2VokGozWKXK/aKEXwAWtdJrSYSN6jYJnEzf2ttcaHgKsq0JEkKde2BqLPDCApLZPYgnOONnQICuMc1ihEFWxtJNbXIrOm4+T6BooAusgr2UPEKE3TzBEMKI0xmX5cUVBUJQUFrfeQDAaFU5EmQQiCtDVaCdopjm9vMtub4qqWpp1hZUAbVF7xHT3V0KKSELuOiELpiFIu32c6oSXf84VzxLZd9pVgjMWYKivJRHClWyq48qpzq7JDAkv1n2SlQRYXLC3lTRTarqHX69H5mK/5JWl23hNCoHAlQQARJAkiEEJ2bPApOzCY0hCioqlrrK0Qn0ss9KpETDOSWLw09IcFnWoYDSO3JKjbhrmH6aJABNbXO5TyJK9QtKwPS8bTgFEWlNAGjUTLYpFwnUKbFmcCqJKYFL4VOpVIGHzXURaOFDVau+x8ETz9qsQgVIXOq9NxKCnztag1IQW89xRliTYlTimCb0khoK0mitB1NVEUojWSYp7QAWjJpSQEsNk6qCh6NG2NNgqnYWe3xWnorw2eM209nwrIawXJl2vSr/rF52zHle8f3cezD+Q/94OH623x2nZ3zwZHJ6RHVfMH/36pzLxXWOFLC1nYadk6fgs/9Kd/lA+/77cQo3nVXa/nR//JP2C+c56mPsfs4j7/+B//P5QucOepOxiMHPe8/dtZP3UTqAKNvipCPhqc533lKDAHXuR56JXtucGx7ksNOawWEtndyUfP4/d/ms3v/+Erjk0u/aM0kg47j4MXg8EQ5xwmdBCzCFcvA/Tcr/pwm3H5eQgKoxW33nKcV776dflcLMtWIYkooJThsYfvY1Ev+Pmf/zeM9xsgopTKNdeWLUgxK+ibBh5/6iGm4ycZDE/zyL3vZ1iu4fqaot/j2MYtqKJAqQQ2YqVCaegAJQaRmqoc5vpmJpJQS5EuIFlxX1TV59XvKw6//PsrDl9hhd9fWHH4FwYrDv/Cc/iKvy///oq/V1jh9xdW/P2FwYq/X1j+vuHEeN0Gzn/qkxw7dQevfNMbEFezVr+ck6+AOgS61PGSl9+D7E1pWk/ZX2Nn57PMHn6S0Gp0ug+rKjZvPc3J428iNJ/l8fln6A0j0c3YPPVmPvbIJ3Lip1zwXz/4b0nhbXzbO/4I0/pJYjrGTRslSt2KloQS9UWRdxzaA/uANYYQPVE6fLfAuBESOhrf4WyB9x3j8YQUA/Vsznw6ZTqe0+uPiH6BBMWo3yOmlBOGfUNIUFjQRJTJCVitbF7ZbRWxyxYErqoIPqJdXh0sMSeUu85ji1xL2yiDsUVO4qZAYaEserjC4n1OGEO+Z4zNq6VTzEnCbMuj6FUDcJLr8BLpj0rauVCobI+AViixGBGC92izXDENhwmzAyVPShHrNFrlmzp4v1Sp5P2FEHIyTSCmRNd0GGNQThPa3B8hJkIX8nG5bKEtkm/SJAlIkGKu97tMcorkmhdaWUIICArvY06eJ00UQAtaC74LNCkxqVvO7E4xzlJak+0knKZtO7RO9EqLUlC6gqZt6Lour1pXEQUYmxPz3udE9EFy1pps9ZFiwJiswEkJQpfQyaKsQRWa5CPOWCaLBVYpRDlC6PBdJIkFbVEqUPYcRgsdClEKHUO2J9IWpSH6jkjEFcUho8SYjvR1trgO0eOjz/XLtcIajRVBJRgUlsGJHqNS0Sss+/MJ41kB0nLbiRM5GbnYR6KmZyq6doEtNF302KiJwdAblLkPKbLVvXQsYsQaiw6SE7sExEe81yiT6DqPVp6qdMsa5iCRZfJW8CrXqY//f/b+PFqy67zuBH/fme6NiDfkywGJmQAIEhxFcZBETZZEjbQt25JttcuWy+VBll292tV216qy7LXsbvfqcrldq7zc3a7lquWaXGXLU1mmZFuWZFEkJUo0KZIiRZEAB4CYE8j5vRcR957p6z/OfYkEkAATJABCVGwuMPO9jLhx4w5nn3O//e1dzTQXVrxrxV1jhZQSXZiTUwSFqhWjgpbccje0XcKrcSCEQBwLbrIRVxFUlKJQh0zSzFgGRIQCiLZi82q9InQeVcOQQW2H1BYzIK6nOkPGUCfLfGMsq7Hgg7C901EPE7UkFp0hDoYw61mtl1SUVYyc3NljWGUurS7gygI1Qr6qiF8VYozorGtdywWopQlLSiuSWzcVzRGMEVI6ijFozgpNHNKs5VWbzXcqiSpK13mc9eTUIgycMYTgELEohlqULoR2/atiTXPLqCKINdRSJumZTK9pxi5tjDAYE3DWAAkymKoY7ETkY8vuJqJeWJU11oOPrUAf5hY0kMuINYFSLGIAFVKKeGPofLufDpeFKodApFjBa8FYh1h4/JEl0fQc23b0C6WbAblg8Zh9z+ULK7Z25oQ+EMdEHhKLbY8g+BCIpYlxcqzkukTVtMx11xFLQsW2cQnXoiJMiyxYrgb6eT+J6DJVIWeIRUE9JiQWxzp2T85YHqyb48GXiatV2k/hhfJnU4Vec5F8ze2/+HihOWjXes/1LMi/YsjRBz3/Q4OrFa4bbLDBC8fRAzyhieAQWOye5Njegj/4h/8wF5/4LJcvD/zYn/4TvP0bv4Pbbr2LM489zp133UU8WPGWb/4W+nmPqZNwjmtnTD01jjSuhKMIpxe/5+UVjTa5pxqwqbB/6QL93LF3YounBj55SnHeZP7XWK4Jt91+Ozs7Cw6HVYuvEVAVnDNXIpGOzq+1lpKnSBaBV7/6Vdx4463opDCvxaJY4nrgAx/4af6zv/iXWS5H9vcPWI8rkIqqYPDolF1mraClcHk/8fBD53jfv/0nPPjgQ83RRw0/9Kd+nJIF6yuzsEsVRaxCmR5MDCt0MeNDH/w5br35bm579ZtRzSDtKikFjG2fq/KVW6lvOHz6+Tlet+HwDTb47YcNh7/M2HD4y87hG/6+6ufneN2GvzfY4LcfNvz9MmPD3y8pf193YdybBdUteezhL3Ly9i0evv/z3LjzWhZbW7j1mlnwPPjIAXfefjszN7KVlCcf+jQle+azHfI4cvbhL/Ldb/0e3vTGXR544jYO9s+R3tLThS0ePfvrnOgMs70ed8JwKRXuuenVvOnuPaLu4sVhObKodjTNxHSNvMTEdrVyrnWggvMetEwFxchydYCbz3DWklIkjkvG9dgKbFTyGKkpszWf0/U9netb7rSPFFFWK/AuMPdCrYUqmSAeWwvr9SFiHcaAtw5yyxSWrtlfpzRQ89RZXQs51lbgEgficN41m3Jp+18y6GS17pxgxIFTxhjxvnWyl5qa5bEIWgU1UIrD2x4fOqxaik61VmMRYIwjUqfzcPRvKpRUp+zvghz5P1DRFkQwFYamLGJt+cPjMKKlEoLDWTd1uTb1irOGWgtaW4GpFXkF5xzGO6xzxNS6540VVC25lElbBCmVNlCYSq1gZbKFN+CMILmS4xrNERMTzgh4SyyF1bjC2o7OW+K4RjVTrlInlpxxxhBjAVOnQanZcgfvMCKUHFvxFUWMI6dWoQ3B4Jww1gEjhVoMWIsJjqJgxWHEElMm6xonEykYA9UhRSkm0tmOmKcM+KrNIrtWSmyZ5nmMU5Z069pvHhjt+MYU8c5hrWEYBwyOE8fmuM7RWQcpc2xnh9O7gC4wvWdUgRRYuEqsGaxQyORSWK3X1Nxyrr0PFJpFvhOLsQpm6tSfssPVtuszeMuwat26Is02JNUEtSBiCT6Qa0SskGpp3dTO4BQQbeox44jjgPcObxxxzKgVjDfkyaY/5sRqvSLVwnw2b3bYpSJGKCJNNJDa/TSMkYPIVCSOaFG2t+a4NOJNy8P2wZEmAjEKcRUJXSA6QJvdNraCCdSsdNbQOcdQFSkOawJaIZXKdt9jrWc4eBwXCrOdDskZo246X4JzHkQYhhFnpy51sfjgW8Z7bt3JxlpyilO2eEbEkkvE+sDycEXfd+36tA4xloJhvuWxosRxaCIShELFWksaE6oGHzy5lHY8p7FYaHEFLd5AqSjOdWgulDq5KoyZNNmaqASCBdclOjdgisN6oeY1ae2YH3MYUxhrxnuPaGYxX1CdMgxK18+xNjMOUGvr0nYu0M0UqYblKrF7bE6qljgOGJeo2VDUcPlwxanjJwjBE9eHmDTdD0ZYjYd0M0PoO7yDmiLjGNnZ2cZ3bQJQRMmqreM7F1SbRX0tlWoUNDHrArW2sdH7QK2FMY6oCrUYQrCYDoKFYbWi5iZWUDLiLSUesuiVCwcvHqc9tUi/enJ5bTzNyugaL2tiEb3mRPYZn8q1FqkyjWNXL551EqC92IpPfa4v8aLh6FgdWfYo157iPx3P91032GCD58fR+KFVsQi5wuu/6Ts5d/+nmfcL/tJf/iv81Hv+IecuH/BH/vRfItgOYyoUR5GCzXHSX3uE5x97pk+c/rz2gvxr+V6eksZQBLWBz37mXvzujbh+axK5TsdOjyzbnnsMv/nmG1lszdEn2pyp5rYGYNqGmURktbbxtNJEZN56Xve6e9g7eQqknceHH/oCv/yB9/K+976fn/uFX+byxYukqhSaqE/UAgWVMmlE23zp5ltO8OSZS/z8z3+Q2284xZ/4s3+aG265kc9+8kOMo+XYzpyLl59gfuw4Rh1FDU4cRSL94gTZCG9967uoOVJIjV9Kaa5Z2tYS1s1B7It6HjYc/lJhw+EbbPByY8PhLx82HP7V5/ANf79U2PD3Bhu83Njw98uHDX+/tPx93YVx42a85Q3fzHKIXLxwwInuFLuzLbZO30wYL/LwQ5/AR8/+sOLC+TWnbznJfPdmZmZBd8MxLj18iCPz0S/8EmN4Dcd292AGx2fHuPOWb+Fzy0/wwANnmekpwsqy7U9QzJohC/Pet9qdGEwtk/20TJOEl+fivzpHQYzQd3NKzpQyktYFLzOyNn98wTGUNTEuSeuBYblEEPrQs7XYxrqAsUxdy560HjE1Y53HOgfYqbu6WZE7Y0ArJY2UksC028JohTp9Zm5d1y44hhhRlVaEqpmQ22mez2fUKs0S3Cqaayvwo3TzGTaMeNNUJVIEMRWxBu9a7nXUQifa8oNTJceEFqWq0np4Wz64s7Y1kzvLmCJUbVbv0qzXqaCmULRQk51u76ZOyTE2e+aquK7ttypYYzHOEmNsxXpken8rRNdssUaaoqVUDELJCZFmK85UoFMVFNs6lQ1USQgZazuscxgxqDWcNNtszWZ0zoFt1t91SMxchxeDNZGcMgbF+p4q9ajcT0xxys6JoIIRi/Etm7wVDAXEEMcIkikK3Sww6+aIqTAWcm5W1nNrGcdIMoo6SyqNMJwYghGCMe3YUSh5wAVHpZDigBWDGteKvCVBrlQ1GBda3juVmDJjye28mI7gDCUrqxoRzXQzi3eCrZC1YAz0Ygi9bXbTsRKHgVQTkdoKk7Ud66QGQmjnYCp+W2fIKYMzGLXk3K4Zra2o2Iq8A7tbW3TW4I1ruew5N7GFBRs6Si4EE0i5WXeYzpInC30xDu8cGtckrXjjSLWQasIapUSoJVCwPPbkZSqW436yGVEogLGWGltxP8Y1MRYu7kcevrTPiZ0tTiwWJEZIFeta9rntQnOUKE3AYUQwzrQM9JiouWLcAkcmpYFLJWIlsLUVGC9nZh3E5T5VHZHCmcceR6Wy64RxgLNnD5kthC3n8CHgnEW0TnngSqlCFzpqhcP1mlqb4CKNI2IMoeuIKWFsR86FlDNxHen6GalmxvUa52Ytb95os90XEOMpWpFaES2kUpptSqnEXMkpI1XxzlHKUWZ2E4OMpWWIF0aaZkJYrS/hbcAaCKESrCH4iBCp1bFMlW3vmS2gdgXnArmA8R7XB7adsL8UDiM4YyF3rJZQyhpjWvY6paBFcV6geixC0QGx0PWWnp7lKnJ8Z4fO93gPi/mcnNv4hhFCF3BGWUclS2U5LDlx4hgzb0nrkazgeyENCcQhvkM0IkCpiapKcJ5SKtZ4sIZcC0NM5Nr0cjYnjM3MtjrGuCKnRO97shmp1VKGkd2dxOFBxtqvzIr1CE+fcD4/fz7blkeuWqTrVX8qKvK0rT2XsvyZ73/m369lE/el9+2ar7jWm65rO1/JvEKf64ev4Yn6Bht81TEJ6FQEq5Vhtebf/LN/zDd8x/dx6603c9vWNt/2nd/XbMJo8UFiSnOqsUI1gtW2vpDneZD2zPHrmePV1/KCHGjrrypYhKqRJx66j62wDSqTK85VPDCtmZBrjPsK586dZb1eX/lZrqztnrJxO+KrUiuowVoIvud1r30dRgJC5kO/+gH+1t/8m5w9+wRvf8c7+JP/8e9jZ3ubn/rpf8dHPnovIpNqXgVkms/XpiaPA/xnf/HHuHjpgE987NOYsGDr2K2cOnEnfd8Ttk+x5zxK3+Z0UtqDAHWoFVwt+PkuVSogmFKoIqS4xoohjmsC/opD14tyDjYc/iW3s+HwDTb4bYYNh78s2HD4V5fDN/z9pbez4e8NNvhthg1/vyzY8PdLy9/XXRhfLI6xdeMCs9rilv5mcjjgkx+7n8X+RaQb6OsObm/G+UfuRUZhuXWICR57Yg8tHr+3jVHlsYce5Jb5KW542zbzvbtZ7icu2PvYrxcYzjtmN8xIdcZiZlnMnuCD9zm+8/WvY+YhScWLawqIq677l/MmaJ3LGWOPLKlHSh1bNq1mahrJY6HvPdEYNKU2UKB0s4751oyYFeMM3jAVby2LeYezYdKBVGptmdvWWFSbgiOXTBxH+n6GADlFtCo1N6vuOCYKrRizWq/IOeFdQMTiu4DxDooQxCOm0s/neN+R8oj1nt5CTmOzTHAWKripiN8HQ5VAXA1XiuI5JUrOrfA6dRxbaV22YdZPXdEtv7jZpiveumaDT52KembqEh/QUlpBWZWuC1SprYP7yAKiVlAlpdy63YMHWl44VhnHliPQsg4s1rbuamtoXdVAymXqXDcYaQXyUgulMhWZLaXqVNgEptb3UirOGQztphbrsd4zrBKGSNFKTKm9TiY7ea1Y41rnelXUNAt1mYqKqmCm4i+m2bWjmVIKXRdwzjEMAzVX/KxDq+Jd+87OGTrTOvBTGkll2tXSjqVV6L2b8iEgl4Kqad3ZaPseQLCW5ZiJQ+RgXHLr8R1WNeOzbdnKtWWkW2MI4ijOgHMMsSImk5O2rnsXkDyCtA5uaz2haznQOUcQQy4VoULJiLEIgVya1XxJmVomu3FrGeLAfB6g5iYCMRZrLLbriCmjpTLERDFK3wdKLa0QTCNmVKmlqZzGIVNzUyilSUBCzSQd6GcWrZ7OdZSsVFq2e8nKOO3TkJTL+2uWg7Lwcw6GAecM28GytdVTxpGxVMbVCudg1nV4H4ipiVhyzuhkR2KtRRC0VLYXCw4PV9QqjOvYsrnLlDkuguaMUgm2Z3fPEjRTUgehjSdVFGm1fFLMLdZgGguHFLHWUaXlfVhjmtNALmhtOeJd1yG5WaXUEtGSGYZCUfDe0oce790UXQFaClkU51qXeBO0NCJWlCE1hwxjHRgYxkwpQskjl5dn2Tt2kuVhbo4f1lBzpbqK7WC1FCwGayvWzlEqzs0xHnJO5NQcGKCSU2m573kkzD3OFYxMwiBrmmW+6bDGIQS63rEeRoiB0LX3mqLM+oB0AVFDYcBaQ3BzCkrJa7YWgYP9RCUjImxvb002QcJsa0FRIaZC33m60LNerzEi5FImkUDrzjeqmNCcRLJCUShaMdYiUpv1zDBijKMyEkts0Rgl4lwhJSVHj+YjBfQLx9UL8SN1OJhnLNCv/b72HnPNyeiVbT9jAXz0mqNJ1TMXyM9ckF+9D9frAPP09129+jXP+PkpyDP+5Wnf4arj86Xw3PvY+Kr9cwVpfI42O32BK0pJpImBRAwg6OS2otA45ks8MNlggw2egkyeQIpQKXhneee7foBTt9zC1vFT/J4//n9j59gNWBPaOD5BaeI1i15ZFF5z+8+417/WF9/PBWkDFGhG1HLu8JC7XnMjVo5Sz+SpMe4Zzl5PHbMKRsl1ekc2ZE0I2sSp6NPe45xDJmcaVU8InpOnTmJE+OIX7uOv/sR/yfd8z3fxJ/70/4Vje8cwxhJz5NHHzvCxj91HoU48ZREKwXtiLMzDgltvu5n/6I/8KDt7N/Lf/jf/FT/xEz/B3/x//10Wx7ZY7Oxy78d+hYe+cC/f8X3fy5CU4APOtnl41UlY3O+AM4ja9sCntLlZdUAxfOHTP8etd38Lx/bu+LKP+4bDGzYcvsEGX5vYcPjLgw2Hv/wcvuHvhg1/b7DB1yY2/P3yYMPfLy1/X3dhvBpLTIXOBsKpLb740Ge5fOYMJ3fmnH/0CXTrVm59zRZnLi45ePICb3/NqylUDg6W7B8o28cddTzgxA0nOCiX+MSnzvG5Rz7NVt3jbW98F/1si8vHn+BwVbl1IXhzSDn8Ih+67wJ3nriT1942w2oFMlUcBvNVEn8JgsO5wDDGpt8TodRIKa3ze7U8ZFYWzMMxzK5hXC1b/rZpg0bXdyiVXFrLv7UO55pleGtaLS07u1RKyS072wjWOWQ0zTIdppzkimEqLufMGEfcfE4fHBIcoeubDbvzxJJBLdYL3WyBDx39fM7CbHG4vw9awYCxzQa5Cx4QrA9TXnElpRGdOp4xFiQzxoGiirUeY0y7AWqhVEUr6BR8D5VatBWDtFBrpWaa3fKUeS3W4JzFOQsizQpBWuEtT93BaKbkOh17cKHZM5SiKAVrO0otpFpxLuBdyyxPKaFVKZO9dK2tOK1qrxT2mYqrYgzeWawYjBWqKEYseCHnyDhUFrMZ3pcr34Vakdq6VJWMsR7RqbAPUCtV2wS31ELRVqA2xlBpGfHGKs62zGcB+s7jjMEaQTBkNYiphGBxBmp6ahsiEHyzz9daKdq6y0tOIJOVvYDUihPwzoJ1BGt4cursFQeXLi6Zd1tcLis4PCQAe1tb5BCQYtGhWdFba5swo51kasmk3Iqv1gmVFXa6SYsKw5Tr3nKkO9b1kErF+TAplSZSnYQZVQvB2ynjwmG9Z4zNgSDFEWsMXd+3/PaUriiRJmkUwvTjNIFOYyvQi7FNsEFl3gdyalbztWaKCFIKFss6ZlYHh6xXA8M6cbCMUCHsBLaC5/jODGeFYWzF+Ap0IaBUihasNai0wrhBsMaQc2rF1Nmi3ULOIjWzvTXDpYLvLKshs4ojmcpqyCxNZlkysSi9FmbBY5xgxZNqRnPBWU8qiZQz3roWh5BLs0YxLVuj5DLdf6aJWWr7d2pB1FDVMKwjVQVU0RonEUWTdSmC9QYVQ0rNSkVKbY79uVJqxXpPTopHSGNif3nIzmLOTadvQdTALFG1Ffz7uW0xD6UjdHOMFERXzGZz0H1izFOBWXGh4n0gpVZsBwguTNdfwXeGvu8RDONYCB5UE+tlxuQZcczM+hkuREQseZVAMikV3NEkTQuFsbl21Gb3bqyAVuI40HVzSskUsc0aBkettOOjiZIHjGn3a85N8IGA9Z71MBJb2ElbFCMYhVILkqDmlu+eS6VIwkvHGA8ppSeue7SuKenLL4xfewKpVy3Qnx/PtXhX2nUP157KNlufpy92r0eJ/mLiWgv+lw51+syJT9RMC+0pBkb9FT5rAsp2fYsRzDRGG2unSenvzEn/Bht8OThSOCuCcQ5jF3zdO7+D5hoE/fxEewDWpgdH04KrHn5d/0O5Z+J31AJdhCoVwRDHgQsXL/D2t3xXE+bpsx9SPvW2p46vIogqt91+J7s7uzyq5zDTSWkxInqFO44e7Fprp/k69F3g9A03gi38rb/13/DGr3sL/+e/8BMsdhaIOIom4sHApz59XzvnmqeTThPXjpGqhte/4Wa8N3zolz/Id03ZltIAAQAASURBVH//9/Kf/pk/yv/0v/wL/tSf/FFObFv+zt/9r/nMA/fzmY99hu/9vT+CDYqIx5hCronlwVl+8af+d77j+/8weydvRbCoyZQaMdVStaKlsLdzF53f+goP+4bDX57P3nD4Bht8NbDh8JcJGw5/2Tl8w9+8TJ+94e8NNvhqYMPfLxM2/P2S8vd1F8a3tuY8+Ll7OXHqDpbjw9z7sXsJa2E9ZNbjkgc+80s8cfFuzBq2tvdYFsvMCYUZs7kyKwPQ0e0uuBgPOB62iPuW2YnTfPrzH8MfD9z51tfx+d/4PDedeDU33fEOnB3pt+ZcODzHoxeOc8uehxrATl2H+uXfRF82potCjrzqBeI4EGxPHlqOtHO2edpb2wq9IdCF1vHbdTOKKmMaMbYVf7sejAjeBapCqbERuBEMhhwjiiGEDuvsle9bVamlFeFiypTS8mzn8w7jfeusrVAmQYOXjmpARTEu4GdzxHtiSrQ+4pYJHEJHrUqMA9YoNbV8dLS07HGg1PZfLYaUC8M40LmORLPGiGPEOY9znnqU2VwqqRZESvNP0AraIRWC87Rs6MkeGahVm2DA2VaQKhnnLMYoKpkhtk7O6gylKMZWvA2t4F2PJoAV1aPCsSEEh0hpeqZc0CqTnTzTiaUV5U3AWYNUoWppxVnbMsItHXFYkjSRy5pMpetnBG9JZJqxfEWkqTWFyYICsLbZnqu2Tndjpb1WBTHTtZNah713BucdQuvYrVVJecQYQ86x5b6njGJwnaM5SCcQi5HWHZ5ybpb6AloSzhiCb04EpRSSRlwnhJkBHKYkTu9sE+j5zLkniLWw6AJdP0NdQXJBMBjb3l+omMkiehwiRgzee0ptTgH9rKemNrgGAzkXgg+ICtYKYcq0j2MixUzW2izCjcH79l8ZlFqVccysh/V0r7Siqmptee5Ht2dpGc8lg5E6FaMLtbRjkEtBS8UHh7PdlE+fKXXEGuFwuYRqSGOehBWeEzu7rEIihIidB4IUjs09fWfRXDDGMO89sRTGYc1sPkNRUko437rmS4XD9RI1hpyVIY503mGMsLWzTdUVlx5/Egke1YyjIKVyzPUc25qTyprAjJ1+hpCpxVKrYr2nViF0HWXdMqZEBNE2pqSYsF3HECNeHM6HRn5CEw9YQ0qwXK+gNgGLRZA65aoPhfm8xzqHlkIIHtVKLoVZP0drhOBZ19S6tU0TnnSub9eCWKwVfCeUVAlOgNCOkcaJbB2wbsXiGqh5Tc6xuSsIKBYxSqmVXA1jKVRd0y+OkUtEnExZ8wkjYJ0hrgsprQmdwznTRESMoIZcwQbfCv3WQC4YNYxxTcrr1sldFVNb/ME4rphtOdBEVQd4irZrvU7OD1qUeT+jpEwumVLaeOpsiwFYj4miTMIjQ0sob/qiUvRK/rtxwjCsEZYY6agMONtjrLDYfnEzSuHa3HltPn327yrTHEcmjfYz3vfMjLIvZXV0PYv2q9/35fD+c235hSjVr37dM/f1aMHdFJtXb0uv/Fsl06JDpgwcKSAeVUHM5HggXzoT7Vp49v78DlosbPA7HnK02hahVAvGIRWMaZyn07119cPCZ71/g+eFTi41WpXV8oDHH3mUnb2bp2P7zOOnT/2/TgvyaZ4NMJ9t4V1o4522mCqkbdsY04R7QCkFY+yke1RKyRweDvzWpz7Gh371w/y9v//32D6220TCUulMxyMP3M9vfPJeKkedUwKlYkx7KIAof+ZP/Ahh5wY++uEP8v0/+IPM917PX/qJv8Y7v/Vb+Gf/7J/zt/72/8Cf/ZN/km98+zdQXcCbGWIKOQ9459jbfRXf+/t/jO0Tt2CsaW5FZKpajI6oNVSfmW3vof11L7dfEDYc/vRtbTh8gw1++2LD4S89Nhz+yuHwDX8/fVsb/t5gg9++2PD3S48Nf7+0/H3dLP/w4/fy6EOP8vBn7+XSxSVbi9Ns33yM++79DdbnLlOicvmzX+Dkjbeye+oYw3jAHafv4ezqAXaCwdfC/NQNODwHT5zlVfPTvO1Nf5bv/fY3sOgiq8NLfPTRD1HGT3MxnOe03+PrXnecmy4vOb69w7mLl7m8chzvBanC88QPvLSYSFRMoZRIXB8yHF5E3RaGip0tmM0W5NWavlswmpYRrqW2DGMrSNW2/4Up13pSURiDFQtFm/00NIUFoLUyrof2K9MKMmXq1i21UlXpQmDed6QUcbZ1DqcSQZvtO7TO6Zoz4xAQ60gptg7XOmU1G8ulS5db87gWQrBXis1ChNqsl5WjbnChVqELASemFeSmoqla125EoORMymmqPRuMLQTnWhf0UQFZAGn7GbynVNrniIIxGHFAu1lDsICSs5JiQh1YtWho3fPjmFAVioIRh7G2FbyMobOWFFMrVtfJZkhqmwxVqFIxFsaY0DQNQqLNjttYggtXCvbOzVilNWjr+BRp39+IpZaCGmk2IYBY04QJWrHWYIxQSiuiex/o+q4VaUWm7Ru64EjREsdIu3xa16xSwbfCclVlnds5L2PG2oJKK7DXWqfO7ooLgdatX8ml5WKrCFIdO77nYlpx+uQxVinRucDrOMml1chhTSzHgZltmeBiDTJZ/YtjGiwNYi3BeZy1iIEQPH0IrFZrcqnMnUVp16ifvp/xjpQSJRvSZA2ecyZFYRZ6VA21tMG65DwJKKQJHmhjgdYmCCi1tmtEFWvaguCo+7nZ+kOuLQpBilJiocQMprkyWGvwtuV325mdiL0itRCCY77oOXPpHDedPs3uViBrmbYH1gq2KlUMcYiUskbEoCrMFlusD1dsz7dRgYODQzrfkeKIWuXysA8aOHHiFMtxoOsDtRQuXzpgPqu86sYdYgwcLlfsLI5TysCwHhHrCV2PD4EKWG+n/A0BhHEc6fseYyw5rgi9b/exc3jvqLVQtWBMK+C267QS08jh4SGz+RzjLCuNOGvpgiOPEcQSvMdagwRPSkv8LExF5EhMBRs6fOfZs3O2dxbUMnDyxElKhr7rSDkRh47z5y8zln26PiA1E2xpneq5MGawNmPEYrAYWwGPDQUtkVxWTTk3rQxraQ4AghKMJZQtkNgs/9eCMTO0WMacoMZ27ozSuUrOmeA9Io5xzNSacKa0jnIL3ihOWpRBKZluFkhjasfb2CZ2OeIHI5ODlzQ3hdoyxktJGFGoCR881iqlJFSbbU2ukUCg7+fs7x9gpRJcQd0a7xdoTF8+bT1jMdsmR8K1VOjP/p25rsnqtRbdz1SKP5cV3LU/9/m/zwuxe7vebb4QPD3f7WifDM2abYr/EAVtQi2tgriMkeaUolpZj5dZDSuOn7xx2qpBcO21L8IcZ7NI3+B3DK5c2m2ubaTNBVWmB4eqk1CyuabACxtHNjgaT5pgt9RMyYkyDFgTmtBVnine0qv+PLJ3YxI1t9iVrS1HLAnrFFXBymTtNp2bozlsewcT5yu1FD7wS7/IHbffzje+89uaqr2WK/Ou++77dQ4OViimzeFrZXt7G0FZrQZOn5jxtrd9PY+cifzahz/GcjmwMz9Occq3vuv38nVvfSf//Cf/Af/X/+Kv8P/4a3+dUzfdBaZgtGDNrD08MIWd0zfhaB1JiFImAauThHcLxrwi2F1sqfAVaNs2HH5923wh2HD4Bhu8grDh8JccGw7/6nD4hr+vb5svBBv+3mCDVxA2/P2SY8PfLz1/X3dh/P7PfY7zTxzQaWR37xTdwtLPey4//jgUh58FTu3dhEjP7Ia70dVDfOG+90OZMYSeWGGtZ3n0wbP8wNt+nBN3nufiwYKbdx0XVwfsF8sbb34Tnzv+KU4fv4sueAyWm4/t4J0jnJqzf3lAFx2CPTrHLz8UwLQuRrHkMbYCWx0wTlr3tWasaxeIOSr6GkNMCTWKWqFGbQoMEcRackyIAW8tIo5SEjIVSEtJUCopt0JMnuyq62RR7rxtXcq5orV1xaZhjbUd0C7uXDIq04UtQp7yl3Npeeb7ly/hxGAVUiqoKt4axBmKpsmWe8QwqUpEpuNvpi5hoeY8dehmigq92FZVroqWpm3U5iWOM5bgHCUr1hi8t1yd9SJG8NZRtFC0tsK+HHVfF3LOOOcJ3lHK2HLExZBTJebSbnrVVrwzphXqpdmTK60TXaQVXVuxvZl5tA78gaqVnDIWizEWjCXnghFPUcF0jrG2rm7vZq3IWBURSy2041YiJWXEOBCLFbDGXhmQji7g9p3NtGc0y3PvENM6sUUMPrSu+JIrxgqqFmuU4Np1lYYI3uDwJNbUnJoddClTQc9hrEFrIufWRa8Y1LTEh1nv8P0xjPVs2cBYR3aOeUzv0POXOTnfaeIAI6hM1y6K5oLEDGLxoeeovCqqWDHT92/fzkgrIIstiJdmo41O90wTZyhNChVcILiOYVhf6UB3vglIFIhZ0VTR2q5fVK/Y9Tfbjzpdq60jF5ooxFjXhBJG23Vshdl8jusWWN8hpXXEY6CMK8acCbNAHAudC3g5wXw2p0hiHDNjyrjgiSWRa8ZaT6kF7zw+BDDNekSsIeaEiDJbdAgGaztiHrGTeq6mxHzREVPLWffHtwlBkRCQopy+eQtBEfWoLVw8fxHnA95ZZrMeFcWKUNXgusDCW3JK7Rga2yzdjQXTSMoYwzAMdN4z63tyqqzWa6z3zBZb7VhSCc5iJOOm8WlImcV8B+8dhebyMA4j3nuMdSzcjDFmrHPMt3eYdxlvM7MuUec7+G5OiIXLlx+dOswtaZnY6nvicAHbFbzPVO1aRIEkxLRro+TmVmAlMAwF3zkEi8VTVUgjOKtt3HWwXsskJPEYYzHiiWmF5ojiKDVju9rGz9JcDoo2B4IhZowI877D2WbrL9qS1XNKoBVnDTFFxFisc6RCE3qUSowJULrO47wnV8UaAa1UHdGiWIFcJ1t7r4hpWVizfoaQ8MZTs1IkNiv6F4vGrsyOvpRi80uT7HPlcD1zkvs0G5/nWCi/3BZvLyZafg4cHTNtM0GqVtJwmc/f/1HuvOMdbC1OEdfn+M3f/PfkVNk7cRPH905T1TXXBW331Jczwbn62D612Ljyr1/hN9xgg1cw9GhO2h6IiYCZlOu1FpDmEPL0LpLNYvx68dS4UifVeJuXu2m+/uwOmy89ljvvOHZsATLZXIo0zueph7TW2hY3VNvcN5YWNbW1Pefez3yON77+NXgfKCU3UW4yOJv5tz/7PiZ5GkfLlfV6jdaKtZ4Tu7t84bOfR7s99lcj/+Qn/zf+kz/1Z9mazXjwi7/OyeM38mN//j/nxttv5+/8f/8ut/8f/4ibbjzNH/hDP8rO7g6r5SFhPufU7gmkX3B5vMRvfeSX2L+U+Nl/89P8yB/6/XzTO78HuwhYXyC/mGdjw+EvBTYcvsEGX0VsOPwlxYbDXzkcvuHvFx8b/t5gg68iNvz9kmLD3y8Pf193YXz7+HEeuu9+VhiObW1zuJ9Ih5cwtVJzRVLl0uHI1vy1/JHv/v38vX/6F1mcv4Xu9mPMZpEsC7Z3v40/8F0zPvbwZzhVbmJYnyfnOzi+teDBc0/w6csPchh3uXn27bztNTtgwdNsrns3I+z17QZ6lof+ywhR0JZHq3VkHFeICvMQWlZ2zISwwHZgvMWZbaiZYThE1GCNIQ1LNGcCBo9HvaNaRcfCMIyNkMWStRWwU02kMTKsR2azGQZpWdLVUKuiBmrNWGtwXlHjiNVhp6xqpovbeIeIkHLBB4PqmuX+ZfLYisDVCOJadnUwthVCUbQkdMrjFjMde21TMeMsMzvHSSbXdrN6HzDOopImK/d2NRqFvm+W8s3SBkLvKM1UGGtaHkAVWifzVITP44iqNpUfTQnobEBMwDgHybRimIEcI1JArEdtU8eU0sKzWy55aZ3atWW+O+cZxwgI1ReMU+qqMpRMSc0mXEngLGComjBicbZHS0QMWDUta9l04EAMiFpq59CUMbTjX2tBKyCmqamAnBMudJSayAW8WJxzrdgmDotFAecCUPCkaZLlcKIUFbK2nPqiirhmWb1/OFJLy0ZfuIzM5sRxiWKwrhXlUyos5l3rGDbA1BGvVSmxkjURHNxy4zGMsYwpY4JrnfS14oIlpTbY1VooOTXBwZQPn3KiDx3OeGytk8VFK96ilVIzw5AAS0wJYyzeN5HI1s4C4yxlvYY63Qc54WgZ9mKEMgxNMDGJH6yx7VwZsG5GrrXZdBulaKHm2LLaJ9FHqokRpYptZIAitnX6kzPihFmYTbkBkTSu6YMjj0vqUJuApChuZom14H1gtV5h2sBFpWCLklKmiiK+WXTXrKgkjGn7oSqY4FksFqxjxNnMOGSQFiuwXh2ixpJLwYkgxuK85/ixLdarA4bVAWjBeU+RirOerpszn8+4dGkfKYKlEkuzGm8aEoN1lu0Q0JTJwyFCxXeeMRa25gExlTQcYsqaiiWJwYil845gLSUJMSreO6xx5FSxXUGrwdrCbNGxs3eCjkgZBvJ4iVVeU+ucls8tSE50BjAWIwVDRY2QtRKsMBw41CrFVIIIvac5daQMOMaxYMcl6jtUDOorpbYJWcqJWhPYvolAxLEeRtJQWq68JqwpZIFu1qOSuXS4ZmdvlzRE7BTclTUhxjcXDaO4zpCLIcdCTgPWeWrJjDkRhzaGg2CMEONIFxzWCi4o1hRqWjHve9ZDImfo+4CqwwZPLoX1YUZzxniIKRGCm1SWXy2blKeg8JRVz9EkjWtPbJ+5+D76+YWqQ6+1iH8hyvaXAs/9UGGKrbhiaWNa9IOZsbN1A8PqAIvyK7/805TxgNfc/Sa2d08gNKeHdiyVWq9eTD8d1/re1zo+09+e930bbPC1AkGfEh2KXLFTbPZhTXw4rdE5ykLb4IWjPfBoDi0xt9wwsYYyqcqvft3ThiXRZ6zdDIJpzlFXupiO3vt0rjiy3Wtz+eYSlOOac09c4o6334yiLfaIihg4d/YRPvbJT2GNwTooRShZW3QO4Lxy8WCfT9/7BR589CH+4A/9Hi5dPMsjn/8Er7rz1SzPnsHWxKUnPs+3vvXtvO6/voWf+Vfv4Wf/7ft4z3t+kRMnj7N/+Um2dnc5fcNtvOXr38Qb73kD73/ve7jppht56JHH+cjHPsSQR77l27+fxx94gP2z9/PW7/pjL+WpuS5sOPypz7/27zccvsEGXw1sOPzlwYbDf/ty+Ia/n/r8a/9+w98bbPDVwIa/Xx5s+Pul5e/rLozLKNx4642cefgyq/WACZWVena843xMxEOLzvc5tRf43IUvcHA+cOrUrey86gbswQGj28MtLhP7JbPuEzx6+Ah7szfz8PIC/arn/kc/y/0PnOGmvbsoM4MT27qaTcsjEGTqtns6Wb3cRKPabuhSWu50SpmumxH6GUUrtp8jxtN1AbWTfUBewXiAUlit1y2DVitd14N1WG+JBxmyYsURhwFVYYxja3yuAmrpu9lkZ1CpNTLrOnKabLSdw9IKN80DAbCtm5tcccZhrCNXwfuuWVzEijeBzLq9XGzL3bZNGRK8bY7v2izbj24KEUMpk/RCmkLPWEs/n6N56uCFlhNcFWrrMLe0rvJcCzaEdmPlinMBUUgxU2kdm8F7qmZa5otCUbQK1jmg4tRSjgZgYyjT/oW+o1YYc7PxCJ2jTt3RRVvH+pEaBsAYWo719L1iiuQKwxgRlK1537K9SyGEnpQjtSixZLoQME4QlxD1jKOSa0ZQcqk427qiS1K0TnnJpbZW1qqk3I5TjCM+9DBZQXjXLNGZrJ7FKKU0C3trmk15rcKQRjS267CWVgjMImhV8pDZP1hzkDOLzjPrVhgDW/2c7blHa8uiqKaixaC1IuJIWSebd4OUZvfunGOMLTuZClYMzrciqfdgrcU7y3JZKDUTxGJcK+SmnKgoIYTWzVwLYi0ueNKYr1idy3QuqJntrcB8bpsdfi2MMTXbDpSYMzZYqtIEOZO6s5ZCLgWM0neeFKGI0ve+2Vknne4jpdLIw4VAUdp9KJOuqQJimwtDjaScoSRcaHbZ4mjWMJVmBW9hTAPDEMk5N+ty17LDa55EHk0a0brnSxNq9PMApjaBSVFijFSNjClhnMc6zzom9lcjnWuCAbVCkYL1tnWldwHnHUE9MLkDWCGlRM5LlqtmN3/s+AkuXbqEd45am2uBNWayuQFjHbPFgvVqjRMlUYhxwFqhc4HODfggpGzwoVmJr9Mh3m03lVmBzgl720otyuX9gWxANbHaP4PbnqHGsR6EGAMpFZIZsFLp52WyTy/kOCAq5GQwxpE1E3qP6wzjYHFiG0kbsMHhTKAUcEbJKSPGUlPFO6GUSC0V4xzrMeLDjKqF9WoFJPq5IZcyRRiE9rvOcMpsk2rGOEcsAlqayCUpORWKFHzfUUqe3AqUmiqlqTGAjHPgvZ2cD3rQTE5Du8eMp+sNuSaQGcOwj3OK932bRNZKFwzJWkQK3rS4C8Gh6alx68XCl+bPp1uzmKsWyEcTp+bQ8OxF6tN/pzzzJc+3sL7a7u3Zqutn7t/T3nnlT9Vn//tXuphv+6JN/VRLm5xqJZfMOCzZnu+iYkhDxDlBrafGFWLg5lvfxHL/cT7yqz/LL/78T3Pb7bcyrA741u/8I6hYICMEKtIs96Etzo0AdTrWCmqpgBG9SiwxOZ5URW2LPdFqp3GtRZCoZkQ9La5EnnvVv8EGv40h08Otq2/9Zy/6Xvbd+pqCSrPCi8OK2bzDedvGxCmOpR3vo7HWPG11fjQGi4D3jptuvBVo7lmaK9WYSUiqLcpGpPkpqSJOMdkzpsT5/UOKE0YdaYklmVIgrS7zvl98H4+duYDvAjm1uQAIhrae2Fr0fOOb7+I/+fEf58EHH+XCQ/eyt7fDjbfdw/z4TbzxW2+FWjk49yjWeV51/A38uT//Km6/eY9PfeYLxJXjwrkt3vaON3DmzFlMWPFf/JW/RkxLtrc8JTl+6X2f4IO//DHy+jw3nr6LG2+75yU5FxsOf2HYcPgGG7yyseHwlx4bDn9lcPiGv18YNvy9wQavbGz4+6XHhr9fOv6+7sL4fb/xcRLN6nV/2bNtDK6HPDT1AF3m4HDJpfMP8aFfTtx54m7W5Qz9/t384Xe9k89feJyPfeYX+d//0f1842u+nTd/w5u55dQtPHnpcS5cNsyPnWaUz7Kfj3Fir2+FpXHE+jDxx7XVcF8NGGNaRnXKiBi6rhXDYkqIMYgVqnWo0IrgObMeBsblEms8Yj2mVjKC9471uKJEcM5igyHXgKEyczMUZViP2NBRSsRaJaWxFaxLmcQfcsVGWkwrHgltwuSm7m2hFfAUS+g8Ma5w1mFFmhe/9ZNtMaScESNkCuBaYXFC1orTlhneatIWa12zIhYQB5IVMdCZ0G7cnNGimCs2GzS7cetAPFUhjSMlJ6omxFi8sU0VQ4Wap2I8kJk6npuCpd3sLWdYaXkJGAimHZ+cEyKOPNmxWwARrPUYI+Tccnuds6SUGNYjOSdyTvTBNSt2UYaUqar4rmO9HnHOUzEtc9wqJSUQJcZE0YJ3HdVUBEW8gWnypCg1Rcx0nhShlIoPkGKhSKWU1AprIqzWIzrl4QTf4af89lash/XhCu9bYTTnjHcO63pmfWX/YM3FgzX7y4HtuacWOH3c0gdHGtfMFotmyZ8r1gjeC8MYCd60BvncbPlLjYypXtFblDLgnCfGZh3ugseIoZ91aMkg2gqTVSm1nZOSC9jWRVurklNFjMM6peZKFxyrw32gsrfbsV4eoFiMUVLNgEFME0aUWsklYY2g0uzvxRqGGAHowrx1V/cWsQZEMc7hUGqpqBSYsk+cD+3a0YJqbvED2mywa8m0bKJWSDdOKFRSzlgXMKrUODanBBFcCLgQwDhqSi3X3DTxgUWaWItmXZJL246owVpY54FShQqUHLl48ZCqyg17W8ydMMY1fdcjWFJVtra2qBWMcwTpcc6TUibnREoVpKIkqgrjeLbtSxZ88OTSxBumNmI1IlQxzeVhGDHuaJxr5yqWntXlkdkikVKz7re1AiNoxnqlWkOYjWx1M07tHefMhYusVs1ifD2sCVaoarEuMMYRasV5x9bOcSyV/Qv72JpRRnJsgoxqmqW6omwv2vW7GhKYgLGeUmid1GJQKeTS3BnIBcWRi6IJVA1pTCRdUlPGBGU2NyAG6wzGKKXYqXjdEWNkjBbVHivTBAIBrXTBM65HrDc4awkhMMZKSYoUQ3CWzgdiWlNrmaxtBEfGuEIcV0gIgCGXRNcviGmFD+0+yClTS6JicK5NZvouQBXG8mIWxoWjjJ+n/fZ5OPWZWUAtHOOqZfA1VOVXf97z7s1Vi/Dn3gd5xmT6aVLIa/z9Gfsiz2U492VAE+CpqpNrSKULHQXYv/gA68NDxmGfxfYp5vMdDg/Pc/HJszz5yGf4jU9+gscfX/Lww5/g9/zukyx2t6jiMDTXCtVKxU6OBoZa26LcGEsuLeZBpLbP1tpUoGQK01ypKFWVcbxMF2aodWjzXUJE2+HResWaf6Ni3+BrAlddx/KMn5/9ks01/0JxZXzX9tBDqxDHAessIXRPG/uvlWV59Pej/1ock+HmW2/DWoM1cJS56VwTmV35TGndPKhra5m44uMf/xDnzj7J/feOPPiJf89HPvRrXFxVclzyr9/7ayyXh01Yy/QgdRKeOmPpjef06dPsHruBb7n5LvI73sE//1/+Aevh3/DO73o3VnaJ8QkWJ25Bx0PcbA/v57zrB36YH3i3YYgJnHD8htshDcQI4/mzfOjjD3DL6ePceuuN3Pm6N3Dh0Sd51+/7M6CW2WL7xT4jGw7/SrDh8A02eGVhw+EvKTYc/kri8A1/f0XY8PcGG7yysOHvlxQb/n55+Pu6C+NvvudNfPaBzxDXhagR7JzlakXMiRBmpJoRKxwcHjJ8/nO89u43kVJkL5ziVa+6A38DvPczD3DDsW32teeWE2/hzptm7N//CFvG8apTc77QL1jlJ/m1+x5gd+suTm35pi94RZFGJefKOK45ysQWa8lGsH1HLQmoaA3kUqaiW1P0jWPm2O4OWRWRyDhUeplhZGy2yr4DYwgzS46ZMR6QYiRF6L2itAJhKRUVYYgZ5xxGpvxro8TSrIS1FKpkkqlTnrYypIRqIpeI945aWjcu4shVm9W3Kjp9x+1ZR0qpfU/bFIm1VmLNoC2X29p208Qh0gWLc836XlqZuh2fo9xesc3GPFeMKibDmCLGGWrKqNYrs7xxyBhRnG8DqQiobV3gTQ3Q7NiNEcS0IlhVpSURayuYakFqJWtGjcdai5aKNQaFKRO8XVsiLYs4poQXIRiDt5acI9YGvHHEmHAEutmcPnSshzVODZoVtBXFh1TINZGK0OdWlLW2nbP2eXWypKjUSssdtr4VumMEKRhTqSUTJdPP5qg0JY/3HTqJH8ZhzXqdAIO1liFm1BjWKeJLwVrBaCGv1vjZjDREclViHri0rthS8dnj1ZNKBW+htAlbrRUJrThprGcYEqW26wpRRKHo1L0vQkwjRipQsU7Q2rKZnbc4b5BqqFpQNdQ6KZEKYA1HtkcioBROntjDmIDQhBp9P2v2G6VinUNyRRBybtdTzqXZ0mvFOYuxhlhG5l2g62cUVfyswxjDarVCqlLSQIytu3t3d5fD5ZKYI1ozXegpRVBaloYRhxYYx9SukRwZh8hs3jrRFdMGfVGsFXJpsQfOOIy0Yr2fz3DGIk4Yx0jfecY0YjA4YzGl0GEpCi6Ellc9h8NhYO49lsju1py+b1bgpbYc6zCbY3Prqm/XcBPt+OAAS66Ks5ZxFQneUxRSahkgzvl2DKksFjNyLKipiBS0ZJzv8NZQiITeYT2IMcT1muU6MduyCAkhsrWw5GTZ3zeULaHqk+wfOrreUDSRlplqEmMpFFtJ6lgvI4d1he+PYY2iro0VpnoKbRzyrrlGjINQbWUcK2MsqCksFqY5Cqht+67NfUJqoQuWqAmtZrI/Z3I6iPh5y3mP6yasqFKa44Ao1kHKlVgFMaB5ZCyCs6YJbkpmjBkU8phAhK7v6bzFiDa3iaF114tmSh6pcuTQIQRr2jWJNpeLkijVkZNSe6hSUaDkhJ3NEQErQskZazz6Ek8km4Lw2QtruWqNKzwlbjpSIOozbVyuue2nCRafNu5erUh/ni1c77e4ztc9fR+uB1fyfTha0CpVCmWMjOsDtrb3yGkg7x/igmH35teSx8iF8w+xWBzjox9/Pz/5j3+adVTIS77lnW9DTOXRR7/IXa89DWpp88+2yBbsdMwS0MRn5uhATiKbdtxdU2tqxVlHHg/BWIKbceniwyy2TtH3e00sowkRC1ierfTfYIMNNvgSmDppBEPOGWsd1kzzoKe/cPrzGuPMFKWkatjeOYbqlFhTppicUp61sC9VMRhqTcQoPPboGTrreN09b+L0a97O19ktnJ1z8YnP86FPfRGw00NLOLKPMyLM5z233rLHN/+ub2PWLcB47Nzx/T/0B/jiFz5JXg781id+gVe9+e1smTnaWQ6euB8fPMdueDXLs1/EWMuDn/ooW99yG1KV5eFF3v27fxC6X+Fjv/IBfuKv/3XOPPQIZ4Pj4Mn7GcbMza/+eqztX4ITctVh3XD482LD4RtssMHveGw4/BXJ4Rv+fn5s+HuDDTb4HY8Nf7+k/H3dhXETFmzv7nDAmmQKFaXve3JsIewzDbiZJRk4fcMb6baEndnXc9OrTvAvP/w+Shq5zdzBQ8M59Ox9/IP3vZc/9+53M3MDv3z/Z4jh9fzud3wHH/rcGe46dYKTOw4tgpgXpqh76SEYQytGiaXrt3F+jjqh5Ag5k8dhum5NK4DUSjffZrErzHf2yCUxjob16jLL5T7GdhgH1nvGuCbGkbReU0tBEcQURFqRS7UVVsfUCkDWMnUfN9VaTAVl6vYsLcNBzdQFbi15GClREOmYphfMFrvENFLWS7QUckmglcNa6HyzhTYUSm36RC0tu7kVozKiYE2g1EpNuXWrC9A0d1hjMcEgxpJrpapQc0Ekt23EjKi2YrptFsfGt1zeZsvevocPAdWjrANa8Upb9jmqxDE2qxpxVIWSC95apFZSilQVvO2IMeN866IXMa2QXpQ0WWFrGln0/VQYrwgFMUJNymoc6YEsQhc6EEspTUljjMFaR5os9mtsl0DVhNIsrEXAG4HWC4/1oVnvSCvoiijBtMxta4XD1apZz+NY0nLRhzQwxohU3zKqq5JToqCIEVywjCmx2N7i+O6aWTejSCWOkVoios3qX0TIuVK1ZZ2rVJxrNus5FawTnAvkAkUztbaOVmsDWqDaAhRqSeRxBQph1tE5MxWvFaRvx08MRlyzUbfTd9Y2CKOVnDMnT51i1ntqMYjtyHkETYhtbgPWmiYUKe0aX69HigFnDC4EtGa8MU355A2lZhSPMRBTZEwRS4sJsLZ18g5jpJvNIVtqrk0IMpGINYaaCzG16AMtMKwjRlpOeSmFHFPLdjfTdamFmqE6gxohuECNlWQqKScEJcYCCs40EcmQElhD1wWW6xU5F+aLBcdPHWPROawKY64s1yM+BBwVEct6vaaWFkUQgsFaQXAcHI7UqrjOM8bmfpDHkTCfI9Js1FPKLOZb5JRZrdY4U9ES6XuLVAcUtuaVIS3R2mE1YMqIKYntPlC1UHJGa+FCGina0XWGi2dWzOaA6cAcMo6KMTNWw7qJLmixAF0/J64HLlzcxwWLKWBqxmrLFzeilGpadn31JNvy3I01qMBytQJagV9qJacEYkEcqVSqKLUqRiwpRebdNqVGUk2E0AFMeSyVWhTrPSUJpQppMDgHmjOKI1iPFUi0a9Vb19w2rCPmhPPC1sIyjhnTbTMMa3y3aKIlo1RKE52owYhnPew3Zw3xzLqOUXvimOm35ihCjK6JT0om5YR3HgVmi9lXzl5XceczleFfSmmuU2m+LRyfel9VxchTr3v2ttt419aTX+5CsImhnm//vqytvsC5hNIeIAzDGusC3neM8TyXzn+Bc0/CfHsb32/x/l/5Fyy2b+JDH/gPnDi54M/+hb/Bt73rh/mp9/w7nMv86T/5Y7z9m76Lw9U+N5y+o5kf1YhYZbm8yHr/EiVFchlZrg+56+534NyCMR6wPDzLYrZDPzvJGC9y/tyjnDh+Owf7j3H+whOcPHUL2/MbuHjweJtbmBmomVwPJueKq9sMePZ5eWWJETfYYINXBibfIG3zrkcfe5xzFy7hnGtrEOBorH6mSv0IR01STYRrpgeLZnoYCahQ65GQtPGIMW2eq9JEiFnhF/79h0gx8h3f9k0stk9yzxt2KCXzi//mX/ILP/8+pDbG0qOwSJ0EjKYJ2t7+Dd/EGJf0wVNSBL/gH//kz/Bf/tVv5tVv/U4unfkMx0/cjZ8vOHvuUXaOnWS2p7j+GF3f84ZvvpXOO2IeOXbqFmZbe/ynr/0mHv097+amW97I6RtfjdY4rUf0+hfbXwIbDn/GOzcc3r7XhsM32GCDL4kNh381OXzD389454a/2/fa8PcGG2zwJbHh75eav6+b53/wh36c3/zCv+Bf/JN/x66fEazFzgrzYcZsvkXJS0zvmS1O84d+9x/n1lse4mc/seQ733oT/917fhq7VLTr2D+zz9arbyQ9+iA/+6GH+BPfexff83bLBz/6MdLOzRyWh3n8/CnO7C84PevBNPZ4fouYlxNTpRmLtYGub8UO44VxtW4Ww7UQ04hiEaPUkgiu49iJOcZ61qvLrOLIMEb2+mMUIyS7YqvbIpfI+vAycVjT+TmIpeaEmjoVcgxdt8D7cnQtU3PbL6UVjkRbR63tAlWUcViSY24ZASmTsxJ6RRwM4wonSqGQ8gjjVIg2hpILSZWuD9RSoJZJmdi6sWumFWa1ZTMbBWObpTfS7JydaRnnzYxYKamSUsFYIThBtGK1WTZDK5yJdWAEY5v9ORhKZSqKCaWmdoMilJRaV7oqNWeqafnWLWfBIBiCb13dQ8zEEtvExDSBQy1HE0gIXd+MdCo40yzLEUOZWpqNaQqd9TCQh4GunxHmc4pAoeVbe2/xrseKIcZCqpmScrM8KgWj2rqCraXmQnCudbJLm/DFlFoOd2kdqLFkUi70YY6zjlIyxhuqmFbEJjUb865jiCNd6HEOhpiYzefceGIPI4Zzy0Oc79iez9npZ3hjKFSqsVgF5wTnzWT/DEYsIpmUIsaAda7tl7eI5imyoiJaqTESl2tc56BajPGkYUDsNFBLbkXOYhHMJBYAcm3XqRVC15Grsh4TzgVKzcScqGUkOI8YQ66t29mqElOeRBQVY1qGe8mJkgpMjgBeWxa61kzNGY0juUJMI/P5nMPDQ5bDgOs6ZosZgjZBRSmt8F0rOeZWYFclpZbLntNIFMVahxjFIagYjLVUVbZmgYyStFJTgVxR20QkhspQlFKU2WIHY4QQwiRaKLjmZYJF0VpYDRErQpgtIDX7fWubdX2tBeMc3lhoKdekyU5/GDNKc0FQFOtN275pB7/rPIeHK0CYBYchsZjP8QasWEoVlqslY2xChnnXrhOrgppErCPjkFHtUGOJdY0xM2oJLA8LqawZk8EawyiFYAKaK2UqJB+Oa0qsVDLDICxCj1YFZ6gqWGnjj3VKykrJYNUgFlbDEowwm2+BEYpWMNJs8lVBa8s6ydKy2VGGFLEGwFOrIJOtf6oQq9IDpShSElIclRZVMJvP2Jr1xGGFMTRxByDBkitUsVjnyTlijJLHSLNuz63A7wpFh8YRAikO7B8O9HOHkaN7rdm3E5WSZRr/HM4Yur6jpIh1lhfVSZ1nK8afG0+t4I5eVY5efyRen17yvGr3q7c4veb6F39HQQ4vLl74fjQ8+tCniet9dnd26MIWs9kuYbbDJz/2Xv67v/+/8clPfpblOBCXiT/1p36E8fACZrDccnKbG2++m5M33cwvv+/9fOM3fxtdtyCOq0mJ3lGqMK4v88DnP8799z/Am9/0DVx84vOYEIgFthfHePD+3+LJs4+wXC75uX/zHu55/euBzA//0I/ThS3G4YDdrRMY7zDGUKU2gR2GoqUp1tU8o4vg6C/yrAc2G2ywwQZtXj3N/aTNY3w/R5x73vHCmCZIbIv1OrlPaZtPxUgTv0oT/x6tn0UnsanF2uYOlNLYnKGqcOHSASqZz37+QbQUxBg0Z2695/XY0GHsmlqnuWbba4KzeOfYXszZ2TqN8wErBuvnBHOB7/i2tzBb9My3b6Cfz7lw5rfot04yW2y1PMliURdwrsO4SjWeeTjF/Z/+IB/7tZ/jxpu+jne++4cYDp9gefki23unWV5+jL2b7qbKFOX0ImLD4RsO33D4BhtscP3YcPgrhcM3/L3h7w1/b7DBBtePDX+/1Px93YXx+1dnOFvXHJ9v0XeOYAtGPbkbOXHq1Vw6+ALHFic5sAe859f+D07dcpoLTz7Kowf38O53/lEee/jDvOdf/zOOb9/Att3h7KWLnHloJCbh5ltv5YYLj/MLv/xhZsYwbn+I3zy2INx5GzdsP9XG/0ogiaNcF2MdnbeM4whq8MbhQ0fKa4ZlxEHrqhbFW0ctGbHKMI6sx30uXXwU745huhmrg7OMqwOW4jBSiXlsNscl0vcL5vM5NY5YLEeCkKbcmGyCpRL6HteBNT3L5T65QM0jZbUCtRQqPvS4sIUNQpECpZLHyOVzlwl9T5jNCIvAvO8pOZLSCjN1p+bUbOMpgoil1NhUI9I6ZbUy5Ygroso4NCtq75SaKmIyNVW0CrVmQKlpQMRQjQELNbdOWpFWpIpTZ7WVdmMWWvdlLhmyIhJIZWjamCpgDSVDigk1DoUpH10pGNRKK9SqTJ31ivcBtCCmWWGPY2znqypFFGOaWXYxDrEVKUrJtWXJl0IZVvQeTKpoSXhxWB/ItOK6qx5rMjEWxnEkDyODjZje0s3n7K/XzGYzrAOMp5Q4FecLcYyknAldx4XDC4hxuCoEH5Dg8JJb972CD0LMLVs+D5maR6q6NiK5ihXl1O6C3fkMZwXXBUSVOOYrc91aBKmWWjJ2ZinqGOJIVcGoQclYa6G27B2ZCujqLfNjJ5h3hSFmUlbETXYb4wokYJ3H2EouyhDXGNMEJXGMzPrWpW5wJFXimFBGYir4KZu6m/eYcSTWjHHCzAlxPZJiG2iFVpjuvSJaWK+WFCCoaYSQCn3XkXNsxVxt18y4HKnrQ9BddraOczgcQC2to1wMrvPkVNHULPituOYOEJrdurWOkipaFdd7qrYiuZ2cCoa4op91rNZLrAGjjvVqDUDXJ5zpGHJs12kRRA3zRY/UitGCimKsMCz3MQgDuVmBpALWIkaImqAUnBVqVmpNGKmItjEJN2c268i6RqoCzQ5/Fjpc37drJUaMMaRciJN1/XpdmHULrKnM+kLKtNyROpBGR46ZKkI0YDxUNcT1QEwjdtazyoaZ88xnjt0b90iXR/bPnWed14gqi+1FywXXSNWMMXOEEWcqRnpyycSkqFmSsiMxp+QlTgIpVg7LAT6sqQWMKtSCMQ7BozgwMJaEAaxUSoKkEe/niAqrZRMcpQw5JnrfUXCUHBlTwdTCOFr2aWNMy5dKeG9IxaB1Rkz7zLylpCVVLXlowqKSR7Rm8phRD6oD2RpyqtQMy8NANxtBMqKCamG9P1JyGztxlW7ekcIORgx5lfHhxWQyfdqC7Pktza5SoU+vaar1Nt5c+bdrLuzlae+/1va/fG5/5nvkGr97jnd+hXOJu177Vi6ceYgP/+pPcevNdzDGJagjrg85d+4clw5Geue5664T3Hffp/n//O3/O5974CEee/wcZ84mshyQDwbuvONGTp48zbC8yCc/+RFWMXD8+Em254F+ts0Xv/hZzj35BNvbe7z2DW/mVXfew6d/48N8/CO/ys//4gc5dyFz/FhA1XD23EUuHziQyu7enD/6I3+es1/8FFU9BeHEqdMcP34rGDvdb5Yj0eHzH9cNNtjgdx6Uqx/IXj0uGCNApp/1bO0sJgn61a97OhdcixuMTGLZmpsDlLR8R7T9G+apGC1rLQYhxojU9u9ve+vrePXrXsNnP/VZhsOLuNkCFcuDDz7M8mCJFn1qL7S5Kc1nPdtbM17/mjvYO3mavDqP6zqc9GhJfOd3/X4WOyeAge2d2+m39jg4/whnH/sifTfn8YcfZDH3nL7j9Th/kjAzVFX2bryN7/iBP84ISC1Yv8D3S8J8jgk3UdXgSnkBK+7rwYbDvxJsOHyDDTb42saGw1+5HL7h768EG/7eYIMNvrax4e+vBn9fN8XfuW356H2PceOdd3LbPdv81kc/TzlYsbtYcHj4ReKQWMmKO+98NV/85Ae5tft9uNVn+P/9/f+Kb3/X93BgE7F27G7fyvFbb+IyM37oXfdwbFv42z/zv3Lfbw286tiC5eUzuFOVxx97FH/Hq66pdPtqQ0RwzlFqnKwHWi63CuSaSSU3+3EDtRacMwzrFavlklm/oI6ZkB1dZ1juPwrjiKbK6vIljG023N5YrAFlpKhDbLsRmnW5Qk2oEbIK1nZYG8h5JEvGdTMuHV7EUujDjJxpXbulYjyI84QwJ8eBnAqLnS1CPyP4ABXGGFl0Dk1AqzeB2Fa8NNIKUCIUhJTASaDkTC6RGlvlfhgS83mHkSmnoChmEgoYMXRdh7WecYw4a1qucC5Y09R0ReP0vRxiHDG3G7fkQh5jK4AZmj18yaRUsNW0jnFrGXLLXaa2rPJUoCLM583SRmmKm5hGvPcYe2SxbUFbB/2QE33oEGAcRyqGghK6gJ2mo0YESqXmZuluTCvOZ2qzcS4jxgizRd/UN71rluRGKEVJY8JiMcayXB6SUiS41kVsncMYjzeOYXUZkczpvRN476mm9cMLhlKVHFuneYyRzgeMNhFAN+uwznDCejp7JKgwiDVI0anrvCkZq7Z8ddP5lrlsA704hjFSYmpd8CmiIpgpa1yppCHTdZ5hVFIVxLYO7sV8xjAW1ocjuaywfoX3M8rkLFCR1r0r4K1iLUi1YGEcRiiWopVSFbfocb1vlu5J6P0ufaeIu4Q35kpHfsrr5hBAoYyGrIKxiZRzs78OMwoRMYZKxHkoWRgODnFFCc6j0oreKOQ0EtShTlCv5FqYWU/JCYNCVYpkmFwaKoIVwUilCqi1jCU3kwlVqlRC31FrZhiWrNcrEKGkTMmt231WZ62re94h4qmmo5tDGldIsRgFMZmcC0Y8SIsWyHFsYoqUmwV+nHLMO4uWgZkPFJvpnJLTgA0z6jiiNYJWnHMcHi7p+g5XKt7v0IWew4NLDLEipg0Gy5UnEsAqNRaoiqk9Y66t2zknxtXY8re7DqOG4XAfPz+BOwYHZx/GO89yXFJQnBVyTsxcIEdL6BwqhaxKrYYUIccCNSI6MJbIOhUkGJxZgHoM4KwSQkG1kvFYG6i1YiaRg3EGawOrOEJprhMhNNWuas8wjhQGslZc6NAkUCspFmopiHi6EBjH0sQMdYU3jjgO2ClTPvVtXJw7oeTKwWGLxui8MEZlWAld2KFUwapSYouUyCljXUcXPFpHlA4phjRGQiekWijpxdKqy1X/PWW381yqdZHm2nH0zi+5dXn2JA541ue8EBeY515EP6Ww/lJ4toreTI4WUFUal2udft+2LSpU046TwQAFqkUMHCzPsNja4/DSWT78G5/lPT/zS9z1qpsYo6J14MZTt3Di+DbrIfMP/ud/zTpGbrv9BJ333P2quxjXK8bVPpeefICfe+8v8vrX38PHP/4f+MD7f4V3v/u7+PS9D3DvZx9kGAqPP/4kN998nNM3nuYLn3+QxXzBY2fOIsayTo7zv7qkD9u871f+IVsLzw2nt/j0Jz/Hww8/ymOPXODH/twf4ru/+5sY9s/TL05wsL7Mq+54C0hzfRAyOomInt4Z8AqcgG2wwQYvEY4W4lePl1ePm9KU5CgqDtKKktpcVCclukxzHVUQ035/JHhtsMg0v1IUa1qcjxQBHKKpKX5Vm+hWlWFo4jRnDanWK8v+b3vH2/kPv/obPHbmSW65+w7SOvEbH/t1xjE1d6Lmo4Wlxar0vePuO07zzm99W5sz9XO0NKGrcwH1bR3nskMlIjJj74ZX0fc7YDseeeDDfPITH0V+/QO841v/IDe/5uuByvbeTcgJhdIEn10X8OF2BOjcFlUL6l5Mx7MNh7dtbjh8w+EbbLDBU9hw+Cufwzf83ba54e8Nf2+wwQZPYcPfX23+vu7C+Ln+IhdS4pvu+Qv86B+7hb/x6F/mUE/xujef4FOfuA/v4aY7TnHyluMccoLzwy9wZjzPncd/F/vLj5Avv5nb77mLuLyH73vnd9PNKmdX+1j2OB62eO0NC5ZZMLO7uf+Lj/Mtp45juldOp/jVMMbgnCOu19NFUykltzx0aXbKMUa896Q4ICoYhO3FHFRwRnGhJ5VIqWs0V1Q9tSbG9RInjmAtSkZMJcXU7KljpAsBA6zHo05JDyRmM0/MI4hhvrXL7rHAenmBbr5DbwwXLj2J0QJDBVOpOWMU9o4dJ6YEpWK8wQVPzmaybfeslyus8y0rnTwpFLUVKLVlRFepaKlTzjU0twZBS8W4Kb9aK7ZaKhXVghy9DkNKBZWKcDRpo02AqlJqQZ3FiCMOcTr2zb45V+VgtWYcBiyBEALq2sAwxmYxbrQiDnKpiAmsVnGybRd8CBhj2vfHgjOk1G54KxZMAONQBDUCKu080/LCtVQ0C1UyvfOUVKhVqbU01Y1Mak7b7MND77FaKFWRYoi5QCmkcSR0C7RO58X3lFKaCEGapfain9H1M8QI1nuss9Sa0CKte52ASBMDqLXM+jkg5NIGmc5DrQkXfMtLr831IA4D4g3eO0QSWiJiO4q2YS/XlmmvwpR53/bf2ICR1k3fh/lk9WwRiRgrzBdboIqzFt8JMibG9UhcJWxwqGlZ08HPsYsFOY/EeEDX91SYipUFzVAlMQxrHI4YlWEcGMYIUlEKsRhiTJQS6QPkYWCImayZrS3DMIyIVvZ2jmM9IMpqGAidxYhBS2jFZWMo0rrpZ/M56+Wy5Y6b0or5xuNdQHLE5IqK0i/mFNp3iePAOGYKmVRTO2apYEXog2uCF98hGMZhxcRK+NAjIuSS0KJYa/Cu4+KlfWznmOWRrfkCMQGpmX7RN4VXNqSSqCVTSyXFFVoKpUJJI2gTHdhcGSuoD4wJsoCpShlGalnhgsVSKbm29w4J6zzKyBAPMc6yGgCdUetAKpkxt/u73QwOMULRgpaE8xZiIVjLOOyTrWBXPcP+E8Q40LuOVCtxbHnfpTShTSoZyWsoa1QTTU3g0JpwwZLHkTRmjFgsBq2GohVnKs41C/+cwfkOZzzOelDFe5hkGJRYqKVO3d8Ri8V1gVoqpRRKzRSpmOIpWRFTydP+GQPrnJp9PxbrBGdbJEWMgrUFoxXjBEvBWEvoe6xacsyMaYlY18bJ0jLdjS2AI2cFGUHAdz1qAqHvyWlktdqnCwti/MoK4y+ER0WuP77kaLtPy7AR4TrX28/ar2cu2K9vv5+tVBeRK9PJZ36P9uOR9b6CFFCLYiaBptIWpwaIqHqgxSuUvEa0sLN3B2ef+CD/0//6j/jwJx/i1MltHnjkYQ6Xyk2n9/ihH/5O/uVP/TxPXhh441tv58zjZ3nowfMc7kf+1c+8n0/91mc4deomDg6WbC92+H/9P99IcIYQ5vzS+z/KL33gE1hvKVWpWVmvn+CBB59gjBnqRXaPzRExXDq/QoywGs6AKFW22F17fvpn3s/l9YpShJ/8Zz/Lr/3qR7jh5A73vOYevvv7fi+PP/IFfLB0Ycb27kmsh1JkihzYYIMNNnjm2NlW16qKVqHrwiQ2lSOpKM3WqkWV1Jqn1biAWq4s+MltoaqWrcVxoIkZKxGjpinZ5alOmqPFefsfeOs4c+YJrBHQMjk9BT760ffyb3/2lzDSRIoCTZCKpQuWYA3veNvX83t/+EcRs8DJFuhApVJrods6iS9K9sK9n/h1Di5d5G1v/7a2uN7a4zVv/D5uvO3rGS89xuXVeT747/5nvun7fhTjOnyuqBiyRIy6NhYrTUhq7PT9vzJsOPzqz4ANh284fIMNNnh+bDj8lcHhG/6++jNgw98b/t5ggw2eHxv+fnn5+7oL4x/9t+/nG177H/H2b9nl/suf58KFc+ThDt76zu/nsw8+RjpYMY7b3PLG23i8fBxZ38a33/O91PmdfMM7lvzdf/r3qed2uOvYd3F8e8bnL36GM2dPkm+PHAyJ2+6+ld/89GfZPn43UQYO149xePkOdk8tXnGCqXaRSiukTP+BIKbljvf9DM2JHDM5FkzNzOczlMR6vWIYVxSNhOKhWIZSKcOAuIq3jt6HVjjWEZGCFrBiSNqKi85bun5OqhUXDOtVxHU3IGFOKsJYE+IsW8dOMOsX5JrhwLU5Ri3M+i12j58CU9i/cBaXla6fM18sKBgCPaVksI4tP6MUpdvqGdYHXHjiPMd2d5iFOcvlEmMq45ipubbPadI/tFasCCWVqXtZ2o1FbV3VtRLLAEc3IC3rAKmU3Dpe05gwvsNZT8kFoQ0GqcKYRnKBnNrxQUz7u4L1BmcdaYykPFI7Q4q1jReY1rleMziPxWDFMozlSqG+looaqFhWQ8ZJBWdRmp2E1jaRc87incXURNVm8V5qbTefNRjbssyHmMA4ai7EnCilbVvE4J3Fe98yteOanBKy6DEow7BuXd8uYEzLvk4G8jrj+xlibVNYGqHzM0qp5KoUQKQ5DhgrWLFNIGB8s6QvhZhap6qZusjjGJnPDOLaMc5qWgdt1anIL6gos1mHsZ4clb5zoKXlP3sBdZRsCaFS0gpj2oSvThNd5z2IkGsllwqa2NrqMWRKMaSoWDsSXCCVSoztnFMzgxacL+SslAhGPGMaWK9X1FoJYTZZ+itWHLUKFqgxsZgtMCLYzlFtxhToOk8XbOs0dgtiWkMRSs6EmYc8crB/iTRkXAhoraiprLWyXC2x3uLEUNaR1WpNSpG0HhjWI5fXaxBlq5/Rhx6sIU458yKCd5bOzRnWK+SKe0EBA/v7B1y4dJnd3T1mfY/JibOPn2fY2WU2m1PSyP7yItZ7alTWhwcYyc0tgQhWENuRMahqy/iOAzlnwrAmJzhQCJ1n1ndUsWhWvBGG2IgUhWEYASglY20rQNdSyKVFGLjgmPkFQxrothcMqxGNEec8wTmyV4aUCQ7MUIl2TZz4OXSeUCD4DjXNBkVEqXGJNS26oWppCjaaerjGSi6W6npmM0+viaKJmIWaMqkqlYwVJaUBvEdo3805i3MO7zxxlTlY7rMe1hir+K6p1NaHB1jrAYvr5nTeUAuoh2G9ZDUc0nUzZrMZznd48RjjUBNZppGcDJ3pcL5gTJ7cEJScVqxjpaaAyJzQV1aXEikmil9jXcfy8BJVoZ9vUfWQqhD6Lfb3D+h6YTHvCKFrAqWvGE+R6fMtuL+Ugv3q3325ivMvT/T2wl5/pGo8+vOqT7/y0EB1EmIdcZNWjE62RGqANpmsKELlwrkHuO+Tv87hWDl5+jg//Pt/H+fO/iTLoYI2G7VLl5d86Nc+w2OPHXAwJD72kS8yxiW5Ko89ueLcpYvkbHjosfs5sTen7+f853/1b3DfZx9iNptjAHGWITVRmXcdqTC5dBh2jm2xXK255eZTnL7hBPfe90DjwFIYhsKDj5zBOuHkiWPkXPmNj3+WRx56gttu3+U/fOST/OL7/wOzOdz96ju453Wv57u/+48xP3YDmKMHEc9+yLHBBht8rePonn/mA9arRs8mV0eoGOeZBd/eJU+NtqpXlsSYtiRouYrkScUOIg4Rg7N+ct6aHpYaS50EmUeff7T5WtrrKsr+wZLP3f8gzgqzzkOBf/QP/0fOXVo1waOpWAy10uauvacLQi5KZo43Bq9CxlK1cunsI5zod/FOAcfp0zezmM2AFWYxa99GE1vHbmSxvcVOFebzXQ7OPsDxk7ejLqDSoppUAAxWgDqtf0x5kfJJNxw+ffqGwzccvsEGGzwNGw5/ZXP4hr+nT9/w94a/N9hgg6dhw99fbf6+7sL4N3zDu1nlwuKY497P7/Oau9/Opz7+Uf7Of/t3ecsbfoTv/z/dzsOPX2a8cJ79M2ep+Z3c9YNv4Wc/8E+4/O9v4Hfd9IN8OP0Kd9w149H1A/z8R3+d1974vSQs3/ymN/BP//1DfN3pO3n07JOc7Hp2FyfYWXh06rp9pXSNPzVZaT/XmkkptQsLQynaunFpBSZnPc53VBWGcbgSZF+NIhiC7RmkUlYDmqfcAJta9i7aMsS1ktKS9WpFKY2sq1FyqnR9wNqO0HcMOTGbLcC2fGFrlThEUlWMs4yHK+b9At8FlnGfSsF2jmFQpBSG/UuUAv1sRkwjxkDwjsX2nOV6yTi0wm2MCWM7coJxPbTs664nritWIJc1zhh8aMXgUhTnLUqzGUYsVQStgjUGZwURgxEl59xs2kui7+d0sy1iKgxjJARHzpmYE/uHS4Jf0IWeYCwQqFoZhzVpeUjoZ82WfbJx6OcBJLBaJ1IueO9BDSUrahRrhK3tbVKKjMOA0M5jzRWxArWQS6VUwahQrNL3ttl/W99szYvDS8DiiJrJJVFLUxqWmjDWIMaBQoyRxXwBavB9T8qpdQrPenJMzYpfBOs8YxxISRCjlCyINRgfmjlFKdRUJiuK1l2bSibHRAjast+tAS14CUgVxqlDXzXT+9ZVG7quFSNrIY4DKUEsFcRQSsFZgzWuddBXSyUz5gpaCd5iLMR1wjnXfg7CMEaWqyWFQEFhstVoVt3g59t4b1pmvDi6bhvvC5qbfXUsI53ryGlkOLhMKZXCGusMaGCM0lwVrGmRBTYwjhFrAbE4q1dZiAjDas2QIlWFEAxaYFiNLVddM1oTs/mcYa3EUrh0+RK5VKo4clLKWOicZ1wvgcJ8Z4f5YkGthZISXRcAZWt7DlrRlJsFtoJKy0FPYySu1wRn0Nzet84ratNvkXMhpchs3jOslnQ2YKvn/JNn2Tuxy7yfs9rfx1rh8uWRqpmiCdTinaB5ZJ0KiEWMwVqDYJiFvpFKmGGiIlkZhhGVpsCNAs60DvP5bAtrHSlnUs3kkpslOUJar1AfmO3O2dqe0cUZ3XwX4jlMmCMGckn0fUevFc0j43rE1Eiphm6xTUojxk0LjFyRqjgLtnOQm+ikXSnSPrtAThkJnpSUJ85dQnNkMZ9TasFRwSbCrKekQloPmJRItU5Ffcd6UMYxk6KyXq+amKlGzKRpUwmt61wEE1cMdb91dmdliGswYK3gg8cHTx+ag0foO8QLSMEyJzgl54HlsiIFyJExK35rDjgEg0jBh8R6vMDhOaFUYb0egHNN3BIrJSVM8Ego7Owd4/TNN9DPd75s3no6f14/lx6JwF6I5dr17o+qXnNh/lwZaM+9rWv//mkPDq79ClSbEnKMA/2sn+abQp0Ul0iBWjHiqGQOLz/OQ1/4NDfccJpuuc8b3/ouTp38MGceuo/PfPEMv/Wbj3HhwhOsh8y/e++v0fWBYzvHOHPmHGoyxob2vYcIxqIU9nZ2Wa2WfOZzj/CGu27jDW+4jcvrFQ89eJ7zFy83UYo2rozjiLOGne0Z+5eXXLp8md2d7emhguKdIzCiNAeP08ePc+nSZQbvwAr3fe5J+n7OvV/4dXYXCz750S/yqjs+we2338nXf8Pvpk0Jr36M8cqYd22wwQYvF579CPNZD1SpoIoPPeOwouTUHIOMXnl71YKIsD683MStvqMTbQ4zGKppNponT21jrUA1ONshtFiiUqbopunzrXWopmnMVi6cv8x//z/8Q07tbWOdUsvI449dQKVQqkGlaeC1KrYzdL7jtltvYLlKnHviYW657W6MKTg6as78q5/8J/zAj/xx7nzTN2Fq5vipUxw7fpqSl3R+ARrBNrcjagd1yQ23vZ48rrh46RGC75n3e9huC8QgNbZ9NQYkY7/CR+obDr/mKzYcvuHwDTbY4GnYcPgrjcM3/H3NV2z4e8PfG2ywwdOw4e+vJn9fd2H8h3/f9/Orn/g49z3wRe689ev4vm++h7/4Vz/Nzv4JLl34KL/68RU/+sf+HLefvsj7fv2nObZzM1vzwOtufRvbxnLWXKA+vM8nP/ledo79IP/x7/pBPvrwZZ64WFF/jDe++jh/5Hfdwk/+2q/w6Y8XTh6/lTFVFlV5kWT2LxquTFBUSanZPFsZ6fo5VgxjLdSS6VzPbGeBqqNUsL4jDwNSDJ7QujnTkpqW/3/2/jt6tuu67wQ/+5xz762qX3gRD8BDJACCAAkwB9EUJVG0REqyRMmWJcu2xqEty7N6ObTcM7Om3TPT47bdwaktj9Oy2rasli3JlhWoTJGiGCRGMIIBABEf8PL7xQr3nrDnj33q9x5AgASDWgy113rr/UL9bt26de7Z59Q3VTty8+BfLExV3rVjtNhgK2S8b5isTcjA3v4+AQ8RJutr7M/28OMW15hdgAsdOc/Zm04JTgxUVCXlnv3dC+ScaRqzks5JCZsdi8WCGHsokcViRtLIaDzh8OHD5DwwTwktiUsXzzBZX0fwNG2g7VqK8+R5QvAggUIhawWVgxBVzYbcN4BD05NZkyKmwF8uAp339CkTshJjJqVE0UQpGRRG3Yg2jAhSKE4omAq8dS0dQjLSCK4JFBVSHAhtIOWEOAO3fM1QiLGnqHJpe4sQTKG8VIOnYtbvWgolgxAoBbImUpIDy/bWFbIKjQ+meB0SMQFZ8Uv2Tc4MccEQFd84FsOctpmQstKMOsbjdWb7+xSgawONdxTNeAlQMsEHBEXEWTZ52+BwpBwPQHSpz9VMxjiXICZEHOq9geR2BFLKqEZSJWj00WzJUSWmTCmOop5SFO8DiFDUE5OAKkkLMSqjztM00IgjB0VFmC8iOfaExpkieCjkpIwmY5wD7xyjrqXrOiQ4+pSIfaEJASQzW+wzZDuXfjZH08ImeDyaFXxhvthjsTCFfNMERIVBB9QJAUHExon3CefNhaAbrRFGm/SLKSnvEOc9eW5W9qOmJWlkd7HPbDY3m/5pz3xI+AyzeY/4wPrmBqJKHnpS7MmpJ1engWnJtK03q6ccmc5m7M96EM8oNCCKOM943NGXTD+fEecREIaSGepGYFgsuG96L4eOHWFtMmK2v8d0vs8w7DLqGnxtWnvbqboUZJqwhojQxx6h0HYG3DoRQhOIzZxF37Kxvk5MmWn2eIW+n6JO2Dx8CJqG0Hqmsx2ca8G1lAzeO7rOH1ituyy0BPa2t4kS2Yv7OBxRhf2dHToPeW9gMd0j9fvEaU9sBvATNg8fp/iO3C/IpdB1I0Qdjownsb91gVwGRmNHig7Fk2Iw4lGYVcv9gaZp2Z71uNQjJeKCww0j4iLS78+BRNJMM27pRiMonjQUpEAbHEkCqs7usVzI4pEQSENPmvek6ZQcM0McLDrAmTtDVrNVHzUNHkWcY0iWVd5Ul5p5yYgb04QxMc/RHJHZFJE1pq3Sz3ZJccFsnhAS3rWkIVmkS1E0Kf1iTu7Bd57Se2YX9wn+y9EIL2+yv4CO9/Q/fRab6Wc84rNgrl/5/RdKjPt8G3IRI82IYD1Qp8ymPZPxppm3eVB1aFHyYsp8uktxA9PtHX7tV36FV77qpaSh5bfe8t/z5jf/Dn/6B97Af/PHvpNf+/W38okHn+CXf/33wFmm/falXbxLhNGYfkjmEKdqRBRGPPDwo6h4Jm3LK1/xPM5ubXHfA4/Sz7IxHeu/gcSJq44yLOacOnWWtuvY3Rm4eO4sWnrasefYsat4yV230o4Db33LPXzqEw8TtceHwIULl0Ab5rMtwHGu3+NlL72T133zH2Ftsk5OA+IVlQaRgtYohiuu2hf0HqxqVav6aq3lvf/Zdpy294GiDt80zGf7xGHBWlg7yDkzijooypnHH0Zjz40v+AbLi8QhalRAEcctt17P2mREPy9ozmhZ8NS5ZjmfN00g51h/K2zt7vOC5z2HQ0eP8ejD9/HeD33SGHfY2t4igeyD2/Go5Rtf+0f4m/+3v0cIBcGTtQCevZ0neM23vZZjV23gczRXqNAxzHdo2jFgBFLRjNOMOAjNOn0/p5kc4+jaCeJ0h/35RcrOaUbdBDc+hG9HuAyiAXUL8OMvw3uz6uF2vFUPX/XwVa1qVU9fqx7+ldnDV/3bjrfq36v+vapVrerpa9W//7D697MGxn/l3W/jxc/9Zv7YK5UPPXKOj546y6tf8yPcdNVJ9rY+we+/6z/zU2/uKMfO88R9F2mueyv/6j9+mG985Xfxoheu8//72X/H4ek6Q9jklXffwmgzU7o5k/XEBz78GY7qyxh3HTcfu5UXfudVvOTWdSQvrQCenq32h6EiN1A8g0BWJZeeUhI5K847U9imOS7PKF7wrKEuEVNkPNpgazojhBF+c0JazEjzPVzGMn6zEhFiTLRNQ+uFlB2hHSO+kLMADSX3lm1bhKZpaUZj3HidgtAv9ikxMlk/Ss4wG+b4oJabWzKlTwwy4ENDk8f0iwWjtcMEP6Ibwd7eeS5e2iL1kSZ05MVAv7nNMOzTx54waun3psz297j6qhOMRkIiUJxnZwdysoWEqJAXEVwmlcLebE4z6milQUux/G8KqTjUK+Iy6gqpCJqhcUocegp7BmznjMZsmQhF6bo1QtMimumagAjMFo6CRxXatqEnk+NA7gcDj0vP2qijOMd4vcMNmVhgSJBjRKNZUa+vr7Po58wXC8iRIIpoYVDBtRt0zYgmCPN5j2s7GhH253Occ/SLBW3bMp8vWAyFcQhM1joSPf18oGTBt4ESCyVHPHPEjUjRMxt6MrC2NkFTMhW6A20yPiml9JZ7HB1tqziX2J3Pax68JziPE4+o2V/0ZaDxnkk7ooiwyA4REOcRdVACQ18omqBAjAkXTH2tOVtmcy44H/DO4xtwQRB1iDSIFoL3ZBzTWaRPEVLEi9J2LbMhE3Og9Q2j8YSiStGE845u1IJvyBRiLizinHkfmU930RIpBYL3TPenaIk0wdEPEU2JcR6TUiKmQkqQtZDKDk4ahIamCTSNII0wyILZ+T0DydsWGk8AxCl7+3tIUVrv2J5vs+gj3jfM5wNFPf2sMPQDiyFbjntOxHmPdxZtMCwW7M2mFFUQQbNaVrQaqJ8KiHN0XUuWiPdCN2rY3t5n1I1IqdDnxGw2I6ZspBYxO6nd3Sk5zpl6R06D/ZsKZX1E23ZsbhxjaAs5tzRty2y+ABEmo4B3MJ3NmM8WjNoJ41GDeEzJPDf192x/wd7ulJwzkhO7l8asb24wmazTjkeID3TthMV8zv7eLpoX9Is5835A2oajwwnWJxNC43HJLNopwjDdZ3d/i73tc8z39kEdwQViMRv2M/ow3Xh00LgFSENEVVBn9744A+NRi0fIpdC1DqdKjomYzCUALzjNULK5JWjtE6lQxJlDgxe6tkVUbEx7R9s1qHOMxmvEVBAxt4NhcYHFfMZi3pOS4lywuR1FnY11VyAPkX1G5jpBQbzivS1AGucZcqbIzF6IE/pFjy8dTrYJHkJrkQVFgQzqMy440mBjpG0dhYb5kImLAsMefjxmkWZ/oH3tGX4DPGWTq3rw/7Ptwc/GMu7K758u3+xyjhrA8rk/N4P+yt+KSP1jI7UpxpZ34lkbHeP82ft56IF7iEm464XfiPOOfrbF7rlHuOfDb+cFL349o7Zla3fKv//pX+DUYxf4+KceoU9wz4ce4LGHH0e8B20Y5oVDay1d69mezVBVgm+YHOtYzCIlCSoDOQ4kHE6FKImff8t7ydMBLZlUMj54fHCUYk4z88VATnD06BFzq/GRl7/kVs6cu8TFC3tcd+1hPvDhT3P3HTfxxje+iN95xyeZTQMlKykPiBMQi9XQuODW225Ey5Sf+Y//kT/3l45z03NeeHAf2eVaXsGvHNeeVa1qVX/QJSzn/ivngYM5GQERzp87z+knTpnbULZ5RUTtAz0nCJlxO6LvFzb1itbf2x4AoG0mNMGxKAtzRYpqTmF1urmccyYs3X9UC87bh6Yve8kLOXLsOt78iz/P/mKBVCtNih3HORiPOtbWW17x8lcyWt+g5BlKwksgl8jaxmHu/obvY3rxEdKwgOCIu1sEHwjBAcms2cQh9cOG4oq5F8UpGtYJ48NsjtcpKdPHXRZ7FxB1jNYOEcZrFEZ/sO/Yqoeveviqh69qVasCVj38q6uHr/r3qn+v+veqVrUqq1X//sPq388aGG/KOU5d+gR3nrybu2+8jktbW3zrK49ydPMY73rww/TZ8enf+mWOHr+Wa9auQWcXSZ/ZQu/a5Z/8/E+RzuwwumqTxaMf4l/+3AXaI6/hb3zPN3Oo8fzxl/4RDo3XEVFaCVx/VaAJkBt3AIx/JZSI5caa/YzZSA99T9e2aBFSjHjnTJE4DJTUgypeWmgCTTtiY/MYDmXa76HqYN8x9I7R+BhlVNA4sLk2Ao0MQ6Fdb5DgcHgW8zkalBQTQ19Yn9ib3O/NGcs6pSkkIv0w4Pq6EIg9PmbSdG4AlG9ofQvJLI+zJoa4TxPHuMYxmWygfWExbCNxTggdORYDHTVQhoHWjRFRFsOCnBtiUfD22otkaJTGBwgQGm/25n1PUJjPLK+7G60TSYh4ggqt8zR+gqY5SCTOB3oFaVu8C6Rs9g1N09KEQBEoRBBHiR4tEdXEPPX0MdM0HY1vaIojB4/vRpQijJpA03QQlcEH+n5OHsxuwnWBZtSiPrOIM2LuabxDvCfFjNeGkjMLnSN4nPc2Y4nQtB39MKC+IUmgmWyQZQ8ks7/YISIkIPiOlBeUbNnHOGU622dIe8S8oBFPKQnNkUhhKAPDdGARB1zwpDQgpdCLUPDgoBmP2NubM8TBJhHX0IhjPiwIPsDaYfB1cZcTTROIQyHGyJAGRCIpGmAacyJnm9AmaxsUNavttm1p2gZpHE27ZhOqKvtzy6JGHc57cj9HtDA9O0VcYDxZJxNJRUlZCUEI3lv2doRcEilFFouekhMlDxAXploXj4pDxCPe0XqPK4G92NO0LUqkbTucBJxAHxeEkBj6RL/oiX0ihIAXGDdjYsxkKcxmU+aLGf3Q0ziPF6GoMo+Zvjc2b3AOLQVRT862AfCtZ197RCwnm1KYzmYMMdJ4j2RlMY+0ayOoYGvwjtIHmlGHZEgLBZeZbvdIUYaYSLmg6ohzR8qm0BdVposZU6fmPtG0LOaZ2XRKCFMunN2h77NdG4QhRXCOXJQUe1QLbReYz7fY2lIjMwRhNOrIKRMXPX2G4hrGTSBt77K3t0vwpqIWUUos9MNAUWXU1HlDA4u8z6Onz+O9RxtPaISudaRBGGIix0jrPKN2zQDfGNGYEMA7j8uQ1eGbYHblvd1Gvs6bAIlCTtkIHEA/QFHFiQCO4BpKnypRI6AZQJCiUGyuds4xLAY0WRSA5ozTwGJ/Bs6z76a29BBoGkVUCCkx8YHi1ZhsvkG85bULEJxDxiNzhaj5K867eg+I2dmkgSIOxCMSQAPOKVJK7SGFxf6AKEjA7NURRqPWGHHA+qRjNBH6PpL6Hs0DwX3xinFVxTlXv14ykd2z2Fh/tpXX5c3xkzfnT85Ee/bn9oXatj35MZ+9WVzawzkvmAmDQzVTtOA1oM4iLjRHhn6PrjvEkHrOPPEZzjz+AI88fIabbryZC6cfZuvs48Q0Zzbd591v+8+88/c/ydve8X4uXtpDKRQRfFB+6dffhRMQzOmkCbCYDSzSQEoZJ7C3u8dzjl9HIz1nz16kKHjfomnguuuOkXNha2ePQkKC0PqOGIW06Ane0+dI2o5oyQwxUooyDAvwAt5xcWeXeG/Et8KDnznDw48AudC1gXnMNKMxadGjWTl0eELJgZ/4t7/AdScPESRw/MQmb3zDn+D6m19M223UGAq1rKD6Icazff9WtapVfaVX/YDyYH6Xp/z8qVVAbBbQ4hj6OT/1k/+ez9z/MP0wsw25K1c83tyJjp+8BbTgDnqE2uYWyz3rmhbnrL8vXYuc90/qWU3TUEqN1XKCJCGEhpwiVx05Tr/Y5wMfuoeYEtS4ErBstbYR1kYTrjt+mBtvup2SIjFGmmaNIUPrBRfWyZJZP3o9j336/Yw2jzK7eJobXvDNaLGNvZ251g8WxByMmg60QRzV+hOkaZjIMdLoGHHYY7b1ILuPL7j6phdB88V/sL7q4asevurhq1rVqi7Xqod/tfTwVf9e9e9V/17VqlZ1uVb9+yuxfz9rYPx8zpS9fR7fmvKCk0e55fobmDRr7OSP85FPfoRrrrmFM/3jHL7mGg5xkhQvcPrig7zn/f+ZV7zwW7nqpsyj587wyOLj5P3TtM0WGqBpCtcdOwQ4nGauPmrW0iqCK2pW3E9T/2c3gicvEoRSEiVH0hDJQ6Jpx2geiEPElQVeC+SBUuYoHYuhJ5GYrK2T4pwywM7+HjvbW6yND7O2fpioAyX2lLhPv4ikBKSM857RZJ3swUkhFyUnmM1m+MbTU0iLQEgtaIY4ZTEvONeRVRliJJVMzj2RYvYLomgopNIzv7TDfH8H2hYBus4zaY+jcQ4UdrefoDglDnNcCIS2o+TebJjbMTEX9nd2TUntG1xldeSiDLMFXgptEwjNmFw8RYsppjEb6MEpe3sLmuBoQkvjW2p8NTkl5v0ecegJISC0zGeFrMa8U7zlriN4Aq7taNvGxkdJ5DiACG3TUJzlXrtmTB8TXdcQPGQxAFM0ozkyHwZS3+NU8UFIMTNf9OQwMAwFLcqh9Q1K8YhrgYRoJKcFIUCMC0ruSamQ+0zfZ8JoTNFCHnpyFlKEYYiUkokpknNhPJowGnWUYO+PTwnVhFagdCwtmjKlKBGH9+BwDNMZs+k+4gQ/gsVih9mQKNkyKObbF4lFabtAv5izNhmTM8z7SKmwXMkZnDCkZNc9ZsTvVTW6o20bco4UURIKKozaEa233B3nHO1oRD+bU+JAX1+TiMMjRjSSguoA2a6h0NDHHu8dRYWSIPiA5iXIW2ysaAGUJni6tqVtGjY2J8Rs5yrJU0QZciSXgkYl9QvURUaTlsZ7tuMWmiGVBPV8JBZizmTfEDMMBVJOqBaGLKyNxzgPKUXEeYIPlBRpXSDuzEAKTjNBQEvEN55WPCVHYjJCAR6kFPK8tyz4xtGMnW0K1NPHzPY0Mu8LfZ/IyRwQ1tY6JqOGUTCwNGup1v9QMpRUcGLEDC2FUfBoKRAcvptYJnhtaILlgYizvwvi6CZrrJkWGofgJKCq+AIl22ZDEGuY3hvzSwveZyaN2ZB7EfoYifPCdCrkVGhaTxccwdnmLw22Iem6YM8kdp5CQlOh8Z5m0trPnNIGT/AOSqaox4s3oga+js9IyYUmCG2Y1IiDZBtBERwgWsiawAmhsegGJw4kIA5aEQpGXBYU7xwhdKCJxneIC5YtjwDmFkCptl/VFsaaszfrcy2gvm6yvCnJxRxFQmPzqUeQYrlZijJqAii44I0gQyHFhPcO5zypGHC+Ng6UgJGDrlzvfIH1TP3y6azTntrrnu7xesXXX2gvfjom+rOpyx8gPPX8nmZTD3Wc2f1hdm1Cpt6zBBZaaCbrxH6Pxc4l+tk2d7/sO9nYfDc/85N/n51Zz3QOFx5/hJe94pW89tXfxP/+b36FRx+/wOb6upGxEHzbMV9MyaXgNKIi+CZAo4y7MZvrEy5e2uXQoTXOnL5ALBEVtb7lFnTtiG963Qv59Cce5cL5C6xtHiKVxNWHj3L0GJzbGnj80fN0TcNskTCbogU+BJpuxHvf8wl+4E+8nqsPb/Lab3k5b/iO7+THfuxv8eF7T+HKQMkKTui6DopjNBqzMQ7ceOIabnv+NfzWWz/FscNjZrMZV1/7HIa0Ryo9rR8T8z6j0VFzLtGw2oCvalVfc7X8cJXKEL9yU34lY31JUxYymVIK5849ziOPnuPsmYc4ecNtB0e8rAwSfHvFRvSK+aOKjkgp2tojNJRSEOcIITzpQ9+cM01oSClW9Y6tIQGOHN3kMw98ht97z0coBVQT3outvxAkOJrQ8IIX3Ml1N95qRLjgbV3EwHS2y2R0Ld4ppQlEhLJ3hhtve6H1Zk9drz71NdiHBCrePmeom3KkUEJGi6drR4xO3E2SRzjzxMd5zm2v+aLfpVUPX/XwVQ9f1apW9dm16uFf6T181b9X/XvVv1e1qlV9dq3691dS/37WwPh9H/wk3/ryVzNyjq204Fzc4ga3wQuufjH/9Xc2/MLb3kHZL8wX22we+Ra+/4/fwv/2H/9HphefYGfR821/9I18x6TlJ9/2DzjuX8tV19wARUAdDgde0QK3nzxOiQNSADUgaMmSWjbzK///wyhVRUum7+c4PE5A80Ae5pTcI5pogJwHpns74CeEtsP7DmSED4L3PaKBcdciRPZnFxlNxhSNzPrEYh6t9xYh555Zv8d8MWdtdIhxN6aMEmno6eeeQ906Pkdi3ufSzjZ57uhG++AKw3yBF7PQVgr4jGuUUTsiikfF40PAJ8d8PqWPcztXJ3iU1nkuXTxDLInQjlAcqoITRUjsz/Zp24Y47JHjQNds0DaBlDOCkLMy7hqOHZ0wDJlYHM4HsxhO2ZTbs55hmLJggRYo2eyPXRNwfoLmTFosaMbruCC0wTOfK0mVlAZSyWZXrQsaneIxJa4PHd1oTNu2dOMOVehjgZCYL/bIBcp8n7i3x1yV2bDAdeBLT46Z1GdShPkim7p/CbiROIPlyxf1lAykga5pKCUSULxTctvaeyiKikMV5tNZtcQ36+c2BDy2gNzZnzJzjj71BiYGx2h9TNt2qCjBjRBxpiAtjku9MRdLUfo+ImLn6CnEIeHFUVCyKLFEgm+gRLYvCUUDSYWYM221xchasGnMIcUy3yV4A9yd4L0ja7L7VSH7GXvJ2EVehCRCEIVUUG/KWFXLS085WuREEVrf4mlQpVp5KJozAEM/kM2ro6p/C11oDoDNOB8gFXbSYMr6UiAHQucZNFGK2LGTQhOYz3pScLhii/c+DTgsJ6OIglNiSRRn5IMQGopC9plp7EmZek3F3p9+YBgy/WJg0rQHVunkSBcCIg1xWCDeUUTQmFkbORoUj0OLY7oX2dmbsbPXs0iwv7/P2niMiDBqG9qRR4kojpxjJYzYPOPEMuYVQMTIImJoeSkGcztnim9xNgehQivV9htTbZdsbC7v7B5NKN5ZhkegbnWKjQlEUIyskcuA14BXIZVEaBqcGItNijWnogUvZtdfimVnI0pSy3Y6mLuLmupaFch4deBMRS4WjkKUhOAROzAtgjQtqRRyyeQYQZOB4s7Acy2VRSwOJwpaEPOmIiWxnPvg63UsOG/tuYCRsnIil4TzgsNRouWpOOcsDqBATgUn0LQexRwHtCgpFdpuDGoWMkvGr2DEhpJsMeLEEbxHRUlDPLjGCWF/NqMJHcELJZm3fKE83d7zC+5bNmyevJH9/JvrJzPWPxeP/PP15C9mA/+FHGP5Gr0IqvX9dcbORx1OAWkoDprQUUpEpGUR97j/4/fwtt95JzfdcIKHHr7Ev/jJX8eJ5/qTE77r+36AgcQ8F649dohbb72RR0+d4onTl0gFYsyWiYbjxLEjPO+Wq/i99z3A5sY6k5GwHYSmbVnbEPb29wmNMJ8PRgIB/st/fjspCutrY45utlzaitx64wl++IffwJlt5f/4tz/Ly192O7/x2+/l0u4+wxAhFZzzuOC4uL3D1v6Cj37sUX7wh07wPd/+anYuvY15Hzl9/jzBOa46vM501hOL49u+/TW85Pm38rvveD87ezto7GnbllhA84K9rfOcv/AIz3/BqwFnpJAv8kOYVa1qVV+JtewDy014qRvzK1nrVz62/m+LD1QzKfW2vgiX92pSmejP1CeW+zctBUU4ffos+9Oh/p39rtR4oFJdVpxz1iPV8tPEqdnGCVx/0wnuvfdjPPTgoweOLDkb+TF4T9t1jFrhrhffzcbhYxZ5NJ9SKHjnydKgkhFVnCrXP+d2Tj/4IRgfwQG52FpJnqZnLp1krvwZQBZHQGw9o4kj19zIZLr2JbxXHDzf5eda9fBVD1/18FWt6uu3Vj38q6mHr/r3qn+v+veqVrUqq1X//krs388aGJ8cvZ5rn7PObi4czvuc2b6fO2+6hpE/xPn5DvtbG3znD/w1Tp++n6PrR3hw9xSvvPtPsTf7DI99+rd4z/G7+FPffieve9H3sr+3yTffeRPbZeDR7RkjL2xuTOiKKei0bU2JF6QOmy+O3fbF1FPtY57K3lOTGbLoZyz6GePxBCjVPtdUt9CyWAy4AGWIdJPMZG1CN15j6BfEOEWcMhqNGfYcMe2juiDGGXHek2IhpUg/GIjaNC2y6E2NGhO9DpaTK4k0KJmB/emU4BxdcaRgbAznOpqNDtXMdLrNdHaJSWyJosRuQlg/hAuO7ITiPeP1w+hMmc92iYtI7CNDWpBKQnA0TYPmJegKh49uWG6zjgjSslgsMBWw0I47Rl1HJ2Oci4zXGpoU2N3tmU7nLBaFvb1thpiIaUEaIqMQ2NxweIkMC4fPDXO3IPa92VmTiGlGHAbm8wV930PJODL7ZbDsl+yISQ0gDQ4XQH0mqadfDLQuwFDo+4gfBYIrSIGUoGgmlkguDVowYDwpMSZC04IDyDiKWXQ7j3fBOCvi2J/1FQBXGu9QNXDNe4dqb+r0rAwRUlwYuNw0tI2nbRpGDiiZbtRSciTnzGw6w7dK4xume3vsbc9YLDLOtca8bIT5oqd1I/KwQNQy3nGQRUklk5yBhikt8F4oIkDCFaF1SlAjKxQtFGeTbhBPzh51dv85hxk+h46mYOpvCjT2dwb1C04hO62LRcuTB8E1jYH01CgCot3jZMgGSHsfKK7UnyuhEUQKTdcY8KoObTubA2rmcxkU33hiLnhnlk5OwHeBkguqDWUolPq84u2xw5CNIYWnHxK52oeghVSUrMK8T0YWyAL0zBYzc0RAmLQjI0aQmA893gtRlVx6EIeLQLHxsre7hzhPUiV0AaGQ+8jGxgZ+PuPw5lEDadXU4k1wlDQgKpRiV7aomH1TzgiZ0DSIwHzogYKvc6UjkbJZoogYSO6QmiNvyvui5qLgJBDVro0ER6kK8pgLHo9HDQjO0fxWLPabvkS8BHtPUsIoDd6aUB0LWuq1U/BqQzJXmxaVOo8LFE2ogneOlFK9pzxkGzdarAlnpzW6XRFyJR4ovmnI2R4zKEgqQEGBvk+IM9U5BXsNxlQhxUxKA00TyEkJIYBTXOPRAoqRBxYp4UQOrmFRA6jt6jhKKpRimecaBBeElAfqXYOqPZfSG6PNGWHCiSnsU0o4Z0QHFUGTIq5hPhR8JRQULZQcjYDwZaqlhduVfe7pvq4w/sF3ZrXzpffhZ/v3z44A9+QPDZY/0yU5QaGUQsEBA1IanC84hJimeL/BoWO3Md44Aece4Mypc7ziFS/hY/c/we++4x6UTT7xoQ+x4T2LOOWFL7qFxx+/xIULe6SiaFmYU4UIosIL776JP/uD38n65tt4/LHzZHqm0wWxP0fb+cq6zFAyTesQN2K+2EG04cTV61x74lrOn3+ATz/6KP/TP/4ZfOjY29/jifMXGPIAqpSUkcbba3eZhx98gks7c+58viMOO+zt7bO1s83S9eH6k8f5U3/i9Xz8k5/hLW/9ML/8S+/kl37pd7l0aR8Jmfn+gp/92bfygQ9+mhtOnmTzsKMZB26+7YV0k2O4Kz+UeZo10qpWtaqvrrp8Hxe4orfYjx0IRkh7mrlVcCCRmGzTnBNItXhD5cnb+WeYH5aPeeSRR0kxE0LddFcbzqfahaaUDjbBrvGQHSlmXBP40Ac/xO7ujKLWT1EheKFrA5NuwpGNhttuez5IsPMXY7x71zIaHzHicLGe0IQJh47dRPDUD3PlSpL9Z53X05VTsbVGBqol3Why7Bkf/8XUqoeveviqh69qVV+/terhX709fNW/V/171b9Xtaqv31r176/M/v2sgfHx5hP83vt/mefe+QZuP34zLznxCtqmJQPXjG/lda+A+87O+PNv+HZOHPa87WPv4uLpLV72sm/hE0646dpNNsaBsT+MX59Aq6xr4ImtS8h4DY2Rey89wMnDJzk+Ooo4RYuY/W8pB9bAS3vgP4h6uov82Q1ISSmzv7+LCDRNR9/P0JIMOPStqU+L2a2HMKFpR8QKjsS4x3y+w6zfZ7GYkoqpFNFIjmYJnGRgPsyYT2c0Hlwxy+3kM6FZUGRCHBJDnpPTwPTsGbpuRDcaM53OyS5BDpAhTmcMvWWabG/tkHNEWkhFcM2IyShwZG2N0XgN33iG+cLs4CXQNIHZPJNyYdHPCcFTciGnhCsgEtk8PsFV1XA3ahBJpGFBn/ZIs8CobRFJDNNLtJ1HozAsplw4v818MSUluxE0O+auEAdjzaBm8SxNIA6RnDI4T0qKJssgHnImZ1sy5phNyZkjzjsa5/DAqG1xXpj1A8439K6gqsQMxJ5SIt63xAFKitR0Y5bAllNlHASIpiYtCfGeHBPFL1Wwdr4qIM6bSrXYwhcVcnYEFUoSUM96cEiwceycQ6UAC2IUPBioXHO1sxbm855BstnnzyMpKc5Fm0cLuFLIZaAJjlHT4oOiwUMsFFUIAaeKk46iuU6c3pwEKKAZ5xxZHVkU5wRSQpwpc503kLDxAUVx4lHJIMaW1OLrRGoAZM6+8p8sG0dUagaPkIupwx2ZpQi2KARn94sTwBmLCTVLjzREs7OWQkr2O0XxKBozaEKdoM6hmA231vxn/PI+hpK1gpQw1DErmkjZAGAUYrGJP+VCStAPA21nduZt8HRNsOwNhEYanPPENOAdlqWNTcYuBLP6V7U8bIWmKJ238RzCiJwKoWnMfts3IJlKyqLgSGpvcCKRs4GzWkxJn9Ngedt145GKVLYVgCmbfSiUEq25ugC5qpZzwXlnpAQFkYKWQlbDzr33FF3gdLkUV0SN81OKklXNxl8gaTKX86L02SF4VOw4IpV15iCVjDhjnanWzKQCWSGVYm4GuVAkIqp1MWAEi7Jkx4lnPgyg0DVmb253jG2I4oHdeSEsGXGmA7fzAdSZQjyXQinghoR3guaIeBsnOefLzR85sKFXUdBsQLi0CAHElPM+eMtAp9qul4Krjd96eDJbGVGoeefB2X2zZP+V+jdS3RccsBgGXNPSBnPw+HKUPmWR8YXU52IhPutjyJOJbs8my+yZa7lofMriURVcARwpJtAF+I4zj91Ht9Zy1YnbOfPE/Zx65JM8/0WvZLR2Fbc997lM1iec39phPJ7wzS+7la0Lp/mB730Dz3v+87nqumu58dqrOXNmmzNnLjEkQDzBexyZY4c2+bbXvYqt2WloT/Bjf/Nv8BP/6h/y+OkpV199mDtuv433vu9DDPN9urala1quvfYEFy/tEVND8J7z5/a56njPC+66jns/eYqLOzP6xQJX4InTW4irji1OzJUkZ2KfefiR06TsOHJ4gz6t88nPnKYbb3DocMfhPrGzvcvb3/E+hrjgtluOcc0113L6zON4p1y8tMeRY5vsz3se+szjHNno+JEf+W85cvw2No9cTUyJtrX77HL9wa3DVrWqVf1BlT7N15W1LvVnNS7EOtDTbMoFVDOqAecDudQ1JbaBXT782XyYqihL0xjnxYiOBzmclm+27Md2TK1sdtCcAPjxf/5vOPXEJcBif4xEqwTf0LaB1nluueUkL3jhK5CSoZKGUcGRjQ5YGhDHMCxwbsTRa2+9bPt5xQfYz/YDSFccSqI4oSnB1jXLxeiXoVY9fNXDVz18Vav6eqxVD/9q7+Gr/r3q36v+vapVfT3Wqn9/pffvZw2MX7NxGzmOufXaE6yNHTcfPYpvPE4cdz3nBu68/hgnH9hjMhIKhRuuupkHNgZecu3zufpQy8PnZtx/LnHbyZMMauDn0CuLnDnReMaNRzXxyfOP8arrDzOLhQ0vIAZibG1tcfToUQNMqw2NXaenb+hfaG7KZ/3siq+kMt/AQJBpSsQ8kGY70GzgugbN+yQdmGfBOVNBt+pxQWmcY2exzXy6T5lN8dqyvbfFfOciw94uUgKhG7E/bDMsFrjiEHUMs11257uoeBaxB1WCU0Zdx2RtjdmiZ3t3n+l8QRc6Uoz08wWaMzmZPW/bjnDiaVpTOKsWSJ6UlRh32E09+5MR41HLaNLggyfGTI6ZUdPSelNqD8yZ7iZSNPsG74Xp2RnndrbxJoXGS8Oh9TVKHuhay9m9FDNxSARv6u3ZdGAoDucbuqYhzXZpQ0dxyu58zmJItKEhRyVnJZeZqbt9wDdm+W3YkphqsxSKczgVGgEfGsYjz8grh3Bsth2PDwsWo4I48FnQXAz89Q1OG0Rh1AoaAlAQDwjkXMkYUtk3ulz+ZVQziCDLnGEMoQ/OvvcukFUN6ISaRVxVvN5Uw0XtOKIOKY7GY2rVWFCxvG1yJs2UXJXUTRNoG8F7T4qW0T5qL9tsu4DdIwoqQu57vILRNirgbwgng0bQQuM8JSdiUXAOFY9kUxCLF4pmTN1b7Pw0MaQB7wGJIK7mmTfGbXWOnJMBi4YumlW6VnB3eWe5paU2ZlFfzMYjE6uKuGVYmDoYMkoF1rXYewME51AnllnvoZRcs6Ytg7ske3ypvaWoQ7NlyqesDFWZXLSYTbkKQkB0ILiMtAHnPEOybPKYklnPO0c3bo20ow6Hgb9OIC0SsVHarkMKdL4lo4SRWXt7CfiqEnbqaFuHl0LOmeACmgtlPke6jpIi/WAm6N6Z/b6mAc2KNg2z+Zy1yYicEr5pGGKkH4xg07YNaMY7T8qZeRxwvgU18DaXTNM0xMVQwXPHECM+WNRB44zxlVKkbY0EUCqYT1nYfaEG0jeNZWMjzkgMauwvv1Rop0Tj/UHfL84h3hnJIEPqjYVrY0LxvjLXkt0zUTOpwNbWPofWR5Ts6+KgWr2rNfglcWoo2fqEYPe6g6U9TElqf2M0BhORZ7F/SCULmH2LqN1rOZflr/DO44pdq7ZrjfmWLQfeMO5ClohDCD6Qo5FLJAjFfMQQ9aAOJ5DV3CWCc4gTBpdBGxbzGV3rySQQX50Lvvj6XBvgp2MHPtnOR6rK3wgY9oA6J8oXFm3y5Xd/+eyFo+IoDIg2aIpcuPAAv/Ybb2dn63F++M/9KJfOPco//fF/xNalR/n7//BF5JR47l2v5bqbt8A3/NYv/zt+7wP3ctutN/P4mfMcu27g93/ml/jUJx6iGU2YLRao2Fx33cnjrHXw5/7s9/LA/Z/hgx+9yKc/dg+znRPc89FH2d+Z0TYNZ86eJxcFFxitbdIv5iwWA/1iToqRQxvrNI3jM595ghuuv4Y3ffuruLi9w3s/fD9xEObTKYcOjyk5M+rW2dmdUlQITYOGQJLIv/vJX+GX3/xOdnd26JMA6wTp2J8NfPrBcwSJ/I3/5i/wHd/xJt7x2z/PEANvfft7uO2WkwyLOe9+36d569s/ymT8z3njd72Rl3/DG3Gupbh18K5aLT3DYn1Vq1rVV3g9dVNev1e5zFiXKy3LnolpXnDS0HUT2i6wsXmEok+2OnvGM3jS/K+cOXOmnor1b4sHKk/qVzln+z5nfAhIaIhxiqrjN9/yHlB3QIoT8Ub4lIKEgKC88EUvZO3IcbREkNY+lNYCRVDvUB1I/RwfRjhf433U1gNFbUP9dFmgT/e6AIoYddMByfU4rXuvL7FWPXzVw1c9fFWr+nquVQ//au3hq/696t+r/r2qVX0916p/f6X372cNjH/HN/4gk2Zgw48IDsaTEc4prmQSQjNaZ6u8lX/ymzu85vbX86rnXs0NN50luMxr7ribE0emHF0b6HxH4wpCyzztcsexI6x1I5J4nnfNHYDHFeHU+cc5trHJNZtH8N5z+MjhA5CyXoLPeb5faga5UA7AcAPVPDEm4uCQEvBOSf2UxaUzyOQQ0+mUuH+JVDp8M0ZF2S8z5nHOTr9HHKZsnz1LjPuMW8f2tGdn9xI5zhn6whANWIr9gHPQeFjM9kl9oh8S8/0FUhSvBS0DzoP4YBa+QGoMuJs0LcUXSgg2iJ0npcxiYbbjBsYqLrS0bWDUdqgqs+mMYRBcE4jRFJZzNwMcKScWi57ZLJOTpwnCeNTgnCMtCjRmKdzHGYvdOTEnXPAUgWHIDFEpSckpm9p4yYzRQhMcSQdmfc8iF4YYcepoxONFaIKvf1doYiAEQTyWGe3sxhAwgK0CZTnBLCt7ktA0RYs9Xlwmq+UpI4oO4JfTSLGMYEGXJEezp8gJ07QbKK8KLtjkI4gdW3wFyWvWgYoB4TkRUQOiay60lIIvgwHry1EsauDysLQRN/DY+WIAZr2ZvQ8H1su52PgOjdmV52LAfMx2jnkwKBz1lD4T2kDWWIHVA2ga5x2LpAZK1uctJR1cj9B4csn4pkFjrK8XnAhDsnvEeUfwLTFX8L++NlBbhKogzsMyt1zVcq4pB0wnUSXHwUBHb5NxHy3zIqdYWZrmHnFAtVUDd7MTRGF/PmNtPKn59ormeDAXqCrinNkt5XodcFDfV5bvrQjOKaEJ+NDRx0IfTRGccjb1vJ2I2dx7T86ZVAopRkZNRzdqCK3Zv7vgaEKw14IiAs5BaOy+1JwJtUlkKiCbE914TInJGoezjPoikHLCY9bz23v7+ODph2rtVJTgPKEdmSq8mPo4DkagCC4QaxSCk6V9eURCJX8oNp5UcXXMOQk0wR+MMSeWHbVs4KqFJtj1LyUj1XHAFOv+oJkG35BzphQjWYgEHI4UY73mGIkB8N6RKoidi1nGpJzZ2d/l6JHDCNlA+mwK7IMslHrOpZjSfDkGlw0+51zHt70PvjohZC0IthjwzlkOulR0HFOML8deaIw8U7QQgqPU11coBLFj1yB1ihYSDieOnBeUYmECCHgJqARUhSw9PgRiH/E4UvTMZrtMRi0UtWz33qz1v5Ra9rNn2pxf7plXstnrRp3Li46Dx2mdv552o69P+vtnPp/PXU+2l3vaR1xxvHLwvMk5JDm0JIoOfPSe9/GP/9H/xuHNI1xz/Bix7PELv/wWFM8/+yf/K29845t4wcu+lc3RJqce+Qh3PO92XnL3p/nV3/4Ab3n7Rzj62x/lthuu4tbbbuSeD9/PbJF46cuey865LYurSJnTT5xhre14w7e+mj/9Z/4i93zot3j9t76Ed7/zE2wePsR73vtxi5MowqVLWwiFoV8QgscRmE0ttkS1YWv7QQ5trvHEqYuUBLkMTDYC11y9QYnCfFZ43nOPsLG+xrvedy8jdTgCogsuXJpZD5OB8xenlDKnbTJliLi1wL/792/m1379dzlz5jz/69/5f3L8yBofv/d+fuDP/BkeP/svede77kFd4Pl3fQvqW9quM5eEnHCySXGCU7uH9OADmeXYuPL9Wm3aV7WqP7h6pjn2qT9/6jxrm3Gbwp/6u6dXoTxprq7Ez0cf+SQf+/h9NNjazcmVx7L12rIXiqodunDFRO5Aldl8autjtXyxvHTCuWLzvsw4WzqxCBhhUpfr9uWGV/BOzCHGOdq2YW3kePGLX2p9SgXJyT601R7nNtCcKCnStCNEgq1P6gePxutzn2+7+dnXi4LDoaJGguOZ+tcXeNxVD1/18FUPX9WqvkZq1cO/nnr4qn+v+veqf69qVV8rterfX4v9+1kD4z/9mx/hL37nazl2TCkacKKoZorzNFVxecPx5/CBj7yDuJUYUqHkMaPRhI89cR//5f3v4vbj38YPv+ZmPJbLcXRtYidblAu7+/QuMXaeq8Yb3HD4KIkl+0EJPjxp6D0d8P1UFtyXxKBTW3QUxRTU1UJdxVEUSjFr3wuXTrGhIL5lOvQQC2u5haDszbaZLXZx3iFDIU8H+n7BoonMtnbo9wfmgzIbDABL8ylpviAXJbQOJ4U0ZPZ2F+QsdG3LeNTQNI62czRdiwvOBoAPlJItV3n5etSUx20rBkjXvGJ1zvJVSIhzOLwpaVUY+kguIOLZn/fgXFVLNrTdiNI4pvMps2lPVsjYQqgJDalPLHMDnKt5xUM0oDgrKVqGMC7YsQEtxTJooGYVW8N3jSNXW2uyUjBwPXloWrPyThi7RZzgxOFxDFKY1zxscKbUFaErEBkoriqWZfn+mvKYqkQWwNdMg6wZnGmcS06I+KqaVlPA178TyRVI14MbH81QCuoFnFDqSF4C+ahU4K9Y5nfNUJbK2smqaKrn5m1M5pRQhJTsmofgIBsYrwopFcQVigRSMiDUZwN7+z5SXAUzi9rzajGFeF5eLyAYcSHnbMr3ku34MXNgYS7OMplV8D6QSyFme6+KLgklevBcRUtV8lqusqpZTlum9eV7zqykM8uMiyUAKUhlENnzIctrCamqdB2ORT8w6sbEFA3EFAN8l8fPKVWgVSpYWux+WfqIaGXeestPzwmc7/DOEyvIXtRsRkSEEIKdp7O5oA02R4Xg8H6ZAwVFB7xXW3w7T8kR74T50NONRgZQx2jqd1W6UYfmbNc02zgVJwY8OxubiyHRDwOHxptmHa/K8qKUlC37mmiqbBxOIQ2RYRgAjwSPaCIPmRCCzXM507atXXNVpICzi2LvmZj1d442Lk3tL6iIEU1KoZAomgnNqFqH2/Uvasp/gYP7PaVUp1prqSpKyVpzvA0QD6FBC8z3pmysTSgl4lBizpRsFueCUDJkLTYuMXabO6BT23y4VJMvx2Kq0RVGbLEmTqmP855cUt3A2nV14m1eKOZIICLkmPDeVQ96m4tSruC3C2iya1CK4n2DSItloBeyRpsVHAxlgXNC7JUhFbqurWC/9QahKt+/yLq8EX82x5DP+lqoJl5P2Uh/MWf0bKzbnvkxT/calt8vyRqKywPTrdO8632/xHvf8Qm2zj7Ioc11PvXwOf7rv/kPmYw8Q+45efwEXgpv+e2f555P3ENQ5Zu++Y3c+oJv43VbUz700Qd52StexO+89b104032dgp3v/Amnvu85/NX/+qP8Q/+7t8iiePd7/wYP/fL7+C7v+2VPPd5N/D3//E/5pOf+CgXz+5x+uyMMDqLczYPi7MF3+bGBs95zkk+9emH8N7R9wMuCMpALsK73nsvk1HLrF/QNGNyFi5dmJOHxI/91R/izMULvOudH+RFd1zPxmSdT3zmCXb2epoQcVlpxhvkVDh+dMSFSztkddx1x3P49H2nec9nzoLLvPs9v8POpX3uve8UR44f5uoTI/7sn/8OfvQv/w2OXXNzvaILKI7d3fMs5qc4cfUtqOsqecRhNiKfPWZWtapV/WGWPunrJ82nspxH6/pC4PJ9+/nuXyNRnjt/lu2dHY5Mxjzy6IPc/oJvsL4tcvABqRgdkOxsnnBuucG94gPUONgJCLZuFnBivbqUcrCPcyLgHaOupYjS9+bIVEo9ZdWDY3vviDESRLj+5HFe+A3fRHYOL4GCoGWfXBYIE9QNNO06Iumzrp3Zxj27+WzZsyyGZfl6rriaX+KHlKsevurhqx6+qlV9PdWqh3+t9PBV/17171X/XtWqvp5q1b+/Gvv3swbGv/cbXsz1R9Qk78wpOsKLg+LAJVx2PO/qO/ihb7uOQ+06+8Mu9zx8H3fecBN7sxlnH3sfaXuNs3fdzNVHi+XXqpA9kIVDoxZpxgbIiLIxWcfpEgBzB2/M8v+nNu2lJcBTB9TnAtCfqXIuJMXAw1xzmisQUrLSSyS7QBuOMzSJ6WyXcRNoZWBP9pgO2yx2F+zunGd/6xLDYkY/E2JfGDUj8JHpfJ/FdMBpze3OikaH9552pEiTyTEZeFQKbdswHgcmE/Psd76gYspuRcz6IBfLy1UB580xuVp46zIHWwspDhRVxDtiX3331UNSUknkIhQdTKksggvmLS7eAMrFNDFEs2pX7PoOMTP0veWkVyVuVmcZ4K7Be4dXR0qJpH21TjBgKziPZssitjfAvi7FAGlKBU7NH5xG5UAdrqWyFypwFepYSGQDBBHUQ3SOAaAUGnUH+d0GzGPAqxrwF3Mm5Ww/VwM/S1G82FMVzcSULWcdoYipwgWtoKIpaLUoNJ48JAPLisUAqBRT3SpULyB7icnyiM0W2tg5osZ8EbnCglyVVAqNCyhV6ewuG2h4X9ibzRiPJ3TBmTV3gVQiUkHnUix92fmapVzs70squKYhxkLWRFBvqnrvicnA2FE7phNBS0FywjLhy8F9eJnVuvze3stYgUiKvSZwNk+5yppSG7s2Zozp4703+2sb6LYnqBka3olZbtf7FXXkIaMlk0vBOXDBH8wXgsdJneTJB6CqOIcXR06FXAzYFcHeY7GM6xwjvm3JOTNuW0LwtI0nVnvyZXY2asrxFBPdaEQuiaZtmc/nqHpi7Bl1HWmItN7TOIerlIMUE13XmQoZau55neBVDFBW40FNZ3PWJms2X6qiWSmCMa+yZawv7UjiMOB9oGsaAJwLIMXIHs5dnjNYKuaNkBSCZYvYzx0xJZw3BXRRpZRswLWasrvrWlJK5AIaE76pxIFSLG+9qOVrLwko3twIqPcPRWhdsOdZ5m8j7Ozu0oSAqwSVImLqabk8v4XQPGmsLMdhKZnQhAMSymXSVKl29jYnWpa53Qs5lwOXhyV5Bio5wIWq/C6oZpy3FipOKDljaQTe5vOqnkcV77qDTPis2QgkxjihSIs6z3w+xxGYTEakoiSWqnQ1gsKXAIw/Uz0dceypP1rOPbbu0c/+3ZN+9vnP8dmw1D/3Y57pwwVbA4gIWc1B5NiRW3nrO3+Cxe7AoBGnidE40PrAnbef5Hu/5/UcWh/zH37ml0j599mYjOnGJ7n7rjn33vdJtvZ77ticsJgv+J3f/STf/oZv4G//nb/HB9//Tn7up/81nsSf+dP/Fy6c2ePG227h0NE1/s7//G+YLYQ4LFhfa5jHHo2Cc746XyiTccd41NC2jnHX0IQRs9mcookh9ThpiENhL1lkh3OZIIXrrr+Ghx47y2+//QNcdeIQP/D9385r/shrOH/+LP/iX/8Uj53a4U//4B/jox+5l3f8/se45bknecEdJ3noocdo19fYHDV886tv4/xWz3jd88Y/+t1MNo7g1o9w8exj/NE3/gmuu+F2YlzUuVJw0uK8cnj9Gp7Y+Tgf+eCvcvudr2W0dojgWg5YSvrs3v9VrWpVX456unvtMinxs3/+dN9+tjLpaZ/pSfO84AVS2kGL9cRrTt6EkqqryXIdS91z2NzgnENzrh9KXj7eZG1ia0nBopyGAa0RJst1Vc7ZemkphOCxXDQ1Yqakg2M5t+zTRl5sGuGWW65lPDpOKUrOeyy2zhO6kcXFNJ4i3RXn+yXj189Yz6bvfTG16uGrHr7q4ata1VdjrXr413sPX/XvVf9e9e9VreqrsVb9+2uxfz9rYLxbzzgXcLkwlIaUCpMOlkpBkYCo5+ZrLAf8Vz/wPk49dJHyyhGbzTG+/9V/nft2P8iH7j/Fnbcf5ni3xqE1jy9AI4yaBqcVeXSmAF1enCW4bUrkCkAdgONPftGfTyH+TBdmOehiKsSU6asa0dfzyDnZeYmpa0ssqA6ErqpVtfDYhQucfuwUw3TOvJ/jBcbesZj39KmnqEfigiKOkoVAY03NY7b0TvEIudjzFw0UjYzWGkajjrV1s6/PpSeVfACYGdgKeFPQJi1IMhXlUgVLJRxoBXlyUiTb4qYUpZR4AFBT7Dp572wgx4Rg9trQGFjvA55qob1U6IYRzkVyMtWvV6EN/uAmRD05qWUuqxrwV1kmB+ClcxAqWCvGVhE1K3OHMhq1NMFYKs6Z7bMW+zsRJSRTl6uABmiDZzqfs+gThzePkOYLFjlSUlVJL5+7gmQlG8CbKZUpE21cqpp9hDNgT7VUFT5oVWIvbSZyKRW4q/brGDjoEIpArPpx5zwORWM2ME5A6nVxYQnUib0PetkOWkRoKiBn3IUKPqsByaKFUdsxxAVNM7lCld6ixSY3Jde8b4dlQSxVwQGymtraWy49mL21dy2jtgXxOGfK2ZwzguVR2DWoIG7Rg/vKiZEJuiYwxFRV04rmgoqpg5csH+cMCNTicA5bFC7tO9wydwIET05GDPHBxpXzAYrZqHtv52323Qa6L0FeI9pgAHK10V6qsV3w1anAMr0LxfK7ncN5oWttAu/nc+JQaJoGw3sbgvfEPtK2nlE7oR96QteSK0sreHMw0FII3jHqJqZGj7Hea6XazDuCE2gaEplclBIjGSNEgKePmfF6QNNAzgnvGmI/oM5A7NCEg7kwtN6IMwpdzUzHeYRgzUiWKmqqpboc2I2XbJsCL47slwwzs5pXNSv7mBNdOyIr4AJezf5/mM9pvCfpEiD+7Pl2aRuWs4HlMVaFdbLmffHiJdq2oxt1RjxBULF7MDh/QArJ2TLanXfm0MEyYqFGGDjLM0eVlFLduJWDeyfHDF4o7jIRi3otbWzaNbJc+2DODMXyz1NKdt3qeJNSX5MWUrVnp3gKCSWSSwJavIxwEtCcme71jMYdTWs9VTShzlFw+GAOK/plWC08+0NcfuCy337+xz/5Mc/Uiz/LneWLqis35lcwL+vPvI+srR/npS/7Vv6//+Pf4r57P8rDjz7K//7vfrXGGnQ85zk38L1vehP3P3Afa+vH6OOM3UXkH/2Df8If/66X8Du/9zE+dO8jfPTjD3Drbdcy2ReuOXkd1157Nfd85FP8m5/4WdYmYz74if+F6XSPm55zNe9770OodBw/0fL4Yz17+4pSKqFqGU9gIQ6L+YKPffR+W4y6wPHjh9ne2bb4icoIzdHIS5oVxXH60XNIzHzz61/Hm970x1nrMpNDJ3nzP/kf2OjWueXmwPd9/w/xwpe8nw9++BNsbW/xqfszL3rBjdz9/Odxy50v5dprr+d97/4trrnuFs6cf5gXHLuGm59zF+65r6KQqmuJXUupG+1UIomeY1ed5OKl0/h2neIDqo6lu87ynraFceGp42FVq1rVH2TVeaOuq422ekVZRgh2X15p1/aF75mKCsNiQSmOZhRYXztus7B4MuVJRxQUJ0pKkeDb+jgQZxZsly5dRLzFr6iCD8FIinWtuzwHV23ZxpOOvu+try5f9vK5KlnOe2VzfY31yTrXXXcdGne5+MQpDh09iVelGa3hXVs5lhaP4pDP22O/kN515YcYz/xB8hdeqx6+6uGrHr6qVX0t1qqHf6338FX/XvXvVf9e1aq+FmvVv78W+vezBsbfec9DXP/6wxxfE4YY+fTFbY6sjbh2Y4OR96gkHnjiHCeOHie0md/5yG8z1ucxmQycvlA4dvU1XB2v59jGBK+wM4tM1jwtBn5pBSjUF0Q9og7ErKOFyyCKqoGeopZfXCoA571D5Jm9+Z8NYJ5SZogGIophcJQKkFYkFlMaNki3xoXZg6TZFrvTGadPneLCow9SkoOcQSxfOlrKNI0f0TYNs1niwvaCre05aGZt1NJ1Bo6jCSk1N1cLjoBGTwiwN52zO+srOQADZl0DWkx1LdUwoTZI33i7RSvQBgUnpqDMBXJxZu3sBRFXf1fw4m3R4OpAqipFcXYT5QINjuI7U2cqiAs0wWCrnLy9DnWUnAgVoFQHSmDUtgYoVUArxh5VIYgDMUW6c4646JHgCcWT+mSK3c4z6RpUBhA9YNMVoOSI08KAR5aAbjH17Hi8xs78EvPZgrbx9lZWhT1U6+OqHM/VOlwEA2NxppgWU5iTiwFxaur6pmlI1c5cRHA1c9qJmFF4xf6R5aKsEIqzMSwWQWCAtqDFAFoVA8FKtf025SuY2bxiFhiXJ6xl9sOSPFKco6D0Q2Q8gax2vVPJUDKNDaA6ESabLqo1ulZ7D81KqI+LOQMOUVO8FwZin0E9gj+wji6iB8pzAcudcK7+XsglIlIfr0JhCSjawtVVq20fbOx5H4wk4B0SPKoZ7wIplYNjS72OQ4z1ymh9fwpa8zMMAF/e6QayC1r7koG4Swt7EWsURswR0AwUmqalOGE0mZAXC7qusXuqAq+5OgI0oTFlthaCN9eGHDNNVS2HEAjeXX4+VZyHxRBp2tYAWMyZopRCTIllAy1a6NqO7d0Z6+sb5JgIYOMTaEKD+EoucZbzkZPlojsnlieuchA94LzNrbnStGKKhEqsELX3XxtbdJdc7HvRSjBQSrUEd0HIxTLtHUubenNYsLFb7DlUaVyoYLNlknvnD5TwWm8Urb4s+3t7hLalHXXVZt82hzbnuINFhrHQLCs8eCNl+EpiObBrr6C6Uwe4SrBagtuVZOVtLOaU7TzUFhRLKxnnHKkSZzTZ35ljgDfiSaWaWNWvHGS1XHgRD65Fak8RJ/TzSE6JjfUWfHUE0GLtwEkly9gmJ+syw+WLr6fbXz8bW7WnPv5pjsxTFx2fawHz5cm+uvKcn/LcziNNh1PlW173PXzTN34f73zbf+LmG27h7e98NxcvbPOxDz3Ij/zoX+XCds+nPvE440MdjXiObBzi+tvu5OP/+jcpMSEUzjy2w1133cjFsw/yPd/5Ju5/4CKjyTqnt3a5sDNj5B3bl7a5/zMPsrs7ZW9vq5JdkhGqVBiPWzY3N+gXPbPpjD4mKI6cIyFE+qGn7we8NGhQui5QIiwWC2LJhNGYdnODMOxz4vjRg5iIhx74ECNVnvu86/nF33gPv/iffgrfZHb3FwzbM/rieOwtH+DU6X2+a+0abr/rVXz7m/4Ms/mUUbPJL//CP+P0z/1b/tv/+9+jnVxrd4oDVVfJdNYrXG44c/Zx1tc3CAJ5MaX4Bu87RHx9N2wc/EExPle1qlUt66mbPr38s4Pp+ClzpFzeT8GyF9Q13xfUAzIb4xMEEVJOqGRUzcHoYMFb179FLTRHvCNqxkKPlqer7O/t23on2POXgn0wqUrT1P2DVuLbaEQIjr6vxFYRvIeU60cNzgiVXsRcZjRy7XU3sTOd8/f/7t/mj//JP88rXv1NRpJzDblA8Gr7zRredeXkdeU1+dLUYl++CXHVw1c9fNXDV7Wqr4Va9fCvtx6+6t+r/r3q36ta1ddCrfr312L/ftbA+F3X3cWRNY8QabqGRZ+IjfLOhz/NHUdu4uihzKOntzi+cYyfeu9/5Mj0euTwlPff+3GuvuoQ0+mDnD3zCeb7QuqezwtPXmfgtppaWioIkTHrY082cNWCnAGPFCWjzGIiD4IXJWL/tzET2oBWsMW7JRhuoNKVvA0bC+UAxFARcjG1eFElg+XXIpV34dGsSMkE78l5zjVX38zp0w/zvvf/AvOLQtzp0TTgnadpAi56Bj+3U3ctwTekfsFDD19kPnc4Mot+wXR3VvPBDQwVp1CKATsKMUVMcK2oWmYyYvnPQTrEQ2igCY7GebzzpmoP+TLwRcF5Ux4LjuC9sc+GzKhtLQdbzI5dKijjMKAqqVYLY63AVKJ4qrLVFKdODHRru5auaeilN5IDodo8LFXWVVFc/yYnAxwRtcWPQuuDUSGaBkVJ80VVwwuuCZblDYj3lKrUDN4TiyASyCVWS3JjoCQ1ZfShtXV2t3Y5duQIJRlwXURNPSsCWi2VRZCqmJeqoE+a7DWwBLOz3fwV2L5ygbkE0QoFnE1KQQy+zNX23DeNAXk52fURMQBUQrVkd1W1b0prs53PeKgW4Q6teRHGKJSa51zHs6vW5zEyDMkOhBFJvBNSsVFdsoFtgj/I6vbBJjXXVReCAsHb+RQ1O3vnxOy4tZIxnCer4g9syitg743s4NXeC5yBtktVtiseL0YGcOIreMoBUJm1kPIyiRycFEqK5nCgIEEIWNZ3nxKhDRRNuGLgKVJJDiq4qhjXeu94bzb7uYCWhIo5HLjiUDzeOQN+S81y9x7nGyAxGjsa35KK2Wl7qbbyovgmGKFDhLZ1xJTpmjWGGHHFCDxa7b6NNGL3UfCFlCMj39I4bwp2FbwDlYxggGoughaLnddc87AFnPeoE3O2UEVtvW+EjwJJqlW+qtn4O1e/X1qKQ/A2dyz5MLnEOj4caLWbz0ZGijkBpir3CKqZVBQv1cmgrg9yTjhn9uQoqFcKkVKqEpvaTL29ZiNItOxP5zgXGI86SjZHChUjfIjzlKLsLRa0obWLIZct+xvnoZg1fdGC8zbOkJrTLkvw3iF1zBbNlL66QgCqlSzj7Vi+CbawECGI2JhRtUxzsXGdSjSb+WL3hRfIJqOniC0yNNesdoGdvR0a5+kmI1wIQKZUhwofgrlLZCOKOefJXJm/8gdfV85r1jOfeVFi9yw8m3XLl2dDvqzLHwZc+eGClELKUIg0boSy4NbbbuFVf+SN9MOct/zm29hvHW//vQdAM60L7O5PccWxvzfnb/0P/4iz57fxXlg/skFwns2NCadOXeJ9H3yY8Ybj2Npxtr1Shswsw++84x52ZwvAuHE+WLaPJgiNMBmNKSlxzdUneOzxJ1jszwAjWu3Ppuztz9jcWCME2J/23PLcGzl2eMTe3oIHHjzD0PfMZ/tc2p3y13/s/8M1J/8pL3z+LZx+4nHWukN842vuZG9/xoc+/CEuXuqZ9wNN23Hx3AWuu+YYl6Zb/L/+3/8Tpx4/xY/+pb9CP1+wNjnM6/7oDzEUQd3EHEW8r9c0oZooRXCuIc7Pc9/Hfp9f/JVf53Xf9npuuP4qnnPTy+nWDjFaO4T4luA7crZ8oVWtalVfjnqmSVWf8nX9JxjJ8UkPkycRh5fRUwf7oi9kv1k39keObLK2EUBbSumh2Obc+6a69GRKScR+Rh4W9EPmyPGrzQlFjZ3ugK7rbN5WI5Y6tXUVUInAQqiuKaVkfPA0wYiLS0K1cDkTzXtbm8/mC8Qf5sUv+UaOHj5G20z463/lL/Lf/3d/kz/2Qz9CEwI+LK+aub98rX2WuOrhqx6+6uGrWtUfdq16+KqHf+G16t+r/r3q36ta1R92rfr311P/ftbA+PNvC2zNZhyedDzw8OPc8+kneP3zXsA3Xn8bH3zo0/zqp96L3zrODTe2fPD97+IVz/lWNo4e5iNPfJBj25uU/iHmqeHcw+/lMIfYO3aUUW6YO89QZtx3/nFeeN1tBEkEVxjUUdSRVGmJ4Bouzqdc2p1z7cYxisu4BkJOiAaKKwyDkkXQONB4T9sEvKsB9CZZtjf/Cn/9ghBjYYhmyywVJC9V7bhUCmLtFUrG6wgcvPJlb+DQ6Bp+/92/wEU+TN+PaeLUgOSwIOiIJkA73qCfzem6CUeOFFLaxqkjJW8KxGL/XM2TRZdZ1ab2XtroOFmCsQmRYvm8SzV8zhSXGbUdEpxZCyelaxucr2Aygqi9hrYJxHlPP5/TTkYUKlGgAkXeeZYjVoplYotkhlJQUgWPDFxCs2UOpEzUwmg8ImclDmb/LEAIDcMw4NRuoqZryN4y3BFTeGoqZt2sStO0DEN/YDFeRImpJ6emEgMSDohRgYJ4jxZH8HaDG/AckaKEIrRNx2Rtwt7+PqNRR6zqy5QTOVdr9KpALlJt1KtA04mQcqxECRAxtT0i5JTsyopZ2rumpe06EOjj3HLFnSm6gzMr8ZxMQZsriK7173F6oMpGs71XssyaLssodVLJqGaChKq0rTbscACUiriDnGZRSDkCDinuYOXsnTvITK4J3OQ4oHUCDG0wNW+p+fR10e3w+Eq6EGxilFKMYJIqMKtGOnDOWTpCcJYlbk7Z5lYg/sDOPms5AJi1Xhu47CBglvlLhwh7sVqJMimVOnl7Skk2DkJAndltIwp5CR7rFQ0JvNOaYa9Iol6zQqqEjuDNASFW+/PQeEZNhxZlzXekGA9eTwjBmFk5gdj91DTOaD3qGYcWLYUYh4PHp5QQLYxHAedbSEoj3kg6KENMll+tPb7puHTpEuO1CdagErkqwO36VKbYFfNGjQ4/ICu4et36tMCHmgFe5xDB3AVSSngRXONRrRsLVXJJ1vCcq5ndmaY6dYh6wGIESs71Mfkg8qBzjUUMUEh5AA0VmDZQO2cDsEU8i2Eg5cLG+rqdewWenXPklNCcK7EgmMqdcODAYI0aU+oXiyRAjAxiZCJXr525Nyz/xkxB7Jo5BHHeyAPOVUIQB4uaGBPmwGHzQK4ECQGbc9Ry6VVqLILz9Z6zsT6kgfliRte1CI5UCovpgqYJdl+4hsU8MpQBcR5RU9fHEp91Y39qLTPkl3XlBvZJbiyqT2Ia22l/9qb36Z/jKczIZ3jMl2dTLgfPYU/75AWq4Ch5h+3zj3Ls6ts5/diHefD+ezl0+Ll84GMf4h3v+RQ+NGxujgEY+ogfCillEoVTj+9AUNrRiDgoi7TPu3//XvpYaJqADsLRYyMeP2ekpNZ5zm0v8C4zGY9xCKH1LPYiPmSef8dNbM1m3P+ZJ9ifzpkvetrGk2ImZUcTHOPWc/ONJ7jlhhNM96Z82xu+hWPHJ/z2297HfZ95nKKwvTXF+4Y+9Tz0yFkefuQJgnN0XcdDp06RUuF9H32IEguN97zh9S/jw/d8iv1pIp66yHjc8pu/9jbOnTnN/fc/yMtf9iLe8D3fzYte9s2MmkOUMkcV5rsXOH/2ES7tXuDw0eu4/qYXIKHleS96Od8ha5zdOssfueXlbB65kVwyRQdyP+BHNn5XtapVfTnrc827l51EzOUGpFpHuuIproDWDeeSPAk1oqiglXoo5lOC9XHFSYuiuBLBeyMtq61R8Z5jVx3h0KE19ncLW5fO85ybF/TzKYv5RTYP32iBQT4z29tl6/F7Wcx6vLyI0K3xvve8l5yh0W3e/3vvJ3iQomjpaUJHyf6AuAc1yuWg7zu6UYt4R/ANpWSGoRyQ8RzgxbM2GfGylz6PG6+7jt3zD/Lgpz/FX/jRv8yNN9xEHDKjzh8Q5USMlLlsd18MM/2Z/+YLP9bTH3/Vw1c9fNXDV7Wqr85a9fCv5x6+6t+r/r3q36ta1Vdrrfr310v/ftbA+HqXeejcgsnJjvd86ixvfP5tLPwF9oeTbGw4PvLW3+eO8avZfjxzy8nDvOPBn8TfewOjtaNMRzcQmjWu3giEE+fpxx/jQ48mXn7jy1kfKWemF3nP47+OL3+SQ+OOazc3KS5TxCyOswssFgXvhVHjiWSmi33ybMHh0RGcZPq44PBo3dTOvkG0UGLGBVDNFL2cnasiFYy1rO2hFLIhH/WNMXU2YIrY+kY7Zza9IgUnGZxw593P5+QN1/De97yNj//+r9JfnOE6oWVEkEBolDAO5Ojp+0jbNBw9fJiUIuub65w9e87AFHGkfNmOeLlsOVgwFbUbSrTeXGL5zAolcaBOzskylpeZwcUoezhnA1spVbUIXdsQ+54co9kluEoayKUCkGahXUox4bssVceNqakVoNQ8Z1NbL/pMLsZY0caOIRW0a70nOI+UREkJX9Xhdl0LRS3L2cgJ2RSZ3hlY7qgTiClbvQfJYjnMmklEY61kX0GscqCQp1ieddu29H1v1utKVe7mAxBXVS3vOVQWDHUOW05kWkkDHhADlHO1Vi4VEEQu25rHnGmCgamKknIi5ogUd5B1s7xlHWbpbnNDXWyiB2AdVV3rnFld2zi+8g69YlFNHacKcRgYtR2dbxhypmjGU8/RgTghV/WwAyQ7nHibqqPZWpRcVfHO3qtSzGp6Odc4H5AKAh6cjSytfBSCN/V1zoh4TGlurgxFa8a41Am4vi+pgquqSq7OAH7J8DD01xTmB1nnpdrze1O350xKCfUGiosKS3xyeZqK2YM33ogyXJEb7SuAXKqFtQSPODt+0zS0ocEpJO9xwdMvFuScLcO7deQ8UAPQURwhQOObatOdTIUuHORei5MKgNfreOASYTnwrnHEVFAnNI1DcySEOlMI1QJ/OWqufA/stZVS7JCVFBDqBiur4jF1c8lGAmm7zs5HXM2K1wPg3Y5XEBWCC0ZASEqOGfE2X1KdEWyx4CqBRvACaGFpleKWDgLeH2SbLIaBxaI3UFwKRaWy0Ox+8d7mHamMOe+9kVlKZciKqdSDeFti5ArWp0w3GlFqZEQ/9LRtW5XxVUWO2faXJVnAWeTB0qViSdpxIoCdc06lXnsjTjkKiLP3TQXvbWFjUnwhxch86BmvjS0ioCxnAHMpEJQhaiVCCeIKjXfM57Ey9r489fkXHVrvE6mkmCsz4a2+EPu3L9Qqbvk3n+cRB+f65FLIirqOc+cfY/vSE5x57DH+4T/9Cdzop3n/e+6lHwYazeQc8K5j3idKLDVCQU2lr55hkdAla1sTeQjc/txrWaTMq172Ul77um/ggU88yp/+/tfx4//q57j34w8zGY24487rOPfEReSaEWcvXeT7/9QbePvb38dL776TN/7R1/LmX38z7//QKR597DzOFTaOHCFQ+KbXvpxv/pZX8g/+wT/n7e96H+fOXeT+B84QC6TcE1xg1DhKEtI84kLgxFXHQGERYX+6YHPjMLPpPjfedA0xFWZDotfIxugoR0fC5pGO//yLv4UPIz700Yf5L7/wNu6++2Ze+cpXcvKaw8xnkcOHW372597Mp+57DC2F7/v+7+Y1r34F5554hNd9+5/k0KEjtN0JEGiDo5Q5kMwNgS/nhy+rWtWqnq50uQuV5Ypo6cBi6zeRUNfCWlfOy0iegnOhMrQFs2usETOViOlE2N85zWjtCMW3uGFAQn0ul5Ci9kEmsDERNteP4ZqWRgLeB1wYoU5wKIevWmPzyNXEYcrO9hkufPIDnH3400yO3sxLX/gi7nz+i/i9D9+HU3OnWvQLQmgIzlsWpdja2Ollgu/SbSeXfHA9pG7cQxB8Ixw/tsZddz6XtSMnyLuRf/TP/iXXXHczTduh+AMym0W7GIF6uY7+8pbw5QLHr6xVD1/18FUPX9Wqvnpr1cO/fnv4qn+v+veqf69qVV+9terfX5v9+1kD4x87M+N5Jw7Tucg8b7HlruI/vfXfc9vGi2Fyhtxf4InpWc6jMDnJsPMepucf43k3HOXwtRO2+l2aGx5jzbXcfOQlTEvm7O6UNqxzJBzmxcdexca4cGbvEU4efRFSBEdBGqXLhdwE7jt/is3uBOtFaX1DVOXM7H7uS7/N+nALrzz2RrpxS/BKKRHEMWRB8RUYUktnrqrULphCr6SqGkZq9m/NJ5ZqDaA2GhxCNnQJcOQEjsDGoSN8+xu/l6tvuo23/+pPceG+j9C1ExucydFpInQB5zOhXzAaKWggKxw7vsnO1h6z2QAhgJfl7XOwkHGunhcVGLd1EgXLCtBy+aYbUsbcyoXQBDtSBX5yzgTvzM5c7Ra2jGxTevvGUYopJimVPVLzxks2K+xS7Lip5nP7pf0yjlIzir0PB9niAkZQkMsWDaMuEEshFWviwfsK9C9tjM3qOg8LMrEOaLthmtAhLlFKRLKvdtiZQjQ1fQl1qWagnJ1mpsQe5wON98z3p0zW1mxScmLq3FLBuyVYJWILjJo/bWC9gfneB0pZKkeX5+sPwFxj1SjBB0Q9acikkiiqpH6ZoeAomivpYcmSqYrXUgHFqmRVwdiXqtSA5cpGssnz8iRSF9JieeBNCMSU6NrOGDzBVaVsVdUegNeXpw4RKDnVDGdn478q3rXa4Jvye5lDb0B5KYXQBFO4yjIXveYxFyNrUEoFHSGpxSNYHoWQqlOBqdOpin+bcEO9pmHcYZnSRtRQAG+uEmZhX8glmWKXQtGagS1mbZ1zvXcqABqcswyibCpvU0VnG4dXnL9lsdv5NaGxuALncKp0TUCd4NcmlJxAM7Iktnhfr0fAB1vsgynf7b2wMW325UZgESfUyPuD2AEVyFrY2dtnfX0d76qV/PLNk6VLAEY6WL5GJwcsZWtk7uBvSkl1fpP6Wiv4rXIwx5D98rZD1cZ6yUvr8YJ3nhwtW13E5pkiIMtIB2eECdVEKtEsztXThJZcMiEEstrcpSL0w8AwJCaTNeSKOUoRs7Y3RJzgHTFGA5bFyBPiXFXsK8VheeJNQ9FC44yQoN7IHKFpCDXzvZhNiBF+vFmcK1SyD1DJUDlnc1ioJIODZdABu1sO8sqNTGDXQbyz8e8C0+k+AOvr64iYdb7Z5peDWAoj6jj6YUHTeZxTmkYoxY71xVcdy08h0yzry8vO+9y1tLJffn3l/0933Mu/e5rNN3Lw+8vse+uN/WyfT33sQzzvrpdy3R0v4gf+5J/g7/zP/4Kt3YR3LU48i75HtWeZ5ZUlodVVQDThFFCHOGHeFzbXJtzx/Bu47tqr+Kt/7W9x3Q03s3/pYUIrfPrRKRfP/yemiwUZ5YnzO3i3jwI//R9+g+nujG967Yt5/PRpREdGhAjCpO2I/ZToOt7ytg/zwQ8/yEfuPcvmxg57e1OapiHn3uz0k3LNNce47uTVvOud97C+scZ41LG3P2N3fx8Rx9bWFkjiwYcf51Ofepi2HdGNHbvbU/ZL5NRje6yvb5ALuGzOJr/77o/xrvd8mM3JJoeOdvSzyHNvv5HvftN3cfbUaX7mP/wC733v7/Ejf/mvsH7kalw3JkvCS4uqINIRfAtS84iWBL5VrWpVf2BVt5Est6uA9W+qU4/ocvtC1oKThmWvMjKoEVelkk+VBvBsnb6P9/3Or/Pa7/xB2sNXsb19mv29PU7ceMfBOuLwoeMc2tjg4s4e3doEqVExbv04pfQosHfhNJRCv3eBNLtEaja5+a5v5o7Xfj+CwwFXnbwadZUEmi265oAkqhZXklTxweODZ4iJ6f7USHk4Sk6X188OnHesrY04sjnh9ufdiR9NOLb2fA5fXXA5kkqiadqD3r0kvDpnG/1n6muf70PG5br3yv+vfJe+9Fr18FUPX/XwVa3qa6lWPfzrpYev+veqf6/696pW9bVUq/79tde/nzUw/uB9ZxmLctfJDb7tZS9ie0e59vghfu1X/w2vuvMu3FQ4PfsdfvE3PslGd4g7b/4OPrrzNrYHz+uufzX3PPxWtvyD3MLrufXaFxOlsL1/ilPnE1dtXsXJY3eytbjIvac/znq4nluvO473ykiFXjJOMzduXs353UScpGofHdif7XN47yjPPfwSZv2UpgGVgFRAKEUllmgArywHrpBVkVRo3OUMYyreIdVCN+WqvhRT4aayfMOcDScpBtsUUya/+q6X8bzbb+cD73sL7/yVf4vf7inOk7KBxq4k2gacNLS+YWt7i+BhfX1C30fiMltEpGalm1pyaat+kIFdgRhT0Zo/tRqWTUbpU0JyYuwE76rhtRhZQLUC5mrgjwuO0pt9cs6Z0dhsbey5LHvYKXYuzuHUbsiimcY3lKUFshOcGLijWS3bWyC0AWkM2EQxNXpW2sYUtyKm8BURxOJ8QQXVgg9CjsscBFNTlphxPlv2u4JigJV3TQUeqzNAdlVZCqkkxClaEuOupcREjokQAiIZdYBWIoQLSIGYlj+HJQjmfTCL+vJkQHxpWS3BkUvBOyGIo20ack6kVFXp4mh8sPfOGRGgFH2SFbaAKVfdgfaWpYWzYFnNy8cjmYIjOG/kiQNw1DLhmxDoFz0pZ1O2N5etyZdycyfeQNqc0ZzxjbdsZSpoKpYt0batKe2L4n1rr1OkEhmWqnmt/5c62dlrcji7ZqqI+KqSdpXMUUh18k0517gAsyZfAsxLW/CccwUdBaWqzVWI0Sy+2+Awi25TEYv3lGxKfr+8j7CxZdcyk6JlZZsTRJ1YxZhPjffknBCxfPtR1+C9o+tGaMk0jY37FCPOOXzbgRZKjjRhTEZRCTgCJCNzhMbR+M4GemgsA74s872FKPa6Uoq0oUFkDk5YDJHQGFCaU6qW+faGLwkVNr/pkzY9Zmdu986VZAURZ69dBLxlzPsQ8E7IJdp9LRjJQqSSQQxAN6Wz5dWXFFm6CYAx3pagcsW2K2suksXmMMlGqMnFGmguBqovFnMmkzUbV0vihXMHjhM275iCv2kbs87P+UDZXSpzz4sRF5YztQLil44Ll8eS3cN2LZxbMv9sXimlmHNCynZcNdeJXOdZqXPv8ryW95JxWsytQbwtLnJJlN6u02jUAeYK4H0Fxb2H4lDNB64Gm5uHcd6hZITMZNKSL5tMfFF1eZHwzOy5J7PRqUSbz944P7WevAj57I3y5/v7z3XMy8d+6nkvv37qhl4peUGKO7zsld/I2Z0drjl6AyevvYEhRXyIlOQoDJcXp9XlQNTRhcDNN1zDK1/6PH79t38fpSGXgel84I+96Zv4u3/7b5P7LW644bloaJgcuY2+f4LrTq5z/ETD4ey5/vhxrnr9cX7rN9/LdD5w7clEtz7mp3/+LagKOTmQBSCsrR8mLhYMw4L7H3oIvb/gRNnTjAuBmI30pUUpTrlwaYvFYs76xhrtuOWRU49btIUPlKzkWBiPPbfdepLHHrnEtdcf5r/6r/4i/+GnfortSzPWJp7tSzNSXzh0eMQP//B3sXNpj929fT59/yM8+OhjPO+WG/jv/h//Lddfdxvvfc8vsrd/Hnzg7rtewy/93L/ita9/Eyevv+1JmwLnPZepLKst+apW9cXXkgxav3umD0ArEbLo8p6rrlB1f7B0eSmKsdh1wCJMfI3QMbIwweM0giQUoV3f4FWv/x7azUO4knnLm3+ZX37zz/N3/pcf56bbXoBqJupAKoX5/oLtS6eJ195ATJHZ3mOknVNoUs4/8QAnbr6TydHrmdxwOxI28B4iBV8KWQpNY/sb5zxJlayJnI1ISV3LlFKgEsNms54hZmKKtn/Q5bq39mIRRt2I4BtOXPMcJEXSsIPrDhNzxrv6QYXYahuWG2oqwfDZMda//Kz2z1+rHr7q4asevqpVfTXUqoeveviTa9W/V/171b9Xtaqvhlr176/X/v2sgfGX330jHzv9Xu551HNi4yZOHltn/eprefDc/Tznmus4d36LtXaMLLbpcySWxPrxDM0l8Mf4rld/F797+glkLbA7S6xtBNaaNc7KAC5xeLzOMGxz1K+R8z6ajhGLJ4uSsqkyg2xw1aZybv9R3nXq17ixeyFHG6VrbubD899ibbHBnc23sMYhnIaqAleSJnzXkQ2HM+C52qoPqtVa2wa0geYZkuLUQufLEhwVj0MRV5WlxYBq50zdu+gzcRi445Wv4sHtd/DIb32EsutY9NC5hkacZS1LZnd3SorJVKvjjn5jzM7+jMViTteNrmBRZIN2BAN3VUHFMkRkqfbMEAQVJeaECw2NryCthNosM+KqYj5nA3SxbOfQBrz3xBjJMdOGYEpJTIlJjkjNFRZ1KHpg47zMBUbVXhsV7BZsoVAtnn3j0aQUag6yCK0PqIJimcjAgRJd1UHoyC6iZaCQ689rxjC+TlkJh6mB7e5MgEeLnYPqUAE+m7S8d5Y1vjc1MNIJ3tt4cGJkB/Hg1Fk+emXA5GTAtpg83kBWZ5nC6tzBxBBCvRZYLvkSiFwuXZy4qm42Zg8123z5eGPNgF3SqgqvCL+XpUK20HghY7bRPoCqOwCmRaRahwdyJU0E7+p4odqs2wxkpIsKznlH27UGJlZw/EmZRyUjAjlbE1CqtBlYMnJMeXw5r93YBtR4ADl4TkWhZlcoagn3qhU8N7KAWxIGNB/0KANMqY+zMTTEnq5rCB4M7zQAOOWl5bvZXOf6mqgOCsatsLFXRJfzs80b9TlybQxBTMEdQkMIDQ6POMt6H40Dse9x0uJ8oIjp2UUcQzK7/sYJXlqcF5zL5JzsfnLQhKZam2fUCeIFjR4nDbJri9wYC6NRS84DrQ8HwO8SFEcLKZfKuKpKfTWCgmHWy3vT5qtUcnV38GanHgJmlxKrAwRQFOfrZkiXoLtlc6ta7rxzdi/kIqjziPdIgJIGG3MFnLQU9eQS6z3nWTogpJgoAvP5gvGow4tSUqYJRt5RzQeNttT5yLgz9XsRCO7y9VA1dwu9THIoWpClWr6iy0uA3FfyhDipi5RKxMhKjhFEK2dmSUaxY7pKYKjb1QMVubgGlVTdPCyHve97NtY2cU6IMbK0jzmYX7FxpTibzyrJZ+kooNUNQd2XYqW+VJvLU/7//HXwuvXy/PLUeurPrlywXPl3T8dOXz7m2W3ar3xMXUUd/H+5+jglx4Hfffs7+PEf/zmiG9jb2efi1q5FEmjGqSN42+x6Og4dcjShY3e75/ixMXe/8HY++OFP8spX3c273vVRVLd54vTDbG3tIv02Z/gIV930ArbPP8z23jY/8Cf/EnfedjM33/wifNfxxBOP8r73/kVmi7OcOXWO0XhUmV+FjY010I79vV0ubW+x1rW8/EXPxY8dH73nCUQiO3tTnAaapkNUmacp4oXt7X22tvYZdS1Djtx8843kCGfOnsf5AOwzGa1z681Xs9auc+zqNV76klfy5l/8Fc6e22dva8EQFd8UXv3al/La176G973zA3zjN9zN//Uv/Hk+/IkPUwLc8cJvYza7wMaha/lTP/SD/Pbb3s3P/h9/nxPX3sBv/8ZP8Kbv+2scOX6zzc+V0LRkxn6hDM1VrWpVTy6bNj/Xxu+KDy2Ry+u0+sdFI0Ig9zNbm7uRES/Lsj+CkXuxdZwCxRya1tavRicLhv1LPPCZ+7j+uXfwwKPn+As//Jf40b/8g3zHd303Zx5/iItnzuGCZ29ri/f95s9x6uFHeM5zb+Pul7wat34Vx259FdL5SqJsiP0U9WOcE3O7otC5Di2OnKsTUCmkpOAdIVSnmLqmsxgeR85GVG2ahnmeH1wPFLy3/c/xo4e4+vobuHjuFHsXH+Wmu78V0R5kUi9RubxGrSV86Zvty6qpL7eV5aqHr3r4qoevalVfLbXq4asefrlW/XvVv1f9e1Wr+mqpVf/++uzfzxoY/43f+TVOcw/ve9uHec5zbqHQcuzotZw4fIJ7T32MW07cREqFY5MTzOMW0i84fLglHL5EUuX2m29gq//z3HH11bStp/Vwvuwx3domTK6jKcrVm9execdVZBILBJ8zoOBaUo4wDDw0Pc/NGyfIe3N2dk8xuSrw6O69XFzscry7njvWB3bKFjvpM6T5eQ6vv5JRu8HQC6PloqBmc9uVkwOwA6mAT2lwFCKFklsap5AWzN0+Q4q4Rjk3ewzvFxwe3c4kH+J8fIQWx6MXH+RTpx5n4+qX8OLvfi4fe+ubKRcTEWVYRNwogI9MJhM0TJHcogOMxx1ZAvv7PTkPNOYoQE6lWvxaRjCGi1NKxFW1tbHtLmdMDylRiqBtvWkdeDA79lKBIhyyBHaqnXXXtSxmA64oo66lL4uasS32d5jS3gHiAk5CNWIARSw3eRnXrEIIoQKYZmOvjZJH1WLdBfrebKcbXxknKoQGYhywvN5AP3UEDYgOQM1EbjzU3GsDbw0mV8Gy4hWcq0psEaSYXXnKA6gpzLtW6GOkFUEwtW7K0ayP1SzkGx9Yqot9vblCCEYsWKrpg9QkdgUyWuy7XCX8qooPS8DYcqa1CDkagJ9LwQVTvIam5lHUoxHTgUW5TUiWo5yzIBLQnAjOmy12zb8uauYYRTNj1xB8MDCw8abQd0LOWhWxRlxQsfwI7zzDfCDUiAEnMERTvDsnpGT214V8AFAa2F7QkslFqr265TEvba6d93gvl4H7ZMpwy182y/NSCm3ToCqIM4AcVbzzlkVeFBeU4EdGjtCE821V3WbGo5G9bhHSkt2kNsGb3YdNwIJQKsFhSVAoCpYJbUClc4IXQaszgHiH9yOC84xHLU0TcJIslBtT6o8nY1AYhgHEGKNeAkE9TdfitFjOuigas7HHfKBzzggPxeIMxDla3+AmHTnBeLzGzmxG10AQwIUDRwv5/7P35/GSnVd9L/xdz7B3DWc+PU/q1ixrtGR5ko3BNrbxgMHYwWBmCCHAhfcGbpI38LkZbnJJCOFNAiEECOAwOcHY2MY24Hm2ZNmWrFlqSd3qeTxzDXs/w/vH2nX6dEuyZdnEGNf6WD7VVbuqdu397Oe3nr1+6/dTvwNGRXiHeqMnNaFoVBy0aJ6ydutLVmJCsyGxiuskGFyjEgBkjBaTDRsYqEYJAYRRnZ3ceNWrL5TFisVaqCQ2JBiVxzJZEPHnusmNyqGLtQz7fSY6HT0RTSd6prkeGgZaEshJVSisMUoAEEO2WgiXBgCViUfze826b72OX72GRp4omtAoiQOy2mqkhLE6hsQpCWWknDCyg6iqCuPdulJAbtQfQh3xhcVg8cYzGFRUwyGdTgfrLKGuyTlROHdeYV5EIAkx6VxmXNDZz1jqOuC8JQQ9Lk83zjHwzk8UnkriMFr2PpXv0M988m2eTsLzxPs3+pykJKoL9rDV3cKdn/0cv/Zf/5ADJ0/ibIveWl8VFPAkU+GLgh3bZ3n2Tddz9swSz3vuNRw7fpqPfPTz3P3AYQ4c+VNWl9f43OfuZXLCsmXzxaycrfm5n/spnBj27JjlJ37y55mbneGP//C/8CM/+gvs2Hs1Syt9Tj9yJzPT87zmlc/lf771ryELb/iul3DrbXfx6c89RDmsmJ6apD/osWPzVv7+j72CW174En79v/wO1j/GzMwUw5TpD/ukOlNICxFHDBXG6nxWx5o4FIiRS/Zt5Ud/7Pv4L//1dzh5akAd4cAjp9iyfZq7vvAIP/D938PJkwOyEboTBcY4Xvsd38b/8y//Hb/3u7/Mn7/zL+l2Df/3v/oXvO5NP8Pa6lmqsEh3aivP/eYfJDPk5d/+gyhp1LO4cIRWd4qRoxJ5hMWNHNN4TT6OcXyF8cUX5IrMUUll7VaDtanhKuZGwi0x6C0wHK4wt/WKhnylZD1rEsPeMjFlWt1Z6lRz5vgRls+cZmpqAu9gZfEE/+Kf/2ve8Ppv5xWveDG/9ht/wn/9zd/hyisvZsuuK5jfth2ATXPbOLr4GC/9ez/A/LaLNMdCiYwxa05MXOPIA59i1zOej/OOmBuuvDQKQ1IDjpwsIorRisdKco05EUPN2lpkOKwwhVXbIs7dMDZWaLc8rVJ4xhUXs23HJfRX11g8+yh1tYI1Lb1x+YS4l74odn2tY4zhYwwfY/g4xvH1FGMMH2O4xhi/x/g9xu9xjOPrKcb4/Y2I30+5MP6Rz7yTpbOLVMtDqnKZRw8/TO/SyxEzSxwe59I9r2PrJW3aZivHTn+S5eNHqYppDh59gDvW3suWuVexZ/NurM8cXHmQx04d5PrtN7Ft3jFIQ+26FUO7bJFSTR1qUg7qBRwqbMqYlmdyUJBrz1XzN/Pgoc9Rrm3i+i2v5L4TH2PPzLMo3QQDKmIVmfAXw6BPUWxDTEUvObxxOBGcZJCKfhwQQiJlgzEl3rfBBOrksVlL9AvVMgfP3s5CfRqRLnumZllKZ1hY6JPcCeZb0/TXTmMLsF6YKwyduIXnP/d1XHXljbzjrb9K//5FejKgTC2MbREsWNOiLDM9Klq1pT3dZnaqy9raGosLS6RsyBgC2tVrNhQaRx3rwjl3A0Q7kkcSKiHEdbCMTZex8dIUjVIjT45qpeeMGEvZ9qQ6MKwqXGFJppE5SKJy3AkK44lisE600NtAs/oiG3zhcdbrfjRd74gWdTOJUKu0RGGEmCGLFlTrqlYZ6kL90AnqgV6niGTTSGqnxg9YO5Bzksbfu9JJQFQ+3sqIeQLJ6gPT+MaLcbQ6jsWVNby0miKsSiFLSusdorEa6kVibFNME2gmiVHxLaeE5EjKDYkD0xQjBUxzdiSjaujSdDGrHHVOUafIpigcY2TUIW0aOfZkz3WyxjTqxG5Kl1Y7wI14xOjEZlHvbFM6TBa8c00RX78TBOsM1hSkHLUAzMiHXrvZq7qiqsE3hUJt2DWMbJc9hhSV7qQdr44kkVZLp5OqrtcVCLwvGh5KOteJ7BxODIGMNQ35QEzTlJzVi5zcyMwbrCRsQj1znEAyOLFYa7BOO5GNLXTfvMevd59DbLrcc1awiimRzYjVpaClCaRZL1amoBLjI7WDGCMGwRqwrpEuR60IiqIkNTYBKSU6nbYWooukxfFsyASKsiSmQCRqeVlKJeTU6gOUyJRlSYqQk6FKShApi4JqYZHJyQkMCkLGjBrAXTPGA5IDGEPObv0aSFlBWjAY1/gOERsfd6PjwQSkkZFP0MjsZ5WzF0NYP3dK1xh10ltrQJymBpJwxiK4JldIjbqBSqJ7p0VpWzjANmSEjHWeXq9HURRKgMhqJSHQyIhnjHNqopCUuGGNMt+scwwrlSdf9wPn3KLPGFE/dB1JpGTWzxmc6xhXKfbmWm7O4Ua5+ZTUgiPnrMXy5hqMjYR7iBGLqgw475rry7K6skQMNd3OBCDUVdV4idv1BbJ+zojYoJYGYks9R1nVM6y1iMm02+2viEX3ZEzz8/8tnFuCm/MSlPX3N+PjvM8eveuLrMS+Etb9E++7yu5IQ6RJzfyACCYn3v/ut/Fr//E/cPDwGeoqE+iTo/rSh5xALDfdeCn/4p//PM+48lr6VcH87Ayra6u86CPv4a3/608oiw4f/fjdDPo1/+5XfoFLLruJI4cf4ad/8meZm+9y8vgy/+k//Tqv/NZvYtPsLGfOHOQDf/0OPnvr/ZjS8q/+9b/nZ372Z/jEJ27lsUN99j/6CMdPLmFspqorZua7LK6tsO+ibWyan+Hjn/o8n7rtPrpTXfqDGmfRuSokotR6faI2JmLQ5DULw2GfPbs3891v/E7e+1fv4fSxs/QHFXc/eIi9gwFnzw4IVY0tMi3fIsfMc59/Bd/33a/h7js+ws5tO/i+73kZp06cIA9XWDh0D66YY2l1jcn5gna7TaiHhEGPcnKWmGomZ7bhXAdJovg2svswfwuy2nGM429l5Asen+scatIVBLXHMTmgXoENPmQlX+VmMU5DVCNnvC/JeYQrNJ1FlobtS2tiDnyrkXpLVP1lDt7zWfZcdBWPPnI7s3Pb6bWO4QvDw3fdytpq4uobb2Z2dicLSyusLq/y27/9FqKBS3Zu4ud//h9y5bNezNLJo8Sqz6ETi9x396e5+TnfTKs7q3ldjkRURebQnbfx0MP7+aZv+0627r0BY9tKWDOq9HR26azm8iaRBByWGs2FUwaLqvooqVlVeKoUKXNjJ9Mc10imdB1ahaXVcVx33Q2EFFhdOcvk5CaMLUipwiWvhFlhnUwM5+PLk2HtE3VeXbj9Rhm4c9t/8ZvVTyXGGD7G8DGGj2McX8sYY/gYw59ejPF7jN9j/B7HOL6WMcbvMX5/6XjKhfGZYhPzu3by4ME7OLV2jJwNi4NDVMs1FImHj/81W3Z9L3M74cFDayQHxrTYvmMLawuPcvTIfkq/j007NjFVTLDGAT7wyMNct/VmBlRU9SlyNLTtNNn0WE5L5NwnDQwBx1xrEyv1CjnW9Kut7J6/mR0zF1MPh/TcGXZO7WLHzDxfOPM2tk08H1ziQPow3XgDeTDFzMQUXSkJWb1PTsbj7D/zEMsLZ/C2YGa2pHQdLpp5DlOmIEqgzoYqLnG8dwf9uMja4klinONw3ebsYIUcIIchTFiOLQxZXVpj+9wEu3fO0KtWuHvxDtrtgme+5LUMn73ImSP38fBHDzJcWiNg8U4wOGYmC0InrRdnOq0O3huOHTuLEZUbFxkVSEWl0wFp5MFpBpZ6iZt1r+FRASrG1DxnGssAHeCNzbRe6KKevtZYvGuRQyTUFbbQgmUm4Z0lR0AcOI9YQaz65RauJIWMsR5pJJqddY0kQ0BMwjj1oXbQ+IuDyZmAFol8aYi1yjSIMaRgyAYt6ol2hiZoZNwhRy1qxqbrnzxKDiNhJEuhfIvmIrJ6DNDCd7tVMBgO6HQmySFhJJFDJDcS+vpeLQjapImfWO0kHgmIpxgxNq13mpONFvlSVvaQkYYYoOSDFKNOp80xHUmjhxi1Kz81Xf6pOT6mSZRFm3xNQw5Q6WidrAUtkItII3EOMQQlOjjdl7YvWOd0Nt7MxqmHthWDtW694A5oF2wzwZimPdjapriYtWjfNOcTcsa6gpjCeqFSC3+2OQFa+HNOCQU5qdS86MAm1I1cNpEseqwkNx3wTac8MiJfaBe3Be1SD/oVviiQhnSQcyNaJec8dxTaAiIG34w/HZ86aGKKpJjw1imBIyclIqCdwt47jG0EEUSw4khpSF3VuIYMYYzVRYsARkjWgrGEEKnjANcoOyCNtUAj6RRSwnqLdVbbwpOhrjxSwmDYp93paKE4ZFqtkpSGOKPXMk1RP6NSSqmhxRhnkRT0ccNcw5ZUdY2YSOGs+r4D1tnGgz03ChGK5ylox7dtPNtTiDDqIM9anG8gh5F3u7MOTRgcMUeslSZx0KQhJO09TxkGg4Fe995TDSuss4g1mIxeQzKST4fcyLYoKcGQQlwH6hEI5manUkrrigXOuvVxiQgpqoR8bLzB7agQ33Saj66tGFPj/+3Wr7lzRXezwSKB5jn1YQ8xsbS8gjVCt9tt5NMjIpbCNx3zOTKSkHHWk4lKNDAj+4eGxGNQQpRJOtd/BQvbJ4pzkmqj5MF8yW2fKLN4soX+hVJuT3X/n/rvFLLNEAWTBaggl+Tcp2tWKAzccP3l3PjsW8jxDPt27eHMycO8850f4sHHzvDqV7ySZ930AopyM75/DGc9ExOTvOKVb+S5z3op//7f/hNa3YKZqS7XXf8Ctu+5ip07dvBP/88f5JnPfjnveeef8Ft/9F4+duud5FzzO7/7Xo6eXIJs6E4WfOCv38bddz/A/oOnseL5y/fdAVnYtXMr1kYOHT5CipaPfeYLfOqOB3CSmOi0uOGqvVxxyV7e875PkU5ahmkIRmhZIYVMXQsme2KuMSZjxfLo/sP81I//Q9JghVe8/EY++dn9TLQmeON3fTNve+fHIGcOn1ygbBW0neXwgaP899/5H3zik5/BNDjxQz/wGu5/8AFuve1WMn1ueeG3srdd0p3YS+xXrK6comh1caZFHVY5eXo/WzdfjfF+Hbd0QlCEfbIbNOMYxzdGXDhX5if5q9eKoCQ2SI3SUSCbJifLZj1fNzkTYk0MA5zv4L1r7J6auTNHRBL1oIcRYWl5manpaXLoIZJZOLqf+7/wCQ4duo+jjz3Gy97wJpxv053bxbNfcjGMLJ9iIvYW+cVf/EXuvPez3HvvAzz66KN8yyvewKlTC9x9+8dZ7VXYmJjavJldlz2TkPpYHJIqJfKmmkcP3Mrdn72Lm553AzPzFyM5qeeNwMrpY9x//8OIsVg8KUOd1FIoi6xbLI3y0DpEZajHRAyRhsiOgmUCIkYcqarYtns3EgKP3Hcb/79//5/54Z/6SV74Lc8n+wnOvynSnI18Thbv6caTvf9vigU/xvAxho8xfBzj+JuKMYaPMXz02U/7I7/od+nfMX6P8XuM3+MYx1c3xvg9xu/RZz/1z3jKhfHdu7o88NgabgB7Lr2endfNI1se5K3vvJ2t7UkeW7yT+fuuYXLyWgZrkd0X7eK+U3fQqaeoZJXpcgpXRv70od/Qg3q6Q2v6AHcs3o5f3ENMlhQ62HqWVmEZ1IHpcprupHB0+QgPDkpyH7pdmEyHufbSkspFkqxy1+l3ckW+iWPhKIP2We48+7sMc8Gy+yzXda6iDj3W+o5+OIW1LU4Oj3HXgVtZPhMpo+HSi3ZSD3v0qFk9fTsXtffRLlqcjT3qapkizXDF5l0cn8icWBrwyENHOX1qlXa7Tav0nD65ihSBAsuxYz2CNfTqNdZWlukWYIxjrjvPVTd/N8+80vKXf/qb9E4ex1LScoFWOzNMpvGTFjqTjonpNhMTLR5+6DCptirraxrmCjpAJWmnrw6mpkjUcNqaajopZULSIqjLQop5nd0naAHUykgCW1kwMUVaRUGRLf16gDGCN1Y/2QplUSBOOxuVrKYFMIvFWIcvW9pJLYJpikFa5IUQM1FUQl1SxOSEzSqRnIxVX/kQMKhcsrEGshbGQ4xI03EpTWFJvar1qIz8gjdeBBYhhoRYIeRIjkH9t42l6w3Dfk2MAed9Iyt9zjdZms5cQ8YWllDr8XGFJ6QIKSPWk0S90zMZUiZRw6hYnYUYVELZiKVwjpDVDz41cvA0+2hF5aNHzE8xykx0xilD0WlBzhgtrCdUrltPglnvOldvefVAdsYyjFEL4aMie06NV7qqD0g2jdR5Wpd2NsYoUSDLOVKGEZx1WJou2qRjzWYtLg+iAkaMEZriXgoBrNGjE7XomGJsfJy1mOidJ+eEdQZjPCln6iogEVJWxlOg8SNyDklZx1phiVlwtqRVtCGp53cMkRzOJYYpx4ZQopL4riEjSFNUVvIDOj4kr0/O3lnEW0BUHcGbdSlvawVJDi+m6aAPiFPv7tHSplW2CM21aYzFiRar8QKNTLlJFtN0nFusfr/NqJ20pdUqKYYVEDDOENOaMlZTVhASkGxIUQkp6suuPuBI0g73pIuWOvaJuVKZfGMxUig3zuo5MSihIpF1XjCukREHkkrGGCMq12+syqtAMw6EmEKj5NCQKxDqqN3j1hhVhzCGWGd6/UEjSa9EH2O1Yz+h8vkZME6PawgR23ivC0Yl10W/x4zUEEba7nKuo18JNrofbGQEGoNkfc8IllNKikvpXEGcDa+llHDuXGf66Pucc6Sk1gR1XdPrD2m1SyQHhvUQZ/y5Y5QMIVXkHBvyBU1HuGCtKMFHZw5A8N42Y6luSEtPvmj+6sU5csy5p85fZD9uEf5kn3RBgnLhwvyrUejP2YBEVL3ANwoRBRPz81x13T527NjBc573cp518y30BhV3ff59PPdZ13L7Xfv5e9/9PbQ6Ozhz4j5C3aMz2wFJlO0ppmYsP/aTP82uiz6EKdfYvfcKnUeqATt3bOXtb/9fvO8DH+G//dq/oZA+//e//HXuvO8QmcQlF23mxPFl/utv/i/WlpbpVxFnkl4LRpid7zDs1fR6ZzGSibFSrDCZamC5+75DzM7PU2e47rrLOfjYI5xeWFYcMw5rwdpAzAGyY27TDK4suP0LD/L93/0SwjBz192P8l3f/kJ+6Id+ihe+9FV86H3v4tbb7uTsmTU2b54lhpqPfvJ2BkNLCBXWCm9+y/voLS1Tdrrs3T3Ht3/nT1C6khgi7dY0xdYOJ44/SEx9Zqcu4uAjd+LdJHObLkJkYyo5XpCP4xs5Llx0P8HrGy+PJn/KWf27DBU1qqoTc1IbH5ObvE5IEc4evJtiahPdmRLJG3Esk5PmlnWdKQrH5MQMtmghOHIWZrbs4AUvfz2Tc7s5efxhNs9dim23ieJ0KiUQI4ThGpt27ePizRdxw7Oey5/98W9x7NFDfOgv/icf/thtvO3dH+bM2SHXXbmDq655YUOMa5NSUPJuTlRLp7nqxtfwyU/up9e3TONYWjjBI/fdy5Ejh3jgnju54677yRJJ0eJyZtDQTq0xONt4SpEhag6S0sj+RAls3nuqqgZU3ck5w6bNm6mrmgMPfp6JuYt41d/7Ts6eOonELjnXTV5rHrdYvpB1fuFzTxZfzrZ/8zHG8DGGjzF8HON4+jHG8DGGf61ijN9j/B7j9zjG8fRjjN9j/H768ZQL4w+eeIBHDq1gXWTfxVfxyOkvEB/zTE9vwcgSkgqOrDzAqQ+v8KaXvYaPL72Lj37uo7zysu/mpc+9mU8f/T0uLXZw+5G3sLf9CrYO5ym5Dje3ysKpChM6RHcML47h8iSdTpdOt4UMl6nWHAwshRPsMCOuxf7jd/LQ4p0snXmM6IBd08STawx7mTZ7mLAdrpl6JXvnLmWyPcfScJH7T9/H/cceIS07ZMHTmSwJrZqHTh0iEanrCPkwR7c+zNbZaYopYTBY5ujCgPoex+atE2yZu5R9Nzk+c/e9HD/eQ2yLlIZM5oJyusupeJrFwzWDtZrV3jJFu6BVdKjmLDNbt3LRVZcyfAN87D2/QzxzltgLLK1mrMn4ElzRdOUiFPNtwnATjx08Ra9X0+608Fa7aEeFT2sNMZ0/KIxpuidz4w2QoQo1IhlvDa7pBh51iBoMOTcF06ZwmGJEbCMjHhPGOMSKepV7izhLiiobnJtBKdYq68RkxNn1js6YGifynPFei4chBASHZJWWTikRE9iiRaCmqiusCVhjCDFoETpnwrBCioLcdIF654g544wnxaBFbGvVU1tpmIBKcotrZC6SeqAbo/t/enGF1tSsFp6DrHcMi7DeTZpixEhuuqGDFrHLpiMeAzFjJWMK9QUWAzYDCMYJxhQ44xCxRGMIMTEcsWMA5y02Z/Uol3X+Da1WixQzMadGKUA7Z3MayVeb9SL3KOk1ziKhxliw4hjUtRaUY2Qk9SE6kyAC1jhUcjvjnUrgG6sS60ZUll614LU455xZLyqGEKmrQFVVuOZ8e+sgJXLMIDqxxqbwrQNOu3RTI1GfooKI+tgnkhGsGO1IFgNGVB4+O7IkJUEgpFgzrDM2W1JVQ4wYC94YkoGYmm79lLECLeub/c40zIINXcCCtwU4oyQTtPhpnKMKQ5zRonrOKrnvbCIZR2EcJmXEGoLEdb/wnDMh1GAdvtWiLYZQJ5y0kBzUmyhGIkmJFnVQWW4neGew3iFEDIFQD3FecBb9fCy58QZJI3KCbRijRrutjRGSqLd7JlLVFTHp+XXOqPR6sphsECsYbcsmSsI01y6NuoQqA0RyY1/gXdkoUcTmWDVe3gIh1ujIyYi1uLJsxrT6k6cIw3owKlVjmmtMvFfZfGf1XFtLHSoMow7tSIo1KmSl+zvyBlcSjkq6xBSIjYc9kkeXP6NObNf4e6eGuDMifYxe894/rhtcp660zupOKWKMyqZvVPMYDodMdLuIZFLS7vayKMgpUYVAzHVDapJ18olzut/rVAJRJ/diRMiwqhjSapfniv9f1XiCRfjoldGiulGheFqf/kUW3hcmME9nka5CHIZEIqCEhoUzhzh17ADf990/Smdulun53cQ6cscn3sPd++/lh37453nOixdpT25HCBADJ46fYG5uG2VnKwbD5Oxerp67nEsufRZHj97FyqljlN0ZiokZNm/fyx1f+FNe9i0vZtv2TfzB7/4+1kWedf1eXvotz0fSkN9/y3upY+TYQh/BUojQ6XZZ6fXZv/8YpW+TQiDZgBNLTlAZmOu2edE3PYP3vPdTzG+b5v/7j36A//ff/QaHTi1RZoczlsokknWU1pND4uDh0xw9dhZJNR/58F0cO36K73j1LTx2aD+/9pu/wY///R/hH/7kz/H6N67xwb96G7d+6hNs37qb04urHDlxklgVJBfo94cYU1BOWlrtNr/7u/+Ni/bu5Pt/+J8ihYDzzMzvIoQekLn66m/FtyYbSw4dr+PF+Di+sWMEOE8UI1yRJ9lEyFlIYtTqCXDZoQojGayFWBGNI8UhEzPb9Nsa1RtVGhIQwXhLy7tzc6oYIkkVhnyb7hQc3v8ZvGsjzkBSJSRjIvVwFSttqt4ahx+6g8unZqhDxXNe8DLa0/Ncc+Oz2bHzEq664Sb+j5/5Z+zYeS2toqC3cJhyYhOHH/gUm/dczYGHvsDysYfZc9234Ezm2KMPceyhz3Fo/yOcOnOGfdfdzKtf9wZuv+9h3vue95NtJiezfmhSyo11jNoDxRgoigJvClbXeudyWRFo8tcUMkUp4DKDYWSwepovfP4+9l20h+e/4o3EVDEMfQrbvgDnz5+3Rlg7UqJ5Kth0oXTb/74YY/gYw8cYPo5xfHVijOFjDP/fieFj/B7j9xi/xzGOr06M8XuM318Zfj/lwvidd9/PFbNXM70v8ZnPvocdF+0jywQznSMsnDzFdLiYN7zy+zm0coA3f+DXeWzhPjbbXTjr+dzSezlefYor6x/hxvnnMfRrtF2LM2dO0z/mKHIb7zPLZ2fY3N1EPyywNABnHDvn5inMGrPTBS3rGLqMLzNrwzW64RJ2b7mah5Zv57ETH2Kyu51Ltj+flpmgHlYscJAHFiPXlDcxUcww19pFJx+hn1eQiRbRZOpexdqyFnU7HU8WOHpokf7yGju3d1muLQtHB9TLA3orqwy2LTG3eZZstLNxptumspOs9VdohzaX776SlaWKIGuc4iSFaTExPUu2gf1nHqRsd7j2kuew+Y2b+eRH3sKDn/kYkiw5CoWDlCJ1XSM4jLFs3TJLEuHEiUUGvWHT0WuaWk9eL0pfODBk3dC58VDO2tWYDWSazsfmfTGp/7IRg9pQayE5kxGnBbqQtPPVeYstnHrCWy1SWetUqtqoPLVt/KJHEubGaSe3EQGbaBnLcBDUOzgaLTznhEMnmFHhKDeyxxQFoarIzuk+SiZZ9YdGpOmqVM9t7512juvchOSM0HQCC4BRqYgQkATeWyY6JVV/lamJSYLVIlhuCucClF67PusQ1xPVDOs+2tq1i05sIeFE/ZudcfjCA5kUM0YsOQkxVpgMhbFqRW7Ub7xRndbip1GPa5sT3jmqEKglr/tLqyT3qEA4KoyDiFXGZenBGApT0Gs61gujk3RCEKsFzzTy4E4Jby3eqB80CM6Ds9qBbBvWUMqRMAzaUW/13BunSac0v6UonEp/58ywGuLw2KabWox2jqeYSNmogoBpCBN1QDI4dbMmWe1QtmIh6f5G1Nu5sA5xhmGumXKO0glVDKQAYjTJpZGodlZHiBFBsoDVDuWUGo8QlAWVY3NdmeZEpKQFdyLOu6aoriQSLY425AGr491ag83qK55iImZRwGuOc1m0VaK+7mOcEGJNSEnHrfOQ9PySMxJout4zhXc4DyaP/OuBLDjbWpf7zxmqYcAah/NCNjreU1aLBozT8+utesUnVTkwOal3u9H5wbpCva5TJDX8AdPIw0dR8oqCpcp7e2+bwnjGF56cI5LVXkGMQX3aU+NXHgl1JIaaVlkiJFzTKR7TOSAUY4gNYOqnZ7z3ZAsxKy6AyrFbY8jYhlijLDZxbFBjaJYK68w3nSOtaTrUm0XnqLhtrdXPaK7zc37jsk5MUYsA1ru+e70eOWempiaJdU1MowK8V3aLyZSuADJupOwhI2sCvY5j1ISJrOdbJGKt12tbLCGExzHrvrqx0a/l/ARk49eek3576knKl7vYvvB9595/3p6wTgYyiRTVE6i/cpqH7/oQ2y+6gqn5Gbbvup6MI4U+h48/wlVXXoPYEm+myAYl9cSSd7/rz7nqhhdjSYRqiO12MTlQTE2wp7yJz3z8rTx64ADPfv63sry8wpWXzLF89ijf+6afZc+ODj//cz/K+97zAV77utfxS//yX/DG7/1e9u7cxT//V7/ENdfu40W3XM/73n8rd95zEHAUZabTmSIwpCg69JfWsCnRGwSMyfzSL/5DPvrJ27nr7i+wdfMs076FsUo0ilXCeiW1ic0Mh0NWQ2T79llSziyuDXj40SO88NnP4E/e/WE+85lP8eu/9lvs3ncdpX0PSyurDAcnWTi1SlgzzM0WLK3UWJOZ3jzBMNQcPXqSg48e5g1vfAUpVsTk1VKimKTdniajiiFik86gOSn28PTO+TjG8fUfGxfko79P2stzwVtVCSqTiBiqpQUGdcXs3A6SaO4oEc0zTGbuohswtkAEQgwNAVYapRn9fhFDTmo/ZCTjcgbJlOUUyU3Q6RzDt6bAd8hkHIbe6lm8d+Ba+JlpLrnqeZTdzbS7MDm/i73X3oxNcNGVme2XXsKv/sq/ZWFpyLEHPkV3fhM7J+cpMXz4r97Gxz9+G699xYt49MHbuPW2O7jhhku57tpv5vJnvoSy3aHV7bCyvMip02corGWQK3Ju7JpQ4u66ipE1pFoJiOqlmNcJbYKjyWrJkvBiuO6q6/iVX/81fvmXfpVXvf4mMAOiMbhckswoVx7NU7JOkvtKbxR/bbvNxhg+xvAxho9jHE8/xhg+xvCvFYaP8XuM32P8Hsc4nn6M8XuM3185fj/lwvjle57FZGtAmD3A6QOW9uJmbr7+Wh587GP0e5myWuKse4DbT7wXZ0vaCTbNP4NXveQNvO3Ef2S4EDjc/xQ2GQbFUY6aw5ST19A7Zun32nTb05g1w9LiKrHwOB9ZSivMFlsoKeinilZLKFpzrA4XmJyYZ7JbMaw902kHl7SeSa88hvg1Wr5DUXaph8Lxs4eZLXazbWoHle1hWxmTLO1Wi2E9wAw88x1Py7dJdsDKUmY2TTLVKjixkhgsrjJBSa87oDTQLabY0p7G7CpZOnMYWhHqyGpvBduvMdLjTD9iJDA516U0lomJKQYscHZpQNqiMsbbtl/Ja177E/zx2lke+9ztdJyjrguK0unFVAeSD9hkmOlazOZZTp1eYnFxmaLdwhcOixZmNjIrrLXaXd10FqcM2QomQzKROkVMounQNYjRMqSI0DRZ6meh04Z3FiFr0bGqaLk2rmip/0I+V9SWnBvJZJUFzqNuXJMxTjtATRaMZFIKlM4z8qE2aGdwThCTJloxBUxtEJNVZrjpsJScKIzFtjw5agEyi9ff1TBXjBUgEHOi8AU5J/WmFoFI0zGuUs1GDPMzE5w6tYCQabccoYYsNdZ6nLPqZZ7A20zMUTvArUXQgpXNGWv9+sFLZJzXSTLFhLWCLyyIoaoDhWlYSRF0QtDinjOp8ZRvCqAmE2MNscaQKazDiGu6dKWR/VYP7NTILccQSAKZhMUCSfcb7V4NOeASYFVeOzZdtWKagikJazM2q1+5EfV7t02Xe6hrJGX97qAzW4oqm27WO4BT0yWeKVsFktWEwpMRiYh3VFVSkMmJHFS23loQcXjrEat+4sZalaE2o0539QVPqcImj0lCqyU4JxgpqUMkJ2nU93XsaDGz8Q1JmZACMQnOFufLaWclgqiPecY5r6A3rLESMbYhZjhLzIY8DODAtRwmgRVLTkMkG7IxSFS/EiMGWzqyUQsAJ5YQMjiPtPSaqYcV0nSoxxgxdoDNgjERb7ULPKdGZjwljLf40mvXe0qEWNNuO1JsFA5yxGUQa4nWkJ3gC6/XSFI765HMexYDWQiiigvNocIYwXlLIjVd2B5EveFtoQSMorDEqJ7xzgghgThH0cjVI5DEksQQYiTWgYmyTZZM4YvG7zuqrLqzkJMm+0nB1TrBWUsyzbXXkEFIBm8tzlhCDERncE2B2TpDjCqrrxLoDmmUM1JMkJsCNUJuyBGF1d+JoP7wWeVwxOj8ZsTofCs6OyqIG3r9NZx3WGOohxXOGqxzZBH1iCGTExTOYkTnO2c8KceRpTgp6fEzxjRF8YzYAmNLYoxUw0qPC+sZ11c1RnnERlbeeX8vYKt/OT5l697vT+F9FyY0T4klKIYcDVYSJ049TD0ccPV1L8O3WiytnMBSEEWJMM+75VUsLS7y+dvfxbXXvIDe4irv/8u3UvUGXH75LkysOH36OF/4wvu58VnfTrvbIYbE8tpZbrjhFt719vfy0Q/fw5VX7eaKK5+D8TU7913L6RP7OXxkiT/6s49w+z2PIsFzy4sdd91zG9/z+ufx0z/1fzAzt5s3vmnAPfd9kj/5w/fw7ve+n7I7wXCxR5RMZSokCDdcspvn3Pgs9j/yMA8fPMJP/+P/k+uuvYHjR8/w2Kmz1MFQD5e5+qLdLPVXOXpqhcIYvud1L2ZhaZVduy7me980wzve9hc8ePA4OSY+8/kD/PFb/oiq9zv89fvez6GTFXt39Jnb3KXdKShaHbIIa70hJ8/2mGgXbN0ywete+1IefvBBHrj3/Vx9zcs5evgI8/O7iC4jYjHeQR0JMVC0JtaZo3rORhnEOMbxjRajxfmF4//Cf+fzX0qZweoi/aUDzG+7FieBbPRmV4pqZSOodY4pOw0mqIWQ5p6ZkUdlVsYsYBsCasNyyyp5KaVh865nEE2NxBpyIppEOb0FU/eJ4Sw2WM6cPkw5tw1jXGOlpKS5mszU5A5m5rczrCoqhD1br0SAzVc+n9ve/Gbuuuchfvqnf5rpHZfyz35hmosuu5qtuy4lpUjor1CTiXWftbUh2Vqk9oQ8bG5ONHN/Q1iLUbn+I8KcGCUoxhg0bzKeHGqMCHMzXV7/PT/Ka3qLbJufo7t5OySDSWpZU/iChlN77vA/Cc58uYvsr9Qf7enGGMPHGD7G8HGM46sVYwwfY/j/vhjj9xi/x/g9jnF8tWKM32P8fvrxlAvjYTFRXLKJQXWYTddWyImC/cf20+puZfHMYXr+ET720U9x/XOuZViXzO+YZpvZx70LtxKOC7v8Pno8RiV9fLScig8xseVeuuFlVIcup1qr8EWHyckWIpHpriXbyPGVhzlw8jPMzvd5cGmFrZNXc/mmWzi1epiydBxZfgTqFWIxRTtN8diRL7B7ssvW2QmmZrsU/jipdTePDB7iM/s/x+BIyUSrxYpdYXV5jXZ7Gk/JSupDWsUOpmDKc/D0Kao1Q4HDhkC7O0HZ9WSrRSzjh3SmI6sri1QBSANWxWBXhDJaFtcG4IeUkwWRI1y1fS9bpq9l68wmcop4CfiJTXzP9/0/fPrS9/HZj/05gxOHyP0I4smmppAu0al+/9y0YXa6zSOH4NTZHkiBIWJM0sJ0M4BHxajQMDlGHciQlQViDMOqJiVDWZRN16wgTgul67zArP4EKWrBK+YEolLf1pUYb0hVQEQ9ql1TuEZouoibrk8jWGdIkaYQbrS4a+05iaAUME1Ht+RMspbkSnIJVdGjX1WNhHlGJFM4ZackDDnHxtNGvdFjhlbbURZtqromxIjJgvcFKaEsOyPgtahr0C74uZk51taGTExOUJkeKbYwBiRpVyuNNHeraDUsGUgJysIT1n3LzbnzgMqDW2Pw3hNyoD8cImLU59p66jpoUaxhzxgRVL9afeElZ4rSE+uIz9rpDo3EexasyU1XqiUGLd7h0a7k1Pi0W5j2XdaqSNn2uAgWLZSTMk4E63zjE52JJMjgTFMwhfXfICYxkhn33tLQFLV4noU6RB0jouMlN5OUiUo/ymQQ1p8PcaiTUGHRXXeI8dhRF3eT3KWkMu45ZSQbIgFnDGVZslZn2i2vmNZ0z6fUEESyA8O6LzvZ6vFOSiiw1kBGpb5TxGk1Xr3QvW06gjOtwmNtbgrthqLUjmUbI3UKhKbYraSMhlWW1FPeuYIs2lkv1mFSUo/1RqLctT3kTAyBHBOSI84Y2p02qysBAG8t1nqySaSgY6rVbiENEWKkZCAiSm5oriPvvBZpc9M9jh4/kzMh1qQUcNaRQk0IEWMtzuoM4Fol3hTUSYvZNNdXFdRru3AO5wwx1nRaLcRAqgPeF5hCx1NuADQZqEIihJqJTlsl943aPMQUKb3HuYKYEzFDHSra7ZLCe6RRvAgJnC3W5zRvPTSkIAnqbQ8qd59SxDn1lC/LArDrHe7R6HvqukaMUHhHXdVYQb3uySQydYiUZUGsg56/xts8C7qfITEMA9plqQV1Ms6p9YSxrvF71ysKa/FWrQEkQyZgndF5sW4sGkqPd44UghJYYt3YTCSmOm2MCDH9TSxyLmRVbmRcnp+UbExczt+6WXSvM8ifODl5qnI4j9vD9UX9ha/ofCnNtT03twekhXUqTT/rpyAHJayYkj2XPpP3vePX2bbvGj5z+6d5z3veTn/hJK6c4PnPvZ6DD36aCke9OODowc8yPbOFzsxmTLbEEPm217yUX/73v4ahx7e9+sVs23IJj/hF/vTP/pjw4Tvo15G77nqMZOCbHn2Mf/APfhTXmmF6bjNldzPbWits3fYdrK1kPvDBjzKsBjhr6fdWMcZRtiw/+Mbv5NjZM/zKb72T6Xabt/zx/+S22+7lngcP0K8Drt0hhsBLXvxs7n/kEEdPfR5fOMg1b/zOb+PZL341t338PbjC8o6//BSdVotN85O8+X+8lZQhDCKdtqU/HDBcHHLRvu0cOXKGugrKlkkDVlZrdm6f48ziKo8dPM3UxC6OH7qTT37sg2zfuZd9l12Gb02xZeslSkgzhixK9pLReYZzLLvHnbPxYn0cX4+xcbEt5z9NZpS7PXk8ycIPmhufFl+2OD2omJGIde0GMHKjHIKS7kQwxHU2ukoNSfNZzXWYAzUJL0r4kgRR5UuoTh9hMFxksHKC6d3XYzsO0hCbEkunH6TTmcK3pwnOs2nXFVjrQIwq90gmO4NNqjpUliWewK7Lns3E7CYSkZgyZen4zte+jJkdF9OenGT77r0cP3A/m3ddTkbxuU5CbmxnMkrEM0mzU/0xiZyV5Kb46vDeqRpQo0qTRjmAGLIRytKwe9dWNm3axLYdz21uIkDW1h6yAXLccOOw+aonwbmNr32xxfbXtlN8jOFjDB9j+DjG8aVjjOFjDH+SkfE1w/Axfo/xe4zf4xjHl44xfo/x+0lGxlcRv59yYfyx4w+wuFhiSrjyyisozYC0sMgzZp/BJS/YSkSYm5rFh03E3jKXdW9kYspx8uRx3MJm9s3egJUTnJLbWO6dYeHMNJNFidg+HYm0fYkUYEyfSlY51q8xfshwrUfonOJwdZTCT3By5VGK1uVYCurVKarhFIPFJS6am+Hk6t1MFSVJKqxMsbi2zOLA0uuvMtUN7JzeRGh3WQ1DXFxjeTVz+vgiZ8+sYq1QWMGbipVBTzv1BtBnSJESsS6IVWJ2IhHygMIVPOOqbawsLxNJLPcshw9VrA4ik7bFlrkOCyuJsBAYhmX6Wwckf5i6FqzrQioAQ1G0ecGLXsbczp28/c3/lHwq0iraWJcwYUggqTe2iZTWsWfHLCbD2bN9BhgmOgXGQEhBwZGIMRZr1NfZW6/y1NZpcUtHNJISNmjR1xtpuoBVdtmM5LONrHdNemdoOUfIgnEOV6injGRLDFk7wo0maNY6bbw0RgukMWlnMBkxXn2sGwZOJpGzRVLNqGEzJQii/uk0nZRiVXraWC1oxsbzQQDJKsuu/uaQQk2yKoFuES12JiCr/41zjowWNSFivWVyqqQ3WCMR6HRLBr2MM/r5ztpm/9V/eORRnUVrw955PU4iypyxTceqQf3B6wrrhHZZkHPj3y6ZVqskhkCMKvmt3eIRYwVXtBrZdENd5ea4xKab2JERvCSavaFwJdKQILIxpBS0ICwZ327RH67RbpXUIZOi+jAjUBQFYhr575R1ohRtqV/3DG+KoCNAWvdJNlqANaKduN46kiQtwBotwKaonb8xJkLMKvstWmQunBaYUS4BxlhG8kCghd2YExK1OCpOE36XDQ5lwaYUMahvdk6ZKgQM2qWfmkWAduoajLHEGPGiHtmh1mNEbggMZqTAYM9Jxxv1MwctehZlSVF4BIvkiCQLSf19irIg1ioT3263IWaM99qtLFYZVnUiR5S04B3ZCinEpthrsUaICZxzOGvxzlEWXqVLsiGkgAjkGCCJdlZbbbdPzXEzYhBb6P4040ulwLU7eWSb4MsSgJxUvvuclLnuixHBNJ3joNe7Kwwt7yi9jtVWp4V1nhQj0Rq8L4hkjFe1CjJEifQHfSY6LVpFi1hX+MKRBUpbNttlHJZQBaZnpnCFw8K6X7sTtw6kIkbHb4ZEUOWHZLW7P6sPeY6J1HR15yw4q/LlzlqVl0f/nVOk03aoBI4mNDTXvCBEm4g5KFXDAGRiqskInVap3f6xAqGZa+36OBajRAVjDFacFsCbOS2L+qG3W4WqZoh2g5uywDlLmQ0pGawpyLECoCj8l4fuX0F8qQX0aPEFNPOgbHilefRlMvdG3/d4dvuFzM8N35EtKVcYcVjbWWfXpzxUAohxGEnkZDj06D3c/8gjdKa38/Y/ezu79m5j99UXcfMLX0usA7/3u7/Kpq1Xcsn2Lm/+3f/B61//Jp59yXPor6yy/54Psv+OO3ntt30Tr3zdj/Lm3/s9/v2v/HeWViKDfp+Lds3S8Y66ToQYectbP8TUpi38+I//E1IOOGs4cuIR5rZcyite8Sr2XfLbfPbO/bQ9lO0SY4Vf/Gf/H77lpc/nda/7IZxX/P6TP/5rTi8tAQHvWuQ6Mjc3y5+87X0sLS8ShrCShrztLz7N9p2bufvhx/iLd/w1P/zDr6bb+SAHHj3LMCROLy5iJGHFU8eKQT9SlI6H9x9DbMB5D2IofMFq6HPfQwcgBLyH3/6t/8wVF21nfusW6sEiJhmWTj7K3Pwe6uES3k0i5blTI0iDPeYpn/txjOPrIzbOSRseyoj0d+4m55e+9dRskc/Nb65ssX3fNUpoQxWHFJaVUZibGwOjG6BiNC/IKWOs4pl+llHeem7sP7BIHLLaX+b06QeY37yPuc4z8J15clzj7NnjdLuztCY2Y1wbcR6bBDe16fx5OOu+mBQxxjM7Ncuwv4iIJWbFay+WH/uJn8W1Zym7M9hs2L73crbt2IGQEesRM4HLlqquiTGQohJxhfPl1DTvVZJvUajyFKgtk+Z/GTFQlpZhDzrdDvv27GVyehMyYvCL5qyMbhY2xMsnsqB6qvFUbjA/Hs++rK/4imOM4WMMH2P4OMZxYYwxfIzhf/sxfIzfY/we4/c4xnFhjPF7jN9/s/j9lAvjmzbN0O/1EZd58P77mN+8BWMzvRWYn93J7MwsPXmYAyceQAYlfuYmjoeTPHz0MPXJaXb4adptR3uqJJ+9jMnFB2jvv4krrriJw+UZ8qCiF0rqSpCZ+6jKFXqrNUYMRXeVHAtW1jKDfJJWPMpcZw+2LbTxLOdJfLZsn302OVRs3zTP7PQe7nvwz5GTBbQdxdwkS4sdBv1V+mGVubkuu/ZO8/DgLNWgzwQFw75lqRow3e5SWkcV+tTDpFLAIeBzhxOnlkl+innTZnZqgl5Vsbq2yI7t25mcqNl/32MMo+CMI9Ur5FggsWS4NuDM0gJMC7EuaBWbyXFIMbAcWztCmjE86+Wv5q6//ktWj52hXXYYVJUWv5xQxUwVh7SKkr3bZylM4tRCnyoIRVGQxWhxJalUsPHqUW1I6vXbyANjBMmWTFafbYRkjUr5jgpPSotpulAtkgQrKgesBV1HshmTHTnZdSkFTSSiehA0xdNU16SccWbkfSKIc3pxpayyyVkwSSBmvDVYW4BpCpqizCBjZF0O25eeQrRwFJPV4nOMpGQwJjfy783l54z6nltLjlpYJSfqqkJSBgO5HtIqDNs3TXHi7CLbd2zHuaHK2UdLyhFEmTXGGGJsGERi8KXXScWAswYxlmE1pKoqCutolYUWjE2iriMpCwmnxXESVsB6i7OWVtHCe0fMFSlHUtOlXxROvd+Tpaoq9XgXwaZMFi0wioDERGEdISsrSYvoGVuIFrazNJ33Kl0tTXGwKdVpJ35KVEml4C2q/OGsnn9TejyOugrkFCCC9waSSqGnoJ3ZWgjWfbLWYXCYmLFJO/5jrKhjQNBidU7qF59DbBJ8nXzFCA7bFDi1aJxSJsWIM5CTvpesUtRZoLAWU2iRMSXtYE8pYySty6aH1HR/G6NF72yUGWUVWB1gJIExCFnJDKIS2OodbVRdwRjttg8BDziBGEfXjyiL1FhSMxZFEkkSriiQhjlVi+ALGEqf0mlxN2ctlFvjaRWlglIMpLo5PtY0xX50f5uu9JBTA+JZfdZjJKWINaOisCNZITYkDusMKel145zXJFpAJDd0Cz2G1hp84fGN10jhHCkGjHOI8zjnybXBFGVDVACMabqcE3W/z+zsNDElYgy0J1o4Z0mAKwpSSoQ6QEx0WpNY70jKl1DZ8UYWPaZI4QslLThLCJGQweLIjVOC5KQe6I1sec46FyMJIZJJDQEnr3vGF96rJ3vjnZ6zYI2oTYLRz09Ji+VLy0uEHGh1JnBW54R2qTBqm3Z9a72SG6wWxsUkTHaaFAhklHRkTYEf+YzTXJtkYqixNinrOtZY1/jU5PBU4fopxRPLqz0xg28Umu6dt9n6gvzJ/NFGSdZGabgnS4Ke+PkLs5ncEBg06TKN8oPBkRg284HhXX/xe+zZdzXX3XALiSEf/MBf8+6/uI1HHtjPc579PF7zxp/BxCWqKvKBv3wXf/CHn2Tnrvv4nu96IR+97W5e9KoV+v01hv0THDt+hE9//gFwcOzUf2Zx4Swz01OcXjzK4WOnKFsFmzbPs9oPrCwusbi6xu/89lvI1RlOnxnw93/k77PWO8bkzF5KUzHTcezeMstlF2/lk7c9wC23XMUbvus7OXLgAXbumuHkSsWw6nF66TQ5CbYQWr6gtDA9bXjsyArGeGKsdZwI/ObvvJ3eSs3uXVv51Mc+x8JCn29/1QsJrGGKDu9/3yc4dniFomNwpuDqK/cy0Sp46NGjnFrsE6IScrpSUJg2x04t8qwbL+eG65/B1rlNPPrwfdx4y7ewOlhiz75ncubwAyRgftsEOcSGNasLhyfuLHiiczmOcfxtjwvnpAu6cNb9h3JztxJGhL8vJ0QyKSesbTfErYSClXn8LgDnJNtqXZBnNF9H7WJMXHf9IptMPVjBW8fey2/RvMMYQhasabNly16ycSOeOJmwnvvovm24EYriLJKZmGjx6KMLrC4tMrd1GybV9AfLuHKCuHaatGmnss99B+vbmBSJYjWfypFBf6DrB2upBhUxncMAY0YyoPpcXQdCiPgmt6hjo54EdEqPz4l2t801115Ld2oKizSqQxuP8fkL5Y3Pf7UY50+82G/WHl/lGGP4GMPHGD6OcXypGGP4GMOfevzvwvAxfo/xe4zf4xjHl4oxfo/x+6nHV4rfT7kwvrzaI8fItp3C6ZNn8e4SjvUP8+CpE+ypWvyDF/4Yx82d/MX730y7nmTvzknuOvjXnDiQeO7lz6U1OcMSj1BN3k/JLXz7ZT/OXQfvZXVxHyf9Y1y96SLWVqdwkjlTRpZ7NRN+irV0H0YEh6euoMgTLA1WCUsHmZkt2LJphe62NS6abHEmt1lMPY6f/iArqwWt4m5mL5phMUYG/cuZsROslpZBL1ItRJi27Ng7y3C5pt+rSGuZbu2YLEqSHzJVW5Z7wjAaTB1Ya9WsLiTO9ta4aFumXRYM68ihA8vUi5mdF+3gppv3srpcszZcYvvu7QzigAOHVji2tIYvDYv1MmeXhpiYafnIZTsuhVjx6IHjXLLndVz3k6/ncx//Q/Z/+pOkmKmtg7qHz4lBnRmi8sJbN08xMz3B6TOrLPf6YBySBY/BFo6UI5IT2QRNYCRjrFPyRtN1KRjqOgCJ0jto5H5pCpjaBa2slGwtKWvx1xkQb0nZEOpEUXiq4RAjBa7w6jVuLcYYnLEqXZ6yFsLRrkkt1gPZYJKQo3YqW3FgI0UyaB2oKXoC1qhcTc4J7yE3XuHJKBPFCvjSN52faHHSe1KqCLHGG68dvSnhrMMXBTE3hcMc6LbbTLQnWVrqMTVtSQlEDDYrS8f7kmwMMThCCOSUiHVFlNyobag0e6fdYqLbJcVGQihF1KAhIEk9kq1360X/kQd6jBXG6I8SVFrdWkuSkVJH1uJqrMEIIY7ma5Vjd9bgWwaPJ8QIw4wQyLGidIY6ZbqdNnUUpI6MZnKVjNeJJJEprKEoPK6xzdDucN3nlLUYnqNFGhJGbNhD3jYeyNboiWkAAdEuf4eQwnD9OcRhGuUA/bcg4pruf0GsjtsUVcI9AxgQZ5EYGIbARKdF4R3WjPyghZz13EgjdWKMAh7NNaGFYmkK37JejI5NR68lE0JQRQQjOHEEZ1VGpPRKKoiJmHOjipBxBrwz9EPAOIvzDpM1WbbGYKwnk8guIaKkhBCCjs9QEeoa12qRc8JYaLuSqtdX3+nSYhJUOYAR/Wyrx1ayFl6TGDrOaaEb9UTJMSNZcE6l6gVLzApUIpacAtmoZLy1FhGttIvVwrgkjy88qSkoG0QVCQCK0Tly6j9uICUlMrXKFoNave6r4YDp6UlCqEhEWq1SwVbUO1ya69Z6hykEL5ZsTXO9W8jCMAWchdJ6jEhzLkGcUb/2OmILS6xrTMNQE4FIxnqLNY4Yai16E7EitJwWscWpRUOmIRxYowuMDIX3ShKMEEJi2BvQKj2t7gQillDXSpLwKv7vjMU615BfMiPrByVgqOd6ykkvDwPO+qZA33T7ZyXLOKdEppyizqMZjD+XMH0149xCWefaL7nd6IlRArohLmTwPZn8zYWSOV9qu/MX++eSnPXt0E5/IwHJBpHE+97/5/yvP3wL/9cv/HNitYpxBQsLK/zQG7+DT995K7bVwYllEIc8tP8g//13/4BNc22uv/Zibrj6Om771D18+sMfZMJUXHvdjTzw2Bn+/H2fpQ413juu2reNLVs3cebMIhjh+Jmz1FVEBFpFG0xmmOD++48yP9lh/wOf4eBjj7Hr4psZxophtcryygoPPSYkybzkpS+j7M7wm7/9B3z2rhOEFJQoU7ZZXRuwaXKKHZvnueHaS2l3HW99xyfp1xUxJfZs38bEZIf7HzqGbxVUKfDZux7k1NkVvv1VE1xz7TO54vJn8MyrLub4iWXe+ucf4r6HDvLgo0fYMjPHseOLJAHnjZI9KOj1AnPzBuuEj33oVl77mhex59J9zE9tZlANSBlOnT3IJVd+E2V3ioxlpOiQScj6gmHj+Tp3/vSUCo8bROMYx9+qaBjPX+w1kQ3bCU9/XI86PJSRnXNoiIxP9lnNTUkxZFTeLaVANoqR1coifnKOjDBYO4P1JcZOgEmYpN5o2ADGqR1IjhgaiyPjiJKwCCIXfr8QjRJpy7Zw+MhJDj94JxddfjnJdRiePcKdH/krrrzxFoociE6Vm9RKR2/hpqyzRG91lboOzZqgWSeMvmWU/6bUEF+TKhQZu07iBfT9hcO12ky1LZt37m2Opl0n+F0YF8q4nXvu6y/GGD7G8DGGj2McTxZjDB9j+N/eGOP3GL/H+D2OcTxZjPF7jN//e+MpF8Z3b91Lq10xv+co5e6CRx+4kxP3Cb5rOSLH+Oh9H+fyfZdyy03fylv+4C0Ubsji8AySp+mtHqC4+Ba2dS9idenHcEVBv76RMp3iyMIBTi8NCbnLRTt2MtGaYsnP8Ngd/42277G5vQtxnlhvZ64zRdcKvVVPy09h8xonTlWIX2bNr9BfWsC1tnNyZZmO7bK1sx0bK46tZo4czLQKWKZHqh0L1YDqzICpmS6+a0i+QEygKDw5VVSDinbRJtshkiO4kkHMlHXESUFdR46eWiG7it2bOsToadlJXGuKiXZkbRmSbdExXeLQsLy4ysJazcKZPqcP9miLp9URltcS05MlM5Nd5gvP/Nw2vvk7/hGXXP0t3PHxP+fgnZ8hVZ66HvDW/3A//VntGtRinj7QLscG7L4IS2Z90I3mEUYMl1ERE0b/t3F8yvn/h7GfbjxlFIKb/zWbnM9q+WIEjfVN19/cvCvnhqWSzv220XcBzmjB9MIf+vhnLny1+W2jCeKC15tSY+NJbc5/37m36z/Xc41zyenGY38hM2XjT70wNh4nkcc/O/qs9XO+4bFsOC9P9h2jbVMeyWLn9Y0ufGc+733nXs1P+gUbJtHR7z/vkJ1//DaeoyxN6XzjwZJmHJ53Mp/gzI5YTJw7ZuePtwtO2BPs73mvnbcP574yb9hORAunKhV1bn9Zv/byunz7+fsj50Cg2eGNMiUZJaEYI0yttPn5//xa1M5EQTelgKSAdyqzhLWIJGJQr3XJQjRgnWCzdoTnFDHWUxgLopYFyjCzYI0y4xoJFIx2j4uxWtClsT8gAEKMAWuEVqvUgm2GmJTNlkIkh4g4QVzGikDS7eu6ZrLdUTmtUNNutbTLXPRYStbu/xAivijwTkkR1hlSMwgG1RBTgG/kyVNMKorR+JeLtVir/uWpcXAZSeObpgBNriEHnFEpeSXRGD0PzUYpZ8hK8EgiDQM6E0iEnKiqmnbLg3FYD7GOeKvqCCKCQfDZEIOaGxTegej3FdYRU2pIF2BNwhqrhBP49vHWAAEAAElEQVRpyCNW5yRnLWIyzpbEmDBZiRkpJ6pY8zcZT8xePz8SjZ/76JqTRomE0QJ7w/X4FBiAXw5DMOcnYEGLcnCUUhAgWz7y0Q/x67/6H/mRN72KZ1z/HOJwjZgNmzdPcPUNz6afhuTQp+qfRkyX//lHf4i1iVd827O46eaXU3YnGRD447d+kOVe5oGHD/FHf/BWYrLUDCmy5f5HjnPP/qP0BxU5O2LIxBCJIePaNYUz9Fb63HP/o/yjn/we/vzdH8e7wBvCGtlYfuJH3sTn73uU3/r9t0GOrCwc5Zf/zS/ygm96AcO1RT72mQf4pX/zC/zKL/8Gh4+eYn56mlYhvOCFz+HRRx4jDAK+TAwk85znXMvxk6eZPHqatbWK46eWMBmqGLj183fwtre/n1e9+mam2pvYsWMT11+zh6IVObswYLVa4apr9hJinzPHK9rdyNpqxc6rd/Mv/tU/Y9uWHXzgvX/Ann3PZG3tNJu2X8Hq6lGMwJXXvpwsQRNtMQowMkJYNoLkBX/lcdg1jnH8bYjzbxjCxrGbN6QUwrnXFMM33nB6umN6NF82n7OOS7nJix4/+ekcG4gpQaMSQ4NBrtshhSEP33Mbn/3sp3njj/4cmaxkUF9AApch5wSYJpUxGBOJsW5Uhp5YijEbtWapqgEpBs6cPaH7lxMTs3uZnt2KKyZIpsTnTCZiUIUjIeNELWPOLpxl0O8zIrHWoXrc79t4TOu6xjXKNqnJAYfDIa3CU7RKLt65iYsvv7K5uWFgA53syzkvX1vP8KcfYwwfY/gYw8fxjRxjDB9jOHx9YvgYv8f4PcbvcXwjxxi/x/gNX1v8fsqF8W07Zmh3SoYCVVpjbm6JU26F/vIU/eVjHHnwATrFDq675Xra03/C6kKfzVsuZ/uWbbQmupitZ1gd9rj/xAOsHN/Jc/Zmrtz7Au489HHCmWXOVItMxhaH1z5Pb+jAt+izAGKxp6fZPLWbYa6YaCWk9nRaZ6lzgR1cw4756zh+doXQq8j9E4TiBPsPX86mua1ctetqylbNBw7dw9KZiJuwpGHEDAzTczO4wjE5IWwpJjjTWqLf75MWMjYU9KtMFSt84SnaDpzKBmAzy6tLHD17mOkJx7W791E5WFk7waxsYaEecOp0rYWhKcO+izZxeOoUkiKdWLM2WKPOHdZiYGWQkB1beOblF9FuT2GsZVIM1171XHbtvZJP7Xwnd3/87awdH9KfrVnb9NWV0316Mfxa78A4xvF3MhSTE6bwiDeY4GhZlcvPFowrSUY9w0VUgh8EK6KEkZxB1Mve4EgxE0Ql/E1Qya1kMlVUmXAVbTAY50CEwhhStmQLOUFd1bS8pyxLLd5LJqasXfeNl33R8oz8XZSlaqj6A5z1FN4T6op2u4MYQyDjnIcQtQhuLM6rX73VWjKusI3sesRJxlu1cIgpq8R6kkaVwhAkkaKqJSSt2Ku/vVM5/xgCOSuZRjDUWYCEWnqrWoI1QsyRGBPW6m+RmCFBqjJZIu22xwRIIRLySHFDMGLxTrvvEWUbCka7vkVIWbvpM+o17pzFak6hi5cm5zE5qcdUI7Oes8c5IedICDWI0O50/yZGHOeSwaewdc6qOLDh3RcwUtZZ6xey0r+c+NLeMSNOkpByaq6HgkTgiiuu5Md/4u9z83NuwtkWRavLw/s/ziMP7edbvvX1vOn7fxIxGUyX5YWTPOc51zExEfntN7+Ld7z308Sq4viZJXpriQ++/1O8/c/ew/JqjVgPdc3KMGoimzWRbZWZdqtD1V8i5Yz3hiuu2sVF2zbxHa9/Fbd806totz0PPHiQf/6Lv4CRkh2X7OEHvv/7ue++/XzhCw9x4tBBvvVlr+XFL3sdO+c0hQ0pMhwOuen6fRw4dAaRxF33fJ4PffQOBinik6XbKnj3ez9FbzDEEcnSoiiEXq/GYjn82GmOHl/l137zryBXvORFN/BPf/7H+dhHPsL9Dx3jZ//JP2HTpu186APv4Fd/5bf46Z/5EbZOT3LR5c9iz6U3kkLixpteyJZde1ldKPCdSWanrseKkKo1FheOINniXIk0pBuaa4B1Nu8FZKSvv/tV4/gGiMd3y2xcmDfjeH2Tc/NTHv3fV+rnlxttJBMhCzmZc99LImdzwbzYqJJgsGKIMXDgwTvoLxxn32VXs9w7y9zUTlbPHOBFL/5WBIeRTJZCiXLGkKNRLEz6HcpaA2vL5ibbxhuu525QSK2qMoNe5nnPuoHnf+u3k1PCiqEu2txwy8sxrSldOAuAIZEbPqvK1YGwtLjEYDDAGsMwpQvOgVokxaiebdYactKbFd55ekNdC1mrZLtux7Jpfop6bbE5Q+G88/S0TknO63i2Mb78Gy/nk42/ujHG8DGGjzF8HOMYY/gYwx93Sv7WY/gYv8f4PcbvcYxjjN9j/H7cKfka4PdTLozPz2yFqocZbmU+zzC/5xibWyu858/vZ2JymlP1A/Q+/xAfuXWZOWkTWWHn7EXs2D3FFw59hof+4i6mpzdTlAXDoeXBQ5+gxSZmOpFhOkJ2+zjgDnDi5DG2rswym2Yo7Ha+9dI38Y77/5T9Z/azbfMOVtMK3W17OXXqHqrhgNWVUyzkDtOtAWWYwNsuTM6xUhfYVYtLF7OtiHz/N1/Lmz/wv1g8k3AGypanFwLhbJ8jRwZs2WoZhhobHd3ZNtXCGr3+ENty2CSYCpI4TOGw7YLSGSYmW2yf30xtDGvVEseOLXKmA2eHy6ydWcOHNvXmaaalxfzkDKu9BSZmDN2pjB8KZTFHlYY4azh25iTt+WkmOlOknIgZOuU8r3jVD/GCW17DrR/9U/6H+cd6eiN0F33DnmmSquZhSjrYm3EwGg7r251j2pwf+dzmWrQZMck2bt88Z51nfYSts2su/NTRfuUNL1/At7mQrbaB6qhJj3r+pqY7lOaCdnYE+Bt+18bP2LAH53+NnMegy4yYMBs2bt6Rcm5kmxuPBfL6cTz3FfrdGxuIR/vSbHluxt7QRTw6X6NtNn794xlJG/f2gtcet6mc9yiP9jHrj0wpnTeZiDz+fRt/03nj6IKk+xxTa7TN+ZP2xl+SL9g2n3dmNp6/kT9381q+sIP9/H1ISeXmEZrOW1kHztycp40/cX3/niApvCBtPO85HZbS+N6r3IiMrrn17UcA2TzzhKfxwrGOeqQDS5M9stHnfKsgewPeYCpHVUUKZzDOEFOi8BbBkHLAGot1BTknjBNsu62d9BFyEpVrCQ3Dq9aCeo160VuBkXy6dQ4QckykEBVMyeQcMFJoJ7jV7nG9/nRfOp0OGbSI7SwhBFZX1/CuRavdIseasqU+TCKZblGQEUzh1yVbjLVgoCgdMUVCqjBiKJylNJbhcIg1o4tMz4MVIaaKHBOSdAylELQ+LwJEYh3VUiCj7LUM1mqn+EgQQrvWK4wknLWkHFG6QGLQGxByotUtiUETAGcN2WTEWoxYMAI5qRKDSSrpj3rT5KwqAGpz4LHWYa0gJo3yLDKZTrtsFpkJQe0IlCkoVHVFu2Mx1jCsB080qJ5iPNEcPRqTo//yhv8ev9UTPR59MhsSF9l4rT1JfCkm+xN6qz1RYpQTRqzuddJ92LZtB6/89h/WcUYgm8iWrbv5vu/7ATquIgBFa5IcEtQnedE3v4Rrrt7N9i07CFh++7ffQhj2QAY8+NhxyML8bJuqStQ9mnMLrtkfZzyDfp+JiZJ+b8hKb8jDj55k6+wkz3v2S6j6gTvueYQH7n2URw4d4fRSn833PUrpS6679ipuu/1eLrvmGbzkVd+GNQWrQ+H4sVP861/6NcpSeMZVu3n48HGOHl/lj97yIVb7Aes9dTXEimW1lwHDMMK112zlyn07eef7b6eqA48+fBRTeExRsLIa+asP3cm+Xe/khc+/iRe/6nvYte9GUqi5+cbn87M/nXnpy7+LVnsKU7QgwerKUfq9JRbPnGLzjitQMojOseJKJqZ2YJ3FOktGr63RQkZZsMC6DNV5GUbzOD3Bc+MYx9OJ8xH5ybe5MP8Y/TM3+eGF43XD4yfKmfLoma9w/I5S6nRhrsN67nvh1CzrLwaGKyd5/zv/JzPT8+zcczGFLSimN7PvGc+nPTlDbm6+6uUpYDLGZlJuWOEiDb9N83YxT+zJpTBsND+ohEsuuZj25CwxRXAFLkfEFSQ81qTmkArq+6PH1xhLTEFtcrIq16Q4mgsUf0HJZCnpZ8SYCCYSc2pyMf24wnuMWGxOXHPt9XQm5snJIFZlPbMYSIEsbv0XPP0zlc+dk9E5WF+zfPGb0F85A36M4WMMH2P4OP4uxxjDxxj+dxXDx/g9xu8xfo/j73KM8XuM31//+P2UC+MPnbqTXTNXsHvbt/HKZ+7grR/8jxx98AyX7t2Ma8/jY+aRow8yYUrmLnsR1163lX4+RLfoMzd5OXK2QgaRlX7FdDvRS/dy9Og2nnXTM9kzfwcD2U95tkNbStrb9zFYHlLmGWx7huu2X8qR/BATnTkWVk6zcObTTBT7iP1FXLHEkfo+lsyAbrWVFz/jH1NMD3jg8L3s6F5JDImT6RiRFS67/CI+9pm7iEseYyvaGMqOYXVpQF2dpCgyRfCE6Yx1GazQajnSIFKFId61CDHBUo/2hGd6Zo6Dp46zvLIMtk0rlZztn2V5tUcpgpcheWWVQbvL5GRJFRLihJm5FsuHa4aDFUIhrPb62HKRyqwyrFYpiglsErwRhIpNmzbxmtf/OC3+FaucpbtY8MM/dSNGIhINMYDxQl1FlpeHnF3oEbMByZRliTOCNepTLYAYaXwTMs5pIWbdO0DACbTKksI5kIizgnEOaxxFt8WOq27EFAVWLLHuU/X7pATWeLIkRAKpjiAQk8oJ6xhNGPGIyRg7uk49glMZZyMYa8kxMOytUPV7nDp8krNnlog5U8dAt225aHuLlAJGPOSwXkw1YtT3O4WmsIcWu2LjmWyN7ktOxJwQ67RgFrRgWBYlxloG9RpGPEuLFfPz85AGVMM+Zacg54K1/jIpCyEG6hDptNqQhXqYQSIpZqwVchIkJ0Ic4lqenB0pCM6CdSPva0hJv1/5PBYjXudgM5JIMhAToR7S7pRkoI4qsW29RUyp3agCki3ZGepaC5HeO6o6YMRyZnGRVtmhKEQLsqKy1dZYSuuxxjKohloM7LQx1pJCIMUayaKfnUBsxBqjvtEpkY1FXInNjXQ1iRAikiDEgFiIoSkY5sYD2zqyGGU4ktc9LArvIWacdeppkQPWOUQsVgIJLQLnFDhxtmJqqoWTCJLpdKbIBLyzVFVFqJWtlNJIsrtWH2xEvchF8N4SQyDVTaexNaQYFbqbQuwwCrZs4ya6zM/P432pvtC2UEnuekDLZob9NaQomiKz1kyJ2tEcgew91npynSAMiPWAehjpdDr87E//FotTa/o+axFXYJ0nmIj1jqJlKLxvrict+nqj8klGhLLVwXghmchwMETEIaLdzt4KORuSyXrtp4wvtNMc0a5nZcdpMdcbLXqnlCjKEue9/hYRrC3JOZJixFvTeItnnPekGElVoHSesqXXZiJijcPZAmMsdTUEgWzdOWDM0kiLA6KeSoIy02LUznJSbgrNDjGGGGtCqNUXBajqSo9DWZBSIkT1G/dOz79+l0rI6/jJOG/XExSTDaGuyRhCyAyHFc5YWtZCjiptb7JKzlv10yLn5phFxCvxJKWoYzfo/GeNwxjBoXMBCXKKCCpbo/NEhKaLXK0OIMUasqVwJWITKas02NMNITdJ34XJwoUsOk1UL2ToraepT0S5GyVdjBbkT7BJ8+QTJTBfUYx+U87Nd5+7wSAkkEzOgm9NIqbm1MEvML9jL6W7miyZd77jbbSd48bnPI9Xv/I7ue1z7ycCgUzhINQJ6yxiHMPhGsYIKRuwsHPrNCtrFdkFQk+Y3zTH8WNn8Dh6S2t86JP3cOsnP8Rtn/kkt37ufq695FI2bSp4+MAax44d47Ofv5vZ6RmWlld48x+8i8v27uabXvxGXvyKv8fn7rib3/jtt9NtF7zvrz7LqbMrOgajw1lHPQya4xqH2ApDJonlsWOnOHN2lZQgkQjWYwPcfMM2+r3I8uoqn7tzP9t2TnHVs1+BMQW2MMzO7+O5twgPPfIZrnrGS/DJEGVIt7uZZzzzpTjXpii6VFVFqqtmTnD4cmYDOSk11xYb1tiyYVG+ccA8boTw+LE5jnF8tSJf8Pf8x5otpg2vjRbs524WPdmi+yvtIrpwTpSG9b5OTtwwv14YSYCsWFq2JvmuN/0EZavDxPQEFBMIlrntlxJTwEhq5sdmbm9+ntl4o6H5Tjnv7/mxce4e1EN27NxN2eqoN6II1BWra4tMzXYVd4xrME+PszS/KWdhWCdCysTG92z9Bkdzk+DcMdE8I+dMiImYItZaYtDHvnQcPnaaLVt2s2n7PjKZUCtxUqx6wKUszW+N5NGNiCf5XU+n0+rCG83nE0W/8hhj+BjDxxg+jm/cGGP4GMO/fjF8jN9j/B7j9zi+cWOM32P8/vrA76dcGD9w60H8FRPMujsZ5lmMm2Jmbi90jmONpbfap38i8cxnX8a+S1/IM595LR++9fc5fHQRkybZs2MLdAP9pYrIGsafZHUwz70nKob1IrGXmYyWo/EeVheGdPKzaE+XfPCOj7CtXOOafTdzYvEwy1UkyRlqGVD7LmDxIhg69MwZ+v1VerND7lt9N2vhMDJ5BdlO0O8vEdJ+9nSF0wuOlRQx1hL7Bm9K8iASawiFpV6KuCLiGk9YSsAZjEnElOnVQ5LL+JUe/d6Q5bM9qrpH103gfCbEmrZvUZZtWh1LPy9TDko6tsD7FtNXdHiYBU6cStTDyGAtUpSnON1r4U2Lra6DEYtIoHAOmyM2Z4qyBTRgO6jIZOqY9N+9ATl6uhOT5JQ4dWZNO+CtJVuVXUYyhfXrBRiVR1A2iLV2pIasnxsixliERIqR0prG79tiTYF1Bc5arFWfgRQS1jgyUVmC4shZyHUNOSIpkiRhXG68B5SdYslgaDpx9b8QVG45OIcttECoHeRJfamNwVmHJC2qatesJedENRgiovLIiGCyFhqrWFOkrN7B1tASoSgK6rqinOgixmKNY2Z6ksK1Cf1VTuVAyw+YmZ0h5jlytFRxiTi5iRBbnF48wXK9wKSboOhkemuZFFukKNShJlkoXEHCUoUBhfckI1hXYmxCSBS+0EJjCnjjCTHji7JJqiJVVWELTw6GlGuQ1BSRA0VRqDRz0cJagyFQD8F6z8TEBKmRd24lqEJkaqJDxmEcOGOx1pNMxoAym5zHF55BXZFioK77FK7AmQJjDCFGoqlxXgvCmUyuBxTeUrZbxJCACCKIUb+fwrdwFsKwUm8Kb6jqmlgHLbTTFHeNYNGirViLcw5jDTGiv9F6bIaII8WaiMOaPt4lSFoQ9c4QAs1nJ8rCEGMmi+57FsE5h7WOiDYsWyPacVxYYsxY49bBdzQZx6a72+RMjJlOx5MRvLHU9RDikBDVs9uLKMHEKElDWWEqO24zxH6/KSoLIWfanTbiNn4nOF9AMuQqYUVoTUzQbmedr2Ii1JCMSr5k1I+7jjUmJ3IMOBFEVAomhhprDNl4stdr3jpBJOt+SdNpn4SIgFEJphBqQkx4Z1QqnHPklhAj3hllkuWA9QZyoOoHcjJ02yUxDyFHCjHKSHOOGANiBF/6pvCt16OMfng2eOeo61pB11isE4x4YkhYUZZaThlywpeeFCJioN1pqX84kHNURq0AYkjS+NFnTbycN4wUKTL6PalSAkpOid5ghU67g7eWECMJyKJElBwzkgWDJY2K9gIpGHIjeRNyUImclDTNEyBFisIT64CzFlfoPCxZyQg5QyITI5AThSsxxmHEUlcDbOnOsX+/SjHyvdfcYWMS8vhEZJRgZDinpDHa/gm2e7IF1uMW+0/CWpfzErIvlRSdk41bT3ARjERy0s5+7zv0qiF+cp7ZHddx+ODd3Pn5D3D33Q/y3o/cyvNu/ixkePd7P8bSaq0EBltgXCSTObu4RAyNR70k5qc6vPibrubjn3qYsyurXH3ZNh49epxA5ptvvowHjxzm4osv5md/7pdxJbzypc/hR3/oe/m3/+E/8cijR7nhut1cd+Vl3PPQQ4QIBw8v8Qd//A7uv/cgt7ziNfzgD/4o73znx9i2pcujj50F1A5hqvAkaobDisIr/oaYwRrKwtNfq1haqmi129j+kJe/9CYu27OZa6+8jLMri3zzt34Xn/vC7XzLN7+aqZltCLWqM3SmmLUXs1YFclYCSIxGk1fbxfo2IhZjVdVBj3XGGCWD5aQKByK2UbPasMiWDaNrw1g7d9rNV7ywGcc4LpiJnuD1L7I4yqAs6Q2f9r95UH6xufCJQ+eijFWVKeuZ3XEJKqgUQZwmOVmwpkAX2V/+YvMJ99NAikPWhj3a3ZbKOibFhZQq6roHVJCVgGdGEi3kZrENIAyqSIjNfTtjgNDcXM3klM+zV8sZ6jriXE0IqSE3Qq8/QIBBHx49cJCqXiFlofSTenySJYvFSJOfJqvP5yfwy/xSvztvfDyax/KTPtdszVerOP5E+zTG8DGGjzF8HH83YozhYwz/xsHwMX6P8XuM3+P4uxNj/B7j99c/fj/lwvj2i/cwNbubPLOJX//dX2Hx0QWee8u30D4DR8+cJYUhU7PbKLsFuB5Fp8WVV72Iu++4nRc987tZ4DbOHP0EL3zezdzxwGlufewRLu1ex3W7L+Hg8R1cs+0FtHYEFr5wL2UOhOoYjxxeYKJ7Cbu2XMahhQOsLJ5mk7+C3VtfyvHeXZh8hG6rT9m7hBCPsjQ4y12P/R6ri4mzgwOYlFh85DGsN+zccj31yiYuvvQAe/Zs4o57l1hazrCWyWZIt9VBCqEuamyAdlGSrUrhpkEi9AKDQUW1VpOzoxomekt9chzQnZ5muuOwpgIMdSqJdUWVLESLqx2h5zHtkv6gZoKSfRfPEcpF6rMelwzVGhw5tEh31zId32eyPU1qZCWKHJFcrp8LX7YxpWWw3KdPIlaBVqtEHNR1xdREB2cMK70Bw7om1kJ2DucLQkyYnJGUgExOWgA3osBomlGacqaKkbLwOKMXliA4V2CMI9P46VpD2WoTq9B0ZgoZ31z82gksKUI2WGux1oLVi9caj/MlGSHGRAw1rU4bMZ5KGm8CC7YwxJBxyWBQCQjnLNL4PUgWMJCSYL3HUzSSyJByzeSU0C06RBKz3SnisGKtGmAxTBbTbJ7fTLs7SdntUg0HbJqZpdWBQa9HUXYp2hPYYhKypx4u01tcgZioB4nllcMUdopsIscXjrDSHzAYBupYsNDrQRREOgwGjhwTGXBtR6+/jC8LWu0WZdmirocMen2cFTrdDsNqSF0Hut22EhIkUxQFkCjLhpTgHMaWFK02zkGKVoulTTd+p92lqgeYQkj9Ie22Z60f6Hba5Eq0CFw4DBmLdtY655koPHUYINngbIsUDSEnvIPCgpUCZxxlYRkMUtOtnulMdpRBlGr6/TWqKuBsiRCIleCdoWh5fGGphrXKXFvXAEbEOkNZtjEYMNr1bhKUZYFkA7VgyxaSLGtrQ7xLtEuPsx18YXHWU1uV83ZJi6pVVTGsay20G+1wzo0UujQs1yyGUEec0PgTaSdvyuovZIxDmgJuTFHHtBGoh1Sri7RKizGOwpc467XACeoZHYGgxfsUKhyCKwu91pwlZ6u+Sef4wEpWSIITR6LCuwJjh4S6bjyrDbbQKzI0ki/eG1UecFb3LQkpRHzLK3uUNKrRI8rjVY8nlMBgxKp/eNaE20iiKCzOqSy4aeZCMljTqEzkhEhGJOn1mypmZubIOVLXOncpAy2RYgADrU6pXevGkTPrJBkAMZacDUWhXd8xBIw1hBSwhSpciFWyg3MFxJHsuRJ9cg4q8SIbADLrbxyx8pz364XonDKSMxktuMc6MBj2mZ6cABFSDM3xgsI5kkd/U9Z5Molp5NAh1rWSdsQQspKunNOOdLWCsI2cvCCipABxKmuTs8rVWKvsQGtVuSDHpN/ddkqksfapwvXjQhfRT7zQfvwCXJOIJ0zaGhbhl/i2p72fX2rfnmDLJ96D3NhViI4fYwquuvIFrK4e5uMf+GMOHTzIb/72nzA7M8PRw8u87cjHeN5zbuBVr3wJf/a2D9Gr+8QYVXGgSRALr8QbZy1hkNi0eSv79q2ys5pgfm6e4ydPctNzr2J2psvzt17P/oMHWFztYweZXn/AvfvvZm1Yc2JpgU/cNuCFL3g+KytKDkl15l1/dTvved/tvOGRw/xfP/MT+KLkZS+5hd/6H+/Gm5Ky7XjjG17G/ocf5f0fvJ2ynMAYQ7UyxAmEEEkRWpKh6lOWBZ2ixU3XP5PBsMfWXZez59JnsX3vVZRuFtOMz5wzeEdh5rn0smc3eXzGuRZZaqwU5CRkIzjnMbkhxcSGVJKU0DY6FQ2PCF2d6/U3Oo3n7EUuXECNV+Xj+GrHky2EGkzYyET/W3JX6EvJf52/cBckewwN1lr1L0sJjHXNhdh08XDuhupXHFk9xRbOHuPAo4c4eOgxqkEf357ASqJOmcnJTY1lWlCy3fqNXFVvUuzPDHtL5JQQSSCmcVc5t4gVObegH+X0ISbOGRDp3xBV/eiWF3wzxnpiXTEcrCoRjwzllOY8WdQK5QmGht4MuPA5edw2F7428kD7m44xho8xfIzh4/jGijGGjzH87waGj/F7jN9j/B7HN1aM8XuM319/+P2UC+NXX3kDl2y6EbdnwG2fEa689FL6dcXE9BamB4lh0aa/cIyLryn4wr1/zuyeVWb9M7n8qmdw15H3sGXeMr1zwFvv/iMefbBNdajFsPNBav8Yw9MDTshxLt65HZdKvICbLHjo2OeZ6k1SXXIZn7/vI/QX72Duog5LBxbpHT3LttblbNlWEPIyvQiTeYblznEWT5eImSROLLPcnyQevox97Z08fOwRSnMxRWuF3du3MRicpRrWTHc6DOpIb63G9g02Z3Jd41uOouOoTY20wTvBSJdqpSLWmbC6zLYd89jC4F0mOYtJKhMd1yLTmyYpJiwpBs4sHScvZSY7LYbDPm6qYLoLx89UlHaKYagoVy0lnYaBErDa1MgATwg1uaWDoNXqsuX663n41k/g1gqm2h2cz1T1kJhrUjS0S4c1LfqDwPLqAFLS7tnYdE2PhnXWoqgV/S8BMWm1LadMHAZaVrC5xol2nPqWQ2zCkhAxOOeok6EONcZAjJnQdKa60oHVordKM+hEYazHSIErWtQhYJpmSG0KNYxcnK1RWXtJkdHbvStxRYTIumR5zAHvwRSWMKzw1iAGJDq62bN1ep6Wc8xt3sTU3BxI06MbalzZYnJuE67VaopUBQmhGPRhEOj3gzIf45AYBNPpIBjsVGZ6516GwyVihPmLLqMsPIO1VXIMrA1qlpf79KvAqbPHWV0+xdrqEoEK04JWt8XE9Az9fk3Z7jI5MU9MAeeErnRZXV3Ri10gVZFqWGm3rzUUPiFZKFtTuNKTpcbYEucy4iAnCynjjAfJOG+QCJVJlB5l7JCxppnAm7EWc8SSKb3F+g5irBZOo0rXi1hIoswfayhbrYahlFnrreJdibVCUZRY6zDiSdkwYbSwXKcaYqTTqADEZBEsYnR/CmeJWWi125SpYDDsYYyFbDDioHTYKLjaMj2dmOxOY/wEYrQ4W/oWRUzkWGOswZcZMatYI8QUiKlRHYjN+A8RU+h4jnWNpEBRGupQAYlW25IrQzA6+VunHeGShdWlswiBspwmJ8GKynzbde8NraqqL3hBzBnvNckXazDZ4osO9bDmHEoIiYS1GeM8BEMVKqgqDA6bIeeEsSp97pwgVlRNoFlIWQtYMMaRYsa4TAJSUPJBThnjHMYb1B8qqdeTqN1CFRLZZIqiIRIkVRUgRZq6M2AxRhDjqKtAb63PxEQXsUNSCHqsikI9VHJDQ2g8TYxxZAlqn5BSU7cWYl2RUKJFbrSgBPV0N0ASOWc7kACj8lopRXLMzX4qcSaLFpFz0i76nDMpJ0LjFQ5ASlijxemqGiI5M9HuNPYFzXuTyq6H4QBXWMhgskVMhKwKAtY7iIKJGRqvcsOIfKSfUxNJWYv/GO3+FjHk5rcaRonLKH0CBLLoHBf14nyqcP240HnkK0/IRpgho/lz9Pkbnv+i73+C15+MpQmPT0ifPM5f2IlJ5GzIGayBjI63bmcbf/mu9/Fn7/oQJxeXqQeHiFaQmHn1617GqeMrVMP3MdUtiGKYKDvknIkknLfkuuYZV13KHffu521/8TG+49ufxzOvfzYf/Ogn+O+/86957KED/Nm7/5r/+59+P7/3+3/K575wgMEg8Wfv/gRkwxu+49V8+nP7mZzt8Jfv+wCf/swhtXxIQ0Qym+Zm+MAHP83ayhlirrniit0Yk7DiufzSHXz/m17Hz/3c/0urbDMcZETW2LpphrW1If1qQJ0SpizYtmmeEAOf/Ow9fOHu+/gvv/4rXHbVjaq8YaYwYkkSkFSQpUZwqoqQIyIbFCyM17/u3Pk1RtVZVHFGrzsr/vxRsn6uRqvxC8/vxvN1fseEvnXjuf7bsWAax9cyNsyLX5KVfmFs9M0axYVj6kIJt7+9Y259vhTUrqdhb5nkG6LrqHNHZRU1l0e3+yrEaK4/c/oMp88ucODhh+mt9ZnttshYfNkm1YA4RCKYEV4I5Ca3z4FQ9zhx/CDkqPiezr9RYq3mGKmxeLHN4jyGgIhbl3VT65Q+RQnd7jRW2piygJjp984SqyHtsg2ixNGQHQ7NA5Q7N5IA1e/fiDNfDH8uxKwnX5h/dRbsYwwfY/gYw8fx9RtjDB/FGMO/8TB8jN9j/B7j9zi+fmOM36MY4/ffbfx+yoXxO79wOwc2n6G6r88EbdqtwNGDd7BQDXjGvms4snAfs7sdp+rIww8/Srv9V0Q5yyte+gqu3DPJg2vv5Pg9yzx0xzKrK2dIy9Nsmyo5ffA+ggw5tfwQj952G2eWBjhzP3HpANNbWwwW7+W+B7dQOMv+4xWh3sXFe27mXvs+FvtnkWFNKi2szYHZwpmVB1g7tpup+SvwcZWiaHF8OOSRA8eZmF0jru1mdbmmDseZcB2WbCbWQrUGSTIhVbTLgl5MlFUgDSOVC2QDNgldY7HTBcYI03YHU1tmWOgt0R/USEjYHCgnOvgJSz9HTPJs2rydul7j1MmzLPczoQWTyZArQ8xrrIQew3qZqclJOhNzTE7MICngRdRbWqwWBZuTa4zl9d/zC3xg6ve5+8PvppU8KaunrpAI1bDpCHWUpWMiOXr9NfXathZJCWcNMav8ecwJiyWmpmhtQIwyR2LK9EOkhUFsDRi8MSSXSSHgGtmWwvvR1Ypx6lscc8CiHbGSG09sGRXJMtZ4leSWTLIjeaAAooVFixZYjRUK57EpktKAKtQ4nxHjEOcpAJssrVbBzHSbybZh0FshVENKN83U7BQTEyUT05OI69Cd2YK4Fq7VxthM1V9AgqMeQkyWXEXqekCqAt4JMcHS2SEprjDVmaDKjuXVRQSPLRYY9JZotzv4VHJ6oSakzORMh245YH7rVurgmT29jf7aMoPBKtY6LIaFUFO6goXlU+ShPr+6WpGSw3c62EGNJeIKx9DWxJxwppEdNzoJ+EJl5bGu8XpIylzMkSSBkAM5RJwDLBRGyHVsmJwqTx+qjC/b+ntsQU41OVZAxqDnV4wWO50tUV93q3+NIFLqh8fYzKc6WQ4GA1qloXCeQCbEoMXebBASMQqFy5Ar6hgpWhM6PkMmxpqcA05MIzefIYsWPH1J0RFs0UWcx/kWYgWHxRnbFEIjMWhi3u52MD4yWF0kh4D4ktJ7hv01airtYBbBFBY3hDoPEIm4RuI9WEcyTpUVYsZZT0wVhRU6k1PgDbmOeGeJGKxYLa4aVVFx3iLOURhLCENwOvnnEHAdCHXkvAUFo+K5RaQkZZXfTiGAtRjUq31dLiknQH2YRgkzWdldGdGia6wb/xF0lWIyzhhSgCiZ3HSPk8F5h7gGHk0jP2D12l4HpuZxrAODXo+pyQnEREI9UMqNtWRReXAjTbe5CBIypAhGSDFS1WkdqI21SmCIjZoFzXwkhnq0ABgx8zCkkCBbMupxkkdb5KQ2DcYQ61qL79ZoRzoJyaiPfNZCer/XwzqDMZaYYnMSDKEKWMw68FeDSIgBbx3tVokRS8hqC5BixIhpCumR/z97/x1vWXbV96LfMedcYccTKndX56gWrVYWSIBAIhqRhQ34go3hgu/F12Bf+/P83nME53QxxjbY4Gsbw8OAMPBAJAkJCQVAqHNO6q6uXHXCTivMdP+Y65wKXaUuSS1QS3tIfeqcvddae+0V5m+ONX7j98tzg3PJtx5Jvi9RFFopbNugTCJKBG3QWZLhCT5ZWgQPJtAVzjvVDRIJ4ZONGDuWIJxjDl40iTgnU3P5yVuI8YJ1z8mmnfuc81+/1H5csN4VsPyulEl6QTIXEj4EXMdcV2AiwVte+5q72LOnx2+++yN8+L4nUU1kbWXAT/zYf2FrawY6sr5/nZfdciP71ld59+9+lKqaUbeO17/6Nr7wDbdiCHzb27+cja1tbrjuWp567OcohtfwsaMP84E/eIx3/Oq7edvbvownnnkOVEHRG/C777+PJ589QlM7zpzZZNwbMFyBtjHsOzhm/941/uHf/iv8n3/rn/OOX/0gr7jzVlZGI4wSfPRsTxqeePIZijLyjW//Yn7pF9/FK195O9dfu872VuQj9z3MV335m6gnGzx95BTHT22DFdSg5P//a/+Tv37r56MkT2zNZJyQCDQI7IwnsYDo2fUhEoA0sRfkgmvEGINzNXU1oeyN0KaHEg2dnYrsJkHnjW3neZ3FXQKIXJC0J++h86+LS1+rl46Pdz195iZay/h4cX5CfrnXL3wody4ulWBf5jo494zoMyoulwwm77CQuktIybgk1h8SNcSQiIwIStEp3ahLfMInE5GN02dwQfHQg49z9sxxVvft232YtyO1cg6vd9IDgRgIrmVz4yT3PfAgQQnKB5IxTCTKORUVpXak4ZKF0LmhIkCIKElqMaDJTZaIuKKJwaNVTpaPeej+3+G2V48p87VEDM4sISaFrND5rl3Jg5jzZd/+JDrEL/n5SwxfYvgSw5fxkoslhp8fSwyHzzUMX+L3Er+X+L3E75dmLPH7/FjiN3w24/cVP2n/4z+4j7L3KIvWstovueWaG7nxla9kPN3ixJnjHB5fw7Wvvo2HNj7Ioev38a5fv5dbr2u5u7fOK9/0Kjae7uHOrnKobGn6GYt8QpCa01tTzmyeZKvZ5MCthsMrV3HV6Dbu7d8P2VluuE7z6JMf5Jabb8IW0G7W3HzX61kfD3jqyMNsnHqMabWgap5h//phVGGo9XPsz/cRJwdRs1WM0xw9tsFKY6kWR7B1ZLoNgYqmrWk04Az9cUHQPsk2x5Ysy+kP+njrCTEyLnvoXOjnefLLzjSLaovVtT6C0FpP8ELA4rYFP2+pZwuCzdmzd8Cevft59rkTtGQsphOOn6nI8x59HakWYzaaM9z33B9wp/581gZ9vFZEKdBiydX57MDI+p5DfO03/R/sOXgj9773Z2ieO0PPgPU5US1wTSSYHBMVqysjiqxmc7uiDSF1RYZUgFOidm8a6SQfgnRSwV3Ho/MOK7q74VJRFlIBKMRIlmeoPEfnObZpd2UX6rbBtzUSBKUNLjo0FsgQkjS898mXWLxCqdSJK0QKnRHynH6ZsdAZ1luqaNGqREXD6lChRTEcjDmwtkKOR2WarFhhz4E9FD0DQaF1REyBd0KMGpPnuFBBmNOendF4R+sc0Rsm8ynkBaNiTAgO74RgW7YnU+YzR9NUBL+JUxqJnpWiT69wqGKIM/t46shTKNtS5H1Obs7JmXPwkKFpp8SgGK1exarxFLnQukC7PeHM5iavueNVaLsg9EtC27CxeZZpvaBULfV8RhVB4zDiEJ1TDIaIGFrbYooC5wImJpkhXZY4UeAcWgnGtl3hMKB6lrY1KJWjck9RrCIqUFdVkjoyYHQE8WR5Tm5KXOuJPnXBupAGzEwbYoiEmBGjEJQjRAfGUFdz+mVJ9J4sE4ht6hLWCq106qwuM5xryESwbVeA1xpUALFJztulQVlMTlA50g20ShlE5WQZ9MscLamAbH3oisKKGBTGZAgtxBzprxF1pJAeY62Y+yR1nekRg8zQtHUq4HqH05voNkOixXpHLlkqYKIT2yl6nJ0TnaMoizTx9xGjk39I9AHnU0c2KLz3GJ1k3JPHtiFGCzGitaJu6kRI2bmzY8QoTWYK8sLRVhYfFM5DpvU5Oe3QsXBj6tbXJkPrVGD2PhWQE7OU5I1NRJRK5BNIxetuDBCVfMQhFYxFFKKF6CNI6mQOdH4g7IBkJHrPYj5nPB4jErHWo01OCDF1hUcgRKKQCsMhpC7xCMEGBIVRhuDShEpFwblUsN7dX5Uk7SUKgZiKxSGkon9I382FdA0RU9rpvSf4QFPXKBG0TvsSgkueKd4jSggxdYMbk6GUdOt5QoiEnWJ4aBN5J22AMjNEInXTdGy5xKoTEZx3xBjQWmGdw4eYyBTagAYJkdhY8jzHeocPgo6BEEAbEAXBWZRSOCqMKVFREaNCxODtJ59UXI6Bt/P3uUT74s84x+CLHU5calp3TrDr+et+vH35ePt6ZROfnWUu2maSOkgTV1FI1Lv3xpu/5lt4c7tJxo9z3yPPsHAN1157kI2N00wXjtX1FU6f2ub7vvuLee2r7+Idv/p+tPLcdv0+vu97v4svectb+c7vnnJwdcwjj93PieeOsXds+L/+1b/msSeeQ2nDdYeu593vvYfCFHz5l7+Rr/66P8df+xt/n9959/sYDDOm2y1PVM8QNKzvH/APf+j/5L4HPsb7P3wf3/Htb+Pv/eP/SAw1f3T3o4SoyUvNfDHnR//dT3Pk2ZOcnTqs1xx77ix/+//zN6imls9//KP85f/tb7F1/AnufuBe/uWP/gdOPXeKr/uar+b7/re/QTnqE8SRJDMUqiN9pLRcEqGms1wQOluOKCg5529/LiFQIBFjegwHxS4BJJ2PS10hcuFpiju2KzuJeTwvMZfzLiQBOZ9JfP55v/jcv1BW9WIk5Ze53pbxIsblkvCdCM9/X+iun8sl5i8U8vE/8jMwYqfEAqTk+zziWsJ/fcFXUp9EQv78MXjHHgWOHHmKA+sjAnD0yYe56Y5XQaf0YjLdPcBVCU+V3517IBCVxtrI1vaMECM+ShoCRM4ba5IFyc532knK2U3xAyLp4SCiWR+POXj4lu4BBcTgMFmP21/xRpTO8ViUBCQmq6Voa6LknDz+CCurBylX1lBRur6Fcw8GO8J/t09Xcowujp39/dRiieFLDF9i+BLDXxqxxPAriSWGf+5g+BK/l/i9xO8lfr80YonfVxJL/P7sxO8rLoznRcF0UZHToywGPHbiCM+89yQH16/iuptvYlZtsW/1VbxsX+THfuVfotxeTmxvc/d9H0KtGFQconRNRaRfBDbNFmG7YqEtfR2YVTP2xsjxeWQ8uI3bDt7E0c3A6soalE8zn47p9/bg3JRHz3yQmw/cQjk8yWSSYydnWb9as7o2psw0tT/Ck5M/4Ma9tzEeHmRFQdsIbSXkOks+xesLzm5t0lQNaEWuBBU7H2ejCE4RUfgAZdHHSGBgNCrPCEqovKMfIdpAM2/ojRWlKbFtzXQ2J5KjJEIjhHkkW+0xGGZcczjH6AG6EMQ2+GnJcLiKXZtx8mwkVwVaW0QbglcgLvnfhrhzOxBJcsdZb8SXfcW3c/0rbuMd//VfUD3+JBmRXtGj6AmL2iIhkgnk4wFFWbCxPSd2xRgAbx39skjkEtnxEki+u0qk89I1eAKN94TokODQyoNSaMnQxhCVwhjdFZBi6l7VCqfAt4Ho0vfQqiBK19UaPKIFbWLq+Iyg0Um2XEe0NphMMRgVVBONCYq8cOxdLTgw6nPNof30RyPy4ZBer5+6hXUGxnTTwSQDrnXyUljMFsynE7x3eOeSV7KOWBvA1/QLTevhxPHnmM9rmjoQYkzFdAv1rKFfDlESaJqaU9tb7N8/xpiSjePH2Tq7wdp4xMbWJlEJWgXqI2doqjm9Mueaa/ZSt3ManSO2Zq3MMWv7sSEjDlbQZU5UOVddvw/XWq6eT5mcOcX25gkmlaPtr+NCn9o6HDVaIsE3iGTkxaDrMobcA1rhXUsIDUorvAQQQ1ZEQFOWCucWBCdkJuC9QxGQEIhdx66lBgJiIi6EJIMuDk2WpDNcQGtJvvViUCgGeR8VwBiNNwrrPCFYVNSpyEfEOUvAJ1UArRMzqfMA10qRqSxdhzGSZSV51keJQmGwNnkVBaPQmQaJCBqlSSoH3mODQDTkeYkyGdZ7nApkwyFKMrKmIUTQZY/WOnrjVbQWJmdPU/uzZBJxrafxjqADjhKPoHQG0WGiJ4oiL8pdGXrV+W5nWTe/FECyRDJRKvmDEymKDNemSYfSiqjNbmF1J5TKEKXJzE7bdir461QJTwXdnXs4dhPrCK61HeilCYYQkZ3EROtUJFaa4JMMODF53itRRO/xrlNr6KRThB1/bDk3Z5HYdXQLVVXR6w2S1Hh0uwXvGCNi0mcoEsM5+MQMSzblCh92ZNy7gjmC9Z4oqWM97n7PNOLt7IYPnuB8N2/rvKe6ZNF7lyYAwSelg51JvwRc69KhRIjBQ0f0EaUI1uF9KoSrblIQvE9e8ZKOn4QkIxNCIBB35dZBsG3yfY8ktY0QPd76VBRHOrWMxBYXoG2aJFGjNd7VqZDuBa2TLUWSswmIOJLye1LS8P5K0frycaXTg8Ro35lwRGJUu+vvvP88BnG3bREuJiBfsN0Xil2ZuIseJJxjSu9s63lrXrgnXXJ5jmUo9Ad7KbIRTzz2NO/54MNEk7F3JWO+2GY+dfRLjQRPWfZoqk1+5Ef+PYNhyV//K9+Kn29x+603M6vn/P7vv4tHHnyEpg089ND9PHv0FI8/fQZvPYN+xo/95P9gc7LJof0r/OZvf5i7XvmF3Hbztbz73UJsDIevPsCh/TlntirufPkNfPPbv49rb/wgf/Uv/wA333IY0LQt/Ief/EXObMzxIeBty+lTG7gQOLW5QZH3ObM54Wd+9hdoFluoEJltHuHQjW9k/02v4WV3fin3ffR3ecUr7mB1/XqidhCSDUCysJMLGP477PJzFLyd9+N5r507HzsPazqm3Cd0jndO3u524/nn79xJTmzX5ycT5zNHLzjnHzfOJfcXXkefaIJ9ueRvGR8/PpGHbBe/Gs+7vc85NcadnxF2Hi59cvHSOZ/P89za+bn7st69Nz7Vb/X8cV5APKC574H7+J6/+K088fRx7r77ft78ts6yJESUFiSk8UNJR3QDkodZIEaTrH9U1lm7aOieF6bJRoTus0NIkpExxt1OFpHkZ5aOhWCMcHDfCqJzdmxKRCISI2awiomaiObUc3ezdfIYt77uz7CxeYL/9OP/nvs+9EH+X3/vh3jZ5385Ji7wkiOSATYx4tW5h5KfbMQLxrdPLZYYvsTwJYYvMfxPJ5YY/mLEEsM/dzF8id9L/F7i9xK//3Riid8vRizx+7Mbv6+4ML4yKrj+Zddz/PETaJVx1Z6C7W3P9Te+gZVrBzz98DHuffD3uOWm69m3Z53njm3S6xuOHL2PM7/5NCtrV3Hnyz6PQWnZ3DzBna/s8egzxzh1n+HwNXtYNGfZ+NiNmLHizPaMa0aH2VPkzKo+gxXh1NZTbJ5wrA9bjmw8yWtufxsr4TSTZsz6IU8VTrC2N/LcVoO1ClMW1NETpCYb5rQeXBWJwQLQVA4JOkmJtwrKxG4QCpRJxcBo28TWismv2qvIom6oQwAHXpIEsp44qu1IltWIRFQQssIgymNrxcJvcWYeyV2JkLE+2kOvLBgdKsmvGRJ1zryucO2zjLJAIQNUVCgVEK9BB9xFN4ZIRqDBWcPhg6/kbd/6Qzz+B7/Fwx/5NdpTG5SZZqAUTdXifYMSQ55r1ldHzOqGul5gtCZJDxek4lPoJBEizjmUpOMTI0RR+OBZVFXyIhdSUVtrtFKITp2gkhmC80ka2DUE3yaoVxrIEMnTPSeBiCXGNNHSyewapQ0xtHgcyiR57NVCuOmmPoM8+bJcffgQe/etMVrbi5g+JsuJ3bnAe9p58jyu2xlGl+AtSqdu9Bg0Wvq0bQOlJ9jIdLPCGJ+keuqAa4UYFJkYTG/E2c0tFvWCTBsm0ykIOCyj8Ro20zz57BGG+Sq9cg8LV2FF0ytWyXWDtQ7rICwi9z/0MAFYH2UMS0MsB4zKfbQinDlzkuHqfvCOEGpQilAOGF59AyvX3E67mNBM5zgbmUxOMZufYGsxR+NxsUVciyYj2jwVQklFySwrqFxLFAFj0EWLaytc6NP6GUpnZJTpehWN8zYVM33A7DCHQvKUUBGyzGAwWJ9865XJkOBQStHYGUYpjCiii6n7OMYkpaRSN3VwDqWTnzRFSVZmhOAQFZIEkC/Ism7CpwxF0Sc3fcqsT8wK+sMhItA6j8pMKoY2ns3tbXwMBKAJAR+FNjjmZ7aYVy0uBvauryBZKloKgtY5vcGIPC+omgXjPQcJ7QaLaQsYVLBEUUQCWUf60EBZlhByghIyk2NrC6JRRkgFzYgP0tkfeLxPBBDVZSvG5EgMRC2Izi+YdIrssEPBR9utn6S6veuK1dEnj/GuKEwUJAS8s0lxQZJNgkQQ1QkqKZAQ8SEVsFPndSQGj6AhhK7gHAniQStUVwje6SwPRAIRow3T+YyyKIgx4p3vlPRD8tzWGrE7jMJURHadrDskQFeSEUivi1YIER+SlLj3HufTd/SdP7gSk8aUEImdL3nwYTdpDDuF/QgxSCdVJfgYaG2T5FtEEXySWtc6gTkxdJ+RuuV3fMxT17hHxKfjS5J9cd4RdQJ878O5aWBMRfsoiXWXeIQdCcF7gk5jppZIVIkYIE5htOCCIEGhvMLagNYGYsS2TUo1YhqXw6eQlJ8vn3alSciFk7ELE5HU1c/F2c2lM/HLbvPyCdFOEn6pdS9ms39COZUT0Jprr72D7/++b+T4P/p3/JXv+y5OHjvKj/7UL/LWN93JU88eo98bsHnqGF/4xtdT+IrgPb/6u/fx2+/6IH/77/4AP/Xjv8iH7n4QHx2jQcawWCe0AWMKokRmsyk6Mzz82FEefvwED/6l/431YZ8De1c5cfoMX/3WL+Tpp89w34PHyAx86MO/xWxWcWpzi4/93lECgWeePYUWnbBYJwKGi0KmcrLSgHe0IfA77/owX/z625kuLP/gh/8x/++/9085dPUt3HDTHQx7wrFjDxKiTwm5JHsHuUSi/WLEJ57gnh+XYNNevLn4/DcuNeG9VHfG5fbshaQHL7PWZXbwczUudzwuHkMusebuA56Pt91w3nMX9fy3d2J5Ol70uDgxT78HHnrkGb7+q69HFeu87wPv5a96l4iCKhHSIjtJs4fgaZoZojOM6SHimM+3OHv2bCLmxYj3rpsypAduO0S0HSxQasfWJGG+MXqXQKmIvOLOW8mMIQaIOoJoogRMLBAci/kpYlYwmx4jugmj0R62N87wzNEtfuKnfpIfvvEW9P4biVhUsGhJZEcfHCKXZ/q/sD9nvCSefaKxxPAulhi+xPCLN7nE8Bchlhj+2RpLDP/Tx/AlfnexxO8lfl+8ySV+vwixxO/P1lji958sfl9xYdzalo3Tx2mi54YD6+w7nDFsLXuu28+8fham25x0j3PT9TfzPd/1/fzS//x57vujZ7nh+sPYpiUPml55gHZkaU4f5cTJNaQpGZXH2d6aoXoKFpo7rrkLPWjZnDScnHlUnDCrjrLY1hzYcy2rV2tObW7wzvt+lYX7MGFjwQ2HX8U8Hubs9BiNFca9m+jnBSsDR9YKps6Y2gYlBZlJBeWmrrDVDBw0NjIclyQrAE/VVljrKVTGYlaTZUlGZdo2tN7RNA6JCjMcUk3mjHsjEMPmdBuUpj8Y4qMnc0nv2IVA1c6Z1wuUt/T8BJ2vcHY+w+iafeOD9JRmbWWF07NTDDef5lp9C1lWYiVgIl1H4rlQCCEovEol0Nuuu5E7bvperrrzJn735/4ZnA2YxiFSpoKXQFSRHGElK8lNpG1dkksmSaqH2HV3xoBSikwlEI879EMx1FVDdB6daXxMcuoei9E6ycIIxGjBWyS0GAlghGAVWmdESUUugsLhAI/CIJJ8BjSSusSHJavZkMGhdUKzyf5DaxSre9Blv/N4NljnkADtvMZowXqHuIhtLM28pa4z+gMh132qZs72bMpkOmM4GhN9JG45omtYTCtypRFRVIuKYjhClMIjnN3YYF63iRjhG6xv6RdDSlOiETaePU2vHLA9P8XePddQTTdYzGpG/TEuQOsDGE3jGqqFQectpzZamn6JjRPY41CznPH6XqabNYgl9AuMAVsn72PrFCorCStjykwor9rPfl4Liy2gJTiPaxwSLSHM0DjaxlI3FiRJ2jtvERyhUNTzOevjPVg3JtCioiCK1OHvI64VbOuoqRGBPDc0KhVO+8qgsynB9PASmTctMeb46DEIhlSYtdbuDs65NomGpDvZkQhGTLqmAmnwE0WW9en19qEw5GWf3nhEUNDrD8lNgUNAIm1TEWtLtWjItCKgcEBAkRUFg6KPCyF5fwi0VYOIYbppsWLp9QvyPENMTh0iznoCGTEqbAv94SGq7aMoGoJNBBCjNUVhKMsMJTmSlSjfdS4rlaS5QyodG6MwJk9SUjZ1Eeuu+1tEoUSlgV4nVYodSe6d8D4iAZzzKKMJdUcwsJ4oEVGS/Ktj8lCPAXRUneVHRFQkuK6L2afiONamLmfpcE+SFUHsvLt3usgTQAreORLUdZIqQRAxKFFsTydkeerqtrZNBegQkle71niXura7FVPROaQO+QAQPYpAVBAlpi5z6ArXlsZHRKUueu89xhgat0jJSScHH3xI4N2B9A6bjSAdszoQVQB8R/gxeOcS4SPTqYM/QnAegyYQuqK67xQTAood1nRKYlpXg9b4kJQ4FKm47kNE6LxXQpKAFyXpnotJBcGHjv+gwLkGpTWiNM51Kh2ikJjIE0opjA4dQ04ByTv+kupYn1DEc/9cZn6ww06+9LpywV/xvCXVDvv4ooT5wm0/P1G6or2+aNlLsdkv3OePtw82WQcM93Dg2lv55m/+Bu561Wt5z4mtDpc00+2KP/v2bwDf8ua3fjnv/8AH+OF//lMEDHtW+vzIf/glHvvYEVZX+lRNyy3XHeTQwXV+83dPcdst+5AgbM1qlAqUWZ/91ww5fWKKD5amrsmLgmPPbPBHH30YayseebLi+//3v8n+fStsbk/o5QWZBsQRVWJL5oUhz3NMCLz+zpu5/5FniMaQxYiYdN298q7beODJp4iugSA4HVjbfy06T1YBiX8Td4kbn0o8/8HIp5gNXXb9lABcsNyuR5qct8z5V+N58nAXbOe8zVxwLV/6evn43yle9K9w2ZvqszouPO6XX+aFt5GYyJfbRpeRy/l/76z7uXjc/3QiKbAofLXNdKtiNF5n4S2PPvoYi2rOcLgCdMQ7Euk1RsHZZFsSowejUGhmsylnzp7uyLkxeZmFHc20c+PKTjK+w1zfeW/H80wrRb/oc+01h9Cd6hAS2CG0JRz13HPPB3ns8Yc4PBjQtJ7H7/0g3/It38jXft238N73/Tbbm6d58sEHuPN1byIfjEmOa+F5CfnHS8Ivecw+gWWvYGvn/lli+BLDP4VYYvgSw1MsMfxzKZYY/qeJ4Uv8XuL3Er/TEkv8fnFiid+fS7HE708/fl9xYfzU2U1G9Sq9fQdYOXQ9z514nOGeCe/9nf+MCpqmmvOyqwccfWbKn/36P4f7S4EzR/4rNxy4mQdPPczRMw/ReyJHdEk26LFxdkovws3X3MbcTdFZzitv/VL2HR7wx899gM87cBvra4d58uwxjNvLtdetsm+P4vR8Su/UCjL/KCqbYfQBZk1DHQ2nHx6y96oBooXF2RUOrs7xw5zghvTy1C3YL9chr9ncmlDoVfSqxmMZjguCU5gCQswINtI0DcZotqcTelmGikJla5TSrK6uET1kWYYUmtp67FxjvWWxuYFThn37VkFaVBvJjFD0ekQdeG7zLE7D+uo+6mbGxtlTlIOMvNRsbs45deYU1+6/Ea0sOmmcd3LDu6cZG2uUZKmgFixoTWwVd9z0JRx59R/z8PveRe4MmREI6cJyIUITCDHQWxnhvLC9OaNe1EhZgCLdGLLjZ5P8A5QEpOvwNCojdXymIli6RyPgQSWfYGME5yziU8cjyhC1QhHxMabiljIER+qQVJ4sC/QLzaCfsb4yYO96H20iZZ4R3AG0KvBB45wiBIWg8FWFRME6x7RZMJ9VSJahzQAlJca0EByb8w1mlWe2iPg4YnMCmVEQMtoq0iv71O0c8ULWH9A0jtZ5rLc0VUBjKPMMUDhbUU9mtFjyfsVKf8T2Vo3zDWHQkOk+MdTM51NUL2Natdi2IjeGcqBp25aq9RTGUFULCrPNvvV9iBIa21AvNplt1BgFogy94ZCi7BObCiFQVYEs70FsCUWPLFshMxmDPMfZNk1YQiQPkbHOcG1L0sewOFuhSXL9YNM+RwPBYnSGztI+te2CEFqiC+SmQIgsFtsoArkqsW1DUWgaN0/+3D6HWGLdjLZtCNHjMkXb1mnABSIBbXKsiniv6JcDisEAHTWZyQlaKEbrlMP9aKVZ27MXGz1b22fxtmVeNTR16uK1sU3F1kSCom1rtMlpmxrraowx+BhQCsbDAf1eSVU5FvMG6wLbJ7YZDgeMVscgELLAoDcgSsv6VS+jmZ1ltq3IyiGzrS2kP0BMBjrJqXsbMQVdUTZgehnBOXxrycoSk5tEIqktra0p8lQoD6QubkQQpROJxEeiv1CSyIgmSsRkOXkOjaikwqBCuoe7rmYlsfPeUDi3A1Qg6lziEkIiPITQyaCEsCvXbZFUyN1RBiBt27sAkuTLg6TCOV5hVIltbQKqQmHbpL4hPhW+o0R8bAFN8LHrOPeps1pponWkKbAg0eOJiTwRAmpXkh9gRyI9SdQ3fnGBZLpANzYlifa4U+0n/a3J0n5LIu6IgI0tIoosM8ToiUScteigsL4lqJgkWwR2/VWAGM7JuaexNvmZR2W64+lRonel1WPYmTikDRid4UIgRIgRfPQIER2S1HpSpU/jrer6zwVoxZP8VRRIniY3vAha6nQTq/j8JPncZCMCOp2riybBl50073z/8176RCTbPt77LxzPT8AutVqMERcFsZYQAtfdfAffftWt/Mg/+/tU1QRlDB/6yCNYV/PoQw9w8MCIX/jpn+L3P3AfwXpuvOUQg16f2WyTb/7az+fO26/nH//r/8L6akHZL3ERbBv40jfdxYmzp6gry+ob1vn2P/9t/JN/9u957Mln+HPf9lZ+83c+zOEbDmEeeBI/rxFRtNbi2pZ+0cc6C8Fy6203cHZzk5MnJ2gFrW04fOggf/EvfhM/8Df+Kav7+oSF4fT2hPsef5Y2KF7+8mvp91YI7Zxjx+7lwKE7Wdt7I1GlSazSQgzpIcqL8ajnU07GP7FP48oSsPjCeeAlHuI8f4lLXUQXrXbe3yKX39ZnY1zYLXKp43nxw5Lz3zv/pXPnK8aLrym54OfFZ+TjPQRcxqchusO8cfokvq648ZY7mT3wAK0XnJsT4qhb7kLPzMwUqCLfVatBQ5H3yLMCLQ0dew6hI/dx4Tnd+f38BP38h7MxCqur68jOOCdJ44bdZ3iGfXv3MxxqTn3sLA/d/T5Ob1T83M/+PN/3vX+BH/yBv4Fkqxx5+F7q+Yysv4KXgFYgsXPvvOjSfeEHkue9/yJfn0sMX2L4EsOXGP6pxhLDPwdjieHP26c/aQxf4vcSv5f4vcTvTzWW+P05GEv8ft4+vdj4fcWFcfEFB67fAzrStg0nTh7HPtcQbcHqAdh/aA+ve+3bOKk2ePDo49x07S286g03o1VJ/dAUrz3bJzepZUqZ5YRqGyk0fsVRLxqu2XczRW/BHz7xexx/ruILrtuP659htLlAje+kyI7gRvcjxXHcsdeyMRPaqDg8vJ7brr2VDz75QfIskudCj5LT2xE7309uS2LIWFu5GmshRk8TZngzY8/4ECEIzgriwWgBidh5QzVz7Nk/ZtiLbFeRuFBkEilWVmkbyHKFBI9XUDVzMnrYSqgXAW2gt2Zo2wUimkwZ5hNHVU1RRlFXDhWm5MMB/dKgpY/PNO3sJHnPs7V1jBMbT3LjwVsZ5IbaOyqvLxiQMpUhREJUOJcuyqgU/SLnS97y3ezdfyf3/N7PUT3zLJCR55GiCbhMEJcKUFFFijxjMfc0fqfrW9Da4JxPHYxK7Q6FgkIr0xVxUsHex4gxqfs3yTAETGYwlHjVFcyiQknAO0dhMkQ8iohWwkjBqDdgtC6MBkNW+wfIx0LWeU4715AFwdsau5hA0Kk85IW2mVHXc5w1BJ3RekldzUNDMShx1QJXO0R65IVibTzAkyHRgAdvFINSyKJQb2zibUDlpK7+qOjlBdvbE7LSYO2C6ZlN+kawsaXsDZi2LUc3TkEYsG/vYcrBiCNHn0ZnGUE0k0mN8ZosZpRFn/lkC+Vb+v2MrckZirLH6Y0NFnXNNdqgjWFRWSRGigzENWiX0eiWcjygtg2pDKjJi4L5ZBubGbJMYbWitZGiHIO0YANWa1rAhkih+8ReD5MrFIpgWyQGjKTPDd7jgifLh2RK46NgdBqQQgyUohACEnMWbYXJAq5uGamcGBwxejKJ+BBBDBIt7WyCcgEXksx9iOlKUhoyPcAaQ2Z6aC0ECbio8RFcmLO1eZy6qmmtxdcWEYX1CidJOj6ERKoIJA/netHifIvokogwny+IMdDv9UEKKtfQisVGC5midi294FgdjYhBmC8WrA5GxDKymJ7C6JKAI19ZQ/VWMUUJknzCUQImgYEPASMRkZi60LsJYQipKFsWJZlJvcVaTOI/SSrqiqgkr23ODcMC6f6LnkwVBECZgnqxjTMBPDjxxJgKp1FSh3706boAumI3hOCShzsB631HctFYF4guveeDT9OmmDrRg0/yKyGQWAcq7r7XxBbrPGWZU1VTYhS0zpLMPglsG+dAaaKLxK6In7afurUVICp11jsf0cqgUbRdwThNhIXUcJ6AMO7KsKduce9cKkirNEkXUUnmPTWKE3Cgk3S/EiHEXbYArrV4b4kdSce5NrHbfDqXUVRXkE+fK2qHcZeIEDY6oggqemwIKK0QPMH7RBSy6SSmzn2Sl0uIIDqRnIholWTXwRFInfFpXtt1rUvszuSOokBLlIDHXTGwXzYil80b0iRnZ6GLF06/706ULjMRuShPed7206ovXuJybq5zfoJw6Yl6jBFlPA/d/Yf8zH/9ccaDHrff9QUc3j/m6eMLXv/qm9mzfy+//Cvv4+FHn+HZIz0+fM+T7D24h6//qtfz337ud/jyN9/Gf/rvP0e1OIuuGrLekPnsLD/+H38dg6cNgW/7jm/n5FMP8uzRo3zdt30/v/VrP01ZRF5x417e9OrXsX224Vd/8/3YpiEvMiQG/ubf/F/5lrd/C3ff/Rjf9Pb/BescG5sTqsbR7xuuvfogp89usnF2m3/74/8FjebA2lV83pvvYHPzJE8+/gyLepv59jr/9If/Onv3r3LVvv18xdv2srr/AHZWMV45lCwW/kQT6U8t0p6qC1+55O7Leb89f4FIPEdyP+9VdhjSz5s074xFl4qd/Qnn/b3Dtr7MKpfYo08uPl3n7oX25/KJR/KuipdY7vyE/OMMPLurycfZjfOT80u8+xK6pl8qcbH84S4ShMCpkxtU1jLo9XnLW76Un/j3/4lnn3iMO19zNaJi93BlZ14RE2scAZXIc2meo8kygxDJ8hxEM5nN0md16yqVVGNAyLJsl3TmnDu3VyJsbE159tljxOhRkkFQoBwxJiWoGAOD/pDxeJXb7voqdD1lstjmX/3ov+JXfvmXed0XvBVT9viir/9LIIkYqKJOliqS8iU5H/8uiuc/HEqTBrno/Rcllhi+xPCX0Hi3xPCLY4nhl3z3JXRNv1RiieGfgRi+xO8lfr+Exrolfl8cS/y+5LsvoWv6pRJL/P7Twe8rLoybzNAuDJLNefCjH2BlBaaNB+M5+dxpbtjzam64+VW4s7/DH/3Rz7D3uQH9FcuHPvhBbnvliHzcsj7awz33PMfiLOwZ9Tm15Wm3nqFX9CnlOeToEbyas77Pc+LsR9g/uJn7j/06V5XXIwcqCqvJ9lfInoLpsyGNhfkGV+17Jbd6xeNH38M8PEs1uYM6Gs5sBVSc4+OEXlYw7K1hwzZntk/Ry/ehskg12cSoAWSGFgdS0bSWzEN0jpMbc8RFQl3gMiGLkBeGEDy94YB2VuGqgI2Wqp2TDRTD9QENjqb2DHo5i3rCIhRkpUaCB9ey6VqkiawfGHHg4Ig8OPp5n3bh2XTPcWZrxKG1a9C6jxdHuHg4UkL0qYM2qe1KVzqKHFg7wME3fx1f8No38du//h956AO/DU6jCsvAG3wmeB9xYumvFPSHno3tLZpaE02OCZIkz1UCH+c9mdHdjCcmOZk8EmKSdJfOh0BJKhQpMYgYROd4uyB6S6E0hh6ZbhkOc+YzR172GAwLVgYHyAea3upeyuEa3jf4xVnqxSZt3eIqj0460SgFBMts1pJnJXmuUJnBicNLJJcxROGJJx6FWNArBuQDKIqSpg30xj3qpmI636IoVxjIGCeCrKyTxZi6733DymDIbDqnt28Pi/kMr3LKPXvQlafEsz2Z0B8MyYIlkyFFv8/m9oT5omLYK5EYWWxucGBlLzZTbG9vkuUZOisRNEU+AN8w6I8JMeP4ybPs2buPg3uvoqonxNig8gBKaN2c9mxLVq7QRou1E1aHBh88vWwF7yK2rmndgrptyPM+1WKS/CHyEkUGPYuvLN7nVNESfIt1FpNlhAX0ypLFYoYIKGNoGk+WGXxoaWzAZD3KXoFSkbad07bJo9uHSFEMIEKZZ8mj3PSwvoJyjFIe4y3OakyW42xDryioqxn9okc1rYguMJtNqG3AE5E8Y76xgdEK0TnVdAE6kUACyec52FSwdSFdn8EGbGi7IrBDYkS0wvkF29M5SGQ0GrK+PmJzexvnHL2yoMgLjMmZLWpmVcX62iqHrns5s/FB6ukpTpx4grat6BU5ZZ5IIkqByRQeyPIcUQpnkwe4MQqNQiR5e2hlkp91pCtEw45bd/LUzgjhvHt7p3tYKaL2uFhjY0PTzpHWo4Lg8BdMGbXSBBshJgnvdJdGgnedh7igSRLpJs9wwXfS7x5nHUon0IohorROkuMds1UkyXz74Agkhlkzt+wUrW0M+BiRkLrAbQj4YFGikyy5St9zB5gUEbrPtz6iVEBiKlKjIrgdJ+1U9NZasL5FlCTamQckjXtGJ590QeFi8u5WSuGCQ6vkRx58uo5FaWJI6hJR4i7Qp2E1ifFHVPr+ISChU71Ie9yNrYKXtH8huG4SrtK1FiJGRbykrnitFdF1jD3SEB2UIviA1uC9R2tFQKdJbUye6TtWFqmoLviQuvqdt1j/IhTGCbvH9uIU+oUnDhdOrC+efj9/6R0PrQsn7OdPbM7/zIvZ8x+PgXrB5KebLCmSRUdQASHiJVlzECAEiyiN94rVlRGLasGHP3Qf//0dv8Fr77qdH/yrP8Dq6pj7H32Gd77zAxw7scWRY09SuRYRQyGaaw/uZ2U95/jTD7Jy4DCtSqS+xSJy58uv57pr9nFqe8aH3vc7vPyO23nNNYe5/6O/y9XX3Mahvffz9m/+87zjF36Hs6fPcOrMjEwrjBIaG3n3b7yPa68+yMvv/AJWRgPOWMeZs5uINgwGOYuqoq0tShueO7rFV37563jd61/On/sLfx1rK37/Xb/M3vUDDPqK33vPe5nWM/7MN/2vjNf2pTFFmWTfoAxJlejT4W726YhPZC+7ZeUS102Ei7PyJDUVL0w+dq7B8/PJS21sl2F9XrIoO0n6J3tkP51n5PwvtHPvXxyBc/fo+esJSb3iosRbLrwHL/yci9+7/HeT3Yccl3vgsow/6djtWpKdM5jOUQwJo05tTFgZD7jqmmsZrq5w3eG93H/fg7zydV8KkkiQO0zylMwCUaN0YpCHGCnKAaurqxw7vU1TV/i4wzwnfW5MD7oAtAh5ZrA+qaZ475M9iwLvPDHCxuYUF0HFZJ3SPQMgEiB6BsN1VGjJgViOGBjDj/7zf4GSiFMBJYkMDNKR2UL3uC39uPxDuvOP2fPjxb+klxi+xPB0Ll4aw+USw1+cWGL4Mq48lhj+mYrhS/xe4nc6Fy+NoXKJ3y9OLPF7GVceS/z+08PvKy6M19FyZmuTYbmCtXOuu+46jh8/y8bZhr7Zx4mTx/kfv/YT7N+T0ytWWemtc3rlcdYGPVb3DFh5eeC+e/6QjVM166O9+NBy7cGSzWqVxcyzaC3VQrH30Cq1P8l8dop2fjWHh9fQl1Nsx22kuppVM2K0ssJ4ZchgbZ3t6kne++AvYaViOjtDaRvWckex3sfagFEW31rmTUMmivHakJW1PUzOHKVpPL1ySOtAF5btjTmxjYy0oR0Gmtjgp4ayD701YTKvUpHQDhADp7Y3WRuM0VlAaRiaHkopbO1og6MwJfP5jKJUWLFsTaZkaPaPh+SiaduGre1Af5Azj3NEHGUJ116zl9Goj3OWxuWgDEY0F4hYxMS+UjGBg4jQOkemhSwmP+KyP+YrvuGvsPf6W7nnt3+e9rkjaGOQoFAmIk6hlCNISVRrnD21RV030Fp6gz42OKJ0bA8gRL/LGLHOo02GdMWoECx0UtHagJgMjUaUJ7aRIjOsr4zZs7JCnimiCLrsU/QKTN5HmREoj7Wn0AsHYYHSmjzT6GAwWpHlGfW8hVrIS0XVtigxtB5CVMSY0fgp1faU6BSSZUy9I25rBnlgfTwAV1EYMCurZFpDcMxnM3RRMhj2aOeBerrg+PYUnRUMhyMyXVDokiZYJGvR4lB5zmRSM+oPsT4VEeumoihyRASjFdpAG2pCtFhfMSoGSACtFEJOLx+jjKYNgdo2TLcXjEcKiVDXddqma1GxTfVA7+mVPebVnHljMb2c1rZEF8lNRgg9qtoSrUvFQh+pT03oDYfUtsG2lkWMmEyR5wYkUjcVvaJHVc3RWlFXc5TTtFWDKvtUzQTrDRuLbcp+yXg8YD7fpt8b09YtyiS5J6Mzai+ICrRuQfSR2dYEIw5nA3nZY7KYo43gbMX2xgbr6/to6pqyzNieTAjB0OsVbJzeoJrOyIucRb1JYbLUzasC1npiFGzTFX4RggiLWUXAUfZH1E2NkghiKHsDirJAlNC2ngVJ3r8sC+qqJljPysoag+GQ6WTCbDEnH6xgxvswribLBmidpK8lRCSGVBT1niiagOr8x0tMqbvCZirWa63QGpRORV0fAoImRvA+ECUS8RDDBWNt7IrWEgWNQXuhmrdIbJEIXjp5+pC8j4ie6BKhIZKKxjGE3a5xUYoQIxqFsm0COyI+sttxr0hFZFE67U/0BAUiBkTTNi1lL2dhpx34JHD1wSOiEUw6JjHivAelCC4gWhNi2CXZJH32VIy3PqBNhrM2fSfp5roxJlWDKF3XdkjTxQgqJt/z2E2MJWqCD2mc0hpiJ82uBNtassyg2pYQYjoH0ScykYCITt8lekJsQTSRdKxEBO988ixPiJy6z3dQdldKBoxSJK10cJIoTFl3zNMZjgnsJRGI0nlJ+7iTDrQ+YJ1D6wxCkmh3EawPRJ+80P0nIAVzuTg3sXj+VOGcpNq5RPpCqZxuzYuS9wum6+cxfxNjMV605EXrforfSSJE0aAE5x26Y0rakMgnzz3xRwzHBxnuOUghJU0zZTqf8NCDR7jm0F5OTuf0csO//r/+Fd/4trdyz90Pk2dC2evzf/zlL+WnfvpXqBczFl7zdV/3hbz3A3/Mf/lP/55vfPuf53fe+fOcOHWW33zPR7nr867htXfdwYNPPs0DjxwlzzLe+MYv5ND+Hmv7DvKK26/mVa99E7/3B0/yi+98P0qnazZEDx5+/V0f5tEnnuGVr7qdybTBe4cmx2SRumnxTbpn9h9c4fZbruGO269hz9qY6dZZDl/3eXzt278PN5tx/NjD/Nnv/Cv8k3/w13jo/j/mi7787YTg6Wcl6eGFh2gS0eQFJpkvlbi8z935y8ALTY8vTi0vu/wF24rn/RbPW+OTyS539uBy5+Xi9y5/L19625f/+8J7VV20zM6NH88tjOJChvr5+3A+nslF/14qlpn4Z2qInJPETPMGEo62Nd/1nd/GnoNXEWPku77re/jZ//HzfPXXfwvr6/vRRu+O7RESYS9IUtIBJCrqasHW9hYRsNbiUF1Cnq7zhJU7uBMTEY7YzZfSMkolAqJznscfewrvLGQFEPARjED0ChCGq2ukB0wGcORZj9tf80X4Tj1nBx0FdgltiZD3iY+Tu1i5exxfvGt8ieFLDF9i+KVjieFLDF/GhbHE8M8sDF/i9xK/l/h96Vji9xK/l3FhLPH7Tx6/r7xjvBgwWlmjyEuilDx9ZIrzgVndctWBw2xXc+69+0O85Q2v5/Yb7yIMt/DTs7zpC99MmY/o9yo+lr+bZsUxWBHWVzSvetMav/LLR9k4Cgdet0rUjmePVaz3h8RSU0RDdANUb8po7SzD6mVcW+5lvvYIiyOv58Y9X8hT2xaxM3rjnPHeBhcMw15LMwMkw8YK5xxro1WyzFPXC0pgZTTEjxWLRc2e3hAxc3qFJTjN+nqP2i9wLWwphRkIQRqKosQ3LVvH5klq2DvGskI2NijT0MwrCl2gfCQ2LT43yXfb9FHM6BVCz2h6RUZeCD73TF3LpOoxLoSgHG2M7MmGDPIMoyOl9oSg8P5CKRO1wzgTDUhicYgQJCb5Za2wNtAPQ9706q/mwFW38IHf+M9sPvQR9BwCBlMU6NjSREtRKtb3jplOK5raUS1qev0ewUeMksT6iEnmJ3U6JkZI8vdNHsoET/QeFQKmpzDa4HG4COP+iPW1VYpBROeGLMu7dQRrZ4irITiCneNqS8xAiUJnGbkyWN/QuAqdG3wLxuSokCSXswy2t+dY54kEMlGUY3ACGzOLiCYvI6aweGsZFCWL+YJgIyEbMO4b7GJBXU+Z1Q3ROpTKiV5Tzeskt2MyekWfOkR8CPQHY/J8xKKeYBvLdD6lKHNGwwO0TYUxmhuvuYFqscC5BSFTkGmqWcu4KNF5jo2RfWtDpvMZ0vQ6ZQDHxsYGvX7GZGuCxFR4UyogsoHOx2RZL3lOe4tzDq0K5vOG4WiF1lXUbY0NntFgQF4Ktq5QugfB4b0leIWtJfnEG6EKaZwr8iKxg3wkOIdtAov5lBAM1WSBq3rQWCaLGjdWiHRS5noLk8GoXE8FUZVj3QJbNyDCdjNnnCuaxlH6HO9m0NTUiwk+BGZ1xcJWVDNLDAOmGxO0EeazSfKqzgpaW+NCQ9s6EMOiSudaKSE4yPIsFZqjw2hQWhN9xLY1PkYab4kxFazzwhAJNG2D9Q7T9hnkBb1+ydb2hLFWSXTEGPJyhPVVKtaKQlSWyACiKfISZ11XIw7E6CBCjIk9q7Www2AU0UgI2LYm+IBzFpMrYnSEoC5ITrTWtC5ibYPOFJk2zBaLzgte473ryCgR72u0MjgXiFoQrfDekXyyAy4EtFLE4NGiIUZCjLgYuyJvxIgiugSAvpP9jgiiE4nB2UCvyJnXbepmRqUucRFccN2ELhWSjVJJJlzA+4iIIUQHHQNM0kfiE+KhpEkkASJRAiEGvPOdRHtHHFARxKCidL7uqWifpFbOeahA53MeIkrlic0mQnQWbRTepXOIhM7fO0KM7HTwK60JkKSukNTZHpPcfQwRTSf5pARIBe5uvkAISW5eOsl2TefrDgQCxNSNH2I3fvT6VNM5KqYprCd5rINHi8G5Fi9CYEc6/lzn/acau9ODmCZIO54xcH5ifvGk/fwJur7iz0nXxmXel3OyOJ/0QwdFR+hIBBkhIgHiYhNV7MX0Rpw+/hi/8Ws/x/79B3nZK17Dv/03/5iPPvg0rrF891/8Bt78Ja/kR//df+cn//Ov8tyJLUbDHme3tnn62DFyU/LlX3Yb11x/FW/74i/muWNHOHryND/6b/4FvmpY3buHyWzO7//ho/zyr3+UKMLe9TFvfONr+Of/4kd5/ImzvOyOa7juunV+5N/8CP+/d7yb1tes9MZY29DWFq01TkWeeOYoJ05uMxhktK1BG52YnkTaJrKyYjiwb8hf+o5v55qr1jlwze383vt/lf37b8D0cqZbzzFcXUWVe3j1a19H0e9j3RyjBwjqgvMQX2Jybp9YfOrf64q8+XYeXO3o+URJ4+bHXfXiCX5a+Pz7K+X8l9rI5ZKDTzRpuMy9HWO3Ozv6RGn0Skn6ucFupwfl/P2/dFxJQr6Mz+zocDWe8xNTWqPqLV75ytcQEJTAl37F1/ChD36IPCugG9cv8K6MQpSUTEvUCIFjR5/i6LGTOLI0HyB2o12KEAJaJ6sR35HhlEp2Kjs2Kt4nsm4UeOCRp5hun6Y/WAEiWhKuKR07Rasi7Qo73mvpmlZKdapX/nnf/lJSoFe2zKf3gecSw5cYvsTwF9jCEsNZYvgylhj+mYfhS/xe4vcSv19gC0v8Zonfy1ji9588fl9xYZxW2Dp5GhEYjcdU1Yy8gOgmODsFcppY85FHHmTl+j2cPnWW489AO3iS21/2JRT5Cq+4dQ/375nQPt4jX51w972bSDjIG15bcOguxQNPbTE/AXZcMBptUzcbHLf3IP293Dh4NfPZ9dTHe9w8CtiDOWeqD+CUJfM9rh5cQxEn5Nn1+GpBb93QuprW5Vx14Hr2HdxHK3OOHP8Yk2rGvvV1VBkYr+V4V+PqwOFrr4IYmC8s68MhK2sjJldtcXR2hscf3SbfVATtmGx6ekGT64zGTBEcqpehfUZTBWaLBYu2Zr0HvVHGfD6l3y8ZDYZocdjWIarAGGHPSAhqjjMDJvOGkycqNvuRvWstp1cWHFg9wKhcJ1Pru6dCABVSx6kHRGlUAKMVuURKrYjR4rNUwO6pjDsO38nNf+kfcff9H+T9v/7fmD/+NP1osE6IzMnUGIxCj/uEgeL0ybMsnCfvFegy6y6y9J/WGmXAtqlrPC+LJDu8UxgSRfCazGTs2dOjzCO5UfQLgy5ScQgXmE82cK0j4pDWAQFlMppqQZ4PiATatqHI+/hg8aHFqBzROSAUhU8+1E1LnuWUPYihZb7tcY1QDODwnjFBhLLf59SJo5SZYhFhOp2Rac3qvqvJipLazkAC/cIwJaJjZGWtT9CBauEY5CNiyGmsZTAuCV5Q0ZCPBmTFDBGdCuI6p9frQ0iSO8PRGrpcx0y2WFQN2hiapqXIx2AiZ7dmrA5XMTiaUNE0FXmvJMtzhoNIaOtUyHQtzgrtok4FOQNSr9LYGm1avHc0tgZJpAM7a7Fqp3AOtI5ITtNUxOAYDoZIDMwnM3SVkZdD6tozGPSYTbeRIFTNNkTD9sYCbyFTHruY0swbtLRUVUWeDRERikJoVYNzgbK/QsRRtw1Z0ce1nvn2ghAt7WJK9JF6saAOQmFyfFPhpy22ctSlpfENg+EK9XZNP8+pbE1tLTooVMxpWw8kKXnnLLkWjIKowDuLJI1/iCBd4mFMhlKpk1+IFFmGdQ5EcDEwX8wZ9ftkWUFsA4OyZKE8vWJIFjSSeTIloDQ6z1OncxtAhKapKDQJjEKSfFdKJwZUlyhAJAaHRE9b13jfMuit4GPnE37eve29Q0vqODa9nMYLz57cSuOGLhACPrrEItaJFWa9R0dBxzTh3iGxuBjSNE8J3ge0KLwLqI5Qozop8ARaGuscojUOi0jiJGoUWlts26au7qQDhZDkWJRSoMA6l2rGXYf4btGY1FVOlFTIBoIStNYEFzCiIIZUkM66ia5riUFQmlTM9zb5eCtDlE56PASM6qUObwJEB9J1l/tEWIgCJtOpi12ENnogkQF8cAgRJSRygqSO8h2/HiN65yICfW4KLqIJQSFRdd9dCKTtZp3Uug0O0WkCYUTjQsAjRKXQmeAEMIZAYuNJBGMS2SEi6JgBAaMEh8IHEgnjRYuYDs4l5svnM9SfH5eeYJ+fSJzzekmfs0OcOH/bO79f/Jm727soYb+U9NtOxz4i6Z5vKrbnm4zG69TNHDdvGfUH/Juf+r9prbC69jT/+Sd/kY8+/BCRlhbPu973IT78x3dz/0NPc8PV+2ij57mnN4hOeOc7/4DX3nUL3//9387WxgYf+9jD/N3/7w9TjA7yjp/5MR6470Hue/gZNicNRZGRK43kiu/51q/g5S+7nd/6nXfxnX/hm9icbfGr7/xdThzdZHtrihHNfNYi0qlfBMitJS8yPB4395giXV95VlC7iqw0tM6zuVXz737sJ/hbf+sH6S+m3HXXF9G2E4reIcqVq8nKnMX0LF/51V/P1Td8QSJ9dBPQGHcewKRr9bMzWfrEvtOL8mDiPILMFe3DRRJwu2PMefP4i7ewe/mf1w2S1rtc4nu5pOBy+9YxdTvc2FnsfNbtLlt5dzOKS8flXl/GSy12xtgLr5qIwqFNjgZiiLT1WV59162MV1YIO9eMkguu84gjCsSQ5mWPPfYQ1gvJGqVL/tOH7j6MBDosSlhrUPjWIvEcLuyQFjenFfd99I/4sqtu6uZAglYQYrJ+EZWnz4jpQVOMYTe5j6Ejw32cW/fKOqvOJeRK5NM8wi4xfInhSwxfYvi55ZcYvoyLY4nhFx6LKzhi/Mlg+BK/l/i9xO8lfp9bfonfy7g4lvh94bG4giPGp4rfV1wY9wGmkxqTCWvrBUXZY2v7BHmW43D0NHiluHrffk6feBbfi1x39av5w498gKeP/Szjq/eyb09gpWd4Rub47UDZ32Z9veBL3nIjj9rTBFlHx21sU9M2gVY8Nx/cS/SOOLmWXEdsPWD/aB/+FVvcf+9HuXn1dQyvKvEN9M31HBrdyMlwHHqBke+xvv5KRut9CtVyprYUgwLd5izqBts4nA/EkKFFsbnhGA0Ebz3TBqbVBmWmWc32sJZPOVktsFPIlabXK9A+YAaBsj9EabClxQwM5UhRuYLgArXyGDFEYL7dsG/vCtpURO+hUuQrBeujgrqdcPrMGezU4EPD5sIw3zhBduOcYGf0zJywutMxmCSdlWhEBQSP0ZCpVCAES0AwweGDYhKhJ5Brxetf81b2H76VX/vpH2b62OPUIVJIP3UTR4/OkifyeHXI5mRGVQcQhyn7iAhN0+B9kjdWSncYEVMhUKVuTFEao4VBaRgPevQHBSY3+LbCNjW2grqqMLpApI+SKahe53Vs0eUA12qcb/FRaOY12ghN3TKfbWNdJCtKegW4piJ6DVExnW2Qmz4RwevAZLrNKNSs7t3H5tYxmsWEykasj5gyp1osyBcLShQr6yOEwHQyYaAjg54wLGuqpibP8+Q9rDzjcQ+VG6wzCIK1U9b3JF9z5wsyXSaPdF9TVTUSFb1+n7I3JPjAbLrBfLLJcJhBFObTBh88OneohYKomc1bev0hWWFxsSXYBpU5lBqgvODDHC19mmpBb9AjECEIPgqtbVBZnnwfoqcNkGeGRT0n6hLRitliQdNa+v0hbRBMVeG84DG0ziWPae/ItSbTfYrSsYgtm9NNBv0VXGio6kgIwmQySUCuFCYTdKaYt0lWn2jQVYv1NSH0kKhpqhZthOliSl9nOGfJlEK0Ikhk3swZDMbJ114pCsmZ1TUqpu7kprLJ294U6E5iJDpP4yvQgTzrk2UGFwOmLLA+gksDpXMWg2BMjm9tGogzzXw2xaicGAKF0bi2oXaaQa4pRiMmDbR+jhIhUxoIxODwAYrSoE2WPDWQpKQgKpFVlEmvdCwordM5L8oco0uMMURH14F8bvjWSlAxQ4vGSI63gdo6RFTyJQ8hzcdUJNhUwM7Yka+KGK1TodvoNBmXgJKAUiCSbA10SLLrUUkndQ6IJ9MRZUB5Q1fVTtdWAIxBK0MIFqOEGDymmxQGBJMbREBHYCdhUgYfLUSNQqNFE2Mg6FS8N0Z3ahQKowyIw/vUlW50RpRAjIFMGxydJHtMr0lHAkgAqDtJr3PH25iMGLtOa6WTnLrSiAR8SAVurWLaeyVESd9XoxCSP7x1bUr6Ou92YieNryE4RwgRbQyZSp34dBPXoBJRKXiPFkWu0jlJ8u8RV7UYAS9JuQGSBL6SmMgsWlAxicZriYk0oD/5ye7FSS9dDnCphPd85vr5r++sGHdldC56b2fS3v2thN3J1osZF+6XIvgWZxe42SlOPPcQ/Zd9KU8+9xz/9l/+M1528w38wq98mNV9Y4wNHDm+idMOVyWZ/Ne+4mYmU8sf/fGTvOG1d3H77Yf5g7sf445br+X+ex7gz3/r27jh9tfx1GP3cP0tb6IY5vTLkmuuPshNNxzmuf/485SqYDDM2LaWzBR87MgRfuif/As2Ti+4p/cQDz7yNHfcdC0HVld4zwfvTwlYaIikiaYKkawY8ravfD3Hjh7nQ3c/gcojmkCZC56MEJOKyYlTZ8mU8PO/9Et8zdd+LV/4xV9PXo7wEYarVxFii5ptMxyt07gZRZYIZjvyfDv3y2dnQv4nGztST13KyhUf03ip5VJysrOd53kpCcR4bpLfmWl0pKvLjQvx3K7t7ufl4tyCz08+OmrXJ/g1l/FZEB2jGzkfGzyre1cozM6DGsWxZ5/m7JmTJBWYlPAKaXxOl1NIViQxqafE4Dh+8iTOpfwlRiHPNKF1IHRkt0R+CyFgTFKgIqbPDN2TAhHpWO0G2zoeeeBBvuzP+GQdYzIiLuGr0BHhdnCPZGVykY3Np3Cg0s94bkTYxcMX6xOWGL7E8CWGv6ixxPBlfNbHEsOv9ECln58mDF/i9xK/l/j94sYSv5fxWR9L/L7SA5V+vgj4fcWF8cGopFpAmQ3AFAQU8+mEXLfUk4xtGyn3weqhPsP1fey73mK3I2+47TbuefIeTh1rWOG13HL9q9hz64xHT/wB0+0Z+1Yt92w+wbMnM7LaQc8wGK5hNDx64gNkQ1j4OSfn93LowGHG+SFWxjfxzOA3mMSCN9z2eRxRD/DcPWBaQ6M3saYiOk9wPU6f/RibdYuLDTFoghVa11DPLUoZ2taTqZy5bZmFllmvZDjOIYu01hFbKHPhzpuv48DqlIceOcb8pKdtAmurBeUgo/GOUhVkvUi/pxjEknHsMW8atG9ZHY0RHYnRosQRW40KBpMpGu9ZzCP7VlZwBz2PTM6wqCp0ryDiOX3mLHE0Io62z58GYSR1OorRWN+CiSh6GLXDxHBEP0NlBT0riII5mtwGrtt7Nf/Ld/0QDz/++7z/XT+Lffw4OhT0M0OW9ahtzd71kn2rKzx35iyLqiJTJbnxWNcQQqQwGagseSp7h9YK7z3GKPrZkJVCMxr26I/79PKcanqUyXTGdKrIzZAYDahArgPemSTb7BqaqqU3GGHDguAis9rhfSR6C9HjXCSSUS3mnDq6zeqgoKrOENwqUWlc2TJvZxijqRZzyjznyYefoHU16+urLHxNvbCs9Mb0ByOKsmQ4yhFVM581lL0xgwEUeUCJZzwY4wlY2zKdb7Iy3EtUEPN0fdB1DYcIeVkSQyQzOSZmiPRQJpAbwdsIOme0uofesECrQFM1rBR9ord4W9HvrRAQhsMxTdNghEQ0iI5eUaLEoEzq4M2MR8UKcYYs79MQ0UYYZDmxqVLRzgVCdLjgky98syDvQZ6X1FVD5hw+GBQxMV/E49vUmRqCpwotg0FJJqkI2u/1mDUzxAkueoJErK3T4ClgRDCuxMYtCAGjB+gQ0TpSK8uimSBOMLEh1ECxxcImSShb1/TzHh5HWWjmjWc0GBKdp/UVRV7QtJ0qAZE8g7qOeOuosShRFJKxqGtMURIjBFrE5CiJyS/a+zR/cYqAwkUhWAuto3IV1rWMRiNMZmh8y5rJkLKE6JmFSO0rvILgQXTA6E5mKYJWBu89ymSp+Kq6orQlFYPFEQJoyaBQ6ZwTyLSm6YBoJ7TAvK2wTUBRExuLFiFqhfgIOjHEdJ7hW7/LJlNJ4T05z8TUyZ0rkje1JOZWjCGNRcqR6seCUqkDXdHJeUWPppM60eBVuj40ChFPEEdA0EqhRON9V/hHI8Gj6ISAtOo8yAVREYLH+UhuDMSA25n8RZBuwhli8hdPE97UIe29I2pLRGhahzEZWpt0XEmF5kjERoeKKt0nMfmRB5K0Upok6CTHLgIx+aEHlya7Jtf46IHkI25EJQ93Ukd+7DzKdycKEjrCUyQ4j3TriEpSBT74RKYhEkRQnZz6zrTaGJNkbSTZrivR6ADeW9BJ3J2YVOQjEaNAXlQWaOwYqB2iXMTavTiJf15Sf4WRVpEXYMB/8uF8zWK+xXz7DL/16z/Pffc+zJ//C0N+/33v5+ff8V5QH8B6x57VPo31zKpt9q/vox4q2mCZbTsef+YICHz43rv5s9/x5/jaP/t2pFnhj2/9nyCWycLyhjd/BxFFtFMmG8+xPh7wng98mCPHjyJ5YHtSo7WwMurzP379IyjliT5y/+NH2Lt3jeBqjp86TZpyBSIekYj3iZzhQkOvn3P1tfvg7idRGMaDjK/9ms/nV37tw0Sl6Rcj6nZGZVt+7Z0fZDTcyx2f93nsO/h5ZJkGWlTMWdl7I5E2yfAT0gVGmrjKjofQMl6U2Lmfdw7pC1/fl07I5QWWic/7XaB7KHBld5RcdsndZGv34ZrsrhM5L8m49K4t47Mwdn3F5NKnfHV9P72sSEl2gA9/5F7mizTPhNQVk1h13UYihCDQKawceeYZ/tt//8VEKpOQkL7D3yQxSZKxFEkPLrt0OoREYttJyJP9S0hzO+CxRx8H5ZGQiI7nPzhTkh5gSdx5sHzeQ7CPg087jPiPFzudWbvH74qP9KcSSwxfYvgyPtVYYvgyPhtjieHn4jMTw5f4vcTvZXyqscTvZXw2xhK/z8WfNH5fuZR6r0R5S39tTIyBulpw602HePL4s0y2t7jq4AH+8vfexrs++hTTYy2nskA4pnjlwTvYCs9y34NbzDMobh0xkj5f8pq381sf+q8M+lezUT9NPR1yaHXMRsyY1DUb2xPq2VluXV8hDzAwfc5uTDh8zdXo8TaD2R6K4QMcqZ/i2kO34m84i6n2cOe1B/i9E/exffIA0eSE2qGqjLads5hs471i/779rK3CsY1TxKiom4bZ1jZta7G9FWylMKNR8nktBqiYKk6Dgafsa+o84mzFcHWALyNtFairLfbuH2OtRZMRnKefacZ719izNqKfgZEka7xoF8zbitiU6LpkbityJcxbIUqGV5Ett0k5zVmVAYt8g+FoeN6ZjoQsFTClhUBGICKxRhcarXNsM2PTb3N8+zEKxuwZHKavDuDQGIHVlQO88Q3fwM23vJ53vONfcvre+8htQYhzBnlEsgIngevzMRubOVvTmkLlqFaIrSIONaHzwdAEJDRoWlbyAXtXIsM9q6kgWU3Z2KqYTiJCiTGRWTXFtoEiN2iZU2QZSkeado73ikUzwbZz+r0BYhTOVgTv6Q9G2FAzn2zR1IFMCVW1oMj3UawE5rUjKzXDYp3pZIr3OdOZw3lhNFhna3OGyXLG4wLrFvQHK4wHObPNU1jnGY5XqNsJ1jf4hbC2Msa6bdrYo4mewkBdnUabkqzo0cuE/npBays2thZoRlRtQ9PUKGUYr+ztim+BrAClArENjFeuwnvPcNwynU0RXxAqxWBQYoNGdIa1WzTTBq0KyBVt6+j3FIJH6UCUBePeCpP5gjwr6JeGiEMkEGKGny+IeKrZlN54jMlH2MUMHzz9QQ9nW+pqgo/JM9t6Byogyu8WOpvaYr1l1BsS1CIVjDcm9IuC4Bxta4m2617O0jYm7YTc9LDWUWYzvHfsWVmlN1int6dHU7UURU5Ese+aaymNot46S1gsaBYLarugCY5Wg9jA/Mw2416f2jtWhj0W2zWZ0VjfJE/7QjM2JT54LFDVDaPekLq15ErIusFSYiTLM3wINN7Rth5TlBDB2Ya2TtuzzrN3zx5EhIm19IwBY4iLgJYIzpH3BzS2RQRM0UerLFWko8c6hzaaKAalFT6k15UGobMLUAbnPc5GkEimzIWDeDCUZY+m9HgqnHVEnwqkmVJE50FSt3iSZUq96udIwzHJk3QdysmdJgFZDLIrNS9aCD4myW8vCUPR6XxKAq1I8s7WSgg+qVRoozCiCA5EJT925wMqxlSsDj55kYtCdwXe6ANa5Skd8Q5tAmidis/n5oBITN32Lnq0ShMDYzJ2vNrzzCCSJK5CjGiBEBxRRUyWyAk7pM8QkytKUGmyYLQmRosEQSmNjZ68GLBv/wFOHHsmfb7q4L9jG4QQMJlO42sn+Q7Jtz2EJHkkShFDSN3jOoF+pjTedky5EIl6RyYpybtESRL6SiLKKIJnl+gkpImLtRbvPMoolPdJZeRFiJ0JRirhy+5rFzLXdyYoO69dKMd24fZgd0LSyUxJ97uce+eCxP5SvmafjNeZlpxeb5VH77+bn/ipn+P0qYa773+UZ58+xWtedyehqlhZG3Ln7Ye478FnOXb8FHfecQMPPfYxQiX8wT33YUzGgQMDphstH733Ib74S97G/NQxbjx8Lc+eOM21V92JIiPYCdunnuKB+z7EE48/xnXX38oPfv/tfOzph3nX793Pxz52nC94w0289wMN25tzpBRC45hsTdnYnLJvpeSL3nATf3jPIzR1IjghAaUz3vrmV/PEk0f443sfxZDjXcsN19+MbS3zesGhfVdRNTOsFaazltFgwC/80q8xGrV8+3f8AGv7r6Xsj9OENAoqalRHpNjNsWI85zH0Ij8c+VyPF5KAutKtXDZx5txbV37uhN3M6gV2budeP/dhO792niTsSGtdtMAyXqLx/I6Eyy32fElNTaYLfPBJCVRFts6c5i1f8WdQO8osaeGOGd75/qESIS0Ezpw9wbAYMDFzQIitpXGu627qPrdDD9Vto7UdgVCp3QRa60SsdNaBGB59/ClstaAo8/Nk5CIxQOwY83RkM6VSN5VI7OYUMSn+RLV7SGJHuttVPD3/eEhEgkpKM91OS/f44NLH+MWLJYYvMXyJ4S9uLDF8GS+tWGL4SxXDl/i9xO8lfr+4scTvZby0Yonfn6n4fcWF8fHeQ5yuFsyn2+RrY1Z7K7z6da9m/shpnvmAY9/eg5Sr+zm2+Tju1NMsnvD0pOS68iBXr7+c6uoTZHqd3vAgjz75S7z15m/itXe9ldPPnGD9oAcsk80tolmhchUfO3qM/dcNaBcDhnnByw7fwNQ+wy1XTTjFh9CyzrXr65zYepLb976VV99yim3/EJlpuUlyspGnMg33Puoxtsew3EtPj2iDJxih9RY7D6kDNAa0CH1laNqKvM7YWpxKnY/rNU4ySpdz7ORpTj9n8YtIMVBsLlomZ6aAZVTm1IseQkScxdYN6/uGaBly9nRFkyl6mSEQUWXG6nrGbLvBNhMOjPez0st5busUuRi01vTyPpJ78kHGgZWrWO2PzzvZgZOLP8L7ktXiEL1snSgaFwMhCG1omIaaqp1RW0twAaen0F+nVJrapQKPIXJw9Vq++zt+iHfd8H9z92/9GmpbE5TD2QZNJJOCPXtG9HpDqmaBJeBo6asMIWCtJS9yesYwynP271unGBQE2zCbzZjPIm1wIMlPOMshSuq2bm3ySVDSELuiIUFBCNTNlKZuGAxWcHXqHLVtQ9NUEBVFESkzw2JSo33Az1Nn5mwxxwVFlhmiD8l/vDeg9ZbBcIBzgfm8QbShWSw49tyTzKoGZTLm8zP0tCeKIaqcbW8RrbBhhg0LynyMwydSja9BK5QZkanIIC8YjVYYFJbpbM5gMMASiNGgC8FgU1FRG4xJHsfb0wllocikRPX7VO2cjclZ9u8/hIsZUWuyLMli5N6gCanbVhl0pphNzlKO1lDG4ayj9RCUItclvbJExDEsDZvTOXk5oshybGxo6gaAum0JwVKYFbQxiVskyS/ZO4fJM0CwruvIdZa2dfjoKPoDqtaS6wzXWkJw9EwiVrStEIJDFSV7D12HDA7x6LFjeDVlUc0oe31aG6kfe461cY9rrrmBlbVDHHrZOtunZvQCHMgVxrdga6bTTRaTKeIX6GsygnVMZ1PWa0/jA4vZjCOnTuAEev0hW1tTJlVNlueMRgMkJnlxH8CFiCISlcGFiISAbVqstSgdKIi0TUuv7NH4gNYZ/cGYIoPp4ixWIkFAQsQYkwBIIERHXc0xRlCdB7ULGsio2wbRFTmCMQW2tajcEK2FTBHa+txAKyBlhmuFoBXBq+RLrU0CgehTUbWrsgqpMKwzjXMW6cBPiRAJ54rkkV0m2Q64pMn5DnTorsieRhlRihA8MfpkcWBTMdiTJv0xJs+R1ltEJ/n3RIz1KOmgKcTkCR7TMVMiKB3x3qYCfepLx4tP46ZKBeId2SkfPFrrDlAT+y3JxHfCRT59P20UQUV8cGgFEkKXHKaudhEBEbQWCFlHopPOBz1yauNk+l4IxOSNHmNEaY1SaX92fiKJKBBIkxGlUqd5lNgxhlPHPkpQ4TwGnCTwh7RrSPr2kLxVtNJdcT2gtXTKEwkLnHNogRc7j0p+8RfKuF3wfuy8jjiXqF/47yVX2k0aZGcb7EzrOTetf4HvcmVeMskbfj4/xfvf+xscfW6L7VnDl7z1i/je77mTm+94DesrB8hLzWS64O/87b+Di8JHH3maL3n9Tdx0+8u55fAefv+D92LykunWlCce/Rht3bI9eY7ReA937L+efFDgpAUPqhxiij5XX3WIs03J7/7Wb/GVb3ktVSs8+ugz/PFHn+Qb/8wbCb7hPe97lCMnztBWc4Iobr/lNu64/SbuffApfOuTjYsGCIxHA06d3uRL3/JaHrz3aY6fOcOTTz/HQ48/jdI50/kZXn7jIR566jTDHrz6rpuoa8ue4Sq/9as/zVd+3Xdy1bWvStYDWEQMIjvkNX3egf3EHnos46UaV3CvXlGcf+9/uj2Tl/EnFemsnifpeIlxYQcbLvahjAi90TiRxpRiPplRnTzCTbe+/ALM2O3k2GGGS6e8IpGbbrqef/iP/j4/+Nf+JluzGXmmqWznQ9btR5JvM6hO/caHcO6Bckea27kqlUr2Oc+eOMvk7Bn2HlohStxVz0nPzBLeI4ISRYiWGDTolHcoFREMkOTewu5cwKG6VFmAZOCWGO+hm4dF8Wh2vCMD56fWV4pln0wsMXyJ4cv4bI0lhi/j8rHE8Jc+hi/xe4nfy/hsjSV+L+PyscTvz1z8vuLC+LHHPoJzgZltaWZj/IED/I+f/y3cokmderVnNr0aiUNWx2vY+Wnmk5byBkU9y1hZHROCYnv6MU5NHuOXP/hfyeQwRu3h6D1rXHf1Kh/rPUc9HaBipOf2cyDvQcy467bXku2z6NrSGgj1gEFZc/PeOyjFc9bdz6i+huFwQC/s5xX7vho58IccmZ4iY8Fw3CMrc5qJRree504cZT6dEl3AS0noOl8LNLrIaBqhWdQ0XhFCy2g9J9lwZ/RLzWRe0TSak2c28HVLmRtM2cdVAWsdGQYRw2JuETclz3tsE6nLyHCokEZR2Bw1ULSFxRTCoCi4/brDtHtaJvPTnDq9zbh3gOuvW2F9pccwL86dZGBj5jmz/TT71yes91ZZKw9j9Bp1iIi3iItM7YxprRnIghP1BF3sQ+kMpwN4MORULlCYFd76xd9DWe7jfT/3H8nbgA8ZeIUpG3KJrK4MGbiM+dyymE3Zd2iFtq0xOmOtHLA+7jEeGFCKrYlnWk2J7SBJlFdJBl1EaNoM5zRoR/Ce3mBECA1tU2FUgUhg0UypFy2h9vjKk2dJpn1aVYjWHNw/YOvsBr41lL0edTXFmJwsK7BW8C5Q9nKihtYHEE0Uy3wxw3uLKE1e5MyrGUEFTAxEIj5EFn5B0evjjefZI8dwjWK80oeocf2IlC1al4jPcTGgM8H0cjJqZltPYrRhpShxdYu1NaYYQ8yxviVGTa+3gq0rtNaMByuEEMizAucbRsU6MRTgDd4G+v0RobUo5cmyQKEF51pMqQlAlvdAeSILqvkUZAWKPpGWotejaiuMMmR5i8YzWhli24x5PUPpAq1BJDKrK5DkH1EUBd56go9Udp7UEnp9+nlJFMtwNOTs5iZFT+8WW330tG2LViQP8SwwyAJXHb6ZYryfRz92lPl0wXSeCuOnN86AGGbzhvVRjyOPPYEpCmJIyglGGYZrKwxWR+zbs4doPXlRUpg9BFfjZUq5LgzHq7ReE12LfTjj6LNHcW1gMltQ2YaohLppaaoFuTH0hgOUNiyahizLyUjHuXXQWCEqx8AL7aKm1ppRv8fCpSL2sDeg0JGzi2mSUleGXtlnWtVkeUbTWBSGXCtcG7B+znw+IfhUKC7yDE/A6QUrwzWUMcSYSDlodQEgKg+L2YzoE9kBo4jYNOiHuCu5I1qIInSl/nPdzt3/Ejs1JUVK1G4mFGPsPD9SkXfXhSOm35QI3rdpXxTQyaHH6Lvi9Y5nd0jdzvhdkN/1MCGBYAhql9nlo0MIKE3al3DO4zzi0UERgqB1jnMWrVPh3gefis0xCVNJTHLr6f86dYZHj9KC+MSGU0qjJHbFaJW+m3OECFrp1OkdPd624JPVxPnkshAj1nuMpJJ4pPMgJx1/T7cPMaRjvHMOfXpfwjkwDjGSkRG6rne6/drBaumK9lEroo+7CasScDGQmUQuiOq85OpTjPP9yi6dpHUp9AUTitgRIs5PrJ/vj7a79EWTkd0k/QWSwvOZkR/voQGAC1NKvcLq6ipXXbXOt73lNXzZl309r7zzVbzn3T/LK771b6JUwfSRu9naOAOi2Lc24O/8nb/Hyv6DnD1+nOuvv53tecsNt1/Hu37tl3nHz/5rxNa0vuWbv/0H0zUbNBFPa1tGazfyUz/5M/zKuz7KV7/l1fzhHz/EH33kYQ7uG3L09BbvefeDjNd6HDt5grzI+PzXvJbRsOS3f/cPufuBJ4ghEoImkPznJSp+4VfeSwR++Bv/KmeOzzl6+ix142l15Kb9Y/7+3/trjAcF73znb3P7y2/ka77+uzj5zIOs7DnIM48/yHRynKY+QFbsRSm9O5m++FAvE/JlLGMZu5C/239w6XHhUt1FQmS05xrs7CQ+CtOzJ7njZbcyXt9LjKGTcDt/I6lpIkaHlgyPZXX1EL6tmUym6TMiXaIcLsBN6ch7xGRZonSax+TGJKurbrkoEROF6bTi4Qce4AuvurFLkne6NTquXNoRCIKoDFExJeYx4oNCokvThY7sKKIgKIJEQvfdRCRZSMVkESMxIjqD2iG5SQf301gMv/jcLDF8ieHLWMYyPsdiieEvaQxf4vcSv5exjGV8jsYSvz9j8fuKC+PNiS3y/YfI+uv42LDwlvl8CzuZc/jq63ndXV9Kb20fX/amL+P3PvS7lBPF533ZmI889QFevfZVnGkfpE/FcC3j0NpBzpw6yebpSDWPjPV+XvtVBU++Z8Ji3vCqlx3k7KbDDi2Dco1br38tZnCWM6eu4ZFnt9m7MgRzGnGOcrTBcHAS524EewtNPmUeP0LbbnH30Wcp+69g39o+KjdhLi3TpkZw9MQQjTCPgVxb8l5OKyDWMqssypTkusa6gK8tc8kw0mM0OkvjIrEBWzv6RY9CG3zdYk1NbRtahNXVEVVbEVrHyhCyPMc1AZ9rTD+nqRS9kaHHKrkoprUl2JKVwZjeEPLCMVgp6K1qZuEYxkcCO1K6ketXXpYu9FDw5KmnGRbHuHHtDnJzFVF5UJoeBzm1cTd1PeW69VsY9h+ilDtYK9fwRlP5SBtDmnRIyRe9/lsoB3v5o9/+BbafeAYZ9clNxAQheMEYRdFTGONRBDKjWCly1oaaQT9nc94yqx2RAk9GpCL3kGc5XkV83aINGImM+ivY1qZOXaXJsyz5FbcNEFBZhtKGiFDblvHqGNUGQrAgLbnJwAhNEzE6g+hZzBegM3KVPKuN1vRWCyIV08kCTYZShv6wjzYaaxTYmhgCmQmpiEkfGsfWLLJoC1AtW9NtXC0EPaUcZGhtyZQwGBnQNdOtjCLPaRYNSglKefLCYG2G8oGsLJlOp5T9VWLRp7EbaPIkKW411iuizjE6oxgJEcOgNCgUTT1HuZpgF3hJvt7GGKz3qGJMCA1F5hkMFNPpBO3B2ggZ5GWfpp4yXhmhdYYowTYB7xzOR7QqCb4FFfAxdeMuFhW5MQQCmUod0ZPFnPGgT2tbhv0Rx85ucXpri+FwwKKqEK2YTGtCFolesbIy5oarV4gq55GH7+XIc8dobUAZg29rpJ0humScCdJa5tsbOOfwVugXfchg48yUIJ61tRVGZU5WZlhvO79zxdrKKh87vsHxY2c4Mz3D/vEeHJrtrQm6V1CoPEn0K2EwGhG8o21b8lwlCfggSNQ4F2jbiDF98v6AXm9EproxNXh6maGaL+iPSnTRp6cUXgQjoCOM+iWT2ZTFfEqZC5t1xWK+wFmH0pGy1yOGyGKrom1axPTRraPsjyj7A2wIiGTnitPA6c2j2CZS9ldoFhPKXo+yLHHWdre/SizU2DHBRHAhSZkndlXCIbVb7U2e1zF2XdtdZzZC8v4myY67AFqblI6JSf4gO/ZIHRgTYifVEgjxXPE9ImjpvJN06lgPbgfUQ2Jz6R35KEX0elc+HCX41I6dCCrep32MST5cKUElxf7EKIuRiIfQdW6LJPYaEZTC7BTv8V1Hv96VNNdadTIzgmDQkhNjwItN/uadrnsiAHhCpLunwXV+KQidhzkdIKd1nHcYVOqwD3G3I120wnm7C+g7Xf0IoDuxmhgQLRilExtOQjoPMcm4hyBE9WlIqC4ion/8JPgc5xzOn3e88H7tMNYvlxS+UPJ9uSjygmAU3/j272ReT/ne//3vIlox29xGgiETQzuf8GM/8ne57vABJpMF11y9ymOPP8Af//RPsrZ3ne/9q/8AjcG6OX/xu3+Qd73rV9g6eYw3f8k3cOLog4zXD6Ekw0d44O738wvveCfv/fCDxBh58qlnuPvuCm9yDIHg4Iljz8BxhVbC133lF3PXrdfw7vd8kCCR7YUlJyCaRKLwQBEQZXjVnbfz2GNPcc+9T2ByTfAtvTLn+77323njF7yFzckJ/v4//Xe08y1a6XPj7W9CmYzx6l7mVUVT1ZS95Hu/8+Bk58gvk/FlLGMZO7ErrRY/uXFBlwY7sYhoHn3gHtb2X91lvee2vxs7ybWSHQszwCSlG5UUcWLruYCZRkLoGDvyXozEECj7Jba1RBGMSYozymgkeCKR+WLOAw88yhu/zHNZuJRIFLfLYq/rOb1yiEd1CjHgfUSUwdYLpttn2Lv/OogeQiLRCpLcXcSjYsR74Z6P/DYvf9UXUhaj9E3Ow9RPaywxfInhy1jGMj6nYonhnyUYvsTvJX4vYxnL+JyKJX5/5uL3FRfGr3vV65lVWzgaXCX0KMgO30L0lkz1ePTsMzz8P+/mq7/oK7j99bfjHisZHd7mqV/JkC8ec/MNtzOZPIs54Ng3fw3inmB1L1TNjOuHQ474ltbkHLpmlTtuu4VtOcWwyOnZjEdOvZ/9BwK1ytgzuI7oFwx4JYM1zenm3UzaE+j4DG4+wNQn2ZjUnN2MlKLZOnGSI9WCLV9jfCpg7l1f4Wy9wcZmSzSB/jBDK4U2Bt+PFFneSfVqnIvMqjmLzW1m05ZBaYgxyS8DZJK6lkWBNjnDMiM4m4pOohiNh5gMwKZCr3RsjmCp5pFga3yToQaBWNfUdU5/NOC6AznluMRFRd1scNo9RRglJoULDc8s3gtZycbcM19M6WUrnKlP08tneL1ApKRVFf3yWkL7LK1vOLb9LHUxJ6rXsN7bz0gFmqDZqqZoqRnkK7zxrq9iz9r1vP/9P8mZj95DXRlERfq6R5FnxM5vOFfCYDCgLAZUNjLbdlivsEHj2oosCr1+jhONb+do30kTa0GUxrYe6bqUrWv+H/b+PNiyLDvvw357OsMd3pz5cq6szKqusecJ6AbYjUZjaBAgQQRNUqZgyzZFiwoyJAfpCNJhBcP2H5YdYkimTCpCdlgkTZkWTcgAaQIiQYKYG91Aoeeq6hpzznzzu+M5Z4/+Y9+XlVld1V0ASKIbuF/Ei/feHc49wz37W3uvb30LoiO4jhgcplAkURKdByGoez1CDMQQcM4yTRLvHEJ4rI8gJb7NtgykjpgcMUaOu0RV9lgdFFSmJKbcW1iJQNfM8AGIjuRnEAuUKTlqJpiij20c/arC+YSQNRiIXhNdzJWnWhGOLEZ5LGMGvVWMErTthLbtcF5QrazQtQ1aVggEbRoR0wwtFN20I1pIITKZBEw9oN/XJDRFtUpKBZ31yEKjTIkyCd9O6dUDmsmM/qBP6MVscZ0cyQeG/YK2m+OSQUWLFoKkc/XsvGkYDBVVXeBDQRcTRENhFHPb4FxgNp8hlaLtXO6TrAu6doJLgtmkI8hEKmFtMODo6BCnFIVSNI1DRo0Pkl4ZuLTZo1convvS19if7dKrFcE5xkcdjYVBXdHMLSl5xp3HOkuvKiEmmuYIVRXURY2pKybzCSUVIkpImqm3+CC5t3vI9VvXuHt3n8571jbXuXz5Ck2I1M5juxYfPZvVJiF6tC7omgaBzVXiXUMIiySsEigtMGVBKAw9Y6iMBBWpS0M3DxzPpqz0KkpVYkNAF7lqOCVJoUr6mwOyY3lgbdWDCyghEErTuo6unLNRaLRURJEIdsp82iJ1TVJvDMPBB/x8Rn/9HMEGnGsxpkaIihgDMVmkUogoiCRIYtGPI6GyVwkhRU76bKSF1buQYmGBDtkuPRFDrnoWSiCVyQnedKLKSjnxzcIyJQQQEoHM9eEyJ4URi5S+OCFcQUgxj58i5WprkRb2JorgyXYqKSezY8ruBCwS0AiZ7afybueK9ZTy/1Lhos9qsdysO/Peibotxvy/ECQJMQSEhPs2VkJAhCQibtFDXQBaqMU2Ut6GlLnftxKImBP0Mj2gtgaUUIhF9b6Qi77hSLwCxWLfhcj9xwnZSl4K4CQxfiJCeKMX2EkrISEE8cQGX2TlX0iBEE9sd353eLhHTbqvEszqOnhzFPPW/cYW9jn3H3pjkn7ynrcKQk7Ox8m0/u327Z0+fv/5KIhS0l89x1OPP4EuhgilqXotn/jUjyF1zRe/9kus9Ib8tb/6V/k//Cf/Cddu7rJ/b5crT1zlk5/6CZSukARK3Uf1zvHe7/okr73wWV58+UtcOH2WZnpEf+0MN77+ZXCa/b07DPsVR8dz7u41GJ3YubVDkhpFwJSaUlf0ewU3Xr/H9ddv8NrrN1Fak2Jic3WN/cPD7PYQEt5HVlcHnFnfpAsdjo5aGlxIpC5yMJoRlCbZiKo2qYt19OyA2ze/SrBzzlx6hq3NCyAKUpIk4bMjwptXXJZYYoklFrhva/Y7RUpIHMeHe5SnW5q24Zn3fhSx6J2YX/IADwjxxuNk+zOBwhQaEGhtgG7BRyeTcIgxYa3D1G+4ZRVFQYzZmStbu6Xc4iUEkBLbWb741S/TzCb0BwOkXKjHeWMROSUBIhGAbtbxL/75P+GHfugnKHvZoQwCWkoEgvHkiF/4F/+YP/nv/CVSEmhTLuKKk6otnV1tuo5/8Uv/lHNXn+LUqX7uyfZAJdfvdtH5G0/9ksOXHL7EEkssseTw7zQOX/L3kr+XWGKJJWDJ39+u/P2OE+Pr22dYlae5deOrTMYNtie4ePYRprMRO3u73Ll1lyQjL5y7gVuD1179OufXzrG6+SitLyh7W4z2bvCVz21zafsiUd3ivWc+yFjv88TZbX7z+i2e3RJcfWafjz75Pl6e/zSXh89yPJJ8+bVbRNVno36C1f4Fbs1epm33iFJgu5peb5tx+wLHXcPjK49i1ICXX32V5lDhJhOq1YTsR3Rs2Fg5RVCWWHnKWjMclJw+VdFGh+wrfIyMdhtsF5FBgwIbA8Q2V31KTQgRpTRFZajLgrIuqMqCrgv0TEXRK2jmc6QQOCcYDmoClqIMlFVN2cu9tsfziAoLL/wkkfWENhxxqrdFf8WihGLAedygpI2HD3CrZP/Ycexus3PQsmk2OJAjQiupdIOrbtLFCUacog0t45lFyLsM6m12mms0ruO7Lv4xSqEQemGdnFpidPiwxqUzF/nxP/GX+aX1v8Xzv/g5ipFCDPr06pKrpw1nVw0rgzW0qbBR0gZLihGtBL2iICqJ0SW6UPj5HEJCKIUpDLowhORJMdDO50gEhdJ0XuCCxyhJZy1GaUKQKA1NaxECVvp9rIRAJEooy5qeCbjO0czmSKkQBDrvkVJjtCCJnEz3MRGSwqiC+dzhfYcNgUJECqFJUdC4SNR9pjNLURS4CFBjlKGUAqfBe0eMicLU1IXEuxnOaiazOYq4sIgwaCWZTKYUpabQjuQVB3sT6kJSFz08isGgJrg5MSaCb/BNRJk+B/d2qaoaXfRQRiPafbqoKbRCBI9Wifn0GFNKnO0YzTpKM8SUiaIIBCtwIeJnFiMlPkSKsodUGmvHFEXuCy50tv3WStM5h3UWI0qC9/k4RIlz2R7b4fHeM+8OqPt9irbEi1x9LgqNsJrVosf502v0+gV7RxOK3pBLGyu5mr/fslcccjxuCTHRhIauc9i2pWnmdGOB8x4fHUoqlCmQpsAUJa8DpEBMCZ8CzgXmc8ve4RHWQa8sULrg9Zu3EEKyPuxD7NCypps1mRRMRGlB23WLgTnQdR3eB0xRMFjtIVUg+Q7dqxEmYYzERs/2mQ1GRweM51N6/ZqiFMQYQCS0LKBUedAN+fvBwvpbmhJPQhnDWr2OFLnaWsrcS8n6MaGdYEOuTj4ZvFdPncfZgPVz0CUytqRkclV2iviQkFHn9KpwiMR9NZgLYWFVDkIoRMjJYKdycjcJgVr0GJEy2zw555FKLcgqk4e3Hm1yf+8YQRYK4bIVOUoipcQDIgmMkiTvESnh1aISXCaSiOgoSCISUoKQJ4EiJZAJgV+8v8DGkBPqueQcQUDIbJuu0EQBKUbQiiCy5E2ist14AElERgFKkqQmhQ6hFv1JRMhDZ87tIxBIEUioxSQGRNIUyeGTIkWLSAKnEoVMEBPeRqTSCJFygtpIpBJ5bIsy77sUKKEJwSIFhJQQAYSIBBFx1pO0QUWBSuBDhBSJKkcMwuaK+iAjIorcnz0EUvJZjKDeZI/ze0TWAqSFcpFFJf79Z/nGydyDSvX8txDfuE9vPZl/4/Fvplp/8+u/peUbBkFC6pLVlXWCnaHrIVVvk6q/QTvd4Wf+X3+b7/7eT7N9+jw/+iOf4O/8g5/i1z77ef79/8VPcuHK06SkiT4CHtce8+i5pxCd4nOf+1me/fCPMh6/TntrF2lbNrcqPvMD38vBP/gX3Ly9T9c0TIIFIkSH6Q1xbk5dF2gj+PyXvoLPESZaarQUSBXvi1t8DLznsUe5+tgmRrb883/6OUxhCCEQgmCgNV/47c9x9/YP89TTH8NNb1ENzxEKSUwtq+uPIJQg4ijrATHluIEgSNnSgIf6my2xxBJLLPCtJotvfu7k/1e++hL/8p/8NP/Lv/pRPvHpH8CsnAIiQqi3fy95IisWLWH2du/iY8R1HcYYuoXY+P77FkN/WZaEEDixpTTG0LYtwS3EekKgVe5vlgT82mc/zwtf/TIf+q6PZ0cdHuabzHYGksXZlhe+/AU+8P4PsbqxjkqC4DtSipiiYHy0w+2bN/nv/v7/hU984pNUVU1wlsn0iIP9HU6f2mQ6a0mASiXddII+FVlIA/+NY8nhSw5fYokl/vBiyeHfuRy+5O8lfy+xxBJ/eLHk728//n7HifFqeEQ73+Lyo+9nv95B+sTB6IC7t79Et9dgD+7x5Hu/l+e/eoNyY5/9yS5njq6A7jMOJYc39ymqdVbrRGCX8XyfQe8p3OZL/NbNl7h4/jyrgyd45OqEm/ZV9vcFj8SP8vjpdT77+n/GZPRupF3n2N5k1IxRrqXs3aVUCTuu8KnktJ6QuM7Z0+f5gY89wcsvCV6+dpPj6ZiiqVDSoNnD9EpWtoZ4P8fbQAhVTkg0kd7QUJyK3L12RPQldaVITWJ/4rLV99yysrpG2S9AWjY2+1R1jSpzBWRoA4Uq6PfheDxn0s2JByV9USFLSTgtGY86BtpglMQoQdULmGEi+siwEojBhI41lKoYh12cPWalWEHcD4gCr+89z/6xZ7Lf8Fq4yyPn13n32fdwbeeI/e4uvUKwsuY4XW4zKaa4UNN2nrvzA64fjbm4epet/lmMUlTCE2RBUo6QDFM/5V73KvLCGlc/9V1MvnSTjXnkqaun2T57FbV6iVgUWJ+IAkxVEGyLUgIlFVobcg/dRF1XVFUPZ122XUgJScSGDu89hIRWi0pKIYghEWwALSnKEmdb2s5hCoOPHlKkaTu0KnICzwecc1S1QSBQQtCGluADRpa0jaWdOxKaJCVGt2iZUFJhhKHQYHROIjoHVVkjZIk2CrWwnZZSkGKkFJKSkhgjKcF03iKlpA2e5BIaMCJhdE4yyuAZ7R+hez2ik0ycJXQCX7QEYRhPjilMQVn2aaYObz1JtiQ8VVkgZGLeNlSpBTVgfVghQgAiwbesrtbMm4DWfTprkVogi4Jev6K1ntm8oxwM8SGRgmc+tajKEEJiqAvazoHRTGcTYvAURUnXObQytE1LYQR1r2Y2GRN9QJeGrrFUpgcIvE/Ugz5t6wgx4qVg3jZEP6XevMhjZ/rsHR3QThtkgqLuUzlF1zl6vRqpJFoLjBJ0XYeUIF12VEjBE7zHzWekkO7ba7RdRxKKZt7RK0r6tWYwGFJVJck60IbZrKUuFa3t0E2DEhLbNdS9mq5rKIoaKQTeO5wPBCHwIdDTPVIIHB3tUZUGNazRlcLHjjNnL3Dzxj28LwnRURiNlBCCx4dA0zUYWQGRXq/OSfeQLepzqbEg5mw183aC6Gn6agMlFM7mqn4gW3ijsu14MpSxIIgxIcwQOhFdiVQJoSKSBEEtiE7jo0UpQ8QhhMBHT9Q5YVwkgVbqfjOGNkkKCTFl+3+FREqN9y4n8I0muASyQMo8qcg2JxIRgJCrpn0MhCARFMgYwGXL9g6Q+sSGReGCJSaPkgXO5p7iUkVi0ogYkYt7qlOeGKZoWSB89rSPIhIDdN5SSU2KPleiS00XIwqNj7laXhMJbYNSBkQeK6VIiKjRusc8zRBoCqURMSGlIQWLNiaPQbKgkCXJB+x0sqgAl2ilstIuJqRaCBkSyJQ/VyAI0WODQyRFQLBVV5zfHOILj0w9VFLUZYGWkZQCqjRI6VCyBJ8o9UIJrmuGSpEUJDxFmW3qEeZ3TfRvjTeCpuwhcJ9hHn7VW06OT2zx31oR/VAQJN6YyH+rmvc3B4lv1zvtjQdDnnJqeOypD+fvZxLZhSFa2vmcRy9f5pkPfBz6a3ziR/8M3/2pP8oXnvsNLj/5AaI0aA9ae3Zvv0xQgkL3uPz4U5w+v4koJIPVRxDRMdy4xOrRPWZzz7PvvYbWgvk88vrdW/hYgPM084ZKw2g0yW4NKaLTQqkiEzE6RsdzTm2scfPOPkJI1tYL/qO/9B/Q2ZbXr+3x4vU7kEBLw9PveoS/8pf+HI+96/2EFLBtQ2SXXv8sTzzzw/gUsyIzBsCgFEDMbgrid6lGXWKJJf7Q4K16mL3da06wduoMh4eH2G6GLnoIoZCLSfFbvTctrNwS8T5lGJ1byIQQAHl/cXixMwtxX46ZQgxorbJTXMrOLsF7lM4th0LK7jcQuHXzDq+8/Dwf+e5PLHqUvWmnBJAcWgqKIvL9P/gj9Hqa4C2JxNHRDlVdoc0mK+tb/PGf+Hf4m//F/5kPfuhjrKycRpaJJBRVtcHp05fwMaJ05Nl3/wARTzhx6/nXUCH+rbHk8CWHL7HEEn+YseTw71QOX/L3kr+XWGKJP8xY8ve3F3+/48S46l3j+V/9TZQXXHryo8yc5eDrX2Y+cyjZp64rNlb7ROd5/MJVZrMpLnYcjSdstZLZZEK8OeYjP/B9jNfvst9JukZgJonTqUKd+wIvvHAKs3KF546f57Hm/TznfgV3PCOoEUYantx4N189/mXm7evMwiMkZ9iu+xTDXWimlKZHWUhcM+fU8IOsfWCLx55UHM1fp2uPeP55xfRgG7opKRXETiJ9ZNzMcXaOTiXRSpCRKDTBRFobmY7n9OshqxWEzjFc72MqjZQ9hAIrLSoIpFdUdUUMjhQjqys9ijCg1iWqSqxtGtbWA1qt4AJMuzFSlITkKVMiyYgWhubIYtYNyjgOZzeRqQJrYZgvslaKM+uKg8kRtVQUEoZilYndY6J2uXH7FviK7Y2O6knN1saAl27sUEhPX6xxlGZc2/1tVs59N1PlOHS3SGqXDbFOieHe9GVuHt1mfixZNVu8+8On2Ux9emuXUOWA3IkgIFLIRYxBInVC62xJU+gCpbOVMTLb0UutCSninaNtp8TocnKLSGcDbdvk6lAhENKA1ERy7+Gy7gER6xeKFaVzBaqHFBWFKbDO5urKmCiUAamwbb5pEQbnImVpEPiFwsVQlhqtIJ1U4UpN8rmKM3hISiNiwPQrCqOJAQSB4AJtawlCglIQAwlJVDCzXbYXb1u00lTDTWZtiwyKfjFgxZQEmZNnLiRaF5i0B+iipCiK3CtaRFhUtxtpiKoHweG9w9qAUIoiluwfRkICUwRSdEQZMdGStERGQW0UiYApDLPpnM539NY28DHhXUQkQdfOMVrggyCmRK/u4V1ESYN1lugtIUUiMJ/kau/JeIr3OVEplCGGREown0yYyYKVs9ucunSF8b07GB/ppMG5REQipEBpSa1qhPQYU6G1oq5rOtsRgiOGiPce77Od9MkoFWLCFAVJCGKISFXQ6w9QxuC9RZJOao1x5GRl6zwK8K4FkXCdRWNwMSG0IkmBKQzNfEYhK+apZXVYEp2k7QJKdGiZLa/7/SGzpqPXK4GW5BwhZdtuUxXZWUCVSCOIQkAQiJh7gM+aGdbOEMKD0IQoGK4OkKUhaU16YFKjtc6uB0YjQqLxChMjQgq0FjgBUSlKqZAeklKE1FGIPkkB0SAISL2wFk8akSQqkL+vEvpYtFQIUSCDzFbpBKSqSBKSAJkKQJCSoyyzGkwIiVwIUJCAzPbqSQq0lOiixLYNtZYkkYhSIZJAyISSeYKSkkaqBCISKEAlChlQlCSjUEJmW/gUc1V2EkhRII3G+w5jBD44BPm1iUT0ghhjVuoScjI9JSRZ1CJFwvkOIQUxFUgtcyV7FGhpsDGQugbr5sioaJrAbz3fUBgJKT40uZHpJGYQKCmz5bxIkKAXFKiaLlj66xVPfOhZKimJUSFKkDGilYEYKbQgKtApq/hUJTFFiRAGGzU2gtSGFCKClMemf93IdgM8qEJ/q6DsjcdPFOsnPwtbHvE7U0R/4/be/PjbBzUPTtyzVU5+fO305ZOtQJQ43xJTx0e/62NcvvQkQpSUpk9va41PfvocKVpkSjmQFBUrpx8leod1DaDo1adBKEzpQKyRZMDaMZeffj9/+V3v5R/83/5L/tkvf4FKlVgZaGJLEpEuaKxt0Vovjm3RuydpKm0Yrg4pTbYpEgiu3d5h4+x5vvhbn8fFDmRCCYOQgtv7u/zdv/dTfOZwxPd+/5/AlGsUZb5/YspCNABpTD4n6eRapresN1hiiSWWeDs8NLYK8RAX3K82SnDq7AXe/55nuXvjGhcffzpz5Ns0FEsnY9JCJJhibj/S6w2JcSGETG+akPNGbzNE5hitS1ISeO/RWhN8JMWIMiIPr0KgvKSqFOvrG9lqLb7VgoNYiNygqjf58Hd/6v5rohCsbl4iBk/wDl0Jyt4mGxtrmGKIKnsoETnV3yRqUEGjTqI3kZCo+xwWYyQr+CUp/RtcZF9y+JLDl1hiiSVYcvh3HIcv+XvJ30ssscQSLPn724G/33FifP92n2LlNrM7U+bHDaxqrJ2jy5pB0efj3/8jnHqij9sJ/NBnPsBL9gu8+pvX2Dh9lZV+xfb2U3z+1z/Lr37+t/jAez/OJ574MbzYYdBb4cLqZ/Diy3T9F1iTidnkNeqV91L1E6/ebfjE4z8JPnFx81H09m9zo/sycfe9nCn+GMfi57g5OqJpz7Cihuzf7djTNxHFT2PSCiGtsKoe48r2IwzXv8bXnjvgYL/GdR7XNSgxwLUdaZHwKYIhGkV/o4cPR8wnAVkoahUxKmHbEus9oU0YEymEJPmETQmZSnToMCbR2kRSgTNXPXa2Q1+d59Jja6yeEtRpA8OAxk+5t3eTrp3S2IRQDt8len1BYTxdGFFXhslkxO70DuFMvhYCxXc9+gms+3le68asVqvs2x1GRzBvHdLD3u6Edq+k7V6mv10gLPg2cXpji9CWhNSy559n1s2RrkMqz0G7y2a/Txkayrblid45Lug1VooeMSm8THTJI0LuYVwUmhADKYCQhhRDDkTyPYIn4q3D+1w1mvsC5ERSjDEHDVLgnM+2wymQksQUFQiF95HBcI2ma/DBgdAgPEIGgg8E74k+YpSgMAUuukWfg4IQE0FCEhoSFCUoKTC6h0wJ7x2tc8gInbWIpCD5bHWtFMlHnLOUVUFwgcYHirJGK5kT9FIhjaaxXU7ix4htsqU8IuA9KC2JSWCTQCFIHvbmU6RO9AcDql5JQtC1jhgSMXqMyknEztqcQK4rkhDIMIMQkEbhQqBfVljbopSiCx6RCuzEUxWRpGdoIanrGtvOcQGCg7nrCMcTWp8r5pWUJCUpdY+YJNZ5IgkfHFJGjNa4lJOetrMgs+W80QYvBJPjhjJGjCnyT09R1yUbZx5BSsG8szggWIfrbBYtFAYfLEpI+v0+83lHiGJhvQ1dl1BaILVB+YDSGuccpETrQz4maynLXnYFMFkkUZYVkJAikYIjqIjtBIWpaJ3Fdi1SKERKTN0UtEFETeMs/eEAZy1tN2feTZCpB1Wde0dHQfKBumioamg6R4oJJcHaOdJoUiopin62gk+OZCMhpvwdJhFDFn8kFxFYrJvSH6xQGUWIYjGhSfcJydkmi0lUgWyOWRkGPvnxixSVzP3Gk0ZEg4hznHdII1GFRJkCoUpUNKQUiTii79BoRFnhFtXOIgZkcHiVkFqi0LnyHEkQCaGAGPExIVMgRU9R94gyV3CbJInBk+Sin4kw2S3AOcp6nRgc0jbIFAnJAxovsggGNKgKQsBoQ2sj1BqFYz7LQhsRsmOALhStz0KWmCJRanTI90trPbruMWqmCOkRTpBcYto4rIhEDzZIJBWVqTg62kPXFcZUDAZrBBLzbkxSglKU3Li3w/b2Kh88+xivvfZ1AGRSBJ97kScCmc/l/f7uWmkC2d4/xZSdJYiIZCm9Yz4wjN/1Lu7dmHBv5x5rW6uMdg/ydpIiOkcziVSVYuZn9M+scfGR03TTGTfu7nNwdEhdVygU43Hu1/I/faeE/Sa8ebL75mBLiDcU6+/EPu3kffD2k3h4k8pRiNxGPeUJ49tNzN94+dtbDD3Yo+2tXiNEpJArOLXPa69+iUuPfwChS17+8i9yZvsRbt99CYTmI3/kJ7PdmVSYsocoIiWrCKEXMeSixYCMeC8Yrlyk7m3xyz//33Lu3GlWhhrvPa11eBIieuQDDj7ZXURglGJ7ewMtJdZa1je3Ubd2SREOD2b8+T//H3Lv9hH7h2OClkihkAaKpLEOnnn2u5mPZphewNTb+OARUmdRSgrEKL/xOqR8zpdYYokl3g7fzHbzrZXrebS+8uz72bnxEpfe9W6EJKvp3jwEpbRQbkO2lBRIsej+JRaiNanuD1UxPjyWSynJ2kKBUooYIzHmCfXJ9qWUlFXJdDql6tVoE6l6fUJ09+uv3u44svL9jeMU5O0jcmyUfHa+mk1aptMxSj2K0RJBhJAFwjk+EA99Vt4v8mJDiveP9/eCJYcvOXyJJZZY4s1Ycvi3P4cv+XvJ30ssscQSb8aSv7+9+PsdJ8Z7xXmMvk1Qc/Z3v0p5tIbqrRCD411PPMa5cyuM0xFfev55Dprr3L0+QDqwx3fYufFFPvo9n+bCxV2uP/9F4qzhk9//KXzY4+Lms/TUkFf2K7b0JbqJ4Uc2/3ecvlDyq7f+e9aqR3hu9xe40n83O9NrXIu3eaz/N9jYPo/1Lcd+ih1LQhhh5x/EyX1m9jbeH7Bdr1B6Q2w7qt5lTq0Gehs/zfVrW7guYOeJqGZEQKgeyUQkLVJLfOsRUWBEoj+oWakVQXaMb8+RskRrSWcd1rncR1qUODdnpkuq1ENrQfSRoj/mQ5/Yp500dM0mx02fY1pEXKVWhrWzZ6HTTEfXuXNwg/5wg/ODDXQRmaeOqW3ZmU5JftHXGAjJM3b7FEPNU+ef4GOXP8QuL/H5F36dX/v1m/S7M1y9WOHEXTYGHX21gtp6F1pJ2jRnf3xA00zQGlY3NiiUwblDgpjTxTvUyvKe/jmG1SZeQNcGYtchlEKTVRiBhE0dIXTgBYWqkKpAaYkykhAtts02595FlM7WxtEHpM49aaL3eGdB6GyzLBIxBeZtQ2H6SGA6n1OUJVFIWu9y/2sRUSL3U9ZSIUi0XYN3CSUKTKFpZlNcyhYRWkiUjDibIAqqwpCEIyZBjAJkkYPREFFaYhcW28oUdLM5spH46DG6oSwkSkpA01kPKdtXyCRRqiBJRRciURmmnSN1jlTmnt7t3GEby8aZNawLOUFsNIVRtG6K1gUqRYrCIIWmbVqMiVS9ihQls2lA93VOSBrQqsB1iYRGFRpvJfMWVOHRdbWwyBYIqZl5T1X1iAFKXTBtW4rSIIDoEkaXKG2Yu46qNri5p7PzRbWtwhQwnjaApG0hGY0LiclkRj87q6O6RKUK6sE2B/d2mLVT5q1jPBrhrCP4gAsOpTUpBZxLdC5bYislkTEihCMBymiUESilQVrmbQNK5+RvTBhTUCEwZUXXeZKAECKIhFK5QjwKTTNviDHQNg11WaCExDub+1hYRyRhW8fa6ioh5X7de3uHuJUBejqm7Q8ojKRX9SlloFfmau/kBf26hzaKe/szVKGo+xUxerzL/dAjEZsi1nXIFFldW6OqsuBDyAIXwAeBc+2JpCtPVoKn3xsymk0JpeL0E0+wfekjdDPLaDqlsROa6S02Nx/DbAyJdsBob8LOwQ1CGzFVH6unbJxdZXP1KvPWc3jvZdI8MZlP0JvbXLryQaZ3b7J34yZtl+j8jLqnKEyNbRTTtuXMhTNUdY+b124TpGY8npIaD02g6PWYtVMKU3Fv5x5b5/o8+/QTaFcwtQ3Xrl9nNA9YYGutRzOf0I4mVCt9zpxbJ4iGeefZWq/Rqodr5vQ2t9m9M+UrX3qO3PtbYnqKjdMr2KajokAoxSxYJJK0N2Y0bWkOD9FRo6qK0eyIK1cf4Xh/TNEvKMoCN3bs7DtW14Zc2jqF9eAj3NuzbJ3fYiYUd1vPux59kk984Efo17/Ewd1X+cLLrxAxi6S3XFyfBAu7mUBWegutYKG6C0IQYqLQFVKUHOw1uE5QrKwxbiRzPaBXSdp5x97RGJ0iRx2ISrLaK7l5+wazgxmy7FEogwoK3wZCmzi243dK198SbzvxfttA7MHH0gOPv/PPfPNL0zf8981V6if78c2ef+O5BBIOj8dsnX6Ezo0wcouDgyNuX7/Gzt4OnTO865mPsX7qMVIKb+xQEiThgEQSESElITlkFDTTfW5d/yJf/uKvc+7sk/zEj3wCN4384m+9TEQgk8B2Hm00xmi6zlJWBm8t4+MZIQaMVLzy8utoFEEkzp49ze1bY0bHHpSh0IY//plPcfHiGk8+/jhPP32Fzc1TDNfOE4VEKEVKESmyUl8p8zYLE8sJ+RJLLPF7x0PWmgvei8WAn/8n/3c+9KmfyIuXeE56Kb7lGH0yxC8m6FLkVkVCCpKPi0ntA+M34Hygs5aqKPKjMYs6k86TZe89KSUGgx7WtfiQsNYxn8/zZD9+M5eV3P7qZH/v73M6mVzL3N5HJnq9HtErBDo7igXy+BvDG7HBm475Ya5K35S3fjdYcviSw5dYYokl3gmWHP7txeFL/l7y9xJLLLHEO8GSv//t8fc7TozLYhVlDEUl8Y2jMlAbgS4qti6eYuLv8tzPf432yPL6QWBza5VZPacaFtw5+Bq/+msN7zp/gebCJvu7U67dvcvKQDCZeYLqaI8O2Tt8nYvNB7h0bpX5nudq+D4+8tiPca39FWbzKa+OPs/eJHL14pDr4SarleZ8/Sxy6yxz5fHpGtPWcqq8ROMivjtmVT/NOHhe3P8s3fHLHBznpvHK9wjdjHlw2E5RFIneRsE0tMzvtgQXcdFju0yiIgyYuzkaSW00rrU0szYHJQOJGkDShs574ryhLioG/SGTuw2VnrByyjNtehyOWlLXMWpeoeIM/ZVTVGIFsyo52B0zOXKsbkgG8hQHfs7tg3tI30dLtbAFAB8co9kOj618hN7GBebCcbn6bqr3BV64eY+7X2hxYs73flLyxIX3MSjPcutgDt1Zbo2uszlwnOsXnFob0IZEG6aIaNHRwWHLqj8NXtG4gLNdrkpVCh2gTR4pDDFEooQYPQJBXKg70IqQIESN8wLvBcGn/OVVEiEVUhQ4l5PE0Qda16GVyglLtbjpSIToUEoSiUijQWY1jHMtSor8nPc01uJjIoishHE+V64bafLjKSCEBpEIBFofUVITfYBIrgCPESkFQkkQYAoNIlu5u5BIURFFYt74bAeuFv0ZQsAKQZQi758HERJaSlwX0VHgYqTXr9CFYWYkrnMYEcFImqmnLnN/iCQFMUXaxuFixJgKET37hyPKStLZDsMcZQR7M0sxGCAX+5qkIOmA85bgElG2eDyVKnLfbWepixqpBG07pxIa33XoqsCngIiRSO4tnUKgKiuOpzMKU6DrgtFkhDEa5zyzpoVY4kJOmnufsNYTa0nv3CO0UnE8PcbalsmkZW47Ou+xIeBDhJSIIdH5mKvtQ8BHn21ApMz9rH3ueW6MwQa/6IsksmBBKaSU2TZ7MZiGCEkopo2l1BolI1UJ3tv8fArY4CBEfFJkSYBAG0PTtFRVjS4MpSnxXUtjLYUU7LdHmFIy6EkubK1BIgsjRCAmTRKG/iCRhGbWjHHOInWBUprQdLi2QSrBYFBT1TXRe6Qs8QFczNbx8sTmBBAIyrIPMleFG+GZVQn/6CPM7h5yd6YQRjKtNFfe+16O5ge0XcndPc/+vEAJwWzaUZ1aYXD6Cu3wHOOjY9z2FcpyjX7bomrFXDrCcAXbO82d6T0uXXmS0hhGu0fsj44ILiGmntWkOJhEgrRsbK0y3WloJnP29seUdcmsC9zYmdG7fI6ut8ru7TGHR2OmVnJvb8TKeoXtZgCsD9fRGxUbGxvcvH6Hr9za593vOUV7POPC1mlevfkq2MjKZo3rYH9vhJAFMiYGwx6VqZnPWkxS9Oo+szTl4rkh5uIa46MJtkn0yzV08Jy/cp7hRh/bWqYHc+q6ZPdgn6ALbt14ke3tc4gIx/f2ia1FzRumvqH3yDZb964gB330L/0yVjSL8EAC2eVCCSAmQgz3rW4kguCycCkS6VJiEMDIgnuTHTb6q8zGxxy0c/bvdaQYmU/mFD3Bzp0dnnrqKQ7uHJAt2QXj/dv0BgPKQcXB0Q6j8Whh4f+7RTrRXnwTm7b8/Xtn/l8LIcf9bZ4EHN+oeHzzAoDIMsGHQrB38IH3t/fG/n6TCboQJDwra+s8/b5PsLJ6kaKqef9Hf5D/zf/qL/Cn/8yfZuzGTCcjNraBFJHCkOLCdkf4RXC2UC/GlmuvfxWVYrbvdxVV3WelP2A0nxGjpzQ6O5WQVereBwaDHqtrKxwfjZnPO5JIfM/3vYcf//HP8F/97b/HF7/yGtoItlaHHI+nFIVBSclnfuSH+OQnPoEoSwbVOsFOiUpz8j2UC9s8IQUxAiK7uDx0jpdYYok/kHg7hfnvBt/KNvMbX595QpuS4XANhMpVSHzzBVOxENWejNvHx6NFFPaG6pzw8CQ6hojzgX5dQ8p8k1LCLGwrvfekGFkZVLS2YjJxgCKFvGgZH+CIN1u5neDBfRbkOUaMeZEgc5WgqmpSjKTkT14F8cGJ9wlpLs4lufUPD2z7976ovuTwJYcvscQSfxCw5PA/bBy+5O8lfy+xxBJ/ELDk7z+4/P2OE+NFT7GyJqmqPvde1MTQ0LkRXkie/+oXWN8fsr2ywbR0KJtIoqCg5d69O+yNRrjDGR979BNc/fTT/MrnfoU7115n/vgex6/dZmAvo85MeO7Wc+xO91H9H+fq1hVW1nrcGL/O5vBRinjAyM7Y2fsyXzSfZc4RV9YvoaoDVGGYxAGlWGVNbKNVgw5ryOTwnWfQ38eJSF/1mWyNeV04Cj/HmIj3EWcNWmuaucObwPRgQl33EMERZhJlEuPumK51qCBRKwUoSHj6gwG6UlSF4pkPPcLLt1/l6I5ncjhjoNfoVx4bHsWJBpEuMe52eenuNQZ6gydXtzgYjamKIwY9yZOPn6PwqygR2Z3s4PyMItSM7IjGtbmXLRAj3D2wPH5mhSgdIYw58nsUaYs/830f458VL/Drv7zLhY33cXmrRqYpm8Mthivv48r2u7H+gCgcN49v87XrN+kpuDo4y6neVZTtYa3HWQsiIaJAoYgBogKJwLoO7z1GK4yqssO5BB9bCBpnA611dF2Xb7LoscGiKZBBEEOuHm6sRcRc/R1DRKkCrQXeOaQMKF1gXUdVipw4hVxBLAqCbZFKkyRIFUg2YZ1nYh1V3UOK3ONYiIhgUaHrOgb9ihQDoFFFhXMdptBY51CmyL2JY+4bkweAgA+BGAVCa0SKRJeT6RGBWPTERogsktAShCZGkXvOhAgx0jQtAsGwV6NEJARPUVZUhUFKkft5R0e/V9LZ3E+8a1vqoo+1HoWi7JUQHQqJI9BMx4tzYCjrPgmD0qCVACFpbYfuFUQXqU1JSiBkQmoQIhKsRyeT+6fbSPAOqQSNC9S6Rso5zgekAh8iMYIxJT56fIpoqZjPOpTUDKsCXStMuUJ7fAAp4n2BEy1eCFxKuOABCDFm1ZEyaLMwwrAeowyySrRNi+06og1UG1Ue2GKkNBUuBEL0JC0IIhIWgoY8EOawNISAdx1FYRAx22zEELHOIxIgFK3tUMYgZQUI2vkst1GIkdY6Sm2QUuKbGVIUHBwdsb7SI7jEysoq3tpF8jwhyoLoFaooUVKTUsS5Dh8dVVVT1yWmzMqnKAXWd9mpAIGUKg/8J+Qq8vfGuUBKnpCmxFZz884+k8O7TJs7rG5VbJRDZuMZt+9OOLh+g6CmvP/DT7Ozdx1rJNvnLjBrxrSzxHpZcWrlDONph0yaqtIkBUEH2EpcPrVNio6DgwkbKys45syOLDs7O/QuD0hV4MKVs8zuHWC0RPcLVJlbJRzP5pSlYbQ/5u71fWw7JxmJ6hXoQrB2qs+5jQEpCUwoSVIwO55jZx4tBJ3zDDdKLIGNjQvceeU606M5589eYHN1gBYGSklvbYW9g2OcTbjZnNR2OAsNjo1Hz5KMwreSsjaU1QAfAs3Y0njHmUdOIzrHhUtnObw9YtzNefbUFgd7BwSZUFWk72rG9/YpV4b0N9ZJNqEwIFqkyjQcIiByy4OUBCIJEnmCmWQixpDFNSRSCqTOc+f6DSa3Ruymu5y/tMalaotpmvLCay9hdMTIIaunTzNPAmOhrAvatqXsryNUhGQZ9gf0q5KDg713StdvgZPAQb6NUn0RVCxmym8O+h4KXN4yEHzrSfn9Zx/4zIeCk/RA93ZxP9x5222cfP7bBaNvfAZAwdrWZUKMKJnHitXtC/zYj/9Rnnz6Xayef4rBYIOQPDJJIo6stUmLIDEhoiHJgGRAry9YGzyOQvLpT+3zd//hP+X/93O/zJ3DYz72XU/y0ss32NsfY4qFejxGLl+6yJ07d0kxUBYCU65y4fwlPvNH/xQ//f/9Wb76wjUm45YkC2ICaz3PPnWRjc2CQMVqvYqoetS9PiLGbDmXsvhCoDLPERbB4ze7PkssscQfBPybqDx+q7/fvJB6/7kIUSSG/SGtl4To0UGBkg9NQh+COJmyZictpKTrumyhFmNugfRW+0bepBCC4APCyBzfeY/3PvdGI7EyqJl3PY4OdqiqHs1slh2E7i8eP3yMJ8fz8CLvA4vTi1l3SgKpJaYYsHd4m+jeRVR9pBAIGXiYyh74jMX2RXojtDtRtf/useTwJYcvscQS3+lYcvgfRg5f8veSv5dYYonvdCz5+w82f7/jxPgP/ljLL/zaiFe/1BBDi4dsb2w9/XqN4coWvXNDojtidHef46NjcI5JN6dPxROPrvAbL/0CH1x9mmv3XuR0dY7RwZwbo/+B1f6jXG36rPRXuX73NmeqV3j03HvZWLvMjYMvcpwOuGdfoY4fpxxucm/0HE+c/qPMRIPuCnZGBjvuc5gOKMQuhZlSmSEr5VlCepXh6iHWzWhin7X6NEEe0KWClTXDXjtlvHvE5vYAoVtkBO0Us9aSpKCSil5P8KkfLjmYz/jnP7sPbYksIxiDFBIlJDPnaHtf41M/+gIHd7eYvPg9XD07ZOVRA0HzyvQar958DnUUODrsmJaRdvw8jZhi24a13jpntjfZHOxihEJrycgH7o6OsH5O09oHlIGK/VnB9MbX2Ro4rmycw7kEKnF6cJXv/rBitXeDR9fWee3GlH51gQtnL0BlaEJLoTdp0wRtCp45tcqG22BdPwrO07aOEFxW6qVAiIkUIkbniu4T+xgfXO43IDRaa4SUue9y12KtxbpACGlh5V2QkqWzc6K1BG/RWtEbFIgQaWZzOusAMFFRGoW1DaYoqSrDvJmizUm/X0HwjuAdQhYoYwgiIKNABoFPLU3bQAKlSgISnySFqjBC0zlHdAuLHpUQQuJCxAWFSwLvEzEllMw3Zz5GmfuJuw4VPUpppCqwNqJJC4FNJBJxPlu0a13linYBhdQ4Z3Ols5LgQeuKtnUIAQ4oy5oQLC5EklCk5IkxcHw8RlYC3wi8VkgFISQm7Yy14SZJKKxP2OmcujSErkP3a4KPxBSw3hN8QqBAQfA5WHQiH6e3Fqk0AkFRFLTRIrWiSwFlDG3TIQBTGCK5l/fh/BihNWVVcHw0RpeCftUjyQErG9vcuX2Nw9mc2ajBdh0hROLCatp7DwtlkkISpSBpiZEFxJxsTz7bYh8dHWH7Nb2qJnhPr+7TdZZ5k/uf68IQfCIgUCLbYwsSWitSymrO4ANKSqQUOGeJzoMswGSFVRQWowvapgUCnbMUQhGdZWpzL+7UROKgZDZvEUnQNA3GGIoq9zQPPmBtoLVzYttQ130KYyirEplUHuSVJAAuJbJUA4RUpEBOjr8xnJOsJyWyw0LRI+wHxuUtWt1x9ZltZKqwTYlzUzZFydbT57hy+f2M2xucvXQRzZD53HIgjnFxymp/EyEU0UypZcQbgfCBcTeiVw8YYugCxJ6hd7pH6p9nY9Xz5ee/zKjbZbAyxO7PGN2dI0NCph6iUAifaKdjjDIc3b7DjQ6chK2NdYwuiM2c3duWpy9+lNF0gjWgqprx8TFH3ZyhjjR7cPHqNqoNTMYTNjZX6Nc1ugKZBth2Suc9k70j2uMR0SmkMcxti0yJ8YHm9BnJysZpmrEnupbJeESICTOo6Bc1joApCqp6gN474vTFbeYEzlx8hNFoh+gF1UqFjBKjKqpeTTlcw+iSJswQKeTqcJUDABJ5MpQEMaSFnQsEDxSL3ic6MT4YUc4js0nChBahFK+9+ipx2tA3Jesbq0zaY4qiQmvB7u3bDHsVZVUSm0Qa1sQAzfERMXaYonqndP0NeFBV9836nEkh7h/jiap8sYW3FZQ/rP5Lb3runS8knARE30q5/taLCg/uY0KktBAxRJAhi2ZEotA13/d9n2HWjCh7Q0Ag0SACApn75oiIFBADtO0h5aBP8p7V4WNMJvuIOOeVG9f5zeee5/bdQwpT8J7HLvHKK7dR0iBkoi5KlDAc7u8RQ8S7xKmNPh/88KN8z3c/Q1lG5vMWZGLWeI7HE2IMaF3yyIXz/Kuf/Vn+H//1f8P3fvKP8H2f+mGuXH43SSrQAhHzcSolF2In8cb1WmKJJb4D8c0XNe+/6l/zhPxbbfsbH0t5mBVgjMK7SPQdmIqER/JW431aLLYKhEjZto2E9w6pZLZyyx/2tvuW+0SmBxZM8+fk34mqVAwHfVJM+OB58YXn8T6gpCBJiUIQnEVohZDZAQoZIWli6PC+pSyHJCCmhBBp4YbUQYyYsuTll36bZjzmR/7E/5gkOogSITRReggJpEIgCa5lNN5jdeM8iIQkEhOkt1l4eKdYcviSw5dYYolvVyw5fMnhb48lfy/5e4kllvh2xZK/l/yd8Y4T42I6ZHP7Ap/buYnWkhgCvarEJ0nXzWnaKYW+wuj4BnvjIzbNBpOgWe2dp+vmfO4rt3HNa8TWslqeYTo5wPQNW6sVt+6+wLkL72L9YstBJ/nt67/N5oUtXjr4DZ7e/CS351/lKB4Qp59lc23EWM5xrgTbh9DjTFjh1bTL7u4eQszZXjlNb3OCk79EVbyH20ctw6JBa8uwJ3j8fI86rfHKjdscHowxSXB8NGY6h7IokY0kRcWwUsS+JdZ95CDy5BVFWc155Ysjdm+uU/Z7qF4kukSaR174LcfZi5onL11i7ez3Yt2YRj6HVZEzxVkm5Yt0GwOMWWU6CdzdvUYIPWzX0gnH+NjxyOYGesWAmmKkpDY9Vuo+rSke8NGP7OxdI9oe6XwPaRx9vc5K1SOKxOkziu1za1h7i1ptkLo5Y/sy/bgGqcKGCYaGU6qm13s3wa7gQsLNWnKBrSSEiLUtSkq0grbtsrIwJaIUaKNRxqB0gTbZ4rfr5jgXCUlkJYmQFEWJi2CEoZvnZHmMia5tc1XvIqleVSXGFCgl8a5jsNInhIQPAW0MzllC8DmZ6eMi8Z2Vl7kQWecbIrQkcjVykiVG13g7J8kqV0rjCaHBaENMubdCxBOsJThPEgkXNa6xKC0xhVoElgKExIeECBZcwkhN5ztMkQUSMeYQL5Gror21aK1zsjxEkCr32rbQ6xV411JWJbP5NOsQZMR3ESEKlK4oVKDQMGum2ACF7jObzikXfa6tF4SQK9e1kUipcFEQY7bdT5S0bR4MTaERMiEigCTGbOvknCW43KNBJYUNniQEMVpAkciqIiESzntCaggpMRmN82CqFG3XcTh2PPv4ezgcTdnfO2Y26xbOAZ4UBSnJxQAvkSyUQiKglUSgiQSkUgQnCArWN1ex7YwYHFoY1ldXEQkUEiEgRIdIIl8zBFLqLJYAUkxobdBKY32HFFAWBT5koQciYBtLwrK+nivSrXdorZBIosvXfjKf0nUt2+sbeBsILtCr+3jvc/I9BqrCMJ63zFqPkYK6X6G1oXOOFB2us6yuriGlpnOWrAvIlcYpcF+te0JHKSVc0+BlgTIVXdsSW8vmmSGbw8vcuHfAtJmxfmbAmbNn0OsDpuEOt/auM54c0S83adtdbt69xcbZNS6uCF658xxn+o/RtCX3JntEO2d6bFnf2kT1Cpz1KNOj0JZXvn6H2DqiVFy8epnx0SGj3T1ULJhNj0nREMQMXWuStyAtpnDgFevrAxjAxnAAAcJjj1AN+owbx+iooWk6htue0HRIGbJNujTsvLbHcFAymQpKST4bJqGEZnwYkSowmc9oZpaeqWnbOXNreerdV9DVAK0L3DwikmBnd5fzZ9cpq3V2j0d0Ry31sGazv8J0MsUMVjmzVWIoGZwaUA817eQI5pBUgZGG/mAVmwoUEmLAB4+U2YKGlJV2fpEQFyJfy5BO7nuXLW2EpDQFj54/TzdLmL6mG8+Y7+5hY8c8SObNEadObxJl4mjnLv1eRakNSmqkSfRazeTuPtsXag6PS0TXvlO6/ga8ofRenF/ePDE/OZZF0JXkNyjHH/yOvnkyn9//5lc+bOvzln3TFj/pAZX8O5lcvvG6N47l5KNTypNxqRb7lTSQhUBSSm7efoX1UxcxpofCk1IgJfGASnGh/BYJ205wfsawOkVZ95hN4e7tV/nA+z/GX//fPsJP/s//InWvwnnLeDzHGIUsHD4qtHL85b/07/I3/vY/Yjxt8CFydmOT3/yN3yTESBcChTb40KG0QQlYWan4+iu3uH3jFmfOrPIL/8PPovwR6z9Rsn766Tx2PhjIEjnpx7PEEkt8Z+Bh67CTCCD/9W97ce0bx/I3/j5Zl31onwQQBabXY9aO2blzhwuP9hYLug+/LP8WxMXEPJ5Ym0mBMQYhoDAFbefy4uKb9w0wWucKJZmV6lJKhBD350OC3N/MRUPC4AO88OILODcHUyB1ydH+67hmynDzPIXpIVMipEiKAtcdMxnvcfrMU3leAbjoCXbGzq3nWVk7T4iR9777Y9x67TX+6c/+v/mBT/0gVW+d0dFt0BW0I7Qx6N6Q/XvX2L93g1/+pX/JpUuP8e73PIumJOp3PN1+Syw5fMnhSyyxxLcHlhy+5PDfCZb8veTvJZZY4tsDS/5e8vfb4Z33GK/22H9llbpqSP0ptmlYWVGMXGDGHD0aUWpJFDNi8sxnI+pqm/7gNKKacDy9jSlXGY/nnH284qB+jXt7jtO1pF/WnDqzw+VTrzKtVyheKrl7+Ks8Kn+UF8NvEtJVXu8OUGGfUETGsx7Wv4TYBLe/znqv4/ndzzHbv83msOLU8CpKbjKR+3z91q9xdDhgLna4OFjn3Zcvc+qRHZhV1AcNBoGLDSV97KyjGXsGpqIoNTYGRJQMh0dENmi95ImnzxHL17m7H/D2LMiAURUbg8CZjQ3Kgy1CucI0fYUj/yJRHqD1DIqz9Ff7zPa2mLhjZIKiFOwcjIkzTX810U4OeGXcMdzQpCpx6fQWj21tMQ0jrjc37jexTykx3p/SV4qjUYvsQdGPdKnDhz61XyeagBUFsT9B6F3W5ccgQIozAiMKWaHdGYSviM0U6xxN15JcJAYLMZFil/sDKLCdzSo5pRBao5UkOkfrIkLmvium6pGEoh2P8o1MYj6bUvR6ObkkFIWpSErRtXOkNHgXMUajlEQIiSlq+sMhIXqc87jW5qQ8Eik03jmMLhZKEYGzAR9yQKWNpCprJvMZSkm08cQwQwrBvJmjtclBpyzwPlLlLBzOgpCaru0WKkBBUWisdySfk9xKy5zSFYZEgBSQOX7F+0BMYVFpnxbCFQEUzJsGpXRODluPUgKpVd62SLjg0KXGBUehC4L3RO9ROqIEtE2Lj+R+2mjKcoAkIlOgmzfZXl9lO+7ZvCMEsLM5SuXzlUKi7hm8UIS2RUqdk/tKEKMneouPBVVd0XUOpTUhJWzXopMCIRaKyFyFPZs5fBTEKBZ9siO+CyhdYcqSO3dvsTM6YDweUcgClyJ+3jygaF30ZBaJhCASMUoRUiKGgNGa/sYKrnMM+hU2BASJ0uRj0VLhvMNZiywEtrUUdUVKudeFWFhdSwzWNqQUiVGihEZJQxCS0WROBMoqizCE6JGIjI5HbGysMRxUJNtSGoP1FoykC47WOcqa/JmFyQn1LiCSpN8fUBuDlIEUMjVN5xO0EsRgsV0gRUnyCakNLKz+tVa07cMqJq01Xgi0lHhvKUyFCD1evHEX5IAnrpxGlZJmBHv7X8fGKR5DHMHYX8Mnz+z4GCUaHtv4GFt6wM27RxyPDhmP7zI+2KV34SxXt1bZ37vL2IObHtOnj3T3sGlKUpphfZWj64e04w6pofOWmKC3soZWic53bJzbYnV9SH+1xyPnL3F77xWm0w6tFNV6jygc944PQBfICq7ducOZrTWGG+sIO+fclYsoOyXKQOmmjCYWYzS3bh1imHF0dMSZzVWqoCjkgNl8QogtEklR96nVKnv3bpCiQijBqXNbiEGP0bhBAOcvX2A+OaSZT3FtQtWGQdVDe0nQgumsZWNtk6NwQOs7Wt9CqSm6AtPrk46yQ4aSkhgSYvEbDAiBlCzsYiJCSogCKYAk6aKniQ3b20Nev75Pi+DUlYt0zQSh+sxnY6rCECRgNIPhGmHusW2iN6zxwVOvDZiNZ/iuRVK8U7r+BjxoXQPwYIz1Dc/laTLpofnuO5kowxt9zt7Amy1zvnXQ+fBE+5tP1B/c9iKIJPcqI+XrRRLE5JFKEmLH5asfpLdymhjlIgiWi32Mb+yfAKRgdfM8k+M9Do+us7l1gcHaNv3jHc5ffQ9OD/jo+57l/R++wmc+8Wn+xS9/iXuHY9b725w5rfiP/+J/wPufeYr19U2++tWvMOxVfP65l/nSi9f4R//4VxCyQqsK5yZIXbI2XOHD736Mazdu8UM/+mk+8N730LZzPvaJzzBYO4PUhrRQUT68YPLOFjKWWGKJbyfkMetkQfLbAQ9WMqUUF6PMySLl4r8k8Hjq3hqXnnyGa9dv8sjVd5FSAHEyUX5wo4vlhpjuj60+RGazGSCwwRFTuP8RJ+sCQuRRrqoKtFZZ3S5yrBtCeIC3BMN+jQ2JEDxCSr7whS9w7dUvcPVd70M6yW/8ws9y6fHHWV25QNse4WODqfqZA6Kl6q0QgSQWlU0ux+HrW4+g65KYZuxe/yof+sCT/O//0/+CX/nnP8df+Wt/jYP917lw4RnU6jmag5sU1qLNAFn2kO4250+fIwVBLFTugfV7wJLDlxy+xBJLfDthyeFLDn9nWPL3kr+XWGKJbycs+XvJ39+Id5wYv3N0l+mdAdubj5FKwcZKxY/9yQ/yf/wb/zkryXD13Zr9yT5VMojYY2fvmM1hj7WNPmVPsJYS/TJBlFg74d7dPYbCYCc1ckMxqC9QVa/wxz4muHH1Ns3xee7d+QKb6y1l82He0zvFcfWLbG16Uvsoh7vXGN17jRsvSwozxFSSqjZUvQmH4ku44yEYz6By3D7Q2LmleH/gMHwOPdzii187IMYe65da7r42o3EelQzBJSgFyiTW64pn/kjDMx88zY3ZPl/fgZXenK3BZX78zwR+5Rdvc/TqeVbPJp79nhWeeuw8PXGa4zjn0LYM9LOMwj0Ou5dIYopLhiRaiBO6aKh0H1MfEZNj1IBIgV5P03OJ1gXm1SayHhLkDB97969FAsZty9E0IsstTH/CmZUSZXok3XB3vM/Wxiax6dN0+6hC4coJAouODSIFym6LNO+YzI6Zz6eEbkw7ny3shBMEkCIgdIGLOTGqTYGQhiQlKSSSSPjomEwmKKMRUmO0AqHyGCMTMVqmowlFWdLMZogYFzbqPebTMVIVdG2HVhJTlEhpSNKQkCAFUkOcd6QYsSlQVXVWHYqEdY6QBEIawBOTAymoqhprHU03QypDCBEhJM47irLGh4gQ0I4nlGWFVBotEsOVIV07x3ZzEJqubZHaEIUktg4lJMooQgpoKZA6V2CLCGiJR5C8gyiwriV6UEZi2w4hNEqASolCS2LyxBQJPuK9x0VH6cIiqSbonMMYRUDi8CAl+6N91oYrxIUduRKSrC8VOG+J5CR9pQVNN6XfXyEGyWg2oqxK2qnFGIPUmhQjQkliyC4Jzjm8C7jOoU1B8nFxnXNiOvgsbLDOopTEdYEoQSqFbSxdBaeHK7x272WObt/h4HCEkJKi1NRViRQSRFokqvOoq5TKVvU+QFwomZSgKEu6psl2G95DcLg20ev3cT5iCo2PBh9yT2elJLNZg7MOY3IwLqXEds1CACDQWpN8pOk6QkwoU9Cre/TrghQ6tFREIWjmc4pUUgBKCNb6faaTKVWxQuccIPA+QAQfBLbzFFVFTAEvcn+PQguMlAzkAKMkEPE+kFKk0AUuRiIJJIxGk0UV+RsTFtOv8CEx61qEEajgmU72eObcezhoblFXPZyP/PaLXyTYDhMr5k1LoSWTo11cCFx4V83HnvgIO4fH7O7e4971PQ6bEdF5zlx+jEJHvvKF36ZiyL2DMant6K+W1HWPYrWkCBXXX3iJ4+N9XAwUKmGdpOwrfGhpGs/pi0Pe9cST2G5Mv79O07aERlCmkv3pHOlahAr0iyG3dw7YXtugm7cgNEWCycExt/RrrPYGrK3XzKYtB/sjeisFla5RCHpVSTNr8D4w7PcRZY9SbZAU6KjwswmrKzXeK4ZrQ46Pp4xvHyGN4dylbUbNlOAkwibGynF5Y5vx4SG2UKytDNlMq4zuHDPbPcKv9wnSU64OKIoBWpVEn1BS4EIAoYmRLAoCUvDEmAMXISQCBamA5IgkVFnirGfn5l1UCqT9CW3cQ6pA8DtUwhJHEAhoFO74CNc4BitDurGkt1bijGF4Zpujay9Tv1OyfgdIKY+JJ9+5EzzYJytPzBcT1IXa8O0n2CeirZPHHrbzeag/zlsgi8Tf2PZD4sg3799Dx/HGfmT3EIt3Fp86ZNIYU+XWF7rOwgYFvdVtEBrwCKEgCnhgMeFB8XdMgrq3Tjc/JMkCXSguP/YRQmj5m//lf8of+8xH+PCHP8aLL72ANiUff9+7uXcw5j/+Kz/JD37qx/lnP/N3uXLlMZxreerJZ/nCV16mtY6f/NOf5Mojj/Cf/a1/wL09TRTw5NPn+eTH3834A0/yF/6jv047OUBJxcr2k6SUnTYgvpP1kSWW+I7AO1+o+/bHt6rMeQji4QmakLkdx7fCv43z9MZn3C8hetOagUAJgVSaR69eZXpwB+c9RssHl1LvT7DTyWx7McaeVA1l8azAWo+PuV9jrho6WRTOylPnHHVZoJTOzksiobQkxoXzEVCUA3r9CIsF1ru7c3Zu7/L0Mz1AcvnCFTbPPYbuD5CxpCdPgwKREiKJLFRMIcfkEe7efZVTm5forZ3BupbQer78/CtcuHSWH/zEh/iZn32On/mpf8y/9+f+IrEZc+v5X6Ks+7Cyzk//d/+QT3/mR/jRP/XncfM5R4fXWF15hKKn/rVepyWHLzl8iSV+v7Hk8MW/Sw5fcvjvAEv+XvL3Ekv8fmPJ34t/l/y95O8F3nFi/F/+9w0bVY8QLFPRIYYdR9xl9fSAflewcb7jV3/uS5xaW8f6iEUwGh+T7nyVrQsX6cb7XH7sGayUWDOjR4moDd//fZuozWuo4td418pl7k0EV9aPkcN1dspVLq8N2CwcZ1bezw17m271NS5tvo+94QVe3P0ldnZfRx7V1CurSHnISj1DFT1u3eqT5i1PPD3iySfWKMQqsnSs6j6tbnj68U0uPgFfeG0X90+GFLpiGkBPHGv9HqUsOHVWcO7cjJv7Q2J8nGGaM+++xEq4glUzprxG1wW2Vge4qWBnNqLQu4RYIolMUkLKmjX/DLWyPLl2FrdZs3vhNmluaLoBz936VV74yiuIuEVsI6lpWKl7PHnpKivDFcZ+zrSd42z30PXo9Ur2j2ckrZjbgpev3+Tc9pioxpRcxjdrjOyc6cyzsjJmozdn1hyy6p5iEC9ipw3z8QHNaELT7EMUKBFIQeJ9zFbUWp3cX3TeEdFIIkqoXCWuNYqYq31TQqV8AwktcG3uHS68hWAZTcaURbaGbmJWEQ76A7q2yYnX2KGiYd62JG8xlcYUBtu2FIXKFcqdZzKfE32kMgohPFrXJKXwLgCashIo15GCI3rwNmBDvtnKskfXtrBIJLuQmLZTSlMiAKVy7wWkxvmENiUxRUSMyCQIPvegllqChrmzFEphnYNCI6QiepAkUgTnPASPUgpBwnlHqSTJsTjHOgehSFI0WBeRJISIRCmz1bYwtM0cSoXzkcm8oZCKeefpTCA4iykNuizw1qFlPhdaSrzzkAqkFHgncClCCBRG40K2LtKml5PxJEyp8G0gpYAL2WIdUj6XIqG0ylb1QeTrHtOiSj7SH66wOzpm73CfxnYgBUkLHIHUzimLRbVrzMG9lhJEzIGmFPgUCTHQ2pZhv1oM4gKtJFWh83ieQq4WdxbIFeZa5cE0UwUYo2nbOSRDYUoa26LN4jzHSIiOKCO9qqCuqlyhL8jygpR/YgRdGFQS1IUhVIFSKbIvAnjv6boOYwwrG6s431AoQxsFUigiEal1tvyXAkFYKLkELlhsyMKl4B3NfEJRFfeVsqTcqqCQmvmsA58nUKdWLyLXBEVhuTfeAa8pUuBwvk9dbWP3ZjSlx7eC3mrNme0neHlvzOG9m7z4wktIIt3eMWuXL1GslDT3DrGNYjy/jT1uKQYloSiYjOaIGfRKQ6oFA9mnnAaOmwapJNPxnLKE0bHl9KM9RvM9Vus+da+ms3MuXtzk1ms72NmUjc11pCmYHk+ws5aJnDAsag7uHjBrHZtrazQjx34zoiwgioKN9U1EqYjzGdOppaQm+BmnHjnL9vltyqRpJ4EgAyqVjO0ROmlu3LvDaSxGFATVUlSGOBtz/NKLlFLS7h8yqAy3vvZFOtughGSSHHhH5yVKafRM8n/6638BrEcnRRtvs7ZeQwq5tYSLgEJJiQ3dInCIiJQFET46hNaolNCmwO4f8eK//HnsfE7fGAYionSi6vVQPY0qKnSQxBSYtS3ElqoUiPaQngB7T5Bkwh+OWLcdQUzfKV2/JR5UfT848X3zxPZBe7Q3CynfPLF+KyX5iSXayTvfmKi//Xt4i+2e4O1sht78fFadF0ilKNKQRCDGFudbXDumV6+RhMoTcWkXywaGJOL9fXr4/AhIcdEPx+N9R1H2sxgiNNRVyentc1y78Tp/97/9R/T6BZ/+9DPcurPPD3z/n0CYIe//7s/QTHY4f/YMp7aucu7MOu9/72P8sR/4FBtnHudnfu7z3Lv3JSKej3704/ypP/s/4/lXv4I2A3TRIEUFMSHxC+X9os/9W5ybJZb4TsE7GUe+c5B4uCHK/SVM3n4FTcID7zmxwvz9wFtdi4cfW+xnkiDyQqUQApkij115nHuvfAUWMa9QgEiLI3nzdheT5sVn7O/v4yMLa7f7uvgFFbzBHV1nCXWFUrmlURa6ivvjoBAglEepdH/ibwP85uc/yx/5oT8JAvbHdxnYy4hoUaokycUCQQwoKREJUoy5VZNUTA5vQzdh++KzCO/YOLPN+9//QZ553/dy5YkP8PEf+LP845/+B/z9/+ff5N/9n/yHpKJAGUMzOuCHf/QniCnxxV/9x1x85Cq6MOhSkpzk96puW3L4ksOXWOLbAUsOX3L4ksN/59dpyd9L/l5iid9vLPl7yd9L/n5rvOPE+Oy4xKmG4D0XH6m4fvsFfurvvIYKPSbzls/+3Azhc09mk9ZZX9e0TcP46A6xGROipT88w0rd8uqNL9MzkiACt24qPv3sGR49rZjFHi+8/jpl2uQ92wPOr16lEc9z3HX0W8+lte/iV0avsdrW6DTgzPqH+WpvRDiKoGrW1i7TH55ltdjEbe5RntphMBywXoKIp/FyTL8Y8freiA9u/wRy46uI/dd57wefxWzNePmlY0YvJVRVo7Vmd6/lN35hg/OPXObiMzU79uvEdsgXX97h9Zc9rt1mIAUvvzZm6/QqUlRcH++hgY3+Oqv+HDFGgtJoUdDFiq4RdK5mNG/wfod+32BFQHQFRMFe13C1d47humaesr3vuDvAKHXikEBMEUnBSh1wc48tPaNpx+bKNqc3+6wUT9C0mtn0VSYNHPmGFVVwVl2in07TzRrm4yOibYmuJXUeZQoEkhQDujAIIQhRIKQgREAakshJzKQkuigRQpGCR4VAjDFXWksQSlJVQ2wUJK2wbaSdzbBtyL1gmjnT8YQQImurW8TaMZ3tElyD8oG636edOKxWKFXShY6ubXJ/8kVyt/EJVUDrLUbXkAoikRgibRtxPuF9JAQICTwCP2/olQUxBnIKOr8mJY9Rhs76fIfLAoRHioSzjhQj3keU1CBzgjtGhUhgfRYF2HFDWRhEzP2qlVT4YFEpB4speZCKxiVKIimBdwnnHIlEWZWklHIlccyKHr/oaZykYWY9SINLEtt6nPUkck/teddRG42znroosSGgVURpSxA5gV3oRb92rWnbJtvjt45Kl7jY5Ur4GPHR06v7yBYQC6sMmRDJ44NDS0HbeYRSiBCQSjNzUzbWVhgdH7N/PMa6wGw+RYhErzfA4vCuQ2qDRFBqQ4qJJBRKaAQJpRR4iC7hraOxDqUFjbX5uFuLTXPq3goH+yOSEljnWBkMaZ0jxmzDToy574UUpJhJUSu1SDwnVIR+VTDsV/RKgyLgvSUlifMBoRKCAk8kOsuwLOlXBeABkDKiFNgQ6A16xGRpO4sqDCEmYgJhBNEHYgIpDdHHLI5QimhB4OmaKdPRMUbBtBk94JYlkAimkxblQLQgK8XB/g53myOIgpLEKOxQDQKbxQoKSTE07Nw5hpRYOX+Ww4ND9o++Tp8KGz0+BfqnN0mt5961W2gh8r3uBUWITI47HCWzw2NW14bMWs+jT51isrPPjdGYJCNIRYwNXRI8/b5HOXvuNFtr55iN73C4u0eyifl4RjVcwxxMGI+OGJg+k70RVaEIKVvKRx+RZUSVknY0JRzOmPYdj155gt2b+zz/9Ze4dPEMpjDIlFgZbFEYw7mNbW6+eou9ox1CFJw6t87R7JDoLFVRIp2CzuFv3mTeNrTCo1NHoRQmeLqdFmstpldDjNzvuiKgUBCt5eDrL2EKQ4ywvjHEWZXHi5iwNiBVQYwJKXo5eBFAihATMSaKqsS5QG91mF0WVIS1FQ6Pp9R1iRIQgiMGh6IEXSOloSiz8g6RkAmSiGAtla5w02PKokRVv3sr9RM8OPn8ZoFwFpuoRWgpFmHnW78+b+ckqDxRGgLEPAHmrQO//HV/QIl+8tzv8HhOtpNSVsnn48vfVxlXEEaQZoeMD24xWD+F0kNICokkRhBSLvY/90V74/yc7Ixk1h5TNWOU7hFTQFU1/6M//qe5c+d1PvOj/x5FJVCyopmM+Pgnfpi1zUdIoqBnDD4+wXO/9jM8//y/4tM/8Ck+pRTbF6/Q39jm0qULyM9+gZVexfve9z7qtQt8+COPIYj0ty6gMAggLERpSUTe3HduiSW+E/DNqlW+s7EYKMSbH/sm92kCTqp/Hnz/v4ZT9E2rgr7FwsdDi6H3x/PIGxNzgSQiIiQlefSxJ1irAiJ5hNL3j/qhfUiQrTUz48aF+n0yneJDvO+kVJYKK6G1/oF9yM5CJ/suhEApldvNeI/zHiGgqmpmM8ugLtBac+jmfO3LXyclB6IiSU3ygmZyiOqtUJg1BB4pTBa/Ekgi4qVChsRT7/8+cJIUWuhvMOxvEIWhGKxT9zdYD4o/9+//r/l7/83f4qf+4d/jj3zsY+zefZ1Bf4XBwHM43eH8hXexdfoRUqERXuLfwuL0d4Mlhy85fIklfj+w5PA3Pb3k8CWH/w6x5O8lfy+xxO8Hlvz9pqeX/L3k77fAO06MD8uaGAW9vqVYaTj62hGrrKBXh8xHc/yso9xcQytFvzLsjG7QK2v6a2dILjA7OOLw7k02L53ChRkXrmjOPnvI69cH/JPP9/jIewOz9gKros/m5jVeeW2djV6JPnOLIzvlYHbAh9c/wLvkD/Oqb/jNV/8VKg3RcYBYmyHNMY+c2mTSHvDE6hOUg4avffU1Uvc+qnOOO92vM5Dfg4wDntk+zWAjcsiY92w8xdmP/zDXzXPcOn6OR4vI4WzKfLZJWfaZBs/IdujDA27eGxP9JQ7GU+a3D+gFg1rVXD7Xh5XI3Vsj6pU5wzVPZ48YyTkpDalZ5+7sJtcPb9K0m7imj7OWnrHU9YDHz58Cm7i1v8tkv+Do7k2uCcH5cxus9s+zb2cIaTEyXy4lJWXtaGYVSUZ296eIUNPMS/x6n93ju8xawb3xHXxoOSNrtqbfS693itHoNt20w3cOb6ckP0cqBSkSnc9JmRARWiG0giSISIqyBpGTNzEKnAtImROazlqcc8QQSAKSFxACPnakGIhJU1YDmvmY0WhEry4ZDoYElzgcjdg4tc16dQpnZwTbEKNEK4lUCh8c0kiwghgghISWOZhqZgFlBJ1tMFIjZCImga76tD5ifZMTjVJiuzmFrmi7lhA9nc8Jc4kmWYf3HikVSQqUFgTn8N6ClJS6QEgQRkF0xOAhxEWwBMpo6soQXN4GCHwMmKoieo91kaZtMVVJSJHUq1BS4TqbVT9KM2kbjFBIkQfBCAiVB1AtFF2M+Bjz+2NC64JEQmqNTBEbchDahchsOqVfFZgksCmgtWHWTIlCgQBtNMEGuqahqCVSSIILuOBouw5TGIwyTKfj3Hu9s/joc3+dGGlth1KGGBPOerTWbK6s4JzFhoDzWZUkWVyrHE4SvafQuTezOFEe+YhMoJVGSomQmmbWMJnO6JeGEOD4eEI7a+iv1lR1oq577B0doE229chm8tniejabMRgOSSnhnEepfM9475lO5gih0FJSF5q6MGhp6LpIZz1S5mr/+WxG8IZTG2tooXBdmxOVCqxvGA4r2plHxJDvSR9ofba7V0rQdXFh/T3I11MqhJRZmGAqfPL0B5KVwSpKgJT6/n4KIbCtQ1eKLkXCUKOKAnd4RH1qFR16SK3o9VeQ8TJ7O3vcfP1VjNBIEdBC04slIXm2t88wcEN4/DR3dm8wG484fWqNyWzCzZdu0D+3Sjtv0VZQVBq6huFqhSwMPkSuf/06x7sTbOhRliuQGnRrOLO1wlOPXqarJATHwZ0xwUN0joPxAbqs2Vw5xfh4F1RHofP30/mY3UTaQFVq9saH1Cs9Vs6cZ/PcNm2X1WLbp9ZYXRlQqilSFERRMRkHbh/s44rEQJfszmYMh4b3Xn6ar7/2Kmp2yPGrX0DbyPZ6H70+IMaOrl2o17xHGMnA9LAxIRLkFgFxIXCZI5VAVBUgMEUOBMqqpm3niBSoaoNzkZRCFumQCClQljr3YFEGVSgSBqSgiwmjFV3n0TLf24UxqErhnKdtA/0BICT9YY2zjq6ZI5IkeJ8T+lpRqoqy6j1kL/Y7Rsqan8SDytA3AsdvtFk7mfotJr2LR95pzJgtfN564i+EyAKntwpahcg6zvSGJvv+NoRAJEFaBIkCuZAq5qAvH44AKRFJZWGMSEQcVT0kBc/e7VfZOH2Rot4gpIBSWZGeBRLy/nmIMSKlyGI0ITh77n3YbgwSZIAoK558+oM89cEPYYNnZbjO2toFXnjxi7zvw5/Gtw1BjNFVH5Mk7/+uTzObTXnpK5/jV3/1X7FaDnh8/So3bu0SRM361mnOXbxCF+cMyhKVKlJSILOLhRaemBQqmxO8zeLIiYrz/lV9i9ecnNXFwsXJFb7fZEnyLeL27zi8ccRL/P7iG2pfFr+zcvvNVTP33/Vt+oW8v495sHvj798RTlTtb//+b3YufqcLHW/3+m/2+IMVPItHQcos/DMl1epp2tmEQVlkxToyT3QFiJSPLibeUJcvIjbv/OJwcyz9yCMXscHz8ivXFwusOa4rywKlThZbH+YUpRRFYVjpD9jbPeIHv/+7uHL1Mf6v//Xf4fXrt5kf7DA8dY7p8YjZ8S7EggurFxB4Ei0kjUgalCHYETFEfJTonkDqPkIUeFp2br2KVJcpcXTR0nlHJRUf+/j38Pf/3n9Ff7jBp//I93C4f4fj+QHFyhabl65gQ0B4TwyBL/7WL/A93/9nf0fX6+GLseTwJYcvOXyJ308sOfwbseTwJYe/kwu35O8lfy/5e4nfTyz5+xux5O8lfz+Md5wYX9naRKuarY0DwvaL2KCQ6zUhRLyoOHNxjSM3YjqZ4SqLrFpK06PsC/pDw3QUObj3PI8/+/28q/cM1/Z/i82Dj/Dhxy7x3O1f46d+fsJ7Lx/z4fdJzmwXxPV9fuvVu+jReSb2CNN7lf/Pa59jTbyXAU8gwgw3aVmrFb0Nw7k1TT08ZDYd8fr487ByxPYTBTvXXqaZfppH1rcZTW7xyk7L9z/6p7F6wC8//4uckk9Rrr7KdDonTBUf++5NXp+9ynO/bOhajRZ9rh/sY9IZPvUhw6/t/TIHX3mEYVyhV9dUfY2Ughef32Nv5HnksSnPvGcNXa1TFBWz7pDj9pAboz3u7ShkaqFzRNmRfI+r28/w7LnHqctH2Z++imtarB2RfGJ97TRabtKuDpiHXfzCbllJRb1Wce3mXfpmkyAqxpM59+6NKWpNG3fxbY23x6xXa3xs9ZMYs8b+rVeYTY8RURBdSzud4FxHWRqEBCkVWuZEq/Qe7xymqBFKkRKLhKxGmxKfcvW2TAKkICx67dquJRFx1uJtR/SOFCI+WKq6hiCw1lKYOldfB8/+wS5ltUpVKaJKhOTRlNhuRudmmUyFprVzBLnKWkpFSoqmaamrinnrUVosBrVE2auIeCaTGc4FQoJ5O8co8NHhkiAgiaEjhhyAKaFwbRYFKEEWAHQOKyKlLuhiR1Fo6qIkWI+1DqUlwVuEUnjvCSwMPKSg61rKoiSgKHuKmELu5x1S7q2gDSRw3iOVBilwnUdKuahADgQfEEJjlCGEQBKKzjmiVhA8ZjFImShouo5eXYPWBKEILhGlzNWsISC0woesOhJSorXBB49WenH9Fuegy+dXSoV1HjBAtv/WxhDCDOs60mKQLHSBEJpKgxKSg+kUOktVaYK3qFKjhCQlQQwJL7N1hiShpEJJsXDfyH3G552js5ZSSpxL7B3ssbWxjrWO2bShqrKwoCwrOmdpO0cMkS4FClNASgQfQKSFXT04HynqkqKs0FpSKEkMFqkMRufEtFQKbx1Kyiz28J5h31DQY2JnzKcTilIyrPvY5PHtnKgivULRhURaXIuQAhKP7RqilBSFQesCdMRHkcUYSSBRmLJAJM+D/ZV6/SGTNuHDlFpWiNZiVeT08FGkKLh7eI9BOsXRaJfp7IjNjS1am7jQW+Xrv/VFzCuR7eICl5/5CF/77G9w++CQldOr9NcLjIicrleZ24s0kzEk0Ov/f/b+O1rT5L7vxD4VnvSmmzuH6Z7uyQPMAAMQgSDACIomRRIkpTVpWVp5j461Z9c6ttdnd4/Cyus9XtlHq9XKq0RxTYqZtERSFANAECRARAKTMMDk6e7p3De/+QmV/Ee993aYgAFESqD91jkzt+97n/TWU1Xf37fqW99fTiJT6rJhNJ1i/ZCFpQ6jdQsuobJTJqOGleVl2mstDqwuUXvI8pyqP6UcTmj12gyGFauLK4Q0w7qaxYUFatuQaEF/t0GlHp1GZ4LGVCwvFUhR0FjD9o0dOsUCIpEcOXwYHxQmcSS5phw3pKlGhAYhamxa0aoEF75yGXYeRw5v0JiKbtEhXThAEwzBWbBRwAIxx7yzBulBC4FKFDJIBB4lJEoEkGrWdgwqiaGD8ZLSWBIlSbRCB4sSEuejpY1xDSEIGuNIsxyZJEiZ0zQNSiZI4Um0IEssAkmWFwipKNopjbEonaATjUr0zKYrkCiNtRVCR1EPLgatSr5luH5NiUSXfWayT+BehzTfJMHALSrFEG4PqW+eF7g9n9nN4C1e63Xyuojbj9x/ztm991WPe9cRnjBLVRDY2+0vQThkiMd7KSJVdx6PQogQbXmCxItA0lqgW5d84XO/yT0PfpgDhw7inUPKBER4TfAbQgwwA46s6GLMBDPdJmut4EMgbRWotMsv/fT/zOoyLCwdI888thyRphkhSMp6m27vGBUZ557/fe5/2/vpLR0iKzoYa6jrEhksiws91g4cpZ2vAoKgZhMNnjgZgUCKsB/73xlE3x6w7hHtO9/Tre/49nP9LVMuf7Ytteblm63cbKtyhnMemOW3EuGWxuhnZOz2CcNveoIeYH/8e5M+d2t57d//5L7XaydYY3mjSY/XvcYt5wgR47LZvGh0NiGK2ISUtJcOMxpug7MgU4J3MdUSJsZEziOVBGZpR0R0TKprQwiOQHTaGY3HBBHuHLxQQuK92x+flJJoLWOONO8AT5opZJKiG88Hv/07+OVf+U1evbHJ8899hXseUbzwlSdYPXwXWesAZdWnyHoI2UHgQMzi6umAyWgT7wJZ0WblwIM0YgrBU9cjTDPBTEpsKNm8do5O0eXXfulfsLG5xcc+9lGmoz5/8Sf+Mv/0//Xfo7zhP/nr9+LLKQZD/8Z1VpdX/p3e6xzD5xh++zu+/dw5hs/Ln1aZY/hryxzD5xj+9ZQ5fs/x+/Z3fPu5c/yelz+tMsfv15Y5fs/x+43KW55pL5IpImkzLA+w/Uyfk0dq0lRx9dIYZMKRU3cxvvA403KXtNOi1cnBGwhjLlxaZ6V3gNOP9pjoc2jamKFn1O8Teg9wpP0g16af5uDKIml+EBeucDB5J3cfvs7mrqW3kCGcxpqTbFQjrq1vYYcVuVacPXKape4qrVbK1PZJ5BeZqOvIeoWT3YdZOXuRsvkK/WkXExSNW2dst7i4c5Uz/u0IHAvpIS7deBwxljz7/DInH2x47P2WhextPPXCZeqh476zD7ByrEc5+gotZbn3kYOMncVPAifvfxvp4hbnf6PP7pUC/zB00jaZVKh0jd26QhKQfoKvKpyQ5EmDDZ6Xblzi6Ooii6nghikZlNdZaa3SUQsM6yFObXJj2GetfQglY8cPeJYXJMuHwAwNpRVsXC050TZstjdo9xyJ3mJFKt7VfR/CC65ffolqZxuRZHhnGffX8bXHO7CmRmWKPO8AAWkNKYLgAk56hJYkaYaU+s7hEogW3QDGGZyLu6+Dg0SlNLahsVXM70w6W4ROqeu48O6CBTthPNkh0z2Wl5aQylE1E5ypsc5imoD0miTL8b7Ge0nwIi4eCUFdGnSqqa1FqoQQYu5p6yRF0cWHIdQO52e7i5WMTZOAUhpvK+raoJwi0Rl4qKYlWZ7HBU0h445s7ylthW9qEpXGgU0Sbe6FIi9STO1IdEJjKlKVMJ3WJEmKsRYtwZtoqS4EBOcxxuCcoygKrHNIKUmSNFpyh9kOU6lBgjM1Sur4HaSgNjU+xJzvOvi4qBcCSIkTEudcXBCX8d/SNzPxgKaxDh/VDkgRcM4jlUbpBCFmAx7gXWBaVagkiUrREMiynP5whE4zqjougOqsYLixTpHl1MbGXe7WkTsDTiElpEkCCrRSeCDTyWx0cXhjoxtBgLqqolgDwdZOH6E1OhGYxtDUFQhNkecgYFo3WONQUlM3NUvLXbyziBDvo7XGGocQkixLSPMMSQDbgPDY2sdc9rZhLxgoTY0Inu3+DlL0WCpaeOdwdU0zmeC7SwgtKZuGIs9JlEJphZnVv0ZhTI33kUxYZwhSEFB4p7DGIKRAJZraWIRwtwTJAuugv7NDECCNZzjYYqgSesVJLt24yKiagMzJq4xGZAzKEdvX+qAzFg+1sWXF/Wcf4saVi1y6/gpSZBxYO8i4FGiVE8aWXjFFNgULnRWm/SHDnV2QgURJsjRj1N+krXrYIDh6YJnxcIwtHbql6BxtsbDW5frlHdYvXMJNA5UboqWmtg1OC9JUUY4d03IS25ZUlHXDyuISw/ENpFCsLh7i2o0diiyjv95n8Z4eIXiss0wnU4qsS1l78nabxcUFynKbMDQML12m2dkhk55ESEg1qWwTvKUp+7Q6HeqqppUoZMgoqwpjDUmSoYJEeIc1DTaEOLYpDXgICudBqWiLHySkaYs2Eq0E4MAHlJZYDwGHJCVLC5y1NM6QkUIATyDNNEI0KKVQqhuFRDohCIlIMtpFlxCiYKdIJVInFG0dbSiEICiPELFfSiGRt/Ler7OE21nYLUHhrYHwmykhIzGPgfWdV79J7u8kdHtqxJsn3aKjvuX64Y6fYnby/jO4mMrCBze7ppw9T4rzDqkEwQmUDngZENLPUikopIh53LWWdNZOYpqCn/rJf8Df+D//1yy0VgneE8Re0BnvGQmDxGMRPgVpaHUP0N+8gFQJSndRquCLn/1t/u1Hf42/83f/Jiu9Y4gk4E3NznCd7uppytEGRdaj1VvkzP3vZmH1FMtrJ/Dec+HSZeq6QWnPocOrLCx0Y4qKEJXzb/Qu3ohkh3A7Or9Z8C1EnCzxwRH8TKEuFAR32/v8Zio31cEAs90K/77uOSvfbHXyzV5urb9oDelnJE2An6WiEG5mnwi3TsWJ/dklbhtf9v/2TVjeyObyT6q8lWvtHfNWlelvVpOxzj1hJsqVUhNTA7mZOxIgJZ3uAk1jSfMWUEUFfhAE6WDmNCSk5OYuJMFCbwH2le2S4WiC8zEFDdx83+PplAOtRfQsjkUKvPf7zycQTCZjpnVJZgT33v8QJ08e5/Gnn+Hpp7/Mo+//Lh5553tI0xY/85N/n8NHjvNtH/p27n34O/HOkCRdZGjoLBwnaa9QDjfIky4b60/TXTyDTHMOrR5nNHZsTrYZb75K0VlmVI34iZ/4Cywduo/PfPbz/MxP/U8EFbi2OeL3fvdjOJ3wv/reDzPY3eHgwTOzCddvvMwxfI7ht72xOYZ/ffeclW+2OvlmL3MMn2P4HMP/3TF8jt9z/L7tjc3x++u756x8s9XJN3uZ4/ccv+f4/fXh91teGG8YY8tV1g4uY8dt7nnoQZ56+XlMXWLHii986o+wwrKwEOiIDtYrBrt9XGLIWymZgGv9LaTaoOyPsaGGtOSl+pPcv/QBDt/9IIvLsOz+MnK8Qaf1MAeKJRZMh4dW386uPE9HHOKy/x3+QP8a050uB5dXQU2obZeJ3YJkwsLSAtviCYSf8uy1Prns0mnDUjHmkeW/xo1qnVZ+N6vVDVyvwraeRegWw1GNrXIubViS7jG+9W3vZ9Q+xyC/xonsPk4cPMFL/Y/zra0PUf6EYK19Ems9u+IZmvAsycDw4Q+eJs893d4iWp/ENTWTMGJkQfolpIChbdA4fOKpzJgLN55gVB7irqN9ajvF1wlTM+XA6il2kz5pnXJk4SiJPTAD3diJDi/cxcbRqzx77gLTqxP6W45Xu1usHs4psgFJVvFg+yO0ydjpD3CDLerhiDpYlM4gpBg7xZkGHwRZEFhXIfMcpCQogcoTvJLImU7EB4+3DiFjx9ZJtIcOIe7iLssJAomUKeW0jwgGrQV5ljMaTmnKCe12m7oxs1wHDoJnOqhp9doga3Z2NynyRerG4LyhaSyZjgvsxjcEDK20wDQBpQ3CCxrraKYlWZHjnCHLW9R1TZJ1KCdThIg74o1pUKlCeYl3Ie74llEto5WiLBucjjusVRAM+wNUmoBUtLICEDTGkiQZznmcC0jhMY1FpUm0stYZ42mJ1hIlYt1V0xIlJV4GnPd4rfEBEq1J8ox6MsYLaEzc0eqdR+kEY2p63S61t3h7c1ATQqKThIADKTGNpa0UeI+3Bi01aZoyHI3wNi52eh9w3mBqQ2IMKIVQASkV1jqs86RKoJMMpWKeaykVOgVlLdNpidZxV6v3Huc9Kni0UiRJQt00DMcTrI/1gYr5kI2H0FiyNO7GztIUawxKa6SK7gEQ25BWCqk1GTlBNpSjkrI2LHbaONOAsdMtCwABAABJREFUdxhT47whz3I2d3ewARQKHwJ5q4VKYuCupUIoiZYy5gTSGqkk1hpypUm0IjgXpR1eoZXEh4DUESScC9RNzbSu6ORZtHPygtB46rpG5znTsWdSBjptjQ8GT0wloHVGWhTRnl/4uCNea5wFIUEpgRCB4O1Nke8tYH5t/SpaZuiiy2gywIZAUgtoHGV/CLVAqkCS5YhK0826XKlHdFbatFsZh9dWmTYlO1evkeZtlleOk9Jhd2eHIjWsdBYZTz2JlEzGO3ihaC0uIfojlhY6rFcjctWinFYkwjPZnpC1F6C1xeLJRQ4tHyNMp6hG0NFddmwfUXlsrqgHNWoyRfY0XniMnSKQGFdRtNrs7AzQSUGrV1AaGK6PSY9mWFtz7tx51hYXuXF5nU4qEH6H4e4ueS7ZGFXU5Sa9pCAJjm67h6cCEdDeg9JgJO2iTRAZWjuCj8QjS3OUTma5wkErgQ+OxjRoqdFZgm0M1nmSJI8L0VoilEQmmly2YKaKE2l0W8CDtRVaCHSSkuUF03KMsZBo4vWtp9NJEUiU0yBi2oUgJGmSE7wC4SjyNhBQKkFKQZA+ph4QDilBq5jjSiff+I5x8OypnoE7gts9pbbcDypfl5TNiCthTxJ1+zG3B+B3BoS3/u3W32cTBK8TQO5NEwRAigQbh7tbrm+jbZAUOA9SQLAG0Ajv8QicAoJD4bF1g9Q5jz7yDrwb8vTjn+L93/b9SKEjHgVPCCHu0t/TRgqFFJ4gQAG9pSOMdm/QXc4REjZvrPMXPvID3HP3+9BpwdLhe1GiwQ0zkqLNofZjmNCADKwdeRiExAeLCAFbNTSNxXvH0aOHabc7EMTMDeUW1fmdNfl6dSX2iLjk1p0Itx5/mx2TYDb+WERQOB/TTAih9tvIN22ZEQQIt42bb1QE3EIGZp+J1+sH3PbZ6976m3Cy4s9KicQ7RJGevHUHy95E2J4rxs0xaS/i/Was89eb9LqzffxJEvI7y5td+7aJ0b3jb/n313sfOSPCkQzH8TG+zzggC52Cm2LLPjrvxJ02QiEtNNqhEQTvY9qe2fOtrCzjfRTVegF102Cs23/+vbrUWiFEdE/Z+2zvcxvisdPphEQrqmnD6soajz7yIJ/946f5hV/5VT704e/j/LWrHDpyD//7v/E3GW9eR8qUxkwwTUOSdvAu4IUhVRLRXsAHgXeKX/yZv8e3vOM9DMob/OT/8q/w/Qs8/OgDmPMvsHb0HlYPnma0e5GjB3P+7n/zf+Pnf/Ff87nPfYG/9h//ZVaWcvrrNzh+9/2M+ju4YcXB4w9/A29gr8wxfI7hcwzf/2yO4f/eyxzD/2TLHMP//wnD5/g9x+85fu9/Nsfvf+9ljt9/smWO3/+/id9veaZ9ZfFBNnb7TG2fgdnlcLZAf1QTgqe97Kh2UzoLCxw4tMDD33aMx7/0WdphgbvuW+bZ53bJegnXXp1SXBKcuE+TnMrQRYNrVVwLX+Se4hS2zBGLl6ixXJxcJU3WSZee4rpYZ8PdIOBZsd/Bd5yeEBbPc3DhHi5sNHzq3DWKkWHxUMHW+DnGdY/FYpFEFHiZE2SfYVjnav1vOVH8GJ+58El6QnHk4EGkuJssG5P2JqycXOKuI4ZOuso1fwOzucmZpQ+zlKU8P/gsV7d3OaAX6SQn8S4gc0EvnKXy56DbJrQkB9pHoYb1YQkWZObYnY65slvipyWTieLwQpt7Dh8mbVvqasRq+26ssliziGr1ON9/hQtb1wlZgbBjnj73EoOt89T3WUjBecf65ojctsham7ilhKOtgpZyjNyY00WHg/ZhtO3SH2wwKrdRdYXSCllOKEdjlG5BAKkFUilEkiCKHJnGhRwvQGUJAhV3+HpP3AcZkMGBENjG4EO0Dpd6tkBa1zADQNtYmsaTpgVZljGcjrgxHdLt9ghBzTqoJW3llHWgUBlpqtju30DphDxNyTLJYHeLVp6RZS2cyylNjVQKJVsxCHMN1ghEHfNsl9OKLM+YTkukTkhkB0+FdYpJNcYYR550aaoSqQRJorDekKYtptMqLjoLZoOAxzUNI1OjdYJIoGwMOEikIpUarxS1aVA6IdESkUimVUlwFufjIq3SCudiMOGbhrKusakmzTLyLEWIAFKSZCk4h5/tCo+RWbQUSpMcYwNVbRBK0S5aDCdjilaH4WiCltEGPdEC5xx1XdJtd3HWxIW1IsPWDUF4pBAEF8UOjYgDrfUBMVvQi4GPxM92mTtvo8270KhUkqUSITytIuHowVUwNTLLGfYHdIo2xs7s9DOJVhoxC3aF2BNYGOo6zPIcxeeRKpozCS+ws+fwaLwPKAR5kTEuG3qLKxgbd8M3LpCImOciL/J4bW+RUiClxlmLEIEYAsQw33niDmIpERDrR0bXbR/Ae4cSIILANAHjogV+6Qx5iE4Ki8ttbO3xQlDVE1qtFB8kgmipH4QAKdBJDtbhrMR6T1k3TKZVzKvkRew/WuJnbcNaC8HRXl6grg2iLqPjQJpweeMSAU2SrzIeedZ3zlGbQGJAjkaMLjdsJ54H7rmbwe6YlSMHSboppQucv3iJnWs36OqMrXSDPMkYDoYIr8hzgcg1dBcRBNKmonE1x+9ZJXUZly6uc+y+Hv3tkqQlWN+9ih14qCp2hhuUiSZLJQuLGSEF5yYz9a8jz1OKfIGi12Nc1fSvjijSlCyBi+deJtu4gWNEYR12MGAsITNTvCaO92lC6hVpp4NaPowQGmMCIXi8APAIBdJqvIriF1dZgnAopSCAFwqdJDR1jQ8WfHRRKIoWUkaLGKUV1jZ4Z6JQJilQKiGIQNPUJFIRvKdxgVaWoGWKaQTTssR5QZJltLuaurIopdAhIctypFKAJk0VzkfhhJKaaPAQXR6isk8jFTRViVKgdIKUCVLHe6WJmvWVb6zsBWQCCD7MfrlTlXxnkPd6IdweuZ+d4WdHyZs2Ym+kXI9B5K2fvX6wfVuwGQJSCBAOqTwEjXMBLVMQgYBFCIV1Jede/BKdos3a8QfxUoPQyCAQ3mNNg/Oe3Du8m/Loo9/CCy8+x+c+9Zt84Nt/BBtiegeB2H9OGSuLMMuXBgaVaLJikXH/Gp2lI5w8fYaVlSPU9RjrSor2KsiUxYVDCBXwvkFKhfAKIUsCbaSQBG+ZlCMm4ylKKXq9RaRImClwbpLsN3gzr62zGCB7b/cFVHtB7OufEAm8dyDwOOtI0oQQxFvhuf8BS2y74o6vdZPAzcrrEqO9XRNfo83Ny59YuZW4RiLuYtsWxHFPAAiUVLNJPjlrgzGPYZiNXHfuTPhmmRx5I2K+97fXK2+FTH9d7XHv2Dvut3//ved5g/t9LVX7rT+Dd7O8jwrnLOAjhgaQKmGyfZ728klk3pphW0AHTcylOCPygJSC++6/D60F1gZCcDSNJ3Lyvd1CN+vCx9lXtNZRmGmju5JU0dZNCsik4tWNHbyp+dC3f4if+ulf5ca1ba6+8izNuGR35xJrJ0+Rtqe8/OKTLB45hTWWVA/JWz2cb1AyJSlyvDNU0wHXX73IU9aR6R7vese7OHjsBJ/+1B/xQx/5CZZWj4AqOXLXoywsjRCh5r/+O/8tP/mP/x6d5UXOnL0bO9khLRYpPPR3d9/6O32998Ecw+cYfusJcwy/8/x5+ZMvcwx/bZlj+BzDv94yx+85ft9+why/7zx/Xv7kyxy/X1vm+D3H7zcrb3lhXBUtsvGUPJW0VhPOXTmP0Bln7jnK/e9Z4qO/+Cxrh4+gkpJLL19ieSlnMhW0Dgo6F1o88L41Fscb+FfWONBb4p1v+yCj9Byq8yoYQ22vc/TAQRbcB1hdWuDy+BlSOWSx/VWuT/ocqP8SX6n+Zwia40s9uoe/j3HZYcO+yFpbszW6Tm2nNE4w3TxK1lpGtAwh0+RymYnVdHWfMtnirlWFyDSXJi9xfesix1YDDxw+ymAxR/Y02BZ1vUkn6SKlZyiukNkpPZXSSw9g/ZQtt8Hm1pTR1HHXWkrayhmHMZv1JUajZerhdRYWFymbKaPpDnnikR2FSh29nqdONllOzrDaepDRdJ316Q51pengmAwarvS/wsRKljOBmA54+clNnLWz3uK4tv4UneQk73vsLupkh+l6iQqCykyR28v0umdpJlMm4z6+cjgHTTPF2JkFQlPhCKhckWXZbOFbI1RBkiYI4YmpBmLHCs7NIE0QpEVKTVA65uCuSpyraeqKpqppmopUaZI0ZzydUJZDCIEsLZhWNbs7u3Q7K8RbRqvytICynmDqhIXeIqPpkO3tLfIkZ2lxkclwgEeisg7elExHYxKVIQTIPCcvBFU5wFaeNCmQUpGkBXXTIIOgVSiCEDS2xlqY1hUyjYvVKg4T1HUZcyDPFDNaaYQAJcDYBoMDL8jygjzPCdZi6gqZahQeiacsx0ipKPIWLsQ6FMHTVHVcsNUSN8sVoaTGG4ucCQ9ECFhno2W5txCgnE7j4pr3GFPHRXlCXKRrPMYEEuuZTEuWlxbx1uABa13MQyEDTR13xkrj0TonSaO1uxB+Bm4S7yzBSWpv0UrFYBQXcx+7QKI1dW3wwuKEQ0uJR6FFiLtig2VaN3FBWglM1USFkdaxDog7da2pIhggcd6gdIJzUSmrlCZRkjrYaL2EgwC7wymHF7qs9boMJutMygbblGglwTgaZ1le7sDM0SBEhMA2FqkVSIkM4OoGlWUIFUGmMQYCKK0IPuZGUkqiiLvi0zTF2oaymqLyAqkUxnrGZcMSkl6vYDAY015q4b0jJWHqZ7uCJQjnZ44KIGxAKoGrSlzdx6ss2vDrFNvsBR8ghaDIu/igkEqSpAVbww26Rw8y8SWj4Yiy9Jw4dJoq9Nm5cZngpyQLmm6eUXSXGJdTpLRM64r+dIDZmNDf2SUETxVqtFWoXkJnoU17oUun1cU7zWA4YrB+GRU0opGMt6Dd9Zx6cJW1uwSjvmK0UdI9tszhI4d45ZnnsEqQFwlVNSXgEY1D24yyGnHqzClwgaqqEFLTjAzHehnjjS2arSv0rCEpNHK8TQGEtsaMx7RbLXSukMT6SaVCEbBOEhJF0KCQTHYndDo5WibITGLLGmMNqBTlBc55kjQlhneSrJPijCFYQzmdoJREBGgaQ5Ln6ERhjSMvMoSSGGtwlYthvJLIRNHt5CgtwWl0kiJUHl0SjCXLc5JURScHAVlWYEy0xVIJSGTcbU7cZT6d1gRjYv8PBpXEXOJJUmCsJUiBSjK0LlBa42d95xspLgT2NNgCgZi5jwRxaxD5esHga0M5IW7VPca+S7iZe0sAt/7yxkHrWws+hRAMd7fYHV7n8KG7sX7CeNLw6U9/jC888Qz33X2Ye+46xubuLh/6jh9ha/tVuq1VWp1FQgBTj1BCIWRGUCmj/g0qK3nsvd/HE5/7bb7wmY/yzvd890w17/fJuLMWHxp80GQ6BaXw3lJ0F8BVlIN1JqNNuosHIM1IEh2V386iVRL7g4xjXRAWIRK8N3FcFIJyOmJajlDKs7jYAyFn+X/sLFi+/S3sKa5fL9iPjx4FUHvCjz2ro706vL2uA856lExxboRWGXiFjF/+a76T/yBF3NoaX0u694n56xKNsFeJwNcmIrfd9hshSq9z/p/d8mbf+2t/t1sn4WIqG7GPd0JAcLe8GxGPiu/Jz44KswNvv97X8z7+NN/BrZORd34GX99zfr1t7Nbeets3vHVi4GvU1511c+ekgpSaMJu09M4SBAiRsrczJt5boFWGztvsXnuB5RNvQwoJilkOyYD3MaWKD1HYdvnSZURQJDrinrEuTsjc8SwhhH0yLiA6FwmBCB7nmpjaxEXi3h+XWDPhAx/8bu695xTnzr/K9RsvIr3i2WefZlKOGI+m/POf+lnuf/AP+bEf/lFsaHjfBz+CNYKXXv5jnn7iS0wqx0//3M+zs9NnbanH3XefJlEJK0srXN5s+NJTz7DU/ipHjp3lVPsYP/vT/4R3P3Kad3/nj/NX/tr/gb/0438ZFRyPvfMsP4LnypUbfPWrT/N33/Hhr+v93lrmGD7H8DmGM8fwb6jMMfxrXXuO4XMM/9PE8Dl+z/F7jt/M8fsbKnP8/lrXnuP3HL//pPD7rXuzCkk52KZIe7SKA4zFdU6uJnR6knPnN2m1ukybbaRpqF4tWDpWkBZdTq2c5Pza82hzFw8/fBfXkimd5CgfvO8jfGbnt/mjr/w63/PYB3GmRVuc4qp5gYP2+xjzEtY8wWi4iC/fhpUfZWv8WcbhHD78ED09pZsUHF6RtHNNspNyffg8pTP0skC3WGJQlqiRx6xo1MIYyiMMkoBUB1HGcmJxlWnyHMJssNj5IUgs/WabbqLIs0O0W57gFMKd5OBKjgqbXBte49DCMdb7A169cY3RQLDAGgePHmVnehXVGF7cuMYxgMygkmUS2SJUkjMnHqatdsiyZcZ2TFNbLo9eYDi5QUe1sFWPYZgw8Vc5e6qhVyzTzpa5MblO3Yx4LoMakCqwvPAgaSiYjCvqSWAhuwdFzYLZ4QTvxU8No8EWk8EQUwecnxB8Td3EBVYVDEIn4KOFdJ5lcVE1OITMY25mW+ODw4i4E1ulKQLwLi5+e9Rswb3C2wprGkxdY6uGUlRkaYrWmsYYmtGYkXd0W20Go222tq5wYO0YMssRwjMYj2jlHbwt2d7ZZGFplSQp6O/2KfuBXr7IcDKApqSQUbUymo5QKiXUTczNnbfJJZiqQqSO4C2tIqGuJaaZkmcpnXYPrQ3D8RCCIAiYlCXdTguhoGpqnBd4D5VziBBIEkVatDDW4r2lnIwpw5hW2iaR6cxSXVOVJUFFtZ8IIHWBEhLTNGgtyXROVVfIRKN1DPDwHqUE3gW0EDE/eWMJPsRF8yRhWpX44On2FhhNxhAErrZUXuBdVO5Y72msjUoeZzHO43zcHY3QSB1za8dd0ZI9Mw5jZwvhBFQicaVFSgiNxStNXTUxUJzhojFNzI1eGbycspyv0sl7aGcQpma0MwAHSjokAds40izatbda+czCviZRCcZ6XGQFKBUXpdMkwWoNIWCtwVmL8VG9liUC7xXjacVir6Dxksn2BkVeoJSknuWSbhVFBEUfYqAr43bwEAJNUyGCIlVxd7lxFi/CLLe0RgaPd448j30gSwTWCmrnWc4LijQnyzImVcWhA4cYj/pU1rHU7VCVE9pZm4lzOOfJkEg8aElQCucLZOJZzkHpLrX1aJVh3egmMApBXhQEKQmhpnIV+tAxxqHD4KUNzOYu1jZ89dJ1jLSIJuCNpLXaYjzd4uShQ9SqgUlDmEgGN8aMt3cZl1OEluyOpnSzgiP3nCDoQKgMo50Bu4MR1Ja80WxvlWyPBrTMAYYmZXihRn5pi3aq2ah3KQfQX57StAKFzxltDRFCcOPqJqGyFCqjqixX2GFxcYFRf0g92mJ48QKubNB5QvAlCwsd6rphMqmYBo8SEltZ2kJQ1pqiUGRpIIiUJgTEbNe2EhHYkzwlyxKSLAPnaIg7vz0enSbUpiFYg7MGhyBttSFRyESjvMXOnAJEkhJCtJhR0s/au0CgkXiSJEXrbF856R3Y4BBCkXa6aG8JQWCMJ9GaaVUhZHQ/8ATSROKcRAiJsxapJMZZkBJnHUFGNwFmAhSPiP2l20WnOXUVBSKmMW8Zru8sAUcIkZZH4nILR5mFQbcaXUXCfFPdezMQ3vssMGOI8cxwO00XQt686q3k8jYV8d7R+3EjvA7ZAkgzxXQ6JASHFim6KLj3zMM89/SXeeDMIzzyrg8gsjaN6VNYwx/+3r/kHe/5Lg4eexsqXUSGksl4HTe2TIxja/0yp+59D+/+th/khWe+wNVzX+b42bchhMDZJqZZEIogM0w1YDqqWFg+gpApIjiK5SNceOlL/Pqv/wZ/5a+eJc/aaJkTbI1IVBQ/qRCdZWQUvMTpi+gSEd+9n6VWkOR5Nvu+0T3j9XhQfCfxPYnZewsEEAFvLdcuvUQIsHroGEW7N6vNGWGYkR0fxOynwwaLmZRcuPQ0J+96J2nqkUEhpP5TITF3khbYa3N7n+8lbYEQbjbQW1XNe+3uzdTKNxXOsX72SctsLil4P5so8bOj5KynMqvgMJtQ0fsEP44PKj5tuHmHmwr4CJBRVT0jlUKCuEnWXtvE/0OT9delc69zzBtMYNx29pt/l706C36PcO+9Szmb5GPmiBEIs/Y8Gm6xvn6FdrvH8vIBivbibAy7xeJwvx3cJJ5fawfM69msfa3PvtZ3e7NyJ0F/s+u+4YTDrPOLWTuL4+3Nurt57dkk4N57m43Re1UuuPkM8Yj4fzEb5/dIdrilbQuhZv+Ox1vToNOZ4FGAcy72leBpLZ/gyitfpb875ewj7498QhF92gRRLBqvSpqJ/ScASJOEunGzybW9sY0o8PTE2FkotNYYE92qnPcIGS3d8jwnEN2GVpbXeOjB0zz+9Fd56eUp3/6d7+TA0TOcPfMAz3/1j/jzP/yjLC8usLq2xrXLr3L96rP8j//gH/Hi8y+wvTPGE7h+bUzjLSFUTMvzPPz2M3zuS0/ys7/4u/zqr/0RaQL/27/4A6x84vf56B89wbMXznPqbd9Pmhq+4713809/5uPIVHH85DMMbmzyAx/58a/Rkt68zDF8juFzDGeO4beVOYbPMXyO4X8WMHyO33P8nuM3c/y+rczxe47fc/z+ZsPvt7wwPhxcp3HrmL4lTXN6R3KyYzWXzl3mxjnFoSMZodUnlS3MuM1oNKTV2mWkR9h0l/MvvsL7l99Jt93gyxHPnL/IysGTnGrfz9WtFznW+j7OX93gwbVlnt39LMPJEuu7Kzx65EMcWbqXQEmv8ygXSs1h8yEWs2Ncnvwmm5uvsJidYjG/wbh/nFS36FfQ7Z1GJiU+HaLKaMVcL3QJoual4SfRowd47OyHOL78NIt+kZaELD9Kua7ohh6dLGE8GVNNHFUYolSN91CWuzwz3MRMWiyLFu00ZeJXWO9LpsMeqfC40cuMtSDZkohsl35lsH7E9vAKQwGuvYFwi4zHNYkU9NIVlrOjTLMSm1zm3Sce4dyll2jUBg+ennJWvZsHTyt+PX+KEWCs4sZWxUo3wPQapb9BNRqjveK9q+9Fh8BgZ5NqVOIbT9PEnZTOg7ceYwy1NbS6S+R5B6QDEUgThZICJQJNXc8WihSEgJICZ+q4k9nWjMcDqsYiVI4QCts0NE2DQBGQNFVN3TRoJKIyFK0Wo3LEzu4uRatH4ydcXb9Gd3GZNMlJVJutrSso5WkXy6yv71K0Mg4sH4gL6Ts3WFk6wKDaYXtQkSeaBMl0MsKqEPOmV4ZEaVKlmJY1Sni081gEUoMIMVe4856V1UWG/Sk+NHGRfTJGJzHHtRTgXCBNEqq6wnpLfzAhUylZmpBlLQiCsm4w0sWc1lqRZGncaWoanHNMp32U1hTtmPN8MJrQKnJSCSE4BIEsTamrkiTPUDqhKicgJE3T0CpajEYjsjRDJprxeIQNDh8UZV0hTU0iNVVdExLNpG4QxoJUOA8uCMbThkTFILFop5TjEuMdzluyNKGuG1p5hrUGqSVN3SACZGnKpLZ4FwfLJNEYW5OkivGowipPIgtkO6GlgWBYLDJ2soRy0tBKU7z3KCXxQtA4z2BS4mZ5ya21KKnwwaGkQIqAQJLIaH8tlUbMBuDGW4pOgU4Eic6pjcX6eExZVfQWugQpMT4gVILQCpUkCOtpTNxBn0hJYy1CC4JXs0ArWqo3Nu5cV1KDkKhZXJVoSZGlyKDotDKydkK706ZoKxLlqashx0/czblzF2i3llg9cJTpZEBXaaYOPAK8I00yJrVmOKlpmgEyVCz2emRZznQ6RkgRlV1E4FSJxklI0KRC47TGlg1he4IbVRhnSaRiXPZptzLqccW0MCwvJdzYPc+yPMFwNGRa1WxuXUc7SBPFdFzSPtChvZizsXmd3et9xsMpbZ0iXU3W0mxVDShLt9NBKsFge4hKJL1VxcblHfCB6xevMR5sc+Bwj/6kpru6ymB7i0InhHZKQyARCf0rLzM5N8aOd0A4dJAELKGsKBZSXGhoJhO2NscsLi+wvJCyUTZcuzbg8LEVOt0OgpnVvoyL1RIdSQ2OVlGASKibuKgudDY7JiCThFaWYZqGEAJ1VZMFCCoS06zVxZoaIQQqCLyzoCw+1HjhITT7bSJNU7yP4b0UGuMMkkCSagiCVEchhlcB7w1F3kJoiVQK6cECWuoZoZIE4uJ6kmSIzGGDRymNTiRSScqqRsqowFNo0iLFNBXh3yWGn7lHQFywJ4S4g32fmQuCuGm9FsIeUb4zcBfEBxH7fwsxY00kIfsPObvmfgA++/S2YDPcEoTOri5uzXs0e3TvSfMl7r3/vTPOpNFScvaBR/kv/tbbEVqByJHC8PTjX+CpJ7/M3ccKpFOEmQDB0yLPVzj//GeY7q7TShcxzpLlBWcfeIynPvdvyXs9VpYPM9i+zvLBkwgVnyVpr7E+eJHy6sscPHY/3jtEAJV0OffKhTjGeEVtxlTTIQvLBwhYCHJGsD1BCIQPOGbMWqrY14VABk05mSLkLBid1X3wt1ux3TaJMasvJx3CWya72wgCv/Ub/4Jv/e6/wEMPvZcQFEG6qCq1E1xIkTpBCIUMgTTJGe1eIVcZk/41TJ6wsHjqNgr2datnv4by9dbJoFvJwV5bi+kFBHs5lITw+yQ8nhwnNeQtKtxbbj57dg/C4XxAiQQhIuELgPCRYAg5a5sCnLc4H5DCY8o+Fy+8SFVPWV45SpbnjIa7bG9ejxNNKuXU6QdYWTtK8AohPSHEviNmVlNgY1cAwr7Pzr8PAv5WSPatx976bt/gnPCaf7zmgMAeUf5a992zaQv7EyFxtijMyDqAxDmDaSa8+NU/5Fd+/pc4eOggj73nW/mO7/kLCFEQvCSoOBl1c7ImCptey2Vff2fCneT4jY55s3Ln9923XrzjnrcSbbmXoPFNymvuuz/jGcAHvAwQRHR0EtFHM1rfeQQx5Ya4hYgHf7tVZxQNMttk5GdjDfEDMTs27LVdeXOSSkikzmKKIFuhZDabpLIIFAKJCw0nH/5Wnvvk77J5+SVWT92NbCReSQieZ770cRZXV9na3uDK9VcQMuB8QyDgrYsPMptkkSJOEkgpsD4KPYO8JT+eJ6rVlSbLCkbDfozrTGzbP/B938fP/8Lv8MSTz/DBb32YdtFDpYJqtM073vkgx08+SPANf/Dz/4rf/NjH+PV/88c4H3jo3qPcffoEnzGPs7k9wVUNl3f6SKV46IEHKFo5SZbwLY/ex4VzL7K9usDzL17kysYuP/lT/4jv+87H+PD3/ygf+9QzPP7EBcy0ot0u+O1P/ld84YmPfM33/4ZljuFzDJ9j+BzDbzt2juG3/v56x7xZmWP4HMP/vWH4HL/n+D3H7zl+33bsHL9v/f31jnmzMsfvOX7/aeD3W14YH/dfZlRfJ4SEYz7D32jjFxO6iWfcKWmdHBKyFUZXQZuEvNvBJX2+8PjTZEYzzM/zxecLpuIG7z/x/axvPsmLj3+VIyfuo+WfZTz9Kpu7nh73ItU5NobPsVteR7d/jWp5ha5fIPeP0HU7XKl/h6n6EEnnXnriZbIKDrdWuVE9wwsvObo33sZOsAzdJq2lKYYKO6lJnKSbK/Lz63zmypCr1TaFHPITj/5n9OWLdGlxaiXDJa9S8hyL4W100jMM2GJcrbMzcawt3I0aX2XoNW0Nm/WEVy6/TGIypo1hs38VVzb4pVWW76mZ2hHeSdpS0l+/wG4pCFmKKKesTy1Hlmq+9313o3sTynHC9d2MhEMcWX6F0ncpnaYX3sX96b14/7fZE0PZ+jpWHuTacIhOJLaa8vCBoxztrDEZbVIPJkymNcEFrG2wjYWQgo+qKxtqvHW4xtHpFSRZQqu9gNQJIXiyLMVaR1PXJDrgRcCHgDc13tVgDTIEqqrEGFBCElDY2W5lLRRVVaGkBAllWdEqWgwby+6oQectMCP6O9u0ii5SaNp5l6oeMZkMaXdWGYx2GA1vsLx6lJ5O2di8TJrnaC0YjgekWUbaauONoZrUSG1xTlMCeZojnCcTHl1oTAkieHxwLC52mFY1nTZ0u12GwwFNE5BaEQQ0TY0IEucc7XaX4WRIkmQkOmEyLSmnhjxPUVogtCQRMaf3ZDIhzTJ0kqKVpJU5amMYDwdIKen1ehRpSuMcOkmQAaaTSRQfIBgNhuR5QV1VJElCcA4hBZW1yBAoy5Isyygrh0RGK3AFTV2hioyqrFjIipgv2zp8EFRVTUg1ApiWMXc53jGdTsnSqGj03mODYzyd4lzcndoYi/OeiJWKLEuoG4VxjiLNqK0FV7G0fJADHc1gVJME6LZzNnb6COIueKllXOSzDlPWCCVIkwyNwhqP1mrfXloCSkryvGBajQjEHe9S62iJT0qRJ/gkZToxmOBIsxw/qxslJK1Wi6zIkBImpiTq32BcVeA9qU7wQlG7qI0UQtHUNcqDUgmauHM9SWe5WGSglUk6WUGat1BJipRZtJa3NVm3w8GDi+zsXqTXOUVatKhHYxIvKfGUZsK0mjCtNZVxODPg8MoRjPWEYHDBIYO/DYiN86SJxguJsIJyOCJIjxMNY19SZDlLC0uYGzXtLGdaDRDkHDsiaJBsbu4SbEHRa7HUHTLcqUmKjMVMQ6JITB5zk4eCwlmKTOC8oEhydAr5Woe1Q22eeuYGUhimo5osWUAVnrtPn2S8PuHS+jqmqpn0p4TDjqJT0M67mMmYpr+J2dpBTHchlSz0ugRvqUwD1pEXLdpFjnUGpRStoqDbboEwLC5nHL+rS5a3aOoyEiOh8cEQlI4JC1xAhPieaj+zvFISlWb7ZEVIEFKR6IRMa4o8x/gwC1Ci+EIINRNvKIJQCFIync1y7UTDM6WIdugquh7MDA4QKonWMS6g9EzNikDKKN5w3tHUFikVzgVCQiQTM3cGrTUgyPMcL/ZC20gcilaBROAC1HVNURQUWcrE1m8Vrl9TBICPSlCIgaInzBSHkWBLwHELWdonVBCCm11J3gwQgT2VYywxUA6BfXIeePN8Wa9Vb75+DqpI5OJnUniMmTIab1ENRsg0IctTxlsbfP4Tv0ln4RCPve9/g9AVTdWnKBapmwlffeKj/Mav/isOnT4B3lAsLHLPw++iGfY5cfIhPvZvfolved/3sHxoBadSEhtw0qFRLK/dxY3rz1MPN8kXVhBAtyg4e+o4X/jcp7n/oYe4dul5ut3FWVw5q1MpbyGgsxoJRKIeHN7FwHc4HETlafDcmsvpVpVrCAFvG4K0oLsE07C9eY5O2uOLf/zbpJ1DbF6/ikSAEwjt8ALKyZRmusnCwnGCHeBFDtYxHPUZ7e5QZC12119k6eBpgtJ7Efr+Pb8R5fobEpqwpx+POyBilUQSEPnVzfYVd1gEQN42eSPEXtj62nvEdq5Bxvp2OIQHicLtnbI3WYEiOBDSxbQmtuTl55/id3/7/0NdlkymJQcOHOCDH/h2Xn3lRT772U9TNnDkxDHuue8BnFPcd88jrBw4wOGjxymKBUJoIv56sd8G9ia+wj45v0nS4I2J41tXUIfX/NzrK288SfJ657/22nvTbq/bAvYI8VuYt7lNse0DQd60GPRBQWiopjtkaRfvHUpIzpx8mEcfeZIDq3dx+dyL/MrP/X0OHznFkbvu5vjJB0mTxdgWZraHfjabdfu4dXNnwZ11fOc490bP+0bl9frG6533lt7zXt3ccl0hYtojKWQcJ6RHypgaRMpA8G42hkdCHoLA42acdjbZJQUyBMDhvEeKBD9zR4nnRUIRrdlmY4xjdo+Z6w4GIRP2UoQIpXHO4EONlhlCevBg3QRnDZluceS+t/PMZ3+Ddy387+j2egSZsHHteX7r3/wyv/cHT7CzM2AyKUmUjv3cR5X5HqpAwPuAUpKiyDGNwRqLTmZphwSz8SPEWDsvSPMqOhJVDaaZ8Og7P8ADdx/hyeef5flLz3DmgQcxleHBBz/AlUsv8tXP/T7Xt87x0ssX+eRnvkjAodMO73znaUb9hoXFLqfuOs37HruP3/n4Z7h8fcg//J9+Bh9fEmkCC4urfPbzz2N8zcaNHf7xP/5pbGM5evAQVVOxupqxMyl55sXzlPU37viyVytzDJ9j+BzDmWM4cwzfq4s5hs8x/M8Chs/xe47fc/xmjt9z/L6tLub4Pcfvbzb8fssL40nvGmJ3yshf4MZunxY9dK7otD1n7z3EKGyS6aNULUs9MBxfddz9qODJF2vGm3D4gGGld431p7f5iv80Z9v388KVpxiNDvP29l2Ua59mfSSpLgt6nGCqXsWH67z8UpcXr1zhPXe9k15ylA2xBH6HqxufpaUG3LV4NwfWHuLy9q+ShzEfue+/YOvwS1y89hlqe5B6e0KSS1rJAv3RNi9sT7iwnWCc4NkXnifNA77+LR44e4xHlu7mYvgEX7zxOxwIGd+hDyPSFuOkS6+4B52e5+roRXacR6pVboyH3Nh9lXJnheF4EzeZYoOg6AgkV8iKU7S7C4yqCarq0jRTdsrrbL80obYWV2kOP3iW6STlev08h/Q7WcjuJpUtDq6epFGv0JUHKJuLvOQv0FgLGpSCe++5QjW5xgcekYzCMmGywgPNSdR4wnhSYesGpS2NB4JgMhrgnKfV6uCDRKctkiTDuwh8edFFpgVJqpmOh+DiYk9S5ASvsC7EIUMnKK2RTuLH05jT2QWaWQ7yIAJIgakciQcXLHmnoBkNGQ5LsjzHhBLjK7I0YTiY0K92WegUDKvA8toS1jj6uxusrh5iMhrw6ssvc3j1KIudFS6tX2NxcZG1g4fp7+7S7w9pdzsgJFVpKFoJw+GAIUN6vQ6ucYgaeu0lvDOQBqrplCxrETIYTcYcPLBGv7/LZFrSarcpdE7TNEwnJdPxkG6nzXg8YToxdLs9CA5rDeW4QSmFUpJ2p0Wv1aIqp9imZFKVdNIWWR7zt1trGewOEAsLjCYlQsmYwzx4Ei0xZU0rb0EIJErTa3cw1lBVjjTRWGto5dFiuyQuqGZpRjUtaayjlaRxoNUK5x2BaEXeauXR5iLRTCYTpEowtiaEmMM8OI8n7qzWOi6gN40hSTNMU+Ns3LHrnSNJ0ugUYAXeB5xwHF0RTEyFs56VpRYvXLhAVRnavRzvLcaCENFimuCxrsE1hjRNZpbyCeBjHKgESiuyPGNajRFCE4LAeU/dNCRe0C00WMWN/ojd8ZC6MfFcH0jTuKNfhECwnjRRJElCVdUoIUGJmRVPtAjxPqCEoJUXaK2ROuaVbhdtEgVZqki0psgLvFBQC5pg8dZQNRZyjZVjlpdXGeyO2Nzc4ujJE0AXMxijgqdbdAhSkS222NnYRiVdtI7OApUJSJFhmzpalRCDB6VzrHE03hHShHqwy2jUB5XgvGDjxha7u32O3Xs3C90ezUWFx/DiyxO2R5u0ehX33/MIO5u7BNsQqgmmHqJMw85Gn3bawSSAb9DB0W9yVLuFEoHptKIxgfpa3H2fZDVKZ9TGc+j4AfJui8uvvIp3E4LXnDh1nLqekNaWybWXKbeuEcyEPCvI8wwF7I6GrCwu0tMprpWTKolrAgpF0spZkJrlpS5CWvJKEqzAVgaJRMkCQYJ0hhAcifYYAjptgVQEDAKBcQbnbdzdbRypjko6qTW4COJSeKy3iBAXqVUS/6aTBOkkUoGzBilmalhmFjIKpAxIBVIJdEzbAiKgixRno4Iu4FBJgTVxh7v3hhA8IgisiUQr5stqkNagVIpKC5RQNKaO6ROI95iMJ1SVZTopcc5QVtNviBztlcjFb6oOYS9YjKTn5nGBmEshhrJ7Z92qdrw1rnw926EwC46FEIgQRQgzJnonG9g/fi8Ijb/vBeyRwEgpokJ8j9QEj2ka6qpia/0c7cUDpMkKk8mQRx57O/c98m14Ybn88vO8eu4873n/d7C0dJxy3OfYkSN8y3f+KCcOH+dTv/NzHD1ylPMvfJHdsqHVWeGf/ZO/x4//pb8Koc3y8ioCicOis5TjJx/kwotPcUS3STttvK14x9sf5Hf/6PfJCsX2ziZ/7a/9n/A+thdCwHFT/T+bWZjVeRyfA6CUwtQV3kchRZzQCMQJiiia2qubJEkYjEdkuWb9yldQWLLuQU6fOM2XvvAZLly8hnNTpmaLPPRoXMVLz/0B997/3VHcESSqNmyuv8Tm7gbb1y7y6c//Lh/5ob/OwtLZGLC/3vv8Wu3rddrBne/45juVBBxCBNwtxCZazIlZPejZ0VE0FR0bfMyx5P0bEpwAoBymqRBConUKIqrVbT1iMtplYfkowc8s9ZqKcy8/ye6gz9UrF/jylx9n/cZ1ptOKwwfWeN97vpW1tTVeefl5inablYNdrl+9xoUXX0Eqy5Nf+AStTs73f/+P8ci3fA9Z3sM7NVMlOySKQFQU7+UUvLOe3kwp/Zb7fPC3/TqbDnjNYfHzAHfe883uI/Z2AbzefW//Tm80CTD7bfb/WwcQYjofD+VkwHj3Kr/+G78A5DxwzxkeevidaKVIc6imFZ/46L9lUA656677+aEf/iucPP0QqGQ2ZoToQjPrX27WTvZ2ROzR85kk7rbnu23SIITXfSdCiL0KvO37vRHpfqs7PaJ6//ZxcO/cuNvFIqXAeYkXFoLHy5uk2zZ1TIcjkkjOvQUfEConWIBYD0rq+G8CCD8j4GFmMRkiloq4iyaIiJHxK/v9SbPgDd5Gt5Ota89jSVhbuwshGl76yh+yeuAuegfu4tCJs4y2HmPrpSfpvPu7EbZhdfUMP/YTf5UnnniJ85fXMSaK0qSPzyKVRPg9/Ij12WoVKKlomoZUa5JUI7UAz378Bg7vapxw+BAYj4csTBu6y0ucvv8ezv3h5/l//r1fZvvcNv/5f/nf0l5b4czSt3HgxBnKqs+vffS/wogoDgyu5Bd+4Y8QCJbWOly5/Bx1OcY7cK7m7Y/cxdNPncM2gY9/4glaLU1pFC4IhPPoJOOf/tS/JFhHqlMWeprLVycEL1Gkb6k9vFGZY/gcw+cYPsfwOYbPMXyO4X/2MHyO33P8nuP3HL/n+D3H7zl+f3Pj91teGPcojhw4SkXD7s4uWa+DFQm+bnFg5W1oe51m2nDo0CG2y6s89vaziKWr3HPiGpfGKW97ZJ316hrl0wnXN7dIXzlPLy+YDA3jwVEOHDnO++9/Oy/uXCQ1BSutU2xUBV19EuUcO0PPpexjvHp5l/cc/x4q/wf0VcExHqXPBleKx+HwFsG/xJmVk5w5s8Wr51ZRyWGSJGdr/QqDxqH9KmFlip9eYzXPqbIJf3zlWSbJZ+ktf57ffv456nP3IM8c4vdSxWOnD/HUix9HJV1Od9e458AHOJitszHZ4gvjTTZGMNy8xkK2xOrZNYy7xLvub3P/PSfZskuMBzWhlGz1d2hnBYs9Te8hyX0PQNrOuXFjwtWxZPnQfWipSIuETfECq/JlKgQD+zRj+XN8ddPiDkXFoG081mzy9nsbTh4/xISX2OofYuHcu6jNDtQlWd6Ju4yrKuaexlHWFdPG0uktIElAKTrdnCRNCQKsM0gLSgqMqREywRqPELOlxOBxAZoQME7gUDjf0NQ1VdVgQyDN4m5pnSiG5Yg8Txn1+5BImuBxowm9Xoth3VCXhvZih93tHUYT6C602djcobfQo9PrsrF+g5Zu0em2OXfledaWDnBgbY3N/g793V0W2otkiWRjY0Cr2wEc/f4uRZ5TTidMxmN0t0cqM6pySnehjXVxUPYukGUJQrQZ7G5T5DmdVovReEKQgt5Cm26vwBjLcDim1+lQTh3j4QSpIUk0rVYbIaKVRFlOKCeBPIkLvouLy7jKMJmUtFttQhKYimjx3ilaVMYwGo7odTv7ecEbIdFCopVi0O+ztyDdaMW0nNLrdHBVQyYEgqhOElKjJWAcSaqx3mOtj7tcZwGsCNEiPextdw0BJeXMSjpgrME6iw+BIs0JwVPVNTgBQYFQOOIud4Kkdg115eisdlnt9TDWMiwFpq6RIqC1wjlPQET7nCDRUuCtReNR0X+DkAiciGqrgEQohQgB6SVIuW9x7m2FFJJUQYqnlWUs9HJ2B1PyIi6uZ6kmTSQCQ6ITpNQUKECSKYlxGU1TU6QpaZbGDCA+2rlLKWP7tzXtvKCVpSQaWkWKlhJrAt6OcWaKahJEmqCaBF128eSIxLN2+Ajrl8+zs7PD2qE1nK0JTmCdROzlPvJ9hM6obUVZBUbjkqbcjkSIm0FVbey+ikyIgLQB0ziKbsryckZvMaGaNJBO8Jng1EMHeeH5l7h6bpfr61d57MG7ePn3Ps7m5auQVthqipIaayVpCPhmHRk80oENAlM1ZC1NtdylUgq9cgRbejrLi2xve7JU4EMFQjHY2aKTFCzdtUiaSHavXkGOBzipyDFkqWFqLXY8JGstsDsZMKhKWqmk3cqROsWYgG0mFO0W7axFq+OwoUTYFCEsWZZR1QYhFVJ4lIx5wrf7I0Zlg9QanYxjniLronhDgJeQKhVJW3AxpYB1SATW2dgOfRRbWOduclEFDhPVeTFKimTAgwgK72d9iSg6kVIRlEDISBqVTgneziydogJWSUkINuZ3EQqEINGaJIntTemU/u6QylmU0uA9ehbP+iBACpwJJELSabeYlA6pX2tx9lbLfsAcIrnZI7y355eK5VajoVv/ukfibw28vb+dOLxGqRkTCtxyi1lgfAcHuDMQ3lP6QsD7vfNkHPNQFMUiRdFldeU4MkmQUlHVDQeO3MXiyknKcki3vcri0hCRCNJel3d/6D9C55/g137xZ/mRH/zzVJMR5y9+hQfe+V1Y1/Dk5z/B//H/8t9STXf42L/9FWRa8D1/7gdYWTs0c79IWF45zvWrz3L0zKOk+QLPv/AKFy9c5Xf7v8f//R/+QzqLyzHsl9GCSAgZxRWCfWKwV11SSqQAIQKT6RRrDFk+U7d7FyciJDOCF5WZFihaHW5ceI4nvvRpvuN7/xLjakDVDHnsvR/g/KVrDHbWufr849z90HdCUNx997sZ7ryKXjtNUuRAQGrNgYPHSa1lbfUUh089hMyTqGz9BgQYb6b83XufkXzE3QshSPacu7yPeMQsd54UkTxAbF8EP0s3EfEkkgZxGyG8+RzM8CTMiERM3zAZruOaEtdYTD0mLRawtuGZL/8e//pXfpFLl29gjaXXbdMYh3eKol2wtLDAhfMvcv3GdZTOWFpe5OzdJ2iqhlbe4YEHHuXqtVd57stf4sb6JneffYh77nsnaauLkALj96dVbpLCNyDht/ajO+vyTcl5uLMHv+mht/28/Q9vsDPh3ymHw623mCmrA7MXNasTYSAErDFcOvcSL33lFSbVlLtOHODBh9+LNRWrqyfQKnD+0hWuPL7JRfcSTz/xBxw8episWEMpgXcuTt7MyGQwBqREaL3/fd/om9xKyPd6anxnN5+VfWcXsf/fm419b1Ze7zleT/nuvQf0rGs4PBG3BWqmVK9pqiFeSqRMkIkiBIFSCUG4GUYFXBCziShgb0xCgtizRYQQBN7PJsxgFvt5PDM7RW+5cfn5mNpHZzzzxT/g0IkzVJMRztesXzzH6uoJhADrGk49/B5+8Z/+d5RZwonT99DqHSLXih/+8x9E6JSnvvJSbLtS4nygrhu0Vljv9q3nvIuuVUoJ2p02Uvpo65mkeG9RSqGVotXqoAeWxtRsD7ZYrfsMBls4VxFcQ3/k6NeSVq9HvbPN+uZFfvujH+Ol568Q7JhkNmY4A307ItEJ5XqJdYEvv3iRpmzI0ox3veNhrl3eZn13l0znKJ2ig8FVIaapEhVSaRrpmEwNeZGz0NbUxlC76VtuH69X5hg+x/A5hs8xfI7hb/BscwyfY/g3MYbP8XuO33P8nuP3HL/f4Nnm+D3H728S/H7LC+ODqxU2NKwur3D62DHKkUdVKeOBpSm2yRckqe6hs4LFU/dz9eIOrz57g2OLxxDqBmEpcOHxHu9+7AgvPneOSSOo+p5MCdavX6d92LJ65hXM9RXqOkWG09hxw9Jdx3jw+BmK6uO8nJ3i1WKda9MXWO4ss51+iV2zhQpn6RTHKHsvYpuvkNt30kk/TLjvMjdGCecufZ7xNOHu3ttJfMJdazmryy2OLi7x/JWLrE/6HD4QqAaSjnIMneTSK5cZH2jT7r7MsNwhjC6gzWkm1mH0lIPtg9x/bMyNi0+RrrQ4cChl7eCU1smENX0fB/I/T83n6evfoiMSLl003NhoY0Mg7+Y89fKAcRhx+mBKsvwUi62zmErQ9m1S1tgyl9h0FdafJgunKZJLKP1vAQjCMxrmLC0vEgRM3ALF6O1Qtgi2QYuUxlkaG3DO0Jgp1loEktFkStpqs9RbQCvwLtDqLJK3o7WxczV53kUnGUhJXTtCaHBNCQh8UJimYTotqcuS6bTE2YBpGqxrCCGhDnoGnIHJaIhKEjQaJTV1M6XcHlK0OpimwgTLyuoKZX9CXQWybkF/d4emaegUBUhDS7foFi2uXbvMwcMnyJMew3LIRr8frcsV7Gytx13gPjDY2aHV7VDVDa7ps7Z6gLKcULuaVl6gtELgyGSGIqBXljFlTVNVpFmCdVBNpngRSPOc3sIi07IhywNBZnjiwrG3FXmW0OkUM1uMQFNWNNZA45FBY62j6vfxAZI0Ic9zJk2NlIqslZPkmqosIQiEUnEHdLB4PMELkiRhWjUURYFpGhKlZznCodVKKcuSNE0JfrYrm2gd5Fwdd5obiwoCFyxppglYnLO00gJvYvDnjETLFAhY0+B9QAuJCQGI6kkRIvJbHwguWhAd6C2iQ4uqGhC8pDF2lqekoVAF5CmV8+hZnvrgHFoK8B4nw0ylZMizDPAY62kaS5Axgg0hWvkYY6isn33vgAue46urnLu4RVbEfDWBgPOzXbhKkSiJEiCCp520GFVTekWbLE1nu3k9jQFnXLTS1gEpFHFd1aKDJJVR9FA1HtOUdLsFzXhIUIoQJFLXlEFRiYy7D65hnGJ3+zpZltHtLLJ74xqNzLDVFEgwTUU7K0AKaltC7VhcWCTJi7g4GpEYgYuBkNAEYg4d3VOETNDqdjHe4LxmuDWkyJfZHW7Rv3iJ3QvrLErD5gvPknqBThVZ3iLJcibVGJEqEusRXscASSr8tKHbbaMzBZWh3Rh2LjxLe20J3euQhYRQZNzzzgPcuHQVt2OgP4WJYjQaIuqadjch1ZHKWevJ84ygBVJKur02h46sYE2NDR7hGpQUqETigkWicdaT5Rmmdggd8HjELN+78yATiWrnXH35MkFItBIkWmGNIU1yUHG8SQQ0JipatZSYxpKrBIhCFmS0rfHOUagUZw0+gM5SJHkE+yzFz/pSVOcFEAEpFQJFICBVXCRP0xyExBqDdS5+b2XQKr0Z+EiBUhoRiAvqziOTDCVzDh70ZFl0KhBSIqWO95ESRBSKqLDXnz1C/7vtOLtNSclec7szPLyVDOyRiDcL+sMsZn0DpWaI9vMiyg/3L/RG938jIhLJ7SwxgogpDkIIKJWBM4gQOHjoFIgUUBTdJU7e9y6On30b03KTEEDrRR599/fyL37qZ3FG8cqFKxy992E2NzbYuvoc3VbBwZP3ooNk9fD9PPHFj/HT/+K/5y/8xf+UEyfvIwRDd2WN8XCD8eZluouHWTh4gmtXP8Hf+tv/HXefuQ8RXBzrQqxL9n7sf/Wb9Vm02iRZinUVxlp8EHjnkSISV2sahAokSUp01fAQJEmS011c5ux9D1JVm6Qq48iJd9FZWuPM2af5ylefRN/7CFc/+bO8+30/SFr0ePWVx1nsHWJz+wq9hVXqeopUKWsrR/ihH/1xFpcPIWIM/pbLbYTljnf3emWvjYQQ9hXnwjucrbly5Tznzz9Pp73AyVN3Y40lURmLKwdIsjSOtyKJtlb7uxfk67Rfj/MGGVKcK7lw6RmqaZ88LVhdPUW7l7NHka9eepYnPv8JFhcXKKcVrVaH61evY43DC8HVKxucP3+Orc0rGFsipOX8+Zc58YEPsNRdJMsKSBqWD6wwqcZsXXuFF577HE89cT8/9CN/lSTvkBedKIy5g4b5mUBtL99V/F7yNcR8v67fRL2+365uo55vRqTf+G9fD7H8+s+PZFne+h0E0eGFQNX0sW7KsWOruGA5uHKYcjpFJRrvNdc3LnHqzHHO3H8/Rw+f5OChu0iy7iw9BUiZzCZ8ZuRZqhkpvalOnz0Gt+/Aec2XiNeY/eqcQwhxy/uZ/eXWMW/v5x2X3LOPe7NJlZt/n03bzYi/9zb+W7hZm/dU9Q5Pf+ljHD/2IEePP0QzHfKZT/4qjz70foajTZxPOHn3g4j2EsIZyukAgkPIHJ22kUlK8C6+C2Z9V4hZLkCJtzXBjynLKUmyRNbKECGhtkO0VFy6+CzCWbK0Q2dxhZ2NS/wPf/8f8O0feozf/K0/4j3Pnec//k/+Op3lU7h6xOWtbZ75Fz/Jf/l3/q/kqaW3vMrD734fv/Zbn41DoQs4G9X4RZaS5gW7/cGshgNN09AqOsg9YVka68uYOFEnlCQIyXA8JZWK0XTCx3//U9z7wL38/m/9Mv2NLYyR6CywM+nziY//PM899ThPPPMqn/vj84ynJVlCjE2URHqBVDkuWGwT30M5qVAkjE3JT/6/f5tupjB1E/mRHXPfPXdx5dIldndtVPObCucFPgh2t0cI7WjnCYeOHXmTvvHWyhzD5xg+x/A5hs8xfI7hcwz/s4fhc/ye4/ccv+f4PcfvOX7P8fubF7/f8sK4cC0sDevb15HpASphWO6dprfm2d28QdHWLGb30yrWKBba7E5yTqkGMhjX11m/1OGxo0fwpiEUEw4e67KVrdANh1nsrrI5fpXL557m0NIiO9MvossHWO2dpgwX+eTlL3O8811U0yky/wJejTmx9q3c4JO8NPwolZ2wHU7QLh7Dtb9EJb+PHfc8Rqcspu/nbac+hD1o0DJg1JgeD9DKjqHzlCOdx/jy5Z9ntTiId0t88MS385npRZ5//jrHTqScX38VUbdoJRmD5hpXLm/R0YL1POPw2kne/86zfPnFl9FpxtmT97Mjd3ny8pTSPE8phgy3l3noyHfTfu8n+e0/uMrdvXezejAD7qfyNUcXv8TxQ69S+S+SJB+iMCcZ2nWuWENpNDLd4YYcMnJ95CwnhNSBV4cdfvaThlP3TDm58DAnts5gR2OmxjD1FeW0wRpL09RY2zAclyiZkCUphUrpFW163bhgo2YBAMLjvcUFCLO80AGB9Z7GOQSapmkYlyV1PcU2DYSAtRbvHYkS2LokoEFGm+JESKbTEu0gTzWNkgxGQ6z19Do9pk1JWVasHFxjd7fPYHdAIgWtdod+v0+dleRpm3ZnCXTKxavXabd6JKnG+cBoOKbVyvDWszXYYXm1h1OK/s6IhV6HYTnEbntWVlaoqgbXBPI8IUkUZTXFC0u7KBg3hpBqrDEY6Vg9tIxoPNv9AZWN+RtEIsh1wmQ0osgSghZU05KpUCSpwHtDliRIkZDmLaypyYvWDC8VxljGgzFeeHSiybMc0wSq0tHptNkZ9Om2u4yrKVpKxGyhzLqaPM/wPuZn7k+2UGmOMXGR0fvZ4m4IOONmQVJcbBwNBqhCkKUZiDgA1mVNK2nhrKMyBgQxwMDTmAYpBFIE6sagdUpd13hnybKoIiyrimlZ4oLDeEOaKNIscG1jwvaoovGBbncZFwx23KCERARPliQoycy6ByQeJUEKi7MNhKieklIhAmilUTPpbG0sJsT2ZoxndS0nKxJ0omaLnpCkKS4EiiQhUQIZQBBIksBS3sJ5RaLif5WpsF4g0LQ7LYyvkCpBoVBSIpWkKic453EOaGqG9QhHQEmNUBLjxngmTNyYXq5ZWD3I1tUXSOQ6rbMtlheX2ZgayknDdHeTQA29jKaSDPsDFtop7e4C4dYFzwDONrQ6LZrKQqLpthehmzK2JQJoJ7B41yJXLlzjS//q96kHWywtSE4tt/BBk2UKYaJCzZomBsLGMZkM0DIjSTOcsxhXY40lL1o4Y0FCXdW0C4Gox4jdGlkZXAqXB5epxw4lBVoBLuDrEbkW5CIhhGiz5Z0jUSleBry09BY6tFotqrKc1aVBCgk62vvjAqPhlPFgjE4TWt02SE+aKoKfETHv8Ag6Rc7yUotWFvtFDGYUVkiqqqKdZdjGxlwTIuCtJVFxt7aQEhel1SA80ge8iyIKT4BZziQhIzHyM2sZJ2IgnGVxp7kUgqopCSSAw3uDVB5cgxAaJQRaKaz1aKVBKpRSsb1LhU8CaZISECRFhvQQVFxA9564gA74YME7ZJZi6mZG1r4OxnRHiTZHEiHAz9whlE64GcDHoFEA/ibPghDw4mZIK7gZfyJukoQ9ZfZ+vCD27hlJqJipt0OAPWsuBJFoij3V514utDh+7RFbQYjqZCFm53qs2bNBq8mzAo/Aiw6IMTJosAEpU6bTKdLm4CyTapdzL/wx2ze2efHiFVyryy/9zM/xnR/+AGdO3YttplD2CXlGr7vAd/65n+DEibv4qX/+/+Av/vh/xgMPvx0nPcsHTvLSM5/mrgdanLrnfh56+CjveOxRCLGtSqXiu9xTKAePEGrWR6K4IgRPmuYoraINv3MQPGGmyBYiWidJYh0JKfDB4X2NazSdlWPcnXdYv/IiU+fY2LzCA+/4Ln7kL/3nbK+f58t//El0Ksg6q1BPOXTkfv7oM7/MwupJFtfPo5KE/qAiNDucvPfdTEebtLurUZm6l2JsNh7tv/hby4xMxf50y3G3nCZmf4jtKfanIAQiSKpywMb6RZ7/6lM8+5Vn+OIX/pjBYExW5Cwtd0hSyDLN2bvv49HHPsjZe+9nZeUYWb5AzN0V/9u3wBLMVLcCqTTT0Q43Lj6DkA2ZbKFEznPPf46N9Rs4rzh24iSXLzzPt733wyysrvLUlz/LpUuX2dzYYjCtcQSMMXzpyScReHSe4knY3Cx5/PGvsrbWIctyGil44MFv4ey9j/HFL/we0+dqvvzkF2iqXfKiywe+9fs4cc+79slh7Awz4mgaRJLinaEqpxRFG7RmP5/bbfUa9gneXj8JwRNEpJxhb9ZH7B19+/G3vqA4ObL/dtjPWbiv1N6/yKyaZ33xljmmwP5XIdryAXgI4g0I6MyEUczsx4K4OcgEjRQNq4tnaJ9pcfXiqyiV89STX0LqJ6hMTX+nz8rSEt/9vT/GybPvjGO2DwShZ9eL40hAzuhmVGoLuTchcuvD305+X/uoMp4xI8reu1lMJPerZa91w944d3O2cU8tH+vl1o5xc/Jq/6vfppKPdShEtP6zpsSamGonPrFCiy4HVk7yyz//z/je7/0xnnzyj2hnmiuvPkOS5OgsYXfzVcz6OZ597qtcPv8yB9d6LC4d5LH3/jnoHUDiePWlZxkOt2nqKafuPosXmk6ry/VrF7l+9SVkEDzy9m9ha2tAXSekqSBLe7SyHloIBrs3OHHvY/z+7/wSk4nhC597jkFlWL9xAzudsFG/zPnnvsDLr7zKiy+c41O/86/RieCTv/d5Xrp8jcefu0CwcaLRh4B3DiUVwbv9SYo4eRcwxpIkmrppkErHfGd2GidalSL4mKInSTRN5fhn//TnuPjqC6x1Ozzy6L28dHGd4bDipWde4ncD/PrHPoNQimntCXpK4zOk0vjQECQkSuIqC0KTpgJXR0cZJQTWN2yNHTpRaAEmCF568VKMwVONcwKCIE8ktW1woiEVKV5ozr96+XX6xVsvcwyfY/gcw+cYHvvmHMPnGD7H8D9LGD7H7zl+z/F7jt+xb87xe47fc/z+ZsXvt7ww3u2u0bZDRiHQHw+Ylobq3FMcPLrE6sGDrO9u0mpNOLC0xrlXn+TkwnHWTt7Ply9+njOrR2htDrnn+CG21HWWWis89rYD/M4TA5ImIw2KVzckrf4BOqfbHD9Z8MKFXS5sX+RQOMjawT67w23oHIH0EFt6m01KatNCiwk7u1PUzn30Vt5Heuq3uHzlRXBriETQ9lfYahqOLp2mci+Qp4EVt00YWrbo0Skc7zz9o2xVI2yocJXnzLIif7smTwNhd5EHOm+DTIHz/PHgcwwnI3p2Ad9SnFx4mPTBAuFbtJKT7EwmbG0P+Oi1j7PUzji2JZgky4RDq/xHH15DZylj21DIJWyrx6ujs1x75T62Bpc5kmqOtL7K4mLDkeQML4an2RoM0DpHhQwhE8CgE82Zt3VZ82vUdpde/1HMIGFU7lJVEGxASUEdAs5Z+ru7BBuweFaWexR5tChJWylSCWSaIZXCuilCaVywNKbEu73gp8a6gHWGsqqp65qmMTG0EnE3o5KKNNM0oylVNUXrlHZW4EOg22oxGE1oJoGi3abXW2A0GJMkGXnRZjQZcG39GksLy5Q7DU1o0KniyOHD7A7G7I6iPXpQCXm7zXAwQCWaLE0py4qyrFheXESIMbvTKcu9HkHVbO5ss3pgDetqNrc3aecdVJqgVEo5naBCwATLdlWSJhl5keOLjFBV3Njeple0Oby2ihSCxhh2pxPGgxG9IsdYR+0cnaUOzpUYr+kWy6Rpwng6YGPrChqFThMa63FCE0K0GU+Iu0w3hxOcU3RaBcY4krRDbQyt9gLT8QiJxVUQc3N7qsYynGygkpQszxiOJkgtqeuGLI+LnT4EKmNItKYsyzjgi0DVVCjnEDLFOTCuRiqFcZDoaDs0Gk3pdAuc81SNi4HwLD954zzTSYk1JZPpmLKseOn8RR5+4B7yYMgKTU+DdGNaSU7djLFC0G6lpIlG4UmUiAvgxmCtIdEZpjY0dYPe21mrE5qmQUlNkqSEAM4HrPUILVjsZfS3HFo7uq0Ww7KiowRKxaC/sRZrG5TQ6DRQqBY2eBLlUEbgXUWDirndpURmGhtqpHcoIUgSjVSKxhq8bQCBd4Lp1KCFQCcpo3JMnmsUAbHT4DVsFy3uOXQKpVIGwwn51gYHD56G6QDVXcDvbNPOc5y3XLt+hXZe0F1YxAaBb+w+dIdZn5JCYssKXE2aKnqrHRKlsPUWdZnz8pde4pnPfJK15Q7Hj6whTIkKMztvBOVoiEBjZMB4T560mLgRk3JK/+o2awdX2Nwa0OtmNKpCaUU1qdAaOt0eVWXIckWeSeoGwrgh9Q6ZaPI0xdmG9lKPEGxcRLYBJSGRKdaAVMR61V0aY8iKFgKBMQ11VaOkQgmFF54sybHe0F3oIRKFaQyplNT1hABkWZvaevIsClecEngRc0jt7G7S7vboZgVSAFrhlUJqCVqhRFyQFirBuYCX+yvPYPfySXnwAetjvvEkleACgrjA3tgalSRUlaHTaaOzjIBGKU3TVCRpzE+e5xrvE5RMQEW1oxTyZqAqBUmSIqSKtNMZZJLEINEHCNFVwfuZwltpXO3wxsUg3Jq3CtevKVENS0yZ4B1SaYTYC0xvqmT3gsh9BTp3BK4xAt4/j1m4GElC2A/k71Ta3gw6bwb8e8H9HiHfI1h7YxYChJczErPnohBm9l+KQEV/Z521QyfQSqGCQIhsZq3vCV5x7tkvUVcDHn3/D/DSc19guH6FOjT8j//gfyBRMBxPGE2mHD78FB/50R8kzXoEJUEnCGe4+56HOXLyAf72f/O3+Ef/6J9z+PAqWdHhrvsf44UnP8fjn/sMJ0+cIAkBGaKdv5upymPduf13y4yQeO9ROJrK0DQGZMQxZxuMS9F4JI7ppM+gfwWlNYePvQ0RAr4xBGK7vXbtMr/40/+Ej/zwXyRv9ZDB8tUnPs+v/vJP4d2E//Rv/E3stI8zDV9+8tM8/cRTnDkLv/DJPyRpJ0yHfT70re/n0IkzWFHR7q3BLJfR3nsJIUQHg30GJm5ONuwpbPd5x813LmbvXSCiVZ0PIGQMwE3Jx37nl/jkH3yU9es7XL22GdN0CEE9nlI1lm6nRacDV65c5fnn/jmtdsH/+if+Cg+//X3krSWE0rMUFHESIzq2QDMdzZS9DUJYnLXs9i/yyovPsb65ycWLm2zv7HLw0Co/8pGPsLC6ypWNTV45f5lnv/I8g9EYY2q8U3gl+PJXX0brwOEjh5hMKgaDMS+ev0jljrG1eY5Pf+EZjh//PPfffw95KukPJzTWsbG5TZGP+dSnfoM/1+2xevgugsgRQqKCxzUTtjfOs7x2isYM2Fnf4PCRswSp0bJFwONdVBCHWHXxsxDi5Je/SRC9iGRYEjGQvUm0GXEXe8aMAcBHYdpsYixOGsW0E3s9Uogw62uxvwki8YmOGyL++5Y37b0HGYjC+70Jg1uGjBmDl0LOhJeO2L1DFBvJgHDgXMW4GbK1tc3Bg0c5d/kyk8GYB+69l3JqaYqayWRAVY/xPiBRZMXMelDu3XRGmUV0QxL7X302rvm9nF1iNlk2y+01E1nh/cy17mZbjqLD2cTH/nh1Sw3Mbr03xnkf1e17h908/jaUJwSPc26mgo8WlbG+Jd41OOsw9YirF54nGLh89TJJqnnwgXfwnR/+Qf7lz/wTnvnqyzz6yH30B7u8593fSr9f8vkv/AbXrl3mhQuX2Li2y7vfcYa3ve1hXFODnfKpT32UT33idxgNdhBKcuTIUZQQPHDfvXz6c1/k+ZfPkSUZP/5jfYaTAf/m3/w+J44d4J6zd9HtZrz97e/n0LFTDDYv8NRXX2BaVXzuy+s8fN8Rvuu7P8QffPaTfPIPP8V0NGY0rhCp4n/5l7/Cu77lvXzvR34Y8fHfYmNrxKXrmziIDkQu4KXA2Ji2JEszhIgTIs57XN1QN4Z8nLC45JBCRuGai1aX1kh0GgVoFsvv/f4XOXJwCb+PqYZXLl1lVDcILWiMhWDxjUKncaLX24BSgbKuZhgd8F7GXHLe443H2hqtNfgEJ8Js+BM4D1rrOLmQRvW/mInkfPCMRtPZbqtvvMwxfI7hcwyfY/gcw+cYPsfwP3sYPsfvOX7P8XuO33P8nuP3HL+/ufH7LS+MB0oWu21MXSFkF5+McfWIzWtjqp1divYhdpuL9MurjPoDquE5xvI0KwuHsFPL9nTK7z6xzZnTJ1nOC1788nGGV85B7xnCcIejx+5hde0GE/0kZpCS5B2SVo4sJpxeOM0F9yVGk4d57K4Pcq1+kQs7nmT0AYrMUI86pC4lNAa9/oNoN6UqA5vXx6y2VugUhtJuMJFTVDpkogvcWGLKCZvqCkW2QJqWZLZkl0U8Cfd23oG2bYZpw43JBL+Z8siZt/OAszy39SWuTXYodwYcapZZWTgEeperwyfoqh6HuiVbtWW10FxLrpFtfoVvOXKKI60V0labTbvL9eoGKhQcEccJeZvDyQkuTy/xxPRp7k2X6KYrBOFRTZtmAjKdcjMPcWBhSdErGsoKOoMUP5rCxGDHgdJb3KxTBy9wJuaqXl5ZYXVlhW67Q6Yz0qxNlkkEHi0zlCyYNhXldII1U4K1OBMXJIMTWONx1lBXJd45gpAzJUnMxVxXYyDaHNd1hUKQakVjDEVR0DSGrd0d2gsL5J0Ww8kIXde0uwXTYcnO1hZLKwcx9ZTJqM9wMKVod+gudtheHzCa1LQWCjrdLv1BH+ccznnG4zE+eNqdDmoM6xtbHFjt0ul06O+MWVzqkmQp1bSiLhsm5Zi1Ayu4qkGh8SJgnKduStCCVpqx2l5kVE/ZmgwRIQoNFoo2y60u02nFcDolI+AI6JBiXWA4GhK8I8sknU6LcmIwJqBVSrAWQaAZVdR4GuNIs4yilZLmGhc801GFUo668RR5jvcNo+GY5eUexgeMF5SNY6FI6Q9HNHVDp9PZt7aZlhWBuIgvhESIgE7TCOQB6qZBIOJP1Sbg9wOtqqoBsMYRmKn+QlzIDN7PbIY8Tsad6HXZsLEz5pd+8+M8cuZuVlcW4+K7aKgbSUsERj6QJZAoQVVW0bJaxgBbEvDGxeDV+2i5IhTOBpyLSlqldFwkRqCExFrJ4oLGXBuh9CFarQwrZCQbxiD21J4uwytP0wg6haLQgaU0ZyM4EDkmeLyQKCS1NygtSXSCMQYnLKXzNPWEPNXgYdxYBuOSPGsx2u1H5eG4YqVV0C6gnk6YTPuMqgm9doetyZh6UOJXpywUGaPNATopSIuU9WsbLPWW6S0u4jwYZ2aB0SyYALRO0UmG1xJrE4K3LHbaJLmgurLIC7//uwx3S+47fZxurpEenPIUmaa2jsrUSCWxdY3ME4QQJGlGmqezBegFvBA0TcB7RVUbWkKS6ozeYgEEsjTF1hapQCJpXEO7m80CFxOFDFJgXQTCgMM7T6JTBIKimxGUI02SKGpAxrjey7ggjkMJRZJlJLrABIPKoi2+FAKHJ21lhBCorUHrHKklWZ5TtFsIoSjLEXmRoyUEZ7ACvJTknRYSjWnq6EqgNDE/uEdhI2AiSVVC8A6tNE5YPAE5C+7EzPJfCEmiEoIL/1/2/jvYsiw77wN/2xx33bPpMyuzbJdBd1f7Zjc8CIIgCIREUEFSwyGDE6MZaf4ZG4yQNKHRSGSIGo5iOBOSSChowCEhgEDDdTfaobvR3pT3VVmVld4+e+0x284f+75XBYIT0QL/AULvVGREvZuZN+89Z+/1rbX2t76PTAtM26B0RhQR7wJS6gS2UdF1LrHejE1y/vkBGzwlxxKBQhJ8YjdKBDFYpNAIqfAhEqPH+jRtHoNPDNwYDxOUP+6lpGTRTFFKk2W95ed2iOWk/L8uE3XAGBTLBD+8+/cPE85lQQ4kL5x3CreUHx8U7e9+/8OXUmItJYSIDwYRA0ElewshE+tUiBRjEQGiRuCXfyc1FqpSML57C2LHeLxDb3SS0eppIpFmcpH7zp5D9x8jNDVxPuHEiQcoykjd1GgRMQau3tzl/vtP8K1vfAUf4D2PfoyrVy9y5dIrXLl8mcZ6fvrHPswv/YO/w//hP/5POb5xmpXVMwQX+b3Pf4lz953k8htP8eB7NUV/BaV6qXAiKVw0zRydF+isJMYWosE4wXPPfY22trgAu/tjFrMd1jONJxADfOPLv8Hm5hqbx8/yzDd+nYDkvR/6CYrBGs1iwuc++6vcuHOHtY1VFnXN9o1X+N7XPstzz7/Iz/zsn8fYhn/5T/8+5aDP3t2blEXJp37zN7hxZ5+VYcFkOuNn/+Jf4uTZJ1PcxBBsJM96S2QD5Dt+USyLK8RB0b2MWMs18odlAiOoiHcSKQOuadjduU5vMODb3/p9fve3PsXuzoTgFUqXiQwSE1PVicBiXlOVkpWVFfb3Zrz00ttcufpf8+BDZ/noR/4Mf/Hn/hqqyAm+RUTY29vm+ee+T7uYc+HCaayzyKwEZ9i9e4fz9z3ARz7+I3z/qaf5vc9/gZ39MV/9+rfZ+dTvsru3T2sanIU8L1A6gEhNIGM9bee5cXMrTT5Izf645s6dlwkhkW62t+c8/8KrDPolWivyTOHiPYb9kqbruPTGC6xvnoMMCIZ6PubWtTd44/Wv8cijP0Lr5pRZgXUtGcNlgeaQS9YyaJzrUDJDyEiIHkmKqWJJNveuw9oO5zxZUaF0hpBJ5SKEkPy/DgpPEtYnpwcFuLS9hEJIRYzLwvkgZsd4WKPGKJaqGp4YUvwTWLyxiKyXmmZh6VMnJT44lJJL7o9KKjgikZrEsrkGAqQiKyo2Ni/QGw545fUXMaZjfX2TtlnQr6DfryiLISHC3t23uXP9TYYbZzj34JP0h2scMPTTqjyIY4AIqXGz/I9Dv8GDJkOKN8Gn+KoOXltOlhy8X9rT7+o2HF4Hxfq7f36Htf9vlN6LB4V5XMbBeNgkjct4K9Ds3rvK9q0bLOYT/uk//3XaBn7kx57kkSfey8uv3+Pubsd3n3kFITPe976a//a//Uds7S7IKs1k2rLaH/K+936I1197HuSvcursef7x//BLhCip65bOWV598ybHV1d45ZW3uHZ7i7oNGDvmP/+v/gGD4Ygb13e4cuMet+5ssbJS8MjjH+DFV1/mV/7lp7h2fZeVzYr9yYJnX7jKtZv/Ha311HPL6jDHes/2TsfWTsvNe19gMr3Hxz7ycd54/W3ubeW03Qy1vF/eOqROtjtCJPsTawPGGKSUKKlogkNOa/Jco1SG80khKUSHsRaiQ6mKgObytS2yTGK8xPpELnU+0HYOKSVaa6SUiYipkrJLUr8KS5UXgbWWg+kO790St9JnyrJsKUcJSgms7ZICzXL9h5CIyUrJw+/zb3MdYfgRhh9h+BGGH2H4EYYfYfifPgw/wu8j/D7C7yP8PsLvI/w+wu8/2fj9A6N8f3VELHcQewWr/WPMZY+yr6jnLfu7NxBuQH8949bdW+RuhXi8xzNvfJX3nv9RZDYjjm5w/tgT3J58H+KI1fx+zq5uUowKZnpC353m5GDIbrYN8RQn+nucHEmq9Rfp2OOHhj/NszzL/uSjDKonWSkFDReY2jHbkxm9RmKIHJfH2dRn2FjPGMmaaYgouYm0cyrfo8rPMJCK470b7PXO8/3xS8y2F9x3rGBt803YPY2zJ3lg5QN85crv89L1r2OcJQsC3a85tXGSTz7+Ma7tj9kdX2ZuDOO7Nxj0StZVySfP9vnk+Se4W1/kxfkXeOKRNY4Dw8E2XT6jNY8Qs5Ydex3X9lgVjxCFZ0zNWnWBdXmSEGfk2RCxGHCffpiiUjTyIpLngBYhBA+cnCAw9MMTyLaHDx1tFLShJRBxrUECrnMUeYXSkf76CtXqkLyokLmmHKwgVMS7Fqkls2nHfDFDCJAx4DpLZzt8F/FRY1zAWEtZ5HgXcTYtUucsQUqEUAiRgYxJasEYQtSoLGM6nVNWParhkNlkTNXrozLFbDql7RasVSWOyPbeFsdW1xgOV5jM5uzt7DAY9qkGFXuTCbv3LKPVIcPhkNlsTllUSCXZ3dvD+MDm2jrjqWF7e8raygrDQcFsWqN1y8rKCsE7rDdcu3WDjfVNnDFUeYFdTouWUjCZz7hptxlkJZv9EZ3pCDp5btddw6HzhXXkOmc2a2lNzfET6wTn2dufIqRi49gKbdOhM02mSkzXUmQj9sY1a7pIiXI9JpM5bRfI8xznG8peiTGO8WRKnmkaG2jbDms99aJhuLJG3Rr6RUFd12itaLv0+9Z5yl5JXdfkeY7UYLxDRMh0hrGOrChACNq2QYg0+RojKJU80V3wFEWF77q0llyXgEVJbBAQHWWZszutuXTtLlv39njfY+9hYwCZ7lFlClROgcPHQBYDRZ7hvEGKSJFpvPfpfZesWedCYslJlZhnLDldMjG4lIw4A3kBWSaZLCyDfo8gWkKw4D3OWaRUWOdQQoD2qAgP9BV1uyCPBeVQ0xhJ3UbyqkDZ5F+SDisFdd0gRPIW8SEggmTWGryQbO/v03TpXlZlxkI1NAtNITXj29vsrRznvuPHuH1pD98E5pM9JBU7V96mWltl0XSMRqusrW3gCDTtFGKS1n4HrAMhROaLBQJJ9JZF1yFmhuZazlNf+AJl7tlYXaUoBQ6bkiOh6FzAGEtWFIhCUvZKxnVNtIGy8uhCo33yap/PG/JcUZQVWjmqskRKRdN6QjD4zjGedQw3+uTKsjroLQ+0JVZ4VJZkqWQMiABeKazxzOspw9E6QisyrZFoMgnBkQ56vSN6jxLJSxwEMlMID0JKRHBkWZkYhISlFwvkeY7WCpVrhFJ45wkEBqMRIgYE4HxAaUkISXFAK7VMbMEFlySPlEKEgJaSMi9wziKUQgeFtBJrLZAmu0P0aJ3jvWR3d5vhKJFJXNeR5QWRJN8vREQVOjHXZPJhEUJA9Cidv+OLs0z2Mp3k3b0PqIOFToDoQIklWzLgfSKMRO8INqAy9YPC9R+5JpNddJaR58WSPR6WyX9KDoXgHc8p8Y4P1b9+heUaTd+Pw2JMCpE8OZY/x7j0FBLxjySlyVvoYL2nV2SM1M2coi8IQUDMCDIkprOQuKYmy4awlMTXSuJDxmTrDpffepsn3v9Rtna3+O7v/Arro1U+9emv8xM//cP87//Pf4/OGurxLfbGOzz3/DPkKuMv/NmP09Q197Z22J21/OzP/lWOrW3QmX22br3IqLfJhz7y46yubaKznE/++C/yt/+P/xt++b//e/z1//D/RK9X8Xtf+TRaabq65tbObU43C3S+ghBm2agQeGvBd1jrUEJz8+1XeOWVp7h55xb/wz/5V7StpVdW3Lx2nWe//fsE37J+4iyLpuXXf/13eOJ9j/FzP/MLvPna61y9fZOT9/0QI+vYun6FjZUe3336Cv/kl38F4VsWbc3P/eK/z8tvXuH65ev8nf/s7/DKG5cxzvL/+X/+F7zvw5+kHPwzfvP3Psft2zv8u3/5L/Ezv/A3MfWcV57/fY6feIDNk+fRA42QGtCJJMWSWbwk5r0jf5V+vXutHD7rCMIn6wEfOvb2r/P//eX/B7fujnn70nXaBpSWrKxVuL0O51RShYkCZz3WGgB2draZLWYIoZjPGl5+8SJ3b90l15KPffKneOm5Z/jWN7/M7Tt3GO/t8jf+xl/j7bdeQyL5oQ/+BPPpNs5b3rp6hc9/5Rss6gWdiVjneea551E6El1G07aEEOi6ZD0hpSDLFDEq2ral6TpCCJSlYjJtadv2sKm0aBpCDJRZRtUrkBKGw4r5oGI66/jWt/6AU+cf4+zZR9jbvcWVS99nNtnh1q1dvvq1/xdIxXseeYCf+umc+x/5GG23S9fNCU6RlRIpewjhUKoPOkv3V6Z4an1NvbvDrVuXsK7hvvsfQahTSFkAjuANQoJ3chlzmlQEKQkowrJ5JoUEYfFBpEZdBBE9wXsCLtnqiEieF1hrCc6h8gItFQJB00wQ7Yyqv4FSWSLReYuUiQgkhEJITwxLfzsfSLZvMcV4kXKGfn+NRx97krX1ddZWNtk4dpayyNib7jLqr5BXJUpoTp55GARYb2hmu5RZUvJALNfnu0KOiAotssPmUsAvm3wC510idoWDtSuWTcDl6haR4FMRdzDB80evd5jpB3vgX/eq+0N/+l2vS6kOYy4I5FKWLJLIVa+9/Cy/8iu/yu4crl6/w8nNAbNZzT/6h/+U6ze20ZmgbTK++rUXePGVi+xP5mS6olIZZ08Pcc7yq7/1e1y7fo9f/+wzKBnJ85ysyJGANen7NwuDNZG6bUBLJJrFDLZ2dmltR7cNN2+OGfQKvv/sf8L6WsnVa9tInTO5sc+8qYluxGS2gy4yYgzU9dLGRUQykTGoMpxR/O6nv8Xrl+5hCAedISCmQlhKlBJ0XQsUSKkSTi6L5BgjnbVY71HKY62jbgyz+ZS8yBFSo3WOdQ4yhXFJCUbIRAy9c3crYfuSOS6EOCzOpZSHrx9MEUgpcc6RJroUcilH6lxaE9baQxujd+OnXdZG3qfXlFLkWfFvXA8/6HWE4UcYfoThRxh+hOFHGH6E4X/6MPwIv4/w+wi/j/D7CL+P8PsIv/9k4/cPfDA+r1tym/HJJz/Cvq25eq1B+pyirxHZBvt7U4brA4TviKHlI2d+lm9fnjLe2Wb0gODMhU3OVRVbVyRbO3uE8ArBnsHsr7C5scGMb7O+ch+bx3bZb3Zw7ft5eOMXuNN6rk9eQckd/uoDf5tr7VO8cL1Bl5sMjx9nRZ1nNNxh77UZzhhc1xL6N5n7FXbsNmuD4zR2i+gEo946Ulnutq9ihkN2Y03IejQ71xkPIHeKQg44UQ7Y7a6iNl7kk8ckRfYIJ4qzrFfr4GDia9ZkjhycZWexhVJzmmngWuu4u3uFUR+q/DYPnHgf92/8L7m3axDziqa8RyPucHP/NTbCe2iCIcgFs7DPOX2KTPZ5dfcqne+TOcnZ/CwLP+VWexOfTd4BRS+50RYojvHg9DHMdmRvMmdvWkOUqEIQtWB7+y6LuWU4WEVLwUpvkKSAlUAKh0QghUZKw3yyz3iyj0CgpKSxDmRGVB7bdsvJVpBC4Fyg6yxNU2NMgw8OERVFkSOVppAKb1p6VYX1gaYzCKnY3tlLnsNZwf7uLoPhgBMba3TG4FykrApc1zCZ7FH0+uRS01sZsDOZMzcda5vHmU/m7OzsIJVE5znGWbTSrK+ts7u/z7yecf7UOTplmM1rRsMeVVUynU+J48hoMKQqSugCezs7bKyvEaJP7BeZJuBXBhsMRKCr5yzqmqwqCM7hvSVKQWsNqtIMq4x6tkDnkWE5ZHd3xqA/YHV9k9Z0jHdbQoS2m4IC0zlCWOBDR5ll+M5QVn0Wu1NcDGyur+C8ZHdvm0F/Fa1Lhqs9ZvOOrrWUeU5Z9tjd3ccGz7CsEBGssVgXiEiyLIHmYbDQiuADudZYF5nXNcNhH+/jMtilZymlxHtPWeXYzqcDQplCRNe1EDoikuiAkOSlnekAR+MCpl3QWIuta7JezsLXbBYVJnpikMsApwCPjAc+JzH52SORIrF7EEvOmRRIlQSDykyRaUGvl9N14L1gZhqsaVBCoGSGcQZJYn1ZY5BRgAmcXrGYNgW6SjgWc0kbDULnIJMYVK4VbYxY61k0Laa15FmSj+qMYzztWLQtUkBRlOiyoDMNndZMm5YVJelMx/beSe4/VnJ2ZZXd2ZSwozl/boV+LmjbCYN+n9HGMTpjgEDe65MLiWs7Dlm9gIiBej4FERB1R4Vg563rXH7xKY5vVMxnU/q9SBCBLGhCaCE4nAURNCpKXExrQipFs+iouwVFWRGCwLQLhlWPQS+SV5CrHO8twUdu3txBaM3mWg7C01rHcNhHqhwXfPJfd+lANyDSlLYIaKWSOkKpCcoSoiLEnNYkWRYAQVI2EEqA0ESllmpEEaIjOkiYmHzjfbCoped3PZ+lPDK4w19llaWEkiTjJHWG8R7hI96nv5sOxiNCBJRKvuNSCFQQ4JZJgQKZFeQqA5LFQOJhR4JQCKWpegO0VhAFYslskzqD5TrVS8l0qRODLUZQUiXJlygIKibP8QBCaFwMoFLRQyD5tgvwS48gZPoOyDQ5HkNE+Hf8w/4nXyJQVQOCJ8ntx0AMEoRM3mPvKrDeXZhDYmEu3YkOC5YkyZXwyPmAkhEp1DuSX0TgQHqNP1LgH/itQUqAtEpSObP9ewyHx5AqWyozRUw3w9RT9LAkRIV3c0LMuLdzl976eUanPb/+W79DrwpEVXHt7h63d7e579RZbrz1FDuTjmjHvPd9n2Rae1568be4c3efBx84h/GR2ayj9Z5zDz2BcQt8cKyt3U+IlvWVVbyvefOVb1MW8Luf+Tof+MAHeOnl1/jCV75Pr+xx69Yu3/jaUzxw4XG00PjYEEJgZXic6XSHty+9zNlzD7FYvM6/+Bf/mJdffpN72zMm+zVCCoy3jOeOz37h99lcr3jpld9gOKq4uz9n9vQrbN+9yZ17DVv7E968/H/hwvlzvPbaJXIFxzZG/PZnv4aWnr1Jwze+9xpdbdnd3afzsHlslV5R8Luf/yxf+f0v8VM/82d5/9uP8tm3vkKVObrJNi+9/F3+4Mtf4i/+/C8SVYfOH0eg8D6S5yUyzwnxgIF7+ATTDnnXYxWCw8LlcOohgJQFg+Eq+3uGV1+5iiOgFagsp6kNXZuwdXWlj840e7tjev2KEydO0DY1SmacObPJ/mRO27Zs7U74l7/yG3zt699gf3+PprVIpeiN1vj2d59jd3eHflHx4utvUC8Mxnj2ZlPqaYsPlqrq0ZmOXq+kqjJmkxZrLceOr4EQzCYNQiSmtXUB4wxKpeRdKcl0OqNtHVrnZJnAOQtEMp3TdZ6yyJjPOuazDiHHzOdT1G/+Mg89cIGtu7e4desOs3nL1tYeO7t7aJ1z5co1XJB8eNyye+8ya8M+6+snuLt9i1dfu8TDD93Pj/3MLyLDKloLJnu3iM4yGW/xa//ql7hza5sPfuADXH77ZQIFH/vYn8VHuH37EoTAww+/jxhha/sKJ08+yrETZ/Ax4IJFqgxYxjZUktxzDVv3rhJ9y3Syz507t0FKTp0+xZXLV3DW8uN/9t9BFZ62adi+/Tb37l3n0Uc/ymDtBCzXgBcKpQ+KkaVEYBBEeTCREogigPcp3hHZ2DxFVRSsbZ7h1IXHMW3NWtugheCp73we29Scf+QDnDj/oYRHODwQCMk37XAtHkxahCXRKrHtfSQx/cVBA8K/q1AWQLI2eefvHTSh3r3WxR+Jae/si3/z9W/ymjv4jEolAAjeAhIRchbTbSId43HH29e3KbKMlWGPrmvZ2ZnjfMB6T2clAgcKymrAfD4nhkDfWIbDAVev3KDtBE1rKTJN0zbkeSDPM5p6Tl5mBCEJzqdGrQsY2yzxOkntOR8QylO7jv3bM46deA+rq2vc29vBWQhEjJljXaQSOVKRSLU+orRktNGn7VpefuVVxrMWYxKRMfleLpu0Aqy1S1sntyQJpmcppaQoikRSXeLrYj4lRMi0ZjE3rK6uI0TEmIYQU77ppYeQVJBiTFMWIj94zu88S2vtH2qkFEVB173zbymV8uN38DFZSB38nXeKeLVsIMhlYR5TLuMDnen+/66NH+g6wvAjDD/C8CMMP8LwIww/wnD+1GH4EX4f4fcRfh/h9xF+H+H3EX7zJxm/f+CD8f35NhfW7+PR+57k+a1v0LZjijDgzPkTDNaO8fT3nmV/d5/QZTTOMB7Peej+h3j7yjUey3+SFbfLna23ePTECSa3X2cyq1kpDUKd4vjwSar77vAG32N9sWDOlGAe4vr0dR7f/A94YPV7DHpr3LW/w/qgYipucW9nwYZbsLGxgs4K9sM+7cLQL3qoahPVt1AYNC1r/RlSjQg4vN4j0mdYPMluuETXFjxx33GK0RrH1OPoVU+bCd7evcLx7BzH9APMo+B6XeNqz7n1EbnuOHvqGHH3BY4XBb1T13j9VmA+GTEqepzvFwyO9dByhfl8yLBwBOFwdoVnLn6TzdJTHfM44Thb1bQxIxPrzMKCB9Y81mpqJ3B2gwcqz2LxFrk/iTyQUo8waaas2jPk+0Ocb2iaBh8iUkC3aOnahtZ4dqdTQLM62iAvy5RQLQ8ijenQStPUC6K1VFlOROBiwB3sBpWjC43rLN55jOnSwiaitcS7xC40zmBNR7/qkymNynLmsxk6zymyjLZpUUown8/RUtLr92nbllxplFaIIKibjuFwSN3WzOcTRnkP5x1FL6fDsbOzTVFUFL0SZx3z+ZxMZ/SrAUpKNlZW2Z/NuXbrNic21ulVBdt7uwz6I3qDIW3bsT+bsjYaUWU9Jm7B3s6U9c11ovPM6hlaZ2Q4MqnIc020AdN0dN6ilEQGkC7QWkue52naNEYWC4tzga2tbZBpYlQrgVAwGPYhOHzWY7aY0xsMcaajN+ohpcIsLFVeYLoOpTT9fp/JZE4EZrMFk3mLitDrleAktjFkVUZr2iRfnSUp5sWiZWWlYtF2h/IRxhgyIQkhEkNAZwpkoGmbpZ9DQEhB1zX0qh5t3YIE6zzWenyw1It5SqKUTuQT5xEx4qwhyypGVcHG6oiRXVD3cqIukcGjJeRZj4V1WNtR5BoRk6S18Y7oU3IfY8RYQ1mWRB+XHt9L2WgZ0VJSaIGQkkVr8SLinEPEsPQf9whAqywFRZ3hg+O+tT4+Wm7OLKPcMq5zFt6TDzK0cOAt/UzRGUfTdszqmsViwUp/lBhT3uGsoSwkDk3XedquwWOJ0bOwErHoMK7l7OlVFuMJ9XyNjWMDdqZ7zCaKxfoKq2s9aivor6zSmnpJLoB6saAsCjJ5wPxMxJNer4cXHUVvgJ3PaPZnbN++xGiQM5mM0RGymNFZg1QSHwU4T56VyDInxogNHXW9oCz7OOPxzgMR4Tz9TFENBoQcelWFEILQtYhYohnTHwzI+5LR0rtdeosXAucinWuJRKxT6EwjyYgigV5RllRC0XQNwamUyItsWYAlGRRj5yiRRMWJCiX98psHnI9omS8ldUDLnK5Lsa03GhBDkwpEBdEGsCnhQoqU3EWWRIkkKSYiLLWWEmvWB6IUSJkOvm30qCwjLgHX2Q4hJFpmeB/QIsXTIKC/MkThcSbJumipltLrB0nDUr7lgLGGREpNYiBKooz4mCbgleTwM/jgkVLgloBPjORSJ5apCMlmQESijOkw/Y95ZbrEL5UFUrLjMF1HVY2IQRyqNKRkk2Xx9e6D+MTg7Jo5MUJRVkndQUiyPMOZFoRY+s6I9FxiIAqVkvB3FfuH7xhT7PHBQYSi6DHeucbq2qm0t62hi1BPdnn9pe/QXxvw6GM/iveWre3L/O3/5D/nsUfuw7ct1ghUBsI6yr7mL/3sj/PBD3+Ar/3Bl3jr9Vd55D0P8z/+2r9itpgxrTtWouCFly4xN4Z+VfFf/Gf/d37qpz7Ln/+Zv8CiBu++w/lzp3jxxae5ffsOf/AH3+YTP/6jVCtDPvv5L7G3O8HVDWsXNhlPO27cusPla1cpyopv/sEXefnl17n/wQepCsXe3j0a+3tcfOsOb7x5E3NgS+GS6oL1LT21yvefe53gO5xVFJWmV2oefvI8b7x2i6tX7+C84OrVezz97EWmTc3maJX3P36BEHaxOMKk4/qNLYqqR+cisshYLGpMU/A7n/k2586d4K/8rf+IvfGnUFnG/efOc/XiM/yD/+a/YbS5Tt7rc/bMh3CxY7HYxXY1Shesb5xFZSWpaZMYvAfPL8a49BkDlozeGElyYGFZuAfBG2+8yBtvXqbqlThvePL9TzCZTLl+7TZCKoosp21bVqsV+oMKomB7Z5/ZZB+VZQipCN7hXSQKxc54yqJx5Ap6fU3bdmzPG8bThqY2DPo1vfGcXr/AOENZSvrVKsZ42sYsGaeWECVFqdnI1jl/32kWixqCZH9/QiBgjKMoEgM9WTIIhoMe3i3IyxJnW6oyo8gz8jJHxIjpWsoyJ8tzfPDs7DR865vf48Xnn0cEwf60puwVmM7RtIEQ5igp+fznv8ZX/uBbrA5zfvhjH+HkiS2u3rjOd7//DNt3rvHYBz7OqVMjfDfnt3/zn7C/s4vpLJ/+3LfwVvPcczc4e26FqhK8+OzzNN2C2azGO8/pM6fI89QgO3HyDI898T6eeOJJxpOGs+ceQeg+Lli0jjSLPV59+Tu88fpzrK2scOPqbd66dIkszymKgvl8jjWGu7evIfOcuq65dfUKBFj9W5uInVusrW1Qln0QGavrpwhIgs8QIWC6hkw7hA8o3Uvkn+ixZkGoFEropfXHkChz7t57nXu3L/PAhccYDlao6zGmW5APh2l9icSuTp5l/wZGuUjTOWl9JpUTZwz7u3e4euUS1hjm8xl1XXPf+QtsHjvFqdNnkSpHKokUihDkkqnsD2PkQUw7mLh5pxEQiPHgM7y7oBfv+v8/2vxM1jZpwkNqTW80YvP4WdbWV8lv71O3hotXt7h8a8psOkOpiHUCXEORS+p5izMB6x0Ta5nVsLU9pzXJKicGj5AaEQQxGqy3BAQ+aJq6IS6J494Hui5ZjnSdR0RHqUu0SkQw6yxvvHodLyLeQwiaXCQFqRA9zi5QIQehQViElNStQXpBVQqKSrG62mMxM4zbDpaM8ZTLOfI8x8uwLHpTE+PgXpuuQ0tFWZYMBj3qRUPbNOzuTdg8cQw48JdTBJdaNVIs8wIhKcuKNJn1TmPkoNi21i4bb+oPva61Js81xgSc8yiVHT43ISSj0RDnHPv7Y4RQFEV5KJ148GetDX90Xf5PvI4w/AjDjzD8CMOPMPwIw48w/E8fhh/h9xF+H+H3EX4f4fcRfh/h959s/P6BD8ZlUAQL33vheZpWM+qd4PadizxQPsK03sfYBZic0WqGHs35/p0v8f6V+zl2esD2/g12zJzLVxoe/5DlzNkets45u1JhS2AxYaDfx3h+kw3/CR4/cZKvvPVt5sNfw5Xf5UMnfhof7pL5BzlXvZe/8PCMX/r8/0h9cwv5Qw/y0MqDfOK9Z/jc81/m7szy6PrHkPEqx1c8rhVE8zgbvRPs2pt0c8VK9QAj/RjnVUFz7FXoVlGzH2ahjzPKMipRo+M+/czRFi+S+RrfFTT5CbaN5s3pPic3bvLQ/RV097MoHb23n+ba3Yucf/gk/c1HyMOPkZkhUXhczBmtneDKva/z0InjnNi4wLxrmM2vcbc4y1qlaLop0QSEmtArjxFnkZ36GjebFuF/iLy/zlJ4F0EEJzkRN/FNpO0abLAIBbb1IDzj2ZwgFVFrFrVhfQWUjBAdIaYDbSvrBN4k1qLOc5qmoTMGJSU+BjrrqesmyfkS8MFTZAXGGLSSqLJi3izIhSIYRz2fkpcVvV6P4eraUu4ksDIaMJvNmc5mmBipehVaa+ZNQ1lWaCGRmWZ3vJ+m2q2ibhp6ayN61qKiwC66w4lPIQRra+vM53Nm8xkbq+sICaPRkNt3biNFZGNtjSIrcMYwrVtkleOF4NbN22ysr9Eb9GhN4NbtHVYHPQajIbWpCTOos0iRZWRRorUEBZnKaBYt/d4qZjFntpiy2i8psz4qdgQyQsjTIRfgkMynC9pFYsPpTNHvD7GmZVT1iNFjvKPsl0znLdq4Q9kK7x15XrCYpUnfQZGkZmazmkxq8ryHaeokHSGTz0m/V2G6FkFi1wTvid5TVhVh6R0jpaCpF1RFD0GSNBeIpfQKLOZzVtZWWXQdMQqs6bDGkPUqOmMxtkMJSXSOleEAGyUrgx4iWG7v3qMJjl5ekOmM1gYwM1RRIYoseT4HASHirEXpdDiY5HCWXhJKJcZZSF4lWS4pQ06Z58xbg1CKulkwn0mcd2k63jh6ZYGSihjAdw39KsNry6XbDV5CneU40SBjTmxA9TS5lkTvmNcNs7rBWUt/MGSxWCCjQ2cFznrqzrI7b/EI+kVOM53Qyws6oeiVChMztvcWDPK77O6t0i9PsDqoWNSO2Xibk8fXuHlvzGIxZz6fUuicrmvpD/q4LmB5h80rRGKGJW/pwMraCu18gZYB27Qspvusrm0wHu/R1g3D9VV8cMzHU3wYE2XB5vo6WZ5RhZLFbMGibnEh0u/lZEoxXFkjK0qikmhyhBKEIhVTZ86tsT/dJ7gRAokSMTGOo0BridKJyCB1liTDQ1yCVzr8jjGmQ2PniMikWrAkPwgEWmpCsGRZhl/mKVIoENnyQJnEdJRJ6UChcMaidZJeSZI6kOcZwacDf6nTQbhzHl2UKfkigNDLw2lSwuAdMsuIIST1GCUPGY4hRJx3lHmVyDEZOC/wMakKgFySNnSShRExKRqoSLAOoSJSp7Urlu5DyQ9nCe4sC1IhkpdTcOnLKwh+6fWzZC0Gb5fc8PRaWMYDlWc/KFz/kSvLSyB97+hhsZikCfblM3hXJb5MKiVReGTSFSFEB0KhtWI+mxKio9dfwTtLrhXONCAMRdlDCMFsOqZeTNnYPInSJUIkF5uUMC2/FxC9JdgWXfRw3nL5rdfor58kUznetZigef2FZ5mO73H2wqMsFnNWhsf43rd/lZefe4XTQ81HPv5hXn39Eu//occQSvDg/Q/gu45P/fqv8Ru/9VU+8Wc+wJ272zzz1CuApD8quH1zJ7HrlaR2LdNZyy//yu/zpd9/irapybKcJz/4BL//tWfpFwX/0f/q5zl33wWee+YZvvO9lzl79jTGOO7t7JDnHQJ49pnneeHFV/it3/os40mLUN/i2LENqqJkOpvTWUvbgDEdeZljYw3IhH0xrYMYCqSwWCuYtB3Pfv9tyqpiMBrgg2d/d85i4VCyYHc256vfegVBwCHI0jbFWYdBUHYBqTRNN6coShb7c/7e3/27vPDSq2Rlxkuvvcm3vvc0167vUG41/N3/8j/mb/6N/5DHn/gIJ46fotg4T9MsWNRzhivFwYpMhUcIBG9wtqNezMmLkqKoDgto09U4Z1ASmrrjqe99l+lkQX9YUWpNPZtgu46iyOmsIRKRUiOlYjAYMJ3OqBctyALnPFIZsqzA2UiWZ8ybwGw2RRCZt33qeY0SYOaWxhv2p4JBldPr98i0YnN1BaNsYh4Lz2CQrCNM68nypLSys7XLbDajsxFjO2KUKKnftQ89zjh6VYFSkixXBEQqIlVJ17U0bc3qypCqV7KxsUZd14z3pqlY8Yq9nQlSRZom4F0gRstoZYjpPDu7M7JMYMOIz33l25RFjtQ5Jua8efUO//Af/H0eevhB1jeGfPXL3+DNN2+iS4n3GS5aFvMF3A1sbo4w4SbNwjObtcQIO5MWIQJ5rrl67S4vvPAyJ45/kaLs8ZGPfoyNjeNsbJ5FEPjed/+AixdfRCnF66++ybUbd5JyTpbhY6AsCoIPfPnL34BMsbI+Yj6ZU88t/+V/9fcYVDl/7a/+Fc6cvcDGsbOE4IhCgAQhWl575ds8+8x3Oba5wemT93PfQ+/F2oabVy+C8Hz5c1/k0ccf4vEnYGPzDPOdXXKtGK4d54mPnMaHQFaNUDGCUMSYJYa9DAmqYjgslFM8S2yq4D1dO+VLn/9tLr72Cm+88QaL+QKtJVoqWmMS6SkTnD9/H9YFzp6/wAc+9BFOnTrPhfOPIFW2ZFYnccNlrxLvHUKkRk/XdvT7I1A6xTvSFM87xfu7CvEQCcESg0OoxJ73LjKb3ualF77Br/7Kb3Dx8g0aYxAoutpjdY0QYDvIc4l1FmcEc2Mpl9ypItNoCSFKjHOYkGxmTIxoGdE6pywqcu2IweG9JKIQEqRweBNpjMG6jgsXTibi6qImeEX0AicD+IDSAmE9Ms9xXYfKFNZ5QrREkoxl8BFvPbY1TCY1MldUvTLhi0qENS0ztBQo75f5oFr6b6ZmyKEPmdRorRj0e1S9glmREUMkzxWCA/lQjWlbpErrQy4l1GxnkowgLKXZQGvNwcRAjKkpoHXCxYPiPLHRE/P8oEngfZI2DCFijKHfr5LqkvM0iwbjOrLsHXk4peQfagQcYfgRhh9h+BGGH2H4EYYfYfj/PDD8CL+P8PsIv4/w+wi/j/D7CL//ZOP3D3ww/lMf+QDrvU1ev3eTk8ce4YkzH2GmP8itqy+iZc2jH6945osTPvHJM8T79jm+9eeI/YJNdZ3p7TFvXrtH7CyvfjOiz1hkHHOsrxn1xlzZ+zrF7fvpnZO8fPsa2p2E7DQ71x8k732FT9z3MJO4j5lcYFJtsBaO85/+7P+N77z+RZxbATtlsLbOn3v/T5I1M0anXyc2xxDqNE0O3u3yxnwL2Uly1dD4e1xevERR9rm2VVHYms58E2PWePD4gwxGHpM35CNY6xXEuMW5ao3JdMr37nyaG7cL2nZOE2Zs5h9nQz7G+0cdxZk3uL//CXbFKwzmb9LPTvGaf4tf/9p3eWTjx3jgZMXx+zJuqttMXUTqEfumz1vNLVrxArKNnKlWccVr7BrDUIzQNmdhx3i9OHyojsDui+8hW3+YbtYwHs8JUeHaFt81TOYLmtYwm05RMkOrnMGgQqmI854sk2RaIURExORfHWIg4tJi8x5jTJpm1HnyvlCJiaUL0kGvM4mRISDXms44pBagMjpn8U1LVVVUgyGT8R4YT5ln0K+YzmZ4Y5I/MMkHxwaPzhSra6vs7+wyKHpYHbl59y4rZY/oA8fWN1jUNdZ7vPXsbG1T9SuQkbs7d1ldGVJUJWdOnWA2nrK/N2Y0GhG8RRcZmdK0xqKyghs376HLjLW1EavrI6zxbO/uoaWgLHqUKscZy3g+xwfPcFjRKE+mYDLZwgfBqL/CrG5Y2H3qZoEgQwhJv5+8i5v5gvXRiKrMqFtozYwiz9FC0FnLeD5FaUVV9dBaUuQ9tFbMJhOklFRlj141wMd0IGhNmq4d9JO0uxAiTa0LwXw2Z3VtDQhkWUZnOrquY9Dr0XYdUivapk2HzZmizEo6Y4lBEmJE5xmtMegsxzqPQDKdTQ89H3xInjAhRJz15Don4OjajhhyrO8oyozCZIyKgrwaMAmRICyZEIkVFQOZ1Agl0bKgtR1KH8ioQ2cNSqTDW+8NwTuUVFSlxoXIwgnymCaNm87ghSBXCo9HkVhl1rUMByWjSrO1N8eiObGSo9BgHJ2ETHjMvMVnGusjnY9EKRGZZjqZ4Dqb2F9Nw92xZWY8PgrmiwVyY5WeKPFoXJSoXNA2HVUxwjQN48k+a6M+q6NVFtNbuDoi+gXBt8SQsToc4mygX/URArrWIDKVvNSXyV+9mJMVBcYuCBFMZ/HdnK7dZ2N9hJCBpu4SmBqLUJKi6hMPiSwzpAwURU7wgqENGGcZrA7JM020kZ3xGJEpTm2uE4VCSk1AkpUFds+xmNWsroxQKlAUBc4n0oaSIqmPq+SBE0IgLH3AlZJp2hsNQqC0hhjwzhB8IkCkUixNuUcEUmT4kNQnkBBFOgiOQaKEoO1arOuwzi4BMR1KL0s6dKYRAlxIjuXWe2SUFHlOsD5VoMskSKmDg+uUT4UQ8M6hVKpJ87xCKoUPLvmZq+QJThSIuLRi0QWSiA+euDzQ1kiIkegcxnliFFRVL02QS4HSasnijoBaJmJJvSGGgJLp8B8iQQiEkkQXCSESYsQvEwjb2h8Urv/I5WJELpnGQsB8usuwt8Jed5PNzfvwRIQUiJik9gWRcrhKDCJZJmiBlDneB/r9Vbqu5tb1i1y+dBmlBYSW27fvsrp+jP5wxEsvvMDly2/xkQ8+ySOPvZf3vu+jSFXhg8PYhkzlxLyinW3z7a9+js0z5wnesLe7yzPf/AxlWXLp8hW++8ybvHHxEhfu2+DOruX48VM89MiDWGt4+KGT7O9PaZuWb3znJf7Mj3ycBx94Atst+MznvsYv/nv/LmcvPMTnPv1ZtNQMBj3WNtaZ1y3OLBMz7+g6z3DYI3jJZN4xGo7Y3ZnwhS9+l6Lqs2gaPvOF7xLDN9mfzJkuLK9cfBvnBIu5IdeS6zd2mM6eYnfcMJ62BATRaba3F3g/w3uPD4HOGPIsQ3SOTCYrELX0qe+65OklpaKtF/jgqbuWIs+T1J3OkTrDtzWSRAvP8oK6qRNWZxmD/oCmaRDOUYcASjAY9Om6lr1J5CtffZqilJw+eYxPf+bLDIcDVF4gdECGks/85q/Sznb50Z/8eXyU5L0BhRimDSMi1tTUixlXLr3BtctvkmVA9Dz44COUvUHStBGC7a277G3fo+0a3nrrbV595VX6w4xzZ49T5jlBSPbG2/gI3qci3wJ7u+NECpJgcEkKKfGkDj22us5iWkvTumWjp0Uv91iyZUmFStsY8llLrjV1bRkM8sM9LQiUlaRua6TJ6ZopWZYhZSq2qjIRwYoyp1407zBXVZZIQlIhkZR5RSQx1PM8Q4iSADRNx9b2LoN+RV7kRC9omxYpI2WZlHC865BCsr83XVpIAGTs704hRDKtUlwkFQh37+zy9LPPcfzYBrNZhyfiuvRdlM7AJN+xA4scQcS5jrbtcC5JqRVFjrcRH+Zcu36Xqip59bU3GPQqHnzgAsY6Ll+5ig+JiVvXLYt5R9sahDD4EJjrdllIaUII1HNDUWqkgnphaBYtv/qv/hUf+tAH+LN/7ufZ3RtT9Qasbp5E2jmTnbtcfvMib12MrI1eZvPF77O1fY/9/X3Ksset23e4tX2bp557ir/57xvG+/u8530fpBqcpGvnFHmGVDlRQDImg6hY+iJGpEidx0TWikkmLkRMW/PlL36Gz376U8wmc4x1lGW5JDIm7HLO0pnA66+/jZSCS5fe5qVnn+H48WP8wr/zl3nyw59Eql5iPDuDkgKlBS+98AxvXnyJtq2JIfIX/vzPU/TWUEVGr9ggimXTIMQlccohvcablt3dt8mzipW1c8hc4OyMN199ht/51K/z3AuvIFVJpg3WBkL0iJAIgErJZF2kJF3XpaLSa5yzGGMoixydxeRT5zxSS0RIa0UImUiOKhFSlU6qJU3TJdxxDiVi2pN79bIeCBiTVFVc55FCUYgcnUGmFfnaSopxXYez/l1FriJGQZDgo0W5QLPXkGWaatCjay1Vr0cInrrtlt5hOpEciYf7UmuNEoqiyBgOK7w3jIY9usZgrMN2NVJ4jBME4nI6S4BIuYQTCbfVUmothHC4r9O+53CC4MCK6OC1EJJkpVLqsJD3PqIzCTEcqsNY70CKFI+WubPWOuXky/h+hOFHGH6E4UcYfoThRxh+hOH/88HwI/w+wu8j/D7C7yP8PsLvI/z+k43fP/DB+GOP/iQb9wcmr83IJp7Gt6z1N3niYz/Osc1jfGvn7/PUlwXR93no9Ca5eB8T+zrzfcHJ9fO8dvc6rsqpoqVXFoyyPufXTxHUmKJ/lX3T40I8T5s/z6dev4y4/cPoRY5Q59g/v4erNK/vfooHTr1NDD9OVw/54KM/QowVV6Z/QJHfIN98k/7kfUytJ5prFOVZVLbDxH+Hi+M7PBb/11SDSL3jqPVlVHWPnfoGm+U5ru/f4vXtL9KGJ/nExseogcX2adaPaWqxxyv7t7l/cIY/83CBso5T1YOUZsIbu9/i46f+CpvV47z33CeZBMvLl75O79SQycoNfvsrn6MfH4Oiw61q3spfoW0DNvY5VT7MWU5i3V1WslVEaekVPWp5j1YPGISHeXy0xk1/g9UsS9Oby0XS1zmjvR7GWqJNh4i9MqduF3jXsru/x63buxzbPI6usiRfYEHlAkLA4/CuwQWDUjnBGrzzCK0JIiAzjXAKYyzRR5Qqk4yCNYnxGAEpMNYmKZ8sTSsTk1/uYj5PE6JaEkNMGwHBsN8n04rWWJyxDIYrAATTMp3P0FqzvrbJ7tYeUUIvK6nbjkAkNA15USKlRghNpjP2JvuJkZbn7I7HFHPFxtomx44dY3d3j7v37rK6ukEwBmEtg6pPVILVdc1sPmVrb5d53bI2WCPPNC60jMdjvAxUvYrBoIf3HU27IHpNWRT0hitILenajqrU6KLHqJ/jTYZzkcVsQp5r1lZWENEzm84IAYaDPrNmyt6sptfrc3xzExkD1joa12EEhOjRWUae5RiT5NnX14fM5wtCTGyzIs8JEkxMRIYQBL1+ifeGTCvqNj2HqlemqfFlcIykqdhBr8KYjrIo6KzFBUe0yas8xogOgqYxKKWx1qC1RmcZ1jlijGS5whiH8BEhItPZjOlixH3VgJYWqQRZJjgpFNuNR0SPdx04T1DgnUdryWjQo3OB1likEBRZjkcQRMRFT1hKBFljccYxrjtKCd5FJrMaVeXoKFESVKYRUpJlOXmWo4Vmr63JC82t3Za1KkeFiFMBqQLBJ28XGwTGR4KL1M0CZz2d8SgtMC6yNzdErVhfHdC4GlVJKp0RBQmQVYllkawHOsl8OmVvvMPGfacodCC4hhDg2InjtF4RAhjrKcuS4B15UaHybMkETZfSCq0iNjhckISokmd6cChVEqKnP6jQWtI1Df3RiNHqGoQ0/e+dYXd3m2A9edGjrCpiK9m+sw9E5o1ht15aJbiS0UqfXimJwZNpwWDQo20cs9mU4Sixj5VOTFIBRB+XrGOxZPrlBMA5m5IOkTxkrHdkUhKCxVoP6UgZISTCg4+e5CUTiSR/kMQFk0QVQUmyMqeil6TCvKdUOUIqhJY42yC1QgnSs5eJPVpkOVJkSUlBkKa+lUoSLEtGtnMWqTVKKrz3ZEvfcGcdWmUpFoq0tkIMhBhQuUx2BFIQo1ySIQUoDSo9wUKmzxlCQGmdRHwEy0N9lRQhnCOq5fNeJgDBOaRSSCVxIRwevguSp1QM8dBP7I9zaa/wqkPHgtu3LmKd4fr1N9md3eGjH/1Zit46fulTNp9u8cZLz3H2wqOoTLJ+7Bg9dZKt669z7fabPPn+H6br9vn7//Xf5bvffx2nIsdWN5hMxgQiMSpsFwle8p3vvsqjjz/Aw498gUcffYyf/smf4d7dm2weO0slAlu3r3Nv6x7Pv/Em58+cop6Mmc41b126we2tMU898xp704472w1PP/ePGPZWcERc53j4gVM8/uQjzCZ7/O/+g/8tP/qTP0+vf5zF/i3Onf0ev/RL/x33XXiQ8bzlG9/5A3r9krs7E6QqcK5ZeulIMl3QtRalc7rOsVAN1gd0lrO6MeTO7QVvXLpJrjKyXJPlksksya2lokkynY558gMfY/rK28wXLflSygehsMbgfMCHpaVAiCyaNjFsASkkxlpyqbHGIqTGuYD3ERM6/FJaYTqbpgRxGc9BYFxN27YAZFl2mDCKJWHNGst8nuJ0UWQURYmUgdmixXQeYydApKgKrt3epv/wOapqgBKBe3deY33jDAKN9TXPPvscTz31bfb397lx7QbNoibPFSuDPqfPnmJ9fQ0lBZPJNGFN8Ozs7HD33i5dZ1kZDVFKsLY2wEXJ5JUJxiSGqZQK66ANDusMXddBBCU1RZ4ltQolkWqpwuBcYo97j/NhGU8Ni0VNjMnmQSlBkWuC95jOUotwmI9onZLkRPhJiXpd1xRFuUzKHXXTMJvXKJXDsikgq5ymbRBIEArnEuFLqCT/5L3Cu0gQ0HUNpnNkWtKZgFIBpTKsTYVKv99PBUfbMR5Pl/fAEqOgLAp8EGRCJIuRGJg3HcJHLl25TdctJbSEQ8aQrBlixL8bu51ZSkpJprOaGAP9XiJH5llGiILJZMFkMifPMu7d2wchadsWYy1aKbIsJ0aoqorOmHQfbMQYS+2TpYixhoEvKasKYsLPnZ0Jzz33PLdu3aJXVqxvrLC+cRK8543XX2d7Z4zxjvX1VcpewdWrt5BKJy80IZhNW+aLln/8T/8Z9184TbXS5+qVG7z6yjPc/+B7eOKHPshiUdOr+lSDIWVVkWcDfHAsZvtkRYa1kv6gRETBfL7Nb//Wr/DlL34meWWVBSGQ5M1iJIQOKSVZliFEirMhBpSS1E3L9Rs3+Bf/7B9ibc0nfvRn2dm6zpc+99vcvTdB55o3L17k2tVrGGtRUvLSCy9x/Pgqv/jv/VUuPPAkUfQRiuTLAezvXWN/b5fV0Tpf/4NPc/b0eT704TV0XmDMmHv3bmOspNcbsD9u0UqmCaJ3saqTBUqgLJO8XggBYwxhqTgTImReEyNkWf4OGAiWuaVb5ho6McqjXxajGVon5SIZBdPxNKmcxFSYCpmwDQnGGTKhKbVMyitLnzCtkydZ1Svp9ftMJrNUrC6L4YNCNxMaIcKyGeCQUuAdyXJEKSIJSyER2aQCaw1dZygKtdzHHVmW0ev1ybO0J4uqpO7aw2JYLVWxnPconYrtg8IcEiGxLEuUUrRte+hbdlCse58kKdvWoPWBtGPy8oxR4dxBjpMUdLIiO3xvY+xSAvLf7jrC8CMMP8LwIww/wvAjDD/C8D99GH6E30f4fYTfR/h9hN9H+H2E33+y8fsH/pMv3PgidmdGs3ObD7/vE4R6yJp/mK07l/m9p3+NN16espZnPPdCw7mNv8Cl5ovMx5bNlTMc67+H8xtXaZkxdgv66x1FFVk922eQn+X46RyzV/PW1iU2z0TyRyZc2b+H2j/FueYX2L28yWLzKW5dPoV/z4DN8n4uuc/z2vUe0xlsruQM+veRTc/SNBPseMT1e5d5z+mCfMWyVkTekx9jPTuGkj2yISymu6zIB/jhMw9wc3KNR4/9EI9svp8PnX2CleEtru3fwOyt4vv3s+9OcOXuLcKxt3ho/QLDXDIqK0zWIWWPV698m97qGicf/gnq7jrm3jp3w/MUccH5lfeRiZMc35jzxNkL7Igf53L9IkJIdrpdzg8ij2cf5Vr9BoPc4cSCm7MziC5jRQmO+1W2tCHPklY/gBIZj6w+jtpegpM1aAHGtuRFzrA/YNjraO02tosMN3pkeZGCHgJvPE1okTIj4AleEL0Dv5R1Xi5eImR5QXQOa1t8DNR1TbaUJqi7JvmYeI/3gSzvYdoWgmfYqyhznRKGGJnXC7xzbG6uUxYlVW9AaxyT2Yw8z6mqChcc4/EErGRlY52tnbtkFkQuUCr5aG/v7LK6skq/38c4w+mTx7l99y5l1Wd9bYNmPmN7Z5vBYIWNjXXs3YatnS16K0MqWVA3Ld57VoYrrK+tE6OjaRu29+5wbOMEw+Eqrudp6gWLWc180rC2ssKoVyGiY1F3bM9muODIspxBf0iuBIu6ZbFYIIRgZbVMG90pghT0RhmZ6hjvzzEdnNkY0gXScaCH6bSm31/BBMfuzjZnTp3EWstsMacs+7TNjLLoM17MWOkPUEJhfMNgMGB/PMFby+rqKiFFM2II9Htp+ty0XUq6ipJ6NkPIRG5QZY7SEeHA2Y4iz1lYkxI557A+oKQEKdFKYUxi2gghEEpQVomVp51nUTc8/8pFmgfPcWFzhMo1LpjkeS8VucrwznAoJy2TNVIIBtNapFD4mPRQlMzwMWKdSfLZPiAE1K3FSksXAvO2pV/leBdwxhFEwLo0cVvkmhBhZ2+KFYGBdNTe0oWKRduy0gvYmLzIrXWYAE1nmS86unaBznuU/ZzBsGA6bSgry2TmuH13gvWRSvcpco1pF+hcMpnW5KjERCpbmvmC6azF+45B2aMLFtMJipVVOtNg2w6hBB6P9RapMrq2IxzIusRIlqnkCR5TAt8bDcl0hc70Um0rPcOsyPDR4b0nFznOW0RIniCD/pCm6bhz+w6ra2usrvZRUuJcJKiG27NtilIznW/TmF1OrA8JEegiRZbT6/WSloOMCaSWvh9iefAtpVweloulhE161p0xafpdCHzwsCRmCJmANoGWTYmCziD6dICNQPilj4lW6X2DR+WadmwY+AgItM4IgUSMKaoUjzKFWibrWgq0kvgQliy5lIRKpZFBEGNSuSjyPP07WVrvksTQI0Lwgbwo8S6AdYToCFIgM03UAhcCGZpM51gfEUqhM5nkzlHECDGEdMgvIj64dBAvFVrlhOiXsi4hJR5L73PnHdEm5pzpujQ5HiFGn4qwg8P0P8b19W/8Gh/56E9jWPDNr3+Fp596hr/xN/86H/nozyOlYO/edZxtcTbwzDPfYWf3Jlduvo0k8HO/8Lew+YIvfOG3ePPtq7zywqs89fTLfOO7r2K8QErB/u49pAShIs4lTxvvAuNGcmf3VT7/xad54rFTvPLii7z1xtvc3Z3z0CP3keF54+JN3rxyj4cuHGdtreT+c2d49Y3bvHbxKlomS43pbE6R50znHuc8ea65dO0us8WMJ95znq39p3j04XXWjj/IzXtb3Li1z+c/9zTz9lvoTCOlZzwzdLbAuTnz2ZyiKpCIJMdDILQLlITOaGJU5HnGzRt36A8GzGcz8mFG09UUWc6JYxupIAsWZzxGKL73/ZfZ2plgjMe4GoDM+cMi+SBJ894vSRh26euT2LKlzOhMS57rpQ+PYDqdLtU0EkkqJbQsY0U4ZFrGGGnbjslsRlkUFHmRcoOYVBSEDERryHWOc56d3TECQVVotNZ0raVrW169eB1+99N8/9mnaeoa5z110+F95MaNG3gfkSKHKKiqkrqpqdsJd3b2OHfuFHmesb29TZ6VECOd8YSQpJZms5Z+33Di5Alu3t5C6xxrDMk5I9DWFmP9kjGqQUDTGuomyb0VuSbTKVnuVRUISwiRRV0zmcxSIi0VeSZZHQ3IMoVzHUrnSSlFZ9R1YvavrZbEKFlMZpRVj4XpsNbSdYm01LQdk6nB+0BZglICKQIudBRVwd7elFi3VFWx3NuSMtfLYiMQURhrsD4wGhS4EBnPppjOkCvJxtoKg1GfoizQSzZu8pXqaI0necilpo7Smrpp6IxNDR7n8S7FxyACVZ4tWcEZMQq6zrNY7DDoFyiVY0yLdWmdd3ZO2eX0+32iT+xjpRRGC5rGYZxNxCbnKIocIRND2pvUUGobgxCSEJb7xgcSqVdhOoNzga4zSJmzszvl9p0dVoZDNtZGlNVlvHPs7E2Z1enevnHxKm9euoq1AXDoLMd7yWQ2QynBbNxx48Y2Tz/7ClXVZ7FYsLn6baq/bnjl1Yu88MKLCK05feYMj7/vvTSLOdPxmB/+5I9y/MR9ED3PPvtNfvNTv8Ybr79J9KQceTjEv4utfMBc9t6n57ks2HSmsTZh7P7+lF/557/KM099j+l8zksvvcb+zhQhBVmhUTLlJDY6nn7mRfq9nL3dGR/7xIf5cz/718nyPj5Y6sWEb3zty3zm059Cy5Lx/pRHHrkPXQypG8uN6xd5+qmnuXtvl7pZkOWKpnXEKJaNH39Y2Hrvl/ldDqTfFwjiUvUpBE+WZWR5lkit3hOXPn3WeprGpO/qE0ZrrQ/jiRARnWXL90m+bcmjSyxVhDx5kSOVxtqQbHykJM9znHOEkNSLEgY7nEv3Mcuy5GHmPW2bZAYXiyRNl2U5SidvM2D5veLhd83zHOcd97Z2qYqc4yc2kopNiPR61eFnN8YeqpNmmSa6FHOHoyHGdIf30Ht/WIAfFPeJie4P8xwp5VLxJuVnB41Pa83yMxbL90lKOkIIImCtPXy/dA//2PB9hOFHGH6E4UcYfoThRxh+hOF/SjH8CL+P8PsIv4/w+wi/j/D7CL//ZOP3D3ww/vL2txFbOT/2kT/Hk++5wNa2Zn6zZuzmHBtcYfRnMl563rA2UNy87XjvIz9Hs3KXLr/KaHCcHz7zSfq9Gd++/A3y0CfvneHq9Lc4OfoY5/LzdKcm6Mke2Z7mmL7AEx84xeDhn+Xkcc0r9y5id9a4cyfyzPXrlOWvcXf3OPN9wVDn5GKVm3tv0+3f4Vj+caTwnD1ZcuzEOjauUs8XrPVeZxHv8ubV6xzvn+Tk5j5zO+HGHc+5lYpscIwb47t89+Y3WGs918b7vHn7JvecY3PVEINFmxK58wT35zlZpXH+BvdVu2z5KW/2Osaz3+Gh+jQ/kT/IU7M7fLj3l3j/w/uE8YucXq+5Ja7wwuR5et0Jgi/ZMvfYN78LvmBWw/vXjrFWdOSx43h5At1K8nmDkPt8hznuzNKQHkcZc6ZNizVzqnKIdY6FtTRNzc72mNhCr1fRmYaV/pA2NCgTse5gsjIdtHgS0AxWhiA0zaKla5NsCVJRdy3ehkMJGmsti2ZBURRL5pVZSh8HvAChJcHFpbZ/8vG1JqCrEuk9e/sThoMheIfUGUp7xtMZTV2TZznD/ojFvKZzHb1+RVfX+M7iYkRnBadPnebW7bs4H1hZGWCd4cK5c1y7fpOurtlYX2Myq9kbz+i6juPHN2m7jv3pjJ16TpWVDKs+TVszKAtk0afISkzXsLNzh+1xSdUfMOhVrI766BhZdAtmrWVYDOj1h2yub9B1C4x11E1N07SUxYCzJzcw3hB8ZFEvmEx3MV0gLyp8sGQ6srpSQZQE55iNJxRZQdXrs3At3jjW1zdpmo69/T1W19ZBBJwPtHZGiBKlNN4Z8iyn7QzW+XRQ3hnKpUx7IyxFnidpmUwTQ8R1HbnOiSIglj4y1nVYGyizEttZpEjJh/UGKSIBQZ4Xh8E41xpfVdTLQ/J+1UegiEGwvbPN1557nR969EF+/H2PcrIU7Lct8ybSBZekeYRAComPkeA8yIggJmYSB97V4IxLPtVJhYUoBft1TekCoYvMmwWDXgERbIwE72jqBdlggIiRRd3SzGqqwZC98QJdZITQkWmJcTolltEeAlQUkq6zyKzCR0/sLNNgyfoZj5xdY3/csvAOHwti1+KyPk5p+lWfGDwheop+j15R0LYts+keptkgzyxdHfC+Q7oF0/Ec5wJaSaaTljwvUVqm6ftlnBVCICQEGyBKdKaQOciswHpPCMkzCJVkUWSu0XmGtRZiRAA+CoTM6A9LmrZFRo9rYXD8JMYsuLBa4QgsmgWrKxX9slr6aIMXHXmZ/H4EB4feAiFUmsLO0kx3wKfPKQClEN5BVEgUApnuYwS/PCRWShJlxC79uGOoEfSSX72QSJKPkIsW4R0BjyQddB/b2ETFiI7QLRoqnZh3EkEmFZo0yR2BzjuEVmRKp8nvGMhUSiKlVuDSnyNGTNNSUJJpjbN2ycSTRCI2WKIUxFwRXUSYVAwFKWicZ+FapM3ojEfnOb2ioFfkiAhyKTtlTQcyJrmhEBE6wy2TDWfTwHnIVLJKkGmq3XYdQoCIaSpfaZ1UE3AQ5Q8K13/k+tJXv8upY8f56tee4tNf+CYfeO/DjCd3kcbz8hsv8o//6S+zsz/mvvMnuPjqVbbHNRurQz7+wcfIv/w7vH39Ds8+/QKnj23yG7/5Bd66sk1rI1F0RJ883ZM3e45zghAcMQZClMhSoXPJ62/dZnv3W6yt9njryl1eeu06ZZ5Rtx1IzaWr24hrcP3mmKZxWOdoTIOSikxrbDTUnUiSPNZz5eZdnD/O9VvPkhUlb116m+nUcP3uDpO9OZ2rKao+KyvreJNUP7KswoeWst9LbPVk7o5QkhADEhJrX2mcdQx6fer5HLHcWyylfExrcD4SCLSNRReaeWdoWkuEtKbelZgmf55FSpoPWJBKkWUZkH62NhHMYkySbsZ0SaUD0Do7lBg6KB4O/v9ALgig6wxiqZBgbWLJRyHAQwiOXGeHygxKSjbW1mm7Fh8j/X6f/f0Z33vqNfovv8na6ipCRoxNUndKSQb9HohI07S4OhV0mZTkRcF4MiFGaBtDqFRizfoU3xEO51MO8fzzr7KzN6aqKjKdE4Gm7fDOIZcxUGudiFlL1m0IyZuv6xwxerTOKLKctuvIdEEMNmFLcAih6LqOECUxBsqqQiudSDFKUzctremQQiXG9rQmhIj3AesirUnftaqKQ5a6EklRojMerZbvUzfEGMjzDKUUeZ58z7yPTGbztP5DRIhkDWKNp6oqVoY9qqpIiXqE2XyOVDrJ+8kIKpEUIxKd5cxmNW1nUo7lAzEmmSh8IFOaqqqS6kQItG1DDJayyJBLBYzxdIK1kaIsybI0PVHT4r2j6zqkTOsw2WQElFbkOnvnPoZELPLOp/i9LMzkkvUblpJvQkCMiXEspcIYj1QZxgW29qaJqGeT/1di+nsWC7u0rhBICVv3dmg7S9Mk4qbA4r1lbxwZDBxSR/Rc8Mzzr3Lz1m229qZY59gbz3j1tYt4a7Fdx8VXL/Lkh58kRM83vvlttu6N6dqA9w7rLSFCnmnyPJVAUkra1jBf1Et2cXredBaW6wYiV25d57W338JbgYgKFzxKCYIQ5LkjKzXeS5wNtFbz8qtv8sEPvoetm69z8dLb3Lpzk7cvvcWbb1xma2sPHyJKa/Znr/HWlf83XVuDT7jpXSTPSrJc0bWGpvWHBDql1GEBCiIxslVSJCGynGDQ5Hme1iFpTcsoDveXsZYQk4dljH4Z2/Sy6eJSYas0WZEvp5BSnBEIpFCoLMVDaz3epSaAfJcEWlWVtG2SEczzhNnWJjuQd7PuQwikrS4Om45VVSzzoaUFS4zL+JfIYkppFouWtjWURYHSkv6gt3wf/658CnpVRb1Iqj5t2y091fxhgQ2Q5zldlxpzznmyTB9+TmcdxoTk/SbFYeNisWiQMjWn4lI9xlqHXBLaDj5rCDE1kovij43fRxh+hOFHGH6E4UcYfoThRxj+pxPDj/D7CL+P8PsIv4/w+wi/j/D7TzZ+/8AH4327ybmzT/Dw+o/y5sW3qfsv8OVXLvKBtZ/jgz/6v2Da7XC6vM16XvLWnR1mi1uY819lcPoSx/MpZ9Y/RK4+xhNn/jwYKMsTZOUUnZVI38PJwIdP5OS5RIQCpXNcC+P5FqOVE1y5e4Vd+QJbd/tsGYW8d5cLZ4cM++fZmm1xt73DWn9G3nTM5UWGG4477nuU8VEU55iF15jsXERNW8z6a+z5AUO1yko54Y17ezx07L3s2SvcXWzzwfw+Hll13Bhs8cqL+2z2H+SBxx9HxQmXxt/F7DTIMKRxY96javT6Cjt757i09yaLfMp9pz7Aj+brbGiPLCa0RWCQHeOt+g7z5joBRy4GZHJCNBXIMSs9TysKtF5D5nts2xc4VXyCq8UKu1uRXkxezJAOhMy0Rs77BBTeNhhnIYAzkqxUqEyhduHevW2cczjTEZQgqIyQkaR/pSBaj1CStvPJLyNGjPMY6/BhKdXtHJ1JTDIpFcVglCZGZYbW2TIQGrQQKJ0hqwwIhOiQmYImEqyjKiu81NR1S1EWONMiRWRzfY3pdIoLdskoWWG8v09bt5RljlYZbb2gsxZrLRtrq8zmM6xPh+feO86fPs3+3h7T8R69/gghoG0Ne3uW9bUVzpwe0jSGyWzG9niXUmq6qke/N2AwHLCxucnGxnE662jMFOEb9urk0yAyzXq/T1Xl9JSgaRYYPI0xiCxjfTCibTpu7WzRz3OapsN6T6+q6PUyvLF4J8kUmNZRO4/vHCsrK+gio25rtLHILAXazjr6wwEuWMb7M+47e5K93R16/RGZ1tSzCaXsJ+/wZQIoEfSqHnt7u+g8wy+T4iIvmOyPk88xCqQg0zDoV4n5ZhdUgyGz6XQZ4CUheiKBIu9hnUky+DL5OJRlDiolXM45yjyjyzW9fh+F4vLl22Qi50fedz/EBNzNPN3HsswxswUqE+SZxJiOSmfYoOisR2ud/u0YyXSOj47OeVyEeWNY7SW5nzLPE2hKiQ0W23p0KfHOYKTEGYPUAms6vDNkWaRtPFKr5E8fwVuHzjVNV1PbgPGWIstRKqM1DaFzRAG5EGyOcjazPpPWcfPuhP3acvzYBoicXEeErcEHmqZl2NeEtuXO3euc6K3hbUuMhmAaBJFcaYoqQ1d5OkQWaQr8kIKKoO0CmcqoioKd8RRnOoYrm9zdegOZJ3kiYiQQUZlMiZyDiMCFlAh5BEpGVo+voSMsJjXT2R6BQI+ClVyy1ltl0B+QqQzhAyI4RB7wMeCjR0WNEhkhBgQS5zqQJCQGfPBoleRMQhS4YIle4V1A5ApdZORInGlpTZ0YmSpQAugCLSQ1jlnX0hmPA2rjiQK0UpS5hmApioxKZxiZmIMrIuLaDl0oVAwQlkxgKSEZHhGiw8eYJO51jhRJzsnFFMMwHq1UKliWSVkIES88SmikUmgBXevxBGa2YX9muTdumbaOrjMEt2TViSQpv7E24sHTxzg+rKgyhbeKzlqkShPpOEHnW0wIaJGSYJwEtWQJCkmQghiSPQUkyXcRktRXkpL5411f+dorZFJx6dJdLl3bobYdiMjTz77G65du8ftffTHtgZcuo5BIFbm9tcu1a1t85evPs79oQUS2701pgyNogfAeJTU2OmznsTb9SrLxS/maXFB3BkGOjJrJdM5iUWOtxThL07VUVQ9jWlobsSbQdolcpLVgsLZB3cxp5w0uBoTuiLGHd5bgIzfv7qCFQmaW2/d2UFJTFRKPQeoMYzyzyZzBICfi8TH5ZR1cIQakSnExxJQgb26u471gNp1grUWg0VoxHtdUZcl8kXyBfAgIEZakkUhVFfR6JZlPjF29LMzfzSg/LKadJ9dLdrMPoJMqR4wx/YzAdBYXQ/Kaso4syw6TSaXUYaLqnOPAiyeEgHEO6QPGWrxPygliWVQWeY5zHVmmMcayaOqlxJxnMOhRljl5UaBkpLMto+GQKCTzxRilCqxvQAiKIicEkT5vBCEUzaLFOU/bGpQqcNbRti39fo+yrDDWMh43TMaLw8S210uWISGPBA8+pAJDSIGQMt0LmeJ+CClBllISXaBxi6T64VLx702HlIKmidjOMhz2gMhi3i73tyVGhQsQomS+aJjNGiIKneV0xtK0hjxX9KqKoszQS/WGsqzSuu0sRiQSTVEk1m2WJWJS03QURWqelHmWsFIErPNEH6nKnH6vpMgz2rbFWo+xntYmpRejPc5aghBoKQg2MJvWGOsOGxPLmowQPVn2jv/SgaRU1SspMkWZZwQfqet6KQEWcdYQvMT6xD7O84yq6qU1YxNRTGuNMQ6XJbKjlBGtFZnOiGF57+M7ahwqS+oebddSFqnw0pk+qKZQyyJpvqgRQuN9IHhPkUuKPD8s8p0NRAJ5lqYsnEvFbpEXWGuxzhJwtG1qVn32i1/FLhn6vbKgMwatNHXTEX3kxu1tFt9+CmNbptMW7wWIRNQMMbBY1ISqOCy+2uVURN06vItI6YnRIaQgX35XYqBtOowX5FISTItBoGOkLIrDfShF8vuKBFCe73z3OZ599jX2p2O6znL37h6zWU1nIkJoQtfiY0bcnUDw5LpK+ZoO9HsVXdeitCJEg/ccxhMhxGEMiPFALiwcFruJnCrTvZSSTKslPHq8Tz6KQoiEUUIil6z9uk5yfVot7XNCQImkXpNrjVaasirY2Fxld2efpnU4AjpL+8X7lHtCkpacLxaHcmupgWMPG4y9Xo+iyLh3bzvlFD5NIhXFO4z3hIOOXGVpfWnJaLTCbDpbrke/LKRz8jynXth075cWJidPbHL7tqM1i8SKl4JeVSKEpOsahJCHTPp3M9QPmhfT6Yy8KJDy4N755b5XOJ+alnGp/pI+a0j3QyvkcgIgxcX2j43fRxh+hOFHGH6E4UcYfoThRxj+pxPDj/D7CL+P8PsIv4/w+wi/j/D7TzZ+/8AH4x849+MM1vtc2nmNE+tw7vx7MLzAtXvXOd19GDN6mvs+ucv4rU3Wun2yjz7PYxvv4f39/561/GNkeogOGfaUJMsUIXiC8AgkEgkqEL3A2S5NrVqPLDpWfI8zJx7isfs/yscf/TiXtl/nTHmP9dVXeODcX+a17iXeeuP7nMsf4CMnfoKbps+tuxc5Fk8BjmCm7NZXiPEcvThCFBWh3uP1xU1WCHinOLbRR8qbFE5RN1fZzzUf2zjPR1f6nPnISV5zz2LtKhv9Y3QbE67tZ6ybku045qXFZc5XP89A30+mFbesQk0sH15/BNFc50XxFW4We8zDA+TNZcpmwl8qf4TZSPL8dMQjaz/GK+4zOLnNCXsaIQKtmCLjkChn7LdvcHbtDDdmr3IQkSUKOXbYdkrjHMI2mGDxrgG6dDAWHP2iou27dNgYHF3bkQ9yVKZxweGcoessQSkwHSZ4amvo2oboHJkusMYhZdpczgWM9UQXqYoSLRL7xFpDICBQKCGRQhNFpFk0mK4lmOT50LUtRdlDuEDdtvQHA2azCc55yn5FU9dJ4kbCcLDC/niX3Z19sjxjNBpinGE8HrMyXGVlZchkPqNpGkaDId2iYW11RD/02J/O0EpQVgX7+3t0TUd/OED3Sk4dO06ZF9zd32ExnjFrF4jxDkVecOrUSYb9Pv3BJipXCKWYTxfUdc3Nu1tkqmBzZcix1SGVzhiWPaZdR1PPAYUPgulkQVFlDHsVBEnTNWSFZmO9wnSBWT1nZViQrQzY3Z+wO2mRUrEyHLK1v4ezlrLXxztBXS84efIY01mNkJqi0MwXc7TOl97uyddYiiRNMp5Naa2lyCRaZgid5CvKMh0kz2YzBsOc4aBAiUjjwiFb0CwlhYzzhCjI8nRwabwnL0uauqE/6CNEJMqU7OWZpg6eTEuqqkwy1F3L29dvIBV85IlHGFQCO5lBFojCU/YKZs0cvKYsSjpjUCEmQgGkBJSUdAqb1uBkPCbGgCs8wSSJFe89RZYRllIyEYFxjiyvqGuDVhKBpd/rJfZpFjFti1IarSRFVeJ9QEhFVeZY48nygixPoGO6LsWmLCfvFWiRYaIFOWd9ZYVBmeFshyAyqkoyKZk3NaPBCiJK5gvH6Q1J6Stc05H3PGVe0LWenb09ZJ7RK/qYrlnKjaS9HYkIFRkM+zjjiUD0nqo3ItcDsqpHV0/IlEre18FT6RwfA3F5SKt0Ri4FxtRkhSaTitmi5bVXr1HkOSeOjxgNc1ZWRwQf8O5g2jwitU6g6gI2uOQFlCmsa0FG8CJNZ/tIDNDRJfUIGVERhPTE6ClUhhQBtCRETe4rZPSEPGd3XHNvPGdvbpk2ARuS37jOFCHGpQe9QuiIrDQiE/SyCEbgreeDw02ePP8kr77xLdbXRnhnEQiC90mVwEGQkSiT3DsieRpJIpkUIDU2S8mW6yxGpOl3GSUqCkQe0JnkzmTKzcmE6axld7+hbf0yIw6ImJJUJVNh1baGW/UWN27epl9WnFpf4YkHL7BSaoJxSfZfdmiVJ4l6PM4lX6QYAnXdIWJKkoq8xLgZnpREeheJMTGO/7jXjet3+ee/MSbGDtPCxbcW3LgxYdHWiS0okn+OX6QCRvmcjkCIC5p7djmsLmmto19l5EIRNamQlTlZ3qWkPhMpDoSU1OmYvq2LDo+ldQXeBlyX2MtCaXKVI6VPShq2o4kCESJ146lNpFflVKMe9azDWYuLC4RQiBBwAbJCYZt5Wp5aMzWBIteIIPCuxQjH7q7EE6mbSWKS+8RqbjuD1skPS8jEYuw6Q1gmv0IKPBYZHINBuSQNCVrbAdCrShbzGYPBCovpghgSUenAN0nK5BEfltJtxhikTKotB/46xhikkgh5wFq3CCHJigLp3dLWJGK6LhU7EWQmyPMcpSRdk/zYDpjuWmfLJDPZKgQi0Qek9cwXC3q9gpXBkMV8QWMsxrpEuKoXFJmmyFSSLVOStkvs4kxleB9xTqKERmSpSIgEFl1g3jaICN47jHWIWZL3k0qQ5SlZbWcLYvDkhQIRiM5jomWxaGiNQaiMzlgCB6lOmiKw1qU4V/VAiEP1kRAjnbX4mKSUCpEhAK0k/V5FlknsUt1ksZinpkRZkOcVOztjADoX8M4hOptsYWJqDCzqhsUCwDPoVxjbkGWCsuzTtDax5LNE17U2TSgY77CLFEtTcR7Ji4zZokNGKHNNninsslnSNJam62i7pZxfliW7CxuIEoosQyyjRdM0CCkBsSyKk1qPEJLJZAokhm9Z5gz7JUqmiY7RaJhYsiLj7t0tnAtkWlPk+ZJVG1FKoqNCaL2814EYDQpBlknKIsOYJXtZQL8/wNpuKW/Gcp0k1n5RFMwWC2KMlEWORKJEjogBZy2TyYRe1SNTCu9TDiOlRMvU3JAqNcqE0kkWznt6/SGCpLTiXUCisW1aN1UV6OdpqiAslW2KXirSt7b3UlNHCCKealAgZY5rLYhAnqc9b41jMpnRtJamc0uW8UHDy1LkmkG/n2TyrMe3Da7IiQjyTFAsJ0msg67tUDIx772PKKl46607qEKBANu0GBNxXmJdBxh0pvA2UPuWPMshtoggyMuMqpdyt0hG1yWpO+cSzoll8eicOywkD4rwLMuRQPQgUDgXiMEsJwnSvbLLQjTEZPkRiIilh53WGUpGUIrOLWOQAFDLdRhRQhC8TXsxRMqqYG00Ymdnh6IoEEJibZqyiCHS6/WpF3OMsWRFjpYCCJw4cZzxeJowUAisDVSV+EMNzTzPUSLFyF5RAYGTp44hiJiuOfRDXBkO2dtLkyIIgekatra3yItU0CuVyHMHzSDvI1ImNnkMafpICLmMpZDnyQfPuTQNMhwOOPBAcy4sFWDEMmDFZdMh/Rh8wMFy8kES3b8FgB9h+BGGH2H4EYYfYfgRhh9h+J9KDD/C7yP8PsLvI/w+wu8j/D7C7z/Z+P0DH4w/svFeVjcj+kxHpkpO6lP8X3/mYVoz5sKZH4bBKn0quv4ajoxRf8aK+hDWS1ybkw0LAh3W1TgnESjiMsBIAVFItMqxZoGXAqlK8qJA65OQpS+8vvkwT/R7XN7/ErE6zTev/gp3uEZ5fE6vKKjUOi9vv4k3J8nlY1y+9xSPr68Sypyw32c9v4AcSvLqPTD9DieyJyjKglFP0ORjHl1bYyiO0ZldtsdP8PCZ4+zZy9h7Gac2nme89wRFNeLC+gkUQ7qdMTeb2+zaltPHpjxw6gKqNLy+9Qyd/DDd+oJuFjnZHmemKpquwMt15jNHl2lKNeDS5PtsN4JT+mE21wfcdjeozENEo9iLNVl0jMuriMweHp4RIoPQx1Qt7bhF55qug+EwZzKeIGKG6VqU1Az7faoieVwUvRyhNV0IKF3QNg2tjwRnCFis8wShiDGxw7xLG67rDIumxvskr+28x7YteSYJ3hKXE6UxeKRQRDyz+YSmWZDneUqghMQ5y+7ePv3REGcsi7qh6g/Y39+nFAMG/RH7e7vE4EBIsjxDdppF3eJ8oFeVrAxGLOoZ3hr6VcVsseDObIt+ryLKQAiwOlxlOp+xmC8YjQbgYTKfkS9q6mpBURacXN1AbZ6kMR2d63DBcHf3Dre3YWN1k5V+jygg+kiR55w/dpzpomF7NmVrNqYqNYNeSSEUvbJgf7ZgYzhCjSRWWNq6ZjqesbZaIDLNrZ0xEcnGaomynsY2qDyjDBBDZN60aJ2jNHTtAu8ivSJHYYlIfIjs7Y2p8pL+aMB8MaO1HZmQyZ/GGYz3NF1Hf1TSmZZB1WcxW6C0ZjybgUzsoGyZHJrOoLIS6y3IlGAPqorWpGnYpqsZDQdY5xgM0hS+UhmZjkBSFOhVJRDpbEctoCxynO147c1LWBf40CPnscKxOlxlUjdM52OKPEO5mLw7Mk1Z5f8/9v7019b0TO/Dfs/4DmvYwxmqWGSxmmyyJzallm1ZigLZgu3AQRw4DhDA3/K35UOCIDBsBAiQGIgNxRAkS7LULbZ6IpvsYs1n3MNa652eMR/ud+1TbRkB1Q3b3em9COJUndrDWu/wXPd9v7/nulDacbg7UX2Lt7BMCxoRq/k0cXm1x1lDKBmtpPDKWYq1uuaqg9iSpyxZHJttx5yC5L8UKXSUVYScsDSEmJjmQFVSxA3DiDUbuq5ls90QQyAugdMcON7eM4bM06sLfunD91nGE03bE+eJmiPzFOgbz7QkchxpWsOLt/c0WnOx3TKNM5Kxrtn0W0JJzOOAVoqk3y3DtWTK+Bb95CnH+xuU0hhnxTLfdhhlyCkJOWgs0+nExrdYK7ZQuQgdqLVQgzUVUs2UWPnG0z3Pnl3hvWTET9OIZG5bnGvQypGUPNyGyDLLmpNLJtWE1ZaSCxopuN1qzYJSaNMhpc9hJZhB54ovQEl8dTjxxc3Mq7uJYSW8sBqPwlQw+pwxLvRvraBCJUwTShsWk2m0wRnHF68GVHvDf/fFS94fRz7YbLhqLdqIfbm2GoMjiwsUdbWOSTVRcsIa2TVejZXcnpIATaqJwwxv3ky8Gn7OYQiEMVGrWWlHLWAIikpcYygSRjm0kYLZqI7DGDgcX/LHn7/gt375Q3712+9BKYw54bPCK0NSGUrFoCgVjKoUhIJN2RCDQqm60sdBGrv6Zw84y5o1f0hsv4wWm6+as0AFRTLRS4WiMqFOWGOIcyHp+YHOq7kwz2I3FtaGByT3SPLmpTgXxCNTtVhrxTN4My/UCnFtIFVJnMaTQCphzZuvkHKRpmsaSWFmu+3xjUEnoTIfLP5rJWbJB8OAMRlqoeIIcUYMyyzGSXyFAlIUYj1leU8ahdUGciTnymmYpdBVilZbnHEriajEBUNpjNI45+jajtAFxikIMRoDBo9ej6/YBNUH+yW7Eurnwj+ljFLgnPy8eRI4KKeEtYZu08taHYIMLdZGteZCWgLKWbS1lDitzbx6yBIyq01czplYIiFKJo/SmhRPOGfYbFumYUJrS9s2NI1lngPOybGeayXnil9jImqVoU1ImmVZ8N6htUVVGSaEmFiC2Lbtdi1aSf6YMRbvG4bTRIwL9B1aC227xMQ4i11XLZKrpLArrMNq7aTXr9frknO+ZhWbtqHvG3zjOR1OWKMFrKE8DDratsNoKcrfngYBL9em1FqFNlZy6WIQsMd7cTApisNJnFm61nFx6dj0nraxjFPgcJwotT7YgeVUcM7ikcKeqtDrcKZpHNZa7u6Psq5biwpxtdparaq0Ztu3YjGoFbkUtNY03rGkzBLkGMWQH0jdOUS8d8SUxbovGtAOYyxaK6zTKDTDtiGldUi02tMJFS7rgWQ+ZYyxOGdJtZCCNGOS6ST5ejEtNO07oG4OEWsV3i34nZdhghJHokJlCQtKyZqvtJDsShuo0swVKlplxAarQlXipgGS0Wc0xohN3KZvRRtURc9Si6Il/iLnitV+HYw5SkmgBNikgtKavnXoVoZWRst9n3QmFZjmuDZZ+WFd01qzhIixC00taCOgWOOl7opFkNBpCqt9mcSQlJLIJbPMQBvFmUnBvMjuipgipWRpABPEdeiAU+QCOUqG3aTig41iKRmjFcZLPE4FUnm3cwVYQVYFVHJdYzzW9V3oaUUpsoaet+1oBWndBaPRDztgqhxolNFrMy9Nf64Ccn3++SumacZayUjMIXF/f7++H5iXmTmIlaRSiU3fU0vLOAVZ37QjhsTLF69XMtzgvScscQVx0/q+z9exo9QquxSMW4cfmnEsFCAu6zFddwxs2w1TmLk/TDIIXXfoKDTnnDUQuNeuFnhl3Ql0zle7ub0n5XPzDeM4rcdt3TGQ60NdDAL4Ka1RyEDU2vN9VR92Rjxq+KOGP2r4o4Y/avijhj9q+F8dDX/U70f9ftTvR/1+1O9H/X7U77/Y+v0Lq/y/85v/Dt/47oeY1uGNp5RCUeCUFmuU+gNSMqjLjLKGmg2UyKuv/gWvP/uKj559n/75N1HWrxd9QokHruREoNlfPcP41bYgJ5wu1Jiwbi8Ltp1p/DN27of87h99xk3+J5xUpTVP+NH4muHZGw7HL/jVDy747PBP+ezzP+K9csWzD56xXGvevL7ngkvSpPhW910udpZRFX6WX6DnzM40qPmCjmtq8Px4+R1eTb/Dq7dP+PWn/xHH/c94/XqgHWaeX+3Zdk95lv46W/UBlR1/fHqFnj/j49df8LNTg48/omr4kPcwpjB0mrBU/kvzMX+7/Q/4DfcBN9OJTXnFq8M9f6B7jjzFYjDpFVGduL1L+OB55sWKGWRnoyaSwkStgfvTkRANOcMyF/reUXJiHuQBqwbmcebp5XuAJqXCcDpR6mpH0PXEXIiHgRwTugplQk7EGMT2A7FaL0WtNhuFWCxWi/2Dt5rGOk6nE6d5JoQZahVRqSv5ZzT9rmeaR5pGiKI6Fa4vrxjGmTFONL4j5MjpeBTCq2lZQmReAiEGri72bHc7huNAygXvPGFJ3B+PdI2ha7ZM48h+u8M3G97evMS7hveePWeOC8P9keU4kEPk+uKStuvJSeNdz/sfvc/r16853N0zn45cX1/RNC2aiuk8LYkSNaYoSk1Mw4xrOgIZ6yzTcMD5hjeHe5z2PH//CafbO463I912izGa6TRgXcOySCFptGZOAbHUqIQlYYym7xzeyUPQeZw4TSd2uy1d17LME8syY52l8Q1oxThPaG3wrSxquiqOcWBZApjMcZzZdB1GK+K8kIsUvkZnQppBQb/tyUVyLlQtdG0jD0KVot903N/fCX1ZwWiLcebh4a43jr5NLDGhsdSq+PKrl7x/uePJtqFVjhfjHUFlnrSSzd0Zhy6IvXnRtNZRjWJJEW0NJSVOp0F2QHvJ5ck503ovBZvWzEvAWdkFbo3jNIygFL5pMcZjrCXmTOstJQmR2FqH1oqubYkFsA5nLcZYDqcjqVi6vqPtGrGVUfD61YHL66dcP71iPt3ROkcYT+z7FpUUtzc39O6KZY5gC9OYqFGRmsphPlGNoRhPBgJQqsJ6T+P8n9oIrJRis7ni9tUrtpstt3FA6RZURBvJdtJocoqEOaxNjjz0r1VyqQuKQgaqWOArw+7Jju1lh7FCkIaSwRhqrqRaiNOIM152yDsHxmKMJ6bIsozykDZFVBVSLRe5Lqx3VBJWJTSebHqyUigqrtF8dXPix5/cEmrhqnNcbjzH+xPeOLLSLKVgAVcrIGCL1iIRSmsMBpQhRRgyOD/z8acf8/Gf/JymdXwVTtx2C092Hc87z9ONhxJp21YssLKExZxJT5WluFVkUgziJlDg1enEy+HEV3dHYlTkuQIWjUcrsaUvpaKqOEMYVXFak9diSOcCJQtlqirBKGx2/OinX3KKmb/1K09xQ0GxsCSFVg5UIZdEKQmlxDIp1kSKCmNlJ3mtCpSloIRU/jO+Si6cv/uctyUFxmoLpMzDP1Ol4CulrHY+erUPk8JOivlESmsuO0YK/SI2OKw6BZLtAopzrte5EDVGAe+sx4xZrexzWWnZ+kD5KQXLIs4ETSOU9zjOAtWtOURnS6N0bkw5W05VYoo0psGsDgKSBSVFWbNSnU3bUJzEBmitSbUC+mHNAcnAOR6PWGvX95sIy4w1BpRGG82yBGpOxDCjtHmwITr/jAe7Nb5WTK+WRrVWrNPsupZxnMlrXAWANWLvX0olpEiuBV0gLQv2axlpsgaUtYmqD38vwwH555IyqRYuLjY4q3D7DVpbKpmUM7lWdIWSMjkntJYsr2VeUH0jFm650LVCLS/zsq5bvRzvUFaARizUcixYZ9Z0gCoNQT1bJhm2mw21VqY5op0jhIh1biX7zdocSzaRc/K5hPgWKhfArLS9d3a1mMsrCW2ZlwAomk1LZW3YldDEm76XIVEU2y5rBOIrpZBiQmlZk62zGGvIpbIsEe9b5mVgXgJN40Vnq8YahTFq3YUg17Lzht1uK84Q0ySwTq0Yo1YSOQP64TPpTgYPcaWEfdOI1WCMgNyT+Wu5eWY9t7XA3e3AMkWcNWzXmBnnHJtNz9X1BSkWxnFe7afi+js13jvO2WkyMFIrdFY5nmaUUvjG4a0lLBlrKtZYSp4wRtN4g9KKZVk4219ppdbrXq/kcsSuDV5K0gDnLNdr1/k/laFWSmGZl9UiUFNKxntHpdCuOXLOGhlsrPfXuZE8Z38pJSR6KZElRgpKmrW+k99fFfPanDrnsM6SS1zv+Sq7QpQmFfm53hsUhr5vHwZKJRWGk9hS1lJoGs/GtCi97kzxDTnLgNJ7J435NAnN37akKAOwtvGUKppdKywhsgTJNpwmWQtylvXUWAc6o9Zl9kzWay0kmFI8EOyllHWodbZ71Cj17p7y3pPX6JHz9zrnOFtO5rzeR+v6dG7+lZEBYdt3GK0ftGVZd15437CE+EB5P39+ydNne37/9z4RGLI1HA8zuWTJNlx38xhjsK4wTRPn7MbzIBOkgR6GhbLp0Eba15QVMRSW5SSNfCpoW+n6jqoVt7e3aK3ZbneUIlpirRWbyCJDUMlMhJoL1tiH9RrkmGht1nxB0S9rDW3byoBNizaf9VF0jnfHSglIqP4c+g2PGv6o4Y8a/qjhjxr+qOGPGv6XUcMf9ftRvx/1+1G/H/X7Ub8f9fsvtn7/wg/Gv/2DX0bJdUpGSB+LoapKXArGFrQBVS1xnpnGAxbPs/d+nV3zvjwsaxpaWwlBguI1shDGeKRpLlFotLEYUzElQwrUFFjGTEyGrm1wRvOt3S/zVf+KD/gVvvnB/wHXXDIc7+i7J/w73804V1mqo/m2xbKhVk19sjDsDxznwO3wivT0E6ZlwUw/5NPxx/z09h/w3fcu6Ou/gfvqV/kq/CHdxYaPvvU38M//Ofvyy2w37zMNv8P96cBhecJiOy4uD5D/hPuvJk7LC242f0ijPsIkDV8+4+gWvtreoWriqr1Du8zE5/x4+PsYtyPUhg+23+G6PicUh7fPuJt+gnO3aHci6ZmaL3mtvBA+ANWwDJq5KLrmGrfZ8cUnn1MLvHz1hotdIebCaR55fv0eKSRUoyi1cJpPZGRB7ruedrPjuCSmaWKaRyiGcRoxdiWhlkgqCWXNepNXtJIF2SjNskQhi1QmpMIQAofhRMmR3UZysLu2FRQiJLSrImLTjLaWaZrpfctu03McJmpVTNOCbxriFJimiaurKw7DkePpRLy5Yb/dst1fEkNkOB1xvsFUy+l0RwwVox2v3rymbTdcX11xf3/g1csXdF3P5mJPyZk8L7w93NEsI5cXT1BVcX97xGjD9eWeZR55++oVru3omgbXeJRu6WxBp4RrPMYrTvcHNo3HGceUR+Zh4OnVNdMyMsy3XDzZ0scNIUycTok4R2gqDsXx/pbNfk/XtYzjSEwJox0hLBhTaHzHNAWaxhGSZdP33Lx9S+MboUIbsQsahpHNfseyzFAqJWWMdcQoedopRHKpbLcdu74nLjPH4YT1Gyk+UlrtbRzzslBrpmkbapFFpeTMssxrQVRomoZxWlDa4JzkUHjnaKaJrDXZNzQ6kpbIT376CR98+JR9v2dOiYtdz1XXchwHdm3DnCu5GIp2TDpQlgnbtKAV891JHjT2HpQ83FRKHhoqrTHGkkpl4x3OnSlQKaCsMxizUlQpkkvCupYQAk2/YZom2nZD0zRkI7AICt57/lQKzWVhGWeca5hC5Bvvv8fb+wPHg8bEyDKOtI1BlYwGLnc7tBKOyVrHkirzeE8aO0y44/LC0PorxnFCdzs23Q7fCVlHlYfMsoBrtOlom0JIM4fDHaf7E0oJkWidZtvvSXkh5ojzjoIUwaoihW8RSrNSKSCCq8GZDm3EXsg6zTyNqJXnjWkh54i2ilLESqhpGnFNoCHnIE2QNlLoWaEhMwWUZkahqqKGiFGFYBv+2R++4PZu5K9/+wOSrvzki9eYzYbfun7CH714yRAKNkpWvGoUMS5oIzSlFM15feAvVimNc6gSME4RjCbWjFoUpzkwToXDdqHWLR/0DYdxRFlL41op/lKmIMBHrQ21FGyeKMbyuy9e8fK0UIeMpaKUxiknXmTrru1cpRjKOWOcwQCpxAfRpUrWTy4VqqWtmcVGbNH8/JM3fPvZhm9eXpNiwXhHzZmYxQpfoUkxY0wR4tF5aqmEOQjooBXKGHKIv6hc/ysvyYfKD01bXQswqnl43p7Wprp+rdg7k4dy7qVYCeGcU1PWplyuO+kvFcsSH4rEWoXSy/ndeYXyteydtDb80sxLASTN2pnmtlYKeeccfd9zOp0AmKYJqOScMEZszWKMDxlR8K4JPheUJSVqzrRtS17znEop5CL3f06ZZVmoSlE13N3f4517yLDqum7NqxFLqxgjuWRp/ma5R/qux3vLze09Sgu5f/49ctzlXJyLTrnm39GgzhmcNzTKczoNaC32Y2GJlHr+GYpcshTdtaJQD4V3itLIn/OwhKaUYlErGXRYYzkdBpxXXFzuOB7uaZuGUirH04BSsN9v2G930iAtAWMtznlCEAuvpsl0XUutM0pVjM44D01eLemUpe867sK9wH5GrKy2uy2qFpzz5CwZVdQOpSAs0pQcDqeV8G7w3q+kfOVsVSeUuV2vQ0UKCYPGWMmdKzlL3pN1ayMthX+3abFOsd3uOR4HDvdHCqvl1kr3Q31oMkrJNI185raR4UWIC/NyolYZ1JyHNzEkadxW+tcah1J6bcYkH2ocJlAGrS3OGzam4+3bW2pV644OxzQLAeycI8f4sPPAGoNqpGFcZtnB0HUd1PWzGoNvLDEVWHeO1FqZl5mcE6mcvy89fELv/XpPv8uS+vqf4hgigFWMWeI6kOZTa81m09J1HTEtMsSosiPAWmnSjTLEkGUNKZWub2g7Ae6mOXA8zhgnpP08L/RdK/dBqTjfrA06gGEYZoxRWC2Dl+1283A/5JyZlwVtNPuLC5Z5llpVW6zV5KI4jhNGLRgUKVeGYXgA7sSesQKVGCJ6dXE5r4FN44GKbzzTKDCaDBzF+g601BzWUJHsOyrrWgjbbf9Qn8h64tfdPVJDOWceGtPzcGEJkVoVtcq9lMiSqVgKkiEmERtmjZZJKXE2FSn1bCX4rplOq41YXQePZy2Qml7I6vOgJ4SAnExFTWcVkWtKG03JibjaRG76Xmzl1jX3bEUZV0BTaxmcvP/ec37646+YwsIvffQhr1/d8dWrV5RcMEbu5WEY6PtWMg/XYe35uH19wDBMCyjDcDrRNA1OK3LNq4tNRaF59ebtOpwQ3bq7O3DO3sw5C+Cb5drMtaKywG6qVpxzjOPMuxmzWDKWLIOTGKNYThZxuElFMgprFTvFUmQgFaMMfc7N+p/n9ajhjxr+qOGPGv6o4Y8a/qjhf/k0/FG/H/X7Ub8f9ftRvx/1+1G//2Lr9y/8YDzNA8Z0a5Y0ZCzWyg5GChg6iknM8x15mDC1YIzi/suvuPzGL+Naj9WWmov41DtLHCesanjy7CmmdeRUUSWi60ItmUwE16CLIqoBVyqoBuMs/8t/4++hTEdVBqUSPKkPNIqumqorplqmMHD/5jOc3fKkveTSO551Hf+y/H1+98Uf8rR+l291v8l1b3m2d7jybT65/QTVzKT9wiFX4vADfj98yYe79/lm83cJ9g/59OW/oJrXfNQ1/O7bn3P6+Su+9+1v85tP/hOUsQzt53zzyd8m1h1/vPwDbvInHMMOli/5pv+7KFv4PP4zLty3eZ0g2UvCFDnE38eWOxof2DYH7tUlh2nhWsH5jis5sdRAXwshH7mPR7ptw3A4gS28vLklk7k/jBiO3G7v+cZ3nzLOB5qmw1TNVXeBAm5fvWCpmaXIQzRdKt4axjCSVpvvXEX0jqcRXTXeuoddzkYbilbEnAlLJKbEptuSlpnhOLHpNwzHha7vUdpwvD/QeHlgeTyONL7h7d093a5bLT/EvnmcFrqup9GKJUw0zlI3G8ISmcfION2y3+9QxjJOI/1mw6bfM4wTyhRCThzevEbrzLMnT1BGczgesePIdrthe7lnmmfu705M48LF5Z6+77Gq5XQ8Sv5M03FaAqfjwHa7JVJxxrDb9wzTiTY6nlw/ZwkLjsp+16KsYTlOslDGno8/fs2mbXn/+QWNyQz9TJoSw7KA0Xhnubu7wzSOvumY5rXQLJr747gukBnTNByHEWM8x3Gm6zpSzgzHI5vNlpoSyzjStQ1GK0IIxCQZFk3XsdU9Vxc7pnFYM7mtWF/ERXYVV6GU5kUKAqMVIWfcunM4hYDzdi0mC7WKrYg2shiKtXZDFxdShTlFVA6cRvjR7/6M+9cD3/zwm1z1DWNYSMYwLAGFpm88mcpkDdl7lrQWx6t9U8wRZ4SY6rpOhAWx80hFREIepK7ZMs4LQYrQXUJuCk20hCB0pzaELHTk3d0BazwpB7rO0TWWi21PrZbjMLPp90JzahjGGUJEmYRzcn+UnHDeSPFFQjea43jidtzSWsXF5Z7dxtG2haw8wcnD+nEqKOWIcXngeyvw5uUXWAXdxTVd37IcR/p2y73vmdI9tvGQNTWtWekpogqyy76CRo4fWpPW4tdbj1GKVMVa6PD6lsZ7uq4j54BumjULSHadW+se3o9vOmKSglprTXNeF0qGVDHWYLSiqkhuCm9uMz/54lOevbfhb3zv2/zoZy8I0fNrH32TSVX+4I9fQKh84+KSF69eU1D47HFK3n/RTmhho4GC1ZoSI6iEQUE2GCqNlkZHaUUOmeN95CcpcXu95/1+S6sLYzkSUlwbjsI4zdSk0DhirXx6c8vLYUItiuoKWRtsAqxY4KiqUDXjraaWCUOFqGStpGAQy5dCJccqGUlW3nuTFbkWii784x99zHX/JZfW4GoilwDGsN31aOUEtGgt1cDu4pKUK3mWzJYxBkKMWPVnt3GTnB/5Z6G1pZmpa5FjjEFTHwpykCb7HeF4ztExNE1DiomUxWqq5ErJUtCeC8BzIXXO25GGMT/8Lu/btZnWD4VxSuWBSgehCtsV2KlVaPlpmgghsNlI5MHt3YFSC53vhCREQakP7hfzvKC1NDzOWrx1q1edfNYlif1aqtJslFxWuMYRYkTXimktxjimacQ5uea0Flr23FijFBXDfrsjpoAqFe8suUiBLFZETppbDVaLa4UxBucd1oCiEmPmmOJ6HKUaPg8ulNLktTGy3j3YEMnnFqv9tm0fSPVSJLsLJXSwcx7vLNYKSBRDpIREWGSokIs070+fXUuhvBK54zgKWLXpKSWu1nCFlCIxOXLmwaav8R3GNMxT4nRcaDrN+994LgMQLSDXtu+wzspwp8K8NqHei9ONjkJ7nhuUslKiMhxiJVjls58HBDEm2rZBWVk24ppP5KxFr8V9CFHAJG0Yx4lpmlfQpzyAOCCOFbUorK1479jtNpTSc39/YJxnapGGdQmJlGRHAFSstg+2TW3TSAPmDbVUxmGUa3O9/q01pFhIpdC0rYCi2shuhyq2dcacf7ZocymFaZoxRmOsYRol86xpNL2T3RibzYZSM23n6TsZCoQYOR4HSlHIAEEsq1IOa5Ni1qyy/EAqn63zZKAjGWYK+dNZ86ARbSdDjlINlbLe227dKSDN2Zna7fsOYzRUhVjFeVIemENgu+3oWkcplbYV2G6eZ3KueL82UkXW17yS9jkl6gp5KmQop7TiuA7tYgjUWmmbVjLppogGvJVrPcaCMWIbGENc41gkgiRn+SxtJ5ZsRslgYpnDWv+Uh/MuGVky2JHdGgHnGvq+/doAyeCsw5pA4x0o+R5tLI23zMu8DiPden0bqtJrnAnr7qDVRu9rx1QpHu4PpQSGO69J53XqfB7k64X8//rgRat1/VobebH2k/rJKsVUl3VAIyDX2tdirdjjxRhX20O5X2OMhCVirWGz3ZBT5s2bA//id/6IpvXMYeHN67eSedZ16y4UxzhOGKMe7nkZ4qqH4ZBzDoWi3/Qcj0emeQEtGZVLbMnV45tWtK0oQlhQarWfQYa9ZYU9jVl3OqiwHpd1qKAVy6p552zKWqrEfa3H2Xux6Ryn6eEYQl138chwxDmx/owxElcLv69r65/l9ajhjxr+qOGPGv6o4Y8a/qjhf/k0/FG/H/X7Ub8f9ftRvx/1+1G//2Lr9y88aa+xkLMsArVahulA1/c03lDyTIxywqxuMX2DdhZD4brfgtKYldCSi75F0aCLJi4zOS/EaKjzSAlHUg403Y6ie1QIVOVwtJRUqNZSkQzZlAvUDHFhjVgHbXEK5hLp+y1xmmj7LVZ7lgxWB4x2fBT+9/zBm8R/+ZP/gveffo/vPX9CHS75ztV3sPWG//ZP/ohfu/wBs7onnCa+Gn/Cm+4L+uLY5JZOf4P99jv0lx51+Ac033iN/lbm8/wpm/gbXJtv8SR9yO8O/5Qya/zllp+Xn/FLzW+yqDfM5StSCpziG6rvyASUecmFf0PUJz70G2rzKS9rwL255gff+wij5KQqFEkv5JqJOZEDpEWyaa/213wxvOHueM+YAuXNCft9T9dtUCayxEC7ueR+GeRBatOgnKGGCBV821LCQo1ik73MC922pXGO6BqWObEsE23rJasCw3bbU0umpoEUs9j7UGkaC0jW8ziOVFXR1sguchRt0zLHgLOGu8M92jjmaaZvOqiVu/t7Lvc7ctEM40AKkb5pKFHorLc3txircd6LqClN0zYsMQrVoxXjHHl7c8duu+fq4pIlLJzGgXlZaJp2XYQSb97c4N2B/cWO7WZHSDNhnHDWctHtqApcThymkXEeuWg7jiHyanjFZevpNo5u3xPGhYvdllf3dyiV+dY3r1E58+b1G5YUaXY9F/sNelaYqz3TMLHbbsnA3XCitRalPXMI5JLZblvC6UiumZIzrZWd3MZaTuNRaLlaZYHQIrgxCkk0zjO73QUxBC53O2oOVA0xV7QVwVXaUEsSwiaL0Fi7Ajoaqq4PNikqKpx3TPMJRUUbQwxBCmtnSa3HOc3pONBZT3WJWArGFH761SfcDCee737AVddQYybnSu8UzsH9MKC1I1bJz1DaEJaAs/rBIskYyxICznusdZSqyNSHIlooOU0IM0r5VWxkp++5INbGMYdEipHGN9iq5CFyCdQaCctE1RoKWKvp2oaQCs4pnIISI04VlmWmv9yt4EIhloo2sh71NeGMgdqz2RjCOPD2jeL62tI3T5mmgRILsyq020uM+BudV1o2+w3GelyzRw9vMEbhvJyUOA0ov8F7T6piOW+NJU4LNUvRarTF2gZlFLEEoYVLlofmxmG04TQdcM01aw8DSs55zgVdCtZrlDb4tgVVcW1DzCLIOUgMhlV2/b5KzoAqZAxzPvEb37nmYmOJoXC977jYXfLi7YGfv7ildZanV9ccjzNoQ8Yy54iyGlWEwjUoyR9HEUuFokg5UrTFWY0qhZShMaslltbkVFiOhc+HOw7diacbS0vGNg01JuI8U6pFq8JhnvnDr+6ZYwRjME7OeYMhmYK2ik61KKdprKHzhbsxk3Lk2093nMaJN6cCumIzhFJZUsZ5Q4mFxjmMUShrUaowDJFXw8QP/s1fZ1MWcklCbAMoQ84XAjLkTNN2GOOwCmIMzGEhl4I3/heV63/1pcQB5GwnI/nlYiUlhZvCrPZVUshIIXLOlRLt1ugHKl0a9VorpRacFZpbG0PKiaqkqTTmT1uZNc05K+xc2P7pZuhMhX/dzo11F7+Qq4Gc8+r40LJZs6CstbRtyzRNKBopGPO7bKySxdkhIRZTVSvIME8LpVY2m04aPiX0pRDPMiQ4nE60K0Ea84LWsOm7r71vvdpA5RVsKlxc7qgoDvcDpcJu26OQgxdDQDstURlrntJ2u10pVRjHGW1kmFFXEv1sPST9v0ErxTm7rJRCjkkGLCuVfm7Ms9Y03qOdZLKlKPZ7xkgwSwyF8JCVJTsLtp0cx2mamaf5Yf09gzFt27IsAckgytwfB/q25XRa2G4NT5484V9+9gdUpdnvt1QqRitc74DC4SC6lXKShnWcsc4jzmuyhitlHgY6WksMwplWTylTykqc5oS1lmVOpDTSlUbuK2WwVj+QxjEFSi00vpXPNQuUVVVdXR4q5uzIw6qNCrrOU0umZCG7lVLyvUqvFP2w3iOaijQS1noBsox5uG/EFqxQktiBLcsixbtvpGkq6eFaSimhVHpovM65dc5ZYrRilWUsSitiinR9x27ToajM87hCeYrarXDTQxNs14ZOcpxyTlJNrqRyrfWB5pUdCkLAG6PJOYnloVJrjRFJqeCcplaDNU5cSZzUINZKHSLUvSYsCW0kGuZsz6eNwjmBn5zR61qRH4aG1so6EUJcd5MoUpZ6Q2lHSEnch8JCLXB2M6mrHpQqzeUcFsZplvOkVnu3lHDOPxzjkgs1iyPKeSePWE1WGvcuk1BrMKZgjCeEyDxP0rhVyQkz689XVWGNZrfpHmJHcooP6xmAMVYGGVajApRcmfMs9pKNQ4eEaj3jOD000rXyQLV/ffD5sMx/jRrPqciKt/67UjKcPNtHnpv2sg7Ydrvd1wZ6eT0fFWs0RWtqyTgjkT8SbyNkOLUitpZl3cmTVheis52iNNSn40KMAW1gGCa89Thj6C72EqfzcD1q5nlej7VZ1z2x01S1EpZlva4lYwytOY0T/8X//b/m5Y0MaUnQtK2c13XHgXxeiYNyRmKMzudOKcnKy6v9mjZetChEuZ9rWtdjOc557WWNWjMnv3aMlVLrELE+EPfWSf3553o9avijhj9q+KOGP2r4o4Y/avhfPg1/1O9H/X7U70f9ftTvR/1+1O+/0Pr9Cz8YL3WmRIXzHTkubLcbFI7T6QBVoXRCqUpKCapGp0JeQ+QrmZIDKSXsmk9utMG1LUtY8K7B6czdeGDb9TTdnlhXWsEaNAZbYJyPaNdhlCPnRXbjxQBJtsob10A14BLOak7394RhkgcuNqJtwxJk8Xt/8yH/3q//b3nf/nc0/Xt8dP197HYgpRd87/kPMOUZhMpt2vDq8CPeo+cD+5zNkyfcHQLcn3g7Luy/ueE3v/MBY/c5Vhk+ffM5n7/+hKfhl/mqfkBMr3lur/hiOXKV3ud/4f6P/Nj+X/k4vuZX3P+G5+47vEj/Eq0TN/VAXTwlOSYWTuE9st9xYb9DXnrs126+HAp5kgdVZQ6kkHnx8gU5wW635TROzMvCaX5N1ZVYFIe3r7h49i2OhzviuHBxdY12lmUYaLRDNZpxHAkZQsxi5ZsLef3nuFSMclQNKE1Omd2up9RMSAvKKRrt8d5xOtzhrCPFSCqatvPMyyii6z3zvFC1wXjLvEimRJhmjNZM84TWmt12y+lwQjtD0/akcGSaJtk1HIIUWSkRwoIzltY3aKWxxtD6lqUuBKU5HgZiyPSbnqZrZScomqpgnCessXRtTymJly9f0zcnNhc9rms53t4zDSOX+z1t17LvLPM8czgN9H3P08s9cTjx6s09275j2244zAPPL65IMTEsI6/f3mMbx+6qp2l6bu9uGU4TvukoVeOd5+7mBtc2GOM4Ho6M88Tl9SXTOAtVWDNt2zBNI957TsORqmVhb7uOt/e3K5VUmJeZWApt1xFSpGs83luMhjlkjuNA1214sCJZC4jj8YRvG1BJ7OZrRueK9Q5qZlkyWq82RnFBVXlo7p0TWnV98KqNWNn40qBSRpVMKIafffEl3ij+13/33yKmIyVEOf/TSM6VWDO1aKEHjZGHhN5R5oQyQlSxFs5CMYEysiu6FsgkfGMwxlGTkof2nUNpi7PymHWeZlQtGOO4vTtgjEUpeZjetJZpnshGiowYFwqwxMTpdEvFskwDm31H326RjJOCPmesVOico2ZNv/XEHHl9N+MJ7Ktldvds1B7fXZBY2DgpngtaSEaEjKoJbN9inMW5Btc2TMtMiAvkutptW7zz0hhlAQlKzuLoURWqSKSAqUrE1FlCTNKIKc3l9VOaxpNKRWsDWuGVwhorsrAeb6MVuUScbzHVs8wjMS84bSm5oqoSCMVWYokYDc/2PdY2VGXQHt7b9QQypiZ++OH7aA3DHDncaq76LdcXjm8+cVz1F0xj4qv7O16eEodTJCmD0xWFFGlLyIScpEmrimQMWoE1oLWnoig1cYpgouLXv/keNmcpltqWpWYa5zi9POA6jd/2xGzRRvNkv2G8jyRVcRtNmAMaTawzv/WtbxIn+INPXnGxu+BXPnjCj37yFa/HiPKGjbY861tqWfjWs/f4yecveDNOPPWGf/NXv8vv//Rjnlw9pfc9zvXYMFNioFhP03mICWscvhQohVIVc8nEJPb21EKq0y8q1//Kq1JhbdbO1jLe27UQqg+FMABKCXzAu8LHuWYlL4XYKyuZmVcqOOVMBYHVUKvGa6FAz/CKtWsTWte1RD8QyWfCXeuz3Y2Qwqz05bngK6U8NKvnl1KK0+nEdrsFwDV+/TqJeEg5r2uSWnN5gPX39StVnFOh7VpKSszTLJS+szhrKbWyhIDRZqUYDQq1Nit5bbzEZisosfY5HQesMTTe07QepdZdAmuT+Y3338daxaeffsbTp3uePr3k5s1bdk+veP36jiVEtF7XVK2p6/V/Jp6XZWEcBrn3lKx1SinKer5SSivB63DO0DRCO4clidtIlPwk78VCK4aJrm2w25YYZpy1mO2Ww2nAGi0DhsOJvmuY54WcxcZPaUW/aWgbT06RmBZOw4HNticmxbIkXry449nTS8J8w3bTk3JlmmaapuU4jSwxMy8TKEhJrJhiXEhJGjKlzDoAEtslapVdCCv1XdcInlIz0xSEfjUWZzSlRJSq9L1kr52GAYWsXSiNtUoiDdbMPre62WgNfe+wxpJiYAkJYz3nbD/nDF3bscyBtNLuWktzIo4vcmycN9zeHNHa0DbtugsirLR+YhhGsUcDvJdGZxpknT5TzqUUainMU1gbXfNuSKA1Grku+r55AONKLoQlyr2C7BRB1ZW4Feu/872jVyBHKR5s7FLKOCf//bwWlJxZSsF7y7uMrIRWHmcljy7lRM6VlKWJU6pZmyu9Xrez6IYSx5GL/YaUVrofyaljvf/3+y0pFW5u76VhEvpKoDwlmYRnm6/TOLLMgaZtMVrhO/cwuEopoQ2U9O5eqlWOOVV+p2TzaUIqfD0bbFlmTNtQ0eSSCEuUAZWWOJKr7oKb2wPjFFb7Roe1Su6Rktlueiz2YdDonHu4R60z1KqJKaGVoShphpWqNN7CuoY1jcQolXFZB1IVrevDwO68jta6upxoRV13I72zijSkGIW8dvphXT835pLplYhBEVPAGBn4nc9NLZWUExcXO4wW9yXvxM7SrI241Ob9SnPL+xL7wkSuK+VtDMpWpmGE6hjnkf1ux26zoZZCXD+fQq1DmXd5nMMwSkxQlM8TY8Q6y8V+T4yBmDQxrbmHrWQ+1tXm7x0oXh7yOk0t9GuWpOiLEVvAXFdivlJqpcSItephVxWcByMaZ5zkpFW5Po3WKC09iAwW9DoAK3xNsh41/FHDHzX8UcMfNfxRwx81/K+Ihj/q96N+P+r3o34/6vejfj/q919s/f6FH4zPY8I1HSEltHWkWEAvNE0nYkchzANWqwc7BJQmV7F+COPE2WZAG7dSExrfdhRlON29pNts8dtLsWuYTqgUwTgqYJRdc3CFJMl1RqPRFVKGkhJaOYqZMMVTgHF4yenmJfvLb9G3WyKKSKDkRKtbvrH5iO/+nb+O7TbUutI0OXG8fUFUnsObL7jMLRv3N/k4Zt4Mn3K0md//9A9ZRsuvfPh9fvzqd/he2/Js+jVe2D9ity+Mbwrdk5+z3bxkniyd+y3+TvsMd3/kv735v/Bi/zGX5pLv2L9NsDOb8AGn/DHhVDG1xRzfY7pvcU9u8X4hbSy/e3jLGDVYKDWjBk3JA6loTqcZihCF98cjyrVAotu0nIZISIn7u3ve/+C7jPNMDInrJ8/JpTKNC3a1H5inhbbtULlwOJ1oNj3TaeD+7iALpRJay3oHylBq5PbulqZ1QCaXKtQSsN1cEGPEr7YN1lSs9VRAFXBOSTEwRbxzDONA6z3GaqY8cxpO+KZls91yd3NLqRPWO+YlMA8nrncXLPOEpoDzjOPMElYrmaZBKXmQLA8EI/O8cHO4p4uBtuvZdJt1p7TQa7e3t3RdS9s2xBB5+eIVfdfx5OqalDI39/f44UTRcH15xdY2LEvg5s1brq52PL/oeXt/RxxOqFx5c/8ZXeMpxbDdb2m8Ii5wexjYXe7pmj339ye0NkzThNZI/nhnSUrTtT0Gzdvbtyhtuby6ZAkBtCziNVf6TQe1yE7ZOXBxcclpGKm6rvZBim7Npc4lcBiFDNQIgTotgSVGNm1LRRFSZON2aO3IsZBiFuFYxYTVNsVZQzJSeFMrVCXWQDaQS6E+FNcJaxWmdixpoWsiP/vyBf/od/6IH37nG3zr+orGREqGhYzOmkNM6CrZRSEGtnZH1/ZUXfHeMw4Dal3dKgXvHdM08fTyEmMU03yi7zqKklxpo9TD/61zbNqWw2lgs+3oOinwcy7MSwBdMaZlWGbCknDGUVUFa8lp4cWrFzx58py+M/SNE9v8eWbbtdRS8E4AEHJmXBLDcGC/d2y3F8xT5bbeYftrWn9NfvYUUiZpBSFxXq+VUqgCd4dbdtcW7S2pSDZ9LdIQ5FJWixvJZ1LIzv4KaPQKIkkOR6kJaz1UTc2KQsHoStN07wr4RSxerG2EAq1ih+XWNfws3rVI8+Kc7DrXBkKKkouVDMZ4dEWaPw3oitIO7TymVJ7vOrrGM8yRL6aJX/rQ80vXO7w1JFUJS2bz1PH82RWmaN4MmS9enzidFt6kylwUuQzUasBUmpUKBYgqS8GqHY2tHIeROTbst0d+7eKKajS6Vso08fln93xxO1NNA0S8rjQ288OPLphPid/77CX7bk+3aXj5+p45GT59eeIH333Cv737kKInVFX88Jef8Ns/ueMuJ2qOfPT+N/n2XmIIvnf9a/z4089o9obrDv6DH3yH3m+ZQ+bw6pbjeGCOIySh3TAGsEzTgFKVYgpUzzIlQoxUMjHNv6hc/ysvYzRnS6HNpl8pOsPpdLYIU6Ck5DVaEL5S/1UKT275BOpdptb55xoj1+aZ9tRabLRSzrDaZEkjr4C1GLRiNSWDgkqMC875h98ppHxZyeS8nm/5ndM007bNAy2+rBRj0zSoUhlPI7WKo8DFxW4dAMhA4usFVOM9IQTCaie0pJUqLGLNsyzL14r5KtlM07wex8xm09O2LcM44Z0VQGMdVGgj98PheKT1LdY6ak1YC11jefb0iufPrpmmmSVkLq88z57tefPmnmGSmAjvLf2mIYQoVK7ROOu5vb2VWmstys3X8r5ijNQkBajRHkVemyRFiGLBZYysEfM8Y5RZASdZv2NcAIXV4ppRSmEqMoAIQYrWXCtt49n1G6FArSKGxNs399Qq61CMgb5rabxju9kT4oIqQtCKrZ9GacsSJTZgCQFXKnW9r88Wa96LxVeMkkVnrcVZI3EhcX44t846AX2Uot10dK0hRSHGa4F5iizLiFKSMyXNqcT+oKWhlpiQinM9p2FiWWah68PCOAq817YtTeNpGgNLoWkbLvcb8tr0phTW9VV2Z8xLJKRC23qWEFEhS/0TMylJvVxLlHtQaXEIochAxXfkkLgZJ5Y50rYO3zRMi6KUhDUroa81zmtyqTjXiLsTkZwrS8goLfdCWXdZwLsMwlIyKYuuyDAMxE7OYJxBK7HB61pP23piiiiEGjfWcBoHwtk9pmlwymK0HHulZG1YwkxczzmlkHLGe0fft5T8Lr5DKYXSCmsURht225ZhjKAM00qHK7WuMQqcd6TW471f72loWoeiskTR1tZ7qgWjNbVC2ziMkUiTxhmsUViruT8Ma6PuJJZppbQbL4O+CoQoINq271FU9vsNSik2nadphEBfcqVUzRwCXSOUf7vZoHSlr+sOG21IqUivEgeBv5zl+bMneGd58fIth+MtIWdSPNvFGZR5d/5yKXh9XofVOvRU1NWCLBfWTDS5rlDS6J8J8BjFltGvGX45a2pdhziI7VkphaZx7JoeZzXLLOusNJ1GrkFr2G46nLMorZmmda1WmpQkbwxVaTtLLQq39wzjgFKGu7sDXRvlel0zOI3lIZ9tGAa0ll0am01L27Ycj0estYQlcHtzh1OKv/7D7/Pkrue3//lPKSVTV6q/7zfrgGXhbJMn2WOBswWfMxazkvrTNJNSWYcKsrvAaLeu3WvWo5HGGyU7vmoSYLPWKtd2fbd+gWSH1l+0K3/U8EcNf9TwRw1/1PBHDX/U8P+/0fBH/X7U70f9ftTvR/1+1O9H/f6Lrd+/8INxbR1FRZSypAzeiKVB23XUUsWCeBUsaiWxfiAlYpZyFEqgOjSFXBKShqvQSrO/eA5oUo7EMAtlVMXvn9XiApWpZJRad4iWgjOGqhLKGmQH7MybNweUcaRlIS0Ljd2glKeWgDMW6zx1pSgOty/Ytt/GGEXJgZdffEy++5wwvcXWQMbwzfef8cQYPj3e0++2/Mpf+zXi0XH59H1SUWxaRbf5Jpu797hffkK/MdR5YP/kxAfPv8F0/DlLPvDNb/yv+FX7itv7Txmi5qf1H3I7/Ak7+4zD6Q2vXxQ+aL9FULCLG7QKvHYTU34NqQpxiDz8ev/ZBW+HRXK988IyRLTVTOPAnCa01ZgKrrNYu6HfPuH+9h6/7+m8kwdmbUvyMAwnlmHCGs9xOPH5Vy85HE7v6MKVciopYIynUx3KGdqmYxwT87Tgvdg351xQGsISsNajjNjHlJzxWj9kToQo1M80jEyT4mK/Z54npinS9T0VzfF0YjqeePrkCfd3t9zdv6Xf7xmXyJubtzy7vmaYBuZJ8lGGYSKeTpJ90zZiOWIMS0o0bYeOluk0UmKhLgXXGjBSdDrnCCESw0LXtOz3e+Zx4ngc0EZjveNit6cC42nEWyfZxV1LiYUxjmxsxxIT/W7Lfn/J65dfYZ2j6fYM8xvSnGldKwtPUex2OyowB0WpgRQVIQXmMHO921EpKCP25SFG5mUhxsjV5QUhLhgkM+R0Oq254guusUxLwBqLARpryXGmaEsImSUEurYnpfJAMrVNy7JEWIu5rm2JZRHL7dOAVpW26QhhWQtCKWjqal0yzwGqPDAn82D77awQRUVDbw1jqSxV8/mLG77/7feJtWBzFmrStMQshGsFhrsBEBsPsljwWyuZQNIcCPXqjKXGwBIDO98JdZVkV3CoVWgzs1qjm4bNpidmAQTElqUSYlpt4RNzmYXsrIolZ3KO2JJ5++YN3jW0jWO3adA1k0uh8Q5vNQpNKoWQJdrBKsvF5hJVI1NYKFiqbZhCousDJXfktJCVIucV0EOEszYNra4YtWbvoDDa4m3LMlaqqeQkxzyFjHYObRQ1g65GYiUU8kO1pSCWVY0XSxmAurp56Cqia7WFquV+XU/suwbrbOMlRdJaFYFRmCoUluRbZXKRrKWaFdY4aimy+55Mt+2BgsuKX7rccH29JZnMkguqaDCKkgpgMLry3tby7fc+YBgDf/hHL/jk7UBWigRsO0ejK0vJaLwAVxR0LuRa6Vey9P5+4JNJMw8zWWVOMTCGQsoWbzQlZJ49fUKYT/zsk1ek44yOcPP2nufXPZlMhyYe7/nd374lAzFCNRVNZhwqSyhgIz/650e+uNrgotgbHabA8kniJ+UznNfsjGWMgRnJlSpUrDKkkkloYpJ7qJIJQUhxo7WcWzKlnouxf/3XuXGWC+Ndk22tRakzlS6Uas2ZollpWSHEz/Y//0OE+YMtkbXklZrWSgFKPuMKJ4EQr9KMizNECOcsL9ZmRqIXrLWEEB4utfP7lfwbyTo7E5pt2wLS9J8zv2JJ+K4hp7rmnM30XUfO5YE4VFqghDksawOjWNbsIDku0rzvdzvGeX7499Z7Uop43zDls/XaxNu3NxhtMcaw3W5Iq/WaouKs2G4Zq1HKcX9/j7q44KOPfolPP/+EWkBpyxdfvmCz2a7NojTM01To+5YYM0YrDIZaFW3XMk8zXbcROl1LTZSy2CgZLYMWZx3GVLxviPEItUgDYD0xBpqmQWvFaZwwVrPbbpimZT22jbBPNdP3bh1ErMMJkM+jZXggcTkFlkoIMzGJhVHrG25u7hnHgWdPn1CLnLPb2zvmOVK1JUWx7dPKEJbIOYcLzLpDIqE12DUuQ2m1UrFJcqpWqjuXjLOatm0wq/1g23rmObIsCyEIvNU0DcZq8hLx2uCbBipMy4zY2UkRnvOEMZam6YgpYoxksMWYifGE94627Wgaj7GGu7e3sF7/yxIoK9Xa9z3zEhjH+aEJjjFJVtpaq6dcVltFcWJZlozVmdZVrFPsdj3WBFAZrRRGQ8pivWaM4XAYALl215ucru8ZhwnnHfMShWSuam24Re8FJARW4jbGtNLG4K3CW0eKApkpJbU8lNViTxFUIEVxe6laaj3Xtph110SMy+oyI9pglEJbTU4RVSGnvO6qWK0glcYaT60FrdVDLVfROJu5vNivDfi7LKxN360WZLIrhFrJtayNmWbbO86xPylHoflDxjftuo4ktltP13tSjGz6nqYRm7KcE413GO24ux8kRmXT4JwhxcRu2/PkcksIC23borVmnAZx82laLvY9xhiOx4HrmPjVF3fSO3nLOC2kqvmvLjeMyyLQq4Yi4xPa1lIXSDFgtaJpG0Dy45Z5IRfoWhkExiQRQ+fhJ4BdbfhKUeQcUUbT+IZz1lfjHVdXl8Q4451Q62GNIgJFSnKthBDIOeGswTpH3/fc3Nxxtht0zrDf7/DOrF8vO0FCSNSS1p0lK+m99nPOWKrRZBQxLaAV2jgooLVYdRpj1h0rkXPG5jwvpFSxFtq2ZRwGqjF88tlL5nmk6zuUriglw8R3GZcSX3K+PyQ38l0GnAKxhFxpf63FAlEr+d6U03qv/WnbPLnGz/fMO5r9PFTOOT/sDvnzvB41/FHDHzX8UcMfNfxRwx81/C+fhj/q96N+P+r3o34/6vf/fPp9OA5oq0mxsOla9tuWu7sDMSsolXmZZcf4o37/ldbvf40H4z05BWoCZSpzCewvtw8LNAq0NahaKLmiEd98VBFLgZihFCIJb0TwQpgxaKrJmH6HVpoaZkgJoyvVGKpSKDQlBzlB68VTESpFO4epyMVsFDdvfs5XXwS++a1fxwBXF3u0gcSCKhpdHEY5os5yMShNvruh9j1vXv8x6f6OFAZsLlx/87ucxtdgWp5vn/LLv/TX2L73PkorVCnoEsn8gJSg1IgPiVcvEx/t3uPlZuDj5f9MNw180P495knxx+MJu/ll1OffpbQvefnepxAVkz1xsenQH/4x9qsrDm+fM20SYfOasH/BZCxd2q3llFwICzMtiiGMLGGg7fYc5wVrPcPdka5rOY0BXS2xJu4Pt1zsNuSlkmug37Ys88gcA2QRoRAjL16/4f7ujhgyujdkROjSEtm0HW3jqTVzGk4r8WdwRmG1J0zyELDqSk6VyryK0YTVhhCzkG85oa2l5MRm03E4nDiNJ5qmZYmR4+GEbxq2fcd4Gnjz+iW73ZYLveX13Vu222tc3/Dq9Ruuri/wvuXm9g6ttTzQnmfmScjB7W7HZrtlOI4YpWmcY7g/Et0CVtFsWrxvGMeRvuvYbLbkGLm/P+CdZJdv1gd6t3d39H0vZE9K7C73TNPEcZjZbXpiKShrubm5Y4kL33n+Hi9ub/n080+4uujoOo+xjuF0xzQn+s3FmrOh2W17TkOSBaZmQo7UkDCqrnlBmnGcaZ1jGAaUgmdPLohh4XA80Pc9qhbmcZFsaGu42HZMwxHfWLQ23N0c8M5QqoL1/lRG7En0mk9inOQI5SyLX1yLu0MYhd5aC/jzQ/Vai+QqA7km8losCxmkcEYRjYGwYKjEknhxf8OPX7zk+uIjQPKHcox4Y8lknPYMwyD2HUaKe+uNPLQ1Zs1YUYRpQaPAGOZpomvENj2EIJk+RiIBtNZ88cUXbDc7Li73hBBY5oDzVtworCZmUFmxhMg0z1xcXmKMRRvFNEy89+QpSyxoCiUmeXgZM08uL1C1YJ0np8Qwzlz2Pc5BijO2OoZcKDbim5bPvnzDr1x8yHb7lPubl8zjHSnCOQOqKvDbHTpGXNU4o/DOgnJC0FmHohBzQlvJSyoxUDSooh92fPvGUzUoIwU8SqGUEYeBnEGbtYBZBMBQ+mHnf61C0KlaiTGt70ssipx11Jof8pdyqigKRskDbaWskMxasaQF03jICuMcFig5Qatxu4ZUFK42zGSMVTQlobQDW0ilYqpFZY2xir7RDMPAEkHpQgmBrt2gYuJkxJ6GWoCISYohFpSqfPniyBfpxKVRjAnGDEpljLLslkrVlddffYUBjqagsxSfaVG8CqMUGMZwsyQcDdYrISuzITnFdlN4dt2hzQ5bFMZrygXSBIUdYClpxDgwGfZuh1mJ4qoVzsi9o11LQSH2QgmqwnlNLYlSwLl2pbz/bC/JTFKEUihFLHXEwkcgk7NN2plOPxcV5+Ku1vpgb/R16q7U+mDjE1bo6fx9pQp4kbLkwkgRD9YJSeq9WxvzAEixIzZpeoWy8koM8gDDWGuFHF6HAmfLMpCCap6mh6JUa4P2lrIUQkhYGx9snc6F2fl35CCEetu2EMEqIRpDECu4xjmcl3u8rg3z69ev6LqW4/FEKWCMRBvElJkXiY7xXuzNzLp2KQU5R2Iq3N2dOJ4mXGOY50Vo2Fp4+1aaVaUlYkGthK1zVhqMbc/pNLJMkffff4bRivvDkVIrcVzYbXbSlKyEZqmZxnpyTjx5ckkpheNpYp7ntfFW8vO9p9t0VBJXVztQrLBhohaNsWZtjuUcjNO0kqqtFLPLgvey+0AbDSscud32LItowqtXr7m42NF2Ddu4YZ5vUavBkFZQUTjrmRdZo33j8N6uQxi9UrSsDVnEOU/OAckA09RSSEUK+m1/wbOnV+SUubv7ClA0bUc4DgLBxYRS0Lc9ShVSDvjVySZnw7KInV9KhVIkx8xqS9GaEAPUwn67wXnPME7iZoRhCRHvHWERGLRtPdOSpEkv666OBDlVJMlkJVtFjVC2MgwzoDmeJmot7HYtXeMxVctgam0mLjZbtvueOcxM84x9GJwVQlgkmkPJcQvLgm8858xCY5TEfvSyu2LUcXUdkTw6pQW801pzPA6yU6VUShZyepojzhuUtqIxIFaHSkn8izGrFZjcnzFEuq5drfI0XdvK+/YePEcAAQAASURBVAphzR2r5BIwVgYTxhg2vTS5wyBxK113SYgLTWNpmhajDd5bhnGgaWQgVtZoESXTRrSWAZx3Xq7LWhnHhWmcHtaUvu/p2oa2a2jaFm0kmqRtGqyzeCfDyyUslJXyT7FgTUPnW2xjCSnQND0URcoz5nTgSddJ3NRv/wHNT78gxkyeA1rBxW6D0po3N3f8h1+85tPrPZ9ebshfvGJJiaVWNtsNbVdp3MjZBk5Ic8UwTnK+tOTXmRChFtrdhphWTUSRYqasoJ11lr4Xy7xaMzkrrMnUqrHWMI6z0PpaMvCas83lOnwspTKOI8YISX7OWIwxkWJEIetp1zUI7V7W4YpbCXDZTRRjxjeWmAcZrFTw1qKBWhKtd7hm+7C2UgveNyhVCSGuFm+iE13fMU0LH3/8JSFEnLUrQG3ZbrtV++D582fc3t4SQngYusW4PAysS5E8zr7rVltTsTs8D2krUtue9aesFppirVcehgbWyjl6N8hWD/Z0f57Xo4Y/avijhj9q+KOGP2r4o4b/5dPwR/1+1O9H/X7U70f9/p9Ov1OYuLjcMwxHfv7zT5mWmWGMHE8j1sCub7i8vOInP/uEN29PbPqOvm94/epW1tMYHvX7r6B+/8IPxkM4MIdP+eSnt3zvO3+Ti/d6oYaqplS5CaoyKOPQqqKVPKiQDyy7jikVUws5LDjvKKGiViouhQljm5VQWy1itKGo8nDh9f0FIcluR2s0JQtt0PZb2ZK/jLx39UO+8Z5hDgth0DTmfdCGHCMpDVQ8Vq/h8scDpsIhjfi5o9c9kz/Ruity26MwXF+/R5wCWgU+/9k/Zv/Vc977/m9ROkvNUcifmBjvXmFiz9Or95hj4FvzBU/8f8prfc/tcuC4WL4dez7c/yp/6+l/wu999fex7cR8r9k/K/jLz3miPmTiBnP7fYK64P6VQt8+46Kr+MMWvvZgJC2BwzByOp24uz0RppHPvnxJ2zbkUsU6oUAxaz6A6+ibLcplnG8Zlom8zJAqWSm0dWjAOMtuv2E8zZyOR3Kt+NZjlFAjuZzQxq0Z0AmPZI3HeMAYzTyOxJwwXuwc7u8mUhB7FRSomjHGAhpjG5ZJSKrD6YSeRrq2E3Lu/paub+g3LYf7wOs3b7l68oT3nnbcvn5D9R1Nu+Hlmxs2bcvlbs9xGjkdj/KQuGmY55m3N7c0jUcryzmPo9t21KqYp4XTfEPXtTS+ZZlnrFFs+g1LjJxOJ9rrhnk40fcNT64uubm9YXuxxXrF3f0Nm65jt91JpvkUeHV3R9N17PqOl3dvaY3hG096YjUSRTBMNK7Fd5YvvnqF954rt2eZIuMUIFUuNntCjozjyLZtCVkeZnrvocA4DHRdwzJL3knbij3QMJyk8LMa3xjm+Yh1GqUMr1/fCXmz7uKf5kUoxCQUoORCSD5N32wZhoVCwfmWnCT7RAjTiNZ+tQESq56UCzqLnHvbUntDyVUegpaKr5CNlnt+CVhn+OLLG47f/Yhd37AMJzrTkrWmcZq4JI7HI67rhHDSVuy6kQeuZ2tvBTgjOfUxBaZ5xju5/udlwa3WVSEErq6uiDkzx4CxFuvEtcBag9FSLE9xwRqDb1ruDydSKnzw/nP8rkGnwMVWMnKsUYRYV0Ai0DjPcZioSj0syClFMJrb+yP7bsd+t+E0D9S8MB3vifwcdfkEPU4Ymx6aISpY7ai2rpY+iqIqtm3QTUtRIhK1VHISwESjqUlhjCerjNf+ofi3xku1i1ozVs67ycWtI6SAVYpSC1ZLUauNRtVKKZEcAlVrlBHqN8aJtm1IWQp5ayAtZwuvhNIVlCIVjbaOmiGXjAU5f+vnU1qy0Y1RbIwiBEja4JRGW0MJERrHuMyUmthu4fvf2HM7LPzK9z5gORyZp0zbXBMI/OGXA6dJKNxFC/gBFW00F9ctf+sHv8yP/vBLTm9fY5zHYvi3/9q3aWzBVEgWsTWPCZzk2+87R6xFstuVBZWgaJRV2LpmwxvQtaKKRtkqcFda0E0nD/FVpaiOWgrGelSoFC20t7GarCUrzNuWnApGQS2BZc2K17pDA9MyyZP1P+PrnGOk4KEJP9PX56Lk6zli58b6/DVf//tzg/x1SzXgT/1ZgfqQ+6Qefp+4yuTVdkqa0VrlOBmjaRpPjInT6QRAKWYt/t4NDM7vIYTwQNM3TSOkaJXmfDwNhBjETYZzUy/uCNJovWvk82r3c/65tVZ861iWAsqsxKQ07Q+Wbmei2TiUkmI1L+GhyZeog8TlxaXUNDFxOg3sdhuM0TLAKLAMA9tdi3We03FG60JMZXVAgKbx+MaiVFmLSBkK9F3Dpm/Z7XuMhlIX2rZnWTrevD3QuIaQM6pmNpsO5wylCAxTq6ydUmMha1WtKGVZ5ihATJnRStGs+WjWSL7PaRgoOVCrDAxYhzXS4Mqx69oGo8G7hmkeKSXgvGYJhXbNgKq1cHGxYxgnxjHKz3cN47ysVGil6/36M8H7hlLySt5WJONJBieo+nBu5JyYdYi0Eq/a0HUdIS3UKLVlKUIhG2PIOdK0HpTDe8c4jusODXHJQClCTBi1WoB1UtAbvV4/60CqFLHIk59d0E2D843ANUtYh1LyM8xaP9X87l5USlFR+LaBRXLCzrZ7IVZqnpinhG/dw/EQOzor63UrDZTkj0GK72rnkjONd3StZ54Dzmm61rPd9msOYaDrLH3f4b2laxskqsOwLNJsLYvU22GR2BxnLI1zKCCupHbbCqEdQngY0m2329XZZkBrhXVC9Dato4yZrmvY9B27fY+1T2gaT06FaRp5773ndF3Hq1dvefvmVoYEZsNms1npY8f19ZUMGq2cv4rosEJJ7WIUjZf11TeOTb+loLi5vcU3HZeXV2w3eyG7tcY1MqTIOZFSxhrZaeKc/ExlDSBRLRqLZOwVhvGEUoppnHnzxz9l99/8iPLZ51w1DafTiQKkIA45yzJTKjSu4XCUjLsPl8j3b44AaGP4HQv/4pm8n+22QykIQXYKKKVlB0vOhCVQq9DSzlnZOWHUA7SsVmvAEJbVFtDRd46Lix2bTcf9/ZG3Nydu7w4ygKpS6513N51zzrbbnpIjRpu1lsgP2WNae4n6UQ5qkoGoNnjf0DQZrQ21VJYYSamAUozjRMiBlKpYd9bKd7/zPikFPvvi7cMwFhTanO91xTmTbZ5noND1HXmcoVS0MYSQkElf5f5esgittRyPx4d1/qyBkvV3pszr2n++67PO9Ll1EhUTY2BZFs6U+n//dV5fwTzoxFlHv/Zj/0yvRw1/1PBHDX/U8EcNf9TwRw3/y6fhj/r9qN+P+v2o34/6/T+Nfn/88cf85Mefcn+4Y7ff8uLlC0BzOM0cjjPHwx05VbbbPZ998YZhjJyGhcuLHSDPzYbTQq0a7x/1+6+Sfv/CD8aN1XT6m3zvV97DmUQtCqoR64eSYKWJzvkYZX2HpRSxE1ntYMPhJba5RKndanehKcqsi/tCrZFCxqkGlEGRxY5hzXHItpJyxWqxOSg5Ah1aW6rzlDSTlwIk4jyhdIdXGY2ilswS7sVSOM0s0y01GvaXT+WC3VyKHW+aafKOpRqqA2MTmAbVfsnbwxv2hyON6mWHrVaclhNLVrTb99FeoeaZOI9s8kd8f/t95vKa3x9+mxeHAz87/lfsdoVQE/bj94n3LymXJ5JyTHrPhOy47k3gW9ffZVoSU17YP7tCazmrFRhPd1jvUVQa13B3e2IKgZvTkd32GoVYmqtsKVlxedGCj0xzJBcj771pqSZiSl7zVSbSMhPnGV0rrfegJLh+HEeaxlOVbMxstKWiOQ4DqhQab/GNexD8HDK5CORALoT1uiAXLvcXhHlhDoGmbQnLjHeeEANvb95ysduyu9hIjoIydF2PUoqbmzu22z39ZsO8BCqFZs2VyanQtB105cGu3TcNKSWmcSSEzNX1Ndra9QFgZecsQ7IcDkcut4Zt3zEMg5Buuw1Gb5jnGdu35CiUnjGGm7e3GGt4/vwp83Diq1f3XF9ckSs0rYUcGVNAxUL2Ct+2hHHh7c1raoV9v+fu7sDFxZ7Npme4PyI0osNby/E0YPuWrt8wzwtt13F/PElueIy0TYuxlhgS05rJI3bqklPceo9RkuVBhSUm5phpvcUaIQmXSTJtGu+kAAmRi+0ekIfK1jcsKcliuO5w1U6jVRY7IiW7tnURq3O5PwVaCUWDNmiqFAtRsoRa52isg6IYTiOfvbrl8oNrNtpi1mycbbvhq+MddX3wff7TrJkoKE1Z/9651V7GWdlhDyxhkl3ey4TuOox1jOOMcxaoLEtAa0+umZgTMWeMtWjj0L4yh4DXmn6z4fXbt5yGkV3Xo4zFt564LChlgLUIRRNTofENIUaM1kxLoNt0HE4Tu+2Wvvcc7wZ2247rpzuG+1c0KrEsmW6zwfLugaeiUmsg1ySZJCiUssQlYqyRY18M2jqykoxxgyNVof68d1BFvGoRj6Cq6lrAaUKMlJpxrqHWynga2O96seCi4LQ4CNQi923Xt1Ql8FMukZQi5ewKohxdtyGoEaUKBg9VzqMsPnKd1ALKKAnOMFp2g+fMlBZ++nrmxe3MOFcwCWszT3eXPNtseLbPkkMTKm3X0PpAswQ+eO8JXF/w848/YX/hcL3nyfaS3/vkli+XAaeE8DUVSlUoFC/v7zktE5vthqaxfPtijzGVlAsVIQ9rAasqKUZKrRxPkVTlHORz9pBW1FxRRmEVoFbXAaPJIYklPVDCtOa1VDrXCHiSxBLflCoW99WhckHVQkxVNrwDSvkH+EMbR62VpvMCNPwZXw8UuaB/QvU5+2DJBqzkLMQ1k0ianoLsWBdb/zMhLnSfgCo5f/36PWdRlXfNvJFrUn5/XanLc7Nfcc7ivVvzZhJnWzeleLDegXcZanWtK3IuNM25AUsc7u5pvCdGibioCqZF4h9CkEJW/qfI54ONNFZnurCUgvcOvVKJZ6urWivTJHTrdrt9oKMla0saLMmQE7rbOUfTNCwhklMhLBGt1WpNZMkZ+r5ht99LREhv0JrVFkyGFdY6gUe0XnOxEilFplmuVWcNYbFoU4QID5FvffhNcoa7uxGjKtYapnGmtDJ8mKdIVYp5DigjjgSqgjGWFCM3N/ekJBpqnWW33fD0yRVVVbQyXOwveP36BucsF5c7QAAdGd5UMhFKpWvFHqttL5mmSTTFarq+Fbu5XGS932xwTgDDcwE+LWHdpSD2STFIfpJSQsCXerapKg/XtFbgnRM3H6VonFxPJXfrbomKs4phGOn6BqX0Qz6TXncSWKtX0rZjnud1R8QqOwqMNdRcyDmucSIN1lqhxK2lZNb7RY5JyuJkcrZ9atuWEGaUMuK+YtQDqX/OGyylUmKkax0pRpYQKNkQ5kBKAaUdIcr6qpTEAcUY8I2n6xratsF7T62V4TQSU2QcJxpvcNbQNJZNL/ZkXed57/m1XL8poZTQyWJ9166WWRNt21Fq5v5uWG0XYZoDjXfsdvL11IbdbkPXe5x1pCy6m3Oi6xq61mHNllIz+4sdSinmeaaUROMcF/sdXScZZW3XAJCiNPPWGrrG8eT6kqvLPbv9js22Xwch0qC1TSe5V6cTbdfhvQzpRK810xhpdxs22w39tsf7hu3F1drcbmnbnq7d0DStNFAoIZULVGRgaY2s9TKEixxP99zf3VJqIcXI4f6OeT5yvL0l/Z/+cw63I7kUtFK4xmGNxMTMSyTFzJs39+tOn0otilASMWVqkYHfbzhNPyz8s6Zh0/eM02kdcCruDyec94DQ0sa8G7CO4/RwTs+Nc9N4rJUB12kYoDZUMss8YYxfh1wCt6Uowxfga7uB5Bhs+o3YRA7TCgAKnS1rdXwYfmpdSGmkVrXaR8a1LmDdkSDDk5IUWgmcSBVC/733nvHJZ6/JIVKq9DuiE+YhbzIlGajFmIn3R2qRIYmxCr2ep1rPkTuC5eVcZJ1LkqWZkuwPoZyb6fpwHzjnHpp3UOuA4F3O4vl+Pe8COw+9JRtRBtjnIbU2hpgC9c+3YfxRwx81/FHDHzX8UcMfNfxRw/8Savijfj/q96N+P+r3Xwj93u/f6XeW6NGLix1d6/HNn1G/2462bf5/6/d+1e9Nj/ft/2j6fXN3y3/2n/0/OB4jMcr72+46fGOoKO7uR6ZpYTh9hm9a5lApWTEMM9McKKmw2fR0ndj011Lo+57pUb//Suj3L/xgnAIGT9WZkCYu22+glGI83BFzom0sRLFjKEjOgapg1mm+sU7orHRHnme076BkqquoGijItn9SRMkTITkQ1QCZWjOmNpJPnhPeeGIt6Kow6y7DWiPDotExkKYXxOOB7uop1RjIC0o7VF2YpwXbiT1M23YrASW24LbdkO4m5vHA5sl3CGVEW8O8HPC24+L5JfN8pDaW7mJLCQPH0wlnHSHNVBylLGhVubv/lOVj2G48u1ct94dXmMue37j+Fv/ut38dk7+FVZauK2QlO2prTvzR/lP+0T/9v7HtNvzGr/1NtAuMZZTdmAjB0W++wc3N55gK15d7Xr6559nz5/z008+4u79nt9mSQ+Zqt+HZkw4IvH5zYr+9ZJ4XXCugwHA6MU5HYqiEnNFoLneXpFw5TZIbH0KSXdgKoTl0ISlNTAFnNCgoNYs1ctugoxRyEKk1UZWhaRrZcZozp2FAVyg58tXLW3bbHcZoVISu7bm5u+dqt8EaRwiJmBbaztO0DXe3dyvpFXHGA7DdbjjcHyhFCCitNcuyMJ5ODyJLXXj51Vf0fY9xIvA5J3bdlpor0zKjNPjGS45wimhtGMYZDJTqMFEeovXdFqUq9zd3bPqGfrNhDJHWt+QwcxpGtLFc7nqWaWYJM9o1bHZXnA4Hppjpug05J968fEPbd/i2wcT8YHUSa2EYRjZdT4xpFR8DWuMbv1rfC00VY2S323F/d2C779G14LSjlgQoxmEi5cKm6/DWEsOyWs17tv0F07TQtT2HuyNN62l7i/Mtdl5YpgVtDFVJ5koKUYCMNTtHdm4rNIrGW+aYUGQaZ4mhyINFpWm6jiVkasnkXPAucXN7z/D8kp31xJJZjCXmwotXr9FKY9Rqw2Ikh1kXWUijMfjVNijEwHa1pim5rM1DJqUqWeta/n1ZJjabLfMS6PtmXUAVKVdCiuQUyWhiQR6cl0y36Rjnic57EgmXDN5ZIauMlnykJLbidb0v26ZDKcXpuNB1DX3rZL3yjlyBmsjphKkdrdkxTwf6bvu1hVbhqjyoNwa8W0UjJpZ5wFmDwRETKyVmUGi0FespreHm7S2b/XYFIyrGOWpWLDGgtKJvJA8pzItY22hDUQqq5Iqbs3298eQiOUYKhTNeduRnEWltrPx3ZdDGys5pFMUJMGCco+QABBqzgaJEK7zj1dsT//CTl4xDRZdA1p6qFLpU3r75ih83Fk/lG9dbPnpySWeh6Q1qqMSq2e42PPvGHtdsmZfCk4+u+Xsf/RK/95Mv+N0/+SlVeUKOaGV4c4rc/PFX6GRpm8zf+eH3udz0eGVYlonqLRbF8XBi028kd0fBEiJN16OV2H0ZrdBGEVPAmw5d10LEaGDNY9caZYxY1SuNt81KOCqc61DaELIUigpPyZFEIqcFW2G4H0ipsLu+pFbJBkspkUv+U83vv+7roXnRmpTKSrSKHVRMK72spQIqVb4uRmngpfA7U7VgrZB41iHkIWeqsKKVYrfbME0z8ywNrhCWiGOMFqs2sf6Rv3fO4Zx9oENrffc7ci4rkc7D1wtJnB6KnHOmWcpljZlQGO+oRqGdWS17RCuohcuLC6ZpkjgCrem6nnmWhlsGfWIt13UdpRScldwl5xzUKplQvqHU8zk5N4iapnGANFQh53XwAEprOt8yzzPjMK2ZbJUYApuup+TKPE7sttd432CMomk9x/sT1hpCyKRUaNuGzbZDVUOIgePxxPPnT9bmv3J/f4ui4J00wLvtjnkOTJMUhbkqhtOEIDiFtnE8ub4mLBNtuyNmga2s02xWzb+7v6XvGqhRQByjSCnwZLvncH9gHCc2mx0piY1Y10sjMU0TTdNwcXGBn2cOxyMlV0wjOVTTtEgukFHMy8wyJ5S2oN5l2JV8vv5EN0JM5FJFF5wMT2qQmJ1a8rozATabDdZUTsOAWTOenj65pBQIqawFtyWlTMqZcZrQqoq7jNb4xlKLEPYyIFjpdiU7Krquo+RMTEnyoFJ5AGeAd9euc2sBb1nC/GDrJNetlXVAFcn/q5L/t7/a0/7HG+6/c8LkjvxPAu6PHDmKy4mxhrv5QL6ubD+44s3/bkS5iVwkJ0yh1rtWBglUzUf/zfvoY8EvihjB6ErTWtr2nMfXkaNcY+NxZDgsVATIubzaYazl4mIPwDTOxJS52HdstxuWJTCNi2iXt4Q009Cglawl223Dfr9l0/ccmoG7X525/fZIiokQIqYm3vvnzxlfnihjZowjXGqu3r8m6MKXb14y6onf+v4PubjYU7I0T7ZfXYCy4fd+/5v86A+u+erLFzRti3VWnH/WYdCm73nx4hUpZz78luI//o9+zrPrliUsnO7v6fsNSlnapkc7Sy6Z999//4F6t9aRSxL3kFRljUTL/bUseNsJDBpHGqvZjoFlBbRiLuR5keiWAnGRZjPXSkxy3mGd/CADyTRNbEzH3zKe9/7wT/iH336f0SpKll0ltWpOpxGFwljLskTEZtOglFinpZTouo66rlnaiMa37RarFTkp3hwPzEvgOEykWClVnGRKlgilru0ARQgL4zgwbzdsV+cc55zQ8iE87Egax4XLywuGYfzaoK3SNHKuwrKw3V9wOA6EZUZViDkCiaZt+Pzzt7x6dRQYLWe5zzWULMPOec4Puz3Og1QZuDnU2ieWkmW3z9pDzvMiNUgjkJlWotdCrsuwuFkjnnKKa/NeHtZuqMQYSEmx3W6plQed+Lq+nm32llXvREPjn1mz//uvRw1/1PBHDX/U8EcNf9TwRw3/y6fhj/r9qN+P+v2o3/+z6ne35fMvPuDjT/72akedH1yav3pd2G9+l+fPPsXaxOVF5vLyCqXh7ds3jNPIr3z/V9j/D+m3qvzek5/xo83P+OqrFzRNi3VG9DsErFVsvrXq95R5un3Kv5V+k789/Y3/UfTbW0OtlkIBB/OSCPcHNpuWkirDaRZYphbGSdbYuoJDKgtw9ObtDe+9d80HH3zAP/4n/4TrJ0/Qqj7q918B/f7FrdTnW+JYaZoe12zkji8Jaz3GWry3zGn1hFcV7ztSWlClgtaUmNEYNhcfcnr5Mfb+JU2/IeNpvCfUhMmamqLsQvdutdxeSYAqu0RzzeQcKFGsK7SSC6YgD7qtL+S4kKY72v6Cpt+TFFStqUqjTUuME77Zsek3hMPAUCVvXPuVdjIdbt8xxEjbXKKoWOPY2Z4wRUqVDJNwf0eaT3IBk6lErLFo7YnZkFKmTK+5r1sSM5f1ir/+g/+Q5x98g7pmx+uq0Up2JMaQ+Se//1/zD/6f/znDpwN33e9yGZ/jvtlw5A3m2+tuxJw53L/BmUJylpvbt8zjgvM9zihevb3n7riQS+Xqgz2tE6LqcveEGBNN35HLzDROpLCw7VomlUhTRruWcVxYYmBJkbbt0RlOhxM5RzZ9z3SaCGbh6XtPSCGyzDOlKpYpyiKhNAq77pjUkkGd85qbYRjHUXZitw3GWe7u7+gaIY3nJdC3PTkV4jJirKfvOqZ5AIQmS6sd9vFwWIm4biXMJk7Tie12S9O2eNcyjgPjMOJcS9f2DMOAbxxN02GMYRkHet+itlumeWQ4DThjuTkc2e33bLuO0+GI223RnRR/y2qHQS2kWlDKcHN7x9WFolTF/vKKlAqpFLSzLItGKziNt3Tdhrd39zTa4pShbTpiqQzDgImJisJ4K4TyOFGLPHBrmoYlBppOCoKcExjDcRh4//33ubu/wzcN1IpVYLXh/v4ExnA6nOh3W0oqKG9IQfLit5sty7yQS8Q7sWNv204yllOgcw0qFaqGmAJZyftKMWFW+6QYpfBUSh6UqwpOKRJVMsNrQFtLjhlnpEAuMaIoDMOJCNwniDkTtWWJgcNwxDrJ8Mh53bVes9wr1Afrm1okA7tUeVAbQsLZhrAEvGsIy4TpWspKIdVaYKVo+37DMIplxzhMQix6Q4kQS8ZqRd9vSEtYCau1SCxCe2lvaE2LsmKjU0pms20ppTANE23fg4Lj8UTbeJTKOK+4PZ7YNx5z+5YnVx8yjzO5rHZBsroTSqVSMdpSasVaTTGVkEa09dQimd1KGyoapS1ZJZreQZRd6N45rDaEIvlMOANaYbXBeU9YKbMSFqCiiti9WCOfJWfJnEJrrGtIKct6i0HpSiqCeFUttja5FHQtsBbGzreg1+JJWSiK6jpsLfz0i5f89idvybGiTSIqR6VQq5LoBr0VsS+ZP3kx8+MvPqfVlevOMif4f/3oJ3gc33vvKU+Uo/cF7wxd3/Dv/tb3CSnye1++oG0uSSWis9jt4BXdruPJxSWuykPmi74lWEueE/v9jrRaOpWcxcbKKDkz1q8ZLhlnG7yVnCxltOyGVxa73gNVyTGpCKigtCbpiDFVaHGlUUrIZk2mpoDEBBiBrdDUnKBATHI8jVq/98/4kmalYoxaaeksYMjaoCgQGxx9dgf4+u+q0gjJCrwSvHL+jRKXCKWEItZ6nQ1RH2h4s1rAn5t6sWVz67oBtWZCKGvD8o4aP5OAZzJRcpkkDkMpobtrRTLEcqbYgtVCl5OlSVZVUdfGPmeJfRjHEW00rWkw1jIMA7V+zUqryroSwmH9vTMK2PQtEh8jDW1KcaUUPbUqlmVmv5M19Z01nqyRkkGk2e93HA4HrNOkFJknAQGvri548vQK3zqG08g0D1xefoMUM8scKLWy23Y0jaHtPDlrTFDkFGTN12I3l2Pm2bMnGHuH9w33h4EQM1TJsmvbjmUJxCWitBKbrjiRa6TrtzTVCp+YIn0vQ8dlKUxzxGhFv+nR0wKrE4PW4JwnhsQ4Brqu4ebmbv17R55mhnWNM1oTY2KepKg+nUZSrux2PWEJxFilQFealGW9MdrI7pxUVvhRrsO8Uu0xZbq1sZTMukTfe3JN5MBaVAe2O8mEG8aRmCqlyPVYK1TkXvfOrH9XyUkzzUHIcMQei5xRToh0cScJeO9x1mINLCmRl4hSFbuS5/cHWf/POUlKqZWyjcQgdn0gOxJqqbjWcPWfPuH2Vw+MdxPDOBF/LeN+OLLZyo4qKsSxEOaFL9RrrDGoKtdXqfLe7JotRpTG/Kf//pe8P13x7B925C8jTdut96q4ypRSwFRKhuO4cHd3wHnNBx885/7uiFKw23YYY7m82FBKpmlaas20nZPabZ6xVuN8TwiJrm3QBq4udvRdz83pwD/6W39AqoXweaKcI0+c5e1fO/Hkdcuv/dFHfPmdG1788i0oRSkZ/0NP33b80hcjz6an3L29EWK6RK4unvOTP/ku/+//T+GLrz4mJwVqoZaI7GyoGINYHM4zKWfu7xMffvCEf//fu6PtO7GSBIbhwGeff0JYFnYXe6iVb33rI6xtxCkkyfVkbMUqK4OX1NC2mzUTL3I4vmTbd5i+JaUBtbph5VJJMa/rvkSh8P9l789ibc3T8z7s95++aQ17OGPNVT1P7G6OIkXJIk2KMiVLkGU5EAQHCBDDl4FvgyRwECBB7nKdKwcIIgRIDDmwLcciZZNsk5RIUaLU3WRP1V3VNZxTZ9jTWusb/mMu3m+tfaq6KTXZEcmm9mpUn3P2sPba6/v+7/MOz/s8Uq9KEJu3cZgbjaXAOHgePnzErm7oUZSi6ccB5xRt18BQAImHMXpKEXWWmIWhXkqQTQIQrJ8330IIDHPB7lMmJFC6wtVZNh3m3Gq/MYQygKNpaiG4JmamekIVhAydMs5VKA3T5A8bE8YYispU1jIW2ZR5+vSCoRfSrTLSACFnGiXYNIyDkMuUwjmDc5YQREpuL+F4vWGhDudYCM7XEnQi0TZLis4xva47UpTtmP0bXYAYJD/MlJlwKP/5INsZaZ55bLfDYbvLWnMozEsWr8KU5evHacIYw54l76wlfh/EthsMv8HwGwy/wfAbDL/B8BsM/8HE8Bv8vsHvG/y+we8/Sfz+xut3+Mo3PkPMG7wPgt+jxznD8fERm+2nee/J52nrK159+Q0ePircOv0Ki0XL888/z2q9oqqq9+P38R2+9uKb/NLuH/POV5/M+A2lxGfwu9DUC6ZxEPz2Wz528iKphH8j+L1adNy6fcQwPaHRDeThcNa1svOQV+YWmSSWEwiJQOYJgjcX51v+2T//MlXVoRBMusHvP/v4/b0PxrPn6nLD/ftLXNugDJScMHUnYUUVsg4Yp2U4bBymFFKR5LbMXuHOtqjGkaYr9GLFGHeMuicrx1p1EkzGiWQCJYivACXPksoikZ7yhMqNDMlyFBaRrigo8AXrOrq7n6QvEEVoGK8KytRo4xl2OyrncNaRnKNYy7jZEZVFVRVZW4xpsKaAykwhsFjdx49nlHBORvzPQxpEQkFpSswoE5F5i6Fd3MW1R2yuHuB0oW2WtHje/ebrtPWCxa0GmyuK8YQi7JBHZ+/xzX/xZV5pnufi/hVn257zr32V/Lbjs//O36IyLXABCkJJVKphOzwglcLR+hZ932MsVG3L9nJAa8Vu9GyvPKbTJDNRSiZFkVP204QPAW0taGFq+SQSNxmYgmfX9+RY6CeR5OjHkUo7Tlcn+CmSQ6Z2CxKQSyQGTwyepjUU5gPUVDijydPEOPvD2Mqx2W2pqopu0eHngqdpFpAjXVNTSuLJk3NCNNR1I4lXEi+RZV1z+/Ztzs/P2W43B9mOWgmTRIZJwnisXStD07ZChYFt36O0YVF1FKUYdluWZsVRt0QtFdvtlhQVIRdszjTLjiFGlPfEFGc2s0Mry8X5JcvlMavlihACldUEP1BVLVebHctli61lmLhulux2nqP1ihLSTKiYB9/a0Cxrtv3I5EW+pZ1lxVDCuqzrCpUz1iiUMjx8+B7r1Zph6BnHga5taSrHYiGMI4ylHz22cjOrUuFjYpo8XdvNA9+MwlCKvA5rLMOwQ1tNCWUGuIw2kHOkKIjjSFXXB6mdMkuAaKsYhlGCsVKk2XcmhoDVmqaqhEAzTWgKfmYojrUjuZYwZS6uNozTRN2Itzm5UDc1BvHmyTGRlMZE8aPYM2TrSgbi4smigUjOCb9ndudy8KvZ7LY03ZIpRkLM7KaRtm1RWdi3MRUZdpeCdY6iRVnCGUulDViDrR0akXiPOVDPw/GcC3XrsMLpQVs7D+wt0QfqbiF1c4mUkrh19/m5INhH2jKrLyTxHprlqvp+S84eYyyZhMFRSiSXQuWqWe7eyKB+scQ2FcUHSsxoZdC2EvmqGOctZyPqCFoRvUehxBM+yblVWuwWSlHEnDHWghIGplJiF6CKeJE7a4ixkH2kpIirahSFmEEV2SaX+2rDP3n9Md8+36HIFBVpq5Y8BiZm2XCrICQhZCiDNtDmQkqBhxfiWb8mceYn/mk/0nWWFYXj4yc89/wd7q1W/MyPfoSLoefhlScbiy7zvWIi23Hkq+9d8EP3jilhImiDLuLtbaqKyTMzlCuKyihRECOFQMmZav5dQBIO7SxFZSkCEWfzrDVVXVPQoC2gMcpQMmilsLYmz7gVfC8b6TGStTByi7JQAjmpQ5FKieT8fTDXlcgS7aWygIO8lVIKyp5xznWz57s+jTqwbZVSxJkZWEqaGeYckpa9BNA+wdkXVCGEg8yNyMKp+dzaQ1G0l4vbP49I5qSDz1hVCTEh58Rms6Gqqmden2YcPVrv/dmYGZWayjl8DNiicU6UIeq6omlqrq6uKKUcZLz2bENjDO1sy9F1C+qqYtcPs+xWZpo8UGia5rBFsme6g6LvL+YCVjzCrK3Q2tI0NSn2hChnJoaRHBN1bdGq4qMf/hBf/OLvEY1Cl0KMHmNrdruJJ0/P5LU0HReXwsguFJquZRgH2rYhZ/G2ampHyQnrxJepqd1cKOb59RhWy3b2LBK5pr2nm5/8XHQaUi5sdwNpZtQ+evSE5bJhfdSQklgtVFWF9xPezyo/RiSnqqrCWM3QX7FeLzg9OaZbNHOM1dSNo2400xTJKGqnqSthuPbTRL/zTJNsKCg0ao6LU0w46xjHiaqqcc5gjGOaRKpJFVERqSqHcw1TiFxc7ubm0PX9nGc1Eq3nZLsUIUPlSNuICgjaoWeZOJH0K+Qi/+1lr4RcJCTNqnbSiFktCEHkneSekHifcyblQprPhVKR9m+0PP3wBf1mZHO1E0WOkpliwfSe6KVpUdWOBsd2O+K9SAQ6a2iamgKMs3+eUtJESCnzsD0j/Pkli/+3JW9F+g40xmpM0sSo2G6kEVDXNctlh1aWMmOamQt9P004p/HjBmsrFJJfDMPAer0QWUZXoZcKkTQ0pJx48xOPUMYQhsjTp5fkLDEppx3b7UB/suadn7pgc7Rj9bRhsWhp6lreNwpf/djbHD8+4jgs2G13kDPaZL769fs8fO/LBF/mbYEESpOzmosz2FwNaANGG1JSfOtbb7DdGu7eW3B+fjHHozxff8hpYrM5I4TnsLYhZshZYed7QBvNciFSX34a2Q1bLi4SGWhcxZ17t9huthinhQEe54bJ3uZkblxe/ydBN8/Nwf0NeobiHy5arqZIiEEUc3yhlHre5El0XTNvBflZntPM8VOKQlFQiod7HoTB7X2U2i0XrFU4V2NnabIQInVVy0ZcSjhX0TTNrL7j53sqQVEHObeYIpVxh/gRQmCaJpqu5fxqwzh6UHq2VtHoObZTWVHdyQXj5DXvMWQvbSgyjmo+NwWxdJkbAkUaAfvfb49zUn9cY5dsI03SNLMVOYQ5vy1MfuIaGZml8czcmNCHcxTCTPxzlnrGhD1m7ocieyk7RT687qqqGMbxXwPS/5rHDYbfYPgNht9g+A2G32A4Nxj+A4fhN/h9g983+H2D339C+P3uey/zrbc+AdoQpomnT65m64ZCTpHtbuT0eI1i5DwX3nvyGstFzYdea/jwq1+mlMJisaBta2LwbLdbwW+b+OqtN3n4zbMZv5Hg9UH83vSC38YKfr/xBtvuc/9/w+9+xu8C1E3ND3/u47z34D2qtiImiyqWmCJZTSityEnNhDak5z3716dZxUIpLWq181ns+0nwOyT8DX7/mcbv73kwfve5V2mbCxQVxhkmP2KNQ6OYT/cMqrK9abQFIzdtTGJKX6IHC1WzRhnFlOFpPqf3PU6v0OaUNsu2atEOpRwoQymJGCaMtagKUpjwfqSuxXM35QjKyoFUiZhGlG4Y/UjjrAxIccTYo0pGq8Buc0HXaExVM04RlSJl8timRVWWMOzoVncYxnNKDIxDTVYOrBOmilLkLGBvi8HZGqUhF4VxgFZoOtpwIv7UKuBjovTnvPHNr/PR5SfRlYNoUKoQc+JLX/xVLt96wHMnt1l2Hl/gsu9R/cg/+5X/Fv/xARayOd+0C4b+PXbDIFIiKbAbBqxuSekCrRSbXY+uLSEFWrcixIDSGqsUm0G2ZBfLFcop/G4gpontdqQfejabLcM0kkthGiNFaeq6pqkrrNK4psIaTe+9yNK0DTlFjFaYpiGEaWYnarabLd2iQVcWYsT3MqA/aZdsd1u0cyy6jmnybLcbGRSFSF1XrFYrHj9+hFI7jo+P6RYLrHMizzJNstUbxVtmn7AdrZbzgFbNXjYJYw0xR46Oj7i6vGToBZi7xUJ8R3YD1VpjXEXtLNMw0W+2NMawOlofvG3atmOz3RCjo21qFoslOQi7U6mMsYbs5X5dr48Ypi05J5zRBF9YL9dsLs9p2o6M4uHTxyyalmY+K1VVsR1G8WpBmJy2qkkp0dSirmCNYdf3uKqiJPEHF+n3QmXAVDWXV1tCLmQFBSVb5iUz9gPM19I5x/nmIadHxyilcU4xTZ6YEl3tMEvLtPWkUkg+oZUEo2maxMNZi98LBVLJxNlDCCW+1sYqconiFWQ0U9+TS6SqDbUz6JR5dHZBdfc20yTsrd1upKkcqIKZE6AUE03biK/8gWQkst0ahSpKPG/ITNM4ex4lKCIVJEzSSC49VdUw+IDPO/HbRuOamn6aOHKOVES+JEdN3VSHgmHXe9qFBq0oTooHY2SrvXYVShWmaZzZhJoQA66yxFBY1gtyDOSQyVGRa8O295Qnjzhpb3F2cfFMDaRAGayzFIXEvJlhZp1Ip1trZbCcDU4bjHWYmXXcNB3VoiPmRCqaKmt2255mIYPvaRpZrlakUoRIZIThmWIgp8jOe+quQ83MRwHIRFKQi0cbA4hnh7WWkiIqZ8I0UFuDqdr584j0vTGQMpfDxD9//RGj0hwvYDcEXnzhHjpCVJEn52ecD2AduNpglaOfdjMJqcIQ0A7GMeJzIqBw2hAmeHdIvH15xVffHmmbig+/cESNA9WDKlijhMmHIcbM7/yz17n37/4QH+5avNUYykxASOIdrq0wOFWBtM9kFLausNahrcjG5zTbTxgtjNFcZINcKXxIuKYGZTDaoYok4OWwZCCFrNaCn9bURO+prTDzQskobUg5oJUwWoWu9Ed7dF3HOI5M/poNCZLU7F9PLs9sPfwBD6Wv/74vrIUsIQSalGB38L6RAmTvR7Yv+ve+MOKjLg0lY6TIdk6SY1AopWemt5Cd9gn2PlHaP6+wMDU+eLSaJayUFMnXHjWC1X7vwYMwso2zUBQ5JVaLpXj/cN1YsNpQGVE/WS66A0N93zyoqhqtDZeXl/PvIl5Xe49478VSYbcbmCZPzoXgA85lKqtJaRKSUoqslhUGyyoeoRrFe19+hD233FuckIoQXJ5ePiHYiaqqCMEz9PLzhmEn9iKVo64qYTSHSF07rDGM48CdW6eHpDomaSYcHYlHmTGanMq8cSBSZUZrKTCRRDikjO9HrLH040DXNYBht92K9YUVtmbXdVxdbQg+M5UJNf+vJFgs1my3PctlxFhD6yy3bp3y+JEm5cLxkeXp2VPqRYfVYi/jnMGPkSFLsRXjrExjNApN2y4IQWTqtNbsdgNpltBbLjuatmHoR5S2oopS12x3A/stjb3MW/RhJkZl9HzNKyd5jsjKCSFStjyEypue8UYqKdO14sd18F8Drq62VHVNXTeM4yDNoUoTfZGthyRkxdWdCv0RxfnlBdvtKPKKeo4VCfHQs7LNUDaKxcJRV45+9AeZRa2tWIOkhLOSpyoFem4aXKx64t9uaf5fnkVZMgwJH3Y8PTtjczVRakXuEk3j2MYtW7+ga1tq5bDFcHLrmE4viWFkdXSM28g5bOqak6Mlbduw6DpQspEyjkIe9VNke2cUL7AYiakQkzSZc1akfiKlDflTCV3BIteQIYUEGi4uLsg582unv0N1bPmFL/4UrauFIT0XZrkoDPt4pOcYItFNbIjElmW5qjm9fYrVG8I0S0MWUTl59bU7LJfHc7yJjNNAIeP9gELhJw9as1go3vz213nw8Lc5vfVl+r4npsgURja+8KXP/zCm9Px4MIy7gbOnW2LKtG3DbudJcxGpjSInkSkD2Sw4v+f41WWH0or1secXf/6pNDWRnOcLv9rw6HHEe8s4enbbATPnjyLxJuc5xiyMclWYxiB1mFF0XYc2jhgz0xTmTSbxB+u6dm5Oaba7rRS+WvwW3+9vCVpJI3AYJN6Lgk+Yr7vEpcl7Li4uUXPJ62xFShHnWqyz1NZycbUhZ/FULDEzjCPGidTjXs5RNpkgJSmovQ/S0OGaAV7284kZaz6IY7mAD3GWEpXC3RrBoJTk33VlCUHqibZtyCkTYgSkWTBX3eIjO0yCRbPFCqpcx4KZjKkUGMP8/n1/G+M3GH6D4TcYfoPhf9oxvFkbxjv+31oMH5wl3LP86uIGw28w/Ppxg98/GPgdwxFKWbpG8eUvP+Li3NLN+K2U4fLyCfYGv2/w+08Iv5f3l7z38paXvnb8h8Lvh4/vkUpFKaJ8GXMmxnKN37uRlKBrLcZomUmQuX/r9wgh8Oabb5JS4N6duxijWK6OhOxQ772gFRmFUcxKFM/gd5F4QJHe8HJZc1qfYCf9R8Lv2hWOF4qv/f7rXL71m3yq/R1y8NxJieMYCEnz9fjjvHhvzYsfeo2nT8/4+tceMvrAyekJjx5d4SePNuCcIQQIXiw079SOk7sOVzl+Pkz8xf/oCeg9eanwP32t4pe/1IAJXHh3g99/BvH7ex6Mt4tTuu4YcPLmxxFtLQYNShPCJKyfVBDJYdG8D168u3306JzJpcZWR6AD75UHPLUbgsq07GhyQ6NasimoHDFK/GtlgGCgyAHba9enLFuXWSu0dpALOStijuympyzsMSoVSlXIPksAjOJvHfPINMoAZPIbqsqQjKWqHCUFcuhFp75oTMjEeIZq1jKsCAGTMkYZmZmUjHYKbRthYhQoZIypqI/W7C4fky9lmGTWNXnwXD7u0fcbXFUgGVTRHB8fc+uFI/KQiGrE5IlpHBiSpi3vHi6qMZZ7Jyse41kuBngycHb1mIuLnqt+JEwTKYOPkZwizbKlOE0eM4uupR/7eRBn8FNme7klxsQ4DiJdMolX/KLp0FrTMwhTxzpUKUxhwk411lpMXbFsa8I0YZXIS6Wc2GwuqOqG2jVM00TOAVfXjNuByjqGaSJMXuQYvKdo2Vo+Wq/ot1s2mytSXmKt4c6duzx9esbDB+9xcnJC3TWHQdZms+H4+Hg+gJ4YI7vtjqapmWIik7FZ4XOmsobtdsOi6/BKfLbbpqFdtux2O4Y40TkFzuC6Fk0hkdn2O1xVkaPIfwuTL2C0pWkqMlmYSDkxefFthkhMW6q6BTJP33vEen1MP26JgPeBKUTadjEzKhPj2DOmhDGayjr6fkddV7iuYeoHTBafiGoOekZpnBUv8dWy49bxmmXVsPOezW6H1hWT9yy7jr3EfdKKrmspOTIO6ZAsT2HCGYv3HuecBPKwwzhNSQq0pTIy9BYWT2G/NbtPSMZhYgoBVzeEcSKHEWML0zRR2RrnZNs2SQXMMExcbjc8d+c2IUa0kgSvcuIPbbQA6zhNNIsObQ0hyfZ6AaZpQnxBYC/BlHJmu/G0dY2zNcMgEvz94PEh0aEJPhEiWOM4ODjpyDROWC2DXxk+ixdGSgVbWay2aKWZShJp+CLb2tM0D//bJdoWctLEEJj6kVW3IuVCPfs37TYD223ieLnkuATS7ozK7BFFHlUtX5vJhBTxU2QahAy06I7IOZCRbXRb1aQoA3RjNSkndIQSAyl4mq5GJUlIYk6YyhBmiTpXVaSYqa2lv7qEMrPmcsJZQ06ZyQey0mAyOWU0iqJBWUeaCzirFavlSgoZY0AJIBWlyQqqOkGGT7x6j+3Y886l4oc/9hILrcm6MHnF2w8uqarCS3fXvHpywq998XWMUtRaMYQo1yUVSaxdi84Rqx1TyCgHtXFQFNvpnH/xtTOKbXDaUBtLyhOoQtIVumiUcfzW77/L1fN3iTmiEPsOpzXLpmVZ19TOoLQWLC6Fqm2xzkgBiviuZ/Isn64pCpQpqKqixETK0NiagkGbCoVIaRUKek/ocI6gHVkVQoqHAXplMoYaPwUqp/FhorINNpvvFa6/4zFN06EoftaXxVqRCQxz0r5naHy3pAbEQ0xl4cLlfM02l6/fP3fBOTX7GzFLxe1ldvZ+URLzJImRRG7PhhXGs5+L770NwuynE8LMLo7ikeS9kIiKWDdUVUXf9ywXC0IU9vS+cJciWuSF6rripRde4I1vv0E1E48oIoeWQxSBASNMZmMMKUY2my1HR0shiiTJSeS5C8vlkpTS/FphuxVpODtLRzR1Q4jC0k8xs+t7Kqf45OKjvNK8zMnJmuWyweSKH376k4SQePzknOADZby+Fm823+SBe0dwM0XeWr3Jo917eKXwUWS4YswMfT8TeyT+LruWGPb3QCYlTynCdN1tt1ycX1FVFVXdcnl1RoyR1WqJ0aK6MozjLFtWM8zMf+8j297TVC19v8M5yYeEtW6ZxghqJmUlSa63mw0+Ft598JSuddy9fco7bz+gFES1QwlOVTMhaBo93if8XLQoLYSpg49XURijKEW8woyRbaMYI1VlWbQtWimGcWK724g1gbIYNUs1GcGMnBLOaZq2ZrvtGacR4+T9y3sZppzQqjCNI8ZaCkpUk7SiaSpQSvy6UFS1OzQGNIppmoizFlQ4MHGFkOMMsIT+rwbSEsIUCXMBxNy0KrOtQtMJ69+HzG6Qn1UocyNI4YMwjeW1SXFRcsY52Vy4utriblX4fy9RfmlL3w88fWFDOImgDPH5yPTxyGAyzln6WqFUf8g9c3qD1WpJToHd2cCPX3yaj5oXWE1CtNNKmhgoYRwvFi1VVfPuO+9Rf9MSPyokWZEsk3xRIezecZyov2JYfnQh6jiIbY02sjWy3W6FKWwsz73wEiY5jHasj45pu4Zx3JCLgrI/LyLBJ/GsYIylqR0nJyvu31uSy9c5u7jEuYbl8pg7d+6zWh1hXY2wngM5BR4/epuLy1/l9de/ydvvPGDygeeev2SxuBRZyHfVIbaKagu8/Onf5sndI5584wWaaEjnW2KI7JThW996h+1uwFjNarXk/nMbGic5RCZz/xcKf8cMhziMEl8ukQ0r/JVfnBjHxJe/vObdtxqePPGUVAgxUtX1HIf26iIKP4VDoyKEyNXV9kBa3Red8tyJ3U4Y1c45QhQfSTmXmhgiKGn2aaXnPFHNvDH5c7/ds29cdosF2+1WVFZypm0cwxAJKcHMRCdljBF2/jQGytzoum7kzudgZoH3/U4aA/uz8Qc0kfc5oZ71PtMcq3NOGBMPWARSsxijDw2NnMVzMM/P/WxBvd/wyjmLTUqUz1VVTSnXeHUoztMHZVH/aI8bDL/B8BsMv8HwP+0YXrRhNf7bi+FfrTSf/dnA39E3GH6D4dePG/z+04nfi8VHaZqXOZ7x+92Hn8XoE6YQefLkHO8D22fwu2m+iXPvUFlDSpHj1ZvsbvD7Br//2PA7s1oteXDn6R8Kv998qz3giDbqsGkvZ/wavyFx+9YRdV2BgmE4J2bZ0H/4wECGuq35+Cc/jyqiJLFen9AuasZpO28I67mlneYG+zP4XVWC3+oF8pv6e8bv4fxXePL113n7nQfcbq/43P2nHIXIuhQ2Yq8Oc2+1VvA3XvlVPtYe8VZ9xMsv3+PWrdtM00RdN7z9T75I2eyoa8etW6fo+xcUK8quPxw8n/2Z/pqApOT3AdkA/2s/HPnFz224GCy/9PtH/N6Dlgdn4Qa/v8vjBxW/v+fBOMXMXEdh4dR1SyqKUmRQoF1FChqtAiEMTMOWxepUpKd1K/JIGZEiMRqfIhf5nF2e8GSR4sgDAYXVMowSEKtRyqJsDRhiFslt01hK9rKxqmUwaZQBPFv/GJ8TS3eC0NvEk0SjyLrCuohOBW00VVWTTSH6gZImVM5osujrpxGtCtoWQr/B6IqsEmEccM2CoqG2TuSKtTCXNIZcjMgSKwCHsQ5MQWWFLh2myrzzrd9ns7lP3RlAY7Hcu/1pNi9uePTNb5O9JgwTykkg0sq+L5m63A7044bt5oJls2S1DPipsB1HovdMkyQilxdbfEjEcWRRt1BE5tcPEz57Ac2mETlspUlJoTtFCplUMqFEbLIQ1fw6FIv1Gusc0ySDYGaiQklRZCBCpK0aAa6SMUYx7Hr8IIyNEDzKaEJJEDJ4JLEymr7vaWfZ6ikG/DDRth2L1ZKiFGdXFxybY6qmFskKMk/Pzzg5PqHrOoKPhMnT9wPdckmcQaCEHcqY2Z8hUTc1u3Hg7OlT7ty5g7aGvh8wxlJZSx88yhiaqhbJi2Hi9PSUnDPb3Zau6+T9vdyw6BYiiUTBWscUM23T0FSWq80Oaw0np3dEOQBFXbUE72nrBp8Tu90W14klwWKxYNeLH4bRoIxj2O1Y1C2NszjnuNrM4JMT4zCScuD0dAkxkJ3l7OwcPwVWRwuq4ISdozUhyYaqNWCU5XKzoetaxmmUuDcnxM45xqc9t06PxbchZoy2TGGa2Y8WP02o2qGUxvsAysxJqhfmlUybUcoAYT5XQCliPVAQlYOrDVfbnm694vLJObvtFldZAfUUsKYixkg/7Eh5XhdXEliZmUExihxRCEGYlFPAp0Slhbm1H+aPPmBrASMfPAVFzAVtLU7LINQgcuFy70ZUEcZRZRwxQds5DIkpBHJdo40leE8sBWU14puhmMI+qZXEMlJQWjOlgXu3V9y+u2a50CwbjQrPDDxLIceJzfaKqmkwppFET82JmQ/kHGb5E0ko0ZqqbhmHnhgG2c4fJyhakjPEM73kRFPXxJyxumAQyZNxGikUqqZCY0gz69OgmErAKEOcJqyzWGeIOR8KMdQ8CEeh3ez5khKKTFYCXn1MLJqah08fkSL8yGu3KSrSuIpFveJX/vnXSRReOlnwUx95iWkc+cRLR9y/fRcVE7/3zSe8dX4JOWNMoq0MuylCkiQ5Z0dOhqA8lVlIEmbdzFqz4DSpRHRRoBLBZN472/Hw7HUoiaw0thRQ4LKhqYW96ipHVUWcbVk2FXePWk5XC5atwSpFVVsBeaBkhTI1CaibltZVpKzRukEZNd9byD2bhaWJkqRDq4Iz8r6VXMgpoYqiaStKirNUTUS56nuG6w8+UhDJHpEMUsLqLhmlyiHx2Bfizxbke9b1/vPzLUouHEgpztlDkrJn6qYkKh0lStH+rPTb/jnTnIzlLIleSpm2reaCd89k55Dkaa2x1sxMwlaSH2vwMbJYLGb2ucNWFdpoalMfksR9AiZJl0GhOD8/x2p7IHwodS0b99y9u1xtrg4FPcA4DDz//H2GYSTnzDCMKGWYponFYnHwULPWydePAzkHSWiTePHsdj0Kxa3lKf8Bf5Pnp+c4mU6oB3mtk/e8mR4Kg3JueuQ8J4Ep8Zx/hRe2r+KsxlnLo/SQoez4Uv1lvmj/BZWzh3jx3HP3efr0KY8fPaWqVlK0efGTOjq+w8XZBZvLCxYLIWedX1xhpjC/T5lpmub7RK55jJkQerquw3shu6WUGa2R0rAouq4GoFt0xLyDoplCgCLbA7EX5ZWSHdtNz2LR0rUN0zgRgqdpWtbrFSklVqslFxeXpBiEMHeQ1ps3HVJmHD3jWNhLla3Xi7kRklkuOqAwjgFrKxYLwzh5hsGjzb6Yl/ykrgx1Zalri1EtV1eiqJNzJpe9dBO0jcWailxEjcRYxbJrOFqvRG7Ne/JcUJu6plt0IDQmcoGry80+0LNaL8k50fcjT44v8Z+QBL4fRYJNzloRLC3gg8hINU1FSgNaG1IqYjlCwSonjN/9Nse8eSW+Z2IlYqzi/OKCo5fWDH+toH1Ev1jR6hYz+0IdYsBcuFWVI8TIru/ZbHuuNltefeUlxmXgV8vv8Fb9Hn/9/C9Q6w7vxYfKOsdyuaKuK6y1NO0lz33pNo8+ecHResXVZsdmF+bfUYobFKSQOdosqCqDsw6dpcA3WvLKYRjR7QKlLK5qMaZjuTzi+GjN+dlmjmdzw2xuGJasDvcvKP7T/+Q2r72yIEXB9qOjE3xI3L59V+QXS2GK/x/On77F5eUV777zFsP4RUzlefXDhhAiSmtKMTMGglIIKVbL++dj4c7dC7ZHhstsKFmakDnDaqvpstybWmfa5x11LTE0zjnavs4spYjXn9KiUlWkEK3ryE/+5CXhR055843EP/+nK1FS6idiFC+vvUfkvmnjg6dpmoN/pGwGRSzmsHkUk3ic7Vnq1so9ud+GyzmDZh6EzJtIpUDJLJcLZro4xogFiKtrmqYl+EDTOF566T5vvfU2cTfK64izvGGRGjBmkbI1XMt3Jh9QRrFcLMgFdjtR+5GmbzkU38/i1LPypFqJ7F72cv1RwoKX37+I4hjye6qisc4SYpjj/HXBf41/5fq94JrTuFes2j/2zQDZftlb//zRHzcY/qcHwzX6BsNvMPwGw28w/Dsw/CdTQuv6BsO5wfBnHzf4/acHvxWa5fKUzN9knJ5jnE7on8HvnB6IhPYH8DulhPevsN2+ip3xO6eHlLKjrr+MucHvG/z+U4rfVS3KLM7C0XrN1dWOTe8hqTmOyNmLMVHXNZXVfPS1r9J1DdoonKsYhpHzs0tOb5+ilcG6BuMalqsjjtdrzp9uRKY870kr19vNBXUgJvynd/6XvNZ8mFTGPxC/7Zv/V8btI7FUePKQbvwyH9ETH3lZzdao0muXoMZ+lxgU85mFT9675HT6dUKxfOpVZvwu1D+3Y+U1kFD6CauXEqYBSPNM07zvuco8FN7/DAUcN4G/82NnPOyP+Nq7mf/mS7du8PvPCH7/IQbjmaLKnrsJRaEpoDXkglYZZRX9LlDSjpyESdS2HTlJ0pxSxNialD1vp7cZTUIVkfNIZWKnDVfFc6qWgJNNxRzJOoDKoDxpmhj8SHTiLWy1IQElR0pK5GIYyo46LYjDBnSLUy1JJZRyWNtBEZYPWmQOqnpBZQq78wvitOR8uyFHWC87bKNJSmFdTSGSYpTBfZgoVQXGoEuhZEVlFL4EkiokVTDRizcv4jObFahcMF1N2j3l8TvfxKSIW90h5oFUggzZxpGcNMVoDIb16pTFycnhUuRS6DeeftiiVGTYTlycXTCMEqirumbb7yRw2RqFonYOZ2uaruPp2RN2u54yExL8JN7FaEMhUZnCYrFknBLvPHnCZttTq4rT9RFtXeGzZ9zt8Gke8pCJ0R8YMo1raNqGfhxJORFCpKkqxqGXv7etbJg7R86KHCNTCNS6RpXCZrOhqRsWy47tZsvl5QVVVbNYdChVOD874/jolKpyaCXbyhcX53SLBV29oK1b+nHHNAzYqmKYBtqm5vz8gna5IoaBftjQNQ3bvuftB+9ycnwiCZqP9NOEVYroJelYLBbsdjt2ux1NXVPbihIzrqkJXjwcrLP0fY9Sis12yzSNsFqRSwIligmlFCokaZJAoXAo2WCPgWkKZMSnZHNxKYFSFxpXC18pC+vlvUeP0LZmGnYsmgWLpcinKODh4zMePznjzt37nJ+dc3JyjNVGZNPPr7h794RSEhlhB+lZemPRLeaExzNOEzEp3n33MUfHRxLEUhYZmqmnqVqMDgIYZAnDMaO1EXUI7wVAspIzZyJGKdpm9s9IkizUlWF3teHb336Lk9u3ePLo0Zzga4oSpmMpknRMk6cUYd6VnAk5z/4fIkdU15UMZWcGkY9Rkm8tYF83DRnNZtuzXC7JFIahZ9uPKGNZLJey4ZwSqqnpxwly4NbxEbWrMQYGn1DjRN05CmKlMHgPM9gb69BKVDJWyzUqJ3yKWOOYJo9zlnv37tDg6TcXOJfQ+oigWsqe9KJA24ppHLHOsVp3Qg1WmZwgTZFCZPAeW1e0C43SZpa2A1O1VLXBuEYSpJTZbHcsVgaVMyUmTIZSIlmJTJHKjqTEomKKHuMcYwxU2nJyfErMme12c2DjWlvhjMP7SdiaxuJcNScQGauFRFViFpl7VRFD5nTRctQt8CnggGIs508vOBt6Xrl3i8+9uhbyiDV84qU7OK3o6pZbqxf59S/2vPskMGXFdpqIReOymu+RTNEZYiEbScSM0qALqUQhaMzb1iWDUZK0aq3IFHxUKCNb93hRBLhdNzw+Hym2kMo5Sju+8qbHqBrrLKtVxfMnHa/cO+LeyZLKOvzoUcVQikZnRVIKZTxkh7Ia0GhtSTFhtagCaCDnOMstGfwUUcaRYpyJimaugkUy5/t97BMYa4WQtVwuRWJmGN7H+nuW6XedfFx/viDJjkKuOXMCtZdWc869j2W+tySQrQnLOE6zH9p8ZpXkFKBomnqWUUpUlRXFhvksm9k7SgrthLaGVAqX2yussWQFqMI4jgdGpp2zHOfc4XdIMXJ2do5SSI6Sr4uRYRw4OT3m9PSYi4tLSlGUXFit1jx48FDuf6e5e/cu5+eXlALDIJ5QCg5SRtYKWaeozEl9gksGax3GOP7a8O9z19/BWYsncHG5QTKqgrBT5V1+9nWVklEFcpybbSFzNJ1yam7zUvMKv9j+Iv9l+Xu8sXvCen3Mt9/8NnVVc3JyIo2BGZ8rV4mXkJFG3ThO4inWNDgnMnAxRim8Eam/mK7ZrZurK1zl0FqUU/aFXHagJ7Hc2O0GfBQ7AICUM+NmQ1HQNA5rLV0ttgtGzyz3mTTnvadtG6ZpZLHoxJ5CGd5+8B6bzQZnK+qZGZpLpplJckplFouWaRxpupbKGbbbXgpTbWZpqIzWBaM1XdeSc5zlMStOjkWhJoaCUuf040RdWSafODldsV61GFVk8yAkKc7iRNtU3L97m2Ea5L52VlRJQqCpHVoltHF03YJ7d47pdz3GGrpFyzQOhNjRnlR8kyeMPkBWe3eiuQEmDQ9Fod9O3L51jFuLRNboPSVKXBuHEWON/IN8aKZIU0EGrirANE5opalePBIMSc+wuvf3XhFWvTSKBhRy7auqYrPZ8ODhY1599QWcc7y9fcx/defX+Z8/+asYI5saCy0yjorAMHsBnp4uWS1b7ty9xXYYGL79kFSgbiqCl8Ispz2jWBSB2nYm1VK4utqSYqJyNWoy1G2Dpma1FMUSrTTH6wW2sjx9fAkotBbPs5gQP7/G8RM/dpuqDpydHbNerXHOst1tudpc8IVf/7+wPvoyT5++xTgNUsgjyjUFBXl+X/OenFfmjvqe0Jtne6fCFBJ1c4EPEa2leamV4tYd+X7xH4vsi7VCmSUDwxx/pZBT840QYrq+H3LGT5nVesOP/ViD0Vd8+407TJMTScf5a5u2YRxEAlNrMxfr5bDFs3/EGGka8YINYRIvs5iwTrZrtBZrlSl48ZJUs42Us0ChbWtCkHPrnOPy8gqAq8tLlDazB6RY67zw4nO89+iCp+cXcq9qRYoZ5zRVLc0X8W6bPc20mv0RDU4rnFtzcbXBGDvn27tr5aJyLUO6VzUKIWOs4AZz8S45qKiaaaXRVohpMRVi9t+BhYcif37e65i8b858p/zpgdGunmXef/+PGwz/k8fwn4g/xUf8R+hobzCcGwy/wfAbDJfTfoPhNxj+r37c4PefDH5X9Ql5xu8Qf4rRfwQ14zczfu83Q8scQ9V3we9cIM34nUJmmk4x5jZN8wpN+4vk8vfY3eD3DX7/KcNvxSltW+Ms3Ll9ynboGd58j1QUdV1f43fe/6fo2gecnp4IwaZk3n3nAd9+5zlObz+P1jN+6xqFZbVco9VDjo86rLM8fXIl/ex5iBuTnJ2qdvzE+qepkuNs/fh9+L3ZXPB7/+j/zIer32HYvEeMgZwLZh6w5v0FmWNhoRxmnaXIOSmzsbsMVAv36jNZ1qpE+h9Ane5h/5mLPD+0koUziYT6EGspHLaO5boK+ejF1ZaXP20w6gm/8/B5vn2D3z/w+P09D8bf+uaXWa1vUTULqmYhQUNl8cg2oIvmYjjH7y5x8wZjnCZMZUnZI8xKTYkeRaSKmuf08/j4lAu7JeWJrB0DkVAceJFdMK5mShlCIE+alC4I+QLUSwJeqlByRClZ09daDtIiJMhnxOo2KRd8FjmNPdMIBSqLXEvOSW48W6MVjLsNxizYbDacNkegHK6tGGKAAtY2KMQvLFlD9AN+hK7SMgCNGu0cxUhwVdagXItKimgLVim0NeSrkWbRoapM2WwZdom43aJSZnF0wtH955iGAe1alLEHckzJCaczx8sTNueXbHdnhCjy2SFqQiqEnBliIqkiLJCYmBBSweBH6rrl6dOnxLAV5mwujENP1zYcrU7Ybre89c67jKPn1tGSdrHk6eUljzaRumpYLjpWC2GkTNNILJpVuyQXmCZPP47iZ25kQ313taFuWowJxCCyEpP3NLWw21xbM40TC9dQlOZqe8mSJcvlkmmc2Fxe0dQV6/Waru24vNzgJ836aE1d1VxtNgzjiEKjVaFuasoE4zRQGcM0TLTNgjB4uqbmKozYqmJtLbvdju12S13VpCgEC20MdVUzjKPIJGslvjQzI7Gua1RBPESMZugHCRzGcO/OPcZxZDf0OFex3W1pmmpOwDIheLquI6UwB4mEMYZu9gEfhpG6rilKJFrIUljlApvNhhAjy64jeEksqkq8IFLWPDq75OjoZJZDEjnmYjLTMIqcmfd0TUWaAdA5y26zZRwnuralqitQheA9rmqYfKRuJAFomwat5HuL0rMkzky1VjBMgRCTyPc3NTlFctHE6Blywtoa65yoBKhCPculbLcbfJhki76qICeUNfvIdghqJUu6arSm7weRalOa3TDgakeZi1DjDDGKVH3VNOQYsUrhqpqHj57y6OkTlsslXbcgpMLFrsc0FdW+gNWKYZpQFC77kWVdE4YBoxzKZGxxaDRxnHBNQ90uCFGk2CtrWTQ1Q+8xTqONFXBXikXTge+JagIc283Iye0JcbneozuUlDk+ukOMnrHfCQs2R8LoiXlkdbwAXWONo8RCIoKGetGhjGGzPSN5TwnCpu/qFhUTJSScM0QyURVKEvKB1gblZHPZhwmKwrmaOHn6mHCupnYWPydpKWZSzDM4ZcgJUwKKwjgKGUVZyxQ8cfI0zhFSZGEcIQWc0RhnyClQlMNoxY++fAtnFGMYmVLAWc3kC2MvCeFPfPQur1fnPN1lTl+6xxe/9RisEv86ldEKjFbX8kpzppozszeUFJipgFOGXGDMGbTBWYMlUuJIMA3PrQw/+7mX+f9+4cucRy3PqSWGFgd59LwzjLz97jm/89UHrDrNa/dP+fgrz3H/ZAU2kZWjUZpcDMppiipzIiVM2xTSrNAhCVhO80B/3qqwSpGVNHLyTKo6AMAf4VG0NHKMmiVtUgIFfd/jQ+QD+cR89L77zzuwALUG5FzmIlI2kvzNqgFKUbkaHyYO/jF1PbPar1mkpahZxUCRYmSa5Ocsuk78AFOkzF5RxpjZ20tIS1pp8fOa5OxqFNY5IoF+lhsTtrzIdqH2BKNC8ELKm0I4NBP2qhkPHz7EOUfbdvS7HpAkdJ/8xRAwugCJmER2ywGackgWlVIs647Pmc/y2fw5XtIvA4UUCkklIolx8sSYZmbtvrmWocyp3j7B3FdNZZ8kQlZCPko549A01PzPqv+Y31p+gQeLd3n38j1JxONE1yyR6k2K+xgCpSiGmfz1cvoQy7SiqRwuynUyrcTTECOhJIqFSOS9+IBHTgqqtmsxSpGyJ8TErh/mBkA8bCmEEClZtmZSiuiu4fjYEX3g6jLQ7yaa1tLUFXpOwKcp0DQN4zjKc1lH17TEEKms5datNZtNzzSJT1nTVKQQqIzGNhWr9VKam1E8y1xVA4nKLeacL3L33inOGcZ+QmlwlaWqamLI5BRIqcM5I/iKoq4r2kb8mUqp0MYwjo66doTkURQWXQ0KlouWlDK77Za2XVIKnJ+fc7Recv+5E+q6YhwnpiHz3P3b2KOar4aH88aw3h80Stp7NaWZcZ3YjT33791i7Afa1PDk7Eo8w1IBVa49/vYho5RDYW+t+Ift+pFxnFguFyyXC6y+ZvHuWcLaGCqtSElIPKZoXDF0Xcd22/Pewyec3lqjSsHj+dLwFT5Vf4zl8gj5FRI+ZJwT0tpxt+IjV6+hj4Thb43h1smav/Lin+fNd97my/5bkmeFgDYGaw39OGKMfKzMhenq6IRFOaKtVhhT8bf/gw2vfwN+//czn//ch/mFn7vPr//mbzL6iY986BW++vXCF77wDbTSPHfvHqUExt2Oqq6o6o792/3f/Lf/Jxbr3+RyK7+7MhWqxENjjPLMeXymQJ5LtQPOMNe6OcPkPa5yTKMnJZHSy3mWr0QwyznZwCHPTQRlDs8NaiYTXjOx9xtGMRe224GmrvnRH9d85oce8H//v53SNhWXVztSkmI7ZUhxv7UApWRpNBYpGvWcyw2TFxuolMhpxFpppmadscaQi6bKe/nEuRGXpODNWX5faai1syRnpq7qeXvBkjJ89atvcnxyMse9gFaa9dER4ku4w9rr2G6MxAOcQRlFKpkUhHG+b8TtcSWEvWzdB3Bv/lM2DedUdS6yC2L5UlVCHO37JPXkB8Dw2YJ8v/G0//j1T/jOx7X1lSHPDenv53GD4X+KMFwXkknEdIPhNxj+bxeGPz88R1TxBsNvMPwGw/8Qjxv8/pPB78Kn6doVJX+OPOO30YViRGb7WfxWuswjlnyIC9fX/P34fT1H2G9Kago1TfUfc/v079N1F5yfpe8Zv5UxDOMnqWNDioqmrulm/BaCQ0JZ0ERifEB9g983+P2HwG+UoqkrrHMorVm2DdZobp2s+fjHX+HBg/c4P5N5kCgCFIouPD07p6otfb8lZ8Wtk2/y8U98isXymLoWr+yP5o/wL+svYmzmEx/7KK+9+gpv/9o7VKMT/E7f4Atf/KdobXju/j1K8Yw7/z78PlZv8Sv/9X/BJ9p/zJUSlU2lDErlQ6x/NlSX9/8DEHtLNZ9RmFU1UpytGJIo0KhZtaXIFVIKtFFo9hvF18oV8jRqxnwZsO4/LuQ68CHQWcPPfybwM594nb/323f5wtdu8PsDl+YHCr+/58H40UlLv3mL7QUYVpiuxdZ3ODqtyMWwHXq+8Y1vcpuW4+ePKClAKoRpEJaMko1S4Xg4XqhfRbuWSS1Y6Cu+HR9ii2bShZ2KdDmz2/So7FCdIsUt03AJJjMMG4K7mn11LZg5aClQWIxuMLZmHLbQe1iJP4nRBl00xTgyCWcM3u9Ebh3Dcn0bjOLkdM00ZkKQwYo1FehCjonKVEQfMVhUkuI3x5H+8oywWMtAoyRcVpTWgVYUrURWWDtU0fhdJk4Tl/4hF8Fyx71GyZ5+8wDdD7jWsl6dotslm92GHDMh5sNYRGtNUxum3gOapu1w7gpnHZvdwOV2R8iFrCBTRLY8BfrtOcoZfMqcPX5CToXVask4jYxjz2rR0rVLxiFxcbWhW3fcvnOfaRg4u7gABScnR6zaJf2u5+z8ghAC1Zy8WK3ph54YIzkGCWxa4Yz4YsdZUsdZR4gBlQIxR7z3xBRx1tFPA7Wr6JoWP07EGOmWC9AKVWCz21G5irt37jCOA5vLDcfHRzR1A9pTSsZYYexUriYb8RnRVpKycQz4AKvVEbtdj60qjm+dcnF+ifeRdrUk6UiMEWX0wRsr54TRhm2/w1rH4IVtOU0TbpbAKLmgrGG7Ffn0kBLGiddywWCMAHrbisd3XVcUxCdonDxGi2y+0SJ9swdnZ6TICjGy2W4x1jJNI03b4iqDdQatLd9++yHazn4+fiIV8baOUQb6rqoxRmRZtqPH1RVPzh4Lc62qsVXFFDwlF7rFgpgzU5xwRQq/vu8PxIAY4wwSRYpFZSgKQgqU5IlBVCQy4vEgftgib2SUSJhopYgpiuxOnqXWlZo3KhJJa4oOgKgCGCO+3844Su6JQeRiYhTp/KZpGIaRtm1I3pNLpK5bQhZ5lAIcHa8Y/YSzwtRcdK1Ig5OFEW6dAEiIxBTpJ0+lDQpoFx3OwDDIRrxdtKSYGZRHOYMKgaQgJk1dKTKK7W5L27Uslh1+nLAqk00CZdGmxofM8nh9zYSiEKMoRqAsigQ5M/QbGY4PA00r9gz9doN1FUkbmuUKMIRhkg32nNBGLCm0UuzGHmcMuqkp/QipYKzCVo7oE6CxVU1TItMYiHFC5cQUg4Dq7H+ijSXnSAiz3EtWxJwY+xGrIfpAVgVdRG7d1Fauk7UUkkjAKI2xDWGa8MbzmRfu4DqwytJYS0VNChFMoSgplnwstHc6UrzkfNyirSNFKTooorJgdCEVMM6hciQViYGpFNkEKDIIjyWLvJeryCWTSuCHPvQczRj47Qfv8eK9e5wcOz7+wm2+8OY5TQF8j1Hi2aO0wWXAGbCayynzO68/5kvfvuTTr9ziRz/5Gs/f6RiibClYVYho2U44JNizX0oWFuB+o0HY2BZSJpUEWmHYy5j90T3GyyxHs2eSp5RwrhIbhWcez0q4Pevpsv/c/GxYaxHPICdF3kyS2Sdr10x1qKqKcRwPBJcY45xMQZoLYqnzMwVJesIc/1LOaGtm5ulcLOh9TBb/MPF20jMrXst9Ycws58XhufZfJ16+ibqtCZMnhUhGfuZqsaSUhHNOXvdsM2CMpmkatFbz88A4+VmaKVG7at4UiZQYZ6Zi5BfUX+cjlx9DKbhiJ9dgblzs2Y57jx2YE8A56WWWAdo/9njwvsRwJvP4kABPZxp+YfHXef3J1xi1p+wyPnp+e/kFspEkvB5qfuTipw4Sd6UUXsyvcKSPMVljgqLsyrzVYA+NluVyQdNUPPIPeSN8i6fDOb+afplcNMZqqq5hHD1+GmmbmlzA+yAM2QSgiEExDJFh9FTOMA0jlxuP2xqOV0tWq5Y0S95ttxustcSUsEpRO8Wqq0CLXJxIBka6bklMHnBYq+iOFhwfH6Hm+P7o0WOU0SwXDavVihCENLNcdiyXHdPkGUfP1WbLdrOT8+0ci4XjeN1RNZZ+GCXOaENVGfY+SbdvHeFDIPhwsFdxzswyg+J9Jmdao3SL8BvLIUk/Pjni6OiIb24fyutiL5tXEMb5s8WA3A7j4NluRQUnjdPMJN7fc3Je5lp8vs/KXMjJuTTazf62iYvLS1KM4lWlpbCab8TDRoL8DkK+85OcV2M0jx4/YbnqaLsOrTVf/6F3Wb2x5ofaj8/xrWBtBQXOzzPHyzV//vELFKX4SnydGAJ/8ejz/K3yl/lWep3luub8uYG3vv0OJ0enpJS4vNjw3HP3GcaBe/dfoN/tWCzXdGFN7TpSzKzXiQ9/eEf3GzWf/tTL/OIvbPmJn3iVYgpOW/7Lv7/gt3/rTU5OTviP/sPnePzobarKcHR8TJ6bIOcX/4jV0W/jKpFTDN6D0u9rpn+Qwfzd4ub+rOz/nvYSbPtcB3O4vtIElC04aySmqPx+GfXDzyzCXv8gQz6ExDhNdG1N2zb86I8P/MZvdHSLjrOnW0Ic5+I7oo1FBNI4bA7FKBtzMRdSECUjgyKVInFySjRtfSjeK1uRc5p91KSmKkUk0KZpkqHIE2HoG2OECa4V0YsqSmUNl1dXQjLL0iweZ3lGUaOx83ur5jgvHdphELuf2jmMcwybjWzZzMpBOan3N0o+8Nhfr73U5rPXci95d2h8fuCaPnst9vHw2YJ7fy3/oMf3OxA/PM8Nhv9bi+H/fPFbbPXFDYbfYPifOIb/9KPbeJP4+7t/eIPh/wYw/C/9bM+bb1X87u/eYPh3w64fVAy/we8/Gfwu5S9zdtbKEHvG7/0Zl196HsLNOFzKfgBeZruFZ2KG1rJJ+gyu7+/ZKSQKnivTYO3fZPvk2zi7ZdH9FjFKf2qP38NQcz7jt57vP2MsKX+CnBw+KLbP4Dfz613M+B39Q0L4FkfdL9Pvzm/w+/vE7/Xpmt967mt/pvEboGstH/vYQ956+2P0/UAMkRdeuMsv/nzi6uqcf/nlivOLl3nr229zcnxKZSseP37Kj/zID3N28ZTPf+4nePz4MXfvv0DbrbBVRYqZHx8/z99X/xVdW/OZFz/Dz40/Q/ehik51gt/1f81vN/+Ck5MTPvaRj/HOG++y1Mv34Tfv/RKf7P4xIsGe3h/7Cu/DTTmMHwiw+6H1PETdf30poGamW8mFrOW9lUH7fqtfUeZwcLhwXD/fHByf/SH7l0VKYuXslMU5y9/+kTO0ucUvf+kGv993eX6A8Pt7Howv7XO0t+9QrBRw28tv8+6bX+etN1/h3qv3uTw75/k79/BnG3zcsb244uRuR9aRog1oYcsUVVDagoqUkjGu43ZZMpVLLsOWXDuUV2jdQRjYbN+k5SUokWm6YCxAHhivntIsV0QacpEbA2sFtBScpw2dM5R+x7S7wFaakjLFCNAbU+MqR1aF6eoJcfJoV0Mx1O0a6yYurxIxJIzSItGLIoUAZaIUR44RrRJj6tmpC0zULHONxxOBxi4pWMI4kIKwVoiFUiIP/EO+9PDLbB7U3L8f+PD9irYUQqVZZo1zmjHPklRayXu457WWwjBuCHFgGAZyLjhjWS2XxFRxOSW20xZhFCou+56Soxy2VDg7O2e1WqOYEyYv3trjGLg4e5uQM1mDj4Xzy/eonOPO6W2aSgbaj88e0Y+eXBRHRwJ+0zRxNQirTxVQuaCNYhpGPNC1ErhzzoTk5TBphakqtLGUKYj/9qJld7WhdY5lt+DJ+Rm6srJZj0iV9OOIdZbFcsEwDGy3O7pFx3a7xdS1+JUXkfIxxonYt0oM446qskx+9sExMtiujaZtG3aXW3wIFAVVXc9JoDQ/vJ/QlSEDY/AYZ+V1GJEOd3VNSoU0zOw6VVM1NQWwruLqaktelFl+JtK1LTkKw68kcLYiJUk067pmChGjxaaglIKfJLkpSqPIpBhZtu1crCW2mx3aGNrFAkOmH/qD50/JibatMEbR1I4peCYfGKYAWQJV5ZywOFOiqRuiD9i6QuXMNI20dU1OMyu1XEts5PkenW9MKueYkshgiKSa+HW7yh2YokrNktvWgIaY4jywr0QlYn6PS4GURX4m+ABOk5PIpZALxlrCOB6Ky6qSAOucnLU9G8oYw3bTo+ZE/XRxxOXlJSEFjK5onGW5XgKaENLBc0MSKU3TtlS2YfIehaPSDqVEbm3T9zS6pTYVWNkQL6VQdzWXF/2BiGCAKXmGXCg6c3vZkVGcnW2InAvLDQGClAroDEmYY0YrwrRjvVoSa4fShu1myzBshOzQdCyOTknBM20vxeYhB+q2JWnw00QePIPVLI8L1aojDAOjHzFNDUph5qIFEroYQj+Rk8gd7bdbtBIpe5JItOckXjaurmiXC0qSDRql5fm8D5AUi2ZBKZGkM4mMDyOVbXET3F9W5K5hEwOXk+fxZksshd0Q8TEx5YzPE0wJPynOHnnc7oKsF0IuUCJPU2amvyoi0aUpaG2JWfyJSskYVchZCrC6VqiSKCmwWip+7NMv0kbFZhy4c/cEpRd84rVX+b2HZ7z68imPHm3pR03Wkc0YJBZrYdBprWTg7RP/8vWHfOvtp/zYj3yEn/zUZwg54VNCzYZFWslZ0UYkulB2TrgTIGdDoVDaYGePIhTzfbWX5/yjPZRSaBRVVdMP/ezHor4jafigbM37vv9QD+bZa8yQs5Ad9kXzs0mKFO6a9XopzHh/LZGj5gJca6irCqVEai3nNMfc/dcWrHWHZGjvq7P/tzFGZIdSIvpAU9eEJGSMfUHunKN2FbkkchG/GWMsKUZiCNRtw8nRmt2uZ7VaErwQY0KUZHKx6KirihSjyBlN4omTszA5q8piNKJaoRTTNHBncYcXLl6a45g0HoQpLTJbZmbP72MNcwK+l/xRQJm/ac+237+3++uzV+wQcpX4ow3DyCvHH5793TyucXx++OHZx0dki6p1fWhUCLt+9pFDCpD984unWmAcRrabLYv2Di8vX2F9eUxsEve6e/xq/Ie8Nz1h9OMs1ySxWeVrWS6t5T6fvCdlRb/zbGcbBqUMWlm0tkwhYOc4GsZATIGCxLDVcsnpyTG7sT8k8qenx2y24hl25/ZtpnGkqmouLy9JaW9PkTk5PuLkeElVOdk6sEYIaNM0W6HU1HVLv7ukri0hTpzeWnF0spqbSxWXl1c0raNbzrhayoGM1fciPZVzom1FYq7rWpbLBefnZ6zXa5w7kbOPYtgNnB4fo1TBdpqvfehd0pQPmHd9jUV+SoprKIjs3sXFFWNdHc7w3levlAxFked4mFPGOotGtgW0mbczYG5gwdW2xxqDc/tyQIqTcRKZK2sMxs4FljHkPCFEM8WTJ+e8/NILDMMOv3A8rs+42l2yaJtZBk3IS1oX2rahqizrsOTvjv8e/4f6v2DdV/TjlhNzyt+t/jr/Xf2bDE3PyfEtnj59wtHRMS++9AqPnzzm9u17DIuBum4pylCKKISknFguW27fvoOrLP2wZbk6QhmLNXByvOb0dM2P/1jh5382U/IJZW5A9MOO6eKSL335H+AqNcur7otmITt+sKGec2bvuXg4g/t37pmCbR9HRWJQrlGK8dCQ22N+SoVSRP6QAkrL9+Ui+DvfxHIu9zVBLgfW+zBMWG2Iseenfvo2r7x2zv/4P2jOz0SZxxlNKSKZuJdylMaorLcFH6Q5MZ8Js/eaS9JYmSZ/eK0A1jpSlq0eP4VDkSv5KTRVdfgZbeuIU6KaG8ElQ2UtRUPg+n2JcyMTONwvzlmslTPqfSDGLb5uqOvMbjfM77FGFqWe2QT4Lo/99dvHo/cX3Nds9mc7L98NF8OhiawOsfhZJvt3K873HztsoXwfjxsM/+PF8L/CX+Wj08fJ84DsTwrDPxE+JYThnLjB8BsM/5PE8Fq3rLc3GP5vCsM/+/nbPPfiFZcX5gbDn3n8WcDwG/z+48Vv+KuE0M3vh/RS1DP4rZ/Bb630wS/32XtiP2Tb43fev7f76zPHj5IL0wG/K06OP4MxlsdPPyey7saQZvwuSrNa16Kqai32GfyG78Tv8Ax+L9s7NMtXuLg8ph8/RtO9QYn/kOEGv//I+J1WmcfLK9Lmzy5+f/RDv8+HX3Es1objoyU+3Ofdh+d8+pPf4qXnId6d+MynFf/dL1kuL1acHN+i7y0vv/QqP/XTf5Hf+73f5+Of/CHu3jtndXRKiPmA37FE2rbm9p3bLN2Cl5/exyyaa/xub3F6esTJ8RF3urucHN+ipj7gdzi/5PwrX+R4nx8/Gw7LdRx/VllVoQ5n8334zXduHMdZPaPkAnke0qrD2zzn9GUescnW+T5/EHWO60E4RZb9DoQ7xDteKU0OiaNFx9/63GMur5b80lkm3+C3vHc/QPj9PQ/Go/UUZSm5UFcr8uIeH/7oa3zl7f+BX/vv/xk//5d+EdttiEPE6YoxDPS7K+puMTPNHErLFp8pmlIiWllyiaANd6vX6HmdvoxENMlWWJ3prx5jlKJZ32LRHXF29i5tdUJbV3Pyud/anv0bDPgS6eNjTt1LjHrL1D+iq++TlSKSIIvnCsoSUiYMW1E4ScKWs64lq4KtxdtcK0PInhR64uixzpPUkkJG5cLTsOH3r75OV2pebF/i1N2m1HJgfAyMm3M0RvxiM+zyE17ffZPHD0f6i4HH23/JN7+V+bmPf5amrTA2kGPAVgs0kNT+BimHm6OqDUOy5KTYbXrGYWDsPX3vhTEneI21Fp8yJhfquuW98yfcOblDyoGrzSXvPXpA8IFF21FVHcvTFWMZudxsKTmxuCUEAh88b7z7CB8zunJ0R8eEYWQYBmGZaE3MiaaqqasKZ5dcXl1RdyK94r2Aaqaw6SMpF5GirjLKaIyzbLcbtCqcnK7ZbXeMXphY/ZUM+btFy2LRMWmPDxO7fscUgnAcp4l2sSCGwMXlJcvFgrpu6PuRED1NW2O0Q2VFSgEfJuq2IW13MIn8S1l0bIaBqnIorbApyWZ206C1xnt/kDiPMcqQ0BhsZQ8Hde8dMU4TyiuMs9R1Td1UTH7AVYZd36ONYtE1DFdXKOOYeo824Cd/SBj95GmqipSzbG+HQEwJYzQGhVGKyjnZiM6F2lisFr9vpdSc4ObZB0TTNML0Oz8752rMGF3RNStKDgcppmEYCKNnvTqCnCgxElNiGjzHR2sp7Yr4oaRYSEWRYsJoS0niLxZCRisLSl7P1m9I9fyeOk0pIvFhncX3HlvJYN6g6YeRddfBzG7MKaK0lkRmGKUwnRPzEDxx9qiYpgljLKBmr6EGay2bzYba1SzaNaFktlPP+cUlsrVsyUoz+cBRUcQiiVCOss1e1xXWSUIyxoGCom5aSBkfR8ZJkg7rDFbLcH7KHrto2exG2sUSozXj0FNKoFBo65opRS4uN5xdvMdqveT0zsnswSaPYRgwpsa6hlxGSo44ByVkphhp6oZ2vQItw2rnKvxWNspjnNAFStaUWGi7juAj4zDSVjW+H1FF5N+sNcQc6NoVOQX8NFG7mhwUpdGQRVIlxETKgXZmqOUoRYLTBl0JO7jEhLEWbRwpFoijSNjYCh9HoNAtGryCMI4MMXDhI+fDJbsxsdsmzi8CAYXWEZ3ED11R03tPiomQIGcrW+thonKVyNHFiHXis+5sNVtriPQQpeCsghxoG9lwLykDIsG+aAw/++c+zbGzZGv4mZ/+NApHzJH13Y7X7t3iU689z597WZGMI8TI//OXf4fR1pScoCSUtRQFUWewsE2af/QbX+bB5pJ/97M/ysI4wR0E/LUSNQCjDVSQUsQq8V7KJWGMyHSJv5WwCYsypPJBiuT3/jhsKGnx73o2eXg2QVEzSzAXKfxyEem3UsrBz0yeb89M38vUSxIG10mIFOgAM0vWGPZS8tc/sxwIXM4aUs6EkGYmckGp6wJ//xz74n/PVt9bWwBURtjrm90OM5N3JOmT2KS1OvipWZNFAq6Ssy7Sc8JuV1qhMnRdTde2UArjMKCtEeKSD5QsKhb7XMu5CmsKk/d0XctfCj9LGztJfufELc8Nt2fZkaUU1F5BYE7CJeHnwE7/YINk/9g3J5Sem3tF0+8CMVyxXosMWSkBvMLqSjwStQEj112S80TlLGiFnhn+JYvChpu3AYwxbLdbnp6d8+JLL9C2LVfbLR/rP8Un9Kf55fYf8IXxN8hzk09pg3hqGerazY1IWCwrfIjsdqK0opXCGIWrDJOfGCZRN9HasdnsZMtt0bJcLiXpLwMhBHZDT1vXDMNILnL9Ls7Pca7i6nLHbtfTdQ1Hx0dAoXLmwPhWSqOVYS83N44RPwlbfV8AHJ0saVpHLoWH7z4iI6opIcuQwRiD92KfouamzcMH75FyomkqFLD1E8vF4kAQS8kAhfOLc+q6QWswRlOAbRkpZHJSs8/XdbEnMqCS3+YsgiDeJyCQUyGmPLOsM8/KfGoj2Cy2Km4uDOUshZhE0SUXKm1l24T9gCYR5rOmlKJyFhPlJrfWSsGvNbpIg6AfBkou7PqBb7z2Li/+7i3uhCNpyCmLdRUidwh53NG1FSfNko6ai7Mt4WRifXRK3bS8cHaXxZuK9z7tGf3EOIikV9susNbRtvDh8hp2bvLMp4DVeo1z4mmYMagcaWpDyRbnatZHa5zbEqN4wKm5kRGT58nTL1DUN0hJkbPIqKm5uN4X4vJ3Dufy2cLscAb3DbLy7PfIKc4pzyx1yRHLTIDSc3O95EIsEu9lK2VPghWZzGd/1v659/E6hMJmOwKZi4tznn/+mL/8C0/5+tccxh5zeXVFyZE8y6wdtkhB4ljJh/hRSkEbifdqPisxRLEOOsSLODPEsxTB833qnDv4IaLElyzGyDSNpDL7XM5s9No5ttvtAZf2cR00MQ6H+9hae5CFG0dP34/0/XDItZUSTzhn3ezb+q+WS9sPPP51DPJnr+OzsfaDf/9uH/tu33/Y/Pk+HjcY/seP4au4pAxidfMnieFmnOOvNjcYfoPhwA2G/1nF8PPzc27fusHwP+jxg4rhN/j9x4/fPi7JAwe5X4Xgd4E5jl7jd+L9ZJhn8frwfnE9T2P/3fM10s/g9+59+N0Qomya62fw2xhAiXR9Tmn++PU9dhjmWDtbdhp22y1Pzs55acbvzTax7T+F1p+mbv8B5Qa//0j4/buf+hbDA/9nGr+NGVEEvFd8+pNfx4cX+NKXK3abh6RSH/BbUVgfrVgslyR+grb7TaYpcnrrDk294OREU1UNuUwH/G5SzYfqV3nPPviD8Xu94iiu+YWHP0NDDc/gd3n0K6zjV8nCPLjGTp7B7zlOsV/e3p9C9QEsUO/H1v337z3Hn/3W/dfAftAtZ3k/dD+M4vcYWQrl2cM/P0POBe8jUBjGkfWi5j/5ixektOB33jq9we9nHj8I+P29D8YLGB0oWUNOpHGiJM+d4xc5a96g6wpTrum6E7SCql0Q/YBtWiqtoMysq6JJqqA0RDKliMy007e400Qejm8wqcQqR1RMVLYV5f9k0W5JvYCmdujKEfOINQ5fClv/iEV6HrtaY3VF093GxBbnCrZZidxASrPk0cz8iuJNaxvL9vwSvbuiWd8jqwLIsHYYdlS2QhmLImNMRhctbE+dUXFCBajrit12yxu7b5LqzPPNK5Ag5ECZ5EbRugGXebR7k6fnGzaXE9iaXDJvbrb8xpvv8O98+K5sH/uEjUFkydX7WRAKhaka9G6D0Zq6qjHGkYrHh1G2nrMAeIqRVGDZrghpoijo+52wwDIsl2vx2K0UZMs0Bna7gVpXHB05pmni4mLDph9QxnAyyz5P4zQPhqCtK+rKUdqKYRi4urqkFEmYVJHDHlLi7PICawWgNZqmafF+YuonTo5PaJdL/BTw4Zzl0Zpp8NRNTS6FzcUlZh721pWjYJh8YLlasdtsSCbi6opiHTElQkqSbFTCPJvGCWsEULTSDLstTVXTdq1ItMSMdY6F0mz7HdUzkuEpJXyM5Ci/U11XMKenfhxZrpakVATo5u1VYc9oSkooDdoYSZxm5uHkPYVC3bT0/UhRhbpuKEkCsVMRa+pZYkhYWT5s5i3yTN3UKKsIuXBxcUVJgdpa4nYLWvy0+3HEOSvMPCPX4ezsgofvPcW1S6q2wmhNxhBCoB8Hmq5BFdmELSlSUFhXEWMQ5qcqVJWVJHfGGbk1xeAi+kDOUug5rcXHusz+ycbihwltHc4a/DSKr0rO5ByxVUXsJ1JpZBCrG3xW+BTQGMZpwLqKy92WgkiDGCWMWV9GfJD31BrxtRGJbUfOReTmi55fqxIfbCXD1LqqyUWh0DirKGS6dsFilgpyrsLVBpULRYn/TswTUWVO10uRgE+J0+WSy83AbhhpW/Fmstogm8CgtOViO2C04tai4ej0Lqujexytbx3AWSnF7dP7vPXO2zz/4ilTn6ldJdLuIVO0QRlDSZm6XUPK5Jjod09JKmNdTdd1TMPINHr6cUIrTWMccfDoDOuTI9ScYBqlGHcbxBJNlAlsVVEMmCLqCtPkaRonkk9aYzGoApWtKQp2045hs6NddLRVTYiBlIL4metALAanDFtfeDduedqPDAF2V5FaFzb9yOZCYVRCq0jSChA/FchEJCG1qhBKJCcFlSahUFmKtldfOuZ0scKUwLsPL7DVkug9vQ+0teO5O/d5uvWcLJfUiM9W1RnqRrGsK/6nf/E2oPjwh+7zwskCsmcshRfv3mIcNEcrUU4/Wi75+MvP8ZWnTxGFmYqUihBDiidmBQRUXfHw4RVXn9pxXB8TvQxHtTaUBMY6kehDFBUUkEOhFMMUJZblubE5d1Yl2fkjPrTSpJLY+47t7zXYs+jKzIqUAsDORa8oVkjS5pyZZd+Zmer6kBjvmeOSoymuWdd6lslJsyLEPjG6LrarygGFGCLK7FOSGTe8lyazU7N0f37mua8T2oNUW+VIKc8SVMLGzjmz3e5E7kg7KEVsVRQ0bUM/DAyjFFhV5TBGkVJmvV4Ro0eVTEqZECOV0Yyjp8zNC6XAGMvewzDGSDXLzu2l8/akF60UZS6u9xsn+6aFNOz0/PXX72kpkm+8r3GiFM82NlJKM9lDijxrHeM4kVK8LraNFtayEjUHbfd4JM+xzXvpOkflqmuizpx0G6NZrUShZbPZsFwuyLMlQc6Zv+R/jhfql/mHm1/ia+qblMKhGZ+zvC8hBBbLDjN5hn4S0oeystXuDORCSrKFt93shHBkRT2nrms2IXB1cYk2mpOTY5qqYpgmYdeqQrdY4ieP0fJ5YzTWaNarJdbq2Q9pZJomTk5OiNGz2+1omyW73TlKaYxxjOOA2xkWnWPZtty+fcKjx0/Z9RMpJzabfm4EVRhdzZv4sFyJV9jR0ZroJ0IIOOc4PlpRlOLx48egNCl4jo5PWK0WGKV4vLtiHKMobRhNTrNyhFLPnFGFVpCVbAIUIKYieUeI89fKOZY/Rf0FhRTte3+tmX2eS2GaCzltDFYrhnGSjQU1x4a5Dp0mf7jfvA9SDGlNVRlpBseEUoV+s2OxXAje1hVimabngqQCo8Bo+t3AxMjxnSXj44mt3aF1za7f8cn0IX49PWLy42GbY5om7n/1lB8bP8fFxTmfX3+abCO7JLYvWheOVu9ytA4MwyCed17eO6MLr736Nk3ds+y+wvlZx/GtU3KS3LhuA4+e/I+HYlfOlrCeyzNSbu8rspRIKat9YTZ/TJjqzOd6X7Ttv2C2Lc1yDQoyCLuWe3umBbDfbFHSjP9gky6Xa1woRbYbiKLaPIwBt9tx+/YxP/lTl/yTf5xF7i8FxjGy6FqxEJrPZooRn4SBzp5EPw/pnLbSMP1AQz+EiJ2bFylFytz4dJVDpUzK0lS11jKMI9qag09fVTmmfqCUvaWONB+maZobrIILzlVzoa4IIRFCkkaaVYdtPxCZyHxoWH33gvy7Fcj/uqL8X/d4Fnv+VQX6B4cs38/jBsNvMPwGw28w/AbDbzD8BsN/8DD8Br//ePE7xOeYpudmrL5+vw/nUGtRcymH8dehx6I/gN+qyNeqZ+4J9Qx+iyfwPMie8Xv4AH4bo+XvM/abZ/BbttC/E78PZ3nG7+VqwTjj92K5oJSMn/Hb+5+jrl9ms/kl1A1+/6HwW7zmw+F9/rcBv1996WscH3+ScZjYbuIBvz/1iczXvnHK3Tvv8vKLX2NzBVdXGx4/fsz5+Rnn52fcDgFXN4xJSF9OG3783c/ye8OXGYbxO/H74YvoaDk+X2NUId6KB/xe1BNX7/z3YiYp4HtQXOFfEW6LQOz7Pzb/354+VJ752me/p8zslnn2fTj/18/9gdhfnnkSrr9+/xEZCMuQOISE1oGua/gbnx/57Tdu8PsHDb+/58G40gatHMYacknYZoVKkSo2uGYiFmGvgEIrg+2W5JDIyaPzgphH9OzJrZ0M1ozKMkQMkBtFk0+4W01M8SGlBJS11CzIxUAeiWmkciuqeg1KE8eBuj4l6cC7u29xkjPP1Z/mcLtWHTYVkrVYCqpkjJIBXdFS9FpXobojwtPHxM1T2qN7xBQlQcgZVQopexQtSmmUSVjVst08wlbH5JhY2SOe06e8a89wufDu5lvcXr4KdmIYerTWhKnHuSNCHnjUv8PZ1UgKCmfF/3sad1xsN+ymI5bKEFMhs6N4T9FqDm4zWFNIJULyhDDQ+5ExRDJQVJbhL2b2XAerNGjNg3cfUIymqxsZMk0BbSzb7ZYUItZqjLKcrNdUdc2Ts3MuNz0ZuH/3rtxUWrPp5Xdqq4pSoJTM5cUFViuMMSy6lu12yzAMVHUtiZFzIn/jpRAyyqAqRypZWGd9z/L4iIiixMBut2O5WLPb7fAxcnR6yjgMTJOn5Mzp6Sl1XWOdlcG0DyLfnCJV0zB5kaaiFNq25fzinKZpZbDd1myfbg+HpGsb+mEklYyrKirvSTmhlHhih9lvZS/ZMU2TbLkXAbhh12PrWiTUdaaQ5wAhA+ztdgsKVoslKWScNljjGPqJUkuCaE3BT168XKz4scsgUkglwzAgMucV49Cjx0LTCVtvu9mhTKbrjhm2A8ZZSgyYSgJb5Wq0yngfOTu7IifFou1om0rAyBh2fqBqapHGtm5GDiWJaK2xlSUhDNYQsxAxciKmOLOShPF4tQnklPFpwjY1ai8djRKZGFUw1kCR5FyCr7BPh2nAWCW/s5biMUXZ7AXNNAws1yv6YcJZkeOxVhh8pYhMdsyZqlmQvcfZmnEcUEBdCsVYKldRShYJ+5KFeTgnyM5WpOyp6wqlwVWatm4wOeHaBh88dQFyom5aOqtxjeZqs0NRWHQdgxfyUGGgsQ0lBVKOKFsIY2B1suB42UpcouK9x+fgHr0vmF9cXHB80uLDFUUrXCNqDBiFNpbRj+xF3AqRpqnx2WBtzdHRMdMwsOg6zh4/oaiCz4XVak2txSNtGHqWbo2KBVKi312xWHYwBdCOYMFYQ/KeafA4I+xWpWFRL4hB2JeliMRT5SqJO8iQvoRIbR2pspgpsGxr3py2vLW75OqyRyVFpVqcUmwuPf12pNp7/5QGnzK3Tzt8LFzudlTKMKbAojOsuiVBwW7yGAu6g+dWR/yFH3qNk/qWWEFcbCkqoWpLaBqGwWOmzOuvvw1NTVtr2qowjZoUNUordkmk67/45gM+8qEX+MyHnuO52yvuPLckTobcJFR2hBz4cz/6MX7UX/DNb2/4tS9+E1VpQrbUyqCSIxKwWC4vdvx3/+g3+ff/yk9zatvZRgC0lZ+pFeJPhzCp0ftYoGbVCENUB3ok+V+VJf7r8Fvt/3x2I0JUA0oWlraZmYRaqWvpIQn5MxkIdJHXZcx1oraXS2ua+lCE70lFeW4i5bxPGBXipy5S93vriBQ9wIHNLuQp2ZAqJeOnwGsfeoEHDx7MklWSVFqtQRtCimhr2e12GGtp6hofhFimgKapD02Duq4pKWO1pD8xR2pXz4W8mhmUXohwWvBtsVigtWHbD6RcsEYfSDLeiy1ModA2FcFPfNZ+ng9ffYwQ44F9WrhO0pTeSw6pg3ybUojcWkwHb9Jnr9f+ekjj5LrRJgWUqOekFGZlDkPKhRJmhn6SuG3NXPgbDUVYzvumjA+RcZwOHkPWCn7uX3ddVVRVw24nlimLboH3XorPpPkcn+XRnXd5cP4u7VJk9cZxIsVCmQlJu+2Ec5bFosUYafY718r7gCKkjM0QS2bRdhhTqJzEvD1TOOfIcrlkHHuO1it2u+HQyOi6mq6r0MbR9z27fst6tWDZdWSEZb3b7VAajtdHDOOOfthwfLLmnbcfcnV5xXK1JCfo6gV3b99i8j11bbm4Gnnr2w+wTs/s+cK33niLk5MjiY9KBiNnZ2c4o2nblqapOD5e8d7jp5xfnHPr1m105Sgk2qZhueh4++yJWPZUcr+TmM9NOTR5rTVU1jJMYr+Sc8EYDjKhAh4ZNBT2tg3X0oAhSqG0Z6WnFCkzadF7j3JyzVPKGCus/jgTH/dNMJhlQbU6WKJopRlHUQShKLa7Hb/7mTd48RvP4ZzDaENV18I+jwllK1HtyYH/LP9dulcXdGYljWg8ipo/d/8n+QtvNCgDxjS0Txpyk1lertH2RexkiGkkZlGmSSHx8Y+e8J//bxyuvqSqHTEUcigoG3ntlcj//n97j667M6uamDlPXZB5k2F4nVK01CJIE3vfmNizsuXuZc4Lv0tBNhfYqGeKv31xXvabKfth2v5yXTfp1eHP9xfA+88fNs6Y63O176HOzcAcMRimKXGZ5Xz+5V84xdgNX/nKbS4venLWGG2ZrKHvd9R1Q9M0hLgTkuuszDOOA91yMd8jMihQRR2Y3tbYaznNuUWgjZ43MhJ1Ux9iSL2X15zjoCjQRHlP1d57UmKu4IXcxvstKGMMl5cbvI9Y6yRGHjzQZlwqsn2hQHI5ZtlMZmlpxcF/cx8vv1uR/of9+PfyODRO58bx9/O4wfAbDL/B8BsM/+PB8G9x943bLFV3g+HcYPgNhn//GH6D33+8+N00z9MPx6Q4sh/yHy7EjN/7ayDxQg6xmfF7v0l5GI6Wchik7/Gb9+UECkom/wH4rVORuceM38ZIvBIPabnnw4zf7hn8fnbA80H87roFbsbvlDSFz3L3zrucnb/L4ga/v2f8lrOdsE79GcHv76UGj/xn/6vHdPY+XVcf8PsjHwr8L/7uOxwdNdjqRYz+sHjbty3ej6zWC1IMKHg/fh9/jP/89v8a19ffid/lRf6Pd/531Pdq6lK/D7+r8A2G8Vuk2WoZCnst9eu8W+TpiyqHMzufwu8aa5/96HWY32O1+sDnyvVAGpl7oK5VZA7T97L/3me2xvevYp6DaaVIBaZRcOK1+xV/5yfO+eXX73N+eYPfPyj4/b0PxgGFBSxKZbRRlGIw9YoSA9F7MD0xJyoU2Vicaoh5JMYK5TSoiEITQ6CkgnIZpQsxTZw9ehfSku6oY/KGbDPGrNClJ8fANF7hakdjFxi7wLEit2JQP/lzHufHvLt9l0rdQa0tg9owGk/dWAgDU0oY6wTAUTBvi8di0FgWzS0SCm0NaRwY+w11JVIbGoR5YzRO1+iiyJdn7C7OMN0pwWa2YaDWRzh6NnHgwe7bHI+OvL3CuAaVK1IIfGvzz/jaxUOmqwXaRnZhpNIVLsFCayrr5KJYhU8elQbS6JF39ZkLHbOwf2rFGAZC9ExTIM1a/zOnHeccXV3Rjzs2Vxuef/EFxhgpYSTGieIH6qpjebRCKdmo99PEt996m8kHtHO0TXuQfxjGiYSSYTuzF0eKdE1NPvhyKPHwritC8AeZlRgjRityQjaLyywvkgVok5+IUWRcUgoMQ49xjrZTVPW1F/LUD7zz9tvcuXcPHyYKhXrR4CfZCr/ablgvFox9jzEWpQt1XbPbbWkXCxk6VY5pHFl0Hf0wYLSWjW9b07UN09jjvbC3go8opQ9sSWsNY/CoArVzlFxI0ygMQgPOOLyXgXqtGkAkiHa7LV3doLShFE3dNFAKfb+jqjuKEnkMidUydB+nCWscWimaRtQFjo6PJIj7xOZyiwJcVbGdRrIWOY26rgToUsLP0jiPnjzET56T0xNySfgQWLYLei9+5OMw0lQN0+jRJVG1DlLE+0hdO2IM2NrNfhrmEDT3Ej3iE+MIaZzvjYhRABrrZqap1mSlaJqOsN3RWGEH1nWNM46SCjmJD7SxlrTd0DZW7mtjZYPeB0LxpJIJk6hPGGOo6wa/2zENI5UxoDJ1UxFD5On5U4qWgSTFEFImxoRWWpI66zhZV2ij5mToOvjXztCSwDnuLlZcDT2X44AtmmEILNolC6uY+gDWYZxhN3iyY07OGmKJHC3WpHGiLwNBGbweuHXnFNe8D6vpFgts5UAX+t1ATJrHT68Yd1um4LFGkvQwySaKdRZMEU/xVLNeNmwvz4lhpO0aYlFUlWWaJjSKadtzdXFJLkU8n2IihA1aG/y0Q7uK1Wo1qxVk6qpGqSyb+MFDUVS1Q5uKatHQjwN5ko8LoiaKa7nc7BhU4q3tIx73md2TgbCD4+MVF8MFxEIqmrau6VxNUiNTmPjsK3f4oVfv8vvfesLvXm340Idv84nbt/CPH/LosuflT3+c4/Vdpu1jTo9X5Cnitzt83mGMwyhDNJJg6Rx4crmlH0deff4em5DoJ8+tE01bWx6fe662GRczg5rY5Jrf+b03+d3fe5OX7h3zE59+lXt3FCa2KDKgWNoMzSk//unnePOtc97te26dGq4eZzATrXN0VcU4jrx46z7/9B9/mT/3459hVbeooshaif1Dke2jXDKYgkGTi8iBpTnJkmRnbqJ+Bz/ye39cF9nPNmwKOUa0UbPEmhSD2u5Z6FLQ7VnYau787IvwUkSa59k4IL5nmpwjVSXsw30yt/ciA2FHhiByWCFMOCfeTFabQ8KHUmikmLeV45133gGkMbXHI1NVUswqTWUsQ+xhLpZNEksEa2dm49wksM4yhgGrHdvdABhCTPjN7sDadsawK8KobpqacRrRxlA5SynCjKxnfynv/aEonEYhmOmk0FEdJI32TQZjDWqv/pL2Enjy3uWYyHORrg7X6Nkkfi/qyOH9fJ9vaWImnemDz4802iFnIWLEJBhKTFijhbQzv769v1X2E8Y4sSiwdm7K71VvpElyfn5JW9fUs0VGyZaSE3/D/k2SyfzK9tfwIZGTYrvr0cqgDRQ0Uwh0jcNoS/SJo5Mj+mFHDomurSkl4YxBo/HDyIBlGHccHa+5ffuEq8srri42pJmwdrReIiosE8vlESklpmk6NAAuLjcsFh2Xl5fSJC2Kd955xO1bCU3DdnvB2liOjpdMU8BaaRoUk9kNI2GKDLsRP3qauuNqc8XQX2CtKK2MY6LrWkLwPH68JefMer1kvfa80AnRZ5p6PvuZT6AwBB84Pj6mbRqsa3jx5fvoOLPDZ8KYmv8n2wWS6lW1xcdATGouxPYNWznLsrmkhSD5zBBGmlzpcL+Il5M6fJzM7Ctn567HM75NRUrFva+mZJUakVfUoAvnF5dUcxyw1tCfDFyejrzgV4fC0liHrTqUMnIP5UKnjlGV2EqIx56mrluW6zu4qpLzVtVUVUVYxEPsskbY+ubQFKwppWV1NDeYCkQjGzFKKwyO01vC0DdOFGQUUHc1j5/+P9juBqxzgCIG8TPcF8D7c7c/iao809hkX5hfk5f2fxbeH2cPH1fys/fbZUop6cMrmOFlbphfx/sPFoaFMq+u7eOA5KRCrlLEpNj1E9oY/sJfcDx574qzx9I8HMNIU1XElMlJJF+7tiGkhDP2/8fen/1Kt+b3fdjnmdZQVXt8xzP1dM7pkWxOpiyRpkRZkmXZMCTDMnwR2xcBchEgAXKX+/guAWIg/0CABA4COECcQI4FT7JgS5REiVQ3p2bPp8/4jnuoYa31jLn4Pat2vW+fJg8pUuqW92q8p/euXbt21Vrreb6/4fv7fhnHka7vakEuV8ugSlJMqe7/DlXm+0POia1TDq65kYyWaadMYyy6KHwM+ClQlEI7i0aS5a5raRqRbcw51ukZuQfHccJ7WeezHKQk+bL/KqUIk8cYiEU80WItvhYKbSOynpvNsJ+0ejmh/iQJ9sexzj9Jcv5xfmd/3OMWw28x/BbDf0wx/PWHtD+wxM+kfykw/Prult968/v8hfd//hbD5wdvMfwWw/8Zjlv8/ueH38Y0TNP92ozRB41Fwe/ZZmSeolQVv1NtWr54jdRNo+0Av1W9puYAv1PFb630/rm5ZErF76SQuKLWm62R65SUyMs3Fb+nit+h4rep+J2LDE/kkvEXV3StNCHRClfxW9m/wV2T2dzi9yfG78/xGr+mfk+ar/8S4PcnzsFXQiT4YfwuP4TfR+ET4PdM8rA/jN931P0fwu9u0WJ/8/+MD0FUnQtVav5Gyrwuu5ujLsC5Zj73rue+9cdv54fN7HkFz1isbh46aKkfRu/z7x7sBC8+t0iPUPaMQi66Tlgr/u2fhe8+vuAfPe1v8fsnBL8/cWM8R0/QGdd0yJXIpDxgrCX4a/JmoJzIZrhcHKHGK6bhKcq2BNNi2wXaOnKIKF0gG0BcuTIKosfEkafba8YUOG4MFkXSGteckONIY8+4Tmt82XLsjjA0qDKyC89IJfBheIp99t/x6fZL9EdnFNWQnUIX8WB2zpGoLO+6aWnEA6LvW3Cn+FxAS8NT5yg3jxE5ZGMdOrWo7OlWd7i++gZps8Yfd1yPa/q2wdBytHJcbb7N+dkX6FZ3RJbaQp4GdvGaJ88GypUlh0AqisYkbNtxerTAarm5UskSMFkwIZBrA3i+KRptKSXgo8c0jr5fst4kStYoZYS1ThHPGD/xwYfvY63DNY6cPbsBQsicnCxZLs9AwXa7Y72+YhzFj6BbdqRUePrkGYtOrvvkA8vlipQSKYp0jjJ6z0j0PrPdbqWxY6SZPE3TPliwxpBKBqtJMdA0jpgzIQWa7ECDrx4i3gf6fkHrnDSJUyLFSLfoyTnhp4kpinz28k4P1pGKsNtSDPRdx/V6zWLRoVSRydpxpF8saKxjHAYaJ01nHyPTOGGsxRmNWy1Zr9dY50QtQeu9nEXOGWcd0zRSivhkGWcYxpFSCynONBjbiKSQc4QYKmhJQBtTprUOjWK57IkZYkhClMoiiQEKoy1h8pSc0ErYOKluSMEHQvA0bUPTNGx3W6x28j7IdE2DqYyxYZgYh4mmteJNYuRa5BTJqcr9KfmMfddW2R1wxu4LPkopSgZrJQiUzU/UDLS1xHEkK5EpT8FjnSH4CWOdMC21EAT61mAwbHyAsqmyMsLy7vuOGCLGWEYf2Y4j3eJIprL1TFdMFCV55fwZpjhIcGgsw25HdnLutYambWmXK3yQa+CnQEoyXZGTNCCHYeD0aCmsw+qtnkIgobki8urxMWqMPN5e4YeEsxaMZbMZcVPCLi07X9Ba2FM5JprVAoVI7LdtQ9cYSna4tscaQ9MotHYU3b0Awvfun/HO974vkVixKDQlKYgFHSVJafqWtgejLZvdyHY94MbE0/WO11+5x/mqw4WOhCQhTWcZxh1kuQYlJFJOXO9GcqmsMWdo2gZCIIQJoxWuczR9RykZ4xqR/06FlAKxgOtamrbBdB3KQ0oTY4lcTSPvTSNPtxuericYLGGnwSmudzuSzzT09E2mbzUhiHzT0rW8tlwQxi2LNvFnfuYVvvDaK+gx8L1nDanxpJA4WVkufMM4eZn6tkuaRUfIA9oIWUWVhM6emAKr4xUny8TP3H/Af/2P3+F3fqBY6C3dynJyBq/eWTBNHVfrzGWeUNry/Y+e8P7TDa8/6PmFL36WN+71qKIZS6GNBeU8v/orn+f9Dzfcv7fkt37rXZ76DafLJb/8K7/Mk/eecnLac7pYsPbC8C1KmH/FGKKq7O+iSSVSlEYVjVZWJvBzRmmHUUUCqEP2xB/xcNagtK4eUWWfyAkzkv3jktylPSnEGF3XkSSdOec9w3BmM8cY9wXYnPM+EBGSFPuvnXP7r2WqSfye5s9lqoSb+KKVvX+YihKUOef2xYC2bck541MWNQrjKEXRWLcvAs/+WeLdo9G5QMnkKLJHYfIUwDauMnmjFCFyplT2pNaKYZhEwi77/XkrJXN8fMz19fW+0CAYoTl2S768+SlSzi8EbVkyrv3z96zXShiiiL9R4cVCWs5UfM37a6eqBNJevq3KbM0FAFUpsPM11VqTShFiRhavupwK1ul9MjH5QNe2wu6cJnQtkMhkgK7Xvcropch6s+X87IS+64QclhOFzL+7+pv8A//3CF7Od9s0cg71fH214JYTvF9vt8QYZF3EGuwqGKYBcmK721EKXF5sODo6AqUZphGt4OzslNWqo+8XPHnyFK0N4xRFacZHjFHcOT8nhIjWspfGKLJQ77zzHnOJo5Bpmw5rHSklQog8fnTJ86fXtG3Hhx8+wlrH6mhB4xu8TwyDFIZCjKw3a5TS5DwSQyDnxG4nCXrXOl555SFHqyUpidrNYtHL3/GZhW05/+2ei68Mcg7rtb+5foiMH9SiTSaXej8wF3k5WKPzNKLcp3MCL7GjkBntDb1e7rcsf2dOelRlECukaJsL4qWXC1C90BACmRSTNKUkNlrx1Fq+vvwWr/l7Nd6J5KJZLFqc67CuQWtLydA0DdY1NG1LTgVTSYCm2nZIDKRR+H1hMMZUi4Ui4xVjpOu6+vlq6lqLVbJMsljaKPHbcsaJxVCIvPPOO/s1ODP7cy1EzGtJHq8eZfuCermplVe/t7mglueEVcn1okAq8vcVas+knrtj82upmwf2jbOy/yPz9Ssv/h4HyWGR9xiTYpoiRo8sFj1f/PLIvQfw3//3Qm40Ruyouq5DaZlQGMepssY7VPWztMahlGYap/3fds7uWezG6L2cpDQHb+QnY92zvfdQZG/XWoi6M0bIvh/3RU3nbCVZzgWjG/JiqXY0xkhRoJSb4qVS1BhYJAzj7kbOLUYpJIhf5ccn0YfTg4fn8w/D20/KWH/hGv0zHLcYfovhtxj+44nhS9ty/js9jz+9+ZcCw6217IwQ3G8x/BbDbzH8nx3Db/H7nx9+W3vMevtVUvY3zRS54OSU0MbMu59c25wPXvemzr6/5plKHqvxQMVvmfyVPdz8CPyeYwLxjS+UMnvzKkoqmB+B39MBfovHuOB30nUyNUU2my1nZycsuq42sgS/j1Z/k3iL358Yv3/q8adpnAxM/cuA3z8pOXgMkc3lZf292V7kBgvn/vULhLJ6rudzuX98T1cp82qXq7Vvlh9W2X94Hy/lptle38YLf+Pm64/HgP3b3WN4QgVonONXPr/h95+umMItfv8k4PcnboyXDDlXRotyUCwUAcNgNLurp2gSK70ihyv8+tuU3Yjr7lN0i12cgtqRSkE7Q0qKkDPKNegibElbPLvxQ2KzZMoTuowoHFkp2v4cU+U+dtMlMa8Yg0w3PhqfstLHWH3B4+fvc3r3U9wpC6ayZqnvkLsGXTTOWnJMIh+txUdCk0SqvFlhuo51GNCqoW0h7NbYtgdra2NCFnkKBd2tWJ3dYXi643rYoRKoErGq4WH3ab5Wfo9meo+3Tr5CU1q244YwXrKZBnaPHWZIFK3RAUYTebA4I41blL6PbRqy97IJqkwugXG35nBhN9ZCKZSkaVxH0yGy8MrQ2JakBbj6ZkHIiSdPH/O5T30WreHi6QUWx+mdezhrCHni6mLN1eUzuoXl7OyUUjSb9Ybr9TWNtTItbC0nx8eAwo8Di36Bc47r62t8CJXFo+i6jjT7awCta6rXMqw3a0AmyNvWMuy2FGWwznJ9dU2/XKGtEfYTimkc9w1rkbjW7IaBeYI7VSmJi6dPWSxW+BhZLhb4YYdSRkAsFwzi073bbFFIA/Vqu2OR896LzTmLH0dM32KMZrlcMowTFGG/GFVw1fvNdS3USYJUIrrU91MghkhIAds4FJBjxBoLSjH6ib7rCDHQtQ5Tgz60AhwpeUBkx3MRyaEUooBUkACp7zpSzlyt5Z6wRjNsdyy6nuAD1sgUrqks1MurS66vtywWPdrcbEDGyCTxGIM0+mMmxlCBOdA1S3QFmxQibdMQQsRZkZYBCaCnSbzHZ0as1hplpQFfcmEMgRgzKdXzkDKkRNe3eD+hlSJUD3PGglUWZTTb3cA2Zk5tw/LEMA6elCIJ0NbiChgUymqUEQBom5bWNsJk1EIsWA8DKVNljNQeAEXFINcEWnxc+t7s94lpGDBofPR8eFGAlskmhnHkaHnM1eiRlECz3o207RI/RTSORd8yjDv6bkEp4k10sXlG27TE0FJC4shasrKMU9gv7YKoJzS2o1tYNrsdOU3cPT9moyacXWBbA9VaoWl6xuDZbLecPXzI4uiUb/7e7/LGK/chB7wf6I8WZCVsRm0sTs1qBJ5hCviU6NsWVME6R0mR4D1BZXrTglrSuF6AUct6SknUP/zoBQhzwjUNcYCPNlveWW/ZbWHYRUw0+BJJqmBKQmVLW5NEpRXTVGhN4HS1IDtFfyQN6Dfvd2QDnVaUvqPvTinbnVhsqMzCa9zZgs24o6SC0w2r9hijhTVRUGjl0NmQfUE1ht/71iU5ORoGSmkZrgwX1yOtHjluG169A59uFd97NzOZnlQiHzy54sNnX+eNh/f5819+kzsrg9eaQsvZ+RF37kRyzPzFv3gXTItqWnrdcvr5BcVnPIVTo/A1iNYKKIqsNUY5UVVIHkX1uMoSCGvjJBArBV0qs/SPecyJqtFAEXLSnHQrdSPRMzPQS/X0kq9vZIVuPL0k6E0Ha35Oxq0VdQJZZ2o/ETUn7m3bVO8nI9PxKUngn4VhqrVIxWWlhGDl7L7g1TTN3stMa4Wu7yvECaUyi1VL3/eMUyCGILYNCPFF1UQkxgCV3dt1rUgrYuj7Hj9NwlgtL7LiQQglN38fNpsNXdeJVQYF54SsZLLl3vAKY5yAWd5RAuaS6jmsaY0wMyXRZe+rVOTruaCm5kJc/Z1coIi6CDXRMMbc7CGFfWFPzYlFLeQVJUGs0FszOqt9gqO0Jni/x54UAtpoYkp0bQsIgaZtG6xzXF1fs1j0OGdpux6HIkTPkWv5m+1/wP/t6j8jq8TRUVexSJGi+JWtVidM04T3gYVrKEUKO8end9hut8SYOD5aorVitx0xRrFYLHh+ccnkA23XcnLUEWNgvQ41QYtcXz+n7zq6rscYj2scfd+zvr4GBcNuR+M6rtcXUAQfxfsusTO+JqmF3TjwhU99jsmP/OAHH/H06YZXX3lAzoVxmthuBkoRjz+bRD7O+0TTGE5OFjjXMAw7PvzwGa/cP+Xs9JS2dTRNx8nJqRSBcsIWxx294pc++Fn+v+nvQS0g7dcckIskTiEkkfWt0whSkJmTY0mIZL2pF4pj87o+TApSZRLvi3Mogo9Vnpd98+XmBSThTVnuSWNrsU4Z8U8z4jU2DBPWbNm5HcEHdnGL1o6lW2BMi7Et1nR0/RLQNE2LskaStZT32aiQUW8KYMo4TE04rb2R/XLWYa2lfgS0tRIT1mmXXItSPkVsJTjGMJFz5noz8ez5c1HpOcylOZBW1AqVb87fXFDfJ+7z83Mhk/cehfv1RtmzpGWK5DCZO0jQ56y6fv1i4f5GMeTjCvDsE//572ZCgVEHlNI8eGVidQzHR+f0naVtWgqFFBPDNBFz5OR4CRQ2mw0hBrSSeNUaw5ClWKSV3suiaaPrBKoUTruur3KO6SahTolUCwSEQMo3eDJ7/0nhNkscqM1+OsoYw3I5k1NNnZhNnJ6eEkJgu90RQhS2e2NpWos1ju12J7hWi5AhxmqbU2rR92Z6an/1DpLvw3VyON1V6w0vFEn+sONPohl+eNxi+C2Gwy2G/7hi+C/+4k/fYvgthu+/vsXwWww/PG7x+58ffpciDZkUIwV9MKko+D2TYObzvW8SzfYopUqtz2tVqbouZyJcIZZY15LgdznAbw7we7ZomPfiVPHbaEUsGXWA3/PndU72Q5nol2vcti0KiCHQtA2u4ne/6GkqfquK36ul4uFP/Qx/79f+IUaVW/z+w/DbrPjLv/Nn+Fv937/F73+O+L3eTIS638+fEdjj5J5cUteuYKWQS174hfr1fB5ffIxKROFgzfPCc26a4De/q9Th8z4JBlSaW31qTpBUJqjEFx5G/td/4Qn/6X97/xa/fwLw+xM3xo2SydAwerQTtlfbHOPH56zXj/jwW7/N/S9/Hrd6Sr7uOTl/g135gJw9OWZiHLFa9PNzjGjtCHEUFtS4Az+Qi8YWTcqeXVEslDStYt7AZEkFlJLFalWDJTFwTUoTCxzn7oisPYaRhVuwCZ6zonCqQTVOmhK6iAdzUfjiKdmi7JKiJkqRppExDSTxbTGNJWgtsgVJEdOEUopWG/LqPlN6xvrZd1FYaMCGDnH4NlynNdfpA+63X0CNmWt1xXceTfitYqUKyjis1qiUeft+x4Olq6wz2ZSy1uSgQBlc295svIBte0IsJJ8I48R2u8EHv2eXiURMYdH3PL26AqVo25b33/mAo9NjrFMiY18yz588ZdhOnB6d0/aKKXguLrdcXFyITE8pNI2jbVtC8KQkfi/BB/EnT+IvXYAQhak1eY9xlnE34LRFGVmIrZPmds6ZkCaaxqG1w/uJZdNTEmgDU4jYthX22TDicmK16On6HqM0l5eX+BBw9bqO28gwDByfnuKnkZQTYYwi7R0Sc4qzWC7YbQdc26Jtg4+Rvm3ROmKNNBvFW0SClL4TH2/5dU2uAcoweWFMqoJWs0+DpZQixICU5H5XImGSpgkq03i72dJ1HcN24Gi5wBqDHwLTNO2bz0pr/DiC0pjWkX2mtR3OWkKKXFxe0tgGbBZ2XMrEEOnajq531Yum4enTp3z40WPu379P37e1IEMNcB3OGfrWst0NaG3o2oVI6mRNTFEk++pn8t6jjAYsMUlQ0HXNPuBtm4ZYJXQKEjxqbdAFpt1E27aYKtlijCbljFJa2H7XWwCOjo7wU8TpwhQiV2PkFdvylbdf5/LZFd/+/jsEMq4Ie07pgtWGXSUfhHFk0XekogghMvmRmAvaNWitiCHsGd8xZ4IXcCDBMHka1xJ9Ytn3xDDgjaF1He9fbVBqoHcNRRsiitb2WHY4FEf9Ea21XJHYeE8h03UtUxRlgClECo6cHTlmMoWwCzz76COO7twEUFopnl89Y3W6qCxNC8XIjqIt2iiapiUVIRpc756TcpWzygoVEyeLFeN2YNzt6JcWVRJ+N9HYlpJhmMSPZvKB9W7AOUMpCdU6jLMYFD7I+m2twahCChOohLWtqBaEgmstxrXEmMklstlueDKMfGs7cX2ZcdFglSHriCkKpzM2OxbWMsWRnCKl6XAKfvqL93n6wY7Wtkx5oGiHihpi4e+/8wFPNgPPn18xXK+JzQnP1olxu+YVf8zZaoUqiUDCmSNMKWSTUKrI3uk0nRUVjqfbJxTl0NoyFU+rKjtaFS6HwLOt594dx2e/CK9eZt57ohh3mlQ03/7gPT548oSf+fwr/MpXvkBrLd40klg1hiY34FqwikDBZUfUgUZ5lGpwJZOVCLIXDI02MiWuFE71xBIkmSKjldhhpIq9WEWKf2R83x+xBvMi+XlTELphigtDfA5YzFxogn3yJ18LPs3PmxO5+Xlzgdc5Vx+XhMEYjbUSSI+jR2uLc45pmvhMOKFF5D6NNZBqAknh2+b5vnB8mPTnLIFcW9nphwl7KhM5iueY1prdbkfX9ZWl7DFK0fUdq9WK1WrB9fU1QmTPWGOIRVi5KUmyVyhgRC3DT2IB4lzDZrOhrcVmpaovXIzs4kQICYqa9ZXYs45LEalHrUX1oiZP5WBaBfYWSxJ3HQSHCvaR4SzDZLTZTxTMRfkXC3c3vzMX4XKV6Es5131YiXwr4ENEa0PMBYMQqGJKOGv2hKiuaxnGgc12S2MtShuWy5Uo0kTPz6tf5Lun3+e37G/iQ2Cx6BjHgefPtkBLzjCOg1zHcUe/6BiHxHYt7H9nNV3j2O1m7yWwpqCNKNPEoAg+s9t5jClsNxPj5BnHwPX1luWiY7HoOVod8b3vvlMJey0xJtyqA8SzNaZECAUfBvrqyzRNI4tlz3s/eB/tNKenZzx/uibnwMMHD/Ahs1mPFKUIdbIDpSlFlE58jGy3AzFGTk6OOD49YppGITw1Hd4HjBPs7WzH6CNvf/5N1PO/L550B4WYYoTAWUomN672W4SRnXO+sV6pR0ovJuI396bEXCWXPYFxLgjJXSL2DhI3ItKgNRO9ye3FtiRmcVAzWjN6TwyBmZmdS2Gz3fI8X/Do4jGlZJp2QUyWjOPsrMNYizFO1HiMTMXkfMP5ls+R0MI7lKROzT6Jcm/O+5FSSiY1Aa1vinfOuf0epZShaTpSDOQqJ9w0Dd//wQ/YrLciL1gOk+q6Xivpcj7B83k/nCg5PApSWD+skx9mcftCfGFffCi5MH9yXX/psKBO/Umpvqn768bNRJx8f/DzOtUyTakWCCObTSKEY87PVqyWS5Fi9J6UhPwpakI9lMwUItOURNkoRlxjscXs97oQhMR4enpK37c8evSIaRI56aZaiGyHsTb1akxdJeFijHvpz/n9itSzFEy6rqvPS/upkZnJXoqoUU2TZ5r8vmnYLxcsFz3eyySTrfuUUoJNMc1TU2VfMDi8dh8ntXb4/rTW1Yom7O+NP+rxJ1Fcv8XwWwyX/+cWw28x/BbDbzH8FsPr8ZOA4T/O+J1S3jdDpB50c97m9/iThN+h4nd5Cb95Cb85wO9DxQjFzbLXL+H34b0wN6GMFhuEw6nz/d590ICXLwAFqeL34fSmUiKVPeN3qnuLNaqqCNR1AbRdyzgOMpn9En4Pg+fZ83+DBw+eE8KjW/z+BPj9hTfe4r98/mu3+L3/HH/6+L19/BsEv8McxM2Hxxxvy2v8we3pGR/US+Hy4WMvPn742M3fuHnssMF+QIA7eK83z5dmveyb8jc0hRgFt3LOdGoghHiL3z8B+P2JG+Pj+hJlO4xrCDExjRs2F+/x6J1fx+5GXn/rVfo756yHj7AT9Od36c+X5DwSs/wZZRpyDDLBawRcx2HDtL2i1ZpiHMu8ZDRbIjDFNa29T9+eEpTCKIuKihJ3BDPSdj0Xm+9yr1mwiZGT5UNs12KUpoRCSDsmG2qbuiVSZDq8Nj8LilzkpilaZEgc4pdSlMK1HSgrbJMqwaSVI+OrNIVjm6/Z5C3KdPTK4KxiE3b0zQqlE5fxMef9pzC07PKa680GFx22dzTAa6crXj85x9lrjo0mhwHoqryaQimDsZauX91cDAWRQCJhtK1A6hm9x0cPTSPS1YAqmaurDYvFinEcsdZxsjpiShO7YcvFxSXWtdy5dwcNXG2uCCkyeM/i+ITOueqnphiHSTxvS2E3DKQQSTFgnTQ7fZSmo9Ga5WJBUYrWNfhxpJRE0zUUZq+zyszNmVyqDAhJgq+SOTpasfOBy/U1Zycn+GliNwxMXhZk17YM04AympOTU7qm5cnjJ7hhqPJCwtrSyjDsPLb6ljtrWK6WXFyt0cYSQ4S2pXGOoCJKG8ZxxLkFOQsT0zYN0zix6HtpFCPNK1nkCorCOieS5Fk2xd0wcHp0gtaG7W4n/lc54aNM2nZtQRvNOHnxotBaGtVWCAgz0GyH6SCZArRmt9ngQ6Rr5inSWT4sEbMnhkJuW95//0OePH3GcrkEaqGmFlQsihQj2+DBGIL3WNOSbCSmRMyZkiLGNng/4ZQlkyBnQhAgzKUSIUqhpMg4eYyRwFArLbLrTYsuO4iJ5BJN0+CMIQTZVKcp0HctOWX6dkGBunE3jCGSisZZRw6B87MT3m7f5mu/8y0eP79kaXuOT1oaZ1n0rfjyOAl2U8r4KEHLonOUUmffjca5hucXa8ilFqMEqC8vr3DmmDCNKDJ936BVIeXMNHlc2xK1wRjH1fqSvlmwcFqYq35AmZYpCCnAOpH5XvWOFAOr0xV+2uHHHevNmqQ1qe+wO2GUlpLqNSo0bU8MBYyh6R1t37NYHJHDgGtFcqj4RJoCi7YTyRrjcDZidCZFz3p9hTPSLE9R0y+XqCRrT1sYx5EFCmNEtjvFhC0alQtd36PRoIqoT4S4l+zXGHIM5JjYDCOn/ZLWKMo28/2LC77/bMN2AzpLkXQshaIUNgpjmhS4d+eEJ88CBVi0ibfvnXLkCu/5wCvnLcoXWmt5Mni+9u5THj8d8SmSGEg+89HFlq9/5wNef+2Et956hRwzriRK9jKZbgw2CmOvKEVWmWRhSpHP3rvH883IdVSMIbHzCYsUKK2JGO14clG4vCycnRpeeWhodObJs8yji4YhFn799z7gvadbfuFLP8XbbxicMagM2mSwCW1E1koZIIIulkwlP1grjNQyS2lW9uMcCJNJcZJg1EdAPMm1NXXU/I95KJkaUvnFoCKGhDYyETUHSDcySWUfwMwsw5yqekVlyhYkmdX2RspsTu6ttfsALMZZ+ke8vIQlvOOnywP+anqTBiMJaLwJhhKF3zaPUErzD9r3uU7TnqXaukaUSEzLfX2Xr/qvwq7wX+u/jdKaxjVMftoXCeZ9UmwbCpP3LHLiww8f0XUNoJgmzyxnaqqsG3U/mln5INJTzjXkPO4D/BQT4zBJcl3E7iIDktEcJNRIImgqjpf5euyT6dk3KO/3/LKXPOJGIrISlmoGV38m8m2pJlPiI5X3ASYcBJuHbOQys50zxmhyKsLoVzUZUFB8BIpIutUiiFaaafLC0Efuna7tcE1H23XYpFitlqw3A+vNjr5fovSAD4Hnz59ydNRzfnrC668/xOiCn0K1AZHE2+jC+fmSafJsd2JFsPerKxnvhYTXtgbXtKR0k5QO47RPxNu2JaUoMVvOfPTRR2gl+/jF9ZppDGL54iMhRrTS+CnxaLOmlIRzG45PjvAp8OFHjyk5c3Z2Atrx5PFjnFtAgaap1iRZ3pvWQka8vNqR0rt89jNvELx45uWS6LqOME40bcuHH31IrPEHRa7l7AOWYuD03hkpZnIW9nWKEefsC4VVuZSHRdz6H31DfT4s9EoynG+KuPv1K3uV1uomFawFJFXqc7IUqlKIlDKfd0natVK8b56yfZj5qf4LZDTL5Qltu+Do6BhrheRZSiH5CZSo+cj0y+zZK3ujPC9RYtrLuOWUoBarjHW4ttt/7nn/0VpLsaSekxACnRP7G+skwYzpH5PKKPlCuZHt2hfiasz/wjrdn48f3ovn/Zx6XimIfFj9tZtJFH0zOYbas+LnK6RuvtnvGTeF+lqEL+qlLP7Fa58pIomoEykVjI28/QXPtL2P9yN939fiX8E5w7Jv2e4mjNH0pqPrNOv1Zj9hlFLCe0/TtFDEn3KaJsZxx9HRUS2swug96+0W7wPONZSS9sx0W2PJ+VzPhdZ5WkoSakvbtmy3A+v1uk4WaUrR+8mZUK12ct1bQwhcXsY9xuScWC5XlOrJluv+Nv+Nl/fCF6/hTQF0LkYLnr1Y7PwXctxiOLcYfovhtxjO/utbDL/F8FsM/wnB8B9T/D5cB/K1SEUfNurnRvuNR/LL+A1f9TvY7fivNf/C8Zsict3zuXkZv0uqw1IK8XMuZT/5vldqOcDvfIDfL+9Th/uOTKaraqciQzuzmszH4XepDc65Zjrjd6r4rSp+p4rfhVJJbGrf9BonLw2pit9t29E0Hdvdp/HhNY5Wm1v8vsXvHzv8XsTvsbz4v/NeGmAeBz48KobPLekX9+3CTQv/5vzAXFOdz/+hHHfZn2PprR1ix03ccPNaL72Zj/1avfT9HM7fNMplwr2waBK/9PbEe8Mtfv+44/cnboyrCEkpnj75AU/f+Q0un32EM5EHD7/MW//6r2IXPaBZtMfYxQKjFNF02KalTJ4SI9FY0IUSZVpTmQatBhoDWfeyoEaPVwlKwliwzRLTNPgoE7nBR5zraJoVWSvw0GrFE124bx/QuCWhbLkuz9nlHbm8AkkaycoKwzvEQBjF20RbTY6FnDwhQOt65oWljZOJvlRQaLJSYDOqWIo2lOj5aPyIQReOe0Njpfk0hR33mgdM5Yrn/gNOx++zUg+Zwpa4NbQWSobVYsnPfPYznPWGMFoUhZgmUrIULf7nuSQBBtUeXg1KjOQsm9DoA8MwVZCqXg44NBqlIrtt4M69U3bbLXfu3adky0cffchue8W9O+e0R0eM6534iQDTFOmajsa1FURylWs35JLw00BJGaOUTI0aQ0ECJnQhhgRFvFO00QQlQUguoF0jpAQFWskE7G6YsNaB05QqBZGzAI948oiMe4iBohSj92ij6Rc90zSKp3TKksCvrzk/PwelhHXWLyrA6AraibZb0IyeEDzj6GkbS9PI5GdJEa3BTxJgOWcrQGh2u5GusxALRmkaI/48WCuS3KXg/cRuEPadVhBTlMagNVASfopY0xBjYLU6YRxH+Ywx0ncty8URu231I04JYqLRhmhFxkKVQvSRnBJT8OI1ExPWaLQqNFa8HN5//wOur3c0TVt9KmSyAAVWQfSebc7yuZPGOWlOzxP/c6CeU0SpQgjTnjmZUsZW0BsnT5j9RYowT1MIuCorVArsdgNd4+icYZwm2rYDbVEhCEu0kgtiTDS9JuaJxi0Zpmt8TPTWYVpDRnPn7hln56f84PFzfBgxy5ZPvX5Gt12T4kKAG0289qgCYZpwWtM1LaP3Vb4qQ5GAd76+1lq894SYMM6wHXaE4Hn44B7WabrckiKMw4QPa2zn2A5bznPDSd+SUkFbw8nRiiEkxhAwzpJLpHeW7XbN6CcW2nHUL1DOcufkhLPzY47Pj/bMXAA/BiiFxWLB5eUlWolM/DDuGKJI6Ey7AasVVouMuW1bdClybxpN2zUYI4F2MRbXdoRRCCLFdpzcOYNUuHx+QazvdzcO4AOlbWkWbSXnWFCFpBSm6yhGE6eCMQ1N25BzJEwjX3v0Id/5aIMNPTplivIE5bAZsjYUmygJXn/lLotO8dgoHpysePPegocnJ/g8SlPcQPCR97ZXfOuDDRdDQLWZNlnK2LAuAUzmF77yGm+/8gpLDMkEVDKUYugbhzUNOW7RyoFKpCR7Smc0Z0ct52cdr736Gv/g17/F7/sBbVJNUhoKGYcm5MTTi8yTi8jxccunH8Cbr2V+933D08vAh48v+K+e/BN+8+4xv/ILX+HN1+4S4iTS/hhKiRQFxjmC35GzoiBscasNKQnhwhhhz+UUUSVCjsTkKd5DnBO1QNMt0O4QA/5oh/i8wJwgztJqOaaahB96XPKCPNscNOWccFpTqrybc45pHCV40brKsaV9YDwH/cMwVi8zKSH1fU8MiS/ne/zV/DkaKTHXoPQmeTUofiY/RKH47HjKu/qaf7R6IknNlPgFfpEv8TM47ThvTlgue/5c94v8Zvl1/v7w66LM0EaUkv0d4PnlNQVorGG7GTDGikVDTnRdC4jn5zAOe8+keW2GEIBZwkqUQ3bVe6trWmJJ9K1l6RdSQKtJbamFtlqtk6SCsic/zVF42Qf0Nf7QkBXol9i0OWexg6l7+lxAmQPyOaHKufpQ1fdSakF+X9zjprCuQVjRObNPLuZ7RRmKUcQozPWcRZpqHCdRtklpb6NxfHzM6uiY4+NT1h+uebR9yjRl1puRoQ/CHM0Z6wyf+cwbHK862qaQs+do5fj0pz/DZjvw/nsfslz1fPazb3C0XPKbX/s93vvgGQqDNQlIlYwWsLbbs/W7uhc31uJcw/X1NVor7tw5Y73eEmMRIlZR5CzNC7lHB7xRGK1YLRdcr7dCTLINT55esFousMayXl9wvGqYfCLEARDljrZpAfF/op5RYVsXLi/WbNfXLPoWDTRdw2rV07UdJSe+8733+Pa3v4P7skGI33MRtbLJFXz5i5/nt3/3WwyjR6lSLU6o+0NN/l4u4MxM9JeKN1L0OJRwqwUxxZ4MWBCWuhRgDrz26j0jUwPVVzfPz5XlG1Ji103ku442HfG1r32dX/xX/xznd+6hlMFoKbiJ1GNBVWmwfbGAm4JBCIEw+f2eZJQQ31T1QZ0VN3IW7ytgv1ellPf7mEER62v4MGHsN9kO/yVG38goSuFhX73er5dyULDWWu+Ta/XSulXcSLZRqDHUwdpH3nepRbMX5OJuNsCD5J09Tf6wsE65kYJVc4I/v948jYAQ7kJI4mdnMz//Cxf81m92fP97isY1KCXSiDEGhmHgaLVisx25uLxAG4nrj4+PGIahSuXN8mvN/tpAxlrLZrOrk6s3hdS+71mvN0I+NAVnNaVKJ85JeUq5+kc6jFGMw0isybMoN2mUMjhnCWFCKSfegBnC5Ek5stuNFUclkZ6npqypxNFSaJxl/BhW+scdfd/vCwZzIn8z+XDT9P0kCfrLDc1/luPHD8MbvpT+Tf5qee8Ww28x/BbDbzH8FsNvMfwWw3/E8eOG3yHcyNn2wGeBRcr8gMJ/EBO/ngtfd7ZeV7Pfi5bOyT41ef4V4KdINBrOG81yueDPdQ3DbuS/iIl3YkQ1Dm//+eL3s4u/frNuKw7ur2ORc1uYCS4v7gMvrNUD/ObgXtlP+c6Nzb0EO1DxW2lVJeJ/+H67afCINPbcXsupTo8z71Hzvm9QRpFiodTJ+Y/Db60UR8fHHFX8fvThmt0tft/i948hfi/iu6yffFsIZeUA8w735CK9ohcP9dLX85p6AaZvzunHPPewef5xxxzDH/TU+binv4gLh+8bipqvVSaXQucy/97PPuU//1rD15/aW/z+A45/0fj9iRvjv/Wb/w27i3fpXebeZ/8sb/3CX2G1PKEow7B9Tolbcol0/V1K8eSk0NpRykQuEV0SCmFJgSamQimVrUBlqKgWpYVpkTCoYnGuI7sWHQo+BTbpEsMZpRi0XdD1Zzx+8ozVyV1ebx5w1N1jaAMf+I/Y5ZZSMgpLiJ7GLbHKMg7XpDiSE9jSCzOzFEqYGEpBZ0drROY2By9sVCOMGBMDWWuKz5Q04UvENgbXapLStKphYSOdW5GvrxmS4oPyHm+7EzbrCNOCvivEZHjr1de4vzomxGtWrmGnIiZrYhZmRlQRVVIlGwlIgoB2mAYomZg9CoPSDdYFjFEoayhBAo9QJgqBWBLHyyNK0Xz3u98lqsTrr75G3zWsx4GSE0aLX7QUIVrxMmk6UopgNH4Y8UGmv9umJUyBEgvDbmbwNthWZEVijJSYmOJE10pjNsTMbr3G2qZurlqCAqVJiNQxWj77brdjnCZOj49ZX1+TYuTk5ARK4ez0lOcXz+hXPW3XSZBQ2V9NtFxfX3K0OqLkxDiOtE3HdrOj7RtCmCjBi8z1NJJLYawMmmW/wNfG7Xqzwzhh1peU6duGQsEHmXBOMTNstixWC1IsWK3IJeOswjUNfppITbMP3kplaIKwHYdxRF0hgUWRgMhPI7vNIOc+JVJMNM4w1elqozUlyf2gisjoF6NonKVxlq5tGMaBiyeX4nWthVXdOCfMxZKqnLkCDaKcAMpIoSXlhMXK3ymFojJ+mkRePIg0+OxHQZ34d9YQrCEGjzWKyYvEvK1SK9ebNVMIRAU5K44WS653W9rG0rqGddkyTRNWKYyBGDKLVUeKwpJWSrFcdPTHx6RSyLuJtz77Ot999xHrYeDp5Q5fIg8f3Edry/rygpAjR6sVj589wbie3eDZ+R1X60Ea31qjtEFpi9Vmn6AWErvdSG4dxvWEkgipcO9sRSqR2Lesn66xXSuTv2EgxIbdlGj7zNU4svWFo8UKQgZtcH2HMTCuNxwvlhy3SxrdkI0EosUkfFWHgJrI50jwCdD0tmWMlwQ/cr1d78k9jTb03QK0JYyBEHfYruHqeiSGCV1aTBQ5edfLfWecE+l/o1HaCvAohffiBWW1QefCsJvQ1rBc9sScaJuOZddj24bkA8Uacohon/FEfuPDD/nuB1tMMGgVaVUiARSNZiSqjq5vMCbxuVdXfPMHF/zUp4556/iEDYDTdN7x9iv3+ODZmm883fBsMxKVxqApMZJ0ojQKhsJr9475Sz/3eT56/ykxK3bjjtPl8Z59Z8TEm3kgx2oj3iZGcRkG/swX3yTnyC/9/OdQv/tdvvX4CigY1VKUJyWwpeAVOOBiE7i4Ujy4Y/n8q5bX7lq++U4gEnnv6VP+n3/7v+MXf+pL/Oq/8kVSSjhT13qdFMeKN49Gk5WugUapgJ+ggCmZkoNI1idPCAMqJlRO5BwZk0c33SeF6x95zAHCnoXeWMQv/iYBn5NQa0ViqWlcVXj4NOhTKdAqTcagXaxM8G9jqpzhHMABoiiiFeRSg50MGY5Nz9/IX5zf1D6BzbPFUS0cSa5ROM4tv8LP8x9c3OGOOuWZEtm4dzT4YtHKokrhobvLX+Ov8W82/zbfyt/mfzB/h8lHfIq8796jbdw+cJvZjqhC33VkEotFS/CJXKriQWU9931PzlLAyClTbMbahq7rUEoTUqBQmHzi37r8dyrTt6p8ZPkbzAiuBfd0/XxzsKZQey+0lydf9sGg/LDuV+z/vVC4Owj+9hMtBwn5fH3nIgFqDuIFE8QC4+b19ixPnfFKgcowFTbbURjBJVNjX1AF6ywnJyecHB+Rt0owqu3Y7kZijpA1OSmur7aMuw1dZzlaHTEkz/FxZNF1e/brxfMLcoKuX3Bx8R2apufO2QkhTjjXcn5+jlKGzXrCmkhII6pojo8XrI5WDLsdn/nUq7z+2n1mZYbtbsfTZ1f89u98i0Xb8ODuOTkluk5UPra7wPOLC9rOkbuEsY7t4Glc4NWHZ6yOeh4+uEfyE13b0i96fIxcXW/Y7UaapmOaPLvdlgf37tB0mug9x8enuKaDXJgGz+Xzd/no0ftcrLf8ua/8NHyq4de+83vUDJGSExnDvbtnjOOaZ88uJIY+SAwPEwS5n1W9oC89rtRNWrhfb+yLsPPwUkEKCXOscmjxsZ903CeLhVKTPnJGo+p0laj/KFXQynF+5654alXPxKwS282Wo+MjfAjEEEVFpjKjtTGUGIhVfsfVyZF5P1LM0m0y1eGHXSVltszyjmpuHCmZqkj1M1ttySkS4prLy6coU5n39fmo2XtQYtF9Gl0nOSX20Sgta6bcPKGeHzmJc/F8zqjnfmFdjXPL6maNljltvym2U/YijDVvOkjED++BvP/lm6acXDWUgkXn0May206k6FksTgDFOAwMw8jzyw1GG9rW4azlaHWMj4FpEhnOZd/jGpliuri8JpVEThHQ+BjZjWsApmlOrm3djm4moEpOlCKqSHNibq0l5bgv3DZ2xbLvuby+kv0HRdf1DMMOMHTdgpxjZc5HrDU4LfeV1nbve1lKYb3e0raOtm3ImepTKQXW+Z4+TKpfftxayziOP5R4f9xUyB90/Ek1xT/uNf/FYzj8u+UjwN5i+C2G32L4LYbfYji3GH6L4Z/s9f44+G1qs2Rvq2kMrpOGc8o3U96fBL+ttaxy5tVS+CsxcQQolSlBfu8vp8z3cua5MSgV+FyGTsHPhMTbWSarnXOUnFBFo5VBlcxDZ+Bkyf8OzbNnid8Bvl4yPiXed/ZPHb93w30mf1Q9wutazmWPj0C18xT8LhW/51VZXsLv/cI/aLDol/B7fv7H3SszfnNw3/1B+K0rft/sPz8av7fbEXOA33NDzlX8Pj4+Yn2L37f4/WOI39qUqiowKyfVtXJzkg4+6OE+PCMwBwj84nN+9DG/+B+0l9/8fH65P2zn/yGMoaYL9Red1Whl8SGikmexWHGL3z+++P2JG+OnJ4433/rLHJ2+QXv3IT4Hac6mgMqZ1h0T4iBNWmVJacDoHutaSlLEosgktDaAqvLcCVU8JU2QC0VrHA3FX5MXJ+ziBudHMpoSRrKSpqDFMMUtbaMJJPCO1/I5JsEYPX17yqpcMaSIaQpYhcqGXBSKWf4kU4oiThO5eEoIqASbcQJl0EdHmLYn5YARq1u8jzSlYIgEpQhWEfA0xWFKi1aWho5Ft0JbxZhbbDTs9IRPz/BTwRm5QOddx9t378o0YNtA0OIrpBXWNIQq9eKUpqCJM4ACFHBNUxtcs0yMwliNNbJhFVNom4aUS/UMSNil4f2P3kW5zJuf+QybqyseP35EMVq8ymNGaUvrOvquRy9gvb4mxMC03Qgrq22AKulTxNfaWodSGa0LIcgEsSqgisZohbVu7zFglKkN96a+70zbNgxe5ExilMbz9eUlClm8bduynrx4pGlNSpGj0xOuri7ouo6j5RHTOBJTpms7ht1E8DKZHaYB29RpaUQuBAohBijCZvFBJIu1GmmtA2YGoLAFlZFmVgwi65NSomRIORK8R5m64elCypGSEq42xbU2pCCSK+Poa6Ely4S8FmmlafT0/YKYJtCGkERO3teGeE5JmqHOsRsGFGCNYfSJQqZU+fDdNPLhoycU3ch5roBrqq9Qv+zQpVRGtSSOWhlhnGpNIhOj3zOJXCP3RcmlXmNDjIHONeRSfXqMRkM9h/Kq3k/0R8ciBxSyNMZzJnjPom+5GDbkIbJsG6xtyCWRSsY4hTOKVlmebnZMOeOs4fT8jDB6UApjWk57zZc/9Tr/6BvfpEyRR48veXh+RiyRfrXkdLliu1tzh5Gjo2MmH9luRxbthu1uYr0bKxkioI2iX3R7X3fbNCQU18NA1za8++Fj7pwec/f4lEebHbp3hJgJ1zuM1exKYr0beKU9RftAToZpkmBEJdBBgqiToxO0gcdXz7CmwRiL6wzp4orjfMBABVzb8fz6GUttMQgzcLPbsV2PYAyubRjDwHY94oytPiWZrm0pKI7PT4DCdreVyXEHfpxYrFYUrdFWk0Im51CJkdIsN06m/Lumrb6Hch9M44B1DmcczjTEsqNxjiElfuN7j/jeoxHlDahA6noaGgw7vNpRnCHGkXsnR5x1J6wvd5w0mjdPj9ihcamgrMHR8P7za/7Je5dchkyrNF6BzwmtRApfi+kOy1VDSuAVXD1/Rkie1x6+Rq4BqEZhlYKSKUXsJlAGpUElSLuMaQ1LF/krP/cWX3qy5oPLa777+IrnGw3Kk6uPVybRpIxp4K03Ps14MbD2z/nKFxd8770tF2sDaP7hP/kWMY/8G3/+lyVBVQ0FLQzKbCha6JyqaMAcvDdRBVE5kUOAHPF+JKmE0gFSqPdFJOfpEwP7JzluGIGGlEQmaQ5qjDF0Xcc0TXj/FynFAG8T4wmqFlxTNqJW4SzHy6+xG/6L/Z5nramKBc2e9YdWKCOJwp8Jr0qIeoBpcxB5kDPs4+PXy0/zGb6MtRe8bxM/mL25YkJruS+sgWkKe8b8m8ef4av+P2ZsNO9Pz/lb+f/Db7vfkiJEQSRFlQLrQCm6piMGj1IGrTIxJozVUGSv10bTWlOT9K56YU37ZENrxZemL2OC2xfD5//eSKnd/LsJ8G6YtjfMU8F0NRfuahJeq/Dyff0nW8f8WoqX47/DiZaXU4LD93aY2O8ncGqBL+WqsmELJcM0eZGBq8/zIaAGCcRTlILJ2fk5bhJSovcDlERrNcY0nJ8fsdlccXay5NVXXsd7z8XzgWdPr3n2/IqLqwHjWvo+sUzw/PklTdOilaJpG5bLjnGaAFMTarj/4CF3zs+IPhFSZBxHjpYdOUeG3cidO3ewznFyfELjWkDz27/1TUIQtv3l+gKtNcMQcM7gnCKluCcHfvnLn+Mzn7rPsNvy2quv0Bhh0RpjuVpfAwXx3yos+yXLheXhg3MePriP0lLcksuUGccRbRxvvP46b2jHOKz5aLjiH6pv1NhK/LqMKrz6yl12u5nUdXMdc8ri51tuJg4UVF/Nm4U0N2L2N9vBMcv5zp5p86vs5d3qApQpKrW/PyUWSJXYOtek6wRlzQibpuO0O2e5OmK5lEQwxoBWBm3EP09pjVHirYbWFCVeuEqrvRqOmln19T1qRNpuP3GTZ48+Tar76OyTFYL8vYz4BQuZz/H02XPGcRAmPzOb36LE6bMWKWQNlgyLfkkIXppeRSY5xV/O7qcC9uf0hfWnKKrsBxBu5FcPn6HmOkwtjJf9Z86VgDgX4RU/tLjl8QNa/Vyw09Xw9KMP72LdHZar36Jd9izDimEzMPnI5fWaYZTYTWvNNAVK0YQkkoGKxHYXuLc8r8kvWAOubTHWsRsmpknsdOairDGmyq0FjDFoXeq6GmkaV4ubucryKRbLpWCP1djG0TROpkF83E/GyH0o9+N831nbYoxmmiR5niXeZsLnNEXatqPrHLthpJSbKazDZPlmekfO3TxF8c9y/Ek2wv+g4xbDbzH8FsNvMfwWw28xHG4xfD53PykY/knxO1X59Pm66Jn8ryCkTN93nJ2d8OFHjz4xfivgtZz5G1F87NE351Epxe8qxbrAnZj5+ZL5YkystKap0uxaiZpnznNd/4fx++z0iF9G8Uu58Hg38rdy5Lcdf6r4vd19lfAx+L2/Tw7/N98jBfTH4DdF7ckzLzRYXsJvMvs9QRXFDy/xj1n3B4eqTU/zEn7rit+yf9d9y5a6Nrys7/q8Gb/zAX6fn58z3uL3LX7/GOL39cWGFEM9H6WeKv0i5exgKTrnpBdSn5vr782S8C+up8M99odW249chy+/xs3v7rv1n+wohaJuIvbGNTjn8H5Nv1qyTLf4/eOM35+4Mf7mV/9NSokMuzXWF4yFnKw00qyl2IZSQmU7aWIaSBEcrWwuxaCLEK9zjnUVi9d0oUDU6M7TsuDcHVFKYENhESJabSAnlC7gIyoHWDiU0mgGOqNpSyGFgdKcQMrgR4zKWNPKpqONaOujyUVTlEEZRLo7DDRakVSkMRa0I6NQuWBMZVrEiTB5dFOwGVTWbCZPKpE3+jcoriFFaEpPY49QLrBcnPKqTzzjPUb/nBgDznQU7fnM3Tscd5Zt2NCYBpoOEwrZJ4xx+JLQaFJl9+USXrgepkqSg0JrcE5TBgXKVpkFj2sM4zjROsdqcST+y6Zw/84Dnjx5xrjdsex7xuoT7Zz4hLRtR0yJx0+eMfty2/ov+Dq9bCRY0XUSmVxvZkCmIAsxKfEkT5CTeOk46+iMbJ6TH2jbjnHcoZQhR/FAKxSUNmgt08lKKc7Ozthst6w3G+7eOafrFnByyuZ6w3Vc07i2Sna3TNOEqYFaXSF0fSc+LCrjGk1OSfzPd15ksBuN9xFVlDBoSgESCkMqWaY9k8gdifSxMPIVhZKjMMuSSFqkmCkpE0qkbTQxVj/1Usgp77fY7WZLv1gAYkEypUJKI6ujYy6vrmVCt8rIFw3LI5FZN9YKgOjIcrmgbR1TCHzw6DExZ4yClMXPo5S0ZwzpyvCaN86cs0i95yyyz0aa5RSFMxZSQithijWNMMHEs+Jmwnmapr1vzI0niSKmCHVypO0aQgioxQJjCq01jMNEdgKBw+jpWoPSAtR917OLA2NInB53LFY9NkVCycSi0aXwqU/d4xvvv8f2auDxR1dsXhto28yiXeFcT24nBifyMEfLJSpnbFlwvux4tml4drVhGITBZI2WhFpR7xvx79iNEzlOfP173+NnPvcWZfQYrfA5EkKmJMUwBjBweb3huO+wfcOkCyYrTvoeoyGVxDCOHPUd/aIna01r5evVomfVL/abuAQ+hsVyhTaGGCaMawmxMA4B12hKiaQYRQY/A9phNbTdAuUcHz65JMYFnSqsr3aY5gSUxU8e5RzWSGAfc0RRWC57Bh8Y/FibyBCmHSRbZdxG2qYlTglrG/TC8Px64te/+RGPrnbYIoxh2xZR4qDFaVsDNMWRVjw8dpweNXz/3Uvefv1VrFOYrUf3LUvT8/X33uXrH05krzE54U1gNypUtoRQUClhFBytDF0RYkhqFCu1ZHF8H4xCZykoWq0hZbS1FNReDaEYx3ZKRA2t0yTdU1LiM2/cJcXC1995RussU5Wfb3xgKIW2Ufy1X/4zvHX3Hv/VP/gN3nvkubrWfOqVhiYn3r/MNAvLb/7Wd3nwyqv83Je+SPYZGQYXhYJIVUyhiEVCKThlxE88i6xmKkJy8uNE4wy6KCGFFVCpAC9iwB/3OAxKZskdaiIANwWimH6OXH6eGE8EB4uwU1VRWGdYLnqG3YCfPIP7WVoXKen/R6YcBPU37GuRV8rY8qu8OSVKmbgJUiV1nA8JwoVc9enyVd7gS1zZp/zAFoKxWK1JSl47Z/Eri1F8dCTwh9VqyU6ESXiwuMN/aP4XXOc17EYeXv19dPnHlCy2FbkUvuEs3+pbfrN3XDbi8WWtQ2spUGw2W/HBmqY9e9Y5yzDI5/A+8Xr4NE1pJMmYy2gzE/xg/5XiA/vPn/NNkj0zNeff3ydLB3FiPggaD8/x/Jo3QaW8fqqJm5rPLTdeUPvXzHJ/zslXKQfFdQWxZEz1vgsx1uTJoFUhU/BeijqXV9ciIfewvk5OnJ2sWC2XTHGiZDg7O2LZWx4+uMP9u2c8evyE1VHPvQdnXO+uKevMh4+fcfF8zTAEmRqgYK3h+npNTh6lHVeXO1Kc+OpX3+LtNz+LVqKsst6sgWMWiwVd15BCZBgGeiT+XC17zk5WlOS5uJwoxhBrkutDoGucECSJnJ70QGa9vuTpE82bn3sDaxRX15csFguWyxVN0/D6a6/y+uuvYq0okWitmIYBPbNkq0yesQatrRBilCFGT+daVk2H0ZpQJfEUiqbRnJ8f8957j/dZ2r7AomYZXbk35q/nSRSttbC21QFTvf7evMYO8k4Ofyy/Nifgh/fJzb7xQuOlSAE654xRBoUmxMQ0eYZhIqMwRhjFy+VKfBRTRhuxMTEalKryg1HwxFRPKq01xllCipJgV6mw+Wfz4f2E955SCrvdbh/jqIp1kixmUoaPHj2SiQjks2qlq7+vfA4Qj+Hl4ogvfelLPHhwn7/7d3+Ni8sLnLXcuXMP6zIffvhY5OvmwtfH5WLlcI/74WRProM6KLojUwTMl/ZgrXMwjbZf4fN02nz9BN9zKTTGcvn8hMl3fPXnGnyMaC3FkbbrOEGx6AvjOOC9x1rD5BOq7gfOipfl1dUly+WCe3dPxeOMKs9pFMmJ0lTTNAceY/nA46zUZBi8D7StE1WkGGmswTlDSuKnGGLEuobdOJBTJqYJY2pxqN5fUKqsW2C3k7/X90b25jFUCxhphmw2u70353xxPi7hfrmpqNSPfu4nOQ5/70+jwH6L4SOvXP59NL9OzmIBdovhtxh+i+E3P77F8FsMv8XwH08M/2T4LfjSNNL8beqwzXx9uq7h3t1znj17zma9YbXsuH/3Do8ePSWj/2D8tpayHfhLcZan/eHP/kbO/Ec50wDH9fHZWkBrLcM06qZpO3lptDjXVPwurFYrFKC14sGi4z80hussXuD/NEd+p3OsYwY0IUW8n2QvMbJH/HHwu+RD8sq8pm/w8mavK/V2qvfJAX6rit83a1Wux+HSn8krwIsqMYr935BXr/FBuYmOXsbv+c5OFb/1S/hNxe9U8t5/Ph7gN3Vo5BC/c068eovffyT87rsGXS1nbvH7Txe/N0+fYfO8slT9zDffz2vStUvu3n/IcrHgO9/9/l5WfLVaYpjYrDf1dN7gw80a5Y9xzNfm4HV+FOarl//ejD03b8AYw3/z7de4DEv++pu/c7B+b/H7487njwN+f3KP8QA0GrQh+g0pJazp8MHTFI0phmwbsi2UYHC2JybFOG0hF2yzIgeHtYUcI1XZBWN6VCdTsapRLPKS1/QRj8Ij1mXiNGwwwWDaJSmvKUPBqUQ0A7ld0ThHWjQUrVBk8rhmyAWVLK3OmLQg60RJmeg9KWesmafaJ3wcsUV8aK821xwfv4JuF9J8LOLZnUpiXF+SfCa2Hb7tBBS85u3uTU7tXT6IH7IeAw/sOW3RTMnibMNddY/N7pK1GihJY9QCXM9nXvssqtfYrFBWo7UlBWHTlCSNkqwKphSZWibvF2cpRRKvDESF0QWlMiFkpilwct4zTZEQEl3TsGgbVn1PzpG+W3Dx9ALjWu6c38VPI85Bvzqm5MgwTaw3V1xer1HaYWxbgT4Tw0TbOBS5slqE+df3HVCIUSZXnWmwVhiywXtGL0oCbSue5aWIh4w1jt1uoGToeyE6xCQy0iFErLFshwEDdN0SHwNhlxl2I33X47TFWcf6esNqpfYLNddrnKoP3DQNONcyjgMo8ZW2WvwunNbkFJn8RN91hBzRKIxSWKOwWrxEcs7SLCbR2Ibr3VrAPscaRIkXVO86MAXnHClJA9NqA1kSNpGVEF8Qax3TOJFiZAeULKzFadyx6DuGYZTrnTPGNcSYSDkze2itlh1NYxnHiWdXV+QsxRNKpK1+EcJEzNLs9LEGWApjZKNsmoauabm6fk6/bBjHETCUpDBZY+uGGYJHa4ttGlRJlCTT/uJRkZBNUNH1PbvdhpQCfdezWi3YDT0GYXwqozhe9GQfsFbRtI5xz5LVWNPyfAxc7Txow9Gyp2ssw85DUaSwJSlFs2j5yuc+zT/8rW9wPSXe+fAxb79xh5ADrUp01nF8eoaxDc7KhLvSsF3vWHYWq4+ZVonNbocPEyhN07bcv3vGuNsScobS0C4bnl+s+Y1vfZvPv/EGxXui1VjX8exyQ05bVkcLdpPidOEYtwO2b9HasNmtcQb6vmGxaHFJ4WyP14qQAmGIuM7Qhm6/iedc2G6uUSmRksb7AAW0MbR9B1ok5xsnU9PKgNIGZzVNa1gen/Bb33oX0yheu3fMqjmiP1qSYiYGT5omerWkaVuUKhhd/UjIoiYQA3FS5JhQRogZu2EgNomiBnwpDN7w9Xef4EvkpGtIxYLKGOUYY6JkT3ukOUqZk6Oe1+8v6a3BtT0//fk3SAlKDFUCqOXv/N6H/O5HT3FmiVEJ07SoYlBqQrWRt1474q5eooaJj7YJ5xyhFHqE+JBjpiBKEliFtga0ISnwJdXPpzFKPKqKshAlEGu1JRYjSV3SGDyuNZhkCCrx2Yfn/OrPfY6HJ/d48mjDu0+fY01hN0V+93uJL35hie1GPngcUM2Sf/Sbv8Pn3niDs2aBMrIeY8yiVqIUkm9lZJJBbERijqQcyERy9KzaFmvEa15+z6DIUOIfCdx/1PFyoDEHLNYK+9MYQwhn7HZ/sco5VWYhokaSSyb4wo6BtmnwPjAME2rxZyl4jPo7oIX0FkI8kEyTAOVfn37Acb73MW/spS8KnPEKn+ZLXJmn/K7KlFQwuaCNqQm3xlpRstBGSEgpFnxKWBvQWqFVqkVuOLdnuFVDXr7B6vlf5ZXtf4pXT0EpXveevzx5Phon/vPzE7521LFeb8k5CamuJIZhi9aWafKSfFmHtRKgUpNYSXJusFopvQ+UbxIeavHuxWMuvEN5IfAuyMOFIuo69XspoN+87r4QX+a/fXNO55Su1EQlJSFt3JCaOMgr5iBWHTCVEdWWYsmpkBJok/dNlHnyAYQwNU0T1+sNxyfHtJXt27fCVtVKpgycVVxdXfDwwR1s0/Ho0VNi0lxvRmKAdR5BZWIKHB2tyLnQ9y3WHnF5taaUzPmdM87Pz3j29DFt07JY9Hjv2W43aA0xeHJKGGsouwJknGuxxvDpz3wK++EFj59e7IluXWvpmpbd4LFGpK20LlhlKBEeP3nKp954g5Ozc7TWbHYD4ziSc6HrWqwVSTidpAhjrWM/0aQ11olazmxHknLA2Ya33n2N492CZ+1arpE19H1D1wgreJYGnO+LcDBdIkXVm0aK0i+x1A9XVrmR8tt71ZabCaf53pmT+5smy8zqVns5Q2PNzb097yVKJhKtcSyWC/p+iTJSyGnblawHFLpKthmKSP8iSUGOSSSdNWJDUwpaaVprheBUkpDGYiRMk9jDmJnA11TZQTkdXddJcmlmKWmFbRyPHz2pvluz1GphueoYBk/2kePjMz79qT/Pwwd/jbPjn+bq6pISfwbiBV/4wpf54pc+T7f8f/Cf/7/+r6KyjObl46bw9sNb28vF98M9+aZ4Usvwdf3dvJYUYQ5ff7837F9ACLPPntxje33G2R3F8dGCq4tLHtz5LCeLntFHvG+hKMaxJ+UEGL713R8wpUxOkawN1lmss5SiuLq65t7du7IXBIn7Yoj7fWpmrMt1mwjBc3JyjPeBECJaQ0oyrdE0krDLRHNEqUkKSUqLbCBz4VD8B6OrxNkC1t5MTs0TCzeTtrPUn3g8xnHcF5Y+HvvY495cbJKl8yff0P6TOm4xvGHlXqG9+sucjf+XWwy/xfBbDL/F8FsMv8XwnwgM/yT4HaNnu91Wlc4bSXFrLSmJ7d/TZ885Ojpis97y7Nkz7t69L3geokx//gj8HseRJiVW5fC+Li/sNYtcWMzfaFU9ZDOZXJUWdMVvg62qlILfiRRzxW9f8Vt0HADOrcUte94ohb+w3vJfHi94r23JBfHDzZmua+j6hpLSHwu/6wfan1tVfZHlBHADjYcqDfPDM/mt7scv4zd1Pc/fK1m4+9fdT4eXl/ePqgLBzTTw3g8+51ke4oXnq4rfIrct+4fsjZaUigydHeC3qfitEPweb/H7j4Tfp+GIJjsi0y1+/ynj9/eePOXhYeCrhAQU6mBh269Yfepfg1f+HfTdn+ejywt+4we/xkW64Ke++GUefOnz3H///8A3fvPv1tOu+JjT/UPHy43Xl37Iyy/yBzVYf9Rr7bdSBRNHrNMpQXe0rePy8pKTW/z+oXP444Tfn7gx/sE3/imv/NRXxd84iiR4ZsDgcLahZIVVIk1d2oYyGDSJYrIYtgcnJzrMoIqcfN2gMBSzgdKgdY9RkaKeE8zAxq+507wuPkIlQ1bCbEkDMY2gepbLDpcTPkNJ16Sp0PQNTQ6oEgmpXswc0dxM7so0LcKEGSdiDJADKJG3tSrum5BGRxqriShMjgxxg9WGO+1rjGkkhMi5WWC0Y9KF7TBBZWd3Zck6XmJMwbrIYnWXe3cfkuIzSjY46/BZvLnRhZT8nt0keK6I3u/lnkrOhHEkpyyyzrFOLMdC13aUlKs0tpIGqdYMux3b3ZrdNHHSrzheLbhcX9I3Da1xgGI3TMTqFXC8PBZWUJFmUk4R66ywV7JIg6dJppljnL3iNc7YKq0tzcaiNckHtMqkXGhdS0zCbClAKooYgiQORjy3N9stVC/eaRwIpaCtxadIt+iYxolxHLHO0bcdeSme5m0n6gCKwhSm6iV94+WjtCFEL4UZbSgm0XSOYRyJMeK9p2lkE08x1A1GY4wjT7N8kZYmZSfyMMI0lgnyxjWUXEhR2OJSkBJKgypZGH85YWxDKtK019rg+gaNIhZh76jq1S1MP2nkN67Bh0Dwka5rGacJo0Te/fnFFethR8zC/lx2K4wWlmYpWWQzkqcEWPSLGoiJ/wgUfAzVc0fkSkIQySUfIsZacp1wpQhgaa1FMh5FQYvXjHU0jcVHj1KatmllCn4YyLFwcnrEbtrhs6fRQq4ATUoBaxvQhiFm/MbzfLdlyFBK5vT0iDhu8dHT2QXFe1y7JJTE3dMTzk6OeXax5YOLNW+8fo/ztqWoQEwRh4FUKCqgSKgiwN8YTdNblr3GGtiOnlQkINNKoQosbMPRsmGYPJ11fPDRc9767BsYH8gxsJtGove0nSWmQACuh4l2KcSBe8eicLDqJCBTEa5j5OrqmrOjFY1WnJ4fs1iKP8c+GlYw7ga219eszs7rxP5E1zQsjxeyhxVRjNDaoY1IwrXWoa0Cp1n0LZutp3+1x2rD5nKDD4FFt8A1DXH0QmYoCmNdLZpF+qZltx2IJVXWpjScm6aj5CyeMOvMNz74CHRh1XYUFFoHIf2gWOqMcorPnB/Ta8vRyuKzpygDcSSVlkLBasvlbs0/ffd9LkdPbx2WjOscpMzlsOPT9+7zldeO+dzr95gutzx+512ebTaorLC2hwIaQwoJkPWUSyblRCqgc8ZqCfyGcWLVi6XENhdOjJPGvFKo4vnCm/fRjeUffPP7XPtILokvvf0qv/rlTwEw5i0Xl5fE6k2Xiickyzd+P/DWmwprW77/KPH0esc3v/MO/+pXvkBM4m8eNdiioSSyikIQQaOSKKdoVUhK9mw0KFMZxNpgGwmGSlVX+ZM+5mB7VtjYTyCpPwcFUmWUl8Le80oC9sI0eUJMKKNrkpcp/BKpFHT5b5kZs4dMwFy9AG9KvDf/PXhXgFzbV/ksF/o539H5JpksUrieC8JA9VQTOTVjDYXCbpxomwZRwZDAu+RSg0PFs9WSzwz/Bjr9bSZzIZP9MfGqj/z7zy/52sNzFn1PCCILNqs5zP5t01Rl7tUcBKu9nD811j8MnOfvXw4O94x+AK33efv+vB/6IL54iuZnvfDAnvX+EvtSvfTCak7ED96nVqLyUCjMQ2+CQ1Kg11qKkHl+/fpZcymUmBnxKOUopRHhHi+MZWcswzgBBWs1wzhxdLTAupa7d07Zbjdsdlf8/je+x6Mna4Yp0HQNIUysNwNHRz0nJ0dcPL8EJSokbgOrsyWnpyseP3nE2299jpIzzy6uSCnvPZC01thKVCuAcx0hJa7XOymi5sBq0ZALdF2DtYauaUglQlGcHJ8wDFuOj5ecHC1RWhN8ZLlcyntpYbvd4azj4vklSitOjo9xzjEOgxC/lLCyfVWAaduGnCJt06OcghDpuw7nrUhvak0qicY15FgYR//CWpqPlNIBdBzeFHJT/tDKmu+D+jWH90m5qZLtfb9qgWeWLdsn83Pz6ODGzLUA1TgriZNr0Magra17x42PVEGhUiTERFJIoUZrYvXVWiwW+0mamUhotJWpMKPQRshifv+ZhA0vU5tZLHOU+C5aK9dSayGd5ixJ4V4eLifO756yWi353vc/gPJlfuWX/le07S8wDp7r6x1GOf7KX/orGKuYdiMpJDbrrWBnVcqZL8Q8BfBCQY3CCwv7Y9ayemk33E+rzN7B8+tzuH++VLUvgJ49KguvvHIf/APafqJxDq0CD+7fYbvZwTBhncGP8v9xDBQUy+WK7XBJzEWIowWmKeF9IoTCs2fXKC02ObkU+n7BWJtoqsa9KSUhoFqD93Lvdp0jV9uYGDOlROYpAWtvJiJEmcjc7Dcl7qdx5/t3Lg7PUxKl5ikpSR4ie1LaJ/U3xVJ+eF8EjNJolBAiX3rOH3a8zGz/o/zun8TxP1cMH7VCnxzz0N9i+C2G32L4LYbfYvgthv/kYfjH43dG5NUz4zjV9wbGaFK9/3POXKUNu2HCNg5tNFOIYuNIIcb0I/Fb/v3QOzns/tZbfW5aVFnlKoObikgaG23Ite74w/jNAX6XA/yWISKtFX3b8FcHz39bCu8uF3Rdx9W1NFvnlfLHxe+ieAkXX8TvwwnuvP977PF7fxRk/Zb9t4enqT72olT6j8LvOaaYL+iN1zgyWUzdt2egr/hNxW+tkD2Pup+rucl+g98THq0cuczevrf4/Unx+zPPH3IcFmz0cIvff+r4PXHTgC70fUfTOC4uNzxVX+Hn/ux/yHT2K4yDZ7reYXTDXz7A7xgS0zhJXKtfPO9/7L37YxqxfxgWfFzzVqn58cJzXicvPsO5kwl6Dbf4/WOO35+4MX788JwpJZRyZB2wqqMYh228NPtUrpu1qd7SHSmOKLUklx3Bb8WfQluUks2xKIgloK0hBY1FoUhEknj6qEQwCkyD312LD26jIIFtlmStKbHBakNJW4pSFG1QtoECjT4hak8KAV0MSncUI3LVJU2oomlMh7EZZy2kiRgnWqUkKMlhv09pZ2vcXICMStA7R4yFkrbcb+/hyhFKtazHHVfjgAoTnQo46whB0XZLnA3cPTml7RSXF+9DHGnyCdFalBOvh6ISCocC+YxFi2vSwYVurbD+fUmkIlxXayBmAfjGGYoWuZuSIUSRYuhXR9y9c5fdsMU6izYilzylAaW0eNoMI33b07Ut19tN9Ya3WFOlZYqhlETTOMZR/F1MbYjnXIg5oK1c4JyVNIKjyLAIU0maqco0aGsxwDBJAKWNIVT/gkRitVyyXq+JIaBrg9k6y+XlJadnZ1BZKFYrht0OYx2L1ZLgQ1U1ABB2o7GGYRSZ9ByzeGc3DjVNKBRGG5mydyJHr7VCKQdFS4GBhDaa0U/COjNWmuDGVt+RWnwAyIVY5PlKice5qoMERRW0pjIcrTTHnaVQiCFhiq4BqJbmdCsS9iEErLMYLWoEKUe2w8Bm9IwxoVB0jcMYg6JUSf2E0nVqVokkU9cLgSDGQM6FpuspRZFioetbJr9BW4fO4jmeciRnkS1KwePallSBVWuDsQZjFOOwoyhw1smmCHgvPjgYTaMsfhjx3mOcZRcUQ8ykYvAxodAMfpL1pTSWyP07J+hUaLVFNwrT9SL9HgPdquWVuyc8fX7Jeih89HTN/fNzVC5YbaRJmqS5n8JICiOqJKzRwqrUmlJanG2YUqIoxcXTC44WC45XS8YwoXMGEkYpduOW80aTWXC9u6CQ8DHjsLS6YTsM4CAZw/XomSiM2y3L5YoQNKFEOueYhpGoC+VZ5vr6gkXTk3OVya4Bdds1WGdRjaMQ0W1DQqObXjwhm56sNKaxtEZz7+49Ykgi/p9lnSUM6ETMkeWqp28btLZstmu0NXRNS7adAFkMeyaZ1YqSNYki93WBkAu+KB5tdpjW0CmLKtI4zyXTaIfWlkWnOLKOpdP0rkFRaJVDZSFQKQppKPxg9PzGB8+48hq0YsqZxcmCX/z8fVojTeCHZ3dQJpMCRA3Lo2Psh48kCNKgKGAVkMkx1zyiyDotimpbSSYzhYgyhpjEe92cHJGDZ0oBWxxGG778mTs8OOn52vffY7Hq+LnPPiTnkaJaVFa89uo5r310zPuPxI9elRG05gfvaL78psWGwDvPC7///W/zc19+FZ0cqSisbgl+hy4FnwKdbclF45RjPT0HCikEUvCEaWAat+SUSSHgJ09WlZ0X/R8T5n/0sS/yUlAZtM6k9G9Rys/UIFvO4Q1btRZ4i0wbFapfjNJC5kHRdv+aKMCo/0GuhRY5+NmD6DD4PJQouikayX+/zF/gDnf4nnqKRxiMr5XCFbDJGWUtpFyDdymIi5+R3b/KNE37aSpb98VSssgVxYlvHv8sb11kdPhbJHWNQli19xX8Jx8+5z9bLvgNrejalpjynikeQ2T0nqYm/culYE70sSbZev8eJIiYpaIOExm5QduuoZhMGiTIRGuoRCp4uaB+I9MoQes+cz68qjWArWe1vo5MxdxIeql6/efroWpRQdfvcxECodlP5Mg1DDGRkgSvKSWMdft7yIeIUgWzBZMNKcDl5bWQqxC/MJctx0fHrK+3PHLP8OPEMO5wbU9Kib639KuGxWLBs2fye9ZadpstIJ9rs9myWKxQqhBjYZwmvvXtd3HWsBt3tE1H2xiePHlC27ZVMWaH1o4YE5vtjo8+espmO2EN3L1zStd1OCeWMU3bcHq6QCst9hkpQFYsmiVtK/GB94FCpmkaHj54QClwfCyig+In5WnbDowmxSj/P034ceTq+hqnNW0baZYtjc0YnXHOCscHSVSbpiHlwm4YJc+mTgtWj8E5qdHa7O/zl9O0w9vnsGyr1IvynZQDn7OcObxLDxOPOX9/2RNPa2EIG2uEIJiy4H+S85RTxjWOFGW9Zm0wxuJDvJmcKLl6Yum9VBtACkHethayoLwnjVaGECKlKnIordFGioQpi09a3r9fIR9pYL25oOsT1io+/elXeHDvHK3O+Af/01f5m//+/5LOvc6w2YHKaC2xzrDbEdKIxnJ0csR7Hz0mZzAHS50fOmd1Lc7Jer1elBeL5IfSqi8X2Q6f98JFefl46Wfj2PD4/bssnWbZL0Quz2Wur68BxeQD19fXLLslbStr/AfvfsSzZ2tihFw0u91uf69opSgp48OANRZjRb6tVOm8w8bCzfUs5HxzHYUsSlUayvX+lWbpnKwvlwuJ24yi71tinBN7kWrz3ouMZH2NNO9R83km7/fM+e/O+DUn8/Nj8/lKOb2QuM/HXET6gxLtH8WA/1Hf/0kfP0kYbiqGX3KL4bcYfovhtxh+i+Efe6FvMfx/Nhj+cfhNHRwRBQ+13xdkyId6Teahn4g2YLMlrzcopTg5OWa73TFNno/D77lp/sL7oLy4R8x3rZSAKq7om3s8F5RVkKrqoFEVv+MBfqvqhf0yfqeqEuNZNS1//mrLfzFOXLsWoxsuLq44Oz2SZgxyD3xS/B4P8PtGgUGaNzNwzp+9VPxe9FLLHIdU1SXrIJ56ac1ysJYFjOtksHphvc/TyfN+f/g6L7dK9w105uZ92TdUcykyjGRqA525qfUiflvroFQ7lIrfeit7ZorlFr9v8fvHCr8XXeDe3W+QP8gYrTg+OWK17HGu5aP4JV752f89/uR1xj8Ev3e74QWkldNwkI+ow8cOznm5wfTDDOblBit/yOOHj73YIJ//lgZlMFrwW9drc4vfP974/Ykb47pNqM01yfa4ZQ9RoW0GrcgxV5/hOg0bEzFuATBqiWlgvLxGqxa11OhixO/AWhqvIUdUcdC0+DRgk+WIFY/yJdfhmnOu8ONAt2xxdLj2mKQ6So5cPX7EeX8XtexxaBI9RXsMisZ2qAI2DRS9wjlhW6iYyUXAOydDKhrjDK7vSdEQs0IpaX5TCwhKyTRfYxwpBRQKoyypRE76M5FqzxafC9POiycvhUcX19zpHHcXr/HO9TV3FiOfPllyNfw+33n0bU7DiG+v6LufQpcFxXhKvVmpDDOFIvj0wvUYp0zRhUz1HrNa5FSKbEQxevq+x7WWpheJ7BgiZycn7IYt4zjQr1b4aSJRQINVhuAnVssFOWeeXV2ym0YKGQPEJASC7TigjcFqYe7lnIhBzgml1E05CdBXBpJxjpyKTDUrhVLSCC65Tkq2DpTCx8Cy67m4uKBomZZum5ZhGFitVgCkGFHO8uTJE87O76DILBYd6+1a5GSMFc90qymVqZ9SRCtF40S+fPbIQWuM0QTvQSmcayXQcJbJjxjbANC1HdvdBm3YF2U0ugaD4k3tw+yPF6GIj0bbNdLEU9XnPiRySUQ/yYZE3jewdZXrm73nQoiYKrNvreXq+loaZCWRiwgTrbcjIRZiVPKeTMsYRhon09uLriGGSNs2NE2HNbI+i8p03YKQMjlGYX7GSJiAoqpflwTPbedQVZa9bRtSyWRVSKnggxdiSinEGMXHUBVQmskHilJEVbjerGkag7MtWSuSL1xPnqgtFAHOkCJJVx92VXCLjtWqZ+sTsRRK2tC1HdNmhw8iA/Lmq3f5wfuPuRoHPnx2xVvTgI4BY1r6ZUfJMHmP306EnZA/lHW0vSOFxMnxMXo30KTC0XLBdjvUolFEAc7INp9SJITI6d37DM82LBc9U1gLgQHNgK/qCZnjowXractx0xGLojcNUxgpKdK0Dsh0bUvTOu7cucPZaoXRDhgE/DQkq9muL1ken9HpFd//wXO+/p0fULKuZIc5gCqgFefn56gI027L8Upzf+lQ2ZN3iqw17ryjaVr8FFHaYIz8C9Mk571A9InFsqexLSlqYp7IxZNCxLUdHzy9ZpcKtu3JWTETBnyy6KT47P2ObQjcWTnaYhimNTY6Fl1PYxqa4piGLd/64Jrff3wpwWWYiAU6ZxnGNXdPXqXFYE1L8iPRWFays8lkvGlxpkXjMMGQW0m8SBFVFK22LLslzy43WOOYvMcqTWMdTlmccaAdOop9hklZVDpiwscBbQZ+5cufAjSTApMbkYO5vMIPE58+bgi+w7qGcdvjU2Yk872PNF9+paVrNE+fXfPb/+Qb3O9MradqbCvsSdW0PLvcIAPkheaoEb9P4wiTp7GOpFqCznR9R7uQJMlaJ/7vf8JH4abQI4WfUwqvoI1YKJSbJ9bnHQSCUAPkTFGFnGU/9D6wWr7JuHuHor5PzrHuwZI8v1gA/uH3o2rhuOOo/h1hIzqlWOXCG8CvKQn2jLGI0oOwjkLMaJ3QRtVmgCamRImJoDM2JZw15CAJzaNSCKuf4Y3175Hyb9SYWqFi4rUC/9Ew8tQp3neavu0YJ89uGCnlhuG62w2UEvjUpwLfjH+Lt6JikRf0uWf3vQfkqPeJ1MysBQlCL+wzFq9Z/mnzj3n7w5/i7u4hJeYaqJoXAn3Jl0tlZFa/tPp+qSxOmeabr02pqiFzKKFuzrB68ToKd2meUrlJJubnGa0rXkEMgVmaNWexwdlPElKYvPzsqx/9Ir3/21y7K0IoNI2h61uWnROrAJ/46KNnvP/BMwCcVbRdR9O27IaRYbflaLVk3A34acbWjFGa07MjSilstwPX1xuaxvH06QWLVUcMURJAu8CYhu12pJRB5AWR+1MZy/ndO3T9Dus01jSAZrPeoI2mbR0lQ9MJZrns0BqsaWgax3YrXneipiONmrbpyUkKJSlAKRqtHV3bkWxkHAdWi2OsdQRfJa1yYtn2ksSWTOMsORTq8IhgSimEUDPRWrya1wjcJBwzk7fM94T8kD0TfV6z1Hh2/31NUMpcJuKFn80rc546RN1I+c6vK78nVhEie+cYponczl5oke1mRwgT2ioa13F2dk4pZe+L5YPEZVIwu5HsksJBXc9otKbGGlJAyRmRcqxqNtYaaQZpS0qBrCKURI7PeX71bb72tb/Hp974PbruLm3rMNbyvXc+4F//1X+P/+3/5t/Cp4hPEdda8UvLqk48KJTuMfW6fe/774lKy34PlWKmsKXrmZzrcvV/cwHt8LxyeJ7nwjvz9frhYp487aawp+dr+UJzLGMw6OJIITIOiTnuyFlUjLrOkUKDUZJPvPf+U7a7gMKg8EJeLaCUFZ9LPxFCpG1bckrkoMhRGOdt1xKR6xJC2BdhhXnuUIoqs2cQqeZcC3sS38o9IOTPaRpJSTzMjo+PefLkScUORwwB7z0K8SOc7+8c6/2o9if8xbVR6iRtlq/LC+fwhf+8eH7/gIT6n/dk+I86fpIw/AT4dIHX+fHD8BACi0Xim6/eYHj+6B5cHcn9covhtxh+i+G3GH6L4bcY/id4vIzf8yF705a0b9LNzfGyl1+mQIqZnCFFT4oOazWb7TV3zs959METYpkb6Df4LcMzaX+P3ryZes8enJf9/S6bzB6LcpnxWxQg53v4D8fviLOWHISQN3rPUmkejoFhzLyvDQrLZj2wPFrSNZZxHMg5/uH4HZc84PcJ9vOU0pPSgu8zEMliZ3mA3woZWHL2GT/707/J9Ro+/PCn2e4e4it+G2XqFnBzTxZVqoeuKN6oMq/x2gA/wG9ygTpcMtfy95SDeg7naKoUKBW/Zzzn4N6Y8RuqimuWGmDO1Tu+FPnbFEY/Y4ncKymWW/y+xe9/4fhtpqeMF9/kN/7p/8RPL97HHi+kb6E0F5fXfPYLf5Y3f/H/yBQ/GX6vL6/3a+LFbfzmzB2copf2+nktHm5/PxoL/qg4UUrh2i/4exdv0BAZBg9Fhg/jLX7/WOP3J660+90azQ7aU+zUEPyATceo1onMdfSIj9lQJ8hdXbSj+MXGS/I2E5uHWF1wyuGL5yI+YYwTx/qMU3UqjXWjUOE5Qx4I0xZfjlGqoRQFwdL0x2irmeKW7dVjzvQJ+qyjhERIW7TXRDtCfsyuPEKVpXh7xzukuMJkBSmTm0rsRstUoO2xRhPJeJ9E2ldJcSHlQi7iPR1zBqUrqBmZxE07VErENLGLHqfB6IZsW957ds1nj16layay2TCOO977yPJ0c8bon/Fefo97R9c8aD9FY872m2jJleWGFgn4G3IFMWamEAgxY0wjk7tasVwsKiAryJqYM1fXl2w3Gx7cP4eSmPxI07YYo8VfersGY9CqiHS598RS2AwDsTaUZyZQSBlbfQlirJLqCawW3xpjbJ22z/vEwlpHjB6lxQe4FFlwSmsoQqhYLhcilRMVfvQ0jcV1tQlbQcRYh3WOYbemMQ0hJba7LXfvnLNdX2OtRSlhOmktC7TkJOcxF2IIMmUwTpRiaPsGnyJt05JjZddQ8FEYEU2VfbfGMvkdpm7gxiRyCihtyMmQSyFOInckYCE7sTDWJoyBthXgUUp8IUQOqdC00ojPCJPGVpaVMND0fkefAdFYYXHZRvzXfYz4GEkl45QVCXdt0EVhlSH7DNritJPrkBJKa1ExiEJSSFGYQLtxROkGpSBMHjUzVusGO00T7apjmnydgJepCOtcLapkjBXPIZQmVaUC4xy7YUDpJSnDMAU2YyArMBSRhE+KUowUZlQjTbBFjyuJ58+ey4Su0uzYiU1AyLiSOV4seOPVc55/810eP7vku+895+3XzsBkubbtggbF8uiEpnHY1tIslqRUuLq4xBlYLgyubVg0LaenC97/4DEhRUKMVeZfZEVCDDinOD054vlmh9USlKI0Mcs0hw+J7fXA8Z07+BS42g14nzhZLbDaMPqAqcoDprWkkLjaDnsyBCi0WtE0kVI8pm1YtA33z5e8uTtBlUhRms5ZFl1TgwLFdjewXKw4Xj7gcnNF2zghQeSIMw1ETQBKsbJmY+D5+hI/7WQKRek9kywV8acyqhCTxjaWXcpc7QrauKoWkFDG4aNnmibefOMur562XIfI2UlH2mq0T4SkyUDnNE92a77x7hMeX0ZapaVhf+TojWY3Tfg4MXjHom+IWqNbS5sKo4mUCVRniTHw7ne+i8sBkwvHy7tcP3/G2l5htMWPkGLAaZEcU0ZzenLMYtGSYqLThscfPeU1EpswQEgUrZl2O0xxaAUbu8Z1DdGLOsVgFCZA3xneuHfEk+sdax85Ol3w/Q8vKSZzvc38w28Zfv4rmlAM33p2xS/99b/EcDGStRVCiCpo1/HB7/8ux3eX2KZFW0vJWeROM+LDNI5oqyHLJJWMM9RizZ/A8XLSO3/t3BnG/k2IrxFiqrncTdGI8mLwuWe6KqrUviQiOUHwb4D+jyn5/4TW27oPSqbxTfeMN+MJXXkx/Dictnjh8SJs0WWBu6WQanKeYqJYaKuMXNs2QpJQsk/HnPc2HTElrLWVwCfFZlc9cp5qwyvuz7PaPWGtfrB/BzkXXhk9/3Fp+E/ayOnZgs1uV8lekjQMwwDAL/1y4Od/3hNTAvX/RqHoyinTP3kLJllXr/rP8t7feRutFVEl/sfm7/Kt+Pu0WdEWyzeOvsXb5Sv88vrPCzN/TqbUjfTWzBKXALROntXgfvb32fNgq3zRXm715SLI/Ei5YaynnF943n5iZn8vzAnYzZFn/7OaROVcCCHhfcBZu7cYiTFIPNM19edZ9s1cmwi9XEcpAAhRqWlaBmdqoO+wtuHyao1xhugz11dbQvAYU/jMZ1/lU59+lWmMOKM5Wi1pu4bdbmBzvUblQNt2tK5hsVwwTiOrRYM1DcM4gIIQNI3T/P/Z+9NY29L0vg/7vdMa9nCGe86d6tbQVdXV80CyKc4UmxQ1mbYixUoYS4KQIDaSOIgDI0A+BvmQfAsQJJa+GAYcOYJsOEpsWJIFIbJEmoooNudmd7OH6qrqqrp1x3PvOWcPa3infHjW2nufW7eriy0O1eTZQNU9wz5rr/VO/2f4P//n/PSMMKuIqeTocELbtrjCkpQQ2fb2hPVaVfXQfiQwn+0NiQbB7hAjtjDSB0obJtO5OHkMPmZWZCxKiz1VFpqSErW+OEPNuh2qN2Xdj7J/siY0Qm8f5WhAKhX1Jsg6Vg+St1JYm7nL2x2nx/neZGHURt5P/jy/yxERIqLZ3KvIdVUcHBzRLlv0vsZVBTlHysLx8OF9vO+5enQsfcycGcYqcH5+Tl3XlEW5uf+LgWRZg1pL9QIAxuCG3mYpBhRD372UMNoQfc/rb3yDN998jao859azkc9//jOEvODr3/gG9++fslp1Qv7T+6zaJVoV4nQOLGpr7SbZJKzpzJ0793j8+BRrRO6S3XEdHUIkuL3ZS+P8ILEykWtW2++f4uCNlWmbIPv4GZuYy+DcDxmvzfuGgE4G2r6HRqp26mpK7zsW52v6kJnPp2gUr33tm5wtFrz44i2++c17LM/PyRHKyqKUEpKtszx6dErbdhgjznQaQCEM1SjjGh0fRWzx8bxkY9c659A6Ega7O0Y/BFTGM1rOIamMkcrmkTUukm5hc3ZdGKunvMazzVqLs5amaS4Est413k/5fnftv5cz/jRZvT+I1/cihisU1yUasgmwf5Aw/Ed+1HPzRuTWc2GD4frVl8n3jzf79hLDLzH8EsMvMVzm5BLDLzH8u3t9O/wuCstkMiEET9N0pKwGtcqtJHoazgD52+H5Upb2J1qTsiL6SN92zPdmnJ6do5S+gN9aS0s4lTbL+V0JIrXz9djubzt28vMYEtnGHfwu6bpuB78jwffkBCGGYW2wg99yBhut+TyK51cr/k5dSwwyZ/rek2Jib2+PxWLx3vjd/zg3/U1u+edkVBUkXfMb9Axi9HT5WX6Bt6WyVmmUvofi/8ODB4qytOzNXyXnT9I/Bb/HAUlRKnn1Dn6z2bNqJwEu+M0Ofu/aRXmcP7ZtTYDNvtlZLLsp2M3f5p3r5G+D3/cfPINSUwrbXeL3JX7/keP3vnnMx657/mzVk69f4+TRI1ardiO5r3Rm2bx//NaLJdWo7rCZj6fhwcWfbSvAd86/98CE95t8vVCNrhiqqKH1PS435Ax1WXNyid8faPx+34nx9f03mM5eQqs1uVnSxEiRlkzKQyLSU4Sc6bo1IfTgagolh42hJKYl/UpxZXYLW2Y0iXN/ylv5bdY5MU+PuOE9V91NVOHo2xYbA36QTnE607dnxL7Hd+c49lBorCnJwWBdTe9X2O6MVX5M374FsyssacmcUXKOTRniPnP94+iyIseINZmoh4NRF/i2IakWpUQaWCklB2gCyCIjoYSBE0LAGUdWBh/C4HT2dE3DwncUUVMby4OUePthy9RNmZUrFt0py14xmczp/YrQabw5oVUGVx0AihADmYw2hhAGx3pnc2ttkETiAIoD+9s6B8qQ0FhdEGKgW6+x1oBWnJ+esr8/Z/9gj7btiEOfW+scOSQmkxkxJ/q2FXk1iZiwblpK54bDS0nVds543+F9jyJjnJIDSuUhST32exEjZGSzbQ+MjHN6GNuAJmKcpmukZ4d1jvPzc8qiJCvFummoFcQMVVlwUJYsFktyzmJ0GYcxVg4NrUlJkvpaaYLvqScVfd8NxtjY486QtABt27ZM53NU3kq8XEN9AAEAAElEQVQFtl3DfDohEVC6oO0aJsN1jDGkCNYo2j7AIBOvtSF2HgZplaIo0EoTs8hlG2NJURhUoyyQHvp4hGFuQZFTlHiWUgPTx5EVqAHEls2aru83h5WAIpikRRa+DxR1BVkSbj72aCwaRVkU2BjovCdlD2SRMowBrS2kwcDKYrQKcGeWqxXaDH1CEKBVSoCpKEtZrzFSGi0y8sN7Q4xEYNF29D6TlSHrJMaGFiM45IFLqS1djLxwdMjVG8f0PuOMQeWxoiLRdx3OWXzfcXQw5XBSsuwTr755j2tX5hwfOLreM7VC1JjrK8Q4xTqDsqIaMJ1OMWRoPfNZiUKS75NpwelZQ1VPhnnLrHpRW6iqkoDCGctsWrNqPRGDUorW91in6VNktV6wXzn2Jpa6LDhvFpTFFJOgT56yNNRFIZI1ZssEBcjWo3XGYuXMUpn9vX2OrxwN1fiQfEtdOQpj0cpyuLePcZocM5NZTVk6imlJaMWRCuuWdVxyvlizXK5QgFEZZy3OOqxVJCVqD0VV4IwdziFwRvPgnUcsYsaagMaQCaio2XeOw6Njnrt+gI4t1+dTclS4qSIXB6z6lgrNnbM1v/v2CY9jwhQOnT0qOMpp4sN7jr7f4wv3H7DGcs0o0nqNLR1KGWLrUTGDVWQDOmeaZsnLH36Z7DVd0xOmiT626BDIKpGzHvrqZGJYEqOlmNXYNvBosWTvsx/BtWtyinKGHh1RmpKmX2FswpCxqkDbgkBER7CVJgTD+ht3+JEf+ST9yRmVLvm1V18DW4ON/M434LOf1rz92l3uvHObvXIqyW1fEslo20HoiL1IHqWBsBNDlIBoHoPTYpRYZ8EYclYY474bjL/wEkWCUZJt14AryfmAEG6RB0dpY+SPa1O88O21hl8oGPp5DUz2KCoNVVWBmtF3W0fWGMM38kMa1/PX+0/thm95WtB39/WkHZRSgiSGZ/AebSxKIXJtSgy9lPLAlh2fl4HlrrdSaCrT2htY/Xly/jvDhw0se5X5aO/5t1vDf/XwIaAGg18zqSfkFPn+z53z6U83hFHUZXCcTjiBHzhhZKg/8l/krWqfX/xF0AaOP7nm3/zUQ4rCUVVCbgv+V3j4xmss/rsf4pX+o6SQIbjhvkfjXw9TI5OzHZetuzzWtjAwiEc/a+NYi4ezM/YywONbditXZF1mwR7G/lZxIMOrnSsI/o/3mmKido7zlIjJY7NlUpekFFks1/R9IA7YLThS4UOgnk3YP7hG30tfsMJJe5WTk1PaPgiz+8EpyQdmsynHx3tcvXrAzWeuEn2P1dB1DTH2mIVIhZWTCdZJOwfnHGVZMqlrtDY0bcu6bUgpU1YV89mM5fkCsiZnRddHHj0+44UXbjGdzAfbK1PX0udutVqzN9/DlSXWOVF/8B3r01NcZSnKCUVhWa8bprOKnBNllSFpbFFIQMmVKJMo+2Jj8GutKIqC88WKmMdgydYpGPfuKJM4pldGPFbYCwG0cT7Ju87HVjJxE6DZ7LenrQdNHgIEm0DRIPlmhh5VxliuHB0TzyKz2Yxm3eFcia1qvvg7X2TdrHn+hZfJCczQK7AsCq5cOaIqq81ny5odGOlINaMx5kIASexWcQjNsP+dMWSl0Tnh3JQPv/RRPvT8SxSuENlFlWj6igcPfl3IgVrO26y+QuYHh3Y4mw0zzIXeOOaJQOJfkPMpanREgVE6OQ/jNcQzx3iV+A45D4Tq8RfDs8SM0sM5Om7lndeT8oubV96Z0yf+qCilrY4QKg0xyvrOXqpY18uWdbOmLByTaUk5KSmspaq1qGEpUQDqupblcoExlsmkHva5BIKck9/7QS1ofImSVMIYhfd+87MxSTApKzKwWC1JAxF0JLZKH01P3wcePnxIjLLmvffiTzwxNmO1w9Nk2Had55gixAHSdub2/QY93g+D/Q/j9YeN4UpN6fvF7xnDNebCuk3AKZnjnWf5QGH4ZxrUTv455UR+6evw0tcvMfwSwy8x/BLDLzH8EsP/tV/fHr9l70k1sMTMNuty+9eMC2tcM5trKklgxxjpk2KxWHJwcEBZVbRtewG/c4bCGqIP0nJueOWdT9ne77d5DnbxOxN8QBvzFPwWxc6UdiSgh3WVkx/OJk1ROJRukV7HEg9t2h5FYjabUpQlD5+G3wG+//QH+fT6s2yLB/LweSd8PyMGakI+oVTwzxLsu3/MX9N/jmb9lyjeGfFb42PmjfIev2h/gab9i/i4NxSVbPFb7+D3ppp++NyL5EDFqO4y2mEbctoOfl/42TC4u/iNGmWzQYokGPbczvuG/+dB5zqmxNn5DYwpSKm5xO9L/P7A4Pfy2ROq9Eus3/q/DcRPIYdJXsZ9R/zO2XPc/H9ZpMeMA6TUdjwZ7OaNuzPusw1BYfO/zS/Hsf5ukWEXU0Zyw6jMOuJ3ypmyrrCX+P2Bxu/3L6V+MGOxeAuXjslmH11Bv3hIVdegRLoh+ITVDrTIuxhn8CQiPWZySCLi4xk5TDhNp5zkh5hUMU2BU+7z2C9xueLAXMOjcaomq076KqfI+eIu3kNoziQJWsyZ7F8jxoRWNZiG03CXr5x9ibMw5aN8nK5csmRJXd2i6Fpc/xbTeo1zc6KywyFiZKIMhOjJSaTVlXIkImgBMI1IlIuxnFEktM7EHEWCO0eW580gKQDv3L+HTY6pVpydL7h1dcKzB4fMKsPd0zMyhrdzwOgEsaDPJ4S4QFMQBrlkMyQJ844BnnOm7zu8l4pc3wkTRCnNuu2Y7k3pUxp6AHgUMJ/uce/+I64eHjKfzfG+JUVP5Qp0ccCi86A0xkLvO/m8nHHaEqJnMp1ijYEUhaGXE85IYt4YwyifEEMg+EThnPQA8WE4zEQuL0lTO5GAyRGVwTiDdcJSWTedyKxoTbNcoTNYbaAoMHboQh8Toe+oqwnkhO88hRWwj17YL0rljfGglKHvO0ksR6ly7/uGrm1xZQkZSjckr0NAK0MAlHaQDX0fKKwFJdIrIyCO8s7aKKxTdH2gMA5JbkliXimIMZM0DG2D6LoerWAymbBcNSLfUld0wVPZAlBYYzc96FLKw3Moet+TESmapukJQ29unWV9GqAu3bBOwDiNMpmQA4USA7lwJcF3tF2Hc46ktBx0SgJZOQ0kDJsxWebNaIHvlD06FUTvsc7hvaeqazrvZX60pnSOruvQRkmgaZDzWDYt/cBsjWRCEkknn8CTCSqDSqS+A225frQnhrwqsNoQFMTsUSpT1iXLVUvMUgX8o598hS/87uucNQ3fevsRlTnGaAmeoRV1WRJDKc6GVVQTR+zEKZD1rKmLKW3fcfXwgL7z5BQpnaJwc5q+Zz6dYrWcEWVd4cqStj8lJOh9z3xeA1CakivllL7vmZUVpXEcHEw5a9eUdYlFUVhF7FvWylK0xcVgpRKnqcuZtmmYlYqqslgjrFsVFWAkEIowhI0WIkWhHWcByklFtA5dRfq2wTctXfCknKgnNQSRis/SQp2cA5PZlGJagQGnLSlYbJWoiorlG4/plPQcV0lJn7eceeZownNX5izXayYTkYfPWaFDQNczZqHi9sk5v/bGGcFYFBGVrZyrJqJ7xXw24XB2wFIV3HvjTYIOTK8cMJvu4arEdDbl/EFPoRy6qJjtHxKzpT68Sn/eUc33eP7DL9E1DUoHZnM4X79B0poQO2KM+KG/UF1VvPb2Xc5TZn92hE8evEcl8EmIDVYZUla0SaFToDSOXiV0LHEq8Zd+4uNoVRKe3edoPucjzx3xjXuPOfOZ+/fe4Xe+bPnJHzhEhRWKGm0UTfeIFDzl5Iiy0miTSD5ickKnhEZaJyijpRWFcags+1KJDMO/ljGwy7Abz6+d35LSz4N+GZVH5iFswjR5iz1jgFV+u9sTa7huTGStIIjcF+p/Qcq/wWTyT+i6DqVE9uvceLjQMv1J939rNNUZDhXMxvfkLAxsJQ5yO7TGUCENgYVIzuFCQB22UnRqMJrDpr9O5rWq4mPrGTlcrNzIGVSO/GzT805K/MqkHvBFsVov+Kk/nfjEp5ohPibG/cYu39yufNG6Nc//yJq/+SNQOOmLFoKc90p5lPJobVA3HpB/6B+R8z8kvn0D//f+B6RH+4xM0N1AxcWv1eaDR5nUYbg2/47OQ978Qu55EFgR3E95aP8xrpmtM5HzyC7f3kAexne7vpCAvlL8O/Gv8Xeu/D9wJexNpyglLQLu3HlIzNt2IVVVDRJRhhs3r5NS5O2334EsRLPFYkXvIzEiyRoUWide+NBNrl3doyoL2qZjsVijCFR1xZXDw4HtKk5btTdnUtWQFWU5oWlbTs9Osc5w584JTdszm8+pJ/ss1i0pNcz8lHfunDCfTcgIXhVFweuvv8bR0RGTyRSAyWSKTwFjNMrAyb0Tuq7l8Mo+dbU/9M8VVn5VTbh79x5WW/YnIgWo0LhCU+kShoBsTBmlDYuzxSbJddGZYHC+CzJhINflrYM3sNY3e3RcPJs53SZTNrM8BOI22hRDUmWsVsl5J3Sbt0E++UxxTuu6Zj6fc3Z2Ttu2gBbnG/jRH/9JtNb0PlAUlQTxGiHOVGWF0tIqBG22AcThRChKu1ln4zjEGEUVKGeUNdiiECZ7FtvP+x7jHGhRKOmG99aTDzOpjzk7vyNs6ZBpW09pRflIlJokSKm12QQ+Uo5Y9xrny3+CUomxmGwcOzZBsLxx/iSUki9gfM7Cut8NhOV3bW45B8czRe2eLzsBsd0zZ0zgkcQGL4uakAPaJbyPHBzssTgv2Nvb49lbz9P2axbLBc88c4O7dx/z1a+/zqc/9VGm9Vu8+sY7TEqL0wXWlazWLd4HqrrG+4i1ojLjvabpeqa13ew354T0F2NADef0KOnmjKVtW+rJZCOFOM7reEZXVUnbdps1LiRaUTwa3wOjVNy7+2U+7bXbL4+0DTjuDPdTK/6efI1se6mgeff7/6Cc9j8qDFfqb6LU32EyOf09YfgNXqFkAvgNhpvNWy8xfDuvF+f4EsMvMfwSwy8x/BLD3/36Xsbw74Tfo2qfqDN6xkTb+LeDai1j7988YOioaiCxxkSKkI2mbT3rpqEoxl7L5QX87o3hv0iJfzMk9jaf9PTXk8ta9u/Q+jFF2lYqwNXQu1zwe5fUJld/N37n4Tjzm6rQECN2eKbYeYxWLBZrZrMpKfWbM0Upxeqs4afiT/OJ1adlGWi1M25bAB/H2uqOH0XxY1ZT2L+EygrvXpDx77ZJzhtW80P5BbKDt3TiP/eek7S1K3bX3CbpJhOFHvb7Ln5vBjcjxS3jj4YzNw34vTkjkpBsxgTbRmR/wO+4g99qwO88rivGcLycI4V7gap64xK/L/H7g4Pfe/uU6WPo6gpx/RANm57o7we/J+vfhrv/FWsVefpRvbPHNkO8PUvHHTtOxfjv7/epb63Z4LcpJHG8vz/n0eISvz/I+P2+E+Ozvec5W/wai7sPKc0BpjygDx3kSAweFQoSkFMcGGiZmDK6zOjWcXzt++n7M7rg8SlwnpYEnVBoYZnEko6OVT6jSnustSRurIXoO1LoIUYqI70g+m5BChG0IxlDDImgA99cZ+6d3GDxKBMf3uaVl0smKFq95PXFW+jGcKWwTIIiG4WKI6s+kkIke08Mgb5pKQ6OSSoOJ9Sgiz9IaJAzRimMMnKQKEfKiS4nlFHMiopT62jWPVnDrRs3ObpS8Pr6lCk1Lx8+w6PujG+ECt+fcbBXEpWnj2eU6lh6oTAa5PDk7o/eEwND9Wai6z3GGA729umTJaQAiERvXRS06zUxJY6PjiElnNXowlIVJWEtFd9dCFglDK2cEHmeQa4mkgg+kIOHofe0LO8s96oVPgS00egsvVt0DGiVpA9BFqB3haUsKvyQWEVJxaRWGmdKFH7ouZ3QxqEKLf3QJwLEhbEUe/ssFueUNjCpKtarlfR8jtIb2hUiIU1GEr8RyIo4MOQVcmikmAZ5HzNIqStCjMLsGWSMjXV0vciDKBPIKKmyJ29k4VNQcnCPz6IVOQRsWUpPeyOyzjEmSEqk2FOi73vIoJVBDZX2WSdiSEwG6XVbSNI0ZzGe5BAcPjdK3/KcZN8VrmKszNdDT/Dei0y6MobgOyEmOIcPHq1FFijGhLHCTA6hR2X5nJg9Vot6gbEGiBhrCUMlSYiRsipIMYhhpkTyJKaENpa+bcgp0bQNzhZ0fZQkvBJw11hUHvseWXIQ2XxthEFWlBZjHTFrImKQ6qzQaFKS5K2KUJcVpMQrz13nt199k7fuPMAS+PiLN2nWK8rJDMi4ooYskbwcMuVkSmg7Dq5cA5VJylHWFu0brh1d4cHDxxhnyNlRGMV8UklLhehJMbBaN8wmE2a2pG3XOGMoXYFyFlcYYgalI+t1S6pnKBLrxYK9uiCRiD4QaEnGb5lWStZSHhQNYuhptKaqa3LvB7UGj9HQt0ucK0X2RoscfzGZYJueQmsIkdgm+qUnJ1lLWiEyWylI5bbSqCR9p1zpKKoCDPgmokMm6UDbRu6cCFtN5URMgUI7JrVhNnEonTjYm+BMha00KQR0UUPvud/BL73zCD+cZUUq0DqRksZqaFJgieXmtODDz+xx9+5DkkosHp/QnJ1R1IZ2b49CWWK7QqdMEz2HkxlRa2wp5ICQDYtli9UtGbcJZiilyUqqn2KIWOMgJM7OG64cT4hJ8KdNHUYpdBKVAzWU6AhXIxGSxw69soLPoFqsKainmmvPPsvNm9coqoJ/+a80X3vzHg8elnzkGUuXO1QSdrF1Dq2lIlxbTUZhbTmcdQadAKXJSg39Ii0oQ1SamBLWfPdS6ruGwu7X1hg5rzCQxeF+t3W468SrCz/fGDEbozKjk3QvC1H6jo0s7l3Gus6j5M93NmBuZriZtobu6PfKHA/OClLhlVIiDKXbIjknwQKlRZJKDQmALbNR3hNi4IEzHPnt82yfN7PXe/56SvxWVdFmYUz+6I81fOJTo0HJhevBkwExOWv1pseZOAGjcTkGGVAS3dZWkWLGvXAX8/P/hO4bN4j/9CfkfsaAWuYpc7V1psd7F5nGkWkrDs2Wn5w318yKrWxXRvbA7jVHGzaPxLa8CajDjr83jH2MkUlVEX1gtl+jVKbvWiG2xZHtLmS6tm1xBo6PrnJ0dMidO3fQyrJuWuq6JJFomwalDc3ac+XKHjEogu9p24aTk4esVz03bj7LbFpwdOWInCLee+q6pmlbilLkYNumY908Yt223L0ncprOljTrFet1w8nDE1LOVEXB+fmS9bolXz/i7PQx+3t7KAXPPf8cXdfQ+4aDw/lAwPH0XR6eLXCwP6dr1+SYqaqanLzIX6nMjWtHeB+IoaGnJ3mFtRNhfKeMsoPTGQLni9XQtmR0RmXORoZvXTqWKw+aQSknQlYbOzVv5k/W3rY/Yd5ZKztLafwbLZUJF/bpzpxvArjj/A9BqaIoAKiqkrIs8f1O/9oosoKFLWXfBT8EhdTQqkf2rtEXr727dhlY6xtpSRjUiOQhRhUelYGhxYkyBjVUGTir8d2z3HnnUxTVPcpSk6JnsTjlcO6IsQEl5FOlFEZZ6cmbwYcWG9bcv/9gx5vOF5NoKW8qLFLO26D3dqRkj+zsHT2o8mzet/Xdt+cI268vzFiWn2/IROMt5cxyuaJZtRR9w60QMAa++eprXD26gdKZ/b0DHj8+58033+Le3RNuXr/KbFqiVWQ2qTk6nONjpCynvPHGWxTWUDpN9FCVJcvlUp4jS5JyrDIYAzhS2bGVdgtBbO911+GTnIfjWHjvB3k3eb/W6sI8j+Ok1DbwJGtcsHFzpgB6sLnHtTtWaI3fjyfjOITW6E2w6ElM2vzNzj54cu3/Ybz+6DB8Avwo8I9/Txh+h69xi48xpXgXhr+DrAd9ieGXGH6J4R9IDHePDXtns0sMv8TwSwz/fXh9J/x2Tgq1+t5v1DXHMwK2Mra7z5OGuNt23WUU22RR13uJLeh3++AAbxnDN2Pi+3eG610jslmi+cK9b5UWtt+n4YwIQzvKNKyZOLRwVDlt5MbHZLlcU+KqEt+KQJQzSiWyNqQM61WLGaog84jfzY/yifZT27vbHHHjHA9H4zD3Uo2uBztCCALa6AvPM1wAowxJJT7kLD9vNH8//ir3u0+yi9/qCfwex04rRcx5s9flfLyI33pzDgxp7xHGx7N82D/jY11IIj0FvxUMqj/y/hG/g/4LBP+3LvH7Txh+wwfbB1+EV2DvE6jmvx/GMtH1olT8nfC7SoHVaiW7Vr2bZARC1BlJCu96hu0wb/590pd52rNf/F72zu7rAmkCObNH/A7VmnQtQ46X+P0Bx+/3nRg3xRX2b36S5N/CuEAKDUpVWDsh5cc061NU4ei6MwwTsImkM755jO73CNNENhU2eM7iKefxBMopGLA+UakZTX7E/XSfrvcE3WFQECEpIPQY6wixpc8W1/WUtcNhKVRFzgofFE1XoeKEagqPV2tWbUkxyyT/gO78ASHOCSSyKVExEBLYDJAga6qi5uHjN1Gqoji6SpcyKSq0MlItPByKOSeqQhIXWmuykv7U3kuSyaTI/rSm6RrqyR7PH9+kVQt80fKt9hEfrz6JqSwxaO6cF1yrGua+Y+XeoeRYJKkT5NCTor8wF5IUFZaG0SLpFgdZlUldE5rEZDrFDwGGalJzfnrK8fEhOXoiUFdTms7Th566KuhikqRfkoTrpJqwThBoAemREHuPihGlRjkZJdWNSWTkCyeVym2zRivL2PfBupIUE33fMJ3OBjMhgTJIwkgqz8mKEARoet/Tdi1lORmYLxrfedZhxf7hAc4VxJSZTmv6vqVpW+mh7YMciFkCCSEE6bk9JIqLomTdrHC2HqqPhfWrrcFYy+r0DKsNGpEfzznhfY8zIlkRe49yWggRKEKO6GjlGpuktMZrQA3y9tYAiaIoB6PRY50ET/rQS4JbFUQCfY6QM947fAhkpSTJrzV9iNLNJCW6vheWllhIGCWgHXMkZ4NWlhh6irJCDQQJVJbvTSaRKMuS0I9gKUBujcX3PTG0aJtICOPI94qyknl0rkBpQx96jBJpeK2ElTT2MGcwPLuuJSZwZYHKiRwzSaw/MoGEJO2TD2g0KENWCmcMdVGhksa4oWdMkp4lKSeSSsTsSb7Hx4RKiedvHrNct3z5zft8607P8eGMW3VB4YQ4k9MgkR8zKSRcMSb1B8mTwmGcIa0jcwxN15NiZLny1KVhMrGonDk4nNIETTmZEXzm5OQUDdiBGbg3qQi+I6vMybJlWjjO24bCWMpiAsahLOSUmBQVfqciBjKF1fQhi3xJzBjjcEVFygmNJQ99omIMWCOSUqMkuysLIRQ5Q1E5MTRM5sGjU65du4Y1A2mlKkQaaEjUlnVFNSlJZGKfEcqNGDh3zs9ZxUzp5Ew6qC0zq6hri0mQtKHICV1lUnagKlytOV2c8Stff8iyTxhlIWqyaSFbYQMnUCQeL1YsJpb1omW/drRdj9ay7rsm0q7vs783Z78syNmCAr8IkizOiW69QinFbG+f1WlDTIGcPQlNBgIJ+oxShl4OGtZtT4qdrAmdsMaCSvgYxZmJkRQjpbGgNE47chr626iENhUpdxg7pW86ppMJPvb8qc++xOe+70UyEZsSRkciEsy11kHytKsWNynBaaIgjziQA6tPel8N7RSQYLHW0rbhX/c1GhMja0/O6c8S4nXUhur0lEjt5vXtfreNKqWcUEkRfBC1F21QylBVZiPplrs4/JV66uft/mzXeFLA1xViyCNnrhqMtxTCxunYZbQKi3fYY4MxOxp7I/MxZ3igFUfsGMCDozp4qxyGiFWKz3zW8PFPLLhyJGtwdHiFTLG999HZlT6hcp9KKfR4TrI1GOMQcGdQOtEDfdyHiHvpDSYvvUUzXRH/4Z9DJbMdmzwGzbeG+nhd8rb/IexW0Q3fjwPK1lnIalurP97btsIsk7UE/5VS255bgNk1UJWMp/cBWzv6rid6hy1rorZ0nadte0BTlhVd0+CMpSg02ijevv02vg+EENjb2+PKlQOq6pycBL9TDhSFQZeiUpST4/joBst6xb3778D16zz73BQDNI00C6vrkr7zWGPYm005W5xz+vgBZWWx2vGhF57ho688z+npkm+89jZ37z8S9ZVJQVXWhBDYP9hnvV4OrFdP06yZTid0XcN5dwYk6c0Us0hG5UhRFKxXC1GAQea+bS0h9DhTk1WgbTxlMWW18jCX8ykPc9e0DV3bb/aXLE0lpLYM89mUzx6/xOv/99u8/enH6JfFoU1xExHaOuXDgh6d9ZjS1oEFuOCwsPEax/U0Olzj1oDteTLuNyHuee788m0+8eglfOhJSUEQr0xrg86QY8DHIP0HFdJyRSmsdVv2uxoTYhpj5GzUSkkfM2UkBBiCrMMhCCSBgYjve4hpWPeZrKTVk9EGElSuYm/+p1is/xlVBYnEYrHg6EDUi2IMLJdLabdijLS60Iaqqnjn3kPW6/WFPSdjt006ffjlD3N6vuTt27e3qa1x8IY/vHHjGkZbHj58zLrtyOkiW9oaUHpwBtM2lL5zMF4Ivm9/LM9cVhNSTBwc7vPyx99EUXDz+Jjnnpnx1tvvsDhf0IfM22/e5er1ffYPrnB8uEdZapZrz7WjA15+6Vle/ebrw/OKLTudipRb9GI7vfDC87z11h26Xgi2UgHcbtaHSHfmIegbEEWcTNf1lKWQ2Mqy3FQBhRCGQGkiRk9VibRhCJ4Q82Zd6jEhPEgcjkPgnKUshQXfdX4TWNo40sOZuTsdSQZ/U421OcqUulihNWB013Xvct7HM/P9Er6+29cfBwy/r8ag8CWGX2L4JYZ/9vglXvvnt7n9zGN0/cHA8Ld/+y0+1r14ieGXGH6J4b+Pr3fjtyHnUTVFkfOQOOPd97Cb1BnvMQ+LViHyzRIziOSQWa9bJpN685nVrqx67zFG8StG8/JQNQ4XrYNNcVYea5a3SYmn47d/Ar/litrYAb8lMSRrSu/g9/ZZVE7EmIe4nBZyHoq273HJUjjHZ8z38fGzT3HFHw34rTb3K+M0jpF8I4n0bd9nPaxRNfQR10rt4Lf8nR4K4rwPvOQc/679CF+Ohn8wVD/vzkkmjybGBr/ZfOZwTzv4vfkeNq0XUs7bHtO78z0k8uOA33rAbz2uoQG/d1uiqAG/ex+oa4e/xO8/UPz++MvP85WvvM5i2X1g8Ptb3/oWL+3/xAcav3+r+3Fu+l9mWog6VN/1aPOd8fv0zjm997ujsHtIAnDlyjFt51mcn144R/MO5s5mU1CGVdPh+7Hdg7zXaFHK3TWLn/iId338rs+igMI5UkwcHuzxM898hYTl6OCQ5545uMTvDzB+v38pdVOhikOqoxZVelKzpLB7hOgBh9I91hWsl2us2kMVsoFyiExm+wQCKjSksOad7g5r3TBhKkdE35NZ4MvAkjVeZSa5wkVL7BK5AJNls93tH3HD1ezPZyyaQBs72pgp0hzjZlyb7fP4caA0FYUN+NQxN9AuLc9NbtHMr5CLSMot0RqgIKaIzgmlDNrVXLt+kxhBaanwzVmRkkIZJVOfFVZnnHVkpfE5k3RGB8hdZFJO0MFT6kiRNR86vEZdZJarNXN9hTf8HVbhNlVxwKQqsOcd5ytHXZXU7oxZ1ZDMISkFctuASeKo7pgsonSh0DpgdcZq6UPmjKUsOoqiIDVxk0St6oqjvX2s1lgDXdswmUyIOdO0HaHvcErkGBSS0ESBG+QUei9Vqr7vcVqhtMGniEqjI6EoXEEIvSTnB0k8UOShh1zhJmhthKE0ZHlyTmgNzhV0nZdEs9XkAK5wtM2aoytXCNHjygIfAl3XYa2lKOUAt1aqpq1V+JAxFqnyVpquC1SlIucesORsJcnqIBmRoJZdCzklysKSU6SaTER2KI/M4R4XZ3I4YyWBGIcgjZYqX6UElK1zgBwqOWdilCryvo9oNFoPckgpUpaWrutABaqiZrU4p64nYiQNB0gKCcx4gmj6mAgZ0HLwdl6CSYN3R0wRm41Ubw+MSDkcLVpJtbVSkiDNJJyThH0a+hOBzElRilQFg3FnlKXtOhq/xpWaED3WTvE5gBH2ko/S190oQzKGzkfKakYICR88ykg1dIoQUkRrSaybkdUUpYLFOsdkUoskix2T8Jqc4nBoCyuuj4HSaFrfkULi+LCifCuz7uFLr77NteuHZLIYZFVGR4PvWrKSRGUG2r5jMp0KAUdllLHEHKnrisX5KYaOV156gVvXn2F5+pDzZi0V/52n7+R5c5I5rauKPVegQ8tJ29A1HTM7x2QhcixTiykFLOv5FFOU1K4a1kwrQCsLBJ0DtiwwhWU2nVNVNd735EG6xBUKYxQhthhborQ4GkVVDtcDWxSolWY6nQAwm89omjVhvRLihHGUZQVkYW0WJaW1RDwxVmgSr50s0bYgp56qLHnmoKQyoiZglFRVl7MZ2Am9DsyMZ72s+Udfe8DSB4wp6KNI4Fdh234CLBjFOw9WXK2MnPHJ46z0ZTFaY43COsvRM7doTs/omoYiTTk42uM3f/EXMNpwfHxFtoYt2D9+jqbpUPYeKQwyeUmRlUYpS9uek2Oi8x5dWGhlD1vlaH1D1galMm2zhuip6yM557SCLESj0km/yEzGqASDxH1OGTUEaRMKn+Tc9tFjrCIPLTmme3sYW1HUc1IeDN5B5gY8ikTyshatlf5MIWZU/u4rxje4sVPhANCHY+AvyDn9e7rS1kmWV37id2yqLZz9OE1zirW/JAZQSqhiyoNuxnFebJzvbx+wv/hqRktVoHgwmOT8NtYKKSojCiYD49YYuznvVFZDH/fhU5OQUMzoVG+egI1TPVrHzz675Cf/dD/0RGITxNhl/Y4X2a0JyTmhk7R1YBPclt+HIK1QUhoMRyNGa0oSjAghUpaG2ee/TGsV/T/6GehrRM5gjJ3vMCrHKRjwYDuuo5N1YZrkM2HzjOPzbxmnY7+sbVJAAcloQoibpIDRmvGGcs50faA0JS++fAhYDg8OiLHE94HZdMI7dx/R97203Imegoqz84am7ZjPavbmNa6oODs7AyIf/9jzOCcM8uWyIZPofcve/oy92ZS9+QSjMof7c+qyIMVIVZXklDhfnONjxBUTVu0Kaw0f++hH6HrPy88JofHOvft8+Xe/wdmypQ+BvXqCcyVaw9nZkq985TWqSiStQBynw4M5ZVnirMMPclJmMCgW5wti9BSV9Dxz1uFDh7UOpTS97ug6kQY85wxjS+J0CNYg9tx63dCHuEmQyMhrMgGF5pY65n9y9nnu/+w5v/zrX+LrN25zNz2inXpEAu9in2FtxBaLMUrwbJx3dWFJbFeBAlEI0sNaT5uAjhps0jxIBmolyaC9vT3ab66Z5yl5UISCCMZIgiuIM54GopstRLrOWrvZD+JAyfW0tpAzReEIMWGKMdETN/3OYogYbaWvlg/opFDWDXbUztpXQqoJKvMjP/wD/PKvTki5QSnN22+9w61rQjhMKVFXtSQEtcLWBSrBZFrx9tt3Nv1EtwHJYT8rhbGOl1/8qzx4eIc7d/7T4YwPaMaAp9zL4f4hE/1TpPWcs/tv886d+zw6W+H7gHOaH/vJjun8Wzx+vNhcf4yt6DG+ttmskFUeyIUZheXt2z/A8y8c8/IrX+ebr5/wxms/yfPP3uLZZ9fM9+Y8eHjKr//mlwFFVU9oO8+9h494+OiU527d4Pade9w/eUTGYUzg1q0bdF2DtuIQn57Lfd2+fXeokBh60Gk7kF238syjHLZSiqZpNmdv0/Si2JQyZVlItVQeHXlJzPkgUn0xpqG32facEjm1nijyPEDeKFeVZUnOiRCSKCUNfyr+wrYHd0baHTEEakcnfLz/XSd9W82zPeuf5oRvgqF/AMH1Pw4YvpsMusTwSwy/xPDPc//mOb/8hS/x9R/8gGB4v2ZS1ZcYfonhlxj++/h6Er993MrBZtSQ3L74mbtVcuP3F/I1GcZ2luP7MtC0npAi07reyOWO+G2Lkr7v+ZEM+zuXuXjZLd48eQ/yTR7wOw34nd8Dv82A36By3pxjIEdjjHA1wU+FxD8dCGh5iEeSEzFLQvil5mX+dPv54eySPZO4mHTe3P2wt8Z70zpBNluclGDopvVMSnkgvz2B3z5wtTriE3t3eK27y6vrj9ChyWrYz2kY2B07I6txrLb4/a553cHvd43tOM9DclyCWVv8TggWjPidBvWazRoakmDGlDx3id9/oPj9N9/8We4vP1j4fXbnnJmZfKDx++VP/hDxX9WkuJA5OFsw6d4bv2ezgkf3v4bZ7LUtpo5jqZRl+srPo9dnLH/772720pMvV815UP4Mb9hneP2Ni/j9Yx9u+YlXWqpwe5AUfxIfePeB+cQbZvMJH33xKj90+Ks8urfgP3v9z13i9/cAfr/vxLiix9oZ9cEtYv+AFKCoJqQkfWutNaikpRw+gdWlyDLrkk51EKE9v0eDZ90v8bUkVXUSTIlZE2JPl1vQgRmOiZqy7h/R+jVVDPjsNz13VjHxm3e/xWKRKK3jo0x47uoVPnz8LMmuef3tBV2seNwYDg4tXd9w4BwH1uBTi1ZXIXti6lGqIGXx0LUtUe4ImxK9D6AyxkiCxZiCnBIhB1BbGRJZkOCzpzSaibO4yYSZ2ad0Z1T7ExrT8qB9jKor+qXnbX+PK71hWkPQmdtrS1/MOSQwv35GaY9xCtZ9TzBJmDc78xujVFaXRYGzIuurkORh5SzOKDoVJYNOwhUGrSLGFhSFwlgNWSoge9+ToydFKIzGR+kfHlOkbVtC7ykLR/AdrixwRstYGWGy5YHJZrRGWUcIPSRFPZnifc963QCKyUQS5uNBJpI+4pBXlSHEFnKma9vNs8r7vFR0D/2iIdH3HfPpBOtkA6+7FmtE4qHvmwHENMY4gt8msYOPlIUDlcgqkbJCRaRSOnRUZcFq3QjzRilSTCij8aHfGH8pJjHyvB8cqQRIklcMEkmWOmfxqScT8F4cnkwe2JWOmISxCdA0HSFI8CcnWK8a2aB2qBwde/TkTNd19MGDGnoL7RhLxhiM2VaZF0aYPjkqApE83GdRWkZ2qVKaGHuRgFGAEiaRMpUcsIVIPEmvD03wLa5wQMJay2rdkog4ZzBWE32kdIX0T1cKkbpOkvAdwDeEQeJdyYGslZakec4obVAqonUmZzE+jJL9GVPCWSfzpjR912FLR25W+AA6JV64vsedR2vO1it+43fe5Md/7IgUW3xTYpX0mPEpEnKk8z2rpsFUJXXpBulIMySZwTnFwXwfozLOFpKczInCWbSKOCcECJQwKQtn8b6l61f4IKZTVImJybQpY41CxYArDH0MnPuOg6LYkVIHtKYLETUwa2PfUxSl3NcoYaK1SG0jfXBiThSDBLsxhma9Zj4tCF2PyoqDvQO66Gn6FuMs3veyjrUlpET0idAHDA6fAqoQIlAKnmXTcmWSqYzhcFYyM0n6H5FRJJFLUpmqsExiJATDf/fFr7LqFEYDIQjxKA4kDDJOBbxPFFYTk+HR0nNjVhFSkHNkCJJmlZhO9jBmzquvfZk+9HQ+cO35q1w5qCEPkkexxxhHSorJdIYrKkL2oBUKjTIKbTUpRowyrLseXRQUCULXAInCWhZnZxijqKuKEPWQ3B7ZmjCdTCElktZi4KZICC1aO6nqHsDYGgdYYgrSIsJoYUoqg1K9XBODMpno43B9YcwZazk7f8xkOiEqQx8YkujfvYP+7Q0HIX7J6/dy/fd6r6h1CLNPGKpd/8Pk/AUYFEjOyfwL/SJ/OX3xqde7wnM4KqQraQl0u3c+GOtihIlBtnXa82Agj06vyImqIeibt0QEJax1McoChoKaK6zzyaAMM95W3qyBn/nZHq8GBzfDRhYxb52T3Wq1cc4ksJDYhER2rGphs49SVkIOkvcPAe+BIWmMovqJL8FvfI7+W+XO73eNv/Hzx38vSn8xBEwu+t8X0gibe3qXYakEh5La3lceDHEQJZPRKFJK9lrKie/7zCfEp0djC2Gjvvb6He7dPyH4hLUVhbVoLThcWIcxBWVdcu/eAyFQobCuYX9PCHRaa2azKdevHeOMZbVcYa3l1o1nmE4mLM8XFAORDgWT2Yx23aCVRivpt0XWFLbi9GzBycMTTs+XPHPzBi9PpnRtjy0czlqWqwXOKIqywBUFOcF0OmM2m+B9y/n5mqqqME4NffIMacDKlAyr8xZrA0q3QtrrWoqikus56ft1erYg0w0O6XZaxqDSKG0lMyyVD8bAj519ijhVzOYFf/bPfI7P+x/g1e4dbvOQX519hcfL86HyQdaqArTTxBw2ySIJpsAQ3dlZFTutWrLMpQRm9CAhmBkDNQzOeYqR6XTCncd3WXLGvbt3mNZzJpOaajJFKYjDg+hB6WSUWRwdIVnrRhRTlIYcWC3OePUbX+X8/IzPfv/nuHJ0bVAZkrVonQTjUpaIsy7sZt+pnEgDSXHzvDlx69az3HzrBm/d/gbOGk4fn/Lo8SMODvbRPlJXQiZTWtpx+NDh/Zq2/Y2Le2aIjCnENvzQix9C5c9TuN9iUh+xWJ3IGZQ0CqlKSSnz6NGaVCvqesJLL7/Exz7yCtYYuranaZa0vmV/csxq9Qu0nSjwsD1ahuHfCZAOgXUylKXh+VtntO05r33ry+wfzDk8nLFYnpNTpixKjo8PuXXrGsFn3nzrDo8frylcLSSvwbZTj884e7ykrErqKnF0tMdi0aBVh9FQVRPWjfQhi0ls0aIsNudOCEGuo9RGpm1MIo72XN+HQXJtbDkUpbcf41klEn+TumbVtIQQN2di0zSbOdj2dFR0bT8EQg1Gb4PNY3WPHkjOWmtcIb03x/ZJ42v3jHvy9V6M9KcGkH8fXpcYfonhlxj+xxjDp5cYfonhlxj+xxXD3yt4v1v9/V73+tQz/Yl7Hr8e5dKDT5iZHcZ5N5kw4tpQhffkvV1494VP4iJ+Q4x+A0gjlgl+Z4GsQa7X6K2cuOCQYGJGFBCVUjyXM4cp81jrIdk1tK1UknD76e5n5a4HXFdj4nuIoVwc58w2tJYHRQdJIG2YKXmsKJcEnkpqczKM9sC4Vq9zg/+5u8l/VHS84cOwfyV5OX7mSJ7ZVPnu4PcFufadpZUZK/KfmM8B67fAMchDP4Hfm/jwEIuXePDYVucSv/9Q8HvyAcPv371LpOGe+2Dj99neHuePztFas1qvaL8Dfjv9Ba4s/wmn4x4dPp8BN3PO7F855vzwr9D1v4IuDwnt4+H3Ir0+7puzqDmxe1T1hBdffomPPoHfv9k2fGzyRWb9FwhPKHbuHpdPQwljNNMi8tn5r8PiVabT/Uv8/h7B7/edGLfKEVOPtXPInmA6+rTE5Tk5NXTrc8r6GariCikEci5lI/ctyXbowhFs5P76hBQ71nHNLJ9jmeBdIscSaengiX1A64QJIu8VU6CsC/w6sKcdtXHcbTvqZAiuYd15vvzmN0mp58WjK3z0+EVWy6/wzr1IUjVdb+hSx8OzzK2rgF6gdE+fNapvMVUFWotseQJV1aiYyblBEYlDtaq1Bcl3RB84ffyQa0dzsukRxY5MyAFnMhNjUFWJdRNmdk5PT396xuLUczybQDQ88itKFnzy6JiHy3MensLq3HDaBQ5Zc+P4lIiliS3OK3LfsTVTMl3XyKTnMTkNzlrqusSve3TylIUkbpq2wbmp9GuPgTxUHhrjKEtFVmBNyXKxpuukmjtlpL80YAtHjB7jHJApnSMF6R1NkgrQsihomjXOOWJUaCOA6JyjrKRvjh/6Ixkj8GCtGjSExRnxXhLKofdYa8lZKlxF3tlDaXBW4X3AWUfvPWU1QSmpGldKpMDbdi0JP+8pXCnyHNrJ4a/M0FdcDnHfdWhtMcaJETRUwzddx/7eHmk4QDyj9I5UgFtXyD0ihliMYYhZCBnBaEXXtqQUUR6sLYhRqgZSgr6PxChS6lobYbBhcE4SxVVVE4Kn7RqqsqbrOoyxdG1PiKIEgFLDeHcYo7fyRZKhF+KC1ijUIAPIxlgWI1GB0oNM4ih/NCT/geABK/1YQK4Xg0e6yzu0lgpypRR1UaMRY1wNxrC0FzAkNAzy3yGGgeMhRsbY30JwXYIyKYvBmdLA0B7aBpAtxhRiWCHEDR8SrfdknfExUdVTjvcDxMT9Rcvb98+4ffcB8yKhtCf3nqwT2lnm870Ng6rve/LQX77UluAD63Uj/WOqEmMK6nrCo6wgizpAWRdYJUSErDS97+h7oJgQUeSgmE/3mNcFLiUyhqougQA6Y5Si1IoQ/a67gjMOlGUEtt5H9MgAQ+GDSPb3fZB70cIeqwtFs16T09A3Kcg4GGVIMQqhICVUhrqebEgYMUaiF3WM9aqhKDXzeoYuFaovccHzqVeeY336iNKBiklkcSSPiygKQNMtsG3mS7cfc3fVYZQjZGkzQU44lVA5oEvNrdkhd+6dMZ8UxF5x1kY+dFTiUfgYcM5KT+0cRDkjelRU2KrgbBGwkxlx5cl+hUZz76032b92FVfN0QasdlglAUCjNcqJVLoxjsKUtJ0fet5A1pacenLwFGOPK2MxrsRYR4oRq42wigcjzGgzBBOzkIpyJkUh5jgzrHllAJkHrR0pRCCQgyf0GnQDFnwnay+nTI4ZXOb0rdfJx1dYtGum+weY6FGDCsB38/p2kjOjdNv7CaiPsmPf7r27DvuunE3X9eKgZI2zZjC812j9i2QOn3qtNY+JeKACCnaD6tJDcwjaD0SQ0YEemdIpDlImgzOjhjNMHGgJdlutN3OIUhhVUOVDVpyIoZt3+N1pR9L0CYf2yYCEVG+pjUM8BgfG349OyO41GHz08Twa2e9aDT+LoBCcm/07/5TDL/4g3/hHH0ZYxHJrGoXKwsLUKLJSjL2o8ube3jVrm7t4ch7JT/a1YwgIjsGHYV3ltMGc8RnHgEmzbqjLkr35nNPFktdff4PTx2tOHp1ycDCncA6tE5NpRbvuWSwX1PURZMWjx6d0vcc6TVXXnJ8tyAlWg9rFyy8/y80b1wfbTMhbMYj8GyFiXUFZVvS+xxjDlSsTyrJkbFcgTHvLzZvPsm7WtF3HdDrDGsPqfMH8cI+maWi7Hmctk+lU7KmmJwRpmaMUgwSVIYSOGBPOWbquJ0bPYnlO4XqqqkYbxWK9wDpNzpqYNNY4lALnKumttOktKGNpnbSOyIN6n/SlS5AVk7rmkx96BXNb4/KEo8NjJpMJH46voDT8+aPP83/80t9isV6jjcz16PC6oqTvOmJKjH2g1LAc9BiQUgjeZ1Gu2E0WKY047ENwalwXVTXl/tsn3P279+BvJG5cvS5tX1Sm90JszcMa3SRlsqTONntjcLhijFhjyDny9/9f/wVf/O1fYz6t+dab3+Iv/+X/EZPZHiBybkpJUFshTv8or0weOhgbK0E5pRgljo21PPf8s7z51tdQytL2Lednj7hy5VBkAneCeH3fk2KgqP452ry6CYSN+3vcD+vlx/joh//39J0n9reI3V8khv8n1mlp/zAk9qSX2yllfYoP1+n7DqwjKUXrPYHMuut5883nOF89z2T+JkoNVTljyHL32B4eXipMFAcHe1TTr3P77h1+87enfOrjP0y3imibqesp5J751PHKyy8CcO/+jC99+Zv4EGmWS7Rz2KLAuYqqkmDJM89eZ3F+RrvuuHp8yJXDQ+7ceUCKQUjEWUkLl2I7xzFKRYGc+Rk3zL8kQtUmKOkKR4yJthPJwpyHSiMlcpGFM9y4fo2zxYJ79x/unJ1wsL9H07TD326xzvsgBHb0ZqxyhhQzRWU3DvpGvWrn/NsNUj/NAX/yzP/DeH2vYfghN3CUyOBfYvglhl9i+CWGX2L4JYb/ycTwb4/f+j3fM/5cDQml3YrzJ59rvNZugjTnzPlihbN6OAfGPt3bKu+nfWx+4utd2NlNPKQYpSI15w2WCn7HAXC2Sijj346JaMHv4ROGBPotFIcp8VirIc45VqR7KS6QT965l3fP5ZZsNv6bNm/OSOtRhb5wjfE5U8rSC334CEl0J1Qc49aGvzqp+NurhpWXquDB/GCUUM9pW7AkX++M2xP4vZF/J19Yv+MN5R27JQ/4nZ/Ab2m3t+0DnHMeteBZXeL3nzz8fnDCO3fuwc0PPn7v7e9xdpJRaHzfs/pO+P3mP6Zt282uUZvsuAzNN9af5Ed++j+k6zxL8xLfiP8Wr+S/I8+qtvtNKUXRP+Io3eGuejp+rzrPb/Uf42h5lw/P3+T9aHLJHCmqqiS056THt/kvv7zP9Vd+6BK/v0fw+30nxmPOhNhLQqeY0KVTJtlgtGjQ5yh9Xa2d0aslRMgEol/j4qGARzlh3XkSBW1+wFl+yJwbUu1YaEo1o4srMjPa0FErz8xW2KImxcCknHJtdkTMHXvRcPji81Rhze/efYe3+p6T/pQrXcmRVbx05Sr3T08oVUVYLdFBcXel2bsP5nhJ0praGIKboFGEIOwGnPS9TiqjBknv0EU5TBh6r2klPbeTxtokJ2bqyX2PRZJ2KSQyHT4mutUjXr39Ve6fF8w+ModkwUdS6jg8vsWPv/JRXntwj9969W18HwldiYodKEeKAZ00Km+NoZwhq0jf9gSfJFEaE9YqppMJq+6c2ayi82lgABnICp0F1I1V2MLRtQFbaKqiZBUDRV1hbcFyuRySUQmlMkYr+j4IbOdMN/SDrouSGEXamZyJyRPagPTtzcQ+0ioxupxzxBTp1j2TSSXPpaXnDVmxWC9ZtQ05K4qyHKpZpXdNiFmqy21mbzbj9GxBipHQe7rGQ1YDG076Y6Q1WKNJsScZTcZvjCNjNHFITGttCD6hrR6kHwy971FGCcuNjLN26BODyKkP7DLpZa5JMARNFFZrojH4oUeydQ6tNFZbYkigofdrtHLCyLMlWUkyebVYo1QASqqqYr1uUBqcM8QkfW4KJf39cpLq/KS3h4XWeuiHkQhJCCU5Z7pWZPXHJL5I1ytheJoCrd1gkCkhtCDAKICbUNpsgjEpR2JOlIWMobIlGXCFobQFzhayRix0vZcK86Fa3PtAShHpWxEFJIf2CGIoWEANRp9IqxMjVjuWrUdbub/YS0/2hMxZjomyqkl+Rd/3TPaPKYxmVtW8oB3/7Iuvce/eA/o64duMij3Zyhpz2pB6z8ndezRdR2lLMJLYtEqRtMIaqF1FTAvW7Rrnpqiux1koy0TXtPi+wSew1nKwN+Ph6WMq5/A60q7OsNnRe0VRVJSVI8SeEMBqQyoK2t5fCFw152sICeUURjlyChgrvVV8WuAKS+jjwPZTGCeMq6aVfu79wPhrGyOyK9mgtREZlBjoh0BkTrBarbDGUJalrNMk69TpCTF6Ts9XvHBtRkWDrjQxJzwKl+Q8SSQwjvVqjYmed84jX7lzgomWaDxKicy9GRyyEANlNhxPKh7ZM67uTaALvLWQnkHGGJGTM5qyqjBaUxQlXd+Rghh2b9y+y69+6Xf5iY9/mle/+ja3bl5FhYBOQ9/xlAZhCTkztVJ0wYtUZCFEoma1oOvWSJ8ORegSvu+kx5IapIEQA7EoKmIEm8NAEkkDM8+ghqS/JkrPJwMxR7R1pGwonCWHjpQjWslZbTSkHICI7hUFSuTah2CLSZGrR9d5+8E9ismEK/vHdF0vLRX+iF8XDZSLAVkJ7or1Mxo0wMCezsT4NzD6bw3SSxmVToBDeIqx2bIkMTIHdzxJpfgM8CuIMTTKq8YYNmt8/MzRCBurO0YDa7eP0Bho8CESdRTnfPCJnmZqbYPTajAqd8ZkIFbtOtlKPKmLQXo1fr2Vfxu/1kPiYnSRR584xDic2xFz8x73ui+g/3/XyWf78nwxDb1DB0cCqV7LRrOxSBmDGU97qos/3AY+tsEDCabsVpmJ4gh5rI7bBj/kqoq283zrrbvkeJvT8yXaaqq64IUPPQcorFEUhWV/f0ZKmeWy4fHZGSGKkg0ImSsEYX/H1PPhD7/ArZvXuXb1KsEHQkhEH+l9EMmtwqIY2pugqMsJY7Ll5OSE+d4eKXrKUs4XRWBaF9R1iSsKUSVyQkzKRcH+3r5IjCkhx9VlTcyjmouQ/qbTOavVEq1FGce5ghhF2QY0s+lcep4peZ7lciXnQMpYq2m7FUolXr9xwq/e+fowVZlJVcpZNu4rGDDccuXogJs3bnJcXR8cU2F/d33HarXkY90L/Hn9U/x99Y+3zr4yQCKnxA8+/1k+88qnuXPnHZGL6zqCD8QYCCFS1zUHBweknPjlL/0mZ24xOLswEjLVsKCU0qSccEXBndt3qFclX/3dr/KTP/bTVHU9EBET3neMvaLGvlfkcY7DhSDhSOJ7fHrKM889z9VrVzk6PuLw8EjasiiZ45TjsPcjOYq6kmZMvoHSZsOMH9duCD29Dzxz86aQEXPG2oaDK7+KVh8dTzRGxrX3HldY1us3WZwvN72Ix0BGzopr157j3/q5/y05PMvp+SlNs+bZW9/HP/+lr3DruV9DGzUwycTOWa87lqs1q9WawhWonOibBmc0WhUc7u0RYyZ0P023+iX6+DbzvSEgMJ61atztQzUact6tV2teez3w6jdKlo9fJHVXmEy0tFZqhfzqtGNvNgcU60XHwd6Mddsxm1zl/Lzl9PGC5fmCZ2/d4PbtO7RtR1VPsUZ61vW9l/7TxlAZi9bSrme1Wkl7HDNWHCe6rqco3OCg56FfnMy1SE0P1TdPHEUyV4kYInfv3aOqS/b3ZpwvVhu8GQPFSl10kFPOCIRcpPpnMm0rilDydXfh90/2OBtf78VQf9rrDyth/nt9/WFh+Df5Na5wiykHcInhlxh+ieH8fmP4Rz/yMj/2/A9z9527lxh+ieGXGD68/rhi+JgcH59tt5oZ5H63Vdzb549RinWM0ZvEXEqZEOIOqrzH5z5xD7tJ7i1+pwv3tsXvvMHoLX6nIVltdvA7SIGTfIhgPGz2yaYQIe/ilJypG8LfBssZ7m/ESr1JauXxiXJ+wt4Zx3dMysgzJiTJHWJEK4nlPl86/r2i5j8NhrMs8d489GLe4u2QoN/B703q+wn8zmT0e+D3Zn6SqJxuElo78z7+OyZYh5Ghu8RvvtfxO6jIL7z6ywSf3hd+v3P7Hcozx1dPP/j4vTebDRXFmVIv+ZD5Z4T3wO/wzhld1+8YwZtNznTvGj/9s/8eq+JFVo8Ev48/9FncvRcJ568/ue0InSc2Lavw3vh9p/sZ7PqXeHn2mpy1gzk+WuVPvpQC7z3fuGf5wjdnfO3sJeYvX73E782MfbDx+/eQGDdoOyHFHqOcSMOqCaRMigZ0pF/dwc2foSyOUTnS5YSb7hNNwmaDzwrlLMlaui5yFhpKndEZFqsHnPgTgkpUVeSII6yuQCly0nRdx0TX5KRJKjLdr9FMCKrkk8/N4eQO99YL7p1dYV5UHE9u8qFnEo9PO67Pr3K6epuUNPdXgYP9zFp7JnaoFCeSgkcrQ04KnSIheWGRZgWI5HOOcmAVhePq8VXQQiFSyZNCR24bSuvIJPA9MXlihrunX+V3XvsaZXWTrzw6QWVP1NBHiD4yr+ZMi1NyyFTZ4bVI+KbYYpKmCz2db3ecdWHaqKwxaPo+QpaqRGctVgsQZzKrdcvedEb0kdhHysoQUkL5xKQq6X1H1/eEKLs85YgxmhCy9CL3iRDlgIshbA4DbRTWaJyriDHQd+3m4I1kMpJw7n0vFbAoXFmgFLRdi1HgbEXfe+rJlNR2QpBwpaypPlDUxQaQC2eJoRdmi3Osu4aD6T5d11FVFavVeki8AkO/KK2l2tlYiF0mpkxWgcmkZrUMgk9DlbL3PVVV4tceW5ZYrWmahso5EnmQQQaySEC0fUdVVoQwgksipIS1Dh+lb4fRmr7vpVhCSWCpKitW6w7rIslLMq1wjt5JNW/XdoNEtsiiWGfpfABj6L0nxChV7BmsMYTEAHY9dVkTfI9VFcYZjLMkL6wwZzUhxQE/JBFeWAdo0iBhlAYjN8REH3qqYmQNqSGwE4jRo5DPVkbk2ElbAM1ZmF+KSNd1+JDIWg2AqIe+EohktFGEIEazsFhHKSRQKbM+X/IgKB6fnzHfn+Os4+T+PZrVmq5pwWjm8ynVdII1DjtzpNCTDUwnNUVRcTAR2e5pfcCyf4TKwvpOoefhvbvMZnPm85mwGH1EO0VVOgrnaPse7wO9j1STcqgSTpwtVpyvOs7XnuB7ytJCDwrD+XLF/nyPUhk6/5jrV48hiLFY1RU6ZyauIudESrBoe1x5UbqxLEo632K1KD4oJZX/1gorV+lxzAwpJ6ZVCTqzXC2Z1XN6NMYaMRCnUwH/KAze0TAXSZWCsiwHI8yTVMS5gt73PHzwgOVqQcwaZzWP769QxmAKR9IZpcSQz8YR2x7vF0RV8jtvPiZF0KkTUOwjNsuhoYzFOOkLn2Pg1tU5B2WJQnF7EdAaqcDP4oR0nZA6KuNk7yV4cNbhk+fhnQcUn4NrN55BmcDe3h7Rd0znBdYWTOqCvulRTjOf1sSmZ6+eMSlrdLLYMtP1EZtBxUzpKlLfsVyc40pHUZVCXrCWrsv0qxZtDTl6ouqxqgAlcjN9HzFOnMPeN2hjULoAXUDOdM2anDLrdiWsyKbBlhbjHtO3HSElFuslOiU8mZQV/cpz3qwpqoovf+22rI93R0O/69fo2G6qrb7zX+w43VuJz4uv/G0NkRRFAmp0glNK3GfKHebcZPEen+uBbmOnKcaeR3JexZw2vdNg7NMu9zCey6KQsuNkZsEJkf0Zg9eJrDIl+6Jiw/opz8/G0Zex2Fa5bUZg3MY710VtA2Bj8Gv8/cb5ZeS/Ds7z6OCTB9LXgF8ZOU+evYv+/t8h/eKf3iwLGRtRDiGNfepGtv52jthhyl98wt1vJIwwMtPHvx2N4DE4otVW2nYTMFGCSVoZQkicna9xVjGfz5nOJqN/Sd/3OKtxzpCTqLAoDdPphJOTx4OKjMc6g+89Bwdz5vOaZr3E9wc0zZoYpD3DZDqlCKKU0YdOejxasTfWqxVFUaCtRWmLto56IuS7Zr2mLB2uKDEourZjuVyJszcwtVNMTGdTun5wKFOirib0XUffi+JM8AVVVTHKdKUkMljOOdq+Q1sh35AzWSvKssBoIeHIGk2s1ucDO3tQfUlQlIWQ1BApOxQYZclkPr33EeyiRBkhPvVdLzZUWaGMgdjxkQ+/hPuyERUMpaQXXxIVmU/e+Qj/u8/9r1nppTxv8hvnNqUkrUGKkqZZ8V+Gf8B/9M5/wmq92qzzPLSrIW/Z56dn51ydHPBX/upf5sd//IcJMTCdzgnRE0OgKCui1vhegixaa5wrpI+xcxvHZxxnYyxXr9/g3/i5v4TWCuekX13btvgQL3imeWiXo8eeZykyVm0YYy5UVGit6XvPfP6n2Nv7h5ydL0Fl1s1rXL92StPOIUliShuNNoqiKHjrnfuEmITUhtg6kKmqCR//yL8P8RW6pkUpqOopKXt+6sf/Al999Vu46qEEMIbdFkKk6zxFWUNMNG0rY2LdJuiVYuD4yh59/PN88/VXmU1+B+Pu7oT41E7AZmhJoxSr5S1e+/oz7E2mfPT56+QIbd/QdZ75bE98hdLR9+d8641vEUJiOq24eu0Q33uiv8d8foWHJ+e8+tprGF3w6qvvYA2U1Zw3377HarUcAoGK2WzGet3Qdf3GZh/x0/tBaQVR5klJ7JCcE1rJXsgkQgg4Z7bB2h0sUQp6L77XKOOmtR6c+bxZk9/Jcd78Xo3nP5v1sEkCD07+GMQZ++19N072d/t37/fa8IeN4SXwcVL66nfE8CvcGqTU343hRimuA/cuMfwSwy8x/LvG8Gcf3+Q//NS/T6uaSwy/xPBLDP8ewvDd5PLuv0/73PG9McZNZe7oRz/5/m2S4mK8QMZZ9sDu334d+BhQf8f73SbFx4RLvoDfEqTZvSdjtpV/T96nQNy2MjulRMrSxjCHQFK7xWA7BLS8Je1pLYnRzeUzQ9/uncR2GuWnN2+R6Hi+OP6b3+fRBtiqSORBHjFq6fOMDzxvar5PW34pi/T2eAsjfucd/GZYr8Odob8Nfl8c7+397+K35EQu4vdYqf80/PaX+P2BxW9nHf/B4f8Sr7r3xO+lP+M/Pvh7/L3f+n+/b/z+H179ue8J/C6coyxLSXaTCeEtXPHt8VtyPXnTgmGU+zaupvrkf8C6/Czd+iJ+L2/9VYr4t9Er8Qm25Bsh9Hwn/D66ssdZ+vPcSb+FWX2Tq8W97UM/uW+H/95aP8d/89rzTKZTfuBDl/i9e6590PH7fSfGtc1YXdK2ASioqxkx9qTUo63DliWrd06Z1D2mnBNVxMaKyWzGeXdG7Ds626O0o+1OyChin2hdhyaxTh2L5Yp41pGvGsoDR9fA2SpRK09KgXW3wBZ76KoiFSXZS0XvO8s19+/f5+FyTXVtxvOHN6ls4iNHx9wrA5WOuKIm5RMePlJ86MoMr9dQzMgx4XMrst9W+geFpITmHQY550EfHxTKKkITmZb7oLJ0JdKgSaic8aGTvtTaUNYVya857zRzO8fVBt+tKZTBKssirznpl+yTyTTMTEldVmjj0CnRd2scivOuHyoUh1eG5aoj+Ciy0saitRgJdVFwfHDEYnmb5D1BZ1IIuNKRs/S2KMuaHCNKi8MvFZKRGAI5J4xVVKqg856yKKTfNFAVFRmIoUWZhDJ52IBjgEFt2PFKKbJWkNSmv65C4coSpSD2nhgyMSWMjUJIQCSfRzBSSiqzFZmqKmkbkbrXygybsyNnSU6NktzjBhKJ8TAcoA7nCpq2oZ44ei/V5ynmTWVpjok0SIjkEKldRdu21GWJIYMVqZAYAkoVJBI+BqyxhBApnJUqew1RZeqyENmSoqDpGsqqIsaEDxnrpCJcK+mT0nc9bdcwn87oO6lUF4anFsCPHTHLs0nPmCxye1EYl8Y6rFYYpVDKYdBSfREUhS3FWEx++BuRkY8hgROJDeccwQeys3jvRbo8RHRVg4KYghAWQFhvSXoKSXjNoKwVyZdBPshoTV0atDKgNVpnQkxy2I4GJxC8JE+1dRvDWiotEqUpOH14n5P0AB9aVssJzz3/Er7v6ZqVGCgxc/7oMcvlOWVZUlYVOXmcNRR1hTaKTzx3jaJwLM5PKcuKSVmChb7r6LqOmOPwXkvHismkFHkenSEH6qomK41PEWcLSIlqMmUtGE7MgabryVHjBqOv61rWMRGzpmkiDkWhYdUssMkR+x5TACkTsibmuAUWwDqFLSCHiDcKY2Xf6ZxxRqrFhYigMNbJ/ssBo4AccLZGa1nPrqjJnR8Y9SI9L3sRUpQ2ATlnQoxYowg+0jU9PniMtTgr/YC6mITU0Huy09J3PilQht53JK957f5Dlt2gPpB6CmewKqFSFLUp37K/Nx96AMFzRzNU0oSy4NlDaXOQc6bQDmsdRVUQQs9i8ZiirGn6hnUr1drnD5b8zm9+gwf3Tylc5srhIZlI//bXUKai7TzdYg2TgsJZ+oen/O7XvwVEuj4T7vfcf3BK7i2lzVTWsl61nJyfY1yBK0v6vqUsSzGy12v6rDA50auEUZZIRKPRKRMzRJWE0QlEhMWstSJ4GeeUEzlmHBkNFM5S5UCXelxpUSnTe+g8eJ9xBaJIkhI+KFDF7wncn/YaHacty+/9Ggyj4ZOGPfxtuZLADoN7cNhk/U7w/sfR+r8nhMiJecAdNeNmng9/uQ0sb18SVM9sHUWT4fkQuV0UYAxdL6zmFOM2+D4wF7dBAo1SkFLcPH/OwprMyNkVVaZgH0dNoNk6silvg+DkbbVaHvuyDcZ5SpteqE8GJTIIsSani8O2E4Qf5Rw3n7tDltlUlCkNRKwzZLIooAy4tfs3IxN4Y7co2MrtjjegLvw7ki8krpAvjPnmdjeGa944AHl4PwyVhXp7DVB0fc+169cptCHEHh+ikJYO9phUpbQd6VtaH3h0csJkMmc6mbNaPqBpelQ2ZDzWHlJVFVcO5uzt7W1u3VpRG3HOkXJiUlb0DGebUhSTCSpDUUyoJnOM0ZSlw/vEetUS0ISmp7AFFktW4iB2KdA0LZBYLDw+9BhjmU4mNO1K1lP0WKPwfYNxJUVhadoVZLDWUVYVhStIUZRamtVC7BPrWPue6WwPhl5wh/uHVGW9cRAcmo+98QLfzG+JswbkJHNynA74N5qfZGb3cNMJIXYkIl3TMmVKWVQENJ9OH+UV9wJfDa/LnGZFShGt4IvXvkKTmo3NJtwVhSsnjES5thfb7K986ud4/OwZ/8kv/d2h2kMKp1SOoiqTxMFq245TdcrBv32F592HRMJtOC+EzCKqPbos6HuPMQ5tDHHoBzcy2WVOwWi7sb9jFMxKORGjBKxC8MMyEPKYMRJYk165iax2+yBucRbA94EUP83efJ/TM6k0aLs3Sdyj7ZzYq0O7DTO0gnnw4OFmT6px62T43A/8ENPpZ2mbnq7tJcgXR0tnxmrxE5j+v2Vv35NzGgJzmfsPHnB8JbE4PaWunFQvOAfaEFGDWk2iUImPvfxJMi/w9Te+xNH1L0igRmW2YfohAEcm9M/xkedu0jRC9otkmnVLTIHF8oyyKjlbPOb09JzHZ6fMZhPQsF6vmdQlH/v4C6zbyL0Hp2hjcEVF18N5v6JqPD5mtC3o+w5rNKvVkpTA+0hROKy19J2ni36olJAgSUwRbcwQtBMJ20we1rysQ2O0UCvHnnTj+WmNkPFSGs7kbeDUObfBgXH/7AaVnww+64HkOCaKxwpj9C77XdaOUqK0Jfbru2Xdnjx7n3ZePnmO/uu8/mgxvCSEj2LMV74jhl/hmUFKveFJDNfAUUw8Ki8x/BLDLzH8u8XwR+4xfewvMfwSwy8x/HsEw5/E7/cTtN+9h3EPPPkMTz7P7himKHEJY+ymEk+kqC1fB1ZI/Y7WaouDbNEFGFO824RtjBRuxG8PSEz1In5zYS6eJGUJfksCOaaEHnplo7ZJkZQkOWuMHdo9wq5izFiZPtoLKgn+PhW/zU7rlQu/EWwde5RfwNPhPVoNVe9oUAnrWpRqJBH+HviddvCbPBDlhs/c3fcjBj95nW+H33msqH/y5wN+D99wid/fPX4bLfFsBqn632/87vtOipK+A35r7/h3r/0N9A/pP3b43T77P6P85helLSuQT34Xdf4qbf74U/F7tVrzrqM4Z27c+hCLwz9F/xT8XvgDOP4x9tt/ThlHworcx+PTR8QrifPvgN9OJR6oH8bNP8k1909JyzcYGK+bs3H36/vpQ3z4uWcu8ZvvPfx+34lx6aHdYp3GUKBVCTni/QrtqkGCzA7VhD0qa/ruDO0O0Bn6/jFLs8LjyH0rvXqyIxQRskbHkj0zx7iS2BWsHrc0aw1dxk41xmja9Tnr5oxZdQuVPCfnj7l31rBYLvFNxPSBh4t7nKyOeLYsMKbmxhy66Lm+N6e2Baerhkfnaw7qnj0iykRU1qgIMXmcrchECJHm7ISu65jN9jBlQVIanRQxeaxxJIJUTKcgh1lhyDFilUZbhSLhY8PCw7y+SjRrSl8wm85Y+SUUmq+u7vNSM+HZ0nH7QNOTSVoSqL5fYAg4U4K+mDBQWouEehZ5Nmc0zjmIAZUzR4f70vc6CPNpNp1SuEIKpFMajAdFNlKdGfqw2djaGNCG0LYCJjljy2oIDGiikYrbPDTdSCnI5rROqiozpCybyioNMZFJWFuQNbjaEXXPer3GWEPXdrSrjhCSJOKAwgqb1xiD9wJKdT2haRpSlOR+33ebQ8g6Sa7K4peeBXIIBMpCZFxCiIAwY2IaDEXrNnLjKUJZ1nRdS1lZcjP0tlbCatFakxS0zRq7YRRFUvRgpYI3DEEbjMYgVdBlWQqQ5ETIERWlH7z3/dAnu8daRdOsqKoJ1lkWDxccHh7Sey/9/awVAM0ynzpFIonQR+nxYwtiiiLnHntKI8lyhRw8IWWMlr7tWgvD0HtPzlAMFczBe3KS/ixS0RxRylG4Wg6qlCFrfOhwRlNNahRmkEGXwBUDAFtnUUaYXmhI3mOMrLA4kMziWGmuxCi2g+FrMGCgngqZwPpE16y5e/tN2mZNWTnIg4yIFUJG6ALN6hQUTCYVk7qm7xpqI4oQrrB06zXteiWJ+K7FB8/5YoXSVvrM5Ihzc7zv6ZtucCI8mYKuC0LW0IquDwK8MaCUxRQV5ExdlqxXK7oEk2lNiEuyKvFZicPgCub7c2LXMZuVTOsJyhWErsOa35IxBPpuSexFtt65CZ1vQEVZp9qSC0vXe7q+QSdD56GwlugTRSF9uFXoqauahMLVBWSFCgGF9L021oLKtG2DtYVUwOSMjz2ohLagkKpw5wpyHmS4QiRpzWwyo7NCpPFt4rxRfGuxBu1QWZGiZ29WY2o4O1/RA1klru1PeG5vhlKakkifWoqi5qbOEC3KZLSRandrLApo1w3Bryly4sXDGQ/W57z1zj3eeOc+KkYSBuNEnigmIbCQxXkxWkunixjIVqMThKxABa7MLbUrOI8d54tMHJa4UZlZqTjeryi09IOvDgy9T+R4jrYVznrWfWZST5mVDuJg8AZPPZsy3ZsTc6asSlarBX69JmVNVRpiisz2DzCFoe8yKAmO9qknLXse339M2y/ZP9oXYpbSpKiIvw9K6hecJ6XQ2hLjtwuQP+3vGfb6e7HwxsD6VtJsSGkT4gGVHYlLKxQrQILqYkwldmXRhMd+CKyBsQIKZmQshun+lNVqfcHhlICu3OvoROtBZSFFwbmUImgRL8tZquEaPeGu/gQqfWU7Vlu/GNRFJz/nMQigxkGR81mxkUQcGa3i5KTd4dk47xsneWyNkQeHWcm/aehnJU8XUUmTvaVWE9osbTVCiGQFXW54aE7k73JiEifM2SMnNUhHqs0ZLf7/kPhQGpRGD8+UkBYE2yC/2jriWZIrDL/Lwxjq8a15DCYOc9XtUzrNbFqTUk2IAZU1OQbWqxVZS7+vs7M1jx6d4T10ncdqw+HenKJ0GDOhdE7at4TIerXm4OBQCCkxErIEZuq64vx8gTEWHy0KCxnKqiKRhh5KifW6wTnHwZVD2rYnq4TPkaZtmc6mZK3ISlHW06F/maI2auPYorO0U1EFORtmsxkhJ0LoMVnmXQO+70lxTVlNUEoTszDiy1LWQtd1gMhflWWND6LqIstDcd0foYxGhSGYosS5ee7qVT5y9SNDRV8rslzG4iZzUGLToRw3quv8Nf9X+D/0/1dyJepMOQtj/nZ/lz52LM4XBJ84Pj7aKL/4EKRVRgwEH0mnif/V9G/yL2/8S377za9jnCYlIQZqMjkZso6AZrFu+YU3/gUfe/EVnjE36bsW7SwGjUoSKMnD+eD7FtSQ/IqDPZmhj1KloFSAbLZ7jkhOmRgDykgQT4JKGWMLchZ7yA8SgJmtSsWmymTctRq6rqDv/jRK/eegjCipGNBZow2E0JGCoqoLVk3H/QcPhoqdJJUpOfPcs5/g6pX/DYtz6a2XCWQiKXucrZlNM5/+5A9w8vhf0fq7KG0gi/1Zzb/KlcPP0K/35K98oH30YBPIKFxJQqQUtdasF5pnrn6WO+8cc7b6LV565S6oOOzYgcCrMn04o4vHrPszVJuwymGIeN/y+OyUrDXr9Zqu81w9PhRn2jjKwrBarelaIcZdPdpjsaoJoWfZLjaKSLHzzPfnPHrUEaMEsdq2QynFlcN9+t7z2C8wRohzCk3vI9NJNZwLI2td9oAx4uPBVgLUWUOIQx/MnIkxsWpaur4fpL3ltVw1GK2oyoIYI73fbcHx7aqVts51GoLAGS7IWYYQNl8LmU9kKd+Ne0LcDSHifeAP+vVHi+GKEEusneHc+j0x/LX86xzmZ5iyz9MwXF9i+CWGX2L4JYZfYvglhv8JwvAn8dsYsxmvb5fo3v3Zhlz2hNzs0xLlG4zTmx1DjBHn7OCDSyL4P5YDn/lEzvbnUfxc76lj2sCn2vmMEGQvWgeH74nfYyIwbapTU5QCmpTSgN9j8j6TTBqSIA6FzN+YSE8pYoYWj7vPq8abkx8O60oxKsmMyR65xu7TDCf0ro2zQwZUw4WFjCd/ItAeUQl8vw/5KvAWRmt8kGRnzg3WnDDu5Rwn5AG/9RP4LfbDiAuDDPsTa13+k/fntH2mTRJ/vNzwnAxfj4OSEnSX+P1d4TcKClv8geH36ek5d9NdinP3Jxa/W/scevIM6vxrKKVJfUeZ47fF79VyJaoSOW/W/vToRdIn/k90zdPxOxfHnK5/ikP9JYh3N3miDHzIfYmm/jhfWx+9L/w+XWj+lf5zhOXbfN/+r+HCCYUKm/NkdDh0/5hZMeHkLFzi9/cYfr//xHhqCT5QFHNC6oGEtoEYNZhITJ6yEglofABbA5HOr5jUNafhEYu2EXZk15E97B/MSV4W576ZU7hAXzfg5qxWHXNfcVTXzCe1OGzes24esYyW4yvHPGrOWJ49ZhICbfZSDeoU90/PuDGbkU3GJgjaMrWW/XnBjb1jbj/6Fg/PTrii9nGTEqULss3kHMgpo60WuXGbKZJIZISYScnj+yh9HbQagGVgzOgEapBc0wbnSmIyRCJNH6nrGbrs0c6xb+Y0tiPpHt+tOCscxxxw40rDo2VLCAqfPEolQgBlMuqJ/rLSpxlJtsZAaS1KaSb1hKwTprB0fUezaOjalpwzzrohARzRUeSUkxZnPoZ+c1AaY2j7jrJy+A5USsScafsOazVWgXWWFCNn6zVWG4qiJDGy980mABG9Z1LWKCXsqAQYBTkGjMmUpSVnYdZNqglGZ7xv0UaRQiTGvNmwWYlUiTMOZyxts8Y4YaqNldRjYMZ7kfxOWaGQRJtSSvoslBYUxJCoiopk00a+qrCWtm2lCrwsaVqRedFaqtmNlh7tKIgxkIeqUHIa5OjHfg4dVVEKYUBJgrhwIq/ufdz03O56qVwuy0IS0ySWyyXT6ZSiEkaX1hqrtfQAz3EI3IiUvTcZ5TNCyMq4wpF8L/slgzFDjxw9sL8G0JV3S6VwF1YiLz4cNimDsRbvW6rKoo0WkEtSRWKLEm0swUuVsXGjtNMw/mwZQ3owIsS4lOceKyQYmJSgcM4MP8+0XRDG4nROSpG+L9CqYbU4o55WlFVJCFl6jOeIwVCWBaMRG3rPo0ePKMsSU5V0fU/sZK5yEuBzTmR3fOhpmp6iLKknU6wVcKnKCpAkrdWIBBABazNWaarCobXj0emK1dmaorao0lA6g3U169Bji5KidHTLhqqcEAZQDCGyWiuqYk7vM3vz6WZOUk70vid5cIXFdx5jEqFvh8S1kGaUytJ3PUeRXm89RimctZwtl1QKYl8QNZjCYl1JCGEH0IQBixICixmqcawzcv4NRBmdIQZPSl6k0AfGGGhCCpQoemW5vVxS1PuoviU7gxlkgEpnqcqSEAOLticlT/I9Re0k0GctWg+S5lYIRVormq4jKygKx2rdYpzl4NkjmjuPmO8f0LWBPvTM94+JTcesNqQMj9crVFHRNQ43VRTKcdYIieFoeoBRgXWIdKnn4x+6js2BLne05w3aZ0yGlAOmVOxf2SOaCcYaUgr4PpLjFeraoHLC9wlcRTKGnDLTopQ+RdoMZIOMtRV7+xVpukb6LWWMMpiy5s6DEyYzy0TX9J2XudCRydwxtVfIxpG8VKMbA3a7dX/PrycZe1v2duTdAfVvH2QfWdlbw+TJ9257f40OptajVFXG6JvkfAO4N0grKZSo/JCyOMwSpYW7vMpLfA7FPrC/6y8yB17szjgJW4Nq907EUcyb+xAnUgYwxSgyV8MDxRDISF3bN8xNno97ZO7uPJE890OlhtDVNmA+fuCucz1i3xjAUEpdcHY3dl9mU8W2iUw/8TCbQPygvJZTJpGoU80kXeP25pkzaPjV/V/my/WXN1Jcz4bneGb9LJ9Zfz8qDVg1ONoZCR6yCYZvz+MxCCLjlYTgpNg4N2PQPw8JALW570GuV0kyo8glP37nz3D+kTd43N6jriYED9pouj7Rdi0xw7rpaZuW69evM51O6PueejJBa2k1oo2mKoVM5PuOvo+s1w0MAZZEhpzovcfqgsODQ7IS6SeUou/6Yd1rZtMZIcqce+/xfk2IYgNUpbTMMMagaydBJOuwzg3tPsJGinC5PBeboSjwUXpmWWPISiq0xFawJCvSU0Vh2N/fJ0ZPSknky9I2yJSyzK8EctRmbY1OiVIZaw2xT/xI/YMYbWnbnr5tsVZkyqazORlF13vKqsLqzJ/9/M/wt3/tP+OdR/cGR1auuVqv+IL/DT43+QwxwnK1wLkCVxSC00ptCFQxeFI03Lr1DL/91tcA6bFmjONTn3qF1197k9OzBdYo0JpfP/lt/s+z/wt//fn/MX82/TTRi/LSqOgzMsh9CIQo7Xu0K4gxEKP0SSOnIZClNnZdiqKWowW6hiAbckAqwbTQd2L/aD1ILY5redwpabsNk+LoyjH3T4b9lhIxZZQRfItRklgxZx49/nVW61OMzpvrOWu5dvQXeXySSamnbdfiTIZA0yxp25YUA+vlgsnkc3zxV/8Jr3wsyDMpxXrdEs0v4ONfwHcBO7Diu14cWd97bFGQFaicWTdLmqbl6OiI/cOfoW2+ymT2q9uFojQpw3z/i/StJ6sXUAlS7tk7mFG0hr29Pc5XS6zVA+ktc3p6Tllarh4fcO3aVbo+8rVvfIP9/QnVrOPRSeDkYeTq1Sv0vhtUiRKTyYS+9/R9j9HINa1muWiY1jWzvSn37t8jBBl77z27vSJHR3xcE2OVwjYALOOstaZtO+ygTDXOpVISLAwbuUy1g3XbIPJ4zW21bLr4O7Y269PY52N/xV0m/NbBZ0cK/N0B6t/PSrMPBoa/QsqvoNVvvyeG55wuMfwSwy8xnEsMv8TwSwz/k47h3w6/n6yifNrnP3kfkqSQ5MOTzzO+b6y2zlmSJmkjz1wwjr0xBmPkOjEmVr1Hac2rZP6BUvwcMBk/PDNUgW7hret64ga/M1uK2C5+8677E/we2qMoPeD3dm5DjPQ7leVjYv1j+WNY3CYBLG/fWUcbDFbvxu8LNs4WwPMInjnvvGUL4Ntk+vCbAb8zafyo4Ypypu3v/zKTHfwO4Tma9bMs199PSFpyBzv4zQ5+59F+Yve+ZW7ME/i9/SM2WE7erh2lxsr6ktt3/gwf/cgbtJf4/XvCb43imYdX+VL+5h8Ifi/XK/7r/I/5n05+/k8sfvd5zvrwL8K9r8kZU1X4skD5d+O3v/evCO0pjkwebHJjNOrZv8L9c/Oe+L1cLDmvP8tR2MqgKxTR91xr/lu+HH6ePsb3jd/T+VV+efkXuJK+yvfNvjCkzsfny3xm74uY8g2+YD7H7eUlfu/iAHyw8ft9J8aViqS4JntDUtKfNoWKoq7IORK1wqdA9F6kHWxHVe7ThQ6lHbqsUatOHLDkMKcL9CTQGMX1eg+yByxaV6RsIWiMhr3KkcMaUxXs7R3Tnr3DvdN7TKs5k7rizErP5QLDMoDqA2dqReszda3ICqxRFM5SKouNBqsV37p9h2v6iCvlVZSQP4c+zVEktl1BqaYk69FaejF3zRnrxYKymqGshtiyahf0wVOUGeNKTBRJA+Ms1pRilGCZzSZ0askqRvZ1jTUT7ujAEs1p17M2ief2jyjsmvNHnpR7UlJkLAlJFF+cDygKS0pRKpUZGBVGy4EVEof7+ywenxOCSGXUk4rO9/jeszedg5ZDIYbIpK7o+pbee/rQDvI0EaMzGINvO3JMtKGndFoknZMkVkOIlK5ADawg4wwhiZGRk/SrLlxJjEIcCCRyFHlnbRUpSM9yo/Ow+A3WOWKWEs6cpBc3RksFaA6ECJNJTTdUPYvEHUP/hERMIhOkUMSUCMFjjBEQ9HLPaSQH5Ezoe8qyIEU5HHzwuMLRd730GiEPxpkiJYU2BjMYOCJJfTFrZbUhhiBS9L6HPDCcjN0Eeap6Qts2KIlzoJSh7z05K1xhySnjfUCbrUyKc47QtXIQxUBGYYdqWTMk6LTSWFts7tlYPUhjmAvBNGvdpo9KTgHrnIxfDJRVSUqrTTJfa0WIgZSgcAXOFRhjKWxBDJ6sRbHAGFEAMAMwxSiVzznn4VCTIBZI8t0YgzbStyf4fpCrydRViXOyJq0pcCaQy4LJdCrwEwLKaGLfM6lrck44JzJJ3kdiVPg+ossCFRLWZFRpsUNPdVsIyMfoOdifD9JDifV6vTFLxYDN9L6jsgVtu0CpIPGt6FmtGkII7M2mxNzjfYdVhvOzM5RSuEnB+fmKyjkikRh7FA5UBptZNGfsHVxDOb2x03POtO0KYyppBRAV7XJN6APdQGTBKKIPpCxyN23bwrAHnDG0j8+pZzNxsFOgtg7jLPuHByijOT09JQMOhzFOrqVkjgorFd+xT4OUVSblKG1syEQiCk2zWmOcxiTNIinOfE+RHEpZvLMQ8v+fvf8Oti1Nz/uw3xfXWjucdPPt3D2pB+gZRCJHUiomg6RAkyqzSpRdUrkkWWXa/sPlomNZtmW7LMlS2VRZLovlsmlaVplmEgiSEEgQRJoAYGYw0zPT3dPd0zeHE3ZY4Uv+4117n3Pv3B70BAgzwNlVt/vec3ZYe61vfc8bnvd5WHQdyjY8+9QFruzNaZcBUwJxfSL3H4Z117I7mxJVgtDhdIW2dgt8uYxySL7CecdqEjhZntBMKg5mO3z0e36Et1/7LF5Hhj4wT1NWXSZViqXq+Kmf+DE+8/FXee3hfeq5pRTFtNTkzpGwTIwlZ01yDm8TtYV+aMFZlKqliV1qYu7o25Yvf/mY7/iOpwhtACNEC6NFlWDdHaNVRQiJGFussSTWsrZyoQ8t3jXoytLFwBtfvsXu5TkvXb4GDlTIYCzK1qQw4J3FVIW+66Ug+g1IqZ8NNt4F4XmsJP0uz1FPeM5jQVIBfYb4LAGQJJgpXUSryyh1UwJmZSQxHbPtok4Dp3f4LArFi3zvE49mN2feun8ia+XMMZ26DpVtQp1SBuKZwOs0qU6j/GlVClfPFrYfOy13Rwaz0qfJqXxXmezaxmFjgr3Z807faEzDz9TR1Zn89uxpPf1GZSyuS6F6E86nJLL8m/Rda8Wv7f4yr+29So0hZfH+OZzc4V5zi1uzG8SQ+YHlD3EpXt6+7wYPAKy2oDfs9M3lVmNBROT4rIOmdiPrOwmJasPeLXK8Rm/2Myl61IsZw4MZ3d7bhEGKBSkWZrMZrmR0hqcvXCEMA85ZlJIAeTKpMcZQVzV9Jx5cBUVVT3DeUUqi7waGELh05TJplPRq6impKBaLBfv7BzJ1kBJm/GJdP1DXNYXCer1itVoCislkKsF/29E0DalIHFFCJqaAc5ZhCHT9gLUWpSzisSRxS0qR4sX+xFcO7RyghIAVIsMwIFMBhlW7Yqbc6Oklyh3GWIx1p3eVVsx3dygn+bThAtSV43t5hTD0UArz+Zyu6/FVTQgZV1VMJsLqDzGRSselgz1uHd6V4tNIYFuvW/7Lk3/G91XfTcnCtLbW0a7XYpEDhBgIIbA8OWG1svzg8ffw8+oXkWlGwZ//+rU/y1OXrvPf+/W/yuHxMXYkkr7xpbf5T5b/KfkDiX9R/THarsVow2QyHdVqRqawVkyqCX3fU8b39JWXeG1MzDf7Vy4JnQEyKRVImaw1JWVKUqjCtgDovBl7UYXQdxILbZppWlFSpE+Juq7GfSvTddc4PtojI2umb1vqqsa5d1gs/nO07rfTn0ZrLhzsceXyZY4PhSFfcmYIka5dk2Oka5esVyuGviW2z9CtniOn18SupSiKyrxz4y6Hhw8gy/cDRRjCdrK1qmr6oaep67GImujaFaUksnqa2eXPslwvTvf3AmFIzPZ+h+nsNjZ/D227g3WauZ9RMlgnSW4/WthoZVC6sH9xxnq5JkTQRfHKy8/z2pvvMPSW3f2OWET5ZLlao7RmPqq/rNdr8exTp3J5/dASjwJGG0IZ7US2nmJjU2KMGdu2xY7xoEwyCYlyO2GgJUZMWxm806RZrIEkHjLaoHV5ZDrh8ccmud6w0Z+UhD/+uhgz2638CQ/5/en7fLOa4Wcf3yoYrrTkdVml3xXDb/EFXuB7to3oxx/nGP61YfhL7Qf44PpDcuznGH6O4ecYfo7h5xj+bYHhX+09zzaAN8/9as/bTGA+6TO2MtBbK44izTAKKclAjx6VTfTYgJRmmWxROYnX7OeAn+S0MV62/zl9pJy5f//wDH6fPnfzTTd109NGvqKUs5Pap/i9+Y5aK4w6Pf7NuXuFV6iUDME8MoGq9bjHbE8E0vh5An4Xtuv3zJY8wt3pDzbvtTnGXGQCefMRN8sJn2G5/c5aK/Z2f5m9vVfRZ/B7OrnDpLnFdHaDEDKL5Q8R42XSiN8bVRdpDL07fsdcKCnjzuB33ydSOUuOkGPVZ/BbKc3JYsaDBzMunOP314TfGs2H+hf5+fIrvyf43a5b7t27j6rMe8bvZtZgFH+g8LuqPGGk1azLC8T+2lfgd9N/HnXrrzPQbvFDKUXT1MwmU5bxd8fvN3mJV2+8wA9ff+MRDDs5WfHg8CGlfO34fVs9jXW/TQ7tmZxE+k65O+Kj049Ryg9yf9g7x+/tXvmtjd/vuTGO1uTUEaKmaIXxE9yshiyeywmPrS14i7IKNbKsrPKklIko9lzNMhUOmssMPGB5eAs9u8L+ZMrK9qRkSEWhQ6HtM3YClVX03TExNzR2TlKG477nnaM1excarlzdZ5HXDO/cJycgOWIp3D56yPvm10kObE5MDFAaJnXhys4en3/rLbqksK4mJJHBIGVifyLSvM2EkjwlB4qSZnkYTlgtb6G5QoktOQfIBVMUFos2Hl2v6YdjHt5/h/2dPbpuwBaNVgHlDCZHSD3X5xeoB0syHUMceCvd56k856BqiO6Y2NvRtwTIDqXk5tk8chJfbasN3joG3VO0oosB72VK1lqD957JbIq2itERHes8xRis1fiUWMYIGSpfkUuhXbZbJmNOsrGXJM3pjGKIGWs0xtfUWrxxUwwiWYLCG0cfe3Iu2xusp0OrQk7iG26UFhBUiiFHvBf/gE3QF2Mi50hORaQjgjBVnLNkssjYW4+K4jmek9yQEbDe0fc9zjqUMjINnmSzmEwmDP2mkSjBhPWWnDK+csQYaZqaxWqNBZSxdP3ApG4wFnJMKGOp6xqlFGEYUFgK4sURUyAlkdQJIYJFJGFKwaDIIaKdxesK8RUxxNBTnGc2nTOERN/3cg37VprISo+eDok4Mj6HPGCKJQcJBpTzUAoh9DhliCFRKGgT2Z1MR91yBchmpLQ0962vyN1ANwRSFF/znLNIaBuLUht2kEJpQxgGvJONJ8VAseL3vupbUNW2YBWGAY3CKj0yAQ0xpbGwprHGoJSw+UCmpI0Wn+6h77hwMGfSNGitWJ4sUUXhfQUJjo9PyLGQYsR7J0oFKYl8u9KEQaGLTPm3x0u0ke9klUI5jbeeIQZQhbquaeqarJXYIoSBGHpSjqRBVANEPgfqSc26ckymU2KGZYKKnr29GQ8e3KfvMsEpqtmMrm1BKXwtfu65GxhCz1KBqRxpPYCrOLp3B1ebM/XMgsKivSKGQimJ2tdEV433dRotBBRi3G3luqdBfL8pWBSL9YqqNlRVRd92qK4HoK48Tz99DSicHK1YnawoqpBUIeVEZWtSH0RiRYmniFIyIW2Q4AcH1hjx+l71vHH/kEntmfkJt49O0GiKrViFjoO64erVq1zZ32N1uMaUjuOjgtWWrArKGJyboKwhdAHvvRAAishsaefQxpJJWFeBgp2DHWIsTJXjS5/5GMZA8TMCLaU0KAYJqirFT/+Jv8Dijf8bt9qVWGYURCJTW5aho2pE5USnyBB6rK3QdU0zm1MAry2mgLKWqC3zuaSJxYs/itkmswbvd4l9S44JjKJoRtJHQiuL8w0xJlzK6ATPX7nEdL8ix2Fk/2lskn3XNg0xi3SNc544RIbYf50wf/o4G2xIovrk4vi7vHqbVJ6+zdkU+PT9z7KsT9nRZSSgJZwrDMPAz5UDnsOxxyi7VNgW0bWG43yHgRZHxZKHFGDKHga5bh9OiV9BS3W6nJbV5ahGD7OUR8uFs0GXfA/BGWFjWxQNhfRIGV+O/XWt+GvG8DMqU48BX4qKoyPLbJbwvmCMJNobKdaz50RtKuJl3E45/ft46KefqTj9xfbbbHJ9Cfj6N69y/GvPCmEM+M3px7h57S3qLHibh8Bs2tD3A0McuFPfYO/qLv98+Hkqa5hOJuRUuHBxD0isVj0/+ak/y7CIIxNYUdLmPAmRanbd8s5PfQa/KxJm79y4R3qt4ZW3f4AqV2LTgsQImtPANKbEMPrZzec7klyPNq22Esyoq4q9+Y4Q1VLCWIu3FdPpbEySd6iamuVyuQ2oq6ph/9plNn5b1WRKjIGuF2ap8w1t27Ozs7Ndl5vvE1KiqiqmM8t8tstiuaBpmm3MZIxBW8NisZAEzzqscUynO0IeHAaMddR1RUqJumnw3m+X2CbRmM/neO/xPmNMN7JxC7s7Qv6JSfB8p6qIMWylA7UxaKXY2zuAE7X1jEspcfXKZa5evca923eo6gnaOPYODogxY0cGvFKKtlvx4P59rl+7xv/6xb/Kv/3gf8ybx+J1KkUpxd1799j9jl2GbkCbXXKWQtbGxzelxHQ64+LBZbQu/MTlCfat/5AQg3yXkpm3Mz5sX+Z//13/c/7qJ/4d7rYPR1KZ4dbd+/z1m/9PzHX40Q/8GDnkkSwnTaKqqtDWkZXG1Q2liPWM7BkGrTIgx7OdrFHicZVSglzQY1Eu57y9P+TYpFgie74k8DEmlBGS32q5QCNJnCj5FNJwifUClF2OEnyRxbCmD29x8+Zr0gArYjeUU2Jv97u5eWOfk+MblJLFGqhdj8VHODk6wToNZCa14Yd/6LsY0pcZklgRaQ2rtufeg7f5ru/8EVIqLJcLUoosVwuqysv6zUL6HIbAdGpIKZNiwNWOuq5ZrpfjXqy324exoMx9CPe4eu0Fui7inOP4+BhjFTs7UykydR3znYpw1BN6hXd7PBxu8d3f/zK/+iuf4a23jrjy1B5PP3WJvpOdqu86Qkosl6txr9aEGAkUhofHck8qxTDIdILRUvTYSHj2fT9O00ijU0ireftHCjaPJsnWGFJMonQDZDb7bB4LOI9OUb2bzKhSapuXPJ6IP4lpvknuN+/3pCQeHsW838vHtxOGFx35dP5HvMyP42meeDznGP7eMTxcWfPZ8DG81ecYfo7h5xh+juHnGP5thuFfid+nx/luk+KPv/bscx/37N78+9Ra8szzcxonZBPWaobRf1jOTUGuCGilMUbhQRRgn3Qsm++wnRQEyqMT46f4Xbb384act7lWgt+CvZv6r0qyZ8g0o94200ranIcRv4n0Vcc0zKTGasQnN+dHGyPyWZu29ijFPR7lBk/KJmY47Zyfef322WyazetkOWKNGVVsptOPcf3aW5Qn4HeIA3V9g6tXdwnDz+OfkIMvVz2f/NSfZTHiNyN+cwa/n75u+WM/9Rn2dmVo6saNe3z+tYY33/4BcpaaMmy+y7jPco7fXy9+F5P5zZe/AL/2rYPf/53wr/H33D/6A4Xfc/J2/7Jm54n4XfEO7eGX2UTZm0nlsv+9vLF+nuP3gN+1N+y/+N3Y8BYpj6q1SlQNFg/e4oOv/OjXjt+VFT/vcNoUP30odDphz97DXnjpHL+/TfD7PTfGjZrhTEvuV4QAttqjFEVJPcpMqJs9kgkkMpaEzh50j1YWrSHnQJ09s+KIXlNmu3TrEyoFsV5SrKJRE6IaMMYR0Ew2zcc4sF6vyHViiJlUDA+Wx1y+eo28t4N/MNDsatJeZL0KkOHG4j4XDufML07Es0BP6BlI2XF5esDV/T2M8ijEhzZrja2sNPJCpKREThk0W5aCNZrpdAIE1usFztZ4W1NCIIfMEBSozNAvcb7h4eE7PIygnQeTiQA6E3XGzubsnWRq1RKJ9CFhJxcwRlE5Te4zXlv63KIwDMOj7EClHZXJuMpByVjvyAqaegJ6YH2vI8XMpSuXaVcLFqslhcvUdQ2F0Qu84Jxn0jS0bTfe6Fka20NPikF8MhCgKqGXzSEG+uhQI9vdKoX3NcY4hjDQta0scAraaJH3zhGt2N6kjA1TbxxaK0IUeQejtch0KEVdNQyhxzv5WRh66kkDStH3HaWA954Yikj4ZUUq4lGttfippzSMdACw1mCdIWdHt263jKiiRr8MxE85ZGHJpCwgN7TiwxzDQC6JYQg4P06gpwxFygghDFKc0aPXttJgDGVkYFpfEUOP0owqBEJGqLwnpsDxyQKjLVVVE8Mg7LciJR7ZvAw5RmIQQoZ3joRmtY5YI01Lo0ZBD8VYlMm0oyf6Tl2hjWG1XuPqhpASKmdKkmn0IUZcVUEu5Bhx1pFiHGX9ETadyfhagN95TyoRpw2Vd3Tj9Lb3lrbrx8KTbLqpZGEhKikWbPz7FEIgyCPxYhgGoGBUlPuwlFGORYHRxBSx2pBNoaSEKmr0TxLPdFU0dVVTCvRtR+UcMSVc5dBAKoEYhCfgrME6ja881WQm0/kUwtBRUkEr8bcvZIaUcX6GUkek1I7KAbKGj4+PpemqLUNIWDtQe0dMklPEEJhOGqa1E390q3EWKlUxnx2we7HeYqnSCl9N6UNLKUJiSX2gmcyw1rHsCt571t0ahSGmKM3i+ZyqMfhK/MTl3MEw2lbsjAEvRpFjJvSJSVXDFNbDmpAiaC1+NQ5ylYWEUVXCCMwjq7dIwGM2wGgd61h45fl97txdgXaiRlB79uY7PHVxnxevP8t8usuNcIdhWDC9ZEiLI4pK9G1C24zJFlODdxWlQEhRJJBiZtV3OO254Gq81Rx3J6SsmEz2MLUlhEDfdhhncD7T9Qq0YpYt//H/6f/I8uFDVAxkI4w8lQ3EgDcTSIU4BKgUKSvW3SB7nrZobVC1IeSBohWT3TlXZ1OyKeSUiIP4lrtpTVU1tKtW1COUME111ng8KQUoafTVzKQSsd6zt98Q+oGgMgOKOAp0qaYiR0lMKFByEk+dfBpkfD2Px4MN8dN65bEC+e/6LmNSeZpYPlpkf/zxmO8ZZfRMLzTNhJQ+zme6a/xoeubRV42MxhPu8nl+hTkXeJPfBgpP8TK7XOYyu6eE6iccwClrcMN4NNt8dxP0pbjx9SuUx7//meT4c0rxhhESxJ27infe9ijV8Bsfc3z45cze3gnf//0SmOZ4WpYXrJNTmzeZ6KOn8/RcblicZUzAx4LFxsOJkSVsleHF9D4+kxRq9F3VVpHzwLQRVYG2VVSVx1rxPnPWslodc2FvzjNPX4KcsK5md29GTj3zzrH79pR7iyNyHqXdFJJAl8Kk9tz+0Be5391B96LwMtmtuP3UfV5Vn+B58zwX33yKvpfvmApim6OFtOZdRV03KDV6qRbFdDYjxIBSGu891nvqyWRkpgoLtaComgnWCZN1NpuNxZSI99VIHHE4a7eFmCFEdvf22d3dHdU0hPQj11/OdaM1KUUg413NvnM0TcMwDGJ74iuGIdLU8zF+FYJKVdXUjXxm27ana68wWoqw3Xsnk4aUIn3PloXrvSeEQew66pqmqSWpGgbE709vi1u+cVJUCXG8/pqcE/v7+0yaGe6aJcaCdR6UqOxIwi3x0+7OLhcOLqGt5qK9yM9e+xn+D8d/DZQwzbUxvPPODe5cvMvFgwukDcM3C/blspksiHTDgPcGpWX/j0muYc6JjCTM81s1f8H/Sf6Txf+boAIlJYz13LD3+Pe7/5hl3/PnZj9DyYJheoz1QpJkWo8TLjElNBBLJOW4ZW3r8fbIaLYLVBWxeBmnLMqm4D3GkCVnsUEpSgL5LGo9zlj29vfo24BlitaGvofDhy/TfKihDx05Zfp+YD5vuHXnDut2jUaRlZZ4Uzn2dv8IJVVMpiI/571DkcjZkWLg4uUr5NTRWomH5/U1lt0zPDh+HanTKZyF933oNZR5H5ZrzGZTiffMqAqVEgUpkEjhL1OKkAInk8nYMDw9JSjEizBJ7DTZ/R1ms+uk9AyLxQJgmwRrI3ufyJBlPvvZ17h985ALl6ccXGp45ZUXONg/5NbtO1R+j7v373Byst5KO26LimO8rICuC9siktEaow3KiV9YjIJhWVih417Qs5mW2vyRNQ9qTK5zljxNKSlQaa0gpfHvMtpcYhmLtKeJ8+bvZxPplNJ2MuIsVpz9/+Pv8ciWfSa5f7ci9lnG+lcrdH+tj6/EcLngp8Nj33oYfsQtPs+vsMvlR35fMzvH8K8Rwxfrw3MMP8fwcww/x/BzDP82xPAn4/dZ9ZKv/jmb55xteG/+/27Tdptp4vFTx8b5WfxO4/SodGFLKVgtjfHPofmhGN81NlDjZ+l3OY9fid/6zL8Z8fvUX317DTk76c124lwpKDlzR93lnclbqAa+bL7MB9IH+cDxB6lsPdpUxi30b2Ik2DR6nvRlTs8P22vO9rjV9scbqWBDzi9R9Ke338tZBd9ADt51jjfennJyBr9RjL7qhab2fMeHvkjo7vBgxO/d3Ypnn7qPVp9Am+d5482nGPqNJzCCI9qQzvH768JvV9d0KXxL4bfR5g8cftc0rLUiBMNg3sde85X4/eDWIW7ElDLen0V50t4fwVc1k2l6T/jdTK4Rl0/D+q3tHuFM4U+/9Co384uszdNfE35PpxNRWNrsIGO6ID1aWU8fnHyae+4iX0rvP8fvbwP8fs+N8VQK2jU4Z4nLNRDRytIPx2gDtq4pXqNipCSFdpmMyIIUBV5ZhlJogkGpOaV+mq5KVH6HB+EYpRq8n6DbY/rBMHcVztc0c8+QZ3TLmwzaUYzFm0zWCVcMR/2KIWdqV9OWJdVuIp6sSYPirZMjXpk1YOWG1KFHK4PxhunODkftCZeHOUprjHXEXprQWUmzN6gEGgFZ63C2IVeRFAN6w4gxihwQCQmnGPrEfHLAZLbH8cMMhyuMUdRes4rCuIghMyxXgGOmNKsCEUWX1jTGU7maYFtKgoCwWkIMlNGrrMB24hsDpSi6MDCZzWhcw2pY08cBVzyzWUPtFdP5DGssVhvadUvlLChNP7QMoUPbgsh9Z3KOWCPFFp0NKY8JtipoMs4YQj+IVLnKBApZO5QWppoxihjSGDSBMxZbi8dxHIEHFEPsqRtH6WU6VFHGBFxkRbTxMn1deWprWYUlwzDgXUPlJsJEGv1EjDMyja0MIST5LlnOltaOMERSKhRdUEbk9GIasK4am7fQ9i3OyS2hgb7rmc+mgCKlglIOZzW5jHIdMYmUcgFtFYZRRiQXQhafq9T3MrEcE8qBryqU1eQM/RCYuAkxBaazGetVSwqJnMYJ+qTQWkA+ZQle2UjUa6QxjEgcKsYAOIun9BA6jJZpeK002hq6vt9OVWulBahyQaMIKZI1xJy2DX/txIu9mdYcHR6O11u8JIz2hKhwXhrx1lghPRRAJQoR7QzoTIbtxroJ1HQBZYz4qhcJcsIoD26MJaxPWPkpWGGaJgshBRRj4BMDhTL6OTtsEYmdQgGdKSVjjEzFe2sxVhNSj/iyKChqDMijqFO4BkjEOK5rmZcQ2ZCSGPqBnDTeOCpvWHWJ2nv6bsAaWRelFExOzJsJqgi5QFHYnU2pnMjyt12Lqyx7VYPXNVEHsLNtEU6+m0wQG2cISQMd2on/y7JrmdQeMwa7KQ0yfT1kcGW8B+T6z6qaRCIOIvOeE2ivsdYwrDJdlLWJ0agkYLderqhsJd7fReS4RE3CE1KilIxWlqRk6vvOasHOtOFK43m7LEnWkJLiJz76DD/7Y9/Hm2/dYnfnIteeu8TL12s++Vtv8PnbPZd2rrFa3MZqR87iZRRbRzdew3o2xVaO1aJlGAL1pCHnSB8HVKnwOqNVQusaZTSLRY/SGWMKqIrEgMNx950vkZUihUByUygRSkKNNg2qMmLbkQtlZCWrUmi7nsl0QggBV4k/UdKKHAZSNpQE2mqqpkYXR3uyJuUepQxaQ0L2mXXohfkaJUkpWTBCkTFYks5CeAF0UmQNuSQ6IilmrK0gR/q+fST4+noejwcJ8u+jbQL43h9Peq567HfqzN8fkzhTQmAStnrht/1dfrx7diwgA+qUua2U5kF5hwd8eftJN/gcd3kD+CBHHJx6eD5+DGqUSlNa9jMUxvtt8pFSYjOXlsfEqin3COWEYXOuEKkzSqZkxd/+245SGk6OLZX3GBV443VP18EP/qAmxM03P03whbv92Dkbi2Dbc6+AcmYqb0yOtkHn5hsqRegUX/qFF8b6uzynqT2zaQ0k6qpiPpMEczqtcKZgXcXQD4Dm/r0TUhbS2+xwxoXdOd56audHSxJ1JsnJtGbF69/1Gs2FKJJXQyBm0Aib++DDO3QHt7j1/AlX3nwf4QtyLcavSMoZYx0HBwcY4ygKnKsEU7uWqqrY2dmlFGEvSwFD5KysNbJeciaFtF3D+/v7oh6Ts1jgTBr6vocCBwcHTCaTEVPCaOmRySlT1RUhBA4fHlE3Nev1iqae4LzHRjv2ODRDEFKa9w7nzTZp6fsWayW5d9ZijDDnSxGZOwDvHF3XYu2YRBiLTBYpQugZhoG6rpjP5wzDwHK5xDnL/v7+KF0la386nbFcrsZpSDtiJ/yL/DjO1OjKUDUOo2WNl7HoZY0VsqcqKGPJJdN2kaefvk79Zk0Y+m1i+SA85Bf7f8bPlp8ZC0+byQ9hcFtnthJauYiqjhnXhkgzFm7fuck7+TXu3LnFn3jhX+DX5p/m17/0SayzkISMtVz1/Kdf+H9Qf2fDn5n9afoNVjOa0OQ8No2gxERRmlTSaA1kpJmkrbDNtZJ4qxRImTQEUhF/OlNJXLtZv0YLvhUFKkt8RoGcRdXHTBruHz7N0dEudd3xoQ+9zGy+gwsV0+kObddhTOL1N9+W12iNQpNy5LXPP89P/Mj30q4XeC8KNXKvFlmLiOcdukjclQ05VsThh0npDtYIgVSjyRyTeButLpJzGJnd0lTZFOasEzlpowxdv4ZSOFkcYmc9hXFaJm8Sc9lclIZ1GzHqY9y8oeiGwO7Ozsh8H1BFCI85Q99lZvMJV68XnKt4eL9nsTxhPvdM6ss888zTVN7yzs1jlqs1i3FyZMP6tlpIj5uCjh73NEqGcYop50Q/pC0eGH0qC7opFGykPVMujxgUbaZ1KAWtLSEW9LZ4KWtFFb1NzL/a46wM6bsVkZ/EWn9kCy9fyW5//PHNbIpvjuPs+8q/N/jw7YPhAI6K3wsMHzfQ03PFOYafY/g5hp9j+DmGn2P47y+GPxm/v3qB/6sd0+ONg837bBoRZ6XZ1Rk4N1qRSt7it7UiSR1C2O4NBtjP4rkbY2Zz9baNqceOZ9MUfeQ3Z44npzTitxV57C1+wwa/zzbH7RlLPe896/WaXDJLs+QX5v+QE38oQ0UxcNjc44uLL/Avm/8Go6X1dn2O4QpfeXrliDcENtm8Rqwv43ca99DH8bvLgV/g9S3WfzPw21lPNeJ3KWorqV5KxpoV3/Ndr3HxXfD7Ix/e4eDgFi8+f8Ibb76PV8/gN8i9Ys/x+2vG753pDh946zn+Wf6NR/D7wsEBxlTn+P1Nwu+ZnXOoNFlPSHs/+ET8/sKX3+GljTrGuF/46Q7pwo/D14DfPRVf5Ce4nv8WM7vc3vsVJ8zLW6zUla8Zv+OuqGqITcR2KxHs1BBiYr76ODdvN+f4fWZP2r7vtxh+fw0T44nD7h42OZyq0SlQ4pIYA14NELz4YGs7bryyQIyxpBSpsKAbWQBGoecXuOh3oAzcC2vIBu0rchgo0VB5D0PC6ApXTaiaGdZPUDljdCLmHlugxtOqNaEUrPK0ek0z6Vg+UKxoWQ8r8iAa+yoXim4pccZzFy+yOBL5dkWPVg6lHcpNUGRKEcBUuaCLQjohCT3eMLP5Hq5qWJyIVDPWo7VC6R5tdxjWidn0ALsa6JeB2f4uSxb0oSf3HYu2p5ntMHWOJoj470lcs1vP8b6lMz0lCuD2Q89yefJIYWKxOGF3zjhdrUkxklKkbVcMMVLVNbXyNNYxqzxaQ9+ucX4HZTR59APo1mvaxQLjnDRnkEa2s8IkEt/vwhA2m6hIbJMSMXRsJBSUsqRBgC9p8JUXlk3JW/mDbujF321kblkNKSa6fkC86mQqvJrKpHhK/Qh2kJVCK08YEgqZ1kZvfApaYdcWsFZTlMjMkLOAfIFUIjnL1GYfAtaLzIcxjpwVKadtQFRVFWWqWa3X5JRxVhhD8j01OY7yPwWcdWiEabVuW5qmETmJnMgZmVCPSeTPY8BZR+yH8bWeYegYBpmWz1n81XOOgKapa45PFjKpqzVFQxxGmYpS6FOgKIPR0hR2dmSSxYBzMmXtjSOnBBkScjxq3Di1MpQogBFjout68GOZLWd00KAMLmm8n7Dx1gghop2nkChZyT1dFLUvKKRQ5b0QJUJOoPS48W6KWBltR7mhUjDG03YtuQhZYG/qUDmzWi6oZhVkiDmQYoEcMcbSxQ7n7Uiy0HhnEbGUhDAVHDlmlBKWoVJiJGBcRRgG7MhATTkAmiGscZWnkEXqXYtnkXWOOCTWbaBdL4BICAPT6Yx1v2Q2u8K67Tg5WbBaramqmm7oCH1H7T1awbLt6DvNxFRoMt265WEIDO0Ddi9dop7500QH8E5jdU3IAzENlKJFGjEbhvWa1A6kXNCmEkJI1oRUmChLGALr1Qo/qXBNjc1ZSBzrHuu9yB85x7pbIjI9Yg9AEtbm0PbEfk1SUDcNRmmUhRQCtTdkZZn6GV3qIEQO15Hnru9SKU+fhCl4/enL/Ot/8c9xudnnxee/k6ASB1de4PATv8ylecNhG1lrw+ypFxjeeh3tFENWJDLdsCYOAV9VWG2w1uCcxqBxxpBix6TZZWfuSX0ihczDhyccLyMPD0/Y2a25cGEXJZEqRUFMmVwKQ8xU3mKspXTihZRHOadEoGTL0PdS1NUSIWaViWXjLyWedBqFNhbjhBncd2uJfwyUZDHWMJk0IscTo6iFKAkwylg/bVtRHYgx4fwo6TQGLikmlBol7LUmZiha9uxv1kMYsQmtb34T3gu2VWLOJv+bn5957rbwDSGI3FYXA0fU7NJSQHyoFJQs5/1Jj6QDd/U9FmmHq8UyBd4E4tnPK6C0JA9CHJL1oLSGlCijBNzmqHLJWHqSCuMbKLSSQO1PpMSXU+Gf3JswmdZUrhBCx3y+w2KxHFmXdhsUA1+RTG8m2rYir5vMSLJrypiUK4k7JUDkdApOj2og/I2/xPLGLtqIWgZk6tozndRSBG/XzGZzDg72ZN0PAW0008mMa9cu067WNHUFKqNNRd+vSKpQdMZYu1WC0VoRU2L3YMLdl1ZEVahdzf7OLlXTcLJo8ZXmfe9/gb3ZPsP1Ner7H3Dwc89w/+Md1hgomRjg9o0HvPRDl2jqhlRgMpmw8Y5VSpRCuq4bPbYsOzt7xBDHpDpgjB2zN4XzTpL0rh/PsSTG1jm0yagCcQhEG1CAMRrvGmFep0TfdRwcXKCUgtGWk5MTzNAz9K2wqI3DGIu1gp0piAKEH4swMQ5YM1rNZAVZ2L+JTIwBMNSjB5xIABZyzOO+oqnr+hHZKik8iA1K17ZkwBbF089c5f6bx5Ryuo6aquKl+nmOjh4ym+2OvG2NUhqjjNjMbNaPNZLIF0XRmquTazx76RpffOcNwX4ygcR/dvz/5ZWnX+aF8AKpnEopOmPICVKCqvKs2xUnJyvx4BrXa0qJN9/8Mt955X28+ML7yGj+R1f+Tf77h/8L3lzcRClNipmUIvcOj/kPf+v/zPGlh/zF5/786L0mBbnNOdkU85RSLI4OqSqP9x4oxBLZbqJJwSgDprbbzyjvluNYrBolGEOEsQh3lhWtVEKZKaGvidFT14n5fEI3tORRgljYZIYvfuF13vd+JYoeSJ75gff/ODuzXdaLNcZUTJqpEBLNQMkDYVjy4P5dlqsFk0nDbDYlpcTEX6C5/AFuH/6mMPRzJgf4/Ntv8/S1D2CSeEKGnNEWclLEvse5ivV6hVIIKS60hAJNN8heVzTCOASlNgVR2UsPj5Z88fU7PP3MBQ6PF4QwAApjNevFAkaib0qRvb0djo8XvPrZ13lwfMzLH3oZbyfcu3/InbsPOTpaURRY6wS34ulEQWJThLNsZL5LPvWJlvj0UV+xzfM38p/6DAOdAkaNikMUtJUigMSich5yluKZMYauHca4XmGMGQsAp5iwZelvZd5O5TU3x3K22Hzq3Sj4b50UDAqn8m6/X4/NVMs3yJcb3wv+oGD4nFv0HNLJNznH8HMMP8fwcww/x/BzDP+WwvBT/NZfcQxfT6P87ITcWdw6Oy2OOkNw4xS/RVpdWiApF+qJRyvF1S4ILp7B/AIMwN+uHD+rNaaTZqjiUSrd+OHSIPsK/DZn8FveVXHa6NDj1K5SBmsVlXcMvebvqr/DbDalnhqqYh/B77fzl8eG9vhdeRf8HuF6+222PxAlHaWkrl4K4x67WSMyJVmA/6z6x9yIP45R9puK34z4ndNYDxzrlBcPJnzwpRVKFaqvgt9PX1/zA9//gL/7c8/wGx/vZO8smRDgxo0H/Og5fn9N+P3UM1f4reHzlLcfxe9/qf0TnKwOz/H7m4Tfm7qo9xb7BPw21vDgxud53+UNQVXi7d8Mf46f+Drw29YX8eZ5yvIzo5VRIWe4f/vLDJc/ROzVe8bvWCBM03bfUeNGqNQY94/quItle47ffHvg93tujIfc0dgpxk5QRhHIGArGzFCmQg2RzqyIbcvu3jNbgJMmbEEpi9UNuURsjjRVRWMmrGPPNb3HSiuccRzsPsPJUk5GG1vW3RSMZUiR9bJjSWYYEmhPCZlaFa5OL3B31TOUHpNrzCSi28LxYsXdes1ebVEa6soSY0dKib16RlcNtMsV0z1Njr14ySoNWjx1rXWkYYCS0dqKB4q1ZOVxk5lIJZSEJosHr95BKU3XrqUJlTR9LnQRYsgjMcXQVBWTotC1wXeGXT/hMHS0ChRe2HtGkYuGIkGLSHxsroZiGALgGPqetu1QyOJJOeFdxd7eDrHtSCmgiqEPCXehQcBd03U9IQwimW1kY1y0a0os4kMTkaClFAoyRW7cGCREmeo11pDzQCmZIXYopbEWYorSzE4RZ0ViPEW9XfvGWbQyOKMIYUApI3LBmfFmLphxg3DGSWM0JIxVxChMyCEElBa5Fe8cfStN9GHoaSY1OSeRN27XmNGbfBh6VAZvHFCIKdCHzYRwYeg6pm4ynlt5pBSpnCelOMrKQS4RlQ3GWHzlCcPAECNN02ylNpRSuMqSYtgydVBj88U5kQxXhcp7VJGgxFXisU0p9EM3brSaUgJhZFgWZGqCsbEVS6EPEVNXAszWYFGgMtYKc8cag7eemCNKydR2zuI/pFFUlcjTDylS65o0SqsrZUgJQszkrNDa4H2FVhYFTJoJSgvjUyRBNM55chowxuOMp7IVfRZJdaXk/pJmn0hpVFVFP/SEGElZkXJhZ1LL1G67YkidEBOKNO6Nkib3aeFKUXQhMmC9SI9LJcwwdEHWT1EMQ4s2ImmUcyaNCYG1jqYR2ZTVSZAJcRBiiXOkUggpUFSkDx0Gi7eGxToQhsBisebh0RHOe+a7M0kQcmF/ujPK9kdmkz2IkZJEDn+3rtidNFhrOepaLl26cgoESqG0JTFKlzjDet2hS2Q1Fu+auiEzkEnCwjWKYcisVpnkEsMwUE1r+nagRJEAKlGTdMFWHucanHfbMqh1YtmQU8I6R+j7Ud4l0vdl2+BPOaGdpY9rvJfJ+UovuX6wQ7/o6XMmpMz733fAga+ZzS9C6dh76oN065ZDrVh3Rzz7/LP8xm//DrP5Faazy/iJpl8PGBXJRqNSIQwR7Sao0tNMRPK8b2WvOF6u2L0wQWchBSgs5DXPPHVA3dTCPB4JGsYYQk6kDG0/YHRFSlECiSJ2ACVFIeyMzOAhBEwxaGvl59riTSUAbQLeWFarFe26w1iH1lYKokokp3ztWawX5Cw2Awrkns2nLDltRKUh5kQe2LJEYxR2py5FPKCiMPOMjijz9QcA7yYpc5a19y6vHP9fHvvZ2X+XR/7/1QIVNX6m88I0LqUQiuYt9niFdrtPKqGnPfE9MoXf9nd4w77KtXSH/2H7Y9tC9RvAaapdYFQ+lUK92mTN5LzhPp4WuVUeqHgoTqlnAjOlFTbBv5EyHxsTZusMBTuyixXaqFHaSgLJTRK+8eKRSbrR522sIpR8WmTfPHdbeB/90Dbs2LOFj9yZ7fGVMWYRqTmRdqoq8dxaLldjgCu2ETs7U8LQCfHGyr6vjcdaWWtNXaPVUljOSo7ZGY37aM+1q5eFnJWg5MSkbrhx8w7vf9/7uXThglgsuIl8m59Zs/PqlOW6H609Cu5mg4mWmAaMrQSLlcIYT9PUxBhISYJr7wWfR2MqUQSxlo3PXM6ZtutQSm1l0IyRpKLrepx3GG0Yhp51u2Y2m4mE5njONu/vRmk4aw0xBvp+TbsW0tqFi5fQKo/M8l0AhqEnJSGvxRgxxmwTya5rqX2Fwo5sWS1s+pQZ+h7vPNZJMWG1WjOZNDJNqIQc0y7XGGNZhBWUQlU7Ll+7yC/c+WeicDI2d3ZOppilpkxkbytFyEjGmFFNpzotjjlR+8gpkUvig/2L/CuX/iL/s7f/XYo5vQ8eHB4Sx0kq7xzo0bplZL0TI+v1GucdFRXSpjrdBUpWXL/+LEMfQWmu7D/PX/nQv8X/5NX/FetVuyl5QYHFquXnj3+BP/Xcn2K/uYBSRmKWM9Mhm4Lh7u4eOSch1JVTZrAqEDd7RxCfNaXVltm+KSxv1szGr80UKyohSgoqJWdCjigtTHeFpanneFeBk5hsMpnQDSvq5obsBUp8zZw1vPIdr7BYnMi5RtN3LSeLQ46PHrBcHFJKRGvFdDrFe8tmimcYekL7fbSL20znd+VMqoQ295nOX2f18Bly0QxDS61rNGr0A2NMggWnUYWwHhh6KboVxI5GayvSeJtyZpG9oZBp1z19P4yxmkMpkaLOCaaTmsVyQQg9u3u7YjfTVLzxxlvs780AuHnrmD4GnNVbVvnZgmw+c12UUqNsYdj+zhizLVaaUbZPjwRX2Q82kyGSL5xOEiO+z2Oz0XlPLiJ9CBs5OMVGVUspIa8plR/5jEcnqE6fv93rN/v2eIxnk/RNgbSqKrp+eGLx+kkTXJvP+0Yffxgw/B5w8sjRfD0Y/oCBco7h5xh+juHnGH6O4ecY/i2B4V8Nv8/+7vFjOns8ZyfFn9QU2OJLzo887+xrjZapQetO8VvuV/m/sxatZeCllH7zzvJ+498UcLPy/ByFZ4rno/3wiD3iI9HEiNPmkc55OYPfpxHKpnEq06abJpPCeS/xhE4EAnUxX4nfGllDebxvtuvg7LndnBM5UpFE3oQVZZz4HFtvY8Ps9DWn+L1of1rWJSPEKS1T+N8k/C5jjbOUgjWa7/4a8ftf+pk1n3t1ymrdM/o98M7NhhAt7hy/3zN+X716md/8rU89gt/WGXRS2/riOX5/4/j9sJ9wEuY09ZPx2+QFP3L9i8TIaaytFS9/+CNfN36/mn6E3eUDnpvdHkPxwsv7N1hOPsOn2g+9Z/we1gMpJsyIRbLG9WO5j6yXc/z+9sDv98w1VynTH98jr5aUHEEVdIn4qiFbBSpgvCa2K1SSzVMrPSaOUJQBXaN1jar2mVaXQVcYXzGlgkVNozw7e/s0U4vWhaQVxnqMNcSSWaxbluuWlCOxj6QYKV1gmisu+V1mxjHJ0NQN9cSxXC25dXSX2HcybVcyKmfpm2Ujfq/9Eqs9TitK7KUBikIVNfqonV5UpRQUjXUN2laUUvAOUupIsaPknpIS5MKyO+LLN++yaANF15A0WSmKdThfMdmZ4ZoapTWNcWhl6FNhEQOqWEwxgEIVTc4K6+tNiCwbjnFY41Hakos0BPt+IMeAtYZJXeErw6JbE1MmRpmYFcfkjLYapaDve4YgEs8aRYqBMt5YMSZSzoShFz8mxAPcemkGKS0TjYUi1yT1xNhjVUbliFFFPHcRiQ5hr4ncSQ5RpryRIM4oTU4JZw3aKIy2pKSw1qGNQhtpqDtntw3Nksc1VtSW4eK9JycpUFirtx4XrnIYa0T6WhucdTRNjVIi8602N5A6ZdZsJcXHG1SabSNIJJFlyUnkZkoRskKMEaM0cQj0XTtKyMiUdxr9MoauE+BJiX7ogIQbgwNnhd2mtSRv4pOeiSGcTq2DJFE50/eBPiS6PgBKikfje4/lGEB8rnNOY9BZRrCLlJLp+p4hBLkO2mx2E5QyFNiCgEi5yL+l+V8w2oh8itHi724sSlmGPjJ0QVhfIyhuNqlcIMSINkY8MZTCV55mUmOtwVth3m0ZSXEYFQHkHK9Wa7TWVJVD6ULMHZkg0tZVRV3V2JFtp5UmRiHTpJhkipxTn6VJM6fvIycna44eHLM8WrE4XrFYrlmuO3JRTHf2aWYTFss1MWpKVkCmcg0hZCbNlKZp2NgQ+KpmSIlYMhlF2weyUpKQAFHBMgQimeefvcZ8svPIXpuLTMgXpVEYppOaysv9XUzFwyFyf8g86HqO255V15JLZr1a03YDe7u7hCHQLtfkIdL1PREw1jHf2QccZvQJV+M1s86KDIqCpqmovMFqNZIrEgUtRBBnMbWnqILfn7F3YUq9M4P9PZIyTKeeD1x5jrZf0qkjDp59EUqNpmd64Rm+733vZ17tY6tdThZrkilEPKkErIFmOmd+cMDFp55hsnOAdtXIDhuIqWc6m7NcD9y8fczhYqDrB7x3XLuyw9VLNZcuTFCZseiotmxOECkofSYoQIn6xaYhbrRMaVtrRY4yF5z1OOuw1qGUXPu2H8gIwcUaYclNmgl7ewcorTg6ekgMPZrCEGTvLFGhy8goHVmWKUaMAqOBnETuPYufe44JXSDFyDD04scSf3d5mq/2kATEbpmB7+2xSV0f/9m7Pb7a+25kRoW9KldI4UvmlXJrfGsJ3qU4/eTPSRR+ubnBm+qIT7rf5M3xcg5nPl89svuNAVUWj5w82jo88rtSMKWn8Co9i9MjlgMei9vwR2Oi9iJlJQGkJGfO+1Ee7vQaPeJRWsakP2fZ18fvpjeSWFpvT50U3vNYcN+cCx5JWM4y38V7y+K9/Nnd3dn6R9V1xbPPPs20qZjUnp35hMuXDriwv0flK+rKsr+zw/VrV6ibZrxHxGpDK82d932J+EOH7O3tsLu7x8HFA65evUpVV1y+dJHvePllfFXjG081aZjOd9FNpPqJwKbkoY3h8oNrHN86wXmDUpnZbEJVeY6Pj0bJM4NzhqpyOGfo+5auWyMkrkTXtYAUM9Mw4K1m2lQ0lUWVwGp1TEwd1sEwtOQScV4wdYPv1hqm08kW90MYRlar2Es0lefCwS4784aSerSKOKvo2jUpBSEHGtkTxZIDCpEYe7Qu9N2KFAYpWkya7XJumppCoe8HFosFzjmGIXByfCzqJcbinFyvw9GypGkqqqqSpsyZRtCVxSVe3HuR/f0LYhszRLTWLJdLFovFlgm8WR+btWKMSIf+157+47z09AvyvHFdt23H3bv32RBZN3HUdl0ijSXnHL80+TVhiCu1XeE3bt5iOt2lbmZcuHgZV834sRd/hD/50h/b4j5AUfId3pneZu06jK22+/HjCXmMYUzOpEhsrcP7Cmv9SMp0KGOpJw3WO3xdYZwlI8e82a83f4yxYx7CdoJ1Y7Vjxu/79/5Oy9HRgpxHiWhEKSnFNS+9rxubffLn8uVLXLpwkfV6PXr0KZSBuq7Ync+YNBV1XVEo7O/vbhPYnDN1M8U7x7z+Kfr1FbTVeF9z9crA3v4XSCSUKqNMoRSRZrPpuEZkzylA1wfeuXFX1GNGCTnxUGSbr0gzr/DZz1xkNpsQgsRUYUhoZRiGgHcOPWL9fDbDaEW7WpJSYnHckqKi6xMhJqrGMJtXGDOuC8V477otG32Dp5sC7dmtfLMuS5HpgZzEPmnjOSbrd5woKJtZ2836hzxKJRotJNLN/pizsOZRMhESU6Hvhq8oCp9dY9u9+QmPJ8m8SbFUU9fNI5NIj2DFY49vNqP9DzqGq0f+e47h5xh+juHfbAwfYjjHcM4x/BzD/6vH8K+G32e/3+PN8MeP4Xc7nsefv23UaT1aXpZH8BtEqa4UxmlAaaxs1uL4Llu8VQqsMXyhFH7ZSyNPNqOzz/7KJnnJRepgKT+G34+ur82LlZbPKaOfrlJCkKuegN/eV2Ot6gx+n8FjacZnGX4p+cn4fQbvN6v2tPlyeh02NXI2TfWcsd8gfl+7dkUURx/D7w+870v88NeI35Mm8tMjfpcRv+89uMbNc/z+hvH7+v2rvDR/6TwH/ybi98PhAot8maEfnojfs/v/n01aMe4Niul0wv7e3teN38458oUfoKkdSinsKGd+Jb9K/hrw+6MHb2BVHveRU/WP0y1c9o7/4rPn+H36+d/a+P2eJ8ZjLPSxg3yMXmb8dJfkAiobUu7pc0SXPapmwhDWKK3R2aGNxRnDkKWhHNIK3QdiXVPUAhaJ1x8ccbywvDK5zmB63MSwO6lYHPcoZHIvFTheril1RUGRy0DXttiZIcTEpfkeaj3wdrrLnj1gvr/k/vFdbtxZ8ZwpuNkeqp6jQkdBWFqNKqjcknNFpocSsFqa+SRpShpj8M6TcqFkNTKMRtm2FOiHHl9VaDUlpXEqWkO3WjKZVZi1Ia0LVjtQUNDSZFRapgFLoSriy70OLTfae1zVU1xx9Fqkx633LFbtI7WMYUj0A2DEEz2GTCxSrMhZURuNm+5w8/4RNltCjLTdGmVrUo7CAPOO6XzGarWi61pUEcnkNE41J0SSPERhC/VRWCcxFXI2aAPOaSgGhUy2n65VmfpWGpEKLxmrhSUfQ0R7P3pMDzjnaNdrvJPJ7jAMFCWsRq0NpUSUtiJrPW6Y09mclFq6rifFhLOerDMoS9cNOOtJMVLXnhgzWWWqaUO/7lFRidR39lSuIhVpXjtfk6IaPeelAa/HjSXFOE5Li7JByRmV5Xz1IUqDGGHTyM0oHuPee5RVrPtOWIR9RBmFduN6yEleq+Vz+mHAOZG6GIaBvk/ENAJoESJWRggNlXGsCSht6YbErE7SgNN2lLEXiXdrLUVtJJtgI+1R0MSc6VcrkZIfG9QUCVr1OCmgVKHrui1zx4xBZhh61MguNFoRRjmwPBIB+hQJJZGysLZSziJxnZIQKxh9O4xIfhSt0Fqkl0IqGGu2ExmpJIzWFJVpqkrkFZX8MWgqU+NshfMN4iOzpFuvcLYmxLJtlNZOk9Cs2xavNF070PcDMQSGJDLtWmnWixWHh0d459jZ3cFNNW03MGk86IqiA0lllFbszXfph562H9BW07UdXmsskoTEfsBjKCWxHnooCTvbIZuAnzREdUYiuxQ0CeM8JUEcMoVICD3FKH7n9ZuEokFLu3dnZnnm2lWWixUX5jVKyR7U9T3H6zXzqiboAVtVuKln2a2Z13N0KSL3kwrFFmxdoXImDkHsFKyThq4SSLTOkWMhJ6gqC6mA9Txz/YC4inSLNVFrXrx8wOHRCZeff5lZdQ1lp8QevvTaG3zm13+BZX7AlR/915m/dcjqwadIqxNyNLTtA2y20NTM5nMmc4dWmonxrI2jUHCuRqk13llyzJQS6VJkPrHszC6QyiA+4VrLGk0JihK7iVHuiVJII1FGcrmCUWrc38vo3S5qFM5ZUOLjzqjIgQJlNEZbFBbvmvE1iZOjFaHvUSoLq9Vo8Z4bJ8VzHBmnxm5ZmMpqKlezDi0xZPEjymIH0LctSjvwBq0N6hvriz8in3OWeb6xO3kS++7rf2wClMJpeizSSpWvCUF+kvOTE/jT93j0eBRs733vHTor7jcdT68bjsbn6HIqt7T1PFMKbS0oScK0MaJSMQZ5m2A70pFHKfUNu1Sp0yP57hDIqzX/fFpReUsMHc56LlysSLGVz9FjqWFkvW+CUKVE1tVay/GxZghJ4glgb38jCXvmtMG4ZMtpoMs4EV8EY7S2aCUSVE8/fY0w9MSUKSWxWgcm0xlGJy4c7PLCC89RVY5uvcb5irpuULrQdQO7e3ssF8vNaZCPVvDU91zg0pVKEpUQKSkLWcR7rj/11MjadlSNKL2QNb0/4c733ubub/Vcvf0cRWu0NTz1Sx9i8kfWhCHQVJ51atnZmVE3HmsMde3xztIPHU0zlaQzRvq+k3spK0LsMTZTVZ6qstx/cFfUV4ChX1HXNU09hRKYTnapKk/OmaqypBSAhNGM3lE9fd8ym04p2WJtw2J5Ql1Vo2qPFvsOMjF2FAqhDxg1MuNDuyXRlVJYr9dUdYPSjuVysSX1xRhHqUIr++rIDN/ZndN1w6geI+tkFqa4Q8sPDB/lxe4ZftN9mkIZFVwUuzu7+KohDmnrPRZjZDKZbOXONvKIalR+iaVAlipTipn/zcv/U/7y8b/BcrkeWf2BT77+W/zowQ8TxmOB08Rko7hjnePTJ58jhCR2FEVsR3772mc5UsfMqz3Bd22oBvjug1f42+bniGSKyhsI5nuPP8J1c5WY5FoIy/iUfOqcwxgFSJK3OZaU0jaGyYjkIIyqMTltlYZO79uz0zKnzGONJO5ZibXOxYOrfMfLf4UXnh/Y398RIqMSlZuqDhye/F9p204+Lxecm3Lt8r9KCFO8lz2kmc1Yr044Xpzw4N4t1usFCinmbZLNEIJY6oREjJnGe64+9QHuH91FIfvGrZsPabuIsxJjK5XpOlG5Wq9WxJTohkDbB5arBR/8jteZTi0hJCha7HScKDClbFkuDF/4/AXIT49ESKirhuVyuT2fjFY9G1KksOsTKa949pmL3LpzyN0797l4cY+mqlms2u2eZIwdmeKnhFKQgmVKSZJ+77YqSoJBp3t6zHmMBzd+imVM4BWoIlLOnJHeQ5Gi+McVxgDwXQrHZ4uam9dz5mdn19zm32flFZ+EhSFE2pHY+s1seL/Xxx9kDDfrhsXm918nhhdV6Dk5x/BzDD/HcJ6M4X99/TfPMfwcw88x/PcBw5+E35tm+TAMZxoZv7t36u/2ePz+AcEbYxx1XdF13Sl+bxrgiu0E7qMEMTh7zZfWoLTgt8mZyntCP2yfrQrbZsoWEZVCj37Vgt+i4PhIDj4+WyuNGa+rtTLk5J2jH8K2Ea102eL3nr7Az/DnSEmaOrImzp4DttPBWosE8bE5ZEiieLob99GYR+D79PvK68/i9+bXUtcW/K6+Cfi9WCzPnnCsgu/7ngtc+zrw+/u/9zYf/62e2yN+W2v4L3/pQ/zAHxG7wnP8/t3x+2LYxzn/CH5f1heZMDvPwb/J+H3y4b/CSRp44TH8rk1Lf+8TQgbQUsO1xnBw9UXuJbFt/Xrxe5H3OZp/L5Pwa2yIOIvFmq6LmPeA3/3yhOnsJtYqZJqcLcEtpULKirtLyz9+7RIPyzPU5/g9QsG3Nn6/58Z4jkfszi9DSaxPbuCtQ1mPRuO0I9oMucJOJ/T9gqbeJ6aBNPQ09QSrKzKRrCFrRYpL7i0ecuuwZblQGJu5c7zG72i88tQ2sVKZ1EesN1TzXdT9gT4WlFMMwyH94oTJ7pSuwJAjU6bM/IRJmjD3mgsHD1i2Cm8aVEmQpZmiyOQUqIwm5EApkqVrX6O1I4QeVRSqCHMrK0h5bE5qRUkDJU8xWryFYspoLZPsqA5KYF5dYbq/xxff/BwlZyrvUEFhkyaZjAz/KezY+LUUEoGTvOIClcjBKJmYVsNGDuX0UZSRjXEjS0GmZEXXdewdTEkp0ncDi0VLPXPMG0/OgaLEc3u9XkMphDDINLYxInetNTlEQozELHJwznn6Xqbp0YZUCoWEVcLks9aNxRGZzs5FQC9m8cFIpSBuGsLG10aYLblkuqEjhQyqEOKAUoWUy8iq1IiMu7DNdBJ5Fu3UFqSUEvZg30nz1DtHr3piGpg1U5bLBUWJD0OIIvu9kQwRH4wsn6s3TB+FyoqcNdZZurYV/2qtiSGN06Ru3DPUdiOyVkNR5JJFokaDH/0fUhTGTkoyseorLx7GQBmvq1ZqK+ccwoBAh8YY6IeegkyPxhxJJZFKYgji7xBG75SYR4AqSRhdWo6/5IKxjlIS+NHzx1gYpYBCiqQM1nooBe8cMSYyRaautchfNM0EVSAn8bP3lfgQqXFzNBhyDOQygqdKJL3x3JONzxonmkpKkUMAbQgxoNXY7Hea+aTCaEsYpfi1UuQo0isbooI1ZgxkMmTxTM9FJveLNlgnBBrjDIYkXkBKrrm2lsl0gkJAwjlp0heltkDvK01dKmIIxKFjuRrgfRl0IZdEomCsYnc+o+06urYTwk5W+EmN1dCWgIqFxlu6NDApir3ZDqEMrLs1/dBx+cpFmvq500qWEtJG38taNVqDskz3L+Iqz2xWY41hWltZj07TLldC+Jg1eN9grOW4XdANA7UzZAqL5THtsKaezkhdEixDgpTlsmO+M0PZTBgC1lU4a2nXS2EvWmGuKlNQWtiiKRaqLnFpNsOVmuOjJZ6Ol3Z2yKWwKglbAv3DQ0K/Yr5T810/+Ucpu/tQfQefzL+OjtJ0Xq1bVkMg9AsWdzqqpmG6s8/VS5cxKZBjoc8ZbzNd1zObVlw6mBO7HqUbdncr4lBQuG0CU3JGazPu+bIGM0X8rRSUmLFak2IS5REKueRxYkga5CUVNIWioSiRZnfGCXFjiOP0UGK9WrNhGEc1EoCEVUUe/XE00tzOOQr5QIP3noKhbXtSLJQyymQhDF1lDGgkiLdW1Ei+CY9Hg4kF8GWUui6kCp4cjDz6+Mpi9+nP5f+b5SxvtSkoq20wJ78XFi350Vdvj/PMZ2zfWQmzc39/j8VygdGav6//IfX6z7Aar/uTDlVYqwKjn5t+Fm0hxszzD9+PHiWD9Hgsavsd1Bk2uUJl+GDKfIpC04hiTKodzz1f+PGf7EVJQukz30/eayufP7LqrdH84i9c4OhQFFp2d2v+0r/ygHW7ppTNlJw0IXI+IxOLEtwYcQIlZCNrxbJD68LO7pTVas3ezmUKmYsXD/BVhSpw8eJFjo8PqZpaFC6yJuWOg/0DUIrj45NRGUSSrboy7F+9SBcf0HcimTSbzZjNdmR/zpFmUmGMJ5eEMwrjLN7PmL5/hn1xSXe7jJYshtW9lv135uRrR6Q00DSeqW2wY4KsSXjnGfo8KjlonK3QJNbrNc1shhoy2ow2Iilw4cIBpZSRnW9o2w6tIcWe5eKIYZDjNtYIuagUvPOAMIvJknDHGFh1Iu1lRmJY13d45+m6pRA9jZH9mEwIPd5XIzNW4hznapS21HVDShtWrHjsykSgk6RsEHnCjeyeNg3DMBBj5l+t/xI/5t/m+195hQvrA/7m8HcxWm3vqeeefYbKG4Yhb73WINNMJmemUGQiI4aBtm3lOBG5t5wyu/UOH/rgB/jEJz8l92cp/J3h5/hR8yN8T/gIaEVdN0KMKpDHSZK6mXD783eEbLTJsAv0uaPtWy5OrhBjppSBSOT9t19k0k848gtZwaVwYPf4l3/4L1L7KRmFHacsUzpN7DYKO0IwSts4T6ZDBlIWAhuMcVPJkE4lDzeNuTQmexuyntVG7ssiakinOZ3i+effj/Oa2Ef6rsN6izKak9Xf57Of+xWcc3JDG4XhRWaT76ck8UBsmpoYBrRWOGeoJ7UUgeJAjIHj44Uor6S0LSB17ZqcErcfrKhnhek0okwmRsVnP/sa73/xObS1Ep8jkzpd39N2HSkrHh4uSOUmzf3C4cMJpUDb9eSc2N/fRVE4epj4/Bf2eeaZy1grBDBtDRk4Wa4pjEV4a4ghUaySOH5sQqaUOVkuKRSa6Yyj4yVtH8m5kFKhH/0AN9doI8GWcyHn0wLv2WJwSqOfH5upASGbWWu21y0GURMqZDYymJKYiwS3UooQ0xMLx483jJ/097P/fnw6yyiN0qcSc5tjP/uarut4r4/Ne3+zE/jHi90bjP12xvCfXf8Ziem/AQzHJIZyco7h5xh+juHvguFf/vyNcww/x/BzDH+Pj98LDD/7XptzvFGp3Ew1frXPe7em+eZYz95Dm+cKKV/qaCLhCxv8ljqmAsXWc/fZAvUTDuGm1fzD2YTdvT1WyyVOad6Imae7d2nmj42TbbNMq3GvV7iYWK5axhBj29RRY13RWUtTOaxRWKOJShq86Efx+ydWP85O2qVX4turRmIbI47nLHvFZi+xRvOLV36eI/2QFAM/Xv4o33n43azX7djMOY17pJl3+lXUhtU3nts84nf8BvG7jPjtHsPv61cvEr8O/H7/+2e89OKS27c3E+6Ge/davvzOnKfP8Rv43fH7l/3H6YfwLYXff1Bz8GffBb/dO3+TBze/KPW58SbM/jIn1/7bDGUXpfiG8PvjtwY+OlfsNmIzmxL8zme/yPtefP53xe9pusEXb2W+dG+OUkoGNVNiZ2eGVooHx5lfeO0CzzxzGW/O8fvbBb/fe2NcaZyd0oWHkEBRSCGijEYVg1Y11iiGINOvqkApkUIiRmH/UMBrxzos+eKD29w9XpKzZaIc6xR5uF7x3LSi0Zp+6BhyJAeRNk+2AgPEiFaOWZXoD28TD56mmk7BKpyDud0HFZmpOXvK0zeF4i12UgMRbSqsM/QxYJQBm8mplSk+7WRakExSCq2zsK9LgdhDjhhraPsF3swp2uCdpYRINhZPQ8wDbXfM3vxZhtJyuF7h7Z7IlwygB020BXQhlIj3DcOypRqnaNsQiD7inMIEzZACQ9tDgk0hoxSRFR+GDp2hlCSa+AXWbStNTxIpJ3YnE7LKGC0NzdVqTewz2sgNk1Mkho627emDTPwqI5LjapzwLoDzDkIhJCECOOtkipGMQqNUxntpkMcQtxLC4vygICXxEQe8M2hV6PqWEDpyyOQyTgurQkljAKLFXzelzUabx8lqYeoVOSnEJMCUSyKkgjaAlgZzKVLMIcmk+2biYQjiY2KMRhmZqK+dI41BKUoxxEBGJky1Ev8YazVZFZx1sjayeDZIE9cSyWhnMEaN7BcJ7Pq+R1u50YtSW4abNG7luSIJJKCfhMeBUsJ4CsNGOnAjH6PJBZQqKJUJpbAeEnszYW5a40U23gjohWEYp07HwFMrkWlO8lqlhJFpjSWkAWXsOLUPXllKYbQWEFUArRWpZFQej6soCoZcMpPZhDhkIItFjRafFWNHTyOVR8BP5CJy52HoyBn25hXT0ZtdFQlIQ8qELjL0iWbSjLI7snUVoAsBHQYcsF4XjPWEmDC+Ybnu8M4Io6sIg6ukQtM09EPAGYN3NaEfMKOcfMiBPK55pcVLQ9tGmHzGYmyhSjV2onjYHtN3PUoLdMYQWa7WWKNwE4/NeSzYWRKKRKGuKqbOoUqhH2RS/RR6oK6maFNYtScM4QTnJgxRYZ1jr67wVU3JA3VtqJsK6y16p0GROVm0xCzAn3MmhIGhHfC1IaXCavWAMNxkdzalbipSLty5fcgwJC5d2RNChFcMcUChZI9EocZrrq18l2bmUc6wbHsuXrnIM82HeWm1oqod/WHLL//ix3hhf43uMs54eheZ7V7kgx/9KX7pn97g+Pgm06Zhb/oczeQuMfScLAK27vDGkUvizq232JtOSSnhG4+xhaauCF3CKsWQhVDUDyLVs1qucJUnhSCBXoGi5F7OpaAtJDJeqZH4FCl5lO1Hpv9F1qkS8sFkirGOPgxiopBEjl+CkIzCjF71gBKrCW/MWBjVqMIoyS73TMwZ7zzOSPCTgZgQRQhVSBt/mgIlKcqYyGkUOcVHisxf6+Pdg4JjSnmVUq4JceYrSttPfLff9eflTCFbAh9EAWIkY22krHJOuMfCkLM+NE96/Nr0Fqv1evw4xZfKLX7dfp4PxJfPHH/BWiMJUcpbJZOYE/98/k/BJlQxPH/0ImQJ1rVWnJ4CUf+wVrywSpHk2uXCNQVV5VFFZMU+8pElVgeGxEgU2hxFwfuKru1Aj4X5scqvS8FqhascXRv4jd/QfOQjepvAbRLwXPKYPAgGyndRQj5GmPMpJZqm5uD6VaBQe89sOqWZVKMkm5H7Y7UcfaoqcsmsFmtSbtGq4uHDQ+bdFKNq0MKcnk4rnO1ZDJG+76EU6qZCa0UzmeJyJMYWDfRrkTILFFJOeF9z8WCXL5clpYzeb73j6J+0uL8Y6XsJqjes8VIKRw8fcLIQtZSdnV2mk7mQlkqDsx4UTKfCBK/rmlIKk8mEnEdFCKWx1o9JdiLlgDayntbtaut3FZNME24HHBCCy8azzFcVzomPl7Ea50esKYWu7WiHNdPJDGUdzlVUvmE6ncMoh2mtJQyJGAO+qhiC2NM0TT0yj+Po1SaWKWEYMMbQNDP2di/yoQ9+EK3hH7tf5sHhA6wzUDTWFJ566ipvvfk6xlhmO7sMfU9VTVkulvTDwHPPPycEPK1Yt0seHj7g+rVnMFpjrOPo6Ijj/ngr84cChWG1XvML7T/hpy/+OG3bEkNAGZF8zAjO/O07f49Pv/4ZSaCQe0+NcobeOxSFSTOh6Iw3NW07ELPENDlFTLH8D577t/nBKz/IMGS0UYQoJMuNFBqMjTNrKSVtE+2U0pjwxUemQQDSIPY1oi60kegqaCCFRAzyPpvC2NaTC0XKAWcqlLZCTsrSaNRac+/hJ/jCF//e6Fc33r9FcfPWTX7rtz7BRz/yvSiEyIbKHB0ec//eHWLsGLqOo8NDSims1kuMkWLgxhNPa83RcsXrrxWsf5of/6n7FBLFWW7dvMu0mTPbsYAdpaOF7S7kLsPbb9+mD4VbN/eojOPCpV2W6yUxwt3bNU1loWSuXTGiHoQWgleGxWpFGBJtO3BvecLBwT5V5Vku16AkUW3XPbfvPOD+gxUR2Ye0glQUMfeEkMfkPG2LuZvkvK69JM7beHZUTBlDoTLuj3mUxyyl4KtKlKKKFLHKKP9XRpKlNXr7PTb78RMR6JGG8aN/P11Xp+x2MxpfxrixOxo/l7wtfj7p/d7ts88m+L+XzfCzD6UOyfm3KeU7f58x/LTZ/vuF4U7X1OEivT7mHMPPMfwcw88x/BzDzzH8Se/3bp/9e4XhX+29Nuv5Sd7gZx9nmwlf7TPONmzF4k/2qbqut/fhWfzevFYpqXfXdc3LyzWTsrnSZXsqX7eG1lnsiN9ZK37TaJ4da7PjkXKK34x1w/Fez5l/OG3AKP5IO+DXLUn6QGw8vjVsFTIP9neksZugHxaIFHL1CH5XwUqNpIiNpkKhlKxU7zxd2mCwHmfMZOjBanCV49fjL7H2LR9pv0eO9yx+j5afW/zOmylPOW85Z3JKTJqa698Afj94eEjbTVGqFvLcGfwO3wB+M+J3iom+d/ziP2n5S+f4/Z7wu+16Hh4+PMfv3yf87u59jAdv/OKZfQ0oihjWPLz3DubgqW8CfhvecM/y3/rBG0DmH3z6Iu+8c59Js/Me8Bs+f/viV+B3XZ/j95P+/u2C3++5MW7sjJwjDoXfvYgyhTCsULWTqXEnHg45CVdaji2KH0UZUFnAoVc9bz+8x91Fj80Vx/0xdb1HKgqLZWZrfD7muF2SB02eBEQdRdFMPaw6rDHsTmrcYo2KAx6PMhXGwrw0LCMoo5h7z716RVcKO0omfhVFJu9ShLGZqYhoPUOXjlV7B5NmUgzQAUpG6UxKAzkMIstbMiUnopZp8n65wE4UfUmEoUXFgvUVq7AmBMXuZILzFUZBMRmdQXlHCQNghUGHwUfLInf0qaN2mmJB54RKmVTiIxdclUTfdcSUZIozdXg3QWnDet1hK9n057Xj8HhB5zxKGXQuOKdp29VWbruUBKVglSZrxRAi7dCjlTBGjLE478golDI4L1O8KQ5QCsqOjKwirZuQIyVH8fk20kDPKcgG6ERqJCN+2yFEDLKZokTGvIy+7kZr4sY7YpT1zjmRSsaQ0AaULZSQKTpTN+KXMp3OOT5eECk4X5OzTN96J37AbdeeSoAYSxwGtDG4SryQ0WrL8ndWWHDOOVLucJUZfYBlIjXGJL7nykoTuIgHnrUycVpXlVww77fgsmmQu/F4Yow468CIzIYEq/JdRbZGJHLKIJJH0h4XH/GcThk3Q4is2jA260EbRzP1hNhRbMG7ilQSThu6rhPVAmNZxyBT+q5BW0PsZOK87wdMXW9LZVorMhlfeykSGfF6sNYSkrDxtLFobalr8bDWyPT9Zhd11hHTgEhwaCCIjIdyKJs5mM/wDmIp22Z8UQptFNYL40sBQ+rlmtUenQ2rdU9dFZzNeC9TJ91avJlVU6G1I2Mw2ov8jRE/nZwKfZA15mpHiglCFtn7lNm/cJFcMkfHx9y5d4vpbIfQCyno8GRFVorZfEZMieVqhasqKEoCjX6gsh5QpAzeK5HHTwMlG/Z2dtjf35f778z+77ylXa/pl2uKCuipJq8LrljS0DKohNIejQTk/apnp25o6pouDCxWLRevXGZSW/bmO6xO7iOekAWtMlXVcHTSMs0SGO1fmOKc4ejhCXVdo1Qm5oS2mmLkXNZ1zWwyZSCDs0zqhm7dMZ005BxQWlEBMQVy1/Lrv/SbHPzsn+LF3QV9Oebg+e/j0vPfx2c+dY+f+8//7yRuUDcThhLwfpcQjoGOF65fpe8C3lf0oWN1ssT4Sq7VWCA9Pj5iVu1ifEUOmRSFhOWripAiaC3kppHQYoyGEkRFoTAqRYwEFefIQfYxKeZuQFnuv5zKOEUurE1AVDVSGZmrspuVHMc9w497gx3fU433isJp8XZPodAPnXjJj032XGQiPWUwiB1CKiJdb60hlohS7xmu39NjkxSdIeTx7gXzr/0hLHVQI/EnxSSKK6WQkkhxxRgwCTZuAlsS7DagUWyczZRSfGxym0/bO+SwCawyrnbc7m7zQngJi0yFaBil14axsM+WFW+No489s2ktPkO9YE8ZiUZiH6HJSIB+82DKU4drIdsU2NWanbmnXWW0suR8TEgZ+bIZpRwhJnamF/nsp1+gG97hg995C4XeTpxVjafqwFeOVbvit397hraRl19uR3bqaYOhFCno5ZLH4Fhx6q+jZFhPOawZ0Mqwe/2q4ChKvOqtRSvFl99+m9lsRuUrQh+Z78yACTo4nv34RzgJCW02LYHEbDah0FNVDdY1NJMpVS0eaH3oIRfW6x6lB4YwMGkmowSWIaPY2d0Bs0Apwbu+Dxy9ccTBPUW1p+mWnRCcVKHvelHcaYVMtlwumc93KDmxv7dPToI3TVNhnUUZgxppebmkLZFv0kzGwollOttBId5WQxhQRNarFU3dUIoaCWpybHMt5zqmYYw9LBotiSFKiHQ5UU8apjs7QtZMmVLELkFrhTZ+xOGA807sa9qWlAa8rwlDpJnMaSYzuq4lhEBV1dS1Jo2WKkqLRc9xbPlbn//7I1tdfq604s69ezz94p8U2T+tCCFgDSwWhQuXLuJchTKJqqrwzYSLl58ihH57W/vac5gXfPG11yklj40vhasqPv6JT/DWy29y6dIlIFNipB8CtrH8v978u/x7n/mPWIeVYHKWFSqJWuH/t/Pz/Hf5N1HKkBP0Q6TtBnbiDm5Ysbe3y7915V/jT3/Pn2axWFCAHMSuxTkv9+GmKDiu26Sy2CKkQEmi8qSsObP2IQ1SYEklCyFwIy+HxFo553GiQO79vh8kNsuFgmLaTGVfUlBSIiSJBZs68+qrf4379x+ilCHl8T5EUdUr3nzzF3n+2Wfp2o51u+Le/Vvcu3+TYeiwxtKuW5pmwtD35CIeoQqDrhyuquj6lknV8P4XrxPSZT77qWPIIhP20vsMzilCKBiTCSGIolNh64P20ovXKSiqypGC4Mx81hBiZAhh9PWTRmDOmWUfqKuGlAYK0LaRd955m739XWKCtO5ZnCzGqaHxvtKWNiRi7M/kpwqNJaZeim1jDgGMRS8pJA5DoBRRjjp9zqhuNRJUrTE4a8bJirD1NrPOMoy+fUKwFqa904b+zPTC2SLwhmj6pGbs6XMLRoMqij5unqe3RRqQpus38tjE4k9KyJ/kifaNPgTDIzHeO1Oo+K8ew0Oy/GJ6gZ8ub3wVDFfUasIvT944x/BzDD/H8HMMB84x/BzD//Bi+CYHT9ta7FeXUH+vhf7N83LOGDMqmJQsAzpnSGsb/E4yRUChoJ3h/Si+Mzw6sAGQtCI7j8qj4uaI3/cmDZ/sAx9t+80RnMHvsP1OOSfQ8HZV06eeBxd3+TOrFtWHR/A7jYp7KiWIgUsX56iiuHt0RE5gVHkMv/MpfjPit2nZueJ5/YOf4IXf/gjtA9kr9Uh8r2pPpe0pfu9/HN17Xm5flv1RNgv02DjaNMlzFtVNo/UY1SgZ0foG8HsIjl/9+EdEIvsx/OabgN+M+D30gdfeOOL2PcXuOX5/Vfz+1fpT/INP/QLDEB/B73eOb/OnXvjj2OzO8ZvfO/ye+cidT/4HLE8OuTxXaFU46QzdYEB1fPFXf4mXf+TFbxp+/40vPgOlcJIz7/+APsfvP8T4/Z4r7RpPzgtSD35ek3RFIVJQlCxT4jGANTJ1S4aS5Pcy1ixNz/urEw5XA1M8WSV0KeLVoKDYDqXnYGrmgCfja2FmxVCIKWBSJLc9rtbYumBQOJ0ZkiJ2Ld45ai1TwPtuAuYB6zhg9BylIMaevhNP5RyjsMNTpthMTguIHd1qiVGWejIh5igSwkqjjGGIcoPkoScXPzLdEpqI8jVVhsEZVA4ct2vaIRMnimIsORRIIteglGLaTFi2QRoiYcBqy1Q7jvsWnxQmJIaSBTzKo8yJOAw4LbLkapzqrOoKbcSDbRgS6+WSoV3hjKbrZQJ0bz7l/uEDnM2s+xUoTUoRVUSKrhTZBJw1xJApJZNVpG/FPy0n8dVASVNHZPwy3olUTD/IJH4x0sS1zkgRo4/orElJmnlaCQOrriaQs5AO1OhdUQp2RJGcRDY75gRpPAdFpt+NEmWCpq5ZrlrW7ZoYAzkHvBuboMbSD5EUI5PplOVqKRINSt57GAaqSUPbtbImRq8dYww2idxE3dQoQCe5qawxZDLWGzIOhZLJ0Bhpqpqq8WhdWJ6sKGNTralqkfAYPTIYG+PDyNBJOaGVJsoSETkUwDlDHAHJWUcJEiTEmMjKkVVEG5F+ljWi8E6YYzkllosl6IKvHbEkvLOEnAkxMcRMH9YEpXBOpI2GMIhkSZGQbxscAjEE6rrGOLWVeAlBAlqtNDEnUoK+L5AjIYzyHmpkKG028byRN1JkBlQuFCw5DexNG0qKY2MRSoQYpWlZVCamJDIgBdquZd139MMw+jxPCP0xfT9Ig1crJk0jpBRtWK9WONeQdCHGga7rUUqmz1NKOHvqMZRCoqobHh4+JMdEVmVkOWpyUpAzs+mUe4fH9H2gbVvxiepHIkdJOJ2JueDqina95jA5PJpGTVHG45oddnafxlT19r4uwI07N4nLNX23YnawQ1h1pKDZv7TLKx9+P9pkui4SswSiqmi8cTTNjN3Sku2EG3fv89KzV7G+RlmLM5mcNMbUFDLWncpraachZ4yyWGNQKuG9Jw4DhcKQE6VrCbGgfYXVmgcPH+CKwVQWTGC96pn4KUO/wkTPjQdf4h/801/h/R98hWvXXsa9PeP1v/+3+Myn/wH7e5k6G44e3qekyP7eRVAw39lHaYt1InEU+x5rhSnZR2kkp5xJMbHuO0y0HB0umM0m7O/M0GSGvmNoE6YRG4NcRHJmU1nVgo7EkvGVyIkVTv0fNwXdQpH71ZkR6E8BVXxWZM9NOY77uQTm0qSXBNc6TSJBVjg/IRdRfkj9IMSqlNBWisCqZJQBsuxLOUWxylCFnMRT6THy3Nf0eFKgUIrI1Dwa5JxOfT369/f0KY88X51u1xJolyIS9lZvmdfWWkwZy+ZKbZ97Oh1fHnn7bBXKaCpnadtWJO9L4WPq1/lB/T4u5qd5oIRQI5NfstcqNkV+kYLyjaNphD2aSWOhWkGSIsJ2Zq3AbmGbTCsFk0nNwf4OC7OmnjQ0zcn2+0ryrHjn7RdYnVxHq8wzz16l8ffoB1kXMcOHXi7cfPsiTd3gq4qu73numVto3hRLDcqIx3Lsm8ZE+fLT5EWD0XqbvCvg5GSBWQ1M6gmHD4+IufDU9adopjUpJ7quY3dnn92dXZQyTPZqwJJyYu+1yxx+vmCNKK8oJZJK/rolXfTs7Fyg67tHJLbW65aq8hjjaCYTdkePvMnEiadYyuxeuIQzdwVTlSKkyPTOHtN/WnPpLzfYq4Z1u6LvWybXZqOcW0eKkeVqCUpIIX2MpBCJMTAEIarlITCdTomjJFrJoprTrZegRN1lucgiGzVKfsXYE0NgGDqayYSYMmGIFOJo3WKxVmxElEqkIKz3nZ09tKkIMeFcRd3UpBgluSuSVA5hoPJCamvbjtnMkosQ88qgMNZjrUcrUcPwvsEYTylil5ODJDFGWxb2hP/ozf8Ln3v4OZw12+S3FPiVf/5r/HH/L/DRj3w3XT8wnSluvfMmt+/c5eKly3Rti/NifaOVou8CpWQ0Cucd89mM/+3f+Pd5sPsAbUYFFy0WJPfu3eVXj36VP//n/zxhCPT9wGQy4Te++An+nd/5d1FaMZtPMEYTQyQMUSxjnGUxnIBLtN2akkRR56MfeYV/b+d/iXeO69evs7Mz5+T4iAIYI35pcntLwiRyf3KsIURSCmNCq0YmNLhsiQwjCXeUmxzjilSE/ayQPTrGOKoXDeL9tiXbCb4w3unGbHz0ZC0ZA8fHhtde/QFu3LhBVdcSkxrFdDIhxsjBwS5vvvVFKJskdMCaiqihmcywbsZ8PuH+/bvkYUBrK/6ApRe1npS3bO5hSNTVLmSoPYSUaLsWjR6fJ4UHrTWTyYTlcsXe3o78zCiJ03PBuYr79++PBQCFdxV9L9MmMWa60m/v4ZgCO7s7tO2K42PL3u4OvvL4yjOEyO07R9y5/VDsbSo/NkITKUWZyDCinFTXImc5DIGNX9rGz0+hxsKsGffSPEq3QckF7bQoMpFx2ozelloUkkICihTgRsKscUqUp4pYLZ31Iftq08kb3BOpUk3XDWMBVopaW+yHr/o+3+jjG50++1bGcF8yPxXfkOI2T8ZwjeECz5Ltl/5QY/g8z+mSIZ9j+DmGn2P4OYafY/gfCgx/L/h95tnja762z3y8WSGfgawmpYhRSPgbyecNfpci62szPWiVwpTC9kyOh3bDGj5Xexn+OYPfqYh+pxonOlFyj8r09ga/pfGttd7it5nUI36LnaIeJatfyvAAxU+HyP0uYiYV7qSFUrAW9nanj+L3ot6eL6U02QTeeflVVi/dRavM/e+acvGXP0A/ZIqCmBQfUh/i5tOvPorfzSX05zSF0+MWu1K28ccNdYNF3kOZOUadDv2cnCxYf534/eXXLvP5zxfMiN9aiVrrU9ctl74B/L404nc6g9+37+zxi/+05r/5lxtm5/j9rvj9C6/9Irfu3PwK/P65B/+IP3b5p/jBqz94jt+/x/j9X9z4SW7cuMFf+KGBxiU+cWfK7dXe7wl+21rw++Acv//Q4/d7b4xXmiEV+mGFC1PM1GKYoa0kqSpYco4Y40dtepkQz6GAyySd0CgerNcMUaNcxjkDvSHFQNGZoYuUfAlfzVDGU9IxpYjnRAmJ1EV0UeicCAPsTGbSLMzSQMzWojH4MZiokqUy0Mde0mSlxqnDQCkRVSJkJXLtPpJTS+wjQ3+Xvk3sqmsYVxOHiMGTVUGrKD5krlC0MFDSMGBNj60b+qjxlWe5/DK3jyIhicRvP+yR+oSKETW+To1MJzasqQxGOXI/gLJko3HWii+FerTUMZk0lLIk5rRt7BjnGGJgsVhSeSvsP6W4dGGPe4dHHB4fc/XKJS7sX+Tk5C6LKDczWuR/IZGCTI8bI43rMPQMfRBBdGWovJXmEbK7WeSm6XqRkzZaU7JIBBcyMUVyES/vgoIim+DQBZQRGeNYIqoUYgiUmFGlyKRqkQ1WpFeEdWO0GSW9i0x9F5EdT1FkIqyrRtZLQRlQZjOVOfotIDegMpoUpYFKkUlmikjU5yLvreOGEVnQxqBLhbUKraHPLTGmUZLDMHQtlZXNK4YIKlHX9cgANJQiHis5iEa61sL4SjHJNH5KMhVeNKUIKIUh4Zys15QCYDFONs2UE8shMaQCKkMUb/chKGpTUVIgpZG9hSIMiXoma63ve4aQiUk8M0wzkUn0mDhcL9nb2WXo+hEcAzvzuWz0Snya9bgQjREWXYyRXLJMw46bWop5lF2R7yekiiKs1CKg1A8DttJgNF3bszP3VFYTk9r6yJTttcnoBEqfynBYYyVwL/KdSAIA9aQRVlTOdP0g8vAjocU6Wb99PxBDIqWBqpKp7mKExeZtRdd1dF0PY8KSKFS+JqVRGihr2pMlJSdc5YUJOxJLNj44+9OKxjkoBa9GCXubaMPA4d0HXHh2j7p25Ki3N7cAhzBYJ7MZqmhC22Fsja0d3isqJ5PH9eQCQ98S+x5vDNYUKl+hTwp37x/z0rPXWK3XhJBoqil9HihqwFmHs3PiOCntvCOlgjOiaqG0xnvPOkbZd7SiKE0fB0Lbo5bSQB9UJi0PwR+Dhr1Zg6sn9OqEKirufPaTnLz5RTAVGMOuhu7wHquwRzCI0gUtR8f3me/sYF1FzgVb1awWR8Q4UHlZy+RMPyTQsr/uzGcMMfPMiy9w+8ZNUoaUA01dY0y3bfrLdZGEjCJcu5CDsF2VEAKs1mDsqE6hSTmKKkQpuHE6fMNC2wQClExBU0aCSEqRlDJGO8TTUgJJNKSSaFctyjhKysRhAKIoYqREyXHkoRg0wsQemWU4IyzOXIQQ8PU+nhQQqLHZbq0VMos8k1N++Nf8KV/xmWVD6DqT4G/OozEiq+O1gWHz0U/+bKWEfGS03noN7ezMCWEghITzlmdbxRUKD5Uap9pknzVai9WBElsNpRS7uzP2d3cxWhHHY9dK0ZQLrNVdAksUkFLmUhdIVtjRxip2dibMJg07s4ZhvO5aa5E/y5mdnX3y8AL7+yLhavQub70R2bvwWZqZWGR88EMLiB9EF1nPxs4h1Lz6O5kPfMfbo8/beCWKHFsuwKsfRJ3sIeGMBK1C6nFcONghhUxV1ShjeHDvHlevXEdpxkRxTtv27O8fkHPB6EIIgcPDY9pWZNGULmgjcq/p6Z5yRaxr6mZC37eI0kmFMeLVBSKfBaOqS5H31ErjvWNnPuXBw+MxgYUQE+nTHj9MOYoP0KrgnGfdBmwErS1FwcGFywxhwBojMm8uCZM8J7yvaOoJqZziut4or3gnsrcU1uvVKAFlsU5ww3k3sq3FZynnRF3viP9kUcSUaeopbdujTIVVBWMrhtAR44CvRAElRIk7RPXFY4tgyia47/thJGhNKSWglGMIiRgHjNUi76vMuN9blLFCaNOaT9//HT529Mnt2jVWk2LEeU/Xrfid3/kUH/7wh+m6FSkldnZ3me3sslwuGfqA934k1Vn6rhO2s5Wk5+bNm1z95C4Xn/8IpUBde1CF2WzCxO4wn8954403pIEznzMMPe3dFX/0zo/w9rV3uJVvU0rCakUomTKqXf3W/+7X+eyf/QwXLl6i73qctfiq4tKli5RS+LVf+1Ws0Xzo5Q/jnMN5L8l2TNJsK5KU5zN/9NhI0iND3WjNkBMhRYZh2BYBN4m1UnKu+qHfMtVzSVLEM5aSZWIm5LSVJUzjmjF2nDQYBtZr2Yx++qf+GDEKa1prQ0EmChaLBSfHx8x35hzsXySmnhA7To5PWCxX7Mx3STkynVQc7F9i3a6lMaYUYehoW5mYOApH9EOPNppJUzMMgdVyTVVVtOO+13U9G3nJ2Ww2FlFP99AUxR5JK0sIcVS6EbuPfgig9Khq5MXTsGSWyyWXLl8QGbY4JedM2/YcHh1jfcVy1XHz5j0WJy3Kmm1i7cdiTwgRrUUuzlo7ynKacZomjwz1vE3kN4muMafs801BRGtECrGqJObte3KShHwDWUIczY80f59UYP5qDylsynMmk5rVut++Zhvj/x5MdH8zH9/uGF5U4o754u85hp9Bzm9JDE+f/jAcHUg8eo7h5xh+juHnGH6O4X/gMfyr4bf3otD4jWH3o5+xOSelfOU5fxy/tdakNDY4y2lTfXyn7Wuc81LPG9/nLH6LRy3berTSesRvhdGijPoofs/Z352fwW+xMcm58D0pc6UPPFsKP7/quOAsBxfm6NcNs1nNSy89TYnpFL+jKHhKY76wc6Uhf8cx+80MKJj9nupu+v+z92e/tq3peR/2+9rRzGY1uzldNawqik0VzUaS1TiwJUNyE1EykDhBAuQqQOIbAwGCBEGuk5sg+RdyEQTwnWAHsRpLJC3btNhJNCmWqlis/pw63W5WN5vRfG0u3rHW3ufUOcXDKjIQqTWAg7P32mvOMeaY3/iet3ne52H+cgWM4Pflz8BffvZB/F5d87X0Nj/x9T8va6kIRt9dG5Wvqz9gV38aVTcfwG/7I+D35Ufgd86FT39q5pUfAb9/9mf2vPK44e13jotSqeD3733ZE8KK3T1+/5Hxu/um5ZvXX+Mv/J1f+FcKv3/zN36Dr57/2cXvog0//5l7/L7H7z/54xM3xqUR1TPUp8zXR1brDamIVLI2EOMkwFe8fJELQOmqqCqTSiDFwGGYUcaQdKWpnpW3jDcHjIwJokOk6plMYg4TjW6JaSIOA75Kc8YoRRwKAVBraXaQKzFnGuNxrSKFgKVjaz2uagoZkUVHzoNMgZacsDVQyKjaUMoVOc7Ei2ccE2xf+wyhFhpnlwJBpSpPVsLmIRSmaWB/vOGBFulhUuDmMHN5k8hhxqiZeX/EFVClMM1HVvUEVRTKzuLbPSuKipArcyokDbYaCvJQLU7dgDyQZ+cb9sNEyoGSE0obqjYY3zCNIzWKdLxve2kq6kKqhXmOgMLZhsZ79vuJmBOpKGIJi/yCPFzWetrVit1uxzyPi+TKIqOtNLUoYskYIz7MInVSFtbRspll8Ya+Xe/W+qVuIiyjGCMxzmgj09/SCFdLYJCwyHmcb6ilYowj1YRzjkoWP/QYORyHxas3492KECNNIzI+ZUGOyq2sXWV/s8N6j7dWJjeXeLQqtTSy5UH13qK0NH1TLDSupZLRTQtUyuLpd7tpTdNEmBPasJAapKBT1Ytg89ZbbgoBbSw5FwGInEiLbL42solVbmU8HBXDYZwYQ+Y4JWKtFG7ZmQqrDMc50buGtrU8Oj+l5LLIS0MIQUgDSuN8w8WzC1zbYIxFV0WYg8jJGIMq8lyXkkQGhnpXGMmpYOwyzbEwv5QV3wmjRWbEWEuqFW3t4rmXyemF51GqGW0sqlYOUdhTP/b6GxirKcgkbsmZzfoUUOx310tj26EQQodaAkKj9B3rNqRILgXr3J1EyM3hhpIDm+0pKSc0mvV6zXW8xlqLc25RNrBM08Q4BQGVUrBOWIwKLaxFXdG2YLUXGXGlePvpBau253x7wm6/Y5wTVQmjr1iLQtG3K6pzbFeWVbeiX1m++IXPM4dI5gXIlJzZPX2H9WaFMi3TNGKdGJOEeaYoBbpyctJxc0xo5dlue+Yx4lpHpyu1TqCtBCI10/menCLWiS89qi5+MJZSZM/EqkUBAmpdFAlQpFLEI/6WPZszu0uRnTx5IOtrfi5AevLgHN0bmqbl9HzFk/2OPFwS9zPZtjzVkRZYGUtqNcqCVg2lznTrHqNbpsMeTEVZTdO1lJioWc47z3FRvqjM40jIFWU8D84fYDRgEnOKFKOoWZ5ZVKUmBQvhJJXCYZqpRhQJjFbkIhPfoDFamLq300ppSqScQb/wmDJKEXOglBds7FIkAa0Lm9caA0aTayHlivGVECZiLDRGkbM8bxiF1QZtLFUZVM0ShCN4U9VC6HqJ9ffDHB9mpNeF/CQSO79O07xCCD9+h3F/vMcH/WhSjGid8L5FKcWI5b/kDf4j3oGqyIuUzkszXwC87Q78C/9sCQoVzpmFtQjeCdtcLUV8pSWJvf2z0fou+DdGs9/tUAvz8ZatmPWGg/5ZNN8FDneNgJxF3QNGaDzjq+ecnZ2AKpycP8N318QszDVrVnz9qz+JJjFPCWMa0tTQ2B/nZPs2U7pGG0uIB37mZ5/y5nc+z3a7JYdEmB1f+LG/zOOHe55fXi/3bSFpGcM8Jf559z/w4/YneJReBcS7yBq9kMcS+92O1XrNpu/xTtZ/0zY8efK+nCcXXnn1Md5bvPc8ePc1nv/TRGVcgn/5HJnMrAd6q5iD7P9dJ4QjY9ziLyZNh9sCS84RrR2giSlQKTx4cMbzi0tKNVgt63eaZ4nVugZqpqpKVWJZAwprDdY6VusTcs60XWKeJh4+OuNb3/g6jW9ZrbYc50HigNu9c0m0u3YNVRQ+5mliu90So5C35inQb7aM4wy54lxL358Sw8Qv/dIv8cUv/jSPH79K1zXkbEkpC5vYNTSIf5oxWqwe5oAuhXGaKCWScyKEeFdo6vuecRD2uDbyjE/TREzLBMIib3frERUW76UHu3P+j/E/pVk1bNZr3FJQ6LqO/nMdnel4+uQppVa8s2LtsPjgdX1/J9ObS7pjIN/a0Xz+85/n//F//b+jFGhtlumNuDSFEOuRRR1jHEe0tvz8F3+Wf+sv/FXGOnG1v2CcRuZpIsSMsYa2beh+vKNrOmoRy4nrw4HTs1NpZgE//7M/d0c4zDkx7fbkJEnu7fXdnnO1Wt0RByuVphPpQKVk7yhZrE6GYWC32/Hqq68uybmwu+c53DUL1+sVzri7RLVpZdJgvYEUw8JQV7jlGnrWDMcDw/HIOMqExoMHD2jbDvFYC3SdxJ8F6DZrSl1RS2GzfcRwHAjjxG5/Qc6Vx6+8wTSOHPZ7nLPsDzuOxyPTFGjaHq0NTeOJKbDZNJRSaPse2zguL685PT1lmiaccxyPt0UxfyeJWatmvdqiteFwGBYMKmzWa3KpDONMCDINW2tlnmd5/TjStC27YcC7hikGLi4nQhwoi0KXcw7XtiKVHRMgkxlSTEl4a9hsN+wPB3nvaV7IkpJW3vqdvWCEK2rJWGNkukhD0zQyMVSWAqq1Qr5TLyw0bhnptyTF22fm5ePFdNRHF59rraRc0Snz8IFI143j+H2/88McH37ty8Xnj/r5D3vcY/gnw/Co/hoNNwQu/pXE8F/ff50fT3+eR/Uew+8x/B7D7zH8HsPhzz6G/yD8zrnQtjKQIae4bRj80Kf7vnO9/OcYA1pxh99wO6knqp3DOAC3nt9yPVEr/n7ruVP9/BB+u2UKnWX69Pvx29wpTb7A77jgt5xLngdZF58uBbVYex6OMw8enWG15vx0zelJD0VsT07eeQ3/9DXicl67ha//hd/6IH5vZt79t77CwydfYnwmtcdwU/iZ7/xV3vzZL7/Abzvzhf/glMdXpzy/2IFmqTtbme7NkfW6xQ6iZKkwy97/w+G3856bd1/jv/+nifISftcKiozWA/ZHwO9+PfH40Slvvb0jL/iteIHfq3v8/rOD321LV/t7/L7H73v8/hHx+5Oblo4RZ8Q3lVJBWfzKk8KIMS25HlHaUJCJaqMyqiRS1aikMS5xuX/O8TCjSkNTDTZrVlh2aUDlln69ghzIKWK8pXWeEiIhTYThgCqgKlhbUKUSj4HpeEOjT1BOGNLYQs4idIvx+KoxyIYsmF3IcUQpkZquqeLIlJRRWWONaOlrJ1IeJY5o3RBSRDlLKYZaAmmcqfsgE8DO0tgNcZgonccqi/EVCJThwPn5Y3SaabQW1lZOxDihfUeu4I3CGEWdAyVbYiwUWwADuaK0xtkXQY5SCusdcR9JJWCNZoaFHRUpeaZmYUEBKGPQCxMnZ5H+LRS6tmHVrXh6cYXKiWkITPMkzJeU0DFjokhAKKNRqpJKgKLIZZm8VmqZCi/LIpRJR63FX6Xy8jSsiDZUEmYB+1JFMlgpaVJRufPyqLHA0oA1yhLSTLXiZVFzxDqR3zgcDozTRCqVxjm09jRemGc3uz3b7ZqmaZgX2fKYEm3boY0hl0qYA8bKPZKGO9RScN7gvMFaIwx8C3MYsQZQWiY4lfg02LYFFEUpqtYvWJPKCGkByClhnEyU1mWC2jnHNE2gpDGeU7m7n2lpCOaF5TdMM5fHkfSy9HCRCe5aIVLJqXCYZ1b9mq5vGI8HSixcXe8pIeEaz+nZGdc3RyEAAHVZY8M4st70MmWLsAJLydSa6Vf9MmlvZMJ1kUlxtsEYUWJQRt3J0YeYMcrgLYQYMdqCTpTKInsohZsQ5bM1XvPwbEsa9mgNxjhircxRJM+ttThrCEsA0bYtcZZJ4lum1zRP0twFYbgt3vXGWozWTNPEHBLWWYZBWGGbzYYYI3WRw74NBIyzxBCW5qrI5GuWf1eVYRjYdCv2+yOb9RqjLIfjEaU11jlSDPiTNVlphv2e3jl8zozKoq3ltG2wdsU0F47jc269rUvJWJWBQpiO1JqpSNB99fySt95+Rs6RR48f8uWvfINPv/4qP/2FNyh5JoVM7bdc7d/FGM0cRrTu8FpYes6Lh7xSllIiioo3FrXcL5YGcVaVWArWOqxamrwxE1Jks1qz7nshLmiFUZ7Ydjx9/pTDsOfpxQXedxwPe0ouHMfIbvEJX68aPv3pV1AOUbSo4m+jTIf34tNutCFOM43RTKEwLwoLqhRSiKRcwMjz5Yxj2O15eHZKyEESK2tJJUkQt6wjyBhnKFTGEKlKvKFENl4KrrkU8VSvBosoWdRa0cbKFHctsp/WQkWmi8R1QaGqXuT9K2XxAk+53E0IiaxQQpwOClU7YcdU+QygSKmCzmhVBUdTQSF7lVua5vlHKHZ/OGh5wSavlBLo+/+SUn6RnH/67ucf8S4f8+4/6Lq+/9+0EbsHYTtDKROX/u/zu/kv88VaaYokNncyTSiKqnzTXDLmgK5gnWO6DQKVupOGg1sfGSErpFxQBape7BgQ5mMMkYOalkkSYbwmpXlPf5otZyieyedVCJlsCQi//OiEq3VLyomYjpzZZ6QcAAk6v/PN14nB3GFILZGr/ZH1qqFrf4I8/XNKqUsSdMODR4YwK3IS9RBq4fVXH3Kz28u1vxTgXT33PHz0V1n/gqb8VqbURaGlwm6/Y3X0nD98TIyB/eFI14qMU6GIAkLJfOELnyfnyHGIHL8C6u9GdlfHBaMk8M2lMLVH/uCVr/GTxy+QUXRdt7BSG7xvsNZxOB7kNbWitWWz2S7BtV6IIjBPkzwbC7lDGcUwjjz91Use/0dbjscJ6wxt1zEOB5yzjNOwrFFF27bMi+XF82eXnD94JCSuEGh8uxSWlkKMKkzjTNu0pBwpaJp+TaqaXEU1xPoVOds7spH3lt//6lf4xjf/gO9855tYV9kfrnj77XcoGX7hF/5NnGtRykhzQxdqCcSUUEpY0ForYsziX2ssXbemLHupb4TYIqzdurDTDTll2qYVdq93d+xrrTSf+8zn+ck/91OUcqu6stzTLNMYzouyRoqJrvVUtbB/l8YRVFKKGC02L3khK4ptiFvIi1W8exHVCu8bmsbTLgoVbdtgvBQgtLFM8wzV8OrZZ+6eOcELKcaUIrtTyoXNdiOxybJnaL1MFCCTonlR3JB0XZK22/2m70XirZSCb1vBK/kUhDjLPm2kaNN1PevVRvbppag2z/L93/ogp1SIYbxLYnPJyzOvibmw2myAxS9QSSJprOHh44dCKoyR9WqFUkLKM84Swow2lnmemeYRY6zEYQqMlhila3ueP3uGb5o7ecrLy0u0gWkOhHni9OyMprfUXLDGM4fA88srTpYCi8QjLAQ2RduuuLnZkZLIwl1d3XAcJkqB4XhcpGINJydb4m7PNAWu93umQfY5YbIXGp+xTnN1fcU4Bg41stvtORwipVS6rpXYcZqpRfYkicELzjgMFrwUPCCzXTUY65imhnGYGKZRiKy1AoW29aSY0EYvBaaFWFtZikl5IViK+hVaofLSJFWyj5cs6/fjIOiW8PpRuPVykhxj4up6R/qQ+sptc/X2935Qcv/hn/1hv/PHdfzrgOEoxaX60TD8ff1ZtjxAccEfN4Z/6lOv8Obbu3sMv8fwewy/x/B7DL/H8E98/GD8rndS0rd2jh/+fB91rbfHD7pnHz5uJcudsy/h96LgyvIMToG2lQnC22nDb2jFkEUu+6Pw+5lzTFrTLpOFt+8r+F0/Ar8zB6WW5uBif7JgtOC/XP9ncuYr33uOWmxCtydrmUTNhXhMnH13Q5qloauV4juf/z3i6koaVB/A78Qbn37Em1fPKbWiMahnHQ94lcD4Ar9t5PXXHnNzcxS1UaOX2AFSO/IL//6f4+pN+PWX8JsFv/d/RPx++5tv8f/+z77ExdWIXgZQbidRu/bI6698jeFHwO9/9tuv8vzi3Tv8rqVQF/z+1V+95H9yj9/3+H2P3/f4fY/fHzg++cR4ihQv8t65amquFKUoVZp/2qxJacDUkVAyre8hHMjKY7L4jj/f3VCKLGBbFVUVtLJ0FuLVDduznnnc4dwWtEOZSBoDVWVqCRTM4uwqyXYshZurZ5z7FY32Mv1nMjo5SonUquiMp+SI1hZlCmVOlDiC8VilSczkGKg64HSFUqgsLLZamMMR4y3Gii53TpU677m+fp/5vRvaboPeNMumK4tJKU2pEVMVvXGcdhbPjEdTcVjrqDGQnUEpT4mZxjb4emAeFaaK3r81FlXl4dT2JbahghiLyHQvDD1rDM66xbi+EkJi01lqyTx7fkmMkc4G4jyhrWGeMylFGmvpnKVtNUaDd45cDblIAHU8DmijsMaTc1yawdIgpBq0XXx5qWhlUbUg3hPIpq4tJadlI6kYA1oVmdA3It+ttV2YS1BrEQ/qxRc41YoDSJEUZqzRtE3L7nCDrw3TGBiOE41vsQgrUWtHShN9Y1n1nlrFl+Hp82cYY2l8I4yntmOcJpwTaWgN4uVrLcfjkRAjbdeQUqRzPUmLJLyxnpSi/FlbtLa0TpNrReVEay2kKJLai4+4RcBNL958KRXxH88JrerSFPRg4gKaMtk/TJE4T6QEQyhkFHWZgpBQkEXaXKbXS4E5B2otFApaJSgy6a6dQTvH7jgyzxONb0jKiK+xFpA+1RtimHGNxjaKkhSocsfSE09qRwxRQLUuga26nZyVDXZ/HBgOR5R3d3uI1pqcKrogk8AlUrCoUuhbWHWe/aCYxwjWYW0LStGvV6QQFoaSbNL7wxFnrHxfRoFGGvlV5PClqS/KBSgr5BAjbEnxARcJnuuLS9qupWpFKuLR4ZyTz2mMyKRHqGVivdmgsqIWRecaUhX5em9FNmcMI9MY8I1HG8XueERrg9GGMY5U7VBVc/F8h28hVQGbVddxKyGitaFbn4qPfRGWWpoyU5p559kFb753jdGa96/f5maG8O4FT66PKBpSDjRdz7sXF7xytqakCZVblNUo7bHKoVHkGIGEXeTltFVUsW0XZQoNqkqiVkuBUvBO5I+Md4QcWfkV8xzYbLfMMTPNE/1mxWoKvPfeU+YQ2Zydcgg3VK2ECIRnDIEHqxMUcHLWUEtG2RbXNKhcSSGhppmYFl+WWvEW5mHG6MVfskSmrBgPE48+/QhdK3mONN5TskKrEawT8krhjg1blNgqVLUUEEuhGEOmUPUSuBoIIQlRQBtSSWgLJQqRqpSMXrzAa1EoJdJLEpgH6hJEVK2ZU8JZJdeXpElvWk0OUViYjZU9QylUrcSQZJ83emEiJ6gZq8QupNQfXkr9Dsdr/UAAo5Qm58zhcEDrf4oxX0I8cD4qsKjLjvNDsvrgLiBWSjFN0zLtVnmiI/+gfo1v5b/Gf8z3lheo24smUflt8x41CtbFmKjUxYtKwvY3tWbS6i6Yq9wWH6Au5J1FcAywC2niBZM/ac13GsdPFkufl3uEJBpqDqAUv/LZV3nlTGwIlB7Zbt9nd5CkuW0a3njtMZdXG+ZYaJ3BO8cwC9vzvXc/hfE7mv4bco3mgrOzgfffWeOcRxs4HGd+73c9/Ubk3ljqA6VkPvPpT3PYPOZy9R6/+ztf46/mv45aEpLVasPJtmccZqwTpZIQIqVENr7hZndgnGbW6y1d1zB/VaH/0ZqyE6UfOc3CEFX1rlHRNC2pipqCtYamaZZCjjCGlWrIKdM0YmHiveBl32+4uLjm6vKKxntiFh9VozVKwfyPFd1nz0hfigszWWGtp9RC3wuLN8eZQxg5jAe++pWv8c1vfIOf+dIX+bmf+zfEs22/Y9WvuE3sShFlmLEI8z7lzGa7AjTzPNK2q2VNaUosUOGb3/w2v/Ir/4TNpudLX/wZUk5cPL9GYdmuNwzHkdXKYq0UCcbxwDzOOO9YrbdUJCEfhgmUYbVqKMKAIRfou05sEHKm8e4u+D8/24pk2HhkGmcpeHhJ+orSTCHdsX2NE1UXciTlSNUV7xt862X/VLKq5bHMaG2oNSzPhqZtG24LXoAQDmum8S1oRWs0apkkUEqjyOSsaLwUN3IqOOeXpo88PzVLwUsk9BQxZWGm69tGz0I0q+J9ZZa8Aa3vPpck5zLxoJbCRdO0hBAW0p5MTsR5Ji+KMFppMvI678S6Bq0wxmK1/oDvVUqJnG5Jmoj6C+LDV4Gu62h8wy2juqREyUnsSJZYpe83KGMQu5aJeRqAwnQc5fPHTGMtzy6fsVqvWK3WTNNITJqHjx8R5pHLi8vlZzPGKprWUys8e3ZBypkYAn6RY4wJnj69wjnLcDjyLF1gnafUyjRKcu29fO6r6x3znKSIgSLHhDaWq+sdORemEEEZ+vUJKURylsnZYZzp8EIy047pGJhDxTrDZt1JYWyU4tE8B7zzSxHVUanEUNHK4ZxYWxhjhNluHcfjQN93oga0JNoyXaxo2+bue/beEkJiWppu3jvatmEcZ1LKd4m71lKUlK3wBfb8IHb6R2LPUgRQSjGO00f+jlmkIF/GhNtzfNx5Xv75hxP0P6kG+Z91DG/rv7oY/s73PsNwVD8yht+sntL+83MhTt5jOPcYfo/h9xh+j+E/EHv+jGD4x+O3DKs0jb/ztP2o1/4ohX+tZbIb+D78lj1HVDzfU5VvK8VnliZ6KZXfsoZcpMH7Ufj9NRRf0ppu+XxyL+X5r7VSDWK5yMfjt1YaZesiBZz5ttK8aw27fYJ3nogUsIKUZG9Qo2H73VfYKZFKvsPvbfho/P7SVxmKo/m9c6m1PHGc3Tzm/dWbL/D7EPm9/p/R21fu/HhZapvrz3oOnzvy8ydHfutD+J3SF2mawDhcfCL8/vJXFb/yTxqeX0xSbF/Oc4vf+k8AvzUv8PuX/+vKv/83Rpqmvcfve/y+x+97/L7H7+X4xI1x4x15mQrW9pZxUCkEypzRvkHlQJlnvDXMw0C4vqTbPKTqzBATzy72OHPCXAtTSFirgcy695SrS1Z1gtLj3Yq5TijdUOooE4DLF6yVls3XyQRuyZlp3KONwa9aYioYlRfp6kyP5WiyJIxVGpXGebRppIk7DqR5oBZLUeJZYZxjtTohxgHyCp1nhnlGYUnjc1SYYR5RHFDV07oNE9A2nrmIJ3qpGm0UD7cnrGpG5YmV0UxFkSjEmjBZsVptmfwVLmastjgL5VYyV2mUKqCg628BRb7s47BHVfElU8zS1HINKVfCNJFipPOOGkd6b2m2a7R2MokcIqkksoJjGKmqcnN9IGeRJzmOI77xC4vR4Hwrm2pJi9+ubKQhBOIUF6ajJicJmm4ldHRN4lkQE961whBD/BlKKRIcVQW1gLzibnGXlIRBVws5BzlvTtSS8KalsY7GNgQtftvON3TeU1Jino7EOGF1z2F/FD9hLVLwt57ixhlSEjl87z3cPUDC8JfgIlGqwrmWWqBpW2rJizS7xjphdzpvl0l88X+2LwWQKiWMMQurLgmLTct5jFHkGGSiIBdCiIzTgLFm8dkopKqYQyHETKwiMa8ywoCrcq8VvJhMrZCzZ7cLbE8Kq3ZNWxLVRGLU3BwPQBV5F98SCswhQZaCWYyZeQz0XUPbsDC1QFEpOaDxKCO+FLcbrFkCdWMs2jqcb1GHmbwE1WS5NmUc1AxZ7l/RhhIiNSdO+zWHmxuRxMlyrkZ5nPGEEAnTKMGHQmSQcqTWSNe0VKUXVQSxZzBWiA4JML55EdxU6FY92shUNwrirQd5TqSUpBAH4i/tZLI6x8TuMIBStFYxFUvIE+89vcb6HgukHGi7llXbMQwjuVaqUrjWo2vFVIVVoJLm9dcf8sqrG1xjuLh8gtIypX6319oWbQzb1ZphPNKebpmfXfPme0+5PI6oqhDag2EIE1fHCarBO0W7P/Lq6QknjUwwG9tSUqCmQiwT1mls49BYnJcASCsjKh9WAq+SC8boF94uKIqTey+eMWDajsZ2uG5DLEeavmG16Vi3HWVOvHd5QSriO7Ve9+ScaFvHOB6Ze8/ZakOjHMOcicPE6bpQY4ScGeeRMY6kkEEZSl4mwBV0jeH9q4gqEPLE588eEJ/uIV0yz5pwy5JURSwStME6zZwitUKqCqPAO72wZ80yvF0X5pysY4wWMlRW5BTvfL+1MmhlyXUCFh+WokkVSWYwi694wWqFUUaUFBJCqqpSRCxVEQoYtDDxqsYtyaR8VgN6ee+YKGlG6/JHQ/eXjg9Ly+i7wFndsQZrfQ+l/hvg3/mhz/ODDmM1zv4eWv8BKWVizMveCyVXlHqX3+fv8Xfr3+HvxHfoFxiswH/uv8ZxGOkaD1pLgq0NdWFS1lK4QdEbYZ8f9J7/xv0y/2H6OyyjX6AUtYB3FuM11hRmN+JCL3mpKfy6/2f8Z6d7/k/PWkxIrFPCV5hz5esadNMzTpEURv7df++K51dZguYUUXQch8BuN9B2nmkSW4fxODGOE8fhyGd+7BX65nvkEqlF8+zimt2uR2vFOEyUqrm5eYO2v+KzX7gCEikZUnBcXf0803zN73319/nu2SX24Pk3ys9wpk6Z5iO/8Vtf4Utf/CmO45HGd6w2a2rO/O7vfIU3v/suP/1Tn6eUxJNnA1e/nfjC4TVqzUKMUnUJL6Qp0XjHVDVTLHjvF7ZoZhgGjHESGzgJrNumEdJgjszzQOMs3/jKH/D812YeuTfIIWINNN4vVh2KsR341ub3ecwjYqqkGIHKk/feIuXEw0evcnr6gMPxyLe/9TZ/7+//Y85ON2y2b/Hk6XvM08x2u6Hven7sc59nsz1BaUvX9oQwcbU7MqeB3/nd32ccJv7yX/4LHPZH1psN+/0ekYzSuMbzt/7238K7RqS5Fgb2yckJ4zAyjCO+7UixoIvI5rkFO51tCPMMSu5R262XpDIusYCE13ohOcYoZDqF4h/+V3+fhw/O+bHPfZ5aK3OYOR4OPH70WAhcSljuxpjFfqRilBdiT0HY6EqTQWKIJTZs2/alqQJJVhWLWlCV/cpYB8YI+YosVi1a4jqRBBSLjXmel+8ejLbYxi5KNhG1xCLGirKG9yKDJklUFTb8UmwwzkpzKs4cjzON94QwQYWmaXHOME4TylhcIwRMpSpxHheZPpEqTDkRphnr3CKpLCoeZvHgSqlQc6FQSUnwPIQASLEvzIG+73HWLwUldVeATClJDLcUAWMKIjFmNTknYkhcXV3hvOG/+9X/lre/9z222y2f//zn0Fpxc3PD2dkZJ9sNz58/55VXXuHtt99kGPfsd0cOh8OdqkXTNMzzCEoxHCUJLUXIZcZYjsNImCN93zEOI9ZJDBJzomkbphCJIXNxdUOMlVceP8QbxTFG2qZlGAa0dlgtu+c8DkssYNBOo+tCbM2VvmmYh8Cqa9huOpwzpJRZda2oTMUJ6/wyFSOTFU+eX/Pk6TVKV7quQZnKzW7PPBdu/c1YSH/aWEpMqKoIIVFrflE4yYJzISTmOeCck2LrS4pIdxJuS4HGGcHwcksoA7x1pFq+D+NePmoty/8/GpuErJo+kFjfTkrd/vvdlMPHFK1vf0/O8/2s9h+1yP6vA4bvUKy0Qf2riuH/0vyxYfj7D36Tnzx+6R7D7zH8HsPvMfwew/+MY/gnwW/IzLM0Wv8kjvYl2VyR5/0gfotyZeaiwjfSxKmzrF+6xmGYfiB+q2U4SQYLNYOuOM1S55UiZS11wW+DMyLfq40M12gjzc9gNdddwy8bwyFnaklc34hVXeNfwu/v/M94nqaloRtQp4FjPH48fjdf5jOf+0n67z4kj3KuZ8+u2a0PH8Tvz3yd9skFn33605AryQZSN3P1V99muj7yL7/6+zx+8Jvsj19ijn8JpTzOf5Pf+d1v8zNf+olPhN+//TsDF1e/IOviQ/httMJ7R/4R8Pv3v/oVfv03Rqz7HCVE3Ifw27mJy6s9r7362j1+3+P3PX7f4/c9fi/HJ26Mp1QWFrfG2hbnWvE4LhlTEtAwTs8Yn808fuU1YPEzziKdfbW74vrqwPpkRS2VGGbSxmG1JsdEaxVGe8Z5IsWRnCdMjGgdOdwcyQvzRim9NBsyunqs1aR5xyHPrMyraOcoJJn8iwMMgWAz07SjdWu0akQ2mYK1LaWV5skULsklyEOuLdVZYWMoqPOeWiyhVuq8Q+dM61u683NCrOyPB7QRqQeDLJaQKzUXGlupcQRbaK2wmIwWed7D7oZplClVcsKXCjlRU6JokZ5JVaS155TvFkmtFacKNQfiNIuEvBYmUIyJYTiScmGaJh6fbmm8IdcCxpFSodTEHKLo/SPN1FK1NOKNyFkM43jHNqolQn3B3geF846iFEaLn0WKIgOutMZqQ4ozpSzTBcbKJGUVBkgI811zXSt196RUoRZiFul3keUWaXxKwTeOaZ7oug6jRL4mTBGlNavNmsPumu12zWG/o20c7733LjEWWKaArbFQKtoYhnFAaWHZyBQ8pJpo2h4ozMdBpAJdQ8nSVLNWoYxbGDZuYbeIuoC1Vlg5CigiQ61qvts8chYWTC3SFI4xYlSFqkgxMg4TtnE8fPSY05MHvPnmt9ntLihU+m7NnA4is1yEta+o0parMjleKyIRXSuVRCiVd95/wmdef8gwzYQ08733rnFtQ9f6RYrHEEPEGEVKEecsKSeZwsZQFvUDapHgV5tlTUhDPpdE0zR3hA21KAcYY7m5ESntVhviEjBX6qK+YInzjMZjXWSeJx6dbhgOB+aQqAXWqw7vPf3JhrzbY2uzTKjLVETf9/hF/iZm8QzynWcax5fkWhRovXw2j9YC3o33WGsZpiN1kazPIaFKwVRFSRXrNDVlQjgwzxnrLI9OTrm5eMbFzY7etpxtTjjMEWUqcZghVfTy3qoKk/b66gqvFSd9TzGBVDWFwNnmhOF6z8a15JfsBqDSNKCVYR4DJhmmODNe3uBU5tHpGlsVcxiEEWbk+1i1PW3vgYw2jtfeeIy3lcN8pI4TKke801gsfWPo+p6cErnmZYZI4bwHJuZhojiLc41c1yKh4hpRsEhxFjJK45nngZwTJ6dnoArH457Ot6z6nmwtjU1YpdntbnDeYyzEnNmNAzfHPUY7qIp33voe682K43AELaoIJ8YNkAABAABJREFUIYptw3q7RpmGGGamOBGmwGbV8fDkAU++8S1yiDTrLdbNjPNikcEi/6NkFD6ljLaLekGtlCQT4vMcUJqlOS1T203T3nkx6aVBLftmBaMpWUGVKXFhWy8+7EpTs+zR1iwMO6UoWS9qBxlNEhYmVXxgqsgv5ZwpNYuaAhVTZG/MKDKAbyh8fDDwhx1/WEAgQUdB68gL65jbAOXl137SwsDLif3t/r4n5f8Pacq3W8bim3PrTaXRZsfv80s49Tk+V69QWjBkb2c2XY9CibqHlgmvUsE3jchgaYUq8r384/U/JLqJr8Wv8Pny51ir1ULeUZyedQxhYHu64VfzL/M3v/t3sNbwu91v8zsnv4Vzmv/bF15nDoF/92rPa+PM3hiurOUwDaTrQsmRN99UvPOOwThPDJWLp59nu9mIcsBCENvtjyhEmeF4GHn+7DHX159ls9mhjeL5k5H9/jnG6CVJ6djvj1xefprz8y2bE82Td1a8/T3DG68lSkz82Ouv8alXX+fi5j2+rHec/Nqn2annHG9G3nzzCc4aVusZ4yzf+va3+eY3v4NzltVmy+XVNe++/xzTd4w/8Yz97kBFcxwmhqOwvPuuxawzw/vPONn0NE1H03Z07ZqnT96jaVsenJ/jF7+5EAJU8a2rtTIZxZu//Q4b94Cbzz7hOAw0jYe+k2emwsXPvsuP2U/x7jtv07Y9zjn2hxu+/o2vM00jP/7nklhwGEXfef723/4PyWni1dces7u+IufK+dkDzEIifP/99zk9e8CTp89ovMc5IeH81m/+JpeXV1xePuVv/I2/zs3NFdZ6rq9v2G5PePTwdWqVBK5tW47HI9ZaYc3mwnq9xhhH3wnO1ZqEFIZIib1Ye1kwX2lW/UqIikYLebNU3IILMQUuLi4wxrBab8k5s95sWK+3tG3Ls6fPeHRycve83iYCt/uMd4sXWKnkmvFNQ6RyO/Fx65V2e4QwU4s8bM7ZJSEMlCr72TTPIq1V6h1TF8Aae1cM0NoQYwD1QWauqhpVXzB7bz3E8pIQa9QSE6m7JNp7Ry1J/IJLIYSZmDS+7SQWqxXrG+ZxIMbI4XDAOYdSIiX4smVCBcGKWiUWTJEwz8SUaJzHe39377z3dF13d19jFPWjsiRrOWesk/gglxeJY4zx7jqaxvLs+RMePzrn/GwrXnVxYJwGvPOEcOS7333CcTjw/pPvcX11tRQMKofDHpSi7zopPi4EWrVY6Git6PuOWoWcaLQl50LbdUtCafCt51ZiupaJs5MTDscRvUyXpBQZhiOlFpxRQhxsW8AuhRpH2zWEkJbJHYNSsFo1pBRoGvF31LriXMVYxXq7IWcpsoQ5M4fM1fWeimKaIofDkdPTLcMwE2NitVrJPUyFMM8oYzHLuhSpwrokwJmUFqxc7tEtFhij75LxGNOSvEux0BqD0kXInMs6jIv824eZ45+cya4+wFR/+ed3CPYR7/3hc3xSVvsPe9xj+J81DFf3GH6P4fcYfo/h9xj+rwGGfxL8lv8++LMPv/aPck8+/JqUCzElUvx4/JYhnsJ/pxW/WSv/Y2QfjEazaZtPgN8yEPOm9/zGquGvXd7wShElQsFvveB3ZHt6ypPdzKN5wlpLMIrvdT1f3bQcVyvaEFDzzDQFjKmcnPZM88D1gt/v6ndoOKNtLH+w/jpPfv7rgt9z/Hj8fuVdrn/qwObiXPA7fo/9xeUH8XvccfmTF5w/3LBRJzzZvsnbzbd5g8eU8YP4fTg+58u/d4U177PfHT8xfj84v6Dvtzx77qlohg/h92adefIj4Pe/+PKX2axOaD/bL9aRnq7vMFoaXD//s+9Syz1+3+P3PX7f4/c9fr98fHKPcYBcaJuOmg2lKowzMMikn+4N43xFCIZxjJgO8WGoIhf9/OIpFEeeJ0KtOK0IKeGtp2/XdKsLQjhi21OUArv4eo/TjhgiOYofQl58aKkiHBZCpbCHMGGann57jjLSsA1VGl1OVXKcqBiqEy8OXRRZRWKpmDIx7N6FHDl/8Fm09qQmYKpMW8bxSDVbTKNJqoAqGO2p1pDrkcvra7wttN5gvTDppiCTsTVPYBxKWYwFkwMGjTOG/XTJ9cUVbatROdBbz6gDaWGOlVpIJFItXF/vufWeqbXSOigpyeZSskzxU1FWmkpt1/Hs2XNef3TOet0Rc+bZ5TW9dazWHU3TMVzdoKiM48hxnMVPJUjzc5oDzkrzVCHB1G1jPpeCpUFVkV42zuIXpkkIQZhdWOwyoV4Qj13nW0RpRWO1ouZKKlWmoJcGuTEGuzzEKScBvRjQiPS10jLJKvdCiBIlF+ZxoO9axvFImCdiiEvTS5rbSimM0jhjmeZJSAtNS991qArzOGIXj50UAjkF2s6hqzTnlTHkVLBG33nrSTOrUinEJMDgrV2+E2mW61JIpVAWP2WtFqnlCjkLEMYovsS1GvaHA+vNlpOTDdc3e4ZxQllF13qGecaBNMJRaP2iKV4ArauAJAprLIdh4s23npIzVJWw3uG8WwIGQ1lYYFOYKUtztbI0AJUoMsSQcE789oyW7SJFARGRD0rCRqv1jmEUYuR4GHBak0NAo/CNE7nyWggpUo0S7+Q5s9ms8cYSpomYMmVhDk1A2lU2p6eMx4FwHDgOR7quR9XbpmSFJSC4ZRTVRc4/5Qy10nQdzsi1l5wXdqz4dlgj64clcJAASzxr9DIBbCmsH54zhplcwSrNcRy4Pkz03Yq2aagxMY7ie1NzwVpLzpVN13G67kkhsOlOmecjJ1vLyeYB0168fVKa7wBAKcV0HFBElIH9ccdhDExplH3RKHQxNG1/9z1Z12Csx2SFNw3ZdBjTMB9uyDViFChraFYdxstUf6lwHAZAmJKt68im4puGktMiW5lxWlQRcqp02xXH4UCpYgMQ5pGSC9MQOX3wiBRmhuOItw3ee672+yWotKxXK5xzeG9oV2sub66xSpPjTJwD61XLYdjRrzekUuhWPa3t2O12+K5B3Urv58p4HNgZoPRs20YCK1tRGIydybEKa1kpWfss0k1ZGMnkQi1C4kAbKklkjIrCK6gxk8utz47ApHOaEGbCHPGNplZFTnl5Dg11kW6ivpgipyoyWbDSqmWdiV95rYIT1rfklGRNpluf+0IxC5BbsTqgQP1IadRPfrzMVL89bgMJY4R1mnN5KYD4w873UUV3XvrZB1nv4u8kckry97L4Auk71RE591P+ZX3C1xsPyLN0ul2xRiwo5HtdlEq0E7WSrPmt7tdYqRXOW2Z/pHvo+HX7T3iq3qMvLfv9gLWKzemKi7duSBcHWiK/1P1Dmq7lG/5rdNphlEZR8c7wL37sdX67CBZppVjVQh1m+r7lf/hnlufPX6dtW7QunD+w7HZ7Li6u8N6y2WxwznF5+YzVasVq1XJ5eUHJW96rJzivWfU9xswYoyW5VYX1psVby/XFA66vJFF4/LigyPSdZ7PxHMaZ9fYx7757yT/2/19edQ+wl5pvfOMtTk7XPDjfsFqtqKXwmc9+irZtOBz35BQ5OzulnimemW8zTwHftBx3B77z3Tc5PTklhpnz8y1d8Tx9+h4hJHyz4uryhj/4gz/gtdde5Y03XqPtxF+s73pyLhwOe9Li8fW+eZdvfvqrnJ2e8fTZUx4/eshnP/spWt8CmnO/5lvf+jpd19E1nUhsectf+Df/Iu+9/S4pzMQwEGvhsL+i9Zp9iFw+f0bTeE5OTvCu4Xg8cjgcWa3X5BJF6UYgge16zd/+xb9J12+5urrm5OThIveWePDgTJQbSiSlwn6/Y54nbpnXxnica3n27H2OxyOvvvYp2rZf4ggj+4U2KGXo+4ZaBeNTSmLnYg1KayFxda2okdRKLfD48Su89trrd0TCgpwTbZhCvMM1SUoiOUe0NksSJc+n1cLe3u93Mh3YNB8oqAmhMN89723bLfxDfZeEaK3xrqEujPWUEs4J4a+kJPsUoNRCYFzeVyklCfRd4hTv9rCUJRlHiTKSMovsWKnUKqzsYRgopbBarYTlbizaiC9YyZIv3CY9L9R28kIuerFvpSTxoXgZC9Zb6xa2tPzONIkdyW0yL5ZHZXmvSgyRtJyvVClEOOfuPmsIgRgiqkqB47333oaamcZRGkVkYhg47K9RSqTKak04a9mebHjrre/hvWe9WRFCoO0aQAokwzCgtMY5SY6VlmnYzWbFbn8gxIjXns1W7G1SzgzHo7DotebBgy1dJ2pHWiseP3q4SK+JPZBWiq5rF1m2GW8txhliCFij0dpRKzSNW647A5Za8xKPCHLGHKBIzHh9PTAOM9uTU+KcmKdICBL3P3zwgCkEwhxeUvfKsCihSMFIsLOUusTBwqJnkWh7GZuUUjKFjMJasxT06iL7x0sx54eQ549YOP4kyTfwkWvw4973j6MR/oPe+x7D7zH8HsPvMfwew+8x/B7D//Rg+CfBb2lI/ODre/n9Pu73boeYbr8XWFRXtfoE+L1cl7X8gz8CfhujsFrxndbz36/XdA9P+DUDr2vHv7M7EseZf241m9MtF2+9T7o48N+uOk4OI39FGf5563lvu8JZjV/w+/zkIekl/KYUxlv8fvhrbD7/EO89b/bf4MR3nwy/H13w3sPvvsDvoD4av9/4LtfLQM3jcvYx+P2btM1Xad0Drv4I+H16doY113f4vfsI/K4/An6nFHn86FucnV5+JH6be/y+x+97/L7H73v8/r7jEzfGS55IIXA47NCpZfVQwGo43NDXBrOFGjJxOjIdGnrT46ylkqhKs58nMi1TVYxLc3ucZzrjaV3L6fljxOVZkVOgqEwkMByuGfZQqyNXmT5MKeGsE1aJUdSsCPNM0w+ksKJdd9QcZfLOGGwJ1HhAWYtSDlCkOVCdQpvK9bNvk4YbrOrQDyuxGhSL93LNpFywKpCHAkEmjnOOKKMpk8WqF43SmjMhTIxzwhTNyjZ4ZyCLJ7hWlhJmYtZUnTCm4rUnlAlHS0dhrgqdC2XZpGLKS0N5+dIBnWfxyEXLNHYWv27nhJWjtGEfg0wRK8Pl9SX7/Z7T9ZqELC5dLZUsjUDrsTozhYDWIqsz54Fa3cLaEWlzYw3ayBSxKoWCAmQK2rcN2mrGcaQW8XIWdnnCepGlFkkOQ4yZXAs5J5FwXhZ7rdLctdpgq4ZSMQtTpS6bTwiRgma3ePJsNxtSClALh+sbpnEkpcRqtUYZS8yRkgvZaOZ5oO06aSQqxXA40C0eK2GO1A7G4UDbOvG1z8tEezGUWhnnmbZtl6ZYofFOvOqUxiqNYpn0XGJRszBzbiUpVK1kZFI1zNIUL0W8FXQppJp487tv8dqr55ycbIT1pQrrXibXc81kNLG+mB6/XRNquXeNNTivmIpizoGcFE1nsMvGVyvEFHDGEcJMyiKhgZJvUykwTqON/F8Zja7ikWftLSNUL3IzoFQFRCJeKcUUA5fXVxgrEisi3ZRJUb5jXQqlZOrSxEYZ5nlG5co8R4oC1XbEccJ4T1jWntKavl8t6yeyWvUcy0COiRQThxBp2xbjGpTR5CpSNNTCPE20viHFxKwm+k1PYz0xzISQxF4Bi4pJ/FOKSODHVKlo+lWDbxturmG7WnGZjyRtSBWmKTBNgWo13ihyLJQqEjEnvSgZrNdrpjTy2o99ms984SfRNmNtxhlYn5zdgZEWnX0KA43tWJ2c4LvC06Romg6VElRFqeLxXqmgNJ3z9J3HWsV+FCKLb3vqeKTvGiqFOUZUkcnpdBxFgmnV0PgOpSxNt4Gc6HtNUZVQIioXVuse067AenzTo5Wwy5quJ6fM+aplHEfSOLLbXdNttpydnmC0IqZECJkUFRcXF/jG8+DxYywWozUhj7jG8eDhOYf9DuOFCBPGGRJsT07QzlDCiLaWlOD0ZMNn3niA1pZUEyVUnK30xjPHAozUHFFKgzGUXMXnu0a8dcwp4nwn0v9q8fNeQNQos1hhiJx+LomchMxTa5GJ9zhBEQ9PpSSoTgvDsda03B9ALQSYIuxsY4WEYa2jFkXOlZzSXRCk4E69QitLRl5Xl71E1w9FHz/k8TITVoKOha1pG1LyfPKJsj/s977/3+1ic2CtZZpmUhJvePEqE7ywVp5vazUhJLpuseGoamFSOoz1dyQjhUYrx2X7Pnm7QQFrC5utJ5cN3zt8i5OTnvqoEMbMWVyLbNp4xKwqT195m1IrZZ7puhVaFZwz5AzjOGGMwltRocg5Ya1htz9gjGW9boUApTVXVztAsVqtaRq/yEAZtifyLGitKLEyTzOr9YaSRd2lbdslkCukNIsSxhzYHSZCCHRdh/eOqWS886QShBioNCcnHf/2/+hncV5xPESmEDg732IshMXWZt07fONY9R1pDneyWhrF+SsPSSmy7i0/8efeYLfbsz8cGYYjxikuLi/Ybk5Jaea11895/PgvYZRmGI7EMHIMgbe+801CThhtef78QooIrzzmlVfO8U0D6pzT0y3Pnj1lu14DcHJ2xsnpZgl0xSbg+vIGbx2bzYaUIu+98zbWWryTJL/1jmEY6boe7xxN43BuS4hxWccFZxXr9QOokcNuppbIZtXR9ytSmokxME+TJHuuIc4R6y1N4+8SwGmaqHVisz7njdc/xf6wZ73ZAuL5Zoyh71d3LNoYI30v04ySAE2Yhe3cdh05vyAVSuGrQhVfMmMtRknxqpTCZ3/ssy8IX8hzOU0zOWc2qw12iTOPhwPdqkelF4W1eZ5ISZjZ1rg7yURrLNM0IX5RRpRhFka5YNwL5u/xuOf9d9/jC5//PNpYUpb9QRu5RrVc07jEWHohONZShJGvJV7Ui9cZVGJOlJQJYeZ4PFBr5cGDBzRNI/elFuIcmBbfqVpvpRYdq9WKGCPe++UzqKWAJ8+cWxj1tVZa31KyYL5SihgCfdst0nD5rvg4z6KyNE0DaklcUxa/t1IyuRSM1gzTiFbqTnZOG8urr7zK8bBjOB7p+545SJKcc2YcRsbhSNt4Ui3EEDg52WKMJi9KIrf3pu97ai3kXHDWLXGS5DEVhXMbclkv9xhWqy2Hw5G29SJfWSohRprGLHsHKCQ32mw2S7wpe6rSFecFk+IU6LqWkBI1V0KY8YtM2+E4Yq1f7pMjxhmFkIDneeJW3rPrGvreczkcWa061quO8/MNpVT2xxeyeKtVzzBP8hmdX/KITM4VZx2+s4Qwo0DkCSt331GtLIWgerc2heV/m8wvgLKoFH0cFP2gBPk24b71w/uof3/5/3fX8aF//7jXfdS1/HEd9xh+j+H3GH6P4fcYfo/h9xj+pw/DPx6/7ffJyX6S9/kBv/F9f7fW/Ynh9z9pTjnfbgjA2lU2W89F2fL7h4mbH3uEqoXrObON80v43fP0lQf8VzlzHScedv6PhN/7B3tppml7j9/3+H2P3/f4fY/f3OP3x13LJzk+cWM8lyCNKm1wrRPd/zoTpmtWzRvUkjnZPsYe34c8UJPINU9xZiyF62PkOA2s2g3adVQlUgOmQgoJs+6pSYzt5zijSkLFwDwNDAdNtRatM37xNxEwrwI8RqOK4rB7BtrTrRpSEpkEbQ02QYo3ROXw5lSatSqQo0Z7w3rdMZdAjQ6zBCrOeGLJoEQKPJdEmEb0GFCbllqDyBOkjK4abx0YLU19YE4iSf1wtWI8XODaDlxDCovEQimkPKG0SHxr25GKpzOJYIVFEmOi1IrRGmNffFVKKeIwMIeZsEwtziGhm4T1DZv1VnzCnef6eodWhXEacd7hGgs1EYNIeYzTSF3eX2WFcwvDxxqapsVYyzCOCGFBNhHjHWhpapMLxlpqSeSkheGkCtZ58ZooGaPAopmnGee0NB4R9hJKGJIK7jYXmaw0Mv2cZYoXa1Bo0IpUs3hCF5GOWXc918cbdhd7SpX3MkqJr4NWaGPRVdG1vZAZqgCBsJ08qIQ2sG46huMgn7215JKZpgHnPPM8ynS80dSSSSXKxKd15BTIuWDbHrKQCowzhGlm1TYYiYCYQ2A8DmSjmcZAiIVcpbk2hQBK/D6GYcKaa9arNTkn5iBS5p23TKVCgVQqVmkqFQuUW9KEEuhU2mCNpnEt05SENUYlye4twBzCQjYwuMWfxGrxD88l4/sOBQJ8RaT9Q5jR2kIVT3nlBKjt7TR/LlxcXpM1otqQA7ZKIOOtpSSxLqAWsUdY5IuUsZha0TpJExK5L+MUOHnQob3I0cdxptYqfjamLg3zinEalMItEvHOO1LJtL5hOA7McaZxXvaEJSkoi09MikkavlrUEHIIso6LRvuGECLbfk2ZAnl5tpum5QTPfn/Ee4f1DTFF5iDyP7paahFLgk3nGYcjm67FKJGxOqRA6xVYy+4wvBS0FdquwZoNKYn0zXDcYZ1n1XhCnAFRHlBV5GCc1aw6z3a7pqaZ4801KvUS1Kx7TBH58jAH2vUGoxuymgQoq6Eq8ZeJaE43a0pJoMCURKoZ37bkqheZFU0MFescKUHTrgGFsYkxR2EWpkRVWZrTtaBUIefA+fk5xjkomkePHjPPA9o5rFHYledzb/wk85hpveWdt79NYzzDfo82J8xz5bA7QNGcnnT0veGwi6JAECOwQWlZ20VoTUBB1QJVZGj6lWPT91zlirJ6sQMIlJBQ1qPQ4ve+BK9lkTbKWYrBzhvmMN1Jn+tb+XQkJogpwS1Za9nHlDWyJ6nFAkFpapE9IseM9aIsoACjDSknebdYMBpSidSlM15/RN+xl4OMW3UFZ82dBJpWr6L1X/vIAOWDxw+aMvv4w+hvUXNhjonsbmWpLG3niCHS+A6QYkGwmrbxnG5F1nQhPdL1Lc7ou+QohMA4Bpx3KGQiCwRL9ruRp0/2XDy/of3JT3F60rLqFKUkHj88oVLIKdE0HdoqUlpjtahttG3DME6Mw8xtMtbaBq01x+NAilFwrxa6Tq4758r2ZE3OmRgCtQgBzXoniY3yhFhIpXIcBozW3Moa3clrLdMCORdiEHJXiIHhZlwSCGG31poxurJZd2gF63XDyQk8fvWEzVqklJx1sqZiFCm8MJFiFLJHTsQUiGkipSiqEDlSgXkeub654pXuVVarFVBIMbC7mei6lvPzB7StJBohGk5P3lhYzhbjvsj77z3h4cMHpBwYxxFnDa++8gqH/Y6ua+VeUPCtJyXN6ckJ4zjSth7v5BnTptL1LX0nSZmOldPTLcYKzpSS2e2uaZuGtvHElJjGI12/opaZw/6KMCX6vmGadhjTMU+VGGdKScQo1gbWig9dCIGzs3NyKmzWK4kLcJIcWo9zDWmZtvjGt77DP/mvf4X/5H/zv6XrO5rG8/b3vscv/8ovY6zhF//WL4qqidGkmEURx2gh4WjNHALaiFywqlWIW/NM6xtZa87eJfvCnpYkNEwzwzAwjROt98s67RjHiZQKXddLMrzIBuacwVQhGoWZpmkBGMdZEpGFpJgWNSDvLN6u2fz4j2OtBWNxKGIMwjzOkTjPwsKvUHLCKEvOEe8bUk64RUIvlyXGK4V5nsSnyxjOH5zTdT2g0ArGcSSmAHVRBFISQzrvKIg0m0KS2dvilfOeUjIllLtrn6aJaZzQSokc33CkaTt845mDeKKpyl0hQit9VxTIi8KL7IkGo8VSJs6BppGC4TzPvP/kXSEGq8rDhw8ZhiNzEMJw4xzdWUOM4a5gAEe6rmOaJlIW0moIQb6j5bm/TVZTiuRchXSKqJXI5MRq8WhTNI1DsxDnSiHniFmS6FqFXGmiFELSQpIV9SJNCJn333+OVpo33ngoLPQQWa/W1Fpw1uKbDdY6UsqLjdHiK3kYabwj54RWlU9/6jWmeUSbwunJmtPTFUYbvvf2OygUTdtScmWa5rsi1DCMWGvuCr8xhYVoppcJEoGVXKoo0tS6ENSEmV5qEf6tUhij0Cyyaz8kKfyjkvVPwjL/o7zmo2TeftTjHsPvMfwew+8x/B7D7zH8HsP/9GH4H4bfRmuUdcT0g23TftCk+Eec9e5PerF7+5PC70ThoCT2cB+J3x3b1cfj9yale/zmHr/v8fsev+/x+x6/P+r4/wd+f+LGuPEOi6Nv1oTZMseZWgZKiiRb0KWgzIb+JFFTRBtpGvim5enNc7JuMaZyfXFBe3pKY8TLADViUuB08wqZTJpk/P8YR8ruwOXFnuubAgS2JxvGcqRdryk5ME0yla2dRneJUgLT4TkpnKCMwylF1QmrFClMpDphmkxe/GJVlXE8057TKMt8OBBrkk3AGNBQDyIloZotOU/iAWvEJ7xi0TbTGKR57TcQd8wp4LTHmEyrIqFGlFuLX2yo0ECrCzplYlKkkiHDnA+kNKOpVG/Ic0Zj8L7B+XAXDCmlaGwrU42lii+0bdFLU9NoT4kHpmni3XffZbv+HOt1zzAG5jizatdY5wh5WKTMDVpVYpllsyuFrDRzSNhacd6RozQs8+0Et9IULd7zJUY0Gu01OcwYZTDGkuskRY5iWHrgsExaO+eJSlPKC5/e22AErbFGmuBzmJmnmWbxApmmGWdbfNtTUsQaxc3NJTc3N8QQyErkd5RSaKNFbpoiUjG14p1GaYtxLGA8MQeRPUdBnEbcylOi+GTUqpmTBAw5R3QxxBKJOYjM+7hIjpApIVCLeOjEcKCEwiGMUBVzCozztDRPFTHCnCIikiDTo75pZPpfZQ7jRFEa364odSKGGY2i8RaVsngwF2lkp0WSviqFKpW+c2izqDAXkcnQSuEAoyt930JKtM4Tw4AzBlnsIhOvFXdsS6sNdpGaiSlJI78qUVFYfClygZoLKleMdhyOA03fkEOkhoxemua1VqoSVpV4XmgyCV9gDAV/CwS6MKeEM1ZUB5RDq4Q2GmUqZGhWlsPhRoCrb2GRjtlsTyU4cIb5cMBZy2q9pioFxuKtZXt+irYKY1qs95SsiCHi2o5pnKFmMAbtNeNxFDl540XaJgbClBjmhPUeC8SQmGKQJnsIVFWpMVBSpm16rPU4o3FaCAa53D6nFmt6shleyORU2A0HSpxpuxNc03L6yhnj9cB2veHysBdpdCQwbX2D9wZ0EtZnLYwhgBLvmdVqSy2FOu5pkL/HrOT1gC6aGBKQSdNI8AalMyUprLZgCtc3B/p2QzGA1swpMaXESmumcaDxDWGcmWLCtS1N07Hb76BIIEqZeXB+xuuvfwpQ7PdHXnvjVZyuHA+BwMh8tNTtK4Q4LiQgQwKGccaamRIz3huur8VaYE6FXBWHmx1FSTM+F1EtsUomslERa+FkuyVNRx5sWwyV0QnBJMeEduBMSyyBnABbyRKvY6pIzhijSGnGaSuBwcLc1FqD1oQQUVrLfhPTIscjEkglRJwzpFrRdSE0KEWhoK2mFGFwqyX4NcZSqni/a+Q71KqSF5bjD3u8LOF26x2TxWNBAjoNzh6g/n1i+YtUHr38an7o6Gc5tP4dnPklqAVdK42zaCOFAK0V3WaFUqKukXPm7OSEGCPGaJRyHI8TIo26pajCMAys+xXzHNntDyil6ToHalEbMR1VVYyrnD9as1q1IjsUEsZotC5sTzrGQZi4JWeM0sxTIJvK7mZYpLoq1qglmVTkfMs2XZFTxjYW3zhKzrRdQykJRaXrWm7tHazV5JQZxpntyQnPnj9jDhPeefQyKaCWZEItzGWlFc4bvDc419J4RwgJVQvjcWDVr9BYLi9voIrvT6lQcmC3KGzkmomLuo71lq5pQWlClKmAvlujFHeyVfM8sd8fqRUenj1g068Yx4E0j8L2zpnjbo/TGu8tVLF2iGnGOkkilarM05GLZ4ntdouqlb71pDjinUYrWYvOKFRJkCLXlxd3GHU8FkKaabzF+8Xuw2pQhmkeCLsMWtE0nhQCx8OOs7NTsc1QiuPxAOV95jByczPy8NGWxgs5LMRA27Z0Xc+Dh49pm56coGlkwkDh0G7Zh4uiIoo42jhAYwzEOPPlL/8e/WrFxeUFj+0jrBG2+9/89/6mJEZWGOGgUErLvlmrxJzG4vwSUyqWtahk8iIl5jlDFv++GIV5DhIX5ZzwTYtzbrHbELJi49vl/hm888xzIMYZ7xshJmqNbxxNKwoxwjgUspA00ApaQ5gn5mkGBY8ePqIoRS63jN5MSZmSCyUllDE4q5nnicY3d1MowioGqMRZiIC1FoxRbE9PcN6Dkn1vGibmOTCHibZr6doO58VHTiZpkhSRYrp9S1HTMJqqIGeRaGuaRpL4LKxjZTVnDx9gnCXGhFeSjFfg1v9tnEdyKbRde5colpxlkoDKOIwYfWvbk+hXPY8ePeT6+pLz8xOJT1WhEijpdsqHZQpnpG0atluZalVAiJGYMsOQxOcuZolR5okQIiHMnJ+fLRKIiVtvNWuX7wx5dlgKCyEEUakqmYpgkKj+JErNWGcZh8BxmJjmxPPLA1c3R1TNtL3js2+8KgS9wyh7iRbcKblyOIzknFite3LOdG0jLHKtWfUtGVk7jx4+oGsb4jxRrdilhCQKOofDkUpltVmTS+X6anc3EaUX9adSspA7qyhB5UV/sdYiuES5699KnFnvEvslZQIW1ZyPOT4qEf44xvnHSbh9eLrr5d/9QUn6H0cj/KPe+x7D7zH8HsPvMfwew+8x/B7D//Rg+CfBb2uNNPJQFL7/s/wo5zVaYTX3+H2P3/f4fY/f9/h9j9/3+P0xxydujGvXy2Rm01C1+PcapdBKNgmjLXhPbnsoMwVh6HT9inK4RJkGbRKEmek4sj01RArr1vNwZTCul2Ag7fHNiikcuRouuby54rgPdG2ilI5pMlib6VpHmcUvoaqKolKSwphMLZmqK8Y16GwgRnKYUY0BVch1JteCXmRvUw7iq4AlpAjGYosmpD0xjxgsjVsRNdS1w5oNvjnhcNgT5hvmnBh3zzn1a1pnhd2TDQZNpbBer+l8w01MhBrxWYIfil3YV4aqhXFSqrA1wjRyc3WNcS1aWbxpPvB9xJqZQ15YRg7tVhjXiret1sxzYIqRYTxy9nzDg9MTpnlivzec91uMVjSNSF1fXu9QRRFTxjhD08vkdG86adjMkVplweWaKHMRv+Cmxdgs5IiYOR6PtJ34iOdFkqfUilKVyuJdsHhtU8TfGS/eFCkXCcBqxRorU6C1LpuO2OzOIYqccs6UcRZPjDmyOwzYpsO3a4qSADCnRIgzKWV6vwLnhCWWM5vVGutkOrsWmKeRkiI5jKz7RqbplUhNFMAaw7jfURQ45QUUdCWMEzVVTLGUkonthHHSgD7xDecPVzy/OfDNN9/lMBdSgVoqwzATM4vfs0ZA0dK3Lc5akrWLvE0BxFvHNS1KG8I8o1RAIfIqVAERtACV1mBR6KowWIzzlJioWhFzwjkPVaGMIpaEdo7GeqrWOC9KC40DpxVKLYFelbURYqYqhXaOkhNos8hNC146K/LqKWecdTgMrW+JKVJqWjZa2YxjyaQSyCmTDMwhEVMhF4M2gRgaghrI2pEKzGMgDzN+1VMGDdbjdM9c9iglFgy+8QzTKIFRVTSL94exng7Q2qCrYhwn1ts1WmuatsO4gbfefgtlLKuFHWlcIR4CYRbP6rOzU7RSaITNOo17mpJAJVCGnGZySKC1EDasfJ9WKS6vb3BWsXntFR48fI1t1+JVWvasGVPzQuCQiXHX9kwkur4hJuRZ9C1nJye89d67MmGtDco5tFasVr20uWths+qwRnzBnfPsdzuRhQqJfrXhcDhgjKd1mpQzXmcMloxiGmcORtM2luEwEHPl4aNzqlGoxlPihFMiTzSFQNf3DIcDwc3omKgh0Z+cMo4Hrq/37K8Kb19fcnMYqEpz8o33MUrx45/7DKfnI9MwYy3EWbHtz3nrze+CgofnZ+SqSXOhJsXxMGBswVpN0mCsYxhmLp8f+NLPfYE3v/OuJHQlM4SZIUvyslm3nJ00eKt5sPE8PtmQciVMsL+5JsU1VhnmMVOcELJCzmw3J1Adw3yQvWQhfNRS6PueEJKsYyQB1EaIViklrFWghKmJkia6tgZTvbA7rSaESfZ5gCosyVKTWBFoRY4iTZYXmSillWCtNj8UyMu6kvX18iRZLYVcuZPnmcMVzv8LKp8j58eAWtbly8HFB6fW9W3wooeF3FQXNubXqfVXFzWDFucjqrakaLBW03ad2Dk4sdjYrDtyzlxcHgFNrRlFQZNZdQ2N0/imufMBqxWGKbDqOxpnqRWcdQsbVKR5DocDD09PabsGrSshFZpWfNyomTBHnPMc9iOlirqD1grvW3Y3e7YnW85Pe3KKxJjuChlN41FKFAca7/De0nUbQgjM8yzKLM5SYyXGxNXljrZp0aZS6pEUxJqksQ21KIZjQKGpqqKVIZfCcBw5PTlBqUpKYfFLW1Er7G4SxolclrWSwPnGs98fJClRFXKUFXqL2zFDA8aqxQJDg6pL4UOSylJEvq7vOsZpwhpF2zhsLyxn33hKEXZyCIVV12GdY06WEIRpr3Wk7xvapsV5g7XdIifnmEoSpZVcGXKm7zq0k/1EZLpGcghUKt45huGItaLWk1Jm1a+oKjEOgxSUdOVku+G9J0/Z7cRbbbvdMhyOTNPEOE1cPH+CscLqXq3XHI8DlUuaZsVwDLTNilwz/eqEhw+EVCWYYck5cX19jTWO11577U7i8H/xP/+PcYuqTwgRlObs4UNySNQqKkXKWFH0yIKZAtFS7nJL8jrHGWOE1FUrC8aLF9Q8C9M3zbJXhBBYr7dY54gxgtHMMZJypPH9wvQWi5SUAlbLJIXWamE0O2IM5Fwpiwdb065o2pZc0l0ilHOS6RAUKSZSFrk3AO8s1Sg0TtR2+h5jG5pWWPYxirqFyonDXrz0qoL1RuTnnG9QQIriGVaKSJS1XUfTtCL5h6gA3e4ltco+WkuVGL0K+/72s6IkDqpI3KyNIcVEyQUTDLkkjvsdX/393+dzn/scTdtJYug0je2FEAl45xjjSM5ZpiWspvUN8zQTY2KaR8Ic2K7XvPnmt5imPV3ToLUhhEjbNszTuBQlFCEXtJH9dp5Fnk72Fk/OZZF+k6LjgwdnYvkC7HY3eC92SLWKv5q1jltlH4UU766urrDW0hixHhHbKsWtzZRWGtdYLt/e8/ziyBQy2hg671Fac7U78vziwPOLa9brFY8en2K1MMyN8cwhg5qFNFkLbeNEXWYK7K5vWG/XqAKrvmG1OmOcBjbblqurgf1+T0iJru+x1pDneUnEy51/XM6ZaZ5JpdzJeoq0YEZmWV7sXXoh+aHAGF7ExncJ8B+t6XubbP+gqas/7GcfV6i+fe+Pe48f5bjH8HsMv8fwewy/x/B7DL/H8D99GP6J8HvBHqusKGeipAa6vFYpUFVxi+jS2DPUIk1JaSpJs0/OVXHWsOqkcaWqIi0S6ff4fY/f9/h9j9/3+H2P3/f4/cHjEzfGwVJ0xRqPdpmSA0qJ3IK2inG6xluP7npqUjQV6iKJMMRI43pSuKHokThoji6z9g29O0Gx5+33v8KDzaeY8wBzg6fF9Yb2RHN97diszunXlnGsxBToqsE3mhoDWjdobUk6ixRuzhRdiLGQYkTVijOOSoKa0VUknlV1mFwJ05EaIl45SAmrpSFojSdq8Y8OaRRm2RSw/YxZfRpHoT1ckb0i7CGmEU2QBqBNNNbiu4auAVUUVUVyDuRlAzOqogzSlHQtnkIuiplEChPeOaZ5Yhzi4hXx0oIwUKtBJK0rrrPEEEgqYNf9IjdeqCmz2x05OTlhngOrtqcUSDmSS2ScE65tGG6OGKOluThPOC9Am6JIS1TER9cYIxLpORMjAvDGsGpb5pAYpxnvGlKJNM6gq0h+OG9l6tkYSgqUkmUzj5CqeNYooJTEvACzW7woUIb9MFBVwVRL43pudnuMdRyOB6Y5knLl0YOHUDKpJEKG/RhR2jDuBigir+5GGKOhX3mc0zht6JoOv9mQsngL29kRwiieCwVSjHegWpUEsinIv51u17z62imPHpzRrx19s2G4uECNCdsafL/mX377bYaQmEOlZKRxWQvTnCCAs4a2qXc+HhVEoj1nUpRJ+uvrG7SzGKWx1gAFiybHSNGaVDSxJqxR4g+uRRooV4CCRqa7damUOWL6FkXGAhqZSDVKJPkba8kpMo0TjffyWWvFu4ZcxL9aVZjniDWWWjLOi6TSHDNKa7wx2EUVopQspAStqUhDPlPQ2tA1DpvBWpE1n2KkVR2f+sIJf+mv/DxnD04ZjwNvfuNtvvHlC4ZDIBPhKqJ0QhlFVZoUI4W6SCtVUomg5B7UAr7r2O92qFSIYaYiALG7ueH64oq2cZw/eAxKc3UVCbNcb9t01BZcVYSUSGrZX6jMKeNcg8qVmqUxTYZ2sWHIWbzLjW3ZrnsO8w3KZIiBahQpK3I8MMeJkm/lI0GVxLbvmcNISo6uW8GcSSkvQbjGWAO54KwhhYnNumfVNrSNXZh9inmaSSVyslkvfi5BFCbiyOFmhJpoGofKGWtEvuXps+fL3u74qS/9HNTMqu2JKTINR4abK4ZplAbzPJPmgK4VnTLPnz7HrXtiGHnyfMe33rpkrpmyMNKOz6/QNaOcYtMZVEisTlrQlt1eAgBrHOMUSUUSuDlF5jRz/mAFpdC0lsMwoGtmu+7ZrDecn6wxWmOLeHTXnPDesOl7nIUSE+cnPeEodhLeGaqBZICSOez3rM47SgWjFYfDEYWjbRtKCWgjigJqCZ5FTqtjvV4zjBNhkZOxxlHqSC4i6WVtA1UxzpFaRSqqcR5lFu+fHKnkhTwkthPkJamtiyR9BV1Y2Mc/FMZ/5HGnPoIEPUJAqnilqfznwC9iTEvN6W5SXSkhCQm7WjDBaEk4mvYfoVW4k0my1qK0ovWWpim0bc9wnCjZ0vUNFYUJYulgTLuQN4QBqY3YZtQqzHXtDK0zWCvJTNOsmaYJax3rVQOIf1EpEuArJWzxOYzsDzsqq+W6LKtVJ7JJOYjSxjSSkuDa6XZDKeK/03cNlMh+v2O72XA8Hj8QzI3jgLUa7x1XlzvmVWQ4CilH6yj4Zd3CIm2ErTpEYrxeJgayWAtojdYSjIMipsRmIxYa43RE/NQswzDQtt3CZM2U4whw97lubnY4Z9DaUBFG/XZzusg9SUGh9Z6m8eQsyeWthJcEuYm+XwGwXq9xg6VtPaenWxSKaRqJKXF2ekaY5zvfqZDEW+yW8a61ZrNe07YdbrluY4wk3WHk1pMqpUSIkTLPWGu5ur4i50zbtrJXHI9cXFzgvWe93nB2es40TazXG7xvxcOqauYxY7THu5bPfuZVjsORzemaUhQxpsUbrmW7PWXdbwkhUSo0vhWmd7Pi5GyD1o4YEzlHsfhQkbZvOTs7Yxwmrq6uUAsJabe7QSvDer1ZCkQVa3tyLbIva72ozRTcgvXGmDs2tdYaax2N93dSbUrruxhvDvIc6cqdvGLTeFFbWb637XZLrZXVerXIjkVCjJKUOUvTiFfXPM93hbjb78m0nSgeVSn4HIcDV1cXHA8HVl1HCJGTk1Oc9RjnyGGilspxN5Nywjt/l0DfMsCnSdSGnJMpAhQ0XUfX9/i2IaZMDJEcIykGjoejMI+d3IeSImEUCxfnHSkntLb4JZGvOZN1Yp5nwVVrOTk5RWvNOA4opbFOPN28k/0gZUnOx2nmC1/4Aicnp3debrf3/ng8yuQAEGPkvffe48GDhyhjGY4j07Rnt7/mvfe/xzAe6NuGrm0k/rJC9PSNw1hL062IMXC42YsF0SJdxjIhdPvZyjRTF0JrjBGtpCigtEzF1Ao5p2V6hTuC1OFwQGw14ORkS62FcRyoCD4IE1z26VXfoqaRVx6fM02JmA4S/zoPFKbpiPOK1147p20dm5WjbRqur8Suar1qZFJEK2pVOOcYp4A2DmNbwlw4O92wWjWEkBiGhNKWvPxu0zaLl5wUUK0Vv8jbQ2uNNYaY8t30lEz2GLS2zCG8hFMy6UGtpKyW50iUrnLO/DCT0J8kYX6Z1X77mlvG+id9/R93c/zD7w/3GH6P4fcYfo/h9xh+j+H3GP5xGPnya/5VwfAfhN+liIqmNZZc5N7L/RW8vcPvWrBa6sC+cTIg8H347WmaRZr8Hr/v8fsev+/x+x6/7/H7Hr8/9vjEjXGrLEW/NMVWRUa7XbXUKo3cvnkVHMQxUmNEW0/JmcMU8bZlVAeM64jTwPFQeOOkpbMjw7iDUTM2QeTggGSh81vWm3NWpyPaNYS5kvKAVj2lWqyXiWzxbRXfEmMV8zRhTYtWFWs0VXtqgRgmzDRDLigizrTUXJapXYeuHmUg5ghFYVyLtYlaAs5BNYbarMB75vEApbDZPqRDc3CR9fkD9hfvUhJYLCvf0LQ9WJGfNkVWpa5gLOTCnVd1VYZSwGqPWtqVXd/Lw6QzfGhaMJBQ2lPKiDEyVZtSpmkspQaZaI4RlwvDODPHQtd2jMMIWrM9OeE4zczzEeU8Tefw3lHIaCVTsSmLXIQpsqkY64CK8xalZOJUPNANKUlQ17Qt8yTyGiknagHrDDmLxHTbNuyuhRVYUqamjEFGnWvKMi2eE1OMTFTSHPFNS64SQKaUUSrj2pb3njyhAIfjRCmVppvw1hBTIuZCRlNyoaqMQmGxwpQLEdNYtLFMY8RQaFpHypmuWzHXStEGlMJ4IRzkVLFaGILjFLCupdbMT/7Uz/Bzv/BFnHLUmlAqsmsh7G8IOXKyOqXp18w3V+RayBRqdndOehqRBmLxwvFNgxpHmchtO4zRlKJJtTLtDzS+QatK36+J04SwNQreakwV72MkTibHItJHWonYhTUYZ7FKk1WVs+sq8s4aShKfDrts8NZoYbTKbCt58b2Q4EDk0GOIWCcMMessN/s90zwBIkuTSvrAJiUz17LB1QSFQE2aZ88HGlfxruUX/1d/hf/kf/2f8qnzT0GpVAy78Zp/9A/+n/wX/8VvcPFsYpoj5+sOY1pyqbimwWgtwZoW2RnjGpxdmH+qChkkzJAK11fX0scOEasNbd9BrQzjUQglaLSyIuPeGF559Jh3nrxLVYq+6zmphfcvrmirJQeRz/ZdQ54SJSRSjrR9I/5JnWccRz7/E6/y8PycHDMpaQwwzAe89yj9Ikmax2uU72WaWMN6veLqeIl1llTyEkDIxDmp0LYeawx931FSwFjD9c01Z2+8xmp1gjWWwyCyNSFEVCnUUjBWlA5yzTjdYV2BCMdhZowjn02wtp4n7z9Bac3x5kbIK1kStjgHpuNASZ6aE+1amL1lyrz1/jUDdSFOFBZbFmqFZxfXzF+onK49c4SiFO89+R6qSlN/c3bCdntCCjM3FEKahDGZCjnNsAS5jXe8+923iXOCXgu7MmZa61j3HqMqOSWoRogSOEqO1CokkGoUWhdOH28YjiPeS6CpAO88zlpClKCiFJGUKUUvwa1BaYX1FgZhZpeyBCY5oZWFKjJA0zSLlFdOBKVorbB/rW1ekq0RT6JbaSWtqrz3QqLKi4TSH9dxx6hbZIsk9BFGqLWaqv8ezllcEXUQYUGDt5ZcMtrYRRYenLbi4YWQebquJ8QJhRLWNpkwT+hFFSWEmcY3tN6TSl4Szco4jjSNA26TlxeSRsZohmGg61q892itSSkyTiJbv6yuhXlfSXnPZrOiaRq0lusQlqR4InnvxXe+7xnHiWkacQ76ruVwOLBZN6w3t95CsFr13NzsaBqP955hGFFKmKo5i6t9CBGlJOH13lGNXI8xhr5r6Puei8tLvPccj0fmeeL0ZEsukfPzM6xt2O329F3DAj903ZYYI13XkbOorPjFP2oYJ4wxy783UoiYxV+pW0gywuLvmaaRw2FHzt2SjEnQb4wQrYxR1CrSUofDjq6T4oUUbZQwZot4Djkv6itKsQTHmpubG5xz9F3HdrNlOB4JCwPXGFEWMcbeBbVmCahviwJaqWUtShwjAbBd/J8qh8MRYywhRLTWnJ2doYBpmuR7bkUtpNSKTgrvWs5Pt9QCYNisHuC9Z7V2tM2KtCQDwzCglMSHt353KWWRiarCKlYa+lW3yNQpNuvtndzWer2WIk+M6CX2uE2cS85UbSgpk4Lg4633VSkZveyloQScaxjH8Y6pLqTIke12S6HSt1IEiXEWP0IlBCmtNSFNovZjjayTlJgXlvttUiDfscE5x/NnF6w3m7tCm3eyXiiZWiohzHz9a19jDpHtyQmlJOriL6a1pu1aSZxjWJQybicVpJDWtA1++awVOB6PjNOEqnWJzQ21FpQSFnYMAZZil7VOiIHGLY90WQiaabGaMOz3gpmb9UaeZSe+gxgpHpYsUmbyuR0PHj2GervHyV6+u76hUFmv14zjeHdvNpuN4GycqTVinaXvVzx68BrONazXPW+99R0ur254ur8m5wQs/odtIzJx1i5ybhNaa7z3d/sIVM5OT2icxNLJ2bsEtW1bUYuaA8NRYmhjLdpK8exku2WcpmUqqLBedfS9J5e6qAspFFuc88u+m3j1lTM26w2Xlzvee/8JMUXW/Yq2kfV7crqFmlBLHPrw4UOU1uz3B7p2BVSub24IoXB1s2cYI9p4hsMeaqWy4cnT5+z3EyiZiKiohVg7kVNZCpWSQ0zTtNwvw5JnUyt3ExFaa1KOH2B9v7yOS8x3vyeekLPE+B+TmP9hifFHybW9fHyYoW6MWQqd+QM/f/n3X0x3KT6c2P9xHvcYfo/h9xh+j+H3GH6P4fcY/qcPw38wfhtqAecMxqpPiN/SXLrH73v8vsfve/y+x+97/L7H7x8Ovz9xYzxOAb8+IcYBbMWYhqwUJjaoqjG5kOYIvizNrIqyDVM+kDLEXPC+odGe5+pAGA60mw4bEu+++w3Kkwd88c9bioG8BAkF6NrHNP37pBpxuUPnTAJKzuRUhbE0x0X6oMf7DUplyLKR1KywWpOtJinFPI84lWSaNWeMdWjbUXXE2hasp4SIMppcFEYZ9OI/rY3Fd2e47QnzeEOZrUh0JMX6fANpZjoe0Fpx6gwrL42OOSfZVI8FigbjZHI6yPQpGUqGOEe0stwq9h+Ggd3hiNHiPX0rgaeUIqtMShWUpoJsnhmoBW3EG6HUTFaIX3VWNL6hLs3NVbdh1a+YxsxhOACQcma3u8EYT0lLUJRHYV052YS11hjvEHlhaQ7JhO7iDe4cuWSOxwFvPSAL01hNmZMw5Yw0rHPMxHmWJquXZnGYZ3bjRFZVpiu1IaZCqpnVyqNq5fHDR6xOT/nuO+9yHEZSqnjriSHRWUfIMgGttCHNM9qIrHSMS8N8f2S16kV2XmkKGowlzAliZsp1+T4CbWPIWWFdR66VVCBWQ8oKVTXrswe4vqdmg8oJqwuPX/8UczjjGAvj1UhtGnldUpQqga4w4hRUTeMMTmuMlqldtPijxxTB6cVjRVQMppSZ5shcLY83PTFI8y2mijOeeZ6F8VcqTlemccYYwzBObLcrzCL10a/WMgEbK6FGjK4olbEL2Lu2Ec+cXMUzu2iqBqWk8eeMECOM0QtLT6azx2fPKKXQuhajCuSC8Q0V8eLOKYhMztKcj7GgahbJaW34t//6X+R//7/7v7ByW1I8UsaA0omVbfif/i//z9y893/g//V3f4s5RMo4km3D6XpLLZUxBeIcmcPM9mTD6UkvagIx0W9WWKWZleaw27PxLdZ5puNAypHDOJB2A0VphmmmhMi6bWi8p29aKtA0HSon3n7nfXTT0FmLMwazaZmvgzS1q4hsv/74AcOwQxmZDO7XHecnj/GmZ5huUMoS4shcRkoSoglIYtS3Pd71aO1IGXY31+Qk/iUlZbEfAPq+o+88kOnXvUzqd+3d+mm7FmMMYRbJ+hCSMMReCi5jGIkp41uNbRwrOpxx/MF3v8ev/+Zv8rNf+Dxvv/sW6/MzOmfvWJbWWMI8MoYZ6yRR863DFLi6OjBEqKoSUxYSTLmdiNcMU+S733uPX/iJz0DVDMMB0sRwTFzdXPPT658mzSONFYUErQ25gBFwQKMZ55l3nlxjtht8VfTjwKOTjmbt2DQdaZRArm0tukpTuiS3TMNbSigcdgO6N6zbnklbYkp4r1FGkXLAFQnjYpBExze3TO1lmt1M3Oz21EVNQpSlDBphD97K2QtTT4I3rc3CFtZLYJKFmY26Cy7k7wsWKL0wFCWR+WGPF8FBXQKhIr5HrcUuPkC1VtbrnlwyeUku+r6V4KuUJalSgFu8dETVQybp5foqBaMr3ln5e62ULHKuktzLfq+VyBpJOq1xzsm+4yToufUVuv3MKRaapiPGTAiLvFdODIcjzlraTkhEYnOlMEpjjAMSpcq6r+T/H3t/9qNblqb3Yb817ukbIuIMmVmVVdVV3V1d3aQoEXJrggHZMOwbG7AAX0uA/yPDFwZ8YRnwAN9IgmzBFiQBNgxI9IUBQwNNkGo2WewacjrnRMQ37L3X7It3R2R2sVhdXWyYRSD2TZ48J8bv23s977vW730exqEnRmlABdQpjIPn7na/OQQIhToMA42Mcx3OiX3c4bhjvs6s68w0CUnaDw7nNdf5wkcfvSXGyDj10GANC3kJ+G5gmnpqTYyjY5xGbu92aCXQg3Oyhs8ncWLI2dBtufPeSb5VjAHvLePQ453lfLmizShU7HXm7u5WKP2+J4aAVjzbXmWEsnwiwZ8Iz5QCt7dvnzc+vPdbHIC4xXSd5GMpbQQ6qpVlWRh3E61KfEDXSzPpnHu2YVrXla7ruH94YJom1hB4/+E9wzCgldQMpQjZHGPmfL5wd3sLVJQyWCv5Vvv9jTTFqnG9zuQseV/9RkF/+eXnfPHFF3jf8fh4ImeBSg67icP+QM6J6+XCuNvju47bu1c45QlxpfM9tcH+MBFLxighwkNYmPY7QFxXnnOkttfy/v6eoR9xTqG1bBIYo4kpcj6fuTnecJ2v9F0nmWVkrNbkJrmBYVmYr0IYd96z2++5zLLh0Pe9vO7eoZrkSYE0LOfzmRjjZtemePfuS7718bcJy8pyuXJzdyv2YcsqDahWhO1nT1ueXc6JEFYahRCE8H6KIRn6HX2/o5bC7e0r/vAP/5q8T03qNAXkIs1bLplcimShtSbPnlbUVnn4cM/1euZv/9f/DX/8x3/MMAw8nB7p+55lmfkv/ov/nB/98A/43ve+x7hNjhgtky2+lykWqdsLD4/3XK8z+/1uqyEN1hg+/vhjSimyOWEMhfbcwKaYeGqXZK2SNVcs9MDhyCmxqBmNbDg+NdAxRvpR7CWtM2jTodXI8XDHR2++Q22BUgN3lxtKSXznO9/leLzh/v071vVKTgJd5ZKZ54Whk424J4tEY8zWlMr1PJ0BtG3T02pNaJWb45HGE0wIxQrB/fWmjjiM9H3PvKyklJ43s3KOKNU2Z6HCNBjyvqOUI8Y6Pv7oDV99+SWn04laC8fDDq0NH+5PNGUppfL5559zOByen62hH6nNsK4z/eAwzvLu/Yl3H87ElJmXlaf+tR96ci6kmDdS3WGMbMbJ5ETb6P36XPfI+yWbTClJg/6rqPCnf9OAtopS1fNUxi9+3F+sib/8437Z3+Wcf+2P/Yu+/1/2etHwFw1/0fAXDX/R8BcNf9HwX9TE334Nf9HvF/1+0e8X/X7R7xf9ftHvX9TE3y79/rUPxi/nR26ngRSuaOSguCglh4YKej+QwoyznlozpVQchiVHctPMeaWskY+9JQ5wmTMmz6RT4NtvPuanH8TGROsOZeVwvNFo1TOON9TYMCYz6oGHJRHWhjcWqzw5ZfaTp2mP73u085ScqYhVrW7il++8g1rJMVNsxelO7N9RRMqzHbKkPssko+QnOFKJQEOXiDGvqWohlvfs+99ljo80VXn86k/wWtEfXtHFFa0r1muUdljvtqxliAXGcWQ0QncoIyRYzRHItJpItQAG73tS2rIcvkFkhJDE6hswTiw5+n6Pao2qEgYHDYqCcZy4PJ54/eYG5eByvnBzKznjWsFh2oHRnC9XapEslFobtCSZFUaj+DrnthShmqx1Mu3eGgoFTZFSoJT4LFTH/QGlK60WjDbEkilNHsxSCilErHO0ojifz6Q14/uekLMcmuZKN/TQCjVnhmHiu59+h4f5KvkITwHXdZvq1JLJ64yntISzTz+bZCTUWojbIaHTMmXqO08uEFNGmQxNIwbjmhCz2KtURS4FrQ2Xdcb3ckj57v0DXo8UlShNU+3Ezbf/JmjFZcmE4Weclv+YXAtVKWrTlCqiWUtBtUZDo4GUEx/u70GLnY/RGruJ6hoStSLkZ20spwuTU9zsR5Z5xhiZprfW4a2hlcaaIrVVSmm4fqQZS8oJ563Y12txXci5os1T4a2e3xutpThqKJqG2gCFHIQ2aEqRm5Ck67pglcVYx9BPtFJxzlI1xNKwzpFzpSE/Y80ZpQy+y6ikQFm6wfBv/c/+Le66G6qKNHtE9RGDobZMaY7/0f/43+E//r//bf7kH3zBBYdvlcfLiZYyJWe8FzuU0/2Jy+nCx9/6NjFGrl/N3N0c6bqRMjYqjTXMpJqYl4VKJeVGaQWjNaazKKtIaWVwR5a0EsMKTbHf7/He0aO4pMJljez3Owxitb2uC0oVdrsB5yx736M9dF5BCxuRqximO4q6FQCibe2JNkzTR+QWsMqCqswPX2GqpbMdirY1JJWu8+RSGEfJWamtUZtQl7bznK9XOqtRQjRIUWLE+SOkyOVyRetGSJF+PEJrXM4XjHEMfU/feR5OH9gdJublSt/f0qzBo1nmGWsNd69eQavYZlmXmVwa705XuVc2y5latwyattmxoPjiy/f8A28xunI4HHl4OFNb5fXb1yhV0RpUazw+PDLsJsDR2HK0lMZ2HbsDKKtZ18hn7x/ZT99iNxxotWKHAYVQuc46XGfAalJUzDkScmEJmX3nWJcVYz0hhWcARbXK+fIIBrknWqOEjFZbJAGZZZbiQYrBIlrRGq02ckvU2kQfraFWtWUXgaKhTUVCWxKlQK2KVrVMilsj0QgpA7LW0p5SzX+zy1lNbVVcSaxYabUqTZxWimkYKLWgFGiloSj6XijQp+wZY8RGrdaC1lJsUaU4CilBSnTeyeS8Amslu6pk+fnFgk3s5dEQc3qmFNvmArAsArk92YKJTZbamvsmDf1GgFo7oqlbwSeNZtf3WGNY17i5i4DzHmcNpVRSCnTeobW4OGitoDXO5xNKHRAAwXI+n5l2w/a1E0pZpmnicJhYlpXWnjKKNjcSZ1mXlf1uj9aaEFduhx3Hw7QVo4lpGul7AfJiWNBKIKXXb14TNmu09+/vqS1z2N+wLgthFUJfI9ldMWe0taSSubk5Mg4DYTdumwliYxW93aYLZC3v+4EYI9M0PRPR8l74rZGWDZivM8o0+/1eGvWNFl+WmVIq/TgCir4fOJ0et68n8IpzeqM5G9paDscj6xoFUMt5e0/qRsLL/bHfH7i5uds2bBqltc1xQdxPruczaPjyy68kS0xr/uE//Ie8efOWaZqIIXJ3+5offP/3aRgO+1uON3cbSV/EHjBnHh/OUrMYwxpWAbQ2Vx7fOxSbS4qVSYC+74lBNheeNilaa+wmobytlfVWG705PGhevbrDaIve6OWUpXn1xmC1oaTMbpzonExbsEFqNzc3z5tiSilSyYz9QN/3hBiZ55ndbvfctMyXKzf7A9fLSQhyo1jXlVJlyoPWNntEyQJ8auZDkA2EYRi3e0CzrqvAO66T+1SwU87nM6fzGW0UvpMcMKGOFWiLt56h65+f31orYQkCkg2v+Tf/e/+mZJgVIfmXVui6nn/jX/835H7TGm30VtvJWqKMFjK5SP0j98cOkHtF6OSVOCfGnTTqWmtUlY2ClDNla1xpUr9rrbapGoWzdotRgcPhQIiBy0WgUFnXZH0dh93zhE5rlXWdOT0+oI1sGLx+/R2++70/YJ3PzOsjOV05HkbmZaY1+K/+q/+Svu/53ne+IxsjzrOsC62152dsHEfOlwshRo6HA9YY7h8esc5tG0Hd8zN8Op22zSn1/JzGKOT+h/tH+X352pax1kpMSertGEkx0w+OV+aIUpqvvvySy+XCNO0w2vLh/kSIlc8+/8AcJJImrZH398v2Wlb2e5lMUtpyuVyJKdFqQxm3QW8yZeGcJYYo+XJGQDLv/fPv8nQPy+stQG1pX7/+T5bff9HVWpMNjia5b09N/2+6if0XUeu/DdeLhr9o+IuGv2j4i4a/aPiLhv/j12+7hr/o94t+v+j3i36/6PeLfr/o9z9+/Tbp9699MK5qISyPPL77kldvvovqKroZUq1kEpAI8xXr3qC0pR93KGOoqWFsx6u9pejMxwcPbc8Qv+DWN2oxvD5+xPythTUuDF4sjY32KOMpJkOTQ8nmPbpZrEukUqm50qxQODEs6H4UokZplEk43TPHgC6BWhLX5TN0cwz2iNaV1gq1aqzXrHOi5Ig2Ge1HdMvQFpxuNCy+U6RsiDlTH39GWs6UOZNcpNoO8kyqAacmrLZU09GK5HJjLHFd5ObdMpmb0bRqUMqhjCHkBaslE1zR5MwE8J0c8JYtJwDkhsxLpSmxiamtEuYZZwaUstuN3mhNo6nknHg4P3K4GRl7z+l64d2X73i43HOaZ47DUbI9asU4Q8pIpm4rz1PhWitKbdScUFpthzYKba1QOrVhrGTltCIT/7SCjMOz5bxYqIo1BMaNsjHO01plmReWGNGbgKcY0YhwoBtOwX7a8zs//CP2+z0/ff8lIRdSAasVoWSxSykF6zw5xY0j2IgU1WiqbrYjmXlNeKep23HTdV7RVhbiFBNaKUppZCraKhKVXAqqVHKrqJoopfBf/3//Lv/av/6v4DqDUYH92z/k+P2/jm2aN9byofyXnK+RUhVZAS2Tm6U0IQjVRoLGXJl6h7YWY+XgWRuD7TrmZeG6JDqrEP5ADmAfrgtGNTrv8RgSgbvXR37wO9/lpz/7CaVUSm3kLGJcakM3cbUuMYO8HTSlUFrs7lEKYxRxDaiGiEOrpCxFn0z/VrQyYCQKIIZI3/XcHPY8zjOXi+TYYAxGKciBtBXJ4kDSxDZHZRQa0xlaLhxf3fHt7//hdmAolKbCo6ho7ail8PrT3+MPvvc7/Mmffklrmr7rqDpyOS9YbahkOt8TLitpLpxPF5TWTNMATdH5EWscp9N7UlwpRV5/6wx2EMeDlANgJbupVsbdDt1bUgnEalnXRGsF7zW+wXq+kmJgdA7SSueM9B1ao5WjVsU49Xz09g2qGGooeC/Z8TTJCXnKttFKYRTkWtGD5fph5ny95zDe0m1ZL9YYeu/IOaG1vKc1F4oBO0xU1fD9jlwrpgnQMgyDFPBroGmF7zoqjVIatcLj4wM0xRoyjczd8UCuhcfTozwLtZCmHdTGOq+EEBl2IziHsxbtPR8+PPB4f5bXpyaUtqhWqPx5oVMAWrPmxM5r7u/f83CVHKRxX4lzYJ6vaGOIuWBCZui77VlthFgY946DMXz7ozd8/uUDp9DROYMpitwURjWBQIyjqkatis41nLVY16AUVIXHh5nj7Q5nFKPxQl4ruxVk8nMaBUaWEFppWG0JeQal0cqQs6wrTwWgbk1cFIzebMMaa6gYI+u/RHpu63M1FJ4Kls3Vo1aK0mgl2aBGNXIVm/jf9BqHXmIQtnXHOy928k0yzc1m4y7Ak6XpAlvzIZZL6rngs1Ysy5qQOtTaaFsTVdZA3ZwkWmMDIqRZk9cjCxyhDF3f4Yp7pgaFUq+UEohxZZrGbxR0jYZQ9PKxUrR7J3k4tTa8Fy1a14Ax6mnlF0guFYxxdEMnDbxWmxOMPAtmo0CFHndcr0U2ENg0dsuKSukq36+IRtRaCWHl9vaWrnNClpYI1GdKVchasVnKuRDCyvFwoHPy7xo4HvfEmBmGbiPGDdPUY63lep0ZhlGyglBcLjNGW6hyP+acGfoBlNiareu6Ff4DYneXecoQerJRSylJ7IQSK3/JS5Ki9IkEjiGyXBcOhyMhJrTRxJgEbKqyblwuM/v9nnVdt0gIaQQmY8lroNK4zAs1Zz766CO893jvNks8h1ZiGTVOmoJYvl3mmeV6paSEd44P9+/RWrPbH/Bdz93dK6Zp5Hx65NXdDe++/AxqpDbF9XLP6eGdbBTlVdZL63i4PzNMA9M0cjk/Yq1jtz8yjnuGYcfQ7aBpQgrc3t2yLvMGIBV5Bo0hJ7F+SymgtUJZC1rR9yPxGxRyKrJx0jRM0441BPk5OkeqWzDJRtq2Jllufd8DTeJsqjwjNSWMMfSdTBk8WeuZ7T0dhoF5mXHes6aA852AYch0g9vyruTZE4u3toFJrTXO5/P2/QrOWd5/+RUfPrznW598glKG3TByvp5xe4fWBpq4Z3jvySFQlGSCPdmVdV0nmxdb3TaOO0KIfPLxt7aoEIV9ZTd4TaBD53u0lnUopgQ0wrLQStnuacl3e7IU9K6jdZtWbn/vtpwwqzVt2yTx/YDe3GxarfKapEgMQernlADFPM8cj8fNfnLAOZnEqa2yLitayebB/rgjhBXnOj68v+fx9IGYZi6XR04P7zdLO8mms51nf9gTUkRp+b5Ka2JKdMNAWJbtdRIHlTUE1NMzGSPrGnAufGOj7MnxKH6DyFa0qshJrB1LLQJtFYmMkdJCU2rd1hCZ8FFA33diuThKXiJK4qNCzCyrPOe1aUpprHFB0XC+e9aAmAR8Vgq8Bq3tltNntg0CNkvLrzcRnhpxmTjRz5twDQUbOPe8ySKi8Rdq2lNN8ZTN+cua6V/VZP+i3do3reP+MkT6r7r+Km1YXzT8RcNfNPxFw180/EXDXzT8z3/+Pw8a/qLfL/r9ot8v+v2i3y/6/aLff/7zf9v0+9c+GNdGE5cr5IrThlwS2hmcdqS8EpcHSmzsMzAOVD2igdwyB7/jux/fkJZHSjnxRai8DhajFFUX1rkyHkaMs5S2slwTu8MNuolgOKMlJ7pEtG6UeJb8abXDj55+csSSsfFKVgHT7ag0VNdLUD0JpeD+/XsonuFuxDWxQa9NoapCWbF5yXFGFYPxBkqieYu1A1VrdGcwRHJ8JOdle8C+JOuOzvXsD69p2TwHiFsKxvZEErUWjNWYfkeJF2ptoC3VyYEIJWOcYU1C53nnMToT4gXfW/z+DU/vr9w8mpoqujUomZISpWaULrx/+EoWEC0Z0efzlcMnHzMvUWx2jKLve6YyEZIseqkovPdcwoVYAspqsS5Go40c5OhtmjgXOaRpJWE8lCJZwiBEodFPeSmVXDPTOHK6nGSRTIUYAvtpopbMtNtJjm9uUAtaNylclsA49FTTmNOZb73+Dn/83/0fwuBIp3seL2eiBI+Ta6NzlqaKgBHbYs02wauVFmKJrfCrlSUGhiy/n2qN3MApQy5FDrW0QTlHDImWykZuyqSucR25VppS/P0f/xl/57/5E/7lv/l7dPs3/N4f/SsMdyNhzcTW+I/+k/+Uy8OCbo5MxrFZG9WKNvq5KAJNypXOKZpSGxkmOUNKi+NBKSDW+XKYH0vh8RrgsvLtj+744fd+B2V7wlrRWKyFugasbjgjxRZV8jO6vqdzhpIS47SjpIQ2Hd5YtBK7d6Mt1nhybWiVn7NloGG2yXw5qgTrvOT0HHaczmeW60oxGm0VTVWM1biqqaVQW0FZkJRtSKWgFTjf4XxH0wYJFEBAD1WoRmFVRzSg9Q6/3zFYCOuJVjPWKqwzQJNibuhRJvPh/ituX71i6I8oZUFpyLKA18bzhLVWFm3AmoZVbqOtDM1oxmmHLolpHMhB0feVZQ18OJ0x3SC59HEmtUxVldF7yPIat5xoRvH69Su08azrmaYKa2roqOl6xbvP73lqISRvumIwpDUQ1sjd3begKl69uaWzHmcspWZsk6wjYyRbvdZCq+C7HoUIzVN2uTGaeVkoFAoVjdx7vveMZqQWKUKaUqQYuc5yUE2TKejLvPD4eOKjjz6i814OxWGz6oJ1lSyjuESMMjhjCUUy7uWOkfsWhJYee0uJgVg0sUgh4DvP+XTh/ZcfUNoKzegdDUWqBactSjvWsnLXy302L4Fx8HSjo/OGFqBThjUugNiBacRuqTiIOZJaoesNtWa6sSeXRM3gFcy10vUK0wqpQpsTVTXmVtjv9hhtqLlSo9B4xjjiEni4f2S322EnjTbSqFnToY0lhMyXX3zF24+Pm8VNptFIqeCUwRiHtY4cI8tyFe1Seit8FNY7eU03gvs3uZxztNS2P1s0/LkCJMSIM1uoVm1oq7eCKj2TzSklWpOCO5dMiRnvpGnXGpQxpBTpeoFa1lTEFD4mnHcsATrnJPdKw83tDfrJHb41hqGjpMDheKDzrwghYO0TIS+601pl6HuhoJVmCQvjIM1zDIFxkmy1GCJd52k0nJfnoebCukoT0fe92NChiFsWlNDeUmCWItZZXScRHcYK4PK0sdAaPJ6uKKDr/TO9WXKhlMT+cOB8Pm8NnWwaCLnpWJYZlFhkzfOFTz75mGVeuH/3HqU0u91ELpndOJJSYrfbU2vj/bv35FrYHfbPtl67Ue6nlAvny5XHhysPD49861sfkUqlFdm86PueP/uzP6O1xjRNHI/H54ZwHAdp+BtAYxhGWmt03bA1D41pN+J9x35/YFmuLMuV3W7Hfn9gGHqW+UopjVLFUmtdA9pY1suCNY7DzS193z9HcAxDzzzPGOtoWpqjECKfffEFp9MZ5yxlW3M/+vgjymYPl1Lk9rjjeDzy6vb2680fDU5rvvj8Z9B+Sqvwybe+RUiJ480r/oV/8V9inlex4zu8etbXZVnZ7W5pDXE1mbeNn80Jp9bK9Xrl9vYOTaJksfYDhTMWWpOPV+Iy1FphCSv9OOCsY1lWjBKSN1+kKfPOcb5eON7cMHWeP/n7f5/XH3/Ezc0NeY2opgjrQs4JhVj9HY63gCKFKM34PLOuK4+Pj3zy6XcgRpzSrMuCdQ62TTLnHH3fPzcd3jpCCuQsmzbOSRN//+E9H+7f8wc/+hFls4apteLGEbVBPyFEqROcpZbMw+MDh8ORp6y6lJJowuYqBI3W6sYnig1bKgVvBoxzjK5DKf1M6msUOUZ638nGxraBVHIhlSxWj04AOWoFY7DOcr5cBKK0YuV2vc44xAavfqPxkg2VSN8PhBBoVSKHhn6ktYp3jmVZNlL/xDj05BT5R//oH/DjH/8pIcxYq/jiy8/RWvHm9WtiiNw/PEqUiO9Yl4WUE4f9ntPlwrKszPPMOE70/bDVYAVa3n73xDgOWK3p+u654XXOPU8HPT2XSilyKtgtE63UTD962jYt0VCEVLbJIsnQE1s3iecYh4lSM86zkeFwOV2ppT437GPXYZzhdLqIe9S2CVSy5F6iBLCMKeLs1sO1Rsp52wCUTYOnzQNrpZ4sRTYX7DY1FEIglwJomoLGBqJuH/errm822k9//qexUfvm5/8mxPsv/ix/me/9l7leNPxFw180/EXDXzT8RcNfNPwf/5jfdg1/0e8X/X7R7xf9ftHvF/1+0e9//GN+m/T71z4Yvy4XdMosl7NQSL4Q44V2LZihUlMGLPPjO/rhrUxhUtHWMzmYrGFphmp6btyB/U3Bj45rjXzx+Y8Zb/eYDmqZoQzUpLDeo7XFGgNW0ZosivP8AW881U+UXDDeUDPUFAklM7iOphVrumI6h9Y9KV4xOVIz5BwwGey4w9hKrRpjPKVcxbJ5fodOE61CNaPYaxcvk4QqoFRjGAfm+cp6umD8HvYG5zqq1mKJgaHMZ4zytBbptoyUVDZb8QbN9NvUrFgXh5iprMBmZY1h6HfYvuOrx9M33nzkwMtqlJFnPIaFsQrJdzk94swTfVgYhh1ouK6BfnCsa6RVeH13g9Ia2zRrUmQ8Ka1ySN0UaY2SNY6m5IQ1YsncWiPFDCRUloOw1CLOO7T5mi7y1mE2odBair11XfDeE9YVrRTWOq7zTJgTWjtyq6QK0/6Gzja0a9x99C3+2h/+TQ43r7iWwJoTISxoBCqQI9RCboWQVrqu3+xk5OCO2kixbEVDpbTKmhI0sxF+UTJ+NvoyNyRbpJRn8a4NllWgBWPFkh/dSGnlP/yP/zO63S3/0//5v4U63HA+X/lv/94/5N//9/89/tP/4P+CoWJMxZay5asLncMGOCitQClxWECy5o0xQgUWmWBXWxFHadQq9vAKRVWNXBqfffWIVmLbcnvzCuMcdYk47zFVSTFhDFUprBXaq+t6VOegVUoreGdpRQ5OrXd4554H7nMRUk8OSqGYvIEGIuClFM7nR/a7PX3vSGsiK2i1YI0hKCE4rbWEHIm5yOQ7oFDoBvcPj3z2k5/xu9/5PQpGHBFag9IwBaoKvH/3GX/yZz+m3/KK9uOe0Tuy1eyOR+bTmRoya5aDbaulWAhrxHeGpCKohrGefrNq0UYT1kBn/bNVTVFF3hejubu7pSwr67JynSveaJoyJG2Z54VaKuhK5wd2uwM308R8ObHmws3NkaHvuLu5owRZO9Aa7ww1NnTTmCZZJQANOJ8+0JQCrbFOY+yBdTnx6u6O3dhv9JrDOjkYV4qt4MisS6BVxY9//Gfc7Rw//P0fYJrCW0d37LguM1ppluuVuK4Mg0RRlCo5NbUJMdltNjDTOKGU4ny90LbnopTCdZ6FOCuFnBNNCUFpesvb7obxsOPHn33JOdU/J06Kyu3Ucds5psEzjR0xSRPTSkU1yai6fzyzxkhKhaFrXC5XDv0OZzy1KeKaKGiuYSWFwnVe2O939M5gNBjXQc3kLbZBeyFL4xzY3x75wTCR8iprhzKYLXLBNScEZ1Y4PbLmldP5TE6JFC5AwxiNtdtBv65Yr/jk2694ykK3umB9R62QE3Sd4fs/+JS+F9eNVhVaGRqNUBXrstDqhd51Urh4R6mQSmO3m1jXBW2ECvxNr+s8b3SnPMdaKSHTO0fNQlSrrkNv76PzVqyWNkgHnrKeuueMerElyvS+x3pp1pUqeCc6kWKhVph2Yv0VwirW/9MEqhHWFe+dOIkgANN+v8caJU2+Elsfawyllg0MkCbFOk2tjVevbmilMA5SWFvr6PpOLIYAv+VvresqzXwQSO16PdP1juPbV9SauFyu5BKeEg2YdgNd19H3HetyotbM48Mj+8MESONRS+Xx8czt3Q0xRqyxYpHnPdDY7cSCqjUBiZZ5pus80zSitX4mUS+XKyFGiSUAlnWRhg+eLfRSSnSdx1TZlPDO0nkHrRFCYHCG25sjr+7ugO9Rc6LrLSGsDMPE9Xpht1lfHY8HyYZSaive62bztQKKdV02Yn5zUMlxs7Y7cb1emaaRZVn56qt3eD+gteVwmAghcH//gN42Z4Zu5LMvPqfzHfcfPvDq1R0pJoy13NzccD5d0cYScybFwDQMWGu5OR755FufsCxXnLP88Pd/n3dffcX5fIEmsIs1Fm0sX3z+JX/4R3+N/eEGaz0pZ7wbmKadbP4ozes3H1NLxbkr0zRxOp2YJnkfhVIeQalnq7DPP/ucTz/9NrltWXAhEKPELKRYxE0jS3SH5EwJwDKO4lhEe4qOkdxAPwzs9/LcmA2GO97cCAiaCz/60Y/ISPNv0eQskxKttednz8gCQG2SsfQ0IfDpp59SeHKnSAgHJRMlxnw9CSLPauDyeMJ2kiW4LPI+a6WwxvLDH/4B87rK65gi3jt0g0IlBIHilNasMbCmwLSbthww/dyIlyLQj+8cMUR857HWSh2yRf60VgnrijGGdZF7QCtNCitKqefJB201YRESfux7KuKORJMaCJWpVdP7TgCtrcn2TrC6shHpbbNyTGHdNmKW58b/o48+Yg2zvPZa4ny0sVhrWa4XoPLxR2857AdiWDmdH3n16jWlFN69+5IQCze3tzjvSCGxnw74jdp///69rKXObsT2lutnDTEGxnHizas7eX2c5TovW6Zge6a2v0mBr+sZFM+blZIJaVjmRaZHUiaElXHckXN+nt4RtybP6XTZcgv9Zt0o+XYpR7HynEbWkNFGvvZSImw1tmQOQmcM61yY+o79bodSjeu8SPxUkUYfGs6Jk4rY/Am0V6pYrsmaUrZ6QOqsp2b+L3t9s5n+Ta5f1uD/ptcvfu4vfr1/2smzFw1/0fAXDX/R8BcNf9HwFw3/+vrnRcNf9PtFv1/0+0W/X/T7Rb9f9Pvr67dRv3/tnXbnLCHJolhVFkohXUnBMXQJp/cs9Z51TXS5AZFUIqVadqOjqUg1BV8M3z7eUXtNSyumVkzR3Ow/ppbEep1JMTFOb1DKYuxAUQGtQDWNdT19N+GMxXcetEYmrC0lVazvSLXi/UjBorQFKto4rHMULOhGNQrMRlkoS8kao/dUVVmuX+FUwPW3WKCEK+hIM9B0hSqUUk1RpozXQDQnqirUXGgqYrqRFhdqTXjfyYEijbhe8FoOYNdlhc4xjrfkZSasMpEtueYalGXoRs7LysOHR75+fxUFxBpcNXKTKeMQAvP1TA6J3bTn5B5Yl4XaCo+nE69eveZ0uXKc9lzPM1obDIlxmDCm8PB4oYZCiXJY2HTDdBajBCk01uD9JhY6ygS5qljjaA28l8VcDqwNSjWs0czzvNkytG1RssQcMdbIQXVVWNcxr4F5XfFdj3WKm+PEH/93/mU++u7vcF1Xrud3jLvX5G5k2g1Mo4WiULXSFCJE1oqFRWuS1wOgNRShfbTWqM2ORimhoVBs2cGVHLcc4yyUTkUWm1ZBG0vNlRyKTMSXgm2Kd+8+43/zf/g/8v/6b37M21ef8P7+z/h7f/qnfPXzP6XFhLaCsvXaEGrbDsTFNrsBpTVSbfTakpIUQX0/iIV5yM/2Jm2bft9OpOmsw1mxOb+uhZ99ec/bj17hO8saZrHabpqyZT1TpchtSgt5VCtVyYSy3ryiS6tY7cQ6OwvB+vT9lRIbdqXlUFArAQaeiLLLEri9ueVmv2O9rmLPv1FnWhuazvJabguUHOxLE9AZw3yZ+c/+k/+Mf+2P/3VamzGqQymZHq8tY8cb/tb/49/ns6/u6W0POqCN2PoXREiGYeK0nlljQCuDKorrZaFUxW6XGacOZRT727utAJhx1tJ1vdy/IdF5seIPOaI19L3HmorvPF0u5BgJMTB2HaVznE9XciysRLSCRzRrqvTOcT4voBTeDaSQQSVyqXR+T9d7clxoLT9PU8v71GhayL3jzWvWJHlC8+lCQ5NrokTo+kkAjbZl5ZSKcZ55WRnGkZubia7v0FUT5hnrHAaF0wbVDzIlvkpjoJRiTRndGm4r5lRpWGcJMUqxUCpKq+dmbRpHsXtKmaHrcc5y8+rIsqy8enXk9e0N/++/+6dc1nWbF298/OrAH373WzhVyTXRTT3XdzO6wTSOKG04nWZaqZQsQFGtGWcsKVbOl4V5XniwcF0j17kw9bKe/OSzL/GdY3QC5Nzd3oiTgAKrtRz4u47LOmOV58P7Fds7Pnx4h+4Ub97eMTiIa+PzL9/z0d2I1x2989hpwlhNyZEQFvx4Q4qZ6xooWTJcSkmkWOl7g3NSTJeaWZaV07ziO0UMib4faFTiWng4XdEKpsFTuoKiEq8nlqioVfHZlw/0vaylwzD9unL9j10x5m0NaWgttLVSGq/k71ptpFLovUFrsdnJORNCYBzHLbvG82QF1nV+I1QzlUpY5DXwtmNdVmkgtUWr+mzhVqsU5dooainPRSc0+r6n5EzXiY1VjJWh73BOmtJxlGJVmgOhVJUxeKsoSgr9vu+Z5wWA3W7i4eEBkOa/bdZyN8c9NzcHoYqXmXHsCAFevbrdmt+yFcbSbHXe8emnHxFjptbDtt4k+Tjd0/c9xhqMgXleGIZJYC0lehhCkA0PpRj7bvtYQ6tSK3S+4/7+EeMt3TAIMToMqE3Pn+yllmVhnIbn3CWl5fkLIfD69WtCjEKNL7MUf6qilWMc5F7b73fiCHO5UEpmGMQazDm7TSN0WGs4n8+0pp83Dp6ssnIp/Pyzd1IHGIP3lmUJvHv3Ga9fvxKLrHXhdL4SYuaP/vCPSHHlX/wX/gYhivPFbtpjnbwG+2nHq7uPuWwk7/sP79FUPvn2d7HOs64LQz9yvV74/OdfMAwDh72loXDOk0vmcDjye7//1xmGidY0N8c7QoqSHXW+cBwnrvOFRsF6T71CDJlx2Ml6mYWWfYK+LtcZv9l4nc9X+mGkFcmiqrVSapXma7P6e7L9Q4lVYCqZEKMQ+Gxg05ZL9WQHF0Kg73uGTlxn1pwJMVE2hxvtHU4baqvM15k3b96gldlsyrzUBUU2abQWqy3lDKopUBpvDMpoGohNI08ZgQJf6c3Jp2z2f7VWpmmiH3tCSpitIQV4vL+n7zqJjlGbA4mRuJFOKU4P93I/ONmEMtZgrGw2reuKVkaa621j7Tm/aqOvrVY0rUkxPjucyCbERjtvuhRCIKYATVFp5JTxzqFrFfeiLK9F2OzkzPa9UoyMw0jOhQ/re5RqdF1PipGH+R7r7EZ+S0V9//DI9Sr0tlYapRvX65mHh/c83H/AKMX5euX+4ZH7+weMM+zGkWHwOO+4ubkjxkzJlWUO4pzUGXIWIl0yycTuzjtHjIkYo9wbGxjJdq+UUp6nJZ6ewacNmqfcSKXEWjAEmQYyRjNOI60i4GpTXK8y4WFM2hp1T86FdQ2yuXM8EKOQ+7vdRGXlcr2SUiKnTG1V1nGtOB53tKY5n6+4LXvOWHGlOV9k07fvu2fbQKUUy7JyuVxpUn5SN3gX2HLnBDQrSOzPL2uMv9nM/kUN9C9rfH9Vo/2Xoct/lcXbr/r+v+rv/zLXi4a/aPiLhr9o+IuGv2j4i4b/8n/7bdbwF/1+0e8X/X7R7xf9ftHvF/3+5f/226Lfv/bBuLWOqi3JFEoraOUoeSXklX41WDtgtWI9BXahYVzkfP2cx+R4ffwUYzOKSM4B240kBmpNXE+VWA3DtGc5P9D7HSWdWOZ7moG+6+h2lmo9MVZqUXRdT+9HtJcs3xQyvgfbd7jxwJojOTZqixjn0Mbjhxv84ZH1USZwzeiocaHphtKKdbnS+QlrBpSqxBLQuyNFa0gzikrJoIocDJYY0bmSWiGkzPJhppt6vPXoulk1k8jzB0wbCbGIRQeZUreipGRaURjtuF/umc9XSkhb1ndPypX3799xXQOppD/3xi7rEyklZ84pV06PJ0qJONvR9SPKyOTh5TJzOHjmeSWGmbGbeP/+A9PuFZ33zHOSzA0ti9TQeUqrdP0Bjaa1QilyONP3HaUgU49GgRaT5JwKrVWMNcQgB4rOWpTS9H3PaaOAtHE01TDeU1Lm8XLldFkxWoRkN+3Zj4bvfOuWv/HX/wV+70d/k4eQSFTWGJCshZGbmyNdp0lz4ua4l0lMbbbXSHK1oeI6B03R4VnCTKWg0aCFxlRakUJgXVdKqdvUZgEUMsSrQH09MS1ZGRqtLSEslJbExuf0nr/1//wPUM1DzURb8VWjKJQKikYuYJWWaWAlX7vWStWaiiaGjDJSdDjvUcpQcsJtB+C1SEGqmtyzzjpoiZgTWiuWGPnZF+94e3cDSm3iJ/kXVStMU8Sa0E0x9MNmP1PpvCXSKJuwKr1lxSuN0gbroJYGtZBiwA89NYs9kFFitxOWK04LLXiYBr50BpUSYQ0CIChNro1IpTQ2ayMRXq3kYDeugf/o//wf8YPv/z7/zr/9b2PqRQ6O7QBDz3/7t3/Mv/vv/u+FrtUw2g5jNX03UijM5zPrHDldLqwpYJUhrAHrPLSZaewoRXNdIr0fmYYRpz3aVuIaSFFyQdYQebJN8c5DiqhqcM2w1/AhJnqjsCge10RVYK3HaUcsgdP1hHeWw7jn0Hu6yVPyhVYq++OAswOX05XmKl1vcLu77TUAWsMoj+00aRUooikrcIJxhFwxXibAqUWAiq5jIy2ehW0YR16/fct1nvHaPx9mW605LwvaWoZpIqQoa1VplJIFZqGhtMZv4Eo/jeL2sKxc54V5nfnutz9lN02camW332M32rMo0M6RYmE3juysJ7mE045G49OP3/D27iiNXFhBK96+eYvVlm4cxIbIGpzTDKqn66TAzakS4pWH65XUGpcQ+fL9hd0BlG44azgvVyZncVh+/u49X15mut5hvaOWzG6cmB8XDq8mJmPAevy+54Dh8Xzlx//w59zcHHh4/ILrvFBSZsmRNWRizOx3PVNn8Ubz4eEzUswCZfkOrVdSSlyXM7up5+7mhhgipVQqjZQatRVaM6wh45wipJXDNDCOgzzbgpsQYqRWizYDJTXuLwulVfL9/GsL+y9eSrFZlGWqkEM4pylJ7JGUBi1MFgA5FUoVx4y4ZRoBG+UIQiRqpt2E0Zp1lntnGHuMBWsstVWWObPMq2ARrUjzXQp6cyZoSOEp64nemhe10dkCaLiN6s1Z6HfnPD/96U/ph56bw8Td3S0ppa1Qlc0GaRwdzhuOfsfQD1yvy9asKppqvH59K+urMaxhRRtHzgGtxSVkXQPWNErROOeptaAwGK3o9z0xZtw4iDVRTmg9YK1GIZR5inG7l8UiSSHF2TBIrtAyr1jrBA4LkYeHBw67HX3vha4fxufXf7/fU2vlernQ+Q5ge42EjGXbZOm6jhQjnZdNkWEcWNav75vdbrcRpHIN/QCtMQ4jj+fT9rr5LSKhbRszkZubW3a7idP5yny5Mk0D027P8XjHNA3MywW04Vvf/h43N6+gIRlV045ht2e+LtTcqFVhlGOYDuRSyFXhfM/NzSs67/j44094PJ3Y72+x1uCd5YsvPifFxP44oY3dmvBKioHrdWUYDjQkkqMh5Ku1HfN8hab4/OefcXv7Whr9YSDlJE1HkY2kaTeRc2bnZaNpWZYNkorkkliWecsfkyumgDaadV2JSd5jWqV3HtXg7es35CJEfVYbRNfUc4xIiCvvP7xjf7zBe49z3UbWf928t6bY3xyFvu9k+kLcaozQziHIpoLW9P1IK41SE61VmdRQihgkVysVIZdBLO9KBe8td3c35CzfTzUDSja2QgikNTD0vYCOWlxUNJBLxXYG22ns3R0ocdBpTWwUS87ysVrjrH1uyrU2lBgIIZJzYp5nul6yzdQW6yExLXJfK6NZ1pWwrsQYCDEwTdMGYbYNrGOzMFO0Wun7jmEYWZaFmgvn05nT4yPGWOZ55u1Hb6GJJZ1zoqlKNc7zmXWZOZ1PtAa1RMK6YI2i1owiYW1DUbm5GdFGNCeEldu7PWENGKXRNPre0XUdu33Pw8ODbEhY842ML80a4vMEyn5/4OGrryil4p2n1IwxVlxYmmwIPb0mxojlXc5PFneJkiUS5nKR1zPn9DylcDqdUUo2n3IujNMoUOpGzrcNVjXaEHPlfD5zuQYu15mUhLJPubDf7ei6nmVZiLGSc+M6n7nMM8M4bBCvofH1pkopGecky/ApJ9BYseOUCRzpF542e5xzlBB/acP76/7db/Ixf5nrn0Sef9PJS29uXuUX6Pu/ip/lRcNfNBxeNPxFw180/EXDXzT8N7n+WWr4i36/6De86PeLfr/o94t+v+j3b3L9/0u/f/2DcW2hmwiuQNGEGGi1sK4XXu0+RfnKZYXrunKcA+Ym8+H8M372FRztHaM19NaRrolMxCTF2O9ZuhWVFGtYmWNA5YpSmRxPpKox5kCuBV0VnfNEpdiNR0rOyJyowigtD1mutNrjnSKvK+s6S+7FsKMoje0nzLwQw8rQJlqMJJPQ2pLzidZWTOvwnaNeMy1mqlbksOAHhVIOjSauM/MS5YGgoZ2j95NYbdSMcjLV2UqipIXL5SqfF2Uxb9WQc4SWiWvjrB9YlkdSrM/TydbBOcyczo90/SBv7J97lxU1FWhiwZGrpuSM7TqqKlyuKzEX0IaUi+Q5NLBO8/7hkY9/8B2uyxWsx5mOkAKP80xplWkaUVoRE5vtT8Jsk7nrum5WNw2QQ9RSKg3FstlvGGdJKdDZDmU0CilyxDpGqBXVBDA4PZxYQ+V4u2fvBz55+4q/9qPf4fvfe0OYK/cPj/jjkV07YFi5rGfJALcWY0H3lhBmjO/F1hmeScsKGNXQm1UNBkoS0ZI8dsnIziXjrKO2KrkN3sn0dK3UprYiFqgbWVOlOA0pU5smJ0VpCQMkVoq26FQoWg7YKXIAb51Gl0pRWsST9myfvsZMzVeMswxjD8ihrEKL60CppCAHlk/FXYwi5FpLxlChUWJGe89AJYZMqYVmNOua0dbhmxS+l/OFV7c3oKWQbZvtvPVeLHK0wm/WznIAiHwf6wSA0ArVGiVJJnuIgeoM13nl7ZsbpqlnDUJMpZzJdcv0rgCSNSRAn9nIWXmN0xL4X/+v/pf89Gfv+e//D/4nHF/dkNJX/Ff/n7/H/+7f/V/w4eGn7LyhpkC1npQq3lcptlLeSE7JHNKt0aqnbr9bzYnzQ2IJkWAiaVnJYaG2/EwgOmcpVSzijTX0vmfoPefHE1U7rJH8ofvrhV03cI0ZrQveijV2qxBj4XZ/oKTCYzrze9/5Xbpu4MsvfoK1tyw0ci3cvdqTYtxyPp4WeSW2Ug8XxsMRoyvn68r5cuJ6SeRW6P0AtaIAraU4lMPtQoyBeVloxhDiLZ0xxBRhyzAROq6SyaScNpJWiLqwLOz3eylMWqVoTWclyqIpuU+s9UyTiPXjwxnjNNZ5rucLtWTO1xkz7Pjy/oHjTvG9Tz/m4e//KahGSIl/9POfM9jKMPS8vrnl9HhCacO43+N7Lxb3fWUJkXy+YH1H5ywlJmJKnJcrQ+9IrbAbe4wWqnOwHcMwEVPmIZ5QzrGEyBoi+2FA1woqMu0sNUVO1yvDODFfzljT8/b2wOzknj9+4qEMGL/HmkLMTxY0iqG3KN0oSdwm+q5jmkbm5SqNmfkYqhCVJRZ854Q4Plq0bhjbbQ2yYtCW2iK1rZIhZCRD/e7Vx1yvVwqONRfmJZIrrPE3s7oBmKYByZ8RcrqWjNECLdUtyzylRKlCTqYk8RJCfpbnQlCKbbNBT4VaMkoZnEdsn0xh54SENlY+X3LRGl3niTEw9B5nlXzvKlb3rbGR6QWlkKn6VgUsaHLvNtUoJdBa4+3bN3Sdx1lpnp+oa5Cvk1LCeSvU/BaHkXLEuZ7dbmRdF8KykrQ0skoZTo+nzcpoxTmLtYrHxyt3tzfQNNfLum1ONPre03dOSFvjsVZzc3PHcl3w3jGOw1bEBvp+2NxUxJKpVslp64eO3TQxjD3LOrOGQKmV0+lCTlKXWGues+WstWINpwSoaq09N3HWypoNlmYb0zhxf/+A8w7n5PNzLux2O9Z1QbKVIiVLttQ8C+U+TRPWWu7vHyilcnt7i7WNDx8+8PrVDW/fvOZynZl2Eyllhn7ks88/o+88P/xrP2K3v+H+/pHdNHG5dPT9wBdffMXheOTu9hWX6xWlNCEkvvrqK4wxTLs90yTRL3/37/49fvC7v4tSYrf188++4pNPPmWadqybxVg/jBitiXHZmhWZsEBVpnFgXQIazWF/AMSdp9XC4bhHW0VnPdM0CCHehOaW+qjiveP16zuMsfS+Yw0Vi+HhwwfZ9Oj7jU4vz/fosgS63lNpYBT3pwfGcWS+XvDeYTZ7uZwzXd/TiuiVt3ajsZfnOrYptW1ONYxxsuFS0ma1J3pct+ywrvPSBRTJ7WJz5cibRVZJidoK1rstG26LaFHSJNXNUaekgkLI8cv5jEIa5GVZaIA2W5NhpbYqOW8TEeJSUqroSIxBJi2QjbMGLFGe17iuYsPYYA2rQHXabPetNONPdPa4m6hNLOzGaaTmzOV6kWfbegYvUTY5Zbx32wRG4e7ujuv1yjzP5JTo+56cRe+GQUDAGKTJLzVRK5xPVy7ne67zGWhY6yklcrncbxS85Iutq0xVWOO4OR7xned8OvPm1evn6ZQn55VcAiGuaN2oOWDcALXQe08plTVEyVM0jvPpzDCMkteoNa3I6+B9x7KsnM/zM/09jgO1rs8bZyEkQko4L9MbQrRbwhoopW4/0/a7l8w0DuQi68jTs36Zr3T9QG2Rx9OJeRV96DvP69d3vHt3D62xLCvLshBSkcinCmlJLEHs4GoRK8FlXlBa7EJTutDaU25ke56CAIXzjutlRqJ4xKEKvqbQfxUZ/ovN8V918/3Nr/2rfoZ/7Hs3UBrZ+NlAx/qU7/dXcL1o+IuGv2j4i4a/aPiLhr9o+K93/TZp+It+v+j3i36/6PeLfr/o94t+/3rXPyv9/rUPxkvNlAzLOpNyQFlDbQrnO5qpKNXkZiuRVhZqhZgULJG+RVqRH63qhmoV5RprDIzdDfvR0moi5hWPwo87aJUUZ3KyxHimroZx70AVNFBCRpsOSqbhUJ2nLBfJsHYz1/sPxBBQNdObhuo1NIPtHKVUTLOUGmlFU1UjnFbG0VDVBef2lF2k5RPhLLYWrVjydqiblhXcDaqbmPQAqtFsJTxcaDXKx9cAW+GjaaQcKDFjlAWVMKqjNg01sawfaCGA6mhVDsbTukLLdM5jlaGz9vnoDCCkGcho7ZjXSKOj9z1NKfzgebx/pDx9f9VY1pVKYzQd1nVU07BKg+l4fXvkNJ8pwGfv3hHXinWaEjO5yFSnMgo/TJRU0apQyLRaUNWilcFYyXuppZFLQm3WJt451piw28KSmtg9N6U5X064fuAazgyd5l/9G3/ID3/wA/zkCXmmZEXVK/FqUWaPtpWaL6TUsM1RciNF0LWSlpmu7/B1O6xNFZyibBnXzVRCiVS0PDCtbnkMFWPE1rshtJjarKkrVSic1tDGyOG4EpoyhkIMiYoipIxqldLk8FeRRMgAXRvj4OXA3WryNo3egFwrTX2dN65rpaZMejxTSmEcC+sa5dmrYpmkDDQqTluh1opQP+ICo7AGSqns+47z+QFtHTEnBteTawU0VsuCk0pkN4xC0tUqhJQBrEbbHqscTVdaFZsQyTbXaGugNbEzygllHcp67NDJIbdW3O4n7h8WudfqiqJiUOhWpbDIjUIWK3dlSCrTdw6HooTCv/d/+t/yf/2//Yccb95SY+Ly+Dk5RXbDhFaQQwQlgknVKOMw2tHOiVbkGUgx0veWGJPAI6VSYqLTDkVlnU/kHDHOYpwQVzlnMhprPKnMuN4JBFCFlG1FKMyUK00naApdwHaaeT5TUpN7J2V059gfdnznu5/i7YDtdzg3EGJG945lyXhtqKo9n4s3GsPNno4J6wfC40xdIt55/uzdTzFNU0PGaIUbreTJtEatRcCMlADD+w8feDjd8YNXH/HZ4+cYBKBBGSqKD+8/MAz9RhaKY0ZJmRQCORb6Xb+RlB6rrVjZGy35RX1Hv2vMlwVFYpx2G+CRmQ47rtfM/ftH1nllN+xwWlNqAaU5XyIhVbzNVBq3xxs+/+od6f07PvnoI6zx0Aq7/ZGQ5F5JuaC15JtXrfn9T9/y48/fY3ce5RrTMEBzzF99JeuMa7Sksd6hqRz3E7vecdgNAuikQsoJTGOwey6XC/2wJ4+eVzc7VNocI4BdP5CoxCCxAk8ODtcUUYCplXSZUTmRwwomAZqcE0qVjQy0tLpZ82wxGTkpQsyUVQq/2gpZZ9AabQwPp5VUA2sWctMomLrfPGNcKbYCyYgmbJlizlmqkQN33znWGJFoBf1sv6Y1lCJF1RNh2Koc5AtoAUoZVG6QhDq31pCiEOfeiy1V5z3jYLfNgKe8J4W1Qq3nKI4Yy7I+N5xuy0SqFXIWd44net2ab9iMZWlUnHMYY/GdpesmUlyhVkJK7Pc7hs5jjUErjR+EwNfaoGtj6DuMVoyDFKSSR7QRnUZh3VEKTAtd5wlroneeRmMcB3Ipkou0zKzrwu3tUUjued02H9gAHLttPHSkHLDWMQ09r+/uiClxukjm0/2He/qhQ6k9T9lIKSWmadqayK+baecs61rR2uC8J0RpFN+/f08/DIQQAHh4eHy25ROrPcO6CMWNVjxudO84Tmit5e9RfHh/TwyFt28+5jB5Sit0fiSlSt9N7MaeP/vxn6HNz7ksV26OR1pT/P7v/wE/+sO3zPOM854uSWN62O8Zx5FllU2MdV1RWnH36hWlFKyV7/3Jx5/QdyNaGaYttynHyMPljLV2yykTSjaGSFhP1JKpTfHRxx/x4cNXWG+Z15ndfo/3np/85CccD0cUimVZmHZ7tFKsa2CZz8zzQt8P3L1+i/OOGFZ2+51MFhSJ1GitbaS6OMekCF1XcFrTDSMxRHKMWK1JuqKU3uhdT1oDiiJrSt8xzzNeW6CRWmUy0/OUQt4a4GVZ2O2kgQ1b8xtThKYJj1fE0q3g+h5rpWZxvSdsFmkAfd9Lw+U6ck6bvRt03m9A14pRm82gUhyOR6lXtukPrYUKL9sGXSkN7+0GnkkciXMGpw3LuuK2HC0A75zE3JRK18u0hTWO2hq0+g2aW21WeIaWm2wMlC3vrW6bd9ZQm9427SSfbl1WYsqkXDDGoppE6/zZTz5nmia88xgj7/HpfM/nn39OCAu3Nwfm6wPrciHEIBMozqG1wI/DMMrzZTusdcQYiDHinOPmuGOZL0h+myVGWeNDCMSS2Q0TzVau1wtd17Hf7zmfz8Qom3rzdcYohTbgjKI0yXC0xnG9zoRVNlFolfm6EFZ5ZksVi7dcEjlHmZDZbCNVg2KLWNRl2ZyUmA8DSsj0JclETkoFrSzrGphnsRcMaaU1hVYNo+C7n75BacfpdKbrB2KZKUUsB6VuVChkA0DTSEFiYZqSGrPURk0JhZK+YHNJkjgeaWoFVE1S/2xN7q/TaD9NODxtUP6yf/9NGvanz/vm5sAvu57+/eln0JqNzN+iqFqjFdko+6u4XjT8RcPhRcNfNPxFw180/EXD/6Kv+9um4S/6/aLf8KLfL/r9ot8v+v2i33/R1/1nqd+/9k67Uo1eeXTXuF5nBjVyWQKueKEQbIS8QowyuZsVtVTeHgdaSrSlolqhmQpJob1izRlnem5e3XFe3tNUorWe2rzkbbRKmGVhqrkSosE4IxOaUw9aYdCohlhXWIWqQmo0lTi9+wl1jex2B4zrce5AcyeCTpSSyTmQQxHrZKXEznuzj3aHO9Z3n1Guke74CZQBnCa1E0kl3DbdV2wP+YqqltqSHJotC0WtqCaT1GjJdDHaoBti55ELtUTG7sBaMzEUclnJqaDMdsCILJgpSUHzdIMoBa7b7BHWhlKSpV5bBQylJB4f3kNr1Na2aUcYtOZ4OKBV5Xy54KcdN3uP9xoTLEXDWrLYv0wjIX6gtMLQSx5IbXLQ7I3jKbOlbf9F1W1SO9KKZFZ3xuGNJWtNboWuG7heZrxRWKNIypIb/Ct/44f8q3/zR7w+fkzKmhIrVu0Yb0aWnEmtolWTRUR39L4RY+E6J2IA16QoXGOiWnnIlTYyla7EQEdjsDhiiZRtBDznxtB7vBer5qYk6ySvAa3l/WolUzd6y3lLKUomfJVM/eacUVoO0kNpKCMgAg1Kk0zwvu/l8LoUzEYa1ioLV6kNrcBqhXWSnWKNZplXLueZVqEoBbpgtXw9pRS5VpQ2GAU1ZcQdXrLBTavoBuM4cL4ubCbdaAMpFjonIqKt2TIvJNPFWicOCFoDRT4+J6GuapHFWDUaRpYZbSgtUUPmOs80FK9v9uRc+fjmjr//0y/JOYuIdT3rGjFKkWoFqzBYSio476E1Smmozsk0eW7EhxPnsDwDF01pSpODZ+ssMcrUf24XHsPMNO1IWaaEVefpOiHnhmGkHzuu1xOqCQBhtBEizno6322LsGSGOO0Ia5YJf6vRtdKPAyk2fOfQVfOYG6d5fqbFlmUFNMYUBtXR7UbO5xPT3RuUcczLws3uiNaO1jKdtjjvULXRdd1GmgIovGlUfeB8WVmvlfvH9wy7nvv3n5NzEUsZpbleZ4wRy5/WKrtxFKFDE9bIMi/U24KqDbRYwJTaGMYdN8rgrGZZrljrxAqoEzcFkPuH2gjLCl0neUwNvnx4z5IaN3cHjLM460glY4zEE3z08VvmOfDTLz8nxESM71G6CrzQKs5bctbM15XrtHB7uME6y5JWWatS5HJd6KeJ8uFBikpVMQ2WhyshgzZ73t4qrtcTawic5sDxeMOu6/GTp+t2/Oxnnz//XF89nHivGq/jkXGQ9fRyPnPc77A6Y7JG6cJuN9KolJYFArGauRRpxJxGG2hGoZyizx7nnKx1SqGVx1pDNoVaNC1AvxsFPFAaWxupiu1WiIkUC95O5GmSdbs1QgxY51hjINZMVZaqJLrEOo15stv/DS5xZhACtBR55szmNCH2Z1KIeOc2mr08N+Hed8/2QdYaQgzyuytLTJkWFVpFYtCgNKUEtIZx6Ok6ta21mb7rKLlScqFWaaBTKjTEVmu+BoZeSOTWpNDKWQpdWqDv/ZYLJiBT2bKNxnFiWcSqbBgGvLekmHDWEmKCVgkxY63DW0MIQWjZrfGRQlGm+601KN24XM5SyG+vi+k80zA8//6qwmE3EUNinhec9UCE2qCTpieliLUDWiuu11nWsVpQWmOsxTrRKK0rOWcmo2mp0TnLcHPkw/t70PI8W+uY5zNP9nLOddRSeHw8i2Xbfo9WBuc8El3RNkv+RoyRYRgIQSCNlCLOmu13E0Aj5pnXr17z/R+85f7+PdfLyvFwJITMbrrBfmfHOO2ZxonT+czQ7yk1MQwOhSGsCykVckr87t0dZrNq0sYTU+Z8OVHKwNA5nIUP777guoi9n9KiORrNuPPMy5kYI53r6PuJWjPzEpmmiXWd2e13EqHR93TdwPl8QrLvAikF9scDRhmpU/uJZbkKpGc7tDL8zu98X9bCUnBeiPqUAo/nM1RF300cDzeM/Y7L9cJu2pNSpNXKvM4M/YDvOypSlD9NI5htqkBrjRt6jsbSuY6UVr784kuGYeSaIp3vGaaJlKWpf/v2LSUX5nmh5szYD6RSiHGm63q6rics8kw5Z1BKsshQUmO7vpdMvizOLk/ZXusiDVRrMIzjZqNVmJcLMQjNPYwDsQh457sOa5xMAmzTEaZWmTbJmVhlkiQG+bkLjd4OUIWU1m6j4HMhhBXnLa1s8SxWbGGM89Sc0EqTSqHrPWWNNKBpRSoZqyxpCULI60Yj44cJo2QjTO7hQNumNGopHDqL1lYArFpZlxmtFT/4/g9wneHd+3eknNnvb+j7kZvjHfvDxPV64u/8nb/NZ18+sN8PdL3n9Hgmp8Lt7YH5chHnoApf/PhLxnHczINmUgh459kf9pQGYV1Zllk2ma4zba34XiDQVgvr5UKris73xLBKXVg3RyNbSWuiHz3X8xlQ3NwchapvBWM9xjhxHTGOVi2lygaotwO61zgLuTTJMCsZ13vRs1KIKdCQrDKQDc6nzcyYMqC4Ox4Y/Mi8zFhn6LxmGgceThfe3z9QqrhGtfZUq0izqbSQ+mjDtOu5XBaJitJaoK/NbUUpSM/TUgKffZMIl0p9+/8nUPAXyHRr9DbBtOVyNvgn9d2/qiH/VQ37N//+n/QxT/ZzEq2ksNo8T4o8TQnUzRXqr+p60fAXDX/R8BcNf9HwFw2HFw3/503DX/T7Rb9f9PtFv1/0+0W/4UW/f5v1+y9hpe6g96zrPfF9Jr49cH73Zxz8R+DuWNeVsL0ZJQVstng3cdOJTbmvPRhNSYEYCq6A1TIheb6euc4rnR+wxaK9oTbww451vdJqYxhGQshoDJ1zoDU1ZVqpqGbIaZtIz6vYPWtFzTPxcqWkgqVnmAZaW3GxIDknjlwuzOvM3au3VDkCBe2gKow9oseF0CpxOdPrkbFzLGEkr2d8dyDmE2p+xAx3GFNZQ8CaHuPq84GVHJhncq1oZGLe6I6YM844zuEB1cQ2hqKoKEouz4eglUIKMoX9dOUKpSlKA5QmpEhpYhedWyWnxLqs5CIZNZ3XaOvQSlFLYg4Bh+UHv7sn5DNrXEkpC6mlBmKMWGdASba4QlNSwrSvqUK3WaYrZDrcaI1RCmU11ji6fhB7EVXJNbLGha6zQpVphdt3/PFf+xF/9N1PqFTO4T2lNHRzHI5vaW5AqUjLdTtgDYSwQIy8efuKbhqIKQDbA5A1a0kYY6EWVGEj4WZag7gEVFNSWKXEugZ8p7cMBkWaF2IVa6JGxrsOsJvQZbRyYlGRMk2JjX5VkKlYZdE0dNNUChF5zRRwPp/l4W1NSFEjh4SgEPeZigZiThsBo7FWY4ymVqQI0wqjQZmGaZqSK733aKdQpnG6rM/TwwaBKtr2/WJJUtzVjU6FbWE1NCU2S3LobfC+w1qzZclLsYx6sg2SQtkaWZTCRkKdrguXdaGZymU+sB89r/c39N6zOIMrlpwiiib2REZRaHKg3xolR7RSKGfRzqG7BmtAbfbdqWVizfKck+m9QynJ0FDNUGKihsJ8mVFNUbWiG/foGmk50/XdZsvkMcoRUsR6zXqVnA/vFVpbYlxw2pIr5JSZpoHdOBJrJpbKmhLXeeUaCyFV1piJqRBzgNbwFrGU0JkcAsd+5O1hZP78p6who2m8+vgNu8NICoHajGQV1bTFE2yEV4KvLpJzHa4XnGvQEjlW7Jb7XVOkYalNbQSsIZfKbtxjjMX2PQ+nE483VxGG1ogxkHJGWS8ZS1XE+Hq9EmOk7yTDqbVKCIFaC8fjDSARA1orfvTD7zPsb1iuC8bqzRpGrOhLLFweT+wPe370e7/L3/47f0/yd3xHLhVjJefm8fTIm+OedU18sXyO6TyffvwddIPL5SLZ42iGvuO6XuXQ3/dkXck58t/+5Kd8/HqPnxQ3x1d0RjP2jrel4/5xZugs94MnxYRxDucdN8c919OZ6+lCiAnnNNb2tBTZDTtarqScabrJOmfkIFp5TynQkqJkTUhwzgvvHq7Pa2AIQjDWVjgcdhz3R2JqXNcrSllq07y7P3O+nMU1Y8vposF+v8M680wi53xmjZHTIrpRm0A8ShXMPxmc+wuvWuuz5VdrEhNRcnkuOpRSVFXRW0EOUEvFOksIV5RSW+YVQpd/o1jpuo6cAtb5jdZeUFtQWoxSwKeUOZ0ujINYCaUcuVzkHhvHjq7v8d6AerJ3K9vPJWS7MQZjNWFZUdpKk9971iXw+HjGebFU853cq7WIHdpuP5JSpkNoWq0tSrXt9RC621i7OYtYWitMG6GaYsR6z/UyCyzUJFokxYR3jhCibDLUwnWeRSc1aAw3uz2tyeu93++ACzEmQigcDgesc9zf34uF3ioE+sNp5jpfoUEqjVev33C5nFlWIXHj+tQEay5bPtTd3Ruh1q8LAEMeSDninaOhMdahlGVdE103YLRBaXkPrfWsMfHp934IDcZxlPXfHLi9rdzs9yijOF/OvH49kVKgtsw09qQy0/UjXbcXolZZbl9N26ZPpuQsBPFWjJ9PJ6iF+69mPjw88KM//COm3Q7Q3NzckGJgDSs5V26OdyhluFwu7HdHSoXd1G05ewPO9fQD9IOsPc53aKUYppHD4cDlcqLrJI4kZ7nvut5jvSNlacbfvXvHJ598wjgKCT+MA7vDQe7PJBlnxmluuz3zPBNzxGgFuqKNkY0so4VSVBrvJbKD0rYJD00IgXVeKDnR9x2t1We63lqHyfo52qI12O33ANvPWDkej5Qim1J3r1+Tc9zWx8DxeGSeZ6wRmO5p42WZZ6w11CJNtjGGnMoGf+XndcBau0E6gaYUSivcNmnRdUK8xyTRN1orYpQ1wViLdz3GWnExUqAR1xGlNSjQW15ZWINAWrNYKrYaGIYe1eozLX85P9J1Ehnz5DDUmmywLOuM1oZp2hNXePfVT7i5OTBfkqwxTX6e63xFAeN+97zRFtawraeJD/fv2O12eNfx85/9lP1+5G/9rf+ccez54qvPOZ/OPD4+8u1vfczbN7dA43Q+04D5OjNNE7v9DqUcKYPVmhwjCk1KlfvHE7UKQOWs5Xg8Mo4j1/lKagvdMGIQpxbnGvPpzDSNGGNZlpWu83hnGaeRZZ25vTugkfdNacmeNNZyvQRyCfRDz7qsvLo7yL06L9TWWINEdaQ8Y63l9HimVLF0NEY286oW2zWZMqjsdgJFvr+/h6kDpclpj1KNdQ0o1cipENYkkw2dQyGwLdv/D0PP9TIz9B1932GN5jqv2C3rbF0j2mzZlUos3CSrsv45/bHWoNjyLutm0KSk6X5qgoeh3zIXwxZ583UMza8iy3/Rku2b3/eb///rXE+EulJKXKJqkU2l7WtoraBKO/5Xdyz+ouEvGv6i4S8a/qLhLxr+ouHf/O8/Lxr+ot8v+v2i3y/6/aLfL/r9ot+/3fr9ax+MZ62x2kArdLZBPaGu9+zvfpccA+8+fCkHhaludsOKqesp66OQZQygK76zGO9I85VWCq5zXC8XvN/RVMQoTcqJcTyiyJT8gbhEtAk05VnmRD8aeq3IS6KpRjcNtCbTpFpXrFKM08R0c8SpiVwiOi4oZWjKoq1nXVY5dAsLzkiuQG1iM6Dx1FbQ446WNCVGrN1jjAMSNI9yGesMaf1Anh9JVeN70JYt01oOIrXSeKOJBRoajCzqaIXShlwyWsE4TISSoWRS1ZJbUTWNjHMes5FIIDdpToXWzDMZIeSGxhhHypslw7LZoKO3bGrD+brSauF0uVLfWKiWyxyJ28GdVZqwLCymiU22qpQSxI5goxq1MZTcKLpRS0MbydzQCqwXqxHFRh5ZzRIypil6pXC7AaUd+2nHD777Cd/91lus6ymtkMsVazxVjzTvwEtmi9WG83nmOp8wypALHA43vH37Ce/f/wO0EWKGKnYprVWoYLzFKEPaMqTFQV1EyRhIJdHaQGky0eqdo5lEqnqbjpfD/ieyRQgujzGWp2wQjTyASRWqAqfkkFuj8b3HKbUdBhs5rK4VrcQaSW/WPk+WD/JA6+dFie1Bd0bTOYM3ipjr9lqL1UarFas1nbMY14k1jO9AZ8q2KEgueoOmqU0gg67rMNZRgVqT3B9KQA6tLFoBxqJ1eZoPh1bIOZJbQCmNQibkl7DI/QrMy0xOE9C4Pex5eHikITnjrTaUkgn5J9IvtUKrBeM8Bfn7FFZqaqRSaLXie0cuhlQKKiPQgLXkVuTwsjSoipwEPkmtcv9wT0dlGiRDaQ2B0iq1RHIteGSNWJeF60Vse0qt9K6jKY1WgZoqn370MZ21zHGmxYxWRqxotGVWBusaTTXiGkixMHg53HfOMI09rSR+/g/+IW4/4TuPN99iXQJ910NVfLi/Z/DD12JRC+8fPhBKpuTAcTcRKxjruFwzpWUMmlqE8oxBrHhKbRiT2A0KbTTeWV5/9JrxZkc9J5ySbKuWGymu9MNIXCM5C2HqnRNIYBw2gk6hjBaHhVDRTmO05mgHIUPnBb/vaTRSTJRtfViuVwyw63uG3nGdI9503B4s709XrksgD47zdWYticEp3uzeigNFVaQY8Nbw+PCOGCv6STwN9IPHnz0/+eqRU1h5dRzwbzVLaPzpT77iBz/8AV98ceX9T/+UmIs0kMbirOXD44WcM6kUjHXYZrj/6efk7fVTWtw1am1QK857oYkVtKeIiCYwckxJMl6aNI0iv7IGm88eMeZLaI3WtpyhAo0K6hsi3YTi/vJy/UbhwbOQa8W2BsjHqYZEO/yGl1B1YiOmlGJZV7wTd4Zv2tFYK/EEpZSv9Ya2wReOZVk3myP13NQC4tChpPAyG6UoeWoJa9lsbjRrCBhj5OONvGZrLMzrCe871iDxDE/2UIpKzrMQ89dMSpm+V6zLTC6JWg2X8xXvPa0VsfSvhWkUt4gYxOniyWHhPgacd7RaxdaKRowJpYTkf7LoMlox9B3edzzcPz5nDJVSnxuw8+XEMgdiThwOAvF472hN8fkX75iGnq4XS6gY00b/N9ZlJpwy1+uVZQlM456UhGS3znF7e4vvPErBtNuTU8QYy+vXH9GqNM/X6xWAcZyotfL4+EAu8h7l0nh/f+Kjj95y2B8p2+aKNHAZpaDrBnw38sk00nWdxAl0fvvdFEpVTtcLp/M9P//5z/jWx59QS0Ipzfv37ykt8Lu/9wcSWUJjnHbQGs5Z9vuR+TqzLrP8nfd89PYjLpczt6/fsLu5Yxz3oIR+vVyuQpnv9xuY1aG1Zej3z43VukZubm+2Ql0xGZk2UP7JgUVynGprQneHyDiM2N7yO9//wQbxCTg2DAOffvqpuGM0KFvMQa6ZlAUW0lrJc60M2nosmt00cXP7hhwTxorjSimFphvzugroheSKLcuCsYZptyNsf1bGYIwjbxsDsuE00BrPUyRf13IyZfD1fZcx1tIPgzy/y4rRFm8d5/nM8Xgk58y4E/u9ZVmoteL7HmPLVrtpnHUYLVMNuRbyZqsmzWx4nlCJMX9jkkUWJK2lsfRDj9kcSJSW+qY1ucdyLYR5pdbMGhbGaYcxnvl6YT6fcM7ifQdaifZsEzBaNVqphJSxzuE6TyoBZx1rmJmXC+PYEeNKLZVh7FiXlZRWrLPU1vDeMY07QogYZTifH2mt8em3v4MxsknS9Y7T6YHjceJ8PvPm1Vv+4Pf/iJQyX375BT/72RegpfZ4OF2wxrE/3hJi4PbVa2qpXM/3HPYTDThdrlwvM601uq7SH/fkUompcDzccblemM8LQ9cT1sC46/ned77LugZCyCgjNn21Vay2ONuTS8L3Dutkg0GyvyrGKpT2nE4X9rs967xijSeXlXlZZYKFiHXSdA9jD2icFbLdFbPVx1JnOqcxVmGsxppt/c5VNkdpODcSQmI39Rz3I84ZPvnkLV+9e8/7+1msFrd7p3cHrLM4Z5le3bCuCyUXlDJc54U1Jq7XGa3BaEUzT1ZpojGykSVCKDaEPK9VbMQ7m+2b6IfApfL5Xzfa32zMf1mT/k1KXSlxc2m/kEH2FzXqYitan//8ix/19GlaS23wl7Gm+1XXi4a/aPiLhr9o+IuGv2j4i4b/86fhL/r9ot8v+v2i3y/6/aLfL/r9263fv/7EuNqmXLuem/EVrb+Qjkdiioy58snH3+Mf/eQfoHSiEfH9jrGNrPHEurzDDXu8cTizw6JpHubzPaVehW6KBjdoVKkyqdvkMLfrFN474rJge0etivmyUk2lFtBOkXPCdxPeGMgJYwZM17O/uaesmlxBpYDrOmq1GFNIYUVpGLsJ/IC2E7UutAoNA0ZRa6RVTVgK2q1E28h5xuAZD9+Rg5TzFzRtgEzNZiOZihzi1Yh2HcoAqokNdANnJGugojdbbo3znpwkT6UEEQmlNX0/ssaI9X/+raplOyZpQJNJSrHFEbsa13mwUONm313ycw6HagbfO1zf4Y1nTYVlWXn88EhcV2qEx1NkCRHv9DbFreVQUzfQilIUvR8wpm0HsE2yp5XchLVVfDM463HWEZRYzxx6z+tXN3zy7W/Tjx7VDbTquD5+xeF4oNvdUOzAmgvrEokpUKslhpnr4z278UBYVwqF62UFZVlzxhpwCoyTTGmx1VGsa6Q+iYtR6ApKCyUWUmKNkbwWOtvLz48ULKXaTZDEJr3VjNKGJzimNWT6Xml0K8TSME6J3XlR0DS6yWFbziKoTw+m2gpkt5GjKEVtDb19zeeFQyGL9baQplLJWQ5BnREr8JIlhzyEgi6RcexBN5RR1CbkZAqJqozYrBuxhG9UjNpO44zditoGraGVwigth/BVFpKaRdhpSu53paBULucLj/ePGOs555X9OLHMC+s+cuiHDQIwQqzmROc8TYFOiaoNVTeyUmjjaLVAg5wLKRVQilYaYa2sS6LVhtnoWavAGOQA0xhyLFyvK8ZpjDPkdcF5w/l05t27d2hnuLk9YrRmP058uH/AaUO/WVSllME6TDfy8PhAigFn5X3orKMbB2xn8DEzmI7HeRUhqVBLQOtCy5lWFPsbj7aVoDLDvqd1jTeffJcYF5bLiYJFW0e4zqxpQfn+Gwu6oswLl3dnWtcxHTWtBGJTrCEQUqTTvViZVLFUaa2hK9iuJzexTNmPPXf7HY/39zQy+5sjMSR8P+B8x/UaCUsgZ3EEUEr8DUpKONeRS0Gpyof39+RSmPY7Uoy8//COr94vTLsDPzz8DufzIve3MVhvOBz2hCViveMPf/h7XNfAV1/cc3r8QOc0uXYsa8JZDcWwm4Q+y6nw7qt7oG2ZLRbvLWMTujmXTGccLRdyhtMpUIDv/0vf4/Iu0K2VD/cLD+fAwyVQeconSV+rJGznzOvXJBwKhUHI4ifBbhASRhk08qxWpSmqoZWG2rBaII7aKvrp6yhZF2tOGAXWQc6Nrh/JLZFTQjUNiHVP5x0hij2U0ZpKwzlPrY2cIsCzDY5zmn8qdr02+r4XmymlUN5uUQJWnmt4fh+fGvTWmjTBw5ZHZK3oY22kkrcGrm05ZWaj1CV/qLVKSqC1EIXD0JNS3oj3xvV6pdaKMYZatWSWlUSIiWVdOd4cWZcFawxD31ErzEtESPtADJFp6mlakWvBNvCu5/Q4y+/QZpyzGxUp7+nz7xQTtTbGUfLbcklCPPC09iSmocP1HZ337A8H2IrBnLO4s5QFtW0uvLo7cp0vlJIZx4nPPvuCZY6U45Fd7YlRiNR+J/lcrTXGvuP2eOCrr97RWmM/DcSU+PD+A7uhFxuusHB7d0NKiRAifbej63oul6vkHJXK559/Qa3ysw3DxOVyZp4jJWtygnUVdT6fH4T6jZnWMssS2O8LYb3inePx/p5pN1BqwVlHqZV1XZivF4bOonVGW4FEfvD932E3HVmWhXX5wH5/4Hr9wKIsj4/SJA/dwH6/x2zr/v5wpO+HzSbPcffqDafTCe/753tO8r/6jQJOYs2nYL+XRlNpsXG6XK5oo4VW31xLYNtIUgpjLDnP1C2Kp+s76kZbD+NI3hxSZDpha4g30K3Vit0y8rS2OOfou5Fa2BppKEWceIjgO3k2jDG0bYOrtEo39Djv0EazPx62mujrgj4EcdoZxpGcE6UUsYJTmoI05845SkmcTifc1qjq7dmkNaw25JzY7YTSTilxOZ9lAysIAPa0mea9F0BPa6og6OSYZbNACdWvgOv1iu+6bePNPW8SdF23bdQ1QpifN0u8c+QoG2ld32OdbI5577dJl0ioAd00XSfrxedffMGbt2+Zpp2sNdZIxtu2aVWqNObHwytCCOSyPG9EDP2EMWzTKwLaplxQRnO9Xnl8PHHYHxn6AaUaDw8Z6x1d17HGSDcMaK25vfuIYdrjrOewv0Fpxf5w4Ae/9wMe7h9QKJZwJSeZkLg5vMZ5x2U+Y1RDtUKhsT8cef3mY6xxLMvCPF+5XO6R7C5DwzDPmRhnUI3wfma+Ki7zmTVeMVZz3B/47GdfMl8XUmmsMTHt9uz3E9YYSk0YLfllrcL5vHA+iW3iumZcr3DOUYui5JXHh8AaIvvDgeV6IoSF3X6itiyTMCmjlEQu+c5hjbxPwzBuG1cV52SawWjDfrfjeJTnsu8HaIWUKilF9ruJZZ5RWkGrhHWmtUjfdTjrSbHgjCXrgrVyj6YU8d5B08RNe2ptWKu2tUDs+ToneqGt5XpdCDE+b1T9Jtcva4q1Eocufsm//eL1zYb+VzXYzx/Dk9Vce6bt/6muFw1/0fAXDX/R8BcNf9HwFw1/vv650fAX/X7R7xf9ftHvF/1+0e8X/X6+fhv1+9c+GE8h4LRDZUN3e0vtLfHnn5OWgu0GYl5x3rBatsMwL8TV/kBCJndrXqlNYzBo47B+4vLwSKvgd46aCq1aaNDqivKadblg0BhvyDxlokRUgWnoyXUltYK3GmWsZJDXRJoDphNLk5Qu2CyB7BhFbQu0RkpNbvqi8J2n6iq0mupQaEyoJAp2GiQ7/PpArZHO7+n7A0u8J4aAptD1PWXNaG3BSPZ2LYmiZdEz1tCqLII5Z+ImBNqobRpQDgfRsnBa31EbMjWLkhzmb1y1yPR2iIGwJqGE6ooxHb3zxKGXzPXcaDVj7YA1llQiGsXt7R5jK9f1xPsPX/HVlydOJ7nxc2yUtaCNJW9jx67vUarhvKaVijEdrYAxcuhsrMUYsVY3xtBqwRoNrdJKJYaE2ml053n97TfM8ZGvPr9we3hD1Zr9OIAfuZZKCiuXU+C8vOf+/gtev/42OWcOo+SNpBz50z/5U37y05/T6jbNXSQTuCaxH/ZPNJVqQitq/fzA5JSgQcyF+brKFLWVB0k3yJv1kN4yfbVSKCNz0867p3eA2hAbB63RrTIai6GRN2v3khreGYxRoMSmvylZgL55IE6TgtFb+yx8pQqAULdpUZqiZDkcbyi0MuRS0FajtCPVAqUSz0L+ObNl0jclU/hNo0zaDuQ6VK2EsKC0wlvHugoo0vsObx1aGZQpNCXZ30/FvHeOSKUmsQP58OGBZV7pvWJ/JwVKzIU5rHTOYLWWHKVa+TqfRUOprE2sZtb5SvGSfV5LxRlH0YlcGvNVCZVakkzox0xD4IKus8QsUQE5FnKVfPkSMqY2sAPWOXkdW6VmsfQHJVYsObNsjUdKBTcMdEMhl8KaE6/HW4a+51wTIRVMgcf5zBIScc3MlwvKGiFUi+Iw7YgpQpDp4N3riU++9X2Oh1seHx4pJTKvZ/pxj1KJkFe0Uazn93JADZSaSa5y/Nae0hSmVg63nvPcSHWmNbFSH8aJ9TKjjMUZyYSf48pxd6TrHJfThdO7D8R5QTvNugaGbiCnxu6gGceREFfCeiEsEd37zUKlkXMQEEPVZ3ut/x97f/ajW5ueeUK/Z1zDO8S8h2/MTGfaWVVuD2VXIVU1yIBQq0qAaCEQM4i/ggPOOAIhoAViUCMhBAeIk1YjIaqaRtCqqq5yDXa1XV0ecvj8jXuIHRFvvNNa6xk5uFfEl3al3Wn7JC3Fa2XKuXfsNyLetdZz3ffz/O7rijGTKvTrE67sgsMhstsfUVmm5ZcnK7xWpFwZYiDsDzSt53S5pMbM3btr0hTJsRC0wTcNtRRinKhlyXZzz+3NBuMMpUiBsN2N7PYjWUsT02pFY8G6zMp7ttuBf///8Zt0viEmsQyyVtO5horcJ7kWrHWkLFYrKQoc8gCeyMQ3GKXoG6HthIszOG2pc1OJqlStoGRKTDgnDgNKi91RzkJdDqFAKZwsl6QUGKcRrTPeOIKqtE1LCkIfO2ckT75koYmtJ+ZEjIVjnqfVS8ZohW8acg4/qVz/Ky/jHUorsdFxbibJhZRUc5FTa5HGm0rjG0IMPMYnWDsXFjwCNg+5aOM40rZe4AhjadsGJWY/Yv2fxTpea6HZU5I/Z87tmiZ5JpvWz8RkIoZIjEKaO+8Zd0eOwzA3MRmtDTEWjFGsl0sk90tgFaUqbdfgnWeaIrvdjq7rODtbidOHgmkKHA4HsVgr9dFqLh4jxkh+GlWxuT8Q4oSbC0o9N0Io8EaiJ4ZhwmjL6ckaZw3r1YppuJXfIya8bx5hLLEiEyrcOcvzZ1c4a9HWslgsePbsjBgzbdux2wsxn2LgcNjyNr2CWvGNZ787sOgX7PZ7rPUsFgvu76VQ975hvV7TNGJHN00TL14853g4cLJecDjsWK97pulA3/Xst1uMqWzu3ooNk17S+Q4D0iiVSuM6Uq1Yq9ntdoxD4tnLC3ZvN/zO7/0QrSvf+Zlv472naXumuSns2wX5mMX1xsykclUMx5GSofGNZGXlwnAMUGWjJEaBdoyd16pp4ng4cH39ls8+/5y/+Tf/dcI0kXOi5szt3R3HYeD8/BznHF3XcXd3JxMS44A25nEDapomSi545zDWsj9IXl9Kcn21EkAohIBvvFDAtT7CY23bMo4jKSayNgJ6aU23XDw+UxXZ5Mql4KzUDA/kd9s2dF1LjokQguiZMoRpYL/bo41Q5cfdVppbbcgpk9KRrm1x1lKVOL9orckhcpxkwyqMExSpJxZtR6llzppLKK2FBFcKpTSLxZJS0uNaEObG+qF5UPN/aoUwTdRaGMYRhZDmAgoXGu9YLXv2x4HDfs96teTubkuICWsUjXd0bccYRkIInJ6dSS5ZySg0KSes1gzjQNuK6800TThnZMNJaYw1WKNROkMtjOPEdrtjmgIvXjzHe80xa0KI3N9v6LuWt2/fslh0lKxIUbFanbHIa9qm5ds/81fYH7YMx4Hz8wuM0dxuNvzjf/LPeHM94L3jO9/5WbSuvHj2jBIz1zc3VGVZLc8wStMve5TSTNNI3/cSh5Eih+Oeu9sN/+Jffp/PPn/N7c091mt8o7i6WLFsGy4urnj11Z67zZ733i9cXJzz7e8+Y7fd81v/8Sf8g1//lzIZYzwvX1zgG7HXjFPi/HzBB++fs9sc2dxNfOtn3qdrndg9hspXr99xOA78jG9pO0/TWk5O1qSc2R+OLJdiD3hysmYYjsQY+PCjj+jalnEaGIYjKcmm1UNe5O3dDcMQePv2HY1vuDhbwtyXaCUbSA9rjdbQdT339zumKRKmSIoJqzRomdroug4YgCx1dJb36BpPnjePdNciAyOavpdNyxgSxf7kuWZ/Uo7Zw9/9uL//k/7s4d9Jn1Mec9yUEoitlAxFNvh+HAX/Z309afiThj9p+JOGP2n4k4Y/afgf/ru/CBr+pN9P+v2k30/6/aTfT/r9pN9/+O9+2vT7Jz4YD0NENwaLQTtHQXMY7rm8/DbGSnaD8Q7Fgye/QRmP9afo1QlaF0IOqOypdYSc8L6lW+4Y7ydiLEBCtZZaEypnWnOKthZFpu9b9tHMltAZ27RoW6ixUmqixiDWvynQto7MgKpKJkItDIc9rj8Dq0h5wCixPMipkLVC14xSPTkntK6Mu3s50Gx6bNNh/CmHt9+DWClNS6yFmBNVW2x7SrGeXI+0tqM4A7GijINcqEWC7nMJOL0k1MgUE2a29jZkqlbUHNHaYm2BWsW6WcyuqfkP2+gqZYgpkgs46ykpkqsUMjoZSgGjWwJzEH2FMciBU9d1OGPw1nO73XJ3fcfNZuSwmzDOgUq0zvH8+XN8MxdnRpFiJgfJitZay8R8lWnJWhTaeEzJpCSEVIiJWuYH1zlKyTw/veL+7Z5QJrq2Z3u8Y316Qb9ecogDNXg2+5E3b17jTcGrSBgPxFrBONquQSnN3f2WXEArmbRGyaEctdD6hhDlMNVYL7ngWR6QWovkW1eZ5BarCTmQfEgFt8bIIVWUAs0YETGtHLlWcs5ia2IMJUco8iDVXEjzQy5ZDYBWcthW54VEiU1SRQ6/Y6lCIs0/D4jAK6XJD7brVkCDOkMSAI01tIue8biX1cnI9WidwjdCcfrGE8cDyhqICTG411K4WU2dF5BYMqbxVKXx1qO1YooTpUgkQM5FrEBy5jiOVAVGa8Zp5DiNaGfINVOVoVKxZqbctOS0lARGW8IUMTrjG0vTtdzubrFFaFRrFKkkrF+SwoDWDWWSA9qckxCnVckaoeSAfcqJ89U5u82WSkHbB/ihEHIiU+fPDIzSjIcRYzVDHtBKMw1S1GXAOEc8DKT0lpoDqRTW6xWmFEqMhGGiKod3jqVr2OvE5jiCM6ikKEaxbntS34GGxjVcnJxiGsPNu3c01rFeXuCeeeI4UtNANgqVDGHYPD7Xxhh27wYab2hOFuTGEscMUZLjVS1oZXBWE1UlpoxuKm27pGkMqWYOx5ExZiqG1ema4zCglWK727Hbjdzv73nvgw/wviGFhDMOoz1DENscq4W8KzWTMfTLFqMMpIrXhnalsOpIjTNIRGUcB8ZDZbVc49uG4+FIWzuMtaxOT1icrLkfRqxWLNcdbWPpXcuHHz1DKcenn3yKVmIf4xvP/jCx2Y3c3m9ZnSzF+aFVLPue2+M9EU3XyIF32yr0pClFz1RrRRVNrBmjDdbK51VqJaFmMro8PsdKKZxtcE5hrUL4KU3JGVUVRitx50hii66QtTeljNJWQJeiyKnO8QKGcRrJc0RByhlVKqpKfjlVilppRivKQBwDWglsAorWW7y1lJwJKaEq1Ppno/RAGoIY4wyCicW7c44QpkearmkbSs2zTc5sCjHblj1kozVtQ4yRvpeIgpTEDs1oRdfIn4VJDvBLLV/b2NRK3/ViZ2bsHLmhJCMsM1+PJLDbTO8u+hZtDNogRCqKECZCSDTeEUKgbSXHappGGm8xVq7v+fkJ2+2OUubfR1WmaaTrRA+8X/Hu3TuhKp3Aas55jseRs/NTcq5stjtAPTZr3pnZeqqwWi9krVGK7faOUqUBsUax6Bu6j14yjSPWGVkrx0m8CbSZCeDC4bCn7zu0VRwOO3a7e6y1nJ9fMI4jJ6slzhr82Qmn6xXDOGKtxRpDzZHTkwVnpyuU0rR9N0MtFZAmq+9brDZcnZ+QcpA6qnMY01NLIOcIZKw3OGuxdnZSCYHV+gTTWJqcGIaRfr4upRTWJ2uOU+T//f/9R/z6P/4tXr9+y+XZkv/uf+eM737353BNg/U9OSUO+5FS4fZ2y9WzS4bjiLUOEDeWEAL39/dCU6dEmAa6rqWiaBoh2e/vt48F/6Jf8ld/6a8yDiMlZ968ec1ysZg3ehxaaalJUqJrO4HOjMJYi3N+bho0KUZSUuQsUEqKkXGQpnB3H0Ap2rYhJyF8U8qUGVorSZ4FZ61EqSjZ7Prank1hjcUoja4P0ShfR5g8QFA1ZcZRLN4gPuZ7pRzZbe/njaE6W9M1xBQJo6xXD/d+jBKH8WD39tAcaq0J04T3DTWX2QpMstO01ugZGLQzqKm1puu6WW+z1DJBnsMYIzknur7j7es3/L3/4B/w6adfsNvvaNuGv/23/gt89NGHXFxd0vU9/+Q3/hn/9v/x/8ztzYZF3/Grv/Kv8Vd/8Rd58+YNt7e3rNdrvvGNb/D8+XPJcJuJZfkdEykmhI6F+80Nn372B/MaZdjtB7748ive3Wz4/g8/Ybvd8d2f/TZ/+9/4z3Fxfs7Ll++RktzbJyfreYOkIl1SRWu4vb0GwDpD0zbs9jvud1v+d//7/xP/wd//hzP5n7m6OqdrG/57/+3/Gr/8i38JbRSXl+eUgpD24iXCNHlQiv3hIM9IFmvIL794hVaZ7373PV69vuX67YbTvuflN1+y2Wz56tU1+yHxyeev6RcN/+W//Ws8v3rGJ5/8PaZQUQoOaeDV9Q3WOnb7PQaDMpZvfLxgPG74tV/7Fc7Pz/i93/0+X3z+htfvtpxfrMEomtbw8cfvs7m7Y5oiuRpu3u1YLjNaZ54/v+LkZMn1u3d8+unnWKtx1tD1vWwWOYEnu77nfnNgCmm2+ZO12Rip6UpOmLaR+97KhNDN7T3DcRSXpSoNaTtv+DzY1j2Q6SmX2QFH+pw6g6JayXpPlnCixnvCFMnlxzfSf5pNa60lGuwBRFVyx8lz+RM29WaGZUstc5/jwEDJ4hTzMAHDn/Aef5rXk4Y/afiThj9p+JOGP2n4k4b/xdPwJ/1+0u8n/X7S7yf9ftLvJ/3+6dbvn/hg3LhEKgOqKFTWJJ1JGXSzoGqP85Wc5WDPOYsqUHMkF0XfL0lxB0mTqYQ0yIUohXbRMY0JFGgjNh0hBEq1hDgBYh1dKuQUqbXSe4/WkmttjaNtV2jtyVSmwz3ZeapO2K5BZ0WJR0KqqBBl0hVDLIFawBmLbRcUa/D+lMoWBZKfHTNNBzV7qunIDPS2xfVXJBKqeoyFlDV1OJDzhHGaNEasMlTXEoYBbVpqGqg5SXZ1kqwCCsS8QelKTYqaMqoYVCnU+YIaoyFE0myn8XDTKCX5GtrLVLi3mmEUCmsKQvIcDwOGOQt6vo4pBQ6HwMuL96g5c9jvOez3jFPm/Pwc6yyL3uOt5vR0zf44PN5gNUeMkiJFWcmr9l4yX2JMHA87us6j9WyrQmU6jtRa6VxD2zkOx3u6vuHs/IS+XWBUxXc9mUwulbvbPTebDSUeWbYrrp59h6FodsOBkiqqOrLNHI4HOehGDq60nukqY8gKcsxYpQkhgVKP9kG5Vvk0jCaWRCIz7I9oo9FzZkqvukdxLRWhw2ar5RSyHKpOMmmeCzgjXFcsGV3VTEzK/84hY2cLmlzk+4sEKbrGo6NYPT9QYUqr2cZaHmRVK9rLAqWcxRvLeBywjSWlwjgFsZ2ZhNzsWot3YtFRa8Ya+TmMg2kSCEAOrmXSvSrAOjSSf1OAVCvkgpwbakqJuIepb6XIyLN7HAZiFjovhkieEp33pJAIMZFQDDExhokQJgqKKWSG6UBMmSlXtJNro7Ump8zNzS1GaRrn0TqDKrTeS+ByrfOUrsI6S44ZtEZbjTGWB4SpVmi8pwKxJKxxsniWBKUyjKPY0MfZiuphOa6zvY7ShCq2IooKRbH0PXfjSNbwdrtjrAbXtpKHngtDinyyf8Oz83Peu1phjOXbH75kvVgRFpqShvnA1VK1RvUtjYd//I//Kf2q5SEnigrNacdJt0RXT9CJPEXGQ6XxS3A7vDY0dkFeG/R0JBu42e342bPnnK5WKBTPXrxH0y6wOuNdxviOu+s7alU02nNzczuDHoYcA8oY9vuRWgIXZ2dS3BUpMofjkaZvcM6TU5qbL8XdZoPznuVqRRgnNIW3b96SC2x3A2DR3nAYI6/e3uJ9i9eV9arl5GzBi/NnGN3y5s0bhjExxZGaC2u/oChZIxerTjKicqFm6NuO1WJkKgWNZtk4sSKyjhASnWuxFFCKKUUhSdU8Ia5BtWLzVKsUVErPsEwqGFNpGgsYrDKS426loatF7oMwBZk4txCTHK4r5FlNOeG0R9WHbJOHQ3NZm7TWMh0+2xUlCR+X9Z9MTl9DJVoJ/ZdmslQphW8f3Cr+9K8cE1kriSPJGeZm1TfSDGklz2AIkzRAs12OnWEarfia1AZyFveWnCactSiVKSVgrEEbgW9K5HHdFVsqi5hwCAwkLiqWWiPWKLzxs61bom17aQZKQVVFt2jJu8Ri0dG0CWZacByHGRLLLFYL2sbQd57hONL3S7QapcCbidyKI8VI2zga39B2HUYr9vsjOU28ePmMGEecddRcBCZbNDSunWEyJ/e9s3Tdgi++fI11TuqPLA37GCaG44CzhraTHKacK+MQMbZijcY5j1aSdTVNo7BNxj7alz1EoqSUSDmTc+KwP7A+XaONYrfdc3F6wSd/8Ak/+3PfpfECnp2uF4SQOByP9K0l5YQ2ivvbW1IKGO1ovOftzQ2ffPo5H37wHsYori4vuX53h3OOE9/zB198xW/8xm/TtR3f+vhDtuuJz7+6xhJ4/+ULVusLLs+v+OSTLwHF3gd+//d/yOvXb/ilX/4luqanFNnQUUZxcrLi3fU1TdPinCcEmVCQa2NIWZ5Z13h8J19T5rpCSFBN17VCL1uxmKIWPvz4I95d37A+O8NYh2sa8gzmlXlD6aH20cbQNA0VaNqWvm0pVbKsUorSMOdM0zusdTzkKGmtmaYg1LkCGokbkXpMSbQKgDIYq8gpSfOPbNqEIaCAEAPD8SCQlwKrzGzVJhtmtRaGOUKhaRuG40CNBW0kokZrLZMTzoGq3N9vQEHXtSjF41QJtQrg1wpEWGuF8pD9VFGlUmumlEyOMoFS5ib+Ya15QIFTSjjr+Ef/6O8TwsD3vvd9/uk//U2omhAyb6/f8vr1p/y1v/aLLJenfPbZW/7Br/8zjod7vLecLD1ffPoZn3/6KY13eO+4vb3miy8+oe8X/Mqv/Crf+tZ3Hj/nWitt10oNngrHw0jjO3JJ3NzccnNzhwYuTlesfv677A8HlFb8/b//H/JXf+kXefHiOcbKjmIpis3thkplsewIceL6+i0X5xeyfiXPYbfnsy8+5fr6GmcKv/af/k9xe3uLRnE8jgzDwL/77/w79F5jnH5sPJ2zXF+/nTdlKl2/mO8y2Zy5urziv/Ff/y/yxZefcHa2Zrvd8+bNDYt+wdXlFS9evOSjjz9mfxi4v99K/JHz/ON/+h/ROc8v/fy3QBe22wMaS0mJk1WDc5bWWTabPdM08Pu/9z0uLiR/7eJizeXlGcrAcBzoW0uOE95ZpjDhreXDDy9xzkIt7HYbpuDFwm4lP39OiXEYmUIQFx1rubvdzBs9CmtlAiikRI2F8ThRMewPw7yxKpT7MEzUqshRNoisnZ2TkA3iEBNGa5QqlKLmTaSAMxqlIMRJ7EJjQlsHqmCtphRDiFGeO75umv+45vmPNthClEsvlUqWTeM/QTf/uPeUDes0PyeyDsT0oEtf38t/iIb/c26sP2n4k4Y/afiThj9p+JOGP2n4XzwNf9LvJ/1+0u8n/X7S7yf9ftLvn279VvUnPEb/3j/5f4HPXH/yKT/z8S/wLv4Br37nh7z/4pe4+Og52mm+uvmX7D+94+Nv/GXsoiHXAzkbvO8I4y1xFqqYKpXCZvOOk+UJh/09ORa0DmhlCWFE2yU4QyoDbz99x7LrOIZCqZXOaUqcqEScF+vz1ckpKR+5ffuO58+e0y479sM9bSmMxz37ORO41MJifUIMBVWEbFP9BRORxeIjVL1Bq8p+umV6M7G4uEDZE1ifcHzzG9jQ01z8HKpviEPg8NVvUbWGCjEHcjaQDafrlinuCPsR45aEMvD56ztO1qcMwz1n3YpYh/kQxBLHijKZlCpTiISQZsEo3B8GdsPIv/2/+vc4Xk4sbhr+W//9X2AzjNwHx/Y4kEplGgNGGYx1vLu95ebdLU4pvLVz/klHpWCN5lsfvEcMExfrFojY7gTvWmrNOAMxyGTwzd09uYK2RqbrgxCPtchhsLbMBF+mazzO6TnTJFFKIadEiZnVouej9684Wy85Pz+V6d7q8N4SdEKhub4buL/bYL1jtThhsXScnX/EVGFzd800Thy3B0Ic+Yf/7Df49d/+AVqDLUIhaSDWSgIoisYYjBKxl4MqsT4PpVCrLA6LtqG1Dmaq8kHwu66HKjbqZiY3tTWUVKhZDsG+fPOWMUUsiqKQAhIwgDOarEUAjTJYYyhUxhgpKBprWfY9291uPkj7+mcMMWK0xiiFQfJOqBXrPcVYhnHg4uQEQ0FROY4TGEfTeIyq/I1f+suM45HdYUdJhSllSpL3yCBT9DNrZZylaRtMgabxaO+wWiy8p6yIOXEcRizzBK1WZC3U283tRjLaU2EaRi6uzvn2hx+wXixoG0fMib//m/+SEOKc6R6oaLK4TZNKoe8alssW7z3TYSQcB6zRlJRx1syT8FlcIdLsmqDVox22MQZnZPH31s8NgpKc8ZJIBVCWikJpzRQGUHa2h4G2bcm5UqiEkMTOp8AQ9vxXfu1X+dXv/gx3d3vuxgmqYgyR7TgxRU2cIsZobm5vcN5RU6A1Mo38s9/9Ft/5zgesfEtJ4FqJJWgaQ44JYyCHzL/8/R9wer7gf/I/+r9xtz6wvmv5n/5b/0Ns27HbvKNpWwyWaV/5v/9//n2KMngc1CD0pNLcbu8Zx8SHL69Y+IYfvHrH67tbPnx+weXpkjiMpFS5u98+Pv8GRdf1NH1LSZndYeRmuwUNv/KLv8DSO16/eYNSs/WPN/SLnhQz43Ekp8pxGLi5uyXOuVinpz1nZxdstyNffPEK7y2pVja7gxS1xqGArvP83M++4IPnz7l5vefd7Ts29/d0i4ZcE6vVghQzMcNmt6Np54bIWHQqfHF/R9aWFKG3Ep8xxkBB4bQV94ZaSbWQi5DZSknxpJUAMCAAVy6BnAI5KdrWoYwWhwRtqSmTFVgn95oqsq4ZrVFOIREDAoY8ZIGXUuSgnIL3cp+FKaGUADVKayRPqfJgWaZUwbeGmhVaG/b7A1Y7HuT+IQeMWrne7H4iYf+jr6vz1eyqIdlJRpsZKDLyXCst1O5MirdtM1ubCQjwkMul52iQhwP+1bKnlMrxMNB1s21YlIYrxUzfy9oaQ3qMoXBOGnXnxMJNG00Mga7ryDNo0zStWHRVKX68b9BaIJqcpFEzWmOMZhgCxlqBaBpN37YcjkcuLy44HI4ziW5p25bGtwzjEagMw4HFYjG7CjgOhz2nZ+vH66awDMPI+fmSHCdKma2NlktqLYQYOR5HIYAVLBcdtco6Mk2Bq8tznJOitmnEHm+9EgeH09NT9vt7tDb0/ZLN5p7nz55LZtg00Xcd292WrusYhpEwTZyfn7HfH7i8uELPjjGb7Qbf9rx6/YZf/Nf+Msf9jmEYuHr2jJu7HXe393R9x/vvveD6+jW1GLSCMYycnz/DeYu1hmW/xBlLrPDv/j//Lr/xm9+XJtPAy+enNK7l3fU9779c86u/8vN85zvfYble8Olnr2nbhsNhz3K5ZNEtOD07k0YqF0IMtK2nbVustRwOR5z19H1PmmuEYRgZx5FSMleXV6xWS3b7/VzMW8ZxnF1UFN57QkoYYzFG8ZBB9uC24rynzLS2MYZpmsg5SzNexYKtzk1nmCaMtVjnoYp2p5QoueIaAVwerAq1lo2Ur5sTK7Wb1gzTOGes6a+fl5ge309p2ZyKIeC8NP6lVrwxTCFgjRWN+5HvNU3T43OvtZDmD9T7w7PzULp71wg4pzVTikzjAEXiXGrl8WuNMYRxkuyoVjYnYoyPFo1CpQu923Ud0zQRY6Skwub+VsjlrmOxWEnzFg4Mx4mXL1+CKtzc3LDdHukXJ6zXa7rWA5XT01PgoSES2KrvW1KUSYhximglGYcA4zgJZGSdZLM1XuClnLBaMt+MNYQw0jYdTduRskwDjOM0X1eDc4acxEYs58L9/T1QWa1W3N3dkVKa1/ZM13Vo42nbDq0hxkAMaa4LM5VEGAJoM28oaVIMTOMo913j589YE6aRzeaWGAZ293ds7jf4xrNarokxsV6foapCGyWbNmEixsQwHjFGMx4mVus1TSeA6eFwZJwmvvjiC07OToHCfrej8R3TKNmSY5hIKXGyPmUcR/aHPacna7SCaZLMyIfsuRge1viWXOS+q0VcqLz3jOPAME6PMKGdQbIQMvf3B4ZJAOWcCyllfCPPxTCMj/owDxtQcpHnxVmZMJk3h4zR+MZRCoSYGCfJZGsbL9mNMVEKjNNEzgVlZAIk5UTO/ypN/idR5T/6+km/7sf+28f/AmsNJZfH3+dHSXetZqD5R74nyERW+iPOX3+a15OGP2n4k4Y/afiThj9p+JOG/8XT8Cf9ftLvJ/1+0u8n/X7S7yf9/unW7598YrxZkNORog3oQhgmSqzcb76iO21ZnZ5irEf7Fu0bcs0obTDakUqmqHliLhWs8aQc8dYzjQNi+w1t1zEejgz7e/pVg/WaKUa0sZKhrCTvNedCzXL4NU0jMUzklHANoDIxZU4WpwQieX9LDhOkgfF4BOXo/BJ0RWuH7S/wqwvy/Zfk3Vu0m6jNCdadkO01pciof1sU3i7I0w41fIXSl4RRKD9aA5Mml8yUJlSypOTk8BVFjYFQEiFrrHakkJh8QFtD054xDXuKmihJbkStNWhNCkEIkJRlIZgv7sO0Ya2amMTC2liFsZWaimSGGCNTiBls28+TvzJhHavmd3//D+j6jrPTb/CXvv2zHIYJpQp32y0pp/mgsFDrPA2ZZFrYWksIAbEWNzSuIefCYtGLNUjJ6Frng17LYXeEUlg/X/P82Qsap9CzZXethmpAacewT2w2dzirOT+7oGZFHDLDfiA3reSZW01B7L/PTk++noRXQotoNFoVdBUaTCt5VPSc61NmapJaqVVT0eyHCRo5qEYrjtNE1qCswShDY808yanIGZx1hDnr11pDSYFYKlUhFuNKHkJtNDFn+dEolCLZ4g+55KkUtvs9qRaMkqn+EBNVKcp80JZyocwknM4V5zx+seT51RV92xCmA4fDkUXvWJ+csOiXhCD54tlEoQJzRCvmrPAJbS1QySmLbbYRKxpZOAwaLaRfTFAKOde5oIhYLZ9/TmXOQBd7Da0qTeMJKXA47oVKUmKhc7JYslF7Qo6oYgghkVLBWrFP11SsNlhtCSi883Sdx1ShvqqRqfYcA1mLjX3TNcSZwrJW0zzek5aMxnnP4uSEcRywKNCOkAr7w0CgoRZNSQlVK4fZlSIVsdkmjlA0pSY+/vB9GmtZLxY42/D6fsMYIzVWhv0elGHKlaZzrLxnHBLeWRqn6V2FGtgeMp32qKZQqmJ/c0vTLzkOE14pnr+8pOk1KX19gKuBIRw4e/6SOmaO4cAQdry52eKLpxpNLiN920OaGAY4hsLd3R61lMz4FCJ3my3rZcd2u2WaItpaloser2Xa3jtDTYlxiLx6fQPO0K8bsHB9d0eqVQhNLaI8TgFjGzBiJUWY6JdLvnr9VnJ8es9yvrenHLm73ZFQxFqEWtGZmkDnzDgUXr96y25zlMN672najloTGo01CmUUzlicNTTO0XqPLRq1uSfFRCmKWBQ1VkxRYv2uDWG+d40TmxVVK8YamdDWIFHhYpGvjSLkip4nxI0CPR9Kp5LFTUDpGTRTpFqJKWLKTIFWKbhBABpjKvWBskWjNGgl31fpWQNrnYt2DUrIN61kur4U4eeUAaNnWlYpcez4c9DqpydrKjBOgVohhiBUq1L4tp2tlKTY995jtGEcRryX6fam6QlTxDlN03i6TmjhxbJjmkbatiHFRAgJo8TSRneO1bIlxszkotj+P5DJtUjGUxFga5JcEVlTS2W/PxBCQmvouoZxHPBOwIoYghCjrRDaCtjvdvR9Q3UNtSoW/YLD4fhIJ2ptqBW223tQ0Pc9oNjvjqxWa8YpUpUhxopzmhBGIFBqYrfd0bSWnDXDlNjsb0gpzpBfpO87vHf0bc/heBAXms5y8+6Wrm8lusR5Uoocj4FSNG9eX1OBxaLjcDhwdXnJdrellkLTeJq2oQkNtSJ5ab5BKUvjG7quYb8fOB4HmnbFD374Bbvdlpv3N+iaadsF3/ve5/zmP/99bm7u+df/M79A2yv+4T/6bc7OTnnx8ozV8kR+LuvlfojyjFASf/2v/gK//Is/z2q1YrVaoWpluViBMqzXC67fvibExHY78O1vfYflciVTDlrccLyXBnyajtg6U5sFYshQpekchoG2bdFas1otyTlhtCeEiWma3RLmRluaIIGYQgi087V7KHa11gJWTZM898ZwOBxwztE0zWOuXAWUFspNz//WaE2cArUUrBOLPaU1OSa0MbMFmpmbBGl0jZZmP6U0W71FjiHIBlcpJCVwm3f+sQkYR5nqqEU2tij5MScwxAml9WyP2EsW1OwqIVaLgZQSx+OR1WolOoF6nGaIOaNhzi1UWG8xSjGNE8oY2q6Xz0nxGCMRU5qbI/PYjMcYaJrmccPBzLmHprGsTlYMw/C4JlmjqfUS7xpSzIQ48q1vPKNWTcpioya5bYr9/sBDPIxSAqMe9qNYd1Wx96pF1sEwN4zOSjNeSpkz/AyKyn7cc9wfWCx79vsdpRTatkOhaRatTJnUTAyZWhzWOXKe5o0GmYCJMXF6ekrXdRyHo2ziKKkHD7sDzluZ6phzIPfHHcNRfqft9h3b7VY2oBYLUgqiN8NhXqMT1ir2hw27+3v8bB+4udsSQ6JpPIf9PW3bMQ0TZW6Kj8cjKE3TtqAz1ipqqWw2N6Qo+ZBt02Gw3N9v8L6jaVqmINdYa7Hf2+23hDDJejw7bMWcMdbJBuZxpO9XTNPEMEw0jUcpaX5TGh4z/EKMtE0nGV1VzzmPhSkUDoeRlGVjrO/7eRKo0DSN1I5F8uceJlGUguWild4tVbTRc9MqTix6fg6pMI5xrin1DNfOkyBVEX+kRvqjWvifZOv2o25bf9zX/UnN/cOzU+FxXSpVSHelFLWUP/R+D+9jZyj5wYHqz/N60vAnDX/S8CcNf9LwJw1/0vAf/3U/zRr+pN9P+v2k30/6/aTfT/r9pN8//ut+WvT7Jz4Y3x9vKMdC0/UUJbYaxhqmcC8HuHFEV4tSUEuWg2eMTFKXINbqZT4Y0WIhq6mE44ixBmMtUyqkklifnKCcp9TC3d0NuXpa6wk5YGfbaqUV3jvScURjSGPAGy/E1TRCgeX6gs3hhqkMqFpRGsKUqNmilORmF9eifUfXr1A5AhXtWprmJSokcpqwtcGZjrr4AF2+QKV7xk0mhIprWwqKVAbGaaCkijcLOaCZEkUBaSTkSFIaiuQBVDUffudAmYuhcRrJSVHRckCjqmQKgxyyPF6NSqaScmUcI2NKON8+LnolzZYdCqTUkgcBVeeHrOC8oll4Lq/WeFMIqlK1JqXIFCesNuy2O5lwVDDFgHb+RxZrIclCSpQqFinWwDgKqbdeLgBN6CLTcKBtPMt+iXFVMptDRCtZlG92I9dfvsX6yvnVFU4rQgrkMHK8f0dz/h46V4ZJ7CC07nj27JJF1zCOYoGTldxPULFaDrIUlUXfzoSLfBKKitGakuv8yQAKEdma0VbPFh5HFk2LchbnJfu4VCFOlFbULIfBZhxRRt4klSIPrzF4Z0m5EEulqAp1zm2YFxxFJdcyC3nFKilKjTYYZMq8Gsn/1trx4sUzFicnFKMxtdC0Htc22HYpB/2lMoRpLmYD3jlM0DK1mzN5ptVKqUChJJmmNsbQOIPzDt84VJX7J6QiC41ShDkXCa2pRXKQay34pmWaIt5ZaKwc+uXElAOehlZbjIG+9eQY5ZDTyP0hWe9CyUq+ihUIQMMYAt76+WcQGiqkjKoahSEMsnDnCmEMjGWi1IpyBeNbYlSUQ0GZDm0tMWdiCbimQ+WG/eFIqTJdLPdAxTqN0xpKomrL4mSF8Zo3mw3HIcqBeNWoaujbjt0UGWPAlEynCr0q+JMlGsfJ2ZLLq2c8O7/gd37v98l55K+c/Tw5Ga7zLVplhv0Be7pCKce0Gx/pJq0Nw27D8mRJHkbicUesFr9e89/8H/xXuXn1JT/86nOsD6TsUDpzmQqf/P41n7265XqzZ3M8UK1iSonDcSRVsfBfLpY0raFmKLFSimKzuQdlsM4xhEgcI9v7Lc461v05X726pvWe1WpBzbDdbTHWoo1iuz/wjW98RNN3/P73P+Xtuy1tu2C17Hn27JTtbmBKmcNxoOSMAYopXD1bc3F1QRoi1Y7EKWGcIcutyTBGcsksl6vZEqxwturwXlGDAmUerc9jDKAdysh9qoEcK9ZAiVKUODvT0V4iBGoptM4RYyLXitYNBkWOiVqUxESoSlUK33gBS6rYcOl57TPKzHBSeaRIFZqqMgo927XzSNhOUWCcnPJciCihxKlUoxmPEW3EPr7vhXqudf77ivwO/KvFwk/6Oh4Gocir2IWVXB4bVrGIkmZBz5nrXetYr1uxzqqV/X6QIsNoFIpxONI2Hqs0pm25vb2j7xf4ZnZjMArnNSeLBUoZ7jZbppiIKVFRNMaxXi7Y7wuL1nF5thayNCamkDgyzAWtpe8bck4zuT3glx3ee+7u7ijzfaJ0S9N4SpHmxVrL8XiQDQZjOB6PXFxcEOJIypXXb26ptbJYtKQ8YYyjFtjvD7MWi3NB2xl22yNt3/PVmzdM08T5+eKxkDfGUwpMY+Tt8R3OfW3NtVj0lCprnHz+A+eXF7KOGFBV0foe3zh2uwPeN0Lpl4xShsuLK47HI+M40vcLLi4uKRVSLjStZn1yijGW919+QIyJkI7ULCR/0xh+8Ve+DShePnvO2ekFf/tvvcBajdaWu7s7xnGEVnN2ek5FoDZrGz7+4Ju41qGV5ezsgpt3b+T5r9JYNe2CxVLWe+8c93dbukVL33fc3txwc3vNs6srUF8T5ijFNAZKEarZzQ0PiKXa1bMracy04nA8opWSbDtrePbsObvdlvv7e66eXeGspQBt20Mp3G3u8E7sCUPJ9Islq9Xqayq8aR4Jdjtn9RmtUdaSUxaI0EjGm3eKB+ulTMV3LapWaWK1Qishu5UWqMs4K24VJeOVocwA53Z7z+XFJQUB4rQxs9IIxBdiRNXyuPngnEMbw3EY5jgWI5ChnvPRcmG5XM7kfftoU2etxTYOXZnrEkA1UCvdwuF989hEaK3BKGpJxLlhK7U8Ng4xqpm+lXrFGIPRsjkQo4B2EktSqTURU0Cpws3dO7bbez788CNqkZp/nKSub1v5WY2Wz02yFcUOrJSApj7mqznnBV6sX69NKSVWyyUhBGIQe8XLy0v2+x1N07BcrfDW8dlnX/Bbv/0fo7XixfNzVC28fXfDBx99jEJI/PdefsAPf/gDTk5OiKlyHHZim3g8UnJhtVoR4kTZ1fk+b5imCWM0m80dX736DK0r4zhiXWW3v8U5h1Lw+vUrhmGkadyjJuSc2R8P5JRR1jKGQFHiZBKy2KQdhyMhREouVFVpgmwwDG/f4L3l/n7LNMoGqrWO/WHLOI0chyNqN98nuZJSRiuDtWKReHKyZrPZ0HULDod7SqkEpWZqf8swDDxswub5PioFpiAWaSXDbj9QquKw33J7dz9PCMR5WkMmIB4mLJRSeNdgtGI7DEzTxHK5nCchKm0n2XXjGKkFATKNYj8d0VrTdy0oxfEwMgyTkPylSNTP3PM8kuFz0/yfRJ7/WUCyH9u0IxBs0zQyzVHKXEfPFoilzF8lP591du6z5Ll5mDD584Bt8KThTxr+pOFPGv6k4U8a/qThf9Lrp1XDn/T7Sb+f9PtJv5/0+0m/n/T7j3/9NOj3T3wwbs2Eb5ZM1ZJqJk2RUjO+7akVpjCwXl6wU+/IIWGaSklQSZIFoRQpTXjXE3OmArFGxhxpbcWoVhZhIxkIURtqyfRtz1RkMlophbMWXSGVQfJjTaFkReMtJWV0NagK+/st3emadnlBLYHh3cAQJgpCpLW+BeclY6UmihZBVzFiw0gtW3S/QsUBcg9WyyGzWTHWHaUkvDMUXTHZ0Z1coEzh+u1bwBP2CYshU6CEeQobQprQSmNtg1KJKW0wqqVWI1mz9WGqGUkHzwUKdE37IxPjki9TcsFby/V2x1JbnHXEGDgOA85LJnDKgRQj3jlySZRcaNuGZbfAGLFWqKWn6Tx3uz3jNOGcZRwGUoyo+bBcGUsO8w1GRWHISnMYDljr5kN5mc521mG1JhWRoLZtOT87FahBKZy3YgmyOmM3Tdy+u0eReHb+Am8s07ilW65ZXF0yjFHs2mPgeLyn5MwUAk4ZVn0n9i9aQalE+dBQpeCM4WS1wGhFGTJKz5PH8wNVSqUqmSwPMeKMRs+HreMw0nqheJSSnGqhaRToKpRKrThjcLM9fy2Fbj6AqznjWsmQVjGgrUMZmWomzxPis8W7cw6DEHMPREzXd2glWUOEibZfo13DkLJQdLWyGwc0BmMcjXez3Xvlg/MzsbyeDqhacdqgKKQUhfZLIshGa5w1UvyoSiGjNDIVXpghiSQEFrOgV5kWp8rkdghCtx0PW6w1rPs1dn5upzBiXIvzllwLjTNMU6Bzls6LlXvSQs+mkiHL9O7tZi+WIlWcAdBSwNYHKEHJCL1c8vk6KDnIJFjKELEuk24OoAqlZk7PTtAoWt8wDkdKyTjvcVYsrFAaZxzaKZzToCwv3ztD1YJVFpMTF+2az2/vOcbCfvOOSWWwcLZc0ZaESpmbzYarixdY6zENNMbwrY++y308EpOiaz1rc07bLyF7Dod7tHYo01Hm9TqXTMiJOML19iua1nP18gV6seDXfvXXOFl07HZ7Vqs1OSeO+g3Pzy/5v/wv/q/8j//n/2u2DKCgpoJJhd39EUVlCIV0t6eWgDGelBC3jZSpupCBVAutanl7fSeuDm3Ldncg+MLl1Qu80zRN4f5+RyyZlx98wOs3bxnGiecvXnD97obbuy1d25CLFNt5CjhfSbGgNTSNYn22Yn2+xpSOVCr712/olz2LRU+aMrvdjuV6xXq95u3dveSchEjf9ezDSMn1kYDVSj6zmMV2JCWZ1K4VChWjHjK6xXZHWz8XvA+iWTBeqE+rLUoZUsqiBUpTQpT30LOTQpEp8aqqFPN6BpDmwlkZRZ3vr5zyI7HX+o5S5uInRxQVXRSlKgriclLRxBxROj8W77KeWlCKP7sJq0QmLBtPLRIDsVi0WCOao7Um54y1QnSLpY/kJgEc9nuG44DR9tFmR9FgjOJwOFJyYtmvyCXh5+IuxcRi3UsxnQQgqDnRt41koNXKatkzDjtKDmjV0HSNFD/e44yh63tSmCg10Tby/aKBQsZ7w8v3nsm1ypWzs5a+a4DK4TDMhL2X5ixFUsoMw8Cr11uurzdCt3rHL/3yC9oGIe97T5oL1E9+8CmnpxdoY9jtt3zx5Vu++OIdNcP5ec9f+ksf89FHH7DbHdnvD3R9y3Q88Pz5c3GqsI6uF9cMrS23N7e8/+ELvnx1yyc/+JJf/et/BWcqwxB49fo1h8OBn/u5n2MME2/evMU3jouzUxovBOjLly/5/ve/j297vvkz32F7tyGEI57MatngnGFlT6XmqorV+pLjeGQ4biXLDtloyaVwdnrGy5cvuLu7Zb0+pZTKcTgC4BpLTmLrdLu95gc//F3Ozy7R1pDyiDUNf/DpH7BY9Hzw3kegC+3CYGzlcNihjeaDDz6gztCV7nu5Fr7FOyGh4VwgMa1p++6x2M5ZIhmMtbNtn9DfboZYYkz4OZ+sZnm2i9a0bcvNu3cs+gV93z1m85mZuu77njAFKahzoW1bsQ/Umm4hmWmlFpwX26xaxB1nfzgQ5nrMPzbzcw1WBLQJUXLRYoxQwTdCqJ+enqKMwVorZHwt7HbSBJ6cnEKtHA5CcctnAjlGrHVSTwBKaUIIOOdm+7mv87XGcRTa3Bqc9wyHAwqFcQ6l7Zy/VmZK1sy1mX6k7r1v2Gw2xBi5vLrAGM1isSSnLJl6KdG2nmkasdYwTZFSK3jEcs3LFEDKlbPT51ycv5QJD5UppXJ6dgrMNnZKgZIGxVjZECzIeuOcxFPcbzbEGFAosVSbe4a269Ba0yhxk9nc3bLf7Tkej7z/wfugFPvjwJdffslv/uZvcHlxxgfvX7G733F1dUXXdNSaaRrLq9ef0i88qMh+f+D6+jWb+xv8vJF2c6u5395zenrObrdju92y3e2wxrLd7cg5sl4t6bqOzz7bczjsaVuJJ4phhvNUT85FGnfrOB6PSM8mVP52v0ej5mb46+kd7xqmceCw2ZFKnZvtSI4CIGZVGUPCWkPXL9jvD6SYWC6XKCV5kiEGbm9vabuWcQyMY+R4uJ1BxIr3fr53ZKNBNhQ00xSZQmYYAlVLDb+933M4jFjbyHVHNgDWa0/btBwOIyFO8yaL6IUxsqa2SXL1HvqYlDPX17fEmLHOgRZoz2t5VsLs3NI0npwLx2EkJTEkck5sJpWSzM0YvlbBP67J/dNatf1YOl3PIPJDXZYrUwikKJvKpfxRNf6ahq/lazvGxz976Ov+HK8nDX/S8CcNf9LwJw1/0vAnDf/Dr78IGv6k30/6/aTfT/r9pN9P+v2k33/49dOm3z+5lboy7A/3NM0FOUykccCq+UPcb9F+QeM0WPVoD6NVJVCwuiXkkSlFfOOwOqFo6No1aQyUCWI+UFHkaSIqjWrk0NEoQwpHjG4wRlNzBrRMGJaETC4blFXEFNBaEVIkHm+xNlKNwzdrkhsxsaHEQqkHajnBVA/FUOOOWiKqaqxtKaoSwx3GdWi9QlkLeT4O7s5w7oSw31JSIk8KYxqSaYhjJtaEyQM1OmxjZlLLcEwbbB3IpgNtgUzKE10jRUMmUKLDaMmNiTlBgmoMUUXS19gGMr0stEdjK513HMeRtpHiiwy6qpkiAeab1FixAne+Aa24OLvgpD/BWMthCEzDgZIiU0zzIY9k4uqqUdoSY0ZpK4c6WoEqtK1Hays0jTakWQxkEluhnaHTDZ3xaKvJNWOM4uTknCEr3m7eUcrEyckSreTfNa7Be0OejjSqZ7/fchi2bPY3hEOiAsu2x3pDQqFKxaOoAkphtKLzjpIyyjkWyyW5RFKMYuNR5UBcIQXMVAq5FAEulKIWQCXUNGGNw81WyWKDnMWiJFe8dbRerB3KA/VW5AHUxuKNwBrOeQ4pEnPCK4MyRSzhq2IIQWyca8VQ5bNLEVO1PA/KoNDsx4jHMEyj0FwGrLbkHGitxzhD2zn6VOQzVhVvNSkoDHM2RFQYJzYhcRxpvNhVV1Ww88S9thBCFlsnrecDvsQ0DJInpC2m9ew3G4bjwPpkjQ0OakFVsfzQ2aBiIahMnILQelpjzNeLZckVUxVGW9AaYxWqyKQtViglQRWE9sMY/FzoKQBVZnpQDkGrMgxTYhoiOR4fnhKU0RwOB9q+J08jTdvKGqBholK1IYyJcNijncG0nhwyF+uWxkCjPQ7HD169IhfNynnysuOwu8dEQwgZqFgM56tzxmHi2+dLXr48Y7c/sDlETlYdIewxTtG3C0Is7MfIZnfkvRdX3N3ePz7ZWmlevPyQ7f2W9arnxXsfcrcfOHn5kqsPPsC6Bd05FK0wObJWH2L0Eu+/xYtn73N9f0OYLYViecikrjMxmUmlUOokB8NUCpoaK1rL83C3OzDFjNUWa47kVNjkid3he1xdnvL8+SWuadlstrx5e8dut8U6w/54oCrFm5stb27k91kulxzHgVIruYIqlelY+fyLG9692+JUg64QYiHsB+6Hif0+kFNilQrbIbHZDlhjGMcb3t5sSKVyjCMxV4pyGFUwBqz2xCR5NNp+DRXVitgQVAEqas7E+XnPuczZP1miPwCrrFiva4U2nkwgV9BFPqPZ/RzJfrKUNHF+vuKwHxiHTIySxVRnarVSiSnMa7AiTCPGasgZXSSLvJAo1WLkxiZnKbwrRfJvUqYWySL7s76E/hS47ORkQdd4rNGkOeemlExKmWmciDUTQkKpAcki6nh2dS7T+SgUQryHIJCF0VKktZ1huVqw3exJORGiZDeBfN+m8bSNwzlDjIXb2w25VM7XJ5ScefP2WqyAfCNU+S7QdTLNf3p6xuvXr2kaP68fst4qNDc31ywXC4ajpesaDgfJL7u8vCDGwDiOLJdLYgxcXaw5PxU9ePbsCqMyKWTGMbBarXBWYW3lZ3/umxyOI8M+8dFHzzk5XfOtn3lJYxu61mFMIaWRt9evORwmTk9WtK3jOBzo+55FvwQq727esdse6NoFu92O3e6eECe0rrx69RV3myNdt8C6ju//8FNSzFxdPefle1f0rWR1ee958+Y1p6cn3N9v+eyH3+f87AKjxbljs70lxiJrYamcnp3R+Za7dweMtlw+vxBLqO2Rrl9yHA4Mw562kYZ5HAcUiqYVG6zGKUIILPoFJVexi5oifb+gaVp+6Rd+GW2gFo3zhsY30jB7xXrt8b6hFsTRJ6U5V0ro1c3mHqO1NN1zbpKZdVMrQwwJY+3j/SUgifxO/aInlyJWbm3HMIrTRtd1vHz5HjlnvHNUpTHOPhLW0zih0VIPWMU0ha+fiVof66P6QMSiOAwj0zCwPDlBfGYgxcjdu3tpEhtZb7z3GCvfq/GeaYhY52jmxr8CJSdKzhwOe7Gva1qmYXwkuacpMI0BrRRGGZQzjxZq0zjgnOQC6vnPHnLhmqaZqeiKtR4NEt+ipAaWXKpKyvHRXguF2HsBy1XPZrPheNwDlaYReEdrsZazUYj5OEx89tknrE9OeHb1EhQM00jjF0Ahl8g4JYGX+hbvJYrCWksqkhv3QPGXkueG1XJ/d4d1BqsN4zjSNC1t21BTQllD0y2w3pNSJk2BVAXU7PsFy+VqzjXLdJ3mr/31v86v/rVfIaaEs7JGbO/v+eEPv88w7vn888/YbG74xjc+xlnP9773PTZ39yzXPf3Cz1FDAj199dUruk6gy/1+JxlermG9WiFWZIlaZOIh50wulYq4BEkOmNyf3nnuN/csl0uYN1iGwzQ3w5YHhyfvLE1jSNFQa+H0ZEFF88Xnkh0YokTg5BxRqoidpapYq1itFtzf76g1s1z2OKdnez+h16uC09PTx42CrutmMj0TY+Zus2W/H5imxBQFOg0xopRMDzhvUErT9w0xTCz6VgBFKo33+EbsE6cpYI0mZx4ty3Ku7KeDOGHNTku+EUu6aZqf7ZrnjUuNc1WmfbIhhvoIm+n5/q/5D9Pqxpg/RMz/cRZtf5o/B3jIRmTerJOpjkqeyvz36sf++4d+68e97593Wvzh/Z80/EnDnzT8ScOfNPxJw580/C+Whj/p95N+P+n3k34/6feTfj/p90+3fv/EB+OLbsVt/D7aLln6U/Aa5Rw5BVI8EMcs5BsKY+VQqmqZ3s5kUkx4v5oFuZJKxDiDdS2lTqhaCDFS57m4NEx416BdRalE366YquRLIM83Jcv0akwBqgEMWEUpiUKWyTxjqNVgGoONDovDeYuyiqIycfcVLHuKWeFcpSTNuH9HqQ1+tSLUCWsrKY0YpTCL50I7Hf4FcbxHYyk1QXFMk0wZaiMEnSm9ZKFrj3UtqIGcI8Y0VK0wOJxdQt2TQ0Bl5PDdaGIEbSzoSqyV3WF49NCX6dlMCJHDcaJvW8b9wPE40roW7ztUkUNDZSzaOYzzeK+IMTEOE12zwGrNcRjJo2cahpmOyZJHrDXOWIwzjCVTq0xR5phpvKPMh5TWCm3lvPwnRZmITDEwjIGKQltNiEGs5qmEWtA68vZuy5T3XF71rNtexEsVzi7fQ7uecb9FGYWqhZOTM5Ku7NgQC7S9LOAOhTNzrnIp+MagVKFvG5z15FLxzpGyECZKGx6KRAqSPa4KfdfgtGGKCe882mj6vpcHH7FxMVqRSiIlyW7PJVPQ6KootTBEscCoCobDHoXQYYGJMcmBfqqFSCUlkFFohZKcAZl4nwKEJM+REmLmqEc8EEpmnCRHRhtNqAmjHUMKqATGKobjgCo91IrSkjOvjJqt0IUoykDWhlgirfao+XA5l0yaCiEVSpGDxYcCKamAtnIvVaUoBVrfMB1HtFI0bUfMmeM4YrTk8MSQaLxn3B9xc9ZLKUDVKK/lYNIgdvFFCK71SY9Rc4FoPJRCmCaqlQzpWubFupQfsYZXUEUERjWRq2TUUCoUSCEwZCm+Rj0ADozCWk2YItMwygH8mIjDiNaKbz97xsK0TGPg3bsbWm8xaGrW6LFgZ7pyGgXIGFJkuehYn7Q8f36KdyckPfDBi54hHtmPe9J05HxxASWzPjnh+t0bmr7HHgces3qMYbFY0LQdmcS4Dxy/eo3rvsGv/8N33B8+IexHdGfwKRDKSNyNfP/1G16++JBEYpomComcJc+9ZA1KqLhS1UzVaaDM9uYK+b8qQnqQa+obTy6IeB/3vNm+4/tffDbTcXE+gJeckpyTTDVXHgmvaXMPVckaYKyINZW311swEiegkPygkotEMmhZP262e6ErUwY1ZxnVOQ5Bq/n6QimGWEHpBEYw61Tma6/AaUXMgVSEfDPayO1SyqMDR1Eg2RWVSqZkyEVDyuhSUEqyypPKVJVo+paSM2lKlJw4HCZqEThGKT0/HxJfEYKQgjkWjG2pOoHKaOMYS8RnLc9dkYI61wjKoFPGOYOZ13oBbuJPLOx/9DWNAW1kAv1wOBJjovGOMI2M40SIYiUkGS6KpmswSrNaLMg5sbvfiVOIMrStkLtVablmSnF+scJ7yzgc6RcN3kszNaWRpmno+0bycLqOnDOb7RaFYn1yznA8zkS7aNswjBLHsVoTY2I4DtzdbWfrr0TXSS5Wmt0vnNOyzinLNAW8lyLucDjQNJ6aC8ejOCn0CwF92maJs0LAllzo+tWcWy90ubOWk9WSdV85OVngW8Oq83jfsr8XS7rF0vHB+88IIXJ5fkFIAWsNKUYOh8Ns5wOXlxe0Tct2e8fHHzzn4w9fsF40LL7xMS/GgNKa5WLFbrdnuVigjVgBKaMgwzAe8N6CMSzXK85OTvDeM272MNPL65ML2qYjxsAwjngFq9M1JSe+/OILPv74W5xfSNYaVTFOE03b0XQtTbsgxknu8ZTw3vHxN77BYnlCyfDP/6N/zhQCvrG0uvD6zSuWi6WQ05Ol9muWqxXDGPC+lVicaeI4DjhjaZoGYy0oCTtxzoutVIhoozkeR6wxNG2LLvqR5FVKMY6TuCeoHm0Mb6+v6bqO7faeUgoXF5eEEDHOcrJeE0NAzRlqqUZx3FGgraGxc9NprOQ4IWDcg/tIjGkGsQr3d7cslwu0kuauVFnj7rf3rBaSbeW8f2zscxZXGqU10zjKGjyvMdPxyH6/4+rZMy6vns3gYME7DxVU49nvDyjnYI5yabt2br4bUs6kEHDdrOszCVuL1A3DQ0YXSGQOsoGgFcQo5HkKAYWsJQ/keNd2DMeBYRi4urqiKs0UJrFntJYQAw9uG1dXL1it1xIfgUwVxDTy4BTUti3WSZ7YQ3ZcivL5FyDlhNheFXa7WxbdQjZWhiPVSPaY0oZhGCn1SK2J9tix3e1Yr085O70gTAVrDP1ygdGGw2GPUuKU83u/+zv88Iff56/8/M+zWp7w9s01n3/+GSmPaJ3J4ciyb/n0Dz5BacV2d08FcqpsN3J9Sq30/QJn7WNm4WKx4u5uR4gVGyIX5yfc39+jlTTkzJ9vVQq3XDCOA7VC08jmoPfi1BRDIYSMMZ629dRaGIaJWgrrk5WIpoaCYrcf2Gz2vLm+4/z0lH7RQp7wTlxudrsNi75jfbKm5MI4RGLIdJ1jHI+z24nFGEXb9MSU0LNV5zgNaG1Q2rA7HLl+t2E4Tmht6Bc9zjumaaLxkiU4TRPeOwFE5+cyxYw1GjRYrXCLnloztVaGIVJSkc2uKs9STLOdorGoCuNxeNykALDOMk2RcYxYq3HWoWwkREi5MgWpvUUfvm5uJWOvEov0gT/u9ce1wn9Sk/xgYyi/QqX8kXdRs04Jczxv7P3Iq9SHWCf1OAljlPQlf57Xk4Y/afiThj9p+JOGP2n4k4b/xdPwJ/1+0u8n/X7S7yf9ftLvJ/3+6dbvn/hgvPXnrE5PyCFQ0hZVFI3zaNPRtj1aF2rM5GjI1eDVg2B6KlGskpWdfxM5uFLFYb1lDCPaORpryHEiTUeMrxSlcE2DVntSimAbSoloKuKALBkY035P1hrve2oJuMaRE+RoaTrHUBJZGWrV+LbhOARO+4Zq5iyHMKKso3hHSXtKDJSSmI4O1ZxRSkMugZoOqGlHVhZFIcZAZx2kxP3hFZvbd5jWEGsiTRGvDdpYlHZo1WB0Lxm2qlJTkYOYnKFqtHZoK4c0BahKLIBDEApoGMbHW6NSGSbJiI6x0K5amrYyHEdiimAaSpLJetc0+K6bLUAMjX84xFaEsOOYHEafUHIkpoRtG6xvGYeRmIPkOqs5l6IUjFJAmQ/W5CeyVqMo1JpRdbb7bhqxPomzbfVcHPULsaAYh4mLs1OWZx9irIGYcY1jyhnl1ljTY9yI9Q0eyabvfI87VRwHoWXOz05489Vr+RxVhCIH5F3bcnF2RpwS4xRoG88YKyk7rEvYAilmlBYayxvDs4tzasySE5MzGM04TeArfdPirSXlKFPaSfJ/q9IUNPfHw3xdmCfpmQ+y5HZPMVHmzyyVCtUgzuRZ8snn6X6DkpxtKkpXqHMmS+NlYSgF62Vh9MaRS0UZjUyZJoZhZEGLQiaPU86U+SDRNWJrk8aEqgrnHU3n5V6cD/FyLigjxTRKiu0UoxCTbTvnoxgyYtHhrCWMEw/25g+2OVVVYs4zBVjo+46UIlZLlkvIlZgj3jVUJY2A9z3jNNB1DUo51uszunYFuZJLpOh5kcyJEAbiFDgcDuQYGKNkjo/TRCkZ6y05J5R2oBTOe+psnSLFmiKXSCgKrME0DTlEqpbPwZrCs1PJhQlpol8tGY8DYQwo7bEz+ee02JbUnNGmYZwybQ/Hw8Sbz78CNMWAcY7zxTPuNrekEIjjAdf0vHjxnGEf6Jv20fKDWnGmYZoORDRKJZ5dveTVp7/L/+x/+38gTokh7jCLnqZUitK4qrnb33J/d4/VGmpAzWISs1jCUEUYtdYSNeDcTJaVr/PjszhB1Cp40hQCYMQ1Qsuh9zAJVVnmrxFIQWz4HzwtlFIz+VmE3lIPdj6AEkeHWgrIrUspmVoVlEIp4RGOeiAcldJ0fYdSYilWS6XmglLynkYZatGcr8/5N//N/xKX5yf8nX/v/8dv/dZvkjSy5mKwKUONMjz+4GoxBepsm6OtQhvFr/1n/yov31uTgyWXwDTsqSmTsyHnht/657/DYXtHypVUCte39zgtpK1kGgjxloYwn71XajWkOmCrpdcLsZlSYveuS+ZieUKcBg67LRpL0uJQkgrkB/v2P8e+urEK7xus1YyjNL0hRNpG1hHvG0r52vq9ItTq4XCg7zvaVuz+p2lkt9tRgZgKMYoDyNXlGUppmqZnnEYq872mxIInRoHjqJXjcSDlyGq5YhonDocjq9UKo7UUb97RNmcopZimzGq9ForR2tk2SPLTtNZ4v+Dq4pJa5ed13rBarcSqyhmmaSCGPGeCWdbrNdMU2W8PpBxBZU7PTwQW61pySaxWPd4b+n6BKnC/3bBarok507etwH1BXADavmO5WHA8HBmOkl9mjOZ4ONL1p7z/wXu8ffsWbRVN19P1C7nflcY3DV2/YppGAfzCxO0kRCkaUpAGeX/YcTwOXD1/iXMetGGzuWfZr9jttjjj6NoO5k2Sh5yoZ8+fUx+edaQJbhrJITs7P+OwP7Ldbum7/pHm//T1K1599RU5F7a7I3e3d7x9e03btbSt42/+zb/Jr/zKr6C1YZom3r275ubmM77znZ9jtV4/uhrEIA4ttfFzHpfFOs+HH3zIOBwJMeG8n4lyKfiNseg5T0ucHCrL1YqKEMC5Vs4uLmm8J6U4uxIpmpkYH6dJmtYKIYqVmzTKatZmIzZScxMtGuZkUiNOGG0IMXEcZDMnTIEYI8fjcdaohsvLS7zz7PY7rLW0bSuketPIJpD3OOcYhoHjUbKbrDF0Xff4XkKYC2SYUqLve9CKxXJByhnnHMfDEW307JAiz2fXdY9WULVKLphRZoabNFbPTcr8mYYQGccRY8QuzRqL94pckhDy08QHH3wodnQhUJXm9PQMrWA4HGnals1ui6Wy3W5pu562bcV6LCbG8Tj/TBXnNE5rUi5oKof9AaUVxijGcZzXlYaT9RJvxWbMGMti0RPiSLdo2N7v0drSd5ILePPums8+/wNqraxWJ7z/3vtsdxt2P9xzenpGyYl3797xd//u3yFMgZcvr1guxXpys7nnBz/4Pi/fewZVs90PHA7SfH/w4Xu8eP6S3X5PmCYWyx7nDdZZ9vs9qPK4zmx3W+42G05PTrm52bNY9BIT0jUQE6VklquecRxomhZjLNvtlpubO8n7so1Q5loT45Gub1gtF4RxxDvZcLm4uKJKMB0x7uj7BSEUvLtHmwrIJNGib0GJBd/p6RlGaw6jNNkoZhtOxWp1Nm8wDlJfJtgfJplqyJWYBvb7I1MU/ewXcg1LEUu2drb7rFVAOWM8tQpcOU4jMUYUGu89IUaZGGlaWX9yxpgWZfRsncljfp/k6Ek+Zn5oeh/qiHlzV82bHaVK3VrKnN3m5N/meeKKKu5KIHZvsv/1Y7LP/hSU+AOcaLRB0G7RQ2qV90fqGvkeFaNF22rOj38u366irX4k6SuIy5P+s6q3vJ40/EnDnzT8ScOfNPxJw580/Me/fpo1/Em/n/T7Sb+f9PtJv5/0+0m/f/zrp0W/f+KD8RAiq5OXHLdbSpLc6zTuMMtT2tWCmO457t6SYqXkRM2FEEY0ClTCzYtjSrLApAhatQS7p2KgFLQzKLckDAN5CtjaYl2H9x0GR1FiL40Wu4v5csqHoeRQq2Q5tDsc9hjj8dniXcsxH/BNhzKKOIHxK2Le0C4uyI3H1EoKiba5JHBL3W453F2zvFjgup4cR2qpYDyxitW0KoVpmPB9h1YFqzLOtWKnkishTzTFYLwlhxGtK2mK5CmxWrSomklxQGmD0h5lM0pVYhBriFQLU5wwFRZzdst8+zBOhVBmwEAZvHMcypGUI9pEUkqgjUzZKiUHX8pQVWUKCm0yMVVe39zz4XpJjomYEylnKJqqHmxN8kxeQcxJ7OwfCK/ZPiFOE87YeQJbywJsDXkcJQ/k8dnQ7Hb3TFMmhMLJeYupRmy6lSENCWUtNU0MQ5DpYmXJcSRFmY4+TBtUlXzstmnJKJluLhmnFH3b8uLqApRCF3DG0LQdapKD4sY7cipzxgag4HzVc75cctgdULlKHrmR+0ijcNbgG4crmlygbXoOxyP7YaJqQ1Hq8dqUymxJIw8wDw8kPJJmSs+Tr8zTu1rYlkzGoIVgU4aqMgUYxwnrHLVI9s5jVoJSjNPAou0kmzoWcjNTeFSMBts4agnEVKWQRA4lFXIuaaxFaUOh0jjPfhjlkFJVnLbys1VZcJRSpCILzkO+9+n5KTFMTNPIlEZoLOOksc6AEaGjFLxvKSmTSqZFcRwnciww318hJIRnK9jWU1xHUBbfNiy7hkIG7UlxhMM9uIHe9QzjnjROlFzRESBSUhUbdmeFQkwP71znQvBrG58YAjXP7goqQc6sVy2tEyuZWBLb48QUMta3TFGcAbxzeK2J0/RIzC2XLR99dMXLZ88Ypj2pRqxKUDQGjTUKqw2N6UipslgsCMOO1nWP62ylMuUjWYNKhZAqjYF115J319we70mxku8zzniMacg10vpWpvBTxVmHn+9fVJqdHSQjKOWMsw1UyZNXSkROGU2myCk2yGF5TkK2IW4LpebHKeuc4jyxXwQGkTtLDI9mUGK+6VHox2dB1oIsa6T60YiCKFPbFUqVYltyj+RtckoSE6GEZrPes1itMU6ysFKM1KL4h//ot7HK8MWrV5SqBKzIklcUUpqvO4+C/nCa76vFdxc8/+icX/jFf4MPrr6DSiMuR1KcGMej0HnecbH8gO//4F/w5atXvLp5x+E4ynP8+Cl8XQg8FgcazATKFP7Gf/5v8Uu//NeIx0A1kjF+ef4+3/+9H/AP/t7f4c3rTxiOR2r5w5yc/nN05c5ajFbklOdGRNaSB/L14QC/bb0AISHR+gZKYb/f4ebGp2kbTFT4tiHnyna7J5fC9bsNRt+zXPSPZPpDTlJK5kdiFBR9v5D7Qim0rpycnFBKxhhNiQHvPOv1arbx0sQotKK1BusMfd9ijOFwOBAmIRxTLuQSCIcseWZR6EnvLc56FBWjDLvtPQpN1zWMk4Abh8NhtqqXtXe322GM5c2ba2qtTGFkmGTz4PRkTdt5lm2HMoYQAvcpEabAME588cWXnJ2fzHZzVRpu4PrmhnEMhFgJYWQYj6zXaxSIHZL3pCxZUF999RUpJS4uLliulpxYDdpwOIyslo6cK6v1KTVn1usztLaMw8jhsKPxDdvdAes9fb9ku92BFsreWgFAXr95zWZzz+Zuw93dHb/2a7/GD37wPcZx5O3btzRNw9XlM97/4COapuHs9JzTs3OcdaQksEzbLChZ4VzL++9dPFLRxsDtu3csFgsur654++YtSpsZshlYLHuxkEoJ6xyLxYLj8UjOooDLxVLcKKaAsYZpHDkOA03bPTbvD8WvPN6FkjJTmIgh0rbtYwRMraLzVtnHZlYyyqSKzykRjgdyzQzDyN3dHSk9ZEYpLi+uKCWzWCwYxyPf//73ePbsGcEG7u/vOT8/p5TCMAy8e/cOgMViwXK55MFmLadEUYqu7x+bZWZIq6SMNpqqZkuqUlC1oqv8bzOv4ddvr1n0Pa7xQvjruTYxRiDKuQ6bYmQcBlkrZ4urh2y03W5HrZW2bQFF13bicjMMbHdb2rbFt53U0LNNnFLgZkeQ5y+ezzAkhCngfSNkt7Oy6TNPmzgjFP1yuULpKo4/WhOmQNsajsNOLOKMm2EkzavPv+L6+ppv/8x3MNYzjWL/+PLl+ywWHa9efwkoYhppO8/xCPvdPQ+ZeH/jb/wN1us143DkzZuvaDvZePrmN79JKYkffvIZr1+/4/T0lLZbsrnfUUphu90LOa7EBq/Gwmq1IsbA4XBkihHvO05Pkc+xd0xhRCkYhoFxHOjn/L6UMnd3d3Om2cg0Sv16eXnJOE50bcvHH31AmAapA/qOV6/fslqvOez3nJ+eULue/X6PcxalKj/zM99gteo4HA4cDhO3t7c4b1gvl9zebKThqzMg/AC0ZcUnP/xUrOOo7A8blHbc3e4eG++UMzFFvG9YLJayeTNNxFTIKRPChDGGlBLaGA77A97Z2WrNzcCnPGMpRgT8AmtBm4qx8jXjDE32i17sPKv0aF2vhHi3lpgiY4o0jVhW5iwbqF9jdjzei9poVMx/qNF+uM+hilsNX5Po6qEur3M58iNN+4971So1eUoFrR/eA6w25LleqEhtlHKe6/o/rPdfv5d8tZ43FiR/5c/3etLwJw1/0vAnDX/S8CcNf9LwH//6adbwJ/1+0u8n/X7S7yf9ftLvJ/3+8a+fFv3+iQ/GFRnjliyWhTLKYWvT9SzOT/FNQyyKabomjS3T/h5cT7tY4LGELAHw6MgwTWjTy+GUalCqUspIKWBsI3nexlKGkSHt0VZogUR8DH1PqsrUo3UoYzBO8hSOcaTRs3d/mMghUIvYWxvrcVaRVMI2QglpBbpqarMU4uD4jiEp0ngkTAMESx5vCbaSUwDtKEURpx0xBLqmZTxGtLW0ekm/WFGdxhsPuZKmEdollUzIByFSssKoilFC84n9R6WUSBZXDkrK1FLI1HnB0Ng4j1vOd8Z2N5FVZgoZ3UQ5rDYaVWSaWXJ9FTkWUpJpbG3Ffuc4HNGu5e31HW8393y8XvLs+QrbNQwhsd8PQKFtl4zTNE/9a6wrjzeqMQal5NC3lEIYR1zboeZsEaU1/aLnMExorehXPavTldhDT0kowjJhYiN5Dw+Wy3huXr/GaUW3XhNi4rDbUKqicR2L5YJpEtv5UirHSXLml63nWx8+59nZOc5ZDsNAnCJN62m9pyjFFGU6tMSEN4aQEr7p+O63PibFQOw8MRd0Keh52r9xHucsIJO1Dw+Z956mgM8Vb4W+k0szZzDwNf0ivxlzdrEma42lsGo0L69OWS083hpqbnjz7o6vbu7ZpyiH47XidGWcAm62J7LWMiXJUbHWcByOFFUpRTOEyBACCyMZ43nOwHZOCD85fKzoUrHGUFA4rcklMUbJpg6T2OukmqlKvh/zYbzVmiEGqqoM00DMAac0OWa8NWgqShXS/Ny5psfUJFkRKHTRFKVR87R5zZa27dhNI6oqcjJY1ZOyJVXFyfkFRmkO+y05jXz26fdZ9Z6aK8M4knMmxjmbHZkurlUOZ3MuksnTNoxzcdw1DVpLpEDXdRzKSKFAzSQlRcty2YMtTLlCkYPYNEZ0EWBhHEec06icGceDUKdtS+ca1s2K7XHL6fIUrQ3323uKU5z5Be3yhIwmxIFDPNK2ZxjTEUJ8FAs5/NTUPBCngYJhqJWkoLUtsR7wTqNLBSM2PbUmjmmP047qxNIkJBEC7yVOQBuHxWCcrB8Pnuea2ZZcK7QWMdQPbhAzWQYKXSFXHikyb8SupxYR74eXmT//hwxzZisT8yhOsoDk+RC9FjFKQc26pR4Ox6XYAEXJWai4x6N3BcpgXIO1nTyjtpDyxJdvvuC435PD9CjWD5nfUlOqR1F/EGkF5JIYjrd88YMt/5t/63+JKgpqkp9LKYGiZkINVallkliKGDBGrNsfAJIffT0WCPP6Vmvm1//Df8Bv/8ZvSQ65lsb4+YtvkmPm1asvGYYDNdeZmOTxfqYm/qwv7yRr6gGsMcaglSKmiDUG51pqldz1nDPGGKZxomsbKUiUuD1458hzdrtSivPzM+7u7hlTwDlLykVAN6UYxoCzRgqtVMQOyDlKLYRpfCSbXeNY9gumaaTrGlYrKVk3qqAAAQAASURBVOhjYiZthf5tmpYQJvazxRdIg3A8Hh8pYKU0wxAZh5G+7whTopYjXd8xDpGmsygUx+MW6zSnp6d88eVX5FS5vDwHCsNxoGk63r59R7/sqVXs3ZxvyRkOh4ESEovlgs12wziMXF09pyrFOEzkVBljgCpASVUa7zwpFN68egsUfGNJc4Nle7HGm6YjzjqeP38OCLmpUCz6Jfv9EYUQ4krBl5uvWHQN5xenpDgx7SPPnj2j6xYY62m6ntvbDff390zjRLmCk9M1MUbW6xO2ux2n5+e8/8EHTCHwjW98k5wzH370Ed41nJ6d0rYdx2Hk8vKSWiTTLmWhsamaxXJB17eklDHWknMhhIHVekXXdsSUODk7pem6x+dsHEdyCsSYaNuWPOfrTdPEMAzz3SpN6xQmybCrc86X0YQwkXOZ15yvs40WiwVUyHPz3XUtOQaMNqQYyKk8EqRvb+/IOdE1DfvDnpwzXdtxerLGu4Z+MU8UVKHeH9xRPv7oI2qpWO+ptRKC3HsA6/WanDLWCPFsjCGnTOMbKvIsO+c4Ho8YbcXCbXbTeNigyDESp4Cd11alJPvt6vISa624ZVRZ02OMQvcrmT5x3pNrkcw1azHG8ObNG5bLpUTdzJsZQvrKWuSsp+TKyXoh2qM1MURUrVjnSKnQdQumMFFyoe06rDVonSglzs2bgJCJxHZu/M/PzkBJLMg4jZJlpwzjeCSlKJE/HaxO1mw2Gxb9mo8/+hjrHDFljJOcvrvNHW/fvibnQimV29t7VqsF52dX83N+ZPneSrS/VsZhENvGmmdi/As2m1sOB8lpfP36NZeXF5w0K5rGow1cv72jZEWIdzx7dkFOiuMxYrRlGCMpjRz2e5bLJTkntN4Lud80rNdrjJGNP1kTFYuF/K4nJ2eUknn2/ILNnViOta3n/PyUEEZiTCyXEh+0306kMGGtx9mWze09x8OARqNWHacnJ+R8T62Vy8tLQhjZ3RwYx4mTk5NH+8nD/kitlcPhKBKnLLebLdMka/MUAtZZvGuwaMKUORzuybkwjCPWSC6a5I4x3ztfx4EoXWk7j3Wa4zCxWCyIcd4MKNI8p1Q4Doc5T00mErxrHjfFSk7E+BAJIo5ND7VljGnWZHgATR8yw5SSSsRa/fj31trHDSpjZL2cQnxcE5Saa9wsuYVaawGalZqh1PL4THzdyDNfT/lMZxVHG3keJY4JdOVH6PQf93rYqDCzW86fvCHwk7yeNPxJw580/EnDnzT8ScOfNPwvnoY/6feTfj/p95N+P+n3k34/6fdPt37/xAfjtVaMdhRTUa6inaVbrWiaBcZ4tHaEcWTcR/btntWzK2wD29st1jjQlqozShWmMc2ZDEJxNL4DVcVKQ1lUjjgXmaaRejSUHDC+R5VKTAVjDa31lJpQFZTVcmPGinOVNAWYD7FKyRyGDdoY0pRRjaNfGkqd8FoR0wE/zof3KjMNN+jpSElA3ZPHJbY9YquhYEl3nxOZGA5bGu3QRhHigVQV2noOw5akAnGMULJkp08HYoiMY8G7lqYtjFEsP2YvbSqZFCLinSsHSFrJJCdKDpkeL6pS+EWP1goXMta16CQLZMkJSUmoks8739/jMMn/qyrHcaCokYWzfPzx+3z7Zz8ipZHhbgtVjp76tqWUSjSZfuE5HodHOxS00HOKOouHCPY0TrMzgFwPjaFrWypgjEMbi/GKZrmkcMZ03EkhqCrKQJwKpEjXtbQOlFWMKeGcoaKYwoC2DV611GFimiK1wrJr+OaHLzg/EQGSKVbNaiWLb4kVmzOqChnYnDq8M7Rty4sXz7G1MqaIjRHfS856TFFIQuvxjUNbjUV+DskCrrSIlfrSG97d3hFyJuQERskh32wtBJIXTiloBb5U/vLPfszPfeMFcRwxVRNTRunCi7M1713s+MGrt7zd7IhKCekzn+fVWslpzo/OWQ7rqxILbWB7PMxF00ieD9eddeRqpAg2Cmc0uqjZpUHyto2yslhWizYGq5mFfj6gm7O9tdG8u77mOBxZLHpSjI8L5jQFlqu12HVoQ6qQShaL9lrlsK+Ik8L4YC9fNEoJdFCrljyL8chxGlmdnvPZF59w2O1pfIO2hpgD20NgOAxyCF4yRRVyTKQUZnLLgJbi43g4EGOkUiRrpVRykqJOZ0WZpOBAyTODdnx4eck3PvgGFMv9cMM0Tay7llgt7zZ79vsd61XP+ckprbccDjvCdCD4wldf/ZDzuCAN7zOFQs4HFhcXvDlsCGXi/PwlpulodUMpBtI0wwvyKiVz8/o1n3/2lssXZ/SrJThHKZV9GGhdQykKpQJFKZSp6Axojwbq4xS3FhAHIe1iShir52YMUohyyFvFLaCqilaz7ZFSj40ZyKT9bHCC5QHmEVuXWiquaR5EQg7Gi/yLnBOQqcw52XMzKHZhD5YohVokZ6bx4i5QlJ2JsXm5M4aYKzmOsr7kQDiMvD3cC2U95xlhjFB0ClAZa+efdR5gFwGujwfudRZdYxSFQkmRlAay3lGrRSmHIs4cwbwm66+n70uO8zXjkVmae0WxmNIyKa/RkCHpRMmKuzfXbNRbqiroWqlK8cWn3wM157RUzYOdvJqLc9RDmfJne4UU0XqGyKrQlg+Eeq0Zl8XOfprinB+m5kJK7N/kulVCzOSquL3dYIzGWEuMgca7mZAsvHn7Fuc8SmnGKXB6eoLQ6XW2lhoATSkCTa2tJWWx+pGCss65On4uyMXiSGz7K+M40HWdUMSTFH59v2AcJafn7nZDqYn1ekXTtJSa2NzfcnpyxvE44V3DOAZenD5HawtV4bwGJdZe/aJjvVphDBjrCGHi7PSUw2FgtVpxc/OWVd+z2dxjfUvTWu42G66urlDnjh/+4IesVi3Pry7Z7HZ88MFHNM6xWq748otXDKPkHoUwPVpcjePEYrFmu92y392yWCzwvmW1XnEcRhb9ksN+pGRxSNnudpysl9ze3tJ4j1KWEDJvrj/HOY9vO0rJXF5e0S8WnJ+fzxS+RGa0bc/Z+Rmr5YrTk5O5tjDsdjvGcaBte/aHA23bkWaHFaWN1GS1YoxAWYfdgbbt6fsFOYvtUUpRwJiKxDAoRZrdbdq2herpujw/jxI/0nWt3IdzhpK1hu12RM+2eeMwMI2WcRqlSXYCiel5vZqmQE4Jax2UwnDYY4xmmkZCiJLnNWfr9Z3EMgzHI1oprJ8nC8aRGCJv375ltVoxxYhScHKyQlWFsQJbbbfb2ULQs1qtHje6ai4Mk2SbLRYLodVzkmw3KlozR4VYKhXn3WPjXec1u1suBBDUGlWraFNV81SGnX9fsTrUSp5J2UxLaGu5vLwihokYAufn53jvadv2ccMjzdMq1hqMMTTNet40S8QwAdKwoMThSSvN+vRMrmEITGEECsYYFouFNPIxEkKgbYXO327v6RcLDvdbSsnkFLFGoapm0a5Zf3DGm7dfcX39iru7Dd/8xneoSnMcBu43d2gNTeO5vn7FbnfPxx9/k/XqhBASIUiTfzweMcaSU+Z+ezdPIVS++PIPOBwODMeRd+/e0vcdV33H+cUZh92Rt9fXnJ6tubl5Ry2O7ebIdntkmjLXbwbOL9YoVRgGeS53uy2nZ6czWFgZx4lvfuMbKAXTNPHq1RuGYcAajW9kHULdoLXi8vKSxaLl7Oxjfvd3fo8YMzFmahVtPTk7l4yzWsTib39gc7fj9OyU9Vq09/PPXvHBh+8LhDWOkl84DJIzV5lzwSb6vuPubkPKlcVyKZFAKTIMSe75vmW1XqCUTL0cjhPjOM0TJgaltLgiOfu4YWut1GYywZRnZxjR5ZIj43gURxllKCXKzzJF/v/s/cmSbduVnol9s1zFrrw4fs65FYBAMIBgkJHBZJKWpFlapillKZmknh5KT6KeTA+hVE+iksqkKDKCAYAI3OpU7r6rVcxSjbH2vgDZgRgdhNF35957rp/tu1hr/mPM+Y/vH8cR7z3eNz9sTC5aH3OSa9BYydkMkVgyqXC9JucQ0UqoRFohxjPECGutveripSH/oaGuv4V0qzKhZRSx5qtjnaUO0EtjfumrzOL4V0ot0wKKUsL1uZumvaIfZRPALPeT1I1LefA7D1nb9HWNSinzt3m8aPiLhr9o+IuGv2j4i4a/aPjfPQ1/0e8X/X7R7xf9ftHvF/1+0e8/bP3+/VHqeaYpNyhnoWha11LV8k5LIOeJbnXD8PwJ7TTWe1I6cTh+YGdfQ1tRRZPSsCC5CyHO5NohZ4ZWJhZzlcO4WZGHwBhGaij0dz0xF6oWUdHOkHMlpUDfWoKqKL1C5UqsgXke6M4nNjcNdcHsFgWmiEul1pl5irgUmOKIXaaiY5zRNLjWMJ4CMc3Ykjjs9zS9xjJdhSfOE+u+J6YzVTmiKrBkK/vGM08T0zzIRDSK4+lEuzX0rRQCJWmM1mjbCEKbCa0gFtBGkWOEkogpkX/rq6rAerdjDhMpDJha5SIuFWsdThlQGac01YiQWGMZ5pFaIdWCb3f86Ms3vNndYagcp4mcCyhNXZyJcmUtv7EWmYqE5eYSPLFvFqEwCoXGWIMiY7WlpEI1BWukECwFTOnIyAGgxqJyolZD0pIl7ZXFuo6QDhz2R7Z3X1CUZR7PFJTkQhdN1ZWcI95o7jYtRmuO08z750e80exWG5xvqKUyxyBZPDlSMhgMftVwt7vH4cgUlDHYotG6YJzCe5kO18osuQxyvc1BciJKKRhVaU2l67Y02vM333+HVqBKlUNKFBe2RNYFq8Fbw8PdDV9+9gpyYUqFEjMhJay2uEZhveEnn78hlsLjHChVhNk1HiqCd9eGXKGmTCxFjiwrNJue3nsoAedahvNATjDl6WpsaJoGzSU3PhFDxSyCn5MUT7kWvAarxFGkrRI0NUCRg/U4zjJZXiLOGYqtxJDQVWNs5TyemGOSA2AqaslZP48jISbScp1rYygVpjmQq5Jse9MAB8bhhFGaoKflYN4S40xaptBrLqSyEBaWBTrnjK6Si62NHE4abTHeYry4BOc5YHxH27TEFKm14Iy4Hd8+bGmy5zQeKSniFKhamFNkjpnWS1F/MgOWxN1uQ9+u8A7+7M/+AaUm3v3mHTEc2d69IpxGSg40VkGYGYeRkhQlJ+ZxQLvu6noqWZyuz/NA+WRYDyPrtmN/nkllyW3XoHDUFDC6ok0jRiCtqFqKH13lnyhAK7w1i1DIobBvOjmELXLoLTjzcj3MtdaiqjjDsqpiAVEL3tw1C2bILa6ujNbLIHblmjuUs2CdlLES0QCLezktU9yFXOV5U4rX6fScF0NJlciBTKEkccORReALy0S6UoBd/u4PGS2p1qVgkKLfYBZCgqCfaqnUlOVZtMJWjbYKpRuc9RjtUIBR4jbVRqIYJPlbyxpOR075WnSwNDa5FHHCLat1lfAWbIWqpTi5OOGqNkuRIHdIXQ7BL9QXJWP00sD8LU7Gw5woNXI+DWgjDnLvHdaKbkxzlOJiaXyVEsxbVIq84OjnaSJm+XPvNHf3W0IIlFSw1pBjELOW86Qkn0kIkZie0aqyW/c0jbhkp1g4HM9CfMiKTe9xVnKgQkicB4l/WK97tHJ0XcfpdJa1dMH9HA4HnGs4ns4oVem6Fqri9m5HjInHxwMhPl6xb+8/PuOd4ebG0nYd+/3zkvvkUKbiXMe333zLer2m7+QesFZjtefhfkdOE5rEn/7pzygpcD63vPu059PHJ96+fWAYB/bPZ4Zh4Mc/+ZwpCrXgm2++5v7unl//+m9IKfGTP/ox4zgQU5KNizGwWq05Hs6MQ6Br19ze3lIA4zzTNGO0YrtZUdDcvXrDn/78zxjHM+/ffbu4z0+kIkWitQtVZJ54eP0a5xrJbUKasmEY+ekf/THWCCLvm6+/xfuG+/vXGG3RaM6nMyUVTGsw2hLniWozzjhSTKgqxBWF4nw60bTt0oTmxWVfyTkxns60TYOulThLsyhGGUGOxSDNcr/q+fbbb4gh8tOf/olkKCnFNM/0qxWr7Q0xhiWjz0i20jxfnShaG6gsqLnIPM2M45k5zDRNg/cN8zzRNC3WOIbxjHGG4+ORV68erteUtW5xIRt821BrJQbJUptniY9Yr9e/Q8lIKXE+n6FUrHfc3NyIGSlGMQhqzfPzI8Nw5ssvv6Rf9YSYGKdB1qEiUxlt36GkOBUjURb3e8nSBGijpWbO0rQc9o/LZ15wXvCL0zQSQ0CBTGuEyKdPnwQ5lyvjsBctVopcMqbIunWhYlzyDZX5oZmYppF5mmgXl75k0EkTI82xrCe1SERGLoUQxDQUwsj//P/+F8zTCWcVm7VoZYyBf/OXf8V/+9/9r2nbhmmaOB0PPD5+whiNMwZrDZ9//gVtK2tCLpFxOnI8PdM0LefhuEwNRO7ubhmHkdZvoFh2m3u0soQ0YYzi8dOeC+knxcx6vWMeAz/68RfEKFl+j09PxBjRpvLq4R5q5asfveWLLz7n4/tHhmHifDrTdw2vH255fD7w/v1HtDK8enXPMAw8Pz/LNbLp+f7dew7HA2/ePPDq4Q2/+ZuvCbESY0ApLXFJOdN4j1CupNbfH/ZLDp+mVMXjp2eG84gzDc9PR2IMWOOZS+JwEpTlMEyghAwUUxE0Yq10vaMWQ79MGpzO4zL1oGjbFolGqjgnhjmZRlALljEs7n+1OLPV0gwbybtczJLTPEHVohOpyDSG91hrGc6jrHNGL42u9BCZyhwTOWWMc/hG6hNpeGUjr1nyLI2x1/93capfpi/Sghy8mO4u7vZauTbtEgOD9GawmEx/Ox9NyQbz9e8LMjRnfX3eS2zMpYaS+qbgnWywpZTISy112WgDKDkvsUpwial50fAXDX/R8BcNf9HwFw1/0fD/fDT8Rb9f9PtFv1/0+0W/X/T7Rb//sPX79z4YPz5/JK9b2k1DUQHvHbnIL6sKfNMSTIN3DXe3N7KhXxtynpnigTwHvC3kmmh0g2s6Mh401JqZzxNNq7G2oHJmnisxHBlPR+rs6NZyiKTcBq0h5eXDqRqqQ+tE03vCHEnHQMmJ4Xzg8L6CyuASRjlqqliTqSVSUiHVimu2aNegmxY/HYiTohrJoTDWkFXBaEW33TAPE3EaUMthXAiJZr0i48gF0I5UKk7pBVkDzrfUcUQbWczmmFk5R0kB6zU5BUrK4p64LJCI/UFpzfG059MhXr+LWivjeSCmQEyBld8S5oxBHC7DJGiRTFrcbZFsBauBlultVWEaRuZmJMSOWjJxDow5C8pDKZmwTUUOh7UlkykpUpVME6vFoaGolBzQgG8atG3JiQVjv9wH2hJzpYbAFAdCmFl1rbid0ijOFDR+1VK1RcVMen4mzHIQnYtiDBMFQ00VZzUpJfpVT9N4UgyEqORGN5q2KaQ0UkphniNzqqRcGceZh7tXGO04HU+EOZAVHM4nhmkkzAkwdJ1ntVrRd/JZHQ97mUJOhTwHyIWSM9Zocp5Y9ZY3tz0JufGNslRdMWicsfRdT2MNrfN06444zTymREgFEBT5aT5jvUQB7I+DLE5AKUmunZyoi0NUil4l97kxMsVPJYXENM40Rg6DnW9IJTGPEylHrPc0vYFSMcpSVKVxHdrIQsxycDdOE6DZbDekGDBKJuXHGJimUfDbSgkaRGu0M9jW4qwDNPvjiTEkMbpYwVj0bUcMkVwuU7GZUhU5ZqaQyBVizGI80IurtWZqEVy+wiDRC4EQL4SEzAXRQZVF8YIMkoPXBEoQOXWsKKsBgzaOOQ4opYgpAIJ6d16z7jwhzNSaWPUN52FC6YJ2HtcaPmvvOY0HQg7EBYfdqMrqpudXv/kF603Pl3/0Y9KkGeIzftVgWDGcnuA8kacRlOLp0xHVaIbxiYuXSmnFZn3Dqj2xP008vH2Nd6BDxBlLyAqqFL7aNii95G8s08vKyJS0NQZrLLUm6uL8UlWmx9My8a2VloZKa3LJeNOID0Ypai0y/c1illnMNxURu8sktvcOpRbhLjL5n0tEa0WjPdbKtPulESw50TY9ShlySYJVAZxbBNoYWDJ2aknUkjFUsOKK1M3ld9erm7oW/YOBB0Otkucljmu5H5VSqOW6sMqigawUqQoF4SKcaSnOc8lYbSjVCAa9VKhKsPQaNPK6DRUrp+9oI79bG808z7JGKnHr6ayoqpKqHKQP8yzutXo5BBcHXa1VDt8XB6tc21IoKP2f3pTHGBdzUqGGSNM04uzVZYkwKDhrcN5JwxQSTQXvPcaANZa22RJShApN4yi50ncdnW9ZrVaczycen56paLS2hBgpJXM6Rvq+lYYeSLHy9PSMdZ5pmHFDRKNpvAD2Y4qCB4uFx8cDNzdbnp9OlJowZnH3VpjmkWl8om3bazZY2zQ4a6lZE8KRzbqnX3Uo4HQe2d3cMgwnXr265XQauH/1hvjuHVprvvn6HYejNE6H45E4R7bbji++eMPxeKTvOu7u71mvNhwOR7rWsF0lHj995P3773nz9g1v3t6jVGaaZm53t4KICpEYC7e3r6glk0JmPM3UCr7paPs1vulQw8TrN5+jEZNK0zbstnes+g1Pj5/4+PEjP//TP8M5z/sP74ghMIXE/PGZP/qjP6JpG16/fsP79+/41a9+zZdffsk8BcZRXPFv377lfB5Zr3fkJctI8Ex6cV0Lsun29hVN69jv94Q4Mz/OeNcyjuKK9UaLmxmF0pbD/omnx0dub+9wzuGtI1Rxf7eN5/HjR5yzDMNA07Roo2l8Q9M07J/35CIkka5bMY1PPD09MYfA7f2dXEMo+q6llooxGqX0NSssxEhKiVoCw/lM07bkHDmdT8zTKLlXw8DtzQ0hZk7HEyVnUDIR0XU9KQve0Lg1Zlk3tZH7ueQspinr8E1Gac1wHsTQqBXj+YR1jtZ7oWg4xzQHfNNIcb40Bn234vbmDu9btLE4FLV4whzYbNeCwlMaay6NiKZqTUwJvWRLhRgW02XHNI68//Ce+/t7mrYFCuP5yDwZVn1PToXn/Z7VesN6s1nWtSK4O6QZRBumMEvMRIWmFSOh9xbUYpxjoYwYg7IGndV1A4NaaHyHUopPH/+G/+V/+Zf8xX/xT/CtEESkMdf8xV/8E6bpLPVYrsSQabXin/3zt1jn+fjxA9vdDkXl9asHxmlmd3NDmGfO5zNPT89LlljH+/fvyanQNi3GONabLZvNrVwba89/+Y//KeM08P133xFiZA4z2+2Om5uB7XbHcX/gdD7KZI0qTHNg/3zii68s4/nM4Xik8R6tNev1GucM33z9LcMwMY4DFfjuu/cMw8TpdMZayzhO/Lu//iVNKzmFgpQ0pFQ4nkYOx1/T+ob9/sRqtWO18jw9PTEMM9Z5DvsTrnGs+p62byi5MM+Bp8c9xjbsD2ecM1gtOh5joG27pd6bF12CXDIpBUpVhEVLjVbkKm7q4/GMtYZV36GNpVTR61IyQndRGKPouk4c+Fpda81pCsv+l5gbJRZF1gBjLjmZol8xibN8noPkD1YxPKtLM5wzpQhaNFBoWkEGCoWlCtrNLHXa1emdfsft7dwPbvCUhEpDvtSBUg5fKDWLL+3qcDd2oeakfK1joBBjoevker70YZe/k1K6Pl+tcv/IeiQ/a61FLxsAl9dcSrlOoUij/rc7GH/R8BcNf9HwFw1/0fAXDX/R8L97Gv6i3y/6/aLfL/r9ot8v+v2i33/Y+v17H4zrGjkfPuGbt3ITK3Day7ShdZRZo7Rntb3BeEdRDqUVuczkEpinA+geu/Ocj3vavKHpN5Qi4fCqzITZQHLE+cxpPJDPEzlGwhwYz+fly5mxxhETdJ1lHuVG79s1RRXQgc6BB0o8cHoecG2P0TuUqZQ8k2KCnMhTwq9vWd/+jCEfSWqmKk2OI8o4GtctB3MZrw0VObjKacZqQ9JwOJ65sT2JGast1jcivClidKVZ3CM5F4zWGBR5OXRCi/sh58g8jeKAUHJS4rxhzgaw+LajmeWLBTkDOo8DTevoVh3KauIpUYpaDr88c5hRGsKUaBpLKgXvOnKZ8U1DaxxeOd48vKJvHMM4UhSEVEi14JThPI7iYFJys+daJL+mAjXhjAUrwuMbmVhOpdAYR5gHyXA3hnGaCTHjs6IkcUVuVytBlKCwVg4iT+czMRn8eoN3az7//OeMsWDjgGpbYqychgmrFVkJQv1u1+Gd5tXtjjkGDkMlp8rpOFJyIi2Hz6kUpnlk3fdses88DmQMUxgJNYPWtN7SWc8wBk7HA4f9gdubW3G1lITRkhG+u9mitSLFjF4mkSmZz+43oMTZaYynhBmtBC0/hplSCinMzKcCrWd/OqNRFKWZzyNQKeOZppGsknGa5DBQOQppQRs1xCD53ZLRIAvSxZ3WekFyGC2TuVXJQXrTdbR0jNPI/nlP37RYJ+KbUoFUQbMQDlqMsbLYlUrjHPMo+UFP+z0hBjkAzSw4GTm8X7UbOuMZ5sBxDlRtaZzFqITRmpoSOSWUgqZ1qGJo2p4QC7FMhGkkxkBdcN3GOVgQNahK6zu0hvNpwlolhgEtRbocMsqh/mURl7PySg7yvYGSA1clh49oEZeaE2p5ntYaditLJTOHmXma8cpzDplDGBmHzM2uh9QzMhIXjA4q8Of/8J/ibc9+f+Y8PfPpwxPdumPXvOZ4/Mg0F371q7/kqz/6MdubBzqjUKrQzP2CSBEjzGmMfPb2gdXNhvuHe7799bd07YZV65jnhNd+OU2Vgk8p8Uao5c9U06BQWK3Qulkyf6SY0lpfEUilZDBmOXh1V9ehwizCJteXWigSIsCGy+Cy/HuW77ZKvoi3/lrk1poJIVGRzJS27aTILZL55FSzNIuFWixaJzF71Io1nqo1pSQMgo1q23Yp9gIg5AoxQYiZpJQk90JVaAW5ZpQzy0F+QWvDBRXV9ytxmAIhRnKq4rJVSyb58ty1Vihi1mAxK4UUKRjJYq9Q6wV5lrEmUUvh7vaOEAMhzJRSRXOWv5+LXI/ameWTVLIOLG66i5uvakHY1CKF0MVd95/yaNoG770QNIJkZOUcMBiZiL8UEdVQqqZr+6UB1r9V/BS00vjGA/D0tKeUzO3tDad379hsevpVQ4yQc0WnSt936LUWkwOw3x9o25Z/8Gd/TCmV33z9PR8/PLN/htW65Wazol+1cg1SFmPTSOMbWtfSr8S1bo1jd7NmOE8Y44RUYaT4XK9W5C6z2jpWq56b3Y5pnhmHmcPhTM6Jjx8/8vDwlsfHJ56fnqjAq1d3OA8fP35iGid2NytCnOj7NeMwk3Lkr/7yr1itNxz2B7744gt86/jqqy/oum5xUErWjtGGGBPv3n3EOc/Dw1vO5zO3Nzuo8PDwmlQhhJlLLs/9qweMsZxOA7Uo5jnz/ffvaZqGECt//Pf+lPV6y/F0IpfKuw8fub+/x/uW58MRN470fc8cEje3dxjTUCn0jef29o6uEySb0ZaH16/w3vHLX/6Sw2HP6XQkhEjOha++/BHrusZYTdN4Vv2GGCMxBs7nE+dhYLVe0fdrlIa2bbm5uaFWRVjwe9M4UYo0EMfjAeccTdPSdS3TNJFipGlb7u7vKbmQcmK33dF3K3JOrDd3NG27xHJIjRFzFBRWOKO0JoZATIL/q7kwTRMhBtabDd43dG1HTolhGPnNb76hXb6jlCVbre3EcTsPE+/ev2e3u2G9WaONwmlLUSzrIXz8+OHqqtYYmqahKkPTddf1IudKVZp+tZK6xjfYzmAXDJVMbmTC6UQIQRoqoO97jJX6LoZwNeZAxThHTolahS6ktNx/KSX+7B/+Q2ouxBQ5HPY8Pz/x4x//mN/85mt++tO/Bwpa34JWTOOEWigaKIX3llSSuJOVlTW5Vo6nI8/7Z/q+p2mEDEKtGAVhmqhV6ENqcfeOw0BOidvbW/6b/+a/Zb2+5XDccz4PtG2LtbL5suOGsriovZOphmmaaLsGlJg027bjcDhIFE9OVBLDeKBtWm5uNsv6bDBW4by4hJ/3H4kx8O7dOy7ZWNM08f333+Os5WZ3Q5gjNVeeHj+RcxbTknOM48y/+H/9Tyg0cww8Px756qu3WKc5n0+UUrm/vyOEwOeff87d3S0pRbwT3Wrajtu7eyrw4cMHNqs1m82a7+N7Pn585NWre3zj2e+fSTFxe3vHuNyj2+0NtR45D6OgC5d4F6M9tSTWK5m8ef/hUTaobrcY7zAFhmGi1oB1Db4R9GUuhRgS1lameSYl2bQyxl7zH9++eZCcy3gQU1rOxDBzc7Nb3NmFEAIxRrz3FJ2ZQiDnukw22UWdNNpoxnFkHCeUAmvFnW6dRWlFDIlcK6XK6xEHuF10W1TOWoOpVrB0SWqUS49z+TlxxEtDXiu/09zWCnnpIcxFvxaUmzGi+5fHBad2+fewZEsaI/d4Slx/90X3L9jQtKwxF7c6yOuqtRKWTDZrf6s/Wza0rs9zIeD87c7FXzT8RcNfNPxFw180/EXDXzT876CGv+j3i36/6PeLfr/o94t+v+j3H7Z+/94H49TMOHxiNdxjmyIM+qjomx5tDU3TQr8B7dCNk0lNXWm6HfNzwbUNZQJvO4byyDwWOUzRLKhqiLlQtCCjjYaiLU27RqlZDmpcs4yKi7vJWCkolDI0viObTE4BaxuUMcxKFpEQEytlKVmwKVoZlLUUfUJrwxRnUinUORDjhMmFHKMszDEz74+YWKmLuKiyZDLrxDiP9PMgh20pkZM49LRRkAQ3cE7IIu0MRin5f8oK0t3oZdEWPEYsE8t5C841aCaM8qxX7ne+jqZ1gkaoC046puVikQyBmOWwt9RIKTJhPU0TkGm0wlvNm1evJNc3Z0ouC1ZCcjJSlkNwrQVtnapkM+Qir8taJ/nWSmOMZG0YI4dnKWW882S50ikVPj4+YRqLU4WUJpnILZJBYL1Ge0unt+RYGZ725HZFUYWn/YlpnvDeEMJImkaq8bhmy6pd0bgnGt+wWXXYSZFyZh9GznOgLhPI0zxhncEax6v7W778/DUf33/gu/cf0Nrwoz/6Md57qJUwzpyHgcfnwv44MkwTUHHWUEPBOYWJiZIzKWdiqSjjgYLVgqqZ5wAYrNWClSmFWDKlVlpnGc8Dj/sjRSmsguN4lkNv22KXTJ1xnsVRVmVRWuKiSSlQl8WrZpl2BcWcMl5Bbzokc1mm/McYmGKQ6dNcaX1LKRmjDfMUsM5iXMFYtxQCSoqAouU+iwmjZfHLOTHPEyiumB1toPMeqxReG7JSnObI+6cDuYIqlZtmhfOekALGO/bHM2lBnyt1kEIlyCKGAmME1VNVkeInW1KOtL0jhsB2t8ZaIy7FesmtLqQkgptjxFpFTlmQHSWRipYpcoQgUYq6TkJL8Q81wf3NHW/udnRdx3keqdqgkezrEBJGwXGaWDnDOAkvAWW4u39LKomnj++ZziPT/MTu5jP6leS932631Jywm46np0/03Yab7QMpTGj3Q0h1rZVuvWU6nykh8+tf/pK+WeFUx+v7Bw7v32G0kvcFKHXJ+xBseCmAVihkrQFQ2lxF8XL4LZiRSi2SxS2IcJki19pK5IBR1CqLkZKT96vz6oIquWSKiMPTYm1LDAnnPNM04hyLi02un1QrehH3XAsOveBNNFp5oQVQyTFilCFXjXWWWgSWHkKga1vB/ee4vFYxJ+jFIlKWqe5UpbCViAk5ztfGk5asGN94Yky0TYPppNDNVfBT1joUC/K8SmYSFaqquFwoRos3oVSZsF/YGVpLTnhGDGNWCS7JNg1KIVlgC3JKK01dXHMUMK0U9ykmql4O/kuWg/8sGfD/qY+Lu1cbveTVJJqmoZRKjoHVdiMZOvNMyhWXIk3bkFPEOct5Hrkgck6n+eriA4lA6JbnutlumUPifJ5Q1VGodJ2jcT3zHNG+Icwz33/7joeHO/74J1/w5uGOD5/2hJiYQ6RfrQghM00BY+Du7kaoIClKNpOxTPNI23tCSjy+e2IYJt68vuX2dkPMkZQiKM2nT3uO+4nzcBJ3c5jYbDaSk1ULx9OeVw8312Zxt91ye3tPrZmuk3X9u3cf8M5zHo5o50gF+vWa/ekoWKiUGYeRT+MjbduyXu/QxhBi4uc//1Oen5/59PjE+XRmngO73Y6MZOZInVd49eoVxhien5949eoVh8ORWuFf/av/Dz/7+c9o24bT+czxdEIpzXa75Wc/+znr9VbMP1kQXuM48erVa8HhzYnb2xu6Xt7bPE+sVitqrTw+fiSlSNt6Npv1FXm0296AUihV2W7lubVRfPr+I7kkiaQwFqM103iS9blWjsejYMtSYr1eU2ulaRqcc+x2NxhjyTlxOp2YpgljDPv9/opEEyOTvAbJ5GqY5lEahZIJ88w8y/faLptCkgFWOO737HY77u5uJdvqPLJer645eBfM0+3NLTmnxVAm64L3nhACD28flteSUQbGeWCeJ9q2pSJNSa2FzWZDlVuc9XqNb5rr/ZVyWTKVDMZacinkIpokdJs1OWeapmEcBoJSYizTokNC56goLeuKuPulMXZG7tkYInMIy1pfZN3TGuc8Wpvl82s4nY7M48xxL9eoNKHj1a0+jAPGWlarFZd8s4vTtlb5XGKMTNMkMSLLe5CGrZGoDaMZhhMlJ9arHUobPn36hDbqeu3UWpmmiVoKHz58xzSN7HY39P0K1xjOw5HD/oBzntu7V6zWW5SC4XTkPJ4okuDD8XjGGMt6taXUyNdf/watNTc3tzw/P4lBTlvatkUrxau7e4wxcj1MI7e3N/zbf/uL6/0ao9QOf/b3f07TtpIvNgzM80jfra6bPqUU7u5u8d4u+in11vPzM3d3d9fP6NX9HTHIxETbNCilGYaR0+lMrZXVqsdax9df/4bdzS21Ks7n83Ldi0M8p0KMgWGQ+CWtDc5ZmqZBYdnvD2ilSQXG88w0n7DWMSymYWMN28bT9h1N27HfH1BKL4a0REqRWjI5ZUJeFEsrtAZVL/VTuGLLxmG65k6u1itCiMxTIMYZtdBYlNLX6aEU0/LnMgGTozT4VEhZ7F7GmMU0p5aasiymMzHE6SVn7NLAXx3nS/SIGNEu+DYxq102j2vVv9NQX+qUy39fjW5ATpVyMUjWhdDFD3XtBf22UA6pIS2vUeoi7+2CLpTXIzVM/Z3fqfQSF7PUJ+pveTL+ouEvGv6i4S8a/qLhLxr+ouF/9zT8Rb9f9PtFv1/0+0W/X/T7Rb//sPX79z4YNwacyaRwxLcdxirIejl4DpLjoCy+6cgpQhgwbUfX7Tg8P+K85Xw64M0dxlaeP76jczOb3Q7lDBiPVQHbtKANm+3MhCeVREIOZys93jnWvacEOQDWVlOTkS+9VmqGgsEWZLKcmRwS66qw2oK2WGfk0My2KKWYxg9o18sMbjboxqK9YzpHGm9Ic+C43+OKY7XuySmQUmXKiQRQDE1TmUq8InVzihjj8W3PaQxgHLmOOOcxTSVXLYfzSG6uQoGRwzqjFmZ+SKiqaL1nXLJSQC4CheJ8GNjsdlhl5QJCUA5aCepEzqWlcFJKUXJYDhIdD6/uyaUwziN17SixCIq9KEIKlGWxKMth6TXwfsnETSlScwLccpBf8Y2TtN/CNVPYWsusypL98EjfNfS9J+VZJo+dp1bLPERUdeQ40/UtVSVCipzOB5xv8W3DPI84V/n23W8oTx3fffeBd+8+8eb1W8YpMIeMNo5SRp4PJ6YUqcpQcqRTDXpxYU7DhDGeORe+enjDyreknEk5UWplvVkzTDOn6YKCVxzPAx+e97xatfJ8TUOohVhB50xRkLQUWE3fcjydqcURpkiIUZAwJVOiBuvIWnM6HrFGUwo8nwPOFNZ9g8uZKWWqEidgLRpBbWRSDBR1eVVapu6X7/h4DMTpzP70lta218XSLlkLMUWca5jnjNaGvnOkKmicUioKI7kZYcZpIT6UWvHG0/VrhvmRXBLUgtYyLV5qQRtF4xoKiq/fvePd45FpTrgl+2EOkuVckOuxLDgPi8JoMQKsfEuuma5p8a6nX3dUJffwOJyZpjNt21Aau2BACl3TLIfr6mKBoq7XlJwI8wQFQhZce0pZ8E6Uq4vq8qhyg0BK3O622JIZzjNzjBQFh/FMt97RjJmpFFINeNdjFWAUjYeH+w27zR2tKox+z7tPA9ubG5wvzPMjvf8M7Q98+cWXrLpe8oKq5Dl5I4egl/v0cPhE23hyScQwc4yVTbvhbncD779BGUstl4NsFpes3KvGKVIR97FGHGjaiMmhLO/bGCuuxVok+1qLI7mWgraCaLrQHlQp5ChT0MpoFAWNOBgVktWdciaFGeMawizOSpDseGctSlVCmHFNi24ruWZKTdRiKFWcktRKTQWrZB1L8tGirWdOAWfF6EGpy3VdqUZTAKw0iGEaF5KBGHqocoh/EVwQoXTGYqzFNX4pOhU5KdrOLi7ueLkqKLksBgS5x3JMuM6A0pRLVnqFmBeDBvJerDbEHLHaCVlFybS6sZa65BVdpsi999Qq97Ki4htLUZmSEspaeU8xY/Tv72P7Dx9aacZxEtJFEhzaJYvKW8M8j4u7OFKKYr3q6LpGCAvUhWig2O02UMWFbJ3ncDhSSmF/GHBOcXd/jzGB83Gg8Z5YAuN5IprIat0RQ6Jqxxwqx+NA23qMLtzuWmLKHPZHvvv+W6xx9H1HKfJn9/d3hDnz8f17fOMZh5kQPnIaJ8Zpou97zucjbz+74/XrB/7y3/6C/f64oMdWeK/IJfHTn/6Er7/+GoXh08dP3N3f8KMffU4tkXfvPrFe3SwNvMLojpwV/+6v/h3OOf6Lv/hzcs58+8133N3fsV6t+GbJQxOTiBWncq14L83a6XRit9tRK3z29jNWqzXPz8/kBH7TME4z8zQRQuTmds3NrRAd3rx5S9N2fP7FF6QUOR6PtG3L+XRms1nTLI3RPI5UKvev7lmvpcGKUQrZeR75/vuJt599RikZ5zyn0wlrpdD/+uuvSSnyi1/8gp/97Gd89tlnvHn7hvP5zIcPHxnHEWMMm82G7W6LNZaYEqfjiRgi+8PTgoqyxJiWbLrA/vC8ZIRZnN/w9LSnbaXW+vDxHd417Ha7q6P0YraRHDJPzpnDfs84jqJ/tTJPMxVxw8cwL02LZrVaLU5luL+/Z73uOZ33fPj4Nf/j//h/Wwpoz09+8lNyygzDIK/NGuYUeX76xHff/oqnx090XYe+bjydubl/w/39K5qmY7PZ0a1WrPo15/PpimnTWnKqmrZDh0CKkdN+jzYGbS3GWYw2GCvZUcboq7msbRqmeVpcs4YY43JPylp+MRNdCB9S/9VrM16WXLW+W3F/f79skilev369PFdY1qcsyLCF4nE8Hjmdz+xubq6N9mVDpOu66+sIS1NKKUzTTNe1dH2PNoYUM77xrPqWT58+LI5eg/dWPgutl98n+XApRe7vXi2Nl2C/2rbDu2apTwSVZa0lpkBKAWscm/WOnBMxJkFv5cDxuGfV94AiTDPbzS3O2eX5HNM0MT2MvHv/PSkH/uinf0yMiT/5k59xc3t7xXdZY3HOX6cDnp+fmOdJ8uR+i6xyc7tjnqdrdlmtQl6ZpjOn05mmaZZmEjabNTHJ5qK1jvfvP5KzTEzolaZfbdDKsD8euJj6rk0jlXEcSClxOp2JKWOMZ5oCOYNWhks00DQn5jngvaAFS67oojifJ0II0rwvWYcxBlZdI3qlPN1qBVNgGidBw2XZEJLvxizvbaZUhfeN/M5pYpwCacln843HGEetSTLtsuDaakZ6q9961GUTLCXJKlNKX7/TCwINfmjAa+V6H1x6nh9qVMUlWgTK73x+zjnUYnaMMV7rKbvkpF3WmRgjlR8adImcEXxcWGKkyvI6Lo9SBUN3uQ/zJStt6Y1Symj9gyv+t9e1nNP1d/1tHi8a/qLhLxr+ouEvGv6i4S8a/ndPw1/0+0W/X/T7Rb9f9PtFv1/0+w9bv3//g3HX0HeKkk6ossJYTQyCyKXKJr5BYYoizTNtt4IMfesZmoSxHdpWwixTo9Zp4nQkeYcxHVWDKg7feqacWfX3UA6kEpljpGtaHqcoFyAFpSUXtiAHGefzmW7VCYbaQpoGyDLpqjTM4xnfrnBeXkdMmZw1sShUcZSUQVe0XWGcwnoH1lLCRFEK3Tj2x0+EaaZrLTEnQWNomMOAMhrvGzIgx4Ca9fqWrDXVaDIQSyEDJRWc06AsuQhaXGtZ6HKuHIcTaBgHcXtoUxmm8Xe+2HGYCXOksQ0ZJWhlDeM003g58AnLYqjQxBCpSB7FdrtlGEcolS8/v2OOkxzapoxbsiyGGMVbURUsmGRjpNgw1i756hMWeR8gh0hpKeAu+dtWG7nRrRwsPX56JqYWpRJt2zDME2u3lil8DO1qS1IwzYV5TKz6FavtGrSmHgY+PX3Pr3/zK7TfkZXi5u6Bw2ni3zz9ezIV4yzjNBMpYB2lZLS1THPEG8+nxyPzNIkwaM/5PFHSR5rGi+FEKXIF1zQYbTkcD0uOeCbkzKf9Ca8r/Txjlmn5CU3SWg6LjSLkTKqGOQrCQSmHrpJ9Ms4ztU7My/QxWuGNp2nkMPdwHpjCzJwStulQVg7NrBW8d63iiMkly0Q/ciYsBoNKyZFQCuvVmv3phNUGlsn1vEy6N01DrkII8E2H4LAN0zRTgca3xDnQNa0cZCMT6BVFWRafksQksWpXOCcL4XmamHJhtdtxoxsomaIKWv1g6NDaoLAylX7BahjNFAOtabHaYJViHkeUhnM4YLXGGU1JYuyoS6FQi0QSaA0VyRjPKdE4g9UttSpapcQRWsFaJwfjuRBjxC6OMMnclqnph/tbVs2alIq4s3KgLCghqw3GQw3i5szM1NpjrcF3ihgM1QSa3tENO07jiRuzQdeeKU18+faPURk+nN6z2t5BilAjjVsLlnv5jLxbYXRFe8vD6gseP33iNHwklhPeSeGhjRz2X4gZRiuM85SacVpTi+RiG2uptSyNlbm6qcwyCa9qpVTB21elFz+VTKTnnPFaY50jpIRCxNFaQ05yLVln5Ro3Vi5EVbFOEeNELpUwV5QSdHjJUZD2qlKVCLSuku2tagUnv78AxYj7C6PRVqOyGAe6TgwfKUW0NUIeSEWKOKexxtB1vbg+UVQt925MM84YcqoYI1EFOST84n7W1WO0EsJGbSgshoISSfXiu7jgYjJqMRbkxanWKXP52ISUUSq2anGQViESONcRk7gBc8rQVqyFUvRSgC1T56hlCr0QQ8RoQ2P9f1Ts/P/zuGS0KG3pOsnGketBig0p6OuSGXWZtM+4xjOOI7WKKz2lR25vb2iblpwT3lvmKIQMpQwfPj4RppnzeWCzWXN/e8PjJ3Fei4O8ME4zn312z83tBm2UmFuq5tXtLQ+v7gHF8TgwDGfaRlySp9OZw+HEPAVO5xPeO1rXs9aGTb9estnEfPSv//W/hqr5yU9+xOl8xnnLj756SykRox0gTklUYR4HjocDtcpmRdd7fv3rR2II/Ff/5DUhJn7ykz/i06cnvv3mHaWIW3fVi7P588+/ZL8/sFpt6bqCdZbddsPhcGC/32OtpRRxSjtrKVWQWsfjka+++orbm1t+8ctf8OnxiXGal3wdTdv2PD09Mk0jx+ORh4cHttstTSOItHfff888z9cG7HA88PDwWorUUokpst2tmafI46dHNtvVtck1xjAMg7h/1yv++//+v8daR4yJ/f4g2UbG4123NKgnVqs18xxoGs9601MLGC1op7vb2+vaUkphGE+L0SeJa3qeeXp+ou97uq5jGsXk17YtIYSluTUcTyecd+LONYJDiyFwOp9R2vD69WtBcBm9TB4E+r7nzZs30szFyDQXrF2z2bT8H/73/0eMEfdsrYXv333H7e6GFCN2Me2cU+bNmy/Zbu5BwatXr2QZA/p1v9Q9nrbruSDQ+tXquqGQYiTlzLw4Z0vOOO9lPaWia72uecPpdP17FzertZYQRNeaRvBgZjGyrVbr5c8EuVVqlQZ/WWtLzdze3nI8Hnl6kp95ejzT9R3ee9bbLWVprsdp5OnxE198+QU3t7fcv3q4ZgJaK03ypcGJMTKOA3GeUVqLs9x71tsNIcxL1mFLToUPH96J+1+Jo7+QGYeBeZquVJOcM3d396BlfZ6mGWsdh9MB7xtSTGy2O5SWvzCOgVQyp9ORr7/5NdM0ySRBDhij+fjhHeMoeEWlFM/Pe96+fcNqtePu7p6q4P/7b/8Nf/Prf8+f/dmfLuvdxMPrt9Qq0zPOekIYOR2PuMZTaqVpPNYawhzolymH8zAs16iQpm52t+wPz4vxNHFzsyOmzBwic0iUw1F6IqUYp0me4zywWvXMIeC9u2prjJHVakXTNKSUCAvuTO5PidHZH+Q+7TqPc5a85H9Za7HWSO6ZdZyOZ/IS+RFCRCtDv2ysyvcr0SkpFcZxlJ8xUoft90ecs0xTIiZ5TSEKVs6annCZWlBi4rxOV9QKFfJimi1F+rJcMuE6fSJOc80PDWspl6a2cslF+21EGss1Ixudv411q0LdMuY63XLZ/Lm40UvJ1z+7bJqVUq4O/MufCdVJGm/n5X4LQQgxS78vtZBa6pBlTfgPHfBUqRtzEZrWBecmmyyLiVkhpuv/ZPV+0fAXDX/R8BcNf9HwFw1/0fC/qxr+ot8v+v2i3y/6/aLfL/r9ot9/2Pr9+4+g6YaqjsxDpOvWOOWIdcmHjQmtE+ex4Aq0d2uZakRuzKQNBYvxivPwhG1amr4npBMxjjAqvG2peuHYa4PSkbZfo3RGl0wqChVgyolYGnQJ6ODQaHJNC6ZGkBvGGrrNhhQtZjJM8QwlknPEqYqqhhQiIJnPvg0UMhpAVdL5hE49yspU6ObmlkN9wtYPxHCg8TtqidgCfbuj36wpdcJUOTic5wGDxfg1oZwJp2esqrTGE3PAxEKoM6BwTnJccpZJ3FwyqUZ09Vhj8SRO5wj/AUZXOcftZg3OMk4DShecNfhlER+niRCWG6kmrHFY06CN4sPHZ07mmc9ePZCGiWwLyiq0qXTOkwqU3DOMZ7Q24kw0cpErLbiIWgwmS1YwyAVbcsE4R6FQlHwPpsKcZt59+shf//VfU1Lhz//R3+dHn7/GUDiHyPuPR7x2TNOZWDLOd4R5JKXA3atXNK5jmGbiPNF1ntev32J1T20n8qcnKhXbLa4jBX3TsFkO3VJKi00BVIGn05HvnmWRVUnxfDyjdcVbS2s9jfOUKnnt53Hi+XTCGi0I/FppnOV0mkhtpvGelXM412CUJsaZmpNMynqHypVYBTlRU2E4R6iZqjUpBqxSTGPFaMfKO1RVHMczYyrsdjf4Tq7nuoyIa2UEd67BKI0vcsDJkouslCGnwikWnPc03rKKHXPOctCuhfCglUEbS12wFKvNhnmcaVpHyJUUI8ZZXCvXi1KFqhTn8wjGocJI17ZYbbHWYxSkPHNOCWdbNIII0QZAch0uiBlkicPZDlQmJ5n47hc8NnVxxlbBbzsrp41GObQWUoEyFrMgNtCepCJUjakKp2WqWXlHSgpNwVkRAWMVShts0fK86OW7smJmyIkvX93htGfIJ8pc0NpjtGUOgrV2FSJwHidudjdM58DruxvePLxFlRltDKa5YbttMTaR55nD08BP/vieYYqElChZ0a8MvusBQ4jzdepfKcXuridMM0pl1r4j9xu+++aZbrVBqY8Yw9UdKxnzgt/RxqKzRlu5TkopGGtRpVLU8tkvGBejxMVYtaDOUciBbJVi+yI61srn2VdProDVaMA4J0JfJeJCaYUzjq7vARFV1zQycV0zZnGY1SKmhFIrRol4phBkytsK3l2pgjOa4TSSK1htUe6H7O+UEs44aqm0xqG9ISaDMQvuvCg619B6T1CC009qRZkiRllSKPRtRy6BtmvwbSsT8UtW+DCPTGEGpUhzJC/GEHIlpoTyGhbSB8s1q1BkoBrodb8cYhcKEGOS69rIBLzGgKlYpdC2UrKiuEpZMOwaLY48U5iMQesGRRKE/n/iQxtF68Rh2/ctwyBxFpvNCufsNZfKaMlg965hnmdCCAzDTEwF71sqhfN5pKSIcwZjHd4KQgoE56WVwTeepnVUZagkmrahaTzzPHN7s+Zms6L1ntN5YBgCJRVifmTVN+x2N2KiMIV+5cnJkVJku13Rvr4HVVAKjseRcBbzWNc2dP2WnAv3dw8c9ge+//47bm5uiSHwzTff8OOvvuTb799zf/+K7779np/80Y+oOXI+DAzjTKnwl3/5Cw7HI2/fvOHx8UDOicNBHOfOWYzppEZZilLnJBbgcDgsk//w67/5msY7lFLc3t4yTYE5BFLOlApN16KdIdeC1ZbVes0333zH+/cfOJ/PWGvpOsn2+vzzz3h4eJD7JCVubm456gPrzRatzYJME7ek0VZcxW1P36/49PiRtml59fDA4+MnLmijxrdL093StI7379+z2Wygarp2hXcNesG1QV0aa3HBfvj4Hf/Pf/H/4OHVa/78H/6jpTnJ5Bxo21auNS3uVec8F8xTSpmb3T3zPLNebZY1oAhNRVv69ZqudktumMRgpJgouXB3f89qvcFYi3WO4XxiPp1o+06cwfPM8/OepmlYrdZULQ1u0zTsn/fM88x2u+Xt51/ROE/OUmcqpdnubmk7+dk5BLp+BbAQHSJt0y6O9ExMSRpsfmiqJJ5GIh42Nzc/NBK1Qq6UlMlklOL6/0qRLLZLM9b3PVprYkxYY0FxnU6w1om5CbBG0GLD8cxms8FoyZJar9fXzC5nBfem0BQlhknftOyM5dWrB9q+E5LSkmOllOKS3+Sc48OHD4KOU5qyvN5aZGPheHjml7/8Bd423Nze0jSeGMP1d4YQMM7hnSFMs9SNC6YupcQ4TpxPJ9quo21aaVCpoDX//t//CpDMq/Nwvhow16sN69WGthOik7WG291rai3SjJ6O9KtHjNU473h8+oRzjp/97Od88cUXdF3Lfn8gzLK58/jpkZvtlu12i3OGlANxiIQgGEStFM45ng97NpuNbAbEjPOS3fW8f2Sz2ZJS4uPHT5yHwPuPHxmnGXLh5ma3GFgLbduRUmK73WCMwXvHHGbmMPHw8GrJ9RLM3yVHSwYSJD/Muop1QnMJIS4N42JyLBVqYdU1jONM2zhxkDvD+WiJMYuOeksMkfN5IoYES6yJxOAoYlaUBMYaplk2AtCSTTiN0zJB4MVIiqKojPcSCwILBk5pTNGEGMm1LGQguQdUAaeFElRKkSkBa68O9YvRUxzoLEg3rhMcF8Tj5XFxiV+acPn3Bd1WK0arq5tcPi+1XFc/tLoXXNwFHSfTW+Z3fkapH0xopSDXl3PL85arE73Will6M4lw0df14+q01+q6kfG3ebxo+IuGv2j4i4a/aPiLhr9o+N89DX/R7xf9ftHvF/1+0e8X/X7R7z9s/f69D8add1AahnImxYBrZcJOsN2FGAJaKWIQ5nuej2hdKSHilEGXQpiONEZjbEfrOpIZiCViqsa6hpQgx4ByRpANl0NA1xHmQK4VVSGHhDGVkAI5zZKlqwtTGLFGoagY22JspXQFjaVWCw6UToTzGZUjprFyYU7PFG3k4quFCJRcUa5g+p5Ih9KPrNtbqorkEFG6LpOsls43zCUzTEHcDVVBLVBmchYkuaFgVMVqS2aGEsixYEyDtgpjLSEHtJbMixATyiqscZTjjPkPvlCnHe16TUUyoZ3zxGkiB5meDyHSeEfT9DRNi9aKnINk9SpYbzu2Nx39qqHWSbI52kbw7UqhjSxypYgrKswTtUjO7ek0ylyjEjdWyglnDLUUqpH89guK23qHMYY5BIoutGvNb77+mv2TXB84hTEdq66FUhnnkfnxe9arrQiIbUgRjHHc7LaseylE5qlghzPT6SAfeVV4J1PfU0ji6lIaozW5SkiG0siEdtdSlZLvWMMyb0yuMJSCxVCVot9saTdbtILpfGJ+fGJOhaEWaspoNdOeRlrrcd6jVWbdGogarOewFAoAKcxLxkSiVkG2NN7L9LKKdL5hqoWkNevNBt//4I7Ty4FirZWm85RyyWD4IcfBGofVDts5coU5yOGjshpLYYoJ7Rxt1xJjoigtSAyjmaeIUkbw3dNE1YoYJQ/DecccAlobhmkk5sT93R0xCG56DhNRG9CaXBzaglLy+ZMrtSpx5RnBbxcKEv2tMc6QiaAkC14rjdOWjOCvnXMUrS5nxigKWon4kAupVKpyNNUsC6x8lyioRqaMlapQEjWKmSCnLIjwC9UAqBSsgewcf/zlA7EGsA24GWpmigWdExSFKYWiNJmMronNbsWrtzuJE6ia0zmTykwMB3LMjPMHxvHAj+pXTOOe8xyxxnI6ZFqbsdZQ7W+JnFJY01G0ol1ZTo+f+JtvvwGv+OrVK/6F/mts46m5YI3BGM9lEr9SL3HdNAtBQDtDzYGKIL9zlnsAJc7Hkosg73OCqoQYoTRo+dm65O0orVEZySvXP7ixoKIMJApNY8g1oirEMNM2hpxnKQSUrAcVBQbG04ndekuMkxRYXjLSU0wcjkf+2T/9r/nrX/w1j4dnGu/xyl1NId56oW5YD1VTcsBWQcBjFcoZ+qZHo+laj7JVqB9Jsek7Uki8f/eOz98+0HYd52FkiAHXOFrvWM3STBSjmKaZOYqRhlzISYoSSuE8jPSrFmM1pSjGc0D7Iu9RCVVAG00KmRwrOUeMVqQo31eIkeoUJUZB4RSZuM9Z7kdDwa89sUJMM1X/vmr9Hz+m6Qf01eFwJOdC2zacz4NQVRAU1TiOTKP87HqzwixF/+l8JpeIEBYkY0orxWbdU4HTeeSS1SPXsmWYIsMcaPsWa6BfebSGw2HkcBzIC1/l5mbLNARimuVuLAnnNb5Zcz4NQMUqS9c1PO335AK3uxUxJpw1bLcrGm/o24aYMtYqmtYTc+bp6Ynj8cDnn3/Gu/fPvH//KEWkVqgqBqJSCm2t3N7eMYwTd7e3bHdbUky03YrTeVxMInYhJkhx1nUdWhtubm5omlaMWSnTWMfbt59JJtnphDGCGJrmwP5w5Hw60a96vv/+uytSbbfbLq7wFW/evoEK8zwtMQmFC6KrXRpua821SP/06YnNekPX9eRchH5CodTMNI1AxVnPqt/Qtg05F/aHZ1arFUZb3r79HKM1xkjuUNO0jOO0INUKbduz6ntSiWzWK/7xP/rHPD/vr8guifmInE7i5C8Z2naFsVY0LmXa1yu5/qwYapwXt6lfCm6thHazf36WrC6jOR4OxBjZbnc4K7EdF2LI6XwmA2ZjyRVW6zVtK1lr0zySkphojqc92+2WQsEYyRyLKUMF6xzetzgvVBtnnRi6tCZMM6VkojYoJY7UYRiu+WWX5to5R4XF6LNg3ZJgwWIIUidlcfI2jVwPzlpSjJQFG+W95LXNkyDqun7Nzc0t8EMjH2JYtB7BGE4DF+TWRfa00iinlggTRWMtKWoUlc16w7hMZjSNTCz0fc88z9eNIOoSwbGI0TwL4aPWSZoPa/jqy58AgqCzzmHMdG0mq4IYZ47DSMllMT1FpnlgHI5Y19C0DaVEzucDoIlLvdm2/TVLsbRgrODvcqoy5bFkkq03G3FOa8Xj4yP7/Z5aCyGJOa7rOmotC6Wj8OHDRxTgrMMoJWt1LRzPR0rOHI4nUCwNtBBQur4TU6fWrFdr3r9/T86JnBPPz3seH58Yx4lvvvmOmBLjHKAWtps11oipaQoTqMKrh1uGYRDX+jgynEeUNqR4Yg6R4TxQqmxgxZCYg9Rdrx/ucc5xe7Mjl8o0zktDC00jvUoMgr1zLgmtRCsUmqZtgZmUMk+PB07n81VzUKCVwjrDNA2y0ag0YRbkn/NeMs60QWnDMAacW2JCSpZpDOfkGr861gt2IbNcqEvGGKmRNVStcNpQc6aWDBicNVChULmg/ZzzQumZpaf7bfQasLj1l6YYRdVLRlr5oYHWzvxWA/wDqajmIr8LFoPmD/mcF3ycbA6wmAL5YbNAkESiAVoL6UgpLntvF8On1vU6afLbjvaLw/1v+3jR8BcNf9HwFw1/0fAXDX/R8L97Gv6i3y/6/aLfL/r9ot8v+v2i33/Y+v37H4zbhmw6KnvCNOBcg65yw1RdKLUyTSfyOXPaH2k6h229oFtKRuNxzUomZ4dRMl7bhpwypcgU8hwTJQbCqDFkDvsT9/evaBtZbPw4EoYBZS3ZJ0JM4ogrUQ5GvaPxHWF+kglEZSlosAZdBdsxTyMahW0ajNEyxTmNrLavKXMlTZFuc0vVhRzB2ZZ5/oBxDSVNpBKXQ6ZKiDOrNZSSlkwRZOpRORrf4JwmXlj8ReG1YrWyPJ7OWN9QSxWhKZpSNUo7rK1kMklVcRwlOYw5T+P1u1BKs7u/Q7eOw/5IKnKweB7OTOGM85putUMbS0pygJVLpiLTpc71KGvYH498+vSJz171aO+pIZJKIQTJFc8VEYOU5WJUBVUls9o3HcZqjAFKFqz14kpyzuEaL2h975ZM58LPf/4z2rYhlEQcA9PhTK2Kw/SO/SfJu6im0raWbtXQtSuU1vjlZqVaYlCs2i1WJ157z9PdLYfTSIoFXeXC995DlRsk50IqSSwnLLiI5YaxXiZj63ITSaGTr3nt2lpiDGgq3mwYppHn80i58EkQtJEKCT8OrL3B1oaaIdWJmipDHMk1LQuPxlrPlBNYw5Ak0zyVxOHpkbwI2xwmUgx0vpXDYWUXxwsL6qPgnRMU+OKKcdouB4Ww6iVS4NPTB+ZYiUt2esmZaRSKw2q1lusYheQfy8S/VRplDNrLAjhOk6ChUfjG0ytFSJGm9agKh2HAtSty1fiuw1KoqmDQbNf3vP3sLX/1138tooEsciFkrJWJXaPlMFatJWeDAlXrJV+ioLW5mhcoFsFNC0BBkYQogWSZU5PgQljw78rI9WnkwL0WcX+laiV5wBa0luu2UrC2UqImJkcyiVSEuGCq5KMbp5kOA6u+p0QpuKY0stnuKNExxTOpVHKoxHBkvV3z2ec/w6jI4WlPmDO1RmKZOZ9kjSq1omko+QdhOY0HtpuenDROr9h0N0Cm9ZVt20hhazQ1CVJeqYKzDmrFO8+cC7VchEGExChNShWMA61QVlEqVCtFrmkamSzPmVIzZAGPaLU8T644Y0FpyeRxdmlugFIwKNIwEJBit9bKMM6LIUVdTSGXDPDW96RUKUUO7HVVQirQlu8+fOTj8UCzXtPPI7UkqtI4Z0klLkW9wRtDLQrdNmy8uG2dNxhb6TqPt4rWd+yaDUobdMnMJRPCRO8UaJne1hVebW5IZLzR9JseZQxjSjQ47EoTU6T1DUYZpnHmGM/c3q+57TakYohW4Y1i4xoUgneKKRBzRFmHUgFTDXkussbWSLvp6NcdKijyFFGuUq0GbQjzhE4JKow1EmtA/S0Gzrz3knujtUQppMQ4BECIAcpIU9Y0Dc75xVE7IxlLEWsF03YpVHIR08U0zqScmObFAGaUaNH5jG9acsx4/0Mz3rUtIUW+e/dIdzT86KvPOR1HzuNITOKe//T0xGF/xBiPUordzYoa4XQKvH9/4td/8z0PD2s+f/PAqm/48su3lByoBTqlaVrP7mbLfn/i+ekg2LmuIYSZm90t1hpudltqLWw2a8ZRtHUOE6UkmsbT+IZ5CgzjgcY3V2dt3/fEGIkxklK5uidvbm7RWrPf75mXBiqlzGq1QSE4/VevXtE0Lb88npjGkX/0F3/B8/OezWbHl1/+mH/wZ39OqYUvvviCYRh4enrCOSNO6jlyf/8KhWYYT+JIVornp2dWqw2r9ZqcEikFQhDX6f2rW04ny+FwYL3aUkoFFOM0Yq3GGE3TtNcCMkbR7mE4cTgcqEgGlPct4zQyh5H3776jbVr+wT/4CrO4O43WrG5uOB5OnE4nXr16hfNeYhZS5jyd6bqOOcxSl2khLnz77Xfi8t5sFsKCYJmwFY2i73roJAIjZTGDPT4+st1sef3wGm0tWmu22y3WGqzWHE8nmsZJxIbS3N/do+2ibws+arVa0fc9F8SUa5w4oWtZzNOaD19/w+s3DzjvBHmlNevVimmarm7by+dWa+Xx0ydiCDKxkBO5QNM2wCWTSV8RcKqKe1ZrxWolJrR5nmmahrZrZdrDe4ZhIMUEqnI6HmXTJ8u9dXNzQylBNnXaTkg9iwt5mia6foUGud+CoA9LljqOpd65XLsXt/tVj5TmdD4tbnlLKWlx5UukjlLw9Pwsn53z1+w6aerh0+M73rz+nLTU+jGKWTOVTN+1KAW73Q5rLDkHDofDNZ7neDrQth1hGEgpEpN87zkmnp+f2d3eYK1hnmemaWS33dD2HY+Pj3zz9dfc3NwQYuDm5kbwbaUSojjzjTXc3t7SNC2Pj4/EGKjL9yObVZaYImGelxgSx/F0YH94BpB1oWnY7/dCZKmF169f45ZayRq9kHIMuVbBupWJkiulwn5/5Hg8czwNtF0HVTGOExVYrWCeghCZFvOZswatK2lMlFKIMdG2LdN0Xmq2wjwHYsygxMQ1jNNybUGYJSPM+xat5P46HA803qOX5jHGiOt7yY8zGrOs8TFGMRFqszjp52XjRyZJahWykLJieJyjvEa0wllLmMPVBe6do9RKrgWtJAorlSqN+uIoF6e3NPNuwbJdGlpZt1jMoReHO4sxUMESMeKdo/FuISj9gFu7aBZcGmjzW/eu+q1GWlB3l3+31lwbd2BZ75dYmgULVytLJmi5Pqf0EQWlfsg4u2Lf/haPFw1/0fAXDX/R8BcNf9HwFw3/u6fhL/r9ot8v+v2i3y/6/aLfL/r9h63fv/fBeK0GoxtQkZxnarGkLItCZnEwNHA+Jpyxko9slLgXyMRcaPpb4nggR4N3DU615LOISEdPVTOmGmqamKLCKE9KhaZtCDGgNYzjgZMK2KCxvkNVg4zcF2KKlKywTlNVJVeNdT0pT5RUSOMMxsJqJV/0PFFjQFF4+vg9KVe2m16mdJuems6oFLBVcRrPnE/fk+dC29/Igte15BQ4nRLay8FUSomcK8obUBolI7TA4txY+Pl5+adM2SdOpwFrrDi8nCZNM0oZhmliSpFqfrg4tNYUUykhEGaZBh2GiRgmrKlUVQjzSMXI4VeFlGa0rmhV2a7XeNew6nru7x/QbibNM7FAVZpCJsTA+XSmIgfOBoU24nYsC+a65EKp0C7v3TlPKlnyh5FDOjEseOYx8un9M2l+RBnD3faB3bonmYhRDqsc/WrFzcOWlDPH43652QfGaY9Sjuf9nvE8sl1t8F1PRi9IGIVu9PVGTEnQ+t57cs0oo6Hkq5uw5IpvW0qUA2NhDEBKAWs0aclpqFRx/RXBeNzdbjiNI6kuePMqRY5RsjDFVPl0GEVsamXKsnBbK4eBctyeyHIUT87LhO+SsyzXiybmivXiwjMVjJZpaaO05CEbmZplOSwUJ0zBC0kJVTM5Rpq2IVfJRu9XK6gnJDfCXnPWrXUY5xfEtxyMa21kwtxo6uKyiXOgcZ6u7wnThDWaEALeOaoC55vfKp4aaiq8ef05b1/f8Ve//GusddQii7JvlsLAGEoWhIgs6Fwn/GtOpJLYbbbkkpjngPNKctW1QSvBuJcq33tKEfCLqBRSiWDERFKrxhlPjhlrDK2GkjM1Lw4/JOO5onBW4Uzm/dNeppBrpfGWc8zMJeJaJyaLVMm6cPNqR+NaIUCkkTAGcjqjjGVKM/n5HaZUQsqkWgRhrwvOFFSIhKTBJOrl1FPB2y/uxTBgO567I43pKPPI5os1/6v2L4jOYo2j5iz3tC60TYcyRtyiWtFoT+csWAU1i2klF0qukidl5HNR1ZCLEDC01vJPJcYPQfhc1i2FM56LYhm7NGhKk3NEWxHLlAulKGISrIpfii2lZEpdI665XMC3lrzgnHKWj7WkxD/f/ymff/YWUmaeBiDhGokVkOZImsw4B8ExGSgorGlwSg7zixaTiHOORlmSkin6GCKn8cAUJmLKpBgoOdK5nvMszssyJ1LO9Mbh3IbGOQpiAlOAN5aUR0q1EMXIVHXB2wZNlcl1LRQA7z1d22NtQ4gz3mtSmjEYyEpwSaVQtWJOQk+oJUExOFVoXU9SBeUqxvS/r1z/Rw9rFV23YZ4D8zyjkDVJG3G7hhBRSqb3JXvJ0PiGUgqrleC1zqeB/fFEDJGbmzVUyEijo7QYHFKs9P2aeRbEVdu0lJJp2lZMKtqSEhij8O2Kr7/9wLt3n7i9vROUUohMU2AYA+t1x+m4Z7VuKTmBsuyX/KCSK6tNx3bT8/HDR+7vb3GNZrPeEOLM6XSibxtufvwjjDH88le/FDqCb4gRbm9uGMeRYRhxzqFUResqWU6u4Xg8EULk6998zWdvP+PVq3uOx8OSZbZivVlzOp44n6V5eP36NTEJHmyz2RJTQhvLai2O9jnMADw8vFqa4YZaoWtXaGU4n8bFmV4ZzpO4n40hBNk4yblcNwMkDsPRdR1nN1IphDCRs+SrxRCx1hLmRNO0lCKZVZcsra7r2Gz6pS6IGCORDNaKyaptW9quI4QZYzWn856UBMV3e3cjtZNSHA4HAF7dv+Z8GhYcVWEYBvxSkF/yuj5+/HgtZMdxQGuWxmq6Zie9fngDiEP7ef/Mer3BOodkr8UFY3cnhrdayUsTLB5dcfMbbcRMljPGOpTSoNXyeUthfHldWlt844lpMa4ZwzxNOGv5/PMvQNXr5z1NM/M8M44ju91uMdJZhvNZmtulORf6haP3MhVw2TxxywZCLUVwfqWQ0hKBoQ2bzfa6ppZcliY5MwwD1smfXzYl1uv1srEm9IqmaZimcYkTcqzXa5nCyD84ZRViGgohUJfXJK9BNmKstVckXVXQ9h3NMslRshjphmG4fj8At3d3VMQJXrJMRkhjpZnDRNeuWa1eo42m8R3TNKCUIoSwXIsTj0+PfPf9N3jvefv2MzabDe/ev2O/f8Z7z2a7pet6hiTZcEpLPpb3jZA7kPd4d3ePNbJmvXv3jvPxhPde1opal0kFaSZ/85uv+f7773l4uOeLL77gb/7mb/jVr37F2zdvWG82V9zlOI6czqdlKkXQatM8o7Wm956f/vTHV3zdNIphDqXY7w/Mc+Tjp0+sVmtp3koR5KVv2WzEUZ5SJqQgGwBG03aOlCQz8tJwK605nQfmKbLZbKR5tZ7zMAnmbApCl8Iyz5EUC85xdXprI3i2YZjQymCNQS+9hKAh47LZU5aNmoIxemlkBRlXSuE0jtdJmBijXCe1kkNEW0PKYo5V5TJhAZecMbSmpIRCyUSI1b/jdpdNL3N1jTvnMPaHzSNnNWqpR/KywSXXtayRLmep7ayhFqn3rTXX16jUD9l9v90kX/4JPzjOrfXX/7YLPSfnLGZCJRutF3rT5TOz1l4352Sq4fJ7pP68bKj8tqv+RcNfNPxFw180/EXDXzT8RcP/89DwF/1+0e8X/X7R7xf9ftHvF/3+w9bv3/tg3BhNQoFKGCVj9MM4EGKWvFTfkM8ztUZqSSjZ9yeERM6gvUE7RThVcp5R9Bi7AhMXLLUl5YSaIlpVmqYjm0ScKq1XtNbR2EJjFcPwLAd13ZbPv3iLBMdHYsgonSkKsBVjFbVqGt8Q6iwXmrHkKJgIrGXcPzLnRE6WnCKx94IaWA4WY81M5wN5DjJtGiIxBhrtl4OSTJgHVGlQqjBPEykrKppcK+ezTMeXuUgBU+XCFJR1ZgojYU7kmNFVk8WGQS4WbxuqmtCuoWkEF71cqeQYyCGjSiFOExbFbrUip5lxClgnh46hZHIt9F2DUdA4i86F8/Mzn283bHvPeTwRM4SYGefI6TyQY8QaQ60aYy3eLHkEpVJipKSAMhptxInijCGkSEUOG9McsMaRYiaEcMV6b7pbYh7JakBZxapreX2/Y9NLXkvViikE7rc3dH1Pqpn9/sg8BZrW0jQ3kDRzSoQ54BuPMxpVlBw7p0ROiVqKCBAFnYQm4JyhUNBeJl9Te8n1cez3T+ScrkWpOPG05Eo7Q6wZv2p59eaOx8c983TJipBp/EwhXM42a4VSKciNHy+5FcujVokmlnpBYa2j73qc9Rhvcd4tU+pyqNg0bsmREGepNZqa5ZD1OrqOxi6LlzaC6+i7HpDiKCyC7ZzjirGwhqoqMc4oLfkb03nAWpnSn2MWJ5mxrLoeb41gTtyWGGbiUuBhPUnpxUkktAE5XNWczwFnxXGZQlpiD5ZGIGWcWQ6atcJqg64apxLVeUCQ1bpoOtdQtWC7L0VXLWCUJScjrsuaUBVKzTL1nrUQHqpkfRhbZSrcgFWathGkjHUabVv6vqLszDgpOt8yq4rODVZXynwip0jvW9I00XaeUwjc/uiWP/6Ln1MnRa6ZxltqzRRrUMZjtcPgJK8dQX9oayQioWrQQlf4P3X/F+CM9y3/6L/+36KpOO2ZY8I4S0mBTOV/l4yQDlTFOkuKM1AWBJGFqkhUyIV5HPCbHqstaU5yXy4CXJVMgXsruUkXJ54IY8G3nmkKclBulBAZrME6EalxHAVrZa1cz8qQQ0BX0MYyJ5k8Nwv5ou06OQCuGY0gj4yxi5NPipJcClVrtBHMvQZSCGhnCAnappWEipKxjSXmgMbgtKfGzBwmMhXTOKw2pFTx3jKfn3GdJ6dKoxsSElkwB3nfNQdyiBjjAHuBv6ANWG1QC34+xIiqGadA9Z40DyigJCnYYp1RShx/UoDnqzmqzidQHrS7inWtkPIZpQulKrRdyfNlcYaKK7BQ4kRVCr/e/L5y/R89lBJ6yMX5Z6yiaTtinGBprIdhwJplramZ0zSx6rqrQzYmcT9udxv6vud8PnJ3s6OWQlFwPJ7xrmEYzzSNw3lN2zhu7zYoKofDiefnPcM58sVXr3h+fiaEzPE0EeMj63WPc4ZVf0fjGnY3O+Z5hbWKcYisVh1/8tPPmWNi1bX0nRe3onfEEHFWHNGSTVU4HB4JIXFze8OnT0+s12usk1rmw8dP5JwWx6OlbRu6rpMiEoX3DcfTmdub28UNbWmaVoo4pVFKs1qv8U0j+VTGsmoa+n7F6XRiu92x2+04HA7c3NxgrePTp488Pz1xPh3p247z8cx5GK8u45/85CeCPSuJw2HPbrcDKofDXjYsxpnVumeeJz58/MDtzR19v2IYTzw9PS45WWJauzRoSiu0Nuy2u+ufxRg4nY8SsaKEkrI/PLPb3tK23dI4zZRcef/0kfW6F6cqhn61wfuWlAr3XS/ZZkuz03UdIYRrQb/f77lkFB0Oh2vBnXNms9nwk5/8lFIK3337LbvdzYLJk+LcOs9qvUHrxYDl/bWwLkVc5bUUpiw5YZLLZBmmCWWEPoOSLDmlpFnnQr9YxLgqxXkYGM9nnHdLvp9iGgYpsJci2jlplkopS2O0IMoWMxkVdtsd2l7QUIqU8pINJc72cRyvGx5aaWISF3rTtPimETdvlr8zDiMKcY17L3ptlMG3npubG1arlWx2OXkf4ygbIqvFTT+O4zX/DKQ5qlRSylcsXF1MnBfX+uVzvzTxOWdZj2tlmiZWqxU5J5rlel+teqyXXEOtBQPWLuvmbnfLOM703cUBXBimMylGhvN4bRhBpj1evbpju70BDFTFbneDc46np08YrYgx4JuGzWaDAmJKtE1DuzjxtV7czVXoOLvbG2mqh4Hj8cgwSJ1yHk5M00AIgS+//IyHhzfsdlsxUBnLarW6fq+XTaCSpaEax5FSq9SypUi8jKrX5n2a5kXP8uLML0t+nWx6XYx31gg1yLcO71YoJTl+3htKlfiiWgrjIK5zpS3zKBti3nvmJW/yQkOaQyRnSHGkaT3bXU/bNkxT4HA4ERYntfce7xqpjZRapm5mwCKu6mXjaQpLUy5TPwq9XCeaWtPVgQ4/4M+Mk2s8kcTIqTTaecaUiTlRM5SYF4qXwmp5j1IL/5BFxlIfKS10Ieckhkld3Oq1kmpZamnZaKm1ogCjWKZEClZ79AUrVy+YOH19jks+2eW/f7tJv1z7JWVyqVKPaDGIaq3x3iwbdfX6s5csth82ADQseLpSMikLOrL+dhPwouEvGv6i4S8a/qLhLxr+ouH/WWj4i36/6PeLfr/o94t+v+j3i37/Yev3730wHucBqxV915HOiQrsbu+E/a5l+lBG/gX9kuKMa1qsa7i5vccoGMOR8Xig62/JYaaoQrvacY57zqcT3q4J+ol5hH6TeTrsmUaFae7Z3m7BPKO8JVGI5xkbZzovbiOtC4fznjQEHu4/p/U9ymRSDuiiqRKQS0oJXT25JlKVA0trPCULqmCaM13IOEB1PRHN4fwOX1rQK4xJ7Lbb5QuNkDONM4S6HCg1lkzl+fjEFEeqrXhtWa+2DNOBlGRRsl1LrYF5ODKPM1rJIVOpimFKhLnKoYxqsa4jxL181svCZ7J8wY01JANN36DxeHe74CMkFzyWTKFijUxaqlyopfD29R1//09+wnbTMUazYKcdVSW0trI+5rg4P/wPh0UOTE1L1kBBUwDLHDNOixMmxoRtPM55jJWfi0mKvn/0X/053mbCNGKaBtv2kDRUmai2xnK/bchZU4LjcD4znAJN2/L69Y7j8cx4TqRSlu9P8sGVApTGd4IoqlWwEbkk0JBqFVQ00FhL360kJ/7WMU9nxvOJccn6jXnGtZ4UZILzcX+iakEle615s7vhoE7EqgRNUUFbJdOeWkGR6VJrnDjQlvwKpRTOS6HUNIKcENyMlZ+vmoy8Zqsln0UpRVEKwcHU5b2BcuIwvBQB5cJ/l5lVMppxjhyPR0HpjONiuJCCpwK6ZMmSWRxkOI/RmsP+iLZakOG1CorJinFEK0XfrEgLmkM3nlQVRilU8dRGpojjHBhOIoK6FE7Pj0xjYLVa0XUdbdfKc8aI9X7JvTaYqjFGXLSpZGqWgiSmQNGGqsA4yZNvW0PXtnRty9vPNjy8XsnEuu14PAys257GW5qupWk8637FbrumcyuskbgD7xq0djTtijrD//3/+n9mPB+ZDxPBQq8gF0tVhtY1eK3o+o5iFOvW84//y/+On3z5zyjTTFWKFGdiTExjxVpFqoUxBGKSqfWUIKeMYmbTO1IZeJ735M8KWEgp8z//i39Hv1pjrBYseZiZ48zxuGcKib7pKYtDr5JxxpJTZQoTmUSpmVZp8hzQ1hJiZJhGjFaCUqoQsnynjsL+eACluNnd07ct0zQzThOn44k3n7+l7VpSTAzjSNt09K04XZXWTOPEarsi55maoiDRUyRTMKahFi25Rs6BkmwZcoaaOY8nVJWsc9+sKLliVKWSFpxKld/Zt6gCYQqoqjHeoK0mzBN5ziSlOYeJdtWwaTshOHhHqQprWuoMgYpvGuIQGaZnqqpoNG2j8bZwHGdUNYCV6IGc8M4xl4DFEkOg6TsUmVXXYU3HYf+MWxn6xkGAp/2E8aCdYxzO9KsVje/EMYsmDQfC+RPOVpQ1TAU295/hseiYOZwOrG63aFNZ25ZEoSYgBcb5RLt9xZsvfv77SvbvPC7OVYCua5C8mkLXNZRShehQYTiPi3vVSIOY09XhfDoNaK3YbNZA5vZ2C6rQtS0VWUPa1nM6nbDWoY2DWohTIeeEro7P3ux49+EdOUac8SgP63XmzcOOm5sV61UnGUze4G3lxz/6Cd9+8w19+8Dz/sgXX77l6fGJp8cDMUz85KdfEmYpQGPMzPO4OCQNh+OZ56dnYsr8vb/3J1dn+Waz5XQ6Uys0bcdnn3/OvOC5nHUYY1F65k//9E8l2+0omVS3t3eklNgfDhgjSKgf3I9iWpIGspHvO8m6X6s01jFGfNNw7x8w1tJ3a968/QxU5enpia5rWa/XV0xX0zScz0eMMazXLajKb37zG5RCGpI4YYxkVV2aVqVgd7PDaHGmX4xQlwwtpST7rV+9RivDfn9YHOQjq36zNBeaGDNdtyZnJMbDWbquJ6aEMZ7Gi/50nQIUq37FMAzXJvzT4yPb7Y66kFoeHh7QxvDx4ydubu7QWnM6DZRc2G5vSSnTNI6K4LPatrsacC7oQWsFlxVCICehFA3TiG8bVps1tVbevn0LLE5Z58gpXQt0Y821iL4g0TSVxhm0EjJLjpF5GmQi4+6eECdSCnRdjzGSuRViuDpUr4W5FWNZzuXagKeU6Lru2ggLTUhMTN1qdW3qSs4M07QY8yrW6KXJLIQ5AFJ3K6149erVtSELYbq67NfrNaXIWoqDEAIxnpeNDrugtGSSIEaJoxjOghO7NCgxRlarlTRaS5MOoK0j5oz1jm6pCaY5sHFyTeWcxZFuW0KYCXOi71acTme+//5bbu92VDRG2yX37JLNVwXhl3vBXi11XNO05JRoWzFToRJW2aV2EpOVXoxDcQ7Xdc35BmqhaVouTdFf/tVf8S//p3/FerPlpz/9EV9++Tk3Nzs+fvjIYf/M+Swu+Ndv3wi6LGdOpyMVadhijIQQ2O/3so4uGxXOSQPeti0Kff2erxsvRgylMUruWggyJWSMwrmG02FEqQlnPaoaSq4MY+B4HGgaw5uHO6xRpJJpWtn8OA8D0xzE2LY48L0XZ/00TTSNxTcSPVOLGCdjCiilcc6AqlcE2ziOyzUSr278S/MqBsdCzpWSBcfWto2g7kpBafns5XrOaCNmPW0EnYjRtMu6N4WZXIpMMSybRHlxfFPFJCjGZqmXrL1QqaRpvzTk17XLWspyrdZarxFO1VQxmtWyGP0a2UyLYta9fG+X93iZHNHLhItVGqUX02atFCW4NqUU1kl0zQXdKddJWdCm6rqxcHHFK6V+2NSRt/m3PhR/0fAXDX/R8BcNf9HwFw1/0fC/mxr+ot8v+v2i3y/6/aLfL/r9ot9/2Pr9ex+My7NnGrfF9B1ZZSoejEKZitGOdXdLXBtSTpik0K3BNS3kiNGFPES6zY6SJobnd/TdG/RKkUJE9xDmQL+7JduB4XzmHEZKEgZ+KZqmNVjX4rSipspufYtSlZoVyhoygVBmbNNSkYMb3zTEabnhS6GkSFWZWBLkGes0pShcrzF+Rd+vCGlkyhV1rBRbcOaWvGTR+nZN6w0FxRwjJSWmmHB+TalycAiB0/hEyRu6zVoO9xqDsd2C4M1UKnPKxCmA9iRbaXTLHPaUrEjHM0NJnOeCsVvuX2+viycVuqalAOM0YN2KHJOcLSLT9blW5taSs6BlUlzyAgx0fcvNdkPXes5T5DxGckzEKVFjpRRFSIKd1lqTYgFVME4LRtwo5ih4mTJFfKPQGErKaBXRVmPqgnGnygFf0zKPE/vjyB9/+ZbgzkwpEc4z43Gg3+7wvWT7HoeRlCO5TKiSWHcdplkxz2nBaChMLjiv6KzjZBusUzgtmdspLyj1xjKHIDnZS1Ea5pl5GolRUDneN1iruH/1GqUNOc3UVJjTRN1IMbvqV6QUUdqSsrhlXt0+YLRhDhHvNMYqtJOChwp909O0LZlMTAmrZfo7lYTVjrRMAs8hLlh9hUVL1rQSdLMsSpBKAV2xRlGVAWXAGlKe6VwnRbRbro0M67UGXTGuxfuJoRRM21NLpColectVxLS4SsqRVCCHGasVq92aw+nE9HxgiDOt84zzjGo8Smtc63HaEFWiKIcqmZtNj0ownAu5FIwzfHr+hmwVhozVhbvbNaUszrkYUWQ6L89pO41rFeuuZbXZ0jSG7bplvVrRtR1d79jdrPG+Zb25Yb3Zsuk3dMbRtGvapsUoi9HLJLbSGONJ43RFKDVuxZwLJSesMqSUGcYT4/lAOiV+8Vf/huOnA269od1a9BRRGpl+VuAbS4mVXCDkROM1/+6vfs3+qaByYpoH4pyZ5pkpjPT9mpgScwgoa2i7FWkO6BIZw4BSUjRaV5n/8QgtpBj45a/+JbkmnHU0VmO04PyVsYzTTMqVgubX33isQgwGWVGrIpRCTYmucTw+7sVw0YA1iq4VlFGIhf04U7Nh0/S8e35PpNI/fUSrS7a4RtXM8y+f6boeryvjcABV0aZlDAntPNM4sVutiGFCWY02PaUmappYdVu08ZQ8c5rP+K7FGw8xE1Pg6Xzifr3GagXakFMFXVEpoVRBN4ZhGtHaorRjGmaqAuUUjbGYyoLOCsy5kqvBOc+q9egKSjvGcaDkSMoZ27QYoykxYBtDVgqjHaTKNI3MUSa+a5Z4j836gaSWa2Uc0UZTlMb6VlD2IvdoCjWDdz3USKyZHM4UFNV4yba3BkpGO0sOEV8zVQfa738jjjjgPM7o3xhe7TpUVuQMrWtIceY4zkwp88//h//N7y3Zv/NQgKqkFPHeEpc8mqbxlJKvhdh60y/4HjG6KeVRSvD7kl3jOBwO9H2DXaI1huHMaQh4b7F2yU/LlfNpoPGe9XrF999/w6pfsVp53qpbHh7e8M237/n4ac9nb+95dbdms2p4//4Tfb8ixcDN7Y7DYc9qteHjpyfOw8B3332HVlI43d7fYIxmmiMfPz7y6tX90ixpaqo8vHrgxz/6MdM04o1mdS+5W6kUlJJNifVasn2s9QznAe8zN7e3+KWp+v7776W5alvWqzXqUsQtzmrvG4ZhXByQavkc4enpiXEcWa/XfPz4kfv7e8n4msXV6pyXQk6D9y2r1Zqvv/6GcRz46quvlgmBEx8/fmC73fL4+MTd7T2N97iFfjLPM9p03KxuuOTryPsvhCjUgZjE7HXJtpvnCZTka82TNCEoybiqtRLCxBwmVv0KYzSr1UqKXO+u7utaC7lkPn16T9s2aG0ZTmcOhwObzZZakXwtYzBuQakhDcbr16+ZxlHMX8ZT+P+x9yc9kmZZmib2nDt9g4gONrjHlFlRlZmdABuNLqDIIkASBBcEyALBX0yCi15zwSXRXLAzKyIywgczU1UR+YY7cnGuiHl0VxPRmQUwAhQFHBHuZqoqIt+99wz3Oe/bmMdRbU/qV9mx0An06++vRane6+v9+M3HG1mswFn4SqHWdpOWss5hRLBevYiuRfQ1Sc4p4YfQpe4yoMXdNB+4qrGICC8vX/S5uXCTWwNuybgx5uuemiZKLgzDcPs7xhjmacI5JWn3FJUW/slrujbKzsvSpyOGrvISeoGYkcxNSmtdF83RqtLCrar/Ui75Js+m0wMJbx3LcmHfN51K6R5Szn6VtbLGIVdVIr4WEs7q53w8PjL16RXnw63hk3PuJYKS3c5rHhbE8Mtf/rJ7dSltvW0bKe0/KWgGco5daux8K55K1YkGES3AMupzpooamVwa+7bx+fMnvA8cjzPjOPPp0yeFJFtjWReen5/59//+f04DnNMJimkYcTaw7StizE2KTWXihHGa+PLyhXVZWdeNbdP84Zp/a2NIKfDzZUVlGQMhBKXaq0oFGlQF53xZiTExDAFj5OZJVmrBGLUaqp2ibq0SwqSqQVLZt8SWdoYwEgYHO32PWPZ9uzXkrg2h7RLJdWVZdnKBmDPOWbWo6euzNdi27Wtxei1WxWJtJ7oF9rgjjdtzFtvtigBr9XnrVEOhJag0tS4qSvnrZI/CoMYYWi7ElKB1+cK+129Uugi1FmoHNmkg3R5J12Mv7sWQU9Z97bz+fqvyfsNP9rmI4K1Tu6K+xwSdTDDGgP26zq97OHfFqNoqYiziFMbMvciOSeup63pXn0idTkmpdik5BRxrg/rTYvzr1rrH8HsMv8fwewy/x/B7DL/H8P9/ieH3+H2P3/f4fY/f9/h9j9/3+P1nHb//5IvxisovhzBTc6XkSNor+8UyHT3WFEyYCNMOainBuryRto2aCm4ecNYh8wM1XXj78Te41MiXRq0ea4t6KrsJN6ysb4VWEjFm9rXw+K5ijOvm9A4RaFRSTYhXn2AxqsefYmaaRl0IFESKeo3vFy7LDm5H7IyQ8D7g0IPWNdXMN0bf37IkRCz/8Z9+w/aHL/zVX/+Cx2+ebg+tNbDGE4LFSKVVg9AQKmT1YJfJUgoUKaS6UEuhFqHtkZJ2koBrBtMcsQhbbNjW2LYLl/PCp4uQ+bpYrkFiPkzUkrFmVMqi1i4foAui5MpcRlLeb5RUrZlqNAD/7NsPvDvOvH75kde3M+teqEUlQUqDYRxJacPCzW+httIv/g1YS8592heVimnlGsYM6qkt1FbJMWFHx54Tv/3d9zyNR6wUUo06zT6NbDGSmm6QPa6knPFhZBwC256JyxveOr45vmNbV3735RMSPAVHmAMPD0cOPvQJY9OlhRpbjFz2eJu2fn5WL3pr3Y360Wl924EFTSxt1Vl4Yyy731SWvRn10/YBaY1aG0/hicN0wHsHUgnGUlNR+X4i1IyMI14c1KaXyblgH2f8ELon81WaxlBzAREqlbhvOGOIKWOcUkRxjbrurOMwDkzjrIfy4MklM/iBw9AILfJ6uqj8UmkUhH3f8MNALUqnGjHEVDQhiju1Zk5xVWJNhJfTG34cGMaRMQQSKpmRUsQax9P0xH/x93/Lsi98992PnMrCdJjYtkTaI6PxjNPApRUep5F3TwOH2TLNI49PB/wjvH/8wIend3x89573Dx95nr9lfJoIMhL8pFPk1iKlQBuoTSfpY0wIsK4rpx9X/rB+opTK2+kraWZM4PX0ymiFtG8kES7rTgiNh+mBuGZO20JuiXeHI7lYju8+spfIadmoBUYvIEpmVtHnv2wr03Hi8HhkSSf+6ft/IO+RUvNX4CFnLsuGq8J+vtCcIdvEuqw8BMtedy7bwugaqSf1gE7Eu0BNQIWUMs1pou9E93ncV0KYGJzg+2cj0ti3Rq7Cup15OWW+/+ELx4eRdx9n2CqYCqVRC1ze3hjGmS/nC0JisgN127BjQKxlHAKO1i9/M6k2qrGqEkADIz2paVQ0UbYCpS44BzHt7PHEGAZMLZgSoVhygVY0+RjFsKZNA29FJ7aN4MWwbxlfhRgbWPXw9oMHGmI06drWnQrUXBl8oCCUktiWrNStD0yDV+kYb8h1Z1szNRZcDtjRgxS8GMq+MHj1SHfWdNuMV7Ce3CoVlVovGcpaIARiKWpZkSKmwvnthWJbVw5YYI8MfsIeAoHAtqwUY/HOc3h8oIlhHi3VZGoyuIPH2MZgDKk1LAISMVIJLpNz+lPD9X/iS/f809MjtifZ+x7xblCFhl6wGWOoRf89dFWKUivrEsmpYU1jWS5s28b79+8oeceIcJhHzpdz97kRaCoV56zhfD5xfDgwT6MqFlTh9fWV4C1DMAh6Bp4vG8uaKGUl5cTvf/+JfV9AhNPpxK9++VfkkqEDTTThfFqhwd/8m79BjMoTXSnta7w0Vm0TpnFmWTdyVjkzlVnKfPr0hW1d+OUvfsk4DPz46RPffPMNzjne3k68f/8e7wPbtuKM5TAd+Pj+Iz9++sQ4JKZ55u104nhUL6NhGNm7X33OmXGYcdYTBs+6rkyT5/HxiRQzKRXd9GjSOQwD67pp/GqFcZxIKfPhwwdiVzB5eDhijDDPkyZ/tbDvkVIy8zyzLFkT/ap+PIf5SMqRUgr/+I//wPOTStMZI0oOty5LVhIhBJ6m504rZ1KKqBJQoZTMul1UFSYm/vEf/oHD4chhPgJwOBwQUd8kLRIyIUw4Pyuhuu0YMYzjxDRPCrHljKCFZkyRWtutSAghcL5cmKaZ+XCg1qJKKmihdi0KrlJjYlT2TEQwtdz+Ts6p+zq5WwFcciLFhBi5eclZ52ilcjlfdJ3VyrZvhL5OrLGIGB6fVDHoKmcFsCzLjaj3PpCNrtNaFHGzxgKtk+Iai0vNDGG4EcJfSfzKODiNy6WwrgtiVCUlRn3OV8IXp1T0jRzu0KjRQ7KvK5Uf00JM+rNXWw3n/K0gaQ0Q/ojwz1ktOK4yYlcyN8XE6e2E8/qZ7tt+a9iIwL5vOOv45puPlFpYl51lPZNi5Lvvfq/KMweVP/Te3eTRrtMO+n50bSzLQukyej4M+MET90jJGRHNT3POlMuZz5+1KHdepcKmaeKbD9/wdnpjnmfajWYONHQioFTNJ0rWz+Pl5QsaaoW3twvTNKklx77fPoPrFAUIh8PEvkdeXi788OmV4zzTUPr5sqzsu8oQHg5HzcHbzhaTgpleKfBaM9Po+fjhkZwLe9xxRiUmp3Fk2xLWGJwxLHGnNkHLN/kJia2wrpLcgtDwzjJNE7UUivQVIahizhButcG2btSqz7a0CiI4q16BIQQulwtUnToapwnnVIHKBX+T+7sqHElTCxTvPcGpQlKtjYowhkEts0TjC4A1BkEQa8gFctbfb4TuKyY3uUQaGCv6vU3rDlAbm9YqpdW+18AgGO9vzZRqi05t6UeA6dMFuStMGRFq1rW9x4SxV/9BlRLUs1YbDdQuctXrgOu+KFe6vjVENLb955gWv8fwewy/x/B7DL/H8HsMv8fwv9QYfo/f9/h9j9/3+H2P3/f4fY/ff87x+0++GB/mke284sTjQlJ/VjdgxVBTU6qkCjZ4at1ZTp+5rC+0apjCgeQ8hcq+rhjTaM6T6o4PI/PzE7kJ4/BMGB+x9cJ8XHldEiU7Xl9feffhSGkqE+zFcJiODMMERqWqU0pqDg+UohcIKSVqaUiFZj3NGard2FelT8bRERgww4HmgJTY1hUXnmluJNo3tssL/83//f/B//IX/4rn97/EWlj2XYPEGinNMM4H1ssCEgHPMDzw/C6xv628vfxAigV/OLDukdkFnIWYN0pO1CK6IQbHIIW2R162xG/Wnf/2Dz/ghwd++XjgeZ51kUKX4nYY45hqUBrFGgzdm9fYvsDyjaSoXY5lz4laM09zYF9PpLgxHw7sZWHvvuGuX+4H67rEiXqzOzfqAbttGOtpYik14bxjjyvOBARouYIoXXU4TFjroFSmceLtdOLL6ysPDzPGeU7nMw9PR4ZgmCavE94pczqf8bLzJsIaK1/OFyXbDiNjGImmkpY3Rhf48O23jMNEFPWrJzdSD/AlR94dZ0K/IBMriHGaAPTJclqgUTC24d0ItehhXSq5qGSJdcIoDnF6OagSEo0mDe8MWMFYPUAaBmsd790zw2EkLyutQjOC1Io3llgzp+WCMQbbScCaG7VZcsrQ4BgmUtqZQ2AvKsUzjZN+xqXLacRELJF914tJPxcyltHpAaqX7ErtBQYK6nmeK4zTRIqRnIoSdrWiZ5xRgq9L3VzljUQ6mAEE7xiC4/X1R/wY+MUvv+HXzmIPnuHgCJPl+eM7Hg9HHqaR90/v+eU3v2YMB7wfMG7ANIezjlagFGGPG8u2UC6ZS3O8lEyOr6Rt5bJsvF02mqhPy7JcOJ3OiBPeXk68nd/woyfVqt4nQ6CVxJJVenxdV9xgyPvK8/jEMuzkuhO8RTD87ocfWc8/Mq6vLEkven3Qi9haKlIb1hsIFhb1hKI0gjGYnAjGUcUx2orUwjw4cm3kVpiOE802XN2ZvCVXOLjAPFXEGy6VHlz0xy7LhVYzUaBKYwgOg8G1DM7ih6HbKjRqzSpHIkJl43JZuvfUzseHA6YWnscjp2VRj/EcuzxLwnrIUa0AAkKzQq0RYz1xW4hV/TkQAYGMSgaVfSEXhWSCc+zbiun0rjMFpCe5IpjakFKZnWNZL1irpGWKEWuE85pUosd4bAhMVpBaEAo1NmqKBDNQc4OaFYwyBmlNPzPbyLliW1+nXlUynKtYm/FelSxEqp6fWchUTE2YVLHWEeNOMBbvDeLVx8kfH3h5e9GAappOi7eMs3ru5hzJTT/3cfR4I8zFcY4bThzu8T0PYcZjYTAMk4e9sFw2hadMJfczWkQTblMa1giSLbWeaK3Q0HganKFN//ziXMGoXX9X8MSYOJ8vlJQprTKOWsTte+ke6YWcErVCrkrSHg5DJ6Ij0Hh9PZFi0oJ3HhmGiW2LxD3jvOXjh6ebVBVYUqqsmyY8P3z/iaenRz68f8e2bXz+/IJzlm3biTFhjOGH7z8rQOMsz0/P/PDDD7x7945lWbhK5aTkeXp64uHxgZTSjRC+0tkiws9//nOWZVXLACAET0rq07MsF0Tgb//ubxl84J9+908qW5X0WT89PfP6+tYLTqFBp/ErD8cHnHeawHYfKyVmf2AcB0J44OnpHeOgvmN73Nj3nW+++YZ93xT8Qf3InLO8f/+el5cXrNWYYIxhHMdb88BayzhNeOduhPGV2AbBuUOnNA3OKXk8Dlo4lE6a//3f/72qavwEpANdf1f/K5pKfFlrWdZLJ+EVQroW6jlrAn4tTI1Ry4TX11cls8vMOE1s24qgRcDV2+xWEF4J0axr8e31hZQSD4+PTONISpV5nJimUYsv7zvRWm8yaldpt5S6Wk9Dpy9EYbO471qAo3JkrTXivnN6e8V7zzzPSh013dO//6ff8/LlCx8/fryRtALM04QPA877W8Nn27YbYX6dXqi1qjdcJ++VoLeUmjUX7T9zGidO51f9PMR0EteoB9+T7+R31IK0y6kty4J3jnGamKaJ4/GBGOOtIL/+U6tKyTmnVO6+bv2zslq49OLfOq8TKT2xrFWL8Ktlz83vrP95jKoSZK2l0XqOpL+v5Iw1hsvlTGv6+9dt4e30BZUZ2zuJ3F+btVRap7WHGwGsxZ5QykXXWkzQmybTNDNNM7lmvHOkPdJq7bKRjlIaSLffaCpveLlcKLlgjYHW2Dd9NtfiunVK/HQ6qa2KOOb5wOVyZrms6j326HuTqeiEiFEZunEcAOF0Xvn06QvrnqBBLmcOxbMsQkpa6JeS+fz5E+OoPmP26DgvC97Z/ro25mkk5x3nAq3BukVi3EH0jDB9z9Pg7e0NI5ZxDMR4tepRK6NgPLXoss61qgWOkQ5vCrZT6vrMK7UUnYToDSuMPnPb18+18SUofb3vO7V7i+WqXmzeayPOGIPruYy1Ft9fc0paJ4gRbNGpHkE61KnNptz30VIUIDbOacMkZ6Rps8/1M8A5qKXd6PbWVM6t5qrrRUT/t79PXce2nw+qnoVoQy43LdQpIE1tkEptqvaz65q/TqLUBrV2TzXrcN4ios26nCu51K9Bt5U/DsL/wt76PYbfY/g9ht9j+D2G32P4PYb/5cXwe/y+x+97/L7H73v8vsfve/z+847ff/LFuDEW64SS9GkLhm1bGIeJVsE6o1r11lHrSo6Vli+UKOwlYywU25C2kPfKw/tvMNVpYBqsSn9fNnIemab3SNrxfsTYQk47OVVEdH7RiEXw0Cw5FWgZK6IeDtXSWiLFFdsM+1aYxwDGU9KE8xvrJSOysu0VWydqKwR7gJpxtuCnkbz9QDz9hrfPG64FfvbtO07bF47mGRmMXpaKp2GIsbDGjXkeiTGxJ5VqGabAXlKnSQrSLEYcrSZibqwxUltlGgJfLgu/f7vw/fnC25YYDzP/9te/5ml6wNmKD4arnIEA0xh4//6JbVP/jcEHleqOieADzliM6XgHOmVfS4NamQ8T02DYlzeMsxAT67YR+6FGVd3/eRwRaRin5Iuxehl7PMysW8Q7gQytZULQw6Xk0hdpwzqVYrcilKpyLfty5tPbJ/CVYZop4rhsFdkqp7NOcy9LJlVIbQexYC3TFNTjfhx5fvegiYdxDMFgMTQDW820VIlbpBZHrY3n48g4HyidgKpAKQ3rAm4YEVH5BZHWA9eIsRZxhlKUMmsp461grKGJTnDXrAfZFjf2kiip4rIwu+4l7ryqKiyFzuKQYwRvKP1nHY6T+jxUSM2wmIQxFe8No3MYgbFa5hBwfsR4RzOJHHdqBhdGTGtIU7JoGgcO88jgDF++/w3btpJyoVahpoq6zUs/jCp7jHoolUotevjX2qitEHPmMM06QdzU35xaGccRWmHZL/z6b/+e/9l/9bc8vX/k8PCOj998y9N0ZJofCGHG21HhCQFpBkolp12J1bWwXV5Ze9KxXM6czgtvl43X05lxHDkvr7QWkdZoxVKkUboEkTThsi+0bDAmMg4VsQXvDWEQLJlkKg9ikJaZBoerjd0GtnjBoD4z2xoZ5xFrC6NxBHEkgSXvJMkUV2lY9bWJGeNULj94jx8Ce4wM1mPFsm0RZ/Qe+RgmQq285AU/j8RtY/AHRqPe31Uafh4pceMwFvrWBhpWAGsQ68i1UHIjVZUPMUYv6q2p5Lxih1GVOCgM1jD6gZaEeRqoQ2FbN1KsTHaCIjjrEanM00DcN1oGKxah6u82gkFlrkpRss90f6NWKylGpCkheLVyGIaAa0DzmijRWJeEO3ha27BGKCl1WRuH8wbbMsVU3s9PxCWSYsYUaMaA6XIyNWNa1rVuPKYZDI20rwr/GJCamZ1RYrFk0p44DBObdyDQckGyyk61lhmsxXqVoclpx0hmCkKtFusMrRWckieIJIYwKQ1aIxghp8oQAi8xYixMw4CthZojgsq6uCoEsWANewL2hJiGrR5xnpp3jsFTjaFl9aZx4kk5cRxHWoPBOlqzCI1mBiqoDP0/8+tyWfBeC4d5PpBzZZ6nnhAnTbSrxqJhGCg1UotoMmcdtWaW5YIRpQPVB6mqVL9zLMuOCEzThHdFPZsuCx8+PHK5XBCx5Nw4ny+sW+SbD08E7ylZ/967d8/kknh4mLHOqXdRTEoHYm4/2znLMKgn2zAMHA6zFh/WUmPk7XQCBG8946ggV86Zy+Vykzx6eXnhZz/7Gcfjkffvn8k58/DwwLqsvP/wHh8G9hiV9BwnBGGaJ5Zl4fsffuBXv/oV82Hm8emJ7777jvP5TIyRDx8+UHLm/fv3nE4nfvzxE7UKv/i5EvTn85nD4YEYEzkXTm9nVSrpBZwx+t4eHg60psWKs2r54L0+F2c1jofguUovDSEwDAdVdMF8pZY7JbmuKykVhmGi1UYqiXEcbx5BoImqsVZtLXqBmXOi1sKPP/7AOIzEpM2SbVOPpZ///OfkpB5kT09P5Jz58uULHz58YJ5mTfBFQazqai+85FYsLvFCipG319dbAQvQOv26bRvjCK0Ot1h1KxzgVuBeiyugF02GUiI5Jc7nN7Z1xQ8eEaf7qbabh9zpfGLfVpZlZRxVTu9wOKjf2+GgUmrB8/D4hDH2RrbmnFnXlXmeGQZtVl2lwKy1N5k0leO7aCE+Tfo+W+nvQYuKlLm9fqWki05+dCk2a+2t4WSMep+dz+dbo8Z0KbJroybG2C0xrlJT19dSbw0g7wPOefZtw1iL965LDCqhvG0brSrB66YRoKvmtNv7DSHcfm+ptX+/Yd8jl+WENZYff/iBUgu/+MUvsdaybRvHw5FSMm+nkzb90qpqN8Nw893SZk9jK1uHPY3aXey7Kv70YssYQ6mFbdkpubJt6tl1LbpTygxBqe19329Nq32PpKyed62q59Z5P+HsRqkaj4ch3Oj52nSd51zYtwgCMWW2bePl9UQYukJVPxPHcYZWCUG9wIxoU0AbeoWUImMwWKtw22E+ELzneLRclp3T6aK1RVaFFGu1QPVeveYOh4lWu0JWVtLcmtr3RCDnREpFZS433RPW2ltBfl2b1/UxjLBvO957lfsSJcRLLyRF/xPBe5VE6wpWVoRx8DjrGEJQgKzv41K1EajPyt08y8Zx/LpOrejkQKvItbko2rRLtd4gVNelM6+ycwC5JK6eftKEVDLOanwSOszXpxyuDVUtrLUIb7XcaqpSq9q0NK1bQs/FtLbXplBrqNURX+truSoa9Z//n/r6KkP3L7sZv8fwewy/x/B7DL/H8HsMv8fwv7wYfo/f9/h9j9/3+H2P3/f4fY/ff97x+0/3GC8gcqVXLMFPrOsLy3Lm8fEBxIE0amnkuGLFQsuUPVO2C600xucDMSf2t8rx6RmGpiRcM9D0Upq60zDUbAguUMoXqtj+YVxJLMtuTb/kVDphHA+IMcggDG7CIrSikgYLkeWcmMYJH46U+j2Hw0yhYsZ3NDJpiZgq2GFiHmcuxWCsJdUTR2cIYknrijt+5PGbJ758+kQrKgUQ807tRMZ2WSkNnLe4MNFQmflcG600UtrwIuwx0UrBJMsflhO/fVv44e2NRx/421/+Ne+eDpiyA5bmAi6YLmMORoTjGGj7ysFb3HTEdHGCMiodpcShTk4Dt8N79EEPWmd4/byzrBvrljDGEoxA1cvjMXicUymKJp3GMkrf5FJVZqZUDKZDC/33Oj0smzSspRNx102UCcNIbmC6b7Verm3UYkDUF8OFETvYLhOtsgziBOssgx+QpgHHVI+rkLPK9x/HERxU3yVsSqY14bSqDLEIjD7cLoCdg+APGDGdeCkgKkMvVIz3OO+oYsklYcUSWyWnqF7IQ2MMjocQyLWQ98joDKlG8OCywVkQ6ziOsx6oVOYqYIU1bjjvGPxATQUZPRaIe8Q6TcbWZSVMA4OfaKZRTSaEgZpgXb8QrMfagVqdTqXXTKvgXVCZnKa+RClvVNGDxRg9QKHhhxFjdHK/1AIVTRpS5XA48IdPP+CNPosq+jydM4iF/+q//rf8H/6P/2eF/cjYJGAsJJ0Az7JjSmHf33h7i1zWxOvbC6kHjNPlE6V0WZ26kWpmTY1UC4ei3uViFEZwzkBOVBr7vjD6keCEKobhOOKCJn/W+W4rYGnFUH1jMjBaQ6qNUAaQTM4bwaJghRNMhRw39tdPSAg8HB1rgpwF4wP7+oZzntb0AC+14IeJVAwWx5o2UimUrNImX84nBq+XwFf4IWf13zDGsa4bpUGiUupXiezWICUIw4gLlpZWPdQ7kWmt0HLBSmUaRvK2k0V4fJgQ3zCycRgfVD6lBH44rVx++EwsGeMt7989U1LCCiznCyEMiPG4wdKk01gpYWyjdJkUazSAOWeItVsVlKSAUsyqokACEwg01n1hcAFDREyhiYApSBWcUY93K0KKhVguLNvGNA34tuGap5WCbQpRjLZhrGBqn66uYIpKSyGGkiNgSDXTKEhpNDFILVRKv1wXXCsYZXcwxtGaMLqAuVpnECFbRDLGVnwY8UagRbwx2AbeWbIRkMLgPWIrZb/gjGMMAZFCKI0hzAxelSMKqiJx8Ael/lwhberTQvWIq7TaNEElc5gc1TRMUwWKkjPeh27/cKMn/id/jcNIQxOc8/mM97bTluZGEU/z2InIwuPjE5fLSkoR7x21OmpVgnUcRlpTwCrFjSEMvL6+4ZwhhCPD6EixEoJTUrdkhi5LhTwwHRLzFBBRT5qHhwPzPKrqhVOZrFoaOanlBVRas6jsmNMCet06warE977vOOdZlkVlv+aJ80kLlwaEEHoRf6DWyrYpOf7tt9/evIG++vk4Yto5n06kmBnHkdPrG59fvjBNE+/evaPUekv4Qgh8++23zIcDNOH19YWHh4ee9BZeX18QMYQwsPUC0FqVTwvGse+RYZgIfmAIQfekGGiGUlr//4JgukSdqiK0rsk0jJooS9U/b7XeEvGrDNMwDDcy13b5Im1udCk01A8qZ7XW2JaFH3/8gfPlRI6R1iqHh0eenp44HA5Y4/Eu0Gri6WlkmiZaa/z85z/vUwBLl3PT351SYhyHnowntk0Ln+Vy0T8bBsRa3r17xzxrQT+OIzlnTm+vmn94fU5XXyaloDec0zQ2Z5VOK6WCoOsuDDTVWwJU3qyZxvv37ymlqORTUyBQjBKxx+ORnDPTNDGME9Zpon8tNpxzSscbw7IsXwvTorT/tWi9Ur5Xin3f91tDQf9MZaFEyo0K3raVFBMpZ97e3mit8bOf/Uw/c+fISWOFiDAMKq1Ga2z9v+37TqvtNnXQF8ntNXivcV+9C/XvA0RrtSlzfd21UUvB9yLyVnj0NaQykPp+0v5VIi6liOlTEJfL+bberu/lxx9/5PnpWVV/9sQ4TlTKjYwHblJ1WhgPLJcL57PCct57gtd9XpsWbXun6FPfj9M03/bR8fAI7Sqfp4Xdtm/sKSEYlmXl7e2Vl5cXjscjSOsNjwSoLOQ0j7disBT97BpCKfp5Pj8/4f2ANXTZtIFa1QNt33YEwzQGnFOAcVtXtSrxVivdJuSUiSnihpFlWdQHTCzbHhmGQKnaDHI9j58nnS7ZVq09nEMnCGqldFJ9GCbOl0sH6qAD2rROnN8aQV6br9YZhmGklEKuumeu60HE3CZTVOKxUKUyTeNtTQyhn0PSB0Ban2xoFY/rz1S6t2O9PXP9XLXBEYL65rXUaE0ni65nuAvu1iS57iv7k0kKK1/Pha/5VONKyxfarSGhePHXf2+tMY4jUtXL0zkLaMPv2jAtRRXIrl+pFCTGmxxc+Smpztdi/Poe/6Vf9xh+j+H3GH6P4fcYfo/h9xj+lxfD7/H7Hr/v8fsev+/x+x6/7/H7zzt+/8kX4yKGFHfyVpinIz4EzOWFmBOl1X65qB4Qe0mUlonrRt4K3gG5IFkAg22RFle8n9l2XWhqx5CJ64VsC6YJPjRKW6hl0gsMHMYKrQnWe8QJxkKODdcc1gRyUpmDlgvNFqwXUk2sm9INwpnz8nus/Vd8+OZvOHz4GcvrP3D5/D3nmBnNB8zLd8R0ZrYD8zzy4cni54HkDT4oNRNzxDbDum5kKRhr2ONGjDvWjex7xoknA62oL3PeKmYUUin88LLx3etnXk6ZYi1jsPz6rz7y86dHHEqlEcA4B83oQSdfH/bz8YCVhhjBBd+nSK3ShA3EOErVy5Sr/EGtetjiDK1kXbTYPvko1JoxLWC9xQBGTA9cHppOWguGnCLOWuKeqK1ijVIkxhpEVDrhcJj6BH/ui1PAgDTPZcnUpodAyzqFG9uOdYVSC2MYcWZgdE4vwB00o1PstEoVg5hGigt7rMS8U5KlvS40EZxVf/cUE1TYi1I7PhhSqozTSCNRayf7XCYMDpFA8A6Lo4rKRjvn8cZAVYl6Gwb1WTZCrUVlKVB55hwjLUe2vBNrYfaTHlIZ9i1SBd5NT+rXXCLBe4w1nJeVz6+vlNZ4OBzw1rBFDSLDeMCaSto31n3j8d0Dgx1xbuDd9AhUcklkqk7i2oarjuX0O6zTAzDmTGsWBKZ5Zt8TjUbqSgGIYZoOlKqSHkYM+76QWmFZNz6/fCEETxXDAcHLgSKqCrEvi9oIAG/rAttKSYl1T6TUOJ03vv/8W3Jp+GFiTwvWGb3Mb3pmSCu42vTyVcDSMKJeFW3XS+g6CVQLPYda1zM0odlMLJZpmJG6U3NFml4otpYRhM0Vypqx1mFFEGkcjgdEGgZoMeK8wbjA/O49y77x8nam4vCj57KrVLixlhgLIahXkQuOMHh8E5wxjDRqyjhpNO9ptkHNxGXncHwEEq00ask4D+v6uZOlXz0wRKDIRrONmgVbE1YqTmAadG9vJeHHEayqeLydz7x998LytrJHw3+3/IGYIxXLZV15fpz49c9/xnSYiFkluJzAN++eyK2xbDtbyvjgEPF97/cE1HqgEtOKwzKaayLsSSVhg9eL233HDk2n871gDDhvEAZqqaS4kql4m9Q6woA3hlYq0zQwTpa5OZoJNDFY1xiCx7hKTJngBmiVGFfmIVBbpfUCCgxuGLmsZ8bBc5iO5NjY88Y0DrRSKSXiHKQCYoS4b0hrOkFvHdZUxnBk3d6g6gX84EaMA6k7wQhSdqQUSluxMpDTRnAWSiPmiLOC8QNbi7QMx2Hs1g2CNJUjklRosZJN7V7unuiOnJdXpocZqmM8WC6XSo47o/fsu9o+nC4vf3Jg/+9/5fKVdqUTu9ZB6qoA10TKeget8OXLG7UWxtHy/P6RH3/40inrRClaYJ1PJ2iFIQw8PT1grekJdeH56Qmh8enTCw8PB6xVX6vzZWE6jOr1tWzUqtT8w8OB+TBqot/pThH18so5EaNCbkptj8zzkctl4YcfPgONn/3sW8Zx5PX1lcvlR6ZpopSssk9ZE8zL5XJLvi6XlXVVgv1Xv/oVORcGPxDjTqmFeZ4Zh4GcFQAbhoGfffMtLnyV8Pr8+TPPz888PqrfVc6ZwQ+qoOAc7949czqdOJ/fOBwfaFnJ+asPltKXwrff/kwTx5gYp5khjJ2M1qLOdIL8+vdrK9DlhFSSqNAAMZbcCxqVDzO35PtKNF+TVpFOe5ZKyhloLMvKy8sr4zBhreF8VquP48Mj7z+816TZB2pteB+w1vP8rM/We9+LPt8bJO5GSV+L1nVd+e677zgcDiqTZgyPj498/PiRadRY6bzS+CnF3sjoqhVWvZ4UtuseWCkyzyMqUagEcC2Vkis5R8ZxZD4ebz5wNzK1FKWxm3oyzccjx4fHW1E6uvFrM6O/rqtEmnPqxUXr6VhVBQ9jzY3eXpblVsRdmx8pfYWfrv5vCi0K0zSrNFbtcOFgSfHE4ANhHG7rJed8I8avxcS2bUjjapFHa+oLZ6T1SQ/5Og1hTY9hUcncTpxfKeDKV58ma9Sy4krfl6T5ogFyUm+xUspNiuvqj3j9jI6HB2iQYsQ5z7qsgOHp8R1DGLlOGtSqHnIx7l2WMfWGRe1NtxHnHemccaV0WTTTbV8MT8cjMcZe+KAFqGgN4L1nXTfWbeN0emM+HBADjcqHD+9oTXh7e2OeR375y1+yriufPn0iBM88T6SYCEPgeDySUupTABU7H1j3vUNLjnkeCV5lzQSN79u6su47raFSgfK1OTKOI0MntnUdwvn0xjRPnN7U61HzgXor9E2XXqyt/dEEA6iqkTGCtdd1KmxbxNpGSoVaGutyUZnJaehr+2p9ohMqiHpAijHs2wa9eC8lKwTovf4Oo41U6wzeOGpRL0XvBvJP6PfSpT8RiDFh7ddiWWPI1zNJpwjMrfFzOMzY3d6KdBHRyYz+97dt4zr10ron209lFK+TL9d9cmsscPUklNvZCl///tXDsAm3Rl/qUqZ6zrY/ItJrreyxAvn2335agF8L+msz76fNgn/O1z2G32P4PYbfY/g9ht9j+D2G/+XF8Hv8vsfve/y+x+97/L7H73v8/vOO33/yxXij4lyAtiC18vLyyvn1hafHX1GaxSLEfaEkoSbBWZ37N67RQmA4PJNtQyRQh0yxDkdhnFUi2holmRyGdT8zWTDisAGO40zZN7zVw1fcyOwc0iyejB0dzgr7FvHB8/LyHfu58u79I2ZygFBkYWjqx/3thw+4MCq5U1ZKn3QVW1jOK+7YSDVxCAeKONw8Mjw90uJGjIl6gpqEXHay0U1gxNBKw3mL95ZSAjlmWi00hJQ8y3LiN384Yb3h8+mC88J/+Xe/4GGaoApD37y1FqVPqqGV0qc1VU5GHy5Mo8MYD9LwwdL6xa00oeaGOMNgRqR4pd2MUiMtN5otSrTljdd9oRZPberfK4hSia1iWu1E2I6xBh/Ui7u1Rm2NYVDJh5QSYnSRBu8ZhxHTUOlkF3DeUbJOQXrrwMKHd+94ePJse8FZUZKyVgY/0NCJbqlQEWLZMfbqK2BxJoBUKuq7QtNp8loqYMglqox5TFjxZJTWCX7UQCMOTKJhkGaVAHKqXqCy8wEo+KDyFM546H7lzZg+LZ+ViKv6j7UwDZ7dNkbvMLkyH2coUGojm0Jedr7/w2eqhVzUY7nUql7UGSSIXsjmircB5z3GRMRWgtVkVBpsywXvdhIWMZVxPPLu8QgtobbijTAEfEOndV3DVss4zWAMMnlojTCOiDVQE7HTnqU1moXH5wfIRfe8s8RaCRKwWFpdGbyDDL/9h//IDz9+pmARF5g8OCe8Ljuv5zPLemZbToRhQigIjlyFrSVItUvFVJo3IEr8OOeoDejUm8SKFJW5bk3hCAGKhZgSzVRkr6zrgnqDNCwQnGGLG8Yo4Wa7v4U1ILVqcmsMxji8t4TBU6PD5JH5YHg5L9Ske8UYiwCHeSLlhDMeZwOmNZxROXqPITlHy4XLlsnSGCchWE/eFYTY4lnVBrBd3j8BX30wWmsMgMRMMgYnVr2xpdKo0CzBepyoHH4ujXdPT6Ts1SPEJiZveB6foDaO8zd8+/Ej22XD4YmtgRXEV2wVLm8RjGM0VifFnWHPhWA9k4VGoaLwh5SCMY7RaYIQRD1QahZKhmV94+HgkCrEFLFOz4tty5xedpopxLDRjFEKuQnB6PuLS8GKI7hCazuXLTKMAdcMEvW90pJOzpeGsQ6aTvxv24p1R4J4wHBZIjntQOXcqcNSk0rsiyDN02o/J6XRKMQ9U/IJZyupJDCV1qT7t1eMWErpqh0mMZqMjB72qioZTmXElnUF52h+IEd9D1UaYh1b2ynbBqWx7AsPxwM5VXwQzAb7dqZ6QeoDbY9YKsZVaBlrCu8exj81XP8PA71zNwrYOUOrer5t500T4aqgwbbvuJ7weR9AAm8vC5fTwuBHtmWlFCGlzNPjIz4ELpeVQ7cR0ULKc1lWQrgqVKgsz6dPn3n5cmLbE/b9E3tUYvl8uXT6OzIMs3qsdfDoeNRi6HQ638jIL1+U/t62nctl7VJs5Uaff/r0CRF4enoiRk2m13VVL52gNKj3nqenX6oKQowsl5Vt3RgGjyA8PD7ireXt7cThON2Kj2VZ2LaF5bKyritT95o6n8+92FWvsHW5cDqdNHFslZR2Sqm3AuZKcjvnO2R1TdxASx+N9eM43gpsUEsbZ66JarqRmPq9qvwSY7mdJa3VTriHm+TZdTpBOjGak5LhwVe+/eZnTNPE5XK+FWzTNPWz1XE8PtCa+lCN49ApYE1y9T0YRDrN23/36+sbtWRqLYTg+PDhA8u64kPg+fmdfp/RBL42EGswTVNT7wJt/+oXtu9avDlrSXFnuVy4XC7EuBNCYJ5nQpiwVr3Xrs/+mvAbY27yddpYUH8vYw3qraV2MDklTqcT67rREHxQWcBlWTThr43L+cI4jipLxdei61ogXAvMK7F9fYYpJdb1+nkM7PvOtu1s23qjv0FJ7WEYeHt743Q6YfhKxDvnbs0PI2pjpFQ9pLRjehMkpcQ8H/X3O3srxDWnh2Eabz9jjzvLRffGtSi5vt7T6cThMOO9676HtT9TVTBaloUYVSYtpUKMG9saFQaiUnPTHNMYLfSoxLT332URGbhcLnz+/JlhGJi6dFwpCig+PT8hGErSz3OeDpRWSUkL9etnL70ZsW96rr29vXE+nwnjoIUm2rS4XC5d2tIzhEAt6vl2PB5vzZQY461hcW1uWefUOsVacvAMo9f1I8L5fCHnnr8PgYfQi9xewAPkUiit8Pr2SoqVWtWW5OHhAe89y7r15z512TbXqXh/W8dAj0uCc+q1Zq1lnEJ/3dosuU11mJ4/SKP1aSQtpG2n2BvbvkNreOMJ3uFao1FJqXI4zBymmatknhae16mGiliN502A9LVhtO+xD0w0ROrttV8L5hCC+uCtKqEYQiDuCSNq39IafQrC4DqQt2+RGKNO3/Sm5PV9/nRq5Cto+BNSvFRyTcSU2FPBiOCtZRoDiH5/aun2Pdd/aldhau3rz/v6d6476T/99Z9jUvz6dY/h9xh+j+H3GH6P4fcYfo/hf3kx/B6/7/H7Hr/v8fsev+/x+x6//7zj959+MV4KkHHB6+a2RS9tydRUuhevyhwM0wGRgaN3tA328katESkBbGOcJ4wZyC0zBEsuEQoqF42nri/kWnVK3DlKaZzeXvDHA8Z4Eo7nybO8RcLDA9lEUtzx4QADXL575bLA4CuDeQSrl0mHeeRyfuVx+jkVw3L+A3ucqalfiPqAkwNNGl4sxo+0UpF9IG6G7Bopq79CxWDMiKlJX78IFYcNjpKUKllqJFf49OUTv//ujU+vK8jI40PgX//1r3j3ODMFh2ngrMOGQJOs042dvNBF6vpEM7eFdjyofI1g9FLeZhqNnGuX0Wi3wztX1fQ3RqWwJQivF6V4UqlcTmeaFIZOhoyDetqu60reI602WsyUrJ4cuR8wrTWc8czTpLSJMZjb5aNepIOwrhvGDYR+wBUKpVSmMDOPjtZ9o1NMBKcy6KW2TocIoY5YK50c0U2SUuqwhuN4OEJrpBZx1tGqxchMKwoXYLtPQVdZMDjEZHRi2GOMwzphi6tOdwLGBJ1IrpCbkjLBW7AOVyvOekotGKfS7EYEaY2pahDRCy8NYLEkQnjm4lfmQ+ayL8RdfTUOw8Qed9xesGGkTcIYgj7/EjnMI2E0DM5wOUeMcXz48A2H+cC6b0r1GThOMxbDH/7w33HZLpRUCHagxDM+CM0KrRTO5wtXz6AQgno5OI+zjXVbqVRcU3JoHFRWSNAEwARLrpmyN46PE7/9/e94+vCRdY0sMeGtsNhGTBuYQEyRbTlhnSfVRtxWWtO1qQoRrSsOCFLpyRLk1nCi8vQlFiyaoFtjyXvsKgkjuWZq2qkecEq3ijRSjnrxWgVpYMVQi55X1jmVXLfgVOeeUmFPidPbmfb6SsMSW8a5oNSVOMRYhH5R35OrYARyAbViIZWCCQPOWT6dP7OXzPHwTIkZZw1rWqhVz7zGjqFgrHpJ/fQr9ASSqr9RfYESGPXaDtZRYmLPCylVajngg/DzX/yCuGdy2kkpk1NmdCOXk3rGeNuUaM2ZIXiWy0pOGXGClIozDUGwpSFbBlOxwUNTko1WqTkzhcC6rYzTgBHHl5eT+rcUS9rVR8d6Ty2wr+oHHoJnq4W9ajCUXGliqK1SSsNaQ6PT0yVTC6SY2beMVEPZVqgJ7xwNyOy6HpLQqqWEzOl0Qky3FJCGM5qY6z4uZIS1JJwt1NywWPJeyVTWbedSN0wruCDEdOFy3hjG2v1Z1KNlPk4IlbJWjvOR2DYwjiUVYszUUhhtYBpm0qaSSmHwVAzWWPw4sccVBkMygX1JWAzBC1/efuTghBwFYiblnX1X+nsMgRQz/9yvcQxcLmecdQQ/IVZIORG7z0+tjVO64Jzw+PDA4+OBUio5JSW3p8Djw8Tzuwculwu5NIZxVECoNWLcVWbHGNZlw1gtGmmw7X1aXoSH45FcCpfLSq2ZeT4wTQPPT08s64W4Z+IeqT3JvFxWjBGm6UjOUWNi3LE2YMTx/t175nm60YaxK2389V//Cmstnz59JufCh48fmTvBfiXnnXM8PT0yTSPzfKBm9QW7eju5ITBN843iNMZwfHRKS4rwzTffAHQ6WYnK89uJw+FACL5LiDXGcWKeZlwvio0xN6kvWsUYRwgD1h4ASFF9qLx3Suqn1IlUy9vpjcNhpnVJpmtCap1lCAMpZYZRCxrrHLUUpumAMVdSVD3IGo3Y19a1cLy+ttYq4ziyrhe815j97v17nFd1CPUOEvZ1ozXBWN2TpRRyTv1c1fN9GAaeHp8Q0eJjWRYuy/lWDKW4k2LmcDzeXsO1ELpKm13/21UC7UrCK8GtqjXe+06bW4UnRf2nEBBryaXgvAdjFBCDW1GeUmJZF5zryjY0Sm1aBDmVGrPWYkRpXSOGKo2Hx8ebNF2KEXqzpXQ5MWvVoqV0dZ5l2W75e9yV4qbBuiw9b1KvJoZA8NoQuVxUUmwYBioG+nkJTc9khJwS2771sz111Zem3n6lkkokF3DN40JQur2pHNm1gKr0popATonWqeN939n3jW3b9IxugW3biDFSu3egFvQR7z0iQoyZEEas0YZUaw3Zd8wtRgvWDsyzReTabNG1OM8z8zyTknroXS4XUk4cDgcEQUyFpipJpu/5a5F0lX4rOWvBPQTCOPHkFYi9Tuu0prngPM2EYSDuO3vsv+MnBdl1PX5t4mizIif1nfPBMY4aC7c9sm6RuGecU0uh1irbZWXft1sjbNt2QvAYY5hmleHTBmT+yTREwhi1GQveU52eB7U3To0x7EllHEuD1goiCqsZ0ZwhDB5A5TO94zjPmp+IIQSngCuNZdE4WmvW2DB4WlWIdpxGaN3KqDe0Si20BnuMOKewmMYJ9SZr7Sud7p3VPKTkTts3rupR+tzAGt3D5eo1R2PdVRKw0mil+6gZw7pp86qWiohBevF+9XwDlWnUZli90evX6ZBStSlgjDAMqohlRJWubM9F8x8V9NoczUXtlWpTvz8Rc2vC/fe//r8V4f/SBvs9ht9jONxj+D2G32P4PYbfY/hfWgy/x+97/IZ7/L7H73v8vsfve/z+c47ff/LFuMWoTEuXI3CDkkvGVnI848OIwSMseD/TRCg54EbDuvzI+fWV+fiMcQ6x+uY0aChtkPYuGTxM6u8Rd2gZ3t4450p98Bzcr6hZJ3vNw8CaCz/8eOHDz0YswvHwjrf6Suxzjud1xc+zBqCskgaIISUQpwG+ZXRa1zta3BmdRfJGa5VoBLznvF5Yzq+YgyXajBkmWtKH2KhY0yh1wTpH2RolCS/nnd9/euWHtxOvpwsSGo8fR3758YH3w5GHeWIYB5pzlCZILjiJGO8xg/q7SINga5+OvC5oXUzH6ZHWKoWkk84tqPd2Xcl5gyLQHBICxqk0incwWk9kobXUL/qk+6Rn9hiZhxGaINYSuyRKy43artQVN7JOKSellZy1t4MnDCMPnWorteLDQGsqHSM0vLO0ApMfwTqaqHSCHVW2vLXKlhK2v99aDcYIznYndav0Y3BKFgpQW8U1i3NGJ5ObyjtowqKB1lmVYDYEPciqyssbo9IOfhqx1tJEDy9jDI3KnqPCdMmA8QSrPvcAKResGKz3pNR9QGjMo6W2xOA9E5ktNR6OHxkHgWJ6MlapLVNrVolrAedHTqeVD+8/Mo0j+7YigJcAkln3BcEyeMvkZ6x/4ryc2Te9gPybv/s7/um3v+WH3/0GY+m+8JW8J0rdqSLEVJjHmdrJN+8UvDBBg/rDYVKlA9OTPhvIFcIcaE0vqZFCk8qnL58xRn1u9lIpzuL80KXgNaic4o7UghODN4L1jtYvk21VOXNq0WlehJgypTXEqgeQEaFkodDXRKeYmrf62VurUkSdmhycR1ohp4bzI60ZSknqlVE0qNQmbLH09SyUosmzyTOXbWVbVmrztP5CvTXUqgl4aRUxQu4XujEV7KhT3KlUvdh3+j5TjDcJnNwS8xhwwPm8EEuDIORaegDQr32LNAN7ahgstexYKwyDp0jDiJK5uaj/dIwJ7yfSRWWMYsnstbLXyuVyZvCeuO0MvkDTy+J9iTgbGEdHrJtCIgb1mk8VK0pw1j3iXMCK6TJYcDiAwbItkVw2TQKdJaVGSqo80VKkGZ2IN9IYwshYLBhDaxaDoURNbpQvKIhXb/CSC84HGgnnDDX1XW4cMVVcT/72nNmyQVolls/UbMFsPBzek2qiZp30xggV/aeJIC7ohX1T76iKBuBSKyk3ln3j2Y2IscTN4rwwhEBMhdPrpr972Si5MUyBdV3YYyaXivWWuO98d/mDrm8reGc4Tk/s+YR0OnkqA5dPiT1t+LbzevmecZzY18wlfyF4SyoraauIqVx21+G0f95XjJo0XROo48OBy/KG806fcy8iNGFWuGkcHO5g2ffI09MjQwice5IsopYapSSGwXcSXBPBzeydoFR5oPN5xVrD89MTw6ByasYYvB9xzrLvO6fTWydC4en5ASOG0/nU6eKCcwMPD08Y4/j5z37R6fTU5a8yT0+PbNvKtq08PDzx+PjE58+fbnHKdfmk0+mV4/HA8/N7Pn/+zOWyUErB+6Dwjb0WFolhqBwPRy14WlN1CKeebYfD4UZiqkdU43R6wxqrXkQ4nt49c5XRSjkjxtyIcbjS5K2/l/hHkkUihtYc58uZUlQqr2GwRljXRdUWumyYtZZSK3HPpJwIISjMtkXGaaTWjDEqA3aly19fXgFuhdS18Lj6dul68Fjb5dhK47xfEBYtNHMvhI25eU/tUUGQcRxJOVF6ManvVZVnxBiG4PHOUzpd6odwrYVvtOm1ILrS1Vda/erJ1poCaOrJpJTrleTOWd8DteGcx472J3+mUk2aaGdevnxRj7JS+PjNx15sKYHsnLs1UlKKtJL5p9//lreXl/6evk4fjNPEw+MTIYx458mlUYr0Z6qf6zAMeOeIe2TfNt074tniTs6Fx0cllveUucq2XacZvPc0RIuzkti2jU+XRRWC0AJ7GNQPbl3ObNvCZdn4f//DP/IP//CP/O/+t/8b/t2/+3d440g5ajOlNz60+ZF4eXnRtTYMxO45p0WN5/17bRgZI8zzEVj47e/+keVy4cOHD4jRqQ9jVPbtmgvmnG85/jzPLOuFq6WP6TBUre0mMfj8/MwwDLy8vBC8J/hAKhonlmXh6h9X+9rIOd+K5ev6SDEqoe8cPly9xvY/akA9PDwCjXT1yvpJI6jWepPii1Hp6HEcbzJzIKS0c5hnzucLe9RiUbPbyh4zbW96Hvam3DgOLMuCIN1DLOt+jBtZ5Ea8O2duTZzr3o5bJpd2mwLQaQhDzlrEt95IMAjeKcBXad1OpjI/zBgxXC4LrUnPeZpKz9WGd57QdC+LoFZKxvVGY6N130Af9Kyo7WusqFV/R04FlVa7Fr7m9qxKLaSsMOzV00ybqxGh+xTuO6F6jRmlkkv9owYJ1/9fCkZU4lLlIxVMRRqty61ZZ277cwgjfgh/RJnD1V+wQRNqa5RWKUl9z64TAldJ0lK1INcfCsYKtf3nnQb/U77uMfwew+8x/B7D7zH8HsPvMfwvL4bf4/c9ft/j9z1+3+P3PX7f4/efd/z+nyCl3shFQAzGe2oWxHpK22lrZhgeAMvgJ2oTjG04BG8nhnjkXE8sa2Y6vsNanQY01mCwmOYZjkeW5Y3BWcQEtvVVN8S6Y0wh7gM+nml41rSyxyOHx5G2JVISyIbz/iPFgxseOEyZRiWnSG0OGIklUiSRqiOtO2LApkqpolPB3lPyCjVyyQm7Oba18rLsSDYYsRg3EHPj9HriMAQqlT1GpfOWyvefF95i5j/++HvWuDINI++fB3754T0///Yj4zQizqokdSvgwBlLM049tE2X9+0XtiofjW6Inz6PjqtZ40DaV18YKpNTmXXj1MM614KRSs2VikF843w5kXNDjMG5hnHhtuFijpSsC7zUyrZuQMN5nSZH5CblYa1lNIbaPYl1Yzdiivgh4GzAOg0oKau8RUOnf5+fnmmmgtMgSVFfi1Ia0kkXMRD3jDUeZ/TQwghC9zJo+jqlVpxTb2NjHNIMzQvOWEyXl2kVUtr6Z5KBHdBJX5qCH7VkxsOk39+gYRmD0+fiQIyjNg0i1llEYFsXXEocHh8xTkkWI5B3YfAjLhjM6Yx3DpEM4vFeMFKoxWHE41xAVDOb98esB58ifirTnJTCnP0jtansvLeNnBxWHD9++Q0tCWb/ls9/+ERNwjSPhNljcIRDYBRh3TbWVX0j9hTZ9p3aZT1qA+88rameztPTM+/fvfH77z/z/O5ZD7KayTX1QzVTik7wUyvNQaz6/GpTe4FcG0Z0ul68wzqLM4ZU9P3kmKBWPHq2phjJNeHtjJJ4mXEaVa1AhEZhXxa2mJifn7q0TcWASrwUEG9J20JDVIrbqkxNLrUDGoaKoeQETcipkirEbSW9vWKspZWMWIfzlm3RImOaZprXiW1jLed1h1QIVhiMqJRJUWJ2sI1YMy2rp3kzBScBY4RWdqw0KJWy71hRyW7d1+3m0ZNS1otcQaf2YyGVpPL4teKd04v+rFPatEpKkVwzKVd8V35IqSLGsUZNSE1S6SYjCbwQJkepVxAhgRGsD+yp4oyDaljWCz4E9lh5fV0YBrUzSLnig8d6AbFqOdDQRKFUxMA0WWoq6mFuoFWhJKXIYqtIq2CELAVTum+OVMSpwkVcc4c0LK2DHbU1sFDpJHQWnHUYq5+NaVYDZ1WJ/toMtahM1LIlvSivlVIyMSdqg8FNfe1WzuedPWZKAucK0rSIGccD3k7kYtnWwrZfuMroWIFSMrXT3857TUaqEOsZJ0KLG9bCdl5p1dFsouaIM07l8XOkVthXwTiDwRD3i0oN9TXyz/k6XS48HI7sMRJTpFIxfaLe9SQmBIeIFsnUxuPjM+u2cDqdEfEdMLlKR1lqKRznGWsF4wJvb2/UWhmGCfoZKEa9eaw0PXvFME0D1jpNqJoWpNlpwnc8HnpCn/n48QOPj4/88MP3LMuKNYbDfCClRoyJ4/HI4TjdCq4hqOzVEAKvLy/qSxYGlnW9FRzzPKqaBFoAfv/99xyPBx4fHzDo52GtBWN5e3tj2xYeHh6+Fi/ZMoag8Qohxp1Gw1nHxw8a369UNXDztrpS0cMw3H5HrUqCas6pXlXjON7I8svlwlUaLiaVLhI0IVWPIwXbroV+o2GrgYae77vKnMFX6bZ937l6d12T5muxrs9uvBWvpUtbXYsRY8xNVq7WwjAcuFwubNuC95aH4+GW9Io0qjV8+PDhVuzHrL/DO23eeG8Zx+mWMF8/l/P5zL7vPD093c7E6/PSoPxVYiklBcty97+LMXI4HG7fF+NG2xuvr68/IVeDkuOoSsnDwwOP06QEfSeanfPsKPmK0Xj7ejnx29/8hvXymTDoGjOd5B184P3HX/D+4zd8+PAt1qlaTq30YrAyDiO1FN7e3rQxZeHLy6fb5/P5yw/MhwPDMDNNs77WIVCrFmHGKIn/5fTKd9/9ASNKx0/HAz44rBFe3l75v/7f/i/89ne/4bJkTpcItfH3f/f31CzEmsFKbwYpVa9Nj6++WddGg/eenAtp328yhcaY3oAL/Pxnv2Db966oASllQhiYpqkX0IJIIHhPyYV9SxymI8Y0TqdzJ50zNuhzv0qopT4hQ5c/NM4SgmPfFMDEGLZlBWCapv66BDH2tgac8Z0w3kl9j67repP6YoR931m3VcnxabrJu/30711lDK/F5LFPVZRSbvKJD8eHDoJq80ZJfv08U0o3haXnp8fbOVBrucmyXT/z2lqftDB9f4XelMyUol5q9DxpGALTKAxjYN829R0rOhlxbe7JqGeEc46UIkN4wDlPTFlBNNEiHhH2/UroF2qlN4G0oXl9JrWfAdKJ7X3fuFL9zluc9SAQo0JjImpV1FpXqupSadoE9YDQ6nXSoCjgF7pEXm/CXdcccFuTgObKxtCuYi5N/5uzlmkI1FJVvWUMNIRcMqUX+ion16cRaqM2iPna4IXWtNm577GvAUsz2jxFj5//n3zdY/g9ht9j+D2G32P4PYbfY/hfXgy/x+97/L7H73v8vsfve/y+x+8/7/j9J1+Mp33DWY8EQy4Za/Vgz7JT8k6tEecHXAhsOdLahhVHyRFrZ6ajpQqEKZDTjh8DIVT1dtgvHP1HsIYSI+Mw8bK88fLlwmH+GU+PSv54a5BYaS1xeVsZH8E4WC4rnoyxEVM8NSfCMFBS1AlGoxOxwUMslpYz43CkEZHScM6SloRYRyFinPqkl3WF5kjBctlWvg0fMKaxX87E7YSrA1urrKmwp50fTyde31YOzw/8619/w/t5ZgwO0zzj+BETDEhFWkKcEiVWLDRDCyCmARVqQ0QlKQ6Tx3i5yYADSmYUJYOMOIwJ2Ekvy61YrB1UaqQWrFMaozXB1Ia3Xv2dqexb4nK6qGSz1wUeY+rTtDs1F1LM5KZe3hadvty3nRA0+Wm19sDYpdutxRrLNE4M86gXe1alPRp6CW2bTmQfjw9kIqXqJTG2QcvEBE4c4xBIOTINE62CMY1WMxX1n9+SygUJFecNYVTCRvDUagCLtUKriVoN3nlcswiW0CwlJcTqJXzOeiGpEieZ2vQinyZs604YAsbBHjeOR/UL0QPFYo1XmeMC0zRiQ+B0PtFqp872TPAW7/WSWHLDGoilYELAuIFUwdtGSTs17zjrqClDE7xxNFFv8z2pxIUTQ14Ty/6JPSWQxlZW/uMffsOX0yuXXFm2iG3qN5NzJYmwxUzMhVo3fPDM00Dt5FiwrtN2hpQaUuC/+De/4ve/+z0tZ1yrfPvuyLqv7NuiyWJVTxOpYKtFrINakVqoNMR6bNK9VaURS4JmqbnSWiFuKnFSUSrKWUMTSyn5J/RYQ8RRWqZJU+imJSRFjDhiSpSo0+TOqh+8AXDCHnf8YMCorLdgEWOUXGoqr349rIchcHh6UgnwlPl8WhGXmYaJnFQmu7WG0Ah+YBgCRRqTd1hp5LhRmkrs0DKmFSiqILCtC9ZNWGD0cDiMtLpx2XbE/fEx3Exl8BbnLXssNDE462lV12POGW+NnhU0WuvJoxUS4MTSWsNlaFa9hhA9b6RqAeGMwVvLniO1NIoY8qYwjlBpAg2FG6TV7p/jGU2lFk+jIcZhyUo8m26xUNT+wllHSZnDNDIMwlarPldpNAFBzyUzWIIoUBCCp0ojVQVEXC+eVF3o69S3MZZgBGOh+Q2plpIC4irOjWwp0xCkdVmmTsEa/cX9swD6uTGMkyoLFMOpnJBilFyrjYdHCDZgzUBrUDAYA5MbCE7IUpWga0JG1SOmYWDbN3LL1NJoxdDcBrujScKMAlWIZSWYEW9V8shIw1uLqYJpsMcdkaBn+k88r/55X0LMmoy5vqeU3jP9M849MVPLjCKJZRkx4qhNIZJxDBwPT2ybevAYKzir4MayXGhdTkup9cYQFBzyzvHNx/d6ZjYhxUzKSmevy4XD4T0fPrxnXTe2LfYkzjNPR1ozPD29J4SF1tRWIKVCKYnT+Y1x9D3RCzw8PuCMZds2Ss6Mw8i27czjRC5F5bKsYEzh7e1EKYXj8cjxcODh+ICgBZTajxT2XdUBYoy35NOgBc08zzci85oEj8NALRX1EvvqY3ZNLOdZ5cOuRWitFeOEUhLbtmuTAgE0trSmSeYQRs3EW7dK6URtKdzirjEa32jxJr0WgmfbCi8vL9RamaaJlBLjON5ozNbarVjf953n53dfCVG4UaXWWhoqJbXvO8YYtm3l6iP2+vp6S55/SpVv26YE9DQyWPV6EqM08/VnhxBuFLFz7tZkOJ/PfyStFXctpM2VXLWuNwwitD9O4jWp3vny5Ys2kazFOYsfAtM04f+oEHXscb81Hq6/DyphcCByI67//b//XwNdPgy6Uk6g5kIztSfsur9ojRT325m91fX22Y3jqDTtMOGdu31W8zyDMaQUb88M6AV5gwbeD/zql3/NMIw9XnRJPeB4fOA//If/k8ZJgYqumw/vnxlmA0bVeq7Ef2tarIIWuFdC+tqcoOsKXT/Tn04SuBAYRIj7Tu2Ue2vw+fMnle97eupFZdSzIQ3Umon70td/l7e7LDern1LUay/ngjWG3FTCq7VG6AVZRdfXuq7s28Yw6HRE66+ltcZ5O5FzUXnA0uXpOtl+XVsxadGlz6KxbRs5a1F7bVw553pzTvO+EAIxRj5//nzznfvw4QPPz8+Ukm709nWPXj3qrkX9lX7+eobo+sk5sq4bzvn+XGsn+DUvEVH1nBo8YsD3KYjBOwwDOat0oXrZ6bkUozYNrHW380ZEpQhT9/CzRkgxIYha2hiH7WdWrSprdj3n6Oejxg49i8dxYBwd10moddspVeONIJTba9A9cV0/2hBw5FxuDbmUEnHb8eHajNAJmuueNMZ+neLw/gaoGmNw3pO7tKCINvzwtlv2XL3vhNzl2BCDtQpEX6cYlKavPR/8SeTsz03/mzYu/sfq8uv5c33e16//PGT7PYbfY/g9ht9j+D2G32P4PYb/5cXwe/y+x+97/L7H73v8vsfve/z+c47ff7qUutOLirQnvLeU6qnWQjXs2xcO6VtcOCAmqgxA+0iur6S8YLxjsMKeHcZ53UjGqQy1VVmSnDMYQ4w7WRIpX9jXyvvnv+L5W6Faz5oip0/fI3tiSxYXDngbcK4yjxYfHrksG04ysVqkJUoxDGFmPDgs4N0j1Sy0nDHWU71e1jVjWZaV5fLK4+MDUiqbWL758IH/8L9/h2yZKoa8Zk6vC/uWyLHx3duZP3x6wQ+Wf/PrX/Nf/t1Hjt6S84qMlorDEXDSDeRNQ8yAaYZcIkbPfGoCSQZxFjGVYdTDwxq9WBZr/+hexIropbo+cawdEKcbtzW9fGqtQV8cIhYBaqmsu3oQO+c5THowYFSxP/mgCULzunDFEq36veeSWbZVg6C1xEvGWWHshNI4jgiahGFQuRAxqHeDKgRYYwneUXNhX1fW8kKumfnwRN4rNMM4HlCJc/Au4J3SjUKjtQJiVco6F/33PlVfVVhHZWeqEipII5iJVq3SM1Zl0/UC32O9UUkQVMJdN5zFh8Dlcrq91rQncquME2yrSrpYZzDWscUzwVnifkZaxFiHD4H5wXN6/YSzE8Y1rAukvWFaoibDNBwpVErWoNWGJ0yXtWhd/iSXRioRgyGnnQaEMLHvCWfh+DAzlMzz+yOvX974/vefOb+9kvaE4Al+IhaVwD+dLreAUGqjpIh4i3UBZx3jOCAI0zTy/HygbpVxMvyv/hf/NT9+PvHXf/Vzvnk8YIZ3/D//X//Ivhcqhj3tGCxHY2hkhAYl00QJtlSLqiHsFeMMe46kWpBcoWny0FrBeT1jcsoqQYJoElcrVKEZnbz2xvDNh3eUZojV0EplnAdME5UHSpnp+Ew18Onl0r2mBeOdKg0YQ2sZK+AszNNIQ6hOWE+VmhoPh2fC4R1bTlzeLtRSWLdFpZRa4+gs1lSCgcPgutJCpaSMoEHCNNt9tzdazVyWM7uxPMwHgjVY2ziMFmP910MdeBhGpCSygYIGkZIKlsbkG84YcsrY4NDoUKkNpFhsgipN7QmM+pS0rIE1GLUkMFUnua0FSVVtLJx6+AgZ4xXEqCYRXOuX0uF2aW6kyysNA3uSWwCXWnFeyUoBXBiw3vRkR/DBsa6XTuYVYsp462kiTFZBFWsssSo0kWK33FBPAEqrqPhDQxmiwnHyXM47JasawXlbCGHSRKxVKE0v+qtK4eeaOBweSC3qZyEwTQHrGue3M85l3GAZw0jcdh6f9exYzztNdO3aGQ4OnBFagb1P7NvB0nIh1oUQPK42fL/Qfn4Qzl8KO5lWHSTD6AIUKPVMlYyYQNxVemuLCfFaEI6zJ8WI+H++lPphnFQ5xFq88yzLeis+vHddCslzOV+w1jGMnhgTcU8c5gdSjliryVNtjT1u6hkUJmgVZ4UQpp4AVqwRDvNAA3JPyktu7FsixozYxjyP/PJXv+iyRJZl2Qh+uFGe5/MF0GJhnmbEGGjSicPGOA28e/fMtm3dH6mq75d1zLPSp34YGHzgdDp12SAw0jgeD4gYDvOsoIj33S5gIedIrkWfYS8St227kZveOoZx5N27Z/XMQqlnZx3jNHElyNd1xXvfCXRzSzR/KklmrXA+62t7OD7hrGfftdDU3+8xnWjXBDWi0mqBlCIiWigLsK8bp8uZYQwYEV5eX/j06TPO+hslX0rhhx9+wDlPa3BZLjinainv3r27FSetNRBu76PUAlTKVG/UqOnnyTgFcols26qxtT/Pa5HsnEIyTYBmyJ3gVZmyK/xSUC+whHPhj+TaWikg3MCkKuqj5K27vS9QGEq9sdKt2XA8Hnl4eODw8HBNlZSWDbovrpYUoJMFSmhn4r4j0mhFCMH3okXXQywRP01aJFhHCOppptJthVYrIpVWK3HbMMZqgdnfbwiBcaz9ubZOEydCGLVh4IPaayC3fK6UgmAopbGsO/OsjYUUE+uyUkvl4Xjkw4ePOO8otXJ+PZGSNkScNdQiWOvJeeN8PqOSV5a9N0Z0csXdJMu0aQfGGhzutv5vhXluSvuW0otZley7QmYpfZVZbIpZkXIkxdilD/X9XZYzrVWmcby9htaaKiAZtbjYz2eWZYHaGEY935XQVllKEcDAOE63Aii0qhKTfqD04q8UpcT3XYG+a+H90ybUlUaPMXK5XPj06ROvr698/Pjx1py4Uvvffvvt7XzQOKgNxeteu1Lv57PKMR4OB4L3tFo7xa/x1buAmW2HWL9KQ+pzqcyzTvBcG0fea6Gs+9Ddnpc2NJSGT0n3UqtQcutSjyt7zuSsQNc8jV3JSOPztQCOMZOz0u+pF8bXPS+tUuA22QLS90y+PZdcCimpPKERo1ZVgpLfzd4I/mtjKNfCliKtVEJVBZnrc7gqpeiaq90nT3P4nDPLsuJc4krft9YQo7WRNZbSFHKrQK6ZVmpvsKpCUUyJlCs5V2Ua0fzImK+5Ta1N84UuM1fqHxfZIvpPh+hpVfrP0r9nkH8Z13aP4fcYfo/h9xh+j+H3GH6P4X+RMfwev+/x+x6/7/H7Hr/v8fsev/+84/efLqU+TJS0gxTdBNUgMpL2L5y//MDj/Ff4adANlDcmsf0SYwRZyFtjHALNWNIeGZ1Hgl7uiggUcN6RG0gu2OB5ePQYV/HjR8J8pO5fEPk9KVeYBIonETmODmMqtQqmNfzjI3NyxLVhW8CZkcHppDpUjBmIbUUZCzDZEkwl1hPH4wPYkdoio/GIDQzOs5D49OOJz3HjdL5QW2U6TMzPM//2Fx95nA4cjpMuGGPw9YAVD1d6obZ+sVsxxtGofSKyUWtjDI7qGmA1GFCprehlMioh/PWpCs2qZLkxqrUvAtIaUoUSK9iESPcuNkJpqQeXxsyBmAvnyxkxGiRLzSCmy4o3xjAQiVB0s6s/REREpR2sMfgpcJhnRh+wCK5fLueUkHXFGAHbpYxrhWD7JepIjBs1Zby3PYioP4M1SpEY42hNGIdRvR+s7RvNIE1lYoxTaWz9M6Wyrhu4tUzowcAZ9TinNUorDMN0k6gwTS/HGkXlvq3DGE165vlAybHTJwKm6ET7rtRYq5FPP3zHtx+fsaYyPX4gxx1qRoJe1IldGAYlsIz3+ABpq5Q9Ke0X1I/bOiEvb6QU8X7A2oAh46TqNHUttzVTs0r3+/4zg9EJ68NuOb38AzmqfJIfR9q2QM3kpheL6jmkchvjODIEzzhOOGcxRjjMI1bAYhhmy7rufPPxG949vaOWQqqGo1geH44IGSmFgKdQyC3jmsXgiC3rRXHJWCvUUqBUmun4UCf5huAwkjH9EKwt4V3DG/Uyb6ZymB3SCqoAMNJqIudEq4XJDxynIxWlr3TKvpBKn4y2llzUo8U6p9QhRQ9PKmlbkTrQjKduZ87nz1gcS7XEZqiiE+ZjGMitIVY9asgFiRu1CZc9gxQaGY+ntEraCqICIjgreG85DjMlN/K+EWth6Mnetq03Oqq1xmlR8GKYHIaKs4EiBW/U6zw4YQVKc3gKo62sWyE1TX2s0bPBOZUPb05/uG6RilgNmiVFnFG5+tRWyLoGkihgIq3RssoHGSnUqoBG6h5BZU8aoJv6ghhxSBM9h1DaM0cwzREsOBGmMFGqEojzMFBSYW8FBjClMo36zFLJGEFJWTeQ0UBYqiaKOResN6RiSNkrPAQE47EG6q6e8yU3lTBvGTFC2xP7tgEFY6HkynKJHMagfJ1RgAJjqE1YU0VypVol1kJrCiSkTk3n2oEbQbLBG4M4wQK2NUzNVAPbxRCCY3RH9ryTfEJsIJiMQaGdPWaoQr1EgheigDGVtCntV64g1D/zy4phCI6471inNgbHxwdUxiur/5QIPqhU2fFx5uXllZx39Y+qhTK2vlcNCN2vKuCcJ5XKvqtKy9PTA7UKWyyc3xa8H/vZbjHOYkQIXtUqzucLIpZWNYk5HGasc7y+vHSPmUytBjGNx8cjKSVKEQ6HmRBUPm4Yxl5oNkqMnE7n3nDwLCyqBmIEFacX4rapbFrwpLiz7StTp1ZrpUtZaX5yuVyY5vkmM3VNtBta4OnraQwPWpBfCeBrYQpatF9JxmtRrgl+Y5qOPD44csnkLbPvG58+/8j5fGIcZz58+Mi6bnjnmOcZ5zzruvekP+G8UFKBCltc2b7fGMaxeyFZ5mmmlMK2Ke2dc0KkFzAobHEtoEH3XEzbV1pa4Hg44HxXW+m+atu24bw2Gx4fH0kxMQzjrZCiU6j0WGtFVWmu0lUyf/WTGseBlGKfFtDiE2DfNj1H+2u7SuQ55/4oYVeitH+u1mDFMdsj4zj1z199rNJPGgLX77s2TqzVZ03rChVF87WtxhtJL1XznFI0Fp/PJ0pKXKX3rlMgRnStK5G/M44TVymrq+xgaaVDierxNjmdZmhAcCpzden+dsbAngveO56fn7Rg6cVLcB4/B+bDTAOWdSWlxLKcKa0hplGMFgVm34kx8vb2QmtNpQGt4fqLr59NSZFLLzSHaUaMEvtfqVstxp2xtBA4HA59gmHDe8fppNMgOpXib/Yv6isFwzTrMyiRh+NBi7Oqqj3nt5NOAzQhl6JnVf93Zx20qnmjC4h0iyNj2PtUxTCG7ku4E+POvm+8vb6y7jvO+b7exlsxfiWiQff9uq43cv16hrx//57DfLj9/SvRrkVbI+6pE/Ye8ZZSE9YaYtR9f5Wbu05p6Fqu2GB684mfNN7Uu0wJbv28QD/7697xXic81LPsK1F9Pl9+0mQwXULS4LyFIsS89/epeZp1Fu8crUs9iqhcWQhOpx1aJ9178+ga/1tWwntZIiXX22swcp3gMBgzYIxj36OuHYArLBl1/1ljQPQ5l1LIpZI3fY06WSDse7oR5MYYXINSK643EHIu5FxVHtRYYszsLVFLxVlLpRG7ZGHujZ5atblYYvojAr+hedL1bPhPfWmxroo6wlea/vp1bRrr///6Z//yibN7DL/H8HsMv8fwewy/x/B7DP9LjOH3+H2P33CP3/f4fY/f9/h9j99/rvH7T74Yn7/510hayfEE8YTkjdI2fC3IsfG6/YDESd/oHsmukEnIpZLNwsunzM9+NlCyTvuZoJrxtWRKjSyXC+PjgzItzjINR8wYGaYJ4wRcJe+Fai3ivXqXOENzBkQ9D6zV6Uv90BrjMCPFU0qiRMftuqYJexZi0w8rp8roRr59f2AtjfOy0ZqltIxZPC/njVQbX1KjNcvf/PrfcDgMGC9gHTTBFL3Mc1ala3Kr6gFjDKW1vqgK1hlazRinPsfWKinSqsE11dKvtYKBXJJe0vbJz58uEe8M3nha08UuVqduMYILSpTQhJoLftALZWOVSkvNYlzm4elASirBc5VFGMeBZugboTAMBucD69IwGbx3WOvwQ0CMwZjAvhdoFSOaQBljePSO0QeGcULkC2IMKemGiDazLQtgGaZnxFqaVNpQcE1Ujtt5RHy/XNSfv+8LPgzqX92aKkkjuBCwzkBVv/jgVIJdxNOkUyqxUnNCSiGvepm1t4b1gWk+aPJQwRpH3BdKyszzARyU0mhkWilIE+bhSGuFdY3M4wPWK/limjD4CWqlGpXXVpkjlS4iQ+h0Xaob+76SL2fEWsZpYN9XRAwhDKRORNngQPRgHMaxX/Z6xOilbQgj1s60kvjDP/3Imhphmmg1YVPD2UAumiC1Vokp4Ts51FB5E2rDGT2cjVicVbloHwxiRpWeEcu2R/aYmOefM1irftBxxw5e4Q3TyK1A2ik5a2JiHLnulJJpMVPTjrWCNWBdY7AFJyrNs8esa4qKtwGMJTjDOFi9tMQRc6Y0sGHAds+ekjXY56p+29LlhuJWMK1S08a2npimgDfX6eyGEZX9TvuGC8IgjueHZ/Y983JZ2Qu4YURsYE/lJm+faiY8DFgLcY/UokFORC9W455BqhKOXebImH6h7PWCNMaNWjPOjoThjy88477iDOzLhq1Q9o3cCn4KuOHAXiridI97Y5jDQKsbcS809CJbKpAzoCoIV4qUWqm5UXNmCA5nYVkX5mPAo5fBpVUl/FqhlabnVy5Yb2kUWvdgkQY1a5HWSHre5aa+3lS8C8S0KWhhjaoEGEOOkVY1OdcEwCtCkCtvr2clWnMkS6UWoRjws8dYCM6S0o4VaNVwOasXN5LZ4sbxMKtPfYwK0jShUXl7+8zhMKqE+aokaZhGnFUZrRgL0gw0R0mNdT8hORPSwG6h9qQeK8ieNFFqBWM7nZea2j2I7jOMwXtL3TOD97gc2IsmJ15QP/LaoKg1Rc6RjHBZI9Y5zl9Wnr55RymNvKnHkh3/5HD9P/jSZE+97J1zqqyQdf+rTJBwOp0IYUSM4XReQIQhDNQKJRdCsBznkUbr+63xww9fmKaZ43FkWXf+8PsfaLVxmA+UCr/9px+AxF/99S8xCKfzhWkeqbVRcuXLyydqqUyT+ppZJzfKu7XG4+MjACKWdb1wPp/w3lFr4w9/+I55PjHPM9ZaPn/+zFUabOp+VVevNP0ZQvAO6UnU2GXNtm3Dh0D8CUFbt6o+S6MqKaQuedZqQ4BW663wLqV1CatGjPEmAdWqxo6cEsaKxupWb4R2Shma5gDrumGsYVnUT25ZVl5f30gxE/xwKwLozQBN5OutEHp7fcX1BFe9s2wn3VWxZds2wqA/4/hwwIgW1zFtXC4XvBtYy8Y4qDzUVc4OYAge63rB5QJKMQu5JNaeQF8bIsOojZbYPd3KUm5FTGsNYy0mdzuEELRYBKBSshbZ27rqz4gJaJ30LjcCWMlQgaoNEmfV2qF2yamUI7lkrn5Ktbbb8/+pxNK1wLomzZfLhZQS3nm2bcWgOaXYLmnV9LmnGGk09tWybSs5R+Z5wuBUfUYMja/NmzAEBfd6/mmdo9bS14na3iDQagcQq8oFdtAVH/r76w0FLY4hNz2TaqmsywLoWS2ikJAPA45e3HQKOxVtrh0fHrHGkruvUzaJhNpZ0AHDf/r974j7xrc/+wVPT8/U3ti5Ut/LZWEYR0S4FZp7l1G7ynKJGIxx5LizLqqkIcbgnSqL1GaJ+8a2rn2qw3I6nRAjDGEk5cL0EwLde0+MO+uqqk/Bj4i1xBhZ14XgB4zR5kq6Qo05cblsrNuq8G1O2qjK2hTZiFijhWvOmcvlcluz12ZMzlnByV4419rwTql0lV9zSqIPgVIy27ZSSkZkJcZ4m6pQ6cQu81Ya+x71c6iVnHeGcST4gJEjKRUEbs2dqyycdDS/lPS1GP4JZX5tDFlrbvvFe4ekAuP1+7UIz0n3WC2VWnMvKG2PFzrSoU1RbXj1wKfwqliGfhbHlBBjcM52yNL0RpVgDKSY1fKmV+bXqZAq3Bo1tQlUQxGNo1f/uFoV6HROGzIlZXLnhGupBOcVeuv5rUn6MlMt+hqaFtC1VmqpFGkYrZoAg1hwVjTHbw3rbM+XO2luRG2jqH9UgBsjN4r9Wm//9Hvkj2DmBvVPK8r/x77uMfwew+8x/B7D7zH8HsPvMfwvL4bf4/c9ft/j9z1+3+P3PX7f4/efd/z+kzvth+e/QVApgIMRjFQokdIS/2r/gbJeuLz9jsvpE5fPP5Lzex7fe747/UcOh5nnh0CqEbeDCQbTCiKBmHaCGbAhU2vCDp59jRgbSOkNUzdyacxFkNwwFHLeWfJCLbMeCoAxnm0viFhKrNimU9k5RzyO2hJNGnuOvL0txF1JO4thHgfWvPNleWXwM9Isl8vGJV54O5949+0TNSceZsfT+49M0wHBQitYKtIyTQxDGPrvVF8CseoLXVrDDV6lu41KC2CE1hdGg36JXcm101jW4ozHiMVaD+2rXr4IzOPVe6YRS5ccaSpl0qT1YB/08s17nWTsCcU0jFgLe1q5nCs+qMyI6wvyvCzU0tTct+n3hOCoVm5UDw3SXviyvGBQCYhh8hqcjEGM4LzKnpScOZ8vDMbSxob3ltP5xOgm5sdnpWCsEEuGLkeR+oXtEDxIu/lHNxqlVUqKHMYJMR5cT6SoOpVPZQihb1r1hh5HTymO0q4+GJHl9QvGBWLRy2kjlsN0pNTEetlYLurDYY1gLZpQoFPMxlqCDwzvHaVY1nXRQ9So8kGtiRQrx8dHTeKKEjNvZ038SlPp5RQL02FGRHg4HnDOE4a5Qx5GkzVxOB9u5MuVmLROCIPDlMB6OvOP//DfklujGdP3QSQMEw19/cf5wLZv7CnqpWdrKtexnckpczweOqGp0kHny4r3QWmmKhyPM7VWzuvOOEy8f5oZQiXWzCEMrC3ijGVwDqqSYqSqgIARzOhxBqbBgmRKG/RS3tqemCS2opex1uhVuIgn7iqDYUzDiiPVyLpHhgFy2ih7ZRgHLEIVTYqstcScGZxjclUneC3ELqWjvtsN7yzB6u+KKfP6ekKsyuDkUinrShP1GLIi1KTSVta9x1phnru/vOjUdClKFKa8YwwEr1TlvkVyqUzzhLRCGOz/h70/+bVlu+88sc9qo9l7n+Y2ryWfSIqkpEylsnOijKqEqwxUwR4ZNmAYBmrugf8L/zMe2R65Sw/coNLlQtqWKyVZSkmkKFLka293zm4iYrUe/FbEucz0gClNSNTewMN7795z9t4Rsdb6Neuzvl9KEmkkg9oWc6VE3t02aOj0+MjoOnQtQnMugaiaLHwFtOXd45mimpxOhZIMGoPW4iHuvaWzlriIdFffjdQksInzjr53OK+pIZGLrIulZqwxhBxIMbIbO0CCXt9pjKqUNGNUEdn1DMoZuQ9KgnapCeeaF1OtqFybl0rbTG+BvjSJog2MUJBUGxfWULLhcqqk5jGktaMoxZwClIx1jpiEGH318IaSCrYf0A5QBa0UH3z0CapWUp6oWFKEZc50fU9VhjllnFJYk0g14rXD+5ElJoIyLItstFslhUZUVcaj1dQsMjqaTAqBTJZ7gWzAGxXJ0yNvLxPVZByGEA1BZc7TJJSv6yi5UmqiqoTxisfXUGNmdI5SFPHh/KuG63/nVWvFWo9IZWVimwcpJrJSOCfqJUJazygKp/MF3WhMqOwOe3Jp5KJxTMvEN9+8BfXAt7/9At0krfrVnycGjIb7uztSXNA4lmnhsB8ZdgPny4VawPuey+XCfr8HNJflKck1xjYqWyTobm/vyDmxLIFxbMVvhcvlwrIsDMPAzc0NSgkIshKitTYoK0ZKleTWakuIERT0vUg9TdMkCiRKcXd3h2uyW8Za8YEqzZeoAWxCSya6rmuSVZllkc8OIbVrMISQW0IHtaamumJb8ksrNMWG5Pbmlru7Wz777DNWz7OSS3ufhctyIoSAJMemFbGFh9ORWmEYRy6XS5NdUjjnGXfDRo5LYZqY5rAl+yklpulMzqGNgaUR+y3mhEoIs0hEZckTai1M0wWlRJIOhOLsuk5iutJbESzNj2krxsUTTgqKUgspJ3ID59bXStCfz2dSKlvjI+fYJKrEFyzn0sYvv1RwS1NBsbSTAtbaTart/XmxNjbW8ZPy6gMInRMfrbVJEdv9U0pDLfRdR21+fvU9dHH9/FKKQH9SPW3XZ7QlBCGc+64XD7BSN9J4DoGcZD1UWiwVUIqQA6U1L5Zl2eTXtNbEECmt2DLWohzb5+VaUUbjmoJQWGRu1ioNlZxlfhljpClgDZ99+7eY5wu1Kvku79HWSml2eyHU3z8FkFtjZKW8RX5ONeDOMAwj2ujmDfbIMPTc3Nyy2x2Y55kQAvvDYaOKrXN0vt8IYwBjCr7rWm4i8y5EaQ71fccyT2LPlMWrTVG5OdyijeUyndFaMY4DyxzRunkJKpjnmePxuBXk26mC1ozoW0EbY2p2L2XzgSulxeecmOYLIYTtz2UeGXIqWOMQD65K5weMmdtnJKyT+ZNzQitD38naU6kcT6cmtdnGx3wh54LWalsDQwhNTk4arVoLCCvzQpqVKeVG+lusEZup1d/u6cTH6mNW2vjSDIN46S1LxCtFVVKoOmOZ5pnzNG0F/bqerE0vgFKLNBSz5EkgxHmMSRqXSea/iP0pSlsX17G9yvuVHKEUgfJKoVSh1rUxJMSPzaAw1uKdo2SRo5OcOW9NOEWlKplbCjk9BRWtzdaUkKbKE1GvVPOqXJtorUm7/XetW5Nkve5a3yvK///D77/y6xrDrzH8GsOvMfwaw68x/BrDf/Ni+DV+X+P3NX5f4/c1fl/j9zV+/3rH71/9CFquFJXliyuHxqKtx1Jx/gY1Gm5e/D5LeUf/7M9599M/o6gFczB06jlqCDxezoQQ0blwqRO23vP4cMLmiN97eufo7QDuAv3I/uYGlCW0U6GmyMnnVDKGnv3+Bj9AzXKa0atKjoqhO5BnRWViKeJbuyRFUYU5JJG/AKbzI6ZzqJxQEVTsCRguceHdNPH28Wtu7j/j7u45u9ExVMsSI+SKgFyy+Wv8QEkVVQsxyUaNsgZtLJ0WOV+tRaZYgWx4a5G2zlX8dOVpilG9NqrBDUJ3gZaB0F4KhfcdxjiRi8h1IydqrihlUNbKTmAFhZw2z0ugs4ZYCvvxgDUZ56NIfjdCKc6TBKom0941ykzpjuNRJEVWukQpw263xzuPdeLbjFJopUSSI2amdGH0HV+G1zjfycl+FMcw8dOff84/+OQZxmRKFapJOU0ME87IaeOSi0gbK003HhC/8pk5BY7nI7v9DRZDybLAaqVlkmrNsogUjdaGiiI3OfKSKyVlduMNaPFuTyGIXNFp4pIWcmqS1FUzeE2oFdN17PobQphZ0qlJcweM9ejek1MC5ch0WG/orGmbf+IL7UsmptiuK6CMQjuRurBaM+z2EuzVkzfMsCtQClWpdnJdPJP3/oBVGnRBVcOP/+JnHB8fiIsl1EKqQl2l2Kg/1TbLaxWKsT4Rk6VIEqAumhADi3NYY8gl0zk5zR1joFTZ9MVrdruew80zlliwvgIzxEwmEpPGqUI3WHa9IpUEVFSBaZrJRVOVYZobqOENIS4CNliNsprSwIiVRoxZZMlBFkqPos4L3kD1WpJuY1DGCHmVBZbRVlHTIhuUxsomdM5oawWjKFXk15GkxY8jx+MJ6zzPDiPzJRB1xjmNU04UAIwE2RizgC7GkHLCdx21KJTWoiqQ5d6WIh5SikJNUJUEKWMMYQk4Y1HqaXYLPAOu6zFakUPA2Q5dNJlK543IlcyZoguPpwdsL5YDvVNiTZCEXHvz7h33N3tc5+ito8hMoB8cKUdCWFrBoogAWmGMxlsnSXqpiBRLwhopGkrJ7T4YULIp7JShpiTrldLISlchB4wypFRwrqMfekKMpFwITX6laMWcMylJsth1kqR0ned8OTHPkSnMsh46UZGwMm1lzqEoVZNTwVkNJMr5wjCMIr9eC19980COAW1lLSGLtwmqMuw6SAVtRAWjFnluXd8Rm5VErzxLLcxLIFNwOkLRxCi/b63lfDxx2I2kkri5v+d0FlKxxErOoLqKUz2PD0ch+lyP7zzD0NEZR82VlCNFFW4ON5wvj5huR9d1hLxg8b9yuP63X5JMRoyVRGR9PFKATQxD34qejFaFm5sDphVvtWgul4kYhcZ+9eoN9/f33N4e+Ow7HSHOdL2jcx0vf+e7HHY7RM6jMg4D1khS5W3P+NGA0mWjZ1MSiw+RZLMtIZKCY54nSWBFDITdONJ1HdMkRc5+v2/FnZCIzrmN5lyluS6Xy0aQA2hrYLOVsFArQzdKoeUUAwPWWW5u7xgGkXVbCdyu6yTRK7XR+148g0LE2oWUhPyU5Ly0opjWVCgbcT7PsyS72pBzwVhNCHNL5FfK3EA1QCClJIVHCISwEGPgfL6gtWG327Ui2Ij1R5M52+12W1L9lJSmrUiWpFH+8d5jjaiuWKs5Ho8YY1qThPa9pFiIMYhkX5RYsN/vKSW3JoHeklMBXMxGzKYktibaPDVL5nmWBkuYCSFu3nbw5DO1JvjWOi6XSyvuLzKmtZCwAPUicU0BnesptRKj/F4KcWsuhBB+KWkGngq+UrcGh1JyamJqkmirBxlIwXOZLkzTid1uj0K3ZxZbMS4SbJskWhX6XCklkm3OEXNivshph7M98/b1Gy6XM8PQcXN7T+e77Vktk4y/kgvHx0eWZZGx6D3WWWqpDMOAeU+O63Q60TlP38t6W5uSj9Iab6TgXJrPmHN2axishHZKRQobP7DS1dLAsEBBt2LlMl2kwGsnG9Z/p/eKeN3yMW8FbFyWyOV84XK5oBQM/Y5SKsfjGe+tFO7t/k3Twvl8/qX3AmlqAFIc54LRFjeIn6LSsDsM1CpqUFSRkNPWMu6GtjYplE5t/IWtcVdKEWjyIoWqNW4rdnOWEyxin6G2JsE6luFJ1nFt9qxNE/mzp6JVt/xuvSbrNCY17zRlMMZu43JZFlKQ5mHWQuyPvZwqim2MpSTfzTpH33WiVtJO7pxaQV/WcWIk2VgbKTLnFJfLmVqhlLTNl/XIRGgSeS2aUHLmdDw+ratKSUxvEm3rOtRukPhOIvmmxH7xaotBPNRqZasdVHs/104WrUR4adCw9347taNQQqVTW1NB1Gw0lRQDJUvDqJbSCmslVji1UtUKJUsjQih723LvCsi4NW3urv9sja6cxbNR0TwXn6ycVoJdqbWJZySI/R1e1xh+jeHXGH6N4dcYfo3h1xj+mxfDr/H7Gr+v8fsav6/x+xq/r/H71zt+/+ob40ZT0Wil2gJTqGSoWr6VKlAt3jznW9/6Z7z46Hc5HX9K+NkfUr6QRSQ/fMVyDJhSCTrycn+QzWyjsNYTz2d0DpyOjxhTQVmGZ7fk80V8WxNUZammIyaNNo5aFlK4EApy2rEY4pyoxeJdT687rO1YYgIDucgGbCwBY0XS9ny+sGRLSIadEtkH5QK/+8Pf5/b2BZZCKbJb5ayVzTujRe65IrSDkw0YoUtkEKsk/soVRa0KpQwVIUdyEeLLGb09Bt02xoWSkAlMlY00s8kCIAvrMGCVImcHaJQqpByeJpRxpPJ0GlNrDa5sxvWGgQ9fdpynE5dLJKWA6eW09zrBnYmNwkksIeKcoescq6dESkJBhRwpStE58T+Y50jXyyar9x13d3fcP5w4n0/YJZCsIyv4i5//lD/4B79DMYWwJNlgdg7fe3JM6LZBh2r3LKZGWwrFNR52eO/a/ap0vpN7AQh5osi1MqeILYocZqbziel0put6+nEgLDNoAJHjzqlilEbpgjYiwXNeMpBRxRHCTEwz2lkOwzO6/lY227TH1ALaMi0iD61M8+MAFJVOSyLhnQS6QsF2PaCQ4S5kUIqZinyPUhLGiKdy0k2eQytymsE6TOk4vX7kR3/056QpERH56Xk+k3MiZzaSq2BYwoLzjlwKpsmKx5woVNJZKMredxilqFqxpMzgPSXDPAesL8SSYKj88f/3j/n404959vwFNQVGawVOWGEOrSAm4jxjXfO5qJXLFElZpKRzDNS+o9ZEyVHuWbMIyKlQtaH6JiNlFc4UrC4iv180lUI1itKEOYzVUDOlJHzfc7lMGAVWG1KuzLOQi6bKXEhZ7qkzhqikkDDG8NXX37A73LEbb6g5kWIm10qtGaclCVFVE5uHkLUdxvUs0yInrHcjSkOMAYVQY4pMzkXknQpixaA0q8zQ+kq1EVG54qxv64IlTbJZLIoFYDtFzYb9zUuUg3k5o41FWdn8LzlhjTzz3kqQqzmRgsAi3rb13A+oajAtWRHPowv7QaTVqzIsMQhkUKHURKlgkOLOWYvVXVvXCjEnqIXpshBDJuVKTAWlTpvcU0URs/gz1QrLvJBrEYmfzpJrQp1UC/qVcTdSEOig73tSChK8jSfGpSVPma73xByIU+L1qyPvHs+4wWEtOKPoBwcqk2Oi7xyoQraFaismJ5zu0b6nLIESKo/zxOPpjMHi+45d7xm6jr67ISwT/c6xhCoAzeFAUUrsAyKUauiHA3Y0pCWgrSYRsc9uGfoOdMYwUGrG1Mr97o4YAtprwhTo9B2ZQnUGXXd03d9eSj2XjDEa57otWVyTR+89fe8Z+p5ShBL1zpJTpO96kevpDMPQ8XBM7Pc9MVyIwbEbB/ajJJZD33F7c6DkxDRN3NzcMHQduRZCyDyeT3jn2I1ihyGf28u4rHA6nRgGiUG3t7d0vcgkCUCSWMLCu3fvZI3q+18q3IAtYZICUV4xCtm8Jse1Zg67HfM0oWlSalYo0NWvSEjYDvMesLJ+jtIaRSHMkRQzr1694ng+cXcnhLnQ0DtyFisOY2Tds9Y1r7Yn0nhZIsfHIylFtBEJpN24R/UG13d4370HoantWUnDYUcMEWPF2mQlgiuRYRxwriX1uTL0XSuWJHHVRm8kMWRqUWhtmZcJrWG/v9mKirUh0Pcd1gqY4b0Xew1tWpy1jIPHWL8RvUrJM40xb8WB0iJhhlLElFimSeSuiig3rJSo+De51piZ2zgRGt4YhbW6FVGQS4I1GVYwDjuMdRsoCPI8V4uXWiWmxyjA5M3tLZVKjmlrFiTE6++Jjjbb78ophMB0OXM8HUkpsxsPGOOIKchYc30jiYXMN5itWeGso+s7Bt2xG8YmsVZJQZQ9qE9jWbUCZR2X5+MJYwyHw4G7uzuR/Op8kwarpCZXmHOWRlLzI9PGbDJ6IEVC13XbKQvrrPjYtd9d14dV6SelyOEg3n4xNj88nujetfh48tVapbnq1tQS2UEpVsIS6PqOw82n5Bw5X07kXFiWiZwNMSx453GuwxqLVqJUEmogpcj5csE5sRjyrqfkQkyBvh/lWdbMNInqUUqivBKTUNG5hKeYbJuM3bxwTOLFBhBCZLrMrciq20mIqTVsVmoc2GTt1gZYrVL4rg2w973GJE+wv3S/1hMYKLk/a0G7zvf1Ph4OB7RZPb9q+z7z1vgBhfOeeVmIKeG93Z6jNFpqawLYRstLARtC3N4z59U/Tca8rKdqa0zVisCFxpLaKYScW6HZiO2cK0tIxCCgqlKrfVWh5sI8zcSSiTmTG8hrzOpzKD5+Wmlcm3OlNQ5Tis1GyGJbc6ACiUaga4XRBqtNO/0iJ5xWlSWFSEeiJYeQ+ZKp5UkOU7cmn/gQymXZVoCvJ29W2n1tNMm4budU1NNpGZlHaqvjjNbb3P7bvq4x/BrDrzH8GsPhGsOvMfwaw3/TYvg1fl/j9zV+X+M3XOP3NX5f4/evc/z+9+i0F6yGWgsoI1r07Vi7AtAZVYUKUTh6+4zx/p77+9/j82f/JY8//RGpwM3hlpQXymNgimf8jSNPhRC+5vH1W2pUjDcHunFgwaL1ToJ+KTxezlitGYcRSuWynDkYOU27LBnvZFJ2Xc88J+YlkVCUEjC1UNsu8xQy8yym9cpoYk189eVXvHzxAS8/PFCN5tPuU5zZYVGgi8iTGxmkSmuM9qQopFkx8r65atk4asSJbvLopi32QhxlUCIbEdKCcRZnvciGWI2pShIW14m0QKNiUopsIwUwrkOrgvEWAa0ytnkAVGQj0ZlKMUZOWlrQvcVpzZuHr1kCpFToncYNO7IeSG2xFbljxTCM0AZvqSJRcLqcySkRk5w9RVWUk9Oj2hpSzISYMb7guwFrFGiDc5opLRw4kGul5MovXn/DT/7NX/Hb//gHOGtIcWEJE9YPDK6n1CKnvmvBWk1KsZ0QXe83nM6PqFrQxjHX0KSXRdJYwA0JeEsMhOlCiotI87jm+ZEK1llMkz/3vUFMrAtFGVyv0MaiVZLnYg50/QswDu/2IiuhhHIpaQalGMcerwEl5GHX9Y0MLeQcZdwYTdf1VIxs9tdCnhdSSu3ZV5Y8U3ImhoQ2lnG/I4SFlApUuIQEOvIXP/3X/PXXf0HJBvSBHC7ElIgxMU+BmIUULEWkNWIS+Z5QIikkTNvQTilRapTVBUi6YKPIuvS+JxSIc6TTPXpX+OSTl3zy0UcYLb7WVYvHe1WKVBQ1JnJM5OJJc2aaFrRRTUZEYUoS6XMCnbOY7ZmIJPvPvvwbnn30Ic5WIJNTpndyajuGQM4GGsmaayMkrXhGe99tRUVKUQKArmjjKDWTs0wn33USCKtAJJfzCecHXjx/wbvTxBzfcrjZE0LbaPYG1+ZhygXTYIZcYZoW8UDRmnkOlJxQSEIfc0DVLBveVQlFRSUGOTFdt71xRdWWUDIqJ3TN6K4jVU02Gm012sAcF4z2ItldMqVUrOnFimEL+prHN2/wQ8duGAi5YKrm7Zs33N/eoqsja8USM2UqkCunaeLw7JbHy8L54cgUMlVZci1Yo0FJQqdKRKOpVRFzIua3pFSoFIwzpJyZl4BxFtDUFpxcKVhlsKqCBuU1Rit2d2I5oFKlKDktn1KGUtF1jUCK0qwqLpdJfGCWhVpn+oOsbcfzET909KPiww8+FurQQTf29K7j+HghxUDnO1QxTCFSVRIZrwzny8Iyz7x7d+L16wdubkb2/U4UBlTFGDgvx3aPFV1n6HrVxlOP1UUSgxI57DxjKwD3+4EcA9YeqMoSw8Tzm3tu7nvc0HG+XIiXheFmYNyPdHpkWmZSLpwvRw6HHSX97Yty78Xry1nxpAkpSkw3Guc8Q98hnjXiHW+1BqPoneXZ8+fi65QWnFN89MEz8YjXmhSTJDGNSA9zAxaU4Xya0Lqw2x9wXjdfI/HoyqkAIkNUasZatxUfpYiaQt8NVGStSzlsyXEpZZPj6rquyRNJMvu+JNH7xKhSQr96azBKi51JKThjpQHQkuPz5YyxHmvrViR63zFNF87nM3d3d4zjHmtbcTz0Qk5WIVj7vme32xFjat8BvKugRGVGQLMosNksRYC1jnEc6fuerut/qUFgjCElvUmjKQSmobIl/illqqksy8x+L42VGDLT/IhWhsPh5pdo0xoTJVdO50e89wzDSK3QefGq8q7HOVGUWBsah8MNqamLaKPZjQdJUgFrbEviDUqLLJsQo6qdFPAb4VlKpbRTErkUjHU43eG9EPoCN8lzHoaRrhvIOW0UdQiB58+fMwwDykheRRUSf24ybFWJ7FhdSXcnEnw1r75SRRJ/5+TnqNv3W5tAthUq1oqMYC1VCotaiUvl7u6e/f4ASnK1sESBvi4zDJq7+3uMkVys1so8zQzDQNd1vHnzmkLh2bMXGGPINTMMY1uDEsY8ncCotaKVZl6k+Lu9vaWUwjCOGPPUKJDCjK1A2I875nlmnueNJldGb2T1WrR77+mHAd95kYGr5d+hrUOYxSpCa6A+EcFaKH1r5fnP84WU0tbEWE8pgEj7zfPCsjQ/PGOJQYyopDhcyFmkBOd55tn9MzqfKbn5izVpva7zGK1IKaJMZSmzFFcUkRnMmfP5yLIsUjwpSwgLp9NZ5oDVGx1tm/pJinLN4om2NHlFgTGlqNOsnl3SRHRb88h7j8hfPq0561q0NiNEDk63Iq1uzy2ltK1N5/OEaqpQMUqhvP4jvogQk5xWAdrfSdNwCYqUMrkULpcLVFF8kvkuOPU8z20tye39amvKqbZWiWReaZS5NLQKOcv6lFKl1ExBkYKsX1DpOidFd6nUhm6vKkRynyUvSzmRQtxOb4ASKNg8eaKVlHHWos2qOCPjudD8ErXGagNakj7dmgZayFZqlqbpOufWolgpSzUyj0qV5xFi2saBArSW2Bqi+A7Kn4H1XfO+k3td8pM03fq8a62gZb7mmKhVaPy1ubjGkfeSvL/V6xrDrzH8GsOvMfwaw68x/BrDf/Ni+DV+X+P3NX5f4/c1fl/j9zV+/3rH7195Y1wekkYpS2r+Cis9JQuj3EStJWCgaKdSez799n/MbrjlHP8F568WXGcYDi+5u3/JOT6QF0jnCasrftwTy8J08XT7HWm+kFLGeo22PcbuqWFhTgtvvjrjP97R7XuWxyPTHEArUB3eaPCWc8osZ8Q7wmtyrqRieAyJd/OMqoFx9Hz3+5/w8vkH3B3uqbkQy4J1UIuc8lRoSqiEXNC6gs5Y49BoShSiTCtDambz2ighYtBYI4mOqgq6DmPFN7uWIqd/cyKECxVLSBWFUC3GiW+BVYbckpPtwRkLVaGsQlWFU54UF6oqKGXQplIIVO1wxlJLFGmMGDg/HIkpySaYlYG+5MJ5npBQqtDaUVEicd0koVGavhtQfUUrxRICSmmcXyUlMkucUUahtHix7A47VC7c3R2IJWHcSFIVp0Ry5E9+8tc8+/gZ4/MeYz0lBtJ8IfQKq6CkSKmJy5xxncizkCMKQ46RmE5oLdIMsU6S8JFkE1OJx3gtiul8BjK+7wDDHCM6Cl2Ta0Qlje9G/HDAOIVzA7FIQmadR6GJJVGblERq0hCdG4hxpoTzU0JZKyVpik5MlyNHZH4oXamq4N2As71I13TinZMLXI4PxLQQ3Z5SM0pnSlay8UlljjNai8y0nOKfyOHMj//Nn1MCpFLJ5cwcZ5YQibHI5loRsEG3BbqmRvqkBGhyyeiSQRlyCVzmjFpzv+FAKBW9LOJ77y0ffvScTz99juscSssGcV0uaN9RWjAz1lKUJuZECGe8NewGTy2VrhMQJCct8tVASXKiVry6Zdf6ww8/wHiP0wbrNGJqoQnKUnXFqooyCrTmvARizoDDdztQVZQfCiilSUU84qtaTztrYowUDfOc6ZylM5bb2+d88+YVc4Bn93ci4Z0kSKreoIxl2O1JuWK0RSHe16mIPLuiJYQKahFSS1eotEKAQtf8wUupUDKpvu+HUXh8ODdZEkmaSq7oWtHK8niK5CR2BoVHNJowZ3KuFATgsd5Rc2GZZ5LxLEth/vw1nfF445gukcf5SOccj+czj9MZ3/fkXAmhcDgvDDvL8XzinCo3do/XlYfpSKoVq54Knc54SpLrt86iW0KrjaHvepyVQlAZjTKrR0mFmkV9QoNC45wl50iloJUlxsKul6QpLE2Ovcp1W+d48eyOS5i46ZvcfM7EJKf6RYUho7Xh5bOPGAYvYE2OdNVxOl3AVKY58u7dEWsr9/sDyzlwuQSKS3zwwZ7nL18yzxO7XvP49oEYIdodn33ybR5ePWI7+PTjZ6SL4u3DG0JtPktFcXd7wzxNxEvAmU4cG6qcrs8Kuv6GbhzAeAiaQ3eP22uUCmjr6cyItgMhBMa+Z54XUv7bnxgfh56SJSEzzuKVoVrdiilJwLQWnxjvHEprOuPQCk6no5CHGgYvxYNq8mS185KE1cx+HIVGjIn97UFkr5SiVs1yudD1nnm64JzHGEvXDQJwOElutda/5Bn0+HjcioF9UwdZJZ1iFDWTVUVFJJ/EBuTm5kZkgKxDKZo8md2So3E3SlGnxAfHWIPAzpph2G2F2UoezvPEV19+CRXGfsR7kbxbf845t0l8hTBzahSzJL6F1edK/l7I4v3+wM1BaG+lVEvuaWtAbT8rCV4phZrrRn+u1716hKUk8mpam5bESxF2vpyoavVVU+13K6VArQprOvqup/M9KT1R/yJlpNGq4qzG2Y6SoWtydyCQYU65xcEm76Xkz1AKrSuxAV/O9bjOb/dTKU1KcHN7g9EC7hkjyhBKS7G8ng6IIYrFRdeTcqIHfD/gun4rdlYitlei0DIvM5fzmZUiBiX5V3vv9VmtxL7YrUihtCyLNEWsFcuL1gAKQdagGCPjOG5Nk/dl4YbdDR9/+q3tOeatwJGiT2TLRC6rlMLQDTjnQYFvBbnFUVLdirZSCq6d6uj7fnuWudmyWOdacSLxLOeM0aYVFXr7/NPptI3VkCIlZ8ZBnmdtxcTqYVay+EatnnqbT1srQFbPrLVwX+dfaKT1+pzfH89S6Mv4Em8/ARhDnPG2Q1VN53r8sxfknLlMF5YQ6JzfThFQKzGILUoMM6FUYpTYM4cJpeBynqQwRdP51sjScLmIR54xzVKn1DZOBVRbmxfSHPN0ncjAGWPbGiTfez0FIZKKoTUh5M/W+beOLWmEaXznJV9eQptfemtcrBJvunkdruNt3PXtnga0Mq24T82/TJp1XefpOmlMTvPM8Thh2nfQSrz91rEpBflaKPrW+JRYXFoRqd4br9SAdaskXyZGKWDzMlNybdKVYpuSS27FqtR8OWc5OVNXCUYjVYUxeGehIrmkMZu8mrFGcs7WyKzvqeiU1jzdxuDTwEKp1TpGwMkYE1ULbKcqoGpbL58k70otlPcYs4oU223Sbicy+s7RuSIqPI3Gr5S2hpanOVrFhkf+X+qC1SNzO3Gg2vf5O7yuMfwaw68x/BrDrzH8GsOvMfw3L4Zf4/c1fl/j9zV+X+P3NX5f4/evd/z+lTvt7weW9Qg7sE0+pXQ70l9l8mnN5fiANhY7WG6e/0N+55+N/Ov/+/8K/Xqm3u04xxP5+MD8cMKPN9z2A2nyvHr4HD98h9u7z1je/deM1lOdQc2J2p+oJTLFR/7mq59R1Gd88vE9+RxISmG7G6BQTCKGmdNp4fiu0DmFtx3VVB4fjizzzHc+esGwP7C/uaHrRowRr1lrFCpqcloa5aNYYqIacM4ITaEMQz+ijSaTCWHGGYNHpL9LrvSDyLi8vwHebhalgHEygUrN9OMONHIyHE3MZSNOJOi59SCvDKS2cyk0DUJcOUNOjcTqPTEplPZYY9D0lBo5vn3DKZ5Y8kzvLVUbYtEoLX4mJeVt8ZimBWc0XT9gvQetmZeF2jadjO8wyrAsgTDN5FSpSZIeowQYiFPiPE3supEHeyIsCxjLXAt2Wfji8TV/9Oc/4p/8wfc4PBspfsSqRC6BJURyipgqYEFZJtIivgjaVIw2pCa/cpqPaGvQFqz1cnLVOsIsgWY37FmmC/MpEtIJ7TV26OnHnv3NLdp4ht0zjO4xRslzU3ISv1bZBPVFM8cZyIR5IZaZ6fzI+fyAQqQjYko449AoImsCdos14kGTUmzSG29Al0YuGXJcF6ZCqbSkM2JNh7OaXCrOGoy1WOvpnKUfPMulMs1ntB7J6cwcTlxm8dxJRRFTJsQocIcRmWeNIaeIdZJ4+W6H95qKxeiOVDKXY4RaKEsmaU2xYLzFjp5xv+P28Izey8aqQlEp4t2tDc570IppnlA103tP52WTM+eK+FRUUZgQzItcIYfVQqATaf6xk1PtRei4VEXCvyTRIrcKdFVoq+XPlIaqyaUpO1RDzRDjgqIQEVkXlSEpWUjzsqCUIStJIud55jDu+Nk3v+ASAvd3dxhtmOeFcM7sD3eMncyTUitGSbIXY8IpRQmJAkJkVZE5eXw4kmPGOo/W0HWWh4dH5jlQqVyWKCoACGTwN1+9xTqNqo3o1EaCUkrEHDG6KTVYQ4wVhWNZAuOuJ6YZE7JAEFVjvHhNXZYJ2w0UZ1B0XHImJNDDwNAJVbkbRrEzUAodIh/efUhNmaRhtA4/W0pNOOsxxvFwPOKc5fXjG4bbPanKiXTrPZTaNvUL2hoJnDnhvaxntVqcNxJIl0SJBaUr2iq885S4UGKm7zpUEYq0rgoAMRKTbKBrbdu6KnL1Nzc3WN9Joq0qISfmhxnvpPjsvWe3NyitOYw9/WjJsZJjJuRMCqLS4J4PDDXz8uYZ07Twqpz5Nz/+Sz7+6CXeWXRRpEVxukANEW0NN2PHq3cPeGvZqYFu6NBUwpIZ+h6jLN1g0VosH7zxKGu5GUUiyVgNZcecEqdFbBAUIqcWQmEK6VcN1//Oy1lHVhrdEkhrn4rJjWKuUFFY5ylNhqbvPSFEYorM84JRhuPphPOW3Tjgmw9TKplvXr/GO8/dzR1d55nmi8AhpRG1MeG9a/YXkmwdbvYMQ8/lfGmJrX4v+TeN/FwJb4lLwzBQa+VyuXA+i3fP4XCgHzpKrnTet+vzjTQuIp/VvM90k/pxTsjIlCSJ1NZgjWvJt96KKu87Pv3029LAaP5UazEHT9JX63cSOadV+q22Ak7+vvP9lryXUrFOrjHEJnVVamtaFKHOY9wSwlUmaqX5JQVQ20kESZTtdn8++fjTrXCS91HtvthWgPRbwWStPJcYA48Pb9jfHNjv9uRcSI3qXCWhYorknHCuQ9sghLV3dL6jVDmFIJYRdTsFYLRpfm4ZkZ0T0M9Yi65qG4ebRFOtLTEXeSalFd54uq5rucnUCiS9jd1SCktYBIiSRIuSpYGxPvtSCsMwsEryrQTpCpOWUreGj3GGTQaqFXDjOJJTYpmFjNdC9gjdHyMzSlRPat0aJtrItWuvSDnx/MULVKPllWp+g0CtMh+1quSScUrko1Za3jkvzZCcmS4Xuq4nq8QcFmFRVzUPRP1kLRyAVszJ3LHWU7UUU+8e3pBi5O72ltwaGMMwEpfU1mmBA9c8xc2rAAEAAElEQVQ5KQ2V1Ao8KZZPpxOlyDyD2gr6RIjyHJzvKLmwtIZUKYVukxcrGFNErs1orHdMl0ub2xessYxNYi6E0DzgpJm3zAsoxfl8oVAaEQ7jOGCMpe8GSs74zjMOI7kIFa+1IkYBXp11mHZiZf0+McV27aWdHlCkHEmLNHNEvlDuk/cO64S2Fs81GWOlZvpB5mQphWmameeJcdxt0m6rxKR4wSENGuTZp5gIMVBKxnmHc7KmgUBg1ghRXasAgDlVjNY8f/ZMmqZViUIWlVJFWm5dp97/d8mpjRUpaNd1zGglUKaSAlkrhTKqfV+RKEy5kqdlez+pBZtsmbHb+rn+nXGmTTeRM5TnILZIus3FkkWOcV0v17mn1NN917bVA0Vy7qoEdFxSFvm20NYSK03enHJb85/eX27evx0l1dYYsEYJ0IfEr9Ry1u0n32s6lVqxSrzZamuSoVfpxmbR1K777/K6xvBrDL/G8GsMv8bwawy/xnB+42L4NX5f4/c1fl/j9zV+X+P3NX7zax2/f+WNcVXZbk7OK9mk0FokBkSCoJJSkOP+RTYol1keeDcUDsMP+Sf/nf8ZP/mT/zXdY6bvb7joxLt3rzn+4pFgzoT5FZfllt39N3z9r9/y+/+t71GGwngz4vo7Prm5Y+wOzGbiRz/+V9gvLbcf9Lx5/RfMv/iSy8NbYjSkannz+h1v3l14OAae7Z4zHiq3L+95eXPgM2+56w5U4+WEs6pYDWqUBCMXISB0I3OsM7IZXRVQWgAIDMNeqDitMEpBe+bdMKCsAyVS2bXm5p3c5EBKbqSHbAZqKyeou86LnEI7oa21POzS6Jp1QLhe5LlLURiNbHI2KYGaJYD4rscY1z4fjO1487pyngudH9Ha8O54pChNbfuK0yykjwLxoFaK82UiXyYq4gttjMhorG7e3jq0qlgvm12xZFIqLDnx5u07druR7jBy9+yOn/3iG2xtnsIuEoCf/uJzuv3I79Kzu3FEZkrylBpYphOnhyPeG3LSWNtOpy8BrR1adzy+O7WJL/BATCfmy4xWjkzm5W99zNs3X1HDCdc77m4/5PmzDzFeoWqHMTvWI505B0oW4YFlmQlB5DVEskY3L44INZGtZllmutGLnHtKmKzIuWKtY7+7RWuHdzuMtm2BFXqn1Io2qiWAbXOuxnZvZQPRuVtKk/xGaWqp5NAWOhRzmHHG048dc5ypKnOZF8CScqSiqUqCTAgR13dYq8hJ/HasszhvOex39C7w8tZxe/ucKZ/42ecTX789o2pTPug7dCx01eB6zfF4wRxu0IhEubUjIUQ0IjetkFP81hhyzNSa0FqxzBFjNNZ6ihXpIWstw7jjMsnYw1iKEonuqg01CcGUsyWFjDUGpQ1FQc4JlQLaOGquxFIoKzFZIcwzWlWUFuIz5Ub7GUMtmU4p0hypcwW1oFBc4sLLFy84ns6E6YJt9KxWcDpfOP74rzkdz2QltgrWamLNGAWj9fK9lRQ+YQnEmHG2R6szpUZ876EqgpJEoncrBSprRyHi/F6SD+Sk+9B1pBB5fHxAa8v+5paqhTL23pJKgFhQaU9CtWSv+XSUiqqQUyKlyHi4RSnFOI7iQT4vhBiwzhFLRhvD4XDHKSVqnel1IcfK3f1zei9J8fly5tv3t9QSef7iFqU8pUm6K0SpISeh/HLJxMuMt56H10dRGlCFaSp0VrzJUZBjpqTKPKVGGivO84SzFmUMgzbMy0KuUIIkMtOSyTHincVaQ997Hh6OQlwS0dox9B1FgSqV0/mCNopdf0cOgdsbQw2VN2/P5J3lTo8Mfs/DaeL14zfM4Rf81sff4Z/+wd/nh9/5mIfjI6/fvqOoSNUOfxz5xc9+xve+91vc7Hd8f3/gMgXePZyxveP5/S3aV85TQFvIxhHTTOc6pnJmfrjwYHZCVBvPMlWmnLBaJKtEoabQWYvV7lcN1//OK0bx1jJF1BdWOniVJ6oVliUwTQvTHBkGx40bUWhub24auHGUxE1pQJGLyOusNKNQfonT5UzMgZIkN7Bdx/Pnz3l8fGCaLyhd2e9uAcXpeGKe5kaqC+kqhbskyOM4YozBd64lZnorsKTIFKWB/WEniVeuAq2UTKmSLBrrEIuQgPc9sY2dmATIcE7iN2qlbsPm97QW3qusl1J6o51Xiab3vW6876HJgiml8d402lagHiHmxedJrtVvUllKtT9zMscEkquklLdGwEqqrhSxUgI7rdTrKiFVSmG3223yTc45puYnpvW4ff/z+cxutwNEdkkpOF+OuM6y3+1FAqxd+5pce+9ByXd03jWBICV5BmC0kbWpFZTWikJGrSL9JzTnk2RfaSo7xpo2WtcCS5QpypbcxnZt8lMikSRNlfUkQlgWalmlqtQmowRPQOd6LTmlRpOm7R73ffdLxey6Lq9+VrT1uNRlk1YDKRiXZdk+C9iKipVgzjljnBRkQlFrrFXt3pVtPG3+VqUyhYkQAtbajfgOITBNl1+SPVRKM+x2KKVIUSTsQljwvtsodqWqeKihSKmSa+LnP/8Z56P4Ct7c3VJK5eZwS9cN27Ws/lnr+ASFc+KPeDpJPqS1xmrNEmbO5zOl5O2e1Qp9N6CHp/cLIW7SeNN03uZCLpmUBXb0zmOsRhnFbhy5nGWM7fd7Ge+DzMO7uztsmx8xxbbeRfq+FxJeKYEDi5wYyFnIZmMNChk/SqntdMBKSm8NJatwZZ33QpinKEWaNrRiGR4fj9uJmZiWbWyUXMhF1sLT6bStW+uYUEqx2+0Yx7GdPImgKjsvY1ch0LFSiqEVoyvtLjKLouRljSNXAWO7TvwcU86oJmcmz+rpJIFSq+QiDL3kOKtsoVGKrvPEnLG6tuaSZgkRUhEJzxAoWZpP1koDa/UFNEZk1LQXOl1phW7KOGtzkFYL6br1xrbvmrP4p6FW+yq1fe+1qaGryKuVUqgWqIWUCyFJDphzc0erbBKMMiAbFd9OCr0/XwG8szgn3y/nvDWS1vXg6eSPPJPtHZRqtkQa0JQicNv2uX/H1zWGX2P4NYZfY/g1hl9j+DWG/+bF8Gv8vsbva/y+xu9r/L7G72v8/vWO3/8eUuoFpRUxBpYlyAJrHLJJLF7O66lArRUGSBm63R7rFDEuoGDffcT3//F/zpuf/Zc8/Oyv0PqG3aef4D7yuAMM3T+n1sT/7f/0v6F+/YLnn/6P+eTvfV/oBKVRqqAxshH54T1f5TO/+w+/j1ILj/EVj2+/4OH1K96++QLz+U/IP/+K5fM3KCx+f4MpVmRq0RyrwqeCSxnnKtUYirKEWagvYxt5lAu+6yRwV01BUasEJ2eEfOu6HTkVvDPUklhiQPSbK86Jx4LRhlpl4Dvv8F0vNJWWhynIlEhHVC0DoDRqT783KFGKrh+a56yh70WqN5eCUU3qJRdQkkTUKpLcSkfOlyNxicTLRI2VsAQwhpyEkplDAG3QGFZ5CzQUMqDprKc3jqpF/lhpGPqBnAshRk4n8YHXpuK7ntp5+q7DOYu3jue3C6fjhUxlMI4pVfqY+eLrv2HQmk8+eEZ/a5hTJIV5k8LOxbLExJweqTHKaVhjiakwLSem5UIImnHsGIYO4yDlC8PhwGl64Pb2hmf332O/u8X7HRlFTZWUkwSuRl/lGKhKPBWsE6nnWiDn2gJcwo07+q4T+mlZxNtHyWYkWhbckjK5QKmJlBact2gsznUYq6AaQkxCuNRCRZ6RKJ2ILM3jw5lh6KlFTiELQSrSF0qBLpL4ffzJt/jxj3+EweD0jjlecE7uVy0J05QOnLagCr63GOOoRaG15aMu8eK+46MP7hnGDmU0H46Wf/WnC1++m+kHT1wip8cju/1HjLsBhWFaIkuOGO8gQa2KlEVS3FuHQTZjcxbf61oVznZobbckzjqhQ0sFbT0py3xJIZJyJcWKVrLgVw1ZZSoZlQsqinS41pZlFll/ZRWhScQ7Y4m1MnaOUuTvC1U+G6HrclGEZLAURgfFaqZzoBbNi5tbooKitWzGG83DaeKb16+x1uG8I5eI0k4WeG1IyElyqy2dc+LnBDjXkWOm8w7XeQmGek3gJCkFSfi+9fGHaNsJuVkkyOZGun74vCfkRNGigGG1ppZIDgalLcpWTCrkUrFa440mU+T3h55edaTm27IScxgh05YU2Y0jpRbmHNhhSb3n+WHg/DgzZ8VlmiS5tYaYiyROVROmgHFG/OurSLNUgFKbrHyjYp1hWWaoWcjJzqGrzBtqwWpFju3UfUsoSm7PuwVBY4xcd62kJNciyYdmupwxVuF9j3WDQAnOYbTCtQIppZmYZdPeGMub4xum5cKbhxP7ccAYePf4mppndjcj+97y6ovPuXuxx3UHPnh5z+Fmx8PDmVIqtz/4LrthoE6BdwEKDj/syCS+fvvI3e0O4zKu8ywh4IwnLoEQZnRveDydxUsqBVKMmN5wf/eSYedwXmIHSmHdUwLx7/tSGjrXCZyyzKCEct6Ng8i0pyixp60vIQTePRbSm8RuHEQ1YZlFfseK/8/lMm/FxJokLssiUmJNkqt3khxeLmKJMo47vLeEEIgxsXr8HA4HnNMovWCsZl4mjNGMu55SEvM8ibzROKKU4nK5YK2l63qg43ySNc8ay+VyxrSCxVnfCrkECoGT2ncqSWJrCIG+H7DVbVTuE3VemaZpK4TFe8i2/MdsSdvqeQQypkoRr6EQAnd3d63IWolLWvIr19/3fZOYEjhCa70VeWtzQsK+2opEIWCnrZBYE/01oc1ZvN7Wv1ulxNbvuhGkrZhdiyKU5lvf/gxrXKNoJcasz3e9P2wF2grcSN7nuw6qmMhUJflMzUJvr9ew0uugqKpSlUBU1EoIy5b0rmTuVkTntBXbOWeWWe7PKuOU2v1U1DYunz5vCUGocmsJS9juuxTMck+6riPmJCcSrEFh2pgROar3C3XfiRrGJjlXy1Yk55wJIWz3fpXPMkbkrHQ7LUBTV0op8749EdDmR2x+SXWj+VOKkqctE9N8Yb/fs98dqIjXoMh+CflrrcV7i9ZgbfN2alT5ql708UcfUz+Q0wVd37MsgXme8b4jpSL5jjNb82NZAt57UkpcLpcmeyc55xICl2kCFA+PRwBevniJMTLfrX+aI0pBiAuxEdkxLizLzErcH3Z7hn6UOFJFmu5wODTa3m7NDucF3gwh4OgYlOTs0zxjtCaXsvmCreNVVei7Dm10A1+lIThNFecdsVkErXOqknn79i05x9Y4ESi41sr5IvclLHI/Lpep5erSsBrHkWHo0MBuP6CbFZVSbNKVqcnnXS6XTU5O1myNVk+NmhDk2QD0vfggliIekV3XgZL8yxgjFjYpbmtHKamtB3Ubk+tYVo3s9p3ndLoIRQ8U2PJNlKjZpCRAr3WiRpVLQaGw2pByRKmKtRorUjptrGWssSgt40grQWpjCvTeSWO4+WNqBAKWtQr0Ok9aAwdoY7du8xvAGs1uN1KVZolHxEfxqRj+twvj9f/re+uS1hqjwZhV3q9ua+3a6FwbF/92g29bF7f3LNt8fqLuDX+X1zWGX2P4NYZfY/g1hl9j+DWG/+bF8Gv8vsbva/y+xu9r/L7G72v8/vWO37/yxniMSciRNlBjjIRlbiSBSAmE5QRVZKgphWogTBf6fCuED4Y5XggBXn76H2Jcx+nnC9/7/n+f4eUNnRtkE7TO3H/ye6ioePnyU5QGikZTKBRiraic+aM//pecfuz5+z/8Hm7vedZ9m/tPPkZ9pEgk5nhmmY48nh/40d/8MT/6139OPRZKjjh/i7IGawu7foCcZGOrgh8GqEb8cbXFaL0NZussqclrKzS+GyhKbrzIeBuU7jA5UYqcrPZuwPthC0TrZrUxhurkNKzSCt0GsTFGNn6t2zbGRbblvRPjrpPNc2VaoK7iQ1Iq1IKxGq0NuZE33nhO5xNv3r1hmQrTWeS1S9LEJbHEhSXOpFox1qMqxHkRWXRr0MaSc2EcBvFj7sQHO8dISZFaIIbAzf4g/t5WPBkqihRmrJbTtt/95CNev37gXDLOOoIqXOYjl6PnC/+ANopP++coLaf1Sw0cbm8JMTGlid7vwWXZyOeC68DdjDzzN8RFCJfbm3ucNZwvZz755DO0OYg3tB9IGc6XgDeW3Mb2HGbZLA0JZw0Zed61QEySNFQUugSRM9dPCUrf9+RayFH8kVPMuOJEQlpZrO3o+wMlC/VUSiAsipKSeDOniLFG7lOOqKpBiYTKskTK6qfeAooxpkEqUDNcSmC/f0bOiXnK1KKJIZNK3jb/ZNF2WG3JVfziYwhYBbZTfPrhPePOEekZVE+OcPCWl4een/78K5bzmbkmck3803/wXepcmPLCRCTUCy/GF5Qk1FIIkW4YWEJAI95GSilQMqZLFW+clJaWCHQixQFgnGyK18SSoRR5FlqJnEYqFaWdyOuXSmcdpbGSRius0RSl2nyVk8pKNzp09QiJka7rKTmhSuTzL9/xZz/5OT/87ENuPryh94abw54vXj3Q+6bKkCspR4oyVK24f3HP0A/UlNAKXOcoVZLewzBglMzzzZelUbYZQEGliAxLFS2RzkvyAaCV4uX9C4qypBgpJQnh2cALp6z40GfxPc8xCMnlRX4+xIjSCqsVqWS8dtRGl3Xe46xmnme0cYQYiGHBacegHdoZUikkssjAlMToRuKcWFJGa0vXe0pOoJT4FwWNUhWthUJ01jbFiISxljAF3NDhOo1F7CP23iFSVp4wB1ISOR1KQVFRRiAQFFgv0kWUQtf1xJZo6HavYm2SVlSxXqgZbU0jHg2d88RlEV/vm4OckndiW1EWkU//zncOnKczH15m5ksg68oPvvstvDYUhARMznA6nrFOYWzhfNF42+G9o2bE+mEuLCnTdZ6x66kl0PWOlBZG35FVofMOrzQoj9UKnKOqSFEOrfbo6lC6p6oJ21RIrPUoFPo9T5Z/35ezXSNBK7ko0hRIqeKspeu6LRHcK02thRgzIURREwipgRuV3TjgWmG4FgpV+KyNil6J7FppIELafKOssVK05oxzaiNC53kBBJ6pZZXfqrx98xaU0JIffPAhKzm4Fq7n04VcEofDnq7zIhGXOmLKzNMCvRR4XZujNDJ4VYKRYjWhTSAXSf5jTIzjuBWxsFKlNAq3Y/UvWxOuNfmtBfHWQcC59wtlIf3Nltj5zlELrZBUxJDITSlAa9VOEqj37qkkq8uyEOLyVIg3mlXm1JrSKY7HE9ZaLpeLJJytsF6/z0q2A42Yl8LVrkWUte2ayzY+3ic0tZZCMIZErRmqouZCLmxFslKK3O5fSomu6zZ6uyKxFdo9qGygYKlPdLyMi9qKIWkClCJjN8ck9iztZ4TeXYnRQpNcgCqiVmuBs8lZKUWICaWE4l3jicTvvDUgSn3y+lohHynKvdxzpdr3Kluh1XXdNobWceK9bzYXsIS5wZKrp5R81dBk5Hgv4V+WFi87j62Fu9tnrQmwAqpPPlBGPzVa5jk02T5RD0kxQa3MYSEsrXFQhcymyjgQGcCyNWpKyZuPW9+Ln6FQ2YWbm0MrrEUWbxx3gKIfhLwehmE7yfF+AVpyYVnm5kVWthx29UCrLe9dx0aMka7r6LqOlMTnq9SK6/x7p0VEqUhrjXe2FXciHRdC4PHxkf1uh7OuFdRnoG6Np2meWB9C53tqlc8udW3ISKNI5p1r48ERQ6TkC/v9gXHcb55jMnar1Ec54ZwnRbBWbZ+zjo31lMx6n2Re6u2+rCcO1nVXfldGq9QmMDdg+alOWAtEuZdd57eCfP1MY8RnLsVMqamtw4qUC8syYa3B+5bvlvrUqDE9znpIcnpJK4Wqir7zW9NvLfzt5l22Ar4yzn025LwWxGxjXRTJ5NmvXnpFF7FqavdtVdVaTwUpQFsNSnE+Tywhtpp6XQfkZbTCGN1I+HbKhro1m7WWvEKhNt/A99f3p4bh03+rWrfm3fp3pUkgPv0DSv0dAjjXGH6N4dcYfo3h1xh+jeHXGP6bGMOv8fsav6/x+xq/r/H7Gr+v8fvXO37/yhvjb77+hvuXz7GdxTnxdMhpRmsLRNmlq3KCsJYKxpHzgs6BvDyQlMd0QM2kaWLRz3jx8X/EZP4lf/pn/0f4lwN9/5Lxxbe5+eSWw+F36G47jPWEXPBoSlUYZTAVTuEdf/kX/0v4yWccv/qPeXb3HFUTFYeucrM1ewazQ+9e8Ac//C0+u/1HfPXTH1OXI+fj55AXfH9LrZK0uHFHIlHyDLkFBhLGOeK8oIxMdOctpYDRInuOWR+03oK3MR6rbaNt6uZVvcqSdH5HCAsVjffu33ngxjSpAi0BJmUJ3CDX1vlepN6VEQ/0JWyLUa0JNChjqSkRQ8BYxfly4fW7By6nWSZqp9BO0SnNUAdi7nn77ogyIg9xc7tjN/Sb70RoC8MSIiEpUBVThVQpudD7HqUMSSWUNaiqmS4XcgpMOdL7ASgiL3yZuDyewTmO4YQ2ijgnOhV4+dEztDbEuvDw8I4cA9Oy0PU37HaVOQWs79nt7jC+Z9y9pKKhRjo/4K1ssLq2CB0fL8Ql8+bhG6iFMC/sdjuMkVOkRluU8kISltxOfytc7+i8TPpSxMcALyd4hZorhGXBuZ7B7VDtVDEamQO5sMSZ8+mCVkJWlgohR5bLBYrcT+N6ULKBBgZnVZOEkU3QkkqjeTQ5i5SLZBiWEM+Mwx3f+c73+Zf/xR/yeHzH43HB9Y5lWagNurlMC3eHW+YQ8d3I5TTx4fMDH734kK/fXeCthjrjXE8MC5fpLW9PiZ999ZYcKiHM3D+75dUXDzy+vlCUpqjC7//B77UkIImMulbUnMilUlCkIBvqMQqVuhKKGABDqhWlFRVNyZUYFtCKVBS5CpCQSyGlgKFuktlhmgk1U41GVc2+G6ilkJAA1XsnG7NzwFkJKBrF+fE17zjR9ZZOV/7qJ3/Nl2/e8fe//5xx51hOM8tp4vbujtNlxmAJMRBCQlmRNRn3e2KYcVqSaoPFO8Ou36NlacRYkUF6fDxK8l1Fzly3oFBKxWDE1yj/MkkVlgXta9vgFhrSOEsuhct8QVeFVR26avzQk/KCd46CZldHnFLkmpnDAhW6ficUm1a4zpFyJJfCOA742xvmaUE5h7YGExMHpUWhwCmUMRxTxA07CaClMo491jfIoShiiKQEXSsIeiTAxhR58eI5VSkMCm8cBcUUAnOYWeJEigWjHSnKfNJaQZWEG6XItWCtk83yFhjFG0VTU6HvLCkuGGtEUkpLAlJzwVlFSRU/iiRRTpF3r1/TdSN+6LBY4px4d/6GCChjKM7htCGWQqweb2aMLlitUf0NCovDkLXBGYNzGdt35Gp4dn8gZqEJj48T2kCtGa16KpJEGVvEqsEYtHJokzHaUVRPDBeGvmDcQi22WWgUtBOPe9OK4b/N63S+bFI4Whsp7ELCWcVuN7QkLbbERG3Js++k6JDfkyJaEpjVJ8tvpLIk0qulhyS0l2nC6Cd/rZwLZZZC5Xw+b9Swb55kUjjbRm+LZYK1Guc8y7KQUtrAPKWaQkX7bPGGkgIqBvmMvu8BKBVsU2/IJUOWe7Emq1oyWHkPbTifzxutvn6mMRqKxA+U3poFa9K2Fgdpjlv8XgsCEK+qlXyURoHcu1wmWZ+2ZByMlfV+XR/WRHz9PNPozrUBUop4Ba0A37IsrYEhNLB+b+xM0yRgYwhb4RSa95TkHmb7tzEy18QD7cn3bVVzyElsWpzTpFTJ+UytkqfkRs5KbiMUKDS7HZqEklLUIpJLunlnPSXCIpWllKjhlJxFPSOl1nzI2/NPKZOzFMUhlC2XkuIgskp1VVW257rek1Uib1lkHcm5fbdami9YG/fjQKvZWwEh8ogKGXPLMm1FUSmJx8cZ5yzGamppwCiFEET+LcTYvKXEemUtXkuToYtB1mk5FdFo9ZgkL20qKnKfyybb9X5RF0Jo1/a0tuacCcvE4+mEVk0KsOWXnRvaSZSyFRil5G1Mrg22EBbk1Ifb5t5KTk/ThHjnjZK/xIRSdWvErER/DBFjVZszsiatjbYiGDLjuKOUynR58olyTWFmXsSvbVmWrcl0PD7KnO9EgjHlpybJ+qpVVIJAscwzldrmzCrD6JusIeQk14VyDMOA0XZrEKxNLlDt1Eje7tkwDNuzKKUQ4tzmJuL3WIW4XpZla9Ct301OGMgJlbXxtyzztgZ5v3r8ydqSS2JZIrF5eMlaI+vwam+1Xv/7RPU8z+RapSGFyCsuIRJjwlov63dcmxHi01iqwHnynBK0e1blmBPaaHxn6LquzV0p1o01WKOhQiq1fSeFUpZac2t0etaTAO0rNmDyCXxTugr13mBio9nW3lqlWWe0Yhh6OaUQM9LwUXgnY13+EcUxpcVuZm1qAJQkjdOn9c9sp5LWe/j+qRKlFBrI9ZfJ9PX5PP2s/js11eEaw68x/BrDrzH8GsOvMfwaw38TY/g1fl/j9/q6xu9r/L7G72v8vsbvX8/4/StvjH/xZz9CZ8fdx3uUG8hZTs/G5UJVYHVPN3hynTgdH+i8kCVoxeV8oXDGKw/a0u9vMLpg6Pitj/67vHjxJd98/keE42vm40/4/EeV81kRU8+N/5Db5x9z/+JDhud3DHt5+Kl6/of/o/8F8aKJbubNzz8nZc0lzNTjRAwzS7iQpjPH6TUuKz76rXu+/6Ijjx9C/ZTHh0cuxyMhTlActRhGbyh2wFnLVBSdUbiuY0xJNgOrUFWgsMYDhlKE1tJa5EgUTVZbiYa+NQ6tLRWRH6jt74UKasRFC0Ray2bu+nBr2wzq+562Ly6DQStsJ5u6KIOya/Cr6GpAadlUMhbb76FWjJUFKKlM33uMVSyhMs0ipxzDgkbRWcvdfkRT0VaIuBSSnNq0loqhqtJot0qOckJZGYM1hsGLvENOSU6UZ4Qgq1CWivaZ57c9yzRxPB/xzvD63RFzY1guI85YkkvoZNgNN9RBcbeSjlrRHXYM4w5tvWychpmh6+l3N3TjiK6aeZq5nBOX6SJy18ZgvSzou/1eIIOKnLi1UI1MbGcNShlqzUzzjLUdWkHJkVolScxtITLaMg4OlMW0U6rUisYQUqDESqkGtCeXyhLFv7kkQEuCmmulhCSnnVNE68I8C/VoncbogZQDyzwBmc71aCObZlNOVCyUhR/+3h9w+/FH/PUXP+Hrrx45TxMhzEzzQimKZYlorRiTEJvdvcf1I5+fA653KBKVid1Q0J3h8OEnfMv1/E/+0Q8wRnxLXr165L/647/gB9//jKGz/O5v/4C7u3vmy5mQF0ooGD/KAqUKBnlfrzVJGS5LxmqoIbWNcFjSgtNgu4Eco2wK46kajJZkolaDUZYUZvbdgAZs12NSpHrNnOREt66y4FsquiTyMjGfApcY8TYSI/zlj/6av/n6G77/ve9ymc48zJGPPn7Jd3/rAzoMwXT4fuSYEofbe0qM2GhABaaYhTRMmf04sh/31EYxSmIlSZduxYdQogqNJP9zDFg/SCJXK2hNt9vxvhpEBbpxL2uM0iwpkmpCpUyNib7zLDGhjLxnzJlcLU4bKIocC9pblHFYK4ANRr5zryW4dKOoZYjEvWK392hryBqUjtiWUAQKMVSsUhQU3o/EZeY4R3w2WKXwncV3GmMS2jo0knCFXHD9jnmKpJwYfUfIgVwrc4wobSW5tYpKIBWgapzxKGuJVRLw3nWYqigU8A6nPOSKNZpqCwZNNICp1JRxXmwb0jQL3aqVAGtNxkzVTFaV8+WCSrLxnpSnlEiHl810MuPQ0Q0OjcN2Hbb5wKQKznQs89SKBQnqJSkSM8NuQNXKOO6INRHjxGAPlDhj3EhtY0N8UCraaVSOpBhJQ0ff94xDLwmNlkK4lkxJiZwyf9uXNmLZoJTGGY3phbh2znG5SJGQU0YpSf6tk+TcOSm+O+8wSgpFpaHv/VZ0OadbQiqWA1CZpwUrZADiG9VvBe5KJa5F3mpb0vXiA7bMctLeNMrEWt0Kz9Jk1Nz2uysZOQyDPB/BHxmGAe/9RnmXXLBD3wqLuMXYpXmr+U4AMJmHBVWL2GpUoRZrzuQoiZoQrODa+6/0s4AbqwdaaAWOXPOqpLP+rBTrkZwTIYovVk11ywcMfiuGQwiIlYffksQlyPhbk0zvDGJzM1HeU2xY7xE8eXWtlOpK5K/34qkoLM13rWuFpzQEtmtfqcwG+miNSGIp0wpjkX8zRrWku2xFzLJMkmhr8dmqVE6nR8KyMIxi0YES1Y+YAvM8EcPC69evyaXw8uVLiY3W0w/dJp+n0Nv9rfWJcl0bOX3XUanM8ySqEdZtxZXWmmWZmOZJ8qxWfKx0ekqR0+mRy+XEvMzolrtdzmfOpxP9OKKN5ssvf8HDwwPjMPLzX/ycn/70p3z3u9/lk08+4nKZ+MEPfsjz5y+4XCZyLhz2N2T11MyKUfy3VKPGUzuZsD63tTEi1K+htoLL2bWYlWJTfl6o4FIi83JmbiS2MY55nvC+wxrXCiZLKdIcSM0bcC3Mx3Ek58zpdNqI9XWMrI2w98f/eiJCvs+CEMUISJtTsxZRTfovtpMZGq2lsVCphCRkeggiyWet5fXrVxyPR/b7PcNuxHddOwHyRHHPlxljLdEkURTKiVxSUx9R3N89b7k2hLA04rmw2z2tFZvUm1IYzebXVWpqeX3z4VOFJs5E33fc3d1tJzKUUltDROQaHVlBinlrFq2NIHiSCcs5gbIsQeZfP8ja5rzerlPGt9x7Yw26OmLKWCUyYdJkdDhrWOaFx+ZpFmPeqPGcpSGkjaXU0uK9FKbDIFJ+MUgccFaaSjlE5mZXM449tWSM0czLTM6Z3W5gtxtxDRJOqWxSmtYajFXkXKmtmK/IM5DatrZrE3+yGDPLEqk1s9+NWCtruNOuFfuKsDzFEVmPa7OToq2H0kT1zjH0XbMyEoo8Nwuqdd0rpZBa08c2Ox5QW0P1fWB5hfPWz671iaBfX+t7rk3ftenzfnPoGsOvMfwaw68x/BrDrzH8GsP/mxHDr/H7Gr+v8fsav6/x+xq/r/H71zt+/8ob43/6xV9wWSzfWT7j7tNbum7HY7iwnN7JG/k9lsQyvyWFM17fUbQ80H68RZvmCVwzVg1Yrwg5YnXHvv+Ym+99SiqRYgopnIjnt7z64id89fVf8kd//i9493/2HPR3ePnJt+gPI3bUvDm/4vFN4PL4BafzN6RUiTww5wdCTPziy2/4/OfvuLM7/pPf+yf8T//n/zll+jO6+RHd3TI8e0Z5+YwlFs5LYppm0rTg2o21GnKtGOUxztMpS1GyaMlDkk2OYRwAOZVKLTgng11rGXwajVKGXMU/V1dFVbqRG0LSdbZtiKfy9JDb78vgETKmrRhYKxvldf2u1rdFuGBoAiZVU6tsDBls88R+bIshKK2JOWOtJYQZKozjKIGuDdTBWEpMIl/dkoxSCkYDKbEEkfsxWtP1q/R0FrnmdbO+gm4nRasO9MrgvKXfdbz66g2z0dzdG8YhQp3JUWNdR9IZZQeccYiOcCSmSN/fAIrLWTx+9zc37G+ekbPh7ZsjSlWWeWG/v6X3AyV58TluhKDSlWmaUWhQGuM82jpUBaU0qSWvynqUkZOra7BTSogahRWv+QKaugXPWguqVJE+UpolZXKVzdKSM4oKSuPciHPi3aMqhCVgnKVm8dhIBZTrKYBRFWVlIXbdyDRNOG3oXUfBkorh4D23zz7gu7/1u1iFKBQ03YQlBOYpiO95LU2OOmO0+EKoaKhkCpWhHzHaY4xFl0C36+l6Lxu9YeZ/v//f8vd++/fJOXJzI7L5Rouf92LEX1vmgSKkQs2GQianQk7NExwJmClnMOD7niVkUi4YJ/PEl8LN0JEVGDvwo5/8DX/54z/jg9s7dkOP84a+d/jYgzJ044GwLIQYqaXibIM3qkidd8pwfnzk1fGB+08O/KN/+G2oiS8eHhgNfHToMFlzXs6kXOjtgfP5zBIWxDsdSWScY38Y6bzHmg6FSODkvPqetKS6yEZqrXL62RqD7zoqCm1Fat+g21rxtKgrpRpkotG1YK3B9nu8daSWQPtREqlawKTM+XJmmcRjpyrITc1BoTDGCUTjLCiLNoVUsgAc2qAKYgWBIsUMyqC1A1VwRWEdlLRQWGX/hfiKUyDkhZojsShSFPBGCDJRyJguEW8c2ijOi3hEpZyx3kGVYq/kiDIi3eKMg1QIKWKcFbn6nNHeomsVArhZBHjnSaVwOk+EkBk6oZp3zpGVZtjtyGXBOt/AFLmXKWoepyNGVaqqLCk3ZQ+IS8AbT01JxlEImN5gXEetipKjSPV7xeFuDykxdgPTvHC6nLksFx6+PNF3mtu7e57fPWM+B5b5Hdo4Sbo0G21oraMfOrwRWSPjOpGDz5Fh7AkhUYqWMG001v7tafVSRU5/6HuEJm/3I+WWMChWOTAQGj1niSsppibrX+g7zzgOhBAJYaHr+paA141SHLp+I8Mr5b3EW29FstZabChybh5VhpIrlURMgcdHScB950hJICzvu40a3+3GJtEE3rv2GTS/MzDabgWb956cxZ5CCghpHKwJVa5PBHmtFa1477/lO5fa5khaE2shQdeEWgrw9wunp2tdloVahCqOMUpimKXwcN4jEiNs90XIVMM8i4eXFFimxSCzJXylFGIIpBbHAIFCMq0YSc2mQeZXjXWTw9okydZ43oop53wbG03hpGS8t1uh/JTIyu/RyMyc8pPFjGJrAK3Xfzw9Ml0uHE+PUAsvX36Is54YAl9/9SXn6cz+5oau6zmdTjw+PvLm9Ssul/MmTae14YvPP8cZx2635+bujnEcBT5sJO80TXjXs9vtUCiOx0dyTuzGkVxgCQvn87kVwqbdC81lOvPu3TtZk0rFuw4hmDMhBqhC+f/VT/6Kcej59re+xePxkdPxxLe//W2GYce7d2/4+c9/zjjuSSnx/PkLjo9H/uTNK968ecO7d+/4/d//B5RSGYcdWtlWyIXmjXWh5IR3XRuzTzJyUBqQB951OGtx3tN1PbVIUSJSieIX9fj42CxixDblfD4JDKQ0wzBye3OL8x3D0BNDJMZA55uyRk6knPCdY5ouHB8fRWFkGKkVHh8eUErjfU/JMjdBGkRGm3YCo7SmUqAiJw1qLWTnmv8acmqhEcoxTJzP0ujy7RTHHIOMfyWx1DewUaQexbZFmgkyfg83N8SYSFFy+RijNLWi+KY5K40u6xwxLYRZ7nvXTVsDaxhkfVzXg+kicnVd3z0VW1G1+WIISzsR0KTuYoyU2qThtNDaKcmpi5gifefpemmIrFQ7VE6nI+fLeWt0rOvl2jTruo7L5cIKzJZSpXnZdQx9zzwHcm4FdhLlHOstzj7JFep2wkapwu3NAW008yzPwDpHpzoAkWKzEq+HoSPlwjQtpBhx3mGMYhh3zR/QMM0Tu91A33VYo9u6W5pNSpJaCCfKP1lsnqhSzQx9j9JS18QoTZRpvpCzxJr11E/KGYcmRpHqk2bP6ndWWlOocrlMnKeFGMSKyVo5jeQ3ELCQ2wkF+d1MTOJ9WWvdAOP1fUVWUI6orADjLxXzReLn+vvrP9JwUdv7KFWpv1y7X2P4NYZfY/g1hl9j+DWGX2P4fwNi+DV+X+P3NX5f4/c1fl/j9zV+/3rH7195Y9zuD3y5fMX41nO4H1lqoOqK7TU6LEzTA26452Z3i7n5hHfHB0oqOKMoJOLDa8KbRxgcrpuI2qCL+Kd2Q8e48xg74KrDu460P9D/9md88lv/EX/vD37Bn//sX/Inf/Jf8X/4//zvePU3M3316EHh95YP7ju+89FHfOuzz/jw039Kt3+O1Y6zmvlXf/F/4f/5L/6vRO+xrueLNzschf3yFqvfYIxiHF4w7p9R7y1LijwcI/l8wS4TumYUBaM0FKFeKAVlTBvkUfwNavOzTYEUZ7RZfcErsh2qiDEQloXOeIzrRLq3iC/15h/RdTjv2gNdyY9MXC5sT7VCTVk2qlE01ZQWaMSTxNZKrYpMJZeAcyPUSFwuqKJROFBKfNVLwSiD6ywpN98DJRrc0zSJJ4dqXg+lQqlcgiQLc0oY60il0GtDiIEUFZd5wVhPziKTbXDYQfP82YhJcJoi+31P8YV5SXw8DHx4u8d5zdvHt3RJo6oix0y1EW0V3mmc76m6Mi1ntLIM44C1jjcPr3n79g19f4PSHfMl8PXXf01MgWE3ygLoHHrWdO1UqarghxHfD408ks1CXVpQMXJdWmkwVvyLi8Eg0jkpR1LN6EZD1gIpF1jdy3XB9x2lNKmHnOVks6ryZ0qjqiHGmVISznYElSiqUFQl5yDe2Fi6oSenJHSU89QaMV1HiQliIUyRwoLpDEvS7HcHcpplYzclaoksk5BFuVSG3QGjNbc3t4RwZpknqoaZxDxNpGkhJEXXGca+54MPP0SheT4+k6CFJtaCU3LfUq7UDCUnnHKUKtRGSJmMbCiGHNBK46yi6iJy4E7hnYUSUVaxzJWdqcw58ed/8TleW3CWN2/ecDpPOGMwvebF/jlj71HWUZpvxhIaWVYq2mhyKvRe8/D4lp999YbjKfD82YH/3n/y3+aD/S1hqbx8XrnzFRvPPJ4vLAm076lVk0LkMgemZeZwuGfc7Tjc3uBMIzWVZpW2KYXmZ56x3kMFZy0hLEK+NrmerAT6QFVyiiid0OYpEAjpItStVW0DHE1IWTa20cxLIIQzShlJPJaFzjuUFokj4/UaR5jSjHEOo4WwkyJgoZaE0kLQxtJgBvUU0EX6yWFQpKrZDR3OSIC/JOgHja4DsVYUC30H2rY1sVZqilg0uoh0kts5ua5LxWgplmopDQhRT5JQOVO1IsSFGjLzNOHHnt0woprXvK6Vy3JB1YK2ifsbTWcLNRpyWrB+JKHR1nOeFpY4c5kDrvfUWDjPF47ThX0/cru/EYmvYlHWiHVBzRirUM5xczugneJ+d0vNiZQrYY4sU0DVwvHhFfvdgRfPPsI4Q0yxPdeCIuO9wbmREBO5NNmqCs72MvenQmnFzhIWfGe5ubnlfI4YJc+0VElqjX5vnPx7vlQrNGkARG5wxFo85mbrEEKUMaIMVM3lfJKlzFSGoRe4o9I27Z/+LQWMJCNWx61oRIPiSWYNhMRdic713zlLMq80xCBeYJfLRKVye3uDc36jPAX6Ewo+pUyMTSZNrz5PlZykkFoLYykcI03BCdUoeW1E+shb3ywBUqMjpTDNtYhUmDVCRDsHTSotxcS8LFtRbo0H1ZJgTftc8QuLJRKXQIiRJSwsYeL29rZJ2HWtwJXk/Cc/+Qld54FK1w28fPEBzllyFkIz50guqV1bxrYEXmtDjOL1JTS4rCWrF5d3vq1Zkl+sJwfeb5gYo1BafNzEm0tAPYUiloj0M/QmMRUbaW+M4XK5cD6fGYaBvu83yat3797x6tXXUnQU8Y5TfMM4HqBUbm7v6MeRZVl4fDiKpJj3fPDyA1BVCjXvybHgnKPzHq0trpPrkEZF5eHhQa5pZ5nnWbz5lpn9YUdMUqApYzidj0yXSxtbt20cRbx3GKN58+YN1lr6fqCUvBXxMSZub0Vt5md/81P6vmd/sydX8Tn7/vd/h+9853sotUrdFXJOvHr1DZ9//nPO5zN/+qd/yv3dM56/eLkVBjGKYoR3Dt3sRtbnkXMWKtkI8h1CaLlYoFQhnI0WuHItHHIWMM53VvzmkhFps6pQ7X1R4uN0Pp1ZlhnfidpHqE1+z2liKLxq99Q7z7xS2FYo97CIJ2DOhZRmtFIis2UEKg1x5uHxHWIdUlDVEExEiRwKOUlzSWuFsVKAzscjZmqnBGLheHqQfHYrliolJy4pijSX70WFZBZZt0phCTPH0wOPj0dqKdzd37PbjVgj4+Xx+MDx+EiKmdPxhLGWaZJTDLvdQKmFvu+3Uwxd13E6hY2uFgJbmkDLLL5zSrPR82sDrVZF1/zirO0Zhg5t5BkMnfinSQGbsU5zuNmzLNIoWP3O1sYR0MZkzzRNYsehYVlCo8pbrlCl8RenjPVGGgNaUbVqDQnT1hVPSlmUV4w0EGrO9H2HUg6j2eZwLRVvNLmz9H1H33mG3mOt5v72wG7syaXy+PiI1pbdbmjrbZIcPmeWmDZ/MlUVnXNopXBOCt0YV2m9wDIt+M6jlOQ6tVTmZSZmiQtUxTj0rP6PSouK2Pky83g8E6KoP6lcKFnm7mE/Nn+29F5jo7TTHqsf4hojnxKxVZ5wLcLXn9lOGFDbeGZ73/W/1+alfObTCZq/7esaw68x/BrDrzH8GsOvMfwaw3/zYvg1fl/j9zV+X+P3NX5f4/c1fv96x+9feWP8+Pk3jPsXfP6Ln1PDwCff+RDbV6p+TvGBEgOvPz+zxBNz8GgnR+lVVWg9cX74G/QScOdbXl8e8cM9N/c7yvwWowvHxxNdf8u3PvsuuzuLHyzGeaqz9P33+Sf/4Hv8w9/5H/A3/+H/g1/89KfoohjG59wcbrkbXjLs7tDDDq0OFG1w3mCr4ve++5/yn/3zP+XHf/z/4lIvUHoClbfhTHj9X9N3FmMt3n+AGz/B7kbubc/FV95+8cD+2S05XUi1MocEVXwHFBWjDcb0uM5QciAr8fEFCCEQCsScGuGhKTVQ6sRpOqIWi3MdSoFp8t0inQ4pFPGgNVY217VB5afTgkqB9pbcNgBVlUW45CwyxG2yqapaQM2kcKLWQt91BFNIBTJJiIyi0QpCmkmpULegoKEqcqmEHClF2ABNbRt1IrFciky082WSSaI0GUOMhZyF/vPAh89e8MEHNxzuLA+v3/HFl2eMU6S5sO9HfN+JR0JvsFahlcP5jPaGgsJ1g2yqUUkxsCwR4yunaZINKRSpiOz4zc0dN3cHnPXgLUbJfcopbnIhaI3RlhAypSku51gaZKK4TBesM2idiVMipkSJkel0QgHWyzgvKTYJmbJNTKUV2hiUkedWc6LUiNIwxwWqJsfSCE9ZrB7md3hjMYtm8L2Qo0pBOBODpipRHjDGUCmkJbNE2TAb9wNUoY5qBaMK2lqM1tjdjlwq0+FMTJlpWphDRCvHeTmxzKnJ/mhSTLiq8L3DeMVdNzBoDzGzTJHdOEApOAwmK5QznOczNRWoDu8tCk2tiaoztlOQLR6FU0JVlpp5fDwy9obXr99xs9sx7EeW6cyrr9/y9nJh7Edqrnz15hWv3r7l5998w5uvX/PDH36PTz74kNfvHpn6jhf39yyXiWCCjNVceddouksIpFD48tXXfP7mDTkr/vHv/oDlnPnpwxtySSSXiTcH9tXy8Bi4TOKxNIcTVWnmWRK5+2f3uE68omMSkARdNxKXCrUUlNFM0yyEaxbgJcUgY04bYspQo0iy10IqFbOCFDLsmr+GwjQyNYaFqgy5SKDLWTznta5YZ/FOY40mxIT2jqrEl8Z3Awrx4KnGEEJiCQZlFDknlOuY5nPzeZdkLYRA7R01ZzqrxJ/KGHbDgYfXr5mXQvGaZ3cvcbWgfeWydLIZjgTDyzRhEO+bSxJVh4O7wSjIOpLjTFUK6ztqTcyTKEHc3T3Dup6h06QQqHPGKMV0PJFCwDpP38izwziibGXfd6yqGaYr4CyUQIyGXBQCAwd8NzKHjPGaw80dv337LZbLhNOWy3lhDtD1HhVBk+j6Hu8tKSqoitQrVFFY74TSDPB4fuC0zFxCoDse2Q0DxvX4zpFLIl6S3HudGPueXbeXQB5pvjKSQGWEZlzmmbu7Z1zOGaOzqCJ4WRNLluLtb/uyxoq/ViNgtdKkkqlV1nGx+5A4JL4yukkQrR4/NBiorMOUUioxLWhj6VpypbUlVynqxK5CZI+kmHzyJ1rH2pr0rAnSMAzonW5kd9gaCSuRDpBSEUUOjXzflBiGrvkCCRW4hLA1HFKKgMgeSXEg/lNCuTqxaUgiwVSo9OMgxY6zgLyHc06I9QZ05CywghBVIiMmlK68r5DY4q9TcmaaJokNGFSF5/fP6IeeWkWJIWeh+pdZZOpW2Sznztze3tH1nVDBqYonVl3J99Io49xOGOTWXBEKtQ5SUJdcUF5yspwyWQk93HUdqyRRjJFlEd+yFBMpPSK+WOJ5Z4yWuJPyE9zS5L5ijKKwsQic9PDw8Euk7SeffGsba1QhOI1xlJzxncNYh0i4LdR5QlvL3csPsM4K4aobWZ9LKwotpcq66ZokW05iYbBS9imL3N6yBF6/fsXj8QFjDV9++SVff/01xjh++7d/mxBmvvjic7TW3Nzc8PDw2E5feO7v77m5ucEaQwgLQz8wzTO/+PxzYozc3d3xgx/8Dre3FVMdvfeEZSbHxPl8wjnLbtjxve98H+8tzglhbowjhSAApdJUYze5PSF886YQEifx3HNeJKlyThyPUkynLBT5MIxY59s4E4WaGANaKfa7kTIMbQyXlu86lK4CfWoluVEROyDrBNQ5n85Q4eawJ8bI4/GBUgq7/Z4CIktUERWPuPDu3TuWZaEfe+Z55vPPv+TNmzd8+OEH7HYjNzc3bR4veO8JSxDC3nh2+x2FyhIWCDRPRaGNQ1g4Hh959+6BWqVAd1Y81G4OB6Zp5tXr14w7ob+lQG+Sk9bgvePm5oau6xr5HEQ1x2eGoefu7o7T+URKkgflIHCg0ooQFqZpYlkW5nnGGDllY4wVz7u2Njrn2e1k3lZZEmS9UnYjykMMhLjICRhroa6yYIphGFEovAvUorYTKdJ4K1R++UTNMPRUKo+PD1xOp+YPKX5yIUQu04R1q0ym2KqsjYTj8UitCyDNtWmasc7SeY9CmjWrx5r40yn2u50007Ru6y4ynxFvtJQC8xKY5zPzsgiFrgTOLSkRs+TIxqyWUeKpl1o8mqaFlGCalvY7hblIE2RaFi7zvK3tWkICh91ArfKc5yXycDyyhKfCuVZFTIXHx3Nb6/VTLGxxcT21s74EYCzbd1zf631CPTdKfT1d9G8X4/Kc1j+H9+Ux/y6vawy/xvBrDL/G8GsMv8bwawz/zYvh1/h9jd/X+H2N39f4fY3f1/j96x2/f+WNcVXe8NUXv+D1K88XP/1r/uovn7EbO4xLHE8P/NnPf8beHtipid2LH6DGEWXOnN/OWI7E8Ih1e7TK5BSoWHSEQqHqRI4z93efMT18yQcffY8XH3/CeCc7qhqFUaD9M779yX/Kxx/OlJogGGop6OrpRovyjqLAloK24rehcuaT/Q/58D/4bd69+2vKq2+Y5hMd4IeB6jxzOHF+/SN481cor1FqRwxwedVT1G/hnynZMNEgns6JkoQAC2lmSQZjPGiRGtHaoLSiIub0qcykrOh8x268QxuHs0JrVGRzy2g5hWydo6BbIDRtBFYc4yZ3ILvpDqWEcFOqYquiVI2mysnGKqSKUarlDZkXzz/h5Ycf8+qrH5GSbA7HmEhJiArxvF5lfBzOOZSCOU2N/jPkVLGu+ZVYoaGUkoFuWuKGtXjrmKYF13m8s4x9z4cvPuOz732bqgr3t4989eq/YDolLo9vMSWRpkz1FULEHQ5kRAraeENBY2yHNx3DuKNUkccQ73YwVqGtxjT5+Kpkgz7lTGL1rBCqZ05RfKBDpGv0TlaZkBMlCtUXUxbPkzcnCVZKU0sEMmGZ6HyPohKWCjViqmWJYQuk2sjzFKmUEXJ9ksFQivPljNIGU5r5h3HsjCLEzJwq03xmOs8sS+B4OhLiAsbg+55h11FK4MYPRCKuc4zdQE6B4+lMzE3SPkXGoce5DhApjaEbuDncU2ql1IRzlpgT3mi5ngrGWUpK9M6hrScslfk0cb6ccP0OlKYqI5u1l8if/uGfoF3P4dlz9oeBw+7AMHTMy4mKJqN59/o17755y8effsr/+1//IfcvbvnWJ4Xj6S3P7p5xmQrvHiM/+ZtvOJlCmb7GUgklcVwWbD/w4pOPWabE118/0DnNazsRZigxM6WAbj4vx+MJlEiwfPn6wpvLBWMKDvjxX/2Mb37xBZ988gH3dyN3hx3HVEhuJClNLpFljnz99i0PpyNaO77/ne/TDSOlASM5ie+KruLvo6okjbEUyLIIO+NISYqK/eFGkq1SGLzBWUeOATI4L+vAykhRhaQlFYquxJDIIZJVYmqb8EsIGK3Fk0XB2PfMYQFtMMZClQCUmzxLjULNzSlCFRuAGBJ5KZJUaVHBmE4njtOZbvBQZE3x3qCU5dVreZJ/+Ed/yGNJ/PP/4J+hlsTtzT3VBGw79XychDA22op0fi4MnWX0lZIq5yi+S0uYCaUwh4CqGVVhniZQgQMDOSastewPB2opTPMEpbDEwGF/h7MCn8RZNcgloZ3GW02MPVpHYpLxvT+MT6etdUFpg8aw9wMKxb6LfHM+kVPk7tnI4Aa80ZA1UzoTUmG+zPTek4JCFUhpIeXE/d2d0NExE2Ikh4wJBa0VJc5UMsopgpKk2xqHMxprNTEuhDyjEM+iznnO5yPaep7f78k1t6KtUKskiH/rV6no5jGTUhL6WhuWeSYQm7ybWHeA0IPLEqnt5523jUqVnzUrkVsK6EDthCgehoFSylYUaqXAuy1pBElchHZmI5qttQzDANAoTYv3Ao4tc0BRsFY3ijptck6lhK3YrzWy+m/VCnS0wlAkoHKRAjmnjHUOVSulzdFaROaOXEghtsK0YIwiq0KcJoFSYpLrTkLIliJyQcO4Qym1FcVwwShN13mB1lryrY1CN9p7bt5qSinCklsyX7i7ueH2cGAJidPpxMPbIzmWBtflRkqmTS6OolE6iDcXjX5u0loxRqwx5JJYlks7mVA2lYqVxKy14qyjVsU8TYQ4k4qQxQ8PD5yOF25v73n5wTO00kRS84N78vzx3uOc204lrIWVtHAUWks+ITJVRiSntCIGaZoopRj6oZ1eSMSYMUYUhFbZNa3N1iRZk+GUIrVW7u/ucU4K/NQ8snLOXC4XQsrUKtJjn376LT755FsoNHd3d5wvj8SYuLu74/nzFzK+jKUiEoPUyuV82RoD47Djhz/4HVmf9nuePXuOMwKEGaPR/YB1QrsbbajttEZKgfUEQylFaPOQcK5jHEdKZRu/MQZiWuj7Ad91aGW2YnmeZ47HR0opDOMoMaSdvpAiVzNNF37y0x/z7O45n3zyqUA+zbtMNS+1h3dv6bxvBPSZGCO73W4bDyspfb6cRGKuSoNubaZ51+x90tP3fnx85O27t3z11dd89fUrcso8Phy5vbthv9sxzTOn05H7uzsp/C/nbX6uMlkhRPb7HYf9LcPQc5mE3k458eWXXyMSch3GiDWOd6LasoSZ/X5P3/f0/cAmm5gLl/MFrRRd1/Ps/hn73V6sR1oRRRuXwzCwTBPzMm3+Z13Xb9Jkq6zYPM8450RGsDUhp+nCMi/0zUdRnrXCt9Mvne//f+z92a9tWZbeh/1mu9ba7TnndhE3IrKJzMrqWMVisaooyRRl0xAlmYBt2IQtGwYkCPajAfvFz4Ze7Gf/A4b14gcbgimQsglRJimJpNizsrIqKzOrson23rj3nnbvvZrZ+WHMtc+JrLQcrCKMTGAv4Ma9cfY+e69mzvmNMeY3vo+2a9BKV2kv/WA9lGRavLfkGIZBIEvf+zjORa+UY31NHVnbpWS0gW7RMIaREBLOic+gcxrvDEplnJWuH9R9giysbZmTMw5IF4plmgK6jr0pBOkcKLMkpmb27lp0C3Lua4FV1bmZiFkKeV23YvaWHEPk9maPdVJISDGB0vimORYEcs4c+pFDP5Ky3EulIJdCSkUUoJDv6IeREB4mvaquKRIH9cNE44WsB9XH7EGyPUsmzvPzoRfZnFQrJTmd5Egc79t9sq2Of8s9KcfCylGS8U9ynDD8hOEnDD9h+AnDTxh+wvCfPQw/4fcJv0/4fcLvE36f8PuE3z/V+P2FN8ZRPRfrzBAiut1xO75mN0m33hAv2S4bzpqezfoZN6Zw+eqOq6s/xITAVx5rTFZMcRQZgHZFmK5JLmKKY7l8Trvektnx0Yvf45NP/4C3P/0a7zx/n0fvvoNZJKwRH4u2adjtCyRPVhPaWCIF7xSagsegnSyEMUWMUajSoGzh/PHPYxctn/7gO8RPP8Mvn+CXa4a7T9jv7sh9Imcw7sDd1Q/Q6Rfwi1+iab2wptREiBPGLik5YLSiKEuIEwpL065AleNkatoOpatESwJrRLY8hFKZXwXxJTEoLSyycYwwM20UzBIBcC8L89K84s9+5S/ykx6xQtWfC0vt+Lv1p+GXhXVDkcFY5IOPC8gf/cC62y1j/DiQqVIcx2Go7uUPCjNz49h8XSUb/hZKSzerVorwP5gYg8gqfFv/pxijK3tEmJPM31WvjB+/4lLk/Cj1ux5IMKifcC31Esv8e+XhC5+/xw+/4yEbhZ94Pp+/d3/0TEv9gXyvPKPy4N2fP49S6U7lJzxhpbQwRUt1ENfqeM6qEi3k9x/+jvrxD/ncuX7+/9Xnzmz+d64+FSmLAsD89GOKxH8/ynk9/Jz67HT92RREJqpQsEY8tx/KW6RjcIiQSubnUO5Peb6s3+a7x2tV9YUyX+dxHJfjLT8+HSVd3SUXQIIOo/VR6gREUrwUqpeMBKp/U3/rx+5ffZT19I7XXR6e7Offe3wuP+mZFNitD8fLzbqQyfSHCYXIY7nG0RpDIYIWhq0zpo5PhTUNwzThSyJMAa0Q/5IQKEqx73u8tSLNpMBYj9VCgBjDBFkSJW00+2FAoVk3DWOcBAjv7vjKu0/5N/78n+Wv/xd/i9//3rd5+9Ezrvd7nlw8o9GZGCJTimzONoz7HcNuT7taYCh47dCNZmxH9tNA2zSkpNiuz1BKNtDHaQIFw+7A9d01IWUWTcO67QjDSPYGj+Ozz15ycb7hbLmkmIi1nvGQ6ZOi3x/o04FFt6VbrVBa5MjGMNF1FqUcTmmUsYRpQqNwi473lp65452iKNlgtcL5jqwtKguRRJvKVqPQdR2qJMZpIutE0ZllJ573rVvj9IjWljGArjJcFFNlqIywVjfn9NNIyRNGeyEY2BatM61tKMUe14uZHfjHObQR/61pEs8Zne+9WsRjKWJqgKHRlJyrJJNILEmMUgM4dR8kWkAZIV7MY3r+POckGXc1AZzZlikljBHi18wGNQ/sBKZpYrFY1gRfrnmskm+qfvfD71BKVZbo7LFWZXdKR0mVXZ4TtirYDMOEjvGYGOqqJjKvKTPLehzHoyVKjiLnFqYJ7x0hJMZxlHMqCT0NEtzFfEy0c6myTro8YEWKysQ4jjStq4GrzJ0ZZwqpBuearqk+Xbe39bpFtQatiEZk2ChgrZOAPSWmcRJmvSoMwx5nTS1wZKYwL0CaECXAzjlTUvXNco4QB0pJKAUvX7zi7/7dv88nn77g4uKcP/fnfp2vffV9QLNYLoUcVyXv5kSk1ORtLr5oPQelco+99/U9BqMdqm2rCoqMtWdvPaPv+yqNZ0UxoXYzzIUh7x1KzZ8rsls5Zygz01e82pwrONfw5MlTjt5dtWgQoqjDhOkRT58+Z9F1KG1om7aOT/HQur6+puvW5JS4u71FaY3ferxzGGMZ+4mhjFgviXjbtHR2KeSzyuRXSuGyrx0Xco+89sf70bYLhnGkVQqtNpSShbldxB7HaIv1hpwiIPeuUOg6If3MrOJSCiknMlmsKWoi2TYdoFC64G1D34stiW8aXB07RkshLCb5LOecYLGC9WaL955QbX+maZKiQ50fKFhWRvOLlx/z9vNnrDcrbq5vuNvdcX39hss3V8yeY4f9UNcHYc1DqeMk1oJSoWuXrFcb2rbhk08/ZRpHnLXs9yO73YBShaZxvPPOM7761a8IARFhjoM6Js6qIBZF1tFXibSmabBOCokhyvWoAsvlipyFFBmSxDWr1VoSxZRrAi6SkMYIrsySXpRC2Wa6riPEIEUN7/GuJQSxIUqldpOE8cgkL9UbLaVEThy7TeY1aC5YWmQN2W63zF0izlX5y5r8HYucO8s49tKhkBNKGZYrGSvL5eI4J2U+5coETzUmyxhtpKOgFmDmtb3R/hjHxCkyjiMoRUxS8Gm8SL01jb+XgSwFpS19PzKNIzkJhk5TYpxqEVNJ4cBaUaGKfWQMgcM4SOG3RkdzTmGNgVzop4lxmiRxTw+T8iKoWdfUEKLERFo6d6iFvXnOHHHyQTI+vzb/yaUcE/LjPajF5Ye/A/f+ePN9e/jvP+5xwvAThp8w/IThJww/YfgJw3/2MPyE3yf8PuH3Cb9P+H3C7xN+/3Tj9xfeGJ8OETykaURnYbvFcodB4fKK83WDKoZu9ZjLmx+w8hOrs0QfZJG4GnpyLngH/b7QtiucLfimQ3tFKAOqaLpFhyqZl69+wNXukueXV3zlG1+jORPZ6lQMq9VCfJCjyMF01qGNtM3HHLFaWFJaGXKqHdVKU0icLb7K4uef8Wr1j1B3rylTICbxlS1pIHNDySu0ajDbDevH5/gMmEDQDd2qg7rYysa1EVaV1tWHoND4BuqmoEbYWtYaQoqkJF3hRmnQhQzkDDFLZ3xWUSQytEySlIK8V8YZAFllPnWvvuij+/zhgMUf71f/5Ef///WV6f+PZ3E6/hjHH1/F+Y8cgT/+Bt+/zCMS/3++Z/wC7/mXexTGKZAj+KaVdS2LP7lJmVQKi7atcusSNE4poY3CtxZtDU0j4GyMgZAqMcWQMhjtMIhSRz/0TFMkTCMgm+82O6xp0QVKjljbUIrCN57v/ugTnj6+4K/8m/9jXl9+ypBGbu5GPvr4h2Sj6Q8BozWPDz3PHz9lF3vevLnFdw2ffHbFom1ZdS2H2z22SxwOPednjwGD0ZacB1HjUI5FtyQVYZwa61k6y82wI0yZwzgxxMB0GNDaU1KqUjLi154UKPaoAkYrrDOyuV8MpmRiUZQYUEahjWUYRmGZ1qQvxwwqkmyBYiDPpAwhKejGsvCakgIpZxq1om0CTaOI2VPiSDwkPn71CVe3I+9++R1heBtH0QWtpPPbOk9RBWscSoPZNrADpTUqTkw6YTKUWChe4x8EDP+ixxSCqJQYjSniYSUsRwPFS5ADeKVIKWNdZd5qjXOSTHrvcMZUnxhhTXvvMVawN+fMMAzCPIRjwC6Bzn3kInJhUw0E771mxnGkq3JTSlFZyFmS6SqLY4zmxz1qHnoBdV13lD4KYazsZpECSzlAlgR5CgGIRGMI00R8IDGnRiG2CQNXJO80mmkKDEOPbz2qFi5cK+MvHfZHxrB4xwmByWhzJMxM08QwjExjqImBBy3Sdzkn2q4BJcmJdV5IOllYzje3V2y3WxaLhST4zh2TJhDC1EzqiTGCynTLRSVWUOXyJOhURtfiTMDaql6QE8PQM4VRLDVy4M2b1/z2N3+HDz78RCTChoHvf//7eGtZbzaENLFeb3G2wRjDOI7HhDylOWmQxAeoTHJ7VMqBqjRjxJ9MayXk5xSkm6BK40ni6up7OFoKyGt8rsthsVwCsN/vj2ugJAdQykAKgWHs6bolrnZQpGmi9Q22ysPNfzQKrTPeN3i/xjeet5+/W9nC6TjOtdYoTSWBKax19Zqr7FQlMM3FIinYCPEqpYj3LYu2qyx+WWNQkKqsWAjjMTFQlVDTdh26qgyhMtZ5jLFYZ0lpYrVe8PTxYwpyb2POFCWyUzEWnPOsNmuMNZQMq/U5jfeEGNnt7ths1mitORwObLcXNN4TY2S5sJ9LViTZMLUbxeAaz2LVsVlvcc5Lt8XtNbu7O/aHHVobVqu1kIpqgc45fyzQHQ49Mcpa1biW5XLJMO65vr4mpcR2e87tzR2Xl5dkCtvNhs1qy7JdsF5tKSgWywU5i7dU27aYKiFpjOJuv+Pm5haUwXspBnnnWS9krbPGVtxx7PsDcz4YRpGF1MagVSYraoGsHNc6kWUUOUVjHsp7FYxRxDgxDuLTJUWPBuk+mOj7vna5IAWOlayDMXZY6/FV9SeXhPf2KNk2DC23tzdS5KmF0ZQyq+VCrsc5msaJDNuyJQZhTcsaq48SdTKOPTGGOv5MLWyV43fFeC8RKfMqEVKSe1Y7A8RSKHF3d8dRUnMQMt4YJ7yX9TGGhKlrpdUWUJQCwxDox5H9vifERCmfT2SVUuJrp2vXxv7ANKXKZn/wvspcnEmcIOujUuqobgP8xOT52MFA7eYBMuVzY/6YqOc/SqZNKVGycJ4fJuIPC89/nOOE4ScMP2H4CcNPGH7C8BOG/+xh+Am/T/h9wu8Tfp/w+4TfJ/z+6cbvL7wxHnPERUOOB/ZZUYZCZyyqbbAmMhwGlO745MMf4FtDzIFSIq0xGAsmW0rO4rGrFWMOtN6TsqbfRUrIMpjXDdYlXJfZHa757vf/Gbvdga//wi+wfrqmNBacm21FhB2mskiqG4Mxrg6GeGyzB/HTNrgK8o5nX/rXiMMdu5vvYe0di/WCMmma9QbVtsT+lsb9HO7RM0xJOGtAe4wVj4iUYr3RFmMcxggLIsUgMus5MI09ZRwosYDSWNPgbGWVJFC6oEuEumEV9IRWmtZU7xAjLEOywmjF0/QIwo/1I8+NtT82MI4v1Z8rVd9TF5Nh6Mmx1Jfl/B5+7sPf5XOd51U+WtUBnEtdzKQTOhcBgJyELaeKnG/jvMhiFMhJgqqYIk3THSUfHh6f+3/18Jr/aHezmhuF+Qn34Hj99U33b/7cNT3oMZ4v/sE3quPiilKf7wgv1A7nB6f68EN/0vHwteO/1f3VKYT5VL/7c++9v/gvdHz+XMuDE/xvOLf6zfdjQGRGSpa7IgzLSEjpuJmo9f3531/SvNDdf7aMGfFOLz92Ufcs08+PZ/Xwv3M3eb0/x+eLOo7v+TqPCgKqBkz1d1AKVSQgymmWVxIQLRQeyqbUqOdzrKZ5bM7STA87+9XD73l4DdWU4ziOUD9xjKz2K5xvyKbUwH9e/IWt6UxbGWaRnGXxR0sSkrJ4MuWcyTGRMqicKSoT8ojRDVYZppi4urmhXbSYRtEsVpBhGidaZRinkWIKy9USbSw5ZpQq6FT46JOXvLKXfP1Lb9M1nrubPT/47AVDEpsApeFHLz7mtt9ztrnAZMfN9S0pTOiiSbHgFyt2w54xB+76O0pCGM05SVJiJIjSjeN6t6PzEZUz1hh827BcrVEUApnbq1eQha2bS6bthPUZ4kReK7abFeIbo7EaWfNIlFxwRmRxUooiFZVEBsd5TSxiizGOPUYZFBBiBFVwGBIZoz3O1sBqP0HUTCUQQ8b6yOr8jMXFyPbMse42lCxMxxjDkS0Ys8apQgR+8WzDmG/45G4iWpFyd04TVaqeN38ykkZBZMm8b5kVHkROShKce5+XAlXCfZYDk6SuMHIv2aS1IZVC2AcUitVqUZNgCV6FJRjIWuOr104ppeKyOrK6Z2xS6l5SSJjO8SgNprU6Bkree2a/tBAmSuHIlp6TuJkRrHUCwjHQKrngvOCrBJHmyCgeKzNT3ncv2WSNnHvMCd96YkwoXeXys/iBtZVxHWPCWl3Z55BLQhfFOIzHdWi5XKCM4G3O833IaKOO91nUU+6vyXeOzXojrFXroOLv7MtmjJH1lUJKgUKpRD1J2FWhFlEaYhILksXCVrZ6QeuCskL0A41Wha5b8Yu/+Iv84i/9MovFmuWiw5pZnk3WL6PlHKdxgiJeZnMSnrME9HNhZma2qxpriN1I9c+r55dSQqVE23bVYy0en/fM+p7viXPueC4FaLvFkXk9s9eNMVhjhVEbJ8ZxwDrHcrWsa0ahaVtiTCyWS5q2lURaS9FFVcKjscIIF2kzL882i8GXSHLJuj+Tc2aGvarrWclZPOaUEnuLOv4UMv6GaazMfENMI2M/CrYU8dIbpx4oImmoNOv1+liAUVq6P3zjyUUImylGtLN459nt9xhtWHRLtFGkMBfTjBRPkJhYG02eEtvtlqZp2O12KKVYLqRjQmt7TGBKLoQoKjCSkC+wVtO2HWFzXpnjiuXyjLOzR4z9QD8e0Nqw3mzwzjOFkRAmGt8yM3zFpy7Jc0UT4kQ7NTjfSmeJUWgFu/0O5xq6diFFmizs/pSF3T/juDGGFMU+Ixdomo7Hj1psnV/zmpOieMqlDOM4cOh3lLru9YcDJRWUkeJLipHb21tSlIKhFFcS/bDn+upaiitKsdlspHNhscA7KQBZZymKY8wkxQIpJj70L5vHuRRGLUqBq4UeKVbW4qkVKTmQolfXdazXhfyo0Pd99UiUYmOp91eS63sJu3m9TCnU8aNrISNTcmIMQWKVksUqqGa61kknSYrCHJvtSoSZn3DWk1JBa7lPuHLMG7w3hJjIKFJMTFMkBvGXnKZITJWZXmOtUkSHShS0CiFGYsXTnMsxrBcinBXPPiUxlEjU2aN60ewjKNgnsWQqcg0lScw2Y838LGJOnzuX+ZjnAnOyXq9PGcGGzxevvmDQ/t9wnDD8hOEnDD9h+AnDTxh+wvCfPQw/4fcJv0/4fcLvE36f8PuE3z+9+P2FN8abFkoq+Lbj7m6g8ZqYI0wazIQ2htvDLbu717z9+C3w1TydQkiZxq1QU2EKCW0aFBZlPTEfeHP5GeNdz2q14Oq64ezRW7LpnTJt0/LBi3/E7e1H/NI3foPH7z2HM0XbNKi68Op6Y+YWe6Ay1u51640pFJWhaFTxGJWx7Rbvf5OzJ78ur6EwiOd0BoxKcouUQmGgiNzAzJwT4Fey86eE1aCKQdXXcsnEHJmmA3E4kMYd8dATpxFKhugwbonqgkizTxZtGmK9jhwCYRqx2hGV4j/5zv+ZDLStQ5FIqVTWU64bfUkWl5wxykCOGOOIWWS3c4Y+HeivX/A73/lt/uP/51/jkw9vCSHQWEfKEkylcSQOgaQsbtXy9Nk5X3n3Ld56a8Vi7TjbXNDaBZ1bkIrGKI/VCmM0KcHd4ZbdzY7b6ZYYRg6HkZXf0Pglb65fswt7tu0jnrz3nLe3j3C2IWbxaQZDt16QcsRrzWKxwh0XsuqhnORep5JkQ1YLw00rRBpb6UpEUEhvrDD1DIaiE8YqSpaNU02pIDaB0miryWUOqAraWPFLCRlTRAUgp4g14vk7DL0s3sZjrJXNq5RprOe2H8k5HmVVHj16jGsaSJHWL+UZlglrHSFCMQkolSWnZVHK1A3S6uGDbCpb66rnjSziuW7O5pzrPZi3kysrpwZuRQmxQRYL0EpLsGgsmep3ocSvo6RIComPPv2AH/z+7/EP/sk3WZyd8aVnz/lHv/s72G6NKpomF7r1ElUSrW9ZLlZY3zCNIxrwnaE1FucN67MNd29uUApCUSgyrXOoPKLzADlzFzJjzoRSmEIkjAMGRSqZRbsFElYLgaaPgTFkILDbj0DD9e0Ny+WKmEaGw4gzlkXb0fqGkjTOFlK44dvf/Da3tzdcDpEXb26xBn7t1/8Uf+aXfx2bZSz4riENI9YYdkPPFDO5ZCjSxd04CYSMtRjvaJwjxkjSVeq9yHtElknuuzaGGNIRZHIuaOsZQgQF0Ua00sQYKgGnHBOEGMU7SmuRwUIXlMqMQ0+3WFBiwhuDspUpjCflgMVB0kwhMkwjvvGUHEhTYJwSV5fXnG3PudndcXu44+zsnEW7Zrg94LSwe7erLW0aOcTAjz59iVOGKWRWmy3P2pb9biRTeProghgzwzSglGa5XqEUkDPLZQsFHm/PGeKIMoacoW08+8NBQBrNaiFeKNuLx7J2GVDGoCt5IsZAyomLx4/IqTBOE/t9z5QSm7Nz4jSxP4wM/cDZ+Yqz7QpVEiAErBDEP6lrW7K3eOvQynI47JEIxHJz1ZNzIIXDUbILo0DdiZS9XdIsoVt6tIPDoacfeqxbktJAt+gw2uPTFoMipgz5nu2mlaKEwKQKC+354R/8gD/9awdWLy/4vVcNzcILvphCmiKYL+588pOOe2JUQlcrjPsE+97rRpI9Iai8fn3DUfbI3ntiSZJlyDnVxMmQSmazWtJW5ZScZK6YpiHNCdccBNdgfg4OZ7yevWJmj6yjd5kqR2a6BHW+BvGSnM2J30PyijH3hYD5c2OKlKkciS+zpNjM9Hz4Z75n1grjWytheucahO0Pe0rJOCufkZN4kM3eW9bKuJqmiVhlB7pVJxw0LQURZ71gk1XH7oBUJZFmprck3BJ3PJRLAygaEkkY9Ua6ELbn20pW88f452Ggr2LEWiMqBcYwDoHlsj0m8fP9Xy5XPHv6dv09z0yImpm4832XJFaSC2vtMeid76P3XmIjrapcVjne90I5dipwJNnJODfGsFwupbtgmmiaBq31kS3r5rU2ZZq2xXmR99Nas1gsKjP7IUFyyWa7xdV7OnsWrZYrCcL1/dicv6/rFlDEHieGAKUQHiROn0vGa7eCcZZZUkvuA4zTyNXlJV23oGnkXql6ja4WLqgJwjj09P1wHJNSnPFAJBiF006KD9PIMBxo2wbX+mqhoTGu4264AxLOKSnkGINznhAiTetomqaOi4B4yDmGYU/KgUZ7QhAZMeeamgyCKZYYZkKolq6M+pznMTlNscowLhA7IIVza8HjKAnh/DwUipzKUbKs1DHedjI2jDZoKwUObTxKQS4TRgnJTCuLNU4Ie0WhtKVtpGCT0720oNKSJMoc8mCrgpSW8UwtbkxhYJpGrq4uubmRGGX2+GrbjpiSxF+lMpKLoh97PvroE3a7QyXXJYxWXJxv8d7RtA2r1VKS4RxpuxYXc8WfeFwnZmnKWRJRZCrDcT7Ke2yVwYvEUKSzxEhCPa8T0xTq2inr1yzbKaRViS/n75rHuKopjNYOVQsUWluGw0Cc4nH98DW5jykCsl6FEEg203hHiIkpzu+3FV9E7s7UdXguhM7k2pwy+/2BoR+PxcgCGC3dK96J/GisMnlKgSqFME0YV5+vqlYjuVTpRrHIsdYcE3GJgz+fVOcsXQcP8eFIVKwx8py0SxG7vqRnX7NyxIKSyj0p9EHy/TCB/0nk5X/R44ThJww/YfgJw08YfsLwE4b/7GH4Cb9P+H3C7xN+n/D7hN8n/P7pxe8vXGnXUyYQGaeAjZppnNinwrIrLDoNGXZjoE+RDz55iTWR803LYt1yGCc++OSWFDzPzxeE0jOkEe9g6veUnHnryVO816Acu901mMKwC2w2Z6wWK/bjFd/9we9w29/x7pe/hDpfoxtHVtJtqI0CKvsmpeMiOU+sKYIm0/gMJVOKGN9rk1DZ1c3uQFZKfp4KSjeUFMBkSjEUJQunRgZTmR9iEU+YWTYdpShKJEacaUSCYXkmC3oYCNOBYbhjf3uHmhIMEySRXolDFAZIToQwElIClbBF4z0kCtMIuoikCQo0MvisdSQV6+a9IsdEURlbMqlkDIVVbMmrFV//uV/lf/v+VzgcJvr9DYHAMEyEqfD73/8efRp5/tZz3nnyNt94/+d5vHmENQ7rLSXBNIy8efOSm5s7dvs9qXhy1lxefoLGcrG94Il5G+s0Q9wT04BzHU+erVAe1s2abrHivFsRSbx4/ZLDYcQqx9n5cwowHUaCKTTNmmGaxBe4KJxW5FK7fJGN4EZrDArrPaDRWHJJZFUQ+4wEJqA4h6KY8muYAk3bQpk7z4swcHBQN41TKWjjMUUWTIpIH2vqhpj3aALTFDFONrFVUaAKiyoh1LQNyoh3SClgiscYB9qitIMM3mmyEnZdyeK5XDIYZ0DJxJ+JGBIcBUrWTFEYRr71FAq+sVA3uKkBcI4ZtMa5Bq2FQSkLUcH7hkwS/yOUXC9CglG6YdffkYbMxy9vGMbCEvjs8pb3nz/n9q7H+AbiiMYQw0RUI/1kyGNPDj02KWAJzlGiZTdd8eLuCu8sF+s1CoM2Gaxi7Fu0NbS+sLQGqzRZ2CbEkkAZQr/H2Qxmxb7vOes6vLHEODIsAtY64rMV/RBAL7noVlzd7BlIlBgpORDCwOvrA/iWyRz45GrH229f8Gd+/Rd49/FzxsM1owUVCuw0QwYwbJYr2sYJKCknUkMlAxltHE3TEkZhHZpK2BDDkoI3TtiwzlHQdK0lTCPLbkkqhf0wYLWiqEIKI9o2aFVI5Mpas3PMdkxiJIgWxqQxClU0Vhvubm5ZrBbiOVI9sBeu4+bqksMw4hcdqCSkEK3ZjQfO33qKd5bzVnHBhsY3DOPAx5+94O7mmuWy46v+XZ6dbZjeHBimwFg0SVvCdSB0E1pZmrYVUDcF440wGksmIaDe91GUQlA0rsU4S4qRFCKLpiMrDSmwXLTESWGUJofAmDJYQzkcOPQ9ynmWviWaxDQFShH2YZgi+91OFCvKQOMty9Cwv9vTNh7nrUiYGU2OibE/MKVA8AvGPpBiIMTA5fUNm/UF63XLze01RgsTN5bI0PeEYaRpPRzggrdQKMZQyFNB2Ykh9aQx0PglKgf0IOsyQMqRFCOtbyFMoDKHpuC1JiTNk68NPP7Y8clhRzERt1xgcEJ2+mMekhBXtY+KUZJU6JpMCct8xrNpEhb77BWla2AVKqvdOZHuEZb6ikXnZYwPI0Pf07Yt1jhCnHBWfMWapqmkDklc58QbODLlcxavqvnwVT5K1YRtTubm33XOHZO1OegRglimZCGsAUd283K5IKWI1grn2lpssMdASzx/0jHoUgoW3QKt7gsYKUtQ3TULfHufCPrKfp6Z9nMRoWkamtYxHAbGcaosT4NIFCmaxh0LCN47YZAX8QUTopI894ds/rkw0jQNm83meE9yziyWLUoZUk2AUkrHpGkuhswJqdaaxpdjIWEOTufX5vtpradkqk9WjQnrucQUjgn5nGCpyhR29t7zLAbxh5s/U5L3wjgOXF/fiLTYavW5cVtqQjwXXY5eYcckRhISraqSSxZmrK1yUrqO7bmAoLQ+rp9zl8J9rCiyVvvdjjAFua8pH99rncNozTAMn5Mhmz9nvgf2wRoNkGv3g6vSe/N5O++OP1NKkStDdrXa0LYLKYBYCwpc8HIuuhV/sP5Qx/VEihajDUWLrJRzjouLC7S+J4jOnRRN02KtFFJiHGtxQ5LwTz79mEVlVoPCOc9RirHGE/O8zTljcTWB08exHmOUGFHBME1YbY/FE/HkepCUV6KjyLjdd6nIHK8s/bGXxC/JfAgx0Qex7Gg6kfo7drMUkRNMKTNNI00j47yU2lWQI6oICzsh3SEpJW5vb4lhIiU5x5n1nbPgY8qJ3eGOEDOPzs/puobDvufy5o6PPn7BN7/1Xfa7Ee8Nq2XHl7/0FqvVElt9IbVWGGvpd7sHc1oom8ZIcdMYQ98LCS7GcOzC0VpUa5SWNeVwOHA4HITCazXTNB7HsHiZybVqrRiGA2/evKJpGs7Pz/G2Yfa7mwsCczcOZGKKmOqh1nUdqkBIBRUC0zQc17JCrp+jmKYi/3auYkohp0JIkSkEYgoopUk5kGoxIuf8YD26L0xIAUpsT4yWmFwbg0Idi7cVoMjVr7LUwnKIAW01XdeiUcf1y1h53tQ5mWpuOK+fZSaJVunEh2vffH/uSdA8GLtKYi4lv5brean6+0dJPqg4oh/4tP3xjhOGnzD8hOEnDD9h+AnDTxj+s4fhJ/w+4fcJv0/4fcLvE36f8PunG7+/8Mb4IWjaRcYrz2HY8fGrF1izpfFnDJOiWEVMhsM4YlQh3d4R+p5u13E97bneSYflficTLIaB5aJjnALNcsOTp5px6vFO49yKMQ6kkFCIDMfuMPHZzUfsxzt215/x1W/8IhfvvI1uHSFMhBAqsAgjSngD+rjwlzJhfScbqspSVGFMkRIGclSyWdU1xBAIU2Wv6R6vLBGNVVAokGswk+9l2qG+pmXvowAUubVakIVSQCmNdyuc67BuhW8eoXSmP7zm5sVHlLse71YiCW+FrWNj4e6ul02uOKJdQ5x6GmeEoeYtGcU0RRrfiFyCKrKJb4w0OKIoUTMeCofrS+I+M16OjENhOCiM2uJc5mzT8vjnn/Ebv/pbnC/WGOUYp8Bh3DHeDuAb4pCJccfU32JV5mzjeXLR0U+aYTqwXT6jpESeAuMwEmNiu/SsVo8ZQs/Cv8Xm0WOKypiuIY0DyxRw7SO00VA8MRgOfU8fbnn61mO2ZxuMqQoFag4UxTM5xyzS7LmgvUNpQ5oS5ETTNjivsamwH67BbPjWP/3PuTh/h1/6879Bv7utkhERm7VsnFmL1w2xBhcxJqaQCGOPMhmjTe1s17LZreWZtqGyB40Ej2RwpsM7TVEBjAR4ZDBmQSkZrWUjnTqJtZZJW0qRQVS7Y9EWrSBMIntirCNnhTaIzIxv8U0DSleJGEXOIh8jgcos7Q2VIoQ1wqoQwHYYLQucTlHkytVIKlDiDZTCzdWBV7c9j589lsBiP5KnQskRTGEabqEoDvs73BRwrmO1lEAdlYmhJ9GinOPsYlNlhTS6dh2nAtp6Qi7oZMA4piwLttEWrTyawna5oZRMsYbGeUqKlNKwXG5xhxu0tqTcEqYXXDx9jzQcGJlwxvHu2TtMHZRh4OXL73F1N/CDT17ym//qr/Drf+bneHvzHuNuxDxpSEDjDGnaI+4WiqwU+37CpIYci3TmIwzYpm1o2o5CJoWEMw6lCuvNluvLG6hd39o4YkqkknCtZ9f3FGVke1uJ7HnbecKQhO1XEihNP+xBGbSC5WpFSuJF7r0hpYixjjSJVYUyhlxE6iTXDuVx6nFOs2mWmKaR4LUqxW/WZyhjiWFksWjxGm5vbumHkcXSs9o8wTWe0USCS6zOFqxWK4Yx0vcD5EQ/TqAjOsm4CnEiThO+adAoVosl+92eEAIFzWK5IIQJ71wNziKlJDpbcK1ltbCwlOCwxMAjb5hMIR8MOXVkZfjs00vCYESOKQlDb1nlcLJWqJJpF40kSmhiKKQ0oVNmu97gWsvd3S3OeW53d7x88ZKLi0cSuDrLDz/4Hk+ePGG1XPHq9RtWGVzrMc2CnAxgaNuMs+Bsw3Doubk6YFuLVw2OhvE2kPobOFuglCQI1jgWyyUaQz8Ucuy5PVzxC19rWK/PUN3AZrrhw6JpuxZFzzQZVJy+KFz/kUMSBCWY8YCJrbUopKQUj4khaNpO5HUePzmjaXw9bw0lVykxU9epgvPi90UplUHb45wk7jEMWKOPSffMzGwazxQmSi41EW+YzSNm2bRjQqA13tuj/Nosz6WUML6bpjkmTsJeTsfAaZoSzluapqnBq8Fod5+koQkhYo0h63xMMBRGJPRVJdrlfJREyimhERawbxuGoafxnrZphPU6TRglTOlmubwPBlMkRZFSco14N2lDLQpIEjkME4tFh9YWhcJZd7xW4Jg0z8d8D4ZhOBY7ci7kVP2YaozykLk9J1bz/QUpzswFE6U4Jl7OuWo3IAkdqmCtOzKtY4pHpuz8/vlZG2uYGe4/3gWgKuM7hJFxHFksuiMjfmaC55yPwfPM4J3HcqjM51kdRZ51ICb5Lm0MxlmcnotONUlX6nhO85/5c7USIs6iW2DX9jgWQBJdWwtRto6zOeE9Fh3q5w1DX32lGgoQxgHvG5qmo+97dCXZuMYf75V8v65J5JwIVH88BVlnYir1ngjrOMaJcRpx1pFiYBpGpipFKGue+Hs1TcNUPdK6tqPUOEBbKQBpo1ER2rarDG93fGbOOcIU6Pte2PuLBW3THuf+PNdACi2r1QrX+OOYV7VYgoJQbYCkOCjPReTeuC9UOHd8PSUpAK5W62PhrO/3TNOIVrLuy+9GQoxo49DaHAl/WitSjlViUAo2WkmRce7UkPGqKSUzDkP9bhlfpWQyhW///vf41re+Q4gjX/3Ke1ycX/D97/+Ijz55zeXNnru7vXyvUuS7nk8/fU3bWN55/hTnGvHaC5H9fi8qOlqKP5L8L8ghcDjsubu7O3ZIeN9IDKdlfDycr03TkKIwu3e7sSbw+ZjszoUr7z3b7ZYYI+M4omuHzOHQk5Ik5zEKSauQGMcR5zxt27Lb7bi73dGP03HNDUkk3Kaa0E9TFpWXXHC+oKgxkSqgLLnmPLWeQzISt8t85TivVit7P07qWuWsIeUiHQKliMBWjNI1ZGviXmPYlCIh2CN2zOvHPK/ndWSeW/OcLhUDU4zkWDupnP0j69TDP/Pvz/8uReyjZsWm+fvu1wWE3Fnuk/Q/7nHC8BOGnzD8hOEnDD9h+AnDf/Yw/ITfJ/w+4fcJv0/4fcLvE37/dOP3F94YDyHShIlxJ8DeLT0qg21axpgY+oGIxegGpSNm3RBR7KeBlME7T+MMh/2efX8g5SybissV1nvudhNPzhsoiRT2GJNZrjTDdMPhzWeUMNGoM9qLhg/e/AHDNye+MvWcvfVUNg9SBpsxxrFcdPVBiuz1MPXo6LgtI30YGA47VIAcelQOxJzY7SdiNGzPlhiTUUmxfPoWTgONZtW0Iv9gPEoVqkoBpVQ/FSULUykJ2YquG9L1wdYnXDfJC942ONdQUHTNGdvVM370yT/kw+/+NupgaOwWbRsW2wa/KITdgcNdz/njtzgMe7zRpKyJoxAH0hgIPpHrYlaQ8ximREgjlzcf8dHL32M/TGRVUK5hUhP2wvPkrWe8/fbXefviyyz8lpAmbg7XNM7T6YY2TxQVSMmCBpcsbVzjfItvOnRRDDkQY6ZzLSH1oAtjuCNnxflyi2PDqAYhD+oWa6wwx5RIMegqSZ9KJEx7wtSTUWxXj1DFkmKQe6uq30CKlFQoKTKOe8jCNAohkQYNU4bcMwXw2yUXz97ne9//Eb/3rT/k5752zm89+mWefCmTi5anlANxHBiHPTHsyYcDOUWm/YHSas6Wj0n9HcvlghgSxluGMOJ8lUMxVSbHWVKO1fN+QFdGViwKo6U7Ha2wXsgYWgnDqGkLuSjx4Ugi+UyBMI7EdEDWOUNJimJgsVxV35QC2qC1ByX31ChNRmTgSy51sasSzghbteQkQROKmAJVdwCnLVkJ4y/5xNW1YQwHYtmzXltCjji/Y7U2PG7P2IcRb5e8unzDfszoSdHazOFwx+3rRMqRp0+eYpXBxD22FFLbopJCO0cskzDYjCLnUWwOWkvWBZUVJSWUtcQMTnfscmAaIzCQYmS9cFxsPa9uD9jFgjD2aG1Yry+YhowZJt59fIHtVhizRE09n77+hB98+gNeH/b8d//tP8e//qf/O0KWSRNq1aAAhyVrg12tmeZu7pJYXQjrrz+MhCnSNC0xe272O4oRYG67pcitk9gPIzSe/TjS+AU5AzozpYQumawMSosShSQg4ktUcoScWSyWxJzpOs8wDEwVJLVy+MaLUoaSQKRbLhnHgc4vsUajjRV1hBSYhj3LdYu2jqyM2AqkALpwfb2jbRcsmo6+3zOWRAyF7WbLO6sFq7bFa4/vFgz9nuW2paTE2cqKcoHK5BiZUiSVwjQGkjPYsxUhRSgKpQtu3ZLphLKUM23XMQ4DGVAWttsFj9Yea6BrW5xfUBIM/cgwiKz8o6eP0EnY1Ic7GFNCaUMYRd5HGGGqEk8EMA+HHhJ445hiT7voGA4jrWlJJREJFA0Xj7dYI8nJZrvGt4UYAs4X3v/al/nw44+5ubxjiAlvG1atRo+K/c3EcmkZ+5E+9IxXe0qGs7O3+ejFD3n2fE3pzzHasFltKcqx2/eQE2NWrJrML30NfuU9g3n0JcgrLN/Eb1rGUtjd9Hjf4vU9U/hf9JAgX1QoSk1ktFH3vucp4KrXksh0gXUO6xqUKjhr6VqPt8JAtrNfWQ1QMhJY+2bJer3EWScM3Rr4zozEruuOckJt2xzZ1G3borVmmoTkJElOQKTvxV9qTviOrNia0Mw/DyEwTZMQI1KhbVrcSuSk5uRylkOLIaGVIdQkLhQJZPu+xxjDxdlC1t9YOBwOhEkYjqUTVvGcVCgUi26JqSzGOYFumoaFXQrZCwghEZN4oY3jiPUeY3TtEjDMbPPD/kCYRil8uHt5pzk57fsegLZtj4EhcPzeUgr94Z5ZOv9stgKYixU8iEskyLwfKzkLqVAIhfO6pOt9tMcEKZeM1fbIBFWqSobV5zIHxnNAO3cboMAaeV7jeC/JJoSufHzGkiQIk3sYhuP3DsMgyad3WGOObOYQgmCrNuSU0UrwMZNJJFAcCxPA8fOky6B6mbVC5JmT7Pn+aq1rEB+Oz8IYwziOx7Eo/lCJvu9r8em8zq85IcjHopT1IsWmtcQ9Is8VCFVaK8bAbrej6zpEMi0f4wJhBMtYEla65tDvub29IYRAt1hIYSZH+uFArgWlYRhYrVZsN4+Eld40xJhEmq0o1qvNg+u9727o+55Xr14dfc/mxGQulkhxTx/HUq7PfO4sAbCl0LYLnJPukxDGYxFnlmScx6b4dwnj2hhRACpl7kxoyRlJQkuuRbCRKYxobVl0q3s2shKWt3eGm5sb9vs93jsh/pVM4xfSreIcoMhkUfFQCusF2z788GN+79t/wB/+8AUpJl6/2dG2DdfXt+z7SVjKWjA9lUQ/JV5f3sr61jWsNyuRoEuFtnWMU8+wm4gx07bnaKNrIWdgGAb6fqAU2GzOjvYrOSdiCsyydDFGhthze3fg7u6WlCIpdXU8m2PHzTzWphDZ73tSLlAywzAeCxfWeUIYq8fYhDGBQy9FuHHo8Y1nuRD1md3+wDCNjGOsHTuJcZDihY8ZZw0aRUa6JlBUtRth7aeU0SpJwShLvGuVRSlRfZo91UCsfVKJQqRTCmcs1hjxVlPcdwEYwywrCQqjNbPn40PZ0BkDj10RsrqRZvKpUiitPvf+h8fDpHz+k1KqLPcHBOlSeFgAUEod78mf9Dhh+AnDTxh+wvAThp8w/IThP3sYfsLvE36f8PuE3yf8PuH3Cb9/uvH7C2+M3/UjRiuGnFgtOox7zM0+cjjssd2SKQrYFAM2KzCKUBKN86hgMV4xloz2DU+ePOIwRKxpsQqUW7Ab9pzHLa4xmJjEO9soUurx2pG1Y7lq8K1h1awxHna313S+JXU72sU5hzRxuHvD3c0V++s7bq8PaKVwjeJw2HN19ZqUe6bxjhI1BUVrvciIZ/EB6PySs/UFXbcgfPufUkpmu90wJU23uGC9XOJaQ7fYsN5uWW/bKssig7AgHbqzTIlsQmaUVrLwi4M0IYUq262Z0oQyHe9/9S/y6OnX+egH/4TPfvAtwmWPv92yWJwz9QP76yum3SWqaXi5vyWlW2y7xnUO4zWNWaHNksX2nK47R1lFh2HpLI/cz/NL/t/CuwXWtjjTivTyUZ7XAalK3xTe1gqKpqiC7LEL00ikZ8TnWhfpco1JpImpKkCgUUQyBkhENL4qMMyfD6qyE0XiYGY/gQxyhaLOFWqr83HQz43PCi2fHwZiHKSrOmVSGCh5Yooa3ThWfkvTtLw6vOHtX3cU9zE2JYz2qFwwylC0w7kl7eoCVRSBQJoGSJEPf/B9Pvr2J/zSrz3nkPeEw8Rh/xqNxliHMx1uuZbnPiZZREokRRinnhQCIU4sFhuUAr9YUXBENN3CQRFZihQjXi+wxhNVwGnLQndMtGhliCGwXG7BOIxt5X4VYfCEKaK0MM9yTBgN5Cz+9GEAAklrFJYc5Z45YxmHiaRHmmaBVmIvcJS80LDQHlUS60cdX/kzz/mVP/WrPDl/m4uLJ3gvJIEYAjkn+ulACKPIfFAIOXF32GOVYhhGDnc70jiwXW0oSuGNJeWMso6CwmhLGCd2hz0lZeI0idyRlmfvdUvSPcoY+n3i+bNnvNfC+P1v4t7+Ks+/suFQCucUuP2I7350Q7DPiM7ReIPOLdxFwmLgz/zFn+dr7/88b2+eEseItgqnF6SS8U1DyoVpGICEVh3jODGmwmEK7G8HSgl0C0+IE4nMauVpbSFEzThNAjSIXzypoGKhZ8d23aFMoRTxdmobL88giVyMsC4HmTXek1ShUcIo1tqgug5jHH0/QoZhqtI92hLHkRILWWVylPlUKOii2azOgUROkdj37A8jt7trMAllPJdXryX4HXu2mxWb7YblqmPRLiBlQp4Yd4FpSkzjhNNCKCmqkErG+QZrGryGzXJVBd4hTQMpZ4ZcKCHjNPjOs+oavILD0GOcozUtOWSGAMU4FrrBZCFkaWtZbCHeDmgKh2Fk2S14cr7k5eUNhxSAxHZzTswTu9sRYxucVuzvetpGMUx7VusV56szYoiMh569HmiWK9Z+jXGQvCMGuOv3hBBZLrbcHK4Ybgb2+571esnj8wWXN3umac/hENHLhk4dCCmzWC14u32Otoo4ZTrf8Naf/hWMNYx9Ytm16KS42w2y9rQHvvKLX+fr732F9dahrAb/Naa/89f50WHkoCIGi8qKabzFqc9LXP2LHE3jZnoexkoyqCpRS2lHkx2zH5H41qSqIgEhjGgFRjc0vq2Bi0EsSWbm8T2DV2vxl1HG0HXdcd12zuG8Jef74Ofey0eSpaaRBL5bNMfgZ5Zqy1l8sEz93DmRnQMwCdolEdAonKvSXzGSdKoENohRSBaueueghBXc9wdCCCwXy2NgC5JQjyEwTQGUBI+5FDxU2TJJWPtDJKbAMPQUhK29Xq9rMA3L5bJK2c1rZEQpCaK9d3Sd55OPP+TyTeYrX/0K1lmGYTgmbE3TfI4dLMxnSXR/nKUqSjkwDMPxOuZnARzZ5feSSrn+uX9Wxohv1ex7pmryCFWmzVpJEHMi5Yzz7piIi5xWOhYc5nM21hJiYAwTYQo452ka8d3SWh2TjvSg8DEXJaDQ94MoBMXIGCZKK1YW89hzzlOcFItKzkz13s2Jc9u2R7Zp0wmGlizqGnOhCa2OIcfMaM2xepXBUfqvaVsKMIWJnBLD7sDd7pZDv6+s45amkWRpvnfWisSZUoqxPtt5DszPaRyl4+P27oo/+INvA4g9RMl45wkxoFC88+57PH/nHdp2weGwq/Y7E9ROikXXMYzSERJCYLuR2MsahUjbCatdFYnY9GIlxR0tsdfcbXD+6IL1diPPQ0t88JAB/JDNe2TfF8QORnHsFpCwcU5ssjDla5IkUmz6yJLPuUrrId52u/0dIYxY2xyTTxCZx+Vywe3tDf3QMwxCSppjbsjc3t3wgx9+wIefvODQj0J80/Brv/qrvP/+VwjTyP6w5+r66lgkGMeRjz9+ybd+73t89w9+xBQzqhhev9mRuaGU6sdWMihZp0LO5KQIQdjzWcHlzZ5njx/JuRvNomuYwoRWSuTYlKy51ogC1Ks3r3n9+jVf+tKXadv7NW4cx/p+dezKEek2f2Rty//L/by7u5P1CkU/DCglEnjOGrSWouo0BXb7a0IUf8QpRlKSrherNYtly6JrcNYSQiLEwjhOUqAsGYWwg1MqxChjN8WqrpNmOchS14V5/dcMw4TWjhSCJNhKcOkhiz3GwDROUrixVsaKteSSySUdC4r3ybEMupDuC2kP17i5sDiPVyiVTa+qylI5js05oZ4//yFDfS4cHX+eEtoKKx8+73t4LH7qgqGmN3+C44ThJww/YfgJw08YfsLwE4b/7GH4Cb9P+H3C7xN+n/D7hN8n/P7pxu8v3jGeCjd3IlFrpokQxa9iTBHVCIPGOs2YItpKJ55CGAqlyiaUUCg4ckmV9dSicl2AfZWrQOQCmsaTMbjiWK7OiRwYxp54p5hub3Cl5cXLj/ih9fh2w/nFU66HSz578RHjtIcSQQXi5IlRke0EsYMME5FUelaNIUQLukhXuYIx9Xw2vEGZBdoqtFJ89mpCq0jrVxz2PTEOXFx8ia9+5VdYbdeszy9YPXrEarvGWAU6YesGo2z0AmS0UsLEUwWtLKqIzPYw3DKOI8tuhY9nfO3L/23e/dJvEUsgxYHU7xj6O/rhE8pksN5y0bzDavUW1ne0bYdxDVq3KC1eKUYDxUrnsMqoIt3CKGGJSODywJM9J8bxQI6RGEZULpSooCSiSpSYKEUTcyFk2Vwbh5GL9Zqu9fSjSNYYlVDtAtc6GreCpMkotBeGC9qiXMZohS7CxFHaoICi7kduoSByEAKaSok8dElFNsSNFj/1otGmo7EOMPhiSN3IuL/ht//2X0VdX9A+/jJvffUpX370G3z1f/YrZBtxVQLEKn0cdyggZ5ISwoBuW3a3B7759/9Lrj6+5Mu/+R/w6NlXYZo47K/pxz2hv+PlB5+w//3fRWlDYxWpGB6fb+uYPhCmHmuWjIcJZ9ck52unOtxcfgwpoDWUGNiFA9p2NIvHXB32jP0V7WaJ0w3GOOkaVwZtHEVH4VgV8fKx3pNKxGaRuijK4RrxsBZf9EiIt+RUOIwitYQJoBqUrb72Uy8Bdoo0XmHXhvf/7K/z9Ffe59nj99i2zzlMd/T9RNNucE3CuEjKCecvKCVV0DGEKfBoafC6UFQm5UApAW0sIQFRWLK6JgMlRXIMJJUxlWlYEJ8V5xx6Siht4Wqk+M94dP5r5Mv/jOHpht1/+R02esX7X/qLvNZbrv/f/ym/+vYj/F/5n2JIFNtiesVA5L81/tto7XFtI/Il/Z7l6qwuogntHKVkcgzEacTaFluZn9Nw4O7mMw79a/rhDmVaQonEIXH12QtSCTjvKcqxXG6ZcmYKmTAcsGvL1772SyzdRhhoU0+/24tkSxpIZSTXe1BKwdhGztM7ru9uGXNkmCbSOND3e1LKhHGSrumYuX51yflmzXKzFMZeimhb0EJUZkqTAG/2aLPA6EdYo9huV2Qy4xTR2lOKpm2WFAUlFlJIWKtAaVKOaA05TIRpJJdEzobGLzDOV2n0grIi1WVyxugEBsJ+4PLTl4TYE9Mt/RDRpiFME/14IIVM0hDvCvvGcr5ZsFi0xHFiWRZcLLdMBJYXFuszX3r7Hd6Kj/ns9ooyQWNEZmjY39HvD6QcGEZJmFarM7zzXF9dMapMt1igS+Fm95rbVBiHic1mwWbb0S4LMSkO0zWhHJjCQNd0DBOM8Zr94ZpHjx9jvEabgG8apnFAO4NiIusR3SZCcty+FJbyYtsyHSwvX72ge/4l/txv/AUevfUOz598CTUV8jiw+2v/GePHf4OzP/sepp0IOrNXCescbuFJ+fBF4fqPHqXcs3Mbg9GifDBNE7P8TghT9YrSQKzWJo6u9RijkA78CChSSDWIlrE6yz/N7OIY0jGRngOVmCIl30tXzQzrmYU5Jyc5F2avHkkEPu9FNSeh8roUEeakbWZVa/QxGSql0HgPVEa9r5JAGkmwc66JliSAi66j5CJWICmT6/U1jSidzCSw25sbUkp0iwW2svNLyTQ18UPJ963Xa4y2R1b4YtnUAkKD1rZ+T6TrWr7+c+8zDBPeN8eAfcbDUjJN41FVIi6EUP3fEqXcJ7Vaf96bZw4m559LcJoE+2vQOh9SlJk9qQIp5fpsDNMUjsGnte5IbNMarPU1iS1MkyTCzjqUpq4J4lUUgkjZpShWEY1v6nfes8LnBG2aRsQPC5wztegAbdvQ0EjSVSBOQq4LIXBze03jGy4uHgOSPHrvK0O1oLSMTWOEfJeyKOs4744s1pTFrchYi56DfjKz5OF8j6W4IoWgaRyFaNkuWG+21Q8vMU13aKXxXjz7jDXCEg+B66s39P3A2dnZsYgSQmC3u8U6w9n2jFRlAbebLVDoh55+6FGIbUqKmaEfGIYJima53KC1ofENTdOyXhvGUeQH52daUpaCijGUKMUprRQ6G5Fk1PesfmOkcFWIFCCX2RsuURC7n1IKfd9XGUCFs/V+60LO5UGikwmTFI7adoFSkh+knIS1neJxDE6TSJu17YKu7TD2jGnspQhYk/eHxR/vG5H3KjD2I0UJqerq5opv/s7v8k/++e9wdbOnYNAlc3625ue+/nWGcaTvD+x2d7UQZBinwA9++DF/9+/9Y95c3jLFXJs3JCad9aC0qpJlyHVap9HOEqbAOEVevLzi6nLPd+0HlJx49uyCd95+QttaurYRS5UUGUbxKAsx1Dns69iN9d5F6Vh4UKiSgqbMpxgD2himcZR8q2R5jkpTFFVFRZ6l0kYKSdPEOAaGSYqNpRSmKRJCovEOYxWL1QJtLLd3e3a7A1MqjGMkRpmTxhRmX0wRvZH7oB52YMSAT4m28TSNkXNzlpwR77HK9i45C7scWZNjzjTesejaYyGCIgl+TPp4ndMkHUo5IaTQnI+FNErB1DW0HJPxWlCqTHWlZ/+re9nB+bt4kFz/eLKdshQfCiL7N79Ha0U10KqwWzDmQSvQn+Q4YThwwvAThp8w/IThJww/YfjPGIaf8PuE3yf8PuH3Cb9P+H3C759q/P7CG+PGQRg0wSbKkMkJUiw0nSbEEXTCKIW3TtgvukGXhDKFPAVKBqM0Y06EFDHaVt/sLCcxFnQqhGmElClToZSINR1tt2UsHq8mUgzcHl4Qiie4hn3OHMY7tm+eE3JPLD0UGVRaWW4Pl4TJstquUTawG95QrKaUhlQgG0WIkTAFvDEom1EGCDfESfwRlIamWRBjj/UJheOwf8k//+ZHPH/359jcPMN+v+H58y+xONuy2K5p1x0ouU+lFOkop5CTqgClxN+lFJRyaCX+AiFGGu/o/BrvW2JRpHXEOy/d2xlUUeQK+LqYyh6KlCjPZIojYYxkbclmQE2Z3I8cwogxhXBI3O2uadqGcZoI40BjLCVPtF0rAxZZKElw2B/IaWCqYBBLJOeeMSVemoaFU6QwYW0DKELUhH5ElUQfI75bsl56lFrx+Mk7LFedMPtC5q3nz1AuM4aEbxzeOxKKUiSAyCXRdi3WlsqQUWgdpVu1KPGeVgq0JiUoJWJMxrkVj39ly/d+/x/y5sP/mL/1T3vUzvF4+WXW5+/z6Pk3ePLuc568c0G7crStF38M5zA2i9R40ly//IyPLr9Jf3NN/+aW5dvvkJaGrrtgnCaG24Fy6Ln6zt+lTBPTqqNZPuf65Wvas7fpFlusbWi7hhAGDtMbLn/4Ccp7DtMtuezpFh3tYov3K7RX9OnALn3Mnh3Lxw6z3qCtxZqGmBRFaYz3oDph6FmPsQ25UAHOobRGa0tRmlZbjFYYHKUklJJO4tnffP53LnMHv7B5VFGyOUrCaIXCkNGs84plSjjrmeV+oFTwVqRSMNUXiKwxtpCyyMRrCrlEMomSXV38IjlH4iTrgnOWkpMEARQB4XEiTAP5238V/vb/lTf5XfTN/53r3/u7/PUXHX+/hf9w+St8/F//Vb6z/zpf/cWWl3/nb/Duf+/fI/sOZxuSGdExYDdLGm0YQ6EYTbtckfuBcQh0iyW72ztynrBaYZQipz03V5d4bVBqxMTM80e/zLDrabcXpEWk0wt0iOzvbjDGEtNeJMtLyzCNZB14672vMh0SKkZSDox6x9ZtcYuWxeoJZEuIB4yqrC8lTKc0TTx/qvFNUyVyHEppUg6Y1lDCCCUzhD2uXWLsoj5DDRhSnCgpYZ2XR5Wrp5PWlBygCLCHGGkXG0LKWE9ltdVnpB1KC4VT+D4CisIlyGAMwnkUvxljhQGmSxaLAGspKbLfvyGkQ00KAikHpizqCNMwMqYepTMQscXx7MlXefHyJVN4w2r9mPX6EYuuI04aoiWOAUvh8OpjsjqwfvKcm7s9NhaGaUDZQtt4coo03nM7jHSblgbN1atLQg64xhB0YtE8xprC0O9R2WAc4DR64Zh2PU61xKKZpgHbWbp2TZ4UOmdKDhSdIStc02E97G5uQXm0VSjt8a3jzUevGQ87vvb+n8LEjLr+Hja/QeWe/lef87u//Z9z8Tf+EX/2f/9/4leSZtAT6i6hmpb8J9gYH8aATSLRZqxHAdM4MYaItQbbSFJNfX65skkXi5a2aY7POoSE0vrIsn2YAForwbqeWavq3oss10RnChOdbY8SWTOD8D4hl+BMK5HjMcYQiSitmGV7Zuk3wU5qgl6ObN+mabDGCbMWjnJrOWds9faaPdHmRL8/9GhjEK8kiVdSEqaoesAIH/qeGCQwyyk/8PZKTMMIGhbLjkZ7kSCqzNKMJCT9eCCmyHa7ZbXcAJqg4z0zfLtltSqSvKaEtY65g8D5mlgFufbFYnFkg0ugrI+s57lQ0nUdM1M6JXmGEkBSmeccA845MZx9kHRNuHKWzxeJqUIlrx/ZxSKlVH3MdFW+0ApVCzm6ymaNQ6Tve2b5Llv9le4ZoemYaIWqQiKyX1I8mp/lXPzRThPGiDXye4fDnt3dDr3VeC9eVyFIwuG8E88zY2jruIgxEoNY6czjypl7bzZtzOeSv1wy+/2efn9gsVigK7PbOUfTtiyXa4ZhEIk0f+/xNXvFlVJIURIPbUwtypj6Xsg5HYsITdtgjeXsTO5N13VorTj0e6Qw4GRZrs+o8Q1+tZaEIRXEq1AS8plpO491rQ0pBPI4oip7PaTMFCNjGI5zEaRokrMQ5WYGL8A0DpRMPS/N4XDgcDhgjGa5XElBIwsRVAlLU541RQh+1fdKpCUz0zhWG5j7uTwXkmKKMna1zLNc14l5rZA539KozH6/4/LqNR9//CkfffKST16+5IMPX3C37yseJpzObDYdi1V7XKNSvb7LN1dcXt3yvT/8gBevbkSmTWmoxYU6dHBOo5TGWi3M7JxpugZjHfuSiVMgx0xUiRCidAspzTgNaC1Fi2Ec6YcDFMU0TZQC5+fnVX6Ro/ReqYWQUjiywufCZt/3DMNArGNUz4xqrWX+oVmtVkxTZLfbUwpYq5mmQMrC2I5pVv1ReOdqgUq+/y4nkYArleRcJCHXtUNH1op0PEfxSxT2trGKVjUohI0fY65dBGIZU4qSomfORxnMkjO5ri0P2ePz/Im1gCCM+VJznwdSiUpR1L2HmULIzelBUi5/qWOyTpEY8/71mnzre/m3eZzJHFDVby1X8jMP1tVK9n3AVp8x8k96nDD8hOEnDD9h+AnDTxh+wvD6ys8Qhp/w+4TfJ/w+4fcJv0/4fcLv+spPKX5/4Y1xpRSLleNQDly/3gMN2hayUsRpQpXCdnvG65udeEtYR0zQGEfOAa1NZQlBLrVzOSe0s2gyrXfCYHKWWEZQwuTQynF59RlXu5c0WdHoljQlpnLLqB0WePPmM3jkOXu2RI9VAiJYCoFtpwmmYFPCLQ1Ne8EUejQySRSBksc60OZBAKZENDIflTGkGIgMHPY9Z+stq9WKUizjGPjRD3+ENplPP/0D1s2GR4/e5vn7X2Px6BHKyjazSDLIIh7iiJu7ZCl0Xctisax+0Ind7R2Xb+4Y+jcoYLvakLtEQFHKRNxHxnjL5ZsX3L7eM44Tu8OOYZoYxoEYR8bDwMV2SU435OjQRhFSIISRcZjwHvohkoqm9ZowBqx1LBcLlJbu/ZAmPnr1BqLII6es0VZx3mjGogmp4axVaEZyYygZVlqxXG3YkSHuyVFxffOaG+sYx4EPP/hn3F5dkeLI9uw9msYw7XesNmdMMVGUwdoGoz2L5ZLVeo0xhru7HeM40fiWplkwxEgxDY+fPqb1DYtug+nA+CXWZRq34Btf/h/y9a/+FZTtuT18wvX1h1y+/pDXL17y+vXf5IN/PjD9g4RjybJ9wmb1nPOLt9g83bBYbVhs1qzOLvh3/73/Hfv4GWuzYQiZ4dUL3nz32/zh736Tx+8+YXEBbtUyThqVDGm4Ja1a+vCSadqxOn9MWVqWzTuy0dY2WLdCu0aYYsaRlcYqjwas7dDK15mXAFMnf93EnsFM+uzRqm5qz8oEper61w78UmThSRoUHpXVkW0mi3iGorBKy9wsuTLTVFU30JRkpTtYRVRyaCwpCAAIeaSgi0XILIVSRM5JOyi5YJ1FfNMLhgarDEpFkdZHCBV0dQGkYKV9X86zqhksiuLw9OuEv/y/YfP3/iOW/3rDq/ee0v2zS/7d5+/z6ahoLp7zFVO4Ti3L33wP0yo2j55TtOFw+4bc33E43HH9Zs80jLSbDWkciUScy6ShYbm5QDf2aH2AaWmaSJn2TIfIcLfj9/+rv8Wu/5g/9Vt/ie173yB1hqHfUUzmbtphnMFpQPdoIovlI2Is9LtrrLdoZehWj2Qt0IYw7GSj2ywIWaGsgZxIQf5Yr4hxkudJFKlypdDFgRX/kdX6jMNhJ4CdLFqJOkUpGls31YVxnFAmk1Qkkli0HY4VSyNA7jNYIzYQYnUknlClFDT6yFIFxBXBZPmeCoDOSZBZlAQSVhdKSuAazs7exZiZ/QW5JIT/p+v6CwVd731hGALf+MY30KoAmpQCMfQoFcGAP18QxoHu7edoHdFuwUp3KCK+BpONdaQxQS5sNxvGbAhF8+itRyQlAUVJkaY9w7mGfC7qBgBhKLTdClykqEAqCa9bpjCSSZilFoaedeLrMu5wzQYynK2eojJkNeGMQxn43vd+wF35jO//vf+IP/eXfpXV+BJ7+A7t4W+zeffP8xf+/f8V4c0O9U8/xT96RPvOE+KZp2CIcfzCwP7jh7OuJmxR5qC11ecmoXVLKdTnJgFN48UzzNl7Tx2gMvlmWa1c2emf9xYzSgLBhxI64nNjKrt2QmlJ9JSSRGv2JJqDuiOz2jhZN+AoUybMyunIpoXxmGRqrUWqq5QacFHljJDigzJQxN9MId97eXmFNY7VaoWxisOhJ4aMM46maeu6Kuepa8LonKFddDRNIx5XIWCtAV0gF5quoW1bYd1TqqyRomlbWhSNX1T2sySsWnsUBq0sRVX5M2RNl2TAkFNhTJJkNY1H6cIw9lCoQbsEkXPHwMNOgTlJfMi6nOXZ5gTovkPAHBP7e5mumclujp9/TJqql9rsdeWtQxt5TSvNLBE3jgPCVG6Pge58TrN8l9byTKZpYrGQ94UwAqUypwsxJdAKUwstSil80+Cco1sucNZSlGKKwqxNSfyjrBc5wLl4EaaJXLsRUhQ/NZCiznq9xjh7HI+zh9osORhCwBtN27THIsI4jnL9lR2P4vhdD6XaUpC51HVLYojMzQIlS5K9XK6PvnZt2x7lyHY7IRTFFFl0Bms91or84tz5MU1TTZL0MaFTSjzDQpiYpom2bWmahsNhOM7tu7s7dvtbci4slyvWq40UNjCS3Jn7JOmw33NzfcM4Dmw2ZywWC+ZOjBAm9vs71uutEKKUEuuWKjtWSnkwJoTlfnX9mv6wZ7Vas1xuaduOpmlxTrpNhmE4yvDN86Vt2+N6NPuDhWnkd3/v2/yjf/zP+ODDT9gPE0obxql66NWui8265e3nj7Fak6MUxLx3pKHwrW9/l+989/tMY0YrQ8kZYxWNs6QEYwiitEOhbRq2mwXjONH3PY13KDTOWrGxsa5KJ2a6zlbWsqrscEnk+qEmmLlgrST5cozH+zMXP0OIjOPENI21E0cfi3cpS6GmbVustoQ4MU2xFm+kmDSMI1ppnGtZLhd1DdfE1KAVx/VgXnt3+z3X+x6tFMY4ArEW7sTvUhux93HGiJ8l1euyXpyzpsar0lUSYhBLqZxrp4yslXMhQYp/WWTPKuNdri0zS6SllKCo2kEiY0nPtk9FGOpiViW/r7Wuxj51GVezf+NcWE2yftr7bp45gX74//O/ZX2UcZcqa1/WsYdJuELrObWWTpp/GccJw08YfsLwE4afMPyE4ScM/9nD8BN+n/D7hN8n/D7h9wm/T/j9043fX3hjvPGOcd/TT/squZAIMbNM4g2xWSzIqYg8dinS8ZgVIcpCU+8RuiiUMqgM8h/ovMF6KCpS0KJjrwrFZg7DgFUGbxT7u1uCOQCF/WFkypC14maI/OLz9xinS4axx9mOlCcOh0v6gyYDZysYrwzt0mF1xNsOkeBPJJ0oKpFCoF0t6yBwKB2FVVMMRckiYrSmZMNudyCmCWVuCbnHKssuw75b8+LqEz787AM2q8c8fvKM8/Mz7ozIFZydP6YozW3Y4xpHSJFxinXjHK4vP+GjD76PMoZl13G4esOLMNIul0QUQx9IwXAYbrm8veXN9SWHQ0/TtISQGIeekgNt1/DmzY9YeUO7EGl7YzS7/UhOha4YrneH2gmqmVJEl4Yy3MmG1Fg4BHh1eeB2t6M4zzAlFsbzq++/w5v+io9f7fnqZs1Zl/nhm5GgHc8vHE/WO253B1bnLX/wySVdUTxdLGk3nle3r0i94emjlv3dx1xf36GNoi+vGaaIdMOaukgZ6WCPkXEKGC0L0TD1XN++RGvPZvEIbzoa3+G6jqbZYr1lsXrMen3BenNBs/Rstxe8tXiP937BY341kpOM5X5/xWH/ht3ukk9ffMxH19+j//Y1b62fMu4dVzd3nKE5f/c3CY9e8cFn/xUffPiPGeLE8/e+zPbdJzSL5/zal3+LSR2ETOEUKltUaWjPOozb4F1LKRptDTqLHMq8MQ0it1EKdeNRAl/ZoNbEMjF7WGhEUl4rVWVFqjx/FLZbDIFSLClESgqUHMgpoArEOKEVxDBRqnR2KZriPLmyM7XSGCuBkS3SsS+bnkk8XnLCNGB1x37XM00HlLZo0/DofImpskSLZYttG3yzoIwjt/sDRVmUtWjrKWi89bSdxzeaQqQkCcK1MqhSJEjVhlAiq/NHkBVd59A3n7L4S/8T+nzLW+vP+Mu/UvjR9S3LL/1rrLuv8K3/4v/Clpblr/8V/GQZv/0t/Ftvs7l4zHK9pR+ueGX/gMNH3+f6k+/QLB7h2w1d0+AXLcY3ZC1sq5QKiojRhSkXsoJDnHBnG7bnDXeHHXzyMaO/BlPQ3YYOzeHVFX2e2Cw6pkPk9vUVTec53N2gbIHq15FyZNk2tO05uWisHwDPcrUGa/Cth7IkFXCNSJqoUsCA1g6jNKluXpMyZ+2SoqvvSlEUEp0Gsq7b2YY6dMhZ1oRS1AxZ5JIxZt6qzmKBoQylRDQGVKp0jFIhRwBYK0uuwZapahZGSTBZSiaGwGEMLJcrAU5dwbvoOpZFBWPmdCmAkmkag1bpaLNgjMbadSVRZIpOdMs1OdSgnQjrRKJQqp8OJRNG6aqnRJqSSFPG+haVEnkcyLkw7if2pcf6Bmc6jLY0OhKD+CbpMMraGCMWh3degpKiCLsJlEa7ljhFSpq4u/6Usb/BOsfy4l1W3ZZu7fjeNz/mW//0H/ClX2752tbg1CeYR0vyzQeYv/Z/wPz6/5zw2X+C3WzY/Qjyv/OX2f7Gv4Jv//jJuQJ8TTJSjvXZG6wxlYAwEMI9Y885U9nEiZIHQhAm8jSOaK1o2gbv/TEpmoMXZ10NWuXezwxo4OhNVkpBFWGwSgAj1zUHn3PCN00DKnAM4qZJfIGMFdmpKUhw6929RJu1Foo6JosPgyz57sNRJiyEA6UUVss1OdfPjyL/5r3HW/GSktdGhnGgbT0Wja+eXDPjW6Fo24Zu0ZFLObLhjTHi8aRtLXy4I9NUa1sZ2e6YWMwJ7zSNxBQo2aG1PQaG99J3ptoazMmxMPLn+/Dwfkogee8VNk2zXJR9kHSrWkQRqar5e+4DUU3bij/aXBARSUBfJY3uGZ3zuKBwlOZKSexzZum4OVmcP/9eGu2elX5fNNJ1PIExFmU0Kcp6ZGf2uvfkklmopXw2iqQz1khiVTVNjuMLwNXkeWaQL5YLjrJjpaDyvc/RfM5d17FaroT5XRnO83hdLVfS6VCq1Js1jON4ZLQDx+dMgd1+z83NDcYolsslc6Kw309H3ypr7QMJQFmncyr0/YhzGe9Ba47FocPhUMf2RIy5+tQZdrvb4/wYp5FxGshJ5BJnNr0kwo62erJN08CQe9pFdxwjSgnzuOvaStCTtUN8/srxWacUJM6vhZz5z5FVnO/v63634/rqkmkaMcY9YD2LZswsxzh3RswdHHMxp+97xnHk5vqKH/3oR+z7PevtmidPpfggPnqGpm1ovGfRebbbBcPYc3l1idaa/WHkg49e8MEnr+hH8XbUukAqPHq05eJszZs3Nxx6YWmnlNFklosGZzXeaparFX0/yHU1jUihLVq8Nzgrf2LMTDmzP4zVq25iHEYpvijHNCVC2NcugyRdMnW9knFlKEX+f74v2rS1W6NnmlS9b5JnhVoAck6IwLHKMi6XS0mUQ8A5mTOofCzQzR0PSic0CqM1nW+oHk3YmV3u5w6Xe0b27Kc350vaCMZroGhFShkhfCaREnyIUlod/z2z6WVNoq5785omnozzujDPHcGrUldCIeulLHZD8985S2wwzy9VhBSd67nPx0PsmNeM+8KmdC7M62B9ua4FMk/nLh0Z53/yjvEThp8w/IThJww/YfgJw08Y/rOH4Sf8PuH3Cb9P+H3C7xN+n/D7pxu/v/DG+DgkUiwsuo7DfiKVQoyalKFpOnJW7O4OFKT9PSvZHCdKi3zJIs3SDxPWd2iVhJmhFc6CZqq24IqSirAvmoar/StMf4txmm65ABSt6ximz4iHA8MQKFPh6uU1Y/iYnBT4QBgHXr2+5N2vvUvRmpurO8oYafwav1iQmGRhLxlTIFY2mSrS3ah0qlIug8jemIVsDqqBqYzkIJ4DYcgopYlF/DwOw4EY77jdf4Y2itVHZzjd8uytt9HWMsWItgpUw5Nn7+KbNaZp6fcHbm5fc3f1CqstVln215cMh1eofGA3Zny35h9+6/f53g9e0znH7m6g8S1Pnj7m0zcfCosLgwYW08Dt/hZrW956JBvaN4cDVzd7Hm1XpBQYJyhElt7QdY4UMmXK7A4Tt/2AXy/Z9z0hFy5aR+hH7vqRD19c4iPs3tzx+9OEL5qQNI/P4GK9JeQ9yYzc3E3c3Y48e+sM044Y5bg5XHP1OjGOK7adJqWR88ePmcYAiOy20Yb9/oA2DX2/x2rpftVKZCRWywXn5z/PMO0JY2Cabihxhy1bzrYLbm8v2d+9JoyOz15oVt0F2jWo1ZbON6yaR7iVMNfa5VMeXXyFt54q3v+qSHyTAw7L4XBJMYXDZ9/lh3/wz/j0oxGjFrz3y7/KxdOv0xZFCgf2b75HGs9Znj/DtZ6iG3S4JLUd3eItsjIoHEpF2cxTFpTIwudcZXNKwtQNyLnLF8T/IUcgJ6AQ4ohGsdvf0rRLbq4v2e93bBZrdne33NxcEoYb9rs92+0a8dAeBKjHHqvXsmbrA+3CY+ySq5cvQGmsdVhnKTmzP+xp24Yw3TFNYL1G5RanwHRnxDyKR1LINK1FW7gcO3a3t+x3B1bLLbvDyJQibz19jDae1XrLq9cvZLFUkOPIZrWlFDjserpuibUe3zTYKkGz3JzRbjaykT9Msllr38I8e5+21aSS6FTicREmWy6F5z/3HxJixISe/e0lefmaEDxr/QTnl7TNgtX6GV95/7cI0w13+0sMDm0cTXtG02zrgipMplw0uQTSdEvob4mtYlpENt0KnQyHwy3Z7rDFMn36GX1/R7Ne0q4vuC573EZxvjpDu4Yn738Vb9aUKpllAKVqF3ZRVa3hPnAcDgNKw6JaHCjEnsEYS8pFNsyVbIqjNSlNaG0QzpbYNJRcO7oLKCUKAkrNChlASZR5wz1XbnCVWcm5CGGpGIwqdbO9VNwXUgelcOgPFCXgqSkYazAWiha5G7THWE1WCl0ghIxSM5NLzklrjoEeCumIr/LsOScUlYU5TlUiqqCKF/kfCxn5TF28zC8t80cbJWv4TEIphRgmooq02qHGxGF8zXS4YtgNhKsBVQ7cvnnJzSefMUw9m/O32V/v8daxulgTohCmdnev0X5i+egRF8+/wvr8CdtHT2map2yePgeiqGBow+Fmz/e//xm/9PW/wM0HP+C//pv/Nz5Zrng2fsrFu4bHd4bVxz+At/8flP/R/5Gb0vP67/y/KHzMVhUK5gsD+48fSot8jvcWjuw5ef6zr9csPyPJW6TkQiaTU2EYRmKWLv5F10rgUYTlm/IcHIligDX2mMjNPkkPZZeMMVATv5mVm3M+So7Nx5zcDf14TOYkGBfGs1ZzkJWPTHnvvTCTKwt3ZsCHEI5JQQiBxWJxTEQfvlcklNTxM7NQLGi79hhgmZrIee9ZLddyndOE85bGS5I6J38iLQRKiSSb1tSxLpJUKQWa1lfGaq7Jq0NrhdMOYyxt0x0TkvlehhiZuwUkgdB1ft8Hj/MzmJnSsySZvE8fvw84Jr7z58/dBfN7lFKf+3s+l9l7TiSeypHdPSeqD5noUKRbAlXPKdbvF5b6nBy2rcj8jeN4fB7yR2Osw1hDTpkUK3GxJmgPvzeljHUG51oh3tTzflgQ0Fqj63XMwXapY/mhNx5w7MaYWejii8bxM7XWrNar430HCFVyqmlb+Z6SMaUIK74UhmHP3d0N3ovFCQphOiuZolo3R5a8cw4zdwPUeSEScRMpxWM3yVxMkfkWyVlTSjoy8aUgJAUT72VNnLs8jGnx3gOKYeilEwLBDJTGVY/AeS4tl0u8F7JW17WAXNvcbeB9exwnc0KVUmIYBlISFSljDM+evc1bb70ty1K5XzO0kRxC6/vPmKUN5+clbGaxO1qsFvwr/+pv8it/+k9xfX0DOeGdxflWpN9KxjlfiwKJROLq9oYPP/iETz59yevLO+7uBrRpxPuQQtN4loslq9WCaZxYLVvariHFxDSOOCveie68o2k8h4OCsjgWQJyzGKtQKGLM9L2QsGS+paP3XNs1x8Raa8MwDjjr6IeJEDPGKEKIlJpId11XVXUKlMSia0AVcprn2323Qs5VGtA7mCZ55tMksU2WIkHT1A6SmEkqU4r41HVtLfXVtUUk1tRxPX+4fnvvj91B83pQCkxTpFCT4co6pyhUEbWhGT9yLhWvNSpXtSDU59Y0pbhPdMs9uXT22ct1Xoq6TDquNcMQ6MfxOP9zBucsnXdS+pnnbAgoI8peM+lUQV3D1X1RuSbfs7/bwwSe+nkzS332kixfPC//iccJw08YfsLwE4afMPyE4ScM/9nD8BN+n/D7hN8n/D7h9wm/T/j9043fX3hjvOhC0YV0iDS2YQgTRSnGMbCwjrt+wHctOUR80xCnCUwmxEzjG4xxFF1om0wqhSEFfNE0xnLoAxerNVFN+FJE3lZZUuxRJLzy9LuBgxrplht2uzeEYcQ7xzRk9odrPvrou5wtDU3nGMLA1ZsXXJw/o1s8JuQ9prnl5vbAeXmMKgWtIhhHSREQuWZrPCmP0iVZJaVzVOQY8M0IjJiiMEq6aENM4uWhCiUnUJESC1Zb6X7FcXt7zRQjr28/w/slZ9tHPDq/IKUDLz76Hn0/Yn3Hfr8nlQAxkVDEfEseb3i0Pufi8SNi7kkxcnNzw35/xZ4GoywLr7m6u+Zuf6BpOvr+QOstb652ssmkAi/fGJ6eKVIO5Ay3Q48jcrXPLBqN3a4ZIxzGnq5oPr7e82jTokqQjlStCHFivVBcJcX3P31FJpJjZp0bzs8d6IYny5aYB0p2eAW2M/zSew6dJ4r2FJv56rtf42J9y2rh8CxQZsDajsPdJUo1MnFTQpVU/Z0TIfYopSlZ5C6mmCi7AaUM1lkWy4718gLnLC9fHchJ4x3cXt+xPXvE3d0N2liaw55oNFfxR3TrJW2zRVkLVU4nJ1guO5TRWLtiuV6x2qx58uUv8ezr/yZ3tx/gjWfcDZQ04pzFNQsedx0oj8JC8ZQcUMu3hJkzQY6Bqcr1x9CTssIAOWWmHLHaEKcJXQoxFvyyIwx7pnGk3w/YnMmuYd8fuHvzKcPVLctVps+eOEWcVdVbXMZ/Tlk8vnNmGBIqa6Zhx5vLF9zc3aBtg9MLyJEcDpSSycqQdUKZlikchKlUGobQo41Flcy4v2XbbUhKgTeEPrC7ecPjt89ZLR+RhsDL15/iG2F0hgJ4y3e++4bt4pzpEHj8+DGb8zNc27JYdkzjgUN/w+tXr5iGHeRIweEaRQKsO8OaDq0Cm/MtJRq0zizP32KaDNvVgs1ZR4wWYxzaStcuTqFZsdg8wlx8A+NsZeYqEgptEqq02MWSxfKpbDoWBblU2ZxCbcvGKvHQUPYCtXzKavsVno23aKsoRFRJKGNJMUIYUUajbIfRDpTC2aVsQpNRdXMzlYjCokhQqtd73bAuJZOjJiZQylBiZNhFtLFHMEUHqvsGQQFKkbOipAxEYaSmRB9HbLHk6g8eJyH15Fw3xVWmpABFM4WI0YqYAgrNMEWsgqSEPGS8I6cg5JGSISdKlt7y1y8+ZHPWsDp7xtnjx7x69Zr18ozVdovOibt9QPlE1yjiPrG/26GVZj+OYDWkSOc7svI0bQsmY73BGEvTLmkXDSUGMob9EPHO4XVB+4JKQvAxWpNxKCXyNIpMznC3u2G1aNG2YZYE01rjlRNcaj3bxbtsz99D5UBCU0jEw2v64Ybr/Rs4jFxdfwKqQQ83hP0b7OKcd77xNudPvszZ+ddwdo1GcRgHUOIVU4ol1WfarRf85f/g3+HVJ3/Iv/Xr/3023f+S/e4OdX2N293w6tV3YbtG+0zzpGXFGdv/xf9aVBZKIar0LwLZPwHEhT3s3APWs5KkrVAIkwTbaIVWzdFapBRwjcMpCdC89zgrc6nxjSSISqTibP3cOYDp+562nYN9CVB8Yz/HXp2PGCPeS8IfwkQpwsrte2FxH9mQpRwl3bquY5qmo8/SnMzNyficSM6J3pzcjuN4DPZmBvmcuM4/zzGBFhsIrRUl66q8kbBWoSoHemb2TjXgna9r/nsYx2OQ3nXd5xjrMQVIYKzFFPO5QF5rDYVjYj0XFIwxaCWM0owkcrPk1XzN8/fNbMo5OS5F4ZwwPeefAcdgU26xXP+chM7PEyQwnZ/l/LslS7JtjEEZkU2y1hzPff69EFL9N5VNHY+JYd8fKAW6bkEIIjk2B/xaW7qulfvgLL4Rz63+0DN7gqVpwlhz7EQoJRwLDGjxTXqYGM6+dDGLvQe1oKCMOcq0zWPTe3/sPpif8Txu5oKPrOn3kngA0zwOnTyHpmnINbmOIWB6w9nZ9jgeCuI/WLI8R+8th/5Av+uZuw20NjI2ipZEMwmzfZ4LwPH5z558MUaWy6UUsrQ+nmPbtlX2LbNcLmsCNQkTu3pYaaNqciNJRS6ZMI2V5eyPxRuQZyr3PBEjWHu/Xs0JtRQ3RlKKx/HZNku0oXZopFoQGyklMk3ix9Y0HmPUsZg0zy8p7EnXx2q54eL8CX2/Z7vecnn5hrEf8dYRVcG5hpASh30v3xUmXr+54uNPXrLbHyBnlo1HG4N1mhgnFt2Cs1XLojGo8yU5Z87O1zjrjtKM1gojGzKbVUcp0i2QcvrcHLAmsVxsJPnNCYXCO5FT7LqGKUTu7nYoJYWzWJ+jdAoJyztFmbfTtMM5izWKRe0moDKip3EkxHQcp/PzyVl8xFSR7hrrbH3u9zJlTRM5DH2974q29cRw32HR1/Gvy/y5MzubB1J7teigFGMdXzHNRdpETvcFtLmgJXOzjjUtMmzG1Lionvs4iTSdJNWlFgNKTYxFrm8cBmZJNSkUONq2Yd8PTFOcYbDiSIDaTaO1yFhSSrXQmtetcuwCEl8tKXLJWiudC/O9/VyxT8+dGZ/3RfsTHycMP2H4CcNPGH7C8BOGnzD8Zw/DT/h9wu8Tfp/w+4TfJ/w+4fdPLX5/4Sp7ihPGaUJS9Ys0VtVW+lKvNMkCF6aANpZSUpUdKPT9QRaeIp4W3inpANYJv2jZ9YHNwnI7gVYFpzKNtaxXZ5ScSf0A2pDKxO5wYLw7oJ1FOYvzDS/evCanDW8tG2IMrDcXrNcb+v01KDhbPWFpezQ9sTfgLKkMUIHJey8b43EkIxM4pVQfQiGmiDIFbRKpjNVIXhYK8atQGCUy2KVkUBDCSAgj1mrG4ZZS9rx6dcVnLyPON8SY8F1DTiKTHWLAGmGNlDTQtZaQJq5vLnHOUIri3bef0jUiy50S7A+R1zc7MJpdf0MpkbsDkBXOaGJJRFWYloaYwDgPGe6GnnEMXGyfcLWfWCyhaxQuKbaLBaUY0jhhrSLuC+vHGmMb4pQY9MQ+AabQLBTDNLFsNE4b+hFyjAxjZJMN/RRZLDRrb4kxoEJmZTaUKbCLO5Qp5DQRU8A7S8gJrYJI7AylPpMJY8A6T1GKVAq5REraU5SjZM3L3Wf04x1X1wcWqw2awPl2w93dJdqI17BRWhqvtXSQWt1SlKLxLb7pWK+2fBojKCdeIDHw6NEzHj++YH3+iO3mKYcCIXZs1o/Y73pub/ZcXV7hGsXu8IYYM+uVp3VbbOu4u77Be8tqsyRnOOwGipqY+j02RA7jSMSwXm74+OPvoEuLbxY4lZnCLbc3b7h68ZqkM8VlphB4dHHBPqx5dXVNjiNGN8LgUlk6zMeAIjMMA2MEVMZZaL3HNoacRlIqhHGQjUAl7D50IscDuQS0gpIyRReZyxS0hUM80HYbLi9vub56wWLpmPI5H/zoR5QSyGTW2y3L1baC94BuRN4m+cTr4RV3b+7wtiUlRefOMeaOw35PKmAby5Qii+0FXilKVLQ6oVMk9HumfkRb+OCDD9ntD2wWHW23wVuDcRCLZnPxnKZriXmkxdI1Dbbr8OsLumaB8VZYkKXHeiVzUAW00oBDqSTS4wVKiaCNsKxUlZaiSCBhPeSMLgV0IbsCnQQzIlleN9izBK4xZcJgoOzZ34pXSYh3WDxTP4hsTpgYx5E0DuQ08ejiMXHsCWFCaU2/v8Z6zTTBetWx2+1YdEtKycSYGENEpQBqZNkuubq7oms9/x/2/mRJkjTL0sS+f2RmmVTNzIcYMmvIAgHUIIBABMJj4D3wmNjVBht0g4BGdzWyKmPwcHdzM1NVEeHhny4Wl1lULbIWUZm9iCASCTKycFMVYZZ/uvdcPvccocPaTE0TL08XztMX9ocHrPQ4qw+WcUIzjTTDdZpI6UJbJkor/PbvfgPJklvmeHrktP+WafoIrnA5e8Zyxg8f+PKHH3n68m84//KZP7ZKqjN91+FsZBh6dn2HwZJqYjccuVy+4AfwzvLTpwsl69rc7wfmeSIER5OB4+lbDiHw8fzCdVLgFAc9s8vk2T8M9F3Ehx4XPb7bc3zYY4Ih0NGyxwaLFWXMGW8wpiFSsM6upAINpkjBGEc//ArXv+Pw+A/kJfObf/CUWnRdWpWytz5QJWNxSDNU09itrOsiCgScsMYR6LoHvvvt/4nPv/w73n/Y8WFfKb+2SEuk5ROyDNSYaHyDMYaljLTF4JtK5seH7i8N2V+/jDLrrNnWtSYbYjRBFBGst8SgZA5or+Ai6dncrb5Uzhi6LuKdBTG02rDO0q8eVxtgNsbcEpoNCBrrVoCWWBZNqFqTG0O+lgwbQM6a1HZdR9/15KIeUmnzK1oB2LIs7HY7BT1rsr4xWYF/xrLemIWvclHcQNg8qwzT6XSiH3rdi7nSnCa01iswVCYzLCsJouu6jTsKK8NynueVcd3jo1MZoaa+OG0d883np+8t1rg1ga3aCSAVYxysCV/O5Sum6JYEvmVqb0ByY1u/sjO396zEm6o5ypYQb+MlAt6HW3FiY0pv12it3Yobm+Tcdh/ba2OLy5sOg5QSIvU2J9v7W2srw7muUmQz87yw3+8wZgX+K1j0/tVTSaWdVB5NmrLMRWQFwkIpGUGBs3VqH9FquyXNW8HEbMn/luc2lXzDrMpHK7vaWVW+aKWSW3qzrVZWfmsUhJzSV+OiDPhXBvtWyDDGsBv27Hd7Zd/f2Od5BSgBHwJucbRWVjCyXnRlDtd1jmK343g8rmtDCytvgYExlhAsMXa0piAvhFdPtq3gs73vVd7P6plhHWzfUyze7fApY6y9ATItBLS1aOCwxjHPM9M0q+fWCsB1jalfn3Me9SdUGSwF9LKuscw0zczTfCsgbtfasE1rVQH+uh7nadZ5bpVpHgHNX3KtdLFXxZIVkG4eV6fjif/w73tyLaRZ106Ijtipco5di1AhGOY5k1ImpYm+Dwqcc72dRbuhx2DJVe9rmiZyzlq4sCq72PcdIQZqUV879d/TsQsh8P7dI8bqd12WRFoy1tnVn1KlyG5SgGjXSdf1dF1PazDPiRhVRtKHsJ41sp5tEykl+gc9p9+e1aUUUs6knLWrpeh1tBhiiSGqP9oq/2jV2wRnLSGGV+BfGyGG1SaqYpyy9F1V6TRpeSWs6V7cil3bObXJQVrntcOkVZqoN9o8L4yTzlET9YxsK5FR530rKm4bxdCWTC71VhCEVb7NKcvcWnSe7WpztBYxjdU1KUYVa/Re2i2WanEy3BbjVtQA1n1kbnFA//yvIKd+j+H3GH6P4fcYfo/h9xh+j+F/ezH8Hr/v8fsev+/x+x6/7/H7Hr//quP3X/5gvGprf6qFVCEXwVuDeMOcFqoom8A6j3b16sGpUgphPYAr/W63+ik3Ou/ISwJjOOfG+bmSy8jff9+rnPrVMBw7Shb63UK33/P0PLKUzHB6oC0Lv4wvPD2/4GPPp+crflCJ3dP+RG4ZK0KrDh92WLcgpiLWYWxA8rQyrSpiVX4GC0Y22QD17ei6TqWGrcW5uA6+YI1KBhc8ORVKyepBvr6vySYXbHDGrew3g3MeqY0QDC2p9PE4JoLvKOYKTXBimKaZaRa6LmNMwxmDrcKH/UCpDTGOx0Phu28CLy8T45TI2VCLR3zPUhNG4Ljv2A2Wy3lm6NQX1wfHwarf9PN15jAn9s6Ba7xcEsE7PjwEfvXOc9pXTIWnp0q3D5gC0/PCbz488v4wEGzjEAzROj5+eoEIz+eZspx4HiuH40LNhmHfaSIzPTMuCW8sQ68Hi7WalGlsr3RdpEgjJWWuDYN6V4c4rHL3HuP1wM35BeuEVBMmWJ4un3h3OjKlkS7ooZBrpiFI8xirD8pnuVBrpY8duRY+hcDT02daHXn/7u/4za//AfIXlqtjPH/hf/zyH/nTH/8JSHTxxOF4ZEzPSG58+PbvccHTDyfOTwsvz79Qpor3Pe/fP5JLoo8dzgRyTaTrhSaZlGcwlv/hyydsFU6nEykvzPOZnK7Umiip8v7Db5jSxOn4LVUM/+VPfwSTsRhszdhcaS2TUlMCy7Iw7AacU0ZjbgWXGuO0kFvGENTToRT8YcDhMRW8F2oVaoVWZ0xVKYuUFzAWawsvX77wP//Tz2AK/4f/3T9Ql4rYGfGe3kaePv/E88sTBq9dzb4i1hJjT8mN8+cLnpEkC4fDC61Wnl++cDr9Gt8cxyGSPmVySozzmUIh1cphOPD05SMpT7hwwPjK80vCFEszYIPnePyA/+lHxnnm24cDwXiqGPrDgWFwOFPZHb4nrL4WIXgev/kth8fvaUbo9x3TnDicDtioyZWtmrxhVfLKIDgcjaqJGkYlyJsCnJYr83VEamUeL3z8+AuX6UrNC6ZNpOtnWitgPC4Y+igsL2eu4xPPuXJdhCgGqQv/z/kzUImhY1km+vDA6fjAND3RhY5SM7vdQBXDPCUInvnzMz52GAo+BIzvmJYzJc3s4gERg9jCeXmiVkMXjpQ6Y13im8fveH96ZL/vaS2wzJaPXz7z01PCzFdsX0jG8Y+//z0xOPpd4HKd+e7dO8anM8/Phv98+Y8kqUraiIFGJS0jlIZ3gV0/EK0BUylFqMUROk8Mht5FcjWIVTmjXAUhY9p/jxWH63bE2JPGZx4fHni6VGpJgOXh/YliK8PQcdh9w8efn3n/3TdEO9DHPcP7IzEeaESOxxPd4PBBCLHdEr7WDNYGGpBQ8pOVjO88xjhca+BZ/dYNRgxGHMYWjLOIcWv8UDgqVZl1xRRqslyXid5YSJXzny68lEIdHfP4M9+cPrBMP5Ci5fDlF/zhHSW/wyPk9EQeLxz/z/+XvzRkf/UyxmrcpemYr0lgU78QWmsE71lWUowP7pZcbOC31Yq1BufdjZUuqIyRC/4GuLZExDqVtmqtkXJSAF7bmk9UjAFjVFZqYyDOdQYDBk3QrbUrYUVuDG8Roe/Vi6mUQt+rXNQ8z1yvV7quu8m5vQXuG0h9y5TfklJQADcMww3EN1Gpf5UJ8vR9pBs02d2A7gbAaq3sdjsQs3rktFtSfjw+EoJjmkZKyjRb17lgZacHRJRVbYxRMQYRvNeEcAMy3rvbtYAbuAzBf5UU6jpuX/03cBs/eJ3fTYJo8yPSz9mKGfq7b9mu2/hvYP4tyARuHQ45Z5VAMrzmS9beZMk2MDvPM+M4Mgw7SlEArAx2ZQs765Q97L2C5NYYr8qW1nWo667rlByWcoIm69rW719yYrxe1+8Ifd+ta0bZqRi5gVizfi9rLPMyK/M3ZaxRNngtlVLL2sFgb9+51Eqrr+tpA6CgSiDjON7G0a7yTrlozhjWvbPNoQ6lME8Lxjr6fsc0TUzX8cZsV+k3XYPO6hpSJv1WZDG361vrVpZ+Y1lmYuyJUQmkt/UHpDmt96BWHd6b275s0tQaQxS8x9iDaUzTiF2vD8qwLrnRWl6/k7sVwm7Aay2Ivf2ZwSBWCxBbV0CrCvq0SKTWS1tHigIpp3ulCDXp2sFoR86yKBY57AKxU3uWWjSO7ndKJFNW/SrXKPodSy1IK5zP59eCgLWktKyMZg/0a0eBBc/aFRDwq0ScA3a7AyFE5nm6AVCygIAzDiwEb/FeJRA3b7ltj2/Frxuod46Uyu1n13U9e+/p+4H9fs9ut791emyFV8Teii/OWva7/a1TY9vTpWRq066aUho5ZYxox0TJWrxLKWuBNET1BTTcztJbQU64FfuK1DV31yJQq7Lu6dfumG3/3Lo96irbZh15LVqWUrmOim1KqdQm/+xcU1W3rTD49mcq1yZScVbjkbOGEP0aFxwibS0m2RuTX5oWYPVGua1ZAzSpt3PFmH8u37btN52nzQttlaD8lzuhvF7vHsPvMXz7//cYfo/h9xh+j+H3GP43EcPv8fsev+/x+x6/7/H7Hr/v8fuvO37/N+iyOuaUEWOxDpyrGAp1VdnfgoVdWSmsjKttM1rnaA263ZGnl8+Y2nAVvLG8fHkmW4tjz9EF0hhoceHnaeL7rieGwP44sKSMc4bD4UBbhOPjgaflme50wOHY9XsOpwNpnhjnmWHfU+uyejAIu92RnGdyKRhbsC5Smh7wXeepoiwya/3K1qg4H8GhkuJNaBW6rsdZIaUF3CrpYgPLvNwmtDZ9yGu9025SMlIb0QYqRZlTReWVlRHW4ey6QJxhmWaM8+CulDySZqEuBeOFbmUTNVSMeW8DcbD07w80CtL08EppYpwrqcF0vYAJlFRwIjQb6KxjN1iSOGoRPl0XDg89Xd/TBc9UJx6GI9F6fny60kXHOF6IIfLffXci00jLC2D5dLXEbma3V6/n3Tc7Spv4t9+853oemSeo9QJGKPNCbkKWwBACxRT8mpwZccqCRCUyVCphd9sMbUk465E2k9MMxiHisc0whMCuc3z6UmklUW3hMsvKPhOkZpyNNBrOK1MTA1NJ63gKLnY8HL/FWc+PP/1nEMHbwNCf2B8PHI+BUhNd1Af53kQqiT/+7j9hTcC0hguZlCpVGs53/PSzEGPPsIucL89MYwJjCX0PNeNozGmC1ijtmVKTHk4uMGdlCl3GM1UKSWY+f/yZVoXogsrA20wzFksgdpXqLJ2ztJXg0WrBYmm+rYfxKhVjPHMVZEmkdqXWhjGO4DuME5zvkarBY9hFmqiXtLOFf/fvH/DWMXSW8foFqkXqhSnrd5bqKHXGUSE5pFWyu4AYcIZznhlC4On5TywpEvuOLy+/J80z++MjxvUazNrCOL5gbKDKyKfLjzhj8RWcnpJkLN4W7Gz5+LIgttLsyPU5YsJA6A50T4GAoVHojz9y3D9AyUQb+Pgf/++azO+O7A8HYr/j17/5d+wO3+BDUEn9xyMYQy4Ni8eIkJaZmhYuecYkmF+u/PDHf6SzldAbni5fsL6BLMzXCzY4YIekhLGF65I5PuxZFiUhtFq4pobvdqR5xLnGYf8IUpGScQw8/fJHfvzhf1qDeMfp+J5xSrg4qJR4rdrNHCEtles4Y91ICGAciBVSynpWWQvNcK1fCH3Pw7tv+enpCz9/+ZkFYfCRU7dn13/Py/iFNjWkNZp8RMi0cuL81Chc+MPPV/IMFnDGUBsYZ6hLxdCIIlgLxlSuly9M1oBx6iNjoSR4uiRicKtsCyCqPmIsYC0x9KSPP+G6QGqJn59/5PlpYZrPnE5HPj4/spTGN9/+BpN+Yb4+88MfCt/+6u8oSwFTOO0PnE7v+fnnJ2yIDMOew+GBw+MRaZbDwwd2Q8+w2xG6Pa4PWDGYYPFBwZLzO5qp0DSxs1jKrCAuTROlNfKyUJfEPE0YZynzwlxfkJyQUvny6Qvj8w+M1wupjhAtv3r3jjY72s7z/fv/wOd/+oE//OEfKe4Lw8OR0/v3/Id/4YNxBVobAamucbnekjyRzTtMQBqlWoZhQH3mX72rNImrFPvqW2atyv3fYv0KbExWAK/X3xiTmtzGqElRTm1N3jcvHGUld12HiNyY6VbsjfF6k0BbfZQ26bKNwbklftu9iKgnVF2LD9vvbAxhEVm/q9wk4IwxN2ZpCJEQPb5T5vOWaHWddu9vRYjWGkYszhlq1cQzdBGsfAWkQYsOW8HBmNf7IWiOYa1B3GZ/skrprb5OOn7xlhBv7OLtu23zso3DNm7bvW5js33/7f9vSXYpr1JJIcSvug+2z9jkwbaixzbHaUmUVtVTTL6WNduk5bZc8fPnz7diwKvEXLgB2pQK3kPnPMbZ2xyVmmlSkcKNuQ2vnmM+BgXXtZJSYplGPv3yC+eXJ7z37HdH9vv9m8KLUUUZr3YbIUZarTw9fSGljPevcmjOadK9XXcbY4y5rfFlmda1rFJy5apgqut7MKuHmbAWlXR+N+C1ff+bN59x7HcHhmFHPb0jrIz9Dczq3Oga2sDNtj9yLsrM9SrztizTWkhyKyhd/fGcR4/b5bZ2tvWq11gwxn3dAeErIWy+gAkYAEMMkRjiraPBGHMDgK8FJSHnhIKmtq7VxCZZpp+p55P1TpWUvL/dQyl1LQREfG9Z/Kxgbf1cYwNd12mxYe2kMdaSZEFE2O81n0wpYZaEiBYBpKml0uVy5enpWdd3jLhVstJYR7D+tu91PYeb3ODT0xO73Q7nAn3f8/DwcBvLrtOuimkemcZRGerruRqCX7sCXvfJdnb1fYdz257Zikevv6fFulcvPi04Dus5btaxsl8VD7d53dar9x7b1i6Z1fuu1jUftq+SnNvfwfsVzL6ep1t3Q6lCrkUBfq4aK4oShG8FFfTadmWL11UOr673lFK67atlTlzGGRG7mqAoALbmDSfdvEoqttbgZknDyki3BOeVtIzyy6WJfkZTCpvB4LQajPx5gRMt9HwFvbdCBK9dQvLmLHr7yzpP2gn0r3ndY/g9hr9de/cYfo/h9xh+j+H3GP63EcPv8fsev9+uu3v8vsfve/y+x+97/P7ri99/8YPxZrQLDgGq4JwenEY8rVYcZj1s1OvCSKOLnrRUWq1UlAFzPl9I80znemppGN90kWfB9RbjDHMSTmHH4+GKQ70gWoXoIuEY+eX5Qj8EvGvs9wNfXp5ptuB8R6uZQz8gQCmJzkesNVgqaUk0mkqwW0tNBWug65V9kdKM99rx7X2HoF4UKtGhrCQ9/MrK5nFrIDCUJojZ5DrayuYoGOcQscrgqQlnlUnkCEhrhNBhrR5UpSb17PUGGzytemoekerItdEkEa2ntkIuFRsiWTLjGgSmpsyUcZxprXEcBk0OYqAPHdM44RuIq8zXwmmIhFChLUxLpSTLfM688x3nmvBt4eAHws5xbAPnZ8GZynfHgWAKl1ZwJvJymfj5y8S//e4dhwdDJ5GcVpZbuZCWieAOjPMTfYzUWXhJC7udJS8OvEqgiBVqynTBQRPmtIBRxklbZSO8N0hTdg3WE2PPfuhYloVcC61mYhTEQmoGqJhmMEaZL83MNFErCBGjD8mjA1HviL7ryNNMllcGi5hCGi/Y+GtSrVhz5MvzE2VOBCdUaaRk6IaMNIukmZQmhu7INF3JuVLLzNNTwoSAs5UxZ0gFKdod79Zk0xiDa4YsYMggE8HsGK9Xvv3uf0MpDW8DOSVSKTgnYBpIXSVrGiKWXIQmhoao3ItAmdYAZVbppdiRkzKUnLVgPVUWLs9ndrsDRioinjk1uj6CeIwExFl6owSNaZw4j89E4zAhkNPCgFU5d+Mo1iBtxhi971YNy1IJIVKKRZon54lpurDbO3bDiX3Xsxi1CpBmKUU4HgbyJTPYE7nOHA47np5e2O066pQgQDOCixljMjWZVf7jTM4jtuuZ0kzc76jXxsuXT+R8JudEq7DbP9BCYmrPTOOPPP1//wlLwDnD6fgNx+MDpalsU2ui/jQyY3JmtIHvv/kVf/rxn7jmjwwmcDieOE8zuVpl4hWw2ZLSC6ap5Lz1kfnzRwoqS2IbiHHUMeObAbGMy1VBgGRKecEOkRiOa9I68/LTn3Cu4/T4CCuDzltDbgulZTIFkytz6nDeM+ULjoANHt87xAiuHom+w1nLh8OBl+eRy3Ukm5nJzaQ2Az3WNGyxnF8WpnEk2Mw4L/iQadYwT5ZhZ5RdSgAiNZ3xFvp+z7SMtFyxzSkLNRpyzZArMWocKU0BjQ3qsROi0KoSepY6kepEkI7mLEuF2AnH9+8JeMROeOf58svvOF++4Gm8//Zbfvzpn1imQmmVoYsE6+m7gPOOWk/k/Ik//k9nasu43Q5vYdcNNLdj982Jd8cT7775DYfTd1gbWD5/VJsHC9N41ntLidIKrZ5JOTGNVyyNnBf2hz0vP31CYiKPmewSrlmW5QKx0TmHJfKHP/yAlJFQM//L8v9gbIJtldYK42Vi98s7/q/83/7SkP3Vq1ah6zSx2mS5NlatubHB12S/FpaUCV7B8pY4G6syRCKQa8W2puxsaRrr1qRtA44bIFYQI6RFWYt2BTNej3mWlFaQs0m8KZixbvVeEwW1W2L4lt24LArivXd0XXcD6rek/M17N6Da9z2g8WnzR9vA0DRNbAzOUi2xCxirAGF7/9tkdkuEN+a8NMEkTZVijETbwcrsrLWooodTrytjhWWZb/f2FjArUMyvMcFZmmjeoUnz6tUjr/OzAeC6glHgn0mtbf//tTDTVk+revud16JEvwKOBgjO+RuA3kDjxi53zq1MWZ2bTVJPAUlck2S5zclWQNnv9wBcr1e8DzfgffNxs/aWxNdabwxeY8yNyT8MgwJRuwLAFVjO88z1csE7y7uHRx4fHm4yhpv0VK0VVrDy9TUSpSR2uz273YGcs7LnXUcMAeu+Zt4azK1YMs8TLy8v1Nq+Wl89gBKWCTHcfNNaKzeQ5NaOjm19bXO8TIlb98ZaONlAUd936/1VlSprm2SfqjwZI8zzyDRNxBhXSb2t26LDOYN3jtPDA7WoP6DuNQX6G0N+A/fTNHG9npUgettXGWXm889AoNp8FDbPQkVFWyFmvBXCYhepZZPbUtnJ7f0b8NJCkMM6izSdO2MNxmohqzVlS4eg49uq+ogZY5AQtFtivZ8lpVVqUeXitrmMIXA6Hlc2fcAHBXRtPddqrUzTyDheb2tmG6etM2Cbu+1s0GKOruWNlb3t4Vorl8vllfG/zq0xrMUjS0qJaZoopRFjRGQrfnLbL9va3QqX1mxF082Day10OIdaXLUVKFoF0K0BdfVQ2+Tl6u2cw6iHXUqLSvVZe/t+W8F1nhOltbVjB6x1xKjXwhjiKlloRItTzltMZ5jnRM1lPdMXShOC1Y6aGCPGmltcMUbB9ga89TqqxKWvV1lJ75wWCAEj5iaDJ7zp6DFgePWcW7cpVV67czaG+hbTXgu+WhTQ6zVq1U4lZ3R9qnLYf7176L/1dY/h9xh+j+H3GH6P4fcYfo/hf3sx/B6/7/H7Hr/v8fsev+/x+x6//7rj91/8YNx6i23aldpKIuVCA6xdpdK9xxqY5sTxdKKISg1Yo1+k5Lr6Hoiaum/simCpVmg54XPgvCR+9etfsd9nUu5Jc6aJoR8CSKOJw9IITiiSsKXy+emJX3/znr63GClcnyce358w1lIyxM4iNeONqOm8sWBEg2JePSJiUPmBkpRtVgrW6uYvteLd6lFQErUmmmnUVqi1IcbrRxpo0lbt//XhI4aUJ0pKWDw1Q5VMNgWqjks/BIxpiFnl6fVHSEl4YM6LHuTB0URY5gRiCZbV21Y9CQIdLTVMLQRvySWxLI2aJ1oWwNKHiOkMZjFMcyVMgpOeWRZs8Bx2HaZldt6w7098uczYi6EYy5ye6XxmroVmPL2zYA0fXy4sC+rxay1iDSVnzi8XbIB//N1Hfvtrw+mhR6znmiZ+uRa+6xrznPGddhRPZaJzHSGoNIe0ylJmllSJ8cDhMFDKiO86TC0YeoJxXF8+05rBiPp4eK8Pzpx3LJNuOusMXgS1MvE0KjnNNIOqAkjDCszXKwSVPO8wlDLhnQM805SZpjOlVAwWcY0//HClVkOrE4e943TcE4LFtI7rVTvanRWEhSzCz3964rtvH9nFHkvl/bs1EMaOnEfG+cLlyzP9/ggCS05MrdAkI8+/AydEE9n5yEKitZmaVcVAWqWJY5oWPfTFgdMu10PfM5cFj6eWQgieOS80Kt4MlLYQgyWnRggRI5mas8qHB4cYmKcJ5yzTdcZ2jnla8NLoQ6dyF1UDTi2JMhe6fqAawRmYphljI4awsq8aFd3/Q+2RONN1AzjHdJ1o1oNxWBPYDe/JWHAJayO7ELhcL8xj4v27d0zzjHOikj4iuOgJ+8hj3DNNC82p1Hr0EdsKX778gONR99wqAzPPX1AlpQKmEpyjVUP0gd+f/3v6bo93e5U7mUYwKuk0Pn2me9zx9J/+C7thx+HwgWWp/PHjF/ZxoMyJ6oQWO0ydQBrOL5QimJyRCiIFEYvxgVoTtWZmtOPaek9r4ESoJeKCXeduwpseS+H8dKbOgguG02mPjYHrOUEV7DAgOWHslVxgXhY+PJ7IyWKXQKvCfrcDqTx9+sSfLjPXZcL5yLDrmK4Th+ORzhp+fj5jfKRJJqeZYBNPL5/od5EQe/XqTuo/9KW88PjhAduEvCxYgkYb0xhfLuR04eGb9wy7IyU1ypSIoVNpI0m0pem+a45+5xAW2iqxXmd9WOz7AWOVqbvURhf3SJnxxmIl0A3C5eWKlwg0klTS8sKh7/nlpyeG/Y7w5YCPe14+/8Jl+sT3/+bf48VjJNEfDuymE/XxxB/+0/+blEai/4ZWKjZWrucry3JhWma6fcfu5Hm3/46Xz08EH8hSSPPMfL0y7CtGVHa/Gcv4fGbOQg6eLjj6VPm8XDjuIT4cuHxcqHbGWUcTj5MTOV/+0nD9z16tNZY5YVBgtAG+jYX7lgFeSqaJ3PxcSimknG4WKMqODijbVAjeE4KjrOx3lZmKmsCuiUkpRbvn17hPEZJZwUFVwJfzoszZVsEIMQYMTpmTTb2FjDEsSSXhpnnS+Nn39F1kv9/fwOAGQOd5vgHnDajt9/s1sZVbYvkKZJS5fno43L7HW/C9FR2CV6YxbwoRW2Ju5A0bdAVY1iojuuSM4CCDKZrU3ZJeXgslwFd/v5U9stYquBNZpbte72EDXNv9wiurFbj9/Vowsbf1sSX1xqhkmbWv8lUbIN9eb0Hsdr0NkG/dCiJ1BRTLba0ty3ID5O/fv6e1dgPkCng2XzVlsAK4tTCRc2aeZwUK9lXSawMPphmwhroy4EGLAzFEvDVUo35SOWUaZpXT0rHre491RteYNXrPztAabwpCK3nNaiGq1NfOjFLKzc+t1oJIwzlDjK/s5lsujcG9kbQSQdcpQpPC5XJlvF45HI8c9kdEhBg7JXG9KQzVWjBWvQJrbWAsIXRwA9zhBk6Uaa+SX/pe5e1unxXedD/oWlJ2razSZmAwJuOcX9dypVyvgAK1GLsbo9yYjUBWb+swr75ZWvSpCA3EfrWmjeHmGSUCuaSv1rMS+orKcTm7nlFZ5RFvbPesMWRdE865FWusxZM3a8YYQ4gBHSJz87nquo7dsF/Bpt6/955cCk3abZ3rS25s9a0Q6X0gZ+2i6TpVqypFC2V6FrwW8WotbExnLTZx69TZil+6P2UtwlRaW/36ml4zZwXs257eiiE5F3JKGKuFHl3X8+2M3u5f97ZZz8TMYhKbFdQmxbgB461guhUxvy7yNdoqASk0rANjVaLPe/1OGyPdAME5jNP14L3FGI+t2lnACo8PaMGlNi3MlKJn9Nbl05raVm3SaRsAf3vOtdZoRRWnZI0N8uZ/6vO5dWqtnoT8c7m4t9/3z89V3ZfqJWeMUTUe0KKReT3L/zWvewy/x/A/X9v3GH6P4fcYfo/h9xj+1x/D7/H7Hr//fF3f4/c9ft/j9z1+3+P3X1f8/sul1KVgKXQ7j7hKs0Krjv2up+93hGDIy5XjMdJ3PdeS6Xd70jxjrS6Svu+Y64J3DpFMRZizPtjYHw/ky0Kunsss9H1iui44F3GrUTymx5qZ075nvkzUnJhqoos9uxgJVj13+5M+TJrzwj/9+JF//+E3vH8YWEpiPo8sqeAOPcf9EW8CRYx2tHeRIoJzylCbF4NlIThHzUIl41dWTM5JO0oJKvO9ygF4v0qXGEdKjZwnhEyePS4ImQvzPLGLJ30QLoaQqxIIgsM4tz4I0wAjoolPkUoz0FKmZQM4rEvMK+PFGTBGDxvvNHAQhLYInsiP5xdSrvzdh/d465iXM50byEvHPJ05HQb8zvKuP9Bk5jpW/vjpC6ZamjHUbDkdI4ae3//xhdBHbIB0WViq5dt3PYaFco2YoIlW8Cp58v3331GkEf0eQyUcDgxhQIxwTjNhtnhvqKXRhsw0J1o2K9NkQGymP+ypLWGN+sPXRR9yFyOIixi1h0eMATxFFso0YqwSHmiGZZ6J0WNMRdAHj0ilpAVjLM5HVQhwHqSCAx8CMXR0ceA6XRnrRBcDZZqRImBfmLNw2h+Y00JIiZzBG4MQsV7VAFqC3lj+/tsjpSXSkjge9jydn3l5edJObqnsY0dwjqdPHzkeH2ipUqTgvSGNZ2KMPE8j1gz0ewsmktqCw+Dw1KQPs5uocoGUhsOwXEdaK1TJGOuwrmNaZqwF6wTvB1prDN2BnDKpFIbjHusCec5Ml5llvmK8ITXDUCOlJob9ntqEUiG4iLMCxtEdeoy1BKud24d3+1fmGZZmHCT1QtkfdoT4iPOBnGcSleidyooYoz7TreKNJ7VKXQwGzzffvGNOiWHYcb1eCEEQ65jmysNhxy9zIrVEZ2B/fGC+TAiGYTgyjoWX58Q0Zx7fRUJ2WDdT50yIjlI0cI3piohnmRJjrRSBLgo1v7C0AeM96bpwPD0yzjPzy4/K3rSRuQjVrJIiy4x1q3VC8sq080K2gjMRWqFa9QQSYIiR6XqluoIJPRBoMkOqICrNY22jmcrhfc84XjFLY/n5mdoMxjj2hz02L8R+IPg9MVhsN9B1R6QWLuOFskw8PUFrmUbl3cM7etPRmmW5ZsQaPj9f0eTD0yTT90rkocHh8KBqAt7RhZ5WGh+vH9kfj7r2rIO+Z8kXSEItwv7hAewOh8PbPZkr3T5SkwbDaT4Te0+3OzGPlXGcMWJY8gvB7LA2Yp3w5dNnhv0OsRFvE+J7agp8+vSJ7hCUoDNWlnzmZVLCi2mWy8uZx4cBCUIuE1+ez+x3hd+8+47OqZ9VDHtyynz8/F/45ceO3/2nf+R47Ggm48Rg/YHcMmEwDMce777lOu0R+YgxlZ8+/oyzgjOJc5n4/NRwxZHFkGqms8pALJMheVi6yO6hwzvhh/98JVklkjWsSsiYQlnZc/+Sl/dR2ax29V1phloEqQmzqr+UYtlY2c6pfFIz9sbqtt4hK0NWwZOqpygb192AY10lfjYmsKVRS2WcF5yzhDcSQK1Wht0Oby25Vs7Xkf3QYyzMk8Y+QRPq+iYZTlO+SS09Pj7eGLubnM/G3hRRmaOcs55vK7N5A3njOK4g3tJ1kb7v6XplEVtrb0oe8CpDJSLkqp5XsVOG6Zbkv2WHpkULGVuy3vUDu/1uBRmbHJjBr6z8TcqrNT0jQRPv7fO3n29JZVvHcLvubfxXMLIlzm+Z+tv3yDmTUroB25TSTRJvY81er1daU3YsKKDQteRXchOEEFmWhWma2aSoFGiUrwoDW+I+jiMiwul0ojX1/VJGu87fssy339f7Vr8pEfXKKkkZ8c27da0KxgitreBFhHmcsM6tPky6z8R7Sq1rEs7KdFdiY8mJuo4tVv3HWi2UIrcx2gonOhavSb9zCnhk9e3b1l3f97d1sD8cMKhEYV3B2TZHm/eUFi4c81x4eXnmy5fPTPNECIHdsEdBsV0BcyOlhVobDkcRZYrvDypNt8zLrSgVY1zBnxLeQlDwvRWrNo+mWlVey61s62lK1FqY5/n2u9YpgTT4Dmu04JZSYkkz5i1jt2XSkm9rte97Yow3H8LW2m0/boWubX0q29qsc1Nu/15z4Xq5qqqTsxyOR8yqflNL0TjjXgHpOCo7X4GazrfzqgCFgHeW4OPq81aIXUdr3DpfRHTP5bQW2lAGc8rb3BkO63hvBbENSM/zdCtUbNin1k0+DUQMzgWc04JD3/eklJmmCe0a8rd9U9bugbd7opT8VaFRi6qB3W53Ky7q3eoeLXkdx1y4jtOKT8yNgb2tVe+D+pgh9H0HdG8KIhCCp+97jNmk1167ZUR07XQhkmuloL+vDo3qwbdsHorGaGHKGpz3WBMooa2FFF0TKWXqCnJFBG8dGCFYZY67PwPIpW3FQb66r5Sy7s/1v8va4bBNRlvH8dYpRFNpxzXObP++FTve/tvrnL6OkXNaUBBegfifF0T/pa97DL/H8HsMv8fwewy/x/B7DP/bi+H3+H2P3/f4fY/f9/h9j9/3+P3XHb//4gfjnYt0vedw7MjlwJenmVoNJvYIkTQnfv39ey6XM9frmaep0mrDe8uu77BdxBhhvk7sQ6SLgZfnM7noAbZMC3MqGHH8/DJy6CzncyEOnuPe6TWWK6ZmjDe4aBknYT8MHB/OfLouGPPCP/z2e371m/d8efpCnq84I/zy5YkhVJZWOM9XdkNknhJ9V/B+lTCulpJU7tmg0t3SGqEKPhgwjWAic55AwGTI+aoPr62nWnAOpAh10cXR5kTooNsfuNqERYguYjoPFVKdqBWCE6LzVONxwWOMsMwzrRRiCCAF017DSd08CJqh1UoMvfr6lsIyTwTvoDbKLHhnaaYRBkfnIr0LpFIpBVxoJJuoDbou8vQyMn75mc4Zxly5LoXedIQoHA7qKZ9TxHmLWI+1HusbOV8pDIyp4lrGZwjHSDUOJxHiTGuQVY+emhtpypjombIw1sTjwxETDKGLtHmhlqIy4NVyPWdOJ7929M9IdjjbwcaokU1OCMQZpCmLS/0wOjCNkjIhdoiUG5GhiTAMe/VCMeCsIedCbzxYwa2BTTC8XM7M4xkTHNM1E2zQbncT+O23Hmc8OavCQC0LYoQ8T3TDwDQvSBGcN7gAYnTbnc+FPM84q9c2QK6ZKoZ+2LOsUjYmV3JyLEtj/92RS/nEUl7A7qiiD/lLSmAtBkuIjrqsB7cPWGugCcEoWyfnharRAbuSL6RVEPWUaXWVIOp7pmmmoV33oe+1875z5GWh71TCHqNkDmwBGqWsQaE5mgH1gVcfllYbQ6/dxQsjSvCwzMvC8nIhBqe2Dc3cDtCKYOyaCKJjMucrphbwhi+fn5UhaixLUtbW9fKCi54mhXFMWNexpIUpzZweD8qIcpViKssqHRNjUwWLurHA1P+91spUi66VImQMYhytZGqrNGns6jp2oj7k3jc94E3DrQd5Surh48TpXi4VY0HIYHQtq4e1o9IIfUeulVoLLmjCmHOCZpiTkjy8sez3e6wJ1KQMtd2pw3sH1hG7PQiazE6JMHR8/vSJkioNZbDlJenZJfD8/Ix3DmMcymZcqOocTue8yuE3VdNwXr2cSklYInPORO857AdNjnKDziKt0MWIiOOcrkq6OAxYHEuppCbMl5FgIzkXvO2w4sizMvsaDdcszuyYl4lWFnbDkb6zdNEQQoePnlItqVWG047cGs+/JGqaCSFznhe+/HTh8UOPFM9wHLi8JHoCaRmxxnI9v/DwCNY4RAy5zLhgcbYh9kIW9QuvzbA/RqK3hBh59+E7qB1fPr+QD0ZVO7wleE/Llt55usOOlhOpFuw8M3iHjxZjNBGyxtNmeFquiO9BErlUcjLsDz0pTZT8L38wDtCkYkXZ3+p5BaBM1a8kgJzHB49ZE60Q1XrEWotdQa+15s3ZITSaqqqsCc6SFlpt1FZx1pGLJk3X6wg0nFPJLucdKRWWRQF3CJ64sntba6vsTiVGTYQ2pro1htPpSC2FlGZy2hHegO9a6w1kKpBSWSjnLOOo0lFbEr2xgY01qNeQns+1qizbxtrfXtOkkv0q5+VQOwtN8ltTyxaAlPP6mQER8C6QS0Jao+t7rPWUXKhF6PqVpdteE0trLdEHNhmrTYVmzjNNlAmvEnyavEuTm1XGxtLcmLYbKN5eb9nDOScFx63y+PioUmpNaM3cGLAA6qNl1s9UKbFtLPV+wy053e5/A7TW2VX2Cg6HAzHGGyDXRP9Vnk8vtq7ZWllao61sY7eusZIrpSpAuo6X9cxSlntdmdnDbs/hsMcHfwOV1jiW5bXAsL2ssyopZQytFZw1xNgjomf3MPQYY1VNZZ0L79T/qSQFkLBJ4FmNuesafnr6QsnaqbCBOx881m7Sd4mui3RdT86JEDyPj488Pr6j74eV8erwTq2GliWTc13PYE9ekloDlYpZ1Xpqrex2/g2Tetuv3FjTzjmssetY67xZp/KJoaxjZh3WqdWMIMzzQnEF5yP7/ZGuS/jJ3Yo7OReEirMW51fW+Sq7t62lragHyjp2/nVfKBguK7isGISh66hrkWQDYtP8yrrWYpDHeMvpdCJ2HeM0AgqESk54txZxclMpv2ZXAROrhR0c0pTd7cMe71TScSsi2bWYmVJaC3kV514Ldnpe1Jsk3SZXqCxys56tTufMrfKB6Jp/K/u2FSzeAvlS6lr0sLfuou2c0325ecipxZVzdgXKKvFnhoFahFobMXSM8+qvVtuqkrP5o217TD/DWUsu2z7RMTC3IqO73aPGEkuWlclu7Vr8WO8Pp4VV76Cadd71rDVWmfesnU66h187pqxxquqD5ifOWuwGvPXL38b+bYcLsnamrIUAZaDrj63VUoE0xVFGBJpg1jleN/1t/bwtvNyAdlUpOqzFGO38cE7Wt9rb3GzF5+2z/rWvewy/x/DtdY/h9xh+j+H3GH6P4X87Mfwev+/xe3vd4/c9ft/j9z1+3+P3X1/8/osfjB92J4Yg1KVwfp6ZpwZGqPN6INLIec9cIl/GF9QSQzsvx0kZH2NSD+2UMhZlOhWBOWUqluTAt8RS4R9/svz222FlZBlKnbHGsD+caKaRphfECPsQ+fX3R/7x95kpN6J7JPpf8c13j3xr4cPjZ/KcKVyZnr8Q3BFxAWNhnGf6oAeb1EorBesdRQqtRmSu/Hj5hXweOZ6OnMeFf/Nv/w1hgLHMTNI4dI9ILdhgKJLAVnxspHFSIsGHR56+fMFUASfMdQYDw/7I9DQzTjOtwOlwUvlqBO9Vmr6szA7XdBE0Y5jmmZQqfbdDqiEvBUqi6zyyLlT1eK/46Og6iM7yzbvv+N2ffuEPn3+gFM9SDcejoaQRsZYfPn4kN3joHT88GU5HOO6ODC5w2iVwliU3plTojoaaFkrOZEn87397wpjGVFVOZEmVd6r5w2UeWZbM+ZwZfCR2Qi1ZO+CTULMh+j3jWNkdOqaUkZKJMVBqw/nK42OgtQkfAl+ernx4P2CBnBf6oQNUnqPmghEL0eCqQBEWCiHANC30XUTQTZTTjLc9y6xeHoIGAWvXMUUw1nI4HBjHCwawRg9EZx216gPMfdgzhI5aCtVo8AmxR2olxgJGPWxiiITowVSWecEHlQ8JziBGGMcrXfCIi5QGPnbayd4q4zxjTI8Pnk9fnpBm6Tt/Y3Iqa2wBF5QlFiz9sCPXtgYTlU631pGXdEvGnbcEb2lNfwfTyHlmNxzZH46cry/kql4NznllxrWCM4BzBB/Bq3+DsVvgVk8LsZ5XWZnGkiZC8BwPez5/ftLE0ytrMbVCKoUY1TudNXgLQtd1jHPCmIZxHiuQ00ITwfcBLOxOe0wTYlBLg/1uR82FPjikOq40fn75zDePH8DAUisxDHz77sh4+ZmctKO86zpoBXEgqAxRrZnn52fi0JGzBeNxptfrWyF6zzgtnC8jFcB4msB1mrDBIzSC95iqzCmDdsKLCKGziBQQIXaR0hq5ZHBBPUYQhv2Oy2VkGs84k/AW5pLoDj37foczDjGGh8eBvBQu15H9cY+1cL6OnD9/pvM9wSk4MFUDj49efaZqubFcvQ84a2Bjthp9j20AFiONZVJ/97kWTZiXRdm21lBzIS0VGixlYpkzyInHhx3LUpjnwh9++Im/+3e/waVEFyPPz0/qyVMKYtVfxK57WZpQWqMfevL6AN0Nkc71TOPC8bTXznlnuVxmUoOffviRv//t3zOEyvAhMV07WhsYmiFGiE6QaLguV3KGicL7DwMuB0wUkLB2aFdityPXGVzlH/67f8/j6YRlTxsj53Sm3/XMS+HjH67U8plSzoxPkW7YM5WZZakE3+M85C9ngqvgHUY6yI6UocmoJJ04I1loOOaSwCgR43z9RL8G9eD7vzRc/1decku0NPlRe4mN/bol1WHtmPfu1aNoA3iInolb4mYMOGNWdQpVA9gQpQBtIy41ZXm2JjdA8+cM1bfM6nkFTUomURY1hpWJbvHWrXJPUc/r9ewAlcPa/No2xieoNJIxVr2M5ukmz9ZaY7/fE4Kntkou0PXxBgrErqxyIJdC8J4+DmysUmmN0pQMlGxGpJEWZR6XWsC+jp8SuDSx1HhRqWuxolFvyZ9zblXVeWVEbol2TpllSTdgFaN6TnnnyGlNirtXRnVrjWVZbvO4zfPbn42jstIfHk/41V9rA9PTNK1+V8pU3aS66ipZNs/zDYS8ZSBvHQGwsuNXpvZuv6fv+xsLt+s6um6gNY2XOXNLzje5KGXPK2lt+7ecM64qM94WZc8aLH3f376b9/bmfaXeYAoeZF5u3QXeqzybylRZasnM0wKiUmcirIBJWahv59I5lajLOa3fVdYCio6ddnRYWsk4Z6CtDFtj3iTuygze7/c451fg1LPfPzD0O5yPCvCAVooSupLeRz/0GO9uAAQRat4KL7oPN2mzt8AtZzXga61RpSqJaiUW6riA9wFQ8NWt68kYlUX88vQJa2eGfqDvB0IIzPPM+XwGuMkp1rU7IKd8k2PbwCqinmi1qrzWOE2UnJRV7iwpJ+Z5ubHnnXNY5+mG7tYx4KzFYEAMBov1Sh6TrbiwdWIsQfNotxEdQbDM00haQVvJWQsKIgzzTN8PXC8jl+t1JYLpOfAKttpXnR1aYNoKfGFdJytDuqwWM3Vhk0vT7/TaBaF7fGOoV/peLWfU5w9EGrvd7rYnN4b4dmaCME0jW7fKJs3pnOIJY5R46Z1jGHqWlCFlxL5K5Omed7e1ba3FulemtbVu7WwpXxXQ3hYmRIRU8m2MtjW1AXcFxG1lyzdKrmsRQs/QutrxaEwxGKN/t3VPm3UdbvNg7Sah1tY1vu6xBiLlNqZvAbEgNAPGuXVshYZgZIX0xtzOkLfzsnVCgK4x4yzwKp23ffo2ltvvvv7sX/u6x/B7DL/H8HsMv8fwewy/x/C/vRh+j9/3+H2P3/f4fY/f9/h9j99/zfH7L34wLtKoLZHymVImQoikIsyzIXaFLgZ++eVMbqhX7pT0KX4tlDKTnG5wDWSFJS30uwMtJWprKqNdG7/+7sinS+HDqcPaRb1P7CqV0irjkkl1YUnahdhSwjcIrrKkwp9++iMuNvzQg6lE64k7h+WBzh7ARrpjYDyPdC6oB3iamZYLUCnG46zn5fwDn3/6zHh5oXeBp88/UIyhpcx3332jjBzv+d1/+UdqTnz78EithtBpV3I3dPSnB6bxievTC+O5cHjcY5ylUVjMlf3JYSavbCcSDj1sWlXZCkC7u3OlSaG2RnQeEyx5SVC0w7PrBl7ODbHKiGmlMZ1f+PZXHwi+owuRac4gCbGO4WHAXBMgxO493lxJxdJ6x6/3PftdwnmYF8Pn85Xo97S24K3n0BWmLz0+Gl6ez3Q+Eug4zyO2H5iWjMHwdJnoY1glFBx+aCx14WSOpOBIMuJa5mGVnS4lYaSS5kznI1NaCG7dwAgWwWH57tv3NKlIK/hgV3aXetVUKYxz5eC0q9WYRquJ3IScF5yB2hL9EFcGmKHWjFCwVpmSy5LXoOTZHw6cz2dalZURpYGrtIZ1ltipJ3KWQm0FH1X2wqCJojGOy/VMjOsD6NpYlhkrGphzXa+ZMzb2OG/Jc8GtLEZEGPY9JgRyNhgvXK5n9v17umGnXs9VPXb8mtTWSaX2lSUDsYurb0vCGY/BK+PHO6CRS8J5T1oy3hseH9+Tc+PlfFnZkCrLbo3FWQ+iiUxBEwsNgA7jLHmcscFj1kTHWKsEiJywzmCMMM4jrLI73vXAa3KiXtuN4AIrt4iSMqY1oDJPE6XU9TDPID1GDMNO11kwFu93mpRb9a4JLrAbBpZaSHlWqX2xNCmUZeR42nEdL8CMaZFShCUnut2gkj7eY7whGIs1wlwXzAVSnokBhn6HYPj46RP9MOBsuEkSDV2gZCGVimkaDISMs6owkOaFEPVcK6aqjEkWOmuV4dsy83glWEuxgKjkixiLG3qadbSqvuHGCEaEMHiV6M6FPC/0wWNsJVeosvpYBe2G79bEOYa4dqsXoo8gjmY0Ca01E1xHmhOVijHCPI8glhh7qEJKM6DJ/WH/jvGy4DuL9Y1puWJfKq3qvjk97hn6yHwZqS5jdUNRU0VMBeMwUum7HqzDeZjGmfmacDHSD3tarYgRnp8z+30gpWcKQhU47ndMLxdi7zFiOex7ihhMCMxLZn8I+OBYyogXVTEhmzW4Vy7XK6UsCA3nR4RKcD1Lqnz8/e/AiZ7NTsAFSg3EuMN5lUqbx0QSwTpw3lDJ0OB8GTkcAhhBUmMpolYXtkAGZyvGR65ToubK6fFEqcsKkoRSFpYp/TcF9z9/xaBeS9ZYBMGYdks2LYbgtMtd2cVmBRavYHGTCFK2ZFMg7Bw0BazLouA5vvFKEtGkxzmP9+bm9bQllZs6Q4zxq0RzS4CMURmoLcGJMdJElLXuLNZ2OMu6Vjd2Z77JRm0Ab/Pp2nyHXpNZWBYFaTFGvPVE3ynzG0+rwpRnTXCtZZmWG6N0Y8rWVljmvI6PArlh6Bh2PcFqkruxIJ115KpqKKDjJq2RcsJ7zzAMGONY0ox3Aess0iq1cWOp1lqpLd9YrN55ppQwqLybWUH3xsZvrd3GvW4KFCsQUxmxxOl04uH0DuDmlRSCSkOllG7gfQOwrdWV8d9WcPQ6p9t1Yww3tvT1OtJ1HcGH9bNGUkp0XaekrnXeNtm0DdgroHDrGnJfse+ds2ACXdPzv5SGtf52DyKGnNSbb0kLwUe6Lt6SZC0qKNBvIvjgaVVVN4zAnHS/9X1/Y9sq30/ZqSJCLcrY3cBma1rQ2Fj73rsb013Xe7uBZC1MaOfI5ne1FUDiCvZarRDCWuySG/DTMdIuEhM7vG83gNh1Kk3mVuUPZdi7mwfZPCvhbNvf1ppVvs6sxQj1tdr25bLU23c7n8/8+ONPHI8H3r/7QK3mti63/bmBZgBu+9/dQKzu60DsekpRKUXvw62gYxEiBpG14LfG826VgbPGsXUV6HrxiGQt0FhDlXbz/VNQvmj+4gzGWYZhULa/c7g3wMsH3Rs5Z6ZxuXWAdLGnHzpCUELkJsPX9+qpKAIxdqSknQci3M4alRqstznLWQFz33c4p16MG4je9udWLNzWxVuAuK2dvu/YvLTentNbl8723xuQtkb3Ra6Vp+cz47xgUT+5bW1ua1c/R4CCc5ayrvGtKJFz0fwUJXXXqvnhxsyWpl1GOb8y0Lci60Z4NBhaaSylrrkuSoozINauRHd978Yol9oUPJtX+TZZi0nbfb9e49U3cmOYvz2fNpAvbz5vG4PX8+Prn729rl5bEFGrJFmp8G9+fPvd7d7+vEPmX/K6x/B7DL/H8HsMv8fwewy/x/C/vRh+j9/3+H2P3/f4fY/f9/h9j99/vfH7L34wnpeEl4JDOOwD41LJRXA+YpxjToW0XAhdr53X1q9fsBK8MkW6LvJ0vuCtMk1STro4nAcM7/rIYDsejpUPe0uqjjHPzJJwUQNUKzDsdhjTyHOmmgVH4Nuj8Okp8fly5jflt1hZmNNCNSqdXVqgcz00qGOhtx3FLCxJ2TodHYaqUt9VELPwy+cvzE8XbPDs9nuiM3x+/sjnX36mzAvNGpaa8Nbx4z/9/+j7A8si7LvA97/6wIdWuZy/8PNPv5CywzrYdQdcVAnyXXdgNwy0kglux+cvL4i58O7xnXbYLzNNUL+YUjHrYnXGYIIj50o3qJx1bUKRTFoSJjd+/d03fPerv6eZypcvL/zp4zPOeVyrHHYd0zjxfJ6pg+fb40AtlcVcaUvmsduDWz07WuH3n74gFmpqvP/Qc70WSDPfnPaUkvnhMnOdZv4udJwGoFqel0wMkSE4rq0yfxGeviw8hD0uCMdDR+cDeS68vLxwPJ7wQRivicP+gdgFWknUXOi6PayBeb/rGacJYz0gpJQ1vRFhXBKfXgpDPGCDYzELktS7fb/rlSnoA5fLyLIUhi6w2/VY12iiXhabP/vhsLsdqBjIueJW73HrPUbMmhQ1EMsmyRNiYBpfVkZOz+Vy4fHhQX3qm2BdwErFWNEE2HkG5xFnkVywThOlECIuRJW7Nnp4ik18++0HphGaaWsXu9WH0QZwFt9pYmGsIae8SnNbStEHskY0+HoJWG8RwFjtMH9+fmLoDtQCcypEv0m8QG0qty7SKAWaWMQow9NYME2wxoNTef8QlRXmLLgYNdhtCUwMlDlxeXlmP+xwxmLcyvysFfMmMLXWiMHTmp4ZraoUjiaggMCcZvoQcVYlys/nC7HrqXqeM4TA8bDjep24LBnXAmIz85KpxtOsI6z+5rUZUq6UeWE36HW9j7SmEkC7fmAaG7HveTz15KXSpMKaxGqQqHTRU5eJVoVaHa0JIVpE9KEuRZN426A1Vhn2gneemitioLZC7AKlqIyRiKU0CH6gVsP5ciFYR7EatDrn9OG76Gfu9wcu1zM+WsRagg+UUimiHu7KSnVkWeWmfCTlDKLMTjEqUdSyqESXVZsCZxxLSrTcKHnRZLXJ6q9S6fqO4bCj1ESZKylBKYnQGU7HgWm8YsVhCITgWFLB+wFrG+P1Qq0zzgtlga4fMA32u45SC+PzE8Y1BMeSHMZMxM6SlqbXCB7boKYZaTNlnhlTxfoA1fD5xwnrE/0xkCt8evnEh9MHei/alZ5HjDU44wjBormSMM8XlnSlGwZaEuJhR8Xge0czmdZgmjRBtAb9fgK6JSzeGSxKSAjOItKwwUOziDc0Y5EM0TnoLCVNYKAPEWlC8BEz/MtBuVuBtRJdNJEwG3McTRzcmrwoy9R8lYS8ZdxtyVcpek5tklWYV2ZfzptEWFZAur5v8zrakqUNLG7s6C0x3663JfLX63X9PbMqkJw5nY5Y52lVlS422aINcGwAbpMs2z57t9uxP+wIwXO5XJimCefBOsE4JSGof5eqJ5zPL3QhcjydVvLUwsbU3u4zl4S1jn7o6GLEWEPfR7wPVGm00vBRz8u0Apis1OwbI3tL3F692RqmvjK+53m+FQ8U+M1IqxjvaKJM5hjVCmabo+3PPM86DlXBirMeaXC+nG/J7MvLy1fMTAXW6vUWV6k/HUN7AxohqMqEtUbjI2ZlezZ80LE/n89Yq2CotcbLywutNY7H43ot1K+rFWLnb0RIvYdMazpeuj4qy1JubNyUFpZlUsayscT4KpO1FZAQsNgVdLLar8gre9aYla2sijdtVfRYloUQFCxi104CaxHTbmt1Az8bINJxsGshRuXK6iq397YYtIH2jRW83W/OafUuKwzDALBK6jVaKwhQN2autcq4xdzev+0jBZlqo7IVOrquX7sjuIE5ZRoLYkRj1RqjN3CiYFELAuM4UkrhdHxgv9+vMT2zzOlWPBORGyDe3r/N1QZ63nZObEWXvtdca5sbkcZRs5Nbcc859faiCbVqUSqXTC6TFg2rSig674mdrlfvAn4XqU19u27FQrTzZpvf7f51XzVeXs7MkxIi+6Gj7zusVYmuzccvpeV2rhijzOltjlkVZ1rjVpTbZN70PMo3tr6C8no7RzeArr50r/OxnZPbn+18fFsIU9Z3XfdOxZhNXlDHa04Lzy8XlpTZD/3aJaTyh5sco8Gs0pVyGxNd53ovuRRK1u4Iv6rhvAWdPgQoZQXLKrlp1kLwtjaqXVnpVWXkrLNIrevecjjWc0j0c8VqxtfexKK3AHnb8zpWKi3653HrbXFD1mIwGPLqIbmN6bZ23xbv3n7W1+D8lc0v0tZixuv1/vwe/jWvewy/x/B7DL/H8HsMv8fwewz/24vh9/h9j9/3+H2P3/f4fY/f9/j91x2//+IH4/N4xlXPvg8Y1yhekA5aEfa7wJyFeWmUWkiADw0plXG6sN+9o1Y4v8yEztNyxoVAKRC7gZQqSTIH15EY6UwgN+0AbMby5TnR7RK1Gh4PR8oqYSLNYqOylR7Ec12E1CrX8QXfd+SmQc/ZjlISpDOh6/h4mTjtV5l2KUhTKQxj3PrAcybVEXFQu0CaF6wL5CgsuUKtTPNMrmjH+csTxnvwz+RU8M3x6cuZb55m5jyS5kIXHX/44+9oxfDhdGR/eIf/zYmX6UpNmfH6Jx7en+iHPUrQ0Qkd9jsWoNv1jONC1+nDq3m8kotgHLhOJZKtcYixGCccjnueXy40ZvIl0xvDIjD0jp//9AM/v1R+++5b3sXCZTHgGkPzPM3CZCZOdqBS+OaxZ0yZ69iIvSVN4IdC1/f0nWMeZ6I4Pnz/AdpCPxyZlytHLEMM6j1/eEfvXni6Fn7340/85ttvOIY9ZZoRE5jrwvL5mb/77Qe++/YdzltqBXFePTLIGAfGOi7XK96pLDgCXe9ULqg2drsDf/r0iZQbwVqMGHxUJlMIkVqUiRZC4HLNLMtE3wdqWTBO/blbafTRkeaZsnZMizQwq9Q6FhoUWX2WnYdWbslPrRZrerwLzPlM1/V0vkOKShktdaZb/YKqFLzxWCwpFayxlJyxWJZ5xFaLsQ3vImkunB73YB12cFSzUFJS2XZRjxofO4yDECOtCsOuI1fBOEfNCakzzqh0+nRZwGjQGRdl7C2p8sMPP/HNh+/Iua5ds+olLa1hnEWaoxpNvFIqGAN+7WZuIjeZjZLVc6XltpIYDNaGFRQUZZKKkJYZH6I+zDeWrtuBc+SqkkStbSysTMqZ4DzTNIMR8jo/JQnNGIpRSZhht6e1isOpx5A00rRwPmtHs+wiy/WZ4Hqenp7BBxKWvvfUVHES9UG9GF6erlhjGGvB5kBdZn55mfnV9+8Yhh0pXTDO453jfLlwOp6oLWMoKoVlPedlYZwSIXt8gKFXvxajT/hpooxTKxZvLTQhLQupllWSyTAMJ8QWTBHm66xznCrFC3iD7zrykmlFk2ZjDGIsNg6EGMkl0Vqh1bLKCDlC8MyrrxQGSq0474hGPaesV2+bWiutNHABxHK9juyGHTQlZ+SSsC4iTT2CvDO8nK/ETiWILudFEw5TV3YvuKgd8UYqGSVPGRrBCbHrECOEGIgruzHnRsqNlEZOjydSFj69PPPb7x+BjstloknFhcK7XaQ1sD5gfeQ6fsZRGK8L/b7j5Tzx7a7j2Fc+f/JQZprxYApirSZgUqhZO+RFVKprToVmExShE0drK+hLC0aEaD2lLhgfkGJozlCplKo+5cZaTPWaGBehWUO0kWSyjmFRVYUlC53v8KFSjILbVrVz/l/+0sRA2a6sgEDDf66VsEpUaXJVMfY12XubzMBrUqJMyFeZsc2755WdqNdwThObLSHbwPFbBuAtWRJN/rdEpu9VPt4aw7CC7Y39Wkq9Jbua2CYOh/0NzGzJ5DTNN6+zvu8ZhoFh6F9BpXMr+1Ol/EVWQl+INKnE6On7SIxaIHDe4kO4+XM559l1O7q+o+9Uam4cJ+Z5ZrfXGNFq4zqONGk3Nv/2iisgF5EbIN/YvRvz2TlH1ym7dWM2b8oUAMOwwwdPjFHlzox6Z21jvMUn65RJXEtlvI5Ia5weH28s4g30b4BzA5HbfSgzUz/Le0/wARFl/uq6sut7VE9rA3IfPnzAGMPz8zPTNHE6nW5zqWuKFRgNePcqH6hJbl0T3kLO9avv9XJ+YrxcGfqB/eFI3+++kozStfnaabEB6G0OtnW5AWJ49TJS6b91rRuz7h2V4tsA003iL2dSXlQN5A1AyCWp5cgq9xRCUCCzgjj9WxnltU4KlKPHO4vQWJYrOfvbHAogjVXmT7CixLYNRAPUlYUbV8B/8zOzltwyznlCjAqeDIDKmNWS1wKC+WpuclYZwK2g9fDwoNcRZR3rOK3+Ya1+NebbebC9/78GdrbxMsZiRM8Sod3OKmuUrGitIbd0I+gZI1gLIlWZ4qlgMIS1MNF1nQLMWpkXLbYgWtRIqxRiSgnEYJ1lv9+hsn6O3U47ZK7Xq+azx8M6b/ZW1ABzk6dTvzbWc6TdOjw2/zoR1vOq3QpvrZV1PKwSW6v6wm0FsJTSTbJw68TZxk690jYW9tZNIJSynrPWgjR8iGv8aEpMXItqu74jxnCb57dFnbxK2jnnSDbduiBabev4bb/7ClK3ebbWUlqlWYv3b4q8Va/dWgNjMFRk/UxjDNa8sswxOh9vv5uxBu8tVb4GuG/B8XbeyxoTtvv5usCk9xtC0E4heWWzY8xX5/Lb+PeWeb59p69fXzPZt+v8eez8173uMfwew+8x/B7D7zH8HsPvMfxvL4bf4/c9ft/j9z1+3+P3PX7f4/dfc/z+ix+Mm9gxtcqjC4SuMmXD0DVK8eRUAG3lT7UgxpJToZbEr7/7Huc9Ty8jJgRKSQiBuVS8dYgkXIgcTOD5MtLZnm++PZDLxJQLUzEspXB+yuA7qs2cOpWgDkcwNvLpy2deloXd0FMl8/Lywv79b/FDwKbKUhaMNMQ6LvPMvCzEzhGMYI1gaIgx+mDFWOLQ8c59w3+JZ1rLmNDR7Y7EncNllS7uh5l2zsznKy10nE4HrtcrzjtC6BnrxP/nf/wfEBr9rqdKpeZKzYUffjSE0BP/p/8Xsj7UfTycmF++4XB8z8MjdEfwrqONBdsipc6UJeMREB0TsSDi8NZx6Huuy5XmDQbHsmTq+IKj8vHLxJcp8PDgcCHQ73a8w/CyXPlVPHJ9mYje83kUjgfD588X/pSuvDvusKFyHRPWBDyOvmuMY4VJGKshV+EYLKVWvrzMnLqekz+x+MQijaU4hpI5dANTu/Cnj4nvlko5ChWLr4Z5nCnWqceuq7TccCYAC2UWkqs44xmiA6NssSU36lwhOnxvCCYiZebf/qon+o5aJywqXWxRyemS9aCPncf6jv/5xxf6neUhNubi8UalpGurICqNQ03E6PXhexNyyQyhx1qVaacoA7GKdqWmtCBN9Bliaxz2O+3iRz2DjHX4ThO1Xb+n1DXJMJUijssycdgf8d4RO4vYhiwW0ypOdszLQqPRTCN0Ub1yqhBDxGEJLrCkRHCO0HUsl4XQRboeSlpwDiNy9wAA0eRJREFUXhlCwTusRcdlGrH9jseHd3z+/JlmKt43ZWxikKryQ7U1VYPwfmUzKZmkpoZZE5dGBZR51QQEj5gG1YEIKU9Yr59jxOBdr2eCZLztESuUuuCqHoqlNagahAxCKTPWVIZuQGrDOOis10DtHRZ9iF9KJlmgJCUTiMWIVTKBbdAcY6uYGKApm7Q0AdMwGOZxYcZgUW+ZEDYgYXjYD8zzhT/+vBC6gdqEYYikaUKqASeUZhlzYegNPgpH15NzYpmV3JKzylAZIrUmXFH2oTNQaLgQGYJHqJgIVWYkW6QUzGq30++PzHlWqXo81gZs0MSk5ELKIz72lAxUQ4tgukiw6oFUc8ZaILDK5Qih66gFTAwYI+yGA8UlLpcrXjShX1Ii9AO5VqyIriXn8TGSW8ECx8OOZUqEvuNwFPaHnqxPq2kN0rzgXCMnmMeMO6wADZiuM3bo+ObdA2mqmDBgWyKdL/guYExgfnoip8qcBWeEXz2eqEaYl0TJGeM9OQmuZj48vEcwtHSh5Jkqls9PV+y7jm8/9HjrEbFYoExXmg26p6JVaai6IEUBm7OA1w5+Fz1NNI4Za2je0lJFasPZDDhc9TRgnrWbPfiAjWZ96K6JiW0ZaxzVqD3HwJZsWGquBN8xjVd8+G+K7V+9VEZsjeXmbWKjzM1UC52LSoAx5pa8avJrbqDsLbje5JrSKneligmNTWJqS5KcU0mmnN0Kkqcb2HvLmjXG3AAXcPtd5xwxqGRaDGqzcDwelSm6MoSt9Thnbp+tQEDZrfO8rIAoUkplHFUiX6SS8wZCNcnq+m69L0sVZV7u9srkb6ISV855apvJNauFQ4z4oElybUJZvdycUwLRssxM80wXI8GurPQ1AbfG0krFx3ADJxu7fisYsK6Ht1JFzrkb4B2G4SZPto1nLa+AZxtPnR/13bpMV0otfPPhAw+P71hW6Sf7hsFba1Wg2RSISNO5dn71tnMaE7wPt4LMxnB3zt28zw6Hw8osV3A4DMOti8AYwzRdWdKi4IuFvjfrZ3pqVZaxMVBrJq8M31wKOSf1qEp6nSqic/FmLb1lWysg2vyn1KMvpbx6lBVC8Ot17W0uNnAvrZHmeQVKr8UhZSurlYra/nADNwDztDCz4H3AhaBycSvbH7YujUCtjZQKMfYMe/XPq7VSS8FZB+jcLymR8oJF1xBG18YGjq21t26Ibc1sAKfU1fLFq3+eseZ2r955xKtlyVswo2fH5tsVbwUiay1YnSdpmuu0Vtlk5jbWsJ4DjbegfBvfbY+31m4Fpw3stGZWVRwFv/OcqDWBvIJaQW4ejSUVZao7h8uVmQVjteDV1mumeVnnUr9DH3v6MGCtJXYB9STMK6DOTNPMTz9+5Dqeeffu4cbGF9Hx2e/3qB+YMM8T4zhirSOlfAOAyzKvXT26nrfvrOvHMS/zeuYZQAsn86xFEC0cGmLstMiFSk4uizLdnVd1oNJU6aiWxpLyDfyHEIidXfNWndeh7zge9oBhmZeb5Nt2PmhEMLiVka+kRPW23Aq7wQec/ZrBLWihSkTITdn3IqxrodGqfr+GrMRWu5IhzW2/1qZM+5zz2jmlYNpZi93OoDcFhO2808KWXXNEfZ/+t66d/9p7ylbkcOoNtxUct33z52B8A/abdN727yJbR4UO0dtOq//a5/xrXvcYfo/h9xh+j+H3GH6P4fcY/rcXw+/x+x6/7/H7Hr/v8fsev+/x+687fv/lD8adStvWBk4s0VekGUJfmaYAPiBm0U1SDRVtz8+lUVqhNZUGNitTToA5KRNsyVeM027Sl2umOy6QGsfjwLy88LAf2O0H5lyYriPVOHzTjtt+13MYOsZlIpeKa5GxFEwDu/r6tpLXjnCoS2LXRYJ1eLN2+Ta5+QiUXGhGKMWRZ/h8TjgcLkKg8f133zOXkTklilz4ch61c30sBL9jt+uJUR+sLLmAadjgaAUOhwEpotLorTHNIyF6Sq08X1+4zhPu4584nd7x4dsPVAPzMtHHHd98+40GAycs48R+t6M5j1RHywtDZ3H+xOesvrZzXXi5LtTS+PQyk23lIHtCF2i152gy/e7AcTgxzS8QG+YyMl8HhIjrKtHBy9J4OKqUS8qNmgu5VULXqxy4jSy1IUvmu3cnnsakLCaZGfY7Um0s4pmeX3h4OPLhMeGDZZonWhZOhx3DwwGaIc2FsPOUllUWXAxNhHHMfNOdyEW96L2DVApTzlAcBwvBWuZc6ejpXcdUG8+XkeNDxGJAPCGsTDKEp8sLUoQfPs4Mv93hqEgNnEV43B2wBobO0VqPMQ7TwFnt6vbekErRLMUYSi0YZ5BWmScNDEZkZfIVvDeU2rDOM4QDvg945xjHKyllrPGolIUQoiaS6hdhEAwpz3w+F97/ZiA/zXS9Y86C3w5J91YypRK9duqWrId8cB5n1sPWqp/6FoyXeSI3y7vdCR8i026PWIdzkY15WEoBC10IiHUrcUCTU42ZenCWXMh5JkbtEJfWsM6RRTCiAdbHQCkLKVV2fY+hQa1YA3V9iN33PdUUSm6AZS6JvgvqLY/To9Oqj4aIX5MLAVEvDucszhrqMmJBPTOMZxj2mGZQZYDCeB2xVhN1qZATpCUzdJFqG8YF0gLjdeLD45FxzFjfYaxXRl0ztCJMS2boDKGP2CBINczXTJHEb777N/zh978n9IKPHXNadN68wwpIbXinXi3GBFJWNqGxhmbAxaDeR6tPknaDiyZ1Al4MqUAzggsWZwKlLioDPi4YGWilIlLoXL/aMhSMBDCG2HXkWpFSoBYsBmPBAUtauM4zzhi6IVJoWGfpdoOuvCqE2AMFrGWcJlxUhucyK0FEmiMGxzxlwFLNSKtR5fRTYth1ON/R2kRJjVYt4Oliz3W8El2HtQJOGI57xsuZ6+VC7AaOYmhLgRApVIoIU0pE59m7SIsOaRVLY5wTtWYqEGKjFUctlhAjS7kSbY9Qcd5gHeAstVUEIdeMC5YyJRBl5dYGXtTmIpWMtQ4rnuU6EaPHuEBrib4fsM7ho+c6TZxOaze+tSCrdJio2seWbBqrRBARND7kzG43YOy/nLVu7XZGKIEFY5Cm62aTvFlSunkcWfNW4qghVrDOvpEt+tr3pbVGThlrt4TOEFa24ibp5lfQxpvkKsaINZZlWW4AaJM0U3BgCMHThYCzlmmaWFK6JZmtKWt7S+pTyoyjyno1WWWF1qQvpcT5/ELfR97JIz54EFHA5LSQIKJWKs5x228qdQUYq0zwFYCKNKwzNCnY9bycJ2Us73ZHBX/OkvKCMer9VLJaKGi6qN9NeE3ijDE3S4ItoZeVHe29+l7VUhiniVpffbXqpp5R2m3M6+p/Vpsyq5clY41hmlTybrcf2O33yAoARVSWaQPjt0JF15OWZS3SCMEPKwtYwcTGTN4+Q5N84Xq94JwqMEzTyLIsatuxghv1VtOccVOAUfa9Ybfb2PbtBnxqK/Rdjz8oW3+aJgWDVdcmBpX1yunG9l2W+eajtvlFbWsBlA2rElp2Xd+J2iqReANWwzDg3Ks31cbG1/2UqVWBvXPhBjzfsrS3NW2dwxihlMQ0jZRa2A0HRAwvz2fmZWK/3yvo3VQ/mnaTWLuC4a2I5bwCoVowohYdW+Fsi7ttlX/TzgG5fWfnLKUWxLyCCLkBm6174JWJHMKr96Bz7lZMCaHTc8oIuabbueCc43odyTnTdT2t6TgiOt5h9R5UH0VHWO8jJd0bm/Tbdq5Yq8x+ZfyDsxofsJrf11LZDwe196iVuhYDYlztP4xhWRYtBJXCkhZaE/qup+s7PfPQM5eiHRHLnFSqDJ2Dy2Xkcr6uHSHdV/MswionmCil8vyktkX7/UBrakvi/at0pUpEcmOhl1xw3tN3/Zt1pZJstaraimgWuwLXosTEXAnB0ncDm4SYFgw83q/2O6JdRSHoWdpavfkJzsuyFkeUkGbXteq8UyWjNaer9bXTo9Z6W1ulFHxQCbZaC7mqtFtrdc1T7ApiG0WEsno/NgEpqkjknUfWfZ/LpmazFgJ4XYvGWDBq56MekgqQQVNQ51+LBloc1QKAZe3UEQWAtyKbiPLl5VXqcnu1Jlrw2vaBWXPGjQB7K9TpZxpj2MrcZruLN/vnf42H4vq97jH8HsPvMfwew+8x/B7D7zH8by2G3+P3PX7f4/c9fsM9ft/j9z1+/zXH77/4wXgtmZSEOXsedp7oK8H15GkmHg1zqUyzxXeBlCas8zjfkYqsD310Qbj18DNGGUgGx8OxpxZBTCBn+ONPz+ztgGkNTKTv9nSuYSTx6eUXendi3wdElPEQrOVXH77hOiXOz4lLLqQxsXOBgujDaWNIaaFJI6Ade9ZbxDisscDrQQvCOBWkCSZ2pAV+eZnosuX7D4bTsGeeKhiL9x3znJiXhhk6rnMitaqa/t7TDxEMhCAcd3vG65U+RJoT0jzpeIjRTkLrqKVRTeN3P/2BeZrY9QPeT/zu50/8w/e/5v/4v/17PiL8dL6Cj1yfJj48HBhT4WU80+/3PP3yhZ+/XPWBeKmEMND3gT507ILleSo87DrmaeKljux7R2rKBPrlcsFY+HAaWKbEad9z6iyXa6aPjpcFxFjGaeH7709cPl+xAR72BwYHf7xMpDTz23ePLOOZ61KxvhFCxx9/+kwcLIuZOcYduXnOl0l9o8XyMsHeWawvWB9ppZBd5XqFYxiJ7y21eko1OCdYqj7ApfLTxydiZzHGMdZPfHxK+M5hrOf5OlLTM8f9idQqv//pzM9PMz7ClOB6dTw8WFqz/O6PZ9yvPPvOUlsB39Ma9DEyLxljhJwXWivEEGGVjzZWH8p675XZWApNDEjFGaG0AmIITjtyx+uZlGa89biVlVhloe8jNQutFGoGZ/Thc6Lwv/zuf+H7xxOtVFpBSQ6trPIT68NhtCvduUCpmRg31o7DB4vFUKURY0eVVUbbe8bLlevlJ4o39Lv+Jnlirfp4DMOACMzLTN91WBNW9mbBOSV3GNNurCq3JiDGgBEDRkkN1jmi68BDLpVxvGjCGjysQdgBS20Y1Lt6KZm+8/jgaM3TWlq/k6oteO8ppVJKYxkXrBGGfcA4S14K8zIx7B40AW6NlCsudPS9rN3ghiqZZQFnAtasgTEX7UAuDeMiS0oMztHHQMlXJRw4T3QBQ9VgHT192LPMXzDF8+njJ758fiHVxOnxHfNcCNcL7w57aimklNX3SFRKx/tISyoX5LxVRYLUCJ3FWyVJWLcGuzUpGPod05JI+cJu16FeOpHdXjvTQxfwbk/J82o5oA/La9Ugg1HnEBHIizLFpnGitYK36jtirCZ+4zJz2u+wzVKyJv39EKm1YUOHtR6pqtLggsd6t3avV2JUn21jhFoEZRNrsC9Z6PzAuJzphgHrFDAZ7/RBeIyELnA0D/z09BnxjeYEC5yGwMvTJ4YQ2VlLdEomsMbSZPXztg7nG605Pv9S+PAh4taH1zEe0LZ6YRgGNt+Zrot44yi1EILlWHeaPEpRILWCAR88tQgtNXaDSgFtskkijZYrffAIHmiaoNVEKQr+WlObglIq/RD1/VJpq7pFLbOCAffPwvJfHuj9ynpuDVk5oK3WVRZHAZ13ASOvxMQtidQkseFWxu+WlLTWKLlgjF1JQHIDiCrbr2zaTZbMYClZAZKxa8IjwrzMN3b2BoCVxahS9VtcnpeFaZo0ucLepMOmaaKUckuQa30FEN57Ygy3wkDXdSswcxgcKSeevjzjg1PygTErmOhWsFlX1qbF+8zGtBXkJhfmnFOVgqaDZy14ZwFRxnZVAACr8oXRwoVzTv2p7GuxA2CeFTRvvlQ6B6/J5jgq4Nl8zpT9rsQrJScV1D9ps2vQIos1hmWaaTUz7AaG3Y5SKykraN/A6gYKZC1qtJWhL6t9iErBCbXkmxTUJmu2yc+lnBAafT+QS2IcLwrAfGBjd25ryVl3u9ctT1TpK9HzsOlYd7F/ndMgDP2Ow/54u2djIHYRZ/36bx7v9/R9fwOBxqinkbV+LToE+l47CuZ54nq9YK1lGHZY49YiyXBb25sfmL5XvcxqZe1iYD17lYAXAux23OauNS0kpLRoLtp0z4Gh1MQ4XpmmKy8vkRgjw9CjbFv9jK07xBhDaZWIgs9WXpm4t06PUlD+lVNgnwvOZWp93Wetbqxmv8YAYevgUBa9Xz+TNwDfY0xZCxavsleCFmIAWttkxlQazxhu9zVNE27tWvDeq/2KUSBT/sxbbWMaz4sWdEpR0tjQ92u+tcmgmZXkFVmWBWdRBR3nlHi3rqvQRbCGEIN6FFKZ04S3TmPZ7GjUtfBm2e17fh2+I+d3WnRc99UG4l6LHO5WYPS+IQ9HWm3ELrLzu9s4Are9VWplt9OflUE7JbTDQX8vl0JKiVLUQ84YgxEFz00MS1ZPx74LSjgMSkDbzrkYPF0fV8BbQAq1mrVIYNe/HTF2X3WnALfC1Xa/IkIrQkN9/qaUmKZEK5XDccCz+rmtf7gVeNb4VyvTMpOT5pshhrXY6tZzb9sjG3O8YdZC3DbWW8Fvi2E3QG4MxikU3tbO9ndDsFKpIjRe1wlA0/Txq8++rbnaaG9iiHFmjYuvRWj98+q3poRvg1nxo6yyjW8B+dddYv/tr3sMv8fwewy/x/B7DL/H8HsM/9uL4ff4fY/f9/h9j9/3+H2P3/f4/dcdv//iB+P68NZwGTOnk0paj/PIoeswptEVw/lsWKbE0PXkyso+2XxQtg0kuGYI3mG8Psh6/92RT2Ui5UIXAtclE6zKjc/XwpfliY+1IUawvaWWxJQFjKym84IPgUjE24pxjafLhf3hPcEFEoAR4hDAGlJS7/Eqytxz3tKkYk1dD+2GMRZjM93e4fuOUoVuv+d5vOIznKeJl8uVaZ7o+p5ulSk57gZKTRhjsd6SSuPd+3c4Y9h1PXPK+PXAfS4qz9z3PV3fr/LUDpFCIGJ9h5ig8rrS+On8hPtjoAA/XyeCrdRsSc8Tu+j48M0HfAfP58BjF+i8pdAhBg4PAw/dgS40TmnBtMb52ni/DwxDYZwbpu8o1xcewp5j6PmlNAaXGHNgqoLJM8VY0gLvTx2uZTpvmGVhngr90ONtJA4Oaxp9PBGGQhXtBg4EBiJOHLZ5QjDMVYjGM+wH/vjTz0gMfHfsOV9mdm5gXhpTmkE8eQHrK61oB/L5uvDu4UCwjeALXTiwLAvTnPhySXzTHVnGzPmp8O67nSYVAvNYaKYRh4HQRSQ0XIvUNPPrXz/igxqP5FKJ3mJtY0kXzMrqqbnggjJ2pJT1oaEGF0Qf1tZaVqlqSzNNO1dN5Hq+3B7GeudpVZlUIOz2O1ot9PsOaZW0zLSiktvv3+04Phyw+ULNji72qMTNGqTX+7DOqppB04NRENLm9922g0FllYx1+Bjpu8j8fEWk8XB4wDZRJlGILMvMJqMkTRM1ZRJpCHZulW5ynmAdRV0V1iTWKsMxJ2XYBU+pjTklpBTmVnk39NAgF3BR5XKmaSKVSvQ9X56+sH88IM2Q65oI+KDSJd5T5npjTbUq7HY9UCllodVGq2CsR4yhSsE5oV+ZcbvgwVj6fmAeJ2qdGXYDjUaIHtuaymAvwu9/+Jmh67Cr1M0yZ057R80zXfAgEKznel54yS+E6BBjsN2FX/1dx9OTzk2ujdSaWjpMC76LIOpvr3YhFqiE4KmlsFwn5mmhzgUxwrAfqDRwmkTlUujiQDSGnOY1ca8UqcSuo1I5PBwZxwkbI7TCdb6uQUelYqwxmCbs+v4WzMwQaBlsE0LoaCL0tqOzHlZfqb4byJK5jGrF4GMAaXhvcdbjY8c0KzPQdw4sGCPM00yMO5Y0g7GUMpPmSgsF5zThZMl0w0BpbZWN8RipYOGbx2+55JGdj8TYWOYX+r5nngvWeK7XK8Oux8bVe6g29Rt3nnFceP+t4+EEwVdMM1Ar3nnSCiy8j+z3kVoL0ho+BiRvTMhKY/U6akJNQhzWNVcrzgRqVi91aw2icgVYWZOFrHuwlkKrhqktiKwxSdax6QKgyXIp6lXknKOtHjr/ktctodmShPV8K1V9amJUhqxb9zVr4r8l70JDyitz+5VRWbEWajM3AKsfoMkQWAXpVZOVsiabYpRFHr2qI2yvjaFairKtL+W6/t4KZtd4GUJgnhdK1aS1VC0OGDZQoFJj3scbiUaTZndjPy/Lwsauvl6vtCYMQ0etlXlWP/d5XoghErvAJs2lQF+B0y1BW4fVh4D1bj13M/M0r0Dd3iTqNjmsWlWeP+esSjUrCN6Y1jlnnHPs9wdiiCxzYhwnZPVIG4bhVjTBcgPRWyLsVoZnlUapem6X2nA+EMLm7yW35BPQ9V0VgKjHW1DZMGs19tUteW9Y4/AuUHKh1EJrVYkcLTNN1xvzPee8krdWmbp0Xa9dbjGplErfa9cBcJubDcADX/uNrd97GAb2+/1Nsm1jX29zU1fws7H6W2MFAuqRtSXO8zzz88efuF6vhBA4HBLv33243Q/wCkDXjgbdN/06loFaC9bq99xkpcCQ8qhjXzLLMisgbJUuqpVKkMZu1zEvqiKzLJMCF/fI4XDUrpLGDfjVWtcihr3tl+3PWxkp9Xpq6/cbqTXTdRGRQCl1Baxa0AFhmWeWZQbMTZIx50LOr3JfMXakvLDMs+a4zq6FiUJe8x3vurVIofssBLVB0YJZva3vDRNsnQtvC2lboWear8zzfOtm6XvFEjmv8ntFuxu62N9k6ZxzlJqoTVVrlkU7ELaiijLtA8ui8n/i4+3ejVGAG6KntY6UEvM8r9+93boVXouV5fZHfRMH5lXuz1q7njn+9r117hvBq//aMAwrMMwsy1ZcUr8vLQIUpmlZCyWrbJ6gRLhUKMWQ5iv7/z97f/ZjO5pleWK/byR5Bhvu4ENERk6qKqC6W0BLQj/oVdBfLzUgQBK6VENXRmSEh7vfwczORPKb9bDJY+aZeojKKkER0CFwwz2u28BDfvzWXptrr7Xr2Ww6+sFhtKFb1gnyBMm1Kev6f73WYi8nDY6QhK+VBiI6FIGvNgYjJkDEkpnGifMlQJVnwDqJmCl1VZBXvHPXZts8R2JMy/SMwjYRxSllUFqamKs7kdILkW1L3mPJ5PxKtNdn6m2jRxpGIjz9pwR+JeR1ua5FKZp6zTxbv+7txI00H2RfakoaVRqxW1wbPABVLdEqSyPirWpdzqte7+c/Jej/kuOG4TcMv2H4DcNvGH7D8BuG/+Vh+A2/b/h9w+8bft/w+4bfN/z+88bvP/nFeMzycNVcqFEULCvQWN3R2cb9neH5lKFK9sKajWKdpjXZ0AZvqbHQWUNn4RAVP31+wvcDj3eeFDJ97yhR83yuOC3FQqqRmGdUirhW8akyzxObzmOtJpUAVdN1lr7AOczkVJZsZLGQQRlqWy0lmijFjCwco9U1B6EqzW53x3//P/73/P6HZ37/4xldFPvdR/pt43w+kWLBNI1u8LDboa2i0aFUoxt2GL3kSA97yaCuhSllfNdhjKUbNuyQ12C979CKRT3UuKRCMYNYKWtPMQ3vOny/4SVn4hT42/fv2e0sz4eM6zYo1dBV4ZLmrx49WjXS4GQK1lSMt6gUOE+By1RQWhFzYYoj3bYjzZp5qvSup6jKWGfuNo53feEQGtUaxinivOb7jwMVOD5H7u63hLERQiJtHBtv6DvL569P0DqGrSPmRL/b8mk6MkyVoVMMnaXpjNKOXKu8BNYCdjUWxmki6EBFrGnGONMXj7aaaTyTa6ZpzRxH9r1nv7U0Kqoz+N0Wv4Hj8wvkR3IuPH9pvH9wMmG66SkLiP6rb3eYNvE0z7x8DWzuFHYwRBRagaJScpKHronlt3YdpYlVRVHLFKyGDCgrhUBpBesld2O1UQnzKBPDzkLTgKEUhfMa51bFoUzUgigecy3kWvj4+F6yXarCdR05ZfRi0zGNs0ytG3mhLRY7ssE4q0VBtLx4VUrsOlLNKCpd38lL5t6SSsW5XrLItSgXp1kmxK+Fcq3y4tj568YZcsQaRQjLi0VjSSFfFWVoTS1yFjFBCJmhs+y7PdZpamrEJBtxaZoUJow2zHGm3w6QK7ZzjJcR65rYf8+Z1gypRHRV+H4pIkLEWXkRrp0HlaFpjLXEKZIp0DLaOFRrzCHxdPyMVhajxVJ9GDZMsVBrwRrHeXxmt79HWyNFfysYK5buSjUulxP7nVi2WOWoS6Hkuo5pPmBo3G13KOU5HSoP93fEOXB3/0DK4tQQpsBlGtnutvTOLQpIASJoaAO+7xblpqO2TNFiey6A0+Q+5YI1CuPkRXmtivPpAkvuVCkyBV5yo0gcvGQYGXEWmOeINlrIEmKZryt46xmnQMmJbplK72xHi4VcNVoZ4jQyzSP7/R2talLOVDQoiY4oRdP38tI8pVnUoMZQmxbLmzShjajPjDbUUrDeL6RNXBRarXgsD90WisRK4BRKN7wVFXDMYvcClZAitSr6XlR4H997jGuUOaG1J+VRipI0kfNrTleKURTeShFyoeUmkQfOMOcErVC1wbkO0xQoA1YUrLRGjBnrDVQhcbkI6RJ7HEhNLLxSSstzb5hCYOh7tJLCo1ZFzhXnO0pKyHz8v+xYi0mQYsFojdIKVdQviLC8yG80LTY11zJiKVhSEfcVY+T+0iRR5nQZlyJU9iTJpxEBU2ttKZ4BoxcXBrFfs8bQu1cVrvzR1JKIWQpv6yx2u6HruqtCe1VT57xccyW2bWJFpPDeXif3VzswyWlStKbfWFE5hmFgs9lIWVBhtVl6q5aOi0Xdmsu1kp+3zhpd13GZRtI5XVXxtRRKLnJuy/dM0wTI9/S+k+J+ISWrQrPz0kxY7dkalTlMpJRESLeQxdXuav2nUqJ8nqaL1F7Wy7WpS6NBgXNe7OViRJHpun65polSK1ppOt8RY2Ce52ujRSmpaawVZb338vlqqZLp1go5Gs7HE+M0st3tZC3B9XNJlldiDgHnhLCsjYr1mkmjR6YAvHfXNSsCMq5TAuua7vv++vUsv0s++6tKeLVkq/U1e0stjSGAzXbD9/Z7QgiLOMbR9z3DMFxJ5NvfURbxm6hrF3LQMuOYcC5LAb8cSmmck1pTK03XDVhjMaaThlYR27x5Fmu+3WbDZrtdMusQR4oqTZC1IZFzYhpHEVQuhG+dOHhLTMKCUUrJ+aEcxip5HpbzTqkua01Ictf56+9Ypx7WyY1pvnC5nLlcpOnS9/212SKX2pCbWH/FOOOMhSr1US2iok8pUJK5XiOx2OJKYOV6NlD1atG4Esz1+Z/nabFHXGy/qhCntRmzNgxbaxhrUFX9gvTLepCpAwUMtlvua1ky5PL1d7793es6Xc9pnmemabo2gtYpnnEcaY3r9VkWJq8WkO1K0FeynlKSa9Egl0IIkZQyc5AG5TD0tNqYwkyMIsSiQVQSVyWTEsIjWhXXk7as+VxkRimnxDxL02dtRmmtF3V8ujZIrtfOGIwSR6vOd+QlBqoWWT9TiHRNLCxTyqCEqOeF/6EUzhus3yxke2mYyo2XiYrrPV8z0xa9t5JcM1m/SoSpy/fIfv7aaH6rrl9xrjVpSCLfsjQVy3UvWpsrK/as/7421dajtYZRhibQ+AuC3Zo4Ja3NgjffdF2b68//r30xfsPwG4bfMPyG4TcMv2H4DcP/8jD8ht83/L7h9w2/b/h9w+8bfv954/ef/GJ8yoVCZu8NqjpKHAVgckPlyv07RauBMGt8V0gxyQsOo1jtSVprbLxFmx6nYWojxlmmSbHB8/Fx4OnziVQmqrG8jIHOKlTT3N3t2A73vBwOTPMZP83UlGjWkEoCFUlZUYxF18K4LGrTDGXx1SfJxqbs8nB7TVluci1lsZfRzCnTdzsu4cL55czxcGGaEh8ffs1EJNmO6hy4gfv3jyhn6TtLmCdCiNzd3eOcl8wL6wnTxPF8ZjMMC6hZWq5449Ba1CPb7YbzZWYOGWM6UJ7NnWe7u+d8uJBL5f3unqF3XBj59Bz4dGk0DDYFOlsZLBymkc1mQ0kzSkecH5hT4NOPF2rriWmksx1VN7JJGFOZLolSQakJo3tKysS5MYWRPFi2mw25nnmZFJsQsRvL0zSji8buIodjwuiA7w0bbYHM82Um58J93TDNETfD6RgpTXH/6wGrQfc9v/3hK83Ct87LtP0UyMPygrw1nBso9cAlddRPhXff7zCupzMybaubQmsvtuA1Y51CKY/v39F/iDwdJpIJfPlsUQa2gyW2ke3uEa0KaZrQzmF8wDiNaoVWPcVqLucjqkW8caDtkmvdpJhVRvJisIgABEKSjJNxvoj1C4XWIITIPF64u9ujWkGVtrxcVzjv2Ww6KoEUIg2ZJtWsCkhFKpHD1wONhu92ZKWpLTKHTN9tRJziNuQc0QaccWLP1KBleQ6G3R5ljUyz14bS4HpHawrfFDOZdIkY6xfr7Mp4meQFOIqYCp3vyTHLy0yWjJ7FFqU2eSHeKjL9vLyFbw1aVdiuZ5oynz4/s9n2uAaDtqQQaAVqM6KkSpWYMr2Foiu1QWcHpingjNiolyrX1HuPc5q2qFNdb5iy5KHHKaF0wdBwtidHeUFqrZe9vzYMhYf7jvuHTvaAbAhzIJPJNaIwGO14eHxkHCc6a8hZspX6zoIWW/pCIdVMiwWaQ+tCU01+htqgqsYZQ8mZbx7u6Y1mjomqDL2z5JzoesOwfyTMgdoyjgHdGbHgNwVUI6VMjEUAspdcGbGxj1DFbSOmjNYdLUk2iWS8QK0K7SwVy8Y7lIPz8UKYZrpBiEeKUoDpZmgL+ZpDZLPZchpHtLZ0m4EpTpRUcEqeGd3ERaHrOrRpYgPeGi1XVINCE6v8VqnJkGKQLPbqORyeuXvYQhNy1XUD1YCukErEK0du4j7SquSJ11L5+fMT3333AYPYpauiRSHnDHmT6U0HWqFpoC0xTHTeYI1hHDOmaWLMVAqVgG5tsZfRjONF1nQVNXUtjZeXI53VGKNQRqMQJZ0ISRasc4YSxV69tXwlF1prNvs90Eip0FRFGUtabIlinNFayKQQQSeOEWth2DTeD6R0/lPh+p8dtTV4o2ZVCLFm+efVsqsJAVoVrKWIYrk2yRFC1aWgWclzYW5wHiesdbggSmBnLaiGM1aspJrs56tYzjlH5z1uiZEQGyqx55dCVYqm/d1eimFn5WeCKEiD5AnV1jBG45zFO0+3FOVi/yafdVV+e++vRflqI7VmbG23W5wTklCqiGKAxY5fRD0rgZ/nmfP5LIW4c7TaJCttUcuutnKrEpUmikl7JVRCap1zi3K9YpYGQm0Nt6jplYKucygl9ldrwbkqZVeycFWBL9lpb4t7cqa2dlUb930P6tUeKYbM5TJKMehEYe1dtxCugXgKVwLmbEff9yglRM8YadzUVoUUaVHeXy4XyWA7jSKy6TvUYvUkhFes+V7VnJrNZrN8jozEc5irld5a2K62WatKeH2+1kL77d+9LczDNcdpLailqF/Vy+ta0UqyvFZhWWuNcRyvauXtdkvXdTQquUiNu2bHsdhEid1dvd4rYyymuF88x0rJPTPG05qstZILomgv1waTNJwiSqWlwdOW+JKy2KMJuX7bIPDeX9XTCrlPjSZTC0XWBowYIwpqIVfyrNeyRqeIaprle8VurVJb4XQ6EuaZ8TIyDD2d78BwvYbGaEpG8ttyZLMZ6EyHVQZUW+6xzMQYq6EprNFviNDSKMhCHuc5XO/l2rBZr+26PkAaRnpRPK8Nt5V8vaqa6/Xz1VpRyESLc0Y2vvV4o4Re96eVtK3P11u7w3XdnU4n2T+W57KWSgyJ1l6/1ntPba8ZY9JEK9Qi9nG5vFrYsTwzfS+NtX4h/doonJMIHa2t/KzWCCGL64yCSoImeWg0qK3inadRlwkDcz3XKyZcm7OrKn9phtVK5yttUWTvthsUhhQzSovQUvZccyXlzurrNZNpIcHMRpNGXeNKqtd7umIDyyporfyCcLMKO7WmaYW53rLXiY31vl33yNqW5+DNRBRglQalr5NS6+9Z1fvrtVgJ+GvDtC33TS8/c8leQ/0z4v2W2P+3OG4YfsPwG4bfMPyG4TcMv2H4Xx6G3/D7ht83/L7h9w2/b/h9w+8/b/z+k1+MO2vprSGWzB9ezmw7i3aa3lSiTuS8RZHR3UxSHZ2zNK1E0UZdFjQcxhFLR1cUw66ndpFpqpRYGU9HTF9xF8A3avPkOVFrQbeMUxatEq1CyIredaSs6PsO1QLNWnLUvHvf8enTmZex8tFbstK8HM44VXnY7zlNhefTmXd3A8PG4EwjVkVdsshNbaiaOR+euVyOfPftnvtNz7/+mzu0U5zmxtP5jlY9nS3kMWJsRVWFNYFSLFMKmE2gVIPrLXfsxRqjRiiVaRKgaAa0MdSmcLbDdwO+60kZctO0rMBusL3DGcO2M5Q9hAahZj7cbfn5+cQpz3xz15EadCsotB3n4xHtYLfr+eHTiFIa7RWdHUjpQtf1/PbnH3k5V2rSdH1kjgEMbAfPlAr5NDIMju/eN15eRkI1VAxD5/j0daJQyTi8sXT7LXO4sOu2jL7x45dnvvvNdxwPR3TJ1H7DNDX+MF7467+55zSfuNs/kFPH8fKVzvVkNXC3CZxPmW6reffgmeYZ1w1oq5cXSBtUKhyeJ/pve7R21BapuWGsFAlWG777cM/HZjk/Rp5fKk8pcDo3qjpSqyJ0jXf3e1KobDaOzaDJUyJnxfnc6F2h92LjU3GkkEk5kIvHuB5vK1MqNDTeeXKpxGrQITNfZoxROFXY391RS2S331JioCkwutE5wCje7X7DT1//wPl4Yet7Zhoqj7hukBfdOeH7DVM44YqoHGttzDkzzTNKe9KU2T4O5FxpSrbA2ipd79Ak5pixCszisBAamFmeaUrgXd9znC70zqCa4u5+Q41ScNSakAn3TM4ObxTLm3FqFmWS1g6jNYki2elKMkVCiMR5Zk6F9w8DY6p8OU38q/09STtaK5gquTxWWYLWNBwtBoy1KGUoZcY4i6GHXNj1dxwOT2w2Fms14+EFYw2pZHSz8jxh0aUypQk33NM7dVVKgsFYT0wZ7wxhTFij2faOTCU7RUsQ5jO2FT7e70k5EdNMN3Q435NbwhtH7xRaw/7+njwFphRBd+Q4SfZ0c+iuUVxj6LeUJDkxxliMln2ylIZtHkzDeEWqkZYaThuZnlYG6zsaI9aIAjSnJrntCoxzZNXQzgGWOUa6jWc+HPDWU43FIMKO42mkRiFPSmtKFVBKOWKcQ2kBUFUbxjliKqISo9JwuK6j64BcKTHhrCPmSgigTL+ItgpD35NypKWEWpRrqIZxGqxmvJx5eZ4JpfLx/UCM0OoZvx/AWmwxXMYZioESgUa8TAwbx33fUUKmKY01hjBnWlHoaqBJjlPB4LyClinVUFRFN4lw0NqhaRi3pZKpSaFqptTGsNvjrCFOEzGtmVYaZSwog6aC7+iW6W+8JZdGiaCaFNi6d5ArINcoBFFWppQZ+g0KIWIlJbSBWjNpjhhtOI1nvOuoVLSRvPbj04XwX/ViXERhq81RWwj3Wki3pq7FCKglM6kt2C3FSMpCxqUAUohKz14tpVKSbCRnDM4uZF8pCqC0WDnRKsMwYLW+umNInlUmxVereCnoFvLeOaw2C7kWkjlOE3MIeO/ZbAa5P/ALNepbhbFz7mrltRbUpZRrUQ1cSfQ4CkmVrwetFf3gWa2/uq67Emu7/NxaK/OiPl2V5Cs5qLXSGYvRenFOWBoduRBmUeO/VRvbThTsLefFqqmy5rGJqrhcFcRrQyOnQo6FEKcly0cv90w+29UWTTWM3VCK5nQ68fNPnyVmQSs+fvOex8eHRakujYx5DouCu6LVQuRaWRSpUZS1OS/kxl3XlzUWmsJZz2bYopREhoQQZfrASsGackArmQ5YGwulZKwzxKQgvmYlvSUOMv1QSVOkXbgSJni1W/PeX+9njBHnDNZ5Oi+5Ya9/hPAfDkdOpxN937Pd7q4F9v8nu7FVZZxSIpeIMRprvcQrlELXmeu5iM1buarBAcl/i0H2h1LIJdJ1Hucs/TC8sZ2ryFRGpHM9pa0kuxLT/Iv1IE20lSSKC5LSq5BPodDEkMlZ7LmEsCjKEpGiMEujQmzMVmVxa2LptZKW3nfstju5pzESU7zaywHkJOuw6zxdL9Z7KUtEhXV+Ua4vcRPKUFpZmgevOW2rfdo0zb8gS+vzGmO8Ei1ZG/K82SpZg3m5NyHE5fqkK0m8quuRaYha7dJklH1SGgSZWgWXFUKcS46EEAkxoJVYjq0TEVppzuNlIbiS2ec30oxaJ4GkgSQNkNdzNxg0pbQljkYszq5OVsYs++RC07UGumWSQVTmGk8uRVyEzDJBozVa6WszdMWAt02odQ9c1/TrOtJvsED24lJhXFT5Yi3ZU4fXplqrYpiSa76e53q9SxERpcRqAeo1+0tU3oiIVOnXpnBdr9Prc78+T/J8r2p1yWyjvqrIr9dWKYzSlFZWUHkFxLbaxb02YODVpWfdZ0ScKjlm69dL00ZEr6CXf67qdTnv1l7P+b/VccPwG4bfMPyG4TcMv2H4DcP5i8PwG37f8PuG3zf8vuH3Db9v+M2fNX7/6S/GtWG3gZQr8xjp+0Gyk7PFK8nSeLzfMDfHZUpgFblksTlPArrWOtCOUCJgGF8ytYkiLOnIdrPBWcXL6UyvLamJ7YioHxTUkaGHeW7EMJFi5f39A0YpDiFhmoGqaaWRS+FwOnG3uWcOgRgSD++2pJK4xMr5PONtRy1ge/DGUVKjGAHeOF9w3QP/0//4He/uH3GbHbYrlGyx0zMP9wMWR6Jweh65xInjMfLN4yPaOB6dx9pMDIqXl2ecKYzTkTA2nLaUXMhT4t3Dew7jmVAz221H53tCSGx6jxu2nGJhpvFhGPju/QODrzSjKTXwK+f48nIklJkpRNTXRrf1/PGPX6lz4243cR5nvO94/9BhaIxJQD6axFgj//F3T2zvHrnbReIU0caguw01V3mpVwt957DOcjlONGV5Oc/EEsQZoGQ6Y0lUjhcpMC5jpN9tqSHz/n3H3/761/z76cgBg6qV33994WGz4W/1N/htx5gyL19+Yv+ww3WaEGb8oqC0xfA8Vz5s9nzcD1hjqFU2drcVa+uU03VquLZIywqlBNS0aVi9591dI5y/gq08O8jZMKWRKTReRjC18ve/ecDRsINHm4xvHV5XWrW0aslpYhwnQs7MceTd/TugkOaEMpZcEnNqHM8Ts7NoDCpl/Kan1kzMjTBNaGdwk9itowaoM7480fs9ZWd53FtO5xNJe7Q1GAx+GEQ1WQ1aG1LKXC4FNWhKLpzOAZqiz5l5inTDhuPxxLb3ci9Kw9SM1U6yPqqmBlChYI0mVkhKcx5n5ta4GwZSiBglQgRtlVjveHlmYknsdhvmEAX0m0EZJVkspVJaQVtNaTBeZobths5pUVLNiRRgTAmrG6UJGGhrSTVjlKcum/t0CSgcOSdoitxmrNuidOQ0zXx5Dvz1b97RmqLkhtYerQx933F5HoFCsw5HxrnGNImTgXFiBTSFkVot4KgoztNMbpCLxpjGZbywcTviHCX3pHP4zmJUwegejSJlS2qF7V4xZ8TqvDZoiq4zHA8Txm9ERNAKRkPf+yshQWlySWhbUd6irCJNE3034IxhHifCHPG1CZnJFd0alIq3js5byX8xlizSLPzGE0vEdD1KG5kaz2KvU5YimgVgO+eYppFWC8ZaciooYxbrfcmid6YjxySxEC2jjaXrOw4xEsKFWhrhnKSg9B7jHKeTgPh+v+d0PnJ3d0dtilwzphg0irs7Q2qR8VzRzaOso8SJMEVSMPj+Hkchq4LRlqIDMcNljihnUDVRO4PqO1KBfWeIh4KigFVc5sW+nIqxjct0RmFBRYbOEy8JZw25VtSq0EwRVSUjpgFVZ5RR+L5bFHqOkhvWG3EYCYHed+QpUHVDo8QmzSjmnNBGUdJKxjwaAwpyDrSm0aqnUfFDY7/fMk0zoZ6wdiDlwuAblURV6V8E8iAFRWkVteyTrTZSkc/ulmehIc+uFE/6ShJjFPJVS8UasbaXvCB1feHvvSfFSG3gO4exVl72p3mxN1JS5NMwSuM7D02UhFIMSuG8EjBrHaVm5llUr96JMlUy2TL90LPdbjFGMwwDalEWH49H+q7HujWDrFs+f73af4maWEqtvu/QergWe6W8Km+dc2IjZw37/U7UmKgl+0sK8pVgz/N8Lb5BrOBSTCit2Gw2spZqu14rpRTjOHEZR1qTnK76Jm/LaEMMiZQzZlHmWusxxlKbkHnnHFkLSUkhCSGsWQhElQJyLYylQaFQmUW1PPL58xe+fv1KazAMcn2HYUAvUwwpJZz1Mm0Ai6I+Q2to5eTeo4ghLs0QzzxF5kl+l9aGbuilqH+jSI0hUIvDOo2zbiEIlZiS/LdWpU4MgWmc0Mqw3W2WZocU9GLjJVlcck177OLGs5IM4Jp7lpIoy3fOX+9jzuWaIZVi5Hw6EUOg73tpuFiH1oq7+zvCPC8Ft0bUqUsDyA2U4oBGqyzkXzHPM8ZoidxY1Mk5i6guxrBYZkkBn1KUOAVt8F1HzmIjh1JXpbyiEVQUFe+bKRK7OFrINIKQ8ZgCpWScsUs2lRDF1Tat1IJSmqGX/x+CiI7WZpbSsn5rFQX9WluJtd1AjhHrHAppRNSFyOecOBwPXC6XqzWid545zCLg0kt6opLPkHPGWCE4cSHQKS2fYWmcyTMmhNZoszy79dqAWQ9rLa4XW0FjDLWJqjwtUxqNV+uutaGWcyUEj/ca616tG8VWLRFDvK6vUl4z2dbsQ7Fz02gjTcd1r5E6tMIy9bASR62NNLeWZ0OuwvKMLnubVppWK3k5D1FAQ6viSpQXDPfOSa2uZPJIJ4XS4mhCtVfRotayzkWd3+TeI9Ey8iUSWyINmLx8Xl6JcJOzfFVqV1qpCwXV1zWstRJXtuW2tMrSbBEeAa/7u1qbBbUSF/vJtxMF5TrFojAGmfZZJqSkYaKWJrIQ/famGbcqxPUbQtyWDMe2it4Xsm6UxGe9nWxYurDXr7vi1tL8krir5efSULw2GOQQbFHoJRvtzRTEf+Vxw/Abht8w/IbhcMPwG4bfMPwvDcNv+H3D7xt+3/Abbvh9w+8bfv854/ef/GL8fucYek09azpvyGVCG88UCs5LfrLyYmmitSGmWdQ5KKyzdH6QxdESOUeUdiilyMuiTVlh3cDpPFHywMv5At5SUsBiCaFgVcYaxf1+x6kWNE0mFaeZuVQ2vSHXiLEDyiqmMjMXUbJp5WjVMMWZwxixfst5nnFmgFR5+TrTecvmQRQql0vm24d7TN9TZkOfIjllrHH85v5bfjz8yD/+4Y98t73nm48dJe8I94p332yJuREnz+ANz+3Ifv+OX3//DXM4cJpGxnAinI7cdwOdtjy0jlAb0xSItWJ7w/uHHZvNlu+UZsyJTeeZY+T505HDOPLD15GdG5jmE+egGDY7LvHCKQR+9f4Ot8/8/unEYYrcNcfXp0jMoGVXJyK249XA6XLCOcmvsM4T5oDSCsm2iGITH6QIM9Zzerlwt/X81Xfv+Yef/8jGdsytch4nmaxNha53hOlEK4o//P4f+etvPvD162+pMZFiYfvNHYrEx73nP/zuCKnxaDqUycQc2fUdUz7T58LdsCGHyMFUvtt5LpcJUGy2DrTYNls9iI1yEVuT3lt5iVcSMc50W80pn8nBkrLiNI8YpZnzTKxwN/SgxM47xYZ2hakUcA6vFHGaucRG328oaeJh02GUwjSN0R5nLdWAso2P3YbLOHM6zrSY2A0fCOGE2+xRDYwyFAXJRnoqJWWmVvl8ufC43fD0lOiGHZ1K5KrwvWe73fG73/6O/d0Dc2l8/vrMu/sdT8eJAYvWUnTnqIlxJi65P/vdXhRsFVLMFGvJJNAwdD1VBeIUGYaew8vIfruDEmhENJqcZNN93D9wPB5ElWR7XDcwzTNVgVH2KlCYo7ygRy8AozT3+3tiKeQ5M5WJMGWOp8Sn45lfv3tPKRe6bqDEwhQiIWs2faVzjh9+/Mru/h7THLppdPM8P19wg8Vve5qxoHtSjJJl3wvgTWNg2Cmez4mX58ivfY8tihq15LcYi7EK34RAzFPmMiqUbZRaCVOj7zUaTS0BbTSd8xhryKHgOyuKOaPQxoKqhBhJOVCSbNS9t4xTZZoTxje8V6RS8L0FZHMX+5ZCTEXUbdaQcsYaKeKrVmK7nUacsxi32ORbjakGXavk3Oy3pFxoKVEMUqRTRfSQZBI5xUhdijkt1RDA1TrcYEAriVooYoluXUdpjVoau/2OeZqouaC0FeUwlVQzVsNu24vydckjKSXhjIg8NtsNxnqeng44q6EmvLPsH3acx5He9cSQxZ4oNsxgcb6R44XN/SOnp5Hz5cCH9w8YrSh55vl4Yjfs2BlHTAmK51hHmtpyHr+y28l5OSNuJcYN3DnL+ZwYx0rOE0PnyclQNYCicwZrFK1UcsrMIdAoKKMJSchpi1VMaZxHG78od7NUJMYQ55mud3SdCARKzvSdZHg568mlcbmMsue2SlPi7KC0iAmMAuvdUkwVQpwZNjt83f4XA/x6rEU2ixqwIbc/JpmSr7VirEa1diWooibU1CIK2UYjl7woMKWgCYsdUe87nBVlpbV6sWGSrCiUYujEti2mxPPhxCZ1r5Y516JT47y7kmLSqqYMIhbbbEQVbSzDkjNUSqYksbnabrfSQFDteu7wqsoXNbUUWEqDUm2xJdOL+jgTYiDEie1WSHiIlXG6sAkDWg+UkjmdTlcCqxbilBZnARAiWLIUl8PQLyShXZWwSgnhbUoI0ThOlNJw3rIdBlFYFskKck6UtaVmHItiHckpAtmr5nkWpaoSG7ZS3xb08oz7zmHtqm4Xy66h3/C3f/u3S9MEUDBeRHC4qnpFBSwZW8aIsMdpK2LGnBeCGSWPTUUhLiVh0FhraYgF3aoYXu9Na4aSFRjoOk9tldPpwOfPn0EptpuB8/nEDz/8wHbY8ld/81d8+PAR1RQlV16OB0pJ7Pd3DMMgTYwYCSFcSVdKiTWDq19ywIw2V9KeUr4qY0/HFy6X06ISFsKcc8J3jhAmmfZAkUuCtqp5RQC7KteN0vRdD0rEfTlL5lsta+NJSLkQ8cQ0CXFPKZIWAmiMZdhupJHT90Iytbne71ZBW0OpWa7v8uyCkG1yo+RMLZm6SpxBpjk00AyK1SZP1q+1npzj8nWy3lY7xZXIilVcgaZQWggsWohLS2I515qQ4/1+T9/3OGPJKVFSZpwnplkwTGkFpdFMu5LzP/zhj/znf/gdT89HQpjRRvHu4ZG7uw3b7cC7d+/RWppCOeerCr01eYZzlvgZQAh+DJzPZ9YswrXJuDbNWhNClepEyq9K55wzWon4cM0cW7MD1+u8/v9pmq65h2ve1nVawzrERWfNVdPL9czUJY5H1kjB2GUqBkVOeVl/XO3W6vI5QdaasxIJYo3BdJ6uNpkaiGkhlfKMNLJMBCyWm60pYsy0lgnLnrlQbgwihLNG1raxlro0ZFJOi7Xl0mhY6gEoi/WjlgdBF1y3WlA2DBqxIpTjVXXeWK0O13vx9t+1EtKtlAjM1omJtTEg11HqW7ln5Rc/QylFW0h5Qeriq9Kc1QYOqgJQV3X9inm/INJKnJdWkl9bu5Jy+e+vXyvfJ+eklsbRkmj036S5fsPwG4bfMPyG4TcMv2H4DcP/8jD8ht83/L7h9w2/b/h9w+8bfv954/ef/GK8FMV4iUwBVGtko1ClECL4ztJ3mlPITFFsprfbQRQniFpqHM/UCvdbT+83nC8j1vfUJCob1xq/+/GZr4cj99tHZhVpc8UPBqpabobG9R2n8QTGEc4zqmWsd2zMhsNlxDrD6TRzCQnnO0Ix9N2AUYXzODPGAMpQSiK7xkzi8lJw3nOJM11y/PTzyOcjfPuoKeFMLfAyWpm2bWeOk6WReNzs2OwdG7ujphPff/jAlIKo2XJC9ZX7jeHx7pF5PkOD9/07vt9/i/pQOM8TRVXuO8t0uTBsEsbAx8c7vFJQFVo5bOcYpwt/OB6Y8yyqmlQ45UiIlkohtoBochK///EnHncbYiiUXKklMmy33D/05BppxfH1MlHyDFYxT4VgxXogzTO1VeI002/uqLkQc2OaRiqKS5hQptF5zTROfHh4pHOel/PM1BSxVA5T5F71jDnysL3jp+czG+doTVM7h22N0yXy+RJ4GO4w6oTbaryX7OVhcJxCYEyK8w+f+JvfvGe8TMxNMYdE5x2qiRrQGC9KrumCRWO0RalMTCNUJc+hasxT5pv7PT98OlFVwSixECFXfK+wTnOYIhVPnWd0gdPYeD4HNl3iw67He8kk0SHRtGKMM71XVO1AGVICpSyOgqqOYfDYbmaeJ3bb9xzGkf3WEXNmCpGh1+jc+OlwodtULuOELZHNfgCtmEJAZ0W/F8uUzXbD8/Mzftjj+g27Xc9UEx+GDac5YJRG6cx22/N8nPjm4zfUElEoLuOEIaMXZWqOiXQMhBbFKSHPWGXwFUzviXkmXxLGbUAJgDhnKUUBarEWcdCKgJgSqwvnemoFhUwm51IpqnCeIuFcmPOEtR5tYeM7Wo6iomqFoipPpxfQPVoZOt/z8O4dp1GmmUsLUlz2mhBGNJ40al6eE43C/q7HewWtcblcSFOl390Tv75wPM18mi9Yb3nvHNZCKxmDIk6BodtQWllsrB33jx7VAht7J/ZMpVFKo6a6qFiz5LPgCfGCM55wDqgGqRZymcgXhfGK+8cdUwiUornbdqSyZoiI8muRCZNTZjqPDP0gGfMomb4vhb73nE4v1LYTy5yUGC8jvXNY54jTDDQUhVYaXlucN6R8YXs3cDpMYjmzEJ5cpIhqNLTVjPOE7zwpiGip9wNayUv11hrWGA4vz5LNbg0ll6s1klEe3UA1jbeWzdATU2LTS4Z8yZWgYDwHaqq0ZjHWkRK0JOQrVkUpYIxiOpzQk8M8dOBnxvELxlTu7nq0KkxT4nKZ6HeGpibKXHB00Ayny4GqNSFOPPr36GYYjye00+hiOR0TYzxjnUO7QkgHvH6gtIz3DmMUKc5oNK1pnBX7LjpotTCNM5thoCmxTLqcT1grRYOxCqyh225JMeGVTKK32mhLET3PM0Y7aGLNZawlpnjNJReM14SQ8d1AbQlUYYon5An7lx1t+bmNSmmvpKuURinI2q6NZcek1UqMEWtX+zOFNoDK1MUyKGUp0kXdDMY4jNVXdbDWCu88Q+8Z+g6rLVOMhBiptSzqY1GvW2Nw1siaX0jOW2uzVQm+Eiyr1bUIgvYLAuE7B02K59cssQ5jylKgquVei3LSGCnAp2m6/ozWCikvauwYeXl5WSzG1nXvrl8Pv8yyWXPS1NIAWD/PajVWayUslm9av2Z7Ga3RVuybShU7uH9WJC4/X2tN5ZV8u8WhpMGS+WYWiyl5xq2VZkDOYvVvreXdu3dorXHOkXLk69cvvLy8kFOl73seHx9EzW/U60RDa2LJp0QQpHVh2AwM/UCYAyHOrLEavu9fv2dR3cq1EvW01q8ZVTlL3MDXr1+5XC5orTgeD3z6/BmU4w8/f+Gbjx/47tt3fHj/HudEuWyMuypj31q5rf/ul+aN1nrJ9uKqPu46L4rmBP3Qo400k5SGXBLWdoQQFuX5mosHirYo0ZfmCWKTF8O0TBOAKJXL8tz3zPO8EAhpTFir8d4DjaHfk/vM8XgixohxBmNEmOi9Ezs21ZbJEINVUOvS5ABSFtcWrc1CwjQpKFistIwxQvyTYHUuGW0kFsVaK7ihFDnnq83XSmLfktXrJMVKcpvsBaUmUkw477i/v8c5d208JSmK5HsrhCr2a95KVtl5vPC73//A/+X/+n/jP/3DD0xTXHBMsektf/93v+Lf/Ou/5/HxHdM0Xu3b3tq9rc+4XvaRBkzzdJ0gWc93/b7172RfW5paeW3QNGj5eg3kHnH9Paul3OshjRRRhefrvjoMw3Xdrz97HMfludFLs05IqzRFQWvJHiuq0EqV2CCj0M1I5EorV6X1mtHYmqyzeQpLVt0iSGyyhtdz0lpcSuQacFXmy/OJhCFZjbNy/sZaUGLnmYom57pMWLzmeK3Xdc1OXK/xem61CqdgIcYo0UwqFE1BRaY/VsLcmqjcBa8aqi0OREsETKkLn1kmFl5JMOSl4bzmdGpEvd9WC8M3DUrgF+f79u/XdbWu9VXF/lbR/vYavLVqW/99VcY3/c9/9n/NccPwG4bfMPyG4TcMv2H4DcP/8jD8ht83/L7h9w2/b/h9w+8bfv954/ef/GJ8HAuKwJwjTnWY1uh6mfjWgDPLWH0TUDifL6IDUKJ4MsZRSyamhrENFNRcaVVG5RWZmisfPtxzOU4MvSenjCoW6xvvP/SEy5HLKZEDhJCpVYLtVYEQEtopYpk5fTlg+w3OyPTsduh5fOg5TiOxAbkx9ApnLbk2MIo5JbHqqBHlHM3P/PCT4lffdhQqNRWKL8wRYp6wwN2wYxgstVncZkcig1EM3QbTQy0jvhWm0xdimii5kLRjNB3WaVJuOL8lXQqd7lB9B1lz+JwwRl7Eua4Sy5GX84HTKXDnDbFUPrzfYR388ecLJTbm8cTdfsfxMKGwHGNDG7jf7bi/25HDyMCGl/NETlGANWvUYNhsBi5BVFTOW0pp3A07jBHQVFpRlZacGiMKEhGuGFKcycVSSxEVFY1ffRw4PV/oTY9plt98u0fpma6zzDnhlcM0Q86NKcuiHbqOEE7Y3jKeJs5pIhfJ0S6t4oee49cT577jvpeXV8oqSjWimDGacUp4V+k6WWulNMnSyJl8yez2W769U9Q2M6UzYZRslVo1tVmO54kQZ6iJIXUcXiLnGNhuLdOYeNx67FDoVOXp8ELTHc4/MoYJVMfzcWTb3+G9Zx4Tz+cTf/XdA6oVjmPFWU/nNK1UNluxivl6Cfznn174n/63H4ih8eUyc29g3wy5GVqY+PzpM/1uJ9fJi433zsF0OdPpRkozoPHGofVMyYg1BzI5bKzhfLqgdOOdkWL069cD7zaAs3hjmKcjvtvh7UDKI6pqtBYl0ziOoAzeWmga3xmUajKhrKDkSGcNtCZFkhLLEIOm1UKqjbttT9DwrX/PP/7xZx7v9ry/29FqQi8v0qtu3N/vOY0BYze0ZugHz8v5Qu8HSggoqwhjQmlLLJmpHLjzHdMl4JOl6zfM44Wuc/z09UQ4PmN05eX4lYeHdxyfn9l3AsbOO7wbyHki5yTnkDQZRbJJVFNZE6Jit90yxUCcZh4f7/FWo3XFuIb1QMs473l+PtCaZdhqjMlMY6HbKkqJ9MOGcZzpnOMyBhqKrnMypWyr7JfVQLNUlQnTSMmN7XYghYnBex7u7gkxkmsmkHG+wztLnBNKCbIp3YhhpmRNroEUMylD33VsNxsuS3FQSsE6xzwHnFtAX8vL6UYhxYRWQixaLTgrqtu7+3vmaebO33GZTovC2XIZZynqnBPF5hyWjG7ZU6Z5RCmxTrdqAArTOJFj5O5xS86GVqHfD9SiqWNhs+0x25745YjvDON4wTvLw0NPaoFwmclAUYE5G0pufPio2X985G7/HgXEOLPbbDlfRlwHj5s9z08vOCUW8UolNIWUKopI7y1hyijVieqzFmqu1JYxTqEdxFSxSonrwkII5jlQS5RSwxiKMCRUU5jFJkjUv7O8RFfidkFVYh3VRmptGN3jdBLLeWuw2lFrQNvMv/RYs76UUnJOi8puzdGBtagQFXqplbqo0xtSNBkj1lssBVmta56YuRZJORVySdSFVHadx7tF3VylsO86fyWDWilazRijcZ1fiLK6kta+7wCpLfTiYnI8SrFtrcW9se6SgqmJPZgTsib2cIWURlJKdJ1Yc9VWGYaO1grPTy9SryjF/m7L/f0dfS+E+HKZ8SldyYB8JrFrulwuC8H3VxKTc75mqYEUf9M0XYv8laxIblvHZiMKVRRYa67Fv3OOFttV3W4X9SgKEdMgCuJWFVpZcR2oUjjXKhly3ntqk2iYNesrhrRck4x37vr3Cnh4eGCaJp6fDsQYuYwXQpR8qWEh2GYR1mglxBrEzspYQ8qRlOKV8LzNpNKL6lTxmlHknLuqo1NK7HY7/u2//bdcLhdeXl6w1jGOkf/02x/4v/8//zOP93v+z/+n/yPff/dr7vbbXxTPa4NjbYAA9H1/XfutiVXeW+K+nkNKSUR5YWae56WIB+fdm6+1dL6XeqQmUa3D9ffSGvM004Dtbi/3WylaNWhj2G63hBC4XM7UVq5Wfqsdm3EO5zu0ybTlMwzDBu89VuurYlms1QrGSKZWWlTsr3l3a+PkVX1ba71ODHg/oPVKzmTPizGK0r295lIJIZf19JoNZq4kX8hhh3JybYKZscahtcUaibFxTshLJLLf76mpEVIkpsAlXMil8POnn/mf/+f/B//Lv/tfCVmyvVqT9mEImeeXIy+HI6fzke1mdz2/dV2tTbJ1Ha72bStRXO/Rmlu17jvr2vynjRqtrJBhLRZo1hmGjeT9hTnKub1pdqxNvbX5BuICZqxBLc/o2qS8WtMZd/0MWtflORbS6axh0/XivGX0QrQrmoZ1XqZ4ls+UcyakcWmsLg2DpYkqe3nPqjCvVeKl1hy6laiuTbOUxf5Rvj6x2s11frECNAbnVtX1a3NxnZRRyuCcwli1fE4kQiuXa3NHrtMrkV0Je85ZHGrqL+35jDHXe8vSRLhOW7Vlfup6HfVCnvWVCCteGw/r8ZZMvyXU6898e6x7ein1SvavTYR/cvzTnwdglt+//v26Hv+lxw3Dbxh+w/Abht8w/IbhNwz/y8PwG37f8PuG3zf8vuH3Db9v+P3njd9/8otx5TMpGBoeTGW735DzBdUMzoDTGqUCRimU1aSoiUkA3TlPzpKvOoaACg6teqqKKN1wdgeq8rDrySnzNBe+e7/hzIUwF1psnF8iNRgwmsFbpjmCkVyCmgOnEHjc7Di9zHjtcW5Dzo0cG6pqrEl0G49JYEpjWF7gTZdKrJnHO4VVjlgUUxh5Pyj+OH3iMX0HOvA8FtQYGbqOpy8juSi2Q+JubAxOc4marnNY61DKYawhzhcRE6QzKItqFt0KtUTAUlNmLpFKwmqYz5lSFFVVfGcJoaIvlt1+wFD58fOZdLfjXBOD1vz68YFuu+XHPz5TSkfImf1m4F2nOE8jx1rRFHL0ZJFgcRwD3358z/F0ZI6FpDXz8QjAZtsxbDqevl4Yuj3bfstlPIFqxJxIpYDWDF2PMoZTaFymxCVO9Aa06/j0dOI3HzrqnaHNGmsH3t2958vh92x2A+08stltGFwHpfGHp6+M00RvHe8fBmpTGBopapSqnOfI6VJQNjNOJ1K4o3UGo2WDP42Z+/s7Orfh68sXop0x5g7VPCUnUh7p+x7/oEhlJtbI0yGTYqGIRGjJIp7QpWDZ4ExPTIpzDKjBUoDxkjmnQjvM/Ntff2DXa6pXkCZezhfu7+7QneUwnXjfd8wtEJXmH3880puG3Rj++uOeMCVCzDRnuRsGTvFCMwO//cMLd5uOl2ni83nm33zziHOJ1in+3X/6Pbv7B4be8euPj6QQsFoUhLZqnDGklqmxYDYdTWW0NqSQyNNE1/W0Bj98mdn6HTmOfDm90A8OExS9c8zTkZfpQu875nnCO1HIicWzbPp+MxBiJeeAQoqOimYaj5hNT+cHTlPieL7gbWU7eAGOXPFO0Q8GXTI1SS69yYYvL0/sthu0NjwfniXfWhfSlMkq04iEccYiOffn44VhMORomeOF/W4LKqFto2Q4nQI5RIbOkHXlcDzz93/9HaYqno5H9rue8zzTFc/WOKZ5xBhDby0xzXRWY3tNyoXaDKfjZx62O14OB7a7HQbNy/HC/X6H8ZZ5HjHG02iEVInFMWw2nKcnKI5WNfvtPVqJXX1LkqWz297zcjoRkmS8Wyv5Un23QWlDbgnbd6gkYNA5x8N+T1iAPcXE3bAhXWbaxmBRjHOm1kTXyRTyYHr6fosxFmvk5e0UwtVanQZWWbyraA2NwuA7clOL+qtAbVgrGe9Wa6ac0M6SL41WE+fzmf2up1AwzqGM4TIHSpLsIKUsxnZMcyTnwnYQ66HzcSbEmf19zzCIjVDXDxjviJMnjRd8v2O6VJ5fTngPTSmcHUgxYt3AdG4MQ2W/VczZUeLMRvfkGR4+3JNDpYQLTluM3bC726JKYug6HvYequbwfAIC3jpyq/S9xynIWnG6TECE2nBGcsVd3xFSQinHNAdSLBitGLYbvBc7IaMVlXYtEow2vFxO7DYbnLdAharIJeB7BzUzzyes6YixLuSxoxCxrlFThmbhn9cCf/LxVnUnGU0gKtXCqlaVryuUwqJ6tZQidmRKKVQr5Cy+NKKEXnNgYFXnroWHsa9KRlG9m/VM8E7yd7SG3jtqfS2CWxMFNk1UoX3f45zBO7GWD0HEFq0BDfw1H0uKvrKQFiF8izcZkoMjRaHkueWUOeeMNprz+cLxeGS73ZBSIoQZ7x0pZfl9MWCtxXvHMAgxe6tcba1dleyrCtosCv612Fv/+0oK4DWPR6nXAlCaFt31fq1fY4wRW65lXeWcKXmNLCisilTnhISuJMw6IRBXJb7ROCzzNHM5nbm7u5MMLpo4EjTYbAZqLdcGCSCWZ0Wcdbq+oyrJ8dFKX4nR6Xym5Mww9PjOy2dYsr0aTfLxrBEl7mIXteaOSWOoXZXla9bW//qf/4EwjzincU6Lpd884p2H5bPL/X9VixqzFNM1E2NjmidqqeSyX/LUpOwNYSLltNjoCXFayZb3/lp8uyVXri0TEKLIb1cisKqaN5stSmuc72hVcqPG6UJTabFtmwghLk2s16ZYjInj8UhrTXKrlKLzHfv9HZvNQJhnWTfeA2rJI5NpD20saQxLU8deSRtGHEdyqrTr9eXa4FmtC2utV2JvjL0qq1cbwRDCdR27JXOttSrqeGWFrFTQaEquzHliDtNixVVZs7HCvDiHxEBMgVoKIUROpxOqweP9HVXJc6qUwmrou579rpdm3JIpuOZ7rftMzpLXVRfV+Uq2N5vN9fquivG1gbPer1W9vjZvVmW6NFkUjfrmegnpqqUxz+FKsN+S/HX9iY1lpJRKirKua2v0Q4dep2PifJ2m8d4vpFSsEtd11VqjmrqQdbfYUEo9EGKk0Za1apeJF9lD18+87js5F1Ga50pb9kO5z22515Wy7Gk5Cwldm569d8ukC1e1e8l1yWJTrOptrWV6pbW6WFhKE2Bdd+se9lYhvv5TPm9GaYVaiHpDbAm1WqcB9C8w7Koc55V8vyXLTU6Wtzx5vT9aLUr29ktF+vqz1z/y36QZ1drrs/52auMtvq6/X66JnMV1Pf03OG4YfsPwG4bfMPyG4TcMl+t2w/C/JAy/4fcNv2/4fcPvG37f8Fuu2w2//1zx+09+Mf5Xv+r58vNEUZ4UR55fjuKxr+WhH2tmmhXv7+54njJpipJJG2dqzeRl0yul0PcyeSig2jHHxIfHPaU4LjnhvCKrivWW8zhSCjxfLjwMHa1B04kpTIQ54rtHnNF8uN8QLiMmOTbvPBsPX6rmabyw85679xv0YSYeG8oqLmGmZjhfIrlp7vsdrWW0yrje8L6/x8QXnk4XNs4RauDz08TezWgrarf/+IcnfvX+gd98NJQ4c2mZXlVU1yBHvLbE2ChJ8mxdt6XktkwkRoxvQKVkGfuPtRCbZT4Xtkpxnhu2Hul0YJ4mrC5YndkZx7vdjpwq+lz4uPccLpkYK9YWPn78wLd6w/Pzge3unvMY+O2nkWmyfPzwyOlyJuWK6ztePj0Tcuabdx/Y+cLgDXn3QCiR4/mMRdGaZugHeh3EziFknPXEkhjuO9ol83fvf8V9Z/hPLz/z48vMv/nV93w5/pbxOdBi5NwaJVactux6Ry6RU5Ap1ncf7nG5Ei6N0zzy3V6sQP746SutWOakeOg82J6aw5Kx7BnPE945Qqz87vNPXELlr75/4Pmc2HaLqslazpcoGcc+0tce9M/YYaCNM2GeRfFoDNZ7Pp9P9J3l1998yyaOPB1m7LABVykhU5zmP/7jJ/7V999BzVzKhPcOjcIpRzaFH3+a+PFwhpy573s679hu73A4jmkkVc3eWD5/OXPf9/z9x8zXufB0jvRGc78f+P2nC/sN3O22fP/hnn/4/ZF5hoe7LRttyGi8H4hRskBUiYjVeaakSCqFVgyHpJhezvz6Xc8xZo4p83Bn+Tv/kdQaLcMpXLh/3NPGzM+HAx8eNsQ8obSBkhi8wm8ccw1Y57FKCtZWK8Y0jBUXhZfnQHKVu2FDzZEfPp/JqbLbD4AmjPLcFhP4+nSgqML7bU8lkWPmcbvhZZwx3UD6PHKIF7TP7IcHYgmopjjPhf2mJ5nAh4c9WmvGMHF/t4XWaCnSeweq8uuHBwYf+fLpzND13PVbQg50TnOMkaYapmX8/SPUQqcNP0+VnoneGp5OJ5xSOKP5x59P7Evm3d0DnVLQAtparB5QMdIw0DQPDwOHS+A0NrzXDNYyHi5MKTOFkbvthnE60bkN3nou0wGjt+x2G2hS2CgSBgVZY3WhlYixW06zTC2rWtAZmqrEkojHA7kEWuu4e9gz14kxZTCRndoR5wJ2USKXglIa33nJaaoClK0WcqkoVdF9J6owBXGO1FxgcYzQFJ5++kJthW7oqUihRbMo09FKI8VCzCJqcK5D+8r5mNh0AzXO0FsGC9pvqG2iJkff72hoypTQJbO7vyfGAiawv9egIAVFyWdxL3Gw7QtfnmaG7lcMOnOMJ0KFv/n+kTRHzsezXE9bmZ6+UGPBojkaw+bOo9A8fnzHD3/8meMx8OHBM0fAZsolUPWeGkesUoRQcMbw/PXE3eaeVCvVRpRteNeLtf2ccYOj2sR4iXR2h2qV2BJ3w5YQMlMOdL1Ga9h3D0zzxKbfcjw8gTJYp/C9Zg4TISbu+gFVLblGzsf0XwTu//S4qvhWAl6FignhEgIo8QAsakV9LdysddQGOSUpLJWQyVVBW1tDK/OLArbkQs6ielwVwKJ6tJS6qAibnEfMiVwlQ6qWpRhWZlFMumtBZ42l891VoQj8wnbKNoNdLMekkH0t5tbPvipd5zlcCeCHDx/oerHNv1wmchIbostlRBsYhp6u84uyOjOOo7ipKHXN1ZJz0QvB41rU0ViiC16VmCupf6tkXEm+XtTJanH9WJW2IG4OMSbCHJdrq69kciUXV6JKpVaxfRNFaJUcusHjnOV8OiFqe1H5juMFlKLrPUqBXRoe1lqMFjLtvMM4SymJWpFcM605nU5M07Scv6KWzHmal8gBIVBaiy2VqjJ1kIysrxjDtWgvpTCeL8SceHh44P/wv//f8b/5+79njjObzcC3Hz7SamMcz1jnr5MCTQmpiFHEltYZWZe1cD6fCCHQKGw2W4kyoJFL4nQ6cTy+EEMUR5e+ZxiGq/pb7tGrBVhY8ty01szzTAhBrpGxpLRaugkRSjEvEwaVWioxhNcGijJ0vb82YEIIhBAYhoGh7+k3G1pTpFioDaz3OLVmDa5q+k6IsS+UtjjS+E7IYJKMNrmultU6zxiHVvLcKa2u92V9LtaGT0wzwJWc1VqZ5umaDTcMA6AoWfLA1r2ktEINQrDK8r3WWMHmIgR1vb7Oef7K/oa7/Tv+u/G83K+KQtZC5wdcp2XixS+TDyVRY6UWIUWtIp9LaUrNV+L09rla94m3UwpvJx2k4dLwXi1Eq6G1uV6PtfG1/oy1kVFrJeVAbYWUE3aZnGlNcHqdHOn7Druw2lorJUs2F3Bdv85pwiw2aSHEaxMRlIht9asFXS7y+0pD9oi27tOy/mpb1pl6bciFECnt9VmUz9SWrxPbwNLU1WloJZwyrfCqbkfJfS05Y6zDO49mzaFMKMSmMVeJaln36beEdb2mb0n6ug5XnFr383VKgvbLiZR/qhivrWGqTPOUVc2uuD63b7/eKMlpfG1Ev+JiWyJOZG1wbfa9XVfrunlrMfpWZS/3YiXkr3j73+K4YfgNw28YfsPwG4bfMPyG4X95GH7D7xt+3/D7ht83/L7h9w2//3zx+09+Ma5zpenK0Hlq6XmJE1Y17jcWNGIxHg0xBsa50JaToylSylhjURaUkpfb1jpazbK5WEWi0feygOygeTqdyFXG9I0xhAy//ekrzjm8A288w35gHgNRFayV0PrtfU9TmoKitkhaJlZLUzireNhr5gYlVZzS+B4+9FtCTvStZ3jo+PTyQowJZ3peDhf6D1us8+g2cxkrD/cDXy5HtINUZwqWrreEXMk1oZPF95InWwto5RkGg1JusehoaGNRZDSSO5CrTGReLjPvHjo+fvMtL9NIDZ6tbxynid3jnnePWz49zfx8KBzHL/Rmi1aV/eCZw8w0VtJsCenMKXSEkLC7Hq1HOteRY+Fyjux29+glxwPtKDXx0+eJx31hc9fT545zqORWSPnEdhhEBWgcichlnvjrjx9496stz09fefl84AcFg7Kcz4GXc8aaDZpZpucvF4bNlsPLE7kUrDVUIOSMbpX9/R0xFs5T4od8RHmDHxxeK2iVHBJeyyTv6ZSxvmPKBq00OQcO8wTVcTlnjpcT0/jMv/77b3BGUU2VcwiZL6cR4y1mnMFaVNfRecv9/T3H4wkaGAzn05lpkpfeVTXGnOiGHUbJi8WnKdHNmbEGtn3PGC/UZrjf7vj58x/JsWCaZ3+/5/t3O57PgZdz5HBO7DZ7lHa85Bd67bnbOY5TwPWQi+PrccSoSlAb/vD8zDfbgW5/h7/TvH/3jsvpCKFRaeKY0JrYVzdQTdNaoN/1WFNRBIpqzAHurOZwSXitGKxGWcvT8cBm6LHasjGKp/FC1g5KxOkOZXuqAkWh5iwFl1XkWonzRNc5nJFs5h9OL2A1P51e+PDwgNOaohRphkOe6DvZxLfdhhS15PG4SojyUnHoPYfDM53f4xzYzvNyqAy+8DxOfP/hPZMVVV9Jjc+XMx8etnTDwDxlWhNV227bczrOHMfAeWyc55GHbSNGQ60z737zLd/3A9MsMQQGTcgJSibVxN46HvY7TrHiW8VbsRafp5m2n0kpkqvmdJzZbu9xnUMpGKeZ0hpGNTZdT4iZUA2oxiXM7DaeOF/YDh0hjFRgt90Qc2aOGaMsKQWsHTBaMn+mMdK7DtNLcRemDEhOU5wz2/0DSilSmujsIJYvWfI9mirkOlFoOLqrgweKxf7bSFGnFaiGQhNioKWEwkCTvHKsFiETUgiGKaG0WIFZaxabFyFjMWVyUzjvSamAMhREneq3FaLm6Tlw3xsmMsPgOR9HMIaWG1rJO3ydLbHBJStMzlhV+XK68O5hz/j1GRsD+48Dwz24oXJ5aYQomUPG7MTC3hQu8Yy3PSU3rLXEmLFdI81i9zWnhjON+7st4yHQf6sJpZCqoRsidrhDtcw8ZUpM5JqY0oWuG6hZgzFEFPthQzh8oimxsr8cI22Y6Ae/FDrL9XKaVoUIjtOF2CppiqDNVUFovFsAvVArxHmmlImY/iusWJsU8isu1yrRJWKPAyz2beaaV/aqam9NFKI0UQGW1igxomhoLUrFvu+wxpLzq5K0NX0l4loptFF03uO9XQj+QjaVJpVCiRGtwSpZP7VWainicFAMMWZYCj3v/aJOz78kfVrymlqTQq21fC3yRZkpyur139fp/N1+R9cJsZrnmRgTpTQ2mw3bnWSqhTBfLYqAqzp9VWRaa1lzwJRSS9aSWDG1JrlgtYpt1mazuRamq2XdSp5ba4vaN2OsvZ7z+rmlYG1XyzFtNM6KKGolE/M8M+ie7XZLrQUFeOcwVgiItYbdfk+tjXmeFhVyY7vdUGthmkZCqFfVr5y/ptRCTY2UliaE0UzzxOFwIOfMbrfFLUr1aR7RbyyutBbCLkpVKCUvdltLQ8gsFmtKMfQDw2bgu2+/x6CJNTBNI6oZ+n5AGUVrQrpzzvTdQC2ZnCMph+t6EDWvuxK71trVZlCK63ptPFhr2G62uGVtrd/fljwolMTIrM2DeZ55eXlZrtuWznfklIlJcgGt1RSafG6v6YdBniO15KMZQ9d1WGs4HA5CEK1Facm9yunMcamVzDLtUXKlUXHWSs6elXyqVkW3u5KFtTGzKvNzzkvuVQUk76yUpWHVGlabq2q9NckXyznTqMxzRgHzPDPPE0pJvprYDiZKKgsBNygtNUguso5911HN675lzYoX8hkBut7zrXq4NgZE4a2gKepyj6V5k+R+l0zJhXmeSGnNUtQYq5Z7pq/PwboOVnXxSrCnaUQvz6M42FWM1svzLY1EY+yVYMkzLg4gzlu2DGijr/aO1+bAYj2WSyTGgFKanI00QFoDNDFFSq5LRqQ0EpSWeKLV9k3u36sVn+TcSTMl5kJMiRCTcKy6qs/ztYFCa6+xJk2aDK97pPwua1ky76Bzhk3XUYGUZZ9tjev0T6ss1+G1MZDLOukgR9957DopkvP12WqIQvxtc3E9D8UryZXJgNV68FUN3lpd8EfWai1Lg1XrpbXR0EBTkpv29qilXj8DLLlnRpzHrl/zhrSv62ZVm69NqvX8QJ612l6bvP+0QbASefn7BXfbfzk5/2fHDcNvGH7D8BuG3zD8huE3DP/Lw/Abft/w+4bfN/y+4fcNv2/4/WeN33/yi/E/fDFME+xLI44Z7xWtRGg9McHXw4mi7rCDwdVKboqYIjSN0fLiSCHWGcY4amuSS0whphF3VqQwszEDXW/4fDnjlSEaUUCE1Ki+JwF1TrQUoIndRc6ZUguq79AtMZ0q/bue3cby9eUz80ZeMKAb948aNUKg4YzlMl34+P2Oy+WAronjOTBOmq1VTLFwmRNTTvzhy4E4G/Zbx2U6k5qiZFHrlFZxxtJpg2qZ2uQlWskV3XoqEFNgv+tQxiybaEWrSgiJMCuxH8Yw9B2D6Xj5OtO6SJ87MmD1xNYlvh6OfLkEUlDEAJObyfOFbz7coywkGj9djmLJ0DR3dx3P48Rf/+obXAu8TAmtLDEk+o3F+Y7aguS97Dv+/q8e+cPXA9NceBpfsMWx3e+x3sEMx8NMSJFucHzzcE8+BA5P8HUqxFDIW8Upz/y7H35guxlIJVOrJs9wSRNaWz5/eWK729F1HV+/nsipUILGeIN2inM8Y4rlYfOANhM//vgjnXOYrbxEM5dASZHdMJBeRu729wxuw2k+EdOGnz4fiFVxfwicvn5hs9lyPpyJaiZimC4TjUrLkpmjFBwOB1LKbIatbCxVNqzNfisqqNII0wWjQA8Dv//0I3/14SNKeXrfoSg8HS44o8govNZstxbrK5TC+XQi9QPaeMLc5CWg3ZCpvBvu+PWHkaHb8PufvvL3331PSJ94PgSeXhL/w1994Di98P7DR8IYKcZgB41SAnA5BUKc6X0vRabfcTrP0Fm2Q888TlxKYa6WpApGFX48zOTa8Zv7O6op8kIzjux2d/z0deLDrufHL0/cDfdshw7jNVVrsgXdFhunTpRKooQz6K6RiiHQ+HwO5DQTasFh+NWveg7Pgao2PD8Xck58ZzSP+3dYXeh9RzgF9t2Wf//TZ759fGCogWPThPORWC0/fPrKw33HyxQ4zwFTLT9/eeHuYcfpGNjvduy3PSWOfHy4o9Svi7Cjp9s4Sjphu4EUAs9poreeuTQOP3zicb8jN4f3GqM6UojoFnDGEWOg6w339xuMymhrUNYzDJ44njgcEo8PO75+OpEVfHy/J6XA6TzL/tQU3nlSqFjnhfx4x+VyZrfd0nWK4/FC5zqMgTAFttuemCecswuJCPKSOYHrxMI9hAJabNy9M8zzxOUSiTkRYqPvtjSjASlsjLEYLVlIWoM2mZgSyolVjW6NVhvWdtRameeINQa0JqeEUoaaRGQiZCgzbHqJ0/BbptNIqVBoeKMJ0fBymniwA2GOXGgY26Bqvh5mHr/bkmpiChDHA7udZdNtmXNAGU3Rmo/v9sznM1NOfNjvGFTPuO95uNsxjRN985RL5MuXE2Y/MKXIITwzuA3VWDqzxVbouoFPT0ecLgzs+fnnI+/fa2zQ7O/2aCpte8fL5cxgHJ03aFcxytHUjHceo/ds3t1xPI9Yrfj89MS337/Db3qmeaZQF8t6i6LRbxyVJRvIeiyZVi0xymR+qaCtwduOxIQ1hpgyFUUlL/d5xvoOqqe3//IX41JUaFqp5PI2z2whHFrsrxrtqk5cVYVSpIg1j0LREFKvlJLYEiv2Ryln0pKdxdU2TeG8RAVorYXYNbE3ulzGK4GVYq/htKJajcG9FuhKMtBqa7Qqiu2GFHYhJinClcJoRc7lTYH1qmZfLZpWMr4WYq9FahaHAhY1eyt479hs+msG2JqVBlyJ3FrsrZZzQoRE/amaFMu5iFWeFLpyH+A1+2y1nVutvqQ4lXO26jU/bS303mY3AWJNpqXpkfOqZF/sk5SlkYlhpusH0AqaJufINAVOp/OiHLZsdwNd9guxE+J+VWIqhPi3Sl2cf6y1hBCY5oBSis12w9B31+supF8sjVaiU0rGeY9qjZKEZNEaRom6vLVGP/TLZ4UYItAYxwtfn7+gtebh4R1DP2C1JauCNoZSFuWxNdQmjRlZ3wZrFNZJFl5p7bUZJHcbEMLcdwPe91jnZH9cVbZKSFspBVS7Tkdst9sroVjz9Iy1mCpEoLW2fJ+sx67vaMvzVlu5qutzflXr1goxJcyqEm8iLvLeQ2uEMpOpsDTJahGLLpRMjYQoNlyiLK4oXWmt0Foh10pKszwvRqGU/AxKJefFxk9MsdDSvRPnijngfccai7SucVCi0g8RlFhjsTTDVJMlH0LgkrPkda2khkZZ9o/W5Lnv/DL5kYRA6YUAl9oWy62MtYoYllwuo9BNYZuh1kajLBM2krcmBFwvdpTSAHg72dFaI6XIqhqnLertLM+5KN+L1H0hk1LAOUM/SM7fawNOLA6nICLYt02R1Qov54w2ZrlfdfmaSkqZvCrokT1tzQ+UPbvi3CtFk32yMI0zx8uFGNOiIpemp3UKbQ1OSVxJ01AWAVxrLOR8VYfX6/VSSqI/OuvItZCBlCutVtDyPbJuG1DBGLTmKpYD8M5IjqVRKA0VQ0qvNml6+UxvFeLXXLNWrqR33bvXf4q1pRDhq0q8VtnHckG15Q5qDUYay+vvqFWek7d7vbV2EQ2+qthfG3TSNFHql5ZsKw6qZbdoy/+8JepvFfnGrOt6mQpR0ry+rrV/4XHD8BuG3zD8huE3DL9h+A3D//Iw/IbfN/y+4fcNv2/4fcPvG37/eeP3n/xifA4jSllOdaKZhE2L9UCaqM1TtQdlZRpOQTUKqw2tSlZxXsBawEcupvYe6+ySlQCpKl7OI27uUEbstq0M21FKpahKLBN711FwYlFeG33fM12OJAJd79l0G3KVDIDddk9Tmo31JGf546efIG/RVYMpbDdb5tORamB/Z/n9754Y40BnImOY2e32JGVIEbBLURHBmsJmP/Ddt3tSHvn6Enj/+CD5snWmUcgJzqcXHt719P2AMZYQJkAvE6GNec4cLpnzHAgV7lPHH19OzBf4H/71t/x0+ULNno22bLqO3x6/Mp4z3ij+9lc7jnFm9lt+/PLC/XbLh53hYef4cpz5u/eP5HSh1IRqYJrhcDpT6sR+43g5XCilcrcb6HrP8+HIp08z41Q5X2YwA854SswcX4o8dL7incG5nmOc+O1//gNfLoW/+80Dd7sN8TTz7qHn6RzJseK7gX//n/6RprXk6dIwxnM4XFBqRgFucOwfdhhlGL8+sbF7Uktc5iOn45nt/g40PD2/4N3Au/2Gd9/sUTS+hpE/fPoRpWQT1rqRaybkwu9+/zO9blzCiUMXwIlCMoTEt7/6lhIy54vkq4cQUFozTRPJioJwv72j5chu0zMHjTWe55czar6w3Q/8w/GZIVuasny773g+X5jmCi3y8f0HOl/Y91u224EP7y+U1nj6eqFahcPwYWforafVSqua//z7JzY7i61nnNqhtzPv3w38v/54Ys6afYpyPe4GrBfb7dM00nViXVSa5NXH4tlaTYwT59mhrGO30aR5Ik7gHvcMuhAbNK1JZSZEjVYdQ2d4GSd+/2PgfKmkOhFqwEXH3d0dJE1MMxpQRolqqVaULtx3mv/4uzNmMDhvOJwSD+82bAdQdIQS+Hr4QsiF2hSRDSUrsoLpkpjmQCyWh+2DKLBiRw6J+3vP4SnyNCaUtlxK4r73hBrYbjpKyigNx8vIea6oVnm+HMnVobWh85FvPtzh9IaXr0fiFOm3jpYLLcBUG+F0ohbDZmOpNfN8TAzOo1tjnCr7/cA0nenNlsHtmaYMplKUwvQiXqlaUY1GOUOuGd/11AbeDIRpolUYz4nN4GkpYLznPI7s7vYM/QZqxfcelaSQNVYT58Y8ZR7eDZQSQSteXiaG3gONl8MJ6xzd3YbcEt47Ph1PtOrYx4JTDoOo92qu5Cbr3BiDQiNWT5VWFTWDqoZ5SihrMM6C0kzzDErRdYYwzfTeM2x3xNTw1jFdIrXMNJXwztEZg7aOcDiA98RUsdqhXIfOEWVnLlPCHgO9NiJmCJUxJe52lZoLTYEzlhwzRVlKiLiuEsOJvmuoFik5c//ugdPLkS+nQLpkrDW8f+ewuqK9orcOaiWFQEszpTP8/OUTuXqO54mSE9/9+j0haHZbx/Ec+JrOeDLf6Z6nz5ntg6fVxBwS+4c7vO0oOfH4zXcM+82SQW7Z7Lb0ncbaDnAYq7F+ICUpirW2NKXwnSeVgt8M6LaoKGsD07Ba03VbQp7lGdAJDLTk6Ps/Ga7/2bEWHm/tw17/sKjW3xQ+pbJmdK1fl3NeiIcUu8YY9KIwnuaw5KCJWnQl874TN4lVAThNE61JJk4pr9Y8QnI1LAVaKZlSDUYteTILyapU5hDIJS+kMALgnWW72WLMWtAJuRB1ckZlIRC/LJ5ebYRSypQiiswQghA8I6rbfMlX+ypYlL+6XIs1UX/LvXm1SdLUXAgpL4VlhYXUKCXK3zXf6K2t1Eqm3xaFr42DSpjjIpR5LYhLTdSmSFPibe5Zzpnz+YzvtFjOoXh5OTBPEVSh5MY4jtdrNc8apU7Xa/Ra3GaUNrRmlubE0gjRmhgiYQ7kWri/v6PvemTyYckya2a5diJCa61RFjJSW6UphVsU9CXnZS0oVns31TRmsQFcr9OqJO67DU0XahH1dMpxEQC9Kt+1trRaqSUTWxPRihLlbC6JlCJiLegkTsXYJVPJvBL3N///7Z+1mbLee/k70EWh2mJJpRSKxd5Qiz0faskLW/KqLpdxyQC0mDcK3vX3rn9Ug2otoLBYscxbMsZyzigR6V8JyMZtroRUbMfENizGeWm6rdmGBtUUuUoDrORMjolSEg1pdKQcRSlcZVLhasWlzLKuhaTmXGT/RqwLU8nLvtFQVJzzsteUSuEN+SkyUbF+ltbKYo1XFgWyTDgora5rZHWv6TpxPhJ1+Cvxeds4yzle771zr/e2VmF1pWRySqScSDEva6nSRNd4vd85V6yT9SXrW/IE53kmhnxtSOVFrd0alBaQ7oecu7BMKO1VlV1KIcSI0a/Za1fiWn9pEVYWO7zXey33aM1gdFbWcFPiwLWq3yU7bt3nYZ1ukJ9jUC2uQwIYq2jNotRCWhXXqR/5naJClww4sHq1z1z3er2slbzsSdLYU/I/1PI2T+y1gbp+1lWxXvI/EYMpQKs397mtl+KVWL/BsbasGasWe9GlwbAeramlafjLjLP1GVrX0dXSkcXqrb2uXdnfXxX3grVioSk5ee0X6/Jfetww/IbhNwy/YfgNw28YfsPw1+MvBcNv+H3D7xt+3/D7ht83/L7h9+vx54jff3Kn3ZkGFUr2xJLBNYqxqCovpXIsoIFU0UsQ/ODF3vn5NFLb8kafvFhSKFJKzFMCreg3HmUdzlemaZYHpSb2u82ickr03tJ1njTNKOtJYSSXCecHjJUcbGctIWeO00hTA9jCZR6Zxp6oZ5SCXC+EXFEFhv0O3eAyBqx2YDqUKaAU277H2cbpFPC2Q3nD4XSi8z2dN9QcSTHRimGKjdP5JMVB7/C+Z17yPpzrcEYTQyatChHEnrnoStWN0qAWTSqW1gopZ75+Gbl/t2EaG1/OR77+AH/3m0fut2e+PkUe9wMPbeB/+Q8/YpQlxsLdbktIkbvdHRvbuOREOE8cVaDkBNrw/fffM11OtCoW9493Ox52PfP5wKVGapfomkeFgjcFtajUcsvcP2zIUfLCP/18YNIG30fGKTPOBx66DTaBmhOXS6Kpynbv8EPPNEZQspHVJjY3ktcyU2rhdD4xTxN+Y7nbbzmHJ1Adxll2O4t3HS/HifMlUmoUixjVEeYZbcA6xxgmrNMMygAV5SHGwGYYRD1YCs0qDl+foRV8PxBiJJVKjQmtFH2/Z46yib67vyfmSM1wmY6UUvjw8IjWhThnijIcp4zDUouAhGueUisPjz0ezfPxgkKx8R31biDUTKkzOsOwk6z0WuHzJbG1cJwNiguPO8dQNX/9oSMV2cQ33cA8RmxfUVXsNuZJJndbTRhjKWWiQ1MLbLeNL+cTVn2g0eNNQntFt7HE2DjEzH/4xzP/6jd7vn/3SG2Vv/6wpYTK3LbLS3s4nid81zF4KWiUNuQgwOP7XjZe4PGD4x9/PjOlhus041Qos6VuKlYP7PeKepxJUVONYyyRVCLTDKZzPH2ZKFSmHAhT4/27e3JUpCqWMmOa2N/fc/l6IeiK0h3ZKKZQCHFk03fs+p6UIp+OIykq9nc9P/14YvCGh13H5+eRx82Wn08vfDrMPO7uOE5ntFJs1B1Kw2Wa2LBBqUZDYxx41XC2I+XKZQ5gG8Y6bCtYpbjbeYb9jpgyxnhqVVIQtozWkFsl1UTVFu8HeU63gyhJlWWKAdMbNsuL9ZRknxynCXu25JzQutJtBo7HEaVEwDJsNOdpZNN1nKYL2ndMc6FZw/FyZus82rpFJViwWpFKJWUlat9O4Z0Te3WlqCTmOdB5jVYCON46rDLgPJLfpNCqo5SEVp6npxfc0FHmwmbo+d3vP7O925DKiDYP1Dby2z8e+Ld//R6LpRuEJBo8ygWsgs+fZ4bdhp3foJohTrOo5ZxDK8VlSgy64bRBm46QT4zjBM2hdGU3OD48DNgW+HyMfHzYgvVE62i18Xi/Ya6W0sAWRSqKKVVeXiZMLkxz5d3jPdPxBd000zjz41QwaeLOa5xqjM8nni4QiWQsIUgO/MPdjnmMpGAYBoihkS8B24mVWdSNzg+iJq2JEAI+e3SJWNvRWgFdaSg+H57Y3++oOYESe/gwxWX6/192/PTl+V/8vbfjdtyO23E7bsft+P/dccPw23E7bsftuB234y/vuOH37bgdt+N23I7b8ed9/Mmd9sc9FFVINZNroTSNzmInLuoxiCmiCBjdaK3QqtgxGMOijJF8A2jX6XFjLApDLvKyptsYNrsea0EbQ5ii5Joog8aimyYVhVIWayzGaEpLKKNIrZJSoest2ltOY2AMgUwlVzDasuu3uF4TKVjjmObA13mCpjiNSH5Fq3Su4+PjHUZn5lNEacWmt/huyzkEzqdErYoQI7EW3Max3faEAJdLYg6FyyjWD05bnp9PtGbQ2oFS5KKpOJqCRuLhvufDQ49SFdtZimm8XGYOB83LJXGaC398OXI6jNxvB/7NhztyiXx6eebzyxG/6Ui68nXJ9h7HCz8+nzld4Nff3bHrYQwTg2tcThdKUbx7t2MYHGEa+Ycf/ojzG769f+DXd+/oBwdGE5sFpdjfdcwhc3rOOOVoWnGcZ97vthQUP7+MHE4jP51eeIpH3NbR7bekqrC6X/INAqWIBcxqDaS0wqI5vByY44xWjafzgTBObNUd3jpOp5HPnyZCSCgj2dMZww9//MLnpxe0rbiu4gfFy3nG2o4UsrxIdBuUsrzrd5yOJ06XMzUHUgi8e/8OpTWXcUah2O62hDiTQ0Ch2O123O/3okZKhaQtzUBqlWnO6AB4y8vlzH/84QsxNrZbTYiRcYo8PxVQmqQS2mq8Fdv16Ww5HB273R1TilSjMDZzf6f5du941xnudztiVqRqySFQS+F5nmgoNn6DyWJtZLThy5cXWrVMY6FVSzjL9Dfe4FrgNx/uOc4njmGidxJxsO23fPv4QG8tzsG7wWLqxGWamS4Nozx3mw7bKvvB8Zvv39NK5aefR2IpGG9xrmPoRXCgGli3hQQ5gfOav3r/jvfbDXaT+XJ4IVWF0R6rG+8eBqbzkRAj+67H93L+uVTmS+NvvvuWbz5u+ZvfPPD5eUQ1T+86dvuBXiXGXFAZPn39wvPxSKYw5shPTwe+XgK/+/SF+TLT9Y2vT8/87uefeJ4mfjwGjqHw4zyRikJXzWWaCVNAN8fTy4HaPJut4XCZqWhsp/n08xM5a8ZpohLJZJrRpNZQ2jIHxfPLxOmY+PHHZ8IlU5MoM503GKdQBnxn8V1PmBvTqZJDJUwBRcMYmOcAVBqivmzIen5+GtG64+nrzMthImP4+N1Hum1PLAXXecZz4vkYOZ8SaM9cESsV4wgpoayi6coYJrTRKOt5OUdi0VymyMvxzGmaJT8+JIzWOG2wWlNSJkyjiMUw5NTQ2uN9TwyV2hxZGULJpBJQfeMSM4PegK4U3aOU48dDpfOWofd4r4h5RBvLZtjw6+/uedj0+MGBLujeoDqL0QpLw/ueQ1L8/vOB0jR761AqEELi/mOH32neffPI3eOWb755j1JNlLwlLpk5nn5ruL//QNOWqjXKVD4fniguoK0olbutQ3lPjlvGKZGrIxZFtoZkNJ9PE6karDHM04hyiimcyVPhcJyYw0xugZBmSomkPJJyJqbGPCeUVvi+I6SCsXZRNsLldKGmitcdNSqsUmz8gDcWoxot/3+jBLgdt+N23I7bcTtux+24HbfjdtyO23E7bsftuB2343bcjttxO/7/5/iTJ8bPl0aOkFUk5co8HvBWY6sFr9DaMJcJkxwPjwPzKUNp3D14DocRYyzdoBncwBwiMVX6nWV+mWhFQ65capSJ7lypDWiahEZl+ObjwNPTE5dscFYMBKIuvHM9j3eVbLbUKXGZZx7sOx7vFcfjgc56NIr5khhs4TyOHC4Rg2boPecQiNkwDD2fP33BOo/Rhk1vqXki5crUIvfdPefLzG7YM/QW7wxbU/FWEWLj+HJBdd/STOAQE/Fyoes33O8HSqmEquhUY2c95/NFrkXfcQknYjHEObMbBqpVjJeJ0uBlCnydTvx3v/mG9w87vNW8jDN350Kzjo29x95pjn/XsXWK40HzHM/MyTHPkak5XubEt/f/b/b+JMbWbV3zu/6j/MpZRcQq9tqnvMeZ15fMVIpCxrItJAyyaOAOQsgd6CO60KAHXfq0QLQQSBZCCIFFIQwyQi7SSWGl82bmveeefXa1ioiY5VeNmsbcJN0jOW/rfL92LEWsWQ7pHe/z1Pzp1zXbjeTmAufbTLd5wjuHTIFN1yIUDIPnOt4oP0Xu7B8Uw3nBOcMwBySJn79/xxQWFjRhnhmWCREKokzUzQFjBLWUvNttuTYzvw0DRQiCy1i7JfhAyg6lJRKNmxzGwDQFur4m5UByicuyUNLAvPh7vwwR0Rq6qma4TT/FtVjqqqZrFdtdz8vrjettoKoatruWSive7no4SJJf6LqWx7bjy/ORTWO5TiPzktDaoFXB6PtwUihDpSw+Bj59OTM6D7JQkqSvOgyJarPBq5mXyxXhErIyOBeYv2iUskw+UM0efS7YELmlQuomXPR8uY10bY33NULCNC1MLvJh15IEPC83wqiptaTpA9++DNiq4emhJfqA2AhSsoQ5IkRA1zUff3zl0Lckq6keHmlri5gm6lqRw0JbWdp2RqoGkT1CW2orQWqMViAso5sJUSJMw+hntmbHj6fA23cVdjgzO8O35yv/qd1XpFSYbheMqbnMV768FmqrGUPCWsHt6vjWazadZhoTdd8B901rq1qUEGRZEb1iyBPBBY7nEVU3+NHx/XcXHh57Tq/33pJ3+4asF87XK5t3b+ibGVFpevZIWXE6H8nLvbvn9fRM0/ZoZZhuI6Y27Lqap31HDpGsPZ8/HXk6HNjuBEvwPNR7hmlimEcqI3jYdKQ0cruM5JKw5p6U4ebMu6rl/WHHlCOiZLK/V0Xsnw7UCgadqY3i4jynecF/TrzZN0DG+UQ53VhcAAneLcQUuCwTjTJ0ShFiRFQGawvjlDjfJpqNoehMVUtuw41u35OzpG8qJIJwS3x6ecUpQV1tEVViryquRqCUwS8BVQOqplaScPVECU1tEVIzjAtFS0bvebvZcng0ZBHvF0IEaKNREqTROJ+oZEHIyDTOOD+zpMIhZ7rHluAFX7/7wPH1Qorgh8S+Fjy1eyKJmDSVFbjJsdnUlCz57uOJw8GyTBNLyOy6FlUSRVmkTjSbHZ9fzxwXzy9+/gR+pNQCaTRBB+qkKUgokdt5om43xFzQ5R4rJpt7bJGQGkok+8J+A229x2rJ5D0yw6arGL2nyMIsPU1n0FXCWEXdapJT/OzDhnFyPL+c0Z1hzJm+qbDS3L8jUyGGjDIAEaIhCM203NDmfgmspEhtNEuGZZmoK42Q98ixkAtWNgAsYcYg2XQt8zD+sz8BrFar1Wq1Wq1Wq9VqtVqtVqvVavVH5A8ejM8BslRIXRHmgJCGJXhECjR6w27b83azY9s9cJsH3pkHtHCo7NgcasRQ2G+35BQRpaK2UOKCzPecfCUMqrrH9CpV7puZOZGzIEi4DTNZqHtHQ1URnaNWhq6r2DYKYTLXDFVdcR5HKtnRNxqpNbWwLMlTBUujDakCrQyajBaZLA0+Jibv6W1PKpHZLew2GZyAZOkaRW0rvlyOyFzx8GTZbitijJzGkUVkTvPEkjyXKbCvW/bGcB1npLJoW3MbRjCGQsTojuOXiUx1L7CXijlnnL9vvTe2otEVdVcxL5EfP59xSKT0IOp7J3v03KbC8cVRNve45zpqpmFhmu9d2lJLQij8w99fUSrx6/c7HrqWL5eFcRyYbo5tZ+kaiw+eKBNoQfaBX7x5z8d05PXikFJgVMUSEm1d4YIjGQ1SYkzNrt6i1H3oVBD8/suJ2WU609wvUuQMZKQq9z4Tyk+dEZm2balaidSFRjdYo7hdbyilaJqW4AMuBXZqx+l8RBRFKRJbWZ7e7ZiGiWkuDNMCaLwLNNt7JPZtcmy7inqb2aialBK6wHa/5XqbIEdSyvd0AyXZbh8wWpOL4Hw68rhrQRhi9AgK+0PDvjM8H6+My8I0e6w0uGEAYNNq+r4BUZgdLG7h0BumZWG7qRDK0DWWumSOlyvbrQZlcELwTkmyzrBvWHxBC8+uN9xGg1SFeXBsn96gyJQoKAK0UVxebjSbDttaogCbYBwCBbiOgtu1UNkCSpOmgO0rnB8Zx4reKP7s54/37hTV8HTo8MOIFAYXPI2VTJfAaUqUn7bNx8UjheEyZj4+X+kfM3WXSUmRi0By75S5XY4UXzGliImFt7sKKyQuh/tzqBTP5xPvD4aSIkbD5BaKgjHODJ8S/aYmyoAXgTpr6qrjy/FKpe29L6YULrcT1ipKygihUdYSk8C5Baxk2/e8OWx5efnCrutRqqfZTnSt4fOPA1FKgnBs+45FJoLQnE4z0tRMy0BlNMsys+3ae6VCSsRo7l1EQlKpmk+3Ixuxo20sVVdhsmYvFNZIpmEiJkNlJSlIbpPDaEtKmdd5uQ+nE6jakAtMw4zJAms3KDXz8JSo6wY3eaxp2HQCkQT4SC0N0zJzPl+RxqIK1HVhCIKX24xbPCI4ChndbDkeb8wh0igwXUUiYUm0vSY4wfOXG6/nmV1nePPQIbRE+IyWCZJi8Y6qaYhuIHhPjIG2ae81DSWSfYCieH05MvtASoKv+h234YxtOmIsHF9u1J3CWM3p6Hj72LPdCEx970g5bDSvr5ndVqFEBl0hIuxaw7jM9NaweM15KNS1QEjoG8nh4RHnHbJIvFt+6ldXCFkASUqCGBLRZzbbDmUiUQhykrxcRx43u/tAuwh2fc27w57f8MDiPG3TMo9XYgVLWHj/9de09Svbg+LHTxe8Xwjcu3SGWTPeFt4eNiTusfqSjFUG5x2l5PslA6UpPlOypERFcAXTCqRM3OYzVlc0jeVyvdBVNaKYv44zwGq1Wq1Wq9VqtVqtVqvVarVarVZ/NP7gwXjOEkoiuoAssN/uiX5G15Zd+44PT3vOt1f+6nff8HobeGx7ukqRZeFw2BHKwuUyEvwAUSJlZrOr0EphK8u8RGIseO9+GojfC+4FEiEV59v40wAd/JLpdMOHd7BMI4U9bizMMdIZy5I9y6joOwG5sOtrrtOZOSnaxnKZZ1xWaGXZbLY8HxeOlxMhJ15PJ5S8Rxwb0xGXmV/+vAUiwSd8KFgSMRlUaRnmG7IIQPHj60jT3gviY8l8vg1cJ09jzb1TPEcev+7YbTfMwXFbZiYf2WxrpqXwclnIGVLKVBK0Fhgp+e3vfsD7SNSCquoQosLWFb4kJr/QtImYApXuOWwtOQTKLBGyYLXmch3AGHqr+PHThFSSrANSFkIqXGawplAbS4zgJs+yZD7+eKKqK/rG01jLODlicNR9y641JJ95vt2odIeRCuccbWMgK1RtSe5I8YLFBUxdk0Ok7RpcdCzOU0pBSEEIESMEMRassZQcMVogpCLljBCCpuk4nS4obVFCcLvNqBQ5HiPRC3J02KoCBG5JOJ9xzuEWz8/ebzCjpKpqnk9ntpsDt/OFYfAoU9M0muAntLb4mOkrAwVS0FR1DctASpG6qiEXdIn3mOm6Qw6RnO/D/Zg8sUScv0djFzKVUfigaFuFVomYE1UleLtv0OqnmOoosFoQTct4PfLh/YEQIiH3BBJaRH483TB1R58CslhGP3O+TbzdtXz1oaOpGmIYKEkTTcV5utB1ltfTgnOZt/stp+uNUqBOHYdeIRHMySO0JBTNMM8IsWB8whhLyA6rFB9fr0RVeHeo+NPNW45nz+9/uODihHOe9NLxy1/sIWc+fTohjaXpLcstc5kXtLkPhZtO8vXXX/PtDx85D55hmHjsW15OC1ZYnC+4DLU2bLsNp9uAVIL9vie5zBc3o7Xi5+/ec7tceb5dafuWum0QOXPY7VgWxzTNiAJKa5SUzLcBtduyaWsgUhl42O35/HqmWMUw3njsdxih6bTFCOi7itfxRlsbfARpFEYWGqVY/EKnLMUlgoKwTDR1SxYZFyPKF7z0CF0jveKXX7/j9XykFi1dVxNzZhzuA9KQMkVINIW2qSkpcRlnDqbluy+f6ZqGyzDyzlScL1e6TUfOmtN1JhXBME8sznPYdPiYMEagZcX7g8IKyecwo2pDYy1aJ6Z54cd5Yte0lCXSGUMjYfSRvm0RsjAnWM4zl2nhFx8eaFsJ7v6++u54wtjEpoG27nB5oNYCkTNtu71vwMeIxJJKxBjJy3HA+Zm3u4bX5wWXFG5y9MUik2AcHXXd0lcdIUyUDCoXks+UqFAl3wf7VaauFKdr4ng68XzOvHnsCMHx61+8AxTzApWtQdwj/ZfosEVSUqEUzThO7LY7psXhA3S2IXpPU+9BKkpJKBR+un/ebjpDKpKPr2dEcCgpSKlwfv5MbRVpEfxzf/ILLtcbUguup4Gr9wRT4UqmV4YcE6UqCCR13VJXFbMb8SmghcYoCQXqqiHEiNLq/r3xUDG7iDYtKUts9ddxBFitVqvVarVarVar1Wq1Wq1Wq9Xqj8cfPBhPxVLVgrxI2k2HthXbbsP5PPPd8ysfP34kpispK94c9pQYSSqzOMfpm4k5BMR9Ts0yObSBw+OO8/UFrRVCQlXdN3pLKaSYEEUi5X3AaIxFa0NJjhAz1zyyj5padySZSGRUglTAVIaQJTkErOrwIZEiFASxEkQlsOLeaT6MM6fLFV1ZqlLYbw+k6BicZ17g1z//Ge3O8OOXZ0Y3Yooii8B3L5/I+YDFUylFq+FWArfJIXJimhPbvsfWoLUiBo+yhnGRCB2IwnMOI4uTuLNgchHnPTFncpHEOJHighIbuv2GOkFEU/KCqew9HjiCtZLdpmNZPMEvKHPv5FVSYDtFyR6EoLXQ1bCkgRQty5joesPPfrHh+OWFzds3oCWHg2aaFlzY8vJ65Tp4+kpT4n3QKLTClUDXd+RSMcZIyYJpGXl680RlMpVSeArBVywO2rZiWUb2ux1aFJS0tHXLbRgJhHusutRM40Apgsf9llspuJRJIaDUvY9ca01VaZpaYrQm+Exf99R7Qd1qXs9Xjq8FYyUxejablofHlmkK7BqDqSSNbahqwfUm0KphXjxVo9jtt8zLDLlwu1zw3rPdbQkxYrRku7UIAW1t2W4sn88z07ygtKexG4TI5My9O11ALpkMqAWCCBhhsdWO74+f+NXPH7idPJXWLDndL1cYgyawxMK3nxe6RlCLCLPg25eBaCV/+6sdksA4RlJakDLzuy9nfvm0o2kb/vG3L3y1V8Qw8PIc8FFRtYaQPLkUrN2gdWZXVdSmJuAojULGCu8dWiSEgvbxkSjgUCKzmEiXgYfugE0a2xV8vJEzPL554OX1St0UdtuaL88nuk3DcnO0couzBakN211FSYHf/Nnf5r/4L/0t/gf/w/8Zzie66v5YDUUy3ya0ykghaWq4XW4UCSE4SoRWV2w3G1xceH59xS+Opu253mYomUppKh2ojEBve063kZChFhqXHbd5ZN+3hODZ7Cs+fnskRIUQhZgTRWWCCvRWs+13XOeR3eGJ8TxyGSe+OrRsaoGLsNs+oHIm2IZhnPHe8+bdE7Mb768BYbiMI1O+x3PXTmBMwzA4qspQGcXTL7b8+PlEZ2tiDiQyMUeEkGy2e2JOKG0owHb3yDBlsrzHfCtpWHLi28+fUdrw+PDEMA4IoamU4Xq5kIJlRlFpidYGoQrBC9q64lErvn574LvvjyAzPzwfkVVH3SuqumaYZ8gCLQ3TkNBSkSO8XM6cx5k0eOxXPS8/HFFGc9i3iCRYQqTkBNKjpODhULMMke9PZ3bbmnlwjMPMdQ48PHZoIUkSppyJLlK8RJiMVpq+TYQkSFGjZcGnSNvUtJUhC8fj457r7ZlvPz7z618dcK7hfHrBp8Khr6EUMhkhNQJFLpEQA6axzPNCVRsuwwUxQq0VmyYjyIy3kRQEk3fs9htqGvxw5Xq7ISQ0uuLz88zj24a4ONqu43q+sNsdqFuJUZAvM8MUkUYxzDNWV5RUaOqOaVwoMVMKFClRFppWM08TSllyEHT1BnE9cno9IpUhZUnXS2JWf30ngdVqtVqtVqvVarVarVar1Wq1Wq3+CPzBg/ElgkgJF2AZHZc0QJyI04iPGtFo3jxu6ZShQuFM4jQObKqOIhxKBJwXhJTuXbCy4h/9xTdMU6JtWzZ9A4V7zKxSGKvuUdshUUQmpYgWEnJESMOurolLoO0kqEKWAdsI5ltAm5YsBDEIjDJcxoU4C4Ka2aqaD7tH5uAYbp6YBdZolDakADlHrtcJqSW6SLQojNeZpmp596S4aMfn0wmtez6djmyMQpkea2r21cLz60hTW1zRtBUgapyfKRJcLCxxpvv/RfqmQpKGKCSJhFIapTI+JKypUVbQGEtSElUkDxsYp0JK6d4N3QneNjX1kvj2u8Dbx57zcaZuFPuNxqWMzBqlBYfe0tqa023ieJ5o2o6UIXl42OzQIhNSpDINQQZCyTSNoRRNTpHn5xNYQy6KJSieHizSZPreMgyJnBXH00BXC94+9YTREQNApq41QlgEicpaYopchwGtNDEFZjfRUfH0uAEJ4zgQk8AaAxKstYgCzgXG0aF1i6kkla3QuiKnQHAg6TAmMY0zUkJbS1IRFBV482bL5fTK26cDMTvMbFicJ8RIqyqUVCgh2O23BD/T9x3dZsfp9QvaWA67LefrhCyC221hniOVsohmAxnc4mjallxgu91QUmTynlbDtCSKWDiNI3OSiCXRNAKjMs/nG7tDh9aay2sCWpY4UyVLMRZhC7/82Y5to/n++cqf/fo9r7cT0WsaCwXL5GbEKHjsKjBgheVhn1h84HwdePP0gNAFUsRgyaGwyIhSYIpmJlBkpN9U5BjJMROCY5GOYViIc+QarrDp+e7HG9cQaLVkGTzTEujrLSIkhKz5cKj5i/mVL+PA148bXq43QFDJws9//nOev/uEm0Y2hwdijoQUaeqKWtb0G3HfhA4CYe4btkJD9JlIYa80McN1nFAxUcUaUQopR5ZY6NualAvjvDA7hzEVt9sNIeDlcoXc0dQ117PD1C3u5QJS0bVbtIRuV3N9ufByuvHxeCEmhxaKAEjZ4zLMMdEFzxQSV59IKdFvO2JaqLTAaMMSA5WtSQliWqBk5slhmx7vBtrKcL3N2LbGolERum2NjwHnFoyuURLatuN8OVNVisvZUTcWLRXX4UIpma/fvWccJqJzhBCoGosWiv4gOZ5mspK87zbEEPGucL3O5FCoqkwdAxWZtw9v+T584jxfsNf7Z+Emt7R7yzRM/Hi5cV02GOkQWtHWPUkFrNF89f6Jb388cny9sWk7hsuVxioyhdbUTEtAYPApE4rAedjsakKRWKUBwewjU/T87F3PckvEkijhyod3W8IsKCROl5F61xFlIIRE0YXr9cruQTM9Zw6HN5QQ0NLik2d2M1JYluhIKRFPEUqk23WIBLIIgivUdYNVNcQRRYXPMz5ncjFch0TIjtJHlmEk5cKcI0YbTkvAjhatFFNc8Evi+WXicKipN5ZfvH1LTpLzcEHWNeM4YKQmpkTXNkQfSBlKKfjg0Vohlbp/HqdMSAEpMnVlELKmagwxTkgh/1oOAavVarVarVar1Wq1Wq1Wq9VqtVr9sfiDB+MlLhAjMkn8MlMZSdcaSt8SHbgkUUmBgiU5cpRUoiANWANJKZboOPSWZQnMy4A2kqaVSFHwLhBCRCqFUgKpwBiJ/2kD3M0BUkCIghSS6CfoKpIQqBgxSExVYXXCLYJlmWjalst4YVwivhQOO8tlWCjBkUriy2XGqorGGkIWzKPH+YXFF95VGx62EiFA6YqPf/Uj+12LrgpvHw68+7Dn9Xjix08XmlJTS8HjTuO7ll996Hk5TwxLIIUAGaRWLC5xLYFd1VDrzK9++cBffndhHBzKKKySaCkJ3t+jvGNGS0MaF65TwIw1b94ekHW8P1a5xSrFpobDXlDrTNMoQgjsmo4fTice+w1CJJYgcdOAUIKuu29Kj84zmxohE30xvHk8MEz3DfOmUuQEt2kmhcz+4cDkZnZ9wzTN/PDjK13TUZmWczhSt4YUFoSuuc0JFyW5eJRSkBUUga0symjm04wQksV7pLJYIfn1rw/sDnv+o3/wO27XCS0sVlqCvw9qSy7EmKnrmmn2QKZtDNfhipLQFcM03pjnBYTAOY9fAm2tEI3hx08XPrx9y2O94Z98+w1ogfMTQiliTMxzwEjN8fWFw67Hp8g3v/8eqxUNhexhGmceaklpWkL09E3PMiRmP1JSRoZAZSv6puJ6HMAXkIIlzOy2jyglaaoWJw1WFRKedquptSIV2G4lD7Xh5dVjadBGk4xjPgV2xvLjZeBPZjDK8uxvuIsF67m5wp/tDH0NaENYEu+fNozJsy81wzURoqDkgtoVPh4HDmKPrTJK1zQykGTFl+MVYSzWJEqCEiUpBlRlWYJDhcziM5UxKCuQRmKEJefCQubT65XKSjKZ5CKywLtNwxwzORpUyCipaGyFqiTHLxFtoa0rSnIoNFZZYknkWAiLx5eGzaZiv2+ZzzNWad7tWpQoDD4ifUEYSQ731IFCvG+RS0VYFjb7HeM00rYbXoeRx2KJRIY48auvnrjdRkoFxiguLyMhFgSJt087LuORafR0uuHj+YqxmgbFXAu+nEZs29JUFtNaGjKziwhr0CUTRMDNM+8eDrzbSHwI3JYrh6ZlmQK34Jmc5/3D/p9eRkBIfAAhBDlHpnHG1poSBbt9R8keKzXFKayVLD6zZHC3iRIyQnl0yXifaNuG5+PIJ260VY1MmR+fz2wOOzqt+cvfP/PDayKqK5VpaKPCSHi9HEnZIigsGbxX/DgceXNoUSmQEWgDn59HfvaVxaeIsZpM4jLfeHrzM4ZxpO8bLs8OHxwhei6DYpwE+02LKFeslkwOAoLiFfMiON9ObHY9Vmicz5xfJ6SeOd08H3oL0WDFSCmWX3x4w6fPr2x7zWHT4k5HpEi0rca7TAyBgCdnqKoWYwV1IxGpkJaFLCRV0zDeRg69QhtLZSxZWZ4/XZFaMQfH//O3rzRF8nDYc/UDb5sGbQqnZcBqRb4K6rZiWTzN1lJ5iffL/bmMmRKhq3uyvFeD+PlGW1miXwgxYuuKlBRKtyyDw4WAWK4oo+l3BiUrpGjIGkrIf20HgdVqtVqtVqvVarVarVar1Wq1Wq3+GPzBg3ErE5VRxBBpjEDkhBaaHNR9gFsLhI10qqZ+aPny5Upb1VhZc3hnKNnzvQRbNUzLBaUllOo+UC33TnGlNZWtgIwWkOJCotBmy1wKVhuMNAiTqG3D75/P7OqWn72TbLqacXZc5whRkpTm++MNLRoCEi3vA6OqqtCVoxawjxrnC7Hct/lsrViCpOTAl+uZzmgGH9nvOjb7hugTyQne7va8qWvMYYu7ap6ngX7f0kpodOZ8nTCyoBVsa8O4FBCJB1PRWs11mDm0DcVn3m5bopVcbjekNaRYqGvNr3/xnrokfv/ykR8+j0wxMNSG9+//hBQEGE2tEm7xOO9poiCEwraTLN4SSqTSFSLDFAPeObSpebttSUNg0gJTMm+eeublxtNuh5LLvcs8LFh6LteRk4901pLdQt80LCFyut14//ZA8pHFz+x7i2laZPTMQaBlQuYFlSU+QpIzqmQocLqOlJwRSiGKZLupcE4zjpL3DxtUAVNrZKmIoTDeZtquBwS2VsTikVFghGL6KQJ/nBfazVsut/l+UYKCbi1L8hyaA6okWlPz0Fn+4e9+B7JmGq7UdXUfoLkJJSxLSqRSCPE+tK+kxFqJtVBINJ3BtC2/+/jMdXJAhVSR/bZjHCeygJQzyxwYM0gF4xSpq4ZS4DZMpCkR+3sSgWoqdmjctOCFQUZHVTLKaD6djrzVO7QUeOCHk8MIzT/47gfe71re7Gs+pZE5wK/ePnBdAo2GSgqUMlSNIS2GmsiX5YYSE8UqnjYP7OvIp5cTle5JKWOsJMuEVIKn7QMpzwy3kd2+obOWc7ohUVjV0PQjKcPjpuE6OYoM/PoXXzOcrkiROU0KrSWpZGKMNEbzblvjU2E+vvKLv/nE/s0TP7w8Y21FLp7xEvFRMMXMPE90dYWuamrhKSXet5SdR2jDPA6McQYpSIBSiuuwsNtsmd3Efr/DVDcWH/A+wTDQ1A2Cwn7XEoLjdRxJLvM538h4nuyB5GaMbkkhoG0ip8Tf/c3f4JvvPzGFyDw5HnrDm3c9ty8TqUi0VBA1Xz6PGGC73XJbFjatZjhBFIrZB/7R7y6IqsYtgU/+Rg6FXAohBRCKIgTTEjjdRq6XG4fDDq0yVle8vo5IKWi0pijYbxuuy43D5gOv1yNWaGotKZXEhcyyTLx9d+A6Tzx+tUP4xPk4krUg5MSXL88/DYQX+n3Lx+cvPB4eMEZzGiOjK7x9qilLpkITxUxXKSSFXDS1Be8TocB3P9w37s8+gS5s2kfma2QaAt9frlglKFpjbIebA6VSvF4mjOkY5sht9Gy2G0KeQPVU1RYrLTEFXl8XpPacL46PY2T4q1f+7NdvSFIgc+Ev/vJbzkvCGMs8TIho0RK+/zQz5cTbg0X5zHa3ZZgdTdMQRkcis0yZyzDT7Qtv3yg6u+U8BmyBxih++fUjp9PEdRj56vEN0zQxFk9ft9x84GG7JZVIkoYv14/0usfompgL5+GK84XGCuq2oQhYRo9XASMk41woQGtrikiklJEmM88DKSuUbjieznz17h1KSxqzIy2BVCxOub+WQ8BqtVqtVqvVarVarVar1Wq1Wq1Wfyz+4MH426cWawU5z4SUkEhEiUwuoqXCSIPMAq2hEobHfXuPbq4gEUhZ0XQbjEz0bY0LMIwjSkgQsOkb/BKotMItjrZvELImXQIhFuraQIaYHNu+JcYACXyM+GDIxXGdE8cLCJngp01vUqKUiLENioiSgYLCBUVtJRHP+TRRsgBA5MJ+XxNi4bxMDAWmKWMbgXeFne3Z9ZZlDsQUGJYbFMHz8ci1CEwjcBne7Ht2MiMxiDYyzYLdZsfryzMlRoSMCBs5njJNW9N1HUuasKrh6e1XXE5XVGcxQvFu1/I8XRFC8ek0s9lAV0mcB20rbF+Rjhe8AyVbcp6JPiEpqErhZsk0Oja7mpzum8N9U5EriS6Rh7ZD54ygoJWilA3awOm7EY+mkgHvPDElvA9obRlGBxmqxtI3NZ9fjxy6Huc9Va1QSpEoFH4qlpcKqSVSZkIueLew2WwYhnun7/fTwjQEQtTURjHe7pvfbdeQS0JKiVSa6Dy1rek2HT4GUi6YqDm9nO6XK1SF1IU/+eV7jq9Hvrxc2fSWIRb+8psZYSqOrzd22x1CFF5eX9BW4fyCUhqJxIXA4h2VMmhrKEJwmyeUrBiHwjxn+k2HFPBm94Yvz1+Q4r51aqTAKJA5UFWWKDM+RqJfaNoNm01NcjMfrwnTadrKg1B0/Z7pduU4LoAmBME4LkxOMUyZ8/WVrjU8bHqMlixD4MPDjpejw4dEiANV33A8LWTR8gAICRTPLz60GCOphUbkwjwGnE+0oZBFxDnF6D3Pk+Bxn0hC4rJgmCPWakxdQfLsNpLbIOkay3efnxnmiCySf/CPvkFIiakkSgXmawKhcEAIgW+OJ2QyfP2bM//i2/8MX73r+e7jZ0wjEVnx1dstz5d7aoIApmlA+ojSmq5rkVLx8npimiO2qhFCIYQkFyi5oLXFh4gPBa4jiwvkUigkpCwYo0mpUDIsy4Ki8PSmRyKYZkWK95+ZM/gkOB1n+m7L77//QsiZSmvag0YbxXT1XKeBtu6IzvN8uxCKwAowjWVvNTklxmVGojBGY7dbXAKhIilnlDZUSjNfL1yGEXJGhEKMhW7TI4Sk71qWxTFOE03TUIzGh8DlNvPu3Qd8LCihWJyjb1oqrZlzoEiNyIq3h0cogmwC/S7icoFSI4TB+0xbZaTQVLXGh4IUBSkztW04Hiecm+jaDUortC5EH5knT9Hw1ZstMid+OI+gNV91LVrX5LxgtEYI6A8V42Xhy/MVYqQ2htk5ur5lGEZAYKzhfBmhFJageLneuA6Grx53RDHzfIXJZw51x+v5yum643S8cHjYYZTlN7/pGV4d0xjJ2TMMN85XEDowzYrtpmY4eUrtWS6RTdcwDZGQQejIm0dFSZlhHiEFxkvCu0SKmcooNlUhh0AyBqPB+cCXcUGLwm0Z2e33vHl4gCiorcUNgZgih8cOlTPj1WMaSdUa3OyJqeZ8PKIeBFYKEIZlmkiixlSCZXS8efuE6SxaV4QYIC2IDEIpchJ/DUeA1Wq1Wq1Wq9VqtVqtVqvVarVarf54/MGlpY02OJ+Zlkx0hRLBRdBG07QNcSm4uRBSYpwWrqdAU+9pNxXH48L1GrlcJ8iCxhqEKFRVRd/W7DeWeXIoKTESmsoQ5kCY79unwzIxjDMuRmIuTNPI+Tz90wH98RK4XAOvZ89lTIzec77ODLcZHyJKGqbgaG1FqxSDS/z+NJK8oNYtSlmEtaAkbWt42rfUjeBym7iOidP1yuI8m43AyYFvvwzEIOh0x9u3e1LULAuMznMb4XaTzAFs26BlixCKy+D4qx8+EQXoGnKSNLLlcddhjCQvieIlT0+PGBvAzMjWoeqErjPvHjbsesEtnSBFKgDlSbrgMySRyTJzW0aEygiRCSHycrxwPF9BClz0XOaFH16OnK4XbGMRUnK9jbiQcEvEJ3h+uRKywFQVtapQ+r7VWgClNdM0MwwL0+zwPjAOIwgIPlFZw6ZvKQWquqJta7q+QxvLMi7sdz1t29OYmk1j0Lqg9H0LdZpnlIaSE5UxPDzsMVYhRCHnRIqRbb+hshVKSVIKDMOVaVm4XCe6fsvhoaWISF4KbvYEAnPWPB9P9F1NpQEC83Lj9fhKzhEpC0IU3LKQcibljLUGQST6xG0YGIeZZQl8eX0lBo82isNhyzRc78PPytK3HbvNjsvlTN80bGyNERItKrqqJQXJ8+uZP//uI4tMmO7enY2SJLdQZOGrXY8RioeDIoyeGBeaOvL2bcdXbzs2NaDhhry/ngGXApSa4yD43Y8zn44vQEIrBUlSS0mcE9dxYVrCfbu36zk/n1myIzrPy48L5y8X/t4//i3H1xEjBV5KFp942lb88s2BMAuCl3w+3hiWDFngvWByGVEi//zXT/QkJBFNxi8OWxo2labqCsfPE8st8Z/7F/55qkrhc0AZjVsKp+GMFInzeGWz26ONpq4aRBG8Hs8oa+nbitpqjFZM80TOASPvFz2WxZFzYV48ORf6rkdpjY+RlBJKSbQ2SKno25qu7pnnhAuRy3hlmhM/fvpMEYL9wxZ0YpgHCpnt1mC14nS5oSRUmwYpC41VHB63UBJoyexmqqqia3qM0lij+fTywvbpiQJch5FxWggxkVNGaY1LkXEJPL++4oNnWTxtVxFT5jYuKGPwIXId75v6zkfGYeR6PNM2LYlCfzggbUUREiEkx/OV7777gdPxyPOXz6RY+PL5wuUykXNGG6gaASKScybFgDGat09vyCGiNbx7/5YUMylGnIsMy4KuNTkLtKqo25o/+/V7Dlbx5brwlz984nhxDC5QTM3L8Uq72VB1mg9vNzxsK6SE82VA6wqhNIuHkCFkz5fnM8OyEFXm9y/P/PDxAkVyi4X+0fD+F08UU3h81yKVQmjB6SWgZU3OjsmNVBuDbgpFCJqm4ocfXxnnkZwyoBnHQHCJeZlody0KC7FjXhKiUvi43B+b2vJyvXINkb5rkCVTYmFxkeNl4nwbsUYjM/h5ojIGHz3oTF8JVFGM15njeeAyLiRZqG2PtI5f/maHtpLFCy6XgWwrkOAcDFNkdBc2rYKSySEjpeI2DSw+UPLaMb5arVar1Wq1Wq1Wq9VqtVqtVqvVfxJ/8Mb4UgLTsuBDBCMZ3UglFdZULNGjrCEVSak7fvhyInnBZgdLgcenR8KSGF1CqYoQEjEUusqiibw9vGGeX/Auk7SgrWt8HNlsDQ4YxgmjNcucoUq4BDEVTCVoGs/zyfN+3xPzzBIsMcX7JrWUSK2wxtIbCbpmyI7T+cY4QWdbcoxs9xWn04AuCu8d3/3gEVrRN/fNvV2v2WwM8zCx2Tc8vzooFYKCn2ZKvGGkpVQGSsCnzOWqSE5yXSaGeUGg6eoWhMN0Fu8K82II+crx5uhth6HhoalgvvD24YBzM5EGtTX47NltFT5n0qwIEXRdkVNkmSYaKsj3fnCpYPvGMnrH4gSbfUdyhdN5xi2Rqumoa8M8eo7TQFf1zEvCWM1087Rtze9/f0Ypg/czcwG4dzgbK5nm5T4EtBXDFNk8PVALCEuiqWuW28g4Tli7YfYOiWJaZmSB4XqPx3/72HLYdnx5fgVT8e7dHhEjQmsml5jjjXS9IoTgsN8hhMQYxTiOJJHZqJZN3UIRFKEYpxlKRFGjhCJnx1cf3nKdF1JIbPsNpUiGKdJtOwqKNC+0bcu+67iNAyd/Q0hJTolcPJu2JSPxXrDfbzG1JUVJuyhcguP5RHELuunRtqIy5h6NbCtiSpz9gNSCFAIhGkpMXKcRa1t++e6A1YmgFaFk0rwwDIFRRWqd+PBmy9F6ep2p5Y7LxZOMQCqNv814l/icb3wcHKfjwt/9+pHxPJJlJPmK5BRaCLSuQUkury9UukWViUzh08eF8+T4O4cOXWu+u9yIl4VK9ZRaY6oaLROialDJoUWhbiTdvvD3/t+B/cOexmpeTs+4kLjNir/3H3+hkIlCYZQjJEvgRkEwj57vP33m99/+wH/6b/0L/Jf/Cy/87/8P/z6+Mti3ln/pw5/yux+e6eqG19dXjLEIoZjniNESJTXSqPvw2znyT5vXKRd22y3H0xFSBplo64rgF1IsJCClzLAMPOzfMN6uZCcZ0wWrFUJbHnYVaYK3T3tkgXlZMHVFdzigRGK+LShtMbrm85eZuQTeH3ZMMXIeBuq6IRTHr96/ZWMKx3EgSskyLcgiOL+eGYaRytY4f09eEBmMMmRAVQqCogjQWvLDD890TcttnDDW3i8MWUOKC0/vHhnGhcVnbsNIQfDl5ZUSE9bUuLAQydS2YnITh21LRrPddbhhpmkaYikkXTPczlhlEMrTdXu++/YH2roG4amK4M224zpO9y53LbFNg1KRcVmwxnCwlpOS9LWh7zXDbcZ5xTQHpBFgEijotj3h9YqUEms1KSVMJdBaUIpiXgrn8wkhC+fzhKgUldQst4ltu6WvG3oXcSFj+pZ5yDyPkZwmHvc76tzz+iXR7TVt13C+DMyDIgQBSiOmTOkL4TpRt4JtbXk8bNBREPJCUZHsG9q2Y1kWLsMVdM3L+Yx5rKis5ocvZ6q+ZbvtKdKglSDlzG5f4+cZHyRLinih+XL9xNfvHpnLjLUGiWYOic9fBmxl6Oqa6B0yG+Yl0qoaLRuer0eC0ojHQNtISiosy0TXN0xzglL+mo4Bq9VqtVqtVqvVarVarVar1Wq1Wv1x+IMH4zkKktBkEtu2YiLgQkTETCySpq/xIfJ8GUhFECm8Hi/YSqNkRGFRyvJ8vFF+ik9PEYqAT1+eccHdtzxtxlSSVATL6On2lt2uAi/pGsniM8EHQhbs246iHDElctLsNy3X0WNsTcgLtm6xTUWlDW8fDoyz43g+o0xDYz0hJqQvNF3N53QmxcBu0zAN4d7XGyObneHpaUuWnmgVv/v+RGUbhnkiTpGYBUkZvn6zZdsX/uK7E03dM8V7ZLhMEbc4ivT3SPAS6Zs9Scx88+UVlxzG1siNIbnAMh8xZPwY+XR2+FDYd4amkiQPCU1VWeZpJkwCnyP7rUVm0CIzDJnbObINEqVbeqO5jjdKug+8TSWRquCDZwyBqmo4jRN9Z5FJoRBILRDGMtyu7Lc9ISeGYcFag/cLfdcxzSNF3HuQldQI4ckUXPCEkhHK3h/fIgjeYbRhWTxQaJuGeYq0TeL9046sDX2/IYfA5Beuryf84tD6PuhCCJxzTFNEa4WQksUH3OLwLjLMA01T3Yf9y4xVltEHivOcLjdylvR9g65rjFvQ4h4jzXaLUZJhWphdoKrv26g5BJrG8njYcblMJGsRQjKNI31fUeua020iUqj6niwUMUf8Esg5E3OmMhpRJCInlCxE4Hg9smR4s6u4Xm/4ILG2oCpIQvBxmSHBr95v+PbjjPP3SyjDfMKNDrRmqA2dtUDmON1IOfMnP99wnWa+DB5VZfo6E3MAPyO1xEXBZtNzOZ8w1SPffDnx8TowjTN//59E/pX/7K/5Gx82vG4bNm1Nj2dZMlWSlDqjRQapKQi25pFffoC2sdxGh1I1G5vZVi1zXFgmzaHVpFKoa82SCiEahAo8X1759/+Df8DbzRP/lX/9X+fz6cj/5+9/w7ZpCEviTdcyTx7R9SzO43ygripSipzPN7Q2eO9JMYEQpATT7Em3EaME7949scwTX55fkcYAEqUEOYO1lmVx1FWNrSXT4GjajtvlRFVvsLWn3G6IWLFkyXhzzDnzcLB0m4bbdSAnw3EY+PBhS8qRGANaZKyRkO/1At4ZLqPDGkNuBFZrpuWerGCMxUuJ0hqjNOmn90vJ5b6BXtdMkwMhmJ1HKo2Rmpgii5v52fu3iJI5XY8oVSMpdHVNzhJdGWIsaK3QUrLpa4iSIhTD6KhqgyoZYwTLOEOxWGWprGa/rXFuZLvdMM0LwQfScqNuNUIJttuOlBPkwv7Qswwj0Us+vlyZZ0/TNKSUedrukOKe/tBVgmkYia7w6fmGRCOFum/FO8fO9vR9da+kkDWqzSAhJsnf+OVXXK9HrjfJb/7kPaoUvhxf6B4U7w9bfhxf+NnXB373288kkTDWIIxjDhBmgbUGVXmkckhrUUXz8fuRP/3V5v5dZDKEwjAkJu+QOtD0liTBNAbrHVZJatnicyEVkNowLguiCCAxAzJndoc9yIiSmlQSL/NC11eMXnC5LphKoHLD8XjGxYzUCbRAIGi0ZJgkIQSmObDdbhnGG39xcXz1pmW37TESluDIWSFK/ms5BKxWq9VqtVqtVqvVarVarVar1Wr1x+IPHoyfx3uX8XiZeLPbYHd7Xl8vnK6vHB5+jrUHXl5/RKvM04NF13D6uLA/7LieJ2JaKLZldzjw8dMXUoEoMlJIrsOMMTXOFaIPVJVBKgk5o4uhNoJ3T0+cpyNi1qi253i5okoiKc1+Z2hbRbXZksvIcY4cmv4+XF88Td8xzjNhmjAlc3URIaG1Gq0F4zBQ24pAYp7u8dtICCJzHj3jUMgyg2kwtWO7UXw6euYYeNpWvOkgzYrPw0RJkjlMHN48EpYBawxaKoQQdLUmZ5icJ8XInBx11SFL5PJ65hdfPWIaAbPgu+sXplRhtSYKSV9pXOQ+FPcDPnEfhlvLMo0QFbKyDLcT2momN7MsmnE6IVXFw+GJH748s+16tn1F8rAojW1qSihsNjXXIXDYbJCy8Dq+sN1vaRpLmQfqylLVFrckQsgYcx/OOucpBbTWjO567xD3AWPvnfAlBvquZvERNGy3e0oITFPEDo73T4+MPnI+j3gfmf2CwrLpKgIZpOQ6DCyLg5KwRtNUDdcQOJ7PFKAyNWF2VLstQsHteOPzfEWWDDmzxMLPPrzhzaPEpcx4NQhT2PcdP3z8hLQVTb+hqWuG6w3RappWIiRIJSmhUErBucgyeXCBKS3YtsHYBmsMpQS2fYtWgtHN1Mowz5432y2L96SsaR533JbEtm/wBF5dZucUX7U11yypZc0ljry+3ihe8cPtSFPVbJoW3TXM3jOkzLI42qrm6grKeJZjRBtJ1SoaZYg5My6BbQepCK6D57HdcJ0tR39knj3j9UZKguez59vvZ96/P/DmHXz6fubzKfDmwSJILFNEVAqHp+02pBx5/2aLqgyXxfG02/DQSmKW6EEwxgvXiycKQ1tZgp+ZZk/WhjxG/h9//o/55Yeav3X6Gf+t/+a/wf8k/Zv44QwKXq4TIRZSiD9FjXOP6A8RYyw5RfabFms0z88vTMMVHzIoTfALL8/PjMMNVEXMEqVBSkgpUduaFDPn8426VYjSMI6Orq84n69sdENdtfSbjkQmzTONaaisJuaE1PeLKw/vn3DLRLWx1EoxLQ6QVEqjbM3H5xMZwdPjgZfzj1ip2fY9D4+PzD8lX4R4j4BHCJQQzN6RUuZyGdBGYaqKFANd0yITTOPAuw/vCYvnNlzYtj21rtHc/+8/vLzisqKuatqqY79pkdmjRc8Pr69EII+er552BO/48PYNry+vJCWQ3CsQ2l1LioL55CgUbtMFrpDIfPXha7ZtR043ZFnwMTE5i7WRqCC5yOGx5+PnC0oUYjY0TcOmtvgMPzxf6eoepSRNVSGKwPtIEyVu8Sgl6Tc1wzgjgeIEHz9eeXq3pRYGyDRtzTIG8qjZtI9c5itSGkqAL1/ODEsm+QWF4OmrA5NLKLFjt1NUIfGbQ0VcZhYvqVvFbVqoGsntOtNuOn54WdhsLU3bsN8ZVAZiJvvClBJNZVmWCecyjcx0mxajKn77lyfarsXFkZAXHrYH5jFBujD4kXKGTz8OKKOQVQ1Sc70uxBBpHzqmcCHJmlwih17yN371lucvM9988xnKR959OPDh548sYWG/6f6ZHwBWq9VqtVqtVqvVarVarVar1Wq1+mPyh2+MJ4lzgZgDL6eJp4cH/uRXe4bhDR7Bdz9+T86Rp4cDb3YNSXhe9ZXTbUDL+zAv+UAKDSAJ3qObipzFvd86ZkoK1JXk9QUe9oa6huFyxQr48fmZYZDEFOh7QYNid+hIfqR7s6OkhPCKvhV4B3ttePWBnABRUJXndBp46GpAMsSAdwtBFhKZurr3m1+Hmac3T8yzYxpmhIRQHGleMFLw5rHnhx9uOB8pOeF6gzI1/+T7H9j0mr/zpz/j8/HMvi389tXj5pm2sfS9AjJKCJQUKF2z7zKLy/joedhu2HYtt+GZRmzozMg4BFyJfI4TInUIqzA2QhagICwLfV0RZkldC7CG/aFmvBaGSWKlYRGG220iCcFXTx1WWVpbE/WA1IrZz2QBp8uCFZrTbaZSUCE5HDqGZaHtOppWMgwzBQW6UNK9D3nbbbndBt6+e+R2G8lRUFcdOS8sziGFRkiLDwtWWa6nKwVJzoXhNrJsej4+H8mhkGIB5D1imYwVgl2/4eX1hNWS/W5HSpG26jhfR0RWaKMoJbPd79Fac35+piB4+7Bn8Z7T6UpXW97uH/jh+1eGJXG+DGy6LVUT2B12ICxGCmIKSKlJMbE1O27XGRcFRWiGaaZpfoq1Nor0eqGyCmkEp3lAUjg0HYbEtqp46Go+hoXXKVEJgTWJaUoYrYhL4jIVlM20D1tel4RfRoyK/Obxgc4EXIRgHu6x3lnz9m3PZXK8vg4IDbfLzOQmurZmTjMPzYF8m7iKgpAKZCYmQ86JbWP482++QdkNXx02/L8+/0BVG5AaiuQ//u4bTrc9f+c3P+cf/vgXvNn0fHhqsFuLmgIJmOdE7RaM0YyTR0iDCobT5UxftTS24sfZsek7LsvE4hdejhmdEyjFfJlRWuLHif/jv/eXqL914W/Okf/6f/W/xH/4f/13eLne+O30ilsyupI89VvQkmG80ZqKrDVTiMxLwAeHy5GQIiIrSk5ILZiCY3t44HadKalQJNR1y75vMQKSSLz/8JbTeWCaBn799VfUteDT5cLLMKMUlGphGT25VKhWgUhQDJUWuBIJV4e2hU3V8XK+8O7Ne0oM5BwJbqLvDJO/107sNxumcWFxI41tEUogo0BqQygFSiHGRAHquiHGiFYKKaFIQc6JOTjqTU2tAJ94e3iDy5nzNPD4cGA8X3nc74kxk/M9keLTD1/YHnpEmok+UvS9V33bbfg4TYhpYfQFmSWJjMuR43nCSgsIlDFUoiP4TCERc2Kcr3RVw+UyE5LgNA68bRuMbMgx8eXzlRAFqurpuonxnBh1pGTJ3rR8ud4QORPGmXa7ZbexNJ3keik0nWKZJPPikRheLzeUUhxfL7w0W/K0kJTkdHM8dCNvHzZcL4EYB8ZFQ0zkXCgZfMp8+90zKMVm11LTUETi9ThzuyZUFZBOoHKiKS2LzITLwFQil0Hx9GbPttdM1wWixGhPXQt8zMgEJSXU7oDLgcXdqxcuw0C/3fJ0eMAP959/86ZDUwg+ozqLrTXjMJNNj3Oew6ZlcQGEwk2B/aGitZI4KPbdnu/tjSIEPz6PCGP56t2OhPtrOAKsVqvVarVarVar1Wq1Wq1Wq9Vq9cfjDx6MywK7riJFS4oLx+OJaajZb1sWv7AsA7VuSSExDx69k+hKkqNBKEVioaiCEAnvIzkJhJDEGBEYcg7kUigIshAIVaGUxCMQutBawTTOGGmIzpGzxvkEUeKXDCSkMaSYedw2CGsIUyDEDCWTk+DLeeE6OiwCU9l7v2/JiCxQSoKI7PoNX348ok0NKfN+13DoDUJYfFZkAkpYrFXEuPDyOuBzoKsMvzwcYIz8fPvA6BZiCSQKdWOZLjN9V1FEopSM9wlbQcwFpQw/+8UTl8sJNwkuDPS1pmoyXd2Ts0daS06JkKGUSI7m/veESPvwCMWxzIW/+jwyDp5KSkqZME3NZrclk0hJkAgIYalMR84TMQkak8lFESlonXi+jNQ2M40jwUeqtqZpG/wyI0hkHwhhQesaISRSSqL3bOuaSGEYz1S2R8lCKTBMN5SWhJjx3hMTxJKJSvLj8xHnIykm6qrGe8dm03K5XFC2wTkPwLJ4ylaSYuE0nzlfBh4eH4gp0DY1OcX7cy0Nh23HPC/My4LWim7b8e2n7xinidNlIYZMJQ3bdsPNL3gf6BqFVprLOLOtLbdhIpTIEjwSwaaueDh05OLxMdN1PVWlcW6irhqUkgw+ItqKLy+vpFDIxVDigu40whrilGltg8iFQy/ZPez48XhlmRJ1Y9ntDbvGkkLm+HrFe1DWEFXh9XUghMi2a7jcTrjFITEM88DDYcN1uvwURQ0pOIblXnVQEmz7De+/esKPESj87KtH+t7yzfdHSimcLoGSEr//8Tuk0nw6j6gfKr56PHD5KYp+XBbO24kPTx22aTidJ7779AyN5uXq+OWbLU0f0FLS1JJh9gyDw3YbwjwixE+XAlzm0/ELf/8bzaP9j3jf1fzn/+V/kf/Tv/V/RslE1/VoYygsaGnYbx8RKXNdBozR97/3fEMaQ601ZGiqmlQiORd8ECAVKQe6tqOyhkPXU7xnSZHrZaKpO4bbxF9+/5GHhwdcEGxqjZKJZqf4ePWkHBCl5uPngVgUs1tomp6UEzEmvv3yQsoRnyN1XaOk4jIsGGvxPhGCY1kW2rZDqURCkHMhuIC2hiIgp0RKifuMvKCUout65nnCu0AMkaqpUFJSUFRNxXUckEZTKcPx5UilLRpNSp5pdpRKk6RgnALbtkVbzRIGLtcBIxTX20JMIwlN8Ymua6DcP4c/fflM3dSIKCmA1gbKfWO/kBF5QspEnAqPjy1WK7xyVG2mVxpjO8iZbffI8fnKZtdAUZyvcAv3WgjMQtsppIJpDvT9hpBmnL8iEAgRECLTNjXdtma37Rlz4Mvtxq7f8eV2pWkMlzkgbI+pKtCFMHus0ggNFE8SkfPxinQBUHw6jnS9Qszw/n3PL592TH4GBDEKhuW+xb2rFCoVhpJIxaBFAKnwacZWliUlYnBsuoqkMt1Dz+tpYJ4mlnlAZEndVoxjTS6G/UPH5y8ncswEV0hppt/2tH3P99/8HtVV/MnPDoxj4ofPN7KLxCjA3j/zrLV8/HIihkRbmX/2J4DVarVarVar1Wq1Wq1Wq9VqtVqt/oj8wYPxy8UhTSSVQoqOlALkwnMYmXwmR9g+1FSV4eV15MN2i1IghCGUgc12g+LeR66NwFYNKWaCz+ScMRach8kFYhRsNzXkgDKw2e243RakGGj6hmVOCFv4/GXEikL/ob7/npxozIacR443xzQnKr1FKYUUgb5RSFUQWSKVgpRIUjMtnkJCyHu/tjYSRMZHhSj3vupxiLRtg6oFMc9UVUVT3SPCiweRFB9vnm8+32g3HYQbT23L5+lGXSk0998dQqK1kl2jcVEyXQceH/aoHIk+40Pg5BPzmPEZuiZCivfBXNXgZ4+QgtfXM1K3DPPEIWgeHitO44ltYzHCMg4jtTbEUBDCM4WInxNPhwohDL//9hMfPjxiZUJXNdYazrcrX++2tMKw6TTHy8yubwklUVKiUpbHzZaurjmON358uRLJJAHTNJGT5/HhgFIFHzTWKJQqpFLQxqCtIIWESIXkA5nM5TZg9H3gE1Ik5sTlfMX7SFVLCgLvPV3bcTlfyTkjhKBpWrS5DwTnacRay5fnV0K4bxSXdP93VSV4+9AzTjdCTPdBvkhMy8jtVkiLRyp77/h92NNXFYXCsMxsth1CSbZdy3S7UdmK08kxzB6UQSmLFIVto3ExEHzCp8TsPDkWrBZ0jcVUNcfzzOXskfuWXV+T5oXX84ybIyVDJxVGKrJ3LDFzHhwuZESloRZEL6lrxbwM+BCZnefh0FEQLEESXKRuaozKbKoNQgqUAVFLigrUQhN05nUOjHOgNhaBR6mKflexe+hJMfGw7bjcJjZdzevpmUtOjMcRFQ3jYnmzq7C1IqYF07SgApKG23VkuExsdw0f3j5yuVwpApquoaoUH58nlBREmUkF/qPff+bd/h277s95++5f5b/x3/7vMP9P/8f89s8/MYWM1Jp5GEjlTLY1EsEyT5RUEMKSYiGWgEDw7qHjcruSSiHnTCkFiaAEj9k0vAyvyHyP5d9uGoSEh4cN4xQYF4e1kkLg8WHD9TaRosLWimn0PD18hYsL8QjX20BbW5qqBqFZlnj/HEwCozWdtSgDWm/43e8/oYyiblpiCETvcItju91xG2/kfO8Dr6oKkwuZjJSSnBObfoMSimWZCS4ia8tlmCgxsATPu7dviM6hpWR2CyJMtJue3m6Zbzdst6G2klIkw3zjsN1im5rpdmVxiarpoGRizNzGEe0FOSWe3j4R/MLkHCmCbDXzvCAE1EpTVZZ371rkDzNWKUoU1JVBa8VmV1NXHSku6FLzuBf3Lw6peP7yme1mx3mYUG1H21mOryM5TXT9nuASddOhgqe2LU1reHqz59PnE4sfkTYzj5Ekrvz66z235YpPicpIYgg/fSZInPdYbUipsORIYzuWAK8vR2IRKJ0wSvPD91e2jUGlgtAGkmK/26LTwnCbWYJCVwJpC8skuA6RhMWnCEWxjB43zrRtRYgXvAcpNcEnbK2wteV2G/HO0fYGYySL90gtaFqLkpnX1xfqrrknZ4wOpRXTOFPZCrUVbMWBGE+EkCil8OV44bBt/1oOAavVarVarVar1Wq1Wq1Wq9VqtVr9sfiDB+MLGRELMWtyWjAyUYTjNDqQGlM1QLp37mrF+eQ5Pc/0neDpseZ8dvRNRVNrrHGM40xTt9RVRUGyLBMFQxERrSVVXaFy4rDdo6uFcRxRynCbZuY5scQrkpam3+BioNb36OFSEvMVbktk27WEHLheZrbVlr/xoSIKz+++/ULVtKRww9QCYxtyighVQChIPaVkrEhIC64kTtcBCrRS34dOKaONAe+ZL1d01THOE26Eh71FVT3jGDCN5tPHF756t6VrLTlqnMt4HD45bL1js91xuo6cxxmKoiR4mWag4mFryKqglcTWhkZrPp8uyKrhept4uY58uS5sjoZlcXQbw7IsbHpLpTQ+gjUZhkxbdTSN4dPzwBILwxjxbkRgCSJyXiKnv/odYHhwO6a5UJkFYSTffP8dbdvzeh0pKVPVhuQjRcLDh/fsmorkPUUpKquY5htVpckpsLjMtCx471BCIEpB5EBtLQ/7jq6tOV4uTD4glCSGjDEV8zQj5UJlLALJ7AJKSrSSxJQ4n68YLdhtNjRNg1Izl8uZ7XbD7TqhjWa7bVgWxzBEUpaYWuFLYvAFGzJv3u24XReSbCFkYl5AKoxQTLeJ7a7n5XSksg3ffXxluM3sDnteT0c2m555PDEvGuc8QmmW4KhsTWsrquZeBH++TYhsOWw2ZBWY58yuhcpUeK/Z7lusTmh1f7wQgqY1bLRB6PtQ7XJeOF4TuXgqY/nFh59xupwRyqA1GKsYxytt26OTwgdYXORpV7GpBC9Xx+fXG16CKVBVha2p2e/2GC0RQvLFXzFKYQw4FxlH2HcVdl/x/fMJNQb+/HefqG3P8fRC1Wv+7t/8Bd/8/geKrjn0HVIrbsOIVAYtNcP5itXwdNizuEwtJI9vDwy3mX/nn3zhSUiK/7/xN+2/wX//v/c/4t/+9/53/K/+1/9bzq9n+t2Geblv0F4vZ1D3CH6lNEpoyJlC4fuPn1BGY60C4j1efva45R61/rDZoEomkFFaISmYXqHLTCwFpRXjNEJoGaYFnzNvuo591/LleKbveuKmpZDo25oUAtN0g7qlamoQGakVUgn6znK8zNhKUzU1Pnoo9zSDVDKX64UCKKUopQDQNDXn8xllNClGpmGkpMKyLDw8PrJ4x82NbLqWmCLX4cKu7/nuh49s9lsqWxGTJ5LRsiYER2MkSgW6xtK3lmGemUZHVzfEEpiHCWtrlAQpCqYyFJlRVpHGiLYtbdvivGMYRky/QVLx3W8n3uxrkk9M88C236OlIiwBERZiXBAFCoJC4XiZqNt7nLkCmq4izB4pFW8f3nObZkLwlGwwRlG3knFy/Pavvmd/2DKMFW8edrx70vz+85HyC4sxim2b+dX+wD/+7gfIhRAztW1QShEzGAlvnzZcrxf6bUsIHq1rlICQBX/53Zm/+esnkhdkFl5+mNk0D5yXZ5S11ElhZCEWwTA5kjSEGKibCrd4unZzj9lXgbYzOLegrCLEiBQKU1uE0Hz+8kzbbLGNxXvPsiz03ROn64hSCiUEr58d7bZCKcs0R6yxzMOJSgmU1Cyx4GIkyXVjfLVarVar1Wq1Wq1Wq9VqtVqtVqv/JP7wKHWTWJaE0YZY9E+DD4VUhpAydV0ITmNbSdNqPp1O2KrmcdtSIbEmEFNEEaksaFWx6TUuBIyzpOyJQdLUGzZ9y6Zr8cvAcXhGDhWLM8xLRJj7AKeq9miTOd3OtLaj6RUiF0pRfL7e2GwsCU/O3AclSiBLAOFoG8M8LRwetlAybWdRwJeXE/22wXQjWmlCzqTi8LfM24cNxii01WAs8+R5uR2ZR8HlNvKzDw1bpXhdBLpIRud5PY8IXTAIdm0HRfB8vjJ5x5/9yc/oNpGPnxxNpXBjoKoKPkQaI1CHHbNb6NvEzWVShnGcka1FmopxeKHrOqq+pdUNkhm1t+QEyzUA9yG/SxNfvX9H103IAqEEljBhW8kwjWzbhiIUl+uVWipy23G+Djzfruy6HbMffxqWSlJySCmZpoHFCZaYscbwu2+/x0rB02HH6/HMsERCCZAySkiK1Ail7v28VjPPE4VC1+5IzqG3NW/fPPB8PHMb3b27PWaUVEiriSkSQsRa+083bUspCEAIQQgBUsEaSdNorpcLSlvaqqFu7nHaXR3om4qqrZl84MuXEzkLUvFstxVxESzJo7UiF8HiHH3XMi+O4Tax2MRu0/HwdCDlTEoJt0xYC1NKFH2/U6GsRAmIJSKjQitJ8BGEpG0tQ5hYQmbbNWSX6TcVKsNvP554t98TXKTrKx4eHhhGhyiFZfIYqzASjN1RYiElsEZTpKRtNU1t0XSIollcoK0q5qVgq4qYHW0lefu4wyeHoeJydhx2DZTIdQh0TY30kg+Pe4Zp5nUINKbgS+E2nTEkhNQcryPTcqKpK566LcPV45eI6RTXaYBF4X2itjW20uS8MA2BetejBYw5Qk5UVpMmyf/l9ydqO1L+3f8Fb7/71/iX/86/wp/+d/85/t1/+9/iP/wP/gF/8WUkSk29qSGL///WfxEIqRA/dXHXbYt3HmvNvVebgtSG1/MZLaBWElEZnp+P7Pc7xtOIKIKqrTFGkVPhNkamKUDOXK4zIWfIihQLxmS2fc3iMlobTAv9ZoPSgkoroktczgNd01BipjYGbSTDbWa7ackpEFPC2grnf3qd/fQ6WpYFay1NU3G7DYgiiNHTtQ3TNCKUQmvN4tz9Pa81r6+vNF2HUYZxntFSoKxhLo7x4niz3VDXFRtRcR0mjq9Hmq5h07d89+kzRiqELOSUmecFYw2X2422qUg54caREALWWmStqNuG8/WM955dSfTbhnlssbWgqQXXS2DzYPj08oWmLWgJn5/P2K6l7iq+HEeEgG3f49KNnW1ZJg+psNn2RA+VVVijScHz9Linsj0pCf7hP/qGLCxpHvHOszEtj29bXl6f0VIy+gmtLFICJIQobOuKh37DsowUASYYnMtkkZBCYlSFj4Eff3fiq9+8w0jHLV9wMdBojTAtn398AStJWXEbZoRIuGWkbXtyykCGWKgsYGpiEcyz5/XlzG7T0LQ9wTcIDKTEODqkkHj3TAoBW1uaRhDcwvyyoCpJ1VjiklBaQkmIJMhFIlXF588vfy2HgNVqtVqtVqvVarVarVar1Wq1Wq3+WPzBg/GSBGHJLGWgqjUZiQuBlDMlBYRqsbZQUqKpa5QyXM8j28Yy3DJVpyEWbpeFum7x/t7VHZ3Haku/7Xn5dCWq+0bn6XiiqTTXKfD6fKOpCrvDjufnkZAd1jSEmGnaDVVlKUkg0SQ0uZIctgeyvvK7TxOV1BzHhb2UFKFYciQVxXCbyAUo0NUVMYDWDU1V07QWH2ZO40CD4XyZGY3mve3Y15IwZZ4Oj5zFgFY9tbKcblBXCakKMmcetg0uBoQIXMeFGAOX8ULbbmltz+X0Ago+fnrFzzO2rpEyg0hcTxOm7XnaPNL3C7/9+IVN/wZhKlQMvHvzhqbvKQk2Xc/HT78jOaj6miBeaXQHJISU/O73rxweO4bLGe8Vm63BtA1h8sxzJueZcQqU7MgSetWTZcHoxOni6OSGQsU4zSilsN0GYwRpmMg54ZxnCRGtDXPwjNMAWmJ1jZIVRRRiDjTWULcVLjhCSrwcj/zi/XteXkYQgpwlJUKKmRQzdVezLBMUqOuaJSS22w3TcCbE+/a40oZhGPjZh6+ZxjPv3x348jwyzQtVZblcR07nzIevDmzqiuDvse6X+oYWip8/vcdNE8eyEM4LWup7pHUqjM4hXaGqGgSCEgI+KkIJWKsZhxtt1XObrzRVw7IEfMpU1pBiwalEpRVNUzElmH3gcpxQRlPPktdx4av9FkTk52/3HG+O6BVbZfju+29oN0/cjmeaTU9w9y1bKTVJ3SsGampQ99d+Y2p2XUVYPDHA6+lMv21ZRsccPaqpWcaZusqUEhlTQgSNC57HTcdxGBi8RIwD795seT0OCKGoTY2RDYkZKaGqN2Q1U7Lk+fOZcUoUITl+fEZqi1GZZtNAFCxjJKoaXwJqySgyTV2TimRyC0kKnp3k//6toOd7bsf/Dd/9k0eevv7b/Gv/6n+Nn/3p3+J/+T//N/l0XIg+YYxGak2MESs1WiiU1mwOLZ8+viDRjIO7v/+swpTMh6/fkbyj7WqmxWMK/PjjC7lEqrri9WXkqzeP9L2mqTJ6qahNJmfBx89X3hw65mnk8NAgb57bbSGVzNPDA25JLPOMN/fEgJwyX65XDtsNo4sUIei7jhQTSlW0nWGeJozVSCX/6ca4ECCl5Hg80jQNy7xgtQEKSsr7RYwY0Vr9f9u1m9y2zSgKw+cjRevHkmW7TtF0//vpoOOiQAKkgZvaki2JkiiSHbU7CAqoz7OCM7zAe1PGIevbu5TU2R1POe1PGUtJVde5qZt8O7/nfr3ObDrL267Nly9tHn5YZDpd5HS+5Pn5OaWMWS6X2e72qeuSx4en7A67DGOVtj2naaZppk2Gvk9JlZumzqFtU5Uhk+mQ102XDPNU9Zhj2+XSDjkchqQ65K+Xc5rjW4a+z/a1y2Q/ZjlPdvu3fPzxYzab1ww3VSaXLqt50szn+ePP/b8PDduXbVbL+7y9fE1V+tzO7rKYz1NKnW/bLr/8+ikfVovcPqwyvA/p+i792Ge5uMlx/57Vcpbd/pB+dp/Pn18yu1+kVMecupJh0qWuqzys1mmaOqU9Zjq7yW+/f83P61WelvN82h3S9UOapuTxp2leNqdUk5LZrMntYpnz5Zzt9j1P63nu1svUKZlNJ3l9a3PouzytHtJu3/Phw12SJlVZZ7xcUo0lVZLHp8dsN5uUJjl2bS5dlf7Sp0uf+lilLkNO3SWzxW2G/pLu0qcbq0zqklIN3+MGAAAAAACA/40y/lNnAAAAAAAAAOAKVf/1AAAAAAAAAAD4noRxAAAAAAAAAK6aMA4AAAAAAADAVRPGAQAAAAAAALhqwjgAAAAAAAAAV00YBwAAAAAAAOCqCeMAAAAAAAAAXDVhHAAAAAAAAICrJowDAAAAAAAAcNX+Bm864Me0xSKCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ref_sample = Sample(\n", + " image_path=str(IMG2),\n", + " bboxes=np.array([IMG2_BOX_COORDS]),\n", + " categories=[\"elephant\"],\n", + " category_ids=[0],\n", + ")\n", + "ve_target = Sample(image_path=str(IMG3))\n", + "\n", + "ve_results = {}\n", + "ve_latencies = {}\n", + "for name, variant in VARIANTS.items():\n", + " print(f\"Loading {name} in VISUAL_EXEMPLAR mode...\")\n", + " model_ve = SAM3OpenVINO(\n", + " variant=variant,\n", + " prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR,\n", + " device=DEVICE,\n", + " )\n", + " model_ve.fit(ref_sample)\n", + " pred = model_ve.predict(ve_target)\n", + " latency = measure_latency(model_ve, ve_target, n=5)\n", + " ve_results[name] = pred[0]\n", + " ve_latencies[name] = latency\n", + " print(f\" {name}: {len(pred[0]['pred_masks'])} detections, {latency:.1f} ms\")\n", + " del model_ve\n", + "\n", + "# IoU vs FP16\n", + "baseline_masks = ve_results[\"FP16\"][\"pred_masks\"]\n", + "print(\"\\nMask IoU vs FP16 baseline (visual exemplar):\")\n", + "ve_ious = {}\n", + "for name, pred in ve_results.items():\n", + " if name == \"FP16\":\n", + " ve_ious[name] = 1.0\n", + " continue\n", + " if len(baseline_masks) > 0 and len(pred[\"pred_masks\"]) > 0:\n", + " base_union = baseline_masks.sum(dim=0).clamp(max=1)\n", + " pred_union = pred[\"pred_masks\"].sum(dim=0).clamp(max=1)\n", + " iou = compute_mask_iou(base_union, pred_union)\n", + " else:\n", + " iou = 0.0\n", + " ve_ious[name] = iou\n", + " print(f\" {name}: IoU = {iou:.4f}\")\n", + "\n", + "# Visualization\n", + "fig, axes = plt.subplots(1, len(VARIANTS) + 1, figsize=(5 * (len(VARIANTS) + 1), 5))\n", + "# Reference image\n", + "ref_img = cv2.imread(str(IMG2))\n", + "ref_img = cv2.cvtColor(ref_img, cv2.COLOR_BGR2RGB)\n", + "axes[0].imshow(ref_img)\n", + "axes[0].set_title(\"Reference\\n(fit image + box)\")\n", + "axes[0].axis(\"off\")\n", + "# Add box overlay on reference\n", + "x1, y1, x2, y2 = IMG2_BOX_COORDS\n", + "import matplotlib.patches as patches\n", + "rect = patches.Rectangle((x1, y1), x2 - x1, y2 - y1, linewidth=2, edgecolor=\"lime\", facecolor=\"none\")\n", + "axes[0].add_patch(rect)\n", + "\n", + "for ax, (name, pred) in zip(axes[1:], ve_results.items()):\n", + " vis = overlay_masks(IMG3, pred[\"pred_masks\"])\n", + " ax.imshow(vis)\n", + " iou_str = f\"IoU={ve_ious[name]:.3f}\" if name != \"FP16\" else \"baseline\"\n", + " ax.set_title(f\"{name}\\n{len(pred['pred_masks'])} det, {ve_latencies[name]:.0f} ms\\n{iou_str}\")\n", + " ax.axis(\"off\")\n", + "fig.suptitle(\"Visual Exemplar: fit on IMG2, predict on IMG3\", fontsize=14, fontweight=\"bold\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "library (3.13.5)", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/library/pyproject.toml b/library/pyproject.toml index 09b425d05..08f4d0e84 100644 --- a/library/pyproject.toml +++ b/library/pyproject.toml @@ -47,6 +47,9 @@ dependencies = [ # ONNXScript is used for authoring and transforming ONNX graphs in # Instant Learn's ONNX-based model export and optimization utilities. "onnxscript>=0.6.0", + # huggingface_hub is required for auto-downloading pre-exported SAM3 + # OpenVINO models from HuggingFace Hub. + "huggingface_hub>=0.25.0", ] [dependency-groups] @@ -84,6 +87,9 @@ notebook = [ "jupyter==1.1.1", "ipykernel==6.30.1", ] +quantize = [ + "nncf>=2.14.0", +] demo = [ "gradio>=4.0", ] @@ -104,7 +110,7 @@ docs = [ ] full = [ - "instantlearn[dev, notebook]", + "instantlearn[dev, notebook, quantize, demo]", ] [project.scripts] @@ -240,6 +246,12 @@ notice-rgx = '# Copyright \(C\) (\d{4}(-\d{4})?) Intel Corporation\r?\n# SPDX-Li "PLR6301", # Ignore no-self-use for test methods "S101", # Use of assert detected ] +"scripts/**/*.py" = [ + "INP001", # Scripts are standalone, not packages +] +"examples/**/*.py" = [ + "INP001", # Examples are standalone, not packages +] # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # diff --git a/library/src/instantlearn/models/__init__.py b/library/src/instantlearn/models/__init__.py index 9c641ad29..184ead565 100644 --- a/library/src/instantlearn/models/__init__.py +++ b/library/src/instantlearn/models/__init__.py @@ -13,7 +13,7 @@ from .grounded_sam import GroundedSAM from .matcher import Matcher from .per_dino import PerDino -from .sam3 import SAM3, Sam3PromptMode +from .sam3 import SAM3, SAM3OpenVINO, SAM3OVVariant, Sam3PromptMode from .soft_matcher import SoftMatcher __all__ = [ @@ -24,6 +24,8 @@ "Matcher", "Model", "PerDino", + "SAM3OVVariant", + "SAM3OpenVINO", "Sam3PromptMode", "SoftMatcher", ] diff --git a/library/src/instantlearn/models/sam3/__init__.py b/library/src/instantlearn/models/sam3/__init__.py index 4288f8b09..4ea5b3515 100644 --- a/library/src/instantlearn/models/sam3/__init__.py +++ b/library/src/instantlearn/models/sam3/__init__.py @@ -11,10 +11,13 @@ from .post_processing import PostProcessingConfig from .processing import Sam3Postprocessor, Sam3Preprocessor, Sam3PromptPreprocessor from .sam3 import SAM3, Sam3PromptMode +from .sam3_openvino import SAM3OpenVINO, SAM3OVVariant __all__ = [ "SAM3", "PostProcessingConfig", + "SAM3OVVariant", + "SAM3OpenVINO", "Sam3Model", "Sam3Postprocessor", "Sam3Preprocessor", diff --git a/library/src/instantlearn/models/sam3/export_openvino.py b/library/src/instantlearn/models/sam3/export_openvino.py new file mode 100644 index 000000000..44ddd40b8 --- /dev/null +++ b/library/src/instantlearn/models/sam3/export_openvino.py @@ -0,0 +1,586 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""ONNX export wrappers for SAM3 sub-components. + +Each wrapper class isolates a portion of ``Sam3Model`` into a standalone +``nn.Module`` with a clean ``forward()`` signature that can be exported +with ``torch.onnx.export()``. + +The 5-model split is designed for maximum flexibility: + +1. **Vision encoder** — ViT backbone + FPN neck. +2. **Text encoder** — CLIP text encoder + linear projection. +3. **Geometry encoder** — Encodes box/point prompts with vision-conditioned + transformer layers. Two export variants are produced (``drop_spatial_bias`` + traced as ``True`` or ``False``). +4. **Prompt decoder** — DETR encoder + decoder + box refinement + dot-product + scoring + mask decoder. Accepts *pre-concatenated* prompt features (text + ± geometry) so that the ONNX graph contains no conditional logic. + +Text and geometry feature concatenation is performed in Python at inference time +(inside ``SAM3OpenVINO``), enabling both *classic* and *visual-exemplar* modes. +""" + +from __future__ import annotations + +import logging +from pathlib import Path +from typing import TYPE_CHECKING + +import torch +from torch import nn + +if TYPE_CHECKING: + from .model import Sam3Model + +logger = logging.getLogger(__name__) + +# --------------------------------------------------------------------------- +# 1. Vision encoder wrapper +# --------------------------------------------------------------------------- + + +class OnnxVisionEncoder(nn.Module): + """ONNX-exportable wrapper around the SAM3 vision encoder. + + Outputs only the first 3 FPN feature maps (scales 4x, 2x, 1x) and the + position encoding at the 1x level. The 0.5x level is dropped -- it is only + used by the DETR encoder which receives ``fpn_feat_2`` directly. + + Inputs: + pixel_values: ``[B, 3, 1008, 1008]`` + + Outputs (named): + fpn_feat_0: ``[B, 256, 288, 288]`` (4x scale) + fpn_feat_1: ``[B, 256, 144, 144]`` (2x scale) + fpn_feat_2: ``[B, 256, 72, 72]`` (1x scale) + fpn_pos_2: ``[B, 256, 72, 72]`` (position encoding at 1x scale) + """ + + def __init__(self, model: Sam3Model) -> None: + """Store reference to the SAM3 vision encoder.""" + super().__init__() + self.vision_encoder = model.vision_encoder + + def forward(self, pixel_values: torch.Tensor) -> tuple[torch.Tensor, ...]: + """Run vision encoder and return FPN outputs. + + Args: + pixel_values: Input image ``[B, 3, H, W]``. + + Returns: + Tuple of ``(fpn_feat_0, fpn_feat_1, fpn_feat_2, fpn_pos_2)``. + """ + vision_outputs = self.vision_encoder(pixel_values) + fpn_hidden = vision_outputs["fpn_hidden_states"] + fpn_pos = vision_outputs["fpn_position_encoding"] + # Drop last FPN level (0.5x scale) -- used only inside model.forward() + # via fpn_hidden_states[:-1], fpn_position_encoding[:-1] + return fpn_hidden[0], fpn_hidden[1], fpn_hidden[2], fpn_pos[2] + + +# --------------------------------------------------------------------------- +# 2. Text encoder wrapper +# --------------------------------------------------------------------------- + + +class OnnxTextEncoder(nn.Module): + """ONNX-exportable wrapper around the CLIP text encoder + projection. + + Inputs: + input_ids: ``[B, 32]`` int64 + attention_mask: ``[B, 32]`` int64 + + Outputs (named): + text_features: ``[B, 32, 256]`` float32 + text_mask: ``[B, 32]`` bool + """ + + def __init__(self, model: Sam3Model) -> None: + """Store references to the CLIP text encoder and projection.""" + super().__init__() + self.text_encoder = model.text_encoder + self.text_projection = model.text_projection + + def forward( + self, + input_ids: torch.Tensor, + attention_mask: torch.Tensor, + ) -> tuple[torch.Tensor, torch.Tensor]: + """Encode text tokens into projected features. + + Args: + input_ids: Token IDs ``[B, seq_len]``. + attention_mask: Attention mask ``[B, seq_len]``. + + Returns: + Tuple of ``(text_features, text_mask)``. + """ + text_outputs = self.text_encoder( + input_ids=input_ids, + attention_mask=attention_mask, + return_dict=True, + ) + text_features = self.text_projection(text_outputs.last_hidden_state) + text_mask = attention_mask.bool() + return text_features, text_mask + + +# --------------------------------------------------------------------------- +# 3. Geometry encoder wrapper +# --------------------------------------------------------------------------- + + +class OnnxGeometryEncoder(nn.Module): + """ONNX-exportable wrapper around the SAM3 geometry encoder. + + Accepts box and/or point prompts together with the 1x FPN features, runs + the geometry encoder transformer, and returns encoded prompt features. + + Because ONNX doesn't support Python-level if/else branching across + ``drop_spatial_bias``, two separate ONNX files are exported: + + * ``geometry-encoder.onnx`` (``drop_spatial_bias=False``) — classic mode + * ``geometry-encoder-exemplar.onnx`` (``drop_spatial_bias=True``) — exemplar fit + + Inputs: + fpn_feat_2: ``[B, 256, 72, 72]`` + fpn_pos_2: ``[B, 256, 72, 72]`` + input_boxes: ``[B, N, 4]`` cxcywh normalised (or all-zero) + input_boxes_labels: ``[B, N]`` int64 (1=pos, 0=neg, -10=ignore) + input_points: ``[B, M, 2]`` xy normalised (or all-zero) + input_points_labels: ``[B, M]`` int64 (1=pos, 0=neg, -10=ignore) + + Outputs (named): + geometry_features: ``[B, K, 256]`` + geometry_mask: ``[B, K]`` bool + """ + + def __init__(self, model: Sam3Model, *, drop_spatial_bias: bool = False) -> None: + """Store geometry encoder and spatial bias flag.""" + super().__init__() + self.geometry_encoder = model.geometry_encoder + self.drop_spatial_bias = drop_spatial_bias + + def forward( + self, + fpn_feat_2: torch.Tensor, + fpn_pos_2: torch.Tensor, + input_boxes: torch.Tensor, + input_boxes_labels: torch.Tensor, + input_points: torch.Tensor, + input_points_labels: torch.Tensor, + ) -> tuple[torch.Tensor, torch.Tensor]: + """Encode geometric prompts. + + Args: + fpn_feat_2: Vision features at 1x scale ``[B, 256, 72, 72]``. + fpn_pos_2: Position encoding at 1x scale ``[B, 256, 72, 72]``. + input_boxes: Box coordinates in cxcywh normalised ``[B, N, 4]``. + input_boxes_labels: Box labels ``[B, N]`` (1=pos, 0=neg, -10=ignore). + input_points: Point coordinates in normalised xy ``[B, M, 2]``. + input_points_labels: Point labels ``[B, M]`` (1=pos, 0=neg, -10=ignore). + + Returns: + Tuple of ``(geometry_features, geometry_mask)``. + """ + img_feats = (fpn_feat_2,) + img_pos_embeds = (fpn_pos_2,) + + # Always compute masks and labels from the label tensors. + # Invalid entries (label == -10) get mask=False, which the geometry + # encoder's attention mechanism uses to ignore them. + # This avoids data-dependent branching that torch.export cannot handle. + box_mask = input_boxes_labels != -10 + box_labels = torch.where(input_boxes_labels == -10, 0, input_boxes_labels) + box_embeddings = input_boxes.to(dtype=fpn_feat_2.dtype) + + point_mask = input_points_labels != -10 + point_labels = torch.where(input_points_labels == -10, 0, input_points_labels) + point_embeddings = input_points.to(dtype=fpn_feat_2.dtype) + + geometry_outputs = self.geometry_encoder( + box_embeddings=box_embeddings, + box_mask=box_mask, + box_labels=box_labels, + point_embeddings=point_embeddings, + point_mask=point_mask, + point_labels=point_labels, + img_feats=img_feats, + img_pos_embeds=img_pos_embeds, + drop_spatial_bias=self.drop_spatial_bias, + ) + + return ( + geometry_outputs["last_hidden_state"], + geometry_outputs["attention_mask"], + ) + + +# --------------------------------------------------------------------------- +# 4. Prompt decoder wrapper (DETR encoder + decoder + scoring + mask decoder) +# --------------------------------------------------------------------------- + + +class OnnxPromptDecoder(nn.Module): + """ONNX-exportable wrapper for the DETR pipeline + mask decoder. + + Accepts pre-concatenated prompt features (text alone, or text + geometry) + and FPN features, runs the DETR encoder/decoder, box refinement, scoring, + and mask decoder. + + Inputs: + fpn_feat_0: ``[B, 256, 288, 288]`` + fpn_feat_1: ``[B, 256, 144, 144]`` + fpn_feat_2: ``[B, 256, 72, 72]`` + fpn_pos_2: ``[B, 256, 72, 72]`` + prompt_features: ``[B, T, 256]`` (T = text tokens ± geometry tokens) + prompt_mask: ``[B, T]`` bool + + Outputs (named): + pred_masks: ``[B, 200, H_mask, W_mask]`` + pred_boxes: ``[B, 200, 4]`` xyxy normalised + pred_logits: ``[B, 200]`` + presence_logits: ``[B, 1]`` + """ + + def __init__(self, model: Sam3Model) -> None: + """Store references to DETR encoder, decoder, mask decoder, and scoring.""" + super().__init__() + self.detr_encoder = model.detr_encoder + self.detr_decoder = model.detr_decoder + self.mask_decoder = model.mask_decoder + self.dot_product_scoring = model.dot_product_scoring + + def forward( + self, + fpn_feat_0: torch.Tensor, + fpn_feat_1: torch.Tensor, + fpn_feat_2: torch.Tensor, + fpn_pos_2: torch.Tensor, + prompt_features: torch.Tensor, + prompt_mask: torch.Tensor, + ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """Run DETR pipeline and mask decoder. + + Args: + fpn_feat_0: FPN features at 4x scale. + fpn_feat_1: FPN features at 2x scale. + fpn_feat_2: FPN features at 1x scale. + fpn_pos_2: Position encoding at 1x scale. + prompt_features: Pre-concatenated prompt features ``[B, T, 256]``. + prompt_mask: Prompt attention mask ``[B, T]``. + + Returns: + Tuple of ``(pred_masks, pred_boxes, pred_logits, presence_logits)``. + """ + from .common import box_cxcywh_to_xyxy, inverse_sigmoid # noqa: PLC0415 + + # DETR encoder -- uses only the 1x scale as the vision "level" + encoder_outputs = self.detr_encoder( + vision_features=[fpn_feat_2], + text_features=prompt_features, + vision_pos_embeds=[fpn_pos_2], + text_mask=prompt_mask, + ) + + # DETR decoder + decoder_outputs = self.detr_decoder( + vision_features=encoder_outputs["last_hidden_state"], + text_features=encoder_outputs["text_features"], + vision_pos_encoding=encoder_outputs["pos_embeds_flattened"], + text_mask=prompt_mask, + spatial_shapes=encoder_outputs["spatial_shapes"], + ) + + # Box refinement (last layer) + all_box_offsets = self.detr_decoder.box_head( + decoder_outputs["intermediate_hidden_states"], + ) + reference_boxes_inv_sig = inverse_sigmoid(decoder_outputs["reference_boxes"]) + all_pred_boxes_cxcywh = (reference_boxes_inv_sig + all_box_offsets).sigmoid() + all_pred_boxes = box_cxcywh_to_xyxy(all_pred_boxes_cxcywh) + + # Dot-product scoring + all_pred_logits = self.dot_product_scoring( + decoder_hidden_states=decoder_outputs["intermediate_hidden_states"], + text_features=encoder_outputs["text_features"], + text_mask=prompt_mask, + ).squeeze(-1) + + pred_logits = all_pred_logits[-1] + pred_boxes = all_pred_boxes[-1] + decoder_hidden_states = decoder_outputs["intermediate_hidden_states"][-1] + presence_logits = decoder_outputs["presence_logits"][-1] + + # Mask decoder + fpn_hidden_states = [fpn_feat_0, fpn_feat_1, fpn_feat_2] + mask_outputs = self.mask_decoder( + decoder_queries=decoder_hidden_states, + backbone_features=fpn_hidden_states, + encoder_hidden_states=encoder_outputs["last_hidden_state"], + prompt_features=prompt_features, + prompt_mask=prompt_mask, + ) + + return ( + mask_outputs["pred_masks"], + pred_boxes, + pred_logits, + presence_logits, + ) + + +# --------------------------------------------------------------------------- +# Export helpers +# --------------------------------------------------------------------------- + +_VISION_ENCODER_NAME = "vision-encoder" +_TEXT_ENCODER_NAME = "text-encoder" +_GEOMETRY_ENCODER_NAME = "geometry-encoder" +_GEOMETRY_ENCODER_EXEMPLAR_NAME = "geometry-encoder-exemplar" +_PROMPT_DECODER_NAME = "prompt-decoder" + + +def export_sam3_to_onnx( # noqa: PLR0915 + model: Sam3Model, + output_dir: str | Path, + *, + resolution: int = 1008, + opset_version: int = 17, +) -> dict[str, Path]: + """Export all SAM3 sub-components to ONNX. + + Produces 5 ONNX files in *output_dir*: + + * ``vision-encoder.onnx`` + * ``text-encoder.onnx`` + * ``geometry-encoder.onnx`` (classic mode, ``drop_spatial_bias=False``) + * ``geometry-encoder-exemplar.onnx`` (exemplar fit, ``drop_spatial_bias=True``) + * ``prompt-decoder.onnx`` + + Args: + model: A loaded ``Sam3Model`` instance (on CPU, eval mode). + output_dir: Directory to write the ONNX files into. + resolution: Input image resolution (default ``1008``). + opset_version: ONNX opset version (default ``17``). + + Returns: + Mapping from model name to the written ONNX path. + """ + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + + model.eval() + device = next(model.parameters()).device + + exported: dict[str, Path] = {} + + # --- 1. Vision encoder --- + logger.info("Exporting vision encoder...") + vision_wrapper = OnnxVisionEncoder(model) + vision_wrapper.eval() + dummy_pixel = torch.randn(1, 3, resolution, resolution, device=device) + vision_path = output_dir / f"{_VISION_ENCODER_NAME}.onnx" + torch.onnx.export( + vision_wrapper, + (dummy_pixel,), + str(vision_path), + opset_version=opset_version, + dynamo=False, + input_names=["pixel_values"], + output_names=["fpn_feat_0", "fpn_feat_1", "fpn_feat_2", "fpn_pos_2"], + dynamic_axes={"pixel_values": {0: "batch"}}, + ) + exported[_VISION_ENCODER_NAME] = vision_path + logger.info(" -> %s", vision_path) + + # --- 2. Text encoder --- + logger.info("Exporting text encoder...") + text_wrapper = OnnxTextEncoder(model) + text_wrapper.eval() + dummy_ids = torch.ones(1, 32, dtype=torch.long, device=device) + dummy_mask = torch.ones(1, 32, dtype=torch.long, device=device) + text_path = output_dir / f"{_TEXT_ENCODER_NAME}.onnx" + torch.onnx.export( + text_wrapper, + (dummy_ids, dummy_mask), + str(text_path), + opset_version=opset_version, + dynamo=False, + input_names=["input_ids", "attention_mask"], + output_names=["text_features", "text_mask"], + dynamic_axes={ + "input_ids": {0: "batch"}, + "attention_mask": {0: "batch"}, + }, + ) + exported[_TEXT_ENCODER_NAME] = text_path + logger.info(" -> %s", text_path) + + # --- 3. Geometry encoder (classic) --- + logger.info("Exporting geometry encoder (classic)...") + geo_wrapper = OnnxGeometryEncoder(model, drop_spatial_bias=False) + geo_wrapper.eval() + # Compute FPN feature sizes from resolution + # At 1x FPN scale: resolution / patch_size(14) = 72 (for 1008) + feat_size = resolution // 14 + dummy_fpn = torch.randn(1, 256, feat_size, feat_size, device=device) + dummy_pos = torch.randn(1, 256, feat_size, feat_size, device=device) + dummy_boxes = torch.rand(1, 1, 4, device=device) + dummy_box_labels = torch.ones(1, 1, dtype=torch.long, device=device) + dummy_points = torch.rand(1, 1, 2, device=device) + dummy_point_labels = torch.full((1, 1), -10, dtype=torch.long, device=device) + + geo_path = output_dir / f"{_GEOMETRY_ENCODER_NAME}.onnx" + torch.onnx.export( + geo_wrapper, + (dummy_fpn, dummy_pos, dummy_boxes, dummy_box_labels, dummy_points, dummy_point_labels), + str(geo_path), + opset_version=opset_version, + dynamo=False, + input_names=[ + "fpn_feat_2", + "fpn_pos_2", + "input_boxes", + "input_boxes_labels", + "input_points", + "input_points_labels", + ], + output_names=["geometry_features", "geometry_mask"], + dynamic_axes={ + "input_boxes": {0: "batch", 1: "num_boxes"}, + "input_boxes_labels": {0: "batch", 1: "num_boxes"}, + "input_points": {0: "batch", 1: "num_points"}, + "input_points_labels": {0: "batch", 1: "num_points"}, + }, + ) + exported[_GEOMETRY_ENCODER_NAME] = geo_path + logger.info(" -> %s", geo_path) + + # --- 4. Geometry encoder (exemplar — drop_spatial_bias=True) --- + logger.info("Exporting geometry encoder (exemplar)...") + geo_exemplar_wrapper = OnnxGeometryEncoder(model, drop_spatial_bias=True) + geo_exemplar_wrapper.eval() + # Exemplar mode uses points only (boxes converted to center points) + dummy_boxes_ignore = torch.zeros(1, 1, 4, device=device) + dummy_box_labels_ignore = torch.full((1, 1), -10, dtype=torch.long, device=device) + dummy_ex_points = torch.rand(1, 1, 2, device=device) + dummy_ex_point_labels = torch.ones(1, 1, dtype=torch.long, device=device) + + geo_exemplar_path = output_dir / f"{_GEOMETRY_ENCODER_EXEMPLAR_NAME}.onnx" + torch.onnx.export( + geo_exemplar_wrapper, + (dummy_fpn, dummy_pos, dummy_boxes_ignore, dummy_box_labels_ignore, dummy_ex_points, dummy_ex_point_labels), + str(geo_exemplar_path), + opset_version=opset_version, + dynamo=False, + input_names=[ + "fpn_feat_2", + "fpn_pos_2", + "input_boxes", + "input_boxes_labels", + "input_points", + "input_points_labels", + ], + output_names=["geometry_features", "geometry_mask"], + dynamic_axes={ + "input_boxes": {0: "batch", 1: "num_boxes"}, + "input_boxes_labels": {0: "batch", 1: "num_boxes"}, + "input_points": {0: "batch", 1: "num_points"}, + "input_points_labels": {0: "batch", 1: "num_points"}, + }, + ) + exported[_GEOMETRY_ENCODER_EXEMPLAR_NAME] = geo_exemplar_path + logger.info(" -> %s", geo_exemplar_path) + + # --- 5. Prompt decoder --- + logger.info("Exporting prompt decoder...") + decoder_wrapper = OnnxPromptDecoder(model) + decoder_wrapper.eval() + # FPN feature sizes: 4x -> resolution*4/14, 2x -> resolution*2/14, 1x -> resolution/14 + feat_4x = feat_size * 4 # 288 for 1008 + feat_2x = feat_size * 2 # 144 for 1008 + dummy_f0 = torch.randn(1, 256, feat_4x, feat_4x, device=device) + dummy_f1 = torch.randn(1, 256, feat_2x, feat_2x, device=device) + dummy_f2 = torch.randn(1, 256, feat_size, feat_size, device=device) + dummy_p2 = torch.randn(1, 256, feat_size, feat_size, device=device) + # Text-only prompt (32 tokens) + dummy_prompt = torch.randn(1, 32, 256, device=device) + dummy_pmask = torch.ones(1, 32, dtype=torch.bool, device=device) + + decoder_path = output_dir / f"{_PROMPT_DECODER_NAME}.onnx" + torch.onnx.export( + decoder_wrapper, + (dummy_f0, dummy_f1, dummy_f2, dummy_p2, dummy_prompt, dummy_pmask), + str(decoder_path), + opset_version=opset_version, + dynamo=False, + input_names=[ + "fpn_feat_0", + "fpn_feat_1", + "fpn_feat_2", + "fpn_pos_2", + "prompt_features", + "prompt_mask", + ], + output_names=["pred_masks", "pred_boxes", "pred_logits", "presence_logits"], + dynamic_axes={ + "prompt_features": {0: "batch", 1: "prompt_len"}, + "prompt_mask": {0: "batch", 1: "prompt_len"}, + }, + ) + exported[_PROMPT_DECODER_NAME] = decoder_path + logger.info(" -> %s", decoder_path) + + logger.info("ONNX export complete. %d models written to %s", len(exported), output_dir) + return exported + + +def convert_onnx_to_openvino( + onnx_dir: str | Path, + output_dir: str | Path, + *, + compress_to_fp16: bool = True, +) -> dict[str, Path]: + """Convert all SAM3 ONNX models in a directory to OpenVINO IR. + + Args: + onnx_dir: Directory containing the ONNX files. + output_dir: Directory to write OpenVINO IR files. + compress_to_fp16: Compress weights to FP16 during conversion. + + Returns: + Mapping from model name to the written ``.xml`` path. + """ + import openvino as ov # noqa: PLC0415 + + onnx_dir = Path(onnx_dir) + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + + model_names = [ + _VISION_ENCODER_NAME, + _TEXT_ENCODER_NAME, + _GEOMETRY_ENCODER_NAME, + _GEOMETRY_ENCODER_EXEMPLAR_NAME, + _PROMPT_DECODER_NAME, + ] + + converted: dict[str, Path] = {} + for name in model_names: + onnx_path = onnx_dir / f"{name}.onnx" + if not onnx_path.exists(): + logger.warning("Skipping %s — ONNX file not found.", onnx_path) + continue + + logger.info("Converting %s to OpenVINO IR...", name) + ov_model = ov.convert_model(str(onnx_path)) + ir_path = output_dir / f"{name}.xml" + ov.save_model(ov_model, str(ir_path), compress_to_fp16=compress_to_fp16) + converted[name] = ir_path + logger.info(" -> %s", ir_path) + + logger.info("OpenVINO conversion complete. %d models written to %s", len(converted), output_dir) + return converted diff --git a/library/src/instantlearn/models/sam3/sam3_openvino.py b/library/src/instantlearn/models/sam3/sam3_openvino.py new file mode 100644 index 000000000..a343c327e --- /dev/null +++ b/library/src/instantlearn/models/sam3/sam3_openvino.py @@ -0,0 +1,1005 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""SAM3 OpenVINO inference model for text, box, point, and visual-exemplar prompting. + +This module provides ``SAM3OpenVINO``, which loads pre-exported SAM3 OpenVINO IR +(or ONNX) models and provides the same inference API as the PyTorch ``SAM3`` model. + +Supported prompt types (matching PyTorch ``SAM3`` parity): + +* **Text prompts** — category names via ``fit()`` or per-sample ``categories`` +* **Box prompts** — bounding boxes via the ``bboxes`` field +* **Point prompts** — click points via the ``points`` field +* **Combined text + box/point** — both at the same time +* **Visual exemplar mode** — encode reference image prompts at ``fit()`` + time, reuse cached features to detect similar objects on any target image + +The model expects 5 sub-models (custom-exported from ``Sam3Model``): + +* ``vision-encoder`` — ViT + FPN backbone +* ``text-encoder`` — CLIP text encoder + projection +* ``geometry-encoder`` — Geometry encoder (classic, ``drop_spatial_bias=False``) +* ``geometry-encoder-exemplar`` — Geometry encoder (exemplar, ``drop_spatial_bias=True``) +* ``prompt-decoder`` — DETR encoder/decoder + box refinement + scoring + mask decoder + +See Also: + - ``SAM3``: PyTorch-based SAM3 model + - ``export_openvino``: ONNX export wrappers and conversion utilities + - ``export_sam3_openvino.py``: CLI script for exporting models +""" + +import logging +from collections import defaultdict +from enum import Enum +from itertools import zip_longest +from pathlib import Path + +import numpy as np +import openvino as ov +import torch +from transformers import CLIPTokenizerFast + +from instantlearn.data.base.batch import Batch, Collatable +from instantlearn.data.base.sample import Sample +from instantlearn.models.base import Model +from instantlearn.utils import device_to_openvino_device + +from .processing import Sam3Postprocessor, Sam3Preprocessor, Sam3PromptPreprocessor +from .sam3 import Sam3PromptMode + +logger = logging.getLogger(__name__) + +# Default HuggingFace repo for SAM3 OpenVINO models and tokenizer +_DEFAULT_HF_REPO = "rajeshgangireddy/exported_sam3" + + +class SAM3OVVariant(str, Enum): + """Available SAM3 OpenVINO model variants. + + Each variant maps to a subdirectory name on HuggingFace Hub. + """ + + FP16 = "openvino-fp16" + FP32 = "openvino-fp32" + INT8 = "openvino-nncf-int8" + INT4 = "openvino-nncf-int4" + + +# Sub-model file names +_VISION_ENCODER = "vision-encoder" +_TEXT_ENCODER = "text-encoder" +_GEOMETRY_ENCODER = "geometry-encoder" +_GEOMETRY_ENCODER_EXEMPLAR = "geometry-encoder-exemplar" +_PROMPT_DECODER = "prompt-decoder" + + +def _find_model_file(model_dir: Path, name: str) -> Path | None: + """Find a model file in a directory, supporting OV IR (.xml) and ONNX (.onnx). + + Search order: + 1. ``{name}.xml`` — OpenVINO IR (preferred) + 2. ``{name}.onnx`` — canonical ONNX name + 3. ``{name}-fp16.onnx`` — FP16 ONNX variant + 4. Any remaining ``{name}*.onnx`` — other quantised variants + + Args: + model_dir: Directory to search. + name: Base name of the model (without extension). + + Returns: + Path to the found model file, or ``None`` if not found. + """ + candidates = [ + model_dir / f"{name}.xml", + model_dir / f"{name}.onnx", + model_dir / f"{name}-fp16.onnx", + ] + for candidate in candidates: + if candidate.exists(): + return candidate + onnx_variants = sorted(model_dir.glob(f"{name}*.onnx")) + if onnx_variants: + return onnx_variants[0] + return None + + +def _require_model_file(model_dir: Path, name: str) -> Path: + """Find a model file or raise. + + Args: + model_dir: Directory to search. + name: Base name of the model (without extension). + + Returns: + Path to the found model file. + + Raises: + FileNotFoundError: If no matching model file is found. + """ + path = _find_model_file(model_dir, name) + if path is None: + msg = f"Model '{name}' not found in {model_dir}." + raise FileNotFoundError(msg) + return path + + +class SAM3OpenVINO(Model): + """SAM3 model using OpenVINO runtime for inference. + + Provides the same capabilities as the PyTorch ``SAM3`` model: + + * **CLASSIC** mode — text, box, point, or combined prompts per target image. + * **VISUAL_EXEMPLAR** mode — encode reference-image prompts during ``fit()`` + and reuse cached geometry features for every target image in ``predict()``. + + The model loads 4 (or 5) pre-exported sub-models from *model_dir*: + + * ``vision-encoder`` + * ``text-encoder`` + * ``geometry-encoder`` (classic mode) + * ``geometry-encoder-exemplar`` (exemplar fit) + * ``prompt-decoder`` + + Examples: + >>> from instantlearn.models.sam3 import SAM3OpenVINO, Sam3PromptMode + >>> from instantlearn.data.base.sample import Sample + >>> import numpy as np + + >>> # Auto-download default variant (FP16) from HuggingFace + >>> model = SAM3OpenVINO(device="CPU") + >>> model.fit(Sample(categories=["elephant"], category_ids=[0])) + >>> results = model.predict( + ... Sample(image_path="examples/assets/coco/000000286874.jpg", categories=["elephant"]), + ... ) + + >>> # Auto-download INT8 quantised variant + >>> model = SAM3OpenVINO(variant=SAM3OVVariant.INT8, device="CPU") + + >>> # Use a local model directory (no download) + >>> model = SAM3OpenVINO(model_dir="./sam3-openvino/openvino-fp16", device="CPU") + + >>> # Box prompting (elephant bounding box) + >>> target = Sample( + ... image_path="examples/assets/coco/000000286874.jpg", + ... bboxes=np.array([[180, 105, 490, 370]]), + ... ) + >>> results = model.predict(target) + + >>> # Point prompting (click on elephant) + >>> target = Sample( + ... image_path="examples/assets/coco/000000286874.jpg", + ... points=np.array([[335, 240]]), + ... ) + >>> results = model.predict(target) + + >>> # Visual exemplar mode — fit on one image, predict on another + >>> model_ve = SAM3OpenVINO( + ... variant=SAM3OVVariant.FP16, + ... prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR, + ... ) + >>> ref = Sample( + ... image_path="examples/assets/coco/000000286874.jpg", + ... bboxes=np.array([[180, 105, 490, 370]]), + ... categories=["elephant"], + ... category_ids=[0], + ... ) + >>> model_ve.fit(ref) + >>> results = model_ve.predict( + ... Sample(image_path="examples/assets/coco/000000390341.jpg"), + ... ) + """ + + def __init__( + self, + model_dir: str | Path | None = None, + device: str = "AUTO", + confidence_threshold: float = 0.5, + resolution: int = 1008, + prompt_mode: Sam3PromptMode = Sam3PromptMode.VISUAL_EXEMPLAR, + drop_spatial_bias: bool = True, + tokenizer_path: str | Path | None = None, + variant: SAM3OVVariant = SAM3OVVariant.FP16, + repo_id: str = _DEFAULT_HF_REPO, + ) -> None: + """Initialise SAM3 OpenVINO model. + + When *model_dir* is provided, models are loaded from the local directory. + Otherwise, the *variant* is automatically downloaded from HuggingFace Hub. + + Args: + model_dir: Directory containing OpenVINO IR or ONNX sub-models. + When ``None``, models are auto-downloaded from HuggingFace Hub. + device: OpenVINO device (``"CPU"``, ``"GPU"``, ``"AUTO"``). + PyTorch-style names (``"cuda"``, ``"cpu"``) are also accepted. + confidence_threshold: Minimum confidence score for predictions. + resolution: Input image resolution (must match exported model). + prompt_mode: ``Sam3PromptMode.CLASSIC`` or + ``Sam3PromptMode.VISUAL_EXEMPLAR``. + drop_spatial_bias: Stored for API compatibility but has no + runtime effect. The exemplar geometry encoder already has + ``drop_spatial_bias=True`` baked in at export time. + tokenizer_path: Explicit tokenizer path or HuggingFace model ID. + variant: Model variant to download when *model_dir* is ``None``. + repo_id: HuggingFace repository ID for auto-download. + """ + super().__init__() + + self.model_dir = self._resolve_model_dir(model_dir, variant=variant, repo_id=repo_id) + self.ov_device = device_to_openvino_device(device) + self.confidence_threshold = confidence_threshold + self.resolution = resolution + self.prompt_mode = prompt_mode + self.drop_spatial_bias = drop_spatial_bias + + # Category mapping from fit() + self.category_mapping: dict[str, int] | None = None + + # Exemplar cache (populated in _fit_visual_exemplar) + self.exemplar_geometry_features: list[np.ndarray] | None = None + self.exemplar_geometry_mask: list[np.ndarray] | None = None + self.exemplar_text_features: list[np.ndarray] | None = None + self.exemplar_text_mask: list[np.ndarray] | None = None + self.exemplar_category_ids: list[int] | None = None + + # -- Load sub-models -- + core = ov.Core() + + # Vision encoder + text encoder (always required) + vision_path = _require_model_file(self.model_dir, _VISION_ENCODER) + text_path = _require_model_file(self.model_dir, _TEXT_ENCODER) + + logger.info("Loading SAM3 OpenVINO models from %s on %s...", self.model_dir, self.ov_device) + self.vision_model = core.compile_model(vision_path, self.ov_device) + self.text_model = core.compile_model(text_path, self.ov_device) + logger.info(" Vision encoder: %s", vision_path.name) + logger.info(" Text encoder: %s", text_path.name) + + # Load prompt decoder (required) + prompt_decoder_path = _require_model_file(self.model_dir, _PROMPT_DECODER) + self.decoder_model = core.compile_model(prompt_decoder_path, self.ov_device) + logger.info(" Prompt decoder: %s", prompt_decoder_path.name) + + # Load geometry encoders (optional — needed for box/point/exemplar) + geo_path = _find_model_file(self.model_dir, _GEOMETRY_ENCODER) + if geo_path is not None: + self.geometry_model = core.compile_model(geo_path, self.ov_device) + logger.info(" Geometry encoder (classic): %s", geo_path.name) + else: + self.geometry_model = None + + geo_ex_path = _find_model_file(self.model_dir, _GEOMETRY_ENCODER_EXEMPLAR) + if geo_ex_path is not None: + self.geometry_exemplar_model = core.compile_model(geo_ex_path, self.ov_device) + logger.info(" Geometry encoder (exemplar): %s", geo_ex_path.name) + else: + self.geometry_exemplar_model = None + + # Pre-create infer requests to avoid per-call allocation overhead (GPU) + self._vision_request = self.vision_model.create_infer_request() + self._text_request = self.text_model.create_infer_request() + self._decoder_request = self.decoder_model.create_infer_request() + self._geometry_request = self.geometry_model.create_infer_request() if self.geometry_model is not None else None + self._geometry_exemplar_request = ( + self.geometry_exemplar_model.create_infer_request() if self.geometry_exemplar_model is not None else None + ) + + self.image_preprocessor = Sam3Preprocessor(target_size=resolution) + self.prompt_preprocessor = Sam3PromptPreprocessor(target_size=resolution) + self.postprocessor = Sam3Postprocessor( + target_size=resolution, + threshold=confidence_threshold, + mask_threshold=0.5, + ) + + # Tokenizer + self.tokenizer = self._load_tokenizer(tokenizer_path) + logger.info("SAM3 OpenVINO model loaded successfully (mode=%s).", prompt_mode.value) + + def _load_tokenizer(self, tokenizer_path: str | Path | None) -> CLIPTokenizerFast: + """Load CLIP tokenizer from local path or HuggingFace. + + Args: + tokenizer_path: Explicit path/repo, or ``None`` for auto-detection. + + Returns: + Loaded ``CLIPTokenizerFast`` instance. + """ + if tokenizer_path is not None: + return CLIPTokenizerFast.from_pretrained(str(tokenizer_path)) + if (self.model_dir / "tokenizer.json").exists(): + return CLIPTokenizerFast.from_pretrained(str(self.model_dir)) + return CLIPTokenizerFast.from_pretrained(_DEFAULT_HF_REPO) + + @staticmethod + def _resolve_model_dir( + model_dir: str | Path | None, + *, + variant: SAM3OVVariant = SAM3OVVariant.FP16, + repo_id: str = _DEFAULT_HF_REPO, + ) -> Path: + """Resolve the model directory, downloading from HuggingFace if needed. + + Args: + model_dir: Explicit local directory, or ``None`` for auto-download. + variant: Model variant to download. + repo_id: HuggingFace repository ID. + + Returns: + Local ``Path`` to the directory containing the sub-model files. + + Raises: + FileNotFoundError: If *model_dir* is given but does not exist. + ImportError: If ``huggingface_hub`` is not installed. + """ + if model_dir is not None: + path = Path(model_dir) + if not path.is_dir(): + msg = f"Model directory not found: {path}" + raise FileNotFoundError(msg) + return path + + variant = SAM3OVVariant(variant) + subdir = variant.value + + try: + from huggingface_hub import snapshot_download # noqa: PLC0415 + except ImportError: + msg = "huggingface_hub is required for auto-download. Install it with: uv pip install huggingface-hub" + raise ImportError(msg) # noqa: B904 + + logger.info("Downloading SAM3 '%s' from HuggingFace: %s", variant.name, repo_id) + cache_dir = snapshot_download( + repo_id=repo_id, + allow_patterns=[f"{subdir}/*", "tokenizer*", "special_tokens_map*"], + ) + return Path(cache_dir) / subdir + + def _run_vision_encoder(self, pixel_values: np.ndarray) -> dict[str, np.ndarray]: + """Run vision encoder. + + Args: + pixel_values: ``[1, 3, H, W]`` float32. + + Returns: + Dict with ``fpn_feat_0``, ``fpn_feat_1``, ``fpn_feat_2``, ``fpn_pos_2``. + """ + self._vision_request.infer([pixel_values]) + return { + "fpn_feat_0": np.array(self._vision_request.get_tensor("fpn_feat_0").data), + "fpn_feat_1": np.array(self._vision_request.get_tensor("fpn_feat_1").data), + "fpn_feat_2": np.array(self._vision_request.get_tensor("fpn_feat_2").data), + "fpn_pos_2": np.array(self._vision_request.get_tensor("fpn_pos_2").data), + } + + def _run_text_encoder( + self, + input_ids: np.ndarray, + attention_mask: np.ndarray, + ) -> dict[str, np.ndarray]: + """Run text encoder. + + Args: + input_ids: ``[1, 32]`` int64. + attention_mask: ``[1, 32]`` int64. + + Returns: + Dict with ``text_features`` and ``text_mask``. + """ + self._text_request.infer([input_ids, attention_mask]) + return { + "text_features": np.array(self._text_request.get_tensor("text_features").data), + "text_mask": np.array(self._text_request.get_tensor("text_mask").data), + } + + def _run_geometry_encoder( + self, + fpn_feat_2: np.ndarray, + fpn_pos_2: np.ndarray, + input_boxes: np.ndarray, + input_boxes_labels: np.ndarray, + input_points: np.ndarray, + input_points_labels: np.ndarray, + *, + exemplar: bool = False, + ) -> dict[str, np.ndarray]: + """Run geometry encoder. + + Args: + fpn_feat_2: ``[1, 256, H, W]`` float32! + fpn_pos_2: ``[1, 256, H, W]`` float32. + input_boxes: ``[1, N, 4]`` cxcywh normalised. + input_boxes_labels: ``[1, N]`` int64. + input_points: ``[1, M, 2]`` xy normalised. + input_points_labels: ``[1, M]`` int64. + exemplar: Use the exemplar geometry encoder (``drop_spatial_bias=True``). + + Returns: + Dict with ``geometry_features`` ``[1, K, 256]`` and + ``geometry_mask`` ``[1, K]``. + + Raises: + RuntimeError: If the required geometry encoder model is not loaded. + """ + model = self.geometry_exemplar_model if exemplar else self.geometry_model + if model is None: + variant = "exemplar" if exemplar else "classic" + msg = f"Geometry encoder ({variant}) is not loaded. Re-export models." + raise RuntimeError(msg) + request = self._geometry_exemplar_request if exemplar else self._geometry_request + request.infer([ + fpn_feat_2, + fpn_pos_2, + input_boxes, + input_boxes_labels, + input_points, + input_points_labels, + ]) + return { + "geometry_features": np.array(request.get_tensor("geometry_features").data), + "geometry_mask": np.array(request.get_tensor("geometry_mask").data), + } + + def _run_prompt_decoder( + self, + vision_features: dict[str, np.ndarray], + prompt_features: np.ndarray, + prompt_mask: np.ndarray, + ) -> dict[str, np.ndarray]: + """Run prompt decoder (DETR pipeline + mask decoder). + + Args: + vision_features: FPN features from vision encoder. + prompt_features: ``[1, T, 256]`` pre-concatenated prompt features. + prompt_mask: ``[1, T]`` bool. + + Returns: + Dict with ``pred_masks``, ``pred_boxes``, ``pred_logits``, + ``presence_logits``. + """ + self._decoder_request.infer([ + vision_features["fpn_feat_0"], + vision_features["fpn_feat_1"], + vision_features["fpn_feat_2"], + vision_features["fpn_pos_2"], + prompt_features, + prompt_mask, + ]) + return { + "pred_masks": np.array(self._decoder_request.get_tensor("pred_masks").data), + "pred_boxes": np.array(self._decoder_request.get_tensor("pred_boxes").data), + "pred_logits": np.array(self._decoder_request.get_tensor("pred_logits").data), + "presence_logits": np.array(self._decoder_request.get_tensor("presence_logits").data), + } + + def _tokenize(self, text: str) -> tuple[np.ndarray, np.ndarray]: + """Tokenise a single text prompt and pad/truncate to length 32. + + Args: + text: Text prompt string. + + Returns: + Tuple of ``(input_ids, attention_mask)`` as ``[1, 32]`` int64 arrays. + """ + text_inputs = self.tokenizer([text], return_tensors="np", padding=True) + input_ids = self._pad_or_truncate(text_inputs.input_ids.astype(np.int64), 32) + attention_mask = self._pad_or_truncate(text_inputs.attention_mask.astype(np.int64), 32) + return input_ids, attention_mask + + @staticmethod + def _pad_or_truncate(arr: np.ndarray, target_len: int) -> np.ndarray: + """Pad or truncate a 2-D array to the target sequence length. + + Args: + arr: ``[batch, seq_len]``. + target_len: Target sequence length. + + Returns: + ``[batch, target_len]``. + """ + current_len = arr.shape[1] + if current_len == target_len: + return arr + if current_len > target_len: + return arr[:, :target_len] + padding = np.zeros((arr.shape[0], target_len - current_len), dtype=arr.dtype) + return np.concatenate([arr, padding], axis=1) + + def fit(self, reference: Sample | list[Sample] | Batch) -> None: + """Learn from reference data. + + * **CLASSIC** mode: stores category mapping only. + * **VISUAL_EXEMPLAR** mode: encodes reference image prompts into cached + geometry features for reuse during ``predict()``. + + Args: + reference: Reference data containing category information and, + for exemplar mode, images with bboxes/points. + """ + reference_batch = Batch.collate(reference) + if self.prompt_mode == Sam3PromptMode.VISUAL_EXEMPLAR: + self._fit_visual_exemplar(reference_batch) + else: + self._fit_classic(reference_batch) + + def _fit_classic(self, reference_batch: Batch) -> None: + """Store category mapping (classic mode). + + Args: + reference_batch: Batch of reference samples. + """ + self.category_mapping = self._build_category_mapping(reference_batch) + + def _fit_visual_exemplar(self, reference_batch: Batch) -> None: + """Encode exemplar geometry features from reference images. + + Mirrors the PyTorch ``SAM3._fit_visual_exemplar()`` flow: + + 1. For each reference sample, run vision encoder. + 2. Convert all box prompts to point-only (box centre) — point encoding + transfers better across images than ROI pooling. + 3. Group prompts by category, encode with geometry encoder (exemplar). + 4. Cross-image: concatenate features for the same category. + 5. Encode text prompts and cache everything. + + Args: + reference_batch: Batch of reference samples with images and prompts. + + Raises: + ValueError: If no reference samples contain bboxes or points. + """ + encoded_by_category: dict[int, list[tuple[np.ndarray, np.ndarray]]] = defaultdict(list) + category_text_map: dict[int, str] = {} + + for sample in reference_batch.samples: + self._encode_sample_prompts(sample, encoded_by_category, category_text_map) + + if not encoded_by_category: + msg = "VISUAL_EXEMPLAR mode requires at least one reference sample with bboxes or points." + raise ValueError(msg) + + # Aggregate per-category features + geo_features_list: list[np.ndarray] = [] + geo_masks_list: list[np.ndarray] = [] + category_ids: list[int] = [] + text_prompts: list[str] = [] + + for cat_id in sorted(encoded_by_category.keys()): + features_list = encoded_by_category[cat_id] + if len(features_list) == 1: + geo_feats, geo_mask = features_list[0] + else: + geo_feats = np.concatenate([f[0] for f in features_list], axis=1) + geo_mask = np.concatenate([f[1] for f in features_list], axis=1) + + geo_features_list.append(geo_feats) + geo_masks_list.append(geo_mask) + category_ids.append(cat_id) + text_prompts.append(category_text_map[cat_id]) + + # Encode text prompts + text_features_list: list[np.ndarray] = [] + text_masks_list: list[np.ndarray] = [] + text_cache: dict[str, tuple[np.ndarray, np.ndarray]] = {} + + for prompt in text_prompts: + if prompt not in text_cache: + input_ids, attention_mask = self._tokenize(prompt) + text_out = self._run_text_encoder(input_ids, attention_mask) + text_cache[prompt] = (text_out["text_features"], text_out["text_mask"]) + text_features_list.append(text_cache[prompt][0]) + text_masks_list.append(text_cache[prompt][1]) + + # Store cached features + self.exemplar_geometry_features = geo_features_list + self.exemplar_geometry_mask = geo_masks_list + self.exemplar_text_features = text_features_list + self.exemplar_text_mask = text_masks_list + self.exemplar_category_ids = category_ids + self.category_mapping = self._build_category_mapping(reference_batch) + + # Log shot counts + shot_info = { + category_text_map[cat_id]: sum(f[0].shape[1] for f in encoded_by_category[cat_id]) + for cat_id in category_ids + } + logger.info( + "Cached %d category exemplar(s): %s, category_ids=%s", + len(category_ids), + shot_info, + category_ids, + ) + + def _encode_sample_prompts( + self, + sample: Sample, + encoded_by_category: dict[int, list[tuple[np.ndarray, np.ndarray]]], + category_text_map: dict[int, str], + ) -> None: + """Encode one sample's box/point prompts into per-category geometry features. + + All box prompts are converted to point-only (box centre ``[cx, cy]``) + because point encoding transfers better across images. + + Args: + sample: Reference sample with image and bboxes/points. + encoded_by_category: Accumulator mapping cat_id to encoded features. + category_text_map: Accumulator mapping cat_id to text name. + + Raises: + ValueError: If the sample has prompts but no image. + """ + bboxes = sample.bboxes + points = sample.points + has_bboxes = bboxes is not None and not (isinstance(bboxes, (np.ndarray, torch.Tensor)) and bboxes.size == 0) + has_points = points is not None and not (isinstance(points, (np.ndarray, torch.Tensor)) and points.size == 0) + + if not has_bboxes and not has_points: + return + if sample.image is None: + msg = "VISUAL_EXEMPLAR mode requires images in reference samples." + raise ValueError(msg) + + # Run vision encoder + image_tensor = sample.image.unsqueeze(0) if sample.image.ndim == 3 else sample.image + with torch.no_grad(): + pixel_values, original_sizes = self.image_preprocessor(image_tensor) + vision_features = self._run_vision_encoder(pixel_values.numpy()) + + # Build metadata + num_prompts = max(len(bboxes) if has_bboxes else 0, len(points) if has_points else 0) + categories = sample.categories if sample.categories is not None else ["visual"] * num_prompts + category_ids = sample.category_ids if sample.category_ids is not None else [0] * num_prompts + + # Convert all prompts to normalised point coords grouped by category + category_coords: dict[int, list[np.ndarray]] = defaultdict(list) + prompts = bboxes if has_bboxes else points + + for prompt, category, raw_cat_id in zip(prompts, categories, category_ids, strict=True): + if has_bboxes: + input_boxes, _ = self.prompt_preprocessor(original_sizes, input_boxes=prompt) + coord = input_boxes[..., :2].numpy() # box centre [1, 1, 2] + else: + _, coord_tensor = self.prompt_preprocessor(original_sizes, input_points=prompt) + coord = coord_tensor.numpy() + int_cat_id = int(raw_cat_id) + category_coords[int_cat_id].append(coord) + category_text_map[int_cat_id] = category + + # Encode each category's points together (n-shot batching) + for cat_id, coords_list in category_coords.items(): + all_coords = np.concatenate(coords_list, axis=1) # [1, N, 2] + num_pts = all_coords.shape[1] + + # No boxes for exemplar — pass ignore sentinels + ignore_boxes = np.zeros((1, 1, 4), dtype=np.float32) + ignore_box_labels = np.full((1, 1), -10, dtype=np.int64) + point_labels = np.ones((1, num_pts), dtype=np.int64) + + geo_out = self._run_geometry_encoder( + fpn_feat_2=vision_features["fpn_feat_2"], + fpn_pos_2=vision_features["fpn_pos_2"], + input_boxes=ignore_boxes, + input_boxes_labels=ignore_box_labels, + input_points=all_coords.astype(np.float32), + input_points_labels=point_labels, + exemplar=True, + ) + encoded_by_category[cat_id].append(( + np.array(geo_out["geometry_features"]), + np.array(geo_out["geometry_mask"]), + )) + + def predict(self, target: Collatable) -> list[dict[str, torch.Tensor]]: + """Predict masks for target images. + + Supports all prompt types: text, box, point, and combined. In + visual-exemplar mode, uses cached geometry features from ``fit()``. + + Args: + target: Target data to infer. Accepts Sample, list[Sample], Batch, + or file paths. + + Returns: + List of prediction dicts per image with ``pred_masks``, + ``pred_boxes``, ``pred_labels``. + """ + if self.prompt_mode == Sam3PromptMode.VISUAL_EXEMPLAR: + return self._predict_visual_exemplar(target) + return self._predict_classic(target) + + def _predict_classic(self, target: Collatable) -> list[dict[str, torch.Tensor]]: # noqa: PLR0915 + """Classic prediction with per-image text/box/point prompts. + + Args: + target: Target data. + + Returns: + List of prediction dicts per image. + """ + target_batch = Batch.collate(target) + results = [] + use_fitted_categories = self.category_mapping is not None + + for sample in target_batch.samples: + img_size = sample.image.shape[-2:] + bboxes = sample.bboxes if sample.bboxes is not None else [] + points = sample.points if sample.points is not None else [] + + # Preprocess image + image_tensor = sample.image.unsqueeze(0) if sample.image.ndim == 3 else sample.image + with torch.no_grad(): + pixel_values, original_sizes = self.image_preprocessor(image_tensor) + vision_features = self._run_vision_encoder(pixel_values.numpy()) + + # Determine prompts + if use_fitted_categories: + texts = list(self.category_mapping.keys()) + category_ids = list(self.category_mapping.values()) + else: + texts = sample.categories or [] + category_ids = list(sample.category_ids or []) + num_visual = max(len(bboxes), len(points)) + if num_visual: + if len(texts) != num_visual: + texts = ["visual"] * num_visual + if len(category_ids) != num_visual: + default_category_id = category_ids[0] if category_ids else 0 + category_ids = [default_category_id] * num_visual + + all_masks: list[torch.Tensor] = [] + all_boxes: list[torch.Tensor] = [] + all_labels: list[torch.Tensor] = [] + + for text, bbox, point, cat_id in zip_longest(texts, bboxes, points, category_ids, fillvalue=None): + # Tokenise and encode text + input_ids, attention_mask = self._tokenize(text or "visual") + text_out = self._run_text_encoder(input_ids, attention_mask) + text_features = text_out["text_features"] # [1, 32, 256] + text_mask = text_out["text_mask"] # [1, 32] + + # Prepare geometry prompts (if any) + has_box = bbox is not None and len(bbox) + has_point = point is not None and len(point) + + if has_box or has_point: + # Encode geometry prompts with separate geometry encoder + with torch.no_grad(): + norm_boxes, norm_points = self.prompt_preprocessor( + original_sizes, + input_boxes=bbox if has_box else None, + input_points=point if has_point else None, + ) + + if norm_boxes is not None: + ov_boxes = norm_boxes.numpy().astype(np.float32) + ov_box_labels = np.ones((1, ov_boxes.shape[1]), dtype=np.int64) + else: + ov_boxes = np.zeros((1, 1, 4), dtype=np.float32) + ov_box_labels = np.full((1, 1), -10, dtype=np.int64) + + if norm_points is not None: + ov_points = norm_points.numpy().astype(np.float32) + ov_point_labels = np.ones((1, ov_points.shape[1]), dtype=np.int64) + else: + ov_points = np.zeros((1, 1, 2), dtype=np.float32) + ov_point_labels = np.full((1, 1), -10, dtype=np.int64) + + geo_out = self._run_geometry_encoder( + fpn_feat_2=vision_features["fpn_feat_2"], + fpn_pos_2=vision_features["fpn_pos_2"], + input_boxes=ov_boxes, + input_boxes_labels=ov_box_labels, + input_points=ov_points, + input_points_labels=ov_point_labels, + ) + + # Concatenate text + geometry + prompt_features = np.concatenate( + [text_features, geo_out["geometry_features"]], + axis=1, + ).astype(np.float32) + prompt_mask = np.concatenate( + [text_mask.astype(bool), geo_out["geometry_mask"].astype(bool)], + axis=1, + ) + + decoder_out = self._run_prompt_decoder( + vision_features, + prompt_features, + prompt_mask, + ) + + else: + # Text-only as prompt features + decoder_out = self._run_prompt_decoder( + vision_features, + text_features.astype(np.float32), + text_mask.astype(bool), + ) + + # Convert outputs and postprocess + outputs_torch = { + "pred_masks": torch.from_numpy(np.array(decoder_out["pred_masks"])), + "pred_boxes": torch.from_numpy(np.array(decoder_out["pred_boxes"])), + "pred_logits": torch.from_numpy(np.array(decoder_out["pred_logits"])), + "presence_logits": torch.from_numpy(np.array(decoder_out["presence_logits"])), + } + + with torch.no_grad(): + result = self.postprocessor(outputs_torch, target_sizes=[img_size]) + + boxes_with_scores = torch.cat( + [result[0]["boxes"], result[0]["scores"].unsqueeze(1)], + dim=1, + ) + all_masks.append(result[0]["masks"]) + all_boxes.append(boxes_with_scores) + label_id = cat_id if cat_id is not None else 0 + all_labels.append(torch.full((len(result[0]["boxes"]),), label_id, dtype=torch.int64)) + + results.append(self._aggregate_results(all_masks, all_boxes, all_labels, img_size)) + + return results + + def _predict_visual_exemplar(self, target: Collatable) -> list[dict[str, torch.Tensor]]: + """Visual-exemplar prediction using cached geometry features from ``fit()``. + + For each target image, reuses the cached exemplar geometry features + (extracted from reference images) as prompt conditioning together with + the cached text features. + + Args: + target: Target data. + + Returns: + List of prediction dicts per image. + + Raises: + RuntimeError: If ``fit()`` has not been called. + """ + if self.exemplar_geometry_features is None: + msg = "No cached exemplar features. Call fit() with reference images and bboxes/points first." + raise RuntimeError(msg) + + target_batch = Batch.collate(target) + results = [] + + for sample in target_batch.samples: + img_size = sample.image.shape[-2:] + + # Preprocess target image + image_tensor = sample.image.unsqueeze(0) if sample.image.ndim == 3 else sample.image + with torch.no_grad(): + pixel_values, _ = self.image_preprocessor(image_tensor) + vision_features = self._run_vision_encoder(pixel_values.numpy()) + + all_masks: list[torch.Tensor] = [] + all_boxes: list[torch.Tensor] = [] + all_labels: list[torch.Tensor] = [] + + # Run detection for each cached exemplar + for geo_feats, geo_mask, text_feats, text_mask, cat_id in zip( + self.exemplar_geometry_features, + self.exemplar_geometry_mask, + self.exemplar_text_features, + self.exemplar_text_mask, + self.exemplar_category_ids, + strict=True, + ): + # Concatenate text + geometry features + prompt_features = np.concatenate( + [text_feats, geo_feats], + axis=1, + ).astype(np.float32) + prompt_mask = np.concatenate( + [text_mask.astype(bool), geo_mask.astype(bool)], + axis=1, + ) + + decoder_out = self._run_prompt_decoder( + vision_features, + prompt_features, + prompt_mask, + ) + + outputs_torch = { + "pred_masks": torch.from_numpy(np.array(decoder_out["pred_masks"])), + "pred_boxes": torch.from_numpy(np.array(decoder_out["pred_boxes"])), + "pred_logits": torch.from_numpy(np.array(decoder_out["pred_logits"])), + "presence_logits": torch.from_numpy(np.array(decoder_out["presence_logits"])), + } + + with torch.no_grad(): + result = self.postprocessor(outputs_torch, target_sizes=[img_size]) + + boxes_with_scores = torch.cat( + [result[0]["boxes"], result[0]["scores"].unsqueeze(1)], + dim=1, + ) + all_masks.append(result[0]["masks"]) + all_boxes.append(boxes_with_scores) + label_id = cat_id if cat_id is not None else 0 + all_labels.append(torch.full((len(result[0]["boxes"]),), label_id, dtype=torch.int64)) + + results.append(self._aggregate_results(all_masks, all_boxes, all_labels, img_size)) + + return results + + @staticmethod + def _build_category_mapping(reference_batch: Batch) -> dict[str, int]: + """Build category name → id mapping from reference samples. + + Args: + reference_batch: Batch of reference samples. + + Returns: + Mapping from category name to category id. + """ + mapping: dict[str, int] = {} + for sample in reference_batch.samples: + if sample.categories is None or sample.category_ids is None: + continue + for category_id, category in zip(sample.category_ids, sample.categories, strict=False): + if category not in mapping: + mapping[category] = int(category_id) + return mapping + + @staticmethod + def _aggregate_results( + all_masks: list[torch.Tensor], + all_boxes: list[torch.Tensor], + all_labels: list[torch.Tensor], + img_size: tuple[int, int], + ) -> dict[str, torch.Tensor]: + """Aggregate results from multiple prompt predictions for one image. + + Args: + all_masks: List of mask tensors. + all_boxes: List of box tensors. + all_labels: List of label tensors. + img_size: Original image size ``(height, width)``. + + Returns: + Aggregated predictions dict. + """ + non_empty_masks = [m for m in all_masks if m.numel() > 0] + non_empty_boxes = [b for b in all_boxes if b.numel() > 0] + non_empty_labels = [lb for lb in all_labels if lb.numel() > 0] + + if non_empty_masks: + return { + "pred_masks": torch.cat(non_empty_masks, dim=0), + "pred_boxes": torch.cat(non_empty_boxes, dim=0), + "pred_labels": torch.cat(non_empty_labels, dim=0), + } + return { + "pred_masks": torch.empty(0, *img_size), + "pred_boxes": torch.empty(0, 5), + "pred_labels": torch.empty(0, dtype=torch.long), + } + + def export( + self, + export_dir: str | Path = Path("./exports/sam3"), # noqa: ARG002 + backend: str = "openvino", # noqa: ARG002 + ) -> Path: + """Export is not applicable — this model already uses exported models. + + For exporting from PyTorch, use:: + + python scripts/export_sam3_openvino.py + + Args: + export_dir: Not used. + backend: Not used. + + Returns: + Path to the model directory. + """ + msg = ( + "SAM3OpenVINO already uses pre-exported models. " + "To export from PyTorch, use: python scripts/export_sam3_openvino.py" + ) + logger.info(msg) + return self.model_dir diff --git a/library/src/instantlearn/scripts/sam3/__init__.py b/library/src/instantlearn/scripts/sam3/__init__.py new file mode 100644 index 000000000..45193e808 --- /dev/null +++ b/library/src/instantlearn/scripts/sam3/__init__.py @@ -0,0 +1,4 @@ +# Copyright (C) 2025 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""scripts for converting and benchmarking SAM3 models.""" diff --git a/library/src/instantlearn/scripts/sam3/benchmark_sam3_openvino.py b/library/src/instantlearn/scripts/sam3/benchmark_sam3_openvino.py new file mode 100644 index 000000000..942099cc9 --- /dev/null +++ b/library/src/instantlearn/scripts/sam3/benchmark_sam3_openvino.py @@ -0,0 +1,1456 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""Benchmark SAM3 OpenVINO inference across model variants, prompt types, and optimizations. + +Measures component-level and end-to-end latency for live-inference scenarios: + +**Model variants benchmarked:** + - OpenVINO IR: FP16, NNCF-INT8, NNCF-INT4 + +**Prompt types:** + - Text prompt (category name → detect all instances) + - Box prompt (bounding box → segment specific ROI) + - Point-as-box prompt (point expanded to small box) + +**Scenarios:** + - Cold start: Full pipeline including vision encoder + - Warm (cached vision features): Same image, new prompts — decoder only + - Live stream: Same prompt, different images — measures per-frame throughput + +**Optimizations tested:** + - Default OpenVINO settings + - LATENCY performance hint + - Reduced inference threads + - BF16 precision hint (if supported) + +**Device support:** + - CPU (default) + - GPU — Intel iGPU/dGPU (pass ``--device GPU``). XPU users should use + ``--device GPU`` since OpenVINO maps Intel XPU as GPU device. + - AUTO — let OpenVINO select the best available device + +**Component breakdown:** + - Image preprocessing (CPU/PyTorch) + - Vision encoder (OpenVINO) + - Text encoder (OpenVINO) + - Geometry encoder (OpenVINO) — for box/point prompts + - Prompt decoder (OpenVINO) + - Postprocessing (CPU/PyTorch) + +**Output:** + - Rich terminal tables with summary, variant comparison, speedups, and FPS + - Excel file with detailed results (``sam3_benchmark_{device}_{timestamp}.xlsx``) + - PNG chart with latency comparison, component breakdown, and FPS + (requires matplotlib; use ``--no-charts`` to skip) + +Usage: + # Auto-download models from HuggingFace and benchmark (default) + python scripts/benchmark_sam3_openvino.py + + # Auto-download INT8 quantised variant + python scripts/benchmark_sam3_openvino.py --variants openvino-int8 + + # Use local model directory instead of HuggingFace + python scripts/benchmark_sam3_openvino.py --base-dir ./sam3-openvino + + # Benchmark on Intel GPU (XPU) + python scripts/benchmark_sam3_openvino.py --device GPU + + # More warmup / iterations + python scripts/benchmark_sam3_openvino.py --warmup 5 --iterations 20 +""" + +from __future__ import annotations + +import argparse +import gc +import logging +import statistics +import sys +import time +from dataclasses import dataclass, field +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np +import openvino as ov +import torch +from huggingface_hub import snapshot_download +from rich.console import Console +from rich.table import Table +from transformers import CLIPTokenizerFast + +from instantlearn.models.sam3.processing import ( + Sam3Postprocessor, + Sam3Preprocessor, + Sam3PromptPreprocessor, +) + +logger = logging.getLogger(__name__) +console = Console() + +RESOLUTION = 1008 + +# Default HuggingFace repo containing exported SAM3 OpenVINO models +SAM3_HF_REPO_ID = "rajeshgangireddy/exported_sam3" + +# Canonical model file names (v3 five-model split) +VISION_ENCODER = "vision-encoder" +TEXT_ENCODER = "text-encoder" +GEOMETRY_ENCODER = "geometry-encoder" +GEOMETRY_ENCODER_EXEMPLAR = "geometry-encoder-exemplar" +PROMPT_DECODER = "prompt-decoder" + +# Model variants to benchmark (directory name -> human label) +DEFAULT_VARIANTS: dict[str, str] = { + "openvino-fp16": "OV-FP16", + "openvino-nncf-int8": "OV-NNCF-INT8", + "openvino-nncf-int4": "OV-NNCF-INT4", +} + +# OpenVINO compile configs to benchmark (keyed by device category) +OV_CONFIGS_CPU: dict[str, dict] = { + "default": {}, + "latency-hint": {"PERFORMANCE_HINT": "LATENCY"}, + "throughput-hint": {"PERFORMANCE_HINT": "THROUGHPUT"}, +} + +# GPU configs — skip throughput-hint (multiplies VRAM usage, causes OOM) +# Enable model caching and FP16 precision hint to stabilise GPU compilation +# on Intel Arc dGPUs (e.g. B580) where the OpenCL JIT compiler can crash +# without these settings. +OV_CONFIGS_GPU: dict[str, dict] = { + "default": {"INFERENCE_PRECISION_HINT": "f16"}, + "latency-hint": {"PERFORMANCE_HINT": "LATENCY", "INFERENCE_PRECISION_HINT": "f16"}, +} + + +def _is_gpu_available() -> bool: + """Check whether an OpenVINO GPU device is available.""" + try: + core = ov.Core() + return "GPU" in core.available_devices + except Exception: # noqa: BKA001 + return False + + +def _get_ov_configs(device: str, cache_dir: Path | None = None) -> dict[str, dict]: + """Return device-appropriate compile configs. + + Args: + device: OpenVINO device string. + cache_dir: Optional model cache directory. Strongly recommended for GPU + to avoid repeated OpenCL JIT compilation which can crash on some + Intel Arc dGPUs. + """ + base = OV_CONFIGS_GPU if device.upper().startswith("GPU") else OV_CONFIGS_CPU + if cache_dir is not None: + cache_dir.mkdir(parents=True, exist_ok=True) + base = {name: {**cfg, "CACHE_DIR": str(cache_dir)} for name, cfg in base.items()} + return base + + +def _download_variant(variant: str, repo_id: str = SAM3_HF_REPO_ID) -> Path: + """Download a model variant from HuggingFace Hub and return its local path. + + Args: + variant: Variant subdirectory name (e.g. ``openvino-fp16``). + repo_id: HuggingFace repository ID. + + Returns: + Local path to the downloaded variant directory. + """ + console.print(f" Downloading [cyan]{variant}[/cyan] from [blue]{repo_id}[/blue]...") + cache_dir = snapshot_download( + repo_id=repo_id, + allow_patterns=[f"{variant}/*", "tokenizer*", "special_tokens_map*"], + ) + return Path(cache_dir) / variant + + +def _resolve_variant_path(base_dir: Path | None, variant: str) -> Path | None: + """Resolve a variant to a local directory, downloading from HF if needed. + + Args: + base_dir: Local base directory, or ``None`` for HuggingFace download. + variant: Variant subdirectory name. + + Returns: + Local path to the variant directory, or ``None`` if unavailable. + """ + if base_dir is not None: + path = base_dir / variant + if not path.is_dir(): + console.print(f"[yellow]Skipping {variant}: not found in {base_dir}[/yellow]") + return None + return path + try: + return _download_variant(variant) + except Exception: + logger.exception("Failed to download %s from HuggingFace", variant) + return None + + + +@dataclass +class TimingResult: + """Timing for a single inference run broken down by component.""" + + preprocess_ms: float = 0.0 + vision_encoder_ms: float = 0.0 + text_encoder_ms: float = 0.0 + geometry_encoder_ms: float = 0.0 + decoder_ms: float = 0.0 + postprocess_ms: float = 0.0 + + @property + def total_ms(self) -> float: + """Total end-to-end time in ms.""" + return ( + self.preprocess_ms + + self.vision_encoder_ms + + self.text_encoder_ms + + self.geometry_encoder_ms + + self.decoder_ms + + self.postprocess_ms + ) + + @property + def without_vision_ms(self) -> float: + """Time without vision encoder (cached features scenario).""" + return self.text_encoder_ms + self.geometry_encoder_ms + self.decoder_ms + self.postprocess_ms + + +@dataclass +class BenchmarkResult: + """Aggregated benchmark results for one configuration.""" + + variant: str + config_name: str + prompt_type: str + timings: list[TimingResult] = field(default_factory=list) + + def _values(self, attr: str) -> list[float]: + return [getattr(t, attr) for t in self.timings] + + def stats(self, attr: str) -> dict[str, float]: + """Return mean, median, std, min, max for a timing attribute.""" + vals = self._values(attr) + if not vals: + return {"mean": 0, "median": 0, "std": 0, "min": 0, "max": 0} + return { + "mean": statistics.mean(vals), + "median": statistics.median(vals), + "std": statistics.stdev(vals) if len(vals) > 1 else 0, + "min": min(vals), + "max": max(vals), + } + + + +class BenchmarkModel: + """Lightweight model wrapper for benchmarking individual components.""" + + def __init__( + self, + model_dir: Path, + device: str = "CPU", + config: dict | None = None, + ) -> None: + """Initialize benchmark model with compile configuration. + + Args: + model_dir: Directory containing model files. + device: OpenVINO device string. + config: Optional OpenVINO compile properties. + """ + core = ov.Core() + compile_config = config or {} + + vision_path = self._find(model_dir, VISION_ENCODER) + text_path = self._find(model_dir, TEXT_ENCODER) + geo_path = self._find(model_dir, GEOMETRY_ENCODER) + geo_ex_path = self._find(model_dir, GEOMETRY_ENCODER_EXEMPLAR) + decoder_path = self._find(model_dir, PROMPT_DECODER) + + models = [ + ("vision-encoder", vision_path), + ("text-encoder", text_path), + ("geometry-encoder", geo_path), + ("geometry-encoder-exemplar", geo_ex_path), + ("prompt-decoder", decoder_path), + ] + compiled = {} + for name, path in models: + console.print(f" Compiling [cyan]{name}[/cyan] on {device}...", end=" ") + t0 = time.perf_counter() + compiled[name] = core.compile_model(path, device, compile_config) + elapsed = time.perf_counter() - t0 + console.print(f"[green]{elapsed:.1f}s[/green]") + + self.vision_model = compiled["vision-encoder"] + self.text_model = compiled["text-encoder"] + self.geometry_model = compiled["geometry-encoder"] + self.geometry_exemplar_model = compiled["geometry-encoder-exemplar"] + self.decoder_model = compiled["prompt-decoder"] + + # Create infer requests for sync inference (avoids request creation overhead) + self.vision_request = self.vision_model.create_infer_request() + self.text_request = self.text_model.create_infer_request() + self.geometry_request = self.geometry_model.create_infer_request() + self.geometry_exemplar_request = self.geometry_exemplar_model.create_infer_request() + self.decoder_request = self.decoder_model.create_infer_request() + + # Preprocessors + self.preprocessor = Sam3Preprocessor(target_size=RESOLUTION) + self.prompt_preprocessor = Sam3PromptPreprocessor(target_size=RESOLUTION) + self.postprocessor = Sam3Postprocessor( + target_size=RESOLUTION, + threshold=0.5, + mask_threshold=0.5, + ) + + # Tokenizer — load from model_dir if available, else HuggingFace + if (model_dir / "tokenizer.json").exists(): + self.tokenizer = CLIPTokenizerFast.from_pretrained(str(model_dir)) + else: + self.tokenizer = CLIPTokenizerFast.from_pretrained(SAM3_HF_REPO_ID) + + @staticmethod + def _find(model_dir: Path, name: str) -> Path: + """Find model file (.xml preferred, then .onnx). + + Raises: + FileNotFoundError: If no matching model file is found. + """ + for ext in (".xml", ".onnx", "-fp16.onnx"): + candidate = model_dir / f"{name}{ext}" + if candidate.exists(): + return candidate + # glob fallback + variants = sorted(model_dir.glob(f"{name}*.onnx")) + if variants: + return variants[0] + msg = f"Model '{name}' not found in {model_dir}" + raise FileNotFoundError(msg) + + def run_preprocess( + self, + image: torch.Tensor, + ) -> tuple[np.ndarray, list[tuple[int, int]], float]: + """Preprocess image; returns (pixel_values_np, original_sizes, elapsed_ms).""" + t0 = time.perf_counter() + image_4d = image.unsqueeze(0) if image.ndim == 3 else image + with torch.no_grad(): + pixel_values, original_sizes = self.preprocessor(image_4d) + pixel_np = pixel_values.numpy() + elapsed = (time.perf_counter() - t0) * 1000 + return pixel_np, original_sizes, elapsed + + def run_vision_encoder(self, pixel_values: np.ndarray) -> tuple[dict[str, np.ndarray], float]: + """Run vision encoder; returns (features_dict, elapsed_ms).""" + t0 = time.perf_counter() + self.vision_request.infer([pixel_values]) + result = { + "fpn_feat_0": self.vision_request.get_tensor("fpn_feat_0").data, + "fpn_feat_1": self.vision_request.get_tensor("fpn_feat_1").data, + "fpn_feat_2": self.vision_request.get_tensor("fpn_feat_2").data, + "fpn_pos_2": self.vision_request.get_tensor("fpn_pos_2").data, + } + elapsed = (time.perf_counter() - t0) * 1000 + return result, elapsed + + def run_text_encoder( + self, + text: str, + ) -> tuple[np.ndarray, np.ndarray, float]: + """Run text encoder; returns (text_features, text_mask, elapsed_ms).""" + tokens = self.tokenizer([text], return_tensors="np", padding=True) + input_ids = _pad_or_truncate(tokens.input_ids.astype(np.int64), 32) + attention_mask = _pad_or_truncate(tokens.attention_mask.astype(np.int64), 32) + + t0 = time.perf_counter() + self.text_request.infer([input_ids, attention_mask]) + text_features = self.text_request.get_tensor("text_features").data + text_mask = self.text_request.get_tensor("text_mask").data + elapsed = (time.perf_counter() - t0) * 1000 + return text_features, text_mask, elapsed + + def run_geometry_encoder( + self, + vision_features: dict[str, np.ndarray], + input_boxes: np.ndarray, + input_boxes_labels: np.ndarray, + input_points: np.ndarray, + input_points_labels: np.ndarray, + *, + exemplar: bool = False, + ) -> tuple[np.ndarray, np.ndarray, float]: + """Run geometry encoder; returns (geometry_features, geometry_mask, elapsed_ms).""" + request = self.geometry_exemplar_request if exemplar else self.geometry_request + t0 = time.perf_counter() + request.infer([ + vision_features["fpn_feat_2"], + vision_features["fpn_pos_2"], + input_boxes, + input_boxes_labels, + input_points, + input_points_labels, + ]) + geo_features = request.get_tensor("geometry_features").data + geo_mask = request.get_tensor("geometry_mask").data + elapsed = (time.perf_counter() - t0) * 1000 + return geo_features, geo_mask, elapsed + + def run_prompt_decoder( + self, + vision_features: dict[str, np.ndarray], + prompt_features: np.ndarray, + prompt_mask: np.ndarray, + ) -> tuple[dict[str, np.ndarray], float]: + """Run prompt decoder; returns (outputs_dict, elapsed_ms).""" + t0 = time.perf_counter() + self.decoder_request.infer([ + vision_features["fpn_feat_0"], + vision_features["fpn_feat_1"], + vision_features["fpn_feat_2"], + vision_features["fpn_pos_2"], + prompt_features, + prompt_mask, + ]) + result = { + "pred_masks": self.decoder_request.get_tensor("pred_masks").data, + "pred_boxes": self.decoder_request.get_tensor("pred_boxes").data, + "pred_logits": self.decoder_request.get_tensor("pred_logits").data, + "presence_logits": self.decoder_request.get_tensor("presence_logits").data, + } + elapsed = (time.perf_counter() - t0) * 1000 + return result, elapsed + + def run_postprocess( + self, + decoder_outputs: dict[str, np.ndarray], + img_size: tuple[int, int], + ) -> tuple[dict, float]: + """Run postprocessing; returns (results_dict, elapsed_ms).""" + t0 = time.perf_counter() + outputs_torch = {k: torch.from_numpy(np.array(v)) for k, v in decoder_outputs.items()} + with torch.no_grad(): + result = self.postprocessor(outputs_torch, target_sizes=[img_size]) + elapsed = (time.perf_counter() - t0) * 1000 + return result[0], elapsed + + + +def _pad_or_truncate(arr: np.ndarray, target_len: int) -> np.ndarray: + """Pad or truncate array to target sequence length.""" + cur = arr.shape[1] + if cur == target_len: + return arr + if cur > target_len: + return arr[:, :target_len] + pad = np.zeros((arr.shape[0], target_len - cur), dtype=arr.dtype) + return np.concatenate([arr, pad], axis=1) + + +def _make_dummy_image(h: int = 720, w: int = 1280) -> torch.Tensor: + """Create a realistic-sized dummy image tensor [3, H, W].""" + rng = np.random.default_rng(42) + img = rng.integers(0, 255, (h, w, 3), dtype=np.uint8) + return torch.from_numpy(img).permute(2, 0, 1).float() / 255.0 + + +def _make_real_image(image_path: Path) -> torch.Tensor | None: + """Load a real image, or return None if not found.""" + if not image_path.exists(): + return None + import cv2 # noqa: PLC0415 + + img = cv2.imread(str(image_path)) + if img is None: + return None + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + return torch.from_numpy(img).permute(2, 0, 1).float() / 255.0 + + +def _sentinel_box() -> tuple[np.ndarray, np.ndarray]: + """Return sentinel box inputs (no box prompt).""" + boxes = np.zeros((1, 1, 4), dtype=np.float32) + labels = np.full((1, 1), -10, dtype=np.int64) + return boxes, labels + + +def _sentinel_points() -> tuple[np.ndarray, np.ndarray]: + """Return sentinel point inputs (no point prompt).""" + points = np.zeros((1, 1, 2), dtype=np.float32) + labels = np.full((1, 1), -10, dtype=np.int64) + return points, labels + + +def _real_box( + preprocessor: Sam3PromptPreprocessor, + bbox: np.ndarray, + original_sizes: list[tuple[int, int]], +) -> tuple[np.ndarray, np.ndarray]: + """Convert a xyxy bbox to the model's normalized cxcywh format.""" + with torch.no_grad(): + box_tensor, _ = preprocessor(original_sizes, input_boxes=bbox) + boxes = box_tensor.numpy().astype(np.float32) + labels = np.ones((1, boxes.shape[1]), dtype=np.int64) + return boxes, labels + + + +def benchmark_single_inference( + model: BenchmarkModel, + image: torch.Tensor, + text: str, + bbox: np.ndarray | None = None, +) -> TimingResult: + """Run one complete inference pass and time each component.""" + img_size = image.shape[-2:] + + # 1. Preprocess + pixel_np, original_sizes, t_pre = model.run_preprocess(image) + + # 2. Vision encoder + vision_features, t_vis = model.run_vision_encoder(pixel_np) + + # 3. Text encoder + text_features, text_mask, t_txt = model.run_text_encoder(text) + + # 4. Geometry encoder (box/point prompts) or text-only + t_geo = 0.0 + if bbox is not None: + input_boxes, input_boxes_labels = _real_box( + model.prompt_preprocessor, + bbox, + original_sizes, + ) + input_points, input_points_labels = _sentinel_points() + + geo_features, geo_mask, t_geo = model.run_geometry_encoder( + vision_features, + input_boxes, + input_boxes_labels, + input_points, + input_points_labels, + ) + + # Concatenate text + geometry features + prompt_features = np.concatenate( + [text_features, geo_features], + axis=1, + ).astype(np.float32) + prompt_mask = np.concatenate( + [text_mask.astype(bool), geo_mask.astype(bool)], + axis=1, + ) + else: + prompt_features = text_features.astype(np.float32) + prompt_mask = text_mask.astype(bool) + + # 5. Prompt decoder + decoder_outputs, t_dec = model.run_prompt_decoder( + vision_features, + prompt_features, + prompt_mask, + ) + + # 6. Postprocess + _, t_post = model.run_postprocess(decoder_outputs, img_size) + + return TimingResult( + preprocess_ms=t_pre, + vision_encoder_ms=t_vis, + text_encoder_ms=t_txt, + geometry_encoder_ms=t_geo, + decoder_ms=t_dec, + postprocess_ms=t_post, + ) + + +def benchmark_cached_vision( + model: BenchmarkModel, + image: torch.Tensor, + text: str, + bbox: np.ndarray | None = None, + iterations: int = 20, +) -> list[TimingResult]: + """Benchmark decoder-only inference with cached vision & text features. + + Simulates the scenario where vision encoder output is cached (same + image) and text encoder output is cached (same prompt). Only geometry + encoder (if box/point) + prompt decoder + postprocess run per iteration. + """ + img_size = image.shape[-2:] + + # Pre-compute everything that can be cached + pixel_np, original_sizes, _ = model.run_preprocess(image) + vision_features, _ = model.run_vision_encoder(pixel_np) + text_features, text_mask, _ = model.run_text_encoder(text) + + has_geometry = bbox is not None + if has_geometry: + input_boxes, input_boxes_labels = _real_box( + model.prompt_preprocessor, + bbox, + original_sizes, + ) + input_points, input_points_labels = _sentinel_points() + + results: list[TimingResult] = [] + for _ in range(iterations): + t_geo = 0.0 + if has_geometry: + geo_features, geo_mask, t_geo = model.run_geometry_encoder( + vision_features, + input_boxes, + input_boxes_labels, + input_points, + input_points_labels, + ) + prompt_features = np.concatenate( + [text_features, geo_features], + axis=1, + ).astype(np.float32) + prompt_mask = np.concatenate( + [text_mask.astype(bool), geo_mask.astype(bool)], + axis=1, + ) + else: + prompt_features = text_features.astype(np.float32) + prompt_mask = text_mask.astype(bool) + + decoder_outputs, t_dec = model.run_prompt_decoder( + vision_features, + prompt_features, + prompt_mask, + ) + _, t_post = model.run_postprocess(decoder_outputs, img_size) + results.append( + TimingResult( + geometry_encoder_ms=t_geo, + decoder_ms=t_dec, + postprocess_ms=t_post, + ), + ) + return results + + +def benchmark_live_stream( + model: BenchmarkModel, + images: list[torch.Tensor], + text: str, + iterations: int = 10, +) -> list[TimingResult]: + """Benchmark live-stream scenario: same prompt, different images. + + Text encoder output is cached; vision encoder runs per frame. + Text-only prompt — no geometry encoder. + """ + # Cache text features once + text_features, text_mask, _ = model.run_text_encoder(text) + prompt_features = text_features.astype(np.float32) + prompt_mask = text_mask.astype(bool) + + results: list[TimingResult] = [] + img_cycle = images * ((iterations // len(images)) + 1) + + for i in range(iterations): + image = img_cycle[i % len(img_cycle)] + img_size = image.shape[-2:] + + pixel_np, _orig, t_pre = model.run_preprocess(image) + vision_features, t_vis = model.run_vision_encoder(pixel_np) + + decoder_outputs, t_dec = model.run_prompt_decoder( + vision_features, + prompt_features, + prompt_mask, + ) + _, t_post = model.run_postprocess(decoder_outputs, img_size) + + results.append( + TimingResult( + preprocess_ms=t_pre, + vision_encoder_ms=t_vis, + decoder_ms=t_dec, + postprocess_ms=t_post, + ), + ) + return results + + + +def _benchmark_variant_config( + model: BenchmarkModel, + label: str, + config_name: str, + prompt_configs: list[tuple[str, str, np.ndarray | None]], + primary_image: torch.Tensor, + real_images: list[torch.Tensor], + warmup: int, + iterations: int, + live_frames: int, +) -> list[BenchmarkResult]: + """Run all benchmarks for one variant + config combination.""" + results: list[BenchmarkResult] = [] + + for prompt_label, text, bbox in prompt_configs: + console.print(f" [green]{prompt_label}[/green] prompt — warmup({warmup}) + measure({iterations})") + + # Warmup + for _ in range(warmup): + benchmark_single_inference(model, primary_image, text, bbox) + + # Full pipeline (cold per-image) + result = BenchmarkResult( + variant=label, + config_name=config_name, + prompt_type=prompt_label, + ) + for _ in range(iterations): + timing = benchmark_single_inference(model, primary_image, text, bbox) + result.timings.append(timing) + results.append(result) + + # Cached vision features (decoder-only) + cached_result = BenchmarkResult( + variant=label, + config_name=config_name, + prompt_type=f"{prompt_label}(cached-vis)", + ) + cached_timings = benchmark_cached_vision( + model, + primary_image, + text, + bbox, + iterations=iterations, + ) + cached_result.timings = cached_timings + results.append(cached_result) + + console.print(f" [green]live-stream[/green] — warmup({warmup}) + measure({live_frames})") + + # Warmup + for _ in range(warmup): + benchmark_single_inference(model, real_images[0], "elephant", None) + + live_result = BenchmarkResult( + variant=label, + config_name=config_name, + prompt_type="live-stream", + ) + live_timings = benchmark_live_stream( + model, + real_images, + "elephant", + iterations=live_frames, + ) + live_result.timings = live_timings + results.append(live_result) + + return results + + +def run_benchmarks( + base_dir: Path | None, + variants: list[str], + device: str = "CPU", + warmup: int = 3, + iterations: int = 10, + live_frames: int = 15, + ov_configs: dict[str, dict] | None = None, +) -> list[BenchmarkResult]: + """Run all benchmarks across variants, prompt types, and configs.""" + # Prepare images + coco_dir = Path("examples/assets/coco") + real_images: list[torch.Tensor] = [] + for img_file in sorted(coco_dir.glob("*.jpg"))[:4]: + img = _make_real_image(img_file) + if img is not None: + real_images.append(img) + + if not real_images: + console.print("[yellow]No real images found, using dummy images[/yellow]") + real_images = [_make_dummy_image() for _ in range(3)] + + primary_image = real_images[0] + + # A box prompt (bounding box in xyxy for an elephant in 000000286874.jpg) + sample_bbox = np.array([[216, 184, 458, 436]]) + + # Point-as-box (expand a point to a small 20x20 box) + point_center = np.array([337, 310]) # center of elephant + half = 10 + point_bbox = np.array([ + [ + point_center[0] - half, + point_center[1] - half, + point_center[0] + half, + point_center[1] + half, + ], + ]) + + # Prompt configurations: (label, text, bbox_or_none) + prompt_configs: list[tuple[str, str, np.ndarray | None]] = [ + ("text", "elephant", None), + ("box", "visual", sample_bbox), + ("point-as-box", "visual", point_bbox), + ] + + all_results: list[BenchmarkResult] = [] + + for variant_dir_name in variants: + # Resolve variant path: local directory or auto-download from HuggingFace + variant_path = _resolve_variant_path(base_dir, variant_dir_name) + if variant_path is None: + continue + + label = DEFAULT_VARIANTS.get(variant_dir_name, variant_dir_name) + + if ov_configs is None: + ov_configs = _get_ov_configs(device) + for config_name, config in ov_configs.items(): + console.rule(f"[bold cyan]{label} — {config_name}[/bold cyan]") + + try: + model = BenchmarkModel(variant_path, device, config) + except Exception: + logger.exception("Failed to load %s with config %s", variant_dir_name, config_name) + continue + + try: + variant_results = _benchmark_variant_config( + model=model, + label=label, + config_name=config_name, + prompt_configs=prompt_configs, + primary_image=primary_image, + real_images=real_images, + warmup=warmup, + iterations=iterations, + live_frames=live_frames, + ) + all_results.extend(variant_results) + except RuntimeError as exc: + console.print(f"[red]Runtime error for {label}/{config_name}: {exc}[/red]") + console.print("[yellow]Skipping — likely GPU out-of-memory[/yellow]") + continue + + # Cleanup + del model + gc.collect() + + return all_results + + + +def print_summary_table(results: list[BenchmarkResult]) -> None: + """Print a rich summary table of all benchmark results.""" + table = Table( + title="SAM3 OpenVINO Benchmark Results (ms)", + show_header=True, + header_style="bold cyan", + ) + table.add_column("Variant", style="cyan", width=16) + table.add_column("Config", width=16) + table.add_column("Prompt", width=18) + table.add_column("Preproc", justify="right") + table.add_column("Vision Enc", justify="right") + table.add_column("Text Enc", justify="right") + table.add_column("Geo Enc", justify="right") + table.add_column("Decoder", justify="right") + table.add_column("Postproc", justify="right") + table.add_column("Total", justify="right", style="bold") + table.add_column("w/o Vision", justify="right", style="green") + table.add_column("FPS", justify="right", style="magenta") + + for r in results: + s_pre = r.stats("preprocess_ms") + s_vis = r.stats("vision_encoder_ms") + s_txt = r.stats("text_encoder_ms") + s_geo = r.stats("geometry_encoder_ms") + s_dec = r.stats("decoder_ms") + s_post = r.stats("postprocess_ms") + s_total = r.stats("total_ms") + s_novis = r.stats("without_vision_ms") + + total_mean = s_total["mean"] + fps = 1000.0 / total_mean if total_mean > 0 else 0 + + table.add_row( + r.variant, + r.config_name, + r.prompt_type, + f"{s_pre['mean']:.1f}", + f"{s_vis['mean']:.1f}", + f"{s_txt['mean']:.1f}", + f"{s_geo['mean']:.1f}", + f"{s_dec['mean']:.1f}", + f"{s_post['mean']:.1f}", + f"{s_total['mean']:.1f}", + f"{s_novis['mean']:.1f}", + f"{fps:.2f}", + ) + + console.print(table) + + +def print_component_detail(results: list[BenchmarkResult]) -> None: + """Print detailed component statistics for each benchmark.""" + for r in results: + console.print( + f"\n[bold]{r.variant} | {r.config_name} | {r.prompt_type}[/bold]", + ) + detail_table = Table(show_header=True, box=None, pad_edge=False) + detail_table.add_column("Component", width=18) + detail_table.add_column("Mean", justify="right") + detail_table.add_column("Median", justify="right") + detail_table.add_column("Std", justify="right") + detail_table.add_column("Min", justify="right") + detail_table.add_column("Max", justify="right") + + for attr_name, label in [ + ("preprocess_ms", "Preprocess"), + ("vision_encoder_ms", "Vision Encoder"), + ("text_encoder_ms", "Text Encoder"), + ("geometry_encoder_ms", "Geometry Encoder"), + ("decoder_ms", "Prompt Decoder"), + ("postprocess_ms", "Postprocess"), + ("total_ms", "TOTAL"), + ("without_vision_ms", "w/o Vision"), + ]: + s = r.stats(attr_name) + style = "bold" if attr_name == "total_ms" else "" + detail_table.add_row( + label, + f"{s['mean']:.1f}", + f"{s['median']:.1f}", + f"{s['std']:.1f}", + f"{s['min']:.1f}", + f"{s['max']:.1f}", + style=style, + ) + console.print(detail_table) + + +def print_comparison_matrix(results: list[BenchmarkResult]) -> None: + """Print a compact variant x prompt comparison (default config only).""" + # Filter to default config, full pipeline only (not cached / live-stream) + default_results = [ + r + for r in results + if r.config_name == "default" and "cached" not in r.prompt_type and r.prompt_type != "live-stream" + ] + + if not default_results: + return + + table = Table(title="Variant x Prompt Comparison (default config, ms)", show_header=True) + table.add_column("Variant", style="cyan", width=16) + + prompt_types = sorted({r.prompt_type for r in default_results}) + for pt in prompt_types: + table.add_column(f"{pt} (total)", justify="right") + table.add_column(f"{pt} (geo+dec)", justify="right") + + variant_names = sorted({r.variant for r in default_results}) + for variant in variant_names: + row = [variant] + for pt in prompt_types: + match = [r for r in default_results if r.variant == variant and r.prompt_type == pt] + if match: + s_total = match[0].stats("total_ms") + s_geo = match[0].stats("geometry_encoder_ms") + s_dec = match[0].stats("decoder_ms") + geo_dec = s_geo["mean"] + s_dec["mean"] + row.extend([f"{s_total['mean']:.1f}", f"{geo_dec:.1f}"]) + else: + row.extend(["—", "—"]) + table.add_row(*row) + + console.print(table) + + +def print_speedup_summary(results: list[BenchmarkResult]) -> None: + """Print speedup of quantized variants relative to FP16 (default config).""" + default_full = [ + r + for r in results + if r.config_name == "default" + and "cached" not in r.prompt_type + and r.prompt_type != "live-stream" + and r.prompt_type == "text" + ] + + fp16 = [r for r in default_full if "FP16" in r.variant and "ONNX" not in r.variant] + if not fp16: + return + + baseline = fp16[0].stats("total_ms")["mean"] + baseline_vis = fp16[0].stats("vision_encoder_ms")["mean"] + + table = Table(title="Speedup vs OV-FP16 (text prompt, default config)", show_header=True) + table.add_column("Variant", style="cyan", width=16) + table.add_column("Total (ms)", justify="right") + table.add_column("Speedup", justify="right", style="green") + table.add_column("Vision Enc (ms)", justify="right") + table.add_column("Vis Speedup", justify="right", style="green") + + for r in default_full: + total = r.stats("total_ms")["mean"] + vis = r.stats("vision_encoder_ms")["mean"] + total_speedup = baseline / total if total > 0 else 0 + vis_speedup = baseline_vis / vis if vis > 0 else 0 + + table.add_row( + r.variant, + f"{total:.1f}", + f"{total_speedup:.2f}x", + f"{vis:.1f}", + f"{vis_speedup:.2f}x", + ) + + console.print(table) + + +def print_live_fps_table(results: list[BenchmarkResult]) -> None: + """Print live-stream FPS comparison across variants and configs.""" + live_results = [r for r in results if r.prompt_type == "live-stream"] + if not live_results: + return + + table = Table(title="Live Stream FPS (text prompt, cached text encoder)", show_header=True) + table.add_column("Variant", style="cyan", width=16) + table.add_column("Config", width=16) + table.add_column("Total (ms)", justify="right") + table.add_column("Vision (ms)", justify="right") + table.add_column("Decoder (ms)", justify="right") + table.add_column("FPS", justify="right", style="bold magenta") + + for r in live_results: + s = r.stats("total_ms") + s_vis = r.stats("vision_encoder_ms") + s_dec = r.stats("decoder_ms") + fps = 1000.0 / s["mean"] if s["mean"] > 0 else 0 + + table.add_row( + r.variant, + r.config_name, + f"{s['mean']:.1f}", + f"{s_vis['mean']:.1f}", + f"{s_dec['mean']:.1f}", + f"{fps:.1f}", + ) + + console.print(table) + + + +def _get_device_full_name(device: str) -> str: + """Get the full device name as reported by OpenVINO. + + Args: + device: OpenVINO device string (e.g. ``CPU``, ``GPU``). + + Returns: + Human-readable device name (e.g. ``Intel Core Ultra 7 265K``). + """ + core = ov.Core() + try: + return core.get_property(device, "FULL_DEVICE_NAME") + except RuntimeError: + return device + + +def save_charts( + results: list[BenchmarkResult], + device: str, + output_dir: Path, +) -> Path | None: + """Generate benchmark comparison charts and save as PNG. + + Creates a multi-panel figure with: + - Bar chart: mean end-to-end latency per variant and prompt type + - Bar chart: component breakdown (stacked) per variant + - Bar chart: live-stream FPS per variant + + Args: + results: Benchmark results to visualize. + device: OpenVINO device string used for benchmarking. + output_dir: Directory to write the chart PNG. + + Returns: + Path to the saved chart, or ``None`` if matplotlib is unavailable. + """ + try: + import matplotlib # noqa: PLC0415 + + matplotlib.use("Agg") + import matplotlib.pyplot as plt # noqa: PLC0415 + except ImportError: + console.print("[yellow]matplotlib not installed — skipping chart generation[/yellow]") + return None + + output_dir.mkdir(parents=True, exist_ok=True) + device_name = _get_device_full_name(device) + + # Filter to default config for cleaner charts + default_full = [ + r + for r in results + if r.config_name == "default" and "cached" not in r.prompt_type and r.prompt_type != "live-stream" + ] + live_results = [r for r in results if r.prompt_type == "live-stream" and r.config_name == "default"] + + if not default_full: + console.print("[yellow]No default-config results for charting[/yellow]") + return None + + fig, axes = plt.subplots(1, 3, figsize=(18, 6)) + fig.suptitle(f"SAM3 OpenVINO Benchmark — {device_name}", fontsize=14, fontweight="bold") + + # --- Panel 1: End-to-end latency by variant × prompt type --- + ax1 = axes[0] + variants = sorted({r.variant for r in default_full}) + prompt_types = sorted({r.prompt_type for r in default_full}) + bar_width = 0.8 / max(len(prompt_types), 1) + + x = np.arange(len(variants)) + for i, pt in enumerate(prompt_types): + means = [] + for v in variants: + match = [r for r in default_full if r.variant == v and r.prompt_type == pt] + means.append(match[0].stats("total_ms")["mean"] if match else 0) + ax1.bar(x + i * bar_width, means, bar_width, label=pt) + + ax1.set_xlabel("Model Variant") + ax1.set_ylabel("Latency (ms)") + ax1.set_title("End-to-End Latency") + ax1.set_xticks(x + bar_width * (len(prompt_types) - 1) / 2) + ax1.set_xticklabels(variants, rotation=15, ha="right", fontsize=9) + ax1.legend(fontsize=8) + ax1.grid(axis="y", alpha=0.3) + + # --- Panel 2: Component breakdown (stacked bar, text prompt) --- + ax2 = axes[1] + text_results = [r for r in default_full if r.prompt_type == "text"] + components = [ + ("preprocess_ms", "Preprocess"), + ("vision_encoder_ms", "Vision Encoder"), + ("text_encoder_ms", "Text Encoder"), + ("geometry_encoder_ms", "Geometry Encoder"), + ("decoder_ms", "Decoder"), + ("postprocess_ms", "Postprocess"), + ] + colors = ["#4c72b0", "#55a868", "#c44e52", "#8172b2", "#ccb974", "#64b5cd"] + + text_variants = [r.variant for r in text_results] + x2 = np.arange(len(text_variants)) + bottom = np.zeros(len(text_variants)) + + for (attr, label), color in zip(components, colors, strict=False): + vals = [r.stats(attr)["mean"] for r in text_results] + ax2.bar(x2, vals, bottom=bottom, label=label, color=color, width=0.6) + bottom += np.array(vals) + + ax2.set_xlabel("Model Variant") + ax2.set_ylabel("Latency (ms)") + ax2.set_title("Component Breakdown (text prompt)") + ax2.set_xticks(x2) + ax2.set_xticklabels(text_variants, rotation=15, ha="right", fontsize=9) + ax2.legend(fontsize=7, loc="upper left") + ax2.grid(axis="y", alpha=0.3) + + # --- Panel 3: Live-stream FPS --- + ax3 = axes[2] + if live_results: + live_variants = [r.variant for r in live_results] + fps_values = [1000.0 / r.stats("total_ms")["mean"] if r.stats("total_ms")["mean"] > 0 else 0 for r in live_results] + x3 = np.arange(len(live_variants)) + bars = ax3.bar(x3, fps_values, color="#55a868", width=0.6) + + for bar, fps in zip(bars, fps_values, strict=False): + ax3.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.1, f"{fps:.1f}", ha="center", va="bottom", fontsize=9) + + ax3.set_xlabel("Model Variant") + ax3.set_ylabel("FPS") + ax3.set_title("Live Stream FPS (text prompt)") + ax3.set_xticks(x3) + ax3.set_xticklabels(live_variants, rotation=15, ha="right", fontsize=9) + ax3.grid(axis="y", alpha=0.3) + else: + ax3.text(0.5, 0.5, "No live-stream data", transform=ax3.transAxes, ha="center", va="center") + ax3.set_title("Live Stream FPS") + + plt.tight_layout() + + device_tag = device.lower().replace(".", "_") + timestamp = datetime.now(tz=timezone.utc).strftime("%Y%m%d_%H%M%S") + chart_path = output_dir / f"sam3_benchmark_{device_tag}_{timestamp}.png" + fig.savefig(chart_path, dpi=150, bbox_inches="tight") + plt.close(fig) + + console.print(f"[bold green]Chart saved to:[/bold green] {chart_path}") + return chart_path + + +def _results_to_dataframe(results: list[BenchmarkResult]): # noqa: ANN202 + """Convert benchmark results to a pandas DataFrame with per-row statistics. + + Each row represents one (variant, config, prompt_type) combination with + mean, median, std, min, max for every timing component. + + Requires ``pandas`` (install with ``uv pip install pandas``). + + Raises: + ImportError: If ``pandas`` is not installed. + """ + try: + import pandas as pd # noqa: PLC0415 + except ImportError as exc: + msg = "pandas is required to export results. Install it with: uv pip install pandas openpyxl" + raise ImportError(msg) from exc + + rows: list[dict[str, object]] = [] + + components = [ + ("preprocess_ms", "Preprocess"), + ("vision_encoder_ms", "Vision Encoder"), + ("text_encoder_ms", "Text Encoder"), + ("geometry_encoder_ms", "Geometry Encoder"), + ("decoder_ms", "Prompt Decoder"), + ("postprocess_ms", "Postprocess"), + ("total_ms", "Total"), + ("without_vision_ms", "w/o Vision"), + ] + + for r in results: + row: dict[str, object] = { + "Variant": r.variant, + "Config": r.config_name, + "Prompt": r.prompt_type, + "Iterations": len(r.timings), + } + total_mean = r.stats("total_ms")["mean"] + row["FPS"] = round(1000.0 / total_mean, 2) if total_mean > 0 else 0 + + for attr, label in components: + s = r.stats(attr) + row[f"{label} Mean (ms)"] = round(s["mean"], 2) + row[f"{label} Median (ms)"] = round(s["median"], 2) + row[f"{label} Std (ms)"] = round(s["std"], 2) + row[f"{label} Min (ms)"] = round(s["min"], 2) + row[f"{label} Max (ms)"] = round(s["max"], 2) + + rows.append(row) + + return pd.DataFrame(rows) + + +def save_results( + results: list[BenchmarkResult], + device: str, + output_dir: Path, +) -> Path: + """Save benchmark results to an Excel file. + + The file is named ``sam3_benchmark_{device}_{timestamp}.xlsx`` and includes + a metadata row with the device name as reported by OpenVINO. + + Args: + results: Benchmark results to save. + device: OpenVINO device string used for benchmarking. + output_dir: Directory to write the output file. + + Returns: + Path to the saved file. + + Raises: + ImportError: If ``pandas`` or ``openpyxl`` is not installed. + """ + output_dir.mkdir(parents=True, exist_ok=True) + + device_name = _get_device_full_name(device) + timestamp = datetime.now(tz=timezone.utc).strftime("%Y%m%d_%H%M%S") + device_tag = device.lower().replace(".", "_") + filename = f"sam3_benchmark_{device_tag}_{timestamp}.xlsx" + filepath = output_dir / filename + + try: + import pandas as pd # noqa: PLC0415 + except ImportError as exc: + msg = "pandas and openpyxl are required to save results. Install with: uv pip install pandas openpyxl" + raise ImportError(msg) from exc + + dataframe = _results_to_dataframe(results) + + # Metadata DataFrame + meta_df = pd.DataFrame([ + {"Key": "Device", "Value": device}, + {"Key": "Device Full Name", "Value": device_name}, + {"Key": "Timestamp (UTC)", "Value": timestamp}, + {"Key": "OpenVINO Version", "Value": ov.get_version()}, + ]) + + with pd.ExcelWriter(filepath, engine="openpyxl") as writer: + meta_df.to_excel(writer, sheet_name="Device Info", index=False) + dataframe.to_excel(writer, sheet_name="Benchmark Results", index=False) + + console.print(f"\n[bold green]Results saved to:[/bold green] {filepath}") + console.print(f" Device: [cyan]{device_name}[/cyan]") + return filepath + + + +def _build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + description="Benchmark SAM3 OpenVINO inference latency.", + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument( + "--base-dir", + type=Path, + default=None, + help=( + "Local directory with model variant subdirectories." + " If omitted, models are auto-downloaded from HuggingFace." + ), + ) + parser.add_argument( + "--variants", + nargs="+", + default=list(DEFAULT_VARIANTS.keys()), + help="Model variant directory names to benchmark.", + ) + parser.add_argument( + "--device", + type=str, + default="CPU", + help='OpenVINO device: "CPU", "GPU" (Intel iGPU/dGPU/XPU), or "AUTO". Default: CPU', + ) + parser.add_argument( + "--warmup", + type=int, + default=3, + help="Number of warmup iterations before measurement.", + ) + parser.add_argument( + "--iterations", + type=int, + default=10, + help="Number of measured iterations per benchmark.", + ) + parser.add_argument( + "--live-frames", + type=int, + default=15, + help="Number of frames for live-stream benchmark.", + ) + parser.add_argument( + "--detail", + action="store_true", + help="Print detailed per-component statistics.", + ) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("./benchmark_results"), + help="Directory to save benchmark results Excel file. Default: ./benchmark_results", + ) + parser.add_argument( + "--no-charts", + action="store_true", + help="Skip chart generation (requires matplotlib).", + ) + parser.add_argument( + "--cache-dir", + type=Path, + default=None, + help=( + "OpenVINO model cache directory. Caches compiled GPU kernels so " + "JIT compilation only runs once. Strongly recommended for GPU to " + "avoid driver crashes. Default: auto-set to ./ov_cache for GPU." + ), + ) + return parser + + +def main() -> None: + """CLI entry point.""" + parser = _build_parser() + args = parser.parse_args() + + logging.basicConfig( + level=logging.INFO, + format="%(levelname)s - %(name)s: %(message)s", + stream=sys.stdout, + force=True, + ) + + console.rule("[bold]SAM3 OpenVINO Benchmark[/bold]") + device_name = _get_device_full_name(args.device) + console.print(f"Device: {args.device} ([cyan]{device_name}[/cyan])") + if _is_gpu_available(): + gpu_name = _get_device_full_name("GPU") + console.print(f"Intel GPU available: [cyan]{gpu_name}[/cyan]") + console.print(f"Warmup: {args.warmup}, Iterations: {args.iterations}, Live frames: {args.live_frames}") + console.print(f"Variants: {args.variants}") + if args.base_dir is not None: + console.print(f"Model source: local ({args.base_dir})") + else: + console.print(f"Model source: HuggingFace ({SAM3_HF_REPO_ID})") + + # Default to ./ov_cache for GPU if no cache dir specified + cache_dir: Path | None = args.cache_dir + if cache_dir is None and args.device.upper().startswith("GPU"): + cache_dir = Path("./ov_cache") + console.print(f"[yellow]GPU detected — enabling model cache: {cache_dir}[/yellow]") + + ov_configs = _get_ov_configs(args.device, cache_dir=cache_dir) + console.print(f"OV configs: {list(ov_configs.keys())}") + console.print() + + results = run_benchmarks( + base_dir=args.base_dir, + variants=args.variants, + device=args.device, + warmup=args.warmup, + iterations=args.iterations, + live_frames=args.live_frames, + ov_configs=ov_configs, + ) + + if not results: + console.print("[red]No benchmark results collected.[/red]") + return + + console.rule("[bold]Summary[/bold]") + print_summary_table(results) + + console.rule("[bold]Variant x Prompt Comparison[/bold]") + print_comparison_matrix(results) + + console.rule("[bold]Speedup vs FP16[/bold]") + print_speedup_summary(results) + + console.rule("[bold]Live Stream FPS[/bold]") + print_live_fps_table(results) + + if args.detail: + console.rule("[bold]Detailed Statistics[/bold]") + print_component_detail(results) + + # Save results to Excel + save_results(results, args.device, args.output_dir) + + # Generate comparison charts + if not args.no_charts: + save_charts(results, args.device, args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/library/src/instantlearn/scripts/sam3/convert_sam3_to_openvino.py b/library/src/instantlearn/scripts/sam3/convert_sam3_to_openvino.py new file mode 100644 index 000000000..8ddd8fa9d --- /dev/null +++ b/library/src/instantlearn/scripts/sam3/convert_sam3_to_openvino.py @@ -0,0 +1,332 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""Convert SAM3 ONNX models to OpenVINO IR format. + +Expects a 5-model split (exported via ``export_sam3_openvino.py``):: + + vision-encoder.onnx + text-encoder.onnx + geometry-encoder.onnx + geometry-encoder-exemplar.onnx + prompt-decoder.onnx + +Usage: + # Convert local ONNX models to OpenVINO IR + python convert_sam3_to_openvino.py --onnx-dir ./onnx-models --output-dir ./openvino-models + + # Convert with FP16 compression + python convert_sam3_to_openvino.py --onnx-dir ./onnx-models --output-dir ./openvino-models --precision fp16 + +Note: + To export from PyTorch, use ``export_sam3_openvino.py`` first. +""" + +import argparse +import logging +import shutil +import sys +from pathlib import Path + +import numpy as np +import openvino as ov + +logger = logging.getLogger(__name__) + +# Canonical model names (5-model split from export_sam3_openvino.py) +OV_MODEL_NAMES = [ + "vision-encoder", + "text-encoder", + "geometry-encoder", + "geometry-encoder-exemplar", + "prompt-decoder", +] + + +def _find_onnx_file(onnx_dir: Path, name: str) -> Path | None: + """Find an ONNX file by base name, trying fp32 then fp16 variants. + + Args: + onnx_dir: Directory to search. + name: Base model name (without extension). + + Returns: + Path to found file, or ``None``. + """ + for suffix in (f"{name}.onnx", f"{name}-fp16.onnx"): + candidate = onnx_dir / suffix + if candidate.exists(): + return candidate + return None + + +def find_onnx_models(onnx_dir: Path) -> dict[str, Path]: + """Find ONNX model files in a directory. + + Expects 5 models: vision-encoder, text-encoder, geometry-encoder, + geometry-encoder-exemplar, prompt-decoder. + + Args: + onnx_dir: Directory containing ONNX models. + + Returns: + Dictionary mapping canonical name to ONNX file path. + + Raises: + FileNotFoundError: If required model files are missing. + """ + models = {} + for name in OV_MODEL_NAMES: + path = _find_onnx_file(onnx_dir, name) + if path is not None: + models[name] = path + + if len(models) == len(OV_MODEL_NAMES): + logger.info("Found all %d ONNX models.", len(models)) + return models + + missing = [n for n in OV_MODEL_NAMES if n not in models] + msg = f"Incomplete model set in {onnx_dir}. Missing: {missing}. Expected all of {OV_MODEL_NAMES}." + raise FileNotFoundError(msg) + + +def convert_onnx_to_openvino( + onnx_path: Path, + output_dir: Path, + model_name: str, + precision: str = "fp32", +) -> Path: + """Convert a single ONNX model to OpenVINO IR format. + + Args: + onnx_path: Path to input ONNX model. + output_dir: Directory to save OpenVINO IR files. + model_name: Name for the output model (without extension). + precision: Target precision ("fp32" or "fp16"). + + Returns: + Path to the saved OpenVINO XML file. + """ + msg = f"Converting {onnx_path.name} → {model_name}.xml (precision={precision})..." + logger.info(msg) + + ov_model = ov.convert_model(onnx_path) + + if precision == "fp16": + ov.save_model(ov_model, output_dir / f"{model_name}.xml", compress_to_fp16=True) + else: + ov.save_model(ov_model, output_dir / f"{model_name}.xml", compress_to_fp16=False) + + xml_path = output_dir / f"{model_name}.xml" + bin_path = output_dir / f"{model_name}.bin" + msg = f"Saved: {xml_path} ({bin_path.stat().st_size / (1024 * 1024):.1f} MB)" + logger.info(msg) + + return xml_path + + +def convert_all( + onnx_dir: Path, + output_dir: Path, + precision: str = "fp32", +) -> dict[str, Path]: + """Convert all SAM3 ONNX models to OpenVINO IR format. + + Args: + onnx_dir: Directory containing ONNX models. + output_dir: Directory to save OpenVINO IR files. + precision: Target precision ("fp32" or "fp16"). + + Returns: + Dictionary mapping model name to OpenVINO XML path. + """ + output_dir.mkdir(parents=True, exist_ok=True) + + onnx_models = find_onnx_models(onnx_dir) + ov_models = {} + + for canonical_name, onnx_path in onnx_models.items(): + xml_path = convert_onnx_to_openvino( + onnx_path=onnx_path, + output_dir=output_dir, + model_name=canonical_name, + precision=precision, + ) + ov_models[canonical_name] = xml_path + + # Copy tokenizer files to output directory if they exist in onnx_dir + tokenizer_files = ["tokenizer.json", "tokenizer_config.json", "special_tokens_map.json", "vocab.json", "merges.txt"] + for filename in tokenizer_files: + src = onnx_dir / filename + dst = output_dir / filename + if src.exists() and not dst.exists(): + shutil.copy2(src, dst) + msg = f"Copied tokenizer file: {filename}" + logger.info(msg) + + return ov_models + + +def validate_openvino_models(model_dir: Path, device: str = "CPU") -> None: + """Validate that OpenVINO models can be loaded and run with dummy inputs. + + Args: + model_dir: Directory containing OpenVINO IR files. + device: OpenVINO device to validate on. + """ + core = ov.Core() + rng = np.random.default_rng(42) + + logger.info("Validating OpenVINO models in %s ...", model_dir) + + # Vision encoder + vision_xml = model_dir / "vision-encoder.xml" + if vision_xml.exists(): + vision_model = core.compile_model(vision_xml, device) + dummy_image = rng.standard_normal((1, 3, 1008, 1008)).astype(np.float32) + vision_result = vision_model([dummy_image]) + logger.info( + " Vision encoder: OK — %s", + {k: vision_result[k].shape for k in ["fpn_feat_0", "fpn_feat_1", "fpn_feat_2", "fpn_pos_2"]}, + ) + + # Text encoder + text_xml = model_dir / "text-encoder.xml" + if text_xml.exists(): + text_model = core.compile_model(text_xml, device) + dummy_ids = np.ones((1, 32), dtype=np.int64) + dummy_mask = np.ones((1, 32), dtype=np.int64) + text_result = text_model([dummy_ids, dummy_mask]) + logger.info( + " Text encoder: OK — %s", + {k: text_result[k].shape for k in ["text_features", "text_mask"]}, + ) + + # Shared FPN dummies for decoder / geometry encoder validation + dummy_fpn0 = rng.standard_normal((1, 256, 288, 288)).astype(np.float32) + dummy_fpn1 = rng.standard_normal((1, 256, 144, 144)).astype(np.float32) + dummy_fpn2 = rng.standard_normal((1, 256, 72, 72)).astype(np.float32) + dummy_pos2 = rng.standard_normal((1, 256, 72, 72)).astype(np.float32) + + # Geometry encoder (classic) + geo_xml = model_dir / "geometry-encoder.xml" + if geo_xml.exists(): + geo_model = core.compile_model(geo_xml, device) + dummy_boxes = rng.random((1, 1, 4)).astype(np.float32) + dummy_box_labels = np.ones((1, 1), dtype=np.int64) + dummy_pts = np.zeros((1, 1, 2), dtype=np.float32) + dummy_pt_labels = np.full((1, 1), -10, dtype=np.int64) + geo_result = geo_model([dummy_fpn2, dummy_pos2, dummy_boxes, dummy_box_labels, dummy_pts, dummy_pt_labels]) + logger.info( + " Geometry encoder (classic): OK — %s", + {k: geo_result[k].shape for k in ["geometry_features", "geometry_mask"]}, + ) + + # Geometry encoder (exemplar) + geo_ex_xml = model_dir / "geometry-encoder-exemplar.xml" + if geo_ex_xml.exists(): + geo_ex_model = core.compile_model(geo_ex_xml, device) + dummy_boxes = np.zeros((1, 1, 4), dtype=np.float32) + dummy_box_labels = np.full((1, 1), -10, dtype=np.int64) + dummy_pts = rng.random((1, 1, 2)).astype(np.float32) + dummy_pt_labels = np.ones((1, 1), dtype=np.int64) + geo_ex_result = geo_ex_model([ + dummy_fpn2, + dummy_pos2, + dummy_boxes, + dummy_box_labels, + dummy_pts, + dummy_pt_labels, + ]) + logger.info( + " Geometry encoder (exemplar): OK — %s", + {k: geo_ex_result[k].shape for k in ["geometry_features", "geometry_mask"]}, + ) + + # Prompt decoder + dec_xml = model_dir / "prompt-decoder.xml" + if dec_xml.exists(): + dummy_prompt = rng.standard_normal((1, 32, 256)).astype(np.float32) + dummy_pmask = np.ones((1, 32), dtype=bool) + dec_model = core.compile_model(dec_xml, device) + dec_result = dec_model([dummy_fpn0, dummy_fpn1, dummy_fpn2, dummy_pos2, dummy_prompt, dummy_pmask]) + logger.info( + " Prompt decoder: OK — %s", + {k: dec_result[k].shape for k in ["pred_masks", "pred_boxes", "pred_logits", "presence_logits"]}, + ) + + logger.info("Validation complete!") + + +def main() -> None: + """CLI entry point for SAM3 ONNX → OpenVINO conversion.""" + parser = argparse.ArgumentParser( + description="Convert SAM3 ONNX models to OpenVINO IR format.", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Convert local ONNX models + python convert_sam3_to_openvino.py --onnx-dir ./onnx-models --output-dir ./openvino-models + + # Convert with FP16 compression + python convert_sam3_to_openvino.py --onnx-dir ./onnx-models --output-dir ./openvino-models --precision fp16 + """, + ) + parser.add_argument( + "--onnx-dir", + type=Path, + required=True, + help="Directory containing ONNX models (5-model split from export_sam3_openvino.py).", + ) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("./sam3-openvino"), + help="Output directory for OpenVINO IR models. Default: ./sam3-openvino", + ) + parser.add_argument( + "--precision", + type=str, + choices=["fp32", "fp16"], + default="fp16", + help="Target OpenVINO IR precision. Default: fp16", + ) + parser.add_argument( + "--validate", + action="store_true", + help="Validate converted models with dummy inference.", + ) + parser.add_argument( + "--device", + type=str, + default="CPU", + help="OpenVINO device for validation. Default: CPU", + ) + + args = parser.parse_args() + + # Setup logging + logging.basicConfig( + level=logging.INFO, + format="%(levelname)s - %(name)s: %(message)s", + stream=sys.stdout, + ) + + onnx_dir = args.onnx_dir + + ov_models = convert_all( + onnx_dir=onnx_dir, + output_dir=args.output_dir, + precision=args.precision, + ) + + logger.info("Conversion complete! OpenVINO models saved to: %s", args.output_dir) + for name, path in ov_models.items(): + logger.info(" %s: %s", name, path) + + if args.validate: + validate_openvino_models(args.output_dir, device=args.device) + + +if __name__ == "__main__": + main() diff --git a/library/src/instantlearn/scripts/sam3/export_sam3_openvino.py b/library/src/instantlearn/scripts/sam3/export_sam3_openvino.py new file mode 100644 index 000000000..304c7dead --- /dev/null +++ b/library/src/instantlearn/scripts/sam3/export_sam3_openvino.py @@ -0,0 +1,369 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""Export SAM3 PyTorch model to OpenVINO IR via ONNX. + +Loads the official ``Sam3Model`` weights from HuggingFace (or a local +checkpoint), exports each sub-component to ONNX, then converts to OpenVINO IR. + +Produces 5 OpenVINO IR models (4-model split + exemplar variant): + +* ``vision-encoder`` — ViT + FPN backbone +* ``text-encoder`` — CLIP text encoder + projection +* ``geometry-encoder`` — Geometry encoder (classic, ``drop_spatial_bias=False``) +* ``geometry-encoder-exemplar`` — Geometry encoder (exemplar, ``drop_spatial_bias=True``) +* ``prompt-decoder`` — DETR encoder/decoder + box head + scoring + mask decoder + +Usage: + # Export from HuggingFace (default: facebook/sam3) to FP16 OpenVINO IR + python export_sam3_openvino.py --output-dir ./sam3-openvino + + # Export with FP32 precision + python export_sam3_openvino.py --output-dir ./sam3-openvino --precision fp32 + + # Export from a local checkpoint + python export_sam3_openvino.py --model-id /path/to/sam3.pt --output-dir ./sam3-openvino + + # Export and validate with dummy inference + python export_sam3_openvino.py --output-dir ./sam3-openvino --validate + + # Only convert existing ONNX models to OpenVINO IR (skip PyTorch export) + python export_sam3_openvino.py --onnx-dir ./sam3-onnx --output-dir ./sam3-openvino --skip-export +""" + +import argparse +import logging +import shutil +import sys +from pathlib import Path + +import numpy as np + +logger = logging.getLogger(__name__) + + +def export_from_pytorch( + model_id: str, + output_dir: Path, + *, + resolution: int = 1008, + opset_version: int = 17, +) -> dict[str, Path]: + """Load Sam3Model and export all sub-components to ONNX. + + Args: + model_id: HuggingFace model ID or local path to ``sam3.pt``. + output_dir: Directory to write the ONNX files and tokenizer. + resolution: Input image resolution. + opset_version: ONNX opset version. + + Returns: + Mapping from model name to ONNX file path. + """ + import torch # noqa: PLC0415 + from transformers import CLIPTokenizerFast # noqa: PLC0415 + + from instantlearn.models.sam3.export_openvino import export_sam3_to_onnx # noqa: PLC0415 + from instantlearn.models.sam3.model import Sam3Model # noqa: PLC0415 + + logger.info("Loading Sam3Model from '%s'...", model_id) + model = Sam3Model.from_pretrained(model_id, device="cpu", dtype=torch.float32) + model.eval() + logger.info("Model loaded successfully.") + + # Export ONNX + onnx_dir = output_dir / "onnx" + with torch.no_grad(): + exported = export_sam3_to_onnx( + model, + onnx_dir, + resolution=resolution, + opset_version=opset_version, + ) + + # Save tokenizer alongside the ONNX files + logger.info("Saving tokenizer...") + tokenizer = CLIPTokenizerFast.from_pretrained(model_id) + tokenizer.save_pretrained(str(onnx_dir)) + logger.info(" Tokenizer saved to %s", onnx_dir) + + return exported + + +def convert_to_openvino( + onnx_dir: Path, + output_dir: Path, + *, + precision: str = "fp16", +) -> dict[str, Path]: + """Convert all SAM3 ONNX models to OpenVINO IR. + + Args: + onnx_dir: Directory containing ONNX files from ``export_from_pytorch``. + output_dir: Directory to write OpenVINO IR files. + precision: Target precision (``"fp32"`` or ``"fp16"``). + + Returns: + Mapping from model name to ``.xml`` path. + """ + from instantlearn.models.sam3.export_openvino import convert_onnx_to_openvino # noqa: PLC0415 + + compress_to_fp16 = precision == "fp16" + converted = convert_onnx_to_openvino( + onnx_dir, + output_dir, + compress_to_fp16=compress_to_fp16, + ) + + # Copy tokenizer files to the IR output directory + tokenizer_files = [ + "tokenizer.json", + "tokenizer_config.json", + "special_tokens_map.json", + "vocab.json", + "merges.txt", + ] + for filename in tokenizer_files: + src = onnx_dir / filename + dst = output_dir / filename + if src.exists() and not dst.exists(): + shutil.copy2(src, dst) + logger.info("Copied tokenizer file: %s", filename) + + return converted + + +def validate_openvino_models( # noqa: PLR0915 + model_dir: Path, + device: str = "CPU", + resolution: int = 1008, +) -> None: + """Validate exported OpenVINO models with dummy inference. + + Args: + model_dir: Directory containing OpenVINO IR files. + device: OpenVINO device for validation. + resolution: Model input resolution. + """ + import openvino as ov # noqa: PLC0415 + + core = ov.Core() + rng = np.random.default_rng(42) + feat_size = resolution // 14 # 72 for 1008 + + logger.info("Validating OpenVINO models in %s...", model_dir) + + # 1. Vision encoder + vision_xml = model_dir / "vision-encoder.xml" + if vision_xml.exists(): + vision_model = core.compile_model(vision_xml, device) + dummy_img = rng.standard_normal((1, 3, resolution, resolution)).astype(np.float32) + vision_result = vision_model([dummy_img]) + logger.info( + " Vision encoder: OK — %s", + {k: vision_result[k].shape for k in ["fpn_feat_0", "fpn_feat_1", "fpn_feat_2", "fpn_pos_2"]}, + ) + else: + logger.warning(" Vision encoder: MISSING (%s)", vision_xml) + + # 2. Text encoder + text_xml = model_dir / "text-encoder.xml" + if text_xml.exists(): + text_model = core.compile_model(text_xml, device) + dummy_ids = np.ones((1, 32), dtype=np.int64) + dummy_mask = np.ones((1, 32), dtype=np.int64) + text_result = text_model([dummy_ids, dummy_mask]) + logger.info( + " Text encoder: OK — %s", + {k: text_result[k].shape for k in ["text_features", "text_mask"]}, + ) + else: + logger.warning(" Text encoder: MISSING (%s)", text_xml) + + # 3. Geometry encoder (classic) + geo_xml = model_dir / "geometry-encoder.xml" + if geo_xml.exists(): + geo_model = core.compile_model(geo_xml, device) + dummy_fpn = rng.standard_normal((1, 256, feat_size, feat_size)).astype(np.float32) + dummy_pos = rng.standard_normal((1, 256, feat_size, feat_size)).astype(np.float32) + dummy_boxes = rng.random((1, 1, 4)).astype(np.float32) + dummy_box_labels = np.ones((1, 1), dtype=np.int64) + dummy_points = np.zeros((1, 1, 2), dtype=np.float32) + dummy_point_labels = np.full((1, 1), -10, dtype=np.int64) + geo_result = geo_model([dummy_fpn, dummy_pos, dummy_boxes, dummy_box_labels, dummy_points, dummy_point_labels]) + logger.info( + " Geometry encoder (classic): OK — %s", + {k: geo_result[k].shape for k in ["geometry_features", "geometry_mask"]}, + ) + else: + logger.warning(" Geometry encoder (classic): MISSING (%s)", geo_xml) + + # 4. Geometry encoder (exemplar) + geo_ex_xml = model_dir / "geometry-encoder-exemplar.xml" + if geo_ex_xml.exists(): + geo_ex_model = core.compile_model(geo_ex_xml, device) + dummy_boxes_ign = np.zeros((1, 1, 4), dtype=np.float32) + dummy_box_labels_ign = np.full((1, 1), -10, dtype=np.int64) + dummy_pts = rng.random((1, 1, 2)).astype(np.float32) + dummy_pt_labels = np.ones((1, 1), dtype=np.int64) + geo_ex_result = geo_ex_model([ + dummy_fpn, + dummy_pos, + dummy_boxes_ign, + dummy_box_labels_ign, + dummy_pts, + dummy_pt_labels, + ]) + logger.info( + " Geometry encoder (exemplar): OK — %s", + {k: geo_ex_result[k].shape for k in ["geometry_features", "geometry_mask"]}, + ) + else: + logger.warning(" Geometry encoder (exemplar): MISSING (%s)", geo_ex_xml) + + # 5. Prompt decoder + dec_xml = model_dir / "prompt-decoder.xml" + if dec_xml.exists(): + dec_model = core.compile_model(dec_xml, device) + dummy_f0 = rng.standard_normal((1, 256, feat_size * 4, feat_size * 4)).astype(np.float32) + dummy_f1 = rng.standard_normal((1, 256, feat_size * 2, feat_size * 2)).astype(np.float32) + dummy_f2 = rng.standard_normal((1, 256, feat_size, feat_size)).astype(np.float32) + dummy_p2 = rng.standard_normal((1, 256, feat_size, feat_size)).astype(np.float32) + dummy_prompt = rng.standard_normal((1, 32, 256)).astype(np.float32) + dummy_pmask = np.ones((1, 32), dtype=bool) + dec_result = dec_model([dummy_f0, dummy_f1, dummy_f2, dummy_p2, dummy_prompt, dummy_pmask]) + logger.info( + " Prompt decoder: OK — %s", + {k: dec_result[k].shape for k in ["pred_masks", "pred_boxes", "pred_logits", "presence_logits"]}, + ) + else: + logger.warning(" Prompt decoder: MISSING (%s)", dec_xml) + + logger.info("Validation complete!") + + +def main() -> None: + """CLI entry point for SAM3 PyTorch → ONNX → OpenVINO export.""" + parser = argparse.ArgumentParser( + description="Export SAM3 PyTorch model to OpenVINO IR via ONNX (5-model split).", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Full pipeline: PyTorch → ONNX → OpenVINO IR (FP16) + python export_sam3_openvino.py --output-dir ./sam3-openvino + + # FP32 precision + python export_sam3_openvino.py --output-dir ./sam3-openvino --precision fp32 + + # From local checkpoint + python export_sam3_openvino.py --model-id /path/to/sam3.pt --output-dir ./sam3-openvino + + # Only convert existing ONNX to OpenVINO IR + python export_sam3_openvino.py --onnx-dir ./sam3-onnx --output-dir ./sam3-openvino --skip-export + + # Export and validate + python export_sam3_openvino.py --output-dir ./sam3-openvino --validate + """, + ) + parser.add_argument( + "--model-id", + type=str, + default="facebook/sam3", + help="HuggingFace model ID or local path. Default: facebook/sam3", + ) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("./sam3-openvino"), + help="Output directory for OpenVINO IR models. Default: ./sam3-openvino", + ) + parser.add_argument( + "--precision", + type=str, + choices=["fp32", "fp16"], + default="fp16", + help="Target OpenVINO IR precision. Default: fp16", + ) + parser.add_argument( + "--onnx-dir", + type=Path, + default=None, + help="Path to existing ONNX directory (skip PyTorch export).", + ) + parser.add_argument( + "--skip-export", + action="store_true", + help="Skip PyTorch → ONNX export and only convert existing ONNX files.", + ) + parser.add_argument( + "--resolution", + type=int, + default=1008, + help="Input image resolution. Default: 1008", + ) + parser.add_argument( + "--opset-version", + type=int, + default=17, + help="ONNX opset version. Default: 17", + ) + parser.add_argument( + "--validate", + action="store_true", + help="Validate converted models with dummy inference.", + ) + parser.add_argument( + "--device", + type=str, + default="CPU", + help="OpenVINO device for validation. Default: CPU", + ) + + args = parser.parse_args() + + logging.basicConfig( + level=logging.INFO, + format="%(levelname)s - %(name)s: %(message)s", + stream=sys.stdout, + ) + + # Step 1: PyTorch → ONNX export + if args.skip_export: + if args.onnx_dir is None: + parser.error("--onnx-dir is required when using --skip-export") + onnx_dir = args.onnx_dir + logger.info("Skipping PyTorch export; using ONNX models from %s", onnx_dir) + else: + exported = export_from_pytorch( + model_id=args.model_id, + output_dir=args.output_dir, + resolution=args.resolution, + opset_version=args.opset_version, + ) + onnx_dir = args.output_dir / "onnx" + logger.info("ONNX export complete: %s", list(exported.keys())) + + # Step 2: ONNX → OpenVINO IR + logger.info("Converting ONNX → OpenVINO IR (precision=%s)...", args.precision) + converted = convert_to_openvino( + onnx_dir=onnx_dir, + output_dir=args.output_dir, + precision=args.precision, + ) + logger.info("OpenVINO conversion complete!") + for name, path in converted.items(): + logger.info(" %s: %s", name, path) + + # Step 3: Validate + if args.validate: + validate_openvino_models( + args.output_dir, + device=args.device, + resolution=args.resolution, + ) + + logger.info("Done! Models saved to: %s", args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/library/src/instantlearn/scripts/sam3/quantize_sam3_openvino.py b/library/src/instantlearn/scripts/sam3/quantize_sam3_openvino.py new file mode 100644 index 000000000..98d82d094 --- /dev/null +++ b/library/src/instantlearn/scripts/sam3/quantize_sam3_openvino.py @@ -0,0 +1,506 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""Quantize SAM3 models to INT8/INT4 for faster inference with OpenVINO. + +Applies NNCF weight compression (INT8 or INT4) to existing FP16 OpenVINO IR +models. Produces proper OpenVINO IR with compressed weights. No calibration +data is needed. + +Usage: + # Apply NNCF INT8 weight compression to FP16 IR + python quantize_sam3_openvino.py --method nncf-int8 --source-dir ./sam3-openvino/openvino-fp16 + + # Apply NNCF INT4 weight compression to FP16 IR + python quantize_sam3_openvino.py --method nncf-int4 --source-dir ./sam3-openvino/openvino-fp16 + + # Run all NNCF methods and compare sizes + python quantize_sam3_openvino.py --method all --source-dir ./sam3-openvino/openvino-fp16 + + # Validate quantized models + python quantize_sam3_openvino.py --method nncf-int8 --source-dir ./sam3-openvino/openvino-fp16 --validate +""" + +import argparse +import logging +import shutil +import sys +from pathlib import Path + +import numpy as np +import openvino as ov +from rich.console import Console +from rich.table import Table + +logger = logging.getLogger(__name__) + +# Canonical model names (5-model split) +MODEL_NAMES = [ + "vision-encoder", + "text-encoder", + "geometry-encoder", + "geometry-encoder-exemplar", + "prompt-decoder", +] + +# Methods that use NNCF +NNCF_METHODS = {"nncf-int8", "nncf-int4"} + +# All individual methods +ALL_METHODS = NNCF_METHODS + +# Tokenizer files needed for inference +TOKENIZER_FILES = [ + "tokenizer.json", + "tokenizer_config.json", + "special_tokens_map.json", + "vocab.json", + "merges.txt", +] + + +def _compress_single_model(nncf: object, ov_model: ov.Model, mode: str) -> ov.Model: + """Apply NNCF weight compression to a single OpenVINO model. + + For INT4 mode, attempts group_size=128 first. If that fails due to + incompatible channel sizes, retries with group_size=-1 (per-channel). + + Args: + nncf: The imported nncf module. + ov_model: OpenVINO model to compress. + mode: Compression mode ("int8" or "int4"). + + Returns: + Compressed OpenVINO model. + """ + if mode == "int8": + return nncf.compress_weights( + ov_model, + mode=nncf.CompressWeightsMode.INT8_SYM, + ) + # INT4: try group_size=128 first, fall back to per-channel + try: + return nncf.compress_weights( + ov_model, + mode=nncf.CompressWeightsMode.INT4_SYM, + ratio=0.8, + group_size=128, + ) + except nncf.errors.InvalidGroupSizeError: + logger.warning(" group_size=128 failed, retrying with per-channel (group_size=-1)...") + return nncf.compress_weights( + ov_model, + mode=nncf.CompressWeightsMode.INT4_SYM, + ratio=0.8, + group_size=-1, + ) + + +def apply_nncf_weight_compression( + source_dir: Path, + output_dir: Path, + mode: str = "int8", +) -> Path: + """Apply NNCF weight compression to OpenVINO IR models. + + Args: + source_dir: Directory containing FP16 OpenVINO IR models. + output_dir: Base output directory. + mode: Compression mode ("int8" or "int4"). + + Returns: + Path to directory containing compressed OpenVINO IR models. + + Raises: + ImportError: If NNCF is not installed. + ValueError: If an unknown compression mode is specified. + """ + try: + import nncf # noqa: PLC0415 + except ImportError: + msg = "nncf is required for weight compression. Install it with: uv pip install nncf" + raise ImportError(msg) from None + + if mode not in {"int8", "int4"}: + msg = f"Unknown NNCF mode: {mode}" + raise ValueError(msg) + + logger.info("=" * 60) + logger.info("Applying NNCF %s weight compression", mode.upper()) + logger.info("Using nncf version: %s", nncf.__version__) + logger.info("=" * 60) + + ir_dir = output_dir / f"openvino-nncf-{mode}" + ir_dir.mkdir(parents=True, exist_ok=True) + + core = ov.Core() + + model_names = MODEL_NAMES + logger.info("Compressing %d models", len(model_names)) + + for model_name in model_names: + xml_path = source_dir / f"{model_name}.xml" + if not xml_path.exists(): + msg = f"Source model not found: {xml_path}" + logger.warning(msg) + continue + + msg = f"Compressing {model_name} with NNCF {mode.upper()}..." + logger.info(msg) + + ov_model = core.read_model(xml_path) + + try: + compressed_model = _compress_single_model(nncf, ov_model, mode) + except Exception: + logger.exception("Failed to compress %s with NNCF %s", model_name, mode) + continue + + out_xml = ir_dir / f"{model_name}.xml" + ov.save_model(compressed_model, out_xml) + + bin_path = ir_dir / f"{model_name}.bin" + size_mb = bin_path.stat().st_size / (1024 * 1024) + msg = f"Saved: {out_xml} ({size_mb:.1f} MB)" + logger.info(msg) + + # Copy tokenizer files from source + for filename in TOKENIZER_FILES: + src = source_dir / filename + dst = ir_dir / filename + if src.exists() and not dst.exists(): + shutil.copy2(src, dst) + + return ir_dir + + +def validate_openvino_models(model_dir: Path, device: str = "CPU") -> bool: # noqa: C901, PLR0915 + """Validate that OpenVINO models can be loaded and run with dummy inputs. + + Tries .xml first, then falls back to .onnx files. + + Args: + model_dir: Directory containing model files. + device: OpenVINO device for validation. + + Returns: + True if all models validated successfully. + """ + core = ov.Core() + rng = np.random.default_rng(42) + all_ok = True + + logger.info("Validating models in %s ...", model_dir) + + model_names = MODEL_NAMES + + # Find model files (prefer .xml, fallback to .onnx) + model_files = {} + for model_name in model_names: + xml = model_dir / f"{model_name}.xml" + if xml.exists(): + model_files[model_name] = xml + continue + # Look for any .onnx variant + onnx_candidates = sorted(model_dir.glob(f"{model_name}*.onnx")) + if onnx_candidates: + model_files[model_name] = onnx_candidates[0] + else: + logger.warning(" %s: NOT FOUND", model_name) + all_ok = False + + # Validate vision encoder + if "vision-encoder" in model_files: + try: + model = core.compile_model(model_files["vision-encoder"], device) + dummy = rng.standard_normal((1, 3, 1008, 1008)).astype(np.float32) + result = model([dummy]) + shapes = {name: result[name].shape for name in ["fpn_feat_0", "fpn_feat_1", "fpn_feat_2", "fpn_pos_2"]} + logger.info(" vision-encoder: OK — %s", shapes) + except Exception: + logger.exception(" vision-encoder: FAILED") + all_ok = False + + # Validate text encoder + if "text-encoder" in model_files: + try: + model = core.compile_model(model_files["text-encoder"], device) + dummy_ids = np.ones((1, 32), dtype=np.int64) + dummy_mask = np.ones((1, 32), dtype=np.int64) + result = model([dummy_ids, dummy_mask]) + shapes = {name: result[name].shape for name in ["text_features", "text_mask"]} + logger.info(" text-encoder: OK — %s", shapes) + except Exception: + logger.exception(" text-encoder: FAILED") + all_ok = False + + # Geometry encoder (classic) + if "geometry-encoder" in model_files: + try: + model = core.compile_model(model_files["geometry-encoder"], device) + dummy_fpn2 = rng.standard_normal((1, 256, 72, 72)).astype(np.float32) + dummy_pos2 = rng.standard_normal((1, 256, 72, 72)).astype(np.float32) + result = model([ + dummy_fpn2, + dummy_pos2, + rng.random((1, 1, 4)).astype(np.float32), + np.ones((1, 1), dtype=np.int64), + np.zeros((1, 1, 2), dtype=np.float32), + np.full((1, 1), -10, dtype=np.int64), + ]) + shapes = {name: result[name].shape for name in ["geometry_features", "geometry_mask"]} + logger.info(" geometry-encoder: OK — %s", shapes) + except Exception: + logger.exception(" geometry-encoder: FAILED") + all_ok = False + + # Geometry encoder (exemplar) + if "geometry-encoder-exemplar" in model_files: + try: + model = core.compile_model(model_files["geometry-encoder-exemplar"], device) + dummy_fpn2 = rng.standard_normal((1, 256, 72, 72)).astype(np.float32) + dummy_pos2 = rng.standard_normal((1, 256, 72, 72)).astype(np.float32) + result = model([ + dummy_fpn2, + dummy_pos2, + np.zeros((1, 1, 4), dtype=np.float32), + np.full((1, 1), -10, dtype=np.int64), + rng.random((1, 1, 2)).astype(np.float32), + np.ones((1, 1), dtype=np.int64), + ]) + shapes = {name: result[name].shape for name in ["geometry_features", "geometry_mask"]} + logger.info(" geometry-encoder-exemplar: OK — %s", shapes) + except Exception: + logger.exception(" geometry-encoder-exemplar: FAILED") + all_ok = False + + # Prompt decoder + if "prompt-decoder" in model_files: + try: + model = core.compile_model(model_files["prompt-decoder"], device) + result = model([ + rng.standard_normal((1, 256, 288, 288)).astype(np.float32), + rng.standard_normal((1, 256, 144, 144)).astype(np.float32), + rng.standard_normal((1, 256, 72, 72)).astype(np.float32), + rng.standard_normal((1, 256, 72, 72)).astype(np.float32), + rng.standard_normal((1, 32, 256)).astype(np.float32), + np.ones((1, 32), dtype=bool), + ]) + shapes = { + name: result[name].shape for name in ["pred_masks", "pred_boxes", "pred_logits", "presence_logits"] + } + logger.info(" prompt-decoder: OK — %s", shapes) + except Exception: + logger.exception(" prompt-decoder: FAILED") + all_ok = False + + status = "All models validated!" if all_ok else "Some models failed validation." + logger.info(status) + return all_ok + + +def get_dir_size(directory: Path) -> float: + """Get total size of model files in a directory in MB. + + Args: + directory: Directory to measure. + + Returns: + Total size in megabytes. + """ + total = 0 + for ext in ("*.xml", "*.bin", "*.onnx"): + for f in directory.glob(ext): + total += f.stat().st_size + return total / (1024 * 1024) + + +def print_comparison_table(output_dir: Path) -> None: + """Print a comparison table of all quantized variants. + + Args: + output_dir: Base output directory containing variant subdirectories. + """ + console = Console() + table = Table(title="SAM3 Quantization Comparison", show_header=True) + table.add_column("Variant", style="cyan", width=20) + table.add_column("Total", justify="right", style="bold") + table.add_column("Model Count", justify="right") + table.add_column("Status", style="green") + + # Find all variant directories (openvino-* and onnx-*) + variant_dirs = sorted([*output_dir.glob("openvino-*"), *output_dir.glob("onnx-*")]) + for variant_dir in variant_dirs: + if not variant_dir.is_dir(): + continue + variant_name = variant_dir.name + for prefix in ("openvino-", "onnx-"): + variant_name = variant_name.replace(prefix, "", 1) if variant_name.startswith(prefix) else variant_name + fmt = "IR" if variant_dir.name.startswith("openvino") else "ONNX" + variant_label = f"{variant_name} ({fmt})" + + model_names = MODEL_NAMES + total_size = 0.0 + found = 0 + for model_name in model_names: + bin_path = variant_dir / f"{model_name}.bin" + if bin_path.exists(): + total_size += bin_path.stat().st_size / (1024 * 1024) + found += 1 + else: + onnx_files = list(variant_dir.glob(f"{model_name}*.onnx")) + if onnx_files: + total_size += onnx_files[0].stat().st_size / (1024 * 1024) + found += 1 + + status = "OK" if found == len(model_names) else f"Missing {len(model_names) - found}" + + table.add_row( + variant_label, + f"{total_size:.1f} MB", + f"{found}/{len(model_names)}", + status, + ) + + console.print(table) + + +def _build_parser() -> argparse.ArgumentParser: + """Build the argument parser for the quantization CLI. + + Returns: + Configured argument parser. + """ + parser = argparse.ArgumentParser( + description="Quantize SAM3 models for faster OpenVINO inference.", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Methods: + nncf-int8 Apply NNCF INT8 weight compression to FP16 models (requires --source-dir) + nncf-int4 Apply NNCF INT4 weight compression to FP16 models (requires --source-dir) + all Run all NNCF methods (requires --source-dir) + +Examples: + python quantize_sam3_openvino.py --method nncf-int8 --source-dir ./sam3-openvino/openvino-fp16 + python quantize_sam3_openvino.py --method nncf-int4 --source-dir ./sam3-openvino/openvino-fp16 + python quantize_sam3_openvino.py --method all --source-dir ./sam3-openvino/openvino-fp16 --validate + """, + ) + parser.add_argument( + "--method", + type=str, + required=True, + choices=["nncf-int8", "nncf-int4", "all"], + help="Quantization method to apply.", + ) + parser.add_argument( + "--output-dir", + type=Path, + default=Path("./sam3-openvino"), + help="Base output directory. Default: ./sam3-openvino", + ) + parser.add_argument( + "--source-dir", + type=Path, + help="Directory with FP16 OpenVINO IR models (required for NNCF methods).", + ) + parser.add_argument( + "--validate", + action="store_true", + help="Validate models after conversion.", + ) + parser.add_argument( + "--device", + type=str, + default="CPU", + help="OpenVINO device for validation. Default: CPU", + ) + parser.add_argument( + "--compare", + action="store_true", + help="Print comparison table of all variants in output-dir.", + ) + return parser + + +def _run_method(method: str, output_dir: Path, source_dir: Path | None) -> Path: + """Run a single quantization method. + + Args: + method: Method name (e.g., "nncf-int8", "nncf-int4"). + output_dir: Base output directory. + source_dir: Source directory with FP16 OpenVINO IR models. + + Returns: + Path to directory containing the quantized models. + """ + nncf_mode = method.replace("nncf-", "") + return apply_nncf_weight_compression(source_dir, output_dir, nncf_mode) + + +def main() -> None: + """CLI entry point for SAM3 quantization.""" + parser = _build_parser() + args = parser.parse_args() + + logging.basicConfig( + level=logging.INFO, + format="%(levelname)s - %(name)s: %(message)s", + stream=sys.stdout, + force=True, + ) + + method = args.method + output_dir = args.output_dir + source_dir = args.source_dir + + # Determine which methods to run + methods_to_run = _resolve_methods(method) + + # Validate that source-dir is provided for NNCF + if source_dir is None: + parser.error("--source-dir is required. Point it to your FP16 OpenVINO IR directory.") + + # Run each method + result_dirs: dict[str, Path] = {} + for m in methods_to_run: + try: + result_dirs[m] = _run_method(m, output_dir, source_dir) + except Exception: # noqa: PERF203 + logger.exception("Failed method: %s", m) + + # Validate + if args.validate: + for m, result_dir in result_dirs.items(): + logger.info("-" * 60) + logger.info("Validating: %s", m) + validate_openvino_models(result_dir, device=args.device) + + # Summary + logger.info("=" * 60) + logger.info("Quantization complete!") + for m, result_dir in result_dirs.items(): + size = get_dir_size(result_dir) + logger.info(" %s: %s (%.1f MB model files)", m, result_dir, size) + + # Print comparison table + if args.compare or method == "all": + print_comparison_table(output_dir) + + +def _resolve_methods(method: str) -> list[str]: + """Resolve a method argument to a list of individual methods. + + Args: + method: Method string from CLI (may be "all" or a single method). + + Returns: + List of individual method names. + """ + if method == "all": + return sorted(ALL_METHODS) + return [method] + + +if __name__ == "__main__": + main() diff --git a/library/src/instantlearn/utils/__init__.py b/library/src/instantlearn/utils/__init__.py index a278c2f6c..860e3f24a 100644 --- a/library/src/instantlearn/utils/__init__.py +++ b/library/src/instantlearn/utils/__init__.py @@ -6,6 +6,7 @@ from .constants import Backend from .similarity_resize import resize_similarity_maps from .utils import ( + device_to_openvino_device, download_file, precision_to_torch_dtype, setup_logger, @@ -13,6 +14,7 @@ __all__ = [ "Backend", + "device_to_openvino_device", "download_file", "precision_to_torch_dtype", "resize_similarity_maps", diff --git a/library/src/instantlearn/utils/utils.py b/library/src/instantlearn/utils/utils.py index 5e807521c..7fa5d9bbd 100644 --- a/library/src/instantlearn/utils/utils.py +++ b/library/src/instantlearn/utils/utils.py @@ -128,7 +128,7 @@ def device_to_openvino_device(device: str) -> str: return "CPU" device_upper = device.upper() # Map PyTorch-style names to OpenVINO names - if device_upper == "CUDA": + if device_upper in {"CUDA", "XPU"}: return "GPU" # OpenVINO names pass through unchanged if device_upper in {"CPU", "GPU", "AUTO"}: diff --git a/library/tests/unit/models/test_sam3_openvino.py b/library/tests/unit/models/test_sam3_openvino.py new file mode 100644 index 000000000..086e52540 --- /dev/null +++ b/library/tests/unit/models/test_sam3_openvino.py @@ -0,0 +1,485 @@ +# Copyright (C) 2025-2026 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +"""Unit tests for SAM3OpenVINO model. + +These tests mock OpenVINO compiled models, tokenizer, and preprocessors +to validate SAM3OpenVINO logic without loading real weights. +""" + +from __future__ import annotations + +from pathlib import Path +from typing import TYPE_CHECKING +from unittest.mock import MagicMock, patch + +import numpy as np +import pytest +import torch + +from instantlearn.data.base.sample import Sample +from instantlearn.models.sam3.sam3 import Sam3PromptMode +from instantlearn.models.sam3.sam3_openvino import SAM3OpenVINO, _find_model_file, _require_model_file # noqa: PLC2701 + +if TYPE_CHECKING: + from collections.abc import Callable + + +_RNG = np.random.default_rng(42) + + +def _make_vision_result() -> MagicMock: + """Create a mock vision encoder output.""" + result = MagicMock() + result.__getitem__ = MagicMock( + side_effect=lambda k: { + "fpn_feat_0": _RNG.standard_normal((1, 256, 4, 4)).astype(np.float32), + "fpn_feat_1": _RNG.standard_normal((1, 256, 2, 2)).astype(np.float32), + "fpn_feat_2": _RNG.standard_normal((1, 256, 1, 1)).astype(np.float32), + "fpn_pos_2": _RNG.standard_normal((1, 256, 1, 1)).astype(np.float32), + }[k], + ) + return result + + +def _make_text_result() -> MagicMock: + """Create a mock text encoder output.""" + result = MagicMock() + result.__getitem__ = MagicMock( + side_effect=lambda k: { + "text_features": _RNG.standard_normal((1, 32, 256)).astype(np.float32), + "text_mask": np.ones((1, 32), dtype=bool), + }[k], + ) + return result + + +def _make_geometry_result(num_prompts: int = 2) -> MagicMock: + """Create a mock geometry encoder output.""" + result = MagicMock() + result.__getitem__ = MagicMock( + side_effect=lambda k: { + "geometry_features": _RNG.standard_normal((1, num_prompts, 256)).astype(np.float32), + "geometry_mask": np.ones((1, num_prompts), dtype=bool), + }[k], + ) + return result + + +def _make_decoder_result() -> MagicMock: + """Create a mock (prompt) decoder output.""" + num_queries = 200 + h_feat, w_feat = 63, 63 + result = MagicMock() + result.__getitem__ = MagicMock( + side_effect=lambda k: { + "pred_masks": _RNG.standard_normal((1, num_queries, h_feat, w_feat)).astype(np.float32), + "pred_boxes": _RNG.random((1, num_queries, 4)).astype(np.float32), + "pred_logits": _RNG.standard_normal((1, num_queries)).astype(np.float32), + "presence_logits": _RNG.standard_normal((1, 1)).astype(np.float32), + }[k], + ) + return result + + +def _make_compiled_model(result_factory: Callable[[], MagicMock]) -> MagicMock: + """Create a mock ov.CompiledModel that returns results from a factory.""" + model = MagicMock() + model.side_effect = lambda _inputs: result_factory() + + # Mock create_infer_request() for the InferRequest-based runner path + def _create_infer_request() -> MagicMock: + request = MagicMock() + result_holder: list[MagicMock] = [] + + def _infer(_inputs: list) -> None: + result_holder.clear() + result_holder.append(result_factory()) + + def _get_tensor(name: str) -> MagicMock: + tensor_mock = MagicMock() + tensor_mock.data = result_holder[0][name] + return tensor_mock + + request.infer = MagicMock(side_effect=_infer) + request.get_tensor = MagicMock(side_effect=_get_tensor) + return request + + model.create_infer_request = _create_infer_request + return model + + +def _make_mock_tokenizer() -> MagicMock: + """Create a mock CLIPTokenizerFast.""" + tokenizer = MagicMock() + tokenizer.return_value = MagicMock( + input_ids=np.ones((1, 32), dtype=np.int64), + attention_mask=np.ones((1, 32), dtype=np.int64), + ) + return tokenizer + + +def _make_mock_preprocessor() -> MagicMock: + """Create a mock Sam3Preprocessor.""" + pre = MagicMock() + pre.return_value = ( + torch.randn(1, 3, 1008, 1008), + torch.tensor([[224, 224]], dtype=torch.int32), + ) + return pre + + +def _make_mock_prompt_preprocessor() -> MagicMock: + """Create a mock Sam3PromptPreprocessor.""" + pre = MagicMock() + pre.return_value = ( + torch.tensor([[[0.3, 0.3, 0.1, 0.1]]]), + torch.tensor([[[0.5, 0.5]]]), + ) + return pre + + +def _make_mock_postprocessor() -> MagicMock: + """Create a mock Sam3Postprocessor.""" + post = MagicMock() + post.return_value = [ + { + "scores": torch.tensor([0.9, 0.8]), + "boxes": torch.tensor([[10, 10, 50, 50], [60, 60, 100, 100]], dtype=torch.float32), + "masks": torch.ones(2, 224, 224, dtype=torch.int64), + }, + ] + return post + + +@pytest.fixture +def tmp_model_dir(tmp_path: Path) -> Path: + """Create a temp directory with dummy model files.""" + for name in [ + "vision-encoder.xml", + "text-encoder.xml", + "geometry-encoder.xml", + "geometry-encoder-exemplar.xml", + "prompt-decoder.xml", + ]: + (tmp_path / name).touch() + return tmp_path + + +def _build_sam3_openvino( + model_dir: Path, + prompt_mode: Sam3PromptMode = Sam3PromptMode.CLASSIC, + *, + geo_prompts: int = 2, +) -> SAM3OpenVINO: + """Build SAM3OpenVINO with mocked internals. + + Args: + model_dir: Path to temp model directory. + prompt_mode: Prompt mode. + geo_prompts: Number of geometry prompts for mock output shape. + + Returns: + Mocked SAM3OpenVINO instance. + """ + mock_core = MagicMock() + vision_cm = _make_compiled_model(_make_vision_result) + text_cm = _make_compiled_model(_make_text_result) + decoder_cm = _make_compiled_model(_make_decoder_result) + geo_cm = _make_compiled_model(lambda: _make_geometry_result(geo_prompts)) + geo_ex_cm = _make_compiled_model(lambda: _make_geometry_result(geo_prompts)) + + def compile_model_side_effect(path: str | Path, _device: str) -> MagicMock: + name = Path(path).stem + mapping = { + "vision-encoder": vision_cm, + "text-encoder": text_cm, + "prompt-decoder": decoder_cm, + "geometry-encoder": geo_cm, + "geometry-encoder-exemplar": geo_ex_cm, + } + return mapping.get(name, MagicMock()) + + mock_core.compile_model = MagicMock(side_effect=compile_model_side_effect) + + with ( + patch("instantlearn.models.sam3.sam3_openvino.ov") as mock_ov, + patch("instantlearn.models.sam3.sam3_openvino.CLIPTokenizerFast") as mock_tok_cls, + patch("instantlearn.models.sam3.sam3_openvino.Sam3Preprocessor") as mock_pre_cls, + patch("instantlearn.models.sam3.sam3_openvino.Sam3PromptPreprocessor") as mock_ppre_cls, + patch("instantlearn.models.sam3.sam3_openvino.Sam3Postprocessor") as mock_post_cls, + ): + mock_ov.Core.return_value = mock_core + mock_tok_cls.from_pretrained.return_value = _make_mock_tokenizer() + mock_pre_cls.return_value = _make_mock_preprocessor() + mock_ppre_cls.return_value = _make_mock_prompt_preprocessor() + mock_post_cls.return_value = _make_mock_postprocessor() + + return SAM3OpenVINO(model_dir=model_dir, prompt_mode=prompt_mode) + + +class TestSAM3OpenVINOInit: + """Test SAM3OpenVINO initialization and model detection.""" + + def test_v3_init(self, tmp_model_dir: Path) -> None: + """Test initialization loads all models correctly.""" + model = _build_sam3_openvino(tmp_model_dir) + + assert model.prompt_mode == Sam3PromptMode.CLASSIC + assert model.geometry_model is not None + assert model.geometry_exemplar_model is not None + + def test_missing_decoder_raises(self, tmp_path: Path) -> None: + """Test missing decoder raises FileNotFoundError.""" + (tmp_path / "vision-encoder.xml").touch() + (tmp_path / "text-encoder.xml").touch() + with pytest.raises(FileNotFoundError): + _build_sam3_openvino(tmp_path) + + +class TestClassicTextPrompts: + """Test classic mode with text-only prompts.""" + + def test_fit_stores_category_mapping(self, tmp_model_dir: Path) -> None: + """Test fit() stores category mapping.""" + model = _build_sam3_openvino(tmp_model_dir) + ref = Sample(categories=["cat", "dog"], category_ids=[0, 1]) + model.fit(ref) + + assert model.category_mapping == {"cat": 0, "dog": 1} + + def test_predict_text_only(self, tmp_model_dir: Path) -> None: + """Test prediction with text-only prompts returns valid structure.""" + model = _build_sam3_openvino(tmp_model_dir) + model.fit(Sample(categories=["shoe"], category_ids=[0])) + + target = Sample(image=torch.randn(3, 224, 224)) + results = model.predict(target) + + assert len(results) == 1 + assert "pred_masks" in results[0] + assert "pred_boxes" in results[0] + assert "pred_labels" in results[0] + + def test_predict_multiple_categories(self, tmp_model_dir: Path) -> None: + """Test prediction with multiple categories.""" + model = _build_sam3_openvino(tmp_model_dir) + model.fit(Sample(categories=["cat", "dog"], category_ids=[0, 1])) + + target = Sample(image=torch.randn(3, 224, 224)) + results = model.predict(target) + + assert len(results) == 1 + # Labels should contain cat_ids from fit + labels = results[0]["pred_labels"] + unique_labels = set(labels.numpy().tolist()) + assert unique_labels <= {0, 1} + + +class TestClassicBoxPrompts: + """Test classic mode with box prompts.""" + + def test_predict_with_bbox(self, tmp_model_dir: Path) -> None: + """Test prediction with a bounding box prompt.""" + model = _build_sam3_openvino(tmp_model_dir) + + target = Sample( + image=torch.randn(3, 224, 224), + bboxes=np.array([[10, 10, 50, 50]]), + categories=["shoe"], + category_ids=[0], + ) + results = model.predict(target) + + assert len(results) == 1 + assert results[0]["pred_boxes"].shape[1] == 5 # [x1, y1, x2, y2, score] + + +class TestClassicPointPrompts: + """Test classic mode with point prompts.""" + + def test_predict_with_point(self, tmp_model_dir: Path) -> None: + """Test prediction with a point prompt.""" + model = _build_sam3_openvino(tmp_model_dir) + + target = Sample( + image=torch.randn(3, 224, 224), + points=np.array([[100, 100]]), + categories=["shoe"], + category_ids=[0], + ) + results = model.predict(target) + + assert len(results) == 1 + assert results[0]["pred_masks"].ndim == 3 # [N, H, W] + + +class TestVisualExemplarMode: + """Test visual-exemplar mode flow.""" + + def test_fit_caches_features(self, tmp_model_dir: Path) -> None: + """Test fit() encodes and caches exemplar features.""" + model = _build_sam3_openvino(tmp_model_dir, prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR) + + ref = Sample( + image=torch.randn(3, 224, 224), + bboxes=np.array([[10, 10, 50, 50]]), + categories=["shoe"], + category_ids=[0], + ) + model.fit(ref) + + assert model.exemplar_geometry_features is not None + assert len(model.exemplar_geometry_features) == 1 + assert model.exemplar_category_ids == [0] + + def test_predict_uses_cached_features(self, tmp_model_dir: Path) -> None: + """Test predict() uses cached exemplar features.""" + model = _build_sam3_openvino(tmp_model_dir, prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR) + + ref = Sample( + image=torch.randn(3, 224, 224), + bboxes=np.array([[10, 10, 50, 50]]), + categories=["shoe"], + category_ids=[0], + ) + model.fit(ref) + + target = Sample(image=torch.randn(3, 224, 224)) + results = model.predict(target) + + assert len(results) == 1 + assert "pred_masks" in results[0] + + def test_predict_without_fit_raises(self, tmp_model_dir: Path) -> None: + """Test predict() raises when fit() has not been called.""" + model = _build_sam3_openvino(tmp_model_dir, prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR) + + with pytest.raises(RuntimeError, match="No cached exemplar features"): + model.predict(Sample(image=torch.randn(3, 224, 224))) + + def test_fit_no_prompts_raises(self, tmp_model_dir: Path) -> None: + """Test fit() with no box/point prompts raises ValueError.""" + model = _build_sam3_openvino(tmp_model_dir, prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR) + + # Sample with image but no prompts + ref = Sample( + image=torch.randn(3, 224, 224), + categories=["shoe"], + category_ids=[0], + ) + with pytest.raises(ValueError, match="at least one reference sample"): + model.fit(ref) + + def test_multi_category_exemplar(self, tmp_model_dir: Path) -> None: + """Test multi-category exemplar with separate reference samples.""" + model = _build_sam3_openvino(tmp_model_dir, prompt_mode=Sam3PromptMode.VISUAL_EXEMPLAR) + + refs = [ + Sample( + image=torch.randn(3, 224, 224), + bboxes=np.array([[10, 10, 50, 50]]), + categories=["shoe"], + category_ids=[0], + ), + Sample( + image=torch.randn(3, 224, 224), + bboxes=np.array([[20, 20, 60, 60]]), + categories=["hat"], + category_ids=[1], + ), + ] + model.fit(refs) + + assert len(model.exemplar_geometry_features) == 2 + assert set(model.exemplar_category_ids) == {0, 1} + + +class TestUtilities: + """Test utility methods.""" + + def test_pad_or_truncate_pads(self) -> None: + """Test _pad_or_truncate pads short sequences.""" + arr = np.array([[1, 2, 3]], dtype=np.int64) + result = SAM3OpenVINO._pad_or_truncate(arr, 5) # noqa: SLF001 + assert result.shape == (1, 5) + np.testing.assert_array_equal(result[0, :3], [1, 2, 3]) + np.testing.assert_array_equal(result[0, 3:], [0, 0]) + + def test_pad_or_truncate_truncates(self) -> None: + """Test _pad_or_truncate truncates long sequences.""" + arr = np.array([[1, 2, 3, 4, 5]], dtype=np.int64) + result = SAM3OpenVINO._pad_or_truncate(arr, 3) # noqa: SLF001 + assert result.shape == (1, 3) + np.testing.assert_array_equal(result[0], [1, 2, 3]) + + def test_pad_or_truncate_exact(self) -> None: + """Test _pad_or_truncate returns same array when lengths match.""" + arr = np.array([[1, 2, 3]], dtype=np.int64) + result = SAM3OpenVINO._pad_or_truncate(arr, 3) # noqa: SLF001 + assert result is arr + + def test_build_category_mapping(self, tmp_model_dir: Path) -> None: + """Test _build_category_mapping merges from multiple samples.""" + from instantlearn.data.base.batch import Batch # noqa: PLC0415 + + model = _build_sam3_openvino(tmp_model_dir) + batch = Batch.collate([ + Sample(categories=["a", "b"], category_ids=[0, 1]), + Sample(categories=["b", "c"], category_ids=[1, 2]), + ]) + mapping = model._build_category_mapping(batch) # noqa: SLF001 + assert mapping == {"a": 0, "b": 1, "c": 2} + + def test_aggregate_results_empty(self) -> None: + """Test _aggregate_results with no detections.""" + result = SAM3OpenVINO._aggregate_results( # noqa: SLF001 + all_masks=[torch.empty(0)], + all_boxes=[torch.empty(0)], + all_labels=[torch.empty(0)], + img_size=(224, 224), + ) + assert result["pred_masks"].shape == (0, 224, 224) + assert result["pred_boxes"].shape == (0, 5) + + def test_export_returns_model_dir(self, tmp_model_dir: Path) -> None: + """Test export() returns model directory.""" + model = _build_sam3_openvino(tmp_model_dir) + result_path = model.export() + assert result_path == model.model_dir + + +class TestModelFileDiscovery: + """Test _find_model_file and _require_model_file.""" + + def test_find_xml_preferred(self, tmp_path: Path) -> None: + """Test .xml is preferred over .onnx.""" + (tmp_path / "vision-encoder.xml").touch() + (tmp_path / "vision-encoder.onnx").touch() + result = _find_model_file(tmp_path, "vision-encoder") + assert result is not None + assert result.suffix == ".xml" + + def test_find_onnx_fallback(self, tmp_path: Path) -> None: + """Test .onnx is found when no .xml exists.""" + (tmp_path / "vision-encoder.onnx").touch() + result = _find_model_file(tmp_path, "vision-encoder") + assert result is not None + assert result.suffix == ".onnx" + + def test_find_fp16_onnx(self, tmp_path: Path) -> None: + """Test FP16 ONNX variant is found.""" + (tmp_path / "vision-encoder-fp16.onnx").touch() + result = _find_model_file(tmp_path, "vision-encoder") + assert result is not None + assert result.name == "vision-encoder-fp16.onnx" + + def test_find_returns_none_when_missing(self, tmp_path: Path) -> None: + """Test returns None for missing model.""" + result = _find_model_file(tmp_path, "nonexistent") + assert result is None + + def test_require_raises_when_missing(self, tmp_path: Path) -> None: + """Test _require_model_file raises FileNotFoundError.""" + with pytest.raises(FileNotFoundError, match="not found"): + _require_model_file(tmp_path, "nonexistent")