diff --git a/docs/case_studies/match-clinical-trials-to-papers/notebook.ipynb b/docs/case_studies/match-clinical-trials-to-papers/notebook.ipynb
index c1855605..cc67aa1f 100644
--- a/docs/case_studies/match-clinical-trials-to-papers/notebook.ipynb
+++ b/docs/case_studies/match-clinical-trials-to-papers/notebook.ipynb
@@ -2,47 +2,159 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "title",
    "metadata": {},
    "source": [
-    "# Matching Clinical Trials to PubMed Papers\n",
+    "# How I used Claude to match 200 Clinical Trials to 700 PubMed Papers\n",
     "\n",
-    "Given a table of clinical trials and a table of PubMed papers, can we find which paper(s) report results for which trial?\n",
+    "Claude Code is a powerful general-purpose coding agent that can design and execute multi-stage data pipelines. However, it's commonly tripped up by messy real-world data operations problems: *I have two tables to merge, with no common key, and matching requires a deep understanding of the subject matter.*\n",
     "\n",
-    "This is a real-world **fuzzy merge** problem: the two tables share no common key, and matching requires understanding medical terminology, drug name aliases, study design, and clinical outcomes.\n",
+    "But with a tool purpose-built for large scale data operations like merging, we get shockingly better results.\n",
     "\n",
-    "Claude Code is a powerful general-purpose coding agent that (if prompted adequately) can design and execute multi-stage data pipelines. EveryRow is purpose-built for large-scale data operations like merging, and is available as a [Claude Code plugin](https://everyrow.io/docs/#tab-claude-code-plugin) — so the two complement each other naturally. This notebook compares what Claude Code does on its own versus what it achieves when it can call EveryRow's `merge()`.\n",
+    "This notebook compares what Claude Code does versus what the everyrow SDK can do.\n",
     "\n",
-    "We compare two approaches:\n",
+    "<small><i>You can also scroll down to see how to reproduce these results yourself.</i></small>\n",
     "\n",
-    "| | **Claude Code + EveryRow** | **Claude Code alone** |\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Approach 1: Claude Code\n",
+    "\n",
+    "When given a table of clinical trials and a table of PubMed papers, then tasked with finding which paper(s) report results for which trial, Claude Code independently devised and executed a multi-stage strategy:\n",
+    "\n",
+    "Phase 1: TF-IDF pre-filtering.\n",
+    "Built TF-IDF text representations for all trials and papers, computed cosine similarity, and selected the top-15 candidate papers per trial. This narrowed the 200 x 700 = 140,000 possible pairs down to ~3,000 candidates.\n",
+    "\n",
+    "Phase 2: Direct NCT ID matching.\n",
+    "Searched paper abstracts for explicit NCT ID mentions using regex. Found 8 papers that directly cite their trial’s identifier.\n",
+    "\n",
+    "Phase 3: 8 parallel LLM subagents.\n",
+    "Split the 200 trials into 8 batches of 25. Each subagent received its batch of trials plus TF-IDF candidate papers, and assessed whether candidates were genuine matches by checking alignment of interventions, conditions, study design, sponsors, endpoints, and institutions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc-results",
+   "metadata": {},
+   "source": [
+    "Claude Code Results: 200 trials + 700 papers\n",
+    "\n",
+    "| Metric | Value |\n",
+    "|---|---|\n",
+    "| F1 Score | 74.5% |\n",
+    "| Precision | 100% |\n",
+    "| Recall | ~59% |\n",
+    "| Runtime | ~6 min |\n",
+    "| Estimated cost | ~$10 to $15 |\n",
+    "\n",
+    "Claude Code achieved perfect precision: every match it reported was correct. But it missed over 40% of the true matches. The conservative TF-IDF pre-filtering and high-confidence thresholds meant many genuine but harder-to-detect links were never surfaced.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "043765fa",
+   "metadata": {},
+   "source": [
+    "## Approach 2: everyrow SDK\n",
+    "\n",
+    "When given the same task with everyrow, the entire merge is a single function call. Behind the scenes, `merge()` orchestrates hundreds of LLM agents that build an understanding of each trial’s key attributes, search through the paper pool for semantic matches, and verify candidates with detailed reasoning.\n",
+    "\n",
+    "Since multiple papers can report results from the same trial (e.g., primary results and follow-up analyses), this is a many-to-one mapping: papers (left) map to trials (right). Getting the table orientation right matters: the left table is the \"many\" side."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42d79347",
+   "metadata": {},
+   "source": [
+    "## Comparing Results\n",
+    "\n",
+    "| | everyrow | Claude Code |\n",
     "|---|---|---|\n",
-    "| **What you write** | A single `merge()` call | A prompt describing the task |\n",
-    "| **What happens** | EveryRow orchestrates hundreds of LLM agents | Claude builds a custom TF-IDF + subagent pipeline |\n",
-    "| **F1 Score** | **87.2%** | 74.5% |\n",
-    "| **Precision / Recall** | 84.1% / 90.6% | 100% / ~59% |\n",
-    "| **Runtime** | 13.5 min | ~6 min |\n",
-    "| **Cost** | ~$20 | ~$10–15 |\n",
-    "\n",
-    "The key finding: EveryRow dynamically scales its resources to match the problem, maintaining accuracy as datasets grow. Claude Code alone allocates a fixed budget of subagents regardless of dataset size, so its accuracy degrades as the problem gets bigger."
+    "| What you write | A single `merge()` call | A prompt describing the task |\n",
+    "| What happens | everyrow orchestrates hundreds of LLM agents | Claude builds a custom TF-IDF + subagent pipeline |\n",
+    "| F1 Score | 87.2% | 74.5% |\n",
+    "| Precision / Recall | 84.1% / 90.6% | 100% / ~59% |\n",
+    "| Runtime | 13.5 min | ~6 min |\n",
+    "| Cost | ~$20 | ~$10 to $15 |"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "setup-3882842f",
+   "cell_type": "markdown",
+   "id": "scaling-intro",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Setup: install everyrow if needed and configure API key\n",
-    "try:\n",
-    "    import everyrow\n",
-    "except ImportError:\n",
-    "    %pip install everyrow\n",
+    "## How Performance Scales\n",
     "\n",
-    "import os\n",
-    "if \"EVERYROW_API_KEY\" not in os.environ:\n",
-    "    os.environ[\"EVERYROW_API_KEY\"] = \"your-api-key-here\"  # Get one at everyrow.io\n"
+    "We ran the same experiment at a smaller scale (200 trials + 200 papers) to see how both approaches respond to growing data.\n",
+    "\n",
+    "At 200 + 200 papers, Claude Code independently chose a similar strategy: regex NCT ID extraction (3 matches), followed by 8 parallel subagents using keyword-based search (`Grep`) on a papers text file. Each agent handled 25 trials across 200 papers.\n",
+    "\n",
+    "| | 200 trials + 200 papers | 200 trials + 700 papers |\n",
+    "|---|---|---|\n",
+    "| everyrow — F1 | 85.7% | 87.2% |\n",
+    "| Claude Code — F1 | 78.8% | 74.5% |\n",
+    "| everyrow — cost | ~$6 | ~$18 |\n",
+    "| Claude Code — cost | ~$15 | ~$12 |\n",
+    "| everyrow — time | 2.7 min | 13.5 min |\n",
+    "| Claude Code — time | 7 min | 6 min |\n",
+    "\n",
+    "The key finding: everyrow dynamically scales its resources to match the problem, maintaining accuracy as datasets grow. Claude Code allocated exactly 8 subagents regardless of whether the paper pool contained 200 or 700 papers. Each agent handled 25 trials, the same workload whether it was searching through 200 or 700 candidates. As the dataset grows, each agent's search space expands but its compute budget doesn't."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "scaling-discussion",
+   "metadata": {},
+   "source": [
+    "A pattern emerges:\n",
+    "\n",
+    "- everyrow's F1 held steady (85.7% to 87.2%) as the paper pool grew by a factor of 3.5. It allocated proportionally more resources to handle the larger search space.\n",
+    "- Claude Code's F1 degraded (78.8% to 74.5%). It used the same 8 subagents and TF-IDF top-15 filtering regardless of dataset size, so each agent's search became less thorough.\n",
+    "- Claude Code's cost decreased slightly ($15 to $12). This is the signature of a fixed-budget approach: the same compute is spent whether the problem is small or large.\n",
+    "- everyrow's cost scaled with the problem ($6 to $18). The extra spend went directly toward maintaining quality at scale.\n",
+    "\n",
+    "At 200 + 200, everyrow was cheaper, faster, and more accurate. At 200 + 700, the accuracy gap widened. Extrapolating to larger datasets (thousands of trials and papers), we would expect the gap to grow further: Claude Code's fixed 8-agent budget would be spread even thinner, while everyrow would continue to scale its orchestration, thus nicely *complementing* Claude Code."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "takeaways",
+   "metadata": {},
+   "source": [
+    "## Key Takeaways\n",
+    "\n",
+    "1. Specialized orchestration beats general-purpose agent planning for data operations at scale.\n",
+    "everyrow's `merge()` is purpose-built to decompose a large matching problem into hundreds of parallel agent tasks, with intelligent candidate selection and verification. Claude Code is remarkably clever: it independently invented a TF-IDF + parallel-subagent pipeline. But a general-purpose coding agent can't match a system designed specifically for this class of problem.\n",
+    "\n",
+    "2. The recall gap is the key differentiator.\n",
+    "Claude Code achieved perfect precision (100%). Every match it reported was correct. But it only found ~59% of the true links. everyrow's higher F1 comes from substantially better recall: it surfaces matches that a fixed-budget approach misses.\n",
+    "\n",
+    "3. Fixed compute means quality suffers as the scale grows.\n",
+    "Claude Code used 8 subagents for both the 200-paper and 700-paper runs. This is a natural consequence of how coding agents plan: they estimate a reasonable level of parallelism and stick with it. As the dataset grows, each agent's workload increases but the total compute stays constant. EveryRow, by contrast, scales its agent count to the problem.\n",
+    "\n",
+    "4. Cost is about what you get for your money.\n",
+    "At the 200 + 700 scale, everyrow cost ~$18 and achieved 87.2% F1. Claude Code cost ~$12 and achieved 74.5% F1. The relevant metric isn't raw cost but cost per unit of quality. The ~$6 in savings from Claude Code comes at the price of missing 40%+ of the true matches.\n",
+    "\n",
+    "5. Claude Code can use the everyrow SDK.\n",
+    "Claude Code is an excellent coding agent already. Everyrow doesn't replace Claude Code. Rather, it complements Claude Code, allowing it to be even more capable!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2906f1cd",
+   "metadata": {},
+   "source": [
+    "## Reproduce It Yourself\n",
+    "\n",
+    "This dataset (200 trials + 700 papers) was sized to fit within everyrow's free-tier credits (~$20). To reproduce:\n",
+    "\n",
+    "1. Run the cells below to execute the everyrow merge and score it\n",
+    "2. To test Claude Code, give it the `trials_200.csv` and `papers_700.csv` files and ask it to match papers to trials\n",
+    "3. Save Claude Code's predictions as a CSV with `nct_id` and `pmid` columns, then score them with the code below."
    ]
   },
   {
@@ -56,7 +168,7 @@
     "\n",
     "PubMed papers describe the same studies in natural language: titles and abstracts discuss the intervention, patient population, endpoints, and findings.\n",
     "\n",
-    "**The matching problem**: given a trial's structured metadata and a paper's title + abstract, determine whether the paper reports results from that trial. This requires:\n",
+    "The matching problem: given a trial's structured metadata and a paper's title + abstract, determine whether the paper reports results from that trial. This requires:\n",
     "\n",
     "- Recognizing that a brand name in a trial record (e.g., \"PGL4001\") maps to a generic name in a paper (e.g., \"ulipristal acetate\")\n",
     "- Matching disease terminology across ontologies (e.g., \"uterine myomas\" vs. \"uterine fibroids\")\n",
@@ -73,20 +185,55 @@
     "\n",
     "The evaluation dataset was constructed as follows:\n",
     "\n",
-    "1. **Trials with known links**: We queried the [ClinicalTrials.gov API](https://clinicaltrials.gov/data-api/about-api) for completed trials that have `RESULT` or `DERIVED` reference types pointing to PubMed IDs. These known links serve as gold labels.\n",
+    "1. Trials with known links: We queried the [ClinicalTrials.gov API](https://clinicaltrials.gov/data-api/about-api) for completed trials that have `RESULT` or `DERIVED` reference types pointing to PubMed IDs. These known links serve as gold labels.\n",
     "\n",
-    "2. **PubMed papers**: We scanned the [PubMed 2019 baseline JSONL](https://www.kaggle.com/datasets/tunguz/pubmed-title-abstracts-2019-baseline) (~20 GB, ~19M papers) to extract:\n",
-    "   - **Gold papers**: those whose PMIDs match the trial references\n",
-    "   - **Distractor papers**: reservoir-sampled English-language papers with abstracts ≥100 characters, at a 10:1 distractor-to-gold ratio\n",
+    "2. PubMed papers: We scanned the [PubMed 2019 baseline JSONL](https://www.kaggle.com/datasets/tunguz/pubmed-title-abstracts-2019-baseline) (~20 GB, ~19M papers) to extract:\n",
+    "   - Gold papers: those whose PMIDs match the trial references\n",
+    "   - Distractor papers: reservoir-sampled English-language papers with abstracts >= 100 characters, at a 10:1 distractor-to-gold ratio\n",
     "\n",
-    "3. **Subsampling**: To keep this example reproducible within EveryRow's free-tier credits, we subsampled to **200 trials** and **700 papers** (64 gold papers + 636 distractors).\n",
+    "3. Subsampling: To keep this example reproducible within everyrow's free-tier credits, we subsampled to 200 trials and 700 papers (64 gold papers + 636 distractors).\n",
     "\n",
-    "**A note on gold labels**: `gold_labels_200.csv` contains 64 `(nct_id, pmid)` pairs. All 64 gold PMIDs are present in `papers_700.csv`, so all pairs are achievable. If you use a smaller paper subset, you must filter the gold labels to only pairs whose PMID is in your paper set — otherwise you'll penalize recall for matches that are impossible to find. The `score_from_csv` helper below handles this automatically."
+    "A note on gold labels: `gold_labels_200.csv` contains 64 `(nct_id, pmid)` pairs. All 64 gold PMIDs are present in `papers_700.csv`, so all pairs are achievable. If you use a smaller paper subset, you must filter the gold labels to only pairs whose PMID is in your paper set. Otherwise, you'll penalize recall for matches that are impossible to find. The `score_from_csv` helper below handles this automatically."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
+   "id": "setup-3882842f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup: install packages if needed and configure API key\n",
+    "try:\n",
+    "    import everyrow\n",
+    "except ImportError:\n",
+    "    %pip install everyrow\n",
+    "\n",
+    "import os\n",
+    "if \"EVERYROW_API_KEY\" not in os.environ:\n",
+    "    os.environ[\"EVERYROW_API_KEY\"] = \"your-api-key-here\"  # Get one at everyrow.io"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "02680f94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from everyrow import create_session\n",
+    "from everyrow.ops import merge\n",
+    "\n",
+    "pd.set_option(\"display.max_colwidth\", 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "id": "load-data",
    "metadata": {},
    "outputs": [
@@ -103,12 +250,6 @@
     }
    ],
    "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "pd.set_option(\"display.max_colwidth\", 100)\n",
-    "\n",
     "trials_df = pd.read_csv(\"trials_200.csv\")\n",
     "papers_df = pd.read_csv(\"papers_700.csv\")\n",
     "\n",
@@ -324,6 +465,33 @@
     "papers_df.head(3)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "a113c9fe",
+   "metadata": {},
+   "source": [
+    "## Merge Using everyrow"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "er-merge",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "async with create_session(name=\"Clinical Trials to Papers Matching\") as session:\n",
+    "    print(f\"Session URL: {session.get_url()}\")\n",
+    "    result = await merge(\n",
+    "        session=session,\n",
+    "        task=(\n",
+    "            \"Match publications to the clinical trial they report results for. A paper matches a trial if the paper describes the results of that trial - look for matching interventions/drugs, conditions/diseases, study design, outcomes, and sponsor/institution. Trial titles may be rewritten in the paper. Drug names may appear as brand or generic. Not every paper has a matching trial and not every trial has a matching paper.\"\n",
+    "        ),\n",
+    "        left_table=papers_df,\n",
+    "        right_table=trials_df,\n",
+    "    )"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "evaluation-intro",
@@ -333,11 +501,11 @@
     "\n",
     "We evaluate merge quality using standard information retrieval metrics on the set of predicted `(nct_id, pmid)` pairs:\n",
     "\n",
-    "- **Precision** = correct pairs / predicted pairs — *\"Of the matches we found, how many are real?\"*\n",
-    "- **Recall** = correct pairs / gold pairs — *\"Of the real matches, how many did we find?\"*\n",
-    "- **F1** = harmonic mean of precision and recall\n",
+    "- Precision = correct pairs / predicted pairs. In other words, of the matches we found, how many are real?\n",
+    "- Recall = correct pairs / gold pairs. In other words, of the real matches, how many did we find?\n",
+    "- F1 = harmonic mean of precision and recall\n",
     "\n",
-    "A system with perfect precision but low recall is too conservative: it only reports matches it's certain about, but misses many real links. In practice, **missed links are harder to recover than false positives** (which can be reviewed), so recall matters."
+    "A system with perfect precision but low recall is too conservative: it only reports matches it's certain about, but misses many real links. In practice, missed links are harder to recover than false positives (which can be reviewed), so recall matters."
    ]
   },
   {
@@ -414,26 +582,6 @@
     "print(f\"Gold label pairs: {len(gold_pairs)} (across {gold_df['nct_id'].nunique()} trials)\")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "er-approach",
-   "metadata": {},
-   "source": [
-    "## Approach 1: Claude Code + EveryRow\n",
-    "\n",
-    "With EveryRow, the entire merge is a single function call. Behind the scenes, `merge()` orchestrates hundreds of LLM agents that build an understanding of each trial's key attributes, search through the paper pool for semantic matches, and verify candidates with detailed reasoning.\n",
-    "\n",
-    "Since multiple papers can report results from the same trial (e.g., primary results and follow-up analyses), this is a **many-to-one** mapping: papers (left) map to trials (right). Getting the table orientation right matters — the left table is the \"many\" side."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "er-merge",
-   "metadata": {},
-   "outputs": [],
-   "source": "from everyrow import create_session\nfrom everyrow.ops import merge\n\nasync with create_session(name=\"Clinical Trials to Papers Matching\") as session:\n    print(f\"Session URL: {session.get_url()}\")\n    result = await merge(\n        session=session,\n        task=(\n            \"Match publications to the clinical trial they report results for. A paper matches a trial if the paper describes the results of that trial - look for matching interventions/drugs, conditions/diseases, study design, outcomes, and sponsor/institution. Trial titles may be rewritten in the paper. Drug names may appear as brand or generic. Not every paper has a matching trial and not every trial has a matching paper.\"\n        ),\n        left_table=papers_df,\n        right_table=trials_df,\n    )"
-  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -444,7 +592,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "=== Claude Code + EveryRow ===\n",
+      "=== everyrow ===\n",
       "Predicted pairs: 69\n",
       "Gold pairs:      64\n",
       "True positives:  58\n",
@@ -462,49 +610,10 @@
     "merged = result.data.dropna(subset=[\"nct_id\"])\n",
     "er_predicted = set(zip(merged[\"nct_id\"], merged[\"pmid\"].astype(str)))\n",
     "\n",
-    "print(\"=== Claude Code + EveryRow ===\")\n",
+    "print(\"=== everyrow ===\")\n",
     "er_scores = score_merge(er_predicted, gold_pairs)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "cc-approach",
-   "metadata": {},
-   "source": [
-    "## Approach 2: Claude Code Only\n",
-    "\n",
-    "When given the same task without EveryRow, Claude Code independently devised and executed a multi-stage strategy:\n",
-    "\n",
-    "**Phase 1: TF-IDF pre-filtering.**\n",
-    "Built TF-IDF text representations for all trials and papers, computed cosine similarity, and selected the top-15 candidate papers per trial. This narrowed the 200 × 700 = 140,000 possible pairs down to ~3,000 candidates.\n",
-    "\n",
-    "**Phase 2: Direct NCT ID matching.**\n",
-    "Searched paper abstracts for explicit NCT ID mentions using regex. Found 8 papers that directly cite their trial's identifier.\n",
-    "\n",
-    "**Phase 3: 8 parallel LLM subagents.**\n",
-    "Split the 200 trials into 8 batches of 25. Each subagent received its batch of trials plus TF-IDF candidate papers, and assessed whether candidates were genuine matches — checking alignment of interventions, conditions, study design, sponsors, endpoints, and institutions."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cc-results",
-   "metadata": {},
-   "source": [
-    "**Claude Code Only — Results (200 trials + 700 papers):**\n",
-    "\n",
-    "| Metric | Value |\n",
-    "|---|---|\n",
-    "| F1 Score | 74.5% |\n",
-    "| Precision | 100% |\n",
-    "| Recall | ~59% |\n",
-    "| Runtime | ~6 min |\n",
-    "| Estimated cost | ~$10–15 |\n",
-    "\n",
-    "Claude Code achieved **perfect precision** — every match it reported was correct. But it missed over 40% of the true matches. The conservative TF-IDF pre-filtering and high-confidence thresholds meant many genuine but harder-to-detect links were never surfaced.\n",
-    "\n",
-    "> **The fixed-budget problem**: Claude Code allocated exactly 8 subagents regardless of whether the paper pool contained 200 or 700 papers. Each agent handled 25 trials — the same workload whether it was searching through 200 or 700 candidates. As the dataset grows, each agent's search space expands but its compute budget doesn't."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "comparison-intro",
@@ -513,97 +622,6 @@
     "## Head-to-Head: 200 Trials × 700 Papers"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "comparison-chart",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQkAAAHPCAYAAADwAFxPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfuVJREFUeJzt3Qd4U+X3wPFTKLTMsnfZeyN7yIYKyBYBQYYMRUAREK3IEAcCKooguGhVRARlCCLIRpYyVfaQKUtWWVJG83/O+/vfmLRpaUvbNM338zzXJvfe3NwmKa/35Lzn+NhsNpsAAAAAAAAA8Fqp3H0CAAAAAAAAANyLICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAIALoaGh4uPjY18eVK9evezHatiwIa85AAAAkhWChAAAwPj7779l+vTp0qVLF6lQoYLkzJlT0qRJY342bdpUvvzyS7HZbNG+WnPnzjX7Zc+eXfz8/KRw4cLSp08fOXToULSPOXjwoNlH99XH5MiRQ5o1a2aOFVsacHMM5sVm0QAg4ia2r62rAOiVK1fk1VdflfLly0uGDBkkc+bMUrVqVZk4caLcunUrQT9TrowdO9bluaZKlUqyZMkiNWvWlDfffFOuXbvGxwIAAHgtX3efAAAASB6++uorCQ4OjrL+woULsmrVKrN89913smDBAkmdOrV9uwYOe/fuLV988YXT444fPy4zZ86U2bNny/fffy8tW7Z02r506VLp2LGjU5Do4sWLsnLlSrPo9pCQkATJ4ouP6tWry6RJk9zy3J4s8vv1119/SePGjc3nwdGOHTvMMmfOHFmxYoUJBD7oZyqu9HnCwsLkt99+M4see926dVKgQIEHOi4AAIAnIkgIAACc5MmTxwRfihYtKseOHZNZs2bZA3mLFy82gbu+ffva9586dapTMEczEcuWLWuCP3v37jWPfeKJJ2TPnj2SP39+e9Zi165d7cfV/fVxur8+TukxNVA3cODAGN+hAQMGyKOPPuq07sUXX7TfrlatmnTu3Nlpux43OlevXjWZbuXKlTOLp9HXVN+fV155xbyurrz++uvm/e3WrVusjxtdwPTIkSMyY8YM+/0WLVrYb0dERJj31QoQZsuWTfr372/O8eOPP5Z///1Xdu7cKc8884zMmzfvgT5TcaGvTdasWU3m4A8//CC7du2yBzQHDx5sAuGe7t69exIeHi7p06d396kAAABPYQMAALDZbF9//bXtq6++st25c8fp9Vi9erXOMbYvHTp0sG/TffPmzWvf9sQTT9i3Xbx40ZYpUyb7thEjRti3vfjii/b1uo/ua9FjWNvy5ctnu3v3bpzfH8fz7dmzZ4zbQ0JCbAsXLrTVrl3bliFDBltAQIDZR9c77udozZo1tqeeespWpUoVW548eWxp06a1pUuXzlasWDFbr169bH/88UeU59TzsI7VoEEDp226f7du3WyFChUyx/L397cFBgbaGjVqZHv55Zdtp06divXv3qVLF/McuXPntu3duzfK9nHjxpntqVOntq1atcr2oPr162f/vTJnzmwLCwuzb/vxxx+dXsOff/7Zvu2TTz5x2mada3w/UzEZM2aM03MdPXrUvu3WrVu2okWL2relSZPGrFOff/65rVOnTrbSpUvbsmfPbvP19TXPX6lSJfPc//zzT5Tn0vfQOpY+75YtW2zNmjUzr03GjBltzZs3t23bts3leZ49e9YWHBxsjq/7+vn5mc/Us88+azt+/Ph9P1O6T/fu3W25cuWy+fj42BYsWJDgny8AAJByESQEAAD3pQESKxjx6KOP2tdv3rzZKfjy/fffOz2udevW9m0aaLGUKlXKvl73caTHcDymBlkSM0j48MMPO92PTZBw2LBhTtsiLxqIWbFiRayChHv27LGlT58+xuP99NNPsf7dNQCVJUsWl4HCN954w+l9DA8Ptz0IDWppIMs65vDhw522P/30004BxIiICKeAn+Pv+Pbbbz/QZyq+QUL12GOPOW3/+++/zfqqVavG+L7kz5/fvq+rIGG9evVM0DHy4zSg/Msvvzg9btOmTbYcOXJE+1z6uVy/fn20n6kSJUqYgLXjYzRImNCfLwAAkHIx3RgAAMTo7Nmzpm6bpUaNGvbbf/zxh9O+OoU1uvvapESnP1q3Y/MY6zm0sURi+eWXX0zDFJ3SqnXxdArr/WjzjQYNGpgGLzqFNl26dKae4o8//ij79u2T27dvy3PPPWemxt6PTqu9efOmua218Lp3726Of+rUKdm9e7ds2bIlTr+PNgTRGn/aAObcuXOmHuCaNWvMFFptHqJatWplavqlTZtWHsSHH35of0+1yc2QIUOctjt+PooUKeJUr1Bft4CAAPtny9o3Pp8pbWoSX/p4rY1o0d/Dqo+YK1cuad26tRQrVsycr9bi1Kny3377rXm/9fYbb7whH330kctjb9iwQUqWLCmdOnUy76fW/dQp2DrNWmsu7t+/3xxTp7i3a9fO1P9UhQoVMlPk9XOldUD1M6mvk9bw1KYt+rpFZjVz6dChg1SqVMlM8db9EvrzBQAAUi6ChAAAIFp37941NeT0pxU00fpxlkuXLjntr7X8HGXKlMl+W4Mjly9fNrcduyTH9BilwZjEpM+/fft2KViwYKwf89prr5nfZ9u2bSYoqN17c+fOberx6X2lP0+ePCmBgYExHsuxcYvWX3z55ZedtluvWVxoHcaff/7ZBAo1yKuBXatzr55jQgQIb9y4YbphW7RGYOT6gI6fj8jvs/VeW0FC632Oz2dK62jGxaeffmpqEl6/ft3UJNRahBatx2kFHbV5jgbYNm/ebPbR/TXYWa9ePVm0aJHZZ/ny5dE+jwaftSGKFdTTgOHIkSPN7cOHD5vgrXZv1m7b58+fN+v1vDRoqUFJq76mPuc///xjFg36aQDalffff1+ef/55p3ULFy5M8M8XAABImQgSAgAAlzSopNlMP/30kz04owGVnDlzRvuKOQb/XN1PqMckpB49esQpQKg0U0+bg5w4cSLG/TRb635BwocfflimTJlibmumn77GpUuXllKlSpkMSt3u2E06trQ5iwYKGzVqZA8QNmnSxGQUPkjmnUU7AVsBPc0QHD58eIz7u3pf3fX5eOutt1yuL1y4sP29UO+9956MGTPGBAdjeo+j06ZNG6esP83is4KESoPTGiTcuHGjU9DOsdNzZJs2bXIZJNTgoqsmP4n1+QIAACkPQUIAABCFZsBpx2Br6qcGBnUqbeSuwJGDGVYwytX9VKlSmUCGFVSygj0xPcbKxkpMGjCJi9OnT5upodYUzphYU3Fj8thjj5kAmzV1V7PWdLHo1FN97ePTaVkDSo7neeDAAfPeFi9eXB60c+7kyZPt9zU7sXz58lH2c/x8RH5fI6+z3uf4fqbiQz+HGvzWDD8N6GkWnpW5qBl4w4YNu+8xdGp5dDTz1pFmmzrSDFRX2ZMx0WxCV3RKtK+vb5J+vgAAQMpCkBAAADjRKbQaMDlz5oy5rwEUnXapQYjIKlas6HRfp2RWrlzZfv/IkSP223ocK4NNs5i0Hpv1GEeOj1Fa9y8xaX22uFi8eLFT4O3dd9+VPn36mIwxrUEYn2DLpEmTTJaXBvX0ddFae5rxpQFJrS337LPPyrp16+J0TJ16+sILL5jbderUkT///NNkvWlmoU5zfZBAodbJO3r0qP2+Tol1RT8f+jsp3V8Dw1ZdQg12aS2+yO9zfD9TcaHnolmDMdG6g5aMGTPK/PnzTdadv7+/qUHoKmsvMmsKsUVrRDrKkiWL+WlNLVZ58+aVoUOHRnvM6DJTY/ocJ8bnCwAApDwECQEAgJ1ORdUpkVYQTIMimlHlGMSIXPsuX758JtigtNadNk5Q2oRh7dq19n3btm1rv61BSCtIqPtoJpX1HPPmzbPvpzXu9DmSk8g1ErUBhTWldO7cufEKWGk2nAaMNCNPF9W8eXP7a+nYWCOuAUKtS6j183bu3CmPPPJIggQK33nnHfttzS5t2LChy/30fZ4xY4a5rQHBlStXmvOxAo2OrM9HfD9Tifk+a7MU67y1DmLkc4+OBuL097ayE2fNmhWlyYwVxLU+Oxo81fc+crBUA6yrVq1yGaxP6s8XAABImQgSAgAAe3BOO/xqEERp4CsoKMjUnnOk6/v162duay2z4OBgGTx4sLk/e/Zs8/iyZcvKN998Y5pbWI9xrKOmtzV4pAEUnT6qwUh9bs3Ecwy06bGTW700zYJ0pJ2CNfCiU7NjGzyKnLGmde800FaiRAmTSaavm75+kTPO4hsg1C65GojS+pIPGijUIJ1mm94vi1Dp50eDiFu3bjX39T1++umnTbMWx6YnOiXWmvYd389UYrzPWntS6XvbtWtXKVOmjHkNY9sRWIOa+vs7dje2aLBP3wPVq1cv0yVZ99cmQXXr1jWP0fdGpwjrNHF93TUTUd8zbWTirs8XAABIwWwAAAA2m23MmDFaJPC+S6FChZxer4iICFvPnj2j3d/f39/2448/RnmNlyxZYvPz84v2cXpMPXZ8RD5OTNtDQkJcHkPXO+5nuX37tq1ChQrRnrPj/TVr1tgf57itQYMG9vXjx4+/72s+ZcqUWP/u7733nnlMs2bNbDdv3oyy/ZdffrFlzJjRVqBAAduhQ4dscdWyZUv7eRUrVsx27969GPc/cuSI+cxE97tVrlzZduHChQT5TMX2s3306NH7PkZfm0yZMkV5bl9fX1u3bt1cfjaU4+/apEkTl59xPf9169Y5PW7jxo22HDly3PezEJvPlKOE/nwBAICUK5W7g5QAAMCzaY250NBQmTNnjjRu3NhMbUybNq2pnaZTcX///Xdp2bJllMdpBp5maOk+uq8+Rh+rx9DsJz2mVb8uOUmTJo2sXr3aZH9pkw2tiadNOz755BMZO3ZsnI+nTVBGjx5tutxqnbz06dObBhSa8aWvkU5ZtbLqYkOzCDUb08ogjKxevXqyfPnyeGURaqan1e1aae08bR4SE52qu2vXLnnllVdMJp6ek9bPq1KlikyYMME00YjcrCS+n6mEpK/N+vXrzbRcfU+0LmGDBg3MlF99r2JDX2vtXKzZm9ogRX9vze7U49avX99pX8303LNnj4waNcpMQ9YpyppVqVl+en/QoEEmszHy45L68wUAAFIuH40UuvskAAAAgJRAA3HaDETpNN/4BI4BAADcgUxCAAAAAAAAwMsRJAQAAAAAAAC8HEFCAAAAAAAAwMtRkxAAAAAAAADwcmQSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAIFnw8fGRsWPHuvs0AAAAvBJBQuABffTRR+aipmbNmryWAACPEBoaasYua/H19ZX8+fNLr1695O+//07U5166dCmBQACAWxw5ckSefvppKVq0qPj7+0vmzJmlbt268sEHH8i///6boM918+ZNM96tXbs2QY8LJCbfRD064AW+/vprKVy4sPz2229y+PBhKV68uLtPCQCAWBk3bpwUKVJEbt26JVu2bDHBww0bNsju3bvNxVNiBQmnTZvmMlCoF2gasAQAIKH9+OOP0qlTJ/Hz85MePXpI+fLl5fbt22bce/HFF2XPnj3yySefJGiQ8LXXXjO3GzZsmGDHBRIT/xcGPICjR4/Kpk2bZP78+eYbKQ0YjhkzJtm9pjdu3JAMGTK4+zQAAMlMixYtpFq1auZ23759JUeOHDJhwgT54Ycf5PHHH0/y80mswCQAwLvpdVuXLl2kUKFCsnr1asmbN69928CBA02yhwYRAW/HdGPgAWhQMGvWrNKqVSt57LHHzP3Irly5Ii+88ILJNtRvrQoUKGC+ubpw4YJ9H83g0IyKkiVLmgskHbQ6dOhg0uGVpqjrdLDIqerHjh0z6zXzw6JTxTJmzGge27JlS8mUKZN069bNbPvll1/Mt2cFCxY05xIYGGjOzVVq/f79+80FYs6cOSVdunRSqlQpGTlypNm2Zs0a87wLFiyI8rjZs2ebbZs3b+azBQAe5uGHHzY/rfFHMx9cZT/oWKPjWuTx6J133jFZGMWKFTPjTPXq1WXr1q1Oj9MsQuU43Tm6moR6W9cdPHhQunfvLgEBAWZcGjVqlNhsNjl58qS0bdvWTBfLkyePvPvuu1HONTw83HyBp5n+1tg3YsQIsx4A4B0mTpwo169fl88//9wpQGjRMeL55583t+/evSuvv/66fSzT8e6VV16JMm5s27ZNgoKCzBdser2kmflPPfWUfVzU8UppNqE13lF3F8kdmYTAA9CgoAbz0qZNK127dpXp06ebiyG9KFI6EOkF1759+8yA8dBDD5ngoGZonDp1ygwo9+7dk0cffVRWrVplvt3SwenatWuyYsUKM91LB6e40oFNB6x69eqZC7b06dOb9fPmzTNp7wMGDJDs2bObKdIffvihORfdZvnjjz/MeadJk0b69+9vBka9YFy8eLG8+eab5oJRL7L092/fvn2U10TPuXbt2ny2AMDD6EWN0i/A4kO/KNIxTLPr9WJIL8p0nPzrr7/MmKLrT58+bca4r776KtbH7dy5s5QpU0befvttk+nxxhtvSLZs2eTjjz+Wxo0bm+xHHX+GDx9uxuD69eubx0VEREibNm3MVDIdz/QYf/75p0yePNkEHhcuXBiv3xMA4Fn0OkbrENapU+e++2pm/RdffGGSQIYNGya//vqrjB8/3lzTWUkS58+fl+bNm5tA4MsvvyxZsmQxY6jOMFO6Xq8N9bpLr5d0LFQVK1ZM5N8UeEA2APGybds2m/4JrVixwtyPiIiwFShQwPb888/b9xk9erTZZ/78+VEer/urmTNnmn3ee++9aPdZs2aN2Ud/Ojp69KhZHxISYl/Xs2dPs+7ll1+OcrybN29GWTd+/Hibj4+P7fjx4/Z19evXt2XKlMlpneP5qODgYJufn5/typUr9nXnz5+3+fr62saMGePiFQMAJBc6buhYsXLlSts///xjO3nypO27776z5cyZ0/zbrvdVgwYNzBKZjjWFChWKMh5lz57ddunSJfv6RYsWmfWLFy+2rxs4cKBZ54qudxxD9Lau69+/v33d3bt3zXirY9fbb79tX3/58mVbunTpzLlZvvrqK1uqVKlsv/zyi9PzzJgxwxx348aNcXrdAACeJywszPyb37Zt2/vuu2vXLrNv3759ndYPHz7crF+9erW5v2DBAnN/69at0R5Lx9fI4xqQ3DHdGIgnzVjInTu3NGrUyNzXjAnNdJgzZ47JDlTff/+9VKpUKUq2nbW/tY9mFA4ePDjafeJDv7WKTNPgHesUalajfpum12U7d+406//55x9Zv369yXzUacnRnY9OmdaU+++++86+7ttvvzVZjDolDACQ/DVt2tRkO2h2uGZMaP1azXbX0hjxoeOgYxaiNX1ZMwkfhGZ1WFKnTm3qKOrY1adPH/t6zeLQ0hiOz6VZ8po9WLp0aTPmWYtmH1rlMwAAKdvVq1fNTy3DFJvmWmro0KFO6zWjUFl1C3XMUUuWLJE7d+4k+DkD7kKQEIgHDQJqMFADhFoEVwvd6lKzZk05d+6cmTqsdIquds2Kie6jFzUJ2c1Rj+XqAu/EiROmHpRO0dK6hXph2KBBA7MtLCzM/LQuru533nrBpVO6HOsw6u1atWrR4RkAPITWB9Spv/qFj9ax1QCa1l+Kr8hfLlkBw8uXLz/QeUY+rtYm1Bq++iVb5PWOz3Xo0CHTrVLHO8dFawBb08UAACmb1q1VWg7jfo4fPy6pUqWKcj2jdW81MKjblV5DdezY0dQb1LFI6+OGhIRQ7xYej5qEQDxoR6wzZ86YQKEukWmwTGtUJJToMgqtjMXI9AJPB7fI+zZr1kwuXbokL730kgnyacbI33//bQKHWrcprjSbUGsoak1DzSrcsmWLTJ06Nc7HAQC4R40aNezdjdu1a2dq2T7xxBNy4MAB82WSjj//mwUcu/FHs/xccXWMuHB13Ng8l45tFSpUkPfee8/lvppBCQBI+UHCfPnymXrvsXW/GV26Xb9g0+sfrXe4fPlyMxNLG2jpOh1DAU9EkBCIBw0C5sqVy96h0ZEWq9WCtjNmzDANPO43GOk+WgxX09S1qLsrViaGdkp2ZH2TFRtaqF2LtGsRXg3uWTSDxJEW9FWxGUS10Yqm4n/zzTemQ7Kev041AwB4Hg26aWF2zZLXL3y0ELuOP66mCsdl/EnIUhpxpWPs77//Lk2aNEnS5wUAJC/aKPKTTz6RzZs3x9hgsVChQuYLJs1E13IVFp0tptdiut2RzqLSRZs7avOubt26mSQSLZPBuANPxHRjII40GKaBQB1otH5T5GXQoEEmlV1rOmkKul6cWF2wXGU66D46vctVBp61jw5GevGmtQIdffTRR7E+byvjwjHDQm9/8MEHTvvpNCztCjlz5kwzPdnV+Vg0tb5FixYya9YsEzh95JFHokz9AgB4Du1er9mF77//vty6dcsE2fbv32/q1Vp0XNu4cWO8n0Oz2F198ZUYHn/8cZMx/+mnn7ocz7U+LwAg5RsxYoQZfzR4pwE/VyWg9LpIS28oHQcdWRnprVq1Mj+1tEXka6PKlSubnzrDSqVPnz7JxjsgoZBJCMSRBv80CNimTRuX2/WbJA20adBMv03SNPROnTqZ9POqVaua6b56DM001KYmmtX35Zdfmoy83377zRR514uWlStXyrPPPmvqW2iNJT3Ghx9+aL6R0os2LZIbl1pKOr1YHzd8+HBzwaRp99o0xVWdqClTppgpZw899JD0799fihQpIseOHTOFenft2uW0r56/BkfV66+/zucJADzciy++aMac0NBQM3bphVFQUJBpEqLjjo5f5cqVsxeCjysdC9Vzzz1njqtfYmlmemJ48sknZe7cufLMM8+YJiV169Y1U6U18KnrdXqYNd0aAJBy6XWQXpvprCfNENRrGK3Bfvv2bdm0aZNpdKUlmLSUUs+ePU3WoQb3tPagXqPpbCwty2E1rdT7mrChDSr12Hp9qF9I6TWWFWjUppFly5Y1zR21Fq7WhdfnvF/td8Ct3N1eGfA0rVu3tvn7+9tu3LgR7T69evWypUmTxnbhwgXbxYsXbYMGDbLlz5/fljZtWluBAgVsPXv2NNssN2/etI0cOdJWpEgR87g8efLYHnvsMduRI0fs+/zzzz+2jh072tKnT2/LmjWr7emnn7bt3r1bv76yhYSE2PfTY2fIkMHlee3du9fWtGlTW8aMGW05cuSw9evXz/b7779HOYbSY7dv396WJUsW8/uWKlXKNmrUqCjHDA8PN+cTEBBg+/fff+P8egIAkp7+m6//9m/dujXKtnv37tmKFStmlrt379pmzZplK1q0qBnDKleubFu+fLkZawoVKmR/zNGjR83xJk2aFOV4un7MmDH2+3rMwYMH23LmzGnz8fEx26PbV2/rOh0DHUU31jVo0MBWrlw5p3W3b9+2TZgwwaz38/MzY1bVqlVtr732mi0sLCxOrxsAwLMdPHjQXAMVLlzYjGuZMmWy1a1b1/bhhx/abt26Zfa5c+eOGSOsa7PAwEBbcHCwfbvasWOHrWvXrraCBQuasSVXrly2Rx991LZt2zan59u0aZMZc/S5Io9xQHLko/9xb5gSgCe7e/euKQTcunVr+fzzz919OgAAAAAAIB6oSQjggSxcuNDUqnJshgIAAAAAADwLmYQA4kU7Mv/xxx+mDqE2K9mxYwevJAAAAAAAHopMQgDxMn36dBkwYIDkypXLNF4BAAAAAACeiyAhgHjRrpdaj3Dbtm106EKKNH78eKlevbpkypTJBMO1o92BAwec9rl165YMHDhQsmfPLhkzZpSOHTvKuXPnYjyulgIePXq05M2b13S9a9q0qRw6dCiRfxsAAOI31jVs2FB8fHycFu0YDgBIeQgSAgDgwrp160wAcMuWLbJixQq5c+eONG/eXG7cuGHf54UXXpDFixfLvHnzzP6nT5+WDh06xPh6Tpw4UaZMmSIzZsww0/YzZMggQUFBJuAIAEByG+tUv3795MyZM/ZFxzIAQMpDTcL/z+q4du2a+QZNvxkDACAybdCjWRZ6QVW/fn0JCwuTnDlzyuzZs+Wxxx4z++zfv1/KlCkjmzdvllq1arkcb7Qb+LBhw2T48OFmnR4nd+7cJju3S5cuUR4THh5uFsdj3L5929QCZcwCACTmWGdlElauXFnef//9WB2DcQsAPBeZhCImQBgQEGB+AgDgigbzVLZs2czP7du3m4wLnS5sKV26tBQsWNAECV05evSonD171ukxOv7UrFkz2sfoVDDdx1qyZMliLuAYswAAiT3WWb7++mvz5VT58uUlODhYbt68Ge0xGLcAwHMRJAQA4D4iIiJkyJAhUrduXXsNTg32pU2b1gTtHGlWoG5zxVqv+8T2MXoxphdt1nLy5EneLwBAkox16oknnpBZs2bJmjVrzJj01VdfSffu3aM9DuMWAHguX3efAAAAyZ3Wa9q9e7ds2LAhyZ/bz8/PLAAAuGOs69+/v/12hQoVTOOtJk2ayJEjR6RYsWJRjsO4BQCei0xCAABiMGjQIFmyZInJoChQoIB9fZ48eUxtwCtXrjjtr92NdZsr1vrIHZBjegwAAO4a61zREhnq8OHDvDEAkMIQJAQAwAVtEKIXTQsWLJDVq1dLkSJFnLZXrVpV0qRJI6tWrbKvO3DggJw4cUJq167t8jXVY2gw0PExV69eNV2Oo3sMAADuGutc2bVrl/mpGYUAgJSF6cYAAEQz7Uo7Fy9atEgyZcpkrxmozUPSpUtnfvbp00eGDh1qCrxnzpxZBg8ebIJ9jp2NtZmJFnFv37696Uas9Z7eeOMNKVGihLkYGzVqlOl43K5dO94HAECyGut0SrFub9mypWTPnl3++OMPeeGFF0zn44oVK/JuAUAKQ5AQAAAXpk+fbn42bNjQaX1ISIj06tXL3J48ebKkSpVKOnbsKOHh4RIUFCQfffSR0/6aXWh1i1QjRoyQGzdumBpPOlW5Xr16smzZMvH39+d9AAAkq7FOG3StXLlS3n//fTN2BQYGmjHv1Vdf5Z0CgBTIx6Y55l5Op3rpt2V6EaeZIAAAJFeMWQAAT8K4BQCeg5qEAAAAAAAAgJcjSAgAAAAAAAB4OYKEAAAAAAAAgJcjSAgAAAAAAAB4OYKEAAAAAAAAgJcjSAgAAAAAAAB4OYKEAAAAAAAAgJcjSAgAAAAAAAB4OYKEAAAAAAAAgJcjSAgAAAAAAAB4OYKEAAAAAAAAgJcjSAgAAAAAAAB4OYKEAAAAAAAAgJcjSAgAAAAAAAB4ObcGCdevXy+tW7eWfPnyiY+PjyxcuNBpu81mk9GjR0vevHklXbp00rRpUzl06JDTPpcuXZJu3bpJ5syZJUuWLNKnTx+5fv16Ev8mAAAAAAAAgOdya5Dwxo0bUqlSJZk2bZrL7RMnTpQpU6bIjBkz5Ndff5UMGTJIUFCQ3Lp1y76PBgj37NkjK1askCVLlpjAY//+/ZPwtwAAAAAAAAA8m49N0/WSAc0kXLBggbRr187c19PSDMNhw4bJ8OHDzbqwsDDJnTu3hIaGSpcuXWTfvn1StmxZ2bp1q1SrVs3ss2zZMmnZsqWcOnXKPD42rl69KgEBAeb4mpEIAEByxZgFAPAkjFsA4DmSbU3Co0ePytmzZ80UY4sG8mrWrCmbN2829/WnTjG2AoRK90+VKpXJPIxOeHi4GawcFwAAAAAAAMBbJdsgoQYIlWYOOtL71jb9mStXLqftvr6+ki1bNvs+rowfP94EHK0lMDAwUX4HAAAAAAAAwBMk2yBhYgoODjZTi63l5MmT7j4lAAAAAAAAwG2SbZAwT5485ue5c+ec1ut9a5v+PH/+vNP2u3fvmo7H1j6u+Pn5mdqDjgsAAAAAAADgrZJtkLBIkSIm0Ldq1Sr7Oq0dqLUGa9eube7rzytXrsj27dvt+6xevVoiIiJM7UIAAAAAAAAA9+crbnT9+nU5fPiwU7OSXbt2mZqCBQsWlCFDhsgbb7whJUqUMEHDUaNGmY7FVgfkMmXKyCOPPCL9+vWTGTNmyJ07d2TQoEGm83FsOxsDAAAAAAAA3s6tQcJt27ZJo0aN7PeHDh1qfvbs2VNCQ0NlxIgRcuPGDenfv7/JGKxXr54sW7ZM/P397Y/5+uuvTWCwSZMmpqtxx44dZcqUKW75fQAAAAAAAABP5GOz2Wzi5XQas3Y51iYm1CcEACRnjFkAAE/CuAUAniPZ1iQEAAAAAAAAkDQIEgIAAAAAAABejiAhAAAAAAAA4OUIEgIAAAAAAABejiAhAAAAAAAA4OUIEgIAAAAAAABejiAhAADRWL9+vbRu3Vry5csnPj4+snDhQqftus7VMmnSpGhf07Fjx0bZv3Tp0rwHAAAAANyKICEAANG4ceOGVKpUSaZNm+Zy+5kzZ5yWmTNnmqBfx44dY3xNy5Ur5/S4DRs28B4AAAAAcCtf9z49AADJV4sWLcwSnTx58jjdX7RokTRq1EiKFi0a43F9fX2jPBYAAAAA3IlMQgAAEsC5c+fkxx9/lD59+tx330OHDpkpzBpM7Natm5w4cSLafcPDw+Xq1atOCwAAAAAkNIKEAAAkgC+++EIyZcokHTp0iHG/mjVrSmhoqCxbtkymT58uR48elYcffliuXbvmcv/x48dLQECAfQkMDOT9AgAAAJDgCBICAJAAtB6hZgX6+/vHuJ9OX+7UqZNUrFhRgoKCZOnSpXLlyhWZO3euy/2Dg4MlLCzMvpw8eZL3CwAAAECCoyYhAAAP6JdffpEDBw7It99+G+fHZsmSRUqWLCmHDx92ud3Pz88sAAAAAJCYyCQEAOABff7551K1alXTCTmurl+/LkeOHJG8efPyPgAAAABwG4KEAADEEMDbtWuXWZTWD9Tbjo1GtJHIvHnzpG/fvi6P0aRJE5k6dar9/vDhw2XdunVy7Ngx2bRpk7Rv315Sp04tXbt25X0AAAAA4DZMNwYAIBrbtm2TRo0a2e8PHTrU/OzZs6dpPqLmzJkjNpst2iCfZgleuHDBfv/UqVNm34sXL0rOnDmlXr16smXLFnMbAAAAANzFx6ZXNl5Os0C0Y6QWhM+cObMkd3oxOXHiRPPzn3/+kTRp0kixYsWkXbt2MmLECNNdU+kFbO/evWM8VoMGDWTt2rUx7nP79m0JCQmRVatWyR9//CGnT5+WO3fuSJEiReSxxx6Tl156STJkyGDf/88//5Rhw4bJb7/9JunSpZOWLVvKpEmTJFu2bPZ99LUuUaKEuSj+/fffxdeXeDUApMQxCwDg3Ri3AMBzEJnxMGvWrJHmzZvL3bt37ev09u7du82ycuVKM33Nx8cnVsfTAOP9XLp0SZ555pko6/ft2yevv/66LFu2TDZs2CBp06aVa9euySOPPGI6der0uz179pjApWbMLFy40P7YsWPHmgDn7NmzCRACAAAAAAC4GTUJPcyHH35oDxA2btzYBOg++ugje7BPswt37NhhbmsGn3bcjLzUrl3bfjzNPowNDTq2aNHCZCcuX77cZApatm7dKl9//bW5rQFKzTRs2rSpeX6tvaUZL4sXL5Zbt27Zg4tan0ufW/cDAAAAAACAe5FJ6GF0epljbaygoCBze+bMmaZ2lrKCiLly5TKLo7Nnz9r302nJPXr0uO9z6lTijRs3OgUXNZtR62xZ2YEaKNSpzeHh4ea+ZhVawUUNYEZERJhpy/7+/jJkyBBTpP/dd9994NcDAAAAAAAAD44goYdp2LChrF692tx+7733TABOg3Va10+VLVtWHnrooWgf/+mnn5p6gurJJ5+01y+Mie7jGCC0aE1Bi1WTsGbNmua21jnU7p86BVoL9teoUcPUzvrhhx/k559/lldeeUWKFi0aj1cAAAAAAAAACY3GJR5WTFcz9QYOHGim/d67d89pm2YFaoOQyNmDFt2/cOHCprOm0gBeuXLl4nUeGmisWLGi7N+/39zXpiY6/VlpIFBrGJ45c8bcr1atmpmOXKhQIfN8Ou34wIEDJpior71K7q87ACQXnjRmAQDAuAUAnoOahB5Gp/GWKlVKsmTJEmWbZuj9+uuv0T520aJF9gChZiTGN0CoU4f79u1rDxB27NjRHiBUbdq0kb///ttkEmpzEp2KXLJkSZk8ebLJepwwYYKcP39eHn74YfN76FKvXj05evRovM4HAAAAAAAAD4YgoYd57bXX7N2Cn3vuOfPN3K5duyR37tym3uBjjz0mx44dc/lYbXBi0WzE+GYQPvHEE/Lll1+a+xros2470lqEgYGBkiNHDnNfswrffPNNqVOnjnl89+7dTUdk/R100ZqHug4AAAAAAABJj+nGHjZ1K3/+/KZ7sDp37px9avGzzz4r06dPN7enTZtm7js6ePCglC5dWmw2m+TLl0+OHz8uvr5xK0mp04Q7deokS5YsMfebNGlishOteoQx0anQOuX4t99+k5w5c5qpxwUKFJCTJ0+a7Xrbyj7U4CIAwPPHLAAAGLcAwHOQSehhtAmI5fr16/bb165dc7neMYtQA4Tq6aefjnOAUI/ZqlUre4Cwbdu28uOPP8YqQLhlyxaZNWuW6X5ctWpVk/GoChYsaN9Hg4bK2gYAAAAAAICkQ5DQwzjWEezfv7/89NNPJnNw3rx59vWVK1d2eszNmzdNoxOl3ZD1ca7oNGWdJqyL1iy0/Pvvv9KsWTN7V2VtWDJkyBBTa1CnDOty6NAhl8fUwKROJ9Zsl7feesus0+YpSusVWqzbVrAQAAAAAAAASSdu6WRwu3Hjxkm7du1Mp2LtKKyLI50CrAE9RzrNV6elqQ4dOkiePHni9Jw6rVmzAS1//PGHNGrUyGmfnj172gORjnSdBhPfffdd+9Ro/amZiDpV+bPPPjNBSQ0y6u8VXWdmAAAAAAAAJB6ChB7m0UcflXXr1sk777xjAnc6/Vg7HpcoUUIef/xxGTp0qAm6ObJqFT5Iw5L40CnQwcHBphvz4MGDnbaFhISYcx05cqQ9yKjdjwEAAAAAAJD0aFxCEXgAgAehADwAwJMwbgGA56AmIQAAAAAAAODlCBICAAAAAAAAXo4gIQAAAAB4ofHjx0v16tUlU6ZMpoGgNhI8cOCA0z63bt0ydc2zZ88uGTNmlI4dO5rGhgCAlIfGJQmkZN8LCXUoJLKDn+XgNQYAAIDX04aIGgDUQOHdu3fllVdekebNm8vevXslQ4YM5vV54YUX5Mcff5R58+ZJQECADBo0SDp06CAbN270+tcPAFIagoQAAAAA4IWWLVvmdD80NNRkFG7fvl3q168vYWFh8vnnn8vs2bOlcePGZp+QkBApU6aMbNmyRWrVqhXlmOHh4WZxbFwCAPAMTDcGAAAAAJigoMqWLZv5qcHCO3fuSNOmTe2vTunSpaVgwYKyefPmaKcwa8ahtQQGBvLKAoCHIEgIAAAAAF4uIiJChgwZInXr1pXy5cubdWfPnpW0adNKlixZnPbNnTu32eZKcHCwCTZay8mTJ5Pk/AEAD47pxgAAAADg5bQ24e7du2XDhg0PdBw/Pz+zAAA8D5mEAAAAAODFtBnJkiVLZM2aNVKgQAH7+jx58sjt27flypUrTvtrd2PdBgBIWQgSAgAAAIAXstlsJkC4YMECWb16tRQpUsRpe9WqVSVNmjSyatUq+7oDBw7IiRMnpHbt2m44YwBAYmK6MQAAAAB46RRj7Vy8aNEiyZQpk73OoDYcSZcunfnZp08fGTp0qGlmkjlzZhk8eLAJELrqbAwA8GwECQEAAADAC02fPt38bNiwodP6kJAQ6dWrl7k9efJkSZUqlXTs2FHCw8MlKChIPvroI7ecLwAgcREkBAAAAAAvnW58P/7+/jJt2jSzAABSNmoSAgAAAADwgAoXLixjx47ldQTgsQgSAgAAAAAQT/fu3ZPDhw+b6dhHjx6VgwcPyt27d532WbdunanvWKZMGTN928fHxyxr1651ecx9+/ZJ9+7dpWDBgpI2bVpTI7JUqVLy/PPPm+7SAJAYCBICAAAAABAP3377reTLl09KlChhGr98+eWXJpinjV6GDRtm3087SM+cOVP2799/32neuk+NGjXk66+/lpMnT8qdO3fk1q1bJvg4ZcoUqVOnjty4cYP3C0CCI0gIAAAAAEAc/fnnn/Lkk0/K+fPno2y7du2abN++3X4/d+7c8thjj8m7774rJUuWjPG4n3zyiVy/ft3crlSpkixevFi++uoryZIli1n3119/ybJly3i/ACQ4GpcAAAAAABBH8+fPN1l+Oh148+bN0qFDBzNFuHfv3rJlyxaT+WcJDg623547d26Mxw0LC7Pf7tevnzz66KPm9qJFi+S7774ztyNPZwaAhECQEAAAAACAOLIyCLUDdNmyZf93ge3rK8WKFTNLfDVs2NBMTVaffvqpaYhy+fJlWblypVmXK1cuad68Oe8XgATHdGMAAKKxfv16ad26tak1pMXFFy5c6LS9V69e9sLj1vLII4/c9/WcNm2a+R9+vaioWbOm/Pbbb7wHAAB4GGva8NWrV6VixYryzz//mCnGmlUYERER7+NqNqJmHvr5+cnvv/9uMgl1WvOVK1fM7U2bNknWrFkT8DcBgP8hSAgAQDS0KLjWAtKgXnQ0KHjmzBn78s0339y3wPnQoUNlzJgxsmPHDnP8oKAgl/WMAABA8vXUU0+Z7sPq0KFDcvPmTVmyZIlpLFK8eHFZsWJFvI6rXzpqIxStYxjZhg0bZPXq1Q987gDgCkFCAACi0aJFC3njjTekffv20b5G+i1/njx57Mv9vtl/7733TH0hrVekU5NmzJgh6dOnt08riiw8PNxkKDguAADA/TJlyiTbtm2TESNGRJlefPToUdOo5Ny5c3E+bmhoqAlAnjhxwhzj4sWLcvjwYSlTpozJJuzfv7/JJgQArwoS3rt3T0aNGiVFihSRdOnSmX94X3/9daeW8Xp79OjRkjdvXrNP06ZNzbc4AAAkhbVr15raQKVKlZIBAwaY/5GPzu3bt800JB2rLKlSpTL3dWqSK+PHj5eAgAD7EhgYmCi/BwAAiLucOXPKhAkTTBCvUKFC0qVLF9PAROkXe8uXL4/zMbUOoeXFF1+UbNmymWthLXNiiVwCBQBSfJBQ/7GdPn26TJ06Vfbt22fuT5w4UT788EP7Pnp/ypQpJhPj119/lQwZMphpW7du3XLruQMAUj6davzll1/KqlWrzBi1bt06k32oX3K5cuHCBbMt8vQhvX/27FmXj9GaRNrl0FpOnjyZKL8LAACIm2PHjjklsCj90lATWyzxySTU/1+wXL9+3X772rVrLtcDgFd0N9YU6rZt20qrVq3MfS3yrrWerALv+g/y+++/L6+++qrZT+nFml5s6Tcr+i1OdFO3dLEwdQsAEB+O40yFChVM0XL9pl+zC5s0aZIgL6pOZ9YFAAAkL2PHjpWtW7eaDD/9/wC9xtRpxpMnT7bvY01D3rt3r1nUpUuX7Nv1C0YrKKhTi1W5cuXk4MGD5vawYcNk3LhxprvxRx99ZH9c5cqVk+i3BOBNknWQUAu+fvLJJ+YfSO0cpZ2dtFCr1nNS+g+wZl44TtvSqVjaKVKnbUUXJNSpW6+99lqS/R4AAO9QtGhRyZEjh5ly5CpIqNtSp04dJatA72s9QwAA4Fk08Kc1CS2atGLRa1idYaDmzp3r8hpUA40WKytx5MiRZpqyNkLZtWuXtGnTxukxGkTUbscA4FXTjV9++WUT6CtdurSkSZNGqlSpIkOGDJFu3bqZ7dbUrLhM21JM3QIQmWYqaye5mBbNDotMv6zImDGjfZ9atWrF+sXVb51jej6dwmL5888/pXnz5pIlSxZTg7VPnz5O30IrnYqqtfH0fxzv3r3Lm+wGp06dMjUJ9T1yJW3atFK1alUzPdkSERFh7teuXTsJzxQAADyoV155RV566SWpVKmSvXGZ/j+cfin4+OOPy08//WTq5seV/r+CltLS616tRazXwv7+/ua6WAOSmjgTn+MCgEdnEuq3LV9//bXMnj3bXPTqtygaJMyXL5/07Nkz3sdl6haA+ND/QYvs6aeflhs3biTqC6r1Z7T2nXazmzdvnuzZs8f8D6IGoxyLVus30f/884/5N9PXN1n/8+4xtN6PZgU6BoV1LNIC4rpoRkDHjh1NFuCRI0fM+1K8eHFTG9eiGYXaHXnQoEHm/tChQ80YVq1aNalRo4Ypm6GfIe12DAAAPIdmCr799ttmsb501i+BHbMDLbrO1frolC9fXmbNmpWg5wsA95OsryK1k5OVTai0zsPx48fNdGG9wLKmZuk0LcesDb1PjQYAcfHdd99FaXi0f/9+6devn7mt/8ZoQMfRF198IStWrDDf7D5IsyT9t0yDf5FZ/65pfdbTp0+bqSYtW7Y001befPNNWbx4sXlefX5t7qRNntq1a+dUggEPZtu2bdKoUSP7fQ3wKR2DtLHWH3/8YT4HGsDVL7A021OLlTvWENTgoWMB8s6dO5tg7ujRo03Wu45Xy5Yti5IVj+RJL/Cs6WIhISFOnSYBAAAAT5asg4RagyFVKucZ0VrLSadmqSJFipiLa52mZQUFtQmJpmYPGDDALecMwDNpVldk3377rf12//79nTIJz58/bwJGOqVEmyfpEl8aUKpXr160261GSzpVVelz6rnov4W3b982QULNstZ/H9999914nweiatiwYZSuhY60XtD9OE4bt2hWoZVZ6Gl0mvukSZNM8FqLtf/777/2wGloaGiU/TW7QoOgWl9Ys191XC9YsKA0a9bMfBFYoECBWL8XWtw9OjG9TwAAJAVXYz4AeJJkHSRs3bq1yZbRiwmdbrxz507TtOSpp56yXyjrhfEbb7whJUqUMEHDUaNGmWwOzaYBgPjS6Z9W4WmduqtBQkfPPfecCZYMHDhQ6tat+0Av9JkzZ0zWoFXLTrMFNcvMyiTUZkwZMmQwNRFPnDghu3fvNplpmtmYOXNm+eGHH+Tnn382dXG0cQaQmPQzaE2rio3PPvvMZFM60oChLvPnzzf1NrNnzy6eQv8fxMrW1WlmAAAAQEqRrIOEH374oQn6PfvssyZrR4N/Wv9LL54tWv9JL+b1Al6ne2k2jmYsaGYNAMSX1oDRzGSl9eT03x+LTvPVLEMtJK3lD7Zv3/5AL7RmA1rNljQAM2PGDPMcv/32m3lenYaqdQafeeYZKVSokD3z8auvvjJZhprRmD9/fhMkVNZ5awARSGia0Vq/fn2pU6eOGZtnzpwZ4/46LuvYrQE1DXZrtr9O171z544JkOtUf90eWzpzQP//wF30i0tdAAAAgJQmWXc3zpQpkynornUIdTqTZiJo1qA15c7KJhw3bpy5wNbaXCtXruSbfQAP7KOPPrLf1mxBxyYi+sWF0mCe/jsVX9qpuG/fviYgqZmAEyZMsAf2/v77b6cvRLQeoa7TIKLWs9Npnhp0mTx5svm3UR+rAZuHH37YHFcXDc5oow0gIZUtW9ZM+9UAefXq1e+7v05B1hrDbdu2NRl4I0eONNmyjn9TcREQEGA+25GXuHYx1/+3ePTRR03gUoPv1t+8Zuzq76VfNurfmDZRi1yT0DqG4/Rqx2Pr/5M8+eSTptOl/huhdSgjdyMHAAAAkptknUkIAO6wYcMG05BCaamDBg0a2LdpYOTUqVPStWtXp0BHfOiXII60RlvOnDntJRV++uknp+0afNDsRYtmYWlJBs3oeuKJJ0ygROvEPf/882b7Bx98IN27d5eNGzc+0HkCCUW/8NNMQv2cWhwbw8SGZu7myJHDBBc1o08zfbUmaFwzZ7XrtDUNWoPv+mXAyZMnTVkTze5Vhw4dMn/rlSpVklKlSsX62FqC4K+//rLf10Cj1hGlSyUAxE/Jvv81AEPyd/CzHO4+BQApMZMQAJJTFqHSLsPqm2++sWcNOQY5NACi6yIHAGPLsYOyZgzG5KWXXjINnqZMmWKCGxp40SYQ+ty66BRkXafbAHfSMiD6d5E+fXrz96KfbW08plOVq1atGqdjXb9+3dTv1EDe4cOHTRMVDZDr+rjQRj8LFiywB9WV1lrULEKd7t+hQwezThsEaV3FuAZDNSCo/5ZYsx/mzJkjYWFhcToOAAAAkJQIEgKAA52y+/3335vbmpmkUwYTg9YN1CylyDTIaNFahNHZsmWLCUL07t3bBFmsmoaOtdKs+oXWNiA5sTp0x5YGFbVZmQbbNOio2YNWAE6bn8Q1MD916lTT5CxyZ/IvvvjCTEMODg62r9NgZFxocLBbt24yYMAAady4sVl37949ul4CAAAgWWO6MQA4+PTTT+1TDXv06CEZM2Z0en10Wq82TnCkAYRp06bZA3MayHCcoqwZVNa2Y8eOmdtan0ynMmu2knZy14Dgjh07zPRhi9Zwc8Vms5nuyhrEfOutt+z10CJnH1q3rWAh4C61atWSX375xQTHNRCuNTQ1w1VrcupnX4Ny96PBQUdBQUGSKlUqU5fYmp4fOeAXm6zdbNmy2ddpDcFixYqZ2zql2aKN0eLC8e/fsXNzXI8DAAAAJCWChADw/zTT55NPPrG/HlaDEkfNmzc3iyNtdGAFCa1sp9jQ7q7aJVmXyLT+mXaAdUWbJWjjknfffVdy5cpl1ulPDSouWrTITI3UwKRmKmqmlLUP4C5WIx1l1fK0gnvauTs2QcIHnZ7vqgGK0kCjJbq6hhqYjwsNNlp8fX3jfRwAAAAgKREkBID/t2TJEtPAQOkUwTJlyiTaa6P1Ar/66itTE+333383TUg0gKBZTNqIQbvBuuqcrM0adBqkBhEHDx7stC0kJESGDh1quseqnj17mu7HgLtobb506dJFWW9l18Y2u05rgepj8ubNG6/p+QAAAADujyAhAPw/zcSLT6ZPw4YNY3ycq21aj007D+sSFxo4jK7GoGYvaaAQSEzaLGfp0qXm9s6dO+3rjx8/Lt999525rc0/dJq7ZslqrUDtEFy6dGnx9/e3Tze2PPTQQ/bbOh2/SJEi9im7mqWrDh48KK1atTLH0WnGmgWo05cnTpx43+n5AAAAAGKHICEAAIhTc59OnTpFWa8BPSuop8HqXr16mduaKauLKxo4HDZsWKyDk59//rlZItOpzIMGDeJdBAAAAB4A3Y0BAECiNSzp37+/lC9f3mS6pk6d2tQnrFmzpmm689tvvznV74tOtWrV5OOPP5YWLVqYJj2akZghQwbT2fudd96RVatWmXUAAAAA4s/HRhVt021Rpy6FhYVFW7T8fkr2vfAAbwOS0sHP/utYCQDeOGYBAJBUuNbyPlxvAZ6L6cYAkrVps5a7+xQQSwO7B/FaAQAAAICHYroxAAAAAAAA4OUIEgIAAAAAAABejiAhAAAAAAAA4OUIEgIAAAAAAABejsYlAAB4oZJ9L7j7FBBLdIkEAABAUiCTEAAAAAAAAPByBAkBAAAAAAAAL0eQEAAAAAAAAPByBAkBAAAAAAAAL0eQEAAAAAAAAPByBAkBAAAAAAAAL0eQEAAAAAAAAPByBAkBAAAAAAAAL0eQEAAAAAAAAPByBAkBAAAAAAAAL0eQEAAAAAAAAPByBAkBAAAAAAAAL0eQEACAaKxfv15at24t+fLlEx8fH1m4cKF92507d+Sll16SChUqSIYMGcw+PXr0kNOnT8f4eo4dO9Ycy3EpXbo07wEAAAAAtyJICABANG7cuCGVKlWSadOmRdl28+ZN2bFjh4waNcr8nD9/vhw4cEDatGlz39ezXLlycubMGfuyYcMG3gMAAAAAbuXr3qcHACD5atGihVlcCQgIkBUrVjitmzp1qtSoUUNOnDghBQsWjPa4vr6+kidPngQ/XwAAAACILzIJAQBIIGFhYWb6cJYsWWLc79ChQ2Z6ctGiRaVbt24mqBid8PBwuXr1qtMCAAAAAAmNICEAAAng1q1bpkZh165dJXPmzNHuV7NmTQkNDZVly5bJ9OnT5ejRo/Lwww/LtWvXXO4/fvx4k7VoLYGBgbxfAAAAAJLPdGPNejh+/LipyZQzZ05TX8nPzy9hzw4AAA+gTUwef/xxsdlsJvAXE8fpyxUrVjRBw0KFCsncuXOlT58+UfYPDg6WoUOH2u9rJiGBQgAAAABuDRIeO3bMXPzMmTNHTp06ZS6GLGnTpjWZEP3795eOHTtKqlQkKQIAvCdAqF+crV69OsYsQld0anLJkiXl8OHDLrfrF3B8CQcAAAAgscU6kvfcc8+ZDo86LeqNN96QvXv3mtpLt2/flrNnz8rSpUulXr16Mnr0aJMZsXXr1sQ9cwAAkkmAUGsMrly5UrJnzx7nY1y/fl2OHDkiefPmTZRzBAAAAIAEzSTMkCGD/PXXXy4vgHLlyiWNGzc2y5gxY0ydpZMnT0r16tVje3gAAJIdDeA5ZvjpF2W7du2SbNmymaDeY489Jjt27JAlS5bIvXv3zJdmSrdrhr1q0qSJtG/fXgYNGmTuDx8+XFq3bm2mGJ8+fdqMm6lTpza1DAEAAAAg2WcSauH02GZIPPLII9KhQ4cHOS8AANxu27ZtUqVKFbMorQ2otzVr/u+//5YffvjBlN+oXLmyCRpay6ZNm+zH0CzBCxcu2O/r/hoQLFWqlMlC1LF1y5Ytpr4vAABJaf369eaLq3z58omPj48sXLjQaXuvXr3MesdFr/UAAClTvBuXWPTC59dffzUZFJo5yHQpAEBK0bBhQ6f6u5HFtM2xnq8jresLAEBycOPGDVNS6qmnnoo2yUODgiEhIfb71MkFgJTrgYKE33//venEqAXXtS7TgQMHZNq0adK7d++EO0MAAAAAQIJr0aKFWWKiQcE8efLE+pjh4eFmsVy9evWBzhEAkHRSxbU2k6PXXntNfvvtN7Ps3LlT5s2bJyNHjkzocwQAAAAAuMHatWtNDXotkzFgwAC5ePHifctUBQQE2JfAwMAkO1cAQBIGCatWrSqLFi2y3/f19ZXz58/b7587d85eqB0AAAAA4Ll0qvGXX34pq1atkgkTJsi6detM5qGWmopOcHCwhIWF2RdtaAkASIHTjZcvXy4DBw6U0NBQM634gw8+kM6dO5tB4u7du5IqVSqzDQAAAADg2bp06WK/XaFCBalYsaIUK1bMZBc2adIk2unJ1C0EAC8IEhYuXFh+/PFH+eabb6RBgwby3HPPyeHDh82igcLSpUuLv79/4p0tAAAAAMAtihYtKjly5DDXf9EFCQEAXjLd2NK1a1fZunWr/P7776bzY0REhFSuXJkAIQAAAACkUKdOnTI1CfPmzevuUwEAJIfuxkuXLpV9+/ZJpUqV5LPPPjN1Kbp162ZqU4wbN07SpUuXGOcJAAAAAEhA2phSswItR48elV27dkm2bNnMoo0qO3bsaLobHzlyREaMGCHFixeXoKAg3gcA8PZMwmHDhknv3r1NFuHTTz8tr7/+upl2vGPHDpNFWKVKFfnpp58S72wBAAAAAAli27Zt5hpOFzV06FBze/To0ZI6dWr5448/pE2bNlKyZEnp06ePaWT5yy+/UHMQAFKoOGUSalOSn3/+2QwOly5dklq1asmoUaNMR2MNGOo0ZA0ealYhAAAAACD50tJRNpstxsaVAADvEadMwgwZMpgUdKWt7CM3KSlbtqz5ZgkAAAAAAABACg0Sjh8/Xnr06CH58uUz04w1exAAAAAAAACAF0031gYljzzyiPz1119SokQJyZIlS+KdGQAAAAAAAIDk2d04e/bsZgEAAAAAAADgZdONn3nmGTl16lSs9v3222/l66+/loTw999/S/fu3U1gMl26dFKhQgXThcuihXa1+1bevHnN9qZNm8qhQ4cS5LkBAJ5p2bJlsmHDBvv9adOmSeXKleWJJ56Qy5cvu/XcAAAAAMCjg4Q5c+aUcuXKScuWLWX69OmydetWE8C7ePGiHD58WH744QcZMWKEFCxYUCZPnmyCeQ9KL+Tq1q0radKkkZ9++kn27t0r7777rmTNmtW+z8SJE2XKlCkyY8YM+fXXX01zlaCgILl169YDPz8AwDO9+OKLcvXqVXP7zz//lGHDhpnxS5tvDR061N2nBwAAAACeO91Ym5QMGjRIPvvsM/noo49MwM5RpkyZTBbfJ598YuoWJoQJEyZIYGCghISE2NcVKVLEKYvw/fffl1dffVXatm1r1n355ZeSO3duWbhwoXTp0sXlccPDw81isS4kAQApgwYDy5Yta25///338uijj8pbb70lO3bsMMFCAAAAAMADdDfW4NvIkSNNVsaFCxfMxdbGjRvlwIEDJuvvu+++S7AAodLsxGrVqkmnTp0kV65cUqVKFfn000+dLgLPnj1rgpOWgIAAqVmzpmzevDnGLs26n7VoIBIAkHKkTZtWbt68aW6vXLlSmjdvbm5ny5aNL4YAAAAAD1K4cGEZO3asu0/DK8QpSOhIp/xWqlRJatWqJcWLFxcfH5+EPTMR00VZpzZrJ+Xly5fLgAED5LnnnpMvvvjCbNcAoRW8dKT3rW2uBAcHS1hYmH05efJkgp87AMB96tWrZ6YVaxb8b7/9Jq1atTLrDx48KAUKFOCtAQAAAJK5e/fumfJ2OhNUk8T0/+Xv3r3rtM+6deukT58+UqZMGUmVKpWJTemydu3aKMfT/hUabGzYsKEplefn52diW02aNJFFixYl4W+WAoOESSEiIkIeeughM0VMswj79+8v/fr1M/UHH4R+EDJnzuy0AABSjqlTp4qvr6/JcNcvm/Lnz2/Wa33bhMx4BwAAAJDwtCFuvnz5TNKYJoFpablSpUqZmUFab9yyYMECmTlzpuzfv9+UpIuJliF67bXXTGBRk8Vu374tV65ckdWrV0u7du1MOTtvF+uahO6gHYutmlIWjQ7rG6vy5Mljfp47d87sa9H72sUSAOCd9JvBJUuWRFmvjbUAAAAAJF9a4u7JJ5+UO3fuRNl27do12b59u9NM0scee0xq164tH3/8sck2jImWnOvVq5cpW6fH114Y2gRXjRw50iSmaUNcb5Wsg4Ta2VjrHTrSN7xQoUL2JiYaKFy1apU9KKhNSPQN1qnJAADvdeTIEdP4Sn9+8MEHpratZhJqALFcuXLuPj0AAAAALsyfP98E8LTOuPab6NChg3Tv3l169+4tW7ZscQoEajk5y9y5c2N8PTUwqDNUNRvRUr9+fRNX0mnMN2/elD179kiNGjW89n1J1tONX3jhBfMB0OnGOg999uzZpnvywIEDzXadZz5kyBB54403TJMTjTb36NHDpKRqqigAwDvpFIIKFSqYL430fzKuX79u1v/+++8yZswYd58eAAAAgGicP3/e/PT397fPLtVSQsWKFZNu3bqZKcPxoY1xHQOEKnv27KYuoSWDF2cRPlCQUKOs2jFS0zk13VOdPn3afiGWEKpXr27ml3/zzTdSvnx5U4Be54jrh8IyYsQIGTx4sIkG6/76/MuWLTMfJgCAd3r55ZfNF0grVqww30BaGjdubL58AgAAAJA8lSxZ0j5TtGLFivLPP/+YKcaaVai9KxLSL7/8Yo5vdVEuU6aMeLN4BQmPHz9uMjTatm1rsvqsF1Tncg8fPjxBT/DRRx81GYK3bt2Sffv2mfnhjjSbcNy4caaQpe6jgUvrAwUA8E46brRv3z7Kep1yfOHCBbecEwAAAID7e+qpp0yJIKsjsU4D1nrjderUkeLFi5tEgISgHZOtJDSNLU2ZMsV0SPZm8frtn3/+eZOmefnyZUmXLp19vV6QaX1AAADcKUuWLHLmzJko63fu3GnvdAwAAAAg+cmUKZNs27bNzBzVKcaRA3vaqEQb1j4ITUJ7+OGHTZdjpTXMW7duLd4uVXzTMV999VWnKVxWaubff/+dUOcGAEC8dOnSRV566SWTZa7fCuq0hI0bN5psd61dCwCAp1u9erUMGjTIzLzSC9vnnntO1q9f7+7TAoAEkTNnTjNbVftTaPNa/f97bWBiTUNevnx5vI+tiQMNGjQw8Su9Vpg2bZopY4d4Bgn1YuvevXtR1p86dcpEfAEAcCdteFW6dGkJDAw0tWq14LF2LtMpCvolFwAAnuyZZ54xXTq1dvvFixdN+aevv/5aGjVqxIUuAI937NgxsdlsTutKlSpl+lRY4ptJuGnTJvNvpf67qc1QvvzyS3n22Wcf+JxTCt/4PKh58+amgYh2GlYaedWLMO0Y2bJly4Q+RwAA4kQz3T/99FMZPXq0qU+oY1SVKlWkRIkSvJIAAI+mjR1DQkJk5syZ0rNnT3MtZiVyhIaGyoABA6RZs2bSpk0bd58qAMTL2LFjZevWrdKrVy/TDyM8PNxMM548ebJ9H2sa8t69e82iLl26ZN++bt06ey1ynZ6sNmzYII888ojcuHHD3B8yZIiZEavrLRUqVJCAgACvfefiFSR85513zAurmRnaLOSJJ54wxSRz5Mhhvs0CAMCdtKGVTi3WTEJdLP/++69MmjTJBA8BAPBEGiAcOnSouXh2pMX2tdj/gQMH5PPPPydICMCjaeBPaxJaNOPPos1qW7RoYW7PnTtXXnvtNZeBRouVlaiNbq0AoRXb0sXRmjVrpGHDhuKt4jXdWC+4fv/9dxk5cqS88MILJjvj7bffNvO6tXMkAADupP+joNmDkWlnNFf/EwEAgKfYsWOHaRgZHa3ZtX379iQ9JwBISK+88oqpL16pUiXJmjWrWadZ05qY9vjjj8tPP/3k1EQXCcfHFnmi933cuXPH1HnS9tNlypSRlECLXmo6aVhYmGTOnDlexyjZ939prEj+Dn6Ww92ngDiYNiv+BWmRtAZ2D0o2L7lmU2idEi14HLnIe+fOnU0NEm8esxTjludg3ALgyN/fX/766y/Jly+fyxdGC/EXL17cZM8nB1xreR/GLSQ0nRKs2dOO2YFIJtON06RJY6YYAwCQ3Og3jfotoy46DcGq06S04ZZmF2qxdwAAPNXt27fNNVl0tBC/7gMAQJLUJBw4cKBpRf3ZZ5+ZQQgAgORAm2ppgrzWZNJpxY5Fh7WZiX4LWbt27Vgfb/369aaGoU7bOnPmjCkW365dO/t2fS5t2qVNUq5cuSJ169aV6dOn37dByrRp08xxz549a6ZRfPjhh1KjRo14/tYAAG8zatQoSZ8+vcttWloDAFJat2MkjXhF+LTLzKpVq+Tnn382nV8yZMjgtH3+/PkJdX4AAMSadnlURYoUkTp16sSYaREbWthYg3gadNQaT5FNnDhRpkyZIl988YV5Tr1oCwoKMoWWdTqYK99++60pOD9jxgypWbOmCWzqY7TQPHV9AQD3U79+fTNm3G8fAACSJEiYJUsW6dixY3weCgBAotOAnWb+RadgwYKxOo52TbM6p0WmWYQa4Hv11Velbdu29q5ruXPnloULF0qXLl1cPu69996Tfv36Se/evc19DRb++OOPMnPmTHn55Zej7B8eHm4Wx9pOAADvtXbtWnefAgAghYpXkDAkJCThzwQAgASi04od6xFGpvUJH9TRo0fNdOGmTZva1+n0Zs0O3Lx5s8sgodaI0qnLwcHBTk1W9Bj6GFfGjx9PR2YAwH3dvXvX1I7PmDEjrxaAWKFJpGcZmASNIlM9yIO1O+SGDRvM4smdIgEAKcvOnTtlx44d9uXXX381GXvazGTevHkJ8hwaIFSaOehI71vbIrtw4YIJUMblMRpQ1E7G1nLy5MkEOX8AgGdavHixhIaGOq178803TXBQZ3w1b95cLl++7LbzAwB4WSah1mgaPHiwmVYVERFh1qVOnVp69Ohhiq9HV0QXAICkoHUEI6tWrZrky5fPNAxxVV8wufLz8zMLAABW2YrHHnvM/mJs2rRJRo8eLePGjZMyZcrIyJEj5fXXXzf7AQCQ6JmEWnB93bp15lss7eaoy6JFi8y6YcOGxeeQAAAkulKlSpnmWwkhT5485ue5c+ec1ut9a1tkOXLkMF+qxeUxAAA42rNnj2nOZfnuu++kWbNmJjioX4K9++675joNAIAkCRJ+//338vnnn5ti7pkzZzZLy5Yt5dNPPzWDFAAA7qTNPRwXnaa7f/9+02SkRIkSCdYcRQN7q1atcnpendpcu3Ztl49JmzatVK1a1ekxmpGv96N7DAAAjq5duybZs2e339fST02aNLHfL1eunJw+fZoXDQCQNNONb968GaWeksqVK5fZBgCAO2lNpsiNS7QbcWBgoMyZMyfWx7l+/bocPnzYqVnJrl27JFu2bKZD8pAhQ+SNN94wgUcNGo4aNcpMaW7Xrp39MXrh1r59exk0aJA9G79nz55m+nONGjVMh2Qt42F1OwYAICb58+eXffv2mXFIx6nff/9dJk+ebN9+8eJFyj8BAJIuSKjZDmPGjDE1Cf39/c26f//913RfJBMCAOBua9ascbqvHYRz5swpxYsXF1/f2A9927Ztk0aNGtnva4BPaZBPi8aPGDHCBPj69+9vSm/Uq1dPli1bZh8b1ZEjR0zDEkvnzp1Nsy+tH6XNSipXrmwe4+rLNwAAIuvUqZP5kuqVV16RpUuXmqz2WrVqOY1dWl4DAIAkCRJ+8MEHEhQUJAUKFLAXh9dvsPSiaPny5fE5JAAACaZBgwYJcpyGDRuaDMToaLaiForXJTrHjh2Lsk6zCq3MQgAA4kK/ZPr777/lueeeMwHCWbNmmXq3lm+++UZat27NiwoASJogYfny5eXQoUPy9ddfmxpPqmvXrtKtWzdJly5dfA4JAECC0nFKMwrPnz9v6v5FvsACAMAT6fWWzuiKbTY9AACJGiRU6dOnl379+sX34QAAJBptpDVgwADTTVizLBzrE+ptgoQAAE+VNWvWKHV3VUBAgJQsWVKGDx9uuh0DAJAkQcLx48eb2klPPfWU0/qZM2eaOksvvfRSfA4LAECC0GYib775JuMRACDF0YZXrmht3O3bt8ujjz4q3333HVOOAQBJEyT8+OOPZfbs2VHWlytXTrp06cJFGQDArS5fvmwKuwMAkNJo86yYaEMsTeqgLiEAIEmChNqNMW/evFHWa+fIM2fOiKfSmlVW3SpN4ddFC9Y7Fq231kdE6Lr/1vumFrl7TyRdWt3nv2OG3xG5FyGS3s/5uW7dFtFDRF5/M1wklY+If9qo61OnEvFL8986Pa1/b//vudM6vJP6K9y6I5ImtUgah/V6frfv/m9ffYzlzl2RO/dE/NNoB9D/1uu+KfF3+t/xnN+//95X57pl1lSOyI0LoluvHVQjf2ZEfCRVKp9Yr4/rZ+/+6z37d/LVD8n/uxcRYT4jjuvUXf1AStzW66+b2uHDoc9+z6z3kdT6gbXW2/73vKl8/ve7WSJsNnN+uk632ddH2Mw2Pbbj3829iP/97qlTpxLHCUIp6XeK/O9nXD97rqZOxZcGCH/++Wd55plnEuyYAAB4As0k1Ix6AACSJEgYGBgoGzdulCJFijit13X58uUTT3Xun8ty89b/okjp0/lJloBMEnb1utz8N9y+T8YM6SRzpgxy+cpVCb99x74+qLLIj9tFPnpapEju/475YqjI1sMi814UyeD/3/peU0TOh4ksHeV8Di1fF8kVIBL63H/rbtwSafWGyENFRSb1+m/90XMivT/833O/2P6/9b8dEhnxhUi3BiK9Gv+3/sdtIpMWijz/qEirav+tD139v2XcEyI1Svy3ftKClPk7qQuXrshdjTD+v2xZM4u/X1rzGXAMYOTMnsUEQM6ev+T0O+XJlc0EX/65eMW+TgMceXNnN5+LS5ev2tf7+qaWXDmyms+Rfp4sfmnTSPZsAXLt+k25fuNf+/q4fvYCMmeUDOn9U+zv1LpRFfv6jTsOyflLV+WRhytKGoeo8MrNe+TfW7ed9lWL1+yUdP5ppWntcvZ1d+7ekyVrd0nOrJml7kP/fTiuXv9XVm3ZKwXzZpOHyha2rz93MUw27TwsJYvkkTJF//v37djfF2TnvuNSqVRBKZw/h339vr9Oy/6/zkjNSkUld/YA+/ode4/J8dMXpWH10pI5Y7oU+TtZn6n4fvbSOH4D8ICKFy8uo0aNki1btkiFChUkTRqHbyNETEdIAABSovDwcEmbNtK38wAAxIKPLXJKRyxMnDjRLJMmTZLGjf8XsVm1apWMGDFChg0bJsHBweJJrl69agr96vS0zJkzxyvzqfyASyky6y4l/k57P86RYrPuUuLv9Om3K1Nk1l1K/J36dW6SbDIJI3+JFfn5/vrrL/FU1pgVFhZmH7Pio2TfCwl6Xkg8Bz/7L2gPAPczZMgQ2b9/vyxbtizFjFuMWZ6FcctzTJu13N2ngDgY2D1IElu80jZefPFFuXjxojz77LNy+/Zts87f39/UIvS0AGHkYIgujqyL3aj76rr/1lsJXBrgckUDYrFdr/ESV+s1NuBqvT63QwKZnQbJdIlMA2XWtFtHGoRzJSX+TpHfv//WO7//luiCF67WR/eZSaj10Z97yvydrKCYI1fr4rpe41Su19vk7r2o352YAJqr9RpAcwhwWjQI58q9BDj35Po7Rf6sxfWzl5COHj2a6M8BAIA7DB061OV6DcLt2LFDDh48KOvXr0/y8wIAeL54BQn1Am/ChAlmKte+ffskXbp0UqJECfHzi5RCBgAAAABIMDt37nS5XrP0mjVrJvPnz48xox4AgOg8UAGojBkzSvXq1eX48eNy5MgRKV26dLSZIwAAJHZmxeuvvy4ZMmSINsvC8t577/FmAAA80po1a9x9CgCAFCpOQcKZM2fKlStXnC6++vfvL59//rm5XapUKVm+fLlpbAIAQFJnVty5cyfGLAsAAAAAQAIECT/55BN5+umn7fe1GG5ISIh8+eWXUqZMGRk0aJC89tpr8tlnn8XlsAAAJGhmBVkWAAAAAJCIQcJDhw5JtWrV7PcXLVokbdu2lW7dupn7b731lvTu3TuOpwAAQMJ46qmnYlVX18qABwAAAADEI0j477//OrWt37Rpk/Tp08d+v2jRonL27Nm4HBIAgAQTGhoqhQoVkipVqpiuzgAAAACARAgS6oXX9u3bzc8LFy7Inj17pG7duvbtGiAMCAiIyyEBAEgwAwYMkG+++UaOHj1qMtu7d+8u2bJl4xUGAAAAgPuIUyvinj17ysCBA033yE6dOpluxlWrVnXKLCxfvnxcDgkAQIKZNm2anDlzRkaMGCGLFy82jbQef/xx01SLzEIAAAAASKAgoV509evXT+bPny/+/v4yb948p+0bN26Url27xuWQAAAkKD8/PzMWrVixQvbu3SvlypWTZ599VgoXLizXr1/n1QYAAACAB51unCpVKhk3bpxZXIkcNAQAwJ103NJGJZpFeO/ePd4MAAAAAEiITEIAAJK78PBwU5ewWbNmUrJkSfnzzz9l6tSpcuLECcmYMaO7Tw8AAAAAPD+TEACA5EynFc+ZM8fUInzqqadMsDBHjhzuPi0AAAAASPYIEgIAUowZM2ZIwYIFpWjRorJu3TqzuKK1dQEAAAAA/yFICABIMXr06GFqEAIAAAAA4oYgIQAgxQgNDXX3KQAAAACAR0rQxiUnT540NaAAAAAAAMnb+vXrpXXr1pIvXz6Tib9w4UKn7TabTUaPHi158+aVdOnSSdOmTeXQoUNuO18AgAcFCS9duiRffPFFQh4SAAAAAJAIbty4IZUqVZJp06a53D5x4kSZMmWKqfn766+/SoYMGSQoKEhu3brF+wEA3j7d+Icffohx+19//fWg5wMAAAAASAItWrQwiyuaRfj+++/Lq6++Km3btjXrvvzyS8mdO7fJOOzSpYvLx4WHh5vFcvXq1UQ6ewCAW4OE7dq1M2noOmBEh4LxAAAAAODZjh49KmfPnjVTjC0BAQFSs2ZN2bx5c7RBwvHjx8trr72WhGcKAHDLdGOtRTF//nyJiIhwuezYsSPBTgwAAAAA4B4aIFSaOehI71vbXAkODpawsDD7onXrAQApMEhYtWpV2b59e7Tb75dlCAAAAABIufz8/CRz5sxOCwAgBQYJX3zxRalTp06024sXLy5r1qxJiPMCAAAAALhJnjx5zM9z5845rdf71jYAgBcHCR9++GF55JFHot2u3a4aNGiQEOcFAAAAAHCTIkWKmGDgqlWrnJqQaJfj2rVr874AgLcHCbV7MdOJAQD4n8KFC5tSG5GXgQMHunyJQkNDo+zr7+/PywkAcIvr16/Lrl27zGI1K9HbJ06cMGPUkCFD5I033pAffvhB/vzzT+nRo4fky5fPNLQEAHh5d+MSJUrImTNnJFeuXOZ+586dZcqUKVGK2QIA4A22bt0q9+7ds9/fvXu3NGvWTDp16hTtY7Q204EDB+z39SIMAAB32LZtmzRq1Mh+f+jQoeZnz549zRdbI0aMkBs3bkj//v3lypUrUq9ePVm2bBlfcAFAChWnTMLIWYRLly41g0ZSefvtt+3faFlu3bplMjayZ88uGTNmlI4dO0apmwEAQGLImTOnmYplLUuWLJFixYrFWHpDxzHHx/BFGwDAXRo2bGiu8SIvGiC0xqxx48aZbsZ63bVy5UopWbIkbxgApFBxChK6O1vj448/looVKzqtf+GFF2Tx4sUyb948WbdunZw+fVo6dOjgtvMEAHin27dvy6xZs+Spp56KMTtQp3YVKlRIAgMDpW3btrJnz54YjxseHm5qQDkuAAAAAODWIKFVPynyusSmF1TdunWTTz/9VLJmzWpfHxYWJp9//rm899570rhxY6lataqEhITIpk2bZMuWLdEejwsuAEBCW7hwoZmK1atXr2j3KVWqlMycOVMWLVpkAooRERFSp04dOXXqVLSPGT9+vAQEBNgXDS4CAAAAgFtrEmrquV78+Pn5mfuacv7MM8+YrsaO5s+fn6AnqdOJW7VqJU2bNjWFcy3bt2+XO3fumPWW0qVLS8GCBWXz5s1Sq1ataC+4XnvttQQ9RwCAd9MvrVq0aGEKukdHu0E6doTUAGGZMmVMpvzrr7/u8jHBwcH2GlFKMwkJFAIAAABwa5BQC9g66t69uyS2OXPmyI4dO8x048i0NkbatGklS5YsTuu1vpNuiw4XXACAhHT8+HFTpymuX5KlSZNGqlSpIocPH452H/1izvpyDgAAAACSRZBQp/ImpZMnT8rzzz8vK1asSNAOWlxwAQASko6PuXLlMlnvcaGdkf/8809p2bIlbwgAAAAAt0rWjUt0OvH58+floYceEl9fX7Noc5IpU6aY25oxqIXitQaUI+1urB0jAQBIbFpXUIOEmm2vY5OjHj16mOx1i3aI/Pnnn+Wvv/4yWfKaka9ZiH379uWNAgAAAOA5mYRJrUmTJibDwlHv3r1N3cGXXnrJ1GTSqVqrVq2Sjh07mu0HDhyQEydOONV8AgAgseg0Yx13tKtxZLo+Var/vo+7fPmy9OvXz5TE0EZc2nBLm22VLVuWNwiAx7MaGmoH92PHjrn7dAAAQEoKEmbKlEnKly/vtE6bpGTPnt2+vk+fPqage7Zs2SRz5swyePBgEyCMrmkJAAAJqXnz5qaxlytr1651uj958mSzAEBC06xkbc63fPlyOX36tGTMmFGKFSsm7du3d8poBgAA8MggYWzoxZZmaWgmYXh4uAQFBclHH33k7tMCAAAAksTGjRtNbVPtfm65dOmSfUmqIOEvv/xifiZkLXEAAJB0PC5IGDkrQ/8nZNq0aWYBAAAAvInW5u7UqZMJEKZOndqUNNAvzdOlSydHjhwxpXiSSr169ZLsuQAAgJc1LgEAAAAQvU8//VTOnDljbo8dO1amT58u7dq1M4HCZ599Vj744IP7vnyhoaGmnqAuegz98r1w4cKmzI9mKJ48eVJu3bolzz//vOTIkcOUBOrcubPJUnRkHUMfG92xZ82aZcoG+fn5ScmSJWXu3Lm8vQAAJBMel0kIAAAA4H8WL17s1G29QoUKcvjwYcmVK5c88cQTMmbMmDhN/9UgnmYgWn766Sd59NFHpWjRorJw4UL7eg3uaQNB3T+2vvrqK9Pd3XLo0CHp2rWrVKpUSUqVKsVbCgCAm5FJCAAAAHiovXv32m9rQHD37t0m60+7q7/99tvStm3baJsruaIBwhEjRsiiRYskf/78Zt0ff/whS5YskXfeeUdmz55tpjKrOXPmSFhYWKyPrQFCbTqox2rSpIk9sPnZZ5/F4TcGAACJhSAhAAAA4ME1CS1Zs2aVL7/80ix6W/3888/yww8/xPp4derUkQkTJkibNm3MtGWLZvwNGzbM/GzcuLFZd+/ePTl27Fisj60ZgxoQbNWqlbz55pv29Zr5CAAA3I8gIQAAAOChtLafZcCAAfLkk0+a5ZlnnrGvX7lyZayPV6NGDfvtbNmy2W9Xq1bNflvrEroKUt5PgwYN7LezZ88er2MAAIDEQ5AQAAAA8FAFCxa03y5UqJDL29r5OLYCAgLst1Ol+u9SIXPmzC73j8tUZiu7Ufn6+sbrGAAAIPEQJAQAAAA8VN26de23tQ6hq9uBgYFJfl4AAMDz0N0YAAAA8FB9+/aVmTNnmmy86dOnS+nSpc36GTNm2Pfp2LGjG88QAAB4CjIJAQAAAA9Vq1YtGT58uLl96dIle01Cva1eeuklqVKlipvPEgAAeAKChAAAAIAHmzhxonzxxRdSvXp1SZ8+vVlq1qwps2bNkrffftvdpwcAADyEj41KwaaYsxZpDgsLi7Yo8/2U7Hshwd8cJI6Dn/3XkQ/J37RZy919Coilgd2DeK08ZMxSjFueg3ELgCfjWsv7MG55Dq61PMvAJLjeIpMQAAAAAAAA8HIECQEAAAAAAAAvR5AQAAAAAAAA8HIECQEAAAAAAAAvR5AQAAAAAAAA8HK+7j4BAAAAIKWgU6TnSIoukQAAeBIyCQEAAAAAAAAvR5AQAAAAAAAA8HIECQEAAAAAAAAvR5AQAAAAAAAA8HIECQEAAAAAAAAvR5AQAAAAAAAA8HIECQEAAAAAAAAvR5AQAAAAAAAA8HIECQEAAAAAAAAvR5AQAAAAAAAA8HIECQEAAAAAAAAvR5AQAAAAAAAA8HIECQEAAAAAAAAvR5AQAIB4Gjt2rPj4+DgtpUuXjvEx8+bNM/v4+/tLhQoVZOnSpbz+AAAAANyOICEAAA+gXLlycubMGfuyYcOGaPfdtGmTdO3aVfr06SM7d+6Udu3amWX37t28BwAAAADcyte9Tw8AgGfz9fWVPHnyxGrfDz74QB555BF58cUXzf3XX39dVqxYIVOnTpUZM2a4fEx4eLhZLFevXk2gMwcAAACA/5BJCADAAzh06JDky5dPihYtKt26dZMTJ05Eu+/mzZuladOmTuuCgoLM+uiMHz9eAgIC7EtgYCDvFwAAAIAER5AQAIB4qlmzpoSGhsqyZctk+vTpcvToUXn44Yfl2rVrLvc/e/as5M6d22md3tf10QkODpawsDD7cvLkSd4vAAAAAAmO6cYAAMRTixYt7LcrVqxogoaFChWSuXPnmrqDCcHPz88sAAAAAJCYyCQEACCBZMmSRUqWLCmHDx92uV1rF547d85pnd6PbU1DAAAAAEgsBAkBAEgg169flyNHjkjevHldbq9du7asWrXKaZ02LtH1AAAAAOBOBAkBAIin4cOHy7p16+TYsWOyadMmad++vaROnVq6du1qtvfo0cPUFLQ8//zzpn7hu+++K/v375exY8fKtm3bZNCgQbwHAAAAANyKmoQAAMTTqVOnTEDw4sWLkjNnTqlXr55s2bLF3Fba6ThVqv++j6tTp47Mnj1bXn31VXnllVekRIkSsnDhQilfvjzvAQAAAAC3IkgIAEA8zZkzJ8bta9eujbKuU6dOZgEAAACA5ITpxgAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAl8aOHSs+Pj5OS+nSpXm1ACAF8nX3CQAAAAAAkq9y5crJypUr7fd9fbmMBICUiH/dAQAAAADRXzT6+kqePHli9QqFh4ebxXL16lVeWQDwEEw3BgAAAABE69ChQ5IvXz4pWrSodOvWTU6cOBHtvuPHj5eAgAD7EhgYyCsLAB6CICEAAAAAwKWaNWtKaGioLFu2TKZPny5Hjx6Vhx9+WK5du+Zy/+DgYAkLC7MvJ0+e5JUFAA+RrIOE+i1U9erVJVOmTJIrVy5p166dHDhwwGmfW7duycCBAyV79uySMWNG6dixo5w7d85t5wwAAAAAKUWLFi2kU6dOUrFiRQkKCpKlS5fKlStXZO7cuS739/Pzk8yZMzstAADPkKyDhOvWrTMBwC1btsiKFSvkzp070rx5c7lx44Z9nxdeeEEWL14s8+bNM/ufPn1aOnTo4NbzBgAAAICUKEuWLFKyZEk5fPiwu08FAOBNjUs0pd2RprlrRuH27dulfv36Jn39888/l9mzZ0vjxo3NPiEhIVKmTBkTWKxVq5bL41JMFwAAAADi7vr163LkyBF58sknefkAIIVJ1pmEkWlQUGXLls381GChZhc2bdrUvk/p0qWlYMGCsnnz5miPQzFdAAAAALi/4cOHmxlbx44dk02bNkn79u0lderU0rVrV14+AEhhPCZIGBERIUOGDJG6detK+fLlzbqzZ89K2rRpTcq7o9y5c5tt0aGYLgAAAADc36lTp0xAsFSpUvL444+bWvA6aytnzpy8fACQwiTr6caOtDbh7t27ZcOGDQ98LC2mqwsAAAAAIHpz5szh5QEAL+ERmYSDBg2SJUuWyJo1a6RAgQL29Xny5JHbt2+b7lqOtLuxbgMAAAAAAADg4UFCm81mAoQLFiyQ1atXS5EiRZy2V61aVdKkSSOrVq2yrztw4ICcOHFCateu7YYzBgAAAAAAADyPb3KfYqydixctWiSZMmWy1xkMCAiQdOnSmZ99+vSRoUOHmmYmmTNnlsGDB5sAYXSdjQEAAAAAAAB4UJBw+vTp5mfDhg2d1oeEhEivXr3M7cmTJ0uqVKmkY8eOEh4eLkFBQfLRRx+55XwBAAAAAAAAT+Sb3Kcb34+/v79MmzbNLAAAAAAAAABSWE1CAAAAAAAAAImPICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAAAAAADg5QgSAgAAAAAAAF6OICEAAPE0fvx4qV69umTKlEly5col7dq1kwMHDsT4mNDQUPHx8XFa/P39eQ8AAAAAuBVBQgAA4mndunUycOBA2bJli6xYsULu3LkjzZs3lxs3bsT4uMyZM8uZM2fsy/Hjx3kPAAAAALiVr3ufHgAAz7Vs2bIoWYKaUbh9+3apX79+tI/T7ME8efIkwRkCAAAAQOyQSQgAQAIJCwszP7NlyxbjftevX5dChQpJYGCgtG3bVvbs2RPtvuHh4XL16lWnBQAAAAASGkFCAAASQEREhAwZMkTq1q0r5cuXj3a/UqVKycyZM2XRokUya9Ys87g6derIqVOnoq17GBAQYF80sAgAAAAACY0gIQAACUBrE+7evVvmzJkT4361a9eWHj16SOXKlaVBgwYyf/58yZkzp3z88ccu9w8ODjYZitZy8uRJ3i8AAAAACY6ahAAAPKBBgwbJkiVLZP369VKgQIE4PTZNmjRSpUoVOXz4sMvtfn5+ZgEAAACAxEQmIQAA8WSz2UyAcMGCBbJ69WopUqRInI9x7949+fPPPyVv3ry8DwAAAADchkxCAAAeYIrx7NmzTX3BTJkyydmzZ816rR2YLl06c1unFufPn9/UFlTjxo2TWrVqSfHixeXKlSsyadIkOX78uPTt25f3AQAAAIDbECQEACCepk+fbn42bNjQaX1ISIj06tXL3D5x4oSkSvVf4v7ly5elX79+JqCYNWtWqVq1qmzatEnKli3L+wAAAADAbQgSAgDwANON72ft2rVO9ydPnmwWAAAAAEhOqEkIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXI0gIAAAAAAAAeDmChAAAAAAAAICXSzFBwmnTpknhwoXF399fatasKb/99pu7TwkA4CXiOgbNmzdPSpcubfavUKGCLF26NMnOFQCA+OB6CwBSvhQRJPz2229l6NChMmbMGNmxY4dUqlRJgoKC5Pz58+4+NQBAChfXMWjTpk3StWtX6dOnj+zcuVPatWtnlt27dyf5uQMAEBtcbwGAd/Cx2Ww28XCatVG9enWZOnWquR8RESGBgYEyePBgefnll6PsHx4ebhZLWFiYFCxYUE6ePCmZM2eO1zlUGXTxAX4DJKWdU7PzgnuQT75d6e5TQCz179z0gV+rTJkyiY+PT4oegzp37iw3btyQJUuW2NfVqlVLKleuLDNmzEiSMUsxbnkOxi3PwrjlObx13ErssY5rLTBueQ7GLM/SPynGLZuHCw8Pt6VOndq2YMECp/U9evSwtWnTxuVjxowZo4FRFl4DPgN8BvgMJLPPQFhYmC2lj0GBgYG2yZMnO60bPXq0rWLFii73Z8xy/+eShdeAzwCfgZQybiXFWMe4xd8L/2byGeAzIB47bvmKh7tw4YLcu3dPcufO7bRe7+/fv9/lY4KDg83UMIt+E3bp0iXJnj27V3wTGFtXr1413xA+aLYKAP624vLNVkofg86ePetyf13vCmNW7DBmAYmDv62UNW4lxVjHuBU7/G0BiYO/rQcbtzw+SBgffn5+ZnGUJUsWt51PcqcBQoKEAH9bcA/GrLhhzAISB39biC3GLf62gOSAcctLG5fkyJFDUqdOLefOnXNar/fz5MnjtvMCAKR88RmDdD1jFgDAU3C9BQDew+ODhGnTppWqVavKqlWrnKYP6/3atWu79dwAAClbfMYgXe+4v1qxYgVjFgAgWeJ6CwC8R4qYbqz1BXv27CnVqlWTGjVqyPvvv286R/bu3dvdp+bxUwXGjBkTZWo2AP62EPsxqEePHpI/f34ZP368uf/8889LgwYN5N1335VWrVrJnDlzZNu2bfLJJ5/wsjJmAckO/z8IxfUWf1uAp2DcejA+2r1EUoCpU6fKpEmTTOH3ypUry5QpU6RmzZruPi0AgBeIaQxq2LChFC5cWEJDQ+37z5s3T1599VU5duyYlChRQiZOnCgtW7Z0428AAEDMuN4CgJQvxQQJAQAAAAAAAHhpTUIAAAAAAAAAD4YgIQAAAAAAAODlCBICAAAAAAAAXo4gIQB4oLVr14qPj49cuXLF3acCAMB9MW4BADzFWi++1iJImIC0q+XgwYOlaNGipu12YGCgtG7dWlatWuW0386dO6VTp06SO3du8ff3N50t+/XrJwcPHpTEot019UMeeXnmmWckufwBWkvOnDlNl88///zT3acGL5TYf8d79uyRxx9/3HzO9fglS5aU0aNHy82bNxP5NwOiYtyKH8YtJCeMW/AmjFvxw7iF5IIxK/kjSJhAjh07JlWrVpXVq1fLpEmTTIBr2bJl0qhRIxk4cKB9vyVLlkitWrUkPDxcvv76a9m3b5/MmjVLAgICZNSoUbF+vsKFC5t/7ONCAxhnzpxxWiZOnCiJ5d69exIRERHr/Q8cOGDOafny5eb1adWqldy+fTvRzg9I6r/jLVu2SM2aNc3n+scffzQBxTfffFNCQ0OlWbNmfN6RpBi3omLcgqdh3II3YdyKinELnoQxy0PYkCBatGhhy58/v+369etRtl2+fNn8vHHjhi1Hjhy2du3auTyGtV9sFCpUyLZmzZpY79+gQQPb888/H+322rVr20aMGOG07vz58zZfX1/bunXrzP1bt27Zhg0bZsuXL58tffr0tho1ajidQ0hIiC0gIMC2aNEiW5kyZWypU6c2j9VjnDlzxunYei716tUzt/UY+lF0/P1/+OEHs+7333+3r/vuu+9sZcuWtaVNm9b8/u+8845924cffmgrV66c/f6CBQvM46dPn25f16RJE9vIkSNj/ZrB+yTm33FERIT5/FarVs127949p227du2y+fj42N5++237Ov38fvrpp+Z50qVLZytevLj527I4/t3o+WbKlMk2b948p+Pq34H+rV69ejWOrwS8AeMW4xY8H+MWvAnjFuMWPBtjlmcgSJgALl68aC7w33rrrRj3mz9/vrmo37Rp0wM/Z0IHCadOnWorWLCgCWQ4Bt4c1/Xt29dWp04d2/r1622HDx+2TZo0yebn52c7ePCgPUiYJk0as8/GjRtt+/fvNwGVkiVL2iZOnGg/7u3bt02QZebMmS6DhFeuXLE98cQTZt2+ffvMum3bttlSpUplGzdunO3AgQPmuTRwoj/VH3/8Yd4DDWyqIUOGmOfo3Lmz/Tk1WLJixYo4vMrwJon9d7xjxw7zuNmzZ7vc3qxZM1ulSpXs93XfAgUKmP0PHTpke+6552wZM2Y05+nq76Zfv362li1bOh2zTZs2th49esTpPOEdGLcYt+D5GLfgTRi3GLfg2RizPAdBwgTw66+/mot1DR7EZMKECWa/S5cuuSVIqAG8DBkyOC2zZs1yyhrUAKBjduFLL71kbh8/ftxkBv79999Ox9XsvODgYHNbA3b6+2lWVOTfWzMLLd9//70JdljZWlawwzonva2LBjgsGjTUIIqjF1980WRmKQ1kZs+e3Z5JVblyZdv48eNtefLkMfc3bNhgfn8NWgLu+DueM2eOedzOnTtdbtcgoAa+Lbrvq6++ar+vfy+67qeffnIZJNTz17/R06dPm/vnzp0zf9Nr167lDUeSf95dYdxi3ELCYtyCN2Hc4noLno0xy3NQkzBhpmwn6H6uaIORjBkz2pcTJ05IixYtnNbdT7du3WTXrl1OS5s2bcw2baLQvHlzU19NHT16VDZv3mweo7Q2m9a80CYLjs+5bt06OXLkiP050qZNKxUrVnR63l69esnhw4dNPTal9de0cUOGDBmc9vvll19k+/btZrs+z4wZM+zbtOZb3bp1nfbX+4cOHTLnpQ1P6tevb+o0ageivXv3yrPPPmtqxu3fv9+cZ/Xq1SV9+vTxePXhDZLi7ziuj3f8W9K/l8yZM8v58+dd7lujRg0pV66cfPHFF+a+1kgsVKiQ+bsA4vs5ZNxi3ELyxbgFb8K4xfUWPBtjlufwdfcJpATa1VSDVBqMiokGvpTuV7t27Tg9x7hx42T48OFO3YonTJhgmiDEljZVKF68eLTbNSD43HPPyYcffiizZ8+WChUqmEVdv35dUqdObYJ4+tORY4AyXbp05rVwlCtXLtMdNiQkRIoUKSI//fSTy6Yrui1LlixSqlQpEwjp3LmzrF+/Pta/n74mn3zyiQk2VqlSxQRUrMChBgkbNGgQ62PB+yT237H1OA146+czMl1v7WNJkyaN0309v5iaAfXt21emTZsmL7/8svl76927d5S/R0AxbjFuwfMxbsGbMG4xbsGzMWZ5EHenMqYUjzzyyH0bHui25Nq4xDo/ne6rTUN0Gq9jEwWtA6gfF8fpyJFZjUtcWbp0qdmmNQVLlSrltM1V4xKdFpw1a1b7VLjophs7Niuxmj88+eST9mnSkydPtnXs2NH8XsuXL4/x9wcS8+9Yp8SXLl06To1LtPGII/0bsupwuvq70Smh/v7+tg8++MDU8Dx58iRvKqLFuMW4Bc/HuAVvwrjFuAXPxpjlGQgSJpAjR46Y+ncaXNMuvNrMY+/eveZiXQMDloULF5raeK1btzZNNI4ePWrbunWrCXhZTTYSK0iojQ20y7DjErnOVLdu3UzzBA1YaB3CyNsKFy5sagr+9ddfpq6ANnlYsmTJfYOEGhQJDAw0nYkdAyHRBTuUdluuUKGCCa5s377dqXFJaGioU+MSpftly5bN1GWz6rZp/Te9r7XZXAV+gKT8O9aGPtpARwOM+vejf2Nz5841fxva8Ec7iD9IkNAKqOvfmQ7CQEwYtxi34PkYt+BNGLcYt+DZGLM8A0HCBKQNAwYOHGgCeHqRrhlJ2nwjcjBPgwkdOnSw5cyZ03QHLl68uK1///6mg2liBgmthiCOS1BQUJSMP11fv379KMfQDsGjR482gUINkOTNm9fWvn1701n4fkFCNWrUKKfGCpbogh0nTpwwwb1vv/3W3NegjQZv9Lm167J2V46sbdu25jHXrl2zByc1I7FWrVqxfq3g3RL771j/XjS7VQPa+lkuVqyYaVASualOfIOEq1atMus1+Ai4+/PuiHGLcQuJg3EL3oRxi+steDbGrOTPR//j7inP8A59+vSRf/75R3744Qd3nwqQYn311VfywgsvyOnTp00jIQDxx7gFJD7GLSDhMG4BiesrL7jWonEJEl1YWJjpjqzNUAgQAonj5s2bcubMGXn77bfl6aefTrGDFpAUGLeAxMe4BSQcxi0gcd30omutVO4+AaR8bdu2lebNm8szzzwjzZo1c/fpACnSxIkTpXTp0pInTx4JDg529+kAHo1xC0h8jFtAwmHcAhLXRC+61mK6MQAAAAAAAODlyCQEAAAAAAAAvBxBQgAAAAAAAMDLESQEAAAAAAAAvBxBQgAAAAAAAMDLESQEAAAAAAAAvBxBQgAAAAAAAMDLESQEAAAAAAAAvBxBQgAAAAAAAEC82/8BtKRctZUrtoYAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 1300x450 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, axes = plt.subplots(1, 3, figsize=(13, 4.5))\n",
-    "\n",
-    "approaches = [\"CC + EveryRow\", \"CC Only\"]\n",
-    "colors = [\"#2563eb\", \"#94a3b8\"]\n",
-    "\n",
-    "# F1 Score\n",
-    "f1_vals = [87.2, 74.5]\n",
-    "bars = axes[0].bar(approaches, f1_vals, color=colors, width=0.5)\n",
-    "axes[0].set_ylabel(\"F1 Score (%)\")\n",
-    "axes[0].set_title(\"Accuracy\")\n",
-    "for i, v in enumerate(f1_vals):\n",
-    "    axes[0].text(i, v + 1.5, f\"{v}%\", ha=\"center\", fontweight=\"bold\", fontsize=12)\n",
-    "axes[0].set_ylim(0, 108)\n",
-    "axes[0].axhline(y=50, color=\"#e5e7eb\", linestyle=\"--\", linewidth=0.8)\n",
-    "\n",
-    "# Runtime\n",
-    "time_vals = [13.5, 6]\n",
-    "bars = axes[1].bar(approaches, time_vals, color=colors, width=0.5)\n",
-    "axes[1].set_ylabel(\"Minutes\")\n",
-    "axes[1].set_title(\"Runtime\")\n",
-    "for i, v in enumerate(time_vals):\n",
-    "    axes[1].text(i, v + 0.4, f\"{v} min\", ha=\"center\", fontweight=\"bold\", fontsize=12)\n",
-    "axes[1].set_ylim(0, 20)\n",
-    "\n",
-    "# Cost\n",
-    "cost_vals = [18, 12.5]\n",
-    "bars = axes[2].bar(approaches, cost_vals, color=colors, width=0.5)\n",
-    "axes[2].set_ylabel(\"USD\")\n",
-    "axes[2].set_title(\"Cost\")\n",
-    "for i, v in enumerate(cost_vals):\n",
-    "    axes[2].text(i, v + 0.5, f\"${v:.0f}\", ha=\"center\", fontweight=\"bold\", fontsize=12)\n",
-    "axes[2].set_ylim(0, 25)\n",
-    "\n",
-    "for ax in axes:\n",
-    "    ax.spines[\"top\"].set_visible(False)\n",
-    "    ax.spines[\"right\"].set_visible(False)\n",
-    "\n",
-    "plt.suptitle(\"200 Trials × 700 Papers\", fontsize=14, fontweight=\"bold\", y=1.02)\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "comparison-discussion",
-   "metadata": {},
-   "source": [
-    "EveryRow achieves a **12.7 percentage point higher F1** than Claude Code alone. The accuracy gain comes primarily from recall: EveryRow finds matches that Claude Code's fixed-budget approach misses.\n",
-    "\n",
-    "Claude Code is faster and somewhat cheaper on this dataset, but the cost of its errors (40%+ missed links) far exceeds the dollar savings."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "scaling-intro",
-   "metadata": {},
-   "source": [
-    "## How Performance Scales\n",
-    "\n",
-    "We ran the same experiment at a smaller scale (200 trials + 200 papers) to see how both approaches respond to growing data.\n",
-    "\n",
-    "**At 200 + 200 papers**, Claude Code independently chose a similar strategy: regex NCT ID extraction (3 matches), followed by 8 parallel subagents using keyword-based search (`Grep`) on a papers text file. Each agent handled 25 trials across 200 papers.\n",
-    "\n",
-    "| | **200 trials + 200 papers** | **200 trials + 700 papers** |\n",
-    "|---|---|---|\n",
-    "| **CC + EveryRow — F1** | 85.7% | 87.2% |\n",
-    "| **CC Only — F1** | 78.8% | 74.5% |\n",
-    "| **CC + EveryRow — cost** | ~$6 | ~$18 |\n",
-    "| **CC Only — cost** | ~$15 | ~$12 |\n",
-    "| **CC + EveryRow — time** | 2.7 min | 13.5 min |\n",
-    "| **CC Only — time** | 7 min | 6 min |"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 9,
@@ -612,7 +630,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1400x500 with 3 Axes>"
       ]
@@ -634,8 +652,8 @@
     "# --- F1 Score ---\n",
     "er_f1 = [85.7, 87.2]\n",
     "cc_f1 = [78.8, 74.5]\n",
-    "axes[0].bar(x - w / 2, er_f1, w, label=\"CC + EveryRow\", color=er_color)\n",
-    "axes[0].bar(x + w / 2, cc_f1, w, label=\"CC Only\", color=cc_color)\n",
+    "axes[0].bar(x - w / 2, er_f1, w, label=\"everyrow\", color=er_color)\n",
+    "axes[0].bar(x + w / 2, cc_f1, w, label=\"Claude Code\", color=cc_color)\n",
     "for i in range(len(scales)):\n",
     "    axes[0].text(i - w / 2, er_f1[i] + 1.2, f\"{er_f1[i]}%\", ha=\"center\", fontsize=9, fontweight=\"bold\")\n",
     "    axes[0].text(i + w / 2, cc_f1[i] + 1.2, f\"{cc_f1[i]}%\", ha=\"center\", fontsize=9, fontweight=\"bold\")\n",
@@ -649,8 +667,8 @@
     "# --- Cost ---\n",
     "er_cost = [6, 18]\n",
     "cc_cost = [15, 12]\n",
-    "axes[1].bar(x - w / 2, er_cost, w, label=\"CC + EveryRow\", color=er_color)\n",
-    "axes[1].bar(x + w / 2, cc_cost, w, label=\"CC Only\", color=cc_color)\n",
+    "axes[1].bar(x - w / 2, er_cost, w, label=\"everyrow\", color=er_color)\n",
+    "axes[1].bar(x + w / 2, cc_cost, w, label=\"Claude Code\", color=cc_color)\n",
     "for i in range(len(scales)):\n",
     "    axes[1].text(i - w / 2, er_cost[i] + 0.5, f\"${er_cost[i]}\", ha=\"center\", fontsize=9, fontweight=\"bold\")\n",
     "    axes[1].text(i + w / 2, cc_cost[i] + 0.5, f\"${cc_cost[i]}\", ha=\"center\", fontsize=9, fontweight=\"bold\")\n",
@@ -664,8 +682,8 @@
     "# --- Runtime ---\n",
     "er_time = [2.7, 13.5]\n",
     "cc_time = [7, 6]\n",
-    "axes[2].bar(x - w / 2, er_time, w, label=\"CC + EveryRow\", color=er_color)\n",
-    "axes[2].bar(x + w / 2, cc_time, w, label=\"CC Only\", color=cc_color)\n",
+    "axes[2].bar(x - w / 2, er_time, w, label=\"everyrow\", color=er_color)\n",
+    "axes[2].bar(x + w / 2, cc_time, w, label=\"Claude Code\", color=cc_color)\n",
     "for i in range(len(scales)):\n",
     "    axes[2].text(i - w / 2, er_time[i] + 0.3, f\"{er_time[i]}m\", ha=\"center\", fontsize=9, fontweight=\"bold\")\n",
     "    axes[2].text(i + w / 2, cc_time[i] + 0.3, f\"{cc_time[i]}m\", ha=\"center\", fontsize=9, fontweight=\"bold\")\n",
@@ -684,66 +702,6 @@
     "plt.tight_layout()\n",
     "plt.show()"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "scaling-discussion",
-   "metadata": {},
-   "source": [
-    "A pattern emerges:\n",
-    "\n",
-    "- **EveryRow's F1 held steady** (85.7% → 87.2%) as the paper pool grew 3.5×. It allocated proportionally more resources to handle the larger search space.\n",
-    "- **Claude Code's F1 degraded** (78.8% → 74.5%). It used the same 8 subagents and TF-IDF top-15 filtering regardless of dataset size, so each agent's search became less thorough.\n",
-    "- **Claude Code's cost stayed flat** (~$12–15 in both cases). This is the signature of a ≈fixed-budget approach: the same compute is spent whether the problem is small or large.\n",
-    "- **EveryRow's cost scaled with the problem** ($6 → $18). The extra spend went directly toward maintaining quality at scale.\n",
-    "\n",
-    "At 200 + 200, EveryRow was cheaper, faster, and more accurate. At 200 + 700, the accuracy gap widened. Extrapolating to larger datasets (thousands of trials and papers), we would expect the gap to grow further: Claude Code's fixed 8-agent budget would be spread even thinner, while EveryRow would continue to scale its orchestration, thus nicely *complementing* Claude Code."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "takeaways",
-   "metadata": {},
-   "source": [
-    "## Key Takeaways\n",
-    "\n",
-    "**1. Specialized orchestration beats general-purpose agent planning for data operations at scale.**\n",
-    "EveryRow's `merge()` is purpose-built to decompose a large matching problem into hundreds of parallel agent tasks, with intelligent candidate selection and verification. Claude Code is remarkably clever — it independently invented a TF-IDF + parallel-subagent pipeline — but a general-purpose coding agent can't match a system designed specifically for this class of problem.\n",
-    "\n",
-    "**2. The recall gap is the key differentiator.**\n",
-    "Claude Code achieved perfect precision (100%) — every match it reported was correct. But it only found ~59% of the true links. EveryRow's higher F1 comes from substantially better recall: it surfaces matches that a fixed-budget approach misses.\n",
-    "\n",
-    "**3. Fixed resources → degrading quality.**\n",
-    "Claude Code used 8 subagents for both the 200-paper and 700-paper runs. This is a natural consequence of how coding agents plan: they estimate a reasonable level of parallelism and stick with it. As the dataset grows, each agent's workload increases but the total compute stays constant. EveryRow, by contrast, scales its agent count to the problem.\n",
-    "\n",
-    "**4. Cost is about what you get for your money.**\n",
-    "At the 200 + 700 scale, EveryRow cost ~$18 and achieved 87.2% F1. Claude Code cost ~$12 and achieved 74.5% F1. The relevant metric isn't raw cost but cost per unit of quality. The ~$6 in savings from Claude Code comes at the price of missing 40%+ of the true matches."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "reproduce",
-   "metadata": {},
-   "source": [
-    "## Reproduce It Yourself\n",
-    "\n",
-    "This dataset (200 trials + 700 papers) was sized to fit within EveryRow's free-tier credits (~$20). To reproduce:\n",
-    "\n",
-    "1. Run the cells above to execute the EveryRow merge and score it\n",
-    "2. To test Claude Code alone, give it the `trials_200.csv` and `papers_700.csv` files and ask it to match papers to trials\n",
-    "3. Save Claude Code's predictions as a CSV with `nct_id` and `pmid` columns, then score with:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "reproduce-code",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Score any set of predictions against the gold labels:\n",
-    "# score_from_csv(\"your_predictions.csv\")"
-   ]
   }
  ],
  "metadata": {
@@ -767,4 +725,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}