diff --git a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb
index 44eb6ce4..0370de04 100644
--- a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb
+++ b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb
@@ -30,7 +30,7 @@
    "source": [
     "### Data pipelines\n",
     "\n",
-    "To be a bit more precise, we are going to be looking at three different data pipelines:\n",
+    "There are two possible pipelines: one with `ServiceX` enabled, and one using only `coffea` for processing.\n",
     "![processing pipelines](utils/processing_pipelines.png)"
    ]
   },
@@ -54,16 +54,15 @@
     "import os\n",
     "import time\n",
     "\n",
-    "import vector; vector.register_awkward()\n",
-    "\n",
     "import awkward as ak\n",
     "import cabinetry\n",
     "from coffea import processor\n",
-    "from coffea.processor import servicex\n",
     "from coffea.nanoevents import transforms\n",
     "from coffea.nanoevents.methods import base, vector\n",
     "from coffea.nanoevents.schemas.base import BaseSchema, zip_forms\n",
+    "from servicex import ServiceXDataset\n",
     "from func_adl import ObjectStream\n",
+    "from func_adl_servicex import ServiceXSourceUpROOT\n",
     "import hist\n",
     "import json\n",
     "import matplotlib.pyplot as plt\n",
@@ -100,26 +99,7 @@
     "| `1000` | 2249 | 3.57 TB |\n",
     "| `-1` | 2269 | 3.59 TB |\n",
     "\n",
-    "The input files are all in the 1–2 GB range.\n",
-    "\n",
-    "Some files are also rucio-accessible (with ATLAS credentials):\n",
-    "\n",
-    "| dataset | number of files | total size |\n",
-    "| --- | --- | --- |\n",
-    "| `user.ivukotic:user.ivukotic.ttbar__nominal` | 7066 | 1.46 TB |\n",
-    "| `user.ivukotic:user.ivukotic.ttbar__scaledown` | 902 | 209 GB |\n",
-    "| `user.ivukotic:user.ivukotic.ttbar__scaleup` | 917 | 191 GB |\n",
-    "| `user.ivukotic:user.ivukotic.ttbar__ME_var` | 438 | 103 GB |\n",
-    "| `user.ivukotic:user.ivukotic.ttbar__PS_var` | 443 | 100 GB |\n",
-    "| `user.ivukotic:user.ivukotic.single_top_s_chan__nominal` | 114 | 11 GB |\n",
-    "| `user.ivukotic:user.ivukotic.single_top_t_chan__nominal` | 2506 | 392 GB |\n",
-    "| `user.ivukotic:user.ivukotic.single_top_tW__nominal` | 50 | 9 GB |\n",
-    "| `user.ivukotic:user.ivukotic.wjets__nominal` | 10199 | 1.13 TB |\n",
-    "| total | 22635 | 3.61 TB |\n",
-    "\n",
-    "The difference in total file size is presumably due to the different storages, which report slightly different sizes.\n",
-    "\n",
-    "When setting the `PIPELINE` variable below to `\"servicex_databinder\"`, the `N_FILES_MAX_PER_SAMPLE` variable is ignored and all files are processed."
+    "The input files are all in the 1–2 GB range."
    ]
   },
   {
@@ -134,21 +114,19 @@
     "# input files per process, set to e.g. 10 (smaller number = faster)\n",
     "N_FILES_MAX_PER_SAMPLE = 5\n",
     "\n",
-    "# pipeline to use:\n",
-    "# - \"coffea\" for pure coffea setup\n",
-    "# - \"servicex_processor\" for coffea with ServiceX processor\n",
-    "# - \"servicex_databinder\" for downloading query output and subsequent standalone coffea\n",
-    "PIPELINE = \"coffea\"\n",
-    "\n",
-    "# enable Dask (may not work yet in combination with ServiceX outside of coffea-casa)\n",
+    "# enable Dask\n",
     "USE_DASK = True\n",
     "\n",
-    "# ServiceX behavior: ignore cache with repeated queries\n",
+    "# enable ServiceX\n",
+    "USE_SERVICEX = False\n",
+    "\n",
+    "# ServiceX: ignore cache with repeated queries\n",
     "SERVICEX_IGNORE_CACHE = False\n",
     "\n",
     "# analysis facility: set to \"coffea_casa\" for coffea-casa environments, \"EAF\" for FNAL, \"local\" for local setups\n",
     "AF = \"coffea_casa\"\n",
     "\n",
+    "\n",
     "### BENCHMARKING-SPECIFIC SETTINGS\n",
     "\n",
     "# chunk size to use\n",
@@ -193,8 +171,6 @@
    },
    "outputs": [],
    "source": [
-    "processor_base = processor.ProcessorABC if (PIPELINE != \"servicex_processor\") else servicex.Analysis\n",
-    "\n",
     "# functions creating systematic variations\n",
     "def flat_variation(ones):\n",
     "    # 2.5% weight variations\n",
@@ -214,7 +190,7 @@
     "    return ak.unflatten(resolution_variation, counts)\n",
     "\n",
     "\n",
-    "class TtbarAnalysis(processor_base):\n",
+    "class TtbarAnalysis(processor.ProcessorABC):\n",
     "    def __init__(self, disable_processing, io_file_percent):\n",
     "        num_bins = 25\n",
     "        bin_low = 50\n",
@@ -483,7 +459,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "812546fa-850e-4448-b9ee-0544be491aec",
+   "id": "6164a27b-0bca-451c-a066-913df8db823e",
    "metadata": {},
    "source": [
     "### ServiceX-specific functionality: query setup\n",
@@ -494,10 +470,8 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "ceab708d-5062-4a13-ba9a-87d762a052e8",
-   "metadata": {
-    "tags": []
-   },
+   "id": "0b7583ea-a2eb-48b4-a511-26c1cdf65a32",
+   "metadata": {},
    "outputs": [],
    "source": [
     "def get_query(source: ObjectStream) -> ObjectStream:\n",
@@ -536,67 +510,49 @@
   },
   {
    "cell_type": "markdown",
-   "id": "e5dbc6e8",
+   "id": "909bb129-3ab7-47cd-80ea-64c42410ed51",
    "metadata": {},
    "source": [
-    "### Standalone ServiceX for subsequent `coffea` processing\n",
+    "### Caching the queried datasets with `ServiceX`\n",
     "\n",
-    "Using `servicex-databinder`, we can execute a query and download the output.\n",
-    "As the files are currently accessible through `rucio` only with ATLAS credentials, you need to use an ATLAS ServiceX instance to run this (for example via the UChicago coffea-casa analysis facility)."
+    "Using the queries created with `func_adl`, we are using `ServiceX` to read the CMS Open Data files to build cached files with only the specific event information as dictated by the query."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
-   "id": "0d7004ab",
-   "metadata": {
-    "tags": []
-   },
+   "id": "142989ed-dcd3-4e49-902a-e3dd7107012e",
+   "metadata": {},
    "outputs": [],
    "source": [
-    "if PIPELINE == \"servicex_databinder\":\n",
-    "    from servicex_databinder import DataBinder\n",
-    "    t0 = time.time()\n",
-    "\n",
-    "    import inspect\n",
-    " \n",
-    "    query_string = inspect.getsource(get_query).split(\"return source.\")[-1]  # extract query from function defined previously\n",
+    "if USE_SERVICEX:\n",
     "    \n",
-    "    sample_names = [\"ttbar__nominal\", \"ttbar__scaledown\", \"ttbar__scaleup\", \"ttbar__ME_var\", \"ttbar__PS_var\",\n",
-    "                    \"single_top_s_chan__nominal\", \"single_top_t_chan__nominal\", \"single_top_tW__nominal\", \"wjets__nominal\"]\n",
-    "    sample_names = [\"single_top_s_chan__nominal\"]  # for quick tests: small dataset with only 50 files\n",
-    "    sample_list = []\n",
-    "\n",
-    "    for sample_name in sample_names:\n",
-    "        sample_list.append({\"Name\": sample_name, \"RucioDID\": f\"user.ivukotic:user.ivukotic.{sample_name}\", \"Tree\": \"events\", \"FuncADL\": query_string})\n",
-    "\n",
-    "\n",
-    "    databinder_config = {\n",
-    "                            \"General\": {\n",
-    "                                           \"ServiceXBackendName\": \"uproot\",\n",
-    "                                            \"OutputDirectory\": \"outputs_databinder\",\n",
-    "                                            \"OutputFormat\": \"root\",\n",
-    "                                            \"IgnoreServiceXCache\": SERVICEX_IGNORE_CACHE\n",
-    "                            },\n",
-    "                            \"Sample\": sample_list\n",
-    "                        }\n",
-    "\n",
-    "    sx_db = DataBinder(databinder_config)\n",
-    "    # out = sx_db.deliver(timer=True)\n",
-    "    parquet_paths = sx_db._sx.get_servicex_data()  # only run transform, do not download as well\n",
-    "    print(f\"execution took {time.time() - t0:.2f} seconds\")\n",
-    "    \n",
-    "    # point to ROOT files from databinder\n",
-    "    # update list of fileset files, pointing to ServiceX output for subsequent processing\n",
-    "    # for process in fileset.keys():\n",
-    "    #     if out.get(process):\n",
-    "    #         fileset[process][\"files\"] = out[process]\n",
-    "    \n",
-    "    # point directly to parquet files from databinder\n",
-    "    # update paths to point to ServiceX outputs\n",
-    "    for sample_name, sample_paths in zip([sample['Name'] for sample in databinder_config['Sample']], parquet_paths):\n",
-    "        print(f\"updating paths for {sample_name} with {len(sample_paths)} parquet files (e.g. {sample_paths[0]}\")\n",
-    "        fileset[sample_name][\"files\"] = sample_paths"
+    "    # dummy dataset on which to generate the query\n",
+    "    dummy_ds = ServiceXSourceUpROOT(\"cernopendata://dummy\", \"events\", backend_name=\"uproot\")\n",
+    "\n",
+    "    # tell low-level infrastructure not to contact ServiceX yet, only to\n",
+    "    # return the qastle string it would have sent\n",
+    "    dummy_ds.return_qastle = True\n",
+    "\n",
+    "    # create the query\n",
+    "    query = get_query(dummy_ds).value()\n",
+    "\n",
+    "    # now we query the files and create a fileset dictionary containing the\n",
+    "    # URLs pointing to the queried files\n",
+    "\n",
+    "    t0 = time.time()\n",
+    "    for process in fileset.keys():\n",
+    "        ds = ServiceXDataset(fileset[process]['files'], \n",
+    "                             backend_name=\"uproot\", \n",
+    "                             ignore_cache=SERVICEX_IGNORE_CACHE)\n",
+    "        files = ds.get_data_rootfiles_uri(query, \n",
+    "                                          as_signed_url=True,\n",
+    "                                          title=process)\n",
+    "\n",
+    "        \n",
+    "        fileset[process][\"files\"] = [f.url for f in files]\n",
+    "\n",
+    "    print(f\"ServiceX data delivery took {time.time() - t0:.2f} seconds\")"
    ]
   },
   {
@@ -606,10 +562,9 @@
    "source": [
     "### Execute the data delivery pipeline\n",
     "\n",
-    "What happens here depends on the configuration setting for `PIPELINE`:\n",
-    "- when set to `servicex_processor`, ServiceX will feed columns to `coffea` processors, which will asynchronously process them and accumulate the output histograms,\n",
-    "- when set to `coffea`, processing will happen with pure `coffea`,\n",
-    "- if `PIPELINE` was set to `servicex_databinder`, the input data has already been pre-processed and will be processed further with `coffea`."
+    "What happens here depends on the flag `USE_SERVICEX`. If set to true, the processor is run on the data previously gathered by ServiceX, then will gather output histograms.\n",
+    "\n",
+    "When `USE_SERVICEX` is false, the input files need to be processed during this step as well."
    ]
   },
   {
@@ -618,48 +573,50 @@
    "id": "78fce979",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.8/site-packages/distributed/client.py:1288: VersionMismatchWarning: Mismatched versions found\n",
+      "\n",
+      "+---------+----------------+----------------+----------------+\n",
+      "| Package | client         | scheduler      | workers        |\n",
+      "+---------+----------------+----------------+----------------+\n",
+      "| python  | 3.8.16.final.0 | 3.8.16.final.0 | 3.8.15.final.0 |\n",
+      "+---------+----------------+----------------+----------------+\n",
+      "  warnings.warn(version_module.VersionMismatchWarning(msg[0][\"warning\"]))\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[########################################] | 100% Completed |  1min 29.6s\n",
-      "execution took 89.62 seconds\n"
+      "[########################################] | 100% Completed |  2min 35.4s\n",
+      "execution took 155.40 seconds\n"
      ]
     }
    ],
    "source": [
-    "if PIPELINE == \"coffea\":\n",
-    "    if USE_DASK:\n",
-    "        executor = processor.DaskExecutor(client=utils.get_client(AF))\n",
-    "    else:\n",
-    "        executor = processor.FuturesExecutor(workers=NUM_CORES)\n",
-    "\n",
-    "    run = processor.Runner(executor=executor, schema=AGCSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)\n",
-    "\n",
-    "    filemeta = run.preprocess(fileset, treename=\"events\")  # pre-processing\n",
-    "\n",
-    "    t0 = time.monotonic()\n",
-    "    all_histograms, metrics = run(fileset, \"events\", processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT))  # processing\n",
-    "    exec_time = time.monotonic() - t0\n",
-    "    all_histograms = all_histograms[\"hist\"]\n",
-    "\n",
-    "elif PIPELINE == \"servicex_processor\":\n",
-    "    # in a notebook:\n",
-    "    t0 = time.monotonic()\n",
-    "    all_histograms = await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT),\n",
-    "                                                        use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE, schema=AGCSchema)\n",
-    "    exec_time = time.monotonic() - t0\n",
-    "\n",
-    "    # as a script:\n",
-    "    # async def produce_all_the_histograms():\n",
-    "    #     return await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT),\n",
-    "    #                                               use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE, schema=AGCSchema)\n",
-    "    #\n",
-    "    # all_histograms = asyncio.run(produce_all_the_histograms())\n",
-    "\n",
-    "elif PIPELINE == \"servicex_databinder\":\n",
-    "    # needs a slightly different schema, not currently implemented\n",
-    "    raise NotImplementedError(\"further processing of this method is not currently implemented\")\n",
+    "if USE_DASK:\n",
+    "    executor = processor.DaskExecutor(client=utils.get_client(AF))\n",
+    "else:\n",
+    "    executor = processor.FuturesExecutor(workers=NUM_CORES)\n",
+    "        \n",
+    "run = processor.Runner(executor=executor, schema=AGCSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)\n",
+    "\n",
+    "if USE_SERVICEX:\n",
+    "    treename = \"servicex\"\n",
+    "    \n",
+    "else:\n",
+    "    treename = \"events\"\n",
+    "    \n",
+    "filemeta = run.preprocess(fileset, treename=treename)  # pre-processing\n",
+    "\n",
+    "t0 = time.monotonic()\n",
+    "all_histograms, metrics = run(fileset, treename, processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT))  # processing\n",
+    "exec_time = time.monotonic() - t0\n",
+    "\n",
+    "all_histograms = all_histograms[\"hist\"]\n",
     "\n",
     "print(f\"\\nexecution took {exec_time:.2f} seconds\")"
    ]
@@ -674,33 +631,42 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "metrics saved as metrics/coffea_casa-20230203-161826.json\n",
-      "event rate per worker (pure processtime): 62.11 kHz\n",
+      "metrics saved as metrics/coffea_casa-20230221-111055.json\n",
+      "event rate per worker (pure processtime): 61.99 kHz\n",
       "amount of data read: 3408.86 MB\n"
      ]
     }
    ],
    "source": [
-    "# track metrics for pure coffea setups\n",
-    "if PIPELINE == \"coffea\":\n",
-    "    # update metrics\n",
-    "    dataset_source = \"/data\" if fileset[\"ttbar__nominal\"][\"files\"][0].startswith(\"/data\") else \"https://xrootd-local.unl.edu:1094\" # TODO: xcache support\n",
-    "    metrics.update({\"walltime\": exec_time, \"num_workers\": NUM_CORES, \"af\": AF_NAME, \"dataset_source\": dataset_source, \"use_dask\": USE_DASK,\n",
-    "                    \"systematics\": SYSTEMATICS, \"n_files_max_per_sample\": N_FILES_MAX_PER_SAMPLE, \"pipeline\": PIPELINE,\n",
-    "                    \"cores_per_worker\": CORES_PER_WORKER, \"chunksize\": CHUNKSIZE, \"disable_processing\": DISABLE_PROCESSING, \"io_file_percent\": IO_FILE_PERCENT})\n",
-    "\n",
-    "    # save metrics to disk\n",
-    "    if not os.path.exists(\"metrics\"):\n",
-    "        os.makedirs(\"metrics\")\n",
-    "    timestamp = time.strftime('%Y%m%d-%H%M%S')\n",
-    "    metric_file_name = f\"metrics/{AF_NAME}-{timestamp}.json\"\n",
-    "    with open(metric_file_name, \"w\") as f:\n",
-    "        f.write(json.dumps(metrics))\n",
-    "\n",
-    "    print(f\"metrics saved as {metric_file_name}\")\n",
-    "    #print(f\"event rate per worker (full execution time divided by NUM_CORES={NUM_CORES}): {metrics['entries'] / NUM_CORES / exec_time / 1_000:.2f} kHz\")\n",
-    "    print(f\"event rate per worker (pure processtime): {metrics['entries'] / metrics['processtime'] / 1_000:.2f} kHz\")\n",
-    "    print(f\"amount of data read: {metrics['bytesread']/1000**2:.2f} MB\")  # likely buggy: https://github.com/CoffeaTeam/coffea/issues/717"
+    "# track metrics\n",
+    "dataset_source = \"/data\" if fileset[\"ttbar__nominal\"][\"files\"][0].startswith(\"/data\") else \"https://xrootd-local.unl.edu:1094\" # TODO: xcache support\n",
+    "metrics.update({\n",
+    "    \"walltime\": exec_time, \n",
+    "    \"num_workers\": NUM_CORES, \n",
+    "    \"af\": AF_NAME, \n",
+    "    \"dataset_source\": dataset_source, \n",
+    "    \"use_dask\": USE_DASK, \n",
+    "    \"use_servicex\": USE_SERVICEX, \n",
+    "    \"systematics\": SYSTEMATICS, \n",
+    "    \"n_files_max_per_sample\": N_FILES_MAX_PER_SAMPLE,\n",
+    "    \"cores_per_worker\": CORES_PER_WORKER, \n",
+    "    \"chunksize\": CHUNKSIZE, \n",
+    "    \"disable_processing\": DISABLE_PROCESSING, \n",
+    "    \"io_file_percent\": IO_FILE_PERCENT\n",
+    "})\n",
+    "\n",
+    "# save metrics to disk\n",
+    "if not os.path.exists(\"metrics\"):\n",
+    "    os.makedirs(\"metrics\")\n",
+    "timestamp = time.strftime('%Y%m%d-%H%M%S')\n",
+    "metric_file_name = f\"metrics/{AF_NAME}-{timestamp}.json\"\n",
+    "with open(metric_file_name, \"w\") as f:\n",
+    "    f.write(json.dumps(metrics))\n",
+    "\n",
+    "print(f\"metrics saved as {metric_file_name}\")\n",
+    "#print(f\"event rate per worker (full execution time divided by NUM_CORES={NUM_CORES}): {metrics['entries'] / NUM_CORES / exec_time / 1_000:.2f} kHz\")\n",
+    "print(f\"event rate per worker (pure processtime): {metrics['entries'] / metrics['processtime'] / 1_000:.2f} kHz\")\n",
+    "print(f\"amount of data read: {metrics['bytesread']/1000**2:.2f} MB\")  # likely buggy: https://github.com/CoffeaTeam/coffea/issues/717"
    ]
   },
   {
@@ -815,7 +781,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -950,16 +916,9 @@
    "id": "ef0b4da0-79e2-47a1-8da3-3e2c3bf7947b",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "W MnPosDef Matrix forced pos-def by adding to diagonal 0.00904336\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 600x375 with 1 Axes>"
       ]
@@ -997,7 +956,7 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "fit result for ttbar_norm: 1.018 +/- 0.013\n"
+      "fit result for ttbar_norm: 1.016 +/- 0.043\n"
      ]
     }
    ],
@@ -1023,7 +982,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmMAAAJjCAYAAABAyBZ9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADljUlEQVR4nOzdeVhU5f//8SeLLCqgKIiKK1qiuIKCmlpuueWCuCGIS320LyllpWXZpi0ulUuklTu445pb4gomoOK+lJYripIIgiKLML8/+M3IODMwbDLA+3FdXck5933OfQ7MzGvuc5/7GCkUCgVCCCGEEKJEGJd0A4QQQgghyjMJY0IIIYQQJUjCmBBCCCFECZIwJoQQQghRgiSMCSGEEEKUIAljQgghhBAlSMKYEEIIIUQJMi3pBoji9+DBA8LDw3F0dMTc3LykmyOEEEKUC2lpacTExNCpUydsbW11lpMwVg4cPHiQKVOmlHQzhBBCiHLphx9+YMCAATrXSxgrB+zt7QH45ptvaNasWZFu29/fn8DAwCLdZmnabkpKCiNGjGDt2rVUrFixyLYLpeccFOd2i+v8lqZzUFzbLW1/u3Jus8m5LV3n9t9//2Xy5Mk4OjrmWk7CWDmgvDTZoEEDXFxcinTbFhYWRb7N0rTd5ORkAJydnbGysiqy7ULpOQfFud3iOr+l6RwU13ZL29+unNtscm5L17lVymuIkAzgF4Xi4+Mj2y0mpe0cyLktfdstLsXRXjm32eTcFp+SbK+RPCi87Dt27JiqW7ddu3Yl3ZwyJTk5mVatWnH69Oki/5Ym5PwWJzm3xUfObfEpbef2/PnzDBgwgG3btuXa6yY9Y+VAhQoV1P4vio6ZmRmTJk3CzMyspJtSJsn5LT5ybouPnNviU1bPrfSMlQP6JnMhhBBCFB3pGRNCCCGEKAUkjAkhhBBClCAJY0IIIYQQJUjCmBBCCCFECZIwJoQQQghRgmQG/nLE398fCwsLfHx88PX1LenmCCGEEGVSUFAQwcHBpKam6lVewlg5EhgYKFNbCCGEEMXM19cXX19f1dQWeZHLlEIIIYQQJUjCmBBCCCFECZIwJoQQQghRgiSMCSGEEEKUIAljQgghhBAlSO6mFC9ESEgIU6dOZdasWXh5eRV4OzExMXTp0gVPT0/mzJlThC0U5c3D291Kugm5sqm9v6SbUGSvWyFE7qRnTBSJLVu24OTkhJOTE+vXr9e73pkzZ5gzZw5jxozB3d0dJycnOnbsWIwt1e7OnTvMnj2b/v3707p1a15++WXatm2Lr68vy5cvJzk5Wa18586dVcfr5OREo0aNaNWqFV5eXqxcuZKnT5++8GMQQpuYmBicnJz48MMPNdZFRkbi5OTE/PnzS6BlQggl6RkThXbnzh2+/PJLKlWqxOPHj7WWef3112ndujX29vZqy7dv386KFSuoUKECTk5O3L9//0U0Wc369ev54osvSE9Px9nZmTfeeANra2sePnzIyZMnmTlzJoGBgZw4cUKj7ujRo7G2tiYzM5M7d+6wd+9evvrqK44ePcovv/zywo9FCCFE6SNhTBSKQqFg6tSpVK1alZ49e7JkyRKt5aysrLCystJYPnjwYDw9PWncuDFmZmY4OTkVd5PVbNu2jWnTpmFjY8PPP//Ma6+9plHm1KlTfP7551rrjxkzBkdHR9XP169fp3///uzbt49jx47Rrl27Ymu7EEKIskEuU4pCWbFiBREREcyaNYuKFSvqLBcSEoKTkxMhISFqy5s2bUqzZs0wMzPL977//fdfxo8fT5s2bXBxcWHo0KGEh4frXf/Ro0d89dVXAMyfP19rEANo3bo1Gzdu1Gub9evXVwWwM2fO6N0WIYrD/Pnz6dKlCwCbN29Wu7TeuXNnRo4cCcCCBQvU1kVGRmps68CBA3h5eeHi4kLr1q3x9/fn2rVrGuWuXbvG7NmzGTBgAG3btsXZ2ZlOnTrx8ccfc+fOHY3yOS+Vnjp1ijFjxtC6dWucnJyIiYkp4jMihGGSnjFRYP/88w9z5sxh9OjRtGvXjoiIiBe275iYGLy8vHjppZcYMWIEcXFx7Ny5k7Fjx/Ljjz/Sr1+/PLexZ88eEhMTad26NZ06dcq1rLm5ud5ty8rKAsDUVF5eomS5u7szevRoVqxYgbOzMz169FCts7a25uLFi2zevBl3d3fc3d1V63L29gLs3buXw4cP07NnTzw8PLh48SJ79uwhMjKSjRs30rBhQ1XZP/74gzVr1uDh4UGbNm2oUKECly9fZuPGjezfv59t27ZRs2ZNjbaePHmSRYsW4ebmxpAhQ4iPj6dChQrFcFaEMDzyaSEK5OnTp7z//vvUqlWLDz744IXv/9ixY7z55pt8/PHHqmW+vr4MGTKE6dOn06VLF62XRXM6fvw4AO3bty+ydl2/fl21XVdX1yLbrhAF4eHhgaOjoyqMBQQEqK2PjIxUhbHn1+W0f/9+fvvtN7p27apatnz5cmbOnMlnn31GcHCwavnAgQMZM2aMxheYQ4cO8dZbbxEYGMjMmTM19nHkyBFmzJiBt7d3QQ9XiFJLwpgokIULF3Lx4kXWr1+PhYXFC9+/lZUVEydOVFvWokUL+vfvz+bNm9m7dy+DBw/OdRv//fcfgNZv6fpavny5xgD+lJQUxo4dS4sWLQq8XSEMSfv27dWCGMCoUaNYtWoVERER3L59m9q1awPg4OCgdRuvvvoqjRo14siRI1rXOzs7SxAT5ZaEMZFvZ86cYdGiRYwbN442bdqUSBuaNWtG5cqVNZa7u7uzefNmLl68mGcYUygUhW7HihUrNJa9++67GkFRiNIs5yVMJRMTE9zc3Lh58yYXLlxQhTGFQsG2bdvYtGkTf/31Fw8fPiQzM1NVT9f40JYtWxZP44UoBSSMiXxRXp5s0KAB7733Xom1o3r16lqX29nZAWjMC6ZNjRo1ALh7926B23H48GEcHR1JS0vj/PnzTJ8+nfnz51OvXj369+9f4O0KYUiqVaumdbm219vXX3/N8uXLsbe3p1OnTtSoUUPVe75p0yZu376d67aEKI8kjJUj/v7+WFhY4OPjg6+vb4G2kZKSorqDqmnTplrLTJs2jWnTpjF69GimT59e4PbmRtd8ZMpLj3mNFwNwc3Nj48aNHD16lMmTJxeqPebm5ri6urJixQp69OjBp59+ioeHh8a8akKURvHx8VqXP/96u3//PitXruSll15i48aNGr3Xv//+u859GBkZFVFrhSh5QUFBBAcHk5qaqld5CWPlSGBgIC4uLoXahpmZGUOHDtW67sKFC1y4cAE3NzcaNmxI69atC7Wv3Fy4cIFHjx5pvNlHRUUBuoNiTr169eLbb7/l1KlT/Pnnn7nO/J+WlqbXHZX29vb83//9H7Nnz+bHH3/k22+/zbOOEMXJ2Dh7BiPlXb45mZiYAKhdRtQmKipK49J7ZmamaiLkZs2aAXDr1i2ysrLo1KmTxmszNjaWW7duFewghChlfH198fX15fz58wwYMCDP8jLPmMgXCwsLvv32W63/deuW/aw/T09Pvv32W72mlyio5ORkFi5cqLbs7NmzbN++HSsrK3r27JnnNipXrsxnn30GwKRJkwgLC9Na7tSpUwwZMkTvto0aNYrq1auzefNmrfMwCfEi2djYYGRkRGxsrMa6KlWqAGhdl1NERAQHDhxQW7Zq1Spu3ryJh4eHaryYckqMEydOqAW8x48fM23aNHlMmBA6SM+YKFH//vsvixcvVlv28OFDtefoffzxx9ja2qqVadeuHRs2bODMmTO4urqq5hnLyspi5syZel2mBBgwYACpqal88cUXjBkzhqZNm9KmTRusra1JTEzk1KlTXLp0SWP/ubG0tGTChAnMnDmTefPmyXP/RImqVKkSrVq14tixY0yePJn69etjbGxM9+7dady4MQ4ODuzYsQNTU1Nq1aqFkZERgwYNUgUsgO7du/P222/Ts2dP6tWrx6VLlzh06BBVqlRRTZwM2eO++vXrx44dO+jXrx+dOnUiOTmZI0eOYG5uTtOmTbl48WJJnAYhDJqEMVGi/vvvPzZv3qy27MmTJ2rLAgICNMKQo6MjM2fOZPbs2axZs4b09HSaNWvGxIkT6dy5c77aMGzYMDp16kRQUBB//vkn27Zt48mTJ1hbW9O4cWM+/fRTvLy88rVNb29vfvvtN3bu3Mnbb79NkyZN8lVfFD+b2vtLugkvzNy5c/n66685fPgw27dvR6FQ4ODgQJMmTVi0aBGzZ89m165dPH78GIVCgZubm1oY69GjB8OHDycwMJCDBw9iamrK66+/zocffkiDBg3U9vXdd99Rp04ddu7cSVBQELa2tnTv3p13330Xf3//F33oQpQKRoqiuL9fGDTlNett27YVesxYQa1Zs4bp06fz448/yl2GQgghygV9P39lzJh4Ia5evQpArVq1SrglQgghhGGRy5SiWO3du5eDBw+ydetWHBwcZGJHIYQQ4jnSMyaKVWhoKH/88Qfu7u6sWrVKHvwrhBBCPEd6xkSxmjNnTkk3QQghhDBo0jMmhBBCCFGCDLJnbPfu3URFRXHp0iX++usvHj16xIABA/jhhx901omOjiYwMJDTp0+TlpZGvXr1GDJkCKNGjVLNMv28TZs2ERwczD///IOxsTHNmjXjzTffpGvXrlrLp6amsnjxYnbs2MHt27epXLkyHh4eBAQE0KhRI611YmNjmTdvHmFhYSQmJmJnZ0ePHj2YNGkSNjY2RXYsQgghhCidDLJnLDAwkKCgIC5duqR6mHNuQkNDGTFiBMePH6dnz574+PiQkZHBzJkzCQgI0Frnm2++YcqUKcTFxTFs2DAGDhzI33//zVtvvcWqVas0yqelpTFq1CgWLlxI5cqVGT16NB07dmTv3r0MHDiQ06dPa9S5ceMGAwYMICQkhBYtWjBmzBjq1KnDihUr8PLyIiEhoUiORQghhBClmMIAHT16VHH16lVFVlaWIiIiQtGwYUPFe++9p7VsUlKSws3NTdGkSRPFmTNnVMtTU1MVgwcPVjRs2FCxfft2tTonTpxQNGzYUPHqq68qEhMTVctv3bqlaNOmjaJJkyaKW7duqdX5+eefFQ0bNlT4+/srMjMzVcv37t2raNiwoeL1119XW65QKBR+fn6Khg0bKlasWKG2fObMmYqGDRsqPvnkk0Ifiz7OnTunaNiwoeLcuXP5riuEEEKIgtH389cge8bat29PgwYNMDIyyrPs7t27efDgAf369aNFixaq5ebm5kyePBmA1atXq9VZs2YNAP7+/mqXCh0dHfHx8SE9PZ2NGzeqlisUClWdqVOnqh68C9kzU7dt25YrV64QGRmpWn7jxg3Cw8OpU6cOvr6+avsPCAigYsWKbNmyhcePHxfqWIQQQghRuhlkGMsPZQDS9gicdu3aYWlpyalTp0hLS9Oo06VLF406ymXPB6s7d+7QsGFD6tSpo1cd5b9feeUVtfAG2Q+odnV1JTU1Ve3yZkGORQghhBClW6kPY8qZ3evXr6+xztTUFEdHR54+fcqtW7cASElJ4e7du1SqVAk7OzuNOsrtXLt2TbVM+W9t+9BVJ7d25Vx+/fr1Ah9LfqWkpJCcnKz6T0KdEEIIUXTS0tLUPmdTUlL0qmeQd1PmR3JyMgBWVlZa1yuXJyUl5au8slxx1alcubJauwpyLPk1YsQItZ8nTZpUpm8K+PPPP5k/fz5XrlwhKSmJ7t2788svv+Dt7U1UVBT//vtvSTdRCCFEGbJ48WIWLFiQ73qlPozlRfH/n4Ouz/izwu6jIPLTrsIey9q1a3F2dlb9bGZmVqDtlAa3b9/mf//7H1ZWVnh5eVG5cmUaNmyos3xkZCQjR44s8wFVCCFE8ZkwYQJjx45V/Xzp0iWNjhBtSn0Y09YrldOjR4/UyuVVXlvvVH738SLr5EfFihULXLe0OXLkCKmpqXz77bf0799fbd3cuXN58uRJCbVMGIroaetKugm5cv1meEk3QQiRT+bm5pibm6t+rlixol71Sv2YMWVvR87xWkpPnz4lJiYGU1NT1cD7ihUr4uDgwOPHj4mLi9OooxzD1aBBA9Uy5b+17UNXndzalbNOzvFh+T0WoZvyd2tvb6+xrlatWjg5Ob3oJglRImJiYnBycuLDDz9UW75nzx6cnJyYNGmS1no///wzTk5OuLi4kJ6errH+2rVrODk50a1bt2JptxDlSakPY+3btwcgLCxMY92xY8d48uQJbdq0UUuqHh4eOuscPnxYbbsA9erVo1atWly7dk3r4HltdZT7OHLkCFlZWWrlHz16RHR0NBYWFrRu3bpQx1JScr7B//vvv4wfP542bdrg4uLC0KFDCQ8PVysfEhKCk5MTISEhHDx4kOHDh9OyZUu1UPT06VOCg4MZPHgwLVu2pFmzZrzxxhusWrVK4xzqEhkZiZOTE/PmzQNg5MiRODk54eTkpLpb1dvbW22/H374ISNHjgRgwYIFqvI56whR1nh4eGBsbExERITWoRYREREYGRnx5MkTTp06pXU9QIcOHYq9rUKUdaU+jPXq1QtbW1t27tzJ2bNnVcvT0tJUj0/y9vZWq6P8OTAwkIcPH6qWx8TEEBwcjJmZGV5eXqrlRkZGqjqzZs1SCwahoaEcP36cxo0b4+7urlper149OnXqRExMDEFBQWr7nz9/PikpKQwaNEitC7Mgx1LSYmJi8PLyIjExkREjRtC7d2/Onz/P2LFj2bFjh0b53bt3q8ZyKcsDZGRk8Oabb/L555+TnJzMG2+8wfDhw8nKyuLLL7/kgw8+0Ks9jo6OTJo0SfW78PT0ZNKkSUyaNAlHR0etdXr06IGnpycA7u7uqvK51RGitKtSpQrOzs48ePCAy5cvq61LS0vj5MmT9OrVCyMjI1XwyknCmBBFxyDHjO3du5fQ0FAA/vvvPwBOnTql6mavWrUq06ZNA7LHT3399de88847jBw5kn79+mFjY8P+/fu5evUqvXv3pl+/fmrbd3V1Zdy4cSxdupQ+ffrQu3dvMjIy2LlzJ4mJiXz++ecaH8Jjx47lwIED7N69G09PTzp06MCdO3fYvXs3lpaWfPfddxrziX355ZcMGTKEr776iqNHj9KoUSNOnz5NZGQkDRo04P3331crX5BjKWnHjh3jzTff5OOPP1Yt8/X1ZciQIUyfPp0uXbqojVM7fPgwS5cu1Zjj7eeffyY8PJzRo0czbdo01TM4MzMz+eSTT9i4cSO9evWiZ8+eubbH0dGRgIAA5s+fT1RUFIMHD1b1UurSs2dPrK2t2bx5M+7u7jKAX5QZ8+fPV93ZtXnzZjZv3qxaN2vWLNq3b8+FCxc4evQoL7/8smrdqVOnSE1NpVevXly7do2IiAjeffdd1XqFQkFkZCRGRkZ5vr6EEHkzyJ6xS5cuqd44lJe7bt68qVq2Z88etfI9e/ZkzZo1tG3blj179rBq1SpMTU355JNPmD9/vta7D6dNm8bs2bOxs7Nj3bp1bNmyhcaNG/Pbb78xatQojfLm5uYEBQUxceJEkpKSWL58OX/++Sc9evRgy5YttGrVSqNOvXr12Lp1K4MHD+bMmTMsXbqUmzdv4ufnR0hICFWrVtWoU5BjKUlWVlZMnDhRbVmLFi3o378/SUlJ7N27V21dt27dNIJYVlYWQUFB2NvbqwUxABMTE6ZNm4aRkRHbt28vvgMRogxyd3dn9OjRADg7O6v1+jZt2lQ1NOL5nq+jR48C2ZcyPTw8OHPmjNp8SX/99RcPHjygadOmWt/HhBD5Y5A9YwEBAfnunXBzc2PZsmX5qjN48GAGDx6sd3kLCwveffddtW+IealVqxazZ8/OV7sKciwlpVmzZqo503Jyd3dn8+bNXLx4Ue0cawut165dIyEhgfr16/PTTz9p3Y+FhYXavGDz58/XKDN48GC5rChEDh4eHjg6OrJixQqcnZ013lfr169PhQoVOHbsGJmZmaovQhERETRu3Jjq1avj4eHBihUrOH78uOqLlDK85RwnK4QoOIMMY6L0qF69utblyqcbPD9Nh7anHiQkJADZd5jmNllezm/m2sq5u7tLGBMiHypWrEiLFi2Ijo7m/PnztGzZksePH3Pu3DmGD8+eWsPd3V010P/5MCbjxYQoGhLGRKHcv39f63LlWD995jVTlunZsyeLFi3Sa78ye74QRaNDhw5ER0cTERFBy5YtOX78OBkZGaqxYNbW1jg7O6sCWGZmJseOHaNChQq0bdu2JJsuRJlhkGPGROlx4cIF1WS0OUVFRQHQtGnTPLfh5OSEtbU1p0+fJiMjo8jbqI+cNwwIUZ4oe7eU48SOHj2KkZGR2t3hHh4eXLx4kYcPH3L27FkePXpEy5Yt9Z7QUgiROwljolCSk5NZuHCh2rKzZ8+yfft2rKys8rz7EbIfgj5q1Cji4uL46quvSE1N1SgTFxfHlStXiqzdz6tSpQoAsbGxxbYPIQxRq1atsLS0JDo6mvT0dCIjI2nSpInawHwPDw+ysrKIjIyUS5RCFAO5TCkKpV27dmzYsIEzZ87g6upKXFwcO3fuJCsri5kzZ+r9+KV33nmHv/76izVr1nDgwAE8PDxwcHAgPj6e69evEx0dzfvvv0/jxo2L5TgaNmyIg4MDO3bswNTUlFq1amFkZMSgQYOoXbt2sexTiBdBOeWOromTzczMcHNzIzw8nIMHD3Lp0iX8/PzUyrRt2xYTExMiIiJUQwQkjAlRdCSMiUJxdHRk5syZzJ49mzVr1pCenk6zZs2YOHEinTt31ns7FSpUYPHixWzdupVNmzZx8OBBUlJSsLW1xdHRkffee0/jGZNFycTEhEWLFjF79mx27drF48ePUSgUuLm5SRgTpZqNjQ1GRka59vq2b9+e8PBw5s+fT1ZWlsbcYVZWVjRr1oywsDDu3r1LxYoVadmyZXE3XYhyQ8KYKDQnJyd++eWXXMt4eXmpPdVAG2VP1KBBgwrdptymR1mzZo3W5S1atCA4OLjQ+xbCkFSqVIlWrVpx7NgxJk+eTP369TE2NqZ79+40adIEeDZFxd9//42xsTHt2rXT2I6Hhwe//vorAJ07d8bMzOzFHYQQZZyEMSFEueT6zfCSbsILM3fuXL7++msOHz7M9u3bUSgUODg4qMKYi4sLNjY2PHz4kKZNm2Jtba2xjZxhTOYXE6JoSRgrR/z9/bGwsMDHxwdfX9+Sbo4Q4gWpX78+v/32m871xsbGnDx5MtdtdOnSRaaUEUJPQUFBBAcHa70hTRsJY+VIYGAgLi4uJd0MIYQQokzz9fXF19eX8+fPM2DAgDzLSxgTBeLo6CjfkoUQQogiIPOMCSGEEEKUIAljQgghhBAlSMKYEEIIIUQJkjAmhBBCCFGCJIwJIYQQQpQgCWNCCCGEECVIwpgQQgghRAmSMCaEEEIIUYIkjAkhhBBClCAJY0IIIYQQJUjCmBBCCCFECZJnUwohyqWLfkYl3YRcNV2peKH78/b2JioqqkSeOVuS+xbl+/wbyrFLz5gQQogybf78+Tg5OREZGVnSTcmXzp0707lz55JuhngBpGdMCCEEc+fO5cmTJyXdDCHKJQlj5Yi/vz8WFhb4+Pjg6+tb0s0RQhiQWrVqlXQThCgzgoKCCA4OJjU1Va/yEsbKkcDAQFxcXEq6GaKE/fDDD5ibm+Pn50flypV1lnv06BErV64kLS0NPz8/qlWrprNsWloaq1evJi4uDl9fX2rXrq2zbGZmJiEhIVy5coWhQ4fy0ksv6SyrUCgwMjLssV2G7o8//mDlypX8+++/JCUlYW1tTb169XjjjTfUvpRpGzsTGRnJyJEjmTRpEj169OD7778nOjqajIwMmjdvzgcffICbm5vGPuPi4pg7dy4HDx7k8ePHNGzYkDFjxlC7dm3V9gICAvRqf1hYGCtWrODs2bM8fvwYBwcHevbsib+/P9bW1nnW79y5M7dv3wZg5MiRautyHuu9e/cIDAzk0KFDxMXFYWVlhaurK//3f/9HixYt1OqFhIQwdepUZs2aha2tLT///DN//fUXFSpUoEOHDnzwwQc0aNBAr+PTRnnelZycnFT/9vT0ZM6cOXptJzExkSVLlrBv3z5u3bqFqakpjo6OdOnShXfeeYeKFSuqlX/69Cm//vorISEhxMbGYmtrS79+/Zg8eTLm5uZqZffu3cuePXs4c+YM9+7dw8jIiAYNGjBo0CBGjRqFiYmJWvkPP/yQzZs3c/jwYcLCwggKCuL69etYWVnRrVs3Pv74Y43fp/IS7R9//MG8efPYuXMn8fHxODg4MGzYMMaPH6/1/eH06dP89ttvnDhxgocPH1KtWjVeffVVJk2aRI0aNfQ6d4Xl6+uLr68v58+fZ8CAAXmWlzAmRCGFhYXlOa7j1KlTbN++HVdXV/r27ZtrwLh8+TIbNmygcePGeHl5abyp5XT79m2CgoKwt7dn5MiRGm+YOcXHx7Ny5cpSFcR27txJv379dJYRuVu9ejWfffYZdnZ2dOvWDVtbW+Lj4/nrr7/YtGmT3j3k586d49dff6V169YMHTqU2NhY9uzZg6+vL7///juNGjVSlb1//z5DhgwhJiaGdu3a0aZNG/777z8+//xzXnnllXy1f+HChcybN4+qVavy6quvUq1aNf7++2+WLFnC4cOH2bhxI1ZWVrluY8yYMYSGhhIVFYWnpyeOjo4aZW7evMmwYcOIi4ujQ4cOvPHGG8TGxrJ7924OHTrEwoUL6dGjh0a9vXv3cvjwYXr27ImHhwcXL15kz549REZGsnHjRho2bJiv41VydHRk0qRJLF++XHUMSs7Oznpt49atW4wcOZLbt2/j4uLCyJEjycrK4urVqyxfvhxvb2+NMPbee+9x/PhxunTpQuXKlTl06BBLliwhPj6euXPnqpWdM2cOxsbGtGrViho1apCUlMTRo0eZOXMmZ86cYd68eVrbNWvWLMLCwujWrRudOnUiMjKSDRs2cP36ddauXatR/unTp/j5+REXF0eXLl0wNTUlNDSUOXPmkJqayrvvvqtWPiQkhGnTpmFubk63bt1wcHDg+vXrbNiwgQMHDrBp0yaD7AWWMCZEIUkQK74gFh0dLWGsENavX4+ZmRk7duygevXqausePHig93YOHjzI7NmzGTx4sGrZmjVrmD59OitXrmTGjBmq5XPnziUmJob//e9/TJ06VbV8zJgxeHp66r3PiIgI5s2bh6urK0uXLlULXcqeqXnz5jF9+vRctzNmzBiSkpKIiopi8ODBeHh4aJSZPn06cXFxTJkyhfHjx6uWe3t7M2LECKZOnUr79u01Xjf79+/nt99+o2vXrqply5cvZ+bMmXz22WcEBwfrfbw5OTo6EhAQwKZNmwD07kXMafLkydy+fZsPPviAt99+W23dgwcPqFSpkkadGzdusGfPHqpUqQLA+++/T9++fdm2bRtTpkzB3t5eVXbJkiXUq1dPrX5WVhYffPAB27Ztw8/Pj9atW2vs4/Tp0+zevVsViJ4+fYqPjw/Hjh3j9OnTtGrVSq38vXv3aNKkCatWrcLCwgKAiRMn0r17d5YvX46/vz8VKlQA4Nq1a3z66afUqVOHtWvXqrX36NGj+Pn58eWXX/LLL7/oeRZfHLmbUohiJEEsW0GDWP/+/XWWE/oxMTFRfVjlZGtrq/c23Nzc1IIYwJAhQzA1NeXs2bOqZenp6fz+++9YWVnh7++vVt7Z2ZmBAwfqvc+VK1cC8PXXX2v0fnl5edG0aVO2b9+u9/Z0iY2N5ciRI9SuXZtx48aprXNzc6Nfv348fPiQvXv3atRt3769WhADGDVqFHXr1iUiIkJ1efRFO3fuHCdPnqRp06Zq4VLJ1tZW63vG1KlTVUEMoGLFigwYMICsrCzOnz+vVvb5IAZgbGys6sU7cuSI1rZNnDhRrWfK1NQULy8vALW/pZw+//xzVRADqF69Ot27d+fRo0dcvXpVtXz16tVkZGTw6aefqgUxgA4dOtCtWzcOHDhAcnKy1v2UJOkZE6KYSBDLVpggpu2btdDfgAED+Oabb+jVqxf9+vWjbdu2uLq65vq71aZ58+YayypUqED16tVJSkpSLbt27Rqpqak0b95c69+am5sbGzZs0Gufp06dokKFCuzatUvr+oyMDB48eEBCQgJVq1bV80g0Xbx4EYC2bdtiaqr5kdixY0e2b9/OhQsXNHr23N3dNcqbmJjg5ubGzZs3uXDhQq6vjcJYvny52rkH6NGjB02bNuX06dMAdOrUCWNj/ftcnh8bB1CzZk0AHj58qLY8ISGB3377jUOHDnHr1i1SUlLU1t+9e1frPrT9LenaB6Aa46irTs5zcOrUKQCioqK0Brv4+HiysrK4fv261naUJAljQhQDCWLZJIiVrHHjxlG1alVWr17NihUrWLZsGUZGRnh4ePDRRx/pfUOPrnFZJiYmZGZmqn5W9jg8f0lUSddybRITE3n69CkLFizItVxKSkqhwlhebbazs1Mrl5Ou10ludYrK8uXLNXreateuTdOmTVUBJb+D1bX9npXvRzl/z0lJSQwaNIhbt27RsmVLBg0ahI2NDaampiQlJbFixQrS09PzvY+srCy9ygOq4JyzXQkJCQD89ttvWusoPR8cDYGEMSGKmASxbBLEDIOnpyeenp4kJSURHR3N3r17CQkJYfTo0fzxxx/57iXLjfLv7P79+1rX61qujZWVFVlZWZw8ebJI2pbbfkB32/777z+1cjnFx8fnu05RCQsL07lOeVfivXv3imXf69ev59atW1rvij158iQrVqwolv3mRXm+T58+XaznvjjImDEhipAEsWwSxAyPtbU1r732Gt9++y2DBw8mISGBEydOFOk+GjZsiIWFBX/99RePHj3SWJ+f/bVq1YqHDx9y+fLlQrdLeakuZy+KUtOmTVVte/r0qcb6iIgIAJo1a6axLioqSmNZZmam6ji11cmP53se9aUcBH/kyBEUiqJ/rNaNGzcA6NWrl8a6Y8eOFfn+9KV87yjqv+sXQcKYEEVEglg2CWKG4/Dhw1oDhrJHx8zMrEj3Z2ZmRt++fUlOTiYwMFBt3aVLl9i6dave21IOBJ82bZrWHp6UlBTVGKG8KC9jxsbGaqyrWbMmr7zyCjExMaqpJJROnz7N77//jo2NDT179tSoGxERwYEDB9SWrVq1ips3b+Lh4aH2OomJicHJySlfjzeqUqUKDx48IC0tTe86kD0uq02bNly4cEHrJbuEhIR8bzMn5fQgyqCqdOHCBRYtWlTg7RaWr68vFSpUYObMmVy7dk1jfXp6OsePHy+BluVNLlMKUQQkiGWTIGZYAgICMDc3x83NTfV7O378OGfPnqVZs2Z07NixyPc5ZcoUIiIi+PXXXzlz5gxt2rQhLi6OXbt20aVLF0JDQ/UaVN6xY0emTJnCnDlz6NatG6+++iqOjo6kpKRw+/Ztjh07hqurq16XxDw8PDA2Nmbu3LlcvnxZdRnvnXfeAWDGjBkMHTqU7777jiNHjtC8eXNiY2PZtWsXxsbGzJo1S+vrqXv37rz99tv07NmTevXqcenSJQ4dOkSVKlX46quv1Moqx0Pl9np/XocOHTh79ixjxoyhbdu2VKhQAWdnZ7p165Zn3R9++AFvb29mzZrFrl27aNeuHQDXr18nPDyc0NBQrXOu6WPQoEH89ttvfP3110RFRVG/fn2uX7/OwYMH6dmzJzt37izQdgvLycmJ7777jo8++ohevXrRuXNnGjRoQEZGBnfu3OHEiRPY2toSGhpaIu3LjYQxIQpJgli20hbEmq4s+ss3hmbKlCmEhYVx4cIFDh06hLm5ObVr12bKlCmMHDmyyHvGIHsg/MaNG5k7dy6HDx/m9OnTNGzYkC+//JKKFSsSGhqa699nTuPHj8fV1ZWVK1dy4sQJ9u3bh5WVFTVq1GD48OG88cYbem2nUaNGzJkzhyVLlhAcHKzqFVKGsbp167J161bVDPxRUVFUrlyZzp074+/vr/UuQ8i+e3H48OEEBgZy8OBBTE1Nef311/nwww81ZuD/+++/AfI1b56/vz9JSUkcOHCAEydOkJmZiaenp15hrE6dOmzfvp1ff/2V0NBQgoKCMDc3x9HRkXHjxhVqrGCNGjVYt24dc+bM4cSJE4SHh6t+xx07diyxMAYwcOBAnJ2dWbJkCZGRkRw5cgRLS0vs7e3p1asXffv2LbG25cZIURwXlIVBUT6OYdu2bfI4pGLw5ZdfShArZUFMlIy5c+eyaNEili9fnq/LdYYm5+OQlHNk5eXrr79m7dq1hIWF5WuON1G66fv5K2PGhCgkCWLFF8Ryu2NMGC5tY7z+/vtvVq1aRdWqVbXOz1XWRUVFMWzYMAliQiu5TClEIUkQK74gdvDgwVLdg1JeDRw4kHr16vHSSy9haWnJ9evXOXToEFlZWXz99de5/l2XVUXxtABRdkkYE6KQJIgVXxB77bXXci0nDJO3tzf79u1j165dJCcnY2VlRefOnXnzzTfLZa+YEHmRMCZEMZEglq0wQUx6xUqniRMnMnHixJJuRrHx8vLSe6yYEPqQMFaO+Pv7Y2FhgY+PD76+viXdnDJNglg2CWJCiPIoKCiI4OBgUlNT9SovYawcCQwMlLspXwAJYtkkiAkhyitfX198fX1Vd1PmRe6mFKIISRDLJkFMCCH0J2FMiCIiQSybBDEhhMgfCWNCFAEJYtkkiAkhRP5JGBOikCSIZZMgJoQQBSNhTIhCkiAmQUwIIQpDwpgQhSRBrPiC2KlTp3JdL4QQZYGEMSEKSYJY8QUxeYSMEKI8kHnGhCgkCWLFF8RcXV1zLVcYRss/KLZtFwXFmLkvdH/e3t5ERUXx77//vtD9lvS+xTORkZGMHDmSSZMmERAQUNLNeaFK+tilZ0yIYiJB7JmCBrG+ffvmWlYIfcyfPx8nJyciIyNLuilCaCU9Y0IUAwlizxQmiOX2EHZRtObOncuTJ09KuhlClEtlKozt27ePlStXcvXqVRISErC3t8fFxYWxY8fSpk0bjfLR0dEEBgZy+vRp0tLSqFevHkOGDGHUqFE6Lz1t2rSJ4OBg/vnnH4yNjWnWrBlvvvkmXbt21Vo+NTWVxYsXs2PHDm7fvk3lypXx8PAgICCARo0aaa0TGxvLvHnzCAsLIzExETs7O3r06MGkSZOwsbEp+AkSL4QEsWckiJUetWrVKukmCFFulZnLlN988w3jx4/n0qVLdO7cmdGjR9OsWTP27dvH0KFD2bx5s1r50NBQRowYwfHjx+nZsyc+Pj5kZGQwc+ZMndeLv/nmG6ZMmUJcXBzDhg1j4MCB/P3337z11lusWrVKo3xaWhqjRo1i4cKFVK5cmdGjR9OxY0f27t3LwIEDOX36tEadGzduMGDAAEJCQmjRogVjxoyhTp06rFixAi8vLxISEorkfIniIUHsGQlihuGPP/7A29sbd3d3nJ2dcXd3Z+jQoQQFBamV8/b2xsnJSW1ZZGQkTk5OzJ8/n4sXLzJu3DhatWpFs2bNGD58OCdOnNC6z7i4OKZMmULbtm1p2rQp/fr1Y9OmTWrb01dYWBhjx47Fzc0NZ2dnXnvtNb799luSkpL0qt+5c2cWLFgAwMiRI3FyclL9l9O9e/f47LPP6Ny5M02aNKFt27ZMmDCBs2fPamwzJCQEJycnQkJCOHDgAF5eXri4uNC6dWv8/f25du2a3seXmwsXLjBx4kQ6deqEs7Mzrq6u9OnTh6+++oqMjIx8bSs8PJy33nqLtm3b4uzsTMeOHRk/fjx//vmn1vL6/r7v3bvHwoULGTJkCO7u7jRp0oT27dsTEBDA5cuXNcrHxMTg5OTEhx9+SExMDJMmTVL9bvv378++ffs06uQ83xEREXh7e9OiRQtatmzJ2LFjte4H4MmTJyxatIh+/frh4uJC8+bN8fLyMsgbg8pEz9h///3H8uXLqV69Ojt37qR69eqqdREREfj4+DB//nw8PT0BSE5OZtq0aZiYmLB69WpatGgBwOTJkxk5ciS7d+/m999/54033lBtJzo6mqVLl1K3bl22bt2q6qF66623GDBgAN9++y1du3bF0dFRVWfZsmVER0fTu3dvFixYgLFxdvbt27cvEyZM4KOPPmLXrl2q5QCff/458fHxfPbZZ/j5+amWf/311yxbtozvv/+emTNnFsNZFIUlQewZCWKGYfXq1Xz22WfY2dnRrVs3bG1tiY+P56+//mLTpk34+vrqtZ1z587x66+/0rp1a4YOHUpsbCx79uzB19eX33//Xa2X//79+wwZMoSYmBjatWtHmzZt+O+///j888955ZVX8tX+hQsXMm/ePKpWrcqrr75KtWrV+Pvvv1myZAmHDx9m48aNWFlZ5bqNMWPGEBoaSlRUFJ6enmrv0Uo3b95k2LBhxMXF0aFDB9544w1iY2PZvXs3hw4dYuHChfTo0UOj3t69ezl8+DA9e/bEw8ODixcvsmfPHiIjI9m4cSMNGzbM1/HmdPHiRby8vDA2NqZbt27UqVOHR48ecePGDdasWcP7779PhQoV9NrWvHnzWLhwIZUqVaJHjx7UrFmTe/fuER0dzdatW+nYsaNa+fz8vo8dO8bixYvx8PCgV69eWFpacv36dfbs2cP+/fvZsGEDTZs21WjT7du3GTRoEHXr1mXgwIEkJiayc+dOJkyYwMqVKzXaBHDw4EH27dtHly5dGDFiBP/88w+HDh3i3Llz7NmzR+29MSkpCR8fHy5cuICLiwteXl4oFArCwsJ47733uHLlCu+//76+v45iVybC2O3bt8nKyqJVq1ZqQQygffv2VK5cWa1Haffu3Tx48ABPT09VEAMwNzdn8uTJ+Pr6snr1arUwtmbNGgD8/f3VLhU6Ojri4+PDTz/9xMaNG3nvvfeA7A8vZZ2pU6eqBa4ePXrQtm1bjh8/TmRkJB06dACye8XCw8OpU6eOxptkQEAA69atY8uWLXz88cdUqlSpUOdMFC0JYs9IEDMc69evx8zMjB07dmi8Nz548EDv7Rw8eJDZs2czePBg1bI1a9Ywffp0Vq5cyYwZM1TL586dS0xMDP/73/+YOnWqavmYMWNUX4j1ERERwbx583B1dWXp0qVqoSskJISpU6cyb948pk+fnut2xowZQ1JSElFRUQwePBgPDw+NMtOnT1f15o0fP1613NvbmxEjRjB16lTVZ0lO+/fv57ffflMbprJ8+XJmzpzJZ599RnBwsN7H+7wtW7aQnp7OokWL6Nmzp9q6hw8fYmlpqdd2wsPDWbhwIXXr1mXt2rU4ODio1ikUCu7evatRJz+/7/bt2xMVFaVxbs6fP8/w4cOZPXs2K1as0NhHVFQUAQEBTJo0SbWsf//+jBkzhiVLlmgNY6GhoSxfvlxt3Zw5c1i8eDEhISFqv7sZM2Zw4cIFPv74Y958803V8rS0NMaPH8+iRYvo1asXzZo103XqXqgycZmyfv36mJmZcfr0ae7fv6+2LiIigkePHqn98pR31Gj7oGjXrh2WlpacOnWKtLQ0jTpdunTRqKNclvNOnRs3bnDnzh0aNmxInTp19Kqj/Pcrr7yiFt4AKleujKurK6mpqVovb+ojJSWF5ORk1X85j08UnASxZySIGR4TExOtPSi2trZ6b8PNzU3tgxlgyJAhmJqaql3GS09P5/fff8fKygp/f3+18s7OzgwcOFDvfa5cuRLIvirwfO+Xl5cXTZs2LZLLTbGxsRw5coTatWszbtw4tXVubm7069ePhw8fsnfvXo267du31xgvPGrUKOrWrUtERAS3b98ucLuUrwdtocvGxkbjM0IX5RCajz76SC2IKfdRs2ZNjTr6/r4BqlevrvV9zMXFRRXUtF1SdXR01Pgb6dy5M7Vq1eLcuXNaj+WNN97QCGnDhw8HUGtXQkIC27Zto0WLFmpBDLI7XaZOnYpCoSiWy5VpaWlqn7MpKSl61SsTPWNVqlTho48+YubMmfTq1YsePXpga2vLjRs32L9/P506dVJL8levXgWyQ9zzTE1NcXR05MqVK9y6dYtGjRqRkpLC3bt3qVSpEnZ2dhp1lNvJOU5A+W9t+9BVJ7d2KZeHh4dz/fp1rd8a8jJixAi1n8vjXDLFQYJYNglihmfAgAF888039OrVi379+tG2bVtcXV1z/XvSpnnz5hrLKlSoQPXq1dXGbl27do3U1FSaN2+u9e/bzc2NDRs26LXPU6dOUaFCBXbt2qV1fUZGBg8ePCAhIYGqVavqeSSaLl68CEDbtm0xNdX8SOzYsSPbt2/nwoULGj177u7uGuVNTExwc3Pj5s2bXLhwIdfXY2769evHihUrmDBhAr1796ZDhw64urpSr149jfaHhoaqLbO2tmbMmDEAnD59GiMjI60dCbro+/tWOnjwIGvWrOHcuXMkJCTw9OlTtfXKG+pycnZ21nqjXM2aNXU+ecPFxUVrecjuLVQ6e/YsmZmZAFrHJyrDofIztygtXrxYNUYxP8pEGAPw8/Ojdu3aTJkyRe3FXq9ePTw9PdW66JOTkwF0jjVQLlf+0elbXlmuuOoo39z0Hbj6vLVr1+Ls7Kz62czMrEDbEeokiBVfELt8+XKu7RS5GzduHFWrVmX16tWsWLGCZcuWYWRkhIeHBx999JHWDzdtdL0nmZiYqD704Nl72POXRJV0LdcmMTGRp0+f5vnBlpKSUqgwlleblV/Ac75XK+l6beZWR18tWrRg3bp1/Pzzz+zevZstW7YA4OTkxKRJk+jXrx+QHcaeP0e1a9dWhbGkpCRsbGywsLDQe9/6/r4BVqxYwYwZM7CxsaFjx47UqlULS0tLjIyMCA0N5dKlS6Snp+u9D1NTU7KysvRulzJA56yTmJgIZIcybTdgKD1+/FjnuoKaMGECY8eOVf186dIljY4QbcpMGFu0aBE//PADo0ePxtfXFzs7O/7991/mzp3Le++9x8WLF/noo4/02pZCoQAo1m/ryn0UREHbVbFixTwHu4r8kyBWfEFsw4YNfPrpp7luU+TO09MTT09PkpKSiI6OZu/evYSEhDB69Gj++OOPfPeS5Ub5t/38cBElXcu1sbKyIisri5MnTxZJ23LbD+hu23///adWLqf4+Ph818mPNm3asGTJEtLS0jh//jxhYWGsWrWKd999F1tbWzp06ICXlxdeXl46t2FtbU1CQgKpqan5CmT6ePr0KfPnz8fOzo7t27dr9H6V1LNlled97NixfPLJJy903+bm5mqfBxUrVtSrXpkYM3b06FHmzp1L9+7d+eSTT6hbty6Wlpa4uLiwaNEiHBwcWLp0KTdu3AC090rl9OjRI7VyeZXX1qOV330UtI4oeRLEii+INW7cWOOb+PNu377Nd999x7Jly/IcBxkfH88PP/xAYGBgruXKImtra9W0EIMHDyYhIUHn1BQF1bBhQywsLPjrr79U71c55Wd/rVq14uHDhzqnLcgP5fgqbX9Lyjv9Tpw4oXF5DbLHHQNaB3pHRUVpLMvMzFQdZ1ENDjc3N8fV1ZX33nuPzz77DIVCoXFpUpdWrVqhUCgIDw8vkrbklJCQQFJSEm3atNEIYo8fP+bChQtFvk99tGjRAmNjY44fP14i+y+IMhHGDh06BKD1LhlLS0tatGhBVlaWamyA8nZjbXPBPH36lJiYGExNTVUD7ytWrIiDgwOPHz8mLi5Oo87169cBaNCggWqZ8t+65pvRVie3duWso2tMmTAsEsSeKWgQK86HsJcHhw8f1howlD06RT1UwczMjL59+5KcnKwReC9dusTWrVv13pbyMtu0adO4d++exvqUlBS9e16UlzFjY2M11tWsWZNXXnmFmJgYli9frrbu9OnT/P7779jY2Gjc0QjZQe3AgQNqy1atWsXNmzfx8PBQe20q59fK67WidPz4ca1fzJU9eLn9rec0atQoIHueTG2fX9ruptRXtWrVsLS05Ny5c2qX/DIyMpgxY0a+7tgtStWrV6d///6cO3eOhQsXan0N3Lhxg1u3bpVA67QrE5cpldejdf3ilcuVbzzt27dn27ZthIWF0b9/f7Wyx44d48mTJ7Rr107tj93Dw4OtW7cSFham0SV8+PBh1XaV6tWrR61atbh27Rq3bt3SuKNSWx1lmDxy5AhZWVlqd8s8evSI6OhoLCws8vyQFCVPgtgzhhjEcvt9lCUBAQGYm5vj5uam+ls5fvw4Z8+epVmzZgW6ESgvU6ZMISIigl9//ZUzZ87Qpk0b4uLi2LVrF126dCE0NFSvOwE7duzIlClTmDNnDt26dePVV1/F0dGRlJQUbt++zbFjx3B1ddU6bcLzPDw8MDY2Zu7cuVy+fBlra2sA3nnnHSB7GoShQ4fy3XffceTIEZo3b05sbKxqHshZs2Zp/Zvp3r07b7/9Nj179qRevXpcunSJQ4cOUaVKFb766iu1ssoxTbn9Tee0ZMkSjhw5gru7O3Xr1qVixYpcuXKFw4cPY21trbqLMC+dOnXinXfe4aeffqJHjx50796dmjVrcv/+faKjo2nVqhVz5szRa1vPMzY2xs/Pj8WLF9OnTx+6d+9ORkYGkZGRJCYm4uHhUWLPA/3iiy+4ceMG8+bNY+vWrbi5uVG9enXu3bvHv//+y9mzZ5k3b57W2Q5KQpkIY23btiUoKIh169YxYsQItdt3Dx06RHR0NObm5qpHIvXq1YvZs2ezc+dORo0apZprLC0tjR9++AHInl8mJ29vb7Zu3UpgYCA9evRQzTUWExNDcHAwZmZmaiHNyMgIb29v5s6dy6xZs9QmfQ0NDeX48eM0btxY7W6cevXq0alTJ8LDwwkKClL79j5//nxSUlIYMWKE3tegRcmQIPaMIQcxxZi5GmWL6/dRUqZMmUJYWBgXLlzg0KFDmJubq250GjlyZLHcxFO9enU2btzI3LlzOXz4MKdPn6Zhw4Z8+eWXVKxYkdDQUL3D8Pjx43F1dWXlypWcOHGCffv2YWVlRY0aNRg+fLjaXJC5adSoEXPmzGHJkiUEBwerLmcrw5hyMu/AwEAOHTqkmjerc+fO+Pv7q81HmVOPHj0YPnw4gYGBHDx4EFNTU15//XU+/PBDtaseAH///TeAauB9Xnx8fLCxseHMmTNER0eTmZmJg4MDI0eO5M0338zX39t7771Hq1atWLlyJQcPHuTJkyfY2trSvHlzBg0apPd2dG3b1taWDRs2sHbtWqysrHjllVeYPHky8+bNK9S2C8PKyoo1a9awbt06tm/fzp49e0hPT6datWrUr1+fTz/9NN+TEBcnI0VhRpIbiKysLEaPHs2ff/5J5cqV6dGjh2oA/4EDB1AoFHz66aeqbm/Injn5nXfewdzcnH79+mFjY8P+/fu5evUqvXv3ZuHChRofHN988w1Lly7FwcGB3r17k5GRwc6dO0lISODzzz9XdQcrpaWl4ePjw8mTJ2nevDkdOnTgzp077N69mwoVKhAcHEyrVq3U6ty4cYMhQ4YQHx9P9+7dadSoEadPnyYyMpIGDRqwcePGfN85dP78eQYMGMC2bdv0vntKFIwEsWcMOYhpU9aCmCGaO3cuixYtYvny5XpfrjNEyklnZ82alevg+Zy+/vpr1q5dS1hYWL7meBOlm76fv2WiZ8zY2JilS5cSHBzMjh07CA0N5cmTJ9jY2PDqq6/i5+dHp06d1Or07NmTNWvW8PPPP7Nnzx7Vg8I/+eQT/Pz8tH5wTJs2jZdfflnVC6d8UPhbb72l9UHh5ubmBAUFsXjxYrZv387y5ctVYTEgIIDGjRtr1KlXrx5bt25VPSj88OHD2NnZ4efnx6RJk6hSpUqRnTdRtAzhg1+C2DOG8Psor+7du0eNGjXUlv3999+sWrWKqlWrap2fq6yLiopi2LBhEsSEVmWiZ0zkTnrGip8hfPBLEHvGEH4f5Vn79u2pV68eL730kupZhYcOHSIrK4sffvhB78uLhqogPWOifCpXPWNClCRD+OCXIPaMIfw+yjtvb2/27dvHrl27SE5OxsrKis6dO/Pmm2+Wy14xIfIiYUyIQirpD34JYs9IEDMMEydOZOLEiSXdjGKT10SrQuRXmZhnTIiSJEFMgpgQQhSGhDEhCkmCmAQx0D67uxBC6EPCmBCFJEFMgpjy9yGEEAUhYUyIYiJB7JnyEMSuXLmis4wQQuRGBvALUUie/WvwJDVLbVlmphGx96zJyjKiZo0kQvd8q7O+Igti46xJzzChpn0yhw98r3tnCrh3vzIpT8yoYZfMn2Hzcy17P6EiSckW2FV7TOSfPwFgXbUr69ev1yguQSxbYYKxEEIUhISxcsTf3x8LCwt8fHzw9fUt6eaUGU9Ss1i3/NnjUh6nVGDTrhakpZvi1fcsVW2e6Kybnm7Clj0uxCdUwrP3ORzsNR8MrJSZacSuA85cv2VLv+4XaVBX90N4FQo48Gcjzv1Vkx6dLtPs5WcPWvZ9W7M9EsSyFVcPpRCifAkKCiI4OJjU1FS9yksYK0cCAwNl0tdiZuhBTBsJYtkkiAkhioqvry++vr6qSV/zImPGhCgiEsSekSAmhBD6k54xIYpAaQpipkTRu6cdiQ8teZBoiW2VJ0T++RO6R7VB8iNz/ouvhLVVKpFHfiJwge6yKU8qcO8/KypaplOj+iNWLH1HZ9m0NFNi46wwq5BJTfskNq6bqlFGOcZNgpgQoqySMCZEIWVmGpWaIAawfJELUafqEhFdn/au13FvfTPX47vwdw1Cw1+ieZNYunb8h1w6xLh205Yd+5pSv84D+nS9hImJ7kff3o2zYvPu5lSr+phBvc5jZqZ9ni7ft58USxAzev/3HD/ZAXZ8/MNJ4KTuAwSgItCS6b/8DfydR9mCU3xfup/fqMuHH37I5s2bOXz4MI6OjiXdHCEMglymFKKQYu9Zl5ogBpSqIAaQnp5eLD1i5cG5c+dwcnJi8ODBWtdv374dJycnnJycuHPnjsb6lJQUmjRpQvPmzcnIyCju5uaLt7c3Tk5OJd0MIYqEhDEhCikry0iCWDEFsYSHlty6datYLk2WB82aNcPGxoZz586RnKz5NxcREaEa+xcREaGx/vjx42RkZODm5kaFChWKpE0ffvghe/fupUaNGkWyPSHKAgljQhRSzRpJEsSKKYiF7GyBsbFxsYwRKw+MjY1xd3cnMzOTY8eOaayPiIigY8eOWFtbaw1jymUdOnTIdT8ffvih3r1U9vb2ODk5FVm4E6IskDAmRCFVqJClc50EsWcKEsTMzZ5Sp06dYhmsX14og9TzYSsmJoZbt27RoUMH2rVrV6gwlh/K4BYTE6Ox7vTp0/j7++Pu7k6TJk3o2LEjn3zyCffuPfv7jomJwcnJiaioKADVZVYnJye8vb1V5S5cuMDEiRPp1KkTzs7OuLq60qdPH7766iuDu+QqhAzgF6KYFDSI9X7tAjExV4k+mUYNe3M6uFfBxORZIipPQWxwn7OE7jfTWbYwd01mD9Yv+9q3bw/A0aNH1ZYrf/bw8MDMzIx9+/Zx7do1GjRoAMDDhw+5ePEiVatWxdnZudjbGRISwrRp0zA3N6dbt244ODhw/fp1NmzYwIEDB9i0aRO1atXC2tqaSZMmsWnTJm7fvs2kSZNU21DeCXvx4kW8vLwwNjamW7du1KlTh0ePHnHjxg3WrFnD+++/Lz1zwqBIGBOiGBQ0iFmahtJ/6EnuxD4b01SrpjnffdmY/n3sy10Qq1QxA9Aexgo/fUX5CGONGjWiRo0aXL58mfj4eNV5ioiIoHLlyri4uGBmZqZapgxjkZGRZGVl4eHhgbFx8V5EuXbtGp9++il16tRh7dq12Nvbq9YdPXoUPz8/vvzyS3755Resra0JCAggKiqK27dvExAQoLG9LVu2kJ6ezqJFi+jZs6fauocPH2JpaVmsxyNEfsllSiGKWGGC2IefRKgFMYDYu2n4jT/P9l1x5TCIaVdc84iVVR4eHigUCiIjI1XLIiMjadu2LSYmJjRp0oSqVauqXaosjkuUuqxevZqMjAw+/fRTtSCm3H+3bt04cOCA1psQtFHelKAtdNnY2BR7uBQiv6RnTIgiVJhLk/2HnkShJdcoFGBkBO99fA1//0G83kWCmASx/OnQoQPbtm0jIiKCvn378s8//xAXF8e4ceOA7PDSrl07IiMjUSgUGBkZqYKb8jInZI/X6tKli879aBvEP2vWLLy8vHJt36lTpwCIiori7NmzGuvj4+PJysri+vXrNG/ePM/j7devHytWrGDChAn07t2bDh064OrqSr169fKsK0RJkDAmRBEpzGD9mJirGj1iOSkUEB//GDubP2n2cu7tkCCWTYLYM8reLeU4MeX/cwYtd3d3/vjjD/766y+qV6/OlStXcHBwUF22BFTjtZ4XGhrKpUuXtK5r2rRpnu1LSEgA4Lfffsu1XEpKSp7bAmjRogXr1q3j559/Zvfu3WzZsgXIDouTJk2iX79+em1HiBdFwpgQRaCwd01Gn9Rv3itL87uAg871EsSySRBTV6tWLerWrcuNGze4c+cOERER2NjYqA3M9/DwALIvT1avXh3QvESpHK/1vJiYGC5duqR1nT6srKyA7Lsplf8urDZt2rBkyRLS0tI4f/48YWFhrFq1infffRdbW9sXcvlVCH3JhXMhCkmRRaGnr6hhr/vh2DnlVk6CWDYJYtrl7B07duwY7dq1Uxs79dJLL2Fra0tERMQLHS8G0Lp1awBOnDihdx1l2zMzdf+NAZibm+Pq6sp7773HZ599hkKhIDQ0tOCNFaIYSBgTopBi46wLPY9YB/cq1KpprjMUGRlB7VrZ01xoU5aD2NOnTyWIFQHlJclly5aRmJio6glTMjIywsPDg2PHjvHnn3+q1Sluvr6+VKhQgZkzZ3Lt2jWN9enp6Rw/flxtWdWqVQGIjY3VKH/8+HGtg/3v378PZAc0IQyJXKYUopDSM0wKPaGriYkR333ZGL/x5zEyQm0gvzIsfftFY7X5xpRKOohlZirY8Uc6u/ZZU7vWX4wZmoiZme6JcPMTxB6nVODWrVtFHsTy6k0pi9q3b4+RkRF///236ufneXh4sGvXLh49eoSTkxMODroviRclJycnvvvuOz766CN69epF586dadCgARkZGdy5c4cTJ05ga2ur1qPVvn17du3axf/93//RuXNnLCwsqF27NoMGDWLJkiUcOXIEd3d36tatS8WKFbly5QqHDx/G2tqa4cOHv5DjEkJfEsbKEX9/fywsLPDx8cHX17ekm1Nm1LRPLpKZ9fv3sWflLy6899E14h88Vi2vVdOcb7/InmfseSUdxLbvimPKp/9wNy5VtWzd+mfzoj0vv0Fs064WZGXdKvIgFhISwoyqVxg6dCgvvfSSzrIKhYKdO3cSHR1N//79VZfTSqNq1arx8ssv89dff2Fra6v1uHP2lr2oXjGlgQMH4uzszJIlS4iMjOTIkSNYWlpib29Pr1696Nu3r1r5YcOGcefOHXbs2MFvv/3G06dPcXd3Z9CgQfj4+GBjY8OZM2eIjo4mMzMTBwcHRo4cyZtvvik9pqLYBQUFERwcTGpqat6FASOFQtvN9KIsOX/+PAMGDGDbtm24uLiUdHMK5fbt2wQFBWFvb8/IkSNzvdwQHx/PypUri+Uh0zk/+N8c04p1y1toLVuQRxyduVgDO5s/sTS/q3UGfiVDCGJ+489rTMeh3PbKX1zUAllBglhauin79p9kz549OssWJIhduVL0QSwsLIzOnTvnWkbApEmT2LlzJxERERpziglR1uj7+StjxkSpYYhBLPcP/oI9a/L1Lv/gOwy8BjrQqUNVgwximZkKpnz6j8550QA+/uIKmZnZPxQ0iHn1PauaHV4bQwpiBw8ezLWMyHbt2jXMzMywtbUt6aYIYTDkMqUoFcpLECstM+vv+CNd7dKktmO6fSeNo1GJuDSrVeAgVtXmCVBJa1lDC2KvvfZaruXKu6VLl3Ls2DEuXrxI3759MTWVjx8hlOTVIAyeBLFnDCGI3Y2zYtc+61z3rXT1uoK/rhcmiGlniEFMLlHmbtWqVWRkZDBkyBCmTZtW0s0RwqBIGBMGTYLYM4YSxDbvbk7tWn/lun+lS/82pamzBDEBhw8fLukmCGGwZMyYMFgSxJ4xpCBWrepjPvRPzHNetCo2VjR5uaYEMSGEyIOEMWGQJIg9Y2hBbFCv81haZvHdl40BNPahnCdtsGdXhvQ7L0FMCCHyIGFMGKTSFMRQUK6CmHJmfeW8aDUd1H8/NtZWjBszgK8+TpUgJoQQepAxY8IglZYglpmZyb37lctdEFPq38eevq/bcTQqkavXFVz6tylNXq5ZpD1iWVlZEsSEEGWa9IwJg1RaglhISAgpT8zKZRBTMjExwqVZLdLpTVPn2kUaxNLTTYiJiZEgJoQo0ySMCYNUWoLYlStXqGGXXG6DGBRuQte8gtiWPS6kp6dLEBNClGkSxkSpYmhBbOjQoVS01B0+JIg9U5AgFp9QCUdHx1IRxE6dOpXreiGE0EXCmCg1DDGI5f7BL0FMqaBBzLP3OSwsLHSWNaQgtn379lzLCCGELjKAX5QKEsSeKU9BzME+GV2PQzK0IObq6opCocAol1/I5cuX2bBhA40bN8bLywsTExOdZV/E9C6TJ0/O9diEEC+GhDFh8CSIPVP+gph2xRnEVq1axbVr12jQoEGeQWzbtm2cPn2a6tWr06dPn1yD2MGDBwkLC6Ny5coMGjQo1yB26tQp/vjjj2K/q1jkztvbm6ioKP7999+Sbooo4wp8mTIzM5MnTzTfWCMjI5kxYwazZ8/m5s3cP1iEyIsEsWckiGV7UUFs1KhRuZbNGcTefvttjI11v53mDGITJ07EzMxMZ1llT1tRBbHIyEicnJwYNmyYztdHTEwMTk5Opf4GBScnJ7y9vUu6GRrmz5+Pk5MTkZGRJd0UYaAK3DP2zTffsGbNGo4dO4aVlRUAO3fu5L333iMrKwuADRs2sH37dmrVqlU0rRWF4u/vj4WFBT4+Pvj6+pZ0c/IkQeyZ8hzETImid0+77B8UcO9+ZVKemFHDLpk/w+br3C4KuJ9QkaRkC+yqPSbyz590lwVsq7fnpZddufx3NJF//sTa4Pd1lrWyaU7TZp25ceMvIo/sZ8e2LwCwrtqV9evXq5UtSBAzMzMr0h4xgLt37+r1+hDPzJ07V2ungxB5CQoKIjg4mNTUVL3KFziMRUZG4uHhoQpiAAsWLMDKyorp06fz33//MXfuXJYtW8ann35a0N2IIhQYGIiLi0tJN0MvEsSeKc9BDGD5ouy/2eJ85NSmXc25dacqdWol8O6bj4EWOsvuPdyYi1ccsK2SQsC4/zA2flbW9231Yy1oEPP39y+yIKYME1lZWRLE8kk6EkRB+fr64uvry/nz5xkwYECe5Qt8mfLevXvUq1dP9fPNmzf5999/GTVqFAMHDuStt96iS5cuhIWFFXQXohwrTUEMCWIqxXdp8sUEscF9zuVaNmcQ8/GMJpcrk4UKYtbW1jrL5veLyh9//AGAg4NDvoJYzktru3fvZtCgQTRr1ow2bdowceJEYmNjtdZLTExk7ty59OrVi2bNmtGyZUv69u3L7NmzSUlJ0Sg7Z84cevbsSdOmTWnZsiU+Pj6Eh4drbDckJAQnJydCQkI4ePAgw4cPp2XLlqplTk5OAERFReHk5KT6b/78+Wrb+L//+z9effVV1f6GDBnC5s2btR6Lt7e3artKysu+8+fP5+LFi4wbN45WrVrRrFkzhg8fzokTJ9TKd+7cmQULFgDZk1nnbBvApEmTcHJy4tixY1rbsHv3bpycnPjiiy+0rhdlQ4F7xh4/fqz2JhAdHY2RkZHamIPGjRvLNXJRIKUliCkUCu4nVJQghgSxnAwliK1cuZKMjOzfWYUKFXI9Pl1Wr17Nvn376N69O+3atePMmTPs2rWLS5cusXPnTrUevFu3bjFy5Ehu376Ni4sLI0eOJCsri6tXr7J8+XK8vb2pWLEikH23qLe3NzExMbRr144uXbrw+PFjDh48yJgxY5gxYwYjRozQaM/u3bsJCwvj1VdfZcSIEcTExNC0aVMmTZrEggULqF27NoMHD1aVd3d3V/37s88+o1GjRrRt2xZ7e3sePHjAoUOH+PDDD7l69SoffPCB3ufl3Llz/Prrr7Ru3ZqhQ4cSGxvLnj178PX15ffff6dRo0YAjBkzhtDQUKKiovD09MTR0VFtOz4+PuzcuZO1a9fSrl07jf2sXbsWQOu5EGVHgcOYnZ0dMTExqp+PHj2KhYWF2mWwx48f53rHkBC6lJYgtnPnTpKSLSSISRBTMaQglpaWxuuvv87WrVtzPb7chIWFsXXrVl5++WXVsnfffZfff/+d0NBQ+vXrp1o+efJkbt++zQcffMDbb7+ttp0HDx5QqdKzaUo+/PBDbt++zcKFC+nTp49qeVJSEt7e3syYMYPu3btjZ2entp3Dhw+zdOlSunTpora8adOmLFiwAEdHRwICArQey+7du9Wu6ED2+8OYMWP47bffGDlyJDVr1tTrvBw8eJDZs2erBb81a9Ywffp0Vq5cyYwZM4DsMJaUlERUVBSDBw/Gw8NDbTvt2rXjpZdeYs+ePXz22WdUrVpVte7GjRscPXqUNm3aqJ1/UfYU+DJly5Yt2b9/P/v37+fPP/9k9+7dtG/fXu3b161bt6hRo0aRNFSUL6UliEVHR2NX7bEEsVIWxKJO1S2WIGZmZmZQQczPzy/X7erDz89PIwgMGzYMgLNnz6qWnTt3jpMnT9K0aVPGjx+vsR1bW1tVL9qlS5eIioqid+/eakEMwNramoCAANLS0tizZ4/Gdrp166YRxPT1fBCD7F74UaNG8fTpUyIiIvTelpubm1oQAxgyZAimpqZq50UfI0eOJD09XeNy6bp161AoFAZ5h6goWgXuGXv77bfZv38/EyZMAMDY2Jj/+7//U61PTk4mKipK7VuTEIVlaEGsf//+ed6lJ0EsmyEFsYjo+kUexCKi69K0aR2DCmLVqlXjypUrWsumpaXlepOAUvPmzTWWKXuPkpKSVMtOnz4NQKdOnXKd5gOePToqKSlJbUyX0oMH2b9vbfN7tWrVKs8263Lnzh1++eUXjh49yp07dzTudLt3L/e/nZy0nZcKFSpQvXp1tfOij4EDBzJ79mzWrVvHuHHjAEhPT2fTpk1UqVJFI7CKsqfAYaxp06Zs2rSJLVu2ANCvXz9atHh2V9Hff//NK6+8whtvvFH4VgqBYQaxvOatkiCWzdCCmD6/j/wGsahT9YiLu8unn35qMEEMUAUj5ZRD8Oz1MXbsWLV12kJUzjvmlUxNsz86MjOf/S0pA4g+V0MSEhIAOHLkCEeOHNFZ7vkB/4DGZUt93bx5E09PTx4+fEjbtm155ZVXsLKywsTEhJiYGDZv3kx6erre29N2XgBMTEzUzos+KleuzIABA1izZg1RUVG4u7uzd+9e4uPjGTt2rF6hWZRuhZqB39nZGWdnZ63r3NzccHNzK8zmhVCRIPaMBLFshhbEKlmmc+fOHYMKYvAsNCQmJgLqrw8lZTgqzCVNZV19epeUbZo+fTqjR48u8D7zY9myZSQkJDBr1iy8vLzU1m3fvl3nHZUvio+PD2vWrGHt2rW4u7urBu4PHz68RNslXowCjxkbOXJknn+8W7duZeTIkQXdhRCABLGcJIhlM8Qg5jfkeK7bzU8Q++eff4psepeGDRtiZmbGtWvXuHfvntrrQ+nkyZMAhRokrrx8eOTIERQK3X+XOcs+Pw1EYRkbG+vslbp+/ToAvXr10lina1qJoqLsccytx+zll1/Gzc2NP/74g+joaFUP2fNTa4iyqcBhLCoqitu3b+da5vbt28X+Ry7KNgliz0gQy2aoQczMLEtn2fwGsTVr1hTZ9C7m5ub06dOHp0+fMmHCBO7du6f2+oiNjWXJkiUAeHp66j7gPDRv3pw2bdpw4cIFfvvtN431CQkJpKWlAdCiRQvatm3LH3/8wcaNG7Vu7++//+b+/fv5akOVKlV0zn+mnFLi+emWwsLC2LBhQ772k1/KOyR1tU1JOZD/nXfeQaFQyHQW5UixPig8NTVVNbbgRTl+/DjLly/n5MmTPHz4EBsbG15++WVGjx7Na6+9plY2OjqawMBATp8+TVpaGvXq1WPIkCGMGjVK55QcmzZtIjg4mH/++QdjY2OaNWvGm2++SdeuXbWWT01NZfHixezYsYPbt29TuXJlPDw8CAgIUM1D87zY2FjmzZtHWFgYiYmJ2NnZ0aNHDyZNmoSNjU3hTlApUhqDGIB765t5fugrNXv5Xp5hQqlB3QdMHKt7fE1ODvbJ/J/f0TzLlbcglpmp4GhUIvfi0qhhb04H9yqYmGQnYEMKYsbGxkU6vcuHH35IeHg4Z8+eJTExkfT0dCpXrsydO3fYt28fjx494s0336R9+/a6D1oPP/zwA97e3syaNYtdu3ap5s26fv064eHhhIaGqkLRjz/+iI+PDx999BErV66kZcuWWFtbc/fuXf766y8uX75MSEgI1atX13v/HTp0YMeOHYwfP56mTZtiYmJCu3btaNeuHT4+PmzatImJEyfSq1cvatSoweXLlwkLC6NPnz7s3LmzUMeeGw8PD4yNjZk7dy6XL19W/Q288847auV69erFzJkziYuLw9bWltdff73Y2iQMS7EkJYVCQWxsLIcPH8bBwaE4dqHVTz/9xI8//oitrS2vvfaaalK/ixcvEhUVpRbGQkNDVY8c6du3LzY2Nhw4cICZM2cSHR3NTz9p3iH3zTffsHTpUhwcHBg2bBgZGRns2LGDt956i88//1zjwcJpaWmMGjWK6OhomjdvzujRo4mNjWX37t0cPHiQ4OBgjTuDbty4wZAhQ4iPj6d79+44OTlx5swZVqxYofoGl3MemrKqtAax0qS8BbHtu+L46PMr3IlNU5WpVdOc775sjJNTcy5ecdC7h/LEmbo41YvPs4fy9u3b/PHHH9SpU0evZ01u376datWqFfk8e7t27aJfv35UqFCByMhINm/eTGpqKjY2NrRt25YRI0bQrVs33Qetpzp16rB9+3Z+/fVXQkNDCQoKwtzcHEdHR8aNG6fWzpo1a7Jt2zZWrVrFnj172L59O5mZmdjZ2dGoUSNGjRqV78um06dPx8jIiKNHj3LgwAGysrKYNGkS7dq1o0mTJgQHB/PDDz9w6NAhMjMzadKkCT///DPW1tbFGsYaNWrEnDlzWLJkCcHBwaoewufDmJmZGQMGDGDZsmV4eXnlOv5QlC1Girwu7ufQqFEjjP7/u5RCoVD9WxeFQsHbb7/N++/rfuBuUdm5cyeTJk2iY8eO/PzzzxpvZBkZGao50JKTk+natSuPHj1i/fr1qrtA09LSGDlyJKdOnWLevHlqd4JGR0czdOhQ6taty9atW1U9VDExMQwYMICUlBS1b30AixYtYu7cufTu3ZsFCxaoxg2EhoYyYcIEGjduzK5du9TuYBo9ejTh4eF89tln+Pn5qZZ//fXXLFu2jBEjRjBz5sx8nRvls7G2bdtWap5NGRgYWGqCWO+edqxbrvtZhoaoPAYxv/Hnef7dzsgoe9tDhw5lmGeVQl8q9n27Etu3bweyg1hQUBD29vZF+tDv4vqiIgyD8pFK+/bto379+iXdHFFI+n7+5mvMWLt27Wjbti1t27bFyMiIWrVqqX7O+Z+Hhwe9evVixowZvPfee4U+mLxkZWUxe/ZsLCws+PHHH7W+keWcjHb37t08ePBAYzoOc3NzJk+eDGQ/AiSnNWvWAODv7692qdDR0REfHx/S09PVxj4oFApVnalTp6oFrh49etC2bVuuXLmiNn7hxo0bhIeHU6dOHbXBtQABAQFUrFiRLVu28PjxY/1PTilVWoJYaVTeglhmpoKPPr+iEcSU2wbYv38nXTyuFNmYPQlioiBOnTrF8ePH6dy5swSxciZflymV4QKye8m8vLyYOHFikTcqv06ePElMTAy9e/fGxsaGgwcPcvnyZczMzGjZsiVt2rRRK68MQDmfo6nUrl07LC0tOXXqlNqkiMo62mZ+7tKlCz/99JNGsLpz5w4NGzakTp06WuscP36cyMhIOnTooLaPV155RWO+n8qVK+Pq6kp4eDinT5+mY8eOep+f0qi0BLGwsLC8D8bAlKcgBnA0KlHt0qQ28fGPiTiWSKcO2ocASBATxWnVqlXcvXuXzZs3Y2JiwrvvvlvSTRIvWIHHjB0+fLjQj9koKspHT1SvXp0BAwbw119/qa1v164dP/30k+rN6+rVqwBav3mYmpri6OjIlStXuHXrFo0aNSIlJYW7d+9SqVIlrRMOKrdz7do11TLlv3V9u9FWJ7d2KZeHh4dz/fr1AoWxlJQUkpOffUiamZkZ7GSCb41pypNU7YOiFVkQG2dNeoYJNe2TOXzge90bUsC9+5V5nFIBC7N4Nq6fjbm5EbZVK2heZlfA/YSKJCVbYFftcZ4z6yc+tORBoiXNXi7wTcklojwFMYB7cbkHsbzK5SeIpaamShAT+bZkyRLu3r1LvXr1mD59utoVG1G6pKWlqU0erG3iYm0KHMYM6QUeHx8PZPfc1alTh+DgYFq0aMHt27f55ptvCA8PZ+LEiaqePWUg0TWDsnK5ckZpfcvnDDrFUUf5Zp3fR20oPX+b9KRJk3Q+ULekPUnN0joOqyAf/Dv/uMfBAzu4HPcsUCgHbvfvYw8U73QJhqY8BTGAGvb6feHQVi6/04nExFwuNUEsMzNT513j4sUqjT3sQrvFixezYMGCfNcr1N2UGRkZhIaGcvbsWR4+fKj2uA0lIyMjvvvuu8LsJk/KifQUCgU///yz6g6cl156icWLF9OtWzeioqI4efKkxiVLbZT3NOR1g0Jh5OO+CQ0FbdfatWvVnphQ2u7UKWgQW79uI8+f7di7afiNP8/KX1x4o7d9uQliQLkKYgAd3KtQq6Y5sXfTtI4bMzLKDucd3KuoLS/IvG5mZtdLTRALCQlRPfBbCFE0JkyYoHrMGMClS5f0mi+uwGHs7t27jBo1imvXruUaLF5EGFMOqK9Tp47GrdAWFhZ07tyZDRs2cObMGdq0aaO1VyqnR48eAc96qPIqr61HK7/7KGid/KhYsWKB65a0gnzwX71RhYMHlmoEMcj+wDcygo+/uIJFZQ8uXi4fQSw3ZTGIAZiYGPHdl40Z9b/zGuuU32u+/aKxar4xKPgEu46OjqUmiOl6gLgQouDMzc3V3gMqVqyoV70Ch7FvvvmGq1ev8sYbbzBs2DBq1qz5wid4VWrYsCGg+7lqyuXKuV0aNmzIuXPnuHbtGs2bN1cr+/TpU2JiYjA1NVUNvK9YsSIODg7cvXuXuLg47O3t1eooH7PRoEED1TLlv3OOCcurjvI48qpT3u6yKegHf63qh7gXpztQKBRw+04aO//I4H+jyncQg+wes1Fe0XqVNTPLZFj/M3qVNTFR8EaPi3qVNTKCbq/8Q7dX/smzbH5+H05OzRk6tCn79+0k/sGzu5Fr1TTn2y+eXa6Gwj3pYMduC51lDS2IDR06VGc5IcSLVeD09Oeff9KuXTt+/PHHomxPgbRt2xZTU1Nu3LhBenq6xuW3y5cvA8/GubVv355t27YRFhZG//791coeO3aMJ0+e0K5dO7V06+HhwdatWwkLC9N4yOzhw4dV21WqV68etWrV4tq1a9y6dUvjjkptdTw8PIDsZ7tlZWWp3VH56NEjoqOjsbCwKHNTLeSmMD0w0Sf1e5RKA8fLNHvZMtcyZT2IlTYFeeTUMM9Yfp7djohj2mfgh+J75JQhBrHc7ioWQrxYBb4NLC0tjZYtWxZlWwrM1taWvn37kpSUxKJFi9TWHTlyhPDwcKysrFTTUvTq1QtbW1t27typuhMTso/phx9+AMDb21ttO8qfAwMDefjwoWp5TEwMwcHBmJmZqYU0IyMjVZ1Zs2apjacLDQ3l+PHjNG7cGHd3d9XyevXq0alTJ2JiYggKClLb//z580lJSWHQoEF6d3uWdoW9FKbvwG3Xlqm5rpcgZlgK8+xPU1MjOnWoitdABzp1qCpBTAhhEArcM/bSSy/l+aDwF2natGmcPn2aBQsWEBkZSfPmzblz5w579+7FxMSEb775RnW50srKiq+//pp33nmHkSNH0q9fP2xsbNi/fz9Xr16ld+/e9OvXT237rq6ujBs3jqVLl9KnTx969+5NRkYGO3fuJDExkc8//1xt9n2AsWPHcuDAAXbv3o2npycdOnTgzp077N69G0tLS7777juN+cS+/PJLhgwZwldffcXRo0dp1KgRp0+fJjIykgYNGryQpxkYAkUWhR6TlNfAbYDatTQHbuckQcywlLaHsEsQE0Loo8A9Y2+99Rb79+83mEGg1atXZ/PmzYwdO5Y7d+6watUqIiIieO2111i3bh19+vRRK9+zZ0/WrFlD27Zt2bNnD6tWrcLU1JRPPvmE+fPna71jcdq0acyePRs7OzvWrVvHli1baNy4Mb/99pvGcykheyBfUFAQEydOJCkpieXLl/Pnn3/So0cPtmzZovFcSsjuHdu6dSuDBw/mzJkzLF26lJs3b+Ln50dISEi5eC4lZM8jVtjB4cqB24DWD2IjI82B2zlJEDMshhrEHqdkUsXxAFUcD/D06VNVWQliQgh95evZlDkdO3aMoKAgwsPDGTNmDC4uLjrv1GvXrl2hGikKpzQ+m9LZ+SW2rmlaJHfpaXtAdO1amgO3c5IgZlgMNYgBPE7JpPZL2WNAe/fuza5duySICSEA/T9/C3yZ0tvbGyMjIxQKBQsXLsx17itD6T0TpUdN++Qimy7hjd72WFT2YOcfGTRwvIxry1SNgds55feDP6+7MEXhGHIQ00aCmBAivwocxiZOnFisk6KK8s3c/KnOdQWZt+ri5Zr/f/oKS0D3nZMF+eCXMFa8SlMQS09PlyAmhMi3AocxQ32MjijbSnoCUaWcH/yieJWWIAbZDwk3tCDm5OSkVsbMzIzKlStTs2ZNmjVrRp8+fejYsaPGzUQFERISwtSpU5k1a5bGFEBCCN1KZpZWIQrAEINY1455T04qCsfQg1hm5rNtPHnyBB8fH4MJYjlNmjRJVS4pKYnIyEi2bt3Khg0baNmyJT/88EO5m1BaCENR6K9C6enpHDp0iGXLlrFw4ULV8rS0NO7fv6/1eZVC5JehBjG5Ul+ySjqIbd8VR9suUaqfb9y4gYuLC5s3b9ZaviQvTQYEBBAQEMB7772Hm5sb7du3Jzw8nD59+nDmzBlGjRrFgwe6X1dCiOJTqJ6xw4cP89FHH3H//n0UCgVGRkZMnDgRgIsXLzJ06FC+//57jVnuhcgPCWJCG0MIYn7jz2vMYXf79m28vLwICQnB09NTtdwQxogpFAp27txJdHQ0/fv3p3r16syfP5/4+HiioqJYtGgRn3zyiar8uXPn2LJlC1FRUcTGxvLkyRNq1qxJt27d8Pf3p0qVKqqy3t7eREVlB9OpU6cydepU1brDhw/j6OjIvXv32LBhA2FhYdy8eZOHDx9StWpV2rVrh7+/v4xvE+VWgXvGzp49y4QJEzA2NuaTTz7RCFytW7fG0dGR0NDQQjdSlF8SxIQ2JR3EMjMVTJn+j9bJhJWzBb377rtkZmbXN8QgpnysmrGxMf7+/gBs27ZNrc769evZsWMHDRs2xMvLC29vb6pXr86yZcsYMmQIjx49UpX19PSke/fuAHTv3p1Jkyap/lNOuH3s2DEWL16MtbU1vXr1YvTo0bRs2ZI9e/bg6enJxYv6PcNUiLKmwD1jgYGBWFpasnXrVuzs7FiwYIFGmRYtWnDhwoVCNVCUXxLEhDYlHcQA9h54wt17uh+jpVAouHXrFuHh4bi5uZV4EAO0BjElNzc3TE1NiY+PJyYmRvU0kbfffpsvv/wSExMTtfJr1qxh+vTpBAcHM2HCBADVgP19+/bRo0cPrQP427dvT1RUlMaYuvPnzzN8+HBmz57NihUrcj0OIcqiAveMRUdH06NHD+zs7HSWqVmzJv/9919BdyGKmL+/P6+//rrGcy8NkgIJYkKDIQSxhIeW/L5X+2TBGm24ds0gghigM4hB9tNCbGxsgOx50pRq166tEcQARowYQeXKlQkPD89zvzlVr15d680NLi4uqqCWkZGRr20KYYiCgoJ4/fXXVb3OeSlwz9jjx4/zfDRPamqqDOA3IIGBgaVmBv579ytLEBNqDCWIhexsQTXbq3q1+fTp09SrV69EL00q6QpiucnIyGDt2rXs2LGDf/75h+TkZLX39Hv38j/H3sGDB1mzZg3nzp0jISFB7RFSAAkJCdjb6xd2hTBUvr6++Pr6qmbgz0uBw5iDg0OeM+tfvHiROnXqFHQXohxLeWImQUyoGFIQMzd7yofvJLBps+6H0BsZGWFjY0OdOnVKfIyYUm5BLC0tjYcPHwJga2urWj5p0iT27t1L3bp16d69O3Z2dpiZmQGwfPly0tPTdW5TmxUrVjBjxgxsbGzo2LEjtWrVwtLSEiMjI0JDQ7l06VK+tylEWVDgMNalSxfWrFnDyZMnadOmjcb6Q4cOcfLkSdV4AiHyo4ZdcqkIYtdu2ubaTlF4hhbEBvc5S6WKT/nuy8b4jT+PkRFqgUz5mLgBAwYwZsyYEh+sr48TJ07w9OlTqlevrvoCffbsWfbu3UuHDh1YtmwZFSpUUJXPysri119/1WvbSk+fPmX+/PnY2dmxfft2jd6vU6dO5Wt7QpQlBR4zNmHCBKytrRk1ahSzZ89W9ZIdPHiQWbNmMXHiROzt7Rk7dmyRNVaUHxUtdY8bMaQgtmNf01y3JwrP8IJY9t9m/z72rPzFBYcaZmrlbWxs8PPz4/vvvy/xIKbPtEJZWVkEBgZmH1OO8jdu3ACy74zMGcQAzpw5Q2qq5g0MyvFl2oanJCQkkJSURJs2bTSC2OPHj+VmL1GuFTiMOTg4sGLFCuzs7Pj111/ZvXs3CoWC//3vf/z222/Y2dmxfPlytS5vIQrL0IJY/TrSK1bcDDGIKfXvY0/UQQ/Vz/Xq1eOTTz4xmCCW1xix+/fvExAQQFRUFLVq1eLtt99WrVPeUamcOyxnnc8//1zr9pTzjsXGaj4mrFq1alhaWnLu3DkeP36sWp6RkcGMGTNkwllRrhVq0lcXFxf27dvHwYMHOXXqFAkJCVhZWdG6dWu6d++Oqak8bUkUHUMMYn26XirIoYh8MNQgpmRi8qxxlpaWBnFpUlsQmz9/PpDda5WUlMTx48f5999/SU9PVz0OKeeX5xYtWuDq6soff/yBl5cXbm5u3L9/n8OHD9OwYUNq1Kih0YY2bdpgaWnJ8uXLSUhIoHr16gD4+flhZWWFn58fixcvpk+fPnTv3p2MjAwiIyNJTEzEw8ODyMhInccnRFlW6LRkYmJC9+7dVZP9CVEcDDWI5fbBL4qGIQcxgJSUZ2+jtWvXNsggBqjmgjQzM1P9N3DgQHr16kWnTp00HhRuYmLCr7/+yg8//MChQ4dYuXIlDg4ODBs2TDVNzvNsbGwIDAxk4cKFbNq0iZSUFAAGDhyIlZUV7733Hra2tmzYsIG1a9diZWXFK6+8wuTJk5k3b57O4xOirCtwGFu9ejX9+vVTzU0jRHGRICa0MYQg9jilAlv/aALsB6Ci2Vl699Q+96IiC2LjrEnPMKGmfTKHD3yv++AU2dO7pDwxo4ZdMn+Gzc+17P2EiiQlW2BX7TGRf/6ktvolJ/XiiQ8teZCYRUWLBK5evUqXLl10bvratWuYmJgwZcoU+vbti1GOF0hYWJha2cuXL7NhwwYaN27M+vXrtc5PZmpqyrhx4+jVqxdBQUHY29szcuRIzM3NmTNnDnPmzNGoEx8fz8qVK5k8ebLucyBEKVfgMPb555/z9ddf061bNzw9PenSpYvGNyshCkuCmNDGUILYpl0tSM94Nlh98fymVKqoGULS003YsseF+IRKePY+h4N9ss7tvsgnT/i+/URn2VOnTrF9+3ZcXV01gtjzcgYxLy8vrUFM6fbt2xpBTBdlEMutjBBlQYHT07vvvkutWrXYvXs3//vf/2jfvj3ffPMNf/31V1G2T5RjEsSENoYUxNLSTfEe9BeJMV1JjOlaqoJYbgwtiPn5+eXaXiFKuwKHsXfeeYd9+/YREhLC8OHDyczMZNmyZbzxxhv079+fFStWqD1WQ4h8kSAmtDC0IObV9yxVbXT3LkkQe6YwQUzbI5SEKEsKfV2xVatWzJgxg6NHj7Jw4UJee+01Ll++zMyZM3nllVcYP358UbRTlDP3EypKEBNqJIhlkyAmRNlTZHNPmJmZ0bt3b3r37s2DBw9YvXo1P//8MwcOHCiqXYhyJCnZQoKYUCmvQSwzU8HRqETuxaVRw96c9u2qcDiysQQxIcqYIp0ITKFQcOTIETZv3sy+ffvIyMiQQf2iQBrWe5DnBw2Ae+ubeX7IKDV7+Z5e2wRoUPcBE8ce0ausKF7lNYht3xXHR59f4U5smmpZNdtKdOtuR8D4ZAliQpQhRRLG/vnnHzZv3sy2bduIi4tDoVBQp04dPD09GTRoUFHsQghRTuUnGDvYJ/N/fkf1KlvV5glveUflXRCoVDGDUV55P+exKIOY3/jzGg8hj3/wmA0bNtCvuwvNXrZHFwliQpQuBQ5jiYmJ/P7772zevJnz58+jUCioVKkSXl5eeHp60rZt26JspyhnTkRk8sariSXdjDKpunMMyxe5lHQzyqSiujT50edXNIKYkpERfPzFFfq+bqc2+79SfoLYw4cPJYgJYQAKHMbat2/P06dPMTIyokOHDgwePJiePXtiYWFRlO0TRcjf3x8LCwt8fHzw9fUt6ebkKisrix+HfFjSzSiTPj0xsaSbUGYVxWD9o1GJapcmn6dQwO07aRyNSqRTh6pq6/I7hvLu3WgJYkIUg6CgIIKDg0lNTdWrfIHDmKOjI4MHD2bgwIE4ODgUdDPiBQoMDMTFRXpEhCguRXHX5L043UEst3IFuZmlSpV/S0UQe/TokQQ1Uar4+vri6+vL+fPnGTBgQJ7lCxzGQkNDVf9+/Pgx169fJyUlRS5PCiHKraKYvqKGvX6zzecsV9C7iqOja5SKILZy5Ur8/f1zPS4hSrNC3eoYGxvL22+/TZs2bRg4cCAjR45UrTtx4gSvv/46kZGRhW6kEEKUZvmZR6x9uypUs62kc72REdSuZU4H9ypA4aZ3yY0hBbG0NP16C4UorQocxuLi4hg8eDD79++na9eutG7dGkWOEactW7YkPj6enTt3FklDhRCiNMrvhK6HIxvTrXtfAI258JQ/f/tFY0xMjIptnj1DC2LyOCRR1hU4jC1YsID4+HhWrVrFokWLeOWVV9TWV6hQATc3N6Kj874dXAghyqKCzqwfMN6EVb+6UNNBPdjUqmnOyl9c6N/HvlwFsWrVquV6fEKUdgUeM3bo0CG6deuGh4eHzjK1atXixIkTBd2FKMcepT7kg6ARJd0MvVSw8uDbgQEl3QxhYAr7iKNmL9vT93U7tRn4O7hXKXc9YhLERHlQ4DAWHx9P/fr1c9+4qSkpKSkF3YUox9Kz4NCDKiXdDL2YxUrvr1BXVM+aNDExKvT0FRLEhDB8BQ5jNjY23L17N9cy169fx87OrqC7EOXdhFUl3QK9KOZ7lnQThAExlId+SxATovQo8JgxV1dX9u/fz/3797Wuv3btGmFhYblexhRCiLJEgtgzEsSE0F+Bw9hbb71Famoq3t7eHD58mCdPsh+cm5KSwqFDh/jf//6HkZER48aNK7LGCiGEISttQezRo0cSxIQwAAW+TNmqVSu+/vprpk+fzptvvqla3rJly+wNm5ry3Xff8dJLLxW+lUIIUQqUpiB27aYtd+6ckyAmhAEocBgD8PLywtXVldWrV3P69GkSEhKwsrKiVatWjBo1ioYNGxZVO4UQwuCVpiC2Y19TKle+ViqCWFpaWq77FaK0K1QYA2jQoAGffvppUbRFCCFKtdIUxOrXeUDNmjVLRRBbvXo1Y8eO1X1QQpRyhQ5jQpR3RoqnpWZONIC/MsxKugnljiEGsT5dL7Fhc0WdZQ0piMXFxek+KCHKAAljQhRSesXqHHrwtKSboTfj1MSSbkK5YqhBzMREobOsoQUxX19f3QcmRBkgYUyIwvrfspJuQb4ofuxf0k0oNySIPVOYIFa7dm3dBydEGSBhrBzx9/fHwsICHx8f+aYpRDGTIPaMBDFR3gQFBREcHExqaqpe5SWMlSOBgYG4uLiUdDOEKPMkiD0jQUyUR76+vvj6+nL+/HkGDBiQZ/kCT/oqhBBCkwSxZySICaEfCWNCCFFEJIg9I0FMCP1JGBNCiCJS2oJYamqqBDEhDICEMSGEKCKlKYjdjbMiJiZGgpgQBkDCmBBCFJHSFMQ2726OmZlZqQhimZmZOtcJURZIGBNCiCJSmoJYtaqPcXR0LBVBLCQkROd6IcoCCWNCCPECGFoQG9TrPMbGuj8CDCmIXblyRWcZIcoCCWNCCFHMDDGImZnpvvRnaEFs6NChOssJURZIGBNCiGIkQSxbYYLYSy+9pLOsEGVBmQ1jW7ZswcnJCScnJ9avX6+1THR0NGPHjqVNmzY0a9aMPn36sHz58lwHi27atIlBgwbRvHlzWrZsibe3NwcOHNBZPjU1lXnz5tG9e3ecnZ1p27YtEydO5J9//tFZJzY2lqlTp9K+fXucnZ3p3LkzM2bM4OHDh/qfACFEiZMglk2CmBC5K5Nh7M6dO3z55ZdUqlRJZ5nQ0FBGjBjB8ePH6dmzJz4+PmRkZDBz5kwCAgK01vnmm2+YMmUKcXFxDBs2jIEDB/L333/z1ltvsWrVKo3yaWlpjBo1ioULF1K5cmVGjx5Nx44d2bt3LwMHDuT06dMadW7cuMGAAQMICQmhRYsWjBkzhjp16rBixQq8vLxISEgo8HkRQrw4EsSySRATIm9l7tmUCoWCqVOnUrVqVXr27MmSJUs0yiQnJzNt2jRMTExYvXo1LVq0AGDy5MmMHDmS3bt38/vvv/PGG2+o6kRHR7N06VLq1q3L1q1bsbGxAeCtt95iwIABfPvtt3Tt2hVHR0dVnWXLlhEdHU3v3r1ZsGCBarBs3759mTBhAh999BG7du1SG0T7+eefEx8fz2effYafn59q+ddff82yZcv4/vvvmTlzZtGeNCFEkSotQcyUKHr3tCMjw5jYe9YYGyuoWSOJHdu+0LndzEwjYu9Zk5VlRM0aSYTu+Va1TqFQ8CAhg7Q0BebmRlS1qcDd/2xIzzChpn0yhw98r/vgFHDvfmVSnphRwy6ZP8Pmq622rtpV51UOIUq7MhfGVqxYQUREBGvWrCEiIkJrmd27d/PgwQM8PT1VQQzA3NycyZMn4+vry+rVq9XC2Jo1awDw9/dXBTEAR0dHfHx8+Omnn9i4cSPvvfcekP2mpKwzdepUtcDVo0cP2rZty/Hjx4mMjKRDhw5Adq9YeHg4derUwdfXV63NAQEBrFu3ji1btvDxxx/n2usnhCg5pSWIASxf5ELCQ0tCdrbA3Owpg/ucpVLFDJ3bfZxSgU27WpCWbopX37NUtXmiWrd9VxwffX6FO7FpqmVVq1Smd582fPZBBg72yTq3m5lpxK4Dzly/ZUu/7hdpUPeBRhnft59oqSlE2VCmLlP+888/zJkzh9GjR9OuXTud5SIjIwHo3Lmzxrp27dphaWnJqVOnSEtL06jTpUsXjTrKZcoykB2s7ty5Q8OGDalTp45edZT/fuWVVzRuOa9cuTKurq6kpqZqvbwphCh5pSmIAUUaxPzGn1cLYgAJiY9YuzaEYyf+1bldfYKYEGVdmQljT58+5f3336dWrVp88MEHuZa9evUqAPXr19dYZ2pqiqOjI0+fPuXWrVsApKSkcPfuXSpVqoSdnZ1GHeV2rl27plqm/Le2feiqk1u7ci6/fv261vV5SUlJITk5WfVfzrAphCi88hjEMjMVfPT5FRS6m8XHX1whM1OzgAQxUdakpaWpfc6mpKToVa/MXKZcuHAhFy9eZP369VhYWORaNjk5u7vcyspK63rl8qSkpHyVV5YrrjrKAbXKduXXiBEj1H6eNGmSzpsVhBD5V96CGMDRqESNHrGcFAq4fSeNo1GJdOpQVbU8P0FMoYB79+7x5Zdf0r9/f1q3bq2zLEBYWBgHDx7ktdde03oFJKdTp06xfft2XF1d6du3L0a5/EIuX77Mhg0baNy4MV5eXpiYmOS6bVH+LF68mAULFuS7XpkIY2fOnGHRokWMGzeONm3aFHp7iv//FS+3F2VR7aMgCtqutWvX4uzsrPrZzMyswG0QQmjKK4hB9iOT8npsklKDug+YOPaIXmUd7JP5P7+jepWtavOEt7yjeJxSoVBBDOBenH497DnL5TeIHfizEYmJh0pNELt9+7Y89LycmjBhAmPHjlX9fOnSJY2OEG1K/WVK5eXJBg0aqAbP50Vbr1ROjx49UiuXV3ltPVr53UdB6+RHxYoVsbKyUv2X2zPphBBlX2GDGEANe/3eR5TlChLEzv1VEwcHh1ITxIKCgnLdtyi7zM3N1T5nK1asqFe9Uh/GUlJSuHbtGv/88w9NmzZVTfTq5OSk6iqcNm0aTk5OzJgxA4CGDRsC6uO1lJ4+fUpMTAympqaqgfcVK1bEwcGBx48fExcXp1FHOYarQYMGqmXKf2vbh646ubUrZx1dY8qEEKIo6BvEANxaV6NqFd1zkhkZQe1a5nRwr1LgINaj02W1u9i1MaQgZm9vn+v+hXheqb9MaWZmpvO5ZRcuXODChQu4ubnRsGFD1beq9u3bs23bNsLCwujfv79anWPHjvHkyRPatWun1nPk4eHB1q1bCQsLw8vLS63O4cOHVdtVqlevHrVq1eLatWvcunVL445KbXU8PDwAOHLkCFlZWWp3VD569Ijo6GgsLCzy/HYohBAFlZ8glp5uwvZQF3r3qcLatSEAagP5lRnn2y8aA8YFDmLZl3V1T+djaEFs5MiRubZBiOeV+p4xCwsLvv32W63/devWDQBPT0++/fZb+vXrB0CvXr2wtbVl586dnD17VrWttLQ0fvjhBwC8vb3V9qP8OTAwUO2xRDExMQQHB2NmZqYW0oyMjFR1Zs2aRVZWlmpdaGgox48fp3Hjxri7u6uW16tXj06dOhETE6PRzT1//nxSUlIYNGiQ3t2eQgiRH/kNYlv2uBCfUInPPshg5S8u1HRQv2RZq6Y5K39xoe/rNQoZxHQzxCAmQ0BEfpX6nrGCsLKy4uuvv+add95h5MiR9OvXDxsbG/bv38/Vq1fp3bu3Krgpubq6Mm7cOJYuXUqfPn3o3bs3GRkZ7Ny5k8TERD7//HO12fcBxo4dy4EDB9i9ezeenp506NCBO3fusHv3biwtLfnuu+805hP78ssvGTJkCF999RVHjx6lUaNGnD59msjISBo0aMD7779f7OdHCFH+FDSIefY+h4N9Mv372NP3dTuORiVyLy6NGvbZlyYL3yOmmwQxUVaUyzAG0LNnT9asWcPPP//Mnj17SEtLo169enzyySf4+flpfaFOmzaNl19+maCgINatW4exsTHNmjXjrbfeomvXrhrlzc3NCQoKYvHixWzfvp3ly5dTuXJlevToQUBAAI0bN9aoU69ePbZu3cq8efMICwvj8OHD2NnZ4efnx6RJk6hSpUpxnA5RrhjxxquJJd0IvVV3jmH5IpeSbkaZVtggpmRiYlSo6SskiInyykhRmDkWRKlw/vx5BgwYwLZt23BxKR0fakZGRjB5e0k3o0yqMN+TiCml526vT09MZN3yFnkXFAVSVEHseUUdxHzfrsT27dnvCRLERGmh7+dvqR8zJoQQomBKSxDLSYKYKIskjAkhRDklQSybBDFR0iSMCSFEOVWaglh8fLwEMVFmSRgTQohyqrQEsahTdbl//36pCWLx8fG5tlGI50kYE0KIcqq0BLGI6PpUr1691ASxlStX5tpOIZ4nYUwIIYQaQwti7V2vU61atVzLGlIQk8uXIr8kjAkhhFAxxCDm3vpmrmUNLYj5+fnl2l4hnidhTAghBCBBLKfCBLHKlXU/OF0IbcrtDPzlkb+/PxYWFvj4+ODr61vSzRFCGBAJYs9IEBOFFRQURHBwMKmpqXqVlzBWjgQGBpaaGfiFEC+OBLFnJIiJouDr64uvr69qBv68yGVKIYQoxySIPSNBTJQUCWNCCFFOSRB7RoKYKEkSxoQQopySIJZNgpgoaRLGhBCinCpNQezhw4cSxESZJWFMCCHKqdISxC78XYO7d++WmiD26NGjXI9HiOfJ3ZRClDMZRsa4zS49U5sYK56WdBPKrNISxELDX6JKlX9LTRBbuXIl/v7+uR6XEDlJGBOivJkUUtItyBfFj/1LugnljqEFseZNYomOrlFqglhaWlquxyXE8+QypRBCCBVDDGJdO/6Ta1lDC2LyOCSRXxLGhBBCAIYbxHLpEDPIIJbXQ82FeJ6EMSGEEBLEcpAgJl40CWNCCFHOSRB7RoKYKAkygF8IIcqx8hrEMjMzCQ8PJzY2lpo1a9KpUycSExMliIkSIWFMCCHKqfIaxDZv3kxAQAAxMTGqsrVq1aJHjx60bdtWgph44SSMCSFEOVWagpgpUXTpVIt7/1lR0TKdGtUfsWLpOzq3m5ZmSmycFWYVMqlpn8TGdVMBuHsvjdNnNedXu3PnDitXruRU9BZ2bPtC53YzM42IvWdNVpYRNWskEbrnW63lrKt2Zf369boPXIgcJIwJIUQ5VVqCGMBnH3dmx76m1K/zgD5dL2FiotBZ9m6cFZt3N6da1ccM6nUeM7NMADIzFTT3OKqznpERxD9I4+BOV0xMNBvzOKUCm3a1IC3dFK++Z6lq80TntkaOf8yyZcuIi4vD19eX2rVr6yybmZlJSEgIV65cYejQobz00ks6yyoUCnbu3El0dDT9+/endevWOssChIWFcfDgQV577TU6d+6ca1lRcmQAvxBClFOlJYhdu2lb6CAGcDQqkTuxuidkVSjg9p00jkYlaqzLTxBLTzchJiZGgpjQm/SMlSP+/v5YWFjg4+ODr2/peRyOEKJ4lKcgBnAvTr+Z8Z8vl98gtmWPC+npeySIlWNBQUEEBweTmpqqV3kJY+VIYGAgLi4uJd0MIUQpYGQE3V75h26v5D77vZJ765t5hjClZi/fyzPcKTWo+4CJY4+QmWlUqCAGUMNe95QWusoVJIjFJ1TC0dGxVASxU6dO5bk9kX++vr74+vpy/vx5BgwYkGd5uUwphBDC4BU2iAF0cK+CQw0LndsxMoLatczp4F4FKHgQ8+x9DgsL3fsxpCC2ffv2XMuIF0PCmBBCiFJL3yAGkPSoIj179gHQuDSq/PnbLxpjYmJUqCDmYK95t6aSoQUxV1fXXMuJF0PCmBBCiFIpP0Es4aElITtb4ObqxG8LW1HTQf2SZa2a5qz8xYX+fezLVRDr27dvrmXFiyFjxoQQQpQ6BQli5mZPGdznLJUq2uLZvwNHoxK5F5dGDfvsS5PlrUesb9++GOV294R4YSSMCSGEKFUKF8QyADAxMaJTh6pqZSWIiZIilymFEEKUGkURxLSRICZKkoQxIYQQpYIEsWckiJUtcplSCGHgjHjj1cSSboReqjvHsHyRzOVXHEpbEFMoFBLEhN4kjAkhDJqpsQk/DvmwpJuhl09PTCzpJpRZpSmIZWYaERsbK0FM6E0uUwohhDB4pSmI7TrgzKNHjySICb1JGBNCCGHwSlMQu37Lllq1apWKIHb58uVctyVeDAljQgghDF5pCmL9ul+kcuXKOssaUhDbsGFDrtsTL4aEMSGEEKWWIQaxBnUf6CxraEGscePGuW5TvBgSxoQQQpRKEsSeKWgQ8/LyynW74sWQMCaEEKLUkSD2TGGCmImJSa7bFi+GTG1Rjvj7+2NhYYGPjw++vr4l3RwhhCgQCWLPSBAzTEFBQQQHB5OamqpXeQlj5UhgYCAuLjIhpRCi9JIg9owEMcPl6+uLr68v58+fZ8CAAXmWlzAmhBCiVCjPQSwzM5Pw8HBiY2OpWbMmlStXZufOnRLEyggJY0IIIQxeaQtiQJEFsc2bNxMQEEBMTIxqmbW1Nf7+/kUaxG7fvk1QUBD29vaMHDkSc3NznWXj4+NZuXIl5ubm+Pn55TqVx6NHj1i5ciVpaWn4+flRrVo1nWXT0tJYvXo1cXFx+Pr6Urt2bZ1lyxIJY+WUIbyQ8vMQXSFE+VaagphCAffu3SuyIObl5YVCoVBbnpSUxHfffYebmxuenp5atytBrPSQuynLIUN4IUkQE0LkR2kKYgf+bERiYmKRXJoMCAjQCGI5vfvuu2Rmak6IK0GsdJGesXLGEF5IEsREfmQYK3ALHFfSzdCLRZp+d06J/CtNQezcXzVxcHAo9GD98PBwtUuTmvtTcOvWLcLDw3n11VdVy8tyEMvMzCyTY94kjJUjDx8+ZO/evSX+QpIgJvKlQXt4ml7SrdBL+rVjJd2EMqs0BbEenS4THW2T6/Hoc9dkbGxsrtvQVq6sB7GQkBCGDRums0xpJWGsHNmxYweOjo5F8kJS3tlz8+ZNzp8/T5UqVfDz85MgJopevykl3QK9KX7sX9JNKHcMMYg1e/keppynd087reUTH1ryINES2ypPiPzzJ77Vsd34B/p9Cfnx+wmsWj6JlCcVuPefFRUt06lR/RErlr6js05amimxcVaYVcjkpZfbMHbsWJ1lDSmIXblyRWeZ0kzCWDlSoUKFInkhabuzp2bNmjRp0kTnQNL8BLHcxkcIIYSSoQYxgOWLtM/pGHWqLhHR9Wnveh331jdzPb6zF+3o57WbpKQkreuNjKBWTXP2bHbl5u1q7NjXlPp1HtCn6yVMTHS/j96Ns2Lz7uZUq/qYQb3OMy4gTWdZQwtiQ4cO1VmuNJMB/OXIG2+8USRBzMvLS2Mcw927d/Hy8mLz5s0adfIbxHbu3JmPoxJClEeGHMR0yU8Qu/B3DQ4cbcL4N90xMsoOXjkpf/72i8aFCmJmZpqD/5UMMYiV1SsqZSKMJSQksH79eiZMmMBrr71G06ZNadmyJUOHDmXDhg1kZWVprRcdHc3YsWNp06YNzZo1o0+fPixfvlzrnSlKmzZtYtCgQTRv3pyWLVvi7e3NgQMHdJZPTU1l3rx5dO/eHWdnZ9q2bcvEiRP5559/dNaJjY1l6tSptG/fHmdnZzp37syMGTN4+PCh/idFC0tLS53r9L00qevOHuWy5+/sKUgQi46Ozs9hCSHKmfIQxELDX6J5k1imvZfJyl9cqOmgPp6rVk1zVv7iQnOXJhLEyoAyEcZ2797NtGnTOH36NK1atWLMmDH06tWLy5cv8/HHH/POO+9oBIjQ0FBGjBjB8ePH6dmzJz4+PmRkZDBz5kwCAgK07uebb75hypQpxMXFMWzYMAYOHMjff//NW2+9xapVqzTKp6WlMWrUKBYuXEjlypUZPXo0HTt2ZO/evQwcOJDTp09r1Llx4wYDBgwgJCSEFi1aMGbMGOrUqcOKFSvw8vIiISGhSM5ZTvq+kPJzZw8UPIj17y/jboQQ2pWnINa14z8YGUH/Pvaci+zA7xtas+Snpvy+oTVnIzpIECtDjBRlYIDO0aNHefz4MV27dlW7c+S///5j0KBBxMbG8tNPP9G7d28AkpOT6dq1K48ePWL9+vW0aNECyP5DGTlyJKdOnWLevHm88cYbqm1FR0czdOhQ6taty9atW7Gxyb5TJiYmhgEDBpCSkkJoaCiOjo6qOosWLWLu3Ln07t2bBQsWYGycnX1DQ0OZMGECjRs3ZteuXarlAKNHjyY8PJzPPvsMPz8/1fKvv/6aZcuWMWLECGbOnJmv86N8NlZdx0dYmKv3EmZmGhF7z5qsLCNq1kiiQgXtvYgAd+6kcfaC7jczpRYuVtRyMOfe/cqkPDGjhl0yFS113wmFAu4nVCQp2QK7ao+xqpzGntD7MHm73scohCEw+rE/Cbe6lnQzhAEpbBDT5dpN2yILYr5vV2L79uz3WwliRUv5+btt27Zcnw1dJgbwd+jQQetyOzs7vL29+f7774mKilKFsd27d/PgwQM8PT1VQQzA3NycyZMn4+vry+rVq9XC2Jo1awDw9/dXBTEAR0dHfHx8+Omnn9i4cSPvvfcekN3To6wzdepUtcDVo0cP2rZty/Hjx4mMjFS1/8aNG4SHh1OnTh18fX3VjiUgIIB169axZcsWPv74YypVqpTv8/Tt541xfvlZV3d+v2F+t8CGsxdC8tzPjE8bk/SkQ6G+YVZxPJiPIxNCCMNTGoJYThLESk6ZuEyZmwoVKgBgavosd0ZGRgJondulXbt2WFpacurUKdLS0jTqdOnSRaOOcpmyDGQHqzt37tCwYUPq1KmjVx3lv1955RW18AZQuXJlXF1dSU1N1Xp5M78K0tVvW+0lHOwtdL5JGBlB7ZrmJD72KJaufiGEKC0kiGWTIKafMtEzpsvTp09Vd/flDF5Xr14FoH79+hp1TE1NcXR05MqVK9y6dYtGjRqRkpLC3bt3qVSpEnZ2mvPGKLdz7do11TLlv7XtQ1ed3NqlXB4eHs7169fp2LGj1jK5efd/yZgZPSELBQnGT1Bwg6oKC7b/qjuTK4BE4yc85SZVFJZUNa7JXcU17WUVYIId38zaj43Cgr2rcp8lOdkojRSjGKwVFuwPfu5PMZc3IyGEMHSlKYilp6dLECsiaWlppKc/mx8uJSVFr3plOozNnj2by5cv06VLF7UwlpycPe7JyspKaz3lcuXcLvqWV5YrrjrKF4iuOWfycurOFdLTMzBGgRGQqUfi0VrW2Bi03KFq9P/au++wqK78f+DvoYugoIJKERlbQGPs2BBJRGMLUdHEgmySzcaNUWLcxCRmU40xrhqJUZNvFpHFSuyxBWMDC6goVhRjQUEFRREQpd7fH/ObGYYpDPXOhffrebLPOufOnTP3M/ecD+eee4+ZGdIz76Iks+L9yiDADEApZNDZnJhbVrgPIiJTJZVE7NHjRrh9+4ZkEjFBECAzdKBE9vPPP+PHH3+s9PvqbTIWERGB8PBwyOVyLFq0qFLvVd7TUJsBr859E1Wtl+2kBXjb5SmsZSWIzO+ArFIbvdtaoQRTbP+Cs/lTRD3pgPTScnPUSkuA9EvAk4cwa+yAce1t0ckqDxufynG1WP8yIDIIGGFzG70sH2DHszY4U9SiSt+FyDTJMHpwttiVMFoLrzS9Dyel6pFKIrZpV1eYmaVKJhHbtWsXRo0apXcbsU2bNk1jNYPk5GRMnDixwvfVy2QsIiIC8+bNQ/v27bFmzRo0a9ZMo1zXqFRZeXl5GttVtL2uEa3KfkZV31MZo2xuw1rmWP1EDADMzAH352GOUgQ1uoEOFjlMxKjBszAzxw/jPxS7Gkb77NQMsavQIJlSImZtVQx3d3fJJGKJiYkmnYxZW1trrPFpa2tr1Pvq3QT+X3/9FfPmzUPHjh2xdu1anXO85HI5AM35WkrFxcVIS0uDhYWFauK9ra0tWrVqhSdPniAzM1PrPTdv3gQAeHp6ql5T/n9dn6HvPYbqVfY9+uaUVcQKNTAiVgYTMSKiyjG1RGzciHMaN7iVV5VE7N69e2jXrh1iY2Nx6NAhnQ9S53MoNdWrkTHlc728vb0RGRmpNSKm1K9fP2zfvh2xsbFagT1x4gSePn2KPn36aGS3ffv2xbZt2xAbG4ugoCCN9xw+fFi1XyUPDw+4uLjgxo0buH37ttYdlbre07dvXwDAkSNHUFpaqnFHZV5eHhITE2FjY4Pu3bsbfUzKWvO0PQqt9SdiAFAIc6zK72TU/kpgho1P2xm1rQAZdj1rg13P2hi1PRFRfWOKiVhj2yIAVjq3rUoiduDAARw4cAB3795Vlbm5uSEsLEy1dnF1ErGq9n+mrt6MjC1btgyLFi1Cly5dEBUVpTcRA4CXX34ZzZo1w65du3Du3DnV6wUFBViyZAkAYNKkSRrvUf57+fLlGssSpaWlYc2aNbCystJI0mQymeo933//vcaSTPv27cPJkyfRoUMH+Pj4qF738PCAr68v0tLSEBUVpfH5YWFhyM/Px5gxY4we9iQiItNguomYblVNxNatW6eRiAFAenq6au1iJmK61YuRsc2bN2Pp0qUwNzdH7969ERkZqbWNq6urKlmyt7fHt99+i/feew+TJ0/GqFGj0LRpU+zfvx/Xr1/H8OHDta5J9+zZE2+99RbCw8MxYsQIDB8+HEVFRdi1axeys7PxxRdfaDx9HwDefPNNHDhwAHv27MHYsWPRv39/3LlzB3v27EGjRo2wYMECreeJffXVVxg/fjy+/vprHDt2DO3bt0dSUhLi4+Ph6emJ2bNn1/DRIyKi2tQQErF79+7hwIEDetculslkCA0NRUFBAa5du1bjiVhsbCwOHjwIf39/nc8QLevMmTPYsWMHevbsiZEjRxq8KS4lJQXR0dHo0KEDgoKCNFb5KS89PR1RUVFwdnbG5MmTNa6uVaReJGPK9RJLSkoQERGhcxsfHx+NkauhQ4di3bp1WLFiBfbu3YuCggJ4eHhg7ty5CAkJ0RmcTz/9FJ06dUJUVBQ2bNgAMzMzdO7cGW+//TZefFF7CRRra2tERUXh559/xo4dOxAREQE7OzsEBAQgNDQUHTp00HqPh4cHtm3bhqVLlyI2NhaHDx+Gk5MTQkJCMHPmTDg4OFTxKBERUV1rCIlYZmYmOnTooDUiVpYgCEhLS8Off/6JOXPmMBErp14kY6GhoXoX9zakV69eWLVqVaXeM27cOIwbN87o7W1sbPD+++/j/fffN/o9Li4uWLhwYaXqRUREpqWhJGLBwcGIjY3V/+XK6Ny5MxMxHerNnDEiIiJT0ZASMVdXV7Ru3Vr/FyyjR48eessaaiIG1JORMSIiIlMipUQMxSfRr283lJbK0LplDvbt/U7vpkIpcDezCQqLzNHaOReHDyxWvC4IsLY2Q0GB9uosSjbWZljwbRC+n6/jgAjAg0e2yMm1gVPzJ4g/+pPe/TRxfBHTp0+vN4kYwGSMiIioxkklEXuSb4mAYcEoKLRA0MhzcGz6VO+2hYXm2Lq3C7IeNcbY4efRylnzAeU7dmci5J0LABRrFSvJ/v///N8yb7wywllrv4IAHDjaHucvt0aAbwo6d8rQWwcAGDEhrV4lYgCTMSKiGlMkM0OvhcFiV8NoZkKx2FWot6SSiG3e3bVGEjEAeGWEMyJ/6YKPv7iKO3cLVK+7uFjjuy871EgilnCmDR48OCaZRKzso7AMYTJGRFRTZm4SuwaVIvxQP59mbgoaWiKmNHJYSwjmg3D4SB7ae1zG895F6O/jAHNz7QNSlUTseGJbtGiRIolELCsrCzt37jRYTyUmY0RERHWkPidiJSUy7D7ghVvpzTDj7Ux4ttG/3mVVE7F+PW8iMVH/zQWA6SRikZGRsLS0NFhXJd5NSUREVAcaQiJ283YzjBpyCZ5tHurdtjqJmE/3Wwa3NaVEzNraGqNHjzZYXyUmY0RERLWMiZhCQ0rEQkJC0KhRI4N1VuJlSiKiBkuG0YOzxa6EUVp4pSFiZRexq1ElTMQUGlIiZmtri3HjxuHZs2cG663EZIyIqIGyMDPHD+M/FLsaRvns1Ayxq1Blnm0eYsabR4zatpVzLt4NOWbUto5Nn+LtSQlGbdvYtghTgxIr3K4hJmIlJSWIi4vD3bt30bp1a/j6+sLc3LxaI2J2dnZ44403cOHCBQQGBhqsP8BkjIiIiNAwE7EtW7YgNDRUtcY1ALi5ueHzzz9HVlZWlROxyuKcMSIiogauoSZiQUFBGokYoLg0+Y9//AO3b9+uk0QMYDJGRETUoDXERKykpAShoaEQBO35e8rXduzYAQsL/RcQayoRA5iMERERNWhSS8QeP35c7cn6cXFxWiNi5aWlpSEuLk5nWU0mYgCTMSIiogZNSonYxSstce/evWrfNXn37l2Dn2Nou8okYk+f6r9rtSwmY0RERA2YlBKxfXEd4eDgUO3HV7Ru3drgZ+nbrjKJWF5eHn7//XejPod3UxIRNVBSWtici5rXHiklYs8/dxeJiS2r/RwxX19fuLm5IT09Xee8MZlMBjc3N/j6+qpeq2wiFhkZiaIi/c9+K4vJGBFRQyWhhc25qHndM8VE7MUBf2HN2gsYPtRJ57b5Ty2Rcd8eto0K0bJFHlaHv6d3vw5NipGWpvsBvIIgoLljNkYNbwUAKCoyw92MJjAzE9C6ZQ52bv9S735LSmS4m9EEpaUyNHPMA2Br8PsBTMaIiIioHFNNxGQy6F2JoSorHaTeTMLvv+/DnXsFqjJXF2t892UHvDLCGUD1Vjq4dy8bk9+ueH4akzEiIiJSMeVETJ+qLjn194kFmP9ZfxxLyEZGZgFaOlujv48DzM0VH1bdJafu3TP4FVWYjBERERGAhpWIqdf+lMG3v6PWtrW19qcuvJuSiIiIGmgipltdJmIAkzEiIqIGj4mYWl0nYgCTMSIiogaNiZiaGIkYwDljREQkCTKMHpwtdiWM1sIrTe9df6aGiZiCWIkYwGSMiIgkwMLMHD+M/1Dsahjts1MzxK6C0UYHXDJqO5kMeGngX3hp4F9Gbe/T/VaFSZhS504ZFSZ3SlJKxIqKtR84qwsvUxIREZFkSCURKyw0x8Fj7Yz6ThwZIyIiIsmQSiK2dW8XPM4p0LtNWRwZIyIiIsmQSiKW9agxXhxg3CVdjowRERGR5JlaIjZ2+Hk8evTEqLozGSMiIpNXJDNDr4XBYlfDaGZCsdhVaFBMMRFr5ZyLR4+Mqz+TMSIiMn0zN4ldg0oRfnhF7Co0GKaaiFUG54wRERGRJNWHRAxgMkZEREQSVF8SMYCXKYmIiGqBdFYMkNJqAUr1KREDmIwRERHVOCmtGCCl1QKA+peIAbxMSURERBIipUSstNTAIptlcGSMiIiIJOPdkGNGbefY9CnenpRg1LaNbYswNSjRqG2trErw2itnjdrWzEz/A2rLYjJGRERUw2RCMf4VNVHsahjlcpGV2FVo8JiMERER1bBC2xY49FAaD341e/pYMjcbANK84aAiTMaIiIhq2j9WiV0Do5mHjZXMzQaA9G44MAYn8BMRERGJiMkYERERkYh4mZKIiKgB4yLs4mMyRkRE1JBxEXbR8TIlERERkYg4MkZEREQSIp11PwuNvKTKZIyIiIgkQ0rrfl5/mI6P962ocDsmY0RERCQZUrrhwMrKEm6tW1e4HZMxIiIikg4p3XCQfRs4tLjCzTiBn4iIiEhETMaIiIiIRMRkjIiIiEhEnDNmou7evYulS5ciNjYW2dnZcHJyQkBAAGbOnImmTZuKXT0iIiKqIUzGTFBqairGjx+PrKwsDBkyBO3atcPZs2exevVqxMbGIjo6Go6Ojkbvr6ioqBZrS0RERNXBZMwEffHFF8jKysLnn3+OkJAQ1evffvstVq1ahcWLF2PevHlG74/JGBERkeninDETk5qairi4OLi7uyM4WPM5KqGhobC1tcXWrVvx5MkTkWpIRERENYnJmImJj48HAAwcOBBmZprhsbOzQ8+ePfHs2TMkJSWJUDsiIiKqabxMaWKuX78OAGjbtq3O8rZt2yIuLg43b97EgAEDjNpnQUEBAMAyN6NG6khEREQVU/a7yn5YHyZjJiY3NxcAYG9vr7Pczs4OAJCTk2P0PjMzMwEALRPXVLN2REREVFlpaWno2bOn3nImYxIlk8mM3tbf3x8LFy6Es7MzrK2tVa9bWlrC0tKyNqpHRETU4BQVFWncNFdQUIDMzEz4+voafB+TMROjHBFTjpCVl5eXp7GdMZo1a4Zx48ZVv3JERERU4ziB38TI5XIAwI0bN3SW37x5E4D+OWVEREQkLUzGTEzfvn0BAEeOHEFpaalGWV5eHhITE2FjY4Pu3buLUT0iIiKqYUzGTIyHhwd8fX2RlpaGqKgojbKwsDDk5+djzJgxsLW1FamGREREVJNkgiAIYleCNJVfDql9+/ZISkpCfHw8PD098dtvv1VqOSQiIiIyXUzGTNSdO3f0LhTu4OAgdvWIiIiohjAZIyIiIhIR54wRERERiYjJGBEREZGImIwRERERiYjJGBEREZGImIwRERERiYjJGBEREZGImIwRERERiYjJGBEREZGImIwRERERiYjJGBEREZGILMSuANW+hw8f4uDBg3B2doa1tbXqdUtLS1haWopYMyIiovqjqKgIRUVFqn8XFBQgMzMT/v7+aNasmd73MRlrAA4ePIiPPvpI7GoQERE1SEuWLEFgYKDeciZjDYCzszMA4PPPP4eXl5fq9ZoYGZs9ezYWL15crX1Ieb/5+fl48803sWrVKtja2tbYfgHpHIPa3G9tHV8pHYPa2q/Ufrs8tgo8tqZ9bMuPjN24cQOffvop3NzcDL6PyVgDoLw06eXlhT59+tT4/rt06VLj+5TKfnNzc/H06VN4eXnB3t6+xvarJIVjUJv7rc3jK5VjUFv7leJvl8dWgcdWOsdWmTCWnSKkCyfwU7VMmTKF+60lUjsGPLbS229tqY368tgq8NjWHjHrKxMEQRDt0420bNmyKr93xowZNVgTaTpx4gQmTpyI9evX18rIWEOWm5uLbt26ISkpqVb+SmvoeHxrD49t7eGxrT1SO7YXLlxAYGAgtm/fbnDUTRKXKcPCwqr0PplMxmQMUM0L452TNc/KygozZ86ElZWV2FWpl3h8aw+Pbe3hsa09ho6tIAjYtWsXEhMT8corr6B79+4G9xUbG4uDBw/C398fgwYNMrjtmTNnsGPHDvTs2RMjR46ETCbTu21KSgqio6PRoUMHjXnahkhiZCwhIaHK7/Xx8anBmkiTsZk5ERGRFJliIhYUFITk5OT6MzLGhKpmTJ8+HTY2NpgyZQqCg4PFrg4REVG1mWIiVlBQgBEjRuDZs2dGfQdJJGNUM5YvX86RMSIiqjdMMRELCgqCubk5pk6dqroyVRFJJ2PJycnYsWMHrl+/jvz8fERFRQEA0tLScPbsWQwcOBBNmzYVuZZERERU00w5EassySZjP/zwA1auXInS0lIA0DhQpaWleP/99/HZZ58hJCRErCoSERFRLahPiRgg0eeM/f7771i+fDkGDBiAnTt3Ytq0aRrlbdq0wfPPP4/9+/eLVEMiIiKqDfUtEQMkmoxFRkbCw8MDv/zyC5577jmdt7i2a9cON2/erPvKERERSciSJUuwfPly5OXlGdwuLy8Py5cvx5IlS5CVlWVw24KCAqxatQoLFixAenq6wW1LSkqwceNGzJs3DykpKQa3rY+JGCDRy5QpKSkYO3aswWe4tGzZEg8ePKjDWpk+3k1JRETlWVtbIyQkBHZ2dnq3ycvLQ2RkJAoKChASEoLmzZvr3bagoABr165FZmYmgoOD4erqqnfbkpISbNq0CVevXsWECRPQsWNHvdtKKRGLiorCmjVrYGZm3JiXJJMxQRAq/IIPHjyocC2ohoZ3UxIRUXlMxGp+RCw4OBgvvvgifvjhhwpH+wCJXqZs27Ytzpw5o7e8pKQEp06dQocOHeqwVkRERNLDRKzmL02mp6cjKioKjo6OBj9fSZLJ2IgRI3DhwgVEREToLF+5ciVSU1Pxyiuv1HHNiIiI6gcmYmpVScScnZ0xYsQIg3VQkuRlyjfeeAN79uzB/PnzsXPnTtXr8+fPx6lTp3D+/Hl069YNr7/+uoi1JCIikiYmYmpVTcQmT56Mq1evGqyHkiRHxmxsbLB27Vq8+uqruHDhAs6ePQtBELBq1SrV024jIiJgYSHJXJOIiEg0TMTUqpOIVWbeuiQWCjckOzsb586dQ3Z2Nuzt7dG1a1eDP5yGSJmgurm58W5KIqI6ZAodf1ZWFiIjI3nXJOouHtHR0VizZg2ePXuGtLS0ChcKl3wyRhVTJmMV/RiIiKjmMBFTaGiJWNl4GNv/SvIyJRERkSljIqbQkBOxypDEpKo5c+ZU6X0ymQwLFiyo4doQEREZJnbHz0RMzdQTMUAiydjmzZt1vi6TyaDrKqvydSZjREQkBiZiTMQqQxLJ2OHDhzX+XVpainnz5uHUqVMICQmBj48PnJyccP/+fcTHx+N///sfevfujblz54pUYyIiasiYiDERA4DHjx8brKOSJJKx8kEPDw/HqVOnsGPHDo0yuVwOHx8fjB07FoGBgfjzzz/xxhtv1HV1iYiojrDjV2MipmYq8Sj7LFRDJDmBf+PGjRgxYoTeH4S7uztGjBiBDRs21HHNTNv06dMxbNgwREVFiV0VIqJqY8evxkRMzRTiER4ejsWLFyMrK8tgXZUkMTJWXlpaGgICAgxu06RJE6SlpVVp/3v27EFCQgKSk5Nx+fJl5OXlITAwEEuWLDF6H48ePUJMTAwOHjyIK1euICMjA5aWlujUqROCgoIQFBSktdh5Wloa/Pz89O5z5MiR+PHHH6v0nQAuFE5E9Qc7fjUmYmqmEo/Hjx/D1dUVY8aMwf79+w3WGZBoMubo6Ii4uDh8+OGHOssFQUBcXBwcHByqtP/ly5cjOTkZjRs3RqtWrZCXl1fpfezZswf//ve/4eTkhH79+sHFxQUPHjzAH3/8gU8++QSHDh3C8uXLdf5QvLy8dCabhn7cREQNBTt+NSZiaqYYj5s3bxqss5Ikk7ERI0YgIiICM2bMwEcffQR3d3dV2e3bt7Fw4UJcvny5yvPF5s6di1atWqFt27ZISEjA5MmTK72Ptm3b4ueff8aLL76oEeR//etfGDNmDP744w/s3bsXw4cP13qvl5cXQkNDq1R3IqLKYMevJvWOn/GQTjzKk2Qy9v777+PUqVPYs2cPYmJi0LJlS7Ro0QIPHjxARkYGSkpK0LVr1yonNP369at2Hfv376/zdScnJ0yaNAmLFy9GQkKCzmSMiKgusONXq88dP+OhZgrx0EWSyVjjxo2xceNG/Pe//8WmTZtw69Yt3LlzBwDg4eGBoKAgvPXWW7CyshK5prpZWloCgN6FzDMzM7Fu3TpkZ2fDwcEBPXr0wHPPPVftz83Pz0dubq7q31ZWVtV+NgoRSRc7foX63PEzHmp1EY/XX38dgiCo+tr8/HyD9VeSZDIGKBKJd999F++++y6ePHmC3Nxc2Nvbo3HjxmJXzaDi4mJs2bIFAPT+yI4cOYIjR45ovObj44NFixbBxcWlyp89ceJEjX/PnDmTl0OJGjB2/NLu+BkP04tHeHh4lW60k2wyVlbjxo1NPglTWrhwIVJSUuDn56f1Q7OxscF7772HgIAAtGnTBgBw+fJlhIWFIT4+HlOmTMHOnTtha2tbpc9ev349vLy8VP821ZFDovpK6h0NO37Gg/FQ0xWPadOm4c0331Rtk5ycrDUQooukk7H8/HzExMTg4sWLqpGxzp07Y+jQoVVOWGpTREQEwsPDIZfLsWjRIq3yFi1aYNasWRqv9enTB5GRkXjttdeQlJSEjRs3VvnGBFtbW9jb21fpvURUPfWho9GHHb8a46HQUONhbW2t8T5jcxHJJmP79+/HnDlz8PjxY431KWUyGb799lt8//33ePHFF0WsoaaIiAjMmzcP7du3x5o1a9CsWTOj32thYYEJEyYgKSkJJ0+e5KoCRBJTXzoaXdjxqzEeCoyH2tOnTw1+HyVJJmPnzp3De++9h5KSEowePRr9+/eHs7MzMjMzcfz4cezcuRPTp09HdHQ0nn/+ebGri19//RULFixAx44dERUVhRYtWlR6H8oTytjJgET1ETsaNVPoaBgPNcZDgfFQy8vLw++//27wOylJMhlbuXIlZDIZ1q9fj549e2qUBQUFITg4GJMmTcLKlSuxYsUKkWqpsHLlSixatAje3t6IjIys1IhYWUlJSQCgmktG1NCwo1EzlY6G8VBgPBQYDzVlPIqKigx+LyVJrk156tQpDB8+XCsRU+rWrRuGDx+OkydP1npdioqKcO3aNaSmpmqVLVu2DIsWLUKXLl0QFRVVYSKWlJSEwsJCrdcTEhKwatUqAEBgYGDNVJwatDNnzuCrr77Czp07NS7z65KSkoJ58+Zh48aNKCkpMbhteno6FixYgFWrVqGgoMDgtllZWViyZAmWL19e4SoX7GjUTKmjYTwYDyXGQ61sPEaNGmXwuylJcmQsLy8PrVu3NrhN69atq7SMEQDExMRg3759AID79+8DUPwYlMsvOTo64tNPPwUAZGRkYOjQoXB1dUVsbKxqH5s3b8bSpUthbm6O3r17IzIyUutzXF1dERQUpPr3woULcfXqVfj4+KBVq1YAgCtXruDYsWMAgFmzZulNQI0xffp02NjYYMqUKQgODq7yfkjapNywsaNhPADGoyzGQ82U4vHo0SOcPHkS27dvN/j9lCSZjDk7O+P8+fMGt7lw4QKcnZ2rtP/k5GTVs8CUbt26hVu3bgFQJFHKZEwf5SLlJSUliIiI0LmNj4+PRjL26quvIiYmBufOncPhw4dRXFyM5s2bY8SIEZg6dSp69+5dpe+jxIXCCYAkGzZ2NIyHEuOhxniomVo8/vnPf+Kzzz7DhQsXjLqiJclkzM/PD+vXr8evv/6Kt956C2Zm6qutpaWlWLVqFY4ePYpJkyZVaf+hoaFGPwzVzc0N165dq9Y+lCZMmIAJEyZU6j0kvvT0dDZs7GgAMB5KjIca46HGeOgnyWTsvffew759+7Bw4UKsXbsWvXr1gpOTE+7fv4/ExESkpaXByckJ06dPF7uq1ACwYWNHAzAeSoyHGuOhxngYJslkzNnZGdHR0fjss89w9OhR1SVBpYEDB+Kbb76p8mVKoprAhk2NHY0a46HAeKgxHmr1OR6GSDIZAwB3d3dERkbi3r17uHTpkuoJ/N7e3qrJ70RiYcOmxo5GjfFQYDzUGA+1+hyPikg2GVNq1aoVky8jSfVuSlM4kdiwqTEeaoyHAuOhxnioNeR4REVFYc2aNXj27JmBb60m+WSMjCfFuynZsKk15IatLMZDjfFQYzwUGA81MeMRHByM4OBgnDlzRuOpCfpINhl7+vQpoqOjkZycjHv37ul8yq1MJsOaNWtEqB3VBDZsag29YVNiPNQYDzXGQ4HxUDOVeOzevVtveVmSTMauXLmCqVOn4uHDhwafHm4oqGTaTOVEYsOmwHioMR4KjIca46HGeCgo4/Ho0SO925QlyWTs66+/xsOHD/HBBx8gMDAQLVu2NBgYUrhy5UqFlyl5IimwYVNjPNQYDwXGQ43xUGM8FMrGY8SIEdi6davebZUkmYwlJSXh5Zdfxj//+U+xqyIpnTp1MljOE0mBDZsa46HGeCgwHmqMhxrjoVA+HsaOjElyoXBbW1u4uLiIXY16hSeSAhs2NcZDjfFQYDzUGA81xkOhMvEoT5IjY3379sXZs2fFrobk6Hu0BU8kBTZsaoyHGuOhwHioMR5q9SEeJSUliIuLw927d9G6dWv4+vrC3Ny8WvE4cOBApR5tIRMMzYA3UTdu3EBQUBDefvttvPPOO5yoXwHlQqXbt2/XmjNWH04kfdiwqTEeCoyHGuOhxngoNMR4bNmyBaGhoRor+bi5uWHBggXIzs6udjwM9b9lSXJkzNPTExs3bsT48eOxceNGeHl5wd7eXms7mUyGBQsWiFBDaagPJ5I+bNjUGA8FxkON8VBjPBQaYjy2bNmCoKAgracypKenY8qUKQgJCcHixYtr7dJkWZJMxu7evYt3330Xubm5yM3Nxe3bt3Vux2RMv/pwIunDhk2N8VBgPNQYDzXGQ6Gm41H2sl9eXh7S0tLQu3dvk4pHSUkJQkNDdT4eS/nan3/+CQcHB737ralEDJBoMjZv3jxcv34d48ePx9ixY+Hs7AwLC0l+FVGwYVOQSsNWFuOhwHioMR5qjIeCmPHQddmvefPm+OWXX0wqHnFxcRp11Pc5cXFxGDx4sFZZTSZigESTsWPHjsHX1xffffed2FWRHDZsClJp2MpiPBQYDzXGQ43xUBA7EdN12e/hw4cYP348Nm3ahLFjx2q9T4x43L171+B3NbRdZeJRWlpq1OdIMhkDKn5mFmn7+uuv0blzZzg6OrJhk0DDVhbjocB4qDEeaoyHgtiXJg1d9pPJZHj//fcRGBiocczFikfr1q0Nfl992xkbj6ioKKxduxYtW7Y06nMkmYy98MILSElJEbsaKnv27EFCQgKSk5Nx+fJl5OXlITAwEEuWLKn0vu7evYulS5ciNjYW2dnZcHJyQkBAAGbOnImmTZtWq56tWrViwyaRhq0sxkOB8VBjPNQaSjwmTZqEq1evIjY2VuPxC0pix6Oiy36CIOD27dsal/3EjIevry/c3NyQnp6uM4GUyWRwc3ODr6+v6rXKnB+TJk2ClZUVjh8/rnebsiT50NfZs2cjISEBv//+u9hVAQAsX74cUVFRSE5ONjoL1iU1NRWBgYHYtGkTunbtijfeeAPu7u5YvXo1goKCjH6Srz69evWqsYatpKQEUVFR+Oyzz1BYWIgxY8ZIqmFjR8N4KDEeCoyHmqnFo3nz5hgwYAD8/f0xadIk+Pv7o23bttiyZQsA04hHZS/7iR0Pc3NzLFiwQG8iBgBLly5V1auq58fQoUP1bleWJEfGDh06hH79+uGDDz7A+vXr0aVLF52PtgCAGTNm1Hp95s6di1atWqFt27ZISEjA5MmTq7SfL774AllZWfj8888REhKiev3bb7/FqlWrsHjxYsybN6/K9ezRo4fBcmMbti1btmD69Om4d++e6rWIiAiEhYXpnA9gag0bOxrGQ4nxUGA81EwtHs2bN8c777yj8/ELQUFBiI6ORklJiejxyMvLM1iu1Lp1a5OJR3Z2NkJCQrBv3z7cuXNHVebm5oalS5eq+rPqnB+FhYWGDoeKJJOxsLAw1f8/ceIETpw4oXM7mUxWJ8lYv379qr2P1NRUxMXFwd3dXePp+AAQGhqKDRs2YOvWrfjkk0/QuHHjan9eeZVJxPQ9lyUoKEhrgqapNWzsaBgPJcZDgfFQM7V4TJo0CQMGDDA4D2vatGmYOXMmXn/9dVHjkZaWhubNm+Phw4cGL/u1bNnSpOKxePFiODg46HwCP1D98+PChQt6ty9LksnY2rVrxa5CjYuPjwcADBw4EGZmmleP7ezs0LNnT8TFxSEpKQkDBgyo0c+uzKXJ6dOnGz1B05Qatnv37qFDhw5651sovx87GgV2/GqMh0J9i0f5JXDkcjnWrVtnUvG4evVqhfOwsrKy4OnpKXo8evfujV9++QXjx4+HTCbT6CeUMfroo4+wefNmkzw/qvv4isqcH7pIMhnz8fERuwo17vr16wCAtm3b6ixv27Yt4uLicPPmzSonY2fOnNGYd+bk5ISnT59i8+bNaNGiBVq3bo0zZ86oypWXNa9cuYInT55g165dGpcmy1NO0Fy/fj38/f1VP3hvb29cvHhRtd3zzz8PS0tLXLt2DY8fP0Z2djZ27twJKysr/OMf/4CdnR0ePXqEGzduaOy/UaNGcHd3R2RkJK5du4ZRo0YhNTUVqampAAAvLy80atQIqampyMrKQmFhIfbs2YOTJ08iMTERmZmZqn05Ozvjww8/xIsvvghLS0t4e3tj06ZNiIuLw0svvYS8vDycPn0aANChQwfY29sjPT0dGRkZEAQBcXFxSE5OVjVsT58+RXJyskZ9ZTIZunfvjtjYWERHR6Nbt26ws7NT7dfT0xOOjo7IyMhAeno6AODy5cs4fPgwevXqhZEjR6K4uBjnz5/XOtYvvPACrl27hpUrV6Jly5aQy+Wq9Vrd3d3h5OSEhw8f4ubNmwCAzMxM7Nq1C61bt1Y1bMp6lOXt7Y0nT55gyZIlKCkpwahRo1Q3y7Ru3RqtW7dGTk4O/vrrLwBAfn4+du7cidLSUsyZMwfNmzfHuXPnUFxcrLHfjh07wtLSEsuWLUNqaipGjhyJjIwMZGRkoEWLFmjTpg3y8/Nx+fJlAIqGbf/+/bh9+zZCQ0PRsWNHXLp0SWudN7lcjqZNm2LNmjU4cuQI/Pz8IAgCTp8+DQcHB8jlchQWFmr8dXr69GmcPHkSEydOxKBBg5CSkqJ1iaVNmzZo0aIFDhw4oFrlQ3l+2NnZoWPHjigtLUVSUpLqPampqdi3bx8GDBiAoKAgpKamIjs7W2O/Li4uaNWqFS5duoSVK1eiWbNmqvPDxsYG3t7eAICkpCTVLfHK88Pd3R0hISF4+PCh1g1Mzs7OcHNzw71797B06VIUFhaqzo/09HR07doVAHDx4kUUFBQAgOr8kMlkePvtt2FmZqb1m3B0dISnpyeePHmCZcuW4datWwgICFCdH+XbiJKSEpw+fRpHjx5FUVERZs+eDTc3N6392tvbo0OHDigpKUFERAROnjyJ3r17q86P8m2E0uXLl3HmzBn4+fmhf//+Gu0VoGgjvLy8AADbtm1DTEwM2rRpozo/lG3EL7/8gs8//1yjTbC3t0dwcDD+/ve/a7RXAGBpaYnnn38egGKi+tatW2FlZaU6P8q3EUr5+fk4ePAgGjdujAkTJmi0V4C6jQCAs2fPYsuWLXj48KHq/FCeZxW5ffu21jF+4YUXYG5ujpSUFOzevRvJycmq8+P+/ftabYTSpUuXcO3aNfj7+2u0V0re3t6wsbHBjRs3cPz4cRw+fFh1fri4uGDTpk2YMWOGxmU/Z2dnvPXWW8jOzkaHDh3QsWNHrfWlO3bsCDs7O6SlpeHChQvYtWuX6vzIyMjQaiOUcnJycPr0aVhbW8PHx0fr3JDL5XBwcMC9e/fw119/YefOnarz4/Hjx2jevLlWGwFA9dqDBw8wYMAAVXulpGwjHjx4gBs3bmD//v24desW/P39kZeXh9zcXJSWlmr9RvUSqEYdP35ckMvlwqxZsyr1vk8++USQy+XChg0bdJb/5z//EeRyubBixYpK1+n8+fOCXC4XrKysBACq/7p37y58+eWXwi+//KLxuvI/pb59++os1/efl5eX8N133wk//fSTzvLMzExBEARh9OjRWmWLFy8WBEEQoqOjtcpeeOEF4aeffhIWL16s9V0ACBcuXBAEQRDeeuutStXX1dVV2LBhg/DNN98ILVu21Co/ePCgIAiC8PHHH2uVvfXWW4IgCMKFCxe0yqysrITDhw8LX375pdChQwet8ujoaEEQBGHx4sVaZaNHjxYEQRAyMzN11jkxMVH45ptvhK5du2qV/fTTT4IgCEJUVJRWmY+PjyquuvZ74sQJYfHixULv3r21yr744gtBEARh7969WmWenp6q/bZo0UKr/NChQ0J4eLgwYMAArbJ3331XEARBSExM1Cpr3Lixar/e3t5a5du2bRN+//134aWXXtIqCwoKEgRBEG7fvq3zuz579kwQBEHw8/PTKvv111+F06dP6/yN+vn5CYIgCM+ePdO535s3bwqCIAhBQUFaZfPnzxfS0tKE4OBgrTJvb2/Vd7W3t9cqj4uLEwRBEN59912tslmzZgm5ubnCBx98oFXWokUL1X7btWunVb5mzRpBEAThiy++0CqbPHmyUFxcLCxdulTnd62ojXBzcxP+/ve/a70+dOhQQRAEYffu3TrfZ6iNeOutt4TS0lKdbUT37t0FQRCEK1euCObm5lrlFy5cEDZv3qzzMwEIMplM+Oqrr7Red3V1FQRBEB48eCA0bdpUq9xQG9GnTx/hwYMHetsI5W+pTZs2Os85fXWt6L/Hjx8LpaWlQvfu3bXKDLURbm5uwuHDh/W2EVevXhUEQRCGDx+us76CIAi7du3SKmvWrJmwYcMGobi4WGcbcezYMUEQBOHtt9/WKjPURlhbWws//fSTkJubq7ON2L59u97fd0VtxDfffCOkpaXpbSMEQdDZf9rY2AhyuVzw9PQUrKysBLlcLpw/f14wRJILhZuy+Ph4TJ48udKPtvj000+xceNGzJ8/H6+99ppW+aJFi7By5Up8+OGHmDZtWqXqpFyo9Msvv1SNvF27dg1JSUkYMmQIXnrpJa1RHUA9MrZ3717s2LEDxcXF+PXXXyv8vAkTJmDYsGF4/fXXtf6KAdQjY6dOncK6detUf2Ha2trC1dUVLVu21BoZy8/Pxx9//AFHR0eEhITg1q1bWpdLlX/1pqSkYO3atXjw4AGio6Px4MEDvXVt2bIlZs2ahaKiIkyYMAEFBQUoKirS2Eb5V29aWho2bdqk+gvzueeeQ/PmzeHh4aFzZOz06dNIT0+Hv7+/ahSyrLIjY/v371f9henr6wsHBwe0a9cORUVFWiNjqampOH/+PDp16oQXXngB+fn5GuVlR8ZOnDih+gtz+PDhcHR0VD2jr/xfvNnZ2Th58iTs7Ozg5+enNfG07MjYuXPnNP7CbNmyJTp37gwAWiNjhYWFOH36NHJycvDSSy9pXZooOzJ28eJF1V+YAQEB8PT0RLdu3QBAa2RMEARcvXoVV65cQf/+/bUu/5QfGVOOiPXu3Rs9evRAt27dYGZmpnNkLDs7G3FxcWjfvj2ee+45jUth5UfGlCNibdq0wUsvvYQXXngBVlZWuH79utbImEwmwx9//AE7Ozv06tULVlZWqrLyI2MPHz5UjRiPGjUKPXr0gK2tLW7duqX1m27cuDH+/PNP5OTkwMfHR2MJFwsLC42RsdzcXOzZs0c1AtO/f380adIEd+/e1bojrkmTJkhMTMSlS5fQrVs3eHh4aJQr24hly5Zh5syZKE953BYuXIgXX3xR9bq9vT3u3r2L/fv3w93dXevmovIjY8oRYy8vL7z++uto1aqV3tFzc3NzREdHw8LCQuv31rFjR3h5eem99CeTyeDi4oKtW7dqvM/S0hIuLi6IjIzEgwcPMGLECNja2qrKy4+MKUeMCwsLMXXqVHTr1k3v6Lm3tzfWrl2LCxcuYOjQoXB2dlaVt2nTBt27dzf4+AVXV1ds2bJF67zq2rUr9u7di5iYGPTt2xfPPfecqkzX6Lny/PD19cWUKVNUr5Xn7e2N5ORkREZGom3btvD19VXFWdfoufL8kMvlmDVrFszNzfWOnj9+/Bg//fQTrKysMHz4cNX5oWv0XDlibG1tjblz58LOzk7v6LmFhQWWLVuG+/fvY9SoUarzQ9fouXLE+OHDh/joo4/g7u6ud/Tc0dERq1atwpkzZxAQEAAPDw8UFhbCysoKHTp0QGlpKXbs2IEvv/yyfi4UXh8p7wbNzc3VWa78Iei7a9QY3bt3R5cuXXDmzBmkpqZiyJAhqjkX+u60TElJwalTp+Dn54cxY8Zgz549BhuGJk2aICAgQHUpTN9+s7KyEBsbi3bt2um8xu/o6AhHR0fVd4+MjFQlYs2bN9c776KgoABHjhxBo0aNMHjwYKxYscLgMcnIyEBKSgrmzJlT4ZyLpKQkPH78GNOmTdOac9GoUSON7xobG6tKxCqac3Hnzh1cvXoVo0ePxsiRI1FaWoq4uDicOHFCa35bSkoKLl68iE6dOlU45+Lp06dISkpC9+7ddc65KFvfrKwsHDp0CHZ2dhXOuTAzM8PZs2fh7Oyscw6MsuMH1HMucnJyKpxzYW1tjevXr6O4uBjvv/++VjyUiQoA1RyYK1euVDgHxsrKCnl5eUhPT8fkyZO14lH+c86cOYO4uLgK5ySZmZnBzs4OFy9ehJ+fn1Y85HK5xvaVmQPj7u6OAwcOwNPTE+3bt8ft27dRXFwMX19ftGnTBm3atFFtW3YOzD/+8Q+Dc5Lat2+PtWvXolGjRvj444814qHsSJXKzoGZPHmy3vOjpKQECxcu1Fkm/P+5pD/++KOqIwbUc5Jeeuklg+dHu3btcObMGY3zQxmPsm2EUkVz9g4dOlThHKz09HQ8efJEYw5R2TlJn376qd7zw9XVFU2bNkVkZKTW+VG+jQA05yTNnj1b5/kRFhaGoKAgvfOwwsLC0Lt3b63voZwj9sYbb+g9P5o1a4ZmzZqp2qvy54eu9ls5R6xs/1FekyZN0KNHD1V7Vf78KNtGKCnPjw4dOug9P2xtbdGjRw9Ve1W+/yjbRigpzw9l0qbr/LCyskKPHj1U8Sh/fuj67SvPj4yMDJ3tlVJF8/OUJPmcsfpI2XCX/0tPSfnXi745ZcaqzuRXKysr1Z2s5d+nbCgmT56M4OBgk5j8Wv4vL306d+4s+uRXZTy2bt2Ktm3b6nyeECeHK9RlPMScrJ+cnIzvv/8eI0aM0PlsKcA04hEbG2v0wz6V24sVj6osgSP2+TF27FhER0drJZ5ubm46lxdqKOeHlNorY3BkzET07dsXAHDkyBGUlpZq3FGZl5eHxMRE2NjYGJ1l63LlyhVcuHChWifS2LFjsWnTJq2FYJs0aYLJkydjyZIlJnMiGbvchaHnr9V1ImbosSGvvfYaXn31VZNr2Mrflebr64vi4mKTTMR01VV5LE2po0lOTkZ4eLjBR8gMHTrUJDqa3bt36y0v6+7du6J3/JVdAsdUOn7lUkOenp6wsLDQe0c4EzE1U0nEjhw5ore8LCZjdayoqAi3bt2ChYWFxvwLDw8P+Pr6Ii4uDlFRURoPfQ0LC0N+fj4mTpyoMU+hsg4fPoyhQ4dW+0QaO3YsAgMDERcXh4sXL+Ls2bPo06ePyYyIKU+kqix3UVZdNmylpaUG13UDgH379iEyMtKkGrYtW7ZoJeaurq4IDAxUPTPPVBIxXXV1c3NDWFgYPD09TaajsbS0xJ49eww+QmbmzJmYM2cOioqKRB+hvH//vt5tysrMzERKSoqoHb/y7tuyd2iWVbZNMLWOX+zniJnK+WEq8TD2/NA1H1sXySRjMTExGDRoEGxsbMSuipaYmBjs27cPAFQN05kzZ/Dhhx8CUMxt+PTTTwEo5igNHToUrq6uiI2N1djPV199hfHjx+Prr7/GsWPH0L59eyQlJSE+Ph6enp6YPXt2teqZlZWFZcuW4dGjR1oPllUy9kQyNzdHhw4dEB8fj759+5rkiWRubl7hfIuyy12UVdcNW0XrugGKY3js2DGdz8MBxEnE9I3krVixAv/3f/9nUomYoVHH8ePHIzg42CQ6GrlcrnrUiS7KeU3Jycn45ptvRL9U/N5772H//v0G/+hRThavaI4YULsd/7p16zB58mSsXLlS9T3K1hNQtAnZ2dmS7PiZiJlOPH744Qfk5OTg9u3bercrSzJzxt5991307t0b7777LrZt24acnByxq6SSnJyMLVu2YMuWLap5Ebdu3VK9tnfvXqP24+HhgW3btmHcuHE4e/YswsPDcevWLYSEhGDTpk1acwYq6+OPP8Yff/xR7UQMkM6JpLysWr5M33wLQJyGrSpzWcoS49KkvpE8QNGxffPNNygpKdFZXteXJg2NOgqCgAMHDuDll182iY6m/B2Y+nTr1s0kOv5evXpVOJd08ODBoidiyngsWbLEYJvg5+cnuY6fiZiCKcUjNzcXgYGB+Oabb/RuW5ZkRsZ+/PFHxMTE4NChQ4iJiYGlpSX69OmDYcOGYciQIRq3A9e10NBQhIaGGrWtm5sbrl27prfcxcVF751J1dVQT6TAwEAUFBTgzz//ROfOndGjRw+d8y0A8Rq2ys5lKUuMeFQ0kld20nb5kby67miMGXV88OABjhw5onfUsS7PD2N/C4aOW113/Prmkjo5OWHw4MGYPn26SXX8ZadalJ0/yBExNSZiCtWNR71bDmnEiBEYMWIEioqKcPToUcTExODAgQM4evQovvzyS3Tt2hXDhg1DQEBAte84bGgawol07do1ox5fIVbDVtX5bWLFo6ojeWJ0NNUddazr86O6cx3F6vjLJziZmZkmcWlSXzzMzc31Pr5C7PaKiVj9j0d5krlMqWRpaYnBgwdj/vz5OH78ODZs2ICQkBBkZWXh+++/R0BAAIYPH46wsDBcunRJ7OqaPJ5ICmI3bMr5bbrom98mZjyqMpInVjyqM+ooxvlR9reg67IfoH+uo9jnhzLBcXV1RXZ2tskmYuWxvVJjPBTqMhEDJJiMlSWTydCrVy/MnTsXBw8exO+//47p06dDJpNh2bJlCAwMhJ+fH+bPny92VU0STyQFU2nYunTpgtdeew3NmjXTeF3X/Dax4+Hr62vw+MtkMri7u6tGb8SMh3KkSd+xL19XJTHPD+VlPxcXF43XDc11rO/nB9srBcZDTYrx0EcylymN4eXlBS8vL7z//vtITU3FH3/8gZiYGKxevVp1NyMp8ERSMLWG7dVXX0VkZCSOHTum81lYgGnEo7i4GIGBgVixYkWFd6qKHY+yd9WWp2+kyRTOj6FDh2LOnDlITk5Gt27d0LFjR71zHRvK+cH2ivFQkmI8DGkQa1MqV6hvqJRrU7q5ucHGxgZjx47F/fv3eSKxYVOpajyaN2+Or7/+WmPStru7O5YuXYqxY8eaVDwWLFiA/fv3IysrS2ddlaQcD54fjIcS46EgVjyioqKwZs0aPHv2DGlpaRWuTdkgkrGGTpmMbd++HVZWVjyRwIatrOrGQ99T7U0xHi+//DKOHDmid9SxPsRDH1OMR0M4P/RhPNTqczzK9r9Mxho4Y38MpsYUTiSADZsS46HGeKgxHgqMhxrjofa///0PX331VYX9r6Qn8FP9ZSonEhs2BcZDjfFQYzwUGA81xkMtNjYWp06dMriNEpMxMkmmciKxYTOtho3xYDzKYjzUGA8FU4tHr169DG6nVK/upqT6w1ROJDZsptWwMR6MhxLjocZ4KJhiPMo/qkgfJmMNyPTp02FjY4MpU6boXZ/SVJjKicSGzbQaNsaD8QAYj7IYDwVTi4ejoyO+/fZbPHv2zOD2SpzA3wBIdQK/VOzcuZMNGzsaAIxHWYyHAuOh1hDjYWz/K+mRsYyMDBw/fhwZGRkoLCzUuc2MGTPquFbU0LBhY0cDMB5lMR4KjIca42GYZJOxxYsX47///S+Ki4tVrwmCoPqRKf8/kzGqbWzY2NEwHmqMhwLjocZ4VEySlym3bt2KDz/8ED4+Ppg6dSqmT5+OcePGYeDAgUhISMBvv/2G4cOHY+LEifDx8RG7uqLjZUoyhhQbNnY0CoyHGuOhxngoiBmPen2Zcv369WjZsiVWr14NS0tLAIoFdEePHo3Ro0dj6NCh+Pvf/47Ro0eLXFMiaZBKw1YWOxoFxkON8VBjPBRMJR4VkeRzxq5cuYLBgwerEjFAccCVBg0aBF9fX/z6669iVI9IUqTYsLGjUWA81BgPNcZDwVTiYQxJjowVFxfD0dFR9W8bGxvk5uZqbNOxY0esW7euyp9x9+5dLF26FLGxscjOzoaTkxMCAgIwc+ZMNG3atML3b9q0CXPmzDG4jZmZGa5evar6d1paGvz8/PRuP3LkSPz444/Gf4lypPRoC6o71tbWePPNN43a1tzcHK+99ppR28pkMowaNQqjRo0yavtBgwYZ1aixo1EwlY6G8VBgPNQYD/VC4ba2tgb3pSTJZMzZ2Rn3799X/dvFxQWXL1/W2CYjIwMWFlX7eqmpqRg/fjyysrIwZMgQtGvXDmfPnsXq1asRGxuL6OhojWRQF29vb8ycOVNn2cmTJ3H8+HG9iZeXlxcCAgK0Xjf0YzLG8uXLOWeMJI0djYLYHY0S46HAeKgxHgrBwcHo0qULIiIicO7cOYP7BCSajHl7e+PKlSuqf/fr1w8bNmzA1q1bMWzYMMTHx2Pv3r3o2bNnlfb/xRdfICsrC59//jlCQkJUr3/77bdYtWoVFi9ejHnz5lVYR29vb51lQUFBAIDXX39dZ7mXlxdCQ0OrVHei+qx79+4VNpZKHTt2xGeffWbUtq6urvj444+N2rZ58+b44IMPKtyuPnc0ADt+JcZDjfFQU8bDy8sLu3btMrgtINE5Y/7+/rh69Spu374NAHjnnXdgb2+Pjz76CC+88ALeeecdCIJgVINZXmpqKuLi4uDu7q51KS80NBS2trbYunUrnjx5UqW6X7lyBWfOnEGrVq3g7+9fpX0QkWlrKB0NO37GQ4nxUCsbj4EDBxrcVkmSI2NBQUGq0SVAcZly69atCA8PR2pqKtzc3DBlyhR06tSp0vuOj48HAAwcOBBmZpq5qp2dHXr27Im4uDgkJSVhwIABld7/+vXrAQDjx4/XexJkZmZi3bp1yM7OhoODA3r06IHnnnuu0p9FRHWvIXU07PgZD4DxKKt8PC5evGhweyVJJmO6uLu748svv6z2fq5fvw4AaNu2rc7ytm3bIi4uDjdv3qx0Mvbs2TNs374dZmZmmDBhgt7tjhw5giNHjmi85uPjg0WLFsHFxaVSn1lWfn6+xo0OVlZWBk8wIqo8Ozs7TJ8+3ahtTeHmCXb8CvWh42c8TCMeXbt2xaBBg5CXl4f8/HyD71GSZDK2bNky+Pj4oE+fPnq3OXnyJOLj4yv9BH5lsmJvb6+zXPlDy8nJqdR+AWDXrl3IycmBv7+/zqTKxsYG7733HgICAtCmTRsAwOXLlxEWFob4+HhMmTIFO3fuNPrujPImTpyo8e+ZM2dybhpRA8aOX0HKHT/jYVrxsLKywr/+9S+D2+oiyTljYWFhSEhIMLjNiRMnqvUYiIoY+uHrs2HDBgDaSZFSixYtMGvWLHTp0gVNmjRBkyZN0KdPH0RGRqJbt25ITU3Fxo0bq1zn9evXIykpSfXftGnTqrwvIpI+dvzS7vgZD9OLx6xZszT6WeXUpIpIMhkzRklJidacL2MoR8TKP7dMKS8vT2M7Y129ehWnT59Gq1atMHjw4Eq918LCQnVZ8+TJk5V6b1m2trawt7dX/cdLlEQNGzt+aXf8jIfpxcPGxkajnzX2Sla9TcYuXrxY4bPAdJHL5QCAGzdu6Cy/efMmAP1zyvRRZscTJkwweELoo/wBG3v9mYioIuz4pd3xMx7SiUdFJDNnbPLkyRr/3rx5s+rOx7JKS0tx9+5dpKenV2ltyr59+wJQTKIvLS3VGF3Ly8tDYmIibGxsjH7WEaD4kW3btg1mZmYYP358pesEAElJSQCgmktGRFTbTOm5bnl5eez4mYhJMh7GkEwyVnaOmEwmQ1paGtLS0rS2MzMzg4ODA0aOHIm5c+dW+nM8PDzg6+uLuLg4REVFaTz0NSwsDPn5+Zg4caJq6LGoqAi3bt2ChYUFPDw8dO5z9+7dePz4MV588UWDd0MmJSXB29sbVlZWGq8nJCRg1apVAIDAwMBKfyciIqljx89ETIrxuHXrlsF9KUkmGfvrr79U/799+/YIDQ2t9J2Sxvrqq68wfvx4fP311zh27Bjat2+PpKQkxMfHw9PTE7Nnz1Ztm5GRgaFDh8LV1RWxsbE696ecuK/viftKCxcuxNWrV+Hj44NWrVoBUDwk9tixYwCAWbNmVXlVAYBrUxJR/cOOX42JmIIpxCMqKgq7du1CixYtDO5PSSYIgmDUliZk8+bN6Ny5c60+CPXOnTt6Fwp3cHBQbadc3FtfMvbXX39h2LBhaNWqFWJjYw2eHNHR0YiJiUFKSgoePXqE4uJiNG/eHN27d8fUqVPRu3fvKn2XCxcuIDAwENu3b+falEREImIiplCfEzFAHQ9bW1ssX768wv5XkskYVQ6TMSIi8TERU2goiViHDh3g5eWFMWPGVNj/SuYypT53795FRkYGCgsLdZYbejAsERFRXWAiptCQErGgoCAkJycb3LeSZJOxw4cPY/78+arli/S5evVqHdWIiIhIGxMxhYaWiFXmMVaSfM7Y6dOn8Y9//AOPHz/GlClTIAgCevfujddeew3t2rWDIAh48cUXa22CPxERkTFMoeNnIqZmCvHQRZIjY7/88gusrKywZcsWuLi4ICoqCv369cOMGTMgCALCwsIQHh6ucdcjERFRXTKFjp+JmJopxEMfSU7g7927NwYOHIgffvgBgOJRFzNmzNBY9PrVV1+Fq6srli9fLlY1TYZyAr+bmxsfbUFERFqYiKnVRCIWFRWFNWvW4NmzZ0hLS6ufE/jz8vI0Amppaam1TFDPnj2xY8eOuq6aSVu+fDnvpiQiIg1MxNRqakQsODgYwcHBqsGQikhyzlizZs3w+PFj1b+bN2+u9ZTb4uJiFBQU1HXViIiIJIWJmEJdX5osS5LJmKenp0by1b17dxw9elS1uHdmZib27t1b6cW8iYiIGhomYrWXiGVmZhr8XCVJJmODBg3CiRMnkJ2dDQAICQnBs2fPMHr0aLz66qsYOnQoHj58iL/97W+i1pOIiMjUMRGrvZsndu/ebfCzlSSZjE2cOBHr16+HhYViyluvXr2wbNkyuLm5ISUlBc7Ozvj6668xduxYkWtKRERk2piI1d5drI6OjgY/X0mSd1NS5fBuSiIiqiwmYmqVTcTCw8Px+PFjnD59Grdu3eLalMS1KYmIqP4zlUSs7HPdrl69alT/K8nLlERERERKppiIGXrAbnmSeM7Y4MGDq/Q+mUyGgwcP1mxliIiIyGRIPREDJJKMlZaWah2woqIi1S2jFhYWcHBwQHZ2NoqLiwEAzs7OsLS0rPO6EhERUd2oD4kYIJFkLDY2VuPfubm5mDp1KlxcXPDhhx+id+/eMDMzQ2lpKU6cOIFFixahtLQU//vf/0SqMREREdWm+pKIARKdM7Z48WLk5ORg3bp18PHxgZmZ4muYmZmhb9++WLt2LbKzs7F48WKRa0pEREQ1rT4lYoBERsbK27dvH0aNGgUrKyud5dbW1hgyZAh27dqFL774os7qdffuXSxduhSxsbHIzs6Gk5MTAgICMHPmTDRt2tSofQwaNAjp6ek6y1q0aIGEhIQq12/69Ol8tAUREUmaFBKxsguFG0OSydijR49Uc8P0KS4uxqNHj+qoRkBqairGjx+PrKwsDBkyBO3atcPZs2exevVqxMbGIjo62uiHv9nb2+ONN97Qet3W1rZKdSsqKgIALF26tMJntFDlFBQU4Oeff8a0adOq9VcR6cbjW3t4bGsPj23tKSgowMGDB+Hr62uyiRigXij86NGjmDp1asVfTJCgYcOGCf379xdycnJ0lmdnZwv9+vUThg0bVmd1CgkJEeRyubB69WqN1+fNmyfI5XJh7ty5Ru3H19dX8PX1rdG6JSQkCHK5XEhISKjR/ZIg5OTkCHK5XO9vkaqHx7f28NjWHh7b2iO1Y3v+/HlBLpcL58+fN7idJOeMTZo0CRkZGRgzZgy2bNmCtLQ0PHv2DGlpadi8eTPGjh2L+/fvY8qUKXVSn9TUVMTFxcHd3V3r8l9oaChsbW2xdetWPHnypE7qU5eioqK431oitWPAYyu9/daW2qgvj60Cj23tEbO+kkzGpk6diqlTp+LmzZuYM2cO/P398fzzz8Pf3x8ff/wxUlNTERwcXGfJWHx8PABg4MCBqpsJlOzs7NCzZ088e/YMSUlJRu2vsLAQ27Ztw4oVKxAREYHjx4+jpKSkpqtdI9asWcP91hKpHQMeW+ntt7bURn15bBV4bGuPmPWV5JwxAPj8888xatQo/Pbbb7h06RJyc3Nhb2+Pzp07Y9y4cejZs2ed1eX69esAgLZt2+osb9u2LeLi4nDz5k0MGDCgwv3dv38fs2fP1njN3d0d33//PXx8fCpdv4KCAgBAcnKyxuuWlpY18iy2CxcuVHsfUt1vfn4+GjVqhOTk5CrP6TNECsegNvdbm8dXKsegtvYrxd8uj60Cj63pHtuioiLVPG0AuHHjBgB1P6wP16asAZ9++ik2btyI+fPn47XXXtMqX7RoEVauXIl//etf+Oc//2lwXz/++CN69eqFjh07onHjxrh16xaioqKwYcMGWFtbY9OmTfDy8qpU/TZv3oyPPvqoUu8hIiKimrFkyRIEBgbqLZfsyJgUGbqTQ2nmzJka/+7UqRPmzZsHW1tbhIeHIywsDD///HOlPtff3x8LFy6Es7Ozxl0fNTUyRkRERNojYwUFBcjMzISvr6/B9zEZqwH29vYAFCsD6JKXl6exXVVMmjQJ4eHhOHnyZKXf26xZM4wbN67Kn01ERES1R5IT+E2NXC4HoL42XN7NmzcB6J9TZozmzZsDUFwvJyIiovqDyVgN6Nu3LwDgyJEjKC0t1SjLy8tDYmIibGxsqvXA1bNnzwIA2rRpU/WKEhERkclhMlYDPDw84Ovri7S0NK3nlISFhSE/Px9jxoxR3flRVFSEa9euITU1VWPblJQUZGdna+3/zp07+PLLLwHA4ARAIiIikh7eTVlDyi+H1L59eyQlJSE+Ph6enp747bffVMshpaWlwc/PD66uroiNjVXtQzk5v2/fvnB3d0fjxo1x+/ZtHDhwAAUFBRg8eDBWrlypd01OIiIikh5O4K8hHh4e2LZtm2qh8MOHD8PJyQkhISGYOXMmHBwcKtxH3759cf36dVy6dAlnzpzB06dP0aRJE/Tq1QuvvvoqxowZY9QdmURERCQdHBkjIiIiEhHnjBERERGJiMkYERERkYiYjBERERGJiMkYERERkYh4N2U9dvfuXdXdndnZ2XByckJAQABmzpyJpk2bil09SXr06BFiYmJw8OBBXLlyBRkZGbC0tESnTp0QFBSEoKAgmJnxb5yatHXrVvzrX/8CAMyfPx+vvfaayDWSvpMnTyIiIgKnT5/G48eP0bRpU3Tq1Al/+9vf4O/vL3b1JOvPP/9EZGQkrl+/jkePHsHZ2RldunTBm2++iR49eohdPZO3Z88eJCQkIDk5GZcvX0ZeXh4CAwOxZMkSve9JTEzE8uXLkZSUhIKCAnh4eGD8+PGYOnUqzM3N67D21cNkrJ4q/9yzdu3a4ezZs1i9ejViY2MRHR2teu4ZGW/Pnj3497//DScnJ/Tr1w8uLi548OAB/vjjD3zyySc4dOgQli9fzkeQ1JA7d+7gq6++QuPGjfHkyROxq1Mv/PTTT/jhhx/QrFkz+Pv7w9nZGQ8fPsSlS5eQkJDAZKyK5s+fj/DwcDg6OiIgIACOjo5ITU3Fn3/+ib1792LhwoUYO3as2NU0acuXL0dycjIaN26MVq1aqdZ11mffvn2YPn06rK2tMXLkSDRt2hQHDhzAvHnzkJiYiJ9++qmOal4DBKqXQkJCBLlcLqxevVrj9Xnz5glyuVyYO3euSDWTtqNHjwoxMTFCcXGxxuuZmZnCgAEDBLlcLuzevVuk2tUvpaWlwpQpU4TBgwcL8+fPF+RyubBhwwaxqyVpO3fuFORyuRAcHCzk5uZqlRcWFopQK+nLzMwU2rdvL/Tp00e4f/++RtmxY8cEuVwuDBo0SKTaScexY8eE69evC6WlpcLx48cFuVwuzJo1S+e2OTk5Qq9evYTnnntOOHv2rOr1Z8+eCePGjRPkcrmwY8eOuqp6tfF6Sj2UmpqKuLg4uLu7Izg4WKMsNDQUtra22Lp1K0caqqB///4ICAjQGv52cnLCpEmTAAAJCQliVK3eWb16NY4fP47vv/9etZQYVV1paSkWLlwIGxsb/PDDD7Czs9PaxtLSUoSaSV96ejpKS0vRrVs3tGjRQqOsX79+sLOzw6NHj0SqnXT069cPnp6eRl1Z2LNnDx4+fIhRo0aha9euqtetra3xwQcfAADWrl1ba3WtaUzG6qH4+HgAwMCBA7XmL9nZ2aFnz5549uwZkpKSRKhd/aXsyCwsePW/uv766y/85z//wd/+9jf06dNH7OrUC6dPn0ZaWhr8/f3RtGlTHDx4EL/88otq7hhVXdu2bWFlZYWkpCQ8ePBAo+z48ePIy8vDgAEDRKpd/aTs5wYNGqRV1qdPHzRq1AhnzpxBQUFBXVetSthr1EPXr18HoGggdGnbti3i4uJw8+ZNNhA1pLi4GFu2bAGgu3Eg4xUXF2P27NlwcXFRTdyn6jt37hwAoEWLFggMDMTly5c1yvv06YOffvoJzZs3F6N6kubg4ICPP/4Y8+bNw8svv4yAgAA0a9YMqamp2L9/P3x9ffHNN9+IXc16xVA/Z2FhATc3N1y9ehW3b99G+/bt67h2lcdkrB7Kzc0FANjb2+ssV16eyMnJqbM61XcLFy5ESkoK/Pz8mIxV07Jly3Dp0iVs3LgRNjY2Ylen3sjKygIArFu3Du7u7lizZg26du2K9PR0zJ8/H3FxcZgxYwbWrVsnck2lKSQkBK6urvjoo48QHR2tet3DwwNjx47VunxJ1VNRP6d8XSr9HC9TNmC8469mREREIDw8HHK5HIsWLRK7OpJ29uxZrFy5Em+99RYfBVDDSkpKAACCIGDFihXo168fGjdujI4dO+Lnn39Gq1atkJCQwEuWVbRy5Ur885//xLhx43Dw4EFcuHAB27dvR5s2bTBr1iwsWLBA7Co2KML/X3ZbKv0ck7F6SPkXgfIvh/KUtwvr+4uCjBcREYF58+ahffv2WLduHZo1ayZ2lSRLeXnS09MTs2bNErs69Y7y2YLu7u7o1KmTRpmNjY1qRPfs2bN1XjepO3bsGBYtWoQhQ4Zg7ty5aNOmDRo1aoQuXbpg5cqVaNWqFcLDw5Gamip2VeuN+tbPMRmrh+RyOQDgxo0bOstv3rwJQP+cMjLOr7/+innz5qFjx45Yu3YtnJycxK6SpOXn5+PGjRv466+/4O3tjXbt2qn++/HHHwEAn376Kdq1a8f5N1WgbBeaNGmis1z5ulQmPJuSQ4cOAQD69u2rVdaoUSN07doVpaWluHTpUh3XrP4y1M8VFxcjLS0NFhYWcHd3r+uqVQnnjNVDygbhyJEjKC0t1bijMi8vD4mJibCxsUH37t3FqqLkrVy5EosWLYK3tzciIyM5IlYDrKysMGHCBJ1lFy9exMWLF9GrVy/I5XL+dqugd+/esLCwQGpqKgoLC2FlZaVRnpKSAgBwdXUVo3qSVlhYCAB4+PChznLl6+WPOVVdv379sH37dsTGxuKVV17RKDtx4gSePn2KPn36wNraWqQaVg5HxuohDw8P+Pr6Ii0tDVFRURplYWFhyM/Px5gxY/jspipatmwZFi1ahC5duiAqKoqJWA2xsbHBd999p/O/l156CQAwduxYfPfddxg1apTItZWeZs2aYeTIkcjJycHKlSs1yo4cOYK4uDjY29vDz89PpBpKV+/evQEAGzZswL179zTKDh06hMTERFhbW3MeZA16+eWX0axZM+zatUt1pzCgGNlVLp+kfPajFMgE5Sw3qlfKL4fUvn17JCUlIT4+Hp6envjtt9+4HFIVbN68GR999BHMzc0xdepUnfMRXF1dERQUJELt6q+wsDD8+OOPXJuymh48eIAJEyYgNTUVffr0wfPPP487d+4gJiYGMpkMP/zwA0aMGCF2NSWntLQUf/vb33D06FHY2dkhICAATk5OuHbtGg4cOABBEPDZZ5/hjTfeELuqJi0mJgb79u0DANy/fx9xcXFo06YNevXqBQBwdHTEp59+qrH9e++9B2tra4waNQpNmzbF/v37cf36dQwfPhzLli2TzAR+JmP12J07d/QuFO7g4CB29SRJmRQY4uPjw8cD1DAmYzUnOzsby5cvR0xMDDIyMtC4cWP06tUL06ZN4+XfaigqKsKaNWuwc+dO/PXXX3j69CmaNm2KF154ASEhIfD19RW7iiavovbV1dUVsbGxGq+dOnUKK1asUD3gVblQeEhIiKQWCmcyRkRERCQizhkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSKiOpKWloZ27drhww8/NGr7TZs2oV27dti0aVMt14yIxMRkjIiIiEhEFmJXgIiIdBs2bBi6d+8OZ2dnsatCRLWIyRgRkYmyt7eHvb292NUgolrGy5RERCK4du0a3nnnHfTo0QNdunTBhAkTEBcXp7GNvjljgwYNwqBBg/D06VN89913GDhwILy8vODv74+ff/4ZgiDU5VchompiMkZEVMfS0tIQFBSE7OxsTJw4EcOHD8eFCxfw5ptvYufOnUbto7i4GCEhIfjjjz/g5+eHCRMmoKCgAP/5z38QFhZWy9+AiGoSL1MSEdWxEydO4O9//zs++eQT1WvBwcEYP348/v3vf8PPz6/Cy5MZGRl47rnn8L///Q82NjYAgBkzZmDIkCGIiIjA9OnTYWlpWavfg4hqBkfGiIjqmL29PWbMmKHxWteuXfHKK68gJycHMTExRu3niy++UCViANCiRQsMGTIEeXl5uH79eo3WmYhqD5MxIqI61rlzZ9jZ2Wm97uPjAwC4dOlShfto0qQJPDw8tF5v3bo1ACAnJ6eatSSiusJkjIiojrVo0ULn605OTgCA3NzcCveh7zKmhYVi9klJSUkVa0dEdY3JGBFRHXvw4IHO1+/fvw9Af6JFRPUTkzEiojp28eJF5OXlab2ekJAAAPD29q7rKhGRiJiMERHVsdzcXCxbtkzjtXPnzmHHjh2wt7fH0KFDRaoZEYmBj7YgIqpjffr0QXR0NM6ePYuePXsiMzMTu3btQmlpKebNm8fLlEQNDEfGiIjqmJubGzZt2oSmTZti3bp12L17Nzp37ozw8HCMGjVK7OoRUR2TCVw3g4iIiEg0HBkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIRMRkjIiIiEhGTMSIiIiIR/T+DnS+i8cOeZgAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 600x600 with 2 Axes>"
       ]
@@ -1077,7 +1036,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 600x600 with 2 Axes>"
       ]
@@ -1101,7 +1060,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmMAAAJjCAYAAABAyBZ9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADIwElEQVR4nOzdeVzNaf/48VeLUlqISCKKGdkJLcRYso8lZYkY281MFDNjzJjBbYYZ2z23mIaZsU7J2EKWkK1yq9DIbpixljCTpUihzu8Pv3O+jnPKKaXk/Xw8PHSuz3Vdn+vzaTnvc13X57r0FAqFAiGEEEIIUSL0S7oBQgghhBBvMwnGhBBCCCFKkARjQgghhBAlSIIxIYQQQogSJMGYEEIIIUQJkmBMCCGEEKIESTAmhBBCCFGCDEu6AaL43blzh9jYWOzs7DA2Ni7p5gghhBBvhezsbJKTk/Hw8MDKyirPfBKMvQUOHDjAZ599VtLNEEIIId5K33//PX369MnzuARjb4GqVasC8O2339KwYcMirdvf35/g4OAirfNNqjczM5PBgwezdu1aTE1Ni6xeeHPuQXHWW1z39026B8VV75v2syv39hm5t2/Wvf3rr7/4+OOPsbOzyzefBGNvAeXQZJ06dWjUqFGR1l2+fPkir/NNqjcjIwMAJycnzM3Ni6xeeHPuQXHWW1z39026B8VV75v2syv39hm5t2/WvVV62RQhmcAvXsnQoUOl3mLypt0DubdvXr3FpTjaK/f2Gbm3xack26snG4WXfUeOHFF167Zu3bqkm1OmZGRk0KxZM5KSkor8U5qQ+1uc5N4WH7m3xedNu7enT5+mT58+bN26Nd9eN+kZewuUK1dO7X9RdIyMjAgICMDIyKikm1Imyf0tPnJvi4/c2+JTVu+t9Iy9BXSNzIUQQghRdKRnTAghhBDiDSDBmBBCCCFECZJgTAghhBCiBEkwJoQQQghRgmTR17eIv78/5cuXZ+jQofj5+ZV0c4QQQogyKSQkhNDQULKysnTKL8HYWyQ4OFiephRCCCGKmZ+fH35+fqqnKV9GhimFEEIIIUqQBGNCCCGEECVIgjEhhBBCiBJUKueMRUZGkpCQwLlz5zh//jwPHjygT58+fP/99xp5J0+eTHh4eL71ubm5ERoaqnq9ceNGpkyZkmf+b775Bl9fX430rKwsli5dyvbt20lJScHMzAxXV1cCAwOpW7eu1rpSU1NZuHAhMTEx3Lt3D2trazw9PQkICMDS0lJrmcTERIKDg0lKSiI7Oxt7e3t8fHwYNmwYBgYG+V6rEEIIId4spTIYCw4O5ty5c1SoUAEbGxsePHiQZ15PT0/s7Oy0HtuyZQvXrl2jffv2Wo937tyZBg0aaKRrm+SenZ3NsGHDSExMpHHjxnzwwQekpqYSGRnJgQMHCA0NpVmzZmplrl69io+PD2lpaXTu3BlHR0dOnDjBqlWriImJYf369VSqVEmtTFRUFP7+/hgbG9OzZ08sLS3Zv38/s2bNIjExkR9++CHPeyGEEEKIN5CiFDp8+LDi0qVLitzcXEVcXJzCwcFBMWnSpALVcf/+fUWDBg0U9evXV6Slpakd27Bhg8LBwUGxYcMGnev78ccfFQ4ODgp/f39FTk6OKn3Pnj0KBwcHRdeuXdXSFQqFYvjw4QoHBwfFqlWr1NJnzZqlcHBwUHz55Zdq6enp6YqWLVsq6tevrzhx4oQqPSsrS9G/f3+Fg4ODIiIiQuc2K506dUrh4OCgOHXqVIHLCiGEEKJwdH3/LZU9Y25ubq9cx+bNm8nKyqJXr15YWVm9Ul0KhYKwsDAApkyZgr7+/0218/T0pFWrVhw9epT4+Hjc3d2BZ71isbGx1KxZU2NNr8DAQH777Tc2b97MF198QYUKFYBnw7N37tzBy8uLJk2aqPIbGxvz8ccf4+fnx5o1a3j//fdf6XpKgnJoeO7cuXh7exe6nuTkZNq3b4+Xlxfz588vwhaKt839lE4l3YR8WdbYV9JNKLLfWyFE/srsBP5169YBMGjQoDzznDt3jpUrV7J06VI2b95Mamqq1nxXr17lxo0bODg4ULNmTY3jymHQ+Ph4VZry67Zt26oFbwBmZmY4OzuTlZVFUlKSRpl27dppnKN169aYmJhw/PhxsrOz87ym/GRmZpKRkaH6V9h6tNm8eTOOjo44Ojqq7v3LPHnyhN27d/P555/TrVs3mjZtSsOGDenWrRv//e9/8x2eLko7d+7kgw8+oFWrVrz77rs4OzvTtWtXPv74YzZt2qSWNzk5WXWdyn/vvPMOrVu3ZsSIEezfv/+1tFkIXSl/ZidPnqxxLD4+HkdHR4KCgkqgZUKUPdnZ2Wrvs5mZmTqVK5U9Y6/q999/548//qBOnTr59rKtWrVK7bWBgQEDBgxg2rRpGBsbq9IvX74MQO3atbXWo0xX5gO4dOnSS8vExsZy5coV2rRp89IyhoaG2NnZcfHiRa5fv57nAwP5GTx4sNrrgIAAAgMDC1zPi27cuMHMmTOpUKECDx8+1Jqna9euNG/enKpVq6rSrl27xkcffYSJiQlubm506NCBzMxMYmJi+OGHH9ixYwfr1q2jcuXKr9zGvEydOpV169ZRvnx5OnTogJ2dHY8ePeLq1avs2bOHhIQE+vfvr1HO3NycESNGAPD48WMuXrzI/v37iYmJ4csvv2TkyJHF1mYhhBCl09KlS1m0aFGBy5XJYOy3334DYODAgVqP16xZkxkzZuDh4YGNjQ0ZGRkcO3aM+fPns3btWh48eMDChQtV+TMyMoBnb8DaKNOV+XQpY2ZmBkB6enqBz/N8mYJYu3YtTk5OqtdGRkaFqud5CoWCKVOmUKlSJbp06cKyZcu05jM3N9e4rgoVKjB9+nS8vb1VQ7XwLLj56KOPOHDgAIsXL+bf//73K7dTm2PHjrFu3TpsbGzYuHEj1atXVzuemZlJQkKC1rIWFhYagey2bduYOHEi33//Pb6+vpQvX75Y2i2EEKJ0GjdunNqH8XPnzml0hGhT5oYpMzIy2LlzJ0ZGRlp7NABcXFwYNmwYderUwcTEhKpVq9KjRw/WrFmDhYUF27Zt49y5czqfU6FQFLq9enp6BT5PQco8z9TUVBUUmZubq/X+FdaqVauIi4tj7ty5mJqa5plv48aNODo6snHjRlWajY0Nw4cPVwvE4FmQ+OGHHwLqQ78v+uuvvxg7diwtWrSgUaNGDBgwgNjYWJ3bnpiYCEC3bt00AjF4dr86dOigc329evWiQoUKPHr0iAsXLuhcTojiEhQUpJpGER4erja83q5dO4YMGQLAokWL1I5p+73bv38/3t7eNGrUiObNm+Pv7682GqB0+fJl5s2bR58+fWjVqhVOTk54eHjwxRdfcOPGDY38zw+VHj9+nBEjRtC8eXMcHR1JTk4u4jsiRPEyNjZWe5/N733xeWWuZ2zLli08evSoUBP3bW1t6dChA1u3buXIkSOqXiRtPV/PU85ter7n53WVKUl//vkn8+fP54MPPqB169bExcUVWd3lypVT+/9FycnJeHt788477zB48GBu377Njh07GDlyJP/973/p1avXS8+h/PnQ9oZSWMqA2dCwzP1qiTeQi4sLH3zwAatWrcLJyQlPT0/VMQsLC86ePUt4eDguLi64uLiojr24XNCePXuIjo6mS5cuuLq6cvbsWXbt2kV8fDwbNmzAwcFBlXf37t2EhYXh6upKixYtKFeuHBcuXGDDhg3s27ePrVu3av3w8/vvv7NkyRJatmypWhIor99/IcqaMveOoZw8rku3oDbK+UmPHj1SpdWpUwfI+037ypUravkA1R+nl5V5fn6Yg4MDp06d4vLlyzRu3Fgt/9OnT0lOTsbQ0FDrQwSv29OnT/nkk0+wtbXl008/LfL6N2zYAGh/mAHgyJEjjB49mi+++EKV5ufnh4+PD9OmTaN9+/YvDVrbtWuHhYUF0dHRjBkzhh49etCkSRPq1Kmj8dCFLrZt20ZmZiZWVlY4OjoWuLwQRc3V1RU7OztVMPbi0Hp8fLwqGMtv/ui+ffv45Zdf6Nixoypt5cqVzJo1i+nTp6stqt23b19GjBih0fN+8OBBxowZQ3BwMLNmzdI4x6FDh/JccFuIsq5MDVMmJSVx7tw56tSpg6ura6HrANQCHnt7e2xtbbl8+TLXr1/XKBMdHQ2oL8mhPP+hQ4fIzc1Vy//gwQMSExMpX748zZs3V6Ury8fExGic48iRIzx69IgWLVoUyfDiq1q8eDFnz55l3rx5RT43au/evaxdu5Zq1arxr3/9S2sec3NzJkyYoJbWpEkTevfuTXp6Onv27HnpeapVq8bSpUuxt7dn//79fPrpp3Tp0oXmzZszcuRItm3bpvG9U0pPTycoKIigoCDmz5/Pv/71Lz755BPKlSvH119/XSq+R0IUFTc3N7VADGDYsGHUqlWLuLg4UlJSVOk2NjZaf/7fe+896taty6FDh7Sew8nJSQIx8dYqU8GYcuJ+fstZABw9elQjTaFQ8NNPP/H7779jZWWl1iOjp6en+iMxd+5ctTfoqKgojh49Sr169dS6+e3t7fHw8CA5OZmQkBC1cwUFBZGZmUm/fv3UxpO7deuGlZUVO3bs4OTJk6r07Oxs1VZQpeGP1YkTJ1iyZAmjRo2iRYsWRVr3sWPHmDRpEqampgQHB+e5ZVTDhg1VD0E8T/k9OHv2rE7nc3FxYe/evfz2229MmjSJrl27Ur58eaKjo5k4cSIjR47k8ePHGuUyMjJYtGgRixYtYunSpezbtw9DQ0N++eUXunfvXoArFqL0e/5vm5KBgQEtW7YE4MyZM6p0hULBli1b8PPzo1WrVrzzzjuquWgXLlzg1q1bWs/RtGnT4mm8EG+AUjlMuWfPHqKiogD4+++/ATh+/LhqnZxKlSoxdepUtTIZGRns2LEDIyMjvLy88q1/0KBB1KlThyZNmlCtWjUyMjJUy2GYmJjw/fffawxxjRw5kv379xMZGYmXlxfu7u7cuHGDyMhITExMmDNnjsbQ1syZM/Hx8eHrr7/m8OHD1K1bl6SkJOLj46lTpw6ffPKJWn5zc3Nmz57N+PHjGTJkCL169cLS0pJ9+/Zx6dIlunfvrtNcqOKkHJ6sU6cOkyZNKtK6jx07xsiRI9HX12f58uVqvYYvqlKlitZ0a2trIO95d9ro6+vTqlUrWrVqBTx7Mzl06BCTJ08mNjaWNWvWqJaxUKpRo4aqBzMjI4PY2FimTp1KQECA6mEFIcqKvJaX0fb7Nnv2bFauXEnVqlXx8PCgWrVqqt7zTZs2qfWiaatLiLdRqQzGzp07p7H597Vr17h27Rrw7I3wxWAsIiKCzMxMnSbujx49mpMnTxIXF8e9e/fQ19fH1tYWPz8/Ro4cSa1atTTKGBsbExISwtKlS4mIiGDlypWYmZnh6elJYGAg9erV0yhjb2/Pli1bVBuFR0dHY21tzfDhwwkICKBixYoaZbp06UJYWBg//vgju3btUm0U/uWXXzJ8+PBCP0lZVDIzM1Xz4LTt6wnP1u6aOnUqH3zwAdOmTdOp3oSEBMaMGYO+vj4rV67MNxAD+Oeff7SmK4P3V3nIQU9PDw8PDz7++GO++OIL4uLiNIKx55mbm9OjRw9MTEwYPXo0n3zyCZs3by7x75UQRSUtLU1r+ou/b//88w+rV6/mnXfeYcOGDRq919u2bcvzHPL7It5mpTIYCwwMLPBipEOGDFE9pv0yz0/6Lojy5cszceJEJk6cqHMZW1tb5s2bV6DztGzZkhUrVhSwda+HkZERAwYM0HrszJkznDlzhpYtW+Lg4PDSgErpf//7H2PHjsXIyIhVq1apbQWVlzNnzvDgwQONP/bKdcHyChQLQrnkhq5Ll3To0IF27doRExNDREQEffr0eeU2CPGqlD322uY/GhgYAJCTk5NvHQkJCRpzNHNycjh27BjwbNoAwPXr18nNzcXDw0PjdzM1NVXrnFshRCkNxkTpVb58eb777jutx4KCgjhz5gxeXl55Lrj7otjYWMaOHYupqSmrV69W/VF/mYyMDBYvXqwWWJ88eZKIiAjMzc3p0qXLS+uIjo4mKyuLjh07ajxC//DhQ1auXAmgGr7UxaRJk4iJiWHhwoX07NlTlrgQJc7S0hI9PT2t270pe+fz2gpOKS4ujv3796tN4v/111+5du0arq6u1KhRA/i/JTGOHTtGTk6OKth7+PAhU6dO5enTp0VxSUKUOfJO8Rbx9/enfPnyDB06VGPz8pJw6dIlxo4dS3Z2Nh06dGDv3r3s3btXI5+2XtLWrVuzfv16Tpw4gbOzs2qdsdzcXGbNmqXTMOWlS5eYNWsWlpaWtGrVCnt7ewwNDbl58yYHDhwgPT2dZs2aMWzYMJ2vqUmTJnTu3Jm9e/eyfv36UvHAhXi7VahQgWbNmnHkyBE+/vhjateujb6+Pp07d6ZevXrY2Niwfft2DA0NsbW1RU9Pj379+qkCLIDOnTvz4Ycf0qVLF+zt7Tl37hwHDx6kYsWKfP3116p81tbW9OrVi+3bt9OrVy88PDzIyMjg0KFDGBsb06BBA50frhHiTRYSEkJoaChZWVk65Zdg7C0SHBxMo0aNSroZKrdv31ZtVr5r1y527dqlNZ+2YMzOzo5Zs2Yxb948wsLCePz4MQ0bNmTChAl5rk32oj59+mBmZsahQ4c4f/48R44cITMzEwsLC5ycnOjRowcDBgwo8LZREydOZN++fQQHB9O/f39Z5qKUsqyxr6Sb8NosWLCA2bNnEx0dTUREBAqFAhsbG+rXr8+SJUuYN28eO3fu5OHDhygUClq2bKkWjHl6ejJo0CCCg4M5cOAAhoaGdO3alcmTJ6utrwgwZ84catasyY4dOwgJCcHKyorOnTszceJE/P39X/elC1Ei/Pz88PPz4/Tp0zpNWdFTvMpePuKNoPxh2Lp1a4kFY2FhYUybNo3//ve/9O7du0TaIIQQQrxOur7/lql1xkTpdenSJeDZAw1CCCGE+D8yTCmK1Z49ezhw4ABbtmzBxsZGFnYUQgghXiA9Y6JYRUVFsXv3blxcXPj1119l418hhBDiBdIzJorV/PnzS7oJQgghRKkmPWNCCCGEECVIgjEhhBBCiBIkwZgQQgghRAmSOWNvkdK2Ar8QQghRFskK/CJPpW0FfiGEEKIsKugK/DJMKYQQQghRgiQYE0IIIYQoQRKMibfelStX+Oijj3B1daVu3bo0a9YMgKCgIBwdHYmPjy/ZBgohhCjTZM6YeOP5+vqSkJDAX3/9VeCyubm5fPjhh1y5coW+fftiY2ODsbFxvmUcHR1xcXEhLCyssE0WQgghVCQYE2+1a9euceHCBQYOHMi3336rdszPz49evXrJ5uZlVOLU30q6Cfly/nZQSTdBCPGayDCleKvdvn0bgGrVqmkcs7KywtHRERMTk9fdLCGKTHJyMo6OjkyePFktfdeuXTg6OhIQEKC13I8//oijoyONGjXi8ePHGscvX76Mo6MjnTp1KpZ2C/E2kWBMFMrzf+D/+usvxo4dS4sWLWjUqBEDBgwgNjZWo0x2djZLliyhe/fuNGzYkKZNmzJw4EC2bdum9Ry7d+/G19cXFxcXnJyccHFxYcCAAYSEhKi1ISEhAXg2fKj85+vr+9JrcHR0ZPDgwQAsWrRIVTYoKAjQnDO2ceNGHB0dAUhISFA7n7KMEG8KV1dX9PX1iYuLQ6FQaByPi4tDT0+PR48ecfz4ca3HAdzd3Yu9rUKUdTJMKV5JcnIy3t7evPPOOwwePJjbt2+zY8cORo4cyX//+1969eoFwOPHjxk+fDhHjx6lXr16DB06lKysLHbu3MnEiRM5e/YsU6ZMUdW7Zs0apk+fjrW1NZ06dcLKyoq0tDTOnz/Ppk2b8PPzw8LCgoCAADZt2kRKSoraJ/waNWq8tO0BAQEkJycTHh6Oi4sLLi4uAKr/X9SgQQMCAgJYtGgRNWrUoH///qpjeZURorSqWLEiTk5OnDlzhgsXLvDuu++qjmVnZ/P777/TrVs3du3aRVxcnMbPuARjQhQdCcbEKzly5AijR4/miy++UKX5+fnh4+PDtGnTaN++Pebm5ixbtoyjR4/SsWNHlixZgqHhsx+9CRMm0LdvX37++Wc6depEy5YtAVi3bh1GRkZs376dKlWqqJ3zzp07AFhYWBAYGEhCQgIpKSkEBgYWqO2BgYHEx8ergrGXlW/QoAENGjRg0aJF2NnZFfh8QrxuQUFBLFq0CIDw8HDCw8NVx+bOnYubmxtnzpzh8OHDasHY8ePHycrKolu3bly+fJm4uDgmTpyoOq5QKIiPj0dPTw9XV9fXdj1ClFUyTPkW8ff3p2vXrqphvqJgbm7OhAkT1NKaNGlC7969SU9PZ8+ePQBs2LABPT09pk6dqgrEAKpUqcL48eNVeZ5nYGBAuXLlNM5pZWVVZO0XoixzcXHhgw8+AMDJyYmAgADVvwYNGuDm5gb8Xy+X0uHDh4FnQ5murq6cOHGCzMxM1fHz589z584dGjRoQKVKlV7PxQjxBgkJCaFr1674+/vrlF96xt4ixbEdUsOGDTEzM9NId3FxITw8nLNnz9K1a1euXbuGjY0NderU0cjbpk0bAM6cOaNK69OnD99++y3dunWjV69etGrVCmdnZypXrlyg9m3cuJGUlBSNtsmnefE2cHV1xc7OjlWrVuHk5KTRm1u7dm3KlSvHkSNHyMnJwcDAAHgWnNWrV48qVarg6urKqlWrOHr0KO3bt1cdB1TBnBBCXUG3Q5JgTLySF4cQlaytrQHIyMggIyNDLe1FVatWVeVVGjVqFJUqVWLNmjWsWrWKFStWqIZEPv/8c52DyvDwcNUEf6WAgAAJxoQATE1NadKkCYmJiZw+fZqmTZvy8OFDTp06xaBBz5bWcHFxUU30fzEYk/liQhQNCcbEK/nnn3+0pv/999/As2FMc3NztbQXKZeXUOZT8vLywsvLi/T0dBITE9mzZw8bN27kgw8+YPfu3Tr1ksnCrELkz93dncTEROLi4mjatClHjx7lyZMnqg8sFhYWODk5qQKwnJwcjhw5Qrly5WjVqlVJNl2IMkPmjIlXcubMGR48eKCRruyNatCgAWZmZtSqVYtbt25x+fJljbzKpSMaNmyo9RwWFhZ06NCB7777jv79+3P37l2OHTumOq6v/+zHOCcn55WvRxf6+vqv7VxCFDdl75Zyntjhw4fR09NTe3rS1dWVs2fPcv/+fU6ePMmDBw9o2rQppqamJdJmIcoaCcbEK8nIyGDx4sVqaSdPniQiIgJzc3O6dOkCgI+PDwqFgjlz5qgFMnfu3OGHH35Q5VGKjo7m6dOnGudLS0sDwMjISJWmnECcmppaRFeVv4oVK762cwlR3Jo1a4aJiQmJiYk8fvyY+Ph46tevrzYx39XVldzcXOLj42WIUohiIMOU4pW0bt2a9evXc+LECZydnVXrjOXm5jJr1izV0OPo0aOJjo5m79699OzZk/fee0+1zlhaWhr/+te/VMtawLNlJ4yNjWnZsqVqzbCjR49y8uRJGjZsqJr0D88mEe/cuZOPPvqIdu3aUb58eWrUqEG/fv2K5Zrd3d3Zvn07Y8eOpUGDBhgYGNC6dWtat25dLOcT4lUoe45zc3O1HjcyMqJly5bExsZy4MABzp07x/Dhw9XytGrVCgMDA+Li4lR7wEowJkTRkWBMvBI7OztmzZrFvHnzCAsL4/HjxzRs2JAJEybQrl07VT4jIyN+/fVXli9fTkREBL/++iuGhobUr1+fr776it69e6vV+9lnnxETE8OZM2c4ePAgxsbG1KhRg88++4whQ4ao9YwNHDiQGzdusH37dn755ReePn2Ki4tLsQVj06ZNQ09Pj8OHD7N//35yc3MJCAiQYEyUSpaWlujp6eXbm+vm5kZsbCxBQUHk5uZqPOBibm5Ow4YNiYmJ4ebNm5iamtK0adPibroQbw09hbZ9MESZony0duvWrUW2tEVycjLt27fHy8uL+fPnF0mdQrxOb9NG4d7e3iQlJdG7d29q166Nvr4+nTt3pn79+sCzqQXKDy/6+vokJiZiYWGhVsfcuXP5+eefAWjXrh0rV64ssvYJUVbp+v4rPWNCiLdSUQY7pd2CBQuYPXs20dHRREREoFAosLGxUQVjjRo1wtLSkvv379OgQQONQAyezRtTBmOyvpgQRUuCsbeIv78/5cuXZ+jQofj5+ZV0c4QQr0nt2rX55Zdf8jyur6/P77//nm8d7du3V80XE0LkLyQkhNDQULKysnTKL8HYW6Q4VuAXQgghhDpZgV+8FnZ2dvIpWQghhCgCss6YEEIIIUQJkmBMCCGEEKIElcphysjISBISEjh37hznz5/nwYMH9OnTh++//14jr3KJhbz07NmTRYsWaT22adMmQkND+fPPP9HX16dhw4aMHj2ajh07as2flZXF0qVL2b59OykpKZiZmeHq6kpgYCB169bVWiY1NZWFCxcSExPDvXv3sLa2xtPTk4CAACwtLbWWSUxMJDg4mKSkJLKzs7G3t8fHx4dhw4ZhYGCQ57UKIYQQ4s1TKoOx4OBgzp07R4UKFbCxsdG69+GLnJyc8PT01Eh/5513tOb/9ttvWb58OTY2NgwcOJAnT56wfft2xowZw4wZMxg2bJha/uzsbIYNG0ZiYiKNGzfmgw8+IDU1lcjISA4cOEBoaCjNmjVTK3P16lV8fHxIS0ujc+fOODo6cuLECVatWkVMTAzr169X23IEICoqCn9/f4yNjenZsyeWlpbs37+fWbNmkZiYqNo6SAghhBBlhKIUOnz4sOLSpUuK3NxcRVxcnMLBwUExadIkrXmvX7+ucHBwUHz66ac613/s2DGFg4OD4r333lPcu3dPra4WLVoo6tevr7h+/bpamR9//FHh4OCg8Pf3V+Tk5KjS9+zZo3BwcFB07dpVLV2hUCiGDx+ucHBwUKxatUotfdasWQoHBwfFl19+qZaenp6uaNmypaJ+/fqKEydOqNKzsrIU/fv3Vzg4OCgiIiJ0vk6lU6dOKRwcHBSnTp0qcFkhhBBCFI6u77+lcs6Ym5sbderUQU9Pr1jqDwsLA56tu/X8UKGdnR1Dhw7l8ePHbNiwQZWuUChUZaZMmaLa6w3A09OTVq1acfHiReLj41XpV69eJTY2lpo1a2qs6RUYGIipqSmbN2/m4cOHqvTIyEju3LlDr169aNKkiSrd2NiYjz/+GIA1a9YUxS0QQgghRClRKoOxwrh9+zZhYWH8+OOPhIWFcf78+TzzKoMmbXPNlGkvBlY3btzAwcGBmjVr6lRG+XXbtm3VgjcAMzMznJ2dycrKIikpSaPM83s6KrVu3RoTExOOHz9OdnZ2ntcmhBBCiDdLqZwzVhiHDh3i0KFDamkuLi4sWLAAW1tbVVpmZiY3b96kQoUKWFtba9RTu3ZtAC5fvqxKU36tPKZLmUuXLr20TGxsLFeuXKFNmzYvLWNoaIidnR0XL17k+vXreT4wkJ/MzEwyMjJUr42MjDA2Ni5wPUIIIYTQlJ2dzePHj1WvMzMzdSr3xgdj5cuXZ/z48Xh6elKrVi0Azp8/T1BQEPHx8QwdOpTt27djamoKoApGzM3NtdanTH8+aCmOMmZmZgCkp6cX+DzPlymIwYMHq70OCAggMDCwUHUJIYQQQt3SpUvzXMEhP298MFalShUmTZqklta6dWtWr17NwIEDSUpKYt26dYwYMaLY2qBQKApdtiDz4pTnKexcurVr1+Lk5KR6bWRkVKh6hBBCCKFp3LhxjBw5UvX63LlzGh0h2pSZOWMvMjQ0ZMCAAQAcPXpUla6tF+t52nqnXlZGufRGSZQpCFNTU8zNzVX/ZIhSCCGEKDrGxsZq77PKUbmXeeN7xvJTuXJlQH3M1tTUFBsbG27evMnt27epWrWqWpkrV64AUKdOHVWa8uvn54S9rIyDg4NOZZ6fH+bg4MCpU6e4fPkyjRs3Vsv/9OlTkpOTMTQ01PoQgRCiYM4OL56ntYtKg9WF73EvDF9fXxISEkpkz9mSPLd4u+9/abn2MtszBqieVFTOJVNydXUFICYmRqNMdHQ08Gx5DSV7e3tsbW25fPky169f16mM8hyHDh0iNzdXLf+DBw9ITEykfPnyNG/eXJWuLK+tXUeOHOHRo0e0aNFCerSEEKIAgoKCcHR0VHvi/U3Qrl07rU/Xi7LnjQ/GkpKS1J5cUEpISGDFihUA9OnTR+2Yr68v8Gyl//v376vSk5OTCQ0NxcjICG9vb1W6np6eqszcuXPVgquoqCiOHj1KvXr1cHFxUaXb29vj4eFBcnIyISEhaucPCgoiMzOTfv36qXVhduvWDSsrK3bs2MHJkydV6dnZ2aqtoJTtEEKIorRgwQL27NlT0s0Q4q1UKocp9+zZQ1RUFAB///03AMePH2fy5MkAVKpUialTpwIwb948Ll68iIuLCzY2NgD88ccfHD58GIBJkybh7OysVr+zszOjRo1i+fLl9OjRg+7du/PkyRN27NjBvXv3mDFjBnZ2dmplRo4cyf79+4mMjMTLywt3d3du3LhBZGQkJiYmzJkzR2M9sZkzZ+Lj48PXX3/N4cOHqVu3LklJScTHx1OnTh0++eQTtfzm5ubMnj2b8ePHM2TIEHr16oWlpSX79u3j0qVLdO/enV69ehXFLRZCCDXPLwEkhHi9SmUwdu7cOcLDw9XSrl27xrVr1wCoUaOGKhjr27cve/bs4eTJk0RHR/P06VMqV65Mjx49GDZsGK1atdJ6jqlTp/Luu+8SEhLCb7/9ptoofMyYMVo3Cjc2NiYkJISlS5cSERHBypUrMTMzw9PTk8DAQOrVq6dRxt7eni1btqg2Co+Ojsba2prhw4cTEBBAxYoVNcp06dJFtXjtrl27VBuFf/nllwwfPrzYdiUQQpRNu3fvZvXq1fz111+kp6djYWGBvb0977//vtruINrmzsTHxzNkyBACAgLw9PTkP//5D4mJiTx58oTGjRvz6aef0rJlS41z3r59mwULFnDgwAEePnyIg4MDI0aMoEaNGqr6dF1WJyYmhlWrVnHy5EkePnyIjY0NXbp0wd/fHwsLi5eWb9euHSkpKQAMGTJE7djz13rr1i2Cg4M5ePAgt2/fxtzcHGdnZz766CO1HVEANm7cyJQpU5g7dy5WVlb8+OOPnD9/nnLlyuHu7s6nn36qNoe4oJT3XcnR0VH1tZeXF/Pnz9epnnv37rFs2TL27t3L9evXVetVtm/fnvHjx2tMLn/69Ck///wzGzduJDU1FSsrK3r16sXHH3+sMT1mz5497Nq1ixMnTnDr1i309PSoU6cO/fr1Y9iwYRgYGKjlnzx5MuHh4URHRxMTE0NISAhXrlzB3NycTp068cUXX2h8P5VDtLt372bhwoXs2LGDtLQ01Z7SY8eO1fqemJSUxC+//MKxY8e4f/8+lStX5r333iMgIIBq1arpdO9et1IZjAUGBur8izpgwADVU5MF1b9/f/r3769z/vLlyzNx4kQmTpyocxlbW1vmzZtXoHa1bNlSNcQqhBCFtWbNGqZPn461tTWdOnXCysqKtLQ0zp8/z6ZNmzS2asvLqVOn+Pnnn2nevDkDBgwgNTWVXbt24efnx7Zt29QWof7nn3/w8fEhOTmZ1q1b06JFC/7++29mzJhB27ZtC9T+xYsXs3DhQipVqsR7771H5cqV+eOPP1i2bBnR0dFs2LDhpU+XjxgxgqioKBISEvDy8tIY9YBnH/YHDhzI7du3cXd35/333yc1NZXIyEgOHjzI4sWL8fT01Ci3Z88eoqOj6dKlC66urpw9e5Zdu3YRHx/Phg0bVA9yFZSdnR0BAQGsXLlSdQ1Kzy9PlJ/r168zZMgQUlJSaNSoEUOGDCE3N5dLly6xcuVKfH19NYKxSZMmcfToUdq3b4+ZmRkHDx5k2bJlpKWlsWDBArW88+fPR19fn2bNmlGtWjXS09M5fPgws2bN4sSJEyxcuFBru+bOnUtMTAydOnXCw8OD+Ph41q9fz5UrV1i7dq1G/qdPnzJ8+HBu375N+/btMTQ0JCoqivnz55OVlaXxfrxx40amTp2KsbExnTp1wsbGhitXrrB+/Xr279/Ppk2bSmUvcKkMxoQQQry6devWYWRkxPbt26lSpYrasTt37uhcz4EDB5g3b57ah9ewsDCmTZvG6tWr+eabb1TpCxYsIDk5mX/9619MmTJFlT5ixAi8vLx0PmdcXBwLFy7E2dmZ5cuXqwVdyp6phQsXMm3atHzrGTFiBOnp6SQkJNC/f3/Vw1XPmzZtGrdv3+azzz5j7NixqnRfX18GDx7MlClTcHNzUy3WrbRv3z5++eUXtdGUlStXMmvWLKZPn05oaKjO1/s8Ozs7AgMD2bRpE0ChFuf++OOPSUlJ4dNPP+XDDz9UO3bnzh0qVKigUebq1avs2rVLNWrzySef0LNnT7Zu3cpnn32mtvrAsmXLsLe3Vyufm5vLp59+ytatWxk+fLjaA2pKSUlJREZGqgKip0+fMnToUI4cOUJSUhLNmjVTy3/r1i3q16/Pr7/+Svny5QGYMGECnTt3ZuXKlfj7+1OuXDng2eoFX331FTVr1mTt2rVq7T18+DDDhw9n5syZ/PTTTzrexdfnjZ/AL3Tn7+9P165dNR4oEEKUXQYGBqo3q+dZWVnpXEfLli01RhF8fHwwNDRUe9jo8ePHbNu2DXNzc/z9/dXyOzk50bdvX53PuXr1agBmz56t0fvl7e1NgwYNiIiI0Lm+vKSmpnLo0CFq1KjBqFGj1I61bNmSXr16cf/+fa0PN7i5uWlMaxk2bBi1atUiLi5ONTz6up06dYrff/+dBg0aqAWXSlZWVlqfyp8yZYra9BlTU1P69OlDbm4up0+fVsv7YiAGoK+vr+rFe3F7QqUJEyao9UwZGhqqHph7/mfpeTNmzFAFYvBssffOnTvz4MED1TaC8Kwn+MmTJ3z11Vcay1a5u7vTqVMn9u/fn+dankUpJCSErl27avwe5EV6xt4iwcHBNGrUqKSbIYR4Tfr06cO3335Lt27d6NWrF61atcLZ2Vm1BqOuXlz3EKBcuXJUqVJFbXu2y5cvk5WVRePGjTV6keBZcLN+/Xqdznn8+HHKlSvHzp07tR5/8uQJd+7c4e7du1SqVEnHK9F09uxZAFq1aoWhoeZbYps2bYiIiODMmTMaPXvPP0GvZGBgQMuWLbl27RpnzpyhRo0ahW5bflauXKmxNZ6npycNGjRQLevk4eGh8WBZfl6cGwdQvXp1ALWVBwDu3r3LL7/8wsGDB7l+/brGHow3b97Ueg5tP0t5nQNQzXHMq8zz9+D48ePAs9UUtAV2aWlp5ObmcuXKFa3tKEp+fn74+flx+vRpjRUdtJFgTAghyqhRo0ZRqVIl1qxZw6pVq1ixYgV6enq4urry+eef6/zhLK95WQYGBuTk5KheK3scXhwSVcorXZt79+7x9OnTl+7zl5mZ+UrB2MvabG1trZbveXkFtfmVKSorV67U6HmrUaMGDRo0UAUoBZ2sru37rJyI//z3OT09nX79+nH9+nWaNm1Kv379sLS0xNDQkPT0dFatWqV1yamXnePFNTnzyg+oAufn23X37l0AfvnlF61llHTdvPt1kmBMCCHKMC8vL7y8vEhPTycxMZE9e/awceNGPvjgA3bv3l3gXrL8KHvD/vnnH63H80rXxtzcnNzcXH7//fciaVt+54G826ZcXklbUJCWllbgMkVF2+LgSsqnEm/dulUs5163bh3Xr1/X+lTs77//zqpVq4rlvC+jvN9JSUnFeu+Lg8wZE0KIt4CFhQUdOnTgu+++o3///ty9e5djx44V6TkcHBwoX74858+fV+2l+7yCnK9Zs2bcv3+fCxcuvHK7lEN1z/eiKDVo0EDVtqdPn2ocj4uLA6Bhw4YaxxISEjTScnJyVNeprUxBvNjzqCvlJPhDhw6hUBT9tlpXr14Fni1U/qIjR44U+fl0pXxgoKh/rl8HCcaEEKKMUq69+CJlj46RkVGRns/IyIiePXuSkZFBcHCw2rFz586xZcsWnetSTgSfOnWq1h6ezMxM1Ryhl1EOY6ampmocq169Om3btiU5OVm1lIRSUlIS27Ztw9LSki5dumiUjYuLY//+/Wppv/76K9euXcPV1VVtvlhycjKOjo4F2t6oYsWK3Llzh+zsbJ3LwLN5WS1atODMmTNah+zu3r1b4Dqfp1weRBmoKp05c4YlS5YUut5X5efnR7ly5Zg1a5bWfaEfP37M0aNHS6BlLyfDlEIIUUYFBgZibGxMy5YtVYHB0aNHOXnyJA0bNqRNmzZFfs7PPvuMuLg4fv75Z06cOEGLFi24ffs2O3fupH379kRFRek0qbxNmzZ89tlnzJ8/n06dOvHee+9hZ2dHZmYmKSkpHDlyBGdnZ52GxFxdXdHX12fBggVcuHBBNYw3fvx4AL755hsGDBjAnDlzOHToEI0bNyY1NZWdO3eir6/P3LlztT6Q0LlzZz788EO6dOmCvb09586d4+DBg1SsWJGvv/5aLa9yPtSLi6Hmx93dnZMnTzJixAhatWpFuXLlcHJyolOnTi8t+/333+Pr68vcuXPZuXMnrVu3BuDKlSvExsYSFRWldc01XfTr149ffvmF2bNnk5CQQO3atbly5QoHDhygS5cu7Nixo1D1vipHR0fmzJnD559/Trdu3WjXrh116tThyZMn3Lhxg2PHjmFlZaXa4ac0kWBMCPFWarC66IdvSpvPPvuMmJgYzpw5w8GDBzE2NqZGjRp89tlnDBkypMh7xuDZRPgNGzawYMECoqOjSUpKwsHBgZkzZ2JqakpUVJTWwEabsWPH4uzszOrVqzl27Bh79+7F3NycatWqMWjQIN5//32d6qlbty7z589n2bJlhIaGqnqFlMFYrVq12LJli2oF/oSEBMzMzGjXrh3+/v5anzKEZ08vDho0iODgYA4cOIChoSFdu3Zl8uTJGivw//HHHwAF2tLO39+f9PR09u/fz7Fjx8jJycHLy0unYKxmzZpERETw888/ExUVRUhICMbGxtjZ2TFq1KhXmitYrVo1fvvtN+bPn8+xY8eIjY1VfY/btGlTYsEYPNuVx8nJiWXLlhEfH8+hQ4cwMTGhatWqdOvWjZ49e5ZY2/KjpyiOAWVRqigfrd26dassbSGEKDELFixgyZIlrFy5skDDdaXN89shKdfIepnZs2ezdu1aYmJiCrTGm3iz6fr+K3PGhBBCFCltc7z++OMPfv31VypVqqR1fa6yLiEhgYEDB0ogJrSSYUohhBBFqm/fvtjb2/POO+9gYmLClStXOHjwILm5ucyePVvr6u9lXVHsFiDKLgnG3iL+/v6UL1+eoUOH6rxBsBBCFJSvry979+5l586dZGRkYG5uTrt27Rg9evRb2Ssm3j4hISGEhoaSlZWlU36ZM/YWkDljQgghxOsnc8aEEEIIId4AEowJIYQQQpQgCcaEEEIIIUqQBGNCCCGEECVIgjEhhBBCiBIkwZgQQgghRAmSYEwIIYQQogRJMCaEEEIIUYJkBf63iKzAL4QQQhS/gq7AL8HYWyQ4OFhW4Bfi/9Nb+WlJNyFfihELXuv5fH19SUhI4K+//nqt5y3pc4v/Ex8fz5AhQwgICCAwMLCkm/NaFfW1+/n54efnp1qB/2VkmFIIIUSZFhQUhKOjI/Hx8SXdFCG0kp4xIYQQLFiwgEePHpV0M4R4K0kwJoQQAltb25JughBvLRmmFEKIMmz37t34+vri4uKCk5MTLi4uDBgwgJCQELV8vr6+ODo6qqXFx8fj6OhIUFAQZ8+eZdSoUTRr1oyGDRsyaNAgjh07pvWct2/f5rPPPqNVq1Y0aNCAXr16sWnTJrX6dBUTE8PIkSNp2bIlTk5OdOjQge+++4709HSdyrdr145FixYBMGTIEBwdHVX/nnfr1i2mT59Ou3btqF+/Pq1atWLcuHGcPHlSo86NGzfi6OjIxo0b2b9/P97e3jRq1IjmzZvj7+/P5cuXdb6+/Jw5c4YJEybg4eGBk5MTzs7O9OjRg6+//ponT54UqK7Y2FjGjBlDq1atcHJyok2bNowdO5b//e9/WvPr+v2+desWixcvxsfHBxcXF+rXr4+bmxuBgYFcuHBBI39ycjKOjo5MnjyZ5ORkAgICVN/b3r17s3fvXo0yz9/vuLg4fH19adKkCU2bNmXkyJFazwPw6NEjlixZQq9evWjUqBGNGzfG29ubiIiIAt2710F6xoQQooxas2YN06dPx9ramk6dOmFlZUVaWhrnz59n06ZNOj9VferUKX7++WeaN2/OgAEDSE1NZdeuXfj5+bFt2zbq1q2ryvvPP//g4+NDcnIyrVu3pkWLFvz999/MmDGDtm3bFqj9ixcvZuHChVSqVIn33nuPypUr88cff7Bs2TKio6PZsGED5ubm+dYxYsQIoqKiSEhIwMvLCzs7O408165dY+DAgdy+fRt3d3fef/99UlNTiYyM5ODBgyxevBhPT0+Ncnv27CE6OpouXbrg6urK2bNn2bVrF/Hx8WzYsAEHB4cCXe/zzp49i7e3N/r6+nTq1ImaNWvy4MEDrl69SlhYGJ988gnlypXTqa6FCxeyePFiKlSogKenJ9WrV+fWrVskJiayZcsW2rRpo5a/IN/vI0eOsHTpUlxdXenWrRsmJiZcuXKFXbt2sW/fPtavX0+DBg002pSSkkK/fv2oVasWffv25d69e+zYsYNx48axevVqjTYBHDhwgL1799K+fXsGDx7Mn3/+ycGDBzl16hS7du2icuXKqrzp6ekMHTqUM2fO0KhRI7y9vVEoFMTExDBp0iQuXrzIJ598ouu3o9hJMCaEEGXUunXrMDIyYvv27VSpUkXt2J07d3Su58CBA8ybN4/+/fur0sLCwpg2bRqrV6/mm2++UaUvWLCA5ORk/vWvfzFlyhRV+ogRI/Dy8tL5nHFxcSxcuBBnZ2eWL1+uFnRt3LiRKVOmsHDhQqZNm5ZvPSNGjCA9PZ2EhAT69++Pq6urRp5p06apevPGjh2rSvf19WXw4MFMmTIFNzc3zMzM1Mrt27ePX375hY4dO6rSVq5cyaxZs5g+fTqhoaE6X++LNm/ezOPHj1myZAldunRRO3b//n1MTEx0qic2NpbFixdTq1Yt1q5di42NjeqYQqHg5s2bGmUK8v12c3MjISFB496cPn2aQYMGMW/ePFatWqVxjoSEBAIDAwkICFCl9e7dmxEjRrBs2TKtwVhUVBQrV65UOzZ//nyWLl3Kxo0b1b5333zzDWfOnOGLL75g9OjRqvTs7GzGjh3LkiVL6NatGw0bNszr1r1WMkwphBBlmIGBgdYeFCsrK53raNmypdobM4CPjw+GhoZqw3iPHz9m27ZtmJub4+/vr5bfycmJvn376nzO1atXAzB79myN3i9vb28aNGhQJMNNqampHDp0iBo1ajBq1Ci1Yy1btqRXr17cv3+fPXv2aJR1c3NTC8QAhg0bRq1atYiLiyMlJaXQ7dLT0wPQGnRZWlqir6/b2/evv/4KwOeff64WiCnPUb16dY0yun6/AapUqaIRiAE0atRIFahpG1K1s7PT+Blp164dtra2nDp1Suu1vP/++xpB2qBBgwDU2nX37l22bt1KkyZN1AIxAGNjY6ZMmYJCoShVw5XSMyaEEGVUnz59+Pbbb+nWrRu9evWiVatWODs7qw3n6KJx48YaaeXKlaNKlSpqc7cuX75MVlYWjRs31voG3bJlS9avX6/TOY8fP065cuXYuXOn1uNPnjzhzp073L17l0qVKul4JZrOnj0LQKtWrTA01HxLbNOmDREREZw5c0ajZ8/FxUUjv4GBAS1btuTatWucOXOGGjVqFKpdvXr1YtWqVYwbN47u3bvj7u6Os7Mz9vb2Gu2PiopSS7OwsGDEiBEAJCUloaenR/v27XU+t67fb6UDBw4QFhbGqVOnuHv3Lk+fPlU7fvfuXapWraqW5uTkhIGBgUZd1atX5/jx41rbpW2dTGUwef/+fVXayZMnycnJAdA6P1EZHF66dEnreUqCBGNCCFFGjRo1ikqVKrFmzRpWrVrFihUr0NPTw9XVlc8//1znRaDzmpdlYGCgetMDyMjIANAYElXKK12be/fu8fTpU9Xk+7xkZma+UjD2sjZbW1ur5XteXkFtfmV01aRJE3777Td+/PFHIiMj2bx5MwCOjo4EBATQq1cv4Fkw9uI9qlGjhioYS09Px9LSkvLly+t8bl2/3wCrVq3im2++wdLSkjZt2mBra4uJiQl6enpERUVx7tw5Hj9+rPM5DA0Nyc3N1bldygD6+TL37t0DngVl2h7AUHr48GGex143CcbeIrIdkhBvHy8vL7y8vEhPTycxMZE9e/awceNGPvjgA3bv3l3gXrL8KHvD/vnnH63H80rXxtzcnNzcXH7//fciaVt+54G82/b333+r5XteWlpagcsURIsWLVi2bBnZ2dmcPn2amJgYfv31VyZOnIiVlRXu7u54e3vj7e2dZx0WFhbcvXuXrKysAgVkunj69ClBQUFYW1sTERGh0fuVVw9XcVPe95EjR/Lll1+WSBsKuh2SzBl7iwQHB7N7924JxIR4C1lYWKiWhejfvz93797Nc2mKwnJwcKB8+fKcP3+eBw8eaBwvyPmaNWvG/fv381y2oCCU86te7NUBVE/6HTt2TGN4DZ49SABoneidkJCgkZaTk6O6zqKaHG5sbIyzszOTJk1i+vTpKBQKjaHJvDRr1gyFQkFsbGyRtOV5d+/eJT09nRYtWmgEYg8fPuTMmTNFfk5dNGnSBH19fY4ePVoi54dn2yHt3r2b4OBgnfJLMCaEEGVUdHS01gBD2aNjZGRUpOczMjKiZ8+eZGRkaLwJnTt3ji1btuhcl3KYberUqdy6dUvjeGZmps49L8phzNTUVI1j1atXp23btiQnJ7Ny5Uq1Y0lJSWzbtg1LS0uNJxrhWaC2f/9+tbRff/2Va9eu4erqqjZfTLm+Vrt27XRq89GjR7UOcyp78IyNjXWqZ9iwYQB8++233L59W+O4tqcpdVW5cmVMTEw4deqU2pDfkydP+Oabbwr0xG5RqlKlCr179+bUqVMsXrxY6+/A1atXuX79egm0TjsZphRCiDIqMDAQY2NjWrZsqQoMjh49ysmTJ2nYsKHW5QNe1WeffUZcXBw///wzJ06coEWLFty+fZudO3fSvn17oqKidHoSsE2bNnz22WfMnz+fTp068d5772FnZ0dmZiYpKSkcOXIEZ2dnrcsmvMjV1RV9fX0WLFjAhQsXsLCwAGD8+PHAs2UQBgwYwJw5czh06BCNGzcmNTWVnTt3oq+vz9y5c7U+kNC5c2c+/PBDunTpgr29PefOnePgwYNUrFiRr7/+Wi2vck6Ttknr2ixbtoxDhw7h4uJCrVq1MDU15eLFi0RHR2NhYaF6ivBlPDw8GD9+PD/88AOenp507tyZ6tWr888//5CYmEizZs2YP3++TnW9SF9fn+HDh7N06VJ69OhB586defLkCfHx8dy7dw9XV9cS2w/03//+N1evXmXhwoVs2bKFli1bUqVKFW7dusVff/3FyZMnWbhwITVr1iyR9r2oVAZjkZGRJCQkcO7cOVV3d58+ffj+++818l6+fJk9e/YQExPDlStXSEtLw8LCgmbNmjFixAjc3Nw0yijXqMnLN998g6+vr0Z6VlYWS5cuZfv27aSkpGBmZoarqyuBgYFqi+A9LzU1lYULFxITE8O9e/ewtrbG09OTgIAALC0ttZZJTEwkODiYpKQksrOzsbe3x8fHh2HDhun8iyyEyJ9ixIKSbkKx++yzz4iJieHMmTMcPHgQY2NjatSowWeffcaQIUOKvGcMnvVKbNiwgQULFhAdHU1SUhIODg7MnDkTU1NToqKitAY22owdOxZnZ2dWr17NsWPH2Lt3L+bm5lSrVo1Bgwbx/vvv61RP3bp1mT9/PsuWLSM0NJTs7Gzg/4KxWrVqsWXLFoKDgzl48KBq3ax27drh7+9PkyZNtNbr6enJoEGDCA4O5sCBAxgaGtK1a1cmT55MnTp11PL+8ccfAKqJ9y8zdOhQLC0tOXHiBImJieTk5GBjY8OQIUMYPXp0gZ7SnDRpEs2aNWP16tUcOHCAR48eYWVlRePGjenXr5/O9eRVt5WVFevXr2ft2rWYm5vTtm1bPv74YxYuXPhKdb8Kc3NzwsLC+O2334iIiGDXrl08fvyYypUrU7t2bb766qsCL0JcnPQUCoWipBvxol69enHu3DkqVKiAjY0Nf/31V57BWEBAADt27KBu3bq0bNmSihUrcunSJfbt20dOTg5fffWVqrtbSRmMde7cWevKwB06dND45cvOzsbPz4/ExEQaN26Mm5ubaoXmcuXKERoaSrNmzdTKXL16FR8fH9LS0ujcuTOOjo6cOHGC+Ph4HBwcWL9+vcZTQFFRUfj7+2NsbEzPnj2xtLRk//79XLp0ie7du/PDDz8U+H6ePn2aPn36sHXrVp2fnhJCiKK2YMEClixZwsqVK3UeriuNlO8hc+fOzXfy/PNmz57N2rVriYmJKdAab+LNpvP7r6IUOnz4sOLSpUuK3NxcRVxcnMLBwUExadIkrXk3bNigOHnypEZ6fHy84t1331W8++67ilu3bmmUcXBwUGzYsEHnNv34448KBwcHhb+/vyInJ0eVvmfPHoWDg4Oia9euaukKhUIxfPhwhYODg2LVqlVq6bNmzVI4ODgovvzyS7X09PR0RcuWLRX169dXnDhxQpWelZWl6N+/v8LBwUERERGhc5uVTp06pXBwcFCcOnWqwGWFEKKgbt68qZF2/vx5RePGjRXOzs6KrKysEmhV0SnMe8j777+v+Prrr4uxVaI00vX9t1RO4Hdzc6NOnTqqFYjz4+3trXWBOhcXF1xcXHjy5AmJiYmv1B6FQkFYWBgAU6ZMUZvv4OnpSatWrbh48aLa2PjVq1eJjY2lZs2aGk8vBgYGYmpqyubNm9UmPUZGRnLnzh169eql1jNnbGzMxx9/DDzba04IIUqzvn37MmjQIKZPn853333H2LFj6d27N48ePWLGjBk6Tz4vSyIiIl66dZN4e5XKYKyoKLcA0baqMjx7umflypUsXbqUzZs3a33SBp4FVjdu3MDBwUHrZD/lysbPB2PKr9u2basxWdXMzAxnZ2eysrJISkrSKKOt+75169aYmJhw/Phx1XwHIYQojXx9fXn06BE7d+5k1apVJCYm0q5dO0JDQ3We5yXE26RUTuAvCikpKfzvf//DxMSE1q1ba83z4lM4BgYGDBgwgGnTpql9crt8+TIAtWvX1lqPMl2ZD/5vm4X8ysTGxnLlyhXVE035lTE0NMTOzo6LFy9y/fr1PB8YyE9mZqbao9JGRkZvzSfUnJwcYmNjSU1NpXr16nh4eMjDEEIUkwkTJjBhwoSSbkaxedlCq+LtlZ2drbbjQGZmpk7lymQwlp2dzaRJk3j8+DGfffaZxlOLNWvWZMaMGXh4eGBjY0NGRgbHjh1j/vz5rF27lgcPHqg9BaIMYPJaTVmZ/nyg87IyyqeJnt/nS9fzaNsbTBeDBw9Wex0QEEBgYGCh6nqThIeHExgYSHJysirNzs6OoKAgjb3mhBBCiMJaunTpS7fw0qbMBWNPnz7l448/JjExke7du/Ovf/1LI49yPpmSiYkJPXr0oFmzZvTs2ZNt27YxduxYnJycdDqn4hUeSNVlXtyL5ylImeetXbtW7ZqK47H20iY8PBxvb2+N71FKSgre3t5s3LhRAjIhhBBFYty4cYwcOVL1+ty5cxodIdqUqTljT58+ZdKkSezatYsePXqwcOHCAgUutra2dOjQAYAjR46o0rX1fD1Pue3H8z1ar6tMQZiammJubq76V9aHKHNycggMDNQaLCvTJk6cqHWLFCGEEKKgjI2N1d5nTU1NdSpXZoKxJ0+eMGHCBHbu3Env3r1ZuHBhnhP386PcNPfRo0eqNOXifc/PCXvelStX1PLBsz3adCnz/Pyw/Mo8ffqU5ORkDA0NS82Kwa/b8ePHmTlzJtu3b39pb+SFCxf417/+pTY0+SKFQsH169cJDw9nzpw5rFix4qUPR6SlpfH9998THBysde89IYQQoqDKxDDl48ePGT9+PPv27aNfv37MmzdPp+02tFE+3fh8wGNvb4+trS2XL1/m+vXrGsFQdHQ0gNpq/66urgAcOnSI3NxctfY8ePCAxMREypcvT/PmzVXpbm5ubN26lZiYGHr37q12jiNHjvDo0SNat25d5nu0ALx6V+NRVq7qdcYDY/5Oq4CFeRbxh34gOJ8h+cxH5bj1tzlZWbrtizZxYgBVKptSvWo6G37Le2eGJ0/0Sb1lgb6+gurV0tm+9d8AWFTqyLp163Q6lxBCCPGiNz4Yy87O5qOPPuLgwYMMGDCA2bNnvzQQO3r0KK1atVJLUygU/Pzzz/z+++9YWVmpLS+hp6eHr68vCxYsYO7cuSxatEh1jqioKI4ePUq9evXU5qHZ29vj4eFBbGwsISEhDB8+XHUsKCiIzMxMBg8erNaF2a1bN+bNm8eOHTsYNmyYaq2x7Oxs1e4D2rZpKoseZeXy20rtW5DoKvZwBd4f8M9L8/20sDoe7pVemi8vfh8+enkmIYQQIg+lMhjbs2cPUVFRAPz999/AsyGqyZMnA1CpUiWmTp0KwLRp0zh48CBWVlZUq1aNxYsXa9Tn4uKi6qkCGDRoEHXq1KFJkyZUq1aNjIwMfv/9d/744w9MTEz4/vvvNeZljRw5kv379xMZGYmXlxfu7u7cuHGDyMhITExMmDNnjkYQOHPmTHx8fPj66685fPgwdevWJSkpifj4eOrUqcMnn3yilt/c3JzZs2czfvx4hgwZQq9evbC0tGTfvn2q7ZB03ddMgLtLRWyrG5N6Mxtto5p6emBb3Rh3l4qvvW1CCCGEUqkMxs6dO0d4eLha2rVr17h27RoANWrUUAVjyjlBd+7c0RqIwbMlHJ4PxkaPHs3JkyeJi4vj3r176OvrY2tri5+fHyNHjqRWrVoadRgbGxMSEsLSpUuJiIhg5cqVmJmZ4enpSWBgIPXq1dMoY29vz5YtW1QbhUdHR2Ntbc3w4cMJCAigYsWKGmW6dOlCWFgYP/74I7t27VJtFP7ll18yfPjwQj9J+TYyMNBjzsx6DB97Gj091AIy5W387t/1MDCQeyqEEKLklMqNwkXRehM3Cu/exfqVhymVInbe5vMZF7mR+n+T82vYGvPdv+vRu0fVV67f78MKREREvHI9QgghyhZd339LZc+YEEWpd4+q9OxqzeGEe9y6nU21qs+GJqVH7O2m98m2km5CvhT/KZvbBk2ePJnw8HCio6Oxs7Mr6eYIUSqUmaUthMiPgYEeHu6V8O5rg4d7JQnExFvh1KlTODo60r9/f63HIyIicHR0xNHRkRs3bmgcz8zMpH79+jRu3JgnT54Ud3MLxNfXF0dHx5JuhhBFQoKxt4i/vz9du3YlJCSkpJsihHgNGjZsiKWlJadOndK6mHRcXJxqHmpcXJzG8aNHj/LkyRNatmxJuXLliqRNkydPZs+ePVSrVq1I6hOiNAoJCaFr1674+/vrlF+CsbdIcHAwu3fvxs/Pr6SbIoR4DfT19XFxcSEnJ0dtVxGluLg42rRpg4WFhdZgTJnm7u6e73kmT56scy9V1apVcXR0LLLgTojSyM/Pj927dxMcHKxTfgnGhBCiDFMGUi8GW8nJyVy/fh13d3dat279SsFYQSgDN227YyQlJeHv74+Liwv169enTZs2fPnll9y6dUut3Y6OjiQkJACohlkdHR3V1mE8c+YMEyZMwMPDAycnJ5ydnenRowdff/11qRtyFUIm8AshRBmm3Bnk8OHDaunK166urhgZGbF3714uX76s2tbt/v37nD17lkqVKuHk5FTs7dy4cSNTp07F2NiYTp06YWNjw5UrV1i/fj379+9n06ZN2NraYmFhQUBAAJs2bSIlJYWAgABVHTVq1ADg7NmzeHt7o6+vT6dOnahZsyYPHjzg6tWrhIWF8cknn0jPnChVJBgTQogyrG7dulSrVo0LFy6Qlpam2n83Li4OMzMzGjVqhJGRkSpNGYzFx8eTm5uLq6trobeX09Xly5f56quvqFmzJmvXrqVq1f9bcubw4cMMHz6cmTNn8tNPP2FhYUFgYCAJCQmkpKQQGBioUd/mzZt5/PgxS5YsoUuXLmrH7t+/j4mJSbFejxAFJcOUQghRxrm6uqJQKIiPj1elxcfH06pVKwwMDKhfvz6VKlVSG6osjiHKvKxZs4YnT57w1VdfqQViyvN36tSJ/fv3a30IQRvlQwnagi5LS8tiDy6FKCjpGRNCiDLO3d2drVu3EhcXR8+ePfnzzz+5ffs2o0aNAp4FL61btyY+Ph6FQoGenp4qcFMOc8Kz+Vrt27fP8zzaJvHPnTsXb2/vfNt3/PhxABISEjh58qTG8bS0NHJzc7ly5QqNGzd+6fX26tWLVatWMW7cOLp37467uzvOzs7Y29u/tKwQJUGCMSGEKOOUvVvKeWLK/58PtFxcXNi9ezfnz5+nSpUqXLx4ERsbG9WwJaCar/WiqKgozp07p/VYgwYNXtq+u3fvAvDLL7/kmy8zM/OldQE0adKE3377jR9//JHIyEg2b94MPAsWAwICZI9fUepIMCaEEGWcra0ttWrV4urVq9y4cYO4uDgsLS3VJuYr9++Ni4ujSpUqgOYQpXK+1ouSk5M5d+6c1mO6MDc3B549Tan8+lW1aNGCZcuWkZ2dzenTp4mJieHXX39l4sSJWFlZvZbhVyF0JQPnQgjxFni+d+zIkSO0bt1abe7UO++8g5WVFXFxca91vhhA8+bNATh27JjOZZRtz8nJyTefsbExzs7OTJo0ienTp6NQKIiKiip8Y4UoBhKMvUVkBX4h3l7KIckVK1Zw7949VU+Ykp6eHq6urhw5coT//e9/amWKm5+fH+XKlWPWrFlcvnxZ4/jjx485evSoWlqlSpUASE1N1ch/9OhRrZP9//nnH+BZgCZEcSroCvwyTPkWCQ4OznfXeCFE2eXm5oaenh5//PGH6vWLXF1d2blzJw8ePMDR0REbG5vX0jZHR0fmzJnD559/Trdu3WjXrh116tThyZMn3Lhxg2PHjmFlZaXWo+Xm5sbOnTv56KOPaNeuHeXLl6dGjRr069ePZcuWcejQIVxcXKhVqxampqZcvHiR6OhoLCwsGDRo0Gu5LvH28vPzw8/Pj9OnT9OnT5+X5pdgTAjxVlL85/2SbsJrVblyZd59913Onz+PlZUV77zzjkae53vLXlevmFLfvn1xcnJi2bJlxMfHc+jQIUxMTKhatSrdunWjZ8+eavkHDhzIjRs32L59O7/88gtPnz7FxcWFfv36MXToUCwtLTlx4gSJiYnk5ORgY2PDkCFDGD16tGpxWCFKCwnGhBDiLbFjx458jzs6OvLXX38VuN758+czf/58nfJmZ2cDqBaafd67776rcz0GBgZ8+umnfPrppxrHPDw88PDw0KkeIUoDmTMmhBDitbl8+TJGRkZYWVmVdFOEKDWkZ0wIIUSxW758OUeOHOHs2bP07NkTQ0N5+xFCSX4bhBBCFLtff/2VJ0+e4OPjw9SpU0u6OUKUKhKMCSGEKHbR0dEl3QQhSi2ZMyaEEEIIUYIkGBNCCCGEKEESjAkhhBBClCCZM/YW8ff3p3z58gwdOhQ/P7+Sbo4QQghRJoWEhBAaGkpWVpZO+SUYe4vIdkhCCCFE8SvodkgyTCmEEEIIUYIkGBNCCCGEKEESjAkhhBBClCAJxoQQQgghSpAEY0II8ZyYmBhmzpxJTEzMS/MeP36cmTNnsn37dhQKRb55L1y4wKxZs1i3bh05OTn55k1JSSlQm0Xx8PX1xdHRsaSbId4ChQ7GcnJyePTokUZ6fHw833zzDfPmzePatWuv1DghhHidYmJiOHDgAB06dKBdu3b55j1+/DgRERE4OzvTs2dP9PT08sx74cIF1q9fT7169fD29sbAwCDPvCkpKYSEhBT6Gl4UHx+Po6Mjvr6+eeZJTk7G0dHxpddc2r3sOktKUFAQjo6OxMfHl3RTRClV6KUtvv32W8LCwjhy5Ajm5uYA7Nixg0mTJpGbmwvA+vXriYiIwNbWtmhaK4QQxaQ0BWJVq1Yt9HWIorNgwQKtnQ5CFLVC94zFx8fj6uqqCsQAFi1ahLm5OQsWLGDKlClkZGSwYsWKImmoEEIUl9IWiA0ZMqTQ1yKKjq2trQxTitei0MHYrVu3sLe3V72+du0af/31F8OGDaNv376MGTOG9u3b6zTvQrwe/v7+dO3atUiHQIR405XGQMzY2LjQ11NUnh9ai4yMpF+/fjRs2JAWLVowYcIEUlNTtZa7d+8eCxYsoFu3bjRs2JCmTZvSs2dP5s2bR2Zmpkbe+fPn06VLFxo0aEDTpk0ZOnQosbGxGvVu3LgRR0dHNm7cyIEDBxg0aBBNmzZVpSmDpoSEBBwdHVX/goKC1Or46KOPeO+991Tn8/HxITw8XOu1aJszphz2DQoK4uzZs4waNYpmzZrRsGFDBg0axLFjx9Tyt2vXjkWLFgEwZMgQtbYBBAQE4OjoyJEjR7S2ITIyEkdHR/79739rPS5Kp5CQELp27Yq/v79O+Qs9TPnw4UPMzMxUrxMTE9HT01P7Y1avXj0ZIy9FZAV+IdRJIPZya9asYe/evXTu3JnWrVtz4sQJdu7cyblz59ixY4dae69fv86QIUNISUmhUaNGDBkyhNzcXC5dusTKlSvx9fXF1NQUeHbdvr6+JCcn07p1a9q3b8/Dhw85cOAAI0aM4JtvvmHw4MEa7YmMjCQmJob33nuPwYMHk5ycTIMGDQgICGDRokXUqFGD/v37q/K7uLiovp4+fTp169alVatWVK1alTt37nDw4EEmT57MpUuX+PTTT3W+L6dOneLnn3+mefPmDBgwgNTUVHbt2oWfnx/btm2jbt26AIwYMYKoqCgSEhLw8vLCzs5OrZ6hQ4eyY8cO1q5dS+vWrTXOs3btWgCt90KUXgVdgb/QwZi1tTXJycmq14cPH6Z8+fJqb/YPHz7M94+QEEKUFAnEdBMTE8OWLVt49913VWkTJ05k27ZtREVF0atXL1X6xx9/TEpKCp9++ikffvihWj137tyhQoUKqteTJ08mJSWFxYsX06NHD1V6eno6vr6+fPPNN3Tu3Blra2u1eqKjo1m+fDnt27dXS2/QoAGLFi3Czs6OwMBArdcSGRmpNqIDkJ2dzYgRI/jll18YMmQI1atX1+m+HDhwgHnz5qkFfmFhYUybNo3Vq1fzzTffAM+CsfT0dBISEujfvz+urq5q9bRu3Zp33nmHXbt2MX36dCpVqqQ6dvXqVQ4fPkyLFi3U7r8oewo9TNm0aVP27dvHvn37+N///kdkZCRubm6UK1dOlef69etUq1atSBoqhBBFSQIx3QwfPlwjEBg4cCAAJ0+eVKWdOnWK33//nQYNGjB27FiNeqysrFTXeO7cORISEujevbtaIAZgYWFBYGAg2dnZ7Nq1S6OeTp06aQRiunoxEAMwNjZm2LBhPH36lLi4OJ3ratmypVogBuDj44OhoaHafdHFkCFDePz4scZw6W+//YZCoSiVT4iKolXonrEPP/yQffv2MW7cOAD09fX56KOPVMczMjJISEhQ+9QkhBClhQRiumncuLFGmrL3KD09XZWWlJQEgIeHB/r6+X/OP378uKr883O6lO7cuQPAX3/9pXGsWbNmOrVbmxs3bvDTTz9x+PBhbty4QVZWltrxW7du6VyXtvtSrlw5qlSponZfdNG3b1/mzZvHb7/9xqhRowB4/PgxmzZtomLFihoBqyh7Ch2MNWjQgE2bNrF582YAevXqRZMmTVTH//jjD9q2bcv7779f4LojIyNJSEjg3LlznD9/ngcPHtCnTx++//77PMskJiYSHBxMUlIS2dnZ2Nvb4+Pjw7Bhw/L8o7hp0yZCQ0P5888/0dfXp2HDhowePZqOHTtqzZ+VlcXSpUvZvn07KSkpmJmZ4erqSmBgoGp+wItSU1NZuHAhMTEx3Lt3D2trazw9PQkICMDS0rLIrkUIUTBvSyCmDIyUSw5pozymLYh6/ol5JUPDZ28dzy9eqwxAdBkNuXv3LgCHDh3i0KFDeeZ7ccI/oDFsqatr167h5eXF/fv3adWqFW3btsXc3BwDAwOSk5MJDw/n8ePHOten7b4AGBgYvHRR3xeZmZnRp08fwsLCSEhIwMXFhT179pCWlsbIkSNLdbAuikahgzEAJycnnJyctB5r2bIlLVu2LFS9wcHBnDt3jgoVKmBjY8ODBw/yzR8VFYW/vz/Gxsb07NkTS0tL9u/fz6xZs0hMTOSHH37QKPPtt9+yfPlybGxsGDhwIE+ePGH79u2MGTOGGTNmMGzYMLX82dnZDBs2jMTERBo3bswHH3xAamoqkZGRHDhwgNDQUI1PbFevXsXHx4e0tDQ6d+6Mo6MjJ06cYNWqVcTExLB+/Xq1+QGFvRYhRNEqK4EY/F/QcO/evTzzKIMjCwuLQp9HWVaX3iVlm6ZNm8YHH3xQ6HMWxIoVK7h79y5z587F29tb7VhERESeT1S+LkOHDiUsLIy1a9fi4uKimrg/aNCgEm2XeD0KPWdsyJAhL/3h3bJlS6HWy/nyyy/Zu3cvJ06c4Ouvv843b0ZGBlOnTsXAwIA1a9YwZ84cvvjiC7Zv307z5s2JjIxk27ZtamUSExNZvnw5tWrVYufOnXz11VfMnDmTrVu3UrFiRb777ju1hxPg2S9yYmIi3bt3Jzw8nClTprBw4UJ++OEHHj16xOeff67xyXPGjBmkpaUxffp0fvrpJz777DPWrFnDyJEjuXTpEv/5z39e+VqEEEWrNARiaWlpr3QNz3NwcMDIyIjLly+rgq4X/f777wCvNElc+WH00KFDL90aSpn3xWUgXpW+vn6evVJXrlwBoFu3bhrH8lpWoqgoexzz6zF79913admyJbt37yYxMVHVQybrnL0dCh2MJSQkvHT/tJSUlEL9kLu5uVGnTp18/wgqRUZGcufOHY1hUmNjYz7++GPg2aPZzwsLCwOerbv1/FChnZ0dQ4cO5fHjx2zYsEGVrlAoVGWmTJmi1pXv6elJq1atuHjxotoyHlevXiU2NpaaNWvi5+endv7AwEBMTU3ZvHkzDx8+fKVrEUIUndISiK1evfqVruN5xsbG9OjRg6dPnzJnzhyNQCk1NZVly5YB4OXlVejzNG7cmBYtWnDmzBl++eUXjeN3794lOzsbgCZNmtCqVSt2796t9rf2eX/88Qf//PNPgdpQsWLFPNc/Uy4p8eJyS8pRiuKkHAHJq21Kyon848ePR6FQyHIWb5FXGqZ8maysLNXcguKi/MXSNv+jdevWmJiYcPz4cbKzs1V/AJVltD2R0759e3744QeNwOrGjRs4ODhQs2ZNrWWOHj1KfHw87u7uaudo27atxjwMMzMznJ2diY2NJSkpiTZt2hT6WoQQRaM0BWJF/fv95ZdfcvLkSTZu3Mjx48dp06YNZmZm3Lhxg7179/LgwQNGjx6Nm5vbK53n+++/x9fXl7lz57Jz507VullXrlwhNjaWqKgoVVD03//+l6FDh/L555+zevVqmjZtioWFBTdv3uT8+fNcuHCBjRs3UqVKFZ3P7+7uzvbt2xk7diwNGjTAwMCA1q1b07p1a4YOHcqmTZuYMGEC3bp1o1q1aly4cIGYmBh69OjBjh07Xuna8+Pq6oq+vj4LFizgwoULqiHd8ePHq+Xr1q0bs2bN4vbt21hZWdG1a9dia5MoXYolUlIoFKSmphIdHY2NjU1xnELl0qVLANSuXVvjmKGhIXZ2dly8eJHr169Tt25dMjMzuXnzJhUqVNA6EVRZz+XLl1Vpyq+1nSOvMvm1S5keGxvLlStXVMFYQa+loDIzM8nIyFC9NjIykqBOiP+vefPmNG/eXKe877zzDl999ZVOeWvUqMHnn3+uU97KlSuresGLkpWVFZs3b2b16tXs2bOH8PBwsrKysLS0pFWrVgwePJhOnTq98nlq1qxJREQEP//8M1FRUYSEhGBsbIydnR2jRo2icuXKqrzVq1dn69at/Prrr+zatYuIiAhycnKwtrambt26DBs2rMDDptOmTUNPT4/Dhw+zf/9+cnNzCQgIoHXr1tSvX5/Q0FC+//57Dh48SE5ODvXr1+fHH3/EwsKiWIOxunXrMn/+fJYtW0ZoaKiqh/DFYMzIyIg+ffqwYsUKvL29MTIyKrY2ieKRnZ2t9iCItodQtClQMFa3bl21T4uLFi1SbfOgjUKh0Fj4r6gpg4u8nmxRpiuf9NE1//NBS3GUUe5e8Pwj0AW9loJ6scs7ICAgz8URhRBli5mZGf7+/jpvzxIYGJjn3wc7Ozuty07AsyG5KVOmMGXKFJ3a9NFHH6kti5QXb29vjYn3L6pSpQoLFy7M87izs3OeUz20XY9yesrzXF1d87x2IM8tAPv27Uvfvn3zLKd06tQp9PT0VGu5iTfL0qVL842L8lKgYOz5rRqOHj2Kra0tNWrU0MhnYGBAxYoVcXd3L/EfKOX8CF3mn73qOQqjIO161WtZu3at2tOv8qlLCCFKj+PHj3P06FHat2+f56iKKN3GjRvHyJEjVa/PnTun09y/AgVjz39KqFu3Lt7e3kyYMKEgVRQ5bb1Sz1Mui6HM97L82nqnCnqO11mmIExNTQtdVgghRPH49ddfuXnzJuHh4RgYGDBx4sSSbpIoJGNjY7XpP8q9WF+m0E9TRkdHv7b1YfLj4OAAqM/XUnr69CnJyckYGhqqJt6bmppiY2PDw4cPuX37tkYZ5ePPderUUaUpv9Z2jrzK5Neu58s8/+mnoNcihBDizbds2TKWLVuGubk5//3vf9Wephdvh0IHYzVq1CgVvSzKp3+0jdMfOXKER48e0aJFC7VIVblRq7Yy0dHRavXCs/3MbG1tuXz5MtevX9epjPIchw4d0lh/7MGDByQmJlK+fHm1CcOFuRYhhBBvtpiYGC5cuEBUVBQ9e/Ys6eaIElDoYAzgyZMn7Ny5U7U4qXLS5vP/dH2KqLC6deuGlZUVO3bsUNucNTs7W7V90oubrCpfBwcHc//+fVV6cnIyoaGhGBkZqU0U1dPTU5WZO3euWnAVFRXF0aNHqVevHi4uLqp0e3t7PDw8SE5OJiQkRO38QUFBZGZm0q9fP7UuzMJcixBCCCHebIVe2uLmzZsMGzaMy5cv5zuBXU9Pjzlz5hSo7j179hAVFQXA33//DTyb2Dh58mTg2dM6U6dOBZ7Nn5o9ezbjx49nyJAh9OrVC0tLS/bt28elS5fo3r27xmblzs7OjBo1iuXLl9OjRw+6d+/OkydP2LFjB/fu3WPGjBmqtXCURo4cyf79+4mMjMTLywt3d3du3LhBZGQkJiYmzJkzR2M9sZkzZ+Lj48PXX3/N4cOHqVu3LklJScTHx1OnTh0++eQTtfyFuRYhhBBCvNkKHYx9++23XLp0iffff5+BAwdSvXr1Ilvg9dy5cxpbLV27do1r164Bz4ZIlcEYQJcuXQgLC+PHH39k165dqs21v/zyS4YPH6716cOpU6fy7rvvEhISwm+//abaKHzMmDFaNwo3NjYmJCSEpUuXEhERwcqVKzEzM8PT05PAwEDq1aunUcbe3p4tW7aoNgqPjo7G2tqa4cOHExAQQMWKFTXKFOZahBBCCPHm0lMUcl0GZ2dn3n33Xa3rsIjS5fTp0/Tp04etW7fSqFGjkm6OTrp3sea3lW/GJFa/DysQERFR0s0QQghRyuj6/lvoOWPZ2dk0bdq0sMWFEEIIIQSvMEz5zjvvvHSjcFG6+Pv7U758eYYOHaqxebkQQgghikZISAihoaFkZWXplL/QPWNjxoxh3759XLx4sbBViNcsODiY3bt3SyAmRBF6+PAhenp66Onp8fDhw5JujhCiFPDz82P37t0EBwfrlL/QPWOVK1emY8eO+Pj4MGLECBo1apTnumPPb6MkhBBCCCH+T6GDMV9fX/T09FAoFCxevDjfp/yk90wIIYQQQrtCB2MTJkyQZRaEEEIIIV5RoYOxwMDAomyHEEKIYuDo6Kj22sjICDMzM6pXr07Dhg3p0aMHbdq00Vi0ujA2btzIlClTmDt3rtouJkKI/BXNKq3irZOTk0NsbCypqalUr14dDw8PDAwMSrpZQrx2OTk5qq9jYmLo0qVLqfxdCAgIAJ61Nz09nYsXL7JlyxbWr19P06ZN+f7776ldu3bJNlKIt9QrB2OPHz/m8OHDXLp0iYcPHzJhwgTg2TpkGRkZWFlZFcknLlF6hIeHExgYSHJysirNzs6OoKAgvLy8SrBlQrxe4eHhqiAHoEePHqX2d0HbaMY///zDzJkz2blzJ8OGDWPLli1YWVmVQOuEeLu9UpQUHR1N+/btGTNmDN9++y2LFi1SHTt79ixubm5s3779lRspSo/w8HC8vb3VAjGAlJQUvL29NbaxEqKsUv4uvLje4pv0u1ClShWCgoJwcXEhJSWFJUuWqB0/deoUX3/9NT179qRFixY4OTnRsWNHZs+ezb1799Ty+vr6MmXKFACmTJmCo6Oj6p/y78WtW7dYvHgxPj4+uLi4UL9+fdzc3AgMDOTChQuv5ZqFKI0KHYydPHmScePGoa+vz5dffknv3r3Vjjdv3hw7OzvVht/izZeTk0NgYKDWjeGVaRMnTlQbthGiLCpLvwv6+vr4+/sDsHXrVrVj69atY/v27Tg4OODt7Y2vry9VqlRhxYoV+Pj48ODBA1VeLy8vOnfuDEDnzp0JCAhQ/bOwsADgyJEjLF26FAsLC7p168YHH3xA06ZN2bVrF15eXpw9e/Y1XbUQpUuhhymDg4MxMTFhy5YtWFtbq/WKKTVp0oQzZ868UgNF6REbG6vRI/Y8hULB9evXiY2N5b333nt9DRPiNStrvwstW7bE0NCQtLQ0kpOTsbOzA+DDDz9k5syZGnPgwsLCmDZtGqGhoYwbNw5ANWF/7969eHp6ap3A7+bmRkJCAmZmZmrpp0+fZtCgQcybN49Vq1YVwxUKUboVOhhLTEzE09MTa2vrPPNUr16dgwcPFvYUooj179+P8sa5VK+ajl4+faJPnuiTessCfX0F1aulY2Dw7JP+jdRsnc4TOKE3ttWNNdIVuZB624LHTwyoXjUDY+OnedZhUl7mGYrSKzU1tUjzlTRjY2MsLS1JS0sjLS1NFYzVqFFDa/7Bgwczd+5cYmNjVcGYLqpUqaI1vVGjRri5uXHo0CGePHlCuXLlCn4RQpQiBd0OqdDB2MOHD6lUqVK+ebKyssjNzS3sKUQRW72kGk7vagZJuoo9fJf3Bxx/ab7Z0+vi4Z7/z4YQb7Lq1asXab7S6smTJ6xdu5bt27fz559/kpGRofY3/datWwWu88CBA4SFhXHq1Cnu3r3L06fqH8ru3r1L1apVX7ntQpQkPz8//Pz8OH36NH369Hlp/kIHYzY2Ni9dWf/s2bPUrFmzsKcQpYy7S0VsqxuTejMbLVNl0NMD2+rGuLtUfO1tE+J18vDwwM7OjpSUFK3zxvT09LCzs8PDw6MEWldw2dnZ3L9/H0DtacqAgAD27NlDrVq16Ny5M9bW1hgZGQGwcuVKHj9+XKDzrFq1im+++QZLS0vatGmDra0tJiYm6OnpERUVxblz5wpcpxBlQaGDsfbt2xMWFsbvv/9OixYtNI4fPHiQ33//vUBd2KJ0MzDQY87Megwfexo9PdQCMuVmDN/9ux4GBrIzgyjbDAwMCAoKwtvbW7UtnJJyZ5KFCxeWyvXGtDl27BhPnz6lSpUqqg/QJ0+eZM+ePbi7u7NixQq1ocPc3Fx+/vnnAp3j6dOnBAUFYW1tTUREhEbv1/HjL+91F6KsKvTEnHHjxmFhYcGwYcOYN2+eqpfswIEDzJ07lwkTJlC1alVGjhxZZI0VJa93j6qs/qkR1W3Uhzttqxuz+qdG9O4hwwvi7eDl5cXGjRuxtbVVS7ezs2Pjxo2lbp2xvOTm5hIcHAyg9lT81atXgWdPRr44h+vEiRNa58Iog09t01Pu3r1Leno6LVq00AjEHj58KA97ibfaKw1Trlq1igkTJqh9QvrXv/6FQqGgVq1aLFmyRBYQLIN696hKz67WHE64x63b2VSr+mxoUnrExNtGuZyDpaUlADt37iy1K/Bro1z0NSEhAVtbWz788EPVMeUk/oSEBIYPH65WZsaMGVrrq1ixIqD9wYXKlStjYmLCqVOnePjwIRUqVACezUv75ptvuHPnTlFdlhBvnFdagb9Ro0bs3buXAwcOcPz4ce7evYu5uTnNmzenc+fOGBrKbktllYGBnkzSFwLUAq927dqV2kAsKCgIeNZrpdwOKTExkcePH6u2Q3r+w3OTJk1wdnZm9+7deHt707JlS/755x+io6NxcHCgWrVqGudo0aIFJiYmrFy5krt376qenhw+fDjm5uYMHz6cpUuX0qNHDzp37syTJ0+Ij4/n3r17uLq6Eh8f/3puhhClzCtHSwYGBnTu3Fm12J8QQojSR7kWpJGRERUqVMDW1pa+ffvSrVs3PDw8NLatMzAw4Oeff+b777/n4MGDrF69GhsbGwYOHIi/vz9du3bVOIelpSXBwcEsXryYTZs2kZmZCUDfvn0xNzdn0qRJWFlZsX79etauXYu5uTlt27bl448/ZuHChcV+D4QorfQU2h4F0sGaNWvo1auXqntelF7KR2vX/FL9lZa2ENr5fViBiIiIkm6GKCEPHz5ULWL64MED1fCbEEIo33+3bt1Ko0aN8sxX6An8M2bMwM3NjQkTJnDgwAFZT0wIIYQQohAKPUw5ceJEtmzZQmRkJLt27cLKyoo+ffrg5eVF/fr1i7KNQghRalWoUEHrWmNCiLdXQVfgL3TP2Pjx49m7dy8bN25k0KBB5OTksGLFCt5//3169+7NqlWrSEtLK2z1QgghhBBvJD8/P3bv3q1aNuZlXnkDwGbNmvHNN99w+PBhFi9eTIcOHbhw4QKzZs2ibdu2jB079lVPIYQQQghRZhXZbsxGRkZ0796dn3/+mcOHDxMYGAjA/v37i+oUQgghhBBlTpEuBKZQKDh06BDh4eHs3buXJ0+eaDwuLYQQQggh/k+RBGN//vkn4eHhbN26ldu3b6NQKKhZsyZeXl7069evKE4hhBBCCFEmFToYu3fvHtu2bSM8PJzTp0+jUCioUKEC3t7eeHl50apVq6JspxBCCCFEmVToYMzNzY2nT5+ip6eHu7s7/fv3p0uXLpQvX74o2yeEEEIIUaYVOhizs7Ojf//+9O3bFxsbm6JskxBCCCHEW6PQwVhUVJTq64cPH3LlyhUyMzNleFIIIYQQogBe6VHH1NRUPvzwQ1q0aEHfvn0ZMmSI6tixY8fo2rUr8fHxr9xIIYQQQoiyqtA9Y7dv36Z///78888/dOrUibS0NI4fP6463rRpU9LS0tixYweurq5F0lghhBBCiNLutW2HtGjRItLS0vj1119ZsmQJbdu2VTterlw5WrZsSWJiYmFPIYQQQgjxxnlt2yEdPHiQTp065dvrZWtry+3btwt7CiGEEEKIMq/QwVhaWhq1a9fON4+hoSGZmZmFPYUQQgghRJlX6DljlpaW3Lx5M988V65cwdraurCn0NnGjRuZMmVKvnn09fW5ePEiAMnJybRv3z7PvD179mTRokVaj23atInQ0FD+/PNP9PX1adiwIaNHj6Zjx45a82dlZbF06VK2b99OSkoKZmZmuLq6EhgYSN26dbWWSU1NZeHChcTExHDv3j2sra3x9PQkICAAS0vLfK9TvPlycnKIjY0lNTWV6tWr4+HhgYGBQUk3SwghRDEpdDDm7OzMvn37+Oeff6hSpYrG8cuXLxMTE0OfPn1eqYG6aNCgAQEBAVqPHT16lLi4OK3Bl5OTE56enhrp77zzjta6vv32W5YvX46NjQ0DBw7kyZMnbN++nTFjxjBjxgyGDRumlj87O5thw4aRmJhI48aN+eCDD0hNTSUyMpIDBw4QGhpKs2bN1MpcvXoVHx8f0tLS6Ny5M46Ojpw4cYJVq1YRExPD+vXrqVSpko53RrxpwsPDCQwMJDk5WZVmZ2dHUFAQXl5eJdgyIYQQxaXQwdiYMWPYu3cvvr6+fPnllzx69AiAzMxMjhw5wuzZs9HT02PUqFFF1ti8NGjQgAYNGmg95u3tDcCgQYM0jjk5OREYGKjTORITE1m+fDm1atViy5Ytqh6qMWPG0KdPH7777js6duyInZ2dqsyKFStITEyke/fuLFq0SLVpes+ePRk3bhyff/45O3fuVNtMfcaMGaSlpTF9+nSGDx+uSp89ezYrVqzgP//5D7NmzdKpzeLNEh4ejre3NwqFQi09JSUFb29vNm7cKAGZEEKUQYWeM9asWTNmz57N9evXGT16NMuWLQOeLWkxZswYkpOTmTNnTp69TK/DH3/8wfHjx7GxsaFDhw6vVFdYWBgA/v7+akOFdnZ2DB06lMePH7NhwwZVukKhUJWZMmWKWsDl6elJq1atuHjxoto6bFevXiU2NpaaNWvi5+endv7AwEBMTU3ZvHkzDx8+fKVrEaVPTk4OgYGBGoEYoEqbOHEiOTk5r7tpQgghitkrLfrq7e3Nzp07GT58OE2bNqVWrVo0bNiQIUOGsGPHjtcyRJmftWvXAuDj46N1zs3t27cJCwvjxx9/JCwsjPPnz+dZlzJo0jbcqUx7MbC6ceMGDg4O1KxZU6cyyq/btm2rFrwBmJmZ4ezsTFZWFklJSXm2U5QeDx48IDg4mO+//560tLR88+7bt09taPJFCoWC69evExsbS05ODuvWrWPWrFlcuHAh33oVCgXbt29n5syZausACiGEKD0KPUypVKdOHb766quiaEuRysrKYuvWrejr6zNgwACteQ4dOsShQ4fU0lxcXFiwYAG2traqtMzMTG7evEmFChW0PpCgfKr08uXLqjTl13k9caqtzKVLl15aJjY2litXrtCmTRutecTrZ0gC3buo/1zk5OiResuC3Fw9qldLJ2rXd3mWV+TC2Qu6fS4KnNAbA8PKZD4yopp1Bv+LCco7swL+uWtKekZ5rCs/JP5/PwBgUakj69at0+l8QgghdJednc3jx49Vr3VdUeKVg7HSaseOHaSnp9OhQwe1wAqgfPnyjB8/Hk9PT2rVqgXA+fPnCQoKIj4+nqFDh7J9+3ZMTU0ByMjIAMDc3FzruZTpynzFVcbMzAyA9PT0vC5blICVSxq9ch2xh+/y/oCXr8k3e3pdPNxf7QEOvw8fvVJ5IYQQ2i1dujTP1Rjy80rDlKXZb7/9BsDgwYM1jlWpUoVJkybRqFEjLCwssLCwoHXr1qxevZpmzZpx9erVYu850DY3SFd6enpF2BJRGri7VMS2ujF5fWv19KCGrTHuLhVfa7uEEELobty4cSQlJan+KadLvUyZDMYuXrzI77//jo2NDe+9957O5QwNDVVDmkePHlWla+vFep62Hq2XlXnw4EGRlBFlg4GBHnNm1gPQCMiUr7/7dz0MDCQQF0KI0srY2Bhzc3PVP+UI28uUyWBMGYkOGDCgwItlVq5cGVAf5zU1NcXGxoaHDx9q3d7pypUrwLP5c0rKr5+fE/ayMg4ODjqVednOB+LN1LtHVVb/1IjqNsZq6bbVjVn9UyN696haQi0TQghRnMrcnLHs7Gy2bNmCvr4+Pj4+BS6vfFJROZdMydXVlS1bthATE6Nau0wpOjoaADc3N1Wavb09tra2XL58mevXr2s8UamtjHKfz0OHDpGbm6v2ROWDBw9ITEykfPnyNG/evMDXJd4MvXtUpWdXaw4n3OPW7WyqVX02NCk9YkIIUXaVuZ6xnTt3cv/+fd577z2NiftKSUlJak87KCUkJLBixQoAjWU5fH19AQgODub+/fuq9OTkZEJDQzEyMlIL0vT09FRl5s6dS25urupYVFQUR48epV69eri4uKjS7e3t8fDwIDk5mZCQELXzBwUFkZmZSb9+/XTu9hRvJgMDPTzcK+Hd1wYP90oSiAkhRBlX5nrGlBP3ta24rzRv3jwuXryIi4sLNjY2wLMFYg8fPgzApEmTcHZ2Vivj7OzMqFGjWL58OT169KB79+48efKEHTt2cO/ePWbMmKG2+j7AyJEj2b9/P5GRkXh5eeHu7s6NGzeIjIzExMSEOXPmaKwnNnPmTHx8fPj66685fPgwdevWJSkpifj4eOrUqcMnn3zyyvdICCGEEKVHmQrG/vzzT44dO/bSift9+/Zlz549nDx5kujoaJ4+fUrlypXp0aMHw4YNo1WrVlrLTZ06lXfffZeQkBB+++031UbhY8aM0bpRuLGxMSEhISxdupSIiAhWrlyJmZkZnp6eBAYGUq9ePY0y9vb2bNmyRbVReHR0NNbW1gwfPpyAgAAqVqxY2NsjhBBCiFJIT/EqayyIN8Lp06fp06cPa36pjtO7xi8vIMo0vw8rEBERUdLNEEKIMk/5/rt161YaNcp7TcoyN2dMCCGEEOJNUqaGKYUQQgghSlpISAihoaFkZWXplF96xoQQQgghipCfnx+7d+8mODhYp/wSjAkhhBBClCAJxoQQQgghSpAEY0IIIYQQJUiCMSGEEEKIEiTBmBBCCCFECZJgTAghhBCiBEkwJoQQQghRgiQYE0IIIYQoQRKMCSGEEEKUINkOSQghhBCiCMl2SEIIIYQQJUi2QxJCCCGEeINIMCaEEEIIUYIkGBNCCCGEKEESjAkhhBBClCAJxoQQQgghSpAEY0IIIYQQJUiCMSGEEEKIEiTBmBBCCCFECZIV+IUQQgghipCswC+EEEIIUYJkBX4hhBBCiDeIBGNCCCGEECVIgjEhhBBCiBIkwZgQQgghRAmSYEwIIYQQogRJMCaEEEIIUYIkGBNCCCGEKEESjAkhhBBClCAJxoQQQgghSpBshySEEEIIUYRkOyQhhBBCiBIk2yEJIYQQQrxBJBgTQgghhChBEowJIYQQQpSgMjOBv127dqSkpGg9VqVKFRISEjTSExMTCQ4OJikpiezsbOzt7fHx8WHYsGEYGBhorWvTpk2Ehoby559/oq+vT8OGDRk9ejQdO3bUmj8rK4ulS5eyfft2UlJSMDMzw9XVlcDAQOrWrau1TGpqKgsXLiQmJoZ79+5hbW2Np6cnAQEBWFpa6nhHhBBCCPEmKDPBGIC5uTkjRozQSDc1NdVIi4qKwt/fH2NjY3r27ImlpSX79+9n1qxZJCYm8sMPP2iU+fbbb1m+fDk2NjYMHDiQJ0+esH37dsaMGcOMGTMYNmyYWv7s7GyGDRtGYmIijRs35oMPPiA1NZXIyEgOHDhAaGgozZo1Uytz9epVfHx8SEtLo3Pnzjg6OnLixAlWrVpFTEwM69evp1KlSq92o4QQQghRapSpYMzCwoLAwMCX5svIyGDq1KkYGBiwZs0amjRpAsDHH3/MkCFDiIyMZNu2bbz//vuqMomJiSxfvpxatWqxZcsWVQ/VmDFj6NOnD9999x0dO3bEzs5OVWbFihUkJibSvXt3Fi1ahL7+s1Hhnj17Mm7cOD7//HN27typSgeYMWMGaWlpTJ8+neHDh6vSZ8+ezYoVK/jPf/7DrFmzXu1GCSGEEKLUeCvnjEVGRnLnzh169eqlCsQAjI2N+fjjjwFYs2aNWpmwsDAA/P391YYK7ezsGDp0KI8fP2bDhg2qdIVCoSozZcoUtYDL09OTVq1acfHiReLj41XpV69eJTY2lpo1a+Ln56d2/sDAQExNTdm8eTMPHz581VsgRJHJycnh4MGDrF27loMHD5KTk1PSTRJCiDdKmQrGHj9+zJYtW/jxxx9ZuXIlcXFxWt8YlAFQu3btNI61bt0aExMTjh8/TnZ2tkaZ9u3ba5RRpr0YWN24cQMHBwdq1qypUxnl123btlUL3gDMzMxwdnYmKyuLpKQk7TdAiNcsPDyc2rVr06FDB3x9fenQoQO1a9cmPDy8pJsmhBCvXXZ2NhkZGap/mZmZOpUrU8OUf//9N5988olaWs2aNZk7dy4uLi6qtEuXLgFQu3ZtjToMDQ2xs7Pj4sWLXL9+nbp165KZmcnNmzepUKEC1tbWGmWU9Vy+fFmVpvxa2znyKpNfu5TpsbGxXLlyhTZt2mjNI8TrEh4ejre3NwqFQi09JSUFb29vNm7ciJeXVwm1TgghXr+lS5eyaNGiApcrMz1j3t7ehISEkJCQwOnTp9m5cyeDBw8mOTmZkSNHcu7cOVXejIwM4NmEf22U6enp6QXKr8xXXGXMzMzU2iVEScnJySEwMFAjEANUaRMnTpQhSyHEW2XcuHEkJSWp/q1du1ancmUmGAsICMDd3Z0qVapgYmLCu+++y6xZsxg5ciRZWVkEBQXpXJfyzURPT6+4mqv1TUxXxdkuIXQRGxtLcnJynscVCgXXr18nNjb2NbZKCCFKlrGxMebm5qp/2lZz0KZMDVNq4+vry/Llyzl69KgqTVuv1PMePHiglu9l+bX1aBX0HIUtI0RBGZJA9y6aw+0FcSM1++WZgMAJvbGtbvxK57Ko1JF169a9Uh1CCFGalflgrHLlygBqk+gcHBw4deoUly9fpnHjxmr5nz59SnJyMoaGhqqJ96amptjY2HDz5k1u375N1apV1cpcuXIFgDp16qjSlF8/PyfsZWUcHBx0KpPXnDIhdLFySaNXriP28F3eH3D8pflmT6+Lh/urrYvn9+GjVyovhBClXZkZpszLiRMnAKhVq5Yqzc3NDYCYmBiN/EeOHOHRo0e0aNECY+P/+0Tv6uqaZ5no6Gi1egHs7e2xtbXl8uXLXL9+XacyynMcOnSI3NxctfwPHjwgMTGR8uXL07x58/wuWYhi5+5SEdvqxuQ1Yq6nBzVsjXF3qfha2yWEEG+iMhGMXbhwgXv37mmk37hxg3//+98A9OnTR5XerVs3rKys2LFjBydPnlSlZ2dn8/333wPPhjefp3wdHBzM/fv3VenJycmEhoZiZGSEt7e3Kl1PT09VZu7cuWrBVVRUFEePHqVevXpqT3na29vj4eFBcnIyISEhaucPCgoiMzOTfv366TwGLURxMTDQY87MegAaAZny9Xf/roeBgcxvFEKIlykTw5SRkZEsXboUV1dXatasSYUKFbh+/Tr79+8nOzub9957j9GjR6vym5ubM3v2bMaPH8+QIUPo1asXlpaW7Nu3j0uXLtG9e3d69eqldg5nZ2dGjRrF8uXL6dGjB927d+fJkyfs2LGDe/fuMWPGDLXV9wFGjhzJ/v37iYyMxMvLC3d3d27cuEFkZCQmJibMmTNHYz2xmTNn4uPjw9dff83hw4epW7cuSUlJxMfHU6dOHY2lO4QoKb17VGX1T434fMZFtTlkttWN+e7f9ejdo2o+pYUQQijpKV7lsb5SIiEhgbCwMM6ePcvff//No0ePsLCwwMnJib59+9KvXz+tTyAeO3aMH3/8UbXAq3Kj8OHDh+e7UXhISIjaRuFjxox56UbhERERpKamYmZmhouLC4GBgdSrV09rmRs3buS5UXjFihULfH9Onz5Nnz59WPNLdZzefbXJ1EK8KCdHweGEe9y6nU21qs+GJouyR8zvwwpEREQUWX1CCPG6KN9/t27dSqNGec/XLRPBmMifBGPiTSbBmBDiTaVrMFYm5owJIYQQQrypysScMSGEEEKI0iIkJITQ0FCysrJ0yi89Y0IIIYQQRcjPz4/du3cTHBysU34JxoQQQgghSpAEY0IIIYQQJUiCMSGEEEKIEiTBmBBCCCFECZJgTAghhBCiBEkwJoQQQghRgiQYE0IIIYQoQRKMCSGEEEKUIFmBXwghhBCiCMkK/EIIIYQQJUhW4BdCCCGEeINIMCaEEEIIUYIkGBNCCCGEKEESjAkhhBBClCAJxoQQQgghSpAEY0IIIYQQJUjWGRNCvDVycnKIjY0lNTWV6tWr4+HhgYGBQUk3SwjxlpNgTAjxVggPDycwMJDk5GRVmp2dHUFBQXh5eZVgy4QQbzsZphRClHnh4eF4e3urBWIAKSkpeHt7Ex4eXkItE0IICcaEEGVcTk4OgYGBKBQKjWPKtIkTJ5KTk/O6myaEKKNCQkLo2rUr/v7+OuWXYEwIUabFxsZq9Ig9T6FQcP36dWJjY19jq4QQZVlBt0OSOWNCiFLNkAS6d7EudPkbqdk65Quc0Bvb6saFPg+ARaWOrFu37pXqEEK8fSQYE0KUaiuXNHql8rGH7/L+gOMvzTd7el083Cu90rn8Pnz0SuWFEG8nGaYUQpRp7i4Vsa1ujJ6e9uN6elDD1hh3l4qvtV1CCKEkwZgQokwzMNBjzsx6ABoBmfL1d/+uh4FBHtGaEEIUMwnGhBBlXu8eVVn9UyOq26jPCbOtbszqnxrRu0fVEmqZEELInDEhxFuid4+q9OxqzeGEe9y6nU21qs+GJqVHTAhR0iQYE0K8NQwM9F55kr4QQhQ1GaYUQgghhChB0jMmhBBCCFGEQkJCCA0NJSsrS6f80jMmhBBCCFGECroCvwRjQgghhBAlSIIxIYQQQogSJMGYEEIIIUQJKhMT+O/evcuePXs4cOAAf/zxB7du3aJcuXK8++67eHt74+3tjb7+/8WdycnJtG/fPs/6evbsyaJFi7Qe27RpE6Ghofz555/o6+vTsGFDRo8eTceOHbXmz8rKYunSpWzfvp2UlBTMzMxwdXUlMDCQunXrai2TmprKwoULiYmJ4d69e1hbW+Pp6UlAQACWlpYFuDNCCCGEKO3KRDAWGRnJtGnTsLa2xs3NDVtbW/755x92797NF198wcGDBwkODkbvhb1QnJyc8PT01KjvnXfe0Xqeb7/9luXLl2NjY8PAgQN58uQJ27dvZ8yYMcyYMYNhw4ap5c/OzmbYsGEkJibSuHFjPvjgA1JTU4mMjOTAgQOEhobSrFkztTJXr17Fx8eHtLQ0OnfujKOjIydOnGDVqlXExMSwfv16KlWSdZKEeBvk5OQQGxtLamoq1atXx8PDAwMDg5JulhCiiJWJYKx27dosXbqUjh07qv2h+vTTT+nXrx+7d+9m165ddO/eXa2ck5MTgYGBOp0jMTGR5cuXU6tWLbZs2aLqoRozZgx9+vThu+++o2PHjtjZ2anKrFixgsTERLp3786iRYtUvXM9e/Zk3LhxfP755+zcuVOt127GjBmkpaUxffp0hg8frkqfPXs2K1as4D//+Q+zZs0q+E0SQrxRwsPDCQwMJDk5WZVmZ2dHUFAQXl5eJdgyIURRKxNzxtzd3fH09NT4xGhtbY2vry8ACQkJr3SOsLAwAPz9/dWGCu3s7Bg6dCiPHz9mw4YNqnSFQqEqM2XKFLWAy9PTk1atWnHx4kXi4+NV6VevXiU2NpaaNWvi5+endv7AwEBMTU3ZvHkzDx8+fKVrEUKUbuHh4Xh7e6sFYgApKSl4e3sTHh5eQi0TQhSHMhGM5adcuXIAGBpqdgLevn2bsLAwfvzxR8LCwjh//nye9SiDJm1zzZRpLwZWN27cwMHBgZo1a+pURvl127Zt1YI3ADMzM5ydncnKyiIpKSnPdgoh3mw5OTkEBgaiUCg0jinTJk6cSE5OzutumhCimJSJYcq8PH36VPUJsl27dhrHDx06xKFDh9TSXFxcWLBgAba2tqq0zMxMbt68SYUKFbC2ttaop3bt2gBcvnxZlab8WnlMlzKXLl16aZnY2FiuXLlCmzZttOYRQrzZYmNjNXrEnqdQKLh+/TqxsbG89957r69hQoiXys7O5vHjx6rXmZmZOpUr08HYvHnzuHDhAu3bt1cLxsqXL8/48ePx9PSkVq1aAJw/f56goCDi4+MZOnQo27dvx9TUFICMjAwAzM3NtZ5Hma7MV1xlzMzMAEhPT8/vsoUQJcSQBLp7WvPPXVPSM8pjXfkh5mbZ+Za5d9+EO/dMsKr4iIqWj7iRmn9+pcAJvbGtbpzn8cxH5bj1tzmmJo+pVuUB6GnmsajUkXXr1ul0PiHEyy1dujTP1RjyU2aDsZUrV7J8+XIcHBxYsGCB2rEqVaowadIktbTWrVuzevVqBg4cSFJSEuvWrWPEiBHF1j5tQxC6evGpUCFE6bBySaNXriP28F3eH3D8pflmT6+Lh/urPVnt9+GjVyovhFA3btw4Ro4cqXp97tw5Bg8e/NJyZXLO2MqVK5k1axZ169YlLCwMKysrncoZGhoyYMAAAI4ePapK19aL9TxtPVovK/PgwYMiKSOEKFvcXSpiW92YvD5z6elBDVtj3F0qvtZ2CSFeztjYGHNzc9U/5Qjby5S5YOyXX35h1qxZvPPOO6xZs0brHK/8VK5cGVAf5zU1NcXGxoaHDx9y+/ZtjTJXrlwBoE6dOqo05dfPzwl7WRkHBwedyuQ1p0wI8eYzMNBjzsx6ABoBmfL1d/+uh4GB9JALUVaUqWBsyZIlzJkzhwYNGrBmzRqqVKlS4DqUTyoq55Ipubq6AhATE6NRJjo6GgA3NzdVmr29Pba2tly+fJnr16/rVEZ5jkOHDpGbm6uW/8GDByQmJlK+fHmaN29e0MsSQrxBeveoyuqfGlHdRn1OmG11Y1b/1IjePaqWUMuEEMWhzARjixcvZsGCBTRq1IiQkJB8hyaTkpLUnnZQSkhIYMWKFQD06dNH7ZhyvbLg4GDu37+vSk9OTiY0NBQjIyO8vb1V6Xp6eqoyc+fOVQuuoqKiOHr0KPXq1cPFxUWVbv//2rvzuKjq/X/gr2GXRVABlUVwIBVSc8cNka5obpGGliZS+r03ixTNW920m9YlLVMTlbCHF5Ewt1zSXBJTlFEEV3DDFUVHCdxQEEVgzu8PfzPXcQBngOFw4PV8PHw8mvM5c+bFCWbe8zmf8/l4eMDf3x9KpRIJCQlarx8VFYWioiKMGDFC725PIpKu14c441Rqb/y+vjP+u9QXv6/vjJOHerMQI6qH6sUA/o0bN2LRokUwNTVF9+7dER8fr7OPq6urpliaN28eLl68CD8/P7Ro0QIAcP78eaSkpAAApk2bhq5du2o9v2vXrpg4cSJiY2MxZMgQDB48GCUlJdi+fTvy8/Mxa9Ysrdn3AWDChAnYu3cvdu7ciZEjR6J37964efMmdu7ciUaNGuHbb7/VmU/sq6++wqhRo/D1118jJSUF3t7eSE9PR2pqKlq3bo3p06fX2HkjorrN1FRW7UH6RFT31YtiTD0nT1lZGeLi4srdx8/PT1OMvfHGG0hMTMTJkyexf/9+lJaWolmzZhgyZAjGjx+P7t27l3uMGTNmoG3btkhISMDatWs1C4X//e9/L3ehcEtLSyQkJGDZsmXYunUr4uLiYGtri6CgIEREROCll17SeY6Hhwd+++03zULh+/fvh5OTE8LCwjBlyhQ4ODhU8SwRERFRXSQTqjPHAknC6dOnERwcjF+Wt4RP24rnJSKihiX0Axts3bpV7BhE9Zb683fLli1o377iqW/qRc8YERGJr6ysDAqFAjk5OWjZsiX8/f111gwmIl0sxoiIqNo2bdqEiIgIraWc3NzcEBUVhZEjR4qYjKj2JSQkYNWqVXj8+LFe+9ebuymJiEgcmzZtQkhIiM6amjdu3EBISIhmjWCihiI0NBS7du1CdHS0XvuzGCMioiorKytDREREuUu8qbdNnToVZWVltR2NSDJYjBERNVBPnjzBwoULER0drVlurSKFhYWIjo7GwoULcefOHc12hUKh0yP2LEEQcP36dSgUinLby8rKsG7dOkRGRuLChQtV+0GIJI5jxoiIGihrixPY/ccxAMC2LbP1ft7uP+Zq/vtmTrFez4mY/DpcWlZ+N/fB5KgK2xo3eRXr1q3TLyCRxLAYIyJqoOJiKr7VXl+KlHsYPvrEC/f75kvvak1gG/rBoyo/l6iu42VKIiKqst5+DnBpaamzqLmaTAa4uliit59DreYikhIWY0REVGWmpjJ8+9XT1USeL8jUj+fOfgmmphVUayIpKyvDvn37sGbNGuzbt483GJCoWIwREVG1vD7EGfE/tUfLFtpjwlxaWiL+p/Z1bnHzTZs2wdPTE4GBgRg7diwCAwPh6enJKThINBwzRkRE1fb6EGcMHeSElLR85OYVo7nz00uTda1HTD0n2vNTcajnRNuwYQMnqaVax2KMiIhqhKmprFqD9I3tRXOiyWQyTJ06FcHBwVzGiWoVizEiImoQDJkTrX///rUXjOodQ5dDYjFGRER1nhnSMHigU7WOUZNzor0I50Vr2EJDQxEaGorTp08jODj4hfuzGKM6aVRQER6XPBE7hl4cfZQ1Ml8TEVVMSnOiATU/L1pZWRkUCgVycnLQsmVL+Pv781JqPcJijOqkxyVP8MOoT8SOoZcvjk4WOwIR6UE9J1rOX8UoZ9gYZLKnd4DWtTnRNm3ahIiICK1LrG5uboiKiuLNBvUEp7YgIqIGQYpzoqnv/nx+rJv67k9Ox1E/sBgjIqIGQ0pzor3o7k8AmDp1KiesrQd4mbIBmfqPAljIpLG+m5W5hdgRiKieqo050S5fvozo6GiEhYXB1ta2wv0KCwsRHx+P4uJihIWFoVmzZpq26tz9WVZWhg0bNuDixYsYPXo02rRpU+2fSV8c32Y4FmMNyPQB4yFv6ip2DCIi0Rl7TrS2XrexbctsbNsyW+/n7P5jrtbjmrr782ByVKXPr8k7Pzm+rWpYjBEREdUwKd39WVN3fnJ1g6rjmDEiIqI6SH335/M3G6jJZICrS924+5Pj26qHxRgREVEdJKW7Pw0Z31bXlJWVYd++fVizZg327dtXIwVjQkICBg0ahPDwcL3252VKomoqU3pjeP98sWPojZPUEkmH+u7Pf826qDWGzKWlJebOfqlG7v6sbHWD/PuNcDe/EZo6PIKDfcWXMw0d31b0yBy5t+xg3egJmjsWApXUk8XFZsjJs4OFeRlaOj+AfbO6P8aNM/AT1bK5b0SIHcEgnKSWSFqMffenlMa3AfVzjBuLMaqTvlg9Bo8lMrTA3K6n5AoyIpIWY9/9WV1SW93gRWPcZDIZpk6diuDg4FqZloPFGNVJfygtAEtrsWPoxSLnmNgRiIhEpR7fFvb+achk0CrI6tr4NqB6c7gZA4uxBmTcz//GkyclYsfQj8wEmPSz2Cn0IkTxVm0iotoY3wZUPsZNXzU1h9uLPC42AVDxpL9qLMYakjHzAQd3sVOQyHjDAREZS22sbiClMW6Z54vxzt9zXrgfizGiBkZq49t4wwGRtNT18W1A3RvjxmKMqJpKZCboNi9U7Bh6s5SZ4OAn8WLHICISTV0b48ZijKi6pmwQO4FBVBIb4yaly6q8pEokHbU1xk0fLMaIqE6T0mVVXlIlkpbaGOOmDxZjRA0ML6sSEf1PXRjjxmKMqKHhZVWjkdIlVYCXVYnqChZjRFSnSaknT2q9eLysSlQ3sBgjorpNQj15UurFI6K6g8VYHZWTk4NFixYhOTkZ+fn5cHJyQlBQEKZMmQJ7e3ux4xFROaTUiwcAJiqVZC6r8pIq1Wcsxuqg7OxsjBo1Cnfu3MGAAQPg5eWFjIwMrFy5EsnJyVi/fj2aNNF/sGFJiUSWQCKSOgn14gGAadRI/DDqE7Fj6OXz36IkUzhKDQtd8bEYq4NmzZqFO3fu4Msvv0RYWJhm+zfffIMVK1ZgwYIFiIyM1Pt4LMaIqDxS68mTEimNH5RaoVsfi0eZIJS3EACJJTs7G6+++irc3d2xd+9emJiYaNoKCwvRq1cvqFQqHD58GDY2Nnod8/DhwxgzZgyU/afjCdemJCIyvsUhgKASO0W9ZKJSoY9XJ7Fj6OWJUIpbQiG2bNmC9u0rLiDZM1bHpKamAgD69u2rVYgBgK2tLbp27QqFQoH09HT06dNHjIhERPQiErtkLSWqxSFQXDkpdgy9WFiYw61lyxfux2KsjsnKygIAeHp6ltvu6ekJhUKBq1ev6l2MFRc/XebBvCC3RjISERGJZvwPYifQm3lBLnBsleZzuCIsxuqYgoICAICdnV257ba2tgCABw8e6H3MvLw8AEDzY6uqmY6IiIgMpVQq0bVr1wrbWYxJlEym/7pZgYGBmDdvHpydnWFpaanZbm5uDnNzc2PEIyIianBKSkq0bporLi5GXl4e/P39K30ei7E6Rt0jpu4he15hYaHWfvpo2rQp3nzzzeqHIyIiohpn8uJdqDbJ5XIAwJUrV8ptv3r1KoCKx5QRERGRtLAYq2N69uwJADhw4ABUKu3bogsLC3Hs2DFYWVmhc+fOYsQjIiKiGsZirI7x8PCAv78/lEolEhIStNqioqJQVFSEESNGwNraWqSEREREVJM46Wsd9PxySN7e3khPT0dqaipat26NX3/91aDlkIiIiKjuYjFWR928ebPChcIdHBzEjkdEREQ1hMUYERERkYg4ZoyIiIhIRCzGiIiIiETEYoyIiIhIRCzGiIiIiETEYoyIiIhIRCzGiIiIiETEYoyIiIhIRCzGiIiIiETEYoyIiIhIRCzGiIiIiERkJnYAMr67d+8iKSkJzs7OsLS01Gw3NzeHubm5iMmIiIjqj5KSEpSUlGgeFxcXIy8vD4GBgWjatGmFz2Mx1gAkJSXh008/FTsGERFRg7Rw4UIEBwdX2M5irAFwdnYGAHz55Zfw8fHRbK+JnrHp06djwYIF1TqGlI9bVFSECRMmYMWKFbC2tq6x4wLSOQfGPK6xzq+UzoGxjiu1312e26d4buv2uX2+Z+zKlSuYMWMG3NzcKn0ei7EGQH1p0sfHBz169Kjx47dv377GjymV4xYUFODRo0fw8fGBnZ1djR1XTQrnwJjHNeb5lco5MNZxpfi7y3P7FM+tdM6tumB8dohQeTiAn6pl3LhxPK6RSO0c8NxK77jGYoy8PLdP8dwaj5h5ZYIgCKK9up6WLFlS5edOnjy5BpNI0+HDhzFmzBisWbPGKD1jDVlBQQE6deqE9PR0o3xLa+h4fo2H59Z4eG6NR2rn9vTp0wgODsaWLVsq7XWTxGXKqKioKj1PJpOxGAM048J452TNs7CwwJQpU2BhYSF2lHqJ59d4eG6Nh+fWeOrruZVEz1haWlqVn+vn51eDSaRJ38qciIiIak696hljQVUzwsPDYWVlhXHjxiE0NFTsOERERPVSQkICVq1ahcePH+u1vySKMaoZ0dHR7BkjIiIystDQUISGhmp6xl5E0sVYZmYmtm7diqysLBQVFSEhIQEAoFQqkZGRgb59+8Le3l7klEREREQVk2wx9sMPPyAmJgYqlQrA08H6aiqVClOnTsUXX3yBsLAwsSISERERvZAk5xn7/fffER0djT59+mDbtm2YNGmSVnurVq3QoUMH7NmzR6SERERERPqRZDEWHx8PDw8P/PTTT2jXrl25t7h6eXnh6tWrtR+OiIiIyACSvEx54cIFjBw5stJ5Rpo3b47bt2/XYqq6j3dTEhERGV+DuJtSEASYmFTeqXf79u0XrgXV0PBuSiIiIuMz9G5KSV6m9PT0xIkTJypsLysrw9GjR/HSSy/VYioiIiIiw0myGBsyZAhOnz6NuLi4cttjYmKQnZ2N119/vZaTERERERlGkpcp33vvPezcuRNz5szBtm3bNNvnzJmDo0eP4tSpU+jUqRPefvttEVMSERERvZgke8asrKzwyy+/4I033sDp06eRkZEBQRCwYsUKzfXZuLg4mJlJstYkIiKiBkQSC4VXJj8/HydPnkR+fj7s7OzQsWNHNGvWTOxYdYq6QHVzc+PdlEREREb27N2USqXyhQuFS74YoxfTd9V4IiIiqjn6fv5K8jIlERERUX0hiUFVn332WZWeJ5PJ8O2339ZwGiIiIqKaI4libOPGjeVul8lkKO8qq3o7izEiIiKq6yRRjO3fv1/rsUqlQmRkJI4ePYqwsDD4+fnByckJt27dQmpqKn7++Wd0794dM2fOFCkxERERkX4kUYy5urpqPY6NjcXRo0exdetWrTa5XA4/Pz+MHDkSwcHB+PPPP/Hee+/VdlwiIiIivUlyAP+6deswZMgQnSJNzd3dHUOGDMHatWtrOVndFh4ejkGDBiEhIUHsKERERPVWQkICBg0ahPDwcL32l0TP2POUSiWCgoIq3adx48ZQKpVVOv7OnTuRlpaGzMxMnDt3DoWFhQgODsbChQv1Psa9e/eQmJiIpKQknD9/Hrm5uTA3N0fbtm0REhKCkJAQncXOlUolAgICKjzm0KFDsXjx4ir9TAAXCiciIqoNhi4ULslirEmTJlAoFPjkk0/KbRcEAQqFAg4ODlU6fnR0NDIzM2FjY4MWLVqgsLDQ4GPs3LkT//73v+Hk5IRevXrBxcUFt2/fxq5du/D5559j3759iI6Ohkwm03muj49PucVmmzZtqvTzEBERUd0lyWJsyJAhiIuLw+TJk/Hpp5/C3d1d03b9+nXMmzcP586dq/J4sZkzZ6JFixbw9PREWloa3nnnHYOP4enpiWXLluHVV1+FqampZvs///lPjBgxArt27cIff/yBwYMH6zzXx8cHERERVcpORERE0iLJYmzq1Kk4evQodu7cicTERDRv3hyOjo64ffs2cnNzUVZWho4dO1a5oOnVq1e1M/bu3bvc7U5OThg7diwWLFiAtLS0cosxIiIiajgkWYzZ2Nhg3bp1+O9//4sNGzbg2rVruHnzJgDAw8MDISEhmDhxIiwsLEROWj5zc3MAqHAh87y8PKxevRr5+flwcHBAly5d0K5du2q/blFREQoKCjSPLSwsYGlpWe3jEhEREVBcXIwnT55oHhcVFen1PEkWY8DTQuLDDz/Ehx9+iIcPH6KgoAB2dnawsbERO1qlSktLsWnTJgBAv379yt3nwIEDOHDggNY2Pz8/zJ8/Hy4uLlV+7TFjxmg9njJlCi+HEhER1ZBly5ZV6UY7yRZjz7KxsanzRZjavHnzcOHCBQQEBOgUY1ZWVvjoo48QFBSEVq1aAQDOnTuHqKgopKamYty4cdi2bRusra2r9Npr1qyBj4+P5nFd7TkkIiKSokmTJmHChAmax5mZmTodIeWRdDFWVFSExMREnDlzRtMz9vLLL2PgwIFVLliMKS4uDrGxsZDL5Zg/f75Ou6OjI6ZNm6a1rUePHoiPj8dbb72F9PR0rFu3rso3JlhbW8POzq5KzyUiIqLKWVpaag3/0bcWkWwxtmfPHnz22We4f/++1vqUMpkM33zzDb777ju8+uqrIibUFhcXh8jISHh7e2PVqlVo2rSp3s81MzPD6NGjkZ6ejiNHjnBVASIionpEksXYyZMn8dFHH6GsrAzDhw9H79694ezsjLy8PBw6dAjbtm1DeHg41q9fjw4dOogdF8uXL8e3336LNm3aICEhAY6OjgYfo1mzZgD0HwxIRERE0iDJYiwmJgYymQxr1qxB165dtdpCQkIQGhqKsWPHIiYmBj/++KNIKZ+KiYnB/Pnz4evri/j4eIN6xJ6Vnp4OAJqxZERERFQ/SHJtyqNHj2Lw4ME6hZhap06dMHjwYBw5csToWUpKSnD58mVkZ2frtC1ZsgTz589H+/btkZCQ8MJCLD09XeuWWLW0tDSsWLECAPRaVoGIiIikQ5I9Y4WFhWjZsmWl+7Rs2bJKyxgBQGJiInbv3g0AuHXrFgDgxIkTmuWXmjRpghkzZgAAcnNzMXDgQLi6uiI5OVlzjI0bN2LRokUwNTVF9+7dER8fr/M6rq6uCAkJ0TyeN28eLl68CD8/P7Ro0QIAcP78eaSkpAAApk2bVmEBqo/w8HBYWVlh3LhxCA0NrfJxiIiIqGIJCQlYtWoVHj9+rNf+kizGnJ2dcerUqUr3OX36NJydnat0/MzMTM1cYGrXrl3DtWvXADwtotTFWEXUi5SXlZUhLi6u3H38/Py0irE33ngDiYmJOHnyJPbv34/S0lI0a9YMQ4YMwfjx49G9e/cq/TxqXCiciIjI+BrEQuEBAQFYs2YNli9fjokTJ8LE5H9XW1UqFVasWIGDBw9i7NixVTp+RESE3pOhurm54fLly9U6htro0aMxevRog55DRERE0ibJYuyjjz7C7t27MW/ePPzyyy/o1q0bnJyccOvWLRw7dgxKpRJOTk4IDw8XOyoRERFRpSRZjDk7O2P9+vX44osvcPDgQc0lQbW+ffviP//5T5UvUxIRERHVFkkWYwDg7u6O+Ph4/PXXXzh79qxmBn5fX1/N4HciIiKiuk6yxZhaixYtWHzpiXdTEhERGV+DuJuSqoZ3UxIRERlfg7ibEgAePXqE9evXIzMzE3/99RdKSkp09pHJZFi1apUI6YiIiIj0I8li7Pz58xg/fjzu3r2rtUj482QyWS2mIiIiIjKcJIuxr7/+Gnfv3sXHH3+M4OBgNG/eHKampmLHIiIiIjKYJIux9PR0vPbaa/jggw/EjkJERERULZJcKNza2houLi5ixyAiIiKqNkn2jPXs2RMZGRlix5AcTm1BRERkfIZObSHJnrGPP/4YFy9exLJlyyodwE/aoqOjsWvXLhZiRERERhQaGopdu3YhOjpar/0l2TPWunVrrFu3DqNGjcK6devg4+MDOzs7nf1kMhm+/fZbERISERER6UeSxVhOTg4+/PBDFBQUoKCgANevXy93PxZjREREVNdJshiLjIxEVlYWRo0ahZEjR8LZ2RlmZpL8UYiIiKiBk2QFk5KSAn9/f8ydO1fsKERERETVIsliDADatm0rdgTJ4d2URERExtcgFgp/5ZVXcOHCBbFjaOzcuRNpaWnIzMzEuXPnUFhYiODgYCxcuNDgY+Xk5GDRokVITk5Gfn4+nJycEBQUhClTpsDe3r5aOblQOBGRNJWVlUGhUCAnJwctW7aEv79/nV15RkpZjaVBLBQ+ffp0vP322/j9998xfPhwseMgOjoamZmZsLGxQYsWLVBYWFil42RnZ2PUqFG4c+cOBgwYAC8vL2RkZGDlypVITk7G+vXr0aRJkxpOXzVS+2OTUl4pZQWklVdKWQHmNSYpZd20aRMiIiKgVCo129zc3BAVFYWRI0eKmEyXlLKq1YnfBUGCFi9eLEycOFHw9vYWxowZI3zzzTfC4sWLy/1XG1JSUoSsrCxBpVIJhw4dEuRyuTBt2jSDjxMWFibI5XJh5cqVWtsjIyMFuVwuzJw5s0r5Tp06JcjlcuHUqVNVev7zNm7cKLi5uQkANP/c3NyEjRs31sjxa5qU8kopqyBIK6+UsgoC8xqT1LLKZDKtrAAEmUwmyGSyOpVZSlnVjP27oO/nrySLMS8vL73+eXt713q2qhZjV69eFeRyuRAQECCUlZVptRUUFAjt27cXfH19hcLCQoMz1WQxJrU/NinllVJWQZBWXillFQTmNSYpZS0tLdUpFJ7P7O7uLpSWloodVVJZ1Wrjd6FeF2Opqal6/6ttVS3G1q5dW2nvl7rX7MCBAwZnqqliTGp/bFLKK6WsgiCtvFLKKgjMy6z/k5SUVGHWZ/8lJSXV6Ovu379fmD17trB///4X7nv8+HFh9uzZwpw5c/TKOmHCBGHt2rUvPMdKpVKYO3euEBsbKzx+/LjSfW/fvi0sWLBAWLp0qVBQUFDpvgUFBcLSpUuF77//XnBxcan0d8HNzU1Yvny5MHfuXEGpVFZ63NLSUmHt2rXCf/7zH+H8+fOa7fp+/kpyzJifn5/YEWpcVlYWAMDT07Pcdk9PTygUCly9ehV9+vSp0mucOHEC9+7d0zx2cnLCo0ePsHHjRjg6OsLf3x8ymUzT3qVLFwDA+fPn8fDhQ2zfvl1rHMDzBEHA9evXsWbNGgQGBiI+Ph7FxcUYPHgwLCwsNPt16NAB5ubmuHz5Mu7fv4/8/Hxs27YNFhYW+Mc//gG5XI579+7hypUrWsdv1KgR3N3dER8fj8uXL2PYsGFwcHDQtPv4+KBRo0bIzs7GnTt3kJqaqlfe+Ph4hIWFYcOGDVAoFPjb3/4GDw8PzX4vvfQS7OzscOPGDeTm5kIQBCgUCmRmZuL111/H0KFD8ejRI2RmZmodXyaToXPnzprxfp06ddKcU+DpShJNmjRBbm4utmzZolfW2NhYdOvWDa+88gouX76MmJgYNG/eHH/72980Yxzc3d3h5OSEu3fv4urVqwCAvLw8bN++HS1btsT06dNhaWmJ48eP67yOr68vHj58iIULF6KsrAzDhg2DtbU1AKBly5Zo2bIlHjx4gLVr1xqUt02bNjA3N8eSJUuQnZ2NoUOHwtnZGQDg6OiIVq1aoaioCOfOnQPwdAzHnj17cP36dURERKBNmzY4e/aszp1Jcrkc9vb2WLVqFQ4cOICAgAC0a9cOAODg4AC5XI69e/calBUAWrVqBUdHR+zdu1ezyof678PW1hZt2rSBSqVCenq65jjZ2dnYvXs3+vTpg7fffhvZ2dnIz8/Xei0XFxe0aNECZ8+eRUxMDJo2bar5+7CysoKvry8UCoXBeZ2dneHm5oa//voLixYtwpMnTzR/H2ZmZujYsSMA4MyZMyguLgYAPHnyBDt37oRMJsPf//53mJiYICcnR+u1mjRpgtatW+Phw4dYsmQJrl27hqCgIM3fR5cuXaqU187ODi+99BLKysoQFxeHI0eOoHv37pq/j+ffI9TOnTuHEydOICAgAL1799b8fqs1atQIPj4+AIDffvsNiYmJaNWqlebv49atWwZnBQBzc3N06NABAKBQKLB582ZYWFho/j6ef49QKyoqQlJSEmxsbDB69Gjk5eVpvZ76PQIAMjIysGnTJty9e1fz93Hp0qUKsz4rJSUFjRs31tr2yiuvwNTUFBcuXMCOHTuQmZmp+fso7z1C7ezZs7h8+TICAwNha2ur8z7h6+sLKysrXLlyBYcOHcL+/fvh4+ODhw8f6pXVxsYGbdq00Vlfuk2bNrC1tYVSqcTp06exfft2NG3aFL6+vsjNzdV5j1B78OABjh8/DktLS/j5+enc3CeXy+Hg4IC//voLly5dwrZt2/DkyRO4ubnh5s2bFeYUBAFKpRKHDx9GaGgocnNztf7fqt8jbt++jStXrmDPnj24du0aAgMDUVhYiIKCAqhUKpw4cUKv8yLJnrG6rKo9Y59//rkgl8uFtWvXltv+/fffC3K5XPjxxx8NzqSuzC0sLLQq/65duwqCIAgXL14s95uBWs+ePfX6xqP+16FDB0EQBOH+/fvltufl5QmCIAjDhw/XaVuwYIEgCIKwfv16nbbOnTtrMj3/swAQTp8+LQiCIEycONGgvE2aNNEc19XVtcJvnf/617902iZOnCgIgiCcPn1ap83CwkJz3M6dO+u0r1+/XhAEQViwYIFBeQEI9+/fFwRBEAYOHKjTtnTpUkEQBCEhIUGnrWfPnppM5R334sWLgiAIwjvvvKPTNmvWLEEQBOGPP/4wOG9KSoogCIIwbdo0nbYPP/xQEARBOHbsmE6bnZ2dJq+vr69O+5YtWwRBEMr9Vh4SEiIIgiAsWbLE4LzLly8XBEEQli9frtMWEBAgCIIgPH78uNznXr9+XRAEQQgJCdFpmzNnjiAIgrBlyxadNl9fX0EQBGH16tUG51W/36SkpOi0OTo6as6hl5eXTvuqVasEQRCEWbNm6bS98847QmlpqbBo0aJyX7eqeQcOHCgIgiDs2LGj3PbK3iMmTpwoqFSqSt8jzp8/L5iamuq0z5s3z+CsAARXV1dBEJ72wNjb2+u0V/Ye0aNHD+H27duVvkc8fvxYaNWqlU57ef9P9P13//59QaVSlfveU9l7hJubm6ZHrLzjqt8jBg8eXKVcf/75p+Do6KizXf0e8fe//12nrbL3CEtLS02PWGXvEVU9l0uXLhUCAgJ0tqvfI3766SedNisrK0EulwutW7cWLCws9OoZk/3/E041JDU1Fe+8847BU1vMmDED69atw5w5c/DWW2/ptM+fPx8xMTH45JNPMGnSJIMyqW+tnT17tlbPm5OTE9q1a4fHjx/j7NmzOs97vmfs6NGjeP/991/4egkJCRg3bhzKysp0vv0AFX/rBQBXV1c0b968wp4x9bfeEydO6CwS/3zPmL55Y2NjMWHCBADAqVOnUFJSotVe0bdeAGjWrBk8PDwq7RkDgMzMTDx69Eir/fmeMX2y/vTTT5qeMVNTU1y8eBEFBQVa+1T2rdfGxkYzR19FPWPqb73P9qICuj1jhuR99lvv870D5fWMqZmYmKBTp04AUGHPmPpb7/PfctU9Y7t378bAgQP1zgpof+u9du2a1n4V9YyptW/fHhYWFsjKyqqwZyw/P1/TG66m7hnbt28fAgMDDcqr7hkrLCzU6RmoqGdMzdvbG40bN0ZOTk6FPWOVvUdUJe+zPWO1+R5x69YtvPbaawZlBbR7xmrzPaJVq1bo3Lkzbty4ofOzqJ/v6uqKTZs26dz9V9vvEWVlZQgODsZff/1VYVY3NzdcuXIFZ86cQWlpqVZ7bb9H6Pv5kJSUBBcXF51ZEip6j3jy5AksLCzw0ksvQaVSYevWrZg9eza2bNlS+dRSlZZqZLCq9ozNmTNHkMvlmmr7ebNmzRLkcrnmW6whanrMWHkDHoG6N95CSnmllFUQpJVXSlkFgXmZVZt6kPnzmeviDQdSylpbvwv6fv6avLAspFohl8sBQOebnpr620tFY8pqg6mpKaKiogBAa2zZs48XLVpUZ+bqkVJeKWUFpJVXSlkB5jUmKWVVGzlyJDZs2ABXV1et7W5ubtiwYUOdmrtLSlnr3O9CtUo+0lHdqS369etX6dQWDx8+NDhTbcwz5u7uXqe+9TxLSnmllFUQpJVXSlkFgXmNSUpZ1UpLS4WkpCRh9erVQlJSUp3qvXuelLIa+3dB389fjhmrYS8aM1ZSUoJr167BzMxM6449AHj33XehUCjw5ZdfIiwsTLP9m2++wYoVKzBmzBhERkYanEk9ZuyF16wNUCdmLDaAlPJKKSsgrbxSygowrzFJKSsZlzF/F/T9/JVMMZaYmIh+/frByspK7Cg6EhMTsXv3bgBPB4gqFAq0atVKMwC0SZMmmDFjBgBAqVQiICAArq6uSE5O1jrO88sheXt7Iz09HampqWjdujV+/fXXKi2HpP5lcHNz40LhRERERvbsQuFKpbL+FGPe3t5o1KgR/P39MXDgQLz66qs686qIJSoqCosXL66w/dnCq7JiDABu3rxZ4ULhz86pZQhj9IwRERFR5epdz9iOHTuQmJiIffv2obCwEObm5ujRowcGDRqEAQMGaCaQJF0sxoiIiGqfvp+/kpmBf8iQIRgyZAhKSkpw8OBBJCYmYu/evTh48CBmz56Njh07YtCgQQgKChL1jkMiIiIiQ0imGFMzNzdH//790b9/fwiCgGPHjmHXrl34888/8d1332HevHnw9vbGa6+9hqCgIPj6+oodmYiIiKhCkp5nTCaToVu3bpg5cyaSkpLw+++/Izw8HDKZDEuWLEFwcDACAgIwZ84csaMSERERlUvSxdjzfHx8MHXqVOzYsQN79uzBJ598AicnJ6xcuVLsaERERETlkswA/uq4desWnJycxI4hGk5tQUREVHsMndpCcmPGqqIhF2LPio6O5t2URERERhYaGorQ0FBNZ8iL1KvLlERERERSw2KMiIiISEQsxoiIiIhExGKMiIiISEQNYgA/PRUeHs67KYmIiIzs2bsp9cFirAHh3ZRERETGZ+jdlJIuxnJzc3Ho0CHk5ubiyZMn5e4zefLkWk5FREREpD/JFmMLFizAf//7X5SWlmq2CYIAmUym9d8sxoiIiKguk+QA/s2bNyMmJgZdunTB0qVLIQgCRo4ciR9++AFvvfUWTExMMGzYMKxatUrsqERERESVkmTP2Jo1a9C8eXOsXLkS5ubmAAA3NzcMHz4cw4cPx8CBA/F///d/GD58uMhJiYiIiConyZ6x8+fPo3///ppCDADKyso0/92vXz/4+/tj+fLlYsQjIiIi0pske8ZKS0vRpEkTzWMrKysUFBRo7dOmTRusXr26yq+Rk5ODRYsWITk5Gfn5+XByckJQUBCmTJkCe3v7Fz5/w4YN+Oyzzyrdx8TEBBcvXtQ8ViqVCAgIqHD/oUOHYvHixfr/EM/h1BZERETG1yCmtnB2dsatW7c0j11cXHDu3DmtfXJzc2FmVrUfLzs7G6NGjcKdO3cwYMAAeHl5ISMjAytXrkRycjLWr1+vVQyWx9fXF1OmTCm37ciRIzh06FCFhZePjw+CgoJ0trdp08bwH+YZnNqCiIjI+BrE1Ba+vr44f/685nGvXr2wdu1abN68GYMGDUJqair++OMPdO3atUrHnzVrFu7cuYMvv/wSYWFhmu3ffPMNVqxYgQULFiAyMvKFGX19fcttCwkJAQC8/fbb5bb7+PggIiKiStmJiIhIWiQ5ZiwwMBAXL17E9evXAQDvv/8+7Ozs8Omnn+KVV17B+++/D0EQ8PHHHxt87OzsbCgUCri7u+tcyouIiIC1tTU2b96Mhw8fVin7+fPnceLECbRo0QKBgYFVOgYRERHVH5LsGQsJCdH0LgFPL1Nu3rwZsbGxyM7OhpubG8aNG4e2bdsafOzU1FQAQN++fWFiol2r2traomvXrlAoFEhPT0efPn0MPv6aNWsAAKNGjYKpqWm5++Tl5WH16tXIz8+Hg4MDunTpgnbt2hn8WkRERFT3SbIYK4+7uztmz55d7eNkZWUBADw9Pctt9/T0hEKhwNWrVw0uxh4/fowtW7bAxMQEo0ePrnC/AwcO4MCBA1rb/Pz8MH/+fLi4uBj0ms8qKirSutHBwsIClpaWVT4eERER/U9xcbHWikBFRUV6PU+SxdiSJUvg5+eHHj16VLjPkSNHkJqaavAM/Opixc7Ortx2W1tbAMCDBw8MOi4AbN++HQ8ePEBgYGC5RZWVlRU++ugjBAUFoVWrVgCAc+fOISoqCqmpqRg3bhy2bdsGa2trg18bAMaMGaP1eMqUKRybRkREVEOWLVtWpVkPJDlmLCoqCmlpaZXuc/jw4WpNA/Ei6mWXDLF27VoAukWRmqOjI6ZNm4b27dujcePGaNy4MXr06IH4+Hh06tQJ2dnZWLduXZUzr1mzBunp6Zp/kyZNqvKxiIiISNukSZO0PmfVQ5NeRJLFmD7Kysp0xnzpQ90j9vy8ZWqFhYVa++nr4sWLOH78OFq0aIH+/fsb9FwzMzPNZc0jR44Y9NxnWVtbw87OTvOPlyiJiIhqjqWlpdbnrL5XsuptMXbmzJkXzgVWHrlcDgC4cuVKue1Xr14FUPGYsoqoq+PRo0dXOHC/Ms2aNQOg//VnIiIikgbJjBl75513tB5v3LhRc+fjs1QqFXJycnDjxo0qrU3Zs2dPAE8H0atUKq3etcLCQhw7dgxWVlbo3Lmz3scsLi7Gb7/9BhMTE4waNcrgTACQnp4OAJqxZERERFQ/SKYYe3aMmEwmg1KphFKp1NnPxMQEDg4OGDp0KGbOnGnw63h4eMDf3x8KhQIJCQlak75GRUWhqKgIY8aM0XQ9lpSU4Nq1azAzM4OHh0e5x9yxYwfu37+PV199tdK7IdPT0+Hr6wsLCwut7WlpaVixYgUA6DWTLxEREUmHZIqxS5cuaf7b29sbERERBt8pqa+vvvoKo0aNwtdff42UlBR4e3sjPT0dqampaN26NaZPn67ZNzc3FwMHDoSrqyuSk5PLPZ564H5FM+6rzZs3DxcvXoSfnx9atGgB4OkksSkpKQCAadOmVXlVAYBrUxIREdWGBrE25XfffYeXX37ZaMf38PDAb7/9plkofP/+/XByckJYWBimTJkCBwcHvY916dIlHD16VK+B+2+88QYSExNx8uRJ7N+/H6WlpWjWrBmGDBmC8ePHo3v37tX6ubg2JRERkfEZujalTBAEoRZykYjUvwxbtmxhMUZERFRL9P38lWTP2LNycnKQm5urNePtsyqbGJaIiIhIbJItxvbv3485c+Zoli+qyMWLF2spEREREZHhJDnP2PHjx/GPf/wD9+/fx7hx4yAIArp374633noLXl5eEAQBr776qtEG+BMRERHVFEn2jP3000+wsLDApk2b4OLigoSEBPTq1QuTJ0+GIAiIiopCbGys1l2PRERERHWRZHvGBgwYoDVnl0qlAvB0DrKpU6fCy8sLUVFRYkWsk8LDwzFo0CAkJCSIHYWIiKjeSkhIwKBBgxAeHq7X/pLsGSssLISrq6vmsbm5uc4yQV27dsXWrVtrO1qdxqktiIiIjM/QqS0k2TPWtGlT3L9/X/O4WbNmuHbtmtY+paWlKC4uru1oRERERAaRZDHWunVrreKrc+fOOHjwoGZx77y8PPzxxx8GL+ZNREREVNskWYz169cPhw8fRn5+PgAgLCwMjx8/xvDhw/HGG29g4MCBuHv3Lt59911RcxIRERG9iCSLsTFjxmDNmjUwM3s65K1bt25YsmQJ3NzccOHCBTg7O+Prr7/GyJEjRU5KREREVDkuh9QAqAcQurm5caFwIiIiI3t2oXClUln/l0Mi/fFuSiIiIuNrEHdTEhEREdUXkugZ69+/f5WeJ5PJkJSUVLNhiIiIiGqQJIoxlUoFmUymta2kpAR5eXkAADMzMzg4OCA/Px+lpaUAAGdnZ5ibm9d6ViIiIiJDSKIYS05O1npcUFCA8ePHw8XFBZ988gm6d+8OExMTqFQqHD58GPPnz4dKpcLPP/8sUmIiIiIi/UhyzNiCBQvw4MEDrF69Gn5+fjAxefpjmJiYoGfPnvjll1+Qn5+PBQsWiJyUiIiIqHKS6Bl73u7duzFs2DBYWFiU225paYkBAwZg+/btmDVrVq3lysnJwaJFi5CcnIz8/Hw4OTkhKCgIU6ZMgb29vV7H6NevH27cuFFum6OjI9LS0qqcLzw8nFNbEBERGdmzU1voQ5LF2L179zRjwypSWlqKe/fu1VIiIDs7G6NGjcKdO3cwYMAAeHl5ISMjAytXrkRycjLWr1+PJk2a6HUsOzs7vPfeezrbra2tq5StpKQEALBo0SJ07ty5Sseg8hUXF2PZsmWYNGkSLC0txY5T7/D8Gg/PrfHw3BqPVM6toVNbQJCgQYMGCb179xYePHhQbnt+fr7Qq1cvYdCgQbWWKSwsTJDL5cLKlSu1tkdGRgpyuVyYOXOmXsfx9/cX/P39azRbWlqaIJfLhbS0tBo9LgnCgwcPBLlcXuHvIlUPz6/x8NwaD8+t8Ujt3J46dUqQy+XCqVOnKt1PkmPGxo4di9zcXIwYMQKbNm2CUqnUzHK7ceNGjBw5Erdu3cK4ceNqJU92djYUCgXc3d11Lv9FRETA2toamzdvxsOHD2slT21KSEjgcY1EaueA51Z6xzUWY+TluX2K59Z4xMwryWJs/PjxGD9+PK5evYrPPvsMgYGB6NChAwIDA/Gvf/0L2dnZCA0NrbViLDU1FQDQt29fzc0Eara2tujatSseP36M9PR0vY735MkT/Pbbb/jxxx8RFxeHQ4cOoaysrKZj14hVq1bxuEYitXPAcyu94xqLMfLy3D7Fc2s8YuaV5JgxAPjyyy8xbNgw/Prrrzh79iwKCgpgZ2eHl19+GW+++Sa6du1aa1mysrIAAJ6enuW2e3p6QqFQ4OrVq+jTp88Lj3fr1i1Mnz5da5u7uzu+++47+Pn5GZyvuLgYAJCZmam13dzcvEbmYjt9+nS1jyHV4xYVFaFRo0bIzMys8pi+ykjhHBjzuMY8v1I5B8Y6rhR/d3lun+K5rbvntqSkRDNOGwCuXLkC4H+fwxXhQuE1YMaMGVi3bh3mzJmDt956S6d9/vz5iImJwT//+U988MEHlR5r8eLF6NatG9q0aQMbGxtcu3YNCQkJWLt2LSwtLbFhwwb4+PgYlG/jxo349NNPDXoOERER1YyFCxdWOpBfsj1jUvT8KgLlmTJlitbjtm3bIjIyEtbW1oiNjUVUVBSWLVtm0OsGBgZi3rx5cHZ21rr7pKZ6xoiIiEi3Z6y4uBh5eXnw9/ev9HksxmqAnZ0dgKcrA5SnsLBQa7+qGDt2LGJjY3HkyBGDn9u0aVO8+eabVX5tIiIiMh5JDuCva+RyOYD/XRt+3tWrVwFUPKZMH82aNQPw9Ho5ERER1R8sxmpAz549AQAHDhyASqXSaissLMSxY8dgZWVVrQlXMzIyAACtWrWqelAiIiKqc1iM1QAPDw/4+/tDqVTqzFMSFRWFoqIijBgxQnPnR0lJCS5fvozs7GytfS9cuID8/Hyd49+8eROzZ88GAP1m8iUiIiLJ4N2UNeT55ZC8vb2Rnp6O1NRUtG7dGr/++qtmOSSlUomAgAC4uroiOTlZcwz14PyePXvC3d0dNjY2uH79Ovbu3Yvi4mL0798fMTExFa7JSURERNLDAfw1xMPDA7/99ptmofD9+/fDyckJYWFhmDJlChwcHF54jJ49eyIrKwtnz57FiRMn8OjRIzRu3BjdunXDG2+8gREjRuh1RyYRERFJB3vGiIiIiETEMWNEREREImIxRkRERCQiFmNEREREImIxRkRERCQi3k1Zj+Xk5Gju7szPz4eTkxOCgoIwZcoU2Nvbix1Pku7du4fExEQkJSXh/PnzyM3Nhbm5Odq2bYuQkBCEhITAxITfcWrS5s2b8c9//hMAMGfOHLz11lsiJ5K+I0eOIC4uDsePH8f9+/dhb2+Ptm3b4t1330VgYKDY8STrzz//RHx8PLKysnDv3j04Ozujffv2mDBhArp06SJ2vDpv586dSEtLQ2ZmJs6dO4fCwkIEBwdj4cKFFT7n2LFjiI6ORnp6OoqLi+Hh4YFRo0Zh/PjxMDU1rcX01cNirJ56ft4zLy8vZGRkYOXKlUhOTsb69es1856R/nbu3Il///vfcHJyQq9eveDi4oLbt29j165d+Pzzz7Fv3z5ER0dzCpIacvPmTXz11VewsbHBw4cPxY5TLyxduhQ//PADmjZtisDAQDg7O+Pu3bs4e/Ys0tLSWIxV0Zw5cxAbG4smTZogKCgITZo0QXZ2Nv7880/88ccfmDdvHkaOHCl2zDotOjoamZmZsLGxQYsWLTTrOldk9+7dCA8Ph6WlJYYOHQp7e3vs3bsXkZGROHbsGJYuXVpLyWuAQPVSWFiYIJfLhZUrV2ptj4yMFORyuTBz5kyRkknbwYMHhcTERKG0tFRre15entCnTx9BLpcLO3bsECld/aJSqYRx48YJ/fv3F+bMmSPI5XJh7dq1YseStG3btglyuVwIDQ0VCgoKdNqfPHkiQirpy8vLE7y9vYUePXoIt27d0mpLSUkR5HK50K9fP5HSSUdKSoqQlZUlqFQq4dChQ4JcLhemTZtW7r4PHjwQunXrJrRr107IyMjQbH/8+LHw5ptvCnK5XNi6dWttRa82Xk+ph7Kzs6FQKODu7o7Q0FCttoiICFhbW2Pz5s3saaiC3r17IygoSKf728nJCWPHjgUApKWliRGt3lm5ciUOHTqE7777TrOUGFWdSqXCvHnzYGVlhR9++AG2trY6+5ibm4uQTPpu3LgBlUqFTp06wdHRUautV69esLW1xb1790RKJx29evVC69at9bqysHPnTty9exfDhg1Dx44dNdstLS3x8ccfAwB++eUXo2WtaSzG6qHU1FQAQN++fXXGL9na2qJr1654/Pgx0tPTRUhXf6k/yMzMePW/ui5duoTvv/8e7777Lnr06CF2nHrh+PHjUCqVCAwMhL29PZKSkvDTTz9pxo5R1Xl6esLCwgLp6em4ffu2VtuhQ4dQWFiIPn36iJSuflJ/zvXr10+nrUePHmjUqBFOnDiB4uLi2o5WJfzUqIeysrIAPH2DKI+npycUCgWuXr3KN4gaUlpaik2bNgEo/82B9FdaWorp06fDxcVFM3Cfqu/kyZMAAEdHRwQHB+PcuXNa7T169MDSpUvRrFkzMeJJmoODA/71r38hMjISr732GoKCgtC0aVNkZ2djz5498Pf3x3/+8x+xY9YrlX3OmZmZwc3NDRcvXsT169fh7e1dy+kMx2KsHiooKAAA2NnZlduuvjzx4MGDWstU382bNw8XLlxAQEAAi7FqWrJkCc6ePYt169bByspK7Dj1xp07dwAAq1evhru7O1atWoWOHTvixo0bmDNnDhQKBSZPnozVq1eLnFSawsLC4Orqik8//RTr16/XbPfw8MDIkSN1Ll9S9bzoc069XSqfc7xM2YDxjr+aERcXh9jYWMjlcsyfP1/sOJKWkZGBmJgYTJw4kVMB1LCysjIAgCAI+PHHH9GrVy/Y2NigTZs2WLZsGVq0aIG0tDResqyimJgYfPDBB3jzzTeRlJSE06dPY8uWLWjVqhWmTZuGb7/9VuyIDYrw/5fdlsrnHIuxekj9jUD9zeF56tuFK/pGQfqLi4tDZGQkvL29sXr1ajRt2lTsSJKlvjzZunVrTJs2Tew49Y56bkF3d3e0bdtWq83KykrTo5uRkVHr2aQuJSUF8+fPx4ABAzBz5ky0atUKjRo1Qvv27RETE4MWLVogNjYW2dnZYketN+rb5xyLsXpILpcDAK5cuVJu+9WrVwFUPKaM9LN8+XJERkaiTZs2+OWXX+Dk5CR2JEkrKirClStXcOnSJfj6+sLLy0vzb/HixQCAGTNmwMvLi+NvqkD9vtC4ceNy29XbpTLguS7Zt28fAKBnz546bY0aNULHjh2hUqlw9uzZWk5Wf1X2OVdaWgqlUgkzMzO4u7vXdrQq4Zixekj9hnDgwAGoVCqtOyoLCwtx7NgxWFlZoXPnzmJFlLyYmBjMnz8fvr6+iI+PZ49YDbCwsMDo0aPLbTtz5gzOnDmDbt26QS6X83e3Crp37w4zMzNkZ2fjyZMnsLCw0Gq/cOECAMDV1VWMeJL25MkTAMDdu3fLbVdvf/6cU9X16tULW7ZsQXJyMl5//XWttsOHD+PRo0fo0aMHLC0tRUpoGPaM1UMeHh7w9/eHUqlEQkKCVltUVBSKioowYsQIzt1URUuWLMH8+fPRvn17JCQksBCrIVZWVpg7d265//72t78BAEaOHIm5c+di2LBhIqeVnqZNm2Lo0KF48OABYmJitNoOHDgAhUIBOzs7BAQEiJRQurp37w4AWLt2Lf766y+ttn379uHYsWOwtLTkOMga9Nprr6Fp06bYvn275k5h4GnPrnr5JPXcj1IgE9Sj3KheeX45JG9vb6SnpyM1NRWtW7fGr7/+yuWQqmDjxo349NNPYWpqivHjx5c7HsHV1RUhISEipKu/oqKisHjxYq5NWU23b9/G6NGjkZ2djR49eqBDhw64efMmEhMTIZPJ8MMPP2DIkCFix5QclUqFd999FwcPHoStrS2CgoLg5OSEy5cvY+/evRAEAV988QXee+89saPWaYmJidi9ezcA4NatW1AoFGjVqhW6desGAGjSpAlmzJihtf9HH30ES0tLDBs2DPb29tizZw+ysrIwePBgLFmyRDID+FmM1WM3b96scKFwBwcHseNJkrooqIyfnx+nB6hhLMZqTn5+PqKjo5GYmIjc3FzY2NigW7dumDRpEi//VkNJSQlWrVqFbdu24dKlS3j06BHs7e3xyiuvICwsDP7+/mJHrPNe9P7q6uqK5ORkrW1Hjx7Fjz/+qJngVb1QeFhYmKQWCmcxRkRERCQijhkjIiIiEhGLMSIiIiIRsRgjIiIiEhGLMSIiIiIRsRgjIiIiEhGLMSIiIiIRsRgjIiIiEhGLMSIiIiIRsRgjIiIiEhGLMSKiWqJUKuHl5YVPPvlEr/03bNgALy8vbNiwwcjJiEhMLMaIiIiIRGQmdgAiIirfoEGD0LlzZzg7O4sdhYiMiMUYEVEdZWdnBzs7O7FjEJGR8TIlEZEILl++jPfffx9dunRB+/btMXr0aCgUCq19Khoz1q9fP/Tr1w+PHj3C3Llz0bdvX/j4+CAwMBDLli2DIAi1+aMQUTWxGCMiqmVKpRIhISHIz8/HmDFjMHjwYJw+fRoTJkzAtm3b9DpGaWkpwsLCsGvXLgQEBGD06NEoLi7G999/j6ioKCP/BERUk3iZkoiolh0+fBj/93//h88//1yzLTQ0FKNGjcK///1vBAQEvPDyZG5uLtq1a4eff/4ZVlZWAIDJkydjwIABiIuLQ3h4OMzNzY36cxBRzWDPGBFRLbOzs8PkyZO1tnXs2BGvv/46Hjx4gMTERL2OM2vWLE0hBgCOjo4YMGAACgsLkZWVVaOZich4WIwREdWyl19+Gba2tjrb/fz8AABnz5594TEaN24MDw8Pne0tW7YEADx48KCaKYmotrAYIyKqZY6OjuVud3JyAgAUFBS88BgVXcY0M3s6+qSsrKyK6YiotrEYIyKqZbdv3y53+61btwBUXGgRUf3EYoyIqJadOXMGhYWFOtvT0tIAAL6+vrUdiYhExGKMiKiWFRQUYMmSJVrbTp48ia1bt8LOzg4DBw4UKRkRiYFTWxAR1bIePXpg/fr1yMjIQNeuXZGXl4ft27dDpVIhMjKSlymJGhj2jBER1TI3Nzds2LAB9vb2WL16NXbs2IGXX34ZsbGxGDZsmNjxiKiWyQSum0FEREQkGvaMEREREYmIxRgRERGRiFiMEREREYmIxRgRERGRiFiMEREREYmIxRgRERGRiFiMEREREYmIxRgRERGRiFiMEREREYmIxRgRERGRiFiMEREREYmIxRgRERGRiP4f+pSxPw2zBesAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 600x600 with 2 Axes>"
       ]
@@ -1131,14 +1090,6 @@
     "\n",
     "Our mailing list is analysis-grand-challenge@iris-hep.org, sign up via the [Google group](https://groups.google.com/a/iris-hep.org/g/analysis-grand-challenge)."
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "569a78bf-af91-46bb-ba3f-9b6fef52411d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -1160,7 +1111,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.15"
+   "version": "3.8.16"
   }
  },
  "nbformat": 4,
diff --git a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py
index 8cdcca74..eca4d3a9 100644
--- a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py
+++ b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py
@@ -6,7 +6,7 @@
 #       extension: .py
 #       format_name: percent
 #       format_version: '1.3'
-#       jupytext_version: 1.14.4
+#       jupytext_version: 1.14.1
 #   kernelspec:
 #     display_name: Python 3 (ipykernel)
 #     language: python
@@ -34,7 +34,7 @@
 # %% [markdown]
 # ### Data pipelines
 #
-# To be a bit more precise, we are going to be looking at three different data pipelines:
+# There are two possible pipelines: one with `ServiceX` enabled, and one using only `coffea` for processing.
 # ![processing pipelines](utils/processing_pipelines.png)
 
 # %% [markdown]
@@ -46,16 +46,15 @@
 import os
 import time
 
-import vector; vector.register_awkward()
-
 import awkward as ak
 import cabinetry
 from coffea import processor
-from coffea.processor import servicex
 from coffea.nanoevents import transforms
 from coffea.nanoevents.methods import base, vector
 from coffea.nanoevents.schemas.base import BaseSchema, zip_forms
+from servicex import ServiceXDataset
 from func_adl import ObjectStream
+from func_adl_servicex import ServiceXSourceUpROOT
 import hist
 import json
 import matplotlib.pyplot as plt
@@ -88,25 +87,6 @@
 # | `-1` | 2269 | 3.59 TB |
 #
 # The input files are all in the 1–2 GB range.
-#
-# Some files are also rucio-accessible (with ATLAS credentials):
-#
-# | dataset | number of files | total size |
-# | --- | --- | --- |
-# | `user.ivukotic:user.ivukotic.ttbar__nominal` | 7066 | 1.46 TB |
-# | `user.ivukotic:user.ivukotic.ttbar__scaledown` | 902 | 209 GB |
-# | `user.ivukotic:user.ivukotic.ttbar__scaleup` | 917 | 191 GB |
-# | `user.ivukotic:user.ivukotic.ttbar__ME_var` | 438 | 103 GB |
-# | `user.ivukotic:user.ivukotic.ttbar__PS_var` | 443 | 100 GB |
-# | `user.ivukotic:user.ivukotic.single_top_s_chan__nominal` | 114 | 11 GB |
-# | `user.ivukotic:user.ivukotic.single_top_t_chan__nominal` | 2506 | 392 GB |
-# | `user.ivukotic:user.ivukotic.single_top_tW__nominal` | 50 | 9 GB |
-# | `user.ivukotic:user.ivukotic.wjets__nominal` | 10199 | 1.13 TB |
-# | total | 22635 | 3.61 TB |
-#
-# The difference in total file size is presumably due to the different storages, which report slightly different sizes.
-#
-# When setting the `PIPELINE` variable below to `"servicex_databinder"`, the `N_FILES_MAX_PER_SAMPLE` variable is ignored and all files are processed.
 
 # %%
 ### GLOBAL CONFIGURATION
@@ -114,21 +94,19 @@
 # input files per process, set to e.g. 10 (smaller number = faster)
 N_FILES_MAX_PER_SAMPLE = 5
 
-# pipeline to use:
-# - "coffea" for pure coffea setup
-# - "servicex_processor" for coffea with ServiceX processor
-# - "servicex_databinder" for downloading query output and subsequent standalone coffea
-PIPELINE = "coffea"
-
-# enable Dask (may not work yet in combination with ServiceX outside of coffea-casa)
+# enable Dask
 USE_DASK = True
 
-# ServiceX behavior: ignore cache with repeated queries
+# enable ServiceX
+USE_SERVICEX = False
+
+# ServiceX: ignore cache with repeated queries
 SERVICEX_IGNORE_CACHE = False
 
 # analysis facility: set to "coffea_casa" for coffea-casa environments, "EAF" for FNAL, "local" for local setups
 AF = "coffea_casa"
 
+
 ### BENCHMARKING-SPECIFIC SETTINGS
 
 # chunk size to use
@@ -149,6 +127,7 @@
 # acceptable values are 4, 15, 25, 50 (corresponding to % of file read), 4% corresponds to the standard branches used in the notebook
 IO_FILE_PERCENT = 4
 
+
 # %% [markdown]
 # ### Defining our `coffea` Processor
 #
@@ -159,8 +138,6 @@
 # - filling all the information into histograms that get aggregated and ultimately returned to us by `coffea`.
 
 # %% tags=[]
-processor_base = processor.ProcessorABC if (PIPELINE != "servicex_processor") else servicex.Analysis
-
 # functions creating systematic variations
 def flat_variation(ones):
     # 2.5% weight variations
@@ -180,7 +157,7 @@ def jet_pt_resolution(pt):
     return ak.unflatten(resolution_variation, counts)
 
 
-class TtbarAnalysis(processor_base):
+class TtbarAnalysis(processor.ProcessorABC):
     def __init__(self, disable_processing, io_file_percent):
         num_bins = 25
         bin_low = 50
@@ -412,7 +389,7 @@ def behavior(self):
 #
 # Define the func_adl query to be used for the purpose of extracting columns and filtering.
 
-# %% tags=[]
+# %%
 def get_query(source: ObjectStream) -> ObjectStream:
     """Query for event / column selection: >=4j >=1b, ==1 lep with pT>25 GeV, return relevant columns
     """
@@ -448,121 +425,101 @@ def get_query(source: ObjectStream) -> ObjectStream:
 
 
 # %% [markdown]
-# ### Standalone ServiceX for subsequent `coffea` processing
+# ### Caching the queried datasets with `ServiceX`
 #
-# Using `servicex-databinder`, we can execute a query and download the output.
-# As the files are currently accessible through `rucio` only with ATLAS credentials, you need to use an ATLAS ServiceX instance to run this (for example via the UChicago coffea-casa analysis facility).
+# Using the queries created with `func_adl`, we are using `ServiceX` to read the CMS Open Data files to build cached files with only the specific event information as dictated by the query.
+
+# %%
+if USE_SERVICEX:
+    
+    # dummy dataset on which to generate the query
+    dummy_ds = ServiceXSourceUpROOT("cernopendata://dummy", "events", backend_name="uproot")
+
+    # tell low-level infrastructure not to contact ServiceX yet, only to
+    # return the qastle string it would have sent
+    dummy_ds.return_qastle = True
+
+    # create the query
+    query = get_query(dummy_ds).value()
+
+    # now we query the files and create a fileset dictionary containing the
+    # URLs pointing to the queried files
 
-# %% tags=[]
-if PIPELINE == "servicex_databinder":
-    from servicex_databinder import DataBinder
     t0 = time.time()
+    for process in fileset.keys():
+        ds = ServiceXDataset(fileset[process]['files'], 
+                             backend_name="uproot", 
+                             ignore_cache=SERVICEX_IGNORE_CACHE)
+        files = ds.get_data_rootfiles_uri(query, 
+                                          as_signed_url=True,
+                                          title=process)
 
-    import inspect
- 
-    query_string = inspect.getsource(get_query).split("return source.")[-1]  # extract query from function defined previously
-    
-    sample_names = ["ttbar__nominal", "ttbar__scaledown", "ttbar__scaleup", "ttbar__ME_var", "ttbar__PS_var",
-                    "single_top_s_chan__nominal", "single_top_t_chan__nominal", "single_top_tW__nominal", "wjets__nominal"]
-    sample_names = ["single_top_s_chan__nominal"]  # for quick tests: small dataset with only 50 files
-    sample_list = []
-
-    for sample_name in sample_names:
-        sample_list.append({"Name": sample_name, "RucioDID": f"user.ivukotic:user.ivukotic.{sample_name}", "Tree": "events", "FuncADL": query_string})
-
-
-    databinder_config = {
-                            "General": {
-                                           "ServiceXBackendName": "uproot",
-                                            "OutputDirectory": "outputs_databinder",
-                                            "OutputFormat": "root",
-                                            "IgnoreServiceXCache": SERVICEX_IGNORE_CACHE
-                            },
-                            "Sample": sample_list
-                        }
-
-    sx_db = DataBinder(databinder_config)
-    # out = sx_db.deliver(timer=True)
-    parquet_paths = sx_db._sx.get_servicex_data()  # only run transform, do not download as well
-    print(f"execution took {time.time() - t0:.2f} seconds")
-    
-    # point to ROOT files from databinder
-    # update list of fileset files, pointing to ServiceX output for subsequent processing
-    # for process in fileset.keys():
-    #     if out.get(process):
-    #         fileset[process]["files"] = out[process]
-    
-    # point directly to parquet files from databinder
-    # update paths to point to ServiceX outputs
-    for sample_name, sample_paths in zip([sample['Name'] for sample in databinder_config['Sample']], parquet_paths):
-        print(f"updating paths for {sample_name} with {len(sample_paths)} parquet files (e.g. {sample_paths[0]}")
-        fileset[sample_name]["files"] = sample_paths
+        
+        fileset[process]["files"] = [f.url for f in files]
+
+    print(f"ServiceX data delivery took {time.time() - t0:.2f} seconds")
 
 # %% [markdown]
 # ### Execute the data delivery pipeline
 #
-# What happens here depends on the configuration setting for `PIPELINE`:
-# - when set to `servicex_processor`, ServiceX will feed columns to `coffea` processors, which will asynchronously process them and accumulate the output histograms,
-# - when set to `coffea`, processing will happen with pure `coffea`,
-# - if `PIPELINE` was set to `servicex_databinder`, the input data has already been pre-processed and will be processed further with `coffea`.
+# What happens here depends on the flag `USE_SERVICEX`. If set to true, the processor is run on the data previously gathered by ServiceX, then will gather output histograms.
+#
+# When `USE_SERVICEX` is false, the input files need to be processed during this step as well.
 
 # %%
-if PIPELINE == "coffea":
-    if USE_DASK:
-        executor = processor.DaskExecutor(client=utils.get_client(AF))
-    else:
-        executor = processor.FuturesExecutor(workers=NUM_CORES)
-
-    run = processor.Runner(executor=executor, schema=AGCSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)
-
-    filemeta = run.preprocess(fileset, treename="events")  # pre-processing
-
-    t0 = time.monotonic()
-    all_histograms, metrics = run(fileset, "events", processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT))  # processing
-    exec_time = time.monotonic() - t0
-    all_histograms = all_histograms["hist"]
-
-elif PIPELINE == "servicex_processor":
-    # in a notebook:
-    t0 = time.monotonic()
-    all_histograms = await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT),
-                                                        use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE, schema=AGCSchema)
-    exec_time = time.monotonic() - t0
-
-    # as a script:
-    # async def produce_all_the_histograms():
-    #     return await utils.produce_all_histograms(fileset, get_query, TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT),
-    #                                               use_dask=USE_DASK, ignore_cache=SERVICEX_IGNORE_CACHE, schema=AGCSchema)
-    #
-    # all_histograms = asyncio.run(produce_all_the_histograms())
-
-elif PIPELINE == "servicex_databinder":
-    # needs a slightly different schema, not currently implemented
-    raise NotImplementedError("further processing of this method is not currently implemented")
+if USE_DASK:
+    executor = processor.DaskExecutor(client=utils.get_client(AF))
+else:
+    executor = processor.FuturesExecutor(workers=NUM_CORES)
+        
+run = processor.Runner(executor=executor, schema=AGCSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)
+
+if USE_SERVICEX:
+    treename = "servicex"
+    
+else:
+    treename = "events"
+    
+filemeta = run.preprocess(fileset, treename=treename)  # pre-processing
+
+t0 = time.monotonic()
+all_histograms, metrics = run(fileset, treename, processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT))  # processing
+exec_time = time.monotonic() - t0
+
+all_histograms = all_histograms["hist"]
 
 print(f"\nexecution took {exec_time:.2f} seconds")
 
 # %%
-# track metrics for pure coffea setups
-if PIPELINE == "coffea":
-    # update metrics
-    dataset_source = "/data" if fileset["ttbar__nominal"]["files"][0].startswith("/data") else "https://xrootd-local.unl.edu:1094" # TODO: xcache support
-    metrics.update({"walltime": exec_time, "num_workers": NUM_CORES, "af": AF_NAME, "dataset_source": dataset_source, "use_dask": USE_DASK,
-                    "systematics": SYSTEMATICS, "n_files_max_per_sample": N_FILES_MAX_PER_SAMPLE, "pipeline": PIPELINE,
-                    "cores_per_worker": CORES_PER_WORKER, "chunksize": CHUNKSIZE, "disable_processing": DISABLE_PROCESSING, "io_file_percent": IO_FILE_PERCENT})
-
-    # save metrics to disk
-    if not os.path.exists("metrics"):
-        os.makedirs("metrics")
-    timestamp = time.strftime('%Y%m%d-%H%M%S')
-    metric_file_name = f"metrics/{AF_NAME}-{timestamp}.json"
-    with open(metric_file_name, "w") as f:
-        f.write(json.dumps(metrics))
-
-    print(f"metrics saved as {metric_file_name}")
-    #print(f"event rate per worker (full execution time divided by NUM_CORES={NUM_CORES}): {metrics['entries'] / NUM_CORES / exec_time / 1_000:.2f} kHz")
-    print(f"event rate per worker (pure processtime): {metrics['entries'] / metrics['processtime'] / 1_000:.2f} kHz")
-    print(f"amount of data read: {metrics['bytesread']/1000**2:.2f} MB")  # likely buggy: https://github.com/CoffeaTeam/coffea/issues/717
+# track metrics
+dataset_source = "/data" if fileset["ttbar__nominal"]["files"][0].startswith("/data") else "https://xrootd-local.unl.edu:1094" # TODO: xcache support
+metrics.update({
+    "walltime": exec_time, 
+    "num_workers": NUM_CORES, 
+    "af": AF_NAME, 
+    "dataset_source": dataset_source, 
+    "use_dask": USE_DASK, 
+    "use_servicex": USE_SERVICEX, 
+    "systematics": SYSTEMATICS, 
+    "n_files_max_per_sample": N_FILES_MAX_PER_SAMPLE,
+    "cores_per_worker": CORES_PER_WORKER, 
+    "chunksize": CHUNKSIZE, 
+    "disable_processing": DISABLE_PROCESSING, 
+    "io_file_percent": IO_FILE_PERCENT
+})
+
+# save metrics to disk
+if not os.path.exists("metrics"):
+    os.makedirs("metrics")
+timestamp = time.strftime('%Y%m%d-%H%M%S')
+metric_file_name = f"metrics/{AF_NAME}-{timestamp}.json"
+with open(metric_file_name, "w") as f:
+    f.write(json.dumps(metrics))
+
+print(f"metrics saved as {metric_file_name}")
+#print(f"event rate per worker (full execution time divided by NUM_CORES={NUM_CORES}): {metrics['entries'] / NUM_CORES / exec_time / 1_000:.2f} kHz")
+print(f"event rate per worker (pure processtime): {metrics['entries'] / metrics['processtime'] / 1_000:.2f} kHz")
+print(f"amount of data read: {metrics['bytesread']/1000**2:.2f} MB")  # likely buggy: https://github.com/CoffeaTeam/coffea/issues/717
 
 # %% [markdown]
 # ### Inspecting the produced histograms
@@ -693,5 +650,3 @@ def get_query(source: ObjectStream) -> ObjectStream:
 # Please do not hesitate to get in touch if you would like to join the effort, or are interested in re-implementing (pieces of) the pipeline with different tools!
 #
 # Our mailing list is analysis-grand-challenge@iris-hep.org, sign up via the [Google group](https://groups.google.com/a/iris-hep.org/g/analysis-grand-challenge).
-
-# %%
diff --git a/analyses/cms-open-data-ttbar/utils/__init__.py b/analyses/cms-open-data-ttbar/utils/__init__.py
index 1633b082..e5c8812a 100644
--- a/analyses/cms-open-data-ttbar/utils/__init__.py
+++ b/analyses/cms-open-data-ttbar/utils/__init__.py
@@ -6,12 +6,6 @@
 import matplotlib.pyplot as plt
 import uproot
 
-from func_adl_servicex import ServiceXSourceUpROOT
-from func_adl import ObjectStream
-from coffea.processor import servicex
-from servicex import ServiceXDataset
-
-
 def get_client(af="coffea_casa"):
     if af == "coffea_casa":
         from dask.distributed import Client
@@ -125,56 +119,4 @@ def save_histograms(all_histograms, fileset, filename):
 
             # W+jets scale
             f[f"{region}_wjets_scale_var_down"] = all_histograms[120j :: hist.rebin(2), region, "wjets", "scale_var_down"]
-            f[f"{region}_wjets_scale_var_up"] = all_histograms[120j :: hist.rebin(2), region, "wjets", "scale_var_up"]
-
-
-def make_datasource(fileset:dict, name: str, query: ObjectStream, ignore_cache: bool):
-    """Creates a ServiceX datasource for a particular Open Data file."""
-    datasets = [ServiceXDataset(fileset[name]["files"], backend_name="uproot", ignore_cache=ignore_cache)]
-    return servicex.DataSource(
-        query=query, metadata=fileset[name]["metadata"], datasets=datasets
-    )
-
-
-async def produce_all_histograms(fileset, query, analysis_processor, use_dask=False, ignore_cache=False, schema=None):
-    """Runs the histogram production, processing input files with ServiceX and
-    producing histograms with coffea.
-    """
-    # create the query
-    ds = ServiceXSourceUpROOT("cernopendata://dummy", "events", backend_name="uproot")
-    ds.return_qastle = True
-    data_query = query(ds)
-
-    # executor: local or Dask (Dask is not supported yet)
-    if not use_dask:
-        executor = servicex.LocalExecutor()
-    else:
-        executor = servicex.DaskExecutor(client_addr="tls://localhost:8786")
-
-    datasources = [
-        make_datasource(fileset, ds_name, data_query, ignore_cache=ignore_cache)
-        for ds_name in fileset.keys()
-    ]
-
-    async def run_updates_stream(accumulator_stream, name):
-        """Run to get the last item in the stream"""
-        coffea_info = None
-        try:
-            async for coffea_info in accumulator_stream:
-                pass
-        except Exception as e:
-            raise Exception(f"Failure while processing {name}") from e
-        return coffea_info
-
-    all_histogram_dicts = await asyncio.gather(
-        *[
-            run_updates_stream(
-                executor.execute(analysis_processor, source, title=f"{source.metadata['process']}__{source.metadata['variation']}", schema=schema),
-                f"{source.metadata['process']}__{source.metadata['variation']}",
-            )
-            for source in datasources
-        ]
-    )
-    all_histograms = sum([h["hist"] for h in all_histogram_dicts])
-
-    return all_histograms
+            f[f"{region}_wjets_scale_var_up"] = all_histograms[120j :: hist.rebin(2), region, "wjets", "scale_var_up"]
\ No newline at end of file
diff --git a/analyses/cms-open-data-ttbar/utils/processing_pipelines.png b/analyses/cms-open-data-ttbar/utils/processing_pipelines.png
index e93e2a57..78fdeeda 100644
Binary files a/analyses/cms-open-data-ttbar/utils/processing_pipelines.png and b/analyses/cms-open-data-ttbar/utils/processing_pipelines.png differ