diff --git a/alloydb/notebooks/alloydb_scann_benchmark_glove.ipynb b/alloydb/notebooks/alloydb_scann_benchmark_glove.ipynb new file mode 100644 index 0000000000..dd37f46fc4 --- /dev/null +++ b/alloydb/notebooks/alloydb_scann_benchmark_glove.ipynb @@ -0,0 +1,2012 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "id": "9WxWMjxAwH1e", + "cell_type": "code", + "source": [ + "# @title ⚙️ Benchmark Execution\n", + "# ==========================================\n", + "# 1. CONFIGURATION\n", + "# ==========================================\n", + "# @markdown ### **⚙️ 1. Cluster Configuration**\n", + "project_id = \"\" # @param {type:\"string\", placeholder:\"Project ID\"}\n", + "region = \"\" # @param {type:\"string\", placeholder:\"Region (e.g. us-central1)\"}\n", + "cluster_id = \"\" # @param {type:\"string\", placeholder:\"Cluster name\"}\n", + "instance_id = \"\" # @param {type:\"string\", placeholder:\"Instance Name\"}\n", + "\n", + "# @markdown ### **🔐 2. Database Credentials**\n", + "# @markdown *Note: Password will be requested securely when the benchmark is executed.*\n", + "db_user = \"postgres\" # @param {type:\"string\", placeholder:\"DB User\"}\n", + "db_name = \"postgres\" # @param {type:\"string\", placeholder:\"DB Name\"}\n", + "\n", + "# @markdown ### **⚡ 3. Benchmark Parameters**\n", + "# @markdown * `num_queries`: Total test queries to run.\n", + "# @markdown * `top_k`: Number of nearest neighbors to retrieve (LIMIT).\n", + "num_queries = 100 # @param [100, 500, 1000, 10000] {type:\"raw\"}\n", + "top_k = 10 # @param [10, 20, 50, 100] {type:\"raw\"}\n", + "\n", + "# ==========================================\n", + "# 2. SETUP & AUTHENTICATION\n", + "# ==========================================\n", + "import getpass\n", + "import os\n", + "import shutil\n", + "import sys\n", + "import time\n", + "import urllib.request\n", + "\n", + "# Prompt for password upfront so user doesn't wait for pip installation\n", + "db_pass = getpass.getpass(\"🔑 Enter Database Password for AlloyDB: \")\n", + "\n", + "# Install dependencies silently (standard for Colab VM runtimes)\n", + "try:\n", + " import pg8000\n", + " import google.cloud.alloydb.connector\n", + " import h5py\n", + " import matplotlib\n", + " import tqdm\n", + "except ImportError:\n", + " try:\n", + " # Run pip install in standard Colab environment\n", + " get_ipython().system(\n", + " \"pip install -q pg8000 google-cloud-alloydb-connector[pg8000] tqdm\"\n", + " \" matplotlib h5py numpy\"\n", + " )\n", + " except Exception as e:\n", + " print(f\"⚠️ Could not auto-install packages: {e}\")\n", + " print(\n", + " \"ℹ️ Ensure you are connected to a standard Colab runtime (e.g. on\"\n", + " \" colab.sandbox.google.com or colab.research.google.com).\"\n", + " )\n", + "\n", + "# Authenticate Colab session\n", + "try:\n", + " from google.colab import auth\n", + "\n", + " auth.authenticate_user()\n", + "except Exception as e:\n", + " print(f\"ℹ️ Google Cloud auth note: {e}\")\n", + "\n", + "from IPython.display import clear_output, display, HTML\n", + "\n", + "clear_output()\n", + "\n", + "# ==========================================\n", + "# 3. LATE IMPORTS (Post-Installation) & THEME-ADAPTIVE STYLING\n", + "# ==========================================\n", + "import h5py\n", + "import matplotlib.patheffects as patheffects\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "import numpy as np\n", + "from tqdm.notebook import tqdm\n", + "from google.cloud.alloydb.connector import Connector\n", + "\n", + "\n", + "def print_step(step_label, text=\"\", is_success=False, is_error=False):\n", + " \"\"\"Renders status messages with styling tuned for both light and dark backgrounds.\"\"\"\n", + " base_style = \"font-size: 16px; margin-top: 10px; margin-bottom: 4px;\"\n", + " if is_success:\n", + " display(\n", + " HTML(f\"\"\"\n", + "
\n", + " {step_label} {text}\n", + "
\n", + " \"\"\")\n", + " )\n", + " elif is_error:\n", + " display(\n", + " HTML(f\"\"\"\n", + "
\n", + " {step_label} {text}\n", + "
\n", + " \"\"\")\n", + " )\n", + " else:\n", + " display(\n", + " HTML(f\"\"\"\n", + "
\n", + " {step_label}\n", + " {text}\n", + "
\n", + " \"\"\")\n", + " )\n", + "\n", + "\n", + "# ==========================================\n", + "# 4. DATASET CONFIGURATION (GloVe-100 Angular)\n", + "# ==========================================\n", + "DATASET_CONFIG = {\n", + " \"url\": \"https://ann-benchmarks.com/glove-100-angular.hdf5\",\n", + " \"file_name\": \"glove-100-angular.hdf5\",\n", + " \"dim\": 100,\n", + " \"table_name\": \"glove\",\n", + " \"test_table_name\": \"glove_test\",\n", + " \"distance_op\": \"<=>\",\n", + " \"index_metric\": \"cosine\",\n", + " \"description\": \"GloVe-100 Angular (1.18M train, 10k test, dim=100)\",\n", + "}\n", + "\n", + "\n", + "# ==========================================\n", + "# 5. CORE HELPER FUNCTIONS\n", + "# ==========================================\n", + "def download_dataset(dataset_cfg):\n", + " file_name = dataset_cfg[\"file_name\"]\n", + " if not os.path.exists(file_name):\n", + " url = dataset_cfg[\"url\"]\n", + " print_step(\n", + " \"📥\",\n", + " f\"Downloading {dataset_cfg['description']} from {url}...\",\n", + " )\n", + " req = urllib.request.Request(url, headers={\"User-Agent\": \"Mozilla/5.0\"})\n", + " with (\n", + " urllib.request.urlopen(req, timeout=60) as response,\n", + " open(file_name, \"wb\") as out_file,\n", + " ):\n", + " shutil.copyfileobj(response, out_file)\n", + " print_step(\"✅\", f\"Dataset {file_name} downloaded successfully.\", is_success=True)\n", + " else:\n", + " print_step(\n", + " \"ℹ️\",\n", + " f\"Dataset {file_name} already exists locally. Skipping download.\",\n", + " )\n", + "\n", + "\n", + "def setup_schema(cur, dataset_cfg):\n", + " dim = dataset_cfg[\"dim\"]\n", + " tbl = dataset_cfg[\"table_name\"]\n", + " tbl_test = dataset_cfg[\"test_table_name\"]\n", + "\n", + " cur.execute(\"CREATE EXTENSION IF NOT EXISTS vector CASCADE;\")\n", + " cur.execute(\"CREATE EXTENSION IF NOT EXISTS alloydb_scann CASCADE;\")\n", + " cur.execute(f\"DROP TABLE IF EXISTS {tbl} CASCADE;\")\n", + " cur.execute(f\"DROP TABLE IF EXISTS {tbl_test} CASCADE;\")\n", + " cur.execute(\n", + " f\"CREATE TABLE {tbl} (id bigserial PRIMARY KEY, embedding vector({dim}));\"\n", + " )\n", + " cur.execute(\n", + " f\"CREATE TABLE {tbl_test} (id bigserial PRIMARY KEY, embedding\"\n", + " f\" vector({dim}));\"\n", + " )\n", + "\n", + "\n", + "def stream_bulk_insert(\n", + " cur,\n", + " table_name,\n", + " column_name,\n", + " numpy_matrix,\n", + " batch_size=5000,\n", + " desc=\"Inserting\",\n", + "):\n", + " total_rows = len(numpy_matrix)\n", + " for i in tqdm(\n", + " range(0, total_rows, batch_size),\n", + " desc=desc,\n", + " leave=True,\n", + " colour=\"#1f77b4\",\n", + " ):\n", + " batch = numpy_matrix[i : i + batch_size]\n", + " placeholders = \", \".join([\"(%s)\"] * len(batch))\n", + " params = [str(vec.tolist()) for vec in batch]\n", + " cur.execute(\n", + " f\"INSERT INTO {table_name} ({column_name}) VALUES {placeholders}\",\n", + " params,\n", + " )\n", + "\n", + "\n", + "def ingest_dataset(cur, dataset_cfg):\n", + " file_name = dataset_cfg[\"file_name\"]\n", + " tbl = dataset_cfg[\"table_name\"]\n", + " tbl_test = dataset_cfg[\"test_table_name\"]\n", + "\n", + " with h5py.File(file_name, \"r\") as f:\n", + " train_data = f[\"train\"][:]\n", + " test_data = f[\"test\"][:]\n", + "\n", + " stream_bulk_insert(\n", + " cur,\n", + " tbl,\n", + " \"embedding\",\n", + " train_data,\n", + " batch_size=5000,\n", + " desc=f\"Inserting {len(train_data):,} Training Records\",\n", + " )\n", + " stream_bulk_insert(\n", + " cur,\n", + " tbl_test,\n", + " \"embedding\",\n", + " test_data,\n", + " batch_size=5000,\n", + " desc=f\"Inserting {len(test_data):,} Test Queries\",\n", + " )\n", + "\n", + "\n", + "def build_scann_index(cur, dataset_cfg, index_name=\"alloydb_scann_idx\"):\n", + " tbl = dataset_cfg[\"table_name\"]\n", + " metric = dataset_cfg[\"index_metric\"]\n", + "\n", + " # VACUUM ANALYZE to ensure accurate statistics for ScaNN AUTO mode\n", + " cur.execute(f\"VACUUM (DISABLE_PAGE_SKIPPING, ANALYZE) {tbl};\")\n", + " cur.execute(\n", + " f\"VACUUM (DISABLE_PAGE_SKIPPING, ANALYZE) {dataset_cfg['test_table_name']};\"\n", + " )\n", + "\n", + " cur.execute(f\"DROP INDEX IF EXISTS {index_name};\")\n", + " cur.execute(\n", + " \"SELECT set_config('max_parallel_maintenance_workers',\"\n", + " \" current_setting('max_parallel_workers'), false);\"\n", + " )\n", + "\n", + " # Scale maintenance_work_mem to at least 10% of table size (minimum 2GB for fast in-memory sampling)\n", + " cur.execute(f\"SELECT pg_catalog.pg_relation_size('{tbl}');\")\n", + " table_size_bytes = cur.fetchone()[0]\n", + " maint_mem_mb = max(2048, int((table_size_bytes * 0.10) / (1024 * 1024)))\n", + " cur.execute(f\"SET maintenance_work_mem = '{maint_mem_mb}MB';\")\n", + "\n", + " t0 = time.time()\n", + " cur.execute(\n", + " f\"CREATE INDEX {index_name} ON {tbl} USING scann (embedding {metric}) WITH\"\n", + " \" (mode = 'AUTO');\"\n", + " )\n", + " build_duration_sec = time.time() - t0\n", + "\n", + " cur.execute(\n", + " f\"SELECT pg_catalog.pg_size_pretty(pg_catalog.pg_relation_size('{index_name}'));\"\n", + " )\n", + " index_size = cur.fetchone()[0]\n", + " cur.execute(\n", + " f\"SELECT pg_catalog.pg_size_pretty(pg_catalog.pg_relation_size('{tbl}'));\"\n", + " )\n", + " table_size = cur.fetchone()[0]\n", + "\n", + " print_step(\n", + " \"✅\",\n", + " f\"ScaNN index '{index_name}' built in {build_duration_sec:.2f}s | \"\n", + " f\"Index Size: {index_size} (Table Size: {table_size})\",\n", + " is_success=True,\n", + " )\n", + "\n", + "\n", + "def deploy_benchmark_functions(cur, dataset_cfg):\n", + " tbl = dataset_cfg[\"table_name\"]\n", + " tbl_test = dataset_cfg[\"test_table_name\"]\n", + " op = dataset_cfg[\"distance_op\"]\n", + "\n", + " # 1. Recall measurement function (using evaluate_query_recall and scann.pct_leaves_to_search)\n", + " cur.execute(f\"\"\"\n", + " CREATE OR REPLACE FUNCTION measure_recall(pct_leaves_to_search FLOAT, num_q INT, k INT)\n", + " RETURNS FLOAT AS $func$\n", + " DECLARE\n", + " q_vec text;\n", + " query_str text;\n", + " total_recall FLOAT := 0.0;\n", + " valid_queries INT := 0;\n", + " v_id int; v_q text; v_p json; v_recall float; v_at float; v_et float; v_idx text;\n", + " BEGIN\n", + " IF num_q <= 0 THEN RETURN 0.0; END IF;\n", + "\n", + " FOR q_vec IN SELECT embedding::text FROM {tbl_test} LIMIT num_q LOOP\n", + " query_str := pg_catalog.format('SELECT id FROM {tbl} ORDER BY embedding {op} ''%s'' LIMIT %s', q_vec, k);\n", + " BEGIN\n", + " EXECUTE pg_catalog.format('SELECT * FROM evaluate_query_recall($$%s$$, ''{{\"scann.pct_leaves_to_search\": %s, \"scann.num_leaves_to_search\": 0}}'', ''{{\"scann\"}}'')', query_str, pct_leaves_to_search)\n", + " INTO v_id, v_q, v_p, v_recall, v_at, v_et, v_idx;\n", + " IF v_recall IS NOT NULL THEN\n", + " total_recall := total_recall + v_recall;\n", + " valid_queries := valid_queries + 1;\n", + " END IF;\n", + " EXCEPTION\n", + " WHEN OTHERS THEN\n", + " RAISE WARNING 'Error during evaluate_query_recall: %', SQLERRM;\n", + " END;\n", + " END LOOP;\n", + "\n", + " IF valid_queries = 0 THEN RETURN 0.0; END IF;\n", + " RETURN total_recall / valid_queries;\n", + " END;\n", + " $func$ LANGUAGE plpgsql;\n", + " \"\"\")\n", + "\n", + " # 2. QPS measurement function (using scann.pct_leaves_to_search)\n", + " cur.execute(f\"\"\"\n", + " CREATE OR REPLACE FUNCTION measure_qps(pct_leaves_to_search FLOAT, num_q INT, k INT)\n", + " RETURNS FLOAT AS $func$\n", + " DECLARE\n", + " q_vec vector;\n", + " start_time timestamp;\n", + " end_time timestamp;\n", + " total_time_ms float;\n", + " BEGIN\n", + " IF num_q <= 0 THEN RETURN 0.0; END IF;\n", + "\n", + " PERFORM pg_catalog.set_config('scann.num_leaves_to_search', '0', false);\n", + " PERFORM pg_catalog.set_config('scann.pct_leaves_to_search', pct_leaves_to_search::text, false);\n", + "\n", + " start_time := pg_catalog.clock_timestamp();\n", + " FOR q_vec IN SELECT embedding FROM {tbl_test} LIMIT num_q LOOP\n", + " EXECUTE pg_catalog.format('SELECT id FROM {tbl} ORDER BY embedding {op} $1 LIMIT %s', k) USING q_vec;\n", + " END LOOP;\n", + " end_time := pg_catalog.clock_timestamp();\n", + "\n", + " total_time_ms := (EXTRACT(epoch FROM end_time) - EXTRACT(epoch FROM start_time)) * 1000.0;\n", + " IF total_time_ms <= 0.0 THEN RETURN 0.0; END IF;\n", + "\n", + " RETURN (num_q * 1000.0) / total_time_ms;\n", + " END;\n", + " $func$ LANGUAGE plpgsql;\n", + " \"\"\")\n", + "\n", + "\n", + "def run_benchmark_sweep(cur, pct_values, num_queries, top_k):\n", + " print_step(\"🔥\", \"Warming up database cache (0.5% leaves to search)...\")\n", + " # Configure query execution memory and parallelism once for the benchmark session\n", + " cur.execute(\"SET work_mem = '256MB';\")\n", + "\n", + " cur.execute(\n", + " \"SELECT measure_qps(0.5, %s, %s);\",\n", + " (min(50, num_queries), top_k),\n", + " )\n", + "\n", + " results = []\n", + " for pct in tqdm(\n", + " pct_values,\n", + " desc=\"Benchmarking ScaNN Auto Search (% Leaves)\",\n", + " colour=\"#1f77b4\",\n", + " ):\n", + " cur.execute(\n", + " \"SELECT measure_recall(%s, %s, %s);\",\n", + " (pct, num_queries, top_k),\n", + " )\n", + " recall = cur.fetchone()[0]\n", + " cur.execute(\n", + " \"SELECT measure_qps(%s, %s, %s);\",\n", + " (pct, num_queries, top_k),\n", + " )\n", + " qps = cur.fetchone()[0]\n", + " results.append({\"pct\": pct, \"recall\": recall, \"qps\": qps})\n", + " return results\n", + "\n", + "\n", + "def display_summary_table(results, top_k):\n", + " print_step(\"📊\", \"Benchmark Summary Table:\", is_success=True)\n", + " rows_html = \"\".join([\n", + " f\"\"\"\n", + " {r['pct']}%\n", + " = 0.9 else 'inherit'}; font-weight: {'bold' if r['recall'] >= 0.9 else 'normal'};\">{r['recall']:.4f}\n", + " {r['qps']:.1f}\n", + " \"\"\"\n", + " for r in results\n", + " ])\n", + " table_html = f\"\"\"\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " {rows_html}\n", + " \n", + "
pct_leaves_to_searchRecall @ {top_k}QPS (Queries/sec)
\n", + " \"\"\"\n", + " display(HTML(table_html))\n", + "\n", + "\n", + "def plot_results(results, dataset_cfg, top_k):\n", + " recalls = [r[\"recall\"] for r in results]\n", + " qps_vals = [r[\"qps\"] for r in results]\n", + " pct_labels = [r[\"pct\"] for r in results]\n", + "\n", + " plt.rc(\"font\", size=14)\n", + " plt.rc(\"axes\", titlesize=16)\n", + " plt.rc(\"axes\", labelsize=14)\n", + " plt.rc(\"xtick\", labelsize=12)\n", + " plt.rc(\"ytick\", labelsize=12)\n", + " plt.rc(\"legend\", fontsize=13)\n", + "\n", + " fig, ax = plt.subplots(figsize=(12, 7), dpi=120)\n", + "\n", + " color_scann = \"#1f77b4\"\n", + "\n", + " ax.plot(\n", + " recalls,\n", + " qps_vals,\n", + " marker=\"o\",\n", + " linewidth=2.5,\n", + " markersize=9,\n", + " color=color_scann,\n", + " label=\"AlloyDB ScaNN (Auto Mode)\",\n", + " )\n", + " ax.fill_between(recalls, qps_vals, color=color_scann, alpha=0.08)\n", + "\n", + " ax.set_xlabel(f\"Recall @ {top_k}\", fontweight=\"bold\", labelpad=10)\n", + " ax.set_ylabel(\"Queries Per Second (QPS)\", fontweight=\"bold\", labelpad=10)\n", + " ax.set_title(\n", + " f\"AlloyDB ScaNN: Recall vs QPS\\n({dataset_cfg['description']}, mode=AUTO,\"\n", + " f\" K={top_k})\",\n", + " fontsize=15,\n", + " fontweight=\"bold\",\n", + " pad=20,\n", + " )\n", + "\n", + " max_qps = max(qps_vals) if qps_vals else 100\n", + " min_recall = min(recalls) if recalls else 0.5\n", + " ax.set_ylim(0, max_qps * 1.18)\n", + " ax.set_xlim(max(0.0, min_recall - 0.05), 1.02)\n", + "\n", + " ax.yaxis.set_major_locator(ticker.MaxNLocator(8))\n", + " ax.xaxis.set_major_locator(ticker.MultipleLocator(0.05))\n", + "\n", + " # Clean spines for compatibility across light and dark themes\n", + " ax.spines[\"top\"].set_visible(False)\n", + " ax.spines[\"right\"].set_visible(False)\n", + " ax.spines[\"left\"].set_color(\"#cccccc\")\n", + " ax.spines[\"bottom\"].set_color(\"#cccccc\")\n", + "\n", + " plt.grid(True, which=\"both\", color=\"#f0f0f0\", linestyle=\"-\", linewidth=1.5)\n", + "\n", + " pe = [patheffects.withStroke(linewidth=3, foreground=\"white\", alpha=0.9)]\n", + "\n", + " for i in range(len(recalls)):\n", + " ax.text(\n", + " recalls[i],\n", + " qps_vals[i] + (max_qps * 0.03),\n", + " f\"PCT={pct_labels[i]}%\\n({qps_vals[i]:.0f} QPS)\",\n", + " color=\"#D97706\",\n", + " fontsize=9,\n", + " fontweight=\"bold\",\n", + " ha=\"center\",\n", + " va=\"bottom\",\n", + " path_effects=pe,\n", + " )\n", + "\n", + " ax.legend(loc=\"lower left\", frameon=True, edgecolor=\"#cccccc\")\n", + " fig.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# ==========================================\n", + "# 6. MAIN EXECUTION PIPELINE\n", + "# ==========================================\n", + "connector = None\n", + "conn = None\n", + "cur = None\n", + "\n", + "try:\n", + " print_step(\"✅\", \"GCP Authentication & Setup Successful!\", is_success=True)\n", + " print_step(\n", + " \"🚀\",\n", + " \"Starting AlloyDB ScaNN Benchmark Pipeline (Auto Mode - % Leaves\"\n", + " \" Search)...\",\n", + " )\n", + "\n", + " dataset_cfg = DATASET_CONFIG\n", + "\n", + " # Step 1: Connect to AlloyDB\n", + " print_step(\n", + " \"Step 1/7:\",\n", + " \"🔌 Initializing Secure AlloyDB Connector...\",\n", + " )\n", + " connector = Connector()\n", + " conn = connector.connect(\n", + " f\"projects/{project_id}/locations/{region}/clusters/{cluster_id}/instances/{instance_id}\",\n", + " \"pg8000\",\n", + " user=db_user,\n", + " password=db_pass,\n", + " db=db_name,\n", + " ip_type=\"PUBLIC\",\n", + " )\n", + " conn.autocommit = True\n", + " cur = conn.cursor()\n", + "\n", + " # Step 2: Database Schema & Extensions\n", + " print_step(\n", + " \"Step 2/7:\",\n", + " \"🛠️ Setting up pgvector & alloydb_scann extensions...\",\n", + " )\n", + " setup_schema(cur, dataset_cfg)\n", + "\n", + " # Step 3: Download Dataset\n", + " print_step(\n", + " \"Step 3/7:\",\n", + " f\"📥 Checking & Downloading {dataset_cfg['description']}...\",\n", + " )\n", + " download_dataset(dataset_cfg)\n", + "\n", + " # Step 4: Stream Ingestion\n", + " print_step(\n", + " \"Step 4/7:\",\n", + " f\"📂 Ingesting training data & test queries into AlloyDB ({dataset_cfg['table_name']})...\",\n", + " )\n", + " ingest_dataset(cur, dataset_cfg)\n", + "\n", + " # Step 5: Build ScaNN Index in AUTO Mode\n", + " print_step(\n", + " \"Step 5/7:\",\n", + " \"🏗️ Building ScaNN Index with mode='AUTO' (VACUUM ANALYZE &\"\n", + " \" auto-tuning)...\",\n", + " )\n", + " build_scann_index(cur, dataset_cfg)\n", + "\n", + " # Step 6: Deploy Benchmark Functions\n", + " print_step(\n", + " \"Step 6/7:\",\n", + " \"⚙️ Deploying Benchmark Functions (measure_recall & measure_qps)...\",\n", + " )\n", + " deploy_benchmark_functions(cur, dataset_cfg)\n", + "\n", + " # Step 7: Sweep & Evaluation\n", + " print_step(\n", + " \"Step 7/7:\",\n", + " \"⏱️ Benchmarking ScaNN recall & QPS across search partition\"\n", + " \" percentages...\",\n", + " )\n", + " pct_values = [0.1, 0.25, 0.5, 1.0, 2.0, 5.0, 10.0]\n", + " benchmark_results = run_benchmark_sweep(cur, pct_values, num_queries, top_k)\n", + "\n", + " # Display Table & Plot\n", + " display_summary_table(benchmark_results, top_k)\n", + " plot_results(benchmark_results, dataset_cfg, top_k)\n", + "\n", + "except Exception as e:\n", + " print_step(\"❌\", f\"ERROR: {str(e)}\", is_error=True)\n", + "\n", + "finally:\n", + " if \"cur\" in locals() and cur:\n", + " cur.close()\n", + " if \"conn\" in locals() and conn:\n", + " conn.close()\n", + " if \"connector\" in locals() and connector:\n", + " connector.close()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "bb2bb0d3c235439a8dd8b8cb9f544191", + "f0d4e9e968724c098b56d8733e8cb42a", + "9b904fc7fefd4ed2b7282dfff26e8244", + "631658ca63714d60a1cfadf61adde2f3", + "78d279973dad446b9b85635c724c0455", + "a224f47dfa8d40cfaafd52c30741db33", + "eb975b210f304ea6a2d9ae8081e46a75", + "e510a1e31be54e3b82832f1047768ad1", + "1a928fcb6f964fdca0fe3d08b5141224", + "0cde9f71448f40ba9f33d63d97f25bbf", + "5038b51e1d454b5e85f92bc905c9e5c3", + "0f1b3c48bca840a9ade73b114aa97033", + "bd95243e64284400ae94adda764dd676", + "4211e3547ca54b80ab8bd83cd18205ed", + "722cad3215fe4f8aac048fe76301f882", + "e1d193b7e60f4914a5477d618b1d2ec5", + "0a6cad141bb543ff85abe1752e92f1f0", + "42ece952d02b44c49a521f7181d6d039", + "7cae70365604497db1f33470ca3e329f", + "1f96e9c7b40e41f4882af89dae656820", + "4510043017864ff8ad0e38e33494b5fe", + "6f0d2aada81f42e3b645ba0c78f6f2dc", + "b7489eb0b544467794893578b208fc30", + "2009e650f2e544d2bd1a87bdb80f4f17", + "4b014493a650429295b29f5e860c5cf8", + "25d9691c62b745148f36c3923f457e00", + "1dd50d6fd07449ddbe838f17bf04d557", + "452d933c977342b9b7809a62bcb7114d", + "66b1ecc6a2ee4e9ab9186b4af0ee5fa0", + "dd57d3e0dfa84249a220d1472a88dfdc", + "79c81933da0c4dcfa8a2130f77c1a281", + "e956f439a7ef4b16a5a01b6c3968920b", + "32f09bc5af3e4bfebd4abd146656b47a" + ] + }, + "cellView": "form", + "outputId": "6ef00517-3025-46cb-be64-dff5b25530ea", + "id": "9WxWMjxAwH1e" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " ✅ GCP Authentication & Setup Successful!\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " 🚀\n", + " Starting AlloyDB ScaNN Benchmark Pipeline (Auto Mode - % Leaves Search)...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " Step 1/7:\n", + " 🔌 Initializing Secure AlloyDB Connector...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " Step 2/7:\n", + " 🛠️ Setting up pgvector & alloydb_scann extensions...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " Step 3/7:\n", + " 📥 Checking & Downloading GloVe-100 Angular (1.18M train, 10k test, dim=100)...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " 📥\n", + " Downloading GloVe-100 Angular (1.18M train, 10k test, dim=100) from https://ann-benchmarks.com/glove-100-angular.hdf5...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " ✅ Dataset glove-100-angular.hdf5 downloaded successfully.\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " Step 4/7:\n", + " 📂 Ingesting training data & test queries into AlloyDB (glove)...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Inserting 1,183,514 Training Records: 0%| | 0/237 [00:00" + ], + "text/html": [ + "\n", + "
\n", + " Step 5/7:\n", + " 🏗️ Building ScaNN Index with mode='AUTO' (VACUUM ANALYZE & auto-tuning)...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " ✅ ScaNN index 'alloydb_scann_idx' built in 90.53s | Index Size: 287 MB (Table Size: 519 MB)\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " Step 6/7:\n", + " ⚙️ Deploying Benchmark Functions (measure_recall & measure_qps)...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " Step 7/7:\n", + " ⏱️ Benchmarking ScaNN recall & QPS across search partition percentages...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " 🔥\n", + " Warming up database cache (0.5% leaves to search)...\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Benchmarking ScaNN Auto Search (% Leaves): 0%| | 0/7 [00:00" + ], + "text/html": [ + "\n", + "
\n", + " 📊 Benchmark Summary Table:\n", + "
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pct_leaves_to_searchRecall @ 10QPS (Queries/sec)
0.1%0.65502134.7
0.25%0.77701671.2
0.5%0.84601293.4
1.0%0.8890902.9
2.0%0.9230576.1
5.0%0.9590279.2
10.0%0.9740150.6
\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABYUAAAMtCAYAAADAKh5gAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAASdAAAEnQB3mYfeAABAABJREFUeJzs3Xd8E+UfB/BPRvfeQBllQ8veQzZUhiwZIqBsFQFBUdwCgj8cICCoKCAgIDJkFQRktGXvWVpaRsssdO+d3O8PbOzlkjZp07TQz/v1ygty9zzPPZc8uVy/ee57MkEQBBARERERERERERFRhSAv6w4QERERERERERERkfkwKExERERERERERERUgTAoTERERERERERERFSBMChMREREREREREREVIEwKExERERERERERERUgTAoTERERERERERERFSBMChMREREREREREREVIEwKExERERERERERERUgTAoTERERERERERERFSBMChMREREREREREREVIEwKExERERERERERERUgTAoTERERM+lOXPmQCaTaR4+Pj6SMj4+PqIyc+bMMXs/iejZUfB4IZPJsHbtWtH6tWvXSsoQERERlUcMChMREVG5tXPnTkmARSaTYejQoWXdNbMaO3as5DWQy+WwsrKCk5MTqlevjnbt2mHMmDFYuXIlUlNTi2xT1+ua/7CwsICzszP8/PwwYsQIrF+/Hrm5uSXej4yMDPzyyy/o27cvqlatChsbG9jY2MDb2xuNGzdG37598fHHH2Pz5s2IiYkp8fZMTVfATy6X49KlSzrLa/8woStAqKuMra0toqOjdbapPRZ0/dhhSoaMk8aNG+P1119HQEBAqfaFyqfk5GQsX74cL7/8MmrVqgUnJydYWlrCy8sLLVu2xDvvvIMjR44U2Y72j3TaDxsbG1SpUgU9e/bEd999h9jY2ELbu3nzJmbNmoW2bdvCzc0NFhYWcHJyQq1atdC6dWuMHj0a3333HQ4ePAi1Wm2ql4OIiOiZoSzrDhARERHpoz0LL19AQAASEhLg6upq3g6VI4IgICcnBzk5OUhJScH9+/dx5swZ/P7773jvvfcwbdo0zJ07FxYWFka3nZeXh+TkZCQnJyM0NBSbN2/GggULsH//flSvXr1Y/Q0JCcGAAQMQGRkpWffo0SM8evQIISEh2LdvHwBg2bJlmDp1arG2ZU6CIODjjz/G/v37TdZmZmYm5s6dixUrVpiszdJQcJyEhIRg/fr16NWrF7Zv3w57e/uy7h6Zwffff4+5c+ciJSVFsi4mJgYxMTG4ePEili1bhlatWmHt2rXw8/Mr1raysrIQHR2N6OhoHD58GP/73/+wcuVKnT8SLlmyBLNmzZL8mJWSkoKUlBRERkbi/Pnz2LhxIwAgNTWVY5aIiCoczhQmIiKicik2NhZ///23znU5OTn4448/zNyjZ0daWhoWLFiAzp07Iz4+3iRthoWFYfz48cWqm5qait69e+sMCD8PDhw4gKCgIJO2uXr1aty8edOkbZrDwYMH8cknn5R1N6iUqdVqjBgxAjNnztQZENbl/PnzaNu2LQ4dOmSSPiQlJWHEiBE4duyYaPmOHTvw7rvvmuTqBiIioucZg8JERERULm3cuLHQP+r1zSKuKI4dO4bIyEhcvXoVO3fuxMSJE2FlZSUqc/r0abz88ssGBUfatm2LyMhIREZGIiwsDCtXroS1tbWozOHDh/H48WOj+7p27Vo8fPhQ81wul2PWrFk4evQowsPDce3aNezfvx8LFixA9+7doVQ+exezffTRRyZtLy8vD5999plJ2zSF/HFy584dnD59GlOmTJGUWb9+PS/Hf8599tln2Lx5s2iZo6Mj5s+fj3PnziEsLAw7d+5Ejx49RGXS09MxfPhwg34g8vb21hyTIiIiEBAQgDZt2ojKqFQqfP7556Jl8+fPFz338fHBqlWrcP78edy8eRMXLlzAH3/8genTp6Nu3brG7DYREdHzRSAiIiIqh5o2bSoA0DwGDBggeg5AuHbtmt76s2fPFpWtUaOGpEyNGjVEZWbPnq23vaCgIGH8+PFCgwYNBEdHR8HCwkLw8PAQOnfuLMybN0+IiYmR1Bk/fryo/W7duultv1GjRqKyH3/8sWbdmDFjJPseGRkpaePatWuCt7e3pOzy5cslZbXLdOnSRVLmjTfekJQ7ffq03n3QZ9iwYaI2xo4dW2j5R48eCeHh4YWWOXbsmPDGG28IjRs3FlxcXAQLCwvBy8tLaN68ufDOO+8Ix44dE5V/8uSJsGLFCuGNN94Q2rVrJ9SqVUtwcnISlEql4OTkJDRq1EgYO3ascOjQIb3bXLNmjeT1KPjYvn27qLz2GNR16q2rTP5DJpMJFy5cEJXXHgu6xnVkZKSkrcDAwEJfT30MGSctWrSQlHvy5IneNp88eSLMmzdP6Ny5s+Dh4SFYWFgIzs7OQvPmzYVZs2YJ9+/fL7JfiYmJwuLFi4U+ffoI3t7egrW1tWBnZyfUqlVL6Nevn7BkyRIhJSVFVOfgwYPC7Nmzhf79+wt+fn5CpUqVBCsrK8Ha2lqoXLmy0KNHD+Gbb74RYmNjDX491qxZI1qva4wYY8aMGaK6LVq00Fu2c+fOorLjxo3TrFOr1cJff/0lDBkyRKhdu7Zga2srKJVKwdPTU/Dz8xMGDx4sLFiwQDh+/LhR/RMEQbh9+7agVCpF23ZychJCQkJ0lh83bpzkNRk1apSknPbxWNfYTkhIEBwcHETlFAqFkJWVJQiCIKSnp0u2FRQUVOj+nDhxQsjJyTH6dSAiInrWMShMRERE5c6lS5ckf9iHhIQIzZs3Fy2bOXOm3jZMFRROSEjQGZDWftjZ2Qnr1q0T1b18+bIkyBcRESHZxvXr1yXt3bx5U7Pe0KCwIAjC8ePHJWWrVq0qqNVqUTlDgn1vvvmmpFxRwVpdevXqJWpjyJAhRreRLzY2VnjppZeKfD8GDhwoqrdjx44i6+Q/XnnlFSE3N1eybV0BP2tra83/GzZsKOTl5WnKFzcoXLDNXr16icqXx6Dw8OHDJeXS09N1trd69WrB1ta20NffyspKWLVqld4+bdq0SXByciryfbx06ZKonvYPTfoebm5uel8v7bKmDgpfvXpVUv/GjRuScvfv3xdkMpmoXH6AV61WS36I0feoX7++Uf0TBEF49913Je0sWrRIb/m0tDTB09NTVF6hUEh+SDMkKCwIgtCqVSvJ9h89eiQIgiA8fPhQsi4gIMDofSQiIqoImD6CiIiIyh3t1BDNmzeHn58fRo8eLVq+ceNG5OXllVo/srOz0b9/f+zevbvIsunp6RgzZozmxkUA0LRpU3Tu3FnzXBAErFq1SlJ3y5YtouedO3dGnTp1itXnjh074oUXXhAte/DgAa5evVpovaysLERFRSEqKgrh4eH47bff8Pvvv4vK1K9fv1iXW1eqVEn0/K+//oK/vz9WrFiBK1euGPwepqamomfPntizZ4/RfTDG5s2bMXfuXIPKvv3225r/h4WFYd26dSXefsE2Dx48iMDAwBK3WZrCw8NFz+vVqwdbW1tJuV9//RUTJkxARkZGoe1lZ2dj4sSJWL9+vWTdunXr8OqrryI5OblknS5EfHw8Bg8ebLJ83MZo3LgxWrVqJVqmK3/6pk2bIAiC5nn9+vXRsWNHAMD27duxdevWUuvjgQMHRM9lMhnGjBmjt7ydnR2GDx8uWqZSqYo1rjMzM3Hnzh3JcmdnZwCAm5ub5Oaar776KqZMmYIdO3bgwYMHRm+TiIjoecWgMBEREZUrubm5kiDIa6+9BuDpH/cKhUKz/PHjx9i/f3+p9WXZsmU4ceKEaFmnTp2wf/9+XLlyBcuWLYOdnZ1o/dSpU5GUlKR5Pn36dNH6tWvXSnL8ageFJ0yYUKJ+d+3aVbLs0qVLhdY5c+YMatasiZo1a6JBgwaYMGECMjMzNetdXV2xYcMGyGQyo/szaNAgybKDBw9i8uTJaNasGezt7dGhQwd88sknuHLlit525s6dK1lfp04drF69GiEhIQgLC8P27dvx6quvSvISKxQKtGvXDl999RV2796N06dPIyIiApcvX8bWrVs1AbV8S5cuRU5OTpH79uabb6JmzZqa53PmzEF2dnaR9QrzySefwNHRUfPc1PmKSyL/x4PIyEicOXMGkydPlrwnunIhP3r0CDNmzBAt6927N/bt24cbN24gKChIMk6mTZuGxMREzfPHjx9LchjLZDK8+eabCA4ORkREBE6fPo1vvvkGtWrVkvTB09MTr7/+OtavX4/Dhw/j6tWrCA8Px/HjxzFnzhxRTu6kpCSsXLnS0JfFpLQ//5s2bZKU0V5W8CaQwcHBonX+/v4ICgpCREQErl27hr1792L+/Pno1q2b0fm7VSoVwsLCRMtq1aoFNze3Quu1bt1asuz69esGbzc3NxfXr1/HK6+8goSEBNG6Vq1awcbGBgBgZWWF3r17i9anpaXhp59+wssvv4xq1arB09MTgwYNwooVKyRtERERVShlPVWZiIiIqCDty/wVCoUQHR2tWW9oKgJTpI+oVauWaH3NmjUluSc3bdokuVz5p59+0qzPy8uTbGfLli2a9dqXizs6OkouvTcmfYQgCMLPP/8sKf/tt9+KymivL+yhUCiElStXCiqVSu82C6NWq4WhQ4cavL0BAwZIctJmZ2cL9vb2onK1atUSEhISdG4zMTHRqD7GxcVJ+qGdP1lXaoDIyEhhw4YNomULFy4UBKH46SMEQRDmz58vWrZt2zZBEMo+fURhDxsbG+GHH37Q2c68efNEZRs3biwZT7o+K8uWLdOs/+qrryTbXLp0qc7t5eTk6E1hoc/UqVNFbffu3bvI18PU6SMEQRCSkpIEGxsbURtnz57VrA8LCxOtUyqVomPk5MmTRev//PNPvdvSzrtclCdPnkj2r3379kXW279/v6Te22+/LSqj/d4b+tixY4eonVu3bknSVeh72Nvbaz6vREREFQ1nChMREVG5op06olevXqL0A9opJAICAkpltteDBw8klymPGzdOcmny8OHD4eLiIlp29OhRzf8VCoUoHQAA0QzEzZs3i9aNGDFC56X3xhAKXFaerzgzfPOpVCpMmjQJI0aMKFa6DplMhs2bN+O7776Dh4dHkeV3796N3r17i7Z17tw5pKWlicp98MEHktc+X/7l5AU9fvwYX331FXr06IFq1arBzs4OcrkcMpkM7u7ukvKGXmo+cuRING3aVPN8wYIFSElJMaiuPjNmzBCN+88++wwqlcqguj4+PhCe3jtE89A1e9yUXF1d8ffff2PatGk612vPXr127RoUCgVkMpnmoVQqcffuXVG5gp8l7XQDVapUkcwczmdhYaHzc7R3716MHTsWTZs2hYuLCywsLDTbX758uahsWaUacHJywssvvyxaVvDqCe0rKfr27SsaKy1bthStnzhxIl555RV8+eWX+PPPP3H16lXNWHJwcDB19w1m6HjWR6lU4vvvv5fMMK9duzbOnz+PV155RXRliS5paWl4//338f3335eoL0RERM8iBoWJiIio3IiNjcXff/8tWpafOiLfyy+/LAr25OTk6My5WVKPHj2SLKtdu7ZkmVwuR40aNQqtO2nSJFGfDx06hMjISACmTx0BAA8fPpQsKyoY26VLF00AMTc3F+Hh4RgxYoSozNatW4t9Sb1cLsf777+Phw8fYv/+/fjoo4/QtWtX2Nvb6yx/6dIl7Ny5U/Nc1/uhHfwqTEBAAOrUqYPPPvsMR44cwYMHD5CRkaEzgJ5POwitj0wmw//+9z/N8/j4eHz77bcG900XOzs7fP7555rnN27cwJo1a0rUZmlKSEiAv7+/zlQHgO4xaYjo6GjN/7XHQLNmzYoM+uXLyMhA79698dJLL2HdunW4evUqkpKSCv2Rw9D3vzRoHwc2b94MtVoNoPDUEcDTH87atGmjeZ6WloYtW7Zg9uzZePXVVzUB8ddffx03b940ql+urq6SH5hiY2OLrBcTEyNZZsgPRNpkMhlq1aqFyZMn4/Lly3j33Xd1lqtWrRr+/PNPPHjwAGvWrMGECRPg5+cHuVz3n7/z5s2TpPUhIiJ63jEoTEREROXGxo0bJX+Yjxo1SjSb0MHBQXKjKu3ZxeWNi4uLaIaz8O8N5y5duiQKyjRq1EgUzCkuXTdwat68ucH1lUol6tWrh3Xr1kkCNyXNs2phYYEXX3wRCxYsQGBgIJKSknD06FF069ZNUvbkyZMl2la+uLg4jBo1Cunp6UbVKyxgrK1v376imwouWbIET548MWp72iZNmiT6IWLu3LnIysoqUZsllf/jQXJyMjZv3izKfZybm4vx48fjxo0bJttewbzWJTF//nzJDdKKYsz7b2pdu3YV5UWOjo7GkSNHcO7cOdy6dUuz3MvLC/369RPVtbKywtGjR7FkyRK0bdtWZ97g1NRUrF+/Hm3atNF54zZ9lEol6tevL1p2584dUR51Xc6ePStZ1rhx40LreHt7IzIyUvN49OgRMjIycPv2bfz000/w8/Mrsr+VKlXC2LFjsWrVKoSEhCAuLg6rV6+W5EBOSkqS5EomIiJ63jEoTEREROVGcYO7Fy5cQEhIiEn7UqVKFcmy27dvS5ap1WrJJe+VK1eWlHvnnXdEz9esWSOZ4aw94684jh8/LgmmVq1aFU2aNDG6LUtLS8ksaGNnFhZFoVCgU6dO2L17tyR4VTCIq+v9uHDhgkHb2Lt3L1JTU0XL3njjDRw7dgw3b95EZGSkSQKZX3/9teb/6enpJf6xwsLCAvPnz9c8f/DgAXbt2lWiNk3F0dERw4cPx4YNG0TLs7Ky8P7770vKa79/vXr1EgX89D0CAgL0tnH58mXN7NmiaM+urV69OjZs2ICrV69qtvXWW28Z1JY5yGQyjB07VrTsjz/+kBwzxowZozPoa2VlhenTp+P06dNIT0/H9evXsXv3bsybN090fEpKSsKyZcuM6luvXr1Ez9VqNTZu3Ki3fEZGBrZu3SpaZmlpCX9//0K3o1Qq4ePjo3lUrlwZ1tbWRvVVm4uLC8aPHy/6XOUz9kcjIiKiZx2DwkRERFQuXL58GVeuXCl2fVPPFq5atapoph7wNJCrPZN5y5YtSExMFC0rOGM0n5+fH3r06KF5Hh0djaVLl2qeW1paSlJlGOvatWuSlA8A8NFHHxWrvdTUVEkQ2NDL9QtasGABfvjhB0lgtqDMzExJgM/Ly0vz/9atW8POzk60fuHChUhOTtbZXsGZi9qpCxwdHfHLL7/ghRdeQJ06deDj44Nr164Zujt6tW/fXpTf1BSzel955RXRLG9D2oyKihLNrpfJZAgKCipxX3Tp37+/aFwDT4Pwp0+fFi3Tzml86tQp5ObmioJ+BR/VqlXDhQsXYGVlpamjPZv80aNH+Pnnn3X2Kzc3V3RFgfYYmDFjBkaNGoXGjRvDx8cH3t7eOHPmjMH7bQ5jx44VpTvYvn27JAe5rh+SYmNjRWkxLC0t4evri/79++Ozzz7DrFmzROWNnSE7ZcoUyXFg9uzZohnMBU2fPl0ya37MmDE6836bwqBBg3D48OFCZ3rrCgAXPN4QERFVBAwKExERUbmgHdStVq1aoTMIp06dKiq/cePGYt0ErTCTJ08WPY+MjESPHj1w4MABXL16FT/++CMmTpwoKuPs7IyRI0fqbE97tnDBAPOAAQN03uxMnwcPHiAqKgohISHYtWsXJk2ahNatW0uCX507d8Ybb7xRZHtZWVmIiopCVFQUbt26hX/++Qf9+/eXBF1btGhhcB/z3b17F9OnT4eXlxeGDBmC5cuX49ixYwgPD8e1a9ewefNm9OrVSxIULhgEtLS0xJtvvilaf/v2bbRp0wZr165FaGgobty4gT179mD8+PGYNGmSppx2CoyUlBR8+umnuHbtGi5duoRvvvnGJLO0AeCrr74qVuBcH5lMhgULFpisvdLw6aefSpZ9+eWXoufjxo2DjY2N5nlaWhq6du2KxYsX48yZM7h58ybOnz+PDRs24M0330TVqlUxdOhQ0Q37xo8fL/lhYNq0aXj77bdx7Ngx3Lp1C+fOncPSpUvRuHFjREREaMrpSoOyf/9+hIeHY9++fXjxxRdx6dKlEr0OplatWjXRrNzk5GRRjuWOHTtKUjkAT/MPe3t7Y+LEiVi3bh1OnTqFiIgI3LhxA9u3b8dPP/0kKq8vr7c+9evXx/Tp00XL4uPj0bZtW3z33Xe4ePEiwsPDERAQAH9/f6xatUpU1svLC/PmzTNqm8bYv38/evbsCR8fH0yfPh1//vknLly4gJs3b+Ls2bNYsGCBKF838HTmuPaPgERERM89gYiIiKiM5eTkCB4eHgIAzWPy5MmF1jl69KioPAAhICBAs3727NmidTVq1JC0UaNGDVGZ2bNni9ZnZWUJHTp0kGynsMeGDRv09lmlUgm1atXSWe/vv//WW2/MmDFG9SH/0b59eyEuLk5nm8VpD4Cwa9euQt8XXd58802jt9OxY0dJO8nJyULjxo0Nqj9w4EBNvQcPHghWVlaFlq9cubJk2Zo1a0TbX7NmjaRMZGSkpJ/jxo3Tux1t2uNU3+l5t27ddLana1xHRkZKygUGBhb2Fuml3U6XLl10lmvbtq2k7Llz50Rlfv75Z6PHgfbru3r1aoPrXrp0SVNv6tSpRZbXHgO6XtvijJGS2Lx5s97+rl69WmedZcuWGfUaa++DIfLy8oRBgwYZ/X46OzsLZ8+e1dmm9vFY1+tviKI+67oev/76a7G2RURE9CzjTGEiIiIqc3v37pXcwf6ll14qtE6HDh3g4uIiWmbqFBJWVlbYs2cP+vfvX2RZW1tbrFu3DqNGjdJbRi6XS2Y4A09TVbz44osl6mtBjo6O+Oyzz3D06FHJDZWKy8LCAosWLcKAAQOMruvq6mpU+Xbt2mH79u2S5Y6Ojjh06BB69+5tVHve3t5YvHgxZDKZ3v7t3r3bqDYLM3fuXFHaA1MomK+4PPrkk08ky7RnC7/11ltYvXq1ZLavPu7u7qLZxcDT2cLr168X3eDOEHPnzoWvr6/e9a+//rpodnl5MXDgQJ2fH3t7ewwfPrzE7Y8aNQpjxowxup5CocD27dvx9ddfw8HBwaA6nTp1wvnz59G6dWujt2cMY443CoUCX3zxRbl874mIiEobg8JERERU5rSDuba2tujevXuhdRQKhSQ4GBAQgISEBJP2zcXFBbt378aRI0cwbtw41K9fHw4ODlAqlXB3d0enTp3w5ZdfIjIyEq+//nqR7Y0fP15yubZ27lBDyGQyKJVKODg4oFq1amjbti1ef/11rFq1Cg8fPsS8efN03oDKUFZWVvDy8kLnzp3x2WefISwsDO+9916x2vrf//6HyMhI/Prrrxg/fjzatm2LSpUqwcbGBgqFAg4ODmjQoAFGjhyJ7du348SJE/D09NTZlqenJ/bt24fg4GBMmjQJjRo1gpOTE5RKJTw9PdG8eXNMmzZNcrOzyZMn49ChQ+jTpw+cnZ01N9F76623cOXKFbRq1apY+6ZLtWrVdAb/S6JNmzYYMmSISds0pf79+6NRo0aiZQEBAZKUDOPHj0dUVBS+/vpr9OjRA5UqVYKVlRUsLS1RqVIldOrUCe+99x727duHR48e6czzOnr0aERFRWHRokV48cUXUblyZVhZWcHW1hY1a9ZEv379sGTJEtSuXVtTx9XVFadPn8Ynn3yCevXqwdLSEs7OznjhhRewfv16rFu3Tu+PBmXJysoKo0ePliwfPny43rQPY8aMwZ49e/Dxxx+je/fuqFevHlxcXKBQKGBvb4+GDRvi9ddfx4EDB7Bhw4Zi77dMJsOHH36I+/fvY/ny5RgyZAhq1aoFR0dHSZstWrRAYGCg6D0pLffv38exY8cwf/58DBw4EH5+fnB2doZSqYSFhQXc3d3Rvn17fPDBB7h27Rrmzp1b6n0iIiIqj2SCUEgGfiIiIiIyuTp16uD27dsAngZWbt26xXyWRPTcyMzMRJcuXXDu3DnNsqlTp2LZsmVl2CsiIiIqiDOFiYiIiMxEEAT88MMPmoAwAPj7+zMgTETPFRsbG+zatQtVq1bVLFu+fDkWLlxYhr0iIiKigjhTmIiIiKiUffjhh/jrr78QFxeH5ORkzXKZTIbjx4+jQ4cOZdg7IqLScfnyZbzwwgtIT08H8PSYt3nzZgwbNqyMe0ZERETFTzRHRERERAZ58uSJaHZwvo8++ogBYSJ6bjVr1gwBAQEIDg7WLLtz5w5yc3NhYWFRhj0jIiIiBoWJiIiIzMjNzQ2+vr6YMWMGXn755bLuDhFRqerWrRu6detW1t0gIiIiLUwfQURERERERERERFSB8EZzRERERERERERERBUIg8JEREREREREREREFQiDwkREREREREREREQVCIPCRM+ojz/+GDKZDDKZDEqlEjdv3iz1bfr4+Gi2KZPJMGfOnFLfJtGzbO3ataLPjEwmK+suFcuBAwdE+/Dbb7+VdZfoGTN27FjRGOratWtZd+mZon0cWbt2bVl3iQoxZ84c0fvl4+MjKcNzqmfLF198ITrvDgsLK+suPZOel/MiovKqc+fOms9WzZo1kZ2dXdZdonKOQWGiZ9D9+/exZMkSzfPhw4ejbt26hdbJycnBpk2bMGnSJDRt2hReXl6wtLSEjY0NPD090bp1a7z++utYuXIloqOjS3kPdGvWrJnoJLFq1apQq9VF1mvRooWoXuXKlZGXl2eGHotdvnwZK1aswIQJE9CkSRMolcoi/yjUJy0tDYsWLUKXLl0075WXlxe6dOmCRYsWIT093aB2Tpw4gQkTJqBu3bqwt7eHvb096tati4kTJ+LkyZPF3FP9tN/D/EdISIjJt0XmoVar8cEHH2ie16hRA6+99pqkXExMDLZt24YPP/wQ3bt3h5OTk2QcBAUFmaRP9+7dw8aNG/Huu+/ihRdegJ2dnWRbUVFRBrW1b98+jB07Fo0aNYKTkxOUSiVsbW1RvXp19O7dG0uXLkVKSorOurr+uJXJZGjQoAEKu4/vxo0bddYz5hhR0M6dOzFnzhzNgwFD08jMzMSBAwcwf/58DBw4EN7e3pL3zJhAXkhICKZNmwZfX184OTnBxsYGPj4+GDlyJP7+++/S2xEDRUVFicbRnDlzkJSUVNbd0isoKEjU14LnRVT2kpOTERAQgC+++AJ9+vSBu7t7iX7cMMX5TEnOraZPnw57e3sAgEqlEn0vUsW0c+dOnd/lQ4cOLbReVFSUpM7YsWOLVVbX9o156PuBNi8vD1u2bMG4cePg6+sLd3d3WFhYwN3dHb6+vhg3bhw2b95str+3DO333bt3UadOHUn5r7/+ulT7l5eXh6CgIHz33XcYPnw4atasafB7rMvdu3cxa9YsNGvWDK6urrC2tka1atUwePBgbNq0qdBzzE8//VTz/6ioKCxbtqwku0YVgUBEz5zXXntNACAAEGQymRASElJo+Z9//lnw8vLS1CnqIZfLhTVr1kjaqVGjhqjc7NmzTbpfixcvlvTl0KFDhdYJCQmR1Jk5c6ZJ+2Uo7ddH+1GjRg2D2jl58qRQuXLlQtuqUqWKcOrUKb1t5ObmChMnTizyvZ40aZKQl5dnkv2/dOmS3u2U1XtS1tasWSN5LZ41q1evFvX/xx9/1Flu9uzZRY63wMBAk/RpzJgxRW4rMjKy0DaSk5MFf39/g46JHh4ewrFjxyRt6Hp/8x8HDhzQu+02bdqU6BhR1OvRpUuXYrVTmp6FPmoLDAwscmwY+j34+eefCwqFotC2+vfvL6Slpemsr11W13d0Sena36I+R2VJ+5hT3M9PaTCkb6V9TlXWCjs+GjOOTXU+Y4pzq/fff19U/vDhw8V5aSq05+G8KN/AgQN1jiNLS0shPj5eb73IyEhJnTFjxhSrrCHnMIU9dH0X79u3T/Dx8TGovo+Pj/D333+X8JUsmiH9vn37ts6/xRYvXlzq/dP1Phn6Hmv7+eefBWtr60LbateunfDkyRO9bbRq1UpT1tnZudDxSMSZwkTPmPv37+OPP/7QPG/fvj38/Px0ls3NzcWQIUMwefJkPHnyxOBtqNVqxMXFlbivxho1ahQsLCxEy37//fdC66xfv16yzJhfYsubkJAQ+Pv7Fzlb+9GjR+jVq5feGbgTJ07EqlWritzeypUrMXHixGL1VVthM342btxYJrO3qWQEQcA333yjeW5tba1zlvCz6N1338U///xjUNnY2FgMHjzYqFmT+mZmnD17FmfPnjW4nefFwoULERkZqXn8+eefZd0ls5kzZw7mzZsHlUpVaLmAgAAMGDCg0BlA9Pw4fvy46DMxY8aMsu5SuWSK8xlTnVtNmjRJ9Lzg9yNVLLGxsXqv8MjJyRH9rfYsWbp0Kfr27Wvw1VZRUVHo168fli5dWrodK0J4eDg6d+6Mu3fvapbJZDL8+OOPz9Sxde3atZg8eTKysrIKLXf69Gl069YNmZmZOtcXPFYlJSXhl19+MWk/6fnCoDDRM+bXX38V/WE5atQovWUnTJiA7du3i5bJZDIMGjQIGzZswKVLl3Dz5k2cP38eGzduxNSpU+Ht7V1qfS+Kh4cH+vbtK1q2fft2ZGRk6CyvVquxceNG0bKWLVuiUaNGpdbHwtjb26Njx46YMWMGNm7ciH79+hndxvjx45GWlqZ57uLigo0bNyIsLAwbNmyAs7OzZl1aWhomTJggaWPv3r1Yt26daNmwYcNw4cIFnD9/XnJZ29q1a7Fv3z6j+1pQbm5uoSfAjx8/xv79+0u0DTK/I0eOICIiQvO8f//+cHBw0FlWLpejQYMGGD16NJYuXYrFixeXWr+USiWaNGmCCRMmYMWKFfjkk0+Mqp+TkyM5djg5OeG3335DaGgogoKC0LlzZ9H6uLg47Nmzx+Bt/P3337hz545k+Q8//GBUX58X7u7u8PHx0TwqVapU1l0qkkwmQ5UqVTBw4EDMnz8fBw4cMLqNK1eu4KuvvhIt69atG06cOIGrV6/i7bffFq07cuQIVqxYUaJ+07OhatWqos9Ewe/350F+Psvhw4fj22+/xYYNG4xuw1TnM6Y4twKAevXqoVWrVprnBw8exO3bt43eL3r2bdy4Ebm5uXrXmyuNU8Eflgo+tLVt21ZnuYI/0O7duxfvvfee6IdJuVyON954A0FBQQgPD0dgYCDeeOMNyOX/hZEEQcB7772HvXv3lu7O6nH9+nV06dIFDx8+1CyTy+VYuXKl5Du2NHl4eKBPnz74/PPPsXv3blSpUsWo+tHR0Zg+fbpoWZMmTXDo0CGEhoZqctXny1+my7Bhw2Bpaal5/uuvvxqUkpEqqLKdqExExlCpVKJL32QymRATE6Oz7P79+yWXmtja2gr79u0rdBtqtVrYuXOnsHfvXsk6Yy51DAoKEsaPHy80aNBAcHR0FCwsLAQPDw+hc+fOwrx58/T2e8eOHZJ+b9iwQWfZw4cPS8ouW7ZMUi4yMlL46KOPhDZt2ghubm6ChYWF4OrqKrRv31748ssvhbi4uEJfE0Op1WrRc+3LpYu6tDU4OFiyP7/99puozK+//iopc/ToUVGZbt26idbXrl1byM3N1azPycmRXBbWvXv3Eu279vtmZWUluTR/yJAhhbahvV9r1qwRMjMzhW+++UZo1qyZYGdnJ9jb2wvt27fXOybyJSYmCrNmzRLq1KkjWFlZCZ6ensKgQYOE48ePC4JQ9Fg29PJGXX02tp2QkBDhu+++E0aOHCk0b95cqFatmmBnZydYWFgI7u7uQtu2bYWZM2cKoaGheve3S5cukkvUVCqVsGLFCqF9+/aCk5OTzv4V5ZVXXhG1u23bNr1ltce/rkvRTZU+Qntbul7nwi57j46OlpT/8ssvRWXu3bsnKfP1118XuV2ZTKb5v3balMePHwuWlpY6yxpyjNCm/b4X9ij42usat8nJycInn3wiNGzYULCxsRG9hpGRkcLSpUuFsWPHCq1atRJq1KghODg4CEqlUnBxcRGaN28uTJ48WTh79qzevhqSPsKUxwBT0B5nuvpY1CX/48aNE5V3dHQUkpKSRGU6dOggKlOnTh3Jtos61ly/fl3w8PAQlalbt65w7969IvfTkMv8Cx5btGVmZgorV64U+vfvL1StWlWwtrYW7OzshLp16wrjx48Xzpw5U+j2Dx06JIwePVqoX7++YG9vLyiVSsHNzU1o0KCB0K9fP2HOnDnC/v37NeUNSR+j73UypfXr1wsdO3YUHBwcBAcHB6FNmzbCr7/+KqjVapOkj9CXzuPatWvCiBEjBC8vL8HGxkZo1KiRsGjRItH3/J49e4QePXoILi4ugq2trdCiRQvhxx9/1DmmBeHpd2ZkZGSxHwW3nU97W7oury7q/THF+Yypzq3yLVy4UFTuo48+KnQfSkLXaxYYGCjcu3dPmDhxoubzVrduXeHzzz8XpZ85fvy4MGDAAMHDw0OwtrYW/Pz8hK+++krIysoqdJsPHz4UZs+eLXTs2FFwd3cXLCwsBEdHR8HX11eYNGmScPLkySL7vWfPHqFXr16a8dekSRPh22+/FbKzs41KH5GcnCwsXrxY8Pf3FypVqiRYWloKDg4Ogp+fnzBlyhQhLCxMb93MzMwSjenU1NRC97Fp06aifRgwYIBkv65du6azrinTR+ijXaeolE25ublCnTp1JPX0fdeuXbtWUrZOnTomS0mnTd/+XLp0SXB3dxetUygUwu+//663rdIYG7qOrdrH+KLet7lz54rKy2Qy4datW6IyI0eOlJxT6Es79dJLL4nKFvweJSqIQWGiZ8jFixdFB3dfX1+9ZTt16iT5Al21alWJtm9IUDghIUHniZH2w87OTli3bp2kfk5OjuQPW39/f5390f5jWzuHl1qtFubPny8olcpC++Ls7CwEBASU6LXRxdig8NSpUyUnA8nJyaIyiYmJkkDStGnTNOtjY2Ml63Xl850xY4ZkWyUJjmvnVRs6dKiwa9euQt8fbdrvy9y5c4WGDRvqfd/0BWNu3bolVK9eXWcduVwuLFmypFwFhadPn17k5wWAoFQqhe+//15nP7SDgyNHjhT69u1bZP8Ko1KpBBcXF1F9fT/m6FKaQWFtxgaFVSqVYGtrKyr/7bffisrExMRI2ty0aVOR233xxRc1/3dxcRHS09M15efMmSN6P3v06GHUMUKbqYLC8+bNE2rWrKn3NdSV713XQyaTCe+9957OvhYnKFzcY0BpMqYPKpVKcHR0FJXX9ePYkiVLJO1euHCh0O0W/CzfuHFDct8APz8/ITo62qB9KklQ+NSpU0Xm0wcgvPXWW0JOTo5k2zNnzjRou1ZWVpo6ZR0UzsvLE1599VW92+zbt6/w8ccfF/nZLk5QePHixaIflgo++vTpI6hUKkne24KPCRMm6NwnQ3LCF/Yo7Hibz9igsKnOZ0xxblXQmTNnROWaNm1a5L4Xl67XbMGCBZLjSv6jefPmQlpamrB06VJBLpfrLNOrVy9BpVLp3N6PP/4oWFlZFfl+v/rqq3qDprNmzdJbr1WrVjq/T3QJCAgQ3NzcCu2HXC6X/KCbz5Cc8MU9dui6h0ZISIjQvHnzIservve1rIPCuibl9O/fv9A6us4zd+7cWWTfikPX/pw9e1ZynqpUKoXNmzcX2lZpjo2CjA0KN2rUSFS+ZcuWkjI7d+6U9Oevv/7S2d4333wjKjd9+nSD+k0VD9NHED1DgoKCRM/btm2rs1xCQoLkTsze3t6lnms3Ozsb/fv3x+7du4ssm56ejjFjxkgu4bawsMDIkSNFyw4fPizJA5eZmYm//vpLtKx///5wdXXVPP/000/x2WefFZnLNikpCYMHD0ZgYGCR/S5N586dEz2vVq0aHB0dRcucnZ0lKT4K1jt//rwkH6WunNPaKTYEQcD58+eL1W9dedVee+019OnTB25ubpplxuZYmzNnDsLCwvSunzdvnii1AfB0DA4YMAD37t3TWUetVmPGjBmiS8yeFXl5eXjvvfdw6NChIstu2bJFb647Q125cgWJiYma5zVr1oSHh0eJ2iwv5HI5Jk+eLFq2dOlSHD16FJmZmbh37x6mTJkiWu/t7Y3+/fsX2fa0adM0/09MTNRcMp2bmyvK6TZ48GBUrVq1JLthMnPnztV5uamxBEHA999/j9WrV5ugV8U7BpQnERERSElJES0z5HgMSL8P9Ll16xa6d+8uum9A8+bNERQUVOopOi5duoSePXuKcjjqs2LFCrz11luiZefPn8eiRYtKq3ulZt68edi0aZPe9X///Xep5dd87733kJOTo3Pdvn370KtXLyxcuFBv/dWrV5f5uY6hTHU+Y4pzq4KaNWsGKysrzfOrV68iISGhkD0xrU8++URyXMl36dIlvPTSS5gxY4beS8UPHjwoSckBAD/++COmTJmC7OzsIvuwadMmDBs2TJInfe3atfj222/11jt//jw+/fTTItvft28fBg0ahPj4+ELLqdVqfPHFF5g3b16RbZqSdmqI5s2bw8/PD6NHjxYtf5bup6HrHgvjxo0rtM748eMNaqc03LlzBz179hSdp1paWmLr1q0YPny4WfpgSunp6QgNDRUtK+n5gnacQDuOQJSPQWGiZ4j2zYmaNGmis9y1a9ckJ2pdu3aFQqEQLcvKykJUVJTeh7EnMsuWLcOJEydEyzp16oT9+/fjypUrWLZsGezs7ETrp06dKrl5k3bwWqVSSYKJu3btkpwUF6x36dIlfP3116L1I0eORGBgIG7cuIEDBw6gU6dOmnV5eXmYOHFiofnBSpt2UMbT01NnOe3lBevpCuzoakfXsuIGhbTzqrm5uaFPnz6wsLCQnJgZk2NNEAS0bNkSBw8exOXLlyVBOrVajc2bN4uWrVq1SnJS1b59ewQGBiIsLAxLly6FlZVVuTpJt7W1Rb9+/fDjjz9i//79uHDhgibX9y+//CIJHBb2B3++vLw8WFhYYPbs2bh48SKuXr2K33//HfXq1TO4X4Yeb55V//vf//DGG29o8rM9fPgQXbp0ga2tLWrUqIGtW7dqytatWxf79++XHL908fPzQ/fu3TXPly9fDgDYunWr6Metd955p8T78OeffyIyMhJDhgwRLdeVO7Bdu3Z628nLy0OlSpWwcuVKhIWF4dy5c1i4cCHs7e0BPP1Dq3v37vj++++xd+9enD17Fjdv3sTFixfx+++/S/5w+e6770q8b0DxjgHlSWkfj+/cuYNu3brh0aNHmmVt27bFkSNH4O7ubnA/hw4disjISJ2BzmPHjonGUf7xRxAETJgwAenp6Zqy9evXx8aNGxESEoLz58/j448/FuU//O2333DkyBHN86NHj4q21aJFCxw4cADh4eG4fv06/vnnH3z33Xfo27cvrK2tNeXyb1qonXvR29tbMu61c86WVGxsrOTcwtbWFj/++COuXLmCXbt2oUGDBnrvhVBSgiDgww8/REhICPbs2SN5n48cOQKlUolFixYhNDQUa9asEeWVBCD5Mb68MtXnxxTnVgVZWlqiQYMGmueCIBj8I44pCIKAcePG4fLlywgKCkLt2rVF64OCgiAIAj766COEhIRgx44dknzV2mPgwYMHeP/990XLnJ2d8csvv+DKlSvYu3cvWrZsKVq/f/9+0c2ec3Nz8fHHH4vKKJVKzJ8/HxcvXsSBAwfQoUOHIj8bmZmZmDBhgujvmLZt22LHjh0ICwvDqVOnJDcUnDt3rtl+INR1D438G/C++uqror+1nqX7aVy/fl2yrHXr1oXW0bVe300aTe3+/fuivwOtrKywfft2DBo0yCzbN7V79+5Jfsgp6flC06ZNRc+vXr2q98Z0VMGVzQRlIioO7UuF9eV52rJli+TSklmzZknKFXX5jPblgEVd6lirVi3R+po1a0ouF920aZNkOz/99JOkb9q5upo0aSJar33JUqVKlUR55iZMmCBa369fP8k20tLSBGtra1E5U6aRMDZ9hPYle506ddJZ7oUXXhCVK3hZ7YIFCySv7+HDhyVtHDp0SFJuwYIFxdpP7fdqypQpmnUnTpyQbEdfjjXtcvb29pKUFn5+fqIyQ4cOFa1v27ataL2jo6OQmJgoKqN9OZWusWzO9BFF2bZtm6i+nZ2d5NJPXWkEli9fbvS2CtK+nHjixIlG1S/P6SPyqVQqYdmyZYWmmBk+fLjey2T1bVf78r6goCChXbt2mufNmzcXBMH4Y4Q+hqRmKEi7z3K5XLhy5Uqxti0IgnD+/HlJm48fPza6j6Y4BpS2oo4dBen6vlu9erWk3K1btyTl3nzzzUK3O2fOHMl3cufOnYWUlJRi75u+HLa6HDt2TFTOwsJCePDggaTc6NGjReUKps/QPhZr5+wuSNd+GZK319R++uknyWuknbvy0aNHku9zU6WPGDRokKjMe++9JykzY8YMUZlBgwaJ1rdq1cokr4WxjE0fYarzGVOcW2nTTv2zdu1aw18II+h6zZo3by7KX/rDDz8UOU60U2y4u7uL1n/55ZeSNg4dOiQqk5qaKsnd2qZNG836v//+W9KGdmqHjIwMwdPTU1KuoPXr14vWeXh4iNIw5dN+v/SlajA17TQLCoVClKqnV69eeo95+cpj+ghdqZqys7MLrZOVlSWpU1hqw5LQ3o72QzsFWHlgTPqIU6dOSfbp888/l5TLy8uTlHvxxRf1tqt9fhsVFWWKXaPnDGcKEz1DYmNjRc8LpkooSsHZOqXhwYMHuHPnjmjZuHHjYGFhIVo2fPhwuLi4iJZpzxYCpLOFr169iqtXrwIAYmJiJJcnjRo1CkqlUvM8ODhYtH7v3r2QyWSih729PbKysvT25fHjx3pnUT948EDXy2BSgtZlk0UtN6YdY9vQ5/Lly7hy5YpoWf6MCQDo0KEDatWqJVpv6GzhESNGiNJPABDNzgEgumwsNzcXFy9eFK0fOnSoZIaM9gyT8uDy5ct477330K5dO3h6esLa2lozTrVnuqWnp4v2WxcvLy9MmjSpRH0qyfHmWRAVFYWWLVti2rRphc4c37JlC2rWrIkDBw4Y3Hb//v3h4+OjeT516lScPn1a87xgionyYODAgUXOBL99+zY+/fRTdOrUCZUrV4aNjY1mjLZq1UpS3hTHSGOPAc8CUx2Pv/zyS1Hahp49e2Lfvn1wcHAoUf8Mpf0dm5ubi6pVq0q+Z/PTp+Qr+B2rPfPwiy++wMCBA/H5559j/fr1OH/+vCZVgrn2qyhnzpwRPbexscGrr74qWla5cmX06dOnVLZf8PsVeJrWR9vrr78ueq59hciz9pkpyBSfH1OcW2kfl2JiYozqQ0mMHj1adE5vijGg/XmuXbs2evToIVpmb28vSe92/vx5zcxf7c8GIE0vYGNjI2lDm3ZfYmNjYWdnJzm2HD9+XFRO198SpUH7HLZXr16iVD3aKSQCAgLMml6kovryyy9x7Nixsu6GSZnieKd97m7OYxU9O5RFFyGiZ42uvJ+lnUO14OWr+bQvaQOe5vKsUaOG6IRUV91Ro0Zh1qxZorQEv//+OxYuXIg///xTEsTRDiIXd38LXt49YsQIyclpvho1aiAqKqpY29DHyclJ9GWt7xIf7eUFg55OTk5Flte3TDt4agjtk+O6detKcliNGjVKlO9t48aN+Prrr0VBfF20gz/A0z8oCio4DhISEiTpP3SNQVdXVzg7O0vSlpSVzz//HF999ZVRJ3ppaWmSP0oL8vPzk1wyTP9RqVTo16+fKNVI9erVsWDBAjRr1gzx8fFYunSpJm95XFwc+vXrhwsXLkgux9NFLpdjypQp+OCDDwCIL6d0d3eXBJHKWvPmzQtd/+uvv2LKlClGpV1JS0srabeMPgaUN6V5PC54mamNjQ1+//132NraGt/JYirud2xcXBzy8vKgVCrRo0cPDBw4ELt27QLwNO/87t27RfclsLa2Ru/evfHpp5/q/PHB3ArmbgaAqlWr6vwu0xWoMwXtH1l1vefa2zbkM5OUlFSi70R9r0NJmOrzY4pzq/LEFGNAO8Wc9nm49jb0LVer1Xjy5Alq1qwp+WxYWVmhSpUqRfZNmynO34GnKfIeP35crLaAp9/V+SmU8um7h0ZBL7/8MiZPnqwJluffT2Pq1KmaMnJ5yebllbS+Lh4eHpIc/jExMYXe+0BXgNGY1EUlIZPJROfNaWlp6NOnDwICAtCtW7dC65bG2Cgpc//9RlQQZwoTPUO0g736fnlu0qSJ5IQhODhYkquoa9euEAQBgiBgzZo1pu1sCXl4eKBv376iZX/88QdUKpUohxnwdLaRrsT7xVGWuZa0T5T1/ZqrfeJdsJ6uk21d7Wi3oa9uYXTlVbt586ZkNof2DUAMzbGmK+ipnRe7KKacIa/9R1RcXFyJ2/znn38wf/58k810yqfrDzFjGXq8eRbt379fknt6w4YNGDlyJHx9fdGpUyds3rwZ9evX16xXqVT45ptvDN7GhAkTdP6x/sYbb4jyo5YHhY2X0NBQvP3220YHX01xNYIpjgFlyVzH48zMTAwePNgkgfjSJgiC6Aqd7du3Y82aNejWrZvo5l35srKysHPnTnTs2BGnTp0yZ1d1MtVVNsWl/ce/ruBQcQIES5YsQc2aNYv9KI2rp0z1+THFuZU27Rug6ctTXBpKawyUVFl/NrTP30+fPl2iMb1t2zbJNrTvoQE8nfhQ8JzXwcFBkjdZewKF9o0OAUiuXMynKwezrgBiSem6qVlRubK17z0B6L4RWmno2LGjJCCfnp6Ofv36FXmzu9IYGyVVvXp1yWfZFOcL2ufu5jxW0bODQWGiZ4j2ncT1BaVcXV3RoUMH0bL79+9LAnimpCuocPv2bckytVotuVN55cqVdbapPfs3OjoaP/74o+iu0rrK6erPuHHjJDeg0fX4+eefdfbFHLRv2PDgwQMkJyeLliUmJkpmURSs16pVK0kgVNfNI65duyZ6ru8S8MLs3btXkmLAUMbccM5Qrq6uknQlumZzJyQkFDkjSteMJ+0Tc1Pc1ET7xk7W1tb45ptvcP78edy5cweRkZHFeq1METgz9HjzLLpx44ZkWYsWLUTPFQoFGjduLFpmzA1UXFxcJJeRKpVKTJ482Yiemkdh42Xr1q2iH0Tkcjk+/vhjnD59Grdu3UJkZCQOHTpkjm4+c+rVqyf549+Q4zFQ9A1+Bg4cKPoD8syZM+jfv7/ewIKpaX/HOjk54fbt2wZ9zxa8YaNcLsfYsWNx5MgRpKWlISIiAvv27cN3332HunXrasrl5OTg22+/Ncu+FcbLy0v0/MGDBzpvUFvcG7fSf0x1PmOKcytt2uc+2t+Xzxrtz7Ou83cAkjRxcrlc85nQ/mxkZ2frvBKwqM+Gdl8aNmxo0HHl0qVLhbZrCsU9d71w4YLo/MHJyUky09TQ1xxAobN3i8vf31+ybN26dYXW0fV66GqnNCgUCqxdu1aSoiQzMxMDBgyQzOgu7+zs7ODr6ytaVtLzhcTERNEP+jKZjEFh0olBYaJniPZBPz/Hri7adwAGgClTppRavqWqVatKLitbs2aN5I+lLVu2SHKZde7cWWeb/fr1k8xWnDVrlui5paWlzvxkXbt2FT3/559/YGdnBx8fH52PSpUqITAwULS9/Ds463qYOnUEAAwbNkz0XBAEya/RW7ZsKbSeu7u7ZN937twpeh9ycnI0l+vm69atW6HpCHQpSWC3NHKsWVhYSAJ7f/31F9LT00XLVq1aVWRbumbZaF9W9+OPPxrfSS3af4T6+/tj1qxZaNmyJWrWrAkfHx+z3tW8IGOON6aydu1ayUzz0qD94wEAyR+UKpVKcvJtbLD9nXfeET0fPHhwqfwxp50qxJRXPGiP0UaNGuF///sf2rZti9q1a8PHx8csf4w/i+RyOYYMGSJadvDgQcmPUlu3bhU9r1OnTpEpPQYNGoSffvpJtCwoKAhDhw7VGaQ0hK6UM/rGkvb3THJyMs6cOaP3O9bHxwePHz9GYmKi5nOdlJQkal+pVKJu3bro3bs33n//fUkQWPsYXJrjXh/t9EiZmZn4888/Rcuio6Oxb9++Uu/L885U5zOmOLcqKDs7W/TDokwmK/JHnPKuS5cuoud37tyR/NiXlpaGjRs3ipa1bNlSc0WM9mcDAH777TfR88zMTMmP4dq03/MbN27g0aNHeo8rNWrUwM2bN4t93DOUrntoGKPgObNMJpNM3rl48SJu3rwpqbd582bJshdeeKHY/dDnpZdekqRc27Vrl+T4lm/Dhg3Ys2ePaFmdOnXQr18/k/dNH7lcjlWrVuHNN98ULc/OzsbgwYMlx4byTvuYc+nSJdy6dUu0TPtY5ejoiBdffFFne9rjtUmTJpJUMkQAg8JEzxTtkzZdl+3k69u3ryRvZUpKCrp3747XX38dO3fuxPXr1xEREYGjR4/i8OHDJe6f9gy4yMhI9OjRAwcOHMDVq1fx448/Sm7y5ezsrPemExYWFpJ12dnZouf9+/fXeQOsyZMniwJKDx8+RMeOHbFy5UpcuHABN2/exJkzZ/Dbb7/h9ddfR+XKlSW/NhtL+8Z02pfy5uXlSW5YV1Dnzp0lf1h88MEH2LhxI8LDw7Fx40Z8+OGHovVt2rRBp06dRMtmzpwpen7nzh2MHDkSFy9exIULFzBy5EjJbG3tOkXRlVdt0aJFemdwhIWFiQJx+TnWTE375irx8fGaMXjjxg388MMPmD17dpHt6Lrp1vjx43HkyBFcu3YNM2fONEn/tX/0OHLkCNatW4cbN27gxIkTeOutt0wSfC6OZs2aiWY53rlzR3LJbEFpaWmisa0rX1tRnxFDJSUlidrRNYv5wYMHojIFZ1Dq+gP+tddew59//omwsDAcP34cr776KsLDw0VljP3D38/PD99++y1mzpyJmTNn4rPPPjOqvqG0x9Hly5fx119/4datWyW+MaZ226GhoViyZAlCQ0Nx9uxZfPLJJ/jkk0+K3X5p6Nq1q+iHBV1XkxiiqGM2UPRYnD59uujHhNTUVAwePBgnT57EtWvX8Pbbb0vSIrz77rsG/SDy5ptv4ssvvxQt27t3L0aNGiVJd2MIXfcjWLJkCa5fvy75HHXs2FGSX3v8+PF4//33ERwcjJs3b+Lq1avYuXMnPv74Y/j5+aF9+/aiP1KPHz+OypUrY9SoUVi5ciWOHTuGGzduaGYLL1iwQNS+9sw67f7GxMTgl19+QUREhM73a86cOaJxUfBmkIYaNmyYJM3F5MmT8dNPP+HatWsICAhA9+7dJecq5d2cOXP0/ghuyEPXa5mVlVXkDXrj4uJEZbR/MDHF+Yypzq3yXb58WXMDRODp+YKu81AfHx/ReJszZ47O9sqDcePGSdIaDRs2DCtXrsS1a9ewb98+dO3aVXIO8Pbbb2v+37NnT8ls4S+//BJfffUVLl++jH/++Qc9e/bUefl7QS+//LJo5rUgCOjXrx++/PJLnDhxAjdv3sSlS5ewZcsWvPvuu6hVqxb8/f1x7949UTsFU+QV56H9vaE9EaJatWqFzlwumEMYeJp6ouCszQkTJojWq9VqdOvWDevXr8e1a9cQHByMiRMnSm7W2bhxY7Rp06bQ17A4lEollixZIvnuGT16NCZPnoyjR4/i5s2bOHr0KCZPnowxY8aIysnlcixZskRypV1pfw5kMhl+/vlnyeudk5ODYcOG6Uz1YOqxkU/7fEE77VZR58mTJk0S3VRVEAQMGTIER44cQVhYGObOnSv5keDNN98UXX1TkPbNH7V/cCHSEIjomZGXlyd4eXkJAAQAglwuF+Li4vSWz87OFvr166cpb+wjMjJS1F6NGjVE62fPni1an5WVJXTo0MGobWzYsKHQfb506VKh9QMCAvTW/fDDD43e55Lo0qVLibd37do1wc7OzqC69vb2wrVr13T2ZcyYMQb3YcyYMUbv6+LFi0VtyGQyITo6utA63bt3F9Vp2bKlaL12v9asWVPkfnXp0kW0PisrS/D19S10f+VyuWBpaVnoWBYEQejYsWOh7chksiL7vGbNmkLf823bthX5/lSuXLnIz6b22CvOe6rL0KFDRe3u2LFDb1ld+1rUw9jXK9/s2bON3lZgYKCmvlqtFjp37mxUfUtLS+H69etF9lf7vSmM9niuUaOGwXULCggIKLTv2u0a8lnLd+7cuWKN0YKvt6591f7sGtovQ9ox1echMjLS6HGma1vGjNdu3boJKpXKqNdm6tSpkvXjxo0T1Gq1UfurUqkEDw8Pgz9H58+fN/j7Sle/ixq32g/t4/S1a9eKrFPY+1Dcz9tnn31W5HaVSmWR2yrqnCowMLDI44shx0xT7bexdPXf2PdYEExzPmOqcytBEITvvvtOVP6jjz7SWa6o99cQuo5B2sdWU42TH374waj36sUXXxTy8vJEbaxatcroz4auvgQEBAgKhcKo/mi/LqaUk5MjOTZOnjy50DpHjx6V9LHg3ywqlUrw9/c3ah8tLCyEo0ePGtRn7bq6vit1Wbx4sc7z28IeMplMWLJkic72TPE5MHR/3n33XZ3j7Y8//ijWNkvax6Ieuvbht99+M7h+w4YNhfT0dL390Y4B7N+/vxT3np5lnClM9AxRKBSiX5bVarXkstOCLC0tERAQgIULF8LFxcXg7VhaWuLll1/WOfOhMFZWVtizZw/69+9fZFlbW1usW7cOo0aNKrRcs2bNJLOR8lWqVAm9e/fWW3fBggWYP3++wXfELo3Luo3VqFEjHDx4UG+e5XyVK1fGP//8o/eGDqtWrZLMQtBlwoQJBqVT0KY9Y6JVq1ZF5tR76aWXRM+1c6yZgpWVFXbv3o1q1arpXK9QKPDLL79IcmrpusHR8uXLdd4MBHg6i90UN2d8+eWXMWLECL3rmzZtWmYzhYGnN0UrSN9lhM8amUyGbdu2SS7f1MfFxQV//fWXJN9bedG7d29J6hRTadWqlWQWXUHVq1eXXFJMYnPmzMFnn31WZPqRl156CQEBAUbfWX7p0qV45ZVXRMvWrFmD6dOnG9VOfr5oQ7Vs2RKHDh0y+KZ4VlZWOmcjG6J79+6ScdioUSMMGDCgWO2VxOzZszF8+HC969u3by9JHUPFZ4rzGVOdWwHiewHIZDLJFXDPqmnTpmH58uU6z4e0jRgxAtu2bZMc0yZMmID33ntPb7169eph7ty5Rbb/0ksvYefOnXB3dy+64wAcHBxK9eZ6uu6hoX1Oq61Dhw6Sv70KnjvL5XJs3boVQ4cONagP7u7u2Llzp94Z7KYyY8YM7N27FzVq1DCofI0aNbB3716jv29Kw/fffy/5nsjLy8Nrr70muUl5eTVu3Dj8/PPPRd6QuG3btggKCtJ5Q2Pg6f1TCt5wz8fHB7169TJpX+n5waAw0TPmjTfeEP3BWNQl7DKZDDNnzsT9+/exatUqjBw5EvXq1YOLiwsUCgXs7Ozg7e2Nzp07Y/Lkydi8eTOio6Px119/6Q2IFcbFxQW7d+/GkSNHMG7cONSvXx8ODg5QKpVwd3dHp06d8OWXXyIyMlJyqb8++i7TGTVqVKEBX5lMhk8//RR37tzBF198gRdeeAEeHh6wsLCAtbU1qlatih49euCTTz5BcHCw5NKzstK+fXtERETgu+++Q6dOneDu7i56/b777jtERESgffv2ettQKpVYtWoVjh8/jnHjxqFWrVqwtbWFra0tateujXHjxuH48eNYtWqVwUHzfLryqhV1cgxAZ56x0rjhXO3atXHlyhV88MEHqF27NiwtLeHp6YnBgwfjxIkTGD16tOTmJ7puvNCsWTOcOXMGr776Kjw9PWFhYQFvb2+8/vrruHLliuTSueKQyWT4448/8Ouvv6J169awtbWFnZ0dGjVqhHnz5uH06dNG/aBjaj179kSdOnU0zwMCAoqd8qG88fDwwPHjx7Fr1y689tpr8PPzg6OjIxQKBWxsbFC1alX4+/tj0aJFuHXrlkFjvKwolUocPnwYM2fORP369Q36o94YX3/9NbZu3YrOnTvDwcEB1tbWqFu3Lj744ANcvnzZ4KCguWjnliyNO7Uba968ebh06RLefvttNGjQAPb29rC2tkb16tXxyiuvYO/evQgICNB7GWhh5HI5fv/9d/Ts2VO0fNmyZUan9nj33XexYcMGdOrUCU5OTkWmsWjXrh3CwsKwbt06vPzyy6hRowZsbW2hVCrh6uqKli1bYsKECdi4cSOePHki+h7o2bMnDh06hDlz5uDFF19Ew4YN4e7uDoVCAVtbW9SpUwfDhg3D1q1bcejQIZ25ELds2YK5c+eicePGev84zmeqcaFUKvHnn39i3bp16NChA+zt7WFnZ4fmzZtj4cKFCA4OFl0CTCVjqvMZU5xbhYeH4+LFi5rnPXv2lORhzVcej0NFmTJlCm7fvo0vvvgCHTp0gJubG5RKJRwcHNCwYUNMnDgRJ06cwKZNmyTpXPItWrQIAQEB6NGjB5ycnGBjY4OGDRvi888/x8WLF3XemFqXl156CXfu3MHy5cvRr18/eHt7w9raGhYWFvDw8EC7du0wZcoUbN++HU+ePEGzZs1M+EqIaZ+r2traonv37oXWUSgUkokr2vfTcHR0xNatW3Hq1Cm8/fbbaNGiBVxdXaFUKmFra4tq1arhpZdewvLly3Hnzh307dvXZPtUmD59+uDWrVv4888/MWbMGDRo0AAuLi5QKpVwcXFBgwYNMGbMGPz555+4desW+vTpo7ctc38Ovv76a0mqLpVKhbFjx0pyXJdXb731FsLCwvDBBx+gSZMmcHJygqWlJby9vTFgwAD88ccfOHXqVKE3jdu6davotZ80aZLRPzhTxSETBEEo604QkXFee+01TY4pmUyGkJCQcjuDjai82bBhA1577TXRsuvXr/MzpMfq1atFM6F++uknSf5wovIiMzMTrq6umty37u7uuH79Ou+4TejatSuCg4MBPD13OnToUJGBHaKC3n//fSxatEjz/PDhwzrHUFRUlOjHsvr16+PSpUu8yRNVKPwclJ1WrVrhwoULAJ7ev+f27dtGXwFMFQd/LiB6Bn311Veay0oEQcBXX31Vxj0iKj9Wr16NyZMnIygoSHQ3+rS0NPz++++Sm1G0bduWAeFCjB07VnQp7TfffCO5eQZReXH06FHRTQVXrFjBgDAhNTUVJ0+e1DyfMmUKA8JklPj4eKxYsULzvF+/fnrH0IEDBzT/VygU+P333xkIowqHn4OyceDAAU1AGAA+/fRTBoSpUAwKEz2DqlevjhkzZmieb968Gbdu3Sq7DhGVI6mpqVixYgW6desGe3t7eHh4wNPTE05OThgzZgySk5M1ZR0cHER/5JGUQqHAwoULNc/v3r37zORmo4qn4B+hI0eOxJAhQ8qwN1ReBAYGai6lrVu3Lr755psy7hE9a5YuXYr09HQAT78Xv/32W71lCx6HPvzwQ7Rp06bU+0dU3vBzUDYKThbz8fHBtGnTyrA39Cxg+ggiInquLFmyBO+++26R5erVq4f169fzJJXoOeLn54fQ0FBUqVIFISEhZZqTm8qPKVOm4KeffoJcLsfx48cLzRtLVBJ5eXlwd3dHcnIymjRpgnPnzsHS0rKsu0VkVvwcED07GBQmIqLnyoMHD7Bt2zYEBwcjLCwMsbGxSE5Ohr29PSpVqoSWLVti4MCBGDRoEE9QiYiIiIiIqEJiUJiIiIiIiIiIiIioAmFOYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQeHnhFqtRmZmJtRqdVl3hYiIiIiIiIiIiMoxZVl3gEwjOzsboaGh8PX1hY2NTVl3h8qxtLQ0qFQqKBQK2Nvbl3V36DnGsUbmwrFG5sKxRubCsUbmwrFG5sTxRubCsWYYzhQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQBgUJiIiIiIiIiIiIqpAGBQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQBgUJiIiIiIiIiIiIqpAGBQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQBgUJiIiIiIiIiIiIqpAGBQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQBgUJiIiIiIiIiIiIqpAGBQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQBgUJiIiIiIiIiIiIqpAGBQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQBgUJiIiIiIiIiIiIqpAGBQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQBgUJiIiIiIiIiIiIqpAGBQmIiIiIiIiIiIiqkAYFCYiIiIiIiIiIiKqQJ7LoHB8fDxWrVqFwYMHo06dOrCxsYGTkxNeeOEFrF69Gmq1usg2Jk6cCJlMBplMhlu3bukso1KpsHjxYjRp0gQ2NjZwdXVF3759cfLkSb3tZmZmYvbs2ahfvz6sra3h6emJ4cOHIywsrNj7S0RERERERERERGSo5zIovHXrVkyaNAlnzpxB27ZtMWPGDAwZMgQhISGYOHEihg8fDkEQ9NYPCAjA6tWrYW9vr7eMIAgYMWIE3nvvPeTk5GDq1KkYPHgwjh49is6dO2PXrl2SOtnZ2ejVqxe+/PJLODo6Yvr06ejZsyd27NiBVq1a4cyZMybZfyIiIiIiIiIiIiJ9ZEJh0dFn1JEjR5Ceno5+/fpBLv8v7v348WO0adMG9+/fx7Zt2zBkyBBJ3djYWDRu3Bhdu3bF48ePERwcjJs3b6JOnTqicps2bcLIkSPRoUMHHD58GNbW1gCAc+fO4YUXXoCTkxNu374NBwcHTZ0FCxbgk08+wdChQ7F582ZN33bt2oVBgwbB19cX165dE/XZUJmZmQgNDYWvry9sbGyMrk8VR1paGlQqFRQKRaE/fBCVFMcamQvHGpkLxxqZC8camQvHGpkTxxuZC8eaYZ7LmcLdu3dH//79JcHVSpUq4a233gIABAUF6az7xhtvAAB+/PHHQrfx888/AwDmz5+vCQgDQOvWrfHKK68gNjYW27Zt0ywXBAErVqwAAHz77beivg0cOBCdOnVCaGgogoODDdxLIiIiIiIiIiIiIuM9l0HhwlhYWAAAlEqlZN3atWuxc+dO/PLLL3Bzc9PbRlZWFk6ePAlbW1t06tRJsr5Pnz4Ans5Yznf79m3cu3cP9erVQ82aNQ2qQ0RERERERERERGRq0sjocywvLw+///47AKB3796idXfv3sX06dMxevRoDBw4sNB2bt++DZVKhVq1aukMLtetWxcAEBERoVkWHh4OAKhXr57ONnXV0ScmJgaxsbGiZfk3z8vIyIBKpSqyDaq48seHSqVCWlpaGfeGnmcca2QuHGtkLhxrZC4ca2QuHGtkThxvZC4VeawZky6jQgWFP/roI4SEhKBv37548cUXNcvVajXGjBkDe3t7/PDDD0W2k5ycDABwcnLSuT5/eVJSUonq6PPTTz9h7ty5omW1atXCli1boFKpGBQmg3GskLlwrJG5cKyRuXCskblwrJG5cKyROXG8kblwrOlXYYLCP/zwAxYtWoQGDRpg/fr1onWLFy9GcHAw9u7dCxcXlzLqoeHefvttDBs2TLRMrVYjJycHCoUCCoWijHpGz4KCB0SOFSpNHGtkLhxrZC4ca2QuHGtkLhxrZE4cb2QuHGuGqRBB4eXLl2P69Onw9fXF4cOH4erqqlkXERGBTz/9FOPGjUPfvn0Nai9/Vm/+7F9t+cudnZ1LVEcfT09PeHp6ipZlZmYiNDQUtra2sLGxKbINqrh4F04yF441MheONTIXjjUyF441MheONTInjjcyF441wzz3N5pbsmQJpk2bhkaNGiEwMBCVKlUSrQ8NDUV2djbWrFkDmUwmegQHBwN4mu9XJpNh586dAIDatWtDoVDgzp07yMvLk2zz5s2bAMT5g+vXrw9Af85gXXWIiIiIiIiIiIiITO25nin8zTff4KOPPkKzZs1w8OBBuLu7S8r4+PhgwoQJOuvv3bsXjx8/xrBhw+Do6AgfHx8AgLW1NTp06IBjx47h2LFj6Natm6jevn37AADdu3fXLKtduzaqV6+OiIgIREZGombNmkXWISIiIiIiIiIiIjK15zYoPG/ePHzxxRdo2bIl/vnnH1HKiIKaNWuGVatW6VzXtWtXPH78GP/73/9Qp04d0brJkyfj2LFj+Oyzz3D48GFYW1sDAM6dO4fNmzfDw8MDQ4YM0ZSXyWR466238Mknn2DWrFnYvHkz5PKnE7V37dqFY8eOwdfXF126dDHF7hMRERERERERERHp9FwGhdetW4cvvvgCCoUCnTp1wg8//CAp4+Pjg7FjxxZ7GyNGjMD27duxbds2NG/eHP3790d8fDw2b94MlUqFlStXwtHRUVTnvffew549e7Bt2za0bdsWPXr0wL1797B161bY2trit99+0wSKiYiIiIiIiIiIiErDcxkUjoyMBPD0boNLlizRWaZLly4lCgrLZDJs2rQJHTp0wG+//YZly5bB2toanTt3xmeffYYOHTpI6lhZWeHgwYP4+uuvsWnTJixevBiOjo4YNGgQ5s6dC19f32L3h4iIiIiIiIiIiMgQMkEQhLLuBJVcZmYmQkND4evrCxsbm7LuDpVjvAsnmQvHGpkLxxqZC8camQvHGpkLxxqZE8cbmQvHmmGYq4CIiIiIiIiIiIioAmFQmIiIiIiIiIiIiKgCYVCYiIiIiIiIiIiIqAJhUJiIiIiIiIiIiIioAmFQmIiIiIiIiIiIiKgCYVCYiIiIiIiIiIiIqAJhUJiIiIiIiIiIiIioAmFQmIiIiIiIiIiIiKgCUZZ1B4jIvGxtbcu6C0REREREREREVIY4U5iIiIiIiIiIiIioAuFMYaJyIjfpPhKCvhMvlMmgsPOAXd2esKraGnKFQrRarVYj+8F5pF7ehJyYGxBUuVA6V4NtnR6wbzwEmXeCkH5jX5Hbtq7eDk4tRhar32q1Glm3g5B07jeoUh9D6VwNzm3fgI1Pe4Pq58RHIuveaWQ/ugx1biYAwKntJFhXbiwql3ErEElnV0GdmQTrGu3h0nkmFJY2/62PPI64fZ/CrcdnsKvfq1j7QkRERERERERUETAoTFROqNLjkHz6F53rEg7Ng7VPR3iP3QmFtSMAIDf5IaI3voqse2ck5VMv/YHcuFuATKa3zYKE3MxiBYXVajWebB6L1CubJdt3bj8ZngOXFNnGveXtoM5MEi2zrdtDFBTOjDqJB6v6wNLLF9ZVWyHh0DzkPL6OKqM3Pe2HKg8xO98BZHLY1Olm9H4QEREREREREVUkDAoTlUOWnr6w9xsIdU4aUq/9BVXKI2RFnUDSyZ/g1v0jqFUqPFr3MrIfXQYAWHjUh1Pr8VA6V0VeQhRSr/0FALCq1gqObSZo2k27shXq7BRAJodj63Ga5TY1OhSrn2lXt2kCwvaNh8C5zUQkHF+KjPD9SDr1M+x8B8CubvdC27DyagQLt1pQ56Qj7d9+a0s+vw6AAM+BS2BbqzOyoy8jLWQHVNnpUFjZIenkj8h5ch3V3gqEXMHDGhERERERERFRYRg9ISqHLL0awv3FOQAAh8ZDcH9FVwBAeugeuHX/CBk3D2oCwlZVmqPq5CAoLKw19Z07vwdV2hNYOFaGQ8N+muWRtwKhzk6BTG4Bz0HLIZeXLK14WsiOp/+RyeE5eDmUtq5QutVC1Lf1n66/9leRQeFqbx0GACSdXa03KKzOSgYAKGzdAAByG1cAAtRZSVBnpyDh0Hw4tBgNG5/iBbeJiIiIiIiIiCoSBoWJyjv5f3mEBQgAgJSLGzTLnDtMEQWEAUAul0PuWNnoTUVveh1Z988VWsa2Xi94DfoBAJBxJxgAoHSuBqWtKwDA0tUHcitHqLNTkHE7yOg+6GJdvS3SQnYg9coWQDES2Q8vQulUFQqHyniyeSwgl8OjzwKTbIuIiIiIiIiI6HnHoDBROZQTcwPxhxc8TR9xZYtmuX3DlwDgab7gf9n4tDPZdgV1HgR1bpFlAECdlwN1RjwAQG7lICojt3aAOjsFeWlPTNIv5/ZvIzPqBBICv0ZC4NdQ2Huh0rBVyIo8itQrm+ExYDHkdu7IvHcWuQmRsPRsCOsqTUyybSIiIiIiIiKi5w2DwkTlUM6T64g/eF20zLpaazh1mPz0ScHZw/8GaU2hyqg/DC8sK5B6QlCLVglq1dMispKlp8gnt7CC9+vbkJvyBOqsBFi41gEA3PuhDayqNINTm0mI3jAc6aEBkFs7QZ2VDOcOb8NzwGKTbJ+IiIiIiIiI6HnCoDBROWThWhM2tboCMhmUdh6wrdcD1jU6am6iZlW5MbIfnAcAZNw8DCvPhibZbtLpX5Ebf6fQMpaVGsGp5WjIFUooHKtAlfIIqswkzXq1Wg11VgqAp2klTMnC0Qtw9AIAJBxdjJyYMFSbHIz08L+RHhoAhxavwWvor3i4ui+STv4Ex1bjOGOYiIiIiIiIiEgLg8JE5ZCVdwtUGrpC73qnVuOQcm4NACDx+DLYNx4CiwI5hFU5GciNu2V0QDT1yhZkRh4rtIy930A4tRwNALCt0x2pFzdAlfIIuUn3YeFcDTmPr0LIzfh3fQ9NveRza5GX+hgKWxc4t3vTqH5py01+iPjDX8Gx1RjY1GiL+CNP8wnb1GgLuVwO66qtkHk7EDlPrjMoTERERERERESkhUFhomeQVbXWsGvQB+k39iEvMQp3v28K+0YvQ+nkjbyke0gL2wvntm8YHRD1GLAY6qzkQsso7Nw1/3dqPgqp/970LvqPUXBoNkITrIZMDsfmr2rKJp36GdmPLsPCtZYoKBy3/wuoMuKRExuhWZZ8ZiUywv+B0qU63Lp9KOlD7N5ZkCks4N7nKwCA0rEqACA34S4AIC/p3tPlTt4G7zsRERERERERUUXBoDDRM0gul6PSyD8Qu2sGUi5vgjorGSnn14jLWDsa3a515cZGlbet2x1uPb9A/JH/IeveGWTdOwMAkCms4N73f7D2bl5kGylX/kRe4l3RsoyIgwAAqyrNJUHhjJtHkHZ1GzwHLYPy3wC1fZMhSAj8GknHf0DW/XPIvBMMa5+OsK7R0aj9ISIiIiIiIiKqCBgUJionlM7V4Dl4OQDAwrV2keUVlraoNOxXuPf7GmlXtyEnJgxCXg6UztVgV7cXrKu1lNRx858DVVYKZAVuVFdSbj0/hWPL15ByYT3yUh5B6VwNjq3GPc3/W4Br94+hSo+F3EocrHb3/xLqnFTd+2jnIVmWFX0Vzh2nwbH1hP/KWdqi+rSTSD67BrmJkbBv/DKcWo2FXGG6/SQiIiIiIiIiel7IBEEQyroTVHKZmZkIDQ2Fr68vbGxsyro7VI6p1WrN/+VyeRn2hJ53aWlpUKlUUCgUsLe3L+vu0HOMY43MhWONzIVjjcyFY43MieONzIVjzTCcKUxUwQiCoHkwKExEREREREREVPEwKExUwWRmZmp+MbOwsCjr7hARERERERERkZkxKExUwVhbW5d1F4iIiIiIiIiIqAwxKExUwTBlBBERERERERFRxcagMFEZSzz+A7IeXYVdg95wbDJUszw3+RFyHocgLy0Gcks7WNdoBwvHyjrbUKtUyEuMhJCXDQBQutaEwtJWXCYvFzlPQpATHwkhNxMKO3dYejWApUsNUTlVdjryEqN0bkdmYQtLt5oG71tu0n1kPbgAITcTSudqsK7eHnKFQtL33NgbkrpyGxdYOFXR2a5apUL2g3PIib8NmVwJpWNlWFZqBKWtq6ZM1qOrSDz+AxRW9nB/aZFku0REREREREREFRWDwkRlKDsmDLF/fwwIarh2fV+z/O6y9sh+eFFS3rZ+b1QasQ5KG2cAT4OjD1f6Iyv6CoTsVE25am8FwcanvajugxXdkPXgnFaLMtjW64VKr/4OpY3L0z7dP4sHq3rr7K911daoPvV4kfuVGXUScf/MQeadowAEzXKFYxU4tR4P1+4fQ654evgR8rJwd0kLne1YuNaCY+txcOnyvmaGc2rYXsT8NRmqtCeS8q5dP4R77y8BAJaeDZB5OxB5yQ9gWbkJnNuML7LfREREREREREQVAa8jJypD8Yf/B6jzYFunG6w8G2iW5yZEQm7tBDvf/rBvOhxyaycAQEb4fiQcmlegBQGZUccBVS4U9p6FbksQ1LCu1gYOzUfDvsnQf9sUkBHxDxKDv9dZR27jArmt638PG8ci9ykj8hjur3wRmXeCAQiw8KgPm5qdAYUlVCmPkHB4Pp5sGQ+1Wq1jgxZQOFSG/N8Zv7kJdxB/4HMkn/oZwNNZzE82j3saEJZbwLp6W9jU6QYLt9pP12cm/deU0hJObSYAABICv4FapSqy70REREREREREFQFnChOVkbyMeKSH7AIAODQZLlrn1usLOLYcA4WVHQAg+/F1zWzatJAd8Oy/6GlBmRzVp56CZaXGSDy6CPH/zNa7vapvHIDCykETjM2MPIaHK/2fth99RWedWp890MzoNVTc3x8DqhwAgMeAxXBq9xbkcjlyEu7iwa89kJd0H6lXNsOl0wxYVxXPELaq3Bg1pp0CAKRe24HojSMAAMlnVsKl4xRk3DoEdVYyAMBr6K9wajFSUzcn8S7yku6J2nNo9iriD85FXmIUMm7+A/sGfYzaFyIiIiIiIiKi5xFnChOVkfQbByConuYAtq3bQ7TOpcPbmoAwAFh4NIDMwgYAIFPaaJbL5XJYV20BudKiyO0prBxEz/OSH2r+b+3dUmed+INz8WTHO0gI/h458XeK3EZO3E1k3X+aosLSy1cTEAYAS9cacOn0rqZsyqWNhbZl59sfkCnEfZX/F6DOuHkIOfF3NEFuS5casK3ZSdSGpVtNKP/NmZweuqfI/hMRERERERERVQScKUxURrLunQYAyG3dYOFcrdCyKefXQMjNBAA4Nh9ZaNnCpIbsRELwQqgzk5AbdxNQWMK57SS4dPtQZ/nEoG81/4/b9wlce3wK916f620/I/K/fMPW1dpoAsL5bHw6aP6fde+MtAF1HvIyEyHkZCL53G+A8DTlg6VnfU19hZ07VOlxSL20EamXNkJh5wGbmi/Avukw2PsNlmzTqlJj5CXeRdb9s3r7TURERERERERUkTAoTFRG8lKjAQBKO49CyyWfX4+YXTMAALb1X9QbwDWEKu0Jsu8XuNmcKgeZUSehSnkEhVutp8vkctjU7ATb2t2gcPBCzpNQJJ9dBSEvGwmH58Oh6VBYeTbU2b6Qk6H5f34e5ILkNq6a/6tzsyTrs6Ov4s7cSpLlLp1nAgCUNi7wHrsbT3ZO1dyIT5Uei7SQHUgL2QGHFqNRefhqUV3Fv69vXqr0xnRERERERERERBURg8JEZUX9743PZLqzuKjVaiQGfoP4g3MAAHZ+A1B5xAajc/wW5NhyLOyaDIM6LR4plzYiMXABsh9dwpPtb6PapP0AANtaXWD7ZhdRPYWDF+IPfAEASL28GVb+c3S2r3Dw0vw/P+hdUF7yfzl/lY6VdXdSpgBkMsitHWFTowMc24yHQ8N+mtXW1VqixrRTyIm7iYxbgci4dQRpoQGAOg+pFzfArfvHsHSvU6A92dN/Bd5ojoiIiIiIiIgIYFCYqMwo7D0BAKrMeMk6tSoPMTunIeXcbwAA5/aT4f7SIsgVihJtU25hBSgsoLB2hluvL5BybjVUaTHIenC+0HoWLj7/9S0nXW85u3r+kFnYQMjNRMbNQ1Blp4tyI6de3qr5v41W/l8AsPJuobnRnC6qnEzIlFaQy+WwdK8LS/e6cG73BmL2zELS8aUAgNyEKFFQWJ3x9PVVFDEjm4iIiIiIiIioouCN5ojKiHXVVgAAVeoT5KXFitZFb3hFExC2rdMdNnW6If3GHqRe34XU67tEZbOjQ5D16CpUaf+lR8iJv42sR1eREx8JAMh6eAmJJ5YjN+kBAEBQ5SHlwu9QpcUAAJQO/83ajdkzC4mnftb0KSc+EolHv9es1xXMzaewdoS93yAAgDojAdEbRyDr4SXkJj9CfOC3SD73NLWD3NYVTq3HGfhK/Scr6iTuLWmJhODvkfXwEvLSYpH16DIyC+Qytig4SxhA9pMwAICVd3Ojt0dERERERERE9DziTGGiMmJXz/9p6ghBjYw7wXBsMlSzLuPWEdH/Cz4HAIevszX/v/dzFwg5aaL1T7ZOAADY1u2JqhP2QpUWi9iAmYgNmAmZhS2EvGxROgXX7h9r/p8bfxtJx5cidtcMzazffNbVWsOuwX+pHHTxGPA9cmLCkP3oMjIi/sG9iH9E62VWDqjy6kYo7Ys3czcnJhRx+z7Wuc6uQR9Yuvr8ty8pT57eUA//vt5ERERERERERMSgMFFZsXCpDtt6vZARfgBpV/8SBYWtvJtD0HEjNl2sqzSDukDgtiBLj3pPt+VWC3Z+A5D96ApUqY8BuQJK+yqwrt4GTq3Gwq7+fwFT53ZvQaawQNbDi1ClPIZMaQ1LL1/Y+/aH8wvTi0xhobR1RdXJwUi7ug2plzch6+FFqDOTAEENmYUNakw7rZXzVw4r75ZP++vZoNC2rao2h9uLXyLzdhCyn4RBlREPmUwGS88GsKvXGy7dPhCVT7u6GYAAhZ077Bu9XGjbREREREREREQVhUwQBKGsO0Ell5mZidDQUPj6+sLGxqasu0MGyow6ifsrukGmsILPrDBYOHmX+jbVarXm/3K5eTLI5MTdwv0V3aBKi4G930BUGrmpxPmRi6JWq3FvSQvkxITB7cUv4dbtw1LdHkmlpaVBpVJBoVDA3t6+rLtDzzGONTIXjjUyF441MheONTInjjcyF441wzCnMFEZsvHpAOf2k2Hl3QzpWmkWnieW7nVQZcwOyG2ckX5jv970D6aU8+gy5NaOsK3bA84vTC/17RERERERERERPSuYPoKojHkOXGLW7eXm5kKtVkMmk8Ha2tps27Wp1gp1Zj8puqCJWFdtgepvHzXb9oiIiIiIiIiInhUMChNVMLm5uZrLKIiIiIiIiIiIqOJh+ggiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCoRBYSIiIiIiIiIiIqIKhEFhIiIiIiIiIiIiogqEQWEiIiIiIiIiIiKiCkRZ1h0gomdDWHQK/jhzD9cfJSMjRwVbSwX8qjhhVLvqaFDJsay7R0REREREREREBmJQmIgKdfl+EubvDcX5qEQAgAyA8O+/F+8lYf3pu2jl44LP+vmiWTXnMuwpEREREREREREZgukjiEivIzeeYPgvp3Dh34Aw8DQgXPBfALgQlYhXfjmFIzeemLV/RERERERERERkPAaFiUiny/eT8NaGi8jNU4sCwLoIAHLy1Ji84SIu308yQ++IiIiIiIiIiKi4GBQmIp3m7w01KCCcLz8w/NXe0NLsFhERERERERERlRCDwkQkERadgvNRiQYHhPMJAM5FJeLG45TS6BYREREREREREZkAg8JEJPHHmXslqr/xdMnqExERERERERFR6WFQmIgkrj9KhqyYdWUAQqM5U5iIiIiIiIiIqLxiUJiIJDJyVEanjsgnALifkIH7CRmm7BIREREREREREZmIsqw7QETlj62lAjKg2IHhmNRsdPo2EA0rO6KXrxf8fb3gV8URMllx5x8TEREREREREZGpMChMRBJ+VZxw8V5SidsJi05BWHQKfjh8E97ONpoAceuarrBQ8EIFIiIiIiIiIqKywKAwEUmMbFsd60/fNWmbD5MysfZkFNaejIKjtRI9Gj4NEHeu5wE7Kx6KiIiIiIiIiIjMhZEYIpJoWNkRrXxccCEq0egUEq52llALApIycvWWScnKw45LD7Hj0kNYKuV4oY47evl6oUdDT3g6WJes80REREREREREVCgGhYlIp8/6+eKVX04hJ09tUGBYBsBCKceSV5qhYWVHXHmQhKDwGASFx+JBYqbeejl5ahy5EYMjN2IgkwHNqznD368S/H29UMvD3mT7Q0RERERERERETzEoTEQ6NavmjJ9Ht8BbGy4i14DAsIVSjoVDm6CRtxMAoEV1F7So7oJ3e9bD7dh0TYA4NDpFbxuCAFy8l4SL95Lw9b4bqO1hpwkQN63qDLmcN6ojIiIiIiIiIiopmSAIxl4dTuVQZmYmQkND4evrCxsbm7LuDpVjaWlpUKlUUCgUsLcveibu5ftJ+GpvKM5FJQJ4OiNYKPAv8HR277u96mkCwoV5kpKF4IhYBIXH4FxUIlRqww5Bng5W6OnrhV6+XuhQ2w1WSoVB9ajsGDvWiIqLY43MhWONzIVjjcyFY43MieONzIVjzTAMCj8nGBQmQxX34HjjcQo2nr6Haw+TkZKZC3trJepXcsDQFlVR18uhWH1JzcrFiVtxCAqPxYlbcUjPURlUz85Sga71PeHv54Wu9T3hZGNRrO1T6eIXMZkLxxqZC8camQvHGpkLxxqZE8cbmQvHmmGYPoKIDNKgkiPmDWqE9Ow8xKVlw85KCbmsZOkcHKwt0LtRZfRuVBk5eWqci0rQzCKOS8vRWy89R4W916Kx91o0lHIZ2tVyg7+fF3o29EIVZ/4oQkRERERERERUGAaFiahcsFTK0bGOOzrWccdHfRog9FEKAsNjEBweiztx6Xrr5akFHL8Vh+O34vDFruto7O0Ef18v9PLzQn0vB8hKGLgmIiIiIiIiInreMChMROWOXCZDI28nNPJ2wrTudXE3Ph1B4bEIjojFlftJhd707trDZFx7mIxFByNQ3dUWvXy94O/rhZY1XKBUyM22D0RERERERERE5RWDwkRU7tVws8OYDnYY08EH8WnZOHozFkHhsThzJwE5KrXeevcSMrD6eCRWH4+Ei60FejR8GiDuVNcDNpa8UR0RERERERERVUwMChPRM8XN3gqDm1fF4OZVkZGTh1O34xEUHotjN2ORkpWnt15iRi62XXiAbRcewNpCjk51PeDv64UeDb3gamdpxj0gIiIiIiIiIipbDAoT0TPL1lKJHg2fBnZzVWpcvp+EoPAYBIXHIjo5S2+9rFw1DoY+wcHQJ5DLgFY+rk/zEPt6oYabnRn3gIiIiIiIiIjI/BgUJqLngoVCjtY+rmjt44r3/esj4kmaJkAc/iRVbz21AJyNTMDZyATM3xuG+l4O8Pfzgr9vJTTyduSN6oiIiIiIiIjoucOgMBE9d2QyGepXckD9Sg54s0ttPErKRHBELALDY3DpbhJUgv5b1YU/SUX4k1QsO3ILlZ2s0evfGcRta7rBUskb1RERERERERHRs49BYSJ67lVxtsGrbarj1TbVkZyZi2P/3qju5O04ZOXqv1FddHIWfj91F7+fugsHayW61feEv58XutTzgIO1hRn3gIiIiIiIiIjIdBgUJqIKxcnGAi81qYKXmlRBVq4KZyMTEBwRi+CIWCSk5+itl5qVh91XHmH3lUewVMjRvrYb/P280KuhFzwdrc24B0REREREREREJcOgMBFVWNYWCnSu54HO9TzwiVpAyMNkBP6bh/heQobeejkqtSaQ/OmOEDSr5vxvHmIv1PawZx5iIiIiIiIiIirXGBQmIgKgkMvQtJozmlZzxvQedREZl46g8FgERcQi5GFyoXUv30/C5ftJ+HZ/OGq526GXrxf8/bzQvJoL5HIGiImIiIiIiIiofGFQmIhIi0wmQy0Pe9TysMf4F2oiNjULwRFP8xCfjUxAnlr/jeruxKXjl6N38MvRO3C3t0LPhk/zEHeo7Q5rC4UZ94KIiIiIiIiISDcGhYmIiuDhYI2hLathaMtqSMvOw8lbcQgKj8XxW3FIy87TWy8uLRt/nruPP8/dh62lAl3qecDfzwvd63vByZY3qiMiIiIiIiKissGgMBGREeytlPD3qwR/v0rIValx4W4iAsNjEBwei5jUbL31MnJU2BfyGPtCHkMhl6FtTVf08vVCL18vVHWxNeMeEBEREREREVFFx6AwEVExWSjkaFfLDe1queGj3g0QFp2CwPBYBIfH4lZsmt56KrWAk7fjcfJ2POYGhMK3suO/N6qrhIaVHXijOiIiIiIiIiIqVQwKExGZgEwmg28VJ/hWccKUbnVwPyEDwRGxCAyPwZX7SSgkDTFCo1MQGp2CJYduwtvZBv5+T2cQt/FxhVIhN99OEBEREREREVGFwKAwEVEpqOZqi9HtamB0uxpITM/B0ZtPb1R3+k48svPUeus9TMrEmhNRWHMiCs62Fuhe/+mN6jrX84CtJQ/ZRERERERERFRyjDAQEZUyFztLDGzmjYHNvJGZo8LpO/EIiojF0YhYJGfm6q2XlJGL7ZceYvulh7BSyvFCHXf4+3mhR0MvuNtbmXEPiIiIiIiIiOh58lxelxwfH49Vq1Zh8ODBqFOnDmxsbODk5IQXXngBq1evhlqte5beyZMn0bdvX7i6usLGxgZNmjTBkiVLoFKp9G5rz5496Nq1K5ycnGBvb4+2bdti3bp1hfZv3bp1aNOmDezt7eHk5ISuXbtiz549JdpnIno22Fgq0K2BJ+YO8MPB9zpj5estMaptdXg72xRaLztPjcM3YvDhX9fQ+qtDGPrzSfx69DYi49LN1HMiIiIiIiIiel7IBEEoJNPls2nFihWYPHkyKleujG7duqF69ep48uQJtm/fjuTkZAwZMgRbt24V3cxp165dGDJkCKytrfHKK6/A1dUVAQEBCA8Px9ChQ7F161bJdpYvX45p06bBzc0Nr7zyCiwtLbFt2zY8ePAAM2fOxMKFCyV13n//fSxatAhVq1bF0KFDkZOTgz///BMJCQlYtmwZpk6dWqx9zszMRGhoKHx9fWFjU3hwiSq2tLQ0qFQqKBQK2NvbG10/PTsPcWnZsLNSQs4bopmMIAi4FZOGoPCneYhvPE41uG5dT3v08vWCv18lNPF2glxePt6Xko41IkNxrJG5cKyRuXCskblwrJE5cbyRuXCsGea5DAofOXIE6enp6NevH+Ty/yZDP378GG3atMH9+/exbds2DBkyBACQkpKCOnXqIDk5GSdOnECrVq0AAFlZWejevTtOnTqFTZs2YcSIEZq2oqKi0KBBA9jZ2eHChQvw8fEBACQmJqJ169a4ffs2Tp48ifbt22vqnDx5Eh07dkTt2rVx7tw5uLi4aNpq2bIl0tPTcePGDU1bxmBQmAzFoPCzITo5E8ERsQgOj8X5u4lQFXanugK8HK3Qs+HTAHH7Wm6wVJbdBSH8IiZz4Vgjc+FYI3PhWCNz4Vgjc+J4I3PhWDPMc5k+onv37ujfv78oIAwAlSpVwltvvQUACAoK0izftm0bYmNjMWLECE1AGACsra0xf/58AMDPP/8sauu3335DdnY2pk6dKgriuri44JNPPgHwdMZyQfnPP/30U01AGAB8fHwwZcoUZGdnY82aNcXcayJ6nlR2ssGI1tXx8+iWOPxeF8wf1Ai9GnrB1lJRaL0nKdnYeOYexvx2Fi3mHcTUPy5i95VHSMnSn7uYiIiIiIiIiCqWCnejOQsLCwCAUvnfrh85cgQA0Lt3b0n5zp07w9bWFidPnkR2djasrKyKrNOnTx9RGUO206dPH8ybNw9HjhzB3Llzjd4vInp+OdpYoG/jyujbuDKy81Q4H5WIwPAYHI2IRVxajt56adl52HM1GnuuRsNCIUO7Wm7w9/VCT18vVHbiFQVEREREREREFdVzmT5Cn7y8PDRv3hwhISHYv38/XnzxRQBA69atcf78eZw/fx4tW7aU1GvUqBGuX7+O0NBQNGzYEADg4eGBuLg4xMXFwc3NTVLH3t4e6enpSE9Ph62tLdLT02Fvbw97e3ukpkpzhcbFxcHDwwOenp548uRJofsRExOD2NhY0TK1Wo2cnBz4+PhoAtdEuhS8caJCUfisU5311QLy1GrIZTLIwPQRZUktCAh5lIrAiHgE3YxDZHymwXX9Kjuge3039KjvjtrutqIc66ZS0rFGZCiONTIXjjUyF441MheONTInjjcyl4o81oxJl1GhZgp/9NFHCAkJQd++fTUBYQBITk4GADg5Oemsl788KSnJqDrp6elITk6Gra1tsbahz08//SSZTVyrVi1s2bIFKpVKNPiJClPcsaKUAYDw74PKikIGNPW2R1Nve8zoVgNR8RkIvJmAwIh4XH2YWui7cz06FdejU7EsKArVnK3RrZ4butVzRVNvRyhK4UZ1PC6RuXCskblwrJG5cKyRuXCskTlxvJG5cKzpV2GCwj/88AMWLVqEBg0aYP369WXdnRJ5++23MWzYMNGy/JnCCoWiwv0KQsbhTOHnVw03e4x1s8fYdtURl5aD4FvxCIyIx5moROSq9IeI7ydl4fezD/H72YdwtbVAl7pu6F7fDe1rusDaovjHk4r86yyZF8camQvHGpkLxxqZC8camRPHG5kLx5phKkRQePny5Zg+fTp8fX1x+PBhuLq6itbnz9LNn82rLX+5s7OzqE5cXBySk5N1po/QnhlcnG3o4+npCU9PT9GyzMxMhIaGwtbWFjY2zBVK+pX0Lpzp2XlISsuGnZUS8lJIOUCm4epshcGtHDC4lQ/Ss/Nw6nY8AsNjcPxWHFKz8vTWS8jIxY4rj7HjymPYWCjQqa47/P0qoUcDT7jYWRrVB97xlcyFY43MhWONzIVjjcyFY43MieONzIVjzTDPfVB4yZIlePfdd9GoUSMcPnxYEkwFgPr16+P8+fOIiIiQ5BTOy8tDZGQklEolatWqJaoTFxeHiIgItG/fXlQnOjoa6enpqFq1KmxtbQEAdnZ28Pb2xsOHDxEdHY3KlSuL6ty8eRMAUK9ePZPsNxFRPjsrJXr+e4O5XJUaF+8lIjg8FkHhsXickqW3XmauCv+EPsE/oU8glwGtfVzh71cJ/r5eqOZqa8Y9ICIiIiIiIiJTkpd1B0rTN998g3fffRfNmjVDYGCgzoAwAHTv3h0AsH//fsm6o0ePIiMjAx06dBDdwK2wOvv27ROVKUkdIiJTslDI0bamG2b1boC977yAPya2xaROtVDXs/BfT9UCcCYyAfP2hKLTt4HoveQovj8YgZCHyahA9yslIiIiIiIiei7IhOf0r/l58+bhiy++QMuWLfHPP/9IUkYUlJKSgtq1ayMlJQUnTpxAq1atAABZWVno3r07Tp06hU2bNmHEiBGaOpGRkWjYsCHs7Oxw4cIF+Pj4AAASExPRunVr3L59GydPnhTNIj558iQ6duyI2rVr49y5c3BxcQEAREVFoWXLlkhPT8eNGzc0bRkjP32Er68v00dQoUyRPiKO6SOeSw8TMxEUEYPg8FhcvJcItYHfDlWcrNHL1wv+fpXQpqYrLBRPf2/kJTtkLhxrZC4ca2QuHGtkLhxrZE4cb2QuHGuGeS6DwuvWrcPYsWOhUCgwbdo0TT7fgnx8fDB27FjN8507d2Lo0KGwtrbGiBEj4Orqit27dyM8PBxDhw7Fli1bINMKgC1btgzvvPMO3Nzc8Morr8DS0hLbtm3DgwcPMHPmTCxcuFCy3ZkzZ+L7779H1apVMXToUOTk5GDz5s2Ij4/HsmXLMHXq1GLtM4PCZCgGhckQiRk5OH4zDkHhsTh5Ow7ZeWqD6jlaK9G9gSf8/SqhZRUbWCtl/CKmUseTPjIXjjUyF441MheONTInjjcyF441wzyXQeE5c+Zg7ty5hZbp0qULgoKCRMtOnDiBr776CqdOnUJWVhbq1KmD8ePH45133tF7t8KAgAAsXLgQFy9ehFqthq+vL6ZOnYoxY8bo3fbatWvx448/IjQ0FHK5HC1atMAHH3yAl156yeh9zcegMBmKQWEyVlauCmciExAUHoPgiFgkZeQaVM9CIUM7H2d0r++Ofs2rw9PBupR7ShUVT/rIXDjWyFw41shcONbInDjeyFw41gzzXAaFKyIGhclQDApTSajUAq4+SEJQeCwCw2PwIDHToHoyGdCsmjP8fSvB388LtT34xUymw5M+MheONTIXjjUyF441MieONzIXjjXDKMu6A0RE9OxQyGVoXt0Fzau7YEbPurgTm47Af2cQX3+UoreeIACX7iXh0r0kfLP/Bmp52GkCxM2qOkMu5w8MRERERERERObCoDARERWLTCZDbU971Pa0x8ROtRCTkoXgiFgEhsfifFQC8gq5U92d2HSsCL6NFcG34eFghZ4NveDv64X2td1gbaE7XQ8RERERERERmQaDwkREZBKejtYY1qoahrWqhtSsXJyKeIzAiDgcv52I9ByV3nqxqdnYdPYeNp29BztLBbrU94C/byV0q+8JJ1sLM+4BERERERERUcXAoDAREZmcg7UFevt6oo+vO7LzgLMP0xEcHougiFjEpmbrrZeeo8Lf1x7j72uPoZTL0LaWK/x9K6GXrxeqODNfOhEREREREZEpMChMRESlylIpR4fa7uhQ2x0f9mmAsOgUBN6IRVB4DO7Epeutl6cWcOJWPE7cisfs3dfRyNtREyBuUMkBMt7okIiIiIiIiKhYGBQmIiKzkctk8KviBL8qTpjavQ7uxacjKCIWQeGxuHI/CfqzEAMhD1MQ8jAF3x+MQDVXG/Rq+PRGda1quECpkJttH4iIiIiIiIiedQwKExFRmanuZofX29vh9fY+iE/LxrGbcQgKj8HpOwnIUan11rufkInfTkTitxORcLG1QPcGXvD380Lnuh6wseSN6oiIiIiIiIgKw6AwERGVC272VhjU3BuDmnsjM0eFU3fiERQeg6MRsUjJytNbLzEjF39dfIC/Lj6AlVKOTnU94O/nhR4NPOFmb2XGPSAiIiIiIiJ6NjAoTERE5Y6NpQLdG3iiewNP5KnVuHwvCYHhsQiOiMGjpCy99bLz1DgU9gSHwp5ALgNa1XBFL18v9PL1go+7nRn3gIiIiIiIiKj8YlCYiIjKNaVcjlY+rmjl44r3/evh5pM0BIbHIDgiFjcep+qtpxaAs1EJOBuVgK/+DkM9L3v4+z7NQ9zY24k3qiMiIiIiIqIKi0FhIiJ6ZshkMtSr5IB6lRzwZpfaeJSUiaMRsQgMj8XFu4lQCfpvVRfxJA0RT25heeAtVHK01swgblfLDZZK3qiOiIiIiIiIKg6TB4WzsrKQlJQEZ2dnWFtbm7p5IiIijSrONhjRpjpGtKmO5MxcHP/3RnUnb8cjM1elt97jlCysP30X60/fhYOVEt0aeKKXrxe61veAg7WFGfeAiIiIiIiIyPxKFBRWq9U4ePAgjhw5guDgYISGhiI9PV2z3tbWFvXr10fnzp3RvXt39OnTBwoF7wpPRESm52RjgX5NKqNfk8rIzlPhbGQCgsJjERwRi4T0HL31UrPzsPvKI+y+8ggWChna13aH/7+ziL0c+eMmERERERERPX9kglDItbZ6REdH4+eff8aaNWvw6NEjAEBhzeTnbfTy8sL48eMxefJkeHt7F7PLpEtmZiZCQ0Ph6+sLGxubsu4OlWNpaWlQqVRQKBSwt7c3un56dh7i0rJhZ6WEnDlZqRDyvGzIoIYAOdRKqzLrh0otIORhMoLCYxEUHoO7CRkG121azRn+vl7w9/VCHU975iEup0p6XCMyFMcamQvHGpkLxxqZE8cbmQvHmmGMCgqnpKTg66+/xtKlS5GVlaUJBGv/kSwIgs5l+WWtra3xzjvv4OOPP4ajo2NJ94HAoDAZjkFhMpfyEhTWFhmXjqDwGASGxyLkYbLB9Wq622lmEDev7gKFnOO/vOBJH5kLxxqZC8camQvHGpkTxxuZC8eaYYwKCru7uyMxMVET9C1YVaFQwMvLC25ubnB0dERycjISEhLw5MkTqFT/5XXMryeTyeDm5oaYmBjT7lEFxaAwGYpBYTKX8hoULig2NQvBEU/zEJ+LSkCuyrCvRHd7S/Ro4AV/Py90rOMOawumRipLPOkjc+FYI3PhWCNz4Vgjc+J4I3PhWDOMUTmFExISNDOABUFAu3bt8PLLL6Ndu3Zo2bKlzmBkRkYGLly4gNOnT2P79u04c+aMpn58fLwJdoGIiKh4PBysMbRlVQxtWRVp2Xk4eSsOwRGxOHYzDmnZeXrrxaXlYPP5+9h8/j5sLBToUs8D/n5e6N7AE862lmbcAyIiIiIiIiLjGTVTWC6Xw93dHdOmTcOYMWNQvXp1ozd49+5drF27FsuXL0dCQoJoFjEVH2cKk6E4U5jM5VmYKaxPrkqNi3cTEfhvHuKY1GyD6inkMrTxcUWvf9NMVHO1LeWeEsCZAGQ+HGtkLhxrZC4ca2ROHG9kLhxrhjEqKPzDDz9g0qRJJgk6ZmRkYOXKlZg+fXqJ2yIGhclwDAqTuTzLQeGCBEFA2ONUBN2IQVBELG7FpBlct2Flx6c3qvPzgm9lR96orpTwpI/MhWONzIVjjcyFY43MieONzIVjzTBGBYWp/GJQmAzFoDCZy/MSFNZ2PyEDwRFPZxBfvp8EtYHfot7ONujl6wV/Xy+0rukKC4W8dDtagfCkj8yFY43MhWONzIVjjcyJ443MhWPNMEblFCYiIqroqrnaYnS7GhjdrgYS03Nw7FYcgm7E4NSdeGTnqfXWe5iUibUno7D2ZBScbCzQo4Enevl6oXM9D9hZ8euYiIiIiIiIzId/hRIRERWTi50lBjStggFNqyAzV4Uzd+IRGB6LoxGxSM7M1VsvOTMX2y89xPZLD2GplOOFOu7w9/VCj4Ze8HB4fmZVExERERERUflUKkHhXbt2YdeuXXj06BEcHR3Rpk0bjB07Fu7u7qWxOSIiojJnY6FA1/qe6FrfE3lqNa7cT0ZQeAyCI2LxIDFTb72cPDWO3IjBkRsxkMmuoUV1F/j/e6O6Wh681ImIiIiIiIhMz+icwteuXcPixYsBAAqFAj/99BMsLCw06ydNmoTffvtNUs/R0RE7duxA165dS9Zj0ok5hclQzClM5vK85hQ2liAIuBWThuCIWASGxyAsOtXgunU87TUB4qZVnSGX8zOnC3OGkblwrJG5cKyRuXCskTlxvJG5cKwZxuiZwocOHcLatWshk8nQu3dvUUB4x44dWL16teZ5/l3WBUFAcnIyhg4divDwcLi5uZmg60REROWfTCZDXS8H1PVywMROtfA4OUtzo7rzdxOhKuROdbdi0nArJg0/Bd2Gp4MVev57o7r2td1gpVSYcS+IiIiIiIjoeWJ0UPjy5cua/w8ePFi0Ln8GccFgcP5zQRCQmJiI1atXY9asWcXtLxER0TOtkpM1XmldDa+0robUrFwcvxmHoIhYnLgVh4wcld56ManZ+OPMPfxx5h7srZToUt8D/r5e6FrfE042FnrrEREREREREWkzOih8/fp1zf+7dOmi+X9CQgJOnDihCQDLZDJ07twZTZs2xfr165GUlAQAOHDgAIPCREREABysLdCncWX0aVwZOXlqnItK0OQhjkvL0VsvLTsPe69GY+/VaCjlMrSv7fZ/9u47vqr6/uP469yVvUnCSAiEHfYQkKWgOBBRRMWBe1et1Q5ta1utto7+auuu1boXiooLtyxFpkwDYUgSQoDsndx5fn9ELsQkkOSGy3o/H488ODnn+z3f70k/Nfd+8r2fL5N/KjPRKUYlhI52Pq8Xb9UeTK8La1RHrPbQoM/B66rBW1WANSIBa0hUq/r6fD68lbsxPXVYI5OxhkQENJe997OExzf5s3BX7MLnrMSe0BOLxRLQWCIiIiIix4tWJ4WLiooAsNvt9OrVy39+yZIl/mQwQP/+/VmwYAEAEydO5LzzzsM0TTZu3NgO0xYRETm2OGwWxvbswNieHfj9FJMf8itYsKmA+VmFZBdXN9vP4zNZvKWIxVuK+PP7PzAoJYbJ/ZI5rX9HeidH+n8vS3C5SnPI/feIhicNA0tYHGHdxxE7+gbCuo5scNlZsImy756mav17eKv2/NTHSmjqCSRM/guuoiyKP/3zQceO6DeFThe91KZ5u8t2UPzFX6lcOxvT4wSrg6iB55Ew+R4cCd0P2LduxyoK591F3c5VmK6fYtZiJ6zrKDqc+TfC0kb72xZ9+mfKvnu6yfvEnfRrEibdBUDN1vnsfvtaPOV5YFiJOeEqEs95DIu1vnyKt66c3MdGEZoyjC5Xzm3TM4uIiIiIHI9anRTeu+I3Ojq6wfkVK1YA+BPDF110kf/a2WefjdVqxev1UlpaGsB0RUREjn0Ww2BglxgGdonh1lN6kV1UzYLNhSzMKmBdXjkH2iF2XV456/LK+ecXm+kaH+7fqG5Et3is2qgueEzwOSsanfbVlVNZmk3lmtmkXPcp4d3HAVCd9Tn5r87EdNfUNzQsWEKi8NVVUJe7lOrMD7DFd2/yno3G2HuPVvI6q8l79nTcxdsAA1tcNzxluVSueZPa7YvpettKbOHxzfZ3Fm6idvsisNiwJ/bBW1WAr7aU2uxvyPvfWXS/MwtbRIf6OXrqmn0W0+P8qY2bXbOvwPS6Sb35W8qXPkP58ucI7TqSmBFXAFD8+T346spJPPuRNj2ziIiIiMjxqtVJ4Zqa+jcaVVVVDc7vTQrvNX78eP+x1WolNjaW4uJifD5fW+YpIiJy3OrWIYIrO0Rw5ZhuFFc5WbSlkPlZhSz/sQSXt/nfq7klNTz3zXae+2Y78REOTumbxOSMZMb3SiTMoY3qgiWs2zg6znwBn7uGsm8ep3z5c+BzU7roEcK7j8PrqmXXm5f7E8JxE+4gbvzt2KKS8NaVU7nuHXx15UQNvoiwtDH+++5++xrchVkApFz/BYatvnSINTy2TfOsWPnCTwlhSDr3MWJHX0/FmtnsfvNyPOU7Kf/uPySc8odm+1vCYkk47V5iTrwBW1gcXncdu165gJrNn2O6qqj4/jXix9/WoE9o6kiSL/xfg3PWiPoNid0l2/BW7iEiYxphqSMwPbVUrHqZ2u3fEjPiCury11D23TPET7wTR0J6m55ZREREROR41eqkcHR0NCUlJTidTjZu3Ei/fv2oq6trUE/YarUyfPjwBv0qKupXg0RGRrbPzEVERI5DCZEhTB+awvShKdS4PHy3rZj5WYV8s6WQijpPs/1Kql28vSqPt1flEWq3MKFXIpMzkjmlXzLxEY4gPsHxx7CHYI/rCkDC6ffWJ4UB5+4NAFStfwdfbf0nqSIHTCdxygP+vtbQGGJHXu3/3h6d7D+22MP9xyEpI7A69n1ff/8f8NYUHXBultA4QjsPAqB68+c/nbQRNfTSn+ZzHobjJkxXNdWbvzhgUjiq31nQ76x9c7eHEjngXGp+uq/ZxApm0+fBuWsteL2Epg7H0WFfaTKLo/41o89VWf9vXf2/lpBIfD4fBe//CntcV+Im3nnAZxQRERERkcZanRTu3bs3S5cuBeDaa6/lzjvv5L333qOyshLDMDAMg6FDhxIevu+NyY8//ojb7cYwDFJSUtpv9iIiIsexcIeNU/rVJ3bdXh+rc8tYkFXAgs2F7C6va7ZfndvH55l7+DxzDxYDRnSL57SMZE7L6EjXhPBm+0ngqrM+8x/bojrWn8v8wH8uavDMdhur6PO/UJ354QHbhPWYSOp1nwLgzPseAGt4vH9zOIvNji0yGXfJjzh3rmr1HGo2f/nTkUFEnzMaXXfu/J7dr8/yfx+acgIdL34ZR0I61ujOhHYbS+2Piyn85G5qtnwOhoWowTOp/P416nK+o/MV7x2WjfhERERERI52rU4Kn3rqqf6k8NKlS5k+fTqAf5WwYRj+c3stXrzYf9y7d+9A5isiIiJNsFstjOwez8ju8fz29D5k7a5kweZCFmQVsHlPVbP9fCYs317C8u0l3P/xRvp2jPqpDnFHBnSJ1kZ17aA2+zu2/6M/pqcWT/lO//mYkdcA4K0p8Z+zx6W127hRA88nJHnAAdvYE3r4j33O+pW4hj2sQRvjpxXIpseJz+PGYrMfdGyfz0fxZ3+masO7AMRP+j2hXYY2aGOL60ZoynAMWwi12d/iKc2hLm8Fu2dfSddfLMJisdD58rcp/vxearbNxxqZTJcr78ee1If8V84nIuNswnufTul3z1Cz+TMMi43IAecROfhCLBbLwX9AIiIiIiLHsVYnhW+66SYeffRRf01h06zf7mbvm8bo6Giuu+66Bn3eeust//EJJ5zQ5smKiIjIwRmGQd9O0fTtFM2NJ/Ugv6yWBVn1CeLVuWV4zea3qtu0u5JNuyt57OutdI4J5dSfVhCPSo/HblWirS1Mdw3u4q3+722xqcSOvoGoYZcB9bV493JX7CSUYe0ybvTQiw7eaD+GIxzTU4fpbrjK3HTX1h9YHWA5eC1qn8fFnndupHL1awDEn3wn8af+qUGb+El30WHKg/7krdddx47HRuEq3ERd7jKcBZsISeqLLTyB5HMfa9B3z/u34XNWkjj1n5R8eR8l8x8gou8UvNXF7J59BUmuKmJHXduqZxcREREROd60OincqVMnXnvtNWbOnEltba3/vGmaOBwOXnzxRRISEvznf/zxRz7//HP/9xMnTgxwyiIiItIanWPDuGRUVy4Z1ZWyGhffbCliflYh3/1YRJ27+Y3q8svrePm7HF7+LoeoUBuT+iZxWkZHTuqTSGRIq19CHLdCU04g8ex/gmFgjeiALa5bg5WsEX1O95d5qFr/LlEZZ7fLuLveutZfz7c5Yd3G0nnWG/Xz7DyEmq1f460pweuqxeoIw+f14Kkq+On64IOuwPXWVbDr1ZnUbP0aDAuJU/9B3NhbGrWzhcc3+N5qDyW060hchZsA8JTtJCSpb6N+dTtXU770WRJOvRtHfBrlq17CCImi06y38NWW8uPfUqlY9bKSwiIiIiIiB9Gmd3RTp05l06ZNPPfcc6xZswaXy0W/fv24/vrr6du34Qv4jRs3cu219S/MHQ6HVgqLiIgcRrHhDqYO7szUwZ2pc3tZtr2EhVkFLNxcSGmNu9l+lXUe3l+Tz/tr8nFYLYzpmcDkjGQm90smKVo1XQ/EEhZNWNqoZq9HDZ5J4bzfYzorqVz9BiHJ/Yk58SasIRH4PG6qN32Mp3IPcSfe0LpxHeFYQqMP2MZwRPiPw3ufVp/M9bmp2vAeMcMuoTrrE8yfykqE9zzV33bXW9dQl7sMa1gsXW/+BgB3eT47X5iGa/d6sNhJOvdRIjOm4akqrB/LHoo1JAqA4i//RvTIa/0b57krdtWPDWBYcSQ1Ljfm8/komPtL7PHdiZvw6/pzdRVYQqPrS1r8lGj21VW06uckIiIiInI8avMyn9TUVO69996DtjvrrLM466yzDtpOREREgivUbuWk3omc1DsRr89k/c5y5mcVsCCrgB0ltc32c3l9P5WjKOSP721gaNdYJv9UZqJnUmQQn+DYYA2NJnnGf9j95pXgc1P06R8p/upvWKOS8FYWYLpriD3xplbf9+dlFw4m+oSrKP3mMbwV+ex55wbKvn0c154fALCEJxCz3xw8ZXm4i7bgDd/36bDqrE/rE8IAPjcF7/6Cgnd/sd/9r6bjjKcBKFnwMMVf/Y2Qjv0x7OE4d6/HdFUDEDloBvbY1Ebzq1j1EnU7ltPlqo+w2EMACE0ZTu2PC6nZ8jXun+o1h6SMaNVzi4iIiIgcj/TZTxEREcFqMRiSGsuQ1Fh+dUovthdVMz+rkIVZBWzIP/DKy9W5ZazOLePhT7NI7xDB5P71CeKhqbFYLNqoriWiB52PPTaN0m8fo3rjx5iuajwl2QA4EvsS1nPSIZ+DLSyWlOs+o+iTP1C98WOcO78HDML7nE6HM/7mX9XbHiL6T6Mm6zOcu9b5z1kjEokadD4JZ/69UXtPTQnFn95N5IDpRPSZ7D+fdM6/yX/5AvL+dyYAIV2G0eH0gy9aEBERERE53hmmeYDdZg7is88+Y9GiRRQXF5OQkMBJJ53Eaaed1p7zkxaqra0lMzOTjIwMwsLCDt5BjltVVVV4vV6sViuRka1f0Vft9FBU5SQixIbFULJHmmfxODHwYWLBZws53NORABRU1LFwcyELNheyYnsJHl/LXjp0iAxhckYSkzOSGdOjA6H2g29S1haB/nftSON11eAp/hGfpw5bTBfs0Z2CPgd3xS685flYoztij+lySMbweT14ynLxVhdjCYnA3qEPFmvTMeKpLsJduAV7Up9G9Yh9Xg/ukm0Y1hBssV0PWvc4EMdarMmRS7EmwaJYk2BSvEmwKNZapk1J4T179nDuueeyfPnyRtdGjRrF3LlzSUpKapcJSssoKSwtpaSwBIuSwsemyjo3S7YVsyCrgG+2FlHt9LaoX7jDysl9EpmckcykPsnEhNvbbU560SfBoliTYFGsSbAo1iSYFG8SLIq1lml1+Qifz8fUqVNZtWpVk9eXLl3K1KlTWbp06SFdqSEiIiLBFxVq5/T+HTm9f0fcXh8rs0tZkFXAgs2FFFY6m+1X4/Iyb/1u5q3fjdViMKp7PKdlJDO5f0e6xOqPmSIiIiIiIsHU6qTwm2++yapVqzCaWSFomiarVq1i9uzZXHzxxQFPUERERI5MdquFE3skcGKPBO48sy8bd1Uwf1MhCzcXsK2wutl+Xp/Jkm3FLNlWzD0fZtK/czSnZXRkckYy/TpFNfsaQ0RERERERNpHq5PCb7/9tv/YNE0Mw6BDhw4UFRWxfyWKt956S0lhERGR44TFMOjfOYb+nWO4ZVJPcktqWJhVwPysQtbuKONAtap+yK/gh/wK/vXlZlLiwpicUb9R3Qnd4rBZ9akjERERERGR9tbqpPDq1av9K3imTJnCyy+/THx8PIWFhVx22WV8/vnnmKbJ999/3+6TFRERkaND1/hwLjuxG5ed2I2SaheLthSyYFMBy7aX4PT4mu2XV1rLC99m88K32cSG25nUN4nTMjoyoXcHwh2tftkiIiIiIiIiTWj1RnMRERHU1tZiGAY7d+6kY8eO/ms7d+4kNTUVgNDQUGpqatp3ttIsbTQnLaWN5iRYtNGcNKXW5eW7H4tZmFXAoi1FlNe6W9QvxGZhfK8OnJbRkUn9kugQuS+mjvSNJMpXvcqeOddjj+9G2h3rsFht+Hw+PKU51OUuw7lrHaa3vh5z7NhbccR3a/I+zt0/UL78OVxFW8Cw4ojvTuTA6YSnnwRA8fyH8VbtaXYekf3PITx9AgCe2lKcuSuo27ECb20JAGE9TiYq4+wWP5fXXUf1xg+p+uEDvFWFWBwRhHUfT9SQmdijOzVoW7FmNnU7Gm5QbFgdOJL6EtHnTGxRDTcodhVvp3LNG9TmLsV0O7GEReOI70FI6nAiB8zw71ux45lTqc1eQsKpfyLhlN+3eO5tdaTHmhw7FGsSLIo1CSbFmwSLYq1lWr3kZm9COC4urkFCGKBLly7Ex8dTUlKC09n8ZjMiIiJyfApzWJnUN4lJfZPw+Hys3VHG/KxCFmQVkF9W12w/p8fHlxsL+HJjAYYBI9Li/GUmOoQG8QFayed2UvzFPWB6iR17CxbrTy+9TJPsf/Rt1D5q4Az4WVLY5/VS8N7NVKx8ocH5GsBTudufFK5c/Tqugo3NzsUW29WfFN79xuXUbP68YQPD2uKkcM2Pi9j1+qV4qwoanK/e+BFFn/yhUZK2ZsuXVKx6ucl7GdYQEqc9QuyoawGozV1O3rOnY7obLi7YW6W6599n+M/FTbiD2u2LKVn0T2JGXYstMrFF8xcREREROd61+XOYDoejyfN2u73NkxEREZHjh81iYXhaPMPT4vn15N5sKahiQVYBC7IK2bS7stl+pgkrsktZkV3K3+dtokeHcCb2jueUvomM6hmBxXLkfIqhct3beMp2YNhCiB52aYNrjo4DCO0yDE/VHmqyPmv2HmVLHvcnhCMHnU/s6BuwhidQl78GX02xv130sEvxVDZcKVy9aR7u4m0AhKWe4D9vi+5CRMY07LEplC15qlXP5C7LI//l8/HVlQMQNXgm4X3OwF2wibKl/8FXV07xF/dgj+9G9NDG+0tEDb0EW3Rn3EVbqPrhA0yvk8IPf03kwOnYwhMo+frvmO4aDFsocSf9BkeHXvic5dTtWEX1pnkN7hXe+3SsUZ3wVu6ifNlzQVktLCIiIiJyLFBxPhERETnsDMOgd3IUvZOjuH5CD/LLalm0uZAFmwtZlV2K9wDVrrYV1bCtqIbnluSRHJ3J5IxkJmd05MT0BBy2w7tR3d7VsWE9JmINjfGft1itdPvVKgCK5z90wKRw+fLnAQhNHUnHi17xl04I6di/Qbv4k3/b4HtPbSnlK+qTyaFdRxHWbYz/Wsfz/wOAs3Bzq5PCFate8SeEY0+8iaRz/u2/FtZ9PDtfmApA2XdPN5kUjhl5DeHdxwGQ//qlVK2bg+mpo3rjJ8QMn0Vd/tr6OXc7kQ6T/7Sv42jweVwN7mWxWonMOJvyZf+l4vtXlBQWEREREWmhNieF9+zZg9Vqbfa6aZpNXjcMA4/H09ZhRURE5DjQOTaMi0Z25aKRXamodfPN1iIWZBXw7dZiat3eZvvtqXDy6tJcXl2aS1SIjZP7JjE5I5mT+yQSHRrcTzN53XXU5S4FIKzr6Dbdw1mwCXdhFgC2uK7sfuNSXIVbsEUlETnoAqKHXY6lmddj5d89g+mqAurLLLSXynVv+49jx97c4FpYr1Owd+iFu2gLdbnLcJfmYo/r2uy9DMt+/5v46l8f2mO64K3Ip3brAvJfu5jwnpMISxuDPakfFlvjT6qFpo2mfNl/cRdvO+h4IiIiIiJSr81J4ZbsT9fKPexEREREGokOszNlYCemDOyE0+NlxfYS5mcVsmhzIcXVrmb7VTo9fLg2nw/X5mO3GoxOT+C0/h2Z3C+ZjjGHvhCxu3Azpqd+jwV7Yq823cNVsMl/XLVuzr7zu6Fmy1fUZS+h4wXPNurnczsp++7p+rETehLRr+UbyB2MuzS7/sBiwxbXvcE1i8WCPb477qIt9W2LtzVK0laumU1t9hLcRVupXPtW/Umrg/A+ZwIQN/FOdr16Efg8VK1/l6r17wJgi0sjfuKdRI+4yr9aGsCR2Md/XLdrrZLCIiIiIiIt0OaksGG0vl6fksQiIiISiBCblXG9EhnXKxGfabJ+ZzkLN+5i/uZickpqm+3n9pos3lLE4i1F/GnuBganxNQniDOS6ZUU2abXNQfjrS7yH1vD4tt0D9O379NVhi2ElOs+xx6fTv7LM6jbsZyKVa8QP+n3OBLSG/SrWPM63srdAMSO+2Wzq4nbxPgpIdvc6zpz30puwx7e6HL5sv82ul+H0/+KPToZgKiMs7HftIjS756iZvPn/s3sPKU5FLz7Cyyh0UQPusDf3Rq+72e7/89cRERERESa16aksJK7IiIicrhZDIPBKbEM7RjG7RO78WNxHfO3ljE/q5D1O8sP2HdtXjlr88r5x2dZdEsI9yeIh3WNw9pOG9VZHBH+Y5+7uk33sMfuW/UamjqSsLT6MhRRQy+mbsdywKQ2e0mDpLDP56Ns8WMAWCMSiR5+eZvGbo6jQ2+cO1eB6cVdmNWgtrHP68VVuGXf/OO7N+of3ud0rBFJGFY7jqQ+RGZMa5TUDk0dTqfU/+Hz+XAXb6F8ydP+lc9VG+Y2SAr7XPt+thZ7BCIiIiIicnCtTgq/8MILh2IeIiIiIgHpnhBOWnIcV47tTmGlk0VbClmQVcDy7SW4vc3/QTu7uIb/LvqR/y76kYQIB6f0S+K0jI6M69WBUHvbV9ja4rr5jz3l+W26R0iXYVjC4vDVlvpLUQCY+224tv9KWYCarE9xFWQCEDP6BqyOsDaN3ZyoIRfWJ4WBkkX/otOFz/mvVa6djacsF4Cw7hOwRSU16h9/8u/8G801pXLDXMJ7n4bVEY7FYiEksQ/xk//sTwr7nFUN2nvK8/zH9vhubX4uEREREZHjSauTwldcccWhmIeIiIhIu0mMCmHGsBRmDEuh2ulhybZiFmQVsHhLEVXO5je8La528dbKPN5amUeY3cqE3h04LaMjk/omERfReJOzA7FHJ2NP6Im7eCvOvFWNrhd+fBemp466nav950q/eZzKtW9hT+pH3Ik3YLHaiBx4HhXL/0dd3krKlj+PI64b5cvq6whbI5MJ73Vqg/uWLvoXUF+6IXbMTU3OrXzVqzjzVuKt27eiuvbHhRS8/ysAOkz9PyzWpl8mRg+/jNLFj+KtyKfy+1fwlGYT3vMUXAUbqfyp/q9hC6HDGfe38CfVUPEX97L77WuJ6DkJR3IGWGxUZ37kvx7Re3KD9nU//WwNRyQhnYe2aUwRERERkeNNm2sKi4iIiBwNIkJsTM5IZnJGMm6vj+9zSlmwuX4V8Z4KZ7P9at1ePvthD5/9sAerxeCEbnFMzujIaRnJpMY3rpXblMgB0yld+A9qtn2Nz+drsEFa2fLnMJ2VDdpXbahPqob3OoW4E28AIHHKA7j2bKQuZwkF7+5L8hqOSJJn/AeLbV+yum7HKmq3LwIgetgsbBEdmpxX9ebPqNq7ydtPnPlrcOavAaDDWQ83+0y28ARSrv2E3W9eiTN/NbXbF1O7fbH/ujWqE8kzniYsbVSz9zgQiyMC01lJ1Q/vww/vN7gW0mVYo3IYNZs/ByAyYyoWm71NY4qIiIiIHG8Ms50KBK9fv568vDzKysoIDw+nR48eZGRkNHjzI4dObW0tmZmZZGRkEBbWvh8TlWNLVVUVXq8Xq9VKZGRkq/tXOz0UVTmJCLFhOQQbM8mxw+JxYuDDxILPFnK4pyPHsLbGmmmabNpdyYKsAuZnFbK1oOrgnX7Sr1M0kzOSOS0jmf6do5vdqM5VkkP2//UHn5uU6z8nPP0k/7WyZc9iet1N9rPFphKVcbb/e5/PR+22BVRnfoDPU0dI56FEDZrRKOlbm7ucuryVAERmnI09NrXJ+1dv/hJX0eZmny9m1A0t2pyubtd6qjbMxVORT+Xa2ZiuamJGXkvyeU82aFezdT7Ogo318+p/LvaYzs3e0+dxU5f7HXW5y3GX5mB66rBGJBLeYyJhPU5ukPh1FW8n+x99AUi9cQFh3U486JwDEejvUJGWUqxJsCjWJJgUbxIsirWWCSgpvGvXLh588EFee+01SktLG11PSEjg8ssv58477yQxMTGgicqBKSksLaWksASLksISLO0Va3mlNSzIql9BvGZHGb4WvkLqEhvmX4k8sns8dmvDP4jvee9Wypf9l4i+U+hy5Xttnt+RrmrTJ+S/fD74PCScfh8JE393yMfc894vKV/2TNB+tnqDIcGiWJNgUaxJMCneJFgUay3T5qTwF198wUUXXURZWRkHuoVhGHTo0IG3336bCRMm+M+bpsktt9zCk08+2WxfaTklhaWllBSWYFFSWILlUMRaaY2LxVuKWJhVwJJtxTg9vhb1iw61cUq/+hXEp/XviNVi4KkuomrDXDAMoodf0Wyt3mNBxbo51Gz+EgxIOOVu7LEph3S88u9fx3TXEN5rMo74tEM6FugNhgSPYk2CRbEmwaR4k2BRrLVMm5LCK1asYPz48bhc9TtfN/eRScCfMA4PD2fRokUMGzYMr9fLZZddxuzZs/F6vW2cuuxPSWFpKSWFJViUFJZgOdSxVuv2svzHYuZnFbJoSyFlNU2XfPi5k3on8u+ZQwixWwixWbFa9N/Mo53eYEiwKNYkWBRrEkyKNwkWxVrLtHqpis/nY9asWbhcLn8y+GArhQFqamqYNWsWy5cv56KLLmLevHkHTCaLiIiIHAnC7FZO6pPESX2S8PpM1uaVsSCrgAVZheSV1jbbb+HmQn47Zy0XjkglOTqUcIcVu81CqM1Cxxj9AVdERERERA6fVieF3333XbZs2YJhGJimidVq5aKLLmLatGn06dOHiIgIqqurycrK4oMPPmiwGjgrK4t+/fqRn5/f7g8iIiIicqhZLQbDusYxrGsct5/am22F1f4Eceauikbtv9xYwJcbCxqd75EYwWn9OzI5I5khKbFYtIpYRERERESCqNVJ4Q8//BCoXx2cmJjIJ598wrBhwxq1GzRoEBdccAG/+tWvmDJlCkVFRQDs3LnT3+aWW25p67xFREREDivDMOiZFEnPpEiuHZ/Onoo6Fm6u36huRXYp3gPsVLetsJqnF2zj6QXbSIwK4dR+yZzWP5kxPRIIsVmD+BQiIiIiInI8anVSeNmyZUD9G6HHHnusyYTw/oYPH86jjz7KJZdc0qBcxJ///Gfuueee1g4vIiIickRKjg7lwhGpXDgilco6N99uLWJ+ViFLthZR7Wp+D4XCSidvLM/ljeW5RDisnNwnidP6J3NynyRiwuxBfAIRERERETletDopXFBQ/xFIm83Geeed16I+M2bMwGaz4fV6MQyDf/7zn/zqV79q7dAiIiIiR4WoUDtnDOjEGQM64fL4WJFd4l9FXFTlarZftcvLx+t38fH6XdgsBqPTE5ickczkjGQ6x6oOsYiIiIiItA/DPNAucU0ICQnB7XYTHx/vLwnREgkJCZSWlmK323E6na2eqBxYbW0tmZmZZGRkEBamN43SvEB34ax2eiiqchIRYsOizSLlACweJwY+TCz4bCGHezpyDDuaYs1nmvyQX+GvQ7y9qLrFfQd2iWFyRn2ZiT7JUdqw9zDQTtYSLIo1CRbFmgST4k2CRbHWMq1eKRwbG0thYSFlZWWUlZURGxt70D7l5eWUlZVhGAZxcXFtmaeIiIjIUc9iGAzsEsPALjHcOqkXOcXVLMiqX0G8Lq+cA/2lfv3OctbvLOeRLzaTGh/GaRn1G9WNSIvDZrUE7RlEREREROTo1+qkcNeuXSksLMQ0TZ566in+8Ic/HLTPs88+i2maGIZBt27d2jJPERERkWNOWkIEV4yJ4Iox3SiucrJoSyELsgpZ9mMJLq+v2X47Smr53zfb+d8324kLt3NKv/oSExN6JRLm0EZ1IiIiIiJyYK1OCo8fP55Vq1Zhmib33HMPMTEx3Hzzzc22f/755/njH//o/4jjuHHj2j5bERERkWNUQmQI04emMH1oCjUuD99tK2ZBViGLtxRSUedptl9pjZs5q/KYsyqPULuF8b0SmZyRzCl9k0iIbHk5jY27Knh9WS4/5JdT4/IS7rDSv3MMl47uSt+O0e3xiCIiIiIicoRodU3hlStXMnLkSAzD8K/+TUtL46yzzqJPnz5ERERQU1PD5s2b+fTTT9m6dSt7hzAMgxUrVjBs2LBD8jDHM9UUlpZSTWEJlqOpzqsc3Y71WHN7fazZUcaCrALmZxWyu7yuRf0sBoxIi+e0/vWriNMSIppst2ZHGfd/nMnK7FIADMDc71+AEd3iuPusDIakxgb6OEc11aeTYFGsSbAo1iSYFG8SLIq1lml1Uhhg2rRpfPTRR/7EMNDkZic/v3bWWWfxwQcfBDJfaYaSwtJSSgpLsBzriTo5chxPsWaaJpv3VDE/q4CFWYVk7alscd8+yVH+BPHALjEYhsHXm/Zw46vf4/b4DljP2AAcNgtPzxrGpL7JAT/H0UpvMCRYFGsSLIo1CSbFmwSLYq1l2pQULi4uZvjw4eTm5voTvk3dZv9rXbt2ZdWqVSQkJAQ4ZWmKksLSUkoKS7AcT4k6ObyO51jLL6tl4eZC5mcVsDqnDG8LX9Z1igllSGosX2TuweszD5gQ3mtvYnj2DScetyuG9QZDgkWxJsGiWJNgUrxJsCjWWqZNW1UnJCSwbNkyxowZg2ma/jISP//ae2306NEsWbJECWERERGRdtQ5NoyLR3blv5eN4Mtfn8Rfz+nPpL5JhNoP/BJvV3kdn2zYjaeFCWGoLyXh8vj428eZAc9bREREREQOr1ZvNLdXcnIy33zzDXPnzuWll15i4cKFlJWV+a/HxMRw0kknccUVVzB9+vT2mKuIiIiINCMmzM7UQZ2ZOqgzdW4vy7eXsCCrgEVbiiipdrXLGCawIruUTbsrtPmciIiIiMhRrM1J4b3OPfdczj33XKB+eXZFRQXR0dFani0iIiJymITarUzonciE3ol4fSbrd5azIKuABVmF5JbUBHz/15bmct+5A9phpiIiIiIicjgEnBTeX2RkpJLBIiIiIkcQq8VgSGosQ1Jjue2UXmwvquaW11ezu6KuTfczgMxdFe07SRERERERCao21RQWERERkaOPYRikJ0YSGdr2dQEmUOX0tN+kREREREQk6FqVFJ4xYwarVq1ql4FXrVrFjBkz2uVeIiIiItJy4Q4rRgD9s4uqeeW7bGpcSg6LiIiIiByNWpUUfu+99xg5ciSnnHIKr776KlVVVa0arKamhtdff51TTz2VkSNHMnfu3Fb1FxEREZHA9ekYhRlAf6fHx5/e/4ExD37NPz7bREEbS1GIiIiIiMjh0abPDi5YsIAFCxYQGhrKpEmTOPHEExk5ciTp6ekkJCQQFRVFRUUFJSUlbN++nRUrVrB06VK+/PJLamtrATBNE8MIZI2KiIiIiLTFjGEpvL0yL+D7lNW4eXL+Np5dtJ1pQzpzzbju9OsU3Q4zFBERERGRQ6lVSeGJEycyf/58DMPANE1qa2uZN28e8+bNa1F/02y4JmXixImtGV5ERERE2kHv5CiGpMayZkdZu9zP5fUxZ1Uec1blMb5XB64dn86EXh20AEBERERE5AjVqvIRX331FR999BH9+/dvdM00zWa/fm7gwIF8/PHHfPnll22fuYiIiIi02R2Te+OwWVpcW9gAHDYLd57Rl3E9OzTbbvGWIq54fjmn/3sRb63YgdPjbZf5ioiIiIhI+2lVUhhgypQprFu3js8++4zp06djtVobJH4Nw/B/7WWaJlarlenTp/Ppp5+ydu1azjzzzPZ5AhERERFptQFdYvjH+YOwW1v2ctBus/B/5w9i5gmpPHbxUObceCLTh3bB0Uz/zXuq+N076xj74Hwe+2oLJdWu9py+iIiIiIgEwDCbWsrbCqWlpSxevJjFixeTmZlJYWEhZWVlxMbGkpiYSN++fRk/fjwTJkwgPj6+veYtP1NbW0tmZiYZGRmEhYUd7unIEayqqgqv14vVaiUyMrLV/audHoqqnESE2LDoY8FyABaPEwMfJhZ8tpDDPR05hinWArNhZzn/+mIzq38qJWEA5n7/AgxNjeX2yb0Z0CWmUf+Sahdvr9zBWyt3UFrjbnacULuFGcNSuHpcd3oktv73z5Eg0N+hIi2lWJNgUaxJMCneJFgUay0TcFJYjgxKCktLKSkswaJEnQSLYq19bNlTyZzv89i8u5Jql5cIh5XeHaM4f1gKvZKjDtq/zu3lkw27eHVpLtuLqg/Y9tR+SVw7Pp1R3eOPqrrDeoMhwaJYk2BRrEkwKd4kWBRrLdOqjeZERERE5NjUKzmK35/Zr839Q+1Wpg9N4ZwhXViytYhXluayIrukybZfbizgy40FDOwSw7XjuzNlYKcWl7EQEREREZHA6dW3iIiIiLQbi2Ewrlciz1w2nDeuG81ZAzthtTS9Gnj9znJue3MNEx6ezzMLt1FR13z5CRERERERaT9KCouIiIjIIdGnYxT3nTuAj28dx1VjuhEV2vSH1HaV1/HAJ5s48e9f8dcPM9lRUhPkmYqIiIiIHF+O2aTwnDlzuPXWWxk/fjzR0dEYhsGsWbMO2Mfr9fLcc88xYcIE4uLiCAsLIz09nZkzZ7J58+Ym+7z00kuMHDmSyMhIYmJiOPnkk/noo48OOMa//vUvBg0aRFhYGPHx8UyZMoUlS5YE9LwiIiIiR6qk6FBuPaUXn9w2nt+d3oeUuKb3P6h2eXn+2+2c9I/53Pza96zOLQ3yTEVEREREjg/HbE3h+++/n7Vr1xIZGUlKSgqbNm06YPuqqirOOeccvv76a4YMGcIVV1xBaGgoO3fuZPHixWzevJnevXs36POb3/yGf/7zn6SkpHDdddfhcrl48803Ofvss3n88ce55ZZbGrQ3TZOLLrqIOXPm0KdPH2655RZKSkqYPXs2EyZM4J133uGcc85p95+FiIiIyJEg3GHjopFduWBEKguyCnh1aQ5r88obtfOZ8PH6XXy8fhcj0uK4dnx3Jmd0bLYMhYiIiIiItI5hmqZ5uCdxKMyfP5+UlBR69uzJwoULmThxIpdeeimvvvpqk+0vvfRSXn/9df7zn/9www03NLrudrux2+3+75csWcLYsWPp0aMHK1asIC4uDoDs7GyGDx9OdXU1mzZtolu3bv4+b7zxBpdccgljxozhq6++IjQ0FIAVK1Ywbtw4YmJi2LZtG1FRB9/h++dqa2vJzMwkIyODsLCmV9+IQOC7cFY7PRRVOYkIsWE5inaMl+CzeJwY+DCx4LOFHO7pyDFMsXZ0W5dXxmtLc/lq0x58B3hVmpYQztVju3P+8BQiQg7PugbtZC3BoliTYFGsSTAp3iRYFGstc8yWj5g4cSK9evXCaEHS6vvvv+f1119n5syZTSaEgQYJYYD//Oc/APzxj3/0J4QBunXrxs0334zT6eSFF15o0Ofpp58G6lcx700IA5xwwgnMnDmTwsJC5syZ07IHFBERETkGDEqJ5aHzB/H+zeO4ZFRXwh3WJtvlFNfwlw9+YMyDX/PQp5vYU1EX5JmKiIiIiBw7jtmkcGu8/vrrAFx88cWUl5fz6quv8sADD/Df//6XrVu3Ntnn66+/BuCMM85odO3MM89s0Aagrq6OJUuWEB4ezvjx41vUR0REROR40SUujN+c1odPbhvPbaf0Ijm66VXf5bVunl6wjXEPfc0ds9eQmV8R5JmKiIiIiBz9jtmawq2xYsUKAHJycujRowfFxcX+a4ZhcNNNN/HYY49htdavXKmurmbnzp1ERkbSqVOnRvfr1asXQIPN6bZt24bX6yU9PR2brfGPvak+zSkoKKCwsLDBOZ/PB0BNTQ1er/eg95Dj19748Hq9VFVVtb6/zyTS6sPi9WKg8hFyID7/vxaP87DORI51irVjSYwNrhrZiVnDk/liUxGvLM9j4+7Gv6/cXpN3V+/k3dU7Gd0tlstHpzCuR/whLW0U6O9QkZZSrEmwKNYkmBRvEizHc6y1plyGksLUJ1kB7rjjDs4991zuv/9+UlJSWLZsGTfeeCNPPfUUiYmJ3HPPPQCUl9dviBITE9Pk/faeLysr859rS5/mPPXUU9x7770NzqWnp/PWW2/h9XqVFJYWa2us2AwA86cvkQOrT8/4DtJKJHCKtWOLwwpn9e/AlIwEVu2o4OVlO1m4taTJtkuzy1iaXUZ6QhiXjezCWQOSCLEd2g/E6fWWBItiTYJFsSbBpHiTYFGsNU9JYfatsu3bty+zZ8/2rwg+5ZRTmDNnDsOGDeORRx7hD3/4Aw6H43BOFYBf/OIXXHDBBQ3O+Xw+XC4XVqvVP3+Rpuz/H8S2xIrXZ+Lx+bAYhlYKy0H4MNj7pwNVK5JDSbF2TDNgeNc4hneNI7u4htdW7OSD9Xtwehr/AeDH4lru/WQrjy/M4aIRnbloeGfiI9rvtVugv0NFWkqxJsGiWJNgUrxJsCjWWqZVSeH2+EEahoHH4wn4Pu0pNjYWgLPPPrvRMw4ePJju3buzbds2Nm7cyODBg/2reveu/v25vef33hdoU5/mJCUlkZSU1OBcbW0tmZmZhIeHExYWdtB7yPEr0F04q50eyqqcRITYDulHdOXoV/8xfh9gwWdrujaoSHtQrB0/uiaH8Pupcdw4qTdzVuYxe+UOSqpdjdqV1Lh5alEOzy3ZwYxhXbhmXDo9kwLfeVo7WUuwKNYkWBRrEkyKNwkWxVrLtGo5jWma7fJ1pOnTpw/QfEI2Li4OqE+8AkRERNClSxeqqqrYtWtXo/ZbtmwBoHfv3v5zPXr0wGq18uOPPzaZFG+qj4iIiIg0Fhfu4LoJ6Xz8y3H8+ewMeiRGNNnO5fHxxvIdnPrIQq5+cQVLthYdka9FRURERESCrdWfsTQMo81fR6pTTz0VgA0bNjS65nQ6/Qnbbt26+c9PmjQJgE8//bRRn08++aRBG4DQ0FDGjBlDTU0NixcvblEfEREREWleiM3KuUO68NYNJ/LEJUMZnR7fbNuvNxVwyXPLOOuxb3hvdR6uJspPiIiIiIgcL1qdFD7YCuCjYWXwz82YMYPOnTsze/Zsli9f3uDafffdR3l5ORMnTqRjx47+8zfeeCMAf/vb3ygtLfWfz87O5sknnyQkJISrrrqqwb1uuukmAO6++27q6ur851esWMHs2bNJTExkxowZ7f58IiIiIscywzAY06MDT106nDevH83ZgztjszS9ICFzVwW3z17LhIfn8/SCbZTXuIM8WxERERGRw88wW5G1zcnJafL8vHnzuPXWW4mIiOD222/n1FNPJSkpiYKCAr744gv+/e9/U1VVxV//+ldmzZpFWlpauz1Ac+bOncvcuXMB2L17N5999hnp6emMHz8egA4dOvB///d//vZffPEFU6dOBeC8886jS5cuLFu2jG+++YakpCS++eYbevXq1WCMX//61zzyyCOkpKRw/vnn43K5mD17NsXFxTz++OPccsstDdqbpsmFF17InDlz6Nu3L2effTbFxcXMnj2buro63nnnHc4555w2Pe/emsIZGRmqKSwH1B41hYtUU1hawOJxYuDDVJ1XOcQUa9KUwkons1fsYM6qHVTUNb+fRbjDyoUjUrl6bHe6JoQf8J6qTyfBoliTYFGsSTAp3iRYFGst06qkcFM2bdrE0KFDcblcfPDBB5x11lmN2nz00UdMmzYNm83G0qVLGTZsWCBDtsg999zDvffe2+z1tLQ0srOzG5xbu3Yt9913HwsXLqS8vJyOHTty1lln8ac//YnOnTs3eZ8XX3yRJ598kszMTCwWC8OGDeO3v/2tP8H8cx6Ph8cff5znn3+erVu3Ehoayoknnsjdd9/NmDFj2vy8SgpLSykpLMGiRJ0Ei2JNDqTW5eXDdfm8tiyHHSW1zbazGHB6/45cO747w9OaLkOhNxgSLIo1CRbFmgST4k2CRbHWMgEnhS+99FLeeOMNwsPDqaysbLJ2sGmaREZGUldXx7nnnss777wTyJDSBCWFpaWUFJZgUaJOgkWxJi3h9Zks3lLIK0tzWJ1bdsC2Q7vGct34dE7LSMZm3VdtTW8wJFgUaxIsijUJJsWbBItirWVsgd7g66+/BqCuro6amhoiIhrv/lxdXY3T6QTgm2++CXRIEREREZFWsVoMTu6TxMl9kvghv5xXvsvhq40FeJtYH7E6t4xfvPY9qfFhXDWmOxeekEpkSMAvm0VEREREjhit3mju58rKyjAMA9M0+d3vfofP13AnZ5/Px29/+1t8Ph+maVJRURHokCIiIiIibda/cwwPzhjE+7eMZdborkQ4rE2221FSy18/yuTEB77igXkb2V3hDPJMRUREREQOjYDLR/Tt25ctW7b4v+/atSsTJ04kMTGRwsJCFixY4N+gzjRNevfuzaZNmwKbtTSi8hHSUiofIcGij/RLsCjWJFBVTg9zV+/k9eW57C6va7adzWJwWr8OXDk6lZG9OgVxhnK80cdeJVgUaxJMijcJFsVaywT8ObgLL7yQ+++/379aOCcnh5deesl/ff+cs2EYXHTRRYEOKSIiIiLSbiJDbMwancZFI1P5KrOAV5bmkLmr8afbPD6TeT8UMu+HQkanx3Pd+HQm9knCYtEfSUVERETk6BLwSuGamhpGjx7Nhg0b/JvM/TwRvPfcwIEDWbp0qVayHgJaKSwtpZXCEixavSnBoliT9maaJqt3lPHqdzks3FzIgV4spydGcM247swYlkKovekyFCKtpRVOEiyKNQkmxZsEi2KtZQKuKRweHs7XX3/N1KlTMU2Tn+eY9547++yz+eqrr5SwFBEREZEjmmEYDOsaxyMzh/DeL8ZwwYgUQmxNv2z+sbCaP763gTEPfs0jn2dRWKm6wyIiIiJy5At4pfD+Vq1axfvvv88PP/xARUUF0dHR9O/fn3PPPZdhw4a11zDSBK0UlpbSSmEJFq3elGBRrEkwlNW4eHdlDm+u3ElRtbvZdg6bhelDunDN+O70To4K4gzlWKIVThIsijUJJsWbBItirWXaNSksh4+SwtJSSgpLsChRJ8GiWJNgsXicuD0e5mUW8cqKfLYWVB2w/Um9E7lufDpjeyb4S6qJtITezEqwKNYkmBRvEiyKtZYJeKM5EREREZHjhcNm4ZxBHZk6tCvLtpfwytIcvttW3GTbhZsLWbi5kL4do7h2fDrTBnfG0UwZChERERGRYGrXpPC6devYtm0bVVVVjWoL7+/yyy9vz2FFRERERILKMAxGpycwOj2BrQVVvLYsh3nrd+H2Nn4NvGl3Jb95ey0Pf7qJK8Z049JRXYkNdxyGWYuIiIiI1GuX8hFz587l9ttvJzc3t0XtvV5voEPKz6h8hLSUykdIsOgj/RIsijUJloPFWlGVk7dX7uDtlXmU1TZfdzjMbuWCESlcPbY73TpEHMopy1FKH3uVYFGsSTAp3iRYFGstE/BK4S+//JLzzz8f0zQPuDp4L9VTExEREZFjUYfIEG46uSdXju3Ox+vyeW1pLjklNY3a1bq9vPxdDq8szWFyv2Sum5DOiLQ4vU4WERERkaAJOCn897//HZ/Ph2EY/hey2rtORERERI5XYXYr5w9P5bxhKSzeUsSrS3NYlVPaqJ1pwueZe/g8cw+DU2O5dlx3zhzQEZtVdYdFRERE5NAKOCm8atUqDMPwJ4LT09NJSkrC4XBotYOIiIiIHLcshsFJvRM5qXcimbsqeG1pDp//sAdvEwso1u4o49Y3VtMlNoyrxnZj5gmpRIXaD8OsRUREROR4EHBSeG99YMMweOGFF7SJnIiIiIjIz2R0iuZv0wdy66RevLEil/e+30mV09Oo3c6yWu7/eCOPfrmFi0amcuXY7nSJ1X4RIiIiItK+Av5sWp8+fTBNk7CwMCWERUREREQOoGNMKLef2ptPbhvPr0/rTaeY0CbbVTo9PLt4OxMens+tb6xmXV5ZcCcqIiIiIse0gJPCs2bNAqC2tpbdu3cHPCERERERkWNdRIiNS0el8f4tY3loxiAGdIlpsp3XZ/Lh2nymPfEtFz7zHZ//sBufT/t3iIiIiEhgAk4K33rrrYwcORKASy+9lIKCgoAnJSIiIiJyPLBZLEzOSOalq07g+StPYFLfJJrblWP59hKuf2UVpzyykFeW5lDr8gZ1riIiIiJy7Ai4pvD1119PcnIypmmyYMEC0tLSGDVqFCkpKTgcjkbtDcPgf//7X6DDioiIiIgcMwzDYEhqLENSY9lRUsPry3N5f81O6ty+Rm23F1Xzp7kb+OfnWcwalcblY9JIimq6DIWIiIiISFMM02xi++NWsFgsGIbB/rcxjKbXN5imiWEY/s3ppP3U1taSmZlJRkYGYWHajESaV1VVhdfrxWq1EhkZ2er+1U4PRVVOIkJsWJr5/7oIgMXjxMCHiQWfLeRwT0eOYYo1CZZgx1pFrZt3vs/jzRU7KKx0NtvOYbUwbUhnrh3fnb4dow/5vOTQC/T1mkhLKdYkmBRvEiyKtZYJeKXwXs0lgkVEREREpPWiw+xcNbY7s0an8dkPu3l1aQ6b91Q1aufy+pizKo85q/IY36sD145PZ0KvDsfN63N3+c5G5yyh0VhDog7Yz1tXjjN/DT5nNbbIZBydBmKxOfC66/DVFB90XMNixxaV1OZ5A7hKsnEVbMIaFkdIyggsVisAoaGhVFdXN9vPU1mA6XM3ec0akYjFtu8Tm66irbhLcnAk9cYem9qgrc/no2bzZ1jD4glLGxXQs4iIiMjRpV2SwgEuNhYRERERkWbYrRamDurMWQM7sTy7hNeW5vLN1qIm2y7eUsTiLUX0SY7imvHdOWdIZ0Js1iDPOLiy/5GB6alrdN7RcQDRwy4jdtwvsVj2baVSl/c9JfMfpDrrswb9LCHRxJ38G0I6DSb/xXMOOq4jOYNut69u05xdpTkUvn8b1Zs+BerfS9kTetLhjPuJGjgdi8VCSEgIHo+nyf55z52Oa09mk9dSf7GYsK4j8fl8FLz7CypWvgBG/fPHT/oDHSb/yd+2at0cdr95GR0vfZ0wlBQWERE5ngScFP7LX/7SHvMQEREREZEDMAyDUd0TGNU9gR8Lq3htWS4fr9uFy9u47nDWnkp+N2cdD3+axRUnpjFrdBpxEY33+zjWGI4ITK8bvC5cuzdQNO9OTK+LhIm/A6B6y9fkv3Qupqe+HIclLBZ7Qk+81UV4SrOp/XERIZ0GH9I5+txO8l84B1fBRrDYCUsfh2vPRtzFW9n1+iVYr/+C0LQx2O32ZpPC+z0xWJpO+tdunU/FyheIHHQ+HS94nrznTqfkq78RNeRCQhL74HVWUjjvTsJ7nUpk/+nt/6AiIiJyRFNSWERERETkKJOeGMmfpmZw88SevLVyB2+t3EFZTeNyAkVVTv75xWaeXLCVGcNSuGZcd9ITj83aera4bqTfmYXP56M68wN2vToTgPKl/yFh4u/web3sefdGf0I4/tQ/ETfh11gd9ftxOPdkUrP1a8J7nUqPe0v8993z9rVUbXgXgJQbviSk87D6C20sz1Gd9Ul9QhhImPwnEibeibs0l+3/yACfm9LFj9IpbQyGYTRY4dyUDmfcT/zJv2nymjO/fhVzeM9JWOwhhHUfT13Odzh3riUksQ/FX9yHr7qYxGn/Oug4IiIicuxpt5rCIiIiIiISXPERDm48qQdXjunGvPW7eHVpLtnFjWvR1rl9vLYsl9eX53JK32SuHd+dUd3jj8m6wxaLhagB57InPAFfTTGe8p34PC5qf1yEpzQHgLDu4+lw6t0N+oUkZxCSnFH/jXW/t0n7rcS12MKxhkQ06FebswznrjUHnJPhiCRm2KUAVGd96j8f2b++TIU9rishnQbi3Pk9tT8uxPR5MSxWrNYDl/6o3bGMok//jOEIJ7znKYSkDPcneK2RiQB4K3bX/1u5BwBbVBLO3T9QtuQp4ibcTkhi7wOOISIiIsemdk0Ke71elixZwtq1aykrKyM2NpbBgwczZsyYg76gERERERGRtgm1WzlvWArnDu3Ct1uLeGVpDiuzSxu1M034cuMevty4h4FdYrh2fHemDOyE3XrsrBT1uZ1Urnvbv1mcLS4Ni81B9ebP/W0iMqa223hVP8yldNEjB2xji031J4VduzbsOx/d2X9sjazftM5XV46ndDv2hJ4HTdpX//AB1XwAQPHnfyE0dSSdr3ofW3g8kQOmU/zFvZQu/jeuwiwqN7xHSOchhKaNZef/pmCL6Uz8pN+36ZlFRETk6NduSeEPPviA2267jdzc3EbXunbtyqOPPsq0adPaazgREREREfkZi2Ewvlci43slsmlXBa8uy+WzH3bj9TXeGHr9znJue3MND32yiSvHduOikV2JDrUfhlm3D09pNpvvCml0PnbMzQD4nJX+c9aIpHYbN2rwhTg6DjxgG8t+q4t97hr/sWEL29fGvu/Y56oFwGZr+u2aNTyByMEXEpLcH9NdS8WaN/GUZlO3YzklX95P0rRHsIZGk3rzd5QteQJPaQ4Jk35P7NhbqFo/h9rti+h02Vt4yvPY/ckfcO5ejy0iibiTfk3UgHPb8mMQERGRo0y7JIVfeuklrrnmGkzTxDQbv+DMycnhvPPO44UXXuCyyy5rjyFFREREROQA+naK5v5zB/DLST15c8UO3vk+j8q6xhuX5ZfX8fd5m3j0yy3MPKErV43tRmp8+GGYcTsyrISmjiB62CyiR14LgC1yXyLYXbyt3YayJ/bFFt/9wNPZb8WvJTTGf+xzVWKxxdcf75+0Dos94P26XPsZlv0+iRlz4o1kP9QH0+ukcv0ckqbVr1y2RyeTeMZ9/nbeugoK591FeJ8ziOh9Bjn/GoKnag8dTruHiu9fZddrF2P7xWLCUkcc/MFFRETkqBZwUnjnzp384he/wOfzYRiG/wWPaZoNXvz4fD5uuukmJk2aRJcuXQIdVkREREREWiApOpRfntKLa8d354M1+by2LJedZbWN2lW7vDz/7XZeXLKdMwd24rrx6QxJjQ3+hNvIFtuVtF+tAsCwRzRImgJEDjqfkvkPAlC57m3iJ96FxdZwZbTP52v1pmslX/61ReUj0u/aCkBY2mjqcpYA4C7ahq1rfVLYXVr/iUtbTArWmJQD3u/nz2aP7oQlPA5v5W58teXN9iv+4l58tWUkTfsXzt3rcZf8SOTAGcSN+yXWiER2z76S6h8+UFJYRETkOBBw8bCnnnqK2tpaDMPwJ4K7d+/O6NGj6d69u/88QG1tLf/5z38CnrSIiIiIiLROuMPGRSO7Mvfmsfzj/EEMSolpsp3PhI/X7eLcJ7/l/KeX8OmGpstPHHEMC9bQaKyh0Y2SpgChnQYS2nUUAO7CLPJfmUHtjpX4vB7c5TspW/pfCube0uphHUl9ieh75gG/wntM9LeP6Hum/7h8+XP4vF5qti3AXbQZgPBek/2Lawrf/yWb7wpl812heH6qkVybs4zCeb/HVbwdqE9kl373NN7K+g3lQlKGNznPul3rKfvuP8RNuANHQjp43fU/NlvIT/+GAmB6Xa3+GYiIiMjRJ+CVwl9++aX/ePTo0bz00kv06tXLf27z5s1cccUVLFu2DIDPP/+c++67r9F9RERERETk0LNaDE7pl8wp/ZJZm1fGa0tz+HpTAU3lfVfmlLIyZxVpCeFcPbY7F4xIIdzRrntVB1XHmS+R978z8JRkU5P1GTVZnzW4Ht7r1FbfM2bEFcSMuKLF7UO7jSMiYxrVmR9QsfJFqta/i89ZAYAlPL7h5m+mCTT8H8Z0VVO66BFKFz2CNaIDPo8Tc2/pCcNCwsTGm8f5fD4K3r8Ne2wqcRPvBMDRaRDWyCRqNn9O1cZ5lC/7L1CflBYREZFjX8Arhbdu3eo/fuONNxokhAF69+7NG2+8AdSXlNi/vYiIiIiIHD6DU2J5+PzBvH/zOC4e2ZUwe+MVtgA5xTX85YMfOPGBr3n4003sqagL8kybZ09Ix57QA3tc2kHbOhK60/XWZXQ462FCUkaAUf92yHBEEJZ+EjEn3tSojy2qY/39E3r4V9UGwmKx0PHiV0g4/a/YYlPxOSswbCFEDb2U1JsW4Ijf9xzWyET/2Hvnak/qQ/SIq7DHp+OtKcF0VmI4IojoN5WUqz8mok/jpG7l6tepy/6WDmf/E6u9fkWwNSSCTpe8hjUikfyXzqMufy0dznyAiN6nBPyMIiIicuQzzKZ2hmsFh8OBx+MhMjKSioqKZttFRUVRXV2NzWbD5dJHktpbbW0tmZmZZGRkEBYWdvAOctyqqqrC6/VitVqJjIxsdf9qp4eiKicRITYs+9UNF/k5i8eJgQ8TC752eBMt0hzFmgTL8RBrlXVu3v1+J28sz6Wg0tlsO7vV4OzBnbl2XDoZnaODOMP25fN6MT11GPawVtcSbi9eVy2GLaTB+D6fz398oHn5PG5Mb119DeUDtPM6qzF9bmzNbGDn87iw2Bytn7wc9QJ9byDSGoo3CRbFWssE/MonOrr+RWB1dTXZ2dlNttm+fTvV1dVAfXJYRERERESOPFGhdq4Y040Pbx3H/ecOoG/Hpl+7u70m736/kymPLebS55YyP6uAANeaHBYWqxVryIETqoea1dE4Ie10Np+Q35/FZscaEnXQ+VtDIppNCNffRwlhERGR403Ar372Lxdx8cUXs3nz5gbXN2/ezCWXXAKAYRj07t070CFFREREROQQslstTBnYideuHcV/LxvO+F4dmm377dZirnphBaf9axFvLs+lzu0N4kyPTV6vl6qqqhYnh0VERERaK+BdIk499VT/JnLLly8nIyODrl27kpiYSGFhIbm5uQ1WDUyerI0LRERERESOBoZhMKJbPCO6xbO9qJrXl+Xw0bpdOD2+Rm23FFRx17vr+b/Ps7hsdDdmje5KQuSxWWbjULNarYd19bKIiIgc+wKuKZyfn0/v3r2pra0FaPJjY4ZhYJomERERbN68mU6dOgUypDRBNYWlpVRTWILleKi9KUcGxZoEi2KtXmm1i7dX7eCtlXmUVDe/V0iIzcJ5w1K4Zlx3eiapnl9rtLSmsEigVHdTgknxJsGiWGuZgF9hdO7cmaefftr/vWEYjb5M08QwDJ5++mklhEVEREREjmJxEQ6un9CDj385jj9PzSC9Q0ST7ZweH28sz+XURxZy9YsrWLKtqN3qDnud1TgLN+Mq/rFd7if1fB43zsLNOAs34/N6Dvd0RERE5BAKuHwEwGWXXUZsbCy/+tWv2L59e6Pr3bp149FHH+Xss89uj+FEREREROQwC7FZOXdoF84Z0pkl24p5dWkOy7aXNNn2600FfL2pgP6do7l2fHemDuqM3dr29SmFH95BxcoXiRx0Pp0veQ0Ar6uWmqxPqduxHFfBJkyzvrZxp0vewBqyL3HtqS2l/LtnqMtdiqtoG6a7Gmt4AmHpJxE79lYc8WkNxqrN/o6y5c9Rl7MUDIOw7uOJG38bIUl9/W28rhqKPr4L5641eCp3A2CLSCI0bRSxY27BkdC9Rc9Vt2s9FatepmbLl/jqKrCExhDRezJRw2YR2mlgg7YFH/0OV+GmBucMWwihnYcSOXA6IUn9/Od9Ph9VG96hcs1snLvWgc+LNTwee0JPwntOJHb09T/dwEL+y+fjLswi8ZzHiDvxhhbNW0RERI4+AZeP2J/X62Xp0qWsXbuWsrIyYmNjGTx4MKNHj8ZqtbbXMNIElY+QllL5CAkWfcxagkWxJsGiWDu4zbsreW1ZDp9s2I3H1/zbjI7RoVw5thsXj+xKTJi9VWM4CzaS86/hYHrp+stlhHYeAkBd/jpyHzuhUfv0v+zBFhbr/742Zyk7nj6pyXtbwhNI+9Uq7NH1n26sWP0mu9+6CkwfWB31jbwuDGsIna94j4jepwDgqSrkx/tTmr5nWBzdfpuJLTz+gM9V9OX9lHx5X7PXE079Mwmn/tH/fe5TE6jLXdZ0Y8NK0nlPEnvCVQCULPo3RfPubLKpPaEH3X+b6f++bPnzFLx7E9bIJLr9LgurI/yA85ajmz5iLcGkeJNgUay1TLusFN7LarUyduxYxo4d2563FRERERGRo0DvjlHce84AbpnUkzdX7OCdVXlU1DUuQ7C7oo4HP9nEY19t4cIRqVwzrjup8S1LPpZ9+xSYXkI6DfInhAEsIZFEDbmY0JThVG36mNqt85u9R2jqCcSOvZWw9An46srZ885N1OUswVdTTPnS/9LhtL/g83op+vwvYPqwd+hF6s3fACY7nhiHu3grBXNvJu03mVgsFgxbCB3OfIDw3pOxxabiLctjzzs3Upe3Al9tKVXr5uxbjduEyo0f+xPClvAEEk79E6FdR1Gb/S0lX/0NX20pxV/+lZCU4UT2PaNR/8Rz/o1hC8WZ9z3ly/4LppfiT+8masjFGFYHpYv/BYA9oScdpj6MPaYL3spCanO+rV85vJ+owRdQ+OEdeKsKqFw7259YFhERkWNLuyaFRUREREREEqNCuXVSL64dl84Ha/N5bVkOeaW1jdrVuLy8uCSbl7/L5vT+Hbl2fDrD0+Kava/P66Vy3VsARPQ9q8E1R0I6nS56EYC6naubvUdI56Gk3LRo3wZu0Z1IOOWP7Hy+/n7u0pz6fws24inNrh+r16n+1cbhPU+hvHgr7pLtuPdkEtJpANbQaOJPusM/hi0sloj+06jLWwGAYT9wwrti2XP+4+TpTxLR/5yf5joEW0Qiu2dfUd9uxfNNJoWjBs+sX4l8wlU4d2+gLmcJ3uoiXDtX4+g0CO9PJS3C0scT1W/fzy2iz+RG97KGRBHe42SqN31C5fevKyksIiJyjAp4o7nnnnuO+Ph44uPjueSSS5psc8kll/jbPPfcc022ERERERGRY0uYw8rME1J57xdj+b8LBjMkNbbJdj4TPtmwmxlPL+G8p75l3vpdeJsoP+HatRZfbRkAoV1HtmlOFnvIvoTw3vsWb/Efh6YMa9THW1exb67Ocv9xzbaGq5Frc5dTsf4dShb8H2XfPg6Ao+MAIgee1+x8vK4aqrd8WT+30BgiMqY1uB456Hx/Urk66zN8Hlez9/J5PXhriv3fG44wrCERWKM7A1Cx4gVy/zOJwk//RNWmT/C665q8T2hKfRmOuh3L8bmdzY4nIiIiR6+AVwrPmzePsrIyDMPg2muvbbLNDTfcwJtvvolhGMybN6/ZdiIiIiIicuyxWgwm9U1iUt8kNuws55WlOXy1cQ9NlR3+PreMX7z2PanxYVw9tjsXjEglMqT+bYuzYKO/nb1Dj3aZW+2OlRR/9hcAQjoPJvqEa+rvn5yBLb4bnpJsqn6YS+l3J4BpUvXDB/6+3p8S1HuVLHiY6swP/d/bYlJInv7kAevyeiv3gNf1U/suWKxWfD4fHo8Hm82GxWrDFt0Jd/E2TE8d3ppiLD/VPN6r8IPbwWLDmb8Gd2EWAI7Evjg6DgIgccpD7Hn7Wkyvk7rsb6nL/pZSwBISTcLkPxM37tYG97PFdwPA9NThLsshJLF3C3+aIiIicrQIeKXw2rVrAbDZbEyYMKHJNmPHjsVur99AYt26dU22ERERERGRY9+ALjE8NGMQH9wyjktHdSXC0fSG1DtKarn3w0xOfOArCirr8PpMfLWl/uuWkOiA51K1cR55z56Gr64cR3J/Ol/5IVZH/abNFouFpGn/xrCHY7qqKXz/VxR+cDumZ9/KWYsjosH9IvufS+zYW4kccB6GPQxPeR55/z2N2pxmNoQDjP02LfS5a/zHNtu+9Ts+177zltDYRveoXPMmld+/imv3hvq+MSkkn/9f/4ro6CEX0vVXK4g76beEdB4Klvr3Zj5nBYUf/YaaLV83uJ8lNGbf2DUlzc5dREREjl4BrxQuKCgAIDIyssELlwaD2GxERERQVlbGnj17Ah1SRERERESOcp1jw/j1aX24fkI6c1fv5I3lO9hd0bicQWWdhx0ltZgmGNZ9O4ibrqqAxi9b/j8K5v4SfB5C08bQ+Yp36uvy7iey75l0++0mqta9hbvkR2wxqWCxUPTxnQCEdj2hQfuY4bNg+Kz6ea9/j12vXYTpdVK+/DnC0kY1OQ9rZDK2mC54ynfiKduJp7oIS9i+ebjL8vBW1b+HssV08Set9xc/6fcY9jAs9jBCU0YQkjoSi7Xhe7OQxD4knnk/nHk/3rpyir/4K2XfPgFA9bb5hPea5G9rOiv9x5awGEREROTYE/BKYa/XC0BZWRkVFRVNtqmoqKCsrKxBexERERERkahQO5ed2I33bxnL36cPoF+nqEZtCivrV+f6Yrv7z9UU/ohpNlF/4iB8Ph9Fn99Lwbu/AJ+HyIEz6HLtJ40Swnvb2qOTiRt3K0nT/kXsuF9StWEuANaoZEK7jgHAU1mAz+dr0LfBCuC6cppjsVqJGnTBTw3dlHx5v/+5TJ+Pos/vAbP+3lGDL2ryHrHjfknCxDuJG/dLwrqNaZQQLv7yb7gr9i3OsYbGENH79H0NfvZz3LvZHlYHtti0ZucuIiIiR6+AVwp36NCBvLw8AJ5//nl+9atfNWrzwgsvNGgvIiIiIiKyP7vVwhkDOnF6/458n1vGq0tzWLS5EBPYkF/O0K6x0HE4hiMS01VFTc4yPKknE+6wEma34q0uYvfsKwFw7v7Bf99dr8zEsNqI7D+N2NE3UJezhJKv/+6/7ty1ntzH9m1aF5Z2Ih3PfwaA0oX/h3PnakJThmN6nFRlfoAzfw0A8Sf9Fou1vvRFyfwHqc76jLD0Cdgik/FU7qZqw7v+e0YOvuCAzx479lYqVr+Bt2oPZd89Tc22BYR0HkrdjuW4i7fW/3wS+xA/6c42/WyL5z9I8Vd/I6TLUBwdemJ6nNRs+cp/PWrA9Abt6/JWAhDaZegB6yGLiIjI0SvgpPCQIUPIy8vDNE3uvvturFYr11xzDeHh4dTU1PD8889z9913YxiGv72IiIiIiEhTDMNgeFocw9PiyCmu5vVluazJLeOy0WkYFhuhGedQu+Y1XFs/xzrmd1TWeah2egmpraFmy5eN7lf74wIAHHs3S/N5Glx3F21u8L09pov/2HTXUrXh3QYJXkt4PPETfk3MmJv3dbJYcRdv9Sdw9523EXviTUQOmHHAZ7bHppB641cUvH8bNVsX4CrYiGu/TfXC+5xRv2FdaNtKOTg69MK15weceStx/pTwBcCwEDf+dkJTh/tPeV211GxbAEDUkKZXJouIiMjRzzDb8pmr/Tz33HNcf/31GIaBaZr+5G9cXBylpfUbQewdwjAM/vvf/3LNNdcEOG35udraWjIzM8nIyCAsrHGdMZG9qqqq8Hq9WK1WIiMjD97hZ6qdHoqqnESE2LD89P93kaZYPE4MfJhY8O33EVqR9qZYk2BRrB0+pTUuIhxWrBYL3j1rqXhuPADRN32PEdcDANNTB/nLsVsNHDYrP9++zhaXiqNDLzy1pbjyVjc7liU8jtAuQwHwumqo2/4trqIsTHcdtvg0IvqdjdUe2qCPz+vBmb8G5651eKuLMKwOHEl9CE07EVtYbKue1V2xi+rNX+Ap30npgocw3bXEjruNpKkPN2hXl/c9vtoyAEK7j8disx/wvq6SHOryVuApzwOvG1tMKuG9TsEWmdigXfn3r7PnrauwhMXS/c7NbU5Ey9Eh0PcGIq2heJNgUay1TMBJ4bq6Ovr160dubi5Ak3W99iaMu3XrRmZmJqGhoY3aSGCUFJaWUlJYgkXJEwkWxZoEi2Lt8AqxWQi1W3F6vBS/dTm1G94hfOhl2M98osn2DpuFCIcVu9XiX7hytNhbn7h648fsenUmmF46nPUQ8eN/dcjH3fH4KJy71tHhjL8Rf/JvDul4cvgpcSLBpHiTYFGstUzA5SNCQ0N58803Of3006moqGjyBZdpmkRHRzN79mwlhEVEREREpNWcHl99YthmJfncx6gbfSMu08bebaxNE1bllDbqFx1mo3uHCDrFhGG1HF3J4Yh+Z9H58jm4CjaBCV5nNdaQiEM3oM9D4rRHAAhNGXmQxiIiInI0CzgpDDBq1Ci+/fZbbrvtNr7++utG10899VT+/e9/k5GR0R7DiYiIiIjIcajW7SXCYcMWnkBken0JCY/PpKjKyTlPfENhlavZvklRIVwxphuXjupKbLgjWFNuk5qaGkJCQupXOPWbAv2mBGVci81BePfxQRlLREREDq+Ay0f83K5du1izZg2lpaXExcUxZMgQOnXq1J5DSBNUPkJaSuUjJFj0MWsJFsWaBIti7chgsxg4bBb2vgzx+cDp8VJQ6eStFTt4e1Ue5bXuZvuH2a1cOCKFq8d1Jy3hEK66DcDe12thYWE4HEd2AluObvqItQST4k2CRbHWMu2eFJbDQ0lhaSklhSVYlDyRYFGsSbAo1o4OtW4vH63N57VlueSW1DTbzjDgtIxkrhufzvC0uCOq7rDezEqwKNYkmBRvEiyKtZZpl/IR+1u/fj3Lly+nsLAQh8PBHXfc0d5DiIiIiIiINCnMbuWCEanMGJ7C4s2FvLI0h+9zyxq1M0347Ic9fPbDHganxnLd+O6c0b8jNqsl+JMWERERCbJ2SwovWbKEW2+9lTVr1vjPJScnc8cddzBy5EiKioqIjo5m1apVWK3W9hpWRERERESkEYthcFKfJE7qk0RmfjmvLs3li8w9eJv4oOTaHWXc8vpqusSGcdXYbsw8IZWoUPthmLWIiIhIcLTLn8Hfe+89Jk2axJo1azBN0/+11wknnEB2djbr16/niy++aI8hRUREREREWiSjcwx/P28gH9w6lstOTCMypOm1MTvLarn/442MeeBr/j5vI/lltUGeqYiIiEhwBJwU3rVrF5dffjkuV/1Ov4ZhNKrHNWXKvt1yP/vss0CHFBERERERabVOMWHcfmpv5t02njsm96ZTTGiT7SqdHv676EfGPzyfX76xmvV55UGeqYiIiMihFXBS+NFHH6W6uhrDMDBNkx49evDzvetGjBjhP16xYkWgQ4qIiIiIiLRZZIiNWaPTeP+WsTx43kAGdI5usp3XZ/LB2nzOfuIbLnzmO77I3IPPp326RURE5OgXcE3hTz/91H/8xz/+kfvuuw+LxdJgtXBycjJhYWHU1taydevWQIcUEREREREJmM1i4bT+HZmckcyaHWW8ujSXBVkFNJX2Xb69hOXbS+jeIYKrx3Xn/GEphDkOvFfKxl0VvL4slx/yy6lxeQl3WOnfOYZLR3elb8emE9EiIiIiwWCYP1/W20oxMTFUVlZis9moqqrC4XD4k8LJycnk5+cDkJiYSHFxMQ6Hg7q6unaZvOxTW1tLZmYmGRkZhIWFHe7pyBGsqqoKr9eL1WolMjKy1f2rnR6KqpxEhNiw/KxUjMj+LB4nBj5MLPhsIYd7OnIMU6xJsCjWjg+5JTW8sTyX99fspM7ta7ZdXLidWaPTuOzENJKiGpahWLOjjPs/zmRldikABmDu9y/AiG5x3H1WBkNSYxvdO9DXayItpViTYFK8SbAo1lom4PIRe2sJh4WF4XA4mmxjmiZlZWUAWK0H/mu6iIiIiIjI4dI1Ppw7z+jLJ7dN4JaJPekQ2fR7nNIaN49/vZVxD87nt2+vJWt3JQBfb9rDhc98x6qfEsKwLxG8/2qcVdmlzHzmO77etOcQPYmIiIhI8wJOCickJAD1WfjNmzc32WbJkiV4vV4MwyAxMTHQIUVERERERA6pmDA7V4/rzse/HM9fp/WnV1LTK41cXh9vr8rj9H8v4twnv+H6l1fh9viaLEGxPxNweXzc9Or3rNlR1t7TFxERETmggJPCQ4YM8R9fddVVZGdnN7i+Y8cObr31Vv/3w4YNC3RIERERERGRoLBbLUwd3Jk3rx/N05cOY2zPhGbbrtlRjsdnHjQhvNfexPDfPs5sl7mKiIiItFTASeHp06f7j5cuXUqPHj383xcUFNC9e3fWrl3rP3feeecFOqSIiIiIiEhQGYbBqPQEHr94GG/fcCLnDumMwxrw2ylMYEV2KZt2VwQ+SREREZEWCvhVzKxZs+jVq5f/+7371pmmic/nw+er35zBMAz69u3LzJkzAx1SRERERETksOmRFMmfz+7Px78cx3Xj04kNtwd8z9eW5rbDzERERERaJuCkcEhICO+88w5JSUmYpolhGI2+TNMkMTGRt956C7s98BdMIiIiIiIih1tCZAg3ndyDeb8cT5fYsDbfxwAyd2mlsIiIiARP4J93AgYMGMCqVau48sorCQ8PxzRN/1d4eDhXXHEFK1eupH///u0xnIiIiIiIyBEj1G4lzGFtc38TqHZ62m9CIiIiIgdha68bde7cmeeff55nnnmGLVu2UFZWRmxsLD179sThcLTXMCIiIiIiIkeccIcVA1q8ydz+DCAipN3emomIiIgcVLu/8rDb7WRkZLT3bUVERERERI5YfTpGsS6vvE19TSCjU3T7TkhERETkANqlfISIiIiIiMjxbMawlID6XzgitZ1mIiIiInJw7Z4Urqys5Pbbbyc9PZ3Q0FCSkpKYOnUqX3zxRXsPJSIiIiIickTonRzFkNTYNvf/49z15BbXtN+ERERERA6g1UnhL774gvT0dNLT0xk0aBBut9t/zel0cvLJJ/PYY4+RnZ2Ny+WiqKiIefPmccYZZ/DII4+06+RFRERERESOFHdM7o3DZsFoQ991eeWc9dhi5q3f1e7zEhEREfm5VieFly5dSnZ2Njk5OYwYMQK73e6/9uSTT7J69WoADMNo8GWaJnfddRcbN25sv9mLiIiIiIgcIQZ0ieEf5w/Cbm3bBzIrnR5+8dr33PfJFpweXzvPTkRERGSfVr9aWbNmjf946tSpDa49++yzGMa+v4ubpun/AvB6vfzvf/9r41RFRERERESObON7JfLcFSMYul8pCeNn/wIMTY3l/nMGkBYf3uges1flc9lLa8lWOQkRERE5RGyt7bB582b/8ejRo/3H2dnZZGVl+VcFG4bB3XffzdChQ7n33ntZt24dAIsXL26HaYuIiIiIiByZBnSJ4X9XnsCWPZXM+T6PzbsrqXZ5iXBY6d0xivOHpdArOQqAk/sm8vd5mxqVjcgqqOaC51bxwHmDOHdol8PxGCIiInIMa3VSuLS0FIDQ0FA6d+7sP79kyRL/sWEYnHrqqfz1r38FIC0tjREjRmCaJtu2bQt0ziIiIiIiIke8XslR/P7MfgdsE+6wcd85/TmhWxwPfbKJuv3KRtS6ffxq9hqWbCvi3mkDCHNYD/WURURE5DjR6vIRZWVlAISHN/yY06pVqwD8pSLOPfdc/7Vhw4YREhICQGVlZVvmKSIiIiIickwyDINzhnTh1WtH0SMxotH1t1bmMe2Jb9i8R++lREREpH20Oins8XgAKC8v9yeAoX4Duv2deOKJDb6PiKh/cWO16q/bIiIiIiIiP5eeGMnL14xi+uCOja5tKahi2hPf8NaKHQ3eh4mIiIi0RauTwvHx8UD9pnFfffUVALt27WLFihX+TebCw8MZNGiQv4/X66WsrAzDMIiOjm6PeYuIiIiIiBxzwuxW/jKlNw9M6034z8pF1Ll9/O6dddw+ew1VTs9hmqGIiIgcC1qdFB4wYID/eNasWdxxxx1MmTIFj8fj32Bu7NixWCz7br1+/Xp8vvraWGlpae0wbRERERERkWPXlP5JvHHlUPr8tCHd/uauyWfa49/wQ375YZiZiIiIHAtanRTev1ZwQUEBjz76KGvXrvWvEga46KKLGvTZu6IYICMjow3TFBEREREROb6kJYTz4tUncOGI1EbXfiyqZvpTS3hlaY7KSYiIiEirtTopfPXVV9OjRw8AfyJ4/4Rw7969mTVrVoM+r7/+uv949OjRbZqoiIiIiIjI8SbEZuWuM/vyj/MHERlia3DN5fHxp7kbuPn176mocx+mGYqIiMjRqNVJ4dDQUD777DMGDBiAaZoNvnr06MHcuXOx2fa9WPnmm29YvXq1//vJkye3z8xFRERERESOE6f0S+b160bRv3PjPVrmrd/NWY8tZu2OsuBPTERERI5KtoM3aSw9PZ3Vq1ezcOFC1qxZg8vlol+/fpx55pnY7fYGbSMjI3njjTcAsNvtpKenBz5rERERERGR40xKXDjPX3kCj3+9hVeX5ja4tqOklvP/s4S7zuzH1WO7Nfg0p4iIiMjPtXqlsL+jxcLEiRO5/fbbufPOO5k2bVqjhDDAkCFDmDlzJjNnzuS8884LaLKtMWfOHG699VbGjx9PdHQ0hmE0Kmux15YtW3jooYeYNGkSqampOBwOkpOTOeecc5g/f/4Bx3nppZcYOXIkkZGRxMTEcPLJJ/PRRx81297r9fKvf/2LQYMGERYWRnx8PFOmTGHJkiUBPa+IiIiIiBz77FYLd0zuw79mDiEmrOH7L7fX5L6PMrnu5VWU1bgO0wxFRETkaNDmpPCR7v777+eJJ55gzZo1dOnS5YBt//SnP3HXXXexZ88epkyZwq9//WvGjh3Lxx9/zKRJk3jsscea7Peb3/yGK6+8kl27dnHdddcxa9Ys1q9fz9lnn80TTzzRqL1pmlx00UXccccduFwubrnlFqZPn86iRYuYMGEC77//frs8u4iIiIiIHNtO6p3IG9eNZkhqbKNrX27cw5RHF7MqpyT4ExMREZGjgmEeo1vVzp8/n5SUFHr27MnChQuZOHEil156Ka+++mqjti+++CKDBw9m6NChDc4vXLiQyZMnYxgG2dnZdOrUyX9tyZIljB07lh49erBixQri4uIAyM7OZvjw4VRXV7Np0ya6devm7/PGG29wySWXMGbMGL766itCQ0MBWLFiBePGjSMmJoZt27YRFRXV6uetra0lMzOTjIwMwsLCWt1fjh9VVVV4vV6sViuRkZGt7l/t9FBU5SQixIZFH0uUA7B4nBj4MLHgs4Uc7unIMUyxJsGiWJNgaU2sub0+/rNwGy98m93omtVi8JvT+nDDhHQsFr1uk8YCfW8g0hqKNwkWxVrLHLMrhSdOnEivXr1aVEvryiuvbJQQBjjppJM4+eSTcblcjco7/Oc//wHgj3/8oz8hDNCtWzduvvlmnE4nL7zwQoM+Tz/9NFC/inlvQhjghBNOYObMmRQWFjJnzpyWP6SIiIiIiBzX7FYLt07qxROXDCUuvGE5Ca/P5KFPN3HliysoqnIephmKiIjIkeiYTQq3l711km22hnvyff311wCcccYZjfqceeaZDdoA1NXVsWTJEsLDwxk/fnyL+oiIiIiIiLTEmB4dePP60YzoFtfo2qLNhUx5dDHfbSs+DDMTERGRI5Ht4E2OXzk5OXz11VeEh4czYcIE//nq6mp27txJZGRkg5ISe/Xq1QuAzZs3+89t27YNr9dLenp6owRzc32aU1BQQGFhYYNzPp8PgJqaGrxebwueTo5Xe+PD6/VSVVXV+v4+k0irD4vXi4E+higH4vP/a/FodZIcSoo1CRbFmgRL22ItOczgmZkDePbbXJ75Jof96wQWVDq59Lml3Dg+jRvGpWFVOQkh8PcGIq2heJNgOZ5jrTXlMpQUbobT6eTSSy/F6XTy8MMPNygRUV5eDkBMTEyTffeeLysrC6hPc5566inuvffeBufS09N566238Hq9SgpLi7U1VmwGgPnTl8iB1b/l9B2klUjgFGsSLIo1CZa2xJrNAjeNT2V41yj+8MFmCqtc/ms+E55alMOKnDIemNaHxEhHu85Xjm56HynBpHiTYFGsNU9J4SZ4vV4uu+wyvv32W2bOnMlvfvObwz2lBn7xi19wwQUXNDjn8/lwuVxYrVasVuthmpkcDfb/D2JbYsXrM/H4fFgMQyuF5SB8GOz904GqFcmhpFiTYFGsSbAEHmsnpMUz++ph/PHDLL7bXtrg2oqcci7832oeOKcvY3vEBzpZOYoF+t5ApDUUbxIsirWWUVL4Z7xeL7NmzeLtt9/mwgsv5NVXX220Wd3eVb17V//+3N7zsbGxAfVpTlJSEklJSQ3O1dbWkpmZSXh4OGFhYQe9hxy/At2Fs9rpoazKSUSIDUsLNnKU41f9x1190IKd00UCoViTYFGsSbC0V6zFxoTw+KXDeWlJNk/N34bX3Pcpr5IaNze+uZ5fnNyD20/tjc2qP3QcjwJ9byDSGoo3CRbFWssE/Jv/6quv9n+tX7++PeZ02Ljdbi6++GLefPNNLrnkEl5//fUm6/9GRETQpUsXqqqq2LVrV6PrW7ZsAaB3797+cz169MBqtfLjjz/i8Xha1EdERERERCQQFsPgqrHdefaKESRHN0wwmyY8OX8bF/13KflltYdphiIiInI4BJwUfvnll3nppZd4+eWXSU9Pb485HRYul4sLLriAt99+m8svv5xXXnnlgEvMJ02aBMCnn37a6Nonn3zSoA1AaGgoY8aMoaamhsWLF7eoj4iIiIiISHsYkhrLG9eNZkKvDo2urcwpZcpji/lq457DMDMRERE5HAJOCiclJWGaJjExMURERLTHnILO6XQyffp03n//fa655hpeeOEFLJYD/2huvPFGAP72t79RWrqvRld2djZPPvkkISEhXHXVVQ363HTTTQDcfffd1NXV+c+vWLGC2bNnk5iYyIwZM9rrsURERERERPxiwx38a+YQ7pjcG5ulYRmwsho317y0kvs/ysTl0UaKIiIix7qAawqffPLJvPnmm1RUVFBeXu6vnXu4zZ07l7lz5wKwe/duAL777juuvPJKADp06MD//d//AfUJ3nnz5tGhQwe6dOnCX//610b3O/nkkzn55JP9348ZM4Y77riDRx55hEGDBnH++efjcrmYPXs2JSUlPP7443Tr1q3BPS666CLeffdd5syZw9ChQzn77LMpLi5m9uzZeL1enn32WaKjo9v9ZyEiIiIiIgJgGAazRqcxJDWW37+7np0/Kxvx3DfbWZFTyhMXDyU1PvwwzVJEREQONcM099ttoA02btzIsGHDcLlc3HTTTTzxxBPtNbeA3HPPPdx7773NXk9LSyM7OxuoT/guXLjwgPf7y1/+wj333NPo/IsvvsiTTz5JZmYmFouFYcOG8dvf/papU6c2eR+Px8Pjjz/O888/z9atWwkNDeXEE0/k7rvvZsyYMS1+vp/bu9FcRkaGNpqTA2qPjeaKtNGctIDF48TAh6kNmeQQU6xJsCjWJFiCFWuVdW7u+yiTLzcWNLoWFWrj4RmDOHNgp0M2vhx+2oxJgknxJsGiWGuZgJPCixYt4rPPPuOBBx7AMAwGDx7MVVddRXp6OlFRUU32mTBhQiBDShOUFJaWUlJYgkXJEwkWxZoEi2JNgiWYsWaaJnNW5fHPzzfj8jYuG3H5iWn8YUo/Qu3N77ciRy8lTiSYFG8SLIq1lgk4KWyxWDB+SgztvZVxgESRYRh4PJ5AhpQmKCksLaWksASLkicSLIo1CRbFmgTL4Yi1rN2V3PnOOnJLahpd6985micuGUb3DkfnHjLSPCVOJJgUbxIsirWWCXijuf0ZhoFhGJimecAvEREREREROXL06RjFa9eO4swBHRtd+yG/gqmPLeb9NTsPw8xERETkUGjXpPBee5PDP/8SERERERGRI1NEiI37zx3An8/OINTW8K1itcvLbW+u4a531lHr8h6mGYqIiEh7sQV6g65duyrhKyIiIiIicgwwDINzh3RhYOcY7nxnHT8WVTe4/uaKHXyfW8qTlwyjV3LTe8iIiIjIkS/gpHB2dnY7TENERERERESOFD2SInnlmlE8/Nkm3l+T3+Da5j1VTHviW/56Tn/OH56iRUIiIiJHoUNSPkJERERERESObmEOK385uz/3nTOAMLu1wbVat5ffzlnHr99aS7VTG4mLiIgcbZQUFhERERERkWadNagTr107it7JjXdwf3f1Ts5+4hsy8ysOw8xERESkrdo1KfzBBx8wY8YMUlNTCQ0NpUuXLgC8+uqrvPzyy7z77rvtOZyIiIiIiIgEQbcOEbx09UguGJ7S6NqPhdWc+9S3vLYsB9M0D8PsREREpLUCrikMUFlZycUXX8wnn3wC4H8hsPff5557jsWLF2MYBtu3byc1NbU9hhUREREREZEgCbFZ+f2UfozoFs99H2VStV/ZCJfHxx/f28CSbcU8cN5AokPth3GmIiIicjDtslJ45syZzJs3z58E/vlGA9OnT8c0TUzTZO7cue0xpIiIiIiIiBwGkzOSef26UWR0im507eN1u5j62DesyysL/sRERESkxQJOCr/77rt8+umnGIaBYRhNflxo4sSJ/uMFCxYEOqSIiIiIiIgcRilx4Tx/5QlcMqpro2u5JTXMeHoJL3y7XeUkREREjlABJ4Vffvll/3F6ejqvvvpqo1/8ffv2xWKpH+qHH34IdEgRERERERE5zBw2C785rQ//unAw0aENKxO6vSb3fpjJ9a+soqzGdZhmKCIiIs0JOCm8YsUK//E777zDJZdcAjQsIeFwOIiOjsY0TfLz8wMdUkRERERERI4QJ/VJ4o3rRzMoJabRtS8y93DWY9+wKqf0MMxMREREmhNwUrioqAiAqKgoBg0a1Gw7r9cLQF1dXaBDioiIiIiIyBGkU0wYz14+givHdGt0bWdZLRc+8x3/WbgNn0/lJERERI4EASeFw8PDAaipqcHtdjfZpqioiMrKSqA+eSwiIiIiIiLHFrvVwi9P6cXjFw8lNtze4JrXZ/LgJ5u4+qUVFFc5D9MMRUREZK+Ak8JpaWlA/UrgZ599tsk2zzzzDFBfUqJHjx6BDikiIiIiIiJHqLE9OzD7+tEMT4trdG1BViFTHlvMsh+LD8PMREREZK+Ak8ITJkwAwDRNbrvtNq666ir/tZqaGq677jr+/Oc/N2ovIiIiIiIix6bEqFCenjWM68anY/zs2p4KJxc/u5THv9qCV+UkDiubzdZgPyARETl+GKZpBvRbODMzk4EDBwL1iWHDMNh7y72/XPZ+b7Va2bBhA3369AlkSGlCbW0tmZmZZGRkEBYWdrinI0ewqqoqvF4vVquVyMjIVvevdnooqnISEWLDoheQcgAWjxMDHyYWfLaQwz0dOYYp1iRYFGsSLMdarC3fXsLdc9dTVOVqdG1szwT+NXMISVGhh2Fm4vP5ME0Tl8ul95FyyAX6XlSkpRRrLRPwSuGMjAzuvPNOf0IY6pPB+/+1ce/xXXfdpYSwiIiIiIjIcWRk93jeuG40o9PjG137dmsxUx5dzDdbitptPJ/Xi8/rafjl87Wor7ssj9odK3Hu2oDXvW+T9Eb3a+6rheMceP777tfqvj4fzsIs6vK+x1tX0XQbjwvnnkzcpbn+9/EhIfv++OAqzaE2+7sGzy8iIsceW3vc5O9//ztWq5WHHnoIj6fxLy6bzcbvfvc77rvvvvYYTkRERERERI4iCZEhPHHJMF74NpunF2xl/6oRRVUuLnt+GTef3JNfndoLmzWwtUuFH95O+dJnGp40LNjjuxPR90ziT/kDtvAE/yWfx03Zd09Rufp1nPlr9nWxhRDe+3Q6Xvg/ch4dgac056Bjp944n7BuY1o955qt8yn95lHqdq7GW7kbgJAuw0i79bsW36Nyw1yKv/grrj0/1M/fEUn0sEvpcObfsIbUb/hem7OU/NcuxluRD0BY+gQ6zZqDJbT+utddx85nz8AamUjKjQta/RwiInL0aJekMMB9993HVVddxezZs1m9ejVlZWXExsYyZMgQZs6cqQ3mREREREREjmMWw+Cacd0Z2jWWP7y7noJKp/+aacIT87eyfHsJj148hE4x7VzKwPThLt5G2bdPULt9Mam3LMViseDzuNj54jRqt873N7VGd8YwDDzlO6nO/ABvbWn7zqUJdXkrqd70CRgWwABaV+WxOusLdr12MZg+LOHx2KI749q9gfKlz+Apy6XT5e9isVjY885N+GpK6HrbSmo2f0HRJ7+ndOHDJJxev4CrbOE/cZfm0OnS17FYAv5gsYiIHMHaLSkMkJ6ezu9///v2vKWIiIiIiIgcQ4Z1jeON60fzlw9+aFQ2Ynl2CVMeXcwjFw5hYt+kgMfqdPkcwnuegrtoK7tevwR30Rac+Wup3fIVEX0mU7bkSX9C2JHYl+QLniWs60gA3OX5lH37OIbFRur1X2L6vADU7VjO7jcvByBy4Aw6nPE3/3jW6E5tmmd478mkpIwgJGU42Y8M9q/kbamS+Q+C6cMIiSLttlXYYzqze84NVKx8kepNn+DatRZ7Yh9cBZmEdBlOaKeBWMPiKPrk99TlrQLAVZJNycJ/EDv6ekK7DG3Tc4iIyNEj4KTwli1bKC4uJiEhgV69erXHnEREREREROQYFhfu4N8zh/Da0hwe/3ornv3qSZTWuLnqxRVcPyGd32tle80AAMHBSURBVJ7eB3sA5SQs1hCsjnCsnQcRmTGN0kX/BMBZ8ANhvU6hYuVL/rYdL36J0M5D/N/bYzqTOOWBRvf0lOfuu39IFI6E7g2ue1011GR9dtC5haaNxv5TEnn/cVvLW1dBbe4yAMLSTsQe0xmAqIHnU7HyRQCqsz4lruMgDHsYvtoSfD4f3pr6hLw1LBaAwg/vwBISTfxp97R5LiIicvRoc1L46aef5v7772f37t3+cx07duRPf/oTN954Y7tMTkRERERERI5NFsPgshO7MaRrHL9/dx35ZQ03Nvvvoh9Zvr2Exy8eSmp8eEBjeWqKqdn6tf97e3x3PGU7cBVsrP8+oUdAidn9easK2fXaRQdt1+mKd7FHnxXweM78NeBzA2CL7uw/b4vt4j+uy/sei9VK1NBLqFj+P/bMvhJX0RYAokZcQfWmeVRv/JjkC/6H7acksYiIHNvalBT+4x//yIMPPohpNqxztGvXLm6++Wby8vK4//7722WCIiIiIiIicuwa2CWGN64bzb0fZvL1poIG19bsKOOsxxbz8PmDOWNAx1bfe9frl4LVhq+2DEwfALb4bkT0mYJrzwZ/O1tU28o+NMUaHkvi1H8ctF1Icv92Gc/nqvYfG/bQ/Y4j/MemqwqApGmP4ujQi5ptC7AnpJMw+S+EpU8g599DCe02lqghF1O65Cmq1r+H6XMT0fs04ib8Gos9pF3mKiIiR45WJ4XXrFnDQw89BIBhGI2um6bJgw8+yPnnn8+QIUMCnqCIiIiIiIgc26JC7fzj/EG8tTKPR77Iwu3dtwCpos7Dja+u4sox3fj9lL6E2Kwtvq/PWeE/toREE97rFDqc+QAWmx1rRAf/NXd5Hj6fr102V7OGxhA37pcB36elLCFR/mPTVbPv2FnZqI3FZid+wu3ET7gdAJ/PR8mXf8VTlkfny+ZQtuQJij7+HRF9p2AJi6P4i3vx1hSTdPY/g/Q0IiISLK1OCj/77LP4fD5/Qnj/1cL7n3v22Wd58skn22maIiIiIiIiciwzDIOZJ6QyOCWGO99dx46S2gbXX1ySzcqcEp64eBjdOkQ0c5eGkmc8Q1j3cRhWB9aojlhsDv81e2wqIZ2H4Mxfg6c0G+eO5YSljQ74OVwlOWT/38FXAXe+7C0i+00JeLyQLsMwbCGYHifu8h375lGW4z8OTR3ZZF93yXZKFz1C7OgbCe00kD3v1JeCTJ75PBZHFNUbP6Jy3RwlhUVEjkGt/jPot99+i2EYmKZJfHw8jzzyCB9//DEPP/wwcXFx/mvffPPNoZiviIiIiIiIHMP6dormtWtHc3r/5EbXNuysYOrj3/DB2vwW3csW3RlHh57Y47o2SAjvFX3Clf7jXW9cRuXGj/F5vfh8Ppy7NrB7zg24y3Y06ncghtVOaJehB/2y7le71+f14HM78bmdsHfhlenzn/N5vQA4d//Atvu6sO2+LpQs+hcAVkc4od3GAFCXswxX8XZ8Ph+Vq1/33z+i75lNzrXwwzuwhMURP/nP9UP+VIrCYo/AYrVh2EMx3bVN9hURkaNbq1cK5+TkYJomhmHw9ttvc/LJJwNw5plnMmTIEE477TR/OxEREREREZHWigyx8ffpAxnZPZ6HP83C6fH5r1U5PfzyjdV8t62Yv5ydQai95eUkfi5m5PXUbltI1Yb38JTlsuul8zDs9Zvame76Ugzxp/yhVfe0x3Sm682LW9WnYuWLFLx3c4Nzzvw1bP1TNACdr3iPyH5TMH1evNVF9fPbr1REwil3k/fjN5juGnL+PRRreAKe8jwAIgdfSEjHxiuXK394n5qsT0m+8EV/eYnQtBNxFWyk7LunsMV0wVu5h/A+p7fqWURE5OjQ6qRwRUV9TaawsDB/QnivU089ldDQUOrq6qiqqmqXCYqIiIiIiMjxxzAMpg9NYUDnGO56dz3bi6obXH9jeS6rc0t54pKh9EzaV1fX4ojAEhZXfw/Lgd/yWqxWOl7yOpWrX6dy9WvUbFvoTwZbIzoQ0e9srOEdGvQxLHb//S2O8ICfE8Cwhfrv2eR1q+Onsa37ns0e5r8e3n0cKdd8RPGXf6N2+yI85XlYI5OIGXkt8RPvanQ/r6uWwo9+S1j3CUQOvtB/vsMZ9+Epy6Ho4zsBCEkZQdK0R9vlGUVE5MhimPsXBW4Bi8WCYRgkJyeTn9/4IzudOnViz549GIaB96ePuMihV1tbS2ZmJhkZGYSFhR28gxy3qqqq8Hq9WK1WIiMjW92/2umhqMpJRIgNSxObTYrsZfE4MfBhYsFn047Vcugo1iRYFGsSLIq1xmpdXh78dBMfNlE2Isxu5b5zB3D+8JSAx/E6q/FWF2HYHFgjk9tl47lg89QUYzqrsUZ1wmKzN9nG66qpTxxHJGIJjQFo8KzeunJMnwdbeEJQ5izHh0Dfi4q0lGKtZVq9UlhEREREREQkmMIcVu6d1p8T0uJ44JNN1Lr3LUCqdXv5zdtrqXN7uWRU14AWLlhDIrCGtGwTuyOVLTwBDpLMtTrCsSb2xuerL8vhcrkIDQ3dd/2nRLGIiBy72pwULi8v5+qrr27y/F5NXTcMg//9739tHVZERERERESOU1MHd6Z/lxjufGcdWwsaliy8e+4GPv9hNw/OGETnWH16siU8Hg8ul+twT0NERA6DNpePOJC9t/x5u70b1KmsRPtT+QhpKZWPkGDRR18lWBRrEiyKNQkWxdrB1bm9/PPzLN75fmejayE2C389pz8Xjkg96HvX493e9wY2m42IiKN7hbQc+fSRfgkWxVrLBFQgyTTNRl9Qnww2DKPReREREREREZFAhdqt/PGsDB44byARDmuDa26vD4fNSkWtB5/eix5QeHg44eHhWlgkInIcanNSuLlEb3OJYCWGRUREREREpD2d3r8jr103mn6dovznpg7qzJgeCdR5vJSUFuOsKsHndh7GWR7ZrNb6pLrP68VTW4qnthSfPt0rInLMa3VN4QkTJugjOCIiIiIiInJE6BofzgtXjuTRrzbzzqqd3HBSev2F8hxK/nMCJV4XybesJLpLfwzDwOf1UrX+HarWz8Fdloc1sgPRQ2cROfA8LNaGb5G9rhoqVr1C1bq38TmrcCRnEDf2FkJThvnb+DwuSuY/hDN/DZ6KfACskYmEpo4kZuQ12KM7teg53OX5VK5+nerNn+OrK8MSEk14r1OIHnop9riuDdoWz38IV8GmBucMWwghnYcS2e8s7LEpDa7V/LiIitVv4MxfCz43lrB4HB16Etp9PFGDL/S32/HEONzFW0ma/iSxo65t0bxFROTo1OqawnJkUk1haSnVFJZgUT1ECRbFmgSLYk2CRbHWdpt3V5KeFIFpguvDa6ld/zahfacSct5rhNgsRIXY/p+9+46Pqkr/OP65d1omPSEJhN7BIB0URFGxYW/Y1t7dtffV9eeq67rq6q679t6wrb3j6qLSBSkKhN47pGcmk2n3/v4YGBgTICEhoXzfrxfLzT3n3PPM7BGYJyfPYcPb5+Kb+2mNsd7Oh9Pmsi8xnS4AIlUlrH5uBKGN82r0zT35cbKGXQdAtLqCJffl1hqPI7UlHW79Fac3c4dxl/30Ehs/vQmscM1Gw0HOCX8j+7Ab47dWPX8MgWXjan2W4fTQ8swXSO9/LgDl00ez4f3La+3rzGhHxzsXArHzg8p+eomNH1+LI60VHW+fj8Otz5bSeFTnVZqK1lrdNKimsIiIiIiIiMieYkCHLLKS3TirNhCY+zEA7j6/AyAYsSia/794QjjzkGvp8pdy8k57EoDA0h8pn/Jc/Fkl3/0lnhDOGflX2v1hPJ7W/QAo+upuwmWrYh1NJ1mH3USby76iw62zaXvlN3ha9wUg6ttA5ax3dhhz1bIJbPzkerDCGK5kso+8izaXfkH2UfdguFPBjlL05R34F35X6/jsEXeRM/JBUvucBYAdCbLpy9vjJTNKxv4NAEdaPnlnPkeby76k1TmvkTH0Gpy/2cWc1u8cDJeXaOV6fL+8t5N3W0RE9mZKCouIiIiIiMg+wWEaOAwDe957YEUwXMnQ6Zh4e3j+Z/HrjIOvxOFKIv2gKzAcsR3Zvrmxdsuy8BV+AYArpzvZR9yGt/1BZB15BwB2NIhv3lexOd3J5J74CCndj8KT253kLkeQPuDCbaLa8cfu8p9eBNsCIPekv5Nz3H2k9DiGnGP+j7xT/7VNvxdqHZ9x8FVkH3E7rX83mqSOwwCI+jZSveonrEiYcPFiAFK6H0vm4EtJ6X406f3Po+Wp/6LNNT8kvn+eNJK7HAlAxYzRO4xbRET2bkoKi4iIiIiIyF7PaRpsKW5WvfRHANz5fTCd7q2doqH4ZaWvkmAkih0NYVsRAAIrp2BFwkRKlxMpWxl7Rsue8TFJ+X3i14ElPyTMH9y0gKqlP1I+fTRlk56OxZTZjrS+o7YbsxUJx5PPhjOJ9IEXJbSn9T0H05MOgH/BGKKhwPafZVnY4er414bpxHS6cGa0AWJJ3jWvn0nJuCcIrJyGFY3Wel5QUvuDAKheNXWH84mIyN6t3gfNiYiIiIiIiOxptj3vIrQpVifX3aILWcluKqsjhKMWji5Hw4zXAKj64S9YQ2/Cmv8x2NHYwGgIK1QRPzAOiCdlY9cZ8euIb0PC/MX/vR/f7A/jXzvSWpH/u3dwJrfYbszRqiLskA8AZ3p+YgIbNid12xLaWIgdCRL1b8Th7pDQp2TswxiuJILrfiW4ZnrsWRlt8LSLJXdbHPsAGz64Cuwo/nlf4J/3RTy+FsfeXyMR7crpCsTKUESKl+DIP3C78YuIyN5LSWERERERERHZ62276TUaKAXATErHYRhkeF1UhSL4u5xAUrdjqF70LdWL/kv1ov/WfI7Ti2Fu81HZisYv7W0OgkvoAyR3ORzD6SFSvpbA8glEK9ez+sVjaXfVdyS1G1h7zA7X1mdHazlkDrAjW3f/mp60Gu3lPz2f8LWZlEHe6U9jOmLxZQy8AE/LAsqmvkTVov8RKV0OQLRyPRs/vBpnVkeSOw+Pj3d4MuPX0aqiWmMSEZG9n5LCIiIiIiIistez7a3XpjuFaLASO1QFgAGkuJ24HCYVo97DveQbIovHYEdDONocRGj2e4RWTcHVogsOdzKuFl02j7LjCWaAaFVJ/NqV3Slh/swhV5M55GoAKn59n/VvX4AdrqJ00lPkn/NqrTGb3mwc6a2JVqwlUrmeSFVxws7iSKCUcPnqzX0zMZMyazwj46ArMNwpmM4kPG36k9ztKBxJ6Ql9ktoOoFXbZwAIl62i+H9/pWJaLKaqBWMSksJW2L81Pk/ic0REZN+hmsIiIiIiIiKy17O2yQq7smIlFrYkVLdwO0yyU724e5yEa+S/cZ/4HGb7wwitnRlr73ESoUgUZ2ountZ9AQiumYEVie3iDSyfEH9WcvfYAXbRoJ/fcqW3jV9Hq4q3G7NpmqT1OWvzC4hQ+v3fE9pLv380Xgc5rfcoTLPmR/jso/5E3kmPkjPyAdJ6n14jIVw25QWiwcqtsWW2I2PgxfGv7W3qLAPxWspg4MzuuN3YRURk76adwiIiIiIiIrLXi1pbk8JJHYZRvfIngmtnYdt2woFq60ePIqntYBzpbQkVL6Nq2osQDWJ40nD2v5zSqjApbpv0ARewae0sor6NrH3zTLztDqZ04pNArB5vSo/jACj534MElo7H2+UInOmtiFSsp2LG6Ph8qQecuMO4M4ddS8WMN7GqSigd/08CKyaT1G4w1at/pnrF5M3z5ZN91N279L5s+vpuNn15B95Oh+LO6YYdjeAr/DzentIzMb7qVT8D4G5ZgDM5e5fmFBGRPZ+SwiIiIiIiIrLXs4GobeMwDFL7nUPZ+H9gVRVTveonvO2HxPsFV0+nat6XCWOd2Z1IPulZyIjtMPaHIjj7XUn6hkIqfn6NqgXfULXgGyCWoG19/js4tqnvW716GtWrp9WIKbXPWaQPunSHcbuzOtD2im/Y8NHvCa7+meqVU6heOSXe7mkzkFZnv4Qro0293xMAZ0ou4ZKlVC38lqqF3ya0pfX7Hd4uR8S/tiJhqhaPjbX1PWuX5hMRkb2DksIiIiIiIiKyTwhFLLwuB0n5fUnqcAjVKybhm/lWQlI4/6KPqF4xkUj5WgxnEp4OQ4i0PYKwFWtftMFHfmYSqR4njmOfoPWhtxCc+wFW0Ie7ZS/S+ozCdLrjz8s++v/wdj6c0Po5RP2bwHTizumGt/Nw3C061ynupNZ96HDdRIKbFuCf9zWRirWUT34OOxokpfuxeFoWJPRvcdTdRHxXAGB6s3b47A63ziG07heqV/9MuGwVRMM4M9qQ3P1oXDk9Evr6F/2XqH8ThstL+qDL6hS7iIjsnQzb3rYc/66xrNjfnoZhxH8sx+/3c//99/Pdd98RDocZNmwYDzzwAHl5eQ2dTmoRCAQoLCykoKAAr9fb3OHIHszn8xGNRnE4HKSmptZ7vD8YocgXJMXjxNz2iGeR3zAjQQwsbEwsp6e5w5F9mNaaNBWtNWkqWmu7zgDSvS4MILBiImuePwrDlUyHOxbgTMnd7jgbCISjvDVlBX//ZgE9WqXx8Bl9yEuPvf/JbgepHmdCGYrdrWLWf1j/7kWATd5pT5I55KpGn2PLZ3mI1Tde9fwxBJaNI+vw28g9/q+NPp/s3xr6WVSkrrTW6qbBO4XffvttLrzwQgCOPPJIvvvuOwDOOussvvkm9uM1tm1TWFjIuHHjmD59upKWIiIiIiIi0uhsIBiJkuR04O0wjPxLP8cO+bEjwXifiGXjMA22pHct2yYctYlELXq0SiM3zcPctRWMem4SJ/bJ55S+remal0o4apOW5MTlaJrz2tP7nQ3YBNf+QqRsNdHqihqHyDVUKBTCMAxcLhdWJEzmsGvJHHYtyV1HNOo8IiKy52lwUvinn36KF+4/4YQTAJg9ezZjxoyJfxfVMAxs22bBggW89NJLXH/99Q2dVkRERERERKSG6rCF22FiGgYp3Y5JbItEqQ5b2xkJfdpm8s6VQ7j/87l8v2ATH81Yw0cz1gDgNA1SPE7+PqoPx/ZqtVtfwxbp/c6BfufstudHIhEAXC4XptNF2oGn7ba5RERkz9Lgb3FOm7a1mP5xx8VOXx0zZkz8nm3bbFuh4vPPt55yKiIiIiIiItLYKoMRghGLiGUTtWwilk0gvOOE8BbpXhePndWXO47rgcuxtVxExLIpD4S56s3p3P/5XIKR6O58CU0mGo0SDAZ33lFERPYpDU4Kr1kT+66pw+GgZ8+eAMycORMAp9NJYWEhL7/8MhBLEM+dO7ehU4qIiIiIiIhsl23HagT7ghEqgxF8m5PEdWUYBuce1J5XLz2Itlk1yx++OnE5o56dzIpif2OG3Wyi0X0jwS0iInXX4KRwcXExABkZGTgcDgAWLFgAQP/+/enZsycXXXQRbnfsdNaSkpKGTikiIiIiIiKy2xXkp/P2lUM4tqBljbbZa8o58d8T+OLXtc0QmYiISMM0OCkcDocBEn7cZOHChRiGQffu3YHYLuL09FhB/KY8rVVERERERESkIVI9Tv52Rm/+dOIBeJyJH6F9wQjXvT2TP308m+qwdtuKiMjeo8FJ4YyMDAD8fj/Tpk1j6tSp+P2xH6Hp0qVLvJ/f78cwDFq0aNHQKUVERERERESajGEYnDmgLa9fdhAdWyTXaH/rp5Wc9vRElmzyNUN0IiIi9dfgpHCPHj3i18OHD+fII4+Mfz1w4EAANm3aRCAQACA3N7ehU4qIiIiIiIg0ue4t0xh9xcGc1Ce/Rtv89ZWc/OQEPpqxuhkiExERqZ8GJ4WPP/74+HUwGIwnf1NSUhgxYgQAP//8c7xPv379GjqliIiIiIiISLNIdjt54NQDuf+UXiS5Ej9SV4Wi3PKfX7jt/V+oCkWaKUIREZGda3BS+Nprr6Vjx47Ytp1w/+677yY5OfZjNV999VX8/qGHHtrQKUVERERERESa1cl9WzP68oPpmptao+2D6as55amJLFhf2QyRiYiI7JyzoQ/IyMjgp59+4rHHHuPXX38lNTWVM844g/POOy/ep02bNtx6660AjBw5sqFTioiIiIiIiDS7zrmpvHH5Qfz9mwV8PHNNQtvijT5OeWoC95/Si3MGt8MwDOatq+Dtn1Yyd205VaEoyW4HvVpncP6Q9vRsld5Mr0JERPZHhv3bLb6yVwoEAhQWFlJQUIDX623ucGQP5vP5iEajOBwOUlNr7mrYGX8wQpEvSIrHiWkYuyFC2VeYkSAGFjYmltPT3OHIPkxrTZqK1po0Fa21vdOYOet48Mt5VIWiNdqGd8vBF4wwY2UZAAZgb/M7wKCOWdxzYgH92mU2TcA0/LOBSH1ovUlT0VqrmwaXjxARERERERHZ3408MJ+3rziYnq3SarSNW1QUTwjD1kTwtju0pi8v5ZznJzN2/obdGqeIiAg0clL4l19+4dZbb+Wwww6jZ8+eDBkyBIDx48czbty4hAPnRERERERERPYl7Vuk8NqlB3Hu4Hb1HmsDoYjF70fPYNaqskaPTUREZFsNrikMEIlEuOGGG3j++efj92zbplWrVgDcfPPNzJw5E6fTyerVq8nNzW2MaUVERERERET2KG6nyR0jezKwQxZ3fvgrVj0KNm5JDP/1y0Lev+aQ3RajiIhIo+wUvuqqq3j++efZUp74t2WKR40ahW3bRCIRPv3008aYUkRERERERGSP1S47uV4J4S1sYNryUuavr2j0mERERLZocFJ47NixvPbaawAYhoFt2xi/OXzq6KOPTugvIiIiIiIisi/7cMbqBo1/a8rKRopERESkpgYnhV944YX4dVZWFg8++GCNncK9evWKJ4pnz57d0ClFRERERERE9mgL1ldi7LxbrQygcJ12CouIyO7T4KTw5MmT49cff/wxd999N0DCbmGv10taWhq2bbNq1aqGTikiIiIiIiKyR6sKRdmF6hFArISEPxhpzHBEREQSNDgpvHHjRgBSUlI47LDDtj+RGZuqqqqqoVOKiIiIiIiI7NGS3Y4G7RRO8TTKufAiIiK1anBS2O12AxAKhWqUjdiisrKSsrIyIJY8FhEREREREdmX9WiV1qCdwge0SmvMcERERBI0OCncpk0bAMLhMB988EGtfd566y0gVlKiffv2DZ1SREREREREZI925oC2DRq/ZJOPyupwI0UjIiKSqMFJ4WHDhgFg2zaXXnop999/f7wtGAzy17/+lZtvvrlGfxEREREREZF9VfeWafRrl7nL4ycvLeHUpyayaENl4wUlIiKyWYOTwpdffjkQ2wVcVVXFAw88AMSSxGVlZdx7770Eg8F4/8suu6yhU4qIiIiIiIjs8W45pjtup7nLtYWXFvk59emJfPnrukaNS0REpMFJ4SFDhnDxxRdj2zaGYcR/N4zYX3vbfn3ppZcyaNCgBgctIiIiIiIisqc7sE0Gfx/VB5ejbh+9XaZBituRcK8qFOXat2fw0FfziESt3RGmiIjshxqcFAZ44YUXOP/88+MHzdX2+3nnncezzz7bGNOJiIiIiIiI7BUO65bLSxcPov82pSSM3/wO0L9dJi9fMpj3rh7KAfk1D5l7YdxSLnx5KkW+YI02ERGR+jLsLZnbRjB+/HhGjx7NzJkzKSsrIzMzk379+nH++edz+OGHN9Y0UotAIEBhYSEFBQV4vd7mDkf2YD6fj2g0isPhIDU1td7j/cEIRb4gKR4nprGrPwgn+wMzEsTAwsbEcnqaOxzZh2mtSVPRWpOmorW271q0oZIPZqxm4fpK/KEoKW4H3VulMWpAW7q13JoIDkaiPPz1fD6dtbbGM/Izknjm/AH0b5/V4Hga+tlApD603qSpaK3VTaMmhaX5KCksdaWksDQVfaCVpqK1Jk1Fa02aitaaQOwnbj+auYZHx8wnHE382O52mNx3Si/OO6hdvHTjrlDiRJqS1ps0Fa21ummU8hEiIiIiIiIi0ngMw+DMAW156eLB5KUlfnMgFLW4++PZ3Pnhr1SHo80UoYiI7M2c9em8cuVKABwOB23atEm4Vx/t27ev9xgRERERERGR/U3vNhm8feUQ/vjhr/y8ojSh7T8/r2b++kqeOX8AbbOSmylCERHZG9UrKdyxY0cMw6BVq1asWbMm4V5dGYZBJBKpX5QiIiIiIiIi+6nsFDfPXDCAJ8cu5s3JKxLafl1dzslPTuDJ8wZwaLecZopQRET2NvUuH2HbNr8tQ7zlXl1/iYiIiIiIiEjdOU2Tm4/uzsNn9MbrciS0lVaFueiVn3jmh8X6zC0iInVS76RwbbuCDcOo0y8RERERERER2XXH9mrFG5cdRIfsxHIRlg2PjlnANaOnU1kdbqboRERkb7FLO4Vru6cdwiIiIiIiIiK7X5e8VN64/CCO6J5bo+2buRs49emJLN5Y2QyRiYjI3qJeSWHLsrAsi7Vr19a4V9df0ahORhURERERERFpiLQkF4+d3Zdrj+zKb38ud+kmP6c+NZGvZ69rlthERGTPV++dwiIiIiIiIiLS/EzD4PJDO/Hk7/qT4XUltPlDUX7/1gz+9vU8IlGrmSIUEZE9VYOTwp07d47/mjp1amPEJCIiIiIiIiJ1dEiXHN664mB6tkqr0fb8j0u56JWpFPuCzRCZiIjsqRqcFF67di3Lly9nzZo1DBo0qDFiEhEREREREZF6aJ3p5ZVLBnNy39Y12iYtKebkJyfwy6qypg9MRET2SA1OCrdr1w6A1NRUTHPvr0bx5Zdfcuyxx9K2bVu8Xi+dO3fmrLPOYvLkybX2nzRpEieccALZ2dl4vV769OnDE088scPayV988QVHHHEEGRkZpKamcvDBB/P666/vrpckIiIiIiIi+4Ekl4P7Ti7g7hN64jQTKw2vLa/mrOcm8+7Ulc0UnYiI7EkanMU95ZRTACgrK2Pp0qUNDqg53XnnnZx00knMmDGDkSNHcuONNzJgwAA+/fRThg0bxujRoxP6f/rppwwfPpxx48Zx+umnc9111xEKhbj55ps599xza53jqaee4uSTT2bOnDlccMEFXHnllaxdu5ZLLrmE2267rSlepoiIiIiIiOyjDMNg1MB2vHTxIHLTPAltoajFHz+azV0f/UowokPgRUT2Z4Zt23ZDHlBaWkr//v1ZtWoVhx12GO+99x4tW7ZsrPiazPr162nTpg25ubn8+uuv5OXlxdu+//57RowYQadOneKJ74qKCrp27Up5eTkTJ06Ml86orq5mxIgRTJ48mXfeeSchObx8+XJ69uxJSkoK06dPp2PHjkDsPRw8eDBLlixh0qRJDB06tN7xBwIBCgsLKSgowOv1NuCdkH2dz+cjGo3icDhITU2t93h/MEKRL0iKx4lp/PacY5GtzEgQAwsbE8vp2fkAkV2ktSZNRWtNmorWmjSWYl+QP340m+krSmu09W2bwWOn9yQv1bXLnw1E6qOhn0VF6kprrW6cDX3Ak08+ydFHH80rr7zC+PHj6dy5MyNHjqRz586kpdUscg9w7733NnTaRrdixQosy+Lggw9OSAgDHHnkkaSlpbFp06b4vQ8++IBNmzZx0UUXJdRSTkpK4sEHH+Soo47i2WefTUgKv/LKKwSDQe688854QhggKyuLu+++m8svv5znnntul5LCIiIiIiIiIttqkerhmfMH8OTYRYyeklg24pfV5Zz98gweObUHh3Rp0UwRiohIc2lwUvi+++7D2Lxb0LZtAoEAn3zyyQ7H7IlJ4W7duuF2u5k6dSpFRUXk5OTE28aNG0dlZSWnnXZa/N7YsWMBGDlyZI1nDR8+nOTkZCZNmkQwGMTj8ex0zPHHH5/QR0RERERERKShXA6TW47pQa/8DO7/Yi7VYSveVloV5pp353DTiM5cf3TP+Gd7ERHZ9zW4fIRpmrX+xfHbxxqGgW3bGIaxw0PYmtMTTzzBLbfcQk5ODqeddhotWrRgyZIlfPbZZwwfPpzRo0fHdxEPHjyYn3/+mZ9//pmBAwfWeNaBBx7I3LlzKSws5IADDgAgNzeXoqIiioqKaNGi5ndiU1NT8fv9+P1+kpOTtxvnxo0bE3YtA1iWRSgUomPHjvEktEhttv3vz+Fw1H+8ZROxLEzDwED/aJQdsTCA2N8Ge/9BpLIn01qTpqK1Jk1Fa012j8Wb/Nz84VxWlVbXaDv2gBz+clIPUjwN3jsmUquGfhYVqav9ea3Vp1xGo/xpX5e8cgNzz03ipptuomPHjlx22WW8+OKL8ftdu3blkksuSSgrUV5eDkBGRkatz9pyv6ysrF5j/H4/5eXlO0wKP/PMM9x///0J9zp37sx//vMfotHoHpt0lz3Prq4VpwGxjyl7/n/X0vxi3zqwdtJLpOG01qSpaK1JU9Fak8bWLdfL25f0457PF/Lj4pKEtv/OK2LxRj//OPMAOrXY/udRkcagvIU0Fa217WtwUvjiiy9ujDj2CI8++ih33303N9xwA9dddx2tWrVi/vz53HXXXZx//vnMmjWLRx99tLnD5A9/+ANnnXVWwr0tO4UdDsd+910QqR/tFJamo11O0lS01qSpaK1JU9Fak90nLcnNP0f14uVJK3lm3IqEbR5LiwOc/9ov/PWUnhzdM2e7zxDZFfvz7k1pWlprddPg8hH7ih9++IEjjzyS008/nY8++iihraqqiu7du7Nu3ToWLVpE586dm7V8RG0CgQCFhYUUFBTg9XrrNVb2Lw09hdMfjFDkC5LicWKq5pjsgE5Ol6aitSZNRWtNmorWmjSVSQvWcfdn86mojtRo+/0RXbjt2B44TP2bXxpHQz+LitSV1lrd6NvOm33xxRcAHHnkkTXakpOTOeigg7Asi5kzZwLQo0cPABYuXFijfyQSYdmyZTidTjp37hy/v6Mx69atw+/307Zt23onhEVERERERETq69Au2bxzST96tEyp0fbsD0u45NWplPhDzRCZiIjsbrslKbxkyRKmTJnClClTdsfjd4tgMAhQ4wC3Lbbcd7vdAIwYMQKAMWPG1Og7btw4qqqqOOSQQxIOfdvRmK+//jqhj4iIiIiIiMju1jYridcu7MeJvfNrtI1fVMTJT05g9uryZohMRER2p0ZLCpeUlHDLLbeQm5tL9+7dGTZsGGeeeSYAv//977nsssu46aabGmu6RnfYYYcB8MILL7BmzZqEtq+//pqJEyeSlJTEIYccAsCoUaPIycnh3Xff5eeff473ra6u5p577gFir3tbl156KR6Ph6eeeorly5fH75eWlvLQQw8BcM011zT6axMRERERERHZHq/LwQOn9uLOkT1x/qZcxJqyAGc+N4n/TFvVTNGJiMju0OCD5gDmz5/PyJEjWbVqFduWKN5yXVJSwvvvv49hGFx44YW11uBtbqNGjeLoo4/mu+++44ADDuD000+nVatWzJs3jy+++ALbtnn44YfjtYDT09N58cUXGTVqFEcccQTnnnsu2dnZfPbZZyxYsIBRo0ZxzjnnJMzRqVMn/v73v3PDDTcwaNAgzjnnHNxuNx988AGrV6/m1ltvZejQoc3x8kVERERERGQ/ZhgG5wxuR89Wadz+wS8U+baWjQhFLO748FdmrS7jzycX4HHq4CYRkb1dg3cKV1dXc/LJJ7Ny5Ups28YwDIzfHD510kknxa+//PLLhk65W5imyVdffcU///lPCgoK+Pjjj3n88ceZMmUKJ5xwAt988w033nhjwpjTTjuNH3/8keHDh/Phhx/y5JNP4nK5+Mc//sG7775b430AuP766/nss8/o1asXb7zxBi+88AKtWrXitdde47HHHmuqlysiIiIiIiJSQ992mbx95RD6t8+s0fb2Tys55/kprCsPNH1gIiLSqAx72629u+Bf//oXN998M4ZhxHcGb7lu1aoVa9euZdmyZXTp0gXDMDj66KP55ptvGiV42SoQCFBYWEhBQQFer7e5w5E9WENP4fQHIxT5gqR4nJi1fONDZAudnC5NRWtNmorWmjQVrTVpKjtaa+GoxRPfLeKdqStrjGuR4uap3w1gaJcWuzSvFQkT9a3/zV0D05uFw1Pz0LuEuMrXEtpQiBWpxpXZHnfLAkyHk2h1BVb1zmsfG+5knMm7GHc0SrhkMeHiZdhWGHdON1w53THN+u23CxUtIrhpIc7kFnjaDsZ0JO68tiyL0LpfiPqL8eT3wZmWl9AeDQWoWvgN7hZd8eQfuEuvpTk09LOoSF1prdVNg8tHfPTRR/HrE088keeff562bdsm7JLt2LEjLpeLSCTC/PnzGzqliIiIiIiIiOxGLofJ7cf14MDW6fzli0KqI1a8rdgf4oKXf+KPI3tyxWGdav0p2R2JlK9i+d8PqNlgmCS1HUjmIdeS3v+8hCbfvK8oHf8vAsvGgb01FkdKLrknPUakch1FX/1xp3OnHngGrS94p17xApT//DqbvrwDK1CWcN/VogstT3+a5K5H7vQZoeKlbPzkOqoW/W/r+Jxu5Bz/V9J6nQpANFzN2ldOjr1O04lhOsk7/WkyBl4QH1P6/cOU/PgYHa7/qd6vQ0RkiwaXjygsLIxfv/LKK7Ru3bpGH8MwSE9Px7ZtioqKGjqliIiIiIiIiDSB43vn89plB9E2K/EnUqOWzV+/msd178zEH4zs+gSGA8OTBg432BbVq6ax/r1LqJz7WbxL6eTnWfv66QSW/gC2hSMtn6R2g3Gktybq30T16mm7Pn8dhUuWYQXKcOX2IKXXKbhyusfuFy9h7du/Ixr073B8NBRgzcsnUrXofxgOD8ndjsaR1pJw0SLWjT6PwMqpAJRPeY7AsnFkH/1/dLl3LY6UHDZ+eiPRcDUQ22VcOv6fZA79/V61S1hE9jwN3ilcUVEBQEZGBrm5udvt5/P5AIhGow2dUkRERERERESaSPeWaYy+/GDu+XQOExYlbvT68td1LFxfyfMXDqRzbv1/TDu521G0vexzrGiUsvH/pGjMnwAom/QMab1OIVJVTNEXt8c6my5anvkcaf3Oi5dcCCyfTLh0Oam9R5Ex5Jr4c1c9cyih9XMA6PznDRiOWHkMw9i1vXGe1v1oe/X/SO50KBArJbHmxWMJLJ+AVVWCf+EY0nufud3xvjkfEy5ZCkDO8Q+SdegNhIqXsfyxArCjlE74N97fjSa4bjYAKd2OxpGUgafNAPyFnxEpXoKjVS82fnYLpjebFsfcu0uvQ0RkiwYnhdPT0ykuLqa8vJzS0lKysrJq9Fm0aBHBYBDDMGptFxEREREREZE9V7rXxRPn9OOl8Ut5/selbHs40aKNPk59aiKPn92XY3u12qXnmw4H6QMviieFw6XLAKiY/iZ2NAhAxuBLE8ooAHg7DsXbcejmr1zx+9smf02nF9OVWDPZN/9rwqXLdxiTM6MdaQUnAZB24Gk14k1qN4jA8gmx+RzuHT6ratG38euUzaUi3C064c47gNCGuQSW/IAVjeJMiW22i1SsAyBaGau97EhrSeWcT6ha+F9anfM6jqT0Hc4nIrIzDU4KH3DAAUyYEPtD8M477+SFF16o0efee7d+B6ugoKChU4qIiIiIiIhIEzMNg6uGd6EgP50/fTKHyuqtZSMqgxGuenM61x3ZlZuP6Y7DrGudYRvLsrDDfsomPhW/687pBkDV4rHxe6mbk6mNoXzKC/jnf7XDPsndjoonhX8rWl1B5dxPAHCk5pHc9agdPmvLDmAAZ1p+/NqRlgcb5hL1byJauZaMg6+gbMrzbPz8FipmvkX1qqmk9jkLw5XMpi9ux9v5CFL7nl3HVykisn0NTgofc8wx8aTwyy+/zP/+t7VgellZGT169GDx4sXxe8cdd1xDpxQRERERERGRZnJot1xGX34wt73/C4s2+hLanvp+Mb+uKedf5/QjK2XHu2cBqhZ+y+K7vb+5a5A17EYArODW5ztScxoc+xZZh99CWr9zd9jHmV77rueIv4i1r51OpGQ5hstL/u9G43An7/BZdiRWExjDAebWVMyWshYAVjiAJ7c77W/4ifKfXiTqLyb31CfIGHwFxd/eT6RiHW0u+4zqFZMo/u99hEuX48ruTM6x92+zW1pEpG4anBS+5pprePzxx6msrMS2bZYti/2Ih23bBINBFi1aFO+bkZHBFVdc0dApRURERERERKQZtctO5rXLDuLBLwr5es76hLZxCzdx8lMTeO6CgRzYJqPOzzRcXrwdh5FxyB9I6XEMAM7UvHh7qGgRSa37NUr8ntb9cLfsteN4zJopk1DxMta8ejLhokUYnjTaXPQByZ0P3+l8pmdzuQc7ih0JgjuWCLdDWw+oc3hj5TY9ud3JO+nv8fvBTQsom/BvsoZdh+lOY+VTh+JIziL7iNspHvswa147lQ63/IIrfesOZBGRnWlwUjg3N5eXXnqJ8847D8uyarQbhoFt2zgcDl566SWys7MbOqWIiIiIiIiINDOvy8GDpx1I7zYZ/OPbhUSsrZWGV5cGOPPZSfz19N6MGth2u89I7jqC/As/AMPAcCZhmokHwaX2Og3fnI8BqJzxNul9zqrxDMuyaozbmfXvXFSn8hFtL9/aJ7DqZ9a+fjpR30Ycafm0ufSTOiepvR0OJrhmOgDh4sU48nvHrstWAuBq0QVnam6NcZZlsenTm3Ck5pB99P/h+/V97JCP9OE3kznkaiLlayn5/mECS37A1f+8OsUiIgKNkBQGGDVqFOnp6Vx77bUsWbKkRnuXLl148sknGTlyZGNMJyIiIiIiIiJ7AMMwOPeg9vRolcadH/5KkS8UbwtGLG57/xdmrSrl3pN64XbWkrg1nTg8Kdt9fuqBp+P46g6ilRvwz/+K9e9fRdbhN+PK7kKkbAWVv7yPbVvkHH1PveJOan8QGDtOJHu2SfhWLRrLmjdHYYf8mJ50ckY+iFVVStXi74FYUteV1R6AVc8fTWDZeBypeXS5ZxUAKT1PpGzSMwCUT34O96n/pmrRf4mUrgAgufsxtcbgm/sxVYvH0up3b+HwpGBbYWCbXcyO2OF6djRS63gRke1plKQwwLHHHsuCBQv46aefmDlzJmVlZWRmZtKvXz+GDBlS7+/aiYiIiIiIiMjeoX/7LN66Ygh3fvgrs1aVJbSNnrKSwrUVvHn5waR46peGMF0eWp//LmtePwMrUErF9NepmP56Qp/MYdfVO94WI+6qV3//om/jpR6sYAUb3r88oT3n+L+Rffgt2x3v7TqC5B4jqVowhvKpL1Ex613sUKxesiO1JdlH3FFjTDTop+iLO0juOoLUA88AILnLEeBwUznrPZLaDKDyl/9gOD14Ox9Wr9cjItJoSWEA0zQZOnQoQ4eqwLmIiIiIiIjI/iQ3zcPzFw7kn98u5N1pqxLaZqws49NZaxg1sB2G6cSV0x0AZ0abnT7X2/EQOtz4MxU/v07lr+8T2jgfsDGTs0nudBhp/WqWTXBmdcQKbznczWjwa3Ok5sVjro2ZnLV17sx2uHK640jeWj7TNE3yz3+Xson/pvynF4mUrcJwp5DW92yyj7gTVy3vQ8n//krUt4ncK76Ob7Rz53Sj1VkvUzTmT6x59RScWe1pec6ruLM7Nvg1isj+xbBt2955N9nTBQIBCgsLKSgowOv97cmtIlv5fD6i0SgOh4PU1NR6j/cHIxT5gqR4nJiN8I8r2XeZkSAGFjYmltOz8wEiu0hrTZqK1po0Fa01aSq7c619+es6/vplIdWRrWcPnX9we244qhupHifJbgfGLn6esKJRbCuMw5XUWOE2OSscBIdrhz9VHQ3GdiZvr7yGFQljOl27Jb7doaGfRUXqSmutbhq8U/iBBx6o95h77723odOKiIiIiIiIyB7qxD75dMtL5db3f2FNWQCAz39Zy3G9WtGjVRqRqE2ad9c2mpgOBzgcjR1ykzJdO0/C76jWMrBXJYRFZM/T4J3CpmnW+7t70Wi0IVNKLbRTWOpKO4WlqWiXkzQVrTVpKlpr0lS01qSpNMVaKw+EueeT2UxcXAyA0zQoaJ1ObpqHNple/nBEV1pl7L07fqXutHtTmorWWt002ulvtm3X6ZeIiIiIiIiI7B8yvC7+dW5/rjysMwARy+bX1eX8b95GZqws5dNZa1hVUtXMUYqI7H8a5aC5HSV7t91FrKSwiIiIiIiIyP7FNAx+f0QXClqn83+fzMEXjDC4Yxb/PKcfLkdsr5qvOkKKZ9frDIuISP00OCl88cUX13o/HA6zevVqfvrpJ4LBIIZhcMIJJ5Cbm9vQKUVERERERERkL3N491xGX3Ewd37wK388/gBcDhM77IeK1fgMB+G87mQkuTBNJYa3J1K5kWigGNOdiiuzXXOHIyJ7sQYnhV999dUdtq9fv57zzz+f77//no0bN/Lxxx83dEoRERERERER2Qu1z07m3auGYBgQjFhExt5D1fRX8BacinHaG5RUhfCWFlL633tqHe/O60neyY8DUFn4BeWTn93uXM70NrQ664WEe9WrplM6+VmqV0zGjgZxprYiqeNQ8k76+05jj4ar8c/9lMpZ7xDcMA/sKK6sTqT1PYvUvmfj9GbG+4aKl7Hxk+sSH2AYOJJzSO56FKm9T8PhSYs3RfxFlI57gqpF3xGpXI/h9OBMz8fdsoDMg68kqU3/2HPXz2H1y8djerPoeHshzuTsncYtIlKbRikfsSOtWrVi9OjRtGnThunTp/Pkk09yyy237O5pRURERERERGQPlJrkxGEYVK6fT/nMNwBwDbkZgKhlU1m2kapF39U61qquiF9Hyldttx+Aq0WXhK+L//cQxd/ev/WG4SBStorghrk7TQqHK9ax5uUTCW2Ym3A/UraKwLJxFP/vIdpc+hlJrfvE4gyWbze2ylnvUDL2r7S9eiyujNZYkRCrnj2ScNHCxGeXLqd6xWTcOd3iSeGkLkfgaTOQ4JrplH7/CLknPrLDuEVEtme3J4UB8vPzSU5OJhAI8OabbyopLCIiIiIiIrIfcpgGjs11g6unvQBWBFfeARit+tfaP+/0p2GbOsOO1Lz4dXKXI8g745mE/qH1cyibFLuX3PXo+P2qZRPiCeHkbkeTd+oTOLO7EK1Yg2/eVzuNe8MHV8UTwsldR5B9+O0Y7mTKJj1D5S/vEa1cx7q3zqXDLbMxHY6EsUntBpMx9PfYIR/lU18muPYXwiXLKJvwb3JPfBhf4afxhHDGwVeTPvBCDIeT0KaF+Bf+F3ObHcWmaZI+4HdsWjOd8p9fI/uY+3C4vTuNX0Tkt5okKfzqq69SVRU7TXTRokVNMaWIiIiIiIiI7GFcm+sF27aN79f/AJDS8wQcDoNItObh9NFup5FKFc60PByupIQ2T94BePIOSLi39q3zYheGg6zhN8XvV8wYDYDpSafV796Kl3owM9uRNfTqHcYcKl1B1cJvAXBmtqP1JZ9iOt2xGNodRLh8NdXLJxIuXkL10h9J7jYiYbwzsx0ZA84HwNthGCv+NRCAqsX/AyBctCTeN+Pgy0hq3Q+ApDb9Se93To14UnudxqbPb8UKlOEv/Jz0fmfvMH4Rkdo0OCk8YsSIWu/btk0oFGLdunWsWLECwzCwbRuns0ny0CIiIiIiIiKyh3E4Yknh0PrZRP1FACS1P5gUrxtfMEJ1OJrQv/jRthRjY7iSSe5+NLnHP4Q7p1utzw4VL8M351MAUnudgrtF53ibf/6Y2Pypuax/6zwCK6dimA6Sux1FixF/wpN/4HZj9s3+GIglrNN6j4onhGHzzt3+v6N6+UQAKud8XCMpvK1I5fr4teFKBmJ1krdY/cKxJHc7mqR2B5HS/RhceQdgmmbCM1yZbXFmtCFSvobA0h+VFBaRXdLgDO0PP/yAYWz/ZFDb3vqdPsMwGDx4cEOnFBEREREREZG9kLk5fxDatCB+z5XdCQNI8zhxOQy2VA02vdmYKblEy1dhh6vwz/2M6lU/0/G2wlpLJpROeALsWFI5a/it8ftWNEK0ch0A4eIlhEuW4UhrRbRiLb7ZH1G1eCwdbpqBK6NNrTFHylfHr51Z7Wu0u7I6bu1bsbZGe/Xq6az7z+XYIT/+beoMp/UZBUDKASeT0vN4/PO/xqouxzf7Q3yzP6ToqzvxtO5Pq7NeqpG0dma0I1K+hlDR4lpjFhHZGXPnXRrGMIx40tg0Te6+++7dPaWIiIiIiIiI7IG2bCmzqsvi98ykjPh1ktNBeusDyLxiHKk3LSXlqqmk37AAT+cjAGKJ3F/fr/HcSFUJFdPfBMDb8VC87bfdkGZsMzO0Ou9Nuty9jLzTn4rFEiijfOor24/ZubVshR3y12i3Qr5aX0s8ttIVVM4YjW/Ox9jBSgBS+5xFxsFXxcY4HORf9BH5F7xHWr9zcWa2i48Nrp3J2rd/h2VZCc80k9Jjc1eXbjduEZEdaZRaDtvuBt6eDh068K9//YsjjzyyMaYUERERERERkb3MluyB6UmP37NClQl9krLa4c5sS2V1hFDUAk867n6XEFz6AwD+Nb+QMsDCuU1ZhfJJz8YTtpnb1BKGWNLVmdWeSOkKAFIPOBmAlANOgo+vAyC0oXC7MSe1GxS/rl77S4326tXT49e1lbZwt+pNer9zwTBxpOSS3G1EjV3JpmmSduBppB14GgDB9XNZO/ocwkWLCG9aQLRyPWZG63h/a3Nyedv3UUSkPhqcFH711Ve322YYBsnJyXTt2pW+ffvusMyEiIiIiIiIiOzbLNvGYRi4crrH70VKluPJ6xX/OrB8AkltB5Pu9VAVilAVimKtn7n1ISktKfGHyEhy4XE5iIarKZvyPADu3J6k9DyxxrzJXUdQMS2Wv4j6N2FmtsXyF8fbnZlttxtzSs8TMJOzsapK8M39lOo1M0lq0x+AUMlyyqe+FOtoOEjffKDctty53cg+4rbtPt+/aCzR6lJSDzh56wF2rXrhzulGuGhRrWO2lLRwZXeutV1EZGcanBS++OKLGyMOEREREREREdnHRS0blwme/L6Y3kysQBnVq6YlJHJLx/2D4KqpJHc7FmdGG8IbCqma/xUAhtODeeDvsG0oC4RJsWwis94k6tsAQOZhN9Q4mA0gY/BlVPz8OtgW6z+4grTeo+LlJjBMMgZfut2YTaebFkfdw6bPb4FoiJVPH0pyt6MwnB6qFnyDHQkC0OKY/8NVS83hnQkXL2LjJzdgerNIajsQR0oO4ZLlVK+cAkBS28G4ttklHK5YR6RsFQDezsPrPZ+ICDRS+QgRERERERERkZ2JRG1wgmGapPY+k4qpL1M1/2taHHNfvI8rvTVV/iIqZ72dMNZMySX1pCcxknPi93zVYQLj/w2AI60l6f0vqHVeb/uDaHnGs2z6+i4Ci78nsPh7AAx3CrknPYanZcEO484adi2Gy0vpD38nXLKUqgXfxNsMdyo5x95HxiHX1uu92MKR3gYzKQMrUErVNgfRATgz2pB76hMJ93xzP4vN60kj9cBTd2lOERHDrktB4J345ZdfGDduHKtXr6asrIzk5GS6dOnC8OHD6dOnT2PEKTsRCAQoLCykoKAAr7fmKawiW/h8PqLRKA6Hg9TU1HqP9wcjFPmCpHic8ZODRWpjRoIYWNiYWE5Pc4cj+zCtNWkqWmvSVLTWpKk011pLT4p9lgiun8OqJw8C26LdDT/jaXVgvE+4bCXVK38iWrEGTAfu/L4kdTgEX8gmGNl66JodqYZ1P2MaBimZrUhp3au2KeOioSr8cz8lUrkBZ2YbUnqcgMOTUufYLcsiuGoawXW/ULXke3yzP8LwpNHuyv+S1HbA1nmClQQ31xp2pObtNOlsRcIE184itGEu0UAphsNFUpuBeNoNxnQk7udb+czhVK+cQsbQa2h56r/qHHtza+hnUZG60lqrmwYlhb/66ivuvvtuZs+evd0+/fv357HHHuOII46o0eb3+0lJqfsfvrJ9SgpLXSkpLE1FH2ilqWitSVPRWpOmorUmTaW51prHaeJ1OQDY8P7lVM58i9R+59Lq7NfqNL5wXQWPjlnAI6N6J3wmMYA0ryv+7N3NikZY99Z5+As/w5Hakna//wF3i91b47dq2QRWP38UpiedjrfNxZmWt1vna0xK1ElT0Vqrm11OCj/wwAPcf//9AOzsEaZp8re//Y3bb789fq+kpIQTTjiBKVOm7Mr08htKCktdKSksTUUfaKWpaK1JU9Fak6aitSZNpTnX2pbdwpHqUsIb52OYLpLaDgIgattYlo1pGpiGgY2NbUM4ahGO2kQtm5+Xl/Cfn1dzePdcslJcAISjNjNWlOJ2mvzx+J64HDVrCze2aChAxdSXsO0orpxupB1Q85C7xhQqXUG0fC1mchaevJ67da7GpkSdNBWttbrZpZrCr732Gvfddx8AhmFg7CQxZFkWf/zjH8nPz+eCCy5g3bp1HHPMMcybN29XphcRERERERGRvVhVOEqq24kzKQtn+6Hx+xY2vuoIO9u9NqhjNu2yk7n9g1+Zs6a8Rvuvq8t4+ncDyEtPauTIEzncXrIOvX63zrEtd1YHyOrQZPOJyL6r3t828/l83HLLLQnJYNu2sW2bjIwMWrduTUZGRvwexBLHtm1zww038PPPP3PooYdSWFjYuK9ERERERERERPYKkaiNLxghFLUIW7FfwYhVp4TwFi3Tk3jpokGMGti2Rtu05aWc9OQEfl5e0riBi4jsI+qdFH7ttdcoKysDYsngDh068OKLL7JhwwZKSkpYtWoVJSUlbNiwgRdeeIEOHTpg2zaGYVBWVsbQoUNZtmxZbHJz9/8oh4iIiIiIiIjseSKWTVUoij8Y+xUIR7HqWeDS7TS5+4QD+PPJBbh/Uy5iY2WQc1+YwuuTlu+07KWIyP6m3lnZ7777Ln49YMAAZs2axeWXX05ubm5Cv9zcXK644gpmzpxJv3794onhaDQKgMvl4u23325g+CIiIiIiIiKyvzu1XxteuXQw+RmJ5SIils2fP5vLLf/5hUAo2kzRiYjseeqdFJ41a1b8+sknnyQ9PX2H/TMyMnjyyScT7iUnJ/PZZ59x1lln1Xd6EREREREREZEaCvLTGX3FwQzpnF2j7eOZazjj2UmsLK5qhshERPY89U4KFxcXA5CUlMTQoUN30jtm2LBheL3e+G7hb7/9luOOO66+U4uIiIiIiIiIbFdWspsnzxvApcM61mibt66Ck5+awPcLNjZ9YCIie5h6J4UjkQgQK/9QH263G6hfMllEREREREREpD4cpsH1I7rx2Fl9SXE7EtrKA2Eue20a//7fIqz6FjAWEdmH1Dsp3KJFCwAqKyvjB8btzIoVKygvL8cwjPh4EREREREREZHdZUTPPN68/GA65aQk3Ldt+Me3C7nqzZ8pD4SbKToRkeZV76Rwjx494td/+tOf6jTmvvvuq3W8iIiIiIiIiMju0jEnhTcuO4ijD8ir0fbdvI2c+tQE5q+vSLg/b10F//fJHM54ZiIjnxjHGc9M5P8+mVOjn4jI3sxZ3wFHHHEE33//PQDvvfcekUiERx55hE6dOtXou3r1au6++27eeuuthPEiIiIiIiIiIk0hxePkkTP78OaUFbGyEdtUjVheXMXpT0/ikVF9aJ+dzINfFvLz8lIADMDe/PuMlWW8OWUFgzpmcc+JBfRrl9kMr0REpPEYtm3Xq4jOmjVr6Ny5M5FIJH5wHEBBQQE9evQgJSWFqqoqFi5cyNy5c7Ftmy1TuN1uli5dSuvWrRv/leznAoEAhYWFFBQU4PV6mzsc2YP5fD6i0SgOh4PU1NR6j/cHIxT5gqR4nJib//sXqY0ZCWJgYWNiOT3NHY7sw7TWpKlorUlT0VqTprI/rrWpy0r440e/UlZVs2yEacRKS+woSWIAbqfJsxcMYETPlrstzn1RQz+LitSV1lrd1Lt8RJs2bbjpppviCeEtSd+5c+fy8ccfM3r0aD766CNmz56NZVnxfoZhcNNNNykhLCIiIiIiIiLN4qBO2bx9xRAObJ1eo83aSUIYYu2hiMXvR89g1qqy3RGiiEiTqHdSGOChhx7i+OOPT0j4bpsgru3+cccdx0MPPdTY8YuIiIiIiIiI1FmrjCReungwZwxos0vjtySG//plYeMGJiLShHYpKexwOPj888+566678Hg8CSUitpST2HLP7XZzxx138Pnnn2OauzSdiIiIiIiIiEijcTtN7jmxgKuHd96l8TYwbXmpDp8Tkb1WvQ+a28I0Tf76179y/fXX89577/Hjjz+ycuVKKioqSE9Pp127dhx++OGcc8455OfnN2bMIiIiIiIiIiINVlIVatD4t6as5C+nHdhI0YiINJ1dTgpv0apVK2688UZuvPHGxohHRERERERERKRJLFhficHOawnXxgAK12mnsIjsnVTPQURERERERET2S1Wh6C4lhCGWSPYHI40ZjohIk1FSWERERERERET2S8luB8YujjWAFE+DfwBbRKRZKCksIiIiIiIiIvulHq3SGrRTuCA/vTHDERFpMkoKi4iIiIiIiMh+6cwBbRs0fkjn7EaKRESkaSkpLCIiIiIiIiL7pe4t0+jXLnOXx9/47iz+9d0iwlGr8YISEWkCSgqLiIiIiIiIyH7rlmO643aau1RbOGLZ/PO7hZzxzCQWbqhs9NhERHYXJYVFREREREREZL91YJsM/j6qDy5H3VIktSWPZ68p56R/T+DZH5YQ0a5hEdkLKCksIiIiIiIiIvu1w7rl8tLFg+i/TSkJ4ze/A/Rvl8nLlwzi8kM74TAS08OhqMUjY+Yz6rnJLNnk2+0xi4g0hLO5AxARERERERERaW4Htsng5UsGs2hDJR/MWM3C9ZX4Q1FS3A66t0pj1IC2dGuZBkC/dlkc0SOXez+dy7Iif8JzZq0q44R/jef243pw2bBOmOauFKYQEdm9DNu27eYOQhouEAhQWFhIQUEBXq+3ucORPZjP5yMajeJwOEhNTa33eH8wQpEvSIrHiWnoHzeyfWYkiIGFjYnl9DR3OLIP01qTpqK1Jk1Fa02aitZawwUjUZ79YQlvTl5BbcmVgzpm8/ez+tChRUqTx7anaehnUZG60lqrG5WPEBERERERERHZBR6ng5uO7s4rlwymfXZyjfapy0sY+cR43pi8HMvSnjwR2XMoKSwiIiIiIiIi0gB922XyzlVDOO+gdjXaAuEo9346lwte/onVpVXNEJ2ISE1KCouIiIiIiIiINJDX5eD243ry4kUDaZNZs6zjpCXFjHxiPO9OXYkqeYpIc1NSWERERERERESkkQzskM17Vw9h1MC2Ndp8wQh//Gg2l7w6jXXlgWaITkQkRklhEREREREREZFGlOx2cvcJB/DM+QNolZ5Uo/3HhZs49p/j+HD6au0aFpFmoaSwiIiIiIiIiMhuMKRzC967egin9mtdo62yOsKt7//ClW9MZ2NldTNEJyL7MyWFRURERERERER2k7QkF38+uRf/OrcfOanuGu3fzdvAsf8cx+e/rG2G6ERkf6WksIiIiIiIiIjIbnZYt1zev+YQTuidX6OtrCrM9e/M5Nq3ZlDsCzZDdCKyv1FSWERERERERESkCWR4XTx42oE8dlZfslNq7hr+cvY6jv3nOMbMWd8M0YnI/kRJYRERERERERGRJjSiZx7vXz2UYw5oWaOt2B/imtHTuendmZRVhZohOhHZHygpLCIiIiIiIiLSxLJS3Dwyqg8Pn9GbTK+rRvsns9Zy7D/HMXb+hmaITkT2dUoKi4iIiIiIiIg0k2N7teI/1wzliO65Ndo2Vga57LWfuf39X6ioDjdDdCKyr1JSWERERERERESkGeWkenj87L48cGovUj3OGu3vT1/Ncf8cx7iFm5ohOhHZFykpLCIiIiIiIiLSzAzD4KQ+rfngmqEM69qiRvu68mouemUqd388G18w0gwRisi+RElhEREREREREZE9RF56Ev8+tz/3nlRAittRo/3tn1Yy8olxTF5S3AzRici+QklhEREREREREZE9iGEYnNa/De9dPZSDOmXXaF9dGuC8F6dw32dzCYSizRBh/RmGgdPpxOmsWR5DRJqeksIiIiIiIiIiInug1plenjl/AH88vidJrpopnNcmLef4f41j+oqSZoiufrxeL16vF7fb3dyhiAhKCouIiIiIiIiI7LFMw+DsQe1476qh9G+fWaN9eXEVo56bzENfzaM6vHfsGhaR5qc9+yIiIiIiIiIie7h22cm8eNEg3pm6kqfGLiYYseJttg0vjFvK2PkbefysvvRtl7nb4igZ/y98cz5OuGeYLlw5XUktOJnkHiMxzcQ9iNXrZlMxfTT++V8R9W/EcHhw5/UktdepZBx8Jevfu5hIxbqdzp132pMk5feud8ylE56kcvaHtbZlDL6cjEEX7vQZodIVlI3/F765n2KFq/C07EXmsOtIKTgl/nrDFRvY9MUtBJZNwHSnkN7/fLKO/COmI1Yb2rIs1r1xBqHipbS//iccbm+9X4tIY1FSWERERERERERkL2AaBucf3IFhXXL482dzmb2mPKF98UYfZzw7iWsO78wNR3XD46x5UF1DhUuWUr1ico37gWXjqJj2CmkDLiT/7Jfi94v/9zeKv70fsBP7+zYQWPojKQUnUb16BpHS5Tud26ou32mf2mNeVmvMACndjtnp+FDxUlY9cxhRf1H8XmDZeALLxpM94m5yjv0zABs+vJKqBd+Qc8LDVK+aSvF3D+BIzSFzyNUA+OZ+jH/+17Q6900lhKXZKSksIiIiIiIiIrIX6ZiTwiuXDObNyct59sclhKNbE65Ry+bp75fwv3kbefzsvvRqnbHb4sgecRee1v0Ilyyj5H8PYQUrqJzxJlmH3UhSfm8q535K8bf3AWC4U8g6/DZSDzwNwzCpXvUzZZOfBSDn2PuwgpUAhIuXUDr+CQCSOgwlvf/v4vO5WnRpULzuVgeSfcQdCfc8ddh5XDTmnlhC2HTS+qIPSGo3mHVvnkNg+QRKvn+E9MGX4EzLp2rRWNwtC8gefjOh4qX4Zn+Ef/7XZA65mmjQT9EXd+DteiSpfUY16HWINAYlhUVERERERERE9jIO0+CSYZ04rFsu9342h3nrKhPa56+v5NSnJnL9iG784cguuByNf6xUUvshpPYcCUCkYi1lE/4NQNXisSTl96Z88nPxvi3PfIHU3mcAYJomnryepPX/HdgW6f3Pi/erWjounhR253Qnc8hVCXNa0Sh2pGqnsRmOJEynK+GeIzWXpLYDse0orqzONdprY0XCVC36LvZ62w4ktefxAGQc8nsCyyeAHaVqwRjSB10K2GBsfp83/25bsTrPJf/7KxHfRtpc/mWN8hoizUFJYRERERERERGRvVSXvFReu/QgXpu4nBfHLyVibd01HLFs/vndQr6dt57Hz+pHj1ZpuyUGy7KIlK6If20mpRPxF1G15AcAHCk5pPQ6FQDb3hpfLDlavwRppGI1yx/pvtN++Rd9SFrBSQn3Aou/Z/ljvWJzezNJPfAMck98BEdS+nafE1r3a7xshatF1/h9d26P+HXV0vFkDrkab6fDCCz5gbJpr1K9YgoAKd2PIbhxPqUTnyRr2PV48nrW/cWK7EZKCouIiIiIiIiI7MVcDpMrh3dmePdc7v10Dos2+hLa56yp4OQnJ3DTMd246rDOOBtp13DJ949QMe0VwqXLCa79BQDDlUzqgacRKV0FduwwPFduDwwzVt84GAySnJy8y3OaTi8pPU/YaT9nWqvEG4YDV05XDIeb8KaFWIEyKqa9glVdRuvz39nuc6JVxVvndqduvfZsTSRbgRIAWo16gQ2fXMemz2/FdKeSeeiNZAz9A2teOQlnWkuyj/oTwXVz8M39FDsaJqXHcXg7Dq3rSxdpVEoKi4iIiIiIiIjsA3q0SmP0FQfz4rilvDpxOdFtduWGohaPjlnAf+du4PGz+9IlN3UHT6qb6hWTEr52pOSSd8bTOL1ZWNscyrbtAXFOZ8NSUc60PNpc8nG9xqQPvpTso+/BmZwNQKhkOaueGU7UtwHfnE8Jl6/FldG61rGGY2uJCTsa2ua6eps+HgBcWe1pe+lnWJYVLxFRMes/BJZ8T/7571K9YjJrXjsNZ1pLDJeXku//Rssznydj8CX1ej0ijUFJYRERERERERGRfYTLYfKHI7tyeI9c7v10LsuK/Ants1aVccK/xnP7cT24dFgnHKaxy3NlDL0Gd14BhsOFO7c7Se2HYDpiqSZnViecGW2IlK8htH4OkbLVODPbNjgpHKncyPr3Lt5pvxbH3Ie3w8EAJP3mMDl3dkeSux1F5cy3wY4SLlq43aSwu2UvwABsov5N8ftR38atfX5TEmJLQjgarGTTV3eS3P0Y0nqfzqoXjgMrTJsrvsaZ1pKlD7aj5IdHlRSWZqGksIiIiIiIiIjIPqZX6wzevvJgnv1hCW9OXoG9TVswYvHgl/P4Zu56HjurLx1apOzSHCk9jo8fNPdbpsNJWr/fUfrj3wHY+NHVtDzvLRzeTCB2YJzv1/dJ7nYUztTcOs9pRQJULR67034Zh1wbv66c+xkpPU/EdMRKWFjhIME1M+Ptzow2AIRKV1D05R8BSO07ivTeZ+JMy8PTui/BtbOoXjWVaKgKhzuZqoXfbfM+HFdrDCXfPYjlLybvlH8CscP4AFzZXTAdDhwpOfF7Ik1NSWERERERERERkX2Qx+ngpqO7c2SPPP782VxWllQltE9bXsrIJ8Zz1wk9ueDgDpgN2DVcm6zDb8Y352PCxYupWjyW5Q93wdvpUDAMgmt/IVq5no53LqzXM50Z7ej6l4qddzS3przWvX0+zrRWeDsdhulOoWrJD4SLYvN6Ox+BO6cbAFZ1Bb45HwHgbtULNm8wzhhyNRs/+j1R30ZWPzcCd8sDqPz1g839DiSpw7Aa0wfXz6V04tNkD78l/nx3bjfCRQsJrpoa20VduQFPq171ev0ijUVJYRERERERERGRfVjfdpm8c9UQnhq7mHemrkxoC4Sj3PvpXMbMWc+jo/rQNmvXD4H7LWdyC9r9/gc2ffXH2OFqwUqqFv433u7K7ozprt8uZdM0wfTUa4w7uzOhTfOpnPlWwn1vp+G0OvvlnY5PH3QJkYq1lI77J8G1Mwmuje0yTuowlFbnvI7pdCX0tyyLjZ/ehDOjNVkj7orfb3HMfVSv/InVLx0HpgvDmUTOyL/V67WINBbDtm175932X6NHj+bCCy8E4MUXX+SKK66o0eeLL77gscceY+bMmUSjUXr16sUf/vAHLr54+zVuXn/9dZ5++mkKCwtxOBz079+f2267jZNOOmmX4gwEAhQWFlJQUIDX692lZ8j+wefzEY1GcTgcpKbW/2ABfzBCkS9IiseJaTTud5Fl32JGghhY2JhYzvr9o02kPrTWpKlorUlT0VqTpqK1tn+avqKE+z4rZE1ZoEZbqsfJPScewDmD22Fs5/NeuHQlUV+stq4rtyuOpIw6zRsJ+qha/D3RyvWYLi+eVr1w5/eN19/dIhqsJLwxtovXTMnBnd2hPi+vVpZlESlZQvXaWVhVpRjuFJI7HYYrq33i3KEA4Q2FADjS82vUGY4EyqiaPwYr7Ccpvx9J7QbW/lqrSqic9S5J7Q7C227Qb9qKCSwZhx0J4u18GK7NpSuk8TQ077G/UFJ4B1atWkXv3r2JRqP4fL5ak8JPPfUU119/PS1atOCcc87B7XbzwQcfsHr1am699VYee+yxGs+97bbbePzxx2nbti2jRo0iFArx7rvvUlJSwpNPPsl1111X71iVFJa6UlJYmoo+ZEhT0VqTpqK1Jk1Fa02aitba/qsqFOGJ7xbxwfTVtbYf3j2Xh8/sTX5G4+UXLMuKX/82ESzSmJQUrhslhbfDtm2OOeYYli1bxhlnnMFjjz1WIym8fPlyevbsSUpKCtOnT6djx44AlJaWMnjwYJYsWcKkSZMYOnRofMykSZMYNmwYXbp0Ydq0aWRlZcWfNXDgQPx+P/Pnz48/q66UFJa6UlJYmoo+ZEhT0VqTpqK1Jk1Fa02aitaaTFlazAOfF7K+orpGW1qSk/tO7sUZA9psd9dwfYRCIUzTxDAMHJsPfBPZHZQUrht9a2Y7/v3vfzN27FheffVVUlJqr2/zyiuvEAwGue666xKSuFlZWdx9990APPfccwljtnz9pz/9KZ4QBujYsSPXXnstwWCQV199tZFfjYiIiIiIiIhIoiGdW/De1UM4tV/rGm2V1RFuff8XrnxjOhsrayaN6ysUCuH3+wkEapatEJGmp6RwLebNm8cf//hHbrzxRoYPH77dfmPHjgVg5MiRNdqOP/74hD4NGSMiIiIiIiIisjukJbn488m9+Ne5/chJdddo/27eBo795zg++2UtDflhc7fbHd8pLCLNz9ncAexpIpEIF154Ie3bt+ehhx7aYd8FCxYA0L179xpt+fn5pKSksHr1aqqqqkhOTsbv97NmzRpSU1PJz8+vMaZbt24ALFy4cIfzbty4kU2bNiXc21Kbp6qqimg0usPxsn/bsj621Mqu93jLJtVhYUajGOgvc9kRK/67GQk2aySyr9Nak6aitSZNRWtNmorWmmx1eKd0+l0xkEe/XcKXczcmtJVVhbnhnZl8MWsV957QndYt6na43LacTidOZywNtW194YaybZvq6urtJqydTidud81k929Fo1EMw6hzveNoNIplWbhcrnrF+9tnBIP6b6+xNTTvsTerT7kMJYV/44EHHmDmzJlMmDBhp7V5y8vLAcjIqP0Pw4yMDPx+P+Xl5SQnJ9epP0BZWdkO533mmWe4//77E+517tyZ//znP0SjUSWFpc52da04DQB78y+RHYt966Dx/tEnsj1aa9JUtNakqWitSVPRWpMtMr0OHjqlO0f1yObBMUsoqQontP93XhGHdMvjnIw03A6DDe9eSKhoEVnDbyWt79kARKtKCSwfT2hDIVZVCYY7BW/HYXg7D8dwbE3O+heMIepP3PC2LU9+Xzz5feJfR6tK8M39hEjxUkxvFml9z8GZ2RbDMEhKSsLv99dIDLtcroSEcLh0Jb45HxGtXI/hSiKpwyEkdz0Kw3Qk1DkOrp5OcGNhwrMM0407tzvu1v3idZG3jLGjIaqW/kj1sgnY4QBmUjrO7M4ktR2EK6dbfHf0xo//QPXq6WQcfCUZB10RH688zu6j93b7lBTexk8//cRDDz3ErbfemnA43J7mD3/4A2eddVbCPcuyCIVCCX8oidRm2z8Qd2WtRC2biGVhGoZ2CstOWBhs+daBqhXJ7qS1Jk1Fa02aitaaNBWtNandiB559GuXyd++Wcy384vi97NT3Bx9QEsqqiOYS77CN/tDzKQMUnpuLZG5/G+dsKOJu19LAXfeAbS+7Auc6bH6xaVj/0b1qqnbjSF7xN3xpHDFjNFs+uQ67G12tBd/ex+ZQ/9AixMexjAMvF5vwq5b0zRJSkoCIFK5jo3vX0nV4rH8dnOTI60VOcc/TFq/c+L3Kme9S9mkp2qNy5nehrzTnyK5x8j4s9e8dDzhTQtq7d/p/9bi8MbOlErufhwV016l+L9/JrXPKBxJmXg8Hu0WbmQNzXvsL5QU3iwSiXDRRRfRvXt3/vKXv9RpTEZGBkVFRZSXl9OiRYsa7b/dGbzl9y33t9c/MzNzh/Pm5eWRl5eXcC8QCFBYWEhycvJOdzjL/q2hp3D6gxHKfEFSPE5M1YKSHYj9CKIFOs1adjOtNWkqWmvSVLTWpKlorcmOZKZ7eOSs/hw1dz0Pfz2fskCYE3vn43LEvoHgn/AYACm9R+H0ZsbH2VaEpA5DSel+HIbDSfm01wgXLya0cR6l3z9M7qn/jiVs2w7EcCUnzBkuXkSkfA0AruzOmKZJuHwtGz/6A1hhPG0HkX3knVQt+IbyqS9RNvHfeFr3JWPgBZimWWsph2gowNpXTiK0Ibbz15XTnZSexxMuWYZ/3hdEK9ez4T+XYialkVZwUmzQNh91PW0G4EhpQaR0FaFN84lUrGHdOxfQ6a4lOL1ZlP34eDwhnNzjODx5BVghP8G1M6lePT2hJEVqwck40loRrVxPxU8v0eLIO7Ybt+y6huY99hdKCm/m8/nitXy3fCfpt6688kquvPJKbrzxRp544gl69OhBUVERCxcurLGzeN26dfj9ftq2bUtycuwPuZSUFNq0acOaNWtYt25djbrCixYtAmqvUSwiIiIiIiIi0tSO7dWKAR2yeOjLeRzeIxcAe9McQmumA2D0OJ3yQJi0pNjGobZXfUNyp8Pi41MPPJ3lj/UCoGrJj/H7eac+kTCPFY2y4vEDAXCk5cd37lbOfBusWBmLnGPuI6XHMaT0OJ6KWe9ih3xUzBhNxsALthu/b87H8YSwt8uRtLnsC0xHLB1W8ev7rH/7AsCm9Ie/b00KbyP7qD+RVnASlmWx7q1z8M/9DDvkxzf7IzIPupyqxd8D4GkzkLaXfpYwNly6EtO9NSlpOpyk9jqV8inPU/Hz67Q48o7txi2yuykpvJnH4+Hyyy+vtW3GjBnMnDmTQw89lB49esQTwCNGjGDixImMGTOmRlL466+/jvfZ1ogRI3jzzTcZM2YMl156aZ3GiIiIiIiIiIg0l5xUD4+f3ZcklwN/MEJ06XexBocbWg+mOhwlFLFI9zoTEsIAZnJ2/NqZ1mq7c/gKPyFcshSAzEN+j+mM1QKO+DZsfVZSWux3pwvT5SUa8lG9fBLRUBUOd3LNhwKVs96JX2cfcUc8IQyQeuCZuHIeIFy0kOqVUwiVrMCd3aHW55imiTunO/7NX1uB2E97m5t3SYfWz6Ho27+Q0v1Y3K374nAl4cpqX+M53o7DKJ/yfGz3dPEy3C06bfc9EdmdlBTezOv18tJLL9Xadt999zFz5kwuvvhirrjiivj9Sy+9lEcffZSnnnqKSy+9lI4dOwJQWlrKQw89BMA111yT8KxrrrmGN998k7/+9a+cdtppZGXF6sosX76cp59+Go/HUyNZLCIiIiIiIiLSnBymgdflwO00Wb9+FgDOrE4YzthPW09dVkLrzCS65KaSunnXsGVZFH11d/wZGcOu2+7zy8Y9AYDhSSNjyNXx+57W/ePXFTPfxtN2MIHF/4sfUmdHg0QrN+DYTnI1tGHu1me16ZvQZpomnla9CBfFfnI8uH52jaRwaN2v+B0ewqVLKZ/6cvy+t/Pw2GsafBnVKyZhR4OU/O9BSv73IIYzCW/n4WQfcRvJnQ9PeJ6n9dbD86pXTVVSWJqNksIN0KlTJ/7+979zww03MGjQIM455xzcbjcffPABq1evrvXAukMOOYRbbrmFf/zjH/Tp04dRo0YRCoV47733KCkp4cknn4wnl0VERERERERE9gRbzpRxGAb25oSsufkANYBXJy6jXXYyd4zsQShikeaG0s+up2L66wBkH3MfqQUn1/rsqmUT4ofOZQy6JKFGcVrvMykZ+zfCRQtjZRemvVbjIDuM7R+UaFuRrd0ctZQLdWxbz9eu0Vz87f017qX2OhVvu0Gb470Qw51E6bgnCK7+OfaUSDVVC/9L1cL/0vqST0jtefzW6ZJz4tfRbXZBizQ1JYUb6Prrr6djx4489thjvPHGG1iWRUFBAQ8++CAXX3xxrWMef/xxevfuzdNPP80LL7yAaZoMGDCA22+/nZNOqlm/RkRERERERESkOW2bLjXMWDrJIIrLYRKOWlx9eGf6tM0EIBqsZMN7F1O9+DvAIOfER8gcdv12n1067h+xC9NF1mE3JrSZLg/trhlLyQ9/xz//K6yQn6Q2A4j6NlK9aiqGy4sjreV2n+3KaE+0MpZ8DZcsxZHfO6E9UrJ8a9/MmqUjXNmdMJPSMUw3rhadSTngJFJ7n5nQJ73PWaT3OYtwxQYCy8dTMf1NqhaMAaB86ssJSWE7Gt460KED5qT5KClcB/fddx/33XffdttPPvlkTj659u92bc8ll1zCJZdc0rDARERERERERESagG1vTQs70vMBiPo3keF1UR2O0rdtJjZg+zcQeP9swmtnYTg9pJ/6Aqn9z97uc4ObFuCf9xUAaX3OxJXZrkYfZ2oueSc9Cic9Gps3FGDF47HD65K7HY3DVcsO4M1S+5xJ9eppAFRMe4WkU/4Zb6te+2t8h7IzqwPulr1qjM856bFaD6DbNn5Xi26YpokrvSWuPqNILTiVxf+XAXaUqG9TQv9tdwc701tv97kiu5uSwiIiIiIiIiIiskOWHdstbADeDkPwzXqHSMkKotWleJOycDtNKgJByt84hkjpCgA8HQ8jsqmQTf+9D4dp4HJ7yTrijoTnlv74T7bsQ84afnOtc5eMfwJvu4Nx5XQlUrqSou/uJ1K+BoD0QZfsMO60fr+j5PuHsQJllE16FitcTUrBSUSKl1Dy4z/i/bKP/COmw1Hv92XDB1djVVeQ2usUPPl9weHCX/gF2FEAktoOTOhfvXr65isDb8dh9Z5PpLEoKSwiIiIiIiIiIjsVsSxcpklyzxPhs1vAjlK9+HtSDzwDh2GQ4XFQvDkhDMTKRyz+Lv61mZRB2vDbcW8uARyu2EDlrLcBSO46gqTW/Wqdt2LqqxR9eWeN+9lH/nGHu3gBXOktaX3h+6x76zyi/iIqpr1CxbRXtnYwHGQfeSeZB11Wx3ehptCGuZRsc6DdFqY3k8xD/pBwr2rJDwAktT8IZ0pOjTEiTUVJYRERERERERER2alwxMblBldGW5J7jqRq3pdU/vIuqQeeAYBhmKQPuhQbG8uyax7b5vJSWhUmxW2R4nES3jSPtH6/AyBj8CXbnTdz2LX4F35LpHwNhunA06Y/mUOvwdOyoE5xJ3ceTsc7F+Gf+ym+OR8TqVhH9ZoZYEXIOOgKco79c0L/pA5DSA/6YyFntt/hs/PPfQNf4edUr5pGuHQ5djiAIzkbb6fhpA84H1fW1vHRoB///FipjIyDrqxT7CK7i2FvWxRG9lqBQIDCwkIKCgrwer3NHY7swXw+H9FoFIfDQWpqar3H+4MRinxBUjzO+OmzIrUxI0EMLGxMLKenucORfZjWmjQVrTVpKlpr0lS01mRXZHhdGED12lmsfmoomE463DoHV1biIW02EAhH8QcjtT7HaRqke124HObuD7oW5dNeY8OHVwPQ8qyXyRh4wW6fs3TCv9n0xe24crrT4aYZmE4dNLc7NDTvsb/QTmEREREREREREamT6nAUr8tBUut+5Jz0KOFNiwhtWlAjKWwAyS4HbodJZXWYiBXbk1gRCDNm7noGtM+ia14qKR4nKW4HRhNvOsoYfAnRqhIqZ39I+dSX8HYchrtFp906pxWuJuPgq0nrc4YSwtLstFN4H6GdwlJX2iksTUU7T6SpaK1JU9Fak6aitSZNRWtNdlV6Uu2fB6O2ja+65s7gsGXx3uRlvDF1NcX+EJvzw6R6nLgcBgfkp3HfyQfSvVXa7g5d9gPaKVw32iksIiIiIiIiIiJ15gtGSPE4cWyTGI7aNv5gpGYdYcBpmlx4cFsO6pjO/32xiIUb/fHnAExaUsJJT07gpmO6cdVhnXE2sKRENBQgWrEm8abhwJHSAkdS+g7HhooWEdw4H6worqwOuFv1wXQ4iPiLsAJlO53bTMrAmZq7y7Fb0SiR8tVghQFwZnbY7q7icOlKqtfOxHB48HY6DIcnpV5zRfxFBFZMBgy8HYfiTG5Ro0+oeBnBDXNwZbTFnd8X00z8/8a/8DusaJC0A06s19zS/JQUFhERERERERGROrNsqKxlR/DO9GyZyluX9Of5SWt4deJyotv88HooavHomAX8d+4GHj+7L11yd32HZ3D1NFa/cEzNBsMkqe0gso64nbRep8RvW5ZF5fQ3KJv8HMG1MxOGOFJb0nLU81QtHkvZhH/vdO7MQ/5A3in/rHfMEX8R60afS3DtL1jBivj9jncuxP2b0hyRQBkbP74W35xPwIr9/2B6s8g67CayjrijRuL2t6xIiE1f3EbF9DewwwEADFcyGYMvJeeER+JJ6OL/PUTxd3/BcLiwI0FSCk4h//x3MR0OAKpXTWfNqyfT4pg/g5LCe53mqeYtIiIiIiIiIiL7HZfD5A9HduW1ywbTKafmztZZq8o44V/jeWn8UqJWwyueGk4PZnILDGcS2BbVq6aybvQ5BJZPjvcpHnMPGz68Op4QdrXoSlLHYTgz2hL1bSC0fm6D49gZK+gnsGw8diSImZSx/X6Wxfp3LsT36wdgRUjudhTuvAKsQCnF//0z5VOe2+lcm764jfIpz2OHAyS1P5ikdgdhh6som/Q0RWPuBiBUuoLi7/6Cp80AutxXTMZBV+Av/Azf3I9icUSjbPz0RlwtupI1/JbGeROkSSkpLCIiIiIiIiIiTapX6wzevvJgLhragd9WJw5GLB78ch7nvjCZFcX+Bs2T1u88ut67li73l5A1/NbYTduibPKzsbk2FFI67nEATE86bS77kg63zqb9NWPpeOci2l71X9wtC8g54RG6PhSI/3Kk5sXGeDMT7uec9PguxelIzaXdtRPpcn8Raf3P226/cNFCqhb+N/baBlxI28u/ot11k3BmtgegbOJTO5wnGvRTMe01ALydDqPtNT/Q9vc/ktR+CADlP72EFQ7GEuG2hbfDEEynC2/n4QCE1s0BoOLnV6lePY28U57AdLp36TVL81L5CBERERERERERaXIep4Obju7OkT3y+PNnc1lZUpXQPm15KSOfGM9dJ/TkgoM7YJq7fti56XCQ1veseAI4XLoCgPKpr8T7ZB1+Kyndj946xjRJ7nz4dp5oxH+vrVxDxcx3iPg27DAmT14vUnrEylw43Ml42w3a6evwLxgTv07dXLLB4fbi7TycyhmjCRcvIVS8FHeLzrWOr1oyFjsaBCClx3Hx2FO6H0v1yinY4SoCy8bjTM8HIFK+dvPvsRrNjrSWRKqKKfrmXlJ7n0FK96N2GrPsmZQUFhERERERERGRZtO3XSbvXDWEp8Yu5p2pKxPaAuEo9346lzFz1vPImX1ol51cr2fbVoRoKIBVXUbpNrto3Xk9Y89f+mP8XuqBpzbgVSQqnfBvgmtm7LBP2oAL4knhugqumx2/dqa13Hq9eecyQHDtL9tNCofW/hq/dqS22nqdtu34WWQOvwVv58PxzfmYNW+MIrDkRxxprUjrfx5FX92FHQmSe+Kj9Ypd9ixKCouIiIiIiIiISLPyuhzcflwPRvTM5b7PCllTFkhon7SkmJFPjOOekwo4d3A7DKNuu4YrZ4ymcsbohHuG00PmsOsAsEJby1M4UnIb+Cq2yj3+IaLV5Tvs49pc8qE+7Eh1/NpweLZeO7deW+HE925b27ZtO8ZwJG3tE6nGNE1aX/oZFT+9SHD9XDIPvYHMIVcT3rSIimmvkTPyL2A6Wfv2BVSvmIThTiV9wPlkHX77Tg+6kz2DksIiIiIiIiIiIrJHGNghm/euHsIT3y3ig+mrE9r8oSh3fTSbMXPW8/CZvcnP8Nbr2WZyC5K7HE7WoTeRlN8bAEdqHuHiJQCENs7D2emwRnkd7vze2JHQDvsY7vrtegYSDqGzQpXbXG+T3PZmbnf8tm1WyFfrs7b0cbiSyDr0+q19olE2vnYq7ryeZB56E2teO5nA4u/JOf5vBFZMpvibe3Gk5JB50OX1fl3S9JQUFhERERERERGRPUay28ndJxzAiJ55PPB5IesrqhPaf1y4iWP/OY77Tu7FGQPaxHcNlwfCGEAwGI33Tel/IblnPIvTNDEdjhpzpR54OtUrJgNQ8fObJNeSFLYsq967X9e8cnKdykfkn/1yvZ7r7TiMiqmxMaHiJSR3OQKAcMmyWAfDQVLHobG4oxFsKxK7bbowHQ6827y+Lcnw2PXSrXN0OrTWucunvkRwzQzaXjEG2woTWPwD7la9yT78FoIbCvEXfoZ/3ldKCu8llBQWEREREREREZE9zpDOLXjv6iH849uFfDprbUJbZXWEW9//ha/nrOP8g9vz9A9LuHhoRw7qlI1t2/F+NgalgSguh01akoHLkZjcTR94AcXf/QU7WEnF9NcxXElkHvIHnOmtCRctpmLmW7iyO5G1udxEXSV3PQpXdscd9klqd1D82opGCZcsjl0HyuL3I8VLsSPVmJ50XOn5pPQ4DkwXWGEqpr1GWr/ziJStoGrx97Fntj8YpzcLgPKfXmDTZzcD0PaKMSR3PRJP20E4UvOI+jZS+esHZB12E7Zl4ZvzMQDOjDa4W/WpEWvEt4ni//6Z1D5nkdz1SKLByti7uyVZbm5OuNvRGmNlz6SksIiIiIiIiIiI7JHSklz8+eRejOiZx1++KKTIl1iS4bt5G/lu3kYALh7acbvPCUctnv5+MYd2y2FQh+z4fWdyC/LPG826dy7ADlZSPuV5yqc8nzA2Z+Rf6x137vEP1qu/Hfaz4vGaydjVL40EIG3AheSf/RLOlBxajLiL4u8eoHrVVJbc3xKisffEcHrIPeFvO5zHdDjIOeFhNvznMiKly1n6UEew7c3JXIOcEx+pdVd00dd/wrYi8cPlHJ40ktoPoXrVVMqmvUpg6XgAkrvV7+A8aT5KCouIiIiIiIiIyB7tsG65vH/NIfz9mwV8NXtdrX3iO4RdKbha9gLASG8db39j0nKe/WEJ7109lH7tMuP3U3uOpMNN06n4+Q18v35AqHgxWFGcmW1J7nIkKb1OqTGXO68n0ZSchBq/DWI4cG+OuTaujLbx66wRd+Fq0ZnSCU8SXDsLw5lESs8TyD7idpLaDoj3cyS3iD/TcKfG72cMOB9nSh4lPz5GYPlEME2SOx1O1uG3k9JtRI25AyumUDH9DXJOeBhXxtb3s9U5r7Hh49+z6dObMD1pZB56IxlDrm7Q2yBNx7C33VMve61AIEBhYSEFBQV4vfUrtC77F5/PRzQaxeFwkJqauvMBv+EPRijyBUnxODHreNqr7J/MSBADCxsTa5tTbUUam9aaNBWtNWkqWmvSVLTWpCk15nobO38jD301jxJ/4q7h60d05YIhHWodU+wLcsK/J2AAgzpm8f41h2z3+ZZlgW3XWoN4T2NZFkC9ax7XZ7wVjYBtgemstd+u1FzenRqa99hf7Dn/j4mIiIiIiIiIiOzEiJ55PHxm7xr335m6kpUlVTXuRy2bx79dCIANTFteyvz1Fdt9vrmdQ+n2RKZpNighW5fxpsOJ6XRvt9+elBCWulP5CBERERERERER2at8W7ihxr0iX4jzXphCQet0Mr0uACKWzZy15VQEIgl935qykr+cdmCTxCqyJ1JSWERERERERERE9ioL1ldiENv5u62IZfPr6vLtjuvQIplT+7amzzY1hUX2R0oKi4iIiIiIiIjIXqUqFK2REN6ZtlleXrhwEJnJLpymzsiR/ZuSwiIiIiIiIiIisldJdjtq3Sm8Izcc1Y3MZBe2FcUuKqS63Ik7rwDTpYMWdyQSKCNSsgzD4cbTqldzhyONRElhERERERERERHZq/RolbbDMhG/1at1Ood3zwXAnv0mJV/eSGWLLnS45dd4n8rCL6heMYXgul+ww9UA5Bx3P96OhyQ8q+SHx/Av+KbWeTKHXUvagacBYEXC+OZ8RPXqnwltmIsdCQPQctQLuFt0qlPcVjRK1cJvqJgxmupVU7HD1ThS80gtOIX0QRfhbtE5of/ql0/EjoQS7plJaXg7DCW179m4szrE70fD1ZRN+Df+ws8JlywFw4EjJQd3Xg/S+p4Tfx1YEVY9NwI7XEW73/+It8OQOsUuezYlhUVEREREREREZK9y5oC2vP/z6jr3P3tQOwDsSDVV4/4GQNoh12OYjnifDf+5DKs6MdEc8RfVeFZo0wICy8bVOk9qr1Pi11bYx/p3L6rRxwr56hSzFQ6ydvTZVC0Yk3A/6t9EyYa5lI77By1HvUB6/3PjbYFlE7Aj1TWe5Z/3JcX/e4g2l35KcufhAGx49yJ8cz9NfLZvA6ENcwEjnhR2puSQPvBCyqc8z6av76b9NWPrFL/s2ZQUFhERERERERGRvUr3lmn0a5fJrFVlO+2b4nZw1AF5ANgLPiFauR4cHqLdz6A8ECY9yYVpGqT2PgN3Xk8iZaspm/jkTp/raTuIzKG/T7iX1G5Q/NownaQNuJCktgOoXjGFyl/eq9drLP7uL/GEsLvVgbQ49n7cLTpTOfsjSsY+jB0NsuHDq0jqMBR3doeEsY7UPHJP+Qd2JIS/8HN8cz7GDldR9N/7aH/NWELFy/DN/QyA5B7H0eKoezC9GURKV1G15HuwrYTnZQy8mPIpz1O9fCLVa2aS1KZ/vV6L7HmUFBYRERERERERkb3OLcd054o3fiYcsXZYW7hvu0xcDhOA0JxYYtbT4RDwZBCMWBT7Q6R7nbQ68zkAyn56qU7zOzNa4+106ObrdpgOR0K7w5NG/tmxZ20qX1ufl4YVjVAx483YF6aL1hd/FC/94GlZgB3yUzruH9iRIJUz36LFUXcnjDfcyaT3OQuAtL7nsPQvrbGqy6lePhErEiZSsowtFZlTep6It/1BsWfn9iCl+9E14nG36Y8zow2R8jVUzBitpPA+wGzuAEREREREREREROrrwDYZ/H1Un3jCd3t6t8mIXVgRQqt+AsDZemC8/T8/r6KsKkxldRjbrvvRdf65n7H80R4sf7QHy/7WiY1f3EE0XLN0w66oXjkltqMZ8HY8JKEWMED6gAvi177Cz3f4rKh/E1Y4AIDhTALTgSuvBxixJPamz25m1UsjKRpzL/5FY7E21z7elmmaeNrE3rPAsgm7/sJkj6GksIiIiIiIiIiI7JUO65bLSxcPon+7zPg94ze/56V7cDlMUiObsEN+AMzMWJJ1Q0U1f/9mAUc//iNVoSgl/hBWXfLChgNXi664c3uC4SDq20DZhH+x6fNbGuV1RcrXxK+dGW1rtDuz2m/tuzl5vK2obxNr376ANW+excp/HwzR2OFzqb3PxDRNXBltaHH0/wEG2FECi7+n5IdHWPPy8Sx7uAuVcz6p8UzX5jnDxUsb+OpkT6DyESIiIiIiIiIistc6sE0GL18ymEUbKvlgxmoWrq/EH4qS4nbQvVUaJ/dpTabXRXXZ1kPkvKkZWA4TXzACgMMRSyFHLBsrEt3hfJlDriHnxEdwJmcDEFw3h1XPj8CqLqdy5tvknvA3HEkZDXpNhispfm3XcjCdVV0Rv3YkZdZot0N+fL++n3AvqcMh5J7wcPzrFkfdRUr3Y6n45V0CS38kuG4O2FGivg2sf+8SktrNxZXRJt7f9KTF5g5WYEWjNcplyN5FSWEREREREREREdnrdWuZxl3HH1DjfrI7lrxMSJ6G/GR4XXTNTeW6I7ty4dAONcYBtdYqTmo3MOFrT/6BeDsdhn/eF9jhAOHipTgaWHM3qe3gWHkHO0pw3ewaSdjqVdPi166crjXGm8nZtBhxV+zak46383DcLTrX+lq2vJ6Iv4gN71+Jf/5X2OEA1aumJSSFrWAlAIYnTQnhfYDKR4iIiIiIiIiIyD7L2lwn2JneGsOVDEC4dAUGkJPq4YajuuE0jVrHVgWjVIe37hy2IiH8C7/Dsqz4vWgoQHDDnNgXhokjtWWDY3ZltMbbZXgs1pKlVEx7eet81eWU/O+v8a/TB15QY7yZlE7WoTeQdegNZAy+pEZCOFS8lJJx/yRSVRK/50zJwdO639ZORuJ7Ei5dCYA7u9Muvy7Zc2insIiIiIiIiIiI7LMiURucYDhcJLU/mMCS7xN22jpNg8xkN+ve+h0R33os38Z4W+D7+6j+6d+4cnqQP+pZbCvKmldOxJXbA2+nQzEdbvyLviNSshyAlJ7H48poHR+/6rmjsLGJlK6I39vw/pUY7mSSOw8n59j7tht3zjH3s3rZJOxokI2fXE/5tNdwZbalaskPWNWxUhipvc8g5YCT6/2eWNXlFH31R4q+uZek/L44M9sSrSqJHyJnJmWQ3O2Yrf0ti+Ca6QB4Ox1a7/lkz6OksIiIiIiIiIiI7LMilo1N7OC5tP6/iyWFl0/AClZgetJhc1tozc9EylYmjA1vmr/5IkCxL0S6C5wZbQhvWkB404KEvt7OR5B3+rMJ9wLLJ/LbIhTBtTMBcKbm7TBub4eDaXvlGDZ9fTfVKyYTXDM9npjFMMk67Cayj/kzpln/QgCmNwtndkciJcupXj0NVm9NkptJGeSd8TQOd3L8XmjNzPjhd+kDLqz3fLLnUVJYRERERERERET2aeGohdthktbnLIq/uYdo5QYqf3mPjIOujPdpdcF/sCPV2DYEI1HC0a3JXMOVjGXblIUMcm6aj6t0HqF1s7ECpZhJ6SR3ORJXVvsa87b7/Q/bjcncfFDdjng7HkL73/9AqGQFgWXjCW9aSMkPj4Bt4crtjmObA+kA2l71LdgWhtOzw+e6szvS8bZ5REqXE1z7CxHferBtPLk9Seo4DNOVOL58xhsAJLUfQlLbATuNW/Z8SgqLiIiIiIiIiMg+LRiJJYUNZxLZR93Dpk+up2z8v0gfdDnG5p22SdvU000GqiNRfNWRGofNBcIW4fSeZLTsjdOx41263g5DGiV+d3YH3Nmxw/DMpHSKxvyJjR9fhyM1j7QDTtw6X/uD6vxM0zRxt+hc6wF024r4i6iY/iYAuSf8bReilz2RksIiIiIiIiIiIrJPi1o24aiFy2GSPugyPG0GxRqsEJix3bbhbQ6PA3CYBm6nyS+ryyjyhVi4vpLpK0rp1z6TPm0yaJudTMcWKWQluzCM2g+q2x2yj7gNZ2Z7ooFirKpSLMvapRISdWY6aXfVd+BwkZTfe/fNI01KSWEREREREREREdnnBcJRHA4D03SQ1KZ//L4N+IIRotZv9wTH9GqdwVtTVvDKxGWEozY/ryhNaB/WtQWPndWX/Azv7gw/QXq/s5tsLqc3E6dKRuxzduO3EURERERERERERPYMlg2+6gjVkSjhqEU4ahGMWDtMCAOYhsGFQzvy5uUH0zU3tUb7xMXFjHxiPF/8unZ3hi/SqJQUFhERERERERGR/YJlQ3XYwh+K4g9FCYSjO0wIb6t7yzTevOIgLhhS80C58kCY696eyS3vzaKiOtzYYYs0OiWFRURERERERERE6sDjdHDLMT149oIB5KV5arR/NHMNxz8xnqnLSpohOpG6U1JYRERERERERESkHg7u1IL3rh7KMQUta7StKQtwzguTeWTMfEIRq5bRIs1PSWEREREREREREZF6yvC6ePiM3vzl1ANJ9TgT2mwbnv1hCac/M5FFGyqbKUKR7XPuvIvsi2zbxu/3U1FRQTAYxLbrVj9H9n6RSATbtjEMA6ez/n8ERDYX4q9yGBgYuyFC2WfYUQxiJ/liOJo5mP2EAQ6HE0+Sl6TkVJwuV3NHJCIiIiKyTzMMgxP75NO/fSb3fjqHGSvLEtrnrq3gpCcncNfxPbn4kI4Yhj5Hy57BsJUN3CcEAgEKCwspKCjA6/XusK9t22zcuJGSklh9G5fLhWlq0/j+wrbteFJ4V/4ysm0bywb9PSY7ZW/5HwN9/6Bp2JZNOBKO/XeOQWZOHskpac0d1m5nRoIYWNiYWM6add1EGovWmjQVrTVpKlpr0pT2h/UWtWzenLKCZ75fTKSWw+uGd8/l76P60DI9qRmi23/4fD6i0SgOh4PU1NTmDmePpZ3C+yG/309JSQnJycnk5+fjdrubOyRpQtFoNJ4Udjjqv3szatlELAvT0D5h2QnbZmtSWKulqViWRZXfz4aNGyjbtAGXy43LvW/+o1tEREREZE/iMA0uOaQjQzplc88nc1ha5E9oH7dwE8c9MY6Hz+jNyAPzE9rmravg7Z9WMndtOVWhKMluB71aZ3D+kPb0bJXelC9D9hPaKbyPqM9O4bVr11JeXk6XLl2UEN4PKSksTUZJ4WYVCARYuXIF3tR0MlvkNXc4u9X+sOtE9gxaa9JUtNakqWitSVPa39ZbdTjKk2MX8c7UVbW2jxrYlj+fXMCSTX4e/LKQn5eXAsRL8MVL8QGDOmZxz4kF9GuX2QSR7/20U7hutFN4PxQMBnG5XEoIi4jsw5KSknA5XYSDweYORURERERkv5PkcnD7cT05tGsuf/5sDkW+UEL7B9NX88OCjZQHwkSiW/dr2r/5HWD68lLOeX4yz14wgBE9W+7+4GW/oEKy+yHbtlVDWERkH2cYBqZp6iBREREREZFmNLRLC/5z9VCO6lnzp/eKfCHCUZud/YvdBkIRi9+PnsGsVWW7I0zZDykzKCIisq9S1Q4RERERkWaXmezm0VF9uP+UXqS461/GEbYmhv/6ZWHjBif7LSWFRUREREREREREdiPDMDi5b2vevWooPVqm7dIzbGDa8lLmr69o3OBkv6SksIiIiIiIiIiISBNok+Wld9uMBj3jrSkrGyka2Z8pKSwiIiIiIiIiItJEFm6o3OVKbwZQuE47haXhlBSW3W7eugr+75M5nPHMREY+MY4znpnI/30yZ6/4cQefz0dqaiqGYTBo0KAd9v3hhx8wDIMjjjiiTvebyvLlyzEMI/7L6XTi9XrJy8ujZ8+enHvuubzwwgtUVlZu9xn33Xff1vEOkySXE7fTQVpqCgf2KuDmm29i7dq1uxTf5MmTufDCC+japTMpyV6yMjPo3q0rI487lr888ABz5szZ1ZfeIF27dMbldOByOhg/btx2+23p4/P5Eu4fNWJEvO2NN17f6Ty78jrnzZuHN8nD9ddft8N+r7/+WjyWp59+ut7z7ImWL18ef00up4OJEydut29JSQkpyd543y+/+GK3x/fA/ffjcjp44P77G/ysefPm4XG7uOWWmxshMhERERERaW5VoehOD5fbHhvwByONGY7sp5QUlt1m1qoyRj03ieP/NZ43p6xg5soy5q+vZObKMt6csoKRT4xn1HOT9uiTM99//338fj8A06dPb7YEZWO5+OKLueiiizj33HM57LDD8Hq9fPDBB1x99dW0adOGF198cYfju3TpwkUXXcwFF17EhRddxOGHH86mTZt46sknGTigPwsWLKhXPI8/9hiHDz+Md995B5fLxbHHHstJJ51E69ZtmDx5Mg88cD9vvL79hGpTueeeexo0/sG//IVwONxI0Wx1x+234XK5uPvuP+2w3+uvbX0Pd5Sgbogtye3ly5fvlufvzOjRb2637d133yUUCjVhNI3rgAMO4NzzzuO5Z59l4cKFzR2OiIiIiIg0ULLb0aCdwikeZ2OGI/spJYVltxg7fwNnPz+Z6ctL4/fs3/wOMH15Kec8P5mx8zc0aXx19dprrwHQunXrhK/3Vq+99hqvvPIKr776Kh9++CEzZ85k3bp13HHHHfj9fq666ioeffTR7Y4/9NBDeeXVV3nplVd4+ZVX+eLLr1i0eAnDhx9OUVERd9/1xzrHMmvWLO666484nU7eefdd5s1fwMeffMqbo9/ihx9/ZP2Gjbz73nv069+vEV75rktOTmbSpIl89eWXuzx+2bJlO02419cP33/PmDFjuOzyy8nPz99uv6VLlzJhwnhSUlLIyMhgxj7wzY1tZWdn06lTJz54/32qq6tr7fPGG6/jdrs5sHfvJo6u8fzpT/cQDof5v3t2/A0AERERERHZ8/VoldagncIF+emNGY7sp5QUlkY3a1UZ14yeQThi7fQPORsIRSx+P3rGHrdjeOnSpYwfH0umvfrqqwC89dZbRCL71o9p5Obm8sgjj/DCCy8AcNddd9Vrx296+v+3d+dxUVXvH8A/wzZssoOoiCgKuHzV1FJxAdRMxcIFl2R1qczdsn6puZuW+5K5lKngUm6hYqIp4Jaa+5IKiQJpIBKy7zP39wfO5DgDAo4MMJ/360U599xzz7nMw2V45sxzzTBzZkmi6uTJk+Xut3/fPgiCgMG+vvD1HaLUbmRkhMGDfTFihF+5j/k6jBs3HgAwe85sCELFf23L+n+9eBFyc3PVNq91674FAAQHjyxzv9CQEAiCgIGDBsF3SMn3uTqsvlYXkUgEf/8ApKen4+DBA0rtt2/fxuVLl9C/f39YWVppYIbq4eLigs6d3XHgwAE8fPhQ09MhIiIiIqJXMLidwyv19+vkqKaZkDZjUpjUbuHh2+VKCMvIEsNfHb79OqdVYdu2bYMgCBg0aBB69+4NFxcXJCcnIyIiQq3jnD59GgMGDICdnR0MDAzQoEED+Pv7K63mTExMhJ6eHmxsbFBQUKDyWCkpKRCLxbCwsJCXvSiv0aNHo3PnzpBKpVi1alWF+ta1tweACiXMU56kAADsbO0qNJZMfHw8Jk+ehJYtmsOsjilsrK3Qtm0bfDZtGhISEuT7FRUVYfv2UIx4fzhaNHeDhbkZLMzN0K7dG1i4YMFLv0/vjxiBli1b4vq1a9izZ3eF59m1a1e88847SEpKwrpvv61wf1X++ecfhIeHo2WrVmjbtm2p+wmCIC+rEBgQiMDAIADArl07S32uZLWQT0ZHq2x/sUzEyeho6Ovpyr/nzZo6/1frV19PqZzEwYMH0LfPO7CztYGJsRGaNXXGuHEfKzxnFeUfEACRSITQkBClNlkCPCAgsMxjFBYWYvXq1ejY8S1YWpjDrI4p3nijLb5auFCpXrSMIAjYsGE93nijLeqYmqBB/Xrw9xuB+/fvv3TOZ8+exfBhQ+HY0AHGRoZwaFAf7w8fhmvXrpVxnv6QSCT4Qc2rzomIiIiIqGq51K2Dtg0tKtxPBOBNJ0u42XOlML06JoVJTioV8G92wSt9nY9LxaX4pxX+GIQA4GL8U5y//+8rjS+VVvYDGC/MRxCw7VkyKTg4GEBJPV5AvSUk1q5dCw8PDxw4cABNmzaFr68vbG1tsWPHDnTo0AEHDx6U7+vo6Ih3330X//77L/bs2aPyeJs3b0ZhYSECAwNhYmJS4fmMGDECAHDixIkK9bt48Q8AgFvz5uXu49iw5J3N/fv3ISkpqULjRRw5gjfatsF369YhPz8fffv2ld/Ib9WqlYiOjpLv+/jxY4wMDsaJEydga2sHb29vdO7cGYkJCZg3by569PBCXl5eqWPp6Ohg7rObhc2bOxcSiaRCcwWA+QsWQiQSYdmypcjIyKhw/xf9+uthFBcXw8vLq8z9oqOiEB8fj0aNGsHTywvu7u7yNzeOqunNjbr29gh4Lt4GDRqEgMCSmtMBAYEwNTWV7/t/n3+OwYMGISoqCm3atMXAgQOhr6+P7zdtQof27XDhwoVKzaFJkybo2rUbfvvtNyQnJ8u3SyQS7Ny5A3Z2dujTt2+p/fPy8vBO796Y9ukn+Cs2Fl5eXujbty+S/vkHc+fOQbduXZGamqrUb+zYjzBxwgTE3L2Lbt26wcPDA2fOnEGnjm/h/oPSE8NLlyyBl6cHfvnlFzg4NISPjw8aODhg79696OLeGeGHDqns5+lZ8nwfClfdTkRERERENccnb7vAQE+n3LWFRQAM9HQw07vF65wWaRFWpia5p7mFaL/wuEbnMHzT+Vfqf/nLXrA2Fb/yPKKiopCQkABHR0d54i0wMBCzZs3CoUOHkJaWBiurV/so+rVr1zB16lTo6elh//796N+/v7zt22+/xcSJExEQEIDY2FjUrVsXADB+/HiEhYVhw4YN8Pf3VzieVCqVl4AYO3Zspeb0xhtvAAD++usvFBUVQV9fv8z9nzx5ghMnjmP6F19AJBLh888/L/dYfv7+WLLkGzx8+BBuri7o168f3Lt0Rbt27dC+fXsYGhqq7JeQkID33x+O7OxsLFm6DJMnT4aOzn/vb929e1ehzIO5uTnCwg7gnT59oKf33yUvIyMDAf5+OHLkCNauWYPP/+//Sp3rgAED0aHDm7h06SK2bduKUaNGl/s8AaBdu3YYNGgQ9u3bhxXLl2Pe/PkV6v8iWZmOjh07lrnftmc3lfPz84dIVPJSIyAgELNmfYmQkG3wfi7mKsvNzQ0//rgFp06eRE5ODr5ZshROTk4ljYIAWRXxw+HhWLFiOczNzfHrkQi89dZbAEridsb06Vi+fBlGvD8ct+/chVhc8Z/hgMAAnD59Crt27sTUTz4BAPx27BiSkpIwefIUhef+RXNmz8aZM6fRuk0bHDkSATu7ktXrmZmZGDxoEKKjozBp4gTs3PWTvM+BA2H4cfNmWFlZ4bfjJ9C6dWsAQH5+PoICA7Bj+3aVY/16+DBmzJgOR0dH7Nm7D+3atZO3hR86hCFDfBEcHITYv+4pXWNcXFxgZWWFmzduqOUaREREREREmtOqgTmW+rbGZ3tuoFAiLXNfWUJ4g3/7Sq0wJlKFK4WJVJCtBg549rF0AHBwcEDPnj1RWFiInTt3vvIYa9asgUQiQVBQkEJCGAAmTJgADw8PZGZmKtygrFevXnBzc8PZs2eVyktEREQgPj4eHh4eaNGicu8c2tjYyP+dlpam1L5t2zbo6erAUF8PBnq6qF/PHgH+/rCyssKRIxEYNGhwucdq1KgRwsMPw9nZGbm5udi7dy8+mToFnh7dYW1liYEDfHDu3DmlfqtWrUR2djaCgoMxdepUhYQwUJKkbP7ciuU6derAu39/paSgubk5lq9YCQDY/8v+l8534cKFAICvFi4stXxHWebOmw9dXV2sWbMaT548qXD/5924fh0A4OZW+srs7OxshP3yCwAgIPC/0gn+AQHQ0dFBeHi4yuf4dZGVJPn002nyhDBQshJ74VdfwdnZGYmJidi7V/Uq+Jfx9R0CY2NjhIT+V0Ii9Nm/nz//F+Xl5WHTpo0AgDVr1soTwkBJvez1GzZAV1cX+/btQ2Jiorzt27UlpUA+++xzeUIYAAwNDbH223UwMjJSOd6CBQsAAJs3/6iQEAaA/u++i4/GjkVGRgZ27Nihsr+rqxsEQcDNGzdKPSciIiIiIqoZujWzxQ9BHfDGc4le0Qv/B4AOTpb4+aPO8HKrXPlFIlWYFCZ6QVZWFvbt2wfgv5IRMuosIXHq1CmVY8iMGjUKgPLN28aNGwcA2LBhg8L29evXA6j8KmGgZNWmjCwZ/jxnZ2cEBgbBP6CkPMCAAQPg6uqK2NhYfPrpJ/jzzz8rNF7Xbt1w68/bOHQoHJMmTUbnzu4wMjJCYWEhwsPD4enRXZ6wkzl29CgAYOTIURUa6+LFi1i2dCkmTpyA0aNHYdSokVi06CsAwF+xsS/t37NXL3h6eiExMREbN2586f4vcnNzg39AALKzs/H14sUV7v+8lJSSeszW1tal7rNnz27k5OTA3b0LmjZtKt/u4OAALy8vFBYWYteuXa80j/IqLi7GuXO/A1CdoNXT04O/fwCA/34uKqpOnToYMHAgbt28iatXrz678dxBtG7TBm3atCm13+XLl5GTkwNnZ2d06dJFqb1p06bo1q07pFIpzpw5rXQ+7z8rufI8Ozs7vP3220rbU1NTcenSRdjY2MDjWbmTF3Xr1g0A8McF1Z+asLYuWR0sq8lNREREREQ1W6sG5tgc/CZ+/rAThnRwQKsG5nC2NcEbjhYI6NQIEVO6Yc9Yd64QJrVj+QiiF+zevRu5ublwd3dHs2bNFNoGDRoEMzMzXL58Gbdu3UKrVq0qPc6jR48AAI0bN1bZ3qRJE4X9ZIKCgjBjxgxs374d33zzDUxMTJCYmIhff/0VdnZ2GDRoUKXn9HzdVFUfTe/atSs2/7gFxVIpdEQi+TuX33+/CeM+/hhv9+qJO3djYG5uXu4x9fT00KdvX3nN1/z8fBw7dhQzpk9HTEwMpk6Zgr59+6Fhw4YAIF+t6erqWq7jZ2dnw2/E+/j1119L3SczM7Ncx1qwcCG6de2Cb75ejFGjRinUyy2P2bPnYNfOndi4cQOmTJ0qP6eKSk9PB1CSCC3Ntq3PbrAWGKDUFhgUhBMnTiAkZBvGjx9fqTlUxL///ouCggL5jRRVadyk5OfgnxfivSKCAoOwc8cObA8NhaubK/Lz8196g7l//ikZT17yopS5RUdH4Z9H/wAo+TmRnU/9+vVV9mmk4ngPHjyQ9zfQL/vXb2mryeuYldxQQhYDRERERERUOzSrWwfT+zZHQbEEEABrUzEM9LiWk14fJoVJztLYAJe/7PVKx/j6yF3sufyw0v2HtHfAF33dKt3f0tig0n1lZKuAExIS0LVrV6V22QrarVu3YtmyZa88XkWZmZkhICAA69evx65duzBmzBhs2rQJUqkUo0ePhoFB5b8HV69eBVCScC2rBuuLPvjgQ/zwww+4cvkyQkNDMWHChErPwdDQEO+954MOHd5EczdX5Obm4ujRCIwZ8wEA1SuYyzJjxnT8+uuvaNmyJRYtWoz2HTrAysoK+vr6KCwshImx6o/5q9KpUyf0798f4eHhWLN6NWbMnFmhuTg6OuKDDz/Eum+/xYIF87Fp0/cv76SChYUFUlNTkZmZCQsLC6X2uLg4nD17BgCwceNGhIaEKrQXFJaUv7hSiTc3nl9NXt14enmhYcOG+OmnXXB0bAQ9PT35zROrA9lNCq2srF5az9nNVfV1MPPZjQpVPe9ERERERERE5cWkMMnp6Ihe+SZto7o2fqWk8OhujdVyo7jKiouLw5kzJcm0R48eKa3Sfd6OHTvw9ddfVyh5+rwGDRogLi4O9+/fV7l68v79+/L9XjR+/HisX78eGzZsQFBQEDZv3gwdHR18+OGHlZqLjKycQK9eFX9zoEnjxrhy+TJiY2NeaQ4y9evXh6ubG65euYLUJ/+tYHZ0dERMTAxiY2MVaiCXZv+zUiDbd+xUSn7eu3evwvOaN38BDh8+jBUrluPjZ6U8KmL69BnYumULQkNC8Nln5b8x3/Pq1q2L1NRUpKWlwdHRUak9ZNs2+b+vPUv0lyZk2zYsWbpU/tjAoOTmgtnZ2Ur7FhcXIykpqcLztba2hlgsRkFBAR4+fKhyhfSD+yWraOuXspK4PHR0dODvH4DFixchJSUF/fv3V6gRrEr9+iXjyVbxqvLf3EpWBdvY2MjPJykpSeVq4YT4eKVtsvM2NjbGjz9uKdc5vSgt7SkAwM6WtcSIiIiIiIio8rgOndSqeT0zdHCyRMXWcpYUUH/TyRJu9mavY1rlJlslPHDgQAiCUOpXs2bNkJycjIiIiEqP1b17dwBASEiIyvYtW0qSRh4eHkptLVu2hKenJy5fvoyZM2ciOTkZffv2LfMj8C+zefNmnD9/Hrq6upg8eXKF+8c9S2KbGJuUa39BEMpsl0gkiH+WqGvg8F+isNezWq1bt5YvqSa7mZqqROTPP/1UrmM8r3Xr1hg2bBgyMjKwdMmSCvevW7cuJkyYiOLiYsydM7vC/QGg9bMauXfu3FZqk0ql2L69ZGXw/l9+QVGxROXXyVMl9XF37dqJ4uJief96zxKcsSrqLEdHRSns+zzZCnVV7Xp6eujc2R0AsD00VKldIpFgx47tAP77uaisgMBA2NjYwNraGsEjR750//bt28PExAT379/H2bNnldpL3ig6DR0dHXTtWlLvV09PD506dQYA/KSiLvOTJ09w/Phxpe0NGjRAy1at8PDhQ1y4cKGipwZBEBATcxc6OjryGCAiIiIiIiKqDCaFSe2+9G4BAz2dcieGRQAM9HQw07vF65zWS0mlUnmC1t/fv8x9/fz8ALzaDecmTZoEXV1dbNu2Tane7fr16xEdHQ0zMzOMGTNGZX9ZiYalz1Z5VvYGc6mpqZg+fbp8lfGSJUuUaim/zPffb8LVK1cAAN7e3uXqM3vWLEz79FPcuXNHqS0rKwsfffQhnj59ClNTU/Tp01feNmXKVJiYmGDrli1Yu3atUjmDu3fv4u7du/LHrm4lH8Pf8OxGfDInjh/HypUryneCL5gzdx709PSwbt23leo/7bPPYGFhgT179uDx48cV7i97o0BVYjEqMhKJiYmwtrZW+L69yN3dHY0bN0ZycjKOPvfmhuezG6Bt2LBefkM7oGRV9ZQppb9ZIFtxe1fF8wlA/kbD8uXLcOnSJfl2qVSK2bNm4d69e3B0dISv75BSxyiPZs2aISn5MZIfp8DHZ8BL9zcyMsIHH3z4bI6TFGr5ZmVlYdzHH6O4uBiDBw9WWJU9fkJJLealS5fg1q1b8u0FBQWYPGkicnNzVY43d+5cAECAvx9OvXATSQAlN1k8dEghhmViY2ORlpaG/7VuDUtLy5eeGxEREREREVFpWD6C1K5tQwus92+HsduvoKhYirLWg8oSwhv822v8TpqRz5JpFhYWL01s+vn5Ye7cuTh06BDS0tJU3pTtZdq2bYuVK1di8uTJ8Pb2hru7O5ycnHD79m1cu3YNYrEYISEhsLe3V9nfx8cHDg4OePjwIRo1aoR+/fq9dMzg4GAIggCpVIrs7GwkJCTgxo0bkEgkMDMzw8qVKzFq1KhS+585cwajRo6EVBAgEgFZmZm4c+cOYmJKSkZMmTIVXbt1K9f55+TmYO2aNVi9ehWcnJzQqlUrmNapg8fJj3H58iVkZmZCLBZj848/wtbWVt7PyckJO3bsxIgR7+OTqVOwetVKdOjQARKJBPfi4nDr5k38sHkz3J4lg2fMmIER77+PL7+cib379sLN1RXx8Qk4f/4cPv/8/7BkyTflmu/zmjZtiqDgYGz+4YcK9wVK6sF++uk0zJr1JfLz8yvcv2/fftDV1UV0VJRS27aQktIRvkOGQF9fv8zjDB/+PhYvXoSQkG3yGrfDhg3HihUr8OetW2jT+n9wd3dHRkYm/vjjAnx8fJCfn4+EhASlY/kMGICTJ6MRGBiAt99+G+YWFoAALF68CNbWNuj/7ruYOvUTrFy5Al27uKN7dw/UrWuHK1euIDY2FhYWFtixcxfE4qovHzN/wQJcunQJZ86chpurCzw9PaGvr4+TJ08iNTUVLVu1wpq1im8ADBw4CEHBwdi2dSs6vvUmPD09YWFhgd9//x05OTnw8/fHju3blcYaMGAgFi/+GjNnzkDPnj3QokULNGvWDIaGhnj06B9cu3YV2dnZCA8/LI9hmaioSABAf++y6xETERERERERvQxXCtNr0cOtLnZ/1BkdnP5bzSZ64f8A0MHJEj9/1Blebpqvjylb9TtkyJCXJqaaNm2Kt956C4WFhdi5c2elx5w4cSKio6Px3nvvITY2Vr5ydMSIEbh48SJ8fHxK7aunpydf1fnhhx9CR+flP87btm1DSEgIdu3ahZMnTyI3Nxe+vr7YtGkTHj58WGZCGCj5KH1IyDZsDw1BaEgIDh8+jKysLPj4+CA8/DCWVuDGezNnfonQ7dsRFBwMcwsLXLx4EXv37MGlSxfh1LgxJk2ajOs3bmLQoMFKfb3798flK1fxwbPzPnToEKKjowEAn3zyKby8esj3HTJkKI4ePYauXbsh/sEDhIeHQyqVYsvWrfhq0aJyz/dFX345C4aGhpXuP3HSJNStW7dSfevXr493330Xf/75J648W6ENAJmZmTgQFgYAGDHC76XHef/ZTdjCw8PlZTbEYjGOHfsNQcHB0NHRQUREBJKTkzB37jxsC1Eu/SAzfvx4zJs3Hw0aNMDhw4ex5ccfsWXLj8jKypLvs2TpUuzdtw+enp64evUK9u3bh/z8fIz54ANcvHQZnTp1qsy345UZGRnh6LFjWLpsOZybNsWJEydw+PBh1K1bF3PmzMWZM2dV1q/etOl7rF6zFs1cXHDy5ElERkaiU6dO+P3ceTRp3KTU8aZ99hnOnb+AgMBA5ObmIiIiAkeOHMGTJyno06cPtoWEqHxzZcf2HdDV1cXoUj49QERERERERFReIuFlhT2pRsjLy8Pt27fRokULGBkZlbmv7AZmTZqUnrRQp7vJmdhxPhG3kzKRU1AME7EeWtQzg18nR43XEK7JcnJy0KBBA+Tl5SExMbHcCUaJRAJBECASiaCrq1vhcSVSAcVSKXREogrXjib1iY6Kwttv98LH48ZhzZq1mp6OaoIAQAAgAkSMllcRGxuLli2aY9CgQfh5955y94uPf4BiiQC7Bso3JKxNdIoLIIIUAnQg1dPczUqp9mOsUVVhrFFVYaxRVWK8lU9BsQQQAGtTMQz0uJazMrKzsyGRSKCrqwtTU1NNT6faYvkIeu3c7M2wYEArTU+j1lmxYgUyMjIQGBhY6RWnVHN5enmhT58+2LplC6ZPn4F69eppekr0Gn311ULo6+tjwcKvND0VIiIiIiIiqgX4lgNRDRITE4MxY8agT58+mDNnDoyNjeU3riLts2TpMhQVFWHRIiYKa7M7d+7gp127MPbjj+Hi4qLp6RAREREREVEtwJXCRDVIUlISNm/eDENDQ3To0AFLlixB48aNNT0t0pDmzZsjL79A09Og16x58+YoKCzS9DSIiIiIiIioFmFSmKgG8fT0BMuAExERERERERHRq2D5CCIiIiIiIiIiIiItwqQwERERERERERERkRZhUpiIiKi2YrUZIiIiIiIiUoFJYS0kEokglUo1PQ0iInqNBEGAVCqFSCTS9FSIiIiIiIiommFSWAuJxWIUFRWhsLBQ01MhIqLXJD8/H0XFRdAXizU9FSIiIiIiIqpmmBTWQmZmZgCApKQkJoaJiGoZqVSK7Kws/PPPIwgCYFLHXNNTIiIiIiIiompGT9MToKpnYmICKysrpKWlIS4uDvr6+hCJRPyIsZYQBAGCIFT6ORcEAVIBYLjQSwmy/4gAxsvrJ5T8fBYVF5X8nEMEC9u60DfgSmEiIiIiIiJSxKSwFhKJRLCzs4OJiQkyMzNRUFAAQeDdiLSFRCKRJ4X19Cp+CZBIBRQUS6GnK4KImT4qiyCBCM9ywyJdDU9GS4gAfbERxIZGMDQ2hZ6+vqZnRERERERERNUQk8JaSiQSwdTUFKamppqeClWx7OxsSCQS6OrqVur5zykoRmp2AUzEetDhcmEqg05xAUSQQoAOpHpcrUpERERERERUXbCmMBEREREREREREZEWYVKYiIiIiIiIiIiISIswKUxERERERERERESkRZgU1pCHDx9i1KhRqF+/PsRiMZycnDBlyhQ8ffpU01MjIiIiIiIiIiKiWow3mtOAuLg4uLu7IyUlBT4+PnBzc8Mff/yB1atXIyIiAmfPnoW1tbWmp0lERERERERERES1EFcKa8C4ceOQkpKCNWvWICwsDF9//TUiIyMxdepUxMTEYObMmZqeIhEREREREREREdVSTApXsbi4OBw7dgxOTk4YP368Qtu8efNgYmKC0NBQ5OTkaGiGREREREREREREVJsxKVzFoqKiAAC9e/eGjo7it79OnTro0qULcnNzcf78eU1Mj4iIiIiIiIiIiGo51hSuYjExMQAAFxcXle3NmjXDsWPHEBsbi549e6rcJyUlBU+ePFHYJpFIAADp6enIzc1V44yptpHFCgAUFBRUvL9UgIEgRVGuSJ3TolpIF4L835KCfA3OhGo7xhpVFcYaVRXGGlUVxhpVJcZbeQkQQYTM9FyI+Gd3pbxq3qMmMzY2hlgsVlqIqgqTwlUsIyMDAGBubq6yXbY9PT291GN89913mDdvnsK27t27Y8WKFfjnn3/UM1EiIiIiIiIiIiKqUVq0aAEjI6OX7sekcA00btw4DBkyRGGbVCpFnTp1YGtrW653A0h73bt3DwMGDEBYWBiaNm2q6elQLcZYo6rCWKOqwlijqsJYo6rCWKOqxHijqqLtsSYWi8u1H5PCVUy2Eli2YvhFsu0WFhalHsPOzg52dnZqnxtpBx0dHdy/fx86OjrleueIqLIYa1RVGGtUVRhrVFUYa1RVGGtUlRhvVFUYa+XDJaVVzNXVFQAQGxursv2vv/4CUHrNYSIiIiIiIiIiIqJXwaRwFfPy8gIAHDt2DFKpVKEtKysLZ8+ehbGxMTp16qSJ6REREREREREREVEtx6RwFXN2dkbv3r0RHx+PdevWKbTNmTMHOTk5CAgIgImJiYZmSERERERERERERLUZawprwHfffQd3d3dMmjQJJ06cQPPmzXHhwgVERUXBxcUFX331laanSLWYra0t5syZA1tbW01PhWo5xhpVFcYaVRXGGlUVxhpVFcYaVSXGG1UVxlr5iARBEDQ9CW30999/Y/bs2YiIiMC///6LevXqYeDAgZgzZw4sLS01PT0iIiIiIiIiIiKqpZgUJiIiIiIiIiIiItIirClMREREREREREREpEWYFCYiIiIiIiIiIiLSIkwKExEREREREREREWkRJoWJiIiIiIiIiIiItAiTwkQ1xMOHDzFq1CjUr18fYrEYTk5OmDJlCp4+fVrhY125cgUjRoyAg4MDxGIx6tatCw8PD4SEhCjtKxKJSv3q1KmTOk6NqplXjbXo6Ogy40b29ffffyv1vX37NoYOHQo7OzsYGhrC1dUVc+bMQV5enrpPk6oBTcUar2vaR12/Q8+cOQMfHx84OTnB0NAQjo6O6NevHyIiIkrtw+ua9tFUvPHapn3UFWv79u2Dp6cnzM3NYWRkhJYtW2Lx4sUoLCwstc/vv/+Ofv36wcrKCkZGRmjdujVWrVoFiUTyqqdF1ZAmYi0+Pr7M69rw4cPVdXpUDezduxcTJ05Et27dYGZmBpFIBH9//0odqzLxqq2v10SCIAiangQRlS0uLg7u7u5ISUmBj48P3Nzc8McffyAqKgqurq44e/YsrK2ty3Wsb7/9FpMnT4alpSW8vb3RoEEDpKWl4datW3BwcMBPP/2ksL9IJEKjRo0QHBysdCwHBweMGTNGHadI1YQ6Yi0+Ph5bt25V2Xbz5k3s378frVq1ws2bNxXaLly4gB49eqCoqAi+vr5o2LAhIiMjcenSJXTp0gUnTpyAWCxW16mShmky1nhd0y7q+h26fv16jBs3DiYmJhg4cCAcHBzw8OFD7N+/H7m5uVi4cCFmzpyp0IfXNe2jyXjjtU27qCvWZsyYgcWLF8PU1BSDBw+GlZUVTp8+jUuXLqFnz544cuQI9PX1FfocOHAAgwcPhqGhIYYNGwYrKyscOnQIMTEx8PX1xZ49e17XaZMGaCrW4uPj0bhxY7Rp0wYDBgxQOl6rVq3g6+urzlMlDWrbti2uX78OU1NTODg44O7du/Dz88P27dsrdJzKxKtWv14TiKja6927twBAWLNmjcL2qVOnCgCEjz76qFzHOXr0qCASiYTevXsLmZmZSu2FhYVK2wAIHh4elZo31TzqirXSDB8+XAAgrF69WmF7cXGx0Lx5cwGAcODAAfl2iUQiDB48WAAgLF68+JXGpupFU7EmCLyuaRt1xFphYaFgbm4uGBoaCnfv3lVou337tiAWiwUjIyMhPz9fvp3XNe2kqXgTBF7btI06Yu3y5csCAMHCwkKIi4uTb5dKpcLYsWMFAMLy5csV+mRkZAi2traCgYGBcPHiRfn2vLw8oXPnzgIAYdeuXa94dlSdaCrWHjx4IAAQgoKC1HIeVL1FRkYKsbGxglQqFaKiogQAgp+fX4WPU9F41fbXa0wKE1Vz9+7dEwAITk5OgkQiUWjLzMwUTExMBGNjYyE7O/ulx2rdurVgbGwspKamlnt8/oGhPdQZa6o8efJE/ofs06dPFdpOnDghABC6d++u1C8uLk4AIDRq1EiQSqWVGpuqF03GmiDwuqZN1BVrycnJAgChdevWKtv/97//CQAUfr/yuqZ9NBlvgsBrmzZRV6zNmjVLACBMmzZNqS0tLU0AIDRp0kRh++bNmwUAQmBgoFKfsq57VDNpMtaYFNZelU0KVyZetf31GmsKE1VzUVFRAIDevXtDR0fxR7ZOnTro0qULcnNzcf78+TKPc+vWLdy4cQO9e/eGlZUVoqKisGzZMixfvhwnTpyAVCottW96ejp+/PFHLFq0COvWrXvpWFQzqSvWSrNt2zYUFBRgyJAhsLCwUGiLjIwEAPTp00epX5MmTeDi4oKEhATcv3+/UmNT9aLJWJPhdU07qCvW7OzsYGtri9jYWPz1118KbbJtbdu2Vfg4Iq9r2keT8SbDa5t2UFesJScnAyi5Jr3I0tISlpaWuH//Ph48eCDfXta1rXv37jA2Nsbvv/+OgoKCip0UVUuajDWZf/75Bxs3bsSiRYuwceNG3Lhxo7KnQ7VcZeJV21+vMSlMVM3FxMQAAFxcXFS2N2vWDEDJHwlluXjxIoCSPzQ8PT3Ro0cPfPbZZ5g2bRp69eqFtm3b4t69eyr7Xr9+HaNHj8bMmTMxYcIEdO7cGW3btlWq00k1m7pirTTff/89AOCjjz6q8rGpetFkrMnwuqYd1BVrIpEI69atg1QqRfv27REUFITp06cjMDAQ7du3R8uWLZVqaPK6pn00GW8yvLZpB3XFmo2NDQCoTMSlp6fLb8okG+9lY+vp6aFx48YoLi6utQkUbaPJWJP57bffMHbsWMycORNjx45FmzZt4OXlhcTExPKfCGmFysSrtr9eY1KYqJrLyMgAAJibm6tsl21PT08v8zgpKSkAgM2bNyM+Ph6HDx9GRkYGYmNj4e/vj5s3b8Lb21vpzq+ffPIJzp49iydPniArKwsXL16Er68vrl+/jh49euDRo0eveIZUXagr1lQ5efIkYmJi0KpVK7i7u1fp2FT9aDLWAF7XtIk6Y23IkCGIjIyEhYUFQkJC8PXXXyM0NBQmJiYYOXKk0uonXte0jybjDeC1TZuoK9a8vb0BlLyZGh8fL98uCILCjQxlCTt1jk01gyZjzdjYGLNmzcLly5fx9OlTPH36FCdPnoSXlxeio6PRs2dP5OTkVOa0qJaqTLxq+zWNSWEiLSErDyGRSPDTTz+hX79+MDMzQ7NmzRASEoIOHTogNjYW+/btU+i3fPlyuLu7w8bGBqampujQoQP27NmDwYMHIzU1FcuWLdPE6VANs2nTJgDAhx9+qOGZUG1XnljjdY0qY/v27ejVqxe6deuGO3fuIDc3F3fu3EHPnj0xYcIEDB8+XNNTpFqkMvHGaxtVVJcuXTB69Gikp6ejdevWGDlyJD799FN07NgRmzdvhpubGwAofQybqKIqE2t2dnaYP38+2rVrBwsLC1hYWKB79+44duwYOnbsiHv37uGHH37Q1CkR1Qq8uhNVc7J3pmTvYL1Itr20upkysnZ7e3t07txZoU0kEsHHxwcA8Mcff5RrXmPHjgUAnDp1qlz7U/Wnrlh7UVpaGvbt2wcjIyMEBARU6dhUPWky1srC61rto65Yi42NxahRo9CyZUuEhobCzc0NRkZGcHNzQ2hoKNq3b489e/YgOjpa7WNTzaHJeCsLr221jzqvL99//z02btwIV1dX7N69Gxs3boSZmRmio6Ph7OwMoCQ59zrGpupPk7FWGj09PYwZMwYAr2ukqDLxqu3XNCaFiao5V1dXAKXXsJHdgKS0GjgvHqe0i5mlpSUAIC8vr1zzsrW1BQB+ZKcWUVesvUh206+hQ4eWGn+va2yqnjQZa2Xhda32UVesHTt2DEVFRfDw8FBaMaejo4Pu3bsDAC5fvqz2sanm0GS8lYXXttpHndcXkUiEDz/8EBcvXkROTg6ys7Nx/PhxdOrUCTdv3oSOjg7atWtXrrGLi4vx4MED6OnpqSxxQjWPJmOtLLyukSqViVdtf73GpDBRNefl5QWg5A8EWQkImaysLJw9exbGxsbo1KlTmcfp1KkTTExMEB8fr/KX561btwAAjRs3Lte8ZHfs5Au+2kNdsfYi2U2/yvo4f48ePQAAERERSm33799HbGwsGjVqxHirJTQZa2Xhda32UVesFRQUAACePHmisl223cDAQL6N1zXto8l4KwuvbbXP6/o9+rzo6GgkJibC29tbodZmWde2U6dOITc3F+7u7hCLxZUem6oPTcZaWXhdI1UqE69a/3pNIKJqr3fv3gIAYc2aNQrbp06dKgAQPvroI4Xtd+7cEe7cuaN0nEmTJgkAhClTpghSqVS+/caNG4KhoaGgp6cn3Lt3T779+vXrQmFhodJxrl+/LlhbWwsAhB07drzq6VE1oq5Ykzl16pQAQGjVqlWZ4xYXFwvNmzcXAAgHDhyQb5dIJIKvr68AQFi8eHElzoiqK03FGq9r2kcdsXbhwgUBgGBkZCRcv35doe3q1auCoaGhIBKJhFu3bsm387qmnTQVb7y2aR91/R7NyMhQ2hYfHy84OzsLBgYGSjGYkZEh2NjYCAYGBsLFixfl2/Py8oTOnTsLAIRdu3a9yqlRNaOpWLt8+bIgkUiU+hw/flwQi8UCAOHs2bOVOSWq5qKiogQAgp+fn8r2wsJC4c6dOwq5C5mKxqu2v14TCYIgvPbMMxG9kri4OLi7uyMlJQU+Pj5o3rw5Lly4gKioKLi4uOD333+HtbW1fH+RSASg5G6uz8vMzISHhweuXbuGjh07okuXLnj8+DH279+PvLw8rFq1CpMnT5bvHxwcjEOHDqFbt25o2LAhxGIx7t69i4iICEgkEnzwwQfYuHGjfDyq+dQVazIBAQHYvn071qxZg4kTJ5Y59oULF9CjRw8UFRXB19cXjo6OOHHiBC5duoQuXbrgxIkTXHVSi2gq1nhd0z7qirVRo0Zhy5YtMDAwwMCBA9GoUSPEx8cjLCwMhYWFmDJlClauXKnQh9c17aOpeOO1TfuoK9aGDBmChIQEtGvXDlZWVnjw4AEOHjyIoqIihIaGYtiwYUpjh4WFwdfXF4aGhhg+fDisrKxw8OBBxMTEwNfXF7t372as1SKaijVPT0/89ddfcHd3h4ODAwDgxo0biIyMBAAsWLAAX3755es8dapCYWFhCAsLAwAkJyfj6NGjaNKkCbp16wYAsLGxkd8wNT4+Ho0bN5b/bnxeReMV0PLXaxpLRxNRhSQmJgrBwcGCvb29oK+vLzg6OgqTJ08W0tLSlPYFIJT2452VlSXMmDFDaNasmWBgYCCYm5sLb7/9tnD06FGlfX/55Rdh4MCBgrOzs1CnTh1BX19fsLe3F/r376/wLhrVLuqKtbS0NMHQ0FAwMjISnj59Wq6x//zzT8HX11ewtrYWDAwMhGbNmgmzZ88WcnNzX+WUqJrSRKzxuqad1BFrUqlU2LJli+Dh4SFYWFgIurq6gqWlpdCjR48yV8XxuqZ9NBFvvLZpJ3XE2tatWwV3d3fByspK0NfXFxwcHITAwEDh9u3bZY595swZoW/fvoKFhYVgaGgotGrVSlixYoVQXFystvOj6kMTsfbDDz8I3t7eQqNGjQQTExPBwMBAaNiwoTB06FDh1KlTaj9H0qw5c+bIY0fVV6NGjeT7PnjwQGnb8yoSrzLa+nqNK4WJiIiIiIiIiIiItAhvNEdERERERERERESkRZgUJiIiIiIiIiIiItIiTAoTERERERERERERaREmhYmIiIiIiIiIiIi0CJPCRERERERERERERFqESWEiIiIiIiIiIiIiLcKkMBEREREREREREZEWYVKYiIiIiIiIiIiISIswKUxERERERERERESkRZgUJiIiIiIiIiIiItIiTAoTERERERERERERaREmhYmIiIiIiIiIiIi0CJPCRERERERERERERFqESWEiIiIiIiIiIiIiLcKkMBEREREREREREZEWYVKYiIiIiIiIiIiISIswKUxERERERERERESkRZgUJiIiIiIiIiIiItIiTAoTERERERERERERaREmhYmIiIiIiIiIiIi0CJPCRERERETV1Ny5cyESieRfwcHBCu1bt25VaPf09NTIPImIiIioZmFSmIiIiIiqNScnJ4XE5/NfhoaGqFevHnr06IElS5YgPT1d09OtdYqKipCUlITc3NzXcuzw8HDMnj0bffv2hY2NjdJzXB6CIODnn3/Ge++9h/r160MsFsPW1hZdu3bF8uXLkZeXp/a5ExEREdVkepqeABERERFRZRUUFCA5ORnJycmIiorC8uXLcfToUbRt21bTU6vRTp06hZ07dyIiIgKJiYkQBAEAYGZmhnbt2mHw4MEYNmwYbG1tX2mcR48e4d13332lY2RlZWHAgAGIjIxU2J6amorU1FScPXsW3377LSIiIuDq6vpKYxERERHVFlwpTEREREQ1iomJCerWrQtLS0ultpSUFLz//vvyJCZVzJ07d9CzZ094eHhg48aNSEhIUPheZmZmIjo6GhMnTkTTpk2xZs0aSCQSjc1XEAQMGjRIKSFsbm4OHZ3//tSJj4+Hl5cX0tLSqnqKRERERNUSk8JEREREVKNMmzYNycnJSEtLQ0pKCnx8fBTa7969iytXrmhodjXXgQMH0LFjR0RGRsLAwACBgYEICwvD33//jYKCAvz777+4fv06vvnmG7Rs2RKZmZmYPHkyhg4diuLi4kqNaWBggD59+mDWrFk4ePAgzp07V6H+O3fuxPHjx+WPLSwscO7cOaSnp+Pvv/9Gu3bt5G1JSUmYOXNmpeZJREREVNswKUxERERENZatrS2WLVumtD0uLq7UPkePHoWfnx+cnZ1hYmICIyMjODs7Y+TIkbh8+XKZ4wmCgCNHjsDf3x8uLi4wMzODWCyGg4MDvLy88NVXXyEjI0O+f15eHtatW4fRo0ejQ4cOcHR0hKmpKQwMDGBra4suXbpg7ty5SEpKqvw3QQ2ioqIwZMgQZGVloWPHjrh79y62bdsGHx8fODg4wMDAAFZWVmjdujU+//xzXL9+HWvWrIG+vj72798Pf3//So1bv359HDlyBPPnz8e7774Le3v7CvX/7rvvFB5/+umn6NSpk/zYq1atUmgPDQ1FVlZWpeZKREREVJuwpjARERER1WgODg5K24yNjZW2paenw8/PD7/++qtS2/3793H//n1s3boV06dPx6JFi5T2SU5OxogRIxAVFaXU9ujRIzx69AjR0dHw9vaW1zR+/PgxJkyYoHLespq3v//+O1avXo1Dhw6ha9euLztdtUtNTYWvry+KioowYMAA7Nq1C4aGhvL2nJwcFBcXw9zcHADw8OFDAMDo0aPRqFEjDB48GD///DO8vb0REBBQZfPOyspSWlncq1cvhcfu7u4wMjKS32guJycHp0+fRr9+/apsnkRERETVEVcKExEREVGN9uKqYJFIhBYtWihsk0qlGDBggFJCWCwWKyRAAWDx4sX4+uuvFbbl5uaid+/eKhPCpqamSscojbGxMWxsbGBkZKSwPT09HUOHDkV+fn65jqNOCxcuRFpaGpo0aYKQkBD5uVy4cAGdO3eGqakpLCws0K5dO1y9ehUNGzZEw4YNsXv3brz33nuYMWMGAGDBggVVWsv5+vXrSuM1adJE4bGuri4cHR0Vtl27du11T42IiIio2mNSmIiIiIhqpKKiIty6dQvjx49X2P7ee+8pJQe3b9+OkydPyh/b2tri2LFjyMvLQ25uLvbt2wexWCxvnzdvnkJJhxUrVuDmzZsKxxw9ejQSEhKQlZWF3NxcXLt2DWPHjoW+vr58HysrK+zatQv37t1DUVERcnJy8OTJE+Tm5iI+Ph4eHh7yfZOSknD48OFX+6ZUUF5eHr7//nsAwPLly1GnTh0AwJUrV+Dl5YXz58/L97169apS/WagpGSDkZER/vrrryqt5fzkyROlbapuPvjitpSUlNc2JyIiIqKagklhIiIiIqpR5s2bB5FIBAMDA/zvf/9TSPb26NEDISEhSn22b9+u8Pibb77B22+/DZFIBJFIhEGDBimUPsjPz8fu3bvlj0NDQxX6+/j44IcffpCvQhWJRGjTpg3Wr1+Pli1byvczMzODj48PoqKi4Ofnh7Zt28LJyQn16tVDx44dcenSJYXjvvj4dTtx4gRyc3Nhb2+P/v37y7dPnjwZeXl50NfXx7Zt25CRkYGwsDCkpaUpHcPMzAwdO3YEULXzz8nJUdqmp6dcHe/5JD0AZGdnv7Y5EREREdUUrClMRERERLXC0KFDERoaCgMDA6W2q1evKjweNWoURo0aVebx/vjjDwAlpSNiY2MV2saMGVOuOcXExOCdd95BQkJCufb/999/y7Wfusi+L127dpUnVFNSUnDmzBkAwPDhwxEYGAigJBE+ceJEpdIaAFCvXj0AVTt/ExMTpW1FRUVKz39RUZHCY1NT09c6LyIiIqKagCuFiYiIiKhGMTExgZ2dndKq0N27d8PT0xO5ublKfdLT0ys8jqw8wdOnT5XaXqxTW5qgoKByJ4QBoLCwsNz7qkNycjIAxfO5f/++/N9vvvmmwv6dO3dWeZzU1FQAkJefqAq2trZK21Q9Vy+ubrazs3ttcyIiIiKqKZgUJiIiIqIaZdq0aXj8+DFyc3Oxdu1a6OrqytvOnTuHSZMmKfWxsLBQeGxtbY26deuW+SVbUaqqTm1iYuJL55mYmIgLFy4obJs/fz6SkpIgkUggCAK++OKL8pzya6Ojo/zngEgkkv9bIpEotBUXFyvtX1hYiOvXrwOAQumM161NmzYKcwWUbzookUiUnqu2bdu+7qkRERERVXtMChMRERFRjaSvr48JEybg008/Vdj+448/4uLFiwrbXkwErly5EsnJyWV+7du3DwBgbGwMFxcXpTFe5uHDhwqPLS0tMWvWLNjb28uTsbIyDZoiK/vwfOLUxcVFnmw9deqUwv7P12+WWbt2LVJSUlCvXj107dr1Nc5WUZ06dZRWLh8/flzh8ZkzZ5Cfny9/bGxsXKVzJCIiIqqumBQmIiIiohpt9uzZCiUBBEHAzJkzFfbx8/NTeDx58mT8/PPPCgnDzMxMnD59GnPmzIGbm5tC2QdZXV2ZX375BWPHjlVI/P7555+YOHEibt26BUB5hfHTp08RFhYGoOQmaZ9//rnGk8Lt27cHAERGRspXBVtaWqJPnz4AgLCwMCxevBh37tzBhg0bsGHDBnnfuLg4fPbZZ/jss88AACtWrFBZz/l1+vjjjxUer1y5EufOnQMAPHr0CFOmTFFo9/f3h5mZWVVNj4iIiKjaEgmCIGh6EkREREREpXFyclJI0M6ZMwdz585V2Gf16tVKCcDo6Gh4eHgAKCkj4OXlhdOnTyvsIxKJYGFhgaKiImRnZyu0PXjwAE5OTgBKbjbXqVMn3Lx5U2l+pqamkEgkyMvLA1By87a2bdtCEAQ4OzvjwYMHSvvn5uZCKpXC2NhYoQZyUFAQtm7dKn88d+5czJs3r9T2rVu3YuTIkfLHHh4eiI6OVppjaQoKCmBra4usrCzs2LEDI0aMAADcu3cPHTt2VKrH6+rqipiYGIVtYrEYq1atwtixY8s97vPs7e3l/5ZIJPL6xDJ169aV/7thw4YKq8AFQUDPnj0RFRWl0Mfc3BxZWVmQSqUK49y6dQvW1taVmicRERFRbcKVwkRERERU440dO1bp5m/PrxbW1dXFwYMH4e3trbCPIAh4+vSpUkJYLBYrrHo1NjbGsWPH4OnpqTR2dna2PCH8PJFIhO+++w76+vpK+0ulUnTu3BkTJ04s9zm+DmKxGOPGjQMAzJgxQ36jtqZNm+L8+fMYPHgwzM3NYWJigj59+uDQoUPQ0dGBhYUF3nrrLXzxxRe4e/dupRPCAPD48WP514sJ4RfbZTf/kxGJRPjll1/kyX+ZjIwMhYSwo6MjIiMjmRAmIiIieoZJYSIiIiKq8cRiMWbPnq2w7ezZszhy5Ij8sYWFBcLDw/Hbb78hKCgIrq6uMDU1ha6uLszNzdGmTRsEBQUhJCQEjx8/Rv369RWOZ29vj8jISISHh2PEiBFwdnaGiYkJDAwMUL9+fXh4eGDBggVo3LixvE+fPn1w6tQp9O3bF2ZmZjA0NETz5s0xf/58REVFwdDQ8PV+Y8rhiy++gL29PRISEjBo0CB5grxZs2bYu3cv0tPTkZ2djSNHjqBZs2aQSCR4+vQpzp8/j8WLF8tXU2uKubk5oqKisHPnTnh7e8Pe3h76+vqwsrKCu7s7li5dijt37qB58+YanScRERFRdcLyEUREREREWu7ChQvw9PREfn4+WrZsiS1btuDNN98sdf+EhASMGTMGwcHBSvWaiYiIiKj6Y1KYiIiIiIgQGRmJYcOGyUs49O7dGz4+PnjjjTdgY2ODzMxM3L59G4cPH8a+fftQXFwMOzs7xMfHw8jISMOzJyIiIqKKYFKYiIiIiIgAAImJiZg2bRr27t2Ll/2Z0LFjR3z33Xdo165dFc2OiIiIiNSFSWEiIiIiIlJw+/Zt7NmzB7/99hsePHiA1NRUmJiYwNHREd27d8fw4cPh7u6u6WkSERERUSUxKUxERERERERERESkRXQ0PQEiIiIiIiIiIiIiqjpMChMRERERERERERFpESaFiYiIiIiIiIiIiLQIk8JEREREREREREREWoRJYSIiIiIiIiIiIiItwqQwERERERERERERkRZhUpiIiIiIiIiIiIhIizApTERERERERERERKRFmBQmIiIiIiIiIiIi0iJMChMRERERERERERFpESaFiYiIiIiIiIiIiLTI/wMlT23pibX8eQAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "name": "scann_on_alloydb_glove_100_angular.ipynb", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "version_major": 2, + "version_minor": 0, + "state": { + "bb2bb0d3c235439a8dd8b8cb9f544191": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f0d4e9e968724c098b56d8733e8cb42a", + "IPY_MODEL_9b904fc7fefd4ed2b7282dfff26e8244", + "IPY_MODEL_631658ca63714d60a1cfadf61adde2f3" + ], + "layout": "IPY_MODEL_78d279973dad446b9b85635c724c0455" + } + }, + "f0d4e9e968724c098b56d8733e8cb42a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a224f47dfa8d40cfaafd52c30741db33", + "placeholder": "​", + "style": "IPY_MODEL_eb975b210f304ea6a2d9ae8081e46a75", + "value": "Inserting 1,183,514 Training Records: 100%" + } + }, + "9b904fc7fefd4ed2b7282dfff26e8244": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e510a1e31be54e3b82832f1047768ad1", + "max": 237, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1a928fcb6f964fdca0fe3d08b5141224", + "value": 237 + } + }, + "631658ca63714d60a1cfadf61adde2f3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0cde9f71448f40ba9f33d63d97f25bbf", + "placeholder": "​", + "style": "IPY_MODEL_5038b51e1d454b5e85f92bc905c9e5c3", + "value": " 237/237 [02:47<00:00,  1.71it/s]" + } + }, + "78d279973dad446b9b85635c724c0455": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a224f47dfa8d40cfaafd52c30741db33": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb975b210f304ea6a2d9ae8081e46a75": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e510a1e31be54e3b82832f1047768ad1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a928fcb6f964fdca0fe3d08b5141224": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": "#1f77b4", + "description_width": "" + } + }, + "0cde9f71448f40ba9f33d63d97f25bbf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5038b51e1d454b5e85f92bc905c9e5c3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f1b3c48bca840a9ade73b114aa97033": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bd95243e64284400ae94adda764dd676", + "IPY_MODEL_4211e3547ca54b80ab8bd83cd18205ed", + "IPY_MODEL_722cad3215fe4f8aac048fe76301f882" + ], + "layout": "IPY_MODEL_e1d193b7e60f4914a5477d618b1d2ec5" + } + }, + "bd95243e64284400ae94adda764dd676": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a6cad141bb543ff85abe1752e92f1f0", + "placeholder": "​", + "style": "IPY_MODEL_42ece952d02b44c49a521f7181d6d039", + "value": "Inserting 10,000 Test Queries: 100%" + } + }, + "4211e3547ca54b80ab8bd83cd18205ed": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7cae70365604497db1f33470ca3e329f", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1f96e9c7b40e41f4882af89dae656820", + "value": 2 + } + }, + "722cad3215fe4f8aac048fe76301f882": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4510043017864ff8ad0e38e33494b5fe", + "placeholder": "​", + "style": "IPY_MODEL_6f0d2aada81f42e3b645ba0c78f6f2dc", + "value": " 2/2 [00:01<00:00,  1.56it/s]" + } + }, + "e1d193b7e60f4914a5477d618b1d2ec5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a6cad141bb543ff85abe1752e92f1f0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42ece952d02b44c49a521f7181d6d039": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7cae70365604497db1f33470ca3e329f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f96e9c7b40e41f4882af89dae656820": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": "#1f77b4", + "description_width": "" + } + }, + "4510043017864ff8ad0e38e33494b5fe": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f0d2aada81f42e3b645ba0c78f6f2dc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7489eb0b544467794893578b208fc30": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2009e650f2e544d2bd1a87bdb80f4f17", + "IPY_MODEL_4b014493a650429295b29f5e860c5cf8", + "IPY_MODEL_25d9691c62b745148f36c3923f457e00" + ], + "layout": "IPY_MODEL_1dd50d6fd07449ddbe838f17bf04d557" + } + }, + "2009e650f2e544d2bd1a87bdb80f4f17": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_452d933c977342b9b7809a62bcb7114d", + "placeholder": "​", + "style": "IPY_MODEL_66b1ecc6a2ee4e9ab9186b4af0ee5fa0", + "value": "Benchmarking ScaNN Auto Search (% Leaves): 100%" + } + }, + "4b014493a650429295b29f5e860c5cf8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd57d3e0dfa84249a220d1472a88dfdc", + "max": 7, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_79c81933da0c4dcfa8a2130f77c1a281", + "value": 7 + } + }, + "25d9691c62b745148f36c3923f457e00": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e956f439a7ef4b16a5a01b6c3968920b", + "placeholder": "​", + "style": "IPY_MODEL_32f09bc5af3e4bfebd4abd146656b47a", + "value": " 7/7 [00:32<00:00,  4.94s/it]" + } + }, + "1dd50d6fd07449ddbe838f17bf04d557": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "452d933c977342b9b7809a62bcb7114d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "66b1ecc6a2ee4e9ab9186b4af0ee5fa0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dd57d3e0dfa84249a220d1472a88dfdc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "79c81933da0c4dcfa8a2130f77c1a281": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": "#1f77b4", + "description_width": "" + } + }, + "e956f439a7ef4b16a5a01b6c3968920b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "32f09bc5af3e4bfebd4abd146656b47a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + } + }, + "nbformat_minor": 5, + "nbformat": 4 +} \ No newline at end of file