{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "54bfad6b",
   "metadata": {},
   "source": [
    "# 03 - Your first language model: the bigram\n",
    "\n",
    "It is time to actually train something. The **bigram** model is the simplest language model there is: to predict the next character, it looks at the current character and nothing before it. (Imagine trying to guess the next word in a sentence when you are allowed to see only the single word immediately before it. That is the handicap it works under.)\n",
    "\n",
    "It is a weak model, but building it lays down the entire skeleton we reuse for the GPT: a forward pass, then the loss, then the backward pass (the gradients), then the update, then generation. We will even work out the gradient by hand and then check it against a brute-force numerical estimate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "colab-setup-03",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Colab setup -- fetch the files this notebook needs.\n",
    "# (Does nothing when run locally in the course folder.)\n",
    "import os, urllib.request\n",
    "BASE = (\"https://raw.githubusercontent.com/waze\"\n",
    "        \"emlabs/llm-book-code/main/\")\n",
    "for f in ['data/input.txt']:\n",
    "    if not os.path.exists(f):\n",
    "        d = os.path.dirname(f)\n",
    "        if d: os.makedirs(d, exist_ok=True)\n",
    "        urllib.request.urlretrieve(BASE + f, f)\n",
    "        print(\"downloaded\", f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "colab-setup-md-03",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n<ul>\n<li><code>import os, urllib.request</code>: two standard-library toolboxes: checking files on disk, and downloading from the web.</li>\n<li><code>BASE = (...)</code>: the web address of this course's folder on GitHub, split over two lines (Python glues adjacent strings together).</li>\n<li><code>for f in [...]</code>: loop over the file names this notebook needs.</li>\n<li><code>if not os.path.exists(f)</code>: only download what is missing -- running locally, everything already exists, so nothing happens.</li>\n<li><code>os.makedirs(d, exist_ok=True)</code>: create the folder for the file if it has one (<code>exist_ok</code> means don't complain if it's already there).</li>\n<li><code>urllib.request.urlretrieve(...)</code>: download the file and save it under the same name here.</li>\n</ul>\n</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "35b3af9d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:40:56.598594Z",
     "iopub.status.busy": "2026-07-01T08:40:56.598447Z",
     "iopub.status.idle": "2026-07-01T08:40:56.812436Z",
     "shell.execute_reply": "2026-07-01T08:40:56.812014Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab: 65  dataset: 1115394\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pathlib import Path\n",
    "import matplotlib.pyplot as plt\n",
    "np.random.seed(1337)\n",
    "\n",
    "# --- setup from notebook 02 (tokenizer + data) ---\n",
    "text = Path(\"data/input.txt\").read_text()\n",
    "chars = sorted(set(text)); vocab_size = len(chars)\n",
    "stoi = {c: i for i, c in enumerate(chars)}; itos = {i: c for c, i in stoi.items()}\n",
    "encode = lambda s: [stoi[c] for c in s]; decode = lambda ids: \"\".join(itos[i] for i in ids)\n",
    "data = np.array(encode(text), dtype=np.int64)\n",
    "def softmax(x, axis=-1):\n",
    "    x = x - x.max(axis=axis, keepdims=True); e = np.exp(x); return e / e.sum(axis=axis, keepdims=True)\n",
    "print(\"vocab:\", vocab_size, \" dataset:\", len(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de8c755",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>import numpy as np ...</code>: load the toolboxes (NumPy, Path for files, matplotlib for plots) and seed the randomness so your run matches the saved outputs.</li>\n",
    "<li><code>text = Path(\"data/input.txt\").read_text()</code>: read the whole Shakespeare file into one string.</li>\n",
    "<li><code>chars = sorted(set(text)); vocab_size = len(chars)</code>: the distinct characters, in order, and how many there are (65) -- the vocabulary, exactly as in notebook 02.</li>\n",
    "<li><code>stoi = {...}; itos = {...}</code>: the character&harr;id lookup tables.</li>\n",
    "<li><code>encode = lambda s: ...; decode = lambda ids: ...</code>: one-line functions to turn text into ids and back.</li>\n",
    "<li><code>data = np.array(encode(text), dtype=np.int64)</code>: the entire book as a long array of integer ids.</li>\n",
    "<li><code>def softmax(x, axis=-1): ...</code>: the scores-to-probabilities helper from notebook 01, squeezed onto two lines (the semicolons just chain statements).</li>\n",
    "<li>Nothing new here -- this cell just replays notebooks 01-02 so this notebook stands on its own.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "423d0c27",
   "metadata": {},
   "source": [
    "## The model\n",
    "\n",
    "The entire model is a single table of numbers called `W`, with a size of `(vocab, vocab)`, here 65 by 65. You can read it like a reference table: row `c` holds the scores for \"which character tends to come after character `c`.\" Those raw scores are the **logits**, and softmax later turns a row into probabilities over the next character.\n",
    "\n",
    "The forward pass is therefore almost nothing: to predict what follows character `x`, you simply take row `x` of `W`. In short, `logits = W[x]`, then softmax, gives probabilities over the next character.\n",
    "\n",
    "(The code comment \"selecting rows IS the matmul with one-hots\" points to a neat fact. Picking row `x` gives the same answer as multiplying `W` by a list that is all 0s except for a single `1` in position `x`, which is called a \"one-hot\" list. Taking the row directly is just the fast version of that multiplication.)\n",
    "\n",
    "A fresh `W` is filled with tiny random numbers, so every row is nearly flat and the model has no opinions yet. That is why the starting loss lands right at `ln(65) = 4.17`, which is the cross-entropy score for guessing all 65 characters as equally likely (notebook 01)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6d320b4e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:40:56.813686Z",
     "iopub.status.busy": "2026-07-01T08:40:56.813604Z",
     "iopub.status.idle": "2026-07-01T08:40:56.816033Z",
     "shell.execute_reply": "2026-07-01T08:40:56.815738Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial loss: 4.1738  | ln(vocab) = 4.1744\n"
     ]
    }
   ],
   "source": [
    "W = np.random.randn(vocab_size, vocab_size) * 0.01    # the only parameters\n",
    "\n",
    "def forward(x):                 # x: (B,) current-char ids\n",
    "    logits = W[x]               # (B, vocab) - selecting rows IS the matmul with one-hots\n",
    "    return logits\n",
    "\n",
    "def loss_fn(logits, y):         # cross-entropy of the true next chars y\n",
    "    p = softmax(logits)\n",
    "    return -np.mean(np.log(p[np.arange(len(y)), y] + 1e-9))\n",
    "\n",
    "# sanity: an untrained model should have loss ~ ln(vocab_size)\n",
    "xb = data[:1000]; yb = data[1:1001]\n",
    "print(\"initial loss:\", round(loss_fn(forward(xb), yb), 4), \" | ln(vocab) =\", round(np.log(vocab_size), 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d331af21",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>W = np.random.randn(vocab_size, vocab_size) * 0.01</code>: a 65&times;65 grid of tiny random numbers. Row <code>c</code> will hold the scores for \"what comes after character c.\" Multiplying by 0.01 keeps it near zero so the model starts with no opinions. This grid is the <i>entire</i> model.</li>\n",
    "<li><code>def forward(x):</code>: the prediction step; <code>x</code> is a whole batch of current-character ids at once.</li>\n",
    "<li><code>logits = W[x]</code>: fancy indexing: for each id in the batch, grab that row of W. In goes a list of ids; out comes a grid of scores, one row of 65 per example.</li>\n",
    "<li><code>def loss_fn(logits, y):</code>: measures how wrong the predictions are against the true next characters <code>y</code>.</li>\n",
    "<li><code>p = softmax(logits)</code>: turn each row of scores into probabilities.</li>\n",
    "<li><code>p[np.arange(len(y)), y]</code>: pairwise pick: for row 0 take column <code>y[0]</code>, for row 1 column <code>y[1]</code>, and so on -- \"the probability each example gave its own correct answer.\" <code>np.arange(n)</code> is just 0,1,...,n-1.</li>\n",
    "<li><code>+ 1e-9</code>: add a microscopic amount so we never take log of exactly 0 (which would blow up to infinity).</li>\n",
    "<li><code>-np.mean(np.log(...))</code>: the average surprise across the batch: cross-entropy from notebook 01, as one number.</li>\n",
    "<li><code>xb = data[:1000]; yb = data[1:1001]</code>: the first 1000 characters and the same span shifted by one: each character paired with the one that follows.</li>\n",
    "<li>The print shows the untrained loss landing on <code>ln(65) = 4.17</code>: exactly the score for \"no idea, all 65 equally likely.\"</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1lookw01",
   "metadata": {},
   "source": [
    "### Actually look at `W`\n",
    "\n",
    "The paragraphs above keep calling `W` \"a 65x65 table of tiny numbers with no opinions yet.\" Rather than take that on trust, let's print it and check every word of that claim by eye."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a1lookw02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:40:56.817035Z",
     "iopub.status.busy": "2026-07-01T08:40:56.816971Z",
     "iopub.status.idle": "2026-07-01T08:40:56.819037Z",
     "shell.execute_reply": "2026-07-01T08:40:56.818757Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W.shape: (65, 65)  -> rows = current char, cols = next char\n",
      "\n",
      "top-left corner W[:4, :6] (raw logits -- all tiny, near zero):\n",
      "[[-0.007  -0.0049 -0.0032 -0.0176  0.0021 -0.0201]\n",
      " [ 0.0076 -0.0158  0.002   0.0009  0.0064 -0.0079]\n",
      " [ 0.0056 -0.0118 -0.0047 -0.0174 -0.     -0.0217]\n",
      " [-0.0239 -0.0044  0.0122  0.0037 -0.0138 -0.0068]]\n",
      "\n",
      "after 'q', the untrained model's top-3 next characters:\n",
      "    '?'  p = 0.0158\n",
      "    'Z'  p = 0.0157\n",
      "    'w'  p = 0.0157\n",
      "a flat, no-opinion guess is 1/65 = 0.0154  <- essentially the same\n"
     ]
    }
   ],
   "source": [
    "# The entire model, made visible.\n",
    "print(\"W.shape:\", W.shape, \" -> rows = current char, cols = next char\\n\")\n",
    "\n",
    "print(\"top-left corner W[:4, :6] (raw logits -- all tiny, near zero):\")\n",
    "print(np.round(W[:4, :6], 4))\n",
    "\n",
    "# One row is the model's whole opinion about \"what follows this character\".\n",
    "# Fresh, that row is near-flat, so softmax turns it into a near-uniform guess.\n",
    "row = softmax(W[stoi[\"q\"]])\n",
    "best = np.argsort(row)[::-1][:3]\n",
    "print(\"\\nafter 'q', the untrained model's top-3 next characters:\")\n",
    "for j in best:\n",
    "    print(f\"   {itos[j]!r:>4}  p = {row[j]:.4f}\")\n",
    "print(f\"a flat, no-opinion guess is 1/65 = {1/vocab_size:.4f}  <- essentially the same\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1lookw03",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>print(\"W.shape:\", ...)</code>: confirm the table is 65&times;65. The row index is the character you are standing on now; the column index is a character that might come next.</li>\n",
    "<li><code>print(np.round(W[:4, :6], 4))</code>: peek at one small corner of W. Every number is a tiny random value near zero -- this is what \"starts with no opinions\" literally looks like.</li>\n",
    "<li><code>row = softmax(W[stoi[\"q\"]])</code>: take the row for 'q' and turn its raw scores into next-character probabilities.</li>\n",
    "<li><code>np.argsort(row)[::-1][:3]</code>: pull out the three characters the model currently rates highest after 'q'.</li>\n",
    "<li>The print shows those top-3 probabilities sitting right on top of <code>1/65 = 0.0154</code>: no real preference yet, which is exactly why the starting loss equals <code>ln(65)</code>.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd031aff",
   "metadata": {},
   "source": [
    "## The gradient, by hand\n",
    "\n",
    "We need to know which way to nudge every number in `W` to lower the loss. The combination of softmax and cross-entropy has a famously clean answer: the gradient at the logits is simply the **probabilities minus the one-hot target**.\n",
    "\n",
    "In plain terms: take the probabilities the model produced, then subtract 1 from the single position that was actually correct. Suppose the model predicted `[0.6, 0.3, 0.1]` and the true next character was at index 1. The gradient is `[0.6, 0.3 - 1, 0.1]`, which is `[0.6, -0.7, 0.1]`. A positive number means \"this logit is too high, push it down,\" and a negative number means \"push it up.\" So the rule automatically pushes the two wrong characters down and the correct one up, and the size of each push grows with how confidently wrong the model was. That is the whole learning signal.\n",
    "\n",
    "Because `logits = W[x]` simply selected row `x`, that gradient flows straight back into row `x` of `W`. The same character appears many times in a batch, so the function `np.add.at` adds up every occurrence's nudge into the right row.\n",
    "\n",
    "The cell below also runs a **gradient check**: it compares our formula against the brute-force numerical slope (nudge one number, watch how the loss moves) from notebook 01. The two agree to six decimal places, which is how you know the hand-derived gradient is correct. (The zeros are honest, and they come in whole rows: id 5 is the apostrophe and id 40 is the lowercase `b`, and neither character appears in this batch *as an input*, so `np.add.at` routes no gradient into row 5 or row 40 at all. A pair that merely never occurred, like `W[10,20]`, still gets a small positive gradient \u2014 \"push down\" \u2014 whenever its row's character shows up as an input.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b4c16dc3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:40:56.819981Z",
     "iopub.status.busy": "2026-07-01T08:40:56.819921Z",
     "iopub.status.idle": "2026-07-01T08:40:56.823121Z",
     "shell.execute_reply": "2026-07-01T08:40:56.822806Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  W[10,20]  analytic= 0.000359  numerical= 0.000359\n",
      "  W[5,5]  analytic= 0.000000  numerical= 0.000000\n",
      "  W[40,1]  analytic= 0.000000  numerical= 0.000000\n",
      "they match -> our hand-derived gradient is correct\n"
     ]
    }
   ],
   "source": [
    "def backward(x, y):\n",
    "    B = len(x)\n",
    "    p = softmax(W[x])                 # (B, vocab)\n",
    "    dlogits = p.copy()\n",
    "    dlogits[np.arange(B), y] -= 1     # probs - one_hot(target)\n",
    "    dlogits /= B                      # average over the batch\n",
    "    dW = np.zeros_like(W)\n",
    "    np.add.at(dW, x, dlogits)         # route each row's gradient back to W[x]\n",
    "    return dW\n",
    "\n",
    "# gradient check: compare our analytic dW to a numerical estimate on a few entries\n",
    "xb, yb = data[:256], data[1:257]\n",
    "dW = backward(xb, yb)\n",
    "def num_grad(i, j, h=1e-4):\n",
    "    global W\n",
    "    W[i, j] += h; lp = loss_fn(forward(xb), yb)\n",
    "    W[i, j] -= 2*h; lm = loss_fn(forward(xb), yb)\n",
    "    W[i, j] += h\n",
    "    return (lp - lm) / (2*h)\n",
    "for (i, j) in [(10, 20), (5, 5), (40, 1)]:\n",
    "    print(f\"  W[{i},{j}]  analytic={dW[i,j]: .6f}  numerical={num_grad(i,j): .6f}\")\n",
    "print(\"they match -> our hand-derived gradient is correct\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fce4f9e0",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>def backward(x, y):</code>: computes the gradient: which way to nudge every number in W to lower the loss.</li>\n",
    "<li><code>p = softmax(W[x])</code>: the model's current probabilities for this batch.</li>\n",
    "<li><code>dlogits = p.copy()</code>: start the gradient as a copy of those probabilities (<code>.copy()</code> so we don't accidentally change <code>p</code> itself).</li>\n",
    "<li><code>dlogits[np.arange(B), y] -= 1</code>: subtract 1 at each example's correct answer. This is the clean <b>probabilities minus one-hot</b> rule from the text, applied to the whole batch at once: it pushes wrong characters down and the right one up.</li>\n",
    "<li><code>dlogits /= B</code>: divide by the batch size, because the loss was an <i>average</i> over B examples.</li>\n",
    "<li><code>dW = np.zeros_like(W)</code>: an all-zeros grid the same shape as W, to collect the gradient.</li>\n",
    "<li><code>np.add.at(dW, x, dlogits)</code>: route each example's gradient back into row <code>x</code> of dW, <i>adding up</i> when the same character appears several times. (Plain <code>dW[x] += ...</code> would silently drop repeats -- this is the safe version.)</li>\n",
    "<li><code>def num_grad(i, j, h=1e-4):</code>: the brute-force check: nudge one entry of W up then down (the <code>+= h</code> ... <code>-= 2*h</code> ... <code>+= h</code> dance restores it afterward) and measure how the loss moves -- rise over run.</li>\n",
    "<li><code>for (i, j) in [(10, 20), ...]:</code>: spot-check three entries; the hand-derived gradient and the brute force agree to six decimals, so the formula is correct.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2grad01",
   "metadata": {},
   "source": [
    "### See the learning signal for a single example\n",
    "\n",
    "\"Probabilities minus the one-hot target\" is a tidy phrase. Here it is as an actual picture, for one real pair from the batch: every wrong character gets a small positive nudge (meaning \"push this logit down\"), and the single correct character gets one big negative nudge (\"push this one up\"). That whole shape is the gradient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b2grad02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:40:56.824147Z",
     "iopub.status.busy": "2026-07-01T08:40:56.824092Z",
     "iopub.status.idle": "2026-07-01T08:40:56.870012Z",
     "shell.execute_reply": "2026-07-01T08:40:56.869597Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current char 'F'  ->  true next char 'i'\n",
      "prob the model put on the correct answer : 0.0153   (we want this near 1)\n",
      "gradient at the correct column           : -0.9847   (negative -> push that logit UP)\n",
      "gradient at each of the 64 other columns : ~+0.0154    (positive -> push them DOWN)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x240 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Rebuild the gradient for ONE example and look at the signal, number by number.\n",
    "xi, yi = int(xb[0]), int(yb[0])            # current char, true next char\n",
    "probs = softmax(W[xi])                     # the model's guess for this row\n",
    "g = probs.copy(); g[yi] -= 1               # probs - one_hot(target): the whole signal\n",
    "\n",
    "print(f\"current char {itos[xi]!r}  ->  true next char {itos[yi]!r}\")\n",
    "print(f\"prob the model put on the correct answer : {probs[yi]:.4f}   (we want this near 1)\")\n",
    "print(f\"gradient at the correct column           : {g[yi]:+.4f}   (negative -> push that logit UP)\")\n",
    "other = g[np.arange(vocab_size) != yi]\n",
    "print(f\"gradient at each of the 64 other columns : ~{other.mean():+.4f}    (positive -> push them DOWN)\")\n",
    "\n",
    "plt.figure(figsize=(6, 2.4))\n",
    "colors = np.where(np.arange(vocab_size) == yi, \"#e5484d\", \"#5b5bd6\")\n",
    "plt.bar(range(vocab_size), g, color=colors)\n",
    "plt.axhline(0, color=\"k\", lw=.5)\n",
    "plt.title(f\"gradient on the logits for one '{itos[xi]}' -> '{itos[yi]}' example\")\n",
    "plt.xlabel(\"next-char id\"); plt.ylabel(\"d loss / d logit\"); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2grad03",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>xi, yi = int(xb[0]), int(yb[0])</code>: take the first pair in the batch -- one current character and the character that truly followed it.</li>\n",
    "<li><code>probs = softmax(W[xi])</code>: the untrained model's probabilities for what comes after <code>xi</code> (all near 1/65).</li>\n",
    "<li><code>g = probs.copy(); g[yi] -= 1</code>: the exact rule from the text -- start from the probabilities, then subtract 1 at the one correct answer.</li>\n",
    "<li>The prints spell the signal out: the correct column becomes a big negative number (about -0.98, \"push up hard\"), while all 64 others stay small and positive (\"push down gently\").</li>\n",
    "<li><code>plt.bar(...)</code>: draw it. The lone red bar diving toward -1 is the correct character; the flat blue line just above zero is every wrong character. Training is just doing this for a whole batch and stepping <code>W</code> the opposite way.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13441aa1",
   "metadata": {},
   "source": [
    "## The training loop\n",
    "\n",
    "Here is the loop that appears in every notebook from this point on. It is worth committing to memory, because only the model in the middle ever changes:\n",
    "\n",
    "1. **sample a batch** of `(current character, next character)` pairs -- a fresh *random* handful each step (that randomness is what puts the \"stochastic\" in **stochastic gradient descent**, the name we meet in notebook 07),\n",
    "2. **forward**: compute the logits,\n",
    "3. **loss**: measure how surprised the model was, using cross-entropy,\n",
    "4. **backward**: compute the gradient, the downhill direction for every number in `W`,\n",
    "5. **update**: step `W` a little way downhill, written `W -= lr * gradient`,\n",
    "6. repeat thousands of times.\n",
    "\n",
    "Watch the loss fall from about `4.17` (random guessing) towards about `2.45`, which is the best any one-character-of-memory model can do on this text. We will actually compute that ceiling in a moment. (The learning rate here is a large `30`, which looks surprising after notebook 01's `0.1`. It is fine because this model is so simple and its gradients are very small. The right step size is always specific to the problem; you tune it until training is both fast and stable.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4step01",
   "metadata": {},
   "source": [
    "### One full step of the loop, unrolled\n",
    "\n",
    "The loop below runs six lines thousands of times. Before trusting it, let's execute a single pass and print what each variable holds, so none of it stays abstract. Every symbol the step touches:\n",
    "\n",
    "| symbol | shape | what it holds |\n",
    "| --- | --- | --- |\n",
    "| `x` | (B,) | the current-character ids of the batch |\n",
    "| `y` | (B,) | the id that actually follows each one |\n",
    "| `logits = W[x]` | (B, 65) | a raw score for every possible next char |\n",
    "| `dW` | (65, 65) | how to nudge every weight to lower the loss |\n",
    "\n",
    "(B is the batch size, 1024 here -- the same batch the loop below draws.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d4step02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:40:56.871063Z",
     "iopub.status.busy": "2026-07-01T08:40:56.871009Z",
     "iopub.status.idle": "2026-07-01T08:40:56.874798Z",
     "shell.execute_reply": "2026-07-01T08:40:56.874429Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 1  a batch of 1024 (current -> next) pairs; the first 6:\n",
      "          id 52  'n'   ->   id 57  's'\n",
      "          id 51  'm'   ->   id 47  'i'\n",
      "          id 46  'h'   ->   id 43  'e'\n",
      "          id 58  't'   ->   id 46  'h'\n",
      "          id 53  'o'   ->   id 59  'u'\n",
      "          id 51  'm'   ->   id  6  ','\n",
      "\n",
      "step 2  forward : logits.shape = (1024, 65)  (1024 rows, a 65-long score vector each)\n",
      "step 3  loss    : 4.1737 nats   (near ln 65 = 4.17 -- the model is still untrained)\n",
      "step 4  backward: dW.shape = (65, 65); 56 of 65 rows are nonzero\n",
      "                  -> a character only gets a nudge if it appeared in the batch\n",
      "step 5  update  : W -= lr * dW.  dW[52,57] = -0.00019 for the seen 'n'->'s' pair,\n",
      "                  so W[52,57] steps +0.0103 -> +0.0159   (lr=30)\n",
      "step 6  repeat this thousands of times -- that is the whole cell below.\n"
     ]
    }
   ],
   "source": [
    "# One real pass of the loop, narrated. We draw a batch the same way the loop does\n",
    "# (a private RNG, so the seeded loop below still reproduces its numbers), then\n",
    "# read off what each step produces.\n",
    "rng = np.random.default_rng(0)\n",
    "B = 1024\n",
    "ix = rng.integers(0, len(data) - 1, size=B)\n",
    "xb1, yb1 = data[ix], data[ix + 1]              # step 1: B (current -> next) pairs\n",
    "\n",
    "print(f\"step 1  a batch of {B} (current -> next) pairs; the first 6:\")\n",
    "for cx, cy in zip(xb1[:6], yb1[:6]):\n",
    "    print(f\"          id {cx:>2} {itos[cx]!r:>4}   ->   id {cy:>2} {itos[cy]!r:>4}\")\n",
    "\n",
    "logits = forward(xb1)                          # step 2: forward\n",
    "L = loss_fn(logits, yb1)                       # step 3: loss\n",
    "dW = backward(xb1, yb1)                         # step 4: backward\n",
    "rows_touched = int((dW != 0).any(axis=1).sum())\n",
    "print(f\"\\nstep 2  forward : logits.shape = {logits.shape}  ({B} rows, a 65-long score vector each)\")\n",
    "print(f\"step 3  loss    : {L:.4f} nats   (near ln 65 = 4.17 -- the model is still untrained)\")\n",
    "print(f\"step 4  backward: dW.shape = {dW.shape}; {rows_touched} of 65 rows are nonzero\")\n",
    "print(f\"                  -> a character only gets a nudge if it appeared in the batch\")\n",
    "\n",
    "i, jt = int(xb1[0]), int(yb1[0])               # step 5: the update rule, on one weight\n",
    "print(f\"step 5  update  : W -= lr * dW.  dW[{i},{jt}] = {dW[i, jt]:+.5f} for the seen \"\n",
    "      f\"'{itos[i]}'->'{itos[jt]}' pair,\")\n",
    "print(f\"                  so W[{i},{jt}] steps {W[i, jt]:+.4f} -> {W[i, jt] - 30.0 * dW[i, jt]:+.4f}   (lr=30)\")\n",
    "print(\"step 6  repeat this thousands of times -- that is the whole cell below.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4step03",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>rng = np.random.default_rng(0); ix = rng.integers(...)</code>: draw 1024 random positions, exactly as the training loop does (a private RNG so the seeded loop below still reproduces its numbers).</li>\n",
    "<li><code>xb1, yb1 = data[ix], data[ix + 1]</code>: turn those positions into (current char, next char) pairs -- the first six are printed so you see what feeds the step.</li>\n",
    "<li><code>forward / loss_fn / backward</code>: run the three core functions once and report the shape or value each produces -- a (1024, 65) grid of logits, one loss number, a (65, 65) gradient.</li>\n",
    "<li><code>rows_touched</code>: counts the nonzero rows of <code>dW</code>. A character only earns a gradient if it appeared in the batch; with 1024 samples that is nearly all of them.</li>\n",
    "<li>The step-5 line shows the real update on one weight -- the gradient, and where <code>W -= lr * dW</code> moves it -- and step 6 is just \"do it again,\" which is the loop in the next cell.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "230f4245",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:40:56.875743Z",
     "iopub.status.busy": "2026-07-01T08:40:56.875682Z",
     "iopub.status.idle": "2026-07-01T08:41:01.657320Z",
     "shell.execute_reply": "2026-07-01T08:41:01.656928Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final train loss (avg of last 200 steps): 2.4613\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "W = np.random.randn(vocab_size, vocab_size) * 0.01   # fresh start\n",
    "lr, steps, batch_size = 30.0, 6000, 1024\n",
    "losses = []\n",
    "for step in range(steps):\n",
    "    ix = np.random.randint(0, len(data) - 1, size=batch_size)\n",
    "    x, y = data[ix], data[ix + 1]\n",
    "    logits = forward(x)\n",
    "    losses.append(loss_fn(logits, y))\n",
    "    W -= lr * backward(x, y)\n",
    "\n",
    "# one batch is a noisy reading (easy and hard stretches of text exist),\n",
    "# so report an average over the last 200 steps\n",
    "print(\"final train loss (avg of last 200 steps):\", round(float(np.mean(losses[-200:])), 4))\n",
    "\n",
    "plt.figure(figsize=(6, 3))\n",
    "plt.plot(losses); plt.title(\"bigram training loss\"); plt.xlabel(\"step\"); plt.ylabel(\"loss\"); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e73ffe2",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>W = np.random.randn(...) * 0.01</code>: a fresh random start, so training begins from scratch.</li>\n",
    "<li><code>lr, steps, batch_size = 30.0, 6000, 1024</code>: three settings on one line: step size, number of updates, examples per update.</li>\n",
    "<li><code>for step in range(steps):</code>: repeat the update 6000 times.</li>\n",
    "<li><code>ix = np.random.randint(0, len(data) - 1, size=1024)</code>: 1024 random positions in the book.</li>\n",
    "<li><code>x, y = data[ix], data[ix + 1]</code>: the characters at those positions and the characters right after: 1024 (current &rarr; next) pairs.</li>\n",
    "<li><code>losses.append(loss_fn(logits, y))</code>: record the loss each step so we can plot the learning curve.</li>\n",
    "<li><code>W -= lr * backward(x, y)</code>: the whole learning rule in one line: step the table downhill along its gradient.</li>\n",
    "<li><code>np.mean(losses[-200:])</code>: average of the <i>last</i> 200 entries (negative indexing counts from the end) -- a steadier reading than one noisy step.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3learn01",
   "metadata": {},
   "source": [
    "### What did `W` actually learn?\n",
    "\n",
    "Fresh, `W` was flat noise. After 6000 steps it has opinions -- so let's look at the whole table again, this time as a heatmap. Each row is a current character, each column a possible next character, and brighter means higher probability. Every bright cell is a real regularity the model dug out of Shakespeare on its own."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c3learn02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:41:01.658510Z",
     "iopub.status.busy": "2026-07-01T08:41:01.658448Z",
     "iopub.status.idle": "2026-07-01T08:41:01.772831Z",
     "shell.execute_reply": "2026-07-01T08:41:01.772542Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAIiCAYAAAAHCPaPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfXtJREFUeJzt3QeYE1XXB/CTbGFZll2WXqQLKIiiFKUjoBRRAUURRVBAEFEREXwFpPsClg+wURSxoIiADRWUJqBIE2nSe5HONpYtSeZ7zuXNmmzmhp3JJJkk/5/PyO7cTMkkmzm55VyLoigKAQAAAECBWQv+UAAAAABAAAUAAACgA2qgAAAAADRCAAUAAACgEQIoAAAAAI0QQAEAAABohAAKAAAAQCMEUAAAAAAaIYACAAAA0AgBFOhWpUoV6tSpkymvoMVioUGDBlEomzt3rngeR44cCfix+Zh8bD6Hgpzj5s2br7nPVq1aiSWcFPQ6hcvfe+/evYN9GgCmgQAKTOPUqVM0ZswY+uuvvwr0+N9//108PiUlhYLltddeo2+++SZoxwcAgOBAAAWmCqDGjh2rKYDix4drANWzZ0+6cuUKVa5cmcLBzz//LBYAgHCAAAogQC5fvqzp8VFRURQXFyeaiMJBbGysWIySmZlJkSorK4scDkewTwMgoiGAinDbt28XN+jvvvsub92WLVvEuttuu83tsR06dKDbb7/dYx/r1q2jRo0aiZt9tWrV6JNPPnErv3jxIg0dOpTq1q1LCQkJlJiYKPa1bdu2vMesXr2aGjZsKH5+4oknxPG99S3hpruXXnpJ/Fy1atW8x+fvL8S1QzfddBMVKlSI6tSpQ0uXLvXY18mTJ+nJJ5+kMmXK5D1uzpw517x2fDwOij7++OO84zv7iPD58e9///039ejRg5KTk6lZs2Z515wfx9eKr1nZsmXF8S9cuHDNPlDOfmfXuuaMa+YGDx5MFStWFM/r+uuvp8mTJ3vcePlxfD5JSUlUrFgx6tWrl+ZaPQ5m+vfvTyVKlBCv7+OPP06XLl26Zh+oo0eP0n333UdFihSh0qVL0wsvvEDLli0Tz5vfE67b8uvI780WLVpQfHw8vfLKK6Ls22+/pXvuuYfKly8vnmf16tVp/PjxZLfbPY7P++Dr37JlS7EPviYLFy4U5b/++qt4fxcuXJhq1apFy5cvJ7327NlDDz74IBUvXly8Rg0aNHD7Gyvo3wXj68DXY/78+TRy5EiqUKGCOPe0tDTxuvG2/B7u3Lmz+LlUqVJiv/mfP7/uU6dOFe9vPid+v/Nrlv91UhSFJkyYQNddd504zp133km7du3SfS0AwlV0sE8AgotvKHzTXLNmjbiRsbVr15LVahUf5PwhzR/s/OHLTWZPPfWU2/YHDhwQN4o+ffqIGy8HHvyhXr9+ffFBzQ4dOiQCmW7duolg58yZMzRz5kxxE+MAg298N954I40bN45effVVcYzmzZuLbZs0aaJ63l27dqV9+/bRF198Qf/3f/9HJUuWFOv55uHEQcbixYtp4MCBVLRoUZo+fTo98MADdOzYMXGjZ3wud9xxR16nc97+p59+Es+HnzsHIDKffvop9e3bVwQyzuvCN29X/Jxr1Kghmvr4xsR++eUXcU04UOTgiW9Os2bNEv/+8ccf16xxKsg154CGry/fWPkmWalSJfH6/ec//6F//vlH3EgZn9P9998vrtWAAQPE6/D111+L/WrB147fRxw47t27l95//30RHDlv/mo4+GzdurU4n+eff15ci88//5xWrVql+ngOMDnA6N69Oz322GMiAHAGmhw4DBkyRPy7cuVK8T7i1+/111932wcHCxyA8j74teHz5J/nzZsnXmu+Bhzw8nZ8jY8fPy7eO1rw69i0aVMR6Lz88ssiOFywYIEIcBYtWkRdunQp8N+FKw4KuQaPg6Ps7Oy82jwOlNq1ayeCvzfeeEMEfm+++aZ4Lz799NN52/P7gK8Vv++ee+45Onz4ML3zzju0detW+u233ygmJkY8jq8dB1AdO3YUy59//kl333035eTkaLoOAGFPgYh3zz33KI0aNcq7Dl27dhVLVFSU8tNPP4l1f/75J9/9lW+//TbvcZUrVxbr1qxZk7fu7NmzSqFChZQXX3wxb11WVpZit9vdrvPhw4fF48aNG5e3btOmTWJ/H330UYFek9dff108nveVH6+PjY1VDhw4kLdu27ZtYv3bb7+dt65Pnz5KuXLllPPnz7tt3717dyUpKUnJzMz0eg5FihRRevXq5bF+9OjR4liPPPKIR5naPr/44guPa8nXIf/zK+g1Hz9+vDi3ffv2uR3n5ZdfFq/rsWPHxO/ffPON2N+UKVPyHmOz2ZTmzZsX6LVwnmP9+vWVnJycvPW8v/zvl5YtW4rF6c033xSP4XNwunLlinLDDTeI9atWrXLbltfNmDGjQNezf//+Snx8vHjv5d/H559/nrduz549Yp3ValX++OOPvPXLli0r0PPn1yb/49q0aaPUrVvX7dgOh0Np0qSJUqNGDc1/F3wd+BjVqlXzeK783uMy18ezW2+9VbwmTmvXrhWPmzdvntvjli5d6rae30v8d8OfCXzOTq+88op4nNp7HSBSoQkPRG0Pf8t09tHh2gj+5lmvXj1RG8X4X65JcDZDOdWuXTuvtohxDQ43f/C3ayduVuEaLee3Za5J4JoCfhwf11/atm3rViN08803i9o057lxnMU1Avfee6/4+fz583kLf6NPTU31+fy4RiM/biJy7cvCx+NaMFaQ4xXkmn/11VfiMdx06Pq8+Jrwa8A1juzHH3+k6Ohot5oK7nv17LPPanqeXAPnrMFgvD/eL+9fhptTuZbGWfPJuGmpX79+qo/n9xHXnni7nunp6eJ58nPnWjhuSnPF7zuucXLi68Y1Z1zz5to87fzZ9ZoWBDfLcQ3YQw89lHcuvPB7nt9T+/fvF7WCev4uuFbQ9bl6e5/x88//fuAm2rvuusvt/cC1lnxMZ60f115xTRO//q41h95qYgEiFZrwQHzY2mw2Wr9+vegvc/bsWbGOmyJcAyi+cXOfDlfcNJQf37Rd+1Vw89+0adPovffeE80Grn0znE1p/nCtczt37pzo68PNZ7yo4WvhC26aUbvJ8uhB7tOSf/8ctF1LQa4536i5r49rk6Yr53G5ma1cuXLiJuqKb+JacDOlK94f79dbDis+Nge4+Zv4uF+SGg621Dqh8/uU+wZx4MLNdt6uJ/fryX88Diz4fZ9/HcvfP+hauHmVg/FRo0aJRXbt+blo/btQey85g878r7Pa+4GvBfczk52T8zVRez15/7xPAPgXAigQHVz5Q5hrJfjmzB+yNWvWFEEUf7hzfwsOoJx9N1xxbYUaZ38fxv1/+GbCHaW5HwcHYfzNm7/V+nMk0bXOzXls7k8j6/PDtVa+UKsx4NoJ7o/EneC5lo+DDT6X9u3bF+h6FOSa8364tmHYsGGqj+XXN9SoXUsOgLnPENcsch86Dsj4vcw1OMOHD/e4nrJrV5BrWhDO43E/Ja5xUuMMELX+Xchqn2Tnnv+8+O+a+3qpkQXaACCHAArEt3ruCM1BEgdQzuYh/peDJ/7Q5Q6uPPpJDx7lxCN5PvzwQ4+bn7PzN9M6XN/X4f180+AOwvzNn5u29NB6DlwrsGLFClEDxZ11XWsIjMSBREZGxjWfF+eY4vPhx7rWQnFHcC34/Pk1duL9cedwbgr2dmzuLM1Biut15FqcguJO6tz0xYMFXN+fXKMTDDwiknFz5rWufUH/Lox6P3DzHHdulwVizJlzjF9P53Nx1tZqrY0DCHfoAwV5wdKGDRtEXwhnAMUf4tw3hIe+Ox+jB39Dzv9NnvtkOPuCOPFoJVbQIfRaH692Xjwqj/tB7dy506OcbxoFOQctx3fWFuS/Hs5RcUbhWi5ukuWUAPnx+XKTLeMAh3/m0WhOHFC+/fbbmo7HTaC5ubl5v/P+eL88ak6Ga2j4PeA6vJ/7hM2ePdun68l9eLjmNBi4lofTJfBoOg4gvb2nCvp3YdT7gV9XrunKj18n53uYgz4O/vj1dz03o9+fAOEANVCQFxxNnDhRDNt2DZT4Wz3fDDj/EPcf0YOHjXPzCncA5rQEO3bsELVart9wnd+SuUPvjBkzRM0QByfcmVfW94M7wLIRI0aIjsH8wc8dwp2BVUFMmjRJBI18HO68zP28uI8SNwHxN3b+2Rs+B37cW2+9JYad87mq5cpy4qYmvqZTpkwRAQf3heHs3EbXmHDzIAcmfO2dKQ54kABfe6754L5JHCDz9eJaCR5uz+v4+XNtTkH6YrnioKVNmzbiRs21VxzA8IAD1w7i+fGweh5G/8gjj4g0Btxnit8X3ARX0No9fj9x3xxuguWh+bwNp5fQ2vRmpHfffVc8d87vxO8pfp9zDS4HtCdOnMjL81TQvwsjcDMnX+///ve/ItM/pyXgvxeuaeKgjfticdoGZw4pfhyfHwfYnOaAU3sYXSsGEPKCPQwQzCEtLU0Mby9atKgYxu702WefieHLPXv29NiGh9TzcOf88g9X5+HaPMSe0wUULlxYadq0qbJ+/XqPxzEe9l67dm0lOjq6QMPIebh+hQoVxDB01yH//PMzzzyjes75h2KfOXNGPLZixYpKTEyMUrZsWTEUfdasWcq18DD4Fi1aiOflOszbmcbg3LlzHtucOHFC6dKli1KsWDGRKqFbt27KqVOnxON5u2ulMSjINWfp6enKf/7zH+X6668XQ9NLliwphtK/8cYbbikHLly4IF7fxMREcT7889atWzWlMfj111+Vp556SklOTlYSEhKURx99VOz3Wud46NAh8Xz4+pUqVUq8TxYtWiT26ZpWgLerU6eO6jn89ttvyh133CH2Ub58eWXYsGF5aQjyp0JQ24fsmsreQ9dKY8AOHjyoPP744+K9xO8pfo926tRJWbhwoea/C2cag6+++srj+Px+43QV+Tnff/nxe5rTG/Dx+G+d0y3w9eL3nxOnVhg7dmzeebVq1UrZuXOn6t8OQCSz8P+CHcQBALg2F3FGcq6t4Ro6AAAzQgAFAEHDkyXnz4t16623iv46nGkeAMCs0AcKAIKGp+ThkZ+czoH7XX322Wci+aVsuD0AgFkggAKAoOGReB988IEImLjWiTuxc4LRhx9+GK8KAJgamvAAAAAANEIeKAAAAACNEEABAAAAREIfKJ7X6dSpUyLZoq/TeQAAAAQaZxBKT08XCXh5DkR/4xGunPDWX9OBxf0vAW4kCckAioOn/LOnAwAAhBqe/UHvLA9agqeqVSvQ6dPeZ1bQq2zZsmI2hUgLokIygOKaJ9agaF+KtsR6lP+RNiNAZ+Kt9it085MmFK4uLbuSfV51vUP5dx60/BTFc2b5f6lvZ7EU0rU/q9Xz/eAUX0h9xvmMKwe9nJ98fxaL+p+P1RIj3cbuyNa8P28U5bKXUvVvtTHRxTVfI5Z6eTdpVSSuirTsctZhHdc9J+L+HsFJb2uDntc+EO8lkSw+737mT1zzxMHTkaMLKDEx3tB9p6VlUpXKD4ljIIAyoezsbLE4cbUn4+ApWvVGG6hmvfBsPrRYoryUqd+ULV6vhbxMUdTLvDfNysu8bSd/Xnr3Jzt3q6H780Z2/f63Rx3nF2Xo+13v/mTXQs/zhXBhCcNjKQHthpKYEEeJCf8mrjWEw9sX5PAWEp3IeWLLpKSkvAXNdwAAADqCHX8sESokAqj//Oc/Ikuxc+E2YwAAAIBgCYk+UIUKFRILAAAA6OSPGiNH5NZAhUQAJXO1s3gw+z2EZ8fU9Mz9Qe906XBk6jgHIrs9S1p2OcumeX+KkqO5zEH6zl0x/O2k/sGWk3tWuoW3Mj28d9DXd91l4mLLScscivprb7Nn6OrU77Crv8bWKHkHXYdD/pyKFq4sLcvMPqO63mZPkW5DJO97ZrWq94EpWlg+sjn9ynHNAze8PV+Hw8t1l9yWEuKrSrcpV+gWadn+S99IyxSya34vZeWckpZFRSWqrrfb06TbQOgK6QAKAAAANHxLM/qbmhKeFQlh0wcKAAAAwExCMo1BWhqqQwEAADRxKH7oA6VE7IsQEjVQSGMAAAAAZhISARTSGAAAAPgIeaAirwkPaQwAAAB8hDQGkRdAyRx+4GEqGuM5hHb879VUHz/t2DhDj29RmYfPl2HYoc387eB6UyOELvO/JkbyNrw8UPQOV0/L3Gv0mWhOIaBnrsOr+yNDKWTTnF5FX+oV499LSFcQWUI6gAIAAIACQg1U5PWBAgAAADATUwVQDz74oOp6TmHAqQtcFwAAANBA8cNEwkrkTuViqgBKBmkMAAAAwExCIoBCGgMAAADfWBSHX5ZIZapO5F26dFFdjzQGAAAAYCamCqCWLFlCjz76aIEfX3XRIrKQpcCPl83y7Q9ej2XxUvEXwdF8yJG9jngNr32NwvU6hcLztUg+mxRb6D6vQJ6fQcdSRJqRAKe7wSi88A2gvvjii2CfAgAAQBjPhWdwfjhHZOWbC7k+UAAAAABmEvQA6vz586KTOKcw+Prrr4N9OgAAAOEJc+GFVxPeN998Qy1btqQ6depQ586dpXmgeHFCHigAAACI6BqoTp060fz58+nDDz+kP/74Q/UxyAMFAADgI9RAhVcAVbZsWZo7dy717NmTJk6cqPoY5IECAAAAMwl6E96KFSto5cqVtH79emrVqpXGPFBWIovFmGGreoam6h0ea4Zhv4EaGq13eHQoXKNADY8OhWsho/fcA3UtjB7+Hgqvlbe/x1B9XoE8P6PuL0oQRq/xMY2+VkrkjsILegDVpk0bsXz22Wf02GOPBft0AAAAAMwfQDkheAIAAPAjJNIMrwBq0KBB4t9mzZpR9+7dg306AAAA4QmJNMMrgDp37hx99NFHFB8fL30M0hgAAACAmQR1FN6OHTuoQoUK9Pzzz1N6ejpNmjSJHFzFmA/SGAAAAPgIaQzCpwZq+fLl1LVrV6pUqRL17duXKlasSFarVTWNwZAhQ9wSafJjAQAAACIugHr44Ydp1KhRVKNGDSpfvjwdPnyYMjIyKCEhoYBpDAAAAKBAOIWBSiuPTxSTp7gI1wCKgybOQG60+Dj12qnLWYflG0VuKovg5ZYR2xl9IiHMBNfCapX3RXQ4MsPvWng5Ttfi/5GWfZf6vup6mz2FzK5Ywk2q61MydpI5qOT2I6KxNUZJt3jr1FfSstTLuynoFJP+wUNodyIHAAAA/7M4HGIxep+RKuhTuQAAAACEGlPVQPGceFWqVPGY0gVpDAAAAIyYysXgpkMlcpsiTVUDFRsbS9HRnjEd0hgAAAD4CGkMwjeA6tGjh8hIrpbGIDU1NW85fvx4UM4PAAAAwHRNeDJIYwAAAOAjzIUXeQGUTNukpyna4pkfasmY86qPjx7sJY1BQEV5KbMH8DwAgpiqwOQWX/wvhSPzpCuQUe9TM3r/uICfCUDYBlAAAABQQJhMOHz7QAEAAACEgpCogUIaAwAAAB+hD1Tk1UAhjQEAAACYSUgEUEhjAAAAYEQfKIfBixKxL4upAqgzZ86oTi7MaQwSExPdFgAAANCRidzoJUKZqg/U1q1bqWrVqgV/vGMtWS2eTyF68CYys2ZJz0jL1qVOD+i5RBb1Wd4xK3p4sFoTpGVR1jjV9TZ7hnSbwrFlpGWZ2SdU10dHJ0m3sdvS5OcXLf9SaLOlyvao471OFBVVVHV9QlwF6TbpV45KyxyObNX1VmthL9tkaE7zUjS+mnSLKzkXpGU220XN10l2jZjdLn8d8RkTWUwVQLVv3z7YpwAAABCe0Ik8fJvwAAAAAEKBqWqgZJDGAAAAwEfcX8noTt9K5PaBCokaKKQxAAAAADMxTQD1ySef0ODBg+nkyZMeZUhjAAAA4CPDUxg4ri4RyjRNeI8//rhY1HAaA14AAAAAzMA0AZQeBxffS4lFPIcnX9dRffjsqZQ1Bp+B+nDbaw0xRqqCYInctvpI4G1ovPdh8+oys+VD9/UNmTd+Oz3vddkw/NTL3obna6fnmnv77EzP3E/GU3SkKtC+P9PAKDxDhXQABQAAAFoykRsc5DlMHjRGQh8oAAAAgFAREjVQSGMAAADgI8VxdTGSErmdyEOiBgppDAAAAMBMQiKAQhoDAAAAg/pAGb1EKFMFUOvXr6f33nvPYz2nMEhMTHRbAAAAAILFVH2gGjduLJaCKnbXBNXZr9+p84rq4wel/EaB4y3FAQAARDauuQlw/yGkMQjfGigAAACAUGCKGqjdu3fTtGnT6Pz589SmTRt6+umng31KAAAA4QV5oMIvgLrxxhtpxowZ5HA4xHQu+QMopDEAAAAwIoAyuNnQgU7kQffdd9/RPffcQx07dvQoQxoDAAAAMBPT9IG677776KeffqJ58+Z5lCGNAQAAgI+QxiD8mvBWr15NixcvFk11ajVQnMaAFwAAAAAzMEUA1apVK7FolfLVYEqM9wysbnrsgKZZvgEAAAIrGH2H/DCVC2EqFwAAAAAIpRooAAAA8DOkMQjPTuRs37599Nprr3ms575RaWlpbgsAAABAsJgqgKpZsya98ornNCxIYwAAAOAjjMIL3wBKBmkMAAAAwExMFUDt3buXJkzgCYLdcQqDxMREtwUAAAB0TCZs9BKhTNWJvFatWjRy5MgCP37NlFwqEu0ZA06oXln18V03+3R6AAAAoQudyMO3BgoAAAAgFJiqBgoAAAD8BDVQkRdAcRoDXpyQxgAAAACCyVRNeCdOnFDNA4U0BgAAAD5CJ/LwDaCuu+461TxQSGMAAAAAZhISTXicxoAXAAAA0ElRri5GUoIxKbI5mKoG6syZM/Thhx8W+PGN7/yHmrU95bEsOBqlugAAAEDwvfvuu1SlShWKi4uj22+/nTZu3Oj18VOnThWpjgoXLkwVK1akF154gbKysiiYTFUDtXXrVqpatWqwTwMAACD8mGQU3pdffklDhgyhGTNmiOCJg6N27dqJZNqlS5f2ePznn39OL7/8Ms2ZM4eaNGki5s3t3bs3WSwWeuuttyhYTBVAtW/fPtinAAAAEJ5MEkC99dZb1K9fP3riiSfE7xxI/fDDDyJA4kApv99//52aNm1KPXr0EL9zzdUjjzxCGzZsIIr0JryffvqJnnvuORGBXrx4MdinAwAAABqkpaW5La6ph1zl5OTQli1bqG3btnnrrFar+H39+vWq23CtE2/jbOY7dOgQ/fjjj9SxY8egvkamqIHq0KGDWAYMGECpqalUvHhxt3LkgQIAAPCR4oe565Sr++N+Sa5Gjx5NY8aM8Xj4+fPnyW63U5kyZdzW8+979uxRPQTXPPF2zZo1I0VRyGaziXhBbdR+xNVAMe483rp1a9U+UMgDBQAAYF7Hjx8XFSDOhdMPGWX16tUiR+R7771Hf/75Jy1evFg0+Y0fP54o0mugGEekXbp0US3jF4I7nDlx9WD+aBcAAACC0wcqMTFRLNdSsmRJioqKEqPuXfHvZcuWVd1m1KhR1LNnT+rbt6/4vW7dunT58mV66qmnaMSIEaIJMKJroHbu3Em5ubmqZZwDyvniFPRFAgAAAHOJjY2l+vXr04oVK/LWORwO8Xvjxo1Vt8nMzPQIkjgIY9ykR5FeAzV9+nTN25Sa8hURWTzWx0SXpEhSNL6GtCw9c7+hx4qKUg9e7fY06TYWS6y0TFFydJyF52vuskcKFIslTrJe/mdVtLC85jT18m7V9VZrvHQbhyNTWlYlWb2D5dGU5bq+U0VHJUjLcm3nvewTrv2+pYC9p2XvW0WR59TpUWqEtOzzcxNlR9L1nCyS21KhWM/h7U5ZOf+QPoqx5y75rNP3OecH3F3J8Boo0oxblHr16kUNGjSgRo0aiTQGXKPkHJX3+OOPU4UKFUT3HXbvvfeKkXu33nqrSHtw4MABUSvF652BVEQHUAAAABD+Hn74YTp37hy9+uqrdPr0aapXrx4tXbo0r2P5sWPH3GqcRo4cKXI+8b8nT56kUqVKieBp4kRZ8B5BARR3CuP+T9wDn7OMAgAAQHjmgWKDBg0Si6zTuKvo6Ggxqo8XMzFFH6hPPvmExo0bR199xU1ynjiNQf4cEwAAAFBwikPxyxKpgh5A8Vw2nN/h0Ucfpe+//171MUhjAAAAAGYS9ABq0aJFog2Uq/J4fhte1NIYuOaX4HwTAAAAoAGPWPPHEqGizRBAcc0T933avn27SKg5efJkjzQGvAAAAACYQdADKM4o6nTzzTeLxVeRNqTa6FQF3tJA6Lm23obwlklSz/txJnW9tz2SHtFRxVTX2+wpuvYnG/bt7QuZLFUBi41RH6adk3tW+8kR0WX7OYOHVMvTGBhNz3BwWYqNa6XZ0KNUYkPV9efSNhn+vpWlsfCWwsIbRVHPt+eNPFUBUWJ8LdX1aZl7SRdJGpCsnFO6dndPsWHSsh9Sphj6WhWKKWnouYdzJ/JwEPQmPAAAAIBQE/QaqLlz59LChQupUqVKFBMTQ9OmTQv2KQEAAIQf1ECFXw0Uz6rMkwReuHBBtRxpDAAAAMBMTBFAzZ49W0wSmJycrFqONAYAAAAG1UAZvUQoUwRQ/fr1ow8++IDKly9P27Zt8yhHGgMAAAAfIYAKrz5QbMaMGbRs2TLRhPfss896lCONAQAAAJhJ0AOo3r17iwXMI75QKWlZqsEpIqrRbarrz5C3NAZyNZK7SstOZ+9QXZ+emaI5tQBzOHIMTYtgMbhC2PuQeu0UPdOu6z2WjlQLsdHyNAZXDE5jYPS1tXj9KDb2fZEYf72haQcKxxRX35+uvcnTg+j1Q8rrFCimSVcgoSjGT72iRHAiTVM04QEAAACEkqDXQOXk5NCLL74oolj+uUePHtSqVatgnxYAAEB4QRqD8AqgeARex44dqUOHDuJ3DqLU0hjw4pSWZmx1PAAAAEBINeHt2rWLGjb8d1qE2FjPKRyQxgAAAMBHGIUXXgFUnTp1aMuWLXm/q9VAIY0BAAAAmEm0GXJADRkyhL7//nuy2+3UvXt3atmypdtjkMYAAADAR+gDFV4BFDfZvfPOO4bus26xnqrrd6R8SuHoumJtpGUnUlZo3l/a5f0UKBvSPzJ0f/svLdY8a7w3OblnfTwjLccyNkWE0WoWbSct+/vSF6rri8bXkG6Tnil/nyUUrq66PuPKQek2V7L/oUCJjipmaAoLhWzSstioBNX12Y4MXcfSm65A5kruRUP3RxQlWW/Xt7eootIyu8HpLUyPUw4YnXZAQRoDAAAAAAiVGqi5c+fSwoULqXr16pSenk4jR46katWqBfu0AAAAworiuLoYvc9IFfQAig0YMIA6deokpnJ54YUX6JNPPnErRxoDAAAAMJOgj8JzVaJECcrNzfVYjzQGAAAAPkIag/ANoLgGSi0PFNIYAAAAgJmYoglvxowZ9Msvv4g+UGPGjPEoRxoDAAAAHyGNQXgFUL179xaLkfZnah+6H8pSc44Zuj9vQ6p53njZVjJWa4J8b5bAVYIaPXy7SFxV1fWXs+SvR/tiQ6RlyzM+VF1vs+kbJl6h2J2q63O8DH+3eKmUlqUq8MZbqgJvLmed1LGVsb1Zvb1v9aYr0CM79zQFm8Xi2TLgr78ro19Hb6kKLJJboL7PwKtbQuQIegAFAAAA/odReGEYQHEqgwULFlClSpWoQoUKNGrUqGCfEgAAQHjhpJfcjGf0PiOUKQIoNnDgQJHKQA3SGAAAAICZmGYU3nvvvSfyQb399tseZUhjAAAAYED3Mn8sESokaqA4jQFPOOyUlpZGFStWDODZAQAAAJgwgOIaqCVLllBycrKocXKFNAYAAAC+URyKWIykGN2nKoRYFCX0eoBxDVRSUtL/WiA9h5QWL1pPdbuL6X9ReAq/YbXehpA7dM5Cb7HEqa5XlCxT7E/2nPU+3+jo4oamRTC7uNjy0rKsnFMBGdavKDlktBuSH1Jdv+fSAp17jJKst+va28Sar6quH7FvnK79JSfcrLr+UsZ2Ci/82eyg1NRUSkxMDMg989zQhymxUKyx+87OoVJvfBmQ52E2pqmBAgAAAD/yR58lB0Usq1nSGHTs2FF0Iv/mm2+CfToAAAAAoVEDhTQGAAAAfm41NLpXh0IRyxQ1UK5pDLZt2+ZRhjQGAAAAxnQiN3qJVFYz1UDxpMK33HKLahoD7qDmXI4fPx6UcwQAAAAwVROeN0hjAAAA4CN0Ig+/AKp3796G7q9EdDXV9RcpXNMYGFuFGhtTWlrmUGyGDo2PiS6puj7Xdt7wc8/JvUBGKlXUs7aUnU3boGt/Vku0oYNcYqOKqq632zOl23hPwWDudBnZufreM3pERyUa+r71Zn/aUkP3Z7HEqK5XFH1pDFacSScjZWafNXR/AGEdQAEAAIB/KY6ri9H7jFRBDaBycnJo6NCh5HA4iPN51q9fn5588slgnhIAAACAuQOo2bNnU4cOHcTCbDb15qHs7GyxuGZVBQAAAA3QByp8RuHt2rWLGjZsKGqgBg8eTIMGDVJ9HNIYAAAAgJkENYCqU6cObdq0iaxWK02dOpXOn1fvgIk0BgAAAMb0gTJ6iVRBbcLr16+f6AO1ZMkSio6OpgYNGqg+DmkMAAAADJm/2FgKRaygBlCxsbE0ffp0w/e7/9JiiiTR0cWlZXrSC9xY5GqfNDXbUj4mIyUVrqS6/ny6vuHgObnyIdBxseVV12flnNJ1LH3pCqKkJYrBn2yZ2UcN3Z/FUkhn+oPAKJ/UVFp2MmWVocdqX7SP6vrvL00mo8VGq6dMuGLX1xfU6NdqF/1h6P6yc08buj+zp98A/zt8+DCtXbuWjh49SpmZmVSqVCm69dZbqXHjxhQXF6d7v0hjAAAAEAEU5epi9D7Nat68eTRt2jTavHkzlSlThsqXL0+FCxemixcv0sGDB0Xw9Oijj9Lw4cOpcuXKmvePAAoAAADCyq233ipauThR96JFi6hixYpu5Tyyf/369TR//nzRfYjn4+3WrVtoBVBz586lkiVLUqdOnWjPnj3iyYwZM8btMUhjAAAA4JtISqQ5adIkateunbSc+1a3atVKLBMnTqQjR46E7mTC3iCNAQAAABSUM3ji/JKffPIJnTlzRvrYEiVKiETeIRlAcdXZgAEDPGqenJDGAAAAwKBEmkYvJsYj/Dm+yMoyfqBL0Jvw2MCBA92a8PJDGgMAAADQo1GjRvTXX3/p6ihu+gAKAAAA/CuS+kDlr6QZMmQIHT9+XDTVFSlSxK385ptvJj0sCs/iG2J4LrykpCQiilHN8fFi5RGq2715dFwA8y+letnSbuh5WK0J0jKHI0Pz/iyWOM05ZLxfi0vyY0nyIiler5G+t2x0VDHV9TZ7iq79yXM6yc+9bFIzaZnVot6ifiplDRmZ/yYqqqh0C7uX3EKy63d1O/X3mUI2zefn3FJ9C/l3Pu/HCgyrNV5a5nBkUqgy+jNGD2+fS97akRQlh8yc1TI1NZUSE9VzfRl9zzzZ6yFKjI01dt85OVTh4wUBeR568Wwn+VksFuLwh/+12/Xdk1EDBQAAEAEiLQ+UayJNfzBVAOWa0gAAAAAM5LBcXYzep8kZ3ffJlAGUDPJAAQAAgC/+/vtvOnbsGOXkuDfr3nfffeEbQHEeqLFjxwb7NAAAAEJWpHYiP3ToEHXp0oV27NiR1/eJ8c9Mbx8oU+SBuhbkgQIAAAA9nn/+eapatSqdPXuW4uPjadeuXbRmzRoxhcvq1atJr5CogUIeKAAAAN8oCte+GNtnSTF4f/7Ac96tXLlS9LHmEXm8NGvWTLRuPffcc7R169bQD6B40j9tuNrN4vd0BTI220UyA6OHEctSFfjjWgRy6Ln+dAUy2qt9T6euk5YlJ+jLRSKnaE5V4M2wys9Jy147pOdvTjH0/RLIofaydAqhnKrAG2/Xr3yxFgan3zDuc4ndmzxcWvb9pck+nBGECm6iK1r0avoWDqJOnTpFtWrVEp3L9+7dq3u/pgqgAAAAwD8itQ/UTTfdRNu2bRPNeLfffjtNmTKFYmNjadasWVStWrXwCKCQxgAAAACMNHLkSLp8+bL4edy4cSJVUvPmzcUkwl9++WV4BFAySGMAAABgQCJNR+Ql0mzXrl3ez9dff72Yd/fixYuUnJycNxIvbEfhcUcvTkPvXCpWrBjsUwIAAAjJTuRGL6GoePHiPgVPIVMDxWkMeCJA13l9EEQBAADAtXDz3aRJk2jFihUilYHD4fDIExXyAVRubq5IWZAf0hgAAAD4yGEhJQKncunbty/9+uuv1LNnTypXrpzPNU+mC6A4qdWSJUvo448/DvaphJy6xXpKy3akfKp5f9HRxQOWuqFV0mDV9atTp5LR3r9ppOr6p3dOIDO4lLGdzExfqoLAiYmSpzHINjiNQSDFxpRWXZ+TezaAZxElLTE6XYHRkKoAfvrpJ/rhhx+oadOmhl4M0wRQLVq0EAsAAAD4qRO5EnmdyJOTk0WfJ6NZzZK+gGufjh8/Tt26dRNJrgAAAAB8NX78eHr11VcpMzMzPGugeFjhZ599JhJbcbToCmkMAAAAfBNJU7nceuutbn2dDhw4QGXKlKEqVapQTEyM22P//PPP0A6g3njjDVq8eLFH8ORMYzB27NignBcAAACEls6dO/v9GKYJoKZPn05vvfUWxcXF0W233eZWhjQGAAAAvlH8MApPMekovNGjR/v9GKboA8Xi4+Pp008/FbVNmzZt8khjkJiY6LYAAACA9k7kRi9mxzHFhg0bPNbzus2bN4d2DVTv3r3zfv7qq6+Cei6haGeq/rl81FQr2lpatu/SIkmJvr+iP3N/okCZceK4ofsrEldVdf3lrMO69lct+V7V9YcufU+BI/82GV+okrQsM/uooWdhtcarrnc45J1A7UoOBUpCvPprn5653/Bj5drSKPjs0pLkhJtNnZbDYomVlikBfM9A8DzzzDM0bNgwMZGwq5MnT9LkyZNVgyvDa6DsdrvI15SSkqLrYAAAABAckTqVy99//+3RNcjZ0ZzL9NIUQEVFRdHdd99Nly5dIn+kMQAAAAAwEncDOnPmjMf6f/75h6KjowPXB+qmm27SPW+MXpzGgOe/c10AAACg4BwOi18Ws+OKHx6MlpqamreOW9JeeeUVuuuuuwIXQE2YMIGGDh0qaow4egtEYMMdy5OSkvIWTCQMAAAABU2TxIm6K1euTHfeeadYqlatSqdPn6Y333yT9NJcd9WxY0fx73333eeWpEpRFPE795MyGtIYAAAA+CZSp3KpUKECbd++nebNm0fbtm2jwoUL0xNPPEGPPPKIR1JNvwZQq1atIn947733RK1WtWrVRG/5/O2XvAAAAABoVaRIEXrqqafISJoDqJYtW5I/0hi4pjIAbSyWaEOH6Z7I3CQ/lmRWdoVspMf1sc1V1/+ZuZeMdon+MXR/etIVeBtSfSR1her6qCh53jO73ehmcyVgqQq88ZauQF/6jYVkJJv9CgWK1ar+nrHbs8gMsnP/7VdiRlGSlBjMZjc2jUGV5KstNPkdufQjmUEkTeUSCLoSaa5du5Yee+wxatKkicijwDgJ5rp164w+PwAAAAizNAbvvvuumJeOZx/h/EwbN270+nju9M35nMqVKydapGrWrEk//vhjaAVQixYtonbt2ok2RJ6Aj0fIMe7d/tprr2lOX1CvXj3xc25urujghXQGAAAA4evLL7+kIUOGiOlWOI645ZZbRFxx9uxZ1cfn5OSI0XJHjhyhhQsX0t69e2n27Nmib1MwResZhTdjxgx6/PHHaf78+XnrmzZtKsq0qlWrFv3+++8iR0Pjxo1VH8NBmjNQY0hjAAAAoI1DsYjFSI7/7S//fdlb32We97Zfv36iIzfjmOKHH36gOXPm0Msvv+zxeF5/8eJFESs4O31z7VWwaa6B4sivRYsWHus5vYCeDOUPPvigqNX6+eefRa4GNUhjAAAAYF4VK1Z0SzfE921ZbdKWLVuobdu2eeusVqv4ff369arbfPfdd6KChZvwypQpI/JRcotXQUf98+C0CxcueKznmIXLAlYDVbZsWTpw4IBH9Mf9n/ScCDcFMr4ofBHVII0BAACAbxSHRSxGUv63P86zlJj474AXWe3T+fPnReDD93xX/PuePXtUt+Hk3StXrqRHH31U9HviGGTgwIGi6w83A14LN/2pBVvcsuXsxx2QAIqr3Z5//nlRpcZ5n06dOiWiRk6uOWrUKF0nMWXKFLGvTz75RLUcaQwAAADMKzEx0S2AMpLD4aDSpUvTrFmzxJRy9evXF4HP66+/7jWA4porp2XLlomaMScOqFasWOFTU6DmAIrbJ/nJtGnThjIzM0VzHgc4HEA9++yzmvaVP3WBUakMCsWUVV2fnXuawpOuwZRSOTb5sGRZuoJiCTdJt7mcJb/uu68s1Xh2ROWLeTYhO51KWSMty3IEf7i1onipclYcqqsdpH1Iv7f0Bw67fH/li6mnlWBn0rdKy+z2DEPTW8jJvz0fTPuZAiUrO3CfJcanqjBWqfgbVdcfDWDaC2/sOlJi6GWWdAVmTqRZsmRJEQTln5uOf+cWLjU88o77PvF2TjfeeKPIJM5NgrGx6qk+OnfuLP7lCppevXq5lfH+OHjyJRO55jsvn8iIESNEh66dO3fSH3/8QefOnaPx48frPgkAAAAIf7GxsaIGiWt/nLhShn+XDSTjQWrcbMePc9q3b58IrGTBk3O/vFSqVEmM8HP+zgs333Gf7k6dOgUugHryyScpPT1dnHTt2rWpUaNGlJCQQJcvXxZlWnEqA76Y/IS4/XPMmDGa9wEAAADeOejqKDxDF9Lep4pTGHAago8//ph2795NTz/9tIghnKPyeJQ/93124nKutOHuQxw48Yg97kTOncoL4vDhw6Lmy2iam/D4CU+aNImKFi3qtv7KlSuiDxP3jdKqbt269Nlnn4lgTA3SGAAAAIRHJvKHH35YtFy9+uqrohmO80EuXbo0r2P5sWPH3AaV8Qg/7sP0wgsv0M033yzyP3EwNXz48AIfk2u4eHHWRLnSE7doCqA4xwNPGMwL10Bx9lDXzljcM547eenBqQw4+OILo4aHQ44dO1bXvgEAAMBcBg0aJBY1q1ev9ljHzXvcZUgPjh/GjRtHDRo0EM1+3BXJCAUOoIoVKyYOygunUM+P1/sS5HAH9OnTp4u2yvyQxgAAAMD32iJHBM6FN2PGDNFdqGfPnobut8AB1KpVq0TtU+vWrUXiy+LFi+eVcX8onoalfPnyuk+kefPmIjupWgCFNAYAAACgB4/U47l7jWZROCrS4OjRoyLIMaoKTA9uTryaz4HbSC2mTGMQEy3vsJZrO2/osQZUkOffmnEyNEdHyobgX3tYt7f3pfbxuxYv3zGSEm5QXZ+dK8/IHxNVRFqWlrlXehZ6nlOpxIaq68+nydMReEs7EB1VTFpms8ue87/Djj0VLItwKImNkXdjyMlVn+crFFit8dIyh8FpAqzWBMlx1FNlXIvF8m93k/wUJYuCh/92HWIeWX/lT8p/z9x851OUEC0ftaZHhi2HGqyaFZDnoRf3leLBbnpzVRrWiZyzgfKJdOvWzW39V199JfJC5c+1AAAAABAsWVlZIgnn8uXLRV9r53x6Ttz6FZAAijt0z5w502M9dyB/6qmnNAVQXK324osviuRYPCcNp2aXjcQDAAAA/XjsmcMP+zS77du3i5F+jPNXuvKlNU1zAMXDC6tWreqxnvtAcZkWH3zwAXXs2JE6dOhANpuNHnjgAfr22289Hoc0BgAAAKAH9+H2B82JNLmmiaO5/LZt20YlSpTQtC+OBBs2vNpPIzo6muLj41Un/ONaL9dZnjknBAAAAGjPA2X0Eio4mznnk+K8lUxjF3DfA6hHHnmEnnvuORHRcbDDC/eL4qRW3bt317QvzmS+ZcsW8TPXQHEfKte5blzTGHAHNefCsz4DAABAwTkUXozORk6md+HCBTF/L6dg4lavf/75R6zv06eP6EYUsCY8nvPuyJEj4mS41ohxVk9Ovc6p1bXo16+fOHlOwsmBkWvqdldIYwAAAAB6cAZz7jjO3Yx4EmLXjOg8rYzeCYU1pzFw4vlouNmucOHCYioW7gNlljQG8mHfIRAqm4AsDYQ/UkHcm6yeiv/7S5Mp0iQUrq66PuPKQV37KxLn2VeRZWaflG4T5WW4epRVPhw8kClCZBLja+lIEaFPsYSbVNenZLh3UDVGlKFpIGSpFvSmWZClbNGbrqVMkvqEsmdS1+van7dUJN7SdoRjGoPfWwyghOhChu47w5ZNTdbMMHUag7Jly4qmu1tuuUVMQ8exS7Vq1ejQoUNiVF5GRkZgaqCcuCpMLSM5AAAAgFnwRMXcxzo/nqCYW7j00hVAnThxgr777jtRHcapCHzNp8Ap1hcuXCg6odepU4eGDRum57QAAADAax8oYy+PIwQadnimE55vl7sgOVMXcNejKVOm0J133hm4AIpnM77vvvtE9deePXvopptuEn2iuCXwtttu030iAwYMoE6dOolUBvkhjQEAAADowYES99vevHmzqPThSppdu3aJGqjffvuNAjYKjzt6Dx06lHbs2EFxcXFiXjweFdeyZUuP7ORazJ49W3QqV0vEiTQGAAAAvonUNAY33XST6LfdrFkzuv/++0WTXteuXWnr1q1Uvbp631O/1EDt3r2bvvjii6sbR0eLfAo8tcu4cePEiT399NO6ToSDJ66BkgVt3FPetUMcckEBAACAN7m5udS+fXuaMWMGjRgxgoykOYAqUqRIXr+ncuXK0cGDB0W/JXb+vLGT5DohjQEAAIBvHGQRi5EcBu/PaJy+QC35d1ACqDvuuIPWrVsncilwQirO48TNeYsXLxZlevTu3VvXdgAAAFAwnLTIx+Tbqvs0u8cee4w+/PBDmjRpUnADKB5l58yZMHbsWPHzl19+STVq1NA9o7HxQuAVNbFA5vSJxHxPMnrzPclczjqseRub3X1UravsQ3OlZVGVg/8lyOhcT974J98TGZrvSUZvvicZvfmeZPTme5JRcD+IeDabjebMmUPLly+n+vXri5Y0V3pjF00BFE/bwikMOPEU45PgdkUAAAAwN+f0K0bv0+x43l1nlgDuTO6KUxropSmA4nnq7r77btGRvFixYuQr7kvFTYC8X+4YPmjQINVUCEhjAAAAAFpxxQ+3lvGMKcnJyWQkq57hgJz+3AgffPCB6Ec1depUmjVrlkhXoAZpDAAAAHyj/K8TuZGLYvJO5M6Kn5SUFMP3rTmAmjBhgsgDtWTJEjGjMdccuS5aq9UaNmyYlxKBF26rVEtjwPPsOBfOOwUAAAAQyIofnzqRc40R42zkrm2HnImcf+fqsoKqXbs2bdmyhdq1aycCp1OnTokgKj+kMQAAAPBNpI7Cm/C/ih+eykWtE7neSZA1B1CrVq0io3DyTO4D9cMPP4hAiqdzAQAAADCKkRU/PgVQPGWLUbhm6Z133hE/cyDFnbyMYJE8LYU8mwfDQZG4qoYOZY+Okg8QsNnV25GjouQRfJmi9aRladknNQ/pt1hipWWKIh+GXz35ftX1By99q+ta2B2ZknPI1ZVio2h8DdX16Zn7yUiyvw8WFS1/HYvUeEX7sSxx0jJFyZKWFYopqyPFRlTAUgFYrZ4zuzOH5D3hi+jo4qrrbbaLZAbxhSqrrs/MPkrm4Aj2CZhGpI7CW2VgxY9PAZRTZmYmHTt2LC8ruZMzxYFWb775pt5TAQAAgGtQ/NDpWzF5J3KjK358CqDOnTtHTzzxBP3000+q5VqrwubOnUsLFy6kEiVKiD5Rw4cP13pKAAAAAKrWrFlD3rRo0YICEkANHjxYDAfcsGEDtWrVir7++ms6c+aM6KSltxaJ+z7xRMLdu3dXLUceKAAAAN84lKuLkYzenz9wrJKfa18ovX2gNKcxWLlypUh73qBBA7JarVS5cmUxz8yUKVOkeZyuZfbs2dSkSRMRRKlBHigAAADQ49KlS27L2bNnaenSpSKN0s8//0x6aQ6gLl++TKVLlxY/c1ZPbtJj3AH8zz//1D0aj+eoWbZsmWo58kABAAAY04nc6MXskpKS3JaSJUvSXXfdRZMnT6Zhw4YFLoCqVasW7d17ddLOW265hWbOnEknT54Uc+KVK1dO94nEx8dTo0aN6Pvvv1cdrcd5GlwXAAAAAL3KlCmTF88EpA/U888/LzKQs9GjR1P79u1p3rx5FBsbKzqEa9W797+zuD/77LNkCIvkaSnhmcagW7FHpWVzT0/QvkOLt7ha/duGwyFPH3AqZY2uIfV6UhXIzo8dTV+r+ViytA3ej6WvU0BG5mHN10hXag4vr29CXHlpWUrGTs2H8paqwBvv6QrUWa2FpGXy9ALevj3LX8cicRUMTTmRVORGaZnNnmXqNAZRUbGmTSvBFMWh4/2p731hdpE6Cm/79u1uv3P+J45jJk2aRPXqydPsXIvmuxf3d3LijJ5Hjx6lPXv2UKVKlUS1GAAAAIBZcJDEncY5cHJ1xx130Jw5cwKfB8q16e22227zaR+7du2iiRMnigDsuuuu86lNEgAAADxF6ii8w4fda/d5AFypUqUoLk6e6NcvARQP9+OmuhUrVoie7A6Hw2OUnlbcC75nz57UoUMH1XKkMQAAAAA9OFuAP1j19IHihQMpnuGYO5K7Lnr06dOH1q1bJ/7lTun5IY0BAACAMX2gjF7M7rnnnqPp06d7rOep5Di3ZcBqoObPn08LFizIm5zPCDyqjpvw2D333CPSGnAVm2sagyFDhuT9npaWRhUrVjTs+AAAAOEuUpvwFi1aRN99953Hes4/yR3Jp06dGpgAikfbXX/99WSkb775RuSAio6OFtO5uAZPzjQGvAAAAABoceHCBZH/Sa3y5vz586SX5gDqxRdfpGnTpomqL9dU6L7o3LmzWIyid+h0qJp/Uf8oAjV2W5qXUsXQa140vrrq+rRMfbk5YqJLSMviC5VSXZ+qezi4wV+9JOkFvKdtkIuOKqY5NYP3VAWBG5auh6IrTYmxKSf0mlT1AWnZs7vfITOLj1EffZ1O+lI6yNJ2eEvZIU9Tca33rdGiTPv3wfyR+NIRAok0udKHM48PGjTIbT3P6VutWjX/BlBdu3b16CjOB65Tpw7FxMS4lS1evFj3yQAAAAAYibsAcfDEM6e0bt1arOOBcDx/r97muwIHUPmrvrp06UJGuXLlCr3wwgt06tQpMUcNB2UvvfQSVa+uXjMBAAAA+upbje6ypITAC/Hkk0+K0fzc13r8+PFiXZUqVej999+nxx9/3L8B1EcffUT+UrhwYTENzOrVq2nnzp0eVWwMaQwAAABAr6efflosXAvFcUdCQgIFPI0BJ6Tav9+zbZvXHTlyhPwBaQwAAAB8wykHjJ5IWAmBNAauOIGmEcGTrgCK5677/fffPdZv2LDBbV47I3Eag9TU1Lzl+PHjfjkOAAAAgF9G4W3dupWaNm3qsZ7nlFFrfjMC0hgAAAD4hucNcfhhn5FKcwDFqQvS09M91nPNEGcn16tVq1ZiAe2yck4Zetm8DReWaVCsn7Rsc4o8zYIi+fOTDWW+1vnl2uQ5PVK9lMmUSmwoLcuxZ6iutzvkaQcyrhySlulNV6DVAyX+Iy1benm+tOxylrFD940WqOun92/Em6d3TiAzi4mWTxR/JnW96nqLRT7PmLe0J0ZfW30pBPR2jTZHugIZhZvcDE47oIRAGgN/0dyE16JFC9EnyTVY4p95XbNmzYw+PwAAAIDQr4GaPHmyCKJq1apFzZs3F+vWrl0rplfRM5EwT0xcsmRJ6tSpE+3Zs0dMFTNmzBjN+wEAAAA5NOEFuQaKp1rZvn07PfTQQ3T27FnRnMd5FDj44cmF/YHTGHCA5roAAAAAqOEp4aKiojQv48aNI7/VQLHy5cvTa6+9RoHCzYNjx44N2PEAAADCTSRNJnz4sL4+m8WKqU+BZVgAZaTk5GSR2IpxjVbx4sVV0xhwKnYnroGqWLFiQM8TAAAAQkPlypX9foygB1Dt2rWj/v3707Zt28SsyGrz0iCNAQAAgG846aXRiS+VEEukGVYBVFxcHH388cfBPo2Q5m2o/bm0TTr2GKV5mO7mlNk6jkN0JedCgIYyEy1u8LLq+q6bJxl8/fS5rlgb1fUnUlbo2p/NnqK6ftGF/1I40pv6wshh/d7SaOgVF1s+IOlLvPH2vArFlFVdn5172o9nBBB8QQ+gAAAAwP8iqQ+UKUfhtW7dmlJSPL/Zcr8kLtOqa9eulJV1Nanajh07aPjw4Zr3AQAAAAVrwjN6iVSaA6jVq1dTTo5nxl8OgjgflFYPPPAALVq0SPw8Z84c6tOnj8djkMYAAAAAtMrNzaU2bdrQ/v37KWhNeJz7yenvv/+m06dPu2UiX7p0KVWoUEFXAPXYY49Rt27d6OjRo1SzZk2PxyCNAQAAgG8isQkvJibGLX4JSgBVr149MQ8eL2pNdYULF6a3335bVyfycuXK0f/93/9R586dVR+DNAYAAACgB1fSfPjhhzRpknzAkF8DKE5KpSgKVatWjTZu3EilSpXKK4uNjaXSpUuLLJ56PPHEE3T33XfT8ePHVcuRxgAAAMA3kVgDxWw2m+gitHz5cqpfvz4VKVKEXL311lvk1wDKmZTK4eDZdIx12223iRxQoM+5tM2GXrrkhDrSsksZxlaF2mwXKVAe2jqDzExvugK4qlBsaemlMHrIf+mEuqrrT6as0rW/pbe/JC0bsG+X6vojAUxj4I3NkRnsUwDwaufOnSLOYPv27XMr41a1gKYx4M5Yq1atEpnD8wdUr776qu6TAQAAAP+I1ESaq1bp+2JjeAA1e/Zsevrpp6lkyZJUtmxZt+iNfy5oANWrVy/R74mb/bjj+MmTJ0UT3vTp08V6AAAAALPSHEBNmDCBJk6c6HO+ppYtW9KaNWvEjMk8Am/Tpk20e/du1Q7qnMaAF9ecUwAAAFBwih/6QCkh0AeKbd68mRYsWEDHjh3zSMW0ePHiwOSBunTpkgh4fMWBEueU+v3330Uwxj9zQMWBlVoag6SkpLwFEwkDAABo4/DTYnbz58+nJk2aiEqar7/+WuSG2rVrF61cuVLEFHppDqA4ePr555/JV1WqVKEjR47QlStXREB05swZSk1NpcTERNU0BlzmXGSj9QAAAABcvfbaa6Jr0Pfffy+yBkybNo327NlDDz30EFWqVIkC1oR3/fXX06hRo+iPP/6gunXriiRVrp577rkC74tTIZQoUSLv91q1aqk+DmkMAAAAfKMoFrEYSTF4f/5w8OBBuueee8TPHEBdvnxZ9Nl+4YUXRGvY2LFjAxNAzZo1ixISEujXX38Viys+IS0BFHdId5o6daqu+devLuD9GmlzKWOHofvz5mCHvqrrayybJ93G4bii61jxhcqork/LTNW1v/DkrVLa3JX1WTn/BOx9ezJltaHHab/hDR1bmeOzz25PN/X5ASQnJ1N6+tX3Kc+YwmkNuAKI5/XNzNSfhkNzAMUJNQEAACC0+KPPkoPMr0WLFvTLL7+IoIm7IT3//POi/xOv43nyAtYHyol7se/du1dk+PTFb7/9RiNHjhQ/P/vss6KTFwAAAIAR3nnnHerevbv4ecSIETRkyBDR75rn4uUpXgJWA8XVXRzofPzxx3lZPXl6F17HVWMvv/yypv01bdqUfvjhB5E/ivdz4403ejwGaQwAAAB8E6lTuRQvXjzvZ06dpDVOMSyA4hFx27ZtE2kH2rdvn7e+bdu2NGbMGF0n1rNnT7rjjjvo1Cn1qQk4jYHeTl4AAAAQ2RwOBx04cEB1BhVu4gtIAPXNN9/Ql19+KQIe1yzkderUET3dteInMnr0aFq0aJEIwF5//XXVoI2r3FwTaSIXFAAAQMFxZZHRFUZKCLwAnDWgR48edPToUVLyZf7kOMZutwemD9S5c+eodGnPSTudwwK14lmQH3/8cVGDxTmg8o/sc6Yx4DLXBQAAALQ24VkMXsj0BgwYQA0aNBCj7y5evCgSgjsX/l0vzTVQfBLcZ4n7PDFn0PTBBx9Q48aNNZ/A0KFD837m/FIAAAAARtm/fz8tXLhQ5LE0UrSejJ4dOnSgv//+W4zA44ye/DNPyaJWe+Rf6qFvu6R/gzJXy1L15FoxvxuSH5KW7bm0ICDnYLUmSMscjgxpWfWf/s0F5m9pmXvJzIoXrae6/mL6XwE8C31V2ZHGHK+VOYytoT6B/Oj94wJ+LqEl8FU3kdqEd/vtt4v+T0YHUJqb8Jo1ayY6kXPwxDkVeFoXbtJbv3491a9fX9dJPProo/TPP/+I1AicWj0rK0vXfgAAAAC2b9+et3CL2Ysvvkhz586lLVu2uJXxEpAaKJ6Ar3///qKpzTWLuK+44zhPKFy5cmUaNmwYxcXFuZUjjQEAAIBvIimNQb169UQXI9dO408++WTez84yXzqRawqgeN47Hi1ndF+l8uXLU6tWrcTsyNzHKj+kMQAAAAAzzZqiuQ9U586dRSoDnoTPSJxEUzYnDdIYAAAA+CaSpnKpXLmy+QKoGjVq0Lhx48QULNznqUiRIm7lWiYTLihOY8ALAAAAgBbcilWmTBm3Jjw2Z84ckZqJuxAFJIDieWOKFSsmOmLx4orbEvUGUNyExwsAAAAYj7sD5csjacg+zW7mzJn0+eefe6znBOA8R15AAijucMVTuPCou8KFC5NZhWu6gkClKkjvf3XSRTVFZ87XnKrAm4ZJ/VXXb0qdSZEmPIfAe0uuGwKfvBH1Wukzev/4YJ8CFJBCFnJ4/ZvUt0+zO336NJUrV85jfalSpUQGgICkMeAAipvwTpw4QUbhTumcJZQXjgbnz1e/QQMAAEB4ePfdd6lKlSpi1D3nadq4cWOBtuMYgVu7uD92QfHUb9ztKD9ex4PY9NJUA8WzGHMAdeHCBfGvER544AGxbNq0SQRoXJ2WH9IYAAAAhEcT3pdffinmt50xY4YInqZOnUrt2rWjvXv3qk4V53TkyBExe0nz5s01Ha9fv340ePBgkYqpdevWYt2KFStE2iTODxWwRJqTJk2il156ScwpY5RTp07R5MmTafr06dIOYElJSXkLJhIGAAAITW+99ZYIap544gmqXbu2CKTi4+NFp24ZztXESbfHjh0rRu1rwTFLnz59aODAgWJbXji5JvfZ5lH+AQugeOJfrmq75ZZbRD+o4sWLuy1acdZxfiLvvPOOdKQdP8HU1NS85fjx45qPAwAAEMkcflpYWlqa28ItR2p4xhEegNa2bVu31i3+nWc0keHR/1w7xYGQVtzkx5U0POLujz/+ELOp8CTCr76qPg2R30bhcVWbkcaMGUPnz58X/7KOHTvSfffd5/YYpDEAAAAwr4oVK7r9Pnr06Lz7uiu+33NtEqcVcMW/79mzR3Xf69atExkA/vrLt8EbCQkJ1LBhQzKK5gCqV69eZCRuEgQAAIDQncrl+PHjlJiYmLfeqNyN6enp1LNnTzF9XMmSJclMNAdQx44d81peqVIlCraYaPWLnGs7H/BzCUWyVAX+EInpCiKLWVIVRKmutVrl6VgsFnkPB7s9TbaVfH+Sc2AK2Qz9PLNa46VlhWLUu1rk2GTPiahxQm9p2bpU9b6rFi+3F2/Pt3ry/arrz2TJ+91WjrtDWrbrkvzzLDo6SXW9zZYq3YZIPm9aVFSixvdL+EhMTHQLoGQ4CIqKiqIzZ864reffy5Yt6/H4gwcPis7j9957b946h+Nqw2F0dLToeF69enUKiQCKhx1ye6KM3kn5AAAAwL9fZ4z+SqNofHxsbKyYxYRHwTlTEXBAxL8PGjTI4/E33HAD7dixw23dyJEjRc3UtGnTgjqoTHMAtXXrVrffeVggr+Ne9RMnTiR/QBoDAAAA8zbhacEpDLg7UIMGDahRo0aib/Xly5fFqDznYLUKFSqIEficJ+qmm25y255nQ2H518usWbOGmjRpImqsXNlsNvr999+pRYsWFJAAikff5ccXgZNRvf7669S1a1fNJ7Fr1y6aN2+eqMLr27cvNW7c2K2cLyIPXQQAAIDQ9vDDD4sRcTwKjrOE16tXj5YuXZrXsZy7CvHIPKPceeedIuN4/hxTPKqfy/S2nGkOoGRq1aolkmHqwVV6nM6AL96nn37qEUBxGgOOWJ14iCRyQQEAAIReIk3GzXVqTXaMp4zzZu7cuaQFJ+lW63rEScGLFClCemkOoDh4yX9iHNnxcEW92ck5gSYnuuJ98dDH/JDGAAAAALRwtohx8NS7d2+3kYFc67R9+3bRtBewAIrbHvNHchz4cI2Q3nnsuAqNk1zlzwsBAAAAxnBNfGkUB5kXz1zijFGKFi0qkn+7tnzdcccdIiN6wAKolStXugVQ3E7JMxpff/31Hh20tESJevpOySBdAUDkSSgsH8qcceWQ6nqHI0PXsf5TTT2D8X8PjdM1dN8bh5IjKZGPhnY4MqVl5eLbqK4/dOl7zakKWPGi9VTXX0zXl/TwfM4+1fWXrxyVbrPryhFpWdkk9y4hrk6nriMjxcWUUF1/OQLSGJjRRx99lJc9gOfQ86W5To3miKdVq1aGngAAAABEzii8YHRalwVPy5YtExMZ66G5mzuPiFOb8I/XcTOcHtwhbMmSJbq2BQAAAJC57bbb6N133/VIj8Sd2O+/Xz1xq18CqJkzZ4rEVvnVqVNHzKis1xdffEEvvviiahDGTzT/RIUAAACgPZGm0YvZcSUNp0zguXY5XRLPqXfrrbfS8uXLae3atYELoDhnQ7ly5TzWcz8oHo2n1913301vvvmmSIXgTNPuWuvFncGcC1IYAAAA6GvCM3oxu4ceeoi2bdsmEn9zZQ+nSmrZsiX9+eefPk0urDmA4uDlt99+81jP6ziZpq/UcjVwHihOeOVceNJCAAAAgILKyckR6Qt44YogznIe0E7kPORv8ODBIpJr3bq1WMdz2AwbNkw0wenFHbk4QuSs5vkzkCIPFAAAgG8UsojFSIrB+/MHTrH09NNPU/PmzWnfvn2iCY+njeG4g5N3V6tWLTABFCe85OydAwcOFNEc4yhu+PDhoqZID05wxQsAgF5FYt2naXCVceWg6nqLJVa6jSJNH0C0+sIFMlKbpCHyY2V8ICmRt53EF6osLTuSuoKMVNuqPo/YOtKXxiAj66TmNBCxMfLX/nzGTgqUy1nHAnYsKLg+ffrQG2+8IYIodtddd4kJivv37y+mkdHbrzpaTxMbd/QeNWoU7d69WySm4gzkrhk+AQAAwFw45Da6z5JC5sd9nXi6OVfJycm0YMECUQOll+658BISEnzqfAUAAADgbxw82Ww2McfewYMHqUePHiIz+alTp6hLly6692vYZMK+OHr0KI0cOVLMlMxPplmzZh5pDHhxQhoDAAAAbSI1kebRo0epffv2dOzYMRFLcBMeB1Dcmsa/603BZIoAihNccY4G2WTEnMZg7NixAT8vAAAACG3PP/+8GKDGA9VKlPh3uh2usPFlLjzNaQz8gSf6yz/yzhXSGAAAAPh4r43QRJpr164VrVw8gbArniPv5En1QQshUwPFI/rGjBkj8jLcd9991KRJE7dypDEAAADwTaQ24TkcDpH7Kb8TJ06IpryQDqCqVq1KH3/8sebtLJZ41cSb3zcYpPr4eza+7mVvet4FUdKSuNgy0rKsnFPSMqs1XvPs6t7OQx/PNxqA2Z1L36F5G2+pCshLfpujFu3H8mZF6lvSskIxZVXX2+3yodeZ2Ue9HM3YvD2bMhcYuj+HXf2zLjqqmHSbnNyzAfx8lLNIrm0IxBhh7e6776apU6fSrFmzxO8cN2RkZNDo0aPF9C4hHUABAACAfyn/+8/ofZodTxPXrl07ql27NmVlZYlRePv376eSJUuKeXjDIoB68MEHaeHChcE+DQAAAAgT1113nehAzhnJt2/fLmqfOLnmo48+KnJZhmwAtWfPHlGNVrNmTfGk1CCNAQAAgG8itQ8Ui46Opscee4yMFPQAavbs2TRp0iQxSTG3U6pBGgMAAADQi5vsVq1aRWfPnhWdyl1xGqWQDKAYDy2MiooSEaIsjcGQIUPcEmlywAUAAAAF44+0A0oIXHyuqOF58LjPU9myZd0Gn/HPIRtA9e3blyZOnOh1NmSkMQAAAAA9JkyYIOKM4cOHk5GCHkDdeOON9N5774mfhw4dqn0IsuI5bHTzpTgKDPdqQFc2yVDca1EcOYaeB0CkiC8kTx2ScSVD8xD36OgkadmZ9L90pAjQ9109O/ccGclqVe80qyg26TbxhSpIyy5nHdaRPkCeKqV0kvocqxnZp+V7c2RJyxRFXiY/R4eu19HsI9IitQ/UpUuXqFu3bobv1xSZyAEAAAD8gYOnn3/+2fD9Br0GCgAAAPxPUa4uRu/T7K6//noaNWoU/fHHH1S3bl2KiYlxK3/uuedCN4DimZI50RXPiVe9enUaPHiwWznSGAAAAPjG4YcOHw4yP85AnpCQQL/++qtYXHEn8pAOoLgPFCez4mXHDs8pEpDGAAAAAPQ4fFjWT883pgigOCdDz5496eabb1YtRxoDAAAAH++1EdqJ3F9M0Yl80KBBNHnyZDEKb+zYsappDBITE90WAAAAADWcoPvKlStUEBs2bKAffviBQrIGqnLlyjRv3jwdW9pJURk2vDdFNkQ2cCnEbPZ0nXu0G3oeAJEiJqqIjq3kf28220VpWalE9aH2aVeOS7fJzpUPw/cmLlY9PUNWzikykkgLozlVAdFdSS+qrv8l9U1d55FlS9F8DlZrvJcy+Rduuz2NjKXn8zuA/NCJnEx6+/n777+pUqVKYgTevffeSw0aNKBSpUqJMpvNJsrXrVtHn332GZ06dYo++eST0AygAAAAAIzCARFPIPzOO+9Qjx49xAwmPOMJt2hlZl7N03jrrbeKZN69e/emuLi40A2gDh48SC+88ILoC+WPhFcAAACRLNJG4d1yyy1iGpeZM2eKYOrYsWOiWY+ndKlXr5741xemCaDef/99Ua1WoYJnxlukMQAAAAA9rFarqG3iJew6kbNOnTpRx44dqUmTJqppDJKSkvIWTCQMAACgL5Gm0YtZ2e12MUCtadOm1LBhQ3r55ZcL3LE8pAIobziNQWpqat5y/Li8oyYAAADIm/CMXszqtddeo1deeUUk0eTWrWnTptEzzzxj2P5N04TnDXf64gUAAACgoB3JOVF3//79xe/Lly+ne+65hz744APRrBc2AVSrVq3EAgAAAMbj6dJ4MXqfZsWdxrlrkFPbtm3F1C2ctuC6664LnwBKnyiyqOSBOp1zdYii/3ke28lqLSwtczgyvOwxSnW9QjZd5yFn3jc9gB7ZuakBu3BRlkI6cj3J/06rJ98nLTuesZ6MpCgOHZ9n8hxbO2gDBeL8rNYE6TYOx2VpWVRUUUPOC0KPzWbzSE/AEwnn5uYasv8QD6AAAACgICJtKhdFUUSOJ9cuQFlZWTRgwAAqUuTfLwWLFy8OzQBq9+7dYvqWmjVr0saNG2np0qUej0EaAwAAANCiV69eHusee+wxMkrQAyjuzMXDDLmHfLt27VQfw2kM1ObIAwAAgILhyqIImclF+Oijj8ifTJPGgDt28aIGaQwAAADATIJeA8Xz0HByK27Cc22TdIU0BgAAAL6JtD5QYR9AlSlThmrUqEHnz59Xba8EAAAA3yGACrMAqnjx4jRu3DidW9tJURl6u0NZR8GmOLL0bUd2XVsBRLq6cf/me8lvQ/b7hh7riRKtVdf/N3Wdrr/Tg5e+lZZVT75f8zbeKIr2zyZvqVey7WlkpLTMA5IS+WejtxQHdrs8xYHRoqOKqa632VMCdg4QOKboAzV37lxasmRJsE8DAAAgzDuRG/1f5Ap6DZTTggULRAoDbtIbNWqUWxnSGAAAAICZmKIGinEKg3feeYd27typmsYgKSkpb6lYsWJQzhEAACDU+0AZvUQq0wRQHBgxtVQGSGMAAAAAZmKaJjxvkMYAAADANzzvr9Fz/yoRXANligCK56pxmj9/flDPBQAAACAkAij91EPfc2mbgnr8qyU2w/cJAHIbU2cbNuycORT53/Abx95TXW+1xuvqMeEtTYCedAUWLx/tCfFVVddfybkg3ebWIt2kZVszvpSehZ7PubjYMqrrGxWWn8NJ6xFp2cFL30nLoqISVdfbdaZmkKcr8HYtAofHzDkMvscoEXzPMk0fKPbdd9/R2rVrg30aAAAAYduEZ/QSqUxVA3Xx4kWyWj1jOqQxAAAAADMxVQ2UDNIYAAAA+MbhpyVShUQAhTQGAAAAYCamasKTQRoDAAAA3yiKIhYjKRHcCcpUAZRrOgMAAAAAszJVAAUAEEjyYefe9S//gur690+MJzPwlkYlPXO/5v1tSp0pLXu+0quq66cdG0d6ZOWcUl2/Jmearv09Vd59blVXs04F6vVSq6UJfM2NP6ZecURuBVRo9IECAAAAMJNos+WBSk5OpubNm7utRxoDAAAA3zj8kEjTgUSa5skDlZqa6rEeaQwAAAB8w6GT4Yk0KXKFRBMe0hgAAACAmZiqCU8GaQwAAAB8gya8MK6B4nwSalO5AAAAAJiJaWqgzp07R4sXL6b3339fw1ZRqrNcN016WvXRv6W+62Vf2ltyrdYEaVnh2FLSsstZh6VlFkuc6npFyfJyJt5m+pYFpN4S8EdyqzaEKm9D90NZ5eT2quuPXlqqa38Wyce+t+tXNqmZtExvugKtCsWUlZZl5542QaoC8/NHnyUlgm8XpgmgSpUqRd9//32wTwMAAADgmkzRXjZ37lxasmRJsE8DAAAg7PtAGb1EKtPUQLGPPvqIMjMz6ZlnnnFbjzxQAAAAYCamqIFi7777LsXExHgETwx5oAAAAHzjUBS/LJHKNAFU9erVadeuXaplyAMFAADgG8VP/0Uq0wRQ7du3F1O4vPzyy6p5oBITE90WAAAAgIjuA9W7d++8nzt27KhhS4fqEP40i+d0MFcZPAeQ44q07ErOGV37VJRcH85IS7qCyP3WAOEpqciN0rLUy7s1769ofA1p2aK0nzWlIbl2KhK5S9nytCd6UpvcWuzfz1tXf6Z8IN3mdOo6zSkOvG2jR44tRVpmscQa/Jmq7/MxOqqY6nqbXX7ugaRcI4GN3n1GKtPUQAEAAACEClMFUEhnAAAA4B9IYxCGTXjXgjQGAAAAYCamqoGSQRoDAAAA3+eb9ccSqUIigEIaAwAAADCTkGjC4zQGvAAAAIA+/ph6xRHB4/BMFUC5pjPwxRnHPgoMu7REUYweLOqNoms4M0A4KRNbR1qWlnlYc2qB9Mz90rLu5Ueprp+dtpGMlmNLN/QzQZauwOLldqCQTVqWJRmib7XGS7dxODJJO/lnqqLkSMuio4tLy2y2i2Skkgk3BSSlg14IoCKwCQ8AAADATBBAAQAARICrDXjGL3rnv61SpQrFxcXR7bffThs3ymtvZ8+eLWYqSU5OFkvbtm29Pj7sm/A459OqVauocOHCVK5cOcrNzaWdO3fSggULKDbWPass0hgAAACEhy+//JKGDBlCM2bMEMHT1KlTqV27drR3714qXbq0x+NXr15NjzzyCDVp0kQEXJMnT6a7775bzJ9boUIFisgaKL5gfAHXrFlDEyZMoEaNGqlOKIw0BgAAAOGRSPOtt96ifv360RNPPEG1a9cWcUB8fDzNmTNH9fHz5s2jgQMHUr169eiGG26gDz74gBwOB61YsSKob4mgBlDOSYFLlSol/uWaJ65tyg9pDAAAAMwrLS3NbVG7l7OcnBzasmWLaIZzslqt4vf169cX6FiZmZmi1ap4cfkAgUAIiT5QnMKAgy3XBQAAAMxRA1WxYkVKSkrKW7jlSM358+fJbrdTmTJl3Nbz76dPny7Q8xg+fDiVL1/eLQiLqD5QrikL5s+fL/4dOnSojvjPc5h+DUtD1UefpQ1krChpicXiZUiwlxpPiyTtgPdEBd6GH8tTLQCEk/0p32ke5m61Jki3aVa0j7RsfsrVzywtyiQ1lpadSZV/887O1T7UXs9ngrdUBd4+66It7n1WfUtVIGeRHIfFF5L3g7mcdYQC5bSX1zHcHT9+3K1yw1+5GydNmiRiBu4Xxf2hgslUeaAAAADAPxz/+8/ofbKCtg6VLFmSoqKi6MyZM27r+feyZct63faNN94QAdTy5cvp5ptvpmALiSY8AAAA8I1iUUixOAxeFE3nwH2d69ev79YB3NkhvHFjeS3tlClTaPz48bR06VJq0KABmYEpaqA4pcGvv/5K1apVE53JRowY4VaONAYAAADhYciQIdSrVy8RCPHoe05jcPnyZTEqjz3++OMiPYGzHxWnLXj11Vfp888/F7mjnH2lEhISxBLRARRr3749PfzwwyLXQ358EceOHRuU8wIAAAgHih/mwlN07I/v9efOnRNBEQdDnJ6Aa5acHcuPHTsmKlOc3n//fTF678EHH3Tbz+jRo2nMmDFEkR5AFSlSRPyrqPSw5jQGHLE68RBJ7vEPAAAAoWfQoEFiUcMdxF0dORK4gQAhGUB5w735/dWjHwAAIBJwh2+LnzqRRyJTBFBqKQ0AAAAAzMoUAZR+nM/EM2/SAdoSoOPLI2+H44quPXrPxWLcNgDhRlFyvZSq51dzODKkW6xLny0tk+U4KlzoOl25nrxRlGxD+6VYrYVV18dEyYegF4pJkpalZB7SnDvq6me3uurJ96uuP5z6i3xvDvk1apf0orTs57TpquvjYj3nY3O6kn1C1z3BDHyZ/NfbPiMV0hgAAAAAhGIN1IEDB0RPes4qeu+999L997t/A0EaAwAAAN84LA6yWNAHKqxqoHgmZk6QxTMsf/bZZ6ppDFzn2MEIPAAAAKBID6A4dYHFcrWPgvPf/GkMUlNT8xaecwcAAAC0T+Vi9H+RyhRNeP3796dRo0ZRfHy8aiJNpDEAAADwDdIYhGEAVbNmTfr000+DfRoAAAAAoRNAGS0t63jQW0AtFvkQXkWxax5uzYNFAUCudGIjadnZtA2aL50sVQGrW6yn6vodKfq+CFossdKy2Ojiquuzc6/OB6ZO/hmTGF9NdX1Kxk7pNt6OVS35XtX1x9J/k25js12UliUppVTXK4o8XUuOLU1atiLjA2mZouToSFWg557g7TM/cJDGIAz7QAEAAACEElPUQM2dO5dWrVpFtWvXpqioKBo6dKhbOdIYAAAA+MZBdrIYXBvmMEntWkTXQN111100fPhw2rx5Mzkc7r36kcYAAAAAzMQ0AZTNdrV9OzfXczoGpDEAAADwDU/x4+wHZdyiROzLYoomPPbzzz/T9u3bqVGjRmS1usd1SGMAAAAAZmKaAKpHjx7UqVOnYJ8GAABAWMJULsayKJwGPMSkpaWJKV2utkDKhv0DAECky7Utl5bFRLel4OFbr0PMrpGYmBiQe2a15M4UZYkxdN92JZcOXfomIM/DbEzTBwoAAAAgVAS9CW/Pnj00ZswYkY1848aNtHTpUo/HII0BAACAr652/DaWgyJV0GugZs+eTZMnT6ZXX31VdQQeQxoDAAAAMJOgB1BOFotFLGqQxgAAAMA3DsXulyVSBb0Jr2/fvvTyyy9T9erVKTpa/XSQxgAAAADMJOgB1I033khffPGF+PnBBx8M9ukAAACEJUwmHGYBlKuFCxdq3CJKNY1Bu6QXVB+9LPUNMpLFy+WzRsVLy+z2NM37VMh2jetgZAe/kMtsAUCFYspKr0J27mnNfzsx0cnSshpF71Jd//el+TpfCfnfXGJ8LdX1aZl7vezPYmjPDYtFfp1KJNykuv58+p+aj3P1WLGq62Oji+vaX2x0ey+lsuelr1nKYolTXa8oWbr2B+ZmqgCK8Tx4+TORAwAAgG8UspNicNdnJYInEzZNADV37lxavnw5NWjQgAYPHuxWhjQGAAAAvnGIFgmHH/YZmUxV1dOhQweP4IkhjQEAAACYiakCqKvTs3hCGgMAAADfKOI/h8GLErEvi2ma8LxBGgMAAAAwE9MEUL179w72KQAAAIQtReFO5BbD9xmpTBNA6ROlmr28djH1FALLUr29cbRXQ3pLLWCVDMVldlO00kZuxz8IT7n2DB1byf8Ocm3npWXn7YckJfqaM4rEVZWWZWaf0bFHPedh13WTzMhWTxFhtcpTuTgcmV6OlaP59a2U1EJadix1jfxYjgzNKWq8fe4jXUFkCfEACgAAAAoCo/AiMIBCGgMAAAAwE1OMwvv888/pqaeeohdffFEES/khjQEAAIARiTSNXyKVKQKogwcP0s033yxyQPGIu/yQxgAAAMA3iuLwyxKpTBFAjRo1ipo3b04vvfQS7d+/36Ocg6rExES3BQAAACCi+0DNmjVLBE48B16JEiWCfToAAABhB53IwzCA4v5P+thJUTxTE+xLlc18bXTGVHlaBLtD3+zb+rK6Rm4VKkAwyIbu6zWsYk9p2YTD7xl6LIvkc0vvp2OU1bPbxbVSFXhjscSprle8fKYevfQzGUlvvx5Z+gNvqQ8gdJkigAIAAAD/QiLNMOwDxebOnUtLliwJ9mkAAAAAhE4N1Lp16ygz82qVb6dOndzKkAcKAADAmMmEjaRgMuHga9asGZUsWdIjeHLmgRo7dmxQzgsAAADAtE14PAJPBnmgAAAAfIM8UGHahHfLLbfQxIkTyWazUefOnT3yQKkl2AQAAICC4szhRrNH7OU3VQC1YMECjVtxW67nkNwjlpMUGPK3orcht97paZ82/k8CINQ4HFe8lEapro2OTpJuYbelSctybKmaU5tER8mPNXr/OM1D471Tf74sIb6q6vqMK0el2xSJqygty7hyUHV9dFQx6TY2e4q07I7EPqrrD9M26TYOJVdadjZtAwXqMxXpCiKLaQIoAAAA8J+r065Y/LDPyGSaPlAAAAAAocJqthxQ3bt39yjnNAZpaWluCwAAABQcOpGHYQB1LZzGICkpKW+pWFHeHg8AAAAQEQEUj7Dj0Xfs8uXLHuVIYwAAAOD7ZML++C9SmaITecuWLWnYsGF0+PBhSknxHJ2BNAYAAABgJhZFUUJuDDz3geKmvKsVaMaOKACA0BQbU1palpN71tBj2T96WnV91BPvk9FKFr1Ndf359D/JzNfd6GseGqI05EriW6+DUlNTKTExMSD3zITCNclikae40DtBccaVfQF5HmZjihooAAAA8C8OdkJhn6HCFH2gAAAAAEKJKQKoAQMG0IULF8jhcCCNAQAAgB8o4j+HwYsSsa+VKQKohx56SEzjsnLlSmrdurVHOdIYAAAAgJmYIoBq1aoV/frrr7Ro0SLq1q2bRznSGAAAAPgGiTTDsBO51WqlypUr06lTpyg5OdmjHGkMAAAAwExMEUCxyZMn69jKoprGoGxSU9VHn05dp+MY1zq+pMQSIy1TlBwd+4zcdmaAgihdpK607ETKCkMvYsvB8r9vPSoUu1NaVlVRf17rSG8aA+2fMdFRxaRlCXHlVddf1JnGwGKJ1byN98/UQDL3iDR/TPyrYDJhAAAAAAi5GigAAADwHx41Fwr7DBVBDaAGDx5MY8eOpaFDh4rpXOLi4ig6Opo6d+7s9rjs7GyxuGZVBQAAgIJDE14YjcJr1qwZrV27VqR/37ZtG61Zs4ZatGjh8TikMQAAAAAzCWoAxbVOc+bMoRo1aogkmhcvXqTixYt7PA5pDAAAAHyDNAZh1IRXqlQp2r9/P7322muUlZUlgig1SGMAAAAAZhL0TuQ7duwQ/95www3BPhUAAIAw5o8O3w6KVEEPoPwhNetIQI5joSg/zFCNfE8AepxK26B5mzJJjaVlZ1LXS8sSLIVU11utCdJtHI4MadnJlNXSsrPRV79kGkf7Z4zNniItu5j+l6HXVk9Op7uSXpSW/ZL6pub9AURsAAUAAADuMAovDAOor7/+mo4fP061a9emjRs30iuvvOJWjjQGAAAAYCammEy4S5cutG/fPpo5cyYNHz7coxxpDAAAAHxPeumPJVKZIoBSFIVSUlLEpMI2m82jHGkMAAAAfL/XGp/KQInYl8UUTXjTpk2jRx55hMqWLUujRo2iKVOmuJUjjQEAAACYiSkCKJ7Sxal+/fpBPRcAAIDwxKPDLQbvU6FIZVFCsP6N58JLSkoioniyWDzfDBubP6W6XcM1b3vZq57LIE9jkFC4irQs48pB+R6jElXX2+1pus7DIvljUcQfkkzIvSUArnFjMPY9re/v1OjnZY6/08ZJz6iuX5/6rqHHsVhiDU19EHz8+jkoNTVVTGcWiHum1Zqoes/0haIo5HCkBeR5mI0paqAAAAAgEGkMjA+gIpUpOpEPGTKETp48KdIV9OzZ06Oc13ME7boAAAAARHQN1MCBA2nWrFlUrVo16t69u2oag7Fjxwbl3AAAAMKD8TVQZJKm5Iitgbr++uvp1KlT9MMPP1CHDh08ypHGAAAAAMzEFDVQrE2bNvTPP/+IXFD5IY0BAACAj/zQB4oiuA+UKQKo3377jRYvXkwffvhhsE8FAAAAINzTGFj90J4LAKEoLra8tCwr55Shx7K/21d1fdQzH5DRLJLvuQrZdO9Rnd5bgSyNirdUKeHKoqG3DF/v3ICmMSAq5Jc0BkTZSGMAAAAA4QqdyMOuE/mCBQto5MiRIgv5mjVrPMqRxgAAAADMxBR9oB566CGqWLGiCJRatGjhUY40BgAAAL5S/JB1QKFIZYoaKE6i+c4774hASQ3SGAAAAICZmCKAevbZZ0UnujFjxtDu3btV0xhwuesCAAAAWiiG/0cRXANliiY8TmGgxb8DByP3hQMAtXm+ZIz9rEi7Ipu81vjPpKs3qUAcS+/+AnV+oUyRrgv8QHi8LmEVQGmVnp7+v58iO/oFgH9l554M2OVIHvpRAC+9LFgzC2+BK1wrpQPfz66mGPCf2NhYKlu2LJ0+fdov+y9btqw4RqQJyTxQDodDTP1StGhR8ebjDujHjx/3aNrj3BdGlmF/uH54v+BvB58V+Gw04l7gvH+VL19edQYOo2VlZVFOjn+C8djYWIqLi6NIE5I1UPxmu+6668TPzqRg3vpGGV2G/eH64f2Cvx18VuCz0dd7gb9rnlxxgBOJQU7YdyIHAAAACCUIoAAAAAAiLYDiFAejR48W//q7DPvD9cP7BX87+KzAZ6M/7jsQekKyEzkAAABAMIV8DRQAAABAoCGAAgAAANAIARQAAACARhEdQD344IMe686fPy8mL+ayr7/+2q1s0KBBYpk/fz4FC88VOGDAAHF+77//vs/7++mnn+i5556jdu3a0cWLF93K/vzzT6pcuTJduXLFbf3cuXOpU6dONHDgQHr++efdyjhRG89tyNfpqaeeotWrV7ttw49/8skn6dChQ27769ixo3he48eP9ziWs+ybb75xOw6fNx/nmWeeoTlz5rhts2TJEvHznj17xByL+ffpLM9Prcy5jpPfdevWTSRxvda+eH29evXEz7m5ueI6Oh/HZfXr1xcJYV3Pz3ntBg8eTL1796aNGzeqXvdevXrRlClTPK45b8fXll83tW0mT57str9du3ZRjx49xHV03R+/3ny977vvPmrevLn4+eDBg16vbdeuXUWiPrZjxw4aPny4+JmPy++r1NRUKlOmDNlsNjp8+DC98MILovy3336jkSNHip/5ObjOhfnoo4/SP//8I57fQw89lLf/RYsWiXPipU6dOgX+e/T2uuv9vJDh68XX76uvvirwNtc6v++++47Wrl1b4LJr7c/X6xEo/HdSUKHynCA8hGQiTX/im3TLli3FB3Pnzp3dys6dO0cfffQRxcfHS/94q1SpQq1atfLb+d144400Y8YM8aHy+OOP09NPP+1Wvm/fPlq4cCG98sorbutPnDhBn3zyicf6Dh06iIVvRnyTK168eF4ZP37cuHHiJsDHcsWP5xvzY4895rZ+9uzZIuDhfTLXzLfObS5cuCBuoLx/Jw7GuEyNWhkfx3nujG/M/sTBwmeffUazZs2i5OTkAm1Tq1Yt+v333+nMmTPUuHFjt7K6deuK/TVq1Chv3QcffJB37fj5PPDAA/Ttt9+6bee8hlwm2+6RRx5xu3E7t+nevbvbvn7++Wfq2bNn3jV0Kly4sHiPcfC7c+dOEaReC58PBzYc9HAw63xf8t/SmjVrRPJbDj43bdokgqTWrVuL8qZNm9IPP/xAr776KlWrVk28v51ef/11EYhx8Dls2LC8JIB8LF54XzwGxvV5cVA4b948cc379u3rcd2/+OILWrVqFZUuXTovyGNHjx4VgRyv79KlCzVr1izvdedRUzVr1qSMjAy3ffE2b775pjiH6tWriwDWib/c8GtRoUIFt234uY8dO1bsjwPkpUuXupUvWLBArONgc9SoUW5lHIjKMlZ7K+PPrMzMTPFFwxv+/OJrw69/uXLlRODPrz+fE2ea5vJff/1VvE58rBEjRuRte+DAARFM82t077330v333++2z9q1a1NUVBQNHTo0bxtnAC67Frzt8uXLqUGDBm7X9vPPPxfvTc7k/dprr7mNaFu3bp14rsz1M4P3VbJkyby/A2fQzX8bEydOFH/T/GXCuZ6Px68Tny+/h/l5RUdH590T+Ms1f6Hi58Xn7vxcHTJkCL344oviWPz++/TTT/POga/j9u3bxZfW//u//6MWLVp4fT3A/CK6BkoN/4HxH9GHH35If/zxR956/lbNH4Zcg8Lp9ydNmuTxzYg/ZPiPzN/42+Y999wjbpr58YdR/iCJceZ2tfWMnyvf0KpWrZq3jr/tc20c3xC///57j204gOEPiPzBBN/AGjZsmPe72vxIJUqUEB/Ort577z3xYfb22297PN5Ztm3bNo/j8GvAH3b5b/LObfLXPun1xhtviJqaggZPzhoLDio4ULn77rs9yvibsrNWhfHNynnt+H3Egbrdbve47v369RM1O7LteHENKHmbJk2aeAShffr0ETcc/nfmzJnkCw5o+KbCATMHFvw+ZPy+4psdB5IcsPDPHFDxTcmJg7hp06aJGktXPMUFfxnhGyLfRF1xLSDXqE2fPt1tPb/f+JpyAOJ683Li14GDHg6+XP9+3333XRHEcZkzeHJeO/5b5yAq/zQY/B7jYIPfz/z54IqvNf998nV3xcEunzcfK//fAOOa4HfeeUe8pkbg5xUTE3PN4Mn1+Bw882s0YcIEEeDz35pT+/btRWCX//x4G6495ufHXwxc3XXXXeK137x5s9s152vr7VowDu5dgydn7d7NN98s1udPB8CvHQdCsi9j+XHNJgc2K1euzAvqnfvhGj3OFs6fO3w9XAMeDrL5yyr/3bgG4vxlj79k8T0k/xcWPhZ/bvNxEDyFh4gOoPiPQG1SRP62wh/q/M3Eib8JcTMFf3hw4MDBRf5vfPyH6/rhey1cA8MfAidPapsElZsG+FsMf9M2At+k818LvvHzxJMcmPAHBS+u+CbOH5Z8k3MNbLjmbsuWLXm/q829xDVQ+QMr/uDhD2FuxsnPWXbLLbe4HYdvgvwaTJ06VbweatsYFUDxjfqtt95yax67Fr65Mr6Zq9UO8HN1DQD426zz2nEAxIEDf2vPf935xsPvAdl2HFy4BvK8Db9/ly1b5rYvvjnwe5wDaA7KC9JUwgEk18Sys2fP5tVY8jd0rrXgb9auNbdcI3vkyBHRLMhzgHHNENd0Oqe44GNycMLvN7XXims7XAN7xgESXzsONPLfQPl68t9U//7982oi1DingHLiWiRZDQ6/V/l1yP/liM+dv2DwefM11IKPn/8cmHNqD7UyPbhmzDUAuhbn61KqVKm8556dnZ1XXqRIEfFv/uw3/LvznPOfuzOYlwVJsmvB1KY64c9gblp+6aWXaP/+/W5lsteQ3yfO87h8+XLeeg7QuVaN339cQ+rEAT7XpNaoUUO8zlzD51o7z883JSVFHM/1y8r1118v/v64VjV/zS5/zvN79r///a/qOULoiegmPK4B4A9AVytWrBDfRtavX+/WFPfwww+LP1z+g+KggftxcJV+QkLCNY/DNw0+Fn/Td8XNYvmbxlzxOWzdulUEA078DX7x4sXiQ02tBmrv3r2i+cbZr+Ra58D42yR/uPE3VSf+QOGaJw4CuNqZbxCufWg4OOEbMgdDrkEP36y5Gpu35cCMv4U5axt4m19++UXU4OW/WfK3eT4/vkEX5AOGj8PV67wN39jy11DoxddBLckd1wZxjQa/Xtyc5FrL5jx3vtlzmSvuW8Q3B9fmSie+CXBQVqlSpbznxNX/P/74owgyuC9eQTi34w9tDqS45k3t/Lk2gV8XbmJxNlfza8jXj4OwgkxoyjUUHJxw0MxBKwevTk888YSo4eGmDVd8M+ZaGtemTSd+/nxN27ZtK97vfDNzrZ1Sw+8dPrbzPcR/B86A8s477xTvUw5a1fDz5XPn94vr8+W/Md4fB4G8L2fNEX9Z4iCTX9v8+MsF1+ryNtycxIHgtfD+Xn75ZVFD5wxGjCALALnGiNfzMbkmzV/4PcGfj/w+4yZkV1wDy58h/P5zPUfnteAgT0vNPdfwcODE+3J9XzH+ksWvFwc1roE8v6f4b5M/tznwceJ9cBMxBz2utcv8nuVjcBMhB+z5v1xwjSk/T/7Czc/btQ9hmzZtRN+9/K8Hf07y+5LfZ3zfcW2uhtCERJoSXA2dv3+PXty2z9/kXKuIA80M52B2XE3PTTgff/wxFStWjEIRB1Jce+rswA7mwjUZHHTyFw++0XKttq+4RpAHD3C/K+ck62bh2vfIG27S5r6boY4HRXBwxV84OaiG8IYACgAAAECjiO4DBQAAAKAHAigAAAAAjRBAAQAAAGiEAAoAAABAIwRQAAAAABohgAIAAADQCAEUAAAAgEYIoAAAAAA0QgAFAAAAoBECKAAAAACNEEABAAAAaIQACgAAAEAjBFAAEcxisdA333wT7NMAAAg5CKAAQtCYMWOoXr16FM569+5NnTt3DvZpAACoQgAFAIbKyckx1RU12/kAQHhAAAVgsFatWtFzzz1Hw4YNo+LFi1PZsmVFjZGrlJQU6tu3L5UqVYoSExOpdevWtG3bNlF27tw5sc1rr72W9/jff/+dYmNjacWKFTR37lwaO3aseDw3wfHC62TmzJlDderUoUKFClG5cuVo0KBBbuXnz5+nLl26UHx8PNWoUYO+++67vDK73U59+vShqlWrUuHChalWrVo0bdo01ZqiiRMnUvny5cVj2KeffkoNGjSgokWLiufTo0cPOnv2rNu2u3btok6dOolrwI9r3rw5HTx4UFyvjz/+mL799tu857h69WqxzfHjx+mhhx6iYsWKiet7//3305EjR655PgAARoo2dG8AIPDNf8iQIbRhwwZav369uKk3bdqU7rrrLlHerVs3EZD89NNPlJSURDNnzqQ2bdrQvn37RFDFQQ8HAXfffbcIAHr27CkCH37MlStXaOfOnbR06VJavny52B/vQ837778vzmPSpEnUoUMHSk1Npd9++83tMRyMTZkyhV5//XV6++236dFHH6WjR4+K4MThcNB1111HX331FZUoUUIEck899ZQIxDiIceLAjoOgX375JW9dbm4ujR8/Xpw/B058HnwdfvzxR1F+8uRJatGihQg4V65cKbbnc7PZbDR06FDavXs3paWl0UcffSQez+fD+2zXrh01btyY1q5dS9HR0TRhwgRq3749bd++XQSZsvMBADCUAgCGatmypdKsWTO3dQ0bNlSGDx8ufl67dq2SmJioZGVluT2mevXqysyZM/N+HzhwoFKzZk2lR48eSt26dd0eP3r0aOWWW2655rmUL19eGTFihLScPwJGjhyZ93tGRoZY99NPP0m3eeaZZ5QHHngg7/devXopZcqUUbKzs72ey6ZNm8S+09PTxe//+c9/lKpVqyo5OTmqj+f93n///W7rPv30U6VWrVqKw+HIW8fHLVy4sLJs2TJN5wMA4AvUQAH4wc033+z2O9fYOJuvuOktIyND1Oi44polbr5yeuONN+imm24StT9btmwRTXBa8PFOnTolaq0Keq5FihQRNTeuTW3vvvuuqBE7duyYOEfuU5S/A3vdunXzan+c+Jy5KY6f76VLl0RtFuP91K5dm/766y/RZBcTE1Pg58T7OnDggGjuc5WVleV27dTOBwDASAigAPwgf1DAfXicAQQHTxxQOfv0uOJ+PU4cEHAAxNtxHx8OCrTgJkJfz3X+/PmiOe3NN98UzWYcuHBTHzdNuuLAy9Xly5dFUxsv8+bNE82SHDjx785O3QU9P1d87erXry/2mR8fQ3Y+AABGQwAFEGC33XYbnT59WvTfqVKliupjOMh47LHH6OGHHxZ9iLjD+Y4dO6h06dKinGtXuIO3Nxzs8P65P9Cdd96p61y5T1KTJk1o4MCBeetca3pk9uzZQxcuXBB9rypWrCjWbd682aPmi/uKcb8mtVootefI1+7LL78U14FrygAAggWj8AACrG3btqI2hzuJ//zzz6J2iTtnjxgxIi/I4J+5w/f06dNp+PDhVLNmTXryySfz9sGB0eHDh0UzGI+iy87OVj0WN6Fx7RHvZ//+/fTnn3+KjuIFxaPy+JyWLVsmOriPGjWKNm3adM3tKlWqJAIgPtahQ4fEyD7uUO6KO8VzJ/Hu3buLY/D58ci9vXv35j1H7hjOv/Nz5ECLO7iXLFlSjLzjTuR8Dbgmj0c9njhxosDPCwDAVwigAAKMm8h4JBqPQHviiSdEcMRBBI98K1OmjAgIpk6dKoIJrmWxWq3iZw4YeFQde+CBB8TIM65Z4qarL774QvVYvXr1Evt67733RCoDThnAgUpB9e/fn7p27Spqwm6//XZRq+RaGyXD58SpFbj/Fvd34poo7tPlivuA8eg7bpZr2bKlaJqbPXt2Xm1Uv379RO0bp0Lg/XFtGKdaWLNmjQjQ+LxuvPFGkWaB+0ChRgoAAsnCPckDekQAAACAEIcaKAAAAACNEEABAAAAaIQACgAAAEAjBFAAAAAAGiGAAgAAANAIARQAAACARgigAAAAADRCAAUAAACgEQIoAAAAAI0QQAEAAABohAAKAAAAgLT5f755sjHQr4YuAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 700x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after     'q': most likely next char is  'u'  (p = 0.99)\n",
      "after     '.': most likely next char is '\\n'  (p = 0.87)\n",
      "after   space: most likely next char is  't'  (p = 0.15)\n"
     ]
    }
   ],
   "source": [
    "# Same table as before, now trained. Turn each row into next-char probabilities and look.\n",
    "P = softmax(W, axis=1)\n",
    "\n",
    "plt.figure(figsize=(7, 6))\n",
    "plt.imshow(P, cmap=\"magma\", aspect=\"auto\")\n",
    "plt.colorbar(label=\"P(next char | current char)\")\n",
    "plt.xticks(range(vocab_size), [itos[i] for i in range(vocab_size)], fontsize=5)\n",
    "plt.yticks(range(vocab_size), [itos[i] for i in range(vocab_size)], fontsize=5)\n",
    "plt.xlabel(\"next character\"); plt.ylabel(\"current character\")\n",
    "plt.title(\"what the trained bigram learned\"); plt.show()\n",
    "\n",
    "# Read a few rows back in plain English -- the model was never told any of this.\n",
    "for c in [\"q\", \".\", \" \"]:\n",
    "    r = P[stoi[c]]; j = int(r.argmax())\n",
    "    name = \"space\" if c == \" \" else repr(c)\n",
    "    print(f\"after {name:>7}: most likely next char is {itos[j]!r:>4}  (p = {r[j]:.2f})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3learn03",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>P = softmax(W, axis=1)</code>: turn every row of the trained table into a clean probability distribution over the next character (<code>axis=1</code> normalises along each row).</li>\n",
    "<li><code>plt.imshow(P, cmap=\"magma\")</code>: draw the 65&times;65 table as an image -- dark = unlikely, bright = likely. The single brightest cell in the whole grid is row 'q', column 'u'.</li>\n",
    "<li><code>plt.xticks / plt.yticks</code>: label the axes with the actual characters instead of raw ids, so you can read the structure straight off the picture.</li>\n",
    "<li>The loop prints the top prediction for three rows: 'q' -&gt; 'u' almost certainly, '.' -&gt; a newline (sentences end lines), and a space -&gt; a common word-starting letter. Compare that to the flat 'q' row we printed before training.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7258312a",
   "metadata": {},
   "source": [
    "## The ceiling: how good can a bigram ever get?\n",
    "\n",
    "Here is a question worth pausing on: if we trained forever, how low could this loss go? Not to zero. Even a perfect bigram is stuck guessing from a single character, and one character genuinely does not determine the next one, since after a space almost anything can follow. That leftover, unavoidable uncertainty sets a hard floor under the loss.\n",
    "\n",
    "We can compute that floor directly, with no training at all: count every neighbouring pair of characters in the text, turn the counts into exact probabilities, and measure their average surprise (the cross-entropy from notebook 01). The answer comes out at about `2.45` nats, which is exactly where the training curve flattened out. (A *nat* is just the unit this kind of loss is measured in when the natural logarithm is used; the number itself is what matters.) The little model is not being lazy; it has learned everything that one character of context can teach.\n",
    "\n",
    "This idea, that a model's loss floor is set by how much context it can see, is the strongest single argument for attention, and it is where the course is heading next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "55813196",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:41:01.774046Z",
     "iopub.status.busy": "2026-07-01T08:41:01.773982Z",
     "iopub.status.idle": "2026-07-01T08:41:01.805138Z",
     "shell.execute_reply": "2026-07-01T08:41:01.804737Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bigram optimum on this text: 2.4526 nats\n",
      "our trained model sits essentially at this ceiling -- the only way past it is more context\n"
     ]
    }
   ],
   "source": [
    "# Count every adjacent pair of characters in the data, turn each row of counts into\n",
    "# probabilities, and measure the loss of those PERFECT bigram probabilities.\n",
    "# No model that sees only one character of context can ever beat this number --\n",
    "# it is the built-in uncertainty of \"next char given current char\" on this text.\n",
    "counts = np.zeros((vocab_size, vocab_size))\n",
    "np.add.at(counts, (data[:-1], data[1:]), 1)\n",
    "p = counts / np.maximum(counts.sum(axis=1, keepdims=True), 1)\n",
    "row_weight = counts.sum(axis=1) / counts.sum()            # how often each char occurs\n",
    "with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n",
    "    row_entropy = -np.nansum(np.where(p > 0, p * np.log(p), 0.0), axis=1)\n",
    "optimum = float(np.nansum(row_weight * row_entropy))\n",
    "print(f\"bigram optimum on this text: {optimum:.4f} nats\")\n",
    "print(\"our trained model sits essentially at this ceiling -- the only way past it is more context\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d471bd",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>counts = np.zeros((65, 65))</code>: a grid of zeros; <code>counts[a, b]</code> will tally \"how many times did character b follow character a?\"</li>\n",
    "<li><code>np.add.at(counts, (data[:-1], data[1:]), 1)</code>: walk every adjacent pair in the book in one shot (all-but-last paired with all-but-first) and add 1 in the matching slot.</li>\n",
    "<li><code>p = counts / np.maximum(counts.sum(axis=1, keepdims=True), 1)</code>: turn each row of tallies into fractions that sum to 1: the true next-character probabilities. <code>np.maximum(..., 1)</code> avoids dividing by zero for a character that never has a follower.</li>\n",
    "<li><code>row_weight = counts.sum(axis=1) / counts.sum()</code>: how often each character actually occurs, so common characters count more in the average.</li>\n",
    "<li><code>row_entropy = -np.nansum(np.where(p > 0, p * np.log(p), 0.0), axis=1)</code>: the average surprise for each current-character (notebook 01's cross-entropy), with zero-probability slots safely treated as zero surprise.</li>\n",
    "<li><code>optimum = np.nansum(row_weight * row_entropy)</code>: the weighted average: <b>2.4526</b>. No one-character model, trained or not, can beat this floor.</li>\n",
    "<li><code>np.errstate(...)</code>: housekeeping that silences harmless \"log of zero\" warnings.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5ceil01",
   "metadata": {},
   "source": [
    "### The whole story in one plot\n",
    "\n",
    "We now have three numbers on the same scale: the random starting loss `ln(65) = 4.17`, our trained bigram's `2.46`, and the perfect bigram ceiling `2.45`. Drawing all three on the training curve shows the entire arc at a glance -- the loss dives off the random line and then settles right onto the ceiling, with essentially no gap left to close."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e5ceil02",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:41:01.806164Z",
     "iopub.status.busy": "2026-07-01T08:41:01.806110Z",
     "iopub.status.idle": "2026-07-01T08:41:01.840208Z",
     "shell.execute_reply": "2026-07-01T08:41:01.839858Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 650x320 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gap left between our model and the perfect bigram: +0.0087 nats\n",
      "essentially zero -- one character of context has nothing left to give\n"
     ]
    }
   ],
   "source": [
    "# Put the training curve and the two reference levels on one axis.\n",
    "plt.figure(figsize=(6.5, 3.2))\n",
    "plt.plot(losses, color=\"#5b5bd6\", label=\"training loss\")\n",
    "plt.axhline(np.log(vocab_size), color=\"#999\", ls=\":\", label=f\"random start = {np.log(vocab_size):.2f}\")\n",
    "plt.axhline(optimum, color=\"#e5484d\", ls=\"--\", label=f\"bigram ceiling = {optimum:.2f}\")\n",
    "plt.xlabel(\"step\"); plt.ylabel(\"loss\"); plt.legend()\n",
    "plt.title(\"the loss falls from random and settles on the ceiling\"); plt.show()\n",
    "\n",
    "gap = float(np.mean(losses[-200:])) - optimum\n",
    "print(f\"gap left between our model and the perfect bigram: {gap:+.4f} nats\")\n",
    "print(\"essentially zero -- one character of context has nothing left to give\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5ceil03",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>plt.plot(losses)</code>: the same training curve as before -- loss on the y-axis, step on the x-axis.</li>\n",
    "<li><code>plt.axhline(np.log(vocab_size), ls=\":\")</code>: a dotted line at 4.17, where an untrained model starts (pure guessing over 65 characters).</li>\n",
    "<li><code>plt.axhline(optimum, ls=\"--\")</code>: a dashed line at 2.45, the perfect-bigram ceiling we just computed from the raw counts.</li>\n",
    "<li>The curve dives off the dotted line and then rides along the dashed one: the model learned everything a single character of context allows, then stopped.</li>\n",
    "<li>The final print measures the leftover gap between our trained model and that ceiling -- it comes out essentially zero.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "590761ef",
   "metadata": {},
   "source": [
    "## Generate text\n",
    "\n",
    "Generating text is a loop of \"predict, draw at random, feed the result back in\":\n",
    "\n",
    "1. start from a character and read off its next-character probabilities,\n",
    "2. **draw** a character from that set of probabilities. We *sample* (in effect rolling a weighted die) rather than always taking the single most likely character, so the text does not get stuck repeating itself,\n",
    "3. feed that new character back in as the context, and repeat.\n",
    "\n",
    "This style, in which each output is fed back in as the next input, is called **autoregressive** generation, and it is exactly how ChatGPT writes as well, one token at a time. The result here is gibberish with some structure: the model has learned which characters tend to follow which (a `q` pulls in a `u`, capital letters follow newlines, vowels and consonants alternate), but with only one character of memory it cannot assemble real words. That precise limitation is what attention fixes in notebook 05."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "23bfd438",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-01T08:41:01.841288Z",
     "iopub.status.busy": "2026-07-01T08:41:01.841230Z",
     "iopub.status.idle": "2026-07-01T08:41:01.846387Z",
     "shell.execute_reply": "2026-07-01T08:41:01.846049Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tha ETorness\n",
      "V:\n",
      "\n",
      "Whan ashe ysisin se myone omes p, t t hanof il omilte pthund: wend's.\n",
      "Ro'stu twobyoun, wares sh s\n",
      "STo t hethalof firor.\n",
      "Thuirer it ter\n",
      "D r, w's heayimatoray busiuthoifou ithe me y!\n",
      "Tur?\n",
      "PEROr mod Pe ithout TAnghas sano n thy winorit te yordo sprGofane i! t stwndvorounouepo id jor witor serery bend--makneat s bonct m buse n soth d, yockifastalore T:\n",
      "\n",
      "n ld thid me ct tindisthitigo in\n"
     ]
    }
   ],
   "source": [
    "def generate(start, n=400, seed=0):\n",
    "    rng = np.random.default_rng(seed)\n",
    "    idx = stoi[start]; out = [idx]\n",
    "    for _ in range(n):\n",
    "        p = softmax(W[idx])\n",
    "        idx = int(rng.choice(vocab_size, p=p))\n",
    "        out.append(idx)\n",
    "    return decode(out)\n",
    "\n",
    "print(generate(\"T\", 400))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70d4cec8",
   "metadata": {},
   "source": [
    "<details class=\"code-read\"><summary>Line by line: what each line does</summary>\n",
    "<ul>\n",
    "<li><code>def generate(start, n=400, seed=0):</code>: write text starting from a character; <code>seed</code> makes the dice rolls repeatable.</li>\n",
    "<li><code>idx = stoi[start]; out = [idx]</code>: look up the starting character's id and begin the output list with it.</li>\n",
    "<li><code>for _ in range(n):</code>: repeat n times (the <code>_</code> means \"loop counter unused\").</li>\n",
    "<li><code>p = softmax(W[idx])</code>: the model's probabilities for what follows the current character.</li>\n",
    "<li><code>idx = int(rng.choice(vocab_size, p=p))</code>: the dice roll: pick one of the 65 ids <i>according to those probabilities</i> (likely characters come up often, unlikely ones rarely).</li>\n",
    "<li><code>out.append(idx)</code>: record the pick, then loop -- feeding each new character back in as context. That feed-back-in is autoregeneration.</li>\n",
    "<li><code>decode(out)</code>: ids back to text so you can read what it wrote.</li>\n",
    "</ul>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eb2f9c5",
   "metadata": {},
   "source": [
    "## Recap\n",
    "\n",
    "You built and trained a real, if tiny, language model, worked out its gradient by hand, and sampled text from it. The skeleton (forward, loss, backward, update, generate) never changes from here; only the model in the middle grows more capable.\n",
    "\n",
    "Two obstacles stand in the way next:\n",
    "1. Writing gradients by hand will not scale to a deep network, so notebook 04 builds **autograd**, which works them out for us.\n",
    "2. One character of context is hopeless, so notebook 05 introduces **attention**, which lets a token look back over the whole context."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (.venv)",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}