{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5ceda081",
   "metadata": {},
   "source": [
    "# Context Engineering From Scratch: Clear What the Agent Already Used\n",
    "\n",
    "**An expense-audit agent checks 30 reports, one per step. By the last step it is re-reading every report it already finished. This notebook measures what that costs, clears it with about ten lines of plain Python, and reports what changed and what did not.**\n",
    "\n",
    "## The one idea\n",
    "\n",
    "The model sees only what is in the context window at this step, and the loop decides what goes in. A bare agent loop only ever adds: every tool result and every document stays in the message list and is sent again on every later step. **Context engineering** is deciding, for every step, what goes into the window and what stays out ([Anthropic, 2025](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)). The cheapest move is also the first one to try: once the agent has acted on a result, replace the full text with a one-line note of what it found. That is a deletion, not a model call.\n",
    "\n",
    "## Overview\n",
    "\n",
    "1. Build 30 synthetic expense reports with 11 planted violations, so the score is exact\n",
    "2. Run the audit the default way, keeping every report in the history, and log the tokens per layer\n",
    "3. Clear each report once it has been answered, and run again\n",
    "4. Clear in batches instead, to protect the prompt cache, and run a third time\n",
    "5. Compare tokens, dollars, the size of the last call, and the audit score\n",
    "6. An aside the data forced on us: the false alarms, and why they are not a context problem\n",
    "\n",
    "**Requirements:** `pip install openai tiktoken matplotlib` and an `OPENAI_API_KEY`. The three runs make 90 calls to `gpt-5.4-mini` and cost about $0.20 together at the list prices of 2026-10-30. Outputs saved in this notebook come from a real run. Yours will differ a little, because the model is not deterministic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "63259186",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:31:21.801620Z",
     "iopub.status.busy": "2026-10-29T22:31:21.801406Z",
     "iopub.status.idle": "2026-10-29T22:31:28.029529Z",
     "shell.execute_reply": "2026-10-29T22:31:28.029036Z"
    }
   },
   "outputs": [],
   "source": [
    "# !pip install openai tiktoken matplotlib\n",
    "import os, json, random, time\n",
    "import openai, tiktoken\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "MODEL = \"gpt-5.4-mini\"\n",
    "# USD per 1M tokens, from https://developers.openai.com/api/docs/pricing on 2026-10-30. Check yours.\n",
    "PRICE = {\"input\": 0.75, \"cached_input\": 0.075, \"output\": 4.50}\n",
    "client = openai.OpenAI()          # reads OPENAI_API_KEY from the environment\n",
    "enc = tiktoken.get_encoding(\"o200k_base\")   # only used to split a call into layers; totals come from the API"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1923b08d",
   "metadata": {},
   "source": [
    "## 1. A job with a known answer\n",
    "\n",
    "The agent audits travel expense reports against a short policy. Each report has the receipts that matter, plus the noise real reports carry: a card statement, an approval chain, notes. Each one is about 1,200 tokens.\n",
    "\n",
    "The generator plants 11 violations and records them as ground truth, so every run can be scored exactly. It also plants a near miss in every report: the employee's home office is always a city with a *higher* hotel cap than the city the hotel is in. Checking a hotel night against the wrong city's cap is the classic way an auditor, human or model, waves a violation through."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bc181aba",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:31:28.030969Z",
     "iopub.status.busy": "2026-10-29T22:31:28.030883Z",
     "iopub.status.idle": "2026-10-29T22:31:28.263211Z",
     "shell.execute_reply": "2026-10-29T22:31:28.262755Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 reports, about 1,177 tokens each\n",
      "planted violations: [('R-02', 'D'), ('R-03', 'H'), ('R-05', 'M'), ('R-06', 'H'), ('R-14', 'M'), ('R-16', 'H'), ('R-17', 'H'), ('R-22', 'H'), ('R-24', 'H'), ('R-26', 'H'), ('R-28', 'D')]\n",
      "\n",
      "EXPENSE REPORT R-03\n",
      "Employee: Mia Chen   Home office: Chicago   Cost center: CC-4102\n",
      "Trip: client workshop in Denver, 2 nights, September 2026\n",
      "\n",
      "RECEIPTS\n",
      "- 2026-09-20  Hotel: The Crawford Hotel, Denver - 1 night - $215.00\n",
      "- 2026-09-21  Hotel: The Crawford Hotel, Denver - 1 night - $215.00\n",
      "- 2026-09-20  Meals, Denver - $38.00\n",
      "- 2026-09-21  Meals, Denver - $70.00\n",
      "- 2026-09-20  Taxi from airport, Denver - $44.00\n",
      "\n",
      "CORPORATE CARD STATEMENT (context only)\n",
      "  2026-09-05  POS 596493  Checked bag fee                      $49.15  auth 2011\n",
      "  2026-09-11  POS 815476  FedEx Office printing                $36.71  auth 8905\n",
      "  2026-09-26  POS 914208  In-flight wifi                       $59.71  auth 1930\n",
      "  2026-09-08  POS 300599  Amtrak seat upgrade                  $5.98  auth 2601\n",
      "  2026-09-17  POS 574140  FedEx Office printing                $4.97  auth 2038\n",
      "  2026-09-15  POS 441430  Checked bag fee   \n",
      "...\n"
     ]
    }
   ],
   "source": [
    "CAPS = {\"New York\": 320, \"San Francisco\": 300, \"Boston\": 260, \"Seattle\": 250, \"Chicago\": 240, \"Austin\": 210, \"Denver\": 200}\n",
    "MEAL_CAP = 75\n",
    "POLICY = \"TRAVEL AND EXPENSE POLICY (FY2026)\\n\\n\" \\\n",
    "    \"Rule H - Hotel nightly cap. A hotel night may not exceed the cap for the city THE HOTEL IS IN:\\n\" + \\\n",
    "    \"\\n\".join(f\"  {c}: ${v}/night\" for c, v in CAPS.items()) + f\"\"\"\n",
    "Rule M - Meals. Meals may not exceed ${MEAL_CAP} per day, per traveler.\n",
    "Rule D - Receipts. Every receipt must show a date. A receipt with no date is a violation.\n",
    "Caps apply to the nightly room rate as shown on the receipt.\n",
    "Card statement lines, approval chains and notes are context only; they are not receipts.\"\"\"\n",
    "\n",
    "HOTELS = {\"New York\": \"The Lexington\", \"San Francisco\": \"Hotel Zephyr\", \"Boston\": \"The Verb Hotel\", \"Seattle\": \"Hotel Theodore\",\n",
    "          \"Chicago\": \"The Robey\", \"Austin\": \"The Driskill\", \"Denver\": \"The Crawford Hotel\"}\n",
    "NAMES = [\"Dana Levi\", \"Omar Haddad\", \"Mia Chen\", \"Lucas Brandt\", \"Priya Nair\", \"Tom Okafor\", \"Sara Weiss\", \"Noa Peretz\",\n",
    "         \"Ivan Petrov\", \"Emma Rossi\", \"Yuki Sato\", \"Ben Carter\", \"Lea Martin\", \"Ravi Shah\", \"Ana Costa\"]\n",
    "NOISE = [\"Airport parking T2\", \"In-flight wifi\", \"Office Depot\", \"Hertz fuel top-up\", \"Amtrak seat upgrade\",\n",
    "         \"Conference badge reprint\", \"Laundry service\", \"Phone charger, Best Buy\", \"FedEx Office printing\",\n",
    "         \"Checked bag fee\", \"Toll road E-ZPass\", \"Zoom Pro renewal\", \"Luggage storage\", \"SIM card, T-Mobile\"]\n",
    "\n",
    "def make_reports(n=30, seed=7):\n",
    "    rng, cities = random.Random(seed), list(CAPS)\n",
    "    kinds = {}                                   # report index -> planted violation\n",
    "    for i in rng.sample(range(n // 2), 2): kinds[i] = \"H\"\n",
    "    for i in rng.sample([x for x in range(n // 2, n) if x not in kinds], 5): kinds[i] = \"H\"   # most hotel violations come late\n",
    "    for i in rng.sample([x for x in range(n) if x not in kinds], 2): kinds[i] = \"M\"\n",
    "    for i in rng.sample([x for x in range(n) if x not in kinds], 2): kinds[i] = \"D\"\n",
    "    reports, truth, city_of = [], set(), {}\n",
    "    for i in range(n):\n",
    "        rid, city = f\"R-{i+1:02d}\", cities[(i * 3) % len(cities)]\n",
    "        home = rng.choice([c for c in cities if CAPS[c] > CAPS[city]] or cities)   # the near miss\n",
    "        rate = CAPS[city] - rng.choice([5, 10, 15, 20, 30])\n",
    "        if kinds.get(i) == \"H\":\n",
    "            rate = CAPS[city] + rng.choice([10, 15, 25]); truth.add((rid, \"H\"))     # over this city's cap, under the home office's\n",
    "        nights, day0 = rng.choice([2, 3, 4]), rng.randint(1, 20)\n",
    "        lines = [f\"EXPENSE REPORT {rid}\", f\"Employee: {NAMES[i % len(NAMES)]}   Home office: {home}   Cost center: CC-{4100 + i}\",\n",
    "                 f\"Trip: client workshop in {city}, {nights} nights, September 2026\", \"\", \"RECEIPTS\"]\n",
    "        lines += [f\"- 2026-09-{day0 + d:02d}  Hotel: {HOTELS[city]}, {city} - 1 night - ${rate}.00\" for d in range(nights)]\n",
    "        for d in range(nights):\n",
    "            meal = rng.choice([38, 44, 52, 57, 61, 66, 70])\n",
    "            if kinds.get(i) == \"M\" and d == nights - 1:\n",
    "                meal = MEAL_CAP + rng.choice([12, 19, 27]); truth.add((rid, \"M\"))\n",
    "            lines.append(f\"- 2026-09-{day0 + d:02d}  Meals, {city} - ${meal}.00\")\n",
    "        if kinds.get(i) == \"D\": truth.add((rid, \"D\"))\n",
    "        lines.append(f\"- {'(no date)' if kinds.get(i) == 'D' else f'2026-09-{day0:02d}'}  Taxi from airport, {city} - ${rng.randint(35, 80)}.00\")\n",
    "        lines += [\"\", \"CORPORATE CARD STATEMENT (context only)\"]\n",
    "        lines += [f\"  2026-09-{rng.randint(1, 28):02d}  POS {rng.randint(100000, 999999)}  {rng.choice(NOISE):<36} ${rng.randint(3, 60)}.{rng.randint(0, 99):02d}  auth {rng.randint(1000, 9999)}\"\n",
    "                  for _ in range(rng.randint(26, 32))]\n",
    "        lines.append(f\"  2026-09-{day0:02d}  POS {rng.randint(100000, 999999)}  {HOTELS[city]} folio, {nights} nights       ${rate * nights}.00\")\n",
    "        lines += [\"\", \"APPROVAL CHAIN (context only)\"]\n",
    "        lines += [f\"  {k + 1}. {who} on 2026-10-{rng.randint(1, 9):02d}, ticket FIN-{rng.randint(10000, 99999)}, comment: \\\"{rng.choice(['ok', 'see attached', 'client billable', 'per diem per policy', 'n/a'])}\\\"\"\n",
    "                  for k, who in enumerate([\"Submitted by employee\", \"Reviewed by team lead\", \"Pending finance review\"])]\n",
    "        lines += [\"\", \"NOTES\", f\"  Workshop agenda attached separately. Client PO {rng.randint(400000, 499999)}. Home office {home} travel desk booked the flights.\"]\n",
    "        reports.append(\"\\n\".join(lines)); city_of[rid] = city\n",
    "    return reports, truth, city_of\n",
    "\n",
    "REPORTS, TRUTH, CITY_OF = make_reports()\n",
    "print(f\"{len(REPORTS)} reports, about {sum(len(enc.encode(r)) for r in REPORTS) // len(REPORTS):,} tokens each\")\n",
    "print(\"planted violations:\", sorted(TRUTH))\n",
    "print(\"\\n\" + REPORTS[2][:900] + \"\\n...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee6f24cd",
   "metadata": {},
   "source": [
    "## 2. The audit loop, the default way\n",
    "\n",
    "One report per step, and the model answers with a structured list of violations. The loop keeps everything, which is what every loop does unless you tell it otherwise: the policy at the top, then every report and every answer, in order. The step that checks report 30 sends reports 1 to 29 again, although the agent finished with them long ago.\n",
    "\n",
    "The answers stay in the history in every mode. They are short, and they are the agent's record of what it found.\n",
    "\n",
    "One parameter, `clear_every`, controls the only thing that differs between the three runs in this notebook:\n",
    "\n",
    "- `0` keeps every report (the default loop)\n",
    "- `1` replaces each report with a one-line note once the model has answered it\n",
    "- `5` does the same in batches of five, for reasons section 4 explains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c57b7008",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:31:28.264976Z",
     "iopub.status.busy": "2026-10-29T22:31:28.264856Z",
     "iopub.status.idle": "2026-10-29T22:31:28.271804Z",
     "shell.execute_reply": "2026-10-29T22:31:28.271300Z"
    }
   },
   "outputs": [],
   "source": [
    "SYSTEM = POLICY + '''\n",
    "\n",
    "You are an expense auditor. Each message gives you one expense report.\n",
    "Answer with the report id and the list of receipts that break a rule (empty if none).\n",
    "For each, give the rule, the receipt line, the amount, and the limit you checked it against (0 for rule D).'''\n",
    "\n",
    "ANSWER = {\"type\": \"json_schema\", \"json_schema\": {\"name\": \"audit\", \"strict\": True, \"schema\": {\n",
    "    \"type\": \"object\", \"additionalProperties\": False, \"required\": [\"report_id\", \"violations\"],\n",
    "    \"properties\": {\"report_id\": {\"type\": \"string\"}, \"violations\": {\"type\": \"array\", \"items\": {\n",
    "        \"type\": \"object\", \"additionalProperties\": False, \"required\": [\"rule\", \"receipt\", \"amount\", \"limit\"],\n",
    "        \"properties\": {\"rule\": {\"type\": \"string\", \"enum\": [\"H\", \"M\", \"D\"]}, \"receipt\": {\"type\": \"string\"},\n",
    "                       \"amount\": {\"type\": \"number\"}, \"limit\": {\"type\": \"number\"}}}}}}}}\n",
    "\n",
    "def call_model(messages):\n",
    "    for attempt in range(5):\n",
    "        try:\n",
    "            return client.chat.completions.create(model=MODEL, messages=messages, response_format=ANSWER)\n",
    "        except (openai.RateLimitError, openai.APIConnectionError, openai.InternalServerError):\n",
    "            if attempt == 4: raise\n",
    "            time.sleep(5 * (attempt + 1))\n",
    "\n",
    "def layers(messages):\n",
    "    # Estimated tokens per layer of one call: instructions, history, current request\n",
    "    n = lambda m: len(enc.encode(m[\"content\"]))\n",
    "    return {\"instructions\": n(messages[0]), \"history\": sum(n(m) for m in messages[1:-1]), \"current\": n(messages[-1])}\n",
    "\n",
    "def run_audit(clear_every=0):\n",
    "    messages = [{\"role\": \"system\", \"content\": SYSTEM}]\n",
    "    answers, log, uncleared = {}, [], []\n",
    "    for step, report in enumerate(REPORTS, 1):\n",
    "        rid = f\"R-{step:02d}\"\n",
    "        # --- the whole technique: once a report has been answered, keep the finding and drop the text ---\n",
    "        if clear_every and uncleared and (step - 1) % clear_every == 0:\n",
    "            for i, old in uncleared:\n",
    "                found = \"; \".join(f\"{v['rule']} {v['amount']:g} vs {v['limit']:g}\" for v in answers[old]) or \"none\"\n",
    "                messages[i][\"content\"] = f\"{old}: checked, full text cleared. Found: {found}\"\n",
    "            uncleared = []\n",
    "        uncleared.append((len(messages), rid))\n",
    "        messages.append({\"role\": \"user\", \"content\": report})\n",
    "        est = layers(messages)\n",
    "        reply = call_model(messages)\n",
    "        u = reply.usage\n",
    "        cached = (u.prompt_tokens_details.cached_tokens or 0) if u.prompt_tokens_details else 0\n",
    "        text = reply.choices[0].message.content\n",
    "        messages.append({\"role\": \"assistant\", \"content\": text})\n",
    "        answers[rid] = json.loads(text)[\"violations\"]\n",
    "        log.append({\"step\": step, \"input\": u.prompt_tokens, \"cached\": cached, \"output\": u.completion_tokens, **est})\n",
    "    return answers, log\n",
    "\n",
    "def score(answers):\n",
    "    got = {(rid, v[\"rule\"]) for rid, vs in answers.items() for v in vs}\n",
    "    wrong_cap = sorted({rid for rid, vs in answers.items() for v in vs if v[\"rule\"] == \"H\" and v[\"limit\"] != CAPS[CITY_OF[rid]]})\n",
    "    return {\"caught\": len(got & TRUTH), \"missed\": sorted(TRUTH - got), \"false_alarms\": sorted(got - TRUTH), \"wrong_cap\": wrong_cap}\n",
    "\n",
    "def cost(log):\n",
    "    i, c, o = (sum(r[k] for r in log) for k in (\"input\", \"cached\", \"output\"))\n",
    "    return ((i - c) * PRICE[\"input\"] + c * PRICE[\"cached_input\"] + o * PRICE[\"output\"]) / 1e6\n",
    "\n",
    "def summary(name, answers, log):\n",
    "    s = score(answers)\n",
    "    print(f\"{name}: {sum(r['input'] for r in log):,} input tokens sent ({sum(r['cached'] for r in log) / sum(r['input'] for r in log):.0%} cached), \"\n",
    "          f\"last call {log[-1]['input']:,} tokens, ${cost(log):.3f}\")\n",
    "    print(f\"  caught {s['caught']}/{len(TRUTH)} planted violations, missed {s['missed'] or 'none'}, \"\n",
    "          f\"wrong city cap used on {s['wrong_cap'] or 'no report'}, {len(s['false_alarms'])} false alarms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d516b42e",
   "metadata": {},
   "source": [
    "## 3. Run it, and log every layer\n",
    "\n",
    "Before changing anything, measure: log the tokens in each layer at every step. Here there are three layers: the instructions (the policy, re-sent on every call), the history (every earlier report and answer), and the current request (this step's report)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7e1794cc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:31:28.273259Z",
     "iopub.status.busy": "2026-10-29T22:31:28.273178Z",
     "iopub.status.idle": "2026-10-29T22:32:12.288227Z",
     "shell.execute_reply": "2026-10-29T22:32:12.287303Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step  1: instructions  214 | history      0 | current 1,088   -> API counted  1,389 input tokens,  1,280 of them cached\n",
      "step  2: instructions  214 | history  1,100 | current 1,160   -> API counted  2,574 input tokens,  2,432 of them cached\n",
      "step 10: instructions  214 | history 10,895 | current 1,210   -> API counted 12,523 input tokens, 11,136 of them cached\n",
      "step 20: instructions  214 | history 23,619 | current 1,238   -> API counted 25,405 input tokens, 23,936 of them cached\n",
      "step 30: instructions  214 | history 36,244 | current 1,205   -> API counted 38,127 input tokens, 36,608 of them cached\n",
      "Keep everything: 587,070 input tokens sent (94% cached), last call 38,127 tokens, $0.080\n",
      "  caught 9/11 planted violations, missed [('R-03', 'H'), ('R-24', 'H')], wrong city cap used on no report, 10 false alarms\n"
     ]
    }
   ],
   "source": [
    "keep_answers, keep_log = run_audit(clear_every=0)\n",
    "for r in keep_log:\n",
    "    if r[\"step\"] in (1, 2, 10, 20, 30):\n",
    "        print(f\"step {r['step']:2d}: instructions {r['instructions']:>4} | history {r['history']:>6,} | current {r['current']:>5,}\"\n",
    "              f\"   -> API counted {r['input']:>6,} input tokens, {r['cached']:>6,} of them cached\")\n",
    "summary(\"Keep everything\", keep_answers, keep_log)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34c0afbe",
   "metadata": {},
   "source": [
    "By the last step, almost the entire call is history: reports the agent already finished, sent again. The current report, the only thing this step needs to read, is a small slice at the bottom.\n",
    "\n",
    "Note the `cached` column. OpenAI caches the start of a prompt when it repeats the previous request exactly ([prompt caching docs](https://platform.openai.com/docs/guides/prompt-caching)), and an append-only history repeats exactly. So most of those re-sent tokens are billed at a tenth of the price. Keep that in mind for section 4."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "017d8cf0",
   "metadata": {},
   "source": [
    "## 4. Clear what the agent already used\n",
    "\n",
    "Same loop, `clear_every=1`. Before each call, the previous report's full text is replaced with one line, and the agent's answer stays in the history:\n",
    "\n",
    "```text\n",
    "R-03: checked, full text cleared. Found: H 215 vs 200\n",
    "```\n",
    "\n",
    "Nothing is lost that the run still needs: the finding is kept, and the original report is still in `REPORTS` if a later step had to look it up again. A real agent would get a `read_report` tool for that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c3861531",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:32:12.290306Z",
     "iopub.status.busy": "2026-10-29T22:32:12.290167Z",
     "iopub.status.idle": "2026-10-29T22:32:55.175071Z",
     "shell.execute_reply": "2026-10-29T22:32:55.174558Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clear each report once answered: 108,086 input tokens sent (31% cached), last call 5,927 tokens, $0.074\n",
      "  caught 11/11 planted violations, missed none, wrong city cap used on no report, 20 false alarms\n"
     ]
    }
   ],
   "source": [
    "clear_answers, clear_log = run_audit(clear_every=1)\n",
    "summary(\"Clear each report once answered\", clear_answers, clear_log)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80f8c635",
   "metadata": {},
   "source": [
    "### Clearing has a price: the cache\n",
    "\n",
    "Editing a message in the middle of the history changes the prompt from that point on, and the cache discount stops at the first changed token. The usual advice is to let used results pile up for a few steps and clear them in one batch, so most calls still repeat the previous prefix exactly. Here is the batch version, `clear_every=5`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "448f6cdc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:32:55.176684Z",
     "iopub.status.busy": "2026-10-29T22:32:55.176580Z",
     "iopub.status.idle": "2026-10-29T22:33:32.933266Z",
     "shell.execute_reply": "2026-10-29T22:33:32.932302Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clear in batches of 5: 158,012 input tokens sent (71% cached), last call 9,673 tokens, $0.055\n",
      "  caught 10/11 planted violations, missed [('R-03', 'H')], wrong city cap used on no report, 12 false alarms\n"
     ]
    }
   ],
   "source": [
    "batch_answers, batch_log = run_audit(clear_every=5)\n",
    "summary(\"Clear in batches of 5\", batch_answers, batch_log)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8b894b1",
   "metadata": {},
   "source": [
    "## 5. Side by side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a2b414dc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:33:32.935879Z",
     "iopub.status.busy": "2026-10-29T22:33:32.935694Z",
     "iopub.status.idle": "2026-10-29T22:33:33.346966Z",
     "shell.execute_reply": "2026-10-29T22:33:33.346545Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                    input sent  cached  last call    cost  caught wrong cap\n",
      "Keep everything                        587,070     94%     38,127  $0.080    9/11         0\n",
      "Clear each report once answered        108,086     31%      5,927  $0.074   11/11         0\n",
      "Clear in batches of 5                  158,012     71%      9,673  $0.055   10/11         0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAGaCAYAAABZiDHTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAv5pJREFUeJzs3QV4U2fbB/B/3VsKbWkpLS3ubsUZg8GGDBk2xphv73zvDObywoT53veDGRuy4QwfG7Lh7q71QilQ9zbfdT9tQqokJW3S5v/jypXk5PTk5DxJOHee57lvG41GowERERERERHVGLbm3gEiIiIiIiIyLQZ6RERERERENQwDPSIiIiIiohqGgR4REREREVENw0CPiIiIiIiohmGgR0REREREVMMw0CMiIiIiIqphGOgRERERERHVMAz0iIiIiIiIahgGekREZnb+/HnY2Njghx9+gDWxpNedkJCg9uXLL78sd1l14ezsjBdeeAHVkSW9Lyy5rarz+5OIqgYDPSKiCsrKyoKLiwuGDh1a4rHffvtNnYR17969xGN//fWXeuzrr7+utGMfHR2tnuPbb7+ttOegmq+y3kd8fxIRVT4GekREFeTk5IQePXpg27ZtyMvLK/LY5s2b4ebmhv379yM5ObnIY1u2bFHXd9xxB489ERERVQoGekREt0GCNQnkJKArHug9+eSTqjdk69atJR6rW7cuWrduzWNPRERElYKBHhHRbRgwYECRXjoRGRmJixcvYvjw4ejYsaMK7LRSUlJw4MAB9O/fv9TtLVu2DC1atFC9hW3btsWGDRtKrGNvb68CSLk4OjqiYcOGeOWVV5CWlqYe3759O4KCgtTtZ599VrfuM888U+5rycnJwYwZM9CyZUs1b6h27doYN24cwsPDjXp+/e19/PHHaNOmjRriWr9+fTzyyCOIiYmp0Osua59v9RyG7u/t+Oqrr9Q+uLu7o169erj33ntx6NAho4+v/vw0Q47JlStXMGnSJNSqVUtdJk+eXKIH2Zh91GfI+ygxMRHPP/88goOD1bGV9WVdWX4729Uy5BgY+r4tTv9Yz58/H02bNlW98HfddZcaWirmzZuHZs2aqe2GhYXhxIkTJbZj6DEwpq0q+pqIiIrQEBFRheXm5mo8PT01AwcO1C376aefNM7OzprMzEzNq6++qmnXrp3usTVr1mjkq/e7777TLTt37pxadt9992mee+45TVRUlCY2NlYzfPhwjYuLi+by5ctlPn9ycrJm3bp1moCAAM2DDz6oWy7bkG1+8803Br2OvLw8zT333KPx8fHRLFy4UHPjxg21X0OGDFHbvnLlilHPL8flrrvu0tSqVUvz888/a+Lj49VrmjNnjuadd9657ddt6HMYur9Xr15V+/LFF1+Uu6w0s2bN0jg4OKjjJttPSEjQrF69WjNx4kSjj68xxyQjI0PTqlUrTWhoqGbr1q2apKQkze+//66ZMGGCxsnJSfP8888btY+lKe99JO/vDh06qP3fsGGDev6NGzdqAgMDNW3bttWkp6dXaLvGHIOKvm/1n2fkyJGal19+WW33/Pnzat+7deumtvfCCy+o57548aKmffv2mpYtW2ry8/ONPgbGtJWhr8nQ9ycRWS8GekREt0lOylxdXTVZWVnq/qRJkzR33HGHui1BhY2NjTqxFv/+97/VydmFCxdKnHB27dq1yHYjIiLU8s8+++yW+/Dtt99qbG1tdSeWxgZ6ixYtUusvWbKkyPLExEQVSL322mtGPf/8+fPV9n799dcy/+Z2X7chz2Ho/t5OoDd+/HhNixYtTHJ8jTkms2fPVsu2bNlSZF0J6mS5fvBgyD6Wprz3kfxYIY+tWrWqyPL169ff8r1nSKBnyDG4nfet9nm6d+9eZPnixYvV8n79+hVZvmzZMrV8x44dRh8DY9rK0NfEQI+IboVDN4mITDB8Mz09HXv27NEN49QOzezVqxfs7Ox0QztlGGeDBg3U8MHi7rnnniL3ZSiYh4eHGgaq788//8SgQYNQp04d2Nra6oa95efnl1jXUKtXr1bDzmS4qT4vLy907twZ//zzj1HPv27dOjVk8r777rvlcxv6uosz9Dkq43jpa9euHU6dOqVS5Muw3OKJeYw9voYek02bNqll/fr1K7KuDMmsyD4aS55fXlPxfR08eLAaHiqP3w5DjoGxx7U0Q4YMKXK/efPm6rp3795FlssQUlG8DQw5Bsa0lSleExGRYKBHRHSbtNkzJZg7e/asmh+mDfTk5E7m6cljN27cwJEjR8rMthkQEFBimaenZ5G5PpLYRU5MQ0JCsHv3bmRkZMjIDPz888+6uT0VcfnyZWRnZ8PV1VUFTxKcaoOijRs34tq1a0Y9f3x8vEo4I9u6FUNed2kMeY7KOl76/v3vf+Pdd9/FypUr1Ym4BJRjxozBwYMHjT6+xhwT+Rt5/cX5+fmpbRu7j8aS5y/tuYTsl9R5ux2GHANjj6shzyOf2fKWF28DQ46BMW1litdERCQY6BER3SZJEuHj46N66+QiJ2hdu3bVPS6/4svyv//+W/UiaRO4FCcncrciSSMk6cisWbPQpEkTlaRCXLp06bZeg+y/nETLCWZubq7q8ZF9LRzirwJYY57f19dXJZ+Qbd2KIa+7NIY8R2UdL30ODg5455131Dbl8sUXX+D48ePo06ePLqmHocfXmGMiwZoEu8XJMtm2sftoLEkQIs8l+1+ctIu85tthyDEw9rga8zyGPL+hx8CYtjLFayIiEgz0iIhuk5wQSg+e9BitXbtWDdeUE2v9QO/06dNYsGCBSernybAu/ZNQORH89ddfi6wj2QO1Rd0NMWzYMJUB8I8//jDJ80sReTlJXbJkCSqLoc9hyP6aivQcPvTQQ5g5c6bK6qntMTPm+Bpb2qP4UD7ptavIPpamvPeR/GAhwYgMoS0+VDY1NbXMHzRutV1jVMZxNYahx8CYtjL3ayKimoOBHhGRCciJnJy0SqBXvHSCzPWRIVjLly9X839KG5JmKJm3I0NA33rrLSQlJakU8RMmTFBzsPR5e3urFPrSkyjr3cr48eNV4DRlyhTMnTtXDR+TUhASBLz++usqKDDm+SUVvKSp/9e//oVffvkFV69eVduUIZMyhNAUDHkOQ/f3djz44IP45ptvcObMGfUeiIiIUPsgc7RkmKQxx9cYkp5f5o1JOYkdO3ao7cn8LgkmtD2Xxuxjacp7H8nzy3F84okn1JBCeX4Zovzoo4+qGpEPP/xwhbZrjMo4rsYw9BgY01bmfk1EVHMw0CMiMgHtL/cytKp4wgU5me7UqZN67HZ78+QEcPbs2aoXy9/fXwUy0gMwevToEuv+9NNPqqafzAO6VR09mQP0+++/44033lD11ho1aqTqgckJrAwle+yxx4x6fplXtGrVKlWvTurcSX27Ll26qBpqjz/++G0dA2Oew5jjVVESVMpwSEmsIfXRevTooY7ntm3bVDBjzPE1hgxJlUBJXvPdd9+tXv/ChQvxv//9r0L7WJay3kdS302CGtmmBCUyjFHqxMkxlwBGhjBXZLvGqIzjagxDj4ExbWXu10RENYeNpN40904QERERERGR6bBHj4iIiIiIqIZhoEdERERERFTDMNAjIiIiIiKqYRjoERERERER1TAM9IiIiIiIiGoYBnpEREREREQ1jL25d6Cmyc/PR2xsLDw8PFRdICIiIiIiIlOQyngpKSmqBqrU3SwPAz0TkyBPCpsSERERERFVhqioKNSvX7/cdRjomZj05GkPvqen5y17/65evQpfX99bRuRUM7DNrQvb2/qwza0P29y6sL2tT76Fna8nJyerTiVtzFEeBnomph2uKUGeIYFeZmamWs8S3jhU+djm1oXtbX3Y5taHbW5d2N7WJ99Cz9cNmSJmOXtLREREREREJsFAj4iIiIiIqIZhoEdERERERFTDcI6emcb6Zmdnq+ucnBw17teSxvxS5WGbWxdzt7eDgwPs7Oyq/HmJiIjI/BjoVTEJ8C5duqROAKUOhlxLLQzW3LMObHPrYgntXatWLfj7+/M7hoiIyMow0Kvik764uDj1C7ukRZUTv9zcXNjb2/MkzIreA2xz62HO9pbnTk9PR3x8vLofEBBQpc9PRERE5sVArwrJCZ+ceEkle1dXV570WyEGetbF3O3t4uKiriXY8/Pz4zBOIiIiK8KJYVUoLy9PXTs6Olbl0xKRFZMflYTMFSQiIiLrwUDPDDgfj4j4fUNERESViYEeURW7fv06zp07V+46iYmJOHPmTJXtExERERGVFJeUgQNRKeq6umGgR7cUExOjMoUWJ8tOnDih5iFR6W7cuIGzZ88WWbZw4UIMHz683EP2+++/Y8CAATysRERERGayaF8ken/yN55edlZdy/3qhIEe3dIbb7yBhx56qMiyWbNmoVmzZti1axeHopZj2bJlGDRokNHvMm9vbzRv3pzvTiIiIiIzOB+fiteXHUN+YX+GXE9bfrxa9ewx0COjffjhh3jhhRewaNEiPProo7rlkl3wwoULathhWcpbR39Io2QnlfWkBpkhytqubOf48ePqcX1SwFqWS11DY/dNbp88eRKpqanlbvvatWuIjY1VSTDkvlwSEhKKrJuRkYGIiIgSr7Nv377473//W+rzl/U3+utGRUWp28nJyTh9+vQtjh4RERERCQnkZqw7hWHfbEPxMWt5Gg3CE9JRXTDQq8Zvwp0XEqr0VwUZoikB3ieffIJ169Zh5MiRuse+//57VafrjjvuQGhoqApUJBjRd6t1fv31V9x5552YMGECgoOD0blzZzRq1AgHDx4sd7/K264EWV26dMEff/xR5G/mzZuHfv366XojDd23+++/H02bNsXYsWNVEeywsDCsXr26yLZ/+uknta7s9+zZs3H16lWMHz9eXVauXKkL1h588EH1XF27dlV1Fffv31/m0E3t85f3NxL4Pf3006hbty569uypXs9LL72EXr163bJtiYiIiKzZsegkPL/wEHp/vAWzt15ERk7JH9TtbGwQ4lOQzbo6YKBnRqqgcXau0Zd5u8LR86PNmPj9HnUt943dhrHz6qTXavLkySrg2LJliwqItNauXYupU6fizz//VMGR1OySAO2BBx4wah0RGRmJWrVqqeBIer/69OmjgittaYribrVdLy8vDB06FAsWLCjyd3JfgjUHBwej9i0kJETtm/TOSSAl25DATp/cl78dOHAg3nvvPVU3Uduj98gjj+i2JQHj5cuXERcXpwLLF198sdw2uNXf/Pbbb5g7dy727t2r1pV2koCRiIiIiErKz9fgr5NXMHb2Lgz7djtWHo5Fbr4G3RvWxg+TO2PGqDawKyyDK9fTR7VGgFdBjdrqgAXTzSgjJw/tPth8W9uQ8cJvrTyhLsY4+f5dcHU0vPl37NihLtIj1alTpyKPffnllyq5iBRnPnXqlAoiR40ahWHDhqlhhLVr1zZoHSGFpWfMmKF62uzs7PDpp5+qHqrt27erwKY4Q7YrgeLEiRPVUEt3d3c1rHHr1q2YPn26wdsQ8vg777xTZE7iY489pnrMJPCSwO/YsWM4cOCA6jEsjwSg06ZNU7dtbW0xbtw4TJo06bb+RgJMud+hQwd1X+b4yf5JbyURERERFZBOj2UHovHTjnBcSkhTy+xtbTCsXT080isUrQO9CtcE+jSpg8PnY9G+cT0EeruhOmGgRwbp1q2bCjQef/xxNG7cGC1bttQ9JsGRzFmTniR9rVq1Ur1yEigZso6Q3i/p0dPy8/ODr68vzp8/X2qgZ8h27777bjg7O2P58uW6XkkZ/tijRw+DtyECAwNLFLvv3r07WrRooXrSXnvtNfz444+6ZeXx9/cvEjC6ubmpQPR2/kbmF957771F/uZW+0FERERkLa4kZ2LurnAs2BOJxPQctczT2R4TuzXAlB4h8PdyLvE30oNnF+QBv2rUk6fFQM+MXBzscOStO1QvlqFF1C8nZeLOz//RZQAStjbAxpf6lvrmLO+5jSGB0qpVq1RPl8xt27RpE9q0aaMek+BHepLef//9Mv/ekHW0c9eKk4QqEtRUdLuyzn333aeGa0qgJ9fSy2fsvkkPY2kkIc3//d//qWGUsm1tT2FVc3V1LXH8SjueRERERNbkZGwyfth+EauPxCInr+AkOri2q+q9G9OpPtycamZIxDl6ZiTBnQyfNObS0Ne9cLxwQWAo13JflhuzHUMDS31OTk5YsWKFSkAic/SOHDmilsvQRektKz6PTj+jpSHrCJn/JrX5tKSXLS0tDe3bty91nwzdrgRyEpxu3LhRDa/UH/Jo6DbKIvPxwsPDVY+eBFaSdEU/QJaEMFVBjtHff/9dZNk///xTJc9NREREZGnz77acjsf9P+zG3V9vw/KDMSrI6xLijVmTOmHLy/3wYI+QGhvkiZr7ymqwcV2C0aepr0rvKpl/qnJSqPR+LV26VAUzEuxJ4PTuu++qoZ0yp+35559XPUt79uxRQaHM6xOGrCOkd1O2LXPzJIuk9JJJb1xZNeUM3a4Ec/Xr18eUKVNUFk5JamLsNsoiQzslA6nM9ZOsmB4eHkWGTkryFEmKIkNeZb5hZZFAU16b1D2UBDSbN29WAaz+/hARERHVZJk5eSqo+3H7RVy4WjD/zs7WBne3CVA9eO2Dbk4RqukY6FVTEtxVVYAnAZJ+D6BkqpQaejJfTwIjyfYopQRmzpypkpVIL5bMU5NASathw4a3XEdItssPPvhADYWUGnQSfEnmyrIYul3Zfyk98Msvv+Cpp54yeht16tQpEhyW1qu3cOFCPPzww0WWS+Ia2e4XX3yhErvI8ZLAsPi2JEmMzAksq2B6ac9f/G/atWuH9evXqyBZMm7Kc//nP//BV199VeZ+ExEREVVXUmZMkqmE+rjB3tYW83ZHYP7uCFxPKxiV5eFkj/Fdg1TPXX3v6lMWwVRsNMbm2adySYFqSVqSlJQET0/PEoW0L126pBKBSDAhh17KFhgzR68m+/bbb9WlOhb4liLykmnzzJkz5a5X2W2u3baWZN2ULKPF6whS1bCEz3jx7x2qXDISQUq0SCIpyY5LNR/b3LqwvS3Hon2RmLr8mC5vhUxnkoLmIrCWCx7uFYqxnevDw9mhRrV5ebFGcezRI7oNUlZBAtOvv/5a9Z6Z21133aV6LqXUw4YNG1QPZvHeTSIiIqLqLOZGOl5ffgz63VUS5LUM8MTT/RvjrlZ1YW9n/qDM3BjokcW41fBISzRnzhw1Z1GGbEr2TXOTYFPmCkoPjhR3lwQ0vXv3NvduEREREd22pIwcLNkfhe+3XSwS5Gm9NbQlwhrV4ZEuxECPLMaECRPUpTqRAubaIuaWQOYWylxBIiIiopri3JUU/LwzHCsOxSA9u2iWdC0ZuilJCukmBnpERERERGRR8vI12HTqCn7ZFY4d56/pljet644pPUKRl5+Pd1edVEM2JcibPqp1lWairw4Y6BERERERkUVITM/Gon1RKoNm9I0MtczWBhjYsq7KnhnWsI4uwdmdLeuapdxYdcFAj4iIiIiIzOr05WT8Ujg8MzMnXy2r5eqA8V2CMal7cKnlEaqy3Fh1xECPiIiIiIiqXG5ePv46eUXNv9tz6bpuuWTPnNIjBMPb14Ozgx1bpoIY6BERERERUZWRgua/7Y3Egt0RiE3KVMvsbG0wuJU/pvQMQecG3qwxbQIM9IiIiIiIqNIdj0lSwzNXHolFdm7B8Mw6bo6Y0DUY93cP5jBME2OgRyYjdeSkUPcHH3xQo4+qlIBo27Ytpk6dau5dIcL27dsxadIkhIeH82gQEZHFiEvKwKWENNT3dsGRqIIAb3/EDd3jbQK91PDMe9oGcHhmTQ304uLi8PfffyM1NRWtWrVCjx49ijy+ceNGHD58uMgyHx8fTJkypciy9PR0rF27FleuXEGbNm3Qt2/fEs9lqnWsUUZGBv7v//4Pq1atQnR0tGqDDh064IUXXkCzZs3UOgkJCXB2dkZNd/XqVSQlJaEmyMvLQ4MGDbBkyRKEhYWZe3eoAjIzM9VnkoiIyFIs2heJqcuPIb9YUXN7Wxvc3SZAZc/sGFyLwzNrcqD30UcfYc6cOarIs729Pd588020a9dOBRPagGHp0qXYsmULhg0bpvs7bUpV/WCxT58+cHNzU8HH+++/j0GDBmH+/PkmX8ca3bhxA/3791dBwTvvvIP27durZUeOHMHo0aPVtZ0dJ8pWRxqNBjExMcjKyjL3rhAREVENsPHUFby27FiJ5Q/3DMGTfRvBz7PmdwpYCltzPnnPnj1x8uRJ/PLLL/jxxx+xd+9e1YO3Zs2aIutJz9rMmTN1l3//+99FHn/ttdfg4eGBPXv2qMBx8+bN+O233/D777+bfB2LkRQDXNpacF3JXnzxRRUMbNu2DWPGjEHjxo3RpUsXNVTz6NGj5QZ5ixcvRr9+/dTfSND8xx9/FHlchj/Wr19fXSTIf+KJJxAfH19iqOTbb7+Nl19+GS1btsTYsWMr9fmE9HDdcccdaNKkCUaNGoUzZ86U6EWRbXXu3Fn9KPDJJ5+ooKks+q9Bhn2OGzdOtx1ZLsGzvLbiQ/Ckh1n2deHCherYN2/eXAXdO3fuLLJ96U3917/+pR6X7UibJScnl9iOHJ8RI0agUaNG6jMn+yLuu+8+9bgcu9IYun05buPHj1fryLakt774cXv33XfRqVMn1YMvxyMtLa3I4+Udj9J07NhRPXdwcLD6Tvn888/VjxLG7ttPP/2k/l56qOVYnzhxQi1/9dVX8dxzz+nW++GHH9T25POgJe81+fvir0Fe44MPPlhqmxZvC3H+/Hk88MADaNq0qfqMyQ8rsj198sNX79690aJFC/V6OGSTiIjMLSs3DysORWPEf3fg0V/2l7rOwJb+DPKqmsaCJCQkaOzs7DTLly/XLXviiSc0YWFhmv/+97+a+fPna86fP1/kb3JzczVubm6aL7/8ssjyPn36aCZMmGDSdQyRlJQkZ/vquriMjAzNyZMn1bXIz8vTZKfe0ORnpmg0WamGX/Z8p9G8W0ujecez4FruG/P3csnPN+j1pKena5ycnDTvvvvuLdcdMWKE5umnn9bdlzYLCgrSLFu2THPmzBnVfh4eHpoNGzbo1rlx44YmKipKXfbv36+20a1bN02+3v4NGDBAY2trq3nzzTc1p06d0sTHx5f6/KZ6vq+++kq9F7799lvNiRMn1PvxvvvuK7E/H3zwgWpPeT5nZ2fNokWLyjw22r954403NEePHtVcuXJFPeegQYM0d911l2bnzp1qWy+99JImICBAk5iYqP4uJSVFvZ/kdfz888+a48ePa1588UWNq6ureg1CttO9e3dNjx49NLt379Zs375d065dO7VdLe12fHx8NAsXLtRcunRJLYuMjFTLFy9erLZ3+fLlEvtuzPb9/f01S5cu1Zw+fVrzyiuvqP2+evWqbjtyHFq0aKFZt26dei2fffaZ5uOPP9Y9fqvjUZrY2Fi17+Hh4Zq1a9dqQkNDNdOnTzdq3+Q94u7urtr63Llzmt9//10zdOhQ9dicOXM0wcHBuu2NHDlS/e3bb7+te09J2x44cKDEa5D3zwsvvFBqm5bWFrLsrbfeUsdm165d6pjrf/+cPXtWfR7lsyDbnj17tsbFxUV9b5al+PcOVa68vDxNXFycuibrwDa3LmzvouISMzSfbTit6fTBn5oGr61Rl8ZT1+puay8NX1+riU1M11RHeRb2vV5erFGc2QM9Ocn59NNP1clN+/btNf/617+KHEgJ9Jo3b6557LHHNHfffbfG0dGxyEmc/L282PXr1xfZ7uOPP662Z8p1SpOZmakOtPYiJ5yyHTn5k9ehf0lLS1MnZxI8yQmhCvAkWDPDRZ5b7cMtLhKUaAOBW60rQZO0n9zOysrSeHt7qxNm/XVef/11zZAhQ8rchhxDOWmW46RdJsFB7969y31uUz2ftKeXl5d6T+qvJz8E6O/P4MGDizw+ZswYzSOPPFLm8+i/BtlXuf7rr79UQJmamlpkXQmEZs2apW4nJyer4z916tQi68h7UoIguS1Bk729vQoUirebBAv625k5c2aR7WRnZ6vlmzdvLnPfjdn+//3f/xXZtgTAq1evVvflsyUBiQRapR1bQ46HIRcJ8Js2baq7b8i+ffLJJ7qAv/h+ab8b5Ecm+RxLMCbvK217ynuuVq1aav3SXoO0d2ltWrwt5EcSCSL1l8mxknUlAJf78n0kPz4V/zs5rmUdD/m+kfe3fP8U/07ixfTHICcnR/34INc8vtbxHmObm78N2N5Vewzk/7vdF65q/jV/v6aRXlDX7T9/ab7eeEZzJSld8+uecE3D17VB3hp139xtl1dDPuMSYxga6Jk9GYvMDbp8+bIaGiZJLmTIVW5uLhwdHdXjTz31lEoCop2Xt2jRIjUMToavydy+lJQUtbxWrVpFtiv3tY+Zap3SzJgxA++9916J5fJaig+5ysnJQX5+vnp9ctHk5KDgVVY9eX7Y5t5yPe1rkDmU6m/KIa9NfjyQ9Y4fP67m8T399NN4/vnn1XK5SNKdOnXq6LYlSSQ+/vhjNVz22rVrum1cuHBBDZsUcl+GwZX3/KZ6PhmKKolWBgwYUOL5ZF3t/sjwP/3HfX191fDWsvZR+xrkPaAdVijZErOzs9XwPu2wT7mW987Zs2d17xMhiVL0ty1DDGVfZdmhQ4cQEhICf39/3ToyxFIS5shjMkxSu1yGq+pvR3tb+7krjTHbl+GE+tuRYy+JjWTZjh071HYaNmxY6rE15HiUZuvWrfjqq69w7tw59VmV7xQZVqpd35B9GzhwoJqTO3LkSDWcUobt1qtXT+1XYGCgSlgjQ7llmKjsk3wvffHFF+r5ZCiltEdZr0GWy/db8TYt3hYyHPfixYsIDQ3VvX+17zkZOly7dm01H1aGner/nSSwmjVrVpnHR5bLduT97uDgUOo6ZDpyrOU7RNrP1tassyOoirDNrYs1t3dmbj7+OnMdSw7H4+zVDN3y9oHuuK+dH/o2qgV7Oxvkpyehf7ATVjzcBlGJWQiq5QQ/D8dSp8pUB/kW1ublxSXFmT3Qk/kwMu9OxMbGqhMkWSZzgLQnQ/pkbpNkety0aZMK9FxdXdVy/flCQhpEkqoIU61TGpmn9dJLL+nuy98HBQWpE39PT88SQZM0jgRNcoGdF7JfDjfu5Cs5FvhfN9hoCk4AhcbGDvjXbsCznsGbsXdwlaw2t1xP5g9JkH3p0qWCfS6HvPllXf2gcN68eWq+XJHn1r5+QCXZkfb+5ptv1Im1LJf15e+168g2XVxcyn1+Uz6fkDYv6/m0r1H/cVmmXV7W38hr0La1XEtAIPPKJFAoTuaK6j9H8dfv5OSk/l6WSfAoyYuKP7esI4/pb6es1yXzLMvad2O2Lz/QFF9P3heyTL4o5W/Keh5DjkdxMsd36NChak6clPWQH2Zk7p1k5dWub8i+yffMqVOn1FzIZcuWqR8M5LtG5s5J20lwJQGlzK+T2/IZl6BV5hXL8vvvv19tp7TXIMdI2rt4mxZvCwlQJ06cWGrZDvk+0W6/eFvIe0P/dRYny+V1SmBrDVlxzU3e5/KekTazhBMCqnxsc+tije0dcyMD8/ZEYPG+aCRm5KhlTva2GNG+Hh4Ma4AWAUXPd7X8/IDWqP7yLazNjfm/3OyBnj458ZYTroMHD5a7npy4aAMy+aVdTh6lR0affo+QqdYpjfyNXIqTN0LxN4M2ENJe5Pd+Gyd3eUGGp5f1bQoM+wpY/QKgyQNs7GAz7MuC5ZVAehGkd0MSUEhP2a2ya2pfmwRT0k7SyyK9r6WRwF4SXqxYsUJ3jE+fPq1OjLXbKb7dspjq+SQJhmxn//796vatXqf+ff3rsv5G/7p169YqiYscU3nvl/c30mN555136pZLb568BnlcetekJ0h6LyWYENJTJVlk5bjo72vx/ZbnvtW+38729ZfJjzifffaZ6nmV91VxhhyP4v755x/VQ6gfHMl+6b8eQ/ZNSIIUSQ4jFwn6pNf28ccfV72pEtxJVmBJHCOfB23wJ4mapJdNPh+yrPhr0PZwy3vqVvsjx0dKyUgQWRZpc3kv6P+dvBf0t1uc9nlK+06iysHjbX3Y5tbFGtpb/v/adeEaft4ZrrJoasskBNZyweSwBhjXJQi1XM01Ls2629zWiH0w297KybUMZdInQ7SOHTumq8smw8nkRFyfZOWU4XdSBkHICdQ999yDBQsW6IY5SRY6OQGUYVimXMdidJwMvHAMeHBNwbXcr0Rff/21CpIkG6C2Xpe0jZxwSs+JfoZDLS8vL5XRUnpatNkJpcdi9erV+Pbbb9V9OdmX3oh169ap+zK0TIbEVYSpnk+288gjj+CNN95QwxK1gUNpw3Nvl2TzlGF6clzl+Irr16/rhpbqkwBJm/lTsjVKj/aTTz6p7stQQxlGKQGK9PhIzUPJEikBmn5wWNaXhQzJLJ5VVN/tbF+ffI4k+JHjK8Gedrii9MIaezy0JDiLiIhQPXtCeti0IwSMMXv2bCxfvlxXZiIyMlJ9qcvrFvLjgQzNXb9+ve6HBAn0pMdPeu5lWG5FX4OWjAzYt2+fykqq3Q9pF207C3m/rly5UtX61AZ52vc3ERHR7UrLysX83RG468utmPjDHvx5siDI69m4Dr57oBO2vtofT/RtZFVBXnVma85fCiQ1uFxkboyc5Eiaejl51KYyl3VkKJOk05cTbTlBlKF3ckIvQZmW/IIuPTmS4nzatGnqF3c5GZNtm3odi+EVCIT2LriuZNKzISegcpIvQbh2WKqkvpe5bGX18skcpocffhjDhw9X68tJs6Sgl/lQ2q5nOVGWE1tvb2/VqypzoLTDaI1lqueT+V6yjV69eqnAr2vXrqqnxtRkfyRgkyF8MgxQ9kmOrwwXlt4dfTI0UI61vC4payFDT6W0g3Y70kspQY48LsMXJfiRGpSG1DeUFP4SxEnAV1p5hdvdvpYE2X/99ZcavizvIdmOlDSRIdjGHg8t+T6Q7wgJtGR9CbS0pSuMIcdWSqnIe0aGOMoPGBL86ff4y0V6NOXzIORYyXBsKXWg/XWt+GuQHxfkvVPea9CS4yA/TMjQUXd3d/Xek+C4b9++unXkOadPn66+E6Ut5PVL+QYiIiJjxCVlYOeFBHUtwhPS8P7qk+g+YxPe/P04zl5JhaujHSZ1D8ZfL/bBgke7Y1Arf9jZGjgCjSyCjWRkMdeTS0+Q/DItPSfaIuVywqVPetekrp6sIydycvItJ+fFSW+gnKjJkDKpuyd1wYqfhJpqnfLIkFI5QZMTu9Lm6MlcN/nFX04ISxvWZemkzaSHQk7Si88tlB4yOVbFE9poE0HISW9px1KOgySr0G5TekJkXe0YZHlM5lcVP55lud3n05K2kXaUE399pe1PYmKiOjbF1y3+NxIolNbm0oOjTRyjTztccteuXSoQkOeRz0pZ8zrlcdmuvAeLv2bpkfLz89MlOip+zOS9L+rWrVvqtiuyfUm0JMepeDAtQyDlObVDQYsr63iURdaXAFICNbktr0V6+4zdN2kb2Y5815TWhrItCVK15L0j7VH8eOjvkzym3963agvt94gEjxLwlUbbsyrblueRfZOkMaUp/r1DlUve15JwQNrXEob4UOVjm1uXmtDei/ZFYuryY6qnTv5raurnjrPxqdBGBCF1XDE5LARjOteHpzOTeOVbWJuXF2tYVKBXE9X0QI9uj7FtXjzQo+rFEj7jDPSs+4SAKh/b3LpU9/aWHryeH23WzbnT16+ZLx7sEYK+TSTpCM9La0KgZ1HJWIiIiIiIyPQ/PB6KSsSXG8+WGuR9MbYdRnYsGAlDNQcDPSILJsMCo6Ki1K9IRERERMZIzcrF74disGBPJE7FFS0hpmVnY4PujQybKkHVCwM9Igsmw/20c82IiIiIDHE8JkkFdysPxyA9uyA7uqO9LYa2DUBdT2d8988F5GkKgrzpo1ojwKugJivVLAz0iIiIiIiqufTsXKw5EocFeyJwJDpJt7yhrxvu79YAozsG6soiSC288IR0hPi4MsirwRjoERERERFVU2cup+DXPRFYfigGKZm5apmDnQ0Gtw7AxK7B6N6wdomEYNKDx168mo+BHhERERFRNZKZk4f1x+Pw655I7Au/oVseXNsVE7sFY0yn+vBxdzLrPpL5MdAjIiIiIqoGLl5NxW97I7HkQDQS03PUMiliPrBFXRXg9Wrsw9IIpMNAj4iIiIjIQmXn5uOvk1fU3LudF67pltfzcsb4rsEY1yVIJVghKo6BHpnMf//7X3h7e2PixInV9vk///xzhISEYNSoUSbdN0t/7lvZsWMHVq5cievXr+Ott95CgwYNzL1LRERENZIUNb+UkAYne1tsOhWPxfujkJCarR6TqXb9m/nh/m7B6NfMT/XmEZWFgR4Z7MSJE1i9ejWio6Ph4+ODDh06YNiwYbC1tVWP//XXX6oUgLkCPVM8/7p169C5c+fbDra++eYbVftu3LhxVf7cpnb8+HH0798fb7zxBpo2bapq+xW3du1arFixosgyV1dXfP3111W4p0RERNWbJFV5Y8VxFK9p7uvhhPFdglTvXX1vVzPtHVU3DPToljQaDZ5//nn88MMPKohq3749bty4gXnz5mHatGk4duyYLtgzp2eeeabUIMQcNmzYgMaNGxsV6Fmqf/75B82bN8c777xT5jqHDh3Cli1bMHXqVN0yJydOAiciIjJE1PV0/LT9EubsDC/x2IyRrTGmcxAc7Mx/rkXVCwM9uqWZM2fi//7v/7B792506tSpyGPnzp0rkbJXn/T+zZ8/X103bNgQDzzwAHx9fXWPy2N///23ul2nTh10794dI0eOLHVIo4eHB9avX4969erh5ZdfLvFcZ86cUUM3w8LCivxd7dq1sXHjRuTl5eG+++5Dx44dDeodlMBF/kb2uXXr1gbv85w5c3D06FGEh4fj0UcfVcs+/PBD+Pv7IzY2FnPnzkVMTAzatm2LKVOmwNGxoKaNlmy7vP291TFNTU1VQfjp06fVsZowYQKCg4PL7bFbtGiRGpYp+zR58mS4uBQUTp01axZ++eUXxMXFqdcivZTTp08vdTuyD9rXS0REROXLyctXQzMlucrWc1ehKd6NVyjEx51BHlUIfxqopi6nXcbeuL3qujLl5+fj008/xcMPP1wiyBNNmjQpM9DbtWuX6v27ePGiGvInvT4tW7ZU97VCQ0NVoCQXT09PvPjii3jyySdLDGl89tlnVY+SBCwtWrQoMzjbuXNnkb977rnn8O6776qA7Nq1a+p5Dh48WO5rliDptddeUwGiBGYynFKCXEP3uVGjRirgDAgI0K0ngdP27dvVvst8N9nGgQMHVCCnTwK48vb3VsdU2qtPnz749ddf1X6kpKSo4bUXLlwo9bVK4CyBpARyEhR/++236NWrF7Kzs3XtGxQUpHpKZV9kuG5ZZBtyLKRXT4ZxSk8wERERley9+3TDafT4aDOenH8A/5wtCPK6hHij+BmVnY2NKmpOVBHs0TMjORHOyM2Ancau3F6x4lZdWIUZe2YgH/mwhS2mdpuK4Y2GG/XcLvYuBj2nBAhXr15Fz549YSwJDmVel5z8a0nvkwRsEkwJ2a7+tmWoowQwb775pppvp9tfFxc1hNDBwcGofZBgbdOmTbCzs1P3z58/r3qoyuvVkyBn69atcHd3V/flOEngJ89vyD5LoCXBkQzd1PZwSVs/9NBDKrCTXjJ7e3u1XemVM2Z/b3VML126pIK/y5cvo27duurx119/Hbm5BQVU9ck+SSAsF+m1FY899pgKQr/77js1FHbAgAHYt28fIiIibtlbJ69XehATExPx+OOPq9cpwbb2tRAREVlz793Gk1fw695IbDuXoFvu4+6I+zoHqfl3Deq4YdG+SExbfhx5Go0K8qaPas3C5lRhDPTMSIK8nouND6D0SbD3nz3/URdj7Jm4B64Ot/6FKDk5WV3LkD1jSIAoQwelB0qGVEpQIRdZLr1Muv3Pz8eaNWtUj1lCQoK6L/P95G/0A70777zT6CBPSBIR/UCjWbNmJYKr4oYMGaIL8rSB3IgRI1SwJAGaoftcfIirBG3aAFer+Prl7a8hx1SGh0pv4nvvvad6QWVunf5r0SfDR2WfZGinVq1atXDPPfeooFYCPUM98sgjKtDVkiGpMgxUhrFyOCcREVmriGtpWLgvCkv2RyMhNUu3vHcTH0zsGowBLerC0f7mALtxXYLRp6kvwhPSVU9egFfBVAqiimCgR+XSBniRkZFGHSkJgIT0REmGTq2uXbuquXZakyZNUoGLXMuwQAnmZA6bfjCoDUAqQjvXTEuCKJn7Vh4ZNqlP9l/+RuawyfEwdJ/1SfIaoe1lq8j+GnJMZYilBGmffPIJ7rjjDrVM9lPmCBZPjhIfH697fcVf762GtxYnw1T1yZBP2U8ZSstAj4iIrLHuncy9234+oUjmzLGd62Nc52AE1yn7x3YJ7hjgkSkw0DMjGT65Y+wOdTJv6NDNK+lXcO/v96qePC1bG1v8PuJ31HWta9RzG0KGIMqwRCmrIMPxDBUYGKiuJYnJ0KFDywx+fvvtN+zfv183/0/mpcnwQXOKiooqcl+GLTo7O6tkI4buc/H21PbcSe9bWb1+pjimok2bNrqeQxl2KXP0JMAsnsBG2lb7+vTr4sn98pK3GCojI4Pz9IiIyGpI7buF+yKxdH80rqXdrHvXp4kvJqjeOz8mVaEqxWQsZiTBgARcMoTS0EuoVyje6fGOCu5UA9rY4p2wd9RyY7ZjzJzAGTNmqKGKP/30U5HlMmRx4cKF6ro4CWb69u2L999/Xzf8UxsUbd68uci6+j1h8lzmJjXhZEijyMnJUYXYZeim/jG71T7LXDvpAdQP0mTunqybmZmpWy7z8QxlyDGVTJ979+7VPdalSxcVtMk6xUngKvv01Vdf6drw1KlTal7d6NGjYQwppq5PtnH48GE1DJaIiKimysrNw+ojsZjw3W70n/k3Zv9zUQV5fh5OePaOxtj6Sn/88nBXDG7tzyCPqhx79KqhUU1GoUe9HohKiUKQRxD83fwr9/lGjVIJQf7973/jiy++0NXRkwLqPXr0KLNWnGSQlABJ5pn17t1b/Y1kh/zss8/U4zKXTLJVSmmCwYMHq8ckCDJ3/bVWrVqpuXKSZfLkyZMqqJPXb8w+y+uWIZOS2EXmyMnQSdmGzH+THrdu3bqpeXbyPJLwxFC3OqYyjFRqHsp8QllHnkOS6RTPZKr1v//9D4MGDVLDLCWZipR1kFqJxUtc3Moff/yhkr7IvDwZYiqZReX+2LFjjdoOERGRJYtLysDhqBTUTrPHljNXsfRANK7r9d71a1rQe3dHcz/Ys+4dmZmNhjnQTUp6Wry8vJCUlKRS7+uTgECyIkpWQxkKKIdem+DDmB42c5H9l7lpkhxE5nHJSb12OKGQIEHmiGnr2Al5jZK0RHrIJCOjBDjFk4PINuVxmefVr18/LFiwQF1rhxNKCQB5PumdKk/x5y/t7+S50tLSVHKX0mj/RnrPZNijtI8EQsbus5Ag8ciRI+r5JNumvC+kh1Dq5F25ckUFzPr1+QzdX0OOqQwtPXv2rBqyKb125SWySU9PVz2CEjRKm7Zr167I41ITUN63EmCWR4Z8yjFzdXVVr032zdpZwme8+PcOVS7pHZf5rzKfV5I0Uc3HNrce83aF4+2VJ1C8eJC/pzPGdgnCuC5BCKzF5Ck1Tb6Ffa+XF2sUx0CvCg9+dQ/06Paxza2LJbQ3Az3rPiGgysc2r9ny8zXYc+k65u0Ox7pjJWsXfzK6LUZ1DGTvXQ2WX40DPQ7dJCIiIiIqllhl+cFoLD8Yg5jEjDKPTVBtVwZ5ZLEY6BERERGR1UtKz8GaY7FYdiAaByMTdcfDw8ked7TwxaojcdDojduUguZS647IUjHQIyIiIiKrlJOXj61nr6qeu79OXVE18IStlEVo6ovRHetjYMu6cHawQ49GkZi2/BjyNBLkAdNHtWa9O7JoDPSIiIiIyKqciE3CsgMxWHUkBgmpBVkzRXN/DxXcjWhfD36eRRNYjesSjF6N6+Dw+Vi0b1wPgd5uZthzIsMx0CMiIiKiGi8+JRMrD8Vi2cFonL58sx6uj7sjRrQPVElVWgZ4lps8K8DLBXZBHvDzYnZNsnwM9MyAFS2IqCqzhRERWavMnDz8dfKKCu5kiGZ+4Rw7RztbNSRTgjsZounAmndUAzHQq0JSy0x+JZIC1r6+vmqZuVOvk/Wl2yfraG957uzsbPV9I+mgHR0dq/T5iYjMUcxcsmWG1HFFTGKmypq55mgcUjJzdet0DK6F0Z3qY2ibevByLbvGLFFNYBGBXlRUFFJTUxESEgIXl9K7wmNjY1UNi8aNG5coDm2OdSrCzs5OFeKWguPh4eHqREx+bZeTMJ70Wwe2uXWxhPaWAvbBwcEWUfuHiKiyLNoXianLj+l67PRJEXPpuRvVsT5CfTivjqyHWQO9NWvW4LXXXlMFfeUXbwmwXnnlFbz99tu6dbKysjB58mSsWrVKBUmyzsyZM/HUU0+ZZZ3bJYFjkyZNkJOTo04Ar127hjp16vAkzEqwza2Ludtbflxi7zER1fQf1FYdicVry46VeOzuNv54oHsIuoXWhq2k0SSyMvbm7smTYC80NFTd/+uvvzBo0CD07NkTAwYMUMs++OADbN++HefPn0dgYCCWLVuG++67D507d0aXLl2qfB1TnXzJRU4CZTins7MzAz0rwTa3LmxvIqLKkZKZo0oizN0VjgtX00pdR4K8sEZ12ARktcw6lkd6yrRBnujXr5/69VkCQK0ff/wRjz76qAq8xOjRo9GyZUv89NNPZlmHiIiIiMzj3JUUvPX7cXSfvgnvrDqhgjwXB1sU769jMXMiC5ijl5SUhFOnTiE5OVkFWq1bt8aoUaPUYzJ08vLlyyV607p164ZDhw5V+TpEREREVLVy8/Kx8dQV/LIzArsuXtMtb+znjslhDTCyQyDWHYvDtOXHkafRqCCPxcyJLCDQkyDvhRdeQEJCAq5fv44vv/wSnp6e6jG5L2rXrl3kb2S+i8x7qep1SiPz+uSiJQGrdsjWrdKay+PaZA1kHdjm1oXtbX3Y5taHbV55ElKzsGhfFH7dG4W4pEy1TKba3dmirgrwwhrW1iW6uq9TfVXMPOJaOhrUcVX17irj/IrtbX3yLex83Zj9MHug1717d+zevVvd3rRpE+6++26VeVPmxsn8NaEfSImMjAzdY1W5TmlmzJiB9957r8RySWkuSWZu1VDSoylvHmbEsw5sc+vC9rY+bHPrwzY3LTknOnE5DUuPXMWmczeQk1eQRtPbxR7DW/tgZBtf+HtKuZg8da6lzw5AQ0mWnpWC+PibBdFNie1tffIt7Hw9JSWl+gR6+iQBS9euXbF27VoV6AUFBakDKsMq9cn9Bg0aqNtVuU5ppk6dipdeeqlIj55sS+rkaXsmy3vjyC9Rsq4lvHGo8rHNrQvb2/qwza0P29x0hc1XH43DvN0ROB5TMDpKtA/ywuTuDTCkjT+c7CWUMy+2t/XJt7DzdUniaPJAb9asWQZv9MknnzTooEmJAScnJ90yuS+JWCTY09Z/kh6/1atX4/7771fL0tPTsXHjRrz11ltVvk5pZP/1X4OWvBEMeTPIG8fQdalmYJtbF7a39WGbWx+2ecVFXU/H/D0RaohmYnqOWuZob4vh7eqp4Zlt69eCpWF7Wx8bCzpfN2YfbDTSD2kAKR5uKClPcCsyJFICuieeeEJltkxMTMTs2bNx4MAB7NmzB40aNVLrbdmyRZVceP311xEWFoavv/4aZ86cwZEjR3Q9ZlW5zq1Ij56Xl5fq4jWkR08Ks/v5+VnEG4cqH9vcurC9rQ/b3PqwzQ0Tl5SBSwlpqmB5XQ9nbD+foEojbDodD+2ZqBQ2n9S9AcZ1CUJtNxmeaXnY3tYn38LO142JNexNGbwZQ+bhrV+/XgVTK1euhJubG3r06IH58+errlGt/v37q7l73377LbZu3Yo2bdqocgf6L6wq1yEiIiIiwy3aF4mpy48hXwNVBqGOuyMSUrN1j/du4oPJYSG4o7kf7FjYnMhkDO7RI8OwR4+q069CVLnY3taHbW592Oa37snr+dFmFeTpc3O0w32dg/BAWAM08pUMKtUD29v65FtDj56p5+gRERERUc0k/Qj7wm/gkz9OlwjyxLcTO6J/cz9z7BqR1TA40Js5c6bBG2WgR0RERGSdxc3XH7+MH7ZdxJHopFLXkYLmzQM8qnzfiKyN2eboEREREVHNkJKZozJnztkRjpjEDF32zNEdA1HPyxlfbjyPPI1GBXnTR7VWBc2JqHJZVB09IiIiIqo+JKj7ecclLNwbhZSsXLWsjpujmnsnGTR93AtKUI3pHITwhHSE+LgyyCOqDoGe1L2LiYlBbm7BB7sipRiIiIiIqHo5Gp2I77ddwrpjccgrnITXyNcNj/ZuiJEdAuHsULS4ufTgsRePqBoEegkJCar+nZRFyMvLK/E4E3kSERER1Sz5+RpsPHUFP2y/hL2XruuW92hUB4/1boi+TX1hy/IIRNU70HvppZdUwfP9+/ejQ4cOOHXqFPbu3YupU6fi5ZdfNv1eEhEREZFZZGTnYenBaPy0/ZIqei7sbW0wrF09PNIrFK0DvdgyRDUl0Pvzzz+xa9cuhIaGqvtNmjRB8+bNERwcjOeeew4vvviiqfeTiIiIiKpQfEom5u6MwPw9EUhMz1HLPJ3tMbFbA0zpEQJ/L2e2B1FNC/SuXLmCkJAQdVsK9l27dk0VEezatSvOnDlj6n0kIiIiokosai49daE+bmoe3ZnLKao8wsrDscjOy1frBNV2wcM9QzG2cxDcnJjLj6g6qPAn1cbGRl23bt0a8+fPV8M5ly5dioCAAFPuHxERERFVkkX7IjF1+TFV1FxO7Rr7uuNcfKru8Y7BtdT8u0Gt/GHH+XdENT/Q69mzp+72u+++i+HDh+ONN95QWTi/++47U+4fEREREVVST542yBMaDVSQJz/lD2njj0d6NUSnBt489kTWFOht375dd/vOO+/EhQsXcOTIETVXr1GjRqbcPyIiIiIysdOXk/HZhrO6IE/fl+PaY0SHQB5zomrOJIOsZbgmh2wSERERWa7MnDysPx6HBbsjsT/iRqnr2NnYoGvD2lW+b0RkerYV+aOzZ8/inXfeKbFclp07d84U+0VEREREJiCJVqavO4WwGZvw4qIjKsiT+XZDWvvj0V6hsLO5GeRNH9Wahc2JrLlH79lnny21Xp7M3ZPyCuvXrzfFvhERERFRBeTk5WPjyStYsCcS288n6JbX83LGhK7BGNslCHU9C8ojPNI7FOEJ6QjxcWWQR1SDVHiOnmTYLC4sLAyjR482xX4RERERkZFiEzOwcG8kFu6LQnxKllom2TT7NfXF/d0aoF8zX9jbFR3QJSUV5EJENUuFAj1vb28cP35cBXb6jh49Ck9PT1PtGxERERHdQl6+BlvPXcWC3RHYfDpel2DFx90R47oEYXyXYATVduVxJLIyFQr0xo0bh0ceeQQ//PADunfvrpbt2rVLLZPHiIiIiKhyXU3JwuL9UfhtbySib2Toloc1rIP7uwdjUEt/ONpXKB0DEVlroPfhhx/i/Pnzak6eo6MjNBqNqqEn9fT+85//mH4viYiIiEidc+2+eB0L9kRgw4nLyMkr6L7zdLbHmE5BmNgtGI393HmkiKhigZ6LiwtWrlyJY8eO4eDBg7CxsUGHDh3Qpk0bHlIiIiIiExY1l6yZPm5OKqmKBHgXrqbpHm8fVAuTujfA0LYBcHaw43EnItPU0ZPAjsEdERERkenJkMxpK45BU6youaujHe7tEIiJXYPROtCLh56IKq9gOhERERGZxrkrKZi3KwJzd0eUeOzlu5rhwbAG8HB24OEmonIx0CMiIiIysyvJmVh9JBYrDsXgRGxymet1CvZmkEdEBmGgR0RERGQGqVm5+OP4Zfx+KAY7LyToyiLY29qge8M62HE+AfqjNu1sbFRRcyKiSg30srKy4OTkpG7fuHFDJWdp1KgRevfuXdFNEhEREdVoOXn52HbuKlYcisVfJy8jMydf91jnBt4Y0SEQ97QJQG03RyzaF4lpy48jT6NRQd70Ua1Z2JyIKjfQ+/XXX7F+/XrMmzcPeXl56Nu3L6Kjo5GamorZs2fjoYceqshmiYiIiGpkSYTDUYmq52710ThcT8vWPdbQxw0jOwRiRPtABNcp2ls3rksw+jT1RXhCuurJC/ByMcPeE5FVBXofffQRFi1apG5v27YNKSkpiI2NxZYtW/DKK68w0CMiIiKrJ2URJLj7/XAMIq6l646Hj7sjhrWrpwK8NoFeqkxVWSS4Y4BHRFUW6Emx9NDQUHV78+bNuPfee+Hs7Iz+/fvj4sWLFdoRIiIioupY5+5wVAraO3kg0NsNCalZWHMkFr8fjlW9eFouDnYY3NpflUXo2agO7O1szbrfRFTzVSjQCwwMxN9//40BAwZgyZIlmDlzploeERGBoKAgU+8jERERkcWROXRTlx9TSVRscBZN67rj/NU05BVmVbG1AXo38VU9dwNb1oWbE3PgEVHVqdDPSS+//DKGDx8Of39/2NvbY+DAgbq5e5MmTTJ4O9u3b8fIkSNRt25dFTyOGzeuRI/g008/rZ5D/9K+ffsS2/rmm29UMhh3d3eEhYVh165dlbYOERERWbfYxHS8XhjkCbk6cyVVBXnt6nvhnWEtsWfanfjl4a6qF49BHhFVi0DviSeewN69ezFnzhzs3LkTjo6OanmTJk3w0ksvGbQNSeIydepUTJkyBceOHcOOHTuQnp6uegklqYv+eiNGjEBmZqbucuDAgSLbkv147bXX8Nlnn+HChQvo0aMHBg0ahKioKJOvQ0RERNYrOzcfKw5FY9IPe6HRr31Q6LOx7bDymV54qGcofD0KspMTEZmDjUZSQVkIGfoZEhKCjRs3qoBPPPnkk0hISMDSpUvL/LuWLVvijjvuwLfffqvuy0uqX78+HnzwQUyfPt2k69xKcnIyvLy8kJSUBE9Pz3LXzc/PR3x8PPz8/GBry7H61oBtbl3Y3taHbV5zXU3Jwq97IjF/T4S6XRopgbD99f5MnlKD8TNuffIt7HzdmFjD4MHis2bN0gVe2ttlkXUq4tq1a+raw8OjyPINGzaoFyIvSur0SdbP4OBgXQ2/U6dO4YMPPtCtL9mrJDGM9Daach0iIiKyLsdjkjBnRzhWH4lFdl5Bzbu6nk54oHsDlWBl+rpTyNNIkAfWuSMii2JwoKdNuCJBnPa2KQM9GaL573//G+3atUOnTp10yyW759y5c1WtvpiYGLz44osq2JPhnhL8xcXFqfUkytbn6+uL/fv3q9umWqeswvFy0Y+ytdG/XMojj0uv4a3Wo5qDbW5d2N7Wh21eM+Tm5ePPk1fw884I7I+4oVvePsgLU3qEYEhrfzgUZs0c1NIPRy/Gom3Degj0duX/6TUcP+PWJ9/CzteN2Q97Y0oqlHbbFOTgyby/EydOqAQtdnZ2usdkzpxW7dq1VZbPgIAALFy4EI8//niZ25Su1VuNSjXFOjNmzMB7771XYvnVq1fVfMJbNZR0u8r2LaErmCof29y6sL2tD9u8ekvKzMWq4wlYduQqLqcUFDWXeG5Ak9oY294PrQPc1LIb1xJ0f2OXn4+G7nmwy0pGfPzNHANUM/Ezbn3yLex8XeqXG8rseX7loP3rX//CypUrVcH1pk2blru+t7e3GrZ57tw5dV8yf2oDK30yllayeZpyndJIQhn9BDTSoyclJqQn0JA5ejI8VNa1hDcOVT62uXVhe1sftnn1dO5KCn7eFYEVh2KQmVPwa3ltVwdM7BaM+7sFo66nc5l/yza3Lmxv65NvYefrUru80gO93bt3q7lr169fL/HYhx9+aPB2nnnmGZVoZdOmTWjduvUt15dASrJgSq+etpdPgsN//vkHo0aN0gWPUufv/vvvN+k6pXFyclKX4uSNYMibQd44hq5LNQPb3Lqwva0P27x6yM/X4O+z8Wr+3bZzN3voWgR44qGeIRjerh6cHW6OMCoP29y6sL2tj40Fna8bsw8VCvRkjt6rr76KNm3aqB62inruueewePFibN68WW2rOJn7JnX5pNesVatWiIyMxPPPPw83N7ciwZfM7ZNetbvvvhvdu3fHJ598ogJQ/bmCplqHiIiIqq/UrFws2R+FX3aGI/xauq6wuRQ0l5II3UJrq5M6IqLqrkKB3pdffokVK1ao+nYVJRk2pTi5fJl26NChyGPfffcdHn74YdVTJoGe9PodPnwYtWrVUolY9uzZU2Q4pczVS0xMxEMPPaSGWkrP4Lp161SpBlOvQ0RERNVDXFIGLiWkIdTHTdW/+3lnOJbsj1bBnvBwtsf4LkGYHBaCoNqu5t5dIiLz19GTXjzJgOnqentfirm5BV+0xUkylur6axrr6FF1qsVClYvtbX3Y5pZj0b5ITF1+DPmlnOU09HXDQz1CMKpjfbg53V66Ara5dWF7W598a6ijp0+GNe7YsQMDBw6s6D4WPLm92XPBEBERUQ1zLDoRry87huIxXveGtfFUv8bo3dgHtjJek4ioBjM40po/f77udteuXTF+/Hg1pLJx48Ylet9kuCURERFRVUnLysWGE5dV5szt5xJKBHni+QFNEdaoDhuFiKyCwYHeyy+/XOS+g4MDZs+eXeq6DPSIiIioKgqbbzufgN8PxeDPE1eQkZNX5rp2NjYI8eE8PCKyHgYHepcvX67cPSEiIiK6BUktcCwmCcsPxmDN0VgkpBYUNheSdOXe9oG4t0M97L54DdOWH0eeRqOCvOmjWiPAy4XHl4ishn1F59aVlUilvMeIiIiIKiLqerrquVtxOAYXr6bpltdxc8SwdvVwb4dAtKvvpZtO0qCOG/o09UV4QrrqyWOQR0TWpkKBXl5e6UMjsrOzmWCFiIiITCIxPRtrjsapAG9/xA3dcid7Wwxq5Y9RHQLRq4kPHOxKz4QnwR0DPCKyVkYFej/88EOpt7WpR/fu3YtmzZqZbu+IiIjIqmTm5GHL6XiVVGXLmXjk5BWkVZGOup6NfFTP3V2t6sLD2cHcu0pEVHMCvQ8//LDU29rkLFJYfNasWabbOyIiIqqR9IuZ1/Vwxt7w66rnbu2xOKRk3pwC0iLAEyM71MPwdoHw93I26z4TEdXYQC88PFxdd+7cGfv376+sfSIiIiIrKWYuM+q8XByQmJGjezzAyxkjCpOqNPcvvyAwERGZcI4egzwiIiKqiMhraUWKmcu1BHlujna4p22AGprZPbQOC5oTEZkj0CMiIiIyRlJGDn7bG4nZ/1wotZj5/yZ1RN+mfjyoREQmwkCPiIiIKk1MYgZ+2n4JC/dGIi279KzdUueuaV0PtgIRkQkx0CMiIiKTOxGbhO+3XsTqo3HIk8l4AJrWdcdjvRsiOzcfb688wWLmRESViIEeERERmYRGo8G2cwn4butFbD+foFse1rAOHu/bEP2a+uoKmt/Rwo/FzImILDHQ2717N3bu3Inr16+XeKx46QUiIiKquaSHbs3RWBXgnb6copbZ2drg7jYBeLx3Q7Sp71Xib1jMnIjIAgO9mTNn4tVXX0WbNm3g7e1t+r0iIiIii5ecmYPf9kRizo5wXE7OVMtcHe0wrksQHu4ZiqDarubeRSIiq1WhQO/LL7/EihUrMGLECNPvEREREVl8sXMJ7n7dE4nUrILi5r4eTpjSIwSTujWAl6uDuXeRiMjqVSjQS0tLw8CBA63+4BEREVmTk7HJ+GHbRaw6EovcwgQrjf3c1fDMER3qwcnezty7SEREtxPode/eHTt27GCwR0REZAUJViSxisy/k0QrWt1Ca+MJlWDFj8XNiYhqSqDXtWtXjB8/Hs888wwaN26sy6ClNWnSJFPtHxEREZlhaOb5+FRciE/F4v3ROBmXrJbb2kAlWJESCe2CarFdiIhqWqA3e/ZsODg4qOvSMNAjIiKqnn7ZGY53V51AwcDMAi4OBQlWHunFBCtERDU60Lt8+bLp94SIiIjMJj45E19vPo/5uyOKLJcxO78/3QPN/D3Ntm9ERGQ8FkwnIiKyYjJE8/utF7HiUAyy8/JLPC49e9fTcsyyb0REVAWB3qxZs9T1k08+qbtdFlmHiIiILDfByv6IG5j9z0VsPHVFt7xtoBeOxSZBozdu087GBiE+rIdHRFRjAz0pkq4N4rS3y8JAj4iIyPLk5Wvw18krmL31Ag5FJqplkk9tYIu6KoNmpwa1sWhfJKYtP448jUYFedNHtUaAl4u5d52IiCor0Dt//nypt4mIiMiyZebkYfnBGHy/7SIuJaSpZY72thjdMRCP9m6IRr7uunXHdQlGn6a+CE9IVz15DPKIiKonztEjIiKqoRLTs1VylZ93hiMhNVst83S2xwNhDfBgjxD4eTiX+ncS3DHAIyKq3hjoERER1TDRN9Lx4/ZLWLQvCunZeWpZYC0XPNwrVJVJcHfif/9ERDUdv+mJiIhqiBOxSfhu60WsORqn5uOJFgGeeKJPQ9zTNgAOdrbm3kUiIrKGQC8pKQk//PADdu7cCXt7e/Tq1QuPP/44nJyciqy3Z88e/O9//8OVK1fQpk0bvPrqq/D19TXbOkRERJaUQXP7+QQV4G07l6Bb3quxDx7v0xC9m/jARjKuEBGRVanwT3tZWVm62zdu3MDPP/+Mbdu2Gfz3eXl5aNeunSq+fv/992PYsGH49ttvMWTIEPWY1vbt29G7d28VbD322GM4cOAAevbsibS0NLOsQ0REZE5xSRnYeSEBUdfTsPJwDO75ejse+HGvCvLsbG0wvF09rHm2F+Y/2k0lVWGQR0RknWw08lOgkX799VesX78e8+bNU0FZhw4dEB0djdTUVMyePRsPPfSQwT16Xl5euvuHDh1Cx44dsWvXLnTv3l0t69u3L/z8/LBkyRJ1X54jICAAH3zwAV544YUqX+dWkpOT1WuS1+bp6Vnuuvn5+YiPj1fPaWvL4TTWgG1uXdje1qey21xKH0xdfgyFozJ1XBzs1Ny7R3qFIqg2a95VJX7OrQvb2/rkW9j5ujGxRoX29qOPPsK0adPUbenFS0lJQWxsLFauXInPPvvM4O3oB3miVq1a6jo9PV13Lb1sw4cP163j7u6OO++8E3/++WeVr0NERGQu+8Ov4/VlJYO8x3uHYufrd+Dd4a0Y5BER0e3N0ZM6eqGhoer25s2bce+998LZ2Rn9+/fHxYsXUVGffPKJipa7deum7ksvoUTRgYGBRdaT+1u2bKnydcoawqo/jFWibCHbkkt55HHpUL3VelRzsM2tC9vb+pi6zfPzNdh6LgHzdkdgy5mrpa7Tr5kvvFzs+X+JmfBzbl3Y3tYn38LO143ZjwoFehL8/P333xgwYIAa5jhz5ky1PCIiAkFBQRXZpBryKYlZVq9eDTc3N7UsO7ug5o+Li0uRdV1dXXWPVeU6pZkxYwbee++9EsuvXr2KzMzMWzaUdLvKm8cSuoKp8rHNrQvb2/qYqs2TM3Ox9uQ1LDt6FdGJN39MLM7WBnDXZKhhRWQe/JxbF7a39cm3sPN1GUlZqYHeyy+/rIY4enh4oF69ehg4cKBu7t6kSZOM3t4vv/yCZ599FvPnz8fgwYN1y729vdX1tWvXiqwv97WPVeU6pZk6dSpeeumlIj16EuxKQhdD5ujJJHlZ1xLeOFT52ObWhe1tfW63zU/FJWPe7kisPByLjJyCxGQezva4r1N93N8tGHvDr+PNFceRpwHsbIAPR7ZG60b1K+GVkKH4ObcubG/rk29h5+syirJSA70nnnhCDa+MjIxUwzUdHR3V8iZNmmDkyJFGbUsSukhJhblz52LcuHEleg5lKOfBgwcxdOhQ3fJ9+/YhLCysytcpjZSCKF4OQsgbwZA3g7xxDF2Xaga2uXVhe1sfY9s8Jy8fG05cxtydESqQ02ru74HJYSG4t0M9uDoW/HfdyM8D/Zr5ITwhHSE+rgjwKjoKhcyDn3Prwva2PjYWdL5uzD5UeG/bt2+v69XTkt487bBLQyxYsACPPvqo6tEbP358qetMmTJFDemUunZChnYeO3ZMLTfHOkRERKYQn5yJLzeeRc+PNuOZXw+pIM/e1kYVNl/8RBjWP98bE7sF64I8LQnuwhrVYZBHRESVUzB99+7dqtD59es3f33U+vDDD2/59zLW9cEHH1SZN2fNmqUuWq+88gruuecedfvdd9/FqVOn0LhxY5UA5ty5c/j888+L9LJV5TpEREQVJXM89kfcwC87w/HH8cvILUyh6evhhIldg1VgV9fT8GE5REREJg30JPnKq6++ijZt2pQ7f608kuRk48aNpT7WrFkz3W1JjrJq1SqVzVN62uSx2rVrF1m/KtchIiIyVkZ2nipu/suuCDUPT6tzA29M7hGCwa384Whv/iFBRERk5YHel19+iRUrVmDEiBEVfmIHBwf069fP4PUbNmyoLpayDhER0a1EXEvDvF0RWLw/SmXSFM4Otri3fSAeCGuAVvWK1pMlIiIya6CXlpamy7RJREREBeKSMnAwMhmZ0dlYd+wy/j57FZrCAufBtV0xOawB7usUBC9XBx4yIiKyvECve/fu2LFjB4M9IiKiQj9tv4QP1pxEYVxXpKD5g2Eh6NtUUnPb8HgREZHlBnpdu3ZVWTKfeeYZlbhEUo7qq0gtPSIiouomP1+DHRcSMGdHODafLlq0XP5nXPREd3QNrWO2/SMiIutVoUBv9uzZao6dXJeGgR4REdX0IZpL9keruXfRNzJKXUd69vLyq3zXiIiIKh7oXb58uSJ/RkREVG1JYXPptVu0Lwp/n4lHYWUEeDrbY1DLulh2KEY3H0/Y2dioouZERETVqo4eERGRNbiUkKaCu6UHopGQmqVb3i20NsZ3DcKQ1gFwdrBDl9DamLb8GPI0EuQB00e1ZlFzIiKqfoHe4cOH8csvv6iacytXrlTL5s+fj1GjRqkaeURERNVVZk6eKmi+cF8kdl+8rlvu4+6EMZ3qY2zn+mjo617kb8Z1CUavxnVw+Hws2jeuh0BvNzPsORER0W0Een/88YcK6IYOHaoKjGudP39e1dibNm1aRTZLRERkVlLMfOHeSKw4FKOreyeJMiVjpgRyA1r4wcGu7MLmAV4usAvygJ+XSxXuNRERkYkCvTfffBNz5szBuHHjimTcnDBhAoYMGcJAj4iIqo2UzBysPhKHRfsicSQ6Sbc8sJYLxnUJUj149WoxcCMiIisI9E6ePIlhw4ap2/qBXmBgIKKjo023d0RERCbMlCnz7UJ93ODv6YyDkYmq927N0Thk5OSpdRzsbDCopb8K8Ho19mHdOyIisq5Az8vLSwV0TZs2LRLo7d69WwV7RERElkR666YuP6YyZcr/Wr4eTohPuZlYpZGvGyZ0DcbIDoGo4+5k1n0lIiIyW6AnQzSfe+45NXxT5OTkYPPmzXjiiSdYQ4+IiCxKbGI6Xl9+TFf6QK4kyHOyt8GwdoEY3yUInRp4F/nhkoiIyCoDvf/85z8qoJPeO41GA3d3d2RnZ2P06NF46623TL+XRERERsrKzcPao3H4dvP5IvXttP53fycMaFGXx5WIiGqkCgV69vb2WLZsGU6dOoX9+/cjPz8fHTt2RJs2bXDt2jU4OXHYCxERmUd8SiZ+3ROJ+bsji9S90yfFzFvW86zyfSMiIrLoQG/y5MlYsGABWrRooS5aEuQNGDBA1dgjIiKqSseikzBnxyWsPhqLHKlaDqCupxMmh4XA2d4W09edRp5Go4I8FjMnIqKarkKB3rFjx/Dss8/iv//9r25ZQkKCCvICAgJMuX9ERERlysnLx4YTlzFnRzgORNzQLe8YXAtTeoZiSGt/Xd27u9sGIDwhHSE+rqreHRERUU1WoUBvw4YN6NmzJ+rUqYP3339fF+TJnL0VK1aYfi+JiIj03EjLxq97ZXhmBOKSMnWlEYa2rYcpPULQLqhWieMlwR0DPCIishYVCvQkoPvrr7/Qq1cvODg4YMmSJahfv74K8jg/j4iIKsvpy8n4eUc4VhyKQVZuvlrm4+6Iid0aYFK3YPh5OvPgExERVTTQE02aNMEff/yBfv36qYBv+fLlDPKIiMjk8vI12HTqihqeueviNd3y1oGeeKhHKIa2C4CTvR2PPBERUUUCvcaNG5e6XMorHD9+HK1atdItO3/+vKGbJSIiKlVSRg6W7I/CL7vCEXU9Qy2zs7XB4Fb+mNIzBJ1Z+46IiOj2A72XX37Z0FWJiIiMEpeUgUsJaQj1cUN6dh5+2RmOpQei1W1Ry9UB47sE44GwBgisxUQqREREJgv0nnzySUNXJSIiMtiifZGYuvwY8kspat60rjse6hmKe9sHwsWRwzOJiIgqfY6eVkpKihq+6enJwrNERGScs1dS8PqyYyge4/Vq7IN/9WuEsEZ1YGNjw8NKRERkpILiQkaSwO6bb75RmTYlwPPy8lK3ZZk8RkREVJ4TsUmYuvwohn69vUSQJ57u3xg9GvswyCMiIqrKHr0ZM2bg008/xb///W90795d/Ue8a9cuvP3226qHb9q0aRXdHyIiqqGycvOw/thlzNsdUaS4eXF2NjaqqDkRERFVcaA3a9YsLFq0CIMGDdItk4LpXbp0wWOPPcZAj4iIdGISM7BgdwQW7YvCtbTsgv98JHtma39MDgvBxaupeGPFceRpNCrImz6qNQubExERmSPQu3z5surJK06WXbly5Xb3iYiIqrn8fA22n0/A3F0R2Hz6ii7Rir+nMyZ2C8b4rkHw8ygobt41tDb6NvNFeEK66skL8GJWTSIiIrMEek2bNlU9etJ7p2/hwoWqkDoREVmnpPQcLDkQhQV7IlW5BK2ejevgge4NcGeLurC3Kzk9XII7BnhERERmDvTeffddjB8/HmvXrkXXrl3Vsj179qj7EuwZIyMjQwWNp0+fxuOPP46GDRsWefz333/H7t27iyzz9/fHCy+8UGTZtWvXsHjxYtWj2KZNG4wcORK2traVsg4RERV1PCYJ83ZFYOWRGGTm5KtlHk72GN2pPiZ1b4DGfu48ZERERFWoQhHMmDFjsGPHDtjb22PevHmYP38+HBwc1DJ5zFC//PILGjVqpIK5jz/+GJGRkSXW+eOPP1QAWatWLd3Fw8OjyDqXLl1SQZkEjGlpaSpJzLBhw5Cfn2/ydYiIqEBmTh6WH4zGyP/twNBvtmPR/igV5DX398D0kW2we9oAvDu8FYM8IiKi6tKj9+GHH+LNN9/E0qVLy3zMEK1atcKJEydUULVy5coy12vWrBlef/31Mh9/7bXXEBISgk2bNsHOzg5PPfWU+hsJ2CZMmGDSdYiIrE1cUoYahhnq46aGV0ZdT1dDMxfvj8L1wuQqDnY2GNI6AJPDGqBTA2+WRSAiIjKzCvXovfXWWxV6rLjOnTvD29v7luuFh4fj/fffx1dffYUDBw4UeSw3NxerV6/GpEmTVHAmZPhn3759sXz5cpOuQ0RkbRbti0TPjzZj4vd70OOjzRjy5Vb0+XQLZv1zQQV59byc8fKgptj5+gB8PaEDOofUZpBHRERUXXv0ynLmzBn4+PjA1JycnJCZmYkLFy7g1VdfxbPPPouZM2eqx2S4pzzWuHHjIn8j96W2nynXKU1WVpa6aCUnJ6trGe55qyGf8rgUmOfQUOvBNrcu1b29pSdv6vJjuoyZGg1w6nKKut2rcR019+6OZr665CrV9XWaUnVvczIe29y6sL2tT76Ffa8bsx9GBXr169cv9bb2Sa9evYpHH30UpvTyyy8XCb4mTpyIwYMHY+jQoejXr58a9ik8PT2L/J2Xl5fuMVOtU1bx+Pfee6/EcjkWEjiWR45ZUlKSevMw4Yt1YJtbl+ra3lm5+dh2MRG/HrhZFkHf24NCcHfLOur29WsJVb+DFqy6tjlVHNvcurC9rU++hX2vp6QU/OBq8kBP5t+Jhx56SHdbS5KxyPy2nj17wpSK97DdddddCAwMxNatW1Wg5+5ekMlNGkBfYmKi7jFTrVOaqVOn4qWXXirSoxcUFARfX98SQWNpbxwbGxu1riW8cajysc2tS3Vqb/kP7Eh0EpYeiMaao3FIzswtdT07G+CuDiHwY627at/mZBpsc+vC9rY++Rb2ve7sXFCD1uSB3pQpU9S1DM+UHjVzycvL0/WWBQcHw83NTQ0blSBQS+63aNHCpOuUNaxULsXJG8GQN4O8cQxdl2oGtrl1sfT2vpyUieWHorHsQDQuXL05ekHm3o3qWB/ODrb44q9zyNNoYGdjg+mjWiPQ282s+2zpLL3NyfTY5taF7W19bCzoe92YfajQHL2qCvIkQcr+/fvRvXt33bJly5bh8uXLGDBggLoviVOk1t3cuXPx5JNPwtHRESdPnsT27dtVPTxTrkNEVFPKImw4cVn13u04n6AbnilBnWTOHNOpPsIa1oGtrY1aLrXwwhPSEeLjyqLmRERE1piMxViSQXPJkiW6sabfffedqpt35513qotEz1JWQSJXKcUgCVM2bNiAN954QxfoiY8++gi9e/dGWFgYOnXqhFWrVql6fhK4mXodIqLqSIZmHoy8UTA080gcUrJuDs3sGlJbBXdD2vjDw9mhxN9KSQW5EBERUfVh1kBPes20RdAlqUnxsafSy/b3339j586dOHTokArAvvjiC1X2QJ/M2Tt69KgKzK5cuYKxY8eqQLEy1iEiqk5iEzOw4lCMCvCkFp5WYC0X1VM3umMgGtThUEwiIqKaxkYjP/Maqbyi6MYUTK+JJBmLZOqUpC6GJGOJj4+Hn5+fRYz5pcrHNrcu5mrvjGy9oZkXElRZBOHqaKeGZo7uFIjuoTeHZpLp8DNufdjm1oXtbX3yLex83ZhYo0KBngypLOvPynvMGjDQo+r0ZUHVv72l1p301IXUcUVMYiaW7o/G2mNxSNUbmtm9oQzNDMKQ1v5wczLrQI4aj59x68M2ty5sb+uTb2HnbsbEGtWiYDoREZW0aF9kkYLm+oJqu2BMxyCM6hiIoNquPHxERERWxuILphMRUVH5+RqsPBKL15YdK3Fohrb1xwPdQ9AlpDaHZhIREVkxiy+YTkREBRLTs9W8u/m7IxB+Lb3Uw3J/txB0a1iHh4yIiMjKVcuC6URE1uRYdBLm7Q7HysOxyMrNV8vcHO2Qnp0H/VGbUtBcat0RERERWXTBdCIiay5qvvZoHObujsCRqETd8ub+HpgcFoJ7O9TD6iOxmLb8OPI0GhXkTR/VmvXuiIiIqOKBntS9K09i4s2TEiIiMlzktXQs2BOBxfujcCM9Ry1ztLPF3W388UBYA3QM9lbZjcW4LsHo09QX4QnpqiePRc2JiIjotgK9H374oUQilnPnzuHzzz/Hiy++WJFNEhFZrbx8Df45G495uyLw99mrurp3UtR8YrdgjOsSBB93p1L/VoI7BnhERERkkkBvzJgxpS7v0qULZs6cWZFNEhFZnetp2arnTnrwoq5n6JZLL90D3RvgjuZ+sGNRcyIiIqoAk9bRk4ybY8eONeUmiYhqFI1Gg8NRiar3bs2xOGQXJlfxcnHAfZ3qY1L3BgjxcTP3bhIREVE1Z9JAb/Xq1apSOxERAXFJGTgclYL2Th6o7eaMVUdiMG93BI7HJOsOT5tALzX3bljbenBxtONhIyIiIvMFet27dy+x7MaNG2qe3rfffmuK/SIiqtYW7YvE1OXHkK8BbHAWTva2yCzsvXO0t1WBnQR47ep76ZKrEBEREVlceQVvb2/06tUL7dq1M8V+ERFVW5HX0vD6smO6GndyLUFeQC1nTAkLwX2dg1DbzdHMe0lEREQ1WYUCvTfffNP0e0JEVM2FJ6Rh4b4o/Lonokghc63PxrRDj8Y+ZtgzIiIisja3NUdv165dOHXqlLrdsmXLUod0EhHVZJJM5c+Tl/Hb3kjsOH+tzPWkoHmoL5OsEBERkQUHepGRkSq75p49e+DjU/DrdEJCAsLCwrB48WLUr1/f1PtJRGRRLknv3d5ILD0QjWtp2WqZTLXr29QXE7oG41pqFt76/TjyNBLkAdNHtWa9OyIiIrLsQO+xxx6Du7s7Ll68iNDQULXs0qVLavmjjz6KP/74w9T7SURkdlm5edhw4gp+2xOJXRdv9t7V9XTCuM5BGNslCPW9XXXL+zb1weHzsWjfuB4CvdmbR0RERBYe6G3duhVnz55FUFCQbpkEfHPmzEHTpk1NuX9ERGZ34WqqrvfuRnqOrveufzM/1XvXv5kv7O1sS/xdgJcL7II84OflYoa9JiIiImtWoUCvXr16ZT4WGBh4O/tDRGQRMnOk9+4yft0TiT2XruuW+3s6Y1yXgt67wFoM4IiIiKgGBXqPPPKIGqL53XffoUGDBmpZRESEGropjxERVVfn4wt675YdvNl7Z6vXe9evjN47IiIiomof6P3www9qTp4M1/T19YVGo8HVq1fVYxcuXMCPP/6oW/f8+fOm21siIhOJS8pQCVVCfdzg7eqIP45fxq97I7FXr/cuwKuw965zEOqx946IiIhqeqD36quvmn5PiIiqyKJ9kZi6/BjyNYANAGdHO2Rk5+l67+5oXhcTuwWhb1M/2MkCIiIiImsI9J588knT7wkRURWIuZGO15cfg6aworlcSZAnc+8mdgtWvXf+Xs5sCyIiIrLegukiNze35Ebtb3uzREQmT67y+6EYfL35nC7I0/fZ2Hbo2bigLigRERFRdVehiEzq5z399NPYsWMHUlJSSjwuc/aIiCzBjbRszN8dgV92hSMhtaCweXF2NjZo6Ms6d0RERFRzVDjrpp2dHX755Rd4e3ubfq+IiG5TeEIaftx+CUsORCEzJ18tq+fljId7hcLBzgbvrz6FPI1GBXnTR7VWNe+IiIiIrDrQ27dvn+rV8/PzM/0eERHdhgMR1/Hd1ov48+QV3RDN1oGeeKx3Q9zdJgAOhaURBrXyR3hCOkJ8XBnkERERUY1T4YLp+fkFv5ATEZlbXr4Gf564jO+3XcTByETd8jua++HR3qEIa1gHNjZFs2dKDx578YiIiKimqlCg98QTT+C1117DrFmz4OJy+8Odzp49qy5hYWGoU6dOqescO3YMV65cQcuWLVWgae51iMj80rNzsWR/tBqiGXk9XS1ztLPFyA6BKsBrUtfD3LtIREREVH0Cvf/9739q6OaiRYsQGBhY4pdyQ4ukb9u2De+99x7OnDmD6OhobNmyBf369SuyTmpqKkaMGIEjR46gSZMmOHz4MN544w28+eabZlmHiMwvPiUTc3dGYN7uCCRl5KhltVwd8ED3BnggrAH8PFgegYiIiKxbhQK9V155xSRPHhsbq3oGmzdvjuDg4FLXeeutt3Dp0iUVDEpv319//YVBgwahT58+6lLV6xCR+Zy9koIftl3E74dikZ1XMHy8QR1XPNorFKM71YerI0u7EBEREZm9YPq4cePUtfTmlUbKNMybNw8vvfSSbkjnwIED0bFjR8ydO1cFX1W5DhFVjbikDFxKSEOoj5sqZL7rwjV8t+0i/j5zVbdOpwbeKsHKwJZ1YWdbdFQBERERkbWz6J+/Y2JicO3aNbRr167I8vbt26vhlVW9TmmysrLURSs5OVldS7KaWyWskcclwGRiG+vBNr+1Rfuj8MaK48jXABK+BXg5IzYpUz0mo8QHtayrevAk0CsgnyHLrN3J9rY+bHPrwza3Lmxv65NvYefrxuyHwYGev7+/ur58+bLudllkHVNITCzInle7du0iy6XHTftYVa5TmhkzZqh5hsVdvXoVmZkFJ6flNVRSUpJ689jaFqR8p5qNbV6++JRsTFtxXFcWQa4kyHOys8Gw1j4Y18EPQbVk/l0O4uPjYenY3taHbW592ObWhe1tfa6kX8HZq2fRNKMp6rrWNffuICUlxfSB3syZM0u9XZkcHR3VdXp6QTY9Lbmvfawq1ynN1KlT1XBP/R69oKAg+Pr6wtPT85ZfFpLIRtZloGcd2OalS8nMwfrjl/HzzghdkKfv6wkd1BDN6obtbX3Y5taHbW5d2N7WZfm55fhg9wfIRz5sT9vire5vYVSTUWbdJ2dnZ9MHepMmTSr1dmWSBC12dnYl5vBFRUUhNDS0ytcpjZOTk7oUJ4GbIcGbBHqGrks1A9u8QG5ePradT8DygzGqBl5WbulDEexsbNA2qFa1/Yywva0P29z6sM2tC9vbOpy9fhbv734fGjW+CCrY+2DPB+hVvxf83cof3ViZjDkfsugzJ4lY+/bti+XLl+uWyTDKTZs2YfDgwVW+DhHdvpOxyfhwzUl0n7EZD83Zh9VHYlWQ19jPHa8OboapQ5qr4E7I9fRRrVnYnIiIiKpEeFI4Ptz9IcavHa8L8rTyNfmISomqNi1h1mQs0nsmteokCYrYtWuXqmXXtGlTddHOgZOMl0899ZQqqC5F2kNCQvDII4/otlOV6xCR8eKTM7HycCyWHYzG6cs3x5bXdnPE8Hb1MKpjINoEeulqcg5vXw/hCekI8XFlkEdERESVSqPRYP+V/Zh7Yi7+jv67zPVsbWwR5BFUbVrDRiOvzEykt+yLL74osXzixInqonX06FEVdF25cgVt2rTBCy+8gFq1ahX5m6pcpzwyR8/Ly0slWTFkjp4klPDz86u2w9LIONbU5hnZefjz5GU1NHPbuasqi6ZwtLPFnS39MKpDffRt5gsHu5p7HKypvakA29z6sM2tC9u7ZsnJz8GG8A0qwDt1/ZRueb/6/TC51WREJkeq4ZvSkydB3jth75h9jp4xsYZZA72aiIEeWfN/EFLmYG/4dSw/GI11xy4jNStX95iUQ5Ceu6Ft6sHL1QHWoKa3N5XENrc+bHPrwvauGZKykrD07FL8evpXxKcXZPF2tnPGiMYjcH+L+xHqdTM/R1xKHI5GHUXboLYI8AhAdYo1LLqOHhFZdjHzAC8Xtezi1VSsOBSjeu9iEjN069b3dsGojvUxqkMgQnzczLjXREREt+9K2hUcuXYE7dzaWcRJPxknKjkK80/Nx4rzK5CRW3C+4uPigwnNJ+C+pvfB21lbo/emum510a52O/i5+VW7w81Aj4gMtmhfJKYuP6aGYdraQM2vC7+WjsNRN2tNejjZ4562ASrA69zAG7ayIhERUQ1Itf/uzndVgg7b/bZ4p4f5h/HRrWk0GhyKP4S5J+dic+RmXYKVJt5N8GDLBzEkdAgc7coupVadMdAjIoN78rRBnpDr3w/Hqtt2tjbo29RXDc28s0VdODvY8agSEVGNkJmbicVnFuPT/Z/qlkmq/fd2vYce9XqYNdU+lS03PxcbIzaqAO9YwjHd8l6BvTC55WR0D+iuSwJXUzHQI6JbSkzPxjebz+mCPH0PdG+A5wY0ga9HyXqSRERE1dWlpEsqwFt1YRWSs5NLPK5Ntc9Az7KkZKeo3tcFpxYgLi1OLXO0dcSwRsPwQMsH0KhWI1gLBnpEVKZj0UmYuyscqwpr3RUnde7+1b8Rgzwislqcs1Wz5OTlYFPUJiw5swR7L+/VLfd39ceV9Csl6qrVd69vhr0krctpl1VmzGDPYORp8lRwJ0FeWk6aery2c22MbzYeY5uNRR2XOlZ34BjoEVERWbl5WHs0DnN3RRSZe9cywBMtAjxU0hXp2WMxcyKydnJC+d7O99QwPs7Zqt6iU6Kx7Nwy1abXM6+rZZJOv0/9PhjbdKwaornywko1XFN68rT+if4H45uPN+OeW/nnT689bGCjC8QbeTVS5RHuaXgPnOysd8QRAz0iUiRb5oLdEVi0LwrX0rLVMgc7G9zdJgCTwxqgY7C3Gsv+8l3NWMyciKze1uiteGfnO7rjwDlb1XMO17bobVh8djF2xOzQBQm+Lr4Y3XQ0RjcZXWRYpiReCfMPU6n2L2RdwP8d/T98tv8zdAvoViQdP1VNYK5NjKMltzv6dcRjbR9Dz3o9a/z8O0Mw0COyYlL3bseFBNV7t+nUFd0cvAAvZ9zfLRjjugSXGJYpJRW0ZRWIiKwuuUPkRiw4uQCHrx4u8TjnbFWf4bbLzy/HsrPL1HBMLem1k967PkF94GBber1Xbar9Ab4DcOjqIeyO241p26Zh7t1zy/wbMp2EjAQsObtEfQaLD6MVz3R4Bl38u/CQF2KgR2SFkjJysOxANObvjsDFhIJx7KJHozqq904yZ9rbscA3EZFIzEzE0nNLsfD0Ql1gYGdjp+YE6ZOhfkEeQTxoFkiCcAnKJLnK31F/69qullMtjGw8EmOajlHzvAwlbf1Bzw8watUoHL92HN8f/R7/av+vSnwF1u3o1aOquPmG8A3qB5fS8PNXEgM9IityKi5Z9d79figGGTkF/8m5O9ljdMdAPBDWAI39PMy9i0REFuPcjXMqucPai2uRmZepS+4ghZXHNRuHbTHbiswRGt5oODMwWhiZb7fy/ErVCyQZMrVkiJ8k6BjYYGCFa6jJsM63ur+FV7e+iu+OfqfS9rf1bWvCvbdu2XnZKrD79dSvKpjWaufbDhObT1QJVz7c86H6/EmQ907YO/z8FcNAj6iGy87Nxx8nLmPernDsC7+hW960rjseCAvByA6BKtgjIiIgLz9Pzb+TAG/P5T26Q9K8dnPc3+J+VVxZm9xBO2fryz1fYl3MOmyK2IRn2j+jhveR+TIwSq9qbFqs6r37K+Iv5OTnqMfdHdxVMC6BemPvxiZ5Tnk/bInagvWX1mPa9mlYPHQxXB1cTbJtaxWfHq/aToJzbWIcGRYrx1oCvFY+rXTr9q7fWwXw0uYsc1ESz+6IalhR80sJaQj1cVPZp37dE4Hf9kXhakqWrrD54Fb+qveuW2htTlQmIiqUmp2KFedXqN6D6NRotUx6CQYED1ABnvQAlZbcQYK651o+h4jMCJy4dgLv734f397xLb9fzZgBtbjWdVqr3ru7Qu6qlCDsjW5v4OCVg4hIjsDnBz7Hm93fNPlz1HQajUbNe5XPnxQ5z9UUDM/0c/VTveeSGKe08ggS3DHAKxsDPaIaYtG+SExdfkyXUEXORzSFtyWhysSuwZjYLRh1PZ3Nup9ENRlrqlU/cnIuJ5e/n/8d6bnpapmHowfGNBmj0ubXc693y23Y2drh/R7vY/za8ao3cM3FNao4M1WNXbG7imRA1RoSMgQPtn4Qrerc7AGqDF5OXviw14d47M/HsOjMIvSt31f1NNGtZeVlYd3Fdfjt9G84df2Ubrn8sDKxxUTcEXwHk9zcBgZ6RDXAgYjreH3ZsSL5pyTIa1+/Fh7pHYq7WvnD0Z7JVYgqE2uqVa/eAwkOFpxeoNLra7P3NfRqqHrvhjYcanTPT+NajVUyjq8OfoUZe2ege0B3+Lr6VtIrIBmOuTlys0qQs//K/lIPyH3N7qv0IE9L2ntSi0mYf2o+3t75NpYPXw5vZ282VDnDbCUoXnp2KRKzCmr2ypDou0PvVgGeDJWm28dAj6iaSsvKxbpjcVh2MBq7LxaMYS/utSHNEdao5FAHIjKtA1cOFKnpxJpqlik9J131tsn8u4tJF3XLpSi2BHhhAWG3NeRySqspak7YyWsn8f6u9/H1HV9zCGclpddfemYp4jPi1TJb2JYYsmmODIzPd3xe/YBwIemCav/P+33O9i/2A4sE5dJ7J0G6NvNpgFuAbnhmLedaVdpmNR0DPaJqVvdu18VrqjTC+uOXdZkzS2NnY4MQH04IJ6osmbmZqqaa9OTtu7yv5OdVk6+SBHD+iPmTc0hPwabITapEQkp2inrM1d4V9za+V/UeNPBsYJLns7e1x4c9P8TYNWPxd/TfWHtpreodJNPM35IAQQJpbXp9bQZUKY2wM3anLgOquTIwOts7Y0bvGZi4bqL6blh9cbVK/mLtnz8/Nz/sv7xflUeQTLZaXf27quQqfYP6qs8OmR6PKlE1cPFqKpYfjMHyg9GITSpI8S0k6cqoDoEY2TEQO84nYNry48jTaFSQN31UaxY2J6oEZ66fwbJzy1TPkDZokORHxYv3sqaTeUkxbDnxL94u9d3rq+BOgjyZi2dqTbyb4Kl2T+GbQ99gxp6CIZw+Lj4mfx5rkJGbobJZSoB3+vpp3fL2vu3V/En90giSAVUKnps7A2OLOi3wdPun1RDe6Xumo1PdTgh0D4S1kR/A9Ec5aDnbOWNoo6GY0HwCmno3Ndv+WQsGekQWXNR8zdFY1Xt3MLJg/LrwcLbH0Lb1MKZTIDoGe+uGhYzrEow+TX0RnpCuevICvFzMuPckmJijZmVkXB++HsvPLi9Sz6meWz2MbDJSBQ36PQrC39W/1CxxVPltJclVvjn8TYnHJGGK9LBI8pTK9FDrh1TmQEkuIUP4vur/FYfwGSEqOUrN35IsqMnZyWqZ9Mre0/AejG82XgVTpbGUDIwPtXoI/0T9o3oh39j+Bn4c9GOlv+csqfdVgvPSkuM80fYJPNDyAZW8hqoGAz0iC5Kbl49t5xKw9GA0/jp5RdXAE7Y2UEHc6I71MbBlXTg7lP4fhgR3DPAsw5IzS/DB7g/Ur5m2+23xTo931C/OVL1OWI5cPaJ676Ror/QuCBlidEfQHWo+Sfd63VXPnX5Nta0XtuKLk1+oOl7fH/1eJeigqulpleBAiptrs2cWV9+jfpWccEvNrw96fqCycGprrN3d8O5Kf97qTH4g2RGzQ/XebY/ZrusJkt4wCe7kB5XqEiDIe2x67+kYs2qMmr877+Q8TGk9BTV9/uuqC6tU++nPf9XXLaBbtWnDmoKBHpEFOH05WfXc/X44VlfzTjSr64HRnQJxb/tA+LEsQrUQlxqHOSfmqP/stJiYo3q5kXkDqy+sVkOPJKmCVqhXqAruJG2+zA0qjdRU6+vfF+4e7nh9++v47uh36BXYC21921bhK7Cu1OwShEtxZQnKtWToXnRKdJFhY1U9lLZZ7WaqB+O/h/+L6Xuno2tAVw7hLEVSVpIqbSFBugy71OoZ2FPN3+pZr2e17A2T99prXV9TPVtfH/oaYfXC1HuiJpYnkcyn0oapOam64ZmZeTenmQgOZTcPBnpEVVzQ/HBUCto7ecDZwR6rjsSqrJnHYwqGpojabo4Y3k6GZtZHq3qeHO5TDeTl52FH7A7Vi7c1Zqtu6J4+JuawbNI+e+L2qN47yQYnqdu1JyxSZHl009FqXpChGRmHhA7BPzH/qJ6cadunYfHQxZVSqNlaycmlfN5+v/C7ChSEvY29qrkl2fu6+HdRw/7MnZzjkTaPqCQwMr/sw90f4ot+X1jtd7o2MUewZ7BqB+mBlR/EpAdWGxR4OHjg3ib3qjY0VYIccxrZeKTq0f076m9M3T4VC+9ZqJtTWJ3JZ0p6XSW5ivTCakmbydw7GR4tSXPM/fkjwEYjY1PIZJKTk+Hl5YWkpCR4enqWu25+fj7i4+Ph5+cHW1vWOLO2guYyHFN728HOBv2b+angrl8zP9a8qyauZVxTJ5NSBygmNUa3XAIC6V0oPgn9j1F/INDD+iblW/rJ58rzK1U76rdhyzotVe+dBGzGJOzQ/15PyUnBqFWjEJ8ej7FNx+KtsLcq6VVYB8m0KCfM0nu3K26XbrmkZpesizJ0tnjSE2nfyk7Ocav/yyWgGb9mPHI1ufi0z6cYHDoYVlljsvCkXxIXSXtEpkTqHpekHBIgSA01S/9BxNhzN/l/Qr4HrmdeV3P3Xur8EqorST4lPXfSg6dtP2lPGbUgCY4kGY52KHtVff6qQr6Fna8bE2sw0DPjwbe0Nw5VnmMxiRj+zQ7APgm2jgnIz/aBJtcLzf09ML5LEIa3D1Q9eVR96gBJb8JfkTfTfHs6emJE4xEq1bcM8dM/sdGSuVqSjY/M26NQz70ezt44q9poW8w2XRtJb4Ike5CAoaxkD7dS/Htdamo9/tfj6rH/DvivqtdGxic1kp5WyaKprZumPbkc22wsegf2NuvQPkP+L/+/w/+H/x35H2o51cLvI363qiQ98rm7a+ldJerc2cEOA0MGquyZHf06Vpuezoqcu22J3ILntjyn3rc/3vWj6nGuTi4kXlC9rzIHTztXWdv7KvMnpZe2Jsu3sPN1BnrV5OBb2huHTO/C1VR8v/Uilh6Ihk2tf+Dktw7yf5lGY4OsuFGYO/ZZFjSvJiTzm8zbkt4E/YnmbX3aqpNNGd4nNZT0xaXE4WjUUSQgAR/t+wh2NnaYf/d8tPZpbYZXYN3KSvUtJP259N5JqvbibWis0r7XP977Meafmo86znWwYsQKeDt739ZzWAMJvnfH7VafN+nF0xZWlrmRMhxOevAksYolMOT/8py8HExYOwFnbpxR7zMppG0NLiVdwmf7P8M/0f+UeOyzvp9hUMggVDcVPXeT7x/5wUJ6oJcNX1YppT1MPSVB2k2GZ8qwdq1GXo1U753Uh7T03ldTyU+MQuKFA6jVqBNsa1XdPF9TxBqco0dUCfaHX8fsrRfx18k42Lmdg0Pgdti7nVNBnrCx0cApYDnc3CQLl/X8slsdnUg4gcVnF6u5VtpfMl3sXVTPjwzHK6/nRxJztKvdDr6+vjh09ZBKGjF121QsHrZYbYOqpgd23aV1pab6lgD9gRYPIMQrpFL34fmOz6uePUnsIr281jxP61YSMxPV0LAlZ5cUGdonPT4yb+vOBndWyzlODnYO+LDXh5iwZoKauyTfBfLjUE0e9fDLiV9KDfCEDO+ztgRFr3R5RQVM0anR+GjvR/hPr//AEsmcV/lhTJLjaIezS3v1q99PBXhS5Nyivr+SYoDrF4DajQCvSpgacXAubFY/j9qafGhkWOqwr4COk1FdMNAjMpH8fA3+PHkF3229gEOxkXDw2ge3Rvtg63izBp4+CfaycBVA5Z5kUsWL9EpvwolrJ3TLG9dqrE42Jcgz5tdY+U/xre5v4eCVgwhPDseXB77E1G5T2TSVnOpbCpovOLWgzFTfg0MGV3qQJ6SXcEbvGZi4bqJKzLHywkpVd8/aaYfSyvydK+lX1OdNAqDs/Gz1uLuDu8pwKsOhpQh5dde8dnM82vZRzDoyC//Z/R81fK+s7K3VkSQwkvabe2Kuqh8oZKhi36C+CPUMxS8nf7HqxBxuDm6q5MKUP6aoIZB96/c1a49maclxpPdOkuNINlshpRBkKLv8v2eRRd8PzgVWPw/I8PvygrC8XCA7BchKBbJTC68NuJ+WAETugjastZHnWf0C0GhA5QSVlYCBHtFtyszJw/KDMfh+23lEZhyCg/deuDU+DRubfN3crQHBA9Sv1OZM9U2GzUOQnoRV51epRBraeljyn7H03nXw61DhXzLlP8z3e76PpzY+pf4zlZMfmbhOphWbGqsSBSw9t1QlDrCUVN/S8/t0+6fx1cGv1K/5net2tpihh+ag5rDufK/EvC3RonYL1dtaHRJzGOvxNo+rYP/cjXOYvmc6ZvadiZowrF3mT8qPKhKwaz9zknlRimNrf0yR3qCakJjjdsj/IY+0fgTfH/se7+9+X933dfW1uOQ4zbybqfaSz+DtDmc3mew0IO0qkHat4PraOeBPSXBVeF4lQdiqZ4H9c4C8nKKBW27R7//bIsPIr19koEdU0yWmZ2Pergj8vPcwUhx2wqHWPrj6FqT51g41knkk2nk/7f3aF0nOIV+sfq5+ZnwF1k2XmMOtHo5dO6Z6E2S4kVZ99/rqZFMSrJjqV3dJHiG/jMqQmLd2vIXlw5ezeKyJhopJUWI50dwctbnIZ0zqcEnv2Z8Rf5o91bdk3NsavRWH4g/hje1v4Ke7fqqW9cFu19H4o6XOl5TvyimtpqCNTxvLGhpm6iGcPT/ExLUTVe/XoAaDquU8NSF1CuUzJ0GDtkC9zEOV7Jny3Vl8Lqp83qw1wNMnCbmkNIH0er618y3834D/q9L3u/zfp/8ji3wOJcizha1KjiPfmbfzo6bBwyqz04H0hKLBW6n3Cy+FUyduKfZg2Y/ZOQKO7oCTOyCjctR1WffdAUm29oeMvtH7rrKxA2o3RHVh8Vk3MzIykJV1s4C0sLOzg4dH6cOmMjMz4exc/q8PplqnNEzGUvNFXU/HD9suYMmpv6Bx3w07d+m9K/gYeTp6YUTj4RjTZAwa1ir5RSDJOTaf24wvT36pehhe7vwyHmz1oBlehXUrqzdBOw9BTlKkuK1+mmhTTdqXIYVj14xVdcDk19KP+3x8W89hzWR40bqL61QPqdQp0+oe0B2TWkxSgbV+IGUJqfbl+cesGqNOjF/o+IKqs2YtpI1+PvEz1l9cX2pPngS+1S0bYUWTc3xz6Bt8d/Q79SOSZOGsTgl6pHSMDM/cGLlR96OKDGuf3HIy7m54N5zsnFCTmSKRnoweGbt6rBqm/Ga3NzGu+ThUVYIjed/JD2PFzewzE3eF3sa8UelFS9MGaleBEyuAQ/NvBkl+rQAH55uBXE6a8c8hvYtuvoBrHcDJAwjfVvRx+T/7ns+BWsFFAzYnj4Jr+wrM7z04F5rVL8BGkweNjR1shn1p9jl6NSrr5pNPPomffvoJrq43h2+0bNkSO3fuLLLeO++8g6+++gqpqakIDQ3FN998g8GDB1fKOuVhoFdzHY9Jwlf/7MPWuLWw99oHWwf93rtOGNvsPpUooLz/5LT/QWxL2qaGbciwwIVDF6oaQlQ1pEfl6U1Pl1guSTkmt5ps0gCgrBOCo1ePYvL6ySqT4Kd9P1VzxchwUpdOekWlfqHUptIOFRvaaCjub34/Gns3tuiTwBXnVuDtnW/D3tYev93zm5q7VVPJKYYkoplzYo46ySyL/KiyYfSGatnjU5ET/+y8bIxbMw7nE89jSMgQfNL3E1h6BkYp/C0JVg5fPaxbLsPPJcCT65raC1tZGdPnn5yPj/d9rL67lgxbUnS+sAkTjMh3pEwdke9L+aHJ4M+fhAdZKYWBmQRw8Tdvp8aXXJ5xw/idkx42beAm124+5d93dJNJ78Xm6L1QMJxSetoqKQjLV1k3D6JWo47MulkZhg8fjqVLl5b5uARjX375JdauXYuuXbti5syZuPfee3H8+HE0btzYpOuQdZGTlC1nr+DzbStxIXMj7NzPwNGn4LcRN3tPjG56L0Y3HY2GXsZ1449qPEplI5OLZGGUk73qmEmuupBfMmWojPQm7Lu8r9R1+gf3r7KTTMk292ibRzH76Gx8sOsDNcyXw3hvTQJkKVPwV/hfqvi0kDaToWJSHkHmQVYHMpRUSgbIMFP5/MuPPTWtF0TKCfwR/of6zEnNQiHlRWSo4oOtH1SJH8w9lNac5PtehnDev+5+rA9fr4Zvyg+FlkZGIKw4v0IFJZItUsgPFPeE3qN+GOOPlBUnc+D+jv5bZeKU74G5d89VP/4anGCkNBKc5eVAk5uJ/Zf3YcmF37ExdjtyCuu9utu5YGjdrvBOisXs1LPIt7GBrUaDd2x84f/XB0WDObk2dm6b7K+rDyBzaxPDSz7e/02gYd+bgZv0tN3ODwRyXCQxisyZk+GUlZUgxTMQ2YEOgGf1m25TLXr0EhISsGDBAjg6Opb6i1GjRo1UQPbZZ5/ploWEhGDMmDEqWDPlOrfCHr2aIScvH/P2HcYPhxciyX4HbB2SdY+19O6AB1uPx4AGA4w+OdP/JfB61nWMWjkKN7Ju4OHWD+PFTi9WwiuxbjK0b82FNSrbm9Rz0hbpzUNBTa7K7k0o75dfyVA3ad0knLx2Ej3r9cT/3Vm18zSqU8Ag8+tkLtCxhGO65RIcT2o5Cf2D+qsTz+r2a7/8yj5y5Uh1LT0iknq9JkjNTlU9B/NOzVM9r0JKiUggLu2ln7mvKobSWnoPz9cHv1aJOWQI58oRK1HLuRYsIQOjFKmXAtlSWkab1EgSi8kcY/lhpUIJRCo7DX4VPUeFa6rlZhdmdJQkISnq9uXkaIw6/DFS8jLxrzqd8ZR9PWD3f4vOCRMNJHGXLSDZMHOzgLzsUq+TNNlY7e6OxR7uuOTooPvzVllZGJucisFp6XAtPO2/bGeHKAd7BOXkwj+v6P+JRciQR23PWvGLe7H7LrUB+QxIO3zZuiBY1ZIetxeOVZskJpZc97rG1dFbvXq1eiH29vbo2bOn6nWT4ZtCgsCLFy+id+/eRf6mT58+2LNnj0nXoZrt6OVwbI84iaNx4dh95R/kOp2CjYtGvlrhaOOBoQ2HYUqb8Qj1CjXJ8/m4+OCdHu/ghS0vYM7xOehTv48q3Ey370bmDTW0T05UtEP7JFW7pGmXX1F3xu40e2+C/HI7o9cMNV9vR+wOlQymKuZpVBfXMq6pDKhyXK5mXNUdM5nXeH+L+8utX1gdyIn9+z3exzObn8Hck3PV579bQDdUVxIoSDAuQV5qTqruO07aSj53pfW2MjkH8GS7J7E5crOqsThj7wyzzNktnoGxrU9bnLh+ArmFvUDBHsEqe6Zk0axwFtTb6aXSkgBF9knmgklgo25nF97PAY4vA/756OZz9HwRaDa44O8kcNJd55eyrHC5uo2y17+wBTb7fkBtlcLEBmg1EvBtViR4K7hdeJ2td7uwZIE++V/nTTdXvObng9kJ+9Ar9graFA/yRMTOsg+LnL84OWKxtzs2uPkiqzAQccnPx91pGbgvPQetNHaAvSfg5QPk5wHJ0Sq4KxLgSXvU7wK4+RUdNulYgTaXYE7auPiwymoY5FV3Fh/otWnTBhs3bkSPHj1UNP3MM8/gjjvuUMMpfXx81DIht/VJ1K0N0Ey1TmkkUYx+shiJsrXRv1zKI49Lh+qt1qPK9/iqT7E7cf7NEQTOUv8HqOfUGo+1n4ChjQbphlbeTnsVb/P+9ftjRKMRqq7WtG3TsGToErjLr2dUIfKLtAztk+OpTafv7+qvTjZluKz22N7b6F6E+YepTGNyEiOFzSvjc3irz3iIZwie7/A8Ptn/CWbun6kK0TbwbABrJD0IESkRBUP+Iv7AH5f+0NVT83XxVeUtpFeojksdtcxSvzeN+V7vHdhbvaZl55apLJxLhy1VvSbViQzLlB5zaS/tcFoZyi69lDK8zxTfm5budv4vt7exVwH/A388gHWX1mFg8EDcEXwHqvJzVzwD45GEI7pec5m7LPXetEmNbvkaJeBK12ZMLLy+fhE2/3wMG700+BpJg39wfkHvj/xNfmHwJvXOVBBXGLxpL/k5sJHlhpLgbPtnBRcT09VUk9dzYrnRf6+xdymSJGSIozu22CTjDyRjav0QLLp0Hm56PWEaGxtoBv0HcPcH7J0K5rXZOSEVeVh39QCWxv6DMykRuvWbeDXEfY1H4e5Gw+FR+ANLkVZLjoHNV20LasLpnsMOmj6vqiGKJVT0s9t+EtCwP3D9ElA7tGDb1fR7IN/CzteN2Q+LD/Sefvpm0oSAgADMnTsXvr6+WLx4Mf71r3+V+aJzc3NLDIMy1Tr6ZsyYgffee6/E8qtXr6rMneWR55JuV3nzWEJXsLVJzEzHj8c3YPPldch2CC8yTFx+vJvaYgYGNOhcsO610oueG6u0Nn8o5CHsid2D2LRYvL/9fbzc+mWTPJc1OXHjBJaEL8HO+J26lO1NPJtgTMgY9KnbRw3tS09Mh/zTkl+uG9g2ANKAeJmXUAkM+YwPqD0Af9X+C4euH8Krf7+KL7t+aXUp91dHrcY3J78pkW6/uVdzjAweid7+vVVvXl5KHuJTKqetTMXY7/UHgx/ErphdiE2Pxbtb38XrbV+HpZPXJu/XxZcW48C1m9n72nq3xdjQseji00X1lJvqe9PS3e7/5X7ww9iQsVh4aSHe3/U+gm2DqyTgT8hMwJxzc0rNgPpci+cwLHiY6v25EXUWthnXCi83Cq4zr5dy/zpss24mKSuP+u82+vZHS2lk2Latvepdsy0l/X6eq29BYCXPqP1PXnr7JHhSe1Fsue6+XBfsqaZwuU1OKhxuXCjxHJkN+iO3VkNoHN2gcXBX1/mF1xoHN2gc3ZFfeK2xdwXsbg6p1HosOxn7dz6BiKwEfNx6EN47/qcKxOS5k/u8j4zQ0bp1zyWfw9rwtdgUt0n3g6ajrSP6+vfF0KChaOHVQp23ZiRlIQOlfV86wKXP+/Dc+rbec7yHjEwHINPU368OgGtTQHbT5NuuOvkWdr6eklIwnLpGBHrFubm5oX79+rh0qWC+Tb169dT1lSsFRTq1pIdO+5ip1inN1KlT8dJLLxXp0QsKClLB6K3GzcobRz6Msq4lvHGsgRzzpSd2Yu7xpYjM3gkb2yz1PVScfM9n2zupHl1TP39pbT6j9ww8/OfD2BCzAYMbD67SX3SrK10WuJO/4GjC0SK9JA+2fFAVpDb3nDdDP+Mf9fsIY1aPwemk01gdvxqPt30cNZ38hynp9qU0wqqLq0o8/lW/r9AvqB+qm4p8r8twvQc3PKhO3AY1HmSxWVhlXumf4X+qz9yZG2fUMgno7gy+U33mWvu0hjWSOVtOsafhVbfiGfleqvMS9l7fi4tJFzEnYg7+0/M/Nx9MjgGuXQTqNCy9x8UQ0nuTlYL8jBvYE7MDSyI34O9rx5BXSpAnyTmG7v4v6v49A0i/frMnztCnUgk56hTNlHh2Q5HtyDqau2YA7nULAh9JQqJ6quwLrtV97TKHstfRfscnx0BTSi+VzeNbYFPRY1ZcGc/hOPIbON7mc0iw/5/e/8ETG5/AitSTuHP8j+jl4KN6wjw8A2GXk44NERvUcPYT104UGRUiQ6OHNRxmXDIqv6eh6XAvNIW9bfIcpRctI0s8Xzem/Fu1C/SkpywiIgLBwcHqfq1atdC6dWts2rQJ9913n65BNm/ejMcff9yk65TGyclJXYqTN4IhbwZ54xi6LlXcqfhofLH7N+y9ugF59gXBvPxfZJtbB03cw3A6Y62uFp7QaGzQKbBJpbRLaW3eOaAzprSeoubqSdmF9nXbq/ktVHoWOEkVPe/kPF0WOOntkfkjMo+kUa1GFnXYDPmM1/Ooh6ndpmLa9mkqE2fvoN5oVacVaiKZMykJcmR4rTYbY2k8nDyq7feisd/r8nl/rM1jqu0/3POhmqsrw4nNST85h4ejh5p7J8OiZbk2wcrIxiNVghVJpmKVZOjHvu9hs/411CnsGbG5812gzX16vUO2uh6km7dL3nexc8QHagjnZKy5uAZ3hdxV8ENH8bltgz4EGg8EMpOAzEQgI7HgWl2SCu8nFbufiBvZqVjp7oolnu6IdLj562bHzEyEZOfgdw/3mxkYE64jIFW/xpkN4OKtN2/LpyCzov59lQK/4NrGpRZQfFRCsTT4UovMxpRp8CXALjYnTD1HBQPv8p6jeE01Uz1Hj8Aeqv6nfM7ePPwl3u3+LlzSo7HlzDysvrBaN/dVRqjIEN/7mt13ez9oyn6b8vjUcDYWdL5uzD5YdNZNmfs2ZMgQvP7662jVqhUiIyPxyiuvIDw8HMeOHYO3d0GB0d9++w1TpkxR9fbCwsLw6aefYuHChTh58qQa7mnKdW6FWTctR1pWFv63dxVWXViJGzgGG5vCOQj5Dqjn0A33txyN+9v1h72dHV7/83usif1GBXsS5A2t9yw+GvRYlWZukrpKE9ZOUCe/Mifimztkf5iFUetq+lWVXEWSrCRnF8yFlV8wtVngLDEwNiZTl3wV//uff+OviL/UHKdFQxfBWYrD1gDSE7Q9ersK0KWOoXYulww3kvpbUmZEf9imtdVUK56FNSwgDLMGzlLHwRyKJ+eQeXaSwVabREbmvMqcydvOEGmJWRjllEjqgcncMl2tMO3teCBV7hcul2HEhUPnTOVz71qYU8sTvrl5WBEbDy+Zn1ZB8ok67OSIRZ4e+NPNFTmF/5+452swLNce99l6o4mdOxC+tWgGxnwNMOoHwK9FQRAnmRSlF80kbVHJafCr4Dkqs6ZaZm4mhiwfgoSMhBKP1Xevr4I7mdevnatMVSOfWTcrh/SUffDBB/j4449x6NAhFdhJVsxly5bpgjwxYcIEZGRkqPVk6KUkcJGeOP3gzFTrkOXbcPYQZh9ciHPp/wB2abqh9s55DXFH4FC82GMM/D1uvn+EBHUTLw/EwZjz6BjYGG399QqXVhE5mZIhnOPXjFcnvpKgYUzTMbBG+r0Jkq5dshLKr9xyMiykB0GSPdxWFjgLI0H9293fxqH4Q2r41lcHv8JrXV9DdXbuxjkV3EnbabOfitZ1WqtacoNDB6tgXT+wsMaaarosrL1nYNzqcdgVt0v9qCEBlTk+e+/ufFcXeMu1BHlykim1H6UovUlq/pkiC6OxzyHJJoK76RV81gvc1P3C2mGF3zMVpg3QtZkajfB0YiK2uLog3NEBn3h74D8JNz83Og5uBQGYsxcgvWdyLUF34e0UBxesSY/E4uuHcD69oAdWtPBujnHNx2NI6JCi35sH58J/9Qvwz8wqzI74FdDm5pwwk5HAq7KzLlbFc1RiTbXErESVcbi4j3p9hCENh5jtxx+qviy6R686Yo+eeUQlXsNnuxZiW9w6ZNtF3nwgzwMtPe7AU53Go1/D1tXiV6FfTvyiMjDK0Khlw5YhyNO6hlbon/QX1963Paa0mqKGNFWHhCUV+RVwW/Q2/GtTQaKpHwb9UO1S7idlJansgRLgSe+UlvQEyTySEY1HoIl3kxJ/x5pqBSTAm75nugqmpFe3qoYiy6nA/iv78cWBL4rUK9Qy6L0oycxy0grSyWvTzKvrYveT44A9s4oFQTZAk0GAvWPBdmT4naSB113nF7uvvzy35DKpWZZWdM69UWS+k6oR5qdXK0x7W679Cp7r57vLrxWm0vZrU/Rr0/fnF7vopfDX5ONwwnFM/ud5FWT/90oC+qSnG1SLTD5vUo5EPn8ZhYlJnO2cVWA3ttnY8udQVkVvWw1Rmb07e+P24pE/Hymx/Ke7fkIX/y4mfS4yHHv0iMwgOzcXcw7+iUWnlyM+7wBsbHOlGjY0Gjv42LTH6KYj8VjnIXB2KEjvXV3IPDPp0dt3eR+mbp+Knwf/bFEFoSvT0fijRXoT9BOsSIKS9n7tUdP1rt9bTa6XSfdv7ngTy4Yvs/iU+5IYR2oTSnAnCXK0Pa+SOr5vUF/Ve9czsKfqtSoLa6oVGN9sPP6J+kfVVpy6bSoW3L0ADqVk6TNl222K3KTmBx+/drzUdeRUtsHhxcD+30oP3LT3s2VeV0V/O9YA5zag0nkFA7VDbgZrusLPfkWvJY29IUqZs1UkUFJz8WRMieEBQXv3/ph8dbJKevNeYAhWXDwLTyk7UEotMgnopLSFBHj67dfIq5Ea5jes0TDDvj+qoieMbklGsUivnf4PnXLfaufB0m1jj56JsUev8oqZH4g5pxKkpGZl4tt9C3E8eRM0djfTd9vnBqJn3SF4qcd4NKxt3kQGt/urUGxqLEavGq0mXz/X4Tk81tb08wUtRVpOmpqXJgk69lwuPd12df01s6K/AkrCGcnCGZUShaENh6ohfZboUtIlrDy/UiUKiM+4mTq7mXczFdzd3fBu1ZNnTUzxy298ejxGrRqlekclSctzHZ+7/XlnWckFPWmSwTElDpmJUVh57SB+SbuIKBTUJ3PKz8eI1DT45+bhW2+vIsk5RhVJznELMrzM0UOvVtjNmmHqIo4sLNmj128a4Fa7IKCRHvsi17bGLZcabr+NK7+3zYLnbMlcrftW34fw5HDcGzwIH4TcW6S37ULiBfVj0Krzq5CSk3IzSUeDgWr+pCT04Rzv6tm7U9pQ9lFNRpn8echw7NEjqkRFEqUcu5lNWXrvkOeChi698Wj7cbinWWeLyIZkCvXcC7IwShHl/x3+n+oNaVmnJWoK6UXYE7dHpdXfFHGzFlBprPHXTJk/M73XdDz4x4Nqflv/oP4YFDLIIuZMujm4YUP4BtV7d+RqQWFlIXPtpEC2BHgt6rQw277WBH6ufmq+piTn+fH4j+hTv8/N3uzi887u+QJoOqhIEIfk2GLXcQVDKgHcsLXFQk93/ObpgRt2BcOfvfLyMD45FROSU1BHY6OGQA5LTbuZnCMvD2h5b0FyjuKBW2n3HVz0vqjL0KBHkQyJqqfK1HP0imVhLN4bZslztiQR0/s938eD6x/E75F/okGdFrirTgiOX1qveu9kmK0Wk3TULBLUSZIq+aFP/u+ztvnKZFrs0TMx9uiZTm5eHj7etgi/hc8oUczcNb8p7m00Bk93GwEv5+qTjKOiWRhlGM7CoQurfRZGSc4hvT9rL64t0gMktYBkiJH0Xu2O211jfs283V8Bvz74Nb4/9r0KolYMXwFfV1+Ye86kDMfUZs2U9ukV2EsFd5IpVhIKWbuC3p0DqNWok3G9OzmZBb1umXJJArKSMO3UT1h97QjqO3hgqd9AuEnikMMLKrRf0fZ2mFvbBytcnZBZ+H0aaOeGB3y7YGTQQLh6NwA86gG5mcBXbaukJ6zGZGGsxB6ex/58TH0nFiefvX71+6m5d2H1wpikw4p7d8j62jw5ORleXl6qiPutanZbx8QfqlY2XziK7w4uwcmUv9XQzOI/DMv9f7V7ClM63YmaTIbdvNX9LZWF8ULShWqbhVHSRK+/tF4FeKeun9Itl+BlSMgQFeC18WmjG2bEXzNveqrdU9ges10dt7d3vo3/DfhflQ7HksC8+JxJCfLkV2bJCCvJVcwRfFpMOn/51UkCo5wMICcdOPIbbLZMR22pqSZDEdvfD/i3KQzgkgoDOO1tbUBXGNwVli/QN9XGBvvrByAaKfj09Fy8W1oGRsUW8AwAPAIKr+sVXHsG4gRy8POV7fgzbqcuWG9RuwUebv0w7mxwZ+nzf6uqJ6ymZGGsxJ50Sc5R3AMtHsDkVpPZ00NEt8RAjyzCuYQ4fLV7MXbF/3kza6YkVslzBmwzi/Xo2agSCNbA29kb7/d4X2VhlCKqktiie0B3WDqZX/J31N9YdWGVStKRJyeMhXNIpOdHgrs+gX3KTDLBxBwF5PjIEM5xa8apgE/m5Mgv+JXtzPUz+PX0ryo4L54YR7wb9i66BnRFtZGdrgpbY+O7hT1VNkCXR4CgbgUBmgRqkkhEBWyFQZvuordMtqN7vPC62PHRflXZyPLD843cURvAyRNw9lTXHs5e+I+jHR7Ji8AyD3f0DeyD/kdWFn1OGb75/BGgVnCR0QCSzOXn4z8Xmffas15PPNT6IXT171r+DwYyhLLRAGZhNDMZLp2PktmH+wf3Z5BHRAZhoEdmk5SZjv/uWYl1l9YgEccLCpqrrJm28LZpi3tCh+KprsMwY+uCEsXMzVHnzpxZGGVy/eKzi/Hm9jexfMRyi8zCKL0F0vsowYHM4ZJEMlptfdqq4G5wyODbL7JsZRp7N8bzHZ/Hp/s/VWU3JNCXuXKmJpkyZb6kpPc/GH+wzPVkyFhlPL9BvW1SPFqKWadfBzKul3M7sehy6XUrQgPs+6HgYiqSUbS0+mshvYE6jQoDOKl35qV327PobUlgUmxYkKQgenD/Z/j5xM94NzscbYbMgM8fbxTtbSsM8qQNJQPjnBNzVG+ssLOxU+n1pSxJs9rNrKInrKZgBkYiul0M9KjK590tPLYVv55Yjqis3YBdpq6guVNeA/T0H4znuo1Bozr+FlXM3Nz+3fnfap5GZEqkqrH1Ue+PLCIxh/S8ye3VF1erAC8mNUa3XoBbgJpzJwFeqFeo2fa3JpjUcpIqubH38l5M2z7NpCU3ZGit9BQuObMEVzOu6ubhybC+Cc0nqMya7+9+33TFzKVGmgxX1B/CeOL3gh431VNlA4T0Kkhzr4K1GwUBW/oNILsgu6DJBLRTwxtV8hB1cSu8dgUcXW/eLv6YXKvH9dZJuQx82brk3LaRs287YHq2w7Oqh06Ct/dST+Lr54/C5sYl3bwzyVy79OxSzDs5D1fSC2rHudq7YnTT0WqYX4B7wO0eKTID+ZzJ5634nGUm5yAiQzHQoyqxI+IU/m//YhxN3AyNfeE8E8mCneuN1l798HjHseUWNJfgzhoDPP0sjJJif/L6ySqRiUzCHxw62KyJOWxgg0D3QESnRusel4yMgxoMUsGdpPeWExO6fXIcP+z5oUq5L5kupeaZruRGBeadydA+2Y703v0Z8SdypeA0gDrOdVTtrTFNxqCuW0GJko4xx9EzMgZR9rYIys2Hf4sbQGq83jyzxJLzzsqciybXKbeotaYBwreV87hNQQ+Ya23ARS7epdz2LrpcEp38X/eSQdj430zXayXbuVVNtQqSJDczes3AhLUT8Hf035jj10EVv3bPScKfB5aoLIzaFPvShvLDgNRilHmwVL1xzjIR3Q5m3TQxZt28Kfx6PL7eswRb4zYgy+6Sbrkm3wlBjt0xrvm9mNS+P+wLU3xbg9vN3PTtoW8x++hsNXRz+fDlupPxqhCXGoe7lt1VYs6WBHw9AntgeMPhau6Ii71Lle2TtWXqkjmPUnJDetx+vXsBWlzYBvzx+s1U+2HPAo36AbnZBck9cgsv6nY2MrNT8UfKOfyafBqncm7WoGxn644Jdj4YpHGBgww/lL+X4Y5SBPvqaVQKySArwxZlnqaUBSiuy2NAYKeSQZwEeVIrzViqLEElp/OvpJpqWhLgf37g81Ifk8y1MjxzaKOhcLIzsNg31ciMfFS52N7WJ9/CPuPGxBoM9Mx48C3tjWOKYuah3nUxa+9aNZTvuuYIbGwKknDIvDsvtMKQkKF4uutweLu6wxrdbpvLHJxJ6ybh5LWTqs7OrDtnVXoWRineve7SOvx0/CdV16e4z/t+joEhA1HtmDoDY0VT7UvmRkkEUmSe2Q29+zd09zUZ1/GSJh4bHfLRKDsHi2Lj4FRe51ihWHs7LPJwx3IPdyQW/rDimK/BkLQ0VTutVXYpc8tuxalwXllp885KvV+4nnaZvdPNdihtyGM1Tedfmd/rsSmxuGv5XSWWvxf2Hu5tci970M2kpvxfToZhe1uffAv7jLO8ApmtmDk0DrCxLThplPjDIS8I3X0H4rnu96G5b322zG1ysHVQQzjHrh6rslkuPLNQzaOqDBHJEVh0ZpEqjJ1SxtwoGVLYxrcNqgWZG5Z+raCAtNQi2zP75pywFsOA+p0LbqvA+VbXuPV6kbtgc/hX1FZ9oDZAozsKUt4XTxQil7xsg16CbPltW1scCgzABUcHfO1dC69cv9kzp9QKUT1fGntH7LHLx282qfhbk6rL3Rdg64xxLiEY5d4Q3o6FAZdcpBfI3rGgp03q4cmyrFTg9ycKglHdTtgVZnkMMumQxxqTzr8S6Q+T1hfkGcQgj4iISuAcPaqwFSd2YU3s18XOe2XYlztaeN6Bx9rfh4FN2vMIm1hDr4Z4qdNLmLF3Bj7f/zm6BXRTy0whLz8P22K2YeHphSr5g1Z99/oY12ycSgAi2R8rPTGAsb1tMu8rOa4giNNedPcv37wuLSuiBHunVhVcTKxIqv0Lm8pfWYKr0uaZFblfG94u3ng/NRxPH/wE8zw90C89A10yC2uw2dghbdJSrE44oObfXUy6qJsOJ+8T+VFA5nfaGTP0UYZ9Fg/CTDwkken8DcMsjEREZAwGemSUlKwM/HfPKqy+uBJJOFaimLl4od27eKRzyeFFZDrjm49Xdep2xe3CtG3TMO/ueaq3r6JuZN5QiVYk+6I2c6bMvesV2Es9l1xrE6vcWbs1ouL2IyigM/z9KyGQV3Opnr8572zAO0BwWBlBXGEAJ3PJDFKYyEMSiBTXsH9BpkfVe6Ux8Lpw6CWK3U5LAGL2l3yODg8AgR11QVuRIE4yNxo4DLcPemN0ygUsO7cMr/vWwVsJ1+GmscGm1ndh5Z+TdaUtZL7k8EbDVYDXqFYjVEhV1VSr5r1tVYFZGImIyBico2diNXWO3rozB/D9oUU4n/4PYCdFgm+e1xYvZv7r4FVWnSGzqtr8StoVlYUxOTsZT7Z7Ek+3f9ronrBjV4+p4Z9Seys7v2D4oGTqG9l4JMY2Hokge/eic8ZOrQGO/HZzyKMER77NAMnaKBfp9cnPu3lfXcpaVsrfSHbExPCKHRCZE+YRAHj4F1zLMEkPvYvcd69bkDGysueEVcG8M5k7OXjZYNzIulFqYg4J0CXI85DabFRlquJ7XUqcyHzZII8gptq3ANXp/3K6fWxv65NvYZ9xztEjk4hKvIbPdi3Etri1yLaLulkSIc8LrT3vwNNdJmD1me1WXczcaMkxcIw5ADh3uu3hb5Jx863ub+GVra/g+6Pfo3dqCtpu+vhmT5jMe5LeGJmbJj1YhfPBslKv4I+4HfgtfjdOZBbUTRMt4YTxOfYYciMJzhe/ANa8f4s90AAXNxdcKpubX0FvUllBnCx3crecOWGVmGpfSwL8xKySPZMf9foIQxoO4ZytGt6zx1pqRER0Kxy6SSUKmv908E8sOr0cV3L3w8Y2VwV3Go0dfG07YkzTkXis8xA42he8dXo2aGH1xcwNdnAubFY/j9qafGj0A7HSSA+XZGLUXVILrnPSb97OTsPg7DRscQnGuoxITDv9MxZDA1f5ewn2Vj0L/PlWQf0yTT6i7e2w2MMDKzzcdJkXHTQaDE5Nx/iUFLTJytbNKStChjrKMENJg59wtuTjrccAtUMBKeAtc7/Utf5Ffh3QX17GOnKRYHTJlJI9YY//bdpArCqGI3acDE3D/rhRmGrfxsTz2qRQffFSF8LPzY9BHhERETHQowL7os/j6z2/4kjiRmjsC4aCSSxinxuIXv5348WwcWhYu27NLmZubAIQ6SmTwCsnA8iRwCu9MBBLK7lM5pTt+LIgKYcaMy2B2HPAoQUFQxbV3+gFdlLDzEDTbG1wIDAAEQ4O+Lx2Lbx57eZQvvzMROx0ccZCTw9sdXGGpnCcbQDsMNbBH6PcG6F2kH+RZB9FbrvUulmzrKzhiAPfN22gVJMyMHoGIjvQAfD0M/mmmZiDiIiIysMePSt2Iz0VX+1ejj8iViPN9vTNd0SeCxq69Maj7cfhnmadbz0euQrqkZnsOWQOmBrGmFj0+tyfwPHlN+eeBXUtGBKoAjcJ1gqDN+1tuc7NuM0XpQGidpe/igQ6ju6Aoxvg6Fp47V6QuKPwtpejGz7MisdjyQewyNMD/rm56JuegZ2urlhcrwki9YZnhgWEqblbfev3NS7zYlWmwa+q5B/VHBNzEBERUXkY6FnhhNIVp3ZjzpHFiMjaAdhmArYFSVQ8NS1wd+gIPNv9Xng5qwGAxmdILG84YkUVf44hnwDN7i4aqGUmlQzeSruWVPEGBWB7jNtHCbxU8CXXhUGZ/jKJH0/+fjM7o5DetcGfAF71bwZw+sGcXEvKfQMyMXaXy9Kh2J0Wga9qe+Mr71oFf5d5FR4OHhjReIQqjxDidZs9r8zAaFFGNRmFHvV6MDEHERERlcBAr4Y7fn4PTlzaBS+fZlgVfRq74tcj1z6u4EFbwCa3NjrWHoTnu01Eh7r1CwKm1FggIQnIvKEXQCUVXvSCqrSrwJXjN59Mf16YzLvSFo4WxYtJl7kMRZfJsMakqKLPse7lgktFSbAo886caxUMTZTUoXGHS67X9UkgoM3N3jMHl6JBnFrmWlBg2pAsTAfnlkzOYaKgWLLw7U3TO06FweELHV9QqfVdZT9NhWnwLQoTcxAREVFpGOjVYJ/Nn4JfcvcXzMuKKayDYA/Y59uge7Yzxmqc0CcvE3YX5wMnvy0YpmgKpdUoMzlbwNX7ZrBW3rVKJqK3TNLN6wdmZc096/mcyROAVFZyDknMkQ+9/S/U1retaYM8IiIiIqoWGOjV4J48XZAn5FqjwfM3EjE2JRWe+SWz9RWpR6bt8dIFSaXcl962Vc/cLBytnscWeOB3wM23aFHp8gpOq9vF1lF3pfB0PLD4gWLPIfXIjhYMeTSFqpp7VonJOZiYg4iIiIj0MdCroWS4pi7I07KxQQPvLvDs2q+UIK4wkJMgz86It4X0ghUPkBr2Ne2LGfZ1KUGYiYK8GpIAhIk5iIiIiEgfA70aqlVoGGxjfkC+XrBnq9EgoNfrQONu1a4eWZUEYdV87hkTcxARERGRFgO9Gqp1426YvL835v5/e/cBHEX1xwH8l1ASQu+E0EOvAWlK6DV0FKSpSJEmICAI8geRAWEAQQGlSBmEUREQBKnSEQlN6VWkB6VDCCUQ8v7zfePe3F0uDcIlt/v9zNwku7e39/a927v321f28W862EOQ945vTb3eIwMkDw/C3IUTcxARERERMNAzsQ87zJLGZ/fKifN7pXThai8nyCMiIiIiohSHgZ7JIbhjgEdEREREZC0JuPkXEREREREReRIGek42bNggzZo1k8qVK0vXrl3lwoULyVMyREREREREz4mBnlOQ16JFC6lZs6ZMmTJF7t69K8HBwfovERERERGRp2CgZ2f06NHSoUMHGT58uNSuXVuWLFkiDx48kNmzZydfCRERERERESUSA73/REREyP79+6Vp06a2zPHx8ZEGDRrItm3bEpuvREREREREyYazbv4nLCxMFG4o7u/vkEFYPn78eKwZGBkZqR+G8PBw/Tc6Olo/4oLn8Z7xbUfmwTK3Fpa39bDMrYdlbi0sb+uJTmH19cSkg4Hef6KiovTftGnTOmQQWvWePn0aawZOmDBBxowZE2P9jRs35PHjx/EW1L179/SHx9ubjatWwDK3Fpa39bDMrYdlbi0sb+uJTmH19fv37yd4WwZ6/8mePbv+e+vWLYcMwnKOHDlizcCPP/5YBg8e7NCilz9/fsmZM6dkypQp3g+Ol5eX3jYlfHDo5WOZWwvL23pY5tbDMrcWlrf1RKew+rqvr2+Ct2Wg9588efJI3rx5Ze/evXrmTUNoaKjUr18/1gxEix8eBkT7xpi/+D4M+OBgu3Tp0qWIDw69fCxza2F5Ww/L3HpY5tbC8rae6BRWX0da7GOOuDDQs9OrVy+ZOXOmdOvWTYoUKSKLFi2SM2fOyA8//JDo5lS06hERERERESU1xByZM2eOcxsGenZGjBihb5BesmRJ3V3z4cOHsmDBAgkKCkpwpqNV8PLly5IxY0bdzBsXo5snto+vmyeZA8vcWlje1sMytx6WubWwvK0nPIXV19GShyAPMUd8vFRC2v0s5s6dO3Lz5k0pUKCAQ7fMl/HBQSSOAZ4p4YNDLx/L3FpY3tbDMrcelrm1sLytJ9yD6+ts0XMha9as+kFEREREROSJkn9EIRERERERESUpBnrJCN1CR48e/VK7h1LKwjK3Fpa39bDMrYdlbi0sb+vx8eD6OsfoERERERERmQxb9IiIiIiIiEyGgR4REREREZHJMNAjIiIiIiIyGd5eIZk8evRITpw4oe/LUbRo0eRKBrkBbrB58eJFh3WpU6eW6tWrM/9Ndk4fPHhQAgICpGDBgi63uXv3rpw9e1by5Mkj+fLlc3saKWlduXJFLly4IEFBQZIhQwaH586cOSPXr193WIf7L5UvX57F4KFwg2Kcv/7+/vocduXZs2dy7NgxSZUqlZQuXVq8vXk93dPP8du3b0tgYKCkT5/e4TmsRz3OWdWqVSVt2rRuTCUlFaWUnDt3Tv+eFylSRPz8/Fxuh+993G+7ZMmSMb77UxzcMJ3ca9myZSpz5syqWLFiKlOmTCo4OFjdunWLxWBSY8eOVRkzZlQ1atSwPZo0aZLcyaIkcu3aNTVw4EDl7++vfH191bBhw1xuN3nyZP18qVKlVLp06VT79u1VZGQky8ED7d69W7Vs2VLlyJFD4Wd0//79Mbbp3LmzypUrl8N537Nnz2RJL72Y8+fPq3bt2unf7aCgIP273bBhQ33u28PnoECBAipfvnwqd+7cqmjRour48ePMfg+0evVqVbZsWRUQEKDKlSun0qdPrz755BOHbVauXKm8vb0dznE8rl+/nmzppuf3448/qsDAQFWiRAlVsmRJlSFDBjV+/HiHbSIiIlRISIj+PGA7Pz8/NW/evBSd7Qz03OzixYvKx8dHTZ8+XS+Hh4frL5OOHTu6OynkxkCvWrVqzG+T2rdvn5oyZYq+WFOmTBmXgd727duVl5eX2rhxo+17AEHAmDFjkiHF9KLmzJmjK3nHjh2LM9Dr0qULM9sENm/erJYuXaqio6P18u3bt3XA16ZNG9s2uGhTsGBB1b17d7387Nkz/Ty+E4zXkeeYNm2aPr8NO3bsUGnSpNHBgAHfAajwkzl8/fXXKiwszLa8atUq/f0eGhpqW9evXz9VpEgRdePGDb28ePFiHewfPXpUpVTsU+Bm3333nW7m7du3r17OmDGjDBw4UJYvXy7h4eHuTg65SVRUlBw+fFhOnz6t/yfzqFKligwePFiyZcsW6zYLFiyQatWqSaNGjfRygQIF5J133tHryfP07NlTWrdurbvnxQXdf/744w85f/68REdHuy19lLTq168v7dq1Ey8vL72cNWtW6dChg+zatcu2zZYtW3QX/ZEjR+pldNn83//+J8ePH5e9e/eySDzMgAEDpEyZMrblWrVq6WX7MjecPHlSjh49Ko8fP3ZzKikp9e3bV/LmzWtbrlu3rv4bFham/6LutmjRIr1djhw59Lq33npLD9VYuHBhii0MBnpuhjE8GM9hX0FAf+6nT5/qHwQyb7l36tRJVxgwtmPx4sXJnSRyc/m/8sorDutw3qNieOfOHZaFSa1cuVK6deumLwZgLPbWrVuTO0mURPbv3+8wvh7nePbs2aVQoUK2dZUqVdK/9XiOPBu+p//+++8Ycyo8ePBAWrRoIW3atNEXAMaOHZtsaaQXd+vWLR3Mr1mzRjp27Cg1atSQZs2a6ecwdg8NMs6/5fh+T8nnOCdjcTMM3sWPgT1jGc+R+eBLAF8QxgQdX375pbz77rtSrFgxTshiEfGd96ggkLmgxW/69Om6pRcX8gYNGqQrg7igx4l4PNuyZctkxYoVujIY1zmOFkCUP3/bPRuGOaEVH9/TXbp0sa3Pnz+/HDhwwFbxX79+vbRs2VKf3127dk3GFNPzOnr0qG6Vx0RaCO7xHe7r66ufM85jV7/lmHwrpWKLnpulSZMmRvM+uvcAZ2kyp8aNGzvMwoiuugjyUFkga+B5bz1t27a1dedF+U+ZMkV/96MySJ4LXTTR7XrixInStGnTOM9x4/edv+2e340TrfGrV6/WM6UbEODZt+6EhIRIq1atZMmSJcmUUnpRderU0S16CNzQTRPn+tq1a23nOLiqw6fkc5yBnpuhwm/09zUYyxi3Q9aQO3fuGJ8Dst55jx+O2KZpJ3Px8fGRLFmy8Lz3YKjso8Vm9OjRMnTo0BjnOFoB0HprQDeviIgI/rZ7MLTEY26FTZs2SYUKFeLdnr/t5hESEiJly5a1XZwzLti7+i1PyfV3Bnpu1rBhQ92XF/dmMaxatUp/SIoXL+7u5JAboA+/vRs3bsihQ4f0FwhZ57z/9ddfJTIy0uG8x9VD4yohmQcG7duXNWAyJgQCPO890/bt2/VYLHTrGj58eIznGzRooMscAYH9OY57phqTOpBnwSRb3377rS5TjLeM77cd5z0+JzzHPU9UVJQ8efIkRksdgjijqyYmYMEcG2jZNaB7586dO/VvfErFMXrJMG4DkzDg74gRI/TNV9EHGF8mxoxeZC74kUd5V6xYUd9gc9KkSZIrVy7bzKvk2XAF35hV7+HDh/oiDrp+2N8cG2X9zTffyOuvvy69e/fWlYHNmzfLjh07kjn19Dz++ecfPTHDpUuXbEEcuvMULlxYAgICdAUwODhYevTooW+oi1k3x40bJzVr1tTfBeR5E680b95cz5qLMrSfeRHlDJikA+X93nvv6W6d+F4YMmSIDhbwfU+e5ZNPPpFp06bJF198oSv8Rpmjso9zGjDRElp58BlAec+ePVuuXr0qS5cuTebUU2KFh4fruprxnY262qxZs/SFml69etm2Gz9+vL7gg8YZ1OnQJT8wMFB38UypvHCPheROhBU/UJMnT5bQ0FDd3xuDdvEjQuaEKz5fffWVDgb8/Px0oI+KP/4nz4cB2ujO5QxTcc+ZM8e2jCuDqABiMg5/f3/p37+/vuUCeR5MxDF16tQY6/v166en3YfLly/LjBkz5MiRI/qKcL169fQkTPHdkoFSHoy5wne4K7hYY5QpWgVQOVy3bp2+vQLGa6HiiP/Js6DcTp06FWM9ggFjZk204M6dO1d36cXtU9CS98EHH0jOnDmTIcX0oi5duqTPc3xn40Itxl8iyEOXe3vbtm3TQT1m6ESwN2zYMNvtFlIiBnpEREREREQmw8tMREREREREJsNAj4iIiIiIyGQY6BEREREREZkMAz0iIiIiIiKTYaBHRERERERkMgz0iIiIiIiITIaBHhERERERkckw0CMiIo/xyy+/6BvVEsXnwYMHsnz5clFKMbOIyJIY6BER0XPZvn27HDlyxG25t3HjRhk6dKhkyZLFbe/paaKiomTJkiUeEwy/zPSmT59epk6dKosXL07yfRMReQIGekRE9FzGjRsn33//vdtyb/jw4TJs2DBJlSqV297T0zx+/Fg6duwof/31l3iCl51efGZGjhwpz549eyn7JyJKyVIndwKIiChlO3XqlJw5c0by588vFSpUEG9vbwkNDZVr167JyZMndYsMtGjRQreiREdHy4EDB+Tq1asSGBgo5cqVc9jfli1bJHfu3OLv7y+HDh3SXetq1aoladOmjTUNu3bt0ml48803HdZHRkbK7t275d69e1K+fHkpUqSIy/fKly+fHDx4UK+rXr26pEuXzmG7+NLszNhvnjx5ZO/evZIhQwapXbu2fi4iIkLnD1qrkF958+a1ve7JkyeyYsUKadKkiW7FQv4FBARIxYoVY7zH9evX9b5Tp04tr732mmTOnNnlfv799185ceKEfi/kBWzevFkuXLggWbNmlcaNGzvsNzFpSOix2KcB+ecMgRaO5fbt2zpvCxYsqNevXLky1vQmRT42bdpUHj58qLv8tm7dOs4yJSIyHUVERBSLbt26qezZs6uWLVuqKlWqqJo1a6rbt2+radOmqdy5c6tSpUqp9u3b68f169fVlStXVKVKlVTx4sX1a/Lnz6+aNGmiHj58aNtnjRo1VHBwsAoICNDPFShQQJUuXVpdu3Yt1nIYNmyYqlOnjsO6EydO6NfivRo2bKj8/PzUkCFDHLbBeyHNgYGBqlmzZqpo0aL6cevWLds2CUmzM+MYChYsqJo3b64mTJig169du1bnF54LCQlRmTNnVpMmTbK97saNGxgwpp8rXLiwaty4scqQIYPq3r27w/7nz5+v0qVLp2rVqqXzHftZt25djP3gmIoVK6batm2rNm3apDp27KjXN2jQQJcJ8s1ZQtOQ0GNxToMzlGvJkiX1A/mL/P/oo4/0c7GlN6nyEVq3bu1yPRGR2THQIyIil86ePasr0+fOnbOt27NnjwoLC9P/169fP0YgUa9ePdWnTx8VHR2tlx89eqQqV66sRo8e7RAkIYg5ffq0Xn7w4IEOtHr27BlrSSCQ69u3r8M6BAGtWrVSUVFRenn37t3K29tbbdmyxeG98ubNawsiIyMjddA3fvz4RKXZGfabLVs2W17A1atXdbBhH5AdO3ZMH+uff/7pEKDg9XgfOHLkiEqTJo3tdZcvX9avmTdvnm0/w4cPV/7+/ioiIsJhPwgynz59atvu/v37en1oaGisaU9IGhJzLM5pcPb555+roKAg9ezZM72MfF65cmWs6U2qfDSMGjVKlS9fPtb0ERGZFcfoERGRSz4+PuLl5SWHDx+2ratWrZpDFzp7ly5dkq1bt+quez/99JMsW7ZMVq9erbtTbtu2zWHbVq1aSfHixfX/fn5+0q9fP1m6dGmsJXHz5k3drc8QFhamu3Paj9l79dVXpV69eraupIY33nhDcuXKpf9H91Bsd/r06USn2Rn2a58XeC2OBbM94n88jh8/rruoYuIae/379xdfX1/9P7oyhoSE2I5/1apVuptmt27dbNuPGDFCd5XdsWOHw3769Omju3Y+j7jSkJhjiS8N6CZ7584dndeAz1Rc3SiTKh8N+Nzg80NEZDUco0dERC5hXNvMmTN1RR4V6rp160qXLl2kfv36LrfHGCv4/fffZf/+/bb1qNhXrlzZYdtChQo5LBcuXFju3r0r4eHhkilTphj7xhg4VPwNFy9e1H+dx+QhYDt//rzDumzZssUIYDH+K7FpdobAw/n4MdYPU/rbq1Klih7LF9/xGzOY4tjwPNJgyJgxo+TMmdN23LGlITHiSkNijiW+NHTt2lX27dsnZcqU0cF9w4YN5f3337eN03OWVPlowOcG+UdEZDUM9IiIKFa9e/eWXr16ydGjR3VLE1pMUAFv2bJljG2NAA2zHFaqVCnOXEULj/MyAjAEdK4gQLAP4HLkyKH/YnIPTIpiwLLxXEIkJs3O7AMxY19ovXJuUUzo8Rvpxl8chz0MtUAg7HxszmlIjLjSkJhjiS8N2M/ChQtl1qxZenIV/EVenz17VtKkSRNj+6TKRwM+NyVKlIh3X0REZsOum0RE5BKCjUePHumKPGa0HDVqlG5V2bNnj34eQRmmxzeg6xxmPpw9e3aMfWE2S3vr1q3TMycaMIMiulRiRk9X0IqIGSWNm1+jJQ/dJvE6A2be3LRpkwQHBye4RBOT5vhgBsjLly/L2rVrHdZj1kcEafZ+/vlnh+c3bNggNWrU0MtIP243gODagO6kaOWqWrVqnGlAgISurPblEpu40pCYY4kPutkaaUPXWrQS47OFY3SV3qTKRwNaaxs0aJCoNBMRmQFb9IiIyCV0E2zfvr20a9dOihUrpsdJ4RYFU6ZM0c+ja+O8efN0sITbKuD2CvPnz5c2bdroKe8xTT4q9GvWrJG2bdvKwIEDbftGAIkufJ06ddK3NcC4qrjGxGGfAwYM0Lc1QKUdY8JwM+y3335bV/4R+M2dO1d35evRo0eCSxRBRkLTHB/ctmHw4ME6vzDmEK1IaLXC2D/cRsD+Ru8IUBHU4rYBaO1CK1bPnj31c7iVQocOHfStAT788EOdVxMnTtQ3i4+tu6P98QQFBekyQoCF1i3n2yskJA2JOZb44IblCOybN2+uu5+irLE/XDyILb1JkY+A8aUYG9i5c+cEp5eIyCzYokdERC7hnmQIvhDEYRIQdLPDODYEATBkyBAZNGiQbjFBywpaVFBJR0CISjzW379/X1finQMmjNHCA61WmCAF2yLAiQ0m3ECgM23aNNs6BKGYnAMtg2hlRND322+/OXQHRFBYtmxZh32hVcz+vRKaZnuu9gt4HYJEpAn7wkQgO3fu1OPT7CFAwXhCjF1DwIsujfb39kNw9Nlnn+n8wZg1BDFYNqCbK47ffoIaAwIipG39+vVxBs/xpSG+Y4krDc43LZ8wYYKeEAX7adSokX4vYxIVV+lNqnycMWOGHmPqPE6TiMgKvDD1ZnIngoiIrANdExEoffrpp4l6HSr9qLSPHz/eYVyeJ0Gwg1YttIyiJcuqaXDHMWASFlxMmD59ussJfoiIzI5dN4mIyCOg5Q/dLIkSAi3RaAklIrIqdt0kIiK3iq3boxUktLuj2dPwosxwDERELxu7bhIREREREZkMW/SIiIiIiIhMhoEeERERERGRyTDQIyIiIiIiMhkGekRERERERCbDQI+IiIiIiMhkGOgRERERERGZDAM9IiIiIiIik2GgR0REREREZDIM9IiIiIiIiMRc/g+bg3QBNjJTkgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 900x420 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "runs = {\"Keep everything\": (keep_answers, keep_log),\n",
    "        \"Clear each report once answered\": (clear_answers, clear_log),\n",
    "        \"Clear in batches of 5\": (batch_answers, batch_log)}\n",
    "\n",
    "print(f\"{'':34}{'input sent':>12}{'cached':>8}{'last call':>11}{'cost':>8}{'caught':>8}{'wrong cap':>10}\")\n",
    "for name, (a, lg) in runs.items():\n",
    "    s, sent = score(a), sum(r[\"input\"] for r in lg)\n",
    "    print(f\"{name:34}{sent:>12,}{sum(r['cached'] for r in lg) / sent:>8.0%}{lg[-1]['input']:>11,}\"\n",
    "          f\"{'$' + format(cost(lg), '.3f'):>8}{str(s['caught']) + '/' + str(len(TRUTH)):>8}{len(s['wrong_cap']):>10}\")\n",
    "\n",
    "plt.figure(figsize=(9, 4.2))\n",
    "for name, (_, lg) in runs.items():\n",
    "    plt.plot([r[\"step\"] for r in lg], [r[\"input\"] for r in lg], marker=\".\", label=name)\n",
    "plt.xlabel(\"step (one report per step)\"); plt.ylabel(\"input tokens in this call\")\n",
    "plt.title(\"What each call sends to the model\"); plt.legend(); plt.grid(alpha=0.3); plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c28ba76f",
   "metadata": {},
   "source": [
    "### What the numbers say, and what they don't\n",
    "\n",
    "- **Tokens.** Keeping everything sends far more tokens per run, and the size of each call grows with every report. Clearing keeps each call close to flat: the policy, one report, and a line per finished report. Batching gives the sawtooth.\n",
    "- **Dollars.** The gap in dollars is much smaller than the gap in tokens: clearing every step sent about a fifth of the tokens and saved under 10%, because the append-only history was 94% cached. Batching was the cheapest run here. It sent more tokens than clearing every step, but most of its calls still repeated the previous prefix, so 71% of what it sent was billed at the cached price. In two earlier runs of the same setup (not shown), the two clearing modes cost about the same, so treat the dollar differences as small and noisy, and measure your own runs before you design around them.\n",
    "- **Quality.** At this size (the last call of the default loop is under 40K tokens), no mode ever checked a hotel night against the wrong city's cap. Recall is closer. Across this run and two earlier ones, keeping everything caught 11, 10 and 9 of the 11 planted violations, and clearing every step caught 11 each time. The default loop missed R-24, one of the late reports, in two of its three runs, and the clearing modes never missed it in six. That is a hint, not proof: three runs per mode is too few, and R-03, an early report where the contexts barely differ, was also missed twice. **This notebook does not prove clearing makes the model more accurate at 30 reports.** Quality loss from long contexts, \"context rot\", has been measured at larger sizes and with harder distractors ([Chroma, 2025](https://www.trychroma.com/research/context-rot)). To look for it on your model, raise `n` in `make_reports` and watch the `caught` and `wrong cap` columns.\n",
    "- **What clearing buys you for sure** is room. The default loop's calls grow by about 1,270 tokens per report, so 300 reports would put roughly 380K tokens in the last call, more than many models' windows hold. With clearing, the history grows by about 150 tokens per report (the one-line stub plus the agent's answer), so the same 300 reports would end under 50K."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "580456b9",
   "metadata": {},
   "source": [
    "## 6. An aside the data forced on us: the false alarms\n",
    "\n",
    "Every mode produced false alarms: 10, 20 and 12 in this run, and anywhere from 12 to 20 in the two earlier runs, with no consistent pattern by mode. So they are not a context effect. Look at what the model actually wrote:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f7cf157c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:33:33.348082Z",
     "iopub.status.busy": "2026-10-29T22:33:33.348006Z",
     "iopub.status.idle": "2026-10-29T22:33:33.350042Z",
     "shell.execute_reply": "2026-10-29T22:33:33.349657Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R-04: listed as a violation -> amount 230, limit 260   (2026-09-06  Hotel: The Verb Hotel, Boston - 1 night - $230.0)\n",
      "R-08: listed as a violation -> amount 310, limit 320   (2026-09-12  Hotel: The Lexington, New York - 1 night - $310.)\n",
      "R-12: listed as a violation -> amount 205, limit 210   (2026-09-16  Hotel: The Driskill, Austin - 1 night - $205.00)\n",
      "R-13: listed as a violation -> amount 290, limit 300   (2026-09-16  Hotel: Hotel Zephyr, San Francisco - 1 night - $)\n",
      "R-15: listed as a violation -> amount 305, limit 320   (2026-09-01  Hotel: The Lexington, New York - 1 night - $305.)\n",
      "R-19: listed as a violation -> amount 205, limit 210   (2026-09-13  Hotel: The Driskill, Austin - 1 night - $205.00)\n",
      "R-21: listed as a violation -> amount 220, limit 240   (2026-09-12  Hotel: The Robey, Chicago - 1 night - $220.00)\n",
      "R-27: listed as a violation -> amount 270, limit 300   (2026-09-15  Hotel: Hotel Zephyr, San Francisco - 1 night - $)\n",
      "R-29: listed as a violation -> amount 305, limit 320   (2026-09-07  Hotel: The Lexington, New York - 1 night - $305.)\n"
     ]
    }
   ],
   "source": [
    "for rid, vs in keep_answers.items():\n",
    "    for v in vs:\n",
    "        if (rid, v[\"rule\"]) not in TRUTH and v[\"rule\"] == \"H\":\n",
    "            print(f\"{rid}: listed as a violation -> amount {v['amount']:g}, limit {v['limit']:g}   ({v['receipt'][:60]})\")\n",
    "            break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18b369ba",
   "metadata": {},
   "source": [
    "In every case printed above, the model wrote down an amount *below* the limit it named, and still listed the receipt as a violation. Moving rules around in the context will not fix that: the model extracted the right numbers and then got the comparison wrong. The fix is the one from the [while-loop notebook](agent_while_loop_from_scratch.ipynb): anything that must hold belongs in code. Let the model do what it is good at, reading a messy report and pulling out the receipt, the amount and the right city's cap, and let a line of Python do the comparison:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1e105fc7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-10-29T22:33:33.350951Z",
     "iopub.status.busy": "2026-10-29T22:33:33.350894Z",
     "iopub.status.idle": "2026-10-29T22:33:33.353130Z",
     "shell.execute_reply": "2026-10-29T22:33:33.352793Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keep everything                    false alarms 10 ->  0   caught 9 -> 9\n",
      "Clear each report once answered    false alarms 20 ->  0   caught 11 -> 11\n",
      "Clear in batches of 5              false alarms 12 ->  0   caught 10 -> 10\n"
     ]
    }
   ],
   "source": [
    "def checked_by_code(answers):\n",
    "    return {rid: [v for v in vs if v[\"rule\"] == \"D\" or v[\"amount\"] > v[\"limit\"]] for rid, vs in answers.items()}\n",
    "\n",
    "for name, (a, _) in runs.items():\n",
    "    before, after = score(a), score(checked_by_code(a))\n",
    "    print(f\"{name:34} false alarms {len(before['false_alarms']):>2} -> {len(after['false_alarms']):>2}   caught {before['caught']} -> {after['caught']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b311b056",
   "metadata": {},
   "source": [
    "## The fact to walk away with\n",
    "\n",
    "The bare loop never forgets, so by step 30 it re-reads 29 reports it already finished. Replacing a result with a one-line finding once the agent has acted on it costs no model call and keeps every call close to the same size, however long the run gets. At 30 reports, on a current model, it did not clearly change the audit's quality, and with prompt caching it saved far less money than the token count suggests. Measure your own runs before you believe any of these claims, including the ones in this notebook.\n",
    "\n",
    "What to try next, in the order the chapter recommends:\n",
    "\n",
    "- **Cap results on arrival.** Keep the head and tail of a huge tool result, write the full text to a file, and leave the path in the window. Always mark the cut, because an unmarked cut looks like a whole result.\n",
    "- **Restate the rule that matters beside new material**, if instructions start fading late in long runs.\n",
    "- **Compact** only when history still outgrows its budget after clearing. Use a summary with fixed headings (task, decisions, exact values, what failed, what is left), because every summary silently drops something."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd485b0b",
   "metadata": {},
   "source": [
    "---\n",
    "📖 **Want the decisions behind agents like this one, explained without code?** [*AI Agents Made Simple*](https://europe-west1-rag-techniques-views-tracker.cloudfunctions.net/rag-techniques-tracker?notebook=all-agents-tutorials--context-engineering-from-scratch&click=book-nb-agents&target=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB0HNXRSRH2%3Fmaas%3Dmaas_adg_api_580351185840460851_static_9_573%26ref_%3Daa_maas%26tag%3Dmaas%26aa_campaignid%3Dagents-en%26aa_adgroupid%3Dgithub-notebook%26aa_creativeid%3Dgenai-context-engineering&retarget=0&text=book-nb-agents) by the author of this repository has a full chapter on context engineering: the five layers, context budgets, compaction and what it loses, and when all of it is overkill. Available on Amazon."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}