diff --git a/docs/api/models.rst b/docs/api/models.rst
index 7c3ac7c4b..239e63055 100644
--- a/docs/api/models.rst
+++ b/docs/api/models.rst
@@ -206,3 +206,4 @@ API Reference
     models/pyhealth.models.BIOT
     models/pyhealth.models.unified_multimodal_embedding_docs
     models/pyhealth.models.califorest
+    models/pyhealth.models.KeepEmbedding
diff --git a/docs/api/models/pyhealth.models.KeepEmbedding b/docs/api/models/pyhealth.models.KeepEmbedding
new file mode 100644
index 000000000..1338eb118
--- /dev/null
+++ b/docs/api/models/pyhealth.models.KeepEmbedding
@@ -0,0 +1,18 @@
+pyhealth.models.KeepEmbedding
+=============================
+
+KEEP embedding model for ontology-preserving medical code embeddings.
+
+
+Classes
+-------
+
+.. autoclass:: pyhealth.models.KeepEmbedding
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. autoclass:: pyhealth.models.keep_embedding.N2V
+   :members:
+   :undoc-members:
+   :show-inheritance:
\ No newline at end of file
diff --git a/examples/keep.ipynb b/examples/keep.ipynb
new file mode 100644
index 000000000..58d5c24a4
--- /dev/null
+++ b/examples/keep.ipynb
@@ -0,0 +1,606 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2631719c",
+   "metadata": {},
+   "source": [
+    "## Ablation Study: KeepEmbedding with Different Domain Types\n",
+    "\n",
+    "**Objective**: \n",
+    "\n",
+    "Evaluate the impact of including different OMOP domain types when creating\n",
+    "KeepEmbedding models. This helps understand which clinical domains contribute\n",
+    "most to embedding quality and computational efficiency.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "773a5c88",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on device: cpu\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict, Counter\n",
+    "import networkx as nx\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import json\n",
+    "import time\n",
+    "from pyhealth.datasets import OMOPDataset\n",
+    "from pyhealth.models import KeepEmbedding, N2V\n",
+    "from pyhealth.trainer import Trainer\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(f\"Running on device: {device}\")\n",
+    "\n",
+    "# Define experiment configurations for ablation study\n",
+    "EXPERIMENTS = {\n",
+    "    \"condition_only\": {\n",
+    "        \"domain_type\": [\"Condition\"],\n",
+    "        \"tables\": [\"condition_occurrence\"],\n",
+    "        \"description\": \"Baseline: Condition codes only\"\n",
+    "    },\n",
+    "    \"condition_drug\": {\n",
+    "        \"domain_type\": [\"Condition\", \"Drug\"],\n",
+    "        \"tables\": [\"condition_occurrence\", \"drug_exposure\"],\n",
+    "        \"description\": \"Condition + Drug exposures\"\n",
+    "    },\n",
+    "    \"condition_drug_measurement\": {\n",
+    "        \"domain_type\": [\"Condition\", \"Drug\", \"Measurement\"],\n",
+    "        \"tables\": [\"condition_occurrence\", \"drug_exposure\", \"measurement\"],\n",
+    "        \"description\": \"Condition + Drug + Measurements\"\n",
+    "    },\n",
+    "    \"full_domains\": {\n",
+    "        \"domain_type\": [\"Condition\", \"Drug\", \"Measurement\", \"Procedure\"],\n",
+    "        \"tables\": [\"condition_occurrence\", \"drug_exposure\", \"measurement\", \"procedure_occurrence\"],\n",
+    "        \"description\": \"All domains: Condition + Drug + Measurement + Procedure\"\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "# Store results from all experiments\n",
+    "experiment_results = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efe2f018",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GloveDataset(Dataset):\n",
+    "    def __init__(self, cooc_matrix, num_words, x_max, alpha):\n",
+    "        super(GloveDataset, self).__init__()\n",
+    "        self.data = []\n",
+    "        for i in range(cooc_matrix.shape[0]):\n",
+    "            for j in range(cooc_matrix.shape[1]):\n",
+    "                if cooc_matrix[i, j] > 0:\n",
+    "                    self.data.append((i, j, cooc_matrix[i, j]))\n",
+    "        self.cooc_matrix = cooc_matrix\n",
+    "        self.num_words = num_words\n",
+    "        self.x_max = x_max\n",
+    "        self.alpha = alpha\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.data)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        i, j, count = self.data[idx]\n",
+    "        weight = (count / self.x_max) ** self.alpha if count < self.x_max else 1.0\n",
+    "        # Return dictionary with keys matching KeepEmbedding.forward() parameters\n",
+    "        return {\n",
+    "            \"i_indices\": torch.tensor(i),\n",
+    "            \"j_indices\": torch.tensor(j),\n",
+    "            \"counts\": torch.tensor(count).float(),\n",
+    "            \"weights\": torch.tensor(weight).float(),\n",
+    "        }\n",
+    "    \n",
+    "def get_code_and_ancestors(graph, code):\n",
+    "    # Start with the code itself\n",
+    "    codes_set = {code}\n",
+    "    \n",
+    "    # Add all ancestors if code exists in graph\n",
+    "    if code in graph:\n",
+    "        ancestors = nx.ancestors(graph, code)\n",
+    "        codes_set.update(ancestors)\n",
+    "    \n",
+    "    return codes_set\n",
+    "\n",
+    "def extract_events_by_domain(patient, domain_types):\n",
+    "    \"\"\"\n",
+    "    Extract events from a patient for specified domain types.\n",
+    "    Returns a list of codes from all specified domains.\n",
+    "    \"\"\"\n",
+    "    codes = []\n",
+    "    \n",
+    "    # Map domain types to event types in pyhealth\n",
+    "    domain_to_event_type = {\n",
+    "        \"Condition\": \"condition_occurrence\",\n",
+    "        \"Drug\": \"drug_exposure\",\n",
+    "        \"Measurement\": \"measurement\",\n",
+    "        \"Procedure\": \"procedure_occurrence\"\n",
+    "    }\n",
+    "    \n",
+    "    for domain in domain_types:\n",
+    "        if domain in domain_to_event_type:\n",
+    "            event_type = domain_to_event_type[domain]\n",
+    "            events = patient.get_events(event_type=event_type)\n",
+    "            \n",
+    "            for event in events:\n",
+    "                # Extract appropriate code field based on domain\n",
+    "                if domain == \"Condition\":\n",
+    "                    code = event.attr_dict.get(\"condition_concept_id\")\n",
+    "                elif domain == \"Drug\":\n",
+    "                    code = event.attr_dict.get(\"drug_concept_id\")\n",
+    "                elif domain == \"Measurement\":\n",
+    "                    code = event.attr_dict.get(\"measurement_concept_id\")\n",
+    "                elif domain == \"Procedure\":\n",
+    "                    code = event.attr_dict.get(\"procedure_concept_id\")\n",
+    "                \n",
+    "                if code is not None:\n",
+    "                    codes.append(code)\n",
+    "    \n",
+    "    return codes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b24d86d0",
+   "metadata": {},
+   "source": [
+    "### Experiment Pipeline\n",
+    "1. Load PyHealth OMOPDaset with appropiate tables and extract distinct conditions from all patients\n",
+    "2. Filter out codes with <2 occurrences in entire patients' history\n",
+    "3. Build OMOP Concepts Knowledge Graph\n",
+    "4. Apply hierarchy rollup\n",
+    "5. Build Co-Occurrence Matrix\n",
+    "6. Load Co-Occurence Matrix as a GloveDataset Dataloader\n",
+    "7. Initialize KEEP PyHealth model and train with PyHealth Trainer\n",
+    "8. Collect remaining performance metrics (loss, training time, etc.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b8fc62e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_experiment(exp_name, config, data_root, epochs=300):\n",
+    "    print(f\"\\n{'='*80}\")\n",
+    "    print(f\"EXPERIMENT: {exp_name}\")\n",
+    "    print(f\"Description: {config['description']}\")\n",
+    "    print(f\"Domain types: {config['domain_type']}\")\n",
+    "    print(f\"Tables: {config['tables']}\")\n",
+    "    print(f\"{'='*80}\\n\")\n",
+    "    \n",
+    "    start_time = time.time()\n",
+    "    metrics = {\n",
+    "        \"exp_name\": exp_name,\n",
+    "        \"domain_type\": config['domain_type'],\n",
+    "        \"description\": config['description']\n",
+    "    }\n",
+    "    \n",
+    "    try:\n",
+    "        # Load OMOPDataset with specified tables\n",
+    "        print(f\"Step 1: Loading OMOPDataset with tables {config['tables']}...\")\n",
+    "        dataset = OMOPDataset(\n",
+    "            root=data_root,\n",
+    "            tables=config['tables'],\n",
+    "            dataset_name=\"omop\",\n",
+    "            dev=False\n",
+    "        )\n",
+    "        dataset.stats()\n",
+    "        \n",
+    "        # Extract codes from all patients for specified domains\n",
+    "        print(f\"\\nStep 2: Extracting {config['domain_type']} codes from all patients...\")\n",
+    "        patient_codes = defaultdict(list)\n",
+    "        \n",
+    "        for patient in dataset.iter_patients():\n",
+    "            patient_id = patient.patient_id\n",
+    "            codes = extract_events_by_domain(patient, config['domain_type'])\n",
+    "            if codes:\n",
+    "                patient_codes[patient_id] = codes\n",
+    "        \n",
+    "        print(f\"Extracted codes for {len(patient_codes)} patients\")\n",
+    "        metrics[\"patients_with_codes\"] = len(patient_codes)\n",
+    "        \n",
+    "        # Filter codes with <2 occurrences in patient history\n",
+    "        print(f\"\\nStep 3: Filtering codes (keeping only those with ≥2 occurrences)...\")\n",
+    "        filtered_codes_dict = {}\n",
+    "        \n",
+    "        before_count = sum(len(codes) for codes in patient_codes.values())\n",
+    "        before_unique = len(set(code for codes in patient_codes.values() for code in codes))\n",
+    "        \n",
+    "        for patient_id, codes in patient_codes.items():\n",
+    "            code_counts = Counter(codes)\n",
+    "            filtered = [code for code, count in code_counts.items() if count >= 2]\n",
+    "            if filtered:\n",
+    "                filtered_codes_dict[patient_id] = filtered\n",
+    "        \n",
+    "        after_count = sum(len(codes) for codes in filtered_codes_dict.values())\n",
+    "        after_unique = len(set(code for codes in filtered_codes_dict.values() for code in codes))\n",
+    "        \n",
+    "        print(f\"Before filtering: {before_count} codes, {before_unique} unique\")\n",
+    "        print(f\"After filtering:  {after_count} codes, {after_unique} unique\")\n",
+    "        \n",
+    "        metrics[\"before_filtering_count\"] = before_count\n",
+    "        metrics[\"before_filtering_unique\"] = before_unique\n",
+    "        metrics[\"after_filtering_count\"] = after_count\n",
+    "        metrics[\"after_filtering_unique\"] = after_unique\n",
+    "        \n",
+    "        # Build concept graph with specified domain types\n",
+    "        print(f\"\\nStep 4: Building concept relationship graph...\")\n",
+    "        n2v = N2V()\n",
+    "        graph = n2v.create_graph(\n",
+    "            path=data_root,\n",
+    "            domain_type=config['domain_type']\n",
+    "        )\n",
+    "        \n",
+    "        print(f\"Graph loaded:\")\n",
+    "        print(f\"  Nodes (unique concepts): {len(graph.nodes())}\")\n",
+    "        print(f\"  Edges (relationships): {len(graph.edges())}\")\n",
+    "        \n",
+    "        metrics[\"graph_nodes\"] = len(graph.nodes())\n",
+    "        metrics[\"graph_edges\"] = len(graph.edges())\n",
+    "        \n",
+    "        # Roll up codes with hierarchy\n",
+    "        print(f\"\\nStep 5: Applying hierarchy roll-up...\")\n",
+    "        rolled_up_codes = {}\n",
+    "        \n",
+    "        total_original = 0\n",
+    "        total_rolled_up = 0\n",
+    "        patients_processed = 0\n",
+    "        \n",
+    "        for patient_id, codes in filtered_codes_dict.items():\n",
+    "            expanded = set()\n",
+    "            for code in codes:\n",
+    "                code_and_ancestors = get_code_and_ancestors(graph, code)\n",
+    "                expanded.update(code_and_ancestors)\n",
+    "            \n",
+    "            if expanded:\n",
+    "                rolled_up_codes[patient_id] = expanded\n",
+    "                total_original += len(codes)\n",
+    "                total_rolled_up += len(expanded)\n",
+    "                patients_processed += 1\n",
+    "        \n",
+    "        print(f\"Roll-up complete:\")\n",
+    "        print(f\"  Avg original codes/patient: {total_original / patients_processed:.2f}\")\n",
+    "        print(f\"  Avg rolled-up codes/patient: {total_rolled_up / patients_processed:.2f}\")\n",
+    "        expansion_factor = total_rolled_up / total_original if total_original > 0 else 0\n",
+    "        print(f\"  Expansion factor: {expansion_factor:.2f}x\")\n",
+    "        \n",
+    "        metrics[\"avg_original_codes\"] = total_original / patients_processed if patients_processed > 0 else 0\n",
+    "        metrics[\"avg_rolled_up_codes\"] = total_rolled_up / patients_processed if patients_processed > 0 else 0\n",
+    "        metrics[\"expansion_factor\"] = expansion_factor\n",
+    "        \n",
+    "        # Build co-occurrence matrix\n",
+    "        print(f\"\\nStep 6: Building co-occurrence matrix...\")\n",
+    "        \n",
+    "        unique_codes = set()\n",
+    "        for codes in rolled_up_codes.values():\n",
+    "            unique_codes.update(codes)\n",
+    "        \n",
+    "        unique_codes = sorted(unique_codes)\n",
+    "        code_to_index = {code: idx for idx, code in enumerate(unique_codes)}\n",
+    "        index_to_code = {idx: code for code, idx in code_to_index.items()}\n",
+    "        \n",
+    "        num_codes = len(code_to_index)\n",
+    "        cooc_matrix = np.zeros((num_codes, num_codes), dtype=np.float32)\n",
+    "        \n",
+    "        total_pairs = 0\n",
+    "        for patient_id, codes in rolled_up_codes.items():\n",
+    "            code_indices = [code_to_index[code] for code in codes]\n",
+    "            for i in range(len(code_indices)):\n",
+    "                for j in range(i + 1, len(code_indices)):\n",
+    "                    idx_i = code_indices[i]\n",
+    "                    idx_j = code_indices[j]\n",
+    "                    cooc_matrix[idx_i, idx_j] += 1.0\n",
+    "                    cooc_matrix[idx_j, idx_i] += 1.0\n",
+    "                    total_pairs += 1\n",
+    "        \n",
+    "        print(f\"Matrix complete:\")\n",
+    "        print(f\"  Shape: {cooc_matrix.shape}\")\n",
+    "        print(f\"  Sparsity: {(cooc_matrix == 0).sum() / cooc_matrix.size * 100:.2f}%\")\n",
+    "        print(f\"  Total co-occurrences: {cooc_matrix.sum():.0f}\")\n",
+    "        \n",
+    "        metrics[\"matrix_shape\"] = cooc_matrix.shape\n",
+    "        metrics[\"matrix_sparsity\"] = (cooc_matrix == 0).sum() / cooc_matrix.size * 100\n",
+    "        metrics[\"total_cooccurrence_pairs\"] = cooc_matrix.sum()\n",
+    "        \n",
+    "        # Create GloveDataset and DataLoader\n",
+    "        print(f\"\\nStep 7: Creating GloveDataset and DataLoader...\")\n",
+    "        x_max = 100\n",
+    "        alpha = 0.75\n",
+    "        batch_size = 1024\n",
+    "        \n",
+    "        glove_dataset = GloveDataset(cooc_matrix, num_codes, x_max, alpha)\n",
+    "        data_loader = DataLoader(glove_dataset, batch_size=batch_size, shuffle=True)\n",
+    "        \n",
+    "        # Initialize KeepEmbedding model\n",
+    "        print(f\"\\nStep 8: Initializing KeepEmbedding model...\")\n",
+    "        keep_model = KeepEmbedding(\n",
+    "            dataset=None,\n",
+    "            graph=graph,\n",
+    "            num_words=num_codes,\n",
+    "            embedding_dim=100,\n",
+    "            walk_length=30,\n",
+    "            num_walks=750,\n",
+    "            lambda_reg=1.0e-3,\n",
+    "            reg_norm=None,\n",
+    "            log_scale=False,\n",
+    "            code_to_index=code_to_index,\n",
+    "            device=device\n",
+    "        )\n",
+    "        \n",
+    "        # Train model\n",
+    "        print(f\"\\nStep 9: Training KeepEmbedding model ({epochs} epochs)...\")\n",
+    "        training_start = time.time()\n",
+    "        \n",
+    "        trainer = Trainer(model=keep_model, enable_logging=False)\n",
+    "        trainer.train(\n",
+    "            train_dataloader=data_loader,\n",
+    "            val_dataloader=None,\n",
+    "            epochs=epochs,\n",
+    "            optimizer_class=torch.optim.Adam,\n",
+    "            optimizer_params={\"lr\": 0.05},\n",
+    "            monitor=\"loss\",\n",
+    "            patience=10,\n",
+    "        )\n",
+    "        \n",
+    "        training_time = time.time() - training_start\n",
+    "        print(f\"Training complete in {training_time:.2f} seconds\")\n",
+    "        \n",
+    "        metrics[\"training_time_seconds\"] = training_time\n",
+    "        metrics[\"embedding_shape\"] = tuple(keep_model.embeddings_v.weight.shape)\n",
+    "        metrics[\"final_loss\"] = trainer.model_state.best_loss if hasattr(trainer, 'model_state') else None\n",
+    "        \n",
+    "        total_time = time.time() - start_time\n",
+    "        metrics[\"total_time_seconds\"] = total_time\n",
+    "        metrics[\"status\"] = \"SUCCESS\"\n",
+    "        \n",
+    "        print(f\"\\n✓ Experiment completed successfully in {total_time:.2f} seconds\")\n",
+    "    \n",
+    "    return metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5567958d",
+   "metadata": {},
+   "source": [
+    "#### Executing Experiment Pipeline for 4 Scenarios\n",
+    "1. Baseline (Condition only): Minimal feature set\n",
+    "2. Condition + Drug: Add medication information  \n",
+    "3. Condition + Drug + Measurement: Add lab values\n",
+    "4. Full (Condition + Drug + Measurement + Procedure): Complete medical context"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4af28ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set data root path\n",
+    "data_root = r\"\\Workspace\\mimic-iv-demo-data-in-the-omop-common-data-model-0.9\\1_omop_data_csv\"\n",
+    "\n",
+    "# Run all ablation experiments\n",
+    "print(\"STARTING ABLATION STUDY\")\n",
+    "print(f\"Number of experiments: {len(EXPERIMENTS)}\")\n",
+    "print()\n",
+    "\n",
+    "for exp_name, config in EXPERIMENTS.items():\n",
+    "    metrics = run_experiment(exp_name, config, data_root, epochs=50)\n",
+    "    experiment_results[exp_name] = metrics\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"ALL EXPERIMENTS COMPLETED\")\n",
+    "print(\"=\"*80)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6eacbda0",
+   "metadata": {},
+   "source": [
+    "#### Summarizing Experiment Results\n",
+    "**Key Findings**\n",
+    "Best Performance Across Metrics:\n",
+    "  * Most unique codes: full_domains (1357 codes)\n",
+    "  * Fastest training: condition_only (81.29 seconds)\n",
+    "  * Largest graph: full_domains (2187 nodes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "4570ee56",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "================================================================================\n",
+      "EXPERIMENT RESULTS SUMMARY\n",
+      "================================================================================\n",
+      "\n",
+      "Key Metrics by Experiment:\n",
+      "                                 domain_type                                              description  patients_with_codes  after_filtering_unique  graph_nodes  expansion_factor  dataset_size  training_time_seconds  total_time_seconds   status final_loss\n",
+      "0                                [Condition]                           Baseline: Condition codes only                  100                     280           34          1.000000         12458              81.290238           83.571328  SUCCESS       None\n",
+      "1                          [Condition, Drug]                               Condition + Drug exposures                  100                     899         1434          1.000000        167976            1039.360564         1053.183805  SUCCESS       None\n",
+      "2             [Condition, Drug, Measurement]                          Condition + Drug + Measurements                  100                    1285         1941          1.000064        628374            2464.622508         2540.309476  SUCCESS       None\n",
+      "3  [Condition, Drug, Measurement, Procedure]  All domains: Condition + Drug + Measurement + Procedure                  100                    1357         2187          1.000062        688994            1475.736484         1514.640198  SUCCESS       None\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display summary of all experiments\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"EXPERIMENT RESULTS SUMMARY\")\n",
+    "print(\"=\"*80)\n",
+    "\n",
+    "results_df = pd.DataFrame(experiment_results).T\n",
+    "results_df = results_df[[col for col in results_df.columns if col != \"domain_type\"]]\n",
+    "\n",
+    "# Display key metrics\n",
+    "key_metrics = [\"domain_type\", \"description\", \"patients_with_codes\", \"after_filtering_unique\", \n",
+    "               \"graph_nodes\", \"expansion_factor\", \"dataset_size\", \"training_time_seconds\", \n",
+    "               \"total_time_seconds\", \"status\", \"final_loss\"]\n",
+    "\n",
+    "summary_df = pd.DataFrame({\n",
+    "    metric: [experiment_results[exp].get(metric, \"N/A\") for exp in EXPERIMENTS.keys()]\n",
+    "    for metric in key_metrics\n",
+    "})\n",
+    "\n",
+    "print(\"\\nKey Metrics by Experiment:\")\n",
+    "print(summary_df.to_string())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00d85a24",
+   "metadata": {},
+   "source": [
+    "#### Generate experiement result visuals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "07f90eb1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Comparison plot saved to ablation_study_comparison.png\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABcsAAAPZCAYAAADOWnJ8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qm8lPP///930UqLaNUihUgLZUmbJSqRFkuFQookihZJOxKVFpWtzZKyfyhaJEuKkhLaSBSttJcWmv/t+fr+r/ldM2fO6SxzZs5pHvfbbeqcWa+55n2ueV2v63W93jkCgUDAAQAAAAAAAACQwHLGewEAAAAAAAAAAIg3kuUAAAAAAAAAgIRHshwAAAAAAAAAkPBIlgMAAAAAAAAAEh7JcgAAAAAAAABAwiNZDgAAAAAAAABIeCTLAQAAAAAAAAAJj2Q5AAAAAAAAACDhkSwHAAAAAAAAACQ8kuUAkA1t377d5c6d2+XIkSPkMmPGjBQfd8YZZ4TcP638j9VzxcPll18eshy//faby0727dvnhg0b5urVq+dOO+00lytXLleoUCFbnxdffLG788473YgRI9yGDRtcVjV58uSQz2DAgAEuq9Cy+JftjjvuiPciIZXefPNNd8UVV7hTTz3VnXDCCcHPsGvXrql6fPj2TRdtJwsWLOjKlSvn6tSp4+677z43Z84cFwgEEu5zicf2O/zvMS2XrLRdQfq3tzt37rTvNv/9ypcv79avX5+tV6vea2rHcrNmzWK2XFn5+1nxmn/ZFM+lxWeffZbieAv/THR/AADS48R0PQoAEFevvfaaO3LkSMSdpOuuu85lR/7kvRJb2S0Jnho///yzu/rqq93vv/8ecv2ePXvsouuXLFli1xUrVszddtttIffTjuXnn38e/F3JhngdtMDxIauMqYkTJ7r27dtH/Xm1ndRl7969dgDqq6++cuPHj3eVKlVyr776qqtZs2bUXxPA//nrr7/sO2/58uXBVVKxYkX36aefujJlyrCaAABAlkSyHACyoSlTpkS8/sMPP3Q7duxwRYoUccer+vXrW0W256STTnLZgSpZW7VqFZIo1/uoVq2aO/nkk93ff//tVq5caZ8fkGhefPHFkN/PP/98d/bZZ9tBtOrVq6frOXX2RtGiRS1Rrr+tP/74I3jb6tWrXe3atd306dNjWvUZTy1btgz+rINxsXDeeeeFvK4cOHDAffzxx8kum/+xyL62bNniGjRo4H766afgdeeee66bN2+eK1mypDve6L0lN2ZVWY/Md9FFF9nZex5t/wEASA+S5QCQzSxbtsx9//33wd/VxsOrMj98+LCbOnWqu//++93xauDAgS47UmXdd999F/z9hhtucG+//bY78cQTk9xP7Sj8BwSA493WrVtDfv/2229dnjx5Mryt8J/mrwr6jh07urVr1wa3l7feeqttU5WYP95pexNrN998s138dNaQ2nDEe9mQef7880935ZVXBv/WpGrVqm7u3LkxO1ATaxrnWanlSSLq3LmzXQAAyCh6lgNANqNWK37hO2fhtx/Lu+++axWY6utboEABV7duXbsurVQZPXjwYKsQrFy5sitRooQlu/Lnz+/Kli3rmjZt6l5//XV39OjRkMdF6p+u6uvk+uumpme5KovGjBljVW3Fixe3vsXqC66d9QceeMCtWrUq4nuI9Nw6XbxJkyZWrZ83b157b88++2yaex77kwZehXx4olxURfvkk0+6Ro0aJVkuf7sMUcIp0ro4Vt/OY/X99Ko/NbaURNTnqM+zbdu27tdff032ParNhQ7eeM+ryt1I9Bn4X3/mzJkx6zka3mNXfy/ffPONfcannHKK/R2ob/b8+fODj5k2bZqrVauWncWgcdS4cWO3ePHiJM8dab3u3r3b9erVy1oPaPxoPbZr1y5iv970/g356cyEZ555xhJV3tgvXLiwVT3eddddweVO65hKLVWNKgFdoUIFW196z1r2Fi1auHfeeSfJsnt9xsNfR4+L9hjQ39yXX34ZUtWqcd6vX7+I91dLpLvvvttatmjbqHWpx1577bVu0qRJlmxPzRhQ4lDPU6pUKZcvXz7bDr3wwgshr6PPVtsY3a7WMDromVwLrg4dOrhLLrnE1quWS39z6vOuMar3En7gITU9yyP1OVZl8IMPPmhjwtsGaE4FvZ/MpO2ff1leeumlJPfRAWIdUPTuo3X777//JrsN0Tpu3ry5VZp623H9nURqZ+bRWNHf6llnnWVn/+hxWhe6zmuXFU7LoLMk1HpEY0XrTZ+pWo5ceuml1jNfn2F6RGs8quVX37597Xn0nrQeb7zxRjvbIhr0/a2Ywv+dd+GFF9o2NblEub5PNeeKEs4am1pn2u6dc845rlOnTsdctvR8VtEaJ+kR6bV1toW+e/QdpO+i66+/Pti+Rutn3LhxFh9o3egzu+mmm5LEFSnNc9OlSxdrcacxqfGo33V9ctatW+e6d+/uLrjgAvsO0XjTNkCt/nRwK6UYSGc/qppe3wF6Lw0bNrRYKjX0NzRy5EjbTnrjU98fOqh5LMeKH8K3gfo+evnll+1vU+NGF8XA4We++H399dfBeEFjVJ/JqFGj3H///ZfheYEAAFlIAACQbRw+fDhw2mmnaQ/FLieddFJg//79gUsuuSR4nS4//PBDxMeXK1cu5H49e/YM+d1/6devX5LH+2/Xc/ktWbIk2efyXxo2bGjvI9JzJnfxv1b9+vVDblu/fn3IcixfvjxwxhlnpPh8J554YmDYsGFJ3l/4c7dt2zbZ53jwwQfT9Nm9++67IY8vWrRoYMyYMYGff/75mI8NX67kLt66aNeuXcj18+fPD3k+/e6/Xff32717d6BmzZoRX6NAgQKBe+65J+S6/v37Bx/bpk2bkNu+++67kOc+cuRIoFixYiGf7X///Re8/VjLfixalpTeW/jt119/feCEE05I8j513QcffBDo2rVrxPWQN2/ewOLFi1Ncr1deeWXgzDPPjPj4U045JbB06dKo/A15Pvroo5DtQ6SL91mldUwdy6FDhwK33HLLMZ/viiuuCOzcuTPZbVKkS2rHQPhzJfe4Z599NuR+efLkse2o5+jRo4Fu3bodc7mqVasW+P3331McA5dddlnIePdfevToEXjrrbcCuXLlini7tg/hKleufMzlKlKkSGDZsmVJHpvS9nvSpEkht1977bWBU089NeLz67H+zzCtNKbCn9Nvx44d9t3mX8/h/ve//4U8/rHHHkt2G3LXXXcFcubMGfG9NGjQwMZu+DbqzjvvTHEd58iRI9C3b9+Qx2ncaHtyrM9H6zUtojke69atGyhfvnzExxcuXDjVf+/JbU+1XSlbtmzIdYpPUhove/bsCTRu3DjF96a/keeffz7JY9P7WUVjnIQ/3v89eCzhj23WrFnE182XL1/gm2++CbRs2TLZv/Xffvstxb/lW2+9NVCqVKmIj9dnFekzHzt2bCB37twprld9Zv7tpqdjx47Jfg4PP/xwkvES/nlq25PcGFDcldL3+7HiB/9txYsXD1xzzTXJLqtitnBTp06NGC/o0qRJkyTrGQCQfbEVB4Bs5J133gkJxFu3bm3Xjxw5MuR67ZBEEikx5e0wREowz5kzJ+TxqUmWlyhRwnaOGzVqFGjatKkli7TD53+sklUe7QSG7wjmz58/eL0unTp1SlWyfPv27fZ+whMTV199deC8885L8v5ee+21kPcQKYF48sknW9KzYsWKIddrp3rDhg2p/uw2bdpkSfrkkhR6De1sr1ixIsljdeBC6yE8EaqdVf962rZtW1SS5XfffXeSHceLLrooUK9ePUsShy+/P0mg5Lj/tvbt24c898yZM0Nuf/zxx0Nuj3WyXBeNTyVxwz9jjUP9X6hQIRtDGtv+2/V3k9J69Sex9PlqLPmvVyL94MGDGf4bEiVUlPT130ef1cUXX2wJPC/J6n1WaR1Tx6LP2f88Gut6D5HGjBJPHv1t63W8de1d/Mvw448/RjVZvmbNmiSf0eeffx68ffDgwUluv+CCCwJXXXWVHSzyX6/tij+JFmkM6O9Hn8Oll16aZBuidaMkkJKY4dsobRcOHDgQsuz6HPWY6tWr25i64YYbbGyGJ2l0e7iUtt/hCTb/+9ayhSeInnjiiUBmJcslPCn25Zdfhtx+0003haxHf5I4fBuii5Lv+hvX+wm/rU+fPiHPfd9994Xcrs9cY1Z/7+F/w+PHjw8+buHChUkOiOkxSqLpdZXYTE+yPNrjUZdKlSrZ+An/2+zQoUOali3S9tR/0dhRMjwlWj/hB5K17dPn5U/Y6u9IBwSj8VlFY5yEP/7cc88N2W6ltA2L9Nr6ntGyn3766SHXe9tGHXTT+9J2wX+7ktPH+lvW34i2Qdoeh39P1K5dO+Txb775Zsjt+tvXd5A+p/Bl0wFSP8VU4a991lln2TbKG/8pJcsVD4Tfp2rVqhHHekaT5d6lZMmStnzh34Vabr9169Yl+R7WY/SZJHfQFwCQfbEVB4BsJLxq7cMPP7TrN2/eHFIRpWSbKnTChQf0l19+eWDfvn1227///msVSP7btdPol1KyZdeuXYG1a9dGXO4tW7aEVAoqiRYupef2SylZ/sgjj6RY0RaedNCOn7+qOfy5tRxe1ZbWp3bY/LdPmTIlkBZKUKaUWPAu+pwjJSmPVVXvyUiyXGMpPKn/9ttvB29XxWr4DmN4RZ12+L3bdF9VikaqPFeSUK+XlmWPdrJc49I7QPHPP/8EypQpk2SMbNy4Mbhu/IkG/eyv8I6UmHruueeCt//666+2Y57cGMrI35CSIP7nVXIj/GDOqlWrAvPmzUvXmErJypUrLZHlPYfGjz/5rDNdlAjyv86sWbNS3DalR2qT5fqcwz8nJYhEYzV8fKua0KN1Gn5g0V/xGmkMTJw4MWKSVxetN+8z0Tb4wgsvDLndvx5FYzW8wlW0Hbv55ptDHqvPO7Xb2EgJNl2X3O3h3w3RTpZru+vfDvmTcjrzxZ/kve6661Lchuj78Jdffgners/Lf7uScN73oA6k+L9LlWDU63m2bt0aso1Q4tv7PF5//fWQ5w3/+1OFuA4mqmo3tTJjPPq31+G3q+o8WslyJXePlSj/5JNPQh6jg4P+8a3Pw5/0Pv/880NuS+9nldFxEunxKV3Ct0Xhj9X3jDde/vrrryQHMZQw9mKZ8APS4Z9ZpL9lL1b0Hh8+prztjLYj/jMDdMBH23eP4qDwgxvffvtt8HZ9Pv7bunTpYuPee1/ht/uT5fpswhPq/jMAtd0I//7MaLJcB2W8A5L6jg0/C8h/EE7vxX+bCgj0ne2tl/Dtb6TtGgAg+6BnOQBkE+pD6++jqP626gMp6iOpXpce9ZqdNWvWMZ9T/ZHVU1JOOOEEN3To0JDbFyxY4A4ePJiq5VMvZ/VMVT9q9bhUP0evf7WWb//+/cH7Rqs3argPPvgg5Hf13VWvTc8jjzxivW096r3rn3QznO6vHp+i/uLqDeuX1t69mnBw4sSJwedMzocffmgTgKa1L3o0qMen1/tX1MtTPbQ96s+pntQp6dGjR/Dnf/75x02YMMF+1hj43//+F7xN71FjI7x38v9/MN8u/gkaM8Mtt9ziqlSpYj+rP2qNGjVCbr/nnntc6dKl7Wctq3rYeg4dOuT++uuvZJ9bfcrVo9ijHrrhk49pwruM/g1pGdSz16P7qy+y+tL6qUexeplHm3oN+8eqxot6FnvOP/98m1gzfIzHS6Se715/2U8++cTGrEe9wVu3bh38XevUP76P9V7Uu119vj3hffy13fY+E22Dw8d7+DZGY2js2LE2H8Ppp59u/Yu17HqsJgb2y8h2Vu/bP5eBeqqntFzRpm2kejJ7NI/G5s2b7Wf1vvd/L917770pPpf+5vQ5eDQW1dvas3fvXutD7H2H+MeH/h7V6189vXXR37N/rGuegYULFwaX2U/j5JVXXnFfffWV27Ztm31O+rv2bxOOJdrjUWPmscceC/6u8ab+55nxueo9a7Jx9XJOznvvvRfyu7Zlbdq0Ca7vRx991LaBnh9//DE4v0FGPquMjpNo0/eMt73W/APaVvupd7gXy2gMKf5L7Wd21VVXWZ9xjx4f/h3ufQ8pHtLcIx715FZ/e2+dtmrVym3atCnieFPcqc/Ho97ojz/+eHDbqvelmCo5em3NueEfq127dg3+rn7g0Z68U/PPaBsqmuNDf19+/nU7Z86cJPGlvrO9+FC97QEAx4+kM4sBALIkJb/8SUwlpPw7kdqB1uR6/qSjfwcpEk2g5KedE+2Q7dq1y37XpFbaMTrzzDOPuXxK1GgHzL+MydGkh5khfJJALwnq0Q7NeeedF7Kzp4kWNaFeJBdddFHI796OkT9ZmlZKnCkJpUklNbniokWLLNHp30kUXa/LZZdd5mJJk7OltA695GdKrrnmGhtbK1assN/Hjx/vHnroIUt4+RO+x0pyxUL4+/MnjiK91/DbUxoDeu7wSb7Cn8+/vtP7N6Qx7E8KaeJHJVVj5Vh/d1KtWrWQ3yNNcBqvMe4lSjLjvRxr/KRlfCn5WKdOHffzzz+71MjIdjYztn1ppSTwG2+8Efwu0sSZ/fv3D5kgUwlqTbiblu85/U3qoJd/PXpjIvyz1ASL3iSLydFjlHTWgRAti3dQe/r06Xbx6ECtto3dunVLskzJifZ4VKI0fGJpfbZKBEukSULTQgff/dt4HSzQZ/fqq6/aAZ1w4cuaUjLb/xglTjPyWWV0nESisRk+4Xpmfg95McOxPrNIYy2576HwdapksQ5OpcR7TPi60feQJitN6XUjLYNHsVr4mDlW7JEWmswz/KBEStu58OUL/7vT+9XjMyu+BQDEFslyAMgmpkyZEvL7W2+95T766KPg79ohDa/20c6UvwIps2hnrVOnTiFJvqJFi7oLL7zQdkhECYQDBw5k6nKEV2KHJyrTSpVQfpF29tNDy6WKbV1E1XEzZ860irp9+/YF77dq1aqoJMvDk686SyEWia7bb7/dfv7111/t83/99deDt5999tmZUuWcVv4zDyRnztCT7lTdHQtZ5W8oK/zdZTb/dtOrgPTOKIj2e4nm+Bo0aFBI4k5JT1VCFitWzJ535cqVts3wZOTMlMza9qWFEruqivUOAitZrgONOvvF06FDhyTrNNb8yWF97yoxrO/nxYsXh5x5ooO0OoitAwBffPGFu/jii+P+nRbtz1bVxxrTI0eODF6n96vt2tSpU5Mk6jO6vmP52ET4Hjqe1mlm/y1E2u5k9e8+AEDq0YYFALKBpUuXuh9++CHkOlV/q+rHu6jqMDz5pp3TlIQ/p3bmvapyUeV6yZIlj7l8P/30U0hltFp1bNy40VrBvP32227atGkuFsKracPfn3bYlVBK6TGZRdVGySU6tdN1/fXXu6uvvjrkev+ZA2nZEcudO3fI7zr93M/fsiOcqqP8/KdV+z/vY9Hp2v42IEr0qaWA/xT3433HMjXrzmvdkJG/IVVZ+telTqNPbeV2ND6DY/3diXeWQXKPiRW1Cgg/Xb5Zs2bWbiCrv5fwv1u191CrLJ2xoTFSt25dd7zxtxjR95MOKHqtN7R9bN++/TGfI9JnGP494P0dhn+WTz31VEhbqEgXtRrxJ9uU0NfBz+3bt9v36bJly6yVhb9addy4cal6/1l5PKbU2qJXr14h1+nggdrqhFdBhy+rtnPHWt/eGXMZ/awyMk6yk0jvK7nvofB12qhRo2OuU217IsUO+h7yzlhI7nX9wh+vA3/hLbNSE3tklvDPPnxZ9H798TMAIHsjWQ4A2YCq0TLjcf369QsmcNVXtHfv3iG367Ryr59jSsKr2pWs9RK92tnR8x6rItb/Okrupuc0//C2M+oR7j8lVkkyfwsWnRavyt1Y7bBqZ1A9WCMlUbWjFd4P1d8fW8I/i+R6lfr7ssukSZOCSQpV1Xo9xCPRKer+6j+1gnn//fdDEjP+CvHk6DkefPDB4O+qsvR616o3uL+Ps58STUrgehd/FWl2oyrg559/PuQ0bvWb9lPv6Yz+DakC3d8LWwmM2267zZLtfuvWrXOffvppusZUSpo0aRKSdNdp+0rk+hNOqgr2O1aLqMygsaSEsv/MCiXJdSDHo0pm/zrR36S/F7jWT3iyPVbvJXyMeAl+7+/U357keKF5OfwtKvxtOnSQI3zOg0j0N+c/ePTSSy+5tWvXBn/XmRveWT76LP1jefjw4RHntVDFuL5flbz3b8OVKNaZNB61ZdCBL+8sG/9Bm9TIyuMxJUpc+3uji75H1D7O/90e3gtfBxUiHejT+9Tn2KVLl+B1GfmsMjpOshOdmeGf7+b7779P8h3ufQ8pHlI7Pn+fbrXSCac5AxRL3Hzzze6PP/6w61RYodYpHn3OijG9syN0MDh8Xhw/nd3jr6DX844ePTrk7yv8+zOW1EIpfM4fr6pehRjhcwcAALI32rAAQBYXqUJciddIvRsVsCt54FUSqyJdidnk+jwqcaYJrdR7UTuF4TupKU3G5Kfn146k10JEiVG12VA/SCXK9LzaqU2pLYDuqwo80fOoz6bXs1I71G3btj3mcjz88MOWGFZFn5dA0iSL2gHUznZ4JdCQIUNiegq/Phe9pi6nnXaaJcOVTNFOpHqY+5NhakEQnsjXOvLv9DZv3tzaMKiNhD5Hb0dUFeo6UOCZPXu2vZ6Sa8dqwaIdXq1rTUTqUYJDfd2VtNFypnbSV1WPa4cyvIenKgxj0R4oK1BrlRdeeMFO+dbfhb/STlV8qsCPxt/Q008/bQc6vIMiSirq8frbVpsOJRp0oEPJC3/7m9SOqZTo71RjxmsVpXGsZVHfayX99V78kxRqUktVLGY29RDWgQStc61DL6nj0XtUiwitJ4/GZc+ePUP+fjQJrNaDEjlLlixxe/bsCVl/yR34iTYl6vxtVmrVqmU9zLU8SqLGY0LgWNDkhu3atUtyfWrnPNDEoPo+UdsTVX6GJ1SVgPUmutbneffdd1uiVPRdoiSe/o50sFMJQPUR/+WXX+wglr/aVNtxzc2gi+6r7x71bNb403bT79xzz03Vsmfl8Xgs2vbr71/bHP9kwJrYWYlzHTRVAlLfV94EkzrAqEk19d2n7yIdINS69nq3169fP/hcGfmsMjpOItFBjEgHwkXb4NSeTRBtXjW+tsda59pW+A9YqNWbt14VD+m7xJsAVOtNf3valmp963YVHGg75D2H7u+PGf2xmtrxKKmus58Uj4af5eansaJ+/v7xot91oEPbcf0NhVeqx5ImG3355ZeD32VqpaTvSB0M02TKKfWzBwBkQwEAQJb21ltvKQMSvFSuXDnF+3fo0CHk/g8//HDwtnLlyoXcdvfdd4f87r/06dMnyXP7b9dz+Y0ePTrZ57r//vuTvHa4sWPHJvt4/3uoX79+yG3r168PeZ6lS5cGypYtm+xz6XLCCScEnnrqqSTLcKznnjRpUsjt/fv3D6TWggULUlwm/0XLv2bNmiTPsXz58sCJJ54Y8TE1atQIue8NN9wQ8X65cuUK3HvvvSHXtWvXLuSxu3btClx44YURH583b95A69atU70eevbsmeQ5vvrqq2Tvr2Xx33f+/PmBtNCypPTewm/XZ5qW109pjOi+/tuuvfZa+3uNtB4LFSoUWLJkSVT/hj788MNAkSJFUhxb4Z9VWsZUSg4ePBi48cYbjzm269WrF/j777+TPP5Y7y01wp8jpct5551n24pIjh49auv7WM9x/vnnJ9lGhI+B8PF3rG1ISuPz119/DZx66qkRl6VChQqBTp06pTi2U9p+p2bbltLj00LrLHz5U3L48OFA6dKlQ+5/9tlnJ3v/8L/hrl272nYv0nq78sorbeyGv17btm1TNY603j3Lli1L1WPOOOOMwKZNm1K9vjJzPGb0b+9Y21sZOnRokmW96qqrAvv377fbd+/eHWjYsGGq1p0eF43PKhrjJPzxKV3C/14y8j1zrM8s/G+5WbNmyW439Hel7Uo4fRflzp07Ve9tw4YNIY9t3759sve96667Qn7X+wz/PBs1ahTxsTlz5kyy3sLH27HWa0qfSWoeP3XqVIsfIy1fy5YtA6VKlQr+rrEEAMi+aMMCAFlceCsVrxI1Oao689PptuETPHpUkaXJyFShqKpWVU2pykj9RR9//PE0LaeqrtS7UtWPqkDW86lCS5XeY8aMOebj77vvPqu8UkW1v71AWqkiTdVdOh1eFayqqFZLEC2PKrk7d+5spyGH91TNbGqTsXz5cqvCUqW2lkWTemnZVFFVvHhxq/gdMWKEVcD7q109qphTD2udmq/HptRvevr06XZKuyqf1M5D60GTr6m6K3yMhFO1u6qm9HhVR2r5VBmnU671+PDTkVOiViz+ti6q3IvGpKXZgarhVMWn1jv+9agWKapaVLV+NP+GVD24Zs0aa4GgSkF95vrs9Xmec8451uLm2muvTfeYSomqtLXd0FkMrVu3tqp5vQe9Z53Wr2pSjcn58+fH9KwCnZmi9aj++Rp399xzjy2jthHJtWDSOtD61pkpd911l/0tatuodam/U7UG0bbz22+/tYrJWNE6VSWx2kl4n62qZR944AG7XmPreKT3qffop88xtTT2tH5atGhh601jVZXd+jvRWRX6Pfz1dJaE+sHr89d9NYY0llQprrNA9Dess2/0vB5VROv7WmfUqMJZ416VvNr+aVugswB0VpG+B1IzF0hWH4+ppcp4fR+HtwbRtkhn0midahvkTXKt7yzFAFrfqp5XTKDe9Opn/sEHH0Tls4rGOMkutI1XzKMqfI1JrTP9r5hLYyZSj3t9F6l6XHGSKtL1OWid6nPR56Oz/YYNG2Yth/xzk4jGota3dzaaPgedaaTJb/29+yPRsukzVksdxUha5/q+UKsvzdmg77B40nebxprGrr5X9f5UWf7cc89ZLO2fOyi8HR4AIHvJoYx5vBcCAAAcn5SU9PccHj9+fKrbJ2Q36omtAzQenb6e3vkGAPw/6ges5JwoQaWWOskddFFCzWsJJDpAo2QdwDhBRqgFjQ6khE+iLn369HFPPvlk8Hd/iyAAQPZDz3IAABBVqoxXJd7OnTut2sqjaspIvYcBIJzORFAfYM2nobMrPKrcTpQ5DwBkHZqoWmf/6aC4+uKr4l698lX17p8TR2c36IwyAED2RbIcAABElU5lVyWon07h1o6mqkIB4Fh0Fsrnn38ecp1anfgnuwSAWNIko+HtgPzUfkUtgyK1twEAZB8kywEAQKY59dRTrTe0TlFWH20ASAsdaCtdurS7/vrrreexegUDQKw1a9bM7d692y1cuNBt3LjR/f333y5nzpzWmkXt5tRbvW3btq5AgQJ8OACQzdGzHAAAAAAAAACQ8HIm/BoAAAAAAAAAACQ8kuUAAAAAAAAAgIRHshwAAAAAAAAAkPBIlgMAAAAAAAAAEh7JcgAAAAAAAABAwiNZDgAAAAAAAABIeCTLAQAAAAAAAAAJj2Q5AAAAAAAAACDhkSwHAAAAAAAAACQ8kuUAjkt33HGHO+OMM+K9GFlKjhw53IABA1xWtWTJEnfZZZe5k046yZZ1+fLlLruMrViv28svv9wuAAAAgEyePNli0m+//fa43a9YvHixy507t/v9999dvHz22Wf2/vV/ZmjVqpW7+eabM+W5AaQOyXIAcaMAS4HGX3/9FfH2888/PyESgkoK33bbba5MmTIuT548rkiRIq5BgwZu0qRJ7r///nPHg1WrVtlnnTdvXrdr164ktx85csTddNNNbseOHe7ZZ591r776qitXrpwbN26cBf6xpES4ljXS5eDBg6l6joULF9r4jvReAQAAsqJ169a5e+65x5155pkWsxUsWNDVrl3bjRo1yv3zzz/ueJPeeO3LL7+0ZObpp59uidtChQq5Sy65xA0aNMht3brVZWcLFixwjRs3tvemMVC2bFl3/fXXu6lTp7qsoE+fPq5169a2n+DR/qLidC1nuN9++81uGzZsmMsuevXq5d555x33/fffx3tRgIR1YrwXAAAyw0svveSOHj2a5Vfuyy+/7O69915XvHhxd/vtt7uzzjrL7d27182bN8+1b9/ebd682T366KMuu3vttddciRIl3M6dO93bb7/t7r777iQ7Z6oQ0efmv03J8tNOO82quWOpevXq7uGHH05yvXaIUjO2tPM1cOBAW+7ChQtHffnmzJkT9ecEAACJa+bMmVa4oMKNtm3bWtHK4cOHLXnao0cP99NPP7kXX3zRHU/SE6/169fPDR482A4o6HH6X8UUS5cudcOHD3dTpkyxuDY7euutt9wtt9xicfCDDz7oTjnlFLd+/Xr3xRdfWPzbpk2b4H118OTEE0+MeYHRJ598Yp9bJDNmzLDPoUaNGi47u+CCC1zNmjVtPL3yyivxXhwgIZEsB3BcypUrl8vqvv76a0uU16pVy3300UeuQIECwdu6du1qp1D++OOPLrsLBAJWjaIAWwH366+/niRZvm3bNvs/MxLL4f79919LdivxnRxV06jaP5KcOeN3UtaBAwdc/vz5U1x2AACAtFB8ptYPqtb99NNPXcmSJYO3de7c2f3yyy+WTE9006dPt0S5qsp1FmR4PKazI3U5Vlys5Hq+fPlcVqMq+/POO8/2UcLfmxere1R1Hms661aV7pdeemmS23S9Co508OODDz5w2Z3GWP/+/a1w6OSTT4734gAJhzYsALINrz/cm2++6Z544glXunRpC9SuuuoqC+KP1Vdap1jqep0qqaRsu3btrEJBz+lv9ZFcP+hIz6mk68iRI13lypVtWVQhrtNXVUF9LArm9NpKHvsT5R5VFPgrqvfv32/Vzl67lnPOOcdOKVTQ7Xfo0CHXrVs3V7RoUXvepk2buj/++CPiMvz555/urrvusuXWc+p9TJw4Mcn9xowZY7cpUasqEy1bak/H/Oqrr+wUSO2E6aLqFP/y6D3Wr1/fflZFk9aJ1r/WtaqYPv/882AbFP/nos9TBxW89VGxYkU3dOjQkKpv/6mX+pwqVKhg9125cqXLrH742tFQBZaUL18+uOxaFn+lvapetKOktjtaLxs3bgx5Hr1XVXWpQqZevXq27r2zDMLHaFr+NmTs2LFWCaXXv/jii+10YvqgAwCQmJ5++mm3b98+N2HChJBEuUcxliqN/YUHShp7cZXiIsUoikH9dP11111n1emKNxSbKP6IVC2ruE7xqx6j51Qsowp3f7tGPb8SiFoe3UcxYM+ePZO8rmKi+++/32Jsxct6XcVdikHTEq9FqirXGY9aT5EKF7SPEd7H21sHs2fPtvhZsdcLL7wQTP5eeeWVrlixYvZ+lKgeP358kuf1nkNnFqrqW+9H93333XcjLqfWx0MPPWT7ApoLqHnz5m779u3uWFQRf9FFF0V8b1rG5HqWe/F2che/b775xjVq1MjWlWJb7QNoXyE13n//fVtf4c8p2ufR+Pnwww/dd999d8zn+vXXX22/Q3G4lkMJ+EgHhLTP0qxZM1uPWgd6jfDxlpb3poS+9l+8ca7nvPrqq5Mss67Tvt/cuXNTsWYARBuV5QCynaeeesqqe7t37+52795tAf6tt95qAUpylFC+4YYbLFhXNfe5557r3nvvPUuYZ4QS40q033nnne6BBx6wypznnnvOLVu2zIKj5CrcVSGsVitKgqoS4li0/Ep6z58/39qzKFBW0K0gXwlvfxWLqraVjFUltybMVIVQkyZNkjyneioqMPR2KBRQf/zxx/b8e/bssUBOdNql3tuNN95oO0qqhlmxYoWtb//pmMnRjop2phR8K/mr4PGNN94I7qBoHaqS+8knn7TX0f2UvFeA2KVLF6umUH9C0fXe+lMAqveux2sd6pTM3r17W+saJcb9tDOi5e7YsWOwL3xK1EM9vJe+lluXY2nRooVbu3atvUd9LtqpEq1fUTK7b9++VjGiz0o7LzoYobGgceOvrv/777+tb6SS6ap0995/Rv42tBOmz7tu3boW8GsHRzsBOgiiHVMAAJBYlGBUEltxY2ooflG7EcWGKuRQnDFkyBCbo0bxtZ8O2ut+ii8Vd6soQ4UHSl6rEEOUqFdcoseriOPCCy+0OEwVwkpWKpZSMYRiYcXyiucUy//www8WaynuUiLVT8UWqgRXbKnYTxW6SmRqgkjFo8eK18Lpvrrovae10nfNmjXWZ1sxa4cOHSyB78VkWgd6X2ppos/hvvvus/eqin6/n3/+2VqkaD9G61GxrZK9s2bNssSqn+JnxXU6sKA4T3GxYj+tj5TozALtn2idpyUm1DpTpX14LK0405941z6J4lp99lo2xazeAQMVbuiASnIU82/YsMHGRnK0n6LPUkn8lKrLtQ+ksa79CY2PU0891cazPge1i9TBBa/VjApP9Lq6X6lSpex96n2ES+170+en19DnoQMeivU1pjX2/e9Nt+nAivYnveUBEEMBAIiT/v37qyQ6sH379oi3V65cOVC/fv3g7/Pnz7f7n3vuuYFDhw4Frx81apRd/8MPPwSva9euXaBcuXLB399//327z9NPPx287t9//w3UrVvXrp80aVLwer2m/3WTe84vv/zSHvv666+H3G/WrFkRr/f7/vvv7T4PPvhgIDW85X/88cdDrr/xxhsDOXLkCPzyyy/2+/Lly+1+9913X8j92rRpY9drnXvat28fKFmyZOCvv/4KuW+rVq0ChQoVChw4cMB+v+GGG+yzSI/Dhw8HTj311ECfPn1ClqVatWoh9/M+27feeivFMeAZPHhw4KSTTgqsXbs25PpHHnkkcMIJJwQ2bNhgv69fv96et2DBgoFt27alapn1Gesx4Rdv3YWPAwlft88884xdp9f3++2332z5nnjiiZDrNXZPPPHEkOv1vvUczz//fJJlDB+jqf3b0G36PC666KLAkSNHgvebPHmy3S/SugYAAMev3bt3WwygeC81vFjz7rvvDrm+e/fudv2nn36aJKb64osvgtcpHsuTJ0/g4YcfDl7Xr18/u9+7776b5PWOHj1q/7/66quBnDlzWvztpzhJj/3qq6+C13mx27fffhu87vfffw/kzZs30Lx582PGa5H873//s/uOHDkyyfJpX8Z/8cdY3jrQ/kE4L9b2a9iwYeDMM88Muc57jnfeeSfkc1Mcf8EFFwSv0/6M7tegQYPgepNu3bpZ/Llr164U3+OECRPs8blz5w5cccUVgb59+9r6/u+//5LcNzz2Dad9Eb2mNx60PGeddZa9P/+yaR2UL18+cPXVV6e4bJ988om95ocffpjkNsWv3r7KwIED7X5Lly4N2RfQZ+3p2rWrXecfS3v37rXlOOOMM4LvV5+17vfmm28G77d///5AxYoV7XrF32l9b9rH6ty5cyA1zj777EDjxo1TdV8A0UUbFgDZjqq4/VUKqkTxTqdLjnqCq2KjU6dOwetOOOEEq7zIyCQ4Os1O1RyqfvEuqihQxYmqwJOjym2J1H4lueXX8qqqwU/VPIpXVRHu3U/C7+dViXv0GM2yrlnj9bN/+Rs2bGhVyd7pgKp0VoXJkiVLXFppuVQxoWoaj37W7O5qsZKRda/PXVUz/mVv0KCB+++//0JOs5WWLVsmWykUySWXXGKnPfovOhU4o3S6rKqFVFXuX25NfqrJXcPHjCqhNN6j9behPvj6PFTV5J+USdXnWpcAACCxpCcmFbX58PMmRg9vZaEKWS8eEcVjqqz2x+2KSatVqxaxgtZruaHYT9XklSpVComhVLkr4TGU5gTyT/SosxB1lqnOzFSsmN71FF5VrphZ78l/UZtHP7V5UXwdzt+3XM+j96MzJ7Vu9Lufqpr966dgwYIWm+qsxC1btoTcV5X3/lYlWv96z7///nuK71FV/apUV2s+VTur1Y4eqxg1uUk1I1GbHVXy6wzHK664wq7TOlF1vM5KVSzqfX46k1TV24rd/a0Uw+kxcqx41ZuYVO0uUxrDqvSuU6dO8Dp9rlpvqsT32jXqfmpLpDMjPDrLVPfzS8t7036VzsTYtGnTMdbi/73X8DNdAcQGbVgAZGmRetKFty3xgqaU+oQrOFSwEx7geqdBpoeCIgWy4T38kpsIx08Brte3LjW0/AqSw3dktNPg3e79r9P+1PYkpfep1h/qDfniiy/aJaXl79Wrl808r6BSPSKvueYaCwZr1659zOVWOxjtICjp6/XO1rIp0FR7FrVeSe+6VyuY5BLg4etey5AWOhVXifdo03Lr4IR2OiIJb9uj9jRpmczzWH8b3jjR5+inxHlKfdgBAMDxKT0xqWLN8FhCB/6VCAxPyEZqN6j4xB+3q1e2ChuOFUOpVUVqY79IsdbZZ59trTcUB2t508KLwdUyxk/7Fl5fafUUf+aZZ5I8Nrk4VC021LJj0aJFtlx+2sdQUY5H6zt8v0jvR5Tg9b+f9OwreZTU10XLo3lz1Lrl+eeft57pq1evTna/x584VqsRFcf4D6jo85OUWmDqPR8rGR4+V1M4rTMVCWm96kBCpOfTGFVhTDj/fpVa9ej/SOs9fL8qLe9NBxB0P/Xb18Gca6+91g56qA1SpPcaaV8YQOYjWQ4gbrxZ1NUPLhIFaZFmWleFdXqCp9RSUBLpucKrUFQhoIBRSd9IUqpkVuClBKV6LcaDV92gPtjJBXZVq1YNBo7qtThjxgyrNlH1j6pFNMlRSlUbqsBR70X1Co+0w6IJQtW/Oz1BoJZfFf2a1CkSb+chUuVOPGm59X5VcR9pHIcfzEnrcmf23wYAADi+KFmugowff/wxTY9LbfwWrdhEMVSVKlXciBEjIt6u5GNmUkW7hK8nxfNegYV/AvtjxXM6QKCqYz2v3pOWXwUSqmZW3+2Uqqxjsc5V2KKqcl1URKKYX/FrSglhJeN10ENx+Msvvxxym/d+dDBBcy9FklIvePUV917jWLze5Vrm8HmMMkNa3pvOLtU6VW9/7+DK0KFD7exT9Tz303tNrsAGQOYiWQ4gbjSJjCgRGx7gKlG+ceNGq2KO1mtpwhpVg/gDMb12OB31j9TSJbxSRhXSqrhWhXVak5oKQHXaqCaD0fs8VoCv5ddrqerHX12uCg/vdu9/BWwKwP1VD+HvU4l8PY8OAKSmglozwGtSIV0OHz5skyIp0a0JNSMd0BAFfUqUa/Iib9Ik//I89thjVlHjPwUytTtiWvf6LDOj+jsaUlpu7aiowig8oR8L3jhRlb93Wqz8+++/VpXkHSABAACJQ1XDOtNQFc5qX5ISL9ZUNa1XietNmqizFr1YIy0UHx0rWa/7qI2fEsypSdR71b5+mqBTMbhX0JKWgg3F1UpcaiJRJWAVG2eECkoOHTpkE1H6K8GTa+Oo2C280ljvRzL77MCaNWva/5s3b072PhoTauunMaB9Fq1nP++sVx2cSU/87h2sWL9+/THv61WXa6LPSMl9jdFI+4CR9qs0LsPXe/hj0/redLazJnLVRWdEaGJP7Vf5k+WKzbWPqElHAcQePcsBxI2CXVVQKJkaXj2hgF1BQvgR9vTSKW56Pr2WR4niMWPGJLmvAh4FSzpF06PgXIldP1UG6DnUzy+cXkvBYkp0eqCCr9tvvz3JKZ2iUx81M7u3/Hqt5557LuQ+qppQ8OatJ+//0aNHh9wvvKpCFSeq/FCVeKSdE/9793oEevSZqf+kll0z3afUgkWnFOpUTPX681+6d+9uBy2Sq8r3aEck0nrUutcOnfpOhtP9tf7jyduBCl92HWTQulelS3h1j34PX9eZsbOjypyXXnopZB3pc0hNpQ4AADj+6Ew9xS533323Jb3DqQhj1KhRwZg0UmzpVXw3adIkza+vmFSxtqptw3nxkmK/P//802KYcDpLVf2h/RQnevPviBKP//vf/6wQx6u8Ti5eS46Sr+ohrblfIsXAaanc9pbB/xi16pg0aVLE+6vHtX/96AxO9QZXJXNaW8okR4VFKfWpT6l9pWJbxeVvvPFGxLYzajmifaxhw4ZF3O/x73tEotaEKi7S/DupoWS52gINGjQoyW0aw4sXL7Yx4tH40f6nDjxoP8e7n9b722+/HVLQFd7CMrXvTfty4b3odZayzuzQgRM/9U1X0dFll12WqvcLILqoLAcQNwoO1MpDFcb16tWzI+eqQtAEMgq0FMxqAspo0POoAvyRRx6xCloFQap8Dg9YvMltFPCrX1/79u3tiL969VWuXDk4uY9oAp577rnHDRkyxPrzaXnVc1qVLJqESDsV/glhwin4GTt2rFUVqFpCSXNVrKh6/LPPPrNKk8cffzy4/KoE7tOnjy2/JkHSqXsK+hUMehUNCpjVI1BtUvTe9BoKfL1+4X5PPfWUVa+oZ5+Cfq2THTt22I6FKkL0s+h9KQjX+itevLj1i1TSXjtDyU0GpcBSzx0+0ahHPcy1frWewhP74cGnDnBoPah1jcaMKvJ79Ohh60eVUHfccYfdT0Gu2toooNU6Cq9mjyVvQil9Xq1atbJxoc9Qn5PeiyrytYzNmjWzdagqGe0AacIgHUjILDrQoR09TWyr9agdTy3H5MmTbdnoiwgAQOJRDKD2eDqDUNXi6qGsns06m1BxueI1xVuiGFTVukoYKsmseFiJRxV4KK7xn7mWWorrFL/ddNNNFocrjlIcqlhPMbheU3Hym2++aUUYijEVlyr5qAIXXa9ErVcBLVp+xZqKRRV3KjYWfwvB5OK15KrGNWePikwU++s96zFKDCsG1fXaf1Fcl5pJ0xVfKy7T62l/QklWHQhQrBupgltnJGq/ZMmSJRaPT5w40Q5sJJdcTw9NgKr348Wsel/aJ1AV/EUXXZTsfpnibxUPaX9O+00qmPFT20f1uVdrFhX2aJ9Kk9IrAa4DIPo8VZWt1znW8ileTk0vb1WXqx1LpJaR2h/UZ6Vl0fgoUqSIjV/F4yok0rKK9o+0z6O/BxUxqSL81VdfTVI1n9r3pn280qVL2/6hxrQKh7R+9ZkOHz485DnVB1+vo7aTAOIgAABx9tprrwUuvfTSwEknnRTIkydPoFKlSoGBAwcGDh48GHK/+fPnq/Qi8NZbb4Vcv379ert+0qRJwevatWsXKFeuXMj9/v7778Dtt98eKFiwYKBQoUL287Jly5I81lumM888M5A7d+5A9erVA7Nnz474nPLiiy8GatSoEciXL1+gQIECgSpVqgR69uwZ2LRpU6re/9KlSwNt2rQJlCpVKpArV67AKaecErjqqqsCU6ZMCfz333/B++3duzfQrVu34P3OOuuswDPPPBM4evRoyPP9888/gQceeCBw6qmn2jq9/vrrAxs3brT32b9//5D7bt26NdC5c+dAmTJl7DlLlChhr6335HnhhRcC9erVs+fT51OhQoVAjx49Art37072PQ0fPtxeb968ecneZ/LkyXaf//3vf8l+tlu2bAk0adLE1qtur1+/fsj66N27d6BixYr2OZ122mmByy67LDBs2LDA4cOHQ8aG1lNq6TPWayYn0jiItG4HDx4cOP300wM5c+a027UsnnfeeSdQp04d+3x00ZjX57BmzZrgffReK1euHHEZdJt/XaTlb0NGjx5t70Gf58UXXxz46quvbAw3atTomOsHAAAcn9auXRvo0KFD4IwzzrDYSvFX7dq1A2PGjAmJy48cOWKxevny5S1+VBypmCw8dk8upgqPY7w4/f7777fYSa9dunRpi7n++uuv4H0U3w0dOtTiI8UwipkVv2hZ/HGpYh/FVYrnFS/rvhdccIHFS+FSiteS89lnnwVuvPHGQMmSJe39a9+iZs2aFgtu3rw5VetAPvjgg0DVqlUDefPmtXWu9zZx4sQky+E9h/ZHdH9vfyk87lO8p8cuWbIk5HovToz0/v3eeOONQKtWrSzW136Nluu8884L9OnTJ7Bnz55kY1/v+ZO7+Gnfq0WLFsH9Cr23m2++OcV9Bs93331nz/fll1+GXJ9czLxz507b54u0L7Bu3Tr7DAsXLmzvU/HwjBkzkjzH77//HmjatGkgf/78tq/x4IMPBmbNmhVxfR7rvR06dMj2oapVq2Z/W9oH0M/jxo1L8rqXXHJJ4LbbbjvmOgGQOXLon3gk6QEgK1BVrSooVJXhVcwAiUZtkNS/U21iIp3eDAAAkF2o6rhz585J2hdmV2oNokr5GTNmuESnNp5qW6IK7+OVzlhWH3Od7ZvchKEAMhc9ywEASCDqfxh+nFw9L3W68+WXXx635QIAAABS8uSTT7rp06e733///bhdUWqVqVYtJMqB+KFnOQAACeTrr7923bp1s76gmuxTVSsTJkywiiVdBwAAAGRFmmtJvfSPZ9OmTYv3IgAJj2Q5AAAJRKfylilTxiZWVTW5JjXSxEWqYtFEUwAAAAAAJCp6lgMAAAAAAAAAEh49ywEAAAAAAAAACY9kOQAAAAAAAAAg4dGzPBWOHj3qNm3a5AoUKOBy5MiR8IMGAAAAxxYIBNzevXtdqVKlXM6c1KhEC7E5AAAAMis2J1meCkqUazI0AAAAIK02btzoSpcuzYqLEmJzAAAAZFZsTrI8FVRR7q3MggULpvvDAAAAQOLYs2ePFVx4sSSig9gcAAAAmRWbkyxPBa/1ihLlJMsBAACQFrTxiy5icwAAAGRWbE7zRAAAAAAAAABAwiNZDgAAAAAAAABIeCTLAQAAAAAAAAAJj2Q5AAAAAAAAACDhkSwHAAAAAAAAACS8ExN+DQAAgITTcPDMeC8CYmx23yascwAAgCymwrAK8V4ExMG67uuy7HqnshwAAAAAAAAAkPBIlgMAAAAAAAAAEh7JcgAAAAAAAABAwiNZDgAAAAAAAABIeCTLAQAAAAAAAAAJj2Q5AAAAAAAAACDhnZjwawAAEHcNB8+M9yIgxmb3bcI6BwAAAABkKVSWAwAAAAluyJAh7qKLLnIFChRwxYoVc82aNXNr1qwJuc/Bgwdd586d3amnnupOPvlk17JlS7d169aQ+2zYsME1adLE5c+f356nR48e7t9//w25z2effeYuvPBClydPHlexYkU3efLkmLxHAAAA4FhIlgMAAADZ1Hfffed++OGH4O//+9//LNH96KOPusOHD6f6eT7//HNLhH/99ddu7ty57siRI+6aa65x+/fvD96nW7du7sMPP3RvvfWW3X/Tpk2uRYsWwdv/++8/S5TrdRcuXOimTJliifB+/foF77N+/Xq7zxVXXOGWL1/uunbt6u6++243e/bsqKwPAAAAICNIlgMAAADZ1D333OPWrl1rP//666+uVatWVtWthHbPnj1T/TyzZs1yd9xxh6tcubKrVq2aJblVJb506VK7fffu3W7ChAluxIgR7sorr3Q1atRwkyZNsqS4EuwyZ84ct3LlSvfaa6+56tWru8aNG7vBgwe7sWPHBhP3zz//vCtfvrwbPny4O/fcc93999/vbrzxRvfss89myvoBAAAA0oKe5QAAAEA2pUS5EtOiBHm9evXc1KlT3VdffWWJ85EjR6breZUclyJFitj/Spqr2rxBgwbB+1SqVMmVLVvWLVq0yF166aX2f5UqVVzx4sWD92nYsKHr1KmT++mnn9wFF1xg9/E/h3cfVZgn59ChQ3bx7Nmzx/4/evSoXQAAQPaVkzrehHQ0DjFcal+TZDkAAACQTQUCgWDg/8knn7jrrrvOfi5Tpoz766+/0vWcej4lr2vXru3OP/98u27Lli0ud+7crnDhwiH3VWJct3n38SfKvdu921K6jxLg//zzj8uXL1/EfuoDBw5Mcv327dutjzoAAMi+Kp1UKd6LgDjYtm1bzF9z7969qbofyXIAAAAgm6pZs6Z7/PHHrVpbfcTHjx8f7A0enpROLfUu//HHH92CBQtcVtC7d2/30EMPBX9XYl0HA4oWLeoKFiwY12UDAAAZs3r/alZhAipWrFjMXzNv3rypuh/JcgAAACCbUpuVW2+91b3//vuuT58+rmLFinb922+/7S677LI0P596iM+YMcN98cUXrnTp0sHrS5QoYX3Hd+3aFVJdvnXrVrvNu8/ixYtDnk+3e7d5/3vX+e+jpHekqnLJkyePXcLlzJnTLgAAIPs66miplohyxiGGS+1rkiwHAAAAsqmqVau6H374Icn1zzzzjDvhhBPS1M6lS5cu7r333nOfffaZTcLppwk9c+XK5ebNm+datmxp161Zs8YmAa1Vq5b9rv+feOIJO63WqxaaO3euJcLPO++84H0++uijkOfWfbznAAAAAOKJZDkAAACQjanaW5Xk69atcz169LBJOVeuXGltWE4//fRUt17RxKD/+9//XIECBYI9xgsVKmQV3/q/ffv21g5Fz68EuJLrSnJrck+55pprLCl+++23u6efftqe47HHHrPn9irD7733Xvfcc8+5nj17urvuust9+umn7s0333QzZ87MxDUEAEitCsMqsLIS0Lru6+K9CECWQbIcAAAAyKZWrFjhrrrqKmuN8ttvv7kOHTpYMvvdd9+1qu9XXnklVc/j9Tq//PLLQ66fNGmSu+OOO+znZ5991k5fVWX5oUOHXMOGDd24ceOC91Ulu1q4dOrUyZLoJ510kmvXrp0bNGhQ8D6qWFdivFu3bm7UqFHW6uXll1+25wIAAADijWQ5AAAAkE2p0vvOO++0Sm5VhHuuvfZa16ZNmzS1YUnNpEhjx461S3LKlSuXpM1KOCXkly1bluplAwAAAGKFGXEAAACAbGrJkiXunnvuSXK92q94rVQAAAAApA7JcgAAACCbUi/wPXv2JLl+7dq1rmjRonFZJgAAACC7IlkOAAAAZFNNmza1nuBHjhyx33PkyGG9ynv16mW9xQEAAADEMFmuSpb333/frVq1KqNPBQAAACANhg8f7vbt2+eKFSvm/vnnH1e/fn1XsWJF61/+xBNPsC4BAACAzJzg8+abb3b16tVz999/vwXkNWvWdL/99ptNCjRt2jQqWAAAAIAYKVSokJs7d65bsGCBW7FihSXOL7zwQtegQQM+AwAAACCzk+VffPGF69Onj/383nvvWZJ8165dbsqUKe7xxx8nWQ4AAADEWJ06dewCAAAAIIbJ8t27d7siRYrYz7NmzbLkeP78+V2TJk1cjx49MrAoAAAAAI5l9OjRqV5JDzzwACsUAAAAyKxkeZkyZdyiRYssYa5kuVqvyM6dO13evHnT+nQAAAAA0uDZZ58N+X379u3uwIEDrnDhwva7zvpUMYv6mJMsBwAAADJxgs+uXbu6W2+91ZUuXdqVLFnSXX755cH2LFWqVEnr0wEAAABIg/Xr1wcvmsSzevXqbtWqVW7Hjh120c/qWz548GDWKwAAAJCZleX33Xefu/jii93GjRvd1Vdf7XLm/L98+5lnnmk9ywEAAADERt++fd3bb7/tzjnnnOB1+lnV5zfeeKMVuQAAAADIpGS51KxZ01WtWtWqWSpUqOBOPPFE61kOAAAAIHY2b97s/v333yTX//fff27r1q18FAAAAEBmtmFRP8T27dtbH8TKlSu7DRs22PVdunRxTz31VFqfDgAAAEA6XXXVVe6ee+5x3333XfC6pUuXuk6dOrkGDRqwXgEAAIDMTJb37t3bff/99+6zzz4LmdBTwfj06dPT+nQAAAAA0mnixImuRIkSduZnnjx57KKWicWLF3cvv/wy6xUAAADIzDYs77//viXFL730UpcjR47g9aoyX7duXVqfDgAAAEA6FS1a1H300Udu7dq1NrGn4vNKlSq5s88+m3UKAAAAZHZl+fbt212xYsWSXL9///6Q5HlqfPHFF+766693pUqVsscqEe8XCARcv379XMmSJV2+fPmsev3nn38Ouc+OHTts4qKCBQu6woULW4uYffv2hdxnxYoVrm7dulYJX6ZMGff000+naTkBAACArEzJ8aZNm1psTaIcAAAAiFGyXKd4zpw5M/i7lyDXaZ61atVK03MpwV6tWjU3duzYiLcrqT169Gj3/PPPu2+++caddNJJrmHDhu7gwYPB+yhR/tNPP7m5c+e6GTNmWAK+Y8eOwdv37NnjrrnmGleuXDnr3/jMM8+4AQMGuBdffDGtbx0AAADIcl555RVXpUoVKy7RpWrVqu7VV1+N92IBAAAAx38blieffNI1btzYrVy50v37779u1KhR9vPChQvd559/nqbn0vPoEomqykeOHOkee+wxd8MNNwR3BNR/URXorVq1slNNZ82a5ZYsWWJJfBkzZoy79tpr3bBhw6xi/fXXX3eHDx+2fo65c+e2djHLly93I0aMCEmqAwAAANmNYtq+ffu6+++/39WuXduuW7Bggbv33nvdX3/95bp16xbvRQQAAACO38ryOnXqWLJZiXJVsMyZM8fasixatMjVqFEjagu2fv16t2XLFmu94ilUqJC75JJL7LVE/6v1ipcoF90/Z86cVonu3adevXqWKPeoOn3NmjVu586dUVteAAAAINZUKDJ+/Hg3dOhQa8Oii87OHDdunJ2hCQAAACATK8ulQoUK7qWXXnKZSYlyUSW5n373btP/4f3TTzzxRFekSJGQ+5QvXz7Jc3i3nXLKKUle+9ChQ3bxt3KRo0eP2gUAEF05XIBVmmDi/X3KmEs88RhzsXjNzZs3u8suuyzJ9bpOtwEAAACIcrLcSxanhibazO6GDBniBg4cGHFyU3+/dABAdJQtQLI80Wzbti2ur8+YSzzxGHN79+7N9NeoWLGie/PNN92jjz4acv306dPdWWedlemvDwAAACRcslytTryJPI/lv//+c9FQokQJ+3/r1q2uZMmSwev1e/Xq1YP3Cd/xUXuYHTt2BB+v//UYP+937z7hevfu7R566KGQgwVlypRxRYsWPS4OBgBAVrNhb+q+Y3D8CD8zLNYYc4knHmMub968mf4aKvC45ZZbbJJ7r2f5V1995ebNm2dJdAAAAABRTpbPnz8/+PNvv/3mHnnkEXfHHXe4WrVqBfuCT5kyxSqyo0WtU5TMVqDvJceVtFYv8k6dOtnvev1du3a5pUuXBvulf/rpp3bKq3qbe/fp06ePO3LkiMuVK5ddN3fuXHfOOedEbMEiefLksUs49ULXBQAQXQFHsjzRxPv7lDGXeOIx5mLxmi1btrT4+Nlnn3Xvv/++XXfuuee6xYsXuwsuuCDTXx8AAAA4nqQqgq9fv37w8sorr7gRI0ZYYtybREg/Dxs2zE2aNClNL75v3z6bLFQXb1JP/bxhwwarZO/atat7/PHH3QcffOB++OEH17ZtW1eqVCnXrFmz4I5Ao0aNXIcOHWyHQFU0999/v2vVqpXdT9q0aWOTe7Zv39799NNPdkrqqFGjQirHAQAAgOxKRSOvvfaaFZDoop/TkyhXdfr1119vcbRicS/57lGxjK73XxSL++kMz1tvvdXOxtTZqYrBFfP7rVixwtWtW9cq73X2piYkBQAAALKCNJe7qIq8Zs2aSa7XdUpYp8W3335rgbwXzCuBrZ/79etnv/fs2dN16dLFdezY0V100UUWaM+aNSvklNbXX3/dVapUyV111VXu2muvdXXq1HEvvvhi8PZChQq5OXPmWCJeOxIPP/ywPb+eEwAAAMD/2b9/v6tWrZobO3ZssqtEyXFNHOpd3njjjZDblShXgYrO5JwxY4Yl4P1xt84Uveaaa1y5cuUssf/MM8+4AQMGhMTvAAAAQJZuw+Kn6o+XXnopSQXIyy+/bLelxeWXX+4CgeQndVO1yqBBg+ySnCJFiripU6em+DpVq1Z1X375ZZqWDQAAAMiq1OLlWHMK6XbN55NajRs3tktK1KowuXl/Vq1aZYUtS5YsCRbXjBkzxgpadBaqKtZV6HL48GE3ceJEO/uzcuXKdmapzlylmAUAAADZLlmufojqjfjxxx8H+4Krovznn39277zzTmYsIwAAAACf9957L8UzQUePHm3z+ETbZ599ZpOlau6fK6+80lomnnrqqcHXVesV/1moDRo0sMS++qo3b97c7lOvXj1LlHsaNmzohg4d6nbu3BlxTqFDhw7ZxV+dLnp/mfEeASCR5Ux7AwIcB+L5fcqYS0xH4zDmUvuaaU6WqzJEifFx48a51atX23XqbXjvvfemubIcAAAAQNrdcMMNSa5bs2aNe+SRR9yHH35o7VBSOjszPdSCpUWLFq58+fJu3bp17tFHH7VKdCXATzjhBLdlyxZLpPudeOKJdiaobhP9r8f7FS9ePHhbpGS55kcaOHBgkuu3b9/uDh48GNX3CACJrtJJleK9CIiDbdu2xW29M+YSUzzG3N69ezMnWS6lS5d2Tz75ZHoeCgAAACCKNm3a5Pr37++mTJliVdpqa3L++edHfR23atUq+HOVKlWs1WGFChWs2lzzB2WW3r1729xG/spyFekULVrUJhIFAETP6v3/VxSJxBJ+sDuWGHOJqVgcxpx/DsyoJ8t37drlJkyYYH0JRb0G77rrLptMEwAAAEDm2717txWwqC949erV3bx581zdunVjturPPPNMd9ppp7lffvnFkuXqZR5eJaSe6Tt27Aj2Odf/W7duDbmP93tyvdDVJ12XcGrvogsAIHqOOtpbJaJ4fp8y5hJTzjiMudS+ZpqX7Ntvv7UKEvUuV+Criybk0XXfffddepYVAAAAQBo8/fTTlqyeMWOGe+ONN9zChQtjmiiXP/74w/3999+uZMmS9nutWrWsqGbp0qXB+3z66afWH9Kb60j3+eKLL9yRI0eC95k7d64755xzIrZgAQAAAGIpzZXl3bp1c02bNnUvvfSS9SD0Kkbuvvtu17VrVwt+AWRfDQfPjPciIA5m923CegeAbES9yfPly+cqVqxo7Vd0ieTdd99N9XPu27fPqsQ969evt5Yu6jmui/qGt2zZ0irA1bO8Z8+e9vpq/SLnnnuu9TXv0KGDe/755y0hfv/991v7llKlStl92rRpY8/Tvn1716tXL/fjjz+6UaNGWSEOAAAAkO2S5aos9yfK7UlOPNGCZf/M9wAAAAAyR9u2bV2OHDmi+pyK86+44org716f8Hbt2rnx48e7FStWWFJe1eNKfl9zzTVu8ODBIS1SXn/9dUuQqy2LTnVVcn306NHB29W2cc6cOa5z586uRo0a1salX79+rmPHjlF9L8DxosKwCvFeBMTBuu7rWO8AkF2S5ZpEZ8OGDa5SpdAZkjdu3OgKFCgQzWUDAAAAEMHkyZOjvl4uv/xyFwgEkr199uzZx3wOVaBPnTo1xftoYtAvv/wyXcsIAAAAZKY09yy/5ZZb7LTJ6dOnW4Jcl2nTplkbltatW2fOUgIAAAAAAAAAkJUqy4cNG2anfOrUT/Uql1y5crlOnTq5p556KjOWEQAAAAAAAACArJUsz507t03CM2TIEJvYRypUqODy58+fGcsHAAAAAAAAAEDWacPy33//2aQ+//zzj/2u5HiVKlXsokpz3Xb06NHMXFYAAAAAAAAAAOKbLH/11VfdXXfdZZXl4dSGRbcdazIfAAAAABlz4YUXup07d9rPgwYNcgcOHGCVAgAAALFMlk+YMMF1797dnXDCCUluO/HEE13Pnj3diy++yIcCAAAAZKJVq1a5/fv3288DBw50+/btY30DAAAAsexZvmbNGnfppZcme/tFF11kgTsAAACAzFO9enV35513ujp16rhAIOCGDRvmTj755Ij37devHx8FAAAAEO1kuapX9uzZk+zte/fu5RRQAAAAIJNNnjzZ9e/f382YMcPmDvr444/tTM9wuo1kOQAAAJAJyfKzzjrLLVy40FWtWjXi7QsWLLD7AAAAAMg855xzjps2bZr9nDNnTjdv3jxXrFgxVjkAAAAQq57lbdq0cY899phbsWJFktu+//57q1rRfQAAAADExtGjR0mUAwAAALGuLO/WrZud4lmjRg3XoEEDV6lSJbt+9erV7pNPPnG1a9e2+wAAAACInXXr1rmRI0cG5w8677zz3IMPPugqVKjAxwAAAABkRmV5rly53Jw5c9wTTzzhNm/e7F588UX3wgsv2M+6TrfpPgAAAABiY/bs2ZYcX7x4sbVL1OWbb75xlStXdnPnzuVjAAAAADKjslyUDO/Zs6ddAAAAAMTXI488Ymd3PvXUU0mu79Wrl7v66qvjtmwAAADAcVtZDgAAACBrUeuV9u3bJ7n+rrvucitXrozLMgEAAADZFclyAAAAIJsqWrSoW758eZLrdV2xYsXiskwAAABAQrRhAQAAAJB1dOjQwXXs2NH9+uuv7rLLLrPrvvrqKzd06FD30EMPxXvxAAAAgGyFZDkAAACQTfXt29cVKFDADR8+3PXu3duuK1WqlBswYIB74IEH4r14AAAAQGIkyw8fPuzWr1/vKlSo4E48kZw7AAAAEGs5cuSwCT512bt3r12n5DkAAACAGPQsP3DggE0ilD9/fle5cmW3YcMGu75Lly7uqaeeSsciAAAAAMgoJclJlAMAAAAxTJbr9M7vv//effbZZy5v3rzB6xs0aOCmT5+egUUBAAAAAAAAACA+0tw/5f3337ek+KWXXmqnfXpUZb5u3bpoLx8AAAAAAAAAAFmvsnz79u2uWLFiSa7fv39/SPIcAAAAAAAAAIDjNlles2ZNN3PmzODvXoL85ZdfdrVq1Yru0gEAAACI6MiRI+6qq65yP//8c1TW0BdffOGuv/56V6pUKYvxdUapXyAQcP369XMlS5Z0+fLlszaM4a+9Y8cOd+utt7qCBQu6woUL21xH+/btC7nPihUrXN26da2lY5kyZdzTTz/NJwwAAIDs2YblySefdI0bN3YrV650//77rxs1apT9vHDhQvf5559nzlICAAAACJErVy5LPEeLzhStVq2au+uuu1yLFi2S3K6k9ujRo92UKVNc+fLlXd++fV3Dhg1tX8Cby0iJ8s2bN7u5c+daMv/OO+90HTt2dFOnTrXb9+zZ46655hpLtD///PPuhx9+sNdTYl33AwAAALJVZXmdOnXc8uXLLVFepUoVN2fOHGvLsmjRIlejRo3MWUoAAAAASdx2221uwoQJUVkzKoh5/PHHXfPmzZPcpqrykSNHuscee8zdcMMNrmrVqu6VV15xmzZtClagr1q1ys2aNcvOOL3kkktsv2HMmDFu2rRpdj95/fXX3eHDh93EiRNtzqNWrVq5Bx54wI0YMYJPFwAAANmvslwqVKjgXnrppegvDQAAAIBUUwGLEs+ffPKJFa6cdNJJIbdHKwm9fv16t2XLFqsI9xQqVMiS4iqaUdJb/6tCXG0bPbp/zpw53TfffGNJeN2nXr16Lnfu3MH7qDp96NChbufOne6UU06JyvICAAAAMUmWb9iwIcXby5Ytm64FAQAAAJA2P/74o7vwwgvt57Vr14bc5s0tFA1KlEvx4sVDrtfv3m36X2ec+p144omuSJEiIfdRC5fw5/Bui5QsP3TokF08auUiR48etQtwPMuZ9pPBcRyI57aNMZeYGHNIhDF3NJWvmeZk+RlnnJFi4P3ff/+l9SkBAAAApMP8+fOP+/U2ZMgQN3DgwCTXb9++3R08eDAuywTESqWTKrGyE9C2bdvi9tqMucTEmEMijLm9e/dmTrJ82bJlIb9r4h5dp1M8n3jiibQ+HQAAAIAM+uWXX9y6deusxUm+fPmsx3g0K8tLlChh/2/dutWVLFkyeL1+r169evA+4Ts+ahOzY8eO4OP1vx7j5/3u3Sdc79693UMPPRRSWV6mTBlXtGhRV7Bgwai9RyArWr1/dbwXAXEQfpZOLDHmEhNjDokw5vL+/xPSRz1ZXq1atSTXqS9hqVKl3DPPPONatGiR1qcEAAAAkA5///23u/nmm63CXMnxn3/+2Z155pmuffv21tJk+PDhUVmvap2iZPa8efOCyXElrdWLvFOnTvZ7rVq13K5du9zSpUutf7p8+umndsqrept79+nTp48V3OTKlcuumzt3rjvnnHOS7VeeJ08eu4RTL3RdgOPZUUeroUQUz20bYy4xMeaQCGMuZypfM2pLpgB3yZIl0Xo6AAAAAMfQrVs3SzprXqH8+fMHr7/lllvcrFmz0rT+9u3b55YvX24Xb1JP/aznViK+a9eu7vHHH3cffPCB++GHH1zbtm2tYKZZs2Z2/3PPPdc1atTIdejQwS1evNh99dVX7v7777fJP3U/adOmjU3uqWT+Tz/95KZPn+5GjRoVUjkOAAAAxEuaK8u9CXU8OsVz8+bNbsCAAe6ss86K5rIBAAAASMGcOXPc7NmzXenSpUOuV1z++++/p2ndffvtt+6KK64I/u4lsNu1a+cmT57sevbs6fbv3+86duxoFeR16tSxhLz/lNbXX3/dEuRXXXWVVe+0bNnSjR49Onh7oUKFbJk7d+5s1eennXaa69evnz0nAAAAkO2S5YULF07S/1AJc/UNnDZtWjSXDQAAAEAKlLz2V5R71Cc8UuuSlFx++eUW1ydH+wCDBg2yS3KKFCnipk6dmuLrVK1a1X355ZdpWjYAAAAgSybL1Q/RTxUjmlynYsWK7sQT0/x0AAAAANKpbt267pVXXnGDBw8OJrTVI/zpp58OqRIHAAAAcGxpzm7Xr18/rQ8BAAAAkAmUFFfLE7VQOXz4sLVKUS9wVZarZzgAAACATEyWa0Kf1GratKnLCPVBHzhwYJKJRFevXm0/Hzx40D388MPW/uXQoUOuYcOGbty4ca548eLB+2tCok6dOllF/Mknn2w9F4cMGUIVPAAAALK9888/361du9Y999xzrkCBAjZJZ4sWLawneMmSJeO9eAAAAMDxnSzXbPc6vTO8n2H4dfr9v//+y/ACVq5c2X3yySfB3/2tXrp16+Zmzpzp3nrrLZssSJMJaefAq6LR6zdp0sSVKFHCLVy40CYibdu2rcuVK5d78sknM7xsAAAAQLwpDu7Tp0+8FwMAAADI9nKm9QGavb569eru448/drt27bKLfr7wwgvd7NmzrUeiLtFIlHvJcSW7vctpp51m1+/evdtNmDDBjRgxwl155ZWuRo0abtKkSZYU//rrr4PLunLlSvfaa6/ZMjdu3Nj6OY4dO9ZOUwUAAACyu507d7phw4a59u3b22X48OHWhgUAAABAJifLu3bt6kaNGmUtTwoWLGgX/ayk9QMPPOCi7eeff3alSpVyZ555prv11lutrYosXbrUHTlyxDVo0CB430qVKrmyZcu6RYsW2e/6v0qVKiFtWbSse/bssV6OAAAAQHb2xRdfuDPOOMONHj3akua66Ofy5cvbbQAAAAAysQ3LunXrXOHChSOe/vnbb7+5aLrkkkvc5MmTrU+5Wqiof3ndunXdjz/+6LZs2eJy586dZFmUGNdtov/9iXLvdu+25Kj/uS4eJdfFq5oHjmc5XGiLJSSGeG/bGHeJhzGHRBhzsXhN9Sa/5ZZb3Pjx490JJ5xg1+kMz/vuu89u++GHHzJ9GQAAAICETZZfdNFF7qGHHnKvvvpqMPG8detW16NHD3fxxRdHdeHUNsVTtWpVS56XK1fOvfnmmy5fvnwus2gC0PCJRWX79u02qShwPCtbgGR5Itq2bVtcX59xl3gYc0iEMbd3795Mf41ffvnFvf3228FEuehnxeuvvPJKpr8+AAAAkNDJ8okTJ7rmzZtbu5MyZcrYdRs3bnRnnXWWe//9911mUhX52WefbTsFV199tfUdV890f3W5EvfqbS76f/HixSHPodu925LTu3dv28HwV5brvRYtWtTazgDHsw17c8R7ERAHxYoVi+t6Z9wlHsYcEmHM5c2bN9NfQ/MGrVq1ys7E9NN11apVy/TXBwAAABI6WV6xYkW3YsUKN3fuXLd69Wq77txzz7Xe4TlyZG6Sbd++fdYG5vbbb7cJPXPlyuXmzZvnWrZsabevWbPGeprXqlXLftf/TzzxhFUSeTtIWm4lvM8777xkXydPnjx2CZczZ067AMezgCNZnojivW1j3CUexhwSYcxl1msqFvdozqAHH3zQikkuvfRSu06T3WtC+6eeeipTXh8AAAA4XqU5WS5Kil9zzTV2yUzdu3d3119/vbVe2bRpk+vfv7+dVtq6dWvrkd6+fXurAC9SpIglwLt06WIJcm9HQcunpLiS608//bT1KX/sscesf2OkZDgAAACQ1VWvXt3i8UDg/7VO69mzZ5L7tWnTxvqZAwAAAIhisnz06NGuY8eOdiqpfk6Jqlui5Y8//rDE+N9//20tUOrUqWOVMvpZnn32WavYUWW5JuRs2LChGzduXPDxSqzPmDHDderUyZLoJ510kmvXrp0bNGhQ1JYRAAAAiKX169ezwgEAAIB4JcuVlL711lstWa6fk6MKl2gmy6dNm5bi7VoenWKqS3JUlf7RRx9FbZkAAACAeFJ8CwAAACBOyXJ/9QqVLAAAAEDWoXaFCxYssHl6jh49GnJbNAtZAAAAgONdunqWAwAAAIi/yZMnu3vuucflzp3bnXrqqXamZ2ad9QkAAAAc79KcLP/vv/8sKJ83b17E6pVPP/00mssHAAAAIBl9+/Z1/fr1c71797a5fAAAAADEMFn+4IMPWrK8SZMm7vzzzw+pXgEAAAAQOwcOHHCtWrUiUQ4AAADEI1muSTfffPNNd+2110bj9QEAAACkU/v27d1bb73lHnnkEdYhAAAAEOtkufohVqxYMaOvCwAAACCDhgwZ4q677jo3a9YsV6VKFZcrV66Q20eMGME6BgAAADIrWf7www+7UaNGueeee44WLAAAAECck+WzZ89255xzjv0ePsEnAAAAgExMli9YsMDNnz/fffzxx65y5cpJqlfefffdtD4lAAAAgHQYPny4mzhxorvjjjtYfwAAAECsk+WFCxd2zZs3z+jrAgAAAMigPHnyuNq1a7MeAQAAgHgkyydNmhSN1wUAAACQQQ8++KAbM2aMGz16dKavywEDBriBAweGXKf2L6tXr7afDx48aC0bp02b5g4dOuQaNmzoxo0b54oXLx68/4YNG1ynTp3sTNWTTz7ZtWvXzlrJnHhimndLAAAAgKgjKgUAAACyqcWLF7tPP/3UzZgxIyYtEvUan3zySfB3f5K7W7dububMme6tt95yhQoVcvfff79r0aKF++qrr+z2//77zzVp0sSVKFHCLVy40G3evNm1bdvWlvnJJ5+M6nICAAAAmZosP+WUUyJOEqRA+Oyzz3bdu3d3V199dboWAgAAAEDaqUWiEtKxouS4kt3hdu/e7SZMmOCmTp3qrrzyyuAZqeeee677+uuv3aWXXurmzJnjVq5cacl2VZtXr17dDR482PXq1cuq1nPnzh2z9wEAAABkKFk+cuTIiNfv2rXLLV261F133XXu7bffdtdff31qnxIAAABABsS6ReLPP//sSpUq5fLmzetq1aplLVTKli1r+wNHjhxxDRo0CN63UqVKdtuiRYssWa7/q1SpEtKWRa1a1Jblp59+chdccEFM3wsAAACQ7mS5+gmmRJUhCpZJlgMAAADHn0suucRNnjzZ+pSrhYr6l9etW9f9+OOPbsuWLVYZrkp3PyXGdZvof3+i3Lvduy056n+ui2fPnj32/9GjR+0CHM9yupzxXgTEQTy3bYy5xMSYQyKMuaOpfM2o9SxXZfnjjz8eracDAAAAcAzly5eP2CrR8+uvv0ZtHTZu3Dj4c9WqVS15Xq5cOffmm2+6fPnyZdpnpYKc8IlFZfv27TapKHA8q3RSpXgvAuJg27ZtcVvvjLnExJhDIoy5vXv3xjZZrmoP+gwCAAAAsdO1a9eQ39UKZdmyZW7WrFmuR48emfraqiLX3EW//PKLzV10+PBha9Hory7funVrsMe5/teEpH663bstOb1793YPPfRQSGV5mTJlXNGiRV3BggUz4Z0BWcfq/avjvQiIg2LFisVtvTPmEhNjDokw5vLmzRvbZLkm9FErFgAAAACx8eCDD0a8fuzYse7bb7/N1Nfet2+fW7dunbv99ttdjRo1XK5cudy8efNcy5Yt7fY1a9a4DRs2WG9z0f9PPPGEVRJ5O0hz5861hPd5552X7OvkyZPHLuFy5sxpF+B4dtTRaigRxXPbxphLTIw5JMKYy5nK10x1stxfzRE+8/13333n1q5d67744ovULyFSpeHgmaypBDS7b5N4LwIAAMjG1DJFFdnRnAC0e/fuNj+RWq9s2rTJ9e/f351wwgmudevWrlChQq59+/a2z1CkSBFLgHfp0sUS5JrcU6655hpLiiu5/vTTT1uf8scee8x17tw5YjIcAAAAiLVUJ8t1OmckCoR12uW7775rPRMBAAAAxNfbb79tSeto+uOPPywx/vfff1sLlDp16rivv/7afpZnn33WKnZUWa4WjQ0bNnTjxo0LPl6J9RkzZrhOnTpZEv2kk05y7dq1c4MGDYrqcgIAAACZniyfP39+ul8EAAAAQPRdcMEFIRN8BgIBq9jW5Jf+RHU0TJs27Zh9INX+RZfkqCr9o48+iupyAQAAANEStZ7lAAAAAGKrWbNmIb+rsluV3pdffrmrVKkSHwcAAACQBiTLAQAAgGxKfcMBAAAARAfTxwMAAAAAAAAAEh6V5QAAAEA2o3Yr/l7lkej2f//9N2bLBAAAAGR3JMsBAACAbOa9995L9rZFixa50aNHu6NHj8Z0mQAAAIDsjmQ5AAAAkM3ccMMNSa5bs2aNe+SRR9yHH37obr31Vjdo0KC4LBsAAACQXdGzHAAAAMjGNm3a5Dp06OCqVKlibVeWL1/upkyZ4sqVKxfvRQMAAACyFZLlAAAAQDa0e/du16tXL1exYkX3008/uXnz5llV+fnnnx/vRQMAAACyJdqwAAAAANnM008/7YYOHepKlCjh3njjjYhtWQAAAACkDclyAAAAIJtRb/J8+fJZVblarugSybvvvhvzZQMAAACyK5LlAAAAQDbTtm1blyNHjngvBgAAAHBcIVkOAAAAZDOTJ0+O9yIAAAAAxx0m+AQAAAAAAAAAJDyS5QAAAAAAAACAhEeyHAAAAAAAAACQ8EiWAwAAAAAAAAASHslyAAAAAAAAAEDCI1kOAAAAAAAAAEh4JMsBAAAAAAAAAAmPZDkAAAAAAAAAIOGRLAcAAAAAAAAAJDyS5QAAAAAAAACAhEeyHAAAAAAAAACQ8BIqWT527Fh3xhlnuLx587pLLrnELV68ON6LBAAAACQc4nIAAABkRQmTLJ8+fbp76KGHXP/+/d13333nqlWr5ho2bOi2bdsW70UDAAAAEgZxOQAAALKqE12CGDFihOvQoYO788477ffnn3/ezZw5002cONE98sgj8V48AAAAICFk57i8wrAK8V4ExNi67utY5wAAJJCESJYfPnzYLV261PXu3Tt4Xc6cOV2DBg3cokWLktz/0KFDdvHs3r3b/t+1a5c7evSoi6X/Du6P6esha9BYixfGXGKK55gTxl3iYcwhEcbcnj177P9AIBDz1z5e4vKsFpu7g7F9OcRfvL+vGHOJKa7jju1cQmLMIRHG3J5UxuYJkSz/66+/3H///eeKFy8ecr1+X716dZL7DxkyxA0cODDJ9eXKlcvU5QQ8pzzJukBsMeYQa4w5JNKY27t3rytUqFD8FiAbx+VCbI54OqXvKXwAYNzhuMe2Dok05vYeIzZPiGR5WqnSRf3NPapY2bFjhzv11FNdjhw54rpsiUJHe8qUKeM2btzoChYsGO/FQQJgzIExh0TAti62VLWiYLxUqVIxfuXjC7F5/LHtAGMOxzu2c2DMHf8CqYzNEyJZftppp7kTTjjBbd26NeR6/V6iRIkk98+TJ49d/AoXLpzpy4mklCgnWY5YYswh1hhziAfGXexQUZ6xuFyIzbMOth1gzOF4x3YOjLnjW2pi85wuAeTOndvVqFHDzZs3L6RaXL/XqlUrrssGAAAAJAricgAAAGRlCVFZLmqr0q5dO1ezZk138cUXu5EjR7r9+/e7O++8M96LBgAAACQM4nIAAABkVQmTLL/lllvc9u3bXb9+/dyWLVtc9erV3axZs5JMLoSsQafb9u/fP0k7HIAxh+MF2zkw7pCoiMuzH76zwJjD8Y7tHBhz8OQIqLs5AAAAAAAAAAAJLCF6lgMAAAAAAAAAkBKS5QAAAAAAAACAhEeyHAAAAAAAAACQ8EiWAwAAAAAAAAASHslyxNzRo0cj/gwAAAAgtojNAQAA/h+S5Yi5nDlzuvXr17uNGzfaz0Bm+u+//+z/gwcPsqIRl8RDIBBgzSPThY8zxh2A1CI2RywRmyPWiMsRa8Tl2R+ZSsQlQBo6dKh77LHH7Gd26JGZY+2EE05wK1eudPfee6/74YcfWNmIybhT4uH33393q1evdjly5GCtI9PHnMbZnj173I4dO9zhw4cZdwDStA0hNkcsEJsj1ojLEY8xR1ye/ZEsR8wpeXnhhRe6zZs320ZEFxLmiDaNKY21FStWuLp167qzzz7blSxZkhWNTK9c8cbdFVdc4aZNm+b++ecf1joyfczpYODll1/uWrZs6WrWrOkmTZrk/vzzT9Y8gGMiNkcsEJsj1ojLEa8xR1ye/ZEsR6ZThVu4u+++223YsMH179/ffqfyEtGmMbV3717Xvn1798gjj7hHH33UnXrqqW7BggVu9uzZrHBkClWU//zzz65Bgwaue/fubsCAAS5fvnzuyJEjrHFk2pjT9+m1117rWrVq5ebPn2//9+jRw86qAYBwxOaIB2JzxBpxOeIx5ojLjw8ky5Ep5s2b5zp27Gg/586d29oRdOrUyf3yyy/u0KFDthHp27ev/f73339TWY5MoT7lRYoUcVWqVLGkkaotn3zySde4cWP38MMPs9aRIf4zYvzJ8Dlz5rimTZu6++67z/3777+27bvpppvcoEGD7Hcg2uPPq17p2bOn/T5z5kx3/fXXu6uvvtr99ddffMcCIDZHlkBsjsxCXI54Ii4//pAsR6acerJ9+3a3ePFi98ADD9h1mtBTCfMrr7zSqnxnzJjh6tev7xYtWuSWLFlCZTmiNvb8ihYtalW9OnDz0EMPuRo1ariPPvrIvf766zYmdeAGyEiFlHb69u3b53LlymUV5dr2ibZrmpdBY04HBOvVq2dV5gsXLmSFIyrbOo0/9cT//vvv7WCNqlg0/jTmypQpY21Y1L981KhRbtu2bax1IIERmyOeY8+P2ByZhbgc8UJcfnw6Md4LgOOPqsZVVank0bBhw6yCd/jw4Vb19u6777off/zR3Xnnna5Dhw4uT548dp9LL73UFS5cON6LjuNgwqB169bZgZotW7a422+/3b3//vtu1apVljQ/44wz7L46WFOwYEEbf0BGAiMdhNEZMoMHD3a1atWyit577rnHtnM6q0ZtgLyDhp999lnEU9+BtI47fc9u3LjRDsKMHDnS5mTQeKtdu7a7+OKL3WuvvWb37dq1qyXMlZwAkLiIzREPxOaIJeJyxANx+fErR4CZFZFJDhw4YIkjJcqrV6/unn/++eBtSmhOnjzZffvtt+7zzz+3KszKlSsHNzZAeqgVwVVXXeWaN2/uli1b5kqUKGGJo969e9vYWrp0qSWW1JJFP+uAjjaB9MxHencCte1Sb3JN6NmvXz/7WcLHVZs2beygjbZ5OqgDZIQS5a+88optw7zWK2ptNmXKFNenTx9XunRpm1xW20SNUbZ1AITYHLFGbI5YIS5HvBCXH5/ISiLTTrXLnz+/a9KkiSWPli9fbv17PRUqVLCWBB9//LFNSqbJF21AkihHOigxqR3Abt26WeLohRdecJ9++qn78ssvLTGpy4knnmhJI93PS5SrfzSJcqR3zGlcnXvuuVa5q8ljNa72799vt3stfjQOr7vuOmvRojMe9BgF80B66ewEHfTTBNmaxNijsxt0JpcO3Kiy/LTTTgsmyjXm2NYBiYnYHPFAbI5YjzficsQDcfnxi8pyRP1UO/WCnj17tiXE1ZbgpJNOcu+884575plnrMp3zJgxwQ2LThtXBbB2+t944w27L5DWMef9f8kll9jYU0sfjTWNQY2rtWvXurx587qyZcsGK36VKFcCHUgr7wwYbyxpPobdu3e7Hj162DhTorJAgQJ2X/UrnzVrlrvllltsvDHukJExp4Mwah+lPuVPPPGEzfuh9j7a1vn5z2zwto8AEg+xOeI15ojNESvE5Yg14vLEQGU5ono0V+0tqlSp4t5++21LDqktga678cYbreJXlZe33XabPUaJcvnggw/cd999Z0kkIC005jR2NNb27NljSXJN3lmzZk2r+FWiXDQO582bZz8rgaTxSqIcGQmOVCn+5JNPWjspJcirVq1q7X50EPDWW2+1MXbzzTfbffS7xpt2HBl3SA+NuT/++MPdfffdbsGCBa5atWpu0KBBrm7dujY3gyb6FO+sBX8VOYlyIDERmyMeiM0RS8TliAfi8sRAshxRoR3zv/76y3bin3rqKffJJ59YdaV24FVJ/tNPP7mWLVtaKxa1Z/GfEqoE53vvvecKFSrEp4FU8cbPvn37LGGkSe00YacmitUZDBpL6t0rbdu2tbMdlFDyj1cgvQG5zlRQclxnxaiavFevXjb3giYxfuyxx2xcajJZVZwPGTIk+HiSlsgIHZRZs2aNe/bZZ93XX3/tKlWqZC3MzjrrLEuia1JZxhgAf6xDbI5YITZHrBGXI56Iy49/tGFBVKiqVy0w9KWlSku1X5G5c+e6ESNGuPLly7uOHTvaRJ8eTg1HRmzYsMG1a9fOEkXjxo2zit2dO3e6Rx55xO3atcsS5Bp3Sliqd7nXt5dkEjJi8+bNbv78+TbWOnfubBNXqVe0kuj33nuvJcw1zpTM1MEbjTdaryA9Io2b7du325kKalmmMxnUbkoHo7XdK1WqlM3XAABCbI5YIzZHrBGXI1aIyxMPyXJkiNcXVZMmvvrqq1ZhqQk9VV3pUfsL7cirJYGqMIGMjjdZtWqVa9WqlQXmf/75p52xIKrqVbsCtfwpU6aMVZ2TsEQ0/PPPP5YMVwuWSZMmuRtuuMGuV6spzbug1lJqCdS0adPgYzhAg7T49ttv3cGDB12dOnXsdx3s09kyzz33XPA+W7dutXGm7drTTz/tatSoYQcHy5UrxyTZAIjNEVPE5ogX4nJkNuLyxEayHOniJYC8STq906BefPFF9/DDD1ulZdeuXUM2NBdeeCE78sgwJYqUHNd4UpLypptucsWKFbNq3/CgPXy8AmnlH0/a3ungnyrKVTU+derU4P108EbX169f3xLnQFrH2Y4dO+wAYPHixW0s6QwtnZ310EMPWQX5hAkTgvfXARttA5UoV6szzRUi3ncxgMRDbI54ITZHrBCXI1bjjLgcJMuRZt7OuE79Vn9yneZZsmRJa7OinfeXXnrJKswHDBjgHnjggYiPBdJDFZd33nmn7RDqLIWLLrrIxqHasZxyyimWWBKS44gGbxzpbAW18Tly5Ig7+eSTbZypF74qy59//vng/X/77TdXtmxZtnFIty+++MINHz7cDgCqD7nam3388cc2UWyFChWszZns3bvXDkjny5fPjR49mjEHJDhic8QLsTlihbgcsUZcntjIWiLtgyZnTqtqu/LKK62aTRWWot8XLlzoOnTo4IYNG2Y78m+++WaSxwJpPbKrizeRxj333OMOHTpkScpvvvnGVa5c2Sbz1EEbryc+VeSIRuJB40g9yZs3b+4aN25sB2XeeOMNd/XVV1vbqdmzZ9ukxR5N6qltnH8CYyC12zn1QqxXr56NKU3K502OrbGnVma//vqrHaBZt26dbQe1PdR9GHMAiM0RS8TmiDXicsQScTkkdOYoIJWmTZtmO/A9e/YM9gxTZe+DDz7oZs6c6W6//XY7lbxRo0asU2SIWmDoNKgiRYrY7+oZrSpfndWgyez0s85o0M9KHHH2AqKVeFByskmTJnYWw2WXXWYHAzW5YtWqVd0VV1zhXn75ZXfttdfaRLL++Rg4KIj00GSe33//vZs4caIdEPzwww8tga7vWY1DbQO7devmbrzxRjvDQQcJtX1UQM+YA0BsjlghNkesEZcj1ojLQRsWpEvfvn1tYkXtrHszA3/33XfWmmD69OlW7ZvSzMFAaqndgPrytmjRwhLkHlWV33XXXXZ2g9r9KJnpoQ0LokHJ8M8//9yqyHUQRmOsUqVK1grDO4Cj+RguuOACzmZAhm3fvt1Vq1bNkuNqa/bll1+6oUOHutNPP93mAvHOnNGkn2r3o2QF368APMTmiBVic8QDcTliibgc9MRAupx33nnWjkBVcF4iXNW9BQsWdPv37w+5L4lypJXXxkKJoAIFCrhHH33UvfLKKzZxrKiSUr18Vd372WefuUWLFoU8njYsiIYtW7bYNk10wEZtVpQo3717txs3bpwFUTVr1rTxpgM0QEYnSCtXrpy1MMufP79r2LChe+KJJyxprp7ln376qd1P91GiXNtJvl8BeIjNkZmIzRFvxOWIJeJykCxHurRu3dp6ptapU8dO+1SyUr3KtQOv5BGQXko66lS71atXW2uLzZs3W6/oZ5991tqsKGmkcSZKpKuXr1oTABkRKdmtAzLavik5qV7S+lk6derkVq1a5U477bTgfTlAg4zSgZk1a9bY2VleYqJWrVrWI18TDC1fvjzk/rReAeBHbI7MQmyOWCMuR7wRl4PeGEjWsXo/Dx8+3JUsWdINGDDATgnPly+fVfl6k42xI4+0UsW4ko4rVqywCWPVA1+JcV1uvvlmu0/79u2tNYZ6+qoVxrJlyxhziMqkQb/88oubO3eutb3QxMVKUmqyxdGjR9tZDJrsU5MXa9JFtV/x+kV7B2+A1PJaRR04cMCqyHVKu75H77jjDvfOO+/YgZirrrrK7qvv1u7du1vFOYDERmyOWCM2R6wRlyPWiMsRCT3LkeIGQxPc7dq1y1qsJEetCDTZWN68eemhigxTAlxnLNx9993uoYcesoDpxx9/tNs0saISluoh7VWVa4JPDs4go1Qprurxs88+28bTqaee6l566SWbqHj8+PF2UW9ytb148cUXbdzRGx/p4W2vtF3r3bu3jSNNkN25c2d35pln2nZt5cqVrnTp0nZQUPODqKpc38ls64DERWyOeCE2R6wRlyNWiMuRHJLlSHaDoerexo0bW6Vbnz59rPrNX2VgAyisspIdeWSUEkNq8aPJPAsVKuRatWpl/6viVwlL3ebHBHdIL//2asKECe7gwYOWsJw/f74lxNUbUQdmlLT0JvT0kChHRqxbt84OzngTd6rNyqBBg9y2bdusylxtqGbNmuVKlSplBw05KAgkNmJzxBOxOWKBuBzxQlyOSEiWI9kNRu3ata3Fyr333mvXKZGkHXZ68yKawg+wHDlyxCp4db2qejWp4qRJk9zAgQOtTYZ+ZlI7ZJSX7F6/fr37+uuv3VdffWWtf1q0aGEHAHXdqFGjLHn58ssvW8Wvh9YryCjNwaDKch2k0bbusssus7MaNJGxJpDVAUI/DgoCIDZHrBCbI9aIyxFPxOWIhJ7liEiJIlW9KVGu5OVdd93l/v77b1exYkWbdLFMmTKsOUQtMPrjjz8saanq3RtuuMF9//33NgbV3qdatWp237Vr17qiRYuSKEfU+m+q97gmJFZ/cvXB186hDtSUL1/eJlbUQZy+ffu6ESNGuOeeey74eHqUIz1jzj9u1L5Mc36I2pxVqlTJEuW6fsqUKfad6z+TgQOEAIjNEQvE5og14nLEY8wRl+NYkp+9EQnFa6viyZ07t/v555+tb7SSRqpqUzuMqVOnBvtHA9GazFPJypEjR7o2bdq45s2bu2nTptmZDUqUq0e5rtf/zzzzDCsdGabgSAf/vvzySxtTaruiCl8dpFHCUnM1yCWXXGKVBprgE8hI4kFj7s8//7QDgqLWK2r1o2pyHZjWNk80qbH6lauHOYDERmyOeIw5YnPEGnE5Yom4HKlFZTmCFQQ69fuff/6x07/VikDVvqoqVyJTSXN588033Z49e1hriEpgpLF05513Wt/ebt26WXX5mDFj3FtvveXKli3rLr74Yvfaa69ZYnPp0qVMqoio2Ldvn6tcubKdufD888/bdRqHqiRXAlNjUwcHlcjU/YT5GJAeGjde4uH666+3ZLj64uvnRYsWWYsfHQxUe4XBgwfb2Q7ffvttkvlAACQWYnPEA7E54oG4HLFCXI60IFme4PwbDLVcOXz4sLVYUZKyd+/eIfdt3bq1TfBy4403xm15cXzRwRn1wb/11lvtd7W/eOSRR2ysffTRR65u3brWq1xnOiiRSd9eZISXfFSSfPjw4a5Tp05uwYIFrkGDBnZ7u3btbJxpokVN6qlkucffVx9ILY0bHQS87rrr7DtV37NeAlwHCE877TTXtm1ba8Wi72IlyrVNZAJZIHERmyOeiM0RK8TliDXicqQFyfIE/4LSBuO3336zPtHdu3d3N998s5s1a5YljapWreqaNGniFi5caG0ItMOv6l7t0LMjj/SOOX+lZMGCBd1ff/3lXn31Vasul2LFirmmTZu6b775xsZZ3rx5gzuP9O1FenjbK+0A5s+f3x04cCB4gEaJysKFC7uuXbva77fffrv1xr/66qtZ2YiKTz75xNpK6eCMtoHedlBnz/Tp08fO3NJ2T3Q9369A4iI2RzzGHLE5Yom4HPFEXI7UIlmeYHTa96FDh9zll18eDIx02rcqeHVquKhHryYXU6J806ZN1rNcbTCuvfZaSzhR3YuMBEZqvaL/NQ41gV2HDh3cZ5995kqUKBFMYOoATalSpex+Hip7kZEKPc210LNnT5cnTx5Llg8dOtTGm8aVEub6/4EHHrDHNGrUKGTMAhmh71GNOW886qLq8dWrV9uBmeLFiyfpFwsgcRCbI16IzRFrxOWIN+JypBbJ8gSihLcqxPfv328VunXq1LHr16xZY/3JpWbNmu6ss86yPqpKZr7wwguuY8eO1l/VC6qo7kVaeQkgTaCo6kqNI7UfULsVVZRv3brVxqZaY6gN0O+//269yoGMUhJc/aAbNmxo/aK9yRTV9kKTGGsM6sCh+kbrgI3OrvGQtERaReptr7Zmw4YNc3PmzHHXXHNNcFypLYsmMR4wYEDwvvQoBxILsTnihdgc8UBcjlgiLkdG5AiET7WO45oqeCdPnmztCNQ79YorrrBEuSb0/PXXX60fuTfhnZJIut+7775LVS+iMkmVDsZ06dLFDsjoIE3fvn3dM888Y2Nx1apV7uOPP7Ze0RqPOijDWQyIBp0to8ryCRMm2HjUdk/98adMmWLbuHz58lki88orr+RgIDK8rVNrM7WR0oRVOourQoUK7rHHHrN2U7169bKxN336dLds2TJrbcYBaCCxEZsj1ojNEU/E5YgF4nJkFJXlCcLrk6oddyWH3nnnHTdq1Ch30kknWdWbEuOqJlff1K+//tqNGTPGkpdLliyxRHl4PzsgtZQ8Wrt2rRs3bpxr1qxZsNWFKn1Llizp+vXrZ1W+Gofnnntu8HGcxYCMBkd//vmn9cU/ePCgnbEgGmvnnXeeJcp1u/7XmFTFr3CABhmp0Pvhhx+sZVmVKlXcjh07bGwpSa6e+Gq3MnLkSBt/mmRWk3kqUU67HyAxEZsjXojNEUvE5Yg14nJEA8nyBKKkt3bkn3vuOUt8z507165XxZt26M8++2w7VVwJJE145+3IkzxCRk97UhsMtVnRhHZqOaBJFjUGNemdDtjoNORwtMBARoIj9YPWXAyasPiUU05xjzzyiHv77betqlwHA0XXaYxqDHqo8kV6aHumSnIlxTVpp86Wkaeeesrddtttbv78+XZWjfrjFypUKPg4EuVAYiM2RywRmyPWiMsRD8TliIbQxpo4rjcY27Zts2req6++2v3vf/9zb775psudO7cbMmSIW758uU3oqR16tSoYO3ZssOKN5BHSuwOontBqNdC4cWNLWm7ZssUOyGg86qKWK3nz5rUWLUC0tnW7du2yM2XU8qJGjRqWuNRknitXrrSEpc6aufPOO92KFSvsfnoMHcmQHvqOFE3gqXY+OnPrzDPPDN6uAzK33367HZQ+fPhwyIEZJvMEEhuxOWKN2ByxRlyOWCIuRzRRWZ5AlECqWLGiJYtUeXnDDTdYBbkq4VTtq8nvGjRoEPIYqnuRXjoj4fHHH3eVK1d2F1xwgbW50AEa9cVXEr1WrVruu+++s1YFug7IKCUfdeBFlbw//fRTcOJEVVKpwlcHB5U0L1eunJ3doLNncuXKRXUv0j3e9B2pgy4aa48++qgrUKCAW79+fUjVuFpMaWJtjT8/WpsBIDZHLBGbI5aIyxHr8UZcjmiisvw456+WVDXB4sWL3YwZM4IJpPr169uki0osLViwII5LiuOBxpRHZyToC0sTK3q3NW3a1CaM/fDDD92LL75ov6s1kHcWA5Ae3thR8lEHANUzOk+ePG7hwoVuw4YNtu1TElMTCs2cOdO98cYb1qucRDkysq3TeNu+fbsbOHCgtffRd6kOCqoNi7ZxOpvLm7wvPFEOIHERmyOWiM0Ra8TliDXicmQGkuXHKe9L6tChQ/a/qtpUVa7qcfWO/vzzz4P9pJVUuu+++1z//v3juszI/jSmNm/ebAdeNAbVk9zrz+uNt+uuu85NnTrVekorka6EpSpdOIsB6aWxo2pe7wwFbc8eeughq/h95ZVXLGHuOe2002zMea1XGHdIa7LB256prVT37t3te/buu++26x9++GHXqVMnawGk1mY6W0vbuRdeeMFup90PkLiIzREPxOaINeJyZDbicsQCbViO042HvqRULd6vXz8LznUZOnSoJZGefvpp66Far149t3XrVquMGzVqlCWP/BO/AGkddzooo/7Qam9RqVIl64GvisrzzjvPxqAqfvfs2WNJpLfeesu1bt3aHvPkk0+yspEhOuDyySef2Bj76KOPXMeOHW3Mvfbaa7ZNa9OmjTvjjDNCtm+0wUBqeO1UtK0aP36827Rpk2vWrJlt23bu3Ok+/fRT99VXXwXbmA0ePNg1atTIWkwdOXLEWp7p8UzmCSQuYnPEa9wRmyMeiMuRWYjLESs5ApQ5HZfWrVtnVb2qclNlr5KXr776qp0Ofskll9gEn9q5P/XUU60Ck3YESK/wAyxKhisxpKpLTeqpCe40qawqzpU40nhUUlOJSiXMO3fubBMuaiwC6R13orMVdCCmQoUKbs6cOXbd888/74YPH24TLLZr144VjHQF5Nquqfe4xpbCpnnz5tkYK1OmjI2tv/76y/qWX3bZZSk+D4DERWyOWCE2R6wRlyMWiMsRSyTLjzPaiVcS8plnnrEWBEqQe9RHdfLkyW7JkiWuVKlSSY7+qm80kJ4vLLW5+Prrr93JJ59syaMqVarY7Uow3XTTTdafXJMq7tu3zyZWVJLTG6u6To8D0uqPP/6wcadqco0rf8L83HPPDc7P8N5771l/fJKVSA9to6pXr+5atGhhZ2aJzopR+xXNwaDe+BMmTLAe5fqevfTSS1nRAIKIzRFLxOaIF+JyxAJxOWKFfhvHCe8EAa+tgP7fu3dvMBGu29VHtWjRom7jxo1JHk+iHOkZc0o+aoJOncUwadIkS4qrPYFX1atx9fPPP7tFixbZ70qKK1HuTcLhXQekdVsnY8aMcU899ZSdKfPPP//YdWr/M2zYMGvFUrduXbuuefPmwTYYQFpoW6X+40qM33PPPcHry5Yta219RNXk7du3dyVKlLAztbxJjQEkNmJzxGPMEZsj1mPOQ1yOzEZcjlgiWX4cUAJIiUclwdWnXHSq+Ny5c63qUglL3V66dGmXL18+a4UBZJTG1K5du6xHuZJJH3/8sSXL1W5F7X5E1b5nnnmmO3z4cMhj6YuPjGzr1PJCyUslynWgZuLEie6dd96xvpyiqvI77rjDlSxZMmQCGCrLkVbaVmlS4lq1atl4++2336yN1JQpU1zLli2D91PCXH3xr7/+epujAUBiIzZHPBCbI5aIyxFrxOWIJdqwHCf9wdRypWHDhtY7VTvsp5xyilW4qV/vs88+axVwSiapCnjBggUkjRAVu3fvdrfccou1u1Blgfrhn3/++e6VV15xS5cudRUrVrTevmqBwdkLiMZpxdqGtWrVyvXv39/dfPPNNu40cfGvv/5q7VduvfVW9+ijj7qTTjrJjRgxwh7LxMXIKB18fuGFF2ybp+9Q/V6nTp3gjmL4AUDGHJC4iM0RT8TmiAXicsQTcTligWT5cdIfrF69eq5bt26uS5cuwd6IonYEalGgivLChQu7119/nck8ERUaZ6qy1NibNm2aTeR5+umn28+itgSNGzd2N954o/3OBHfIKE0EqwRl9+7dXe/evUPmWhg8eLC1XlHVuQ4WagJjTVzs3x4C6dnOeeNHB/40Wayu01k0mp8h/D4AIMTmiAdic8QScTlijbgcsUSy/Djw9ttv20SeSopH2nHXJIu5c+d2efLkseuZzBPRpKSlJpTVJIsffPCBXXfbbbe5devWcRYDolqp17lzZ1ewYEE3dOhQ+33AgAG2TdMZDLfffrslJ7Zv3+6qVq1qVehs65AZgfn48eNtHGoekIsuuoiVDCAJYnPEE7E5MhtxOeKFuByx8n8lecjW1A96x44d9r+qLL3JXZQ42rlzp/VP9Xr16jbaYSA9kque7NChg/WKfv/9990DDzzgfv/9d7dly5ZgopyKckSD2lyoklcJiLPPPts999xzNqGi2q3Mnj3beperP77mZhCNO7Z1iAZt97zt31VXXWU7iKosHzJkiHviiSesRz4A+BGbIxaIzREvxOWIF+JyxAoTfB4HypUr57777js3a9Ys++LyEuNqyzJ16tSQ/uScKo70znKuCRX9v3uUoFS7n5EjR1rSSD3MFy5caC0wVNnLpIpID//EnJ7LL7/cVatWzSaQVXsfTSr78ssvu7x58wbHp4dxh8wIzOXqq692bdu2te3dOeecw4oGkASxOTITsTlijbgcWQlxOWKBNizHCbUl0KR2mvTutNNOc998841btmyZTbKopCWQkUmq/v77b3fXXXfZGNMknqnp0UtFOdLLGzu//PKLtfb5559/XIsWLYIVvKrYU2spufPOO63ljxLo4ZMsAseS3LbMP0Gn/z6R7s9kngAiITZHZiA2R6wRlyNWiMuRlZBZOE4qC3r16mV9y5cvX+4+//xz66fqJcpV3QukJzBSskgJS1WNa8JEJcuXLFkScjQ3OVT2Ij28NlIrVqxwtWrVsrNm3njjDZtAVq0vtD1Tovzrr7+26nIdFFQfaY3VSFUvQEr8vch//fXX4BjUeNL/27ZtC0mOR0qsc5AGQPj3mBCbI9qIzRFrxOWIJeJyZCVUlmejo7lKBHlfWMkddTt48KC1JAh/LJAeK1eudFdccYXr3r2727x5s816ripfVUultsIcSCv1vL/mmmtcu3bt3MMPP2xzMlSqVCk4kee9997rfvrpJzd37lzXpUsX603OZJ5IL825cN1119nEsJp3oUKFCnb9ZZddZm2lHnzwQVYugBDE5ogXYnPEGnE5Yom4HFkFyfJscqrdjz/+6J555hkLzlu3bu2aNGkS8f7HOl0cSAslItXy4oUXXrDf1d5n/Pjx7rfffnOjRo2y/tFAtH377bfuww8/dAMHDrTxV6dOHXfWWWfZGTOffvqpJcu7du0a3L5xUBDR2BHs1KmTTYitllNKkqvtj87YAgA/YnPEE7E5Yo24HLFGXI6sgDYsWZh3KrgSk6qyVEuVk046yTVt2tQ9//zzER9zrNPFgWONOf/POrJboECB4O+qJm/UqJG1ZNEEsmrJAmRUePuUmjVruttuu81+1kSK5cuXd6+//rpr3ry5Xbdnz56Q+3P2DDI6/kqUKOGmT5/ufvjhB1e7dm1XtmzZYKKcVmYAPMTmiDVic8QacTniibgcWQXJ8ixMye6//vrLqnp79+7tXn75Zft5ypQprnPnzlbhC0R7zOlIrpLk+vnSSy91kydPtr7R3sGX66+/3jVr1syqLnXQZvfu3XwIyHD/zY0bN9pBmHfffdeuVyW5Wv7s3LnT9enTx6773//+Z21Y+vXrl6q++UBadgrVC//333+3/1VhvnXrVhufavMDAEJsjlgjNkcsEZcj3ojLkVWQLM/CDh065Pr27WtJ8jVr1gSvV8WlEpjqo6rWLEC0KEmuivE2bdq4ffv2uY4dO9okivp9xowZltDU6Z86y+HKK6+0SfE0AR6Q0UmD1B96+PDhrmfPntZmav78+S5PnjzuwIED9vsNN9xgPco10ad2HBVIcfYMokHJcO0c6gCgJpXVpMb6ztVY2759OysZQBCxOWKN2ByxQlyOrIC4HFkFyfIsxl8pqUTR3XffbS1YNLHinDlzgrepunLMmDHugw8+oLoSUaMxp6Sk6OwFbzLPFi1aWDsMHahR/3y1xGjZsqUrUqSInf0ApIeS3aoc79Chg+vVq5dVlStx/vHHH1vCUhXn77zzjt1+0UUX2aSeXgCl24Bo0cHAGjVq2NkyqizXgZvixYvbBUBiIzZHPBGbI1aIy5FVEJcjK2CCzyzEm6ROyaO9e/e6fPnyuaJFi7p169ZZ2wHdfuedd7qGDRsmeSyTeSI9vHGjSikF415/Xk2u+NJLL7lixYq5cePGufz587tff/3VnXLKKa5QoUKWqBwxYoQllr744gvr9wukZvvm/e+NPW3fdCBGLVg09urVq+fKlSvn3njjDavuPeeccyI+D5DaSfj827rUjB//9jD8eQAkFmJzxBqxOWKBuByxRlyO7Ia9vyy08fDaEdStW9fdeuut7vzzz7devapyGzx4sFVUvvLKK9a3149EOdI75pQ8UpuBypUruwULFtj1GmfXXXedVfOqivzhhx+2CRXPPPNMS5avX7/ePf74427AgAFu2rRpJMqRKtq+qbXPhRde6F577bVgCxX9r4Mxy5Ytsx75msxTiXLR9m/mzJlJngdIDSW41cbnxRdftHGmyTuffvppd/DgwRQf50+Ue88DIPEQmyMeY47YHLFAXI5YIy5HdsMeYBaZaVobj82bN9vkiWq9Mnv2bDdkyBC3evVqS5SXLFnSde/e3e3atcsmW/Sjby/SM/Y05pQ80sEWtbi4+eab3TfffGO3qyd548aN3cknn2wHZ1RF7ilQoIBV/i5ZssQSn0BqKUmuMXfHHXfYgT/Rtk3VLRqD6hmtFj9eqyn1w2/UqBErGOmm3vf33nuv69q1q/Uj14GZvHnzskYBRERsjnghNkesEZcj1ojLkZ3QhiVO1JNX/aCbN2/+fx9Ejhxu6dKlrn///tajyaOqSl03atQoV7t2bWtLcNZZZ1HphgyfdvfHH3+4smXLWruV9u3bWwJT401js2bNmsG+5UowaYJPf3UlbQmQHmoxpQk81eZCSXHNu3Dfffe5HTt22ISx5513nrWf0mRWa9eutYM3OnBD6xVkhA486ywFHYz2zsxiTAEIR2yOeCE2RzwQlyMeiMuRXVBZHiezZs1yZ599tiXJvcpwJYjmzZtnSXNRxW+TJk2s9YU3uaf69ypp6a98AdJCiXK1Uvnss8/cE088YYlymTx5srVf0QSfPXr0cFdffbW1xmjdunWSMUdbAqRmxy/8d1X06v+KFStaX/wuXbq48ePH20SxqjRQwrxq1aru2muvdYsXL7ZEufqY03oFGZmQT9XkOnPm66+/tm0e2zAAkRCbI16IzZHZiMsRT8TlyI6oLI+x8P7iv/32m7VVUcsL9SbXBJ4nnXSSe+ihh6yCXJo1a2YVcV5SE0jvePPcdtttburUqe7GG2+0/71e5fLUU09ZSyBNMvvCCy9YwpJKcqRnO6cDgOprrwk89bvG2E8//eRatGhhleX6Wds8JczvueeeJOOV6l+khzdu1CNfraQ8GnMPPPCAzcPw6KOP2nXvvfeeu+KKK1zhwoVZ2UCCIjZHPMebh9gcmT3miMsRD8TlyK7+LzuGmH1JhQdHEyZMsEoWbURuuukm16pVK/fyyy9bSwztwKsVgRLq7dq141NCmngJbo0ttfzRONJZCqeffrr1qFMS/IMPPnArV660al7v/o888kjI86iy10ukA6mh7ZzGjc5OUDXvp59+amOsfv36NomnkuUad9quqSXL/fffb2NUfaX9qChHer5rvcmylRjXWNSZCqos18TZovG2e/du9+eff7rvv//eLgASD7E5Yo3YHPFAXI54IS5HdkYblhh+SR08eDA4qZ16jw8YMMANHDjQ+kOrgvedd96xnXpN6NmyZUu3adMma7uiiRSVrAw/fQpIjsaKEt+qrFRCUj3HNc40vtSHXCZNmuQuu+wya73y448/JttahUQ50kPJciUnNRms+uOfeuqpNkeD5l/4+eef3bBhw6xXYseOHd3w4cNt++c/RQ9Iz3ZP37V///23TQyr7Z22cV999ZUbNGiQ++WXX2xMqsJcbX403nRml7Z9jD0g8RCbI5aIzRFPxOWINeJyZHe0YYkR7YiPGzfOvfvuu5a0VPW4Ju5U5Zs2JJrkbt26ddaKoGnTpi5Pnjwhp+nRjgCp5Y2VPXv2WBWvqnk1rnSwRhWUqhzXWQsai6Lx9sMPP9jvF1xwASsaUaODNdOnT7dJPbX907ZvypQpNnGnepQvWrTI1ahRI7iN1PYuudOTgdTQ2VizZ8+2MxU07uT99993r776qrVa6dWrl80XcuTIETsQ6FVbcVAQSDzE5ogVYnNkBcTliDXicmRrAWSql156KTBhwoTg7507dw7kyJEj0Lx585D7/fvvv4GOHTsGGjVqZPc/dOgQnwzSbc+ePYEzzzwz0KNHjyS3LV68OFC4cOHA/fffH7yuTp06ScYkEA0HDhwIPPfcc4GCBQsGpk2bZtft378/8NlnnwX++++/kPsePXqUlY4MGTlypH3HNmzYMOT6d999N3DTTTcFmjVrFli/fj1jDkhgxOaIB2JzZAXE5Ygl4nJkZ7RhyWSatFNVbB71i9Zknar8HTFihFW/iX4fO3asK1q0qFu2bJk9DkhvP0RNEKuevEOGDLHr1Bfac9FFF7knnnjCLVy40Hr2ypdffunefvttVjiiLl++fDY58ZNPPmlnODz//PMuf/78dsZDeOsfKsqRnu2d34MPPmgtfj755BP38ccfB69XCyBdKleu7MqWLcuYAxIYsTlijdgcWQVxOTITcTmOJ8zal0nU7qJ06dKubdu29vtPP/1kfaF79+5tv/ft29d25pUs8ia1mzFjhvU0p3cqMkJj6sorr7Q2LB06dLC++GXKlAlOKiRVqlSxMbl3795g2wvd5r8PEC158+a1hLnG1mOPPWYtgcIn8wTSe1q7euLrNE/9XrduXTtYqFON1WJKLViaNGli92/dunXwsWzrgMRDbI54ITZHVkJcjsxAXI7jDcnyTPDrr7+6Hj16WEW5JhUrUqSITSKmiRb/+usvm2BRSfOnnnrKzZkzx23ZssV29nUf7dyTtER6eYlvJYVUOaWJ7JSc1FgrWbKkVZirH74qezX5nSos/dW8JMqRmYH5nXfeaUnMWbNmWQUwleTIyLZOifIVK1a4G264wZUvX96u+/33361neb9+/ex2TZb92muvuRtvvDHk8WzrgMRCbI54ITZHVkRcjmgiLsfxiAk+M8lzzz3n5s6d6ypUqOAeffRRd9ppp7nJkydbdeWoUaPc/fffby1Y1JJAlS47duxw77zzjsuVKxcT3CFD/BMkakwpYV6gQAH3+OOPW4W56MCNEkkTJkwgYYkMj7O0VOoePnzYtnNM5omM+vvvv61q/K677nIdO3Z0Bw4ccCeffLIbOXKkTZ4tmuTz66+/dl988QUrHEhwxOaIF2JzxHKMCXE5Yo24HMcbkuVR5v9iGjdunO2glytXzirJCxcu7CZOnGitMUaPHm0V5rq/vtz0GH3B/fvvv+7EEyn4R/SD8lNOOcWNHz/eKnqVPFqyZImNtfDgCkiLRYsWuVq1atnP3pkLaR2jQHps3LjRWp3Nnz/fxl7t2rVdpUqVrJJ86dKl1m5KZ9gw1oDERmyOrIDYHLFAXI54IS7H8YbmxJlk3bp19mX1yy+/WPW4JlTU0TZVwL300kuuW7du7plnnrEkuSp8vSpLEuWIBm88idoQ3HrrrdafXBPIajLPxYsX21hTbzESlkgv9YkePny4bd80lpQoV+V4gwYN3OrVq485RoGMUFszXbZv3+4uv/xyO5NLiXLRAWm1Y/HGGnOBACA2RzwRmyOzEZcjnojLcbwhWR7tFZozp/VMvfDCC92ll15qE3aqglx9VZ988km3c+dOS5grwfTBBx+E7MCTPEJmBuXNmze3Kszly5dbGwydxaADNUB6qa1PmzZtLAExduxYq96rX7++tcJQhS8QLToYIzoY47ngggtcqVKlXPHixV3lypXd9OnT7XodHFR/Ys3L4OH7FUhcxObIKojNkZmIyxErxOVIBLRhyQSqZlPiSMlwj6rcXnzxRdesWTPXtWtX62HunY7HKeJIi+TGi/96/ynHke5Pux9Ei85Y0JkKr776qvvkk0/clVdeaQcJ/bOiAxnhbcN++OEH99BDD9nOYMWKFW0+EFWx6IDNn3/+ad+vOqNBB6x1ZpcOCqa2ZyeA4xuxOTITsTmyCuJyZDbiciQK9iCjxF8hvmvXLvfZZ59ZFbnnvvvus7YX6h2ti5AoR3p4iW8lg9asWWM/KyHkr1bxJ4citSCg3Q+i4ciRIzZ57CWXXOIWLFjg8ubN62rWrBm8nSQlokHbsM2bN7vrr7/e+pCffvrpNmG2ztrSgec5c+bYWTMlSpRwjRo1sjkZvLNnGINA4iI2R6wQmyMrIC5HLBCXI1FQWZ5BXuVkeKWuTv/Wjvtzzz3n8ufPb9dpYs+qVavaDj478MjoBBr333+/JSlbtGhhLS+0U6j2PzpzoV27dqxgxIS2fRqHGoNqMfXmm2+6IkWKuCFDhvAJICrfr9q27d692yYo1mTZBw4csIOFd955p33Xal6Q5B4LIPEQmyMeiM2RFRCXI7MQlyPRUFmeAarm1c74ypUrrUfqww8/HGw/oETmli1b3BVXXGETeqoiTqeHq8JciXI9FkgvtSHQeFu1apVVVWpsXXzxxVZ1SaIcsXT33Xe7888/386Yueqqq1zdunWt2pwJFZERGj/6fv3xxx9tvgV9h+qMrX/++ccOQNerV89NnDjRtn+tWrVK8ngS5UBiIjZHvBCbIysgLkdmIC5HIqKyPJ28Pqjr1693NWrUsJ6pOk1cLViUIH/sscesRcaIESOsIu6kk06y6jd6qCKaNHHs0KFD3eeff+4uuugi99577wVPw9NYA6IhpXkVNLlnhQoVgr9rAsbcuXMf83HAsSpX1IdcZ2O1b9/erV271m3dutXdeOONdtA5X758tp1TH+JJkya5t956izO2gARHbI6sgNgcmY24HLFEXI5ERbI8g6fbLVy40P7v3r27TTT2/vvvWy/VBg0auAEDBtj9/C1amFgR0eBPSJ5zzjmWNOrWrZtVYJYuXZqVjKgG4wcPHrR+5CkF50ykiGjSQZgvv/zSEuS9evWyinIdGPz2229tElklzDUm/d+pjEEAxOaIF2JzZDbicsQLcTkSEW1YMkD9Ulu3bu02bdpkO+maaExVb5poTJW+6k0u/l7mTKyIaFCiXAly9SivX7++HaRZtmyZGzt2rPvjjz9Yycgwb9LYv//+291yyy3um2++iThZrId5GBBNI0eOtB742q4dOnTIKsmVNNeZXGrHosS5EhP+71TGIABic8QLsTkyE3E54om4HImIZHkahCeJPvnkE6tw+/jjj60/uRQuXNjdfPPNrmnTphEfA0TLqFGj3Omnn+5efPFFa1WghKYSSroOyOjpdko8/vLLLxYcffXVV+7RRx91S5YsSTFhDqRX+DweY8aMsbk/9P2qU9pF2zdN8Km2P/v27aPVFABic2QpxObIDMTliDXicoA2LGnu1aQqS532rZYrlStXtttq1qxpwfr//ve/YAsM7cirT7mXWKJvL2IxPj2MOWSUJi7W/AtqMaX5GDSZrNcK45JLLmGMIerbL52lpbYr+n69+uqrg1WiH374oZs5c6aNO1FFueZk4PsVSGzE5sjKiM0RTcTliBXicuD/0LM8Fbw+qKpuu+OOOywJ/uuvv7oWLVpY9Zvo1HCdDv7mm2+6cuXKBR9L0hLpEan3rn8sJfczEC1dunSxpOQLL7xgv6sNy/jx491vv/1mlVPVqlVjZSPDvO2Xvl8158KZZ55praSKFSvmXn/9dTsAre/dWbNm2SSedevWTfJYAImH2BzxGnN+xOaIFeJyxAJxOfD/0IYlFRQYqbJSyfF7773XTZkyxb3xxhtu2rRp1p9cli5dalVxgwYNCnksO/JI76l2f/75p/Xm/f33360/ucaSd0qUf1wxxhAN/tYq+nn//v2uQIECwd9V1duoUSNryaLJZNWSBcgobb+2b99uCfGePXu6uXPn2iSemtxTP4smzdYZXE899VSSxwJITMTmiCVic8QacTnigbgc+H+oLE+makBfUAqMvMnDPv30UzdgwAD3xRdfBO+rfr7qFa2e0bfddlvEU+6A9Fi+fLlr0qSJy58/vytatKj1wH/ggQfs90iVLUA0aO4FJch19oy2a+pTPmfOHJtIVpRAV1JTVb8HDx50I0aMcIUKFWLlI83827F169bZuFKCXJN5ai4QnaE1depU98MPP7gqVaokeQyAxEFsjqyA2ByxRlyOWCEuB5JirzNC1YASQn369LEqtgULFgRnON+7d69bs2aN/a72BBUrVnTXXnut27NnT/A5lCjX8wBp5VWNHzhwwD3//POuX79+bvXq1e66665zCxcudE888YTdpjEaPukGkFHa7qlivE2bNjbnQseOHd2NN95ov8+YMcNt3LjRTgFVr2glM+fNm+e2bdvGikea6WC0tmM//fSTe+WVV2wc6btTFea1a9cOJspFZ2vpgI2w7QMSD7E54onYHPFCXI5YIS4HIiNZ7ttIaGddiW+1G9ixY4dVU3oVlRUqVLCJPdWzV0lzJc9l9+7dSVYqleVIDyWC1MpH7QY0xpo1a2ZjSRMsKjmpnr46gKPgiepKRFuePHncDTfcYD937tw5OJmn2k+p3ZTOnvnxxx+tj3TLli1dkSJFbCJGIK2JB53iqTZTOntGP+s7V4ny4sWL2/wfXqL89ttvt0m1r7rqquDj2fYBiYPYHPFGbI54IS5HLBCXA8mjDYuPkkN16tSxZKU3qZ0oSa52LN99951r2LCh7biXKFHCEkU6RVz9yr12LUBGJtPQGQtKTn788cc23rxJFNWzXAdq1Cv/zjvvtKpfIBpjTm0vFJB727oPP/zQvfTSS9ZqZdy4cdb6RxMan3LKKdZyRTuOar+isx/UlkrbQiAttm7dapPEavzpjBnRmQsNGjSwliuVKlWyNmc6s0a98XU2Ay1YgMREbI54ITZHPMYbcTlijbgciIzKch9NJqYEkZco9069UyJcyUpVmWtyu7PPPtu+yMqUKRNMlNN6BekRPmGnzlhQy4vGjRtbn3JNLCtKFmlyWbXJuPvuu1nZiEoVgap5K1euHGw3pW2Z2v506NDBqsgffvhhO9vmzDPPtGT5+vXr3eOPP27zN2iCYxLlSMtOoHfRd6wm7fzkk0/su1X0faoDhEqWq29+3bp1baJPbft0EIeKciAxEZsj1ojNEY8xR1yOWCIuB46NynIfVbq9//77bv78+REn6tTp4Kp+q169esj1TOqJ9PDGzdq1a93EiRMtGaTWFmq7ImpRoJ6+ixYtciVLlgx5LFWWSC9v7OisGLW9ePDBB93nn3/u3nvvPWuHIZq8s1GjRjY2dRaDkuOi3tKzZ892F198sTvnnHP4EJAmu3btcoULF7ae+CNHjrQDg61atbK2P0qKR8L3K5DYiM0RS8TmiDXicsQLcTmQMirLfVTVq3YD2pFXElNH3MSrGlfSctasWcFKOA89ypEa3njy/te4WbVqlbX+0ZhTInL06NHu6quvtttnzpxpVZbly5e3AzUhf7g5+dNF+idK++OPP6zFj1quqLXPNddcYxXlquSVvHnzWsX5008/bRPNenTmza233kqiHGmmeRh0VtaTTz7pTj75ZNe1a1ebi0HV5Wrpo+pxb4z68f0KJDZic2QmYnPEE3E54oW4HDg2Mm4+Ou27dOnSVvGm5KVOh/JXtb3zzjtWcZlcBRyQknXr1oW0XFFySMnITp06ueeee869/PLLlqxUq4t27drZfVTtq8pfVWMCGaVtmcbXZ599Zr2i27dvb9erJYaS5Zrgs0ePHnbAZtmyZa5169aWXPdOSRYO1CA91FpFE8YOGjTIvmOVMO/du7erWrWqtVl45plnqCIHkASxOTITsTniibgc8UJcDhwbyXKf888/39WrV8/aDGgCO6/CXAlzVVOuWLHCPfbYY6lYrUAo9X9WFaV6RHsVlOoPrYoWb3JYnbGgyl0lztV+ZdOmTXabEkzeOATSWi0Vrm/fvq5t27aWDNdY9MbjpEmTXJcuXWySWfWPVmsWjTta/iAj4+/AgQPB6zQ5sVpOqRf+s88+a4H6o48+auNtx44dHIgBkASxOTILsTliibgc8URcDqQdPcv/f15CSBuSPn36WOWl+pOrBUaePHnc/v37LXmkqnJ6qCKt/vnnH7dz505XqlQpt3v3bleoUCEbc5qsc8OGDdaKwKNe0qo2V1V50aJFWdlI9/ZM2yqNvd9++80m6Dz99NODScsPPvjA5mdQZW9yCXEl0r2DOUBabdmyxQ4wX3/99XbWgkeTw952223WfkXbQI1Rtf7RWTf6DvbOvgGQ2IjNkZmIzRErxOXICojLgbQhWe7jTxipl/RXX31lyaayZctaT19VWZI8Qmr5kz7ez0qY16hRw/Xq1cvdc889wX5htWrVcoMHD7axpjYYOlCjye9IGiGtvIN5OjPm3nvvdXv27HFz5syxPuPqjz927Fi7nxKY33//vfvoo4+scg+I9vfomjVrXM+ePa3lipLjjRs3tuvVzkyTyerA4PTp091NN92UZJsJAOHbFGJzZBSxOWKNuBzxRFwOpF9CJsvDK8P9G5GUWg5QUY608h9c2bp1qyUu3333XTds2DBrr3LXXXe5P//80zVp0sTGXr58+eyiHr46i4EWGEjPtk3j7NJLL3X169e3gzJKTiox/sgjj7grrrjCxqA0bdrUEpb6/YILLmBlIyrjTz1gly9f7lq2bOlWrlzphgwZYu19dEZDo0aN7L4DBgxwFStWdK1ateLsBQDE5ogZYnPECnE54om4HMiYhEyWewYOHOj69+8f78XAcerQoUNWMf7QQw+52rVrWz98JSWrVatm1b0af5ro7o477rB+5atXr7ZEU6VKleyADWcxID10tkL16tUtUakJZP2WLFliZ8moynfMmDHBydPU7sdLoAPp4R3Y00EZTRDbvXt3S45rbClxrh7l27Zts4Myagv0yy+/uG+++cYqydnWAfAQmyMzEZsj1ojLEQ/E5UDGJWwzWu2oa6ceiDaNqwoVKljrASXK27dvbz8//vjj7qKLLrL7qNpXdLuSRe3atXNVqlQJ+YKjVzTSSuNGY0p98VXN6+0Yat4F0fh74okn3IQJE+yMBvUw//LLL+1xQEYoUf7HH3+4a6+91vXr18/df//9Nq40FnUAUMlyTe6p+UA0safanHk9ytnWARBic2QWYnPEA3E54oW4HMi4ExPpFBSviF476Dr926ukVFWvWl4IbS+Q0WBcSXElhpQgV19ojS/1Ki9RokRwjOXPn9/6SeuLTNWXxYsXD7YnkORaAQEp0bi58sorrQ1Lhw4drEKvTJkyIds1HZT56aefrNLF692p29j2IaPU0ue8886zRLkmxVYvciXC1YJKZ9Go2lwXDxXlQOIiNkesEJsjXojLEU/E5UDG5EyUYFzJoS5durjrrrvOqtu+++674H28RLmQpERGKBE5YsQIV7p0aff333+7QoUK2dh78803rS3Gyy+/HBxj6k3evHlz9/bbb7sGDRqw4pEh3sHA1q1bu5tvvtnt2rXLPfbYY27z5s025lRhLjpQo+pfTSbrn0yRbR8ySmfU/Pzzz9baRwf/tP174IEHrBWLAvbw8UpFOZCYiM0RS8TmiAficsQbcTmQMcd9slyJ8lWrVlm1pXbYGzZs6GbOnOl69OhhfVM9Xbt2dR07dozrsiL7UsJb7S+UcFQl719//WXjST3xS5Uq5W688UbrU65qch2skU6dOrnZs2e7Fi1aWNJIVZZAenktLUQHZm699VarHteknhs3bgy2Yhk9erQrXLiwHawBMpLskgMHDtjknfr97LPPdm+88YYdsNF3rH7WgUCdtaD7hY9XAImJ2ByxQGyOeCIuRywRlwPRlxATfCpZpMSQN5nnmWee6Zo1a2YVwPv27bN2GT/++KP1VaXSDenxySef2MSJffr0cYMHD7bkkPr2rlixwl166aXWlqBgwYLupZdesn7lmvhzy5YtNqmn/8wGIKO81iryzjvvuNdff92dcsopbvz48e7BBx90X3/9tU30qW2d/75AWqtC9b3Zq1cva7OiCYz1var/RdtAtWLR9k5n1yxdupTvVwBBxObIbMTmyAqIy5HZiMuBzHHcV5bLypUrLVkkF1xwgbv44ostUb5+/Xr3xRdf2Abm/PPPtx1576gckFpKCql6UmPpmWeesYS5KswHDRpkSXFNoPjcc88F+0grUam+vWvXrrVEOWMOsahk0Zk1GouLFy8ObutIlCM9vNZml19+uW3jdGaW2v7ogPRHH31k99GBQCXDfv/9d/ftt9/y/QogBLE5MhOxObIK4nJkNuJyIHMcd5XlkSapU9sB9UtduHChVflOmDDBrldfX/WWVuIcyOjRXE3kqaT4ww8/bNXlSpprPA4dOtQtWLDA1alTx9qweAdu/I8FMrOSRe0wtP3TxLNeyx/OokF6qWJcbaTOOuss17dvX7tOZ2blzp3bFStWzJLm6luuSdV0IFrbOMYckLiIzRFrxObIaojLkVmIy4HMkfN4C4yUKN+0aZObO3eu/a8vpksuucTaYeTNm9d169bN7nv77bfbRGRPP/10vBcb2ZwSQRpf6k2+e/duS4oPGDDA2hNoPOp/JY7ef/999+GHHyZ5LJBayR3b9F+vpER4JYt6SI8ZM4ZEOaJC260mTZq4++67z5LgF110katdu7Z79dVXbVuo67/66itXrVo1u6/GJAdngMREbI54IDZHLBCXIysgLgcyx3FTWe4drVUlmybxLFKkiO3E6/Rwtb5QZe9rr71m/evUiuWff/5xM2bMCLbBIGmJ9NJY0gSeSoir7YASQzpY07RpU9ezZ89gD3P1jlZLjPAzH4C0WrRokW3jzjnnnGDFXnL9x+lLjozyf0d64+ngwYN2AHrUqFHu008/df/73//sdm0Lr7jiCqs8Z1sHJDZic8QLsTliibgcsURcDsTGcZG1U7JIO+/qCT116lQ7LVy9EG+77Tb37rvvWusB9VVV+5XPPvvMJlmcNWuWJcqVUCdRjozQ5LHaIVTiyKMDNo8//rh74oknrC2LkkY6m0H/e5W/QHps3LjRPfXUUzZ5p/pCe4nyCy+80E2ZMiXJ/elLjmgE5PpO7dGjh7vlllvctGnT3ObNm+12TVSsMXb48GHbxqkVi5coZ1sHJC5ic8QTsTlihbgcsURcDsROtk2Wq0J83rx59rN2yrdu3WrtVtasWWOT2km/fv0saTlnzhzrW66d+/Lly9tEd9q559RwpEd4AujAgQOuePHiNmGnKlm8asoqVarYxJ+a3M5/AgfVlsiIMmXK2AGYVatW2bZNCXNNWqzx1q5dO1YuospLlKtaXNsutVwZOXKke/TRR+0AdYsWLdwHH3xgk30uW7bMDth4iXK2dUBiITZHvBCbI16IyxFLxOVA7OTMjkfTlJycNGmS9Yj25MmTx3biP/roIzvC61ElXOPGjW2COy+57mFHHukZfxo3OvCyePFi98cff7j8+fNbj161WRk0aJBbvny53Xf69Onuuuuuc59//nlI/2ggo+rVq2fbtm+++cYOyGii4ldeecVu00SzQHpEqgTXNu/FF190Dz74oE1WrHGn+UC0c1iwYEH73v3tt9+sHYvaoHlnbPH9CiQOYnPEe/wRmyOeiMuRGYjLgfjKdj3Lt23b5ooVKxbsl6rE+C+//GJVb5pc8f7777d+0apuOf/884OPU3uWVq1asQOPDPfe1AR2Gm8VK1a0xPjEiROtF7n61XkT3nmT2SmhruQRfaMRLWp3oVYXop7lSo5r4uLmzZtb0hxID28bpbNjdBDwrLPOCt6mg36qIL/rrrtszo+zzz7bDgaq4lzfyaoq91BRDiQeYnPEC7E54o24HJmBuByIv2xVWa4k5RlnnGGTiSlRri+nPn36WG9oJcgLFSrkxo4d65o0aeIaNWpkO/KeNm3a0EMVGf7C2r59uxsxYoS1+FFVr3qSd+7c2Sov1Rf/448/dq+++qrdR+1XvCpL+kYjWpQoV4JcPcrr16/v3n//fWt/oW2fkpxAeniTdp533nnWvkzft56aNWu6n3/+2VWvXt1Vq1bNEuXSv39/O5vLj4pyILEQmyNeiM2RFRCXIzMQlwPxl62S5WXLlnUdO3a0xLdaW+jLScnKIkWKuPHjx1v/Xp0WrkSlWq+oh69OD/djRx7p4SXKu3fvbv3xVUEu+n3gwIHukUcesQlkTz31VEsoqfJcPcV0aqhXZQ5Ei1penH766XaQpmrVqjbpoiaz0nVAeqmqXC3N9L2pM7HUVkXUakWtzHSQWq2mRBNor1u3zj355JOscCCBEZsjXojNkVUQlyMzEJcD8ZXt2rCo1YoS5EpMvvXWW+7KK690f/75p7VfUdB07733umuuucbt3LnTPf/8865nz56WtAQyaunSpe6ZZ55xM2fOdK+99pq74YYbgreNGTPGevp++OGHdmYDEOtZ0T20/EFaeOPFax+lpPj69evtzJmvv/7aDkKrmvydd95xkydPdr///rsrV66czR0ya9YsO3smfAwCSCzE5ogXYnNkNcTlyAjiciDryDbJcn8CaMeOHW7IkCHWK9qfMO/SpYtVjrdt29Y1bdo0+Fh25JEekXrvqj++xp565auqXAdmPBqL6htNJTmiPe7827/kfgbSwvteDB9vamnWt29faymlyTx1AFDX6QwG9SXetWuXndWlalI9zj9HA4DEQmyOWCM2R1YYc8TliDbiciDryRbJcm/j4Z9AQ19cSlZOmTIlmDDftGmTa926tatduzanhiMqY27NmjXuvffes0pLTXKnsbV3714bXxs2bHAPP/ywa9CgQchjSR4ho+NOB//UI7p8+fKuVKlSVr3LxImItn379tl2TQeY1QNfLaREZ2opNFAf/BtvvNEmL1byXAlzP8YkkLiIzRGvMUdsjliPOeJyxAJxOZC1ZPlkubczvmrVKutFrirKokWLul69ell/ciUrX3nlFffmm29an+i//vrLepjTmxwZpQliL7/8cnfHHXe4H374wcaU+kKr5cr+/fvds88+6xYvXuzGjRtnPX2BaFi+fLm18smfP79t63SWzAMPPGC/k5xEND311FPu0UcftTYrl112mU0Qq/k/NDmxqsmHDh1q4+6mm26yg4arV692FStW5EMAEtz/x96dgNlcv/8fv8m+VsqWJURFRAhZSimisqVNJUKFylaiIqXQIltokRLakHaVQgnZoyJLSGXNvpP5X6/7+/+c38wYxSznzMx5Pq5rrpn5nHPmnDneztzn/tzv+yY2R6QQmyPciMsRLsTlQOqS6gd8KkGpCgIlLQsVKuSVbUqc67MqzbVdvE2bNnbVVVd537qzzjrLb6NAHjgZCZ0v0vpRf/J27drZs88+61WVXbp08Qrf4cOHe8JIA+40BK9y5co80UiS4PVKfaA1a6F3796emFTV7+zZs31Ogy7jtQ3JSa9pmvOhv7F6LStQoICfgH7ttde8qlyvdaLdWzpBrZ0OAEBsjpRGbI5IIi5HJBCXA6lLqq4sD/qBqaoya9asnrxUi4vq1avbRRdd5MPGdJ2DBw/6wM/77ruPIWNI1Pa6Q4cO2aJFizwJrmperStV9+qjY8eOoesPHjzYXnnlFT8xoyrzABW/SCq1kVJLn0qVKvkuGiUudUJQOxe+/vprP66EZc6cOXmykWyOHDni7cu0e+bbb7/1XTPTp0/3NfjUU0/5CZug/ZkwAwSIbsTmSGnE5kgNiMsRCcTlQOqRqivLg8F16t+kBLlUqVLFypQp44lyDVt8++23PZGuHqtKeiqZDpwMJbi1ZtSDvEGDBn4yRhWVwRtB7V546623bNOmTaHbqB2Bkpi7d++O87No+4PECs5XaldMyZIl7Z133gmtOSUpdbLm6quv9rYY48eP54lGstJumXfffdcuvPBCu/TSS/018e6777YZM2ZYs2bN4iTKRZcDiF7E5khJxOaINOJyRBJxOZB6pLrK8qCaYOfOnXb66af7sQcffNDmzp3rf7xUXfnyyy/7cbXBUGsWJTmBUxEkxJUoVxsVJcuHDBnilbw6+SKLFy+2/v37+wmYvn37WunSpX33wsaNG70tS/CGEUiME+1GUCWvqnz1mqfXN9G6nDJlig9b5MQMUupv70033eTDPLX2ihUrFnqdBBDdiM0RDsTmiCTicqQmxOVA5KWqZHkQjP/0009e2abBY40bN/ahYxqyqOSlBngeOHDAqy31vQaRZcqUKdIPHWmQlr56kisRqSGxCQVLX375pVfzqvKydu3a3jdaFZc660siCUl9rVu5cqW9/vrrvt40mLh79+5+udr//Pzzz564DBLmCa1PILnXpVqyTJo0ybcfaxcNgOhGbI5wIjZHJBCXIzUiLgciK1Uly0WJ8ssvv9weeeQRT4jnyJHDjysp/swzz/jlF1xwgQdTkydP9qQlPVSRGKoYv+GGG3zAnT7r++DES7CmgsSk+pmfccYZVrx4cf8+9nWB/xKcWIl9gkWDivVap2pezV3QiZnzzz/f263I9ddf71//+eefli9fPp5khIVe+/r06eO7aWi5AkCIzREuxOYIB+JypBXE5UDkpKpkuQYa3HLLLd47tV+/fp6oVNWlKsmVODr33HO9PUHBggU9eUTSEkmhvuPqha/E0M0333xcpbh65b/44oveekX9pANU9uJUab6ChsfGfjOoXQ1qdaGkpGzZssUuu+wyq1mzpr355pt+nUcffdRPEpK0RHLQa5w+TnZnAieiARCbI5yIzREOxOVIDYjLgdQtVe3lV6IyT5483hbj008/9f7kn3zyifckV69eJY/Kly9vZ599tr/ZV9KS6l4klgbX5c2b16ZPnx5af/qjFQyJzZ49u7f6Wbt2bZzb0QIDp1qRd+WVV9rWrVtDa0uvW1prweuXkhH58+e34cOHe/sVtcDQZQMHDvREuZKWQGKMGzfO3n//ff9a60ivX1p78V/XEsJJGgDE5ggnYnOkNOJyRBJxOZB2RDRZrmR3bEoOVahQwb755hvvIX311Vf7ULt58+b5sE8lm2IjaYmkyJYtmz3xxBP22muv2bBhw0JvCoMEZvv27b1HuQaAAolVqlQpH5iok3z79u2Lszth5syZ/r3aSck555zj6zL4PkDSEomhE88aYqzhxR988IG/tilhXqZMGf/bCgDxEZsjkojNkdKIyxEpxOVA2hKxNizB9u5169Z59e7OnTutdevWftnGjRu9P7QCJrnjjjts8+bN9sUXX8RpkwEkB1Xzdu7c2dq0aeNDPHPnzu1nfTV8ceHChZ64pPUKTkXslj7B1zt27PATLz169LB77rnHk5hKWtaoUcOeeuopb8ny0EMP2YYNG3xHDa91SK4t7RMnTrQJEyb4HBDt1NIbxbfeeosnGEAcxOZILYjNkZyIy5FaEJcDaUdEkuVB4nHp0qV27bXX+ht3JYjUguXDDz/03uQK2KdNm+ZVv0paasAnSUukFA1XVMJy+/btVrp0aStcuLANHTrUKzEZ5onEiL1udLJPwZGGEj///PPeXkUnZzS8s1GjRv6aqLY/+tBQT17rkNxGjx5tXbp08RM2QespVbhoyzsAEJsjtSE2R3IiLkdqQlwOpH7/y+SEmRLlqihv0qSJD7Dr0KGDv2lXJbkGfKqqNxiGpz6+b7/9NklLpKhrrrnGLr/8cu8dnSNHjlCLH520oS8+TtWhQ4e8Yrxr164+sLNOnTqeKFeyUslJHdcau+uuu2z+/Pm2YsUK32lzwQUXMLgYKfLG8KWXXrKLLrrIv9curfr165MoBxBCbI7UhtgcyYW4HKkBcTmQtqR4ZfmJ2ld8/fXXPnRs1KhRnihXQumSSy7xoRt6SGPGjLHzzz//uK2hQCS27AEn48cff/SdMrly5fKTfnfffbd/3a9fP7vvvvv8OuqD//LLL/tOhhdffNFatWoV52fQ8gfJSX87q1Sp4olytV5RO5ann37a12CtWrV4soEoRGyOtIrYHKeCuBypDXE5kHZkTOkXAyXKDxw44C1VPv74Yz+jJldddZU99thj/nXz5s299YXevDdr1syH4T355JNxfhaJcoQbiXKcakCupLjmL8j111/vOxXUq7xgwYKhBIV2Ltx7773Wp08fn9MwderUOD+HwcVITup/r3ZnQY9yVZSrb7l2PgCIPsTmSMuIzXGyiMuRGhGXA2lHilWWB5Xg6tOrN+XFixf3Xrw33XSTvfrqq54wkt9//90HeKqSvGTJknb//fdbixYtvNKcBDmAtEKJcPUgL1q0qP3999+WL18+W758uf3888/+uvfKK69Y27ZtQ9fXa59mMdxwww20+kGS1l3stlH/9nczfjUpO7aA6EJsDiBaEJcjUuuOuBxIH1Kkslz5d71h37Nnjw8Tu/rqq+2zzz7zQZ2ffvqpffTRR6Hr5s2b16/frVs3r8T8/PPPQ4lyBfUAkJpNnDgx1INcifJt27ZZ+/btvXJcg2JvvPFG7xetavLXX3/db6OWLOobrZ00wRBZ4FTpb6fWnU7SSPy/m/HPhcfftcAJaSB6EJsDiAbE5YgU4nIgfUmxynIN0lDSW9WVSgoFNMBTCSUNuStRooRXWr7zzju2aNEiTzKpFUvmzJnp2wsgTVCLKQ2h0rBi9SFXRUHv3r1t6dKlVr16devUqZPlyZPHd9Tcc889vtNm06ZNPtRTr3VAUipEdVJaf1f1dXAimopxAAkhNgeQ3hGXIxKIy4H0J8WS5Zs3b/aqyQsvvNAH2NWuXdt7ljdu3NgGDhxoCxcutPXr11uHDh28DcuJJgUDQGrfajdr1iyrV6+e75DR8EQd1+vct99+6699QcJcr3tqv6LWK0EVMNW9SOy6W7Zsme9gUF/877//3v++anC2sLYAxEdsDiA9Iy5HJNcdcTmQvqRYslzWrFljDzzwgA+3UzX50KFD/Y28hnvu3bvXk+lKJD3++OMp9RAAIMUECUkN8hw+fLgny1VdrirzIGGuRHqtWrW8DcsZZ5xx3G2BxNBJl2rVqlnfvn39b6rW2ciRI731z+TJk1ljABJEbA4gvSIuR6QQlwPpT4r0LA+UKlXKE+SqZBk0aJA98sgj/qZecuXKZdmzZ/d2LACQFinZrXYrSlDu2rXLk+JPPPGE9ejRwysM9FknBKdMmeI7a+LfFkis3377zUqXLu398fW3tmXLln6iZsmSJda6devQGtNJGwAIEJsDSK+IyxEpxOVA+pOileWxz7Sp3Ur+/PmtTZs2nlDSm3n1KVdbAlquAEiLDhw44AM8lRDXyUAlJr/66itvs/Lwww+HepiPHz/ek5nxBywCJyv+TgSdfNHOLfW+z5o1qw8V2rdvnzVs2NArRy+//HKbMGECTzCABBGbA0hviMsRLsTlQPoXlsxNsWLFbMiQIV5hPmbMGKtTp44nyRcsWOCJcr3YAEBao90xSlJmy5YtdKx+/frWr18/712utixKkGsugz5T5YvEUqJcVStq9yPXX3+998FXn3LJkCGD79gqU6aM9zHX39v33nuPJxxAgojNAaQ3xOUIF+JyIP3LGO5tn6qCU3JJyfLMmTP7ME/aEQBIC+Inu/fv328FChSwlStXejVLUDlevnx5H/ipE4KxN+9QWY7E0jqaPXu298N/9tln/djEiRNt3bp1VqlSJXvmmWd8R4PasNx0002+Vn/66SeecAAnRGwOIC0jLkekEJcD6V+mcAflH3zwgZ111lmeNFKinBYsANLSdruNGzfahg0bvE95kSJFvMWUEuN58+a1m2++2SpWrGjvvvuuXXfddd4mIwioVPkLnOqbwOAEi9aP1tThw4e9vY/WonYuLF682Lp06eLrUmtS1eTa6XDuuef6bYOTNaw/AAkhNgeQFhGXI9yIy4HoEpae5f/1YgMAqVmQ7NYwz7p169p5553nFbyvv/669yKfM2eOJ81jnwCcN2+e754hUY6k2LRpk+3evdvbq4gGyaqiXK1+dDJGifL4VHmuj++//97OP/98/gEAnBRicwBpAXE5IoW4HIgeYa0sj41EOYC0FJBv3brVBg0aZL1797YHH3zQnn/+eevYsaMPVWzfvr19/vnnHkDt2LHD5zKo8pfdM0hKtZTW1q233uq9yJ977jm74IILfAdDixYtvKWZepOrFZBas4j6lH/22Wf28ssv25dffkmiHMApITYHkNoRlyPciMuB6BSxynIASCuUKO/evbtt2bLFPvroI68YFw0u7tu3rycy77zzztDxhKakA6fyJlBzPdTOR8nydu3aeWX5448/7glwJbTefvtte+WVV7xnvr4O2qz88ccfliVLFsufPz9POAAASHeIyxEuxOVA9KIPCgD8h99//90OHTpks2bN8srdgCrMlSxXMlOVvLGRKEdiWiAo6b1z505vsZInTx4f3jlp0iT75ZdfrH///vbDDz/4ddVipWHDhqFEeTDkSn30SZQDAID0irgc4UBcDkQ3KssB4CT6tq5evdqTlRruqSrza665JnTZ+++/b02bNmVgMZJs7dq19sILL3g7n3HjxoUqxtevX2+tWrXy1ix79+716nFVn6tHPn3xAQBAekVcjkghLgeiF8lyAIglaJ/y66+/2gcffOBB0nXXXWc1a9a0PXv22DPPPOMVLd26dbN69erFee7oUY6TdaIE908//WQNGjTwtaY++Jdddlnosm3bttmPP/5o27dvD52cod0PAABIr4jLEQ7E5QDiI1kOAPGo5cUVV1xhd911ly1btsyrzLNnz27Dhg3zyt4XX3zR5s2bZyNGjLCqVavy/CFRFVIHDx60uXPn+lrS4M7atWtb2bJlfRdD48aNrVq1aj68s1SpUgn+HBLlAAAgvSMuR0oiLgeQEJLlAKJWQlUECpjuvvtuK1y4sD399NN+bNq0aTZ69GgrWbKkH5szZ47Nnj3bunTpcly7FuDfBAluVY43atTIzjnnHH8TmCtXLps/f74NHz7c2rdv78eaN2/uOxp69erlaw8AACC9Ii5HuBGXAzgRsjwAojY4UqJcgzuV/N66dasf17HNmzd7sjygdiuq8lVblgMHDliNGjW8DYsS5cFgReC/aK0oUb57926rUqWKXXTRRfbWW2/Z4sWL7auvvvJhsffee6+9+uqrXmH+7rvveuX5Qw89ZH/99RdPMAAASJeIyxFuxOUA/g3JcgBRGxypulf9oZ977jl77bXXQhUtFSpU8CTmpk2bQrdp0aKFFShQwBOdsVFZjpOltbJ//34rX768XX/99d7GR33HgzY/PXv2tH79+lmnTp1s+fLlvg415DNbtmxWsGBBnmgAAJDuEJcjEojLAfwbkuUAoooS4gqOlCivXLmyJy4nTZpkXbt2DbVkufnmm61YsWLWoUMH71mu3tKPPfaYZc2a1fLnzx/pXwFpmCrIlTCPvXNB1VTB2nzggQesUqVKvttBbx4rVqxo48ePZxcDAABId4jLEUnE5QBOhGQ5gKiihLgCc/Ubr169ug0dOtSPKREetFRRsrJt27aWO3duH+CpKuCVK1faxx9/HLo9kBh16tSx559/3iZMmOAnYES7HLT2tLZURa4hsnv37j1u1wK7GAAAQHpCXI5IIi4HcCKZTngJAKRTquRVD2j1h5ajR4+G2mEEg17Up/yaa66xBx980M444wwrXry4Xx5cF0gMraUmTZp4clzDPLXW1Ktcn0XH1a/8kksu4QkGAADpHnE5IoW4HMCJkPEBEHXUBmPdunU+rFOCRGXwtap6X3zxRbvvvvviJC2VyCRRjqTKmzevNWvWzL9WwlxvEtWrXNq1a2d///23D5EFAABI74jLEUnE5QASQrIcQNTJkiWLB0bTp0/3/uTBFlAlLZUM17DFxYsX29q1a+2ss84K3Y42GEiJwPyll17y71evXm1LliyxBQsWhFqzsOYAAEB6RlyOSCMuBxAfyXIAUUd9oZ944glr1KiRlStXzu6//35PmAdV4+3bt/cqFw0ABVI6MNfa6969u5199tm2dOlSy5w5M+1+AABAVCAuR2pAXA4gtgwxTKoDEKXUAqNz587Wpk0bq127tg/0HDdunA/zXLhwoSctqe5FStuxY4fNnj3bGjRo4BXl9MUHAADRhrgcqQFxOQAhWQ4gqn355Zf21FNP2fbt26106dJWuHBhGzp0qFeZk7REYh06dMiyZs0ap73PyQgGzAIAAEQb4nKkBOJyAKeKZDmAqKcA6siRI5YjR45Qj2iSlkisqVOn+s6Ejh072umnnx5aT99++63VrVuXJxYAAOAEiMuRnIjLASTG/7JCABDFVAGcK1euUKJc1cBU9yKxNm7caOvXr7fRo0eHjl100UX2yiuv8KQCAAAQlyNMiMsBJAaV5QAAJDP1vld1+TnnnONfV61a1V599VWeZwAAACCMiMsBnCqS5QAAJBPtSsiQIUMoMO/atasVK1bMFixY4McOHz5sWbJk4fkGAAAAUhBxOYDEIlkOAEAyOXbsWKidT5UqVSx79uxeVV6qVClr0aKF5c+fn+caAAAASGHE5QASi57lAAAkEyXKFZhXqFDBypcvb999953VrFnTh3tOnz6d5xkAAAAIA+JyAImVKdG3BAAAx9m2bZs1b97c+vTp4983adLE8uTJY1dddRXPFgAAABAmxOUAEoM2LAAApMB2z4R6lMe/HAAAAEDyIy4HkFgkywEAOEn//POPnXbaaf86QAgAAABAyiIuB5BSSJYDAHAK1SkrVqywESNGWIkSJeziiy+2K6+80i8nYQ4AAACkPOJyACmJZDkAACcZkK9cudIuvfRSq1+/vm3evNmrzG+//XZr3bq1X4+EOQAAAJByiMsBpDSS5QAAnAQlx6dOnWo7duywzp07e+L8/ffft08++cTat29PwhwAAAAIA+JyACkpU4r+dAAA0jhVi6snYq1atWz9+vX27LPP+vEyZcpYy5Ytvbrl9ddft3379lmnTp3oXQ4AAAAQlwNIozJG+gEAAJBak+SiwZ2ZMmXyqvJChQrZN998YwcOHPDLzj33XLvzzjutevXqtmzZstBtAAAAABCXA0h7aMMCAEA8qiRXP/I9e/ZY5syZvfWKEuVr1661ypUr27XXXmsvv/yy5cqVy6+/adMmK1CggCfW6VsOAAAAJA/icgDhRmU5AACxqK2KEuWqFG/YsKE1atTI6tSpY6+99pqVKFHCFi5c6FXmHTp08GS6FCxYkEQ5AAAAkIyIywFEAj3LAQD4/8F4xowZ/eP333/3RPnDDz/sleRLliyxjh072vbt2/3YvHnzrHTp0nbeeedZ7969Q8+fKssBAAAAJB5xOYBIIlkOAIhqb7/9tl155ZXeRiUwZ84cu/jii+3+++/37y+77DKvHr/55pu9ylw9yv/880/Lnz9/BB85AAAAkH4QlwNIDWjDAgCIWuov/sEHH3gleWxZsmSxLVu22MaNG/06R48etWbNmnnSPLiuepirXYsuAwAAAEBcDiDtI1kOAIhaapvy7rvvWtWqVW3lypW2efNmP16kSBHbtm2bffjhhz5UKFOm/23EUuJcbVpiCy4DAAAAQFwOIG3jHT4AICp7IMb+Wp8HDBjgifPVq1d78rxXr17WtWtXW7VqlRUtWtR+/PFH27dvnzVt2jTSvwIAAACQ5hGXA0iNSJYDAKKKkuP79+/3dioXXHCBV5TPnj3bhg4dan///bddeuml9sMPP1jbtm0tX7589tlnn9n3339vZ511ls2dO9dbr6jaXJ8BAAAAEJcDSD8yxGhPOQAAUaRLly42cuRIGzdunN155502atQo/3z48GFr3ry5LVmyxObNm+d9yQ8ePGjZsmUL3ZZEOQAAAEBcDiB9IlkOAIgKqhDfuXOn3Xbbbf79NddcYzNmzPDE+cCBA0PXCxLmP//8s3377bfevzyg88vqcw4AAACAuBxA+sOATwBAuqde4/Pnz7fy5cuHjuXNm9fKlCnjfcqXLl0aqhrPkiWLTZ482YoVK2b3339/nJ9DohwAAAAgLgeQflFZDgBI1zZu3OjtVI4ePWqZMmWydevW2a+//mr169f3yxs3bmwLFy60zz//PJRMnzlzplWqVMly5coVGgYKAAAAgLgcQPpGBgAAkC6pZcqPP/5oF154oU2ZMsW/P3bsmL311lvWs2dPe/XVV/16H374oVWpUsUaNmzoSXK1YBkyZIjlzp3bE+W6DQAAAADicgDpH5XlAIB0rVOnTvbxxx/bSy+9ZNddd5399ttv9vrrr9vcuXPtlltusbZt2/r1WrZsaZs2bfKvp06dapkzZ6ZHOQAAAEBcDiCKZIr0AwAAICWo//hpp51mw4cP9/YrSpqr53ijRo2sXbt2XjH+zjvv+HWVMB8/frz9+eefVrhwYb9e0LYFAAAAAHE5gOhAGxYAQLoUDONcs2aNXXzxxZ78VlL8o48+suLFi9s999xjl156qb3//vueUJdzzjnHb6dEOolyAAAAgLgcQHQhWQ4ASJfUb1yJcg3t3LVrlz333HN29dVXW6tWrUIJ83vvvddKly5tq1at8pYrsW8LAAAAgLgcQHShZzkAIN3SoM7Zs2fbu+++Gzr24IMP2tixY23cuHHekmXz5s2WP39+ryhXwjyoSAcAAABAXA4gulA6BwBIt3LmzOlV48HgTnnmmWcsW7Zs1qJFC0+kFyhQgEQ5AAAAQFwOAAz4BACkr4GesavDy5Qp44nxmTNnehV5rly5PIF+++23W9asWa1atWqh21NRDgAAABCXA4humSL9AAAASCoN5FSifMWKFTZ+/HhPmD/wwANWp04du+aaa2zAgAG2ZMkSq1Klik2aNMn+/vtvmzp1qifIgyQ7AAAAAOJyANGNnuUAgDSfKNdAzrVr11q5cuXstttus2nTplmJEiXsiSeesMsvv9xGjx5t33zzjf3xxx/en3zChAmWOXNmepQDAAAAxOUAEEKyHACQ5v35558+xFMtVzp06GBHjx71Visa3tm7d2+rW7euX2/fvn2WI0cOryjXdTJlYoMVAAAAQFwOAP/DgE8AQJq2f/9+69Onjz322GPej1yUBH/rrbd8eKcGen744Yd25MgRv1yJcrVpIVEOAAAAEJcDQGwkywEAaY6S3QEN6rz55putcuXKNmrUKDt06JAfV5uVcePG+dfTp0/37wMM8wQAAACIywEgPtqwAADSlGAg5969e+3w4cOWJ08erxKfN2+e9erVy6vHlSTPnTt36PpKjquvOQAAAADicgA4EZLlAIA0N8xz6dKl1rVrV9u+fbsVKVLEatasaT169PCEuVqyZMmSxcaOHWt58+Y97rYAAAAAiMsBICFkDQAAaYaS3evWrbNGjRpZ06ZNbfDgwT68c+LEifbQQw/ZpZde6r3Lt2zZYk8//fRxtwUAAABAXA4AJ5LphJcAABBBJ6oEX7x4sfcn79ixo39ftWpVO/fccz1xrorzGjVq2EsvvWQVK1aMwKMGAAAA0hficgDRhDI7AECqoz7jSpTv27fPBg0a5C1Vfv/9d79s8+bNtmrVqtB1s2fPbtWrV7e//vrLVq5c6be75JJL/LMCewAAAADE5QBwMkiWAwBSFSW4NcBz9+7dXiX+yy+/2M6dOy1//vx++U033WQHDx60Rx55JHSbQoUKWenSpS1z5sxxfhatVwAAAADicgA4WQz4BACkOvv37/dq8dq1a3tLlcDRo0ctU6ZM9t5771nfvn2tbNmy1rx5c/vwww9t+fLltnDhQk+0AwAAACAuB4BTRWU5ACDVmTRpkpUqVSqUKA/aqShRLhru+eabb9qePXvsk08+sWzZstn8+fM9Ua4WLgAAAACIywHgVDHgEwCQ6ixatCjUQiUmJua4dipHjhyxkiVL2tSpU+McDyrPAQAAABCXA8CporIcAJDqFChQwBPfhw4dsgwZMoSOB1Xjr7zyin366adxbqOkOolyAAAAgLgcABKLZDkAINUpWrSoff/99/bDDz/ESYYH/chVea6hn7HFTqoDAAAAIC4HgFPFgE8AQKp0++2321dffWXvvvuu1ahRw7JmzerHW7Vq5cM8Z8+eTSU5AAAAQFwOAMmGZDkAIFXRMM+gR/kdd9xhn3/+uVWrVs2yZMnivco3bdpkc+bMscyZM3tblqDaHAAAAABxOQAkBclyAECqpsryDRs22Pbt261ChQrWokULT5AzzBMAAAAgLgeA5ESyHACQKqrIg77kQe/x+JfFRkU5AAAAQFwOAMmNAZ8AgIgJkuHjxo2z/fv3xxnSeaJEudB6BQAAACAuB4DkRrIcABBWqhiPbeLEiTZv3jzLkSMH/xIAAABAmBCXA8DxaMMCAAiboH3K2rVrbdu2bVa1atU47VZi9yGP3ZIFAAAAAHE5AKQ0KssBAGGhpLgS5T/++KPVrVvXpkyZYrt27UowUX7w4EES5QAAAABxOQCEFZXlAICwWb16tdWsWdOeeOIJu++++/zYgQMHLHv27KHrDBgwwL9/8MEH+ZcBAAAAiMsBIGz+V8IHAEAYzJ0716699lpPlB85csTat29vmzdvtlKlStnAgQMtW7Zsli9fPmvTpg3/HgAAAABxOQCEFW1YAAApRn3HYzt8+LDNnj3bunbt6v3K9+/fby1btrQRI0bYtGnTvCVLu3btvF1L/IFDAAAAAIjLASAlUVkOAEjRYZ7qS75nzx4rUqSIV4xruGfOnDm9uvyee+7x606cOPG4HuVBL3MAAAAAxOUAEA70LAcApEhFuZLfS5YssVatWnlf8sqVK9vTTz9tJUuW9OuoclwJcVWW//TTT7Zo0SJPrgMAAAAgLgeASKBsDwCQrJQEV6J8+/btPqRTyfA33njDK8ofeugh+/777/168+fPt+uuu87WrFljCxYs8ES5qtEBAAAAEJcDQCRQWQ4ASDJVkBctWtSHc8qff/5p3bp1s+LFi/vgTtEgz9tuu83OPPNMe+SRR7zSfMqUKXb99dd7ovzo0aOWKRPdwQAAAADicgCIDCrLAQBJareiivHbb7/dW60EfvzxR2+rMnny5NCxAgUK2Pjx472HuQZ8rlq1ypo0aRKqKCdRDgAAABCXA0AkkSwHACSa2q2UKFHCZs6c6QM8t23b5sM869evby+++KJlzZrVh3oGChYs6C1ZKlasaKVKlQodp1c5AAAAQFwOAJFGGxYAQJIHeaqFiirLa9WqZQ0bNrSePXtarly57JNPPrHnn3/eSpcubaNHjz7u9sGQTwAAAADE5QAQaWQoAACJpkS5qIVK7ty5rXv37vbee+/ZkCFDbO/evdaoUSM/tnr1amvWrNnxf4RIlAMAAABJRlwOAMmDSWoAgERRn/HYgzlVZX7HHXf41xrgKQ8++KAnzA8ePGjTp0+nkhwAAABIZsTlAJB8aMMCAEh0QL5ixQobNGiQV7Kcf/751rFjR+9T/vbbb3srlnbt2vmxPHnyhKrIab0CAAAAJA/icgBIXrRhAQCcMiXKly1b5j3Ks2XL5onwr7/+2tq3b2+HDh2yW2+91QYMGGBPPvmkTZkyJU67FVqvAAAAAMmDuBwAkheV5QCAU7Zjxw674YYbrEGDBvboo4/a/v37rVKlSt5u5dJLL7Vx48Z5hfm0adOsbt26HsQDAAAASF7E5QCQvEiWAwBO2caNG+3TTz+1tm3b2pEjR6xGjRrehqVJkyZ+rFq1avbJJ59YlixZ4mwPBQAAAJB8iMsBIHkx4BMA8J/iJ7sLFSpk9evX96+7detmRYsWtfHjx9vatWutTp06VrZsWR/0GSBRDgAAACQdcTkApCyS5QCAf6WBnEp2r1q1ymbMmOFft2nTxhPkcuDAAbvqqqv86/79+1uxYsW8X7mGfjLMEwAAAEgexOUAkPJIlgMA/pUGcq5cudIqV67s/cdnzpxpEydOtLfeesvy5ctnmTNntscee8zee+8927p1qy1dutQT5TExMQzzBAAAAJIJcTkApDx6lgMA/nOL58iRI314Z5cuXWz79u1WvXp1K1y4sH322WeWI0cOT5QrQd60aVNvv0KPcgAAACB5EJcDQPiQLAcAHCdon7J69WpbtmyZzZ4926pWrWo33XSTX75//36rWLGinXPOOTZ58mQ744wzQrclUQ4AAAAkD+JyAAgvkuUAgDjUPkVV4suXL7caNWpYyZIlbcOGDXbBBRfY9OnTQ4M71au8QIEC1qpVKxs2bBjPIgAAAJCMiMsBIPxIlgMAjgvId+7cab169fJq8tatW3u7laFDh3rLlXHjxvlnOXTokCfPg3YtAAAAAJKOuBwAIiNjhO4XAJAKKVGunuSqFp8xY4YVLFjQj9erV8+6devmfcvvuOMO27dvnx/PmjWrJ8rVegUAAAAAcTkApGUkywEAcZx55pl22WWXeWL822+/tc2bN1uWLFmsbt26njBXS5Z+/frFuQ2V5QAAAEDyIi4HgPCjDQsARLlgIOfhw4d9gFC2bNn8+EsvveQtVzTU89Zbb/Uq86NHj9qSJUvskksu8QGgAAAAAIjLASC9+N+UNgBAVFJyXInyn376yXr27Gn79+/3fuQPP/ywdezY0a8zYcIEb8/SokULO+ecc6xKlSqh25IwBwAAAIjLASC9oCwQAKJ4aJCS3WvWrLErr7zSLr30UuvevbsP7Ozbt69NnDjRE+ZNmza1kSNH2qxZs+LcnkQ5AAAAQFwOAOkJbVgAIIosXLjQMmfObBUqVAgde+WVV2zx4sWeEA906tTJli5d6j3L5e233/Z2LPQmBwAAAIjLASC9orIcAKKkinznzp1211132aBBg+znn38OXbZlyxb7/vvv7dChQ6FjAwYMsF9++cU+/fRT/149y5UoV39zAAAAAMTlAJAekSwHgCignuOnn366vf7667ZixQobNmyYV5NLvXr1vBf5Bx98EEqG58qVyypWrOhDPWOjshwAAAAgLgeA9Io2LAAQJQ4fPmxZsmTx1irdunWzSy65xAd5Fi9e3B588EFbv369lS1b1po1a2ajRo3yyvI5c+aQIAcAAACIywEgKpAsB4AoacOi6vJFixbZSy+9ZH/88Yd99dVX1qJFC2/LctZZZ9nLL79sn3zyiVeX58uXz8aPH+/9zfU9FeUAAAAAcTkApHckywEgSmzevNkqV65sDz30kLVs2dKWL19u9957r1eYP/PMM1a0aFG/3u7duy1Pnjz+9dGjRy1TpkwRfuQAAABA+kFcDgCpFxkQAIgSarNSqFAhb7kitWvXtrffftvq1KljGTNmtAceeMCT6UGiXNXoJMoBAAAA4nIAiBYM+ASAKJE/f37bsWOHTZ482b8/duyYVahQwa6//np79913bdasWXGur7YtAAAAAIjLASBakCwHgHRk//79J7xMfchVRf7ZZ5/Z999/79XkwfHBgwdbp06dwvhIAQAAgPSLuBwA0iZ6lgNAOvH555/bxIkT7dFHH7WSJUsmeB0N+OzTp48dPnzYcubM6dXlK1eutGXLlvkQT4Z5AgAAAMTlABCt6FkOAOmEKsS/+OILy549u3Xv3t3OPffcOJerB7mGeaqK/Mcff7SZM2d6a5b333/fE+VKnOszAAAAAOJyAIhGVJYDQBr3zTffWJEiRaxMmTK2cOFCu/XWW+3KK6+0Rx555LiE+YkcPXqUYZ4AAAAAcTkARDV6lgNAGqaBnSNGjPAE+erVq61y5co2YcIET6APGDDA1q1bl+DtVGUeW6ZMbDQCAAAAiMsBILqRLAeANOyMM86whx56yMqVK2d33XWXrVq1yqpUqfKfCfMMGTJE5PECAAAA6RFxOQCkDyTLASCNCqrDq1WrZg888IAVL17cWrdufVzCfODAgSesMAcAAABAXA4A+B96lgNAGvLPP/+ccAjn/PnzfXjn+vXrbcyYMVa6dGlbsGCB3XnnnXbxxRfboEGDrFChQmF/zAAAAEB6Q1wOAOkTleUAkIYoUb5v3z579NFHbe7cubZ3797QZVWrVvUK82LFinmFuXqYq8L8tdde8yr0AgUKRPSxAwAAAOkFcTkApE9UlgNAGvPUU09Znz59rGbNmp4sf/rpp+3CCy+0EiVK+OULFy605557zjZu3GijRo3yywLHjh2zjBk5TwoAAAAQlwMA4iNjAgBpzNVXX+0J7yuuuMIaNmzogz3VaqV///62fft2q1y5svXr189y5MhhQ4cODSXJhUQ5AAAAQFwOAEgYleUAkAbdc889tmXLFvvggw9s5syZPtSzffv2Vr16de9P3qFDB79euXLlSJADAAAAxOUAgJNAZTkApEFKii9evNjWrFljl19+ue3YscPOOecc/3rWrFnWu3dvK1++vCfKg6pyAAAAAMTlAIATo7IcANIoDfTUAM+yZcva888/bx9++KFVrFjRL6M3OQAAAEBcDgA4NZlO8foAgAiLiYmxDBkyWMeOHf2jUKFC9s4773ii/J9//rHTTjstVFFOj3IAAACAuBwAcHJowwIAaYwS5VK/fn0744wz7Nprr7UaNWp4El2J8gCJcgAAAIC4HABw8kiWA0AapYryHj162GeffWa//fZbKIkOAAAAIHyIywEg/aANCwCkYQ0aNLBFixbZueeeG+mHAgAAAEQt4nIASB8Y8AkA6aSHOT3KAQAAgMghLgeAtI9kOQAAAAAAAAAg6tGzHAAAAAAAAAAQ9UiWAwAAAAAAAACiHslyAAAAAAAAAEDUI1kOAAAAAAAAAIh6JMsBAAAAAAAAAFGPZDkAAAAAAAAAIOqRLAcAAAAAAAAARD2S5QAAAAAAAACAqEeyHAAAAAAAAAAQ9UiWAwAAAAAAAACiHslyAAAAAAAAAEDUI1kOAAAAAAAAAIh6JMsBAAAAAAAAAFGPZDkAAAAAAAAAIOqRLAcAAAAAAAAARD2S5QCAdGvdunWWIUMGe+ONNyza3XXXXXbuuedG+mEAAABEjaTEX0888YTHsamZfjf9jgCQnpAsB5Bi1qxZY/fcc4+VLFnSsmXLZnny5LGaNWvakCFD7MCBAzzz6YyCeX20bds2wcsfffTR0HW2bdt2yj//s88+8zcNkbZs2TK78cYbrXjx4r6uzznnHLv66qtt2LBhlpbs37/fn88ZM2ZE+qEAAACEVRCT/tdHtMVJ+n1P9rkBgPQqQ0xMTEykHwSA9OfTTz+1Fi1aWNasWe3OO++0iy66yA4fPmyzZs2ySZMmeQXCK6+8EumHiWSkoFnJY31s3rzZsmTJEudynTTZuHGjHTx40LZu3WpnnXXWKf38Tp062UsvvWSn8mdL1z106JBlzpzZTjvtNEuq2bNnW926da1YsWLWqlUrK1iwoG3YsMHmzp3rJ4dWr15tqdWRI0fs2LFj/n9SdMLi7LPPtj59+qSKkxAAAADhMm7cuDjfjx071r766it766234hxXQUSBAgWSLf46FUePHvUPxdbhohhez0NsPXv2tFy5cnnhS2y33367x9kZM2b0WBsA0otMkX4AANKftWvX2i233OKVt998840VKlQodFnHjh09oahkerTat2+f5cyZ87jjCqR1QiGcAXFya9CggX300Uf2+eefW+PGjeMkmbUumjdv7idLUpreWOj5VMI+OZ/Pp59+2vLmzWvz58+3008/Pc5lW7ZssdSylhLCmxgAAID/S/TGpsIHJYnjH09oZ16OHDlO+mlMSvyVKVMm/wgnnRiI/xwMGDDAi1wSem4ScxIAAFI72rAASHbPPvus7d2710aPHh0nUR4477zz7MEHH4yT2HzqqaesVKlSHnCp912vXr28UuFkLV682K699lpv9aLKh6uuusqD3vh27txpXbp08fvQfRUpUsQr32O3BVHlsypty5Qp44lW/Q7NmjXzyuHY2xPjb8tMqD+2Kuj1eHTbhg0bWu7cua1ly5Z+ma6raunx48dbuXLl/PFMnTrVL/vzzz+tTZs2HrDquC5//fXX49xf8Djee+89T+Lqd9Hj1e+eUIXzDz/84I/hjDPO8ARrhQoVvCVObCtWrPAWI2eeeab/rCpVqnjy+2SpJUmdOnVswoQJcY7rdyxfvrzvMIjvu+++810IqtbW71q0aFH/N4rdqkfPo6rKg+ct9vbP4Hl//vnnbfDgwaF19Msvvxz3b6KEtqqpr7jiijgV6nq+9JzcfPPN//r76d9R/xbxE+WSP3/+ON/H/vc9//zz/fmsXLmyffvtt3Gut379euvQoYNfJ3v27JYvXz5/PvTYY9PvoJ85c+ZMv77uT//msmfPHuvcuXNoXesyVUItWrQowZ6Z+tl6HqRv376h51PrfsyYMf61/k/F98wzz3iFvtYnAABAeqZ4UbHrwoULPb5VklzvUeTDDz+0Ro0aWeHChT32Uvyp9zP//PPPv/Ysjx23apdtELdWrVrVizH+q2d5EF9OmTLFH1vwPiF4DxH/vYJiecWgup+XX3452fugx+9ZHsSr2k38wAMPeLypuFmtOVUUpPdieu+l9yP6ePjhh4/bNaqCF8X0+r302PV+SLffsWNHsj1uAPg3VJYDSHYff/yxt9y47LLLTur66nH95ptvepK2W7duntTt37+/LV++3D744IP/vP3PP/9stWvX9kS5Ai5VcCgYVICrxGK1atX8ekrg63r6uUpEX3LJJZ4kVzL4jz/+8IoJBbjXXXedff31114dr6S+EpGqNPnpp5880DxVOhlQv359q1WrlgfGsatRVHmvZLeCXt2/Ak5tf6xevXooGFaQqUrtu+++23bv3u1J0fjVHtr+2L17d9u1a5efrFBCXs9jQI9fv5cS//qd1D5Ez8Mnn3wSOnGh51E95ZXwfuSRRzx5rMfWpEkTrwZv2rTpSf2+t912m/9MPd86UaDf//3337euXbv6iYj4dJmqdO677z5PFM+bN8/7f+vfRJeJAuS//vorwe2xASV59fPbt2/vbxyU8FewHZuSyCNHjvRktO5DQbyuoyBfJzJGjBjxr7+bdkvMmTPH10JCif/4tP7effddvx89Jv18Vd/rdwxurzdGqrzXelPyW2+i9Bi1fpXwj1+9pES51kTv3r29slzuvfdemzhxoq+XsmXL2t9//+1vUvRvrHUen26v+9Bzrn9XnQwSnUApUaKE7wBRkr9SpUpxbqdjelxaIwAAAOmdYioV5ChOU2V10JJFSWHFuYpv9VkxvWIzxerPPffcf/5cFZboPYZiXMX8it8Vj/3222//WY2uGG/y5MkeEyp+HTp0qO/e/P333z2WFhU9KOZU7K/CCL3HefLJJ0PFEint/vvv9/cbum8VMOnEgJLminlVIKMCDM0j0nOlmFgJ9ICeEz2/rVu39hhau1OHDx/uv9P333/PbkkAKU89ywEguezatUulATGNGzc+qesvWbLEr9+2bds4x7t37+7Hv/nmm//8GU2aNInJkiVLzJo1a0LH/vrrr5jcuXPH1KlTJ3Ssd+/e/jMnT5583M84duyYf3799df9OoMGDTrhdaZPn+7X0efY1q5d68fHjBkTOtaqVSs/9sgjjxz383Q8Y8aMMT///HOc43fffXdMoUKFYrZt2xbn+C233BKTN2/emP3798d5HBdeeGHMoUOHQtcbMmSIH1+2bJl/f/To0ZgSJUrEFC9ePGbHjh0J/k5y1VVXxZQvXz7m4MGDcS6/7LLLYkqXLn3c40/o9+nYsWPM9u3b/d/jrbfe8uOffvppTIYMGWLWrVsX06dPH7/e1q1bQ7cLfp/Y+vfv77dZv3596Jh+dkJ/toLnPU+ePDFbtmz5z38TufXWW2Ny5MgRs3LlypjnnnvOrzNlypT//B2//PLLmNNOO80/atSoEfPwww/HfPHFFzGHDx9O8PnQx4IFC0LH9Ptky5YtpmnTpv/6+8+ZM8dvO3bs2NAx/Q46VqtWLf83jU3rQs/Pv9Fa1BoI6N9AP0//JvHp+SlcuHDMP//8Ezq2aNGiBJ9LAACAtC6hOPPyyy/3Y6NGjTru+gnFb/fcc4/Hl7Fj6fjxVxCb5suXz2PmwIcffujHP/7449CxIG6OTd8rzl69enXo2I8//ujHhw0bFjp2/fXX+2P5888/Q8dWrVoVkylTpgTj6X9Trlw5fy4Sot9Nv2P8eLV+/fpx3mcoblZsf++994aOKZ4tUqRInJ/93Xff+e3Hjx8f536mTp2a4HEASAm0YQGQrFRNIapyOBmqKBBVZcSmCnP5r97mqpL48ssvvfpZ1ewBVVGowlmVF8FjUnX0xRdfnGCFdLAdUddRhbeqIU50ncRQBW9CLr/8cq8EDigG1mO4/vrr/WtVvgcfqk5X5Xjs1hqiqovYwzRVPS+qTBFVYagiQxXp8duHBL/T9u3bvSLmpptu8iqX4D5VTaP7XbVq1Um33tCWSlWyvP3226HKGe0yUFV2QtR6JKBKad2vrq/fP6FWICeiipqTrZZRdYp6j2s3w+OPP2533HFHnB7rJ6LWJqosv+GGG+zHH3/0KiA9P6q0TqhdTY0aNbz1SkCVNLqfL774IrRNN/bvryFQes7Vqkj/VvH/raVdu3bHDSvVdbWTQNX3yUHVPfpZ06dPj1NVrseq5xkAACAaaGegYu34YsdvQeysGFy7JdXW8L+o9Z9i5hPF7/+mXr16cXa7amegdtgGt1WMOW3aNH9/pDYxAcWXqpIPB+2Ijf3eSTt9FdvreEDxrNrExP6dtatUMbpi7tjvgxRPq4I/dmwKACmFZDmAZKVALQgaT4b6NauFiIK32LRtTwlAXS7qX71p06Y4H7J161YPStXvOb4LL7zQW2xs2LAh1G/6v1pn6Dr6Wck5TEc/K+gtHZ9aXsSm30e9/LRVUYnf2B9BoB5/kKQSsLEFgXfQ1y/otf5vv7t6diuAVeI4/v326dMnwfv9NzpRoZYp2g6qnor6/kR0HbVBUdsUBcG6T51EEJ0cOFnxn8t/o/vSltWlS5d6QK6vT5Z6Smrrq55ftVPp2bOnr3cl3tU2JbbSpUsfd3v1wtea1b91sLa1bVe92vWGTCdr9BxoHST0+yf0eyppr9Yw+hmXXnqp96M8mTdbJ6I3KDrhpAS56P+RTn4o0X+yJ8IAAADSOhVExC5KCah9oQpwFEfq/Y9it2AA5snEr/8Vv5/KbYPbB7dVzK74Mv77K0noWEqI/xj1PIli1fjHY//OKtDR86fWifHfk6jF46m8HwGAxKJnOYBkpWBRFQxK3J2K/6raVt/n+FUd8YfBhMuJHmv8gT4BJUB1QiAhsatSJOixrWC7VatWCd5G1SOxxa8yTszzE9yv+p6rUjohpxJcq/Jav7d+Bw1qVcX6iZ4zJWZV2d6jRw+74IILvFe6qtiVQI/fc/zfxH8u/4uqu0UBuvqjJzS089/ojZMS5/pQAlzrU9UwwcmFk6VdDOq3rsp/VaLrTYPWmHpjJvT7J/R76vlVRZJ6/Gunhfo/Dhw40JP6iakg0prSCY5XX33V+6yrP6QqzYM3gQAAANEgobhLBQ0q7ND7HvUBV5W3BlFqR6Di2ZOJX5MSvydH7J/STvQYEzoe+3HruVOiPCjYiC9cPdcBRDeS5QCSnQZJqjJa7SqU/Ps3as2hoEhVBKoED2jIpQLRoHWHEriqVE4oYNIAxF9//fW4y7QFUknqoIJBgex/JfF1HbWzUDuMEw3XCSo/9PhiC6rgk0K/jyp3lUTWFsvkEGzT1O9+op8ZtLDR75wc96s3Ftr6OW7cOE/Wqlo6IcuWLbOVK1f6gNfYg30S+rdOShuc+KZOnWqvvfaaD4RVMK6kvv7dE7ujQFtIZePGjXGOa13Hp99XazYI9jWYU/f/wgsvhK6jQaXx19d/USW4Bj3pQ1U3Guz59NNPnzBZ/l/Pp/499Jg0sFcDZvV4T3QiBQAAIFrMmDHD2+apKKFOnTqh42p7mBoo2azkvXaOxpfQsdRE71vUQqZmzZqnXAgDAMmFNiwAkp0SkKoObtu2rSe941NbkCFDhvjXDRs29M+DBw+Oc51Bgwb550aNGoUSgUrixv4IqhOuueYa+/DDD23dunWh2+t+1Su7Vq1aodYw6rWsPtOqvj1RRYOuo7546ml9ousoga/7/fbbb+NcrgrcpNLP1WNQ3/KEEvtB645ToaSpWnfoOY6fgA1+JwXVV1xxhb388svHJXwTe7+qUleVtVq7nEhQXRK7okRfB+sjNq0pOdUkcny6vdam2pU888wznjRXJZC+/i/qk5hQ1U7Qez9+OyCdMIrdd1wtgbRWtWaD312f4//MYcOGnXCnQny6Xvztvvr31A4PVfWfiBL2//Z8ageDPvT8aD2q0j052xMBAACkRQnFr4cPH06W9wLJ9fj0XkmtEGPPs1GiXAUQqZl2Syq2feqpp4677OjRo0l+HwAAJ4N3vQBSpCJAiWoNrlG1uCpU1S9bQeTs2bO9VYVabIgGbqqqVpXowZZG9YFWpbEqk+vWrfuf99evXz+vRFZiXFW1Sugp6atEoXo5Bx566CGv4m3RooW1adPGB8Wo/YcGM44aNcofix7r2LFjfeCoHodaW2jopCoc9LPVs1ltMvQzlNBUda5+308++STZeugNGDDAk7IahKNhjhoAqseppKseh74+FaquHzlypA8NrVixorcL0ckHVd6r32LQjuSll17y57B8+fJ+v6o210kHJXzVpkQnGk6Fnk99/Bu1XdHzp8S6Wq/oxIYSswn1awwGZT7wwANe4aw3AkrgnqoHH3zQq4H0XOpnaBipkudaR/r3/bfHrJYp6jeuHpV67MGaVpugc88997hWQVr3eqx6zGpLE7yJ6tu3b5ydGG+99ZavK/1b6/nWY8uXL99J/T7ql66e+OqZrseuvu+6/fz58+NUq8enah3dnx672sioj7seb+ze9vr/oH8boQULAACA+SB67TTVexjFeHo/oFguNbVB0fwateZThfZ9993nCWgVAynOW7JkiaVWei94zz33WP/+/f1xqsBEO1+1W1PvIVVQo5gXAFISyXIAKUI9qzU8Ub2TVUmrZK2ShapUVQJPydiAKleVmH3jjTe86lvDPTU08WR7P5crV86+++47v40CK7V1UaJZLUD0OaAkoq6nn6v7UUJeFbhXXXVVaACnkqeqElb7CiX8lbhV0jJIIgeUKFerFiXZ9XupCkK/638NED0ZBQoU8ES9eiBqe6cSrHoM+j3VhzoxlLBVAl5JWj3/eo6UpI7976DE6YIFC/w6+rdQQlnPT6VKlXwAZUpQ8Ks2H3qjoX87bRlVIrpTp07HJa2bNWvmyep33nnH/231huRUk+U6MaKTIXoOlOyOvZNBJ1z0pkdJ5hO14Hn++ec9UNca0QkeJcs1wEgnUh577LHj+p4r4FcrIj2nGmSq51jPbey+8wr6te7UDkbtV/SmRsnuk215ogpx3b/eEGm96N9W/eW1bvTm6N/o/56e0y5duvjvov8bsddwy5Ytvfem1ooq8QEAAKKd4nIVynTr1s3jPyXOVVSg9xSppWWdikxURa6iB+3yVFtKvbdYvny5F8ykZnp/pcev4qdevXp5IZSKUvQcK04GgJSWISY1nf4EACCdUJVRx44dE2zpk1aoJZF2Iehkyb+10wEAAEDqp5272lma0FwdAMD/0LMcAAAkSFXw2rZ7xx138AwBAACkIQcOHIjzvRLk2h2pOUUAgBOjDQsAAIjjm2++sV9++cXbEakCSVtfAQAAkHaozaXmROnz+vXrvS1mlixZ7OGHH470QwOAVI1kOQAAiEM9LTW4VH0h1Z8fAAAAaYuG2L/99tu2adMmn7GkOTrPPPOMlS5dOtIPDQBStVTfs/zbb7/1oXkLFy60jRs3+lA+VbkF9PA1kOzVV1+1nTt3+ht7nTGN/Qdg+/btPsBMQ+QyZsxozZs394FqGvYHAAAAAAAAAECq71m+b98+u/jii+2ll15K8PJnn33Whg4d6hOTf/jhB8uZM6dPoD548GDoOi1btvQhFl999ZVPrVYCvn379mH8LQAAAAAAAAAAqVmqryyPLUOGDHEqy/XQCxcubN26dbPu3bv7sV27dlmBAgV8KNktt9xiy5cvt7Jly9r8+fOtSpUqfp2pU6daw4YN7Y8//vDbAwAAAAAAAACiW5ruWb527Vrvv1WvXr3Qsbx581q1atVszpw5nizX59NPPz2UKBddX+1YVInetGnT437uoUOH/CNw7Ngxb+WSL18+T9gDAAAA/0WFHXv27PHiDMWeSB6Kzf/66y/LnTs3sTkAAACSNTZP08lyJcpFleSx6fvgMn3Onz9/nMszZcpkZ555Zug68fXv39/69u2bYo8bAAAA0WPDhg1WpEiRSD+MdEOJ8qJFi0b6YQAAACAdxuZpOlmeUnr27Gldu3YNfa/WLsWKFbP169dbnjx5IvrYAAAAkDbs3r3bihcv7hXQSD7B86k3OsTmAAAAONnYXAUX/xWbp+lkecGCBf3z5s2brVChQqHj+r5ixYqh62zZsiXO7Y4ePeptVYLbx5c1a1b/iE/tXAjIAQAAcDKC7Z208UtewfOpuJzYHAAAAKfiv2LzNN08sUSJEp7w/vrrr+OcJVAv8ho1avj3+rxz505buHBh6DrffPON9zpUb3MAAAAAAAAAAFJ9ZfnevXtt9erVcYZ6LlmyxHuOqzVK586drV+/fla6dGlPnj/++OPeqL1JkyZ+/QsvvNAaNGhg7dq1s1GjRtmRI0esU6dOPvxT1wMAAAAAAAAAINUnyxcsWGB169YNfR/0Em/VqpW98cYb9vDDD9u+ffusffv2XkFeq1Ytmzp1qmXLli10m/Hjx3uC/KqrrvLtsM2bN7ehQ4dG5PcBAAAAAAAAAKQ+GWJiYmIi/SBSO7V2yZs3rw/6pC8iAAAAiCEjh9gcAAAAKRVDpume5QAAAAAAAAAAREUbFgAAAAAAAITBCxl4mqNRN5pOAAEqywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHokywEAAAAAAAAAUY9kOQAAAAAAAAAg6pEsBwAAAAAAAABEPZLlAAAAAAAAAICoR7IcAAAAAAAAABD1SJYDAAAAAAAAAKIeyXIAAAAAAAAAQNQjWQ4AAAAAAAAAiHqZov4ZSOWGd1kd6YeACOj04nk87wAAAAAAAEAYpfnK8n/++ccef/xxK1GihGXPnt1KlSplTz31lMXExISuo6979+5thQoV8uvUq1fPVq1aFdHHDQAAACTV2rVrbezYsR7/9uzZ0wYNGmTTp0+3gwcP8uQCAAAA0VZZPnDgQBs5cqS9+eabVq5cOVuwYIG1bt3a8ubNaw888IBf59lnn7WhQ4f6dZRUV3K9fv369ssvv1i2bNki/SsAAAAAp2T8+PE2ZMgQj30LFChghQsX9qKQ7du325o1azzGbdmypfXo0cOKFy/OswsAAABEQ7J89uzZ1rhxY2vUqJF/f+6559rbb79t8+bNC1WVDx482B577DG/nqj6Rm8qpkyZYrfccktEHz8AAABwKipVqmRZsmSxu+66yyZNmmRFixaNc/mhQ4dszpw59s4771iVKlVsxIgR1qJFC55kAAAAIL23Ybnsssvs66+/tpUrV/r3P/74o82aNcuuvfba0NbUTZs2eeuVgKrOq1Wr5m8iAAAAgLRkwIAB9sMPP1iHDh2OS5RL1qxZ7YorrrBRo0bZihUrrGTJkhF5nAAAAEBak+Yryx955BHbvXu3XXDBBXbaaad5D/Onn37at52KEuWiSvLY9H1wWXyqxtFHQD9fjh075h9hleH/eq8jeoR9nQEAgDTz91ztBE9Wvnz5/AMAAABAFCTL33vvPe/ZOGHCBO9ZvmTJEuvcubP3bWzVqlWifmb//v2tb9++xx3funVr2IclZTtzb1jvD6nDli1bIv0QAABAEu3ZsyfFn8NFixZZ5syZrXz58v79hx9+aGPGjLGyZcvaE0884e1aTjb+nTx5sleiq/e5dm9qNtD5558fuo7i4G7dunl7FxWWKGmvFi+xi1J+//13u++++3zIaK5cuTwe18/OlOn/3nbMmDHDunbtaj///LNXxqtdolrKAAAAAJGW5pPlDz30kFeXB73H9UZh/fr1HpQrOC9YsKAf37x5sxUqVCh0O31fsWLFBH9mz549PYCPXVmuQP7ss8+2PHnyWDgd3J7yb7KQ+uTPnz9i9z2i+5qI3Tcip8PzpXj6ASCZhWOQ/D333OOxsGLg3377zWPipk2b2vvvv2/79+/32T0nY+bMmdaxY0erWrWqHT161Hr16mXXXHON/fLLL5YzZ06/TpcuXezTTz/1n622hp06dbJmzZrZ999/75drh6fmCCn+1lyhjRs32p133unJ/GeeeSbUIlHXuffee73gRe0U27Zt63H6qVTMAwAAACkhzSfL9SYgY8a4rdfVjiXY9lqiRAkP2BWIB8lxJb/V51FVLwlRn0d9xKf7iX9fKS4mQ3jvD6lC2NdZbKy5qBTRNQcA6VQ4Xls1tyeIcZXErlOnju+4VAJbifOTTZZPnTo1zvdvvPGGn7xfuHCh/8xdu3bZ6NGj/WdfeeWVfh1VsF944YU2d+5cq169un355ZeeXJ82bZpXm+txPfXUU9ajR49Qlbv6qCs+f+GFF/xn6PaaN/Tiiy+SLAcAAEDEpflk+fXXX+89yosVK+ZtWBYvXmyDBg2yNm3a+OUZMmTwtiz9+vWz0qVLe3D++OOPe5uWJk2aRPrhAwAAAIkWExMTKhJRkvq6667zr7Urctu2bYn+uUqOy5lnnumflTQ/cuSI1atXL3QdzQxSDD5nzhxPluuzKtxjt2VRtbgKVNRypVKlSn6d2D8juI7i9RNJVfOEACDdo4gmKvH3FFHg2Emu8zSfLB82bJgnvzt06OB9npUE13bU3r17h67z8MMP2759+6x9+/a2c+dOq1WrllfPhGNrLAAAAJBSqlSp4kUhSkCrlcrIkSND7U7iD7g/lTcSSl7XrFnTLrroIj+2adMmrww//fTT41xX96HLguvEv8/g+/+6jhLgBw4c8H7pqXmeEACkezkqR/oRIBKYm4YosOck5wkle7J8+fLlPvTnu+++897hapOiXt+qJFHVSPPmzRNscZJYuXPn9u2l/7bFVNXlTz75pH8AAAAA6YVi4JYtW9qUKVPs0UcftfPOO8+PT5w40Yd0JoZ6l//000/eHiU1SPLHLTkAAJnTSURBVE3zhAAg3du/MNKPAJEQwblpQLicbNF0siXLFy1a5BXcCqpVhVKtWjUfLqTqkO3bt3vArQD+/vvv9+upWiU5k+YAAABAtKlQoYItW7bsuOPPPfecz/E5VRra+cknn9i3335rRYoUCR3XDKDDhw/7Ls3Y1eWbN2/2y4LrzJs3L87P0+XBZcHn4Fjs6yjpnVBVeaqbJwQA6R7traISf08RBTKe5DpPtmS5KsYfeughr2KJvz0zNvUpHDJkiA/16dWrV3LdPQAAAID/71TbDar3uYpaPvjgA5sxY4bP+YmtcuXKljlzZvv666897pdff/3Vfv/9d6tRo4Z/r8+aJaTWiBoOKl999ZUnwsuWLRu6zmeffRbnZ+s6wc8AAAAAIinZkuUrV670APq/KBDWhwYEAQAAADg1Z5xxhrcZPBna4XmyrVcmTJhgH374obc5DHqM582b1yu+9fnuu+/2diga+qkEuJLrius13FOuueYaT4rfcccd9uyzz/rPeOyxx/xnB5Xh9957rw0fPtx3mrZp08a++eYbe++99+zTTz9lGQAAACD9JMtPJlGelOsDAAAA+F+f8sDff//tAz41GyioztZOzi+++MIef/zxk366gsGgV1xxRZzjY8aMsbvuusu/fvHFF337qirLDx065Pc5YsSI0HXV9kUtXO677z5/LDlz5rRWrVrFmRukinUlxrt06eK7TdXq5bXXXvOfBQAAAERahhjtuUwhGzdu9IqTmTNn2j///OO9zBUUlyxZ0tISDRFSNc2uXbvCPkRoeJfVYb0/pA6dXvzfcK5IYM1Fp0iuOQBIr8IRQypxXbduXe81Hpuqt6dNm+aDP9ObSMbmAJDuvXByO5eQznRLsdQgkOZiyBSdiKOtlRdddJEny7XFskCBAnbbbbel5F0CAAAAUUMV5A0aNDjuuI4pWQ4AAADg5CVrsvzBBx+0ffv2hb5fvXq19ejRw3sXVqxY0S/XICAAAAAASZcvXz7vMx6fjukyAAAAABHoWS7qOVi5cmUf6HPDDTfYzTffbNWqVbOGDRv6QM/Jkydby5Ytk/MuAQAAgKjVt29fa9u2rc2YMcPjbvnhhx9s6tSp9uqrr0b64QEAAADRmyx/6KGH7MYbb7QOHTrYG2+8YcOGDfOgXcG7epYria7LAQAAACSdhm9eeOGFNnToUC9MEX0/a9asUPIcAAAAQASS5cGE+88//9zGjx9vl19+ubdeef755y1DBoZEAAAAAMlNSXHF3gAAAABSWbJc/v77b2+3ovYr3bp1sxo1atgrr7xiFSpUSIm7AwAAAKLWsWPHfFbQli1b/OvY6tSpE7HHBQAAAER1svzrr7+22267zbZu3WqFCxe2999/315//XWbPn263XrrrdaoUSPvq5g9e/bkvFsAAAAgKs2dO9fj7/Xr11tMTEycy7SzU60QAQAAAJycjJaMOnbsaA8//LDt37/fhg8fbp07d/bjdevWtUWLFlnmzJmtYsWKyXmXAAAAQNS69957rUqVKvbTTz/Z9u3bbceOHaEPfQ8AAAAgQpXlGzdu9OrxbNmyWYMGDaxr166hy7JmzWpPP/20V74AAAAASLpVq1bZxIkT7bzzzuPpBAAAAFJTsvyGG26wG2+80T/PmjXLe5bHV65cueS8SwAAACCqh3uqXznJcgAAACCVJctHjx5tL7/8sq1YscJuv/12a9OmTXL+eAAAAACx3H///datWzfbtGmTlS9f3tsexlahQgWeLwAAACASyfIsWbJ4wA4AAAAg5TVv3tw/xy5S0WBPDftkwCcAAAAQoWT53LlzrXr16id1XQ0AXbt2LS1ZAAAAgCRQTA0AAAAglSXL77jjDitZsqS1bdvWe5XnzJnzuOv88ssvNm7cOBszZowNHDiQZDkAAACQBMWLF+f5AwAAAFJbslyJ8JEjR9pjjz1mt912m5UpU8YKFy5s2bJlsx07dngf871791rTpk3tyy+/9J6KAAAAAJJmzZo1NnjwYFu+fLl/X7ZsWXvwwQetVKlSPLUAAABAJJLlGib0wAMP+MeCBQts1qxZtn79ejtw4IBdfPHF1qVLF6tbt66deeaZltz+/PNP69Gjh33++efe4uW8887z6vUqVar45erZ2KdPH3v11Vdt586dVrNmTU/sly5dOtkfCwAASP2Gd1kd6YeAMOv04nnp8jn/4osv7IYbbrCKFSt6jCvff/+97+D8+OOP7eqrr470QwQAAACic8BnQEnqIFGd0lS1rjcGSsQrWX722WfbqlWr7Iwzzghd59lnn7WhQ4fam2++aSVKlLDHH3/c6tev79XwqnwHAEQWicvok14Tl0C4PfLII16UMmDAgOOOq5iEZDkAAAAQ4WR5OKn3edGiRb2SPKCEeEBV5dqWqvYwjRs39mNjx461AgUK2JQpU+yWW26JyOMGAAAAkkqtV957773jjrdp08ZjYAAAAABRlCz/6KOPvEq8RYsWNnPmTDvnnHOsQ4cO1q5dO7987dq1tmnTJqtXr17oNnnz5rVq1arZnDlzEkyWHzp0yD8Cu3fv9s/Hjh3zj7DKEBPe+0OqEPZ1FhtrLipFdM0J6y7qsOYQDWsuHPepXZVLliw5rr2gjuXPnz/F7x8AAABIT9J8svy3337z/uNdu3a1Xr162fz5871vepYsWaxVq1aeKBdVksem74PL4uvfv7/17dv3uONbt261gwcPWjhlO3NvWO8PqcOWLVsidt+suegUyTUnrLvow5pDNKy5PXv2pPh9qECkffv2HhNfdtlloZ7l2n2p+BgAAABAFCXLVbGj/ujPPPOMf1+pUiX76aefbNSoUZ4sT4yePXvGeXOhynK1elHlTp48eSycDm5P+TdZSH0iWQnGmotOka4+ZN1FH9YcomHNhWM2jmbx5M6d21544QWPYaVw4cL2xBNPeAEJAAAAgAgny1XZUrJkSQuHQoUKWdmyZeMcu/DCC23SpEn+dcGCBf3z5s2b/boBfV+xYsUEf2bWrFn9I76MGTP6R1jFZAjv/SFVCPs6i401F5UiuuaEdRd1WHOIhjUXjvvMkCGDD/jUR1DJruQ5AAAAgFOXIhH8eeedZ3Xr1rVx48aleNuSmjVr2q+//hrn2MqVK6148eKhYZ9KmH/99ddxKsV/+OEHq1GjRoo+NgAAACAlaT7PqlWrQknyIFGuY+vWrePJBwAAACKdLF+0aJFVqFDBW5koUX3PPffYvHnzUuQfRlU0c+fO9TYsq1evtgkTJtgrr7xiHTt2DFXbdO7c2fr16+fDQJctW2Z33nmnb09t0qRJijwmAAAAIBzuuusumz179nHHVRiiywAAAABEuA2L2psMGTLEeycqQf3GG29YrVq1rEyZMtamTRu74447vP93cqhatap98MEH3qPxySef9ErywYMHW8uWLUPXefjhh23fvn0+/Gjnzp3+WKZOnRqWPpIAAABASlm8eLHvtIyvevXq1qlTJ554AACQur1A++Go1C3GUqsUbaSYKVMma9asmb3//vs2cOBAr/zu3r27D8tUdffGjRuT5X6uu+46rxhXy5fly5dbu3bt4lyu6nIl0jdt2uTXmTZtmifuAQAAgLRMcW7Qqzy2Xbt22T///BORxwQAAACkVSmaLF+wYIF16NDBB2sOGjTIE+Vr1qyxr776yv766y9r3LhxSt49AAAAkK7VqVPH+vfvHycxrq91TLspAQAAAES4DYsS42PGjPHBmw0bNrSxY8f654wZ/5ebV6sUtWY599xzU+LuAQAAgKig3ZtKmJ9//vlWu3ZtP/bdd9/5QPtvvvkm0g8PAAAASFNSpLJ85MiRdtttt9n69ettypQp3iYlSJQH8ufPb6NHj06JuwcAAACiQtmyZW3p0qV200032ZYtW7wli9odrlixwi666KJIPzwAAAAgTUmRynK1WSlWrNhxCfKYmBjbsGGDX5YlSxZr1apVStw9AAAAEDUKFy5szzzzTKQfBgAAAJDmpUhlealSpWzbtm3HHd++fbu3YAEAAACQPNR25fbbb7fLLrvM/vzzTz/21ltv2axZs3iKAQAAgEgny1VBnpC9e/datmzZUuIuAQAAgKgzadIkq1+/vmXPnt0WLVpkhw4d8uO7du2i2hwAAACIZBuWrl27+ucMGTJY7969LUeOHKHL/vnnH/vhhx+sYsWKyXmXAAAAQNTq16+fjRo1yvuUv/POO6HjNWvW9MsAAAAARChZvnjx4lBl+bJly7wveUBfX3zxxda9e/fkvEsAAAAgav36669Wp06d447nzZvXdu7cGZHHBAAAAKRVyZosnz59un9u3bq1DRkyxPLkyZOcPx4AAABALAULFrTVq1fbueeeG+d5Ub/ykiVL8lwBAAAAke5ZPmbMGBLlAAAAQApr166dPfjgg97uUK0Q//rrLxs/frzv5rzvvvt4/gEAAIBIVJY3a9bM3njjDU+S6+t/M3ny5OS6WwAAACBqPfLII3bs2DG76qqrbP/+/d6SJWvWrJ4sv//++yP98AAAAIDoTJarL6KqWYKvAQAAAKQsxd+PPvqoPfTQQ96OZe/evVa2bFnLlSsXTz0AAAAQqWS5Wq8k9DUAAACAlJUlSxZPku/evdumTZtm559/vl144YU87QAAAECke5YfOHDAt4EG1q9fb4MHD7Yvv/wyJe4OAAAAiEo33XSTDR8+PBSDV61a1Y9VqFDBJk2aFOmHBwAAAKQpKZIsb9y4sY0dO9a/3rlzp1166aX2wgsv+PGRI0emxF0CAAAAUefbb7+12rVr+9cffPCB9y9X/D106FDr169fpB8eAAAAkKakSLJ80aJFoaB94sSJVrBgQa8uVwJdgTsAAACApNu1a5edeeaZ/vXUqVOtefPmliNHDmvUqJGtWrWKpxgAAACIdLJcLVhy587tX6v1SrNmzSxjxoxWvXp1T5oDAAAASLqiRYvanDlzbN++fZ4sv+aaa/z4jh07LFu2bDzFAAAAQKST5eedd55NmTLFNmzYYF988UUoaN+yZYvlyZMnJe4SAAAAiDqdO3e2li1bWpEiRaxw4cJ2xRVXhNqzlC9fPtIPDwAAAEhTUiRZ3rt3b+vevbude+65Vq1aNatRo0aoyrxSpUopcZcAAABA1OnQoYPNnTvXXn/9dZs1a5bv5pSSJUvSsxwAAAA4RZksBdx4441Wq1Yt27hxo1188cWh41dddZU1bdo0Je4SAAAAiEqVK1f2j9jUsxwAAABAhCvLjxw5YpkyZbJt27Z5FXlQ3SKXXnqpXXDBBZaSBgwYYBkyZPAtqYGDBw9ax44dLV++fJYrVy4ffLR58+YUfRwAAABASsW7Bw4cOKnr/vDDD/bpp5/yDwEAAABEIlmeOXNmK1asmP3zzz8WbvPnz7eXX37ZKlSoEOd4ly5d7OOPP7b333/fZs6caX/99ZcPHQUAAADSml9++cXjbbVg+fzzz23r1q2hy44ePWpLly61ESNG2GWXXWY333yz5c6dO6KPFwAAAIjqnuWPPvqo9erVy7Zv327hsnfvXh9u9Oqrr9oZZ5wROr5r1y4bPXq0DRo0yK688krfojpmzBibPXu293cEAAAA0pKxY8fatGnTfEfnbbfdZgULFrQsWbJ4Ujxr1qy+u1M9zO+8805bsWKF1alT56R+roaCXn/99T4oVDs1p0yZEufymJgYn01UqFAhy549u9WrV89WrVoV5zqK/xWT58mTx04//XS7++67PU6PTcn82rVrW7Zs2axo0aL27LPPJsOzAgAAAKTSnuXDhw+31atXe6BdvHhxy5kzZ5zLFy1alOz3qTYr6s2ooL1fv36h4wsXLvQ3EjoeUCsYVePMmTPHqlevftzPOnTokH8Edu/e7Z+PHTvmH2GVISa894dUIezrLDbWXFSK6JoT1l3UYc0hGtZcSt6n5gKpSES7KpV8Xr9+vbdmOeuss6xixYr++VTt27fPf26bNm0S3IWppPbQoUPtzTfftBIlStjjjz9u9evX90p3Jb5FiXLNLfrqq688Bm/durW1b9/eJkyYEIqrr7nmGo/NR40aZcuWLfP7U2Jd1wMAAADSXbK8SZMmFk7vvPOOJ+DVhiW+TZs2eaWNAvDYChQo4JclpH///ta3b9/jjmuLq/qfh1O2M+NW4iA6bNmyJWL3zZqLTpFcc8K6iz6sOUTDmtuzZ0+K34fmAyk5ro+kuvbaa/0jIaoqHzx4sD322GPWuHHjUIW7YmpVoN9yyy22fPlymzp1qsfkVapU8esMGzbMGjZsaM8//7wX0owfP94OHz7sle+K0cuVK2dLlizxXaAky4EEvJCBpyUadaNoDgDSVbK8T58+Fi4bNmywBx980KtXgoqWpOrZs6d17do19L0qYLRF9Oyzz/YtpeF0cHvKv8lC6pM/f/6I3TdrLjpFcs0J6y76sOYQDWsuuWLT1GDt2rVeaBJ7t2bevHmtWrVqvltTyXJ9VoFKkCgXXV8JfQ0abdq0qV9HbWGUKA+oOn3gwIG2Y8eOOO0UU+WuTyB9dE5FahfR1zbWXFRizSEK1tyxk7zPFEmWh5ParKhS6JJLLgkd03BR9VxUO5gvvvjCq1d27twZp7p88+bN3t8xIer1qI/4FOjrI6xiqCSIRmFfZ7Gx5qJSRNecsO6iDmsO0bDmIr7Ok1GwI1OV5CfaranP8U9KZMqUyc4888w411ELl/g/I7gsoWR5atr1CYRdjso86dEokrs+WXPRiTWHKFhze05y12eKJMuVrH7xxRftvffes99//92T1bEl5+DPq666ynsdxqbeiOpL3qNHD68Iz5w5s3399dfWvHlzv/zXX3/1x1WjRo1kexwAAAAAkl9q2vUJhN3+hTzp0SiSuz5Zc9GJNYcoWHPZTnLXZ4oky1X58dprr1m3bt28r+Gjjz5q69at836GvXv3Ttb7yp07t1100UVxjmmgaL58+ULH7777bg+wVdWigPr+++/3RHlCwz0BAAAAxBXsyNTuzEKFCoWO6/ugX7quE783/NGjR71QJri9Pus2sQXfp4ldn0DY0WooKkX0tY01F5VYc4iCNZfxJO8zRR6ZBve8+uqrnizX1stbb73Vk+dKlM+dO9fCTVXu1113nVeWq0eiAvHJkyeH/XEAAAAAKWH16tXefvDAgQOhgZzJSa1TFENrt2bsCm/1Ig92a+qzWh+qTWLgm2++8f6Q6m0eXEftEo8cORK6jmYPnX/++Qm2YAEAAADCKUWS5eo3WL58ef86V65ctmvXLv9aCetPP/3UUtqMGTNs8ODBccrsX3rpJa9q2bdvnyfKT1S5AgAAAKQVf//9tw/RLFOmjDVs2NA2btwY2lmpwpVTsXfvXluyZIl/BEM99bXaF2bIkME6d+5s/fr1s48++sjbIN55551WuHBha9KkiV//wgsvtAYNGli7du1s3rx59v3331unTp18+KeuJ7fddpsP99Tj+/nnn+3dd9+1IUOGxGmzAgAAAKSrZHmRIkVCgXqpUqXsyy+/9K/nz5+f4BZKAAAAAKeuS5cuvpNTCe0cOXKEjt988802derUU/pZCxYssEqVKvmHKIGtr4M2ig8//LC3M2zfvr1VrVrVk+u6j9j9H7XDVLODNFdIyftatWrZK6+8Ero8b968/t5AifjKlSt7Ql8/Xz8TAAAAiLQU6VnetGlT36Kp7ZYKqG+//XYbPXq0B/EK6AEAAAAknRLPar+iYpXYSpcubevXrz+ln3XFFVf8a/sWVZc/+eST/nEimhE0YcKEf72fChUq2HfffXdKjw0AAABIs8nyAQMGxKlqKVasmM2ZM8eD9uuvvz4l7hIAAACIOmoxGLuiPKD2g+zoBAAAAFJBsjw+DfIJBv8AAAAASB61a9e2sWPH2lNPPRWq/tZAzWeffdbq1q3L0wwAAACkhmT5r7/+asOGDbPly5eHBv6oJYsm3QMAAABIOiXF1R9c/cYPHz7sfcU1OFOV5RqwCQAAACDCAz4nTZpkF110kS1cuNAuvvhi/1i0aJEf02UAAAAAkk7x9cqVK32QZuPGjb0tS7NmzWzx4sVWqlQpnmIAAAAg0pXlqmjp2bPnccN/+vTp45c1b948Je4WAAAAiDp58+a1Rx99NNIPAwAAAEjzUiRZvnHjRrvzzjuPO3777bfbc889lxJ3CQAAAESlgwcP2tKlS23Lli3erzy2G264IWKPCwAAAEhrUiRZfsUVV9h3331n5513Xpzjs2bN8iFEAAAAAJJu6tSpXqSybdu24y7TsM9//vmHpxkAAACIZLJcFSw9evTwnuXVq1f3Y3PnzrX333/f+vbtax999FGc6wIAAAA4dffff7+1aNHCevfubQUKFOApBAAAAFJbsrxDhw7+ecSIEf6R0GVCtQsAAACQeJs3b7auXbuSKAcAAACSQUZLAeqVeDIfbAsFAAAAEu/GG2+0GTNm8BQCAAAAqbWyHAAAAEDKGz58uLdh0byg8uXLW+bMmeNc/sADD/DPAAAAAEQiWT5nzhz7+++/7brrrgsdGzt2rPXp08f27dtnTZo0sWHDhlnWrFmT824BAACAqPT222/bl19+admyZfMKc7U5DOhrkuUAAABAhNqwPPnkk/bzzz+Hvl+2bJndfffdVq9ePXvkkUfs448/tv79+yfnXQIAAABR69FHH7W+ffvarl27bN26dbZ27drQx2+//RbphwcAAABEb7J8yZIldtVVV4W+f+edd6xatWr26quv+uChoUOH2nvvvZecdwkAAABErcOHD9vNN99sGTOmyCgiAAAAIKoka1S9Y8cOK1CgQOj7mTNn2rXXXhv6vmrVqrZhw4bkvEsAAAAgarVq1crefffdSD8MAAAAIF1I1p7lSpRry2fRokW9ymXRokW+LTSwZ8+e44YOAQAAAEicf/75x5599ln74osvrEKFCsfF2oMGDeKpBQAAACKRLG/YsKH3Jh84cKBNmTLFcuTIYbVr1w5dvnTpUitVqlRy3iUAAAAQtTQjqFKlSv71Tz/9FOey2MM+AQAAAIQ5Wf7UU09Zs2bN7PLLL7dcuXLZm2++aVmyZAld/vrrr9s111yTnHfpA0MnT55sK1assOzZs9tll13myfrzzz8/dJ2DBw9at27dvIf6oUOHrH79+jZixIg4LWMAAACAtGb69OmRfggAAABAupGsyfKzzjrLvv32W9u1a5cny0877bQ4l7///vt+PDmpL3rHjh29H/rRo0etV69enpD/5ZdfLGfOnH6dLl262Keffur3nzdvXuvUqZMn9b///vtkfSwAAAAAAAAAgLQpWZPlASWkE3LmmWcm+31NnTo1zvdvvPGG5c+f3xYuXGh16tTxxP3o0aNtwoQJduWVV/p1xowZYxdeeKHNnTvXqlevnuyPCQAAAEgpKvpQzJsnTx7/+t9oByYAAACACCbLI0nJ8diJeSXNjxw5YvXq1Qtd54ILLrBixYrZnDlzSJYDAAAgTVFhStCP/ERFKgAAAACiPFl+7Ngx69y5s9WsWdMuuugiP7Zp0ybvm3766afHua76leuyhKivuT4Cu3fvDv18fYRVhpjw3h9ShbCvs9hYc1EpomtOWHdRhzWHaFhzKXWf2iX55JNPWvfu3f1rAAAAAMkjXSXL1bv8p59+slmzZiV5aGjfvn2PO75161YfFhpO2c7cG9b7Q+qwZcuWiN03ay46RXLNCesu+rDmEA1rbs+ePSn2sxWr3nvvvZYjR44Uuw8AAAAg2qSbZLmGdn7yySc+YLRIkSKh4wULFrTDhw/bzp0741SXb9682S9LSM+ePa1r165xKsuLFi1qZ599tveGDKeD21PuTRZSL/XdjxTWXHSK5JoT1l30Yc0hGtZctmzZUuxnx8Sw+xAAAABIbmk+Wa43Cvfff7998MEHNmPGDCtRokScyytXrmyZM2e2r7/+2po3b+7Hfv31V/v999+tRo0aCf7MrFmz+kd8GTNm9I+wivlfP0pEl7Cvs9hYc1EpomtOWHdRhzWHaFhzKX2fQd9yAAAAAMkjU3povTJhwgT78MMPLXfu3KE+5Bp2lD17dv989913e6W4hn6qMlzJdSXKq1evHumHDwAAACRKmTJl/jNhvn37dp5dAAAAIFqS5SNHjvTPV1xxRZzjGnZ01113+dcvvviiV/aoslyDO+vXr28jRoyIyOMFAAAAkqtvuQpDAAAAACSPNJ8sP5l+jeoX+dJLL/kHAAAAkB7ccsstEe//DwAAAKQnEW5SCwAAAOBU0a8cAAAASH4kywEAAIB0uLsSAAAAQJS1YQEAAACizbFjxyL9EAAAAIB0h8pyAAAAAAAAAEDUI1kOAAAAAAAAAIh6JMsBAAAAAAAAAFGPZDkAAAAAAAAAIOqRLAcAAAAAAAAARD2S5QAAAAAAAACAqEeyHAAAAAAAAAAQ9UiWAwAAAAAAAACiHslyAAAAAAAAAEDUI1kOAAAAAAAAAIh6JMsBAAAAAAAAAFGPZDkAAAAAAAAAIOqRLAcAAAAAAAAARD2S5QAAAAAAAACAqEeyHAAAAAAAAAAQ9UiWAwAAAAAAAACiXqaofwYAAAAA4GS8kIHnKdp0i4n0IwAAAGEUVZXlL730kp177rmWLVs2q1atms2bNy/SDwkAAACIOsTlAAAASI2iJln+7rvvWteuXa1Pnz62aNEiu/jii61+/fq2ZcuWSD80AAAAIGoQlwMAACC1ippk+aBBg6xdu3bWunVrK1u2rI0aNcpy5Mhhr7/+eqQfGgAAABA1iMsBAACQWkVFz/LDhw/bwoULrWfPnqFjGTNmtHr16tmcOXOOu/6hQ4f8I7Br1y7/vHPnTjt27JiF04HDe8J6f0gdtNYihTUXnSK55oR1F31Yc4iGNbd7927/HBNDz+PExuWpLTa3g/QsjzoRjpFYc1EqkuuO17noxJpDFKy53ScZm0dFsnzbtm32zz//WIECBeIc1/crVqw47vr9+/e3vn37Hne8ePHiKfo4gcDDI3guEF6sOYQbaw7RtOb27NljefPmjdwDSMNxuRCbI6IeO4N/ALDukP7xWocoWnN7/iM2j4pk+alSpYv6mwdUsbJ9+3bLly+fZchANUm4zvYULVrUNmzYYHny5AnLfSK6sebAmkM04LUuvFS1omC8cOHCYb7n9IXYPPJ47QBrDukdr3NgzaV/MScZm0dFsvyss86y0047zTZv3hznuL4vWLDgcdfPmjWrf8R2+umnp/jjxPGUKCdZjnBizSHcWHOIBNZd+FBRnrS4XIjNUw9eO8CaQ3rH6xxYc+nbycTmUTHgM0uWLFa5cmX7+uuv41SL6/saNWpE9LEBAAAA0YK4HAAAAKlZVFSWi9qqtGrVyqpUqWKXXnqpDR482Pbt22etW7eO9EMDAAAAogZxOQAAAFKrqEmW33zzzbZ161br3bu3bdq0ySpWrGhTp049brgQUgdtt+3Tp89x7XAA1hzSC17nwLpDtCIuT3v4mwXWHNI7XufAmkMgQ4y6mwMAAAAAAAAAEMWiomc5AAAAAAAAAAD/hmQ5AAAAAAAAACDqkSwHAAAAAAAAAEQ9kuUAAAAAAAAAgKhHshxhd+zYsQS/BgAAABBexOYAAAD/h2Q5wi5jxoy2du1a27Bhg38NpKR//vnHPx88eJAnGhFJPMTExPDMI8XFX2esOwAni9gc4URsjnAjLke4EZenfWQqEZEAaeDAgfbYY4/517yhR0qutdNOO81++eUXu/fee23ZsmU82QjLulPiYf369bZixQrLkCEDzzpSfM1pne3evdu2b99uhw8fZt0BOKXXEGJzhAOxOcKNuByRWHPE5WkfyXKEnZKXl1xyiW3cuNFfRPRBwhzJTWtKa23p0qVWu3ZtK1OmjBUqVIgnGileuRKsu7p169o777xjBw4c4FlHiq85nQy84oorrHnz5lalShUbM2aM/fnnnzzzAP4TsTnCgdgc4UZcjkitOeLytI9kOVKcKtzia9u2rf3+++/Wp08f/57KSyQ3rak9e/bY3XffbY888oj16tXL8uXLZ7NmzbIvvviCJxwpQhXlq1atsnr16ln37t3tiSeesOzZs9uRI0d4xpFia05/Txs2bGi33HKLTZ8+3T8/9NBDvqsGAOIjNkckEJsj3IjLEYk1R1yePpAsR4r4+uuvrX379v51lixZvB3BfffdZ6tXr7ZDhw75i8jjjz/u3//9999UliNFqE/5mWeeaeXLl/ekkaotn3nmGbv22mutW7duPOtIktg7YmInw7/88ku74YYbrEOHDnb06FF/7WvRooU9+eST/j2Q3OsvqF55+OGH/ftPP/3Urr/+erv66qtt27Zt/I0FQGyOVIHYHCmFuByRRFye/pAsR4psPdm6davNmzfPHnjgAT+mgZ5KmF955ZVe5fvJJ5/Y5ZdfbnPmzLH58+dTWY5kW3uxnX322V7VqxM3Xbt2tcqVK9tnn31m48eP9zWpEzdAUiqk9KZv7969ljlzZq8o12uf6HVNcxm05nRCsE6dOl5lPnv2bJ5wJMtrndafeuL/+OOPfrJGVSxaf1pzRYsW9TYs6l8+ZMgQ27JlC886EMWIzRHJtRcbsTlSCnE5IoW4PH3KFOkHgPRHVeOqqlTy6Pnnn/cK3hdeeMGr3iZPnmw//fSTtW7d2tq1a2dZs2b161SvXt1OP/30SD90pIOBQWvWrPETNZs2bbI77rjDpkyZYsuXL/ek+bnnnuvX1cmaPHny+PoDkhIY6SSMdsg89dRTVqNGDa/oveeee/x1Trtq1AYoOGk4Y8aMBLe+A6e67vR3dsOGDX4SZvDgwT6TQeutZs2adumll9q4ceP8up07d/aEuZITAKIXsTkigdgc4URcjkggLk+/MsQwWREpZP/+/Z44UqK8YsWKNmrUqNBlSmi+8cYbtmDBAps5c6ZXYZYrVy70YgMkhloRXHXVVda0aVNbvHixFSxY0BNHPXv29LW1cOFCTyypJYu+1gkdvQTSMx+JfROo1y71JtdAz969e/vXEn9d3XbbbX7SRq95OqkDJIUS5WPHjvXXsKD1ilqbvfnmm/boo49akSJFfLisXhO1RnmtAyDE5gg3YnOEC3E5IoW4PH0iK4kU22qXI0cOa9SokSePlixZ4v17A6VKlfKWBJ9//rkPJdPwRV+QJMqRCEpM6g1gly5dPHH08ssv2zfffGPfffedJyb1kSlTJk8a6XpBolz9o0mUI7FrTuvqwgsv9MpdDY/Vutq3b59fHrT40Tq87rrrvEWLdjzoNgrmgcTS7gSd9NOAbA0xDmh3g3Zy6cSNKsvPOuusUKJca47XOiA6EZsjEojNEe71RlyOSCAuT7+oLEeyb7VTL+gvvvjCE+JqS5AzZ06bNGmSPffcc17lO2zYsNALi7aNqwJYb/rffvttvy5wqmsu+FytWjVfe2rpo7WmNah1tXLlSsuWLZsVK1YsVPGrRLkS6MCpCnbABGtJ8xh27dplDz30kK8zJSpz587t11W/8qlTp9rNN9/s6411h6SsOZ2EUfso9Sl/+umnfe6H2vvotS622DsbgtdHANGH2ByRWnPE5ggX4nKEG3F5dKCyHMl6NlftLcqXL28TJ0705JDaEujYjTfe6BW/qry8/fbb/TZKlMtHH31kixYt8iQScCq05rR2tNZ2797tSXIN76xSpYpX/CpRLlqHX3/9tX+tBJLWK4lyJCU4UqX4M8884+2klCCvUKGCt/vRScCWLVv6Grvpppv8Ovpe601vHFl3SAytuT/++MPatm1rs2bNsosvvtiefPJJq127ts9m0KBPCXYtxK4iJ1EORCdic0QCsTnCibgckUBcHh1IliNZ6I35tm3b/E38gAEDbNq0aV5dqTfwqiT/+eefrXnz5t6KRe1ZYm8JVYLzgw8+sLx58/KvgZMSrJ+9e/d6wkhD7TSwU4NitYNBa0m9e+XOO+/03Q5KKMVer0BiA3LtVFByXLtiVE3eo0cPn72gIcaPPfaYr0sNk1XFef/+/UO3J2mJpNBJmV9//dVefPFFmzt3rl1wwQXewqx06dKeRNdQWdYYgNixDrE5woXYHOFGXI5IIi5P/2jDgmShql61wNAfLVVaqv2KfPXVVzZo0CArUaKEtW/f3gd9BtgajqT4/fffrVWrVp4oGjFihFfs7tixwx555BHbuXOnJ8i17pSwVO/yoG8vySQkxcaNG2369Om+1jp27OiDq9QrWkn0e++91xPmWmdKZurkjdYbrVeQGAmtm61bt/pOBbUs004GtZvSyWi97hUuXNjnNQCAEJsj3IjNEW7E5QgX4vLoQ7IcSRL0RdXQxLfeessrLDXQU9WVAbW/0Bt5tSRQFSaQ1PUmy5cvt1tuucUD8z///NN3LIiqetWuQC1/ihYt6lXnJCyRHA4cOODJcLVgGTNmjDVu3NiPq9WU5i6otZRaAt1www2h23CCBqdiwYIFdvDgQatVq5Z/r5N92i0zfPjw0HU2b97s60yva88++6xVrlzZTw4WL16cIdkAiM0RVsTmiBTicqQ04vLoRrIciRIkgIIhncE2qFdeecW6devmlZadO3eO80JzySWX8EYeSaZEkZLjWk9KUrZo0cLy58/v1b7xg/b46xU4VbHXk17vdPJPFeWqGp8wYULoejp5o+OXX365J86BU11n27dv9xOABQoU8LWkHVrandW1a1evIB89enTo+jpho9dAJcrV6kyzQiT4Wwwg+hCbI1KIzREuxOUI1zojLgfJcpyy4M24tn6rP7m2eRYqVMjbrOjN+6uvvuoV5k888YQ98MADCd4WSAxVXLZu3drfEGqXQtWqVX0dqh3LGWec4YklITmO5BCsI+1WUBufI0eOWK5cuXydqRe+KstHjRoVuv66deusWLFivMYh0b799lt74YUX/ASg+pCrvdnnn3/ug2JLlSrlbc5kz549fkI6e/bsNnToUNYcEOWIzREpxOYIF+JyhBtxeXQja4lTXzQZM3pV25VXXunVbKqwFH0/e/Zsa9eunT3//PP+Rv6999477rbAqZ7Z1UcwSOOee+6xQ4cOeZLyhx9+sHLlyvkwT520CXriU0WO5Eg8aB2pJ3nTpk3t2muv9ZMyb7/9tl199dXeduqLL77wocUBDfXUa1zsAcbAyb7OqRdinTp1fE1pKF8wHFtrT63MfvvtNz9Bs2bNGn8d1OuhrsOaA0BsjnAiNke4EZcjnIjLIXEnRwEn6Z133vE38A8//HCoZ5gqex988EH79NNP7Y477vCt5A0aNOA5RZKoBYa2QZ155pn+vXpGq8pXuxo0zE5fa0eDvlbiiN0LSK7Eg5KTjRo18l0Ml112mZ8M1HDFChUqWN26de21116zhg0b+iDZ2PMYOCmIxNAwzx9//NFef/11PyH48ccfewJdf2e1DvUa2KVLF7vxxht9h4NOEur1UQE9aw4AsTnChdgc4UZcjnAjLgdtWJAojz/+uA9W1Jv1YDLwokWLvDXBu+++69W+/zY5GDhZajegvrzNmjXzBHlAVeVt2rTx3Q1q96NkZoA2LEgOSobPnDnTq8h1EkZr7IILLvBWGMEJHM1jqFSpErsZkGRbt261iy++2JPjamv23Xff2cCBA+2cc87xWSDBzhkN/VS7HyUr+PsKIEBsjnAhNkckEJcjnIjLQU8MJErZsmW9HYGq4IJEuKp78+TJY/v27YtzXRLlOFVBGwslgnLnzm29evWysWPH+uBYUSWlevmqunfGjBk2Z86cOLenDQuSw6ZNm/w1TXTCRm1WlCjftWuXjRgxwoOoKlWq+HrTCRogqQPSihcv7i3McuTIYfXr17enn37ak+bqWf7NN9/49XQdJcr1OsnfVwABYnOkJGJzRBpxOcKJuBwky5Eot956q/dMrVWrlm/7VLJSvcr1Bl7JIyCxlHTUVrsVK1Z4a4uNGzd6r+gXX3zR26woaaR1Jkqkq5evWhMASZFQslsnZPT6puSkeknra7nvvvts+fLldtZZZ4WuywkaJJVOzPz666++OytITNSoUcN75GvA0JIlS+Jcn9YrAGIjNkdKITZHuBGXI9KIy0FvDJzQf/V+fuGFF6xQoUL2xBNP+Jbw7Nmze5VvMGyMN/I4VaoYV9Jx6dKlPjBWPfCVGNfHTTfd5Ne5++67vTWGevqqFcbixYtZc0iWoUGrV6+2r776ytteaHCxkpQatjh06FDfxaBhnxperKGLar8S9IsOTt4AJytoFbV//36vIteWdv0dveuuu2zSpEl+Iuaqq67y6+pva/fu3b3iHEB0IzZHuBGbI9yIyxFuxOVICD3L8a8vGBpwt3PnTm+xciJqRaBhY9myZaOHKpJMCXDtWGjbtq117drVA6affvrJL9NgRSUs1UM6qCrXgE9OziCpVCmu6vEyZcr4esqXL5+9+uqrPqh45MiR/qHe5Gp78corr/i6ozc+EiN4vdLrWs+ePX0daUB2x44drWTJkv669ssvv1iRIkX8pKDmg6iqXH+Tea0DohexOSKF2BzhRlyOcCEux4mQLMcJXzBU3Xvttdd6pdujjz7q1W+xqwx8AcWrrOSNPJJKiSG1+NEwz7x589ott9zin1Xxq4SlLouNAXdIrNivV6NHj7aDBw96wnL69OmeEFdvRJ2YUdIyGOgZIFGOpFizZo2fnAkGd6rNypNPPmlbtmzxKnO1oZo6daoVLlzYTxpyUhCIbsTmiCRic4QDcTkihbgcCSFZjhO+YNSsWdNbrNx7771+TIkkvWGnNy+SU/wTLEeOHPEKXh1XVa+GKo4ZM8b69u3rbTL0NUPtkFRBsnvt2rU2d+5c+/777731T7NmzfwEoI4NGTLEk5evvfaaV/wGaL2CpNIMBlWW6ySNXusuu+wy39WgQcYaIKsThLFxUhAAsTnChdgc4UZcjkgiLkdC6FmOBClRpKo3JcqVvGzTpo39/fffdt555/nQxaJFi/LMIdkCoz/++MOTlqrebdy4sf3444++BtXe5+KLL/brrly50s4++2wS5Ui2/pvqPa6BxOpPrj74enOoEzUlSpTwwYo6ifP444/boEGDbPjw4aHb06MciVlzsdeN2pdp5oeozdkFF1zgiXIdf/PNN/1vbuydDJwgBEBsjnAgNke4EZcjEmuOuBz/5cTTGxFVgrYqgSxZstiqVau8b7SSRqpqUzuMCRMmhPpHA8k1zFPJysGDB9ttt91mTZs2tXfeecd3NihRrh7lOq7Pzz33HE86kkzBkU7+fffdd76m1HZFFb46SaOEpWY1SLVq1bzSQAM+gaQkHrTm/vzzTz8hKGq9olY/qibXiWm95omGGqtfuXqYA4huxOaIxJojNke4EZcjnIjLcbKoLEeogkBbvw8cOODbv9WKQNW+qipXIlNJc3nvvfds9+7dPGtIlsBIa6l169bet7dLly5eXT5s2DB7//33rVixYnbppZfauHHjPLG5cOFChioiWezdu9fKlSvnOxdGjRrlx7QOVUmuBKbWpk4OKpGp6wnzGJAYWjdB4uH666/3ZLj64uvrOXPmeIsfnQxUe4WnnnrKdzssWLDguHkgAKILsTkigdgckUBcjnAhLsepIFke5WK/YKjlyuHDh73FipKUPXv2jHPdW2+91Qe83HjjjRF7vEhfdHJGffBbtmzp36v9xSOPPOJr7bPPPrPatWt7r3LtdFAik769SIog+agk+QsvvGD33XefzZo1y+rVq+eXt2rVyteZBi1qqKeS5YHYffWBk6V1o5OA1113nf9N1d/ZIAGuE4RnnXWW3Xnnnd6KRX+LlSjXayIDZIHoRWyOSCI2R7gQlyPciMtxKkiWR/kfKL1grFu3zvtEd+/e3W666SabOnWqJ40qVKhgjRo1stmzZ3sbAr3hV3Wv3tDzRh6JXXOxKyXz5Mlj27Zts7feesuryyV//vx2ww032A8//ODrLFu2bKE3j/TtRWIEr1d6A5gjRw7bv39/6ASNEpWnn366de7c2b+/4447vDf+1VdfzZONZDFt2jRvK6WTM3oNDF4HtXvm0Ucf9Z1bet0THefvKxC9iM0RiTVHbI5wIi5HJBGX42SRLI8y2vZ96NAhu+KKK0KBkbZ9q4JXW8NFPXo1XEyJ8r/++st7lqsNRsOGDT3hRHUvkhIYqfWKPmsdaoBdu3btbMaMGVawYMFQAlMnaAoXLuzXC1DZi6RU6GnWwsMPP2xZs2b1ZPnAgQN9vWldKWGuzw888IDfpkGDBnHWLJAU+juqNResR32oenzFihV+YqZAgQLH9YsFED2IzREpxOYIN+JyRBpxOU4WyfIoooS3KsT37dvnFbq1atXy47/++qv3J5cqVapY6dKlvY+qkpkvv/yytW/f3vurBkEV1b04VUECSAMUVV2pdaT2A2q3ooryzZs3+9pUawy1AVq/fr33KgeSSklw9YOuX7++94sOhimq7YWGGGsN6sSh+kbrhI121wRIWuJUJdTbXm3Nnn/+efvyyy/tmmuuCa0rtWXREOMnnngidF16lAPRhdgckUJsjkggLkc4EZcjKTLExB+1jnRNFbxvvPGGtyNQ79S6det6olwDPX/77TfvRx4MvFMSSdebPHkyVb1IliFVOhlz//33+wkZnaR5/PHH7bnnnvO1uHz5cvv888+9V7TWo07KsIsByUG7ZVRZPnr0aF+Pet1Tf/w333zTX+OyZ8/uicwrr7ySk4FI8mudWpupjZQGVmkXV6lSpeyxxx7zdlM9evTwtffuu+/a4sWLvbUZJ6CB6EZsjnAjNkckEZcjHIjLkVRUlkeJoE+q3rgrOTRp0iQbMmSI5cyZ06velBhXNbn6ps6dO9eGDRvmycv58+d7ojx+PzvgZCl5tHLlShsxYoQ1adIk1OpClb6FChWy3r17e5Wv1uGFF14Yuh27GJDU4OjPP//0vvgHDx70HQuitVa2bFlPlOtyfdaaVMWvcIIGSanQW7ZsmbcsK1++vG3fvt3XlpLk6omvdiuDBw/29achsxrmqUQ57X6A6ERsjkghNkc4EZcj3IjLkRxIlkcRJb31Rn748OGe+P7qq6/8uCre9Ia+TJkyvlVcCSQNvAveyJM8QlK3PakNhtqsaKCdWg5oyKLWoIbe6YSNtiHHRwsMJCU4Uj9ozWLQwOIzzjjDHnnkEZs4caJXletkoOiY1qjWYIAqXySGXs9USa6kuIZ2areMDBgwwG6//XabPn2676pRf/y8efOGbkeiHIhuxOYIJ2JzhBtxOSKBuBzJIW5jTaTrF4wtW7Z4Ne/VV19tH374ob333nuWJUsW69+/vy1ZssQHeuoNvVoVvPTSS6GKN5JHSOwbQPWEVquBa6+91pOWmzZt8hMyWo/6UMuVbNmyeYsWILle63bu3Ok7ZdTyonLlyp641DDPX375xROW2jXTunVrW7p0qV9Pt6EjGRJDfyNFAzzVzkc7t0qWLBm6XCdk7rjjDj8pffjw4TgnZhjmCUQ3YnOEG7E5wo24HOFEXI7kRGV5FFEC6bzzzvNkkSovGzdu7BXkqoRTta+G39WrVy/ObajuRWJpR0K/fv2sXLlyVqlSJW9zoRM06ouvJHqNGjVs0aJF3qpAx4CkUvJRJ15Uyfvzzz+HBieqkkoVvjo5qKR58eLFfXeDds9kzpyZ6l4ker3pb6ROumit9erVy3Lnzm1r166NUzWuFlMarK31FxutzQAQmyOciM0RTsTlCPd6Iy5HcqKyPJ2LXS2paoJ58+bZJ598EkogXX755T50UYmlWbNmRfCRIj3QmgpoR4L+YGmwYnDZDTfc4ANjP/74Y3vllVf8e7UGCnYxAIkRrB0lH3UCUD2js2bNarNnz7bff//dX/uUxNRAoU8//dTefvtt71VOohxJea3Tetu6dav17dvX2/vob6lOCqoNi17jtJsrGN4XP1EOIHoRmyOciM0RbsTlCDficqQEkuXp/I/UoUOH/LOq2lRVrupx9Y6eOXNmqJ+0kkodOnSwPn36RPQxI+3Tmtq4caOfeNEaVE/yoD9vsN6uu+46mzBhgveUViJdCUtVurCLAYmltaNq3mCHgl7Punbt6hW/Y8eO9YR54KyzzvI1F7ReYd3hVJMNweuZ2kp1797d/862bdvWj3fr1s3uu+8+bwGk1mbaraXXuZdfftkvp90PEL2IzREJxOYIN+JypDTicoQDbVjS6YuH/kipWrx3794enOtj4MCBnkR69tlnvYdqnTp1bPPmzV4ZN2TIEE8exR78ApzqutNJGfWHVnuLCy64wHvgq6KybNmyvgZV8bt7925PIr3//vt26623+m2eeeYZnmwkiU64TJs2zdfYZ599Zu3bt/c1N27cOH9Nu+222+zcc8+N8/pGGwycjKCdil6rRo4caX/99Zc1adLEX9t27Nhh33zzjX3//fehNmZPPfWUNWjQwFtMHTlyxFue6fYM8wSiF7E5IrXuiM0RCcTlSCnE5QiXDDGUOaVLa9as8apeVbmpslfJy7feesu3g1erVs0HfOrNfb58+bwCk3YESKz4J1iUDFdiSFWXGuqpAXcaKquKcyWOtB6V1FSiUgnzjh07+sBFrUUgsetOtFtBJ2JKlSplX375pR8bNWqUvfDCCz5gsVWrVjzBSFRArtc19R7X2lLY9PXXX/saK1q0qK+tbdu2ed/yyy677F9/DoDoRWyOcCE2R7gRlyMciMsRTiTL0xm9iVcS8rnnnvMWBEqQB9RH9Y033rD58+db4cKFjzv7q77RQGL+YKnNxdy5cy1XrlyePCpfvrxfrgRTixYtvD+5hiru3bvXBysqyRmsVR3T7YBT9ccff/i6UzW51lXshPmFF14Yms/wwQcfeH98kpVIDL1GVaxY0Zo1a+Y7s0S7YtR+RTMY1Bt/9OjR3qNcf2erV6/OEw0ghNgc4URsjkghLkc4EJcjXOi3kU4EGwSCtgL6vGfPnlAiXJerj+rZZ59tGzZsOO72JMqRmDWn5KMGdGoXw5gxYzwprvYEQVWv1tWqVatszpw5/r2S4kqUB0M4gmPAqb7WybBhw2zAgAG+U+bAgQN+TO1/nn/+eW/FUrt2bT/WtGnTUBsM4FTotUr9x5UYv+eee0LHixUr5m19RNXkd999txUsWNB3agVDjQFEN2JzRGLNEZsj3GsuQFyOlEZcjnAiWZ4OKAGkxKOS4OpTLtoq/tVXX3nVpRKWurxIkSKWPXt2b4UBJJXW1M6dO71HuZJJn3/+uSfL1W5F7X5E1b4lS5a0w4cPx7ktffGRlNc6tbxQ8lKJcp2oef31123SpEnel1NUVX7XXXdZoUKF4gyAobIcp0qvVRpKXKNGDV9v69at8zZSb775pjVv3jx0PSXM1Rf/+uuv9xkNAKIbsTkigdgc4URcjnAjLkc40YYlnfQHU8uV+vXre+9UvWE/44wzvMJN/XpffPFFr4BTMklVwLNmzSJphGSxa9cuu/nmm73dhSoL1A//oosusrFjx9rChQvtvPPO896+aoHB7gUkx7ZivYbdcsst1qdPH7vpppt83Wlw8W+//ebtV1q2bGm9evWynDlz2qBBg/y2DC5GUunk88svv+yvefobqu9r1aoVeqMY/wQgaw6IXsTmiCRic4QDcTkiibgc4UCyPJ30B6tTp4516dLF7r///lBvRFE7ArUoUEX56aefbuPHj2eYJ5KF1pmqLLX23nnnHR/kec455/jXorYE1157rd14443+PQPukFQaBKsEZffu3a1nz55xZi089dRT3npFVec6WagBxhpcHPv1EEjM61ywfnTiT8NidUy7aDSfIf51AECIzREJxOYIJ+JyhBtxOcKJZHk6MHHiRB/kqaR4Qm/cNWQxS5YsljVrVj/OME8kJyUtNVBWQxY/+ugjP3b77bfbmjVr2MWAZK3U69ixo+XJk8cGDhzo3z/xxBP+mqYdDHfccYcnJ7Zu3WoVKlTwKnRe65ASgfnIkSN9HWoOSNWqVXmSARyH2ByRRGyOlEZcjkghLke4/K8kD2ma+kFv377dP6vKMhjuosTRjh07vH9q0KtXl9EOA4lxourJdu3aea/oKVOm2AMPPGDr16+3TZs2hRLlVJQjOajNhSp5lYAoU6aMDR8+3Acqqt3KF1984b3L1R9fsxlE647XOiQHve4Fr39XXXWVv0FUZXn//v3t6aef9h75ABAbsTnCgdgckUJcjkghLke4MOAzHShevLgtWrTIpk6d6n+4gsS42rJMmDAhTn9ytoojsVPONVAx9vcBJSjV7mfw4MGeNFIP89mzZ3sLDFX2MlQRiRF7MGfgiiuusIsvvtgHyKq9j4bKvvbaa5YtW7bQ+gyw7pASgblcffXVduedd/rr3fnnn88TDeA4xOZIScTmCDficqQmxOUIB9qwpBNqS6Chdhp6d9ZZZ9kPP/xgixcv9iGLSloCSRlS9ffff1ubNm18jWmI58n06KWiHIkVrJ3Vq1d7a58DBw5Ys2bNQhW8qthTaylp3bq1t/xRAj3+kEXgv5zotSz2gM7Y10no+gzzBJAQYnOkBGJzhBtxOcKFuBypCZmFdFJZ0KNHD+9bvmTJEps5c6b3Uw0S5aruBRITGClZpISlqsY1MFHJ8vnz58c5m3siVPYiMYI2UkuXLrUaNWr4rpm3337bB8iq9YVez5Qonzt3rleX66Sg+khrrSZU9QL8m9i9yH/77bfQGtR60uctW7bESY4nlFjnJA2A+H/HhNgcyY3YHOFGXI5wIi5HakJleRo6m6tEUPAH60Rn3Q4ePOgtCeLfFkiMX375xerWrWvdu3e3jRs3+tRzVfmqWupkK8yBU6We99dcc421atXKunXr5jMZLrjggtAgz3vvvdd+/vln++qrr+z+++/33uQM80RiaebCdddd54NhNXehVKlSfvyyyy7ztlIPPvggTy6AOIjNESnE5gg34nKEE3E5UguS5Wlkq91PP/1kzz33nAfnt956qzVq1CjB6//XdnHgVCgRqZYXL7/8sn+v9j4jR460devW2ZAhQ7x/NJDcFixYYB9//LH17dvX11+tWrWsdOnSvmPmm2++8WR5586dQ69vnBREcrwRvO+++3wgtlpOKUmutj/asQUAsRGbI5KIzRFuxOUIN+JypAa0YUnFgq3gSkyqylItVXLmzGk33HCDjRo1KsHb/Nd2ceC/1lzsr3VmN3fu3KHvVU3eoEEDb8miAbJqyQIkVfz2KVWqVLHbb7/dv9YgxRIlStj48eOtadOmfmz37t1xrs/uGSR1/RUsWNDeffddW7ZsmdWsWdOKFSsWSpTTygxAgNgc4UZsjnAjLkckEZcjtSBZnoop2b1t2zav6u3Zs6e99tpr/vWbb75pHTt29ApfILnXnM7kKkmur6tXr25vvPGG940OTr5cf/311qRJE6+61EmbXbt28Y+AJPff3LBhg5+EmTx5sh9XJbla/uzYscMeffRRP/bhhx96G5bevXufVN984FTeFKoX/vr16/2zKsw3b97s61NtfgBAiM0RbsTmCCfickQacTlSC5LlqdihQ4fs8ccf9yT5r7/+GjquikslMNVHVa1ZgOSiJLkqxm+77Tbbu3evtW/f3oco6vtPPvnEE5ra/qldDldeeaUPxdMAPCCpQ4PUH/qFF16whx9+2NtMTZ8+3bJmzWr79+/37xs3buw9yjXoU28cFUixewbJQclwvTnUCUANldVQY/3N1VrbunUrTzKAEGJzhBuxOcKFuBypAXE5UguS5alM7EpJJYratm3rLVg0WPHLL78MXabqymHDhtlHH31EdSWSjdackpKi3QvBMM9mzZp5OwydqFH/fLXEaN68uZ155pm++wFIDCW7VTnerl0769Gjh1eVK3H++eefe8JSFeeTJk3yy6tWrepDPYMASpcByUUnAytXruy7ZVRZrhM3BQoU8A8A0Y3YHJFEbI5wIS5HakFcjtSAAZ+pSDCkTsmjPXv2WPbs2e3ss8+2NWvWeNsBXd66dWurX7/+cbdlmCcSI1g3qpRSMB7059VwxVdffdXy589vI0aMsBw5cthvv/1mZ5xxhuXNm9cTlYMGDfLE0rfffuv9foGTeX0LPgdrT69vOhGjFixae3Xq1LHixYvb22+/7dW9559/foI/BzjZIXyxX+tOZv3Efj2M/3MARBdic4QbsTnCgbgc4UZcjrSGd3+p6MUjaEdQu3Zta9mypV100UXeq1dVbk899ZRXVI4dO9b79sZGohyJXXNKHqnNQLly5WzWrFl+XOvsuuuu82peVZF369bNByqWLFnSk+Vr1661fv362RNPPGHvvPMOiXKcFL2+qbXPJZdcYuPGjQu1UNFnnYxZvHix98jXME8lykWvf59++ulxPwc4GUpwq43PK6+84utMwzufffZZO3jw4L/eLnaiPPg5AKIPsTkiseaIzREOxOUIN+JypDW8A0wlk6b14rFx40YfnqjWK1988YX179/fVqxY4YnyQoUKWffu3W3nzp0+bDE2+vYiMWtPa07JI51sUYuLm266yX744Qe/XD3Jr732WsuVK5efnFEVeSB37txe+Tt//nxPfAInS0lyrbm77rrLT/yJXttU3aI1qJ7RavETtJpSP/wGDRrwBCPR1Pv+3nvvtc6dO3s/cp2YyZYtG88ogAQRmyNSiM0RbsTlCDficqQltGGJEPXkVT/opk2b/u8fIkMGW7hwofXp08d7NAVUValjQ4YMsZo1a3pbgtKlS1PphiRvu/vjjz+sWLFi3m7l7rvv9gSm1pvWZpUqVUJ9y5Vg0oDP2NWVtCVAYqjFlAZ4qs2FkuKau9ChQwfbvn27D4wtW7ast5/SMKuVK1f6yRuduKH1CpJCJ561S0Eno4OdWawpAPERmyNSiM0RCcTliATicqQVVJZHyNSpU61MmTKeJA8qw5Ug+vrrrz1pLqr4bdSokbe+CIZ7qn+vkpaxK1+AU6FEuVqpzJgxw55++mlPlMsbb7zh7Vc04POhhx6yq6++2ltj3HrrrcetOdoS4GTe+MX/XhW9+nzeeed5X/z777/fRo4c6YNiVWmghHmFChWsYcOGNm/ePE+Uq485rVeQlIF8qibXzpm5c+f6ax6vYQASQmyOSCE2R0ojLkckEZcjLaKyPMzi9xdft26dt1VRywv1JtcAz5w5c1rXrl29glyaNGniFXFBUhNI7HoL3H777TZhwgS78cYb/XPQq1wGDBjgLYE0ZPbll1/2hCWV5EjM65xOAKqvvQZ46nutsZ9//tmaNWvmleX6Wq95Spjfc889x61Xqn+RGMG6UY98tZIKaM098MADPoehV69efuyDDz6wunXr2umnn86TDUQpYnNEcr0FiM2R0muOuByRQFyOtOp/2TGE7Y9U/OBo9OjRXsmiF5EWLVrYLbfcYq+99pq3xNAbeLUiUEK9VatW/CvhlAQJbq0ttfzROtIuhXPOOcd71CkJ/tFHH9kvv/zi1bzB9R955JE4P0eVvUEiHTgZep3TutHuBFXzfvPNN77GLr/8ch/iqWS51p1e19SSpVOnTr5G1Vc6NirKkZi/tcGwbCXGtRa1U0GV5RqcLVpvu3btsj///NN+/PFH/wAQfYjNEW7E5ogE4nJECnE50jLasITxj9TBgwdDQ+3Ue/yJJ56wvn37en9oVfBOmjTJ39RroGfz5s3tr7/+8rYrGqSoZGX87VPAiWitKPGtykolJNVzXOtM60t9yGXMmDF22WWXeeuVn3766YStVUiUIzGULFdyUsNg1R8/X758PqNB8xdWrVplzz//vPdKbN++vb3wwgv++hd7ix6QmNc9/a39+++/fTCsXu/0Gvf999/bk08+aatXr/Y1qQpztfnRetPOLr32sfaA6ENsjnAiNkckEZcj3IjLkdbRhiVM9EZ8xIgRNnnyZE9aqnpcgztV+aYXEg25W7NmjbciuOGGGyxr1qxxtunRjgAnK1gru3fv9ipeVfNqXelkjSooVTmuXQtai6L1tmzZMv++UqVKPNFINjpZ8+677/pQT73+6bXvzTff9MGd6lE+Z84cq1y5cug1Uq93J9qeDJwM7cb64osvfKeC1p1MmTLF3nrrLW+10qNHD58XcuTIET8RGFRbcVIQiD7E5ggXYnOkBsTlCDficqRpMUhRr776aszo0aND33fs2DEmQ4YMMU2bNo1zvaNHj8a0b98+pkGDBn79Q4cO8S+DRNu9e3dMyZIlYx566KHjLps3b17M6aefHtOpU6fQsVq1ah23JoHksH///pjhw4fH5MmTJ+add97xY/v27YuZMWNGzD///BPnuseOHeNJR5IMHjzY/8bWr18/zvHJkyfHtGjRIqZJkyYxa9euZc0BUYzYHJFAbI7UgLgc4URcjrSMNiwpTEM7VcUWUL9oDetU5e+gQYO8+k30/UsvvWRnn322LV682G8HJLYfogbEqidv//79/Zj6QgeqVq1qTz/9tM2ePdt79sp3331nEydO5AlHssuePbsPJ37mmWd8h8OoUaMsR44cvuMhfusfKsqRmNe72B588EFv8TNt2jT7/PPPQ8fVAkgf5cqVs2LFirHmgChGbI5wIzZHakFcjpREXI70hKl9KUTtLooUKWJ33nmnf//zzz97X+iePXv6948//ri/mVeyKBhq98knn3hPc3qnIim0pq688kpvw9KuXTvvi1+0aNHQUCEpX768r8k9e/aE2l7ostjXAZJLtmzZPGGutfXYY495S6D4wzyBxG5rV098bfPU97Vr1/aThdpqrBZTasHSqFEjv/6tt94aui2vdUD0ITZHpBCbIzUhLkdKIC5HekOyPAX89ttv9tBDD3lFuYaKnXnmmT5ETIMWt23b5gMWlTQfMGCAffnll7Zp0yZ/s6/r6M09SUskVpD4VlJIlVMaZKfkpNZaoUKFvMJc/fBV2avhd6qwjF3NS6IcKRmYt27d2pOYU6dO9QpgKsmRlNc6JcqXLl1qjRs3thIlSvix9evXe8/y3r17++Ualj1u3Di78cYb49ye1zoguhCbI1KIzZEaEZcjORGXIz1iwGcKGT58uH311VdWqlQp69Wrl5111ln2xhtveHXlkCFDrFOnTt6CRS0JVOmyfft2mzRpkmXOnJkBd0iS2AMStaaUMM+dO7f169fPK8xFJ26USBo9ejQJSyR5nZ1Kpe7hw4f9dY5hnkiqv//+26vG27RpY+3bt7f9+/dbrly5bPDgwT48WzTkc+7cufbtt9/yhANRjtgckUJsjnCuMSEuR7gRlyO9IVmezGL/YRoxYoS/QS9evLhXkp9++un2+uuve2uMoUOHeoW5rq8/brqN/sAdPXrUMmWi4B/JH5SfccYZNnLkSK/oVfJo/vz5vtbiB1fAqZgzZ47VqFHDvw52LpzqGgUSY8OGDd7qbPr06b72atasaRdccIFXki9cuNDbTWmHDWsNiG7E5kgNiM0RDsTliBTicqQ3NCdOIWvWrPE/VqtXr/bqcQ1U1Nk2VcC9+uqr1qVLF3vuuec8Sa4K36DKkkQ5kkOwnkRtCFq2bOn9yTVAVsM8582b52tNvcVIWCKx1Cf6hRde8Nc3rSUlylU5Xq9ePVuxYsV/rlEgKdTWTB9bt261K664wndyKVEuOiGtdizBWmMWCABic0QSsTlSGnE5Iom4HOkNyfLkfkIzZvSeqZdccolVr17dB3aqglx9VZ955hnbsWOHJ8yVYProo4/ivIEneYSUDMqbNm3qVZhLlizxNhjaxaATNUBiqa3Pbbfd5gmIl156yav3Lr/8cm+FoQpfILnoZIzoZEygUqVKVrhwYStQoICVK1fO3n33XT+uk4PqT6y5DAH+vgLRi9gcqQWxOVIScTnChbgc0YA2LClA1WxKHCkZHlCV2yuvvGJNmjSxzp07ew/zYDseW8RxKk60XmIfj73lOKHr0+4HyUU7FrRT4a233rJp06bZlVde6ScJY09FB5IieA1btmyZde3a1d8MnnfeeT4PRFUsOmHz559/+t9X7WjQCWvt7NJJwZPt2QkgfSM2R0oiNkdqQVyOlEZcjmjBO8hkErtCfOfOnTZjxgyvIg906NDB216od7Q+hEQ5EiNIfCsZ9Ouvv/rXSgjFrlaJnRxKqAUB7X6QHI4cOeLDY6tVq2azZs2ybNmyWZUqVUKXk6REctBr2MaNG+3666/3PuTnnHOOD8zWri2deP7yyy9910zBggWtQYMGPpMh2D3DGgSiF7E5woXYHKkBcTnCgbgc0YLK8iQKKifjV+pq+7feuA8fPtxy5MjhxzTYs0KFCv4GnzfwSOoAjU6dOnmSslmzZt7yQm8K1f5HOxdatWrFE4yw0Guf1qHWoFpMvffee3bmmWda//79+RdAsvx91Wvbrl27fECxhmXv37/fTxa2bt3a/9ZqLsiJbgsg+hCbIxKIzZEaEJcjpRCXI9pQWZ4EqubVm/FffvnFe6R269Yt1H5AicxNmzZZ3bp1faCnKuK0PVwV5kqU67ZAYqkNgdbb8uXLvapSa+vSSy/1qksS5Qintm3b2kUXXeQ7Zq666iqrXbu2V5szUBFJofWjv68//fSTz1vQ31Dt2Dpw4ICfgK5Tp469/vrr/vp3yy23HHd7EuVAdCI2R6QQmyM1IC5HSiAuRzSisjyRgj6oa9eutcqVK3vPVG0TVwsWJcgfe+wxb5ExaNAgr4jLmTOnV7/RQxXJSYNjBw4caDNnzrSqVavaBx98ENqGp7UGJId/m6ug4Z6lSpUKfa8BjFmyZPnP2wH/VbmiPuTajXX33XfbypUrbfPmzXbjjTf6Sefs2bP765z6EI8ZM8bef/99dmwBUY7YHKkBsTlSGnE5wom4HNGKZHkSt9vNnj3bP3fv3t0HjU2ZMsV7qdarV8+eeOIJv17sFi0MVkRyiJ2QPP/88z1p1KVLF6/ALFKkCE8ykjUYP3jwoPcj/7fgnEGKSE46CfPdd995grxHjx5eUa4TgwsWLPAhskqYa03G/pvKGgRAbI5IITZHSiMuR6QQlyMa0YYlCdQv9dZbb7W//vrL36Rr0Jiq3jRoTJW+6k0usXuZM1gRyUGJciXI1aP88ssv95M0ixcvtpdeesn++OMPnmQkWTA09u+//7abb77ZfvjhhwSHxQaYw4DkNHjwYO+Br9e1Q4cOeSW5kubayaV2LEqcKzER+28qaxAAsTkihdgcKYm4HJFEXI5oRLL8FMRPEk2bNs0r3D7//HPvTy6nn3663XTTTXbDDTckeBsguQwZMsTOOecce+WVV7xVgRKaSijpGJDU7XZKPK5evdqDo++//9569epl8+fP/9eEOZBY8ed4DBs2zGd/6O+rtrSLXt804FNtf/bu3UurKQDE5khViM2REojLEW7E5QBtWE65V5OqLP9fe3cBJmXB/X38qLSEiNLd0h1SgnSHgEgjndIISKfwgtLto3SDpIAiPJR0SksLC0izpPpe5zzvPe8uoWzN7M58P9flxe7sjH/+6/3cc+bc5/6dp0+fWuRK5syZ7Wd58uSxYn358uWuCAz9IK855U5jidxeuOP4dHDMIaR0cbHuX9CIKd3HoMtknSiM/Pnzc4wh1M9fepeWxq7o+2upUqVcU6IrVqyQVatW2XGndKJcdzLw/gr4NmpzhGfU5ghN1OVwF+py4H/ILH8FTg6qTrc1atTImuC//fabVK9e3abflN4arreDL1iwQFKkSOF6LU1LBMeLsncDHksv+xoILe3atbOm5OTJk+17jWGZOHGinD171iansmfPzi8bIeacv/T9VXcupE6d2qKk4sePL7Nnz7YL0Pq+u3btWlviWaRIkedeC8D3UJvDU8dcQNTmcBfqcrgDdTnw/xHD8gq0MNLJSm2Ot2zZUr799luZO3euzJs3z/LJ1Z49e2wqbsCAAYFeywd5BPdWu0uXLlk277lz5yyfXI8l55aogMcVxxhCQ8BoFf36/v37EitWLNf3OtVbtmxZi2TRZbIayQKElJ6/rl27Zg3xbt26yfr1622Jpy731K+VLs3WO7iGDRv23GsB+CZqc7gTtTncjbocnkBdDvx/TJa/ZGpA36C0MHKWh/3000/Sr18/2bx5s+u5muerWdGaGV2vXr0X3nIHBMf+/fulQoUKEiNGDHn33XctA799+/b2/YsmW4DQoLsXtEGud8/oeU1zytetW2eLZJU20LWpqVO/Dx8+lFGjRkmcOHH45SPIAp7HTp8+bceVNsh1mafuAtE7tObMmSOHDh2SrFmzPvcaAL6D2hzhAbU53I26HO5CXQ48j0+dL5ga0IZQr169bIpty5Ytrg3nd+/elePHj9v3Gk+QNm1aKV++vNy5c8f179BGuf57gKBypsb9/f1l0qRJ0qdPHzl27JhUrFhRtm3bJoMHD7af6TH67NINIKT0vKcT45988ontXGjevLl89NFH9v3KlSvlwoULdguoZkVrM/PHH3+Uq1ev8otHkOnFaD2PHTlyRL777js7jvS9UyfMCxUq5GqUK71bSy/YKM59gO+hNocnUZvDU6jL4S7U5cCL0SwPcJLQD+va+Na4gRs3btg0pTNRmSZNGlvsqZm92jTX5rm6ffv2c79UJssRHNoI0igfjRvQY6xq1ap2LOmCRW1OaqavXsDR4onpSoS2qFGjSpUqVezrNm3auJZ5avyUxk3p3TOHDx+2HOkaNWrI22+/bYsYgaA2HvQWT42Z0rtn9Gt9z9VGeYIECWz/h9Mor1+/vi3V/vDDD12v59wH+A5qc3gatTk8hboc7kBdDrwcMSwBaHOocOHC1qx0ltopbZJrHMvevXulTJky9sE9YcKE1ijSW8Q1r9yJawFCskxD71jQ5uSaNWvseHOWKGpmuV6o0az8xo0b29QvEBrHnMZeaEHunOtWrFghU6dOtaiVCRMmWPSPLjSOGzeuRa7oB0eNX9G7HzSWSs+FQFD4+fnZklg9/vSOGaV3LpQsWdIiVzJmzGgxZ3pnjWbj690MRLAAvonaHJ5CbQ5PHG/U5XA36nLgxZgsD0CXiWmDyGmUO7feaSNcm5U6Za7L7dKnT29vZMmSJXM1yoleQXA8u7BT71jQyIty5cpZTrkullXaLNLlshqT0bRpU37ZCJUpAp3mzZw5sytuSs9lGvvTrFkzmyLv3Lmz3W2TOnVqa5afOXNGBg0aZPsbdMExjXIE5UOg84++x+rSzg0bNth7q9L3U71AqM1yzc0vUqSILfrUc59exGGiHPBN1OZwN2pzeOKYoy6HO1GXA/+OyfIAdNJt2bJlsnHjxhcu6tTbwXX6LUeOHIEeZ6kngsM5bk6cOCEzZsywZpBGW2jsitKIAs303b59uyRKlCjQa5myRHA5x47eFaOxFx06dJBNmzbJ0qVLLQ5D6fLOsmXL2rGpdzFoc1xptvQPP/wg+fLlkwwZMvAfAUFy69YteeuttywT/6uvvrILgx9//LHF/mhT/EV4fwV8G7U53InaHO5GXQ5PoS4H/hmT5QHoVK/GDegHeW1i6hU35UyNa9Ny7dq1rkk4BxnleBXO8eT8qcfN0aNHLfpHjzltRI4ZM0ZKlSplP1+1apVNWaZKlcou1AT6H+7r/E8XwV+UdvHiRYv40cgVjfYpXbq0TZTrJK+KFi2aTZx/+eWXtmjWoXfe1K1bl0Y5gkz3MOhdWUOGDJGYMWPKZ599ZrsYdLpcI310etw5RgPi/RXwbdTmCEvU5vAk6nJ4CnU58O/ouAWgt30nTZrUJt60eam3QwWcalu8eLFNXL5sAg74J6dPnw4UuaLNIW1GtmrVSsaNGyfTpk2zZqVGXTRs2NCeo9O+Ovmr05hASOm5TI+vn3/+2bKiP/30U3tcIzG0Wa4LPrt27WoXbPbt2yd16tSx5rpzS7LiQg2CQ6NVdGHsgAED7D1WG+aff/65ZMuWzWIWRowYwRQ5gOdQmyMsUZvDk6jL4SnU5cC/o1keQJYsWaRo0aIWM6AL7JwJc22Y6zTlwYMHpXfv3q/wawUC0/xnnaLUjGhnglLzoXWixVkOq3cs6OSuNs41fuX333+3n2mDyTkOgaBOSz3riy++kAYNGlgzXI9F53j85ptvpF27drZkVvOjNZpFjzsifxCS48/f39/1mC4n1sgpzcIfPXq0Feo9e/a04+3GjRtciAHwHGpzhBVqc7gTdTk8ibocCDoyy/8fpyGkJ5JevXrZ5KXmk2sERtSoUeX+/fvWPNKpcjJUEVQPHjyQmzdvSuLEieX27dsSJ04cO+Z0Wef58+ctisChWdI6ba5T5e+++y6/bAT7fKbnKj32zp49aws6kyRJ4mpafv/997afQSd7X9YQ10a6czEHCKorV67YBeZKlSrZXQsOXQ5br149i1/Rc6Aeoxr9o3fd6Huwc/cNAN9GbY6wRG0Od6EuR3hAXQ4EDc3yAAI2jDRLeuvWrdZsSp48uWX66pQlzSO8qoBNH+drbZjnzp1bunfvLi1atHDlhRUsWFAGDhxox5rGYOiFGl1+R9MIQeVczNM7Y1q2bCl37tyRdevWWc645uOPHz/enqcNzAMHDsjq1attcg8I7ffR48ePS7du3SxyRZvj5cqVs8c1zkyXyeqFwfnz50vNmjWfO2cCwLPnFGpzhBS1OdyNuhyeRF0OBJ9PNsufnQwPeBL5p8gBJsoRVAEvrvj5+VnjcsmSJTJy5EiLV2nSpIlcunRJKlSoYMde9OjR7R/N8NW7GIjAQHDObXqcFShQQIoVK2YXZbQ5qY3xHj16SPHixe0YVJUrV7aGpX6fM2dOftkIleNPM2D3798vNWrUkF9//VWGDh1q8T56R0PZsmXtuf369ZO0adPKxx9/zN0LAKjN4TbU5nAX6nJ4EnU5EDI+2Sx39O/fX/r27evpvwa81KNHj2xivFOnTlKoUCHLw9emZPbs2W26V48/XXTXqFEjyys/duyYNZoyZsxoF2y4iwHBoXcr5MiRwxqVukA2oF27dtldMjrlO3bsWNfyNI37cRroQHA4F/b0oowuiO3SpYs1x/XY0sa5ZpRfvXrVLspoLNCpU6fkl19+sUlyznUAHNTmCEvU5nA36nJ4AnU5EHI+G0arH9T1Qz0Q2vS4SpMmjUUPaKP8008/ta8HDRokefPmtefotK/Sn2uzqGHDhpI1a9ZAb3BkRSOo9LjRY0pz8XWa1/lgqHsXlB5/gwcPlunTp9sdDZph/t///tdeB4SENsovXrwo5cuXlz59+kjbtm3tuNJjUS8AarNcl3vqPhBd7KkxZ05GOec6AIraHGGF2hyeQF0OT6EuB0Iuki/dguIM0esHdL3925mk1KlejbxQxF4gpMW4NsW1MaQNcs2F1uNLs8oTJkzoOsZixIhhedL6RqbTlwkSJHDFE6iXRQEB/0SPmxIlSlgMS7NmzWxCL1myZIHOa3pR5siRIzbp4mR36s849yGkNNInU6ZM1ijXpdiaRa6NcI2g0rtodNpc/3EwUQ74LmpzuAu1OTyFuhyeRF0OhMzrvlKMa3OoXbt2UrFiRZtu27t3r+s5TqNc0aRESGgjctSoUZI0aVL5448/JE6cOHbsLViwwGIxpk2b5jrGNJu8WrVqsmjRIilZsiS/eISIczGwTp06UqtWLbl165b07t1bLl++bMecTpgrvVCj07+6TDbgMkXOfQgpvaPm5MmTFu2jF//0/Ne+fXuLYtGC/dnjlYlywDdRm8OdqM3hCdTl8DTqciBkvL5Zro3yo0eP2rSlfmAvU6aMrFq1Srp27Wq5qY7PPvtMmjdv7tG/KyIubXhr/IU2HHWS9/r163Y8aSZ+4sSJ5aOPPrKccp0m14s1qlWrVvLDDz9I9erVrWmkU5ZAcDmRFkovzNStW9emx3Wp54ULF1xRLGPGjJG33nrLLtYAIWl2KX9/f1veqd+nT59e5s6daxds9D1Wv9YLgXrXgj7v2eMVgG+iNoc7UJvDk6jL4U7U5UDo84kFn9os0saQs8wzderUUrVqVZsAvnfvnsVlHD582HJVmXRDcGzYsMEWJ/bq1UsGDhxozSHN7T148KAUKFDAYglix44tU6dOtbxyXfx55coVW+oZ8M4GIKScaBW1ePFimT17tsSNG1cmTpwoHTp0kB07dtiiTz3XBXwuENSpUH3f7N69u8Ws6AJjfV/VP5WeAzWKRc93enfNnj17eH8F4EJtjrBGbY7wgLocYY26HAgbXj9Zrn799VdrFqmcOXNKvnz5rFF+5swZ2bx5s51gsmTJYh/knatywKvSppBOT+qxNGLECGuY64T5gAEDrCmuCxTHjRvnypHWRqXm9p44ccIa5RxzcMcki95Zo8fizp07Xec6GuUIDifa7IMPPrBznN6ZpbE/ekF69erV9hy9EKjNsHPnzsnu3bt5fwUQCLU5whK1OcIL6nKENepyIGx43WT5i5bUaeyA5qVu27bNpnynT59uj2uur2ZLa+McCOnVXF3kqU3xzp0723S5Ns31eBw+fLhs2bJFChcubDEszoWbgK8FwnKSReMw9Pyni2edyB/uokFw6cS4xkilS5dOvvjiC3tM78yKEiWKxI8f35rmmluuS9X0QrSe4zjmAN9FbQ53ozZHeENdjrBCXQ6Ejde9rTDSRvnvv/8u69evtz/1jSl//vwWhxEtWjTp2LGjPbd+/fq2iOzLL7/09F8bEZw2gvT40mzy27dvW1O8X79+Fk+gx6P+qY2jZcuWyYoVK557LfCqXnZtM+Dj2pR4dpJFM6THjh1LoxyhQs9bFSpUkNatW1sTPG/evFKoUCGZOXOmnQv18a1bt0r27NntuXpMcnEG8E3U5vAEanO4A3U5wgPqciBseM1kuXO1VifZdInn22+/bR/i9fZwjb7Qyd5Zs2ZZfp1GsTx48EBWrlzpisGgaYng0mNJF3hqQ1xjB7QxpBdrKleuLN26dXNlmGt2tEZiPHvnAxBU27dvt3NchgwZXBN7L8sfJ5ccIRXwPdI5nh4+fGgXoL/++mv56aefZPny5fZzPRcWL17cJs851wG+jdocnkJtDneiLoc7UZcD7uEVXTttFumHd82EnjNnjt0WrlmI9erVkyVLllj0gOaqavzKzz//bEsW165da41ybajTKEdI6PJY/UCojSOHXrAZNGiQDB482GJZtGmkdzPon87kLxAcFy5ckGHDhtnyTs2FdhrluXLlkm+//fa555NLjtAoyPU9tWvXrlK7dm2ZN2+eXL582X6ui4r1GHv8+LGd4zSKxWmUc64DfBe1OTyJ2hzuQl0Od6IuB9wnwjbLdUL8xx9/tK/1Q7mfn5/FrRw/ftyW2qk+ffpY03LdunWWW64f7lOlSmWL7vTDPbeGIziebQD5+/tLggQJbGGnTrI405RZs2a1xZ+63C7gDRxMWyIkkiVLZhdgjh49auc2bZjr0mI93ho2bMgvF6HKaZTrtLieuzRy5auvvpKePXvaBerq1avL999/b8s+9+3bZxdsnEY55zrAt1Cbw1OozeEp1OVwJ+pywH1ej4hX07Q5+c0331hGtCNq1Kj2IX716tV2hdehk3DlypWzBXdOc93BB3kE5/jT40YvvOzcuVMuXrwoMWLEsIxejVkZMGCA7N+/3547f/58qVixomzatClQfjQQUkWLFrVz2y+//GIXZHRR8XfffWc/00WzQHC8aBJcz3lTpkyRDh062LJiPe50H4h+OIwdO7a97549e9biWDQGzblji/dXwHdQm8PTxx+1OTyJuhxhgboc8KwIl1l+9epViR8/visvVRvjp06dsqk3Xa7Ytm1by4vW6ZYsWbK4XqfxLB9//DEf4BHi7E1dYKfHW9q0aa0xPmPGDMsi17w6Z+Gds8xOG+raPCI3GqFF4y406kJpZrk2x3VxcbVq1axpDgSHc47Su2P0ImC6dOlcP9OLfjpB3qRJE9v5kT59ersYqBPn+p6sU+UOJsoB30NtDk+hNoenUZcjLFCXA54XoSbLtUmZMmVKWyamjXJ9c+rVq5dlQ2uDPE6cODJ+/HipUKGClC1b1j7IOz755BMyVBHiN6xr167JqFGjLOJHp3o1k7xNmzY2eam5+GvWrJGZM2faczR+xZmyJDcaoUUb5dog14zyYsWKybJlyyz+Qs992uQEgsNZ2pkpUyaLL9P3W0eePHnk5MmTkiNHDsmePbs1ylXfvn3tbq6AmCgHfAu1OTyF2hzhAXU5wgJ1OeB5EapZnjx5cmnevLk1vjXaQt+ctFn59ttvy8SJEy2/V28L10alRq9ohq/eHh4QH+QRHE6jvEuXLpaPrxPkSr/v37+/9OjRwxbIxosXzxpKOnmumWJ6a6gzZQ6EFo28SJIkiV2kyZYtmy1d1GVW+hgQXDpVrpFm+r6pd2JprIrSqBWNMtOL1Bo1pXSB9unTp2XIkCH8wgEfRm0OT6E2R3hBXY6wQF0OeFaEi2HRqBVtkGtjcuHChVKiRAm5dOmSxa9o0dSyZUspXbq03Lx5UyZNmiTdunWzpiUQUnv27JERI0bIqlWrZNasWVKlShXXz8aOHWuZvitWrLA7GwB3b0V3EPmDoHCOFyc+SpviZ86csTtnduzYYRehdZp88eLF8p///EfOnTsnKVKksN0ha9eutbtnnj0GAfgWanN4CrU5whvqcoQEdTkQfkSYZnnABtCNGzdk6NChlhUdsGHerl07mxxv0KCBVK5c2fVaPsgjOF6Uvav5+HrsaVa+TpXrhRmHHouaG80kOUL7uAt4/nvZ10BQOO+Lzx5vGmn2xRdfWKSULvPUC4D6mN7BoLnEt27dsru6dJpUXxdwRwMA30JtDnejNkd4OOaoyxHaqMuB8CdCNMudk0fABRr6xqXNym+//dbVMP/999+lTp06UqhQIW4NR6gcc8ePH5elS5fapKUuudNj6+7du3Z8nT9/Xjp37iwlS5YM9FqaRwjpcacX/zQjOlWqVJI4cWKb3mVxIkLbvXv37LymF5g1A18jpJTeqaWlgebgf/TRR7a8WJvn2jAPiGMS8F3U5vDUMUdtDncfc9TlcAfqciB8CffNcufD+NGjRy2LXKco3333Xenevbvlk2uz8rvvvpMFCxZYTvT169ctw5xscoSULoj94IMPpFGjRnLo0CE7pjQXWiNX7t+/L6NHj5adO3fKhAkTLNMXCA379++3KJ8YMWLYuU7vkmnfvr19T3MSoWnYsGHSs2dPi1l5//33bUGs7v/Q5cQ6TT58+HA77mrWrGkXDY8dOyZp06blPwLg46jN4SnU5nA36nK4C3U5EL6E+wWf2qDUCQJtWiZKlMgm27Rxrn/qpLneLt6kSRP58MMPLbfunXfesddoIQ+8ihddL9LjR/PJmzVrJl9++aVNVXbs2NEmfMeNG2cNI11wp0vwcufOzS8aIeKcrzQHWnct9OnTxxqTOvW7bds229OgP+PchtCk5zTd86HvsXouS5AggV2AnjZtmk2V67lO6d1beoFa73QAAGpzhDVqc3gSdTk8gbocCF/C9WS5kwemU5VRo0a15qVGXBQoUECyZMliy8b0OQ8fPrSFn61atWLJGIJ1e92jR49k79691gTXaV49rnS6V/9p06aN6/lfffWVTJkyxS7M6JS5g4lfhJTGSGmkT86cOe0uGm1c6gVBvXPhxx9/tMe1Yfnmm2/yy0aoefLkicWX6d0zmzdvtrtmNm7caMfgwIED7YKNE3+m2AEC+DZqc4Q1anOEB9Tl8ATqciD8CNeT5c7iOs1v0ga5ypMnj6RPn94a5bpsce7cudZI14xVbXpqMx14Fdrg1mNGM8jLli1rF2N0otL5IKh3L8ycOVOuXLnieo3GEWgT886dO4H+XcT+ILic65V6V0zq1Kll3rx5rmNOm5R6saZUqVIWizF79mx+0QhVerfM/Pnz5b333pN8+fLZOfHTTz+Vn3/+WapXrx6oUa705wB8F7U5whK1OTyNuhyeRF0OhB/hbrLcmSa4deuWvPXWW/ZYhw4dZMeOHfbmpdOVkydPtsc1BkOjWbTJCQSF0xDXRrnGqGiz/Ouvv7ZJXr34ovbt2ydDhw61CzD9+/eXdOnS2d0Lly9ftlgW5wMjEBwvuxtBJ3l1ylfPeXp+U3pcLlu2zJYtcmEGYfXeW6tWLVvmqcde8uTJXedJAL6N2hzuQG0OT6IuR3hCXQ54XrhqljvF+OHDh22yTRePValSxZaO6ZJFbV7qAs8HDx7YtKV+r4vIIkWK5Om/OiIgPfQ1k1wbkbok9kXF0rp162yaVycvixQpYrnROnGpV31pJCGk57oTJ07IjBkz7HjTxcRdunSxn2v8z5EjR6xx6TTMX3R8AqF9XGoky+LFi+32Y72LBoBvozaHO1GbwxOoyxEeUZcDnhWumuVKG+XFihWTHj16WEM8RowY9rg2xYcMGWI/z5gxoxVTS5YssaYlGaoIDp0Yr1y5si240z/1e+fCi3NMOY1JzTOPGzeupEiRwr4P+Fzg3zgXVgJeYNFFxXqu02le3bugF2YyZMhgcSuqUqVK9vWlS5ckXrx4/JLhFnru69u3r91NQ+QKAEVtDnehNoc7UJcjoqAuBzwnXDXLdaHBxx9/bNmpgwYNskalTl3qJLk2jlKmTGnxBAkTJrTmEU1LhITmjmsWvjaGateu/dykuGbljx492qJXNE/awWQvgkr3K+jy2IAfBvWuBo260Kakunr1qrz//vtSqFAh+fbbb+05vXr1souENC0RGvQcp/+86p0JXIgGQG0Od6I2hztQlyM8oC4HwrdwdS+/Nipjx45tsRirVq2yfPKVK1daJrlm9WrzKGvWrPLuu+/ah31tWjLdi+DSxXVx4sSRjRs3uo4/fdNylsRGjx7don7OnDkT6HVEYCCoE3klSpSQa9euuY4tPW/pseacv7QZET9+fBk3bpzFr2gEhv5s+PDh1ijXpiUQHLNmzZKFCxfa13oc6flLj71nz2svwkUaANTmcCdqc4Q16nJ4EnU5EHF4tFmuze6AtDmULVs2+emnnyxDulSpUrbUbufOnbbsU5tNAdG0REhEixZN+vXrJ9OmTZOxY8e6PhQ6DczmzZtbRrkuAAWCK02aNLYwUS/y3b9/P9DdCZs2bbLvNU5KJUmSxI5L53sHTUsEh1541iXGurx46dKldm7Thnn69OntvRUAnkVtDk+iNkdYoy6Hp1CXAxGLx2JYnNu7z549a9O7t27dksaNG9vPLl++bPnQWjCp+vXri5+fn/zwww+BYjKA0KDTvJ999pk0adLElnjGihXLrvrq8sU9e/ZY45LoFQRFwEgf5+ubN2/ahZfu3btLixYtrImpTcuCBQvKwIEDLZKla9eucuHCBbujhnMdQuuW9kWLFsmcOXNsD4jeqaUfFGfOnMkvGEAg1OYIL6jNEZqoyxFeUJcDEYdHmuVO4/HgwYNSrlw5++CuDSKNYFm+fLllk2vBvmHDBpv61aalLvikaYmwossVtWF548YNSZcunSROnFjGjBljk5gs80RwBDxu9GKfFke6lHjkyJEWr6IXZ3R5Z4UKFeycqLE/+o8u9eRch9A2ffp06dixo12wcaKndMJFb3kHAGpzhDfU5ghN1OUIT6jLgfDvf50cN9NGuU6UV61a1RbYtW7d2j606yS5LvjUqV5nGZ7m+M6dO5emJcJU6dKlpVixYpYdHSNGDFfEj160IRcfQfXo0SObGO/UqZMt7CxatKg1yrVZqc1JfVyPsUaNGsmuXbvk2LFjdqdNxowZWVyMMPlgOH78eMmSJYt9r3dplSlThkY5ABdqc4Q31OYILdTlCA+oy4GIJcwny18WX/Hjjz/a0rFJkyZZo1wbSrly5bKlG/pX+uabbyRDhgzP3RoKeOKWPeBVHDhwwO6UiRkzpl30+/TTT+3rQYMGSatWrew5moM/efJku5Nh9OjR0rBhw0D/DiJ/EJr0vTNPnjzWKNfoFY1jGTx4sB2DhQsX5pcN+CBqc0RU1OYICupyhDfU5UDE8XpYnwy0Uf7gwQOLVFmxYoVdUVMffvih9O7d276uUaOGRV/oh/fq1avbMrwBAwYE+nfRKIe70ShHUAtybYrr/gVVqVIlu1NBs8oTJkzoalDonQstW7aUvn372p6GtWvXBvr3sLgYoUnz7zXuzMko14lyzS3XOx8A+B5qc0Rk1OZ4VdTlCI+oy4GII8wmy51JcM3p1Q/lKVKksCzeWrVqydSpU61hpM6fP28LPHWSPHXq1NKuXTupWbOmTZrTIAcQUWgjXDPIkyVLJn/88YfEixdPjh49KkeOHLHz3pQpU6Rp06au5+u5T3cxVK5cmagfhOi4Cxgb9U/vm89Ok3LHFuBbqM0B+ArqcnjquKMuB7xDmEyWa/9dP7DfvXvXlomVKlVKVq9ebYs6V61aJd9//73ruXHixLHnd+7c2SYx16xZ42qUa1EPAOHZokWLXBnk2ii/fv26NG/e3CbHdVHsRx99ZHnROk0+Y8YMe41GsmhutN5J4yyRBYJK3zv1uNOLNOrZ981nr4U/e9cCF6QB30FtDsAXUJfDU6jLAe8SZpPlukhDm946XalNIYcu8NSGki65S5UqlU1azps3T/bu3WtNJo1iiRw5Mrm9ACIEjZjSJVS6rFhzyHWioE+fPnLw4EEpUKCAtG3bVmLHjm131LRo0cLutLly5Yot9dRzHRCSCVG9KK3vq/q1cyGaiXEAL0JtDsDbUZfDE6jLAe8TZs1yPz8/m5p87733bIFdkSJFLLO8SpUqMnz4cNmzZ4+cO3dOWrdubTEsL9sUDADh/Va7LVu2SMmSJe0OGV2eqI/reW7z5s127nMa5nre0/gVjV5xpoCZ7kVwj7tDhw7ZHQyai79161Z7f9XF2YpjC8CzqM0BeDPqcnjyuKMuB7xLmDXL1enTp6V9+/a23E6nyceMGWMf5HW5571796yZro2kL774Iqz+CgAQZpyGpC7yHDdunDXLdbpcp8ydhrk20gsXLmwxLHHjxn3utUBw6EWX/PnzS//+/e09VY+ziRMnWvTPkiVLOMYAvBC1OQBvRV0OT6EuB7xPmGSWO9KkSWMNcp1kGTVqlPTo0cM+1KuYMWNK9OjRLY4FACIibXZr3Io2KG/fvm1N8X79+kn37t1twkD/1AuCy5Ytsztrnn0tEFy//fabpEuXzvLx9b22bt26dqFm//790rhxY9cxphdtAMBBbQ7AW1GXw1OoywHvE6aT5QGvtGncSvz48aVJkybWUNIP85pTrrEERK4AiIgePHhgCzy1Ia4XA7UxuX79eotZ6datmyvDfPbs2dbMfHbBIvCqnr0TQS++6J1bmn0fNWpUWyp0//59KV++vE2OFitWTObMmcMvGMALUZsD8DbU5XAX6nLA+7mlc5M8eXL5+uuvbcL8m2++kaJFi1qTfPfu3dYo15MNAEQ0eneMNimjRYvmeqxMmTIyaNAgyy7XWBZtkOteBv2TKV8ElzbKdWpF435UpUqVLAdfc8rVa6+9ZndspU+f3nLM9f12wYIF/MIBvBC1OQBvQ10Od6EuB7zf6+6+7VOn4LS5pM3yyJEj2zJP4ggARATPNrv9/f0lQYIEcuLECZtmcSbHs2bNags/9YJgwJt3mCxHcOlxtG3bNsvD//LLL+2xRYsWydmzZyVnzpwyZMgQu6NBY1hq1aplx+rhw4f5hQN4KWpzABEZdTk8hboc8H6R3F2UL126VN555x1rGmmjnAgWABHpdrvLly/LhQsXLKc8adKkFjGljfE4ceJI7dq1JUeOHDJ//nypWLGixWQ4BZVO/gJB/RDoXGDR40ePqcePH1u8jx6LeufCvn37pGPHjnZc6jGp0+R6p0PKlCnttc7FGo4/AC9CbQ4gIqIuh7tRlwO+xS2Z5f92sgGA8Mxpdusyz+LFi0vatGltgnfGjBmWRb59+3Zrmge8ALhz5067e4ZGOULiypUrcufOHYtXUbpIVifKNepHL8Zoo/xZOnmu/2zdulUyZMjAfwAAr4TaHEBEQF0OT6EuB3yHWyfLA6JRDiAiFeTXrl2TUaNGSZ8+faRDhw4ycuRIadOmjS1VbN68uaxZs8YKqJs3b9peBp385e4ZhGRaSo+tOnXqWBb5iBEjJGPGjHYHQ82aNS3STLPJNQpIo1mU5pSvXr1aJk+eLOvWraNRDiBIqM0BhHfU5XA36nLAN3lsshwAIgptlHfp0kWuXr0q33//vU2MK11c3L9/f2tkNmjQwPX4i7akA0H5EKh7PTTOR5vlzZo1s8nyL774whrg2tCaO3euTJkyxTLz9WsnZuXixYsSJUoUiR8/Pr9wAADgdajL4S7U5YDvIgcFAP7F+fPn5dGjR7Jlyxab3HXohLk2y7WZqZO8AdEoR3AiELTpfevWLYtYiR07ti3vXLx4sfz6668ydOhQ+eWXX+y5GrFSvnx5V6PcWXKlOfo0ygEAgLeiLoc7UJcDvo3JcgB4hdzWU6dOWbNSl3vqlHnp0qVdP1u4cKFUq1aNhcUIsTNnzsj/+T//x+J8Zs2a5ZoYP3funDRs2NCiWe7du2fT4zp9rhn55OIDAABvRV0OT6EuB3wXzXIACMCJTzl+/LgsXbrUiqSKFStKoUKF5O7duzJkyBCbaOncubOULFky0O+OjHK8qpc1uA8fPixly5a1Y01z8N9//33Xz65fvy4HDhyQGzduuC7OEPcDAAC8FXU53IG6HMCzaJYDwDM08uKDDz6QRo0ayaFDh2zKPHr06DJ27Fib7B09erTs3LlTJkyYIHnz5uX3h2BNSD18+FB27Nhhx5Iu7ixSpIhkypTJ7mKoUqWK5M+f35Z3pkmT5oX/HhrlAADA21GXIyxRlwN4EZrlAHzWi6YItGD69NNPJXHixDJ48GB7bMOGDTJ9+nRJnTq1PbZ9+3bZtm2bdOzY8bm4FuCfOA1unRyvUKGCJEmSxD4ExowZU3bt2iXjxo2T5s2b22M1atSwOxp69uxpxx4AAIC3oi6Hu1GXA3gZujwAfLY40ka5Lu7U5ve1a9fscX3Mz8/PmuUOjVvRKV+NZXnw4IEULFjQYli0Ue4sVgT+jR4r2ii/c+eO5MmTR7JkySIzZ86Uffv2yfr1621ZbMuWLWXq1Kk2YT5//nybPO/atav8/vvv/IIBAIBXoi6Hu1GXA/gnNMsB+GxxpNO9mg89YsQImTZtmmuiJVu2bNbEvHLlius1NWvWlAQJElijMyAmy/Gq9Fjx9/eXrFmzSqVKlSzGR3PHnZifzz//XAYNGiRt27aVo0eP2nGoSz6jRYsmCRMm5BcNAAC8DnU5PIG6HMA/oVkOwKdoQ1yLI22U586d2xqXixcvlk6dOrkiWWrXri3JkyeX1q1bW2a5Zkv37t1bokaNKvHjx/f0/wuIwHSCXBvmAe9c0Gkq59hs37695MyZ0+520A+POXLkkNmzZ3MXAwAA8DrU5fAk6nIAL0OzHIBP0Ya4FuaaN16gQAEZM2aMPaaNcCdSRZuVTZs2lVixYtkCT50CPnHihKxYscL1eiA4ihYtKiNHjpQ5c+bYBRildznosafHlk6R6xLZe/fuPXfXAncxAAAAb0JdDk+iLgfwMpFe+hMA8FI6yasZ0JoPrZ4+feqKw3AWvWhOeenSpaVDhw4SN25cSZEihf3ceS4QHHosVa1a1ZrjusxTjzXNKtc/lT6ueeW5cuXiFwwAALwedTk8hbocwMvQ8QHgczQG4+zZs7asUzmNSudrneodPXq0tGrVKlDTUhuZNMoRUnHixJHq1avb19ow1w+JmlWumjVrJn/88YctkQUAAPB21OXwJOpyAC9CsxyAz4kSJYoVRhs3brR8cucWUG1aajNcly3u27dPzpw5I++8847rdcRgICwK8/Hjx9v3p06dkv3798vu3btd0SwccwAAwJtRl8PTqMsBPItmOQCfo7nQ/fr1kwoVKkjmzJmlXbt21jB3psabN29uUy66ABQI68Jcj70uXbrIu+++KwcPHpTIkSMT9wMAAHwCdTnCA+pyAAG99jeb6gD4KI3A+Oyzz6RJkyZSpEgRW+g5a9YsW+a5Z88ea1oy3YuwdvPmTdm2bZuULVvWJsrJxQcAAL6GuhzhAXU5AEWzHIBPW7dunQwcOFBu3Lgh6dKlk8SJE8uYMWNsypymJYLr0aNHEjVq1EDxPq/CWTALAADga6jLERaoywEEFc1yAD5PC6gnT55IjBgxXBnRNC0RXGvXrrU7E9q0aSNvvfWW63javHmzFC9enF8sAADAS1CXIzRRlwMIjv91hQDAh+kEcMyYMV2Ncp0GZroXwXX58mU5d+6cTJ8+3fVYlixZZMqUKfxSAQAAqMvhJtTlAIKDyXIAAEKZZt/rdHmSJEns67x588rUqVP5PQMAAABuRF0OIKholgMAEEr0roTXXnvNVZh36tRJkidPLrt377bHHj9+LFGiROH3DQAAAIQh6nIAwUWzHACAUPLXX3+54nzy5Mkj0aNHt6nyNGnSSM2aNSV+/Pj8rgEAAIAwRl0OILjILAcAIJRoo1wL82zZsknWrFnlv//9rxQqVMiWe27cuJHfMwAAAOAG1OUAgitSsF8JAACec/36dalRo4b07dvXvq9atarEjh1bPvzwQ35bAAAAgJtQlwMIDmJYAAAIg9s9X5RR/uzPAQAAAIQ+6nIAwUWzHACAV/Tnn3/KG2+88Y8LhAAAAACELepyAGGFZjkAAEGYTjl27JhMmDBBUqVKJdmzZ5cSJUrYz2mYAwAAAGGPuhxAWKJZDgDAKxbkJ06ckHz58kmZMmXEz8/Ppszr1asnjRs3tufRMAcAAADCDnU5gLBGsxwAgFegzfG1a9fKzZs35bPPPrPG+cKFC2XlypXSvHlzGuYAAACAG1CXAwhLkcL03w4AQASn0+KaiVi4cGE5d+6cfPnll/Z4+vTppW7dujbdMmPGDLl//760bduW7HIAAACAuhxABPW6p/8CAACE1ya50sWdkSJFsqnyRIkSyU8//SQPHjywn6VMmVIaNGggBQoUkEOHDrleAwAAAIC6HEDEQwwLAADP0ElyzSO/e/euRI4c2aJXtFF+5swZyZ07t5QrV04mT54sMWPGtOdfuXJFEiRIYI11cssBAACA0EFdDsDdmCwHACAAjVXRRrlOipcvX14qVKggRYsWlWnTpkmqVKlkz549NmXeunVra6arhAkT0igHAAAAQhF1OQBPILMcAID/V4y//vrr9s/58+etUd6tWzebJN+/f7+0adNGbty4YY/t3LlT0qVLJ2nTppU+ffq4fn86WQ4AAAAg+KjLAXgSzXIAgE+bO3eulChRwmJUHNu3b5fs2bNLu3bt7Pv333/fpsdr165tU+aaUX7p0iWJHz++B//mAAAAgPegLgcQHhDDAgDwWZovvnTpUpskDyhKlChy9epVuXz5sj3n6dOnUr16dWuaO8/VDHONa9GfAQAAAKAuBxDx0SwHAPgsjU2ZP3++5M2bV06cOCF+fn72eNKkSeX69euyfPlyWyoUKdL/bsTSxrnGtATk/AwAAAAAdTmAiI1P+AAAn8xADPi1/jls2DBrnJ86dcqa5z179pROnTrJyZMnJVmyZHLgwAG5f/++VKtWzdP/LwAAAAARHnU5gPCIZjkAwKdoc9zf39/iVDJmzGgT5du2bZMxY8bIH3/8Ifny5ZNffvlFmjZtKvHixZPVq1fL1q1b5Z133pEdO3ZY9IpOm+ufAAAAAKjLAXiP1/7We8oBAPAhHTt2lIkTJ8qsWbOkQYMGMmnSJPvz8ePHUqNGDdm/f7/s3LnTcskfPnwo0aJFc72WRjkAAABAXQ7AO9EsBwD4BJ0Qv3XrlnzyySf2fenSpeXnn3+2xvnw4cNdz3Ma5keOHJHNmzdbfrlDry9rzjkAAAAA6nIA3ocFnwAAr6dZ47t27ZKsWbO6HosTJ46kT5/ecsoPHjzomhqPEiWKLFmyRJInTy7t2rUL9O+hUQ4AAABQlwPwXkyWAwC82uXLly1O5enTpxIpUiQ5e/asHD9+XMqUKWM/r1KliuzZs0fWrFnjaqZv2rRJcubMKTFjxnQtAwUAAABAXQ7Au9EBAAB4JY1MOXDggLz33nuybNky+/6vv/6SmTNnyueffy5Tp0615y1fvlzy5Mkj5cuXtya5RrB8/fXXEitWLGuU62sAAAAAUJcD8H5MlgMAvFrbtm1lxYoVMn78eKlYsaL89ttvMmPGDNmxY4d8/PHH0rRpU3te3bp15cqVK/b12rVrJXLkyGSUAwAAANTlAHxIJE//BQAACAuaP/7GG2/IuHHjLH5Fm+aaOV6hQgVp1qyZTYzPmzfPnqsN89mzZ8ulS5ckceLE9jwntgUAAAAAdTkA30AMCwDAKznLOE+fPi3Zs2e35rc2xb///ntJkSKFtGjRQvLlyycLFy60hrpKkiSJvU4b6TTKAQAAAOpyAL6FZjkAwCtp3rg2ynVp5+3bt2XEiBFSqlQpadiwoath3rJlS0mXLp2cPHnSIlcCvhYAAAAAdTkA30JmOQDAa+mizm3btsn8+fNdj3Xo0EG+++47mTVrlkWy+Pn5Sfz48W2iXBvmzkQ6AAAAAOpyAL6F0TkAgNd68803bWrcWdyphgwZItGiRZOaNWtaIz1BggQ0ygEAAADqcgBgwScAwLsWegacDk+fPr01xjdt2mRT5DFjxrQGer169SRq1KiSP39+1+uZKAcAAACoywH4tkie/gsAABBSupBTG+XHjh2T2bNnW8O8ffv2UrRoUSldurQMGzZM9u/fL3ny5JHFixfLH3/8IWvXrrUGudNkBwAAAEBdDsC3kVkOAIjwjXJdyHnmzBnJnDmzfPLJJ7JhwwZJlSqV9OvXT4oVKybTp0+Xn376SS5evGj55HPmzJHIkSOTUQ4AAABQlwOAC81yAECEd+nSJVviqZErrVu3lqdPn1rUii7v7NOnjxQvXtyed//+fYkRI4ZNlOtzIkXiBisAAACAuhwA/ocFnwCACM3f31/69u0rvXv3tjxypU3wmTNn2vJOXei5fPlyefLkif1cG+Ua00KjHAAAAKAuB4CAaJYDACIcbXY7dFFn7dq1JXfu3DJp0iR59OiRPa4xK7NmzbKvN27caN87WOYJAAAAUJcDwLOIYQEARCjOQs579+7J48ePJXbs2DYlvnPnTunZs6dNj2uTPFasWK7na3Ncc80BAAAAUJcDwMvQLAcARLhlngcPHpROnTrJjRs3JGnSpFKoUCHp3r27Ncw1kiVKlCjy3XffSZw4cZ57LQAAAADqcgB4EboGAIAIQ5vdZ8+elQoVKki1atXkq6++suWdixYtkq5du0q+fPksu/zq1asyePDg514LAAAAgLocAF4m0kt/AgCAB71sEnzfvn2WT96mTRv7Pm/evJIyZUprnOvEecGCBWX8+PGSI0cOD/ytAQAAAO9CXQ7AlzBmBwAIdzRnXBvl9+/fl1GjRlmkyvnz5+1nfn5+cvLkSddzo0ePLgUKFJDff/9dTpw4Ya/LlSuX/amFPQAAAADqcgB4FTTLAQDhija4dYHnnTt3bEr8119/lVu3bkn8+PHt57Vq1ZKHDx9Kjx49XK9JlCiRpEuXTiJHjhzo30X0CgAAAEBdDgCvigWfAIBwx9/f36bFixQpYpEqjqdPn0qkSJFkwYIF0r9/f8mUKZPUqFFDli9fLkePHpU9e/ZYox0AAAAAdTkABBWT5QCAcGfx4sWSJk0aV6PciVPRRrnS5Z7ffvut3L17V1auXCnRokWTXbt2WaNcI1wAAAAAUJcDQFCx4BMAEO7s3bvXFaHy999/Pxen8uTJE0mdOrWsXbs20OPO5DkAAAAA6nIACComywEA4U6CBAms8f3o0SN57bXXXI87U+NTpkyRVatWBXqNNtVplAMAAADU5QAQXDTLAQDhTrJkyWTr1q3yyy+/BGqGO3nkOnmuSz8DCthUBwAAAEBdDgBBxYJPAEC4VK9ePVm/fr3Mnz9fChYsKFGjRrXHGzZsaMs8t23bxiQ5AAAAQF0OAKGGZjkAIFzRZZ5ORnn9+vVlzZo1kj9/fokSJYpllV+5ckW2b98ukSNHtlgWZ9ocAAAAAHU5AIQEzXIAQLimk+UXLlyQGzduSLZs2aRmzZrWIGeZJwAAAEBdDgChiWY5ACBcTJE7ueRO9vizPwuIiXIAAACAuhwAQhsLPgEAHuM0w2fNmiX+/v6BlnS+rFGuiF4BAAAAqMsBILTRLAcAuJVOjAe0aNEi2blzp8SIEYP/EgAAAICbUJcDwPOIYQEAuI0Tn3LmzBm5fv265M2bN1DcSsAc8oCRLAAAAACoywEgrDFZDgBwC22Ka6P8wIEDUrx4cVm2bJncvn37hY3yhw8f0igHAAAAqMsBwK2YLAcAuM2pU6ekUKFC0q9fP2nVqpU99uDBA4kePbrrOcOGDbPvO3TowH8ZAAAAgLocANzmfyN8AAC4wY4dO6RcuXLWKH/y5Ik0b95c/Pz8JE2aNDJ8+HCJFi2axIsXT5o0acJ/DwAAAIC6HADcihgWAECY0dzxgB4/fizbtm2TTp06WV65v7+/1K1bVyZMmCAbNmywSJZmzZpZXMuzC4cAAAAAUJcDQFhishwAEKbLPDWX/O7du5I0aVKbGNflnm+++aZNl7do0cKeu2jRoucyyp0scwAAAADU5QDgDmSWAwDCZKJcm9/79++Xhg0bWi557ty5ZfDgwZI6dWp7jk6Oa0NcJ8sPHz4se/futeY6AAAAAOpyAPAExvYAAKFKm+DaKL9x44Yt6dRm+H/+8x+bKO/atats3brVnrdr1y6pWLGinD59Wnbv3m2Ncp1GBwAAAEBdDgCewGQ5ACDEdII8WbJktpxTXbp0STp37iwpUqSwxZ1KF3l+8skn8vbbb0uPHj1s0nzZsmVSqVIla5Q/ffpUIkUiHQwAAACgLgcAz2CyHAAQorgVnRivV6+eRa04Dhw4YLEqS5YscT2WIEECmT17tmWY64LPkydPStWqVV0T5TTKAQAAAOpyAPAkmuUAgGDTuJVUqVLJpk2bbIHn9evXbZlnmTJlZPTo0RI1alRb6ulImDChRbLkyJFD0qRJ43qcrHIAAACAuhwAPI0YFgBAiBd5aoSKTpYXLlxYypcvL59//rnEjBlTVq5cKSNHjpR06dLJ9OnTn3u9s+QTAAAAAHU5AHgaHQoAQLBpo1xphEqsWLGkS5cusmDBAvn666/l3r17UqFCBXvs1KlTUr169effhGiUAwAAACFGXQ4AoYNNagCAYNGc8YCLOXXKvH79+va1LvBUHTp0sIb5w4cPZePGjUySAwAAAKGMuhwAQg8xLACAYBfkx44dk1GjRtkkS4YMGaRNmzaWUz537lyLYmnWrJk9Fjt2bNcUOdErAAAAQOigLgeA0EUMCwAgyLRRfujQIcsojxYtmjXCf/zxR2nevLk8evRI6tSpI8OGDZMBAwbIsmXLAsWtEL0CAAAAhA7qcgAIXUyWAwCC7ObNm1K5cmUpW7as9OrVS/z9/SVnzpwWt5IvXz6ZNWuWTZhv2LBBihcvbkU8AAAAgNBFXQ4AoYtmOQAgyC5fviyrVq2Spk2bypMnT6RgwYIWw1K1alV7LH/+/LJy5UqJEiVKoNtDAQAAAIQe6nIACF0s+AQA/Ktnm92JEiWSMmXK2NedO3eWZMmSyezZs+XMmTNStGhRyZQpky36dNAoBwAAAEKOuhwAwhbNcgDAP9KFnNrsPnnypPz888/2dZMmTaxBrh48eCAffvihfT106FBJnjy55ZXr0k+WeQIAAAChg7ocAMIezXIAwD/ShZwnTpyQ3LlzW/74pk2bZNGiRTJz5kyJFy+eRI4cWXr37i0LFiyQa9euycGDB61R/vfff7PMEwAAAAgl1OUAEPbILAcA/OstnhMnTrTlnR07dpQbN25IgQIFJHHixLJ69WqJESOGNcq1QV6tWjWLXyGjHAAAAAgd1OUA4D40ywEAz3HiU06dOiWHDh2Sbdu2Sd68eaVWrVr2c39/f8mRI4ckSZJElixZInHjxnW9lkY5AAAAEDqoywHAvWiWAwAC0fgUnRI/evSoFCxYUFKnTi0XLlyQjBkzysaNG12LOzWrPEGCBNKwYUMZO3Ysv0UAAAAgFFGXA4D70SwHADxXkN+6dUt69uxp0+SNGze2uJUxY8ZY5MqsWbPsT/Xo0SNrnjtxLQAAAABCjrocADzjdQ/93wUAhEPaKNdMcp0W//nnnyVhwoT2eMmSJaVz586WW16/fn25f/++PR41alRrlGv0CgAAAADqcgCIyGiWAwACefvtt+X999+3xvjmzZvFz89PokSJIsWLF7eGuUayDBo0KNBrmCwHAAAAQhd1OQC4HzEsAODjnIWcjx8/tgVC0aJFs8fHjx9vkSu61LNOnTo2Zf706VPZv3+/5MqVyxaAAgAAAKAuBwBv8b8tbQAAn6TNcW2UHz58WD7//HPx9/e3PPJu3bpJmzZt7Dlz5syxeJaaNWtKkiRJJE+ePK7X0jAHAAAAqMsBwFswFggAPrw0SJvdp0+flhIlSki+fPmkS5cutrCzf//+smjRImuYV6tWTSZOnChbtmwJ9Hoa5QAAAAB1OQB4E2JYAMCH7NmzRyJHjizZsmVzPTZlyhTZt2+fNcQdbdu2lYMHD1pmuZo7d67FsZBNDgAAAFCXA4C3YrIcAHxkivzWrVvSqFEjGTVqlBw5csT1s6tXr8rWrVvl0aNHrseGDRsmv/76q6xatcq+18xybZRrvjkAAAAA6nIA8EY0ywHAB2jm+FtvvSUzZsyQY8eOydixY22aXJUsWdKyyJcuXepqhseMGVNy5MhhSz0DYrIcAAAAoC4HAG9FDAsA+IjHjx9LlChRLFqlc+fOkitXLlvkmSJFCunQoYOcO3dOMmXKJNWrV5dJkybZZPn27dtpkAMAAADU5QDgE2iWA4CPxLDodPnevXtl/PjxcvHiRVm/fr3UrFnTYlneeecdmTx5sqxcudKmy+PFiyezZ8+2fHP9nolyAAAAgLocALwdzXIA8BF+fn6SO3du6dq1q9StW1eOHj0qLVu2tAnzIUOGSLJkyex5d+7ckdixY9vXT58+lUiRInn4bw4AAAB4D+pyAAi/6IAAgI/QmJVEiRJZ5IoqUqSIzJ07V4oWLSqvv/66tG/f3prpTqNcp9FplAMAAADU5QDgK1jwCQA+In78+HLz5k1ZsmSJff/XX39JtmzZpFKlSjJ//nzZsmVLoOdrbAsAAAAA6nIA8BU0ywHAi/j7+7/0Z5pDrlPkq1evlq1bt9o0ufP4V199JW3btnXj3xQAAADwXtTlABAxkVkOAF5izZo1smjRIunVq5ekTp36hc/RBZ99+/aVx48fy5tvvmnT5SdOnJBDhw7ZEk+WeQIAAADU5QDgq8gsBwAvoRPiP/zwg0SPHl26dOkiKVOmDPRzzSDXZZ46RX7gwAHZtGmTRbMsXLjQGuXaONc/AQAAAFCXA4AvYrIcACK4n376SZImTSrp06eXPXv2SJ06daREiRLSo0eP5xrmL/P06VOWeQIAAADU5QDg08gsB4AITBd2TpgwwRrkp06dkty5c8ucOXOsgT5s2DA5e/bsC1+nU+YBRYrEjUYAAAAAdTkA+Daa5QAQgcWNG1e6du0qmTNnlkaNGsnJkyclT548/9owf+211zzy9wUAAAC8EXU5AHgHmuUAEEE50+H58+eX9u3bS4oUKaRx48bPNcyHDx/+0glzAAAAANTlAID/IbMcACKQP//886VLOHft2mXLO8+dOyfffPONpEuXTnbv3i0NGjSQ7Nmzy6hRoyRRokRu/zsDAAAA3oa6HAC8E5PlABCBaKP8/v370qtXL9mxY4fcu3fP9bO8efPahHny5MltwlwzzHXCfNq0aTaFniBBAo/+3QEAAABvQV0OAN6JyXIAiGAGDhwoffv2lUKFClmzfPDgwfLee+9JqlSp7Od79uyRESNGyOXLl2XSpEn2M8dff/0lr7/OdVIAAACAuhwA8Cw6JgAQwZQqVcoa3h988IGUL1/eFntq1MrQoUPlxo0bkjt3bhk0aJDEiBFDxowZ42qSKxrlAAAAAHU5AODFmCwHgAioRYsWcvXqVVm6dKls2rTJlno2b95cChQoYPnkrVu3tudlzpyZBjkAAABAXQ4AeAVMlgNABKRN8X379snp06elWLFicvPmTUmSJIl9vWXLFunTp49kzZrVGuXOVDkAAAAA6nIAwMsxWQ4AEZQu9NQFnpkyZZKRI0fK8uXLJUeOHPYzsskBAAAA6nIAQNBECuLzAQAe9vfff8trr70mbdq0sX8SJUok8+bNs0b5n3/+KW+88YZropyMcgAAAIC6HADwaohhAYAIRhvlqkyZMhI3blwpV66cFCxY0Jro2ih30CgHAAAAqMsBAK+OZjkARFA6Ud69e3dZvXq1/Pbbb64mOgAAAAD3oS4HAO9BDAsARGBly5aVvXv3SsqUKT39VwEAAAB8FnU5AHgHFnwCgJdkmJNRDgAAAHgOdTkARHw0ywEAAAAAAAAAPo/McgAAAAAAAACAz6NZDgAAAAAAAADweTTLAQAAAAAAAAA+j2Y5AAAAAAAAAMDn0SwHAAAAAAAAAPg8muUAAAAAAAAAAJ9HsxwAAAAAAAAA4PNolgMAAAAAAAAAfB7NcgAAAAAAAACAz6NZDgAAAAAAAAAQX/d/AV7q7XXS8BqhAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1500x1000 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Create comparison plots\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(15, 10))\n",
+    "fig.suptitle('Ablation Study: Impact of Domain Types on KeepEmbedding', fontsize=16, fontweight='bold')\n",
+    "\n",
+    "exp_names = list(EXPERIMENTS.keys())\n",
+    "exp_labels = [EXPERIMENTS[name]['description'] for name in exp_names]\n",
+    "\n",
+    "# 1. Number of unique codes after filtering\n",
+    "ax = axes[0, 0]\n",
+    "unique_codes = [experiment_results[exp].get('after_filtering_unique', 0) for exp in exp_names]\n",
+    "ax.bar(range(len(exp_names)), unique_codes, color='steelblue')\n",
+    "ax.set_xticks(range(len(exp_names)))\n",
+    "ax.set_xticklabels(exp_labels, rotation=45, ha='right', fontsize=9)\n",
+    "ax.set_ylabel('Unique Codes')\n",
+    "ax.set_title('Unique Codes After Filtering')\n",
+    "ax.grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# 2. Graph size (nodes)\n",
+    "ax = axes[0, 1]\n",
+    "graph_nodes = [experiment_results[exp].get('graph_nodes', 0) for exp in exp_names]\n",
+    "ax.bar(range(len(exp_names)), graph_nodes, color='forestgreen')\n",
+    "ax.set_xticks(range(len(exp_names)))\n",
+    "ax.set_xticklabels(exp_labels, rotation=45, ha='right', fontsize=9)\n",
+    "ax.set_ylabel('Number of Nodes')\n",
+    "ax.set_title('Concept Graph Size (Nodes)')\n",
+    "ax.grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# 4. Co-occurrence matrix sparsity\n",
+    "ax = axes[1, 0]\n",
+    "sparsity = [experiment_results[exp].get('matrix_sparsity', 0) for exp in exp_names]\n",
+    "ax.bar(range(len(exp_names)), sparsity, color='mediumpurple')\n",
+    "ax.set_xticks(range(len(exp_names)))\n",
+    "ax.set_xticklabels(exp_labels, rotation=45, ha='right', fontsize=9)\n",
+    "ax.set_ylabel('Sparsity (%)')\n",
+    "ax.set_title('Co-occurrence Matrix Sparsity')\n",
+    "ax.set_ylim([0, 100])\n",
+    "ax.grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# 5. Training time\n",
+    "ax = axes[1, 1]\n",
+    "train_time = [experiment_results[exp].get('training_time_seconds', 0) for exp in exp_names]\n",
+    "ax.bar(range(len(exp_names)), train_time, color='darkorange')\n",
+    "ax.set_xticks(range(len(exp_names)))\n",
+    "ax.set_xticklabels(exp_labels, rotation=45, ha='right', fontsize=9)\n",
+    "ax.set_ylabel('Time (seconds)')\n",
+    "ax.set_title('Training Time')\n",
+    "ax.grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('ablation_study_comparison.png', dpi=300, bbox_inches='tight')\n",
+    "print(\"✓ Comparison plot saved to ablation_study_comparison.png\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e4d8f82",
+   "metadata": {},
+   "source": [
+    "#### Observations\n",
+    "1. CODE COVERAGE & GRAPH SIZE\n",
+    "   * Higher unique codes = more medical concepts covered\n",
+    "   * Larger graphs (more nodes/edges) = richer concept relationships\n",
+    "   * Trade-off: More domains = larger graph but also higher complexity\n",
+    "\n",
+    "2. COMPUTATIONAL EFFICIENCY\n",
+    "   * Training time increases with matrix size\n",
+    "   * Sparsity affects actual computation (denser = more work)\n",
+    "   * Consider trade-off between performance and computational cost\n",
+    "\n",
+    "#### Takeaways\n",
+    "   * More domains → larger graphs → more training time\n",
+    "   * More domains → potentially better embeddings (more signal)\n",
+    "   * Diminishing returns possible (some domains add little value)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.12.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyhealth/models/__init__.py b/pyhealth/models/__init__.py
index 4c168d3e3..551793457 100644
--- a/pyhealth/models/__init__.py
+++ b/pyhealth/models/__init__.py
@@ -45,4 +45,5 @@
 from .sdoh import SdohClassifier
 from .medlink import MedLink
 from .unified_embedding import UnifiedMultimodalEmbeddingModel, SinusoidalTimeEmbedding
-from .califorest import CaliForest
\ No newline at end of file
+from .califorest import CaliForest
+from .keep_embedding import N2V, KeepEmbedding
diff --git a/pyhealth/models/keep_embedding.py b/pyhealth/models/keep_embedding.py
new file mode 100644
index 000000000..4d246e449
--- /dev/null
+++ b/pyhealth/models/keep_embedding.py
@@ -0,0 +1,418 @@
+import os
+from collections import defaultdict, Counter
+
+import networkx as nx
+from node2vec import Node2Vec
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from pyhealth.datasets import SampleDataset
+from .base_model import BaseModel
+
+class N2V:
+    """Generate Node2Vec embeddings for OMOP concepts.
+
+    Builds a directed knowledge graph from OMOP concept relationship tables
+    and trains Node2Vec to create graph embeddings.
+
+    Attributes:
+        embedding_dim: Dimension of learned embeddings.
+        walk_length: Length of each random walk.
+        num_walks: Number of walks per node.
+    """
+    def __init__(
+        self,
+        embedding_dim: int | None = None,
+        walk_length: int | None = None,
+        num_walks: int | None = None,
+    ) -> None:
+        self.embedding_dim = embedding_dim
+        self.walk_length = walk_length
+        self.num_walks = num_walks
+    
+    def create_graph(
+        self, path: str, domain_type: list[str]
+    ) -> nx.DiGraph:
+        """Create a Network directed graph from OMOP concept relationships.
+
+        Args:
+            path: Path to OMOP concept CSV files.
+            domain_type: List of domain IDs to include.
+
+        Returns:
+            Directed graph with concept IDs as nodes and relationships
+                as edges.
+        """
+        # Load concept table
+        concept_path = os.path.join(path, "2b_concept.csv")  
+        print(f"Loading concepts from {concept_path}")
+        concept_df = pd.read_csv(concept_path, dtype=str)
+ 
+        # Load concept relationships table
+        concept_relationship_path = os.path.join(path, "2b_concept_relationship.csv")
+        print(f"Loading concept relationships from {concept_relationship_path}")
+        concept_rel_df = pd.read_csv(concept_relationship_path, dtype=str)
+        
+        print(f"Loaded {len(concept_df)} concepts and {len(concept_rel_df)} relationships")
+
+        if domain_type != ["all"]:
+            # Filter concepts by target domain
+            concept_df = concept_df[concept_df["domain_id"].isin(domain_type)].copy()
+        
+            print(f"Filtered to {len(concept_df)} concepts in domains: {domain_type}")
+        
+        # Create set of filtered concept IDs for quick lookup
+        filtered_concept_ids = set(concept_df["concept_id"].values)
+        print(f"Created set of {len(filtered_concept_ids)} concept IDs")
+        
+        # Filter to relationships where both concepts are in our domain set
+        concept_rel_df = concept_rel_df[
+            (concept_rel_df["concept_id_1"].isin(filtered_concept_ids)) &
+            (concept_rel_df["concept_id_2"].isin(filtered_concept_ids))
+        ].copy()
+        
+        print(f"Found {len(concept_rel_df)} relationships between concepts")
+        
+        # Create directed graph
+        graph = nx.DiGraph()
+        
+        # Add all filtered concepts as nodes
+        for _, row in concept_df.iterrows():
+            graph.add_node(
+                row["concept_id"],
+                name=row["concept_name"],
+                domain=row["domain_id"]
+            )
+        
+        # Add edges from concept relationships
+        for _, row in concept_rel_df.iterrows():
+            concept_1 = row["concept_id_1"]
+            concept_2 = row["concept_id_2"]
+            rel_type = row.get("relationship_id")
+            
+            # Add directed edge from concept_1 to concept_2
+            if graph.has_edge(concept_1, concept_2):
+                # Append to existing relationships list
+                graph[concept_1][concept_2]["relationships"].append(rel_type)
+            else:
+                # Create new edge with relationships list
+                graph.add_edge(concept_1, concept_2, relationships=[rel_type])
+        
+        return graph
+
+    def _build_index_mapping(
+        self, node_embeddings: object
+    ) -> dict[int, int]:
+        """Map concept codes to embedding indices.
+
+        Args:
+            node_embeddings: Word2Vec model word vectors.
+
+        Returns:
+            Mapping from concept_id to index in embeddings.
+        """
+        return {int(key): i for i, key in enumerate(node_embeddings.index_to_key)}
+
+    def _get_vector_iso(
+        self,
+        code: int,
+        node_embeddings: object,
+        index_mapping: dict,
+        mean_vector: np.ndarray,
+    ) -> np.ndarray:
+        """Get embedding vector for code or mean vector if not found.
+
+        Args:
+            code: Concept ID.
+            node_embeddings: Word2Vec model word vectors.
+            index_mapping: Concept ID to embedding index mapping.
+            mean_vector: Fallback vector to use if code not found.
+
+        Returns:
+            Embedding vector for the concept.
+        """
+        index = index_mapping.get(int(code))
+        if index is not None:
+            return node_embeddings.get_vector(index)
+        else:
+            print(f"Code {code} not found, returning mean vector.")
+            return mean_vector
+
+    def generate_embeddings(
+        self, graph: nx.DiGraph
+    ) -> tuple[np.ndarray, list]:
+        """Generate node embeddings using Node2Vec.
+
+        Args:
+            graph: Directed graph of OMOP concepts and relationships.
+
+        Returns:
+            Tuple of (embedding_matrix, node_ids) where embedding_matrix
+                is numpy array of embeddings and node_ids is the list of
+                node IDs in order.
+        """
+        print(f"Graph created with {len(graph.nodes())} nodes and {len(graph.edges())} edges")
+        
+        if len(graph.nodes()) == 0:
+            raise ValueError("Graph is empty, cannot generate embeddings")
+        
+        # Initialize and fit Node2Vec
+        print(f"Initializing Node2Vec with embedding_dim={self.embedding_dim} walk_length={self.walk_length}, num_walks={self.num_walks}")
+
+        node2vec = Node2Vec(
+            graph,
+            dimensions=self.embedding_dim,
+            walk_length=self.walk_length,
+            num_walks=self.num_walks,
+            p=1, q=1, workers=4
+        )
+        
+        # Train the model
+        self.model = node2vec.fit(window=10, min_count=1, epochs=1)
+        
+        # Extract embeddings from trained model
+        keys = list(graph.nodes())
+        node_embeddings = self.model.wv
+        
+        # Build index mapping for efficient lookup
+        index_mapping = self._build_index_mapping(node_embeddings)
+        mean_vector = np.mean(node_embeddings.vectors, axis=0)
+        
+        # Create embedding vectors for all concepts
+        print(f"Creating embedding vectors for {len(keys)} concepts...")
+        vectors = [self._get_vector_iso(key, node_embeddings, index_mapping, mean_vector) for key in keys]
+        
+        # Stack into matrix
+        embedding_matrix = np.vstack(vectors)
+        print(f"Embedding matrix shape: {embedding_matrix.shape}")
+        
+        return embedding_matrix, keys
+
+class KeepEmbedding(BaseModel):
+    """KEEP Embedding Framework
+
+
+    Fine-tune Node2Vec embeddings using GloVe with graph regularization.
+
+    Balances co-occurrence structure (GloVe) with graph (Node2Vec) via regularization
+    to generate medical concept embeddings.
+
+    Args:
+        dataset: Dataset to train the model.
+        graph: Directed graph of concepts and relationships.
+        embedding_dim: Dimension of embeddings.
+        walk_length: Length of random walks for Node2Vec.
+        num_walks: Number of random walks per node.
+        num_words: Size of vocabulary.
+        lambda_reg: Regularization strength (default: 1.0).
+        reg_norm: Norm type ('cosine' or numeric p-norm, default: None).
+        log_scale: Apply log scaling to regularization distance
+            (default: False).
+        code_to_index: Optional mapping from concept codes to indices.
+        device: Device to use ('cuda' or 'cpu', default: 'cpu').
+
+    Examples:
+        >>> from pyhealth.datasets import OMOPDataset
+        >>> from pyhealth.models import KeepEmbedding
+        >>> dataset = SampleDataset(num_patients=100, num_visits=10, num_codes=50)
+        >>> graph = n2v.create_graph()  # Build knowledge graph from concept and relationship tables
+        >>> dataset = OMOPDataset(...)
+        >>> # Build co-occurrence matrix from dataset
+        >>> # Load co-occurrence matrix as GloveDatset Dataloader
+        >>> model = KeepEmbedding(
+        ...     dataset=None,
+        ...     graph=graph,
+        ...     embedding_dim=128,
+        ...     walk_length=10,
+        ...     num_walks=5,
+        ...     num_words=50,
+        ...     lambda_reg=0.5,
+        ...     reg_norm='cosine',
+        ...     log_scale=True,
+        ...     device='cuda'
+        ... )
+        >>> # Use embeddings for with downstream PyHealth models
+    """
+    
+    def __init__(
+        self,
+        dataset: SampleDataset,
+        graph: nx.Graph,
+        embedding_dim: int,
+        walk_length: int,
+        num_walks: int,
+        num_words: int,
+        lambda_reg: float = 1.0,
+        reg_norm: str | float | None = None,
+        log_scale: bool = False,
+        code_to_index: dict | None = None,
+        device: str = "cpu",
+    ) -> None:
+        """Initialize KEEP Embedding model."""
+        super().__init__(dataset=dataset)
+        
+        self.embedding_dim = embedding_dim
+        self.lambda_reg = lambda_reg
+        self.reg_norm = reg_norm
+        self.log_scale = log_scale
+        self._device = device
+        self.mode = "regression"  # Set mode for compatibility with BaseModel
+        
+        # Generate Node2Vec embeddings
+        print(f"Initializing Node2Vec with embedding_dim={embedding_dim}...")
+        self.n2v = N2V(
+            embedding_dim=embedding_dim,
+            walk_length=walk_length,
+            num_walks=num_walks
+        )
+        
+        embedding_matrix, node_ids = self.n2v.generate_embeddings(graph)
+        print(f"Created embedding matrix with shape: {embedding_matrix.shape}")
+        
+        # Filter embeddings if code_to_index mapping is provided
+        if code_to_index is not None:
+            print(f"Filtering embeddings from {len(node_ids)} concepts to {num_words} vocabulary items...")
+            # Create a mapping from node IDs to embeddings
+            node_to_embedding = {node_id: embedding_matrix[i] for i, node_id in enumerate(node_ids)}
+            
+            # Build filtered embedding matrix for only codes in vocabulary
+            filtered_vectors = []
+            missing_count = 0
+            for idx in range(num_words):
+                # Find the concept code for this index
+                code = next((code for code, code_idx in code_to_index.items() if code_idx == idx), None)
+                if code is not None and code in node_to_embedding:
+                    filtered_vectors.append(node_to_embedding[code])
+                else:
+                    missing_count += 1
+                    # Use mean of all embeddings as fallback
+                    filtered_vectors.append(np.mean(embedding_matrix, axis=0))
+            
+            if missing_count > 0:
+                print(f"  {missing_count}/{num_words} codes not found in graph, using mean embedding as fallback")
+            
+            embedding_matrix = np.vstack(filtered_vectors)
+            print(f"Filtered embedding matrix shape: {embedding_matrix.shape}")
+        
+        # Create learnable embedding and bias parameters
+        self.embeddings_v = nn.Embedding(num_words, embedding_dim)
+        self.embeddings_u = nn.Embedding(num_words, embedding_dim)
+        self.biases_v = nn.Embedding(num_words, 1)
+        self.biases_u = nn.Embedding(num_words, 1)
+        
+        # Initialize with Node2Vec embeddings
+        embedding_tensor = torch.from_numpy(embedding_matrix).float()
+        self.embeddings_v.weight.data.copy_(embedding_tensor)
+        self.embeddings_u.weight.data.copy_(embedding_tensor)
+        
+        # Initialize biases to zero
+        self.biases_v.weight.data.fill_(0)
+        self.biases_u.weight.data.fill_(0)
+
+        # Store initial embeddings for regularization
+        self.register_buffer(
+            "initial_embeddings",
+            embedding_tensor.clone().to(device)
+        )
+        
+        print(f"Initialized KEEP Embedding with {num_words} tokens")
+        print(f"Embedding dimension: {embedding_dim}")
+        print(f"Regularization lambda: {lambda_reg}")
+        print(f"Regularization norm: {reg_norm}")
+        print(f"Log scaling: {log_scale}")
+    
+    def forward(
+        self,
+        i_indices: torch.Tensor | None = None,
+        j_indices: torch.Tensor | None = None,
+        counts: torch.Tensor | None = None,
+        weights: torch.Tensor | None = None,
+        **kwargs,
+    ) -> dict[str, torch.Tensor]:
+        """Compute GloVe loss with optional Node2Vec regularization.
+
+        Args:
+            i_indices: Token indices (batch_size,).
+            j_indices: Context token indices (batch_size,).
+            counts: Co-occurrence counts (batch_size,).
+            weights: Weights for loss terms (batch_size,).
+            **kwargs: Additional arguments for compatibility.
+
+        Returns:
+            Dictionary with keys: loss, logit, y_prob, y_true,
+                reg_loss.
+        """
+        
+        # If no GloVe inputs provided, return dummy output
+        if i_indices is None or j_indices is None:
+            dummy_loss = torch.tensor(0.0, device=self.device, requires_grad=True)
+            return {
+                "loss": dummy_loss,
+                "logit": dummy_loss,
+                "y_prob": dummy_loss,
+                "y_true": dummy_loss,
+            }
+        
+        # Move inputs to correct device
+        i_indices = i_indices.to(self._device)
+        j_indices = j_indices.to(self._device)
+        counts = counts.to(self._device)
+        weights = weights.to(self._device)
+        
+        # Get embeddings and biases
+        embedding_i = self.embeddings_v(i_indices)  # (batch_size, embedding_dim)
+        embedding_j = self.embeddings_u(j_indices)  # (batch_size, embedding_dim)
+        bias_i = self.biases_v(i_indices).squeeze(-1)  # (batch_size,)
+        bias_j = self.biases_u(j_indices).squeeze(-1)  # (batch_size,)
+        
+        # Compute GloVe loss: weighted squared difference
+        # GloVe objective: w(i,j) * (u_i · v_j + b_i + b_j - log(X_ij))^2
+        dot_product = torch.sum(embedding_i * embedding_j, dim=1)  # (batch_size,)
+        glove_target = torch.log(counts + 1e-8)  # Avoid log(0)
+        
+        squared_diff = (dot_product + bias_i + bias_j - glove_target) ** 2
+        glove_loss = torch.sum(weights * squared_diff)
+        
+        total_loss = glove_loss
+        reg_loss = torch.tensor(0.0, device=self._device)
+        
+        # Add Node2Vec regularization if lambda > 0
+        if self.lambda_reg > 0:
+            # Average embeddings: (u_i + v_i) / 2 and (u_j + v_j) / 2
+            u_plus_v_i = (embedding_i + self.embeddings_u(i_indices)) / 2
+            u_plus_v_j = (embedding_j + self.embeddings_v(j_indices)) / 2
+            
+            # Get initial embeddings
+            initial_i = self.initial_embeddings[i_indices]
+            initial_j = self.initial_embeddings[j_indices]
+            
+            # Compute regularization distance based on norm type
+            if self.reg_norm is None or self.reg_norm == "cosine":
+                # Cosine distance: 1 - cosine_similarity
+                reg_dist_i = 1 - F.cosine_similarity(u_plus_v_i, initial_i, dim=1)
+                reg_dist_j = 1 - F.cosine_similarity(u_plus_v_j, initial_j, dim=1)
+            else:
+                # Lp norm distance
+                p_norm = float(self.reg_norm)
+                reg_dist_i = torch.norm(u_plus_v_i - initial_i, p=p_norm, dim=1)
+                reg_dist_j = torch.norm(u_plus_v_j - initial_j, p=p_norm, dim=1)
+            
+            # Apply log scaling if enabled
+            if self.log_scale:
+                reg_dist_i = torch.log(reg_dist_i + 1e-8)
+                reg_dist_j = torch.log(reg_dist_j + 1e-8)
+            
+            # Compute regularization loss
+            reg_loss = self.lambda_reg * (torch.sum(reg_dist_i) + torch.sum(reg_dist_j))
+            total_loss = glove_loss + reg_loss
+        
+        return {
+            "loss": total_loss,
+            "logit": glove_loss.detach(),  # Return GloVe component as logit for reference
+            "y_prob": torch.zeros(i_indices.shape[0], device=self._device),  # Placeholder
+            "y_true": torch.zeros(i_indices.shape[0], device=self._device),  # Placeholder
+            "reg_loss": reg_loss.detach(),  # Return regularization loss for monitoring
+        }
diff --git a/pyproject.toml b/pyproject.toml
index 98f88d47b..d93115e3f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -31,6 +31,7 @@ dependencies = [
   "ogb>=1.3.5",
   "scikit-learn~=1.7.0",
   "networkx",
+  "node2vec",
   "mne~=1.10.0",
   "urllib3~=2.5.0",
   "numpy~=2.2.0",
diff --git a/tests/core/test_keep_embedding.py b/tests/core/test_keep_embedding.py
new file mode 100644
index 000000000..e579d42f4
--- /dev/null
+++ b/tests/core/test_keep_embedding.py
@@ -0,0 +1,249 @@
+import sys
+import unittest
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+import torch
+
+# pyhealth.models.__init__ imports every model in the package, each of which
+# pulls in its own optional deps (einops, litdata, polars, rdkit, …).
+# Mock out everything except keep_embedding and base_model so Python never
+# loads those files, keeping test imports fast and dep-free.
+_datasets_mock = MagicMock()
+_datasets_mock.SampleDataset = MagicMock
+sys.modules.setdefault("pyhealth.datasets", _datasets_mock)
+sys.modules.setdefault("pyhealth.processors", MagicMock())
+
+for _mod in (
+    "pyhealth.models.adacare",
+    "pyhealth.models.agent",
+    "pyhealth.models.biot",
+    "pyhealth.models.cnn",
+    "pyhealth.models.concare",
+    "pyhealth.models.contrawr",
+    "pyhealth.models.deepr",
+    "pyhealth.models.embedding",
+    "pyhealth.models.gamenet",
+    "pyhealth.models.jamba_ehr",
+    "pyhealth.models.logistic_regression",
+    "pyhealth.models.gan",
+    "pyhealth.models.gnn",
+    "pyhealth.models.graph_torchvision_model",
+    "pyhealth.models.graphcare",
+    "pyhealth.models.grasp",
+    "pyhealth.models.medlink",
+    "pyhealth.models.micron",
+    "pyhealth.models.mlp",
+    "pyhealth.models.molerec",
+    "pyhealth.models.retain",
+    "pyhealth.models.rnn",
+    "pyhealth.models.safedrug",
+    "pyhealth.models.sparcnet",
+    "pyhealth.models.stagenet",
+    "pyhealth.models.stagenet_mha",
+    "pyhealth.models.tcn",
+    "pyhealth.models.tfm_tokenizer",
+    "pyhealth.models.torchvision_model",
+    "pyhealth.models.transformer",
+    "pyhealth.models.transformers_model",
+    "pyhealth.models.ehrmamba",
+    "pyhealth.models.vae",
+    "pyhealth.models.vision_embedding",
+    "pyhealth.models.text_embedding",
+    "pyhealth.models.sdoh",
+    "pyhealth.models.unified_embedding",
+    "pyhealth.models.transformer_deid",
+    "pyhealth.models.califorest",
+):
+    sys.modules.setdefault(_mod, MagicMock())
+
+from pyhealth.models.keep_embedding import N2V, KeepEmbedding
+
+
+# Tiny sizes so every test finishes in milliseconds.
+NUM_CONCEPTS = 8
+EMBEDDING_DIM = 4
+
+
+class TestN2VHelpers(unittest.TestCase):
+    """Test N2V helper methods that require no CSV files or graph construction."""
+
+    def setUp(self):
+        """Set up a minimal N2V instance."""
+        self.n2v = N2V(
+            embedding_dim=EMBEDDING_DIM,
+            walk_length=5,
+            num_walks=5,
+        )
+
+    def test_build_index_mapping(self):
+        """Test that concept string keys are mapped to integer indices."""
+        wv = MagicMock()
+        wv.index_to_key = ["100", "200", "300"]
+        mapping = self.n2v._build_index_mapping(wv)
+        self.assertEqual(mapping, {100: 0, 200: 1, 300: 2})
+
+    def test_get_vector_iso_found(self):
+        """Test that the correct embedding is returned for a known concept."""
+        wv = MagicMock()
+        wv.index_to_key = ["42"]
+        vec = np.array([1.0, 2.0])
+        wv.get_vector.return_value = vec
+        result = self.n2v._get_vector_iso("42", wv, {42: 0}, np.zeros(2))
+        np.testing.assert_array_equal(result, vec)
+
+    def test_get_vector_iso_missing_returns_mean(self):
+        """Test that the mean vector is returned for an unknown concept."""
+        wv = MagicMock()
+        wv.index_to_key = []
+        mean_vec = np.array([0.5, 0.5])
+        result = self.n2v._get_vector_iso("999", wv, {}, mean_vec)
+        np.testing.assert_array_equal(result, mean_vec)
+
+
+class TestKeepEmbeddingInit(unittest.TestCase):
+    """Test KeepEmbedding initialization with a mocked N2V embedding matrix."""
+
+    def setUp(self):
+        """Set up a KeepEmbedding instance with N2V mocked out."""
+        fake_matrix = np.random.randn(NUM_CONCEPTS, EMBEDDING_DIM).astype(np.float32)
+        fake_keys = list(range(NUM_CONCEPTS))
+        with patch.object(N2V, "generate_embeddings", return_value=(fake_matrix, fake_keys)):
+            self.model = KeepEmbedding(
+                dataset=None,
+                graph=MagicMock(),
+                embedding_dim=EMBEDDING_DIM,
+                walk_length=5,
+                num_walks=5,
+                num_words=NUM_CONCEPTS,
+                device="cpu",
+            )
+
+    def test_embedding_shapes(self):
+        """Test that embedding layers are created with the correct dimensions."""
+        self.assertEqual(self.model.embeddings_v.num_embeddings, NUM_CONCEPTS)
+        self.assertEqual(self.model.embeddings_v.embedding_dim, EMBEDDING_DIM)
+        self.assertEqual(self.model.initial_embeddings.shape, (NUM_CONCEPTS, EMBEDDING_DIM))
+
+    def test_biases_initialized_to_zero(self):
+        """Test that bias embeddings are initialized to zero."""
+        self.assertTrue(torch.all(self.model.biases_v.weight.data == 0))
+        self.assertTrue(torch.all(self.model.biases_u.weight.data == 0))
+
+
+class TestKeepEmbeddingForward(unittest.TestCase):
+    """Test KeepEmbedding forward pass across regularization configurations."""
+
+    def _make_model(self, lambda_reg=1.0, reg_norm=None, log_scale=False):
+        """Return a KeepEmbedding with N2V mocked out."""
+        fake_matrix = np.random.randn(NUM_CONCEPTS, EMBEDDING_DIM).astype(np.float32)
+        fake_keys = list(range(NUM_CONCEPTS))
+        with patch.object(N2V, "generate_embeddings", return_value=(fake_matrix, fake_keys)):
+            return KeepEmbedding(
+                dataset=None,
+                graph=MagicMock(),
+                embedding_dim=EMBEDDING_DIM,
+                walk_length=5,
+                num_walks=5,
+                num_words=NUM_CONCEPTS,
+                lambda_reg=lambda_reg,
+                reg_norm=reg_norm,
+                log_scale=log_scale,
+                device="cpu",
+            )
+
+    def _glove_batch(self, batch_size=3):
+        """Return a minimal GloVe batch with random indices."""
+        return {
+            "i_indices": torch.randint(0, NUM_CONCEPTS, (batch_size,)),
+            "j_indices": torch.randint(0, NUM_CONCEPTS, (batch_size,)),
+            "counts": torch.rand(batch_size) * 10 + 1,
+            "weights": torch.rand(batch_size),
+        }
+
+    def setUp(self):
+        """Set up a default KeepEmbedding model."""
+        self.model = self._make_model(lambda_reg=1.0)
+
+    def test_output_keys(self):
+        """Test that the forward pass returns all expected output keys."""
+        ret = self.model(**self._glove_batch())
+        for key in ("loss", "logit", "y_prob", "y_true", "reg_loss"):
+            self.assertIn(key, ret)
+
+    def test_loss_is_scalar(self):
+        """Test that the total loss is a scalar tensor."""
+        self.assertEqual(self.model(**self._glove_batch())["loss"].dim(), 0)
+
+    def test_placeholder_shapes(self):
+        """Test that placeholder output tensors match the batch size."""
+        ret = self.model(**self._glove_batch(batch_size=3))
+        self.assertEqual(ret["y_prob"].shape[0], 3)
+        self.assertEqual(ret["y_true"].shape[0], 3)
+
+    def test_no_inputs_returns_zero_loss(self):
+        """Test that calling forward with no inputs returns zero loss."""
+        self.assertEqual(self.model()["loss"].item(), 0.0)
+
+    def test_no_regularization(self):
+        """Test that lambda_reg=0 produces zero regularization loss."""
+        ret = self._make_model(lambda_reg=0.0)(**self._glove_batch())
+        self.assertEqual(ret["reg_loss"].item(), 0.0)
+
+    def test_lp_norm_regularization(self):
+        """Test that Lp norm regularization runs without error."""
+        ret = self._make_model(lambda_reg=1.0, reg_norm=2)(**self._glove_batch())
+        self.assertEqual(ret["loss"].dim(), 0)
+
+    def test_log_scale_regularization(self):
+        """Test that log-scale cosine regularization runs without error."""
+        ret = self._make_model(lambda_reg=1.0, log_scale=True)(**self._glove_batch())
+        self.assertEqual(ret["loss"].dim(), 0)
+
+
+class TestKeepEmbeddingBackward(unittest.TestCase):
+    """Test that gradients flow correctly through KeepEmbedding."""
+
+    def _make_model(self, lambda_reg=1.0):
+        """Return a KeepEmbedding with N2V mocked out."""
+        fake_matrix = np.random.randn(NUM_CONCEPTS, EMBEDDING_DIM).astype(np.float32)
+        fake_keys = list(range(NUM_CONCEPTS))
+        with patch.object(N2V, "generate_embeddings", return_value=(fake_matrix, fake_keys)):
+            return KeepEmbedding(
+                dataset=None,
+                graph=MagicMock(),
+                embedding_dim=EMBEDDING_DIM,
+                walk_length=5,
+                num_walks=5,
+                num_words=NUM_CONCEPTS,
+                lambda_reg=lambda_reg,
+                device="cpu",
+            )
+
+    def _glove_batch(self, batch_size=3):
+        """Return a minimal GloVe batch with random indices."""
+        return {
+            "i_indices": torch.randint(0, NUM_CONCEPTS, (batch_size,)),
+            "j_indices": torch.randint(0, NUM_CONCEPTS, (batch_size,)),
+            "counts": torch.rand(batch_size) * 10 + 1,
+            "weights": torch.rand(batch_size),
+        }
+
+    def _has_grads(self, model):
+        return any(p.grad is not None for p in model.parameters() if p.requires_grad)
+
+    def test_gradients_flow_with_regularization(self):
+        """Test that gradients flow through the GloVe + regularization loss."""
+        model = self._make_model(lambda_reg=1.0)
+        model(**self._glove_batch())["loss"].backward()
+        self.assertTrue(self._has_grads(model))
+
+    def test_gradients_flow_without_regularization(self):
+        """Test that gradients flow through the GloVe-only loss."""
+        model = self._make_model(lambda_reg=0.0)
+        model(**self._glove_batch())["loss"].backward()
+        self.assertTrue(self._has_grads(model))
+
+
+if __name__ == "__main__":
+    unittest.main()