{ "cells": [ { "cell_type": "markdown", "id": "cdaf235fd", "metadata": {}, "source": [ "# Chapter 41: Pretraining \u2014 BERT and GPT\n", "\n", "You have built a Transformer. In Chapter 40 you trained it end-to-end on the string-reversal task that has carried us from Chapter 36 onward. It works. It is also, in a strict sense, useless: the model knows nothing except how to reverse strings, and there is no obvious way to apply that skill to anything else.\n", "\n", "The question this chapter answers is the one Chapter 40 left open: **how does this become ChatGPT?**\n", "\n", "The answer is not architectural. The Transformer that powers GPT-4 is \u2014 in almost every detail that matters for this chapter \u2014 the model you built in Chapter 40. What changed between 2017 and 2018 is not the architecture but **what the architecture is asked to do**. Two papers, published within five months of each other, made the same observation: instead of training a fresh Transformer on each downstream task, *pretrain* one model on raw text using a self-supervised objective, then fine-tune that single model on whichever task you actually care about.\n", "\n", "The two papers chose two different self-supervised objectives, and that single choice cascaded into everything else:\n", "\n", "- **Radford, Narasimhan, Salimans, Sutskever** (2018), *Improving Language Understanding by Generative Pre-Training*, OpenAI Technical Report \u2014 chose **causal** language modeling (predict the next token from the left context). The resulting model is **GPT**.\n", "- **Devlin, Chang, Lee, Toutanova** (2019), *BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding*, NAACL 2019 (arXiv:1810.04805) \u2014 chose **masked** language modeling (predict a randomly hidden token from the bidirectional context). The resulting model is **BERT**.\n", "\n", "By the end of this chapter you will have built both, trained them on the same Shakespeare corpus, and watched them diverge from a shared architectural skeleton into two qualitatively different kinds of model. The thesis you should carry away is the one this chapter is built around:\n", "\n", "> **The mask matrix is the worldview.**\n", "\n", "GPT and BERT differ \u2014 pedagogically, philosophically, almost everywhere \u2014 by a single line of code in the attention layer.\n" ] }, { "cell_type": "markdown", "id": "cc10ac437", "metadata": {}, "source": [ "## 41.1 From Task-Specific to General-Purpose Models\n", "\n", "The model you trained in Chapter 40 is task-specific. It saw 3500 string-reversal examples during training, and the only thing it learned to do is map a source string to its reverse. If you handed it a sentiment-classification task, you would have to throw away the trained weights and start over.\n", "\n", "This is wasteful for two reasons. The first is **data**. Labeled translation pairs are scarce; labeled sentiment-annotated reviews are scarce; labeled-anything is scarce. Raw text \u2014 Wikipedia, scraped web pages, books in the public domain \u2014 is effectively infinite. There is roughly four orders of magnitude more *unlabeled* text in the world than *labeled* text for any specific task. The second is **inductive structure**. Most of what a sentiment classifier needs to know is what a verb is, what a negation is, what a name is, what a clause boundary is \u2014 and all of that is recoverable from unlabeled text. Training a sentiment classifier from scratch is asking the model to learn the structure of English alongside the much narrower question of \"is this review positive?\". A sentiment-classification dataset of a few thousand examples is enough to learn the *task* but nowhere near enough to learn the *language*.\n", "\n", "### The pretraining hypothesis\n", "\n", "The pretraining hypothesis is the proposal that resolves both problems at once:\n", "\n", "1. Pre-train a model on a **self-supervised** objective derived purely from raw text \u2014 no human labels.\n", "2. Fine-tune that model on whatever small labeled dataset you actually care about.\n", "\n", "Self-supervised means the supervision signal is constructed from the input itself. For text the canonical choice is *predict missing tokens given context*. Both GPT and BERT pick a missing-token objective; they disagree on which tokens to hide and how.\n", "\n", "### Historical precedent \u2014 three steps to BERT and GPT\n", "\n", "The pretraining idea did not appear out of nowhere in 2018. Three earlier works set the stage.\n", "\n", "| Year | Model | Idea | Limitation |\n", "|---|---|---|---|\n", "| 2013 | **word2vec** (Mikolov et al.) | Distributed token representations from raw text | Single vector per word \u2014 no context |\n", "| 2018 | **ELMo** (Peters et al.) | *Contextualised* token representations from a bidirectional LSTM-LM | Representations are extracted features, not the model itself; downstream task gets its own architecture |\n", "| 2018 | **ULMFiT** (Howard & Ruder) | Pretrain a language model, then fine-tune the *whole network* on the downstream task | LSTM-based; predates the Transformer |\n", "\n", "Both GPT and BERT inherit ULMFiT's full-network fine-tuning recipe and apply it to the Transformer. ELMo's bidirectionality argument is what motivates BERT's masked objective specifically. The chain of inheritance is direct.\n", "\n", "```{admonition} Cross-reference\n", ":class: tip\n", "\n", "This chapter assumes you have built and trained the Transformer of Chapter 40. We will not redefine multi-head attention, positional encodings, or the encoder/decoder block. The `part12_pretraining.utils` module re-exports those pieces with identical semantics so we can extend \u2014 not rebuild \u2014 the Chapter 40 architecture.\n", "\n", "We also lean on:\n", "- **Cross-entropy + maximum likelihood** (\u00a726.2) \u2014 to derive both pretraining objectives.\n", "- **Softmax saturation** (\u00a717.5, \u00a738.3) \u2014 to motivate temperature sampling later in the chapter.\n", "- **Bidirectional RNNs** (\u00a736.4) \u2014 the philosophical ancestor of BERT's bidirectional context.\n", "- **Character-level language modeling** (Ch 35) \u2014 we reuse `shakespeare.txt` as our corpus so the comparison is direct.\n", "- **Unsupervised feature extraction** (\u00a713 Oja's rule + PCA) \u2014 the same idea, two decades older.\n", "```\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "c2fbd5f3b", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:04:46.235892Z", "iopub.status.busy": "2026-05-20T10:04:46.235749Z", "iopub.status.idle": "2026-05-20T10:04:48.110253Z", "shell.execute_reply": "2026-05-20T10:04:48.109857Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PyTorch: 2.7.0\n", "Device: cpu\n" ] } ], "source": [ "# Setup. We extend, not rebuild \u2014 the Transformer building blocks come from\n", "# Chapter 40 via part12_pretraining/utils.py.\n", "import sys, os; sys.path.insert(0, os.path.abspath('.'))\n", "import math, time, random\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "from utils import (\n", " Config, CharTokenizer, TransformerBlock,\n", " causal_mask, sinusoidal_positional_encoding,\n", " load_shakespeare, sample_batch, count_params,\n", ")\n", "\n", "torch.manual_seed(0); random.seed(0)\n", "device = torch.device('cpu')\n", "print('PyTorch:', torch.__version__)\n", "print('Device:', device)\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "c73f906ff", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:04:48.112054Z", "iopub.status.busy": "2026-05-20T10:04:48.111898Z", "iopub.status.idle": "2026-05-20T10:04:48.126536Z", "shell.execute_reply": "2026-05-20T10:04:48.126262Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Corpus : 80,000 chars, 62 unique tokens (incl. [MASK])\n", "Train / val : 72,000 / 8,000 tokens\n", "First 200 chars:\n", "First Citizen:\n", "Before we proceed any further, hear me speak.\n", "\n", "All:\n", "Speak, speak.\n", "\n", "First Citizen:\n", "You are all resolved rather to die than to famish?\n", "\n", "All:\n", "Resolved. resolved.\n", "\n", "First Citizen:\n", "First, you\n" ] } ], "source": [ "# Load the corpus and the tokeniser\n", "text = load_shakespeare(max_chars=80_000)\n", "tok = CharTokenizer(text)\n", "data = tok.encode(text)\n", "\n", "n = int(0.9 * len(data))\n", "train_data, val_data = data[:n], data[n:]\n", "\n", "print(f'Corpus : {len(text):,} chars, {tok.vocab_size} unique tokens (incl. [MASK])')\n", "print(f'Train / val : {len(train_data):,} / {len(val_data):,} tokens')\n", "print(f'First 200 chars:')\n", "print(text[:200])\n" ] }, { "cell_type": "markdown", "id": "cd4537281", "metadata": {}, "source": [ "## 41.2 The Causal Language Modeling Objective (GPT Lineage)\n", "\n", "Both GPT and BERT define their pretraining objective as a cross-entropy loss over the vocabulary at certain positions; they differ in *which* positions and *what context* the model is allowed to see when predicting them. We start with GPT \u2014 it is the more direct extension of the autoregressive seq2seq model from Chapter 36.\n", "\n", "### Derivation: the autoregressive log-likelihood\n", "\n", "Let $x_{1:T} = (x_1, x_2, \\ldots, x_T)$ be a token sequence drawn i.i.d. from the empirical distribution of the corpus. The chain rule of probability decomposes the joint distribution exactly:\n", "\n", "$$\n", "p_\\theta(x_{1:T}) \\;=\\; \\prod_{t=1}^{T} p_\\theta(x_t \\mid x_{ i \\end{cases},\n", "\\qquad\n", "A = \\mathrm{softmax}\\!\\Bigl(\\tfrac{QK^\\top}{\\sqrt{d_k}} + M\\Bigr) V.\n", "$$\n", "\n", "Since $e^{-\\infty} = 0$, every future position is zeroed out of the softmax. Position $i$ literally cannot see positions $j > i$. The chain-rule factorisation is then a mathematical truth about the model, not just an assumption.\n", "\n", "```{admonition} Definition (causal LM loss)\n", ":class: note\n", "\n", "For a parameterised Transformer $f_\\theta$ that maps a sequence $x_{1:T}$ to a tensor of per-position vocabulary logits $z_{t,v}$, with all self-attention layers using the causal mask above, the **causal language modeling loss** is\n", "\n", "$$\n", "\\boxed{\\;\\mathcal{L}_{\\text{CLM}}(\\theta) \\;=\\; -\\frac{1}{T}\\sum_{t=1}^{T} \\log\\, \\mathrm{softmax}(z_{t})_{x_t}\\;}\n", "$$\n", "\n", "This is identical to the next-token cross-entropy you implemented for the char-RNN in Chapter 35. The only difference is the architecture computing the logits.\n", "```\n", "\n", "### Architecture choice: decoder-only\n", "\n", "A causal language model needs no encoder. There is no separate \"source\" sequence to attend over \u2014 there is only the running prefix $x_{" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "@torch.no_grad()\n", "def perplexity(model, data_tensor, block=48, n_batches=20, batch=64):\n", " model.eval()\n", " nll = 0.0; ntok = 0\n", " for _ in range(n_batches):\n", " x, y = sample_batch(data_tensor, block, batch, device)\n", " logits = model(x)\n", " loss = F.cross_entropy(logits.reshape(-1, model.cfg.vocab_size),\n", " y.reshape(-1), ignore_index=tok.MASK_ID,\n", " reduction='sum')\n", " nll += loss.item(); ntok += y.numel()\n", " return math.exp(nll / ntok)\n", "\n", "print(f'GPT val perplexity (after training): {perplexity(gpt, val_data):.2f}')\n", "\n", "fig, ax = plt.subplots(figsize=(9, 3.5))\n", "smooth = np.convolve(gpt_losses, np.ones(20) / 20, mode='valid')\n", "ax.plot(smooth, color='#4f46e5', lw=2)\n", "ax.set(xlabel='step', ylabel='train loss (next-token CE)',\n", " title=f'GPT-like training on Shakespeare (final loss = {gpt_losses[-1]:.3f})')\n", "ax.grid(alpha=0.3); plt.tight_layout(); plt.show()\n" ] }, { "cell_type": "markdown", "id": "c27b708a7", "metadata": {}, "source": [ "### Generation: autoregressive sampling\n", "\n", "Once a causal LM is trained, generation is one feedforward call per token: feed the prefix, take the logits at the last position, sample a token, append it, repeat. Three knobs control the sampling:\n", "\n", "1. **Temperature** $\\tau$ \u2014 scale the logits by $1/\\tau$ before softmax. $\\tau \\to 0$ becomes argmax (deterministic, repetitive); $\\tau \\to \\infty$ becomes uniform random.\n", "2. **Top-$k$** \u2014 keep only the $k$ most-probable tokens; renormalise; sample from those.\n", "3. **Top-$p$** (nucleus) \u2014 keep the smallest set of tokens whose cumulative probability is at least $p$; sample from that set.\n", "\n", "We implement the first two below and use them in the static applet that follows.\n", "\n", "```{admonition} Cross-reference \u2014 why temperature, again?\n", ":class: tip\n", "The temperature trick is exactly the inverse-temperature softmax from \u00a717.5 and \u00a738.3. At $\\tau \\to 0$ the softmax becomes the one-hot argmax; at $\\tau \\to \\infty$ it becomes uniform. We are not introducing a new operation, only varying its parameter.\n", "```\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "c46ce8a1c", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:05:15.398497Z", "iopub.status.busy": "2026-05-20T10:05:15.398291Z", "iopub.status.idle": "2026-05-20T10:05:16.239249Z", "shell.execute_reply": "2026-05-20T10:05:16.238858Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Prompt: 'ROMEO:'\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "--- temperature = 0.5 ---\n", "ROMEO:\n", "Not stay make o' well the dows the shall trunke anke p ckeaneseshandouthese ars,\n", "\n", "\n", "\n", "He ad condearelllishare f ce an ore anditoushasin t cct angh ande hifarishale ht ad\n", "Ingh an adi\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "--- temperature = 0.8 ---\n", "ROMEO:\n", "Not stame as a lakeive the ows prove, he thadisthade p chim h an anddoose timalind ce m'decorinie henoshars f ce;\n", "Thore w, aloushasin thenount f m he hin arshallore beadist t iad\n", "\n", "\n", "--- temperature = 1.0 ---\n", "ROMEO:\n", "Not stame as a lakeive the ows come, not. G Yowse I Marckeanomareasharce' ct al--s ous tanovameashagnthar,\n", "He cious or ow, anofulllin dde cknt m me e arequichalethivemadirrst ias,\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "--- temperature = 1.3 ---\n", "ROMEO:\n", "Kt is the venceld eived: yours voice, he tr disshadeastcdimyomabm\n", "Wl coevest alinstousmomoushidaed g anar,' f cioncnorqus,\n", "I thulldinad cchunear m, busin aich, chadube\n", "In'dut imou\n", "\n" ] } ], "source": [ "@torch.no_grad()\n", "def generate(model, prompt_ids, max_new=200, temperature=1.0, top_k=None, rng=None):\n", " model.eval()\n", " rng = rng or torch.Generator(device='cpu').manual_seed(0)\n", " out = prompt_ids.clone().to(device)\n", " for _ in range(max_new):\n", " ctx = out[-(model.cfg.max_len - 1):]\n", " logits = model(ctx.unsqueeze(0))[0, -1] / temperature\n", " if top_k is not None:\n", " topv, topi = torch.topk(logits, top_k)\n", " probs = torch.zeros_like(logits)\n", " probs[topi] = F.softmax(topv, dim=-1)\n", " else:\n", " probs = F.softmax(logits, dim=-1)\n", " nxt = torch.multinomial(probs, 1, generator=rng).item()\n", " out = torch.cat([out, torch.tensor([nxt], device=device)])\n", " return out\n", "\n", "prompt = 'ROMEO:'\n", "print(f'Prompt: {prompt!r}\\n')\n", "prompt_ids = tok.encode(prompt)\n", "\n", "for tau in [0.5, 0.8, 1.0, 1.3]:\n", " rng = torch.Generator().manual_seed(7)\n", " out = generate(gpt, prompt_ids, max_new=180, temperature=tau, top_k=None, rng=rng)\n", " print(f'--- temperature = {tau} ---')\n", " print(tok.decode(out))\n", " print()\n" ] }, { "cell_type": "markdown", "id": "caf36dbfa", "metadata": {}, "source": [ "**Static applet \u2014 next-token distribution under temperature.**\n", "We freeze a fixed prompt and visualise the next-token distribution at four temperature settings. This is the static-HTML rendering of what would be an `ipywidgets` slider in a live notebook: rather than scrubbing a slider, the reader sees the four representative regimes in one figure." ] }, { "cell_type": "code", "execution_count": 7, "id": "cfcd1a95a", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:05:16.241169Z", "iopub.status.busy": "2026-05-20T10:05:16.241022Z", "iopub.status.idle": "2026-05-20T10:05:16.557088Z", "shell.execute_reply": "2026-05-20T10:05:16.556816Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAF7CAYAAACpV6kmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABvP0lEQVR4nO3deXhTZf738U+aLpSlLUvLZmnZFFCgCCqISHEBdQSFUXEQpajjBgKCo/bnKAgKqLh0VFyQoSiKCoyoyMi4AK5oRaoiyF4oCiICLWuB5n7+4CE2tKVJc9LkNO/XdeW6yFm/587JJ+2X0xOHMcYIAAAAAAAAABASIoJdAAAAAAAAAADgTzRtAQAAAAAAACCE0LQFAAAAAAAAgBBC0xYAAAAAAAAAQghNWwAAAAAAAAAIITRtAQAAAAAAACCE0LQFAAAAAAAAgBBC0xYAAAAAAAAAQghNWwAAAAAAAAAIITRtAQBhZdy4cXI4HO7Hu+++6zE/IyPDPe+FF14IeD179uzRuHHjNG7cOGVnZ/u0bl5ennvd+fPn+1VHXl6e+7jT09P92lZVKvl6lhy/1NRU9/TKbnfcuHF6+umnfV63vLEsr1arLFmyxF13bm5uqfn+jomVDhw4oOHDh6tZs2aKioqSw+FQWlqaJLlrTE1NrfT2s7Oz3WOxZ88en+fDv2yCNH/+fPf45eXlBbscS5T8fFyyZEmwywEAoNqLDHYBAAAE0/3336/LL79cERHB+X/MPXv26KGHHpIk9ezZUxkZGV6vm5eX5153yJAhuvLKKwNQYXg6Pq4pKSkaNWpUcIvx0pIlS9x1p6amupugoWjChAl67rnnArb97OxsLV26VNKxRlNCQoJP8+FfNuFY03bmzJmSpPT0dL/+EwIAAIQnrrQFAIS1lStX6vXXXw92GbBYXl6ejDEyxlTpfg8ePKjU1FT3vkPparRgjUlZli9f7v734sWLZYwp8+pgINhcLpeKioqCXUa5Dhw4UGX7yM7OdmeInf4iAwAAu6JpCwAIW06nU5I0duxYHTlypMLlN23apFtvvVUtWrRQTEyM4uLidP7552vOnDnuZYqKitS5c2c5HA45nU598cUXkiRjjPr06eP+09K5c+cqIyNDzZs3d6+7dOlSr29RkJ6erl69ermfz5w5071uySvi1q9fr5tuukmpqamKjo5WXFyczj33XE2bNs2r5t2LL76oiIgIORwOnX766frll1+8Hgvp2NWfJet67bXX1LFjR8XGxqp169Z66qmnvG4ivvTSSzrttNMUExOj00477aS3ryjvVgCPP/64OnbsqFq1aik6OlqNGjXSeeedpwcffFDSn7cwOG7z5s2l/lw/OzvbPW3s2LF67LHH1KpVK0VGRurNN9/06lYTxcXFevjhh5WamqqYmBh16NBB8+bN81gmPT3dvZ2Sf15d1m0WHA6H+6pISRo6dGipZcobk8OHD2vKlCnq3LmzateurRo1aqh169YaMWKEtm/fXm5NX331lYYMGaL69esrISFBl156qTZs2FDuayL9eT58+OGH7mm9evUqdd6eaNu2bbruuut0+umnq379+oqKilJcXJy6dOmiJ598UkePHvXY/vGraCWpefPmHmNxsvnHx9kYo+zsbJ1//vlKSEhQdHS0UlNTNWzYML/HZMGCBerZs6fq1q2ryMhI1a9fX2lpabrpppu0e/fuk46ft+NwXHZ2ts455xzFxcUpKipKSUlJOvvss3XHHXec9H3nbTbt2LFDY8aMUZs2bRQbG6tatWrprLPO0osvvuix/RPfE++99546duyoGjVqqGPHjnr//fflcrk0ZcoUpaamqk6dOurRo4dHc//Esf766691ww03qH79+qpZs6Yuuugi/fDDD6WO5dNPP1X//v3VqFEjRUdHKykpSX/9619Lbbvk++rFF1/Ufffdp+TkZEVFRemrr77SoUOHNHToUKWlpSkxMVHR0dGqVauWOnTooAcffFD79+/3ONbjV9lKf57jx28rcLKMKOt9emKOzpgxQ2eccYaio6P12GOPuZd755131KdPH/e50bRpU91www1at25dua91eftevXq1Lr/8csXFxen000+XVP7tEbw9p315X61evVp//etf1ahRI0VFRSk+Pl6nnnqqrrnmGn377bdeHQ8AALZnAAAII2PHjjWSjCQzaNAgExMTYySZqVOnGmOMGTJkiHv+888/717vm2++MXXq1HHPO/Fx3333uZddv369iYuLM5JM8+bNTWFhoXnqqafcyw4fPrzUvk589OzZ86TH0bNnz3LXHTJkiDHGmK+++srUrl273OWuvvpq43K5jDHGbNq0qdS+n3nmGeNwOIwkc9ZZZ5mdO3f6PBaLFy92T69bt26Zy7/++usVvm5PPPFEmes2bdrU/e8ZM2a4l09JSXFPP+7pp58ut+amTZuWOj9OfKSkpBhjjJkxY4Z7WoMGDTyWmTFjRpljeeK2S9Z9/OFwOMwbb7xR5mu8adOmMrdz/JjLq7nkMmWNycGDB815551X7roNGzY069evL7Omsl7Ptm3bmqNHj5b7OpY8H8o7b08cb2OMWbFixUmP8ZZbbqlw+8fH4mTzN23aZFwul7n22mvLXaZx48Yer4cvY/Ltt9+ayMjIcre9bt26csfOl3Ewxpi33377pMseOXKk3P14k00bNmwwjRs3Lne5a6+91r29ku+JevXqmYiICI9lIyMjzYABA0pto0GDBqagoKDMsU5MTCy1fFxcnFm7dq17+alTp7oz7MRHVFSUee+999zLlnxfnfi+Xrx4sdm9e/dJx7N3796ljrWsx+LFi8vNCGPKfp+WPK9PrG3s2LHGGGPuvffecvdZu3Ztk5OTc9Jz68R9l9zP8fdiyfNi8eLFxhjvz2lf3lcHDx40jRo1KnfZadOmVXgsAABUBzRtAQBhpeQv5vfee68ZNWqUkWSaNGliDhw4UG7T9owzzjCSTEJCgvnoo4/MoUOHzJYtW0yPHj2MdKzh9uOPP7qXf/PNN93bufTSS93N4c6dO5uioiL3cif75b0iJX+RP97wKqldu3bu+ZmZmWbPnj1m+fLlJjk52T39rbfeKrOOkk3mCy+80Ozdu7dSY3FiE+3JJ580BQUF5plnnnFP69Onz0mPs7Cw0KP5/PLLL5u9e/ea999/3z2uUsVN2759+7obGGvXrjWHDx82+fn5ZuHChWbcuHEe+zyxWVHSiY2/xx9/3Ozatcts27bNbN261aumbf369c1nn31mCgoKzMMPP+ye3rRpU3eDz5em7cmmn2xMHnvsMfe0Tp06mbVr15qdO3eawYMHu6dfdtll7uVL1nTGGWeYn3/+2WzdutW0bdvWPf2rr7466et5smMrb+x/++03M2/ePLN582azf/9+U1RUZH744QdzyimnGEnG6XSa3bt3e7X9iubPnTvXPS8jI8Ns27bNHDp0yLz++uvu6VdddVWlxqTkfz68+eab5vDhw2bHjh3myy+/NA8++KDZtm3bScfNl3G48847PfZ/+PBhs23bNvPJJ5+Yf/zjH6a4uPik+6oomy6//HIjHWu4zpkzxxw4cMD89ttv5uqrr3avt2DBglLbkmQmTZpkCgsLPWqUZLKyskxBQYHp16+fe9rs2bPLHOuzzz7bbNy40fz222/miiuucE8/3izeunWrOx/OPPNMs3r1alNUVGS+/fZbd8O3cePG7uZ1yfdPVFSUyc7ONoWFhSYvL8/s3LnTHDp0yLz22mtmw4YNZu/evebw4cNm/fr1Ji0tzb3eDz/84K61rAanN2NbUdNWkhk1apT57bffzB9//GE2btxocnJy3PMuueQSk5eXZ4qKiszHH39soqOjjSTTpUuXk77eJ+67ffv2ZsWKFebAgQPu4yrrmLw9p315Xy1fvtw9bcSIEWb//v2moKDA/PjjjyYrK8ssWbKkwmMBAKA6oGkLAAgrJzZtd+zY4W4IPvroo2U2bdetW+fxC3N5jylTpnjs67bbbvOYHx8fbzZs2OCxTKCatiVrbtCggcfVjyUbsoMHDy5VR61atdz/HjBggDl06FCZ2/VmLErW2KlTJ/d29u7d655+2mmnnfQ4P/jgA/eynTt39pj3t7/9rcxGZVmNj+MNeofDYQYNGmSeeOIJs2DBAvPbb7+V2mdZjcPjSjZtL7jgglLzvWnaZmZmuqe7XC6PK2+PN0iqomnbvXt397R33nnHPX3Xrl3uKxQjIyPNwYMHS9VUcvkxY8aU2WQrj69N2yNHjpgpU6aYs846y8TFxZV59eSyZcu82n5F86+77roKz+/atWuXua2KxmT+/Pnuaeeff76ZMGGCeeuttzyuDj0ZX8ah5JXlffv2NZMnTzZvv/222bJli1f7Olk2HTx48KRXVx5/HP+rgpLbaty4sbthvHDhQvf0pk2buq/8f+GFF9zTJ02aVOZYL1q0yD19zZo17un16tUzxhgzbdo0r7Lq22+/NcZ4vn9uvPHGMsdk+vTp5rzzzjN169YtdbWwJI8r5QPVtG3VqlWphvv999/v1bH+/vvvZR5XWfv+9NNPS80v65i8Pad9eV/t2LHDREVFuY83MzPTZGdnm2+//fakV/IDAFDdcE9bAEBYS0xM1F133SVJevTRR1VQUFBqmd9++82rbe3cudPj+b333quIiD8/agcMGKAWLVr4VN/x+weWfJS8v2l5StZ8yimnuO/fK8njW8zLOrbj92aUpAsvvFAxMTEnXb4sJ46FJLVt29b971q1arn/fejQIa+3lZyc7DEvJSXFq3qkY/cu/stf/iKHw6HXX39dY8aM0eWXX67GjRtr0KBBKi4u9npbx3Xu3NnndSTPuh0Oh8dx7dixo9TypsT9QU+8b6k/Sr6eJWuqW7eu4uLi3PvbtWtXqXUr+3pWxl133aW7775bOTk5KiwsLPN+rAcPHrRkX96c4/v27Svzy6kqGpMrrrhCY8aMUc2aNfXpp5/qgQce0DXXXKNTTz1VnTt31q+//nrS/foyDrfffruuv/56RUVF6b333tN9992n/v37q1mzZrrooou0b9++Co+zPH/88YdX52FZOdCiRQt3LsbGxrqnH7+fqiSPzCnvfCp5vpb8965du1RcXOxXVpX1vn7iiSd000036fPPP9fu3bvlcrlKLVOZc/DE17Cice3UqZPH54rkfS7/8ccfXtflbbZ5e0778r5KTEzUjBkz1KhRI61fv16TJk1SRkaGunTpouTkZC1evNjr4wAAwM5o2gIAwt7dd9+t+vXra9euXXrvvfdKzW/YsKH7323atHF/e/aJj4kTJ7qXc7lcuummmzx+sZ85c6Y++ugjj22f+KVQvjjZuiVr3rp1q0dDsmTTt+Ryx5122mk65ZRTJEnDhw/Xyy+/XOby3o7FcVFRUV7VfqIGDRq4/52fn+8xb/PmzV5vJyEhQQsWLNAff/yhTz/9VDNnzlSfPn3kcrk0e/bsUl+i5o2aNWv6vI7kWbcxxuO4kpKSJEk1atRwTyv5DfHr168vc5uVOZdKvp4la9q9e7cKCwslSZGRkapXr16pdSv7elbGrFmz3P/+z3/+o6KiIhljdOaZZ5a5fEX1ePvemT17dpnnt8vl8mgsHufNmEyZMkW7du1STk6O3nrrLQ0bNkyS9N1332n8+PEnrduXcYiOjtYrr7yi3bt368svv9Rrr72mv/3tb5Kkjz/+WM8+++xJ93WyMapfv74iIyMlSXXq1HHXceLj9ddfL7Xu8fW8nV6ekudryX/Xq1dPTqfT43W89dZby30d+/TpU2rbZb2vS459VlaWDhw4IGOMBgwYUGZ9Jxu/8t7b+/btK/WFXN7UVvJYJ02aVO6xnnbaaSfddkX7KY8357Sv76vrrrtOv/76q1atWqV33nlHEydOVO3atbVt2zbdfvvtXtcGAICd0bQFAIS9uLg43XvvvZJU5tWWrVq10hlnnCFJ+vnnn3X33Xdr27ZtOnLkiDZu3KipU6eqQ4cOHo2Dhx56SJ988okk6c4771SDBg3kcrk0ePBgj1/K69ev7/735s2bS317fFm/2B6/UrbkuuvWrfO4QrZVq1buq/527typsWPHqqCgQLm5uXrqqafcy/Xr16/U8TZq1EgfffSRkpKSZIzRLbfcohkzZlR6LPx17rnnqnbt2pKk5cuXa/r06dq3b5/++9//6j//+Y/X25k2bZqmTZum7du3Ky0tTVdddZXOPfdc9/wtW7a4/318bHfu3KlffvnFoiP508svv6wvv/xSe/fu1cSJE937aNq0qdq1ayfJ84roBQsWSJK++OILzZ8/v8xtljwfVq5c6dWVkCVf//Hjx2v9+vXatWuXRo0a5b4CsHfv3h5NpmAo2dCrU6eOjh49qpdeekkrVqwoc/mSY/H999+XuprxZPP79+/v/ndmZqaWLl2qQ4cOqaCgQEuWLNGNN97obkr5aunSpZo4caJ++uknpaam6sorr9SVV17pnl/yHCyLL+Mwb948ZWVladOmTWrbtq3++te/6qKLLvJ6XyfLpho1auiSSy6RJO3du1c33nij8vLydOTIEeXn52vmzJnq3r27Pv3005Puwx9jx45VXl6efv/9d91zzz3u6b1795YkXXrppe4G4IwZM/TKK6+ooKBABw8eVG5urv75z396vP8rUnLsa9euLYfDoXfeeUfvv/9+mcuXHL8ffvjB4z/wGjZs6H5P/fTTT9q0aZOKi4t1//33V+qK/5Ln0GOPPaYFCxZo//792rdvn5YtW6aRI0eW21z2l7fntC/vq507d2r06NFaunSp4uPjdemll+qaa65R3bp1PbYJAEC1Z+W9FgAACHUn3tP2uAMHDpgmTZp43F+v5BeRffPNNyYuLu6k9+M7fm/Mjz/+2H2/w+7du5ujR4+aBQsWuJfr1auXxz0J27dvX2pbx78R/GQOHjxY5jeoH7+f6RdffGFq1qxZbr0DBgxw30OyrHssfv/996Zu3bpGkomIiDAzZ870eSxOdt/d49PLum/siUp+2U3JR8njr+ietjfddFO59UZGRpoVK1a4lz3+pWUlH8frL3lP27JeJ2/uaVvyHrYlHyXvB/v55597zDs+5iXvOVzymL/99tuTvhZljcmBAwdMt27dyh2XpKQkj3tT+nqf3fL4ek/bE+8PLcnUrFnT/QVckud9Q8s6X0pu72TzXS6XGTRo0EnP75Lnsi9j8uqrr550u88888xJx82XcZgwYcJJ9/Xee+9V+DqdLJs2btxY7nl8Yi3lvSdK5kPJ6eW9x0qOdVn7jouL8zhfn3/++TLv+1vWOVHROTx58uRS60dERJiWLVuWud68efPK3Odxf//7393TnE6nqVmzpomMjHR/cVjJZSv60kljjMnMzDzpa+HNPdPLyoiSyrqnrbfntC/vq/z8/JMu99e//rXCYwEAoDrgSlsAAHTs3ooPPvhgufPPOuss/fDDD7rjjjvUqlUrxcTEqHbt2mrdurWuvvpqZWdnq0mTJtq+fbsGDRokl8uluLg4zZo1S06nU3/5y180YsQISdLixYs9/gz61VdfVXp6uuLj432quUaNGnrrrbd09tlnu69ELencc8/VihUrlJGRoeTkZEVFRal27do655xz9Pzzz2vOnDkn/RPeDh066L///a/q1Kkjl8uloUOH6rXXXvN6LKw0evRovfDCC2rdurWioqLUqlUrPf3007rjjju83saAAQN0zTXXqGXLlqpTp46cTqcaNGigSy+9VB999JHS0tLcyz7zzDPq27evx9VyVnrooYc0YcIENWvWTNHR0TrjjDM0Z84cXXvtte5lunfvrtdee03t2rVTTEyMEhMTNXnyZPc9mE/UuXNnTZ06Va1bt1Z0dLRXdcTGxmrx4sWaPHmyOnXqpJo1ayo6OlotWrTQsGHDtGLFCrVu3dqSY/bHE088oVGjRqlJkyaqUaOGunXrpg8//FAtW7Ysc/k77rhDw4YNU9OmTUvd/7Oi+Q6HQ7NmzdKrr76qXr16qW7duoqMjFSjRo10zjnn6P7779fdd99dqePo3Lmzbr75ZrVv3979Z/x16tRR165d9dJLL2n48OGWjcOFF16o66+/Xm3atFF8fLwiIiJUt25dpaen6z//+Y8uv/zyCus9WTY1b95cubm5uueee9SuXTvVqFFDsbGxatGihfr27avnn3++3NtXWGH+/PkaOnSo6tWrp9jYWF1wwQX69NNPPc7X2267TZ999pmuuuoqNW7c2H2rj/bt2+u2227TSy+95PX+7r77bo0fP16pqamKiYlRx44d9fbbb+u8884rc/kBAwZo7NixSk1NLfPWD08++aRuvfVWNW7cWNHR0TrrrLP0ySefqHHjxr4PhqSJEydqwYIFuuyyy5SYmKjIyEglJibqzDPP1F133aVJkyZVarsV8fac9uV9VbduXY0ZM0bdunVTw4YNFRUVpRo1aqhdu3bKzMzUK6+8EpBjAQAg1DiMKeMbDAAAAAAghKSnp2vp0qWSpE2bNnncQgQAAKC64UpbAAAAAAAAAAghNG0BAAAAAAAAIIRwewQAAAAAAAAACCFcaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsE2L59+zRq1Cg1adJENWrUUFpamt544w2v1l2yZIkcDkeZj2XLlgW4cgAIDf7k6IoVK3TllVeqSZMmqlmzptq0aaPx48frwIEDAa4aAELD3r17dc8996h3795KTEyUw+HQuHHjfNqGPzkMAHbnb47yez0qKzLYBQDV3YABA5STk6PJkyfr1FNP1euvv66//e1vcrlcGjRokFfbmDhxonr16uUx7YwzzghEuQAQciqbo6tWrdK5556r0047TU8//bQaNGigTz/9VOPHj9fy5cv1zjvvVOFRAEBw/PHHH3rppZfUsWNHXXnllXr55Zd93oYVP88CgF1ZkaMSv9fDdzRtgQBauHChPvzwQ/cPtpLUq1cvbd68Wf/4xz80cOBAOZ3OCrfTunVrde3aNdDlAkDI8SdHX3/9dR06dEjz5s1Ty5YtJUkXXHCBtm3bppdeekm7d+9W3bp1q+xYACAYUlJStHv3bjkcDu3cudPnZoNVP88CgF35m6PH8Xs9fMXtERAWnn322XL/HMHhcKhmzZo6fPiw5ft9++23Vbt2bV199dUe04cOHapff/1VX3/9teX7BIBAsGOORkVFSZLi4+M9pickJCgiIkLR0dGW1wsA5QlWjh7ffmXx8yyAUGHXHAUqi6YtwkLfvn311Vdf6auvvtLUqVMlSU8++aR72rJly0r98m6M0dGjR716lGflypVq27atIiM9L2rv0KGDe743hg0bpsjISMXFxalPnz76/PPPfTl8APCbHXN0yJAhSkhI0O23366NGzdq7969WrBggV588UUNGzZMtWrVquxwAIDPgpWj/rLq51kA8Jddc/Q4fq+Hr7g9AsJCSkqKUlJSJEnfffedJOmqq65ScnJyuessXbq01P1myrNp0yalpqaWmv7HH3+oRYsWpabXq1fPPf9k4uPjNXLkSKWnp6t+/fpav369Hn/8caWnp+v9999Xnz59vKoPAPxlxxxNTU3VV199pf79+7tvjyBJI0aM0NNPP+1VXQBglWDlqL/8/XkWAKxi1xzl93pUFk1bhJ3c3FzVq1fvpMEuSZ07d1ZOTo5X22zSpEm58072ZxQV/YlFp06d1KlTJ/fzHj16qH///mrfvr3uuecewh1AUNglR/Py8tS3b181bNhQc+fOVWJior7++ms9/PDD2rdvn6ZPn+5VbQBgtarOUX/58/MsAASCnXKU3+tRWTRtEXZyc3OVlpZW4XK1a9f2ajlJpf5c7Lj69euXefXBrl27JP15hYIvEhISdPnll+uFF17QwYMHFRsb6/M2AMAfdsnR++67T4WFhcrNzXXfCuH8889XgwYNdOONN+qGG25Qz549vaoPAKxUlTnqr0D8PAsA/rJTjpaF3+vhDe5pi7BijNHKlSu9Cu2lS5cqKirKq0deXl6Z22jfvr1Wr15d6v44P/74oyTpjDPOqPRxSFzZAKDq2SlHc3Nz1a5du1L3rj3rrLMkcR9GAMFR1Tnqr0D9PAsAlWW3HC0Pv9ejIlxpi7Cya9cuHTx4UM2bN69wWSv+jKJ///6aNm2a5s2bp4EDB7qnz5w5U02aNNE555zjXeEl7N69WwsWLFBaWppq1Kjh8/oA4A875WiTJk20cuVK7du3T7Vr13ZP/+qrryRJp5xyile1AYCVqjpH/RWIn2cBwB92y9Gy8Hs9vEHTFmElJiZGUVFR+vDDD9WhQwd17NhR8fHxZS5bp04ddenSxa/9XXrppbr44ot1++23q7CwUK1atdLs2bP1wQcfaNasWXI6ne5lly5dqgsvvFAPPvigHnzwQUnSoEGD1KxZM3Xp0kUNGjTQunXr9MQTT+i3335Tdna2X7UBQGXYKUdHjRqlK6+8UhdffLHuuusuNWjQQMuWLdOkSZPUrl07XXrppX7VBgCVUdU5Kkn//e9/tX//fu3du1eStGrVKs2dO1eSdNlll6lmzZqSyv551JccBoCqYLcc5fd6VJoBwsyTTz5pmjRpYiSZNWvWBHx/e/fuNSNGjDCNGjUy0dHRpkOHDmb27Nmlllu8eLGRZMaOHeueNmnSJJOWlmbi4+ON0+k0iYmJpn///uabb74JeN0AUB475egnn3xievfubRo1amRiY2PNqaeeasaMGWN27twZ8LoBoDxVnaMpKSlGUpmPTZs2uZcrK0eN8T6HAaCq2ClH+b0eleUw5v/fRAMAAAAAAAAAEHRe3x5h/PjxHs+PX+YNAAAAAAAAALCO103bTZs2uf/NN9sBAAAAAAAAQGBwewQAAAAAAAAACCERwS4AAAAAAAAAAPAnmrYAAAAAAAAAEEJo2gIAAAAAAABACPH6i8iqA5fLpV9//VV16tThy9QA2JYxRnv37lWTJk0UEVF1//dGhgKoLshRAKi8YGWoRI4CqB68zdGwatr++uuvSk5ODnYZAGCJ/Px8nXLKKVW2PzIUQHVDjgJA5VV1hkrkKIDqpaIctbRp++mnn6pjx46Kj4+3crOWqVOnjiRp8+bNSkhICG4xAeZyufT7778rMTGxyv/3s6pxrNUTx1q+wsJCJScnuzOtqtg5Q+18Ptm1drvWLVF7MFR13eSobzivqpYd67ZjzRJ1V1awMlSyb45aKdivf6hgHI5hHOw5Bt7mqKVN2/T0dNWtW1f/93//pzFjxli5aUsc//OJuLg4xcXFBbmawHK5XDp06JDi4uJsc9JWFsdaPXGsFavqPwmzc4ba+Xyya+12rVui9mAIVt3kqHc4r6qWHeu2Y80SdfsrGLcnsGuOWilUXv9gYxyOYRzsPQYV5ailR7Np0ybNmzdPO3futHKzAAAAAAAAABA2LL3SNiUlRSkpKUpPT7dyswAAAAAAAAAQNirdtF2+fLlWr14th8Ohtm3b6swzz7SyLgAAAAAAAAAISz43bXfs2KFrr71WS5YsUUJCgowxKigoUK9evfTGG28oMTExEHUCAAAAAAAAQFjw+Z62d955pwoLC/XTTz9p165d2r17t1auXKnCwkKNGDEiEDUCAAAAAAAAQNjw+UrbDz74QB999JHatm3rntauXTs999xz6t27t6XFAQAAAAAAAEC48flKW5fLpaioqFLTo6Ki5HK5LCkKAAAAAAAAAMKVz03bCy64QCNHjtSvv/7qnvbLL7/orrvu0oUXXmhpcQAAAAAAAAAQbny+PcKzzz6rK664QqmpqUpOTpbD4dCWLVvUvn17zZo1KxA1Wm7wVdsV6TwQ7DICyuEwOqVZgbZuKZYxjmCXE1Aca/UUDsc6f1GTYJdQKXbMUDufT3at3a51S9QeDJWtmxytGuF2XgWbHeu2Y80SdUvkqB3Z9by1GuNwDOMQ3DEIdIb63LRNTk7Wd999pw8//FA///yzjDFq166dLrrookDUBwAAAAAAAABhxeem7XEXX3yxevTooZiYGDkcle9k5+XlKT09XXl5eV6vk5GRofT0dGVkZFR6vwAAAAAAAAAQiir1RWQTJkxQ06ZNVbt2bW3atEmS9MADD2j69OmWFwgAAAAAAAAA4cTnpu3DDz+s7OxsPfbYY4qOjnZPb9++vV5++WWfC3A6nUpMTHQ/P3r0qC6++GJ17NhRXbp00c0336wDBzzvVRMfH6/Y2Fif9wUAAAAAAAAAoc7n2yO88soreumll3ThhRfqtttuc0/v0KGDfv75Z58LSE5OVk5Ojvt5RESE/v3vfys5OVmSNHjwYE2fPl133nmne5msrCyvtl1UVKSioiL388LCQp/rA4BwRYYCgH/IUQDwDzkKIJz5fKXtL7/8olatWpWa7nK5dOTIEb8LMsZo6tSp6tSpk9LS0vTRRx+5b8Hgq0mTJik+Pt79ON4IBgBUjAwFAP+QowDgH3IUQDjzuWl7+umn67PPPis1fc6cOerUqZPfBc2ePVtLly7VZ599ptzcXF133XVyuVyV2lZmZqYKCgrcj/z8fL/rA4BwQYYCgH/IUQDwDzkKIJz5fHuEsWPH6vrrr9cvv/wil8ul//znP1qzZo1eeeUVLViwwO+Cdu/eraSkJNWuXVu7du3S22+/rX79+lVqWzExMYqJifG7JgAIR2QoAPiHHAUA/5CjAMKZz1fa9u3bV2+++aYWLlwoh8OhBx98UKtXr9Z7772niy++2O+CbrjhBu3fv1/t27fXoEGD1L17d7+3CQAAAAAAAAB24fOVtpLUp08f9enTx+paJEnx8fH68MMPA7JtAAAAAAAAAAh1lWraHrdv375S95uNi4vzqyAAAAAAAAAACGc+N203bdqk4cOHa8mSJTp06JB7ujFGDodDxcXFlhYYCLPmNlJCQkKwywgol8ulHTucSkpKUkSEz3fBsBWOtXoKp2O1GztmqJ3PJ7vWbte6JWoPBrvWXVl2y1G7vj7UXXXsWLNE3XZmtxy1Eq//MYzDMYxD9R4Dn5u21113nSTp3//+txo2bCiHw2F5UQAAAAAAAAAQrnxu2v7www9avny5TjvttEDUUyUGX7Vdkc4DwS4joBwOo1OaFWjrlmIZU70b6xxrxeYvahLAqhBu7Jihds4Ju9Zu17ql0K2dLK8+7JajofqeqAh1Vx071ixVXDe5G7rslqNWsuv7zWqMwzHhMg7hmsc+Xzd81llnKT8/PxC1AAAAAAAAAEDY8/lK25dfflm33XabfvnlF51xxhmKiorymN+hQwfLigMAAAAAAACAcONz0/b333/Xhg0bNHToUPc0h8NR6S8iy8vLU3p6uvLy8rxeJyMjQ+np6crIyPBpXwAAAAAAAAAQ6nxu2t54443q1KmTZs+ezReRAQAAAAAAAIDFfG7abt68We+++65atWplSQFOp1OJiYke08aPH6/XXntNNWrUUJ06dfT55597zI+Pj1dsbGyF2y4qKlJRUZH7eWFhoSU1A0A4IEMBwD/kKAD4hxwFEM58/iKyCy64QN9//71lBSQnJysnJ8f9fPfu3Ro/frxycnL0/fffa86cOaXWycrK0sCBAyvc9qRJkxQfH+9+JCcnW1Y3AFR3ZCgA+IccBQD/kKMAwpnPTdu+ffvqrrvu0rhx4zRv3jy9++67Hg9/xcXFqX379hoyZIhefPFFHT16tNLbyszMVEFBgfuRn5/vd30AEC7IUADwDzkKAP4hRwGEM59vj3DbbbdJOnYLgxNV5ovITuR0OpWTk6MvvvhCH330kTp27KgVK1YoJSXF523FxMQoJibGr3oAIFyRoQDgH3IUAPxDjgIIZz5faetyucp9+NuwlaT9+/frt99+U8+ePTV27Fg1aNBAW7Zs8Xu7AAAAAAAAAGAHPl9pG2j79u3TX//6Vx04cEBHjhzRJZdcou7duwe7LAAAAAAAAACoEpVq2i5dulRTpkzR6tWr5XA41LZtW/3jH/9Qjx49/C6oYcOGWrZsmd/bAQAAAAAAAAA78rlpO2vWLA0dOlQDBgzQiBEjZIzRl19+qQsvvFDZ2dkaNGhQIOq01Ky5jZSQkBDsMgLK5XJpxw6nkpKSFBHh810wbIVjBaqWHTPUzu8du9Zu17ole9cOe7Bbjtr1PUHdVceONUv2rRv2y1Ercd4ewzgcwzhUbz43bR955BE99thjuuuuu9zTRo4cqSeffFITJkywRdMWAAAAAAAAAEKVz234jRs3qm/fvqWm9+vXT5s2bbKkKAAAAAAAAAAIVz5faZucnKyPP/5YrVq18pj+8ccfKzk52bLCAmnwVdsV6TwQ7DICyuEwOqVZgbZuKZYxjmCXE1BWHOv8RU0srgqovuyYoXbORLvWboe6yX4Ei91y1A7v57JQd9Xxt2byGL6yW45ayY4ZEQiMwzHBGAcyu+r43LQdM2aMRowYodzcXJ177rlyOBz6/PPPlZ2draysrEDUCAAAAAAAAABhw+em7e23365GjRrpiSee0FtvvSVJatu2rd58801dccUVPheQl5en9PR05eXleb1ORkaG0tPTlZGR4fP+AAAAAAAAACCU+dy0laT+/furf//+pabn5OTorLPO8rsoAAAAAAAAAAhXPn8R2b59+3Tw4EGPabm5uerbt6+6du3qcwFOp1OJiYmSjn3JWdu2bUstM3DgQL399tvu5/Hx8YqNjfV5XwAAAAAAAAAQ6rxu2m7dulXdu3dXfHy84uPjNXr0aB04cEA33HCDzjrrLMXExOjzzz/3uYDk5GTl5ORIklq0aKF9+/Zp9+7d+u2337RhwwZJ0tdff63zzjvPvU5WVpYGDhxY4baLiopUWFjo8QAAeIcMBQD/kKMA4B9yFEA487ppe99992nfvn3KyspS9+7dlZWVpR49eigyMlJr167V3Llz1a1bN78LOvfcc/X1119rypQpGjVqlLZv367Y2Fj31bi+mDRpkrvJHB8fr+TkZL/rA4BwQYYCgH/IUQDwDzkKIJx53bRdvHixpk6dquHDh2v27Nkyxujqq6/Wv//9bzVv3tyygnr06KFly5Zpw4YNio+P18cff+xxla0vMjMzVVBQ4H7k5+dbVicAVHdkKAD4hxwFAP+QowDCmddfRLZ9+3a1bNlSktSoUSPFxsbqiiuusLygHj166Prrr9eFF16oDh066NFHH9Xdd99dqW3FxMQoJibG4goBIDyQoQDgH3IUAPxDjgIIZz59EZnT6fxzxYgI1ahRw/KC2rdvry1btuiyyy7TZZddppUrV1b6SlsAAAAAAAAAsBuvr7Q1xujCCy9UZOSxVQ4ePKi+ffsqOjraY7nvvvvOr4IiIiK0Z88e93OXy+XX9gAAAAAAAADATrxu2o4dO9bjeSBujQAAAAAAAAAA4a7STVs7mzW3kRISEoJdRkC5XC7t2OFUUlKSIiJ8uguG7YTTsQKhwI4ZauecsGvtdq0bqAp2y1G7vp+pu+rYsWbYm91y1Eq8345hHI5hHKo3XlEAAAAAAAAACCFeX2lbnQy+arsinQeCXUZAORxGpzQr0NYtxTLGEexyAsrXY52/qEkVVAVUX3bMUDtnol1rD8W6yX+ECrvlaCi+n71B3VWnMjWTyfCH3XLUSnbMiEBgHI6pynEgt6seV9oCAAAAAAAAQAihaQsAAAAAAAAAISToTdu8vDylpqaWmv70009r+/btZa6TkZGh7OzswBYGAAAAAAAAAEHgU9P26NGjevzxx3XmmWeqdu3aqlOnjs4880xNmTJFR44csbSwkzVtAQAAAAAAAKC68vqLyA4ePKiLL75YX331lS666CKdf/75Msbo559/1r333qt3331X//vf/1SjRg2fCnA6nUpMTHQ/f+GFF/TCCy/o119/1cCBAxUbG6vRo0frhhtucC8THx+v2NjYCrddVFSkoqIi9/PCwkKfagOAcEaGAoB/yFEA8A85CiCced20nTRpkvLz87VixQp16NDBY97333+vfv36afLkyRo3bpxPBSQnJysnJ8f9/LbbbtNtt92m1NRUvfnmm0pLSyu1TlZWltc1P/TQQz7VAwA4hgwFAP+QowDgH3IUQDjz+vYIb7zxhp588slSDVtJ6tixo6ZMmaLXX3/d0uL8lZmZqYKCAvcjPz8/2CUBgG2QoQDgH3IUAPxDjgIIZ15fabtlyxadffbZ5c7v2rWrtmzZYklRVomJiVFMTEywywAAWyJDAcA/5CgA+IccBRDOvL7SNi4uTjt27Ch3/vbt2xUXF2dJUZKUkJCg33//3bLtAQAAAAAAAIAdeN207dWrlyZOnFju/MmTJys9Pd2KmiRJY8aM0fDhw9W9e3e98cYblm0XAAAAAAAAAEKZ17dHGDt2rM455xx17dpVo0ePVps2bSRJq1at0lNPPaVVq1Zp2bJllhV2/fXX6/rrr7dsewAAAAAAAABgB143bdu1a6cPP/xQN910k6699lo5HA5JkjFGbdq00aJFi3T66acHrFArzZrbSAkJCcEuI6BcLpd27HAqKSlJERFeX1BtS+F0rEAosGOG2jkn7Fq7XesGqoLdctSu72fqrjp2rBn2ZrcctRLvt2MYh2MYh+rN66atdOzLxn766Sfl5uZq7dq1kqRTTz1VaWlpgagNAAAAAAAAAMKOT03b49LS0mjUAgAAAAAAAEAAeN20HT9+vMfzBx980PJiqsrgq7Yr0nkg2GUElMNhdEqzAm3dUixjHMEuR5I0f1GTYJcAwAJ2zNBQzERv2bX28urmswCwX45WtxwKdcGqm3yGndgtR61k12yzGuNwTFnjQJ5XH143bTdt2uT+9/H72QIAAAAAAAAArOV103bGjBkBKSAvL0/p6enKy8vzep2MjAylp6crIyMjIDUBAAAAAAAAQLDw1XIAAAAAAAAAEEKC3rR1Op1KTEx0P8/IyNCll16qli1batSoUUpLS9Pdd9/tsU58fLxiY2OrulQAAAAAAAAACDivb48QKMnJycrJyfGYNmTIEEnSv//9by1fvlytW7fWlClT3POzsrK82nZRUZGKiorczwsLCy2oGADCAxkKAP4hRwHAP+QogHAW9Ctty9KwYUMlJSWpUaNGcjqdMsZUajuTJk1SfHy8+5GcnGxxpQBQfZGhAOAfchQA/EOOAghnljZtK9tcPZHD4VBERIQiIiL82m5mZqYKCgrcj/z8fEvqA4BwQIYCgH/IUQDwDzkKIJz53LS9/vrrtW/fvlLT8/LydP7551tSlFViYmIUFxfn8QAAeIcMBQD/kKMA4B9yFEA487lpu2rVKrVv315ffPGFe9rMmTPVsWNHNWzY0NLiAAAAAAAAACDc+PxFZF9//bX++c9/6oILLtCYMWO0bt06ffDBB8rKytKNN97od0HZ2dnuf6enp0s6dhUvAAAAAAAAAIQDn5u2kZGRmjx5smJiYjRhwgRFRkZq6dKl6tatWyDqC4hZcxspISEh2GUElMvl0o4dTiUlJbnvDQwAVrBjhto5E+1au13rBqqC3XLUru9n6gaqL7vlqJXIiGMYh2MYh+rN51f0yJEjGjNmjB599FFlZmaqW7du6t+/vxYuXBiI+gAAAAAAAAAgrPh8pW2XLl104MABLVmyRF27dpUxRo899pgGDBigG2+8UVOnTg1EnQAAAAAAAAAQFirVtP3Xv/6lWrVqSZIcDofuvfde9enTR4MHD7a8wEAYfNV2RToPBLuMSpu/qEmwSwAQxuyYoQ6H0SnNCrR1S7GMcQS7HJ+UrP3tD5oGuxwAFrBbjto1Q4NRNz+nA1XDbjlqJbtmstWCOQ5kPaqKz03b6dOnlzk9LS1Ny5cv97sgAAAAAAAAAAhnXjVtCwsLFRcX5/73ycTExPhfFQAAAAAAAACEKa++iKxu3brasWOHJCkhIUF169Yt9Tg+3Vd5eXlKTU11P1+1apXS0tLUqFEjJSYmKi0tTd9++63HOhkZGcrOzvZ5XwAAAAAAAAAQ6ry60vaTTz5RvXr1JEmLFy8OaEHt2rVTbm6uxo0bpz179ujpp58O6P4AAAAAAAAAIJR41bTNyspSp06dFBcXp82bN2vgwIGW3QbB6XQqMTHRp3Xi4+MVGxtb4XJFRUUqKipyP6/o1g4AgD+RoQDgH3IUAPxDjgIIZ17dHmHBggXav3+/JGno0KEqKCiwrIDk5GTl5OT4tE5WVpYGDhxY4XKTJk1SfHy8+5GcnFzZMgEg7JChAOAfchQA/EOOAghnXl1p26ZNG2VmZqpXr14yxuitt95yfzHZiW644QZLC/RHZmamRo8e7X5eWFhIyAOAl8hQAPAPOQoA/iFHAYQzr5q2L7zwgkaPHq33339fDodD//znP+VwOEot53A4QqppGxMTY9ltHAAg3JChAOAfchQA/EOOAghnXjVtzz33XC1btkySFBERobVr1yopKSmghQEAAAAAAABAOPKqaVvSpk2bfP7iMF+sWrVKgwYN0vbt21VcXKwlS5bo5ZdfVpcuXQK2TwAAAAAAAAAIFT43bVNSUvTZZ5/pxRdf1IYNGzR37lw1bdpUr776qpo3b67zzjvPr4LatWun3Nxcv7YBAAAAAAAAAHblc9N23rx5uv7663XddddpxYoVKioqkiTt3btXEydO1MKFCy0v0mqz5jZSQkJCsMsAAFuyY4a6XC7t2OFUUlKSIiIigl2OT0rWDqB6sFuO2jVD7Vo3gIrZLUetRLYdwzggHPh8Zj/88MN64YUXNG3aNEVFRbmnn3vuufruu+8sLQ4AAAAAAAAAwo3PTds1a9bo/PPPLzU9Li5Oe/bssaImAAAAAAAAAAhbPt8eoXHjxlq/fr1SU1M9pn/++edq0aKFVXUF1OCrtivSeSDYZVTK/EVNgl0CgDBnxwx1OIxOaVagrVuKZYwj2OX45HjtWS9wewSgurBbjto1Q6u6bn5OB6qO3XLUSnbNZKsFaxzIelQln6+0vfXWWzVy5Eh9/fXXcjgc+vXXX/Xaa6/p7rvv1h133BGIGgEAAAAAAAAgbPjctL3nnnt05ZVXqlevXtq3b5/OP/983Xzzzbr11ls1fPhwnwvIy8vzuGp3yZIlSktLO+k6GRkZys7O9nlfAAAAAAAAABDqfLo9QnFxsT7//HONGTNG999/v1atWiWXy6V27dqpdu3agaoRAAAAAAAAAMKGT1faOp1O9enTRwUFBapZs6a6dOmis88+26+GrdPpVGJiose0gwcPauDAgWrfvr0GDhyoAwc871UTHx+v2NjYSu8TAAAAAAAAAEKVz19E1r59e23cuFHNmze3pIDk5GTl5OR4TFu3bp3mzp2r9u3b65prrtGzzz6re+65xz0/KyvLq20XFRWpqKjI/bywsNCSmgEgHJChAOAfchQA/EOOAghnPt/T9pFHHtHdd9+tBQsWaNu2bSosLPR4WKFFixZq3769JKlfv3768ssvK7WdSZMmKT4+3v1ITk62pD4ACAdkKAD4hxwFAP+QowDCmc9N20suuUTff/+9+vXrp1NOOUV169ZV3bp1lZCQoLp161pSlMPhOOlzb2VmZqqgoMD9yM/Pt6I8AAgLZCgA+IccBQD/kKMAwpnPt0dYvHhxIOrwsHHjRv300086/fTT9d5776l79+6V2k5MTIxiYmIsrg4AwgMZCgD+IUcBwD/kKIBw5nPTtmfPnoGow0OrVq300EMPafXq1WrXrp3uuOOOgO8TAAAAAAAAAEKBz01bSdq9e7emT5+u1atXy+FwqG3btho6dKjq1avnd0Hp6elas2aN39sBAAAAAAAAADvyuWm7dOlS9evXT/Hx8erSpYsk6V//+pfGjx+vd999t0quxPXXrLmNlJCQEOwyAMCW7JihLpdLO3Y4lZSUpIgIn2/nHlTHawdQfdgtR+2aoXatG0DF7JajViLbjmEcEA58btoOGzZMAwcO1PPPPy+n89gvkcXFxbrjjjs0bNgwrVy50vIiAQAAAAAAACBc+PzfERs2bNCYMWPcDVtJcjqdGj16tDZs2GBpcQAAAAAAAAAQbny+0vbMM8/U6tWrddppp3lMX716tdLS0qyqK6AGX7Vdkc4DwS7DK/MXNQl2CQDgwU4ZepzDYXRKswJt3VIsYxzBLqdCZD9QvdktR+2WoccFsm5yGgguu+WoleyayVarqnEg7xFMPjdtR4wYoZEjR2r9+vXq2rWrJGnZsmV67rnnNHnyZP3www/uZTt06GBdpQAAAAAAAAAQBnxu2v7tb3+TJN1zzz1lznM4HDLGyOFwqLi4uMLt5eXlKT09XXl5eZKkJUuWaNSoUcrNzS13nYyMDKWnpysjI8PX8gEAAAAAAAAgpPnctN20aVMg6gAAAAAAAAAAqBJN25SUFEsLcDqdSkxM9Jh29OhR3XHHHfr000/VtGlTvffee4qOjnbPj4+PV2xsrKV1AAAAAAAAAEAo8Llpa7Xk5GTl5OR4TFu7dq3eeecdPfvsszrnnHP0/vvvq3///u75WVlZXm27qKhIRUVF7ueFhYXWFA0AYYAMBQD/kKMA4B9yFEA4iwh2AWVp1aqVWrZsqYiICLVr105bt26t1HYmTZqk+Ph49yM5OdniSgGg+iJDAcA/5CgA+IccBRDOQrJpW/JWCN5+oVlZMjMzVVBQ4H7k5+dbVSIAVHtkKAD4hxwFAP+QowDCmU+3RyguLtbnn3+uDh06qG7duoGqyTIxMTGKiYkJdhkAYEtkKAD4hxwFAP+QowDCmU9X2jqdTvXp00d79uwJUDkAAAAAAAAAEN58/iKy9u3ba+PGjWrevHkg6lF6erpyc3Pdz7OzswOyHwAAAAAAAAAIRT7f0/aRRx7R3XffrQULFmjbtm0qLCz0eAAAAAAAAAAAKs/nK20vueQSSVK/fv3kcDjc040xfn1pWFWaNbeREhISgl0GANiSHTPU5XJpxw6nkpKSFBERkt/BCSCM2C1H7Zqhdq0bQMXslqNWItuOYRwQDnxu2i5evDgQdQAAAAAAAAAAVImmbc+ePQNRBwAAAAAAAABAlWjaStJnn32mF198URs3btScOXPUtGlTvfrqq2revLnOO+88q2u03OCrtivSeSDYZZQyf1GTYJcAABUK1Qw9GYfD6JRmBdq6pVjGOCpeoYqQ+0B4sluOhmqGVsSKuslpIDTZLUetZNdMtprV40DeIxT5fOOPefPmqU+fPoqNjdV3332noqIiSdLevXs1ceJEywsEAAAAAAAAgHDic9P24Ycf1gsvvKBp06YpKirKPf3cc8/Vd99953MBeXl5Sk1N9WmdjIwMZWdn+7wvAAAAAAAAAAh1Pjdt16xZo/PPP7/U9Li4OO3Zs8eKmgAAAAAAAAAgbPl8T9vGjRtr/fr1pa6O/fzzz9WiRQufC3A6nUpMTHQ/X7JkiYYPH67zzz9fn376qZo2bar33ntP0dHR7mXi4+MVGxtb4baLiorct2+QpMLCQp/rA4BwRYYCgH/IUQDwDzkKIJz5fKXtrbfeqpEjR+rrr7+Ww+HQr7/+qtdee01333237rjjDp8LSE5OVk5Ojse0tWvXasyYMfrhhx+0a9cuvf/++x7zs7KyNHDgwAq3PWnSJMXHx7sfycnJPtcHAOGKDAUA/5CjAOAfchRAOPO5aXvPPffoyiuvVK9evbRv3z6df/75uvnmm3Xrrbdq+PDhlhTVqlUrtWzZUhEREWrXrp22bt1aqe1kZmaqoKDA/cjPz7ekPgAIB2QoAPiHHAUA/5CjAMKZz7dHkKRHHnlE999/v1atWiWXy6V27dqpdu3alhVV8lYIDodDxcXFldpOTEyMYmJirCoLAMIKGQoA/iFHAcA/5CiAcObzlbY33nij9u7dq5o1a6pLly46++yzVbt2be3fv1833nhjIGoEAAAAAAAAgLDhc9N25syZOnjwYKnpBw8e1CuvvGJJUQAAAAAAAAAQrry+PUJhYaGMMTLGaO/evapRo4Z7XnFxsRYuXKikpCS/C0pPT1dubq77eXZ2tt/bBAAAAAAAAAC78Lppm5CQIIfDIYfDoVNPPbXUfIfDoYceesjS4gJl1txGSkhICHYZAGBLdsxQl8ulHTucSkpKUkSEz39kAgCWsluO2jVD7Vo3gIrZLUetRLYdwzggHHjdtF28eLGMMbrgggs0b9481atXzz0vOjpaKSkpatKkSUCKBAAAAAAAAIBw4VXTtl69elq7dq0aNGigIUOG6KKLLlKdOnUCXRsAAAAAAAAAhB2vmraHDx9WYWGhGjRooFdeeUWPPfaYrZu2g6/arkjngWCX4WH+Iq5SBmAPoZihFXE4jE5pVqCtW4pljCPY5Ugi94FwZrccDcUM9Ya/dZPTQOiyW45aya6ZbDUrx4G8R6jyqmnbrVs3XXnllercubOMMRoxYoRiY2PLXPbf//63pQUCAAAAAAAAQDjx6m7Ns2bN0mWXXaZ9+/bJ4XCooKBAu3fvLvPhq7y8PKWmprqfL1q0SGlpaapdu7bmz59f5joZGRnKzs72eV8AAAAAAAAAEOq8utK2YcOGmjx5siSpefPmevXVV1W/fv2AFNSnTx/16dNH6enpAdk+AAAAAAAAAIQyr5q2JW3atMnSApxOpxITE31aJz4+vtzbMwAAAAAAAACAnfnctJWk/fv3a+nSpdqyZYsOHz7sMW/EiBE+bSs5OVk5OTk+rZOVleXVckVFRSoqKnI/Lyws9Gk/ABDOyFAA8A85CgD+IUcBhDOfm7YrVqzQZZddpgMHDmj//v2qV6+edu7cqZo1ayopKcnnpm0gTZo0SQ899FCwywAAWyJDAcA/5CgA+IccBRDOvPoispLuuusu9e3bV7t27VJsbKyWLVumzZs3q3PnzpoyZYplhTkcDr+3kZmZqYKCAvcjPz/fgsoAIDyQoQDgH3IUAPxDjgIIZz5faZubm6sXX3xRTqdTTqdTRUVFatGihR577DENGTJEAwYMsKSwxMREvwM5JiZGMTExltQDAOGGDAUA/5CjAOAfchRAOPP5StuoqCj3VbANGzbUli1bJB37crDj/7bCvffeqxdeeEEdO3bUK6+8Ytl2AQAAAAAAACCU+XylbadOnfTtt9/q1FNPVa9evfTggw9q586devXVV9W+fXvLCuvcubN++ukny7YHAAAAAAAAAHbg85W2EydOVOPGjSVJEyZMUP369XX77bdrx44deumllywvEAAAAAAAAADCic9X2nbp0sX978TERC1cuNDSgqrCrLmNlJCQEOwyAMCW7JihLpdLO3Y4lZSUpIgIn/+/EgAsZbcctWuG2rVuABWzW45aiWw7hnFAOODMBgAAAAAAAIAQQtMWAAAAAAAAAEKIz7dHqA4GX7Vdkc4DAd/P/EVNAr4PAKhqVZWhVnI4jE5pVqCtW4pljMOSbZLxACrLbjkaiAwNJPIZqP7slqNWslsmB0rJcXj7g6bBLgcICK60BQAAAAAAAIAQYknTds+ePZVeNy8vT6mpqT6tk5GRoezs7ErvEwAAAAAAAABClc9N20cffVRvvvmm+/k111yj+vXrq2nTpvr+++8tLQ4AAAAAAAAAwo3PTdsXX3xRycnJkqQPP/xQH374of773//q0ksv1T/+8Q+fC3A6nUpMTPSY9tNPP+miiy5Sx44d1aFDBy1atMhjfnx8vGJjYyvcdlFRkQoLCz0eAADvkKEA4B9yFAD8Q44CCGc+N223bdvmbtouWLBA11xzjXr37q177rlHOTk5PheQnJzssd6RI0d0xRVXaNiwYfr++++Vk5Oj1q1be6yTlZWlgQMHVrjtSZMmKT4+3v04XjcAoGJkKAD4hxwFAP+QowDCmc9N27p16yo/P1+S9MEHH+iiiy6SJBljVFxc7HdBa9as0ZEjR9S/f39JUkxMjFq0aFGpbWVmZqqgoMD9OF43AKBiZCgA+IccBQD/kKMAwlmkrysMGDBAgwYNUuvWrfXHH3/o0ksvlSTl5uaqVatWlhTlcDgs2U5MTIxiYmIs2RYAhBsyFAD8Q44CgH/IUQDhzOcrbZ966indeeedateunT788EPVrl1b0rHbJtxxxx1+F3TaaacpMjJS77zzjiTp6NGjysvL83u7AAAAAAAAAGAHPl1pe+TIEd1yyy164IEHSt2yYNSoUZYUFBUVpXfeeUcjRozQ2LFjJUmPPvqoUlNTLdk+AAAAAAAAAIQyn5q2UVFRevvtt/XAAw8Eqh5J0umnn66PP/44oPsAAAAAAAAAgFDk8z1t+/fvr/nz52v06NGBqKdKzJrbSAkJCcEuAwBsyY4Z6nK5tGOHU0lJSYqI8PnOQABgKbvlKBkKINTYLUetRCYfU3IcgOrK56Ztq1atNGHCBH355Zfq3LmzatWq5TF/xIgRlhUHAAAAAAAAAOHG56btyy+/rISEBC1fvlzLly/3mOdwOGjaAgAAAAAAAIAffG7abtq0KRB1VKnBV21XpPOAJduav6iJJdsBALuwMkOrisNhdEqzAm3dUixjHOUuR6YDqAp2y1FvMzSQyGcAJdktR60UCpkcaGQ+cEz43gAFAAAAAAAAAEKQz1faStLWrVv17rvvasuWLTp8+LDHvCeffNKnbeXl5Sk9PV15eXler5ORkaH09HRlZGT4tC8AAAAAAAAACHU+N20//vhj9evXT82bN9eaNWt0xhlnKC8vT8YYnXnmmYGoEQAAAAAAAADChs+3R8jMzNSYMWO0cuVK1ahRQ/PmzVN+fr569uypq6++2ucCnE6nEhMT3c8feeQRjy8zW7p0qc466yyPdeLj4xUbG+vzvgAAAAAAAAAg1Pl8pe3q1as1e/bsYytHRurgwYOqXbu2xo8fryuuuEK33367T9tLTk5WTk6O+/nNN9+sjh076tFHH1VsbKxefvll3XbbbR7rZGVlebXtoqIiFRUVuZ8XFhb6VBsAhDMyFAD8Q44CgH/IUQDhzOcrbWvVquUOzSZNmmjDhg3ueTt37vS7oIYNG6pXr16aM2eOdu/erY8++kh/+9vfKrWtSZMmKT4+3v1ITk72uz4ACBdkKAD4hxwFAP+QowDCmc9N265du+qLL76QJP3lL3/RmDFj9Mgjj+jGG29U165dLSnqjjvu0EsvvaRZs2bpqquuUs2aNSu1nczMTBUUFLgf+fn5ltQHAOGADAUA/5CjAOAfchRAOPP59ghPPvmk9u3bJ0kaN26c9u3bpzfffFOtWrXSU089ZUlRPXr0UGFhoSZPnqwPPvig0tuJiYlRTEyMJTUBQLghQwHAP+QoAPiHHAUQznxu2rZo0cL975o1a2rq1KmWFnRcRkaG5s6dq/bt2wdk+wAAAAAAAAAQinxu2h53+PBh7dixQy6Xy2N6s2bN/C5Kkj755JNSX0AGAAAAAAAAANWdz/e0Xbt2rXr06KHY2FilpKSoefPmat68uVJTU9W8eXO/C/r222/VqlUr1alTR4MGDfJ7ewAAAAAAAABgJz5faTt06FBFRkZqwYIFaty4sRwOh6UFdenSRevXr7d0myeaNbeREhISAroPAKiu7JihLpdLO3Y4lZSUpIgIn/+/EgAsZbccJUMBhBq75aiVyGQgfPjctM3NzdXy5cvVpk2bQNQDAAAAAAAAAGHN5/+WadeunXbu3BmIWgAAAAAAAAAg7Hl1pW1hYaH7348++qjuueceTZw4Ue3bt1dUVJTHsnFxcdZWGACDr9quSOcBv7czf1ETC6oBAHuxKkOrksNhdEqzAm3dUixjyr6tD5kOoKrYLUe9ydBAIZsBlMVuOWqlYGZyoJH5gCevmrYJCQke9641xujCCy/0WMYYI4fDoeLiYmsrBAAAAAAAAIAw4lXTdvHixQErIC8vT+np6crLy/OYvmzZMt10002KiorSjTfeqBEjRrjnZWRkKD09XRkZGQGrCwAAAAAAAACCwaumbc+ePQNdRykzZ87U4MGDlZmZWeX7BgAAAAAAAIBg8appW9KMGTNUu3ZtXX311R7T58yZowMHDmjIkCE+bc/pdCoxMdH9/Ntvv9XNN9+sLVu2KDY2Vm+++WapK23j4+MVGxtb4baLiopUVFTkfl7y3rwAgJMjQwHAP+QoAPiHHAUQziJ8XWHy5Mlq0KBBqelJSUmaOHGizwUkJycrJyfH/bxLly7Kzc1Vv3799I9//EO5ubkeDVtJysrK0sCBAyvc9qRJkxQfH+9+JCcn+1wfAIQrMhQA/EOOAoB/yFEA4cznpu3mzZvVvHnzUtNTUlK0ZcsWS4qySmZmpgoKCtyP/Pz8YJcEALZBhgKAf8hRAPAPOQognPl8e4SkpCT98MMPSk1N9Zj+/fffq379+lbVZYmYmBjFxMQEuwwAsCUyFAD8Q44CgH/IUQDhzOcrba+99lqNGDFCixcvVnFxsYqLi/XJJ59o5MiRuvbaawNRIwAAAAAAAACEDZ+vtH344Ye1efNmXXjhhYqMPLa6y+XSDTfcUKl72gIAAAAAAAAA/uRz0zY6OlpvvvmmHn74YeXm5io2Nlbt27dXSkqKpYVlZ2dbuj0AAAAAAAAAsAOfm7bHtW7dWq1bt7aylioza24jJSQkBLsMALAlO2aoy+XSjh1OJSUlKSLC5zsDAYCl7JajZCiAUGO3HLUSmQyED97hAAAAAAAAABBCaNoCAAAAAAAAQAip9O0R7GzwVdsV6TxQ4XLzFzWpgmoAwF68zdCqRmYDsItQzdHyOBxGpzQr0NYtxTLG4dU6ZDKAQLJbjlqpMpkcKGQ9EFhcaQsAAAAAAAAAIcSvpu3u3buVk5OjrVu3VnobeXl5Sk1NLTX922+/1cCBA8tcJyMjQ9nZ2ZXeJwAAAAAAAACEKq+btv/3f/+nAweO/fnBkSNHdMstt6hBgwY655xzlJKSogEDBujQoUOWFdalSxe9+eablm0PAAAAAAAAAOzA66bto48+qn379kmSHn/8cc2fP19z5szR1q1b9c477+ibb77R448/7nMBTqdTiYmJHtMGDhyoVq1aKS0trcx14uPjFRsb6/O+AAAAAAAAACDUef1FZMYY97/nzJmjyZMna8CAAZKkJk2a6Mknn9S4ceP0wAMP+FRAcnKycnJyPKa9+eabWrJkiUaNGlXmOllZWV5tu6ioSEVFRe7nhYWFPtUGAOGMDAUA/5CjAOAfchRAOPPpnrYOx7FvJszPz9fZZ5/tMe/ss8/W5s2bravMApMmTVJ8fLz7kZycHOySAMA2yFAA8A85CgD+IUcBhDOfmrbTpk3Tv/71L8XExGj37t0e8woKChQTE2Npcf7KzMxUQUGB+5Gfnx/skgDANshQAPAPOQoA/iFHAYQzr2+P0KxZM02bNk2SFB0dre+++049evRwz1+8eLFOO+006yv0Q0xMTMg1kgHALshQAPAPOQoA/iFHAYQzr5u2eXl5J53ftWtX9ezZ0996lJubq4yMDO3bt0+//PKL0tLSdPrpp+u1117ze9sAAAAAAAAAEOq8btpWpGvXrpZsJy0tTbm5uZZsCwAAAAAAAADsxqd72p7M7t279corr1i1OQAAAAAAAAAIS5ZdabtlyxYNHTpUN9xwg1WbDJhZcxspISEh2GUAgC2RoQDgH7vlqMvl0o4dTiUlJSkiwrJrPgCg0uyWo1Yik4Hw4XXTtrCw8KTz9+7d63cxAAAAAAAAABDuvG7aJiQkyOFwlDvfGHPS+aFk8FXbFek8UOFy8xc1qYJqAMBevM3QqkReA7CTUMzRk3E4jE5pVqCtW4plTMU/75PJAALNbjlqJV8zOVDIeiDwvG7a1qlTR/fff7/OOeecMuevW7dOt956q2WFAQAAAAAAAEA48rppe+aZZ0qSevbsWeb8hIQEGWOsqQoAAAAAAAAAwpTXd60eNGiQatSoUe78Ro0aaezYsT4XkJeXp9TU1HLnX3nllcrOzvaYlpGRUWoaAAAAAAAAAFQHXl9p+/e///2k8xs2bFippi0AAAAAAAAA4E9eN23LsnXrVjVp0kQREV5fsFuK0+lUYmKi+7nL5dKdd96pTz75RC1atNCePXtKrRMfH6/Y2NgKt11UVKSioiL388LCwkrXCQDhhgwFAP+QowDgH3IUQDirfLdVUrt27ZSXl+dXAcnJycrJyXE/nzNnjlasWKEff/xR06ZN0/fff19qnaysLA0cOLDCbU+aNEnx8fHuR3Jysl+1AkA4IUMBwD/kKAD4hxwFEM78atoG4ovHvvrqK1122WWKjIxUkyZN1LVr10pvKzMzUwUFBe5Hfn6+hZUCQPVGhgKAf8hRAPAPOQognPl1e4RAcTgc7n/70xiOiYlRTEyMFSUBQNghQwHAP+QoAPiHHAUQzvy60vb//u//VK9ePatqkSR1795dCxcu1NGjR7V9+3Z98803lm4fAAAAAAAAAEKZX1fa3nfffVbV4fbXv/5VixcvVvv27ZWSkqIOHTpYvg8AAAAAAAAACFWVatpOnz5dTz31lNatWydJat26tUaNGqWbb77Z74IiIiI0depUv7cDAAAAAAAAAHbkc9P2gQce0FNPPaU777xT3bp1k3Tsy8Puuusu5eXl6eGHH7a8SKvNmttICQkJwS4DAGyJDAUA/9gtR10ul3bscCopKUkREX7dXQ0ALGG3HLUSmQyED5+bts8//7ymTZumv/3tb+5p/fr1U4cOHXTnnXfaomkLAAAAAAAAAKHK5/+WKS4uVpcuXUpN79y5s44ePWpJUQAAAAAAAAAQrnxu2g4ePFjPP/98qekvvfSSrrvuOkuKAgAAAAAAAIBwVekvIvvf//6nrl27SpKWLVum/Px83XDDDRo9erR7uSeffNKaKgEAAAAAAAAgTPjctF25cqXOPPNMSdKGDRskSYmJiUpMTNTKlSvdyzkcDotKBAAAAAAAAIDw4XPTdvHixYGoAwAAAAAAAACgStzTtqStW7fql19+saoWAAAAAAAAAAh7PjdtXS6Xxo8fr/j4eKWkpKhZs2ZKSEjQhAkT5HK5AlEjAAAAAAAAAIQNn2+PcP/992v69OmaPHmyunfvLmOMvvjiC40bN06HDh3SI488Eog6AQAAAAAAACAs+Ny0nTlzpl5++WX169fPPa1jx45q2rSp7rjjjpBu2hpjJEmFhYWKiPDrzhAhz+Vyae/evapRowbHWo1wrNWTr8daWFgo6c9Mqyp2zlA7n092rd2udUvUHgxVXTc56hvOq6plx7rtWLNE3ZUVrAwtuU+75aiVgv36hwrG4RjGwZ5j4G2O+ty03bVrl9q0aVNqeps2bbRr1y5fN1el/vjjD0lSSkpKkCsBAP/t3btX8fHxVbY/MhRAdUOOAkDlVXWGSuQogOqlohz1uWnbsWNHPfvss/rXv/7lMf3ZZ59Vx44dfa+wCtWrV0+StGXLlir/cKlqhYWFSk5OVn5+vuLi4oJdTkBxrNUTx1o+Y4z27t2rJk2aVEF1f7Jzhtr5fLJr7XatW6L2YKjquslR33BeVS071m3HmiXqrqxgZahk3xy1UrBf/1DBOBzDONhzDLzNUZ+bto899pj+8pe/6KOPPlK3bt3kcDj05ZdfKj8/XwsXLqx0wVXh+GXS8fHxtnkh/RUXF8exVkMca/Xky7EG44fU6pChdj6f7Fq7XeuWqD0YqrJuctR3nFdVy45127FmiborI1gNU7vnqJXset5ajXE4hnGw3xh4k6M+3+yhZ8+eWrt2rfr37689e/Zo165dGjBggNasWaMePXpUqlAAAAAAAAAAwDE+X2m7ZcsWJScnl/mFY1u2bFGzZs0sKQwAAAAAAAAAwpHPV9o2b95cv//+e6npf/zxh5o3b25JUYESExOjsWPHKiYmJtilBBzHWj1xrNWTXY7VLnWWhdqrnl3rlqg9GOxat6/sepzUXbXsWLcda5ao247C+diPYwyOYRyOYRyq9xg4jDHGlxUiIiL022+/KTEx0WP65s2b1a5dO+3fv9/SAgEAAAAAAAAgnHh9e4TRo0dLkhwOhx544AHVrFnTPa+4uFhff/210tLSLC8QAAAAAAAAAMKJ103bFStWSJKMMfrxxx8VHR3tnhcdHa2OHTvq7rvvtr5CAAAAAAAAAAgjPt8eYejQocrKylJcXFygagIAAAAAAACAsOVz0xYAAAAAAAAAEDgRwS7AH1OnTlXz5s1Vo0YNde7cWZ999tlJl1+6dKk6d+6sGjVqqEWLFnrhhRdKLTNv3jy1a9dOMTExateund5+++1Ale8Tq481OztbDoej1OPQoUOBPAyv+HKs27Zt06BBg3TaaacpIiJCo0aNKnO56vC6enOs1eV1/c9//qOLL75YiYmJiouLU7du3bRo0aJSy1WH19WbY7XqdQ1WZvq636qofdq0aerRo4fq1q2runXr6qKLLtI333zjscy4ceNKjXmjRo2CXru354O/42513enp6WXW/Ze//MW9TDDG3MrPkaocc2/qDtXz3MrPMyvyxR92/Vk0GJkainWX9MYbb8jhcOjKK6+0uOrA1L1nzx4NGzZMjRs3Vo0aNdS2bVstXLgw5Ot++umnddpppyk2NlbJycm66667LP851Y6/SwQj/0OFXXPUanbNZavZNeetZNfPDKvZ9TPIcsam3njjDRMVFWWmTZtmVq1aZUaOHGlq1aplNm/eXObyGzduNDVr1jQjR440q1atMtOmTTNRUVFm7ty57mW+/PJL43Q6zcSJE83q1avNxIkTTWRkpFm2bFlVHVaZAnGsM2bMMHFxcWbbtm0ej2Dz9Vg3bdpkRowYYWbOnGnS0tLMyJEjSy1TXV5Xb461uryuI0eONI8++qj55ptvzNq1a01mZqaJiooy3333nXuZ6vK6enOsVryuwcpMX/dbVbUPGjTIPPfcc2bFihVm9erVZujQoSY+Pt5s3brVvczYsWPN6aef7jHmO3bs8LruQNXuzfng77gHou4//vjDo96VK1cap9NpZsyY4V4mGGNu1edIVY+5N3WH6nlu1eeZFfniD7v+LBqsTA3Fuo/Ly8szTZs2NT169DBXXHGFZTUHqu6ioiLTpUsXc9lll5nPP//c5OXlmc8++8zk5uaGdN2zZs0yMTEx5rXXXjObNm0yixYtMo0bNzajRo0KWt2h8LtEsPI/FNg1R61m11y2ml1z3kp2/cywml0/gwLBtk3bs88+29x2220e09q0aWPuu+++Mpe/5557TJs2bTym3XrrraZr167u59dcc4255JJLPJbp06ePufbaay2qunICcawzZsww8fHxltfqL1+PtaSePXuW+UNLdXldSyrvWKvj63pcu3btzEMPPeR+Xh1f1+NOPFYrXtdgZaYV4xGI2k909OhRU6dOHTNz5kz3tLFjx5qOHTt6XWdZgpXf/o57VYz5U089ZerUqWP27dvnnhaMMS/Jn8+Rqh5zb+o+Uaic5yX583lmRb74w64/iwYrU/0VqLqPHj1qunfvbl5++WUzZMgQy3+ZD0Tdzz//vGnRooU5fPiwpbWWFIi6hw0bZi644AKPZUaPHm3OO+88i6q25+8Swcr/UGDXHLWaXXPZanbNeSvZ9TPDanb9DAoEW94e4fDhw1q+fLl69+7tMb1379768ssvy1znq6++KrV8nz599O233+rIkSMnXaa8bVaFQB2rJO3bt08pKSk65ZRTdPnll2vFihXWH4APKnOs3qgur6u3quPr6nK5tHfvXtWrV889rbq+rmUdq+Tf6xqszLRiPAKZgSUdOHBAR44cKTXu69atU5MmTdS8eXNde+212rhxo1d1B7r2k50P/o57VY359OnTde2116pWrVoe06t6zL0R6HM9kJ8JJYXKee6tQJ7n/rLrz6LBztRQrHv8+PFKTEzUTTfdZEmtVVH3u+++q27dumnYsGFq2LChzjjjDE2cOFHFxcUhXfd5552n5cuXu/9Ee+PGjVq4cKHHbXKqum5vBPJ9Gez8Dya75qjV7JrLVrNrzlvJrp8ZVrPrZ1Cg2LJpu3PnThUXF6thw4Ye0xs2bKjt27eXuc727dvLXP7o0aPauXPnSZcpb5tVIVDH2qZNG2VnZ+vdd9/V7NmzVaNGDXXv3l3r1q0LzIF4oTLH6o3q8rp6o7q+rk888YT279+va665xj2tur6uZR2rv69rsDLTivEIVO0nuu+++9S0aVNddNFF7mnnnHOOXnnlFS1atEjTpk3T9u3bde655+qPP/4Iau0VnQ/+jntVjPk333yjlStX6uabb/aYHowx90agz/VA1X2iUDnPvRHo89xfdv1ZNJiZGop1f/HFF5o+fbqmTZtmSZ1VVffGjRs1d+5cFRcXa+HChfrnP/+pJ554Qo888khI133ttddqwoQJOu+88xQVFaWWLVuqV69euu+++4JWtzcC+b4MZv4Hm11z1Gp2zWWr2TXnrWTXzwyr2fUzKFAig12APxwOh8dzY0ypaRUtf+J0X7dZVaw+1q5du6pr167u+d27d9eZZ56pZ555Rv/617+sKrtSAvEaVJfXtSLV8XWdPXu2xo0bp3feeUdJSUmWbDPQrD5Wq17XYGWmFa9TIGo/7rHHHtPs2bO1ZMkS1ahRwz390ksvdf+7ffv26tatm1q2bKmZM2dq9OjRQavd2/PB33EP5JhPnz5dZ5xxhs4++2yP6cEac6u2WdVj7otQO88rUlXnub/s+rNoMDLVClbWvXfvXg0ePFjTpk1TgwYNLK3Tmzr8GW+Xy6WkpCS99NJLcjqd6ty5s3799Vc9/vjjevDBB0O27iVLluiRRx7R1KlTdc4552j9+vUaOXKkGjdurAceeCBodQdrm1W1/UC+J61g1xy1ml1z2Wp2zXkr2fUzw2p2/Qyymi2btg0aNJDT6SzVZd+xY0ep7vpxjRo1KnP5yMhI1a9f/6TLlLfNqhCoYz1RRESEzjrrrKBekVmZY/VGdXldK8Pur+ubb76pm266SXPmzCn1v8LV7XU92bGeyNfXNViZacV5HugMnDJliiZOnKiPPvpIHTp0OGkttWrVUvv27YM+7ic68Xzwd9wDXfeBAwf0xhtvaPz48RXWUhVj7o1An+uB/kwItfO8Mqw+z/1l159FQylTg133Tz/9pLy8PPXt29c93+VySZIiIyO1Zs0atWzZMuTqlqTGjRsrKipKTqfTvUzbtm21fft2HT58WNHR0SFZ9wMPPKDrr7/e/VcW7du31/79+3XLLbfo/vvvV0SEf38EasffJUIp/6uaXXPUanbNZavZNeetZNfPDKvZ9TMoUEKzqgpER0erc+fO+vDDDz2mf/jhhzr33HPLXKdbt26llv/f//6nLl26KCoq6qTLlLfNqhCoYz2RMUa5ublq3LixNYVXQmWO1RvV5XWtDDu/rrNnz1ZGRoZef/31Mu8zU51e14qO9US+vq7BykwrzvNAZuDjjz+uCRMm6IMPPlCXLl0qrKWoqEirV68O+rif6MTzwd9xD3Tdb731loqKijR48OAKa6mKMfdGoM/1QH4mhOJ5XhlWn+f+suvPoqGUqcGuu02bNvrxxx+Vm5vrfvTr10+9evVSbm6ukpOTQ7Ju6diV5+vXr3c3HyRp7dq1aty4sSW/fAeq7gMHDpT6pdjpdMoc+3LsoNTtjUC+L0Mp/6uaXXPUanbNZavZNeetZNfPDKvZ9TMoYKz4NrNgeOONN0xUVJSZPn26WbVqlRk1apSpVauWycvLM8YYc99995nrr7/evfzGjRtNzZo1zV133WVWrVplpk+fbqKioszcuXPdy3zxxRfG6XSayZMnm9WrV5vJkyebyMhIs2zZsio/vpICcazjxo0zH3zwgdmwYYNZsWKFGTp0qImMjDRff/11lR9fSb4eqzHGrFixwqxYscJ07tzZDBo0yKxYscL89NNP7vnV5XU1puJjrS6v6+uvv24iIyPNc889Z7Zt2+Z+7Nmzx71MdXldvTlWK17XYGVmRfsNVu2PPvqoiY6ONnPnzvUY971797qXGTNmjFmyZInZuHGjWbZsmbn88stNnTp1gl67N+eDv+MeiLqPO++888zAgQPL3G8wxtwYaz5HqnrMvak7VM9zb2qvivPcX3b9WTRYmRqKdZ8oEN8qHoi6t2zZYmrXrm2GDx9u1qxZYxYsWGCSkpLMww8/HNJ1jx071tSpU8fMnj3bbNy40fzvf/8zLVu2NNdcc03Q6jYm+L9LBCv/Q4Fdc9Rqds1lq9k1561k188Mq9n1MygQbNu0NcaY5557zqSkpJjo6Ghz5plnmqVLl7rnDRkyxPTs2dNj+SVLlphOnTqZ6Ohok5qaap5//vlS25wzZ4457bTTTFRUlGnTpo2ZN29eoA/DK1Yf66hRo0yzZs1MdHS0SUxMNL179zZffvllVRxKhXw9VkmlHikpKR7LVJfXtaJjrS6va8+ePcs81iFDhnhsszq8rt4cq1Wva7Ay82T7DVbtKSkpZY772LFj3csMHDjQNG7c2ERFRZkmTZqYAQMGePxCFKzavT0f/B33QJwva9asMZLM//73vzL3Gawxt+pzpKrHvKK6Q/k8t+rzzIp88YddfxYNRqaGYt0nCtQv84Go+8svvzTnnHOOiYmJMS1atDCPPPKIOXr0aEjXfeTIETNu3DjTsmVLU6NGDZOcnGzuuOMOs3v37qDWHQq/SwQj/0OFXXPUanbNZavZNeetZNfPDKvZ9TPIag5jQvk6YAAAAAAAAAAIL7a8py0AAAAAAAAAVFc0bQEAAAAAAAAghNC0BQAAAAAAAIAQQtMWAAAAAAAAAEIITVsAAAAAAAAACCE0bQEAAAAAAAAghNC0BQAAAAAAAIAQQtMW1c6aNWvUqFEj7d27N9il+CwjI0NXXnllQLb97LPPql+/fgHZNoDqhRwtGzkKwFvkaNnIUQDeIkfLRo6GF5q2qHbuv/9+DRs2THXq1Kmyfebl5cnhcCg3N7fK9umrv//978rJydHnn38e7FIAhDhytGzkKABvkaNlI0cBeIscLRs5Gl5o2qJa2bp1q959910NHTo02KWEDGOMjh49qpiYGA0aNEjPPPNMsEsCEMLI0dLIUQC+IEdLI0cB+IIcLY0cDU80bWEb6enpGj58uIYPH66EhATVr19f//znP2WMcS/z1ltvqWPHjjrllFPc07Kzs5WQkKBFixapbdu2ql27ti655BJt27bNY/szZsxQ27ZtVaNGDbVp00ZTp051z7vxxhvVoUMHFRUVSZKOHDmizp0767rrrpMkNW/eXJLUqVMnORwOpaenl3scP/30k/7yl78oLi5OderUUY8ePbRhwwaPZaZMmaLGjRurfv36GjZsmI4cOeKeN2vWLHXp0kV16tRRo0aNNGjQIO3YscM9f8mSJXI4HFq0aJG6dOmimJgYffbZZ5Kkfv36af78+Tp48KBXYw6geiFHjyFHAVQWOXoMOQqgssjRY8hReMUANtGzZ09Tu3ZtM3LkSPPzzz+bWbNmmZo1a5qXXnrJvcwVV1xhbrvtNo/1ZsyYYaKiosxFF11kcnJyzPLly03btm3NoEGD3Mu89NJLpnHjxmbevHlm48aNZt68eaZevXomOzvbGGPM3r17TYsWLcyoUaOMMcbce++9plmzZmbPnj3GGGO++eYbI8l89NFHZtu2beaPP/4o8xi2bt1q6tWrZwYMGGBycnLMmjVrzL///W/z888/G2OMGTJkiImLizO33XabWb16tXnvvfdKHeP06dPNwoULzYYNG8xXX31lunbtai699FL3/MWLFxtJpkOHDuZ///ufWb9+vdm5c6cxxph9+/YZh8NhlixZUunXAYB9kaPHkKMAKoscPYYcBVBZ5Ogx5Ci8QdMWttGzZ0/Ttm1b43K53NPuvfde07ZtW/fzjh07mvHjx3usN2PGDCPJrF+/3j3tueeeMw0bNnQ/T05ONq+//rrHehMmTDDdunVzP//yyy9NVFSUeeCBB0xkZKRZunSpe96mTZuMJLNixYqTHkNmZqZp3ry5OXz4cJnzhwwZYlJSUszRo0fd066++mozcODAcrd5/INl7969xpg/w33+/PllLl+3bl33hxaA8EKOlo0cBeAtcrRs5CgAb5GjZSNHURZujwBb6dq1qxwOh/t5t27dtG7dOhUXF0uSDh48qBo1apRar2bNmmrZsqX7eePGjd1/evD7778rPz9fN910k2rXru1+PPzwwx5/3tCtWzfdfffdmjBhgsaMGaPzzz/f5/pzc3PVo0cPRUVFlbvM6aefLqfTWWatkrRixQpdccUVSklJUZ06ddx/srFlyxaP7XTp0qXM7cfGxurAgQM+1w6geiBHyVEA/iFHyVEA/iFHyVF4JzLYBQBWatCggXbv3l1q+olh6nA43PfMcblckqRp06bpnHPO8ViuZMi6XC598cUXcjqdWrduXaXqi42NrXCZsmo9XuP+/fvVu3dv9e7dW7NmzVJiYqK2bNmiPn366PDhwx7r1apVq8zt79q1S4mJiZWqH0D1R47+iRwFUBnk6J/IUQCVQY7+iRwNb1xpC1tZtmxZqeetW7d2h3CnTp20atUqn7bZsGFDNW3aVBs3blSrVq08HsdvRC5Jjz/+uFavXq2lS5dq0aJFmjFjhntedHS0JLn/Z7A8HTp00GeffeZxA3Jf/Pzzz9q5c6cmT56sHj16qE2bNh7/W1eRDRs26NChQ+rUqVOl9g/A/shRchSAf8hRchSAf8hRchTeoWkLW8nPz9fo0aO1Zs0azZ49W88884xGjhzpnt+nTx999dVXFYbsicaNG6dJkyYpKytLa9eu1Y8//qgZM2boySeflHTszx8efPBBTZ8+Xd27d1dWVpZGjhypjRs3SpKSkpIUGxurDz74QL/99psKCgrK3M/w4cNVWFioa6+9Vt9++63WrVunV199VWvWrPGqzmbNmik6OlrPPPOMNm7cqHfffVcTJkzw+jg/++wztWjRwuNPSgCEF3KUHAXgH3KUHAXgH3KUHIV3aNrCVm644QYdPHhQZ599toYNG6Y777xTt9xyi3v+ZZddpqioKH300Uc+bffmm2/Wyy+/rOzsbLVv3149e/ZUdna2mjdvrkOHDum6665TRkaG+vbtK0m66aabdNFFF+n6669XcXGxIiMj9a9//UsvvviimjRpoiuuuKLM/dSvX1+ffPKJ9u3bp549e6pz586aNm3aSe+FU1JiYqKys7M1Z84ctWvXTpMnT9aUKVO8Ps7Zs2fr73//u9fLA6h+yFFyFIB/yFFyFIB/yFFyFN5xmOM3AAFCXHp6utLS0vT000+fdLmpU6fqnXfe0aJFi6qmMJtYuXKlLrzwQq1du1bx8fHBLgdAEJCj/iFHAZCj/iFHAZCj/iFHwwtfRIZq55ZbbtHu3bu1d+9e1alTJ9jlhIxff/1Vr7zyCsEOoELkaNnIUQDeIkfLRo4C8BY5WjZyNLzQtEW1ExkZqfvvvz/YZYSc3r17B7sEADZBjpaNHAXgLXK0bOQoAG+Ro2UjR8MLt0cAAAAAAAAAgBDCF5EBAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAihaQsAAAAAAAAAIYSmLQAAAAAAAACEEJq2AAAAAAAAABBCaNoCAAAAAAAAQAj5fz+oOCEvyY1KAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Static panel grid: same prompt, four temperatures, same axes\n", "prompt_seed = 'O Romeo, '\n", "ids = tok.encode(prompt_seed).to(device)\n", "\n", "with torch.no_grad():\n", " gpt.eval()\n", " logits = gpt(ids.unsqueeze(0))[0, -1] # (V,)\n", "\n", "# Top-15 characters at each temperature\n", "top_n = 15\n", "fig, axes = plt.subplots(1, 4, figsize=(14, 3.6), sharey=True)\n", "for ax, tau in zip(axes, [0.5, 0.8, 1.0, 1.5]):\n", " probs = F.softmax(logits / tau, dim=-1)\n", " vals, idxs = torch.topk(probs, top_n)\n", " labels = [repr(tok.itos[i.item()]) if tok.itos[i.item()] != ' ' else \"' '\"\n", " for i in idxs]\n", " ax.barh(range(top_n), vals.numpy()[::-1], color='#4f46e5')\n", " ax.set_yticks(range(top_n))\n", " ax.set_yticklabels(labels[::-1], fontsize=8, family='monospace')\n", " ax.set_xlabel('p(next char)')\n", " ax.set_title(rf'$\\tau = {tau}$')\n", " ax.grid(axis='x', alpha=0.3)\n", "axes[0].set_ylabel(f\"top-{top_n} chars after prefix '{prompt_seed}'\")\n", "plt.suptitle(\"Next-token distribution flattens as temperature rises\",\n", " y=1.04, fontsize=12, weight='bold')\n", "plt.tight_layout(); plt.show()\n" ] }, { "cell_type": "markdown", "id": "c954fb43a", "metadata": {}, "source": [ "## 41.3 The Masked Language Modeling Objective (BERT Lineage)\n", "\n", "A causal LM commits to a fundamental asymmetry: each position predicts itself from the **left** context only. This is exactly what you want at generation time \u2014 text is produced left-to-right \u2014 but for *understanding* a sentence it is a strange constraint. When you read \"the capital of France is ___\", you do not pretend you have not yet seen \"of France\" while you predict \"Paris\". The full surrounding context resolves the ambiguity.\n", "\n", "ELMo (Peters et al. 2018) bolted bidirectionality onto an LSTM language model by training two independent LMs \u2014 one left-to-right, one right-to-left \u2014 and concatenating their hidden states. Devlin et al. observed that this still leaves each direction predicting tokens from one-sided context; *true* bidirectional context never enters the loss. Their fix was to change the objective so the model is *required* to use both directions at once.\n", "\n", "### The masked LM objective\n", "\n", "Sample a random subset $M \\subseteq \\{1, \\ldots, T\\}$ of positions to mask. Replace the tokens at those positions with a special `[MASK]` symbol \u2014 call the corrupted sequence $\\tilde{x}$. The model's job is to predict the original tokens at the masked positions from the **full** corrupted sequence:\n", "\n", "$$\n", "\\mathcal{L}_{\\text{MLM}}(\\theta)\n", "\\;=\\; -\\mathbb{E}_{x_{1:T} \\sim \\mathcal{D},\\,M} \\;\\sum_{t \\in M} \\log p_\\theta\\!\\bigl(x_t \\,\\bigm|\\, \\tilde{x}_{1:T}\\bigr).\n", "$$\n", "\n", "Three things are worth pausing on.\n", "\n", "1. **The loss is only computed at masked positions.** The model produces logits for every position (the forward pass is the same), but the cross-entropy is summed over $|M|$ tokens, not over $T$. This is a much sparser learning signal per sentence than CLM.\n", "2. **The expectation is over the choice of $M$ as well as over the corpus.** Each minibatch samples a fresh mask. The same sentence trains the model on different positions on each pass through.\n", "3. **The context $\\tilde{x}_{1:T}$ is fully bidirectional.** There is no causal mask. The model attends freely in both directions; only the *targets* are partially hidden.\n", "\n", "### The 80-10-10 corruption recipe\n", "\n", "If we *only* replaced masked tokens with the literal `[MASK]` symbol, the model would learn to recognise it as a special signal \u2014 \"look here, the answer is somewhere in the surrounding context\". But at fine-tuning and inference time `[MASK]` never appears in real input. The model would have learnt a pattern it cannot use. Devlin et al. resolve this with a three-part recipe:\n", "\n", "- Pick **15%** of the positions in the sequence uniformly at random; call this the masked set $M$.\n", "- For positions in $M$, with probability:\n", " - **80%**: replace the token with `[MASK]`.\n", " - **10%**: replace it with a *random* token from the vocabulary.\n", " - **10%**: leave it unchanged.\n", "- The cross-entropy is computed at *every* position in $M$ \u2014 even the unchanged ones \u2014 using the original token as the target.\n", "\n", "Why this exact recipe? Two reasons working together:\n", "- The 10% **random** replacement forces the encoder to keep useful representations *everywhere*, not just at `[MASK]` positions; it must distrust every token slightly and treat its representation as a denoising target.\n", "- The 10% **unchanged** replacement keeps the distribution over input tokens at training time approximately equal to the distribution at fine-tuning time. The model never sees `[MASK]` after pretraining.\n", "\n", "### Architecture choice: encoder-only\n", "\n", "A masked LM needs no decoder: there is no autoregressive generation, and the prediction at each masked position attends to all other positions in one shot. The Chapter 40 Transformer collapses to its encoder stack: bidirectional self-attention (no causal mask) plus an MLM head on top.\n", "\n", "```{admonition} Definition (masked LM loss)\n", ":class: note\n", "\n", "Let $\\tilde{x}_{1:T}$ be the corrupted sequence and $z_{t,v}$ the per-position vocabulary logits produced by the encoder $f_\\theta$. The **masked LM loss** is\n", "\n", "$$\n", "\\boxed{\\;\\mathcal{L}_{\\text{MLM}}(\\theta) \\;=\\; -\\frac{1}{|M|}\\sum_{t \\in M} \\log\\,\\mathrm{softmax}(z_t)_{x_t}.\\;}\n", "$$\n", "\n", "Note the same cross-entropy expression as $\\mathcal{L}_{\\text{CLM}}$ \u2014 the difference lives entirely in *which positions* are summed and *what mask* the attention layer uses.\n", "```\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "c112622b7", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:05:16.558966Z", "iopub.status.busy": "2026-05-20T10:05:16.558848Z", "iopub.status.idle": "2026-05-20T10:05:16.568001Z", "shell.execute_reply": "2026-05-20T10:05:16.567697Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original : First Citizen:\n", "Before we\n", "Corrupted : ws i' the _award are the\n", "Targets : ['d', 's', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', 'v', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7', '\u00b7']\n", "\n", "Masked positions in this batch: 7 / 48 tokens (14.6% \u2014 should be ~15%)\n" ] } ], "source": [ "def make_mlm_batch(data_tensor, block, batch, vocab_size, mask_token_id,\n", " mask_prob=0.15, device='cpu', rng=None):\n", " \"\"\"Sample a batch and apply the 80-10-10 corruption recipe.\n", "\n", " Returns:\n", " x_corrupted: (B, T) \u2014 input fed to the encoder\n", " targets: (B, T) \u2014 original tokens at masked positions, -100 elsewhere\n", " (so F.cross_entropy with ignore_index=-100 picks\n", " only the masked positions out automatically).\n", " \"\"\"\n", " g = rng or torch.Generator(device='cpu').manual_seed(0)\n", " ix = torch.randint(0, len(data_tensor) - block - 1, (batch,), generator=g)\n", " x = torch.stack([data_tensor[i:i + block] for i in ix]).to(device)\n", " targets = torch.full_like(x, fill_value=-100)\n", "\n", " # Pick masked positions\n", " mask = (torch.rand(x.shape, generator=g, device=device) < mask_prob)\n", "\n", " # Of those, 80% -> [MASK], 10% -> random, 10% -> unchanged\n", " rand_for_kind = torch.rand(x.shape, generator=g, device=device)\n", " is_mask = mask & (rand_for_kind < 0.80)\n", " is_random = mask & (rand_for_kind >= 0.80) & (rand_for_kind < 0.90)\n", " # is_unchanged = mask & (rand_for_kind >= 0.90) # left as-is below\n", "\n", " x_corrupted = x.clone()\n", " x_corrupted[is_mask] = mask_token_id\n", " rand_tokens = torch.randint(1, vocab_size, x.shape, generator=g, device=device)\n", " x_corrupted[is_random] = rand_tokens[is_random]\n", "\n", " # Targets only at masked positions; loss ignores -100\n", " targets[mask] = x[mask]\n", " return x_corrupted, targets\n", "\n", "\n", "# Quick sanity check\n", "xb, yb = make_mlm_batch(train_data, block=24, batch=2,\n", " vocab_size=tok.vocab_size,\n", " mask_token_id=tok.MASK_ID,\n", " device=device)\n", "print('Original :', tok.decode(train_data[:24]))\n", "print('Corrupted :', tok.decode(xb[0]).replace(tok.MASK_STR, '_'))\n", "print('Targets :', [tok.itos[t.item()] if t >= 0 else '\u00b7' for t in yb[0]])\n", "print(f'\\nMasked positions in this batch: {(yb != -100).sum().item()}'\n", " f' / {yb.numel()} tokens'\n", " f' ({(yb != -100).float().mean().item()*100:.1f}% \u2014 should be ~15%)')\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "c54d99177", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:05:16.570088Z", "iopub.status.busy": "2026-05-20T10:05:16.569902Z", "iopub.status.idle": "2026-05-20T10:06:14.065166Z", "shell.execute_reply": "2026-05-20T10:06:14.064533Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BERT-like parameters: 186,430\n", " step 0 loss=4.3505 (0.0s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 80 loss=3.1357 (3.1s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 160 loss=2.8969 (6.2s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 240 loss=2.5195 (9.2s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 320 loss=2.5112 (12.1s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 400 loss=2.2788 (15.3s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 480 loss=2.0921 (18.3s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 560 loss=1.8270 (21.4s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 640 loss=1.7781 (24.4s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 720 loss=1.6459 (27.4s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 800 loss=1.6789 (30.5s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 880 loss=1.6150 (33.6s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 960 loss=1.6696 (36.6s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 1040 loss=1.5949 (39.7s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 1120 loss=1.5764 (42.8s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 1200 loss=1.6942 (46.0s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 1280 loss=1.4785 (49.0s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 1360 loss=1.5137 (52.1s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 1440 loss=1.4454 (55.2s elapsed)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " step 1499 loss=1.3956 (57.5s elapsed)\n", "Done in 57.5s.\n" ] } ], "source": [ "class BertLike(nn.Module):\n", " \"\"\"Encoder-only Transformer (BERT-style architecture).\n", "\n", " Identical stack to GPTLike, but the attention mask is None (full\n", " bidirectional self-attention) and an MLM head sits on top of the final\n", " LayerNorm.\n", " \"\"\"\n", "\n", " def __init__(self, cfg: Config):\n", " super().__init__()\n", " self.cfg = cfg\n", " self.tok_emb = nn.Embedding(cfg.vocab_size, cfg.d_model)\n", " self.register_buffer(\n", " 'pos_emb',\n", " sinusoidal_positional_encoding(cfg.max_len, cfg.d_model),\n", " persistent=False,\n", " )\n", " self.blocks = nn.ModuleList([\n", " TransformerBlock(cfg.d_model, cfg.n_heads, cfg.d_ff, cfg.dropout)\n", " for _ in range(cfg.n_layers)\n", " ])\n", " self.ln_f = nn.LayerNorm(cfg.d_model)\n", " # MLM head: project final hidden states back to vocabulary\n", " self.mlm_head = nn.Linear(cfg.d_model, cfg.vocab_size, bias=True)\n", "\n", " def encode(self, x):\n", " \"\"\"Return the contextual hidden states (used by fine-tuning).\"\"\"\n", " B, T = x.shape\n", " h = self.tok_emb(x) + self.pos_emb[:T].unsqueeze(0)\n", " for block in self.blocks:\n", " h = block(h, mask=None) # NO causal mask \u2014 bidirectional\n", " return self.ln_f(h) # (B, T, d_model)\n", "\n", " def forward(self, x):\n", " return self.mlm_head(self.encode(x)) # (B, T, V)\n", "\n", "\n", "def train_mlm(model, data_tensor, *, steps=1500, block=48, batch=64, lr=3e-3, log_every=80):\n", " opt = torch.optim.Adam(model.parameters(), lr=lr)\n", " sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=steps)\n", " losses = []\n", " t0 = time.time()\n", " rng = torch.Generator(device='cpu').manual_seed(0)\n", " model.train()\n", " for step in range(steps):\n", " x, y = make_mlm_batch(data_tensor, block, batch,\n", " tok.vocab_size, tok.MASK_ID, device=device, rng=rng)\n", " logits = model(x)\n", " loss = F.cross_entropy(logits.reshape(-1, model.cfg.vocab_size),\n", " y.reshape(-1), ignore_index=-100)\n", " opt.zero_grad(); loss.backward()\n", " torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n", " opt.step(); sched.step()\n", " losses.append(loss.item())\n", " if step % log_every == 0 or step == steps - 1:\n", " print(f' step {step:4d} loss={loss.item():.4f} '\n", " f'({time.time() - t0:.1f}s elapsed)')\n", " print(f'Done in {time.time() - t0:.1f}s.')\n", " return losses\n", "\n", "\n", "torch.manual_seed(0); random.seed(0)\n", "bert = BertLike(cfg).to(device)\n", "print(f'BERT-like parameters: {count_params(bert):,}')\n", "bert_losses = train_mlm(bert, train_data, steps=1500, block=48, batch=64, lr=3e-3)\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "c6b3a3837", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:06:14.068494Z", "iopub.status.busy": "2026-05-20T10:06:14.068265Z", "iopub.status.idle": "2026-05-20T10:06:14.157861Z", "shell.execute_reply": "2026-05-20T10:06:14.156928Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(9, 3.5))\n", "smooth = np.convolve(bert_losses, np.ones(20) / 20, mode='valid')\n", "ax.plot(smooth, color='#0891b2', lw=2)\n", "ax.set(xlabel='step', ylabel='train loss (masked-position CE)',\n", " title=f'BERT-like MLM training (final loss = {bert_losses[-1]:.3f})')\n", "ax.grid(alpha=0.3); plt.tight_layout(); plt.show()\n" ] }, { "cell_type": "markdown", "id": "c96168787", "metadata": {}, "source": [ "**Static applet \u2014 mask-fill predictions.**\n", "Pick a sentence from the corpus, mask one character, and look at the encoder's top-$k$ predictions. The point is to show that **bidirectional context matters**: the right answer is determined by tokens both before *and* after the mask." ] }, { "cell_type": "code", "execution_count": 11, "id": "c056d2506", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:06:14.160917Z", "iopub.status.busy": "2026-05-20T10:06:14.160770Z", "iopub.status.idle": "2026-05-20T10:06:14.349690Z", "shell.execute_reply": "2026-05-20T10:06:14.349232Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "@torch.no_grad()\n", "def mask_fill(model, text, mask_pos, top_k=8):\n", " \"\"\"Replace text[mask_pos] with [MASK] and return top-k predictions.\"\"\"\n", " model.eval()\n", " ids = tok.encode(text).to(device)\n", " corrupted = ids.clone()\n", " target_char = tok.itos[ids[mask_pos].item()]\n", " corrupted[mask_pos] = tok.MASK_ID\n", " logits = model(corrupted.unsqueeze(0))[0, mask_pos]\n", " probs = F.softmax(logits, dim=-1)\n", " topv, topi = torch.topk(probs, top_k)\n", " return target_char, [(tok.itos[i.item()], v.item()) for i, v in zip(topi, topv)]\n", "\n", "\n", "# Three illustrative examples, each with the masked position highlighted\n", "examples = [\n", " ('ROMEO:\\nIs love a tender thing? it is too rough,', 18), # mask 't' in tender\n", " ('To be, or not to be, that is the question:', 14), # mask 'b' in 'be,'\n", " ('JULIET:\\nO Romeo, Romeo! wherefore art thou Rome', 38), # mask 'a' in 'art'\n", "]\n", "\n", "fig, axes = plt.subplots(1, 3, figsize=(14, 4.2))\n", "for ax, (sentence, pos) in zip(axes, examples):\n", " truth, preds = mask_fill(bert, sentence, pos)\n", " chars = [c for c, _ in preds][::-1]\n", " probs = [p for _, p in preds][::-1]\n", " colors = ['#10b981' if c == truth else '#94a3b8' for c in chars]\n", " ax.barh(range(len(chars)), probs, color=colors)\n", " ax.set_yticks(range(len(chars)))\n", " ax.set_yticklabels([repr(c) for c in chars], fontsize=9, family='monospace')\n", " ax.set_xlabel('p')\n", " # Show the corrupted sentence with the masked position underlined\n", " display = sentence[:pos] + '_' + sentence[pos + 1:]\n", " display = display.replace('\\n', ' / ')\n", " if len(display) > 50:\n", " display = display[max(0, pos - 25):pos + 25]\n", " ax.set_title(f\"...{display}...\\ntruth = {truth!r}\", fontsize=9)\n", " ax.grid(axis='x', alpha=0.3)\n", "plt.suptitle('BERT-style top-8 mask-fill predictions (green = the true token)',\n", " y=1.02, fontsize=12, weight='bold')\n", "plt.tight_layout(); plt.show()\n" ] }, { "cell_type": "markdown", "id": "cfe03cefa", "metadata": {}, "source": [ "## 41.4 Same Architecture, Different Worldview\n", "\n", "We have trained two models. Both are stacks of the exact same `TransformerBlock` from \u00a741.1, instantiated with the same hyperparameters. We trained both on the same Shakespeare corpus, for comparable wall-clock time, with the same optimiser and learning-rate schedule. The only thing that differs is the **attention mask** applied at every self-attention layer:\n", "\n", "| | Attention mask | Loss summed over |\n", "|---|---|---|\n", "| **GPT-like** | Lower-triangular (causal) | every position |\n", "| **BERT-like** | None (full bidirectional) | only the masked positions |\n", "\n", "The remainder of this section makes that contrast visible.\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "c335668bb", "metadata": { "execution": { "iopub.execute_input": "2026-05-20T10:06:14.351609Z", "iopub.status.busy": "2026-05-20T10:06:14.351492Z", "iopub.status.idle": "2026-05-20T10:06:14.615093Z", "shell.execute_reply": "2026-05-20T10:06:14.614717Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot the two attention masks side by side\n", "T_demo = 8\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 4.2))\n", "\n", "# GPT-style causal mask\n", "m_causal = torch.tril(torch.ones(T_demo, T_demo)).numpy()\n", "axes[0].imshow(m_causal, cmap='RdYlGn', vmin=0, vmax=1)\n", "axes[0].set_title(\"GPT-style: causal mask\\n(position i can only see j \u2264 i)\", fontsize=11)\n", "axes[0].set_xlabel('key position j (attended to)')\n", "axes[0].set_ylabel('query position i (attending)')\n", "axes[0].set_xticks(range(T_demo)); axes[0].set_yticks(range(T_demo))\n", "\n", "# BERT-style: no mask\n", "m_bidir = torch.ones(T_demo, T_demo).numpy()\n", "axes[1].imshow(m_bidir, cmap='RdYlGn', vmin=0, vmax=1)\n", "axes[1].set_title(\"BERT-style: no mask\\n(every position sees every other)\", fontsize=11)\n", "axes[1].set_xlabel('key position j')\n", "axes[1].set_ylabel('query position i')\n", "axes[1].set_xticks(range(T_demo)); axes[1].set_yticks(range(T_demo))\n", "\n", "# Inline the one-line code change as a text annotation\n", "fig.text(0.5, -0.04, 'The one-line code difference: '\n", " 'mask = causal_mask(T) vs mask = None',\n", " ha='center', fontsize=11, family='monospace',\n", " color='#0f172a', weight='bold')\n", "plt.suptitle('The mask matrix is the worldview', y=1.04,\n", " fontsize=13, weight='bold')\n", "plt.tight_layout(); plt.show()\n" ] }, { "cell_type": "markdown", "id": "ce54d3570", "metadata": {}, "source": [ "### What the mask *forces* about the loss\n", "\n", "Look at row $i = 3$ in each panel above.\n", "\n", "- In the GPT mask, only columns $0, 1, 2, 3$ are green. Position 3's attention output is a function of positions $0, 1, 2, 3$ only. To predict $x_4$ at the next position, the loss can only use information that is \"to the left\" of position 4. The factorisation $p(x_{1:T}) = \\prod_t p(x_t \\mid x_{" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Pretraining absorbed real structure (rates relative to a random encoder):\n", " Top-1: 58.2x over random (chance is 0.016)\n", " Top-5: 10.8x over random (chance is 0.082)\n" ] } ], "source": [ "import numpy as np\n", "\n", "labels = ['top-1 accuracy', 'top-5 accuracy']\n", "pre_vals = [acc1_pre, acc5_pre]\n", "rnd_vals = [acc1_rnd, acc5_rnd]\n", "chance_vals = [chance, 5 * chance]\n", "\n", "x = np.arange(len(labels))\n", "w = 0.28\n", "\n", "fig, ax = plt.subplots(figsize=(8, 4.2))\n", "b1 = ax.bar(x - w, pre_vals, w, color='#10b981', label='PRETRAINED encoder')\n", "b2 = ax.bar(x, rnd_vals, w, color='#ef4444', label='RANDOM-init encoder')\n", "b3 = ax.bar(x + w, chance_vals, w, color='#94a3b8', label='Uniform chance')\n", "\n", "for bars in (b1, b2, b3):\n", " for rect in bars:\n", " h = rect.get_height()\n", " ax.text(rect.get_x() + rect.get_width() / 2, h + 0.005,\n", " f'{h:.3f}', ha='center', va='bottom', fontsize=9)\n", "\n", "ax.set_xticks(x); ax.set_xticklabels(labels, fontsize=11)\n", "ax.set_ylabel('fraction of masked positions predicted correctly')\n", "ax.set_ylim(0, max(max(pre_vals), max(rnd_vals)) * 1.18)\n", "ax.set_title('Held-out mask-fill accuracy: pretraining vs random initialisation',\n", " fontsize=12, fontweight='bold')\n", "ax.legend(loc='upper left', fontsize=10)\n", "ax.grid(alpha=0.3, axis='y')\n", "plt.tight_layout(); plt.show()\n", "\n", "print('\\nPretraining absorbed real structure (rates relative to a random encoder):')\n", "print(f' Top-1: {acc1_pre / max(acc1_rnd, 1e-9):4.1f}x over random (chance is {chance:.3f})')\n", "print(f' Top-5: {acc5_pre / max(acc5_rnd, 1e-9):4.1f}x over random (chance is {5 * chance:.3f})')\n" ] }, { "cell_type": "markdown", "id": "c1c40f17f", "metadata": {}, "source": [ "The pretrained encoder predicts the right character at the masked positions far above chance; the random encoder is indistinguishable from a uniform guess. This is the *value of self-supervised pretraining as a feature extractor*, measured directly on the same objective that produced it \u2014 but on text the model has never seen.\n", "\n", "### From mask-fill to downstream tasks \u2014 how the advantage actually transfers\n", "\n", "The gap above is the gap that ULMFiT, ELMo, BERT and GPT all parlayed into the headline downstream-task wins of 2018-2019. The recipe in practice:\n", "\n", "- **Full fine-tuning.** Unfreeze every weight. Use a smaller learning rate ($\\sim 5\\times 10^{-5}$ instead of $3\\times 10^{-3}$). Train for 2-4 epochs on the labeled task. The downstream cross-entropy gradient adapts every layer\\'s features while keeping the pretrained initialisation as a strong prior.\n", "- **Linear probe.** Freeze the encoder. Train only a single Linear layer on the pooled hidden state. Cheaper, diagnostic, and the natural baseline you compare full-fine-tuning against.\n", "- **Parameter-efficient fine-tuning (modern).** Inject a small number of trainable rank-decomposed updates inside the frozen encoder. The canonical instance is **LoRA** (Hu, Shen, Wallis, Allen-Zhu, Li, Wang, Wang, Chen 2022, *LoRA: Low-Rank Adaptation of Large Language Models*, ICLR 2022, arXiv:2106.09685). At today\\'s 100B-parameter scales LoRA recovers most of the accuracy of full fine-tuning at ~0.1% of the trainable parameters.\n", "\n", "When does each make sense? **Linear probing** answers \"how good are the features?\". **Full fine-tuning** answers \"how good can I get on this task?\". **LoRA** answers \"how many tasks can I serve from one frozen backbone?\". All three rest on the fact your held-out mask-fill experiment just demonstrated: pretraining absorbs structure, and that structure stays in the weights for whatever downstream recipe needs it." ] }, { "cell_type": "markdown", "id": "ca052e3eb", "metadata": {}, "source": [ "## 41.6 Why This Worked \u2014 The Unreasonable Effectiveness of Self-Supervision\n", "\n", "We have built two pretraining objectives, watched both train, and quantified the downstream benefit. What is left is the question every student should ask: *why does any of this work?* Why should training a model to fill in missing tokens or predict next tokens produce a model that is then useful for sentiment classification, question answering, translation, dialogue?\n", "\n", "### The compression argument\n", "\n", "Schmidhuber argued, in a long line of papers running from the 1990s into the 2010s (collected and refined in his 2015 review *Deep Learning in Neural Networks: An Overview*, Neural Networks 61:85-117), that **prediction is compression and compression is understanding**. A model that can predict the next character of \"The capital of France is \" must know that 'P' is much more likely than 'X' at that position. The only way to know that is to have absorbed *something about France, capitals, and the syntactic shape of declarative sentences in English*. The arithmetic of the prediction loss forces this absorption \u2014 without it, the loss would not drop.\n", "\n", "This is a compression argument because it is the same logic that underlies Kolmogorov complexity and the minimum-description-length principle (Rissanen 1978). A model that achieves low cross-entropy is, in information-theoretic terms, **compressing** the corpus efficiently. Efficient compression of human text requires understanding human text. Hence, by the contrapositive, a model that compresses human text well must, in some operational sense, understand it.\n", "\n", "### The objective shapes the verb\n", "\n", "The point of comparing GPT and BERT \u2014 the point of the whole chapter \u2014 is that this \"understanding\" is not a single thing. The pretraining objective shapes what the model is good at:\n", "\n", "- A causal LM compresses text by **generating** it left-to-right. Its strong skill is sampling continuations.\n", "- A masked LM compresses text by **restoring** corruptions. Its strong skill is producing representations that capture the *whole* of a span.\n", "\n", "Both compress the same text. Both achieve, after enough training, low loss on their respective objectives. But the *verbs* they get good at \u2014 generate, restore \u2014 are different, and that difference cascades into every downstream task.\n", "\n", "### Forward look\n", "\n", "Everything in this chapter was demonstrated at toy scale and with a hidden simplification: a 100KB corpus, a 100K-parameter model, a 60-second training run, and a vocabulary of ~60 characters. Two consecutive chapters take both pieces apart. **Chapter 42 \u2014 Tokenizers** retires the character-level vocabulary, builds byte-pair encoding from scratch, derives WordPiece from the unigram log-likelihood, and quantifies the cascade of consequences (sequence length, embedding-table size, multilingual fairness, the arithmetic pathology) that the tokenizer choice imposes on the downstream model. **Chapter 43 \u2014 Scaling Laws and Emergent Abilities** then asks what happens when each of the remaining numbers grows by six orders of magnitude. The same two objectives still work. The same architecture still works. But qualitative behaviours appear \u2014 in-context learning, multi-step reasoning, instruction following \u2014 that no inspection of the toy version could have predicted.\n" ] }, { "cell_type": "markdown", "id": "c7b3a4bbc", "metadata": {}, "source": [ "## 41.7 Exercises\n", "\n", "**Exercise 41.1 (Conceptual).** Explain in your own words why BERT uses an encoder-only architecture but GPT uses decoder-only. What would a \"BERT with a decoder\" look like \u2014 and which famous model family is the closest historical example? Why is the pure decoder-only choice still standard for *generative* models today?\n", "\n", "**Exercise 41.2 (Derivation).** Starting from the chain rule of probability,\n", "\n", "$$\n", "p(x_{1:T}) = \\prod_{t=1}^{T} p(x_t \\mid x_{